From 5c49882b22b3a8314c6dfcc8c026456c887262fa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Mon, 9 Nov 2015 14:33:22 +0100
Subject: [PATCH 01/33] Added some classifiers for multi-label classification

---
 .../samoa/instances/MultiLabelPrediction.java |   8 +
 .../LocalMultiTargetClassifier.java           | 145 +++++++++
 .../classifiers/multilabel/meta/MTOzaBag.java | 107 +++++++
 .../multilabel/trees/ISOUPOptionTree.java     | 277 ++++++++++++++++++
 .../tasks/EvaluatePrequentialMultiTarget.java |   7 +-
 5 files changed, 542 insertions(+), 2 deletions(-)
 create mode 100644 moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
 create mode 100644 moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
 create mode 100644 moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java

diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
index d59395ce4..ea4eaf26b 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
@@ -28,6 +28,10 @@ public MultiLabelPrediction(int numOutputAttributes) {
 		for (int i=0; i<numOutputAttributes;i++)
 			prediction[i]= new DoubleVector();
 	}
+
+	public MultiLabelPrediction(DoubleVector[] prediction) {
+		this.prediction = prediction;
+	}
 	
 	@Override
 	public int numOutputAttributes() {
@@ -95,5 +99,9 @@ public boolean hasVotesForAttribute(int outputAttributeIndex) {
     public int size() {
         return prediction.length;
     }
+    
+    public DoubleVector[] getPrediction() {
+    	return prediction;
+    }
 
 }
diff --git a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
new file mode 100644
index 000000000..f28ba2e8f
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
@@ -0,0 +1,145 @@
+package moa.classifiers.multilabel;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Vector;
+
+import com.yahoo.labs.samoa.instances.Attribute;
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
+import com.yahoo.labs.samoa.instances.Prediction;
+
+import moa.classifiers.AbstractClassifier;
+import moa.classifiers.AbstractMultiLabelLearner;
+import moa.classifiers.Classifier;
+import moa.classifiers.MultiLabelClassifier;
+import moa.classifiers.MultiTargetRegressor;
+import moa.classifiers.core.splitcriteria.SplitCriterion;
+import moa.classifiers.trees.FIMTDD;
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.learners.Learner;
+import moa.options.ClassOption;
+
+public class LocalMultiTargetClassifier extends AbstractMultiLabelLearner
+		implements MultiLabelClassifier, MultiTargetRegressor {
+
+	public ClassOption classifierOption = new ClassOption(
+			"classifier",
+			'c',
+			"Classifier to use.",
+			Classifier.class,
+			"moa.classifiers.trees.FIMTDD");
+	
+	LinkedList<Classifier> classifiers = null;
+	LinkedList<InstancesHeader> headers = null;
+	
+	@Override
+	public boolean isRandomizable() {
+		// TODO Auto-generated method stub
+		return true;
+	}
+
+	private InstancesHeader getHeader(int target) {
+		if (headers == null) 
+			makeHeaders();
+		return headers.get(target);
+	
+	}
+	
+	private void makeHeaders() {
+		if (headers == null) {
+			headers = new LinkedList<InstancesHeader>();
+			for (int target = 0; target < getModelContext().numOutputAttributes(); target++) {
+				List<Attribute> attributes = new LinkedList<Attribute>();
+				List<Integer> indexValues = new LinkedList<Integer>();
+				for (int i = 0; i < getModelContext().numInputAttributes(); i++) {
+					attributes.add(getModelContext().inputAttribute(i));
+					indexValues.add(i);
+				}
+				attributes.add(getModelContext().outputAttribute(target));
+				indexValues.add(getModelContext().numInputAttributes());
+				InstancesHeader STHeader = new InstancesHeader();
+				STHeader.setAttributes(attributes, indexValues);
+				STHeader.setClassIndex(getModelContext().numInputAttributes());
+				headers.add(STHeader);
+			}
+		}
+	}
+	
+	private Instance getSTInstance(MultiLabelInstance inst, int target) {
+		double[] instanceData = new double[getModelContext().numInputAttributes() + 1];
+		for (int i = 0; i < inst.numInputAttributes(); i++)
+			instanceData[i] = inst.valueInputAttribute(i);
+		instanceData[inst.numInputAttributes()] = inst.valueOutputAttribute(target);
+		DenseInstance STInst = new DenseInstance(inst.weight(), instanceData);
+		STInst.setDataset(getHeader(target));
+		return STInst;
+	}
+	
+	@Override
+	public void trainOnInstanceImpl(MultiLabelInstance instance) {
+		// TODO Auto-generated method stub
+		initializeClassifiers();
+		
+		for (int j = 0; j < instance.numberOutputTargets(); j++) {
+			Instance STInst = getSTInstance(instance, j);
+			
+			classifiers.get(j).trainOnInstance(STInst);
+		}
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(MultiLabelInstance inst) {
+		initializeClassifiers();
+
+		MultiLabelPrediction prediction = new MultiLabelPrediction(getModelContext().numOutputAttributes());
+		for (int j = 0; j < inst.numberOutputTargets(); j++) {
+			Instance STInst = getSTInstance(inst, j);
+			
+			prediction.setVote(j, 1, classifiers.get(j).getVotesForInstance(STInst)[0]);
+		}
+		return prediction;
+	}
+
+	@Override
+	public void resetLearningImpl() {
+		classifiers = null;
+
+	}
+
+	public void initializeClassifiers() {
+		this.classifierRandom.setSeed(1234);
+		if (classifiers == null) {
+			makeHeaders();
+			classifiers = new LinkedList<Classifier>();
+			for (int i = 0; i < getModelContext().numOutputAttributes(); i++) {
+				Classifier learner = (Classifier) getPreparedClassOption(this.classifierOption);
+				classifiers.add(learner);
+				learner.resetLearning();
+				((AbstractClassifier) learner).classifierRandom = this.classifierRandom;
+				learner.setModelContext(getHeader(i));
+			}
+		}
+	}
+	
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		for (int i =0; i < getModelContext().numOutputAttributes(); i++) {
+			out.append(getModelContext().outputAttribute(i).name() + '\n');
+			((AbstractClassifier) classifiers.get(i)).getModelDescription(out, indent);
+		}
+
+	}
+
+}
+ 
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java b/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
new file mode 100644
index 000000000..e2db81e43
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
@@ -0,0 +1,107 @@
+/*
+ *    MLOzaBag.java
+ *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
+ *    @author Jesse Read (jesse@tsc.uc3m.es)
+ * 
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *    
+ */
+package moa.classifiers.multilabel.meta;
+
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
+import com.yahoo.labs.samoa.instances.Prediction;
+
+import moa.classifiers.Classifier;
+import moa.classifiers.MultiLabelLearner;
+import moa.classifiers.MultiTargetRegressor;
+import moa.classifiers.meta.OzaBag;
+import moa.core.DoubleVector;
+import moa.core.Example;
+import moa.options.ClassOption;
+
+/**
+ * OzaBag for Multi-label data.
+ * 
+ * @author Jesse Read (jesse@tsc.uc3m.es)
+ * @version $Revision: 1 $
+ */
+public class MTOzaBag extends OzaBag implements MultiLabelLearner, MultiTargetRegressor {
+
+    public MTOzaBag() {
+    	super();
+    	this.baseLearnerOption = new ClassOption("baseLearner", 'l',
+                "Classifier to train.", MultiLabelLearner.class, "multilabel.trees.ISOUPTree");
+    	}
+	
+    @Override
+    public void resetLearningImpl() {
+        this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
+        MultiLabelLearner baseLearner = (MultiLabelLearner) getPreparedClassOption(this.baseLearnerOption);
+        baseLearner.resetLearning();
+        for (int i = 0; i < this.ensemble.length; i++) {
+            this.ensemble[i] = baseLearner.copy();
+        }
+    }
+
+    @Override
+    public void setModelContext(InstancesHeader raw_header) {
+
+        //set the multilabel model context
+        this.modelContext = raw_header;
+
+        // reset ensemble
+        this.resetLearningImpl();
+
+        for (int i = 0; i < this.ensemble.length; i++) {
+            this.ensemble[i].setModelContext(raw_header);
+            this.ensemble[i].resetLearning();
+        }
+    }
+
+    @Override // @note don't need this here
+    public boolean isRandomizable() {
+        return true;
+    }
+
+	public Prediction getPredictionForInstance(MultiLabelInstance inst) {
+		DoubleVector[][] predictions = new DoubleVector[this.ensemble.length][getModelContext().numOutputAttributes()];
+		for (int i = 0; i < this.ensemble.length; i++) {
+			Prediction basePrediction = this.ensemble[i].getPredictionForInstance(inst);
+			predictions[i] = ((MultiLabelPrediction) basePrediction).getPrediction();
+		}
+		DoubleVector[] prediction = new DoubleVector[getModelContext().numOutputAttributes()];
+		for (int j = 0; j < getModelContext().numOutputAttributes(); j++) {
+			prediction[j] = new DoubleVector();
+			for (int i = 0; i < this.ensemble.length; i++) {
+				prediction[j].addValues(predictions[i][j]);
+			}
+			prediction[j].scaleValues(1.0 / this.ensemble.length);
+		}
+		return new MultiLabelPrediction(prediction);
+	}
+
+    @Override
+    public void trainOnInstanceImpl(MultiLabelInstance instance) {
+        trainOnInstanceImpl((Instance) instance);
+    }
+    
+    @Override
+	public Prediction getPredictionForInstance(Example<Instance> example) {
+		return getPredictionForInstance((MultiLabelInstance)example.getData());
+	}
+    
+}
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java
new file mode 100644
index 000000000..93de284a0
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java
@@ -0,0 +1,277 @@
+package moa.classifiers.multilabel.trees;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+
+import moa.classifiers.multilabel.trees.ISOUPTree.LeafNode;
+import moa.classifiers.multilabel.trees.ISOUPTree.Node;
+import moa.classifiers.multilabel.trees.ISOUPTree.SplitNode;
+import moa.classifiers.trees.ORTO;
+import moa.classifiers.trees.FIMTDD.InnerNode;
+import moa.classifiers.trees.ORTO.OptionNode;
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+
+public class ISOUPOptionTree extends ISOUPTree {
+
+	private static final long serialVersionUID = 1L;
+
+	private int innerNodeCount = 0;
+	private int optionNodeCount = 0;
+
+	private int numTrees = 1;
+	
+	//region ================ OPTIONS ================
+
+	public IntOption maxTreesOption = new IntOption(
+			"maxTrees",
+			'm',
+			"The maximum number of trees contained in the option tree.",
+			10, 1, Integer.MAX_VALUE);
+
+	public IntOption maxOptionLevelOption = new IntOption(
+			"maxOptionLevel",
+			'x',
+			"The maximal depth at which option nodes can be created.",
+			10, 0, Integer.MAX_VALUE);
+
+	public FloatOption optionDecayFactorOption = new FloatOption(
+			"optionDecayFactor",
+			'z',
+			"The option decay factor that determines how many options can be selected at a given level.",
+			0.9, 0.0, 1.0);
+
+	public MultiChoiceOption optionNodeAggregationOption = new MultiChoiceOption(
+			"optionNodeAggregation",
+			'o',
+			"The aggregation method used to combine predictions in option nodes.", 
+			new String[]{"average", "bestTree"}, new String[]{"Average", "Best tree"}, 0);
+
+	public FloatOption optionFadingFactorOption = new FloatOption(
+			"optionFadingFactor",
+			'q',
+			"The fading factor used for comparing subtrees of an option node.",
+			0.9995, 0.0, 1.0);
+
+	//endregion ================ OPTIONS ================
+
+	//region ================ CLASSES ================
+	
+	public static class OptionNode extends InnerNode {
+		protected AutoExpandVector<DoubleVector> optionFFSSL;
+		protected AutoExpandVector<DoubleVector> optionFFSeen;
+		
+		public OptionNode(ISOUPTree tree) {
+			super(tree);
+		}
+
+		public void resetFF() {
+			optionFFSSL = new AutoExpandVector<DoubleVector>();
+			optionFFSeen = new AutoExpandVector<DoubleVector>();
+			for (int i = 0; i < numChildren(); i++) {
+				optionFFSSL.set(i, new DoubleVector());
+				optionFFSeen.set(i, new DoubleVector());
+				for (int j = 0; j < tree.getModelContext().numOutputAttributes(); j++) {
+					optionFFSSL.get(i).setValue(j, 0.0);
+					optionFFSeen.get(i).setValue(j, 0.0);
+				}
+			}
+		}
+		
+		public int getNumSubtrees() {
+			int num = 0;
+			for (Node child : children) {
+				num += child.getNumSubtrees();
+			}
+			return num;
+		}
+		
+		public double[] getPrediction(MultiLabelInstance inst) {
+			double[][] predictions = new double[numChildren()][tree.getModelContext().numOutputAttributes()];
+			for (int i = 0; i < numChildren(); i++) {
+				predictions[i] = getChild(i).getPrediction(inst);
+			}
+			return aggregate(predictions);
+		}
+		
+		private double[] aggregate(double[][] predictions) {
+			if (((ISOUPOptionTree) tree).optionNodeAggregationOption.getChosenIndex() == 0) { // Average
+				double[] sums = new double[tree.getModelContext().numOutputAttributes()];
+				for (int j = 0; j < tree.getModelContext().numOutputAttributes(); j++) {
+					for (int i = 0; i < numChildren(); i++) {
+						sums[j] += predictions[i][j];
+					}
+					sums[j] = sums[j] / numChildren();
+				}
+				return sums;
+			} else if (((ISOUPOptionTree) tree).optionNodeAggregationOption.getChosenIndex() == 1) {
+				int d = directionForBestTree();
+				return predictions[d];
+			} else {
+				return new double[] {};
+			}
+		}
+		
+		public int directionForBestTree() {
+			int d = 0;
+			double min = Double.MAX_VALUE;
+			for (int i = 0; i < numChildren(); i++) {
+				double avg = 0.0;
+				for (int j = 0; j < tree.getModelContext().numOutputAttributes(); j++) {
+					avg += getFFRatio(i, j);
+				}
+				avg /= tree.getModelContext().numOutputAttributes();
+				if (avg < min) {
+					min = avg;
+					d = i;
+				}
+			}
+			return d;
+		}
+		
+		public double getFFRatio(int childIndex, int targetIndex) {
+			return optionFFSSL.get(childIndex).getValue(targetIndex) / optionFFSeen.get(childIndex).getValue(targetIndex); 
+		}
+		
+		protected boolean skipInLevelCount() {
+			return true;
+		}
+	}
+	
+	//endregion ================ CLASSES ================
+	
+	//region ================ METHODS ================
+	
+	public String getPurposeString() {
+		return "Implementation of the ORTO tree as described by Ikonomovska et al.";
+	}
+
+	public void resetLearningImpl() {
+		super.resetLearningImpl();
+		this.innerNodeCount = 0;
+		this.optionNodeCount = 0;
+	}
+
+	
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[]{ 
+				new Measurement("number of subtrees", this.numTrees),
+				//new Measurement("tree size (nodes)", this.leafNodeCount + this.innerNodeCount),
+				//new Measurement("tree size (leaves)", this.leafNodeCount),
+				new Measurement("number of option nodes", this.optionNodeCount),};
+	}
+	
+	@Override
+	public void processInstance(MultiLabelInstance inst, Node node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
+		if (node instanceof OptionNode) {
+			processInstanceOptionNode(inst, (OptionNode) node, prediction, normalError, growthAllowed, inAlternate);
+		} else {
+			Node currentNode = node;
+			while (true) {
+				if (currentNode instanceof LeafNode) {
+					((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
+					break;
+				} else {
+					currentNode.examplesSeen += inst.weight();
+//					if (!inAlternate && iNode.alternateTree != null) {
+//						boolean altTree = true;
+//						double lossO = Math.pow(inst.classValue() - prediction, 2);
+//						double lossA = Math.pow(inst.classValue() - currentNode.alternateTree.getPrediction(inst), 2);
+//						
+//						iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
+//						iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
+//						iNode.lossExamplesSeen++;
+//						
+//						double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
+//						double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+//						iNode.lossSumQi += Qi;
+//						iNode.lossNumQiTests += 1;
+//						double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+//						
+//						if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
+//							iNode.previousWeight = iNode.lossExamplesSeen;
+//							if (Qi > 0) {
+//								// Switch the subtrees
+//								Node parent = currentNode.parent;
+//								
+//								if (parent != null) {
+//									Node replacementTree = iNode.alternateTree;
+//									parent.setChild(parent.getChildIndex(iNode), replacementTree);
+//									if (growthAllowed) replacementTree.restartChangeDetection();
+//								} else {
+//									treeRoot = iNode.alternateTree;
+//									treeRoot.restartChangeDetection();
+//								}
+//								optionNodeCount += currentNode.alternateTree.getNumSubtrees() - currentNode.getNumSubtrees();
+//								removeExcessTrees();
+//										
+//								currentNode = iNode.alternateTree;
+//								currentNode.originalNode = null;
+//								altTree = false;
+//							} else if (QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * alternateTreeTMinOption.getValue()) || iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()) {
+//								// Remove the alternate tree
+//								iNode.alternateTree = null;
+//								if (growthAllowed) iNode.restartChangeDetection();
+//								altTree = false;
+//							}
+//						}
+//						if (altTree) {
+//							growthAllowed = false; // this is the growth of the original tree
+//							processInstance(inst, currentNode.alternateTree, prediction, normalError, true, true); // growth is allowed in the alt tree
+//						} else if (currentNode instanceof OptionNode) {
+//							// this happens when an option node is switched into the tree
+//							for (Node child : ((OptionNode) currentNode).children) {
+//								processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed, inAlternate);
+//							}
+//							break;
+//						}
+//					}
+				
+//					if (iNode.changeDetection && !inAlternate) {
+//						if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+//							iNode.initializeAlternateTree();
+//						}
+//					}
+					if (currentNode instanceof SplitNode) {
+						currentNode = ((SplitNode) currentNode).getChild(((SplitNode) currentNode).instanceChildIndex(inst));
+					} else if (currentNode instanceof OptionNode) {
+						processInstanceOptionNode(inst, (OptionNode) currentNode, prediction, normalError, growthAllowed, inAlternate);
+						break;
+					}
+				}
+			}
+		}
+		
+	}
+	
+	public void processInstanceOptionNode(MultiLabelInstance inst, OptionNode node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
+//		if (node.changeDetection) {
+//			double error = Math.abs(prediction - inst.classValue());
+//			node.sumOfAbsErrors += error;
+//			
+//			if (((InnerNode) node).PageHinckleyTest(error - node.sumOfAbsErrors / node.examplesSeen + PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+//				node.initializeAlternateTree();
+//			}
+//		}
+
+		for (Node child : node.children) {
+			int i = node.getChildIndex(child);
+			double[] childPrediction = child.getPrediction(inst);
+			for (int j = 0; j < getModelContext().numOutputAttributes(); j++)  {
+				node.optionFFSeen.get(i).setValue(j, node.optionFFSeen.get(i).getValue(j) * optionFadingFactorOption.getValue() + 1);
+				node.optionFFSSL.get(i).setValue(j, node.optionFFSSL.get(i).getValue(j) * optionFadingFactorOption.getValue() + Math.pow(childPrediction[j] - inst.valueOutputAttribute(j), 2));
+			}
+		}
+
+		for (Node child : node.children) {
+			processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed && node.alternateTree == null, inAlternate);
+		}
+	}
+	
+	//endregion ================ METHODS ================
+
+}
diff --git a/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java b/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
index eba9b70b5..55ee5302d 100644
--- a/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
+++ b/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
@@ -202,8 +202,11 @@ protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
             Prediction prediction = learner.getPredictionForInstance(testInst);
             // Output prediction
             if (outputPredictionFile != null) {
-                double trueClass = ((Instance) trainInst.getData()).classValue();
-                outputPredictionResultStream.println(prediction + "," + trueClass);
+            	StringBuilder sb = new StringBuilder();
+            	for (int i = 0; i < ((Instance) trainInst.getData()).numOutputAttributes(); i++) {
+            		sb.append("Out " + i + ": " + ((Instance) trainInst.getData()).valueOutputAttribute(i) + " ");
+            	}
+                outputPredictionResultStream.println(prediction + "," + sb.toString());
             }
 
             //evaluator.addClassificationAttempt(trueClass, prediction, testInst.weight());

From 6715ccf4064e5ee5a910ca567c6f091f6a8ff461 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Mon, 9 Nov 2015 14:43:19 +0100
Subject: [PATCH 02/33] Updates to multi-label methods

---
 .../samoa/instances/MultiLabelPrediction.java |    8 +
 .../NumericAttributeBinaryTest.java           |    2 +-
 .../LocalMultiTargetClassifier.java           |  145 ++
 .../splitcriteria/ICVarianceReduction.java    |  113 +
 .../classifiers/multilabel/meta/MTOzaBag.java |  125 ++
 .../multilabel/trees/ISOUPOptionTree.java     |  277 +++
 .../multilabel/trees/ISOUPTree.java           | 1515 +++++++++++++
 .../java/moa/classifiers/trees/FIMTDD.java    | 1912 +++++++++--------
 .../main/java/moa/classifiers/trees/ORTO.java | 1838 +++++-----------
 9 files changed, 3673 insertions(+), 2262 deletions(-)
 create mode 100644 moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
 create mode 100644 moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java
 create mode 100644 moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
 create mode 100644 moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java
 create mode 100644 moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java

diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
index d59395ce4..7e821ce9f 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
@@ -29,6 +29,10 @@ public MultiLabelPrediction(int numOutputAttributes) {
 			prediction[i]= new DoubleVector();
 	}
 	
+	public MultiLabelPrediction(DoubleVector[] prediction) {
+		this.prediction = prediction;
+	}
+	
 	@Override
 	public int numOutputAttributes() {
 		return prediction.length;
@@ -95,5 +99,9 @@ public boolean hasVotesForAttribute(int outputAttributeIndex) {
     public int size() {
         return prediction.length;
     }
+    
+    public DoubleVector[] getPrediction() {
+    	return prediction;
+    }
 
 }
diff --git a/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java b/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
index 1b67102b9..87a3f2e0e 100644
--- a/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
+++ b/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
@@ -52,7 +52,7 @@ public int branchForInstance(Instance inst) {
         if (inst.isMissing(instAttIndex)) {
             return -1;
         }
-        double v = inst.value(instAttIndex);
+        double v = inst.valueInputAttribute(instAttIndex);
         if (v == this.attValue) {
             return this.equalsPassesTest ? 0 : 1;
         }
diff --git a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
new file mode 100644
index 000000000..6d79d6dab
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
@@ -0,0 +1,145 @@
+package moa.classifiers.multilabel;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Vector;
+
+import com.yahoo.labs.samoa.instances.Attribute;
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
+import com.yahoo.labs.samoa.instances.Prediction;
+
+import moa.classifiers.AbstractClassifier;
+import moa.classifiers.AbstractMultiLabelLearner;
+import moa.classifiers.Classifier;
+import moa.classifiers.MultiLabelClassifier;
+import moa.classifiers.MultiTargetRegressor;
+import moa.classifiers.core.splitcriteria.SplitCriterion;
+import moa.classifiers.trees.FIMTDD;
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.learners.Learner;
+import moa.options.ClassOption;
+
+public class LocalMultiTargetClassifier extends AbstractMultiLabelLearner
+		implements MultiLabelClassifier, MultiTargetRegressor {
+
+	public ClassOption classifierOption = new ClassOption(
+			"classifier",
+			'c',
+			"Classifier to use.",
+			Classifier.class,
+			"moa.classifiers.trees.FIMTDD");
+	
+	ArrayList<Classifier> classifiers = null;
+	ArrayList<InstancesHeader> headers = null;
+	
+	@Override
+	public boolean isRandomizable() {
+		// TODO Auto-generated method stub
+		return true;
+	}
+
+	private InstancesHeader getHeader(int target) {
+		if (headers == null) 
+			makeHeaders();
+		return headers.get(target);
+	
+	}
+	
+	private void makeHeaders() {
+		if (headers == null) {
+			headers = new ArrayList<InstancesHeader>();
+			for (int target = 0; target < getModelContext().numOutputAttributes(); target++) {
+				List<Attribute> attributes = new LinkedList<Attribute>();
+				List<Integer> indexValues = new LinkedList<Integer>();
+				for (int i = 0; i < getModelContext().numInputAttributes(); i++) {
+					attributes.add(getModelContext().inputAttribute(i));
+					indexValues.add(i);
+				}
+				attributes.add(getModelContext().outputAttribute(target));
+				indexValues.add(getModelContext().numInputAttributes());
+				InstancesHeader STHeader = new InstancesHeader();
+				STHeader.setAttributes(attributes, indexValues);
+				STHeader.setClassIndex(getModelContext().numInputAttributes());
+				headers.add(STHeader);
+			}
+		}
+	}
+	
+	private Instance getSTInstance(MultiLabelInstance inst, int target) {
+		double[] instanceData = new double[getModelContext().numInputAttributes() + 1];
+		for (int i = 0; i < inst.numInputAttributes(); i++)
+			instanceData[i] = inst.valueInputAttribute(i);
+		instanceData[inst.numInputAttributes()] = inst.valueOutputAttribute(target);
+		DenseInstance STInst = new DenseInstance(inst.weight(), instanceData);
+		STInst.setDataset(getHeader(target));
+		return STInst;
+	}
+	
+	@Override
+	public void trainOnInstanceImpl(MultiLabelInstance instance) {
+		// TODO Auto-generated method stub
+		initializeClassifiers();
+		
+		for (int j = 0; j < instance.numberOutputTargets(); j++) {
+			Instance STInst = getSTInstance(instance, j);
+			
+			classifiers.get(j).trainOnInstance(STInst);
+		}
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(MultiLabelInstance inst) {
+		initializeClassifiers();
+
+		MultiLabelPrediction prediction = new MultiLabelPrediction(getModelContext().numOutputAttributes());
+		for (int j = 0; j < inst.numberOutputTargets(); j++) {
+			Instance STInst = getSTInstance(inst, j);
+			prediction.setVote(j, 1, classifiers.get(j).getVotesForInstance(STInst)[0]);
+		}
+		return prediction;
+	}
+
+	@Override
+	public void resetLearningImpl() {
+		classifiers = null;
+
+	}
+
+	public void initializeClassifiers() {
+		this.classifierRandom.setSeed(1234);
+		if (classifiers == null) {
+			makeHeaders();
+			classifiers = new ArrayList<Classifier>();
+			for (int i = 0; i < getModelContext().numOutputAttributes(); i++) {
+				Classifier learner = ((Classifier) getPreparedClassOption(this.classifierOption)).copy();
+				classifiers.add(learner);
+				learner.resetLearning();
+				((AbstractClassifier) learner).classifierRandom = this.classifierRandom;
+				learner.setModelContext(getHeader(i));
+			}
+		}
+	}
+	
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		for (int i =0; i < getModelContext().numOutputAttributes(); i++) {
+			out.append(getModelContext().outputAttribute(i).name() + '\n');
+			((AbstractClassifier) classifiers.get(i)).getModelDescription(out, indent);
+		}
+
+	}
+
+}
+ 
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java b/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java
new file mode 100644
index 000000000..c3f2299d2
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java
@@ -0,0 +1,113 @@
+package moa.classifiers.multilabel.core.splitcriteria;
+
+import moa.classifiers.rules.core.Utils;
+import moa.core.DoubleVector;
+import moa.core.ObjectRepository;
+import moa.options.AbstractOptionHandler;
+import moa.tasks.TaskMonitor;
+import moa.classifiers.rules.multilabel.core.splitcriteria.MultiLabelSplitCriterion;;
+
+
+
+public class ICVarianceReduction extends AbstractOptionHandler implements MultiLabelSplitCriterion {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public double getMeritOfSplit(DoubleVector[] preSplitDist, DoubleVector[][] postSplitDists) {
+		double error=0;
+		int numOutputs=preSplitDist.length;
+		for (int i=0; i<numOutputs; i++)
+			error+=getMeritOfSplitForOutput(preSplitDist,postSplitDists,i);
+		return error/numOutputs;
+	}
+	
+	public double[] getBranchSplitVarianceOutput(DoubleVector[] postSplitDists) {
+		double[] variances = new double[postSplitDists.length];
+		for(int i = 0; i < postSplitDists.length; i++)
+			variances[i]=computeVariance(postSplitDists[i]);
+		return variances;
+
+	}
+	
+	private double computeVariance(double n, double sum, double squares) {
+		if (n > 1) {
+			return (squares - sum * sum / n) / (n - 1);
+		}
+		return 0;
+	}
+	
+	private double computeVariance(DoubleVector v) {
+		return computeVariance(v.getValue(0), v.getValue(1), v.getValue(2));
+	}
+
+	@Override
+	public double [] getBranchesSplitMerits(DoubleVector[][] postSplitDists){
+		int numOutputs=postSplitDists.length;
+		int numBranches=postSplitDists[0].length;
+		double [] merits=new double[numBranches];
+			for(int j=0; j<numOutputs;j++)
+			{
+				double [] branchMeritsOutput=getBranchSplitVarianceOutput(postSplitDists[j]);
+				
+				for (int i=0; i<numBranches;i++){
+					if (postSplitDists[j][i].getValue(0)>0)
+						merits[i]-=branchMeritsOutput[i];
+					else
+						merits[i]=Double.MIN_VALUE;
+				}
+			}
+		return merits;
+	}
+	
+	protected double getMeritOfSplitForOutput(DoubleVector[] preSplitDist, DoubleVector[][] postSplitDists, int outputAttributeIndex){
+		return getMeritOfSplitForOutput(preSplitDist[outputAttributeIndex],postSplitDists[outputAttributeIndex]);
+	}
+
+	protected double getMeritOfSplitForOutput(DoubleVector preSplitDist, DoubleVector[] postSplitDists) {
+		double merit=0;
+		//count number of branches with weightSeen higher than threshold
+		int count = 0; 
+		for(int i = 0; i < postSplitDists.length; i++)
+			if(postSplitDists[i].getValue(0) >=0.05*preSplitDist.getValue(0))
+				count = count +1;
+		//Consider split if all branches have required weight seen
+		if(count == postSplitDists.length){
+			double varPreSplit=computeVariance(preSplitDist);
+			double sumVarPostSplit=0;
+			double weightTotal=0;
+			for (int i=0; i<postSplitDists.length;i++){
+				weightTotal+=postSplitDists[i].getValue(0);
+			}
+			double [] variances=getBranchSplitVarianceOutput(postSplitDists);
+			for(int i = 0; i < variances.length; i++)
+				if(postSplitDists[i].getValue(0)>0)
+					sumVarPostSplit+=(postSplitDists[i].getValue(0)/weightTotal*variances[i]);  //weight variance
+			merit= 1 - sumVarPostSplit / varPreSplit;
+		}
+		/*if(merit<0 || merit>1)
+			System.out.println("out of range");*/
+		return merit;
+	}
+
+	public double getRangeOfMerit(DoubleVector [] preSplitDist) {
+		return 1;
+	}
+
+
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor,
+			ObjectRepository repository) {		
+	}
+
+
+}
diff --git a/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java b/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
new file mode 100644
index 000000000..2594f61be
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
@@ -0,0 +1,125 @@
+/*
+ *    MLOzaBag.java
+ *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
+ *    @author Jesse Read (jesse@tsc.uc3m.es)
+ * 
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *    
+ */
+package moa.classifiers.multilabel.meta;
+
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
+import com.yahoo.labs.samoa.instances.Prediction;
+
+import moa.classifiers.Classifier;
+import moa.classifiers.MultiLabelLearner;
+import moa.classifiers.MultiTargetRegressor;
+import moa.classifiers.meta.OzaBag;
+import moa.core.DoubleVector;
+import moa.core.Example;
+import moa.options.ClassOption;
+
+/**
+ * OzaBag for Multi-label data.
+ * 
+ * @author Jesse Read (jesse@tsc.uc3m.es)
+ * @version $Revision: 1 $
+ */
+public class MTOzaBag extends OzaBag implements MultiLabelLearner, MultiTargetRegressor {
+
+    public MTOzaBag() {
+    	super();
+    	this.baseLearnerOption = new ClassOption("baseLearner", 'l',
+                "Classifier to train.", MultiLabelLearner.class, "multilabel.trees.ISOUPTree");
+    	}
+	
+    @Override
+    public void resetLearningImpl() {
+        this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
+        MultiLabelLearner baseLearner = (MultiLabelLearner) getPreparedClassOption(this.baseLearnerOption);
+        baseLearner.resetLearning();
+        for (int i = 0; i < this.ensemble.length; i++) {
+            this.ensemble[i] = baseLearner.copy();
+        }
+    }
+
+    @Override
+    public void setModelContext(InstancesHeader raw_header) {
+
+        //set the multilabel model context
+        this.modelContext = raw_header;
+
+        // reset ensemble
+        this.resetLearningImpl();
+
+        for (int i = 0; i < this.ensemble.length; i++) {
+            this.ensemble[i].setModelContext(raw_header);
+            this.ensemble[i].resetLearning();
+        }
+    }
+
+    @Override // @note don't need this here
+    public boolean isRandomizable() {
+        return true;
+    }
+
+	public Prediction getPredictionForInstance(MultiLabelInstance inst) {
+		DoubleVector[][] predictions = new DoubleVector[this.ensemble.length][getModelContext().numOutputAttributes()];
+		for (int i = 0; i < this.ensemble.length; i++) {
+			Prediction basePrediction = this.ensemble[i].getPredictionForInstance(inst);
+			predictions[i] = ((MultiLabelPrediction) basePrediction).getPrediction();
+		}
+		DoubleVector[] prediction = new DoubleVector[getModelContext().numOutputAttributes()];
+		for (int j = 0; j < getModelContext().numOutputAttributes(); j++) {
+			prediction[j] = new DoubleVector();
+			for (int i = 0; i < this.ensemble.length; i++) {
+				prediction[j].addValues(predictions[i][j]);
+			}
+			prediction[j].scaleValues(1.0 / this.ensemble.length);
+		}
+		return new MultiLabelPrediction(prediction);
+	}
+	
+	public Prediction getPredictionForInstanceUsingN(MultiLabelInstance inst, int n) {
+		int actual = Math.max(1, Math.min(n, this.ensemble.length));
+		DoubleVector[][] predictions = new DoubleVector[actual][getModelContext().numOutputAttributes()];
+		for (int i = 0; i < actual; i++) {
+			Prediction basePrediction = this.ensemble[i].getPredictionForInstance(inst);
+			predictions[i] = ((MultiLabelPrediction) basePrediction).getPrediction();
+		}
+		DoubleVector[] prediction = new DoubleVector[getModelContext().numOutputAttributes()];
+		for (int j = 0; j < getModelContext().numOutputAttributes(); j++) {
+			prediction[j] = new DoubleVector();
+			for (int i = 0; i < actual; i++) {
+				prediction[j].addValues(predictions[i][j]);
+			}
+			prediction[j].scaleValues(1.0 / actual);
+		}
+		return new MultiLabelPrediction(prediction);
+	}
+
+    @Override
+    public void trainOnInstanceImpl(MultiLabelInstance instance) {
+        trainOnInstanceImpl((Instance) instance);
+    }
+    
+    @Override
+	public Prediction getPredictionForInstance(Example<Instance> example) {
+		return getPredictionForInstance((MultiLabelInstance)example.getData());
+	}
+    
+}
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java
new file mode 100644
index 000000000..93de284a0
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java
@@ -0,0 +1,277 @@
+package moa.classifiers.multilabel.trees;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+
+import moa.classifiers.multilabel.trees.ISOUPTree.LeafNode;
+import moa.classifiers.multilabel.trees.ISOUPTree.Node;
+import moa.classifiers.multilabel.trees.ISOUPTree.SplitNode;
+import moa.classifiers.trees.ORTO;
+import moa.classifiers.trees.FIMTDD.InnerNode;
+import moa.classifiers.trees.ORTO.OptionNode;
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+
+public class ISOUPOptionTree extends ISOUPTree {
+
+	private static final long serialVersionUID = 1L;
+
+	private int innerNodeCount = 0;
+	private int optionNodeCount = 0;
+
+	private int numTrees = 1;
+	
+	//region ================ OPTIONS ================
+
+	public IntOption maxTreesOption = new IntOption(
+			"maxTrees",
+			'm',
+			"The maximum number of trees contained in the option tree.",
+			10, 1, Integer.MAX_VALUE);
+
+	public IntOption maxOptionLevelOption = new IntOption(
+			"maxOptionLevel",
+			'x',
+			"The maximal depth at which option nodes can be created.",
+			10, 0, Integer.MAX_VALUE);
+
+	public FloatOption optionDecayFactorOption = new FloatOption(
+			"optionDecayFactor",
+			'z',
+			"The option decay factor that determines how many options can be selected at a given level.",
+			0.9, 0.0, 1.0);
+
+	public MultiChoiceOption optionNodeAggregationOption = new MultiChoiceOption(
+			"optionNodeAggregation",
+			'o',
+			"The aggregation method used to combine predictions in option nodes.", 
+			new String[]{"average", "bestTree"}, new String[]{"Average", "Best tree"}, 0);
+
+	public FloatOption optionFadingFactorOption = new FloatOption(
+			"optionFadingFactor",
+			'q',
+			"The fading factor used for comparing subtrees of an option node.",
+			0.9995, 0.0, 1.0);
+
+	//endregion ================ OPTIONS ================
+
+	//region ================ CLASSES ================
+	
+	public static class OptionNode extends InnerNode {
+		protected AutoExpandVector<DoubleVector> optionFFSSL;
+		protected AutoExpandVector<DoubleVector> optionFFSeen;
+		
+		public OptionNode(ISOUPTree tree) {
+			super(tree);
+		}
+
+		public void resetFF() {
+			optionFFSSL = new AutoExpandVector<DoubleVector>();
+			optionFFSeen = new AutoExpandVector<DoubleVector>();
+			for (int i = 0; i < numChildren(); i++) {
+				optionFFSSL.set(i, new DoubleVector());
+				optionFFSeen.set(i, new DoubleVector());
+				for (int j = 0; j < tree.getModelContext().numOutputAttributes(); j++) {
+					optionFFSSL.get(i).setValue(j, 0.0);
+					optionFFSeen.get(i).setValue(j, 0.0);
+				}
+			}
+		}
+		
+		public int getNumSubtrees() {
+			int num = 0;
+			for (Node child : children) {
+				num += child.getNumSubtrees();
+			}
+			return num;
+		}
+		
+		public double[] getPrediction(MultiLabelInstance inst) {
+			double[][] predictions = new double[numChildren()][tree.getModelContext().numOutputAttributes()];
+			for (int i = 0; i < numChildren(); i++) {
+				predictions[i] = getChild(i).getPrediction(inst);
+			}
+			return aggregate(predictions);
+		}
+		
+		private double[] aggregate(double[][] predictions) {
+			if (((ISOUPOptionTree) tree).optionNodeAggregationOption.getChosenIndex() == 0) { // Average
+				double[] sums = new double[tree.getModelContext().numOutputAttributes()];
+				for (int j = 0; j < tree.getModelContext().numOutputAttributes(); j++) {
+					for (int i = 0; i < numChildren(); i++) {
+						sums[j] += predictions[i][j];
+					}
+					sums[j] = sums[j] / numChildren();
+				}
+				return sums;
+			} else if (((ISOUPOptionTree) tree).optionNodeAggregationOption.getChosenIndex() == 1) {
+				int d = directionForBestTree();
+				return predictions[d];
+			} else {
+				return new double[] {};
+			}
+		}
+		
+		public int directionForBestTree() {
+			int d = 0;
+			double min = Double.MAX_VALUE;
+			for (int i = 0; i < numChildren(); i++) {
+				double avg = 0.0;
+				for (int j = 0; j < tree.getModelContext().numOutputAttributes(); j++) {
+					avg += getFFRatio(i, j);
+				}
+				avg /= tree.getModelContext().numOutputAttributes();
+				if (avg < min) {
+					min = avg;
+					d = i;
+				}
+			}
+			return d;
+		}
+		
+		public double getFFRatio(int childIndex, int targetIndex) {
+			return optionFFSSL.get(childIndex).getValue(targetIndex) / optionFFSeen.get(childIndex).getValue(targetIndex); 
+		}
+		
+		protected boolean skipInLevelCount() {
+			return true;
+		}
+	}
+	
+	//endregion ================ CLASSES ================
+	
+	//region ================ METHODS ================
+	
+	public String getPurposeString() {
+		return "Implementation of the ORTO tree as described by Ikonomovska et al.";
+	}
+
+	public void resetLearningImpl() {
+		super.resetLearningImpl();
+		this.innerNodeCount = 0;
+		this.optionNodeCount = 0;
+	}
+
+	
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[]{ 
+				new Measurement("number of subtrees", this.numTrees),
+				//new Measurement("tree size (nodes)", this.leafNodeCount + this.innerNodeCount),
+				//new Measurement("tree size (leaves)", this.leafNodeCount),
+				new Measurement("number of option nodes", this.optionNodeCount),};
+	}
+	
+	@Override
+	public void processInstance(MultiLabelInstance inst, Node node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
+		if (node instanceof OptionNode) {
+			processInstanceOptionNode(inst, (OptionNode) node, prediction, normalError, growthAllowed, inAlternate);
+		} else {
+			Node currentNode = node;
+			while (true) {
+				if (currentNode instanceof LeafNode) {
+					((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
+					break;
+				} else {
+					currentNode.examplesSeen += inst.weight();
+//					if (!inAlternate && iNode.alternateTree != null) {
+//						boolean altTree = true;
+//						double lossO = Math.pow(inst.classValue() - prediction, 2);
+//						double lossA = Math.pow(inst.classValue() - currentNode.alternateTree.getPrediction(inst), 2);
+//						
+//						iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
+//						iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
+//						iNode.lossExamplesSeen++;
+//						
+//						double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
+//						double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+//						iNode.lossSumQi += Qi;
+//						iNode.lossNumQiTests += 1;
+//						double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+//						
+//						if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
+//							iNode.previousWeight = iNode.lossExamplesSeen;
+//							if (Qi > 0) {
+//								// Switch the subtrees
+//								Node parent = currentNode.parent;
+//								
+//								if (parent != null) {
+//									Node replacementTree = iNode.alternateTree;
+//									parent.setChild(parent.getChildIndex(iNode), replacementTree);
+//									if (growthAllowed) replacementTree.restartChangeDetection();
+//								} else {
+//									treeRoot = iNode.alternateTree;
+//									treeRoot.restartChangeDetection();
+//								}
+//								optionNodeCount += currentNode.alternateTree.getNumSubtrees() - currentNode.getNumSubtrees();
+//								removeExcessTrees();
+//										
+//								currentNode = iNode.alternateTree;
+//								currentNode.originalNode = null;
+//								altTree = false;
+//							} else if (QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * alternateTreeTMinOption.getValue()) || iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()) {
+//								// Remove the alternate tree
+//								iNode.alternateTree = null;
+//								if (growthAllowed) iNode.restartChangeDetection();
+//								altTree = false;
+//							}
+//						}
+//						if (altTree) {
+//							growthAllowed = false; // this is the growth of the original tree
+//							processInstance(inst, currentNode.alternateTree, prediction, normalError, true, true); // growth is allowed in the alt tree
+//						} else if (currentNode instanceof OptionNode) {
+//							// this happens when an option node is switched into the tree
+//							for (Node child : ((OptionNode) currentNode).children) {
+//								processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed, inAlternate);
+//							}
+//							break;
+//						}
+//					}
+				
+//					if (iNode.changeDetection && !inAlternate) {
+//						if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+//							iNode.initializeAlternateTree();
+//						}
+//					}
+					if (currentNode instanceof SplitNode) {
+						currentNode = ((SplitNode) currentNode).getChild(((SplitNode) currentNode).instanceChildIndex(inst));
+					} else if (currentNode instanceof OptionNode) {
+						processInstanceOptionNode(inst, (OptionNode) currentNode, prediction, normalError, growthAllowed, inAlternate);
+						break;
+					}
+				}
+			}
+		}
+		
+	}
+	
+	public void processInstanceOptionNode(MultiLabelInstance inst, OptionNode node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
+//		if (node.changeDetection) {
+//			double error = Math.abs(prediction - inst.classValue());
+//			node.sumOfAbsErrors += error;
+//			
+//			if (((InnerNode) node).PageHinckleyTest(error - node.sumOfAbsErrors / node.examplesSeen + PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+//				node.initializeAlternateTree();
+//			}
+//		}
+
+		for (Node child : node.children) {
+			int i = node.getChildIndex(child);
+			double[] childPrediction = child.getPrediction(inst);
+			for (int j = 0; j < getModelContext().numOutputAttributes(); j++)  {
+				node.optionFFSeen.get(i).setValue(j, node.optionFFSeen.get(i).getValue(j) * optionFadingFactorOption.getValue() + 1);
+				node.optionFFSSL.get(i).setValue(j, node.optionFFSSL.get(i).getValue(j) * optionFadingFactorOption.getValue() + Math.pow(childPrediction[j] - inst.valueOutputAttribute(j), 2));
+			}
+		}
+
+		for (Node child : node.children) {
+			processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed && node.alternateTree == null, inAlternate);
+		}
+	}
+	
+	//endregion ================ METHODS ================
+
+}
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
new file mode 100644
index 000000000..bc01e6471
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
@@ -0,0 +1,1515 @@
+/*
+ *    FIMTDDMultilabel.java
+ *    Copyright (C) 2014 Jožef Stefan Institute, Ljubljana, Slovenia
+ *    @author Aljaž Osojnik <aljaz.osojnik@ijs.si>
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *    
+ *    
+ */
+
+/* Project MAESTRA (Learning from Massive, Incompletely annotated, and Structured Data) 
+ *
+ * Contact: saso.dzeroski@ijs.si
+ */
+
+package moa.classifiers.multilabel.trees;
+
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Attribute;
+import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
+import com.yahoo.labs.samoa.instances.Prediction;
+
+import moa.AbstractMOAObject;
+import moa.classifiers.AbstractMultiLabelLearner;
+import moa.classifiers.MultiTargetRegressor;
+import moa.classifiers.multilabel.core.splitcriteria.ICVarianceReduction;
+import moa.classifiers.rules.core.Predicate;
+import moa.classifiers.rules.multilabel.attributeclassobservers.AttributeStatisticsObserver;
+import moa.classifiers.rules.multilabel.attributeclassobservers.MultiLabelBSTree;
+import moa.classifiers.rules.multilabel.attributeclassobservers.MultiLabelNominalAttributeObserver;
+import moa.classifiers.rules.multilabel.attributeclassobservers.NominalStatisticsObserver;
+import moa.classifiers.rules.multilabel.attributeclassobservers.NumericStatisticsObserver;
+import moa.classifiers.rules.multilabel.core.AttributeExpansionSuggestion;
+import moa.classifiers.rules.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.SizeOf;
+import moa.core.StringUtils;
+
+/**
+ * iSOUPTrees class for structured output prediction.
+ *
+ * @author Aljaž Osojnik (aljaz.osojnik@ijs.si)
+ * @version $Revision: 1 $
+ */
+public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetRegressor {
+
+	private static final long serialVersionUID = 1L;
+
+	public Node treeRoot;
+
+	private int leafNodeCount = 0;
+	private int splitNodeCount = 0;
+
+	private double examplesSeen = 0.0;
+	private DoubleVector sumOfValues = new DoubleVector();
+	private DoubleVector sumOfSquares = new DoubleVector();
+
+	private DoubleVector sumOfAttrValues = new DoubleVector();
+	private DoubleVector sumOfAttrSquares = new DoubleVector();
+
+	public int maxID = 0;
+
+	//region ================ OPTIONS ================
+
+	//	public ClassOption splitCriterionOption = new ClassOption(
+	//			"splitCriterion",
+	//			's',
+	//			"Split criterion to use.",
+	//			SplitCriterion.class,
+	//			"moa.classifiers.core.splitcriteria.VarianceReductionSplitCriterion");
+	// TODO not used at the moment, consider later when the implementation catches up	
+
+	public IntOption gracePeriodOption = new IntOption(
+			"gracePeriod",
+			'g',
+			"The number of instances a leaf should observe between split attempts.",
+			200, 0, Integer.MAX_VALUE);
+
+	public FloatOption splitConfidenceOption = new FloatOption(
+			"splitConfidence",
+			'c',
+			"The allowable error in split decision, values closer to 0 will take longer to decide.",
+			0.0000001, 0.0, 1.0);
+
+	public FloatOption tieThresholdOption = new FloatOption(
+			"tieThreshold",
+			't',
+			"Threshold below which a split will be forced to break ties.",
+			0.05, 0.0, 1.0);
+
+	public FloatOption PageHinckleyAlphaOption = new FloatOption(
+			"PageHinckleyAlpha",
+			'a',
+			"The alpha value to use in the Page Hinckley change detection tests.",
+			0.005, 0.0, 1.0);
+
+	public IntOption PageHinckleyThresholdOption = new IntOption(
+			"PageHinckleyThreshold",
+			'h',
+			"The threshold value to be used in the Page Hinckley change detection tests.",
+			50, 0, Integer.MAX_VALUE);
+
+	public FloatOption alternateTreeFadingFactorOption = new FloatOption(
+			"alternateTreeFadingFactor",
+			'f',
+			"The fading factor to use when deciding if an alternate tree should replace an original.",
+			0.995, 0.0, 1.0);
+
+	public IntOption alternateTreeTMinOption = new IntOption(
+			"alternateTreeTMin",
+			'y',
+			"The Tmin value to use when deciding if an alternate tree should replace an original.",
+			150, 0, Integer.MAX_VALUE);
+
+	public IntOption alternateTreeTimeOption = new IntOption(
+			"alternateTreeTime",
+			'u',
+			"The 'time' (in terms of number of instances) value to use when deciding if an alternate tree should be discarded.",
+			1500, 0, Integer.MAX_VALUE);
+
+	public FlagOption regressionTreeOption = new FlagOption(
+			"regressionTree",
+			'r',
+			"Build a regression tree instead of a model tree.");
+
+	public FloatOption learningRatioOption = new FloatOption(
+			"learningRatio", 
+			'l',
+			"Learning ratio to use for training the Perceptrons in the leaves.",
+			0.02);
+
+	public FloatOption learningRateDecayFactorOption = new FloatOption(
+			"learningRatioDecayFactor",
+			'd',
+			"Learning rate decay factor (not used when learning rate is constant).",
+			0.001);
+
+	public FlagOption learningRatioConstOption = new FlagOption(
+			"learningRatioConst",
+			'o',
+			"Keep learning rate constant instead of decaying (if kept constant learning ratio is suggested to be 0.001).");
+
+	public FlagOption doNotNormalizeOption = new FlagOption(
+			"doNotNormalize",
+			'n',
+			"Don't normalize.");
+	
+	public FlagOption printLogsOption = new FlagOption(
+			"printLogs",
+			'z',
+			"Print logs.");
+
+
+	//endregion ================ OPTIONS ================
+
+	//region ================ CLASSES ================
+
+	public abstract static class Node extends AbstractMOAObject {
+
+		private static final long serialVersionUID = 1L;
+
+		protected double weightSeenAtLastSplitEvaluation;
+
+		public int ID;
+
+		protected ISOUPTree tree;
+
+		// The parent of this particular node
+		protected SplitNode parent;
+
+		protected Node alternateTree;
+		protected Node originalNode;
+
+		protected AutoExpandVector<AttributeStatisticsObserver> attributeObservers = new AutoExpandVector<AttributeStatisticsObserver>();
+
+		// The error values for the Page Hinckley test
+		// PHmT = the cumulative sum of the errors
+		// PHMT = the minimum error value seen so far
+		protected boolean changeDetection = true;
+
+		// The statistics for this node:
+		// Number of instances that have reached it
+		protected double examplesSeen;
+		// Sum of y values
+		protected DoubleVector sumOfValues = new DoubleVector();
+		// Sum of squared y values
+		protected DoubleVector sumOfSquares = new DoubleVector();
+
+		public Node(ISOUPTree tree) {
+			this.tree = tree;
+		}
+
+		public void copyStatistics(Node node) {
+			examplesSeen = node.examplesSeen;
+			sumOfValues = (DoubleVector) node.sumOfValues.copy();
+			sumOfSquares = (DoubleVector) node.sumOfSquares.copy();
+		}
+
+		public int calcByteSize() {
+			return (int) SizeOf.fullSizeOf(this);
+		}
+
+		/**
+		 * Set the parent node
+		 */
+		public void setParent(SplitNode parent) {
+			this.parent = parent;    
+		}
+
+		/**
+		 * Return the parent node
+		 */
+		public Node getParent() {
+			return parent;
+		}
+
+		public void disableChangeDetection() {
+			changeDetection = false;
+		}
+
+		public void restartChangeDetection() {
+			changeDetection = true;
+		}
+
+		public void getDescription(StringBuilder sb, int i) {}
+
+		public double[] getPrediction(MultiLabelInstance inst) {
+			return null;
+		}
+
+		public void describeSubtree(StringBuilder out, int indent) {
+			StringUtils.appendIndented(out, indent, "Leaf");
+		}
+
+		public int getLevel() {
+			Node target = this;
+			int level = 0;
+			while (target.getParent() != null) {
+				if (target.skipInLevelCount()) {
+					target = target.getParent();
+					continue;
+				}
+				level = level + 1;
+				target = target.getParent();
+			}
+			if (target.originalNode == null) {
+				return level;
+			} else {
+				return level + originalNode.getLevel();
+			}
+		}
+
+		public void setChild(int parentBranch, Node node) {
+		}
+
+		public int getChildIndex(Node child) {
+			return -1;
+		}
+
+		public int getNumSubtrees() {
+			return 1;
+		}
+
+		protected boolean skipInLevelCount() {
+			return false;
+		}
+	}
+
+	public static class LeafNode extends Node {
+
+		private static final long serialVersionUID = 1L;
+
+		// Perceptron model that carries out the actual learning in each node
+		public MultitargetPerceptron learningModel;
+
+		public DoubleVector errorP = new DoubleVector();
+		public DoubleVector errorM = new DoubleVector();
+
+		protected double examplesSeenAtLastSplitEvaluation = 0;
+
+		/**
+		 * Create a new LeafNode
+		 */
+		public LeafNode(ISOUPTree tree) {
+			super(tree);
+			if (tree.buildingModelTree()) {
+				learningModel = tree.newLeafModel();
+			}
+			examplesSeen = 0;
+			sumOfValues = new DoubleVector();
+			sumOfSquares = new DoubleVector();
+		}
+
+		/**
+		 * Method to learn from an instance that passes the new instance to the perceptron learner,
+		 * and also prevents the class value from being truncated to an int when it is passed to the
+		 * attribute observer
+		 */
+		public void learnFromInstance(MultiLabelInstance inst, double[] prediction, boolean growthAllowed) {
+			// Update the statistics for this node
+			// number of instances passing through the node
+			double[] predictionP = tree.buildingModelTree() ? getPredictionModel(inst) : null;
+			double[] predictionM = getPredictionTargetMean(inst);
+
+			examplesSeen += inst.weight();
+
+			for (int i = 0; i < tree.getModelContext().numOutputAttributes(); i++) {
+				// sum of y values
+				sumOfValues.addToValue(i, inst.weight() * inst.valueOutputAttribute(i));
+
+				// sum of squared y values
+				sumOfSquares.addToValue(i, inst.weight() * inst.valueOutputAttribute(i) * inst.valueOutputAttribute(i));
+
+				if (tree.buildingModelTree()) {
+					errorP.setValue(i, errorP.getValue(i) * 0.95 + Math.abs(predictionP[i] - inst.valueOutputAttribute(i)));
+					errorM.setValue(i, errorM.getValue(i) * 0.95 + Math.abs(predictionM[i] - inst.valueOutputAttribute(i)));
+				}
+			}
+			
+			if (tree.buildingModelTree()) learningModel.updatePerceptron(inst);
+
+			for (int i = 0; i < inst.numInputAttributes(); i++) {
+				AttributeStatisticsObserver obs = attributeObservers.get(i);
+				if (obs == null) {
+					// At this stage all nominal attributes are ignored
+					if (inst.inputAttribute(i).isNumeric()) {
+						obs = tree.newNumericClassObserver();
+						attributeObservers.set(i, obs);
+					} else if (inst.inputAttribute(i).isNominal()) {
+						obs = tree.newNominalClassObserver();
+						attributeObservers.set(i, obs);
+					}
+
+				}
+				if (obs != null) {
+					DoubleVector[] observations = new DoubleVector[inst.numOutputAttributes()];
+					for (int j = 0; j < inst.numOutputAttributes(); j++) {
+						observations[j] = new DoubleVector();
+						observations[j].setValue(0, inst.weight());
+						observations[j].setValue(1, inst.weight() * inst.valueOutputAttribute(j));
+						observations[j].setValue(2, inst.weight() * inst.valueOutputAttribute(j) * inst.valueOutputAttribute(j));
+					}
+					obs.observeAttribute(inst.valueInputAttribute(i), observations);
+
+					//obs.observeAttributeClassVector(inst.valueInputAttribute(i), getTargetVector(inst), inst.weight());
+				}
+			}
+
+			if (growthAllowed) {
+				checkForSplit();
+			}
+		}
+
+		/**
+		 * Return the best split suggestions for this node using the given split criteria
+		 */
+		public AttributeExpansionSuggestion[] getBestSplitSuggestions(MultiLabelSplitCriterion criterion) {
+
+			List<AttributeExpansionSuggestion> bestSuggestions = new LinkedList<AttributeExpansionSuggestion>();
+
+			for (int i = 0; i < attributeObservers.size(); i++) {
+				AttributeStatisticsObserver obs = attributeObservers.get(i);
+				if (obs != null) {
+					DoubleVector[] preSplitStatistics = new DoubleVector[tree.getModelContext().numOutputAttributes()];
+					for (int j = 0; j < tree.getModelContext().numOutputAttributes(); j++) {
+						preSplitStatistics[j] = new DoubleVector();
+						preSplitStatistics[j].setValue(0, examplesSeen);
+						preSplitStatistics[j].setValue(1, sumOfValues.getValue(j));
+						preSplitStatistics[j].setValue(2, sumOfSquares.getValue(j));
+					}
+
+					AttributeExpansionSuggestion bestSuggestion = null;
+					bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion, preSplitStatistics, i);
+
+					if (bestSuggestion != null) {
+						bestSuggestions.add(bestSuggestion);
+					}
+				}
+			}
+			return bestSuggestions.toArray(new AttributeExpansionSuggestion[bestSuggestions.size()]);
+		}
+
+		/**
+		 * Retrieve the class votes using the perceptron learner
+		 */
+		public double[] getPredictionModel(MultiLabelInstance inst) {
+			return learningModel.prediction(inst);
+		}
+
+		public double[] getPredictionTargetMean(MultiLabelInstance inst) {
+			double[] pred = new double[inst.numOutputAttributes()];
+			for (int i = 0; i < inst.numOutputAttributes(); i++) {
+				if (examplesSeen > 0) {
+					pred[i] = sumOfValues.getValue(i) / examplesSeen;
+				} else {
+					pred[i] = 0;
+				}
+			}
+			return pred;
+		}
+
+		public double[] getPrediction(MultiLabelInstance inst) {
+			if (tree.buildingModelTree()) {
+				double[] predictionP = getPredictionModel(inst);
+				double[] predictionM = getPredictionTargetMean(inst);
+				double[] prediction = new double[predictionP.length];
+				for (int i = 0; i < predictionP.length; i++) {
+					if (errorP.getValue(i) < errorM.getValue(i)) {
+						prediction[i] = predictionP[i];
+					} else {
+						prediction[i] = predictionM[i];
+					}
+				}
+				return prediction;
+			} else {
+				return getPredictionTargetMean(inst);
+			}
+
+		}
+
+		//		public double[] getClassVotes(MultiLabelInstance inst, ISOUPTrees tree) {
+		//			return new double[] {getPrediction(inst, tree)};
+		//		}
+
+		public void checkForSplit() {
+			// If it has seen Nmin examples since it was last tested for splitting, attempt a split of this node
+			if (examplesSeen - examplesSeenAtLastSplitEvaluation >= tree.gracePeriodOption.getValue()) {
+				int index = (parent != null) ? parent.getChildIndex(this) : 0;
+				tree.attemptToSplit(this, parent, index);
+
+				// Take note of how many instances were seen when this split evaluation was made, so we know when to perform the next split evaluation
+				examplesSeenAtLastSplitEvaluation = examplesSeen;
+			}
+		}
+
+		public void describeSubtree(StringBuilder out, int indent) {
+			StringUtils.appendIndented(out, indent, "Leaf ");
+			if (tree.buildingModelTree()) {
+				learningModel.getModelDescription(out, 0);
+			} else {
+				//out.append(tree.getClassNameString() + " = " + String.format("%.4f", (sumOfValues / examplesSeen)));
+				StringUtils.appendNewline(out);
+			}
+		}
+
+	}
+
+	public static abstract class InnerNode extends Node {
+		// The InnerNode and SplitNode design is used for easy extension in ISOUPOptionTree
+		private static final long serialVersionUID = 1L;
+
+		protected AutoExpandVector<Node> children = new AutoExpandVector<Node>();
+
+		// Sum of absolute errors
+		protected DoubleVector sumOfAbsErrors = new DoubleVector(); // Needed for PH tracking of mean error
+		
+		protected DoubleVector PHsums = new DoubleVector();
+		protected DoubleVector PHmins = new DoubleVector();
+
+		// Keep track of the statistics for loss error calculations
+		protected double lossExamplesSeen;
+		protected double lossFadedSumOriginal;
+		protected double lossFadedSumAlternate;
+		protected double lossNumQiTests;
+		protected double lossSumQi;
+		protected double previousWeight = 0;
+
+		public InnerNode(ISOUPTree tree) {
+			super(tree);
+		}
+
+		public int numChildren() {
+			return children.size();
+		}
+
+		public Node getChild(int i) {
+			return children.get(i);
+		}
+
+		public int getChildIndex(Node child) {
+			return children.indexOf(child);
+		}
+
+		public void setChild(int i, Node child) {
+			children.set(i, child);
+		}
+
+		public void disableChangeDetection() {
+			changeDetection = false;
+			for (Node child : children) {
+				child.disableChangeDetection();
+			}
+		}
+
+		public void restartChangeDetection() {
+			if (this.alternateTree == null) {
+				changeDetection = true;
+				PHsums = new DoubleVector();
+				PHmins = new DoubleVector();
+				for (int i = 0; i < tree.getModelContext().numOutputAttributes(); i++) {
+					PHmins.setValue(i, Double.MAX_VALUE);
+				}				
+				for (Node child : children)
+					child.restartChangeDetection();
+			}
+		}
+
+		/**
+		 * Check to see if the tree needs updating
+		 */
+		public boolean PageHinckleyTest(double error, double threshold, int targetIndex) {    
+			// Update the cumulative mT sum
+			PHsums.addToValue(targetIndex, error);
+
+			// Update the minimum mT value if the new mT is
+			// smaller than the current minimum
+			if(PHsums.getValue(targetIndex) < PHmins.getValue(targetIndex)) {
+				PHmins.setValue(targetIndex, PHsums.getValue(targetIndex));;
+			}
+			// Return true if the cumulative value - the current minimum is
+			// greater than the current threshold (in which case we should adapt)
+			return PHsums.getValue(targetIndex) - PHmins.getValue(targetIndex) > threshold;
+		}
+
+		public void initializeAlternateTree(ISOUPTree tree) {
+			// Start a new alternate tree, beginning with a learning node
+			alternateTree = tree.newLeafNode();
+			alternateTree.originalNode = this;
+
+			// Set up the blank statistics
+			// Number of instances reaching this node since the alternate tree was started
+			lossExamplesSeen = 0;
+			// Faded squared error (original tree)
+			lossFadedSumOriginal = 0;
+			// Faded squared error (alternate tree)
+			lossFadedSumAlternate = 0;
+			// Number of evaluations of alternate tree
+			lossNumQiTests = 0;
+			// Sum of Qi values
+			lossSumQi = 0;
+			// Number of examples at last test
+			previousWeight = 0;
+
+			// Disable the change detection mechanism bellow this node
+			disableChangeDetection();
+		}
+	}
+
+	public static class SplitNode extends InnerNode {
+
+		private static final long serialVersionUID = 1L;
+
+		protected Predicate predicate;
+
+		/**
+		 * Create a new SplitNode
+		 * @param predicate
+		 * @param tree
+		 */
+		public SplitNode(Predicate predicate, ISOUPTree tree) {
+			super(tree);
+			this.predicate = predicate;
+			ID = tree.maxID;
+		}
+
+		public int instanceChildIndex(MultiLabelInstance inst) {
+			return (predicate.evaluate(inst)) ? 0 : 1;
+		}
+
+		public void describeSubtree(StringBuilder out, int indent) {
+			for (int branch = 0; branch < children.size(); branch++) {
+				Node child = getChild(branch);
+				if (child != null) {
+					if (branch == 0) {
+						StringUtils.appendIndented(out, indent, "if ");
+						this.predicate.getDescription(out, 0);
+					} else {
+						StringUtils.appendIndented(out, indent, "else");
+					}
+					out.append(": ");
+					StringUtils.appendNewline(out);
+					child.describeSubtree(out, indent + 2);
+				}
+			}
+		}
+
+		public double[] getPrediction(MultiLabelInstance inst) {
+			return children.get(predicate.evaluate(inst) ? 0 : 1).getPrediction(inst);
+		}
+	}
+
+	public class MultitargetPerceptron {
+
+		protected ISOUPTree tree;
+
+		// The Perception weights 
+		public double[][] weights; 
+
+		// The number of instances contributing to this model
+		protected int instancesSeen = 0;
+
+		public String getPurposeString() {
+			return "A multi-target perceptron";
+		}
+
+		public MultitargetPerceptron(ISOUPTree tree, MultitargetPerceptron original) {
+			this.tree = tree;
+			weights = original.weights.clone();
+			// TODO check if this is necessary
+//			for (int i = 0; i < this.tree.getModelContext().numOutputAttributes(); i++) {
+//				weights[i] = (DoubleVector) original.weights[i].copy();
+//			}
+		}
+
+		public MultitargetPerceptron(ISOUPTree tree) {
+			this.tree = tree;
+			initializeWeights();
+		}
+
+		public void initializeWeights() {
+			instancesSeen = 0;
+			int numTargets = tree.getModelContext().numOutputAttributes();
+			int numInputs = tree.getModelContext().numInputAttributes();
+			weights = new double[numTargets][numInputs+1];
+			tree.classifierRandom.setSeed(1234);
+			for (int i = 0; i < numTargets; i++) {
+				for (int j = 0; j < numInputs + 1; j++) { 
+					// The last index corresponds to the constant b
+					weights[i][j] = 2 * tree.classifierRandom.nextDouble() - 1;
+				}
+			}
+			normalizeWeights();
+		}
+
+		/**
+		 * Update the model using the provided instance
+		 */
+		public void updatePerceptron(MultiLabelInstance inst) {
+			// Update attribute statistics
+			instancesSeen += inst.weight();
+			
+			// Update weights
+			double learningRatio = 0.0;
+			if (tree.learningRatioConstOption.isSet()) {
+				learningRatio = tree.learningRatioOption.getValue();
+			} else {
+				learningRatio = learningRatioOption.getValue() / (1 + instancesSeen * tree.learningRateDecayFactorOption.getValue());
+			}
+
+			// Loop for compatibility with bagging methods 
+			for (int i = 0; i < (int) inst.weight(); i++) {
+				updateWeights(inst, learningRatio);
+			}
+		}
+
+		public void updateWeights(MultiLabelInstance inst, double learningRatio) {
+			if (instancesSeen > 1.0) {
+				// Compute the normalized instance and the delta
+				double[] normalizedInput = tree.normalizedInputVector(inst); 
+			    double[] normalizedPrediction = prediction(normalizedInput);
+
+				double[] normalizedTarget = tree.normalizedTargetVector(inst);
+				for (int i = 0; i < inst.numOutputAttributes(); i++){
+					double delta = normalizedTarget[i] - normalizedPrediction[i];
+					for (int j = 0; j < normalizedInput.length; j++) {
+						weights[i][j] += delta * learningRatio * normalizedInput[j];
+					}
+				}
+				normalizeWeights();
+			}
+		}
+
+		public void normalizeWeights() {
+			for (int j =0; j < weights.length; j++) {
+				double sum = 0;
+				for (int i = 0; i < weights[j].length; i++)
+					sum += Math.abs(weights[j][i]);
+				for (int i = 0; i < weights[j].length; i++)
+					weights[j][i] /= sum;
+			}
+		}
+
+		
+		/**
+		 * Output the prediction made by this perceptron on the given instance
+		 */
+		public double[] prediction(double[] instanceValues) {
+			double[] out = new double[tree.getModelContext().numOutputAttributes()];
+			for (int i = 0; i < tree.getModelContext().numOutputAttributes(); i++) {
+				out[i] = 0;
+				for (int j = 0; j < instanceValues.length; j++) {
+					out[i] += weights[i][j] * instanceValues[j];
+				}
+			}
+			return out;
+		}
+
+		private double[] prediction(MultiLabelInstance inst) {
+			double[] normalizedInput = tree.normalizedInputVector(inst);
+			double[] normalizedPrediction = prediction(normalizedInput);
+			return denormalizePrediction(normalizedPrediction);
+		}
+
+		private double[] denormalizePrediction(double[] normalizedPrediction) {
+			double[] out = new double[normalizedPrediction.length];
+			if (tree.normalize()) {
+				for (int i = 0; i < tree.getModelContext().numOutputAttributes(); i++) {
+					double mean = tree.sumOfValues.getValue(i) / tree.examplesSeen;
+					double sd = computeSD(tree.sumOfSquares.getValue(i), tree.sumOfValues.getValue(i), tree.examplesSeen);
+					if (examplesSeen > 1) 
+						out[i] = normalizedPrediction[i] * sd + mean;
+					else
+						out[i] = 0;
+				}
+				return out;
+			} else return normalizedPrediction;
+		}
+
+		public void getModelDescription(StringBuilder out, int indent) {
+			for (int i = 0; i < tree.getModelContext().numOutputAttributes(); i++) {
+				StringUtils.appendIndented(out, indent, " [" + tree.getModelContext().outputAttribute(i).name() + "]");
+				//if (getModelContext() != null) {
+				//for (int j = 0; j < getModelContext().numAttributes() - 1; j++) {
+				//					if (getModelContext().attribute(j).isNumeric()) {
+				//						// TODO
+				//						//out.append((j == 0 || weightAttribute.getValue(j) < 0) ? " " : " + ");
+				//						//out.append(String.format("%.4f", weightAttribute.getValue(j)));
+				//						out.append(" * ");
+				//						out.append(getAttributeNameString(j));
+				//					}
+				//}
+				//out.append(" + " + weightAttribute.getValue((getModelContext().numAttributes() - 1)));
+				//}
+			}
+			StringUtils.appendNewline(out);
+		}
+	}
+
+	//	public class SOPNumericAttributeClassObserver implements MultitargetAttributeClassObserver {
+	//
+	//		private static final long serialVersionUID = 1L;
+	//
+	//		protected class Node implements Serializable {
+	//
+	//			private static final long serialVersionUID = 1L;
+	//
+	//			// The split point to use
+	//			public double cut_point;
+	//
+	//			// E-BST statistics
+	//			public double leftCount = 0;
+	//			public double rightCount = 0;
+	//			public DoubleVector leftSums = new DoubleVector();
+	//			public DoubleVector leftSquares = new DoubleVector();
+	//			public DoubleVector rightSums = new DoubleVector();
+	//			public DoubleVector rightSquares = new DoubleVector();
+	//
+	//			// Child nodes
+	//			public Node left;
+	//			public Node right;
+	//
+	//			public Node(double val, DoubleVector labelVector, double weight) {
+	//				cut_point = val;
+	//				leftCount += 1;
+	//				for (int i = 0; i < labelVector.numValues(); i++) {
+	//					leftSums.addToValue(i, labelVector.getValue(i));
+	//					leftSquares.addToValue(i, labelVector.getValue(i) * labelVector.getValue(i));
+	//				}
+	//			}
+	//
+	//			/**
+	//			 * Insert a new value into the tree, updating both the sum of values and
+	//			 * sum of squared values arrays
+	//			 */
+	//			public void insertValue(double val, DoubleVector labelVector, double weight) {
+	//
+	//				// If the new value equals the value stored in a node, update
+	//				// the left (<=) node information
+	//				if (val == cut_point) {
+	//					leftCount += 1;
+	//					for (int i = 0; i < labelVector.numValues(); i++) {
+	//						leftSums.addToValue(i, labelVector.getValue(i));
+	//						leftSquares.addToValue(i, labelVector.getValue(i) * labelVector.getValue(i));
+	//					}
+	//				} // If the new value is less than the value in a node, update the
+	//				// left distribution and send the value down to the left child node.
+	//				// If no left child exists, create one
+	//				else if (val <= cut_point) {
+	//
+	//					leftCount += 1;
+	//					for (int i = 0; i < labelVector.numValues(); i++) {
+	//						leftSums.addToValue(i, labelVector.getValue(i));
+	//						leftSquares.addToValue(i, labelVector.getValue(i) * labelVector.getValue(i));
+	//					}
+	//					if (left == null) {
+	//						left = new Node(val, labelVector, weight);
+	//					} else {
+	//						left.insertValue(val, labelVector, weight);
+	//					}
+	//				} // If the new value is greater than the value in a node, update the
+	//				// right (>) distribution and send the value down to the right child node.
+	//				// If no right child exists, create one
+	//				else { // val > cut_point
+	//					rightCount += 1;
+	//					for (int i = 0; i < labelVector.numValues(); i++) {
+	//						rightSums.addToValue(i, labelVector.getValue(i));
+	//						rightSquares.addToValue(i, labelVector.getValue(i) * labelVector.getValue(i));
+	//					}
+	//					if (right == null) {
+	//						right = new Node(val, labelVector, weight);
+	//					} else {
+	//						right.insertValue(val, labelVector, weight);
+	//					}
+	//				}
+	//			}
+	//		}
+	//
+	//		// Root node of the E-BST structure for this attribute
+	//		protected Node root = null;
+	//
+	//		// Global variables for use in the FindBestSplit algorithm
+	//		DoubleVector sumsTotalLeft;
+	//		DoubleVector sumsTotalRight;
+	//		DoubleVector squaresTotalLeft;
+	//		DoubleVector squaresTotalRight;
+	//		double countRightTotal;
+	//		double countLeftTotal;
+	//
+	//		public void observeAttributeClass(double attVal, double classVal, double weight) {
+	//			// DEPRECATED (used for single-target cases)
+	//
+	//			//	        if (Double.isNaN(attVal)) { //Instance.isMissingValue(attVal)
+	//			//	        } else {
+	//			//	            if (root == null) {
+	//			//	                root = new Node(attVal, classVal, weight);
+	//			//	            } else {
+	//			//	                root.insertValue(attVal, classVal, weight);
+	//			//	            }
+	//			//	        }
+	//		}
+	//
+	//		public void observeAttributeClass(double attVal, DoubleVector classVector, double weight) {
+	//			if (Double.isNaN(attVal)) { //Instance.isMissingValue(attVal)
+	//			} else {
+	//				if (root == null) {
+	//					root = new Node(attVal, classVector, weight);
+	//				} else {
+	//					root.insertValue(attVal, classVector, weight);
+	//				}
+	//			}
+	//
+	//		}
+	//
+	//		public double probabilityOfAttributeValueGivenClass(double attVal, int classVal) {
+	//			// TODO: NaiveBayes broken until implemented
+	//			return 0.0;
+	//		}
+	//
+	//		@Override
+	//		public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(SplitCriterion criterion, double examlpesSeen, DoubleVector preSplitSums, DoubleVector preSplitSquares, int numTargets, int attIndex, boolean binaryOnly) {
+	//			// Initialise global variables
+	//			sumsTotalLeft = new DoubleVector();
+	//			sumsTotalRight = preSplitSums;
+	//			squaresTotalLeft = new DoubleVector();
+	//			squaresTotalRight = preSplitSquares;
+	//			countLeftTotal = 0;
+	//			countRightTotal = examplesSeen;
+	//
+	//			// Hardcoded for ICV reduction
+	//			double preSplitVariance = 0;
+	//			for (int i = 0; i < numTargets; i++) {
+	//				preSplitVariance += (preSplitSquares.getValue(i) - examplesSeen * preSplitSums.getValue(i) * preSplitSums.getValue(i)) / examplesSeen;
+	//			}
+	//
+	//			return searchForBestSplitOption(root, null, preSplitVariance, attIndex, numTargets);
+	//		}
+	//
+	//		public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(SplitCriterion criterion, double[] preSplitDist, int attIndex, boolean binaryOnly) {
+	//			// DEPRECATED
+	//			return null;
+	//		}
+	//
+	//		/**
+	//		 * Implementation of the FindBestSplit algorithm from E.Ikonomovska et al.
+	//		 */
+	//		protected AttributeSplitSuggestion searchForBestSplitOption(Node currentNode, AttributeSplitSuggestion currentBestOption, double preSplitVariance, int attIndex, int numTargets) {
+	//			// Return null if the current node is null or we have finished looking through all the possible splits
+	//			if (currentNode == null || countRightTotal == 0.0) {
+	//				return currentBestOption;
+	//			}
+	//
+	//			if (currentNode.left != null) {
+	//				currentBestOption = searchForBestSplitOption(currentNode.left, currentBestOption, preSplitVariance, attIndex, numTargets);
+	//			}
+	//
+	//			sumsTotalLeft.addValues(currentNode.leftSums);
+	//			sumsTotalRight.subtractValues(currentNode.leftSums);
+	//			squaresTotalLeft.addValues(currentNode.leftSquares);
+	//			squaresTotalRight.subtractValues(currentNode.leftSquares);
+	//			countLeftTotal += currentNode.leftCount;
+	//			countRightTotal -= currentNode.leftCount;
+	//
+	//			//	        double[][] postSplitDists = new double[][]{{countLeftTotal, sumTotalLeft, sumSqTotalLeft}, {countRightTotal, sumTotalRight, sumSqTotalRight}};
+	//			//	        double[] preSplitDist = new double[]{(countLeftTotal + countRightTotal), (sumTotalLeft + sumTotalRight), (sumSqTotalLeft + sumSqTotalRight)};
+	//			//	        double merit = criterion.getMeritOfSplit(preSplitDist, postSplitDists);
+	//
+	//			double postSplitVariance = 0;
+	//			for (int i = 0; i < numTargets; i++) {
+	//				postSplitVariance += (squaresTotalLeft.getValue(i) - examplesSeen * sumsTotalLeft.getValue(i) * sumsTotalLeft.getValue(i)) / countLeftTotal;
+	//				postSplitVariance += (squaresTotalRight.getValue(i) - examplesSeen * sumsTotalRight.getValue(i) * sumsTotalRight.getValue(i)) / countRightTotal;
+	//			}
+	//
+	//			double merit = preSplitVariance - postSplitVariance;
+	//
+	//			if ((currentBestOption == null) || (merit > currentBestOption.merit)) {
+	//				currentBestOption = new AttributeSplitSuggestion(
+	//						new NumericAttributeBinaryTest(attIndex,
+	//								currentNode.cut_point, true), new double[0][0], merit);
+	//
+	//			}
+	//
+	//			if (currentNode.right != null) {
+	//				currentBestOption = searchForBestSplitOption(currentNode.right, currentBestOption, preSplitVariance, attIndex, numTargets);
+	//			}
+	//
+	//			sumsTotalLeft.subtractValues(currentNode.leftSums);
+	//			sumsTotalRight.addValues(currentNode.leftSums);
+	//			squaresTotalLeft.subtractValues(currentNode.leftSquares);
+	//			squaresTotalRight.addValues(currentNode.leftSquares);
+	//			countLeftTotal -= currentNode.leftCount;
+	//			countRightTotal += currentNode.leftCount;
+	//
+	//			return currentBestOption;
+	//		}
+	//
+	//		/**
+	//		 * A method to remove all nodes in the E-BST in which it and all it's
+	//		 * children represent 'bad' split points
+	//		 */
+	//		public void removeBadSplits(SplitCriterion criterion, double lastCheckRatio, double lastCheckSDR, double lastCheckE, int numTargets) {
+	//			removeBadSplitNodes(criterion, root, lastCheckRatio, lastCheckSDR, lastCheckE, numTargets);
+	//		}
+	//
+	//		/**
+	//		 * Recursive method that first checks all of a node's children before
+	//		 * deciding if it is 'bad' and may be removed
+	//		 */
+	//		private boolean removeBadSplitNodes(SplitCriterion criterion, Node currentNode, double lastCheckRatio, double lastCheckSDR, double lastCheckE, int numTargets) {
+	//			boolean isBad = false;
+	//
+	//			if (currentNode == null) {
+	//				return true;
+	//			}
+	//
+	//			if (currentNode.left != null) {
+	//				isBad = removeBadSplitNodes(criterion, currentNode.left, lastCheckRatio, lastCheckSDR, lastCheckE, numTargets);
+	//			}
+	//
+	//			if (currentNode.right != null && isBad) {
+	//				isBad = removeBadSplitNodes(criterion, currentNode.left, lastCheckRatio, lastCheckSDR, lastCheckE, numTargets);
+	//			}
+	//
+	//			if (isBad) {
+	//
+	//				double preSplitVariance = 0;
+	//				for (int i = 0; i < numTargets; i++) {
+	//					preSplitVariance += (currentNode.leftSquares.getValue(i) + currentNode.rightSquares.getValue(i) - examplesSeen * 
+	//							(currentNode.leftSums.getValue(i) + currentNode.rightSums.getValue(i)) * (currentNode.leftSums.getValue(i) + currentNode.rightSums.getValue(i))) / examplesSeen;
+	//				}
+	//
+	//				double postSplitVariance = 0;
+	//				for (int i = 0; i < numTargets; i++) {
+	//					postSplitVariance += (currentNode.leftSquares.getValue(i) - currentNode.leftCount * currentNode.leftSums.getValue(i) * currentNode.leftSums.getValue(i)) / currentNode.leftCount;
+	//					postSplitVariance += (currentNode.rightSquares.getValue(i) - currentNode.rightCount * currentNode.rightSums.getValue(i) * currentNode.rightSums.getValue(i)) / currentNode.rightCount;
+	//				}
+	//
+	//
+	//				//	            double[][] postSplitDists = new double[][]{{currentNode.leftStatistics.getValue(0), currentNode.leftStatistics.getValue(1), currentNode.leftStatistics.getValue(2)}, {currentNode.rightStatistics.getValue(0), currentNode.rightStatistics.getValue(1), currentNode.rightStatistics.getValue(2)}};
+	//				//	            double[] preSplitDist = new double[]{(currentNode.leftStatistics.getValue(0) + currentNode.rightStatistics.getValue(0)), (currentNode.leftStatistics.getValue(1) + currentNode.rightStatistics.getValue(1)), (currentNode.leftStatistics.getValue(2) + currentNode.rightStatistics.getValue(2))};
+	//				//	            double merit = criterion.getMeritOfSplit(preSplitDist, postSplitDists);
+	//				double merit = preSplitVariance - postSplitVariance;
+	//
+	//				if ((merit / lastCheckSDR) < (lastCheckRatio - (2 * lastCheckE))) {
+	//					currentNode = null;
+	//					return true;
+	//				}
+	//			}
+	//
+	//			return false;
+	//		}
+	//
+	//		@Override
+	//		public void getDescription(StringBuilder sb, int indent) {
+	//			// TODO Auto-generated method stub
+	//		}
+	//
+	//		protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+	//			// TODO Auto-generated method stub
+	//		}
+	//
+	//		@Override
+	//		public void observeAttributeClass(double attVal, int classVal,
+	//				double weight) {
+	//			// TODO Auto-generated method stub
+	//
+	//		}
+	//
+	//		@Override
+	//		public void observeAttributeTarget(double attVal, double target) {
+	//			// TODO Auto-generated method stub
+	//
+	//		}
+	//
+	//		@Override
+	//		public String getPurposeString() {
+	//			// TODO Auto-generated method stub
+	//			return null;
+	//		}
+	//
+	//		@Override
+	//		public Options getOptions() {
+	//			// TODO Auto-generated method stub
+	//			return null;
+	//		}
+	//
+	//		@Override
+	//		public void prepareForUse() {
+	//			// TODO Auto-generated method stub
+	//
+	//		}
+	//
+	//		@Override
+	//		public void prepareForUse(TaskMonitor monitor,
+	//				ObjectRepository repository) {
+	//			// TODO Auto-generated method stub
+	//
+	//		}
+	//
+	//		@Override
+	//		public OptionHandler copy() {
+	//			// TODO Auto-generated method stub
+	//			return null;
+	//		}
+	//
+	//		@Override
+	//		public String getCLICreationString(Class<?> expectedType) {
+	//			// TODO Auto-generated method stub
+	//			return null;
+	//		}
+	//
+	//		@Override
+	//		public int measureByteSize() {
+	//			// TODO Auto-generated method stub
+	//			return 0;
+	//		}
+	//
+	//
+	//
+	//		@Override
+	//		public void observeAttributeClassVector(double attVal,
+	//				DoubleVector classVector, double weight) {
+	//			// TODO Auto-generated method stub
+	//
+	//		}
+	//
+	//
+	//	}
+
+	//endregion ================ CLASSES ================
+
+	//region ================ METHODS ================
+
+	// Regressor methods
+	public ISOUPTree() {}
+
+	public String getPurposeString() {
+		return "Implementation of the FIMT-DD tree as described by Ikonomovska et al.";
+	}
+
+	public void resetLearningImpl() {
+		treeRoot = null;
+		leafNodeCount = 0;
+		splitNodeCount = 0;
+		examplesSeen = 0.0;
+		sumOfValues = new DoubleVector();
+		sumOfSquares = new DoubleVector();
+
+		sumOfAttrValues = new DoubleVector();
+		sumOfAttrSquares = new DoubleVector();
+	}
+
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	public void getModelDescription(StringBuilder out, int indent) {
+		if (treeRoot != null) treeRoot.describeSubtree(out, indent);
+	}
+
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[]{ 
+				//new Measurement("tree size (nodes)", this.leafNodeCount + this.splitNodeCount),
+				//new Measurement("tree size (leaves)", this.leafNodeCount)
+		};
+	}
+
+	public int calcByteSize() {
+		int size = (int) SizeOf.sizeOf(this);
+		if (this.treeRoot != null) {
+			size += this.treeRoot.calcByteSize();
+		}
+		return size;
+	}
+
+	public Prediction getPredictionForInstance(MultiLabelInstance inst) {
+		checkRoot();
+		double[] predictionVector = treeRoot.getPrediction(inst);
+		MultiLabelPrediction prediction = new MultiLabelPrediction(getModelContext().numOutputAttributes());
+		for (int i = 0; i < getModelContext().numOutputAttributes(); i++) {
+			prediction.setVote(i, 1, predictionVector[i]);
+		}
+		return prediction;
+	}
+
+	public double[] normalizedInputVector(MultiLabelInstance inst) {
+		// Normalize Instance
+		double[] normalizedInput = new double[inst.numInputAttributes()+1];
+		if (normalize()) {
+			for (int j = 0; j < inst.numInputAttributes(); j++) {
+				Attribute attr = inst.inputAttribute(j);
+				double value =  inst.valueInputAttribute(j);
+				double mean = sumOfAttrValues.getValue(j) / examplesSeen;
+				double sd = computeSD(sumOfAttrSquares.getValue(j), sumOfAttrValues.getValue(j), examplesSeen);
+				if (examplesSeen > 1 && sd > 0.00001) {
+					if (attr.isNumeric())
+						normalizedInput[j] = (value - mean) / sd;
+					else
+						normalizedInput[j] = value;
+				} else
+					normalizedInput[j] = 0;
+			}
+			if (examplesSeen > 1)
+				normalizedInput[inst.numInputAttributes()] = 1.0; // Value to be multiplied with the constant factor
+			else
+				normalizedInput[inst.numInputAttributes()] =  0.0;
+		} else {
+			for (int j = 0; j < inst.numInputAttributes(); j++) {
+				normalizedInput[j] = inst.valueInputAttribute(j);
+			}
+			normalizedInput[inst.numInputAttributes()] = 1.0;
+		}
+		return normalizedInput;
+	}
+
+	public double[] normalizedTargetVector(MultiLabelInstance inst) {
+		double[] out = new double[getModelContext().numOutputAttributes()];
+		if (normalize()) {
+			for (int i = 0; i < inst.numOutputAttributes(); i++) {
+				double value = inst.valueOutputAttribute(i);
+				double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen);
+				double average = sumOfValues.getValue(i) / examplesSeen;
+				if (sd > 0 && examplesSeen > 1)
+					out[i] = (value - average) / (sd);
+				else
+					out[i] = 0;
+			}
+		} else {
+			for (int i = 0; i < inst.numOutputAttributes(); i++) {
+				out[i] = inst.valueOutputAttribute(i);
+			}
+		}
+		return out;
+	}
+
+	public double[] normalizeTargetVector(double[] pred) {
+		if (normalize()) {
+			double[] out = new double[pred.length];
+			for (int i = 0; i < pred.length; i++) {
+				double value = pred[i];
+				double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen);
+				double average = sumOfValues.getValue(i) / examplesSeen;
+				if (sd > 0 && examplesSeen > 1)
+					out[i] = (value - average) / sd;
+				else
+					out[i] = 0;
+			}
+			return out;
+		} else return pred;
+	}
+
+
+	public double normalizeTargetValue(MultiLabelInstance inst, int i) {
+		if (normalize()) {
+			if (examplesSeen > 1) {
+				double value = inst.valueOutputAttribute(i);
+				double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen);
+				double average = sumOfValues.getValue(i) / examplesSeen;
+				if (sd > 0)
+					return (value - average) / sd;
+				else
+					return 0;
+			}
+			return 0;
+		} else return inst.valueOutputAttribute(i);
+	}
+
+	public double normalizeTargetValue(double value, int i) {
+		if (normalize()) {
+			if (examplesSeen > 1) {
+				double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen);
+				double average = sumOfValues.getValue(i) / examplesSeen;
+				if (sd > 0)
+					return (value - average) / sd;
+				else
+					return 0;
+			}
+			return 0;
+		} else return value;
+	}
+
+	public double[] getNormalizedError(MultiLabelInstance inst, double[] prediction) {
+		double[] normalPrediction = normalizeTargetVector(prediction);
+		double[] normalValue = normalizedTargetVector(inst);
+		double[] out = new double[getModelContext().numOutputAttributes()];
+		for (int i = 0; i < inst.numOutputAttributes(); i++) {
+			out[i] = Math.abs(normalValue[i] - normalPrediction[i]);
+		}
+		return out;
+	}
+
+
+	/**
+	 * Method for updating (training) the model using a new instance
+	 */
+	public void trainOnInstanceImpl(MultiLabelInstance inst) {
+		if (inst.weight() > 0) {
+			checkRoot();
+
+			double[] prediction = treeRoot.getPrediction(inst);
+			double[] normalError = getNormalizedError(inst, prediction);
+			
+			processInstance(inst, treeRoot, prediction, normalError, true, false);
+			
+			examplesSeen += inst.weight();
+			for (int i = 0; i < inst.numberOutputTargets(); i++) {
+				sumOfValues.addToValue(i, inst.weight() * inst.valueOutputAttribute(i));
+				sumOfSquares.addToValue(i, inst.weight() * inst.valueOutputAttribute(i) * inst.valueOutputAttribute(i));
+			}
+
+			for (int i = 0; i < inst.numInputAttributes(); i++) {
+				sumOfAttrValues.addToValue(i, inst.weight() * inst.valueInputAttribute(i));
+				sumOfAttrSquares.addToValue(i, inst.weight() * inst.valueInputAttribute(i) * inst.valueInputAttribute(i));
+			}
+			
+			//normalError.scaleValues(inst.weight());
+
+		}
+	}
+
+	public void processInstance(MultiLabelInstance inst, Node node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
+		Node currentNode = node;
+		while (true) {
+			if (currentNode instanceof LeafNode) {
+				((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
+				break;
+			} else {
+				currentNode.examplesSeen += inst.weight();
+				//currentNode.sumOfAbsErrors.addValues(normalError);
+				//				SplitNode iNode = (SplitNode) currentNode;
+				//				if (!inAlternate && iNode.alternateTree != null) {
+				//					boolean altTree = true;
+				//					double lossO = Math.pow(inst.valueOutputAttribute() - prediction, 2);
+				//					double lossA = Math.pow(inst.valueOutputAttribute() - iNode.alternateTree.getPrediction(inst), 2);
+				//
+				//					iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
+				//					iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
+				//					iNode.lossExamplesSeen++;
+				//
+				//					double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
+				//					double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+				//					iNode.lossSumQi += Qi;
+				//					iNode.lossNumQiTests += 1;
+				//					double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+				//
+				//					if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
+				//						iNode.previousWeight = iNode.lossExamplesSeen;
+				//						if (Qi > 0) {
+				//							SplitNode parent = currentNode.getParent();
+				//
+				//							if (parent != null) {
+				//								Node replacementTree = iNode.alternateTree;
+				//								parent.setChild(parent.getChildIndex(currentNode), replacementTree);
+				//								if (growthAllowed) replacementTree.restartChangeDetection();
+				//							} else {
+				//								treeRoot = iNode.alternateTree;
+				//								treeRoot.restartChangeDetection();
+				//							}
+				//
+				//							currentNode = iNode.alternateTree;
+				//							altTree = false;
+				//						} else if (
+				//								(QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * this.gracePeriodOption.getValue()))
+				//								|| iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()
+				//								) {
+				//							iNode.alternateTree = null;
+				//							if (growthAllowed) iNode.restartChangeDetection();
+				//							altTree = false;
+				//						}
+				//					}
+				//
+				//					if (altTree) {
+				//						growthAllowed = false;
+				//						processInstance(inst, iNode.alternateTree, prediction, normalError, true, true);
+				//					}
+				//				}
+
+				//				if (iNode.changeDetection && !inAlternate) {
+				//					if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+				//						iNode.initializeAlternateTree(this);
+				//					}
+				//				}
+				if (currentNode instanceof SplitNode) {
+					currentNode = ((SplitNode) currentNode).getChild(((SplitNode) currentNode).instanceChildIndex(inst));
+				} else { // if the replaced alternate tree is just a leaf node
+					((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
+					break;
+				}
+			}
+		}
+	}
+
+	//region --- Object instatiation methods
+
+	protected NumericStatisticsObserver newNumericClassObserver() {
+		return new MultiLabelBSTree();
+	}
+
+	public NominalStatisticsObserver newNominalClassObserver() {
+		return new MultiLabelNominalAttributeObserver();
+	}
+
+	//	protected SplitNode newSplitNode(InstanceConditionalTest splitTest) {
+	//		maxID++;
+	//		return new SplitNode(splitTest, this);
+	//	}
+
+	protected SplitNode newSplitNode(Predicate predicate) {
+		maxID++;
+		return new SplitNode(predicate, this);
+	}
+
+	protected LeafNode newLeafNode() {
+		maxID++;
+		return new LeafNode(this);
+	}
+
+	public MultitargetPerceptron newLeafModel() {
+		return new MultitargetPerceptron(this);
+	}
+
+	//endregion --- Object instatiation methods
+
+	//region --- Processing methods
+	protected void checkRoot() {
+		if (treeRoot == null) {
+			treeRoot = newLeafNode();
+			leafNodeCount = 1;
+		}
+	}
+
+	public static double computeHoeffdingBound(double range, double confidence, double n) {
+		return Math.sqrt(( (range * range) * Math.log(1 / confidence)) / (2.0 * n));
+	}
+
+	public boolean buildingModelTree() {
+		return !regressionTreeOption.isSet();
+	}
+
+	public boolean normalize() {
+		return !doNotNormalizeOption.isSet();
+	}
+
+	protected void attemptToSplit(LeafNode node, SplitNode parent, int parentIndex) {
+		//System.out.println("Evaluating splits");
+		//System.out.println(examplesSeen);
+		// Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
+		MultiLabelSplitCriterion splitCriterion = new ICVarianceReduction();
+
+		// Using this criterion, find the best split per attribute and rank the results
+		AttributeExpansionSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion); // TODO update with split criterion option
+		Arrays.sort(bestSplitSuggestions);
+
+		// Declare a variable to determine if any of the splits should be performed
+		boolean shouldSplit = false;
+
+		// If only one split was returned, use it
+		if (bestSplitSuggestions.length < 2) {
+			shouldSplit = bestSplitSuggestions.length > 0;
+		} else { // Otherwise, consider which of the splits proposed may be worth trying
+
+			// Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
+			// to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
+			double hoeffdingBound = computeHoeffdingBound(1, splitConfidenceOption.getValue(), node.examplesSeen);
+			// Determine the top two ranked splitting suggestions
+			AttributeExpansionSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+			AttributeExpansionSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
+
+			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
+			// as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
+			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
+			// splitting should occur.
+			// Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
+			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
+			// competing attributes are equally good, and the split will be made on the one with the higher SDR value.
+			//System.out.print(hoeffdingBound);
+			//System.out.print(" ");
+			///System.out.println(secondBestSuggestion.merit / bestSuggestion.merit);
+			if ((secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) || (hoeffdingBound < this.tieThresholdOption.getValue())) {
+				shouldSplit = true;
+			}
+			// If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
+			else {
+				// TODO pruning is currently disabled
+				for (int i = 0; i < node.attributeObservers.size(); i++) {
+					AttributeStatisticsObserver obs = node.attributeObservers.get(i);
+					if (obs != null) {
+						if (getModelContext().attribute(i).isNumeric());
+						//TODO obs.removeBadSplits(null, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound, getModelContext().numOutputAttributes());
+						if (getModelContext().attribute(i).isNominal());
+						// TODO nominal class observers
+					}
+				}
+			}
+			
+			if (hoeffdingBound < this.tieThresholdOption.getValue() && this.printLogsOption.isSet()) System.out.println("Forced to split due to tie at " + this.examplesSeen); 
+		}
+
+		// If the splitting criterion were met, split the current node using the chosen attribute test, and
+		// make two new branches leading to (empty) leaves
+		if (shouldSplit) {
+			if (node.parent == null && this.printLogsOption.isSet()) {
+				System.out.println("splitting root node at " + this.examplesSeen);
+			}
+			AttributeExpansionSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+
+			SplitNode newSplit = newSplitNode(splitDecision.predicate);
+			newSplit.copyStatistics(node);
+			newSplit.changeDetection = node.changeDetection;
+			newSplit.ID = node.ID;
+			leafNodeCount--;
+			//System.out.println("Splitting");
+			//System.out.println(examplesSeen);
+			for (int i = 0; i < 2; i++) { // Hardcoded for 2 values (due to the use of the Predicate class)
+				LeafNode newChild = newLeafNode();
+				if (buildingModelTree()) {
+					// Copy the splitting node's perceptron to it's children
+					newChild.learningModel = new MultitargetPerceptron(this, (MultitargetPerceptron) node.learningModel);
+
+				}
+				newChild.changeDetection = node.changeDetection;
+				newChild.setParent(newSplit);
+				newSplit.setChild(i, newChild);
+				leafNodeCount++;
+			}
+			if (parent == null && node.originalNode == null) {
+				treeRoot = newSplit;
+			} else if (parent == null && node.originalNode != null) {
+				node.originalNode.alternateTree = newSplit;
+			} else {
+				parent.setChild(parentIndex, newSplit);
+				newSplit.setParent(parent);
+			}
+
+			splitNodeCount++;
+		}
+	}
+
+	public  double computeSD(double squaredVal, double val, double size) {
+		if (size > 1)
+			return Math.sqrt((squaredVal - ((val * val) / size)) / size);
+		else
+			return 0.0;
+	}
+
+	public static double scalarProduct(DoubleVector u, DoubleVector v) {
+		double ret = 0.0;
+		for (int i = 0; i < Math.max(u.numValues(), v.numValues()); i++) {
+			ret += u.getValue(i) * v.getValue(i);
+		}
+		return ret;
+	}
+	//endregion --- Processing methods
+
+	//endregion ================ METHODS ================
+}
diff --git a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java b/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
index ebff655c3..1479c2b18 100644
--- a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
+++ b/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
@@ -1,920 +1,992 @@
- /*
- *    FFIMTDD.java
- *    Copyright (C) 2013 University of Porto, Portugal
- *    @author Katie de Lange, E. Almeida, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-/* Project Knowledge Discovery from Data Streams, FCT LIAAD-INESC TEC, 
- *
- * Contact: jgama@fep.up.pt
- */
-
- package moa.classifiers.trees;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Set;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import moa.AbstractMOAObject;
-import moa.classifiers.Regressor;
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
-import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
-import moa.classifiers.core.splitcriteria.SDRSplitCriterion;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.core.DoubleVector;
-import moa.options.ClassOption;
-import com.yahoo.labs.samoa.instances.Instance;
- 
-/*
- * Implementation of FIMTDD, regresion tree for data streams.
- */
- 
-public class FIMTDD extends HoeffdingTree implements Regressor{
-
-	private static final long serialVersionUID = 1L;
-
-	@Override
-	public String getPurposeString() {
-		return "Implementation of the FIMT-DD tree as described by Ikonomovska et al.";
-	}
-		
-	// For the moment at least, force the split criterion to be SDRSplitCriterion and the 
-	// numeric estimator to be FIMTLDDNumericAttributeClassObserver
-	public FIMTDD() {
-
-	    numericEstimatorOption = new ClassOption("numericEstimator",
-            'n', "Numeric estimator to use.", FIMTDDNumericAttributeClassObserver.class,
-            "FIMTDDNumericAttributeClassObserver");
-            
-            splitCriterionOption = new ClassOption("splitCriterion",
-            's', "Split criterion to use.", SDRSplitCriterion.class,
-            "SDRSplitCriterion");
-        }
-        
-        protected DoubleVector splitRatioStatistics = new DoubleVector();
-	
-        		// Store the lowest node in the tree that requires adaptation
-	protected ArrayList<FIMTDDSplitNode> nodesToAdapt = new ArrayList<FIMTDDSplitNode>();
-	
-	protected boolean Adaptable = true;
-	
-	protected double initLearnRate = 0.1;
-	
-	protected double learnRateDecay = 0.001;
-        
-    //============================= SET OPTIONS ==============================//
-
-	public FloatOption PageHinckleyAlphaOption = new FloatOption(
-	    "PageHinckleyAlpha",
-	    'a',
-	    "The alpha value to use in the Page Hinckley change detection tests.",
-	    0.005, 0.0, 1.0);   
-    
-	public IntOption PageHinckleyThresholdOption = new IntOption(
-	    "PageHinckleyThreshold",
-	    'h',
-	    "The threshold value to be used in the Page Hinckley change detection tests.",
-	    50, 0, Integer.MAX_VALUE);
-	
-	public FloatOption AlternateTreeFadingFactorOption = new FloatOption(
-	    "AlternateTreeFadingFactor",
-	    'f',
-	    "The fading factor to use when deciding if an alternate tree should replace an original.",
-	    0.995, 0.0, 1.0);
-	
-	public IntOption AlternateTreeTMinOption = new IntOption(
-	    "AlternateTreeTMin",
-	    'y',
-	    "The Tmin value to use when deciding if an alternate tree should replace an original.",
-	    150, 0, Integer.MAX_VALUE);
-	
-	public IntOption AlternateTreeTimeOption = new IntOption(
-	    "AlternateTreeTime",
-	    'u',
-	    "The 'time' (in terms of number of instances) value to use when deciding if an alternate tree should be discarded.",
-	    1500, 0, Integer.MAX_VALUE);
-	
-	public FloatOption learningRatioOption = new FloatOption("learningRatio", 'w', "Learning ratio to use for training the Perceptrons in the leaves.", 0.01);
-	
-	public FlagOption learningRatio_Decay_or_Const_Option = new FlagOption("learningRatio_Decay_or_Const", 'j',
-			"learning Ratio Decay or const parameter.");
-    
-    //=============================== CLASSES ================================//
-    
-     	     /**
-     	     * A new interface for nodes to be used in an adaptive setting
-     	     */
-     	     public interface AdaptationCompatibleNode {    	     	
-     	     	
-     	     	     public void setParent(Node parent);
-     	     	
-     	     	     public Node getParent();
-     	     }
-    
-    	     /**
-    	     * A modified ActiveLearningNode that uses a Perceptron as the leaf node
-    	     * model, and ensures that the class values sent to the attribute observers
-    	     * are not truncated to ints if regression is being performed
-    	     */
-	     public static class FIMTDDActiveLearningNode extends ActiveLearningNode implements AdaptationCompatibleNode{
-		
-		// Create a Perceptron model that carries out the actual learning in each node
-		public FIMTDDPerceptron learningModel = new FIMTDDPerceptron();
-		
-		// The parent of this particular leaf node
-		protected Node parent;
-		
-		// The statistics for this node:
-			// Number of instances that have reached it
-			// Sum of y values
-			// Sum of squared y values
-			protected DoubleVector nodeStatistics;
-		
-		// The error values for the Page Hinckley test
-			// PHmT = the cumulative sum of the errors
-			// PHMT = the minimum error value seen so far
-		protected double PHmT = 0;
-		protected double PHMT = Double.MAX_VALUE; 
-		
-		/**
-		 * Create a new FIMTDDActiveLearningNode
-		 */
-		public FIMTDDActiveLearningNode(double[] initialClassObservations) {
-			super(initialClassObservations);		
-			learningModel.resetLearningImpl();
-			nodeStatistics = new DoubleVector();
-		}
-	
-		/**
-		 * Set the parent node
-		 */
-		public void setParent(Node parent) {
-			this.parent = parent;	
-		}
-		
-		/**
-		 * Return the parent node
-		 */
-		public Node getParent() {
-			return parent;
-		}
-		
-		@Override
-		public double getWeightSeen() {
-			if(nodeStatistics != null)
-			{
-				return this.nodeStatistics.getValue(0);
-			}
-			else
-			{
-				return 0;
-			}
-		}
-		
-		@Override
-		/**
-		 * Method to learn from an instance that passes the new instance to the perceptron learner,
-		 * and also prevents the class value from being truncated to an int when it is passed to the
-		 * attribute observer
-		 */
-		public void learnFromInstance(Instance inst, HoeffdingTree ht) {
-		   // this.observedClassDistribution.addToValue((int)inst.classValue(),inst.weight());
-		   
-		    // Update the statistics for this node
-		    	// number of instances passing through the node
-		    	nodeStatistics.addToValue(0, 1);
-		    	// sum of y values
-		    	nodeStatistics.addToValue(1, inst.classValue());
-		    	// sum of squared y values
-		    	nodeStatistics.addToValue(2, inst.classValue() * inst.classValue());
-		    	// sum of absolute errors
-		    		// Normalise values prior to calculating absolute error
-		    		double sd = Math.sqrt((nodeStatistics.getValue(2) - ((nodeStatistics.getValue(1) * 
-				nodeStatistics.getValue(1))/nodeStatistics.getValue(0)))/nodeStatistics.getValue(0));
-				double mean = nodeStatistics.getValue(1) / nodeStatistics.getValue(0);
-		    	nodeStatistics.addToValue(3, Math.abs(((inst.classValue()-mean)/sd) - ((learningModel.prediction(inst)-mean)/sd)));
-		    	// sum of squared errors
-		    	nodeStatistics.setValue(4, Math.pow(this.getError(inst), 2) + nodeStatistics.getValue(4) * ((FIMTDD) ht).AlternateTreeFadingFactorOption.getValue());
-		    	
-		    	
-		    learningModel.trainOnInstanceImpl(inst, (FIMTDD)ht);
-
-		    for (int i = 0; i < inst.numAttributes() - 1; i++) {
-			int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
-			AttributeClassObserver obs = this.attributeObservers.get(i);
-			if (obs == null) {
-			    // At this stage all nominal attributes are ignored
-			    if(inst.attribute(instAttIndex).isNumeric())
-			    {
-			    	    obs = ((FIMTDD)ht).newNumericClassObserver();
-			    	    this.attributeObservers.set(i, obs);   
-			    }
-			}
-			if(obs != null)
-			{
-				((FIMTDDNumericAttributeClassObserver)obs).observeAttributeClass(inst.value(instAttIndex),inst.classValue(), inst.weight());
-			}
-		    }
-		}
-
-		@Override
-		/**
-		 * Return the best split suggestions for this node using the given split criteria
-		 */
-		public AttributeSplitSuggestion[] getBestSplitSuggestions(SplitCriterion criterion, HoeffdingTree ht) {
-		
-			List<AttributeSplitSuggestion> bestSuggestions = new LinkedList<AttributeSplitSuggestion>();
-			
-			// Set the nodeStatistics up as the preSplitDistribution, rather than the observedClassDistribution
-			double[] nodeSplitDist = this.nodeStatistics.getArrayCopy();
-			double[] preSplitDist = this.observedClassDistribution.getArrayCopy();
-			
-			if (!ht.noPrePruneOption.isSet()) {
-				// add null split as an option
-				bestSuggestions.add(new AttributeSplitSuggestion(null,new double[0][], criterion.getMeritOfSplit(nodeSplitDist,new double[][]{nodeSplitDist})));
-			}
-			for (int i = 0; i < this.attributeObservers.size(); i++) {
-				AttributeClassObserver obs = this.attributeObservers.get(i);
-				if (obs != null) {
-					
-					// AT THIS STAGE NON-NUMERIC ATTRIBUTES ARE IGNORED
-					AttributeSplitSuggestion bestSuggestion = null;
-					if(obs instanceof FIMTDDNumericAttributeClassObserver) {
-						bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion,nodeSplitDist, i, ht.binarySplitsOption.isSet());
-					}
-					
-					if (bestSuggestion != null) {
-						bestSuggestions.add(bestSuggestion);
-					}
-				}
-			}
-			return bestSuggestions.toArray(new AttributeSplitSuggestion[bestSuggestions.size()]);
-		}
-		
-		/**
-		 * Retrieve the class votes using the perceptron learner
-		 */
-		public double getPrediction(Instance inst, HoeffdingTree ht) {
-			return learningModel.prediction(inst);
-			
-		}
-		/**
-		* Retrieve the class votes using the target mean
-		 */
-		public double getPredictionTargetMean(Instance inst, HoeffdingTree ht) {
-			double valor = 0.0;
-			if(this.nodeStatistics.getValue(0) > 0.0){
-				valor = this.nodeStatistics.getValue(1)/this.nodeStatistics.getValue(0);
-				}
-			return valor;
-			}
-		
-		@Override
-		public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
-			double[] ret = new double[1];
-			double perceptronPrediction = getPrediction(inst, ht); // Prediction using perceptron
-			double targetMeanPrediction = getPredictionTargetMean(inst, ht); // Prediction using Target Mean
-			double perceptronError = Math.abs(inst.classValue() - perceptronPrediction);
-			double targetMeanError = Math.abs(inst.classValue() - targetMeanPrediction);
-			if(perceptronError < targetMeanError){ // Adaptative strategy
-				ret[0] = perceptronPrediction;
-			}else{
-				ret[0] = targetMeanPrediction;
-			}
-		
-			
-		 	return ret;
-		}
-		
-/*		@Override
-		public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
-			double[] ret = {getPrediction(inst, ht)};
-		 	return ret;
-		}*/
-		
-		/**
-		 * Return the error for a given instance
-		 */
-		public double getError(Instance inst)
-		{    	
-			return inst.classValue() - learningModel.prediction(inst);
-		}
-		
-		/**
-		 * A method returning the Page-Hinckley error produced on this instance in the leaf node,
-		 * which will then be back-propagated back through the tree to allow the 
-		 * Page-Hinckley change detection tests to be updated
-		 */
-		public double getPHError(Instance inst)
-		{
-			double sd = Math.sqrt((nodeStatistics.getValue(2) - ((nodeStatistics.getValue(1) * nodeStatistics.getValue(1))/nodeStatistics.getValue(0)))/nodeStatistics.getValue(0));
-			double mean = nodeStatistics.getValue(1) / nodeStatistics.getValue(0);
-			return Math.abs(((inst.classValue()-mean)/sd) - ((learningModel.prediction(inst)-mean)/sd)) -  ((nodeStatistics.getValue(3) + Math.abs(((inst.classValue()-mean)/sd) - ((learningModel.prediction(inst)-mean)/sd))) / (nodeStatistics.getValue(0)+1));
-		}
-		
-		/**
-		 * Returns the squared error, for use in determining if an alternate tree is performing better than an original
-		 * tree, or if the alternate tree should be deleted
-		 */
-		public double getSquaredError()
-		{
-			return nodeStatistics.getValue(4);
-		}
-	     }
-	    
-	     /**
-	     * A modified SplitNode method implementing the extra information regarding it's parent,
-	     * and the ability to track the error rate and perform Page-Hinckley tests
-	     */
-	     public static class FIMTDDSplitNode extends SplitNode implements AdaptationCompatibleNode {
-			
-	     	        // A reference to the parent of this node
-	     	     	protected Node parent;
-	     	     	
-	     	     	// The error values for the Page Hinckley test
-			// PHmT = the cumulative sum of the errors
-			// PHMT = the minimum error value seen so far
-			protected double PHmT = 0;
-			protected double PHMT = Double.MAX_VALUE; 
-			
-			// Scope for an alternate tree that may need to be grown from this node
-			protected FIMTDD alternateTree;
-			
-			// Keep track of the statistics for loss error calculations
-			protected DoubleVector lossStatistics = new DoubleVector();
-			
-			protected int weightSeen = 0;
-			protected int previousWeight = 0;
-			
-			/**
-			 * Create a new FIMTDDSplitNode
-			 */
-			public FIMTDDSplitNode(InstanceConditionalTest splitTest, double[] classObservations) {
-			      super(splitTest,classObservations);
-			}
-			
-			/**
-			* Set the parent node
-			*/
-			public void setParent(Node parent)
-			{
-			      this.parent = parent;	
-			}
-			
-			/**
-			* Return the parent node
-			*/
-			public Node getParent()
-			{
-			      return parent;
-			} 
-	     	      
-	     	      	/**
-			 * Check to see if the tree needs updating
-			 */
-			public boolean PageHinckleyTest(double error, double threshold)
-			{	
-				// Update the cumulative mT sum
-				PHmT += error;
-				
-				// Update the minimum mT value if the new mT is
-				// smaller than the current minimum
-				if(PHmT < PHMT)
-				{
-					PHMT = PHmT;
-				}
-				// Return true if the cumulative value - the current minimum is
-				// greater than the current threshold (in which case we should adapt)
-				return PHmT - PHMT > threshold;
-			}
-			
-			/**
-			 * This method has been added to the SplitNode subclass to allow alternate trees
-			 * to be grown and compared to the current tree, to allow adaptation in the face
-			 * of concept drift
-			 */
-			public void learnFromInstance(Instance inst, FIMTDD ht, boolean growingAltTree) {
-			
-				if(growingAltTree)
-				{
-					weightSeen++;
-					
-					// If no alternate tree exists		
-					if (this.alternateTree == null) 
-					{
-						// Start a new alternate tree, beginning with a learning node
-						this.alternateTree = (FIMTDD)ht.copy();
-						this.alternateTree.resetLearningImpl();
-						this.alternateTree.Adaptable = false;
-						
-						// Set up the blank statistics
-							// Number of instances reaching this node since the alternate tree was started	
-							lossStatistics.setValue(0,0);
-							// Sum of Qi values
-							lossStatistics.setValue(1,0);
-							weightSeen = 0;
-							previousWeight = 0;
-					} 	
-					
-					// If an alternate tree already exists, check if the current tree should be replaced with it,
-					// or if the alternate tree should be discarded.
-					else if(weightSeen - previousWeight >= ht.AlternateTreeTMinOption.getValue())
-					{
-						
-						// Update the weight at which a decision was tested for
-						previousWeight = weightSeen;
-						
-						// Update the loss statistics for the alternate tree
-						FoundNode foundNode = this.alternateTree.treeRoot.filterInstanceToLeaf(inst,null,-1);
-						Node leaf = foundNode.node;
-                                                double squaresAlternate= 0.0;
-                                                if(leaf instanceof FIMTDDActiveLearningNode)
-                                                {
-                                                    squaresAlternate = ((FIMTDDActiveLearningNode)leaf).getSquaredError();
-
-                                                }
-
-                                                // Update the loss statistics for the current tree
-                                                foundNode = this.getChild(this.instanceChildIndex(inst)).filterInstanceToLeaf(inst,null,-1);
-                                                leaf = foundNode.node;
-                                                double squaresOriginal = 0.0;
-                                                if(leaf instanceof FIMTDDActiveLearningNode)
-                                                {
-                                                   squaresOriginal = ((FIMTDDActiveLearningNode)leaf).getSquaredError();
-
-                                                }
-
-                                                // Compute the Qi statistics
-                                                double Qi = Math.log(squaresOriginal /squaresAlternate);
-						double previousQiAverage = lossStatistics.getValue(1) / lossStatistics.getValue(0);
-						lossStatistics.addToValue(0,1);
-						lossStatistics.addToValue(1,Qi);
-						double QiAverage = lossStatistics.getValue(1) / lossStatistics.getValue(0);
-						
-						// If appropriate, replace the current tree with the alternate tree
-						if(Qi > 0)
-						{
-							FIMTDDSplitNode parent = (FIMTDDSplitNode)this.parent;
-							//Replace the main FIMT-DD tree at a subtree
-							if(parent != null)
-							{
-								parent.setChild(parent.instanceChildIndex(inst),this.alternateTree.treeRoot);
-								ht.nodesToAdapt.remove(this);
-								this.alternateTree = null;
-							}
-							// Or occasionally at the root of the tree
-							else
-							{
-								ht = this.alternateTree;
-								ht.nodesToAdapt = new ArrayList<FIMTDDSplitNode>();
-								ht.Adaptable = true;
-								this.alternateTree = null;
-							}
-
-							
-						}
-						// Otherwise, check if the alternate tree should be discarded
-						else if (QiAverage < previousQiAverage && lossStatistics.getValue(0) >= (10 * ht.AlternateTreeTMinOption.getValue()) || weightSeen >= ht.AlternateTreeTimeOption.getValue())
-						{
-							ht.nodesToAdapt.remove(ht.nodesToAdapt.indexOf(this));
-							this.alternateTree = null;
-						}
-					}
-					
-					// Learn the alternate tree (if it has not just been discarded)
-					if(this.alternateTree != null)
-					{
-						this.alternateTree.trainOnInstanceImpl(inst);
-					}
-					 
-				
-				}
-				
-				// Determine which of the current children this instance should
-				// be sent to, and learn that child
-				int childBranch = this.instanceChildIndex(inst);
-				Node child = this.getChild(childBranch);
-				if (child != null) {
-					
-					if(child instanceof FIMTDDActiveLearningNode)
-					{
-						((FIMTDDActiveLearningNode)child).learnFromInstance(inst, ht);
-					}
-					else
-					{
-						((FIMTDDSplitNode)child).learnFromInstance(inst,ht, false);	
-					}
-				}
-			}
-			
-	     }
-	     
-	     /**
-	      * A Perceptron classifier modified to conform to the specifications of Ikonomovska et al.
-	      */
-	     public static class FIMTDDPerceptron extends AbstractMOAObject{
-			
-	     	    // The Perception weights 
-	     	    protected double[] weightAttribute; 
-	     	    
-	     	    // Statistics used for error calculations
-	     	    protected DoubleVector attributeStatistics = new DoubleVector();
-	     	    protected DoubleVector squaredAttributeStatistics = new DoubleVector();
-	     	    
-	     	    // The number of instances contributing to this model
-	     	    protected int instancesSeen = 0;
-	     	    
-	     	    // If the model should be reset or not
-	     	    protected boolean reset;
-	     	    
-	     	     @Override
-		    public void getDescription(StringBuilder sb, int indent) {
-			// TODO Auto-generated method stub
-		    }
-	     	     
-	     	    public FIMTDDPerceptron(FIMTDDPerceptron copy)
-	     	    {
-	     	    		this.weightAttribute = copy.getWeights(); 
-	     	    }
-	     	    
-	     	    public FIMTDDPerceptron()
-	     	    {
-	     	    	    this.reset = true;
-	     	    }
-	     	    
-	     	    public void setWeights(double[] w)
-	     	    {
-	     	    	this.weightAttribute = w;	    
-	     	    }
-	     	    
-	     	    public double[] getWeights()
-	     	    {
-	     	    	return this.weightAttribute;	    
-	     	    }
-	     	    
-	     	    /**
-	     	     * A method to reset the model
-	     	     */
-		    public void resetLearningImpl() {
-			this.reset = true;
-		    }
-		
-		    /**
-		     * Update the model using the provided instance
-		     */
-		    public void trainOnInstanceImpl(Instance inst, FIMTDD ft) {
-			
-			// Initialise Perceptron if necessary   
-			if (this.reset == true) {
-				this.reset = false;
-				this.weightAttribute = new double[inst.numAttributes()];
-				this.instancesSeen = 0;
-				this.attributeStatistics = new DoubleVector();
-				this.squaredAttributeStatistics = new DoubleVector();
-				for (int j = 0; j < inst.numAttributes(); j++) {
-				    weightAttribute[j] = 2 * Math.random() - 1;
-				}
-			}
-			
-			// Update attribute statistics
-			instancesSeen++;
-			for(int j = 0; j < inst.numAttributes() -1; j++)
-			{
-				attributeStatistics.addToValue(j, inst.value(j));	
-				squaredAttributeStatistics.addToValue(j, inst.value(j)*inst.value(j));
-			}
-			
-			// Update weights
-			
-			double learningRatio = 0.0;
-			if(ft.learningRatio_Decay_or_Const_Option.isSet()){
-				learningRatio = ft.learningRatioOption.getValue();
-			}else{
-				learningRatio = ft.initLearnRate / (1+ instancesSeen*ft.learnRateDecay);
-			}
-		//	double learningRatio = ft.learningRatioOption.getValue();
-			double actualClass = inst.classValue();
-			double predictedClass = this.prediction(inst);
-			
-			//System.out.println("Actual Class: " + actualClass + "  Prediction: " + predictedClass);
-
-			// SET DELTA TO ACTUAL - PREDICTED, NOT PREDICTED - ACTUAL AS SAID IN PAPER
-			double delta = actualClass - predictedClass;
-			
-			for (int j = 0; j < inst.numAttributes() - 1; j++) {
-				
-				if(inst.attribute(j).isNumeric())
-				{
-					// Update weights. Ensure attribute values are normalised first
-					double sd = Math.sqrt((squaredAttributeStatistics.getValue(j) - ((attributeStatistics.getValue(j) * attributeStatistics.getValue(j))/instancesSeen))/instancesSeen);
-					double instanceValue = 0;
-					if(sd > 0.0000001) // Limit found in implementation by Ikonomovska et al (2011)
-					{
-						instanceValue = (inst.value(j) - (attributeStatistics.getValue(j)/instancesSeen))/(3*sd);
-					}
-					this.weightAttribute[j] += learningRatio * delta * instanceValue;
-				}
-			}
-			this.weightAttribute[inst.numAttributes() - 1] += learningRatio * delta;
-		    }
-		    
-		    /**
-		     * Output the prediction made by this perceptron on the given instance
-		     */
-		    public double prediction(Instance inst)
-		    {
-			double prediction = 0;
-			if(this.reset == false)
-			{
-				for (int j = 0; j < inst.numAttributes() - 1; j++) {
-					if(inst.attribute(j).isNumeric())
-					{	
-						prediction += this.weightAttribute[j] * inst.value(j);
-					}
-				} 
-				prediction += this.weightAttribute[inst.numAttributes() - 1];
-			}
-			
-			// Return prediction to 3dp
-			return (double)Math.round(prediction * 1000) / 1000;
-		    }
-	     	     
-	     }
-	     
-	     
-
-    //=============================== METHODS ================================//
-        
-    	//================= TRAIN and TEST ================//
-    	    /**
-	     * Method for updating (training) the model using a new instance
-	     */
-	    @Override
-	    public void trainOnInstanceImpl(Instance inst) {
-		
-	    	// Convert any nominal attributes to numeric ones???
-	    	
-	    	// If no model exists yet, begin with an empty leaf node (the root)
-	    	if (this.treeRoot == null) {
-		    this.treeRoot = newLearningNode();
-		    this.activeLeafNodeCount = 1;
-		}
-		
-		// Take the current example and traverse it through the tree to a leaf
-		FoundNode foundNode = this.treeRoot.filterInstanceToLeaf(inst, null, -1);
-		Node leafNode = foundNode.node;
-		
-		// If no appropriate leaf already existed, create one
-		if (leafNode == null) {
-		    FIMTDDActiveLearningNode newNode = newLearningNode();
-		    foundNode.parent.setChild(foundNode.parentBranch, newNode);
-		    newNode.setParent(foundNode.parent);
-		    leafNode = newNode;
-		    this.activeLeafNodeCount++;
-		}
-        		
-		// Update the change detection tests on the path traversed in a bottom-up
-		// fashion (i.e. using the error from the leaf node)
-		if(leafNode instanceof FIMTDDActiveLearningNode)
-		{	
-			FIMTDDActiveLearningNode currentNode = (FIMTDDActiveLearningNode)leafNode;
-			
-			// Retrieve the error for the found leaf node
-			//currentNode.learnFromInstance(inst, this);
-			Double leafError = currentNode.getPHError(inst) - this.PageHinckleyAlphaOption.getValue();
-			
-			// Back-propagate the error through all the parent nodes
-			FIMTDDSplitNode parent = (FIMTDDSplitNode)currentNode.getParent();
-			while(parent != null && Adaptable)
-			{
-				// Update the Page-Hinckley error test in the parent node
-				if(parent.PageHinckleyTest(leafError, this.PageHinckleyThresholdOption.getValue()) == true)
-				{
-					if(!nodesToAdapt.contains(parent))
-					{
-						nodesToAdapt.add(parent);
-						nodesToAdapt.remove(parent.getChild(parent.instanceChildIndex(inst)));
-					}	
-				}
-
-				// Propagate back to the next parent node					
-				parent = (FIMTDDSplitNode)parent.getParent();			
-			}
-		}
-
-		if(nodesToAdapt.size() > 0 && Adaptable)
-		{
-			// Adapt the model tree by creating an alternate tree at this node which
-			// will be updated as new instances arrive and may, in time, replace the current subtree			
-			for(int i = 0; i < nodesToAdapt.size(); i++)
-			{
-				nodesToAdapt.get(i).learnFromInstance(inst, this, true);
-			}
-			
-		}
-		else
-		{
-			// Check that the current node is in fact a leaf node (i.e. that we
-			// haven't accidently stopped earlier in the tree)
-			if (leafNode instanceof LearningNode) {	
-				
-			    LearningNode learningNode = (LearningNode) leafNode;
-			    
-			    // Update the statistics in this leaf node, based on the new instance
-			    learningNode.learnFromInstance(inst, this);
-			    
-			    // Provided growth is allowed, and this leaf node hasn't been deactivated...
-			    if (this.growthAllowed && (learningNode instanceof FIMTDDActiveLearningNode)) {
-			    	
-			    	// Extract details about this leaf, and the number of examples it has seen
-				FIMTDDActiveLearningNode activeLearningNode = (FIMTDDActiveLearningNode) learningNode;			    
-				double weightSeen = activeLearningNode.getWeightSeen();
-				
-				// If it has seen Nmin examples since it was last tested for splitting, attempt a split of this node
-				if (weightSeen - activeLearningNode.getWeightSeenAtLastSplitEvaluation() >= this.gracePeriodOption.getValue()) {
-					
-					FIMTDD_attemptToSplit(activeLearningNode, (FIMTDDSplitNode)foundNode.parent, foundNode.parentBranch);
-				    
-				    // Take note of how many instances were seen when this split evaluation was made, so we know when to perform the next split evaluation
-				    activeLearningNode.setWeightSeenAtLastSplitEvaluation(weightSeen);
-				}
-			    }
-			}
-
-			/*if (this.trainingWeightSeenByModel% this.memoryEstimatePeriodOption.getValue() == 0) {
-			    estimateModelByteSizes();
-			}*/
-		}
-	    }
-	    
-	    	    
-	    /**
-	     * Method used to split a leaf node and generate child nodes, if appropriate
-	     */
-	    protected void FIMTDD_attemptToSplit(FIMTDDActiveLearningNode node, FIMTDDSplitNode parent, int parentIndex) {
-	    		
-	    	    // Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
-		    SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
-		    
-		    // Using this criterion, find the best split per attribute and rank the results
-		    AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion, this);
-		    Arrays.sort(bestSplitSuggestions);
-		    
-		    // Declare a variable to determine if any of the splits should be performed
-		    boolean shouldSplit = false;
-		    
-		    // If only one split was returned, use it
-		    if (bestSplitSuggestions.length < 2) {
-			shouldSplit = bestSplitSuggestions.length > 0;
-		    } 
-		    // Otherwise, consider which of the splits proposed may be worth trying
-		    else {
-		    	
-		    	// Determine the hoeffding bound value, used to select how many instances should be used to make a test decision
-		    	// to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
-			double hoeffdingBound = computeHoeffdingBound(1,this.splitConfidenceOption.getValue(), node.getWeightSeen());
-			
-			// Determine the top two ranked splitting suggestions
-			AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-			AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
-			
-			splitRatioStatistics.addToValue(0,1);
-			splitRatioStatistics.addToValue(1,secondBestSuggestion.merit / bestSuggestion.merit);
-			
-			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
-			// as determined using the hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
-			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
-			// splitting should occur.
-			// Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
-			// (default 0.05) is applied to the hoeffding bound; if the hoeffding bound is smaller than this limit then the two
-			// competing attributes are equally good, and the split will be made on the one with the higher SDR value.
-			if ((((splitRatioStatistics.getValue(1)/splitRatioStatistics.getValue(0)) + hoeffdingBound)  < 1) || (hoeffdingBound < this.tieThresholdOption.getValue())) {	
-				
-			    shouldSplit = true;
-			    
-			}
-			// If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
-			else
-			{
-				for (int i = 0; i < node.attributeObservers.size(); i++) {
-					AttributeClassObserver obs = node.attributeObservers.get(i);
-					if (obs != null) {
-						((FIMTDDNumericAttributeClassObserver)obs).removeBadSplits(splitCriterion, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound);	
-					}
-				}
-			}
-	
-			
-			// If the user has selected this option, it is also possible to remove poor attributes at this stage
-			if ((this.removePoorAttsOption != null)
-				&& this.removePoorAttsOption.isSet()) {
-			    Set<Integer> poorAtts = new HashSet<Integer>();
-			    // scan 1 - add any poor to set
-			    for (int i = 0; i < bestSplitSuggestions.length; i++) {
-				if (bestSplitSuggestions[i].splitTest != null) {
-				    int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
-				    if (splitAtts.length == 1) {
-					if (((bestSuggestion.merit / secondBestSuggestion.merit) + hoeffdingBound)  < 1) {
-					    poorAtts.add(new Integer(splitAtts[0]));
-					}
-				    }
-				}
-			    }
-			    // scan 2 - remove good ones from set
-			    for (int i = 0; i < bestSplitSuggestions.length; i++) {
-				if (bestSplitSuggestions[i].splitTest != null) {
-				    int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
-				    if (splitAtts.length == 1) {
-					if (((bestSuggestion.merit / secondBestSuggestion.merit) + hoeffdingBound)  < 1) {
-					    poorAtts.remove(new Integer(splitAtts[0]));
-					}
-				    }
-				}
-			    }
-			    for (int poorAtt : poorAtts) {
-				node.disableAttribute(poorAtt);
-			    }
-			}
-		    }
-		    
-		    // If the splitting criterion were met, split the current node using the chosen attribute test, and
-		    // make two new branches leading to (empty) leaves
-		    if (shouldSplit) {
-		    	    
-		    	  
-			AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-			
-			// Deactivate this node if the best split was to do nothing
-			if (splitDecision.splitTest == null) {
-			    // preprune - null wins
-			    deactivateLearningNode(node, parent, parentIndex);
-			} 
-			// Otherwise
-			else {
-				
-			    FIMTDDSplitNode newSplit = newSplitNode(splitDecision.splitTest,
-				    node.getObservedClassDistribution());
-			    for (int i = 0; i < splitDecision.numSplits(); i++) {
-				FIMTDDActiveLearningNode newChild = newLearningNode(splitDecision.resultingClassDistributionFromSplit(i));
-				newChild.learningModel = new FIMTDDPerceptron(node.learningModel);
-				newChild.setParent(newSplit);
-				newSplit.setChild(i, newChild);
-			    }
-			    this.activeLeafNodeCount--;
-			    this.decisionNodeCount++;
-			    this.activeLeafNodeCount += splitDecision.numSplits();
-			    if (parent == null) {
-				this.treeRoot = newSplit;
-			    } else {
-				parent.setChild(parentIndex, newSplit);
-				newSplit.setParent(parent);
-			    }
-			    
-			}
-			// Check the memory limits are not being exceeded
-			enforceTrackerLimit();
-		    }
-	    }	
-	    
-	    /**
-	     * Return an empty FIMTDDActiveLearningNode
-	     */
-	    protected FIMTDDActiveLearningNode newLearningNode() {
-	    	    return newLearningNode(new double[0]);
-	    }
-
-	    /**
-	     * Return a new FIMTDDActiveLearningNode using the initial class observations
-	     */
-	    protected FIMTDDActiveLearningNode newLearningNode(double[] initialClassObservations) {
-	    	    return new FIMTDDActiveLearningNode(initialClassObservations);
-	    }
-	    
-	    /**
-	     * Return a new FIMTDDSplitNode
-	     */
-	    protected FIMTDDSplitNode newSplitNode(InstanceConditionalTest splitTest,double[] classObservations) {
-	    	    return new FIMTDDSplitNode(splitTest, classObservations);
-	    }
-}
+/*
+ *    FIMTDD.java
+ *    Copyright (C) 2015 Jožef Stefan Institute, Ljubljana, Slovenia
+ *    @author Aljaž Osojnik <aljaz.osojnik@ijs.si>
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *    
+ *    
+ */
+
+package moa.classifiers.trees;
+
+import java.io.Serializable;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+
+import moa.options.ClassOption;
+import moa.AbstractMOAObject;
+import moa.classifiers.Regressor;
+import moa.classifiers.core.AttributeSplitSuggestion;
+import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
+import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
+import moa.classifiers.core.splitcriteria.SplitCriterion;
+import moa.classifiers.AbstractClassifier;
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.SizeOf;
+import moa.core.StringUtils;
+
+/*
+ * Implementation of FIMTDD, regression and model trees for data streams.
+ */
+
+public class FIMTDD extends AbstractClassifier implements Regressor {
+
+	private static final long serialVersionUID = 1L;
+
+	protected Node treeRoot;
+
+	protected int leafNodeCount = 0;
+	protected int splitNodeCount = 0;
+
+	protected double examplesSeen = 0.0;
+	protected double sumOfValues = 0.0;
+	protected double sumOfSquares = 0.0;
+
+	protected DoubleVector sumOfAttrValues = new DoubleVector();
+	protected DoubleVector sumOfAttrSquares = new DoubleVector();
+
+	public int maxID = 0;
+
+	//region ================ OPTIONS ================
+
+	public ClassOption splitCriterionOption = new ClassOption(
+			"splitCriterion", 's', "Split criterion to use.",
+			SplitCriterion.class, "moa.classifiers.core.splitcriteria.VarianceReductionSplitCriterion");
+
+	public IntOption gracePeriodOption = new IntOption(
+			"gracePeriod", 'g', "Number of instances a leaf should observe between split attempts.",
+			200, 0, Integer.MAX_VALUE);
+
+	public FloatOption splitConfidenceOption = new FloatOption(
+			"splitConfidence", 'c', "Allowed error in split decision, values close to 0 will take long to decide.",
+			0.0000001, 0.0, 1.0);
+
+	public FloatOption tieThresholdOption = new FloatOption(
+			"tieThreshold", 't', "Threshold below which a split will be forced to break ties.",
+			0.05, 0.0, 1.0);
+
+	public FloatOption PageHinckleyAlphaOption = new FloatOption(
+			"PageHinckleyAlpha", 'a', "Alpha value to use in the Page Hinckley change detection tests.",
+			0.005, 0.0, 1.0);
+
+	public IntOption PageHinckleyThresholdOption = new IntOption(
+			"PageHinckleyThreshold", 'h', "Threshold value used in the Page Hinckley change detection tests.",
+			50, 0, Integer.MAX_VALUE);
+
+	public FloatOption alternateTreeFadingFactorOption = new FloatOption(
+			"alternateTreeFadingFactor", 'f', "Fading factor used to decide if an alternate tree should replace an original.",
+			0.995, 0.0, 1.0);
+
+	public IntOption alternateTreeTMinOption = new IntOption(
+			"alternateTreeTMin", 'y', "Tmin value used to decide if an alternate tree should replace an original.",
+			150, 0, Integer.MAX_VALUE);
+
+	public IntOption alternateTreeTimeOption = new IntOption(
+			"alternateTreeTime", 'u', "The number of instances used to decide if an alternate tree should be discarded.",
+			1500, 0, Integer.MAX_VALUE);
+
+	public FlagOption regressionTreeOption = new FlagOption(
+			"regressionTree", 'e', "Build a regression tree instead of a model tree.");
+
+	public FloatOption learningRatioOption = new FloatOption(
+			"learningRatio", 'l', "Learning ratio to used for training the Perceptrons in the leaves.",
+			0.003, 0, 1.00);
+
+	public FloatOption learningRateDecayFactorOption = new FloatOption(
+			"learningRatioDecayFactor", 'd', "Learning rate decay factor (not used when learning rate is constant).",
+			0.001, 0, 1.00);
+
+	public FlagOption learningRatioConstOption = new FlagOption(
+			"learningRatioConst", 'p', "Keep learning rate constant instead of decaying.");
+
+	//endregion ================ OPTIONS ================
+
+	//region ================ CLASSES ================
+
+	public abstract static class Node extends AbstractMOAObject {
+
+		private static final long serialVersionUID = 1L;
+
+		public int ID;
+
+		protected FIMTDD tree;
+		
+		protected boolean changeDetection = true;
+		
+		protected Node parent;
+
+		protected Node alternateTree;
+		protected Node originalNode;
+
+		// The statistics for this node:
+		// Number of instances that have reached it
+		protected double examplesSeen;
+		// Sum of y values
+		protected double sumOfValues;
+		// Sum of squared y values
+		protected double sumOfSquares;
+		// Sum of absolute errors
+		protected double sumOfAbsErrors; // Needed for PH tracking of mean error
+
+		public Node(FIMTDD tree) {
+			this.tree = tree;
+			ID = tree.maxID; 
+		}
+
+		public void copyStatistics(Node node) {
+			examplesSeen = node.examplesSeen;
+			sumOfValues = node.sumOfValues;
+			sumOfSquares = node.sumOfSquares;
+			sumOfAbsErrors = node.sumOfAbsErrors;
+		}
+
+		public int calcByteSize() {
+			return (int) SizeOf.fullSizeOf(this);
+		}
+
+		/**
+		 * Set the parent node
+		 */
+		public void setParent(Node parent) {
+			this.parent = parent;    
+		}
+
+		/**
+		 * Return the parent node
+		 */
+		public Node getParent() {
+			return parent;
+		}
+
+		public void disableChangeDetection() {
+			changeDetection = false;
+		}
+
+		public void restartChangeDetection() {
+			changeDetection = true;
+		}
+		
+		public void getDescription(StringBuilder sb, int indent) {
+			
+		}
+
+		public double getPrediction(Instance inst) {
+			return 0;
+		}
+		
+		public void describeSubtree(StringBuilder out, int indent) {
+			StringUtils.appendIndented(out, indent, "Leaf");
+		}
+		
+		public int getLevel() {
+			Node target = this;
+			int level = 0;
+			while (target.getParent() != null) {
+				if (target.skipInLevelCount()) {
+					target = target.getParent();
+					continue;
+				}
+				level = level + 1;
+				target = target.getParent();
+			}
+			if (target.originalNode == null) {
+				return level;
+			} else {
+				return level + originalNode.getLevel();
+			}
+		}
+
+		public void setChild(int parentBranch, Node node) {
+		}
+
+		public int getChildIndex(Node child) {
+			return -1;
+		}
+
+		public int getNumSubtrees() {
+			return 1;
+		}
+
+		protected boolean skipInLevelCount() {
+			return false;
+		}
+	}
+
+	public static class LeafNode extends Node {
+
+		private static final long serialVersionUID = 1L;
+
+		public double errorModel = 0.0;
+		public double errorTargetMean = 0.0;
+		
+		// Perceptron model that carries out the actual learning in each node
+		public FIMTDDPerceptron learningModel;
+
+		protected AutoExpandVector<FIMTDDNumericAttributeClassObserver> attributeObservers = new AutoExpandVector<FIMTDDNumericAttributeClassObserver>();
+		
+		protected double examplesSeenAtLastSplitEvaluation = 0;
+
+		/**
+		 * Create a new LeafNode
+		 */
+		public LeafNode(FIMTDD tree) {
+			super(tree);
+			if (tree.buildingModelTree()) {
+				learningModel = tree.newLeafModel();
+			}
+			examplesSeen = 0;
+			sumOfValues = 0;
+			sumOfSquares = 0;
+			sumOfAbsErrors = 0;
+		}
+
+		public void setChild(int parentBranch, Node node) {
+		}
+
+		public int getChildIndex(Node child) {
+			return -1;
+		}
+
+		public int getNumSubtrees() {
+			return 1;
+		}
+
+		protected boolean skipInLevelCount() {
+			return false;
+		}
+		
+		/**
+		 * Method to learn from an instance that passes the new instance to the perceptron learner,
+		 * and also prevents the class value from being truncated to an int when it is passed to the
+		 * attribute observer
+		 */
+		public void learnFromInstance(Instance inst, boolean growthAllowed, double prediction) {
+			//The prediction must be calculated here -- it may be different from the tree's prediction due to alternate trees
+			
+			// Update the statistics for this node
+			// number of instances passing through the node
+			examplesSeen += inst.weight();
+
+			// sum of y values
+			sumOfValues += inst.weight() * inst.classValue();
+
+			// sum of squared y values
+			sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
+
+			// sum of absolute errors
+			sumOfAbsErrors += inst.weight() * Math.abs(tree.normalizeTargetValue(Math.abs(inst.classValue() - prediction)));
+			
+			if (tree.buildingModelTree()) {
+				double predictionModel = getPredictionModel(inst);
+				double predictionTargetMean = getPredictionTargetMean(inst);
+				
+				errorModel = errorModel * 0.95 + Math.abs(predictionModel - inst.classValue());
+				errorTargetMean = errorTargetMean * 0.95 + Math.abs(predictionTargetMean - inst.classValue());
+				
+				learningModel.updatePerceptron(inst);
+			}
+
+			for (int i = 0; i < inst.numAttributes() - 1; i++) {
+				int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
+				FIMTDDNumericAttributeClassObserver obs = attributeObservers.get(i);
+				if (obs == null) {
+					// At this stage all nominal attributes are ignored
+					if (inst.attribute(instAttIndex).isNumeric()) {
+						obs = tree.newNumericClassObserver();
+						this.attributeObservers.set(i, obs);
+					}
+				}
+				if (obs != null) {
+					obs.observeAttributeClass(inst.value(instAttIndex), inst.classValue(), inst.weight());
+				}
+			}
+
+			if (growthAllowed) {
+				checkForSplit();
+			}
+		}
+
+		/**
+		 * Return the best split suggestions for this node using the given split criteria
+		 */
+		public AttributeSplitSuggestion[] getBestSplitSuggestions(SplitCriterion criterion) {
+
+			List<AttributeSplitSuggestion> bestSuggestions = new LinkedList<AttributeSplitSuggestion>();
+
+			// Set the nodeStatistics up as the preSplitDistribution, rather than the observedClassDistribution
+			double[] nodeSplitDist = new double[] {examplesSeen, sumOfValues, sumOfSquares};
+
+			for (int i = 0; i < this.attributeObservers.size(); i++) {
+				FIMTDDNumericAttributeClassObserver obs = this.attributeObservers.get(i);
+				if (obs != null) {
+
+					// AT THIS STAGE NON-NUMERIC ATTRIBUTES ARE IGNORED
+					AttributeSplitSuggestion bestSuggestion = null;
+					if (obs instanceof FIMTDDNumericAttributeClassObserver) {
+						bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion, nodeSplitDist, i, true);
+					}
+
+					if (bestSuggestion != null) {
+						bestSuggestions.add(bestSuggestion);
+					}
+				}
+			}
+			return bestSuggestions.toArray(new AttributeSplitSuggestion[bestSuggestions.size()]);
+		}
+
+		/**
+		 * Retrieve the class votes using the perceptron learner
+		 */
+		public double getPredictionModel(Instance inst) {
+			return learningModel.prediction(inst);
+		}
+
+		public double getPredictionTargetMean(Instance inst) {
+			return (examplesSeen > 0.0) ? sumOfValues / examplesSeen : 0.0;
+		}
+
+		public double getPrediction(Instance inst) {
+			if (tree.buildingModelTree()) {
+				//return getPredictionModel(inst);
+				return (errorModel < errorTargetMean) ? getPredictionModel(inst) : getPredictionTargetMean(inst);
+			} else
+				return getPredictionTargetMean(inst);
+		}
+		
+		public void checkForSplit() {
+			// If it has seen Nmin examples since it was last tested for splitting, attempt a split of this node
+			if (examplesSeen - examplesSeenAtLastSplitEvaluation >= tree.gracePeriodOption.getValue()) {
+				int index = (parent != null) ? parent.getChildIndex(this) : 0;
+				tree.attemptToSplit(this, parent, index);
+
+				// Take note of how many instances were seen when this split evaluation was made, so we know when to perform the next split evaluation
+				examplesSeenAtLastSplitEvaluation = examplesSeen;
+			}
+		}
+
+		public void describeSubtree(StringBuilder out, int indent) {
+			StringUtils.appendIndented(out, indent, "Leaf ");
+			if (tree.buildingModelTree()) {
+				learningModel.getModelDescription(out, 0);
+			} else {
+				out.append(tree.getClassNameString() + " = " + String.format("%.4f", sumOfValues / examplesSeen));
+				StringUtils.appendNewline(out);
+			}
+		}
+	}
+
+	public abstract static class InnerNode extends Node {
+		// The InnerNode and SplitNode design is used for easy extension in ORTO
+		private static final long serialVersionUID = 1L;
+
+		protected AutoExpandVector<Node> children = new AutoExpandVector<Node>();
+
+		// The error values for the Page Hinckley test
+		// PHmT = the cumulative sum of the errors
+		// PHMT = the minimum error value seen so far
+		protected double PHsum = 0;
+		protected double PHmin = Double.MAX_VALUE;
+
+		// Keep track of the statistics for loss error calculations
+		protected double lossExamplesSeen;
+		protected double lossFadedSumOriginal;
+		protected double lossFadedSumAlternate;
+		protected double lossNumQiTests;
+		protected double lossSumQi;
+		protected double previousWeight = 0;
+		
+		public InnerNode(FIMTDD tree) {
+			super(tree);
+		}
+
+		public int numChildren() {
+			return children.size();
+		}
+
+		public Node getChild(int index) {
+			return children.get(index);
+		}
+
+		public int getChildIndex(Node child) {
+			return children.indexOf(child);
+		}
+
+		public void setChild(int index, Node child) {
+			children.set(index, child);
+		}
+
+		public void disableChangeDetection() {
+			changeDetection = false;
+			for (Node child : children) {
+				child.disableChangeDetection();
+			}
+		}
+
+		public void restartChangeDetection() {
+			if (alternateTree == null) {
+				changeDetection = true;
+				PHsum = 0;
+				PHmin = Integer.MAX_VALUE;
+				for (Node child : children)
+					child.restartChangeDetection();
+			}
+		}
+		
+		/**
+		 * Check to see if the tree needs updating
+		 */
+		public boolean PageHinckleyTest(double error, double threshold) {    
+			// Update the cumulative mT sum
+			PHsum += error;
+
+			// Update the minimum mT value if the new mT is
+			// smaller than the current minimum
+			if(PHsum < PHmin) {
+				PHmin = PHsum;
+			}
+			// Return true if the cumulative value - the current minimum is
+			// greater than the current threshold (in which case we should adapt)
+			return PHsum - PHmin > threshold;
+		}
+		
+		public void initializeAlternateTree() {
+			// Start a new alternate tree, beginning with a learning node
+			alternateTree = tree.newLeafNode();
+			alternateTree.originalNode = this;
+
+			// Set up the blank statistics
+			// Number of instances reaching this node since the alternate tree was started
+			lossExamplesSeen = 0;
+			// Faded squared error (original tree)
+			lossFadedSumOriginal = 0;
+			// Faded squared error (alternate tree)
+			lossFadedSumAlternate = 0;
+			// Number of evaluations of alternate tree
+			lossNumQiTests = 0;
+			// Sum of Qi values
+			lossSumQi = 0;
+			// Number of examples at last test
+			previousWeight = 0;
+
+			// Disable the change detection mechanism bellow this node
+			disableChangeDetection();
+		}
+	}
+	
+	public static class SplitNode extends InnerNode {
+
+		private static final long serialVersionUID = 1L;
+
+		protected InstanceConditionalTest splitTest;
+
+		/**
+		 * Create a new SplitNode
+		 * @param tree 
+		 */
+		public SplitNode(InstanceConditionalTest splitTest, FIMTDD tree) {
+			super(tree);
+			this.splitTest = splitTest;
+		}
+
+		public int instanceChildIndex(Instance inst) {
+			return splitTest.branchForInstance(inst);
+		}
+		
+		public Node descendOneStep(Instance inst) {
+			return children.get(splitTest.branchForInstance(inst));
+		}
+
+		public void describeSubtree(StringBuilder out, int indent) {
+			for (int branch = 0; branch < children.size(); branch++) {
+				Node child = getChild(branch);
+				if (child != null) {
+					StringUtils.appendIndented(out, indent, "if ");
+					out.append(this.splitTest.describeConditionForBranch(branch,
+							tree.getModelContext()));
+					out.append(": ");
+					StringUtils.appendNewline(out);
+					child.describeSubtree(out, indent + 2);
+				}
+			}
+		}
+
+		public double getPrediction(Instance inst) {
+			return children.get(splitTest.branchForInstance(inst)).getPrediction(inst);
+		}
+	}
+
+	public class FIMTDDPerceptron implements Serializable {
+
+		private static final long serialVersionUID = 1L;
+		
+		protected FIMTDD tree;
+		
+		// The Perception weights 
+		protected double[] weightAttribute; 
+
+		// The number of instances contributing to this model
+		protected double instancesSeen = 0;
+
+		public String getPurposeString() {
+			return "A perceptron regressor as specified by Ikonomovska et al. used for FIMTDD";
+		}
+
+		public FIMTDDPerceptron(FIMTDDPerceptron original) {
+			this.tree = original.tree;
+			weightAttribute = original.weightAttribute.clone();
+		}
+
+		public FIMTDDPerceptron(FIMTDD tree) {
+			this.tree = tree;
+			initializeWeights();
+
+		}
+
+		public void initializeWeights() {
+			weightAttribute = new double[tree.getModelContext().numInputAttributes()+1];
+			instancesSeen = 0;
+			for (int j = 0; j < tree.getModelContext().numInputAttributes()+1; j++) {
+				// The last index corresponds to the constant b
+				weightAttribute[j] = 2 * tree.classifierRandom.nextDouble() - 1;
+			}
+			normalizeWeights();
+		}
+		
+		/**
+		 * Update the model using the provided instance
+		 */
+		public void updatePerceptron(Instance inst) {
+
+			// Update attribute statistics
+			instancesSeen += inst.weight();
+
+			// Update weights
+			double learningRatio = 0.0;
+			if (tree.learningRatioConstOption.isSet()) {
+				learningRatio = learningRatioOption.getValue();
+			} else {
+				learningRatio = learningRatioOption.getValue() / (1 + instancesSeen * tree.learningRateDecayFactorOption.getValue());
+			}
+
+			// Loop for compatibility with bagging methods 
+			for (int i = 0; i < (int) inst.weight(); i++) {
+				updateWeights(inst, learningRatio);
+			}
+		
+		}
+
+		public void updateWeights(Instance inst, double learningRatio) {
+			// Compute the normalized instance and the delta
+			double[] normalizedInstance = normalizedInstance(inst); 
+			double normalizedPrediction = prediction(normalizedInstance);
+			double normalizedValue = tree.normalizeTargetValue(inst.classValue());
+			double delta = normalizedValue - normalizedPrediction;
+			for (int i = 0; i < weightAttribute.length; i++) {
+				weightAttribute[i] += delta * learningRatio * normalizedInstance[i];
+			}
+			
+			normalizeWeights();
+		}
+		
+		public void normalizeWeights() {
+			double sum = 0;
+			for (int i = 0; i < this.weightAttribute.length; i++)
+				sum += Math.abs(weightAttribute[i]);
+			for (int i = 0; i < this.weightAttribute.length; i++)
+				weightAttribute[i] /= sum;
+		}
+
+		public double[] normalizedInstance(Instance inst) {
+			// Normalize Instance
+			double[] normalizedInstance = new double[inst.numInputAttributes()+1];
+			for (int j = 0; j < inst.numInputAttributes(); j++) {
+				double mean = tree.sumOfAttrValues.getValue(j) / tree.examplesSeen;
+				double sd = computeSD(tree.sumOfAttrSquares.getValue(j), tree.sumOfAttrValues.getValue(j), tree.examplesSeen);
+				if (inst.inputAttribute(j).isNumeric() && tree.examplesSeen > 1 && sd > 0.0000001)
+					normalizedInstance[j] = (inst.valueInputAttribute(j) - mean) / (sd);
+				else
+					normalizedInstance[j] = 0;
+			}
+			normalizedInstance[inst.numInputAttributes()] = tree.examplesSeen > 1 ? 1 : 0; // Value to be multiplied with the constant factor
+			return normalizedInstance;
+		}
+
+		/**
+		 * Output the prediction made by this perceptron on the given instance
+		 */
+		public double prediction(double[] instanceValues) {
+			double ret = 0;
+			for (int i = 0; i < instanceValues.length; i++)
+				ret += instanceValues[i] * weightAttribute[i];
+			return ret;
+		}
+
+		protected double prediction(Instance inst) {
+			double[] normalizedInstance = normalizedInstance(inst);
+			double normalizedPrediction = prediction(normalizedInstance);
+			return denormalizePrediction(normalizedPrediction);
+		}
+
+		private double denormalizePrediction(double normalizedPrediction) {
+			double mean = tree.sumOfValues / tree.examplesSeen;
+			double sd = computeSD(tree.sumOfSquares, tree.sumOfValues, tree.examplesSeen);
+			if (examplesSeen > 1) 
+				return normalizedPrediction * sd + mean;
+			else
+				return 0.0;
+		}
+		
+		public void getModelDescription(StringBuilder out, int indent) {
+	        StringUtils.appendIndented(out, indent, getClassNameString() + " =");
+			if (getModelContext() != null) {
+				for (int j = 0; j < getModelContext().numAttributes() - 1; j++) {
+					if (getModelContext().attribute(j).isNumeric()) {
+						out.append((j == 0 || weightAttribute[j] < 0) ? " " : " + ");
+		                out.append(String.format("%.4f", weightAttribute[j]));
+		                out.append(" * ");
+		                out.append(getAttributeNameString(j));
+		            }
+		        }
+				out.append(" + " + weightAttribute[getModelContext().numInputAttributes()]);
+			}
+	        StringUtils.appendNewline(out);
+		}
+	}
+
+
+	//endregion ================ CLASSES ================
+
+	//region ================ METHODS ================
+
+	// region --- Regressor methods
+	
+	public String getPurposeString() {
+		return "Implementation of the FIMT-DD tree as described by Ikonomovska et al.";
+	}
+
+	public void resetLearningImpl() {
+		this.treeRoot = null;
+		this.leafNodeCount = 0;
+		this.splitNodeCount = 0;
+		this.maxID = 0;
+		this.examplesSeen = 0;
+		this.sumOfValues = 0.0;
+		this.sumOfSquares = 0.0;
+
+		this.sumOfAttrValues = new DoubleVector();
+		this.sumOfAttrSquares = new DoubleVector();
+	}
+
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	public void getModelDescription(StringBuilder out, int indent) {
+		if (treeRoot != null) treeRoot.describeSubtree(out, indent);
+	}
+
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[]{ 
+				new Measurement("tree size (leaves)", this.leafNodeCount)
+		};
+	}
+
+	public int calcByteSize() {
+		return (int) SizeOf.fullSizeOf(this);
+	}
+
+	public double[] getVotesForInstance(Instance inst) {
+		if (treeRoot == null) {
+			return new double[] {0};
+		}
+
+		double prediction = treeRoot.getPrediction(inst);
+
+		return new double[] {prediction};
+	}
+
+	public double normalizeTargetValue(double value) {
+		if (examplesSeen > 1) {
+			double sd = Math.sqrt((sumOfSquares - ((sumOfValues * sumOfValues)/examplesSeen))/examplesSeen);
+			double average = sumOfValues / examplesSeen;
+			if (sd > 0 && examplesSeen > 1)
+				return (value - average) / sd;
+			else
+				return 0.0;
+		}
+		return 0.0;
+	}
+
+	public double getNormalizedError(Instance inst, double prediction) {
+		double normalPrediction = normalizeTargetValue(prediction);
+		double normalValue = normalizeTargetValue(inst.classValue());
+		return Math.abs(normalValue - normalPrediction);
+	}
+
+
+	/**
+	 * Method for updating (training) the model using a new instance
+	 */
+	public void trainOnInstanceImpl(Instance inst) {
+		checkRoot();
+
+		double prediction = treeRoot.getPrediction(inst);
+		double normalError = getNormalizedError(inst, prediction);
+	
+		processInstance(inst, treeRoot, prediction, normalError, true, false);
+		
+		examplesSeen += inst.weight();
+		sumOfValues += inst.weight() * inst.classValue();
+		sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
+
+		for (int i = 0; i < inst.numAttributes() - 1; i++) {
+			int aIndex = modelAttIndexToInstanceAttIndex(i, inst);
+			sumOfAttrValues.addToValue(i, inst.weight() * inst.value(aIndex));
+			sumOfAttrSquares.addToValue(i, inst.weight() * inst.value(aIndex) * inst.value(aIndex));
+		}
+
+
+	}
+
+	public void processInstance(Instance inst, Node node, double prediction, double normalError, boolean growthAllowed, boolean inAlternate) {
+		Node currentNode = node;
+		while (true) {
+			if (currentNode instanceof LeafNode) {
+				((LeafNode) currentNode).learnFromInstance(inst, growthAllowed, prediction);
+				break;
+			} else {
+				currentNode.examplesSeen += inst.weight();
+				currentNode.sumOfAbsErrors += inst.weight() * normalError;
+				InnerNode iNode = (InnerNode) currentNode;
+				if (!inAlternate && iNode.alternateTree != null) {
+					boolean altTree = true;
+					double lossO = Math.pow(inst.classValue() - prediction, 2);
+					double lossA = Math.pow(inst.classValue() - iNode.alternateTree.getPrediction(inst), 2);
+					
+					// Loop for compatibility with bagging methods
+					for (int i = 0; i < inst.weight(); i++) {
+						iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
+						iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
+						iNode.lossExamplesSeen++;
+						
+						double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
+						iNode.lossSumQi += Qi;
+						iNode.lossNumQiTests += 1;
+					}
+					double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
+					double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+					double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+					
+					if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
+						iNode.previousWeight = iNode.lossExamplesSeen;
+						if (Qi > 0) {
+							// Switch the subtrees
+							Node parent = iNode.getParent();
+
+							if (parent != null) {
+								Node replacementTree = iNode.alternateTree;
+								parent.setChild(parent.getChildIndex(iNode), replacementTree);
+								if (growthAllowed) replacementTree.restartChangeDetection();
+							} else {
+								treeRoot = iNode.alternateTree;
+								treeRoot.restartChangeDetection();
+							}
+
+							currentNode = iNode.alternateTree;
+							currentNode.originalNode = null;
+							altTree = false;
+						} else if (QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * alternateTreeTMinOption.getValue()) || iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()) {
+							// Remove the alternate tree
+							iNode.alternateTree = null;
+							if (growthAllowed) iNode.restartChangeDetection();
+							altTree = false;
+						}
+					}
+
+					if (altTree) {
+						growthAllowed = false;
+						processInstance(inst, iNode.alternateTree, prediction, normalError, true, true);
+					}
+				}
+
+				if (false && iNode.changeDetection && !inAlternate) {
+					if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+						iNode.initializeAlternateTree();
+						growthAllowed = false;
+					}
+				}
+				if (currentNode instanceof SplitNode) {
+					currentNode = ((SplitNode) currentNode).descendOneStep(inst);
+				} 
+			}
+		}
+	}
+
+	// endregion --- Regressor methods
+	
+	// region --- Object instatiation methods
+
+	protected FIMTDDNumericAttributeClassObserver newNumericClassObserver() {
+		return new FIMTDDNumericAttributeClassObserver();
+	}
+
+	protected SplitNode newSplitNode(InstanceConditionalTest splitTest) {
+		maxID++;
+		return new SplitNode(splitTest, this);
+	}
+
+	protected LeafNode newLeafNode() {
+		maxID++;
+		return new LeafNode(this);
+	}
+
+	protected FIMTDDPerceptron newLeafModel() {
+		return new FIMTDDPerceptron(this);
+	}
+
+	//endregion --- Object instatiation methods
+	
+	// region --- Processing methods
+	
+	protected void checkRoot() {
+		if (treeRoot == null) {
+			treeRoot = newLeafNode();
+			leafNodeCount = 1;
+		}
+	}
+
+	public static double computeHoeffdingBound(double range, double confidence, double n) {
+		return Math.sqrt(( (range * range) * Math.log(1 / confidence)) / (2.0 * n));
+	}
+
+	public boolean buildingModelTree() {
+		return !regressionTreeOption.isSet();
+	}
+
+	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
+
+		// Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
+ 		SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
+
+		// Using this criterion, find the best split per attribute and rank the results
+		AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion);
+		Arrays.sort(bestSplitSuggestions);
+
+		// Declare a variable to determine if any of the splits should be performed
+		boolean shouldSplit = false;
+
+		// If only one split was returned, use it
+		if (bestSplitSuggestions.length < 2) {
+			shouldSplit = bestSplitSuggestions.length > 0;
+		} else { // Otherwise, consider which of the splits proposed may be worth trying
+
+			// Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
+			// to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
+			double hoeffdingBound = computeHoeffdingBound(1, this.splitConfidenceOption.getValue(), node.examplesSeen);
+			// Determine the top two ranked splitting suggestions
+			AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+			AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
+
+			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
+			// as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
+			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
+			// splitting should occur.
+			// Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
+			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
+			// competing attributes are equally good, and the split will be made on the one with the higher SDR value.
+			if ((secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) || (hoeffdingBound < this.tieThresholdOption.getValue())) {
+				shouldSplit = true;
+			}
+			// If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
+			else {
+				for (int i = 0; i < node.attributeObservers.size(); i++) {
+					FIMTDDNumericAttributeClassObserver obs = node.attributeObservers.get(i);
+					if (obs != null) {
+						obs.removeBadSplits(splitCriterion, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound);    
+					}
+				}
+			}
+//			if (hoeffdingBound < this.tieThresholdOption.getValue() && !(secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound)) {
+//				System.out.println("Forced to split due to tie at " + this.examplesSeen);
+//				System.out.println(SizeOf.fullSizeOf(node.attributeObservers) / 1000000.0);
+//			}
+		}
+
+		// If the splitting criterion were met, split the current node using the chosen attribute test, and
+		// make two new branches leading to (empty) leaves
+		if (shouldSplit) {
+//			System.out.println("splitting node");
+//			System.out.println(SizeOf.fullSizeOf(node.attributeObservers) / 1000000.0);
+//			if (node.parent == null) {
+//				System.out.println("splitting root node at " + this.examplesSeen);
+//			}
+			AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+						
+			SplitNode newSplit = newSplitNode(splitDecision.splitTest);
+			newSplit.copyStatistics(node);
+			newSplit.changeDetection = node.changeDetection;
+			newSplit.ID = node.ID;
+			leafNodeCount--;
+			for (int i = 0; i < splitDecision.numSplits(); i++) {
+				LeafNode newChild = newLeafNode();
+				if (buildingModelTree()) {
+					// Copy the splitting node's perceptron to it's children
+					newChild.learningModel = new FIMTDDPerceptron((FIMTDDPerceptron) node.learningModel);
+					
+				}
+				newChild.changeDetection = node.changeDetection;
+				newChild.setParent(newSplit);
+				newSplit.setChild(i, newChild);
+				leafNodeCount++;
+			}
+			if (parent == null && node.originalNode == null) {
+				treeRoot = newSplit;
+			} else if (parent == null && node.originalNode != null) {
+				node.originalNode.alternateTree = newSplit;
+			} else {
+				((SplitNode) parent).setChild(parentIndex, newSplit);
+				newSplit.setParent(parent);
+			}
+			
+			splitNodeCount++;
+		}
+	}
+	
+	public double computeSD(double squaredVal, double val, double size) {
+		if (size > 1)
+			return Math.sqrt((squaredVal - ((val * val) / size)) / size);
+		else
+			return 0.0;
+	}
+	
+	public double scalarProduct(DoubleVector u, DoubleVector v) {
+		double ret = 0.0;
+		for (int i = 0; i < Math.max(u.numValues(), v.numValues()); i++) {
+			ret += u.getValue(i) * v.getValue(i);
+		}
+		return ret;
+	}
+	//endregion --- Processing methods
+	
+	//endregion ================ METHODS ================
+}
+
diff --git a/moa/src/main/java/moa/classifiers/trees/ORTO.java b/moa/src/main/java/moa/classifiers/trees/ORTO.java
index fcdff7f73..d0a6ab79d 100644
--- a/moa/src/main/java/moa/classifiers/trees/ORTO.java
+++ b/moa/src/main/java/moa/classifiers/trees/ORTO.java
@@ -1,7 +1,7 @@
- /*
+/*
  *    ORTO.java
- *    Copyright (C) Jožef Stefan Institute, Ljubljana
- *    @author Aljaž Osojnik
+ *    Copyright (C) 2015 Jožef Stefan Institute, Ljubljana, Slovenia
+ *    @author Aljaž Osojnik <aljaz.osojnik@ijs.si>
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
@@ -18,1359 +18,515 @@
  *    
  */
 
-/* Based on the FIMTDD implementation by Katie de Lange, E. Almeida, J. Gama. See FIMTDD.java.
- *
- * Contact: aljaz.osojnik@ijs.si
- */
-
 package moa.classifiers.trees;
 
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
 import java.util.Stack;
-import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.Set;
-import moa.AbstractMOAObject;
-import moa.classifiers.AbstractClassifier;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+
 import moa.classifiers.Regressor;
 import moa.classifiers.core.AttributeSplitSuggestion;
 import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
 import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.NullAttributeClassObserver;
-import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
-import moa.classifiers.core.splitcriteria.VarianceReductionSplitCriterion;
-// import moa.classifiers.core.splitcriteria.SDRSplitCriterion;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.core.DoubleVector;
+import moa.classifiers.trees.FIMTDD.InnerNode;
+import moa.classifiers.trees.FIMTDD.Node;
 import moa.core.AutoExpandVector;
 import moa.core.Measurement;
-import moa.core.SizeOf;
-import moa.options.ClassOption;
-// import weka.core.Utils;
+import moa.core.StringUtils;
 
 /*
- * Implementation of ORTO, option tree for data streams.
+ * Implementation of ORTO, option trees for data streams.
  */
 
-public class ORTO extends AbstractClassifier implements Regressor{
-
-    private static final long serialVersionUID = 1L;
-
-    //============================== INTERNALS ===============================//
-    
-    protected Node treeRoot;
-    
-    private int leafNodeCount = 0;
-    private int innerNodeCount = 0;
-    private int optionNodeCount = 0;
-    
-    private int numTrees = 1;
-
-    protected int maxDepth = 0;
-    
-    protected double inactiveLeafByteSizeEstimate;
-
-    protected double activeLeafByteSizeEstimate;
-
-    protected double byteSizeEstimateOverheadFraction;
-
-    // Store the lowest node (lowest level) in the tree that requires adaptation
-    protected ArrayList<InnerNode> nodesToAdapt = new ArrayList<InnerNode>();
-    
-    protected boolean Adaptable = true;
-    
-    protected double initLearnRate = 0.1;
-    
-    protected double learnRateDecay = 0.001;
-    
-    public int maxID = 0;
-    
-    private double learnTime = 0.0;
-    
-    private double predictTime = 0.0;
-    
-    //============================ END INTERNALS =============================//
-    
-    //============================= SET OPTIONS ==============================//
-
-    public FloatOption PageHinckleyAlphaOption = new FloatOption(
-            "PageHinckleyAlpha",
-            'a',
-            "The alpha value to use in the Page Hinckley change detection tests.",
-            0.005, 0.0, 1.0);
-        
-    public IntOption PageHinckleyThresholdOption = new IntOption(
-            "PageHinckleyThreshold",
-            'h',
-            "The threshold value to be used in the Page Hinckley change detection tests.",
-            50, 0, Integer.MAX_VALUE);
-        
-    public FloatOption AlternateTreeFadingFactorOption = new FloatOption(
-            "AlternateTreeFadingFactor",
-            'f',
-            "The fading factor to use when deciding if an alternate tree should replace an original.",
-            0.995, 0.0, 1.0);
-        
-    public IntOption AlternateTreeTMinOption = new IntOption(
-            "AlternateTreeTMin",
-            'y',
-            "The Tmin value to use when deciding if an alternate tree should replace an original.",
-            150, 0, Integer.MAX_VALUE);
-        
-    public IntOption AlternateTreeTimeOption = new IntOption(
-            "AlternateTreeTime",
-            'u',
-            "The 'time' (in terms of number of instances) value to use when deciding if an alternate tree should be discarded.",
-            1500, 0, Integer.MAX_VALUE);
-    
-    public FloatOption LearningRatioOption = new FloatOption(
-            "LearningRatio",
-            'w',
-            "Learning ratio to use for training the Perceptrons in the leaves.",
-            0.01, 0.0, 1.0);
-    
-    public FlagOption LearningRatioDecayOrConstOption = new FlagOption(
-            "LearningRatioDecayOrConst",
-            'j',
-            "learning Ratio Decay or const parameter.");
-    
-    public IntOption MaxTreesOption = new IntOption(
-            "MaxTrees",
-            'm',
-            "The maximum number of trees contained in the option tree.",
-            10, 1, Integer.MAX_VALUE);
-    
-    public IntOption MaxOptionLevelOption = new IntOption(
-            "MaxOptionLevel",
-            'l',
-            "The maximal depth at which option nodes can be created.",
-            10, 0, Integer.MAX_VALUE);
-
-    public FloatOption OptionDecayFactorOption = new FloatOption(
-            "OptionDecayFactor",
-            'd',
-            "The option decay factor that determines how many options can be selected at a given level.",
-            0.9, 0.0, 1.0);
-            
-    public ClassOption splitCriterionOption = new ClassOption(
-            "splitCriterion",
-            's',
-            "Split criterion to use.",
-            VarianceReductionSplitCriterion.class,
-            "VarianceReductionSplitCriterion");
-    
-    public ClassOption numericEstimatorOption = new ClassOption(
-            "numericEstimator",
-            'n',
-            "Numeric estimator to use.",
-            FIMTDDNumericAttributeClassObserver.class,
-            "FIMTDDNumericAttributeClassObserver");
-
-    public IntOption gracePeriodOption = new IntOption(
-            "gracePeriod",
-            'g',
-            "The number of instances a leaf should observe between split attempts.",
-            200, 0, Integer.MAX_VALUE);
-    
-    public FloatOption splitConfidenceOption = new FloatOption(
-            "splitConfidence",
-            'c',
-            "The allowable error in split decision, values closer to 0 will take longer to decide.",
-            0.0000001, 0.0, 1.0);
-    
-    public FloatOption tieThresholdOption = new FloatOption(
-            "tieThreshold",
-            't',
-            "Threshold below which a split will be forced to break ties.",
-            0.05, 0.0, 1.0);
-    
-    public FlagOption removePoorAttsOption = new FlagOption(
-            "removePoorAtts",
-            'p',
-            "Disable poor attributes.");
-    
-    public MultiChoiceOption OptionNodeAggregationOption = new MultiChoiceOption(
-            "OptionNodeAggregation",
-            'o',
-            "The aggregation method used to combine predictions in option nodes.", 
-            new String[]{"average", "bestTree"}, new String[]{"Average", "Best tree"}, 0);
-    
-    public FloatOption OptionFadingFactorOption = new FloatOption(
-            "OptionFadingFactor",
-            'q',
-            "The fading factor used for comparing subtrees of an option node.",
-            0.9995, 0.0, 1.0);
-    
-    //============================= END OPTIONS ==============================//
-    
-    //=============================== CLASSES ================================//
-    
-    public abstract static class Node extends AbstractMOAObject /*implements AdaptationCompatibleNode*/ {
-
-        private static final long serialVersionUID = 1L;
-
-        public int ID;
-        
-        protected InnerNode parent;
-      
-        protected Node alternateTree;
-        
-        protected boolean Alternate = false;
-        
-        protected boolean Adaptable = true;
-
-        public Node(int id) {
-            this.ID = id;
-        }
-        
-        @Override
-        public void getDescription(StringBuilder sb, int indent) {
-        }
-
-        public int calcByteSize() {
-            return (int) SizeOf.fullSizeOf(this);
-        }
-
-        public boolean isLeaf() {
-            return true;
-        }
-
-        public void calculateDetph(ORTO tree) {
-            int level = this.getLevel();
-            if (level > tree.maxDepth) {
-                tree.maxDepth = level;
-            }
-        }
-        
-        public int getLevel() {
-            Node target = (Node) this.getParent();
-            while (target instanceof OptionNode) {
-                target = (Node) target.getParent();
-            }
-            if (target == null) {
-                if (!Alternate) { 
-                    // Actual tree root
-                    return 0;
-                } else {
-                    // Root of alternate tree
-                    return alternateTree.getLevel();
-                }
-            } else {
-                return target.getLevel() + 1;
-            }
-        }
-        
-        /**
-        * Set the parent node
-        */
-        public void setParent(InnerNode parent)
-        {
-            this.parent = parent;
-        }
-        
-        /**
-        * Return the parent node
-        */
-        public InnerNode getParent()
-        {
-            return parent;
-        }
-        
-        public void setChild(int parentBranch, Node node) {
-        }
-        
-        public int getChildIndex(Node child) {
-            return 0;
-        }
-        
-        public int getNumSubtrees() {
-            return 1;
-        }
-        
-        public double[] processInstance(Instance inst, ORTO tree) {
-            // The returned values represent (by index):
-            // 0: the prediction of the node
-            // 1: the faded MSE
-            // 2: examples seen
-            // 3: the back propagated PH error
-            return new double[] {0.0, 0.0, 0.0, 0.0};
-        }
-        
-        public double[] getPrediction(Instance inst, ORTO tree) {
-            // The returned values represent (by index):
-            // 0: the prediction of the node
-            // 1: the faded MSE
-            // 2: examples seen
-            return new double[] {0.0, 0.0, 0.0};
-        }
-        
-        public void setAdaptable(boolean value) {
-            Adaptable = value;
-        }
-        
-        public void setAlternate(boolean value) {
-            Alternate = value;
-        }
-    }
-
-    public abstract static class InnerNode extends Node {
-        private static final long serialVersionUID = 1L;
-        
-        protected AutoExpandVector<Node> children = new AutoExpandVector<Node>();
-        
-        protected double PHmT = 0;
-        protected double PHMT = Double.MAX_VALUE;
-
-        // Keep track of the statistics for loss error calculations
-        protected DoubleVector lossStatistics = new DoubleVector();
-
-        protected int weightSeen = 0;
-        protected int previousWeight = 0;
-        
-        public InnerNode(int id) {
-            super(id);
-        }
-        
-        public int numChildren() {
-            return this.children.size();
-        }
-
-        public Node getChild(int index) {
-            return this.children.get(index);
-        }
-        
-        public int getChildIndex(Node child) {
-            return this.children.indexOf(child);
-        }
-        
-        public void setChild(int index, Node child) {
-            this.children.set(index, child);
-        }
-
-        public void setAlternateTree(Node tree) {
-            this.alternateTree = tree;
-        }
-        
-        public Node getAlternateTree() {
-            return this.alternateTree;
-        }
-        
-        public int calcByteSize() {
-            return (int) SizeOf.fullSizeOf(this) + (int) SizeOf.fullSizeOf(children);
-        }
-        
-        public void calculateDetph(ORTO tree) {
-            if (this.getLevel() > tree.maxDepth) {
-                tree.maxDepth = this.getLevel();
-            }
-            
-            for (Node child : children) {
-                child.calculateDetph(tree);
-            }
-        }
-        
-        /**
-         * Check to see if the tree needs updating
-         */
-        public boolean PageHinckleyTest(double error, double threshold)
-        {    
-            // Update the cumulative mT sum
-            PHmT += error;
-
-            // Update the minimum mT value if the new mT is
-            // smaller than the current minimum
-            if(PHmT < PHMT)
-            {
-                PHMT = PHmT;
-            }
-            // Return true if the cumulative value - the current minimum is
-            // greater than the current threshold (in which case we should adapt)
-            return PHmT - PHMT > threshold;
-        }
-        
-        public void setAdaptable(boolean value) {
-            Adaptable = value;
-            
-            for (Node child : children) {
-                child.setAdaptable(value);
-            }
-        }
-        
-        public void setAlternate(boolean value) {
-            Alternate = value;
-            
-            for (Node child : children) {
-                child.setAlternate(value);
-            }
-        }
-        
-    }
-    
-    public static class SplitNode extends InnerNode {
-
-        private static final long serialVersionUID = 1L;
-
-        protected InstanceConditionalTest splitTest;
-        
-        public void setChild(int index, Node child) {
-            if ((this.splitTest.maxBranches() >= 0) && (index >= this.splitTest.maxBranches())) {
-                throw new IndexOutOfBoundsException();
-            }
-            this.children.set(index, child);
-        }
-
-        public SplitNode(InstanceConditionalTest splitTest, int id) {
-            super(id);
-            this.splitTest = splitTest;
-        }
-
-        public int instanceChildIndex(Instance inst) {
-            return this.splitTest.branchForInstance(inst);
-        }
-
-        @Override
-        public boolean isLeaf() {
-            return false;
-        }
-        
-        public int getNumSubtrees() {
-            int num = 1;
-            for (Node child : children) {
-                num += child.getNumSubtrees();
-            }
-            num -= children.size();
-            return num;
-        }
-
-        public double[] processInstance(Instance inst, ORTO tree) {
-            int branch = splitTest.branchForInstance(inst);
-            Node child = children.get(branch);
-            if (child == null) {
-                tree.maxID++;
-                child = new ActiveLearningNode(tree.maxID);
-                this.setChild(branch, child);
-                child.setParent(this);
-            }
-
-            double[] processed = child.processInstance(inst, tree);
-            
-            weightSeen++;
-            
-            // Convert any nominal attributes to numeric ones???
-            
-            // If no model exists yet, begin with an empty leaf node (the root)    
-            // Take the current example and traverse it through the tree to a leaf
-            if (Adaptable) {
-                if (this.alternateTree == null) {
-                    // Retrieve the error for the found leaf node
-                    // currentNode.learnFromInstance(inst, this);
-                    double PHerror = processed[3] - tree.PageHinckleyAlphaOption.getValue();
-                            
-                    // Back-propagate the error through all the parent nodes
-                    if(PageHinckleyTest(PHerror, tree.PageHinckleyThresholdOption.getValue())) {
-                        if (tree.nodesToAdapt.contains(child)) {
-                            tree.nodesToAdapt.remove(child);
-                        }
-                        tree.nodesToAdapt.add(this);
-                    }
-                } else if (this.alternateTree != null) {
-    
-                    // If an alternate tree already exists, check if the current tree should be replaced with it,
-                    // or if the alternate tree should be discarded.
-                    
-                    // this.alternateTree.checkRoot();
-                    
-                    double[] processedAlt = this.alternateTree.processInstance(inst, tree);
-                    
-                    // Update the loss statistics for the alternate tree
-                    double qAlt = processedAlt[1];
-                    double qOrg = processed[1];
-                                     
-                    // Compute the Qi statistics
-                    double Qi = Math.log(qOrg / qAlt);
-                    lossStatistics.addToValue(0,1);
-                    lossStatistics.addToValue(1,Qi);
-                    double QiAverage = lossStatistics.getValue(1) / lossStatistics.getValue(0);
-                    
-                    if(weightSeen - previousWeight >= tree.AlternateTreeTMinOption.getValue()) {
-    
-                        // Update the weight at which a decision was tested for
-                        previousWeight = weightSeen;
-                        
-    
-                        // If appropriate, replace the current tree with the alternate tree
-                        if(Qi > 0) {
-                            // Replace the main FIMT-DD tree at a subtree
-                            alternateTree.setAdaptable(true);
-                            alternateTree.Alternate = false;
-                            if(parent != null) {
-                                parent.setChild(parent.getChildIndex(this), alternateTree);
-                                alternateTree.setParent(parent);
-                                tree.numTrees = tree.numTrees - this.getNumSubtrees() + alternateTree.getNumSubtrees();
-                                alternateTree.alternateTree = null;
-                            } else { // Or occasionally at the root of the tree
-                                tree.numTrees = tree.numTrees - this.getNumSubtrees() + alternateTree.getNumSubtrees();
-                                tree.treeRoot = alternateTree;
-                                alternateTree.alternateTree = null;
-                            }
-                            tree.removeExcessTrees();
-                        }
-                        // Otherwise, check if the alternate tree should be discarded
-                        else if (QiAverage < lossStatistics.getValue(2) && lossStatistics.getValue(0) >= (10 * tree.AlternateTreeTMinOption.getValue()) || weightSeen >= tree.AlternateTreeTimeOption.getValue()) {
-                            // tree.nodesToAdapt.remove(tree.nodesToAdapt.indexOf(this));
-                            this.alternateTree = null;
-                            setAdaptable(true);
-                        }
-                        
-                        lossStatistics.setValue(2, QiAverage);
-                    }
-                }
-            }
-            
-            return processed;
-            
-        }
-        
-        public double[] getPrediction(Instance inst, ORTO tree) {
-            int branch = splitTest.branchForInstance(inst);
-            Node child = children.get(branch);
-            if (child == null) {
-                tree.maxID++;
-                child = new ActiveLearningNode(tree.maxID);
-                this.setChild(branch, child);
-                child.setParent(this);
-            }
-            return child.getPrediction(inst, tree);
-        }
-        
-    }
-   
-    public static class OptionNode extends InnerNode {
-        
-        private static final long serialVersionUID = 1L;
-        
-        protected double[] optionFFSSL;
-        protected double[] optionFFSeen;
-        // protected double[] optionBaseFFSSL;
-        
-        public OptionNode(int id) {
-            super(id);
-        }
-       
-        public void resetFF() {
-            this.optionFFSSL = new double[this.children.size()];
-            this.optionFFSeen = new double[this.children.size()];
-            // this.optionBaseFFSSL = new double[this.children.size()];
-            for (int i = 0; i < this.children.size(); i++) {
-                this.optionFFSSL[i] = 0.0;
-                this.optionFFSeen[i] = 0.0;
-                // this.optionBaseFFSSL[i] = 0.0;
-            }
-        }
-
-        @Override
-        public boolean isLeaf() {
-            return false;
-        }
-        
-        public int getNumSubtrees() {
-            int num = 0;
-            for (Node child : children) {
-                num += child.getNumSubtrees();
-            }
-            return num;
-        }
-        
-        public int directionForBestTree() {
-            int d = 0;
-            double tmp = 0.0, min = Double.MAX_VALUE;
-            for (int i = 0; i < children.size(); i++) {
-                tmp = optionFFSSL[i] / optionFFSeen[i];
-                if (tmp < min) {
-                    min = tmp;
-                    d = i;
-                }
-            }
-            return d;
-        }
-        
-        public double[] getPrediction(Instance inst, ORTO tree) {
-            double[][] predictions = new double[this.children.size()][];
-            if (tree.OptionNodeAggregationOption.getChosenIndex() != 1) {
-                int i = 0;
-                for (i = 0; i < this.children.size(); i++) {
-                    predictions[i] = this.getChild(i).getPrediction(inst, tree);
-                }
-                return aggregate(predictions, tree);
-            } else {
-                int d = directionForBestTree();
-                return this.getChild(d).getPrediction(inst, tree);
-            }
-        }
-        
-        public double[] processInstance(Instance inst, ORTO tree) {
-            double[][] processed = new double[this.numChildren()][];
-            int i = 0;
-            
-            for (i = 0; i < this.numChildren(); i++) {
-                processed[i] = this.getChild(i).processInstance(inst, tree); // All the children get to see the instance
-            }
-            
-            double[] prediction;
-            
-            if (tree.OptionNodeAggregationOption.getChosenIndex() != 1) {
-                prediction = aggregate(processed, tree);
-            } else {
-                prediction = processed[directionForBestTree()];
-            }
-            
-            if (Adaptable) {
-                if (this.alternateTree == null) {
-                    // Retrieve the error for the found leaf node
-                    double PHerror = inst.classValue() - prediction[0];
-                            
-                    // Back-propagate the error through all the parent nodes
-                    if(PageHinckleyTest(PHerror, tree.PageHinckleyThresholdOption.getValue())) {
-                        for (Node node : tree.nodesToAdapt) {
-                            if (children.contains(node)) {
-                                tree.nodesToAdapt.remove(node);
-                            }
-                        }
-                        tree.nodesToAdapt.add(this);
-                    }
-                } else {
-                    // If an alternate tree already exists, check if the current tree should be replaced with it,
-                    // or if the alternate tree should be discarded.                  
-                    double[] predictionAlt = this.alternateTree.processInstance(inst, tree);
-
-                    // Update the loss statistics for the alternate tree
-                    double qOrg = prediction[1];
-                    double qAlt = predictionAlt[1];
-                                     
-                    // Compute the Qi statistics
-                    double Qi = Math.log(qOrg / qAlt);
-                    lossStatistics.addToValue(0,1);
-                    lossStatistics.addToValue(1,Qi);
-                    double QiAverage = lossStatistics.getValue(1) / lossStatistics.getValue(0);
-                    
-                    if (weightSeen - previousWeight >= tree.AlternateTreeTMinOption.getValue()) {
-    
-                        // Update the weight at which a decision was tested for
-                        previousWeight = weightSeen;
-    
-                        // If appropriate, replace the current tree with the alternate tree
-                        if(Qi > 0) {
-                            alternateTree.setAdaptable(true);
-                            alternateTree.Alternate = false;
-                            if (parent != null) { // Replace the main tree at a subtree
-                                parent.setChild(parent.getChildIndex(this), alternateTree);
-                                tree.numTrees = tree.numTrees - this.getNumSubtrees() + alternateTree.getNumSubtrees();
-                                alternateTree.setParent(parent);
-                                this.alternateTree = null;
-                            } else { // Or occasionally at the root of the tree
-                                tree.treeRoot = this.alternateTree;
-                                tree.numTrees = tree.numTrees - this.getNumSubtrees() + alternateTree.getNumSubtrees();
-                                tree.Adaptable = true;
-                                this.alternateTree = null;
-                            }
-                            tree.removeExcessTrees();
-                        }
-                        
-                        // Otherwise, check if the alternate tree should be discarded
-                        else if (QiAverage < lossStatistics.getValue(2) && lossStatistics.getValue(0) >= (10 * tree.AlternateTreeTMinOption.getValue()) || weightSeen >= tree.AlternateTreeTimeOption.getValue()) {
-                            // tree.nodesToAdapt.remove(tree.nodesToAdapt.indexOf(this)); ?
-                            this.alternateTree = null;
-                            setAdaptable(true);
-                        }
-                        
-                        lossStatistics.setValue(2, QiAverage);
-                    }
-                }
-    
-                double sqLoss;
-                
-                if (weightSeen + 1 > tree.gracePeriodOption.getValue() + 50) {
-                    for (i = 0; i < this.children.size(); i++) {
-                        sqLoss = Math.pow(processed[i][0] - inst.classValue(), 2);
-                        optionFFSSL[i] = optionFFSSL[i] * tree.OptionFadingFactorOption.getValue() + sqLoss; 
-                        optionFFSeen[i] = optionFFSeen[i] * tree.OptionFadingFactorOption.getValue() + 1;
-                    }
-                }
-            }
-            
-            weightSeen++;
-            
-            return prediction;
-        }
-        
-        private double[] aggregate(double[][] predictions, ORTO tree) {
-            if (tree.OptionNodeAggregationOption.getChosenIndex() == 0) { // Average
-                double[] average = new double[predictions[0].length];
-                for (int i = 0; i < predictions[0].length; i++) {
-                    average[i] = 0.0;
-                }
-                for (int i = 0; i < predictions[0].length; i++) {
-                    for (int j = 0; j < predictions.length; j++) {
-                        average[i] += predictions[j][i];
-                    }
-                    average[i] = average[i] / predictions.length; 
-                }
-                
-                return average;
-            } else {
-                assert false : tree.OptionNodeAggregationOption.getChosenLabel();
-                return new double[] {0.0};
-            }
-        }
-        
-        public double getFFRatio(int childIndex) {
-            return optionFFSSL[childIndex] / optionFFSeen[childIndex];
-        }
-    }
-
-    public static class ActiveLearningNode extends Node {
-
-        private static final long serialVersionUID = 1L;
-        
-        // Create a Perceptron model that carries out the actual learning in each node
-        public ORTOPerceptron learningModel = new ORTOPerceptron();
-        
-        // The statistics for this node:
-        // Sum of y values
-        // Sum of squared y values
-        protected DoubleVector nodeStatistics = new DoubleVector();
-        
-        protected DoubleVector splitRatioStatistics = new DoubleVector();
-        
-        // The error values for the Page Hinckley test
-        // PHmT = the cumulative sum of the errors
-        // PHMT = the minimum error value seen so far
-        protected double PHmT = 0;
-        protected double PHMT = Double.MAX_VALUE;
-        
-        protected int examplesSeenAtLastSplitEvaluation;
-        
-        protected int examplesSeen = 0;
-
-        protected AutoExpandVector<AttributeClassObserver> attributeObservers = new AutoExpandVector<AttributeClassObserver>();
-        
-        public ActiveLearningNode(int id) {
-            super(id);
-            this.learningModel = new ORTOPerceptron();
-        }
-
-        @Override
-        public int calcByteSize() {
-            return super.calcByteSize() + (int) (SizeOf.fullSizeOf(this.attributeObservers)) + (int) (SizeOf.fullSizeOf(this.learningModel));
-        }
-
-        /**
-         * Return the best split suggestions for this node using the given split criteria
-         */
-        public AttributeSplitSuggestion[] getBestSplitSuggestions(SplitCriterion criterion, ORTO tree) {
-            List<AttributeSplitSuggestion> bestSuggestions = new LinkedList<AttributeSplitSuggestion>();
-            
-            // Set the nodeStatistics up as the preSplitDistribution, rather than the observedClassDistribution
-            double[] nodeSplitDist = this.nodeStatistics.getArrayCopy();
-            
-            for (int i = 0; i < this.attributeObservers.size(); i++) {
-                AttributeClassObserver obs = this.attributeObservers.get(i);
-                if (obs != null) {
-                    // AT THIS STAGE NON-NUMERIC ATTRIBUTES ARE IGNORED
-                    AttributeSplitSuggestion bestSuggestion = null;
-                    if (obs instanceof FIMTDDNumericAttributeClassObserver) {
-                        bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion, nodeSplitDist, i, true /*ht.binarySplitsOption.isSet()*/);
-                    }
-                    if (bestSuggestion != null) {
-                        bestSuggestions.add(bestSuggestion);
-                    }
-                }
-            }
-            return bestSuggestions.toArray(new AttributeSplitSuggestion[bestSuggestions.size()]);
-        }
-            
-
-        public void disableAttribute(int attIndex) {
-            this.attributeObservers.set(attIndex, new NullAttributeClassObserver());
-        }
-        
-        public double getPHError(Instance inst) {
-            double sd = Math.sqrt((nodeStatistics.getValue(2) - ((nodeStatistics.getValue(1) * nodeStatistics.getValue(1))/nodeStatistics.getValue(1)))/examplesSeen);
-            double mean = nodeStatistics.getValue(2) / nodeStatistics.getValue(1);
-            //     AbsErr(inst) - (SumAbsErr + AbsErr(inst)) / (N + 1)   || SumAbsErr only contains errors for the first N examples and not the last one
-            return Math.abs( (inst.classValue() - learningModel.prediction(inst)) / sd ) - ((nodeStatistics.getValue(3) + Math.abs(((inst.classValue()-mean)/sd) - ((learningModel.prediction(inst)-mean)/sd))) / (nodeStatistics.getValue(1)+1));
-        }
-
-        /**
-         * Returns the squared error, for use in determining if an alternate tree is performing better than an original
-         * tree, or if the alternate tree should be deleted
-         */
-        public double getSquaredError() {
-            return nodeStatistics.getValue(4);
-        }
-        
-        /**
-         * Return the error for a given instance
-         */
-        public double getError(Instance inst)
-        {
-            return inst.classValue() - learningModel.prediction(inst);
-        }
-        
-        public double[] processInstance(Instance inst, ORTO tree) {
-            double prediction = getPrediction(inst, tree)[0];
-            examplesSeen++;
-
-            // Update the statistics for this node
-            // number of instances passing through the node
-            nodeStatistics.addToValue(0, 1);
-            // sum of y values
-            // sum of squared y values
-            nodeStatistics.addToValue(2, inst.classValue() * inst.classValue());
-            
-            // sum of absolute errors
-            // Normalize values prior to calculating absolute error
-            double sd = Math.sqrt((nodeStatistics.getValue(2) - ((nodeStatistics.getValue(1) * nodeStatistics.getValue(1))/examplesSeen))/examplesSeen);
-            double error = this.getError(inst);
-            nodeStatistics.addToValue(3, Math.abs(error / sd));
-            // sum of squared errors
-            // nodeStatistics.addToValue(4, error * error);
-            nodeStatistics.setValue(4, nodeStatistics.getValue(4) * tree.AlternateTreeFadingFactorOption.getValue() + error * error);
-
-            double ph = getPHError(inst);
-            
-            learningModel.trainOnInstanceImpl(inst, tree);
-
-            for (int i = 0; i < inst.numAttributes() - 1; i++) {
-                int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
-                AttributeClassObserver obs = this.attributeObservers.get(i);
-                if (obs == null) {
-                    // At this stage all nominal attributes are ignored
-                    if (inst.attribute(instAttIndex).isNumeric()) {
-                        obs = tree.newNumericClassObserver();
-                        this.attributeObservers.set(i, obs);
-                    }
-                }
-                if (obs != null) {
-                    ((FIMTDDNumericAttributeClassObserver) obs).observeAttributeClass(inst.value(instAttIndex), inst.classValue(), inst.weight());
-                }
-            }
-
-            // If it has seen Nmin examples since it was last tested for splitting, attempt a split of this node
-            if (examplesSeen - examplesSeenAtLastSplitEvaluation >= tree.gracePeriodOption.getValue()) {
-                // Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
-                SplitCriterion splitCriterion = (SplitCriterion) tree.getPreparedClassOption(tree.splitCriterionOption);
-
-                // Using this criterion, find the best split per attribute and rank the results
-                AttributeSplitSuggestion[] bestSplitSuggestions = getBestSplitSuggestions(splitCriterion, tree);
-                List<AttributeSplitSuggestion> acceptedSplits = new LinkedList<AttributeSplitSuggestion>();
-                Arrays.sort(bestSplitSuggestions);
-
-                // Declare a variable to determine the number of splits to be performed
-                int numSplits = 0;
-
-                // If only one split was returned, use it
-                if (bestSplitSuggestions.length == 1) {
-                    numSplits = 1;
-                    acceptedSplits.add(bestSplitSuggestions[0]);
-                } else if (bestSplitSuggestions.length > 1) { // Otherwise, consider which of the splits proposed may be worth trying
-
-                    // Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
-                    // to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
-                    double hoeffdingBound = computeHoeffdingBound(1, tree.splitConfidenceOption.getValue(), examplesSeen);
-                    
-                    // Determine the top two ranked splitting suggestions
-                    AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-                    AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
-
-                    // assert false : bestSuggestion.merit;
-                    
-                    // If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
-                    // as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
-                    // particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
-                    // splitting should occur.
-                    // Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
-                    // (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
-                    // competing attributes are equally good, and the split will be made on the one with the higher SDR value.
-                    if (secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) {
-                        numSplits = 1;
-                        acceptedSplits.add(bestSuggestion);
-                    } else if (tree.numTrees < tree.MaxTreesOption.getValue() && getLevel() <= tree.MaxOptionLevelOption.getValue()) {
-                        for (AttributeSplitSuggestion suggestion : bestSplitSuggestions) {
-                            if (suggestion.merit / bestSuggestion.merit >= 1 - hoeffdingBound) {
-                                numSplits++;
-                                acceptedSplits.add(suggestion);
-                            }
-                        }
-                    } else if (hoeffdingBound < tree.tieThresholdOption.getValue()) {
-                        numSplits = 1;
-                        acceptedSplits.add(bestSplitSuggestions[0]);
-                    } else { // If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
-                        for (int i = 0; i < attributeObservers.size(); i++) {
-                            AttributeClassObserver obs = attributeObservers.get(i);
-                            if (obs != null) {
-                                ((FIMTDDNumericAttributeClassObserver) obs).removeBadSplits(splitCriterion, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound);    
-                            }
-                        }
-                    }
-                    // If the user has selected this option, it is also possible to remove poor attributes at this stage
-                    if ((tree.removePoorAttsOption != null) && tree.removePoorAttsOption.isSet()) {
-                        Set<Integer> poorAtts = new HashSet<Integer>();
-                        for (int i = 0; i < bestSplitSuggestions.length; i++) { // scan 1 - add any poor to set
-                            if (bestSplitSuggestions[i].splitTest != null) {
-                                int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
-                                if (splitAtts.length == 1) {
-                                    if (((bestSuggestion.merit / secondBestSuggestion.merit) + hoeffdingBound)  < 1) {
-                                        poorAtts.add(new Integer(splitAtts[0]));
-                                    }
-                                }
-                            }
-                        }                     
-                        for (int i = 0; i < bestSplitSuggestions.length; i++) { // scan 2 - remove good ones from set
-                            if (bestSplitSuggestions[i].splitTest != null) {
-                                int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
-                                if (splitAtts.length == 1) {
-                                    if (((bestSuggestion.merit / secondBestSuggestion.merit) + hoeffdingBound)  < 1) {
-                                        poorAtts.remove(new Integer(splitAtts[0]));
-                                    }
-                                }
-                            }
-                        }
-                        for (int poorAtt : poorAtts) {
-                            this.disableAttribute(poorAtt);
-                        }
-                    }
-                }
-                
-                // assert numSplits == 0 : numSplits;
-
-                // If the splitting criterion were met, split the current node using the chosen attribute test, and
-                // make two new branches leading to (empty) leaves
-                if (numSplits > 0) {
-
-                    double optionFactor = numSplits * Math.pow(tree.OptionDecayFactorOption.getValue(), (double) getLevel());
-
-                    // Deactivate this node if the best split was to do nothing
-                    if (numSplits == 1 || optionFactor < 2.0 || tree.MaxTreesOption.getValue() - tree.numTrees  <= 1) {
-                        AttributeSplitSuggestion splitDecision = acceptedSplits.get(0);
-                        tree.maxID++;
-                        SplitNode newSplit = new SplitNode(splitDecision.splitTest, tree.maxID);
-                        newSplit.Adaptable = Adaptable;
-                        for (int i = 0; i < splitDecision.numSplits(); i++) {
-                            tree.maxID++;
-                            ActiveLearningNode newChild = new ActiveLearningNode(tree.maxID);
-                            newChild.setParent(newSplit);
-                            newChild.Adaptable = Adaptable;
-                            newSplit.setChild(i, newChild);
-                        }
-                        tree.leafNodeCount--;
-                        tree.innerNodeCount++;
-                        tree.leafNodeCount += splitDecision.numSplits();
-                        if (parent == null) {
-                            tree.treeRoot = newSplit;
-                        } else {
-                            parent.setChild(parent.getChildIndex(this), newSplit);
-                            newSplit.setParent(parent);
-                        }
-                    } else {
-                        tree.maxID++;
-                        OptionNode optionNode = new OptionNode(tree.maxID);
-                        optionNode.Adaptable = Adaptable;
-                        tree.leafNodeCount--;
-                        int j = 0;
-                        
-                        for (AttributeSplitSuggestion splitDecision : acceptedSplits) {
-                            if (j > optionFactor || tree.MaxTreesOption.getValue() - tree.numTrees <= 0) {
-                                break;
-                            }
-                            tree.maxID++;
-                            SplitNode newSplit = new SplitNode(splitDecision.splitTest, tree.maxID);
-                            newSplit.Adaptable = Adaptable;
-                            for (int i = 0; i < splitDecision.numSplits(); i++) {
-                                tree.maxID++;
-                                ActiveLearningNode newChild = new ActiveLearningNode(tree.maxID);
-                                newChild.setParent(newSplit);
-                                newSplit.setChild(i, newChild);
-                                newChild.Adaptable = Adaptable;
-                            }
-                            
-                            tree.leafNodeCount += splitDecision.numSplits();
-                            tree.innerNodeCount++;
-                            tree.numTrees++;
-
-                            newSplit.setParent(optionNode);
-                            optionNode.setChild(j, newSplit);
-                            j++;
-                        }
-                        
-                        tree.innerNodeCount++;
-                        tree.optionNodeCount++;
-                       
-                        if (parent == null) {
-                            tree.treeRoot = optionNode;
-                        } else {
-                            parent.setChild(parent.getChildIndex(this), optionNode);
-                            optionNode.setParent(parent);
-                        }
-                        
-                        optionNode.resetFF();
-                    }
-                }
-
-                // Take note of how many instances were seen when this split evaluation was made, so we know when to perform the next split evaluation
-                examplesSeenAtLastSplitEvaluation = examplesSeen;
-            }
-            
-            return new double[] {prediction, nodeStatistics.getValue(4), examplesSeen, ph};
-        }
-        
-        public double[] getPrediction(Instance inst, ORTO tree) {
-            return new double[] {this.learningModel.prediction(inst), this.nodeStatistics.getValue(4), this.examplesSeen};
-        }
-        
-    }
-    
-    /**
-     * A Perceptron classifier modified to conform to the specifications of Ikonomovska et al.
-     */
-    public static class ORTOPerceptron extends AbstractMOAObject {
-        private static final long serialVersionUID = 1L;
-        
-        // The Perception weights 
-        protected double[] weightAttribute; 
-        
-        // Statistics used for error calculations
-        protected DoubleVector attributeStatistics = new DoubleVector();
-        protected DoubleVector squaredAttributeStatistics = new DoubleVector();
-        
-        // The number of instances contributing to this model
-        protected int instancesSeen = 0;
-        
-        // If the model should be reset or not
-        protected boolean reset;
-        
-        @Override
-        public void getDescription(StringBuilder sb, int indent) {
-        //TODO Auto-generated method stub
-        }
-        
-        public ORTOPerceptron(ORTOPerceptron copy) {
-                this.weightAttribute = copy.getWeights();
-        }
-        
-        public ORTOPerceptron() {
-                this.reset = true;
-        }
-        
-        public void setWeights(double[] w) {
-            this.weightAttribute = w;
-        }
-        
-        public double[] getWeights() {
-            return this.weightAttribute;
-        }
-                
-        /**
-         * A method to reset the model
-         */
-        public void resetLearningImpl() {
-            this.reset = true;
-        }
-        
-        /**
-         * Update the model using the provided instance
-         */
-        public void trainOnInstanceImpl(Instance inst, ORTO ft) {
-            // Initialize Perceptron if necessary   
-            if (this.reset == true) {
-                this.reset = false;
-                this.weightAttribute = new double[inst.numAttributes()];
-                this.instancesSeen = 0;
-                this.attributeStatistics = new DoubleVector();
-                this.squaredAttributeStatistics = new DoubleVector();
-                for (int j = 0; j < inst.numAttributes(); j++) {
-                    weightAttribute[j] = 2 * ft.classifierRandom.nextDouble() - 1;
-                }
-            }
-            
-            // Update attribute statistics
-            instancesSeen++;
-            for(int j = 0; j < inst.numAttributes() -1; j++)
-            {
-                attributeStatistics.addToValue(j, inst.value(j));    
-                squaredAttributeStatistics.addToValue(j, inst.value(j)*inst.value(j));
-            }
-            
-            // Update weights
-            
-            double learningRatio = 0.0;
-            if(ft.LearningRatioDecayOrConstOption.isSet()){
-                learningRatio = ft.LearningRatioOption.getValue();
-            } else {
-                learningRatio = ft.initLearnRate / (1 + instancesSeen * ft.learnRateDecay);
-            }
-            // double learningRatio = ft.learningRatioOption.getValue();
-            double actualClass = inst.classValue();
-            double predictedClass = this.prediction(inst);
-            
-            // SET DELTA TO ACTUAL - PREDICTED, NOT PREDICTED - ACTUAL AS SAID IN PAPER
-            double delta = actualClass - predictedClass;
-            
-            for (int j = 0; j < inst.numAttributes() - 1; j++) {
-                
-                if (inst.attribute(j).isNumeric()) {
-                    // Update weights. Ensure attribute values are normalized first
-                    double sd = Math.sqrt((squaredAttributeStatistics.getValue(j) - ((attributeStatistics.getValue(j) * attributeStatistics.getValue(j))/instancesSeen))/instancesSeen);
-                    double instanceValue = 0;
-                    if (sd > 0.0000001) { // Limit found in implementation by Ikonomovska et al (2011)
-                        instanceValue = (inst.value(j) - (attributeStatistics.getValue(j)/instancesSeen))/(3*sd);
-                    }
-                    this.weightAttribute[j] += learningRatio * delta * instanceValue;
-                }
-            }
-            this.weightAttribute[inst.numAttributes() - 1] += learningRatio * delta;
-        }
-        
-        /**
-         * Output the prediction made by this perceptron on the given instance
-         */
-        public double prediction(Instance inst)
-        {
-            double prediction = 0;
-            if (this.reset == false) {
-                for (int j = 0; j < inst.numAttributes() - 1; j++) {
-                    if(inst.attribute(j).isNumeric())
-                    {    
-                        prediction += this.weightAttribute[j] * inst.value(j);
-                    }
-                } 
-                prediction += this.weightAttribute[inst.numAttributes() - 1];
-            }
-            
-            // Return prediction to 3dp
-            return (double)Math.round(prediction * 1000) / 1000;
-        }
-    }
-
-    //============================= END CLASSES ==============================//
-    
-    //=============================== METHODS ================================//
-        
-    @Override
-    public String getPurposeString() {
-        return "Implementation of the ORTO tree as described by Ikonomovska et al.";
-    }
-    
-    // For the moment at least, force the split criterion to be SDRSplitCriterion and the 
-    // numeric estimator to be FIMTLDDNumericAttributeClassObserver
-    public ORTO() {
-//        numericEstimatorOption = new ClassOption("numericEstimator",
-//                'n', "Numeric estimator to use.", FIMTDDNumericAttributeClassObserver.class,
-//                "FIMTDDNumericAttributeClassObserver");
-                
-        splitCriterionOption = new ClassOption("splitCriterion",
-                's', "Split criterion to use.", VarianceReductionSplitCriterion.class,
-                "VarianceReductionSplitCriterion");
-    }
-
-    @Override
-    public void resetLearningImpl() {
-        this.treeRoot = null;
-        this.numTrees = 1;
-        this.innerNodeCount = 0;
-        this.leafNodeCount = 0;
-        this.optionNodeCount = 0;
-        this.maxID = 0;
-        
-        this.learnTime = 0.0;
-        this.predictTime = 0.0;
-    }
-    
-    public boolean isRandomizable() {
-        return true;
-    }
-
-    protected void checkRoot() {
-        if (treeRoot == null) {
-            maxID++;
-            treeRoot = new ActiveLearningNode(maxID);
-            leafNodeCount = 1;
-        }
-    }
-    
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        // if (this.treeRoot != null) {
-        //    this.treeRoot.calculateDetph(this);
-        // }
-        return new Measurement[]{ 
-                    new Measurement("number of subtrees", this.numTrees),
-                    new Measurement("tree size (nodes)", this.leafNodeCount + this.innerNodeCount),
-                    new Measurement("tree size (leaves)", this.leafNodeCount),
-                    new Measurement("number of option nodes", this.optionNodeCount),
-                    // new Measurement("tree depth", this.maxDepth),
-                    // new Measurement("option count", this.countOptions()),
-                    // new Measurement("learning time", learnTime),
-                    // new Measurement("prediction time", predictTime),
-                    /*new Measurement("tree depth", measureTreeDepth()),
-                    new Measurement("active leaf byte size estimate",
-                    this.activeLeafByteSizeEstimate),
-                    new Measurement("inactive leaf byte size estimate",
-                    this.inactiveLeafByteSizeEstimate),
-                    new Measurement("byte size estimate overhead",
-                    this.byteSizeEstimateOverheadFraction),
-                    new Measurement("maximum prediction paths used",
-                    this.maxPredictionPaths) */ };
-    }
-
-    public int calcByteSize() {
-        int size = (int) SizeOf.sizeOf(this);
-        if (this.treeRoot != null) {
-            size += this.treeRoot.calcByteSize();
-        }
-        return size;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-    }
-
-    @Override
-    public double[] getVotesForInstance(Instance inst) {
-        
-        if (this.treeRoot != null) {
-            double start = System.nanoTime();
-            double[] out = {this.treeRoot.getPrediction(inst, this)[0]};
-            predictTime += System.nanoTime() - start;
-            
-            return out;
-        }
-        return new double[0];
-    }
-    
-    //================= TRAIN and TEST ================//
-    /**
-     * Method for updating (training) the model using a new instance
-     */
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-    
-        double start = System.nanoTime();
-        
-        checkRoot();
-
-        treeRoot.processInstance(inst, this);
-                        
-        for (InnerNode node : nodesToAdapt) {
-            if (node.Adaptable) {
-                maxID++;
-                node.alternateTree = new ActiveLearningNode(maxID);
-                node.alternateTree.Adaptable = false;
-                node.alternateTree.Alternate = true;
-                node.alternateTree.alternateTree = node;
-                
-                node.setAdaptable(false);
-                
-                // Reset the node statistics
-                node.lossStatistics.setValue(0,0);
-                node.lossStatistics.setValue(1,0);
-                node.lossStatistics.setValue(2,0);
-                node.PHmT = 0;
-                node.PHMT = Double.MAX_VALUE; // TODO Does this reset too?
-                node.weightSeen = 0;
-                node.previousWeight = 0;
-            }
-        }
-        nodesToAdapt = new ArrayList<InnerNode>();
-        
-        learnTime += System.nanoTime() - start;
-    }
-    
-    protected AttributeClassObserver newNumericClassObserver() {
-        AttributeClassObserver numericClassObserver = (AttributeClassObserver) getPreparedClassOption(numericEstimatorOption); // FIXME fix this
-        // AttributeClassObserver observer = new FIMTDDNumericAttributeClassObserver();
-        return (AttributeClassObserver) numericClassObserver;
-    }
-
-    public static double computeHoeffdingBound(double range, double confidence, double n) {
-        return Math.sqrt(((range * range) * Math.log(1.0 / confidence)) / (2.0 * n));
-    }
-    
-    protected Node findWorstOption() {
-        Stack<Node> stack = new Stack<Node>();
-        stack.add(this.treeRoot);
-
-        double ratio = Double.MIN_VALUE;
-        Node out = null;
-        
-        while (!stack.empty()) {
-            Node node = stack.pop();
-            if (node.parent instanceof OptionNode) {
-                OptionNode myParent = (OptionNode) node.parent;
-                int myIndex = myParent.getChildIndex(node);
-                double myRatio = myParent.getFFRatio(myIndex); 
-                
-                if (myRatio > ratio) {
-                    ratio = myRatio;
-                    out = node;
-                }
-            }
-            if (node instanceof InnerNode) {
-                for (Node child : ((InnerNode) node).children) {
-                    stack.add(child);
-                }
-            }
-        }
-
-        return out;
-    }
-    
-    protected void removeExcessTrees() {
-        while (numTrees > MaxTreesOption.getValue()) {
-            Node option = findWorstOption();
-            OptionNode parent = (OptionNode) option.parent;
-            int index = parent.getChildIndex(option);
-  
-            if (parent.children.size() == 2) {
-                parent.children.remove(index);
-                
-                for (Node chld : parent.children) {
-                    chld.parent = parent.parent;
-                    parent.parent.setChild(parent.parent.getChildIndex(parent), chld);
-                }
-            } else {
-                AutoExpandVector<Node> children = new AutoExpandVector<Node>();
-                double[] optionFFSSL = new double[parent.children.size() - 1];
-                double[] optionFFSeen = new double[parent.children.size() - 1];
-                
-                int seen = 0;
-                
-                for (int i = 0; i < parent.children.size() - 1; i++) {
-                    if (parent.getChild(i) != option) {
-                        children.add(parent.getChild(i));
-                        optionFFSSL[i] = parent.optionFFSSL[i + seen];
-                        optionFFSeen[i] = parent.optionFFSeen[i + seen];
-                    } else {
-                        seen = 1;
-                    }
-                }
-                
-                parent.children = children;
-                parent.optionFFSSL = optionFFSSL;
-                parent.optionFFSeen = optionFFSeen;
-                
-                assert parent.children.size() == parent.optionFFSSL.length;
-            }
-  
-            numTrees--;
-        }
-    }
-  
+public class ORTO extends FIMTDD implements Regressor {
+
+	private static final long serialVersionUID = 1L;
+
+	private int innerNodeCount = 0;
+	private int optionNodeCount = 0;
+
+	private int numTrees = 1;
+
+
+	//region ================ OPTIONS ================
+
+	public IntOption maxTreesOption = new IntOption(
+			"maxTrees",
+			'm',
+			"The maximum number of trees contained in the option tree.",
+			10, 1, Integer.MAX_VALUE);
+
+	public IntOption maxOptionLevelOption = new IntOption(
+			"maxOptionLevel",
+			'x',
+			"The maximal depth at which option nodes can be created.",
+			10, 0, Integer.MAX_VALUE);
+
+	public FloatOption optionDecayFactorOption = new FloatOption(
+			"optionDecayFactor",
+			'z',
+			"The option decay factor that determines how many options can be selected at a given level.",
+			0.9, 0.0, 1.0);
+
+	public MultiChoiceOption optionNodeAggregationOption = new MultiChoiceOption(
+			"optionNodeAggregation",
+			'o',
+			"The aggregation method used to combine predictions in option nodes.", 
+			new String[]{"average", "bestTree"}, new String[]{"Average", "Best tree"}, 0);
+
+	public FloatOption optionFadingFactorOption = new FloatOption(
+			"optionFadingFactor",
+			'q',
+			"The fading factor used for comparing subtrees of an option node.",
+			0.9995, 0.0, 1.0);
+
+	//endregion ================ OPTIONS ================
+
+	//region ================ CLASSES ================
+
+	public static class OptionNode extends InnerNode {
+
+		private static final long serialVersionUID = 1L;
+
+		protected double[] optionFFSSL;
+		protected double[] optionFFSeen;
+
+		public OptionNode(FIMTDD tree) {
+			super(tree);
+		}
+
+		public void resetFF() {
+			optionFFSSL = new double[children.size()];
+			optionFFSeen = new double[children.size()];
+			
+			for (int i = 0; i < children.size(); i++) {
+				optionFFSSL[i] = 0.0;
+				optionFFSeen[i] = 0.0;
+			}
+		}
+
+		public int getNumSubtrees() {
+			int num = 0;
+			for (Node child : children) {
+				num += child.getNumSubtrees();
+			}
+			return num;
+		}
+
+		public int directionForBestTree() {
+			int d = 0;
+			double min = Double.MAX_VALUE;
+			for (int i = 0; i < numChildren(); i++) {
+				double tmp = getFFRatio(i);
+				if (tmp < min) {
+					min = tmp;
+					d = i;
+				}
+			}
+			return d;
+		}
+
+		public double getPrediction(Instance inst) {
+			double[] predictions = new double[numChildren()];
+			for (int i = 0; i < numChildren(); i++) {
+				predictions[i] = getChild(i).getPrediction(inst);
+			}
+			return aggregate(predictions);
+		}
+
+		private double aggregate(double[] predictions) {
+			if (((ORTO) tree).optionNodeAggregationOption.getChosenIndex() == 0) { // Average
+				double sum = 0.0;
+				for (int i = 0; i < predictions.length; i++) {
+					sum += predictions[i];
+				}
+				return sum / predictions.length;
+			} else if (((ORTO) tree).optionNodeAggregationOption.getChosenIndex() == 1) {
+				int d = directionForBestTree();
+				return predictions[d];
+			} else {
+				return 0.0;
+			}
+		}
+
+		public double getFFRatio(int childIndex) {
+			return optionFFSSL[childIndex] / optionFFSeen[childIndex];
+		}
+		
+		protected boolean skipInLevelCount() {
+			return true;
+		}
+		
+		@Override
+		public void describeSubtree(StringBuilder out, int indent) {
+			StringUtils.appendIndented(out, indent, "[option node]");
+			StringUtils.appendNewline(out);
+			for (int childIndex = 0; childIndex < children.size(); childIndex++) {
+				Node split = getChild(childIndex);
+				StringUtils.appendIndented(out, indent, "[" + childIndex + "]");
+				StringUtils.appendNewline(out);
+				split.describeSubtree(out, indent + 2);
+			}
+		}
+	}
+
+	//endregion ================ CLASSES ================
+
+	//region ================ METHODS ================
+
+	// region --- Regressor methods
+
+	public String getPurposeString() {
+		return "Implementation of the ORTO tree as described by Ikonomovska et al.";
+	}
+
+	public void resetLearningImpl() {
+		super.resetLearningImpl();
+		this.innerNodeCount = 0;
+		this.optionNodeCount = 0;
+	}
+
+	
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[]{ 
+				new Measurement("number of subtrees", this.numTrees),
+				new Measurement("tree size (nodes)", this.leafNodeCount + this.innerNodeCount),
+				new Measurement("tree size (leaves)", this.leafNodeCount),
+				new Measurement("number of option nodes", this.optionNodeCount),};
+	}
+
+	public void processInstance(Instance inst, Node node, double prediction, double normalError, boolean growthAllowed, boolean inAlternate) {
+		if (node instanceof OptionNode) {
+			processInstanceOptionNode(inst, (OptionNode) node, prediction, normalError, growthAllowed, inAlternate);
+		} else {
+			Node currentNode = node;
+			while (true) {
+				if (currentNode instanceof LeafNode) {
+					((LeafNode) currentNode).learnFromInstance(inst, growthAllowed, prediction);
+					break;
+				} else {
+					currentNode.examplesSeen += inst.weight();
+					currentNode.sumOfAbsErrors += inst.weight() * normalError;
+					InnerNode iNode = (InnerNode) currentNode;
+					if (!inAlternate && iNode.alternateTree != null) {
+						boolean altTree = true;
+						double lossO = Math.pow(inst.classValue() - prediction, 2);
+						double lossA = Math.pow(inst.classValue() - iNode.alternateTree.getPrediction(inst), 2);
+						
+						// Loop for compatibility with bagging methods
+						for (int i = 0; i < inst.weight(); i++) {
+							iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
+							iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
+							iNode.lossExamplesSeen++;
+							
+							double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
+							iNode.lossSumQi += Qi;
+							iNode.lossNumQiTests += 1;
+						}
+						double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
+						double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+						double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+						
+						if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
+							iNode.previousWeight = iNode.lossExamplesSeen;
+							if (Qi > 0) {
+								// Switch the subtrees
+								Node parent = iNode.getParent();
+								
+								if (parent != null) {
+									Node replacementTree = iNode.alternateTree;
+									parent.setChild(parent.getChildIndex(iNode), replacementTree);
+									if (growthAllowed) replacementTree.restartChangeDetection();
+								} else {
+									treeRoot = iNode.alternateTree;
+									treeRoot.restartChangeDetection();
+								}
+								optionNodeCount += iNode.alternateTree.getNumSubtrees() - iNode.getNumSubtrees();
+								removeExcessTrees();
+										
+								currentNode = iNode.alternateTree;
+								currentNode.originalNode = null;
+								altTree = false;
+							} else if (QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * alternateTreeTMinOption.getValue()) || iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()) {
+								// Remove the alternate tree
+								iNode.alternateTree = null;
+								if (growthAllowed) iNode.restartChangeDetection();
+								altTree = false;
+							}
+						}
+						if (altTree) {
+							growthAllowed = false; // this is the growth of the original tree
+							processInstance(inst, iNode.alternateTree, prediction, normalError, true, true); // growth is allowed in the alt tree
+						} else if (currentNode instanceof OptionNode) {
+							// this happens when an option node is switched into the tree
+							for (Node child : ((OptionNode) currentNode).children) {
+								processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed, inAlternate);
+							}
+							break;
+						}
+					}
+				
+					if (iNode.changeDetection && !inAlternate) {
+						if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+							iNode.initializeAlternateTree();
+						}
+					}
+					if (currentNode instanceof SplitNode) {
+						currentNode = ((SplitNode) currentNode).descendOneStep(inst);
+					} else if (currentNode instanceof OptionNode) {
+						processInstanceOptionNode(inst, (OptionNode) currentNode, prediction, normalError, growthAllowed, inAlternate);
+						break;
+					}
+				}
+			}
+		}
+		
+	}
+	
+	public void processInstanceOptionNode(Instance inst, OptionNode node, double prediction, double normalError, boolean growthAllowed, boolean inAlternate) {
+		node.examplesSeen += inst.weight();
+		node.sumOfAbsErrors += inst.weight() * normalError;
+		if (node.changeDetection) {
+			double error = Math.abs(prediction - inst.classValue());
+			node.sumOfAbsErrors += error;
+			
+			if (((InnerNode) node).PageHinckleyTest(error - node.sumOfAbsErrors / node.examplesSeen + PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+				node.initializeAlternateTree();
+				growthAllowed = false;
+			}
+		}
+
+		for (Node child : node.children) {
+			int index = node.getChildIndex(child);
+			double childPrediction = child.getPrediction(inst);
+			node.optionFFSeen[index] = node.optionFFSeen[index] * optionFadingFactorOption.getValue() + 1;
+			node.optionFFSSL[index] = node.optionFFSSL[index] * optionFadingFactorOption.getValue() + Math.pow(childPrediction - inst.classValue(), 2);
+		}
+
+		for (Node child : node.children) {
+			processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed, inAlternate);
+		}
+	}
+	
+	// endregion --- Regressor methods
+	
+	// region --- Object instantiation methods
+
+	protected OptionNode newOptionNode() {
+		maxID++;
+		return new OptionNode(this);
+	}
+	
+	// endregion --- Object instantiation methods
+
+	// region --- Processing methods
+
+	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
+
+		// Initialize the split criterion 
+		SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(splitCriterionOption);
+
+		// Using this criterion, find the best split per attribute and rank the results
+		AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion);
+		List<AttributeSplitSuggestion> acceptedSplits = new LinkedList<AttributeSplitSuggestion>();
+		Arrays.sort(bestSplitSuggestions);
+		
+		// Declare a variable to determine the number of splits to be performed
+		int numSplits = 0;
+
+		// If only one split was returned, use it (this generally shouldn't happen)
+		if (bestSplitSuggestions.length == 1) {
+			numSplits = 1;
+			acceptedSplits.add(bestSplitSuggestions[0]);
+		} else if (bestSplitSuggestions.length > 1) { // Otherwise, consider which of the splits proposed may be worth trying
+
+			// Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
+			// to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
+			double hoeffdingBound = computeHoeffdingBound(1, splitConfidenceOption.getValue(), node.examplesSeen);
+
+			// Determine the top two ranked splitting suggestions
+			AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+			AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
+
+			
+			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
+			// as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
+			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
+			// splitting should occur.
+			// Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
+			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
+			// competing attributes are equally good, and the split will be made on the one with the higher SDR value.
+			if (secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) {
+				numSplits = 1;
+				acceptedSplits.add(bestSuggestion);
+			} else if (numTrees < maxTreesOption.getValue() && node.getLevel() <= maxOptionLevelOption.getValue()) {
+				for (int i = 0; i < bestSplitSuggestions.length; i++) {
+					AttributeSplitSuggestion suggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1 - i];
+					if (suggestion.merit / bestSuggestion.merit >= 1 - hoeffdingBound) {
+						numSplits++;
+						acceptedSplits.add(suggestion);
+					} else {
+						break;
+					}
+						
+				}
+				
+			} else if (hoeffdingBound < tieThresholdOption.getValue()) {
+				numSplits = 1;
+				acceptedSplits.add(bestSplitSuggestions[0]);
+			} else { // If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
+				for (int i = 0; i < node.attributeObservers.size(); i++) {
+					AttributeClassObserver obs = node.attributeObservers.get(i);
+					if (obs != null) {
+						((FIMTDDNumericAttributeClassObserver) obs).removeBadSplits(splitCriterion, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound);    
+					}
+				}
+			}
+		}
+
+		// If the splitting criterion was met, split the current node using the chosen attribute test, and
+		// make two new branches leading to (empty) leaves
+		if (numSplits > 0) {
+			double optionFactor = numSplits * Math.pow(optionDecayFactorOption.getValue(), (double) node.getLevel());
+
+			if (numSplits == 1 || optionFactor < 2.0 || maxTreesOption.getValue() - numTrees <= 0) {
+				AttributeSplitSuggestion splitDecision = acceptedSplits.get(0);
+				SplitNode newSplit = newSplitNode(splitDecision.splitTest);
+				for (int i = 0; i < splitDecision.numSplits(); i++) {
+					LeafNode newChild = newLeafNode();
+					newChild.setParent(newSplit);
+					newSplit.setChild(i, newChild);
+				}
+				leafNodeCount--;
+				innerNodeCount++;
+				leafNodeCount += splitDecision.numSplits();
+				if (parent == null && node.originalNode == null) {
+					treeRoot = newSplit;
+				} else if (parent == null && node.originalNode != null) {
+					node.originalNode.alternateTree = newSplit;
+				} else {
+					parent.setChild(parentIndex, newSplit);
+					newSplit.setParent(parent);
+				}
+			} else {
+				OptionNode optionNode = newOptionNode();
+				leafNodeCount--;
+				int j = 0;
+
+				for (AttributeSplitSuggestion splitDecision : acceptedSplits) {
+					if (j > optionFactor || maxTreesOption.getValue() - numTrees <= 0) {
+						break;
+					}
+					SplitNode newSplit = newSplitNode(splitDecision.splitTest);
+					for (int i = 0; i < splitDecision.numSplits(); i++) {
+						LeafNode newChild = newLeafNode();
+						newChild.setParent(newSplit);
+						newSplit.setChild(i, newChild);
+					}
+
+					leafNodeCount += splitDecision.numSplits();
+					innerNodeCount++;
+					numTrees++;
+
+					newSplit.setParent(optionNode);
+					optionNode.setChild(j, newSplit);
+					j++;
+				}
+
+				innerNodeCount++;
+				optionNodeCount++;
+
+				if (parent == null) {
+					treeRoot = optionNode;
+				} else {
+					parent.setChild(parentIndex, optionNode);
+					optionNode.setParent(parent);
+				}
+
+				optionNode.resetFF();
+			}
+		}
+	}
+
+	// endregion --- Processing methods 
+	
+	// region --- Option tree methods
+	protected Node findWorstOption() {
+		Stack<Node> stack = new Stack<Node>();
+		stack.add(treeRoot);
+
+		double ratio = Double.MIN_VALUE;
+		Node out = null;
+
+		while (!stack.empty()) {
+			Node node = stack.pop();
+			if (node.getParent() instanceof OptionNode) {
+				OptionNode myParent = (OptionNode) node.getParent();
+				int nodeIndex = myParent.getChildIndex(node);
+				double nodeRatio = myParent.getFFRatio(nodeIndex); 
+
+				if (nodeRatio > ratio) {
+					ratio = nodeRatio;
+					out = node;
+				}
+			}
+			if (node instanceof InnerNode) {
+				for (Node child : ((InnerNode) node).children) {
+					stack.add(child);
+				}
+			}
+		}
+
+		return out;
+	}
+
+	protected void removeExcessTrees() {
+		while (numTrees > maxTreesOption.getValue()) {
+			Node option = findWorstOption();
+			OptionNode parent = (OptionNode) option.parent;
+			int index = parent.getChildIndex(option);
+
+			if (parent.children.size() == 2) {
+				parent.children.remove(index);
+				for (Node chld : parent.children) {
+					chld.parent = parent.parent;
+					parent.parent.setChild(parent.parent.getChildIndex(parent), chld);
+				}
+			} else {
+				AutoExpandVector<Node> children = new AutoExpandVector<Node>();
+				double[] optionFFSSL = new double[parent.children.size() - 1];
+				double[] optionFFSeen = new double[parent.children.size() - 1];
+
+				int seen = 0;
+
+				for (int i = 0; i < parent.children.size() - 1; i++) {
+					if (parent.getChild(i) != option) {
+						children.add(parent.getChild(i));
+						optionFFSSL[i] = parent.optionFFSSL[i + seen];
+						optionFFSeen[i] = parent.optionFFSeen[i + seen];
+					} else {
+						seen = 1;
+					}
+				}
+
+				parent.children = children;
+				parent.optionFFSSL = optionFFSSL;
+				parent.optionFFSeen = optionFFSeen;
+
+				assert parent.children.size() == parent.optionFFSSL.length;
+			}
+			numTrees--;
+		}
+	}
+	
+	// endregion --- Option tree methods
+	
+	//endregion ================ METHODS ================
 }
\ No newline at end of file

From fedd0d2a8e23b838b85a43e006124b43177d94f2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Mon, 9 Nov 2015 14:50:42 +0100
Subject: [PATCH 03/33] Cosmetic changes (fixed indentation)

---
 .../multilabel/MultilabelHoeffdingTree.java   |  60 +--
 .../tasks/EvaluatePrequentialMultiTarget.java | 401 +++++++++---------
 2 files changed, 232 insertions(+), 229 deletions(-)

diff --git a/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java b/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java
index 5bee4b482..934eae252 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java
@@ -46,9 +46,9 @@
  * 
  */ 
 public class MultilabelHoeffdingTree extends HoeffdingTreeClassifLeaves implements MultiLabelLearner, MultiTargetRegressor { 
-// Needs to use InfoGainSplitCriterionMultiLabel, since multilabel entropy is calculated in a different way 
-// Trains a mlinstance adding statistics of several class values and training node classifiers
-// Get votes from the training node classifier
+	// Needs to use InfoGainSplitCriterionMultiLabel, since multilabel entropy is calculated in a different way 
+	// Trains a mlinstance adding statistics of several class values and training node classifiers
+	// Get votes from the training node classifier
 
 	private static final long serialVersionUID = 1L;
 
@@ -56,19 +56,19 @@ public class MultilabelHoeffdingTree extends HoeffdingTreeClassifLeaves implemen
 
 	// Converts multi-label format to single-label format
 	//protected Converter converter = null;
-	
+
 	@Override
 	public void setModelContext(InstancesHeader raw_header) {
 		//set the multilabel model context
 		this.modelContext = raw_header;
 	}
 
-   	@Override
+	@Override
 	public Prediction getPredictionForInstance(Example<Instance> example) {
 		return getPredictionForInstance((MultiLabelInstance)example.getData());
 	} 
-    
-  @Override
+
+	@Override
 	public Prediction getPredictionForInstance(MultiLabelInstance instance) {
 
 		double[] predictionArray = this.getVotesForInstance(instance);
@@ -100,17 +100,17 @@ public void learnFromInstance(Instance inst, HoeffdingTree ht) {
 			}
 		}
 	}
-	
+
 	// It uses classifier at nodes, and to be able to train with several class values
 	public class MultilabelLearningNodeClassifier extends LearningNodeClassifier {
-		
+
 		//protected Classifier classifier; 
 
 		private static final long serialVersionUID = 1L;
 
 		public MultilabelLearningNodeClassifier(double[] initialClassObservations, Classifier cl, MultilabelHoeffdingTree ht ) {
 			super(initialClassObservations);
-		
+
 			if (cl== null) {
 				this.classifier = ((Classifier) getPreparedClassOption(ht.learnerOption)).copy();
 				this.classifier.resetLearning();
@@ -136,13 +136,13 @@ public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
 		public void disableAttribute(int attIndex) {
 			// should not disable poor atts - they are used in NB calc
 		}
-		
+
 		public Classifier getClassifier() {
 			return this.classifier;
 		}
-		
+
 		//It uses different class values
-	    @Override
+		@Override
 		public void learnFromInstance(Instance mlinst, HoeffdingTree ht) {
 			this.classifier.trainOnInstance(mlinst);  
 			MultilabelHoeffdingTree mht = ((MultilabelHoeffdingTree) ht);
@@ -152,7 +152,7 @@ public void learnFromInstance(Instance mlinst, HoeffdingTree ht) {
 			}
 			Instance inst = mlinst; //mht.converter.formatInstance(mlinst);
 			for (int i = 0; i < inst.numInputAttributes(); i++) {
-			//for (int i = 1; i < inst.numAttributes(); i++) {
+				//for (int i = 1; i < inst.numAttributes(); i++) {
 				int instAttIndex = inst.inputAttribute(i).index(); //modelAttIndexToInstanceAttIndex(i, inst);
 				AttributeClassObserver obs = this.attributeObservers.get(instAttIndex); //i
 				if (obs == null) {
@@ -176,13 +176,13 @@ protected LearningNode newLearningNode(double[] initialClassObservations) {
 		// Create new Learning Node null
 		return new MultilabelLearningNodeClassifier(initialClassObservations,null,this);
 	}
-	
+
 	//@Override
 	protected LearningNode newLearningNode(double[] initialClassObservations, Classifier cl) {
 		// Create new Learning Node
 		return new MultilabelLearningNodeClassifier(initialClassObservations,cl,this);
 	}
-	
+
 	//It uses MultilabelInactiveLearningNode since there are several class values
 	@Override
 	protected void deactivateLearningNode(ActiveLearningNode toDeactivate,
@@ -229,21 +229,21 @@ public double[] getVotesForInstance(Instance inst) {
 		// Return empty array (this should only happen once! -- before we build the root node).
 		return new double[this.m_L];
 	}
-        
+
 
 	@Override
 	public void trainOnInstanceImpl(MultiLabelInstance instance) {
-            trainOnInstanceImpl((Instance) instance);
-        }
-        
-        private List<Integer> getRelevantLabels(Instance x) {
-        List<Integer> classValues = new LinkedList<Integer>();
-        //get all class attributes
-        for (int j = 0; j < m_L; j++) {
-            if (x.value(j) > 0.0) {
-                classValues.add(j);
-            }
-        }
-        return classValues;
-    }
+		trainOnInstanceImpl((Instance) instance);
+	}
+
+	private List<Integer> getRelevantLabels(Instance x) {
+		List<Integer> classValues = new LinkedList<Integer>();
+		//get all class attributes
+		for (int j = 0; j < m_L; j++) {
+			if (x.value(j) > 0.0) {
+				classValues.add(j);
+			}
+		}
+		return classValues;
+	}
 }
diff --git a/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java b/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
index eba9b70b5..cf8090816 100644
--- a/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
+++ b/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
@@ -59,222 +59,225 @@
  */
 public class EvaluatePrequentialMultiTarget extends MultiTargetMainTask {
 
-    @Override
-    public String getPurposeString() {
-        return "Evaluates a classifier on a stream by testing then training with each example in sequence.";
-    }
+	@Override
+	public String getPurposeString() {
+		return "Evaluates a classifier on a stream by testing then training with each example in sequence.";
+	}
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public ClassOption learnerOption = new ClassOption("learner", 'l',
-           "Learner to train.", MultiTargetRegressor.class, "moa.classifiers.multitarget.functions.MultiTargetNoChange");
+	public ClassOption learnerOption = new ClassOption("learner", 'l',
+			"Learner to train.", MultiTargetRegressor.class, "moa.classifiers.multitarget.functions.MultiTargetNoChange");
 
-    public ClassOption streamOption = new ClassOption("stream", 's',
-            "Stream to learn from.", MultiTargetInstanceStream.class,
-            "MultiTargetArffFileStream");
+	public ClassOption streamOption = new ClassOption("stream", 's',
+			"Stream to learn from.", MultiTargetInstanceStream.class,
+			"MultiTargetArffFileStream");
 
-    public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
-            "Classification performance evaluation method.",
-            MultiTargetPerformanceEvaluator.class,
-            "BasicMultiTargetPerformanceEvaluator");
+	public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
+			"Classification performance evaluation method.",
+			MultiTargetPerformanceEvaluator.class,
+			"BasicMultiTargetPerformanceEvaluator");
 
-    public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
-            "Maximum number of instances to test/train on  (-1 = no limit).",
-            100000000, -1, Integer.MAX_VALUE);
+	public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
+			"Maximum number of instances to test/train on  (-1 = no limit).",
+			100000000, -1, Integer.MAX_VALUE);
 
-    public IntOption timeLimitOption = new IntOption("timeLimit", 't',
-            "Maximum number of seconds to test/train for (-1 = no limit).", -1,
-            -1, Integer.MAX_VALUE);
+	public IntOption timeLimitOption = new IntOption("timeLimit", 't',
+			"Maximum number of seconds to test/train for (-1 = no limit).", -1,
+			-1, Integer.MAX_VALUE);
 
-    public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
-            'f',
-            "How many instances between samples of the learning performance.",
-            100000, 0, Integer.MAX_VALUE);
+	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
+			'f',
+			"How many instances between samples of the learning performance.",
+			100000, 0, Integer.MAX_VALUE);
 
-    public IntOption memCheckFrequencyOption = new IntOption(
-            "memCheckFrequency", 'q',
-            "How many instances between memory bound checks.", 100000, 0,
-            Integer.MAX_VALUE);
+	public IntOption memCheckFrequencyOption = new IntOption(
+			"memCheckFrequency", 'q',
+			"How many instances between memory bound checks.", 100000, 0,
+			Integer.MAX_VALUE);
 
-    public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
-            "File to append intermediate csv results to.", null, "csv", true);
+	public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
+			"File to append intermediate csv results to.", null, "csv", true);
 
-    public FileOption outputPredictionFileOption = new FileOption("outputPredictionFile", 'o',
-            "File to append output predictions to.", null, "pred", true);
+	public FileOption outputPredictionFileOption = new FileOption("outputPredictionFile", 'o',
+			"File to append output predictions to.", null, "pred", true);
 
-    //New for prequential method DEPRECATED
-    public IntOption widthOption = new IntOption("width",
-            'w', "Size of Window", 1000);
+	//New for prequential method DEPRECATED
+	public IntOption widthOption = new IntOption("width",
+			'w', "Size of Window", 1000);
 
-    public FloatOption alphaOption = new FloatOption("alpha",
-            'a', "Fading factor or exponential smoothing factor", .01);
-    //End New for prequential methods
+	public FloatOption alphaOption = new FloatOption("alpha",
+			'a', "Fading factor or exponential smoothing factor", .01);
+	//End New for prequential methods
 
-    @Override
-    public Class<?> getTaskResultType() {
-        return LearningCurve.class;
-    }
+	@Override
+	public Class<?> getTaskResultType() {
+		return LearningCurve.class;
+	}
 
-    @Override
-    protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
-        Learner learner = (Learner) getPreparedClassOption(this.learnerOption);
-        ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
-        LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
-        LearningCurve learningCurve = new LearningCurve(
-                "learning evaluation instances");
+	@Override
+	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
+		Learner learner = (Learner) getPreparedClassOption(this.learnerOption);
+		ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
+		LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
+		LearningCurve learningCurve = new LearningCurve(
+				"learning evaluation instances");
 
-        //New for prequential methods
-        if (evaluator instanceof WindowClassificationPerformanceEvaluator) {
-            //((WindowClassificationPerformanceEvaluator) evaluator).setWindowWidth(widthOption.getValue());
-            if (widthOption.getValue() != 1000) {
-                System.out.println("DEPRECATED! Use EvaluatePrequential -e (WindowClassificationPerformanceEvaluator -w " + widthOption.getValue() + ")");
-                 return learningCurve;
-            }
-        }
-        if (evaluator instanceof EWMAClassificationPerformanceEvaluator) {
-            //((EWMAClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
-            if (alphaOption.getValue() != .01) {
-                System.out.println("DEPRECATED! Use EvaluatePrequential -e (EWMAClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
-                return learningCurve;
-            }
-        }
-        if (evaluator instanceof FadingFactorClassificationPerformanceEvaluator) {
-            //((FadingFactorClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
-            if (alphaOption.getValue() != .01) {
-                System.out.println("DEPRECATED! Use EvaluatePrequential -e (FadingFactorClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
-                return learningCurve;
-            }
-        }
-        //End New for prequential methods
+		//New for prequential methods
+		if (evaluator instanceof WindowClassificationPerformanceEvaluator) {
+			//((WindowClassificationPerformanceEvaluator) evaluator).setWindowWidth(widthOption.getValue());
+			if (widthOption.getValue() != 1000) {
+				System.out.println("DEPRECATED! Use EvaluatePrequential -e (WindowClassificationPerformanceEvaluator -w " + widthOption.getValue() + ")");
+				return learningCurve;
+			}
+		}
+		if (evaluator instanceof EWMAClassificationPerformanceEvaluator) {
+			//((EWMAClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
+			if (alphaOption.getValue() != .01) {
+				System.out.println("DEPRECATED! Use EvaluatePrequential -e (EWMAClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
+				return learningCurve;
+			}
+		}
+		if (evaluator instanceof FadingFactorClassificationPerformanceEvaluator) {
+			//((FadingFactorClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
+			if (alphaOption.getValue() != .01) {
+				System.out.println("DEPRECATED! Use EvaluatePrequential -e (FadingFactorClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
+				return learningCurve;
+			}
+		}
+		//End New for prequential methods
 
-        learner.setModelContext(stream.getHeader());
-        int maxInstances = this.instanceLimitOption.getValue();
-        long instancesProcessed = 0;
-        int maxSeconds = this.timeLimitOption.getValue();
-        int secondsElapsed = 0;
-        monitor.setCurrentActivity("Evaluating learner...", -1.0);
+		learner.setModelContext(stream.getHeader());
+		int maxInstances = this.instanceLimitOption.getValue();
+		long instancesProcessed = 0;
+		int maxSeconds = this.timeLimitOption.getValue();
+		int secondsElapsed = 0;
+		monitor.setCurrentActivity("Evaluating learner...", -1.0);
 
-        File dumpFile = this.dumpFileOption.getFile();
-        PrintStream immediateResultStream = null;
-        if (dumpFile != null) {
-            try {
-                if (dumpFile.exists()) {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile, true), true);
-                } else {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile), true);
-                }
-            } catch (Exception ex) {
-                throw new RuntimeException(
-                        "Unable to open immediate result file: " + dumpFile, ex);
-            }
-        }
-        //File for output predictions
-        File outputPredictionFile = this.outputPredictionFileOption.getFile();
-        PrintStream outputPredictionResultStream = null;
-        if (outputPredictionFile != null) {
-            try {
-                if (outputPredictionFile.exists()) {
-                    outputPredictionResultStream = new PrintStream(
-                            new FileOutputStream(outputPredictionFile, true), true);
-                } else {
-                    outputPredictionResultStream = new PrintStream(
-                            new FileOutputStream(outputPredictionFile), true);
-                }
-            } catch (Exception ex) {
-                throw new RuntimeException(
-                        "Unable to open prediction result file: " + outputPredictionFile, ex);
-            }
-        }
-        boolean firstDump = true;
-        boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
-        long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-        long lastEvaluateStartTime = evaluateStartTime;
-        double RAMHours = 0.0;
-        while (stream.hasMoreInstances()
-                && ((maxInstances < 0) || (instancesProcessed < maxInstances))
-                && ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
-            Example trainInst = stream.nextInstance();
-            Example testInst = (Example) trainInst; //.copy();
-            //testInst.setClassMissing();
-            //double[] prediction = learner.getVotesForInstance(testInst);
-            Prediction prediction = learner.getPredictionForInstance(testInst);
-            // Output prediction
-            if (outputPredictionFile != null) {
-                double trueClass = ((Instance) trainInst.getData()).classValue();
-                outputPredictionResultStream.println(prediction + "," + trueClass);
-            }
+		File dumpFile = this.dumpFileOption.getFile();
+		PrintStream immediateResultStream = null;
+		if (dumpFile != null) {
+			try {
+				if (dumpFile.exists()) {
+					immediateResultStream = new PrintStream(
+							new FileOutputStream(dumpFile, true), true);
+				} else {
+					immediateResultStream = new PrintStream(
+							new FileOutputStream(dumpFile), true);
+				}
+			} catch (Exception ex) {
+				throw new RuntimeException(
+						"Unable to open immediate result file: " + dumpFile, ex);
+			}
+		}
+		//File for output predictions
+		File outputPredictionFile = this.outputPredictionFileOption.getFile();
+		PrintStream outputPredictionResultStream = null;
+		if (outputPredictionFile != null) {
+			try {
+				if (outputPredictionFile.exists()) {
+					outputPredictionResultStream = new PrintStream(
+							new FileOutputStream(outputPredictionFile, true), true);
+				} else {
+					outputPredictionResultStream = new PrintStream(
+							new FileOutputStream(outputPredictionFile), true);
+				}
+			} catch (Exception ex) {
+				throw new RuntimeException(
+						"Unable to open prediction result file: " + outputPredictionFile, ex);
+			}
+		}
+		boolean firstDump = true;
+		boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
+		long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+		long lastEvaluateStartTime = evaluateStartTime;
+		double RAMHours = 0.0;
+		while (stream.hasMoreInstances()
+				&& ((maxInstances < 0) || (instancesProcessed < maxInstances))
+				&& ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
+			Example trainInst = stream.nextInstance();
+			Example testInst = (Example) trainInst; //.copy();
+			//testInst.setClassMissing();
+			//double[] prediction = learner.getVotesForInstance(testInst);
+			Prediction prediction = learner.getPredictionForInstance(testInst);
+			// Output prediction
+			if (outputPredictionFile != null) {
+				StringBuilder sb = new StringBuilder();
+				for (int i = 0; i < ((Instance) trainInst.getData()).numOutputAttributes(); i++) {
+					sb.append("Out " + i + ": " + ((Instance) trainInst.getData()).valueOutputAttribute(i) + " ");
+				}
+				outputPredictionResultStream.println(prediction + "," + sb.toString());
+			}
 
-            //evaluator.addClassificationAttempt(trueClass, prediction, testInst.weight());
-            evaluator.addResult(testInst, prediction);
-            learner.trainOnInstance(trainInst);
-            instancesProcessed++;
-            if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0
-                    || stream.hasMoreInstances() == false) {
-                long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-                double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);
-                double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);
-                double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); //GBs
-                RAMHoursIncrement *= (timeIncrement / 3600.0); //Hours
-                RAMHours += RAMHoursIncrement;
-                lastEvaluateStartTime = evaluateTime;
-                learningCurve.insertEntry(new LearningEvaluation(
-                        new Measurement[]{
-                            new Measurement(
-                            "learning evaluation instances",
-                            instancesProcessed),
-                            new Measurement(
-                            "evaluation time ("
-                            + (preciseCPUTiming ? "cpu "
-                            : "") + "seconds)",
-                            time),
-                            new Measurement(
-                            "model cost (RAM-Hours)",
-                            RAMHours)
-                        },
-                        evaluator, learner));
+			//evaluator.addClassificationAttempt(trueClass, prediction, testInst.weight());
+			evaluator.addResult(testInst, prediction);
+			learner.trainOnInstance(trainInst);
+			instancesProcessed++;
+			if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0
+					|| stream.hasMoreInstances() == false) {
+				long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+				double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);
+				double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);
+				double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); //GBs
+				RAMHoursIncrement *= (timeIncrement / 3600.0); //Hours
+				RAMHours += RAMHoursIncrement;
+				lastEvaluateStartTime = evaluateTime;
+				learningCurve.insertEntry(new LearningEvaluation(
+						new Measurement[]{
+								new Measurement(
+										"learning evaluation instances",
+										instancesProcessed),
+										new Measurement(
+												"evaluation time ("
+														+ (preciseCPUTiming ? "cpu "
+																: "") + "seconds)",
+																time),
+																new Measurement(
+																		"model cost (RAM-Hours)",
+																		RAMHours)
+						},
+						evaluator, learner));
 
-                if (immediateResultStream != null) {
-                    if (firstDump) {
-                        immediateResultStream.println(learningCurve.headerToString());
-                        firstDump = false;
-                    }
-                    immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
-                    immediateResultStream.flush();
-                }
-            }
-            if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
-                if (monitor.taskShouldAbort()) {
-                    return null;
-                }
-                long estimatedRemainingInstances = stream.estimatedRemainingInstances();
-                if (maxInstances > 0) {
-                    long maxRemaining = maxInstances - instancesProcessed;
-                    if ((estimatedRemainingInstances < 0)
-                            || (maxRemaining < estimatedRemainingInstances)) {
-                        estimatedRemainingInstances = maxRemaining;
-                    }
-                }
-                monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
-                        : (double) instancesProcessed
-                        / (double) (instancesProcessed + estimatedRemainingInstances));
-                if (monitor.resultPreviewRequested()) {
-                    monitor.setLatestResultPreview(learningCurve.copy());
-                }
-                secondsElapsed = (int) TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread()
-                        - evaluateStartTime);
-            }
-        }
-        StringBuilder sb= new StringBuilder();
-        learner.getDescription(sb, 0);
-        System.out.println(sb.toString());
-        if (immediateResultStream != null) {
-            immediateResultStream.close();
-        }
-        if (outputPredictionResultStream != null) {
-            outputPredictionResultStream.close();
-        }
-        return learningCurve;
-    }
+				if (immediateResultStream != null) {
+					if (firstDump) {
+						immediateResultStream.println(learningCurve.headerToString());
+						firstDump = false;
+					}
+					immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
+					immediateResultStream.flush();
+				}
+			}
+			if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
+				if (monitor.taskShouldAbort()) {
+					return null;
+				}
+				long estimatedRemainingInstances = stream.estimatedRemainingInstances();
+				if (maxInstances > 0) {
+					long maxRemaining = maxInstances - instancesProcessed;
+					if ((estimatedRemainingInstances < 0)
+							|| (maxRemaining < estimatedRemainingInstances)) {
+						estimatedRemainingInstances = maxRemaining;
+					}
+				}
+				monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
+						: (double) instancesProcessed
+						/ (double) (instancesProcessed + estimatedRemainingInstances));
+				if (monitor.resultPreviewRequested()) {
+					monitor.setLatestResultPreview(learningCurve.copy());
+				}
+				secondsElapsed = (int) TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread()
+						- evaluateStartTime);
+			}
+		}
+		StringBuilder sb= new StringBuilder();
+		learner.getDescription(sb, 0);
+		System.out.println(sb.toString());
+		if (immediateResultStream != null) {
+			immediateResultStream.close();
+		}
+		if (outputPredictionResultStream != null) {
+			outputPredictionResultStream.close();
+		}
+		return learningCurve;
+	}
 }

From 4e3116ae22afc259caa4f4e7d967ae369aae367c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Mon, 9 Nov 2015 15:22:23 +0100
Subject: [PATCH 04/33] Removed merging artefacts

---
 .../samoa/instances/MultiLabelPrediction.java |   5 +-
 .../LocalMultiTargetClassifier.java           |  31 +-
 .../classifiers/multilabel/meta/MTOzaBag.java |  94 +-
 .../multilabel/trees/ISOUPTree.java           | 144 +--
 .../java/moa/classifiers/trees/FIMTDD.java    | 986 +-----------------
 .../main/java/moa/classifiers/trees/ORTO.java | 114 +-
 .../tasks/EvaluatePrequentialMultiTarget.java |  59 +-
 7 files changed, 63 insertions(+), 1370 deletions(-)

diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
index 838f90c7b..bb9824e9d 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
@@ -32,10 +32,7 @@ public MultiLabelPrediction(int numOutputAttributes) {
 	public MultiLabelPrediction(DoubleVector[] prediction) {
 		this.prediction = prediction;
 	}
-	
-	public MultiLabelPrediction(DoubleVector[] prediction) {
-		this.prediction = prediction;
-	}
+
 	
 	@Override
 	public int numOutputAttributes() {
diff --git a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
index 38c82f7e9..35223d3db 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
@@ -1,12 +1,8 @@
 package moa.classifiers.multilabel;
 
-<<<<<<< HEAD
 import java.util.ArrayList;
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 import java.util.LinkedList;
 import java.util.List;
-import java.util.Vector;
 
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
@@ -21,16 +17,14 @@
 import moa.classifiers.Classifier;
 import moa.classifiers.MultiLabelClassifier;
 import moa.classifiers.MultiTargetRegressor;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.classifiers.trees.FIMTDD;
-import moa.core.DoubleVector;
 import moa.core.Measurement;
-import moa.learners.Learner;
 import moa.options.ClassOption;
 
 public class LocalMultiTargetClassifier extends AbstractMultiLabelLearner
 		implements MultiLabelClassifier, MultiTargetRegressor {
 
+	private static final long serialVersionUID = 1L;
+
 	public ClassOption classifierOption = new ClassOption(
 			"classifier",
 			'c',
@@ -38,17 +32,11 @@ public class LocalMultiTargetClassifier extends AbstractMultiLabelLearner
 			Classifier.class,
 			"moa.classifiers.trees.FIMTDD");
 	
-<<<<<<< HEAD
 	ArrayList<Classifier> classifiers = null;
 	ArrayList<InstancesHeader> headers = null;
-=======
-	LinkedList<Classifier> classifiers = null;
-	LinkedList<InstancesHeader> headers = null;
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 	
 	@Override
 	public boolean isRandomizable() {
-		// TODO Auto-generated method stub
 		return true;
 	}
 
@@ -61,11 +49,7 @@ private InstancesHeader getHeader(int target) {
 	
 	private void makeHeaders() {
 		if (headers == null) {
-<<<<<<< HEAD
 			headers = new ArrayList<InstancesHeader>();
-=======
-			headers = new LinkedList<InstancesHeader>();
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 			for (int target = 0; target < getModelContext().numOutputAttributes(); target++) {
 				List<Attribute> attributes = new LinkedList<Attribute>();
 				List<Integer> indexValues = new LinkedList<Integer>();
@@ -95,7 +79,6 @@ private Instance getSTInstance(MultiLabelInstance inst, int target) {
 	
 	@Override
 	public void trainOnInstanceImpl(MultiLabelInstance instance) {
-		// TODO Auto-generated method stub
 		initializeClassifiers();
 		
 		for (int j = 0; j < instance.numberOutputTargets(); j++) {
@@ -112,10 +95,6 @@ public Prediction getPredictionForInstance(MultiLabelInstance inst) {
 		MultiLabelPrediction prediction = new MultiLabelPrediction(getModelContext().numOutputAttributes());
 		for (int j = 0; j < inst.numberOutputTargets(); j++) {
 			Instance STInst = getSTInstance(inst, j);
-<<<<<<< HEAD
-=======
-			
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 			prediction.setVote(j, 1, classifiers.get(j).getVotesForInstance(STInst)[0]);
 		}
 		return prediction;
@@ -131,15 +110,9 @@ public void initializeClassifiers() {
 		this.classifierRandom.setSeed(1234);
 		if (classifiers == null) {
 			makeHeaders();
-<<<<<<< HEAD
 			classifiers = new ArrayList<Classifier>();
 			for (int i = 0; i < getModelContext().numOutputAttributes(); i++) {
 				Classifier learner = ((Classifier) getPreparedClassOption(this.classifierOption)).copy();
-=======
-			classifiers = new LinkedList<Classifier>();
-			for (int i = 0; i < getModelContext().numOutputAttributes(); i++) {
-				Classifier learner = (Classifier) getPreparedClassOption(this.classifierOption);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				classifiers.add(learner);
 				learner.resetLearning();
 				((AbstractClassifier) learner).classifierRandom = this.classifierRandom;
diff --git a/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java b/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
index a4c64a809..bdf2c7ffd 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
@@ -41,41 +41,43 @@
  */
 public class MTOzaBag extends OzaBag implements MultiLabelLearner, MultiTargetRegressor {
 
-    public MTOzaBag() {
-    	super();
-    	this.baseLearnerOption = new ClassOption("baseLearner", 'l',
-                "Classifier to train.", MultiLabelLearner.class, "multilabel.trees.ISOUPTree");
-    	}
-	
-    @Override
-    public void resetLearningImpl() {
-        this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
-        MultiLabelLearner baseLearner = (MultiLabelLearner) getPreparedClassOption(this.baseLearnerOption);
-        baseLearner.resetLearning();
-        for (int i = 0; i < this.ensemble.length; i++) {
-            this.ensemble[i] = baseLearner.copy();
-        }
-    }
-
-    @Override
-    public void setModelContext(InstancesHeader raw_header) {
-
-        //set the multilabel model context
-        this.modelContext = raw_header;
-
-        // reset ensemble
-        this.resetLearningImpl();
-
-        for (int i = 0; i < this.ensemble.length; i++) {
-            this.ensemble[i].setModelContext(raw_header);
-            this.ensemble[i].resetLearning();
-        }
-    }
-
-    @Override // @note don't need this here
-    public boolean isRandomizable() {
-        return true;
-    }
+	private static final long serialVersionUID = 1L;
+
+	public MTOzaBag() {
+		super();
+		this.baseLearnerOption = new ClassOption("baseLearner", 'l',
+				"Classifier to train.", MultiLabelLearner.class, "multilabel.trees.ISOUPTree");
+	}
+
+	@Override
+	public void resetLearningImpl() {
+		this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
+		MultiLabelLearner baseLearner = (MultiLabelLearner) getPreparedClassOption(this.baseLearnerOption);
+		baseLearner.resetLearning();
+		for (int i = 0; i < this.ensemble.length; i++) {
+			this.ensemble[i] = baseLearner.copy();
+		}
+	}
+
+	@Override
+	public void setModelContext(InstancesHeader raw_header) {
+
+		//set the multilabel model context
+		this.modelContext = raw_header;
+
+		// reset ensemble
+		this.resetLearningImpl();
+
+		for (int i = 0; i < this.ensemble.length; i++) {
+			this.ensemble[i].setModelContext(raw_header);
+			this.ensemble[i].resetLearning();
+		}
+	}
+
+	@Override // @note don't need this here
+	public boolean isRandomizable() {
+		return true;
+	}
 
 	public Prediction getPredictionForInstance(MultiLabelInstance inst) {
 		DoubleVector[][] predictions = new DoubleVector[this.ensemble.length][getModelContext().numOutputAttributes()];
@@ -93,8 +95,8 @@ public Prediction getPredictionForInstance(MultiLabelInstance inst) {
 		}
 		return new MultiLabelPrediction(prediction);
 	}
-<<<<<<< HEAD
-	
+
+
 	public Prediction getPredictionForInstanceUsingN(MultiLabelInstance inst, int n) {
 		int actual = Math.max(1, Math.min(n, this.ensemble.length));
 		DoubleVector[][] predictions = new DoubleVector[actual][getModelContext().numOutputAttributes()];
@@ -112,17 +114,15 @@ public Prediction getPredictionForInstanceUsingN(MultiLabelInstance inst, int n)
 		}
 		return new MultiLabelPrediction(prediction);
 	}
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
-
-    @Override
-    public void trainOnInstanceImpl(MultiLabelInstance instance) {
-        trainOnInstanceImpl((Instance) instance);
-    }
-    
-    @Override
+
+	@Override
+	public void trainOnInstanceImpl(MultiLabelInstance instance) {
+		trainOnInstanceImpl((Instance) instance);
+	}
+
+	@Override
 	public Prediction getPredictionForInstance(Example<Instance> example) {
 		return getPredictionForInstance((MultiLabelInstance)example.getData());
 	}
-    
+
 }
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
index 592a0c5c6..1873b87cf 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
@@ -66,14 +66,7 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 
 	private static final long serialVersionUID = 1L;
 
-<<<<<<< HEAD
 	public Node treeRoot;
-=======
-	protected Node treeRoot;
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
-
-	private int leafNodeCount = 0;
-	private int splitNodeCount = 0;
 
 	private double examplesSeen = 0.0;
 	private DoubleVector sumOfValues = new DoubleVector();
@@ -86,7 +79,6 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 
 	//region ================ OPTIONS ================
 
-<<<<<<< HEAD
 	//	public ClassOption splitCriterionOption = new ClassOption(
 	//			"splitCriterion",
 	//			's',
@@ -95,8 +87,6 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 	//			"moa.classifiers.core.splitcriteria.VarianceReductionSplitCriterion");
 	// TODO not used at the moment, consider later when the implementation catches up	
 
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 	public IntOption gracePeriodOption = new IntOption(
 			"gracePeriod",
 			'g',
@@ -115,7 +105,6 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 			"Threshold below which a split will be forced to break ties.",
 			0.05, 0.0, 1.0);
 
-<<<<<<< HEAD
 	public FloatOption PageHinckleyAlphaOption = new FloatOption(
 			"PageHinckleyAlpha",
 			'a',
@@ -127,19 +116,6 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 			'h',
 			"The threshold value to be used in the Page Hinckley change detection tests.",
 			50, 0, Integer.MAX_VALUE);
-=======
-//	public FloatOption PageHinckleyAlphaOption = new FloatOption(
-//			"PageHinckleyAlpha",
-//			'a',
-//			"The alpha value to use in the Page Hinckley change detection tests.",
-//			0.005, 0.0, 1.0);
-//
-//	public IntOption PageHinckleyThresholdOption = new IntOption(
-//			"PageHinckleyThreshold",
-//			'h',
-//			"The threshold value to be used in the Page Hinckley change detection tests.",
-//			50, 0, Integer.MAX_VALUE);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 
 	public FloatOption alternateTreeFadingFactorOption = new FloatOption(
 			"alternateTreeFadingFactor",
@@ -185,15 +161,6 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 			"doNotNormalize",
 			'n',
 			"Don't normalize.");
-<<<<<<< HEAD
-	
-	public FlagOption printLogsOption = new FlagOption(
-			"printLogs",
-			'z',
-			"Print logs.");
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
-
 
 	//endregion ================ OPTIONS ================
 
@@ -342,17 +309,11 @@ public LeafNode(ISOUPTree tree) {
 		 */
 		public void learnFromInstance(MultiLabelInstance inst, double[] prediction, boolean growthAllowed) {
 			// Update the statistics for this node
-<<<<<<< HEAD
-			// number of instances passing through the node
-			double[] predictionP = tree.buildingModelTree() ? getPredictionModel(inst) : null;
-			double[] predictionM = getPredictionTargetMean(inst);
-
-=======
+			
 			double[] predictionP = tree.buildingModelTree() ? getPredictionModel(inst) : null;
 			double[] predictionM = getPredictionTargetMean(inst);
 
 			// number of instances passing through the node
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 			examplesSeen += inst.weight();
 
 			for (int i = 0; i < tree.getModelContext().numOutputAttributes(); i++) {
@@ -367,10 +328,7 @@ public void learnFromInstance(MultiLabelInstance inst, double[] prediction, bool
 					errorM.setValue(i, errorM.getValue(i) * 0.95 + Math.abs(predictionM[i] - inst.valueOutputAttribute(i)));
 				}
 			}
-<<<<<<< HEAD
-			
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+
 			if (tree.buildingModelTree()) learningModel.updatePerceptron(inst);
 
 			for (int i = 0; i < inst.numInputAttributes(); i++) {
@@ -443,17 +401,11 @@ public double[] getPredictionModel(MultiLabelInstance inst) {
 
 		public double[] getPredictionTargetMean(MultiLabelInstance inst) {
 			double[] pred = new double[inst.numOutputAttributes()];
-<<<<<<< HEAD
 			for (int i = 0; i < inst.numOutputAttributes(); i++) {
 				if (examplesSeen > 0) {
 					pred[i] = sumOfValues.getValue(i) / examplesSeen;
 				} else {
 					pred[i] = 0;
-=======
-			if (examplesSeen > 0) {
-				for (int i = 0; i < inst.numOutputAttributes(); i++) {
-					pred[i] = sumOfValues.getValue(i) / examplesSeen;
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				}
 			}
 			return pred;
@@ -654,11 +606,8 @@ public class MultitargetPerceptron {
 		protected ISOUPTree tree;
 
 		// The Perception weights 
-<<<<<<< HEAD
 		public double[][] weights; 
-=======
-		protected double[][] weights; 
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+
 
 		// The number of instances contributing to this model
 		protected int instancesSeen = 0;
@@ -670,13 +619,6 @@ public String getPurposeString() {
 		public MultitargetPerceptron(ISOUPTree tree, MultitargetPerceptron original) {
 			this.tree = tree;
 			weights = original.weights.clone();
-<<<<<<< HEAD
-			// TODO check if this is necessary
-//			for (int i = 0; i < this.tree.getModelContext().numOutputAttributes(); i++) {
-//				weights[i] = (DoubleVector) original.weights[i].copy();
-//			}
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		}
 
 		public MultitargetPerceptron(ISOUPTree tree) {
@@ -696,10 +638,7 @@ public void initializeWeights() {
 					weights[i][j] = 2 * tree.classifierRandom.nextDouble() - 1;
 				}
 			}
-<<<<<<< HEAD
 			normalizeWeights();
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		}
 
 		/**
@@ -750,10 +689,6 @@ public void normalizeWeights() {
 			}
 		}
 
-<<<<<<< HEAD
-		
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		/**
 		 * Output the prediction made by this perceptron on the given instance
 		 */
@@ -792,7 +727,6 @@ private double[] denormalizePrediction(double[] normalizedPrediction) {
 		public void getModelDescription(StringBuilder out, int indent) {
 			for (int i = 0; i < tree.getModelContext().numOutputAttributes(); i++) {
 				StringUtils.appendIndented(out, indent, " [" + tree.getModelContext().outputAttribute(i).name() + "]");
-<<<<<<< HEAD
 				//if (getModelContext() != null) {
 				//for (int j = 0; j < getModelContext().numAttributes() - 1; j++) {
 				//					if (getModelContext().attribute(j).isNumeric()) {
@@ -1140,24 +1074,6 @@ public void getModelDescription(StringBuilder out, int indent) {
 	//
 	//	}
 
-=======
-				if (getModelContext() != null) {
-				for (int j = 0; j < getModelContext().numOutputAttributes(); j++) {
-									if (getModelContext().attribute(j).isNumeric()) {
-										out.append((j == 0 || weights[i][j] < 0) ? " " : " + ");
-										out.append(String.format("%.4f", weights[i][j]));
-										out.append(" * ");
-										out.append(getAttributeNameString(j));
-									}
-				}
-				out.append(" + " + weights[i][getModelContext().numOutputAttributes()]);
-				}
-				StringUtils.appendNewline(out);
-			}
-		}
-	}
-
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 	//endregion ================ CLASSES ================
 
 	//region ================ METHODS ================
@@ -1166,27 +1082,17 @@ public void getModelDescription(StringBuilder out, int indent) {
 	public ISOUPTree() {}
 
 	public String getPurposeString() {
-<<<<<<< HEAD
-		return "Implementation of the FIMT-DD tree as described by Ikonomovska et al.";
-=======
 		return "Implementation of the iSOUP-Tree algorithm as described by Osojnik et al.";
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 	}
 
 	public void resetLearningImpl() {
 		treeRoot = null;
-		leafNodeCount = 0;
-		splitNodeCount = 0;
-<<<<<<< HEAD
 		examplesSeen = 0.0;
 		sumOfValues = new DoubleVector();
 		sumOfSquares = new DoubleVector();
 
 		sumOfAttrValues = new DoubleVector();
 		sumOfAttrSquares = new DoubleVector();
-=======
-		maxID = 0;
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 	}
 
 	public boolean isRandomizable() {
@@ -1280,11 +1186,7 @@ public double[] normalizeTargetVector(double[] pred) {
 				double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen);
 				double average = sumOfValues.getValue(i) / examplesSeen;
 				if (sd > 0 && examplesSeen > 1)
-<<<<<<< HEAD
 					out[i] = (value - average) / sd;
-=======
-					out[i] = (value - average) / (3 * sd);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				else
 					out[i] = 0;
 			}
@@ -1300,11 +1202,7 @@ public double normalizeTargetValue(MultiLabelInstance inst, int i) {
 				double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen);
 				double average = sumOfValues.getValue(i) / examplesSeen;
 				if (sd > 0)
-<<<<<<< HEAD
 					return (value - average) / sd;
-=======
-					return (value - average) / (3 * sd);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				else
 					return 0;
 			}
@@ -1318,11 +1216,7 @@ public double normalizeTargetValue(double value, int i) {
 				double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen);
 				double average = sumOfValues.getValue(i) / examplesSeen;
 				if (sd > 0)
-<<<<<<< HEAD
 					return (value - average) / sd;
-=======
-					return (value - average) / (3 * sd);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				else
 					return 0;
 			}
@@ -1350,15 +1244,9 @@ public void trainOnInstanceImpl(MultiLabelInstance inst) {
 
 			double[] prediction = treeRoot.getPrediction(inst);
 			double[] normalError = getNormalizedError(inst, prediction);
-<<<<<<< HEAD
 			
 			processInstance(inst, treeRoot, prediction, normalError, true, false);
 			
-=======
-			//normalError.scaleValues(inst.weight());
-			processInstance(inst, treeRoot, prediction, normalError, true, false);
-
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 			examplesSeen += inst.weight();
 			for (int i = 0; i < inst.numberOutputTargets(); i++) {
 				sumOfValues.addToValue(i, inst.weight() * inst.valueOutputAttribute(i));
@@ -1369,12 +1257,6 @@ public void trainOnInstanceImpl(MultiLabelInstance inst) {
 				sumOfAttrValues.addToValue(i, inst.weight() * inst.valueInputAttribute(i));
 				sumOfAttrSquares.addToValue(i, inst.weight() * inst.valueInputAttribute(i) * inst.valueInputAttribute(i));
 			}
-<<<<<<< HEAD
-			
-			//normalError.scaleValues(inst.weight());
-
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		}
 	}
 
@@ -1475,11 +1357,7 @@ protected LeafNode newLeafNode() {
 		return new LeafNode(this);
 	}
 
-<<<<<<< HEAD
 	public MultitargetPerceptron newLeafModel() {
-=======
-	protected MultitargetPerceptron newLeafModel() {
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		return new MultitargetPerceptron(this);
 	}
 
@@ -1489,7 +1367,6 @@ protected MultitargetPerceptron newLeafModel() {
 	protected void checkRoot() {
 		if (treeRoot == null) {
 			treeRoot = newLeafNode();
-			leafNodeCount = 1;
 		}
 	}
 
@@ -1556,29 +1433,17 @@ protected void attemptToSplit(LeafNode node, SplitNode parent, int parentIndex)
 					}
 				}
 			}
-<<<<<<< HEAD
-			
-			if (hoeffdingBound < this.tieThresholdOption.getValue() && this.printLogsOption.isSet()) System.out.println("Forced to split due to tie at " + this.examplesSeen); 
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		}
 
 		// If the splitting criterion were met, split the current node using the chosen attribute test, and
 		// make two new branches leading to (empty) leaves
 		if (shouldSplit) {
-<<<<<<< HEAD
-			if (node.parent == null && this.printLogsOption.isSet()) {
-				System.out.println("splitting root node at " + this.examplesSeen);
-			}
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 			AttributeExpansionSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
 
 			SplitNode newSplit = newSplitNode(splitDecision.predicate);
 			newSplit.copyStatistics(node);
 			newSplit.changeDetection = node.changeDetection;
 			newSplit.ID = node.ID;
-			leafNodeCount--;
 			//System.out.println("Splitting");
 			//System.out.println(examplesSeen);
 			for (int i = 0; i < 2; i++) { // Hardcoded for 2 values (due to the use of the Predicate class)
@@ -1591,7 +1456,6 @@ protected void attemptToSplit(LeafNode node, SplitNode parent, int parentIndex)
 				newChild.changeDetection = node.changeDetection;
 				newChild.setParent(newSplit);
 				newSplit.setChild(i, newChild);
-				leafNodeCount++;
 			}
 			if (parent == null && node.originalNode == null) {
 				treeRoot = newSplit;
@@ -1601,8 +1465,6 @@ protected void attemptToSplit(LeafNode node, SplitNode parent, int parentIndex)
 				parent.setChild(parentIndex, newSplit);
 				newSplit.setParent(parent);
 			}
-
-			splitNodeCount++;
 		}
 	}
 
diff --git a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java b/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
index 6cb747894..fc8b2aaea 100644
--- a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
+++ b/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
@@ -1,4 +1,3 @@
-<<<<<<< HEAD
 /*
  *    FIMTDD.java
  *    Copyright (C) 2015 Jožef Stefan Institute, Ljubljana, Slovenia
@@ -829,7 +828,7 @@ public void processInstance(Instance inst, Node node, double prediction, double
 					}
 				}
 
-				if (false && iNode.changeDetection && !inAlternate) {
+				if (iNode.changeDetection && !inAlternate) {
 					if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
 						iNode.initializeAlternateTree();
 						growthAllowed = false;
@@ -926,20 +925,11 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 					}
 				}
 			}
-//			if (hoeffdingBound < this.tieThresholdOption.getValue() && !(secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound)) {
-//				System.out.println("Forced to split due to tie at " + this.examplesSeen);
-//				System.out.println(SizeOf.fullSizeOf(node.attributeObservers) / 1000000.0);
-//			}
 		}
 
 		// If the splitting criterion were met, split the current node using the chosen attribute test, and
 		// make two new branches leading to (empty) leaves
 		if (shouldSplit) {
-//			System.out.println("splitting node");
-//			System.out.println(SizeOf.fullSizeOf(node.attributeObservers) / 1000000.0);
-//			if (node.parent == null) {
-//				System.out.println("splitting root node at " + this.examplesSeen);
-//			}
 			AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
 						
 			SplitNode newSplit = newSplitNode(splitDecision.splitTest);
@@ -989,976 +979,4 @@ public double scalarProduct(DoubleVector u, DoubleVector v) {
 	//endregion --- Processing methods
 	
 	//endregion ================ METHODS ================
-}
-
-=======
-/*
- *    FIMTDD.java
- *    Copyright (C) 2015 Jožef Stefan Institute, Ljubljana, Slovenia
- *    @author Aljaž Osojnik <aljaz.osojnik@ijs.si>
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.classifiers.trees;
-
-import java.io.Serializable;
-import java.util.Arrays;
-import java.util.LinkedList;
-import java.util.List;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-
-import moa.options.ClassOption;
-import moa.AbstractMOAObject;
-import moa.classifiers.Regressor;
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
-import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.classifiers.AbstractClassifier;
-import moa.core.AutoExpandVector;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.core.SizeOf;
-import moa.core.StringUtils;
-
-/*
- * Implementation of FIMTDD, regression and model trees for data streams.
- */
-
-public class FIMTDD extends AbstractClassifier implements Regressor {
-
-	private static final long serialVersionUID = 1L;
-
-	protected Node treeRoot;
-
-	protected int leafNodeCount = 0;
-	protected int splitNodeCount = 0;
-
-	protected double examplesSeen = 0.0;
-	protected double sumOfValues = 0.0;
-	protected double sumOfSquares = 0.0;
-
-	protected DoubleVector sumOfAttrValues = new DoubleVector();
-	protected DoubleVector sumOfAttrSquares = new DoubleVector();
-
-	public int maxID = 0;
-
-	//region ================ OPTIONS ================
-
-	public ClassOption splitCriterionOption = new ClassOption(
-			"splitCriterion", 's', "Split criterion to use.",
-			SplitCriterion.class, "moa.classifiers.core.splitcriteria.VarianceReductionSplitCriterion");
-
-	public IntOption gracePeriodOption = new IntOption(
-			"gracePeriod", 'g', "Number of instances a leaf should observe between split attempts.",
-			200, 0, Integer.MAX_VALUE);
-
-	public FloatOption splitConfidenceOption = new FloatOption(
-			"splitConfidence", 'c', "Allowed error in split decision, values close to 0 will take long to decide.",
-			0.0000001, 0.0, 1.0);
-
-	public FloatOption tieThresholdOption = new FloatOption(
-			"tieThreshold", 't', "Threshold below which a split will be forced to break ties.",
-			0.05, 0.0, 1.0);
-
-	public FloatOption PageHinckleyAlphaOption = new FloatOption(
-			"PageHinckleyAlpha", 'a', "Alpha value to use in the Page Hinckley change detection tests.",
-			0.005, 0.0, 1.0);
-
-	public IntOption PageHinckleyThresholdOption = new IntOption(
-			"PageHinckleyThreshold", 'h', "Threshold value used in the Page Hinckley change detection tests.",
-			50, 0, Integer.MAX_VALUE);
-
-	public FloatOption alternateTreeFadingFactorOption = new FloatOption(
-			"alternateTreeFadingFactor", 'f', "Fading factor used to decide if an alternate tree should replace an original.",
-			0.995, 0.0, 1.0);
-
-	public IntOption alternateTreeTMinOption = new IntOption(
-			"alternateTreeTMin", 'y', "Tmin value used to decide if an alternate tree should replace an original.",
-			150, 0, Integer.MAX_VALUE);
-
-	public IntOption alternateTreeTimeOption = new IntOption(
-			"alternateTreeTime", 'u', "The number of instances used to decide if an alternate tree should be discarded.",
-			1500, 0, Integer.MAX_VALUE);
-
-	public FlagOption regressionTreeOption = new FlagOption(
-			"regressionTree", 'e', "Build a regression tree instead of a model tree.");
-
-	public FloatOption learningRatioOption = new FloatOption(
-			"learningRatio", 'l', "Learning ratio to used for training the Perceptrons in the leaves.",
-			0.02, 0, 1.00);
-
-	public FloatOption learningRateDecayFactorOption = new FloatOption(
-			"learningRatioDecayFactor", 'd', "Learning rate decay factor (not used when learning rate is constant).",
-			0.001, 0, 1.00);
-
-	public FlagOption learningRatioConstOption = new FlagOption(
-			"learningRatioConst", 'p', "Keep learning rate constant instead of decaying.");
-
-	//endregion ================ OPTIONS ================
-
-	//region ================ CLASSES ================
-
-	public abstract static class Node extends AbstractMOAObject {
-
-		private static final long serialVersionUID = 1L;
-
-		public int ID;
-
-		protected FIMTDD tree;
-		
-		protected boolean changeDetection = true;
-		
-		protected Node parent;
-
-		protected Node alternateTree;
-		protected Node originalNode;
-
-		// The statistics for this node:
-		// Number of instances that have reached it
-		protected double examplesSeen;
-		// Sum of y values
-		protected double sumOfValues;
-		// Sum of squared y values
-		protected double sumOfSquares;
-		// Sum of absolute errors
-		protected double sumOfAbsErrors; // Needed for PH tracking of mean error
-
-		public Node(FIMTDD tree) {
-			this.tree = tree;
-			ID = tree.maxID; 
-		}
-
-		public void copyStatistics(Node node) {
-			examplesSeen = node.examplesSeen;
-			sumOfValues = node.sumOfValues;
-			sumOfSquares = node.sumOfSquares;
-			sumOfAbsErrors = node.sumOfAbsErrors;
-		}
-
-		public int calcByteSize() {
-			return (int) SizeOf.fullSizeOf(this);
-		}
-
-		/**
-		 * Set the parent node
-		 */
-		public void setParent(Node parent) {
-			this.parent = parent;    
-		}
-
-		/**
-		 * Return the parent node
-		 */
-		public Node getParent() {
-			return parent;
-		}
-
-		public void disableChangeDetection() {
-			changeDetection = false;
-		}
-
-		public void restartChangeDetection() {
-			changeDetection = true;
-		}
-		
-		public void getDescription(StringBuilder sb, int indent) {
-			
-		}
-
-		public double getPrediction(Instance inst) {
-			return 0;
-		}
-		
-		public void describeSubtree(StringBuilder out, int indent) {
-			StringUtils.appendIndented(out, indent, "Leaf");
-		}
-		
-		public int getLevel() {
-			Node target = this;
-			int level = 0;
-			while (target.getParent() != null) {
-				if (target.skipInLevelCount()) {
-					target = target.getParent();
-					continue;
-				}
-				level = level + 1;
-				target = target.getParent();
-			}
-			if (target.originalNode == null) {
-				return level;
-			} else {
-				return level + originalNode.getLevel();
-			}
-		}
-
-		public void setChild(int parentBranch, Node node) {
-		}
-
-		public int getChildIndex(Node child) {
-			return -1;
-		}
-
-		public int getNumSubtrees() {
-			return 1;
-		}
-
-		protected boolean skipInLevelCount() {
-			return false;
-		}
-	}
-
-	public static class LeafNode extends Node {
-
-		private static final long serialVersionUID = 1L;
-
-		// Perceptron model that carries out the actual learning in each node
-		public FIMTDDPerceptron learningModel;
-
-		protected AutoExpandVector<FIMTDDNumericAttributeClassObserver> attributeObservers = new AutoExpandVector<FIMTDDNumericAttributeClassObserver>();
-		
-		protected double examplesSeenAtLastSplitEvaluation = 0;
-
-		/**
-		 * Create a new LeafNode
-		 */
-		public LeafNode(FIMTDD tree) {
-			super(tree);
-			if (tree.buildingModelTree()) {
-				learningModel = tree.newLeafModel();
-			}
-			examplesSeen = 0;
-			sumOfValues = 0;
-			sumOfSquares = 0;
-			sumOfAbsErrors = 0;
-		}
-
-		public void setChild(int parentBranch, Node node) {
-		}
-
-		public int getChildIndex(Node child) {
-			return -1;
-		}
-
-		public int getNumSubtrees() {
-			return 1;
-		}
-
-		protected boolean skipInLevelCount() {
-			return false;
-		}
-		
-		/**
-		 * Method to learn from an instance that passes the new instance to the perceptron learner,
-		 * and also prevents the class value from being truncated to an int when it is passed to the
-		 * attribute observer
-		 */
-		public void learnFromInstance(Instance inst, boolean growthAllowed) {
-			//The prediction must be calculated here -- it may be different from the tree's prediction due to alternate trees
-			
-			// Update the statistics for this node
-			// number of instances passing through the node
-			examplesSeen += inst.weight();
-
-			// sum of y values
-			sumOfValues += inst.weight() * inst.classValue();
-
-			// sum of squared y values
-			sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
-
-			// sum of absolute errors
-			sumOfAbsErrors += inst.weight() * Math.abs(tree.normalizeTargetValue(Math.abs(inst.classValue() - getPrediction(inst))));
-
-			if (tree.buildingModelTree()) learningModel.updatePerceptron(inst);
-
-			for (int i = 0; i < inst.numAttributes() - 1; i++) {
-				int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
-				FIMTDDNumericAttributeClassObserver obs = attributeObservers.get(i);
-				if (obs == null) {
-					// At this stage all nominal attributes are ignored
-					if (inst.attribute(instAttIndex).isNumeric()) {
-						obs = tree.newNumericClassObserver();
-						this.attributeObservers.set(i, obs);
-					}
-				}
-				if (obs != null) {
-					obs.observeAttributeClass(inst.value(instAttIndex), inst.classValue(), inst.weight());
-				}
-			}
-
-			if (growthAllowed) {
-				checkForSplit(tree);
-			}
-		}
-
-		/**
-		 * Return the best split suggestions for this node using the given split criteria
-		 */
-		public AttributeSplitSuggestion[] getBestSplitSuggestions(SplitCriterion criterion) {
-
-			List<AttributeSplitSuggestion> bestSuggestions = new LinkedList<AttributeSplitSuggestion>();
-
-			// Set the nodeStatistics up as the preSplitDistribution, rather than the observedClassDistribution
-			double[] nodeSplitDist = new double[] {examplesSeen, sumOfValues, sumOfSquares};
-
-			for (int i = 0; i < this.attributeObservers.size(); i++) {
-				FIMTDDNumericAttributeClassObserver obs = this.attributeObservers.get(i);
-				if (obs != null) {
-
-					// AT THIS STAGE NON-NUMERIC ATTRIBUTES ARE IGNORED
-					AttributeSplitSuggestion bestSuggestion = null;
-					if (obs instanceof FIMTDDNumericAttributeClassObserver) {
-						bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion, nodeSplitDist, i, true);
-					}
-
-					if (bestSuggestion != null) {
-						bestSuggestions.add(bestSuggestion);
-					}
-				}
-			}
-			return bestSuggestions.toArray(new AttributeSplitSuggestion[bestSuggestions.size()]);
-		}
-
-		/**
-		 * Retrieve the class votes using the perceptron learner
-		 */
-		public double getPredictionModel(Instance inst) {
-			return learningModel.prediction(inst);
-		}
-
-		public double getPredictionTargetMean(Instance inst) {
-			return (examplesSeen > 0.0) ? sumOfValues / examplesSeen : 0.0;
-		}
-
-		public double getPrediction(Instance inst) {
-			return (tree.buildingModelTree()) ? getPredictionModel(inst) : getPredictionTargetMean(inst);
-		}
-		
-		public void checkForSplit(FIMTDD tree) {
-			// If it has seen Nmin examples since it was last tested for splitting, attempt a split of this node
-			if (examplesSeen - examplesSeenAtLastSplitEvaluation >= tree.gracePeriodOption.getValue()) {
-				int index = (parent != null) ? parent.getChildIndex(this) : 0;
-				tree.attemptToSplit(this, parent, index);
-
-				// Take note of how many instances were seen when this split evaluation was made, so we know when to perform the next split evaluation
-				examplesSeenAtLastSplitEvaluation = examplesSeen;
-			}
-		}
-
-		public void describeSubtree(StringBuilder out, int indent) {
-			StringUtils.appendIndented(out, indent, "Leaf ");
-			if (tree.buildingModelTree()) {
-				learningModel.getModelDescription(out, 0);
-			} else {
-				out.append(tree.getClassNameString() + " = " + String.format("%.4f", (sumOfValues / examplesSeen)));
-				StringUtils.appendNewline(out);
-			}
-		}
-	}
-
-	public abstract static class InnerNode extends Node {
-		// The InnerNode and SplitNode design is used for easy extension in ORTO
-		private static final long serialVersionUID = 1L;
-
-		protected AutoExpandVector<Node> children = new AutoExpandVector<Node>();
-
-		// The error values for the Page Hinckley test
-		// PHmT = the cumulative sum of the errors
-		// PHMT = the minimum error value seen so far
-		protected double PHsum = 0;
-		protected double PHmin = Double.MAX_VALUE;
-
-		// Keep track of the statistics for loss error calculations
-		protected double lossExamplesSeen;
-		protected double lossFadedSumOriginal;
-		protected double lossFadedSumAlternate;
-		protected double lossNumQiTests;
-		protected double lossSumQi;
-		protected double previousWeight = 0;
-		
-		public InnerNode(FIMTDD tree) {
-			super(tree);
-		}
-
-		public int numChildren() {
-			return children.size();
-		}
-
-		public Node getChild(int index) {
-			return children.get(index);
-		}
-
-		public int getChildIndex(Node child) {
-			return children.indexOf(child);
-		}
-
-		public void setChild(int index, Node child) {
-			children.set(index, child);
-		}
-
-		public void disableChangeDetection() {
-			changeDetection = false;
-			for (Node child : children) {
-				child.disableChangeDetection();
-			}
-		}
-
-		public void restartChangeDetection() {
-			if (alternateTree == null) {
-				changeDetection = true;
-				PHsum = 0;
-				PHmin = Integer.MAX_VALUE;
-				for (Node child : children)
-					child.restartChangeDetection();
-			}
-		}
-		
-		/**
-		 * Check to see if the tree needs updating
-		 */
-		public boolean PageHinckleyTest(double error, double threshold) {    
-			// Update the cumulative mT sum
-			PHsum += error;
-
-			// Update the minimum mT value if the new mT is
-			// smaller than the current minimum
-			if(PHsum < PHmin) {
-				PHmin = PHsum;
-			}
-			// Return true if the cumulative value - the current minimum is
-			// greater than the current threshold (in which case we should adapt)
-			return PHsum - PHmin > threshold;
-		}
-		
-		public void initializeAlternateTree() {
-			// Start a new alternate tree, beginning with a learning node
-			alternateTree = tree.newLeafNode();
-			alternateTree.originalNode = this;
-
-			// Set up the blank statistics
-			// Number of instances reaching this node since the alternate tree was started
-			lossExamplesSeen = 0;
-			// Faded squared error (original tree)
-			lossFadedSumOriginal = 0;
-			// Faded squared error (alternate tree)
-			lossFadedSumAlternate = 0;
-			// Number of evaluations of alternate tree
-			lossNumQiTests = 0;
-			// Sum of Qi values
-			lossSumQi = 0;
-			// Number of examples at last test
-			previousWeight = 0;
-
-			// Disable the change detection mechanism bellow this node
-			disableChangeDetection();
-		}
-	}
-	
-	public static class SplitNode extends InnerNode {
-
-		private static final long serialVersionUID = 1L;
-
-		protected InstanceConditionalTest splitTest;
-
-		/**
-		 * Create a new SplitNode
-		 * @param tree 
-		 */
-		public SplitNode(InstanceConditionalTest splitTest, FIMTDD tree) {
-			super(tree);
-			this.splitTest = splitTest;
-		}
-
-		public int instanceChildIndex(Instance inst) {
-			return splitTest.branchForInstance(inst);
-		}
-		
-		public Node descendOneStep(Instance inst) {
-			return children.get(splitTest.branchForInstance(inst));
-		}
-
-		public void describeSubtree(StringBuilder out, int indent) {
-			for (int branch = 0; branch < children.size(); branch++) {
-				Node child = getChild(branch);
-				if (child != null) {
-					StringUtils.appendIndented(out, indent, "if ");
-					out.append(this.splitTest.describeConditionForBranch(branch,
-							tree.getModelContext()));
-					out.append(": ");
-					StringUtils.appendNewline(out);
-					child.describeSubtree(out, indent + 2);
-				}
-			}
-		}
-
-		public double getPrediction(Instance inst) {
-			return children.get(splitTest.branchForInstance(inst)).getPrediction(inst);
-		}
-	}
-
-	public class FIMTDDPerceptron implements Serializable {
-
-		private static final long serialVersionUID = 1L;
-		
-		protected FIMTDD tree;
-		
-		// The Perception weights 
-		protected DoubleVector weightAttribute = new DoubleVector(); 
-
-		protected double sumOfValues;
-		protected double sumOfSquares;
-
-		// The number of instances contributing to this model
-		protected double instancesSeen = 0;
-
-		// If the model should be reset or not
-		protected boolean reset;
-
-		public String getPurposeString() {
-			return "A perceptron regressor as specified by Ikonomovska et al. used for FIMTDD";
-		}
-
-		public FIMTDDPerceptron(FIMTDDPerceptron original) {
-			this.tree = original.tree;
-			weightAttribute = (DoubleVector) original.weightAttribute.copy();
-			reset = false;
-		}
-
-		public FIMTDDPerceptron(FIMTDD tree) {
-			this.tree = tree;
-			reset = true;
-		}
-
-
-		public DoubleVector getWeights() {
-			return weightAttribute;
-		}
-
-		/**
-		 * Update the model using the provided instance
-		 */
-		public void updatePerceptron(Instance inst) {
-
-			// Initialize perceptron if necessary   
-			if (reset == true) {
-				reset = false;
-				weightAttribute = new DoubleVector();
-				instancesSeen = 0;
-				for (int j = 0; j < inst.numAttributes(); j++) { // The last index corresponds to the constant b
-					weightAttribute.setValue(j, 2 * tree.classifierRandom.nextDouble() - 1);
-				}
-			}
-
-			// Update attribute statistics
-			instancesSeen += inst.weight();
-
-			// Update weights
-			double learningRatio = 0.0;
-			if (tree.learningRatioConstOption.isSet()) {
-				learningRatio = learningRatioOption.getValue();
-			} else {
-				learningRatio = learningRatioOption.getValue() / (1 + instancesSeen * tree.learningRateDecayFactorOption.getValue());
-			}
-
-			sumOfValues += inst.weight() * inst.classValue();
-			sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
-
-			// Loop for compatibility with bagging methods 
-			for (int i = 0; i < (int) inst.weight(); i++) {
-				updateWeights(inst, learningRatio);
-			}
-		}
-
-		public void updateWeights(Instance inst, double learningRatio) {
-			// Compute the normalized instance and the delta
-			DoubleVector normalizedInstance = normalizedInstance(inst); 
-			double normalizedPrediction = prediction(normalizedInstance);
-			double normalizedValue = tree.normalizeTargetValue(inst.classValue());
-			double delta = normalizedValue - normalizedPrediction;
-			normalizedInstance.scaleValues(delta * learningRatio);
-			
-			weightAttribute.addValues(normalizedInstance);
-		}
-
-		public DoubleVector normalizedInstance(Instance inst) {
-			// Normalize Instance
-			DoubleVector normalizedInstance = new DoubleVector();
-			for (int j = 0; j < inst.numAttributes() - 1; j++) {
-				int instAttIndex = modelAttIndexToInstanceAttIndex(j, inst);
-				double mean = tree.sumOfAttrValues.getValue(j) / tree.examplesSeen;
-				double sd = computeSD(tree.sumOfAttrSquares.getValue(j), tree.sumOfAttrValues.getValue(j), tree.examplesSeen);
-				if (inst.attribute(instAttIndex).isNumeric() && tree.examplesSeen > 1 && sd > 0)
-					normalizedInstance.setValue(j, (inst.value(instAttIndex) - mean) / (3 * sd));
-				else
-					normalizedInstance.setValue(j, 0);
-			}
-			if (tree.examplesSeen > 1)
-				normalizedInstance.setValue(inst.numAttributes() - 1, 1.0); // Value to be multiplied with the constant factor
-			else
-				normalizedInstance.setValue(inst.numAttributes() - 1, 0.0);
-			return normalizedInstance;
-		}
-
-		/**
-		 * Output the prediction made by this perceptron on the given instance
-		 */
-		public double prediction(DoubleVector instanceValues) {
-			return scalarProduct(weightAttribute, instanceValues);
-		}
-
-		protected double prediction(Instance inst) {
-			DoubleVector normalizedInstance = normalizedInstance(inst);
-			double normalizedPrediction = prediction(normalizedInstance);
-			return denormalizePrediction(normalizedPrediction, tree);
-		}
-
-		private double denormalizePrediction(double normalizedPrediction, FIMTDD tree) {
-			double mean = tree.sumOfValues / tree.examplesSeen;
-			double sd = computeSD(tree.sumOfSquares, tree.sumOfValues, tree.examplesSeen);
-			if (examplesSeen > 1) 
-				return normalizedPrediction * sd * 3 + mean;
-			else
-				return 0.0;
-		}
-		
-		public void getModelDescription(StringBuilder out, int indent) {
-	        StringUtils.appendIndented(out, indent, getClassNameString() + " =");
-			if (getModelContext() != null) {
-				for (int j = 0; j < getModelContext().numAttributes() - 1; j++) {
-					if (getModelContext().attribute(j).isNumeric()) {
-						out.append((j == 0 || weightAttribute.getValue(j) < 0) ? " " : " + ");
-		                out.append(String.format("%.4f", weightAttribute.getValue(j)));
-		                out.append(" * ");
-		                out.append(getAttributeNameString(j));
-		            }
-		        }
-				out.append(" + " + weightAttribute.getValue((getModelContext().numAttributes() - 1)));
-			}
-	        StringUtils.appendNewline(out);
-		}
-	}
-
-
-	//endregion ================ CLASSES ================
-
-	//region ================ METHODS ================
-
-	// region --- Regressor methods
-	
-	public String getPurposeString() {
-		return "Implementation of the FIMT-DD tree as described by Ikonomovska et al.";
-	}
-
-	public void resetLearningImpl() {
-		this.treeRoot = null;
-		this.leafNodeCount = 0;
-		this.splitNodeCount = 0;
-		this.maxID = 0;
-		this.examplesSeen = 0;
-		this.sumOfValues = 0.0;
-		this.sumOfSquares = 0.0;
-
-		this.sumOfAttrValues = new DoubleVector();
-		this.sumOfAttrSquares = new DoubleVector();
-	}
-
-	public boolean isRandomizable() {
-		return true;
-	}
-
-	public void getModelDescription(StringBuilder out, int indent) {
-		if (treeRoot != null) treeRoot.describeSubtree(out, indent);
-	}
-
-	protected Measurement[] getModelMeasurementsImpl() {
-		return new Measurement[]{ 
-				new Measurement("tree size (leaves)", this.leafNodeCount)
-		};
-	}
-
-	public int calcByteSize() {
-		return (int) SizeOf.fullSizeOf(this);
-	}
-
-	public double[] getVotesForInstance(Instance inst) {
-		if (treeRoot == null) {
-			return new double[] {0};
-		}
-
-		double prediction = treeRoot.getPrediction(inst);
-
-		return new double[] {prediction};
-	}
-
-	public double normalizeTargetValue(double value) {
-		if (examplesSeen > 1) {
-			double sd = Math.sqrt((sumOfSquares - ((sumOfValues * sumOfValues)/examplesSeen))/examplesSeen);
-			double average = sumOfValues / examplesSeen;
-			if (sd > 0 && examplesSeen > 1)
-				return (value - average) / (3 * sd);
-			else
-				return 0.0;
-		}
-		return 0.0;
-	}
-
-	public double getNormalizedError(Instance inst, double prediction) {
-		double normalPrediction = normalizeTargetValue(prediction);
-		double normalValue = normalizeTargetValue(inst.classValue());
-		return Math.abs(normalValue - normalPrediction);
-	}
-
-
-	/**
-	 * Method for updating (training) the model using a new instance
-	 */
-	public void trainOnInstanceImpl(Instance inst) {
-		checkRoot();
-
-		examplesSeen += inst.weight();
-		sumOfValues += inst.weight() * inst.classValue();
-		sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
-
-		for (int i = 0; i < inst.numAttributes() - 1; i++) {
-			int aIndex = modelAttIndexToInstanceAttIndex(i, inst);
-			sumOfAttrValues.addToValue(i, inst.weight() * inst.value(aIndex));
-			sumOfAttrSquares.addToValue(i, inst.weight() * inst.value(aIndex) * inst.value(aIndex));
-		}
-
-		double prediction = treeRoot.getPrediction(inst);
-		processInstance(inst, treeRoot, prediction, getNormalizedError(inst, prediction), true, false);
-	}
-
-	public void processInstance(Instance inst, Node node, double prediction, double normalError, boolean growthAllowed, boolean inAlternate) {
-		Node currentNode = node;
-		while (true) {
-			if (currentNode instanceof LeafNode) {
-				((LeafNode) currentNode).learnFromInstance(inst, growthAllowed);
-				break;
-			} else {
-				currentNode.examplesSeen += inst.weight();
-				currentNode.sumOfAbsErrors += inst.weight() * normalError;
-				SplitNode iNode = (SplitNode) currentNode;
-				if (!inAlternate && iNode.alternateTree != null) {
-					boolean altTree = true;
-					double lossO = Math.pow(inst.classValue() - prediction, 2);
-					double lossA = Math.pow(inst.classValue() - iNode.alternateTree.getPrediction(inst), 2);
-					
-					// Loop for compatibility with bagging methods
-					for (int i = 0; i < inst.weight(); i++) {
-						iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
-						iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
-						iNode.lossExamplesSeen++;
-						
-						double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
-						iNode.lossSumQi += Qi;
-						iNode.lossNumQiTests += 1;
-					}
-					double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
-					double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
-					double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
-					
-					if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
-						iNode.previousWeight = iNode.lossExamplesSeen;
-						if (Qi > 0) {
-							// Switch the subtrees
-							Node parent = currentNode.getParent();
-
-							if (parent != null) {
-								Node replacementTree = iNode.alternateTree;
-								parent.setChild(parent.getChildIndex(currentNode), replacementTree);
-								if (growthAllowed) replacementTree.restartChangeDetection();
-							} else {
-								treeRoot = iNode.alternateTree;
-								treeRoot.restartChangeDetection();
-							}
-
-							currentNode = iNode.alternateTree;
-							currentNode.originalNode = null;
-							altTree = false;
-						} else if (
-								(QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * this.gracePeriodOption.getValue()))
-								|| iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()
-								) {
-							// Remove the alternate tree
-							iNode.alternateTree = null;
-							if (growthAllowed) iNode.restartChangeDetection();
-							altTree = false;
-						}
-					}
-
-					if (altTree) {
-						growthAllowed = false;
-						processInstance(inst, iNode.alternateTree, prediction, normalError, true, true);
-					}
-				}
-
-				if (iNode.changeDetection && !inAlternate) {
-					if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
-						iNode.initializeAlternateTree();
-					}
-				}
-				if (currentNode instanceof SplitNode) {
-					currentNode = ((SplitNode) currentNode).descendOneStep(inst);
-				} 
-			}
-		}
-	}
-
-	// endregion --- Regressor methods
-	
-	// region --- Object instatiation methods
-
-	protected FIMTDDNumericAttributeClassObserver newNumericClassObserver() {
-		return new FIMTDDNumericAttributeClassObserver();
-	}
-
-	protected SplitNode newSplitNode(InstanceConditionalTest splitTest) {
-		maxID++;
-		return new SplitNode(splitTest, this);
-	}
-
-	protected LeafNode newLeafNode() {
-		maxID++;
-		return new LeafNode(this);
-	}
-
-	protected FIMTDDPerceptron newLeafModel() {
-		return new FIMTDDPerceptron(this);
-	}
-
-	//endregion --- Object instatiation methods
-	
-	// region --- Processing methods
-	
-	protected void checkRoot() {
-		if (treeRoot == null) {
-			treeRoot = newLeafNode();
-			leafNodeCount = 1;
-		}
-	}
-
-	public static double computeHoeffdingBound(double range, double confidence, double n) {
-		return Math.sqrt(( (range * range) * Math.log(1 / confidence)) / (2.0 * n));
-	}
-
-	public boolean buildingModelTree() {
-		return !regressionTreeOption.isSet();
-	}
-
-	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
-		// Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
-		SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
-
-		// Using this criterion, find the best split per attribute and rank the results
-		AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion);
-		Arrays.sort(bestSplitSuggestions);
-
-		// Declare a variable to determine if any of the splits should be performed
-		boolean shouldSplit = false;
-
-		// If only one split was returned, use it
-		if (bestSplitSuggestions.length < 2) {
-			shouldSplit = bestSplitSuggestions.length > 0;
-		} else { // Otherwise, consider which of the splits proposed may be worth trying
-
-			// Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
-			// to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
-			double hoeffdingBound = computeHoeffdingBound(1, this.splitConfidenceOption.getValue(), node.examplesSeen);
-			// Determine the top two ranked splitting suggestions
-			AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-			AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
-
-			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
-			// as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
-			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
-			// splitting should occur.
-			// Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
-			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
-			// competing attributes are equally good, and the split will be made on the one with the higher SDR value.
-			if ((secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) || (hoeffdingBound < this.tieThresholdOption.getValue())) {
-				shouldSplit = true;
-			}
-			// If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
-			else {
-				for (int i = 0; i < node.attributeObservers.size(); i++) {
-					FIMTDDNumericAttributeClassObserver obs = node.attributeObservers.get(i);
-					if (obs != null) {
-						obs.removeBadSplits(splitCriterion, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound);    
-					}
-				}
-			}
-		}
-
-		// If the splitting criterion were met, split the current node using the chosen attribute test, and
-		// make two new branches leading to (empty) leaves
-		if (shouldSplit) {
-			AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-
-			SplitNode newSplit = newSplitNode(splitDecision.splitTest);
-			newSplit.copyStatistics(node);
-			newSplit.changeDetection = node.changeDetection;
-			newSplit.ID = node.ID;
-			leafNodeCount--;
-			for (int i = 0; i < splitDecision.numSplits(); i++) {
-				LeafNode newChild = newLeafNode();
-				if (buildingModelTree()) {
-					// Copy the splitting node's perceptron to it's children
-					newChild.learningModel = new FIMTDDPerceptron((FIMTDDPerceptron) node.learningModel);
-					
-				}
-				newChild.changeDetection = node.changeDetection;
-				newChild.setParent(newSplit);
-				newSplit.setChild(i, newChild);
-				leafNodeCount++;
-			}
-			if (parent == null && node.originalNode == null) {
-				treeRoot = newSplit;
-			} else if (parent == null && node.originalNode != null) {
-				node.originalNode.alternateTree = newSplit;
-			} else {
-				((SplitNode) parent).setChild(parentIndex, newSplit);
-				newSplit.setParent(parent);
-			}
-			
-			splitNodeCount++;
-		}
-	}
-	
-	public double computeSD(double squaredVal, double val, double size) {
-		if (size > 1)
-			return Math.sqrt((squaredVal - ((val * val) / size)) / size);
-		else
-			return 0.0;
-	}
-	
-	public double scalarProduct(DoubleVector u, DoubleVector v) {
-		double ret = 0.0;
-		for (int i = 0; i < Math.max(u.numValues(), v.numValues()); i++) {
-			ret += u.getValue(i) * v.getValue(i);
-		}
-		return ret;
-	}
-	//endregion --- Processing methods
-	
-	//endregion ================ METHODS ================
-}
-
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/trees/ORTO.java b/moa/src/main/java/moa/classifiers/trees/ORTO.java
index 2745dcc7e..7ab9734db 100644
--- a/moa/src/main/java/moa/classifiers/trees/ORTO.java
+++ b/moa/src/main/java/moa/classifiers/trees/ORTO.java
@@ -35,16 +35,11 @@
 import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
 import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
-<<<<<<< HEAD
-import moa.classifiers.trees.FIMTDD.InnerNode;
-import moa.classifiers.trees.FIMTDD.Node;
+
 import moa.core.AutoExpandVector;
 import moa.core.Measurement;
 import moa.core.StringUtils;
-=======
-import moa.core.AutoExpandVector;
-import moa.core.Measurement;
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+
 
 /*
  * Implementation of ORTO, option trees for data streams.
@@ -127,15 +122,9 @@ public int getNumSubtrees() {
 
 		public int directionForBestTree() {
 			int d = 0;
-<<<<<<< HEAD
-			double min = Double.MAX_VALUE;
-			for (int i = 0; i < numChildren(); i++) {
-				double tmp = getFFRatio(i);
-=======
 			double tmp = 0.0, min = Double.MAX_VALUE;
 			for (int i = 0; i < children.size(); i++) {
 				tmp = getFFRatio(i);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				if (tmp < min) {
 					min = tmp;
 					d = i;
@@ -144,38 +133,22 @@ public int directionForBestTree() {
 			return d;
 		}
 
-<<<<<<< HEAD
 		public double getPrediction(Instance inst) {
-=======
-		public double getPrediction(Instance inst, ORTO tree) {
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 			double[] predictions = new double[numChildren()];
 			for (int i = 0; i < numChildren(); i++) {
 				predictions[i] = getChild(i).getPrediction(inst);
 			}
-<<<<<<< HEAD
 			return aggregate(predictions);
 		}
 
 		private double aggregate(double[] predictions) {
 			if (((ORTO) tree).optionNodeAggregationOption.getChosenIndex() == 0) { // Average
-=======
-			return aggregate(predictions, tree);
-		}
-
-		private double aggregate(double[] predictions, ORTO tree) {
-			if (tree.optionNodeAggregationOption.getChosenIndex() == 0) { // Average
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				double sum = 0.0;
 				for (int i = 0; i < predictions.length; i++) {
 					sum += predictions[i];
 				}
 				return sum / predictions.length;
-<<<<<<< HEAD
 			} else if (((ORTO) tree).optionNodeAggregationOption.getChosenIndex() == 1) {
-=======
-			} else if (tree.optionNodeAggregationOption.getChosenIndex() == 1) {
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				int d = directionForBestTree();
 				return predictions[d];
 			} else {
@@ -190,7 +163,6 @@ public double getFFRatio(int childIndex) {
 		protected boolean skipInLevelCount() {
 			return true;
 		}
-<<<<<<< HEAD
 		
 		@Override
 		public void describeSubtree(StringBuilder out, int indent) {
@@ -203,8 +175,7 @@ public void describeSubtree(StringBuilder out, int indent) {
 				split.describeSubtree(out, indent + 2);
 			}
 		}
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+
 	}
 
 	//endregion ================ CLASSES ================
@@ -239,11 +210,7 @@ public void processInstance(Instance inst, Node node, double prediction, double
 			Node currentNode = node;
 			while (true) {
 				if (currentNode instanceof LeafNode) {
-<<<<<<< HEAD
 					((LeafNode) currentNode).learnFromInstance(inst, growthAllowed, prediction);
-=======
-					((LeafNode) currentNode).learnFromInstance(inst, growthAllowed);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 					break;
 				} else {
 					currentNode.examplesSeen += inst.weight();
@@ -252,11 +219,7 @@ public void processInstance(Instance inst, Node node, double prediction, double
 					if (!inAlternate && iNode.alternateTree != null) {
 						boolean altTree = true;
 						double lossO = Math.pow(inst.classValue() - prediction, 2);
-<<<<<<< HEAD
 						double lossA = Math.pow(inst.classValue() - iNode.alternateTree.getPrediction(inst), 2);
-=======
-						double lossA = Math.pow(inst.classValue() - currentNode.alternateTree.getPrediction(inst), 2);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 						
 						// Loop for compatibility with bagging methods
 						for (int i = 0; i < inst.weight(); i++) {
@@ -276,11 +239,7 @@ public void processInstance(Instance inst, Node node, double prediction, double
 							iNode.previousWeight = iNode.lossExamplesSeen;
 							if (Qi > 0) {
 								// Switch the subtrees
-<<<<<<< HEAD
 								Node parent = iNode.getParent();
-=======
-								Node parent = currentNode.parent;
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 								
 								if (parent != null) {
 									Node replacementTree = iNode.alternateTree;
@@ -290,11 +249,7 @@ public void processInstance(Instance inst, Node node, double prediction, double
 									treeRoot = iNode.alternateTree;
 									treeRoot.restartChangeDetection();
 								}
-<<<<<<< HEAD
 								optionNodeCount += iNode.alternateTree.getNumSubtrees() - iNode.getNumSubtrees();
-=======
-								optionNodeCount += currentNode.alternateTree.getNumSubtrees() - currentNode.getNumSubtrees();
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 								removeExcessTrees();
 										
 								currentNode = iNode.alternateTree;
@@ -309,11 +264,7 @@ public void processInstance(Instance inst, Node node, double prediction, double
 						}
 						if (altTree) {
 							growthAllowed = false; // this is the growth of the original tree
-<<<<<<< HEAD
 							processInstance(inst, iNode.alternateTree, prediction, normalError, true, true); // growth is allowed in the alt tree
-=======
-							processInstance(inst, currentNode.alternateTree, prediction, normalError, true, true); // growth is allowed in the alt tree
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 						} else if (currentNode instanceof OptionNode) {
 							// this happens when an option node is switched into the tree
 							for (Node child : ((OptionNode) currentNode).children) {
@@ -341,35 +292,23 @@ public void processInstance(Instance inst, Node node, double prediction, double
 	}
 	
 	public void processInstanceOptionNode(Instance inst, OptionNode node, double prediction, double normalError, boolean growthAllowed, boolean inAlternate) {
-<<<<<<< HEAD
 		node.examplesSeen += inst.weight();
 		node.sumOfAbsErrors += inst.weight() * normalError;
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+
 		if (node.changeDetection) {
 			double error = Math.abs(prediction - inst.classValue());
 			node.sumOfAbsErrors += error;
 			
 			if (((InnerNode) node).PageHinckleyTest(error - node.sumOfAbsErrors / node.examplesSeen + PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
 				node.initializeAlternateTree();
-<<<<<<< HEAD
 				growthAllowed = false;
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 			}
 		}
 
 		for (Node child : node.children) {
 			int index = node.getChildIndex(child);
 			double childPrediction = child.getPrediction(inst);
-<<<<<<< HEAD
-			node.optionFFSeen[index] = node.optionFFSeen[index] * optionFadingFactorOption.getValue() + 1;
-			node.optionFFSSL[index] = node.optionFFSSL[index] * optionFadingFactorOption.getValue() + Math.pow(childPrediction - inst.classValue(), 2);
-		}
 
-		for (Node child : node.children) {
-			processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed, inAlternate);
-=======
 			// Loop for compatibility with bagging methods
 			for (int i = 0; i < inst.weight(); i++) {
 				node.optionFFSeen[index] = node.optionFFSeen[index] * optionFadingFactorOption.getValue() + 1;
@@ -379,7 +318,6 @@ public void processInstanceOptionNode(Instance inst, OptionNode node, double pre
 
 		for (Node child : node.children) {
 			processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed && node.alternateTree == null, inAlternate);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		}
 	}
 	
@@ -397,10 +335,6 @@ protected OptionNode newOptionNode() {
 	// region --- Processing methods
 
 	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
-<<<<<<< HEAD
-
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		// Initialize the split criterion 
 		SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(splitCriterionOption);
 
@@ -408,11 +342,7 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 		AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion);
 		List<AttributeSplitSuggestion> acceptedSplits = new LinkedList<AttributeSplitSuggestion>();
 		Arrays.sort(bestSplitSuggestions);
-<<<<<<< HEAD
-		
-=======
 
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		// Declare a variable to determine the number of splits to be performed
 		int numSplits = 0;
 
@@ -430,10 +360,7 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 			AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
 			AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
 
-<<<<<<< HEAD
-			
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+
 			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
 			// as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
 			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
@@ -445,7 +372,6 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 				numSplits = 1;
 				acceptedSplits.add(bestSuggestion);
 			} else if (numTrees < maxTreesOption.getValue() && node.getLevel() <= maxOptionLevelOption.getValue()) {
-<<<<<<< HEAD
 				for (int i = 0; i < bestSplitSuggestions.length; i++) {
 					AttributeSplitSuggestion suggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1 - i];
 					if (suggestion.merit / bestSuggestion.merit >= 1 - hoeffdingBound) {
@@ -456,15 +382,7 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 					}
 						
 				}
-				
-=======
-				for (AttributeSplitSuggestion suggestion : bestSplitSuggestions) {
-					if (suggestion.merit / bestSuggestion.merit >= 1 - hoeffdingBound) {
-						numSplits++;
-						acceptedSplits.add(suggestion);
-					}
-				}
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+
 			} else if (hoeffdingBound < tieThresholdOption.getValue()) {
 				numSplits = 1;
 				acceptedSplits.add(bestSplitSuggestions[0]);
@@ -483,11 +401,7 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 		if (numSplits > 0) {
 			double optionFactor = numSplits * Math.pow(optionDecayFactorOption.getValue(), (double) node.getLevel());
 
-<<<<<<< HEAD
-			if (numSplits == 1 || optionFactor < 2.0 || maxTreesOption.getValue() - numTrees <= 0) {
-=======
 			if (numSplits == 1 || optionFactor < 2.0 || maxTreesOption.getValue() - numTrees <= 1) {
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				AttributeSplitSuggestion splitDecision = acceptedSplits.get(0);
 				SplitNode newSplit = newSplitNode(splitDecision.splitTest);
 				for (int i = 0; i < splitDecision.numSplits(); i++) {
@@ -498,19 +412,12 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 				leafNodeCount--;
 				innerNodeCount++;
 				leafNodeCount += splitDecision.numSplits();
-<<<<<<< HEAD
 				if (parent == null && node.originalNode == null) {
 					treeRoot = newSplit;
 				} else if (parent == null && node.originalNode != null) {
 					node.originalNode.alternateTree = newSplit;
 				} else {
 					parent.setChild(parentIndex, newSplit);
-=======
-				if (parent == null) {
-					treeRoot = newSplit;
-				} else {
-					parent.setChild(parent.getChildIndex(node), newSplit);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 					newSplit.setParent(parent);
 				}
 			} else {
@@ -544,11 +451,7 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 				if (parent == null) {
 					treeRoot = optionNode;
 				} else {
-<<<<<<< HEAD
 					parent.setChild(parentIndex, optionNode);
-=======
-					parent.setChild(parent.getChildIndex(node), optionNode);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 					optionNode.setParent(parent);
 				}
 
@@ -631,8 +534,5 @@ protected void removeExcessTrees() {
 	// endregion --- Option tree methods
 	
 	//endregion ================ METHODS ================
-<<<<<<< HEAD
-}
-=======
 }
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+
diff --git a/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java b/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
index 4202599c6..61f2ee877 100644
--- a/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
+++ b/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
@@ -154,7 +154,6 @@ protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
 		int secondsElapsed = 0;
 		monitor.setCurrentActivity("Evaluating learner...", -1.0);
 
-<<<<<<< HEAD
 		File dumpFile = this.dumpFileOption.getFile();
 		PrintStream immediateResultStream = null;
 		if (dumpFile != null) {
@@ -208,63 +207,7 @@ protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
 					sb.append("Out " + i + ": " + ((Instance) trainInst.getData()).valueOutputAttribute(i) + " ");
 				}
 				outputPredictionResultStream.println(prediction + "," + sb.toString());
-			}
-=======
-        File dumpFile = this.dumpFileOption.getFile();
-        PrintStream immediateResultStream = null;
-        if (dumpFile != null) {
-            try {
-                if (dumpFile.exists()) {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile, true), true);
-                } else {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile), true);
-                }
-            } catch (Exception ex) {
-                throw new RuntimeException(
-                        "Unable to open immediate result file: " + dumpFile, ex);
-            }
-        }
-        //File for output predictions
-        File outputPredictionFile = this.outputPredictionFileOption.getFile();
-        PrintStream outputPredictionResultStream = null;
-        if (outputPredictionFile != null) {
-            try {
-                if (outputPredictionFile.exists()) {
-                    outputPredictionResultStream = new PrintStream(
-                            new FileOutputStream(outputPredictionFile, true), true);
-                } else {
-                    outputPredictionResultStream = new PrintStream(
-                            new FileOutputStream(outputPredictionFile), true);
-                }
-            } catch (Exception ex) {
-                throw new RuntimeException(
-                        "Unable to open prediction result file: " + outputPredictionFile, ex);
-            }
-        }
-        boolean firstDump = true;
-        boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
-        long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-        long lastEvaluateStartTime = evaluateStartTime;
-        double RAMHours = 0.0;
-        while (stream.hasMoreInstances()
-                && ((maxInstances < 0) || (instancesProcessed < maxInstances))
-                && ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
-            Example trainInst = stream.nextInstance();
-            Example testInst = (Example) trainInst; //.copy();
-            //testInst.setClassMissing();
-            //double[] prediction = learner.getVotesForInstance(testInst);
-            Prediction prediction = learner.getPredictionForInstance(testInst);
-            // Output prediction
-            if (outputPredictionFile != null) {
-            	StringBuilder sb = new StringBuilder();
-            	for (int i = 0; i < ((Instance) trainInst.getData()).numOutputAttributes(); i++) {
-            		sb.append("Out " + i + ": " + ((Instance) trainInst.getData()).valueOutputAttribute(i) + " ");
-            	}
-                outputPredictionResultStream.println(prediction + "," + sb.toString());
-            }
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+			}
 
 			//evaluator.addClassificationAttempt(trueClass, prediction, testInst.weight());
 			evaluator.addResult(testInst, prediction);

From 5dec8c12eaac8f4785df76b61e4d40a591a13321 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Mon, 9 Nov 2015 16:07:34 +0100
Subject: [PATCH 05/33] Additional merging artefacts fixed

---
 .../MultitargetAttributeClassObserver.java        | 15 +++++++++++++++
 .../NumericAttributeBinaryTest.java               |  4 ----
 2 files changed, 15 insertions(+), 4 deletions(-)
 create mode 100644 moa/src/main/java/moa/classifiers/core/attributeclassobservers/MultitargetAttributeClassObserver.java

diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/MultitargetAttributeClassObserver.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/MultitargetAttributeClassObserver.java
new file mode 100644
index 000000000..0cfc7acb6
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/MultitargetAttributeClassObserver.java
@@ -0,0 +1,15 @@
+package moa.classifiers.core.attributeclassobservers;
+
+import moa.classifiers.core.AttributeSplitSuggestion;
+import moa.classifiers.core.splitcriteria.SplitCriterion;
+import moa.core.DoubleVector;
+
+public interface MultitargetAttributeClassObserver extends AttributeClassObserver {
+
+	public void observeAttributeClassVector(double attVal, DoubleVector classVector, double weight);
+	
+    public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(
+            SplitCriterion criterion, double examlpesSeen, DoubleVector preSplitSums, DoubleVector preSplitSquares, int attIndex,
+            int numTargets, boolean binaryOnly);
+
+}
diff --git a/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java b/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
index d60ee3af2..87a3f2e0e 100644
--- a/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
+++ b/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
@@ -52,11 +52,7 @@ public int branchForInstance(Instance inst) {
         if (inst.isMissing(instAttIndex)) {
             return -1;
         }
-<<<<<<< HEAD
         double v = inst.valueInputAttribute(instAttIndex);
-=======
-        double v = inst.valueInputAttribute(instAttIndex); // if the attIndex is not calculated above this is the correct method call
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
         if (v == this.attValue) {
             return this.equalsPassesTest ? 0 : 1;
         }

From 02d26831ad12964b8c91204bb81c22a5fdd5550b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Mon, 9 Nov 2015 16:09:11 +0100
Subject: [PATCH 06/33] Test commit of everything

---
 .classpath                                    |  13 ++
 .project                                      |   6 +
 moa/.classpath                                |  17 +--
 moa/.settings/org.eclipse.jdt.core.prefs      |   3 +
 moa/pom.xml                                   | 138 ------------------
 .../classifiers/DecisionStumpTutorial.java    |  13 +-
 .../classifiers/multilabel/trees/.gitignore   |   1 +
 moa/src/main/java/moa/evaluation/.gitignore   |   2 +
 weka-package/pom.xml                          |  53 -------
 9 files changed, 41 insertions(+), 205 deletions(-)
 create mode 100644 .classpath
 delete mode 100755 moa/pom.xml
 create mode 100644 moa/src/main/java/moa/classifiers/multilabel/trees/.gitignore
 create mode 100644 moa/src/main/java/moa/evaluation/.gitignore
 delete mode 100644 weka-package/pom.xml

diff --git a/.classpath b/.classpath
new file mode 100644
index 000000000..dec9f005e
--- /dev/null
+++ b/.classpath
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="moa/src/examples/java"/>
+	<classpathentry kind="src" path="moa/src/main/java"/>
+	<classpathentry kind="src" path="moa/src/test/java"/>
+	<classpathentry kind="lib" path="weka-package/lib/sizeofag-1.0.0.jar"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/meka"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/weka-dev"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
+	<classpathentry kind="lib" path="/home/aljazo/Work/JARs/diffutils-1.2.1.jar"/>
+	<classpathentry kind="output" path="moa/target/classes"/>
+</classpath>
diff --git a/.project b/.project
index 76bea900b..56c2846a7 100644
--- a/.project
+++ b/.project
@@ -5,6 +5,11 @@
 	<projects>
 	</projects>
 	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
 		<buildCommand>
 			<name>org.eclipse.m2e.core.maven2Builder</name>
 			<arguments>
@@ -13,5 +18,6 @@
 	</buildSpec>
 	<natures>
 		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
 	</natures>
 </projectDescription>
diff --git a/moa/.classpath b/moa/.classpath
index 534b5e52f..f5accf223 100644
--- a/moa/.classpath
+++ b/moa/.classpath
@@ -11,26 +11,21 @@
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
-		<attributes>
-			<attribute name="optional" value="true"/>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
 	<classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources">
 		<attributes>
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6">
-		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
 	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
 		<attributes>
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
+	<classpathentry combineaccessrules="false" kind="src" path="/meka"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/weka-dev"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/weka-package"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="lib" path="/home/aljazo/Work/MT MOA/moa/weka-package/lib/sizeofag-1.0.0.jar"/>
 	<classpathentry kind="output" path="target/classes"/>
 </classpath>
diff --git a/moa/.settings/org.eclipse.jdt.core.prefs b/moa/.settings/org.eclipse.jdt.core.prefs
index 60105c1b9..69c31cd49 100644
--- a/moa/.settings/org.eclipse.jdt.core.prefs
+++ b/moa/.settings/org.eclipse.jdt.core.prefs
@@ -1,5 +1,8 @@
 eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
 org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
 org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
 org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
 org.eclipse.jdt.core.compiler.source=1.6
diff --git a/moa/pom.xml b/moa/pom.xml
deleted file mode 100755
index dd44c7979..000000000
--- a/moa/pom.xml
+++ /dev/null
@@ -1,138 +0,0 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-  <modelVersion>4.0.0</modelVersion>
-
-  <parent>
-    <groupId>nz.ac.waikato.cms.moa</groupId>
-    <artifactId>moa-pom</artifactId>
-    <version>2015.05-SNAPSHOT</version>
-  </parent>
-
-  <artifactId>moa</artifactId>
-  <packaging>jar</packaging>
-
-  <name>MOA: Massive Online Analysis</name>
-  <description>
-  Massive On-line Analysis is an environment for massive data mining. MOA
-  provides a framework for data stream mining and includes tools for evaluation
-  and a collection of machine learning algorithms. Related to the WEKA project,
-  also written in Java, while scaling to more demanding problems.
-  </description>
-  <url>http://moa.cms.waikato.ac.nz/</url>
-  <organization>
-    <name>University of Waikato, Hamilton, NZ</name>
-    <url>http://www.waikato.ac.nz/</url>
-  </organization>
-  <licenses>
-    <license>
-      <name>GNU General Public License 3.0</name>
-      <url>http://www.gnu.org/licenses/gpl-3.0.txt</url>
-      <distribution>repo</distribution>
-    </license>
-  </licenses>
-
-  <developers>
-    <developer>
-      <id>abifet</id>
-      <name>Albert Bifet</name>
-      <email>abifet@waikato.ac.nz</email>
-    </developer>
-    <developer>
-      <id>rkirkby</id>
-      <name>Richard Kirkby</name>
-    </developer>
-  </developers>
-
-  <dependencies>
-    <dependency>
-      <groupId>nz.ac.waikato.cms.weka</groupId>
-      <artifactId>weka-dev</artifactId>
-    </dependency>
-
-    <dependency>
-      <groupId>com.googlecode.sizeofag</groupId>
-      <artifactId>sizeofag</artifactId>
-    </dependency>
-
-    <dependency>
-      <groupId>junit</groupId>
-      <artifactId>junit</artifactId>
-      <scope>test</scope>
-    </dependency>
-    
-    <dependency>
-      <groupId>com.googlecode.java-diff-utils</groupId>
-      <artifactId>diffutils</artifactId>
-      <version>1.2.1</version>
-      <scope>test</scope>
-    </dependency>
-  </dependencies>
-
-  <build>
-    <plugins>
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-compiler-plugin</artifactId>
-        <configuration>
-          <source>1.6</source>
-          <target>1.6</target>
-        </configuration>
-      </plugin>
-
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-jar-plugin</artifactId>
-      </plugin>
-
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-javadoc-plugin</artifactId>
-      </plugin>
-      
-      <plugin>
-        <groupId>org.codehaus.mojo</groupId>
-        <artifactId>license-maven-plugin</artifactId>
-      </plugin>
-
-      <plugin>
-        <groupId>org.codehaus.mojo</groupId>
-        <artifactId>latex-maven-plugin</artifactId>
-      </plugin>
-
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-assembly-plugin</artifactId>
-      </plugin>
-    </plugins>
-    <pluginManagement>
-    	<plugins>
-    		<!--This plugin's configuration is used to store Eclipse m2e settings only. It has no influence on the Maven build itself.-->
-    		<plugin>
-    			<groupId>org.eclipse.m2e</groupId>
-    			<artifactId>lifecycle-mapping</artifactId>
-    			<version>1.0.0</version>
-    			<configuration>
-    				<lifecycleMappingMetadata>
-    					<pluginExecutions>
-    						<pluginExecution>
-    							<pluginExecutionFilter>
-    								<groupId>org.codehaus.mojo</groupId>
-    								<artifactId>
-    									license-maven-plugin
-    								</artifactId>
-    								<versionRange>[1.1,)</versionRange>
-    								<goals>
-    									<goal>add-third-party</goal>
-    								</goals>
-    							</pluginExecutionFilter>
-    							<action>
-    								<ignore></ignore>
-    							</action>
-    						</pluginExecution>
-    					</pluginExecutions>
-    				</lifecycleMappingMetadata>
-    			</configuration>
-    		</plugin>
-    	</plugins>
-    </pluginManagement>
-  </build>
-</project>
diff --git a/moa/src/examples/java/moa/classifiers/DecisionStumpTutorial.java b/moa/src/examples/java/moa/classifiers/DecisionStumpTutorial.java
index 8d18b0a9d..0cabab7dc 100644
--- a/moa/src/examples/java/moa/classifiers/DecisionStumpTutorial.java
+++ b/moa/src/examples/java/moa/classifiers/DecisionStumpTutorial.java
@@ -1,11 +1,18 @@
 package moa.classifiers;
 
+import moa.classifiers.core.AttributeSplitSuggestion;
+import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
+import moa.classifiers.core.attributeclassobservers.GaussianNumericAttributeClassObserver;
+import moa.classifiers.core.attributeclassobservers.NominalAttributeClassObserver;
+import moa.classifiers.core.splitcriteria.SplitCriterion;
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
 import moa.options.ClassOption;
-import moa.options.FlagOption;
-import moa.options.IntOption;
-import weka.core.Instance;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
+
+import com.yahoo.labs.samoa.instances.Instance;
 
 public class DecisionStumpTutorial extends AbstractClassifier {
 
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/.gitignore b/moa/src/main/java/moa/classifiers/multilabel/trees/.gitignore
new file mode 100644
index 000000000..8e36d7391
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/multilabel/trees/.gitignore
@@ -0,0 +1 @@
+/BaselinePerceptron.java
diff --git a/moa/src/main/java/moa/evaluation/.gitignore b/moa/src/main/java/moa/evaluation/.gitignore
new file mode 100644
index 000000000..48df8b2bf
--- /dev/null
+++ b/moa/src/main/java/moa/evaluation/.gitignore
@@ -0,0 +1,2 @@
+/MultilabelWindowClassificationPerformanceEvaluatorWithMEKAMetrics.java
+/MultiTargetWindowRegressionPerformanceEvaluator2.java
diff --git a/weka-package/pom.xml b/weka-package/pom.xml
deleted file mode 100644
index 6cd73530c..000000000
--- a/weka-package/pom.xml
+++ /dev/null
@@ -1,53 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-
-  <modelVersion>4.0.0</modelVersion>
-
-  <parent>
-    <groupId>nz.ac.waikato.cms.moa</groupId>
-    <artifactId>moa-pom</artifactId>
-    <version>2012.09-SNAPSHOT</version>
-  </parent>
-
-  <artifactId>weka-package</artifactId>
-  <packaging>jar</packaging>
-
-  <name>MOA: WEKA Package</name>
-  <description>
-  Massive On-line Analysis is an environment for massive data mining. MOA provides a framework for data stream mining and includes tools for evaluation and a collection of machine learning algorithms. Related to the WEKA project, also written in Java, while scaling to more demanding problems.
-  This artifact enables you to use MOA from within WEKA.
-  </description>
-  <url>http://moa.cms.waikato.ac.nz/</url>
-  <organization>
-    <name>University of Waikato, Hamilton, NZ</name>
-    <url>http://www.waikato.ac.nz/</url>
-  </organization>
-  <licenses>
-    <license>
-      <name>GNU General Public License 3</name>
-      <url>http://www.gnu.org/licenses/gpl-3.0.txt</url>
-      <distribution>repo</distribution>
-    </license>
-  </licenses>
-
-  <developers>
-    <developer>
-      <id>abifet</id>
-      <name>Albert Bifet</name>
-      <email>abifet@waikato.ac.nz</email>
-    </developer>
-    <developer>
-      <id>fracpete</id>
-      <name>Peter Reutemann</name>
-      <email>fracpete@waikato.ac.nz</email>
-    </developer>
-  </developers>
-
-  <dependencies>
-    <dependency>
-      <groupId>nz.ac.waikato.cms.moa</groupId>
-      <artifactId>moa</artifactId>
-      <version>[${project.version},)</version>
-    </dependency>
-  </dependencies>
-</project>

From 8e867c37acda33492d7f9853d0d9c0cebadad723 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Mon, 9 Nov 2015 16:37:42 +0100
Subject: [PATCH 07/33] Revert "Test commit of everything"

This reverts commit 02d26831ad12964b8c91204bb81c22a5fdd5550b.
---
 .classpath                                    |  13 --
 .project                                      |   6 -
 moa/.classpath                                |  17 ++-
 moa/.settings/org.eclipse.jdt.core.prefs      |   3 -
 moa/pom.xml                                   | 138 ++++++++++++++++++
 .../classifiers/DecisionStumpTutorial.java    |  13 +-
 .../classifiers/multilabel/trees/.gitignore   |   1 -
 moa/src/main/java/moa/evaluation/.gitignore   |   2 -
 weka-package/pom.xml                          |  53 +++++++
 9 files changed, 205 insertions(+), 41 deletions(-)
 delete mode 100644 .classpath
 create mode 100755 moa/pom.xml
 delete mode 100644 moa/src/main/java/moa/classifiers/multilabel/trees/.gitignore
 delete mode 100644 moa/src/main/java/moa/evaluation/.gitignore
 create mode 100644 weka-package/pom.xml

diff --git a/.classpath b/.classpath
deleted file mode 100644
index dec9f005e..000000000
--- a/.classpath
+++ /dev/null
@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="moa/src/examples/java"/>
-	<classpathentry kind="src" path="moa/src/main/java"/>
-	<classpathentry kind="src" path="moa/src/test/java"/>
-	<classpathentry kind="lib" path="weka-package/lib/sizeofag-1.0.0.jar"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
-	<classpathentry combineaccessrules="false" kind="src" path="/meka"/>
-	<classpathentry combineaccessrules="false" kind="src" path="/weka-dev"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
-	<classpathentry kind="lib" path="/home/aljazo/Work/JARs/diffutils-1.2.1.jar"/>
-	<classpathentry kind="output" path="moa/target/classes"/>
-</classpath>
diff --git a/.project b/.project
index 56c2846a7..76bea900b 100644
--- a/.project
+++ b/.project
@@ -5,11 +5,6 @@
 	<projects>
 	</projects>
 	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
 		<buildCommand>
 			<name>org.eclipse.m2e.core.maven2Builder</name>
 			<arguments>
@@ -18,6 +13,5 @@
 	</buildSpec>
 	<natures>
 		<nature>org.eclipse.m2e.core.maven2Nature</nature>
-		<nature>org.eclipse.jdt.core.javanature</nature>
 	</natures>
 </projectDescription>
diff --git a/moa/.classpath b/moa/.classpath
index f5accf223..534b5e52f 100644
--- a/moa/.classpath
+++ b/moa/.classpath
@@ -11,21 +11,26 @@
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
+	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
 	<classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources">
 		<attributes>
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
 	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
 		<attributes>
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry combineaccessrules="false" kind="src" path="/meka"/>
-	<classpathentry combineaccessrules="false" kind="src" path="/weka-dev"/>
-	<classpathentry combineaccessrules="false" kind="src" path="/weka-package"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
-	<classpathentry kind="lib" path="/home/aljazo/Work/MT MOA/moa/weka-package/lib/sizeofag-1.0.0.jar"/>
 	<classpathentry kind="output" path="target/classes"/>
 </classpath>
diff --git a/moa/.settings/org.eclipse.jdt.core.prefs b/moa/.settings/org.eclipse.jdt.core.prefs
index 69c31cd49..60105c1b9 100644
--- a/moa/.settings/org.eclipse.jdt.core.prefs
+++ b/moa/.settings/org.eclipse.jdt.core.prefs
@@ -1,8 +1,5 @@
 eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
 org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
 org.eclipse.jdt.core.compiler.compliance=1.6
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
 org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
 org.eclipse.jdt.core.compiler.source=1.6
diff --git a/moa/pom.xml b/moa/pom.xml
new file mode 100755
index 000000000..dd44c7979
--- /dev/null
+++ b/moa/pom.xml
@@ -0,0 +1,138 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <parent>
+    <groupId>nz.ac.waikato.cms.moa</groupId>
+    <artifactId>moa-pom</artifactId>
+    <version>2015.05-SNAPSHOT</version>
+  </parent>
+
+  <artifactId>moa</artifactId>
+  <packaging>jar</packaging>
+
+  <name>MOA: Massive Online Analysis</name>
+  <description>
+  Massive On-line Analysis is an environment for massive data mining. MOA
+  provides a framework for data stream mining and includes tools for evaluation
+  and a collection of machine learning algorithms. Related to the WEKA project,
+  also written in Java, while scaling to more demanding problems.
+  </description>
+  <url>http://moa.cms.waikato.ac.nz/</url>
+  <organization>
+    <name>University of Waikato, Hamilton, NZ</name>
+    <url>http://www.waikato.ac.nz/</url>
+  </organization>
+  <licenses>
+    <license>
+      <name>GNU General Public License 3.0</name>
+      <url>http://www.gnu.org/licenses/gpl-3.0.txt</url>
+      <distribution>repo</distribution>
+    </license>
+  </licenses>
+
+  <developers>
+    <developer>
+      <id>abifet</id>
+      <name>Albert Bifet</name>
+      <email>abifet@waikato.ac.nz</email>
+    </developer>
+    <developer>
+      <id>rkirkby</id>
+      <name>Richard Kirkby</name>
+    </developer>
+  </developers>
+
+  <dependencies>
+    <dependency>
+      <groupId>nz.ac.waikato.cms.weka</groupId>
+      <artifactId>weka-dev</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>com.googlecode.sizeofag</groupId>
+      <artifactId>sizeofag</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <scope>test</scope>
+    </dependency>
+    
+    <dependency>
+      <groupId>com.googlecode.java-diff-utils</groupId>
+      <artifactId>diffutils</artifactId>
+      <version>1.2.1</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <configuration>
+          <source>1.6</source>
+          <target>1.6</target>
+        </configuration>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-jar-plugin</artifactId>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-javadoc-plugin</artifactId>
+      </plugin>
+      
+      <plugin>
+        <groupId>org.codehaus.mojo</groupId>
+        <artifactId>license-maven-plugin</artifactId>
+      </plugin>
+
+      <plugin>
+        <groupId>org.codehaus.mojo</groupId>
+        <artifactId>latex-maven-plugin</artifactId>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-assembly-plugin</artifactId>
+      </plugin>
+    </plugins>
+    <pluginManagement>
+    	<plugins>
+    		<!--This plugin's configuration is used to store Eclipse m2e settings only. It has no influence on the Maven build itself.-->
+    		<plugin>
+    			<groupId>org.eclipse.m2e</groupId>
+    			<artifactId>lifecycle-mapping</artifactId>
+    			<version>1.0.0</version>
+    			<configuration>
+    				<lifecycleMappingMetadata>
+    					<pluginExecutions>
+    						<pluginExecution>
+    							<pluginExecutionFilter>
+    								<groupId>org.codehaus.mojo</groupId>
+    								<artifactId>
+    									license-maven-plugin
+    								</artifactId>
+    								<versionRange>[1.1,)</versionRange>
+    								<goals>
+    									<goal>add-third-party</goal>
+    								</goals>
+    							</pluginExecutionFilter>
+    							<action>
+    								<ignore></ignore>
+    							</action>
+    						</pluginExecution>
+    					</pluginExecutions>
+    				</lifecycleMappingMetadata>
+    			</configuration>
+    		</plugin>
+    	</plugins>
+    </pluginManagement>
+  </build>
+</project>
diff --git a/moa/src/examples/java/moa/classifiers/DecisionStumpTutorial.java b/moa/src/examples/java/moa/classifiers/DecisionStumpTutorial.java
index 0cabab7dc..8d18b0a9d 100644
--- a/moa/src/examples/java/moa/classifiers/DecisionStumpTutorial.java
+++ b/moa/src/examples/java/moa/classifiers/DecisionStumpTutorial.java
@@ -1,18 +1,11 @@
 package moa.classifiers;
 
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.GaussianNumericAttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.NominalAttributeClassObserver;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
 import moa.options.ClassOption;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
-
-import com.yahoo.labs.samoa.instances.Instance;
+import moa.options.FlagOption;
+import moa.options.IntOption;
+import weka.core.Instance;
 
 public class DecisionStumpTutorial extends AbstractClassifier {
 
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/.gitignore b/moa/src/main/java/moa/classifiers/multilabel/trees/.gitignore
deleted file mode 100644
index 8e36d7391..000000000
--- a/moa/src/main/java/moa/classifiers/multilabel/trees/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-/BaselinePerceptron.java
diff --git a/moa/src/main/java/moa/evaluation/.gitignore b/moa/src/main/java/moa/evaluation/.gitignore
deleted file mode 100644
index 48df8b2bf..000000000
--- a/moa/src/main/java/moa/evaluation/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-/MultilabelWindowClassificationPerformanceEvaluatorWithMEKAMetrics.java
-/MultiTargetWindowRegressionPerformanceEvaluator2.java
diff --git a/weka-package/pom.xml b/weka-package/pom.xml
new file mode 100644
index 000000000..6cd73530c
--- /dev/null
+++ b/weka-package/pom.xml
@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+
+  <modelVersion>4.0.0</modelVersion>
+
+  <parent>
+    <groupId>nz.ac.waikato.cms.moa</groupId>
+    <artifactId>moa-pom</artifactId>
+    <version>2012.09-SNAPSHOT</version>
+  </parent>
+
+  <artifactId>weka-package</artifactId>
+  <packaging>jar</packaging>
+
+  <name>MOA: WEKA Package</name>
+  <description>
+  Massive On-line Analysis is an environment for massive data mining. MOA provides a framework for data stream mining and includes tools for evaluation and a collection of machine learning algorithms. Related to the WEKA project, also written in Java, while scaling to more demanding problems.
+  This artifact enables you to use MOA from within WEKA.
+  </description>
+  <url>http://moa.cms.waikato.ac.nz/</url>
+  <organization>
+    <name>University of Waikato, Hamilton, NZ</name>
+    <url>http://www.waikato.ac.nz/</url>
+  </organization>
+  <licenses>
+    <license>
+      <name>GNU General Public License 3</name>
+      <url>http://www.gnu.org/licenses/gpl-3.0.txt</url>
+      <distribution>repo</distribution>
+    </license>
+  </licenses>
+
+  <developers>
+    <developer>
+      <id>abifet</id>
+      <name>Albert Bifet</name>
+      <email>abifet@waikato.ac.nz</email>
+    </developer>
+    <developer>
+      <id>fracpete</id>
+      <name>Peter Reutemann</name>
+      <email>fracpete@waikato.ac.nz</email>
+    </developer>
+  </developers>
+
+  <dependencies>
+    <dependency>
+      <groupId>nz.ac.waikato.cms.moa</groupId>
+      <artifactId>moa</artifactId>
+      <version>[${project.version},)</version>
+    </dependency>
+  </dependencies>
+</project>

From 4436a24bb8f615d42331b901d0800047d9f3d389 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Mon, 9 Nov 2015 16:37:46 +0100
Subject: [PATCH 08/33] Revert "Additional merging artefacts fixed"

This reverts commit 5dec8c12eaac8f4785df76b61e4d40a591a13321.
---
 .../MultitargetAttributeClassObserver.java        | 15 ---------------
 .../NumericAttributeBinaryTest.java               |  4 ++++
 2 files changed, 4 insertions(+), 15 deletions(-)
 delete mode 100644 moa/src/main/java/moa/classifiers/core/attributeclassobservers/MultitargetAttributeClassObserver.java

diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/MultitargetAttributeClassObserver.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/MultitargetAttributeClassObserver.java
deleted file mode 100644
index 0cfc7acb6..000000000
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/MultitargetAttributeClassObserver.java
+++ /dev/null
@@ -1,15 +0,0 @@
-package moa.classifiers.core.attributeclassobservers;
-
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.core.DoubleVector;
-
-public interface MultitargetAttributeClassObserver extends AttributeClassObserver {
-
-	public void observeAttributeClassVector(double attVal, DoubleVector classVector, double weight);
-	
-    public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(
-            SplitCriterion criterion, double examlpesSeen, DoubleVector preSplitSums, DoubleVector preSplitSquares, int attIndex,
-            int numTargets, boolean binaryOnly);
-
-}
diff --git a/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java b/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
index 87a3f2e0e..d60ee3af2 100644
--- a/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
+++ b/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
@@ -52,7 +52,11 @@ public int branchForInstance(Instance inst) {
         if (inst.isMissing(instAttIndex)) {
             return -1;
         }
+<<<<<<< HEAD
         double v = inst.valueInputAttribute(instAttIndex);
+=======
+        double v = inst.valueInputAttribute(instAttIndex); // if the attIndex is not calculated above this is the correct method call
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
         if (v == this.attValue) {
             return this.equalsPassesTest ? 0 : 1;
         }

From 296844e6d6970be9525b3fb6603b58ce33c8746a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Mon, 9 Nov 2015 16:38:13 +0100
Subject: [PATCH 09/33] Revert "Removed merging artefacts"

This reverts commit 4e3116ae22afc259caa4f4e7d967ae369aae367c.
---
 .../samoa/instances/MultiLabelPrediction.java |   5 +-
 .../LocalMultiTargetClassifier.java           |  31 +-
 .../classifiers/multilabel/meta/MTOzaBag.java |  94 +-
 .../multilabel/trees/ISOUPTree.java           | 144 ++-
 .../java/moa/classifiers/trees/FIMTDD.java    | 986 +++++++++++++++++-
 .../main/java/moa/classifiers/trees/ORTO.java | 114 +-
 .../tasks/EvaluatePrequentialMultiTarget.java |  59 +-
 7 files changed, 1370 insertions(+), 63 deletions(-)

diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
index bb9824e9d..838f90c7b 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
@@ -32,7 +32,10 @@ public MultiLabelPrediction(int numOutputAttributes) {
 	public MultiLabelPrediction(DoubleVector[] prediction) {
 		this.prediction = prediction;
 	}
-
+	
+	public MultiLabelPrediction(DoubleVector[] prediction) {
+		this.prediction = prediction;
+	}
 	
 	@Override
 	public int numOutputAttributes() {
diff --git a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
index 35223d3db..38c82f7e9 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
@@ -1,8 +1,12 @@
 package moa.classifiers.multilabel;
 
+<<<<<<< HEAD
 import java.util.ArrayList;
+=======
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Vector;
 
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
@@ -17,14 +21,16 @@
 import moa.classifiers.Classifier;
 import moa.classifiers.MultiLabelClassifier;
 import moa.classifiers.MultiTargetRegressor;
+import moa.classifiers.core.splitcriteria.SplitCriterion;
+import moa.classifiers.trees.FIMTDD;
+import moa.core.DoubleVector;
 import moa.core.Measurement;
+import moa.learners.Learner;
 import moa.options.ClassOption;
 
 public class LocalMultiTargetClassifier extends AbstractMultiLabelLearner
 		implements MultiLabelClassifier, MultiTargetRegressor {
 
-	private static final long serialVersionUID = 1L;
-
 	public ClassOption classifierOption = new ClassOption(
 			"classifier",
 			'c',
@@ -32,11 +38,17 @@ public class LocalMultiTargetClassifier extends AbstractMultiLabelLearner
 			Classifier.class,
 			"moa.classifiers.trees.FIMTDD");
 	
+<<<<<<< HEAD
 	ArrayList<Classifier> classifiers = null;
 	ArrayList<InstancesHeader> headers = null;
+=======
+	LinkedList<Classifier> classifiers = null;
+	LinkedList<InstancesHeader> headers = null;
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 	
 	@Override
 	public boolean isRandomizable() {
+		// TODO Auto-generated method stub
 		return true;
 	}
 
@@ -49,7 +61,11 @@ private InstancesHeader getHeader(int target) {
 	
 	private void makeHeaders() {
 		if (headers == null) {
+<<<<<<< HEAD
 			headers = new ArrayList<InstancesHeader>();
+=======
+			headers = new LinkedList<InstancesHeader>();
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 			for (int target = 0; target < getModelContext().numOutputAttributes(); target++) {
 				List<Attribute> attributes = new LinkedList<Attribute>();
 				List<Integer> indexValues = new LinkedList<Integer>();
@@ -79,6 +95,7 @@ private Instance getSTInstance(MultiLabelInstance inst, int target) {
 	
 	@Override
 	public void trainOnInstanceImpl(MultiLabelInstance instance) {
+		// TODO Auto-generated method stub
 		initializeClassifiers();
 		
 		for (int j = 0; j < instance.numberOutputTargets(); j++) {
@@ -95,6 +112,10 @@ public Prediction getPredictionForInstance(MultiLabelInstance inst) {
 		MultiLabelPrediction prediction = new MultiLabelPrediction(getModelContext().numOutputAttributes());
 		for (int j = 0; j < inst.numberOutputTargets(); j++) {
 			Instance STInst = getSTInstance(inst, j);
+<<<<<<< HEAD
+=======
+			
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 			prediction.setVote(j, 1, classifiers.get(j).getVotesForInstance(STInst)[0]);
 		}
 		return prediction;
@@ -110,9 +131,15 @@ public void initializeClassifiers() {
 		this.classifierRandom.setSeed(1234);
 		if (classifiers == null) {
 			makeHeaders();
+<<<<<<< HEAD
 			classifiers = new ArrayList<Classifier>();
 			for (int i = 0; i < getModelContext().numOutputAttributes(); i++) {
 				Classifier learner = ((Classifier) getPreparedClassOption(this.classifierOption)).copy();
+=======
+			classifiers = new LinkedList<Classifier>();
+			for (int i = 0; i < getModelContext().numOutputAttributes(); i++) {
+				Classifier learner = (Classifier) getPreparedClassOption(this.classifierOption);
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				classifiers.add(learner);
 				learner.resetLearning();
 				((AbstractClassifier) learner).classifierRandom = this.classifierRandom;
diff --git a/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java b/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
index bdf2c7ffd..a4c64a809 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
@@ -41,43 +41,41 @@
  */
 public class MTOzaBag extends OzaBag implements MultiLabelLearner, MultiTargetRegressor {
 
-	private static final long serialVersionUID = 1L;
-
-	public MTOzaBag() {
-		super();
-		this.baseLearnerOption = new ClassOption("baseLearner", 'l',
-				"Classifier to train.", MultiLabelLearner.class, "multilabel.trees.ISOUPTree");
-	}
-
-	@Override
-	public void resetLearningImpl() {
-		this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
-		MultiLabelLearner baseLearner = (MultiLabelLearner) getPreparedClassOption(this.baseLearnerOption);
-		baseLearner.resetLearning();
-		for (int i = 0; i < this.ensemble.length; i++) {
-			this.ensemble[i] = baseLearner.copy();
-		}
-	}
-
-	@Override
-	public void setModelContext(InstancesHeader raw_header) {
-
-		//set the multilabel model context
-		this.modelContext = raw_header;
-
-		// reset ensemble
-		this.resetLearningImpl();
-
-		for (int i = 0; i < this.ensemble.length; i++) {
-			this.ensemble[i].setModelContext(raw_header);
-			this.ensemble[i].resetLearning();
-		}
-	}
-
-	@Override // @note don't need this here
-	public boolean isRandomizable() {
-		return true;
-	}
+    public MTOzaBag() {
+    	super();
+    	this.baseLearnerOption = new ClassOption("baseLearner", 'l',
+                "Classifier to train.", MultiLabelLearner.class, "multilabel.trees.ISOUPTree");
+    	}
+	
+    @Override
+    public void resetLearningImpl() {
+        this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
+        MultiLabelLearner baseLearner = (MultiLabelLearner) getPreparedClassOption(this.baseLearnerOption);
+        baseLearner.resetLearning();
+        for (int i = 0; i < this.ensemble.length; i++) {
+            this.ensemble[i] = baseLearner.copy();
+        }
+    }
+
+    @Override
+    public void setModelContext(InstancesHeader raw_header) {
+
+        //set the multilabel model context
+        this.modelContext = raw_header;
+
+        // reset ensemble
+        this.resetLearningImpl();
+
+        for (int i = 0; i < this.ensemble.length; i++) {
+            this.ensemble[i].setModelContext(raw_header);
+            this.ensemble[i].resetLearning();
+        }
+    }
+
+    @Override // @note don't need this here
+    public boolean isRandomizable() {
+        return true;
+    }
 
 	public Prediction getPredictionForInstance(MultiLabelInstance inst) {
 		DoubleVector[][] predictions = new DoubleVector[this.ensemble.length][getModelContext().numOutputAttributes()];
@@ -95,8 +93,8 @@ public Prediction getPredictionForInstance(MultiLabelInstance inst) {
 		}
 		return new MultiLabelPrediction(prediction);
 	}
-
-
+<<<<<<< HEAD
+	
 	public Prediction getPredictionForInstanceUsingN(MultiLabelInstance inst, int n) {
 		int actual = Math.max(1, Math.min(n, this.ensemble.length));
 		DoubleVector[][] predictions = new DoubleVector[actual][getModelContext().numOutputAttributes()];
@@ -114,15 +112,17 @@ public Prediction getPredictionForInstanceUsingN(MultiLabelInstance inst, int n)
 		}
 		return new MultiLabelPrediction(prediction);
 	}
-
-	@Override
-	public void trainOnInstanceImpl(MultiLabelInstance instance) {
-		trainOnInstanceImpl((Instance) instance);
-	}
-
-	@Override
+=======
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+
+    @Override
+    public void trainOnInstanceImpl(MultiLabelInstance instance) {
+        trainOnInstanceImpl((Instance) instance);
+    }
+    
+    @Override
 	public Prediction getPredictionForInstance(Example<Instance> example) {
 		return getPredictionForInstance((MultiLabelInstance)example.getData());
 	}
-
+    
 }
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
index 1873b87cf..592a0c5c6 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
@@ -66,7 +66,14 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 
 	private static final long serialVersionUID = 1L;
 
+<<<<<<< HEAD
 	public Node treeRoot;
+=======
+	protected Node treeRoot;
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+
+	private int leafNodeCount = 0;
+	private int splitNodeCount = 0;
 
 	private double examplesSeen = 0.0;
 	private DoubleVector sumOfValues = new DoubleVector();
@@ -79,6 +86,7 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 
 	//region ================ OPTIONS ================
 
+<<<<<<< HEAD
 	//	public ClassOption splitCriterionOption = new ClassOption(
 	//			"splitCriterion",
 	//			's',
@@ -87,6 +95,8 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 	//			"moa.classifiers.core.splitcriteria.VarianceReductionSplitCriterion");
 	// TODO not used at the moment, consider later when the implementation catches up	
 
+=======
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 	public IntOption gracePeriodOption = new IntOption(
 			"gracePeriod",
 			'g',
@@ -105,6 +115,7 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 			"Threshold below which a split will be forced to break ties.",
 			0.05, 0.0, 1.0);
 
+<<<<<<< HEAD
 	public FloatOption PageHinckleyAlphaOption = new FloatOption(
 			"PageHinckleyAlpha",
 			'a',
@@ -116,6 +127,19 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 			'h',
 			"The threshold value to be used in the Page Hinckley change detection tests.",
 			50, 0, Integer.MAX_VALUE);
+=======
+//	public FloatOption PageHinckleyAlphaOption = new FloatOption(
+//			"PageHinckleyAlpha",
+//			'a',
+//			"The alpha value to use in the Page Hinckley change detection tests.",
+//			0.005, 0.0, 1.0);
+//
+//	public IntOption PageHinckleyThresholdOption = new IntOption(
+//			"PageHinckleyThreshold",
+//			'h',
+//			"The threshold value to be used in the Page Hinckley change detection tests.",
+//			50, 0, Integer.MAX_VALUE);
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 
 	public FloatOption alternateTreeFadingFactorOption = new FloatOption(
 			"alternateTreeFadingFactor",
@@ -161,6 +185,15 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 			"doNotNormalize",
 			'n',
 			"Don't normalize.");
+<<<<<<< HEAD
+	
+	public FlagOption printLogsOption = new FlagOption(
+			"printLogs",
+			'z',
+			"Print logs.");
+=======
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+
 
 	//endregion ================ OPTIONS ================
 
@@ -309,11 +342,17 @@ public LeafNode(ISOUPTree tree) {
 		 */
 		public void learnFromInstance(MultiLabelInstance inst, double[] prediction, boolean growthAllowed) {
 			// Update the statistics for this node
-			
+<<<<<<< HEAD
+			// number of instances passing through the node
+			double[] predictionP = tree.buildingModelTree() ? getPredictionModel(inst) : null;
+			double[] predictionM = getPredictionTargetMean(inst);
+
+=======
 			double[] predictionP = tree.buildingModelTree() ? getPredictionModel(inst) : null;
 			double[] predictionM = getPredictionTargetMean(inst);
 
 			// number of instances passing through the node
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 			examplesSeen += inst.weight();
 
 			for (int i = 0; i < tree.getModelContext().numOutputAttributes(); i++) {
@@ -328,7 +367,10 @@ public void learnFromInstance(MultiLabelInstance inst, double[] prediction, bool
 					errorM.setValue(i, errorM.getValue(i) * 0.95 + Math.abs(predictionM[i] - inst.valueOutputAttribute(i)));
 				}
 			}
-
+<<<<<<< HEAD
+			
+=======
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 			if (tree.buildingModelTree()) learningModel.updatePerceptron(inst);
 
 			for (int i = 0; i < inst.numInputAttributes(); i++) {
@@ -401,11 +443,17 @@ public double[] getPredictionModel(MultiLabelInstance inst) {
 
 		public double[] getPredictionTargetMean(MultiLabelInstance inst) {
 			double[] pred = new double[inst.numOutputAttributes()];
+<<<<<<< HEAD
 			for (int i = 0; i < inst.numOutputAttributes(); i++) {
 				if (examplesSeen > 0) {
 					pred[i] = sumOfValues.getValue(i) / examplesSeen;
 				} else {
 					pred[i] = 0;
+=======
+			if (examplesSeen > 0) {
+				for (int i = 0; i < inst.numOutputAttributes(); i++) {
+					pred[i] = sumOfValues.getValue(i) / examplesSeen;
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				}
 			}
 			return pred;
@@ -606,8 +654,11 @@ public class MultitargetPerceptron {
 		protected ISOUPTree tree;
 
 		// The Perception weights 
+<<<<<<< HEAD
 		public double[][] weights; 
-
+=======
+		protected double[][] weights; 
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 
 		// The number of instances contributing to this model
 		protected int instancesSeen = 0;
@@ -619,6 +670,13 @@ public String getPurposeString() {
 		public MultitargetPerceptron(ISOUPTree tree, MultitargetPerceptron original) {
 			this.tree = tree;
 			weights = original.weights.clone();
+<<<<<<< HEAD
+			// TODO check if this is necessary
+//			for (int i = 0; i < this.tree.getModelContext().numOutputAttributes(); i++) {
+//				weights[i] = (DoubleVector) original.weights[i].copy();
+//			}
+=======
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		}
 
 		public MultitargetPerceptron(ISOUPTree tree) {
@@ -638,7 +696,10 @@ public void initializeWeights() {
 					weights[i][j] = 2 * tree.classifierRandom.nextDouble() - 1;
 				}
 			}
+<<<<<<< HEAD
 			normalizeWeights();
+=======
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		}
 
 		/**
@@ -689,6 +750,10 @@ public void normalizeWeights() {
 			}
 		}
 
+<<<<<<< HEAD
+		
+=======
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		/**
 		 * Output the prediction made by this perceptron on the given instance
 		 */
@@ -727,6 +792,7 @@ private double[] denormalizePrediction(double[] normalizedPrediction) {
 		public void getModelDescription(StringBuilder out, int indent) {
 			for (int i = 0; i < tree.getModelContext().numOutputAttributes(); i++) {
 				StringUtils.appendIndented(out, indent, " [" + tree.getModelContext().outputAttribute(i).name() + "]");
+<<<<<<< HEAD
 				//if (getModelContext() != null) {
 				//for (int j = 0; j < getModelContext().numAttributes() - 1; j++) {
 				//					if (getModelContext().attribute(j).isNumeric()) {
@@ -1074,6 +1140,24 @@ public void getModelDescription(StringBuilder out, int indent) {
 	//
 	//	}
 
+=======
+				if (getModelContext() != null) {
+				for (int j = 0; j < getModelContext().numOutputAttributes(); j++) {
+									if (getModelContext().attribute(j).isNumeric()) {
+										out.append((j == 0 || weights[i][j] < 0) ? " " : " + ");
+										out.append(String.format("%.4f", weights[i][j]));
+										out.append(" * ");
+										out.append(getAttributeNameString(j));
+									}
+				}
+				out.append(" + " + weights[i][getModelContext().numOutputAttributes()]);
+				}
+				StringUtils.appendNewline(out);
+			}
+		}
+	}
+
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 	//endregion ================ CLASSES ================
 
 	//region ================ METHODS ================
@@ -1082,17 +1166,27 @@ public void getModelDescription(StringBuilder out, int indent) {
 	public ISOUPTree() {}
 
 	public String getPurposeString() {
+<<<<<<< HEAD
+		return "Implementation of the FIMT-DD tree as described by Ikonomovska et al.";
+=======
 		return "Implementation of the iSOUP-Tree algorithm as described by Osojnik et al.";
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 	}
 
 	public void resetLearningImpl() {
 		treeRoot = null;
+		leafNodeCount = 0;
+		splitNodeCount = 0;
+<<<<<<< HEAD
 		examplesSeen = 0.0;
 		sumOfValues = new DoubleVector();
 		sumOfSquares = new DoubleVector();
 
 		sumOfAttrValues = new DoubleVector();
 		sumOfAttrSquares = new DoubleVector();
+=======
+		maxID = 0;
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 	}
 
 	public boolean isRandomizable() {
@@ -1186,7 +1280,11 @@ public double[] normalizeTargetVector(double[] pred) {
 				double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen);
 				double average = sumOfValues.getValue(i) / examplesSeen;
 				if (sd > 0 && examplesSeen > 1)
+<<<<<<< HEAD
 					out[i] = (value - average) / sd;
+=======
+					out[i] = (value - average) / (3 * sd);
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				else
 					out[i] = 0;
 			}
@@ -1202,7 +1300,11 @@ public double normalizeTargetValue(MultiLabelInstance inst, int i) {
 				double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen);
 				double average = sumOfValues.getValue(i) / examplesSeen;
 				if (sd > 0)
+<<<<<<< HEAD
 					return (value - average) / sd;
+=======
+					return (value - average) / (3 * sd);
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				else
 					return 0;
 			}
@@ -1216,7 +1318,11 @@ public double normalizeTargetValue(double value, int i) {
 				double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen);
 				double average = sumOfValues.getValue(i) / examplesSeen;
 				if (sd > 0)
+<<<<<<< HEAD
 					return (value - average) / sd;
+=======
+					return (value - average) / (3 * sd);
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				else
 					return 0;
 			}
@@ -1244,9 +1350,15 @@ public void trainOnInstanceImpl(MultiLabelInstance inst) {
 
 			double[] prediction = treeRoot.getPrediction(inst);
 			double[] normalError = getNormalizedError(inst, prediction);
+<<<<<<< HEAD
 			
 			processInstance(inst, treeRoot, prediction, normalError, true, false);
 			
+=======
+			//normalError.scaleValues(inst.weight());
+			processInstance(inst, treeRoot, prediction, normalError, true, false);
+
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 			examplesSeen += inst.weight();
 			for (int i = 0; i < inst.numberOutputTargets(); i++) {
 				sumOfValues.addToValue(i, inst.weight() * inst.valueOutputAttribute(i));
@@ -1257,6 +1369,12 @@ public void trainOnInstanceImpl(MultiLabelInstance inst) {
 				sumOfAttrValues.addToValue(i, inst.weight() * inst.valueInputAttribute(i));
 				sumOfAttrSquares.addToValue(i, inst.weight() * inst.valueInputAttribute(i) * inst.valueInputAttribute(i));
 			}
+<<<<<<< HEAD
+			
+			//normalError.scaleValues(inst.weight());
+
+=======
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		}
 	}
 
@@ -1357,7 +1475,11 @@ protected LeafNode newLeafNode() {
 		return new LeafNode(this);
 	}
 
+<<<<<<< HEAD
 	public MultitargetPerceptron newLeafModel() {
+=======
+	protected MultitargetPerceptron newLeafModel() {
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		return new MultitargetPerceptron(this);
 	}
 
@@ -1367,6 +1489,7 @@ public MultitargetPerceptron newLeafModel() {
 	protected void checkRoot() {
 		if (treeRoot == null) {
 			treeRoot = newLeafNode();
+			leafNodeCount = 1;
 		}
 	}
 
@@ -1433,17 +1556,29 @@ protected void attemptToSplit(LeafNode node, SplitNode parent, int parentIndex)
 					}
 				}
 			}
+<<<<<<< HEAD
+			
+			if (hoeffdingBound < this.tieThresholdOption.getValue() && this.printLogsOption.isSet()) System.out.println("Forced to split due to tie at " + this.examplesSeen); 
+=======
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		}
 
 		// If the splitting criterion were met, split the current node using the chosen attribute test, and
 		// make two new branches leading to (empty) leaves
 		if (shouldSplit) {
+<<<<<<< HEAD
+			if (node.parent == null && this.printLogsOption.isSet()) {
+				System.out.println("splitting root node at " + this.examplesSeen);
+			}
+=======
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 			AttributeExpansionSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
 
 			SplitNode newSplit = newSplitNode(splitDecision.predicate);
 			newSplit.copyStatistics(node);
 			newSplit.changeDetection = node.changeDetection;
 			newSplit.ID = node.ID;
+			leafNodeCount--;
 			//System.out.println("Splitting");
 			//System.out.println(examplesSeen);
 			for (int i = 0; i < 2; i++) { // Hardcoded for 2 values (due to the use of the Predicate class)
@@ -1456,6 +1591,7 @@ protected void attemptToSplit(LeafNode node, SplitNode parent, int parentIndex)
 				newChild.changeDetection = node.changeDetection;
 				newChild.setParent(newSplit);
 				newSplit.setChild(i, newChild);
+				leafNodeCount++;
 			}
 			if (parent == null && node.originalNode == null) {
 				treeRoot = newSplit;
@@ -1465,6 +1601,8 @@ protected void attemptToSplit(LeafNode node, SplitNode parent, int parentIndex)
 				parent.setChild(parentIndex, newSplit);
 				newSplit.setParent(parent);
 			}
+
+			splitNodeCount++;
 		}
 	}
 
diff --git a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java b/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
index fc8b2aaea..6cb747894 100644
--- a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
+++ b/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
@@ -1,3 +1,4 @@
+<<<<<<< HEAD
 /*
  *    FIMTDD.java
  *    Copyright (C) 2015 Jožef Stefan Institute, Ljubljana, Slovenia
@@ -828,7 +829,7 @@ public void processInstance(Instance inst, Node node, double prediction, double
 					}
 				}
 
-				if (iNode.changeDetection && !inAlternate) {
+				if (false && iNode.changeDetection && !inAlternate) {
 					if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
 						iNode.initializeAlternateTree();
 						growthAllowed = false;
@@ -925,11 +926,20 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 					}
 				}
 			}
+//			if (hoeffdingBound < this.tieThresholdOption.getValue() && !(secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound)) {
+//				System.out.println("Forced to split due to tie at " + this.examplesSeen);
+//				System.out.println(SizeOf.fullSizeOf(node.attributeObservers) / 1000000.0);
+//			}
 		}
 
 		// If the splitting criterion were met, split the current node using the chosen attribute test, and
 		// make two new branches leading to (empty) leaves
 		if (shouldSplit) {
+//			System.out.println("splitting node");
+//			System.out.println(SizeOf.fullSizeOf(node.attributeObservers) / 1000000.0);
+//			if (node.parent == null) {
+//				System.out.println("splitting root node at " + this.examplesSeen);
+//			}
 			AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
 						
 			SplitNode newSplit = newSplitNode(splitDecision.splitTest);
@@ -979,4 +989,976 @@ public double scalarProduct(DoubleVector u, DoubleVector v) {
 	//endregion --- Processing methods
 	
 	//endregion ================ METHODS ================
-}
\ No newline at end of file
+}
+
+=======
+/*
+ *    FIMTDD.java
+ *    Copyright (C) 2015 Jožef Stefan Institute, Ljubljana, Slovenia
+ *    @author Aljaž Osojnik <aljaz.osojnik@ijs.si>
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *    
+ *    
+ */
+
+package moa.classifiers.trees;
+
+import java.io.Serializable;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+
+import moa.options.ClassOption;
+import moa.AbstractMOAObject;
+import moa.classifiers.Regressor;
+import moa.classifiers.core.AttributeSplitSuggestion;
+import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
+import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
+import moa.classifiers.core.splitcriteria.SplitCriterion;
+import moa.classifiers.AbstractClassifier;
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.SizeOf;
+import moa.core.StringUtils;
+
+/*
+ * Implementation of FIMTDD, regression and model trees for data streams.
+ */
+
+public class FIMTDD extends AbstractClassifier implements Regressor {
+
+	private static final long serialVersionUID = 1L;
+
+	protected Node treeRoot;
+
+	protected int leafNodeCount = 0;
+	protected int splitNodeCount = 0;
+
+	protected double examplesSeen = 0.0;
+	protected double sumOfValues = 0.0;
+	protected double sumOfSquares = 0.0;
+
+	protected DoubleVector sumOfAttrValues = new DoubleVector();
+	protected DoubleVector sumOfAttrSquares = new DoubleVector();
+
+	public int maxID = 0;
+
+	//region ================ OPTIONS ================
+
+	public ClassOption splitCriterionOption = new ClassOption(
+			"splitCriterion", 's', "Split criterion to use.",
+			SplitCriterion.class, "moa.classifiers.core.splitcriteria.VarianceReductionSplitCriterion");
+
+	public IntOption gracePeriodOption = new IntOption(
+			"gracePeriod", 'g', "Number of instances a leaf should observe between split attempts.",
+			200, 0, Integer.MAX_VALUE);
+
+	public FloatOption splitConfidenceOption = new FloatOption(
+			"splitConfidence", 'c', "Allowed error in split decision, values close to 0 will take long to decide.",
+			0.0000001, 0.0, 1.0);
+
+	public FloatOption tieThresholdOption = new FloatOption(
+			"tieThreshold", 't', "Threshold below which a split will be forced to break ties.",
+			0.05, 0.0, 1.0);
+
+	public FloatOption PageHinckleyAlphaOption = new FloatOption(
+			"PageHinckleyAlpha", 'a', "Alpha value to use in the Page Hinckley change detection tests.",
+			0.005, 0.0, 1.0);
+
+	public IntOption PageHinckleyThresholdOption = new IntOption(
+			"PageHinckleyThreshold", 'h', "Threshold value used in the Page Hinckley change detection tests.",
+			50, 0, Integer.MAX_VALUE);
+
+	public FloatOption alternateTreeFadingFactorOption = new FloatOption(
+			"alternateTreeFadingFactor", 'f', "Fading factor used to decide if an alternate tree should replace an original.",
+			0.995, 0.0, 1.0);
+
+	public IntOption alternateTreeTMinOption = new IntOption(
+			"alternateTreeTMin", 'y', "Tmin value used to decide if an alternate tree should replace an original.",
+			150, 0, Integer.MAX_VALUE);
+
+	public IntOption alternateTreeTimeOption = new IntOption(
+			"alternateTreeTime", 'u', "The number of instances used to decide if an alternate tree should be discarded.",
+			1500, 0, Integer.MAX_VALUE);
+
+	public FlagOption regressionTreeOption = new FlagOption(
+			"regressionTree", 'e', "Build a regression tree instead of a model tree.");
+
+	public FloatOption learningRatioOption = new FloatOption(
+			"learningRatio", 'l', "Learning ratio to used for training the Perceptrons in the leaves.",
+			0.02, 0, 1.00);
+
+	public FloatOption learningRateDecayFactorOption = new FloatOption(
+			"learningRatioDecayFactor", 'd', "Learning rate decay factor (not used when learning rate is constant).",
+			0.001, 0, 1.00);
+
+	public FlagOption learningRatioConstOption = new FlagOption(
+			"learningRatioConst", 'p', "Keep learning rate constant instead of decaying.");
+
+	//endregion ================ OPTIONS ================
+
+	//region ================ CLASSES ================
+
+	public abstract static class Node extends AbstractMOAObject {
+
+		private static final long serialVersionUID = 1L;
+
+		public int ID;
+
+		protected FIMTDD tree;
+		
+		protected boolean changeDetection = true;
+		
+		protected Node parent;
+
+		protected Node alternateTree;
+		protected Node originalNode;
+
+		// The statistics for this node:
+		// Number of instances that have reached it
+		protected double examplesSeen;
+		// Sum of y values
+		protected double sumOfValues;
+		// Sum of squared y values
+		protected double sumOfSquares;
+		// Sum of absolute errors
+		protected double sumOfAbsErrors; // Needed for PH tracking of mean error
+
+		public Node(FIMTDD tree) {
+			this.tree = tree;
+			ID = tree.maxID; 
+		}
+
+		public void copyStatistics(Node node) {
+			examplesSeen = node.examplesSeen;
+			sumOfValues = node.sumOfValues;
+			sumOfSquares = node.sumOfSquares;
+			sumOfAbsErrors = node.sumOfAbsErrors;
+		}
+
+		public int calcByteSize() {
+			return (int) SizeOf.fullSizeOf(this);
+		}
+
+		/**
+		 * Set the parent node
+		 */
+		public void setParent(Node parent) {
+			this.parent = parent;    
+		}
+
+		/**
+		 * Return the parent node
+		 */
+		public Node getParent() {
+			return parent;
+		}
+
+		public void disableChangeDetection() {
+			changeDetection = false;
+		}
+
+		public void restartChangeDetection() {
+			changeDetection = true;
+		}
+		
+		public void getDescription(StringBuilder sb, int indent) {
+			
+		}
+
+		public double getPrediction(Instance inst) {
+			return 0;
+		}
+		
+		public void describeSubtree(StringBuilder out, int indent) {
+			StringUtils.appendIndented(out, indent, "Leaf");
+		}
+		
+		public int getLevel() {
+			Node target = this;
+			int level = 0;
+			while (target.getParent() != null) {
+				if (target.skipInLevelCount()) {
+					target = target.getParent();
+					continue;
+				}
+				level = level + 1;
+				target = target.getParent();
+			}
+			if (target.originalNode == null) {
+				return level;
+			} else {
+				return level + originalNode.getLevel();
+			}
+		}
+
+		public void setChild(int parentBranch, Node node) {
+		}
+
+		public int getChildIndex(Node child) {
+			return -1;
+		}
+
+		public int getNumSubtrees() {
+			return 1;
+		}
+
+		protected boolean skipInLevelCount() {
+			return false;
+		}
+	}
+
+	public static class LeafNode extends Node {
+
+		private static final long serialVersionUID = 1L;
+
+		// Perceptron model that carries out the actual learning in each node
+		public FIMTDDPerceptron learningModel;
+
+		protected AutoExpandVector<FIMTDDNumericAttributeClassObserver> attributeObservers = new AutoExpandVector<FIMTDDNumericAttributeClassObserver>();
+		
+		protected double examplesSeenAtLastSplitEvaluation = 0;
+
+		/**
+		 * Create a new LeafNode
+		 */
+		public LeafNode(FIMTDD tree) {
+			super(tree);
+			if (tree.buildingModelTree()) {
+				learningModel = tree.newLeafModel();
+			}
+			examplesSeen = 0;
+			sumOfValues = 0;
+			sumOfSquares = 0;
+			sumOfAbsErrors = 0;
+		}
+
+		public void setChild(int parentBranch, Node node) {
+		}
+
+		public int getChildIndex(Node child) {
+			return -1;
+		}
+
+		public int getNumSubtrees() {
+			return 1;
+		}
+
+		protected boolean skipInLevelCount() {
+			return false;
+		}
+		
+		/**
+		 * Method to learn from an instance that passes the new instance to the perceptron learner,
+		 * and also prevents the class value from being truncated to an int when it is passed to the
+		 * attribute observer
+		 */
+		public void learnFromInstance(Instance inst, boolean growthAllowed) {
+			//The prediction must be calculated here -- it may be different from the tree's prediction due to alternate trees
+			
+			// Update the statistics for this node
+			// number of instances passing through the node
+			examplesSeen += inst.weight();
+
+			// sum of y values
+			sumOfValues += inst.weight() * inst.classValue();
+
+			// sum of squared y values
+			sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
+
+			// sum of absolute errors
+			sumOfAbsErrors += inst.weight() * Math.abs(tree.normalizeTargetValue(Math.abs(inst.classValue() - getPrediction(inst))));
+
+			if (tree.buildingModelTree()) learningModel.updatePerceptron(inst);
+
+			for (int i = 0; i < inst.numAttributes() - 1; i++) {
+				int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
+				FIMTDDNumericAttributeClassObserver obs = attributeObservers.get(i);
+				if (obs == null) {
+					// At this stage all nominal attributes are ignored
+					if (inst.attribute(instAttIndex).isNumeric()) {
+						obs = tree.newNumericClassObserver();
+						this.attributeObservers.set(i, obs);
+					}
+				}
+				if (obs != null) {
+					obs.observeAttributeClass(inst.value(instAttIndex), inst.classValue(), inst.weight());
+				}
+			}
+
+			if (growthAllowed) {
+				checkForSplit(tree);
+			}
+		}
+
+		/**
+		 * Return the best split suggestions for this node using the given split criteria
+		 */
+		public AttributeSplitSuggestion[] getBestSplitSuggestions(SplitCriterion criterion) {
+
+			List<AttributeSplitSuggestion> bestSuggestions = new LinkedList<AttributeSplitSuggestion>();
+
+			// Set the nodeStatistics up as the preSplitDistribution, rather than the observedClassDistribution
+			double[] nodeSplitDist = new double[] {examplesSeen, sumOfValues, sumOfSquares};
+
+			for (int i = 0; i < this.attributeObservers.size(); i++) {
+				FIMTDDNumericAttributeClassObserver obs = this.attributeObservers.get(i);
+				if (obs != null) {
+
+					// AT THIS STAGE NON-NUMERIC ATTRIBUTES ARE IGNORED
+					AttributeSplitSuggestion bestSuggestion = null;
+					if (obs instanceof FIMTDDNumericAttributeClassObserver) {
+						bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion, nodeSplitDist, i, true);
+					}
+
+					if (bestSuggestion != null) {
+						bestSuggestions.add(bestSuggestion);
+					}
+				}
+			}
+			return bestSuggestions.toArray(new AttributeSplitSuggestion[bestSuggestions.size()]);
+		}
+
+		/**
+		 * Retrieve the class votes using the perceptron learner
+		 */
+		public double getPredictionModel(Instance inst) {
+			return learningModel.prediction(inst);
+		}
+
+		public double getPredictionTargetMean(Instance inst) {
+			return (examplesSeen > 0.0) ? sumOfValues / examplesSeen : 0.0;
+		}
+
+		public double getPrediction(Instance inst) {
+			return (tree.buildingModelTree()) ? getPredictionModel(inst) : getPredictionTargetMean(inst);
+		}
+		
+		public void checkForSplit(FIMTDD tree) {
+			// If it has seen Nmin examples since it was last tested for splitting, attempt a split of this node
+			if (examplesSeen - examplesSeenAtLastSplitEvaluation >= tree.gracePeriodOption.getValue()) {
+				int index = (parent != null) ? parent.getChildIndex(this) : 0;
+				tree.attemptToSplit(this, parent, index);
+
+				// Take note of how many instances were seen when this split evaluation was made, so we know when to perform the next split evaluation
+				examplesSeenAtLastSplitEvaluation = examplesSeen;
+			}
+		}
+
+		public void describeSubtree(StringBuilder out, int indent) {
+			StringUtils.appendIndented(out, indent, "Leaf ");
+			if (tree.buildingModelTree()) {
+				learningModel.getModelDescription(out, 0);
+			} else {
+				out.append(tree.getClassNameString() + " = " + String.format("%.4f", (sumOfValues / examplesSeen)));
+				StringUtils.appendNewline(out);
+			}
+		}
+	}
+
+	public abstract static class InnerNode extends Node {
+		// The InnerNode and SplitNode design is used for easy extension in ORTO
+		private static final long serialVersionUID = 1L;
+
+		protected AutoExpandVector<Node> children = new AutoExpandVector<Node>();
+
+		// The error values for the Page Hinckley test
+		// PHmT = the cumulative sum of the errors
+		// PHMT = the minimum error value seen so far
+		protected double PHsum = 0;
+		protected double PHmin = Double.MAX_VALUE;
+
+		// Keep track of the statistics for loss error calculations
+		protected double lossExamplesSeen;
+		protected double lossFadedSumOriginal;
+		protected double lossFadedSumAlternate;
+		protected double lossNumQiTests;
+		protected double lossSumQi;
+		protected double previousWeight = 0;
+		
+		public InnerNode(FIMTDD tree) {
+			super(tree);
+		}
+
+		public int numChildren() {
+			return children.size();
+		}
+
+		public Node getChild(int index) {
+			return children.get(index);
+		}
+
+		public int getChildIndex(Node child) {
+			return children.indexOf(child);
+		}
+
+		public void setChild(int index, Node child) {
+			children.set(index, child);
+		}
+
+		public void disableChangeDetection() {
+			changeDetection = false;
+			for (Node child : children) {
+				child.disableChangeDetection();
+			}
+		}
+
+		public void restartChangeDetection() {
+			if (alternateTree == null) {
+				changeDetection = true;
+				PHsum = 0;
+				PHmin = Integer.MAX_VALUE;
+				for (Node child : children)
+					child.restartChangeDetection();
+			}
+		}
+		
+		/**
+		 * Check to see if the tree needs updating
+		 */
+		public boolean PageHinckleyTest(double error, double threshold) {    
+			// Update the cumulative mT sum
+			PHsum += error;
+
+			// Update the minimum mT value if the new mT is
+			// smaller than the current minimum
+			if(PHsum < PHmin) {
+				PHmin = PHsum;
+			}
+			// Return true if the cumulative value - the current minimum is
+			// greater than the current threshold (in which case we should adapt)
+			return PHsum - PHmin > threshold;
+		}
+		
+		public void initializeAlternateTree() {
+			// Start a new alternate tree, beginning with a learning node
+			alternateTree = tree.newLeafNode();
+			alternateTree.originalNode = this;
+
+			// Set up the blank statistics
+			// Number of instances reaching this node since the alternate tree was started
+			lossExamplesSeen = 0;
+			// Faded squared error (original tree)
+			lossFadedSumOriginal = 0;
+			// Faded squared error (alternate tree)
+			lossFadedSumAlternate = 0;
+			// Number of evaluations of alternate tree
+			lossNumQiTests = 0;
+			// Sum of Qi values
+			lossSumQi = 0;
+			// Number of examples at last test
+			previousWeight = 0;
+
+			// Disable the change detection mechanism bellow this node
+			disableChangeDetection();
+		}
+	}
+	
+	public static class SplitNode extends InnerNode {
+
+		private static final long serialVersionUID = 1L;
+
+		protected InstanceConditionalTest splitTest;
+
+		/**
+		 * Create a new SplitNode
+		 * @param tree 
+		 */
+		public SplitNode(InstanceConditionalTest splitTest, FIMTDD tree) {
+			super(tree);
+			this.splitTest = splitTest;
+		}
+
+		public int instanceChildIndex(Instance inst) {
+			return splitTest.branchForInstance(inst);
+		}
+		
+		public Node descendOneStep(Instance inst) {
+			return children.get(splitTest.branchForInstance(inst));
+		}
+
+		public void describeSubtree(StringBuilder out, int indent) {
+			for (int branch = 0; branch < children.size(); branch++) {
+				Node child = getChild(branch);
+				if (child != null) {
+					StringUtils.appendIndented(out, indent, "if ");
+					out.append(this.splitTest.describeConditionForBranch(branch,
+							tree.getModelContext()));
+					out.append(": ");
+					StringUtils.appendNewline(out);
+					child.describeSubtree(out, indent + 2);
+				}
+			}
+		}
+
+		public double getPrediction(Instance inst) {
+			return children.get(splitTest.branchForInstance(inst)).getPrediction(inst);
+		}
+	}
+
+	public class FIMTDDPerceptron implements Serializable {
+
+		private static final long serialVersionUID = 1L;
+		
+		protected FIMTDD tree;
+		
+		// The Perception weights 
+		protected DoubleVector weightAttribute = new DoubleVector(); 
+
+		protected double sumOfValues;
+		protected double sumOfSquares;
+
+		// The number of instances contributing to this model
+		protected double instancesSeen = 0;
+
+		// If the model should be reset or not
+		protected boolean reset;
+
+		public String getPurposeString() {
+			return "A perceptron regressor as specified by Ikonomovska et al. used for FIMTDD";
+		}
+
+		public FIMTDDPerceptron(FIMTDDPerceptron original) {
+			this.tree = original.tree;
+			weightAttribute = (DoubleVector) original.weightAttribute.copy();
+			reset = false;
+		}
+
+		public FIMTDDPerceptron(FIMTDD tree) {
+			this.tree = tree;
+			reset = true;
+		}
+
+
+		public DoubleVector getWeights() {
+			return weightAttribute;
+		}
+
+		/**
+		 * Update the model using the provided instance
+		 */
+		public void updatePerceptron(Instance inst) {
+
+			// Initialize perceptron if necessary   
+			if (reset == true) {
+				reset = false;
+				weightAttribute = new DoubleVector();
+				instancesSeen = 0;
+				for (int j = 0; j < inst.numAttributes(); j++) { // The last index corresponds to the constant b
+					weightAttribute.setValue(j, 2 * tree.classifierRandom.nextDouble() - 1);
+				}
+			}
+
+			// Update attribute statistics
+			instancesSeen += inst.weight();
+
+			// Update weights
+			double learningRatio = 0.0;
+			if (tree.learningRatioConstOption.isSet()) {
+				learningRatio = learningRatioOption.getValue();
+			} else {
+				learningRatio = learningRatioOption.getValue() / (1 + instancesSeen * tree.learningRateDecayFactorOption.getValue());
+			}
+
+			sumOfValues += inst.weight() * inst.classValue();
+			sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
+
+			// Loop for compatibility with bagging methods 
+			for (int i = 0; i < (int) inst.weight(); i++) {
+				updateWeights(inst, learningRatio);
+			}
+		}
+
+		public void updateWeights(Instance inst, double learningRatio) {
+			// Compute the normalized instance and the delta
+			DoubleVector normalizedInstance = normalizedInstance(inst); 
+			double normalizedPrediction = prediction(normalizedInstance);
+			double normalizedValue = tree.normalizeTargetValue(inst.classValue());
+			double delta = normalizedValue - normalizedPrediction;
+			normalizedInstance.scaleValues(delta * learningRatio);
+			
+			weightAttribute.addValues(normalizedInstance);
+		}
+
+		public DoubleVector normalizedInstance(Instance inst) {
+			// Normalize Instance
+			DoubleVector normalizedInstance = new DoubleVector();
+			for (int j = 0; j < inst.numAttributes() - 1; j++) {
+				int instAttIndex = modelAttIndexToInstanceAttIndex(j, inst);
+				double mean = tree.sumOfAttrValues.getValue(j) / tree.examplesSeen;
+				double sd = computeSD(tree.sumOfAttrSquares.getValue(j), tree.sumOfAttrValues.getValue(j), tree.examplesSeen);
+				if (inst.attribute(instAttIndex).isNumeric() && tree.examplesSeen > 1 && sd > 0)
+					normalizedInstance.setValue(j, (inst.value(instAttIndex) - mean) / (3 * sd));
+				else
+					normalizedInstance.setValue(j, 0);
+			}
+			if (tree.examplesSeen > 1)
+				normalizedInstance.setValue(inst.numAttributes() - 1, 1.0); // Value to be multiplied with the constant factor
+			else
+				normalizedInstance.setValue(inst.numAttributes() - 1, 0.0);
+			return normalizedInstance;
+		}
+
+		/**
+		 * Output the prediction made by this perceptron on the given instance
+		 */
+		public double prediction(DoubleVector instanceValues) {
+			return scalarProduct(weightAttribute, instanceValues);
+		}
+
+		protected double prediction(Instance inst) {
+			DoubleVector normalizedInstance = normalizedInstance(inst);
+			double normalizedPrediction = prediction(normalizedInstance);
+			return denormalizePrediction(normalizedPrediction, tree);
+		}
+
+		private double denormalizePrediction(double normalizedPrediction, FIMTDD tree) {
+			double mean = tree.sumOfValues / tree.examplesSeen;
+			double sd = computeSD(tree.sumOfSquares, tree.sumOfValues, tree.examplesSeen);
+			if (examplesSeen > 1) 
+				return normalizedPrediction * sd * 3 + mean;
+			else
+				return 0.0;
+		}
+		
+		public void getModelDescription(StringBuilder out, int indent) {
+	        StringUtils.appendIndented(out, indent, getClassNameString() + " =");
+			if (getModelContext() != null) {
+				for (int j = 0; j < getModelContext().numAttributes() - 1; j++) {
+					if (getModelContext().attribute(j).isNumeric()) {
+						out.append((j == 0 || weightAttribute.getValue(j) < 0) ? " " : " + ");
+		                out.append(String.format("%.4f", weightAttribute.getValue(j)));
+		                out.append(" * ");
+		                out.append(getAttributeNameString(j));
+		            }
+		        }
+				out.append(" + " + weightAttribute.getValue((getModelContext().numAttributes() - 1)));
+			}
+	        StringUtils.appendNewline(out);
+		}
+	}
+
+
+	//endregion ================ CLASSES ================
+
+	//region ================ METHODS ================
+
+	// region --- Regressor methods
+	
+	public String getPurposeString() {
+		return "Implementation of the FIMT-DD tree as described by Ikonomovska et al.";
+	}
+
+	public void resetLearningImpl() {
+		this.treeRoot = null;
+		this.leafNodeCount = 0;
+		this.splitNodeCount = 0;
+		this.maxID = 0;
+		this.examplesSeen = 0;
+		this.sumOfValues = 0.0;
+		this.sumOfSquares = 0.0;
+
+		this.sumOfAttrValues = new DoubleVector();
+		this.sumOfAttrSquares = new DoubleVector();
+	}
+
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	public void getModelDescription(StringBuilder out, int indent) {
+		if (treeRoot != null) treeRoot.describeSubtree(out, indent);
+	}
+
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[]{ 
+				new Measurement("tree size (leaves)", this.leafNodeCount)
+		};
+	}
+
+	public int calcByteSize() {
+		return (int) SizeOf.fullSizeOf(this);
+	}
+
+	public double[] getVotesForInstance(Instance inst) {
+		if (treeRoot == null) {
+			return new double[] {0};
+		}
+
+		double prediction = treeRoot.getPrediction(inst);
+
+		return new double[] {prediction};
+	}
+
+	public double normalizeTargetValue(double value) {
+		if (examplesSeen > 1) {
+			double sd = Math.sqrt((sumOfSquares - ((sumOfValues * sumOfValues)/examplesSeen))/examplesSeen);
+			double average = sumOfValues / examplesSeen;
+			if (sd > 0 && examplesSeen > 1)
+				return (value - average) / (3 * sd);
+			else
+				return 0.0;
+		}
+		return 0.0;
+	}
+
+	public double getNormalizedError(Instance inst, double prediction) {
+		double normalPrediction = normalizeTargetValue(prediction);
+		double normalValue = normalizeTargetValue(inst.classValue());
+		return Math.abs(normalValue - normalPrediction);
+	}
+
+
+	/**
+	 * Method for updating (training) the model using a new instance
+	 */
+	public void trainOnInstanceImpl(Instance inst) {
+		checkRoot();
+
+		examplesSeen += inst.weight();
+		sumOfValues += inst.weight() * inst.classValue();
+		sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
+
+		for (int i = 0; i < inst.numAttributes() - 1; i++) {
+			int aIndex = modelAttIndexToInstanceAttIndex(i, inst);
+			sumOfAttrValues.addToValue(i, inst.weight() * inst.value(aIndex));
+			sumOfAttrSquares.addToValue(i, inst.weight() * inst.value(aIndex) * inst.value(aIndex));
+		}
+
+		double prediction = treeRoot.getPrediction(inst);
+		processInstance(inst, treeRoot, prediction, getNormalizedError(inst, prediction), true, false);
+	}
+
+	public void processInstance(Instance inst, Node node, double prediction, double normalError, boolean growthAllowed, boolean inAlternate) {
+		Node currentNode = node;
+		while (true) {
+			if (currentNode instanceof LeafNode) {
+				((LeafNode) currentNode).learnFromInstance(inst, growthAllowed);
+				break;
+			} else {
+				currentNode.examplesSeen += inst.weight();
+				currentNode.sumOfAbsErrors += inst.weight() * normalError;
+				SplitNode iNode = (SplitNode) currentNode;
+				if (!inAlternate && iNode.alternateTree != null) {
+					boolean altTree = true;
+					double lossO = Math.pow(inst.classValue() - prediction, 2);
+					double lossA = Math.pow(inst.classValue() - iNode.alternateTree.getPrediction(inst), 2);
+					
+					// Loop for compatibility with bagging methods
+					for (int i = 0; i < inst.weight(); i++) {
+						iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
+						iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
+						iNode.lossExamplesSeen++;
+						
+						double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
+						iNode.lossSumQi += Qi;
+						iNode.lossNumQiTests += 1;
+					}
+					double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
+					double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+					double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+					
+					if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
+						iNode.previousWeight = iNode.lossExamplesSeen;
+						if (Qi > 0) {
+							// Switch the subtrees
+							Node parent = currentNode.getParent();
+
+							if (parent != null) {
+								Node replacementTree = iNode.alternateTree;
+								parent.setChild(parent.getChildIndex(currentNode), replacementTree);
+								if (growthAllowed) replacementTree.restartChangeDetection();
+							} else {
+								treeRoot = iNode.alternateTree;
+								treeRoot.restartChangeDetection();
+							}
+
+							currentNode = iNode.alternateTree;
+							currentNode.originalNode = null;
+							altTree = false;
+						} else if (
+								(QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * this.gracePeriodOption.getValue()))
+								|| iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()
+								) {
+							// Remove the alternate tree
+							iNode.alternateTree = null;
+							if (growthAllowed) iNode.restartChangeDetection();
+							altTree = false;
+						}
+					}
+
+					if (altTree) {
+						growthAllowed = false;
+						processInstance(inst, iNode.alternateTree, prediction, normalError, true, true);
+					}
+				}
+
+				if (iNode.changeDetection && !inAlternate) {
+					if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+						iNode.initializeAlternateTree();
+					}
+				}
+				if (currentNode instanceof SplitNode) {
+					currentNode = ((SplitNode) currentNode).descendOneStep(inst);
+				} 
+			}
+		}
+	}
+
+	// endregion --- Regressor methods
+	
+	// region --- Object instatiation methods
+
+	protected FIMTDDNumericAttributeClassObserver newNumericClassObserver() {
+		return new FIMTDDNumericAttributeClassObserver();
+	}
+
+	protected SplitNode newSplitNode(InstanceConditionalTest splitTest) {
+		maxID++;
+		return new SplitNode(splitTest, this);
+	}
+
+	protected LeafNode newLeafNode() {
+		maxID++;
+		return new LeafNode(this);
+	}
+
+	protected FIMTDDPerceptron newLeafModel() {
+		return new FIMTDDPerceptron(this);
+	}
+
+	//endregion --- Object instatiation methods
+	
+	// region --- Processing methods
+	
+	protected void checkRoot() {
+		if (treeRoot == null) {
+			treeRoot = newLeafNode();
+			leafNodeCount = 1;
+		}
+	}
+
+	public static double computeHoeffdingBound(double range, double confidence, double n) {
+		return Math.sqrt(( (range * range) * Math.log(1 / confidence)) / (2.0 * n));
+	}
+
+	public boolean buildingModelTree() {
+		return !regressionTreeOption.isSet();
+	}
+
+	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
+		// Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
+		SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
+
+		// Using this criterion, find the best split per attribute and rank the results
+		AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion);
+		Arrays.sort(bestSplitSuggestions);
+
+		// Declare a variable to determine if any of the splits should be performed
+		boolean shouldSplit = false;
+
+		// If only one split was returned, use it
+		if (bestSplitSuggestions.length < 2) {
+			shouldSplit = bestSplitSuggestions.length > 0;
+		} else { // Otherwise, consider which of the splits proposed may be worth trying
+
+			// Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
+			// to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
+			double hoeffdingBound = computeHoeffdingBound(1, this.splitConfidenceOption.getValue(), node.examplesSeen);
+			// Determine the top two ranked splitting suggestions
+			AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+			AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
+
+			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
+			// as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
+			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
+			// splitting should occur.
+			// Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
+			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
+			// competing attributes are equally good, and the split will be made on the one with the higher SDR value.
+			if ((secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) || (hoeffdingBound < this.tieThresholdOption.getValue())) {
+				shouldSplit = true;
+			}
+			// If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
+			else {
+				for (int i = 0; i < node.attributeObservers.size(); i++) {
+					FIMTDDNumericAttributeClassObserver obs = node.attributeObservers.get(i);
+					if (obs != null) {
+						obs.removeBadSplits(splitCriterion, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound);    
+					}
+				}
+			}
+		}
+
+		// If the splitting criterion were met, split the current node using the chosen attribute test, and
+		// make two new branches leading to (empty) leaves
+		if (shouldSplit) {
+			AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+
+			SplitNode newSplit = newSplitNode(splitDecision.splitTest);
+			newSplit.copyStatistics(node);
+			newSplit.changeDetection = node.changeDetection;
+			newSplit.ID = node.ID;
+			leafNodeCount--;
+			for (int i = 0; i < splitDecision.numSplits(); i++) {
+				LeafNode newChild = newLeafNode();
+				if (buildingModelTree()) {
+					// Copy the splitting node's perceptron to it's children
+					newChild.learningModel = new FIMTDDPerceptron((FIMTDDPerceptron) node.learningModel);
+					
+				}
+				newChild.changeDetection = node.changeDetection;
+				newChild.setParent(newSplit);
+				newSplit.setChild(i, newChild);
+				leafNodeCount++;
+			}
+			if (parent == null && node.originalNode == null) {
+				treeRoot = newSplit;
+			} else if (parent == null && node.originalNode != null) {
+				node.originalNode.alternateTree = newSplit;
+			} else {
+				((SplitNode) parent).setChild(parentIndex, newSplit);
+				newSplit.setParent(parent);
+			}
+			
+			splitNodeCount++;
+		}
+	}
+	
+	public double computeSD(double squaredVal, double val, double size) {
+		if (size > 1)
+			return Math.sqrt((squaredVal - ((val * val) / size)) / size);
+		else
+			return 0.0;
+	}
+	
+	public double scalarProduct(DoubleVector u, DoubleVector v) {
+		double ret = 0.0;
+		for (int i = 0; i < Math.max(u.numValues(), v.numValues()); i++) {
+			ret += u.getValue(i) * v.getValue(i);
+		}
+		return ret;
+	}
+	//endregion --- Processing methods
+	
+	//endregion ================ METHODS ================
+}
+
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
diff --git a/moa/src/main/java/moa/classifiers/trees/ORTO.java b/moa/src/main/java/moa/classifiers/trees/ORTO.java
index 7ab9734db..2745dcc7e 100644
--- a/moa/src/main/java/moa/classifiers/trees/ORTO.java
+++ b/moa/src/main/java/moa/classifiers/trees/ORTO.java
@@ -35,11 +35,16 @@
 import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
 import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
-
+<<<<<<< HEAD
+import moa.classifiers.trees.FIMTDD.InnerNode;
+import moa.classifiers.trees.FIMTDD.Node;
 import moa.core.AutoExpandVector;
 import moa.core.Measurement;
 import moa.core.StringUtils;
-
+=======
+import moa.core.AutoExpandVector;
+import moa.core.Measurement;
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 
 /*
  * Implementation of ORTO, option trees for data streams.
@@ -122,9 +127,15 @@ public int getNumSubtrees() {
 
 		public int directionForBestTree() {
 			int d = 0;
+<<<<<<< HEAD
+			double min = Double.MAX_VALUE;
+			for (int i = 0; i < numChildren(); i++) {
+				double tmp = getFFRatio(i);
+=======
 			double tmp = 0.0, min = Double.MAX_VALUE;
 			for (int i = 0; i < children.size(); i++) {
 				tmp = getFFRatio(i);
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				if (tmp < min) {
 					min = tmp;
 					d = i;
@@ -133,22 +144,38 @@ public int directionForBestTree() {
 			return d;
 		}
 
+<<<<<<< HEAD
 		public double getPrediction(Instance inst) {
+=======
+		public double getPrediction(Instance inst, ORTO tree) {
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 			double[] predictions = new double[numChildren()];
 			for (int i = 0; i < numChildren(); i++) {
 				predictions[i] = getChild(i).getPrediction(inst);
 			}
+<<<<<<< HEAD
 			return aggregate(predictions);
 		}
 
 		private double aggregate(double[] predictions) {
 			if (((ORTO) tree).optionNodeAggregationOption.getChosenIndex() == 0) { // Average
+=======
+			return aggregate(predictions, tree);
+		}
+
+		private double aggregate(double[] predictions, ORTO tree) {
+			if (tree.optionNodeAggregationOption.getChosenIndex() == 0) { // Average
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				double sum = 0.0;
 				for (int i = 0; i < predictions.length; i++) {
 					sum += predictions[i];
 				}
 				return sum / predictions.length;
+<<<<<<< HEAD
 			} else if (((ORTO) tree).optionNodeAggregationOption.getChosenIndex() == 1) {
+=======
+			} else if (tree.optionNodeAggregationOption.getChosenIndex() == 1) {
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				int d = directionForBestTree();
 				return predictions[d];
 			} else {
@@ -163,6 +190,7 @@ public double getFFRatio(int childIndex) {
 		protected boolean skipInLevelCount() {
 			return true;
 		}
+<<<<<<< HEAD
 		
 		@Override
 		public void describeSubtree(StringBuilder out, int indent) {
@@ -175,7 +203,8 @@ public void describeSubtree(StringBuilder out, int indent) {
 				split.describeSubtree(out, indent + 2);
 			}
 		}
-
+=======
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 	}
 
 	//endregion ================ CLASSES ================
@@ -210,7 +239,11 @@ public void processInstance(Instance inst, Node node, double prediction, double
 			Node currentNode = node;
 			while (true) {
 				if (currentNode instanceof LeafNode) {
+<<<<<<< HEAD
 					((LeafNode) currentNode).learnFromInstance(inst, growthAllowed, prediction);
+=======
+					((LeafNode) currentNode).learnFromInstance(inst, growthAllowed);
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 					break;
 				} else {
 					currentNode.examplesSeen += inst.weight();
@@ -219,7 +252,11 @@ public void processInstance(Instance inst, Node node, double prediction, double
 					if (!inAlternate && iNode.alternateTree != null) {
 						boolean altTree = true;
 						double lossO = Math.pow(inst.classValue() - prediction, 2);
+<<<<<<< HEAD
 						double lossA = Math.pow(inst.classValue() - iNode.alternateTree.getPrediction(inst), 2);
+=======
+						double lossA = Math.pow(inst.classValue() - currentNode.alternateTree.getPrediction(inst), 2);
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 						
 						// Loop for compatibility with bagging methods
 						for (int i = 0; i < inst.weight(); i++) {
@@ -239,7 +276,11 @@ public void processInstance(Instance inst, Node node, double prediction, double
 							iNode.previousWeight = iNode.lossExamplesSeen;
 							if (Qi > 0) {
 								// Switch the subtrees
+<<<<<<< HEAD
 								Node parent = iNode.getParent();
+=======
+								Node parent = currentNode.parent;
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 								
 								if (parent != null) {
 									Node replacementTree = iNode.alternateTree;
@@ -249,7 +290,11 @@ public void processInstance(Instance inst, Node node, double prediction, double
 									treeRoot = iNode.alternateTree;
 									treeRoot.restartChangeDetection();
 								}
+<<<<<<< HEAD
 								optionNodeCount += iNode.alternateTree.getNumSubtrees() - iNode.getNumSubtrees();
+=======
+								optionNodeCount += currentNode.alternateTree.getNumSubtrees() - currentNode.getNumSubtrees();
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 								removeExcessTrees();
 										
 								currentNode = iNode.alternateTree;
@@ -264,7 +309,11 @@ public void processInstance(Instance inst, Node node, double prediction, double
 						}
 						if (altTree) {
 							growthAllowed = false; // this is the growth of the original tree
+<<<<<<< HEAD
 							processInstance(inst, iNode.alternateTree, prediction, normalError, true, true); // growth is allowed in the alt tree
+=======
+							processInstance(inst, currentNode.alternateTree, prediction, normalError, true, true); // growth is allowed in the alt tree
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 						} else if (currentNode instanceof OptionNode) {
 							// this happens when an option node is switched into the tree
 							for (Node child : ((OptionNode) currentNode).children) {
@@ -292,23 +341,35 @@ public void processInstance(Instance inst, Node node, double prediction, double
 	}
 	
 	public void processInstanceOptionNode(Instance inst, OptionNode node, double prediction, double normalError, boolean growthAllowed, boolean inAlternate) {
+<<<<<<< HEAD
 		node.examplesSeen += inst.weight();
 		node.sumOfAbsErrors += inst.weight() * normalError;
-
+=======
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		if (node.changeDetection) {
 			double error = Math.abs(prediction - inst.classValue());
 			node.sumOfAbsErrors += error;
 			
 			if (((InnerNode) node).PageHinckleyTest(error - node.sumOfAbsErrors / node.examplesSeen + PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
 				node.initializeAlternateTree();
+<<<<<<< HEAD
 				growthAllowed = false;
+=======
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 			}
 		}
 
 		for (Node child : node.children) {
 			int index = node.getChildIndex(child);
 			double childPrediction = child.getPrediction(inst);
+<<<<<<< HEAD
+			node.optionFFSeen[index] = node.optionFFSeen[index] * optionFadingFactorOption.getValue() + 1;
+			node.optionFFSSL[index] = node.optionFFSSL[index] * optionFadingFactorOption.getValue() + Math.pow(childPrediction - inst.classValue(), 2);
+		}
 
+		for (Node child : node.children) {
+			processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed, inAlternate);
+=======
 			// Loop for compatibility with bagging methods
 			for (int i = 0; i < inst.weight(); i++) {
 				node.optionFFSeen[index] = node.optionFFSeen[index] * optionFadingFactorOption.getValue() + 1;
@@ -318,6 +379,7 @@ public void processInstanceOptionNode(Instance inst, OptionNode node, double pre
 
 		for (Node child : node.children) {
 			processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed && node.alternateTree == null, inAlternate);
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		}
 	}
 	
@@ -335,6 +397,10 @@ protected OptionNode newOptionNode() {
 	// region --- Processing methods
 
 	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
+<<<<<<< HEAD
+
+=======
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		// Initialize the split criterion 
 		SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(splitCriterionOption);
 
@@ -342,7 +408,11 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 		AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion);
 		List<AttributeSplitSuggestion> acceptedSplits = new LinkedList<AttributeSplitSuggestion>();
 		Arrays.sort(bestSplitSuggestions);
+<<<<<<< HEAD
+		
+=======
 
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		// Declare a variable to determine the number of splits to be performed
 		int numSplits = 0;
 
@@ -360,7 +430,10 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 			AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
 			AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
 
-
+<<<<<<< HEAD
+			
+=======
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
 			// as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
 			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
@@ -372,6 +445,7 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 				numSplits = 1;
 				acceptedSplits.add(bestSuggestion);
 			} else if (numTrees < maxTreesOption.getValue() && node.getLevel() <= maxOptionLevelOption.getValue()) {
+<<<<<<< HEAD
 				for (int i = 0; i < bestSplitSuggestions.length; i++) {
 					AttributeSplitSuggestion suggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1 - i];
 					if (suggestion.merit / bestSuggestion.merit >= 1 - hoeffdingBound) {
@@ -382,7 +456,15 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 					}
 						
 				}
-
+				
+=======
+				for (AttributeSplitSuggestion suggestion : bestSplitSuggestions) {
+					if (suggestion.merit / bestSuggestion.merit >= 1 - hoeffdingBound) {
+						numSplits++;
+						acceptedSplits.add(suggestion);
+					}
+				}
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 			} else if (hoeffdingBound < tieThresholdOption.getValue()) {
 				numSplits = 1;
 				acceptedSplits.add(bestSplitSuggestions[0]);
@@ -401,7 +483,11 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 		if (numSplits > 0) {
 			double optionFactor = numSplits * Math.pow(optionDecayFactorOption.getValue(), (double) node.getLevel());
 
+<<<<<<< HEAD
+			if (numSplits == 1 || optionFactor < 2.0 || maxTreesOption.getValue() - numTrees <= 0) {
+=======
 			if (numSplits == 1 || optionFactor < 2.0 || maxTreesOption.getValue() - numTrees <= 1) {
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				AttributeSplitSuggestion splitDecision = acceptedSplits.get(0);
 				SplitNode newSplit = newSplitNode(splitDecision.splitTest);
 				for (int i = 0; i < splitDecision.numSplits(); i++) {
@@ -412,12 +498,19 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 				leafNodeCount--;
 				innerNodeCount++;
 				leafNodeCount += splitDecision.numSplits();
+<<<<<<< HEAD
 				if (parent == null && node.originalNode == null) {
 					treeRoot = newSplit;
 				} else if (parent == null && node.originalNode != null) {
 					node.originalNode.alternateTree = newSplit;
 				} else {
 					parent.setChild(parentIndex, newSplit);
+=======
+				if (parent == null) {
+					treeRoot = newSplit;
+				} else {
+					parent.setChild(parent.getChildIndex(node), newSplit);
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 					newSplit.setParent(parent);
 				}
 			} else {
@@ -451,7 +544,11 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 				if (parent == null) {
 					treeRoot = optionNode;
 				} else {
+<<<<<<< HEAD
 					parent.setChild(parentIndex, optionNode);
+=======
+					parent.setChild(parent.getChildIndex(node), optionNode);
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 					optionNode.setParent(parent);
 				}
 
@@ -534,5 +631,8 @@ protected void removeExcessTrees() {
 	// endregion --- Option tree methods
 	
 	//endregion ================ METHODS ================
+<<<<<<< HEAD
 }
-
+=======
+}
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
diff --git a/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java b/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
index 61f2ee877..4202599c6 100644
--- a/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
+++ b/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
@@ -154,6 +154,7 @@ protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
 		int secondsElapsed = 0;
 		monitor.setCurrentActivity("Evaluating learner...", -1.0);
 
+<<<<<<< HEAD
 		File dumpFile = this.dumpFileOption.getFile();
 		PrintStream immediateResultStream = null;
 		if (dumpFile != null) {
@@ -207,7 +208,63 @@ protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
 					sb.append("Out " + i + ": " + ((Instance) trainInst.getData()).valueOutputAttribute(i) + " ");
 				}
 				outputPredictionResultStream.println(prediction + "," + sb.toString());
-			}
+			}
+=======
+        File dumpFile = this.dumpFileOption.getFile();
+        PrintStream immediateResultStream = null;
+        if (dumpFile != null) {
+            try {
+                if (dumpFile.exists()) {
+                    immediateResultStream = new PrintStream(
+                            new FileOutputStream(dumpFile, true), true);
+                } else {
+                    immediateResultStream = new PrintStream(
+                            new FileOutputStream(dumpFile), true);
+                }
+            } catch (Exception ex) {
+                throw new RuntimeException(
+                        "Unable to open immediate result file: " + dumpFile, ex);
+            }
+        }
+        //File for output predictions
+        File outputPredictionFile = this.outputPredictionFileOption.getFile();
+        PrintStream outputPredictionResultStream = null;
+        if (outputPredictionFile != null) {
+            try {
+                if (outputPredictionFile.exists()) {
+                    outputPredictionResultStream = new PrintStream(
+                            new FileOutputStream(outputPredictionFile, true), true);
+                } else {
+                    outputPredictionResultStream = new PrintStream(
+                            new FileOutputStream(outputPredictionFile), true);
+                }
+            } catch (Exception ex) {
+                throw new RuntimeException(
+                        "Unable to open prediction result file: " + outputPredictionFile, ex);
+            }
+        }
+        boolean firstDump = true;
+        boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
+        long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+        long lastEvaluateStartTime = evaluateStartTime;
+        double RAMHours = 0.0;
+        while (stream.hasMoreInstances()
+                && ((maxInstances < 0) || (instancesProcessed < maxInstances))
+                && ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
+            Example trainInst = stream.nextInstance();
+            Example testInst = (Example) trainInst; //.copy();
+            //testInst.setClassMissing();
+            //double[] prediction = learner.getVotesForInstance(testInst);
+            Prediction prediction = learner.getPredictionForInstance(testInst);
+            // Output prediction
+            if (outputPredictionFile != null) {
+            	StringBuilder sb = new StringBuilder();
+            	for (int i = 0; i < ((Instance) trainInst.getData()).numOutputAttributes(); i++) {
+            		sb.append("Out " + i + ": " + ((Instance) trainInst.getData()).valueOutputAttribute(i) + " ");
+            	}
+                outputPredictionResultStream.println(prediction + "," + sb.toString());
+            }
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 
 			//evaluator.addClassificationAttempt(trueClass, prediction, testInst.weight());
 			evaluator.addResult(testInst, prediction);

From 562350e5b38ba1128c52425fe49aedb69af80d71 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Fri, 13 Nov 2015 13:57:24 +0100
Subject: [PATCH 10/33] Updates with the new versions of the algorithms (some
 code is imported from the 2015.10 prerelease version, so the pom files were
 updated back to the 2014.04 version)

---
 Release.key                                   |   19 +
 moa/pom.xml                                   |    2 +-
 .../samoa/instances/MultiLabelPrediction.java |    4 -
 .../NumericAttributeBinaryTest.java           |    4 -
 .../LocalMultiTargetClassifier.java           |   34 +-
 .../AttributeStatisticsObserver.java          |    6 +-
 .../MultiLabelBSTree.java                     |    6 +-
 .../MultiLabelNominalAttributeObserver.java   |    6 +-
 .../NominalStatisticsObserver.java            |    3 +-
 .../NumericStatisticsObserver.java            |    3 +-
 .../splitcriteria/ICVarianceReduction.java    |    1 -
 .../MultiLabelSplitCriterion.java             |    2 +-
 .../classifiers/multilabel/meta/MTOzaBag.java |    3 -
 .../multilabel/trees/ISOUPOptionTree.java     |   15 +-
 .../multilabel/trees/ISOUPTree.java           | 1010 ++++----------
 .../core/AttributeExpansionSuggestion.java    |    3 +-
 .../multilabel/AMRulesMultiLabelLearner.java  |    6 +-
 .../AMRulesMultiTargetRegressor.java          |    2 +-
 .../multilabel/core/LearningLiteral.java      |   10 +-
 .../core/LearningLiteralRegression.java       |    9 +-
 .../rules/multilabel/core/MultiLabelRule.java |    6 +-
 .../MultiTargetVarianceRatio.java             |    1 +
 .../java/moa/classifiers/trees/FIMTDD.java    | 1156 ++---------------
 .../main/java/moa/classifiers/trees/ORTO.java |  113 +-
 .../tasks/EvaluatePrequentialMultiTarget.java |   59 +-
 pom.xml                                       |    2 +-
 weka-package/pom.xml                          |    2 +-
 27 files changed, 422 insertions(+), 2065 deletions(-)
 create mode 100644 Release.key
 rename moa/src/main/java/moa/classifiers/{rules/multilabel => multilabel/core}/attributeclassobservers/AttributeStatisticsObserver.java (90%)
 rename moa/src/main/java/moa/classifiers/{rules/multilabel => multilabel/core}/attributeclassobservers/MultiLabelBSTree.java (96%)
 rename moa/src/main/java/moa/classifiers/{rules/multilabel => multilabel/core}/attributeclassobservers/MultiLabelNominalAttributeObserver.java (93%)
 rename moa/src/main/java/moa/classifiers/{rules/multilabel => multilabel/core}/attributeclassobservers/NominalStatisticsObserver.java (56%)
 rename moa/src/main/java/moa/classifiers/{rules/multilabel => multilabel/core}/attributeclassobservers/NumericStatisticsObserver.java (56%)
 rename moa/src/main/java/moa/classifiers/{rules => }/multilabel/core/splitcriteria/MultiLabelSplitCriterion.java (85%)
 rename moa/src/main/java/moa/classifiers/rules/{multilabel => }/core/AttributeExpansionSuggestion.java (95%)

diff --git a/Release.key b/Release.key
new file mode 100644
index 000000000..549e44194
--- /dev/null
+++ b/Release.key
@@ -0,0 +1,19 @@
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+Version: GnuPG v1.4.5 (GNU/Linux)
+
+mQGiBE8ySNwRBACKcsg4AceGW7vuOSywcGiiNZg4I8vIzn7zphgj+s6/i2/hs8TQ
+TOHy1s3b0f32ani3sBRmTWtgNv8+HSaKSVUcNqqNL+Jy6Pulyao7amGTtvqVKmuz
+6ADrbVz0SxWmzTlSctdxK3g3yRSb+vfYrBPrbXNCNB5g9C/uK1uh0fpj1wCgn3MX
+GFlZsO3bF7SNqqYlzpV6DM0D/AjnBlxTwRJOA1sLAVSXipLOdkjo00OQ8jgOFDio
+oJsqLtsscNGocPCqNRo6QSVQKNs5sfYP2GXWTnPVM5oJI1p6bjuADRE8mneJrJvF
+Uc+Mt1MdS6ttF4tVqd5Ncc8LKYQJRn+AtiuxAAayAA35JOslnMM0bqSYMlw4BJTP
+8TlPA/4r+k+ucz3cJtM2aaL/ngUdrhmGKfGK7npXA3Ic6FzQo2NlJyKfWjSsR8x+
+oN7tKEpuYxE5fcdbWd3v+4Ypx0LYMgBT1pUgI09AXxrx1cLRZI4yovrvQJgiA4Mh
+CZ0eFkJJ1nwQR3NPMj5soar+7d3Ubc2EqkESGm0CgGtjgg+7HrQ6aXN2Om93bkNs
+b3VkIE9CUyBQcm9qZWN0IDxpc3Y6b3duQ2xvdWRAYnVpbGQub3BlbnN1c2Uub3Jn
+PohmBBMRAgAmBQJU2MJUAhsDBQkJxSl4BgsJCAcDAgQVAggDBBYCAwECHgECF4AA
+CgkQl3xDqLpoQiMpOQCggCpaq5yz8C3ckqEr0RkTjICcQYMAnRvjarxoY6iSThDN
+7vgxE1Fe8X5EiEYEExECAAYFAk8ySNwACgkQOzARt2udZSPlpwCfQZKNN8Rxx0LE
+BF32EYXBdEvkMYYAoIt3lfXL8uwmjvyljzb0JgBQN1cF
+=FJ6Q
+-----END PGP PUBLIC KEY BLOCK-----
diff --git a/moa/pom.xml b/moa/pom.xml
index dd44c7979..ec5e36169 100755
--- a/moa/pom.xml
+++ b/moa/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <groupId>nz.ac.waikato.cms.moa</groupId>
     <artifactId>moa-pom</artifactId>
-    <version>2015.05-SNAPSHOT</version>
+    <version>2014.04</version>
   </parent>
 
   <artifactId>moa</artifactId>
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
index 838f90c7b..7e821ce9f 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
@@ -28,10 +28,6 @@ public MultiLabelPrediction(int numOutputAttributes) {
 		for (int i=0; i<numOutputAttributes;i++)
 			prediction[i]= new DoubleVector();
 	}
-
-	public MultiLabelPrediction(DoubleVector[] prediction) {
-		this.prediction = prediction;
-	}
 	
 	public MultiLabelPrediction(DoubleVector[] prediction) {
 		this.prediction = prediction;
diff --git a/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java b/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
index d60ee3af2..fd7f27b19 100644
--- a/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
+++ b/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
@@ -52,11 +52,7 @@ public int branchForInstance(Instance inst) {
         if (inst.isMissing(instAttIndex)) {
             return -1;
         }
-<<<<<<< HEAD
-        double v = inst.valueInputAttribute(instAttIndex);
-=======
         double v = inst.valueInputAttribute(instAttIndex); // if the attIndex is not calculated above this is the correct method call
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
         if (v == this.attValue) {
             return this.equalsPassesTest ? 0 : 1;
         }
diff --git a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
index 38c82f7e9..5fce8915c 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
@@ -1,12 +1,7 @@
 package moa.classifiers.multilabel;
 
-<<<<<<< HEAD
 import java.util.ArrayList;
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
-import java.util.LinkedList;
 import java.util.List;
-import java.util.Vector;
 
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
@@ -21,11 +16,7 @@
 import moa.classifiers.Classifier;
 import moa.classifiers.MultiLabelClassifier;
 import moa.classifiers.MultiTargetRegressor;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.classifiers.trees.FIMTDD;
-import moa.core.DoubleVector;
 import moa.core.Measurement;
-import moa.learners.Learner;
 import moa.options.ClassOption;
 
 public class LocalMultiTargetClassifier extends AbstractMultiLabelLearner
@@ -38,17 +29,11 @@ public class LocalMultiTargetClassifier extends AbstractMultiLabelLearner
 			Classifier.class,
 			"moa.classifiers.trees.FIMTDD");
 	
-<<<<<<< HEAD
 	ArrayList<Classifier> classifiers = null;
 	ArrayList<InstancesHeader> headers = null;
-=======
-	LinkedList<Classifier> classifiers = null;
-	LinkedList<InstancesHeader> headers = null;
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 	
 	@Override
 	public boolean isRandomizable() {
-		// TODO Auto-generated method stub
 		return true;
 	}
 
@@ -61,14 +46,10 @@ private InstancesHeader getHeader(int target) {
 	
 	private void makeHeaders() {
 		if (headers == null) {
-<<<<<<< HEAD
 			headers = new ArrayList<InstancesHeader>();
-=======
-			headers = new LinkedList<InstancesHeader>();
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 			for (int target = 0; target < getModelContext().numOutputAttributes(); target++) {
-				List<Attribute> attributes = new LinkedList<Attribute>();
-				List<Integer> indexValues = new LinkedList<Integer>();
+				List<Attribute> attributes = new ArrayList<Attribute>();
+				List<Integer> indexValues = new ArrayList<Integer>();
 				for (int i = 0; i < getModelContext().numInputAttributes(); i++) {
 					attributes.add(getModelContext().inputAttribute(i));
 					indexValues.add(i);
@@ -95,7 +76,6 @@ private Instance getSTInstance(MultiLabelInstance inst, int target) {
 	
 	@Override
 	public void trainOnInstanceImpl(MultiLabelInstance instance) {
-		// TODO Auto-generated method stub
 		initializeClassifiers();
 		
 		for (int j = 0; j < instance.numberOutputTargets(); j++) {
@@ -112,10 +92,6 @@ public Prediction getPredictionForInstance(MultiLabelInstance inst) {
 		MultiLabelPrediction prediction = new MultiLabelPrediction(getModelContext().numOutputAttributes());
 		for (int j = 0; j < inst.numberOutputTargets(); j++) {
 			Instance STInst = getSTInstance(inst, j);
-<<<<<<< HEAD
-=======
-			
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 			prediction.setVote(j, 1, classifiers.get(j).getVotesForInstance(STInst)[0]);
 		}
 		return prediction;
@@ -131,15 +107,9 @@ public void initializeClassifiers() {
 		this.classifierRandom.setSeed(1234);
 		if (classifiers == null) {
 			makeHeaders();
-<<<<<<< HEAD
 			classifiers = new ArrayList<Classifier>();
 			for (int i = 0; i < getModelContext().numOutputAttributes(); i++) {
 				Classifier learner = ((Classifier) getPreparedClassOption(this.classifierOption)).copy();
-=======
-			classifiers = new LinkedList<Classifier>();
-			for (int i = 0; i < getModelContext().numOutputAttributes(); i++) {
-				Classifier learner = (Classifier) getPreparedClassOption(this.classifierOption);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				classifiers.add(learner);
 				learner.resetLearning();
 				((AbstractClassifier) learner).classifierRandom = this.classifierRandom;
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/AttributeStatisticsObserver.java b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/AttributeStatisticsObserver.java
similarity index 90%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/AttributeStatisticsObserver.java
rename to moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/AttributeStatisticsObserver.java
index e760469e8..34be2f026 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/AttributeStatisticsObserver.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/AttributeStatisticsObserver.java
@@ -17,10 +17,10 @@
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
  *    
  */
-package moa.classifiers.rules.multilabel.attributeclassobservers;
+package moa.classifiers.multilabel.core.attributeclassobservers;
 
-import moa.classifiers.rules.multilabel.core.AttributeExpansionSuggestion;
-import moa.classifiers.rules.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.classifiers.rules.core.AttributeExpansionSuggestion;
 import moa.core.DoubleVector;
 import moa.options.OptionHandler;
 
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/MultiLabelBSTree.java b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelBSTree.java
similarity index 96%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/MultiLabelBSTree.java
rename to moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelBSTree.java
index 9058f9479..58fd92faa 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/MultiLabelBSTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelBSTree.java
@@ -1,13 +1,13 @@
-package moa.classifiers.rules.multilabel.attributeclassobservers;
+package moa.classifiers.multilabel.core.attributeclassobservers;
 
 import java.io.Serializable;
 
 import com.github.javacliparser.IntOption;
 
+import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.classifiers.rules.core.AttributeExpansionSuggestion;
 import moa.classifiers.rules.core.NumericRulePredicate;
 import moa.classifiers.rules.core.Utils;
-import moa.classifiers.rules.multilabel.core.AttributeExpansionSuggestion;
-import moa.classifiers.rules.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.core.DoubleVector;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/MultiLabelNominalAttributeObserver.java b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelNominalAttributeObserver.java
similarity index 93%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/MultiLabelNominalAttributeObserver.java
rename to moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelNominalAttributeObserver.java
index 969f28576..2495b158f 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/MultiLabelNominalAttributeObserver.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelNominalAttributeObserver.java
@@ -1,13 +1,13 @@
-package moa.classifiers.rules.multilabel.attributeclassobservers;
+package moa.classifiers.multilabel.core.attributeclassobservers;
 
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map.Entry;
 
+import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.classifiers.rules.core.AttributeExpansionSuggestion;
 import moa.classifiers.rules.core.NominalRulePredicate;
 import moa.classifiers.rules.core.Utils;
-import moa.classifiers.rules.multilabel.core.AttributeExpansionSuggestion;
-import moa.classifiers.rules.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.core.DoubleVector;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/NominalStatisticsObserver.java b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/NominalStatisticsObserver.java
similarity index 56%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/NominalStatisticsObserver.java
rename to moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/NominalStatisticsObserver.java
index 64ce01864..e52a0cb42 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/NominalStatisticsObserver.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/NominalStatisticsObserver.java
@@ -1,4 +1,5 @@
-package moa.classifiers.rules.multilabel.attributeclassobservers;
+package moa.classifiers.multilabel.core.attributeclassobservers;
+
 
 
 public interface NominalStatisticsObserver extends AttributeStatisticsObserver {
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/NumericStatisticsObserver.java b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/NumericStatisticsObserver.java
similarity index 56%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/NumericStatisticsObserver.java
rename to moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/NumericStatisticsObserver.java
index 5914dbb15..b899ce1dc 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/NumericStatisticsObserver.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/NumericStatisticsObserver.java
@@ -1,4 +1,5 @@
-package moa.classifiers.rules.multilabel.attributeclassobservers;
+package moa.classifiers.multilabel.core.attributeclassobservers;
+
 
 
 public interface NumericStatisticsObserver extends AttributeStatisticsObserver {
diff --git a/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java b/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java
index c3f2299d2..176f3dfd0 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java
@@ -5,7 +5,6 @@
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.tasks.TaskMonitor;
-import moa.classifiers.rules.multilabel.core.splitcriteria.MultiLabelSplitCriterion;;
 
 
 
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/splitcriteria/MultiLabelSplitCriterion.java b/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/MultiLabelSplitCriterion.java
similarity index 85%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/core/splitcriteria/MultiLabelSplitCriterion.java
rename to moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/MultiLabelSplitCriterion.java
index 099748611..cc9247039 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/splitcriteria/MultiLabelSplitCriterion.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/MultiLabelSplitCriterion.java
@@ -1,4 +1,4 @@
-package moa.classifiers.rules.multilabel.core.splitcriteria;
+package moa.classifiers.multilabel.core.splitcriteria;
 
 
 import moa.core.DoubleVector;
diff --git a/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java b/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
index a4c64a809..2594f61be 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
@@ -93,7 +93,6 @@ public Prediction getPredictionForInstance(MultiLabelInstance inst) {
 		}
 		return new MultiLabelPrediction(prediction);
 	}
-<<<<<<< HEAD
 	
 	public Prediction getPredictionForInstanceUsingN(MultiLabelInstance inst, int n) {
 		int actual = Math.max(1, Math.min(n, this.ensemble.length));
@@ -112,8 +111,6 @@ public Prediction getPredictionForInstanceUsingN(MultiLabelInstance inst, int n)
 		}
 		return new MultiLabelPrediction(prediction);
 	}
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 
     @Override
     public void trainOnInstanceImpl(MultiLabelInstance instance) {
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java
index 93de284a0..a0ce07563 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java
@@ -3,15 +3,7 @@
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.MultiLabelInstance;
-
-import moa.classifiers.multilabel.trees.ISOUPTree.LeafNode;
-import moa.classifiers.multilabel.trees.ISOUPTree.Node;
-import moa.classifiers.multilabel.trees.ISOUPTree.SplitNode;
-import moa.classifiers.trees.ORTO;
-import moa.classifiers.trees.FIMTDD.InnerNode;
-import moa.classifiers.trees.ORTO.OptionNode;
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
@@ -20,7 +12,6 @@ public class ISOUPOptionTree extends ISOUPTree {
 
 	private static final long serialVersionUID = 1L;
 
-	private int innerNodeCount = 0;
 	private int optionNodeCount = 0;
 
 	private int numTrees = 1;
@@ -62,6 +53,11 @@ public class ISOUPOptionTree extends ISOUPTree {
 	//region ================ CLASSES ================
 	
 	public static class OptionNode extends InnerNode {
+		/**
+		 * 
+		 */
+		private static final long serialVersionUID = 1L;
+		
 		protected AutoExpandVector<DoubleVector> optionFFSSL;
 		protected AutoExpandVector<DoubleVector> optionFFSeen;
 		
@@ -152,7 +148,6 @@ public String getPurposeString() {
 
 	public void resetLearningImpl() {
 		super.resetLearningImpl();
-		this.innerNodeCount = 0;
 		this.optionNodeCount = 0;
 	}
 
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
index 592a0c5c6..3596120c3 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
@@ -41,15 +41,15 @@
 import moa.AbstractMOAObject;
 import moa.classifiers.AbstractMultiLabelLearner;
 import moa.classifiers.MultiTargetRegressor;
+import moa.classifiers.multilabel.core.attributeclassobservers.AttributeStatisticsObserver;
+import moa.classifiers.multilabel.core.attributeclassobservers.MultiLabelBSTree;
+import moa.classifiers.multilabel.core.attributeclassobservers.MultiLabelNominalAttributeObserver;
+import moa.classifiers.multilabel.core.attributeclassobservers.NominalStatisticsObserver;
+import moa.classifiers.multilabel.core.attributeclassobservers.NumericStatisticsObserver;
 import moa.classifiers.multilabel.core.splitcriteria.ICVarianceReduction;
+import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.classifiers.rules.core.AttributeExpansionSuggestion;
 import moa.classifiers.rules.core.Predicate;
-import moa.classifiers.rules.multilabel.attributeclassobservers.AttributeStatisticsObserver;
-import moa.classifiers.rules.multilabel.attributeclassobservers.MultiLabelBSTree;
-import moa.classifiers.rules.multilabel.attributeclassobservers.MultiLabelNominalAttributeObserver;
-import moa.classifiers.rules.multilabel.attributeclassobservers.NominalStatisticsObserver;
-import moa.classifiers.rules.multilabel.attributeclassobservers.NumericStatisticsObserver;
-import moa.classifiers.rules.multilabel.core.AttributeExpansionSuggestion;
-import moa.classifiers.rules.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
@@ -66,14 +66,7 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 
 	private static final long serialVersionUID = 1L;
 
-<<<<<<< HEAD
 	public Node treeRoot;
-=======
-	protected Node treeRoot;
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
-
-	private int leafNodeCount = 0;
-	private int splitNodeCount = 0;
 
 	private double examplesSeen = 0.0;
 	private DoubleVector sumOfValues = new DoubleVector();
@@ -86,17 +79,6 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 
 	//region ================ OPTIONS ================
 
-<<<<<<< HEAD
-	//	public ClassOption splitCriterionOption = new ClassOption(
-	//			"splitCriterion",
-	//			's',
-	//			"Split criterion to use.",
-	//			SplitCriterion.class,
-	//			"moa.classifiers.core.splitcriteria.VarianceReductionSplitCriterion");
-	// TODO not used at the moment, consider later when the implementation catches up	
-
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 	public IntOption gracePeriodOption = new IntOption(
 			"gracePeriod",
 			'g',
@@ -115,7 +97,6 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 			"Threshold below which a split will be forced to break ties.",
 			0.05, 0.0, 1.0);
 
-<<<<<<< HEAD
 	public FloatOption PageHinckleyAlphaOption = new FloatOption(
 			"PageHinckleyAlpha",
 			'a',
@@ -127,19 +108,6 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 			'h',
 			"The threshold value to be used in the Page Hinckley change detection tests.",
 			50, 0, Integer.MAX_VALUE);
-=======
-//	public FloatOption PageHinckleyAlphaOption = new FloatOption(
-//			"PageHinckleyAlpha",
-//			'a',
-//			"The alpha value to use in the Page Hinckley change detection tests.",
-//			0.005, 0.0, 1.0);
-//
-//	public IntOption PageHinckleyThresholdOption = new IntOption(
-//			"PageHinckleyThreshold",
-//			'h',
-//			"The threshold value to be used in the Page Hinckley change detection tests.",
-//			50, 0, Integer.MAX_VALUE);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 
 	public FloatOption alternateTreeFadingFactorOption = new FloatOption(
 			"alternateTreeFadingFactor",
@@ -185,15 +153,6 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 			"doNotNormalize",
 			'n',
 			"Don't normalize.");
-<<<<<<< HEAD
-	
-	public FlagOption printLogsOption = new FlagOption(
-			"printLogs",
-			'z',
-			"Print logs.");
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
-
 
 	//endregion ================ OPTIONS ================
 
@@ -342,17 +301,11 @@ public LeafNode(ISOUPTree tree) {
 		 */
 		public void learnFromInstance(MultiLabelInstance inst, double[] prediction, boolean growthAllowed) {
 			// Update the statistics for this node
-<<<<<<< HEAD
-			// number of instances passing through the node
-			double[] predictionP = tree.buildingModelTree() ? getPredictionModel(inst) : null;
-			double[] predictionM = getPredictionTargetMean(inst);
 
-=======
 			double[] predictionP = tree.buildingModelTree() ? getPredictionModel(inst) : null;
 			double[] predictionM = getPredictionTargetMean(inst);
 
 			// number of instances passing through the node
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 			examplesSeen += inst.weight();
 
 			for (int i = 0; i < tree.getModelContext().numOutputAttributes(); i++) {
@@ -367,10 +320,7 @@ public void learnFromInstance(MultiLabelInstance inst, double[] prediction, bool
 					errorM.setValue(i, errorM.getValue(i) * 0.95 + Math.abs(predictionM[i] - inst.valueOutputAttribute(i)));
 				}
 			}
-<<<<<<< HEAD
-			
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+
 			if (tree.buildingModelTree()) learningModel.updatePerceptron(inst);
 
 			for (int i = 0; i < inst.numInputAttributes(); i++) {
@@ -443,17 +393,11 @@ public double[] getPredictionModel(MultiLabelInstance inst) {
 
 		public double[] getPredictionTargetMean(MultiLabelInstance inst) {
 			double[] pred = new double[inst.numOutputAttributes()];
-<<<<<<< HEAD
 			for (int i = 0; i < inst.numOutputAttributes(); i++) {
 				if (examplesSeen > 0) {
 					pred[i] = sumOfValues.getValue(i) / examplesSeen;
 				} else {
 					pred[i] = 0;
-=======
-			if (examplesSeen > 0) {
-				for (int i = 0; i < inst.numOutputAttributes(); i++) {
-					pred[i] = sumOfValues.getValue(i) / examplesSeen;
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				}
 			}
 			return pred;
@@ -513,7 +457,7 @@ public static abstract class InnerNode extends Node {
 
 		// Sum of absolute errors
 		protected DoubleVector sumOfAbsErrors = new DoubleVector(); // Needed for PH tracking of mean error
-		
+
 		protected DoubleVector PHsums = new DoubleVector();
 		protected DoubleVector PHmins = new DoubleVector();
 
@@ -654,11 +598,7 @@ public class MultitargetPerceptron {
 		protected ISOUPTree tree;
 
 		// The Perception weights 
-<<<<<<< HEAD
 		public double[][] weights; 
-=======
-		protected double[][] weights; 
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 
 		// The number of instances contributing to this model
 		protected int instancesSeen = 0;
@@ -670,13 +610,6 @@ public String getPurposeString() {
 		public MultitargetPerceptron(ISOUPTree tree, MultitargetPerceptron original) {
 			this.tree = tree;
 			weights = original.weights.clone();
-<<<<<<< HEAD
-			// TODO check if this is necessary
-//			for (int i = 0; i < this.tree.getModelContext().numOutputAttributes(); i++) {
-//				weights[i] = (DoubleVector) original.weights[i].copy();
-//			}
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		}
 
 		public MultitargetPerceptron(ISOUPTree tree) {
@@ -696,10 +629,7 @@ public void initializeWeights() {
 					weights[i][j] = 2 * tree.classifierRandom.nextDouble() - 1;
 				}
 			}
-<<<<<<< HEAD
 			normalizeWeights();
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		}
 
 		/**
@@ -708,7 +638,7 @@ public void initializeWeights() {
 		public void updatePerceptron(MultiLabelInstance inst) {
 			// Update attribute statistics
 			instancesSeen += inst.weight();
-			
+
 			// Update weights
 			double learningRatio = 0.0;
 			if (tree.learningRatioConstOption.isSet()) {
@@ -727,7 +657,7 @@ public void updateWeights(MultiLabelInstance inst, double learningRatio) {
 			if (instancesSeen > 1.0) {
 				// Compute the normalized instance and the delta
 				double[] normalizedInput = tree.normalizedInputVector(inst); 
-			    double[] normalizedPrediction = prediction(normalizedInput);
+				double[] normalizedPrediction = prediction(normalizedInput);
 
 				double[] normalizedTarget = tree.normalizedTargetVector(inst);
 				for (int i = 0; i < inst.numOutputAttributes(); i++){
@@ -750,10 +680,6 @@ public void normalizeWeights() {
 			}
 		}
 
-<<<<<<< HEAD
-		
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		/**
 		 * Output the prediction made by this perceptron on the given instance
 		 */
@@ -792,372 +718,22 @@ private double[] denormalizePrediction(double[] normalizedPrediction) {
 		public void getModelDescription(StringBuilder out, int indent) {
 			for (int i = 0; i < tree.getModelContext().numOutputAttributes(); i++) {
 				StringUtils.appendIndented(out, indent, " [" + tree.getModelContext().outputAttribute(i).name() + "]");
-<<<<<<< HEAD
-				//if (getModelContext() != null) {
-				//for (int j = 0; j < getModelContext().numAttributes() - 1; j++) {
-				//					if (getModelContext().attribute(j).isNumeric()) {
-				//						// TODO
-				//						//out.append((j == 0 || weightAttribute.getValue(j) < 0) ? " " : " + ");
-				//						//out.append(String.format("%.4f", weightAttribute.getValue(j)));
-				//						out.append(" * ");
-				//						out.append(getAttributeNameString(j));
-				//					}
-				//}
-				//out.append(" + " + weightAttribute.getValue((getModelContext().numAttributes() - 1)));
-				//}
-			}
-			StringUtils.appendNewline(out);
-		}
-	}
-
-	//	public class SOPNumericAttributeClassObserver implements MultitargetAttributeClassObserver {
-	//
-	//		private static final long serialVersionUID = 1L;
-	//
-	//		protected class Node implements Serializable {
-	//
-	//			private static final long serialVersionUID = 1L;
-	//
-	//			// The split point to use
-	//			public double cut_point;
-	//
-	//			// E-BST statistics
-	//			public double leftCount = 0;
-	//			public double rightCount = 0;
-	//			public DoubleVector leftSums = new DoubleVector();
-	//			public DoubleVector leftSquares = new DoubleVector();
-	//			public DoubleVector rightSums = new DoubleVector();
-	//			public DoubleVector rightSquares = new DoubleVector();
-	//
-	//			// Child nodes
-	//			public Node left;
-	//			public Node right;
-	//
-	//			public Node(double val, DoubleVector labelVector, double weight) {
-	//				cut_point = val;
-	//				leftCount += 1;
-	//				for (int i = 0; i < labelVector.numValues(); i++) {
-	//					leftSums.addToValue(i, labelVector.getValue(i));
-	//					leftSquares.addToValue(i, labelVector.getValue(i) * labelVector.getValue(i));
-	//				}
-	//			}
-	//
-	//			/**
-	//			 * Insert a new value into the tree, updating both the sum of values and
-	//			 * sum of squared values arrays
-	//			 */
-	//			public void insertValue(double val, DoubleVector labelVector, double weight) {
-	//
-	//				// If the new value equals the value stored in a node, update
-	//				// the left (<=) node information
-	//				if (val == cut_point) {
-	//					leftCount += 1;
-	//					for (int i = 0; i < labelVector.numValues(); i++) {
-	//						leftSums.addToValue(i, labelVector.getValue(i));
-	//						leftSquares.addToValue(i, labelVector.getValue(i) * labelVector.getValue(i));
-	//					}
-	//				} // If the new value is less than the value in a node, update the
-	//				// left distribution and send the value down to the left child node.
-	//				// If no left child exists, create one
-	//				else if (val <= cut_point) {
-	//
-	//					leftCount += 1;
-	//					for (int i = 0; i < labelVector.numValues(); i++) {
-	//						leftSums.addToValue(i, labelVector.getValue(i));
-	//						leftSquares.addToValue(i, labelVector.getValue(i) * labelVector.getValue(i));
-	//					}
-	//					if (left == null) {
-	//						left = new Node(val, labelVector, weight);
-	//					} else {
-	//						left.insertValue(val, labelVector, weight);
-	//					}
-	//				} // If the new value is greater than the value in a node, update the
-	//				// right (>) distribution and send the value down to the right child node.
-	//				// If no right child exists, create one
-	//				else { // val > cut_point
-	//					rightCount += 1;
-	//					for (int i = 0; i < labelVector.numValues(); i++) {
-	//						rightSums.addToValue(i, labelVector.getValue(i));
-	//						rightSquares.addToValue(i, labelVector.getValue(i) * labelVector.getValue(i));
-	//					}
-	//					if (right == null) {
-	//						right = new Node(val, labelVector, weight);
-	//					} else {
-	//						right.insertValue(val, labelVector, weight);
-	//					}
-	//				}
-	//			}
-	//		}
-	//
-	//		// Root node of the E-BST structure for this attribute
-	//		protected Node root = null;
-	//
-	//		// Global variables for use in the FindBestSplit algorithm
-	//		DoubleVector sumsTotalLeft;
-	//		DoubleVector sumsTotalRight;
-	//		DoubleVector squaresTotalLeft;
-	//		DoubleVector squaresTotalRight;
-	//		double countRightTotal;
-	//		double countLeftTotal;
-	//
-	//		public void observeAttributeClass(double attVal, double classVal, double weight) {
-	//			// DEPRECATED (used for single-target cases)
-	//
-	//			//	        if (Double.isNaN(attVal)) { //Instance.isMissingValue(attVal)
-	//			//	        } else {
-	//			//	            if (root == null) {
-	//			//	                root = new Node(attVal, classVal, weight);
-	//			//	            } else {
-	//			//	                root.insertValue(attVal, classVal, weight);
-	//			//	            }
-	//			//	        }
-	//		}
-	//
-	//		public void observeAttributeClass(double attVal, DoubleVector classVector, double weight) {
-	//			if (Double.isNaN(attVal)) { //Instance.isMissingValue(attVal)
-	//			} else {
-	//				if (root == null) {
-	//					root = new Node(attVal, classVector, weight);
-	//				} else {
-	//					root.insertValue(attVal, classVector, weight);
-	//				}
-	//			}
-	//
-	//		}
-	//
-	//		public double probabilityOfAttributeValueGivenClass(double attVal, int classVal) {
-	//			// TODO: NaiveBayes broken until implemented
-	//			return 0.0;
-	//		}
-	//
-	//		@Override
-	//		public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(SplitCriterion criterion, double examlpesSeen, DoubleVector preSplitSums, DoubleVector preSplitSquares, int numTargets, int attIndex, boolean binaryOnly) {
-	//			// Initialise global variables
-	//			sumsTotalLeft = new DoubleVector();
-	//			sumsTotalRight = preSplitSums;
-	//			squaresTotalLeft = new DoubleVector();
-	//			squaresTotalRight = preSplitSquares;
-	//			countLeftTotal = 0;
-	//			countRightTotal = examplesSeen;
-	//
-	//			// Hardcoded for ICV reduction
-	//			double preSplitVariance = 0;
-	//			for (int i = 0; i < numTargets; i++) {
-	//				preSplitVariance += (preSplitSquares.getValue(i) - examplesSeen * preSplitSums.getValue(i) * preSplitSums.getValue(i)) / examplesSeen;
-	//			}
-	//
-	//			return searchForBestSplitOption(root, null, preSplitVariance, attIndex, numTargets);
-	//		}
-	//
-	//		public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(SplitCriterion criterion, double[] preSplitDist, int attIndex, boolean binaryOnly) {
-	//			// DEPRECATED
-	//			return null;
-	//		}
-	//
-	//		/**
-	//		 * Implementation of the FindBestSplit algorithm from E.Ikonomovska et al.
-	//		 */
-	//		protected AttributeSplitSuggestion searchForBestSplitOption(Node currentNode, AttributeSplitSuggestion currentBestOption, double preSplitVariance, int attIndex, int numTargets) {
-	//			// Return null if the current node is null or we have finished looking through all the possible splits
-	//			if (currentNode == null || countRightTotal == 0.0) {
-	//				return currentBestOption;
-	//			}
-	//
-	//			if (currentNode.left != null) {
-	//				currentBestOption = searchForBestSplitOption(currentNode.left, currentBestOption, preSplitVariance, attIndex, numTargets);
-	//			}
-	//
-	//			sumsTotalLeft.addValues(currentNode.leftSums);
-	//			sumsTotalRight.subtractValues(currentNode.leftSums);
-	//			squaresTotalLeft.addValues(currentNode.leftSquares);
-	//			squaresTotalRight.subtractValues(currentNode.leftSquares);
-	//			countLeftTotal += currentNode.leftCount;
-	//			countRightTotal -= currentNode.leftCount;
-	//
-	//			//	        double[][] postSplitDists = new double[][]{{countLeftTotal, sumTotalLeft, sumSqTotalLeft}, {countRightTotal, sumTotalRight, sumSqTotalRight}};
-	//			//	        double[] preSplitDist = new double[]{(countLeftTotal + countRightTotal), (sumTotalLeft + sumTotalRight), (sumSqTotalLeft + sumSqTotalRight)};
-	//			//	        double merit = criterion.getMeritOfSplit(preSplitDist, postSplitDists);
-	//
-	//			double postSplitVariance = 0;
-	//			for (int i = 0; i < numTargets; i++) {
-	//				postSplitVariance += (squaresTotalLeft.getValue(i) - examplesSeen * sumsTotalLeft.getValue(i) * sumsTotalLeft.getValue(i)) / countLeftTotal;
-	//				postSplitVariance += (squaresTotalRight.getValue(i) - examplesSeen * sumsTotalRight.getValue(i) * sumsTotalRight.getValue(i)) / countRightTotal;
-	//			}
-	//
-	//			double merit = preSplitVariance - postSplitVariance;
-	//
-	//			if ((currentBestOption == null) || (merit > currentBestOption.merit)) {
-	//				currentBestOption = new AttributeSplitSuggestion(
-	//						new NumericAttributeBinaryTest(attIndex,
-	//								currentNode.cut_point, true), new double[0][0], merit);
-	//
-	//			}
-	//
-	//			if (currentNode.right != null) {
-	//				currentBestOption = searchForBestSplitOption(currentNode.right, currentBestOption, preSplitVariance, attIndex, numTargets);
-	//			}
-	//
-	//			sumsTotalLeft.subtractValues(currentNode.leftSums);
-	//			sumsTotalRight.addValues(currentNode.leftSums);
-	//			squaresTotalLeft.subtractValues(currentNode.leftSquares);
-	//			squaresTotalRight.addValues(currentNode.leftSquares);
-	//			countLeftTotal -= currentNode.leftCount;
-	//			countRightTotal += currentNode.leftCount;
-	//
-	//			return currentBestOption;
-	//		}
-	//
-	//		/**
-	//		 * A method to remove all nodes in the E-BST in which it and all it's
-	//		 * children represent 'bad' split points
-	//		 */
-	//		public void removeBadSplits(SplitCriterion criterion, double lastCheckRatio, double lastCheckSDR, double lastCheckE, int numTargets) {
-	//			removeBadSplitNodes(criterion, root, lastCheckRatio, lastCheckSDR, lastCheckE, numTargets);
-	//		}
-	//
-	//		/**
-	//		 * Recursive method that first checks all of a node's children before
-	//		 * deciding if it is 'bad' and may be removed
-	//		 */
-	//		private boolean removeBadSplitNodes(SplitCriterion criterion, Node currentNode, double lastCheckRatio, double lastCheckSDR, double lastCheckE, int numTargets) {
-	//			boolean isBad = false;
-	//
-	//			if (currentNode == null) {
-	//				return true;
-	//			}
-	//
-	//			if (currentNode.left != null) {
-	//				isBad = removeBadSplitNodes(criterion, currentNode.left, lastCheckRatio, lastCheckSDR, lastCheckE, numTargets);
-	//			}
-	//
-	//			if (currentNode.right != null && isBad) {
-	//				isBad = removeBadSplitNodes(criterion, currentNode.left, lastCheckRatio, lastCheckSDR, lastCheckE, numTargets);
-	//			}
-	//
-	//			if (isBad) {
-	//
-	//				double preSplitVariance = 0;
-	//				for (int i = 0; i < numTargets; i++) {
-	//					preSplitVariance += (currentNode.leftSquares.getValue(i) + currentNode.rightSquares.getValue(i) - examplesSeen * 
-	//							(currentNode.leftSums.getValue(i) + currentNode.rightSums.getValue(i)) * (currentNode.leftSums.getValue(i) + currentNode.rightSums.getValue(i))) / examplesSeen;
-	//				}
-	//
-	//				double postSplitVariance = 0;
-	//				for (int i = 0; i < numTargets; i++) {
-	//					postSplitVariance += (currentNode.leftSquares.getValue(i) - currentNode.leftCount * currentNode.leftSums.getValue(i) * currentNode.leftSums.getValue(i)) / currentNode.leftCount;
-	//					postSplitVariance += (currentNode.rightSquares.getValue(i) - currentNode.rightCount * currentNode.rightSums.getValue(i) * currentNode.rightSums.getValue(i)) / currentNode.rightCount;
-	//				}
-	//
-	//
-	//				//	            double[][] postSplitDists = new double[][]{{currentNode.leftStatistics.getValue(0), currentNode.leftStatistics.getValue(1), currentNode.leftStatistics.getValue(2)}, {currentNode.rightStatistics.getValue(0), currentNode.rightStatistics.getValue(1), currentNode.rightStatistics.getValue(2)}};
-	//				//	            double[] preSplitDist = new double[]{(currentNode.leftStatistics.getValue(0) + currentNode.rightStatistics.getValue(0)), (currentNode.leftStatistics.getValue(1) + currentNode.rightStatistics.getValue(1)), (currentNode.leftStatistics.getValue(2) + currentNode.rightStatistics.getValue(2))};
-	//				//	            double merit = criterion.getMeritOfSplit(preSplitDist, postSplitDists);
-	//				double merit = preSplitVariance - postSplitVariance;
-	//
-	//				if ((merit / lastCheckSDR) < (lastCheckRatio - (2 * lastCheckE))) {
-	//					currentNode = null;
-	//					return true;
-	//				}
-	//			}
-	//
-	//			return false;
-	//		}
-	//
-	//		@Override
-	//		public void getDescription(StringBuilder sb, int indent) {
-	//			// TODO Auto-generated method stub
-	//		}
-	//
-	//		protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-	//			// TODO Auto-generated method stub
-	//		}
-	//
-	//		@Override
-	//		public void observeAttributeClass(double attVal, int classVal,
-	//				double weight) {
-	//			// TODO Auto-generated method stub
-	//
-	//		}
-	//
-	//		@Override
-	//		public void observeAttributeTarget(double attVal, double target) {
-	//			// TODO Auto-generated method stub
-	//
-	//		}
-	//
-	//		@Override
-	//		public String getPurposeString() {
-	//			// TODO Auto-generated method stub
-	//			return null;
-	//		}
-	//
-	//		@Override
-	//		public Options getOptions() {
-	//			// TODO Auto-generated method stub
-	//			return null;
-	//		}
-	//
-	//		@Override
-	//		public void prepareForUse() {
-	//			// TODO Auto-generated method stub
-	//
-	//		}
-	//
-	//		@Override
-	//		public void prepareForUse(TaskMonitor monitor,
-	//				ObjectRepository repository) {
-	//			// TODO Auto-generated method stub
-	//
-	//		}
-	//
-	//		@Override
-	//		public OptionHandler copy() {
-	//			// TODO Auto-generated method stub
-	//			return null;
-	//		}
-	//
-	//		@Override
-	//		public String getCLICreationString(Class<?> expectedType) {
-	//			// TODO Auto-generated method stub
-	//			return null;
-	//		}
-	//
-	//		@Override
-	//		public int measureByteSize() {
-	//			// TODO Auto-generated method stub
-	//			return 0;
-	//		}
-	//
-	//
-	//
-	//		@Override
-	//		public void observeAttributeClassVector(double attVal,
-	//				DoubleVector classVector, double weight) {
-	//			// TODO Auto-generated method stub
-	//
-	//		}
-	//
-	//
-	//	}
-
-=======
 				if (getModelContext() != null) {
-				for (int j = 0; j < getModelContext().numOutputAttributes(); j++) {
-									if (getModelContext().attribute(j).isNumeric()) {
-										out.append((j == 0 || weights[i][j] < 0) ? " " : " + ");
-										out.append(String.format("%.4f", weights[i][j]));
-										out.append(" * ");
-										out.append(getAttributeNameString(j));
-									}
-				}
-				out.append(" + " + weights[i][getModelContext().numOutputAttributes()]);
+					for (int j = 0; j < getModelContext().numOutputAttributes(); j++) {
+						if (getModelContext().attribute(j).isNumeric()) {
+							out.append((j == 0 || weights[i][j] < 0) ? " " : " + ");
+							out.append(String.format("%.4f", weights[i][j]));
+							out.append(" * ");
+							out.append(getAttributeNameString(j));
+						}
+					}
+					out.append(" + " + weights[i][getModelContext().numOutputAttributes()]);
 				}
 				StringUtils.appendNewline(out);
 			}
 		}
 	}
 
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 	//endregion ================ CLASSES ================
 
 	//region ================ METHODS ================
@@ -1166,27 +742,17 @@ public void getModelDescription(StringBuilder out, int indent) {
 	public ISOUPTree() {}
 
 	public String getPurposeString() {
-<<<<<<< HEAD
-		return "Implementation of the FIMT-DD tree as described by Ikonomovska et al.";
-=======
 		return "Implementation of the iSOUP-Tree algorithm as described by Osojnik et al.";
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 	}
 
 	public void resetLearningImpl() {
 		treeRoot = null;
-		leafNodeCount = 0;
-		splitNodeCount = 0;
-<<<<<<< HEAD
 		examplesSeen = 0.0;
 		sumOfValues = new DoubleVector();
 		sumOfSquares = new DoubleVector();
 
 		sumOfAttrValues = new DoubleVector();
 		sumOfAttrSquares = new DoubleVector();
-=======
-		maxID = 0;
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 	}
 
 	public boolean isRandomizable() {
@@ -1280,11 +846,7 @@ public double[] normalizeTargetVector(double[] pred) {
 				double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen);
 				double average = sumOfValues.getValue(i) / examplesSeen;
 				if (sd > 0 && examplesSeen > 1)
-<<<<<<< HEAD
 					out[i] = (value - average) / sd;
-=======
-					out[i] = (value - average) / (3 * sd);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				else
 					out[i] = 0;
 			}
@@ -1300,11 +862,7 @@ public double normalizeTargetValue(MultiLabelInstance inst, int i) {
 				double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen);
 				double average = sumOfValues.getValue(i) / examplesSeen;
 				if (sd > 0)
-<<<<<<< HEAD
 					return (value - average) / sd;
-=======
-					return (value - average) / (3 * sd);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				else
 					return 0;
 			}
@@ -1318,11 +876,7 @@ public double normalizeTargetValue(double value, int i) {
 				double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen);
 				double average = sumOfValues.getValue(i) / examplesSeen;
 				if (sd > 0)
-<<<<<<< HEAD
 					return (value - average) / sd;
-=======
-					return (value - average) / (3 * sd);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				else
 					return 0;
 			}
@@ -1344,283 +898,249 @@ public double[] getNormalizedError(MultiLabelInstance inst, double[] prediction)
 	/**
 	 * Method for updating (training) the model using a new instance
 	 */
-	public void trainOnInstanceImpl(MultiLabelInstance inst) {
-		if (inst.weight() > 0) {
-			checkRoot();
-
-			double[] prediction = treeRoot.getPrediction(inst);
-			double[] normalError = getNormalizedError(inst, prediction);
-<<<<<<< HEAD
-			
-			processInstance(inst, treeRoot, prediction, normalError, true, false);
-			
-=======
-			//normalError.scaleValues(inst.weight());
-			processInstance(inst, treeRoot, prediction, normalError, true, false);
-
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
-			examplesSeen += inst.weight();
-			for (int i = 0; i < inst.numberOutputTargets(); i++) {
-				sumOfValues.addToValue(i, inst.weight() * inst.valueOutputAttribute(i));
-				sumOfSquares.addToValue(i, inst.weight() * inst.valueOutputAttribute(i) * inst.valueOutputAttribute(i));
-			}
-
-			for (int i = 0; i < inst.numInputAttributes(); i++) {
-				sumOfAttrValues.addToValue(i, inst.weight() * inst.valueInputAttribute(i));
-				sumOfAttrSquares.addToValue(i, inst.weight() * inst.valueInputAttribute(i) * inst.valueInputAttribute(i));
-			}
-<<<<<<< HEAD
-			
-			//normalError.scaleValues(inst.weight());
-
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
-		}
-	}
-
-	public void processInstance(MultiLabelInstance inst, Node node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
-		Node currentNode = node;
-		while (true) {
-			if (currentNode instanceof LeafNode) {
-				((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
-				break;
-			} else {
-				currentNode.examplesSeen += inst.weight();
-				//currentNode.sumOfAbsErrors.addValues(normalError);
-				//				SplitNode iNode = (SplitNode) currentNode;
-				//				if (!inAlternate && iNode.alternateTree != null) {
-				//					boolean altTree = true;
-				//					double lossO = Math.pow(inst.valueOutputAttribute() - prediction, 2);
-				//					double lossA = Math.pow(inst.valueOutputAttribute() - iNode.alternateTree.getPrediction(inst), 2);
-				//
-				//					iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
-				//					iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
-				//					iNode.lossExamplesSeen++;
-				//
-				//					double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
-				//					double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
-				//					iNode.lossSumQi += Qi;
-				//					iNode.lossNumQiTests += 1;
-				//					double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
-				//
-				//					if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
-				//						iNode.previousWeight = iNode.lossExamplesSeen;
-				//						if (Qi > 0) {
-				//							SplitNode parent = currentNode.getParent();
-				//
-				//							if (parent != null) {
-				//								Node replacementTree = iNode.alternateTree;
-				//								parent.setChild(parent.getChildIndex(currentNode), replacementTree);
-				//								if (growthAllowed) replacementTree.restartChangeDetection();
-				//							} else {
-				//								treeRoot = iNode.alternateTree;
-				//								treeRoot.restartChangeDetection();
-				//							}
-				//
-				//							currentNode = iNode.alternateTree;
-				//							altTree = false;
-				//						} else if (
-				//								(QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * this.gracePeriodOption.getValue()))
-				//								|| iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()
-				//								) {
-				//							iNode.alternateTree = null;
-				//							if (growthAllowed) iNode.restartChangeDetection();
-				//							altTree = false;
-				//						}
-				//					}
-				//
-				//					if (altTree) {
-				//						growthAllowed = false;
-				//						processInstance(inst, iNode.alternateTree, prediction, normalError, true, true);
-				//					}
-				//				}
-
-				//				if (iNode.changeDetection && !inAlternate) {
-				//					if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
-				//						iNode.initializeAlternateTree(this);
-				//					}
-				//				}
-				if (currentNode instanceof SplitNode) {
-					currentNode = ((SplitNode) currentNode).getChild(((SplitNode) currentNode).instanceChildIndex(inst));
-				} else { // if the replaced alternate tree is just a leaf node
-					((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
-					break;
-				}
-			}
-		}
-	}
-
-	//region --- Object instatiation methods
-
-	protected NumericStatisticsObserver newNumericClassObserver() {
-		return new MultiLabelBSTree();
-	}
-
-	public NominalStatisticsObserver newNominalClassObserver() {
-		return new MultiLabelNominalAttributeObserver();
-	}
-
-	//	protected SplitNode newSplitNode(InstanceConditionalTest splitTest) {
-	//		maxID++;
-	//		return new SplitNode(splitTest, this);
-	//	}
-
-	protected SplitNode newSplitNode(Predicate predicate) {
-		maxID++;
-		return new SplitNode(predicate, this);
-	}
-
-	protected LeafNode newLeafNode() {
-		maxID++;
-		return new LeafNode(this);
-	}
-
-<<<<<<< HEAD
-	public MultitargetPerceptron newLeafModel() {
-=======
-	protected MultitargetPerceptron newLeafModel() {
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
-		return new MultitargetPerceptron(this);
-	}
-
-	//endregion --- Object instatiation methods
-
-	//region --- Processing methods
-	protected void checkRoot() {
-		if (treeRoot == null) {
-			treeRoot = newLeafNode();
-			leafNodeCount = 1;
-		}
-	}
-
-	public static double computeHoeffdingBound(double range, double confidence, double n) {
-		return Math.sqrt(( (range * range) * Math.log(1 / confidence)) / (2.0 * n));
-	}
-
-	public boolean buildingModelTree() {
-		return !regressionTreeOption.isSet();
-	}
-
-	public boolean normalize() {
-		return !doNotNormalizeOption.isSet();
-	}
-
-	protected void attemptToSplit(LeafNode node, SplitNode parent, int parentIndex) {
-		//System.out.println("Evaluating splits");
-		//System.out.println(examplesSeen);
-		// Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
-		MultiLabelSplitCriterion splitCriterion = new ICVarianceReduction();
-
-		// Using this criterion, find the best split per attribute and rank the results
-		AttributeExpansionSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion); // TODO update with split criterion option
-		Arrays.sort(bestSplitSuggestions);
-
-		// Declare a variable to determine if any of the splits should be performed
-		boolean shouldSplit = false;
-
-		// If only one split was returned, use it
-		if (bestSplitSuggestions.length < 2) {
-			shouldSplit = bestSplitSuggestions.length > 0;
-		} else { // Otherwise, consider which of the splits proposed may be worth trying
-
-			// Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
-			// to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
-			double hoeffdingBound = computeHoeffdingBound(1, splitConfidenceOption.getValue(), node.examplesSeen);
-			// Determine the top two ranked splitting suggestions
-			AttributeExpansionSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-			AttributeExpansionSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
-
-			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
-			// as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
-			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
-			// splitting should occur.
-			// Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
-			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
-			// competing attributes are equally good, and the split will be made on the one with the higher SDR value.
-			//System.out.print(hoeffdingBound);
-			//System.out.print(" ");
-			///System.out.println(secondBestSuggestion.merit / bestSuggestion.merit);
-			if ((secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) || (hoeffdingBound < this.tieThresholdOption.getValue())) {
-				shouldSplit = true;
-			}
-			// If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
-			else {
-				// TODO pruning is currently disabled
-				for (int i = 0; i < node.attributeObservers.size(); i++) {
-					AttributeStatisticsObserver obs = node.attributeObservers.get(i);
-					if (obs != null) {
-						if (getModelContext().attribute(i).isNumeric());
-						//TODO obs.removeBadSplits(null, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound, getModelContext().numOutputAttributes());
-						if (getModelContext().attribute(i).isNominal());
-						// TODO nominal class observers
-					}
-				}
-			}
-<<<<<<< HEAD
-			
-			if (hoeffdingBound < this.tieThresholdOption.getValue() && this.printLogsOption.isSet()) System.out.println("Forced to split due to tie at " + this.examplesSeen); 
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
-		}
-
-		// If the splitting criterion were met, split the current node using the chosen attribute test, and
-		// make two new branches leading to (empty) leaves
-		if (shouldSplit) {
-<<<<<<< HEAD
-			if (node.parent == null && this.printLogsOption.isSet()) {
-				System.out.println("splitting root node at " + this.examplesSeen);
-			}
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
-			AttributeExpansionSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-
-			SplitNode newSplit = newSplitNode(splitDecision.predicate);
-			newSplit.copyStatistics(node);
-			newSplit.changeDetection = node.changeDetection;
-			newSplit.ID = node.ID;
-			leafNodeCount--;
-			//System.out.println("Splitting");
-			//System.out.println(examplesSeen);
-			for (int i = 0; i < 2; i++) { // Hardcoded for 2 values (due to the use of the Predicate class)
-				LeafNode newChild = newLeafNode();
-				if (buildingModelTree()) {
-					// Copy the splitting node's perceptron to it's children
-					newChild.learningModel = new MultitargetPerceptron(this, (MultitargetPerceptron) node.learningModel);
-
-				}
-				newChild.changeDetection = node.changeDetection;
-				newChild.setParent(newSplit);
-				newSplit.setChild(i, newChild);
-				leafNodeCount++;
-			}
-			if (parent == null && node.originalNode == null) {
-				treeRoot = newSplit;
-			} else if (parent == null && node.originalNode != null) {
-				node.originalNode.alternateTree = newSplit;
-			} else {
-				parent.setChild(parentIndex, newSplit);
-				newSplit.setParent(parent);
-			}
-
-			splitNodeCount++;
-		}
-	}
-
-	public  double computeSD(double squaredVal, double val, double size) {
-		if (size > 1)
-			return Math.sqrt((squaredVal - ((val * val) / size)) / size);
-		else
-			return 0.0;
-	}
-
-	public static double scalarProduct(DoubleVector u, DoubleVector v) {
-		double ret = 0.0;
-		for (int i = 0; i < Math.max(u.numValues(), v.numValues()); i++) {
-			ret += u.getValue(i) * v.getValue(i);
-		}
-		return ret;
-	}
-	//endregion --- Processing methods
-
-	//endregion ================ METHODS ================
+	 public void trainOnInstanceImpl(MultiLabelInstance inst) {
+		 if (inst.weight() > 0) {
+			 checkRoot();
+
+			 double[] prediction = treeRoot.getPrediction(inst);
+			 double[] normalError = getNormalizedError(inst, prediction);
+
+			 processInstance(inst, treeRoot, prediction, normalError, true, false);
+
+			 examplesSeen += inst.weight();
+			 for (int i = 0; i < inst.numberOutputTargets(); i++) {
+				 sumOfValues.addToValue(i, inst.weight() * inst.valueOutputAttribute(i));
+				 sumOfSquares.addToValue(i, inst.weight() * inst.valueOutputAttribute(i) * inst.valueOutputAttribute(i));
+			 }
+
+			 for (int i = 0; i < inst.numInputAttributes(); i++) {
+				 sumOfAttrValues.addToValue(i, inst.weight() * inst.valueInputAttribute(i));
+				 sumOfAttrSquares.addToValue(i, inst.weight() * inst.valueInputAttribute(i) * inst.valueInputAttribute(i));
+			 }
+		 }
+	 }
+
+	 public void processInstance(MultiLabelInstance inst, Node node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
+		 Node currentNode = node;
+		 while (true) {
+			 if (currentNode instanceof LeafNode) {
+				 ((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
+				 break;
+			 } else {
+				 currentNode.examplesSeen += inst.weight();
+				 //currentNode.sumOfAbsErrors.addValues(normalError);
+				 //				SplitNode iNode = (SplitNode) currentNode;
+				 //				if (!inAlternate && iNode.alternateTree != null) {
+				 //					boolean altTree = true;
+				 //					double lossO = Math.pow(inst.valueOutputAttribute() - prediction, 2);
+				 //					double lossA = Math.pow(inst.valueOutputAttribute() - iNode.alternateTree.getPrediction(inst), 2);
+				 //
+				 //					iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
+				 //					iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
+				 //					iNode.lossExamplesSeen++;
+				 //
+				 //					double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
+				 //					double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+				 //					iNode.lossSumQi += Qi;
+				 //					iNode.lossNumQiTests += 1;
+				 //					double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+				 //
+				 //					if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
+				 //						iNode.previousWeight = iNode.lossExamplesSeen;
+				 //						if (Qi > 0) {
+				 //							SplitNode parent = currentNode.getParent();
+				 //
+				 //							if (parent != null) {
+				 //								Node replacementTree = iNode.alternateTree;
+				 //								parent.setChild(parent.getChildIndex(currentNode), replacementTree);
+				 //								if (growthAllowed) replacementTree.restartChangeDetection();
+				 //							} else {
+				 //								treeRoot = iNode.alternateTree;
+				 //								treeRoot.restartChangeDetection();
+				 //							}
+				 //
+				 //							currentNode = iNode.alternateTree;
+				 //							altTree = false;
+				 //						} else if (
+				 //								(QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * this.gracePeriodOption.getValue()))
+				 //								|| iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()
+				 //								) {
+				 //							iNode.alternateTree = null;
+				 //							if (growthAllowed) iNode.restartChangeDetection();
+				 //							altTree = false;
+				 //						}
+				 //					}
+				 //
+				 //					if (altTree) {
+				 //						growthAllowed = false;
+				 //						processInstance(inst, iNode.alternateTree, prediction, normalError, true, true);
+				 //					}
+				 //				}
+
+				 //				if (iNode.changeDetection && !inAlternate) {
+				 //					if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+				 //						iNode.initializeAlternateTree(this);
+				 //					}
+				 //				}
+				 if (currentNode instanceof SplitNode) {
+					 currentNode = ((SplitNode) currentNode).getChild(((SplitNode) currentNode).instanceChildIndex(inst));
+				 } else { // if the replaced alternate tree is just a leaf node
+					 ((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
+					 break;
+				 }
+			 }
+		 }
+	 }
+
+	 //region --- Object instatiation methods
+
+	 protected NumericStatisticsObserver newNumericClassObserver() {
+		 return new MultiLabelBSTree();
+	 }
+
+	 public NominalStatisticsObserver newNominalClassObserver() {
+		 return new MultiLabelNominalAttributeObserver();
+	 }
+
+	 //	protected SplitNode newSplitNode(InstanceConditionalTest splitTest) {
+	 //		maxID++;
+	 //		return new SplitNode(splitTest, this);
+	 //	}
+
+	 protected SplitNode newSplitNode(Predicate predicate) {
+		 maxID++;
+		 return new SplitNode(predicate, this);
+	 }
+
+	 protected LeafNode newLeafNode() {
+		 maxID++;
+		 return new LeafNode(this);
+	 }
+
+	 public MultitargetPerceptron newLeafModel() {
+		 return new MultitargetPerceptron(this);
+	 }
+
+	 //endregion --- Object instatiation methods
+
+	 //region --- Processing methods
+	 protected void checkRoot() {
+		 if (treeRoot == null) {
+			 treeRoot = newLeafNode();
+		 }
+	 }
+
+	 public static double computeHoeffdingBound(double range, double confidence, double n) {
+		 return Math.sqrt(( (range * range) * Math.log(1 / confidence)) / (2.0 * n));
+	 }
+
+	 public boolean buildingModelTree() {
+		 return !regressionTreeOption.isSet();
+	 }
+
+	 public boolean normalize() {
+		 return !doNotNormalizeOption.isSet();
+	 }
+
+	 protected void attemptToSplit(LeafNode node, SplitNode parent, int parentIndex) {
+		 //System.out.println("Evaluating splits");
+		 //System.out.println(examplesSeen);
+		 // Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
+		 MultiLabelSplitCriterion splitCriterion = new ICVarianceReduction();
+
+		 // Using this criterion, find the best split per attribute and rank the results
+		 AttributeExpansionSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion); // TODO update with split criterion option
+		 Arrays.sort(bestSplitSuggestions);
+
+		 // Declare a variable to determine if any of the splits should be performed
+		 boolean shouldSplit = false;
+
+		 // If only one split was returned, use it
+		 if (bestSplitSuggestions.length < 2) {
+			 shouldSplit = bestSplitSuggestions.length > 0;
+		 } else { // Otherwise, consider which of the splits proposed may be worth trying
+
+			 // Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
+			 // to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
+			 double hoeffdingBound = computeHoeffdingBound(1, splitConfidenceOption.getValue(), node.examplesSeen);
+			 // Determine the top two ranked splitting suggestions
+			 AttributeExpansionSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+			 AttributeExpansionSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
+
+			 // If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
+			 // as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
+			 // particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
+			 // splitting should occur.
+			 // Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
+			 // (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
+			 // competing attributes are equally good, and the split will be made on the one with the higher SDR value.
+			 //System.out.print(hoeffdingBound);
+			 //System.out.print(" ");
+			 ///System.out.println(secondBestSuggestion.merit / bestSuggestion.merit);
+			 if ((secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) || (hoeffdingBound < this.tieThresholdOption.getValue())) {
+				 shouldSplit = true;
+			 }
+			 // If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
+			 else {
+				 // TODO pruning is currently disabled
+				 for (int i = 0; i < node.attributeObservers.size(); i++) {
+					 AttributeStatisticsObserver obs = node.attributeObservers.get(i);
+					 if (obs != null) {
+						 if (getModelContext().attribute(i).isNumeric());
+						 //TODO obs.removeBadSplits(null, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound, getModelContext().numOutputAttributes());
+						 if (getModelContext().attribute(i).isNominal());
+						 // TODO nominal class observers
+					 }
+				 }
+			 }
+		 }
+
+		 // If the splitting criterion were met, split the current node using the chosen attribute test, and
+		 // make two new branches leading to (empty) leaves
+		 if (shouldSplit) {
+			 AttributeExpansionSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+
+			 SplitNode newSplit = newSplitNode(splitDecision.predicate);
+			 newSplit.copyStatistics(node);
+			 newSplit.changeDetection = node.changeDetection;
+			 newSplit.ID = node.ID;
+			 for (int i = 0; i < 2; i++) { // Hardcoded for 2 values (due to the use of the Predicate class)
+				 LeafNode newChild = newLeafNode();
+				 if (buildingModelTree()) {
+					 // Copy the splitting node's perceptron to it's children
+					 newChild.learningModel = new MultitargetPerceptron(this, (MultitargetPerceptron) node.learningModel);
+
+				 }
+				 newChild.changeDetection = node.changeDetection;
+				 newChild.setParent(newSplit);
+				 newSplit.setChild(i, newChild);
+			 }
+			 if (parent == null && node.originalNode == null) {
+				 treeRoot = newSplit;
+			 } else if (parent == null && node.originalNode != null) {
+				 node.originalNode.alternateTree = newSplit;
+			 } else {
+				 parent.setChild(parentIndex, newSplit);
+				 newSplit.setParent(parent);
+			 }
+		 }
+	 }
+
+	 public  double computeSD(double squaredVal, double val, double size) {
+		 if (size > 1)
+			 return Math.sqrt((squaredVal - ((val * val) / size)) / size);
+		 else
+			 return 0.0;
+	 }
+
+	 public static double scalarProduct(DoubleVector u, DoubleVector v) {
+		 double ret = 0.0;
+		 for (int i = 0; i < Math.max(u.numValues(), v.numValues()); i++) {
+			 ret += u.getValue(i) * v.getValue(i);
+		 }
+		 return ret;
+	 }
+	 //endregion --- Processing methods
+
+	 //endregion ================ METHODS ================
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/AttributeExpansionSuggestion.java b/moa/src/main/java/moa/classifiers/rules/core/AttributeExpansionSuggestion.java
similarity index 95%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/core/AttributeExpansionSuggestion.java
rename to moa/src/main/java/moa/classifiers/rules/core/AttributeExpansionSuggestion.java
index b39b52ba0..a1e24bbb6 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/AttributeExpansionSuggestion.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/AttributeExpansionSuggestion.java
@@ -17,10 +17,9 @@
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
  *    
  */
-package moa.classifiers.rules.multilabel.core;
+package moa.classifiers.rules.core;
 
 import moa.AbstractMOAObject;
-import moa.classifiers.rules.core.Predicate;
 import moa.core.DoubleVector;
 
 /**
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java b/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java
index 8014b5e20..2672f58f5 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java
@@ -36,13 +36,13 @@
 import moa.classifiers.AbstractMultiLabelLearner;
 import moa.classifiers.MultiLabelLearner;
 import moa.classifiers.core.driftdetection.ChangeDetector;
+import moa.classifiers.multilabel.core.attributeclassobservers.NominalStatisticsObserver;
+import moa.classifiers.multilabel.core.attributeclassobservers.NumericStatisticsObserver;
+import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.rules.core.anomalydetection.AnomalyDetector;
 import moa.classifiers.rules.core.anomalydetection.OddsRatioScore;
-import moa.classifiers.rules.multilabel.attributeclassobservers.NominalStatisticsObserver;
-import moa.classifiers.rules.multilabel.attributeclassobservers.NumericStatisticsObserver;
 import moa.classifiers.rules.multilabel.core.MultiLabelRule;
 import moa.classifiers.rules.multilabel.core.MultiLabelRuleSet;
-import moa.classifiers.rules.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.rules.multilabel.core.voting.ErrorWeightedVoteMultiLabel;
 import moa.classifiers.rules.multilabel.core.voting.MultiLabelVote;
 import moa.classifiers.rules.multilabel.errormeasurers.MultiLabelErrorMeasurer;
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressor.java b/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressor.java
index 5b192f525..146a6be85 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressor.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressor.java
@@ -3,9 +3,9 @@
 import moa.classifiers.MultiLabelLearner;
 import moa.classifiers.MultiTargetRegressor;
 import moa.classifiers.Regressor;
+import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.rules.multilabel.core.MultiLabelRule;
 import moa.classifiers.rules.multilabel.core.MultiLabelRuleRegression;
-import moa.classifiers.rules.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.rules.multilabel.core.voting.ErrorWeightedVoteMultiLabel;
 import moa.classifiers.rules.multilabel.core.voting.InverseErrorWeightedVoteMultiLabel;
 import moa.classifiers.rules.multilabel.errormeasurers.MultiLabelErrorMeasurer;
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java
index a2765587b..4a8a18ccf 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java
@@ -11,16 +11,18 @@
 import com.yahoo.labs.samoa.instances.MultiLabelInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
+
 import moa.classifiers.MultiLabelLearner;
 import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
 import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
 import moa.classifiers.core.attributeclassobservers.NumericAttributeClassObserver;
 import moa.classifiers.core.driftdetection.ChangeDetector;
+import moa.classifiers.multilabel.core.attributeclassobservers.AttributeStatisticsObserver;
+import moa.classifiers.multilabel.core.attributeclassobservers.NominalStatisticsObserver;
+import moa.classifiers.multilabel.core.attributeclassobservers.NumericStatisticsObserver;
+import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.classifiers.rules.core.AttributeExpansionSuggestion;
 import moa.classifiers.rules.core.anomalydetection.AnomalyDetector;
-import moa.classifiers.rules.multilabel.attributeclassobservers.AttributeStatisticsObserver;
-import moa.classifiers.rules.multilabel.attributeclassobservers.NominalStatisticsObserver;
-import moa.classifiers.rules.multilabel.attributeclassobservers.NumericStatisticsObserver;
-import moa.classifiers.rules.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.rules.multilabel.errormeasurers.AbstractMultiTargetErrorMeasurer;
 import moa.classifiers.rules.multilabel.errormeasurers.MultiLabelErrorMeasurer;
 import moa.classifiers.rules.multilabel.outputselectors.OutputAttributesSelector;
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java
index fb96cae96..26ae4e0d9 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java
@@ -15,11 +15,12 @@
 import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
 import moa.classifiers.core.driftdetection.ChangeDetector;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
+import moa.classifiers.multilabel.core.attributeclassobservers.AttributeStatisticsObserver;
+import moa.classifiers.multilabel.core.attributeclassobservers.NominalStatisticsObserver;
+import moa.classifiers.multilabel.core.attributeclassobservers.NumericStatisticsObserver;
+import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.classifiers.rules.core.AttributeExpansionSuggestion;
 import moa.classifiers.rules.core.Utils;
-import moa.classifiers.rules.multilabel.attributeclassobservers.AttributeStatisticsObserver;
-import moa.classifiers.rules.multilabel.attributeclassobservers.NominalStatisticsObserver;
-import moa.classifiers.rules.multilabel.attributeclassobservers.NumericStatisticsObserver;
-import moa.classifiers.rules.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.rules.multilabel.functions.AMRulesFunction;
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java
index 9312ce86a..6bd641395 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java
@@ -14,13 +14,13 @@
 import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
 import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
 import moa.classifiers.core.driftdetection.ChangeDetector;
+import moa.classifiers.multilabel.core.attributeclassobservers.NominalStatisticsObserver;
+import moa.classifiers.multilabel.core.attributeclassobservers.NumericStatisticsObserver;
+import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.rules.core.RuleActiveLearningNode;
 import moa.classifiers.rules.core.RuleSplitNode;
 import moa.classifiers.rules.core.anomalydetection.AnomalyDetector;
 import moa.classifiers.rules.core.conditionaltests.NumericAttributeBinaryRulePredicate;
-import moa.classifiers.rules.multilabel.attributeclassobservers.NominalStatisticsObserver;
-import moa.classifiers.rules.multilabel.attributeclassobservers.NumericStatisticsObserver;
-import moa.classifiers.rules.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.rules.multilabel.errormeasurers.MultiLabelErrorMeasurer;
 import moa.classifiers.rules.multilabel.outputselectors.OutputAttributesSelector;
 import moa.core.StringUtils;
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/splitcriteria/MultiTargetVarianceRatio.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/splitcriteria/MultiTargetVarianceRatio.java
index c9a3a9904..4f64f7c44 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/splitcriteria/MultiTargetVarianceRatio.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/core/splitcriteria/MultiTargetVarianceRatio.java
@@ -1,5 +1,6 @@
 package moa.classifiers.rules.multilabel.core.splitcriteria;
 
+import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.rules.core.Utils;
 import moa.core.DoubleVector;
 import moa.core.ObjectRepository;
diff --git a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java b/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
index 6cb747894..02bd090fd 100644
--- a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
+++ b/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
@@ -1,997 +1,3 @@
-<<<<<<< HEAD
-/*
- *    FIMTDD.java
- *    Copyright (C) 2015 Jožef Stefan Institute, Ljubljana, Slovenia
- *    @author Aljaž Osojnik <aljaz.osojnik@ijs.si>
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.classifiers.trees;
-
-import java.io.Serializable;
-import java.util.Arrays;
-import java.util.LinkedList;
-import java.util.List;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-
-import moa.options.ClassOption;
-import moa.AbstractMOAObject;
-import moa.classifiers.Regressor;
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
-import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.classifiers.AbstractClassifier;
-import moa.core.AutoExpandVector;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.core.SizeOf;
-import moa.core.StringUtils;
-
-/*
- * Implementation of FIMTDD, regression and model trees for data streams.
- */
-
-public class FIMTDD extends AbstractClassifier implements Regressor {
-
-	private static final long serialVersionUID = 1L;
-
-	protected Node treeRoot;
-
-	protected int leafNodeCount = 0;
-	protected int splitNodeCount = 0;
-
-	protected double examplesSeen = 0.0;
-	protected double sumOfValues = 0.0;
-	protected double sumOfSquares = 0.0;
-
-	protected DoubleVector sumOfAttrValues = new DoubleVector();
-	protected DoubleVector sumOfAttrSquares = new DoubleVector();
-
-	public int maxID = 0;
-
-	//region ================ OPTIONS ================
-
-	public ClassOption splitCriterionOption = new ClassOption(
-			"splitCriterion", 's', "Split criterion to use.",
-			SplitCriterion.class, "moa.classifiers.core.splitcriteria.VarianceReductionSplitCriterion");
-
-	public IntOption gracePeriodOption = new IntOption(
-			"gracePeriod", 'g', "Number of instances a leaf should observe between split attempts.",
-			200, 0, Integer.MAX_VALUE);
-
-	public FloatOption splitConfidenceOption = new FloatOption(
-			"splitConfidence", 'c', "Allowed error in split decision, values close to 0 will take long to decide.",
-			0.0000001, 0.0, 1.0);
-
-	public FloatOption tieThresholdOption = new FloatOption(
-			"tieThreshold", 't', "Threshold below which a split will be forced to break ties.",
-			0.05, 0.0, 1.0);
-
-	public FloatOption PageHinckleyAlphaOption = new FloatOption(
-			"PageHinckleyAlpha", 'a', "Alpha value to use in the Page Hinckley change detection tests.",
-			0.005, 0.0, 1.0);
-
-	public IntOption PageHinckleyThresholdOption = new IntOption(
-			"PageHinckleyThreshold", 'h', "Threshold value used in the Page Hinckley change detection tests.",
-			50, 0, Integer.MAX_VALUE);
-
-	public FloatOption alternateTreeFadingFactorOption = new FloatOption(
-			"alternateTreeFadingFactor", 'f', "Fading factor used to decide if an alternate tree should replace an original.",
-			0.995, 0.0, 1.0);
-
-	public IntOption alternateTreeTMinOption = new IntOption(
-			"alternateTreeTMin", 'y', "Tmin value used to decide if an alternate tree should replace an original.",
-			150, 0, Integer.MAX_VALUE);
-
-	public IntOption alternateTreeTimeOption = new IntOption(
-			"alternateTreeTime", 'u', "The number of instances used to decide if an alternate tree should be discarded.",
-			1500, 0, Integer.MAX_VALUE);
-
-	public FlagOption regressionTreeOption = new FlagOption(
-			"regressionTree", 'e', "Build a regression tree instead of a model tree.");
-
-	public FloatOption learningRatioOption = new FloatOption(
-			"learningRatio", 'l', "Learning ratio to used for training the Perceptrons in the leaves.",
-			0.003, 0, 1.00);
-
-	public FloatOption learningRateDecayFactorOption = new FloatOption(
-			"learningRatioDecayFactor", 'd', "Learning rate decay factor (not used when learning rate is constant).",
-			0.001, 0, 1.00);
-
-	public FlagOption learningRatioConstOption = new FlagOption(
-			"learningRatioConst", 'p', "Keep learning rate constant instead of decaying.");
-
-	//endregion ================ OPTIONS ================
-
-	//region ================ CLASSES ================
-
-	public abstract static class Node extends AbstractMOAObject {
-
-		private static final long serialVersionUID = 1L;
-
-		public int ID;
-
-		protected FIMTDD tree;
-		
-		protected boolean changeDetection = true;
-		
-		protected Node parent;
-
-		protected Node alternateTree;
-		protected Node originalNode;
-
-		// The statistics for this node:
-		// Number of instances that have reached it
-		protected double examplesSeen;
-		// Sum of y values
-		protected double sumOfValues;
-		// Sum of squared y values
-		protected double sumOfSquares;
-		// Sum of absolute errors
-		protected double sumOfAbsErrors; // Needed for PH tracking of mean error
-
-		public Node(FIMTDD tree) {
-			this.tree = tree;
-			ID = tree.maxID; 
-		}
-
-		public void copyStatistics(Node node) {
-			examplesSeen = node.examplesSeen;
-			sumOfValues = node.sumOfValues;
-			sumOfSquares = node.sumOfSquares;
-			sumOfAbsErrors = node.sumOfAbsErrors;
-		}
-
-		public int calcByteSize() {
-			return (int) SizeOf.fullSizeOf(this);
-		}
-
-		/**
-		 * Set the parent node
-		 */
-		public void setParent(Node parent) {
-			this.parent = parent;    
-		}
-
-		/**
-		 * Return the parent node
-		 */
-		public Node getParent() {
-			return parent;
-		}
-
-		public void disableChangeDetection() {
-			changeDetection = false;
-		}
-
-		public void restartChangeDetection() {
-			changeDetection = true;
-		}
-		
-		public void getDescription(StringBuilder sb, int indent) {
-			
-		}
-
-		public double getPrediction(Instance inst) {
-			return 0;
-		}
-		
-		public void describeSubtree(StringBuilder out, int indent) {
-			StringUtils.appendIndented(out, indent, "Leaf");
-		}
-		
-		public int getLevel() {
-			Node target = this;
-			int level = 0;
-			while (target.getParent() != null) {
-				if (target.skipInLevelCount()) {
-					target = target.getParent();
-					continue;
-				}
-				level = level + 1;
-				target = target.getParent();
-			}
-			if (target.originalNode == null) {
-				return level;
-			} else {
-				return level + originalNode.getLevel();
-			}
-		}
-
-		public void setChild(int parentBranch, Node node) {
-		}
-
-		public int getChildIndex(Node child) {
-			return -1;
-		}
-
-		public int getNumSubtrees() {
-			return 1;
-		}
-
-		protected boolean skipInLevelCount() {
-			return false;
-		}
-	}
-
-	public static class LeafNode extends Node {
-
-		private static final long serialVersionUID = 1L;
-
-		public double errorModel = 0.0;
-		public double errorTargetMean = 0.0;
-		
-		// Perceptron model that carries out the actual learning in each node
-		public FIMTDDPerceptron learningModel;
-
-		protected AutoExpandVector<FIMTDDNumericAttributeClassObserver> attributeObservers = new AutoExpandVector<FIMTDDNumericAttributeClassObserver>();
-		
-		protected double examplesSeenAtLastSplitEvaluation = 0;
-
-		/**
-		 * Create a new LeafNode
-		 */
-		public LeafNode(FIMTDD tree) {
-			super(tree);
-			if (tree.buildingModelTree()) {
-				learningModel = tree.newLeafModel();
-			}
-			examplesSeen = 0;
-			sumOfValues = 0;
-			sumOfSquares = 0;
-			sumOfAbsErrors = 0;
-		}
-
-		public void setChild(int parentBranch, Node node) {
-		}
-
-		public int getChildIndex(Node child) {
-			return -1;
-		}
-
-		public int getNumSubtrees() {
-			return 1;
-		}
-
-		protected boolean skipInLevelCount() {
-			return false;
-		}
-		
-		/**
-		 * Method to learn from an instance that passes the new instance to the perceptron learner,
-		 * and also prevents the class value from being truncated to an int when it is passed to the
-		 * attribute observer
-		 */
-		public void learnFromInstance(Instance inst, boolean growthAllowed, double prediction) {
-			//The prediction must be calculated here -- it may be different from the tree's prediction due to alternate trees
-			
-			// Update the statistics for this node
-			// number of instances passing through the node
-			examplesSeen += inst.weight();
-
-			// sum of y values
-			sumOfValues += inst.weight() * inst.classValue();
-
-			// sum of squared y values
-			sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
-
-			// sum of absolute errors
-			sumOfAbsErrors += inst.weight() * Math.abs(tree.normalizeTargetValue(Math.abs(inst.classValue() - prediction)));
-			
-			if (tree.buildingModelTree()) {
-				double predictionModel = getPredictionModel(inst);
-				double predictionTargetMean = getPredictionTargetMean(inst);
-				
-				errorModel = errorModel * 0.95 + Math.abs(predictionModel - inst.classValue());
-				errorTargetMean = errorTargetMean * 0.95 + Math.abs(predictionTargetMean - inst.classValue());
-				
-				learningModel.updatePerceptron(inst);
-			}
-
-			for (int i = 0; i < inst.numAttributes() - 1; i++) {
-				int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
-				FIMTDDNumericAttributeClassObserver obs = attributeObservers.get(i);
-				if (obs == null) {
-					// At this stage all nominal attributes are ignored
-					if (inst.attribute(instAttIndex).isNumeric()) {
-						obs = tree.newNumericClassObserver();
-						this.attributeObservers.set(i, obs);
-					}
-				}
-				if (obs != null) {
-					obs.observeAttributeClass(inst.value(instAttIndex), inst.classValue(), inst.weight());
-				}
-			}
-
-			if (growthAllowed) {
-				checkForSplit();
-			}
-		}
-
-		/**
-		 * Return the best split suggestions for this node using the given split criteria
-		 */
-		public AttributeSplitSuggestion[] getBestSplitSuggestions(SplitCriterion criterion) {
-
-			List<AttributeSplitSuggestion> bestSuggestions = new LinkedList<AttributeSplitSuggestion>();
-
-			// Set the nodeStatistics up as the preSplitDistribution, rather than the observedClassDistribution
-			double[] nodeSplitDist = new double[] {examplesSeen, sumOfValues, sumOfSquares};
-
-			for (int i = 0; i < this.attributeObservers.size(); i++) {
-				FIMTDDNumericAttributeClassObserver obs = this.attributeObservers.get(i);
-				if (obs != null) {
-
-					// AT THIS STAGE NON-NUMERIC ATTRIBUTES ARE IGNORED
-					AttributeSplitSuggestion bestSuggestion = null;
-					if (obs instanceof FIMTDDNumericAttributeClassObserver) {
-						bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion, nodeSplitDist, i, true);
-					}
-
-					if (bestSuggestion != null) {
-						bestSuggestions.add(bestSuggestion);
-					}
-				}
-			}
-			return bestSuggestions.toArray(new AttributeSplitSuggestion[bestSuggestions.size()]);
-		}
-
-		/**
-		 * Retrieve the class votes using the perceptron learner
-		 */
-		public double getPredictionModel(Instance inst) {
-			return learningModel.prediction(inst);
-		}
-
-		public double getPredictionTargetMean(Instance inst) {
-			return (examplesSeen > 0.0) ? sumOfValues / examplesSeen : 0.0;
-		}
-
-		public double getPrediction(Instance inst) {
-			if (tree.buildingModelTree()) {
-				//return getPredictionModel(inst);
-				return (errorModel < errorTargetMean) ? getPredictionModel(inst) : getPredictionTargetMean(inst);
-			} else
-				return getPredictionTargetMean(inst);
-		}
-		
-		public void checkForSplit() {
-			// If it has seen Nmin examples since it was last tested for splitting, attempt a split of this node
-			if (examplesSeen - examplesSeenAtLastSplitEvaluation >= tree.gracePeriodOption.getValue()) {
-				int index = (parent != null) ? parent.getChildIndex(this) : 0;
-				tree.attemptToSplit(this, parent, index);
-
-				// Take note of how many instances were seen when this split evaluation was made, so we know when to perform the next split evaluation
-				examplesSeenAtLastSplitEvaluation = examplesSeen;
-			}
-		}
-
-		public void describeSubtree(StringBuilder out, int indent) {
-			StringUtils.appendIndented(out, indent, "Leaf ");
-			if (tree.buildingModelTree()) {
-				learningModel.getModelDescription(out, 0);
-			} else {
-				out.append(tree.getClassNameString() + " = " + String.format("%.4f", sumOfValues / examplesSeen));
-				StringUtils.appendNewline(out);
-			}
-		}
-	}
-
-	public abstract static class InnerNode extends Node {
-		// The InnerNode and SplitNode design is used for easy extension in ORTO
-		private static final long serialVersionUID = 1L;
-
-		protected AutoExpandVector<Node> children = new AutoExpandVector<Node>();
-
-		// The error values for the Page Hinckley test
-		// PHmT = the cumulative sum of the errors
-		// PHMT = the minimum error value seen so far
-		protected double PHsum = 0;
-		protected double PHmin = Double.MAX_VALUE;
-
-		// Keep track of the statistics for loss error calculations
-		protected double lossExamplesSeen;
-		protected double lossFadedSumOriginal;
-		protected double lossFadedSumAlternate;
-		protected double lossNumQiTests;
-		protected double lossSumQi;
-		protected double previousWeight = 0;
-		
-		public InnerNode(FIMTDD tree) {
-			super(tree);
-		}
-
-		public int numChildren() {
-			return children.size();
-		}
-
-		public Node getChild(int index) {
-			return children.get(index);
-		}
-
-		public int getChildIndex(Node child) {
-			return children.indexOf(child);
-		}
-
-		public void setChild(int index, Node child) {
-			children.set(index, child);
-		}
-
-		public void disableChangeDetection() {
-			changeDetection = false;
-			for (Node child : children) {
-				child.disableChangeDetection();
-			}
-		}
-
-		public void restartChangeDetection() {
-			if (alternateTree == null) {
-				changeDetection = true;
-				PHsum = 0;
-				PHmin = Integer.MAX_VALUE;
-				for (Node child : children)
-					child.restartChangeDetection();
-			}
-		}
-		
-		/**
-		 * Check to see if the tree needs updating
-		 */
-		public boolean PageHinckleyTest(double error, double threshold) {    
-			// Update the cumulative mT sum
-			PHsum += error;
-
-			// Update the minimum mT value if the new mT is
-			// smaller than the current minimum
-			if(PHsum < PHmin) {
-				PHmin = PHsum;
-			}
-			// Return true if the cumulative value - the current minimum is
-			// greater than the current threshold (in which case we should adapt)
-			return PHsum - PHmin > threshold;
-		}
-		
-		public void initializeAlternateTree() {
-			// Start a new alternate tree, beginning with a learning node
-			alternateTree = tree.newLeafNode();
-			alternateTree.originalNode = this;
-
-			// Set up the blank statistics
-			// Number of instances reaching this node since the alternate tree was started
-			lossExamplesSeen = 0;
-			// Faded squared error (original tree)
-			lossFadedSumOriginal = 0;
-			// Faded squared error (alternate tree)
-			lossFadedSumAlternate = 0;
-			// Number of evaluations of alternate tree
-			lossNumQiTests = 0;
-			// Sum of Qi values
-			lossSumQi = 0;
-			// Number of examples at last test
-			previousWeight = 0;
-
-			// Disable the change detection mechanism bellow this node
-			disableChangeDetection();
-		}
-	}
-	
-	public static class SplitNode extends InnerNode {
-
-		private static final long serialVersionUID = 1L;
-
-		protected InstanceConditionalTest splitTest;
-
-		/**
-		 * Create a new SplitNode
-		 * @param tree 
-		 */
-		public SplitNode(InstanceConditionalTest splitTest, FIMTDD tree) {
-			super(tree);
-			this.splitTest = splitTest;
-		}
-
-		public int instanceChildIndex(Instance inst) {
-			return splitTest.branchForInstance(inst);
-		}
-		
-		public Node descendOneStep(Instance inst) {
-			return children.get(splitTest.branchForInstance(inst));
-		}
-
-		public void describeSubtree(StringBuilder out, int indent) {
-			for (int branch = 0; branch < children.size(); branch++) {
-				Node child = getChild(branch);
-				if (child != null) {
-					StringUtils.appendIndented(out, indent, "if ");
-					out.append(this.splitTest.describeConditionForBranch(branch,
-							tree.getModelContext()));
-					out.append(": ");
-					StringUtils.appendNewline(out);
-					child.describeSubtree(out, indent + 2);
-				}
-			}
-		}
-
-		public double getPrediction(Instance inst) {
-			return children.get(splitTest.branchForInstance(inst)).getPrediction(inst);
-		}
-	}
-
-	public class FIMTDDPerceptron implements Serializable {
-
-		private static final long serialVersionUID = 1L;
-		
-		protected FIMTDD tree;
-		
-		// The Perception weights 
-		protected double[] weightAttribute; 
-
-		// The number of instances contributing to this model
-		protected double instancesSeen = 0;
-
-		public String getPurposeString() {
-			return "A perceptron regressor as specified by Ikonomovska et al. used for FIMTDD";
-		}
-
-		public FIMTDDPerceptron(FIMTDDPerceptron original) {
-			this.tree = original.tree;
-			weightAttribute = original.weightAttribute.clone();
-		}
-
-		public FIMTDDPerceptron(FIMTDD tree) {
-			this.tree = tree;
-			initializeWeights();
-
-		}
-
-		public void initializeWeights() {
-			weightAttribute = new double[tree.getModelContext().numInputAttributes()+1];
-			instancesSeen = 0;
-			for (int j = 0; j < tree.getModelContext().numInputAttributes()+1; j++) {
-				// The last index corresponds to the constant b
-				weightAttribute[j] = 2 * tree.classifierRandom.nextDouble() - 1;
-			}
-			normalizeWeights();
-		}
-		
-		/**
-		 * Update the model using the provided instance
-		 */
-		public void updatePerceptron(Instance inst) {
-
-			// Update attribute statistics
-			instancesSeen += inst.weight();
-
-			// Update weights
-			double learningRatio = 0.0;
-			if (tree.learningRatioConstOption.isSet()) {
-				learningRatio = learningRatioOption.getValue();
-			} else {
-				learningRatio = learningRatioOption.getValue() / (1 + instancesSeen * tree.learningRateDecayFactorOption.getValue());
-			}
-
-			// Loop for compatibility with bagging methods 
-			for (int i = 0; i < (int) inst.weight(); i++) {
-				updateWeights(inst, learningRatio);
-			}
-		
-		}
-
-		public void updateWeights(Instance inst, double learningRatio) {
-			// Compute the normalized instance and the delta
-			double[] normalizedInstance = normalizedInstance(inst); 
-			double normalizedPrediction = prediction(normalizedInstance);
-			double normalizedValue = tree.normalizeTargetValue(inst.classValue());
-			double delta = normalizedValue - normalizedPrediction;
-			for (int i = 0; i < weightAttribute.length; i++) {
-				weightAttribute[i] += delta * learningRatio * normalizedInstance[i];
-			}
-			
-			normalizeWeights();
-		}
-		
-		public void normalizeWeights() {
-			double sum = 0;
-			for (int i = 0; i < this.weightAttribute.length; i++)
-				sum += Math.abs(weightAttribute[i]);
-			for (int i = 0; i < this.weightAttribute.length; i++)
-				weightAttribute[i] /= sum;
-		}
-
-		public double[] normalizedInstance(Instance inst) {
-			// Normalize Instance
-			double[] normalizedInstance = new double[inst.numInputAttributes()+1];
-			for (int j = 0; j < inst.numInputAttributes(); j++) {
-				double mean = tree.sumOfAttrValues.getValue(j) / tree.examplesSeen;
-				double sd = computeSD(tree.sumOfAttrSquares.getValue(j), tree.sumOfAttrValues.getValue(j), tree.examplesSeen);
-				if (inst.inputAttribute(j).isNumeric() && tree.examplesSeen > 1 && sd > 0.0000001)
-					normalizedInstance[j] = (inst.valueInputAttribute(j) - mean) / (sd);
-				else
-					normalizedInstance[j] = 0;
-			}
-			normalizedInstance[inst.numInputAttributes()] = tree.examplesSeen > 1 ? 1 : 0; // Value to be multiplied with the constant factor
-			return normalizedInstance;
-		}
-
-		/**
-		 * Output the prediction made by this perceptron on the given instance
-		 */
-		public double prediction(double[] instanceValues) {
-			double ret = 0;
-			for (int i = 0; i < instanceValues.length; i++)
-				ret += instanceValues[i] * weightAttribute[i];
-			return ret;
-		}
-
-		protected double prediction(Instance inst) {
-			double[] normalizedInstance = normalizedInstance(inst);
-			double normalizedPrediction = prediction(normalizedInstance);
-			return denormalizePrediction(normalizedPrediction);
-		}
-
-		private double denormalizePrediction(double normalizedPrediction) {
-			double mean = tree.sumOfValues / tree.examplesSeen;
-			double sd = computeSD(tree.sumOfSquares, tree.sumOfValues, tree.examplesSeen);
-			if (examplesSeen > 1) 
-				return normalizedPrediction * sd + mean;
-			else
-				return 0.0;
-		}
-		
-		public void getModelDescription(StringBuilder out, int indent) {
-	        StringUtils.appendIndented(out, indent, getClassNameString() + " =");
-			if (getModelContext() != null) {
-				for (int j = 0; j < getModelContext().numAttributes() - 1; j++) {
-					if (getModelContext().attribute(j).isNumeric()) {
-						out.append((j == 0 || weightAttribute[j] < 0) ? " " : " + ");
-		                out.append(String.format("%.4f", weightAttribute[j]));
-		                out.append(" * ");
-		                out.append(getAttributeNameString(j));
-		            }
-		        }
-				out.append(" + " + weightAttribute[getModelContext().numInputAttributes()]);
-			}
-	        StringUtils.appendNewline(out);
-		}
-	}
-
-
-	//endregion ================ CLASSES ================
-
-	//region ================ METHODS ================
-
-	// region --- Regressor methods
-	
-	public String getPurposeString() {
-		return "Implementation of the FIMT-DD tree as described by Ikonomovska et al.";
-	}
-
-	public void resetLearningImpl() {
-		this.treeRoot = null;
-		this.leafNodeCount = 0;
-		this.splitNodeCount = 0;
-		this.maxID = 0;
-		this.examplesSeen = 0;
-		this.sumOfValues = 0.0;
-		this.sumOfSquares = 0.0;
-
-		this.sumOfAttrValues = new DoubleVector();
-		this.sumOfAttrSquares = new DoubleVector();
-	}
-
-	public boolean isRandomizable() {
-		return true;
-	}
-
-	public void getModelDescription(StringBuilder out, int indent) {
-		if (treeRoot != null) treeRoot.describeSubtree(out, indent);
-	}
-
-	protected Measurement[] getModelMeasurementsImpl() {
-		return new Measurement[]{ 
-				new Measurement("tree size (leaves)", this.leafNodeCount)
-		};
-	}
-
-	public int calcByteSize() {
-		return (int) SizeOf.fullSizeOf(this);
-	}
-
-	public double[] getVotesForInstance(Instance inst) {
-		if (treeRoot == null) {
-			return new double[] {0};
-		}
-
-		double prediction = treeRoot.getPrediction(inst);
-
-		return new double[] {prediction};
-	}
-
-	public double normalizeTargetValue(double value) {
-		if (examplesSeen > 1) {
-			double sd = Math.sqrt((sumOfSquares - ((sumOfValues * sumOfValues)/examplesSeen))/examplesSeen);
-			double average = sumOfValues / examplesSeen;
-			if (sd > 0 && examplesSeen > 1)
-				return (value - average) / sd;
-			else
-				return 0.0;
-		}
-		return 0.0;
-	}
-
-	public double getNormalizedError(Instance inst, double prediction) {
-		double normalPrediction = normalizeTargetValue(prediction);
-		double normalValue = normalizeTargetValue(inst.classValue());
-		return Math.abs(normalValue - normalPrediction);
-	}
-
-
-	/**
-	 * Method for updating (training) the model using a new instance
-	 */
-	public void trainOnInstanceImpl(Instance inst) {
-		checkRoot();
-
-		double prediction = treeRoot.getPrediction(inst);
-		double normalError = getNormalizedError(inst, prediction);
-	
-		processInstance(inst, treeRoot, prediction, normalError, true, false);
-		
-		examplesSeen += inst.weight();
-		sumOfValues += inst.weight() * inst.classValue();
-		sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
-
-		for (int i = 0; i < inst.numAttributes() - 1; i++) {
-			int aIndex = modelAttIndexToInstanceAttIndex(i, inst);
-			sumOfAttrValues.addToValue(i, inst.weight() * inst.value(aIndex));
-			sumOfAttrSquares.addToValue(i, inst.weight() * inst.value(aIndex) * inst.value(aIndex));
-		}
-
-
-	}
-
-	public void processInstance(Instance inst, Node node, double prediction, double normalError, boolean growthAllowed, boolean inAlternate) {
-		Node currentNode = node;
-		while (true) {
-			if (currentNode instanceof LeafNode) {
-				((LeafNode) currentNode).learnFromInstance(inst, growthAllowed, prediction);
-				break;
-			} else {
-				currentNode.examplesSeen += inst.weight();
-				currentNode.sumOfAbsErrors += inst.weight() * normalError;
-				InnerNode iNode = (InnerNode) currentNode;
-				if (!inAlternate && iNode.alternateTree != null) {
-					boolean altTree = true;
-					double lossO = Math.pow(inst.classValue() - prediction, 2);
-					double lossA = Math.pow(inst.classValue() - iNode.alternateTree.getPrediction(inst), 2);
-					
-					// Loop for compatibility with bagging methods
-					for (int i = 0; i < inst.weight(); i++) {
-						iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
-						iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
-						iNode.lossExamplesSeen++;
-						
-						double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
-						iNode.lossSumQi += Qi;
-						iNode.lossNumQiTests += 1;
-					}
-					double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
-					double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
-					double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
-					
-					if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
-						iNode.previousWeight = iNode.lossExamplesSeen;
-						if (Qi > 0) {
-							// Switch the subtrees
-							Node parent = iNode.getParent();
-
-							if (parent != null) {
-								Node replacementTree = iNode.alternateTree;
-								parent.setChild(parent.getChildIndex(iNode), replacementTree);
-								if (growthAllowed) replacementTree.restartChangeDetection();
-							} else {
-								treeRoot = iNode.alternateTree;
-								treeRoot.restartChangeDetection();
-							}
-
-							currentNode = iNode.alternateTree;
-							currentNode.originalNode = null;
-							altTree = false;
-						} else if (QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * alternateTreeTMinOption.getValue()) || iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()) {
-							// Remove the alternate tree
-							iNode.alternateTree = null;
-							if (growthAllowed) iNode.restartChangeDetection();
-							altTree = false;
-						}
-					}
-
-					if (altTree) {
-						growthAllowed = false;
-						processInstance(inst, iNode.alternateTree, prediction, normalError, true, true);
-					}
-				}
-
-				if (false && iNode.changeDetection && !inAlternate) {
-					if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
-						iNode.initializeAlternateTree();
-						growthAllowed = false;
-					}
-				}
-				if (currentNode instanceof SplitNode) {
-					currentNode = ((SplitNode) currentNode).descendOneStep(inst);
-				} 
-			}
-		}
-	}
-
-	// endregion --- Regressor methods
-	
-	// region --- Object instatiation methods
-
-	protected FIMTDDNumericAttributeClassObserver newNumericClassObserver() {
-		return new FIMTDDNumericAttributeClassObserver();
-	}
-
-	protected SplitNode newSplitNode(InstanceConditionalTest splitTest) {
-		maxID++;
-		return new SplitNode(splitTest, this);
-	}
-
-	protected LeafNode newLeafNode() {
-		maxID++;
-		return new LeafNode(this);
-	}
-
-	protected FIMTDDPerceptron newLeafModel() {
-		return new FIMTDDPerceptron(this);
-	}
-
-	//endregion --- Object instatiation methods
-	
-	// region --- Processing methods
-	
-	protected void checkRoot() {
-		if (treeRoot == null) {
-			treeRoot = newLeafNode();
-			leafNodeCount = 1;
-		}
-	}
-
-	public static double computeHoeffdingBound(double range, double confidence, double n) {
-		return Math.sqrt(( (range * range) * Math.log(1 / confidence)) / (2.0 * n));
-	}
-
-	public boolean buildingModelTree() {
-		return !regressionTreeOption.isSet();
-	}
-
-	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
-
-		// Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
- 		SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
-
-		// Using this criterion, find the best split per attribute and rank the results
-		AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion);
-		Arrays.sort(bestSplitSuggestions);
-
-		// Declare a variable to determine if any of the splits should be performed
-		boolean shouldSplit = false;
-
-		// If only one split was returned, use it
-		if (bestSplitSuggestions.length < 2) {
-			shouldSplit = bestSplitSuggestions.length > 0;
-		} else { // Otherwise, consider which of the splits proposed may be worth trying
-
-			// Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
-			// to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
-			double hoeffdingBound = computeHoeffdingBound(1, this.splitConfidenceOption.getValue(), node.examplesSeen);
-			// Determine the top two ranked splitting suggestions
-			AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-			AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
-
-			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
-			// as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
-			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
-			// splitting should occur.
-			// Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
-			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
-			// competing attributes are equally good, and the split will be made on the one with the higher SDR value.
-			if ((secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) || (hoeffdingBound < this.tieThresholdOption.getValue())) {
-				shouldSplit = true;
-			}
-			// If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
-			else {
-				for (int i = 0; i < node.attributeObservers.size(); i++) {
-					FIMTDDNumericAttributeClassObserver obs = node.attributeObservers.get(i);
-					if (obs != null) {
-						obs.removeBadSplits(splitCriterion, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound);    
-					}
-				}
-			}
-//			if (hoeffdingBound < this.tieThresholdOption.getValue() && !(secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound)) {
-//				System.out.println("Forced to split due to tie at " + this.examplesSeen);
-//				System.out.println(SizeOf.fullSizeOf(node.attributeObservers) / 1000000.0);
-//			}
-		}
-
-		// If the splitting criterion were met, split the current node using the chosen attribute test, and
-		// make two new branches leading to (empty) leaves
-		if (shouldSplit) {
-//			System.out.println("splitting node");
-//			System.out.println(SizeOf.fullSizeOf(node.attributeObservers) / 1000000.0);
-//			if (node.parent == null) {
-//				System.out.println("splitting root node at " + this.examplesSeen);
-//			}
-			AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-						
-			SplitNode newSplit = newSplitNode(splitDecision.splitTest);
-			newSplit.copyStatistics(node);
-			newSplit.changeDetection = node.changeDetection;
-			newSplit.ID = node.ID;
-			leafNodeCount--;
-			for (int i = 0; i < splitDecision.numSplits(); i++) {
-				LeafNode newChild = newLeafNode();
-				if (buildingModelTree()) {
-					// Copy the splitting node's perceptron to it's children
-					newChild.learningModel = new FIMTDDPerceptron((FIMTDDPerceptron) node.learningModel);
-					
-				}
-				newChild.changeDetection = node.changeDetection;
-				newChild.setParent(newSplit);
-				newSplit.setChild(i, newChild);
-				leafNodeCount++;
-			}
-			if (parent == null && node.originalNode == null) {
-				treeRoot = newSplit;
-			} else if (parent == null && node.originalNode != null) {
-				node.originalNode.alternateTree = newSplit;
-			} else {
-				((SplitNode) parent).setChild(parentIndex, newSplit);
-				newSplit.setParent(parent);
-			}
-			
-			splitNodeCount++;
-		}
-	}
-	
-	public double computeSD(double squaredVal, double val, double size) {
-		if (size > 1)
-			return Math.sqrt((squaredVal - ((val * val) / size)) / size);
-		else
-			return 0.0;
-	}
-	
-	public double scalarProduct(DoubleVector u, DoubleVector v) {
-		double ret = 0.0;
-		for (int i = 0; i < Math.max(u.numValues(), v.numValues()); i++) {
-			ret += u.getValue(i) * v.getValue(i);
-		}
-		return ret;
-	}
-	//endregion --- Processing methods
-	
-	//endregion ================ METHODS ================
-}
-
-=======
 /*
  *    FIMTDD.java
  *    Copyright (C) 2015 Jožef Stefan Institute, Ljubljana, Slovenia
@@ -1103,7 +109,7 @@ public class FIMTDD extends AbstractClassifier implements Regressor {
 
 	public FloatOption learningRatioOption = new FloatOption(
 			"learningRatio", 'l', "Learning ratio to used for training the Perceptrons in the leaves.",
-			0.02, 0, 1.00);
+			0.003, 0, 1.00);
 
 	public FloatOption learningRateDecayFactorOption = new FloatOption(
 			"learningRatioDecayFactor", 'd', "Learning rate decay factor (not used when learning rate is constant).",
@@ -1229,6 +235,9 @@ public static class LeafNode extends Node {
 
 		private static final long serialVersionUID = 1L;
 
+		public double errorModel = 0.0;
+		public double errorTargetMean = 0.0;
+		
 		// Perceptron model that carries out the actual learning in each node
 		public FIMTDDPerceptron learningModel;
 
@@ -1270,7 +279,7 @@ protected boolean skipInLevelCount() {
 		 * and also prevents the class value from being truncated to an int when it is passed to the
 		 * attribute observer
 		 */
-		public void learnFromInstance(Instance inst, boolean growthAllowed) {
+		public void learnFromInstance(Instance inst, boolean growthAllowed, double prediction) {
 			//The prediction must be calculated here -- it may be different from the tree's prediction due to alternate trees
 			
 			// Update the statistics for this node
@@ -1284,9 +293,17 @@ public void learnFromInstance(Instance inst, boolean growthAllowed) {
 			sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
 
 			// sum of absolute errors
-			sumOfAbsErrors += inst.weight() * Math.abs(tree.normalizeTargetValue(Math.abs(inst.classValue() - getPrediction(inst))));
-
-			if (tree.buildingModelTree()) learningModel.updatePerceptron(inst);
+			sumOfAbsErrors += inst.weight() * Math.abs(tree.normalizeTargetValue(Math.abs(inst.classValue() - prediction)));
+			
+			if (tree.buildingModelTree()) {
+				double predictionModel = getPredictionModel(inst);
+				double predictionTargetMean = getPredictionTargetMean(inst);
+				
+				errorModel = errorModel * 0.95 + Math.abs(predictionModel - inst.classValue());
+				errorTargetMean = errorTargetMean * 0.95 + Math.abs(predictionTargetMean - inst.classValue());
+				
+				learningModel.updatePerceptron(inst);
+			}
 
 			for (int i = 0; i < inst.numAttributes() - 1; i++) {
 				int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
@@ -1304,7 +321,7 @@ public void learnFromInstance(Instance inst, boolean growthAllowed) {
 			}
 
 			if (growthAllowed) {
-				checkForSplit(tree);
+				checkForSplit();
 			}
 		}
 
@@ -1348,10 +365,14 @@ public double getPredictionTargetMean(Instance inst) {
 		}
 
 		public double getPrediction(Instance inst) {
-			return (tree.buildingModelTree()) ? getPredictionModel(inst) : getPredictionTargetMean(inst);
+			if (tree.buildingModelTree()) {
+				//return getPredictionModel(inst);
+				return (errorModel < errorTargetMean) ? getPredictionModel(inst) : getPredictionTargetMean(inst);
+			} else
+				return getPredictionTargetMean(inst);
 		}
 		
-		public void checkForSplit(FIMTDD tree) {
+		public void checkForSplit() {
 			// If it has seen Nmin examples since it was last tested for splitting, attempt a split of this node
 			if (examplesSeen - examplesSeenAtLastSplitEvaluation >= tree.gracePeriodOption.getValue()) {
 				int index = (parent != null) ? parent.getChildIndex(this) : 0;
@@ -1367,7 +388,7 @@ public void describeSubtree(StringBuilder out, int indent) {
 			if (tree.buildingModelTree()) {
 				learningModel.getModelDescription(out, 0);
 			} else {
-				out.append(tree.getClassNameString() + " = " + String.format("%.4f", (sumOfValues / examplesSeen)));
+				out.append(tree.getClassNameString() + " = " + String.format("%.4f", sumOfValues / examplesSeen));
 				StringUtils.appendNewline(out);
 			}
 		}
@@ -1520,52 +541,41 @@ public class FIMTDDPerceptron implements Serializable {
 		protected FIMTDD tree;
 		
 		// The Perception weights 
-		protected DoubleVector weightAttribute = new DoubleVector(); 
-
-		protected double sumOfValues;
-		protected double sumOfSquares;
+		protected double[] weightAttribute; 
 
 		// The number of instances contributing to this model
 		protected double instancesSeen = 0;
 
-		// If the model should be reset or not
-		protected boolean reset;
-
 		public String getPurposeString() {
 			return "A perceptron regressor as specified by Ikonomovska et al. used for FIMTDD";
 		}
 
 		public FIMTDDPerceptron(FIMTDDPerceptron original) {
 			this.tree = original.tree;
-			weightAttribute = (DoubleVector) original.weightAttribute.copy();
-			reset = false;
+			weightAttribute = original.weightAttribute.clone();
 		}
 
 		public FIMTDDPerceptron(FIMTDD tree) {
 			this.tree = tree;
-			reset = true;
-		}
-
+			initializeWeights();
 
-		public DoubleVector getWeights() {
-			return weightAttribute;
 		}
 
+		public void initializeWeights() {
+			weightAttribute = new double[tree.getModelContext().numInputAttributes()+1];
+			instancesSeen = 0;
+			for (int j = 0; j < tree.getModelContext().numInputAttributes()+1; j++) {
+				// The last index corresponds to the constant b
+				weightAttribute[j] = 2 * tree.classifierRandom.nextDouble() - 1;
+			}
+			normalizeWeights();
+		}
+		
 		/**
 		 * Update the model using the provided instance
 		 */
 		public void updatePerceptron(Instance inst) {
 
-			// Initialize perceptron if necessary   
-			if (reset == true) {
-				reset = false;
-				weightAttribute = new DoubleVector();
-				instancesSeen = 0;
-				for (int j = 0; j < inst.numAttributes(); j++) { // The last index corresponds to the constant b
-					weightAttribute.setValue(j, 2 * tree.classifierRandom.nextDouble() - 1);
-				}
-			}
-
 			// Update attribute statistics
 			instancesSeen += inst.weight();
 
@@ -1577,63 +587,70 @@ public void updatePerceptron(Instance inst) {
 				learningRatio = learningRatioOption.getValue() / (1 + instancesSeen * tree.learningRateDecayFactorOption.getValue());
 			}
 
-			sumOfValues += inst.weight() * inst.classValue();
-			sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
-
 			// Loop for compatibility with bagging methods 
 			for (int i = 0; i < (int) inst.weight(); i++) {
 				updateWeights(inst, learningRatio);
 			}
+		
 		}
 
 		public void updateWeights(Instance inst, double learningRatio) {
 			// Compute the normalized instance and the delta
-			DoubleVector normalizedInstance = normalizedInstance(inst); 
+			double[] normalizedInstance = normalizedInstance(inst); 
 			double normalizedPrediction = prediction(normalizedInstance);
 			double normalizedValue = tree.normalizeTargetValue(inst.classValue());
 			double delta = normalizedValue - normalizedPrediction;
-			normalizedInstance.scaleValues(delta * learningRatio);
+			for (int i = 0; i < weightAttribute.length; i++) {
+				weightAttribute[i] += delta * learningRatio * normalizedInstance[i];
+			}
 			
-			weightAttribute.addValues(normalizedInstance);
+			normalizeWeights();
+		}
+		
+		public void normalizeWeights() {
+			double sum = 0;
+			for (int i = 0; i < this.weightAttribute.length; i++)
+				sum += Math.abs(weightAttribute[i]);
+			for (int i = 0; i < this.weightAttribute.length; i++)
+				weightAttribute[i] /= sum;
 		}
 
-		public DoubleVector normalizedInstance(Instance inst) {
+		public double[] normalizedInstance(Instance inst) {
 			// Normalize Instance
-			DoubleVector normalizedInstance = new DoubleVector();
-			for (int j = 0; j < inst.numAttributes() - 1; j++) {
-				int instAttIndex = modelAttIndexToInstanceAttIndex(j, inst);
+			double[] normalizedInstance = new double[inst.numInputAttributes()+1];
+			for (int j = 0; j < inst.numInputAttributes(); j++) {
 				double mean = tree.sumOfAttrValues.getValue(j) / tree.examplesSeen;
 				double sd = computeSD(tree.sumOfAttrSquares.getValue(j), tree.sumOfAttrValues.getValue(j), tree.examplesSeen);
-				if (inst.attribute(instAttIndex).isNumeric() && tree.examplesSeen > 1 && sd > 0)
-					normalizedInstance.setValue(j, (inst.value(instAttIndex) - mean) / (3 * sd));
+				if (inst.inputAttribute(j).isNumeric() && tree.examplesSeen > 1 && sd > 0.0000001)
+					normalizedInstance[j] = (inst.valueInputAttribute(j) - mean) / (sd);
 				else
-					normalizedInstance.setValue(j, 0);
+					normalizedInstance[j] = 0;
 			}
-			if (tree.examplesSeen > 1)
-				normalizedInstance.setValue(inst.numAttributes() - 1, 1.0); // Value to be multiplied with the constant factor
-			else
-				normalizedInstance.setValue(inst.numAttributes() - 1, 0.0);
+			normalizedInstance[inst.numInputAttributes()] = tree.examplesSeen > 1 ? 1 : 0; // Value to be multiplied with the constant factor
 			return normalizedInstance;
 		}
 
 		/**
 		 * Output the prediction made by this perceptron on the given instance
 		 */
-		public double prediction(DoubleVector instanceValues) {
-			return scalarProduct(weightAttribute, instanceValues);
+		public double prediction(double[] instanceValues) {
+			double ret = 0;
+			for (int i = 0; i < instanceValues.length; i++)
+				ret += instanceValues[i] * weightAttribute[i];
+			return ret;
 		}
 
 		protected double prediction(Instance inst) {
-			DoubleVector normalizedInstance = normalizedInstance(inst);
+			double[] normalizedInstance = normalizedInstance(inst);
 			double normalizedPrediction = prediction(normalizedInstance);
-			return denormalizePrediction(normalizedPrediction, tree);
+			return denormalizePrediction(normalizedPrediction);
 		}
 
-		private double denormalizePrediction(double normalizedPrediction, FIMTDD tree) {
+		private double denormalizePrediction(double normalizedPrediction) {
 			double mean = tree.sumOfValues / tree.examplesSeen;
 			double sd = computeSD(tree.sumOfSquares, tree.sumOfValues, tree.examplesSeen);
 			if (examplesSeen > 1) 
-				return normalizedPrediction * sd * 3 + mean;
+				return normalizedPrediction * sd + mean;
 			else
 				return 0.0;
 		}
@@ -1643,13 +660,13 @@ public void getModelDescription(StringBuilder out, int indent) {
 			if (getModelContext() != null) {
 				for (int j = 0; j < getModelContext().numAttributes() - 1; j++) {
 					if (getModelContext().attribute(j).isNumeric()) {
-						out.append((j == 0 || weightAttribute.getValue(j) < 0) ? " " : " + ");
-		                out.append(String.format("%.4f", weightAttribute.getValue(j)));
+						out.append((j == 0 || weightAttribute[j] < 0) ? " " : " + ");
+		                out.append(String.format("%.4f", weightAttribute[j]));
 		                out.append(" * ");
 		                out.append(getAttributeNameString(j));
 		            }
 		        }
-				out.append(" + " + weightAttribute.getValue((getModelContext().numAttributes() - 1)));
+				out.append(" + " + weightAttribute[getModelContext().numInputAttributes()]);
 			}
 	        StringUtils.appendNewline(out);
 		}
@@ -1712,7 +729,7 @@ public double normalizeTargetValue(double value) {
 			double sd = Math.sqrt((sumOfSquares - ((sumOfValues * sumOfValues)/examplesSeen))/examplesSeen);
 			double average = sumOfValues / examplesSeen;
 			if (sd > 0 && examplesSeen > 1)
-				return (value - average) / (3 * sd);
+				return (value - average) / sd;
 			else
 				return 0.0;
 		}
@@ -1732,6 +749,11 @@ public double getNormalizedError(Instance inst, double prediction) {
 	public void trainOnInstanceImpl(Instance inst) {
 		checkRoot();
 
+		double prediction = treeRoot.getPrediction(inst);
+		double normalError = getNormalizedError(inst, prediction);
+	
+		processInstance(inst, treeRoot, prediction, normalError, true, false);
+		
 		examplesSeen += inst.weight();
 		sumOfValues += inst.weight() * inst.classValue();
 		sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
@@ -1742,20 +764,19 @@ public void trainOnInstanceImpl(Instance inst) {
 			sumOfAttrSquares.addToValue(i, inst.weight() * inst.value(aIndex) * inst.value(aIndex));
 		}
 
-		double prediction = treeRoot.getPrediction(inst);
-		processInstance(inst, treeRoot, prediction, getNormalizedError(inst, prediction), true, false);
+
 	}
 
 	public void processInstance(Instance inst, Node node, double prediction, double normalError, boolean growthAllowed, boolean inAlternate) {
 		Node currentNode = node;
 		while (true) {
 			if (currentNode instanceof LeafNode) {
-				((LeafNode) currentNode).learnFromInstance(inst, growthAllowed);
+				((LeafNode) currentNode).learnFromInstance(inst, growthAllowed, prediction);
 				break;
 			} else {
 				currentNode.examplesSeen += inst.weight();
 				currentNode.sumOfAbsErrors += inst.weight() * normalError;
-				SplitNode iNode = (SplitNode) currentNode;
+				InnerNode iNode = (InnerNode) currentNode;
 				if (!inAlternate && iNode.alternateTree != null) {
 					boolean altTree = true;
 					double lossO = Math.pow(inst.classValue() - prediction, 2);
@@ -1779,11 +800,11 @@ public void processInstance(Instance inst, Node node, double prediction, double
 						iNode.previousWeight = iNode.lossExamplesSeen;
 						if (Qi > 0) {
 							// Switch the subtrees
-							Node parent = currentNode.getParent();
+							Node parent = iNode.getParent();
 
 							if (parent != null) {
 								Node replacementTree = iNode.alternateTree;
-								parent.setChild(parent.getChildIndex(currentNode), replacementTree);
+								parent.setChild(parent.getChildIndex(iNode), replacementTree);
 								if (growthAllowed) replacementTree.restartChangeDetection();
 							} else {
 								treeRoot = iNode.alternateTree;
@@ -1793,10 +814,7 @@ public void processInstance(Instance inst, Node node, double prediction, double
 							currentNode = iNode.alternateTree;
 							currentNode.originalNode = null;
 							altTree = false;
-						} else if (
-								(QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * this.gracePeriodOption.getValue()))
-								|| iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()
-								) {
+						} else if (QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * alternateTreeTMinOption.getValue()) || iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()) {
 							// Remove the alternate tree
 							iNode.alternateTree = null;
 							if (growthAllowed) iNode.restartChangeDetection();
@@ -1813,6 +831,7 @@ public void processInstance(Instance inst, Node node, double prediction, double
 				if (iNode.changeDetection && !inAlternate) {
 					if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
 						iNode.initializeAlternateTree();
+						growthAllowed = false;
 					}
 				}
 				if (currentNode instanceof SplitNode) {
@@ -1864,8 +883,9 @@ public boolean buildingModelTree() {
 	}
 
 	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
+
 		// Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
-		SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
+ 		SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
 
 		// Using this criterion, find the best split per attribute and rank the results
 		AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion);
@@ -1911,7 +931,7 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 		// make two new branches leading to (empty) leaves
 		if (shouldSplit) {
 			AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-
+						
 			SplitNode newSplit = newSplitNode(splitDecision.splitTest);
 			newSplit.copyStatistics(node);
 			newSplit.changeDetection = node.changeDetection;
@@ -1959,6 +979,4 @@ public double scalarProduct(DoubleVector u, DoubleVector v) {
 	//endregion --- Processing methods
 	
 	//endregion ================ METHODS ================
-}
-
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/trees/ORTO.java b/moa/src/main/java/moa/classifiers/trees/ORTO.java
index 2745dcc7e..2f7ca3d52 100644
--- a/moa/src/main/java/moa/classifiers/trees/ORTO.java
+++ b/moa/src/main/java/moa/classifiers/trees/ORTO.java
@@ -35,16 +35,11 @@
 import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
 import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
-<<<<<<< HEAD
-import moa.classifiers.trees.FIMTDD.InnerNode;
-import moa.classifiers.trees.FIMTDD.Node;
+
 import moa.core.AutoExpandVector;
 import moa.core.Measurement;
 import moa.core.StringUtils;
-=======
-import moa.core.AutoExpandVector;
-import moa.core.Measurement;
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+
 
 /*
  * Implementation of ORTO, option trees for data streams.
@@ -127,15 +122,9 @@ public int getNumSubtrees() {
 
 		public int directionForBestTree() {
 			int d = 0;
-<<<<<<< HEAD
-			double min = Double.MAX_VALUE;
-			for (int i = 0; i < numChildren(); i++) {
-				double tmp = getFFRatio(i);
-=======
 			double tmp = 0.0, min = Double.MAX_VALUE;
 			for (int i = 0; i < children.size(); i++) {
 				tmp = getFFRatio(i);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				if (tmp < min) {
 					min = tmp;
 					d = i;
@@ -144,38 +133,22 @@ public int directionForBestTree() {
 			return d;
 		}
 
-<<<<<<< HEAD
 		public double getPrediction(Instance inst) {
-=======
-		public double getPrediction(Instance inst, ORTO tree) {
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 			double[] predictions = new double[numChildren()];
 			for (int i = 0; i < numChildren(); i++) {
 				predictions[i] = getChild(i).getPrediction(inst);
 			}
-<<<<<<< HEAD
 			return aggregate(predictions);
 		}
 
 		private double aggregate(double[] predictions) {
 			if (((ORTO) tree).optionNodeAggregationOption.getChosenIndex() == 0) { // Average
-=======
-			return aggregate(predictions, tree);
-		}
-
-		private double aggregate(double[] predictions, ORTO tree) {
-			if (tree.optionNodeAggregationOption.getChosenIndex() == 0) { // Average
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				double sum = 0.0;
 				for (int i = 0; i < predictions.length; i++) {
 					sum += predictions[i];
 				}
 				return sum / predictions.length;
-<<<<<<< HEAD
 			} else if (((ORTO) tree).optionNodeAggregationOption.getChosenIndex() == 1) {
-=======
-			} else if (tree.optionNodeAggregationOption.getChosenIndex() == 1) {
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				int d = directionForBestTree();
 				return predictions[d];
 			} else {
@@ -190,7 +163,6 @@ public double getFFRatio(int childIndex) {
 		protected boolean skipInLevelCount() {
 			return true;
 		}
-<<<<<<< HEAD
 		
 		@Override
 		public void describeSubtree(StringBuilder out, int indent) {
@@ -203,8 +175,7 @@ public void describeSubtree(StringBuilder out, int indent) {
 				split.describeSubtree(out, indent + 2);
 			}
 		}
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+
 	}
 
 	//endregion ================ CLASSES ================
@@ -239,11 +210,7 @@ public void processInstance(Instance inst, Node node, double prediction, double
 			Node currentNode = node;
 			while (true) {
 				if (currentNode instanceof LeafNode) {
-<<<<<<< HEAD
 					((LeafNode) currentNode).learnFromInstance(inst, growthAllowed, prediction);
-=======
-					((LeafNode) currentNode).learnFromInstance(inst, growthAllowed);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 					break;
 				} else {
 					currentNode.examplesSeen += inst.weight();
@@ -252,11 +219,7 @@ public void processInstance(Instance inst, Node node, double prediction, double
 					if (!inAlternate && iNode.alternateTree != null) {
 						boolean altTree = true;
 						double lossO = Math.pow(inst.classValue() - prediction, 2);
-<<<<<<< HEAD
 						double lossA = Math.pow(inst.classValue() - iNode.alternateTree.getPrediction(inst), 2);
-=======
-						double lossA = Math.pow(inst.classValue() - currentNode.alternateTree.getPrediction(inst), 2);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 						
 						// Loop for compatibility with bagging methods
 						for (int i = 0; i < inst.weight(); i++) {
@@ -276,11 +239,7 @@ public void processInstance(Instance inst, Node node, double prediction, double
 							iNode.previousWeight = iNode.lossExamplesSeen;
 							if (Qi > 0) {
 								// Switch the subtrees
-<<<<<<< HEAD
 								Node parent = iNode.getParent();
-=======
-								Node parent = currentNode.parent;
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 								
 								if (parent != null) {
 									Node replacementTree = iNode.alternateTree;
@@ -290,11 +249,7 @@ public void processInstance(Instance inst, Node node, double prediction, double
 									treeRoot = iNode.alternateTree;
 									treeRoot.restartChangeDetection();
 								}
-<<<<<<< HEAD
 								optionNodeCount += iNode.alternateTree.getNumSubtrees() - iNode.getNumSubtrees();
-=======
-								optionNodeCount += currentNode.alternateTree.getNumSubtrees() - currentNode.getNumSubtrees();
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 								removeExcessTrees();
 										
 								currentNode = iNode.alternateTree;
@@ -309,11 +264,7 @@ public void processInstance(Instance inst, Node node, double prediction, double
 						}
 						if (altTree) {
 							growthAllowed = false; // this is the growth of the original tree
-<<<<<<< HEAD
 							processInstance(inst, iNode.alternateTree, prediction, normalError, true, true); // growth is allowed in the alt tree
-=======
-							processInstance(inst, currentNode.alternateTree, prediction, normalError, true, true); // growth is allowed in the alt tree
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 						} else if (currentNode instanceof OptionNode) {
 							// this happens when an option node is switched into the tree
 							for (Node child : ((OptionNode) currentNode).children) {
@@ -341,35 +292,23 @@ public void processInstance(Instance inst, Node node, double prediction, double
 	}
 	
 	public void processInstanceOptionNode(Instance inst, OptionNode node, double prediction, double normalError, boolean growthAllowed, boolean inAlternate) {
-<<<<<<< HEAD
 		node.examplesSeen += inst.weight();
 		node.sumOfAbsErrors += inst.weight() * normalError;
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+
 		if (node.changeDetection) {
 			double error = Math.abs(prediction - inst.classValue());
 			node.sumOfAbsErrors += error;
 			
 			if (((InnerNode) node).PageHinckleyTest(error - node.sumOfAbsErrors / node.examplesSeen + PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
 				node.initializeAlternateTree();
-<<<<<<< HEAD
 				growthAllowed = false;
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 			}
 		}
 
 		for (Node child : node.children) {
 			int index = node.getChildIndex(child);
 			double childPrediction = child.getPrediction(inst);
-<<<<<<< HEAD
-			node.optionFFSeen[index] = node.optionFFSeen[index] * optionFadingFactorOption.getValue() + 1;
-			node.optionFFSSL[index] = node.optionFFSSL[index] * optionFadingFactorOption.getValue() + Math.pow(childPrediction - inst.classValue(), 2);
-		}
 
-		for (Node child : node.children) {
-			processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed, inAlternate);
-=======
 			// Loop for compatibility with bagging methods
 			for (int i = 0; i < inst.weight(); i++) {
 				node.optionFFSeen[index] = node.optionFFSeen[index] * optionFadingFactorOption.getValue() + 1;
@@ -379,7 +318,6 @@ public void processInstanceOptionNode(Instance inst, OptionNode node, double pre
 
 		for (Node child : node.children) {
 			processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed && node.alternateTree == null, inAlternate);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		}
 	}
 	
@@ -397,10 +335,6 @@ protected OptionNode newOptionNode() {
 	// region --- Processing methods
 
 	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
-<<<<<<< HEAD
-
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		// Initialize the split criterion 
 		SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(splitCriterionOption);
 
@@ -408,11 +342,7 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 		AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion);
 		List<AttributeSplitSuggestion> acceptedSplits = new LinkedList<AttributeSplitSuggestion>();
 		Arrays.sort(bestSplitSuggestions);
-<<<<<<< HEAD
-		
-=======
 
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		// Declare a variable to determine the number of splits to be performed
 		int numSplits = 0;
 
@@ -430,10 +360,7 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 			AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
 			AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
 
-<<<<<<< HEAD
-			
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+
 			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
 			// as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
 			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
@@ -445,7 +372,6 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 				numSplits = 1;
 				acceptedSplits.add(bestSuggestion);
 			} else if (numTrees < maxTreesOption.getValue() && node.getLevel() <= maxOptionLevelOption.getValue()) {
-<<<<<<< HEAD
 				for (int i = 0; i < bestSplitSuggestions.length; i++) {
 					AttributeSplitSuggestion suggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1 - i];
 					if (suggestion.merit / bestSuggestion.merit >= 1 - hoeffdingBound) {
@@ -456,15 +382,7 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 					}
 						
 				}
-				
-=======
-				for (AttributeSplitSuggestion suggestion : bestSplitSuggestions) {
-					if (suggestion.merit / bestSuggestion.merit >= 1 - hoeffdingBound) {
-						numSplits++;
-						acceptedSplits.add(suggestion);
-					}
-				}
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+
 			} else if (hoeffdingBound < tieThresholdOption.getValue()) {
 				numSplits = 1;
 				acceptedSplits.add(bestSplitSuggestions[0]);
@@ -483,11 +401,7 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 		if (numSplits > 0) {
 			double optionFactor = numSplits * Math.pow(optionDecayFactorOption.getValue(), (double) node.getLevel());
 
-<<<<<<< HEAD
-			if (numSplits == 1 || optionFactor < 2.0 || maxTreesOption.getValue() - numTrees <= 0) {
-=======
 			if (numSplits == 1 || optionFactor < 2.0 || maxTreesOption.getValue() - numTrees <= 1) {
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				AttributeSplitSuggestion splitDecision = acceptedSplits.get(0);
 				SplitNode newSplit = newSplitNode(splitDecision.splitTest);
 				for (int i = 0; i < splitDecision.numSplits(); i++) {
@@ -498,19 +412,12 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 				leafNodeCount--;
 				innerNodeCount++;
 				leafNodeCount += splitDecision.numSplits();
-<<<<<<< HEAD
 				if (parent == null && node.originalNode == null) {
 					treeRoot = newSplit;
 				} else if (parent == null && node.originalNode != null) {
 					node.originalNode.alternateTree = newSplit;
 				} else {
 					parent.setChild(parentIndex, newSplit);
-=======
-				if (parent == null) {
-					treeRoot = newSplit;
-				} else {
-					parent.setChild(parent.getChildIndex(node), newSplit);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 					newSplit.setParent(parent);
 				}
 			} else {
@@ -544,11 +451,7 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 				if (parent == null) {
 					treeRoot = optionNode;
 				} else {
-<<<<<<< HEAD
 					parent.setChild(parentIndex, optionNode);
-=======
-					parent.setChild(parent.getChildIndex(node), optionNode);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 					optionNode.setParent(parent);
 				}
 
@@ -631,8 +534,4 @@ protected void removeExcessTrees() {
 	// endregion --- Option tree methods
 	
 	//endregion ================ METHODS ================
-<<<<<<< HEAD
-}
-=======
 }
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
diff --git a/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java b/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
index 4202599c6..61f2ee877 100644
--- a/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
+++ b/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
@@ -154,7 +154,6 @@ protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
 		int secondsElapsed = 0;
 		monitor.setCurrentActivity("Evaluating learner...", -1.0);
 
-<<<<<<< HEAD
 		File dumpFile = this.dumpFileOption.getFile();
 		PrintStream immediateResultStream = null;
 		if (dumpFile != null) {
@@ -208,63 +207,7 @@ protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
 					sb.append("Out " + i + ": " + ((Instance) trainInst.getData()).valueOutputAttribute(i) + " ");
 				}
 				outputPredictionResultStream.println(prediction + "," + sb.toString());
-			}
-=======
-        File dumpFile = this.dumpFileOption.getFile();
-        PrintStream immediateResultStream = null;
-        if (dumpFile != null) {
-            try {
-                if (dumpFile.exists()) {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile, true), true);
-                } else {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile), true);
-                }
-            } catch (Exception ex) {
-                throw new RuntimeException(
-                        "Unable to open immediate result file: " + dumpFile, ex);
-            }
-        }
-        //File for output predictions
-        File outputPredictionFile = this.outputPredictionFileOption.getFile();
-        PrintStream outputPredictionResultStream = null;
-        if (outputPredictionFile != null) {
-            try {
-                if (outputPredictionFile.exists()) {
-                    outputPredictionResultStream = new PrintStream(
-                            new FileOutputStream(outputPredictionFile, true), true);
-                } else {
-                    outputPredictionResultStream = new PrintStream(
-                            new FileOutputStream(outputPredictionFile), true);
-                }
-            } catch (Exception ex) {
-                throw new RuntimeException(
-                        "Unable to open prediction result file: " + outputPredictionFile, ex);
-            }
-        }
-        boolean firstDump = true;
-        boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
-        long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-        long lastEvaluateStartTime = evaluateStartTime;
-        double RAMHours = 0.0;
-        while (stream.hasMoreInstances()
-                && ((maxInstances < 0) || (instancesProcessed < maxInstances))
-                && ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
-            Example trainInst = stream.nextInstance();
-            Example testInst = (Example) trainInst; //.copy();
-            //testInst.setClassMissing();
-            //double[] prediction = learner.getVotesForInstance(testInst);
-            Prediction prediction = learner.getPredictionForInstance(testInst);
-            // Output prediction
-            if (outputPredictionFile != null) {
-            	StringBuilder sb = new StringBuilder();
-            	for (int i = 0; i < ((Instance) trainInst.getData()).numOutputAttributes(); i++) {
-            		sb.append("Out " + i + ": " + ((Instance) trainInst.getData()).valueOutputAttribute(i) + " ");
-            	}
-                outputPredictionResultStream.println(prediction + "," + sb.toString());
-            }
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+			}
 
 			//evaluator.addClassificationAttempt(trueClass, prediction, testInst.weight());
 			evaluator.addResult(testInst, prediction);
diff --git a/pom.xml b/pom.xml
index 052fa8916..2320c5ec3 100644
--- a/pom.xml
+++ b/pom.xml
@@ -4,7 +4,7 @@
   <groupId>nz.ac.waikato.cms.moa</groupId>
   <artifactId>moa-pom</artifactId>
   <packaging>pom</packaging>
-  <version>2012.09-SNAPSHOT</version>
+  <version>2014.04</version>
 
   <name>MOA: meta-package</name>
   <description>
diff --git a/weka-package/pom.xml b/weka-package/pom.xml
index 6cd73530c..693727f08 100644
--- a/weka-package/pom.xml
+++ b/weka-package/pom.xml
@@ -6,7 +6,7 @@
   <parent>
     <groupId>nz.ac.waikato.cms.moa</groupId>
     <artifactId>moa-pom</artifactId>
-    <version>2012.09-SNAPSHOT</version>
+    <version>2014.04</version>
   </parent>
 
   <artifactId>weka-package</artifactId>

From 483366b26ca357ec80022ba6bb3966199aaf9d75 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Wed, 23 Mar 2016 11:06:20 +0100
Subject: [PATCH 11/33] Intermediary commit for multi-label changes

---
 .../labs/samoa/instances/ArffLoader.java      |  15 +-
 .../yahoo/labs/samoa/instances/Attribute.java | 594 ++++++++++--------
 .../samoa/instances/AttributeStructure.java   |   7 +
 .../labs/samoa/instances/DAGStructure.java    |  86 +++
 .../instances/HierarhicalInstanceImpl.java    | 452 +++++++++++++
 .../yahoo/labs/samoa/instances/Instance.java  |  11 +
 .../labs/samoa/instances/InstanceImpl.java    |  14 +-
 .../samoa/instances/InstanceInformation.java  |   9 +
 .../labs/samoa/instances/InstancesHeader.java |   4 +
 .../com/yahoo/labs/samoa/instances/Range.java |   4 +-
 ...lInstance.java => StructuredInstance.java} |   4 +-
 .../moa/classifiers/AbstractClassifier.java   |  11 +-
 .../AbstractMultiLabelLearner.java            |  10 +-
 .../moa/classifiers/MultiLabelLearner.java    |   6 +-
 .../java/moa/classifiers/meta/OzaBag.java     |   2 +-
 .../LocalMultiTargetClassifier.java           |   8 +-
 .../multilabel/MEKAClassifier.java            |  10 +-
 .../multilabel/MajorityLabelset.java          |   6 +-
 .../multilabel/MultilabelHoeffdingTree.java   |   8 +-
 .../splitcriteria/ICVarianceReduction.java    |   1 -
 .../WeightedICVarianceReduction.java          |  46 ++
 .../classifiers/multilabel/meta/MLOzaBag.java |   8 +-
 .../multilabel/meta/MLOzaBagAdwin.java        |   8 +-
 .../classifiers/multilabel/meta/MTOzaBag.java |  40 +-
 .../multilabel/trees/ISOUPOptionTree.java     | 319 +++++++++-
 .../multilabel/trees/ISOUPTree.java           | 195 ++++--
 .../BasicMultiTargetRegressor.java            |   8 +-
 .../functions/MultiTargetNoChange.java        |   6 +-
 .../rules/core/NominalRulePredicate.java      |  15 +-
 .../rules/core/NumericRulePredicate.java      |  16 +-
 .../moa/classifiers/rules/core/Predicate.java |   2 +
 .../AbstractAnomalyDetector.java              |   4 +-
 .../AnomalinessRatioScore.java                |   4 +-
 .../anomalydetection/AnomalyDetector.java     |   4 +-
 .../anomalydetection/NoAnomalyDetection.java  |   4 +-
 .../core/anomalydetection/OddsRatioScore.java |   4 +-
 .../NominalAttributeBinaryRulePredicate.java  |   9 +
 .../NumericAttributeBinaryRulePredicate.java  |   7 +
 .../rules/functions/Perceptron.java           |   2 +-
 .../multilabel/AMRulesMultiLabelLearner.java  |  10 +-
 .../multilabel/core/LearningLiteral.java      |  12 +-
 .../core/LearningLiteralRegression.java       |   4 +-
 .../rules/multilabel/core/MultiLabelRule.java |  12 +-
 .../AbstractMultiLabelErrorMeasurer.java      |   4 +-
 .../AbstractMultiTargetErrorMeasurer.java     |   4 +-
 .../MultiLabelErrorMeasurer.java              |   4 +-
 .../AdaptiveMultiTargetRegressor.java         |   6 +-
 .../meta/MultiLabelRandomAMRules.java         |   6 +-
 .../java/moa/classifiers/trees/FIMTDD.java    |  37 +-
 .../main/java/moa/classifiers/trees/ORTO.java |   6 +-
 .../BasicMultiTargetPerformanceEvaluator.java |   4 +-
 ...tWindowRegressionPerformanceEvaluator.java |   4 +-
 ...dowClassificationPerformanceEvaluator.java |   4 +-
 .../main/java/moa/streams/ArffFileStream.java |   9 +-
 54 files changed, 1568 insertions(+), 521 deletions(-)
 create mode 100644 moa/src/main/java/com/yahoo/labs/samoa/instances/AttributeStructure.java
 create mode 100644 moa/src/main/java/com/yahoo/labs/samoa/instances/DAGStructure.java
 create mode 100644 moa/src/main/java/com/yahoo/labs/samoa/instances/HierarhicalInstanceImpl.java
 rename moa/src/main/java/com/yahoo/labs/samoa/instances/{MultiLabelInstance.java => StructuredInstance.java} (87%)
 create mode 100644 moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/WeightedICVarianceReduction.java

diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
index 124b1d5d6..a6bddce59 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
@@ -352,10 +352,6 @@ private InstanceInformation getHeader() {
     	//commented JD
         //this.range.setUpper(10000); //TO DO: Create a new range object with isInRange that does not need the upper limit
         String relation = "file stream";
-        //System.out.println("RELATION " + relation);
-        //inputAttributes = new ArrayList<Attribute>();
-        //outputAttributes = new ArrayList<Attribute>();
-        //ArrayList<Attribute> 
         auxAttributes = new ArrayList<Attribute>();//JD
         int numAttributes = 0;
         try {
@@ -405,6 +401,17 @@ private InstanceInformation getHeader() {
                              }*/
                             auxAttributes.add(new Attribute(name, attributeLabels));
                             numAttributes++;
+                        } else if (streamTokenizer.sval != null && streamTokenizer.sval.toUpperCase() == "HIERARCHICAL") {
+                        	streamTokenizer.nextToken();
+                        	DAGStructure attributeStructure = new DAGStructure();
+                        	if (streamTokenizer.ttype == '{') {
+                        		while(streamTokenizer.ttype == '}') {
+                        			streamTokenizer.nextToken();
+                        			System.out.println(streamTokenizer.sval);
+                        		}
+                        		
+                        	}
+                        	
                         } else {
                             // Add attribute
                             //commented JD
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java
index 941616a73..54e6c21dc 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java
@@ -25,279 +25,323 @@
  */
 public class Attribute implements Serializable {
 
-    /** The keyword used to denote the start of an arff attribute declaration */
-    public final static String ARFF_ATTRIBUTE = "@attribute";
-
-    /** A keyword used to denote a numeric attribute */
-    public final static String ARFF_ATTRIBUTE_INTEGER = "integer";
-
-    /** A keyword used to denote a numeric attribute */
-    public final static String ARFF_ATTRIBUTE_REAL = "real";
-
-    /** A keyword used to denote a numeric attribute */
-    public final static String ARFF_ATTRIBUTE_NUMERIC = "numeric";
-
-    /** The keyword used to denote a string attribute */
-    public final static String ARFF_ATTRIBUTE_STRING = "string";
-
-    /** The keyword used to denote a date attribute */
-    public final static String ARFF_ATTRIBUTE_DATE = "date";
-
-    /** The keyword used to denote a relation-valued attribute */
-    public final static String ARFF_ATTRIBUTE_RELATIONAL = "relational";
-
-    /** The keyword used to denote the end of the declaration of a subrelation */
-    public final static String ARFF_END_SUBRELATION = "@end";
-
-    /** Strings longer than this will be stored compressed. */
-    private static final int STRING_COMPRESS_THRESHOLD = 200;
-
-    /**
-     * The is nominal.
-     */
-    protected boolean isNominal;
-
-    /**
-     * The is numeric.
-     */
-    protected boolean isNumeric;
-
-    /**
-    * The is date.
-    */
-    protected boolean isDate;
-
-     /** 
-     * Date format specification for date attributes 
-     */
-    protected SimpleDateFormat m_DateFormat;
-  
-    /**
-     * The name.
-     */
-    protected String name;
-
-    /**
-     * The attribute values.
-     */
-    protected List<String> attributeValues;
-
-    /**
-     * Gets the attribute values.
-     *
-     * @return the attribute values
-     */
-    public List<String> getAttributeValues() {
-        return attributeValues;
-    }
-
-    /**
-     * The index.
-     */
-    protected int index;
-
-    /**
-     * Instantiates a new attribute.
-     *
-     * @param string the string
-     */
-    public Attribute(String string) {
-        this.name = string;
-        this.isNumeric = true;
-    }
-
-    /**
-     * Instantiates a new attribute.
-     *
-     * @param attributeName the attribute name
-     * @param attributeValues the attribute values
-     */
-    public Attribute(String attributeName, List<String> attributeValues) {
-        this.name = attributeName;
-        this.attributeValues = attributeValues;
-        this.isNominal = true;
-    }
-
-    /**
-     * Instantiates a new attribute.
-     *
-     * @param attributeName the attribute name
-     * @param dateFormat the format of the date used
-     */
-    public Attribute(String attributeName, String dateFormat) {
-        this.name = attributeName;
-        this.index  = -1;
-        this.valuesStringAttribute = null;
-        this.isDate = true;
-        
-        if (dateFormat != null) {
-          m_DateFormat = new SimpleDateFormat(dateFormat);
-        } else {
-          m_DateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
-        }
-  }
-                   
-    /**
-     * Instantiates a new attribute.
-     */
-    public Attribute() {
-        this("");
-    }
-
-    /**
-     * Checks if is nominal.
-     *
-     * @return true, if is nominal
-     */
-    public boolean isNominal() {
-        return this.isNominal;
-    }
-
-    /**
-     * Name.
-     *
-     * @return the string
-     */
-    public String name() {
-        return this.name;
-    }
-
-    /**
-     * Value.
-     *
-     * @param value the value
-     * @return the string
-     */
-    public String value(int value) {
-        return attributeValues.get(value);
-    }
-
-    /**
-     * Checks if is numeric.
-     *
-     * @return true, if is numeric
-     */
-    public boolean isNumeric() {
-        return isNumeric;
-    }
-
-    /**
-     * Num values.
-     *
-     * @return the int
-     */
-    public int numValues() {
-        if (isNumeric()) {
-            return 0;
-        } else {
-            return attributeValues.size();
-        }
-    }
-
-    /**
-     * Index.
-     *
-     * @return the int
-     */
-    public int index() { //RuleClassifier
-        return this.index;
-    }
-
-    /**
-     * Format date.
-     *
-     * @param value the value
-     * @return the string
-     */
-    String formatDate(double value) {
-        return this.m_DateFormat.format(new Date((long) value));
-    }
-
-    /**
-     * Checks if is date.
-     *
-     * @return true, if is date
-     */
-    boolean isDate() {
-        return isDate;
-    }
-
-    /**
-     * The values string attribute.
-     */
-    private Map<String, Integer> valuesStringAttribute;
-
-    /**
-     * Index of value.
-     *
-     * @param value the value
-     * @return the int
-     */
-    public final int indexOfValue(String value) {
-
-        if (isNominal() == false) {
-            return -1;
-        }
-        if (this.valuesStringAttribute == null) {
-            this.valuesStringAttribute = new HashMap<String, Integer>();
-            int count = 0;
-            for (String stringValue : attributeValues) {
-                this.valuesStringAttribute.put(stringValue, count);
-                count++;
-            }
-        }
-        Integer val = (Integer) this.valuesStringAttribute.get(value);
-        if (val == null) {
-            return -1;
-        } else {
-            return val.intValue();
-        }
-    }
-    
-    /**
-    * Returns a description of this attribute in ARFF format. Quotes
-    * strings if they contain whitespace characters, or if they
-     * are a question mark.
-     *
-     * @return a description of this attribute as a string
-     */
-    public final String toString() {
-    
-    StringBuffer text = new StringBuffer();
-    
-    text.append(ARFF_ATTRIBUTE).append(" ").append(Utils.quote(this.name())).append(" ");
-    
-    if (this.isNominal){
-        text.append('{');
-        Enumeration enu =  enumerateValues();
-        while (enu.hasMoreElements()) {
-            text.append(Utils.quote((String) enu.nextElement()));
-            if (enu.hasMoreElements())
-                text.append(',');
-        }
-        text.append('}');
-    } else if (this.isNumeric){
-        text.append(ARFF_ATTRIBUTE_NUMERIC);
-    } else if (this.isDate){
-        text.append(ARFF_ATTRIBUTE_DATE).append(" ").append(Utils.quote(m_DateFormat.toPattern()));
-    } else{
-        text.append("UNKNOW");
-    }
-    
-    return text.toString();
-  }
-  
-    /**
-   * Returns an enumeration of all the attribute's values if the
-   * attribute is nominal, null otherwise.
-   *
-   * @return enumeration of all the attribute's values
-   */
-  public final /*@ pure @*/ Enumeration enumerateValues() {
-
-    if (this.isNominal()) {
-      return Collections.enumeration(this.attributeValues);
-    }
-    return null;
-  }
+	/** The keyword used to denote the start of an arff attribute declaration */
+	public final static String ARFF_ATTRIBUTE = "@attribute";
+
+	/** A keyword used to denote a numeric attribute */
+	public final static String ARFF_ATTRIBUTE_INTEGER = "integer";
+
+	/** A keyword used to denote a numeric attribute */
+	public final static String ARFF_ATTRIBUTE_REAL = "real";
+
+	/** A keyword used to denote a numeric attribute */
+	public final static String ARFF_ATTRIBUTE_NUMERIC = "numeric";
+
+	/** The keyword used to denote a string attribute */
+	public final static String ARFF_ATTRIBUTE_STRING = "string";
+
+	/** The keyword used to denote a date attribute */
+	public final static String ARFF_ATTRIBUTE_DATE = "date";
+
+	/** The keyword used to denote a (nominal) hierarchical attribute */
+	public final static String ARFF_ATTRIBUTE_HIERARCHICAL = "hierarchical";
+
+	/** The keyword used to denote a relation-valued attribute */
+	public final static String ARFF_ATTRIBUTE_RELATIONAL = "relational";
+
+	/** The keyword used to denote the end of the declaration of a subrelation */
+	public final static String ARFF_END_SUBRELATION = "@end";
+
+	/** Strings longer than this will be stored compressed. */
+	private static final int STRING_COMPRESS_THRESHOLD = 200;
+
+	/**
+	 * The is nominal.
+	 */
+	protected boolean isNominal;
+
+	/**
+	 * The is numeric.
+	 */
+	protected boolean isNumeric;
+
+	/**
+	 * The is date.
+	 */
+	protected boolean isDate;
+
+	/**
+	 * The is hierarchical.
+	 */
+	protected boolean isHierarchical;
+
+	/** 
+	 * Date format specification for date attributes 
+	 */
+	protected SimpleDateFormat m_DateFormat;
+
+	/**
+	 * The name.
+	 */
+	protected String name;
+
+	/**
+	 * The attribute values.
+	 */
+	protected List<String> attributeValues;
+	
+	/**
+	 * The attribute structure.
+	 */
+	protected AttributeStructure attributeStructure;
+
+	/**
+	 * Gets the attribute values.
+	 *
+	 * @return the attribute values
+	 */
+	public List<String> getAttributeValues() {
+		return attributeValues;
+	}
+
+	/**
+	 * The index.
+	 */
+	protected int index;
+
+	/**
+	 * Instantiates a new attribute.
+	 *
+	 * @param string the string
+	 */
+	public Attribute(String string) {
+		this.name = string;
+		this.isNumeric = true;
+	}
+
+	/**
+	 * Instantiates a new attribute.
+	 *
+	 * @param attributeName the attribute name
+	 * @param attributeValues the attribute values
+	 */
+	public Attribute(String attributeName, List<String> attributeValues) {
+		this.name = attributeName;
+		this.attributeValues = attributeValues;
+		this.isNominal = true;
+	}
+
+	/**
+	 * Instantiates a new attribute.
+	 *
+	 * @param attributeName the attribute name
+	 * @param dateFormat the format of the date used
+	 */
+	public Attribute(String attributeName, String dateFormat) {
+		this.name = attributeName;
+		this.index  = -1;
+		this.valuesStringAttribute = null;
+		this.isDate = true;
+
+		if (dateFormat != null) {
+			m_DateFormat = new SimpleDateFormat(dateFormat);
+		} else {
+			m_DateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
+		}
+	}
+	
+	/**
+	 * Instantiates a new attribute.
+	 *
+	 * @param attributeName the attribute name
+	 * @param attributeValues the attribute values
+	 * @param attributeStructure the attribute structure 
+	 */
+	public Attribute(String attributeName, List<String> attributeValues, AttributeStructure attributeStructure) {
+		this.name = attributeName;
+		this.attributeValues = attributeValues;
+		this.attributeStructure = attributeStructure;
+		this.isHierarchical = true;
+	}
+	/**
+	 * Instantiates a new attribute.
+	 */
+	public Attribute() {
+		this("");
+	}
+
+	/**
+	 * Checks if is nominal.
+	 *
+	 * @return true, if is nominal
+	 */
+	public boolean isNominal() {
+		return this.isNominal;
+	}
+
+	/**
+	 * Name.
+	 *
+	 * @return the string
+	 */
+	public String name() {
+		return this.name;
+	}
+
+	/**
+	 * Value.
+	 *
+	 * @param value the value
+	 * @return the string
+	 */
+	public String value(int value) {
+		return attributeValues.get(value);
+	}
+
+	/**
+	 * Checks if is numeric.
+	 *
+	 * @return true, if is numeric
+	 */
+	public boolean isNumeric() {
+		return isNumeric;
+	}
+
+	/**
+	 * Num values.
+	 *
+	 * @return the int
+	 */
+	public int numValues() {
+		if (isNumeric()) {
+			return 0;
+		} else {
+			return attributeValues.size();
+		}
+	}
+
+	/**
+	 * Checks if is hierarchical.
+	 *
+	 * @return true, if is hierarchical
+	 */
+	public boolean isHierarchical() {
+		return this.isHierarchical;
+	}
+
+	
+	/**
+	 * Index.
+	 *
+	 * @return the int
+	 */
+	public int index() { //RuleClassifier
+		return this.index;
+	}
+
+	/**
+	 * Format date.
+	 *
+	 * @param value the value
+	 * @return the string
+	 */
+	String formatDate(double value) {
+		return this.m_DateFormat.format(new Date((long) value));
+	}
+
+	/**
+	 * Checks if is date.
+	 *
+	 * @return true, if is date
+	 */
+	boolean isDate() {
+		return isDate;
+	}
+
+	/**
+	 * The values string attribute.
+	 */
+	private Map<String, Integer> valuesStringAttribute;
+
+	/**
+	 * Index of value.
+	 *
+	 * @param value the value
+	 * @return the int
+	 */
+	public final int indexOfValue(String value) {
+
+		if (!isNominal()) {
+			return -1;
+		}
+		// TODO check how this affects hierarchies
+		if (this.valuesStringAttribute == null) {
+			this.valuesStringAttribute = new HashMap<String, Integer>();
+			int count = 0;
+			for (String stringValue : attributeValues) {
+				this.valuesStringAttribute.put(stringValue, count);
+				count++;
+			}
+		}
+		Integer val = (Integer) this.valuesStringAttribute.get(value);
+		if (val == null) {
+			return -1;
+		} else {
+			return val.intValue();
+		}
+	}
+
+	/**
+	 * Returns a description of this attribute in ARFF format. Quotes
+	 * strings if they contain whitespace characters, or if they
+	 * are a question mark.
+	 *
+	 * @return a description of this attribute as a string
+	 */
+	public final String toString() {
+
+		StringBuffer text = new StringBuffer();
+
+		text.append(ARFF_ATTRIBUTE).append(" ").append(Utils.quote(this.name())).append(" ");
+
+		if (this.isNominal){
+			text.append('{');
+			Enumeration enu = enumerateValues();
+			while (enu.hasMoreElements()) {
+				text.append(Utils.quote((String) enu.nextElement()));
+				if (enu.hasMoreElements())
+					text.append(',');
+			}
+			text.append('}');
+		} else if (this.isNumeric){
+			text.append(ARFF_ATTRIBUTE_NUMERIC);
+		} else if (this.isDate){
+			text.append(ARFF_ATTRIBUTE_DATE).append(" ").append(Utils.quote(m_DateFormat.toPattern()));
+		} else if (this.isHierarchical) {
+			text.append(ARFF_ATTRIBUTE_HIERARCHICAL).append(" ");
+
+			text.append("{");
+			// TODO output hierarchy
+			text.append("}");
+			
+		} else {
+			text.append("UNKNOW");
+		}
+
+		return text.toString();
+	}
+
+	/**
+	 * Returns an enumeration of all the attribute's values if the
+	 * attribute is nominal, null otherwise.
+	 *
+	 * @return enumeration of all the attribute's values
+	 */
+	public final /*@ pure @*/ Enumeration enumerateValues() {
+
+		if (this.isNominal()) {
+			return Collections.enumeration(this.attributeValues);
+		}
+		return null;
+	}
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/AttributeStructure.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/AttributeStructure.java
new file mode 100644
index 000000000..afcd53e38
--- /dev/null
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/AttributeStructure.java
@@ -0,0 +1,7 @@
+package com.yahoo.labs.samoa.instances;
+
+import java.io.Serializable;
+
+public interface AttributeStructure extends Serializable {
+
+}
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/DAGStructure.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/DAGStructure.java
new file mode 100644
index 000000000..b26cd433c
--- /dev/null
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/DAGStructure.java
@@ -0,0 +1,86 @@
+package com.yahoo.labs.samoa.instances;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class DAGStructure implements AttributeStructure {
+	public Node root;
+	
+	public Map<String, Node> nodes;
+	
+	public int type;
+	
+	public static int HIERARCHY_TYPE = 0;
+	public static int DAG_TYPE = 1;
+	
+	public DAGStructure() {
+		this.type = DAGStructure.HIERARCHY_TYPE;
+		this.nodes = new HashMap<String, Node>();
+		this.root = null;
+	}
+	
+	public boolean hasNode(String description) {
+		return nodes.containsKey(description);
+	}
+	
+	public void addNode(String description) {
+		nodes.put(description, new Node(description));
+	}
+	
+	public void addChild(String parent, String child) {
+		Node p = nodes.get(parent);
+		Node c = nodes.get(child);
+		p.addChild(c);
+		c.addAncestor(p);
+		if (c.ancestors.size() > 1) {
+			this.type = DAGStructure.DAG_TYPE;
+		}
+	}
+	
+	public void setRoot(String description) {
+		if (this.nodes.containsKey(description)) {
+			this.root = this.nodes.get(description);
+		}
+	}
+	
+	public class Node {
+		public String description;
+		
+		public List<Node> ancestors;
+		public List<Node> children;
+		
+		public Node(String description) {
+			this.description = description;
+			this.ancestors = new ArrayList<Node>();
+			this.children = new ArrayList<Node>();
+		}
+		
+		public void addAncestor(Node ancestor) {
+			this.ancestors.add(ancestor);
+		}
+		
+		public void addChild(Node child) {
+			this.ancestors.add(child);
+		}
+		
+		public boolean isRoot() {
+			// Should only be called when the structure is built
+			return this.ancestors.isEmpty();
+		}
+		
+		public double getLevel() {
+			// Check how this is done when a DAG is used instead of a hierarchy
+			if (this.isRoot()) return 0;
+			else {
+				double total = Integer.MAX_VALUE; 
+				for (Node ancestor : this.ancestors) {
+					total = total + ancestor.getLevel();
+				}
+				return total / ancestors.size() + 1;
+			}
+		}
+	}
+
+}
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/HierarhicalInstanceImpl.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/HierarhicalInstanceImpl.java
new file mode 100644
index 000000000..c9ed7728c
--- /dev/null
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/HierarhicalInstanceImpl.java
@@ -0,0 +1,452 @@
+/*
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * 	        http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific
+ * language governing permissions and limitations under the
+ * License.  
+ */
+package com.yahoo.labs.samoa.instances;
+
+import moa.AbstractMOAObject;
+
+/**
+ * The Class InstanceImpl.
+ *
+ * @author abifet
+ */
+public class HierarhicalInstanceImpl implements StructuredInstance {
+
+    /**
+	 * 
+	 */
+	private static final long serialVersionUID = 1L;
+
+	/**
+     * The weight.
+     */
+    protected double weight;
+
+    /**
+     * The instance data.
+     */
+    protected InstanceData instanceData;
+
+    /**
+     * The instance information.
+     */
+    protected InstancesHeader instanceHeader;
+
+    /**
+     * Instantiates a new instance.
+     *
+     * @param inst the inst
+     */
+    public HierarhicalInstanceImpl(HierarhicalInstanceImpl inst) {
+        this.weight = inst.weight;
+        this.instanceData = inst.instanceData.copy();
+        this.instanceHeader = inst.instanceHeader;
+    }
+
+    //Dense
+    /**
+     * Instantiates a new instance.
+     *
+     * @param weight the weight
+     * @param res the res
+     */
+    public HierarhicalInstanceImpl(double weight, double[] res) {
+        this.weight = weight;
+        this.instanceData = new DenseInstanceData(res);
+    }
+
+    //Sparse
+    /**
+     * Instantiates a new instance.
+     *
+     * @param weight the weight
+     * @param attributeValues the attribute values
+     * @param indexValues the index values
+     * @param numberAttributes the number attributes
+     */
+    public HierarhicalInstanceImpl(double weight, double[] attributeValues, int[] indexValues, int numberAttributes) {
+        this.weight = weight;
+        this.instanceData = new SparseInstanceData(attributeValues, indexValues, numberAttributes);
+    }
+
+    /**
+     * Instantiates a new instance.
+     *
+     * @param weight the weight
+     * @param instanceData the instance data
+     */
+    public HierarhicalInstanceImpl(double weight, InstanceData instanceData) {
+        this.weight = weight;
+        this.instanceData = instanceData;
+    }
+
+    /**
+     * Instantiates a new instance.
+     *
+     * @param numAttributes the num attributes
+     */
+    public HierarhicalInstanceImpl(int numAttributes) {
+        this.instanceData = new DenseInstanceData(new double[numAttributes]); //JD
+        this.weight = 1;
+    }
+
+    /**
+     * Weight.
+     *
+     * @return the double
+     */
+    @Override
+    public double weight() {
+        return weight;
+    }
+
+    /**
+     * Sets the weight.
+     *
+     * @param weight the new weight
+     */
+    @Override
+    public void setWeight(double weight) {
+        this.weight = weight;
+    }
+
+    /**
+     * Attribute.
+     *
+     * @param instAttIndex the inst att index
+     * @return the attribute
+     */
+    @Override
+    public Attribute attribute(int instAttIndex) {
+        return this.instanceHeader.attribute(instAttIndex);
+    }
+
+    /**
+     * Delete attribute at.
+     *
+     * @param i the i
+     */
+    @Override
+    public void deleteAttributeAt(int i) {
+        //throw new UnsupportedOperationException("Not yet implemented");
+        this.instanceData.deleteAttributeAt(i);
+    }
+
+    /**
+     * Insert attribute at.
+     *
+     * @param i the i
+     */
+    @Override
+    public void insertAttributeAt(int i) {
+        throw new UnsupportedOperationException("Not yet implemented");
+    }
+
+    /**
+     * Num attributes.
+     *
+     * @return the int
+     */
+    @Override
+    public int numAttributes() {
+        return this.instanceData.numAttributes();
+    }
+
+    /**
+     * Value.
+     *
+     * @param instAttIndex the inst att index
+     * @return the double
+     */
+    @Override
+    public double value(int instAttIndex) {
+        return this.instanceData.value(instAttIndex);
+    }
+
+    /**
+     * Checks if is missing.
+     *
+     * @param instAttIndex the inst att index
+     * @return true, if is missing
+     */
+    @Override
+    public boolean isMissing(int instAttIndex) {
+        return this.instanceData.isMissing(instAttIndex);
+    }
+
+    /**
+     * Num values.
+     *
+     * @return the int
+     */
+    @Override
+    public int numValues() {
+        return this.instanceData.numValues();
+    }
+
+    /**
+     * Index.
+     *
+     * @param i the i
+     * @return the int
+     */
+    @Override
+    public int index(int i) {
+        return this.instanceData.index(i);
+    }
+
+    /**
+     * Value sparse.
+     *
+     * @param i the i
+     * @return the double
+     */
+    @Override
+    public double valueSparse(int i) {
+        return this.instanceData.valueSparse(i);
+    }
+
+    /**
+     * Checks if is missing sparse.
+     *
+     * @param p the p
+     * @return true, if is missing sparse
+     */
+    @Override
+    public boolean isMissingSparse(int p) {
+        return this.instanceData.isMissingSparse(p);
+    }
+
+    /**
+     * Value.
+     *
+     * @param attribute the attribute
+     * @return the double
+     */
+    @Override
+    public double value(Attribute attribute) {
+        return value(attribute.index());
+
+    }
+
+    /**
+     * String value.
+     *
+     * @param i the i
+     * @return the string
+     */
+    @Override
+    public String stringValue(int i) {
+        throw new UnsupportedOperationException("Not yet implemented");
+    }
+
+    /**
+     * To double array.
+     *
+     * @return the double[]
+     */
+    @Override
+    public double[] toDoubleArray() {
+        return this.instanceData.toDoubleArray();
+    }
+
+    /**
+     * Sets the value.
+     *
+     * @param numAttribute the num attribute
+     * @param d the d
+     */
+    @Override
+    public void setValue(int numAttribute, double d) {
+        this.instanceData.setValue(numAttribute, d);
+    }
+
+    /**
+     * Class value.
+     *
+     * @return the double
+     */
+    @Override
+    public double classValue() {
+        return this.instanceData.value(classIndex());
+    }
+
+    /**
+     * Class index.
+     *
+     * @return the int
+     */
+    @Override
+    public int classIndex() {
+        int classIndex = instanceHeader.classIndex();
+        return classIndex != Integer.MAX_VALUE ? classIndex : 0;
+    }
+
+    /**
+     * Num classes.
+     *
+     * @return the int
+     */
+    @Override
+    public int numClasses() {
+        return this.instanceHeader.numClasses();
+    }
+
+    /**
+     * Class is missing.
+     *
+     * @return true, if successful
+     */
+    @Override
+    public boolean classIsMissing() {
+        return this.instanceData.isMissing(classIndex());
+    }
+
+    /**
+     * Class attribute.
+     *
+     * @return the attribute
+     */
+    @Override
+    public Attribute classAttribute() {
+        return this.instanceHeader.attribute(classIndex());
+    }
+
+    /**
+     * Sets the class value.
+     *
+     * @param d the new class value
+     */
+    @Override
+    public void setClassValue(double d) {
+        this.setValue(classIndex(), d);
+    }
+
+    /**
+     * Copy.
+     *
+     * @return the instance
+     */
+    @Override
+    public Instance copy() {
+        HierarhicalInstanceImpl inst = new HierarhicalInstanceImpl(this);
+        return inst;
+    }
+
+    /**
+     * Dataset.
+     *
+     * @return the instances
+     */
+    @Override
+    public Instances dataset() {
+        return this.instanceHeader;
+    }
+
+    /**
+     * Sets the dataset.
+     *
+     * @param dataset the new dataset
+     */
+    @Override
+    public void setDataset(Instances dataset) {
+        this.instanceHeader = new InstancesHeader(dataset);
+    }
+
+    /**
+     * Adds the sparse values.
+     *
+     * @param indexValues the index values
+     * @param attributeValues the attribute values
+     * @param numberAttributes the number attributes
+     */
+    @Override
+    public void addSparseValues(int[] indexValues, double[] attributeValues, int numberAttributes) {
+        this.instanceData = new SparseInstanceData(attributeValues, indexValues, numberAttributes); //???
+    }
+
+    /**
+     * Text representation of a InstanceImpl.
+     */
+    @Override
+    public String toString() {
+        double[] aux = this.instanceData.toDoubleArray();
+        StringBuilder str = new StringBuilder();
+        for (int i = 0; i < aux.length; i++) {
+            str.append(aux[i]).append(" ");
+        }
+
+        return str.toString();
+    }
+
+    @Override
+    public int numInputAttributes() {
+        return this.instanceHeader.numInputAttributes();
+    }
+
+    @Override
+    public int numOutputAttributes() {
+        return numberOutputTargets();
+    }
+    
+    @Override
+    public int numberOutputTargets() {
+        return this.instanceHeader.numOutputAttributes();
+    }
+
+    @Override
+    public double classValue(int instAttIndex) {
+        return valueOutputAttribute(instAttIndex);
+    }
+
+    @Override
+    public void setClassValue(int indexClass, double valueAttribute) {
+        InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
+        this.instanceData.setValue(instanceInformation.outputAttributeIndex(indexClass), valueAttribute);
+
+    }
+
+    @Override
+    public Attribute outputAttribute(int outputIndex) {
+        InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
+        return instanceInformation.outputAttribute(outputIndex);
+    }
+
+    @Override
+    public Attribute inputAttribute(int attributeIndex) {
+        InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
+        return instanceInformation.inputAttribute(attributeIndex);
+    }
+
+    @Override
+    public double valueInputAttribute(int attributeIndex) {
+        InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
+        return this.instanceData.value(instanceInformation.inputAttributeIndex(attributeIndex));
+    }
+
+    @Override
+    public double valueOutputAttribute(int attributeIndex) {
+        InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
+        return this.instanceData.value(instanceInformation.outputAttributeIndex(attributeIndex));
+    }
+    
+    public int structureType() {
+    	return Instance.STRUCTURE_TYPE_HIERARHICAL;
+    }
+    
+    public AttributeStructure getStructure() {
+    	return this.instanceHeader.getInstanceStructure();
+    }
+}
\ No newline at end of file
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
index 1780a9d11..dbf315738 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
@@ -17,6 +17,8 @@
 
 import java.io.Serializable;
 
+import moa.AbstractMOAObject;
+
 /**
  * The Interface Instance.
  *
@@ -24,6 +26,11 @@
  */
 public interface Instance extends Serializable {
 
+	public static int STRUCTURE_TYPE_SINGLE_TARGET = 0;
+	public static int STRUCTURE_TYPE_MULTI_TARGET = 1;
+	public static int STRUCTURE_TYPE_TIME_SERIES = 2;
+	public static int STRUCTURE_TYPE_HIERARHICAL = 3;
+	
     /**
      * Gets the weight of the instance.
      *
@@ -287,5 +294,9 @@ public interface Instance extends Serializable {
      * @return the value
      */
     public double valueOutputAttribute(int attributeIndex);
+    
+    public int structureType();
+    
+    public AttributeStructure getStructure();
 
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
index 50403eb20..16acdac54 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
@@ -15,12 +15,14 @@
  */
 package com.yahoo.labs.samoa.instances;
 
+import moa.AbstractMOAObject;
+
 /**
  * The Class InstanceImpl.
  *
  * @author abifet
  */
-public class InstanceImpl implements MultiLabelInstance {
+public class InstanceImpl implements StructuredInstance {
 
     /**
      * The weight.
@@ -434,4 +436,12 @@ public double valueOutputAttribute(int attributeIndex) {
         InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
         return this.instanceData.value(instanceInformation.outputAttributeIndex(attributeIndex));
     }
-}
+    
+    public int structureType() {
+    	return (numOutputAttributes() > 1) ? Instance.STRUCTURE_TYPE_MULTI_TARGET : Instance.STRUCTURE_TYPE_SINGLE_TARGET;
+    }
+    
+    public AttributeStructure getStructure() {
+    	return null;
+    }
+}
\ No newline at end of file
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
index dd59d6f27..7a8aae816 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
@@ -18,6 +18,8 @@
 import java.io.Serializable;
 import java.util.List;
 
+import moa.AbstractMOAObject;
+
 /**
  * The Class InstanceInformation.
  *
@@ -31,6 +33,8 @@ public class InstanceInformation implements Serializable {
     protected String relationName;
 
     protected AttributesInformation attributesInformation;
+    
+    protected AttributeStructure structure = null;
 
     /**
      * The class index.
@@ -58,6 +62,7 @@ public Attribute outputAttribute(int w) {
     public InstanceInformation(InstanceInformation chunk) {
         this.relationName = chunk.relationName;
         this.attributesInformation = chunk.attributesInformation;
+        this.structure = chunk.structure;
         this.classIndex = chunk.classIndex;
     }
 
@@ -212,5 +217,9 @@ public void setAttributes(List<Attribute> v, List<Integer> indexValues) {
         this.attributesInformation.setAttributes(v,indexValues);
 		
 	}
+	
+	public AttributeStructure getStructure() {
+		return this.structure;
+	}
 
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
index 687bb9705..ed53007d0 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
@@ -113,4 +113,8 @@ public int numOutputAttributes() {
     public InstanceInformation getInstanceInformation() {
         return this.instanceInformation;
     }
+    
+    public AttributeStructure getInstanceStructure() {
+    	return this.instanceInformation.getStructure();
+    }
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/Range.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/Range.java
index dfdf3dba9..ab27c38fb 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/Range.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/Range.java
@@ -15,7 +15,9 @@
  */
 package com.yahoo.labs.samoa.instances;
 
-public class Range {
+import java.io.Serializable;
+
+public class Range implements Serializable {
 
     //Only works for ranges "start-end"
     private int start = 0;
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelInstance.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/StructuredInstance.java
similarity index 87%
rename from moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelInstance.java
rename to moa/src/main/java/com/yahoo/labs/samoa/instances/StructuredInstance.java
index 0978bd332..279d6baed 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelInstance.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/StructuredInstance.java
@@ -16,12 +16,12 @@
 package com.yahoo.labs.samoa.instances;
 
 /**
- * The Interface MultiLabelInstance.
+ * The Interface StructuredInstance.
  *
  * @author abifet
  */
    
-public interface MultiLabelInstance extends Instance {
+public interface StructuredInstance extends Instance {
 
 }
  
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/AbstractClassifier.java b/moa/src/main/java/moa/classifiers/AbstractClassifier.java
index 9511a24f6..ee1c01c47 100644
--- a/moa/src/main/java/moa/classifiers/AbstractClassifier.java
+++ b/moa/src/main/java/moa/classifiers/AbstractClassifier.java
@@ -85,14 +85,15 @@ public AbstractClassifier() {
     }
 
     @Override
-    public void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
+    public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
         if (this.randomSeedOption != null) {
             this.randomSeed = this.randomSeedOption.getValue();
         }
-        if (!trainingHasStarted()) {
-            resetLearning();
-        }
+        
+        // resetLearning should not be called if the classifier has not yet received the context
+//        if (!trainingHasStarted()) {
+//            resetLearning();
+//        }
     }
 
 	
diff --git a/moa/src/main/java/moa/classifiers/AbstractMultiLabelLearner.java b/moa/src/main/java/moa/classifiers/AbstractMultiLabelLearner.java
index 641228cf0..3fefdd9ce 100644
--- a/moa/src/main/java/moa/classifiers/AbstractMultiLabelLearner.java
+++ b/moa/src/main/java/moa/classifiers/AbstractMultiLabelLearner.java
@@ -2,7 +2,7 @@
 
 import moa.core.Example;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 public abstract class AbstractMultiLabelLearner extends AbstractClassifier implements MultiLabelLearner {
@@ -13,11 +13,11 @@ public abstract class AbstractMultiLabelLearner extends AbstractClassifier imple
     private static final long serialVersionUID = 1L;
 
     @Override
-    abstract public void trainOnInstanceImpl(MultiLabelInstance instance);
+    abstract public void trainOnInstanceImpl(StructuredInstance instance);
 
     @Override
     public void trainOnInstanceImpl(Instance instance) {
-        trainOnInstanceImpl((MultiLabelInstance) instance);
+        trainOnInstanceImpl((StructuredInstance) instance);
     }
 
     @Override
@@ -27,10 +27,10 @@ public Prediction getPredictionForInstance(Example<Instance> example) {
 
     @Override
     public Prediction getPredictionForInstance(Instance inst) {
-        return getPredictionForInstance((MultiLabelInstance) inst);
+        return getPredictionForInstance((StructuredInstance) inst);
     }
 
-    abstract public Prediction getPredictionForInstance(MultiLabelInstance inst);
+    abstract public Prediction getPredictionForInstance(StructuredInstance inst);
 
     @Override
     public double[] getVotesForInstance(Instance inst) {
diff --git a/moa/src/main/java/moa/classifiers/MultiLabelLearner.java b/moa/src/main/java/moa/classifiers/MultiLabelLearner.java
index b42a37085..ee875ee60 100644
--- a/moa/src/main/java/moa/classifiers/MultiLabelLearner.java
+++ b/moa/src/main/java/moa/classifiers/MultiLabelLearner.java
@@ -1,12 +1,12 @@
 package moa.classifiers;
 
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 public interface MultiLabelLearner extends Classifier{
 	
-	public void trainOnInstanceImpl(MultiLabelInstance instance);
+	public void trainOnInstanceImpl(StructuredInstance instance);
 	
-	public Prediction getPredictionForInstance(MultiLabelInstance instance);
+	public Prediction getPredictionForInstance(StructuredInstance instance);
 
 }
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBag.java b/moa/src/main/java/moa/classifiers/meta/OzaBag.java
index d7c935590..9ca3dd639 100644
--- a/moa/src/main/java/moa/classifiers/meta/OzaBag.java
+++ b/moa/src/main/java/moa/classifiers/meta/OzaBag.java
@@ -70,9 +70,9 @@ public String getPurposeString() {
     public void resetLearningImpl() {
         this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
         Classifier baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
-        baseLearner.resetLearning();
         for (int i = 0; i < this.ensemble.length; i++) {
             this.ensemble[i] = baseLearner.copy();
+            
         }
     }
 
diff --git a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
index 5fce8915c..4c78071f9 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
@@ -7,7 +7,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 
@@ -64,7 +64,7 @@ private void makeHeaders() {
 		}
 	}
 	
-	private Instance getSTInstance(MultiLabelInstance inst, int target) {
+	private Instance getSTInstance(StructuredInstance inst, int target) {
 		double[] instanceData = new double[getModelContext().numInputAttributes() + 1];
 		for (int i = 0; i < inst.numInputAttributes(); i++)
 			instanceData[i] = inst.valueInputAttribute(i);
@@ -75,7 +75,7 @@ private Instance getSTInstance(MultiLabelInstance inst, int target) {
 	}
 	
 	@Override
-	public void trainOnInstanceImpl(MultiLabelInstance instance) {
+	public void trainOnInstanceImpl(StructuredInstance instance) {
 		initializeClassifiers();
 		
 		for (int j = 0; j < instance.numberOutputTargets(); j++) {
@@ -86,7 +86,7 @@ public void trainOnInstanceImpl(MultiLabelInstance instance) {
 	}
 
 	@Override
-	public Prediction getPredictionForInstance(MultiLabelInstance inst) {
+	public Prediction getPredictionForInstance(StructuredInstance inst) {
 		initializeClassifiers();
 
 		MultiLabelPrediction prediction = new MultiLabelPrediction(getModelContext().numOutputAttributes());
diff --git a/moa/src/main/java/moa/classifiers/multilabel/MEKAClassifier.java b/moa/src/main/java/moa/classifiers/multilabel/MEKAClassifier.java
index 88881ce21..bc44ab3f7 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/MEKAClassifier.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/MEKAClassifier.java
@@ -24,7 +24,7 @@
 import moa.classifiers.meta.WEKAClassifier;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import weka.classifiers.UpdateableClassifier;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
@@ -87,12 +87,12 @@ public void setModelContext(InstancesHeader raw_header) {
 
 	@Override
 	public void trainOnInstanceImpl(Instance instance) {
-		trainOnInstanceImpl((MultiLabelInstance) instance);
+		trainOnInstanceImpl((StructuredInstance) instance);
 	}
 
 
 	@Override
-	public void trainOnInstanceImpl(MultiLabelInstance samoaInstance) {
+	public void trainOnInstanceImpl(StructuredInstance samoaInstance) {
 		weka.core.Instance inst = this.instanceConverter.wekaInstance(samoaInstance);
 		//System.out.println(""+m_L);                   // <--  this is correct
 		//System.out.println(""+inst.classIndex());     // <--- this one is wrong
@@ -130,11 +130,11 @@ public double[] getVotesForInstance(Instance samoaInstance) {
 
 	@Override
 	public Prediction getPredictionForInstance(Example<Instance> example) {
-		return getPredictionForInstance((MultiLabelInstance)example.getData());
+		return getPredictionForInstance((StructuredInstance)example.getData());
 	}
 
 	@Override
-	public Prediction getPredictionForInstance(MultiLabelInstance instance) {
+	public Prediction getPredictionForInstance(StructuredInstance instance) {
 
 		double[] predictionArray = this.getVotesForInstance(instance);
 
diff --git a/moa/src/main/java/moa/classifiers/multilabel/MajorityLabelset.java b/moa/src/main/java/moa/classifiers/multilabel/MajorityLabelset.java
index 039c0834e..c83ddbde6 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/MajorityLabelset.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/MajorityLabelset.java
@@ -24,7 +24,7 @@
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.Measurement;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 import moa.classifiers.AbstractMultiLabelLearner;
@@ -91,13 +91,13 @@ public void resetLearningImpl() {
     }
 
     @Override
-    public void trainOnInstanceImpl(MultiLabelInstance x) {
+    public void trainOnInstanceImpl(StructuredInstance x) {
         updateCount(x, m_L);
     }
 
     @Override
     //public double[] getVotesForInstance(Instance x) {
-    public Prediction getPredictionForInstance(MultiLabelInstance x){
+    public Prediction getPredictionForInstance(StructuredInstance x){
         
 		System.out.println("-------- start MC vote   ---------------");
         int L = x.numOutputAttributes(); //x.classIndex() + 1;
diff --git a/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java b/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java
index 934eae252..aaaa1b6d8 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java
@@ -28,7 +28,7 @@
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.Instances;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 import java.util.LinkedList;
@@ -65,11 +65,11 @@ public void setModelContext(InstancesHeader raw_header) {
 
 	@Override
 	public Prediction getPredictionForInstance(Example<Instance> example) {
-		return getPredictionForInstance((MultiLabelInstance)example.getData());
+		return getPredictionForInstance((StructuredInstance)example.getData());
 	} 
 
 	@Override
-	public Prediction getPredictionForInstance(MultiLabelInstance instance) {
+	public Prediction getPredictionForInstance(StructuredInstance instance) {
 
 		double[] predictionArray = this.getVotesForInstance(instance);
 
@@ -232,7 +232,7 @@ public double[] getVotesForInstance(Instance inst) {
 
 
 	@Override
-	public void trainOnInstanceImpl(MultiLabelInstance instance) {
+	public void trainOnInstanceImpl(StructuredInstance instance) {
 		trainOnInstanceImpl((Instance) instance);
 	}
 
diff --git a/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java b/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java
index 176f3dfd0..24f9839b0 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java
@@ -1,6 +1,5 @@
 package moa.classifiers.multilabel.core.splitcriteria;
 
-import moa.classifiers.rules.core.Utils;
 import moa.core.DoubleVector;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
diff --git a/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/WeightedICVarianceReduction.java b/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/WeightedICVarianceReduction.java
new file mode 100644
index 000000000..9d5d181ea
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/WeightedICVarianceReduction.java
@@ -0,0 +1,46 @@
+package moa.classifiers.multilabel.core.splitcriteria;
+
+import moa.core.DoubleVector;
+import moa.core.ObjectRepository;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Weighted intra cluster variance reduction split criterion 
+ * @author Aljaž Osojnik <aljaz.osojnik@ijs.si>
+ *
+ */
+
+public class WeightedICVarianceReduction extends ICVarianceReduction {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 1L;
+	
+	public DoubleVector weights;
+	
+	public WeightedICVarianceReduction(DoubleVector targetWeights) {
+		super();
+		this.weights = targetWeights;
+	}
+	
+	@Override
+	public double getMeritOfSplit(DoubleVector[] preSplitDist, DoubleVector[][] postSplitDists) {
+		double error=0;
+		int numOutputs=preSplitDist.length;
+		for (int i=0; i<numOutputs; i++)
+			error += weights.getValue(i) * getMeritOfSplitForOutput(preSplitDist,postSplitDists,i);
+		return error / weights.sumOfValues();
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor,
+			ObjectRepository repository) {		
+	}
+	
+}
diff --git a/moa/src/main/java/moa/classifiers/multilabel/meta/MLOzaBag.java b/moa/src/main/java/moa/classifiers/multilabel/meta/MLOzaBag.java
index 8cd80bc41..f5d1dff78 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/meta/MLOzaBag.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/meta/MLOzaBag.java
@@ -23,7 +23,7 @@
 import moa.classifiers.meta.OzaBag;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 import moa.classifiers.MultiLabelLearner;
@@ -99,17 +99,17 @@ public double[] getVotesForInstance(Instance x) {
     }
 
     @Override
-    public void trainOnInstanceImpl(MultiLabelInstance instance) {
+    public void trainOnInstanceImpl(StructuredInstance instance) {
         trainOnInstanceImpl((Instance) instance);
     }
     
     @Override
 	public Prediction getPredictionForInstance(Example<Instance> example) {
-		return getPredictionForInstance((MultiLabelInstance)example.getData());
+		return getPredictionForInstance((StructuredInstance)example.getData());
 	} 
     
     @Override
-	public Prediction getPredictionForInstance(MultiLabelInstance instance) {
+	public Prediction getPredictionForInstance(StructuredInstance instance) {
 
 		double[] predictionArray = this.getVotesForInstance(instance);
 
diff --git a/moa/src/main/java/moa/classifiers/multilabel/meta/MLOzaBagAdwin.java b/moa/src/main/java/moa/classifiers/multilabel/meta/MLOzaBagAdwin.java
index 43c008713..65e25b533 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/meta/MLOzaBagAdwin.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/meta/MLOzaBagAdwin.java
@@ -25,7 +25,7 @@
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.MiscUtils;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 import moa.classifiers.MultiLabelLearner;
@@ -156,17 +156,17 @@ public double[] getVotesForInstance(Instance x) {
     }
 
     @Override
-    public void trainOnInstanceImpl(MultiLabelInstance instance) {
+    public void trainOnInstanceImpl(StructuredInstance instance) {
         trainOnInstanceImpl((Instance) instance);
     }
 
     @Override
     public Prediction getPredictionForInstance(Example<Instance> example) {
-        return getPredictionForInstance((MultiLabelInstance) example.getData());
+        return getPredictionForInstance((StructuredInstance) example.getData());
     }
 
     @Override
-    public Prediction getPredictionForInstance(MultiLabelInstance instance) {
+    public Prediction getPredictionForInstance(StructuredInstance instance) {
 
         double[] predictionArray = this.getVotesForInstance(instance);
 
diff --git a/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java b/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
index 2594f61be..b4675887f 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
@@ -21,7 +21,7 @@
 
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 
@@ -41,7 +41,12 @@
  */
 public class MTOzaBag extends OzaBag implements MultiLabelLearner, MultiTargetRegressor {
 
-    public MTOzaBag() {
+    /**
+	 * 
+	 */
+	private static final long serialVersionUID = 1L;
+
+	public MTOzaBag() {
     	super();
     	this.baseLearnerOption = new ClassOption("baseLearner", 'l',
                 "Classifier to train.", MultiLabelLearner.class, "multilabel.trees.ISOUPTree");
@@ -51,23 +56,9 @@ public MTOzaBag() {
     public void resetLearningImpl() {
         this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
         MultiLabelLearner baseLearner = (MultiLabelLearner) getPreparedClassOption(this.baseLearnerOption);
-        baseLearner.resetLearning();
+        baseLearner.setModelContext(this.modelContext);
         for (int i = 0; i < this.ensemble.length; i++) {
             this.ensemble[i] = baseLearner.copy();
-        }
-    }
-
-    @Override
-    public void setModelContext(InstancesHeader raw_header) {
-
-        //set the multilabel model context
-        this.modelContext = raw_header;
-
-        // reset ensemble
-        this.resetLearningImpl();
-
-        for (int i = 0; i < this.ensemble.length; i++) {
-            this.ensemble[i].setModelContext(raw_header);
             this.ensemble[i].resetLearning();
         }
     }
@@ -77,14 +68,15 @@ public boolean isRandomizable() {
         return true;
     }
 
-	public Prediction getPredictionForInstance(MultiLabelInstance inst) {
-		DoubleVector[][] predictions = new DoubleVector[this.ensemble.length][getModelContext().numOutputAttributes()];
+	public Prediction getPredictionForInstance(StructuredInstance inst) {
+		int numTargets = getModelContext().numOutputAttributes();
+		DoubleVector[][] predictions = new DoubleVector[this.ensemble.length][numTargets];
 		for (int i = 0; i < this.ensemble.length; i++) {
 			Prediction basePrediction = this.ensemble[i].getPredictionForInstance(inst);
 			predictions[i] = ((MultiLabelPrediction) basePrediction).getPrediction();
 		}
-		DoubleVector[] prediction = new DoubleVector[getModelContext().numOutputAttributes()];
-		for (int j = 0; j < getModelContext().numOutputAttributes(); j++) {
+		DoubleVector[] prediction = new DoubleVector[numTargets];
+		for (int j = 0; j < numTargets; j++) {
 			prediction[j] = new DoubleVector();
 			for (int i = 0; i < this.ensemble.length; i++) {
 				prediction[j].addValues(predictions[i][j]);
@@ -94,7 +86,7 @@ public Prediction getPredictionForInstance(MultiLabelInstance inst) {
 		return new MultiLabelPrediction(prediction);
 	}
 	
-	public Prediction getPredictionForInstanceUsingN(MultiLabelInstance inst, int n) {
+	public Prediction getPredictionForInstanceUsingN(StructuredInstance inst, int n) {
 		int actual = Math.max(1, Math.min(n, this.ensemble.length));
 		DoubleVector[][] predictions = new DoubleVector[actual][getModelContext().numOutputAttributes()];
 		for (int i = 0; i < actual; i++) {
@@ -113,13 +105,13 @@ public Prediction getPredictionForInstanceUsingN(MultiLabelInstance inst, int n)
 	}
 
     @Override
-    public void trainOnInstanceImpl(MultiLabelInstance instance) {
+    public void trainOnInstanceImpl(StructuredInstance instance) {
         trainOnInstanceImpl((Instance) instance);
     }
     
     @Override
 	public Prediction getPredictionForInstance(Example<Instance> example) {
-		return getPredictionForInstance((MultiLabelInstance)example.getData());
+		return getPredictionForInstance((StructuredInstance)example.getData());
 	}
     
 }
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java
index a0ce07563..da8fdadd3 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java
@@ -1,12 +1,31 @@
 package moa.classifiers.multilabel.trees;
 
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Stack;
+
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
+import moa.classifiers.core.AttributeSplitSuggestion;
+import moa.classifiers.multilabel.core.attributeclassobservers.AttributeStatisticsObserver;
+import moa.classifiers.multilabel.core.splitcriteria.ICVarianceReduction;
+import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.classifiers.multilabel.core.splitcriteria.WeightedICVarianceReduction;
+import moa.classifiers.multilabel.trees.ISOUPTree.LeafNode;
+import moa.classifiers.multilabel.trees.ISOUPTree.MultitargetPerceptron;
+import moa.classifiers.multilabel.trees.ISOUPTree.Node;
+import moa.classifiers.multilabel.trees.ISOUPTree.SplitNode;
+import moa.classifiers.rules.core.AttributeExpansionSuggestion;
+import moa.classifiers.trees.FIMTDD.InnerNode;
+import moa.classifiers.trees.ORTO.OptionNode;
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
+import moa.core.StringUtils;
 
 public class ISOUPOptionTree extends ISOUPTree {
 
@@ -15,7 +34,7 @@ public class ISOUPOptionTree extends ISOUPTree {
 	private int optionNodeCount = 0;
 
 	private int numTrees = 1;
-	
+
 	//region ================ OPTIONS ================
 
 	public IntOption maxTreesOption = new IntOption(
@@ -38,7 +57,7 @@ public class ISOUPOptionTree extends ISOUPTree {
 
 	public MultiChoiceOption optionNodeAggregationOption = new MultiChoiceOption(
 			"optionNodeAggregation",
-			'o',
+			'p',
 			"The aggregation method used to combine predictions in option nodes.", 
 			new String[]{"average", "bestTree"}, new String[]{"Average", "Best tree"}, 0);
 
@@ -51,16 +70,16 @@ public class ISOUPOptionTree extends ISOUPTree {
 	//endregion ================ OPTIONS ================
 
 	//region ================ CLASSES ================
-	
+
 	public static class OptionNode extends InnerNode {
 		/**
 		 * 
 		 */
 		private static final long serialVersionUID = 1L;
-		
+
 		protected AutoExpandVector<DoubleVector> optionFFSSL;
 		protected AutoExpandVector<DoubleVector> optionFFSeen;
-		
+
 		public OptionNode(ISOUPTree tree) {
 			super(tree);
 		}
@@ -77,7 +96,7 @@ public void resetFF() {
 				}
 			}
 		}
-		
+
 		public int getNumSubtrees() {
 			int num = 0;
 			for (Node child : children) {
@@ -85,15 +104,15 @@ public int getNumSubtrees() {
 			}
 			return num;
 		}
-		
-		public double[] getPrediction(MultiLabelInstance inst) {
+
+		public double[] getPrediction(StructuredInstance inst) {
 			double[][] predictions = new double[numChildren()][tree.getModelContext().numOutputAttributes()];
 			for (int i = 0; i < numChildren(); i++) {
 				predictions[i] = getChild(i).getPrediction(inst);
 			}
 			return aggregate(predictions);
 		}
-		
+
 		private double[] aggregate(double[][] predictions) {
 			if (((ISOUPOptionTree) tree).optionNodeAggregationOption.getChosenIndex() == 0) { // Average
 				double[] sums = new double[tree.getModelContext().numOutputAttributes()];
@@ -111,7 +130,7 @@ private double[] aggregate(double[][] predictions) {
 				return new double[] {};
 			}
 		}
-		
+
 		public int directionForBestTree() {
 			int d = 0;
 			double min = Double.MAX_VALUE;
@@ -128,22 +147,34 @@ public int directionForBestTree() {
 			}
 			return d;
 		}
-		
+
 		public double getFFRatio(int childIndex, int targetIndex) {
 			return optionFFSSL.get(childIndex).getValue(targetIndex) / optionFFSeen.get(childIndex).getValue(targetIndex); 
 		}
-		
+
 		protected boolean skipInLevelCount() {
 			return true;
 		}
+
+		public void describeSubtree(StringBuilder out, int indent) {
+			for (int branch = 0; branch < children.size(); branch++) {
+				Node child = getChild(branch);
+				if (child != null) {
+					StringUtils.appendIndented(out, indent, "option");
+					out.append(branch);
+					StringUtils.appendNewline(out);
+					child.describeSubtree(out, indent + 2);
+				}
+			}			
+		}
 	}
-	
+
 	//endregion ================ CLASSES ================
-	
+
 	//region ================ METHODS ================
-	
+
 	public String getPurposeString() {
-		return "Implementation of the ORTO tree as described by Ikonomovska et al.";
+		return "Implementation of the iSOUPOptionTree";
 	}
 
 	public void resetLearningImpl() {
@@ -151,7 +182,7 @@ public void resetLearningImpl() {
 		this.optionNodeCount = 0;
 	}
 
-	
+
 	protected Measurement[] getModelMeasurementsImpl() {
 		return new Measurement[]{ 
 				new Measurement("number of subtrees", this.numTrees),
@@ -159,9 +190,18 @@ protected Measurement[] getModelMeasurementsImpl() {
 				//new Measurement("tree size (leaves)", this.leafNodeCount),
 				new Measurement("number of option nodes", this.optionNodeCount),};
 	}
-	
+
+	// region --- Object instantiation methods
+
+	protected OptionNode newOptionNode() {
+		maxID++;
+		return new OptionNode(this);
+	}
+
+	// endregion --- Object instantiation methods
+
 	@Override
-	public void processInstance(MultiLabelInstance inst, Node node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
+	public void processInstance(StructuredInstance inst, Node node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
 		if (node instanceof OptionNode) {
 			processInstanceOptionNode(inst, (OptionNode) node, prediction, normalError, growthAllowed, inAlternate);
 		} else {
@@ -225,7 +265,7 @@ public void processInstance(MultiLabelInstance inst, Node node, double[] predict
 //							break;
 //						}
 //					}
-				
+
 //					if (iNode.changeDetection && !inAlternate) {
 //						if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
 //							iNode.initializeAlternateTree();
@@ -240,18 +280,18 @@ public void processInstance(MultiLabelInstance inst, Node node, double[] predict
 				}
 			}
 		}
-		
+
 	}
-	
-	public void processInstanceOptionNode(MultiLabelInstance inst, OptionNode node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
-//		if (node.changeDetection) {
-//			double error = Math.abs(prediction - inst.classValue());
-//			node.sumOfAbsErrors += error;
-//			
-//			if (((InnerNode) node).PageHinckleyTest(error - node.sumOfAbsErrors / node.examplesSeen + PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
-//				node.initializeAlternateTree();
-//			}
-//		}
+
+	public void processInstanceOptionNode(StructuredInstance inst, OptionNode node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
+		//		if (node.changeDetection) {
+		//			double error = Math.abs(prediction - inst.classValue());
+		//			node.sumOfAbsErrors += error;
+		//			
+		//			if (((InnerNode) node).PageHinckleyTest(error - node.sumOfAbsErrors / node.examplesSeen + PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+		//				node.initializeAlternateTree();
+		//			}
+		//		}
 
 		for (Node child : node.children) {
 			int i = node.getChildIndex(child);
@@ -266,7 +306,220 @@ public void processInstanceOptionNode(MultiLabelInstance inst, OptionNode node,
 			processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed && node.alternateTree == null, inAlternate);
 		}
 	}
-	
+
 	//endregion ================ METHODS ================
 
+	protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex) {
+		//System.out.println("Evaluating splits");
+		//System.out.println(examplesSeen);
+		// Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
+		MultiLabelSplitCriterion splitCriterion = new WeightedICVarianceReduction(targetWeights);
+
+		// Using this criterion, find the best split per attribute and rank the results
+		AttributeExpansionSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion); // TODO update with split criterion option
+		List<AttributeExpansionSuggestion> acceptedSplits = new LinkedList<AttributeExpansionSuggestion>();
+		Arrays.sort(bestSplitSuggestions);
+
+		// Declare a variable to determine the number of splits to be performed
+		int numSplits = 0;
+
+		// If only one split was returned, use it
+		if (bestSplitSuggestions.length == 1) {
+			numSplits = 1;
+			acceptedSplits.add(bestSplitSuggestions[0]);
+		} else if (bestSplitSuggestions.length > 1) { // Otherwise, consider which of the splits proposed may be worth trying
+
+			// Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
+			// to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
+			double hoeffdingBound = computeHoeffdingBound(1, splitConfidenceOption.getValue(), node.examplesSeen);
+			// Determine the top two ranked splitting suggestions
+			AttributeExpansionSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+			AttributeExpansionSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
+
+			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
+			// as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
+			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
+			// splitting should occur.
+			// Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
+			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
+			// competing attributes are equally good, and the split will be made on the one with the higher SDR value.
+			//System.out.print(hoeffdingBound);
+			//System.out.print(" ");
+			///System.out.println(secondBestSuggestion.merit / bestSuggestion.merit);
+			if (secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) {
+				numSplits = 1;
+				acceptedSplits.add(bestSuggestion);
+			} else if (numTrees < maxTreesOption.getValue() && node.getLevel() <= maxOptionLevelOption.getValue()) {
+				for (int i = 0; i < bestSplitSuggestions.length; i++) {
+					AttributeExpansionSuggestion suggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1 - i];
+					if (suggestion.merit / bestSuggestion.merit >= 1 - hoeffdingBound) {
+						numSplits++;
+						acceptedSplits.add(suggestion);
+					} else {
+						break;
+					}
+				}
+
+			} else if (hoeffdingBound < this.tieThresholdOption.getValue()) {
+				numSplits = 1;
+				acceptedSplits.add(bestSuggestion);
+			}
+			else {
+				// If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
+				// TODO pruning is currently disabled
+				for (int i = 0; i < node.attributeObservers.size(); i++) {
+					AttributeStatisticsObserver obs = node.attributeObservers.get(i);
+					if (obs != null) {
+						if (getModelContext().attribute(i).isNumeric());
+						//TODO obs.removeBadSplits(null, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound, getModelContext().numOutputAttributes());
+						if (getModelContext().attribute(i).isNominal());
+						// TODO nominal class observers
+					}
+				}
+			}
+		}
+
+		// If the splitting criterion were met, split the current node using the chosen attribute test, and
+		// make two new branches leading to (empty) leaves
+		if (numSplits > 0) {
+			double optionFactor = numSplits * Math.pow(optionDecayFactorOption.getValue(), (double) node.getLevel());
+			log(Integer.toString(node.ID) + ',' + Integer.toString((int) this.examplesSeen));
+
+			if (numSplits == 1 || optionFactor < 2.0 || maxTreesOption.getValue() - numTrees <= 1) {
+				AttributeExpansionSuggestion splitDecision = acceptedSplits.get(0);
+				SplitNode newSplit = newSplitNode(splitDecision.getPredicate());
+				newSplit.ID = node.ID;
+
+				for (int i = 0; i < 2 /* TODO Hardcoded for Predicate class */; i++) {
+					LeafNode newChild = newLeafNode();
+					newChild.setParent(newSplit);
+					newSplit.setChild(i, newChild);
+				}
+				//leafNodeCount--;
+				//innerNodeCount++;
+				//leafNodeCount += splitDecision.numSplits();
+				if (parent == null && node.originalNode == null) {
+					treeRoot = newSplit;
+				} else if (parent == null && node.originalNode != null) {
+					node.originalNode.alternateTree = newSplit;
+				} else {
+					parent.setChild(parentIndex, newSplit);
+					newSplit.setParent(parent);
+				}
+			} else {
+
+				OptionNode optionNode = newOptionNode();
+				optionNode.ID = node.ID;
+
+				//leafNodeCount--;
+				int j = 0;
+
+				for (AttributeExpansionSuggestion splitDecision : acceptedSplits) {
+					if (j > optionFactor || maxTreesOption.getValue() - numTrees <= 0) {
+						break;
+					}
+					SplitNode newSplit = newSplitNode(splitDecision.getPredicate());
+					for (int i = 0; i < 2 /* TODO Hardcoded for Predicate class */; i++) {
+						LeafNode newChild = newLeafNode();
+						newChild.setParent(newSplit);
+						newSplit.setChild(i, newChild);
+					}
+
+					//leafNodeCount += splitDecision.numSplits();
+					//innerNodeCount++;
+					numTrees++;
+
+					newSplit.setParent(optionNode);
+					optionNode.setChild(j, newSplit);
+					j++;
+				}
+
+				//innerNodeCount++;
+				optionNodeCount++;
+
+				if (parent == null) {
+					treeRoot = optionNode;
+				} else {
+					parent.setChild(parentIndex, optionNode);
+					optionNode.setParent(parent);
+				}
+
+				optionNode.resetFF();
+			}
+		}
+	}
+
+	// region --- Option tree methods
+	protected Node findWorstOption() {
+		Stack<Node> stack = new Stack<Node>();
+		stack.add(treeRoot);
+
+		double ratio = Double.MIN_VALUE;
+		Node out = null;
+
+		while (!stack.empty()) {
+			Node node = stack.pop();
+			if (node.getParent() instanceof OptionNode) {
+				OptionNode myParent = (OptionNode) node.getParent();
+				int nodeIndex = myParent.getChildIndex(node);
+				DoubleVector nodeRatios = new DoubleVector();
+				for (int i = 0; i < getModelContext().numOutputAttributes(); i++) {
+					nodeRatios.setValue(i, myParent.getFFRatio(nodeIndex, i));
+				}
+				double nodeRatio = nodeRatios.sumOfValues() / nodeRatios.numValues(); 
+
+				if (nodeRatio > ratio) {
+					ratio = nodeRatio;
+					out = node;
+				}
+			}
+			if (node instanceof InnerNode) {
+				for (Node child : ((InnerNode) node).children) {
+					stack.add(child);
+				}
+			}
+		}
+
+		return out;
+	}
+
+	protected void removeExcessTrees() {
+		while (numTrees > maxTreesOption.getValue()) {
+			Node option = findWorstOption();
+			OptionNode parent = (OptionNode) option.parent;
+			int index = parent.getChildIndex(option);
+
+			if (parent.children.size() == 2) {
+				parent.children.remove(index);
+				for (Node chld : parent.children) {
+					chld.parent = parent.parent;
+					parent.parent.setChild(parent.parent.getChildIndex(parent), chld);
+				}
+			} else {
+				AutoExpandVector<Node> children = new AutoExpandVector<Node>();
+				AutoExpandVector<DoubleVector> optionFFSSL = new AutoExpandVector<DoubleVector>();
+				AutoExpandVector<DoubleVector> optionFFSeen = new AutoExpandVector<DoubleVector>();
+
+				int seen = 0;
+
+				for (int i = 0; i < parent.children.size() - 1; i++) {
+					if (parent.getChild(i) != option) {
+						children.add(parent.getChild(i));
+						optionFFSSL.set(i, parent.optionFFSSL.get(i + seen));
+						optionFFSeen.set(i, parent.optionFFSeen.get(i + seen));
+					} else {
+						seen = 1;
+					}
+				}
+
+				parent.children = children;
+				parent.optionFFSSL = optionFFSSL;
+				parent.optionFFSeen = optionFFSeen;
+
+				assert parent.children.size() == parent.optionFFSSL.size();
+			}
+			numTrees--;
+		}
+	}
+
 }
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
index 3596120c3..853405dd8 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
@@ -26,15 +26,23 @@
 package moa.classifiers.multilabel.trees;
 
 
+import java.io.BufferedWriter;
+import java.io.FileWriter;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Paths;
 import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Vector;
 
+import com.github.javacliparser.FileOption;
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 
@@ -46,8 +54,8 @@
 import moa.classifiers.multilabel.core.attributeclassobservers.MultiLabelNominalAttributeObserver;
 import moa.classifiers.multilabel.core.attributeclassobservers.NominalStatisticsObserver;
 import moa.classifiers.multilabel.core.attributeclassobservers.NumericStatisticsObserver;
-import moa.classifiers.multilabel.core.splitcriteria.ICVarianceReduction;
 import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.classifiers.multilabel.core.splitcriteria.WeightedICVarianceReduction;
 import moa.classifiers.rules.core.AttributeExpansionSuggestion;
 import moa.classifiers.rules.core.Predicate;
 import moa.core.AutoExpandVector;
@@ -57,18 +65,18 @@
 import moa.core.StringUtils;
 
 /**
- * iSOUPTrees class for structured output prediction.
+ * iSOUPTree class for structured output prediction.
  *
  * @author Aljaž Osojnik (aljaz.osojnik@ijs.si)
  * @version $Revision: 1 $
  */
 public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetRegressor {
-
+	
 	private static final long serialVersionUID = 1L;
 
 	public Node treeRoot;
 
-	private double examplesSeen = 0.0;
+	protected double examplesSeen = 0.0;
 	private DoubleVector sumOfValues = new DoubleVector();
 	private DoubleVector sumOfSquares = new DoubleVector();
 
@@ -76,6 +84,10 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 	private DoubleVector sumOfAttrSquares = new DoubleVector();
 
 	public int maxID = 0;
+	
+	private BufferedWriter writer;
+	
+	public DoubleVector targetWeights;
 
 	//region ================ OPTIONS ================
 
@@ -154,6 +166,13 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 			'n',
 			"Don't normalize.");
 
+	public FlagOption randomForestBaseModelOption = new FlagOption(
+			"randomForestBaseModel",
+			'z',
+			"Use the learner as a base model in a random forest.");
+	
+	public FileOption weightFile = new FileOption("targetWeightFile", 'w', "File with the weights of the targets.", null, null, false);
+
 	//endregion ================ OPTIONS ================
 
 	//region ================ CLASSES ================
@@ -169,7 +188,7 @@ public abstract static class Node extends AbstractMOAObject {
 		protected ISOUPTree tree;
 
 		// The parent of this particular node
-		protected SplitNode parent;
+		protected InnerNode parent;
 
 		protected Node alternateTree;
 		protected Node originalNode;
@@ -191,6 +210,7 @@ public abstract static class Node extends AbstractMOAObject {
 
 		public Node(ISOUPTree tree) {
 			this.tree = tree;
+			this.ID = tree.maxID;
 		}
 
 		public void copyStatistics(Node node) {
@@ -206,7 +226,7 @@ public int calcByteSize() {
 		/**
 		 * Set the parent node
 		 */
-		public void setParent(SplitNode parent) {
+		public void setParent(InnerNode parent) {
 			this.parent = parent;    
 		}
 
@@ -227,10 +247,10 @@ public void restartChangeDetection() {
 
 		public void getDescription(StringBuilder sb, int i) {}
 
-		public double[] getPrediction(MultiLabelInstance inst) {
+		public double[] getPrediction(StructuredInstance inst) {
 			return null;
 		}
-
+		
 		public void describeSubtree(StringBuilder out, int indent) {
 			StringUtils.appendIndented(out, indent, "Leaf");
 		}
@@ -278,6 +298,8 @@ public static class LeafNode extends Node {
 
 		public DoubleVector errorP = new DoubleVector();
 		public DoubleVector errorM = new DoubleVector();
+		
+		public List<Integer> inputIndexes = null;
 
 		protected double examplesSeenAtLastSplitEvaluation = 0;
 
@@ -289,17 +311,38 @@ public LeafNode(ISOUPTree tree) {
 			if (tree.buildingModelTree()) {
 				learningModel = tree.newLeafModel();
 			}
+			initializeInputIndexes();
 			examplesSeen = 0;
 			sumOfValues = new DoubleVector();
 			sumOfSquares = new DoubleVector();
 		}
 
+		public void initializeInputIndexes() {
+			List<Integer> indexes = new Vector<Integer>();
+			int numAttrs = tree.getModelContext().numInputAttributes();
+			for (int i = 0; i < numAttrs; i++) {
+				indexes.add(i, i);
+			}
+			if (tree.buildingRandomForestTree()) {
+				// Select the first sqrt(n) attribute indexes
+				for (int i = 0; i < Math.ceil(Math.sqrt(numAttrs)); i++) {
+					int swap = i + tree.classifierRandom.nextInt(numAttrs - i);
+					int temp = indexes.get(i);
+					indexes.set(i, indexes.get(swap));
+					indexes.set(swap, temp);
+				}
+				inputIndexes = indexes.subList(0, (int) Math.ceil(Math.sqrt(numAttrs)));
+			} else {
+				inputIndexes = indexes;
+			}
+		}
+		
 		/**
 		 * Method to learn from an instance that passes the new instance to the perceptron learner,
 		 * and also prevents the class value from being truncated to an int when it is passed to the
 		 * attribute observer
 		 */
-		public void learnFromInstance(MultiLabelInstance inst, double[] prediction, boolean growthAllowed) {
+		public void learnFromInstance(StructuredInstance inst, double[] prediction, boolean growthAllowed) {
 			// Update the statistics for this node
 
 			double[] predictionP = tree.buildingModelTree() ? getPredictionModel(inst) : null;
@@ -323,7 +366,7 @@ public void learnFromInstance(MultiLabelInstance inst, double[] prediction, bool
 
 			if (tree.buildingModelTree()) learningModel.updatePerceptron(inst);
 
-			for (int i = 0; i < inst.numInputAttributes(); i++) {
+			for (int i : inputIndexes) {
 				AttributeStatisticsObserver obs = attributeObservers.get(i);
 				if (obs == null) {
 					// At this stage all nominal attributes are ignored
@@ -362,7 +405,7 @@ public AttributeExpansionSuggestion[] getBestSplitSuggestions(MultiLabelSplitCri
 
 			List<AttributeExpansionSuggestion> bestSuggestions = new LinkedList<AttributeExpansionSuggestion>();
 
-			for (int i = 0; i < attributeObservers.size(); i++) {
+			for (int i : inputIndexes) {
 				AttributeStatisticsObserver obs = attributeObservers.get(i);
 				if (obs != null) {
 					DoubleVector[] preSplitStatistics = new DoubleVector[tree.getModelContext().numOutputAttributes()];
@@ -387,11 +430,11 @@ public AttributeExpansionSuggestion[] getBestSplitSuggestions(MultiLabelSplitCri
 		/**
 		 * Retrieve the class votes using the perceptron learner
 		 */
-		public double[] getPredictionModel(MultiLabelInstance inst) {
+		public double[] getPredictionModel(StructuredInstance inst) {
 			return learningModel.prediction(inst);
 		}
 
-		public double[] getPredictionTargetMean(MultiLabelInstance inst) {
+		public double[] getPredictionTargetMean(StructuredInstance inst) {
 			double[] pred = new double[inst.numOutputAttributes()];
 			for (int i = 0; i < inst.numOutputAttributes(); i++) {
 				if (examplesSeen > 0) {
@@ -403,7 +446,7 @@ public double[] getPredictionTargetMean(MultiLabelInstance inst) {
 			return pred;
 		}
 
-		public double[] getPrediction(MultiLabelInstance inst) {
+		public double[] getPrediction(StructuredInstance inst) {
 			if (tree.buildingModelTree()) {
 				double[] predictionP = getPredictionModel(inst);
 				double[] predictionM = getPredictionTargetMean(inst);
@@ -438,11 +481,14 @@ public void checkForSplit() {
 		}
 
 		public void describeSubtree(StringBuilder out, int indent) {
-			StringUtils.appendIndented(out, indent, "Leaf ");
+			StringUtils.appendIndented(out, indent, "Leaf");
+			StringUtils.appendNewline(out);
+			
 			if (tree.buildingModelTree()) {
-				learningModel.getModelDescription(out, 0);
+				learningModel.getModelDescription(out, indent + 2);
 			} else {
 				//out.append(tree.getClassNameString() + " = " + String.format("%.4f", (sumOfValues / examplesSeen)));
+				out.append("Leaf node");
 				StringUtils.appendNewline(out);
 			}
 		}
@@ -567,7 +613,7 @@ public SplitNode(Predicate predicate, ISOUPTree tree) {
 			ID = tree.maxID;
 		}
 
-		public int instanceChildIndex(MultiLabelInstance inst) {
+		public int instanceChildIndex(StructuredInstance inst) {
 			return (predicate.evaluate(inst)) ? 0 : 1;
 		}
 
@@ -577,7 +623,7 @@ public void describeSubtree(StringBuilder out, int indent) {
 				if (child != null) {
 					if (branch == 0) {
 						StringUtils.appendIndented(out, indent, "if ");
-						this.predicate.getDescription(out, 0);
+						this.predicate.getDescription(out, 0, tree.getModelContext());
 					} else {
 						StringUtils.appendIndented(out, indent, "else");
 					}
@@ -588,7 +634,7 @@ public void describeSubtree(StringBuilder out, int indent) {
 			}
 		}
 
-		public double[] getPrediction(MultiLabelInstance inst) {
+		public double[] getPrediction(StructuredInstance inst) {
 			return children.get(predicate.evaluate(inst) ? 0 : 1).getPrediction(inst);
 		}
 	}
@@ -635,7 +681,7 @@ public void initializeWeights() {
 		/**
 		 * Update the model using the provided instance
 		 */
-		public void updatePerceptron(MultiLabelInstance inst) {
+		public void updatePerceptron(StructuredInstance inst) {
 			// Update attribute statistics
 			instancesSeen += inst.weight();
 
@@ -653,7 +699,7 @@ public void updatePerceptron(MultiLabelInstance inst) {
 			}
 		}
 
-		public void updateWeights(MultiLabelInstance inst, double learningRatio) {
+		public void updateWeights(StructuredInstance inst, double learningRatio) {
 			if (instancesSeen > 1.0) {
 				// Compute the normalized instance and the delta
 				double[] normalizedInput = tree.normalizedInputVector(inst); 
@@ -694,7 +740,7 @@ public double[] prediction(double[] instanceValues) {
 			return out;
 		}
 
-		private double[] prediction(MultiLabelInstance inst) {
+		private double[] prediction(StructuredInstance inst) {
 			double[] normalizedInput = tree.normalizedInputVector(inst);
 			double[] normalizedPrediction = prediction(normalizedInput);
 			return denormalizePrediction(normalizedPrediction);
@@ -716,18 +762,18 @@ private double[] denormalizePrediction(double[] normalizedPrediction) {
 		}
 
 		public void getModelDescription(StringBuilder out, int indent) {
-			for (int i = 0; i < tree.getModelContext().numOutputAttributes(); i++) {
-				StringUtils.appendIndented(out, indent, " [" + tree.getModelContext().outputAttribute(i).name() + "]");
-				if (getModelContext() != null) {
-					for (int j = 0; j < getModelContext().numOutputAttributes(); j++) {
-						if (getModelContext().attribute(j).isNumeric()) {
-							out.append((j == 0 || weights[i][j] < 0) ? " " : " + ");
-							out.append(String.format("%.4f", weights[i][j]));
+			if (getModelContext() != null) {
+				for (int i = 0; i < tree.getModelContext().numOutputAttributes(); i++) {
+					StringUtils.appendIndented(out, indent, " [" + tree.getModelContext().outputAttribute(i).name() + "] =");
+					for (int j = 0; j < getModelContext().numInputAttributes(); j++) {
+						if (getModelContext().inputAttribute(j).isNumeric()) {
+							out.append((j == 0 && weights[i][j] >= 0) ? " " : (weights[i][j] < 0) ? " - " : " + ");
+							out.append(String.format("%.4f", Math.abs(weights[i][j])));
 							out.append(" * ");
-							out.append(getAttributeNameString(j));
+							out.append(getModelContext().inputAttribute(j).name());
 						}
 					}
-					out.append(" + " + weights[i][getModelContext().numOutputAttributes()]);
+					out.append((weights[i][getModelContext().numInputAttributes()] < 0 ? " - " : " + ") + String.format("%.4f", Math.abs(weights[i][getModelContext().numInputAttributes()])));
 				}
 				StringUtils.appendNewline(out);
 			}
@@ -739,7 +785,9 @@ public void getModelDescription(StringBuilder out, int indent) {
 	//region ================ METHODS ================
 
 	// Regressor methods
-	public ISOUPTree() {}
+	public ISOUPTree() {
+		super();
+	}
 
 	public String getPurposeString() {
 		return "Implementation of the iSOUP-Tree algorithm as described by Osojnik et al.";
@@ -753,8 +801,19 @@ public void resetLearningImpl() {
 
 		sumOfAttrValues = new DoubleVector();
 		sumOfAttrSquares = new DoubleVector();
+		loadWeights();
 	}
 
+	public void loadWeights() {
+		targetWeights = new DoubleVector();
+		try {
+			List<String> lines = Files.readAllLines(Paths.get(weightFile.getValue()), Charset.defaultCharset());
+			for (int i = 0 ; i < lines.size(); i++) targetWeights.setValue(i, Double.valueOf(lines.get(i)));
+		} catch (Exception e) {
+			for (int i = 0; i < getModelContext().numOutputAttributes(); i++) targetWeights.setValue(i, 1.0);
+		}
+	}
+	
 	public boolean isRandomizable() {
 		return true;
 	}
@@ -762,7 +821,7 @@ public boolean isRandomizable() {
 	public void getModelDescription(StringBuilder out, int indent) {
 		if (treeRoot != null) treeRoot.describeSubtree(out, indent);
 	}
-
+	
 	protected Measurement[] getModelMeasurementsImpl() {
 		return new Measurement[]{ 
 				//new Measurement("tree size (nodes)", this.leafNodeCount + this.splitNodeCount),
@@ -778,7 +837,7 @@ public int calcByteSize() {
 		return size;
 	}
 
-	public Prediction getPredictionForInstance(MultiLabelInstance inst) {
+	public Prediction getPredictionForInstance(StructuredInstance inst) {
 		checkRoot();
 		double[] predictionVector = treeRoot.getPrediction(inst);
 		MultiLabelPrediction prediction = new MultiLabelPrediction(getModelContext().numOutputAttributes());
@@ -788,7 +847,7 @@ public Prediction getPredictionForInstance(MultiLabelInstance inst) {
 		return prediction;
 	}
 
-	public double[] normalizedInputVector(MultiLabelInstance inst) {
+	public double[] normalizedInputVector(StructuredInstance inst) {
 		// Normalize Instance
 		double[] normalizedInput = new double[inst.numInputAttributes()+1];
 		if (normalize()) {
@@ -818,7 +877,7 @@ public double[] normalizedInputVector(MultiLabelInstance inst) {
 		return normalizedInput;
 	}
 
-	public double[] normalizedTargetVector(MultiLabelInstance inst) {
+	public double[] normalizedTargetVector(StructuredInstance inst) {
 		double[] out = new double[getModelContext().numOutputAttributes()];
 		if (normalize()) {
 			for (int i = 0; i < inst.numOutputAttributes(); i++) {
@@ -855,7 +914,7 @@ public double[] normalizeTargetVector(double[] pred) {
 	}
 
 
-	public double normalizeTargetValue(MultiLabelInstance inst, int i) {
+	public double normalizeTargetValue(StructuredInstance inst, int i) {
 		if (normalize()) {
 			if (examplesSeen > 1) {
 				double value = inst.valueOutputAttribute(i);
@@ -884,7 +943,7 @@ public double normalizeTargetValue(double value, int i) {
 		} else return value;
 	}
 
-	public double[] getNormalizedError(MultiLabelInstance inst, double[] prediction) {
+	public double[] getNormalizedError(StructuredInstance inst, double[] prediction) {
 		double[] normalPrediction = normalizeTargetVector(prediction);
 		double[] normalValue = normalizedTargetVector(inst);
 		double[] out = new double[getModelContext().numOutputAttributes()];
@@ -898,7 +957,7 @@ public double[] getNormalizedError(MultiLabelInstance inst, double[] prediction)
 	/**
 	 * Method for updating (training) the model using a new instance
 	 */
-	 public void trainOnInstanceImpl(MultiLabelInstance inst) {
+	 public void trainOnInstanceImpl(StructuredInstance inst) {
 		 if (inst.weight() > 0) {
 			 checkRoot();
 
@@ -920,7 +979,7 @@ public void trainOnInstanceImpl(MultiLabelInstance inst) {
 		 }
 	 }
 
-	 public void processInstance(MultiLabelInstance inst, Node node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
+	 public void processInstance(StructuredInstance inst, Node node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
 		 Node currentNode = node;
 		 while (true) {
 			 if (currentNode instanceof LeafNode) {
@@ -1031,22 +1090,24 @@ protected void checkRoot() {
 	 }
 
 	 public static double computeHoeffdingBound(double range, double confidence, double n) {
-		 return Math.sqrt(( (range * range) * Math.log(1 / confidence)) / (2.0 * n));
+		 return Math.sqrt(((range * range) * Math.log(1 / confidence)) / (2.0 * n));
 	 }
 
 	 public boolean buildingModelTree() {
 		 return !regressionTreeOption.isSet();
 	 }
+	 
+	 public boolean buildingRandomForestTree() {
+		 return randomForestBaseModelOption.isSet();
+	 }
 
 	 public boolean normalize() {
 		 return !doNotNormalizeOption.isSet();
 	 }
 
-	 protected void attemptToSplit(LeafNode node, SplitNode parent, int parentIndex) {
-		 //System.out.println("Evaluating splits");
-		 //System.out.println(examplesSeen);
+	 protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex) {
 		 // Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
-		 MultiLabelSplitCriterion splitCriterion = new ICVarianceReduction();
+		 MultiLabelSplitCriterion splitCriterion = new WeightedICVarianceReduction(targetWeights);
 
 		 // Using this criterion, find the best split per attribute and rank the results
 		 AttributeExpansionSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion); // TODO update with split criterion option
@@ -1054,7 +1115,6 @@ protected void attemptToSplit(LeafNode node, SplitNode parent, int parentIndex)
 
 		 // Declare a variable to determine if any of the splits should be performed
 		 boolean shouldSplit = false;
-
 		 // If only one split was returned, use it
 		 if (bestSplitSuggestions.length < 2) {
 			 shouldSplit = bestSplitSuggestions.length > 0;
@@ -1074,9 +1134,6 @@ protected void attemptToSplit(LeafNode node, SplitNode parent, int parentIndex)
 			 // Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
 			 // (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
 			 // competing attributes are equally good, and the split will be made on the one with the higher SDR value.
-			 //System.out.print(hoeffdingBound);
-			 //System.out.print(" ");
-			 ///System.out.println(secondBestSuggestion.merit / bestSuggestion.merit);
 			 if ((secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) || (hoeffdingBound < this.tieThresholdOption.getValue())) {
 				 shouldSplit = true;
 			 }
@@ -1101,9 +1158,11 @@ protected void attemptToSplit(LeafNode node, SplitNode parent, int parentIndex)
 			 AttributeExpansionSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
 
 			 SplitNode newSplit = newSplitNode(splitDecision.predicate);
+			 newSplit.ID = node.ID;
 			 newSplit.copyStatistics(node);
 			 newSplit.changeDetection = node.changeDetection;
 			 newSplit.ID = node.ID;
+			 log(Integer.toString(node.ID) + ',' + Integer.toString((int) this.examplesSeen));
 			 for (int i = 0; i < 2; i++) { // Hardcoded for 2 values (due to the use of the Predicate class)
 				 LeafNode newChild = newLeafNode();
 				 if (buildingModelTree()) {
@@ -1126,7 +1185,7 @@ protected void attemptToSplit(LeafNode node, SplitNode parent, int parentIndex)
 		 }
 	 }
 
-	 public  double computeSD(double squaredVal, double val, double size) {
+	 public double computeSD(double squaredVal, double val, double size) {
 		 if (size > 1)
 			 return Math.sqrt((squaredVal - ((val * val) / size)) / size);
 		 else
@@ -1141,6 +1200,38 @@ public static double scalarProduct(DoubleVector u, DoubleVector v) {
 		 return ret;
 	 }
 	 //endregion --- Processing methods
-
+	 
+	 public void initWriter(String filename) {
+		 try {
+			 writer = new BufferedWriter(new FileWriter(filename));
+			 writer.write("");
+			 writer.close();
+			 writer = new BufferedWriter(new FileWriter(filename, true));
+		 } catch (Exception e) {
+			 e.printStackTrace();
+		 }
+	 }
+	 
+	 public void closeWriter() {
+		 try {
+		 writer.close();
+		 } catch (Exception e) {
+			 e.printStackTrace();
+		 }
+		 writer = null;
+		 
+	 }
+	 
+	 public void log(String s) {
+		 if (writer != null) {
+			 try {
+				 writer.write(s + "\n");
+				 writer.flush();
+			 } catch (Exception e) {
+				 e.printStackTrace();
+			 }
+		 }
+	 }
+	 
 	 //endregion ================ METHODS ================
 }
diff --git a/moa/src/main/java/moa/classifiers/multitarget/BasicMultiTargetRegressor.java b/moa/src/main/java/moa/classifiers/multitarget/BasicMultiTargetRegressor.java
index 56c3985a5..93c1c94a1 100644
--- a/moa/src/main/java/moa/classifiers/multitarget/BasicMultiTargetRegressor.java
+++ b/moa/src/main/java/moa/classifiers/multitarget/BasicMultiTargetRegressor.java
@@ -16,7 +16,7 @@
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.Instances;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 
@@ -47,7 +47,7 @@ public void resetLearningImpl() {
 	}
 
 	@Override
-	public void trainOnInstanceImpl(MultiLabelInstance instance) {
+	public void trainOnInstanceImpl(StructuredInstance instance) {
 		if (this.hasStarted == false){		
 			this.ensemble = new Classifier[instance.numberOutputTargets()];
 			Classifier baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
@@ -65,7 +65,7 @@ public void trainOnInstanceImpl(MultiLabelInstance instance) {
 
 	protected InstancesHeader[] header;
 
-	protected Instance transformInstance(MultiLabelInstance inst, int outputIndex) {
+	protected Instance transformInstance(StructuredInstance inst, int outputIndex) {
 		if (header == null) {
 			this.header = new InstancesHeader[this.ensemble.length];
 		}
@@ -128,7 +128,7 @@ public void getModelDescription(StringBuilder out, int indent) {
 	
 
 	@Override
-	public Prediction getPredictionForInstance(MultiLabelInstance instance) {
+	public Prediction getPredictionForInstance(StructuredInstance instance) {
 		Prediction prediction=null;
 		if (this.hasStarted){ 
 			prediction=new MultiLabelPrediction(ensemble.length);
diff --git a/moa/src/main/java/moa/classifiers/multitarget/functions/MultiTargetNoChange.java b/moa/src/main/java/moa/classifiers/multitarget/functions/MultiTargetNoChange.java
index 0f61f4e73..9f08ed855 100644
--- a/moa/src/main/java/moa/classifiers/multitarget/functions/MultiTargetNoChange.java
+++ b/moa/src/main/java/moa/classifiers/multitarget/functions/MultiTargetNoChange.java
@@ -4,7 +4,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstanceData;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 
@@ -37,7 +37,7 @@ public void resetLearningImpl() {
     }
 
     @Override
-    public void trainOnInstanceImpl(MultiLabelInstance inst) {
+    public void trainOnInstanceImpl(StructuredInstance inst) {
     	int numOutputs = inst.numberOutputTargets();
     	Prediction prediction = new MultiLabelPrediction(numOutputs);
     	
@@ -65,7 +65,7 @@ public boolean isRandomizable() {
     }
 
 	@Override
-	public Prediction getPredictionForInstance(MultiLabelInstance inst) {
+	public Prediction getPredictionForInstance(StructuredInstance inst) {
 		//return (lastSeenClasses!=null) ? this.lastSeenClasses : new MultiLabelPrediction();
 		return (lastSeenClasses!=null) ? this.lastSeenClasses : null;
 	}
diff --git a/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java
index 8d835fb5a..fb5505ef7 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java
@@ -1,7 +1,8 @@
 package moa.classifiers.rules.core;
 
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.AbstractMOAObject;
 import moa.core.StringUtils;
@@ -23,10 +24,10 @@ public NominalRulePredicate(int inputAttributeIndex, double attributeValue, bool
 	}
 	@Override
 	public boolean evaluate(Instance instance){
-		return evaluate((MultiLabelInstance) instance);
+		return evaluate((StructuredInstance) instance);
 	}
 
-	public boolean evaluate(MultiLabelInstance instance) {
+	public boolean evaluate(StructuredInstance instance) {
 		if (instance.isMissing(inputAttributeIndex)) {
 			return false;
 		}
@@ -68,5 +69,11 @@ public int getAttributeIndex() {
 	public boolean isEqualOrLess() {
 		return isEqual;
 	}
-
+	@Override
+	public void getDescription(StringBuilder sb, int indent, InstancesHeader header) {
+		if(isEqual)
+			StringUtils.appendIndented(sb, indent, InstancesHeader.getAttributeNameString(header, inputAttributeIndex) + " == " + attributeValue);
+		else
+			StringUtils.appendIndented(sb, indent, InstancesHeader.getAttributeNameString(header, inputAttributeIndex) + " <> " + attributeValue);
+	}
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java
index 6084fbae6..8387610c0 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java
@@ -1,7 +1,8 @@
 package moa.classifiers.rules.core;
 
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.AbstractMOAObject;
 import moa.core.StringUtils;
@@ -23,10 +24,10 @@ public NumericRulePredicate(int inputAttributeIndex, double attributeValue, bool
 	}
 	@Override
 	public boolean evaluate(Instance instance){
-		return evaluate((MultiLabelInstance) instance);
+		return evaluate((StructuredInstance) instance);
 	}
 
-	public boolean evaluate(MultiLabelInstance instance) {
+	public boolean evaluate(StructuredInstance instance) {
 		if (instance.isMissing(inputAttributeIndex)) {
 			return false;
 		}
@@ -69,5 +70,14 @@ public boolean isEqualOrLess() {
 		return isEqualOrLower;
 	}
 
+	public double getAttributeValue() {
+		return attributeValue;
+	}
+	@Override
+	public void getDescription(StringBuilder sb, int indent, InstancesHeader header) {
+		if(isEqualOrLower)
+			StringUtils.appendIndented(sb, indent, InstancesHeader.getAttributeNameString(header, inputAttributeIndex) + " <= " + attributeValue);
+		else
+			StringUtils.appendIndented(sb, indent, InstancesHeader.getAttributeNameString(header, inputAttributeIndex) + " > " + attributeValue);	}
 
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/core/Predicate.java b/moa/src/main/java/moa/classifiers/rules/core/Predicate.java
index f7f120d5d..75517efc3 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/Predicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/Predicate.java
@@ -20,6 +20,7 @@
 package moa.classifiers.rules.core;
 
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public interface Predicate {
 	
@@ -28,5 +29,6 @@ public interface Predicate {
 	 public int getAttributeIndex();
 	 public boolean isEqualOrLess();
 	 public void getDescription(StringBuilder sb, int indent);
+	 public void getDescription(StringBuilder sb, int indent, InstancesHeader header);
 	 
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AbstractAnomalyDetector.java b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AbstractAnomalyDetector.java
index dea1adf2c..13a4f85ba 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AbstractAnomalyDetector.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AbstractAnomalyDetector.java
@@ -1,7 +1,7 @@
 package moa.classifiers.rules.core.anomalydetection;
 
 import moa.options.AbstractOptionHandler;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 
 public abstract class AbstractAnomalyDetector extends AbstractOptionHandler implements AnomalyDetector {
@@ -12,7 +12,7 @@ public abstract class AbstractAnomalyDetector extends AbstractOptionHandler impl
 	private static final long serialVersionUID = 1L;
 
 	@Override
-	public abstract boolean updateAndCheckAnomalyDetection(MultiLabelInstance instance);
+	public abstract boolean updateAndCheckAnomalyDetection(StructuredInstance instance);
 
 	@Override
 	public AnomalyDetector copy() {
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalinessRatioScore.java b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalinessRatioScore.java
index 211fbbc29..9297ebe1e 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalinessRatioScore.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalinessRatioScore.java
@@ -11,7 +11,7 @@
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 public class AnomalinessRatioScore extends AbstractAnomalyDetector {
 
@@ -54,7 +54,7 @@ public class AnomalinessRatioScore extends AbstractAnomalyDetector {
 
 
 	@Override
-	public boolean updateAndCheckAnomalyDetection(MultiLabelInstance instance) {
+	public boolean updateAndCheckAnomalyDetection(StructuredInstance instance) {
 		boolean isAnomaly=false;
 		if(probabilityFunction==null){
 			weightSeen=0.0;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalyDetector.java b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalyDetector.java
index f4d4647d7..6e9361842 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalyDetector.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalyDetector.java
@@ -1,5 +1,5 @@
 package moa.classifiers.rules.core.anomalydetection;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.options.OptionHandler;
 
@@ -18,7 +18,7 @@ public interface AnomalyDetector extends OptionHandler {
      *
      * @return true if anomaly is detected and false otherwise
      */
-    public boolean updateAndCheckAnomalyDetection(MultiLabelInstance instance);
+    public boolean updateAndCheckAnomalyDetection(StructuredInstance instance);
 
     
     @Override
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/NoAnomalyDetection.java b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/NoAnomalyDetection.java
index e7e44a113..722f15dfa 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/NoAnomalyDetection.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/NoAnomalyDetection.java
@@ -2,7 +2,7 @@
 
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 public class NoAnomalyDetection extends AbstractAnomalyDetector{
 
@@ -17,7 +17,7 @@ public void getDescription(StringBuilder sb, int indent) {
 	}
 
 	@Override
-	public boolean updateAndCheckAnomalyDetection(MultiLabelInstance instance) {
+	public boolean updateAndCheckAnomalyDetection(StructuredInstance instance) {
 		return false;
 	}
 
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/OddsRatioScore.java b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/OddsRatioScore.java
index 08d846ea9..53cc8556c 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/OddsRatioScore.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/OddsRatioScore.java
@@ -11,7 +11,7 @@
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 public class OddsRatioScore extends AbstractAnomalyDetector {
 
@@ -48,7 +48,7 @@ public class OddsRatioScore extends AbstractAnomalyDetector {
 	private ProbabilityFunction probabilityFunction;
 
 	@Override
-	public boolean updateAndCheckAnomalyDetection(MultiLabelInstance instance) {
+	public boolean updateAndCheckAnomalyDetection(StructuredInstance instance) {
 		boolean isAnomaly=false;
 		if(probabilityFunction==null){
 			weightSeen=0.0;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java
index 49a82a67d..df2405a5a 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java
@@ -20,6 +20,7 @@
 package moa.classifiers.rules.core.conditionaltests;
 
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import moa.classifiers.core.conditionaltests.NominalAttributeBinaryTest;
 import moa.classifiers.rules.core.Predicate;
@@ -78,6 +79,14 @@ public int getAttributeIndex() {
 	public boolean isEqualOrLess() {
 		return state;
 	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent, InstancesHeader header) {
+		if(state)
+			StringUtils.appendIndented(sb, indent, InstancesHeader.getAttributeNameString(header, attIndex) + " = " + attValue);
+		else
+			StringUtils.appendIndented(sb, indent, InstancesHeader.getAttributeNameString(header, attIndex) + " <> " + attValue);		
+	}
 	
 	
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java
index 90560586b..37650e7ca 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java
@@ -169,4 +169,11 @@ public boolean isEqualOrLess() {
 		return state;
 	}
 
+	@Override
+	public void getDescription(StringBuilder sb, int indent, InstancesHeader header) {
+		String compareChar = (operator == 0) ? "=" : (operator == 1) ? "<=" : ">";
+		StringUtils.appendIndented(sb, indent, InstancesHeader.getAttributeNameString(header, attIndex) + compareChar + attValue);		
+	}
+	
+
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/functions/Perceptron.java b/moa/src/main/java/moa/classifiers/rules/functions/Perceptron.java
index 45ae75b74..a5e48b1a8 100644
--- a/moa/src/main/java/moa/classifiers/rules/functions/Perceptron.java
+++ b/moa/src/main/java/moa/classifiers/rules/functions/Perceptron.java
@@ -25,7 +25,7 @@
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Regressor;
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java b/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java
index 2672f58f5..44a24ae5f 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java
@@ -55,7 +55,7 @@
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 
@@ -147,7 +147,7 @@ public AMRulesMultiLabelLearner(double attributesPercentage) {
 
 
 	@Override
-	public Prediction getPredictionForInstance(MultiLabelInstance inst) {
+	public Prediction getPredictionForInstance(StructuredInstance inst) {
 		/*MultiLabelVote vote=getVotes(inst);
 		if(vote!=null)	
 			return vote.getVote();
@@ -166,7 +166,7 @@ public Prediction getPredictionForInstance(MultiLabelInstance inst) {
 	 * returns the prediction of the instance.
 	 * Called in WeightedRandomRules
 	 */
-	public ErrorWeightedVoteMultiLabel getVotes(MultiLabelInstance instance) {
+	public ErrorWeightedVoteMultiLabel getVotes(StructuredInstance instance) {
 		ErrorWeightedVoteMultiLabel errorWeightedVote=newErrorWeightedVote();
 		//DoubleVector combinedVote = new DoubleVector();
 		debug("Test",3);    
@@ -237,7 +237,7 @@ public boolean isRandomizable(){
 	private double numInstances; //Just for statistics
 
 	@Override
-	public void trainOnInstanceImpl(MultiLabelInstance instance) {
+	public void trainOnInstanceImpl(StructuredInstance instance) {
 		/**
 		 * AMRules Algorithm
 		 * 
@@ -398,7 +398,7 @@ protected void debug(String string, int level) {
 		}
 	}
 
-	protected void VerboseToConsole(MultiLabelInstance inst) {
+	protected void VerboseToConsole(StructuredInstance inst) {
 		if(VerbosityOption.getValue()>=5){	
 			System.out.println(); 
 			System.out.println("I) Dataset: "+inst.dataset().getRelationName()); 
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java
index 4a8a18ccf..9c179d2f6 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java
@@ -8,7 +8,7 @@
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 
@@ -95,9 +95,9 @@ public LearningLiteral(int [] outputsToLearn){
 		this.outputsToLearn=outputsToLearn.clone();
 	}
 
-	abstract public void trainOnInstance(MultiLabelInstance instance);
+	abstract public void trainOnInstance(StructuredInstance instance);
 
-	public Prediction getPredictionForInstance(MultiLabelInstance instance) {
+	public Prediction getPredictionForInstance(StructuredInstance instance) {
 		if (learner!=null)
 			return learner.getPredictionForInstance(instance);
 		else
@@ -107,7 +107,7 @@ public Prediction getPredictionForInstance(MultiLabelInstance instance) {
 
 	public abstract boolean tryToExpand(double splitConfidence, double tieThresholdOption);
 
-	public boolean updateAndCheckChange(MultiLabelInstance instance) {
+	public boolean updateAndCheckChange(StructuredInstance instance) {
 		boolean hasChanged=false;
 		if (hasStarted){
 			if (changeDetectors==null){
@@ -133,7 +133,7 @@ public boolean updateAndCheckChange(MultiLabelInstance instance) {
 	protected abstract double[] getNormalizedErrors(Prediction prediction,
 			Instance inst);
 
-	public boolean updateAndCheckAnomalyDetection(MultiLabelInstance instance) {
+	public boolean updateAndCheckAnomalyDetection(StructuredInstance instance) {
 		if(hasStarted)
 			return anomalyDetector.updateAndCheckAnomalyDetection(instance);
 		else
@@ -239,7 +239,7 @@ public void setAttributesPercentage(double attributesPercentage) {
 		this.attributesPercentage=attributesPercentage;
 	}
 	
-	protected void initializeAttibutesMask(MultiLabelInstance inst) {
+	protected void initializeAttibutesMask(StructuredInstance inst) {
 		int numInputAttributes=inst.numInputAttributes();
 		int numAttributesSelected=(int)Math.round(numInputAttributes*attributesPercentage/100);
 		
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java
index 26ae4e0d9..f9e2c5c82 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java
@@ -2,7 +2,7 @@
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 import java.util.Arrays;
@@ -157,7 +157,7 @@ private AttributeExpansionSuggestion[] getBestSplitSuggestions(MultiLabelSplitCr
 	}
 
 	@Override
-	public void trainOnInstance(MultiLabelInstance instance)  {
+	public void trainOnInstance(StructuredInstance instance)  {
 		if (attributesMask==null)
 			initializeAttibutesMask(instance);
 		
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java
index 6bd641395..0fb2aba8b 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java
@@ -5,7 +5,7 @@
 import java.util.List;
 import java.util.Random;
 
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 import moa.AbstractMOAObject;
@@ -63,7 +63,7 @@ public void setRuleNumberID(int ruleNumberID) {
 		this.ruleNumberID = ruleNumberID;
 	}
 	
-	public boolean isCovering(MultiLabelInstance inst) {
+	public boolean isCovering(StructuredInstance inst) {
 		boolean isCovering = true;
 		for (Literal l : literalList) {
 			if (l.evaluate(inst) == false) {
@@ -90,15 +90,15 @@ public void getDescription(StringBuilder out, int indent) {
 		StringUtils.appendNewline(out);
 	}
 
-	public boolean updateChangeDetection(MultiLabelInstance instance) {
+	public boolean updateChangeDetection(StructuredInstance instance) {
 		return this.learningLiteral.updateAndCheckChange(instance);
 	}
 
-	public boolean updateAnomalyDetection(MultiLabelInstance instance) {
+	public boolean updateAnomalyDetection(StructuredInstance instance) {
 		return this.learningLiteral.updateAndCheckAnomalyDetection(instance);
 	}
 
-	public void trainOnInstance(MultiLabelInstance instance) {
+	public void trainOnInstance(StructuredInstance instance) {
 		learningLiteral.trainOnInstance(instance);
 	}
 
@@ -114,7 +114,7 @@ public LearningLiteral getLearningNode() {
 		return learningLiteral.getErrors();
 	}
 
-	public  Prediction getPredictionForInstance(MultiLabelInstance instance) {
+	public  Prediction getPredictionForInstance(StructuredInstance instance) {
 		return learningLiteral.getPredictionForInstance(instance);
 	}
 	
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiLabelErrorMeasurer.java b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiLabelErrorMeasurer.java
index ddcad8f6c..b96ddd2a7 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiLabelErrorMeasurer.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiLabelErrorMeasurer.java
@@ -5,7 +5,7 @@
 import moa.tasks.TaskMonitor;
 
 import com.github.javacliparser.FloatOption;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 public abstract class AbstractMultiLabelErrorMeasurer  extends AbstractOptionHandler implements MultiTargetErrorMeasurer{
@@ -27,7 +27,7 @@ public void addPrediction(Prediction prediction, Prediction trueClass){
 		addPrediction(prediction, trueClass);
 	}
 	
-	abstract public void addPrediction(Prediction prediction, MultiLabelInstance inst);
+	abstract public void addPrediction(Prediction prediction, StructuredInstance inst);
 	
 	abstract public double getCurrentError();
 	
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiTargetErrorMeasurer.java b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiTargetErrorMeasurer.java
index 97ee491ac..5b2bc3be8 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiTargetErrorMeasurer.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiTargetErrorMeasurer.java
@@ -1,6 +1,6 @@
 package moa.classifiers.rules.multilabel.errormeasurers;
 
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 
@@ -11,7 +11,7 @@ public abstract class AbstractMultiTargetErrorMeasurer extends AbstractMultiLabe
 	 */
 	private static final long serialVersionUID = 1L;
 
-	public void addPrediction(Prediction prediction, MultiLabelInstance inst){
+	public void addPrediction(Prediction prediction, StructuredInstance inst){
 		int numOutputs=inst.numberOutputTargets();
 		Prediction trueClass= new MultiLabelPrediction(numOutputs);
 		for (int i=0; i<numOutputs; i++){
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/MultiLabelErrorMeasurer.java b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/MultiLabelErrorMeasurer.java
index f66d3e4d3..66259cfe6 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/MultiLabelErrorMeasurer.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/MultiLabelErrorMeasurer.java
@@ -1,6 +1,6 @@
 package moa.classifiers.rules.multilabel.errormeasurers;
 
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 import moa.options.OptionHandler;
@@ -11,7 +11,7 @@ public interface MultiLabelErrorMeasurer extends OptionHandler {
 
 	public void addPrediction(Prediction prediction, Prediction trueClass);
 
-	public void addPrediction(Prediction prediction, MultiLabelInstance inst);
+	public void addPrediction(Prediction prediction, StructuredInstance inst);
 
 	public double getCurrentError();
 
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/AdaptiveMultiTargetRegressor.java b/moa/src/main/java/moa/classifiers/rules/multilabel/functions/AdaptiveMultiTargetRegressor.java
index e8a16a8d4..1f0adf4b4 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/AdaptiveMultiTargetRegressor.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/functions/AdaptiveMultiTargetRegressor.java
@@ -8,7 +8,7 @@
 import moa.learners.Learner;
 import moa.options.ClassOption;
 
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 public class AdaptiveMultiTargetRegressor extends AbstractMultiLabelLearner
@@ -43,7 +43,7 @@ public AdaptiveMultiTargetRegressor(){
 
 	}
 	@Override
-	public void trainOnInstanceImpl(MultiLabelInstance instance) {
+	public void trainOnInstanceImpl(StructuredInstance instance) {
 		if (!this.hasStarted){	
 			baseLearner=new MultiTargetRegressor[NUM_LEARNERS];
 			errorMeasurer= new MultiTargetErrorMeasurer[NUM_LEARNERS];
@@ -67,7 +67,7 @@ public void trainOnInstanceImpl(MultiLabelInstance instance) {
 	}
 
 	@Override
-	public Prediction getPredictionForInstance(MultiLabelInstance inst) {
+	public Prediction getPredictionForInstance(StructuredInstance inst) {
 		Prediction prediction=null;
 		if(hasStarted){
 			int bestIndex=0;
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/meta/MultiLabelRandomAMRules.java b/moa/src/main/java/moa/classifiers/rules/multilabel/meta/MultiLabelRandomAMRules.java
index b499ace51..7c08a3eed 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/meta/MultiLabelRandomAMRules.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/meta/MultiLabelRandomAMRules.java
@@ -18,7 +18,7 @@
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.MultiChoiceOption;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 public class MultiLabelRandomAMRules extends AbstractMultiLabelLearner
@@ -93,7 +93,7 @@ public void resetLearningImpl() {
 		this.isRegression = (baseLearner instanceof MultiTargetRegressor);
 	}
 
-	public void trainOnInstanceImpl(MultiLabelInstance instance) {
+	public void trainOnInstanceImpl(StructuredInstance instance) {
 		for (int i = 0; i < this.ensemble.length; i++) {
 			Instance inst=instance.copy();
 			int k = 1;
@@ -114,7 +114,7 @@ public void trainOnInstanceImpl(MultiLabelInstance instance) {
 	}
 
 	@Override
-	public Prediction getPredictionForInstance(MultiLabelInstance inst) {
+	public Prediction getPredictionForInstance(StructuredInstance inst) {
 		Prediction vote=null;
 		//ErrorWeightedVote combinedVote = (ErrorWeightedVote)((ErrorWeightedVote) votingTypeOption.getPreMaterializedObject()).copy();
 		ErrorWeightedVoteMultiLabel combinedVote = (ErrorWeightedVoteMultiLabel)((ErrorWeightedVoteMultiLabel) getPreparedClassOption(this.votingFunctionOption)).copy();
diff --git a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java b/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
index 02bd090fd..f986c3d60 100644
--- a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
+++ b/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
@@ -52,7 +52,7 @@ public class FIMTDD extends AbstractClassifier implements Regressor {
 
 	private static final long serialVersionUID = 1L;
 
-	protected Node treeRoot;
+	public Node treeRoot;
 
 	protected int leafNodeCount = 0;
 	protected int splitNodeCount = 0;
@@ -321,7 +321,7 @@ public void learnFromInstance(Instance inst, boolean growthAllowed, double predi
 			}
 
 			if (growthAllowed) {
-				checkForSplit();
+				checkForSplit(inst, prediction);
 			}
 		}
 
@@ -366,17 +366,16 @@ public double getPredictionTargetMean(Instance inst) {
 
 		public double getPrediction(Instance inst) {
 			if (tree.buildingModelTree()) {
-				//return getPredictionModel(inst);
 				return (errorModel < errorTargetMean) ? getPredictionModel(inst) : getPredictionTargetMean(inst);
 			} else
 				return getPredictionTargetMean(inst);
 		}
 		
-		public void checkForSplit() {
+		public void checkForSplit(Instance inst, double prediction) {
 			// If it has seen Nmin examples since it was last tested for splitting, attempt a split of this node
 			if (examplesSeen - examplesSeenAtLastSplitEvaluation >= tree.gracePeriodOption.getValue()) {
 				int index = (parent != null) ? parent.getChildIndex(this) : 0;
-				tree.attemptToSplit(this, parent, index);
+				tree.attemptToSplit(this, parent, index, inst, prediction);
 
 				// Take note of how many instances were seen when this split evaluation was made, so we know when to perform the next split evaluation
 				examplesSeenAtLastSplitEvaluation = examplesSeen;
@@ -553,6 +552,7 @@ public String getPurposeString() {
 		public FIMTDDPerceptron(FIMTDDPerceptron original) {
 			this.tree = original.tree;
 			weightAttribute = original.weightAttribute.clone();
+			instancesSeen = original.instancesSeen / 2;
 		}
 
 		public FIMTDDPerceptron(FIMTDD tree) {
@@ -742,6 +742,18 @@ public double getNormalizedError(Instance inst, double prediction) {
 		return Math.abs(normalValue - normalPrediction);
 	}
 
+	
+	public void updateStatistics(Instance inst) {
+		examplesSeen += inst.weight();
+		sumOfValues += inst.weight() * inst.classValue();
+		sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
+
+		for (int i = 0; i < inst.numAttributes() - 1; i++) {
+			int aIndex = modelAttIndexToInstanceAttIndex(i, inst);
+			sumOfAttrValues.addToValue(i, inst.weight() * inst.value(aIndex));
+			sumOfAttrSquares.addToValue(i, inst.weight() * inst.value(aIndex) * inst.value(aIndex));
+		}
+	}
 
 	/**
 	 * Method for updating (training) the model using a new instance
@@ -754,16 +766,7 @@ public void trainOnInstanceImpl(Instance inst) {
 	
 		processInstance(inst, treeRoot, prediction, normalError, true, false);
 		
-		examplesSeen += inst.weight();
-		sumOfValues += inst.weight() * inst.classValue();
-		sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
-
-		for (int i = 0; i < inst.numAttributes() - 1; i++) {
-			int aIndex = modelAttIndexToInstanceAttIndex(i, inst);
-			sumOfAttrValues.addToValue(i, inst.weight() * inst.value(aIndex));
-			sumOfAttrSquares.addToValue(i, inst.weight() * inst.value(aIndex) * inst.value(aIndex));
-		}
-
+		updateStatistics(inst);
 
 	}
 
@@ -867,7 +870,7 @@ protected FIMTDDPerceptron newLeafModel() {
 	
 	// region --- Processing methods
 	
-	protected void checkRoot() {
+	public void checkRoot() {
 		if (treeRoot == null) {
 			treeRoot = newLeafNode();
 			leafNodeCount = 1;
@@ -882,7 +885,7 @@ public boolean buildingModelTree() {
 		return !regressionTreeOption.isSet();
 	}
 
-	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
+	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex, Instance inst, double prediction) {
 
 		// Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
  		SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
diff --git a/moa/src/main/java/moa/classifiers/trees/ORTO.java b/moa/src/main/java/moa/classifiers/trees/ORTO.java
index 2f7ca3d52..5c48c0e21 100644
--- a/moa/src/main/java/moa/classifiers/trees/ORTO.java
+++ b/moa/src/main/java/moa/classifiers/trees/ORTO.java
@@ -334,7 +334,7 @@ protected OptionNode newOptionNode() {
 
 	// region --- Processing methods
 
-	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
+	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex, Instance inst, double prediction) {
 		// Initialize the split criterion 
 		SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(splitCriterionOption);
 
@@ -380,12 +380,10 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 					} else {
 						break;
 					}
-						
 				}
-
 			} else if (hoeffdingBound < tieThresholdOption.getValue()) {
 				numSplits = 1;
-				acceptedSplits.add(bestSplitSuggestions[0]);
+				acceptedSplits.add(bestSuggestion);
 			} else { // If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
 				for (int i = 0; i < node.attributeObservers.size(); i++) {
 					AttributeClassObserver obs = node.attributeObservers.get(i);
diff --git a/moa/src/main/java/moa/evaluation/BasicMultiTargetPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/BasicMultiTargetPerformanceEvaluator.java
index aec992e29..5b87a670b 100644
--- a/moa/src/main/java/moa/evaluation/BasicMultiTargetPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/BasicMultiTargetPerformanceEvaluator.java
@@ -27,7 +27,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstanceData;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 /**
@@ -59,7 +59,7 @@ public void reset() {
     @Override
     public void addResult(Example<Instance> example, Prediction prediction) {
 
-    MultiLabelInstance inst = (MultiLabelInstance) example.getData();
+    StructuredInstance inst = (StructuredInstance) example.getData();
     if (numberOutputs == 0) {
     	numberOutputs = inst.numberOutputTargets();
     }
diff --git a/moa/src/main/java/moa/evaluation/MultiTargetWindowRegressionPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/MultiTargetWindowRegressionPerformanceEvaluator.java
index 2b43a72a6..24d45642d 100644
--- a/moa/src/main/java/moa/evaluation/MultiTargetWindowRegressionPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/MultiTargetWindowRegressionPerformanceEvaluator.java
@@ -30,7 +30,7 @@
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 /**
@@ -152,7 +152,7 @@ public void prepareForUseImpl(TaskMonitor monitor,
 
 	@Override
 	public void addResult(Example<Instance> testInst, Prediction prediction) {
-		MultiLabelInstance inst=(MultiLabelInstance) testInst.getData();
+		StructuredInstance inst=(StructuredInstance) testInst.getData();
        double weight = inst.weight();
         if (numberOutputs == 0) {
         	numberOutputs = inst.numberOutputTargets();
diff --git a/moa/src/main/java/moa/evaluation/MultilabelWindowClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/MultilabelWindowClassificationPerformanceEvaluator.java
index b1374ff95..b26c131c0 100644
--- a/moa/src/main/java/moa/evaluation/MultilabelWindowClassificationPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/MultilabelWindowClassificationPerformanceEvaluator.java
@@ -25,7 +25,7 @@
 import moa.core.Example;
 import moa.core.Measurement;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 /**
@@ -110,7 +110,7 @@ public void addResult(Example<Instance> example, double[] p_y) {
     @Override
     public void addResult(Example<Instance> example, Prediction prediction) {
 
-        MultiLabelInstance inst = (MultiLabelInstance) example.getData();
+        StructuredInstance inst = (StructuredInstance) example.getData();
         if (inst.weight() > 0.0) {
             int numberOutputs = inst.numOutputAttributes();
 			if (numberOutputs <= 1) {
diff --git a/moa/src/main/java/moa/streams/ArffFileStream.java b/moa/src/main/java/moa/streams/ArffFileStream.java
index c701d431d..408c6d2da 100644
--- a/moa/src/main/java/moa/streams/ArffFileStream.java
+++ b/moa/src/main/java/moa/streams/ArffFileStream.java
@@ -41,8 +41,7 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class ArffFileStream extends AbstractOptionHandler implements
-        InstanceStream {
+public class ArffFileStream extends AbstractOptionHandler implements InstanceStream {
 
     @Override
     public String getPurposeString() {
@@ -82,8 +81,7 @@ public ArffFileStream(String arffFileName, int classIndex) {
     }
 
     @Override
-    public void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
+    public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
         restart();
     }
 
@@ -127,8 +125,7 @@ public void restart() {
             InputStream fileStream = new FileInputStream(this.arffFileOption.getFile());
             this.fileProgressMonitor = new InputStreamProgressMonitor(
                     fileStream);
-            this.fileReader = new BufferedReader(new InputStreamReader(
-                    this.fileProgressMonitor));
+            this.fileReader = new BufferedReader(new InputStreamReader(this.fileProgressMonitor));
             int classIndex = this.classIndexOption.getValue();
             this.instances = new Instances(this.fileReader, 1, classIndex);
             if (classIndex < 0) {

From 60b81db2af688ed40ee2a837addc3ae2ba666a62 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Thu, 24 Mar 2016 13:16:58 +0100
Subject: [PATCH 12/33] Instance, InstanceHeader, ArffReader, etc. rework

---
 .../labs/samoa/instances/ArffLoader.java      | 147 ++--
 .../instances/HierarhicalInstanceImpl.java    | 452 ------------
 .../yahoo/labs/samoa/instances/Instance.java  |  12 +-
 .../labs/samoa/instances/InstanceImpl.java    |  17 +-
 .../samoa/instances/InstanceInformation.java  | 127 ++--
 .../yahoo/labs/samoa/instances/Instances.java | 542 --------------
 .../labs/samoa/instances/InstancesHeader.java | 674 ++++++++++++++++--
 .../instances/MultiTargetArffLoader.java      |  43 +-
 .../com/yahoo/labs/samoa/instances/Range.java |   1 +
 .../SamoaToWekaInstanceConverter.java         |   4 +-
 .../samoa/instances/StructuredInstance.java   |   3 +
 .../WekaToSamoaInstanceConverter.java         |  12 +-
 .../moa/classifiers/AbstractClassifier.java   |  20 +-
 .../bayes/NaiveBayesMultinomial.java          |   4 +-
 .../InstanceConditionalTest.java              |   3 +-
 .../NominalAttributeBinaryTest.java           |   1 +
 .../NominalAttributeMultiwayTest.java         |   1 +
 .../NumericAttributeBinaryTest.java           |   1 +
 .../main/java/moa/classifiers/lazy/kNN.java   |   9 +-
 .../java/moa/classifiers/lazy/kNNwithPAW.java |   4 +-
 .../classifiers/lazy/kNNwithPAWandADWIN.java  |   4 +-
 .../neighboursearch/DistanceFunction.java     |   6 +-
 .../neighboursearch/EuclideanDistance.java    |   6 +-
 .../lazy/neighboursearch/KDTree.java          |  22 +-
 .../lazy/neighboursearch/LinearNNSearch.java  |  10 +-
 .../NearestNeighbourSearch.java               |  12 +-
 .../neighboursearch/NormalizableDistance.java |  10 +-
 .../kdtrees/KDTreeNodeSplitter.java           |   8 +-
 .../kdtrees/KMeansInpiredMethod.java          |   8 +-
 .../main/java/moa/classifiers/meta/ADACC.java |   6 +-
 .../meta/AccuracyUpdatedEnsemble.java         |   8 +-
 .../meta/AccuracyWeightedEnsemble.java        |  16 +-
 .../moa/classifiers/meta/RandomRules.java     |   4 +-
 .../meta/TemporallyAugmentedClassifier.java   |   8 +-
 .../moa/classifiers/meta/WEKAClassifier.java  |   2 +-
 .../LocalMultiTargetClassifier.java           |   1 +
 .../multilabel/MEKAClassifier.java            |   8 +-
 .../multilabel/MajorityLabelset.java          |   4 +-
 .../multilabel/MultilabelHoeffdingTree.java   |   9 +-
 .../multilabel/meta/OzaBagAdwinML.java        |   6 +-
 .../classifiers/multilabel/meta/OzaBagML.java |   6 +-
 .../multilabel/trees/ISOUPTree.java           |   5 +
 .../BasicMultiTargetRegressor.java            |   4 +-
 .../rules/core/NominalRulePredicate.java      |   1 +
 .../rules/core/NumericRulePredicate.java      |   1 +
 .../NominalAttributeBinaryRulePredicate.java  |   1 +
 .../NumericAttributeBinaryRulePredicate.java  |   1 +
 .../rules/meta/RandomAMRulesOld.java          |   1 -
 .../moa/clusterers/AbstractClusterer.java     |   4 +-
 .../main/java/moa/clusterers/Clusterer.java   |   2 +-
 moa/src/main/java/moa/clusterers/CobWeb.java  |  14 +-
 .../clusterers/WekaClusteringAlgorithm.java   |  10 +-
 .../moa/core/MultilabelInstancesHeader.java   |   4 +-
 moa/src/main/java/moa/core/SizeOf.java        |   2 +-
 .../core/utils/AttributeDefinitionUtil.java   | 121 ++++
 .../main/java/moa/core/utils/Converter.java   |   8 +-
 .../BasicMultiLabelPerformanceEvaluator.java  |   4 +-
 .../visualization/RunOutlierVisualizer.java   |   4 +-
 .../moa/gui/visualization/RunVisualizer.java  |   4 +-
 .../moa/gui/visualization/WekaExplorer.java   |   4 +-
 .../main/java/moa/streams/ArffFileStream.java |  55 +-
 .../moa/streams/CachedInstancesStream.java    |   6 +-
 .../moa/streams/ConceptDriftRealStream.java   |  13 +-
 .../java/moa/streams/ConceptDriftStream.java  |   3 +-
 .../main/java/moa/streams/ExampleStream.java  |   3 +-
 .../main/java/moa/streams/FilteredStream.java |   3 +-
 .../java/moa/streams/MultiFilteredStream.java |   2 +-
 .../moa/streams/MultiLabelFilteredStream.java |   4 +-
 .../streams/MultiTargetArffFileStream.java    | 290 ++++----
 .../moa/streams/clustering/FileStream.java    |  43 +-
 .../clustering/RandomRBFGeneratorEvents.java  |   4 +-
 .../streams/clustering/SimpleCSVStream.java   |   6 +-
 .../moa/streams/filters/AddNoiseFilter.java   |   3 +-
 .../java/moa/streams/filters/RBFFilter.java   |   7 +-
 .../java/moa/streams/filters/ReLUFilter.java  |   6 +-
 .../RemoveDiscreteAttributeFilter.java        |   4 +-
 .../filters/ReplacingMissingValuesFilter.java |   1 +
 .../filters/SelectAttributesFilter.java       |  16 +-
 .../streams/generators/AgrawalGenerator.java  |   4 +-
 .../generators/HyperplaneGenerator.java       |   4 +-
 .../moa/streams/generators/LEDGenerator.java  |   4 +-
 .../streams/generators/LEDGeneratorDrift.java |   1 +
 .../generators/RandomRBFGenerator.java        |   4 +-
 .../generators/RandomTreeGenerator.java       |   4 +-
 .../moa/streams/generators/SEAGenerator.java  |   4 +-
 .../streams/generators/STAGGERGenerator.java  |   4 +-
 .../streams/generators/WaveformGenerator.java |   4 +-
 .../generators/WaveformGeneratorDrift.java    |   1 +
 .../cd/AbstractConceptDriftGenerator.java     |   4 +-
 .../multilabel/MetaMultilabelGenerator.java   |   7 +-
 .../multilabel/MultilabelArffFileStream.java  |   4 +-
 .../java/moa/tasks/CacheShuffledStream.java   |   4 +-
 .../moa/tasks/EvaluateInterleavedChunks.java  |   4 +-
 .../tasks/EvaluatePeriodicHeldOutTest.java    |   4 +-
 .../instances/MultiTargetArffLoaderTest.java  |  31 +-
 .../AbstractClassifierTestCase.java           |  14 +-
 .../filters/SelectAttributesFilterTest.java   |   4 +-
 97 files changed, 1358 insertions(+), 1657 deletions(-)
 delete mode 100644 moa/src/main/java/com/yahoo/labs/samoa/instances/HierarhicalInstanceImpl.java
 delete mode 100644 moa/src/main/java/com/yahoo/labs/samoa/instances/Instances.java
 create mode 100644 moa/src/main/java/moa/core/utils/AttributeDefinitionUtil.java

diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
index a6bddce59..c427141d8 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
@@ -20,10 +20,13 @@
 import java.io.Reader;
 import java.io.StreamTokenizer;
 import java.util.ArrayList;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
+import moa.core.utils.AttributeDefinitionUtil;
+
 /**
  * The Class ArffLoader. Loads an Arff file with sparse or dense format.
  */
@@ -41,8 +44,9 @@ public class ArffLoader {
      */
     protected StreamTokenizer streamTokenizer;
 
+   
     /**
-     * Instantiates a new arff loader.
+     * Instantiates a new arff loader. Constructor for backwards compatibility.
      *
      * @param reader the reader
      * @param size the size
@@ -50,39 +54,43 @@ public class ArffLoader {
      */
     public ArffLoader(Reader reader, int size, int classAttribute) {
         // size is not used
-        this(reader);
-        if (classAttribute < 0) {
-            this.instanceInformation.setClassIndex(this.instanceInformation.numAttributes() - 1);
-            //System.out.print(this.instanceInformation.classIndex());
-        } else if (classAttribute > 0) {
-            this.instanceInformation.setClassIndex(classAttribute - 1);
-        }
+    	this(reader,String.valueOf(classAttribute));
     }
 
-    protected Range range;
 
     /**
      * Instantiates a new arff loader.
      *
      * @param reader the reader
-     * @param range
-     * @param size the size
-     * @param classAttribute the class attribute
+     * @param outputDefinition the string definition of output attributes
+     * @param inputDefinition the string definition of input attributes
      */
-    public ArffLoader(Reader reader) {
-        this(reader, null);
+    public ArffLoader(Reader reader, String outputDefinition, String inputDefinition) {
+        BufferedReader br = new BufferedReader(reader);
+
+        //Init streamTokenizer
+        streamTokenizer = new StreamTokenizer(br);
+        streamTokenizer.resetSyntax();
+        streamTokenizer.whitespaceChars(0, ' ');
+        streamTokenizer.wordChars(' ' + 1, '\u00FF');
+        streamTokenizer.whitespaceChars(',', ',');
+        streamTokenizer.commentChar('%');
+        streamTokenizer.quoteChar('"');
+        streamTokenizer.quoteChar('\'');
+        streamTokenizer.ordinaryChar('{');
+        streamTokenizer.ordinaryChar('}');
+        streamTokenizer.eolIsSignificant(true);
+
+        this.instanceInformation = this.getHeader(outputDefinition, inputDefinition);
     }
 
     /**
      * Instantiates a new arff loader.
      *
      * @param reader the reader
-     * @param range
-     * @param size the size
-     * @param classAttribute the class attribute
+     * @param outputDefinition the string definition of output attributes (others are taken as inputs)
      */
-    public ArffLoader(Reader reader, Range range) {
-        this.range = range;
+    public ArffLoader(Reader reader, String outputDefinition) {
         BufferedReader br = new BufferedReader(reader);
 
         //Init streamTokenizer
@@ -98,23 +106,9 @@ public ArffLoader(Reader reader, Range range) {
         streamTokenizer.ordinaryChar('}');
         streamTokenizer.eolIsSignificant(true);
 
-        this.instanceInformation = this.getHeader();
-
-        if (range != null) { //is MultiLabel
-            this.instanceInformation.setRangeOutputIndices(range);
-        }
-
-    }
-
-    /**
-     * Gets the structure.
-     *
-     * @return the structure
-     */
-    public InstanceInformation getStructure() {
-        return this.instanceInformation;
+        this.instanceInformation = this.getHeader(outputDefinition, AttributeDefinitionUtil.nonIgnoredDefinition);
     }
-
+    
     /**
      * Reads instance. It detects if it is dense or sparse.
      *
@@ -144,7 +138,6 @@ public Instance readInstance() {
      */
     public Instance readInstanceDense() {
         Instance instance = newDenseInstance(this.instanceInformation.numAttributes());
-        //System.out.println(this.instanceInformation.numAttributes());
         int numAttribute = 0;
         try {
             while (numAttribute == 0 && streamTokenizer.ttype != StreamTokenizer.TT_EOF) {
@@ -196,7 +189,7 @@ protected void setValue(Instance instance, int numAttribute, double value, boole
             valueAttribute = value;
             //System.out.println(value +"/"+valueAttribute+" ");
         }
-        if (this.instanceInformation.classIndex() == numAttribute) {
+        if (this.instanceInformation.numOutputAttributes() == 1 && this.instanceInformation.classIndex() == numAttribute) {
             setClassValue(instance, valueAttribute);
             //System.out.println(value +"<"+this.instanceInformation.classIndex()+">");
         } else {
@@ -219,17 +212,11 @@ private Instance readInstanceSparse() {
         ArrayList<Double> attributeValues = new ArrayList<Double>();
         List<Integer> indexValues = new ArrayList<Integer>();
         try {
-            //while (streamTokenizer.ttype != StreamTokenizer.TT_EOF) {
-            streamTokenizer.nextToken(); // Remove the '{' char
             //For each line
             while (streamTokenizer.ttype != StreamTokenizer.TT_EOL
                     && streamTokenizer.ttype != StreamTokenizer.TT_EOF) {
                 while (streamTokenizer.ttype != '}') {
                     //For each item
-                    //streamTokenizer.nextToken();
-                    //while (streamTokenizer.ttype != '}'){
-                    //System.out.println(streamTokenizer.nval +"-"+ streamTokenizer.sval);
-                    //numAttribute = (int) streamTokenizer.nval;
                     if (streamTokenizer.ttype == StreamTokenizer.TT_NUMBER) {
                         numAttribute = (int) streamTokenizer.nval;
                     } else {
@@ -342,25 +329,20 @@ private Instance readDenseInstanceSparse() {
         }
         return instance;
     }
-
-    //protected List<Attribute> inputAttributes;
-   // protected List<Attribute> outputAttributes;
     
     protected List<Attribute> auxAttributes;
 
-    private InstanceInformation getHeader() {
-    	//commented JD
-        //this.range.setUpper(10000); //TO DO: Create a new range object with isInRange that does not need the upper limit
+    private InstanceInformation getHeader(String outputDefinition, String inputDefinition) {
         String relation = "file stream";
         auxAttributes = new ArrayList<Attribute>();//JD
         int numAttributes = 0;
+        List<Integer> inputIndexes = new ArrayList<Integer>();
+        List<Integer> outputIndexes = new ArrayList<Integer>();
         try {
             streamTokenizer.nextToken();
             while (streamTokenizer.ttype != StreamTokenizer.TT_EOF) {
                 //For each line
-                //if (streamTokenizer.ttype == '@') {
                 if (streamTokenizer.ttype == StreamTokenizer.TT_WORD && streamTokenizer.sval.startsWith("@") == true) {
-                    //streamTokenizer.nextToken();
                     String token = streamTokenizer.sval.toUpperCase();
                     if (token.startsWith("@RELATION")) {
                         streamTokenizer.nextToken();
@@ -369,13 +351,11 @@ private InstanceInformation getHeader() {
                     } else if (token.startsWith("@ATTRIBUTE")) {
                         streamTokenizer.nextToken();
                         String name = streamTokenizer.sval;
-                        //System.out.println("* " + name);
                         if (name == null) {
                             name = Double.toString(streamTokenizer.nval);
                         }
                         streamTokenizer.nextToken();
                         String type = streamTokenizer.sval;
-                       // System.out.println("* " + name + ":" + type + " ");
                         if (streamTokenizer.ttype == '{') {
                             streamTokenizer.nextToken();
                             List<String> attributeLabels = new ArrayList<String>();
@@ -391,35 +371,21 @@ private InstanceInformation getHeader() {
 
                                 streamTokenizer.nextToken();
                             }
-                           // System.out.println();
-                            //attributes.add(new Attribute(name, attributeLabels));
-                            //commented JD
-                           /* if (this.range.isInRange(numAttribute)) {
-                             outputAttributes.add(new Attribute(name, attributeLabels));
-                             } else {
-                             inputAttributes.add(new Attribute(name, attributeLabels));
-                             }*/
                             auxAttributes.add(new Attribute(name, attributeLabels));
                             numAttributes++;
-                        } else if (streamTokenizer.sval != null && streamTokenizer.sval.toUpperCase() == "HIERARCHICAL") {
-                        	streamTokenizer.nextToken();
-                        	DAGStructure attributeStructure = new DAGStructure();
-                        	if (streamTokenizer.ttype == '{') {
-                        		while(streamTokenizer.ttype == '}') {
-                        			streamTokenizer.nextToken();
-                        			System.out.println(streamTokenizer.sval);
-                        		}
-                        		
-                        	}
-                        	
+//                        } else if (streamTokenizer.sval != null && streamTokenizer.sval.toUpperCase() == "HIERARCHICAL") {
+//                        	streamTokenizer.nextToken();
+//                        	DAGStructure attributeStructure = new DAGStructure();
+//                        	if (streamTokenizer.ttype == '{') {
+//                        		while(streamTokenizer.ttype != '}') {
+//                        			streamTokenizer.nextToken();
+//                        			System.out.println(streamTokenizer.sval);
+//                        		}
+//                        		
+//                        	}
+//                        	
                         } else {
-                            // Add attribute
-                            //commented JD
-                        	/*if (this.range.isInRange(numAttribute)) {
-                             outputAttributes.add(new Attribute(name));
-                             } else {
-                             inputAttributes.add(new Attribute(name));
-                             }*/
+
                             auxAttributes.add(new Attribute(name));
                             numAttributes++;
                         }
@@ -432,29 +398,16 @@ private InstanceInformation getHeader() {
                 }
                 streamTokenizer.nextToken();
             }
-            if (range != null) {
-                this.range.setUpper(numAttributes);
-            }
-            /*if (range==null) //is single-target. All instances should go to inputAtrributes (see setClassIndex(int) from InstanceInformation )
-             inputAttributes=auxAttributes;
-             else//is multi-target
-             {
-             this.range.setUpper(numAttribute);
-             for (int i=0; i<auxAttributes.size();i++)
-             {
-             //if (this.range.isInRange(i))
-             //	outputAttributes.add(auxAttributes.get(i));
-             //else
-             inputAttributes.add(auxAttributes.get(i));
-	            	
-             }
-             }*/
+            
+            outputIndexes = AttributeDefinitionUtil.parseAttributeDefinition(outputDefinition, numAttributes, null);
+            // TODO don't remove output attributes for online PCTs 
+            inputIndexes = AttributeDefinitionUtil.parseAttributeDefinition(inputDefinition, numAttributes, outputIndexes);
 
         } catch (IOException ex) {
             Logger.getLogger(ArffLoader.class.getName()).log(Level.SEVERE, null, ex);
         }
         // this.range.setUpper(inputAttributes.size()+outputAttributes.size());
-        return new InstanceInformation(relation, auxAttributes);
+        return new InstanceInformation(relation, auxAttributes, outputIndexes, inputIndexes);
     }
 
     protected Instance newSparseInstance(double d, double[] res) {
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/HierarhicalInstanceImpl.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/HierarhicalInstanceImpl.java
deleted file mode 100644
index c9ed7728c..000000000
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/HierarhicalInstanceImpl.java
+++ /dev/null
@@ -1,452 +0,0 @@
-/*
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
- * either express or implied. See the License for the specific
- * language governing permissions and limitations under the
- * License.  
- */
-package com.yahoo.labs.samoa.instances;
-
-import moa.AbstractMOAObject;
-
-/**
- * The Class InstanceImpl.
- *
- * @author abifet
- */
-public class HierarhicalInstanceImpl implements StructuredInstance {
-
-    /**
-	 * 
-	 */
-	private static final long serialVersionUID = 1L;
-
-	/**
-     * The weight.
-     */
-    protected double weight;
-
-    /**
-     * The instance data.
-     */
-    protected InstanceData instanceData;
-
-    /**
-     * The instance information.
-     */
-    protected InstancesHeader instanceHeader;
-
-    /**
-     * Instantiates a new instance.
-     *
-     * @param inst the inst
-     */
-    public HierarhicalInstanceImpl(HierarhicalInstanceImpl inst) {
-        this.weight = inst.weight;
-        this.instanceData = inst.instanceData.copy();
-        this.instanceHeader = inst.instanceHeader;
-    }
-
-    //Dense
-    /**
-     * Instantiates a new instance.
-     *
-     * @param weight the weight
-     * @param res the res
-     */
-    public HierarhicalInstanceImpl(double weight, double[] res) {
-        this.weight = weight;
-        this.instanceData = new DenseInstanceData(res);
-    }
-
-    //Sparse
-    /**
-     * Instantiates a new instance.
-     *
-     * @param weight the weight
-     * @param attributeValues the attribute values
-     * @param indexValues the index values
-     * @param numberAttributes the number attributes
-     */
-    public HierarhicalInstanceImpl(double weight, double[] attributeValues, int[] indexValues, int numberAttributes) {
-        this.weight = weight;
-        this.instanceData = new SparseInstanceData(attributeValues, indexValues, numberAttributes);
-    }
-
-    /**
-     * Instantiates a new instance.
-     *
-     * @param weight the weight
-     * @param instanceData the instance data
-     */
-    public HierarhicalInstanceImpl(double weight, InstanceData instanceData) {
-        this.weight = weight;
-        this.instanceData = instanceData;
-    }
-
-    /**
-     * Instantiates a new instance.
-     *
-     * @param numAttributes the num attributes
-     */
-    public HierarhicalInstanceImpl(int numAttributes) {
-        this.instanceData = new DenseInstanceData(new double[numAttributes]); //JD
-        this.weight = 1;
-    }
-
-    /**
-     * Weight.
-     *
-     * @return the double
-     */
-    @Override
-    public double weight() {
-        return weight;
-    }
-
-    /**
-     * Sets the weight.
-     *
-     * @param weight the new weight
-     */
-    @Override
-    public void setWeight(double weight) {
-        this.weight = weight;
-    }
-
-    /**
-     * Attribute.
-     *
-     * @param instAttIndex the inst att index
-     * @return the attribute
-     */
-    @Override
-    public Attribute attribute(int instAttIndex) {
-        return this.instanceHeader.attribute(instAttIndex);
-    }
-
-    /**
-     * Delete attribute at.
-     *
-     * @param i the i
-     */
-    @Override
-    public void deleteAttributeAt(int i) {
-        //throw new UnsupportedOperationException("Not yet implemented");
-        this.instanceData.deleteAttributeAt(i);
-    }
-
-    /**
-     * Insert attribute at.
-     *
-     * @param i the i
-     */
-    @Override
-    public void insertAttributeAt(int i) {
-        throw new UnsupportedOperationException("Not yet implemented");
-    }
-
-    /**
-     * Num attributes.
-     *
-     * @return the int
-     */
-    @Override
-    public int numAttributes() {
-        return this.instanceData.numAttributes();
-    }
-
-    /**
-     * Value.
-     *
-     * @param instAttIndex the inst att index
-     * @return the double
-     */
-    @Override
-    public double value(int instAttIndex) {
-        return this.instanceData.value(instAttIndex);
-    }
-
-    /**
-     * Checks if is missing.
-     *
-     * @param instAttIndex the inst att index
-     * @return true, if is missing
-     */
-    @Override
-    public boolean isMissing(int instAttIndex) {
-        return this.instanceData.isMissing(instAttIndex);
-    }
-
-    /**
-     * Num values.
-     *
-     * @return the int
-     */
-    @Override
-    public int numValues() {
-        return this.instanceData.numValues();
-    }
-
-    /**
-     * Index.
-     *
-     * @param i the i
-     * @return the int
-     */
-    @Override
-    public int index(int i) {
-        return this.instanceData.index(i);
-    }
-
-    /**
-     * Value sparse.
-     *
-     * @param i the i
-     * @return the double
-     */
-    @Override
-    public double valueSparse(int i) {
-        return this.instanceData.valueSparse(i);
-    }
-
-    /**
-     * Checks if is missing sparse.
-     *
-     * @param p the p
-     * @return true, if is missing sparse
-     */
-    @Override
-    public boolean isMissingSparse(int p) {
-        return this.instanceData.isMissingSparse(p);
-    }
-
-    /**
-     * Value.
-     *
-     * @param attribute the attribute
-     * @return the double
-     */
-    @Override
-    public double value(Attribute attribute) {
-        return value(attribute.index());
-
-    }
-
-    /**
-     * String value.
-     *
-     * @param i the i
-     * @return the string
-     */
-    @Override
-    public String stringValue(int i) {
-        throw new UnsupportedOperationException("Not yet implemented");
-    }
-
-    /**
-     * To double array.
-     *
-     * @return the double[]
-     */
-    @Override
-    public double[] toDoubleArray() {
-        return this.instanceData.toDoubleArray();
-    }
-
-    /**
-     * Sets the value.
-     *
-     * @param numAttribute the num attribute
-     * @param d the d
-     */
-    @Override
-    public void setValue(int numAttribute, double d) {
-        this.instanceData.setValue(numAttribute, d);
-    }
-
-    /**
-     * Class value.
-     *
-     * @return the double
-     */
-    @Override
-    public double classValue() {
-        return this.instanceData.value(classIndex());
-    }
-
-    /**
-     * Class index.
-     *
-     * @return the int
-     */
-    @Override
-    public int classIndex() {
-        int classIndex = instanceHeader.classIndex();
-        return classIndex != Integer.MAX_VALUE ? classIndex : 0;
-    }
-
-    /**
-     * Num classes.
-     *
-     * @return the int
-     */
-    @Override
-    public int numClasses() {
-        return this.instanceHeader.numClasses();
-    }
-
-    /**
-     * Class is missing.
-     *
-     * @return true, if successful
-     */
-    @Override
-    public boolean classIsMissing() {
-        return this.instanceData.isMissing(classIndex());
-    }
-
-    /**
-     * Class attribute.
-     *
-     * @return the attribute
-     */
-    @Override
-    public Attribute classAttribute() {
-        return this.instanceHeader.attribute(classIndex());
-    }
-
-    /**
-     * Sets the class value.
-     *
-     * @param d the new class value
-     */
-    @Override
-    public void setClassValue(double d) {
-        this.setValue(classIndex(), d);
-    }
-
-    /**
-     * Copy.
-     *
-     * @return the instance
-     */
-    @Override
-    public Instance copy() {
-        HierarhicalInstanceImpl inst = new HierarhicalInstanceImpl(this);
-        return inst;
-    }
-
-    /**
-     * Dataset.
-     *
-     * @return the instances
-     */
-    @Override
-    public Instances dataset() {
-        return this.instanceHeader;
-    }
-
-    /**
-     * Sets the dataset.
-     *
-     * @param dataset the new dataset
-     */
-    @Override
-    public void setDataset(Instances dataset) {
-        this.instanceHeader = new InstancesHeader(dataset);
-    }
-
-    /**
-     * Adds the sparse values.
-     *
-     * @param indexValues the index values
-     * @param attributeValues the attribute values
-     * @param numberAttributes the number attributes
-     */
-    @Override
-    public void addSparseValues(int[] indexValues, double[] attributeValues, int numberAttributes) {
-        this.instanceData = new SparseInstanceData(attributeValues, indexValues, numberAttributes); //???
-    }
-
-    /**
-     * Text representation of a InstanceImpl.
-     */
-    @Override
-    public String toString() {
-        double[] aux = this.instanceData.toDoubleArray();
-        StringBuilder str = new StringBuilder();
-        for (int i = 0; i < aux.length; i++) {
-            str.append(aux[i]).append(" ");
-        }
-
-        return str.toString();
-    }
-
-    @Override
-    public int numInputAttributes() {
-        return this.instanceHeader.numInputAttributes();
-    }
-
-    @Override
-    public int numOutputAttributes() {
-        return numberOutputTargets();
-    }
-    
-    @Override
-    public int numberOutputTargets() {
-        return this.instanceHeader.numOutputAttributes();
-    }
-
-    @Override
-    public double classValue(int instAttIndex) {
-        return valueOutputAttribute(instAttIndex);
-    }
-
-    @Override
-    public void setClassValue(int indexClass, double valueAttribute) {
-        InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
-        this.instanceData.setValue(instanceInformation.outputAttributeIndex(indexClass), valueAttribute);
-
-    }
-
-    @Override
-    public Attribute outputAttribute(int outputIndex) {
-        InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
-        return instanceInformation.outputAttribute(outputIndex);
-    }
-
-    @Override
-    public Attribute inputAttribute(int attributeIndex) {
-        InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
-        return instanceInformation.inputAttribute(attributeIndex);
-    }
-
-    @Override
-    public double valueInputAttribute(int attributeIndex) {
-        InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
-        return this.instanceData.value(instanceInformation.inputAttributeIndex(attributeIndex));
-    }
-
-    @Override
-    public double valueOutputAttribute(int attributeIndex) {
-        InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
-        return this.instanceData.value(instanceInformation.outputAttributeIndex(attributeIndex));
-    }
-    
-    public int structureType() {
-    	return Instance.STRUCTURE_TYPE_HIERARHICAL;
-    }
-    
-    public AttributeStructure getStructure() {
-    	return this.instanceHeader.getInstanceStructure();
-    }
-}
\ No newline at end of file
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
index dbf315738..6978bb385 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
@@ -184,6 +184,14 @@ public interface Instance extends Serializable {
      */
     public boolean classIsMissing();
 
+    /**
+     * Are any of the output values missing.
+     *
+     * @return true, if any output has missing value
+     */
+    public boolean missingOutputs();
+
+    
     /**
      * Class value.
      *
@@ -217,14 +225,14 @@ public interface Instance extends Serializable {
      *
      * @param dataset the new dataset
      */
-    public void setDataset(Instances dataset);
+    public void setDataset(InstancesHeader dataset);
 
     /**
      * Dataset.
      *
      * @return the instances
      */
-    public Instances dataset();
+    public InstancesHeader dataset();
 
     /**
      * Gets the number of input attributes.
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
index 16acdac54..7484abec2 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
@@ -308,6 +308,19 @@ public int numClasses() {
     public boolean classIsMissing() {
         return this.instanceData.isMissing(classIndex());
     }
+    
+    public boolean missingOutputs() {
+    	if (this.instanceHeader.numOutputAttributes() == 1)
+    		return classIsMissing();
+    	else {
+    		for (int i = 0; i < this.instanceHeader.numOutputAttributes(); i++) {
+    			if (this.instanceData.isMissing(outputAttribute(i).index)) {
+    				return true;
+    			}
+    		}
+    	}
+    	return false;
+    }
 
     /**
      * Class attribute.
@@ -346,7 +359,7 @@ public Instance copy() {
      * @return the instances
      */
     @Override
-    public Instances dataset() {
+    public InstancesHeader dataset() {
         return this.instanceHeader;
     }
 
@@ -356,7 +369,7 @@ public Instances dataset() {
      * @param dataset the new dataset
      */
     @Override
-    public void setDataset(Instances dataset) {
+    public void setDataset(InstancesHeader dataset) {
         this.instanceHeader = new InstancesHeader(dataset);
     }
 
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
index 7a8aae816..d9d769f77 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
@@ -16,6 +16,7 @@
 package com.yahoo.labs.samoa.instances;
 
 import java.io.Serializable;
+import java.util.ArrayList;
 import java.util.List;
 
 import moa.AbstractMOAObject;
@@ -34,18 +35,10 @@ public class InstanceInformation implements Serializable {
 
     protected AttributesInformation attributesInformation;
     
-    protected AttributeStructure structure = null;
-
-    /**
-     * The class index.
-     */
-    protected int classIndex = Integer.MAX_VALUE; //By default is multilabel
-
-    /**
-     * Range for multi-label instances.
-     */
-    protected Range range;
-
+    protected List<Integer> outputIndexes;
+    protected List<Integer> inputIndexes;
+    
+    
     public Attribute inputAttribute(int w) {
         return this.attributesInformation.attribute(inputAttributeIndex(w));
     }
@@ -54,6 +47,8 @@ public Attribute outputAttribute(int w) {
         return this.attributesInformation.attribute(outputAttributeIndex(w));
     }
 
+    
+    
     /**
      * Instantiates a new instance information.
      *
@@ -61,9 +56,9 @@ public Attribute outputAttribute(int w) {
      */
     public InstanceInformation(InstanceInformation chunk) {
         this.relationName = chunk.relationName;
+        this.outputIndexes = chunk.outputIndexes;
+        this.inputIndexes = chunk.inputIndexes;
         this.attributesInformation = chunk.attributesInformation;
-        this.structure = chunk.structure;
-        this.classIndex = chunk.classIndex;
     }
 
     /**
@@ -72,16 +67,38 @@ public InstanceInformation(InstanceInformation chunk) {
      * @param st the st
      * @param v the v
      */
-    public InstanceInformation(String st, List<Attribute> input) {
+    public InstanceInformation(String st, List<Attribute> attributes, List<Integer> outputIndexes, List<Integer> inputIndexes) {
+        this.relationName = st;
+        this.outputIndexes = outputIndexes;
+        this.inputIndexes = inputIndexes;
+        this.attributesInformation = new AttributesInformation(attributes, attributes.size());
+    }
+    
+    public InstanceInformation(String st, List<Attribute> input, List<Integer> indexes) {
         this.relationName = st;
-        this.attributesInformation = new AttributesInformation(input, input.size());
+        this.outputIndexes = new ArrayList<Integer>();
+        this.inputIndexes = new ArrayList<Integer>();
+        this.attributesInformation = new AttributesInformation(input, indexes, indexes.size());
     }
 
+    public InstanceInformation(String st, List<Attribute> input) {
+        this.relationName = st;
+        this.outputIndexes = new ArrayList<Integer>();
+        this.inputIndexes = new ArrayList<Integer>();
+        List<Integer> indexes = new ArrayList<Integer>();
+        for (int i = 0; i < input.size(); i++) {
+        	indexes.add(i);
+        }
+        this.attributesInformation = new AttributesInformation(input, indexes, indexes.size());
+    }
+    
     /**
      * Instantiates a new instance information.
      */
     public InstanceInformation() {
         this.relationName = null;
+        this.inputIndexes = null;
+        this.outputIndexes = null;
         this.attributesInformation = null;
     }
 
@@ -104,15 +121,16 @@ public String getRelationName() {
      * @see com.yahoo.labs.samoa.instances.InstanceInformationInterface#classIndex()
      */
     public int classIndex() {
-        return this.classIndex;
+    	if (this.outputIndexes.size() > 1)
+    		throw new UnsupportedOperationException("This instance has multiple output attributes.");
+        return this.outputIndexes.get(0);
     }
 
-    /* (non-Javadoc)
-     * @see com.yahoo.labs.samoa.instances.InstanceInformationInterface#setClassIndex(int)
-     */
-    public void setClassIndex(int classIndex) {
-        this.classIndex = classIndex;
+    public void setClassIndex(int index) {
+    	this.outputIndexes = new ArrayList<Integer>();
+    	this.outputIndexes.add(index);
     }
+    
 
     /* (non-Javadoc)
      * @see com.yahoo.labs.samoa.instances.InstanceInformationInterface#classAttribute()
@@ -163,63 +181,48 @@ public void setAttributes(List<Attribute> v) {
     }
 
     public int inputAttributeIndex(int index) {
-        int ret = 0;
-        if (classIndex == Integer.MAX_VALUE) {//Multi Label
-        	if(index<range.getStart())//JD
-        		ret= index;
-        	else 
-        		ret= index+range.getSelectionLength();
-	
-        } else { //Single Label
-            ret = classIndex() > index ? index : index + 1;
-        }
-        return ret;
+    	// Returns actual instance attribute index!
+        return inputIndexes.get(index);
     }
 
-    public int outputAttributeIndex(int attributeIndex) {
-        int ret = 0;
-        if (classIndex == Integer.MAX_VALUE) {//Multi Label
-        		ret=attributeIndex+range.getStart(); //JD - Range should be a "block"
-        } else { //Single Label
-            ret = classIndex;
-        }
-        return ret;
+    public int outputAttributeIndex(int index) {
+    	// Returns actual instance attribute index!
+    	return outputIndexes.get(index);    
     }
 
     public int numInputAttributes() {
-        int ret = 0;
-        if (classIndex == Integer.MAX_VALUE) {//Multi Label
-        	ret=this.numAttributes()-range.getSelectionLength(); //JD
-        } else { //Single Label
-            ret = this.numAttributes() - 1;
-        }
-        return ret;
+        return inputIndexes.size();
     }
 
     public int numOutputAttributes() {
-        int ret = 0;
-        if (classIndex == Integer.MAX_VALUE) {//Multi Label
-        	ret=range.getSelectionLength(); //JD
-        } else { //Single Label
-            ret = 1;
-        }
-        return ret;
-    }
 
-    public void setRangeOutputIndices(Range range) {
-        this.setClassIndex(Integer.MAX_VALUE);
-        this.range = range;
+    	return outputIndexes.size();
     }
 
 	public void setAttributes(List<Attribute> v, List<Integer> indexValues) {
     	if(this.attributesInformation==null)
     		this.attributesInformation= new AttributesInformation();
         this.attributesInformation.setAttributes(v,indexValues);
-		
+	}
+
+	public void setOutputIndexes(List<Integer> outputIndexes) {
+		this.outputIndexes = outputIndexes;
 	}
 	
-	public AttributeStructure getStructure() {
-		return this.structure;
+	public void setInputIndexes(List<Integer> inputIndexes) {
+		this.inputIndexes = inputIndexes;
+	}
+
+	/** 
+	 * Sets all non-output attributes as input attributes.
+	 */
+	public void setInputIndexes() {
+		this.inputIndexes = new ArrayList<Integer>();
+		for (int i = 0; i < attributesInformation.indexValues.size(); i++) {
+			if (!outputIndexes.contains(attributesInformation.indexValues.get(i))) {
+				inputIndexes.add(attributesInformation.indexValues.get(i));
+			}
+		}
 	}
 
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/Instances.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/Instances.java
deleted file mode 100644
index 7a52cead0..000000000
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/Instances.java
+++ /dev/null
@@ -1,542 +0,0 @@
-/*
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
- * either express or implied. See the License for the specific
- * language governing permissions and limitations under the
- * License.  
- */
-package com.yahoo.labs.samoa.instances;
-
-import java.io.Reader;
-import java.io.Serializable;
-import java.io.StringReader;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Random;
-import moa.core.Utils;
-
-/**
- * The Class Instances.
- *
- * @author abifet
- */
-public class Instances implements Serializable {
-
-    /** The keyword used to denote the start of an arff header */
-    public final static String ARFF_RELATION = "@relation";
-  
-    /** The keyword used to denote the start of the arff data section */
-    public final static String ARFF_DATA = "@data";
-  
-    private static final long serialVersionUID = 8110510475535581577L;
-    /**
-     * The instance information.
-     */
-    protected InstanceInformation instanceInformation;
-    /**
-     * The instances.
-     */
-    protected List<Instance> instances;
-
-    /**
-     * The arff.
-     */
-    protected ArffLoader arff;
-
-    /**
-     * Instantiates a new instances.
-     *
-     * @param chunk the chunk
-     */
-    public Instances(Instances chunk) {
-        this(chunk, chunk.numInstances());
-        chunk.copyInstances(0, this, chunk.numInstances());
-    }
-
-    /**
-     * Instantiates a new instances.
-     */
-    public Instances() {
-    }
-
-    /**
-     * Instantiates a new instances.
-     *
-     * @param reader the reader
-     * @param size the size
-     * @param classAttribute the class attribute
-     */
-    public Instances(Reader reader, int size, int classAttribute) {
-        arff = new ArffLoader(reader, 0, classAttribute);
-        this.instanceInformation = arff.getStructure();
-        this.instances = new ArrayList<Instance>();
-    }
-
-    /**
-     * Instantiates a new instances.
-     *
-     * @param reader the reader
-     * @param range
-     */
-    public Instances(Reader reader, Range range) {
-        this.arff = new MultiTargetArffLoader(reader, range);
-        this.instanceInformation = arff.getStructure();
-        this.instances = new ArrayList<Instance>();
-    }
-
-    /**
-     * Instantiates a new instances.
-     *
-     * @param chunk the chunk
-     * @param capacity the capacity
-     */
-    public Instances(Instances chunk, int capacity) {
-        this.instanceInformation = chunk.instanceInformation();
-        if (capacity < 0) {
-            capacity = 0;
-        }
-        this.instances = new ArrayList<Instance>(capacity);
-    }
-
-    /**
-     * Instantiates a new instances.
-     *
-     * @param st the st
-     * @param v the v
-     * @param capacity the capacity
-     */
-    public Instances(String st, List<Attribute> v, int capacity) {
-        this.instanceInformation = new InstanceInformation(st, v);
-    }
-
-    /**
-     * Instantiates a new instances.
-     *
-     * @param chunk the chunk
-     * @param first the first instance
-     * @param toCopy the j
-     */
-    public Instances(Instances chunk, int first, int toCopy) {
-
-        this(chunk, toCopy);
-
-        if ((first < 0) || ((first + toCopy) > chunk.numInstances())) {
-            throw new IllegalArgumentException("Parameters first and/or toCopy out "
-                    + "of range");
-        }
-        chunk.copyInstances(first, this, toCopy);
-    }
-
-    /**
-     * Instantiates a new instances.
-     *
-     * @param st the st
-     * @param capacity the capacity
-     */
-    public Instances(StringReader st, int capacity) {
-         this.instances = new ArrayList<Instance>(capacity);
-    }
-
-    //Information Instances
-    /**
-     * Sets the relation name.
-     *
-     * @param string the new relation name
-     */
-    public void setRelationName(String string) {
-        this.instanceInformation.setRelationName(string);
-    }
-
-    /**
-     * Gets the relation name.
-     *
-     * @return the relation name
-     */
-    public String getRelationName() {
-        return this.instanceInformation.getRelationName();
-    }
-
-    /**
-     * Class index.
-     *
-     * @return the int
-     */
-    public int classIndex() {
-        return this.instanceInformation.classIndex();
-    }
-
-    /**
-     * Sets the class index.
-     *
-     * @param classIndex the new class index
-     */
-    public void setClassIndex(int classIndex) {
-        this.instanceInformation.setClassIndex(classIndex);
-    }
-
-    /**
-     * Class attribute.
-     *
-     * @return the attribute
-     */
-    public Attribute classAttribute() {
-        return this.instanceInformation.classAttribute();
-    }
-
-    /**
-     * Num attributes.
-     *
-     * @return the int
-     */
-    public int numAttributes() {
-        return this.instanceInformation.numAttributes();
-    }
-
-    /**
-     * Attribute.
-     *
-     * @param w the w
-     * @return the attribute
-     */
-    public Attribute attribute(int w) {
-        return this.instanceInformation.attribute(w);
-    }
-
-    /**
-     * Num classes.
-     *
-     * @return the int
-     */
-    public int numClasses() {
-        return this.instanceInformation.numClasses();
-    }
-
-    /**
-     * Delete attribute at.
-     *
-     * @param integer the integer
-     */
-    public void deleteAttributeAt(Integer integer) {
-        this.instanceInformation.deleteAttributeAt(integer);
-    }
-
-    /**
-     * Insert attribute at.
-     *
-     * @param attribute the attribute
-     * @param i the i
-     */
-    public void insertAttributeAt(Attribute attribute, int i) {
-    	if (this.instanceInformation==null)
-    		this.instanceInformation= new InstanceInformation();
-        this.instanceInformation.insertAttributeAt(attribute, i);
-    }
-
-    //List of Instances
-    /**
-     * Instance.
-     *
-     * @param num the num
-     * @return the instance
-     */
-    public Instance instance(int num) {
-        return this.instances.get(num);
-    }
-
-    /**
-     * Num instances.
-     *
-     * @return the int
-     */
-    public int numInstances() {
-        return this.instances.size();
-    }
-
-    /**
-     * Adds the.
-     *
-     * @param inst the inst
-     */
-    public void add(Instance inst) {
-        this.instances.add(inst.copy());
-    }
-
-    /**
-     * Randomize.
-     *
-     * @param random the random
-     */
-    public void randomize(Random random) {
-        for (int j = numInstances() - 1; j > 0; j--) {
-            swap(j, random.nextInt(j + 1));
-        }
-    }
-
-    /**
-     * Stratify.
-     *
-     * @param numFolds the num folds
-     */
-    public void stratify(int numFolds) {
-
-        if (classAttribute().isNominal()) {
-
-            // sort by class
-            int index = 1;
-            while (index < numInstances()) {
-                Instance instance1 = instance(index - 1);
-                for (int j = index; j < numInstances(); j++) {
-                    Instance instance2 = instance(j);
-                    if ((instance1.classValue() == instance2.classValue())
-                            || (instance1.classIsMissing()
-                            && instance2.classIsMissing())) {
-                        swap(index, j);
-                        index++;
-                    }
-                }
-                index++;
-            }
-            stratStep(numFolds);
-        }
-    }
-
-    protected void stratStep(int numFolds) {
-        ArrayList<Instance> newVec = new ArrayList<Instance>(this.instances.size());
-        int start = 0, j;
-
-        // create stratified batch
-        while (newVec.size() < numInstances()) {
-            j = start;
-            while (j < numInstances()) {
-                newVec.add(instance(j));
-                j = j + numFolds;
-            }
-            start++;
-        }
-        this.instances = newVec;
-    }
-
-    /**
-     * Train cv.
-     *
-     * @param numFolds the num folds
-     * @param numFold
-     * @param n the n
-     * @param random the random
-     * @return the instances
-     */
-    public Instances trainCV(int numFolds, int numFold, Random random) {
-        Instances train = trainCV(numFolds, numFold);
-        train.randomize(random);
-        return train;
-    }
-
-    public Instances trainCV(int numFolds, int numFold) {
-        int numInstForFold, first, offset;
-        Instances train;
-
-        numInstForFold = numInstances() / numFolds;
-        if (numFold < numInstances() % numFolds) {
-            numInstForFold++;
-            offset = numFold;
-        } else {
-            offset = numInstances() % numFolds;
-        }
-        train = new Instances(this, numInstances() - numInstForFold);
-        first = numFold * (numInstances() / numFolds) + offset;
-        copyInstances(0, train, first);
-        copyInstances(first + numInstForFold, train,
-                numInstances() - first - numInstForFold);
-        return train;
-    }
-
-    protected void copyInstances(int from, Instances dest, int num) {
-        for (int i = 0; i < num; i++) {
-            dest.add(instance(from + i));
-        }
-    }
-
-    /**
-     * Test cv.
-     *
-     * @param numFolds the num folds
-     * @param numFold the num fold
-     * @return the instances
-     */
-    public Instances testCV(int numFolds, int numFold) {
-
-        int numInstForFold, first, offset;
-        Instances test;
-
-        numInstForFold = numInstances() / numFolds;
-        if (numFold < numInstances() % numFolds) {
-            numInstForFold++;
-            offset = numFold;
-        } else {
-            offset = numInstances() % numFolds;
-        }
-        test = new Instances(this, numInstForFold);
-        first = numFold * (numInstances() / numFolds) + offset;
-        copyInstances(first, test, numInstForFold);
-        return test;
-    }
-
-    /*  public Instances dataset() {
-     throw new UnsupportedOperationException("Not yet implemented");
-     }*/
-    /**
-     * Mean or mode.
-     *
-     * @param j the j
-     * @return the double
-     */
-    public double meanOrMode(int j) {
-        throw new UnsupportedOperationException("Not yet implemented"); //CobWeb
-    }
-
-    /**
-     * Read instance.
-     *
-     * @param fileReader the file reader
-     * @return true, if successful
-     */
-    public boolean readInstance(Reader fileReader) {
-
-        //ArffReader arff = new ArffReader(reader, this, m_Lines, 1);
-        Instance inst = arff.readInstance();
-        if (inst != null) {
-            inst.setDataset(this);
-            add(inst);
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    /**
-     * Delete.
-     */
-    public void delete() {
-        this.instances = new ArrayList<Instance>();
-    }
-    
-     /**
-     * Delete.
-     */
-    public void delete(int index) {
-        this.instances.remove(index);
-    }
-
-
-    /**
-     * Swap.
-     *
-     * @param i the i
-     * @param j the j
-     */
-    public void swap(int i, int j) {
-        Instance in = instances.get(i);
-        instances.set(i, instances.get(j));
-        instances.set(j, in);
-    }
-
-    /**
-     * Instance information.
-     *
-     * @return the instance information
-     */
-    private InstanceInformation instanceInformation() {
-        return this.instanceInformation;
-    }
-
-    public Attribute attribute(String name) {
-
-        for (int i = 0; i < numAttributes(); i++) {
-            if (attribute(i).name().equals(name)) {
-                return attribute(i);
-            }
-        }
-        return null;
-    }
-
-    public int size() {
-        return this.numInstances();
-    }
-
-    public void set(int i, Instance inst) {
-        this.instances.set(i, inst);
-    }
-
-    public Instance get(int k) {
-        return this.instance(k);
-    }
-
-	public void setRangeOutputIndices(Range range) {
-		this.instanceInformation.setRangeOutputIndices(range);
-		
-	}
-	
-    public void setAttributes(List<Attribute> v) {
-    	if(this.instanceInformation==null)
-    		this.instanceInformation= new InstanceInformation();
-        this.instanceInformation.setAttributes(v);
-    }
-    
-    public void setAttributes(List<Attribute> v, List<Integer> indexValues) {
-    	if(this.instanceInformation==null)
-    		this.instanceInformation= new InstanceInformation();
-        this.instanceInformation.setAttributes(v, indexValues);
-    }
-    
-      /**
-   * Returns the dataset as a string in ARFF format. Strings
-   * are quoted if they contain whitespace characters, or if they
-   * are a question mark.
-   *
-   * @return the dataset in ARFF format as a string
-   */
-  public String toString() {
-    
-    StringBuffer text = new StringBuffer();
-    
-    text.append(ARFF_RELATION).append(" ").
-      append(Utils.quote( this.instanceInformation.getRelationName())).append("\n\n");
-    for (int i = 0; i < numAttributes(); i++) {
-      text.append(attribute(i).toString()).append("\n");
-    }
-    text.append("\n").append(ARFF_DATA).append("\n");
-
-    text.append(stringWithoutHeader());
-    return text.toString();
-  }
-  
-    /**
-   * Returns the instances in the dataset as a string in ARFF format. Strings
-   * are quoted if they contain whitespace characters, or if they
-   * are a question mark.
-   *
-   * @return the dataset in ARFF format as a string
-   */
-  protected String stringWithoutHeader() {
-    
-    StringBuffer text = new StringBuffer();
-
-    for (int i = 0; i < numInstances(); i++) {
-      text.append(instance(i));
-      if (i < numInstances() - 1) {
-	text.append('\n');
-      }
-    }
-    return text.toString();
-    
-  }
-  
-}
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
index 6086fa888..421cbb74e 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
@@ -15,116 +15,642 @@
  */
 package com.yahoo.labs.samoa.instances;
 
+import java.io.Reader;
+import java.io.Serializable;
+import java.io.StringReader;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import org.junit.experimental.theories.Theories;
+
+import moa.core.Utils;
+
 /**
- * Class for storing the header or context of a data stream. It allows to know
- * the number of attributes and classes.
+ * The Class Instances.
  *
- * @version $Revision: 7 $
+ * @author abifet
  */
-public class InstancesHeader extends Instances {
+public class InstancesHeader implements Serializable {
 
+    /** The keyword used to denote the start of an arff header */
+    public final static String ARFF_RELATION = "@relation";
+  
+    /** The keyword used to denote the start of the arff data section */
+    public final static String ARFF_DATA = "@data";
+    
     private static final long serialVersionUID = 1L;
 
-    public InstancesHeader(Instances i) {
-        super(i, 0);
+	/**
+     * The instance information.
+     */
+    protected InstanceInformation instanceInformation;
+    /**
+     * The instances.
+     */
+    protected List<Instance> instances;
+
+    /**
+     * The arff.
+     */
+    protected ArffLoader arff;
+
+    /**
+     * Instantiates a new instances.
+     *
+     * @param chunk the chunk
+     */
+    public InstancesHeader(InstancesHeader chunk) {
+        this(chunk, chunk.numInstances());
+        chunk.copyInstances(0, this, chunk.numInstances());
     }
 
+    /**
+     * Instantiates a new instances.
+     */
     public InstancesHeader() {
-        super();
     }
 
-    public static String getClassNameString(InstancesHeader context) {
-        if (context == null) {
-            return "[class]";
-        }
-        return "[class:" + context.classAttribute().name() + "]";
+    /**
+     * Instantiates a new instances.
+     *
+     * @param reader the reader
+     * @param size the size
+     * @param classAttribute the class attribute
+     */
+    public InstancesHeader(Reader reader, int size, int classAttribute) {
+        arff = new ArffLoader(reader, String.valueOf(classAttribute));
+    	this.instanceInformation = arff.instanceInformation;
+        this.instances = new ArrayList<Instance>();
     }
 
-    public static String getClassLabelString(InstancesHeader context,
-            int classLabelIndex) {
-        if ((context == null) || (classLabelIndex >= context.numClasses())) {
-            return "<class " + (classLabelIndex + 1) + ">";
+    public InstancesHeader(Reader reader, String outputDefinition) {
+    	this.arff = new ArffLoader(reader, outputDefinition);
+    	this.instanceInformation = arff.instanceInformation;
+    	this.instances = new ArrayList<Instance>();
+    }
+    
+    public InstancesHeader(Reader reader, String outputDefinition, String inputDefinition) {
+    	this.arff = new ArffLoader(reader, outputDefinition, inputDefinition);
+    	this.instanceInformation = arff.instanceInformation;
+    	this.instances = new ArrayList<Instance>();
+    }
+    
+    public InstancesHeader(Reader reader, int size, String outputDefinition, String inputDefinition) {
+    	this.arff = new ArffLoader(reader, outputDefinition, inputDefinition);
+    	this.instanceInformation = arff.instanceInformation;
+    	this.instances = new ArrayList<Instance>();
+    }
+    
+    /**
+     * Instantiates a new instances.
+     *
+     * @param reader the reader
+     * @param range
+     */
+//    public Instances(Reader reader, Range range) {
+//        this.arff = new MultiTargetArffLoader(reader, range);
+//        this.instanceInformation = arff.getStructure();
+//        this.instances = new ArrayList<Instance>();
+//    }
+
+    /**
+     * Instantiates a new instances.
+     *
+     * @param chunk the chunk
+     * @param capacity the capacity
+     */
+    public InstancesHeader(InstancesHeader chunk, int capacity) {
+        this.instanceInformation = chunk.instanceInformation();
+        if (capacity < 0) {
+            capacity = 0;
         }
-        return "<class " + (classLabelIndex + 1) + ":"
-                + context.classAttribute().value(classLabelIndex) + ">";
+        this.instances = new ArrayList<Instance>(capacity);
     }
 
-    // is impervious to class index changes - attIndex is true attribute index
-    // regardless of class position
-    public static String getAttributeNameString(InstancesHeader context,
-            int attIndex) {
-        if ((context == null) || (attIndex >= context.numAttributes())) {
-            return "[att " + (attIndex + 1) + "]";
+    /**
+     * Instantiates a new instances.
+     *
+     * @param st the st
+     * @param v the v
+     * @param capacity the capacity
+     */
+    public InstancesHeader(String st, List<Attribute> v, int capacity) {
+        this.instanceInformation = new InstanceInformation(st, v);
+    }
+
+    /**
+     * Instantiates a new instances.
+     *
+     * @param chunk the chunk
+     * @param first the first instance
+     * @param toCopy the j
+     */
+    public InstancesHeader(InstancesHeader chunk, int first, int toCopy) {
+
+        this(chunk, toCopy);
+
+        if ((first < 0) || ((first + toCopy) > chunk.numInstances())) {
+            throw new IllegalArgumentException("Parameters first and/or toCopy out "
+                    + "of range");
         }
-        int instAttIndex = attIndex < context.classIndex() ? attIndex
-                : attIndex + 1;
-        return "[att " + (attIndex + 1) + ":"
-                + context.attribute(instAttIndex).name() + "]";
+        chunk.copyInstances(first, this, toCopy);
+    }
+
+    /**
+     * Instantiates a new instances.
+     *
+     * @param st the st
+     * @param capacity the capacity
+     */
+    public InstancesHeader(StringReader st, int capacity) {
+         this.instances = new ArrayList<Instance>(capacity);
+    }
+
+    //Information Instances
+    /**
+     * Sets the relation name.
+     *
+     * @param string the new relation name
+     */
+    public void setRelationName(String string) {
+        this.instanceInformation.setRelationName(string);
     }
 
-    public static String getInputAttributeNameString(InstancesHeader context,
-                                                int attIndex) {
-        if ((context == null) || (attIndex >= context.numInputAttributes())) {
-            return "[att " + (attIndex + 1) + "]";
+    /**
+     * Gets the relation name.
+     *
+     * @return the relation name
+     */
+    public String getRelationName() {
+        return this.instanceInformation.getRelationName();
+    }
+
+    /**
+     * Class index.
+     *
+     * @return the int
+     */
+    public int classIndex() {
+        return this.instanceInformation.classIndex();
+    }
+
+    /**
+     * Sets the class index. Also sets all other attributes as input attributes for backward compatibility.
+     *
+     * @param classIndex the new class index
+     */
+    public void setClassIndex(int classIndex) {
+        this.instanceInformation.setClassIndex(classIndex);
+        this.instanceInformation.setInputIndexes();
+    }
+
+    public void setOutputIndexes(List<Integer> outputIndexes) {
+        this.instanceInformation.setOutputIndexes(outputIndexes);
+    }
+
+    public void setInputIndexes(List<Integer> inputIndexes) {
+        this.instanceInformation.setInputIndexes(inputIndexes);
+    }
+
+	/** 
+	 * Sets all non-output attributes as input attributes.
+	 */
+	public void setInputIndexes() {
+        this.instanceInformation.setInputIndexes();
+	}
+    
+    /**
+     * Class attribute.
+     *
+     * @return the attribute
+     */
+    public Attribute classAttribute() {
+        return this.instanceInformation.classAttribute();
+    }
+
+    /**
+     * Num attributes.
+     *
+     * @return the int
+     */
+    public int numAttributes() {
+        return this.instanceInformation.numAttributes();
+    }
+
+    /**
+     * Attribute.
+     *
+     * @param w the w
+     * @return the attribute
+     */
+    public Attribute attribute(int w) {
+        return this.instanceInformation.attribute(w);
+    }
+
+    /**
+     * Num classes.
+     *
+     * @return the int
+     */
+    public int numClasses() {
+        return this.instanceInformation.numClasses();
+    }
+
+    /**
+     * Delete attribute at.
+     *
+     * @param integer the integer
+     */
+    public void deleteAttributeAt(Integer integer) {
+        this.instanceInformation.deleteAttributeAt(integer);
+    }
+
+    /**
+     * Insert attribute at.
+     *
+     * @param attribute the attribute
+     * @param i the i
+     */
+    public void insertAttributeAt(Attribute attribute, int i) {
+    	if (this.instanceInformation==null)
+    		this.instanceInformation= new InstanceInformation();
+        this.instanceInformation.insertAttributeAt(attribute, i);
+    }
+
+    //List of Instances
+    /**
+     * Instance.
+     *
+     * @param num the num
+     * @return the instance
+     */
+    public Instance instance(int num) {
+        return this.instances.get(num);
+    }
+
+    /**
+     * Num instances.
+     *
+     * @return the int
+     */
+    public int numInstances() {
+        return this.instances.size();
+    }
+
+    /**
+     * Adds the.
+     *
+     * @param inst the inst
+     */
+    public void add(Instance inst) {
+        this.instances.add(inst.copy());
+    }
+
+    /**
+     * Randomize.
+     *
+     * @param random the random
+     */
+    public void randomize(Random random) {
+        for (int j = numInstances() - 1; j > 0; j--) {
+            swap(j, random.nextInt(j + 1));
         }
-        int instAttIndex = attIndex;
-        return "[att " + (attIndex + 1) + ":"
-                + context.inputAttribute(instAttIndex).name() + "]";
-    }
-
-    // is impervious to class index changes - attIndex is true attribute index
-    // regardless of class position
-    public static String getNominalValueString(InstancesHeader context,
-            int attIndex, int valIndex) {
-        if (context != null) {
-            int instAttIndex = attIndex < context.classIndex() ? attIndex
-                    : attIndex + 1;
-            if ((instAttIndex < context.numAttributes())
-                    && (valIndex < context.attribute(instAttIndex).numValues())) {
-                return "{val " + (valIndex + 1) + ":"
-                        + context.attribute(instAttIndex).value(valIndex) + "}";
+    }
+
+    /**
+     * Stratify.
+     *
+     * @param numFolds the num folds
+     */
+    public void stratify(int numFolds) {
+
+        if (classAttribute().isNominal()) {
+
+            // sort by class
+            int index = 1;
+            while (index < numInstances()) {
+                Instance instance1 = instance(index - 1);
+                for (int j = index; j < numInstances(); j++) {
+                    Instance instance2 = instance(j);
+                    if ((instance1.classValue() == instance2.classValue())
+                            || (instance1.classIsMissing()
+                            && instance2.classIsMissing())) {
+                        swap(index, j);
+                        index++;
+                    }
+                }
+                index++;
             }
+            stratStep(numFolds);
         }
-        return "{val " + (valIndex + 1) + "}";
-    }
-
-    // is impervious to class index changes - attIndex is true attribute index
-    // regardless of class position
-    public static String getNumericValueString(InstancesHeader context,
-            int attIndex, double value) {
-        if (context != null) {
-            int instAttIndex = attIndex < context.classIndex() ? attIndex
-                    : attIndex + 1;
-            if (instAttIndex < context.numAttributes()) {
-                if (context.attribute(instAttIndex).isDate()) {
-                    return context.attribute(instAttIndex).formatDate(value);
-                }
+    }
+
+    protected void stratStep(int numFolds) {
+        ArrayList<Instance> newVec = new ArrayList<Instance>(this.instances.size());
+        int start = 0, j;
+
+        // create stratified batch
+        while (newVec.size() < numInstances()) {
+            j = start;
+            while (j < numInstances()) {
+                newVec.add(instance(j));
+                j = j + numFolds;
             }
+            start++;
+        }
+        this.instances = newVec;
+    }
+
+    /**
+     * Train cv.
+     *
+     * @param numFolds the num folds
+     * @param numFold
+     * @param n the n
+     * @param random the random
+     * @return the instances
+     */
+    public InstancesHeader trainCV(int numFolds, int numFold, Random random) {
+        InstancesHeader train = trainCV(numFolds, numFold);
+        train.randomize(random);
+        return train;
+    }
+
+    public InstancesHeader trainCV(int numFolds, int numFold) {
+        int numInstForFold, first, offset;
+        InstancesHeader train;
+
+        numInstForFold = numInstances() / numFolds;
+        if (numFold < numInstances() % numFolds) {
+            numInstForFold++;
+            offset = numFold;
+        } else {
+            offset = numInstances() % numFolds;
+        }
+        train = new InstancesHeader(this, numInstances() - numInstForFold);
+        first = numFold * (numInstances() / numFolds) + offset;
+        copyInstances(0, train, first);
+        copyInstances(first + numInstForFold, train,
+                numInstances() - first - numInstForFold);
+        return train;
+    }
+
+    protected void copyInstances(int from, InstancesHeader dest, int num) {
+        for (int i = 0; i < num; i++) {
+            dest.add(instance(from + i));
+        }
+    }
+
+    /**
+     * Test cv.
+     *
+     * @param numFolds the num folds
+     * @param numFold the num fold
+     * @return the instances
+     */
+    public InstancesHeader testCV(int numFolds, int numFold) {
+
+        int numInstForFold, first, offset;
+        InstancesHeader test;
+
+        numInstForFold = numInstances() / numFolds;
+        if (numFold < numInstances() % numFolds) {
+            numInstForFold++;
+            offset = numFold;
+        } else {
+            offset = numInstances() % numFolds;
         }
-        return Double.toString(value);
+        test = new InstancesHeader(this, numInstForFold);
+        first = numFold * (numInstances() / numFolds) + offset;
+        copyInstances(first, test, numInstForFold);
+        return test;
     }
 
-    public Attribute inputAttribute(int w) {
-        return this.instanceInformation.inputAttribute(w);
+    /*  public Instances dataset() {
+     throw new UnsupportedOperationException("Not yet implemented");
+     }*/
+    /**
+     * Mean or mode.
+     *
+     * @param j the j
+     * @return the double
+     */
+    public double meanOrMode(int j) {
+        throw new UnsupportedOperationException("Not yet implemented"); //CobWeb
     }
 
-    public Attribute outputAttribute(int w) {
-        return this.instanceInformation.outputAttribute(w);
+    /**
+     * Read instance.
+     *
+     * @param fileReader the file reader
+     * @return true, if successful
+     */
+    public boolean readInstance(Reader fileReader) {
+
+        //ArffReader arff = new ArffReader(reader, this, m_Lines, 1);
+        Instance inst = arff.readInstance();
+        if (inst != null) {
+            inst.setDataset(this);
+            add(inst);
+            return true;
+        } else {
+            return false;
+        }
     }
 
-    public int numInputAttributes() {
-        return this.instanceInformation.numInputAttributes();
+    /**
+     * Delete.
+     */
+    public void delete() {
+        this.instances = new ArrayList<Instance>();
+    }
+    
+     /**
+     * Delete.
+     */
+    public void delete(int index) {
+        this.instances.remove(index);
     }
 
-    public int numOutputAttributes() {
-        return this.instanceInformation.numOutputAttributes();
+
+    /**
+     * Swap.
+     *
+     * @param i the i
+     * @param j the j
+     */
+    public void swap(int i, int j) {
+        Instance in = instances.get(i);
+        instances.set(i, instances.get(j));
+        instances.set(j, in);
     }
 
-    public InstanceInformation getInstanceInformation() {
+    /**
+     * Instance information.
+     *
+     * @return the instance information
+     */
+    private InstanceInformation instanceInformation() {
         return this.instanceInformation;
     }
+
+    public Attribute attribute(String name) {
+
+        for (int i = 0; i < numAttributes(); i++) {
+            if (attribute(i).name().equals(name)) {
+                return attribute(i);
+            }
+        }
+        return null;
+    }
+
+    public int size() {
+        return this.numInstances();
+    }
+
+    public void set(int i, Instance inst) {
+        this.instances.set(i, inst);
+    }
+
+    public Instance get(int k) {
+        return this.instance(k);
+    }
+
+//	public void setRangeOutputIndices(Range range) {
+//		this.instanceInformation.setRangeOutputIndices(range);
+//		
+//	}
+	
+    public void setAttributes(List<Attribute> v) {
+    	if(this.instanceInformation==null)
+    		this.instanceInformation= new InstanceInformation();
+        this.instanceInformation.setAttributes(v);
+    }
+    
+    public void setAttributes(List<Attribute> v, List<Integer> indexValues) {
+    	if(this.instanceInformation==null)
+    		this.instanceInformation= new InstanceInformation();
+        this.instanceInformation.setAttributes(v, indexValues);
+    }
+    
+      /**
+   * Returns the dataset as a string in ARFF format. Strings
+   * are quoted if they contain whitespace characters, or if they
+   * are a question mark.
+   *
+   * @return the dataset in ARFF format as a string
+   */
+  public String toString() {
+    
+    StringBuffer text = new StringBuffer();
+    
+    text.append(ARFF_RELATION).append(" ").
+      append(Utils.quote( this.instanceInformation.getRelationName())).append("\n\n");
+    for (int i = 0; i < numAttributes(); i++) {
+      text.append(attribute(i).toString()).append("\n");
+    }
+    text.append("\n").append(ARFF_DATA).append("\n");
+
+    text.append(stringWithoutHeader());
+    return text.toString();
+  }
+  
+    /**
+   * Returns the instances in the dataset as a string in ARFF format. Strings
+   * are quoted if they contain whitespace characters, or if they
+   * are a question mark.
+   *
+   * @return the dataset in ARFF format as a string
+   */
+  protected String stringWithoutHeader() {
     
-    public AttributeStructure getInstanceStructure() {
-    	return this.instanceInformation.getStructure();
+    StringBuffer text = new StringBuffer();
+
+    for (int i = 0; i < numInstances(); i++) {
+      text.append(instance(i));
+      if (i < numInstances() - 1) {
+	text.append('\n');
+      }
     }
+    return text.toString();
+    
+  }
+
+	public Attribute inputAttribute(int w) {
+	    return this.instanceInformation.inputAttribute(w);
+	}
+
+	public Attribute outputAttribute(int w) {
+	    return this.instanceInformation.outputAttribute(w);
+	}
+
+	public int numInputAttributes() {
+	    return this.instanceInformation.numInputAttributes();
+	}
+
+	public int numOutputAttributes() {
+	    return this.instanceInformation.numOutputAttributes();
+	}
+
+	public InstanceInformation getInstanceInformation() {
+	    return this.instanceInformation;
+	}
+
+	public static String getClassNameString(InstancesHeader context) {
+	    if (context == null) {
+	        return "[class]";
+	    }
+	    return "[class:" + context.classAttribute().name() + "]";
+	}
+
+	public static String getClassLabelString(InstancesHeader context, int classLabelIndex) {
+	    if ((context == null) || (classLabelIndex >= context.numClasses())) {
+	        return "<class " + (classLabelIndex + 1) + ">";
+	    }
+	    return "<class " + (classLabelIndex + 1) + ":"
+	            + context.classAttribute().value(classLabelIndex) + ">";
+	}
+
+	public static String getAttributeNameString(InstancesHeader context, int attIndex) {
+	    if ((context == null) || (attIndex >= context.numAttributes())) {
+	        return "[att " + (attIndex + 1) + "]";
+	    }
+	    return "[att " + (attIndex + 1) + ":"
+	            + context.attribute(attIndex).name() + "]";
+	}
+
+	public static String getInputAttributeNameString(InstancesHeader context, int attIndex) {
+	    if ((context == null) || (attIndex >= context.numInputAttributes())) {
+	        return "[att " + (attIndex + 1) + "]";
+	    }
+	    return "[att " + (attIndex + 1) + ":"
+	            + context.inputAttribute(attIndex).name() + "]";
+	}
+
+	public static String getNominalValueString(InstancesHeader context, int attIndex, int valIndex) {
+	    if (context != null) {
+	        if ((attIndex < context.numInputAttributes())
+	                && (valIndex < context.inputAttribute(attIndex).numValues())) {
+	            return "{val " + (valIndex + 1) + ":"
+	                    + context.inputAttribute(attIndex).value(valIndex) + "}";
+	        }
+	    }
+	    return "{val " + (valIndex + 1) + "}";
+	}
+
+	public static String getNumericValueString(InstancesHeader context, int attIndex, double value) {
+	    if (context != null) {
+	        int instAttIndex = attIndex < context.classIndex() ? attIndex
+	                : attIndex + 1;
+	        if (instAttIndex < context.numAttributes()) {
+	            if (context.attribute(instAttIndex).isDate()) {
+	                return context.attribute(instAttIndex).formatDate(value);
+	            }
+	        }
+	    }
+	    return Double.toString(value);
+	}
+
+	
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiTargetArffLoader.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiTargetArffLoader.java
index fc7392e68..a0a4b0b48 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiTargetArffLoader.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiTargetArffLoader.java
@@ -19,24 +19,31 @@
 
 public class MultiTargetArffLoader extends ArffLoader {
 
-    public MultiTargetArffLoader(Reader reader) {
-        super(reader);
-    }
+	public MultiTargetArffLoader(Reader reader, String outputDefinition, String inputDefinition) {
+		super(reader, outputDefinition, inputDefinition);
+		// TODO Auto-generated constructor stub
+	}
 
-    public MultiTargetArffLoader(Reader reader, Range range) {
-        super(reader, range);
-    }
-
-    @Override
-    protected Instance newSparseInstance(double d, double[] res) {
-        return new SparseInstance(d, res); // TODO
-    }
-
-    @Override
-    protected Instance newDenseInstance(int numAttributes) {
-        // numAttributes is this.instanceInformation.numAttributes()
-        this.range.setUpper(numAttributes);
-        return new DenseInstance(numAttributes);
-    }
+// DEPRECATED
+	
+//    public MultiTargetArffLoader(Reader reader) {
+//        super(reader);
+//    }
+//
+//    public MultiTargetArffLoader(Reader reader, Range range) {
+//        super(reader, range);
+//    }
+//
+//    @Override
+//    protected Instance newSparseInstance(double d, double[] res) {
+//        return new SparseInstance(d, res); // TODO
+//    }
+//
+//    @Override
+//    protected Instance newDenseInstance(int numAttributes) {
+//        // numAttributes is this.instanceInformation.numAttributes()
+//        this.range.setUpper(numAttributes);
+//        return new DenseInstance(numAttributes);
+//    }
 
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/Range.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/Range.java
index ab27c38fb..d02e5fbbc 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/Range.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/Range.java
@@ -1,3 +1,4 @@
+
 /*
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/SamoaToWekaInstanceConverter.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/SamoaToWekaInstanceConverter.java
index f94851d93..3ef342875 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/SamoaToWekaInstanceConverter.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/SamoaToWekaInstanceConverter.java
@@ -77,7 +77,7 @@ public weka.core.Instance wekaInstance(Instance inst) {
      * @param instances the instances
      * @return the weka.core. instances
      */
-    public weka.core.Instances wekaInstances(Instances instances) {
+    public weka.core.Instances wekaInstances(InstancesHeader instances) {
         weka.core.Instances wekaInstances = wekaInstancesInformation(instances);
         //We assume that we have only one WekaInstanceInformation for SamoaToWekaInstanceConverter
         this.wekaInstanceInformation = wekaInstances;
@@ -93,7 +93,7 @@ public weka.core.Instances wekaInstances(Instances instances) {
      * @param instances the instances
      * @return the weka.core. instances
      */
-    public weka.core.Instances wekaInstancesInformation(Instances instances) {
+    public weka.core.Instances wekaInstancesInformation(InstancesHeader instances) {
         weka.core.Instances wekaInstances;
         ArrayList<weka.core.Attribute> attInfo = new ArrayList<weka.core.Attribute>();
         for (int i = 0; i < instances.numAttributes(); i++) {
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/StructuredInstance.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/StructuredInstance.java
index 279d6baed..9867f74ca 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/StructuredInstance.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/StructuredInstance.java
@@ -19,6 +19,9 @@
  * The Interface StructuredInstance.
  *
  * @author abifet
+ * 
+ * A placeholder for structured instances.
+ * 
  */
    
 public interface StructuredInstance extends Instance {
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/WekaToSamoaInstanceConverter.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/WekaToSamoaInstanceConverter.java
index f49d7397d..1937f6274 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/WekaToSamoaInstanceConverter.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/WekaToSamoaInstanceConverter.java
@@ -26,7 +26,7 @@
  */
 public class WekaToSamoaInstanceConverter implements Serializable{
 
-    protected Instances samoaInstanceInformation;
+    protected InstancesHeader samoaInstanceInformation;
     
     /**
      * Samoa instance from weka instance.
@@ -65,8 +65,8 @@ public Instance samoaInstance(weka.core.Instance inst) {
      * @param instances the instances
      * @return the instances
      */
-    public Instances samoaInstances(weka.core.Instances instances) {
-        Instances samoaInstances = samoaInstancesInformation(instances);
+    public InstancesHeader samoaInstances(weka.core.Instances instances) {
+        InstancesHeader samoaInstances = samoaInstancesInformation(instances);
         //We assume that we have only one samoaInstanceInformation for WekaToSamoaInstanceConverter
         this.samoaInstanceInformation = samoaInstances;
         for (int i = 0; i < instances.numInstances(); i++) {
@@ -81,13 +81,13 @@ public Instances samoaInstances(weka.core.Instances instances) {
      * @param instances the instances
      * @return the instances
      */
-    public Instances samoaInstancesInformation(weka.core.Instances instances) {
-        Instances samoaInstances;
+    public InstancesHeader samoaInstancesInformation(weka.core.Instances instances) {
+        InstancesHeader samoaInstances;
         List<Attribute> attInfo = new ArrayList<Attribute>();
         for (int i = 0; i < instances.numAttributes(); i++) {
             attInfo.add(samoaAttribute(i, instances.attribute(i)));
         }
-        samoaInstances = new Instances(instances.relationName(), attInfo, 0);
+        samoaInstances = new InstancesHeader(instances.relationName(), attInfo, 0);
         samoaInstances.setClassIndex(instances.classIndex());
         return samoaInstances;
     }
diff --git a/moa/src/main/java/moa/classifiers/AbstractClassifier.java b/moa/src/main/java/moa/classifiers/AbstractClassifier.java
index ee1c01c47..fb8daca38 100644
--- a/moa/src/main/java/moa/classifiers/AbstractClassifier.java
+++ b/moa/src/main/java/moa/classifiers/AbstractClassifier.java
@@ -44,7 +44,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstanceData;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 
@@ -68,7 +68,7 @@ public String getPurposeString() {
     protected int randomSeed = 1;
 
     /** Option for randomizable learners to change the random seed */
-    protected IntOption randomSeedOption;
+    public IntOption randomSeedOption;
 
     /** Random Generator used in randomizable learners  */
     public Random classifierRandom;
@@ -91,9 +91,9 @@ public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository)
         }
         
         // resetLearning should not be called if the classifier has not yet received the context
-//        if (!trainingHasStarted()) {
-//            resetLearning();
-//        }
+        if (!trainingHasStarted()) {
+            resetLearning();
+        }
     }
 
 	
@@ -120,7 +120,7 @@ public Prediction getPredictionForInstance(Instance inst){
     
     @Override
     public void setModelContext(InstancesHeader ih) {
-        if ((ih != null) && (ih.classIndex() < 0)) {
+        if ((ih != null) && (ih.numOutputAttributes() < 1)) {
             throw new IllegalArgumentException(
                     "Context for a classifier must include a class to learn");
         }
@@ -131,6 +131,10 @@ public void setModelContext(InstancesHeader ih) {
                     "New context is not compatible with existing model");
         }
         this.modelContext = ih;
+        this.modelContextSet();
+    }
+    
+    public void modelContextSet() {
     }
 
     @Override
@@ -170,7 +174,7 @@ public void resetLearning() {
     public void trainOnInstance(Instance inst) {
         boolean isTraining = (inst.weight() > 0.0);
         if (this instanceof SemiSupervisedLearner == false &&
-                inst.classIsMissing() == true){
+                inst.missingOutputs() == true){
             isTraining = false;
         }
         if (isTraining) {
@@ -430,7 +434,7 @@ protected static int modelAttIndexToInstanceAttIndex(int index,
      * @return the index of the attribute in the instances
      */
     protected static int modelAttIndexToInstanceAttIndex(int index,
-            Instances insts) {
+            InstancesHeader insts) {
         return insts.classIndex() > index ? index : index + 1;
     }
 }
diff --git a/moa/src/main/java/moa/classifiers/bayes/NaiveBayesMultinomial.java b/moa/src/main/java/moa/classifiers/bayes/NaiveBayesMultinomial.java
index 523e8d6c8..5e474770e 100644
--- a/moa/src/main/java/moa/classifiers/bayes/NaiveBayesMultinomial.java
+++ b/moa/src/main/java/moa/classifiers/bayes/NaiveBayesMultinomial.java
@@ -28,7 +28,7 @@
 import moa.core.StringUtils;
 import moa.core.Utils;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * <!-- globalinfo-start --> Class for building and using a multinomial Naive
@@ -77,7 +77,7 @@ public String getPurposeString() {
     /**
      * copy of header information for use in toString method
      */
-    protected Instances m_headerInfo;
+    protected InstancesHeader m_headerInfo;
 
     /**
      * number of class values
diff --git a/moa/src/main/java/moa/classifiers/core/conditionaltests/InstanceConditionalTest.java b/moa/src/main/java/moa/classifiers/core/conditionaltests/InstanceConditionalTest.java
index fad4d9a30..9d5160136 100644
--- a/moa/src/main/java/moa/classifiers/core/conditionaltests/InstanceConditionalTest.java
+++ b/moa/src/main/java/moa/classifiers/core/conditionaltests/InstanceConditionalTest.java
@@ -20,8 +20,9 @@
 package moa.classifiers.core.conditionaltests;
 
 import moa.AbstractMOAObject;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Abstract conditional test for instances to use to split nodes in Hoeffding trees.
diff --git a/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeBinaryTest.java b/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeBinaryTest.java
index 73498ff6b..519ec6a42 100644
--- a/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeBinaryTest.java
+++ b/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeBinaryTest.java
@@ -21,6 +21,7 @@
 
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Nominal binary conditional test for instances to use to split nodes in Hoeffding trees.
diff --git a/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeMultiwayTest.java b/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeMultiwayTest.java
index 003cf416c..a0dd5ff7b 100644
--- a/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeMultiwayTest.java
+++ b/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeMultiwayTest.java
@@ -21,6 +21,7 @@
 
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Nominal multi way conditional test for instances to use to split nodes in Hoeffding trees.
diff --git a/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java b/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
index d8cb5e8c3..597a7c07f 100644
--- a/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
+++ b/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
@@ -21,6 +21,7 @@
 
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Numeric binary conditional test for instances to use to split nodes in Hoeffding trees.
diff --git a/moa/src/main/java/moa/classifiers/lazy/kNN.java b/moa/src/main/java/moa/classifiers/lazy/kNN.java
index da99909e9..1cf765b1d 100644
--- a/moa/src/main/java/moa/classifiers/lazy/kNN.java
+++ b/moa/src/main/java/moa/classifiers/lazy/kNN.java
@@ -24,7 +24,6 @@
 import moa.classifiers.lazy.neighboursearch.NearestNeighbourSearch;
 import moa.core.Measurement;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.MultiChoiceOption;
@@ -62,12 +61,12 @@ public String getPurposeString() {
         return "kNN: special.";
     }
 
-    protected Instances window; 
+    protected InstancesHeader window; 
 
 	@Override
 	public void setModelContext(InstancesHeader context) {
 		try {
-			this.window = new Instances(context,0); //new StringReader(context.toString())
+			this.window = new InstancesHeader(context,0); //new StringReader(context.toString())
 			this.window.setClassIndex(context.classIndex());
 		} catch(Exception e) {
 			System.err.println("Error: no Model Context available.");
@@ -86,7 +85,7 @@ public void trainOnInstanceImpl(Instance inst) {
 		if (inst.classValue() > C)
 			C = (int)inst.classValue();
 		if (this.window == null) {
-			this.window = new Instances(inst.dataset());
+			this.window = new InstancesHeader(inst.dataset());
 		}
 		if (this.limitOption.getValue() <= this.window.numInstances()) {
 			this.window.delete(0);
@@ -106,7 +105,7 @@ public double[] getVotesForInstance(Instance inst) {
 				search.setInstances(this.window);
 			}	
 			if (this.window.numInstances()>0) {	
-				Instances neighbours = search.kNearestNeighbours(inst,Math.min(kOption.getValue(),this.window.numInstances()));
+				InstancesHeader neighbours = search.kNearestNeighbours(inst,Math.min(kOption.getValue(),this.window.numInstances()));
 				for(int i = 0; i < neighbours.numInstances(); i++) {
 					v[(int)neighbours.instance(i).classValue()]++;
 				}
diff --git a/moa/src/main/java/moa/classifiers/lazy/kNNwithPAW.java b/moa/src/main/java/moa/classifiers/lazy/kNNwithPAW.java
index 9d7103053..6b78777a3 100644
--- a/moa/src/main/java/moa/classifiers/lazy/kNNwithPAW.java
+++ b/moa/src/main/java/moa/classifiers/lazy/kNNwithPAW.java
@@ -19,7 +19,7 @@
 
 import moa.classifiers.core.driftdetection.ADWIN;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * k Nearest Neighbor ADAPTIVE with PAW.<p>
@@ -57,7 +57,7 @@ public void trainOnInstanceImpl(Instance inst) {
             C = (int) inst.classValue();
         }
         if (this.window == null) {
-            this.window = new Instances(inst.dataset());
+            this.window = new InstancesHeader(inst.dataset());
         }
 
         for (int i = 0; i < this.window.size(); i++) {
diff --git a/moa/src/main/java/moa/classifiers/lazy/kNNwithPAWandADWIN.java b/moa/src/main/java/moa/classifiers/lazy/kNNwithPAWandADWIN.java
index 1ff1b2412..65e9266ed 100644
--- a/moa/src/main/java/moa/classifiers/lazy/kNNwithPAWandADWIN.java
+++ b/moa/src/main/java/moa/classifiers/lazy/kNNwithPAWandADWIN.java
@@ -20,7 +20,7 @@
 import java.util.ArrayList;
 import moa.classifiers.core.driftdetection.ADWIN;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * k Nearest Neighbor ADAPTIVE with ADWIN+PAW.<p>
@@ -67,7 +67,7 @@ public void trainOnInstanceImpl(Instance inst) {
         }
         // ADWIN
         if (this.window == null) {
-            this.window = new Instances(inst.dataset());
+            this.window = new InstancesHeader(inst.dataset());
         }
 
         if (this.timeStamp == null) {
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/DistanceFunction.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/DistanceFunction.java
index 9df3b3a4c..ef0723941 100644
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/DistanceFunction.java
+++ b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/DistanceFunction.java
@@ -22,7 +22,7 @@
 package moa.classifiers.lazy.neighboursearch;
 
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Interface for any class that can compute and return distances between two
@@ -38,14 +38,14 @@ public interface DistanceFunction  {
    * 
    * @param insts 	the instances to use
    */
-  public void setInstances(Instances insts);
+  public void setInstances(InstancesHeader insts);
 
   /**
    * returns the instances currently set.
    * 
    * @return 		the current instances
    */
-  public Instances getInstances();
+  public InstancesHeader getInstances();
 
   /**
    * Sets the range of attributes to use in the calculation of the distance.
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/EuclideanDistance.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/EuclideanDistance.java
index f21197d81..ac9743bbc 100644
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/EuclideanDistance.java
+++ b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/EuclideanDistance.java
@@ -22,7 +22,7 @@
 package moa.classifiers.lazy.neighboursearch;
 
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  <!-- globalinfo-start -->
@@ -92,7 +92,7 @@ public EuclideanDistance() {
    * 
    * @param data 	the instances the distance function should work on
    */
-  public EuclideanDistance(Instances data) {
+  public EuclideanDistance(InstancesHeader data) {
     super(data);
   }
 
@@ -195,7 +195,7 @@ public double getMiddle(double[] ranges) {
    * @return 		the index of the closest point
    * @throws Exception	if something goes wrong
    */
-  public int closestPoint(Instance instance, Instances allPoints,
+  public int closestPoint(Instance instance, InstancesHeader allPoints,
       			  int[] pointList) throws Exception {
     double minDist = Integer.MAX_VALUE;
     int bestPoint = 0;
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/KDTree.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/KDTree.java
index 3a44f2b70..b3b6d7a0d 100644
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/KDTree.java
+++ b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/KDTree.java
@@ -27,7 +27,7 @@
 import moa.classifiers.lazy.neighboursearch.kdtrees.KDTreeNodeSplitter;
 import moa.classifiers.lazy.neighboursearch.kdtrees.SlidingMidPointOfWidestSide;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 
 
@@ -151,7 +151,7 @@ public KDTree() {
    * @param insts The instances/points on which the BallTree 
    * should be built on.
    */
-  public KDTree(Instances insts) {
+  public KDTree(InstancesHeader insts) {
     super(insts);
   }
 
@@ -166,7 +166,7 @@ public KDTree(Instances insts) {
    * @param instances	The instances to build the tree on
    * @throws Exception	if something goes wrong
    */
-  protected void buildKDTree(Instances instances) throws Exception {
+  protected void buildKDTree(InstancesHeader instances) throws Exception {
 
     checkMissing(instances);
     if (m_EuclideanDistance == null)
@@ -325,13 +325,13 @@ protected void findNearestNeighbours(Instance target, KDTreeNode node, int k,
    * one neighbours at the kth boundary). 
    * @throws Exception 	if the nearest neighbour could not be found.
    */
-  public Instances kNearestNeighbours(Instance target, int k) throws Exception {
+  public InstancesHeader kNearestNeighbours(Instance target, int k) throws Exception {
     checkMissing(target);
     
     MyHeap heap = new MyHeap(k);
     findNearestNeighbours(target, m_Root, k, heap, 0.0);
 
-    Instances neighbours = new Instances(m_Instances, (heap.size() + heap
+    InstancesHeader neighbours = new InstancesHeader(m_Instances, (heap.size() + heap
         .noOfKthNearest()));
     m_DistanceList = new double[heap.size() + heap.noOfKthNearest()];
     int[] indices = new int[heap.size() + heap.noOfKthNearest()];
@@ -399,7 +399,7 @@ public double[] getDistances() throws Exception {
    * @throws Exception If some error occurs while 
    * building the KDTree
    */
-  public void setInstances(Instances instances) throws Exception {
+  public void setInstances(InstancesHeader instances) throws Exception {
     super.setInstances(instances);
     buildKDTree(instances);
   }
@@ -527,7 +527,7 @@ public void addInstanceInfo(Instance instance) {
    * @param instances	the instances to check
    * @throws Exception	if missing values are encountered
    */
-  protected void checkMissing(Instances instances) throws Exception {
+  protected void checkMissing(InstancesHeader instances) throws Exception {
     for (int i = 0; i < instances.numInstances(); i++) {
       Instance ins = instances.instance(i);
       for (int j = 0; j < ins.numValues(); j++) {
@@ -698,7 +698,7 @@ public void setMeasurePerformance(boolean measurePerformance) {
    * @throws Exception If there is some problem 
    * assigning instances to centers.
    */
-  public void centerInstances(Instances centers, int[] assignments, double pc)
+  public void centerInstances(InstancesHeader centers, int[] assignments, double pc)
       throws Exception {
 
     int[] centList = new int[centers.numInstances()];
@@ -719,7 +719,7 @@ public void centerInstances(Instances centers, int[] assignments, double pc)
    * @throws Exception If there is some problem assigning 
    * instances to centers.
    */
-  protected void determineAssignments(KDTreeNode node, Instances centers,
+  protected void determineAssignments(KDTreeNode node, InstancesHeader centers,
       int[] candidates, int[] assignments, double pc) throws Exception {
 
     // reduce number of owners for current hyper rectangle
@@ -752,7 +752,7 @@ protected void determineAssignments(KDTreeNode node, Instances centers,
    * @return list of owners
    * @throws Exception If some problem occurs in refining.
    */
-  protected int[] refineOwners(KDTreeNode node, Instances centers,
+  protected int[] refineOwners(KDTreeNode node, InstancesHeader centers,
       int[] candidates) throws Exception {
 
     int[] owners = new int[candidates.length];
@@ -907,7 +907,7 @@ protected boolean candidateIsFullOwner(KDTreeNode node, Instance candidate,
    * @param assignments	index list of last assignments
    * @throws Exception If there is error assigning the instances.
    */
-  public void assignSubToCenters(KDTreeNode node, Instances centers,
+  public void assignSubToCenters(KDTreeNode node, InstancesHeader centers,
       int[] centList, int[] assignments) throws Exception {
     // todo: undecided situations
     int numCent = centList.length;
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/LinearNNSearch.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/LinearNNSearch.java
index 59b1f07bb..3c51f26c5 100644
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/LinearNNSearch.java
+++ b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/LinearNNSearch.java
@@ -22,7 +22,7 @@
 
 
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 //import weka.core.Option;
 //import weka.core.RevisionUtils;
 //import weka.core.Utils;
@@ -73,7 +73,7 @@ public LinearNNSearch() {
    * 
    * @param insts	the instances to use
    */
-  public LinearNNSearch(Instances insts) {
+  public LinearNNSearch(InstancesHeader insts) {
     super(insts);
     m_DistanceFunction.setInstances(insts);
   }
@@ -143,7 +143,7 @@ public Instance nearestNeighbour(Instance target) throws Exception {
    * @return		the k nearest neighbors
    * @throws Exception  if the neighbours could not be found.
    */
-  public Instances kNearestNeighbours(Instance target, int kNN) throws Exception {
+  public InstancesHeader kNearestNeighbours(Instance target, int kNN) throws Exception {
   
     //debug
     boolean print=false;
@@ -182,7 +182,7 @@ else if(distance == temp.distance) {
       }
     }
     
-    Instances neighbours = new Instances(m_Instances, (heap.size()+heap.noOfKthNearest()));
+    InstancesHeader neighbours = new InstancesHeader(m_Instances, (heap.size()+heap.noOfKthNearest()));
     m_Distances = new double[heap.size()+heap.noOfKthNearest()];
     int [] indices = new int[heap.size()+heap.noOfKthNearest()];
     int i=1; MyHeapElement h;
@@ -240,7 +240,7 @@ public double[] getDistances() throws Exception {
    * 			training set. 
    * @throws Exception	if setting of instances fails
    */
-  public void setInstances(Instances insts) throws Exception {
+  public void setInstances(InstancesHeader insts) throws Exception {
     m_Instances = insts;
     m_DistanceFunction.setInstances(insts);
   }
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NearestNeighbourSearch.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NearestNeighbourSearch.java
index 5b8402c35..ddefd58ae 100644
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NearestNeighbourSearch.java
+++ b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NearestNeighbourSearch.java
@@ -22,7 +22,7 @@
 
 import java.io.Serializable;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Abstract class for nearest neighbour search. All algorithms (classes) that
@@ -482,7 +482,7 @@ public NeighborNode getLast() {
   }
   
   /** The neighbourhood of instances to find neighbours in. */
-  protected Instances m_Instances;
+  protected InstancesHeader m_Instances;
   
   /** The number of neighbours to find. */
   protected int m_kNN;
@@ -504,7 +504,7 @@ public NearestNeighbourSearch() {
    * 
    * @param insts 	The set of instances that constitute the neighbourhood.
    */
-  public NearestNeighbourSearch(Instances insts) {
+  public NearestNeighbourSearch(InstancesHeader insts) {
     this();
     m_Instances = insts;
   }
@@ -592,7 +592,7 @@ public boolean getMeasurePerformance() {
    * @return		the k nearest neighbors
    * @throws Exception 	if the neighbours could not be found.
    */
-  public abstract Instances kNearestNeighbours(Instance target, int k) throws Exception;
+  public abstract InstancesHeader kNearestNeighbours(Instance target, int k) throws Exception;
  
   /**
    * Returns the distances of the k nearest neighbours. The kNearestNeighbours
@@ -629,7 +629,7 @@ public void addInstanceInfo(Instance ins) {
    * @param insts	the instances to use
    * @throws Exception	if setting fails
    */
-  public void setInstances(Instances insts) throws Exception {
+  public void setInstances(InstancesHeader insts) throws Exception {
     m_Instances = insts;
   }
   
@@ -638,7 +638,7 @@ public void setInstances(Instances insts) throws Exception {
    * 
    * @return		the current instances
    */
-  public Instances getInstances() {
+  public InstancesHeader getInstances() {
     return m_Instances;
   }
 
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NormalizableDistance.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NormalizableDistance.java
index 0c815a686..7800a8576 100644
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NormalizableDistance.java
+++ b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NormalizableDistance.java
@@ -23,7 +23,7 @@
 
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Represents the abstract ancestor for normalizable distance functions, like
@@ -48,7 +48,7 @@ public abstract class NormalizableDistance
   public static final int R_WIDTH = 2;
 
   /** the instances used internally. */
-  protected Instances m_Data = null;
+  protected InstancesHeader m_Data = null;
 
   /** True if normalization is turned off (default false).*/
   protected boolean m_DontNormalize = false;
@@ -78,7 +78,7 @@ public NormalizableDistance() {
    * 
    * @param data 	the instances the distance function should work on
    */
-  public NormalizableDistance(Instances data) {
+  public NormalizableDistance(InstancesHeader data) {
     setInstances(data);
   }
   
@@ -230,7 +230,7 @@ protected void initializeAttributeIndices() {
    * 
    * @param insts 	the instances to use
    */
-  public void setInstances(Instances insts) {
+  public void setInstances(InstancesHeader insts) {
     m_Data = insts;
     invalidate();
   }
@@ -240,7 +240,7 @@ public void setInstances(Instances insts) {
    * 
    * @return 		the current instances
    */
-  public Instances getInstances() {
+  public InstancesHeader getInstances() {
     return m_Data;
   }
 
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KDTreeNodeSplitter.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KDTreeNodeSplitter.java
index 431cfd972..f69760c9f 100644
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KDTreeNodeSplitter.java
+++ b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KDTreeNodeSplitter.java
@@ -25,7 +25,7 @@
 import java.util.Vector;
 import moa.classifiers.lazy.neighboursearch.EuclideanDistance;
 
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Class that splits up a KDTreeNode.
@@ -37,7 +37,7 @@ public abstract class KDTreeNodeSplitter
   implements Serializable {
   
   /** The instances that'll be used for tree construction. */
-  protected Instances m_Instances;
+  protected InstancesHeader m_Instances;
   
   /** The distance function used for building the tree. */
   protected EuclideanDistance m_EuclideanDistance;
@@ -78,7 +78,7 @@ public KDTreeNodeSplitter() {
    * @param e The EuclideanDistance object that is used
    * in tree contruction.
    */
-  public KDTreeNodeSplitter(int[] instList, Instances insts, EuclideanDistance e) { 
+  public KDTreeNodeSplitter(int[] instList, InstancesHeader insts, EuclideanDistance e) { 
     m_InstList = instList;
     m_Instances = insts;
     m_EuclideanDistance = e;
@@ -155,7 +155,7 @@ public abstract void splitNode(KDTreeNode node, int numNodesCreated,
    * to be) built. 
    * @param inst The training instances.
    */
-  public void setInstances(Instances inst) {
+  public void setInstances(InstancesHeader inst) {
     m_Instances = inst;
   }
   
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KMeansInpiredMethod.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KMeansInpiredMethod.java
index 6e19a86a0..6d834c9be 100644
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KMeansInpiredMethod.java
+++ b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KMeansInpiredMethod.java
@@ -21,7 +21,7 @@
 package moa.classifiers.lazy.neighboursearch.kdtrees;
 
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  <!-- globalinfo-start -->
@@ -227,7 +227,7 @@ public void splitNode(KDTreeNode node, int numNodesCreated,
    * that should be partitioned.
    * @return the index of the middle element
    */
-  protected static int partition(Instances insts, int[] index, int attidx, int l, int r) {
+  protected static int partition(InstancesHeader insts, int[] index, int attidx, int l, int r) {
     
     double pivot = insts.instance(index[(l + r) / 2]).value(attidx);
     int help;
@@ -270,7 +270,7 @@ protected static int partition(Instances insts, int[] index, int attidx, int l,
    * @param right The end index of the portion of the master index 
    * array that needs to be sorted.
    */
-  protected static void quickSort(Instances insts, int[] indices, int attidx, int left, int right) {
+  protected static void quickSort(InstancesHeader insts, int[] indices, int attidx, int left, int right) {
 
     if (left < right) {
       int middle = partition(insts, indices, attidx, left, right);
@@ -295,7 +295,7 @@ protected static void quickSort(Instances insts, int[] indices, int attidx, int
    * @throws Exception If the indices of the instances 
    * are not in sorted order.
    */
-  private static void checkSort(Instances insts, int[] indices, int attidx, 
+  private static void checkSort(InstancesHeader insts, int[] indices, int attidx, 
                                int start, int end) throws Exception {
     for(int i=start+1; i<=end; i++) {
       if( insts.instance(indices[i-1]).value(attidx) > 
diff --git a/moa/src/main/java/moa/classifiers/meta/ADACC.java b/moa/src/main/java/moa/classifiers/meta/ADACC.java
index 3c000f353..8aa324af8 100644
--- a/moa/src/main/java/moa/classifiers/meta/ADACC.java
+++ b/moa/src/main/java/moa/classifiers/meta/ADACC.java
@@ -23,7 +23,7 @@
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.classifiers.Classifier;
 import moa.core.Measurement;
 
@@ -74,7 +74,7 @@ public String getPurposeString() {
     /**
      * Last chunk of data of size (tau_size) to compute the stability index   
      */
-    protected Instances recentChunk;
+    protected InstancesHeader recentChunk;
     /**
      * Threshold values for the stability index and concept equivalence
      */
@@ -112,7 +112,7 @@ protected void initVariables(){
     public void trainOnInstanceImpl(Instance inst) {
 	
     	if (recentChunk == null)
-            recentChunk = new Instances(this.getModelContext());
+            recentChunk = new InstancesHeader(this.getModelContext());
     	
     	if (recentChunk.size() < this.tau_size)
     		recentChunk.add(inst);
diff --git a/moa/src/main/java/moa/classifiers/meta/AccuracyUpdatedEnsemble.java b/moa/src/main/java/moa/classifiers/meta/AccuracyUpdatedEnsemble.java
index c017c5fe7..f9764fa19 100644
--- a/moa/src/main/java/moa/classifiers/meta/AccuracyUpdatedEnsemble.java
+++ b/moa/src/main/java/moa/classifiers/meta/AccuracyUpdatedEnsemble.java
@@ -29,7 +29,7 @@
 import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * The revised version of the Accuracy Updated Ensemble as proposed by
@@ -94,7 +94,7 @@ public class AccuracyUpdatedEnsemble extends AbstractClassifier {
 	/**
 	 * Current chunk of instances.
 	 */
-	protected Instances currentChunk;
+	protected InstancesHeader currentChunk;
 
 	@Override
 	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
@@ -247,7 +247,7 @@ protected double computeMseR() {
 	 * @param chunk chunk of examples
 	 * @return the computed error.
 	 */
-	protected double computeMse(Classifier learner, Instances chunk) {
+	protected double computeMse(Classifier learner, InstancesHeader chunk) {
 		double mse_i = 0;
 
 		double f_ci;
@@ -348,7 +348,7 @@ private int getPoorestClassifierIndex() {
 	 */
 	private void initVariables() {
 		if (this.currentChunk == null) {
-			this.currentChunk = new Instances(this.getModelContext());
+			this.currentChunk = new InstancesHeader(this.getModelContext());
 		}
 
 		if (this.classDistributions == null) {
diff --git a/moa/src/main/java/moa/classifiers/meta/AccuracyWeightedEnsemble.java b/moa/src/main/java/moa/classifiers/meta/AccuracyWeightedEnsemble.java
index ddcd76d70..df7e6fea1 100644
--- a/moa/src/main/java/moa/classifiers/meta/AccuracyWeightedEnsemble.java
+++ b/moa/src/main/java/moa/classifiers/meta/AccuracyWeightedEnsemble.java
@@ -30,7 +30,7 @@
 import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.Utils;
 
 /**
@@ -119,7 +119,7 @@ public int compare(double[] o1, double[] o2) {
 
     protected Classifier candidateClassifier;
 
-    protected Instances currentChunk;
+    protected InstancesHeader currentChunk;
 
     @Override
     public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
@@ -168,7 +168,7 @@ public void trainOnInstanceImpl(Instance inst) {
      */
     private void initVariables() {
         if (this.currentChunk == null) {
-            this.currentChunk = new Instances(this.getModelContext());
+            this.currentChunk = new InstancesHeader(this.getModelContext());
         }
 
         if (this.classDistributions == null) {
@@ -243,18 +243,18 @@ protected void processChunk() {
      * @param useMseR Determines whether to use the MSEr threshold.
      * @return Candidate classifier weight.
      */
-    protected double computeCandidateWeight(Classifier candidate, Instances chunk, int numFolds) {
+    protected double computeCandidateWeight(Classifier candidate, InstancesHeader chunk, int numFolds) {
         double candidateWeight = 0.0;
         Random random = new Random(1);
-        Instances randData = new Instances(chunk);
+        InstancesHeader randData = new InstancesHeader(chunk);
         randData.randomize(random);
         if (randData.classAttribute().isNominal()) {
             randData.stratify(numFolds);
         }
 
         for (int n = 0; n < numFolds; n++) {
-            Instances train = randData.trainCV(numFolds, n, random);
-            Instances test = randData.testCV(numFolds, n);
+            InstancesHeader train = randData.trainCV(numFolds, n, random);
+            InstancesHeader test = randData.testCV(numFolds, n);
 
             Classifier learner = candidate.copy();
 
@@ -282,7 +282,7 @@ protected double computeCandidateWeight(Classifier candidate, Instances chunk, i
      * @param useMseR Determines whether to use the MSEr threshold.
      * @return The given classifier's weight.
      */
-    protected double computeWeight(Classifier learner, Instances chunk) {
+    protected double computeWeight(Classifier learner, InstancesHeader chunk) {
         double mse_i = 0;
         double mse_r = 0;
 
diff --git a/moa/src/main/java/moa/classifiers/meta/RandomRules.java b/moa/src/main/java/moa/classifiers/meta/RandomRules.java
index 694b8b37e..e170e1ef7 100644
--- a/moa/src/main/java/moa/classifiers/meta/RandomRules.java
+++ b/moa/src/main/java/moa/classifiers/meta/RandomRules.java
@@ -25,7 +25,7 @@
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import moa.classifiers.AbstractClassifier;
@@ -174,7 +174,7 @@ protected Instance transformInstance(Instance inst, int classifierIndex) {
 				//System.out.println("Number of attributes: "+this.numAttributes+ ","+inst.numAttributes()); //JD
 				System.out.println("Number of attributes: "+this.numAttributes+ ","+(inst.numAttributes()-1));
 				attributes.addElement(inst.classAttribute());
-				this.dataset[ensembleIndex] =  new InstancesHeader(new Instances(
+				this.dataset[ensembleIndex] =  new InstancesHeader(new InstancesHeader(
 						getCLICreationString(InstanceStream.class), attributes, 0));
 				this.dataset[ensembleIndex].setClassIndex(this.numAttributes);
 				this.ensemble[ensembleIndex].setModelContext(this.dataset[ensembleIndex]);
diff --git a/moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java b/moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java
index 5fe182cc2..eac49168d 100644
--- a/moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java
+++ b/moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java
@@ -33,7 +33,7 @@
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Include labels of previous instances into the training data
@@ -65,7 +65,7 @@ public String getPurposeString() {
     
     protected double[] oldLabels;
     
-    protected Instances header;
+    protected InstancesHeader header;
 
     public FlagOption labelDelayOption = new FlagOption("labelDelay", 'd',
         "Labels arrive with Delay. Use predictions instead of true Labels.");
@@ -97,7 +97,7 @@ public void addOldLabel(double newPrediction) {
         }
     }
 
-    public void initHeader(Instances dataset) {
+    public void initHeader(InstancesHeader dataset) {
         int numLabels = this.numOldLabelsOption.getValue();
         Attribute target = dataset.classAttribute();
 
@@ -124,7 +124,7 @@ public void initHeader(Instances dataset) {
                 attrs.add(newAttribute);
             }
         }
-        this.header = new Instances("extended_" + dataset.getRelationName(), attrs, 0);
+        this.header = new InstancesHeader("extended_" + dataset.getRelationName(), attrs, 0);
         this.header.setClassIndex(numLabels + dataset.classIndex());
     }
 
diff --git a/moa/src/main/java/moa/classifiers/meta/WEKAClassifier.java b/moa/src/main/java/moa/classifiers/meta/WEKAClassifier.java
index 13bb3e338..d9ac321c8 100644
--- a/moa/src/main/java/moa/classifiers/meta/WEKAClassifier.java
+++ b/moa/src/main/java/moa/classifiers/meta/WEKAClassifier.java
@@ -27,7 +27,7 @@
 import weka.classifiers.Classifier;
 import weka.classifiers.UpdateableClassifier;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
 
 /**
diff --git a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
index 4c78071f9..070665e55 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
@@ -7,6 +7,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
diff --git a/moa/src/main/java/moa/classifiers/multilabel/MEKAClassifier.java b/moa/src/main/java/moa/classifiers/multilabel/MEKAClassifier.java
index 7691b603f..96e8f09ac 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/MEKAClassifier.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/MEKAClassifier.java
@@ -30,10 +30,10 @@
 import weka.classifiers.Classifier;
 import weka.classifiers.UpdateableClassifier;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
 
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
@@ -90,7 +90,7 @@ public void resetLearningImpl() {
     }
 
 	@Override
-	public void trainOnInstanceImpl(MultiLabelInstance samoaInstance) {
+	public void trainOnInstanceImpl(StructuredInstance samoaInstance) {
 
 		// Convert Samoa instance to Weka instance (as used in Meka)
 		L = samoaInstance.numberOutputTargets();
@@ -146,7 +146,7 @@ public double[] getVotesForInstance(Instance samoaInstance) {
 	}
 
 	@Override
-	public Prediction getPredictionForInstance(MultiLabelInstance samoaInstance) {
+	public Prediction getPredictionForInstance(StructuredInstance samoaInstance) {
 
 		MultiLabelPrediction prediction = new MultiLabelPrediction(L);
 
diff --git a/moa/src/main/java/moa/classifiers/multilabel/MajorityLabelset.java b/moa/src/main/java/moa/classifiers/multilabel/MajorityLabelset.java
index c7eded5ed..135f8f88e 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/MajorityLabelset.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/MajorityLabelset.java
@@ -60,7 +60,7 @@ public void resetLearningImpl() {
     }
 
     @Override
-    public void trainOnInstanceImpl(MultiLabelInstance x) {
+    public void trainOnInstanceImpl(StructuredInstance x) {
 		int L = x.numberOutputTargets();
 
         MultiLabelPrediction y = new MultiLabelPrediction(L);
@@ -80,7 +80,7 @@ public void trainOnInstanceImpl(MultiLabelInstance x) {
     }
 
     @Override
-    public Prediction getPredictionForInstance(MultiLabelInstance x){
+    public Prediction getPredictionForInstance(StructuredInstance x){
 
 		if (this.majorityLabelset == null)  {
 			int L = x.numberOutputTargets();
diff --git a/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java b/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java
index b6c793eb9..1801eba28 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java
@@ -27,7 +27,6 @@
 import moa.core.StringUtils;
 import moa.core.utils.Converter;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
@@ -181,11 +180,11 @@ protected void deactivateLearningNode(ActiveLearningNode toDeactivate,
 
 	@Override
 	public Prediction getPredictionForInstance(Example<Instance> example) {
-		return getPredictionForInstance((MultiLabelInstance)example.getData());
+		return getPredictionForInstance((StructuredInstance)example.getData());
 	}
 
 	@Override
-	public Prediction getPredictionForInstance(MultiLabelInstance inst){
+	public Prediction getPredictionForInstance(StructuredInstance inst){
 
 		if (this.treeRoot != null) {
 			FoundNode foundNode = this.treeRoot.filterInstanceToLeaf(inst, null, -1);
@@ -209,12 +208,12 @@ public void trainOnInstance(Instance inst) {
 		boolean isTraining = (inst.weight() > 0.0);
 		if (isTraining) {
 			this.trainingWeightSeenByModel += inst.weight();
-			trainOnInstanceImpl((MultiLabelInstance) inst);
+			trainOnInstanceImpl((StructuredInstance) inst);
 		}
 	}
 
 	@Override
-	public void trainOnInstanceImpl(MultiLabelInstance instance) {
+	public void trainOnInstanceImpl(StructuredInstance instance) {
 		trainOnInstanceImpl((Instance) instance);
 	}
         
diff --git a/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagAdwinML.java b/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagAdwinML.java
index d07673f02..a94b89b6f 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagAdwinML.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagAdwinML.java
@@ -25,7 +25,7 @@
 import moa.core.InstanceExample;
 import moa.core.MiscUtils;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 import moa.classifiers.MultiLabelLearner;
@@ -84,7 +84,7 @@ public void trainOnInstanceImpl(Instance inst) {
 	}
 
 	@Override
-	public void trainOnInstanceImpl(MultiLabelInstance instance) {
+	public void trainOnInstanceImpl(StructuredInstance instance) {
 		trainOnInstanceImpl((Instance) instance);
 	}
 
@@ -101,7 +101,7 @@ public double[] getVotesForInstance(Instance inst) {
 	}
 
 	@Override
-	public Prediction getPredictionForInstance(MultiLabelInstance instance) {
+	public Prediction getPredictionForInstance(StructuredInstance instance) {
 		return getPredictionForInstance((new InstanceExample(instance)));
 	}
 
diff --git a/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagML.java b/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagML.java
index 66c9c470a..20acefa4e 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagML.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagML.java
@@ -22,7 +22,7 @@
 import moa.classifiers.meta.OzaBag;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 import moa.classifiers.MultiLabelLearner;
@@ -43,7 +43,7 @@ public class OzaBagML extends OzaBag implements MultiLabelLearner, MultiTargetRe
 
 	//Training
 	@Override
-	public void trainOnInstanceImpl(MultiLabelInstance inst) {
+	public void trainOnInstanceImpl(StructuredInstance inst) {
 		trainOnInstanceImpl((Instance) inst);
 	}
 
@@ -119,7 +119,7 @@ public static double[] compileVotes(Classifier h[], Instance inst) {
 	}
 
 	 @Override
-    public Prediction getPredictionForInstance(MultiLabelInstance instance) {
+    public Prediction getPredictionForInstance(StructuredInstance instance) {
         return getPredictionForInstance((new InstanceExample(instance)));
     }
 
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
index 853405dd8..b7d54bb4a 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
@@ -801,6 +801,11 @@ public void resetLearningImpl() {
 
 		sumOfAttrValues = new DoubleVector();
 		sumOfAttrSquares = new DoubleVector();
+		
+	}
+	
+	@Override
+	public void modelContextSet() {
 		loadWeights();
 	}
 
diff --git a/moa/src/main/java/moa/classifiers/multitarget/BasicMultiTargetRegressor.java b/moa/src/main/java/moa/classifiers/multitarget/BasicMultiTargetRegressor.java
index 93c1c94a1..edad24332 100644
--- a/moa/src/main/java/moa/classifiers/multitarget/BasicMultiTargetRegressor.java
+++ b/moa/src/main/java/moa/classifiers/multitarget/BasicMultiTargetRegressor.java
@@ -14,7 +14,7 @@
 
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
@@ -77,7 +77,7 @@ protected Instance transformInstance(StructuredInstance inst, int outputIndex) {
 			}
 			//System.out.println("Number of attributes: "+this.numAttributes+ ","+inst.numAttributes());
 			attributes.addElement(inst.outputAttribute(outputIndex));
-			this.header[outputIndex] =  new InstancesHeader(new Instances(
+			this.header[outputIndex] =  new InstancesHeader(new InstancesHeader(
 					getCLICreationString(InstanceStream.class), attributes, 0));
 			this.header[outputIndex].setClassIndex(attributes.size()-1);
 			this.ensemble[outputIndex].setModelContext(this.header[outputIndex]);
diff --git a/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java
index fb5505ef7..7e5febe56 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java
@@ -2,6 +2,7 @@
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.AbstractMOAObject;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java
index 8387610c0..a6b313c12 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java
@@ -2,6 +2,7 @@
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.AbstractMOAObject;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java
index df2405a5a..93d962149 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java
@@ -21,6 +21,7 @@
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import moa.classifiers.core.conditionaltests.NominalAttributeBinaryTest;
 import moa.classifiers.rules.core.Predicate;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java
index 37650e7ca..ff4c0c350 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java
@@ -21,6 +21,7 @@
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import moa.classifiers.core.conditionaltests.InstanceConditionalBinaryTest;
 import moa.classifiers.rules.core.Predicate;
diff --git a/moa/src/main/java/moa/classifiers/rules/meta/RandomAMRulesOld.java b/moa/src/main/java/moa/classifiers/rules/meta/RandomAMRulesOld.java
index b860ad10e..8828c1d84 100644
--- a/moa/src/main/java/moa/classifiers/rules/meta/RandomAMRulesOld.java
+++ b/moa/src/main/java/moa/classifiers/rules/meta/RandomAMRulesOld.java
@@ -29,7 +29,6 @@
 import com.github.javacliparser.MultiChoiceOption;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import moa.classifiers.AbstractClassifier;
diff --git a/moa/src/main/java/moa/clusterers/AbstractClusterer.java b/moa/src/main/java/moa/clusterers/AbstractClusterer.java
index db3a2a8a4..a8f23f48e 100644
--- a/moa/src/main/java/moa/clusterers/AbstractClusterer.java
+++ b/moa/src/main/java/moa/clusterers/AbstractClusterer.java
@@ -34,7 +34,7 @@
 import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public abstract class AbstractClusterer extends AbstractOptionHandler
 		implements Clusterer {
@@ -286,7 +286,7 @@ protected static int modelAttIndexToInstanceAttIndex(int index,
 	}
 
 	protected static int modelAttIndexToInstanceAttIndex(int index,
-			Instances insts) {
+			InstancesHeader insts) {
 		return insts.classIndex() > index ? index : index + 1;
 	}
 
diff --git a/moa/src/main/java/moa/clusterers/Clusterer.java b/moa/src/main/java/moa/clusterers/Clusterer.java
index 36bdbf79c..b018b421f 100644
--- a/moa/src/main/java/moa/clusterers/Clusterer.java
+++ b/moa/src/main/java/moa/clusterers/Clusterer.java
@@ -21,11 +21,11 @@
 
 import moa.MOAObject;
 import moa.cluster.Clustering;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.Measurement;
 import moa.gui.AWTRenderable;
 import moa.options.OptionHandler;
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public interface Clusterer extends MOAObject, OptionHandler, AWTRenderable {
 
diff --git a/moa/src/main/java/moa/clusterers/CobWeb.java b/moa/src/main/java/moa/clusterers/CobWeb.java
index c6c451098..03e34a5f9 100644
--- a/moa/src/main/java/moa/clusterers/CobWeb.java
+++ b/moa/src/main/java/moa/clusterers/CobWeb.java
@@ -30,7 +30,7 @@
 import com.github.javacliparser.IntOption;
 import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import weka.core.AttributeStats;
 import weka.experiment.Stats;
 import weka.filters.unsupervised.attribute.Add;
@@ -73,7 +73,7 @@ private class CNode implements Serializable {
         /**
          * Instances at this node
          */
-        protected Instances m_clusterInstances = null;
+        protected InstancesHeader m_clusterInstances = null;
         /**
          * Children of this node
          */
@@ -107,7 +107,7 @@ public CNode(int numAttributes, Instance leafInstance) {
             if (m_clusterInstances == null) {
 		//System.out.println(leafInstance.numAttributes()+"-"+leafInstance.value(0)+"-"+leafInstance.value(1)+"-"+leafInstance.value(2));
 		//System.out.println(leafInstance.numAttributes()+"-"+leafInstance.attribute(0).type()+"-"+leafInstance.attribute(1).type()+"-"+leafInstance.attribute(2).type());
-                m_clusterInstances = new Instances(leafInstance.dataset(), 1);
+                m_clusterInstances = new InstancesHeader(leafInstance.dataset(), 1);
             }
             m_clusterInstances.add(leafInstance);
             updateStats(leafInstance, false);
@@ -122,7 +122,7 @@ protected void addInstance(Instance newInstance) {
             // Add the instance to this cluster
 
             if (m_clusterInstances == null) {
-                m_clusterInstances = new Instances(newInstance.dataset(), 1);
+                m_clusterInstances = new InstancesHeader(newInstance.dataset(), 1);
                 m_clusterInstances.add(newInstance);
                 updateStats(newInstance, false);
                 return;
@@ -196,7 +196,7 @@ private double cuScoreForBestTwoMerged(CNode merged,
             double mergedCU = -Double.MAX_VALUE;
             // consider merging the best and second
             // best.
-            merged.m_clusterInstances = new Instances(m_clusterInstances, 1);
+            merged.m_clusterInstances = new InstancesHeader(m_clusterInstances, 1);
 
             merged.addChildNode(a);
             merged.addChildNode(b);
@@ -620,11 +620,11 @@ protected String dumpData() { //throws Exception {
 
             // construct instances string with cluster numbers attached
             CNode tempNode = new CNode(m_numAttributes);
-            tempNode.m_clusterInstances = new Instances(m_clusterInstances, 1);
+            tempNode.m_clusterInstances = new InstancesHeader(m_clusterInstances, 1);
             for (int i = 0; i < m_children.size(); i++) {
                 tempNode.addChildNode((CNode) m_children.elementAt(i));
             }
-            Instances tempInst = tempNode.m_clusterInstances;
+            InstancesHeader tempInst = tempNode.m_clusterInstances;
             tempNode = null;
 
             Add af = new Add();
diff --git a/moa/src/main/java/moa/clusterers/WekaClusteringAlgorithm.java b/moa/src/main/java/moa/clusterers/WekaClusteringAlgorithm.java
index 774e675dc..978290119 100644
--- a/moa/src/main/java/moa/clusterers/WekaClusteringAlgorithm.java
+++ b/moa/src/main/java/moa/clusterers/WekaClusteringAlgorithm.java
@@ -33,7 +33,7 @@
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
 
 import weka.core.Utils;
@@ -52,7 +52,7 @@ public class WekaClusteringAlgorithm extends AbstractClusterer {
     
     private Class<?>[] clustererClasses;
     
-    private Instances instances;
+    private InstancesHeader instances;
     
     private weka.clusterers.AbstractClusterer clusterer;
     
@@ -136,7 +136,7 @@ public Clustering getClusteringResult() {
             
             clusterer.buildClusterer(wekaInstances);
             int numClusters = clusterer.numberOfClusters();
-            Instances dataset = getDataset(instances.numAttributes(), numClusters);
+            InstancesHeader dataset = getDataset(instances.numAttributes(), numClusters);
             List<Instance> newInstances = new ArrayList<Instance>() ; //Instances(dataset);
 
             for (int i = 0; i < wekaInstances.numInstances(); i++) {
@@ -159,7 +159,7 @@ public Clustering getClusteringResult() {
         return clustering;
     }
 
-    public Instances getDataset(int numdim, int numclass) {
+    public InstancesHeader getDataset(int numdim, int numclass) {
         FastVector attributes = new FastVector();
         for (int i = 0; i < numdim; i++) {
             attributes.addElement(new Attribute("att" + (i + 1)));
@@ -173,7 +173,7 @@ public Instances getDataset(int numdim, int numclass) {
             attributes.addElement(new Attribute("class", classLabels));
         }
 
-        Instances myDataset = new Instances("horizion", attributes, 0);
+        InstancesHeader myDataset = new InstancesHeader("horizion", attributes, 0);
         if (numclass > 0) {
             myDataset.setClassIndex(myDataset.numAttributes() - 1);
         }
diff --git a/moa/src/main/java/moa/core/MultilabelInstancesHeader.java b/moa/src/main/java/moa/core/MultilabelInstancesHeader.java
index cc7e57c59..b8dc3b3c2 100644
--- a/moa/src/main/java/moa/core/MultilabelInstancesHeader.java
+++ b/moa/src/main/java/moa/core/MultilabelInstancesHeader.java
@@ -19,7 +19,7 @@
  */
 package moa.core;
 
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
@@ -33,7 +33,7 @@ public class MultilabelInstancesHeader extends InstancesHeader {
 
     private int m_NumLabels = -1;
 
-    public MultilabelInstancesHeader(Instances i, int numLabels) {
+    public MultilabelInstancesHeader(InstancesHeader i, int numLabels) {
         super(i);
         m_NumLabels = numLabels;
     }
diff --git a/moa/src/main/java/moa/core/SizeOf.java b/moa/src/main/java/moa/core/SizeOf.java
index 6e7b4e168..ff3def4c8 100644
--- a/moa/src/main/java/moa/core/SizeOf.java
+++ b/moa/src/main/java/moa/core/SizeOf.java
@@ -34,7 +34,7 @@ public class SizeOf {
     protected static Boolean m_Present;
 
     /**
-     * Checks whteher the agent is present.
+     * Checks whether the agent is present.
      *
      * @return true if the agent is present, false otherwise
      */
diff --git a/moa/src/main/java/moa/core/utils/AttributeDefinitionUtil.java b/moa/src/main/java/moa/core/utils/AttributeDefinitionUtil.java
new file mode 100644
index 000000000..a47df6c0d
--- /dev/null
+++ b/moa/src/main/java/moa/core/utils/AttributeDefinitionUtil.java
@@ -0,0 +1,121 @@
+package moa.core.utils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+public class AttributeDefinitionUtil {
+	//public static String definitionTotal = "(!?-?[0-9]+?)|(!?[0-9]+?-[0-9]+?)|(!?-?[0-9]+?~-?[0-9]+?)";
+	
+	public static String nonIgnoredDefinition = "0";
+	
+	public static String definitionSingle = "-?[0-9]+?";
+	public static String definitionPositiveRange = "-?[0-9]+?-[0-9]+?";
+	public static String definitionArbitraryRange = "-?[0-9]+?~-?[0-9]+?";
+	
+	public static String getDefinitionTotal() {
+		return "(!?" + definitionSingle + ")|" + "(!?" + definitionPositiveRange + ")|" + "(!?" + definitionArbitraryRange + ")";
+	}
+	
+	public static List<Integer> parseDefinition(String definition, int numAttributes, List<Integer> ignoredAttributes) {
+		List<Integer> ret = new ArrayList<Integer>();
+		if (Pattern.matches(definitionArbitraryRange, definition)) {
+			String[] split = definition.split("~");
+			int start = Integer.valueOf(split[0]);
+			int end = Integer.valueOf(split[1]);
+			if (start < 0) {
+				start = numAttributes + start + 1; // + 1 for so that -1 maps to last attribute 
+			}
+			if (end < 0) {
+				end = numAttributes + end + 1; // + 1 for so that -1 maps to last attribute 
+			}
+			start = Math.max(0, start);
+			end = Math.max(0, end);
+			if (start == end) {
+				System.err.println("[Warning] Strage attribute range definition '" + definition + "', start equals end");
+			}
+			Integer i = start;
+			if (start <= end)
+				while(i <= end) {
+					if (!ignoredAttributes.contains(i - 1)) ret.add(i - 1);
+					i++;
+				}
+			else 
+				System.err.println("[Warning] Strage attribute range definition '" + definition + "', end smaller of start, ignoring...");
+		} else if (Pattern.matches(definitionPositiveRange, definition)) {
+			String[] split = definition.split("-");
+			int start = Integer.valueOf(split[0]);
+			int end = Integer.valueOf(split[1]);
+			if (start == 0 || end == 0) {
+				throw new UnsupportedOperationException("Attribute definition range error - start or end equals 0: " + definition);
+			}
+			if (start == end) {
+				System.err.println("[Warning] Strage attribute range definition '" + definition + "', start equals end");
+			}
+			Integer i = start;
+			if (start <= end)
+				while(i <= end) {
+					if (!ignoredAttributes.contains(i - 1)) ret.add(i - 1);
+					i++;
+				}
+			else 
+				System.err.println("[Warning] Strage attribute range definition '" + definition + "', end smaller of start, ignoring...");
+		} else if (Pattern.matches(definitionSingle, definition)) {
+			int index = Integer.valueOf(definition);
+			if (index == 0) {
+	    		// Add all non-ignored attributes
+				for (Integer i = 0; i < numAttributes; i++)
+	   				if (!ignoredAttributes.contains(i)) ret.add(i);
+			} else {
+				if (index < 0){
+					index = numAttributes + index + 1;
+					if (index <= 0) {
+						throw new UnsupportedOperationException("Attribute definition range error - negative index overflows the number of attributes: " + definition);
+					}
+				}
+				if (!ignoredAttributes.contains(index - 1)) ret.add(index - 1);
+			}
+		}
+		return ret;
+	}
+	
+    public static List<Integer> parseAttributeDefinition(String attributeDefinition, int numAttributes, List<Integer> ignoredAttributes) {
+    	List<Integer> ret = new ArrayList<Integer>();
+    	if (ignoredAttributes == null) ignoredAttributes = new ArrayList<Integer>();
+    	if (attributeDefinition != "") {
+	    	String[] definitions = attributeDefinition.split("[,;]");
+	    	Pattern definitionsPattern = Pattern.compile(getDefinitionTotal());
+	    	for (int i = 0; i < definitions.length; i++) {
+	    		String definition = definitions[i];
+	    		boolean negative = false;
+	    		if (definition.isEmpty()) {
+	    			continue;
+	    		}
+	    		if (!definitionsPattern.matcher(definition).matches()) throw new UnsupportedOperationException("The attribute definition '" + definition + "' is not recognised.");
+	
+	    		if (definition.startsWith("!")) {
+	    			definition = definition.substring(1);
+	    			negative = true;
+	    		}
+	
+	    		List<Integer> candidates = parseDefinition(definition, numAttributes, ignoredAttributes);
+	    		if (negative) {
+	    			for (Integer j : candidates) {
+	    				if (ret.contains(j)) ret.remove(j);
+	    			}
+	    		} else {
+	    			for (Integer j : candidates) {
+	    				if (!ret.contains(j)) ret.add(j);
+	    			}
+	    		}
+	    	}
+    	} else {
+    		// Add all non-ignored attributes (this is the default behavior for input attributes)
+ 			for (Integer i = 0; i < numAttributes; i++)
+   				if (!ignoredAttributes.contains(i)) ret.add(i);
+    	}
+    	return ret;
+    }
+	
+	
+}
diff --git a/moa/src/main/java/moa/core/utils/Converter.java b/moa/src/main/java/moa/core/utils/Converter.java
index 3e3110557..a3f976c38 100755
--- a/moa/src/main/java/moa/core/utils/Converter.java
+++ b/moa/src/main/java/moa/core/utils/Converter.java
@@ -23,7 +23,7 @@
 import java.util.List;
 import moa.AbstractMOAObject;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Converter. This class can be used to convert a multi-label instance into a
@@ -34,7 +34,7 @@
  */
 public class Converter extends AbstractMOAObject {
 
-    protected Instances m_InstancesTemplate = null;
+    protected InstancesHeader m_InstancesTemplate = null;
 
     protected int m_L = -1;
 
@@ -49,8 +49,8 @@ public Converter(int n) {
         m_L = n;
     }
 
-    public Instances createTemplate(Instances i) {
-        this.m_InstancesTemplate = new Instances(i, 0, 0);
+    public InstancesHeader createTemplate(InstancesHeader i) {
+        this.m_InstancesTemplate = new InstancesHeader(i, 0, 0);
         return this.m_InstancesTemplate;
     }
 
diff --git a/moa/src/main/java/moa/evaluation/BasicMultiLabelPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/BasicMultiLabelPerformanceEvaluator.java
index 6f677c93c..33e6b18d1 100644
--- a/moa/src/main/java/moa/evaluation/BasicMultiLabelPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/BasicMultiLabelPerformanceEvaluator.java
@@ -24,7 +24,7 @@
 import moa.core.Measurement;
 
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 /**
@@ -57,7 +57,7 @@ public void reset() {
     @Override
 	public void addResult(Example<Instance> example, Prediction y) {
 
-		MultiLabelInstance x = (MultiLabelInstance) example.getData();
+		StructuredInstance x = (StructuredInstance) example.getData();
 
 		if (L == 0) {
 			L = x.numberOutputTargets();
diff --git a/moa/src/main/java/moa/gui/visualization/RunOutlierVisualizer.java b/moa/src/main/java/moa/gui/visualization/RunOutlierVisualizer.java
index 380b31204..ce611e1ba 100644
--- a/moa/src/main/java/moa/gui/visualization/RunOutlierVisualizer.java
+++ b/moa/src/main/java/moa/gui/visualization/RunOutlierVisualizer.java
@@ -59,7 +59,7 @@
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public class RunOutlierVisualizer implements Runnable, ActionListener, ClusterEventListener{	
     /** the pause interval, being read from the gui at startup */
@@ -646,7 +646,7 @@ public void weka() {
         for(int i = 0; i < dims; i++)
                 attributes.addElement( new Attribute("att" + i) );
 
-        Instances instances = new Instances("trainset",attributes,0);
+        InstancesHeader instances = new InstancesHeader("trainset",attributes,0);
 
         for(int c = 0; c < wekaClustering.size(); c++){
             Cluster cluster = wekaClustering.get(c);
diff --git a/moa/src/main/java/moa/gui/visualization/RunVisualizer.java b/moa/src/main/java/moa/gui/visualization/RunVisualizer.java
index e95cb7551..1e08cab18 100644
--- a/moa/src/main/java/moa/gui/visualization/RunVisualizer.java
+++ b/moa/src/main/java/moa/gui/visualization/RunVisualizer.java
@@ -52,7 +52,7 @@
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import moa.core.FastVector;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public class RunVisualizer implements Runnable, ActionListener, ClusterEventListener{
 
@@ -606,7 +606,7 @@ public void weka() {
         for(int i = 0; i < dims; i++)
                 attributes.addElement( new Attribute("att" + i) );
 
-        Instances instances = new Instances("trainset",attributes,0);
+        InstancesHeader instances = new InstancesHeader("trainset",attributes,0);
 
         for(int c = 0; c < wekaClustering.size(); c++){
             Cluster cluster = wekaClustering.get(c);
diff --git a/moa/src/main/java/moa/gui/visualization/WekaExplorer.java b/moa/src/main/java/moa/gui/visualization/WekaExplorer.java
index 7825f5433..cfc1d5254 100644
--- a/moa/src/main/java/moa/gui/visualization/WekaExplorer.java
+++ b/moa/src/main/java/moa/gui/visualization/WekaExplorer.java
@@ -36,7 +36,7 @@
 import java.awt.event.WindowAdapter;
 import java.awt.event.WindowEvent;
 import javax.swing.JFrame;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
 
 
@@ -46,7 +46,7 @@ public class WekaExplorer {
     /** for monitoring the Memory consumption */
     private static Memory m_Memory = new Memory(true);
 
-    public WekaExplorer(Instances instances) {
+    public WekaExplorer(InstancesHeader instances) {
         //weka.core.logging.Logger.log(weka.core.logging.Logger.Level.INFO, "Logging started");
         try {
             javax.swing.UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
diff --git a/moa/src/main/java/moa/streams/ArffFileStream.java b/moa/src/main/java/moa/streams/ArffFileStream.java
index 408c6d2da..5d0d10ef9 100644
--- a/moa/src/main/java/moa/streams/ArffFileStream.java
+++ b/moa/src/main/java/moa/streams/ArffFileStream.java
@@ -21,7 +21,8 @@
 
 import com.github.javacliparser.FileOption;
 import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.github.javacliparser.StringOption;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import java.io.BufferedReader;
 import java.io.FileInputStream;
@@ -41,7 +42,7 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class ArffFileStream extends AbstractOptionHandler implements InstanceStream {
+public class ArffFileStream extends AbstractOptionHandler implements InstanceStream, MultiTargetInstanceStream {
 
     @Override
     public String getPurposeString() {
@@ -53,13 +54,26 @@ public String getPurposeString() {
     public FileOption arffFileOption = new FileOption("arffFile", 'f',
             "ARFF file to load.", null, "arff", false);
 
-    public IntOption classIndexOption = new IntOption(
-            "classIndex",
-            'c',
-            "Class index of data. 0 for none or -1 for last attribute in file.",
-            -1, -1, Integer.MAX_VALUE);
+//    public IntOption classIndexOption = new IntOption(
+//            "classIndex",
+//            'c',
+//            "Class index of data. 0 for none or -1 for last attribute in file.",
+//            -1, -1, Integer.MAX_VALUE);
+
+    public StringOption outputIndexesOption = new StringOption(
+    		"outputIndexes",
+    		'c',
+    		"Indices of output (class) attributes. Can be provided in a comma or semicolon separated list of single values or ranges.",
+    		"-1");
+
+    public StringOption inputIndexesOption = new StringOption(
+    		"inputIndexes",
+    		'i',
+    		"Indices of input (class) attributes. Can be provided in a comma or semicolon separated list of single values or ranges. Leave blank for all non-output attributes.",
+    		"");
 
-    protected Instances instances;
+    
+    protected InstancesHeader instances;
 
     protected Reader fileReader;
 
@@ -76,7 +90,22 @@ public ArffFileStream() {
 
     public ArffFileStream(String arffFileName, int classIndex) {
         this.arffFileOption.setValue(arffFileName);
-        this.classIndexOption.setValue(classIndex);
+        this.outputIndexesOption.setValue(Integer.toString(classIndex));
+        this.inputIndexesOption.setValue("");
+        restart();
+    }
+
+    
+    public ArffFileStream(String arffFileName, String outputIndexes) {
+        this.arffFileOption.setValue(arffFileName);
+        this.outputIndexesOption.setValue(outputIndexes);
+        restart();
+    }
+    
+    public ArffFileStream(String arffFileName, String outputIndexes, String inputIndexes) {
+        this.arffFileOption.setValue(arffFileName);
+        this.outputIndexesOption.setValue(outputIndexes);
+        this.inputIndexesOption.setValue(inputIndexes);
         restart();
     }
 
@@ -126,13 +155,7 @@ public void restart() {
             this.fileProgressMonitor = new InputStreamProgressMonitor(
                     fileStream);
             this.fileReader = new BufferedReader(new InputStreamReader(this.fileProgressMonitor));
-            int classIndex = this.classIndexOption.getValue();
-            this.instances = new Instances(this.fileReader, 1, classIndex);
-            if (classIndex < 0) {
-		this.instances.setClassIndex(this.instances.numAttributes() - 1);
-            } else if (this.classIndexOption.getValue() > 0) {
-                this.instances.setClassIndex(this.classIndexOption.getValue() - 1);
-				}
+            this.instances = new InstancesHeader(this.fileReader, 1, this.outputIndexesOption.getValue(), this.inputIndexesOption.getValue());
             this.numInstancesRead = 0;
             this.lastInstanceRead = null;
             this.hitEndOfFile = !readNextInstanceFromFile();
diff --git a/moa/src/main/java/moa/streams/CachedInstancesStream.java b/moa/src/main/java/moa/streams/CachedInstancesStream.java
index 4faa60832..bb618fac8 100644
--- a/moa/src/main/java/moa/streams/CachedInstancesStream.java
+++ b/moa/src/main/java/moa/streams/CachedInstancesStream.java
@@ -23,7 +23,7 @@
 import moa.core.InstanceExample;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Stream generator for representing a stream that is cached in memory.
@@ -38,11 +38,11 @@ public class CachedInstancesStream extends AbstractMOAObject implements
 
 	private static final long serialVersionUID = 1L;
 
-	protected Instances toStream;
+	protected InstancesHeader toStream;
 
 	protected int streamPos;
 
-	public CachedInstancesStream(Instances toStream) {
+	public CachedInstancesStream(InstancesHeader toStream) {
 		this.toStream = toStream;
 	}
 
diff --git a/moa/src/main/java/moa/streams/ConceptDriftRealStream.java b/moa/src/main/java/moa/streams/ConceptDriftRealStream.java
index fd7b8c313..46c30398a 100644
--- a/moa/src/main/java/moa/streams/ConceptDriftRealStream.java
+++ b/moa/src/main/java/moa/streams/ConceptDriftRealStream.java
@@ -23,13 +23,16 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Random;
 import moa.core.InstanceExample;
 
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
+import moa.core.utils.AttributeDefinitionUtil;
 import moa.options.AbstractOptionHandler;
 import moa.options.ClassOption;
 import com.github.javacliparser.FloatOption;
@@ -111,8 +114,8 @@ public void prepareForUseImpl(TaskMonitor monitor,
         }
 
         // generate header
-        Instances first = this.inputStream.getHeader();
-        Instances second = this.driftStream.getHeader();
+        InstancesHeader first = this.inputStream.getHeader();
+        InstancesHeader second = this.driftStream.getHeader();
         FastVector newAttributes = new FastVector();
         for (int i = 0; i < first.numAttributes() - 1; i++) {
             newAttributes.addElement(first.attribute(i));
@@ -130,9 +133,11 @@ public void prepareForUseImpl(TaskMonitor monitor,
         }
         newAttributes.addElement(classLabels);
 
-        this.streamHeader = new InstancesHeader(new Instances(
+        this.streamHeader = new InstancesHeader(new InstancesHeader(
                 getCLICreationString(InstanceStream.class), newAttributes, 0));
         this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
+        // TODO adapt for multi-target streaming
+        this.streamHeader.setInputIndexes();
         restart();
 
     }
diff --git a/moa/src/main/java/moa/streams/ConceptDriftStream.java b/moa/src/main/java/moa/streams/ConceptDriftStream.java
index c0775b447..19ff13c49 100644
--- a/moa/src/main/java/moa/streams/ConceptDriftStream.java
+++ b/moa/src/main/java/moa/streams/ConceptDriftStream.java
@@ -22,8 +22,6 @@
 import java.util.Random;
 import moa.core.Example;
 import moa.core.InstanceExample;
-
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.options.ClassOption;
@@ -31,6 +29,7 @@
 import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Stream generator that adds concept drift to examples in a stream.
diff --git a/moa/src/main/java/moa/streams/ExampleStream.java b/moa/src/main/java/moa/streams/ExampleStream.java
index f5e9ec500..20877597a 100644
--- a/moa/src/main/java/moa/streams/ExampleStream.java
+++ b/moa/src/main/java/moa/streams/ExampleStream.java
@@ -21,8 +21,9 @@
 
 import moa.MOAObject;
 import moa.core.Example;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Interface representing a data stream of examples. 
diff --git a/moa/src/main/java/moa/streams/FilteredStream.java b/moa/src/main/java/moa/streams/FilteredStream.java
index 1eb0803a5..6cf072f88 100644
--- a/moa/src/main/java/moa/streams/FilteredStream.java
+++ b/moa/src/main/java/moa/streams/FilteredStream.java
@@ -19,8 +19,9 @@
  */
 package moa.streams;
 
-import moa.core.Example;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
+
+import moa.core.Example;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.options.ClassOption;
diff --git a/moa/src/main/java/moa/streams/MultiFilteredStream.java b/moa/src/main/java/moa/streams/MultiFilteredStream.java
index 6e35c4994..befa684b6 100644
--- a/moa/src/main/java/moa/streams/MultiFilteredStream.java
+++ b/moa/src/main/java/moa/streams/MultiFilteredStream.java
@@ -21,7 +21,6 @@
 
 import moa.core.Example;
 import moa.core.InstanceExample;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.options.ClassOption;
@@ -31,6 +30,7 @@
 import moa.streams.filters.StreamFilter;
 import moa.tasks.TaskMonitor;
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Class for representing a stream that is filtered.
diff --git a/moa/src/main/java/moa/streams/MultiLabelFilteredStream.java b/moa/src/main/java/moa/streams/MultiLabelFilteredStream.java
index d63b0e451..f7c8bdf79 100644
--- a/moa/src/main/java/moa/streams/MultiLabelFilteredStream.java
+++ b/moa/src/main/java/moa/streams/MultiLabelFilteredStream.java
@@ -19,6 +19,8 @@
  */
 package moa.streams;
 
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.core.Example;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
@@ -29,8 +31,6 @@
 import moa.streams.filters.StreamFilter;
 import moa.tasks.TaskMonitor;
 
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
 /**
  * Class for representing a stream that is filtered.
  *
diff --git a/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java b/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java
index 4eb9dbff0..80e2ae84f 100644
--- a/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java
+++ b/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java
@@ -20,7 +20,7 @@
 package moa.streams;
 
 import com.github.javacliparser.FileOption;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import java.io.BufferedReader;
 import java.io.FileInputStream;
@@ -41,149 +41,151 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class MultiTargetArffFileStream extends AbstractOptionHandler implements
+public class MultiTargetArffFileStream extends ArffFileStream implements
         MultiTargetInstanceStream {
 
-    @Override
-    public String getPurposeString() {
-        return "A stream read from an ARFF file.";
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    public FileOption arffFileOption = new FileOption("arffFile", 'f',
-            "ARFF file to load.", null, "arff", false);
-
-    public RangeOption outputAttributesOption = new RangeOption(
-            "outputAttributes",
-            'c',
-            "Output attributes:  n for first n attributes,  -n for last n attributes  For example, 2 for the two first attributes, -2 for the two last attributes.",
-			"-1");
-
-    protected Instances instances;
-
-    protected Reader fileReader;
-
-    protected boolean hitEndOfFile;
-
-    protected InstanceExample lastInstanceRead;
-
-    protected int numInstancesRead;
-
-    protected InputStreamProgressMonitor fileProgressMonitor;
-
-    public MultiTargetArffFileStream() {
-    }
-
-	// jesse
-    public MultiTargetArffFileStream(String arffFileName, String classIndices) {
-		this.arffFileOption.setValue(arffFileName);
-		this.outputAttributesOption.setValue(classIndices);
-		restart();
-    }
-
-	/*
-    public ArffFileStream(String arffFileName, int classIndex) {
-        this.arffFileOption.setValue(arffFileName);
-        this.outputAttributesOption.setValue(classIndex);
-        restart();
-    }
-	*/
-
-    @Override
-    public void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        restart();
-    }
-
-    @Override
-    public InstancesHeader getHeader() {
-        return new InstancesHeader(this.instances);
-    }
-
-    @Override
-    public long estimatedRemainingInstances() {
-        double progressFraction = this.fileProgressMonitor.getProgressFraction();
-        if ((progressFraction > 0.0) && (this.numInstancesRead > 0)) {
-            return (long) ((this.numInstancesRead / progressFraction) - this.numInstancesRead);
-        }
-        return -1;
-    }
-
-    @Override
-    public boolean hasMoreInstances() {
-        return !this.hitEndOfFile;
-    }
-
-    @Override
-    public InstanceExample nextInstance() {
-        InstanceExample prevInstance = this.lastInstanceRead;
-        this.hitEndOfFile = !readNextInstanceFromFile();
-        return prevInstance;
-    }
-
-    @Override
-    public boolean isRestartable() {
-        return true;
-    }
-
-    @Override
-    public void restart() {
-        try {
-            if (this.fileReader != null) {
-                this.fileReader.close();
-            }
-            InputStream fileStream = new FileInputStream(this.arffFileOption.getFile());
-            this.fileProgressMonitor = new InputStreamProgressMonitor(
-                    fileStream);
-            this.fileReader = new BufferedReader(new InputStreamReader(
-                    this.fileProgressMonitor));
-			// jesse -----
-			/*int cs[] = this.outputAttributesOption.getRange(); 
-			if (cs.length == 1) {
-				// single label
-				int c = cs[0]; 
-				this.instances = new Instances(this.fileReader, 1, c);
-				if (c < 0) {
-					this.instances.setClassIndex(this.instances.numAttributes() - 1);
-				} else if (c > 0) {
-					this.instances.setClassIndex(c - 1);
-				}
-			}
-			else {*/
-				// multi-label since cs[] contains _multipe_ class indices, e.g., cs[] = {9,10,11} 
-				// what to do here?
-			this.instances = new Instances(this.fileReader, this.outputAttributesOption.getRange());
-			//}
-            this.numInstancesRead = 0;
-            this.lastInstanceRead = null;
-            this.hitEndOfFile = !readNextInstanceFromFile();
-        } catch (IOException ioe) {
-            throw new RuntimeException("ArffFileStream restart failed.", ioe);
-        }
-    }
-
-    protected boolean readNextInstanceFromFile() {
-        try {
-            if (this.instances.readInstance(this.fileReader)) {
-                this.lastInstanceRead = new InstanceExample(this.instances.instance(0));
-                this.instances.delete(); // keep instances clean
-                this.numInstancesRead++;
-                return true;
-            }
-            if (this.fileReader != null) {
-                this.fileReader.close();
-                this.fileReader = null;
-            }
-            return false;
-        } catch (IOException ioe) {
-            throw new RuntimeException(
-                    "ArffFileStream failed to read instance from stream.", ioe);
-        }
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
+	// deprecated
+	
+//    @Override
+//    public String getPurposeString() {
+//        return "A stream read from an ARFF file.";
+//    }
+//
+//    private static final long serialVersionUID = 1L;
+//
+//    public FileOption arffFileOption = new FileOption("arffFile", 'f',
+//            "ARFF file to load.", null, "arff", false);
+//
+//    public RangeOption outputAttributesOption = new RangeOption(
+//            "outputAttributes",
+//            'c',
+//            "Output attributes:  n for first n attributes,  -n for last n attributes  For example, 2 for the two first attributes, -2 for the two last attributes.",
+//			"-1");
+//
+//    protected Instances instances;
+//
+//    protected Reader fileReader;
+//
+//    protected boolean hitEndOfFile;
+//
+//    protected InstanceExample lastInstanceRead;
+//
+//    protected int numInstancesRead;
+//
+//    protected InputStreamProgressMonitor fileProgressMonitor;
+//
+//    public MultiTargetArffFileStream() {
+//    }
+//
+//	// jesse
+//    public MultiTargetArffFileStream(String arffFileName, String classIndices) {
+//		this.arffFileOption.setValue(arffFileName);
+//		this.outputAttributesOption.setValue(classIndices);
+//		restart();
+//    }
+//
+//	/*
+//    public ArffFileStream(String arffFileName, int classIndex) {
+//        this.arffFileOption.setValue(arffFileName);
+//        this.outputAttributesOption.setValue(classIndex);
+//        restart();
+//    }
+//	*/
+//
+//    @Override
+//    public void prepareForUseImpl(TaskMonitor monitor,
+//            ObjectRepository repository) {
+//        restart();
+//    }
+//
+//    @Override
+//    public InstancesHeader getHeader() {
+//        return new InstancesHeader(this.instances);
+//    }
+//
+//    @Override
+//    public long estimatedRemainingInstances() {
+//        double progressFraction = this.fileProgressMonitor.getProgressFraction();
+//        if ((progressFraction > 0.0) && (this.numInstancesRead > 0)) {
+//            return (long) ((this.numInstancesRead / progressFraction) - this.numInstancesRead);
+//        }
+//        return -1;
+//    }
+//
+//    @Override
+//    public boolean hasMoreInstances() {
+//        return !this.hitEndOfFile;
+//    }
+//
+//    @Override
+//    public InstanceExample nextInstance() {
+//        InstanceExample prevInstance = this.lastInstanceRead;
+//        this.hitEndOfFile = !readNextInstanceFromFile();
+//        return prevInstance;
+//    }
+//
+//    @Override
+//    public boolean isRestartable() {
+//        return true;
+//    }
+//
+//    @Override
+//    public void restart() {
+//        try {
+//            if (this.fileReader != null) {
+//                this.fileReader.close();
+//            }
+//            InputStream fileStream = new FileInputStream(this.arffFileOption.getFile());
+//            this.fileProgressMonitor = new InputStreamProgressMonitor(
+//                    fileStream);
+//            this.fileReader = new BufferedReader(new InputStreamReader(
+//                    this.fileProgressMonitor));
+//			// jesse -----
+//			/*int cs[] = this.outputAttributesOption.getRange(); 
+//			if (cs.length == 1) {
+//				// single label
+//				int c = cs[0]; 
+//				this.instances = new Instances(this.fileReader, 1, c);
+//				if (c < 0) {
+//					this.instances.setClassIndex(this.instances.numAttributes() - 1);
+//				} else if (c > 0) {
+//					this.instances.setClassIndex(c - 1);
+//				}
+//			}
+//			else {*/
+//				// multi-label since cs[] contains _multipe_ class indices, e.g., cs[] = {9,10,11} 
+//				// what to do here?
+//			this.instances = new Instances(this.fileReader, this.outputAttributesOption.getRange());
+//			//}
+//            this.numInstancesRead = 0;
+//            this.lastInstanceRead = null;
+//            this.hitEndOfFile = !readNextInstanceFromFile();
+//        } catch (IOException ioe) {
+//            throw new RuntimeException("ArffFileStream restart failed.", ioe);
+//        }
+//    }
+//
+//    protected boolean readNextInstanceFromFile() {
+//        try {
+//            if (this.instances.readInstance(this.fileReader)) {
+//                this.lastInstanceRead = new InstanceExample(this.instances.instance(0));
+//                this.instances.delete(); // keep instances clean
+//                this.numInstancesRead++;
+//                return true;
+//            }
+//            if (this.fileReader != null) {
+//                this.fileReader.close();
+//                this.fileReader = null;
+//            }
+//            return false;
+//        } catch (IOException ioe) {
+//            throw new RuntimeException(
+//                    "ArffFileStream failed to read instance from stream.", ioe);
+//        }
+//    }
+//
+//    @Override
+//    public void getDescription(StringBuilder sb, int indent) {
+//        // TODO Auto-generated method stub
+//    }
 }
diff --git a/moa/src/main/java/moa/streams/clustering/FileStream.java b/moa/src/main/java/moa/streams/clustering/FileStream.java
index 9b122de65..7ef557add 100644
--- a/moa/src/main/java/moa/streams/clustering/FileStream.java
+++ b/moa/src/main/java/moa/streams/clustering/FileStream.java
@@ -43,10 +43,12 @@
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.ListOption;
 import com.github.javacliparser.Option;
+import com.github.javacliparser.StringOption;
+
 import moa.tasks.TaskMonitor;
 
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public class FileStream extends ClusteringStream{
 
@@ -63,12 +65,24 @@ public String getPurposeString() {
 	public FileOption arffFileOption = new FileOption("arffFile", 'f',
 			"ARFF file to load.", defaultfile, "arff", false);
 
-	public IntOption classIndexOption = new IntOption(
-			"classIndex",
-			'c',
-			"Class index of data. 0 for none or -1 for last attribute in file.",
-			-1, -1, Integer.MAX_VALUE);
-
+//	public IntOption classIndexOption = new IntOption(
+//			"classIndex",
+//			'c',
+//			"Class index of data. 0 for none or -1 for last attribute in file.",
+//			-1, -1, Integer.MAX_VALUE);
+
+    public StringOption outputIndicesOption = new StringOption(
+    		"outputIndices",
+    		'c',
+    		"Indices of output (class) attributes. Can be provided in a comma or semicolon separated list of single values or ranges.",
+    		"-1");
+
+    public StringOption inputIndicesOption = new StringOption(
+    		"outputIndices",
+    		'i',
+    		"Indices of input (class) attributes. Can be provided in a comma or semicolon separated list of single values or ranges. Leave blank for all non-output attributes.",
+    		"");
+	
     public FlagOption normalizeOption = 
     		new FlagOption("normalize", 'n', 
     				"Numerical data will be normalized to 0-1 " +
@@ -90,7 +104,7 @@ public String getPurposeString() {
 
     
   
-	protected Instances instances;
+	protected InstancesHeader instances;
 
 	protected Reader fileReader;
 
@@ -104,7 +118,7 @@ public String getPurposeString() {
 	
 	private Integer[] removeAttributes = null;
     
-	private Instances filteredDataset = null;
+	private InstancesHeader filteredDataset = null;
     
 	private ArrayList<Double[]> valuesMinMaxDiff = null;
 
@@ -155,12 +169,7 @@ public void restart() {
 			InputStream fileStream = new FileInputStream(arffFileOption.getFile());
 			fileProgressMonitor = new InputStreamProgressMonitor(fileStream);
 			fileReader = new BufferedReader(new InputStreamReader(fileProgressMonitor));
-            instances = new Instances(fileReader, 1, this.classIndexOption.getValue());
-			if (classIndexOption.getValue() < 0) {
-				instances.setClassIndex(instances.numAttributes() - 1);
-			} else if (classIndexOption.getValue() > 0) {
-				instances.setClassIndex(classIndexOption.getValue() - 1);
-			}
+            instances = new InstancesHeader(fileReader, 1, this.outputIndicesOption.getValue(), this.inputIndicesOption.getValue());
 
 
 			//use hashset to delete duplicates and attributes numbers that aren't valid
@@ -206,7 +215,7 @@ public void restart() {
 			}
             
 			//create filtered dataset
-			filteredDataset = new Instances(instances);
+			filteredDataset = new InstancesHeader(instances);
 			for (int i = removeAttributes.length-1; i >= 0 ; i--) {
 				filteredDataset.deleteAttributeAt(removeAttributes[i]);
 				if(true){
@@ -278,7 +287,7 @@ protected ArrayList<Double[]> readMinMaxDiffValues(HashSet<Integer> ignoredAttri
 			InputStream fileStream = new FileInputStream(arffFileOption.getFile());
 			InputStreamProgressMonitor fileProgressMonitor = new InputStreamProgressMonitor(fileStream);
 			Reader fileReader = new BufferedReader(new InputStreamReader(fileProgressMonitor));
-            Instances instances = new Instances(fileReader, 1, this.classIndexOption.getValue());
+            InstancesHeader instances = new InstancesHeader(fileReader, 1, this.outputIndicesOption.getValue(), this.inputIndicesOption.getValue());
 
 			valuesMinMaxDiff = new ArrayList<Double[]>();
 			for (int i = 0; i < instances.numAttributes()-ignoredAttributes.size(); i++) {
diff --git a/moa/src/main/java/moa/streams/clustering/RandomRBFGeneratorEvents.java b/moa/src/main/java/moa/streams/clustering/RandomRBFGeneratorEvents.java
index 4ade99a71..84b15eebc 100644
--- a/moa/src/main/java/moa/streams/clustering/RandomRBFGeneratorEvents.java
+++ b/moa/src/main/java/moa/streams/clustering/RandomRBFGeneratorEvents.java
@@ -47,7 +47,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 
 public class RandomRBFGeneratorEvents extends ClusteringStream {
@@ -510,7 +510,7 @@ protected void generateHeader() {	// 2013/06/02: Noise label
         if (noiseLevelOption.getValue() > 0) classLabels.add("noise");	// The last label = "noise"
         
         attributes.add(new Attribute("class", classLabels));
-        streamHeader = new InstancesHeader(new Instances(getCLICreationString(InstanceStream.class), attributes, 0));
+        streamHeader = new InstancesHeader(new InstancesHeader(getCLICreationString(InstanceStream.class), attributes, 0));
         streamHeader.setClassIndex(streamHeader.numAttributes() - 1);
     }
 
diff --git a/moa/src/main/java/moa/streams/clustering/SimpleCSVStream.java b/moa/src/main/java/moa/streams/clustering/SimpleCSVStream.java
index d554e0eaf..fe46621be 100644
--- a/moa/src/main/java/moa/streams/clustering/SimpleCSVStream.java
+++ b/moa/src/main/java/moa/streams/clustering/SimpleCSVStream.java
@@ -33,7 +33,7 @@
 import com.github.javacliparser.StringOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import moa.core.InputStreamProgressMonitor;
@@ -61,7 +61,7 @@ public class SimpleCSVStream extends ClusteringStream {
 	public FlagOption classIndexOption = new FlagOption("classIndex", 'c',
 			"Last attribute is class index.");
 
-	protected Instances dataset;
+	protected InstancesHeader dataset;
 
 	protected BufferedReader fileReader;
 
@@ -252,7 +252,7 @@ public void restart() {
 				ArrayList<String> classLabels = new ArrayList<String>();
 				classLabels.add("0");
 		        attributes.add(new Attribute("class", classLabels));
-				this.dataset = new Instances(csvFileOption.getFile().getName(),
+				this.dataset = new InstancesHeader(csvFileOption.getFile().getName(),
 						attributes, 0);
 				this.dataset.setClassIndex(this.numAttributes - 1);
 				numAttsOption = new IntOption("numAtts", 'a', "",
diff --git a/moa/src/main/java/moa/streams/filters/AddNoiseFilter.java b/moa/src/main/java/moa/streams/filters/AddNoiseFilter.java
index 3caa94559..c7968e479 100644
--- a/moa/src/main/java/moa/streams/filters/AddNoiseFilter.java
+++ b/moa/src/main/java/moa/streams/filters/AddNoiseFilter.java
@@ -25,10 +25,11 @@
 import moa.core.DoubleVector;
 import moa.core.GaussianEstimator;
 import moa.core.InstanceExample;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Filter for adding random noise to examples in a stream.
diff --git a/moa/src/main/java/moa/streams/filters/RBFFilter.java b/moa/src/main/java/moa/streams/filters/RBFFilter.java
index 4b9901d83..bf90b324c 100644
--- a/moa/src/main/java/moa/streams/filters/RBFFilter.java
+++ b/moa/src/main/java/moa/streams/filters/RBFFilter.java
@@ -11,7 +11,7 @@
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceImpl;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Range;
 
@@ -88,7 +88,7 @@ private void initialize(Instance instance) {
 		}
 
 		// initialize instance space
-		Instances ds = new Instances();
+		InstancesHeader ds = new InstancesHeader();
 		List<Attribute> v = new ArrayList<Attribute>(h);
 		List<Integer> indexValues = new ArrayList<Integer>(h);
 
@@ -101,9 +101,6 @@ private void initialize(Instance instance) {
 
 
 		ds.setAttributes(v,indexValues);
-		Range r= new Range("start-end");
-		//r.setUpper(h);
-		ds.setRangeOutputIndices(r);
 		dataset=(new InstancesHeader(ds));
 		dataset.setClassIndex(h);
 		System.out.println(""+dataset);
diff --git a/moa/src/main/java/moa/streams/filters/ReLUFilter.java b/moa/src/main/java/moa/streams/filters/ReLUFilter.java
index f50c6ac60..3f6eb7f55 100644
--- a/moa/src/main/java/moa/streams/filters/ReLUFilter.java
+++ b/moa/src/main/java/moa/streams/filters/ReLUFilter.java
@@ -11,7 +11,7 @@
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceImpl;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Range;
 
@@ -99,7 +99,7 @@ private void initialize(Instance instance) {
 		}
 
 		// initialize instance space
-		Instances ds = new Instances();
+		InstancesHeader ds = new InstancesHeader();
 		List<Attribute> v = new ArrayList<Attribute>(H);
 		List<Integer> indexValues = new ArrayList<Integer>(H);
 
@@ -112,8 +112,6 @@ private void initialize(Instance instance) {
 
 
 		ds.setAttributes(v,indexValues);
-		Range r= new Range("start-end");
-		ds.setRangeOutputIndices(r);
 		dataset=(new InstancesHeader(ds));
 		dataset.setClassIndex(H);
 
diff --git a/moa/src/main/java/moa/streams/filters/RemoveDiscreteAttributeFilter.java b/moa/src/main/java/moa/streams/filters/RemoveDiscreteAttributeFilter.java
index fa80d5230..f2143f080 100644
--- a/moa/src/main/java/moa/streams/filters/RemoveDiscreteAttributeFilter.java
+++ b/moa/src/main/java/moa/streams/filters/RemoveDiscreteAttributeFilter.java
@@ -25,7 +25,7 @@
 import moa.streams.InstanceStream;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.SparseInstance;
 import moa.core.FastVector;
@@ -74,7 +74,7 @@ public InstanceExample nextInstance() {
             }
             attributes.addElement(inst.classAttribute());
             numericAttributes.add(inst.classIndex());
-            this.streamHeader = new InstancesHeader(new Instances(
+            this.streamHeader = new InstancesHeader(new InstancesHeader(
                     getCLICreationString(InstanceStream.class), attributes, 0));
             this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
 
diff --git a/moa/src/main/java/moa/streams/filters/ReplacingMissingValuesFilter.java b/moa/src/main/java/moa/streams/filters/ReplacingMissingValuesFilter.java
index 29aa407bc..fefe7f955 100644
--- a/moa/src/main/java/moa/streams/filters/ReplacingMissingValuesFilter.java
+++ b/moa/src/main/java/moa/streams/filters/ReplacingMissingValuesFilter.java
@@ -23,6 +23,7 @@
 import com.github.javacliparser.MultiChoiceOption;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
diff --git a/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java b/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java
index 808f3641f..b5905e34a 100644
--- a/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java
+++ b/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java
@@ -3,6 +3,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import moa.core.Example;
 import moa.core.InstanceExample;
 import moa.streams.MultiTargetInstanceStream;
 
@@ -10,11 +11,12 @@
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceImpl;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Range;
 
 public class SelectAttributesFilter extends AbstractMultiLabelStreamFilter implements MultiLabelStreamFilter{
+
 	/**
 	 * 
 	 */
@@ -48,15 +50,18 @@ private void initialize(Instance instance) {
 		inputsSelected=getSelection(inputStringOption.getValue());
 		outputsSelected=getSelection(outputStringOption.getValue());
 		int totAttributes=inputsSelected.numValues()+outputsSelected.numValues();
-		Instances ds= new Instances();
+		InstancesHeader ds= new InstancesHeader();
 		List<Attribute> v = new ArrayList<Attribute>(totAttributes);
 		List<Integer> indexValues = new ArrayList<Integer>(totAttributes);
 		int ct=0;
+		List<Integer> inputIndexes = new ArrayList<Integer>();
+		List<Integer> outputIndexes = new ArrayList<Integer>();
 		for (int i=0; i<inputsSelected.numEntries();i++)
 		{
 			for (int j=inputsSelected.getStart(i); j<=inputsSelected.getEnd(i);j++){
 				v.add(instance.attribute(j-1));
 				indexValues.add(ct);
+				inputIndexes.add(ct);
 				ct++;
 			}
 		}
@@ -66,13 +71,13 @@ private void initialize(Instance instance) {
 			for (int j=outputsSelected.getStart(i); j<=outputsSelected.getEnd(i);j++){
 				v.add(instance.attribute(j-1));
 				indexValues.add(ct);
+				outputIndexes.add(ct);
 				ct++;
 			}
 		}		
 		ds.setAttributes(v,indexValues);
-		Range r= new Range("-" + outputsSelected.numValues());
-		r.setUpper(totAttributes);
-		ds.setRangeOutputIndices(r);
+		ds.setOutputIndexes(outputIndexes);
+		ds.setInputIndexes(inputIndexes);
 		dataset=(new InstancesHeader(ds));
 	}
 
@@ -128,5 +133,4 @@ private Instance processInstance(Instance instance) {
 		newInstance.setDataset(dataset);
 		return newInstance;
 	}
-
 }
diff --git a/moa/src/main/java/moa/streams/generators/AgrawalGenerator.java b/moa/src/main/java/moa/streams/generators/AgrawalGenerator.java
index ba8a96f74..b6fd685eb 100644
--- a/moa/src/main/java/moa/streams/generators/AgrawalGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/AgrawalGenerator.java
@@ -23,7 +23,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import java.util.Random;
 import moa.core.Example;
@@ -306,7 +306,7 @@ protected void prepareForUseImpl(TaskMonitor monitor,
         classLabels.addElement("groupA");
         classLabels.addElement("groupB");
         attributes.addElement(new Attribute("class", classLabels));
-        this.streamHeader = new InstancesHeader(new Instances(
+        this.streamHeader = new InstancesHeader(new InstancesHeader(
                 getCLICreationString(InstanceStream.class), attributes, 0));
         this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
         restart();
diff --git a/moa/src/main/java/moa/streams/generators/HyperplaneGenerator.java b/moa/src/main/java/moa/streams/generators/HyperplaneGenerator.java
index d5bd99e01..be6e6aa71 100644
--- a/moa/src/main/java/moa/streams/generators/HyperplaneGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/HyperplaneGenerator.java
@@ -31,7 +31,7 @@
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
@@ -101,7 +101,7 @@ protected void generateHeader() {
             classLabels.addElement("class" + (i + 1));
         }
         attributes.addElement(new Attribute("class", classLabels));
-        this.streamHeader = new InstancesHeader(new Instances(
+        this.streamHeader = new InstancesHeader(new InstancesHeader(
                 getCLICreationString(InstanceStream.class), attributes, 0));
         this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
     }
diff --git a/moa/src/main/java/moa/streams/generators/LEDGenerator.java b/moa/src/main/java/moa/streams/generators/LEDGenerator.java
index f6c78d868..a57fb1dc1 100644
--- a/moa/src/main/java/moa/streams/generators/LEDGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/LEDGenerator.java
@@ -23,7 +23,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import java.util.Random;
 import moa.core.InstanceExample;
@@ -96,7 +96,7 @@ protected void prepareForUseImpl(TaskMonitor monitor,
             classLabels.addElement(Integer.toString(i));
         }
         attributes.addElement(new Attribute("class", classLabels));
-        this.streamHeader = new InstancesHeader(new Instances(
+        this.streamHeader = new InstancesHeader(new InstancesHeader(
                 getCLICreationString(InstanceStream.class), attributes, 0));
         this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
         restart();
diff --git a/moa/src/main/java/moa/streams/generators/LEDGeneratorDrift.java b/moa/src/main/java/moa/streams/generators/LEDGeneratorDrift.java
index bde9241ca..26ee76a89 100644
--- a/moa/src/main/java/moa/streams/generators/LEDGeneratorDrift.java
+++ b/moa/src/main/java/moa/streams/generators/LEDGeneratorDrift.java
@@ -23,6 +23,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.core.ObjectRepository;
 import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
diff --git a/moa/src/main/java/moa/streams/generators/RandomRBFGenerator.java b/moa/src/main/java/moa/streams/generators/RandomRBFGenerator.java
index 5fbbf8390..cbbe0202c 100644
--- a/moa/src/main/java/moa/streams/generators/RandomRBFGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/RandomRBFGenerator.java
@@ -23,7 +23,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import java.io.Serializable;
 import java.util.Random;
@@ -158,7 +158,7 @@ protected void generateHeader() {
             classLabels.addElement("class" + (i + 1));
         }
         attributes.addElement(new Attribute("class", classLabels));
-        this.streamHeader = new InstancesHeader(new Instances(
+        this.streamHeader = new InstancesHeader(new InstancesHeader(
                 getCLICreationString(InstanceStream.class), attributes, 0));
         this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
     }
diff --git a/moa/src/main/java/moa/streams/generators/RandomTreeGenerator.java b/moa/src/main/java/moa/streams/generators/RandomTreeGenerator.java
index c48d690f0..282618a02 100644
--- a/moa/src/main/java/moa/streams/generators/RandomTreeGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/RandomTreeGenerator.java
@@ -23,7 +23,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import java.io.Serializable;
 import java.util.ArrayList;
@@ -191,7 +191,7 @@ protected void generateHeader() {
             classLabels.addElement("class" + (i + 1));
         }
         attributes.addElement(new Attribute("class", classLabels));
-        this.streamHeader = new InstancesHeader(new Instances(
+        this.streamHeader = new InstancesHeader(new InstancesHeader(
                 getCLICreationString(InstanceStream.class), attributes, 0));
         this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
     }
diff --git a/moa/src/main/java/moa/streams/generators/SEAGenerator.java b/moa/src/main/java/moa/streams/generators/SEAGenerator.java
index 231722231..06da33f07 100644
--- a/moa/src/main/java/moa/streams/generators/SEAGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/SEAGenerator.java
@@ -23,7 +23,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import java.util.Random;
 import moa.core.InstanceExample;
@@ -135,7 +135,7 @@ protected void prepareForUseImpl(TaskMonitor monitor,
         classLabels.addElement("groupA");
         classLabels.addElement("groupB");
         attributes.addElement(new Attribute("class", classLabels));
-        this.streamHeader = new InstancesHeader(new Instances(
+        this.streamHeader = new InstancesHeader(new InstancesHeader(
                 getCLICreationString(InstanceStream.class), attributes, 0));
         this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
         restart();
diff --git a/moa/src/main/java/moa/streams/generators/STAGGERGenerator.java b/moa/src/main/java/moa/streams/generators/STAGGERGenerator.java
index d1b94c8c6..a92118e17 100644
--- a/moa/src/main/java/moa/streams/generators/STAGGERGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/STAGGERGenerator.java
@@ -23,7 +23,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import java.util.Random;
 import moa.core.InstanceExample;
@@ -137,7 +137,7 @@ protected void prepareForUseImpl(TaskMonitor monitor,
         classLabels.addElement("false");
         classLabels.addElement("true");
         attributes.addElement(new Attribute("class", classLabels));
-        this.streamHeader = new InstancesHeader(new Instances(
+        this.streamHeader = new InstancesHeader(new InstancesHeader(
                 getCLICreationString(InstanceStream.class), attributes, 0));
         this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
         restart();
diff --git a/moa/src/main/java/moa/streams/generators/WaveformGenerator.java b/moa/src/main/java/moa/streams/generators/WaveformGenerator.java
index d58eedd73..f66e5b0ff 100644
--- a/moa/src/main/java/moa/streams/generators/WaveformGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/WaveformGenerator.java
@@ -23,7 +23,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import java.util.Random;
 import moa.core.InstanceExample;
@@ -89,7 +89,7 @@ protected void prepareForUseImpl(TaskMonitor monitor,
             classLabels.addElement("class" + (i + 1));
         }
         attributes.addElement(new Attribute("class", classLabels));
-        this.streamHeader = new InstancesHeader(new Instances(
+        this.streamHeader = new InstancesHeader(new InstancesHeader(
                 getCLICreationString(InstanceStream.class), attributes, 0));
         this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
         restart();
diff --git a/moa/src/main/java/moa/streams/generators/WaveformGeneratorDrift.java b/moa/src/main/java/moa/streams/generators/WaveformGeneratorDrift.java
index 719267e88..c918ad8b3 100644
--- a/moa/src/main/java/moa/streams/generators/WaveformGeneratorDrift.java
+++ b/moa/src/main/java/moa/streams/generators/WaveformGeneratorDrift.java
@@ -24,6 +24,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.core.ObjectRepository;
 import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
diff --git a/moa/src/main/java/moa/streams/generators/cd/AbstractConceptDriftGenerator.java b/moa/src/main/java/moa/streams/generators/cd/AbstractConceptDriftGenerator.java
index 607b53511..7dd440d98 100644
--- a/moa/src/main/java/moa/streams/generators/cd/AbstractConceptDriftGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/cd/AbstractConceptDriftGenerator.java
@@ -24,7 +24,7 @@
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import java.util.ArrayList;
 import java.util.Random;
@@ -96,7 +96,7 @@ protected void prepareForUseImpl(TaskMonitor monitor,
         attributes.addElement(new Attribute("change", binaryLabels));
         attributes.addElement(new Attribute("ground truth input"));
 
-        this.streamHeader = new InstancesHeader(new Instances(
+        this.streamHeader = new InstancesHeader(new InstancesHeader(
                 getCLICreationString(InstanceStream.class), attributes, 0));
         this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
 
diff --git a/moa/src/main/java/moa/streams/generators/multilabel/MetaMultilabelGenerator.java b/moa/src/main/java/moa/streams/generators/multilabel/MetaMultilabelGenerator.java
index 7517e7566..62536ddc5 100644
--- a/moa/src/main/java/moa/streams/generators/multilabel/MetaMultilabelGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/multilabel/MetaMultilabelGenerator.java
@@ -31,7 +31,6 @@
 import moa.tasks.TaskMonitor;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.SparseInstance;
 import moa.core.FastVector;
@@ -75,7 +74,7 @@ public class MetaMultilabelGenerator extends AbstractOptionHandler implements In
 
     protected InstanceStream m_BinaryGenerator = null;
 
-    protected Instances multilabelStreamTemplate = null;
+    protected InstancesHeader multilabelStreamTemplate = null;
 
     protected Random m_MetaRandom = new Random();
 
@@ -152,8 +151,8 @@ public void restart() {
      *
      * @param	si	single-label Instances
      */
-    protected MultilabelInstancesHeader generateMultilabelHeader(Instances si) {
-        Instances mi = new Instances(si, 0, 0);
+    protected MultilabelInstancesHeader generateMultilabelHeader(InstancesHeader si) {
+        InstancesHeader mi = new InstancesHeader(si, 0, 0);
         mi.setClassIndex(-1);
         mi.deleteAttributeAt(mi.numAttributes() - 1);
         FastVector bfv = new FastVector();
diff --git a/moa/src/main/java/moa/streams/generators/multilabel/MultilabelArffFileStream.java b/moa/src/main/java/moa/streams/generators/multilabel/MultilabelArffFileStream.java
index 2da61df1d..cec7e0aa4 100644
--- a/moa/src/main/java/moa/streams/generators/multilabel/MultilabelArffFileStream.java
+++ b/moa/src/main/java/moa/streams/generators/multilabel/MultilabelArffFileStream.java
@@ -21,12 +21,10 @@
 
 import moa.streams.ArffFileStream;
 import moa.streams.MultiTargetInstanceStream;
-
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
 import moa.core.MultilabelInstancesHeader;
 
 import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Stream reader for ARFF files of multilabel data.
diff --git a/moa/src/main/java/moa/tasks/CacheShuffledStream.java b/moa/src/main/java/moa/tasks/CacheShuffledStream.java
index fa623d3aa..ae50c8c53 100644
--- a/moa/src/main/java/moa/tasks/CacheShuffledStream.java
+++ b/moa/src/main/java/moa/tasks/CacheShuffledStream.java
@@ -21,7 +21,7 @@
 
 import java.util.Random;
 
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
 import moa.options.ClassOption;
 import com.github.javacliparser.IntOption;
@@ -58,7 +58,7 @@ public String getPurposeString() {
     @Override
     protected Object doTaskImpl(TaskMonitor monitor, ObjectRepository repository) {
         InstanceStream stream = (InstanceStream) getPreparedClassOption(this.streamOption);
-        Instances cache = new Instances(stream.getHeader(), 0);
+        InstancesHeader cache = new InstancesHeader(stream.getHeader(), 0);
         monitor.setCurrentActivity("Caching instances...", -1.0);
         while ((cache.numInstances() < this.maximumCacheSizeOption.getValue())
                 && stream.hasMoreInstances()) {
diff --git a/moa/src/main/java/moa/tasks/EvaluateInterleavedChunks.java b/moa/src/main/java/moa/tasks/EvaluateInterleavedChunks.java
index 1badc058d..f8c78b6bb 100644
--- a/moa/src/main/java/moa/tasks/EvaluateInterleavedChunks.java
+++ b/moa/src/main/java/moa/tasks/EvaluateInterleavedChunks.java
@@ -38,7 +38,7 @@
 import moa.streams.ExampleStream;
 import moa.streams.InstanceStream;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public class EvaluateInterleavedChunks extends MainTask {
 
@@ -169,7 +169,7 @@ protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
 				&& ((maxInstances < 0) || (instancesProcessed < maxInstances))
 				&& ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
 			
-			Instances chunkInstances = new Instances(stream.getHeader(), chunkSize);
+			InstancesHeader chunkInstances = new InstancesHeader(stream.getHeader(), chunkSize);
 			
 			while (stream.hasMoreInstances() && chunkInstances.numInstances() < chunkSize) {
 				chunkInstances.add((Instance) stream.nextInstance().getData());
diff --git a/moa/src/main/java/moa/tasks/EvaluatePeriodicHeldOutTest.java b/moa/src/main/java/moa/tasks/EvaluatePeriodicHeldOutTest.java
index 049d033ed..fac762d2f 100644
--- a/moa/src/main/java/moa/tasks/EvaluatePeriodicHeldOutTest.java
+++ b/moa/src/main/java/moa/tasks/EvaluatePeriodicHeldOutTest.java
@@ -41,7 +41,7 @@
 import moa.streams.CachedInstancesStream;
 import moa.streams.ExampleStream;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Task for evaluating a classifier on a stream by periodically testing on a heldout set.
@@ -121,7 +121,7 @@ protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
         int testSize = this.testSizeOption.getValue();
         if (this.cacheTestOption.isSet()) {
             monitor.setCurrentActivity("Caching test examples...", -1.0);
-            Instances testInstances = new Instances(stream.getHeader(),
+            InstancesHeader testInstances = new InstancesHeader(stream.getHeader(),
                     this.testSizeOption.getValue());
             while (testInstances.numInstances() < testSize) {
                 testInstances.add((Instance) stream.nextInstance().getData());
diff --git a/moa/src/test/java/com/yahoo/labs/samoa/instances/MultiTargetArffLoaderTest.java b/moa/src/test/java/com/yahoo/labs/samoa/instances/MultiTargetArffLoaderTest.java
index 42242bebe..1171e785b 100644
--- a/moa/src/test/java/com/yahoo/labs/samoa/instances/MultiTargetArffLoaderTest.java
+++ b/moa/src/test/java/com/yahoo/labs/samoa/instances/MultiTargetArffLoaderTest.java
@@ -23,18 +23,18 @@
 
 public class MultiTargetArffLoaderTest {
 	private static double EPS=0.00000001;
-	private static Instances instancesRegression;
-	private static Instances instancesClassification;
+	private static InstancesHeader instancesRegression;
+	private static InstancesHeader instancesClassification;
 	
 	@BeforeClass
 	public static void setUpBeforeClassRegression() throws Exception {
 		try {
             InputStream fileStream = new FileInputStream(ClassLoader.getSystemResource("moa/classifiers/data/small_regression.arff").getPath());
             Reader  reader= new BufferedReader(new InputStreamReader(fileStream));
-    		instancesRegression = new Instances(reader,new Range("4-6"));
+    		instancesRegression = new InstancesHeader(reader,"4-6");
     		fileStream = new FileInputStream(ClassLoader.getSystemResource("moa/classifiers/data/small_classification.arff").getPath());
     		reader = new BufferedReader(new InputStreamReader(fileStream));
-    		instancesClassification = new Instances(reader,new Range("2"));
+    		instancesClassification = new InstancesHeader(reader,"2");
         } catch (IOException ioe) {
             throw new RuntimeException("ArffFileStream restart failed.", ioe);
         }
@@ -43,12 +43,13 @@ public static void setUpBeforeClassRegression() throws Exception {
 	/*
 	 * TESTS REGRESSION DATASET
 	 */
-	@Test
-	public void testRangeRegression(){
-		assertEquals(3,instancesRegression.arff.range.getStart());
-		assertEquals(5,instancesRegression.arff.range.getEnd());
-	}
+//	@Test
+//	public void testRangeRegression(){
+//		assertEquals(3,instancesRegression.);
+//		assertEquals(5,instancesRegression.arff.range.getEnd());
+//	}
 	
+	@Test
 	public void testClassRegression(){
 		assertEquals(3,instancesRegression.arff.instanceInformation.numOutputAttributes());
 		assertTrue(instancesRegression.arff.instanceInformation.outputAttribute(0).name.equals("R1"));
@@ -155,12 +156,14 @@ public void testInstancesRegression() {
 	 * TESTS REGRESSION DATASET
 	 */
 
-	@Test
-	public void testRangeClassification(){
-		assertEquals(0,instancesClassification.arff.range.getStart());
-		assertEquals(1,instancesClassification.arff.range.getEnd());
-	}
+	// DEPRECATED
 	
+//	@Test
+//	public void testRangeClassification(){
+//		assertEquals(0,instancesClassification.arff.range.getStart());
+//		assertEquals(1,instancesClassification.arff.range.getEnd());
+//	}
+	@Test
 	public void testClassClassification(){
 		assertEquals(2,instancesClassification.arff.instanceInformation.numOutputAttributes());
 		assertTrue(instancesClassification.arff.instanceInformation.outputAttribute(0).name.equals("C1"));
diff --git a/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java b/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java
index 0c5a65e47..5c99a5e92 100644
--- a/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java
+++ b/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java
@@ -37,7 +37,7 @@
 
 import com.yahoo.labs.samoa.instances.ArffLoader;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Range;
 
@@ -132,8 +132,8 @@ protected AbstractTestHelper newTestHelper() {
 	 * @return		the data, null if it could not be loaded
 	 * @see		#getDataDirectory()
 	 */
-	protected Instances load(String filename, int classIndex) {
-		Instances	result = null;
+	protected InstancesHeader load(String filename, int classIndex) {
+		InstancesHeader	result = null;
 		//ArffLoader 	loader;
 
 		//result = null;
@@ -145,8 +145,7 @@ protected Instances load(String filename, int classIndex) {
 			TmpFile tmp=new TmpFile(filename);
 			FileInputStream fileStream = new FileInputStream(tmp.getAbsolutePath());
 			Reader reader=new BufferedReader(new InputStreamReader(fileStream));
-			Range range = new Range("-1");
-			result = new Instances(reader,range);
+			result = new InstancesHeader(reader,"-1");
 			result.setClassIndex(classIndex);
 			while (result.readInstance(null));
 		}
@@ -168,7 +167,7 @@ protected Instances load(String filename, int classIndex) {
 	 * @param scheme		the scheme to process the data with
 	 * @return			the processed data
 	 */
-	protected InspectionData[] inspect(Instances data, int[] inspectionPoints, LearningPerformanceEvaluator<Example<Instance>>  evaluator, Classifier scheme) {
+	protected InspectionData[] inspect(InstancesHeader data, int[] inspectionPoints, LearningPerformanceEvaluator<Example<Instance>>  evaluator, Classifier scheme) {
 		InspectionData[]	result;
 		int			i;
 		int			point;
@@ -178,6 +177,7 @@ protected InspectionData[] inspect(Instances data, int[] inspectionPoints, Learn
 		result = new InspectionData[inspectionPoints.length];
 
 		scheme.prepareForUse();
+		scheme.setModelContext(data);
 
 		point = 0;
 		for (i = 0; i < data.numInstances(); i++) {
@@ -296,7 +296,7 @@ protected String createOutputFilename(String input, int no) {
 	 * Compares the processed data against previously saved output data.
 	 */
 	public void testRegression() {
-		Instances					data;
+		InstancesHeader					data;
 		InspectionData[]				processed;
 		boolean					ok;
 		String					regression;
diff --git a/moa/src/test/java/moa/streams/filters/SelectAttributesFilterTest.java b/moa/src/test/java/moa/streams/filters/SelectAttributesFilterTest.java
index 4d6879edf..02ee87bf6 100644
--- a/moa/src/test/java/moa/streams/filters/SelectAttributesFilterTest.java
+++ b/moa/src/test/java/moa/streams/filters/SelectAttributesFilterTest.java
@@ -1,6 +1,8 @@
 package moa.streams.filters;
 
 import static org.junit.Assert.assertEquals;
+
+import moa.streams.ArffFileStream;
 import moa.streams.MultiTargetArffFileStream;
 
 import org.junit.BeforeClass;
@@ -14,7 +16,7 @@ public class SelectAttributesFilterTest {
 
 	@BeforeClass
 	public static void setUpBeforeClass() throws Exception {
-		MultiTargetArffFileStream stream=new MultiTargetArffFileStream(ClassLoader.getSystemResource("moa/classifiers/data/small_regression.arff").getPath(), "4-6");
+		ArffFileStream stream=new ArffFileStream(ClassLoader.getSystemResource("moa/classifiers/data/small_regression.arff").getPath(), "4-6");
 		filter= new SelectAttributesFilter();
 		filter.setInputStream(stream);   
 		filter.inputStringOption.setValue("2-5,8");

From 3dfb80bd13be625e8137b941b00cff9dfce8cb88 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Thu, 24 Mar 2016 13:45:02 +0100
Subject: [PATCH 13/33] AttributeInformation streamlining and other fixes

---
 .../com/github/javacliparser/RangeOption.java |   57 -
 .../labs/samoa/instances/ArffLoader.java      |   17 -
 .../yahoo/labs/samoa/instances/Attribute.java |    5 +
 .../instances/AttributesInformation.java      |   83 +-
 .../labs/samoa/instances/DenseInstance.java   |    5 +
 .../samoa/instances/DenseInstanceData.java    |    5 +
 .../yahoo/labs/samoa/instances/Instance.java  |    2 -
 .../labs/samoa/instances/InstanceImpl.java    |    7 +-
 .../samoa/instances/InstanceInformation.java  |   65 +-
 .../labs/samoa/instances/InstancesHeader.java | 1165 ++++++++---------
 .../samoa/instances/MultiLabelPrediction.java |    5 +
 .../com/yahoo/labs/samoa/instances/Range.java |  110 --
 .../LocalMultiTargetClassifier.java           |   11 +-
 .../main/java/moa/streams/ArffFileStream.java |    2 +-
 .../streams/MultiTargetArffFileStream.java    |    1 -
 .../moa/streams/clustering/FileStream.java    |   14 +-
 .../java/moa/streams/filters/RBFFilter.java   |    7 +-
 .../java/moa/streams/filters/ReLUFilter.java  |    7 +-
 .../filters/SelectAttributesFilter.java       |    9 +-
 .../AbstractClassifierTestCase.java           |    4 -
 20 files changed, 668 insertions(+), 913 deletions(-)
 delete mode 100644 moa/src/main/java/com/github/javacliparser/RangeOption.java
 delete mode 100644 moa/src/main/java/com/yahoo/labs/samoa/instances/Range.java

diff --git a/moa/src/main/java/com/github/javacliparser/RangeOption.java b/moa/src/main/java/com/github/javacliparser/RangeOption.java
deleted file mode 100644
index 56f4da850..000000000
--- a/moa/src/main/java/com/github/javacliparser/RangeOption.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright 2007 University of Waikato.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
- * either express or implied. See the License for the specific
- * language governing permissions and limitations under the
- * License.  
- */
-
-package com.github.javacliparser;
-
-import java.util.Arrays;
-import com.yahoo.labs.samoa.instances.Range;
-
-/**
- * Range option.
- *
- * @author Jesse Read (jesse@tsc.uc3m.es)
- * @version $Revision: 7 $
- */
-public class RangeOption extends StringOption {
-
-    private static final long serialVersionUID = 1L;
-
-	public RangeOption(String name, char cliChar, String purpose, String defaultValue) {
-        super(name, cliChar, purpose, defaultValue);
-    }
-
-	/*
-	 * This class will be like StringOption, but expect a string of numbers like Weka's Range
-	 * e.g., 1,2,5-9,end will return something like [0,1,4,5,6,7,8,-1] which we will use later indicate e.g. multiple class attributes
-	 */
-
-	public void setRange(int indices[]) {
-        this.currentVal = Arrays.toString(indices); 								// "[1,2,3]"
-		this.currentVal = this.currentVal.substring(1,this.currentVal.length()-1);	// "1,2,3"
-    }
-    
-	public Range getRange() {	
-        return new Range(this.getValue());
-    }
-
-    /*public int[] getRange() {
-		Range r = new Range(this.getValue());
-        return r.getSelection();
-    }*/
-
-}
-
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
index c427141d8..fa92fc81e 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
@@ -20,7 +20,6 @@
 import java.io.Reader;
 import java.io.StreamTokenizer;
 import java.util.ArrayList;
-import java.util.LinkedList;
 import java.util.List;
 import java.util.logging.Level;
 import java.util.logging.Logger;
@@ -285,35 +284,25 @@ private void setSparseValue(Instance instance, List<Integer> indexValues, List<D
     private Instance readDenseInstanceSparse() {
         //Returns a dense instance
         Instance instance = newDenseInstance(this.instanceInformation.numAttributes());
-        //System.out.println(this.instanceInformation.numAttributes());
         int numAttribute;
         try {
-            //while (streamTokenizer.ttype != StreamTokenizer.TT_EOF) {
             streamTokenizer.nextToken(); // Remove the '{' char
             //For each line
             while (streamTokenizer.ttype != StreamTokenizer.TT_EOL
                     && streamTokenizer.ttype != StreamTokenizer.TT_EOF) {
                 while (streamTokenizer.ttype != '}') {
                     //For each item
-                    //streamTokenizer.nextToken();
-                    //while (streamTokenizer.ttype != '}'){
-                    //System.out.print(streamTokenizer.nval+":");
                     numAttribute = (int) streamTokenizer.nval;
                     streamTokenizer.nextToken();
 
                     if (streamTokenizer.ttype == StreamTokenizer.TT_NUMBER) {
-                        //System.out.print(streamTokenizer.nval + " ");
                         this.setValue(instance, numAttribute, streamTokenizer.nval, true);
-                        //numAttribute++;
-
                     } else if (streamTokenizer.sval != null && (streamTokenizer.ttype == StreamTokenizer.TT_WORD
                             || streamTokenizer.ttype == 34)) {
-                        //System.out.print(streamTokenizer.sval + "/"+this.instanceInformation.attribute(numAttribute).indexOfValue(streamTokenizer.sval)+" ");
                         if (this.auxAttributes.get(numAttribute).isNumeric()) {
                             this.setValue(instance, numAttribute, Double.valueOf(streamTokenizer.sval).doubleValue(), true);
                         } else {
                             this.setValue(instance, numAttribute, this.instanceInformation.attribute(numAttribute).indexOfValue(streamTokenizer.sval), false);
-                            //numAttribute++;
                         }
                     }
                     streamTokenizer.nextToken();
@@ -321,9 +310,6 @@ private Instance readDenseInstanceSparse() {
                 streamTokenizer.nextToken(); //Remove the '}' char
             }
             streamTokenizer.nextToken();
-            //System.out.println("EOL");
-            //}
-
         } catch (IOException ex) {
             Logger.getLogger(ArffLoader.class.getName()).log(Level.SEVERE, null, ex);
         }
@@ -355,7 +341,6 @@ private InstanceInformation getHeader(String outputDefinition, String inputDefin
                             name = Double.toString(streamTokenizer.nval);
                         }
                         streamTokenizer.nextToken();
-                        String type = streamTokenizer.sval;
                         if (streamTokenizer.ttype == '{') {
                             streamTokenizer.nextToken();
                             List<String> attributeLabels = new ArrayList<String>();
@@ -363,10 +348,8 @@ private InstanceInformation getHeader(String outputDefinition, String inputDefin
 
                                 if (streamTokenizer.sval != null) {
                                     attributeLabels.add(streamTokenizer.sval);
-                                   // System.out.print(streamTokenizer.sval + ",");
                                 } else {
                                     attributeLabels.add(Double.toString(streamTokenizer.nval));
-                                    //System.out.print(streamTokenizer.nval + ",");
                                 }
 
                                 streamTokenizer.nextToken();
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java
index 54e6c21dc..9ba21d898 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java
@@ -25,6 +25,11 @@
  */
 public class Attribute implements Serializable {
 
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -3739913325563469730L;
+
 	/** The keyword used to denote the start of an arff attribute declaration */
 	public final static String ARFF_ATTRIBUTE = "@attribute";
 
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/AttributesInformation.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/AttributesInformation.java
index 8fcbb1330..dae542dd4 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/AttributesInformation.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/AttributesInformation.java
@@ -16,7 +16,6 @@
 package com.yahoo.labs.samoa.instances;
 
 import java.io.Serializable;
-import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -27,16 +26,15 @@
  * @version $Revision: 7 $
  */
 public class AttributesInformation implements Serializable {
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 1666190771085863695L;
 
-    /**
+	/**
      * The attribute information.
      */
     protected List<Attribute> attributes;
-    protected List<Integer> indexValues;
-    /**
-     * The number of attributes.
-     */
-    protected int numberAttributes;
 
     /**
      * The attribute used for default for numerical values
@@ -45,29 +43,14 @@ public class AttributesInformation implements Serializable {
 
     public AttributesInformation(AttributesInformation chunk) {
         this.attributes = chunk.attributes;
-        this.indexValues = chunk.indexValues;
-        this.numberAttributes = chunk.numberAttributes;
     }
 
-    public AttributesInformation(List<Attribute> v, List<Integer> i, int numberAttributes) {
+    public AttributesInformation(List<Attribute> v) {
         this.attributes = v;
-        this.indexValues = i;
-        this.numberAttributes = numberAttributes;
-    }
-
-    public AttributesInformation(List<Attribute> v, int numberAttributes) {
-        this.attributes = v;
-        this.indexValues = new ArrayList<Integer>(numberAttributes);
-        for (int i = 0; i < numberAttributes; i++) {
-            this.indexValues.add(i);
-        }
-        this.numberAttributes = numberAttributes;
     }
 
     public AttributesInformation() {
         this.attributes = null;
-        this.indexValues = null;
-        this.numberAttributes = 0;
         this.defaultNumericAttribute = null;
     }
 
@@ -82,17 +65,11 @@ public Attribute attribute(int indexAttribute) {
             //All attributes are numeric
             return defaultNumericAttribute();
         }
-        int location = locateIndex(indexAttribute);
-        if (location == -1) {
-            //if there is not attribute information, it is numeric
-            return defaultNumericAttribute();
-        }
-        return attributes.get(location);
+        return attributes.get(indexAttribute);
     }
 
-    public void add(Attribute attribute, int value) {
+    public void add(Attribute attribute) {
         this.attributes.add(attribute);
-        this.indexValues.add(value);
     }
 
     /**
@@ -102,40 +79,6 @@ public void add(Attribute attribute, int value) {
      */
     public void setAttributes(List<Attribute> v) {
         this.attributes = v;
-        this.numberAttributes=v.size();
-    }
-
-    /**
-     * Locates the greatest index that is not greater than the given index.
-     *
-     * @return the internal index of the attribute index. Returns -1 if no index
-     * with this property could be found
-     */
-    public int locateIndex(int index) {
-
-        int min = 0;
-        int max = this.indexValues.size() - 1;
-
-        if (max == -1) {
-            return -1;
-        }
-
-        // Binary search
-        while ((this.indexValues.get(min) <= index) && (this.indexValues.get(max) >= index)) {
-            int current = (max + min) / 2;
-            if (this.indexValues.get(current) > index) {
-                max = current - 1;
-            } else if (this.indexValues.get(current) < index) {
-                min = current + 1;
-            } else {
-                return current;
-            }
-        }
-        if (this.indexValues.get(max) < index) {
-            return max;
-        } else {
-            return min - 1;
-        }
     }
 
     private Attribute defaultNumericAttribute() {
@@ -145,10 +88,8 @@ private Attribute defaultNumericAttribute() {
         return this.defaultNumericAttribute;
     }
 
-	public void setAttributes(List<Attribute> v, List<Integer> indexValues) {
-	        this.attributes = v;
-	        this.numberAttributes=v.size();	
-	        this.indexValues=indexValues;
-	}
-
+    public int numAttributes() {
+    	return attributes.size();
+    }
+    
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/DenseInstance.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/DenseInstance.java
index bae288728..f8bc4b60d 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/DenseInstance.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/DenseInstance.java
@@ -21,6 +21,11 @@
 public class DenseInstance extends InstanceImpl {
 
     /**
+	 * 
+	 */
+	private static final long serialVersionUID = 2470663722464623836L;
+
+	/**
      * Instantiates a new dense instance.
      *
      * @param weight the weight
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/DenseInstanceData.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/DenseInstanceData.java
index c4ec564ff..200e450a3 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/DenseInstanceData.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/DenseInstanceData.java
@@ -22,6 +22,11 @@
 public class DenseInstanceData implements InstanceData{
 
     /**
+	 * 
+	 */
+	private static final long serialVersionUID = 8799186995568094103L;
+
+	/**
      * Instantiates a new dense instance data.
      *
      * @param array the array
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
index 6978bb385..15bd6bb98 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
@@ -17,8 +17,6 @@
 
 import java.io.Serializable;
 
-import moa.AbstractMOAObject;
-
 /**
  * The Interface Instance.
  *
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
index 7484abec2..9305556e3 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
@@ -15,8 +15,6 @@
  */
 package com.yahoo.labs.samoa.instances;
 
-import moa.AbstractMOAObject;
-
 /**
  * The Class InstanceImpl.
  *
@@ -25,6 +23,11 @@
 public class InstanceImpl implements StructuredInstance {
 
     /**
+	 * 
+	 */
+	private static final long serialVersionUID = -7908832747696137766L;
+
+	/**
      * The weight.
      */
     protected double weight;
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
index d9d769f77..ebb0d8940 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
@@ -19,8 +19,6 @@
 import java.util.ArrayList;
 import java.util.List;
 
-import moa.AbstractMOAObject;
-
 /**
  * The Class InstanceInformation.
  *
@@ -28,7 +26,9 @@
  */
 public class InstanceInformation implements Serializable {
 
-    /**
+	private static final long serialVersionUID = 4240189973932498979L;
+
+	/**
      * The dataset's name.
      */
     protected String relationName;
@@ -39,15 +39,25 @@ public class InstanceInformation implements Serializable {
     protected List<Integer> inputIndexes;
     
     
+    /**
+     * Returns the input attribute.
+     * 
+     * @param w the input attribute index (indexes only input attributes)
+     * @return the input attribute.
+     */
     public Attribute inputAttribute(int w) {
         return this.attributesInformation.attribute(inputAttributeIndex(w));
     }
 
+    /**
+     * Returns the output attribute.
+     * 
+     * @param w the output attribute index (indexes only output attributes)
+     * @return the output attribute.
+     */
     public Attribute outputAttribute(int w) {
         return this.attributesInformation.attribute(outputAttributeIndex(w));
     }
-
-    
     
     /**
      * Instantiates a new instance information.
@@ -71,27 +81,16 @@ public InstanceInformation(String st, List<Attribute> attributes, List<Integer>
         this.relationName = st;
         this.outputIndexes = outputIndexes;
         this.inputIndexes = inputIndexes;
-        this.attributesInformation = new AttributesInformation(attributes, attributes.size());
+        this.attributesInformation = new AttributesInformation(attributes);
     }
     
-    public InstanceInformation(String st, List<Attribute> input, List<Integer> indexes) {
-        this.relationName = st;
-        this.outputIndexes = new ArrayList<Integer>();
-        this.inputIndexes = new ArrayList<Integer>();
-        this.attributesInformation = new AttributesInformation(input, indexes, indexes.size());
-    }
-
     public InstanceInformation(String st, List<Attribute> input) {
         this.relationName = st;
         this.outputIndexes = new ArrayList<Integer>();
         this.inputIndexes = new ArrayList<Integer>();
-        List<Integer> indexes = new ArrayList<Integer>();
-        for (int i = 0; i < input.size(); i++) {
-        	indexes.add(i);
-        }
-        this.attributesInformation = new AttributesInformation(input, indexes, indexes.size());
+        this.attributesInformation = new AttributesInformation(input);
     }
-    
+
     /**
      * Instantiates a new instance information.
      */
@@ -143,7 +142,7 @@ public Attribute classAttribute() {
      * @see com.yahoo.labs.samoa.instances.InstanceInformationInterface#numAttributes()
      */
     public int numAttributes() {
-        return this.attributesInformation.numberAttributes;
+        return this.attributesInformation.numAttributes();
     }
 
     /* (non-Javadoc)
@@ -175,7 +174,7 @@ public void insertAttributeAt(Attribute attribute, int i) {
     }
 
     public void setAttributes(List<Attribute> v) {
-    	if(this.attributesInformation==null)
+    	if(this.attributesInformation == null)
     		this.attributesInformation= new AttributesInformation();
         this.attributesInformation.setAttributes(v);
     }
@@ -198,17 +197,21 @@ public int numOutputAttributes() {
 
     	return outputIndexes.size();
     }
-
-	public void setAttributes(List<Attribute> v, List<Integer> indexValues) {
-    	if(this.attributesInformation==null)
-    		this.attributesInformation= new AttributesInformation();
-        this.attributesInformation.setAttributes(v,indexValues);
-	}
-
+    
+    /**
+     * Sets the output attribute indexes, i.e., the targets. 
+     * 
+     * @param outputIndexes
+     */
 	public void setOutputIndexes(List<Integer> outputIndexes) {
 		this.outputIndexes = outputIndexes;
 	}
 	
+	/**
+     * Sets the input attribute indexes. 
+     * 
+     * @param inputIndexes
+     */
 	public void setInputIndexes(List<Integer> inputIndexes) {
 		this.inputIndexes = inputIndexes;
 	}
@@ -218,9 +221,9 @@ public void setInputIndexes(List<Integer> inputIndexes) {
 	 */
 	public void setInputIndexes() {
 		this.inputIndexes = new ArrayList<Integer>();
-		for (int i = 0; i < attributesInformation.indexValues.size(); i++) {
-			if (!outputIndexes.contains(attributesInformation.indexValues.get(i))) {
-				inputIndexes.add(attributesInformation.indexValues.get(i));
+		for (int i = 0; i < attributesInformation.numAttributes(); i++) {
+			if (!outputIndexes.contains(i)) {
+				inputIndexes.add(i);
 			}
 		}
 	}
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
index 421cbb74e..30401fdf5 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
@@ -22,8 +22,6 @@
 import java.util.List;
 import java.util.Random;
 
-import org.junit.experimental.theories.Theories;
-
 import moa.core.Utils;
 
 /**
@@ -33,624 +31,625 @@
  */
 public class InstancesHeader implements Serializable {
 
-    /** The keyword used to denote the start of an arff header */
-    public final static String ARFF_RELATION = "@relation";
-  
-    /** The keyword used to denote the start of the arff data section */
-    public final static String ARFF_DATA = "@data";
-    
-    private static final long serialVersionUID = 1L;
-
-	/**
-     * The instance information.
-     */
-    protected InstanceInformation instanceInformation;
-    /**
-     * The instances.
-     */
-    protected List<Instance> instances;
-
-    /**
-     * The arff.
-     */
-    protected ArffLoader arff;
-
-    /**
-     * Instantiates a new instances.
-     *
-     * @param chunk the chunk
-     */
-    public InstancesHeader(InstancesHeader chunk) {
-        this(chunk, chunk.numInstances());
-        chunk.copyInstances(0, this, chunk.numInstances());
-    }
-
-    /**
-     * Instantiates a new instances.
-     */
-    public InstancesHeader() {
-    }
-
-    /**
-     * Instantiates a new instances.
-     *
-     * @param reader the reader
-     * @param size the size
-     * @param classAttribute the class attribute
-     */
-    public InstancesHeader(Reader reader, int size, int classAttribute) {
-        arff = new ArffLoader(reader, String.valueOf(classAttribute));
-    	this.instanceInformation = arff.instanceInformation;
-        this.instances = new ArrayList<Instance>();
-    }
-
-    public InstancesHeader(Reader reader, String outputDefinition) {
-    	this.arff = new ArffLoader(reader, outputDefinition);
-    	this.instanceInformation = arff.instanceInformation;
-    	this.instances = new ArrayList<Instance>();
-    }
-    
-    public InstancesHeader(Reader reader, String outputDefinition, String inputDefinition) {
-    	this.arff = new ArffLoader(reader, outputDefinition, inputDefinition);
-    	this.instanceInformation = arff.instanceInformation;
-    	this.instances = new ArrayList<Instance>();
-    }
-    
-    public InstancesHeader(Reader reader, int size, String outputDefinition, String inputDefinition) {
-    	this.arff = new ArffLoader(reader, outputDefinition, inputDefinition);
-    	this.instanceInformation = arff.instanceInformation;
-    	this.instances = new ArrayList<Instance>();
-    }
-    
-    /**
-     * Instantiates a new instances.
-     *
-     * @param reader the reader
-     * @param range
-     */
-//    public Instances(Reader reader, Range range) {
-//        this.arff = new MultiTargetArffLoader(reader, range);
-//        this.instanceInformation = arff.getStructure();
-//        this.instances = new ArrayList<Instance>();
-//    }
-
-    /**
-     * Instantiates a new instances.
-     *
-     * @param chunk the chunk
-     * @param capacity the capacity
-     */
-    public InstancesHeader(InstancesHeader chunk, int capacity) {
-        this.instanceInformation = chunk.instanceInformation();
-        if (capacity < 0) {
-            capacity = 0;
-        }
-        this.instances = new ArrayList<Instance>(capacity);
-    }
-
-    /**
-     * Instantiates a new instances.
-     *
-     * @param st the st
-     * @param v the v
-     * @param capacity the capacity
-     */
-    public InstancesHeader(String st, List<Attribute> v, int capacity) {
-        this.instanceInformation = new InstanceInformation(st, v);
-    }
-
-    /**
-     * Instantiates a new instances.
-     *
-     * @param chunk the chunk
-     * @param first the first instance
-     * @param toCopy the j
-     */
-    public InstancesHeader(InstancesHeader chunk, int first, int toCopy) {
-
-        this(chunk, toCopy);
-
-        if ((first < 0) || ((first + toCopy) > chunk.numInstances())) {
-            throw new IllegalArgumentException("Parameters first and/or toCopy out "
-                    + "of range");
-        }
-        chunk.copyInstances(first, this, toCopy);
-    }
-
-    /**
-     * Instantiates a new instances.
-     *
-     * @param st the st
-     * @param capacity the capacity
-     */
-    public InstancesHeader(StringReader st, int capacity) {
-         this.instances = new ArrayList<Instance>(capacity);
-    }
-
-    //Information Instances
-    /**
-     * Sets the relation name.
-     *
-     * @param string the new relation name
-     */
-    public void setRelationName(String string) {
-        this.instanceInformation.setRelationName(string);
-    }
-
-    /**
-     * Gets the relation name.
-     *
-     * @return the relation name
-     */
-    public String getRelationName() {
-        return this.instanceInformation.getRelationName();
-    }
-
-    /**
-     * Class index.
-     *
-     * @return the int
-     */
-    public int classIndex() {
-        return this.instanceInformation.classIndex();
-    }
-
-    /**
-     * Sets the class index. Also sets all other attributes as input attributes for backward compatibility.
-     *
-     * @param classIndex the new class index
-     */
-    public void setClassIndex(int classIndex) {
-        this.instanceInformation.setClassIndex(classIndex);
-        this.instanceInformation.setInputIndexes();
-    }
-
-    public void setOutputIndexes(List<Integer> outputIndexes) {
-        this.instanceInformation.setOutputIndexes(outputIndexes);
-    }
-
-    public void setInputIndexes(List<Integer> inputIndexes) {
-        this.instanceInformation.setInputIndexes(inputIndexes);
-    }
+	/** The keyword used to denote the start of an arff header */
+	public final static String ARFF_RELATION = "@relation";
+
+	/** The keyword used to denote the start of the arff data section */
+	public final static String ARFF_DATA = "@data";
+
+	private static final long serialVersionUID = 1L;
+
+	/**
+	 * The instance information.
+	 */
+	protected InstanceInformation instanceInformation;
+	/**
+	 * The instances.
+	 */
+	protected List<Instance> instances;
+
+	/**
+	 * The arff.
+	 */
+	protected ArffLoader arff;
+
+	/**
+	 * Instantiates a new instances.
+	 *
+	 * @param chunk the chunk
+	 */
+	public InstancesHeader(InstancesHeader chunk) {
+		this(chunk, chunk.numInstances());
+		chunk.copyInstances(0, this, chunk.numInstances());
+	}
+
+	/**
+	 * Instantiates a new instances.
+	 */
+	public InstancesHeader() {
+	}
+
+	/**
+	 * Instantiates a new instances.
+	 *
+	 * @param reader the reader
+	 * @param size the size
+	 * @param classAttribute the class attribute
+	 */
+	public InstancesHeader(Reader reader, int size, int classAttribute) {
+		arff = new ArffLoader(reader, String.valueOf(classAttribute));
+		this.instanceInformation = arff.instanceInformation;
+		this.instances = new ArrayList<Instance>();
+	}
+
+	/**
+	 * Instantiates a new intances header.
+	 * 
+	 * @param reader 
+	 * @param outputDefinition defines the output attributes (others are treated as inputs)
+	 */
+	public InstancesHeader(Reader reader, String outputDefinition) {
+		this.arff = new ArffLoader(reader, outputDefinition);
+		this.instanceInformation = arff.instanceInformation;
+		this.instances = new ArrayList<Instance>();
+	}
+
+	/**
+	 * Instantiates a new intances header.
+	 * 
+	 * @param reader
+	 * @param outputDefinition defines the output attributes
+	 * @param inputDefinition defines the input attributes
+	 */
+	public InstancesHeader(Reader reader, String outputDefinition, String inputDefinition) {
+		this.arff = new ArffLoader(reader, outputDefinition, inputDefinition);
+		this.instanceInformation = arff.instanceInformation;
+		this.instances = new ArrayList<Instance>();
+	}
+
+	/**
+	 * Instantiates a new instances.
+	 *
+	 * @param reader the reader
+	 * @param range
+	 */
+	//    public Instances(Reader reader, Range range) {
+	//        this.arff = new MultiTargetArffLoader(reader, range);
+	//        this.instanceInformation = arff.getStructure();
+	//        this.instances = new ArrayList<Instance>();
+	//    }
+
+	/**
+	 * Instantiates a new instances.
+	 *
+	 * @param chunk the chunk
+	 * @param capacity the capacity
+	 */
+	public InstancesHeader(InstancesHeader chunk, int capacity) {
+		this.instanceInformation = chunk.instanceInformation();
+		if (capacity < 0) {
+			capacity = 0;
+		}
+		this.instances = new ArrayList<Instance>(capacity);
+	}
+
+	/**
+	 * Instantiates a new instances.
+	 *
+	 * @param st the st
+	 * @param v the v
+	 * @param capacity the capacity
+	 */
+	public InstancesHeader(String st, List<Attribute> v, int capacity) {
+		this.instanceInformation = new InstanceInformation(st, v);
+	}
+
+	/**
+	 * Instantiates a new instances.
+	 *
+	 * @param chunk the chunk
+	 * @param first the first instance
+	 * @param toCopy the j
+	 */
+	public InstancesHeader(InstancesHeader chunk, int first, int toCopy) {
+
+		this(chunk, toCopy);
+
+		if ((first < 0) || ((first + toCopy) > chunk.numInstances())) {
+			throw new IllegalArgumentException("Parameters first and/or toCopy out "
+					+ "of range");
+		}
+		chunk.copyInstances(first, this, toCopy);
+	}
+
+	/**
+	 * Instantiates a new instances.
+	 *
+	 * @param st the st
+	 * @param capacity the capacity
+	 */
+	public InstancesHeader(StringReader st, int capacity) {
+		this.instances = new ArrayList<Instance>(capacity);
+	}
+
+	//Information Instances
+	/**
+	 * Sets the relation name.
+	 *
+	 * @param string the new relation name
+	 */
+	public void setRelationName(String string) {
+		this.instanceInformation.setRelationName(string);
+	}
+
+	/**
+	 * Gets the relation name.
+	 *
+	 * @return the relation name
+	 */
+	public String getRelationName() {
+		return this.instanceInformation.getRelationName();
+	}
+
+	/**
+	 * Class index.
+	 *
+	 * @return the int
+	 */
+	public int classIndex() {
+		return this.instanceInformation.classIndex();
+	}
+
+	/**
+	 * Sets the class index. Also sets all other attributes as input attributes for backward compatibility.
+	 *
+	 * @param classIndex the new class index
+	 */
+	public void setClassIndex(int classIndex) {
+		this.instanceInformation.setClassIndex(classIndex);
+		this.instanceInformation.setInputIndexes();
+	}
+
+	public void setOutputIndexes(List<Integer> outputIndexes) {
+		this.instanceInformation.setOutputIndexes(outputIndexes);
+	}
+
+	public void setInputIndexes(List<Integer> inputIndexes) {
+		this.instanceInformation.setInputIndexes(inputIndexes);
+	}
 
 	/** 
 	 * Sets all non-output attributes as input attributes.
 	 */
 	public void setInputIndexes() {
-        this.instanceInformation.setInputIndexes();
-	}
-    
-    /**
-     * Class attribute.
-     *
-     * @return the attribute
-     */
-    public Attribute classAttribute() {
-        return this.instanceInformation.classAttribute();
-    }
-
-    /**
-     * Num attributes.
-     *
-     * @return the int
-     */
-    public int numAttributes() {
-        return this.instanceInformation.numAttributes();
-    }
-
-    /**
-     * Attribute.
-     *
-     * @param w the w
-     * @return the attribute
-     */
-    public Attribute attribute(int w) {
-        return this.instanceInformation.attribute(w);
-    }
-
-    /**
-     * Num classes.
-     *
-     * @return the int
-     */
-    public int numClasses() {
-        return this.instanceInformation.numClasses();
-    }
-
-    /**
-     * Delete attribute at.
-     *
-     * @param integer the integer
-     */
-    public void deleteAttributeAt(Integer integer) {
-        this.instanceInformation.deleteAttributeAt(integer);
-    }
-
-    /**
-     * Insert attribute at.
-     *
-     * @param attribute the attribute
-     * @param i the i
-     */
-    public void insertAttributeAt(Attribute attribute, int i) {
-    	if (this.instanceInformation==null)
-    		this.instanceInformation= new InstanceInformation();
-        this.instanceInformation.insertAttributeAt(attribute, i);
-    }
-
-    //List of Instances
-    /**
-     * Instance.
-     *
-     * @param num the num
-     * @return the instance
-     */
-    public Instance instance(int num) {
-        return this.instances.get(num);
-    }
-
-    /**
-     * Num instances.
-     *
-     * @return the int
-     */
-    public int numInstances() {
-        return this.instances.size();
-    }
-
-    /**
-     * Adds the.
-     *
-     * @param inst the inst
-     */
-    public void add(Instance inst) {
-        this.instances.add(inst.copy());
-    }
-
-    /**
-     * Randomize.
-     *
-     * @param random the random
-     */
-    public void randomize(Random random) {
-        for (int j = numInstances() - 1; j > 0; j--) {
-            swap(j, random.nextInt(j + 1));
-        }
-    }
-
-    /**
-     * Stratify.
-     *
-     * @param numFolds the num folds
-     */
-    public void stratify(int numFolds) {
-
-        if (classAttribute().isNominal()) {
-
-            // sort by class
-            int index = 1;
-            while (index < numInstances()) {
-                Instance instance1 = instance(index - 1);
-                for (int j = index; j < numInstances(); j++) {
-                    Instance instance2 = instance(j);
-                    if ((instance1.classValue() == instance2.classValue())
-                            || (instance1.classIsMissing()
-                            && instance2.classIsMissing())) {
-                        swap(index, j);
-                        index++;
-                    }
-                }
-                index++;
-            }
-            stratStep(numFolds);
-        }
-    }
-
-    protected void stratStep(int numFolds) {
-        ArrayList<Instance> newVec = new ArrayList<Instance>(this.instances.size());
-        int start = 0, j;
-
-        // create stratified batch
-        while (newVec.size() < numInstances()) {
-            j = start;
-            while (j < numInstances()) {
-                newVec.add(instance(j));
-                j = j + numFolds;
-            }
-            start++;
-        }
-        this.instances = newVec;
-    }
-
-    /**
-     * Train cv.
-     *
-     * @param numFolds the num folds
-     * @param numFold
-     * @param n the n
-     * @param random the random
-     * @return the instances
-     */
-    public InstancesHeader trainCV(int numFolds, int numFold, Random random) {
-        InstancesHeader train = trainCV(numFolds, numFold);
-        train.randomize(random);
-        return train;
-    }
-
-    public InstancesHeader trainCV(int numFolds, int numFold) {
-        int numInstForFold, first, offset;
-        InstancesHeader train;
-
-        numInstForFold = numInstances() / numFolds;
-        if (numFold < numInstances() % numFolds) {
-            numInstForFold++;
-            offset = numFold;
-        } else {
-            offset = numInstances() % numFolds;
-        }
-        train = new InstancesHeader(this, numInstances() - numInstForFold);
-        first = numFold * (numInstances() / numFolds) + offset;
-        copyInstances(0, train, first);
-        copyInstances(first + numInstForFold, train,
-                numInstances() - first - numInstForFold);
-        return train;
-    }
-
-    protected void copyInstances(int from, InstancesHeader dest, int num) {
-        for (int i = 0; i < num; i++) {
-            dest.add(instance(from + i));
-        }
-    }
-
-    /**
-     * Test cv.
-     *
-     * @param numFolds the num folds
-     * @param numFold the num fold
-     * @return the instances
-     */
-    public InstancesHeader testCV(int numFolds, int numFold) {
-
-        int numInstForFold, first, offset;
-        InstancesHeader test;
-
-        numInstForFold = numInstances() / numFolds;
-        if (numFold < numInstances() % numFolds) {
-            numInstForFold++;
-            offset = numFold;
-        } else {
-            offset = numInstances() % numFolds;
-        }
-        test = new InstancesHeader(this, numInstForFold);
-        first = numFold * (numInstances() / numFolds) + offset;
-        copyInstances(first, test, numInstForFold);
-        return test;
-    }
-
-    /*  public Instances dataset() {
+		this.instanceInformation.setInputIndexes();
+	}
+
+	/**
+	 * Class attribute.
+	 *
+	 * @return the attribute
+	 */
+	public Attribute classAttribute() {
+		return this.instanceInformation.classAttribute();
+	}
+
+	/**
+	 * Num attributes.
+	 *
+	 * @return the int
+	 */
+	public int numAttributes() {
+		return this.instanceInformation.numAttributes();
+	}
+
+	/**
+	 * Attribute.
+	 *
+	 * @param w the w
+	 * @return the attribute
+	 */
+	public Attribute attribute(int w) {
+		return this.instanceInformation.attribute(w);
+	}
+
+	/**
+	 * Num classes.
+	 *
+	 * @return the int
+	 */
+	public int numClasses() {
+		return this.instanceInformation.numClasses();
+	}
+
+	/**
+	 * Delete attribute at.
+	 *
+	 * @param integer the integer
+	 */
+	public void deleteAttributeAt(Integer integer) {
+		this.instanceInformation.deleteAttributeAt(integer);
+	}
+
+	/**
+	 * Insert attribute at.
+	 *
+	 * @param attribute the attribute
+	 * @param i the i
+	 */
+	public void insertAttributeAt(Attribute attribute, int i) {
+		if (this.instanceInformation==null)
+			this.instanceInformation= new InstanceInformation();
+		this.instanceInformation.insertAttributeAt(attribute, i);
+	}
+
+	//List of Instances
+	/**
+	 * Instance.
+	 *
+	 * @param num the num
+	 * @return the instance
+	 */
+	public Instance instance(int num) {
+		return this.instances.get(num);
+	}
+
+	/**
+	 * Num instances.
+	 *
+	 * @return the int
+	 */
+	public int numInstances() {
+		return this.instances.size();
+	}
+
+	/**
+	 * Adds the.
+	 *
+	 * @param inst the inst
+	 */
+	public void add(Instance inst) {
+		this.instances.add(inst.copy());
+	}
+
+	/**
+	 * Randomize.
+	 *
+	 * @param random the random
+	 */
+	public void randomize(Random random) {
+		for (int j = numInstances() - 1; j > 0; j--) {
+			swap(j, random.nextInt(j + 1));
+		}
+	}
+
+	/**
+	 * Stratify.
+	 *
+	 * @param numFolds the num folds
+	 */
+	public void stratify(int numFolds) {
+
+		if (classAttribute().isNominal()) {
+
+			// sort by class
+			int index = 1;
+			while (index < numInstances()) {
+				Instance instance1 = instance(index - 1);
+				for (int j = index; j < numInstances(); j++) {
+					Instance instance2 = instance(j);
+					if ((instance1.classValue() == instance2.classValue())
+							|| (instance1.classIsMissing()
+									&& instance2.classIsMissing())) {
+						swap(index, j);
+						index++;
+					}
+				}
+				index++;
+			}
+			stratStep(numFolds);
+		}
+	}
+
+	protected void stratStep(int numFolds) {
+		ArrayList<Instance> newVec = new ArrayList<Instance>(this.instances.size());
+		int start = 0, j;
+
+		// create stratified batch
+		while (newVec.size() < numInstances()) {
+			j = start;
+			while (j < numInstances()) {
+				newVec.add(instance(j));
+				j = j + numFolds;
+			}
+			start++;
+		}
+		this.instances = newVec;
+	}
+
+	/**
+	 * Train cv.
+	 *
+	 * @param numFolds the num folds
+	 * @param numFold
+	 * @param n the n
+	 * @param random the random
+	 * @return the instances
+	 */
+	public InstancesHeader trainCV(int numFolds, int numFold, Random random) {
+		InstancesHeader train = trainCV(numFolds, numFold);
+		train.randomize(random);
+		return train;
+	}
+
+	public InstancesHeader trainCV(int numFolds, int numFold) {
+		int numInstForFold, first, offset;
+		InstancesHeader train;
+
+		numInstForFold = numInstances() / numFolds;
+		if (numFold < numInstances() % numFolds) {
+			numInstForFold++;
+			offset = numFold;
+		} else {
+			offset = numInstances() % numFolds;
+		}
+		train = new InstancesHeader(this, numInstances() - numInstForFold);
+		first = numFold * (numInstances() / numFolds) + offset;
+		copyInstances(0, train, first);
+		copyInstances(first + numInstForFold, train,
+				numInstances() - first - numInstForFold);
+		return train;
+	}
+
+	protected void copyInstances(int from, InstancesHeader dest, int num) {
+		for (int i = 0; i < num; i++) {
+			dest.add(instance(from + i));
+		}
+	}
+
+	/**
+	 * Test cv.
+	 *
+	 * @param numFolds the num folds
+	 * @param numFold the num fold
+	 * @return the instances
+	 */
+	public InstancesHeader testCV(int numFolds, int numFold) {
+
+		int numInstForFold, first, offset;
+		InstancesHeader test;
+
+		numInstForFold = numInstances() / numFolds;
+		if (numFold < numInstances() % numFolds) {
+			numInstForFold++;
+			offset = numFold;
+		} else {
+			offset = numInstances() % numFolds;
+		}
+		test = new InstancesHeader(this, numInstForFold);
+		first = numFold * (numInstances() / numFolds) + offset;
+		copyInstances(first, test, numInstForFold);
+		return test;
+	}
+
+	/*  public Instances dataset() {
      throw new UnsupportedOperationException("Not yet implemented");
      }*/
-    /**
-     * Mean or mode.
-     *
-     * @param j the j
-     * @return the double
-     */
-    public double meanOrMode(int j) {
-        throw new UnsupportedOperationException("Not yet implemented"); //CobWeb
-    }
-
-    /**
-     * Read instance.
-     *
-     * @param fileReader the file reader
-     * @return true, if successful
-     */
-    public boolean readInstance(Reader fileReader) {
-
-        //ArffReader arff = new ArffReader(reader, this, m_Lines, 1);
-        Instance inst = arff.readInstance();
-        if (inst != null) {
-            inst.setDataset(this);
-            add(inst);
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    /**
-     * Delete.
-     */
-    public void delete() {
-        this.instances = new ArrayList<Instance>();
-    }
-    
-     /**
-     * Delete.
-     */
-    public void delete(int index) {
-        this.instances.remove(index);
-    }
-
-
-    /**
-     * Swap.
-     *
-     * @param i the i
-     * @param j the j
-     */
-    public void swap(int i, int j) {
-        Instance in = instances.get(i);
-        instances.set(i, instances.get(j));
-        instances.set(j, in);
-    }
-
-    /**
-     * Instance information.
-     *
-     * @return the instance information
-     */
-    private InstanceInformation instanceInformation() {
-        return this.instanceInformation;
-    }
-
-    public Attribute attribute(String name) {
-
-        for (int i = 0; i < numAttributes(); i++) {
-            if (attribute(i).name().equals(name)) {
-                return attribute(i);
-            }
-        }
-        return null;
-    }
-
-    public int size() {
-        return this.numInstances();
-    }
-
-    public void set(int i, Instance inst) {
-        this.instances.set(i, inst);
-    }
-
-    public Instance get(int k) {
-        return this.instance(k);
-    }
-
-//	public void setRangeOutputIndices(Range range) {
-//		this.instanceInformation.setRangeOutputIndices(range);
-//		
-//	}
-	
-    public void setAttributes(List<Attribute> v) {
-    	if(this.instanceInformation==null)
-    		this.instanceInformation= new InstanceInformation();
-        this.instanceInformation.setAttributes(v);
-    }
-    
-    public void setAttributes(List<Attribute> v, List<Integer> indexValues) {
-    	if(this.instanceInformation==null)
-    		this.instanceInformation= new InstanceInformation();
-        this.instanceInformation.setAttributes(v, indexValues);
-    }
-    
-      /**
-   * Returns the dataset as a string in ARFF format. Strings
-   * are quoted if they contain whitespace characters, or if they
-   * are a question mark.
-   *
-   * @return the dataset in ARFF format as a string
-   */
-  public String toString() {
-    
-    StringBuffer text = new StringBuffer();
-    
-    text.append(ARFF_RELATION).append(" ").
-      append(Utils.quote( this.instanceInformation.getRelationName())).append("\n\n");
-    for (int i = 0; i < numAttributes(); i++) {
-      text.append(attribute(i).toString()).append("\n");
-    }
-    text.append("\n").append(ARFF_DATA).append("\n");
-
-    text.append(stringWithoutHeader());
-    return text.toString();
-  }
-  
-    /**
-   * Returns the instances in the dataset as a string in ARFF format. Strings
-   * are quoted if they contain whitespace characters, or if they
-   * are a question mark.
-   *
-   * @return the dataset in ARFF format as a string
-   */
-  protected String stringWithoutHeader() {
-    
-    StringBuffer text = new StringBuffer();
-
-    for (int i = 0; i < numInstances(); i++) {
-      text.append(instance(i));
-      if (i < numInstances() - 1) {
-	text.append('\n');
-      }
-    }
-    return text.toString();
-    
-  }
+	/**
+	 * Mean or mode.
+	 *
+	 * @param j the j
+	 * @return the double
+	 */
+	public double meanOrMode(int j) {
+		throw new UnsupportedOperationException("Not yet implemented"); //CobWeb
+	}
+
+	/**
+	 * Read instance.
+	 *
+	 * @param fileReader the file reader
+	 * @return true, if successful
+	 */
+	public boolean readInstance(Reader fileReader) {
+
+		//ArffReader arff = new ArffReader(reader, this, m_Lines, 1);
+		Instance inst = arff.readInstance();
+		if (inst != null) {
+			inst.setDataset(this);
+			add(inst);
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	/**
+	 * Delete.
+	 */
+	public void delete() {
+		this.instances = new ArrayList<Instance>();
+	}
+
+	/**
+	 * Delete.
+	 */
+	public void delete(int index) {
+		this.instances.remove(index);
+	}
+
+
+	/**
+	 * Swap.
+	 *
+	 * @param i the i
+	 * @param j the j
+	 */
+	public void swap(int i, int j) {
+		Instance in = instances.get(i);
+		instances.set(i, instances.get(j));
+		instances.set(j, in);
+	}
+
+	/**
+	 * Instance information.
+	 *
+	 * @return the instance information
+	 */
+	private InstanceInformation instanceInformation() {
+		return this.instanceInformation;
+	}
+
+	public Attribute attribute(String name) {
+
+		for (int i = 0; i < numAttributes(); i++) {
+			if (attribute(i).name().equals(name)) {
+				return attribute(i);
+			}
+		}
+		return null;
+	}
+
+	public int size() {
+		return this.numInstances();
+	}
+
+	public void set(int i, Instance inst) {
+		this.instances.set(i, inst);
+	}
+
+	public Instance get(int k) {
+		return this.instance(k);
+	}
+
+	//	public void setRangeOutputIndices(Range range) {
+	//		this.instanceInformation.setRangeOutputIndices(range);
+	//		
+	//	}
+
+	public void setAttributes(List<Attribute> v) {
+		if(this.instanceInformation==null)
+			this.instanceInformation= new InstanceInformation();
+		this.instanceInformation.setAttributes(v);
+	}
+
+	/**
+	 * Returns the dataset as a string in ARFF format. Strings
+	 * are quoted if they contain whitespace characters, or if they
+	 * are a question mark.
+	 *
+	 * @return the dataset in ARFF format as a string
+	 */
+	public String toString() {
+
+		StringBuffer text = new StringBuffer();
+
+		text.append(ARFF_RELATION).append(" ").
+		append(Utils.quote( this.instanceInformation.getRelationName())).append("\n\n");
+		for (int i = 0; i < numAttributes(); i++) {
+			text.append(attribute(i).toString()).append("\n");
+		}
+		text.append("\n").append(ARFF_DATA).append("\n");
+
+		text.append(stringWithoutHeader());
+		return text.toString();
+	}
+
+	/**
+	 * Returns the instances in the dataset as a string in ARFF format. Strings
+	 * are quoted if they contain whitespace characters, or if they
+	 * are a question mark.
+	 *
+	 * @return the dataset in ARFF format as a string
+	 */
+	protected String stringWithoutHeader() {
+
+		StringBuffer text = new StringBuffer();
+
+		for (int i = 0; i < numInstances(); i++) {
+			text.append(instance(i));
+			if (i < numInstances() - 1) {
+				text.append('\n');
+			}
+		}
+		return text.toString();
+
+	}
 
 	public Attribute inputAttribute(int w) {
-	    return this.instanceInformation.inputAttribute(w);
+		return this.instanceInformation.inputAttribute(w);
 	}
 
 	public Attribute outputAttribute(int w) {
-	    return this.instanceInformation.outputAttribute(w);
+		return this.instanceInformation.outputAttribute(w);
 	}
 
 	public int numInputAttributes() {
-	    return this.instanceInformation.numInputAttributes();
+		return this.instanceInformation.numInputAttributes();
 	}
 
 	public int numOutputAttributes() {
-	    return this.instanceInformation.numOutputAttributes();
+		return this.instanceInformation.numOutputAttributes();
 	}
 
 	public InstanceInformation getInstanceInformation() {
-	    return this.instanceInformation;
+		return this.instanceInformation;
 	}
 
 	public static String getClassNameString(InstancesHeader context) {
-	    if (context == null) {
-	        return "[class]";
-	    }
-	    return "[class:" + context.classAttribute().name() + "]";
+		if (context == null) {
+			return "[class]";
+		}
+		return "[class:" + context.classAttribute().name() + "]";
 	}
 
 	public static String getClassLabelString(InstancesHeader context, int classLabelIndex) {
-	    if ((context == null) || (classLabelIndex >= context.numClasses())) {
-	        return "<class " + (classLabelIndex + 1) + ">";
-	    }
-	    return "<class " + (classLabelIndex + 1) + ":"
-	            + context.classAttribute().value(classLabelIndex) + ">";
+		if ((context == null) || (classLabelIndex >= context.numClasses())) {
+			return "<class " + (classLabelIndex + 1) + ">";
+		}
+		return "<class " + (classLabelIndex + 1) + ":"
+		+ context.classAttribute().value(classLabelIndex) + ">";
 	}
 
 	public static String getAttributeNameString(InstancesHeader context, int attIndex) {
-	    if ((context == null) || (attIndex >= context.numAttributes())) {
-	        return "[att " + (attIndex + 1) + "]";
-	    }
-	    return "[att " + (attIndex + 1) + ":"
-	            + context.attribute(attIndex).name() + "]";
+		if ((context == null) || (attIndex >= context.numAttributes())) {
+			return "[att " + (attIndex + 1) + "]";
+		}
+		return "[att " + (attIndex + 1) + ":"
+		+ context.attribute(attIndex).name() + "]";
 	}
 
 	public static String getInputAttributeNameString(InstancesHeader context, int attIndex) {
-	    if ((context == null) || (attIndex >= context.numInputAttributes())) {
-	        return "[att " + (attIndex + 1) + "]";
-	    }
-	    return "[att " + (attIndex + 1) + ":"
-	            + context.inputAttribute(attIndex).name() + "]";
+		if ((context == null) || (attIndex >= context.numInputAttributes())) {
+			return "[att " + (attIndex + 1) + "]";
+		}
+		return "[att " + (attIndex + 1) + ":"
+		+ context.inputAttribute(attIndex).name() + "]";
 	}
 
 	public static String getNominalValueString(InstancesHeader context, int attIndex, int valIndex) {
-	    if (context != null) {
-	        if ((attIndex < context.numInputAttributes())
-	                && (valIndex < context.inputAttribute(attIndex).numValues())) {
-	            return "{val " + (valIndex + 1) + ":"
-	                    + context.inputAttribute(attIndex).value(valIndex) + "}";
-	        }
-	    }
-	    return "{val " + (valIndex + 1) + "}";
+		if (context != null) {
+			if ((attIndex < context.numInputAttributes())
+					&& (valIndex < context.inputAttribute(attIndex).numValues())) {
+				return "{val " + (valIndex + 1) + ":"
+						+ context.inputAttribute(attIndex).value(valIndex) + "}";
+			}
+		}
+		return "{val " + (valIndex + 1) + "}";
 	}
 
 	public static String getNumericValueString(InstancesHeader context, int attIndex, double value) {
-	    if (context != null) {
-	        int instAttIndex = attIndex < context.classIndex() ? attIndex
-	                : attIndex + 1;
-	        if (instAttIndex < context.numAttributes()) {
-	            if (context.attribute(instAttIndex).isDate()) {
-	                return context.attribute(instAttIndex).formatDate(value);
-	            }
-	        }
-	    }
-	    return Double.toString(value);
-	}
-
-	
+		if (context != null) {
+			int instAttIndex = attIndex < context.classIndex() ? attIndex
+					: attIndex + 1;
+			if (instAttIndex < context.numAttributes()) {
+				if (context.attribute(instAttIndex).isDate()) {
+					return context.attribute(instAttIndex).formatDate(value);
+				}
+			}
+		}
+		return Double.toString(value);
+	}
+
+
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
index 12b35c5a3..7e8fb2bdc 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
@@ -18,6 +18,11 @@
 import java.io.Serializable;
 
 public class MultiLabelPrediction implements Prediction, Serializable {
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 1413498152667626736L;
+	
 	protected DoubleVector [] prediction;
 
 	public MultiLabelPrediction() {
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/Range.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/Range.java
deleted file mode 100644
index d02e5fbbc..000000000
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/Range.java
+++ /dev/null
@@ -1,110 +0,0 @@
-
-/*
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
- * either express or implied. See the License for the specific
- * language governing permissions and limitations under the
- * License.  
- */
-package com.yahoo.labs.samoa.instances;
-
-import java.io.Serializable;
-
-public class Range implements Serializable {
-
-    //Only works for ranges "start-end"
-    private int start = 0;
-    private int end = 0;
-    private int upperLimit = 0;
-    private final String rangeText;
-
-    public Range(String range) {
-        this.rangeText = range;
-        //this.setRange(range); //needs upperLimit
-    }
-
-    /**
-     * Sets the range from a string representation.
-     *
-     * @param range the start and end string
-     *
-     */
-    public void setRange(String range) {
-        String single = range.trim();
-        int hyphenIndex = range.indexOf('-');
-
-        if (hyphenIndex > 0) {
-            this.start = rangeSingle(range.substring(0, hyphenIndex));
-            this.end = rangeSingle(range.substring(hyphenIndex + 1));
-        } else {
-            int number = rangeSingle(range);
-            if (number >= 0) { // first n attributes
-                this.start = 0;
-                this.end = number;
-            } else { // last n attributes
-                this.start = this.upperLimit + number > 0 ? this.upperLimit + number : 0;
-                this.end = this.upperLimit - 1;
-            }
-        }
-    }
-
-    /**
-     * Translates a single string selection into it's internal 0-based
-     * equivalent.
-     *
-     * @param single the string representing the selection (eg: 1 first last)
-     * @return the number corresponding to the selected value
-     */
-    protected /*@pure@*/ int rangeSingle(/*@non_null@*/String singleSelection) {
-
-        String single = singleSelection.trim();
-        if (single.toLowerCase().equals("first")) {
-            return 0;
-        }
-        if (single.toLowerCase().equals("last") || single.toLowerCase().equals("-1")) {
-            return -1;
-        }
-        int index = Integer.parseInt(single);
-        if (index >= 1) { //Non for negatives
-            index--;
-        }
-        return index;
-    }
-
-    boolean isInRange(int value) {
-        boolean ret = false;
-        if (value >= start && value <= end) {
-            ret = true;
-        }
-        return ret;
-    }
-
-    int getSelectionLength() {
-        return end - start + 1;
-    }
-
-    public void setUpper(int attributeNumber) {
-        this.upperLimit = attributeNumber;
-        this.setRange(this.rangeText);
-    }
-
-    //JD
-    public int getStart() {
-        return start;
-    }
-
-    //JD
-
-    public int getEnd() {
-        return end;
-    }
-
-}
diff --git a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
index 070665e55..7ac2b2825 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
@@ -7,7 +7,6 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
@@ -23,6 +22,11 @@
 public class LocalMultiTargetClassifier extends AbstractMultiLabelLearner
 		implements MultiLabelClassifier, MultiTargetRegressor {
 
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 5437749202546674734L;
+
 	public ClassOption classifierOption = new ClassOption(
 			"classifier",
 			'c',
@@ -50,15 +54,12 @@ private void makeHeaders() {
 			headers = new ArrayList<InstancesHeader>();
 			for (int target = 0; target < getModelContext().numOutputAttributes(); target++) {
 				List<Attribute> attributes = new ArrayList<Attribute>();
-				List<Integer> indexValues = new ArrayList<Integer>();
 				for (int i = 0; i < getModelContext().numInputAttributes(); i++) {
 					attributes.add(getModelContext().inputAttribute(i));
-					indexValues.add(i);
 				}
 				attributes.add(getModelContext().outputAttribute(target));
-				indexValues.add(getModelContext().numInputAttributes());
 				InstancesHeader STHeader = new InstancesHeader();
-				STHeader.setAttributes(attributes, indexValues);
+				STHeader.setAttributes(attributes);
 				STHeader.setClassIndex(getModelContext().numInputAttributes());
 				headers.add(STHeader);
 			}
diff --git a/moa/src/main/java/moa/streams/ArffFileStream.java b/moa/src/main/java/moa/streams/ArffFileStream.java
index 5d0d10ef9..81d639198 100644
--- a/moa/src/main/java/moa/streams/ArffFileStream.java
+++ b/moa/src/main/java/moa/streams/ArffFileStream.java
@@ -155,7 +155,7 @@ public void restart() {
             this.fileProgressMonitor = new InputStreamProgressMonitor(
                     fileStream);
             this.fileReader = new BufferedReader(new InputStreamReader(this.fileProgressMonitor));
-            this.instances = new InstancesHeader(this.fileReader, 1, this.outputIndexesOption.getValue(), this.inputIndexesOption.getValue());
+            this.instances = new InstancesHeader(this.fileReader, this.outputIndexesOption.getValue(), this.inputIndexesOption.getValue());
             this.numInstancesRead = 0;
             this.lastInstanceRead = null;
             this.hitEndOfFile = !readNextInstanceFromFile();
diff --git a/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java b/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java
index 80e2ae84f..9ade14c76 100644
--- a/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java
+++ b/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java
@@ -28,7 +28,6 @@
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.Reader; 
-import com.github.javacliparser.RangeOption;  // jesse
 import moa.core.InputStreamProgressMonitor;
 import moa.core.InstanceExample;
 import moa.core.ObjectRepository;
diff --git a/moa/src/main/java/moa/streams/clustering/FileStream.java b/moa/src/main/java/moa/streams/clustering/FileStream.java
index 7ef557add..bd8458fff 100644
--- a/moa/src/main/java/moa/streams/clustering/FileStream.java
+++ b/moa/src/main/java/moa/streams/clustering/FileStream.java
@@ -38,6 +38,8 @@
 import moa.core.InstanceExample;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
+import moa.core.utils.AttributeDefinitionUtil;
+
 import com.github.javacliparser.FileOption;
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.IntOption;
@@ -48,7 +50,6 @@
 import moa.tasks.TaskMonitor;
 
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public class FileStream extends ClusteringStream{
 
@@ -65,11 +66,6 @@ public String getPurposeString() {
 	public FileOption arffFileOption = new FileOption("arffFile", 'f',
 			"ARFF file to load.", defaultfile, "arff", false);
 
-//	public IntOption classIndexOption = new IntOption(
-//			"classIndex",
-//			'c',
-//			"Class index of data. 0 for none or -1 for last attribute in file.",
-//			-1, -1, Integer.MAX_VALUE);
 
     public StringOption outputIndicesOption = new StringOption(
     		"outputIndices",
@@ -81,7 +77,7 @@ public String getPurposeString() {
     		"outputIndices",
     		'i',
     		"Indices of input (class) attributes. Can be provided in a comma or semicolon separated list of single values or ranges. Leave blank for all non-output attributes.",
-    		"");
+    		AttributeDefinitionUtil.nonIgnoredDefinition);
 	
     public FlagOption normalizeOption = 
     		new FlagOption("normalize", 'n', 
@@ -169,7 +165,7 @@ public void restart() {
 			InputStream fileStream = new FileInputStream(arffFileOption.getFile());
 			fileProgressMonitor = new InputStreamProgressMonitor(fileStream);
 			fileReader = new BufferedReader(new InputStreamReader(fileProgressMonitor));
-            instances = new InstancesHeader(fileReader, 1, this.outputIndicesOption.getValue(), this.inputIndicesOption.getValue());
+            instances = new InstancesHeader(fileReader, this.outputIndicesOption.getValue(), this.inputIndicesOption.getValue());
 
 
 			//use hashset to delete duplicates and attributes numbers that aren't valid
@@ -287,7 +283,7 @@ protected ArrayList<Double[]> readMinMaxDiffValues(HashSet<Integer> ignoredAttri
 			InputStream fileStream = new FileInputStream(arffFileOption.getFile());
 			InputStreamProgressMonitor fileProgressMonitor = new InputStreamProgressMonitor(fileStream);
 			Reader fileReader = new BufferedReader(new InputStreamReader(fileProgressMonitor));
-            InstancesHeader instances = new InstancesHeader(fileReader, 1, this.outputIndicesOption.getValue(), this.inputIndicesOption.getValue());
+            InstancesHeader instances = new InstancesHeader(fileReader, this.outputIndicesOption.getValue(), this.inputIndicesOption.getValue());
 
 			valuesMinMaxDiff = new ArrayList<Double[]>();
 			for (int i = 0; i < instances.numAttributes()-ignoredAttributes.size(); i++) {
diff --git a/moa/src/main/java/moa/streams/filters/RBFFilter.java b/moa/src/main/java/moa/streams/filters/RBFFilter.java
index bf90b324c..df300eb65 100644
--- a/moa/src/main/java/moa/streams/filters/RBFFilter.java
+++ b/moa/src/main/java/moa/streams/filters/RBFFilter.java
@@ -5,15 +5,12 @@
 import java.util.Random;
 
 import moa.core.InstanceExample;
-import moa.streams.MultiTargetInstanceStream;
 
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceImpl;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.Range;
 
 public class RBFFilter extends AbstractStreamFilter {
 
@@ -53,14 +50,12 @@ public InstanceExample nextInstance() {
 
 		int d = x.numAttributes();
 		int h = numLatentOption.getValue();
-		int j_c = x.classIndex();
 
 		for(int k = 0; k < h; k++) {
 			double sum_k = 0.;
 			for(int j = 0; j < d; j++) {
 				sum_k += (x.value(j) - c[k]);
 			}
-			double v = sum_k / Math.pow(r[k],2);
 			z.setValue(k,Math.exp(-sum_k));
 		}
 		z.setValue(h,x.classValue());
@@ -100,7 +95,7 @@ private void initialize(Instance instance) {
 		indexValues.add(h);
 
 
-		ds.setAttributes(v,indexValues);
+		ds.setAttributes(v);
 		dataset=(new InstancesHeader(ds));
 		dataset.setClassIndex(h);
 		System.out.println(""+dataset);
diff --git a/moa/src/main/java/moa/streams/filters/ReLUFilter.java b/moa/src/main/java/moa/streams/filters/ReLUFilter.java
index 3f6eb7f55..4023e2194 100644
--- a/moa/src/main/java/moa/streams/filters/ReLUFilter.java
+++ b/moa/src/main/java/moa/streams/filters/ReLUFilter.java
@@ -4,16 +4,11 @@
 import java.util.List;
 import java.util.Random;
 
-import moa.core.InstanceExample;
-import moa.streams.MultiTargetInstanceStream;
-
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceImpl;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.Range;
 
 public class ReLUFilter extends AbstractStreamFilter {
 
@@ -111,7 +106,7 @@ private void initialize(Instance instance) {
 		indexValues.add(H);
 
 
-		ds.setAttributes(v,indexValues);
+		ds.setAttributes(v);
 		dataset=(new InstancesHeader(ds));
 		dataset.setClassIndex(H);
 
diff --git a/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java b/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java
index b5905e34a..5270011e2 100644
--- a/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java
+++ b/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java
@@ -3,17 +3,13 @@
 import java.util.ArrayList;
 import java.util.List;
 
-import moa.core.Example;
 import moa.core.InstanceExample;
-import moa.streams.MultiTargetInstanceStream;
 
 import com.github.javacliparser.StringOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceImpl;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.Range;
 
 public class SelectAttributesFilter extends AbstractMultiLabelStreamFilter implements MultiLabelStreamFilter{
 
@@ -52,7 +48,6 @@ private void initialize(Instance instance) {
 		int totAttributes=inputsSelected.numValues()+outputsSelected.numValues();
 		InstancesHeader ds= new InstancesHeader();
 		List<Attribute> v = new ArrayList<Attribute>(totAttributes);
-		List<Integer> indexValues = new ArrayList<Integer>(totAttributes);
 		int ct=0;
 		List<Integer> inputIndexes = new ArrayList<Integer>();
 		List<Integer> outputIndexes = new ArrayList<Integer>();
@@ -60,7 +55,6 @@ private void initialize(Instance instance) {
 		{
 			for (int j=inputsSelected.getStart(i); j<=inputsSelected.getEnd(i);j++){
 				v.add(instance.attribute(j-1));
-				indexValues.add(ct);
 				inputIndexes.add(ct);
 				ct++;
 			}
@@ -70,12 +64,11 @@ private void initialize(Instance instance) {
 		{
 			for (int j=outputsSelected.getStart(i); j<=outputsSelected.getEnd(i);j++){
 				v.add(instance.attribute(j-1));
-				indexValues.add(ct);
 				outputIndexes.add(ct);
 				ct++;
 			}
 		}		
-		ds.setAttributes(v,indexValues);
+		ds.setAttributes(v);
 		ds.setOutputIndexes(outputIndexes);
 		ds.setInputIndexes(inputIndexes);
 		dataset=(new InstancesHeader(ds));
diff --git a/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java b/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java
index 5c99a5e92..4987e2718 100644
--- a/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java
+++ b/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java
@@ -21,7 +21,6 @@
 
 import java.io.BufferedReader;
 import java.io.FileInputStream;
-import java.io.FileReader;
 import java.io.InputStreamReader;
 import java.io.Reader;
 
@@ -35,11 +34,8 @@
 import moa.test.TmpFile;
 import weka.core.MOAUtils;
 
-import com.yahoo.labs.samoa.instances.ArffLoader;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.Range;
 
 /**
  * Ancestor for all classifier test cases.

From 66c988f31fbeef509dbb8ea08e05acd425deabce Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Tue, 10 Jan 2017 14:30:50 +0100
Subject: [PATCH 14/33] Instances rework, new iSOUPTree models and import
 cleanup

---
 moa/.settings/org.eclipse.jdt.core.prefs      |  13 +-
 .../github/javacliparser/JavaCLIParser.java   |   1 -
 .../gui/ClassOptionEditComponent.java         |   3 +-
 .../ClassOptionWithNamesEditComponent.java    |   3 +-
 .../gui/FileOptionEditComponent.java          |   1 +
 .../gui/ListOptionEditComponent.java          |   4 +-
 .../gui/OptionsConfigurationPanel.java        |   8 +-
 .../labs/samoa/instances/ArffLoader.java      |   1 +
 .../yahoo/labs/samoa/instances/Attribute.java |   7 +-
 .../yahoo/labs/samoa/instances/Instance.java  |  16 +
 .../labs/samoa/instances/InstanceImpl.java    |  22 +
 .../samoa/instances/InstanceInformation.java  |   1 -
 .../labs/samoa/instances/InstancesHeader.java |  13 +
 .../samoa/instances/MultiLabelPrediction.java |   3 +-
 .../SamoaToWekaInstanceConverter.java         |   2 +-
 moa/src/main/java/moa/AbstractMOAObject.java  |   6 +-
 moa/src/main/java/moa/DoTask.java             |  10 +-
 moa/src/main/java/moa/MOAObject.java          |   2 +-
 .../moa/classifiers/AbstractClassifier.java   |  34 +-
 .../AbstractMultiLabelLearner.java            |   5 +-
 .../main/java/moa/classifiers/Classifier.java |   7 +-
 .../moa/classifiers/MultiLabelLearner.java    |   2 +-
 .../classifiers/active/ActiveClassifier.java  |  10 +-
 .../moa/classifiers/bayes/NaiveBayes.java     |   3 +-
 .../bayes/NaiveBayesMultinomial.java          |   6 +-
 .../core/AttributeSplitSuggestion.java        |   2 +-
 ...naryTreeNumericAttributeClassObserver.java |   1 +
 ...mericAttributeClassObserverRegression.java |   1 +
 .../FIMTDDNumericAttributeClassObserver.java  |  61 +-
 ...GaussianNumericAttributeClassObserver.java |  12 +-
 ...ldKhannaNumericAttributeClassObserver.java |   6 +-
 .../NominalAttributeClassObserver.java        |   7 +-
 .../VFMLNumericAttributeClassObserver.java    |   8 +-
 .../InstanceConditionalTest.java              |   4 +-
 .../NominalAttributeBinaryTest.java           |   1 -
 .../NominalAttributeMultiwayTest.java         |   1 -
 .../NumericAttributeBinaryTest.java           |   1 -
 .../driftdetection/ADWINChangeDetector.java   |   1 +
 .../core/driftdetection/CusumDM.java          |   1 +
 .../classifiers/core/driftdetection/DDM.java  |   1 +
 .../core/driftdetection/EWMAChartDM.java      |   1 +
 .../EnsembleDriftDetectionMethods.java        |   1 +
 .../GeometricMovingAverageDM.java             |   1 +
 .../core/driftdetection/HDDM_A_Test.java      |   1 +
 .../core/driftdetection/HDDM_W_Test.java      |   1 +
 .../core/driftdetection/PageHinkleyDM.java    |   1 +
 .../driftdetection/SEEDChangeDetector.java    |   1 +
 .../SeqDrift1ChangeDetector.java              |   8 +-
 .../SeqDrift2ChangeDetector.java              |   8 +-
 .../splitcriteria/InfoGainSplitCriterion.java |   1 +
 .../drift/DriftDetectionMethodClassifier.java |   6 +-
 .../classifiers/functions/MajorityClass.java  |   3 +-
 .../moa/classifiers/functions/NoChange.java   |   3 +-
 .../moa/classifiers/functions/Perceptron.java |   5 +-
 .../java/moa/classifiers/functions/SGD.java   |   9 +-
 .../classifiers/functions/SGDMultiClass.java  |   7 +-
 .../moa/classifiers/functions/SPegasos.java   |   7 +-
 .../main/java/moa/classifiers/lazy/kNN.java   |  10 +-
 .../java/moa/classifiers/lazy/kNNwithPAW.java |   1 -
 .../classifiers/lazy/kNNwithPAWandADWIN.java  |   4 +-
 .../lazy/neighboursearch/KDTree.java          |   6 +-
 .../NearestNeighbourSearch.java               |   1 +
 .../neighboursearch/NormalizableDistance.java |   1 -
 .../kdtrees/KDTreeNodeSplitter.java           |   3 +-
 .../main/java/moa/classifiers/meta/ADACC.java |   7 +-
 .../meta/AccuracyUpdatedEnsemble.java         |   7 +-
 .../meta/AccuracyWeightedEnsemble.java        |  16 +-
 .../main/java/moa/classifiers/meta/DACC.java  |  11 +-
 .../moa/classifiers/meta/LeveragingBag.java   |  13 +-
 .../classifiers/meta/LimAttClassifier.java    |  18 +-
 .../java/moa/classifiers/meta/OCBoost.java    |  10 +-
 .../meta/OnlineAccuracyUpdatedEnsemble.java   |   1 +
 .../classifiers/meta/OnlineSmoothBoost.java   |   1 +
 .../java/moa/classifiers/meta/OzaBag.java     |  14 +-
 .../java/moa/classifiers/meta/OzaBagASHT.java |   7 +-
 .../moa/classifiers/meta/OzaBagAdwin.java     |  10 +-
 .../java/moa/classifiers/meta/OzaBoost.java   |   8 +-
 .../moa/classifiers/meta/OzaBoostAdwin.java   |  11 +-
 .../moa/classifiers/meta/PairedLearners.java  |   9 +-
 .../moa/classifiers/meta/RandomRules.java     |   3 +-
 .../meta/TemporallyAugmentedClassifier.java   |  14 +-
 .../moa/classifiers/meta/WEKAClassifier.java  |   8 +-
 .../meta/WeightedMajorityAlgorithm.java       |  17 +-
 .../HoeffdingTreeClassifLeaves.java           |   4 +-
 .../LocalMultiTargetClassifier.java           |  46 +-
 .../multilabel/MEKAClassifier.java            |  22 +-
 .../multilabel/MajorityLabelset.java          |   9 +-
 .../multilabel/MultilabelHoeffdingTree.java   |  30 +-
 .../MultiLabelBSTree.java                     |  72 +-
 .../MultiLabelBSTreePCT.java                  | 270 ++++++
 .../MultiLabelNominalAttributeObserver.java   |   4 +-
 .../splitcriteria/ICVarianceReduction.java    |   8 +-
 .../PCTWeightedICVarianceReduction.java       |  76 ++
 .../classifiers/multilabel/meta/MTOzaBag.java |  16 +-
 .../multilabel/meta/OzaBagAdwinML.java        | 109 ++-
 .../classifiers/multilabel/meta/OzaBagML.java |  13 +-
 .../multilabel/trees/ISOUPOptionTree.java     |  68 +-
 .../multilabel/trees/ISOUPTree.java           | 901 ++++++++++--------
 .../multilabel/trees/ISOUPTreeRF.java         |  46 +
 .../BasicMultiTargetRegressor.java            |  15 +-
 .../functions/MultiTargetNoChange.java        |   6 +-
 .../rules/AMRulesRegressorOld.java            |   3 +-
 .../classifiers/rules/AbstractAMRules.java    |   8 +-
 .../moa/classifiers/rules/Predicates.java     |   3 +-
 .../classifiers/rules/RuleClassification.java |   6 +-
 .../moa/classifiers/rules/RuleClassifier.java |  13 +-
 .../rules/RuleClassifierNBayes.java           |   4 +-
 .../rules/core/NominalRulePredicate.java      |   1 -
 .../rules/core/NumericRulePredicate.java      |   1 -
 .../java/moa/classifiers/rules/core/Rule.java |   8 +-
 .../rules/core/RuleActiveLearningNode.java    |   2 +-
 .../rules/core/RuleActiveRegressionNode.java  |  12 +-
 .../moa/classifiers/rules/core/Utils.java     |   5 +
 .../AbstractAnomalyDetector.java              |   3 +-
 .../AnomalinessRatioScore.java                |  10 +-
 .../anomalydetection/NoAnomalyDetection.java  |   3 +-
 .../core/anomalydetection/OddsRatioScore.java |  10 +-
 .../CantellisInequality.java                  |   3 -
 .../ChebyshevInequality.java                  |   3 -
 .../probabilityfunctions/GaussInequality.java |   3 -
 ...TDDNumericAttributeClassLimitObserver.java |   4 +-
 .../NominalAttributeBinaryRulePredicate.java  |   1 -
 .../NumericAttributeBinaryRulePredicate.java  |   1 -
 .../SDRSplitCriterionAMRules.java             |   1 -
 .../SDRSplitCriterionAMRulesNode.java         |   2 -
 .../voting/AbstractErrorWeightedVote.java     |   1 +
 .../errormeasurers/MeanAbsoluteDeviation.java |   1 -
 .../errormeasurers/RootMeanSquaredError.java  |   2 -
 .../rules/functions/AMRulesLearner.java       |   4 +-
 .../rules/functions/Perceptron.java           |   2 -
 .../rules/functions/TargetMean.java           |   2 +-
 .../rules/meta/RandomAMRulesOld.java          |   7 +-
 .../multilabel/AMRulesMultiLabelLearner.java  |  13 +-
 .../AMRulesMultiTargetRegressor.java          |   2 -
 .../multilabel/core/LearningLiteral.java      |   9 +-
 .../core/LearningLiteralRegression.java       |  15 +-
 .../rules/multilabel/core/MultiLabelRule.java |   8 +-
 .../AbstractErrorWeightedVoteMultiLabel.java  |   1 -
 .../voting/ErrorWeightedVoteMultiLabel.java   |   2 -
 .../AbstractMultiLabelErrorMeasurer.java      |   8 +-
 .../AbstractMultiTargetErrorMeasurer.java     |   2 +-
 .../MultiLabelErrorMeasurer.java              |   2 +-
 .../RootMeanSquaredErrorMT.java               |   3 -
 .../AdaptiveMultiTargetRegressor.java         |   7 +-
 .../MultiLabelTargetMeanRegressor.java        |   1 -
 .../meta/MultiLabelRandomAMRules.java         |  18 +-
 .../trees/AdaHoeffdingOptionTree.java         |   3 +-
 .../moa/classifiers/trees/DecisionStump.java  |   3 +-
 .../java/moa/classifiers/trees/FIMTDD.java    |  46 +-
 .../trees/HoeffdingAdaptiveTree.java          |   4 +-
 .../trees/HoeffdingOptionTree.java            |  12 +-
 .../moa/classifiers/trees/HoeffdingTree.java  |  14 +-
 .../trees/LimAttHoeffdingTree.java            |   3 +-
 .../main/java/moa/classifiers/trees/ORTO.java |   7 +-
 .../trees/RandomHoeffdingTree.java            |   3 +-
 moa/src/main/java/moa/cluster/CFCluster.java  |   1 +
 moa/src/main/java/moa/cluster/Cluster.java    |   4 +-
 moa/src/main/java/moa/cluster/Clustering.java |   6 +-
 .../main/java/moa/cluster/SphereCluster.java  |   1 +
 .../moa/clusterers/AbstractClusterer.java     |  10 +-
 .../java/moa/clusterers/ClusterGenerator.java |   4 +-
 .../main/java/moa/clusterers/Clusterer.java   |   5 +-
 moa/src/main/java/moa/clusterers/CobWeb.java  |  10 +-
 moa/src/main/java/moa/clusterers/KMeans.java  |   1 +
 .../clusterers/WekaClusteringAlgorithm.java   |  13 +-
 .../moa/clusterers/clustream/Clustream.java   |   8 +-
 .../clusterers/clustream/ClustreamKernel.java |   5 +-
 .../moa/clusterers/clustream/WithKmeans.java  |   7 +-
 .../moa/clusterers/clustree/ClusKernel.java   |   5 +-
 .../moa/clusterers/clustree/ClusTree.java     |  10 +-
 .../clusterers/denstream/MicroCluster.java    |   3 +-
 .../moa/clusterers/denstream/WithDBSCAN.java  |   9 +-
 .../clusterers/macro/NonConvexCluster.java    |   3 +-
 .../outliers/AbstractC/AbstractC.java         |   6 +-
 .../outliers/AbstractC/AbstractCBase.java     |   3 +-
 .../outliers/AbstractC/ISBIndex.java          |   1 +
 .../outliers/AbstractC/MyMTree.java           |   1 +
 .../clusterers/outliers/AbstractC/Test.java   |   3 +-
 .../outliers/Angiulli/ApproxSTORM.java        |   6 +-
 .../outliers/Angiulli/ExactSTORM.java         |   6 +-
 .../outliers/Angiulli/ISBIndex.java           |   1 +
 .../clusterers/outliers/Angiulli/MyMTree.java |   1 +
 .../outliers/Angiulli/STORMBase.java          |   6 +-
 .../clusterers/outliers/Angiulli/Test.java    |   3 +-
 .../clusterers/outliers/AnyOut/AnyOut.java    |   4 +-
 .../outliers/AnyOut/AnyOutCore.java           |   6 +-
 .../clusterers/outliers/MCOD/ISBIndex.java    |   1 +
 .../moa/clusterers/outliers/MCOD/MCOD.java    |   8 +-
 .../clusterers/outliers/MCOD/MCODBase.java    |   3 +-
 .../outliers/MCOD/MTreeMicroClusters.java     |   1 +
 .../outliers/MCOD/MTreeStreamObjects.java     |   1 +
 .../outliers/MCOD/MicroCluster.java           |   1 +
 .../moa/clusterers/outliers/MCOD/Test.java    |   3 +-
 .../outliers/MyBaseOutlierDetector.java       |   6 +-
 .../outliers/SimpleCOD/ISBIndex.java          |   1 +
 .../outliers/SimpleCOD/MyMTree.java           |   1 +
 .../outliers/SimpleCOD/SimpleCOD.java         |   6 +-
 .../outliers/SimpleCOD/SimpleCODBase.java     |   1 +
 .../clusterers/outliers/SimpleCOD/Test.java   |   3 +-
 .../moa/clusterers/outliers/TestSpeed.java    |   3 +-
 .../outliers/utils/mtree/MTree.java           |   1 +
 .../utils/mtree/PromotionFunctions.java       |   1 +
 .../java/moa/clusterers/streamkm/Point.java   |   4 +-
 .../moa/clusterers/streamkm/StreamKM.java     |   3 +-
 .../java/moa/core/AutoClassDiscovery.java     |   2 +-
 .../main/java/moa/core/AutoExpandVector.java  |   2 +-
 .../moa/core/MultilabelInstancesHeader.java   |   1 -
 moa/src/main/java/moa/core/Utils.java         |   8 -
 .../main/java/moa/core/utils/Converter.java   |   4 +-
 .../main/java/moa/evaluation/Accuracy.java    |   1 +
 ...winClassificationPerformanceEvaluator.java |   1 -
 ...sicClassificationPerformanceEvaluator.java |  12 +-
 ...BasicConceptDriftPerformanceEvaluator.java |   1 -
 .../BasicMultiLabelPerformanceEvaluator.java  |   8 +-
 .../BasicMultiTargetPerformanceEvaluator.java |  11 +-
 .../BasicRegressionPerformanceEvaluator.java  |   7 +-
 .../java/moa/evaluation/CMM_GTAnalysis.java   |   4 +-
 .../evaluation/ChangeDetectionMeasures.java   |   1 +
 .../ClassificationPerformanceEvaluator.java   |   3 +-
 ...WMAClassificationPerformanceEvaluator.java |  13 -
 .../moa/evaluation/EntropyCollection.java     |   1 +
 moa/src/main/java/moa/evaluation/F1.java      |   1 +
 ...torClassificationPerformanceEvaluator.java |  12 -
 moa/src/main/java/moa/evaluation/General.java |   4 +-
 .../moa/evaluation/LearningEvaluation.java    |   4 +-
 .../LearningPerformanceEvaluator.java         |   1 -
 .../moa/evaluation/MeasureCollection.java     |   1 +
 .../java/moa/evaluation/MembershipMatrix.java |   1 +
 .../MultiTargetPerformanceEvaluator.java      |   3 +-
 ...tWindowRegressionPerformanceEvaluator.java |  13 +-
 .../moa/evaluation/OutlierPerformance.java    |   2 +-
 .../RegressionPerformanceEvaluator.java       |   3 +-
 moa/src/main/java/moa/evaluation/SSQ.java     |   1 +
 .../main/java/moa/evaluation/Separation.java  |   7 +-
 .../moa/evaluation/SilhouetteCoefficient.java |   2 +-
 .../moa/evaluation/StatisticalCollection.java |   1 +
 ...dowClassificationPerformanceEvaluator.java |  12 -
 .../WindowRegressionPerformanceEvaluator.java |  11 +-
 moa/src/main/java/moa/gui/BatchCmd.java       |   5 +-
 .../moa/gui/ClassOptionSelectionPanel.java    |   3 +-
 .../ClassOptionWithNamesSelectionPanel.java   |   3 +-
 .../java/moa/gui/ConceptDriftTabPanel.java    |   1 +
 moa/src/main/java/moa/gui/GUI.java            |   6 +-
 moa/src/main/java/moa/gui/GUIDefaults.java    |   6 +-
 .../java/moa/gui/MultiTargetTabPanel.java     |   1 +
 .../moa/gui/MultiTargetTaskManagerPanel.java  |   2 +
 .../main/java/moa/gui/RegressionTabPanel.java |   1 +
 .../moa/gui/RegressionTaskManagerPanel.java   |   6 +-
 .../main/java/moa/gui/TaskManagerPanel.java   |   6 +-
 .../java/moa/gui/TaskTextViewerPanel.java     |   3 +-
 .../moa/gui/WEKAClassOptionEditComponent.java |  12 +-
 .../gui/clustertab/ClusteringAlgoPanel.java   |  10 +-
 .../gui/clustertab/ClusteringEvalPanel.java   |   3 +-
 .../gui/clustertab/ClusteringSetupTab.java    |   2 +
 .../clustertab/ClusteringVisualEvalPanel.java |   4 +-
 .../gui/clustertab/ClusteringVisualTab.java   |   2 +
 .../gui/conceptdrift/CDTaskManagerPanel.java  |  11 +-
 .../moa/gui/outliertab/OutlierAlgoPanel.java  |  15 +-
 .../moa/gui/outliertab/OutlierEvalPanel.java  |   4 +-
 .../moa/gui/outliertab/OutlierSetupTab.java   |   2 +
 .../outliertab/OutlierVisualEvalPanel.java    |   4 +-
 .../moa/gui/outliertab/OutlierVisualTab.java  |   2 +
 .../moa/gui/visualization/ClusterPanel.java   |   2 +
 .../moa/gui/visualization/GraphCanvas.java    |   2 +
 .../moa/gui/visualization/GraphCurve.java     |   1 +
 .../moa/gui/visualization/OutlierPanel.java   |  21 +-
 .../visualization/RunOutlierVisualizer.java   |  10 +-
 .../moa/gui/visualization/RunVisualizer.java  |  12 +-
 .../gui/visualization/StreamOutlierPanel.java |  16 +-
 .../moa/gui/visualization/WekaExplorer.java   |   7 +-
 .../moa/learners/ChangeDetectorLearner.java   |   3 +-
 moa/src/main/java/moa/learners/Learner.java   |   6 +-
 .../java/moa/options/AbstractClassOption.java |   2 +
 .../moa/options/AbstractOptionHandler.java    |   1 +
 .../main/java/moa/options/ClassOption.java    |   3 +-
 .../moa/options/ClassOptionWithNames.java     |   6 +-
 .../main/java/moa/options/OptionHandler.java  |   1 +
 .../main/java/moa/options/OptionsHandler.java |   2 +
 .../java/moa/options/WEKAClassOption.java     |   6 +-
 .../dataset/impl/FlixsterDataset.java         |   5 +-
 .../dataset/impl/JesterDataset.java           |   9 +-
 .../dataset/impl/MovielensDataset.java        |   6 +-
 .../predictor/BRISMFPredictor.java            |   6 +-
 .../predictor/BaselinePredictor.java          |   1 +
 .../predictor/RatingPredictor.java            |   1 +
 .../rc/data/AbstractRecommenderData.java      |   1 +
 .../recommender/rc/data/RecommenderData.java  |   1 +
 .../rc/data/impl/MemRecommenderData.java      |   1 +
 .../rc/predictor/RatingPredictor.java         |   1 +
 .../rc/predictor/impl/BRISMFPredictor.java    |   1 +
 .../rc/predictor/impl/BaselinePredictor.java  |   1 +
 .../main/java/moa/streams/ArffFileStream.java |  12 +-
 .../moa/streams/CachedInstancesStream.java    |   5 +-
 .../moa/streams/ConceptDriftRealStream.java   |  14 +-
 .../java/moa/streams/ConceptDriftStream.java  |  10 +-
 .../main/java/moa/streams/ExampleStream.java  |   5 +-
 .../main/java/moa/streams/InstanceStream.java |   3 +-
 .../java/moa/streams/MultiFilteredStream.java |   9 +-
 .../moa/streams/MultiLabelFilteredStream.java |   1 -
 .../streams/MultiTargetArffFileStream.java    |  15 -
 .../streams/MultiTargetInstanceStream.java    |   3 -
 .../streams/RecurrentConceptDriftStream.java  |   7 +-
 .../streams/clustering/ClusteringStream.java  |   3 +-
 .../moa/streams/clustering/FileStream.java    |  14 +-
 .../clustering/RandomRBFGeneratorEvents.java  |  17 +-
 .../streams/clustering/SimpleCSVStream.java   |   1 -
 .../AbstractMultiLabelStreamFilter.java       |   1 -
 .../streams/filters/AbstractStreamFilter.java |   2 +-
 .../moa/streams/filters/AddNoiseFilter.java   |   9 +-
 .../java/moa/streams/filters/RBFFilter.java   |   4 +-
 .../RemoveDiscreteAttributeFilter.java        |   7 +-
 .../filters/ReplacingMissingValuesFilter.java |  11 +-
 .../filters/SelectAttributesFilter.java       |   4 +-
 .../moa/streams/filters/StreamFilter.java     |   1 +
 .../streams/generators/AgrawalGenerator.java  |  15 +-
 .../generators/HyperplaneGenerator.java       |  11 +-
 .../moa/streams/generators/LEDGenerator.java  |  11 +-
 .../streams/generators/LEDGeneratorDrift.java |   4 +-
 .../generators/RandomRBFGenerator.java        |  11 +-
 .../generators/RandomRBFGeneratorDrift.java   |   6 +-
 .../generators/RandomTreeGenerator.java       |  15 +-
 .../moa/streams/generators/SEAGenerator.java  |  11 +-
 .../streams/generators/STAGGERGenerator.java  |  11 +-
 .../streams/generators/WaveformGenerator.java |  11 +-
 .../generators/WaveformGeneratorDrift.java    |   4 +-
 .../cd/AbstractConceptDriftGenerator.java     |   7 +-
 .../generators/cd/ConceptDriftGenerator.java  |   1 +
 .../multilabel/MetaMultilabelGenerator.java   |  26 +-
 .../multilabel/MultilabelArffFileStream.java  |   8 +-
 .../java/moa/tasks/CacheShuffledStream.java   |   3 +-
 .../java/moa/tasks/ConceptDriftMainTask.java  |   1 +
 .../java/moa/tasks/EvaluateClustering.java    |   5 +-
 .../java/moa/tasks/EvaluateConceptDrift.java  |   9 +-
 .../moa/tasks/EvaluateInterleavedChunks.java  |  12 +-
 .../EvaluateInterleavedTestThenTrain.java     |   7 +-
 .../main/java/moa/tasks/EvaluateModel.java    |   4 +-
 .../moa/tasks/EvaluateModelMultiTarget.java   |   8 +-
 .../moa/tasks/EvaluateModelRegression.java    |   5 +-
 .../moa/tasks/EvaluateOnlineRecommender.java  |   3 +-
 .../tasks/EvaluatePeriodicHeldOutTest.java    |   6 +-
 .../java/moa/tasks/EvaluatePrequential.java   |  16 +-
 .../java/moa/tasks/EvaluatePrequentialCV.java |  28 +-
 .../tasks/EvaluatePrequentialMultiTarget.java |  11 +-
 .../tasks/EvaluatePrequentialRegression.java  |  22 +-
 moa/src/main/java/moa/tasks/LearnModel.java   |   3 +-
 .../java/moa/tasks/LearnModelMultiTarget.java |   1 +
 .../java/moa/tasks/LearnModelRegression.java  |   5 +-
 moa/src/main/java/moa/tasks/MainTask.java     |   3 +-
 .../java/moa/tasks/MeasureStreamSpeed.java    |   4 +-
 .../java/moa/tasks/MultiTargetMainTask.java   |   2 +-
 moa/src/main/java/moa/tasks/Plot.java         |   3 +-
 .../java/moa/tasks/RegressionMainTask.java    |   2 +-
 .../main/java/moa/tasks/RunStreamTasks.java   |   1 +
 moa/src/main/java/moa/tasks/RunTasks.java     |   5 +-
 .../java/moa/tasks/WriteStreamToARFFFile.java |   7 +-
 .../main/java/weka/classifiers/meta/MOA.java  |  18 +-
 .../classifiers/classification/MOA.java       |  19 +-
 .../java/weka/gui/MOAClassOptionEditor.java   |   3 +-
 .../instances/MultiTargetArffLoaderTest.java  |  12 +-
 .../AbstractClassifierTestCase.java           |  12 +-
 .../AbstractMultipleClassifierTestCase.java   |   1 -
 .../AbstractMultipleRegressorTestCase.java    |   1 -
 .../active/ActiveClassifierTest.java          |   1 -
 .../drift/SingleClassifierDriftTest.java      |   1 -
 .../functions/MajorityClassTest.java          |   1 -
 .../classifiers/functions/NoChangeTest.java   |   1 -
 .../classifiers/functions/PerceptronTest.java |   1 -
 .../moa/classifiers/functions/SGDTest.java    |   1 -
 .../classifiers/functions/SPegasosTest.java   |   1 -
 .../meta/AccuracyUpdatedEnsembleTest.java     |   1 -
 .../meta/AccuracyWeightedEnsembleTest.java    |   1 -
 .../classifiers/meta/LeveragingBagTest.java   |   1 -
 .../meta/LimAttClassifierTest.java            |   1 -
 .../moa/classifiers/meta/OCBoostTest.java     |   1 -
 .../OnlineAccuracyUpdatedEnsembleTest.java    |   1 -
 .../moa/classifiers/meta/OzaBagASHTTest.java  |   1 -
 .../moa/classifiers/meta/OzaBagAdwinTest.java |   1 -
 .../java/moa/classifiers/meta/OzaBagTest.java |   1 -
 .../classifiers/meta/OzaBoostAdwinTest.java   |   1 -
 .../moa/classifiers/meta/OzaBoostTest.java    |   1 -
 .../TemporallyAugmentedClassifierTest.java    |   1 -
 .../classifiers/meta/WEKAClassifierTest.java  |   1 -
 .../meta/WeightedMajorityAlgorithmTest.java   |   1 -
 .../rules/AMRulesRegressorTest.java           |   1 -
 .../rules/RuleClassifierNBayesTest.java       |   1 -
 .../classifiers/rules/RuleClassifierTest.java |   1 -
 ...nverseErrorWeightedVoteMultiLabeLTest.java |   3 +-
 .../UniformWeightedVoteMultiLabelTest.java    |   4 +-
 .../trees/ASHoeffdingTreeTest.java            |   1 -
 .../trees/AdaHoeffdingOptionTreeTest.java     |   1 -
 .../classifiers/trees/DecisionStumpTest.java  |   1 -
 .../moa/classifiers/trees/FIMTDDTest.java     |   4 +-
 .../trees/HoeffdingAdaptiveTreeTest.java      |   1 -
 .../trees/HoeffdingOptionTreeTest.java        |   1 -
 .../trees/LimAttHoeffdingTreeTest.java        |   1 -
 .../java/moa/classifiers/trees/ORTOTest.java  |   1 -
 .../trees/RandomHoeffdingTreeTest.java        |   1 -
 .../moa/integration/SimpleClusterTest.java    |  12 +-
 .../filters/SelectAttributesFilterTest.java   |   5 +-
 .../.settings/org.eclipse.jdt.core.prefs      |   9 +-
 400 files changed, 2267 insertions(+), 1558 deletions(-)
 create mode 100644 moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelBSTreePCT.java
 create mode 100644 moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/PCTWeightedICVarianceReduction.java
 create mode 100644 moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTreeRF.java

diff --git a/moa/.settings/org.eclipse.jdt.core.prefs b/moa/.settings/org.eclipse.jdt.core.prefs
index 60105c1b9..672496e10 100644
--- a/moa/.settings/org.eclipse.jdt.core.prefs
+++ b/moa/.settings/org.eclipse.jdt.core.prefs
@@ -1,5 +1,12 @@
 eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
-org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
 org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
-org.eclipse.jdt.core.compiler.source=1.6
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/moa/src/main/java/com/github/javacliparser/JavaCLIParser.java b/moa/src/main/java/com/github/javacliparser/JavaCLIParser.java
index 23522e085..68191078c 100644
--- a/moa/src/main/java/com/github/javacliparser/JavaCLIParser.java
+++ b/moa/src/main/java/com/github/javacliparser/JavaCLIParser.java
@@ -73,7 +73,6 @@ public Option[] discoverOptionsViaReflection() {
         Field[] fields = c.getFields();
         List<Option> optList = new LinkedList<Option>();
         for (Field field : fields) {
-            String fName = field.getName();
             Class<?> fType = field.getType();
             if (fType.getName().endsWith("Option")) {
                 if (Option.class.isAssignableFrom(fType)) {
diff --git a/moa/src/main/java/com/github/javacliparser/gui/ClassOptionEditComponent.java b/moa/src/main/java/com/github/javacliparser/gui/ClassOptionEditComponent.java
index 7eb583603..5ba9ec261 100644
--- a/moa/src/main/java/com/github/javacliparser/gui/ClassOptionEditComponent.java
+++ b/moa/src/main/java/com/github/javacliparser/gui/ClassOptionEditComponent.java
@@ -32,9 +32,10 @@
 import javax.swing.event.DocumentEvent;
 import javax.swing.event.DocumentListener;
 
-import moa.options.ClassOption;
 import com.github.javacliparser.Option;
+
 import moa.gui.ClassOptionSelectionPanel;
+import moa.options.ClassOption;
 
 /**
  * An OptionEditComponent that lets the user edit a class option.
diff --git a/moa/src/main/java/com/github/javacliparser/gui/ClassOptionWithNamesEditComponent.java b/moa/src/main/java/com/github/javacliparser/gui/ClassOptionWithNamesEditComponent.java
index 7df51c402..f311f1d54 100644
--- a/moa/src/main/java/com/github/javacliparser/gui/ClassOptionWithNamesEditComponent.java
+++ b/moa/src/main/java/com/github/javacliparser/gui/ClassOptionWithNamesEditComponent.java
@@ -23,9 +23,10 @@
 import javax.swing.event.DocumentEvent;
 import javax.swing.event.DocumentListener;
 
-import moa.options.ClassOptionWithNames;
 import com.github.javacliparser.Option;
+
 import moa.gui.ClassOptionWithNamesSelectionPanel;
+import moa.options.ClassOptionWithNames;
 
 public class ClassOptionWithNamesEditComponent extends JPanel implements OptionEditComponent {
 
diff --git a/moa/src/main/java/com/github/javacliparser/gui/FileOptionEditComponent.java b/moa/src/main/java/com/github/javacliparser/gui/FileOptionEditComponent.java
index db0d3803b..5e3f6871a 100644
--- a/moa/src/main/java/com/github/javacliparser/gui/FileOptionEditComponent.java
+++ b/moa/src/main/java/com/github/javacliparser/gui/FileOptionEditComponent.java
@@ -31,6 +31,7 @@
 
 import com.github.javacliparser.FileOption;
 import com.github.javacliparser.Option;
+
 import moa.gui.FileExtensionFilter;
 
 /**
diff --git a/moa/src/main/java/com/github/javacliparser/gui/ListOptionEditComponent.java b/moa/src/main/java/com/github/javacliparser/gui/ListOptionEditComponent.java
index 0b295155c..53721bf3a 100644
--- a/moa/src/main/java/com/github/javacliparser/gui/ListOptionEditComponent.java
+++ b/moa/src/main/java/com/github/javacliparser/gui/ListOptionEditComponent.java
@@ -19,9 +19,9 @@
  */
 package com.github.javacliparser.gui;
 
-import com.github.javacliparser.Option;
+import javax.swing.JTextField;
 
-import javax.swing.*;
+import com.github.javacliparser.Option;
 
 /**
  * An OptionEditComponent that lets the user edit a list option.
diff --git a/moa/src/main/java/com/github/javacliparser/gui/OptionsConfigurationPanel.java b/moa/src/main/java/com/github/javacliparser/gui/OptionsConfigurationPanel.java
index c30b765f6..b099ed8c0 100644
--- a/moa/src/main/java/com/github/javacliparser/gui/OptionsConfigurationPanel.java
+++ b/moa/src/main/java/com/github/javacliparser/gui/OptionsConfigurationPanel.java
@@ -30,11 +30,8 @@
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.logging.Level;
-import java.util.logging.Logger;
 
 import javax.swing.BorderFactory;
 import javax.swing.JButton;
@@ -48,11 +45,12 @@
 import javax.swing.ScrollPaneConstants;
 import javax.swing.UIManager;
 
-import moa.classifiers.trees.HoeffdingTree;
 import com.github.javacliparser.Option;
-import moa.options.OptionHandler;
 import com.github.javacliparser.Options;
+
+import moa.classifiers.trees.HoeffdingTree;
 import moa.gui.GUIUtils;
+import moa.options.OptionHandler;
 
 /**
  * This panel displays an options configuration.
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
index fa92fc81e..bec02f2e5 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
@@ -211,6 +211,7 @@ private Instance readInstanceSparse() {
         ArrayList<Double> attributeValues = new ArrayList<Double>();
         List<Integer> indexValues = new ArrayList<Integer>();
         try {
+        	streamTokenizer.nextToken(); // Remove the '{' char
             //For each line
             while (streamTokenizer.ttype != StreamTokenizer.TT_EOL
                     && streamTokenizer.ttype != StreamTokenizer.TT_EOF) {
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java
index 9ba21d898..3408543ec 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java
@@ -17,7 +17,12 @@
 
 import java.io.Serializable;
 import java.text.SimpleDateFormat;
-import java.util.*;
+import java.util.Collections;
+import java.util.Date;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
 import moa.core.Utils;
 /**
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
index 15bd6bb98..bcf740624 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
@@ -128,6 +128,22 @@ public interface Instance extends Serializable {
      */
     public boolean isMissing(int instAttIndex);
 
+    /**
+     * Checks if an attribute is missing.
+     *
+     * @param index the instance input attribute index
+     * @return true, if is missing
+     */
+    public boolean isInputMissing(int index);
+
+    /**
+     * Checks if an attribute is missing.
+     *
+     * @param index the instance output attribute index
+     * @return true, if is missing
+     */
+    public boolean isOutputMissing(int index);
+    
     /**
      * Gets the index of the attribute given the index of the array in a sparse
      * representation.
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
index 9305556e3..1299504d1 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
@@ -184,6 +184,28 @@ public boolean isMissing(int instAttIndex) {
         return this.instanceData.isMissing(instAttIndex);
     }
 
+    /**
+     * Checks if is missing.
+     *
+     * @param instAttIndex the instance input attribute index
+     * @return true, if is missing
+     */
+    @Override
+    public boolean isInputMissing(int index) {
+        return this.instanceData.isMissing(this.instanceHeader.getInputInstanceIndex(index));
+    }
+
+    /**
+     * Checks if is missing.
+     *
+     * @param instAttIndex the instance output attribute index
+     * @return true, if is missing
+     */
+    @Override
+    public boolean isOutputMissing(int index) {
+        return this.instanceData.isMissing(this.instanceHeader.getOutputInstanceIndex(index));
+    }
+    
     /**
      * Num values.
      *
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
index ebb0d8940..8df8da3cd 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
@@ -194,7 +194,6 @@ public int numInputAttributes() {
     }
 
     public int numOutputAttributes() {
-
     	return outputIndexes.size();
     }
     
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
index 30401fdf5..ece3f6d58 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
@@ -217,7 +217,16 @@ public void setOutputIndexes(List<Integer> outputIndexes) {
 	public void setInputIndexes(List<Integer> inputIndexes) {
 		this.instanceInformation.setInputIndexes(inputIndexes);
 	}
+	
+	public int getInputInstanceIndex(int index) {
+		return this.instanceInformation.inputAttributeIndex(index);
+	}
+
+	public int getOutputInstanceIndex(int index) {
+		return this.instanceInformation.outputAttributeIndex(index);
+	}
 
+	
 	/** 
 	 * Sets all non-output attributes as input attributes.
 	 */
@@ -478,6 +487,10 @@ public void delete(int index) {
 		this.instances.remove(index);
 	}
 
+	
+	public void setInstances(List<Instance> instances) {
+		this.instances = instances;
+	}
 
 	/**
 	 * Swap.
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
index 7e8fb2bdc..55b335f4b 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
@@ -14,9 +14,10 @@
  */
 package com.yahoo.labs.samoa.instances;
 
-import moa.core.DoubleVector;
 import java.io.Serializable;
 
+import moa.core.DoubleVector;
+
 public class MultiLabelPrediction implements Prediction, Serializable {
 	/**
 	 * 
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/SamoaToWekaInstanceConverter.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/SamoaToWekaInstanceConverter.java
index 3ef342875..ad1acfad7 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/SamoaToWekaInstanceConverter.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/SamoaToWekaInstanceConverter.java
@@ -15,8 +15,8 @@
  */
 package com.yahoo.labs.samoa.instances;
 
-import java.util.ArrayList;
 import java.io.Serializable;
+import java.util.ArrayList;
 
 /**
  * The Class SamoaToWekaInstanceConverter.
diff --git a/moa/src/main/java/moa/AbstractMOAObject.java b/moa/src/main/java/moa/AbstractMOAObject.java
index 60310da9e..3cea8bf11 100644
--- a/moa/src/main/java/moa/AbstractMOAObject.java
+++ b/moa/src/main/java/moa/AbstractMOAObject.java
@@ -37,7 +37,7 @@ public MOAObject copy() {
     }
 
     @Override
-    public int measureByteSize() {
+    public long measureByteSize() {
         return measureByteSize(this);
     }
 
@@ -73,7 +73,7 @@ public static MOAObject copy(MOAObject obj) {
      * @param obj object to measure the memory size
      * @return the memory size of this object
      */
-    public static int measureByteSize(MOAObject obj) {
-        return (int) SizeOf.fullSizeOf(obj);
+    public static long measureByteSize(MOAObject obj) {
+        return SizeOf.fullSizeOf(obj);
     }
 }
diff --git a/moa/src/main/java/moa/DoTask.java b/moa/src/main/java/moa/DoTask.java
index 0365bc2cb..0f7e51789 100644
--- a/moa/src/main/java/moa/DoTask.java
+++ b/moa/src/main/java/moa/DoTask.java
@@ -19,7 +19,10 @@
  */
 package moa;
 
-import weka.core.Version;
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.Option;
+
 import moa.core.Globals;
 import moa.core.Measurement;
 import moa.core.StringUtils;
@@ -29,10 +32,7 @@
 import moa.tasks.FailedTaskReport;
 import moa.tasks.Task;
 import moa.tasks.TaskThread;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.Option;
+import weka.core.Version;
 
 /**
  * Class for running a MOA task from the command line.
diff --git a/moa/src/main/java/moa/MOAObject.java b/moa/src/main/java/moa/MOAObject.java
index 497547634..4ec56618d 100644
--- a/moa/src/main/java/moa/MOAObject.java
+++ b/moa/src/main/java/moa/MOAObject.java
@@ -36,7 +36,7 @@ public interface MOAObject extends Serializable {
      *
      * @return the memory size of this object
      */
-    public int measureByteSize();
+    public long measureByteSize();
 
     /**
      * This method produces a copy of this object.
diff --git a/moa/src/main/java/moa/classifiers/AbstractClassifier.java b/moa/src/main/java/moa/classifiers/AbstractClassifier.java
index fb8daca38..7b050c020 100644
--- a/moa/src/main/java/moa/classifiers/AbstractClassifier.java
+++ b/moa/src/main/java/moa/classifiers/AbstractClassifier.java
@@ -25,31 +25,23 @@
 import java.util.List;
 import java.util.Random;
 
-import moa.MOAObject;
-import moa.core.Example;
-
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
+import com.yahoo.labs.samoa.instances.Prediction;
 
+import moa.MOAObject;
+import moa.core.Example;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
 import moa.core.StringUtils;
+import moa.core.Utils;
 import moa.gui.AWTRenderer;
 import moa.learners.Learner;
 import moa.options.AbstractOptionHandler;
-
-import com.github.javacliparser.IntOption;
-
 import moa.tasks.TaskMonitor;
 
-import com.yahoo.labs.samoa.instances.DenseInstanceData;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
-import com.yahoo.labs.samoa.instances.Prediction;
-
-import moa.core.Utils;
-
 public abstract class AbstractClassifier extends AbstractOptionHandler
         implements Classifier { //Learner<Example<Instance>> {
 
@@ -78,10 +70,10 @@ public String getPurposeString() {
      * if the classifier is randomizable.
      */
     public AbstractClassifier() {
-        if (isRandomizable()) {
-            this.randomSeedOption = new IntOption("randomSeed", 'r',
-                    "Seed for random behaviour of the classifier.", 1);
-        }
+//        if (isRandomizable()) {
+//            this.randomSeedOption = new IntOption("randomSeed", 'r',
+//                    "Seed for random behaviour of the classifier.", 1);
+//        }
     }
 
     @Override
@@ -112,8 +104,8 @@ public Prediction getPredictionForInstance(Example<Instance> example){
 
     @Override
     public Prediction getPredictionForInstance(Instance inst){
-    	Prediction prediction= new MultiLabelPrediction(1);
-    	prediction.setVotes(getVotesForInstance(inst));
+    	Prediction prediction= new MultiLabelPrediction(inst.numOutputAttributes());
+  		prediction.setVotes(getVotesForInstance(inst));
     	return prediction;
     }
 
diff --git a/moa/src/main/java/moa/classifiers/AbstractMultiLabelLearner.java b/moa/src/main/java/moa/classifiers/AbstractMultiLabelLearner.java
index 3fefdd9ce..c4ea71475 100644
--- a/moa/src/main/java/moa/classifiers/AbstractMultiLabelLearner.java
+++ b/moa/src/main/java/moa/classifiers/AbstractMultiLabelLearner.java
@@ -1,9 +1,10 @@
 package moa.classifiers;
 
-import moa.core.Example;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
+import moa.core.Example;
 
 public abstract class AbstractMultiLabelLearner extends AbstractClassifier implements MultiLabelLearner {
 
diff --git a/moa/src/main/java/moa/classifiers/Classifier.java b/moa/src/main/java/moa/classifiers/Classifier.java
index 101d7fe3d..d246bee77 100644
--- a/moa/src/main/java/moa/classifiers/Classifier.java
+++ b/moa/src/main/java/moa/classifiers/Classifier.java
@@ -19,13 +19,12 @@
  */
 package moa.classifiers;
 
-import moa.core.Example;
-import moa.learners.Learner;
-
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
 import com.yahoo.labs.samoa.instances.Prediction;
 
+import moa.core.Example;
+import moa.learners.Learner;
+
 /**
  * Classifier interface for incremental classification models.
  *
diff --git a/moa/src/main/java/moa/classifiers/MultiLabelLearner.java b/moa/src/main/java/moa/classifiers/MultiLabelLearner.java
index ee875ee60..97e995a1c 100644
--- a/moa/src/main/java/moa/classifiers/MultiLabelLearner.java
+++ b/moa/src/main/java/moa/classifiers/MultiLabelLearner.java
@@ -1,7 +1,7 @@
 package moa.classifiers;
 
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 public interface MultiLabelLearner extends Classifier{
 	
diff --git a/moa/src/main/java/moa/classifiers/active/ActiveClassifier.java b/moa/src/main/java/moa/classifiers/active/ActiveClassifier.java
index da8922e85..6b44087f3 100644
--- a/moa/src/main/java/moa/classifiers/active/ActiveClassifier.java
+++ b/moa/src/main/java/moa/classifiers/active/ActiveClassifier.java
@@ -22,17 +22,17 @@
 
 import java.util.LinkedList;
 import java.util.List;
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.Classifier;
 
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.MultiChoiceOption;
 import com.yahoo.labs.samoa.instances.Instance;
-import moa.core.Utils;
 
+import moa.classifiers.AbstractClassifier;
+import moa.classifiers.Classifier;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
+import moa.core.Utils;
 import moa.options.ClassOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.MultiChoiceOption;
 
 /**
  * Active learning setting for evolving data streams.
diff --git a/moa/src/main/java/moa/classifiers/bayes/NaiveBayes.java b/moa/src/main/java/moa/classifiers/bayes/NaiveBayes.java
index 6c9ab92ff..4ff1ad0af 100644
--- a/moa/src/main/java/moa/classifiers/bayes/NaiveBayes.java
+++ b/moa/src/main/java/moa/classifiers/bayes/NaiveBayes.java
@@ -19,6 +19,8 @@
  */
 package moa.classifiers.bayes;
 
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
 import moa.classifiers.core.attributeclassobservers.GaussianNumericAttributeClassObserver;
@@ -27,7 +29,6 @@
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.StringUtils;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Naive Bayes incremental learner.
diff --git a/moa/src/main/java/moa/classifiers/bayes/NaiveBayesMultinomial.java b/moa/src/main/java/moa/classifiers/bayes/NaiveBayesMultinomial.java
index 5e474770e..4f5cf8063 100644
--- a/moa/src/main/java/moa/classifiers/bayes/NaiveBayesMultinomial.java
+++ b/moa/src/main/java/moa/classifiers/bayes/NaiveBayesMultinomial.java
@@ -21,14 +21,16 @@
 package moa.classifiers.bayes;
 
 import java.util.Arrays;
+
 import com.github.javacliparser.FloatOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.classifiers.AbstractClassifier;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.StringUtils;
 import moa.core.Utils;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * <!-- globalinfo-start --> Class for building and using a multinomial Naive
diff --git a/moa/src/main/java/moa/classifiers/core/AttributeSplitSuggestion.java b/moa/src/main/java/moa/classifiers/core/AttributeSplitSuggestion.java
index d8f08b3ac..8c5f21837 100644
--- a/moa/src/main/java/moa/classifiers/core/AttributeSplitSuggestion.java
+++ b/moa/src/main/java/moa/classifiers/core/AttributeSplitSuggestion.java
@@ -19,8 +19,8 @@
  */
 package moa.classifiers.core;
 
-import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
 import moa.AbstractMOAObject;
+import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
 
 /**
  * Class for computing attribute split suggestions given a split test.
diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserver.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserver.java
index d64b4f569..269039fb6 100644
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserver.java
+++ b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserver.java
@@ -21,6 +21,7 @@
 package moa.classifiers.core.attributeclassobservers;
 
 import java.io.Serializable;
+
 import moa.classifiers.core.AttributeSplitSuggestion;
 import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserverRegression.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserverRegression.java
index 7155bb235..2a084d630 100644
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserverRegression.java
+++ b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserverRegression.java
@@ -22,6 +22,7 @@
 package moa.classifiers.core.attributeclassobservers;
 
 import java.io.Serializable;
+
 import moa.classifiers.core.AttributeSplitSuggestion;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
 import moa.core.ObjectRepository;
diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/FIMTDDNumericAttributeClassObserver.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/FIMTDDNumericAttributeClassObserver.java
index cd822e4e6..c36862652 100644
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/FIMTDDNumericAttributeClassObserver.java
+++ b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/FIMTDDNumericAttributeClassObserver.java
@@ -27,6 +27,7 @@
 package moa.classifiers.core.attributeclassobservers;
 
 import java.io.Serializable;
+
 import moa.classifiers.core.AttributeSplitSuggestion;
 import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
@@ -47,7 +48,7 @@ protected class Node implements Serializable {
 
         // E-BST statistics
         public DoubleVector leftStatistics = new DoubleVector();
-        public DoubleVector rightStatistics = new DoubleVector();
+        //public DoubleVector rightStatistics = new DoubleVector();
 
         // Child nodes
         public Node left;
@@ -55,9 +56,9 @@ protected class Node implements Serializable {
 
         public Node(double val, double label, double weight) {
             this.cut_point = val;
-            this.leftStatistics.addToValue(0, 1);
-            this.leftStatistics.addToValue(1, label);
-            this.leftStatistics.addToValue(2, label * label);
+            this.leftStatistics.addToValue(0, weight);
+            this.leftStatistics.addToValue(1, weight * label);
+            this.leftStatistics.addToValue(2, weight * label * label);
         }
 
         /**
@@ -69,16 +70,16 @@ public void insertValue(double val, double label, double weight) {
 		// If the new value equals the value stored in a node, update
             // the left (<=) node information
             if (val == this.cut_point) {
-                this.leftStatistics.addToValue(0, 1);
-                this.leftStatistics.addToValue(1, label);
-                this.leftStatistics.addToValue(2, label * label);
+                this.leftStatistics.addToValue(0, weight);
+                this.leftStatistics.addToValue(1, weight * label);
+                this.leftStatistics.addToValue(2, weight * label * label);
             } // If the new value is less than the value in a node, update the
             // left distribution and send the value down to the left child node.
             // If no left child exists, create one
             else if (val <= this.cut_point) {
-                this.leftStatistics.addToValue(0, 1);
-                this.leftStatistics.addToValue(1, label);
-                this.leftStatistics.addToValue(2, label * label);
+                this.leftStatistics.addToValue(0, weight);
+                this.leftStatistics.addToValue(1, weight * label);
+                this.leftStatistics.addToValue(2, weight * label * label);
                 if (this.left == null) {
                     this.left = new Node(val, label, weight);
                 } else {
@@ -88,14 +89,14 @@ else if (val <= this.cut_point) {
             // right (>) distribution and send the value down to the right child node.
             // If no right child exists, create one
             else { // val > cut_point
-                this.rightStatistics.addToValue(0, 1);
-                this.rightStatistics.addToValue(1, label);
-                this.rightStatistics.addToValue(2, label * label);
-                if (this.right == null) {
-                    this.right = new Node(val, label, weight);
-                } else {
-                    this.right.insertValue(val, label, weight);
-                }
+                //this.rightStatistics.addToValue(0, weight);
+                //this.rightStatistics.addToValue(1, weight * label);
+                //this.rightStatistics.addToValue(2, weight * label * label);
+                //if (this.right == null) {
+                //    this.right = new Node(val, label, weight);
+                //} else {
+                //    this.right.insertValue(val, label, weight);
+                //}
             }
         }
     }
@@ -111,10 +112,20 @@ else if (val <= this.cut_point) {
     double countRightTotal;
     double countLeftTotal;
 
+	public static double roundToSignificantFigures(double num, int n) {
+	    final double d = Math.ceil(Math.log10(num < 0 ? -num: num));
+	    final int power = n - (int) d;
+
+	    final double magnitude = Math.pow(10, power);
+	    final long shifted = (long) (num*magnitude);
+	    return shifted/magnitude;
+	}
+    
     public void observeAttributeClass(double attVal, double classVal, double weight) {
         if (Double.isNaN(attVal)) { //Instance.isMissingValue(attVal)
         } else {
             if (this.root == null) {
+//            	if ((long) attVal != attVal) attVal = roundToSignificantFigures(attVal, 4);
                 this.root = new Node(attVal, classVal, weight);
             } else {
                 this.root.insertValue(attVal, classVal, weight);
@@ -215,14 +226,14 @@ private boolean removeBadSplitNodes(SplitCriterion criterion, Node currentNode,
 
         if (isBad) {
 
-            double[][] postSplitDists = new double[][]{{currentNode.leftStatistics.getValue(0), currentNode.leftStatistics.getValue(1), currentNode.leftStatistics.getValue(2)}, {currentNode.rightStatistics.getValue(0), currentNode.rightStatistics.getValue(1), currentNode.rightStatistics.getValue(2)}};
-            double[] preSplitDist = new double[]{(currentNode.leftStatistics.getValue(0) + currentNode.rightStatistics.getValue(0)), (currentNode.leftStatistics.getValue(1) + currentNode.rightStatistics.getValue(1)), (currentNode.leftStatistics.getValue(2) + currentNode.rightStatistics.getValue(2))};
-            double merit = criterion.getMeritOfSplit(preSplitDist, postSplitDists);
+            //double[][] postSplitDists = new double[][]{{currentNode.leftStatistics.getValue(0), currentNode.leftStatistics.getValue(1), currentNode.leftStatistics.getValue(2)}, {currentNode.rightStatistics.getValue(0), currentNode.rightStatistics.getValue(1), currentNode.rightStatistics.getValue(2)}};
+            //double[] preSplitDist = new double[]{(currentNode.leftStatistics.getValue(0) + currentNode.rightStatistics.getValue(0)), (currentNode.leftStatistics.getValue(1) + currentNode.rightStatistics.getValue(1)), (currentNode.leftStatistics.getValue(2) + currentNode.rightStatistics.getValue(2))};
+            //double merit = criterion.getMeritOfSplit(preSplitDist, postSplitDists);
 
-            if ((merit / lastCheckSDR) < (lastCheckRatio - (2 * lastCheckE))) {
-                currentNode = null;
-                return true;
-            }
+            //if ((merit / lastCheckSDR) < (lastCheckRatio - (2 * lastCheckE))) {
+            //    currentNode = null;
+            //    return true;
+            //}
         }
 
         return false;
diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/GaussianNumericAttributeClassObserver.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/GaussianNumericAttributeClassObserver.java
index dbc0e0e17..9d5620eee 100644
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/GaussianNumericAttributeClassObserver.java
+++ b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/GaussianNumericAttributeClassObserver.java
@@ -19,21 +19,21 @@
  */
 package moa.classifiers.core.attributeclassobservers;
 
-import moa.core.ObjectRepository;
-import moa.tasks.TaskMonitor;
-import moa.core.Utils;
-
 import java.util.Set;
 import java.util.TreeSet;
+
+import com.github.javacliparser.IntOption;
+
 import moa.classifiers.core.AttributeSplitSuggestion;
 import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
-
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
 import moa.core.GaussianEstimator;
+import moa.core.ObjectRepository;
+import moa.core.Utils;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.IntOption;
+import moa.tasks.TaskMonitor;
 
 /**
  * Class for observing the class data distribution for a numeric attribute using gaussian estimators.
diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/GreenwaldKhannaNumericAttributeClassObserver.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/GreenwaldKhannaNumericAttributeClassObserver.java
index 32061a92b..f1f3b0076 100644
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/GreenwaldKhannaNumericAttributeClassObserver.java
+++ b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/GreenwaldKhannaNumericAttributeClassObserver.java
@@ -19,17 +19,17 @@
  */
 package moa.classifiers.core.attributeclassobservers;
 
+import com.github.javacliparser.IntOption;
+
 import moa.classifiers.core.AttributeSplitSuggestion;
 import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.core.Utils;
-
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
 import moa.core.GreenwaldKhannaQuantileSummary;
 import moa.core.ObjectRepository;
+import moa.core.Utils;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
 
 /**
diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/NominalAttributeClassObserver.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/NominalAttributeClassObserver.java
index ce8021017..4ae978569 100644
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/NominalAttributeClassObserver.java
+++ b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/NominalAttributeClassObserver.java
@@ -23,13 +23,12 @@
 import moa.classifiers.core.conditionaltests.NominalAttributeBinaryTest;
 import moa.classifiers.core.conditionaltests.NominalAttributeMultiwayTest;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.core.ObjectRepository;
-import moa.tasks.TaskMonitor;
-import moa.core.Utils;
-
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
+import moa.core.ObjectRepository;
+import moa.core.Utils;
 import moa.options.AbstractOptionHandler;
+import moa.tasks.TaskMonitor;
 
 /**
  * Class for observing the class data distribution for a nominal attribute.
diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/VFMLNumericAttributeClassObserver.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/VFMLNumericAttributeClassObserver.java
index c3a4cbed7..0b4f7b3ae 100644
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/VFMLNumericAttributeClassObserver.java
+++ b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/VFMLNumericAttributeClassObserver.java
@@ -19,19 +19,19 @@
  */
 package moa.classifiers.core.attributeclassobservers;
 
-import moa.core.Utils;
-
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.List;
+
+import com.github.javacliparser.IntOption;
+
 import moa.classifiers.core.AttributeSplitSuggestion;
 import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
-
 import moa.core.DoubleVector;
 import moa.core.ObjectRepository;
+import moa.core.Utils;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
 
 /**
diff --git a/moa/src/main/java/moa/classifiers/core/conditionaltests/InstanceConditionalTest.java b/moa/src/main/java/moa/classifiers/core/conditionaltests/InstanceConditionalTest.java
index 9d5160136..08f7c7100 100644
--- a/moa/src/main/java/moa/classifiers/core/conditionaltests/InstanceConditionalTest.java
+++ b/moa/src/main/java/moa/classifiers/core/conditionaltests/InstanceConditionalTest.java
@@ -19,11 +19,11 @@
  */
 package moa.classifiers.core.conditionaltests;
 
-import moa.AbstractMOAObject;
-
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.AbstractMOAObject;
+
 /**
  * Abstract conditional test for instances to use to split nodes in Hoeffding trees.
  *
diff --git a/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeBinaryTest.java b/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeBinaryTest.java
index 519ec6a42..62f1e73bc 100644
--- a/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeBinaryTest.java
+++ b/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeBinaryTest.java
@@ -19,7 +19,6 @@
  */
 package moa.classifiers.core.conditionaltests;
 
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
diff --git a/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeMultiwayTest.java b/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeMultiwayTest.java
index a0dd5ff7b..eb1135ef1 100644
--- a/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeMultiwayTest.java
+++ b/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeMultiwayTest.java
@@ -19,7 +19,6 @@
  */
 package moa.classifiers.core.conditionaltests;
 
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
diff --git a/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java b/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
index 597a7c07f..ca81135f5 100644
--- a/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
+++ b/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
@@ -19,7 +19,6 @@
  */
 package moa.classifiers.core.conditionaltests;
 
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/ADWINChangeDetector.java b/moa/src/main/java/moa/classifiers/core/driftdetection/ADWINChangeDetector.java
index a2755fee6..fb9366e7f 100644
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/ADWINChangeDetector.java
+++ b/moa/src/main/java/moa/classifiers/core/driftdetection/ADWINChangeDetector.java
@@ -19,6 +19,7 @@
 package moa.classifiers.core.driftdetection;
 
 import com.github.javacliparser.FloatOption;
+
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/CusumDM.java b/moa/src/main/java/moa/classifiers/core/driftdetection/CusumDM.java
index 6b65bead3..8653a1007 100644
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/CusumDM.java
+++ b/moa/src/main/java/moa/classifiers/core/driftdetection/CusumDM.java
@@ -20,6 +20,7 @@
 
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
+
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/DDM.java b/moa/src/main/java/moa/classifiers/core/driftdetection/DDM.java
index be0baac1e..f1e5bb3aa 100644
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/DDM.java
+++ b/moa/src/main/java/moa/classifiers/core/driftdetection/DDM.java
@@ -19,6 +19,7 @@
 package moa.classifiers.core.driftdetection;
 
 import com.github.javacliparser.IntOption;
+
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/EWMAChartDM.java b/moa/src/main/java/moa/classifiers/core/driftdetection/EWMAChartDM.java
index 381998ebf..83b5c4981 100644
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/EWMAChartDM.java
+++ b/moa/src/main/java/moa/classifiers/core/driftdetection/EWMAChartDM.java
@@ -20,6 +20,7 @@
 
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
+
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/EnsembleDriftDetectionMethods.java b/moa/src/main/java/moa/classifiers/core/driftdetection/EnsembleDriftDetectionMethods.java
index 3a887fa63..08e68c8d3 100644
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/EnsembleDriftDetectionMethods.java
+++ b/moa/src/main/java/moa/classifiers/core/driftdetection/EnsembleDriftDetectionMethods.java
@@ -22,6 +22,7 @@
 import com.github.javacliparser.ListOption;
 import com.github.javacliparser.MultiChoiceOption;
 import com.github.javacliparser.Option;
+
 import moa.core.ObjectRepository;
 import moa.options.ClassOption;
 import moa.options.OptionHandler;
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/GeometricMovingAverageDM.java b/moa/src/main/java/moa/classifiers/core/driftdetection/GeometricMovingAverageDM.java
index e3bbee7bf..1b7074ed2 100644
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/GeometricMovingAverageDM.java
+++ b/moa/src/main/java/moa/classifiers/core/driftdetection/GeometricMovingAverageDM.java
@@ -20,6 +20,7 @@
 
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
+
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/HDDM_A_Test.java b/moa/src/main/java/moa/classifiers/core/driftdetection/HDDM_A_Test.java
index 92b963bdd..37d4118da 100644
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/HDDM_A_Test.java
+++ b/moa/src/main/java/moa/classifiers/core/driftdetection/HDDM_A_Test.java
@@ -23,6 +23,7 @@
 
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.MultiChoiceOption;
+
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/HDDM_W_Test.java b/moa/src/main/java/moa/classifiers/core/driftdetection/HDDM_W_Test.java
index 0ed125f45..b4c6111e4 100644
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/HDDM_W_Test.java
+++ b/moa/src/main/java/moa/classifiers/core/driftdetection/HDDM_W_Test.java
@@ -21,6 +21,7 @@
 
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.MultiChoiceOption;
+
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/PageHinkleyDM.java b/moa/src/main/java/moa/classifiers/core/driftdetection/PageHinkleyDM.java
index a9c916ea2..fecdb775d 100644
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/PageHinkleyDM.java
+++ b/moa/src/main/java/moa/classifiers/core/driftdetection/PageHinkleyDM.java
@@ -20,6 +20,7 @@
 
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
+
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/SEEDChangeDetector.java b/moa/src/main/java/moa/classifiers/core/driftdetection/SEEDChangeDetector.java
index 8b6226430..8f7124b0e 100644
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/SEEDChangeDetector.java
+++ b/moa/src/main/java/moa/classifiers/core/driftdetection/SEEDChangeDetector.java
@@ -21,6 +21,7 @@
 
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
+
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/SeqDrift1ChangeDetector.java b/moa/src/main/java/moa/classifiers/core/driftdetection/SeqDrift1ChangeDetector.java
index bc5bca3d6..72aae962a 100644
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/SeqDrift1ChangeDetector.java
+++ b/moa/src/main/java/moa/classifiers/core/driftdetection/SeqDrift1ChangeDetector.java
@@ -18,13 +18,15 @@
  */
 package moa.classifiers.core.driftdetection;
 
+import java.util.ArrayList;
+
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
-import moa.core.ObjectRepository;
-import moa.tasks.TaskMonitor;
-import java.util.ArrayList;
+
 import moa.AbstractMOAObject;
 import moa.classifiers.core.driftdetection.SeqDrift2ChangeDetector.Repository;
+import moa.core.ObjectRepository;
+import moa.tasks.TaskMonitor;
 
 /**
  * SeqDrift1ChangeDetector.java. This extends Abstract Change Detector 
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/SeqDrift2ChangeDetector.java b/moa/src/main/java/moa/classifiers/core/driftdetection/SeqDrift2ChangeDetector.java
index 6278e15fc..37de7e7fc 100644
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/SeqDrift2ChangeDetector.java
+++ b/moa/src/main/java/moa/classifiers/core/driftdetection/SeqDrift2ChangeDetector.java
@@ -18,13 +18,15 @@
  */
 package moa.classifiers.core.driftdetection;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
+
+import moa.AbstractMOAObject;
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
-import java.util.ArrayList;
-import java.util.List;
-import moa.AbstractMOAObject;
 
 /**
  * SeqDriftChangeDetector.java. This extends Abstract Change Detector 
diff --git a/moa/src/main/java/moa/classifiers/core/splitcriteria/InfoGainSplitCriterion.java b/moa/src/main/java/moa/classifiers/core/splitcriteria/InfoGainSplitCriterion.java
index bbb6a0eea..516ac8823 100644
--- a/moa/src/main/java/moa/classifiers/core/splitcriteria/InfoGainSplitCriterion.java
+++ b/moa/src/main/java/moa/classifiers/core/splitcriteria/InfoGainSplitCriterion.java
@@ -20,6 +20,7 @@
 package moa.classifiers.core.splitcriteria;
 
 import com.github.javacliparser.FloatOption;
+
 import moa.core.ObjectRepository;
 import moa.core.Utils;
 import moa.options.AbstractOptionHandler;
diff --git a/moa/src/main/java/moa/classifiers/drift/DriftDetectionMethodClassifier.java b/moa/src/main/java/moa/classifiers/drift/DriftDetectionMethodClassifier.java
index 06a4f60d2..b920e82fa 100644
--- a/moa/src/main/java/moa/classifiers/drift/DriftDetectionMethodClassifier.java
+++ b/moa/src/main/java/moa/classifiers/drift/DriftDetectionMethodClassifier.java
@@ -18,15 +18,17 @@
  */
 package moa.classifiers.drift;
 
-import com.yahoo.labs.samoa.instances.Instance;
 import java.util.LinkedList;
 import java.util.List;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
+import moa.classifiers.core.driftdetection.ChangeDetector;
 import moa.classifiers.meta.WEKAClassifier;
 import moa.core.Measurement;
 import moa.core.Utils;
-import moa.classifiers.core.driftdetection.ChangeDetector;
 import moa.options.ClassOption;
 
 /**
diff --git a/moa/src/main/java/moa/classifiers/functions/MajorityClass.java b/moa/src/main/java/moa/classifiers/functions/MajorityClass.java
index e92892bcc..bf254d191 100644
--- a/moa/src/main/java/moa/classifiers/functions/MajorityClass.java
+++ b/moa/src/main/java/moa/classifiers/functions/MajorityClass.java
@@ -19,11 +19,12 @@
  */
 package moa.classifiers.functions;
 
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.StringUtils;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Majority class learner. This is the simplest classifier.
diff --git a/moa/src/main/java/moa/classifiers/functions/NoChange.java b/moa/src/main/java/moa/classifiers/functions/NoChange.java
index e52b5608a..ee45de0ee 100644
--- a/moa/src/main/java/moa/classifiers/functions/NoChange.java
+++ b/moa/src/main/java/moa/classifiers/functions/NoChange.java
@@ -19,9 +19,10 @@
  */
 package moa.classifiers.functions;
 
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.core.Measurement;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * NoChange class classifier. It always predicts the last class seen.
diff --git a/moa/src/main/java/moa/classifiers/functions/Perceptron.java b/moa/src/main/java/moa/classifiers/functions/Perceptron.java
index ca4c997ff..8e5fa11d5 100644
--- a/moa/src/main/java/moa/classifiers/functions/Perceptron.java
+++ b/moa/src/main/java/moa/classifiers/functions/Perceptron.java
@@ -19,11 +19,12 @@
  */
 package moa.classifiers.functions;
 
+import com.github.javacliparser.FloatOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.core.Measurement;
 import moa.core.Utils;
-import com.github.javacliparser.FloatOption;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Single perceptron classifier.
diff --git a/moa/src/main/java/moa/classifiers/functions/SGD.java b/moa/src/main/java/moa/classifiers/functions/SGD.java
index 12df09340..8c5100f56 100644
--- a/moa/src/main/java/moa/classifiers/functions/SGD.java
+++ b/moa/src/main/java/moa/classifiers/functions/SGD.java
@@ -27,14 +27,15 @@
 
 package moa.classifiers.functions;
 
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
+import moa.classifiers.Regressor;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.StringUtils;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.MultiChoiceOption;
-import moa.classifiers.Regressor;
-import com.yahoo.labs.samoa.instances.Instance;
 import moa.core.Utils;
 
 /**
diff --git a/moa/src/main/java/moa/classifiers/functions/SGDMultiClass.java b/moa/src/main/java/moa/classifiers/functions/SGDMultiClass.java
index 3b7c274b1..f7c824815 100644
--- a/moa/src/main/java/moa/classifiers/functions/SGDMultiClass.java
+++ b/moa/src/main/java/moa/classifiers/functions/SGDMultiClass.java
@@ -27,14 +27,15 @@
 
 package moa.classifiers.functions;
 
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Regressor;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.StringUtils;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
 import moa.core.Utils;
 
 
diff --git a/moa/src/main/java/moa/classifiers/functions/SPegasos.java b/moa/src/main/java/moa/classifiers/functions/SPegasos.java
index cf562e6e5..3b418f734 100644
--- a/moa/src/main/java/moa/classifiers/functions/SPegasos.java
+++ b/moa/src/main/java/moa/classifiers/functions/SPegasos.java
@@ -25,12 +25,13 @@
  */
 package moa.classifiers.functions;
 
-import moa.classifiers.AbstractClassifier;
-import moa.core.Measurement;
-import moa.core.StringUtils;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.MultiChoiceOption;
 import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.classifiers.AbstractClassifier;
+import moa.core.Measurement;
+import moa.core.StringUtils;
 import moa.core.Utils;
 
 /**
diff --git a/moa/src/main/java/moa/classifiers/lazy/kNN.java b/moa/src/main/java/moa/classifiers/lazy/kNN.java
index 1cf765b1d..f3ad62446 100644
--- a/moa/src/main/java/moa/classifiers/lazy/kNN.java
+++ b/moa/src/main/java/moa/classifiers/lazy/kNN.java
@@ -17,16 +17,16 @@
  */
 package moa.classifiers.lazy;
 
-import java.io.StringReader;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.lazy.neighboursearch.KDTree;
 import moa.classifiers.lazy.neighboursearch.LinearNNSearch;
 import moa.classifiers.lazy.neighboursearch.NearestNeighbourSearch;
 import moa.core.Measurement;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.MultiChoiceOption;
 
 /**
  * k Nearest Neighbor.<p>
diff --git a/moa/src/main/java/moa/classifiers/lazy/kNNwithPAW.java b/moa/src/main/java/moa/classifiers/lazy/kNNwithPAW.java
index 6b78777a3..ae232b9b0 100644
--- a/moa/src/main/java/moa/classifiers/lazy/kNNwithPAW.java
+++ b/moa/src/main/java/moa/classifiers/lazy/kNNwithPAW.java
@@ -17,7 +17,6 @@
  */
 package moa.classifiers.lazy;
 
-import moa.classifiers.core.driftdetection.ADWIN;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
diff --git a/moa/src/main/java/moa/classifiers/lazy/kNNwithPAWandADWIN.java b/moa/src/main/java/moa/classifiers/lazy/kNNwithPAWandADWIN.java
index 65e9266ed..74670860e 100644
--- a/moa/src/main/java/moa/classifiers/lazy/kNNwithPAWandADWIN.java
+++ b/moa/src/main/java/moa/classifiers/lazy/kNNwithPAWandADWIN.java
@@ -18,10 +18,12 @@
 package moa.classifiers.lazy;
 
 import java.util.ArrayList;
-import moa.classifiers.core.driftdetection.ADWIN;
+
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.classifiers.core.driftdetection.ADWIN;
+
 /**
  * k Nearest Neighbor ADAPTIVE with ADWIN+PAW.<p>
  *
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/KDTree.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/KDTree.java
index b3b6d7a0d..684f063d8 100644
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/KDTree.java
+++ b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/KDTree.java
@@ -23,11 +23,13 @@
 
 import java.util.Enumeration;
 import java.util.Vector;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.classifiers.lazy.neighboursearch.kdtrees.KDTreeNode;
 import moa.classifiers.lazy.neighboursearch.kdtrees.KDTreeNodeSplitter;
 import moa.classifiers.lazy.neighboursearch.kdtrees.SlidingMidPointOfWidestSide;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 
 
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NearestNeighbourSearch.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NearestNeighbourSearch.java
index ddefd58ae..541d0f527 100644
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NearestNeighbourSearch.java
+++ b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NearestNeighbourSearch.java
@@ -21,6 +21,7 @@
 package moa.classifiers.lazy.neighboursearch;
 
 import java.io.Serializable;
+
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NormalizableDistance.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NormalizableDistance.java
index 7800a8576..46da24f3e 100644
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NormalizableDistance.java
+++ b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NormalizableDistance.java
@@ -21,7 +21,6 @@
 
 package moa.classifiers.lazy.neighboursearch;
 
-import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KDTreeNodeSplitter.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KDTreeNodeSplitter.java
index f69760c9f..61126b4a0 100644
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KDTreeNodeSplitter.java
+++ b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KDTreeNodeSplitter.java
@@ -23,10 +23,11 @@
 import java.io.Serializable;
 import java.util.Enumeration;
 import java.util.Vector;
-import moa.classifiers.lazy.neighboursearch.EuclideanDistance;
 
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.classifiers.lazy.neighboursearch.EuclideanDistance;
+
 /**
  * Class that splits up a KDTreeNode.
  * 
diff --git a/moa/src/main/java/moa/classifiers/meta/ADACC.java b/moa/src/main/java/moa/classifiers/meta/ADACC.java
index 8aa324af8..f5dbe47c1 100644
--- a/moa/src/main/java/moa/classifiers/meta/ADACC.java
+++ b/moa/src/main/java/moa/classifiers/meta/ADACC.java
@@ -20,15 +20,16 @@
 
 package moa.classifiers.meta;
 
+import java.util.Arrays;
+import java.util.Collections;
+
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.classifiers.Classifier;
 import moa.core.Measurement;
-
-import java.util.Arrays;
-import java.util.Collections;
 import moa.core.Utils;
 
 /**
diff --git a/moa/src/main/java/moa/classifiers/meta/AccuracyUpdatedEnsemble.java b/moa/src/main/java/moa/classifiers/meta/AccuracyUpdatedEnsemble.java
index f9764fa19..7a935202d 100644
--- a/moa/src/main/java/moa/classifiers/meta/AccuracyUpdatedEnsemble.java
+++ b/moa/src/main/java/moa/classifiers/meta/AccuracyUpdatedEnsemble.java
@@ -19,6 +19,10 @@
  */
 package moa.classifiers.meta;
 
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
 import moa.classifiers.trees.HoeffdingTree;
@@ -26,10 +30,7 @@
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
 import moa.options.ClassOption;
-import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * The revised version of the Accuracy Updated Ensemble as proposed by
diff --git a/moa/src/main/java/moa/classifiers/meta/AccuracyWeightedEnsemble.java b/moa/src/main/java/moa/classifiers/meta/AccuracyWeightedEnsemble.java
index df7e6fea1..3fd651d59 100644
--- a/moa/src/main/java/moa/classifiers/meta/AccuracyWeightedEnsemble.java
+++ b/moa/src/main/java/moa/classifiers/meta/AccuracyWeightedEnsemble.java
@@ -20,18 +20,20 @@
 package moa.classifiers.meta;
 
 import java.util.Random;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
+import moa.core.Utils;
 import moa.options.ClassOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import moa.core.Utils;
 
 /**
  * The Accuracy Weighted Ensemble classifier as proposed by Wang et al. in
@@ -433,9 +435,9 @@ protected Classifier addToStored(Classifier newClassifier, double newClassifiers
      *
      * @return the size of the removed classifier.
      */
-    protected int removePoorestModelBytes() {
+    protected long removePoorestModelBytes() {
         int poorestIndex = Utils.minIndex(this.ensembleWeights);
-        int byteSize = this.ensemble[poorestIndex].measureByteSize();
+        long byteSize = this.ensemble[poorestIndex].measureByteSize();
         discardModel(poorestIndex);
         return byteSize;
     }
diff --git a/moa/src/main/java/moa/classifiers/meta/DACC.java b/moa/src/main/java/moa/classifiers/meta/DACC.java
index 8cb76472b..dfb470e1e 100644
--- a/moa/src/main/java/moa/classifiers/meta/DACC.java
+++ b/moa/src/main/java/moa/classifiers/meta/DACC.java
@@ -20,18 +20,19 @@
 
 package moa.classifiers.meta;
 
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.MultiChoiceOption;
 import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
 import moa.options.ClassOption;
 
 /**
diff --git a/moa/src/main/java/moa/classifiers/meta/LeveragingBag.java b/moa/src/main/java/moa/classifiers/meta/LeveragingBag.java
index 6d6e78830..3edcf5ae1 100644
--- a/moa/src/main/java/moa/classifiers/meta/LeveragingBag.java
+++ b/moa/src/main/java/moa/classifiers/meta/LeveragingBag.java
@@ -19,20 +19,19 @@
  */
 package moa.classifiers.meta;
 
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.FlagOption;
-import moa.options.ClassOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
 import com.github.javacliparser.MultiChoiceOption;
-import moa.classifiers.core.driftdetection.ADWIN;
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.Classifier;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.classifiers.AbstractClassifier;
+import moa.classifiers.Classifier;
+import moa.classifiers.core.driftdetection.ADWIN;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.MiscUtils;
-import moa.options.*;
+import moa.options.ClassOption;
 
 /**
  * Leveraging Bagging for evolving data streams using ADWIN. Leveraging Bagging
diff --git a/moa/src/main/java/moa/classifiers/meta/LimAttClassifier.java b/moa/src/main/java/moa/classifiers/meta/LimAttClassifier.java
index 8cb281802..d223111dc 100644
--- a/moa/src/main/java/moa/classifiers/meta/LimAttClassifier.java
+++ b/moa/src/main/java/moa/classifiers/meta/LimAttClassifier.java
@@ -20,21 +20,21 @@
  */
 package moa.classifiers.meta;
 
-import moa.classifiers.trees.LimAttHoeffdingTree;
-import com.yahoo.labs.samoa.instances.Instance;
-import moa.core.Utils;
-
 import java.math.BigInteger;
 import java.util.Arrays;
-import moa.classifiers.core.driftdetection.ADWIN;
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.Classifier;
 
-import moa.core.Measurement;
-import moa.options.ClassOption;
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.classifiers.AbstractClassifier;
+import moa.classifiers.Classifier;
+import moa.classifiers.core.driftdetection.ADWIN;
+import moa.classifiers.trees.LimAttHoeffdingTree;
+import moa.core.Measurement;
+import moa.core.Utils;
+import moa.options.ClassOption;
 
 /**
  * Ensemble Combining Restricted Hoeffding Trees using Stacking.
diff --git a/moa/src/main/java/moa/classifiers/meta/OCBoost.java b/moa/src/main/java/moa/classifiers/meta/OCBoost.java
index 9e796ff7b..e9c33ff73 100644
--- a/moa/src/main/java/moa/classifiers/meta/OCBoost.java
+++ b/moa/src/main/java/moa/classifiers/meta/OCBoost.java
@@ -19,15 +19,15 @@
  */
 package moa.classifiers.meta;
 
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.Classifier;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
-import moa.core.Utils;
 
+import moa.classifiers.AbstractClassifier;
+import moa.classifiers.Classifier;
 import moa.core.Measurement;
+import moa.core.Utils;
 import moa.options.ClassOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
 
 /**
  * Online Coordinate boosting for two classes evolving data streams. 
diff --git a/moa/src/main/java/moa/classifiers/meta/OnlineAccuracyUpdatedEnsemble.java b/moa/src/main/java/moa/classifiers/meta/OnlineAccuracyUpdatedEnsemble.java
index 790599ff4..44e381d78 100644
--- a/moa/src/main/java/moa/classifiers/meta/OnlineAccuracyUpdatedEnsemble.java
+++ b/moa/src/main/java/moa/classifiers/meta/OnlineAccuracyUpdatedEnsemble.java
@@ -23,6 +23,7 @@
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
 import moa.classifiers.trees.HoeffdingTree;
diff --git a/moa/src/main/java/moa/classifiers/meta/OnlineSmoothBoost.java b/moa/src/main/java/moa/classifiers/meta/OnlineSmoothBoost.java
index 0810d2153..445ca1027 100644
--- a/moa/src/main/java/moa/classifiers/meta/OnlineSmoothBoost.java
+++ b/moa/src/main/java/moa/classifiers/meta/OnlineSmoothBoost.java
@@ -22,6 +22,7 @@
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
 import moa.core.DoubleVector;
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBag.java b/moa/src/main/java/moa/classifiers/meta/OzaBag.java
index 9ca3dd639..d43f2da0b 100644
--- a/moa/src/main/java/moa/classifiers/meta/OzaBag.java
+++ b/moa/src/main/java/moa/classifiers/meta/OzaBag.java
@@ -19,15 +19,15 @@
  */
 package moa.classifiers.meta;
 
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.Classifier;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.classifiers.AbstractClassifier;
+import moa.classifiers.Classifier;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.MiscUtils;
 import moa.options.ClassOption;
-import com.github.javacliparser.IntOption;
 
 /**
  * Incremental on-line bagging of Oza and Russell.
@@ -66,6 +66,14 @@ public String getPurposeString() {
 
     protected Classifier[] ensemble;
 
+    @Override
+    public long measureByteSize() {
+    	long size = 0;
+    	for (Classifier c : ensemble) 
+    		size += c.measureByteSize();
+    	return size;
+    }
+    
     @Override
     public void resetLearningImpl() {
         this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBagASHT.java b/moa/src/main/java/moa/classifiers/meta/OzaBagASHT.java
index 4496d81de..308ef2454 100644
--- a/moa/src/main/java/moa/classifiers/meta/OzaBagASHT.java
+++ b/moa/src/main/java/moa/classifiers/meta/OzaBagASHT.java
@@ -19,13 +19,14 @@
  */
 package moa.classifiers.meta;
 
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.Classifier;
 import moa.classifiers.trees.ASHoeffdingTree;
 import moa.core.DoubleVector;
 import moa.core.MiscUtils;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.FlagOption;
-import com.yahoo.labs.samoa.instances.Instance;
 import moa.core.Utils;
 
 /**
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBagAdwin.java b/moa/src/main/java/moa/classifiers/meta/OzaBagAdwin.java
index fa688e426..8f790f339 100644
--- a/moa/src/main/java/moa/classifiers/meta/OzaBagAdwin.java
+++ b/moa/src/main/java/moa/classifiers/meta/OzaBagAdwin.java
@@ -19,16 +19,16 @@
  */
 package moa.classifiers.meta;
 
-import moa.classifiers.core.driftdetection.ADWIN;
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.Classifier;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.classifiers.AbstractClassifier;
+import moa.classifiers.Classifier;
+import moa.classifiers.core.driftdetection.ADWIN;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.MiscUtils;
 import moa.options.ClassOption;
-import com.github.javacliparser.IntOption;
 
 /**
  * Bagging for evolving data streams using ADWIN.
@@ -141,7 +141,7 @@ public void trainOnInstanceImpl(Instance inst) {
             }
             if (imax != -1) {
                 this.ensemble[imax].resetLearning();
-                //this.ensemble[imax].trainOnInstance(inst);
+                this.ensemble[imax].trainOnInstance(inst);
                 this.ADError[imax] = new ADWIN();
             }
         }
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBoost.java b/moa/src/main/java/moa/classifiers/meta/OzaBoost.java
index 54fc8e15b..cf149c8c9 100644
--- a/moa/src/main/java/moa/classifiers/meta/OzaBoost.java
+++ b/moa/src/main/java/moa/classifiers/meta/OzaBoost.java
@@ -19,16 +19,16 @@
  */
 package moa.classifiers.meta;
 
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.Classifier;
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.classifiers.AbstractClassifier;
+import moa.classifiers.Classifier;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.MiscUtils;
 import moa.options.ClassOption;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
 
 /**
  * Incremental on-line boosting of Oza and Russell.
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBoostAdwin.java b/moa/src/main/java/moa/classifiers/meta/OzaBoostAdwin.java
index 17d370547..1e60ba154 100644
--- a/moa/src/main/java/moa/classifiers/meta/OzaBoostAdwin.java
+++ b/moa/src/main/java/moa/classifiers/meta/OzaBoostAdwin.java
@@ -19,17 +19,18 @@
  */
 package moa.classifiers.meta;
 
-import moa.classifiers.core.driftdetection.ADWIN;
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
+import moa.classifiers.core.driftdetection.ADWIN;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.MiscUtils;
 import moa.options.ClassOption;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Boosting for evolving data streams using ADWIN.
diff --git a/moa/src/main/java/moa/classifiers/meta/PairedLearners.java b/moa/src/main/java/moa/classifiers/meta/PairedLearners.java
index dc071be46..9ec64027e 100644
--- a/moa/src/main/java/moa/classifiers/meta/PairedLearners.java
+++ b/moa/src/main/java/moa/classifiers/meta/PairedLearners.java
@@ -18,18 +18,19 @@
  */
 package moa.classifiers.meta;
 
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
 import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
 
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
 import moa.core.Measurement;
-import moa.options.ClassOption;
-import com.yahoo.labs.samoa.instances.Instance;
 import moa.core.MiscUtils;
+import moa.options.ClassOption;
 
 /**
  * Creates two classifiers: a stable and a reactive. The first represents the
diff --git a/moa/src/main/java/moa/classifiers/meta/RandomRules.java b/moa/src/main/java/moa/classifiers/meta/RandomRules.java
index e170e1ef7..143849bdb 100644
--- a/moa/src/main/java/moa/classifiers/meta/RandomRules.java
+++ b/moa/src/main/java/moa/classifiers/meta/RandomRules.java
@@ -19,14 +19,12 @@
  */
 package moa.classifiers.meta;
 
-import moa.options.ClassOption;
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
@@ -35,6 +33,7 @@
 import moa.core.FastVector;
 import moa.core.Measurement;
 import moa.core.MiscUtils;
+import moa.options.ClassOption;
 import moa.streams.InstanceStream;
 
 
diff --git a/moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java b/moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java
index eac49168d..431348c5d 100644
--- a/moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java
+++ b/moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java
@@ -19,21 +19,23 @@
  */
 package moa.classifiers.meta;
 
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Attribute;
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
 import moa.core.Measurement;
 import moa.core.Utils;
 import moa.options.ClassOption;
-import com.yahoo.labs.samoa.instances.Attribute;
-import com.yahoo.labs.samoa.instances.DenseInstance;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Include labels of previous instances into the training data
diff --git a/moa/src/main/java/moa/classifiers/meta/WEKAClassifier.java b/moa/src/main/java/moa/classifiers/meta/WEKAClassifier.java
index d9ac321c8..b2595ff28 100644
--- a/moa/src/main/java/moa/classifiers/meta/WEKAClassifier.java
+++ b/moa/src/main/java/moa/classifiers/meta/WEKAClassifier.java
@@ -20,15 +20,15 @@
  */
 package moa.classifiers.meta;
 
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
+
 import moa.classifiers.AbstractClassifier;
 import moa.core.Measurement;
-import com.github.javacliparser.IntOption;
 import moa.options.WEKAClassOption;
 import weka.classifiers.Classifier;
 import weka.classifiers.UpdateableClassifier;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
 
 /**
  * Class for using a classifier from WEKA.
diff --git a/moa/src/main/java/moa/classifiers/meta/WeightedMajorityAlgorithm.java b/moa/src/main/java/moa/classifiers/meta/WeightedMajorityAlgorithm.java
index c08bdfe6a..8ee34158b 100644
--- a/moa/src/main/java/moa/classifiers/meta/WeightedMajorityAlgorithm.java
+++ b/moa/src/main/java/moa/classifiers/meta/WeightedMajorityAlgorithm.java
@@ -19,19 +19,20 @@
  */
 package moa.classifiers.meta;
 
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.ListOption;
+import com.github.javacliparser.Option;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
+import moa.core.Utils;
 import moa.options.ClassOption;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.ListOption;
-import com.github.javacliparser.Option;
 import moa.tasks.TaskMonitor;
-import com.yahoo.labs.samoa.instances.Instance;
-import moa.core.Utils;
 
 /**
  * Weighted majority algorithm for data streams.
@@ -196,9 +197,9 @@ public void discardModel(int index) {
         this.ensembleWeights = newEnsembleWeights;
     }
 
-    protected int removePoorestModelBytes() {
+    protected long removePoorestModelBytes() {
         int poorestIndex = Utils.minIndex(this.ensembleWeights);
-        int byteSize = this.ensemble[poorestIndex].measureByteSize();
+        long byteSize = this.ensemble[poorestIndex].measureByteSize();
         discardModel(poorestIndex);
         return byteSize;
     }
diff --git a/moa/src/main/java/moa/classifiers/multilabel/HoeffdingTreeClassifLeaves.java b/moa/src/main/java/moa/classifiers/multilabel/HoeffdingTreeClassifLeaves.java
index a70def66a..600e2f2ae 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/HoeffdingTreeClassifLeaves.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/HoeffdingTreeClassifLeaves.java
@@ -22,12 +22,14 @@
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Set;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.Classifier;
 import moa.classifiers.core.AttributeSplitSuggestion;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
 import moa.classifiers.trees.HoeffdingTree;
 import moa.options.ClassOption;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Hoeffding Tree that have a classifier at the leaves.
diff --git a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
index 7ac2b2825..6924b00e9 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
@@ -7,9 +7,9 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.AbstractMultiLabelLearner;
@@ -17,6 +17,7 @@
 import moa.classifiers.MultiLabelClassifier;
 import moa.classifiers.MultiTargetRegressor;
 import moa.core.Measurement;
+import moa.core.SizeOf;
 import moa.options.ClassOption;
 
 public class LocalMultiTargetClassifier extends AbstractMultiLabelLearner
@@ -36,6 +37,17 @@ public class LocalMultiTargetClassifier extends AbstractMultiLabelLearner
 	
 	ArrayList<Classifier> classifiers = null;
 	ArrayList<InstancesHeader> headers = null;
+
+	@Override
+	public long measureByteSize() {
+		long size = 0;
+		for (Classifier c : classifiers)
+			size += c.measureByteSize();
+		for (InstancesHeader h : headers) {
+			size += SizeOf.sizeOf(h);
+		}
+		return size;
+	}
 	
 	@Override
 	public boolean isRandomizable() {
@@ -60,6 +72,7 @@ private void makeHeaders() {
 				attributes.add(getModelContext().outputAttribute(target));
 				InstancesHeader STHeader = new InstancesHeader();
 				STHeader.setAttributes(attributes);
+				STHeader.setInstances(new ArrayList<Instance>()); 
 				STHeader.setClassIndex(getModelContext().numInputAttributes());
 				headers.add(STHeader);
 			}
@@ -77,9 +90,7 @@ private Instance getSTInstance(StructuredInstance inst, int target) {
 	}
 	
 	@Override
-	public void trainOnInstanceImpl(StructuredInstance instance) {
-		initializeClassifiers();
-		
+	public void trainOnInstanceImpl(StructuredInstance instance) {		
 		for (int j = 0; j < instance.numberOutputTargets(); j++) {
 			Instance STInst = getSTInstance(instance, j);
 			
@@ -89,8 +100,6 @@ public void trainOnInstanceImpl(StructuredInstance instance) {
 
 	@Override
 	public Prediction getPredictionForInstance(StructuredInstance inst) {
-		initializeClassifiers();
-
 		MultiLabelPrediction prediction = new MultiLabelPrediction(getModelContext().numOutputAttributes());
 		for (int j = 0; j < inst.numberOutputTargets(); j++) {
 			Instance STInst = getSTInstance(inst, j);
@@ -102,21 +111,22 @@ public Prediction getPredictionForInstance(StructuredInstance inst) {
 	@Override
 	public void resetLearningImpl() {
 		classifiers = null;
-
+	}
+	
+	public void modelContextSet() {
+		initializeClassifiers();
+		makeHeaders();
+		for (int i = 0; i < classifiers.size(); i++)
+			classifiers.get(i).setModelContext(getHeader(i));
 	}
 
 	public void initializeClassifiers() {
-		this.classifierRandom.setSeed(1234);
-		if (classifiers == null) {
-			makeHeaders();
-			classifiers = new ArrayList<Classifier>();
-			for (int i = 0; i < getModelContext().numOutputAttributes(); i++) {
-				Classifier learner = ((Classifier) getPreparedClassOption(this.classifierOption)).copy();
-				classifiers.add(learner);
-				learner.resetLearning();
-				((AbstractClassifier) learner).classifierRandom = this.classifierRandom;
-				learner.setModelContext(getHeader(i));
-			}
+		classifiers = new ArrayList<Classifier>();
+		for (int i = 0; i < getModelContext().numOutputAttributes(); i++) {
+			Classifier learner = ((Classifier) getPreparedClassOption(this.classifierOption)).copy();
+			classifiers.add(learner);
+			learner.resetLearning();
+			((AbstractClassifier) learner).classifierRandom = this.classifierRandom;
 		}
 	}
 	
diff --git a/moa/src/main/java/moa/classifiers/multilabel/MEKAClassifier.java b/moa/src/main/java/moa/classifiers/multilabel/MEKAClassifier.java
index 96e8f09ac..388634637 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/MEKAClassifier.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/MEKAClassifier.java
@@ -19,28 +19,20 @@
  */
 package moa.classifiers.multilabel;
 
-import java.util.Arrays;
 import java.io.Serializable;
-import moa.core.Measurement;
-import weka.classifiers.UpdateableClassifier;
-import moa.classifiers.AbstractClassifier;
-import moa.core.Measurement;
-import com.github.javacliparser.IntOption;
-import moa.options.WEKAClassOption;
-import weka.classifiers.Classifier;
-import weka.classifiers.UpdateableClassifier;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
 
-import com.yahoo.labs.samoa.instances.StructuredInstance;
+import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
-import moa.classifiers.MultiLabelLearner;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.classifiers.AbstractMultiLabelLearner;
 import moa.classifiers.MultiTargetRegressor;
-import moa.core.Example;
+import moa.core.Measurement;
+import moa.options.WEKAClassOption;
+import weka.classifiers.Classifier;
+import weka.classifiers.UpdateableClassifier;
 
 /**
  * Wrapper for MEKA classifiers. 
diff --git a/moa/src/main/java/moa/classifiers/multilabel/MajorityLabelset.java b/moa/src/main/java/moa/classifiers/multilabel/MajorityLabelset.java
index 135f8f88e..9ac0dd346 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/MajorityLabelset.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/MajorityLabelset.java
@@ -19,16 +19,15 @@
  */
 package moa.classifiers.multilabel;
 
-import java.util.Arrays;
 import java.util.HashMap;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import moa.core.Measurement;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.classifiers.AbstractMultiLabelLearner;
 import moa.classifiers.MultiTargetRegressor;
+import moa.core.Measurement;
 import moa.core.StringUtils;
 
 /**
diff --git a/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java b/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java
index 1801eba28..85de46c30 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java
@@ -19,23 +19,21 @@
  */
 package moa.classifiers.multilabel;
 
-import java.io.StringReader;
+import java.util.LinkedList;
 import java.util.List;
-import moa.classifiers.Classifier;
-import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
-import moa.classifiers.trees.HoeffdingTree;
-import moa.core.StringUtils;
-import moa.core.utils.Converter;
+
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
-import java.util.LinkedList;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
+import moa.classifiers.Classifier;
 import moa.classifiers.MultiLabelLearner;
 import moa.classifiers.MultiTargetRegressor;
+import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
+import moa.classifiers.trees.HoeffdingTree;
 import moa.core.Example;
-import java.util.Arrays;
+import moa.core.StringUtils;
 
 /**
  * Hoeffding Tree for classifying multi-label data.
@@ -46,7 +44,7 @@
  * 
  * 
  */ 
-public class MultilabelHoeffdingTree extends HoeffdingTreeClassifLeaves implements MultiLabelLearner, MultiTargetRegressor { 
+public class MultilabelHoeffdingTree extends HoeffdingTreeClassifLeaves implements MultiLabelLearner, MultiTargetRegressor, Classifier { 
 // Needs to use InfoGainSplitCriterionMultiLabel, since multilabel entropy is calculated in a different way 
 // Trains a mlinstance adding statistics of several class values and training node classifiers
 // Get votes from the classifier in the learning node of the tree
@@ -82,7 +80,7 @@ public MultilabelInactiveLearningNode(double[] initialClassObservations) {
 		public void learnFromInstance(Instance inst, HoeffdingTree ht) {
 			List<Integer> labels = ((MultilabelHoeffdingTree) ht).getRelevantLabels(inst);
 			for (int l : labels){
-				this.observedClassDistribution.addToValue( l, inst.weight());
+				this.observedClassDistribution.addToValue(l, inst.weight());
 			}
 		}
 	}
@@ -117,7 +115,7 @@ public Prediction getPredictionForInstance(Instance inst, HoeffdingTree ht) {
 
 			return this.classifier.getPredictionForInstance(inst);
 		}
-
+		
 		@Override
 		public void disableAttribute(int attIndex) {
 			// should not disable poor atts - they are used in NB calc
@@ -183,8 +181,12 @@ public Prediction getPredictionForInstance(Example<Instance> example) {
 		return getPredictionForInstance((StructuredInstance)example.getData());
 	}
 
+	public Prediction getPredictionForInstance(StructuredInstance inst) {
+		return getPredictionForInstance((Instance) inst);
+	}
+	
 	@Override
-	public Prediction getPredictionForInstance(StructuredInstance inst){
+	public Prediction getPredictionForInstance(Instance inst){
 
 		if (this.treeRoot != null) {
 			FoundNode foundNode = this.treeRoot.filterInstanceToLeaf(inst, null, -1);
diff --git a/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelBSTree.java b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelBSTree.java
index 58fd92faa..6a23d619d 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelBSTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelBSTree.java
@@ -18,7 +18,7 @@ public class MultiLabelBSTree extends AbstractOptionHandler implements NumericSt
 	/**
 	 * 
 	 */
-	public IntOption maxNodesOption = new IntOption("maxNodesOption", 'z', "Maximum number of nodes", 50, 0, Integer.MAX_VALUE);
+	public IntOption maxNodesOption = new IntOption("maxNodesOption", 'z', "Maximum number of nodes", 2000, 0, Integer.MAX_VALUE);
 	protected int maxNodes;
 	protected int numNodes;
 
@@ -26,14 +26,25 @@ public class MultiLabelBSTree extends AbstractOptionHandler implements NumericSt
 
 	protected Node root = null;
 
-	protected DoubleVector [] leftStatistics;
-	protected DoubleVector [] rightStatistics;
+	protected DoubleVector[] leftStatistics;
+	protected DoubleVector[] rightStatistics;
 
+	public static double roundToSignificantFigures(double num, int n) {
+	    final double d = Math.ceil(Math.log10(num < 0 ? -num: num));
+	    final int power = n - (int) d;
+
+	    final double magnitude = Math.pow(10, power);
+	    final long shifted = (long) (num*magnitude);
+	    return shifted/magnitude;
+	}
+	
 	@Override
 	public void observeAttribute(double inputAttributeValue,
 			DoubleVector[] statistics) {
 		if (!Double.isNaN(inputAttributeValue))
 		{
+//			if ((long) inputAttributeValue != inputAttributeValue) 
+//				inputAttributeValue = roundToSignificantFigures(inputAttributeValue, 4);
 			if (this.root == null) {
 				this.root = new Node(inputAttributeValue, statistics);
 				maxNodes=maxNodesOption.getValue();
@@ -49,13 +60,13 @@ public void observeAttribute(double inputAttributeValue,
 	public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(
 			MultiLabelSplitCriterion criterion, DoubleVector[] preSplitStatistics, int inputAttributeIndex) {
 		// Initialize global variables
-		int numOutputs=preSplitStatistics.length;
-		leftStatistics=new DoubleVector[numOutputs];
-		rightStatistics=new DoubleVector[numOutputs];
+		int numOutputs = preSplitStatistics.length;
+		leftStatistics = new DoubleVector[numOutputs];
+		rightStatistics = new DoubleVector[numOutputs];
 		for (int i=0; i< numOutputs; i++)
 		{
-			leftStatistics[i]=new DoubleVector(new double [preSplitStatistics[i].numValues()]); //sets statistics to zeros
-			rightStatistics[i]=new DoubleVector(preSplitStatistics[i]);
+			leftStatistics[i] = new DoubleVector(new double [preSplitStatistics[i].numValues()]); //sets statistics to zeros
+			rightStatistics[i] = new DoubleVector(preSplitStatistics[i]);
 		}
 
 		return searchForBestSplitOption(this.root, null, criterion, preSplitStatistics, inputAttributeIndex);
@@ -70,34 +81,36 @@ protected AttributeExpansionSuggestion searchForBestSplitOption(Node currentNode
 		if (currentNode.left != null) {
 			currentBestOption = searchForBestSplitOption(currentNode.left, currentBestOption, criterion, preSplitStatistics, inputAttributeIndex);
 		}
+		
 		for (int i=0; i<leftStatistics.length; i++)
 		{
-			leftStatistics[i].addValues(currentNode.leftStatistics[i]);
-			rightStatistics[i].subtractValues(currentNode.leftStatistics[i]);
+			leftStatistics[i].addValues(currentNode.statistics[i]);
+			rightStatistics[i].subtractValues(currentNode.statistics[i]);
 		}
 
 		DoubleVector[][] postSplitDists = new DoubleVector [leftStatistics.length][2];
 		for (int i=0; i<leftStatistics.length; i++)
 		{
-			postSplitDists[i]= new DoubleVector[2];
-			postSplitDists[i][0]=leftStatistics[i];
-			postSplitDists[i][1]=rightStatistics[i];
+			postSplitDists[i] = new DoubleVector[2];
+			postSplitDists[i][0] = leftStatistics[i];
+			postSplitDists[i][1] = rightStatistics[i];
 		}
 
 		double merit = criterion.getMeritOfSplit(preSplitStatistics, postSplitDists);
 
 		if ((currentBestOption == null) || (merit > currentBestOption.merit)) {
-			currentBestOption= new AttributeExpansionSuggestion(new NumericRulePredicate(inputAttributeIndex, currentNode.cutPoint, true), Utils.copy(postSplitDists), merit);
+			currentBestOption = new AttributeExpansionSuggestion(new NumericRulePredicate(inputAttributeIndex, currentNode.cutPoint, true), Utils.copy(postSplitDists), merit);
 		}
 
 		if (currentNode.right != null) {
 			currentBestOption = searchForBestSplitOption(currentNode.right, currentBestOption, criterion, preSplitStatistics, inputAttributeIndex);
 		}
-		for (int i=0; i<leftStatistics.length; i++)
+		for (int i = 0; i < leftStatistics.length; i++)
 		{
-			leftStatistics[i].subtractValues(currentNode.leftStatistics[i]);
-			rightStatistics[i].addValues(currentNode.leftStatistics[i]);
+			leftStatistics[i].subtractValues(currentNode.statistics[i]);
+			rightStatistics[i].addValues(currentNode.statistics[i]);
 		}
+		
 		return currentBestOption;
 	}
 
@@ -130,8 +143,7 @@ protected class Node implements Serializable {
 		private double cutPoint;
 
 		// E-BST statistics
-		private DoubleVector [] leftStatistics;
-		private DoubleVector [] rightStatistics;
+		private DoubleVector[] statistics;
 
 		// Child nodes
 		private Node left;
@@ -139,31 +151,23 @@ protected class Node implements Serializable {
 
 		public Node(double inputAttributeValue, DoubleVector [] statistics) {
 			cutPoint = inputAttributeValue;
-			int numOutputAttributes=statistics.length;
-			leftStatistics=new DoubleVector[numOutputAttributes];
+			int numOutputAttributes = statistics.length;
+			this.statistics=new DoubleVector[numOutputAttributes];
 			for (int i=0; i<numOutputAttributes; i++)
 			{					
-				leftStatistics[i]=new DoubleVector(statistics[i]);
+				this.statistics[i]=new DoubleVector(statistics[i]);
 			}
-			//this.leftStatistics=statistics.clone();
-
-			this.rightStatistics=new DoubleVector[numOutputAttributes];
-			for (int i=0; i<numOutputAttributes; i++)
-				this.rightStatistics[i]= new DoubleVector();
 		}
 
 		/**
 		 * Updates tree with new observation
 		 */
 		public void observeAttribute(double inputAttributeValue, DoubleVector [] statistics) {
-			if (inputAttributeValue == this.cutPoint) {
-				for (int i=0; i<statistics.length; i++)
-					this.leftStatistics[i].addValues(statistics[i]);
+			if (inputAttributeValue <= this.cutPoint) {
+				for (int i=0; i < statistics.length; i++)
+					this.statistics[i].addValues(statistics[i]);
 			}
 			else if (inputAttributeValue < this.cutPoint) {
-				for (int i=0; i<statistics.length; i++)
-					this.leftStatistics[i].addValues(statistics[i]);
-				
 				if (this.left == null) {
 					if(numNodes<maxNodes){
 						this.left = new Node(inputAttributeValue, statistics);
@@ -174,8 +178,6 @@ else if (inputAttributeValue < this.cutPoint) {
 				}
 			}
 			else { 
-				for (int i=0; i<statistics.length; i++)
-					this.rightStatistics[i].addValues(statistics[i]);
 				if (this.right == null) {
 					if(numNodes<maxNodes){
 						this.right = new Node(inputAttributeValue, statistics);
diff --git a/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelBSTreePCT.java b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelBSTreePCT.java
new file mode 100644
index 000000000..94f016788
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelBSTreePCT.java
@@ -0,0 +1,270 @@
+package moa.classifiers.multilabel.core.attributeclassobservers;
+
+import java.io.Serializable;
+
+import com.github.javacliparser.IntOption;
+
+import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.classifiers.multilabel.core.splitcriteria.PCTWeightedICVarianceReduction;
+import moa.classifiers.rules.core.AttributeExpansionSuggestion;
+import moa.classifiers.rules.core.NumericRulePredicate;
+import moa.classifiers.rules.core.Utils;
+import moa.core.DoubleVector;
+import moa.core.ObjectRepository;
+import moa.options.AbstractOptionHandler;
+import moa.tasks.TaskMonitor;
+
+public class MultiLabelBSTreePCT extends AbstractOptionHandler implements NumericStatisticsObserver {
+
+	/**
+	 * 
+	 */
+	public IntOption maxNodesOption = new IntOption("maxNodesOption", 'z', "Maximum number of nodes", 2000, 0, Integer.MAX_VALUE);
+	protected int maxNodes;
+	protected int numNodes;
+
+	private static final long serialVersionUID = 1L;
+
+	protected Node root = null;
+
+	protected DoubleVector[] leftTargetStatistics;
+	protected DoubleVector[] rightTargetStatistics;
+
+	protected DoubleVector[] leftInputStatistics;
+	protected DoubleVector[] rightInputStatistics;
+
+	
+	public static double roundToSignificantFigures(double num, int n) {
+	    final double d = Math.ceil(Math.log10(num < 0 ? -num: num));
+	    final int power = n - (int) d;
+
+	    final double magnitude = Math.pow(10, power);
+	    final long shifted = (long) (num*magnitude);
+	    return shifted/magnitude;
+	}
+	
+	@Override
+	public void observeAttribute(double inputAttributeValue, DoubleVector[] statistics) {
+		// DON'T CALL THIS
+		if (!Double.isNaN(inputAttributeValue))
+		{
+//			if ((long) inputAttributeValue != inputAttributeValue) 
+////				inputAttributeValue = roundToSignificantFigures(inputAttributeValue, 4);
+//			if (this.root == null) {
+//				this.root = new Node(inputAttributeValue, statistics);
+//				maxNodes=maxNodesOption.getValue();
+//			} else {
+//				this.root.observeAttribute(inputAttributeValue, statistics);
+//			}
+		}
+
+	}
+
+	public void observeAttribute(double inputAttributeValue, DoubleVector[] targetStatistics, DoubleVector[] inputStatistics) {
+		// DON'T CALL THIS
+		if (!Double.isNaN(inputAttributeValue))
+		{
+//			if ((long) inputAttributeValue != inputAttributeValue) 
+////				inputAttributeValue = roundToSignificantFigures(inputAttributeValue, 4);
+			if (this.root == null) {
+				this.root = new Node(inputAttributeValue, targetStatistics, inputStatistics);
+				maxNodes=maxNodesOption.getValue();
+			} else {
+				this.root.observeAttribute(inputAttributeValue, targetStatistics, inputStatistics);
+			}
+		}
+
+	}
+
+
+	@Override
+	public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(
+			MultiLabelSplitCriterion criterion, DoubleVector[] preSplitStatistics, int inputAttributeIndex) {
+		// Initialize global variables
+//		int numOutputs = preSplitStatistics.length;
+//		leftStatistics = new DoubleVector[numOutputs];
+//		rightStatistics = new DoubleVector[numOutputs];
+//		for (int i=0; i< numOutputs; i++)
+//		{
+//			leftStatistics[i] = new DoubleVector(new double [preSplitStatistics[i].numValues()]); //sets statistics to zeros
+//			rightStatistics[i] = new DoubleVector(preSplitStatistics[i]);
+//		}
+
+//		return searchForBestSplitOption(this.root, null, criterion, preSplitStatistics, inputAttributeIndex);
+		return null;
+	}
+
+	public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(
+			MultiLabelSplitCriterion criterion, DoubleVector[] preSplitTargetStatistics, DoubleVector[] preSplitInputStatistics, int inputAttributeIndex) {
+		// Initialize global variables
+		int numOutputs = preSplitTargetStatistics.length;
+		int numInputs = preSplitInputStatistics.length;
+
+		leftTargetStatistics = new DoubleVector[numOutputs];
+		rightTargetStatistics = new DoubleVector[numOutputs];
+
+		leftInputStatistics = new DoubleVector[numInputs];
+		rightInputStatistics = new DoubleVector[numInputs];
+
+		for (int i=0; i< numOutputs; i++)
+		{
+			leftTargetStatistics[i] = new DoubleVector(new double [preSplitTargetStatistics[i].numValues()]); //sets statistics to zeros
+			rightTargetStatistics[i] = new DoubleVector(preSplitTargetStatistics[i]);
+		}
+		for (int i=0; i< numInputs; i++)
+		{
+			leftInputStatistics[i] = new DoubleVector(new double [preSplitInputStatistics[i].numValues()]); //sets statistics to zeros
+			rightInputStatistics[i] = new DoubleVector(preSplitInputStatistics[i]);
+		}
+
+		return searchForBestSplitOption(this.root, null, criterion, preSplitTargetStatistics, preSplitInputStatistics, inputAttributeIndex);
+	}
+
+	
+	protected AttributeExpansionSuggestion searchForBestSplitOption(Node currentNode, AttributeExpansionSuggestion currentBestOption,
+			MultiLabelSplitCriterion criterion, DoubleVector [] preSplitTargetStatistics, DoubleVector [] preSplitInputStatistics, int inputAttributeIndex) {
+		// Return null if the current node is null or we have finished looking through all the possible splits
+		if (currentNode == null) { // TODO: JD check || countRightTotal == 0.0
+			return currentBestOption;
+		}
+
+		if (currentNode.left != null) {
+			currentBestOption = searchForBestSplitOption(currentNode.left, currentBestOption, criterion, preSplitTargetStatistics, preSplitInputStatistics, inputAttributeIndex);
+		}
+		
+		for (int i=0; i<leftTargetStatistics.length; i++)
+		{
+			leftTargetStatistics[i].addValues(currentNode.targetStatistics[i]);
+			rightTargetStatistics[i].subtractValues(currentNode.targetStatistics[i]);
+		}
+
+		for (int i=0; i<leftInputStatistics.length; i++)
+		{
+			leftInputStatistics[i].addValues(currentNode.inputStatistics[i]);
+			rightInputStatistics[i].subtractValues(currentNode.inputStatistics[i]);
+		}
+
+		
+		DoubleVector[][] postSplitTargetDists = new DoubleVector [leftTargetStatistics.length + leftInputStatistics.length][2];
+		DoubleVector[][] postSplitInputDists = new DoubleVector [leftTargetStatistics.length + leftInputStatistics.length][2];
+		for (int i=0; i<leftTargetStatistics.length; i++)
+		{
+			postSplitTargetDists[i] = new DoubleVector[2];
+			postSplitTargetDists[i][0] = leftTargetStatistics[i];
+			postSplitTargetDists[i][1] = rightTargetStatistics[i];
+		}
+		for (int i=0; i<leftInputStatistics.length; i++)
+		{
+			postSplitInputDists[i] = new DoubleVector[2];
+			postSplitInputDists[i][0] = leftInputStatistics[i];
+			postSplitInputDists[i][1] = rightInputStatistics[i];
+		}
+
+
+		double merit = ((PCTWeightedICVarianceReduction) criterion).getMeritOfSplit(preSplitTargetStatistics, postSplitTargetDists, preSplitInputStatistics, postSplitInputDists);
+
+		if ((currentBestOption == null) || (merit > currentBestOption.merit)) {
+			currentBestOption = new AttributeExpansionSuggestion(new NumericRulePredicate(inputAttributeIndex, currentNode.cutPoint, true), Utils.copy(postSplitTargetDists), merit);
+		}
+
+		if (currentNode.right != null) {
+			currentBestOption = searchForBestSplitOption(currentNode.right, currentBestOption, criterion, preSplitTargetStatistics, preSplitInputStatistics, inputAttributeIndex);
+		}
+		for (int i = 0; i < leftTargetStatistics.length; i++) {
+			leftTargetStatistics[i].subtractValues(currentNode.targetStatistics[i]);
+			rightTargetStatistics[i].addValues(currentNode.targetStatistics[i]);
+		}
+		for (int i = 0; i < leftInputStatistics.length; i++) {
+			leftInputStatistics[i].subtractValues(currentNode.inputStatistics[i]);
+			rightInputStatistics[i].addValues(currentNode.inputStatistics[i]);
+		}
+		
+		return currentBestOption;
+	}
+
+
+
+
+	@Override
+	public String getPurposeString() {
+		return "Stores statistics for all output and input attributes for a giver input attribute.";
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {	
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor,
+			ObjectRepository repository) {
+
+	}
+
+
+	//Inner classes inspired in FIMTDDNumericalAttributeClassObserver
+
+	protected class Node implements Serializable {
+
+		private static final long serialVersionUID = 1L;
+
+		// The split point to use
+		private double cutPoint;
+
+		// E-BST statistics
+		private DoubleVector[] targetStatistics;
+		private DoubleVector[] inputStatistics;
+		
+
+		// Child nodes
+		private Node left;
+		private Node right;
+
+		public Node(double inputAttributeValue, DoubleVector[] targetStatistics, DoubleVector[] inputStatistics) {
+			cutPoint = inputAttributeValue;
+			int numOutputAttributes = targetStatistics.length;
+			int numInputAttributes = inputStatistics.length;
+			this.targetStatistics = new DoubleVector[numOutputAttributes];
+			this.inputStatistics = new DoubleVector[numInputAttributes];
+			for (int i=0; i<numOutputAttributes; i++) {					
+				this.targetStatistics[i]=new DoubleVector(targetStatistics[i]);
+			}
+			for (int i=0; i<numInputAttributes; i++) {					
+				this.inputStatistics[i]=new DoubleVector(inputStatistics[i]);
+			}
+		}
+
+		/**
+		 * Updates tree with new observation
+		 */
+		public void observeAttribute(double inputAttributeValue, DoubleVector[]targetStatistics, DoubleVector[] inputStatistics) {
+			if (inputAttributeValue <= this.cutPoint) {
+				for (int i=0; i < targetStatistics.length; i++)
+					this.targetStatistics[i].addValues(targetStatistics[i]);
+				for (int i=0; i < inputStatistics.length; i++)
+					this.inputStatistics[i].addValues(inputStatistics[i]);
+			}
+			else if (inputAttributeValue < this.cutPoint) {
+				if (this.left == null) {
+					if (numNodes<maxNodes) {
+						this.left = new Node(inputAttributeValue, targetStatistics, inputStatistics);
+						++numNodes;
+					}
+				} else {
+					this.left.observeAttribute(inputAttributeValue, targetStatistics, inputStatistics);
+				}
+			}
+			else { 
+				if (this.right == null) {
+					if(numNodes<maxNodes){
+						this.right = new Node(inputAttributeValue, targetStatistics, inputStatistics);
+						++numNodes;
+					}
+				} else {
+					this.right.observeAttribute(inputAttributeValue, targetStatistics, inputStatistics);
+				}
+			}
+		}
+	}
+
+
+}
diff --git a/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelNominalAttributeObserver.java b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelNominalAttributeObserver.java
index 2495b158f..bba7cbd0d 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelNominalAttributeObserver.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelNominalAttributeObserver.java
@@ -4,6 +4,8 @@
 import java.util.Iterator;
 import java.util.Map.Entry;
 
+import com.github.javacliparser.FlagOption;
+
 import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.rules.core.AttributeExpansionSuggestion;
 import moa.classifiers.rules.core.NominalRulePredicate;
@@ -13,8 +15,6 @@
 import moa.options.AbstractOptionHandler;
 import moa.tasks.TaskMonitor;
 
-import com.github.javacliparser.FlagOption;
-
 public class MultiLabelNominalAttributeObserver extends AbstractOptionHandler
 		implements NominalStatisticsObserver {
 
diff --git a/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java b/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java
index 24f9839b0..da15f568f 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java
@@ -31,14 +31,14 @@ public double[] getBranchSplitVarianceOutput(DoubleVector[] postSplitDists) {
 
 	}
 	
-	private double computeVariance(double n, double sum, double squares) {
+	public double computeVariance(double n, double sum, double squares) {
 		if (n > 1) {
 			return (squares - sum * sum / n) / (n - 1);
 		}
 		return 0;
 	}
 	
-	private double computeVariance(DoubleVector v) {
+	public double computeVariance(DoubleVector v) {
 		return computeVariance(v.getValue(0), v.getValue(1), v.getValue(2));
 	}
 
@@ -62,10 +62,10 @@ private double computeVariance(DoubleVector v) {
 	}
 	
 	protected double getMeritOfSplitForOutput(DoubleVector[] preSplitDist, DoubleVector[][] postSplitDists, int outputAttributeIndex){
-		return getMeritOfSplitForOutput(preSplitDist[outputAttributeIndex],postSplitDists[outputAttributeIndex]);
+		return getMeritOfSplitForAttribute(preSplitDist[outputAttributeIndex],postSplitDists[outputAttributeIndex]);
 	}
 
-	protected double getMeritOfSplitForOutput(DoubleVector preSplitDist, DoubleVector[] postSplitDists) {
+	protected double getMeritOfSplitForAttribute(DoubleVector preSplitDist, DoubleVector[] postSplitDists) {
 		double merit=0;
 		//count number of branches with weightSeen higher than threshold
 		int count = 0; 
diff --git a/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/PCTWeightedICVarianceReduction.java b/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/PCTWeightedICVarianceReduction.java
new file mode 100644
index 000000000..adb022397
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/PCTWeightedICVarianceReduction.java
@@ -0,0 +1,76 @@
+package moa.classifiers.multilabel.core.splitcriteria;
+
+import moa.core.DoubleVector;
+
+public class PCTWeightedICVarianceReduction extends WeightedICVarianceReduction {
+
+	public DoubleVector inputWeights;
+	
+	public double targetInputTradeoff; // \in [0, 1]
+	
+	public PCTWeightedICVarianceReduction(DoubleVector targetWeights, DoubleVector inputWeights, double targetInputTradeoff) {
+		super(targetWeights);
+		this.inputWeights = inputWeights;
+		this.targetInputTradeoff = targetInputTradeoff;
+	}
+	
+	public double getMeritOfSplit(DoubleVector[] preSplitTargetDist, DoubleVector[][] postSplitTargetDists, DoubleVector[] preSplitInputDist, DoubleVector[][] postSplitInputDists) {
+		double targetError = 0;
+		double inputError = 0;
+		int numTargets=preSplitTargetDist.length;
+		int numInputs=preSplitInputDist.length;
+		for (int i=0; i<numTargets; i++)
+			targetError += weights.getValue(i) * getMeritOfSplitForAttribute(preSplitTargetDist[i],postSplitTargetDists[i]);
+		for (int i=0; i<numInputs; i++)
+			targetError += inputWeights.getValue(i) * getMeritOfSplitForAttribute(preSplitInputDist[i],postSplitInputDists[i]);
+
+		
+		return targetInputTradeoff * targetError / weights.sumOfValues() + (1 - targetInputTradeoff) * inputError / inputWeights.sumOfValues();
+	}
+
+	protected double getMeritOfSplitForAttribute(DoubleVector preSplitDist, DoubleVector[] postSplitDists) {
+		double merit=0;
+		//count number of branches with weightSeen higher than threshold
+		int count = 0; 
+		for(int i = 0; i < postSplitDists.length; i++)
+			if(postSplitDists[i].getValue(0) >= 0.05*preSplitDist.getValue(0))
+				count = count +1;
+		//Consider split if all branches have required weight seen
+		if(count == postSplitDists.length){
+			double varPreSplit=computeVariance(preSplitDist);
+			double sumVarPostSplit=0;
+			double weightTotal=0;
+			for (int i=0; i<postSplitDists.length;i++){
+				weightTotal+=postSplitDists[i].getValue(0);
+			}
+			double [] variances=getBranchSplitVarianceOutput(postSplitDists);
+			for(int i = 0; i < variances.length; i++)
+				if(postSplitDists[i].getValue(0)>0)
+					sumVarPostSplit+=(postSplitDists[i].getValue(0)/weightTotal*variances[i]);  //weight variance
+			merit= 1 - sumVarPostSplit / varPreSplit;
+		}
+		/*if(merit<0 || merit>1)
+			System.out.println("out of range");*/
+		return merit;
+	}
+	
+
+//	private double computeVariance(double n, double sum, double squares) {
+//		if (n > 1) {
+//			return (squares - sum * sum / n) / (n - 1);
+//		}
+//		return 0;
+//	}
+	
+//	private double computeVariance(DoubleVector v) {
+//		return computeVariance(v.getValue(0), v.getValue(1), v.getValue(2));
+//	}
+	
+	public double getMeritOfSplit(DoubleVector[] preSplitTargetDist, DoubleVector[] preSplitInputDist, DoubleVector[][] postSplitTargetDists, DoubleVector[][] postSplitInputDists) {
+		double error=0;
+		int numOutputs=preSplitTargetDist.length;
+		for (int i=0; i<numOutputs; i++)
+			error += weights.getValue(i) * getMeritOfSplitForOutput(preSplitTargetDist,postSplitTargetDists,i);
+		return error / weights.sumOfValues();
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java b/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
index b4675887f..1f42cb747 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
@@ -19,11 +19,10 @@
  */
 package moa.classifiers.multilabel.meta;
 
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.classifiers.Classifier;
 import moa.classifiers.MultiLabelLearner;
@@ -51,18 +50,25 @@ public MTOzaBag() {
     	this.baseLearnerOption = new ClassOption("baseLearner", 'l',
                 "Classifier to train.", MultiLabelLearner.class, "multilabel.trees.ISOUPTree");
     	}
-	
-    @Override
+
+	@Override
     public void resetLearningImpl() {
         this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
         MultiLabelLearner baseLearner = (MultiLabelLearner) getPreparedClassOption(this.baseLearnerOption);
-        baseLearner.setModelContext(this.modelContext);
         for (int i = 0; i < this.ensemble.length; i++) {
             this.ensemble[i] = baseLearner.copy();
             this.ensemble[i].resetLearning();
+            this.ensemble[i].setRandomSeed(this.randomSeed + i * 100);
         }
     }
 
+    
+    @Override    
+    public void modelContextSet() {
+        for (int i = 0; i < this.ensemble.length; i++) {
+            this.ensemble[i].setModelContext(this.getModelContext());;
+        }
+    }
     @Override // @note don't need this here
     public boolean isRandomizable() {
         return true;
diff --git a/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagAdwinML.java b/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagAdwinML.java
index a94b89b6f..4ce25720a 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagAdwinML.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagAdwinML.java
@@ -18,21 +18,17 @@
  */
 package moa.classifiers.multilabel.meta;
 
-import moa.classifiers.Classifier;
-import moa.classifiers.core.driftdetection.ADWIN;
-import moa.classifiers.meta.OzaBagAdwin;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import moa.core.InstanceExample;
-import moa.core.MiscUtils;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.classifiers.MultiLabelLearner;
 import moa.classifiers.MultiTargetRegressor;
+import moa.classifiers.core.driftdetection.ADWIN;
+import moa.classifiers.meta.OzaBagAdwin;
 import moa.core.Example;
-import meka.core.Metrics;
-import meka.core.A;
+import moa.core.InstanceExample;
+import moa.core.MiscUtils;
 
 /**
  * OzaBagAdwinML: Changes the way to compute accuracy as an input for Adwin
@@ -45,44 +41,93 @@ public class OzaBagAdwinML extends OzaBagAdwin implements MultiLabelLearner, Mul
     @Override
     public void trainOnInstanceImpl(Instance inst) {
 		// train
-		try {
-			super.trainOnInstanceImpl(inst);
-		} catch(NullPointerException e) {
-			System.err.println("[Warning] NullPointer on train.");
-			//e.printStackTrace();
-		}
-
-		for (int i = 0; i < this.ensemble.length; i++) {
+        boolean Change = false;
+        for (int i = 0; i < this.ensemble.length; i++) {
+            int k = MiscUtils.poisson(1.0, this.classifierRandom);
+            if (k > 0) {
+                Instance weightedInst = (Instance) inst.copy();
+                weightedInst.setWeight(inst.weight() * k);
+                this.ensemble[i].trainOnInstance(weightedInst);
+            }
 
 			// get prediction
-			double prediction[] = this.ensemble[i].getVotesForInstance(inst);
-			if (prediction == null) {
-				prediction = new double[]{};
+			Prediction P = this.ensemble[i].getPredictionForInstance(inst);
+			if (P == null) {
+				continue; // TODO what to do here?
 			}
 
-			// get true value
-			double actual[] = new double[prediction.length];
-			for (int j = 0; j < prediction.length; j++) {
-				actual[j] = (double)inst.classValue(j);
+			// get true value and prediction arrays
+			double actual[] = new double[inst.numOutputAttributes()];
+			double prediction[] = new double[inst.numOutputAttributes()];
+			for (int j = 0; j < inst.numOutputAttributes(); j++) {
+				actual[j] = (double)inst.valueOutputAttribute(j);
+				prediction[j] = P.getVote(j, 1);
 			}
 
 			// compute loss
-			double loss = Metrics.L_ZeroOne(A.toIntArray(actual,0.5), A.toIntArray(prediction,0.5));
+			//double loss = Metrics.L_ZeroOne(A.toIntArray(actual,0.5), A.toIntArray(prediction,0.5));
 			//System.err.println("loss["+i+"] = "+loss);
 
+			int p_sum = 0, r_sum = 0;
+			int set_union = 0;
+			int set_inter = 0;
+			double t = 0.01;
+			for(int j = 0; j < prediction.length; j++) {
+				int p = (prediction[j] >= t) ? 1 : 0;
+				int R = (int) actual[j];
+				if (p==1) {
+					p_sum++;
+					// predt 1, real 1
+					if(R==1) {
+						set_inter++;
+						set_union++;
+					}
+					// predt 1, real 0
+					else {
+						set_union++;
+					}
+				}
+				else {                      
+					// predt 0, real 1
+					if(R==1) { 
+						set_union++;
+					}
+					// predt 0, real 0
+					else {   
+					}
+				}
+			}
+			double accuracy = 0.0;
+			if(set_union > 0)	//avoid NaN
+				accuracy = ((double)set_inter / (double)set_union);
+			
 			// adwin stuff
 			double ErrEstim = this.ADError[i].getEstimation();
-			if (this.ADError[i].setInput(loss)) {
+			
+			if (this.ADError[i].setInput(1-accuracy)) {
 				if (this.ADError[i].getEstimation() > ErrEstim) {
-					System.err.println("Change model "+i+"!");
-					this.ensemble[i].resetLearning();
-					this.ensemble[i].trainOnInstance(inst);
-					this.ADError[i] = new ADWIN();
+				Change = true;
 				}
 			}
 		}
+        
+        if (Change) {
+			double max=0.0; int imax=-1;
+			for (int i = 0; i < this.ensemble.length; i++) {
+				if (max<this.ADError[i].getEstimation()) {
+					max=this.ADError[i].getEstimation();
+					imax=i;
+				}
+			}
+			if (imax!=-1) {
+				 
+				this.ensemble[imax].resetLearning();
+				this.ensemble[imax].trainOnInstance(inst);
+				this.ADError[imax]=new ADWIN();
+			}
+        }
 	}
-
+    
 	@Override
 	public void trainOnInstanceImpl(StructuredInstance instance) {
 		trainOnInstanceImpl((Instance) instance);
diff --git a/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagML.java b/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagML.java
index 20acefa4e..9a44b2e9f 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagML.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagML.java
@@ -18,20 +18,17 @@
  */
 package moa.classifiers.multilabel.meta;
 
-import moa.classifiers.Classifier;
-import moa.classifiers.meta.OzaBag;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
+import moa.classifiers.Classifier;
 import moa.classifiers.MultiLabelLearner;
 import moa.classifiers.MultiTargetRegressor;
-import moa.core.InstanceExample;
-import moa.core.MiscUtils;
+import moa.classifiers.meta.OzaBag;
 import moa.core.Example;
-
-import java.util.Arrays;
+import moa.core.InstanceExample;
 
 /**
  * OzaBag for Multi-label data.
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java
index da8fdadd3..a5ac4c6a9 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java
@@ -10,21 +10,13 @@
 import com.github.javacliparser.MultiChoiceOption;
 import com.yahoo.labs.samoa.instances.StructuredInstance;
 
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.multilabel.core.attributeclassobservers.AttributeStatisticsObserver;
-import moa.classifiers.multilabel.core.splitcriteria.ICVarianceReduction;
 import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.multilabel.core.splitcriteria.WeightedICVarianceReduction;
-import moa.classifiers.multilabel.trees.ISOUPTree.LeafNode;
-import moa.classifiers.multilabel.trees.ISOUPTree.MultitargetPerceptron;
-import moa.classifiers.multilabel.trees.ISOUPTree.Node;
-import moa.classifiers.multilabel.trees.ISOUPTree.SplitNode;
 import moa.classifiers.rules.core.AttributeExpansionSuggestion;
-import moa.classifiers.trees.FIMTDD.InnerNode;
-import moa.classifiers.trees.ORTO.OptionNode;
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
+import moa.core.SizeOf;
 import moa.core.StringUtils;
 
 public class ISOUPOptionTree extends ISOUPTree {
@@ -41,13 +33,13 @@ public class ISOUPOptionTree extends ISOUPTree {
 			"maxTrees",
 			'm',
 			"The maximum number of trees contained in the option tree.",
-			10, 1, Integer.MAX_VALUE);
+			125, 1, Integer.MAX_VALUE);
 
 	public IntOption maxOptionLevelOption = new IntOption(
 			"maxOptionLevel",
 			'x',
 			"The maximal depth at which option nodes can be created.",
-			10, 0, Integer.MAX_VALUE);
+			3, 0, Integer.MAX_VALUE);
 
 	public FloatOption optionDecayFactorOption = new FloatOption(
 			"optionDecayFactor",
@@ -83,6 +75,12 @@ public static class OptionNode extends InnerNode {
 		public OptionNode(ISOUPTree tree) {
 			super(tree);
 		}
+		
+		public long calcByteSize() {
+			long size = super.calcByteSize();
+			size += SizeOf.fullSizeOf(optionFFSSL) + SizeOf.fullSizeOf(optionFFSeen); 
+			return size;
+		}
 
 		public void resetFF() {
 			optionFFSSL = new AutoExpandVector<DoubleVector>();
@@ -293,24 +291,21 @@ public void processInstanceOptionNode(StructuredInstance inst, OptionNode node,
 		//			}
 		//		}
 
+		double[][] childPredictions = new double[node.numChildren()][];
 		for (Node child : node.children) {
 			int i = node.getChildIndex(child);
-			double[] childPrediction = child.getPrediction(inst);
+			childPredictions[i] = child.getPrediction(inst);
 			for (int j = 0; j < getModelContext().numOutputAttributes(); j++)  {
 				node.optionFFSeen.get(i).setValue(j, node.optionFFSeen.get(i).getValue(j) * optionFadingFactorOption.getValue() + 1);
-				node.optionFFSSL.get(i).setValue(j, node.optionFFSSL.get(i).getValue(j) * optionFadingFactorOption.getValue() + Math.pow(childPrediction[j] - inst.valueOutputAttribute(j), 2));
+				node.optionFFSSL.get(i).setValue(j, node.optionFFSSL.get(i).getValue(j) * optionFadingFactorOption.getValue() + (childPredictions[i][j] - inst.valueOutputAttribute(j)) * (childPredictions[i][j] - inst.valueOutputAttribute(j)));
 			}
-		}
-
-		for (Node child : node.children) {
-			processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed && node.alternateTree == null, inAlternate);
+			processInstance(inst, child, childPredictions[node.getChildIndex(child)], normalError, growthAllowed && node.alternateTree == null, inAlternate);
 		}
 	}
 
 	//endregion ================ METHODS ================
 
 	protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex) {
-		//System.out.println("Evaluating splits");
 		//System.out.println(examplesSeen);
 		// Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
 		MultiLabelSplitCriterion splitCriterion = new WeightedICVarianceReduction(targetWeights);
@@ -364,28 +359,30 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 				numSplits = 1;
 				acceptedSplits.add(bestSuggestion);
 			}
-			else {
-				// If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
-				// TODO pruning is currently disabled
-				for (int i = 0; i < node.attributeObservers.size(); i++) {
-					AttributeStatisticsObserver obs = node.attributeObservers.get(i);
-					if (obs != null) {
-						if (getModelContext().attribute(i).isNumeric());
-						//TODO obs.removeBadSplits(null, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound, getModelContext().numOutputAttributes());
-						if (getModelContext().attribute(i).isNominal());
-						// TODO nominal class observers
-					}
-				}
-			}
+//			else {
+//				// If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
+//				// TODO pruning is currently disabled
+////				for (int i = 0; i < node.attributeObservers.size(); i++) {
+////					AttributeStatisticsObserver obs = node.attributeObservers.get(i);
+////					if (obs != null) {
+////						if (getModelContext().attribute(i).isNumeric());
+////						//TODO obs.removeBadSplits(null, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound, getModelContext().numOutputAttributes());
+////						if (getModelContext().attribute(i).isNominal());
+////						// TODO nominal class observers
+////					}
+////				}
+//			}
 		}
 
+		//System.out.println("Found " + numSplits + " candidates.");
+		
 		// If the splitting criterion were met, split the current node using the chosen attribute test, and
 		// make two new branches leading to (empty) leaves
 		if (numSplits > 0) {
 			double optionFactor = numSplits * Math.pow(optionDecayFactorOption.getValue(), (double) node.getLevel());
 			log(Integer.toString(node.ID) + ',' + Integer.toString((int) this.examplesSeen));
 
-			if (numSplits == 1 || optionFactor < 2.0 || maxTreesOption.getValue() - numTrees <= 1) {
+			if (numSplits == 1) {
 				AttributeExpansionSuggestion splitDecision = acceptedSplits.get(0);
 				SplitNode newSplit = newSplitNode(splitDecision.getPredicate());
 				newSplit.ID = node.ID;
@@ -406,7 +403,7 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 					parent.setChild(parentIndex, newSplit);
 					newSplit.setParent(parent);
 				}
-			} else {
+			} else if (optionFactor >= 2.0 || maxTreesOption.getValue() - numTrees > 1) {
 
 				OptionNode optionNode = newOptionNode();
 				optionNode.ID = node.ID;
@@ -415,7 +412,7 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 				int j = 0;
 
 				for (AttributeExpansionSuggestion splitDecision : acceptedSplits) {
-					if (j > optionFactor || maxTreesOption.getValue() - numTrees <= 0) {
+					if (j > optionFactor || maxTreesOption.getValue() - numTrees <= 0 || j > 4) {
 						break;
 					}
 					SplitNode newSplit = newSplitNode(splitDecision.getPredicate());
@@ -447,6 +444,7 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 				optionNode.resetFF();
 			}
 		}
+		//System.out.println("Splits finished...");
 	}
 
 	// region --- Option tree methods
@@ -522,4 +520,4 @@ protected void removeExcessTrees() {
 		}
 	}
 
-}
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
index b7d54bb4a..b271de183 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
@@ -41,20 +41,21 @@
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.AbstractMOAObject;
 import moa.classifiers.AbstractMultiLabelLearner;
 import moa.classifiers.MultiTargetRegressor;
 import moa.classifiers.multilabel.core.attributeclassobservers.AttributeStatisticsObserver;
 import moa.classifiers.multilabel.core.attributeclassobservers.MultiLabelBSTree;
+import moa.classifiers.multilabel.core.attributeclassobservers.MultiLabelBSTreePCT;
 import moa.classifiers.multilabel.core.attributeclassobservers.MultiLabelNominalAttributeObserver;
 import moa.classifiers.multilabel.core.attributeclassobservers.NominalStatisticsObserver;
 import moa.classifiers.multilabel.core.attributeclassobservers.NumericStatisticsObserver;
 import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.classifiers.multilabel.core.splitcriteria.PCTWeightedICVarianceReduction;
 import moa.classifiers.multilabel.core.splitcriteria.WeightedICVarianceReduction;
 import moa.classifiers.rules.core.AttributeExpansionSuggestion;
 import moa.classifiers.rules.core.Predicate;
@@ -71,7 +72,7 @@
  * @version $Revision: 1 $
  */
 public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetRegressor {
-	
+
 	private static final long serialVersionUID = 1L;
 
 	public Node treeRoot;
@@ -83,10 +84,13 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 	private DoubleVector sumOfAttrValues = new DoubleVector();
 	private DoubleVector sumOfAttrSquares = new DoubleVector();
 
+	private int numInputAttributes;
+	private int numOutputAttributes;
+
 	public int maxID = 0;
-	
+
 	private BufferedWriter writer;
-	
+
 	public DoubleVector targetWeights;
 
 	//region ================ OPTIONS ================
@@ -161,16 +165,17 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 			'o',
 			"Keep learning rate constant instead of decaying (if kept constant learning ratio is suggested to be 0.001).");
 
+	public FlagOption runAsPCTOption = new FlagOption(
+			"runAsPCT",
+			'p',
+			"Run as a predictive clustering tree, i.e., use input attributes in heuristic calculation.");
+
+
 	public FlagOption doNotNormalizeOption = new FlagOption(
 			"doNotNormalize",
 			'n',
 			"Don't normalize.");
 
-	public FlagOption randomForestBaseModelOption = new FlagOption(
-			"randomForestBaseModel",
-			'z',
-			"Use the learner as a base model in a random forest.");
-	
 	public FileOption weightFile = new FileOption("targetWeightFile", 'w', "File with the weights of the targets.", null, null, false);
 
 	//endregion ================ OPTIONS ================
@@ -193,7 +198,6 @@ public abstract static class Node extends AbstractMOAObject {
 		protected Node alternateTree;
 		protected Node originalNode;
 
-		protected AutoExpandVector<AttributeStatisticsObserver> attributeObservers = new AutoExpandVector<AttributeStatisticsObserver>();
 
 		// The error values for the Page Hinckley test
 		// PHmT = the cumulative sum of the errors
@@ -208,6 +212,12 @@ public abstract static class Node extends AbstractMOAObject {
 		// Sum of squared y values
 		protected DoubleVector sumOfSquares = new DoubleVector();
 
+		// Sum of y values
+		protected DoubleVector sumOfInputValues;
+		// Sum of squared y values
+		protected DoubleVector sumOfInputSquares;
+
+
 		public Node(ISOUPTree tree) {
 			this.tree = tree;
 			this.ID = tree.maxID;
@@ -217,10 +227,18 @@ public void copyStatistics(Node node) {
 			examplesSeen = node.examplesSeen;
 			sumOfValues = (DoubleVector) node.sumOfValues.copy();
 			sumOfSquares = (DoubleVector) node.sumOfSquares.copy();
+			if (tree.runAsPCTOption.isSet()) {
+				sumOfInputValues = (DoubleVector) node.sumOfInputValues.copy();
+				sumOfInputSquares = (DoubleVector) node.sumOfInputSquares.copy();
+			}
 		}
 
-		public int calcByteSize() {
-			return (int) SizeOf.fullSizeOf(this);
+		public long calcByteSize() {
+			long size = SizeOf.sizeOf(this) + SizeOf.sizeOf(sumOfSquares) + SizeOf.sizeOf(sumOfValues);
+			if (tree.runAsPCTOption.isSet()) {
+				size += SizeOf.sizeOf(sumOfInputSquares) + SizeOf.sizeOf(sumOfInputValues);
+			}
+			return size;
 		}
 
 		/**
@@ -250,7 +268,7 @@ public void getDescription(StringBuilder sb, int i) {}
 		public double[] getPrediction(StructuredInstance inst) {
 			return null;
 		}
-		
+
 		public void describeSubtree(StringBuilder out, int indent) {
 			StringUtils.appendIndented(out, indent, "Leaf");
 		}
@@ -298,11 +316,13 @@ public static class LeafNode extends Node {
 
 		public DoubleVector errorP = new DoubleVector();
 		public DoubleVector errorM = new DoubleVector();
-		
+
 		public List<Integer> inputIndexes = null;
 
 		protected double examplesSeenAtLastSplitEvaluation = 0;
 
+		protected AutoExpandVector<AttributeStatisticsObserver> attributeObservers = new AutoExpandVector<AttributeStatisticsObserver>();
+
 		/**
 		 * Create a new LeafNode
 		 */
@@ -315,28 +335,28 @@ public LeafNode(ISOUPTree tree) {
 			examplesSeen = 0;
 			sumOfValues = new DoubleVector();
 			sumOfSquares = new DoubleVector();
+			if (tree.runAsPCTOption.isSet()) {
+				sumOfInputValues = new DoubleVector();
+				sumOfInputSquares = new DoubleVector();
+			}
 		}
 
-		public void initializeInputIndexes() {
-			List<Integer> indexes = new Vector<Integer>();
-			int numAttrs = tree.getModelContext().numInputAttributes();
-			for (int i = 0; i < numAttrs; i++) {
-				indexes.add(i, i);
-			}
-			if (tree.buildingRandomForestTree()) {
-				// Select the first sqrt(n) attribute indexes
-				for (int i = 0; i < Math.ceil(Math.sqrt(numAttrs)); i++) {
-					int swap = i + tree.classifierRandom.nextInt(numAttrs - i);
-					int temp = indexes.get(i);
-					indexes.set(i, indexes.get(swap));
-					indexes.set(swap, temp);
-				}
-				inputIndexes = indexes.subList(0, (int) Math.ceil(Math.sqrt(numAttrs)));
-			} else {
-				inputIndexes = indexes;
+		public long calcByteSize() {
+			long size = super.calcByteSize();
+			if (tree.buildingModelTree()) {
+				size += learningModel.calcByteSize();
+				size += SizeOf.sizeOf(errorP);
+				size += SizeOf.sizeOf(errorM);
 			}
+			size += SizeOf.sizeOf(inputIndexes);
+			size += SizeOf.fullSizeOf(attributeObservers);
+			return size;
+		}
+
+		public void initializeInputIndexes() {
+			this.inputIndexes = tree.newInputIndexes();
 		}
-		
+
 		/**
 		 * Method to learn from an instance that passes the new instance to the perceptron learner,
 		 * and also prevents the class value from being truncated to an int when it is passed to the
@@ -344,28 +364,75 @@ public void initializeInputIndexes() {
 		 */
 		public void learnFromInstance(StructuredInstance inst, double[] prediction, boolean growthAllowed) {
 			// Update the statistics for this node
+			double weight = inst.weight();
 
 			double[] predictionP = tree.buildingModelTree() ? getPredictionModel(inst) : null;
 			double[] predictionM = getPredictionTargetMean(inst);
 
 			// number of instances passing through the node
-			examplesSeen += inst.weight();
+			examplesSeen += weight;
+
+			for (int i = 0; i < tree.numOutputAttributes; i++) {
+				if (!inst.isOutputMissing(i)) {
+					double outVal = inst.valueOutputAttribute(i);
+					// sum of y values
+					sumOfValues.addToValue(i, weight * outVal);
+
+					// sum of squared y values
+					sumOfSquares.addToValue(i, weight * outVal * outVal);
+
+					if (tree.buildingModelTree()) {
+						errorP.setValue(i, errorP.getValue(i) * 0.95 + Math.abs(predictionP[i] - outVal));
+						errorM.setValue(i, errorM.getValue(i) * 0.95 + Math.abs(predictionM[i] - outVal));
+					}
+				}
+			}
 
-			for (int i = 0; i < tree.getModelContext().numOutputAttributes(); i++) {
-				// sum of y values
-				sumOfValues.addToValue(i, inst.weight() * inst.valueOutputAttribute(i));
+			if (tree.runAsPCTOption.isSet()) {
+				for (int i = 0; i < tree.numInputAttributes; i++) {
+					if (!inst.isInputMissing(i)) {
+						double inVal = inst.valueInputAttribute(i);
 
-				// sum of squared y values
-				sumOfSquares.addToValue(i, inst.weight() * inst.valueOutputAttribute(i) * inst.valueOutputAttribute(i));
+						// sum of attr values
+						sumOfInputValues.addToValue(i, weight * inVal);
 
-				if (tree.buildingModelTree()) {
-					errorP.setValue(i, errorP.getValue(i) * 0.95 + Math.abs(predictionP[i] - inst.valueOutputAttribute(i)));
-					errorM.setValue(i, errorM.getValue(i) * 0.95 + Math.abs(predictionM[i] - inst.valueOutputAttribute(i)));
+						// sum of squared attr values
+						sumOfInputSquares.addToValue(i, weight * inVal * inVal);
+					}
 				}
 			}
 
+
+
 			if (tree.buildingModelTree()) learningModel.updatePerceptron(inst);
 
+			DoubleVector[] observations = new DoubleVector[tree.numOutputAttributes];
+			DoubleVector[] inputObservations = null;
+
+			for (int j = 0; j < tree.numOutputAttributes; j++) {
+				observations[j] = new DoubleVector();
+				if (!inst.isOutputMissing(j)) {
+					double outVal = inst.valueOutputAttribute(j);
+					observations[j].setValue(0, weight);
+					observations[j].setValue(1, weight * outVal);
+					observations[j].setValue(2, weight * outVal * outVal);
+				}
+			}
+			
+			if (tree.runAsPCTOption.isSet()) {
+				inputObservations = new DoubleVector[tree.numInputAttributes];
+				for (int j = 0; j < tree.numInputAttributes; j++) {
+					
+					inputObservations[j] = new DoubleVector();
+					if (!inst.isInputMissing(j)) {
+						double inVal = inst.valueInputAttribute(j);
+						inputObservations[j].setValue(0, weight);
+						inputObservations[j].setValue(1, weight * inVal);
+						inputObservations[j].setValue(2, weight * inVal * inVal);
+					}
+				}
+			}
+
 			for (int i : inputIndexes) {
 				AttributeStatisticsObserver obs = attributeObservers.get(i);
 				if (obs == null) {
@@ -379,15 +446,12 @@ public void learnFromInstance(StructuredInstance inst, double[] prediction, bool
 					}
 
 				}
-				if (obs != null) {
-					DoubleVector[] observations = new DoubleVector[inst.numOutputAttributes()];
-					for (int j = 0; j < inst.numOutputAttributes(); j++) {
-						observations[j] = new DoubleVector();
-						observations[j].setValue(0, inst.weight());
-						observations[j].setValue(1, inst.weight() * inst.valueOutputAttribute(j));
-						observations[j].setValue(2, inst.weight() * inst.valueOutputAttribute(j) * inst.valueOutputAttribute(j));
+				if (obs != null ) {
+					if (!tree.runAsPCTOption.isSet() || !inst.inputAttribute(i).isNumeric()) {
+						obs.observeAttribute(inst.valueInputAttribute(i), observations);
+					} else {
+						((MultiLabelBSTreePCT) obs).observeAttribute(inst.valueInputAttribute(i), observations, inputObservations);
 					}
-					obs.observeAttribute(inst.valueInputAttribute(i), observations);
 
 					//obs.observeAttributeClassVector(inst.valueInputAttribute(i), getTargetVector(inst), inst.weight());
 				}
@@ -408,16 +472,32 @@ public AttributeExpansionSuggestion[] getBestSplitSuggestions(MultiLabelSplitCri
 			for (int i : inputIndexes) {
 				AttributeStatisticsObserver obs = attributeObservers.get(i);
 				if (obs != null) {
-					DoubleVector[] preSplitStatistics = new DoubleVector[tree.getModelContext().numOutputAttributes()];
-					for (int j = 0; j < tree.getModelContext().numOutputAttributes(); j++) {
+					DoubleVector[] preSplitStatistics = new DoubleVector[tree.numOutputAttributes];
+					DoubleVector[] preSplitInputStatistics = null;
+					for (int j = 0; j < tree.numOutputAttributes; j++) {
 						preSplitStatistics[j] = new DoubleVector();
 						preSplitStatistics[j].setValue(0, examplesSeen);
 						preSplitStatistics[j].setValue(1, sumOfValues.getValue(j));
 						preSplitStatistics[j].setValue(2, sumOfSquares.getValue(j));
 					}
+					
+					if (tree.runAsPCTOption.isSet() && tree.modelContext.inputAttribute(i).isNumeric()) {
+						preSplitInputStatistics = new DoubleVector[tree.numInputAttributes];
+						for (int j = 0; j < tree.numInputAttributes; j++) {
+							preSplitInputStatistics[j] = new DoubleVector();
+							preSplitInputStatistics[j].setValue(0, examplesSeen);
+							preSplitInputStatistics[j].setValue(1, sumOfInputValues.getValue(j));
+							preSplitInputStatistics[j].setValue(2, sumOfInputSquares.getValue(j));
+						}
+
+					}
 
 					AttributeExpansionSuggestion bestSuggestion = null;
-					bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion, preSplitStatistics, i);
+					if (tree.runAsPCTOption.isSet() && tree.modelContext.inputAttribute(i).isNumeric()) {
+						bestSuggestion = ((MultiLabelBSTreePCT) obs).getBestEvaluatedSplitSuggestion(criterion, preSplitStatistics, preSplitInputStatistics, i);
+					} else {
+						bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion, preSplitStatistics, i);
+					}
 
 					if (bestSuggestion != null) {
 						bestSuggestions.add(bestSuggestion);
@@ -435,8 +515,8 @@ public double[] getPredictionModel(StructuredInstance inst) {
 		}
 
 		public double[] getPredictionTargetMean(StructuredInstance inst) {
-			double[] pred = new double[inst.numOutputAttributes()];
-			for (int i = 0; i < inst.numOutputAttributes(); i++) {
+			double[] pred = new double[tree.numOutputAttributes];
+			for (int i = 0; i < tree.numOutputAttributes; i++) {
 				if (examplesSeen > 0) {
 					pred[i] = sumOfValues.getValue(i) / examplesSeen;
 				} else {
@@ -483,7 +563,7 @@ public void checkForSplit() {
 		public void describeSubtree(StringBuilder out, int indent) {
 			StringUtils.appendIndented(out, indent, "Leaf");
 			StringUtils.appendNewline(out);
-			
+
 			if (tree.buildingModelTree()) {
 				learningModel.getModelDescription(out, indent + 2);
 			} else {
@@ -519,6 +599,14 @@ public InnerNode(ISOUPTree tree) {
 			super(tree);
 		}
 
+		public long calcByteSize() {
+			long size = super.calcByteSize();
+			size += SizeOf.sizeOf(PHsums) + SizeOf.sizeOf(PHmins) + SizeOf.sizeOf(sumOfAbsErrors);
+			for (Node child : children)
+				size += child.calcByteSize();
+			return size;
+		}
+
 		public int numChildren() {
 			return children.size();
 		}
@@ -547,7 +635,7 @@ public void restartChangeDetection() {
 				changeDetection = true;
 				PHsums = new DoubleVector();
 				PHmins = new DoubleVector();
-				for (int i = 0; i < tree.getModelContext().numOutputAttributes(); i++) {
+				for (int i = 0; i < tree.numOutputAttributes; i++) {
 					PHmins.setValue(i, Double.MAX_VALUE);
 				}				
 				for (Node child : children)
@@ -613,6 +701,10 @@ public SplitNode(Predicate predicate, ISOUPTree tree) {
 			ID = tree.maxID;
 		}
 
+		public long calcByteSize() {
+			return super.calcByteSize() + SizeOf.sizeOf(predicate);
+		}
+
 		public int instanceChildIndex(StructuredInstance inst) {
 			return (predicate.evaluate(inst)) ? 0 : 1;
 		}
@@ -649,10 +741,6 @@ public class MultitargetPerceptron {
 		// The number of instances contributing to this model
 		protected int instancesSeen = 0;
 
-		public String getPurposeString() {
-			return "A multi-target perceptron";
-		}
-
 		public MultitargetPerceptron(ISOUPTree tree, MultitargetPerceptron original) {
 			this.tree = tree;
 			weights = original.weights.clone();
@@ -663,10 +751,19 @@ public MultitargetPerceptron(ISOUPTree tree) {
 			initializeWeights();
 		}
 
+		public long calcByteSize() {
+			return SizeOf.sizeOf(this);
+		}
+
+		public String getPurposeString() {
+			return "A multi-target perceptron";
+		}
+
+
 		public void initializeWeights() {
 			instancesSeen = 0;
-			int numTargets = tree.getModelContext().numOutputAttributes();
-			int numInputs = tree.getModelContext().numInputAttributes();
+			int numTargets = tree.numOutputAttributes;
+			int numInputs = tree.numInputAttributes;
 			weights = new double[numTargets][numInputs+1];
 			tree.classifierRandom.setSeed(1234);
 			for (int i = 0; i < numTargets; i++) {
@@ -706,10 +803,12 @@ public void updateWeights(StructuredInstance inst, double learningRatio) {
 				double[] normalizedPrediction = prediction(normalizedInput);
 
 				double[] normalizedTarget = tree.normalizedTargetVector(inst);
-				for (int i = 0; i < inst.numOutputAttributes(); i++){
-					double delta = normalizedTarget[i] - normalizedPrediction[i];
-					for (int j = 0; j < normalizedInput.length; j++) {
-						weights[i][j] += delta * learningRatio * normalizedInput[j];
+				for (int i = 0; i < tree.numOutputAttributes; i++){
+					if (normalizedTarget[i] != Double.NaN) { /* to account for missing target values */
+						double delta = normalizedTarget[i] - normalizedPrediction[i];
+						for (int j = 0; j < normalizedInput.length; j++) {
+							weights[i][j] += delta * learningRatio * normalizedInput[j];
+						}
 					}
 				}
 				normalizeWeights();
@@ -730,8 +829,8 @@ public void normalizeWeights() {
 		 * Output the prediction made by this perceptron on the given instance
 		 */
 		public double[] prediction(double[] instanceValues) {
-			double[] out = new double[tree.getModelContext().numOutputAttributes()];
-			for (int i = 0; i < tree.getModelContext().numOutputAttributes(); i++) {
+			double[] out = new double[tree.numOutputAttributes];
+			for (int i = 0; i < tree.numOutputAttributes; i++) {
 				out[i] = 0;
 				for (int j = 0; j < instanceValues.length; j++) {
 					out[i] += weights[i][j] * instanceValues[j];
@@ -749,7 +848,7 @@ private double[] prediction(StructuredInstance inst) {
 		private double[] denormalizePrediction(double[] normalizedPrediction) {
 			double[] out = new double[normalizedPrediction.length];
 			if (tree.normalize()) {
-				for (int i = 0; i < tree.getModelContext().numOutputAttributes(); i++) {
+				for (int i = 0; i < tree.numOutputAttributes; i++) {
 					double mean = tree.sumOfValues.getValue(i) / tree.examplesSeen;
 					double sd = computeSD(tree.sumOfSquares.getValue(i), tree.sumOfValues.getValue(i), tree.examplesSeen);
 					if (examplesSeen > 1) 
@@ -763,9 +862,9 @@ private double[] denormalizePrediction(double[] normalizedPrediction) {
 
 		public void getModelDescription(StringBuilder out, int indent) {
 			if (getModelContext() != null) {
-				for (int i = 0; i < tree.getModelContext().numOutputAttributes(); i++) {
+				for (int i = 0; i < tree.numOutputAttributes; i++) {
 					StringUtils.appendIndented(out, indent, " [" + tree.getModelContext().outputAttribute(i).name() + "] =");
-					for (int j = 0; j < getModelContext().numInputAttributes(); j++) {
+					for (int j = 0; j < tree.numInputAttributes; j++) {
 						if (getModelContext().inputAttribute(j).isNumeric()) {
 							out.append((j == 0 && weights[i][j] >= 0) ? " " : (weights[i][j] < 0) ? " - " : " + ");
 							out.append(String.format("%.4f", Math.abs(weights[i][j])));
@@ -773,7 +872,7 @@ public void getModelDescription(StringBuilder out, int indent) {
 							out.append(getModelContext().inputAttribute(j).name());
 						}
 					}
-					out.append((weights[i][getModelContext().numInputAttributes()] < 0 ? " - " : " + ") + String.format("%.4f", Math.abs(weights[i][getModelContext().numInputAttributes()])));
+					out.append((weights[i][tree.numInputAttributes] < 0 ? " - " : " + ") + String.format("%.4f", Math.abs(weights[i][tree.numInputAttributes])));
 				}
 				StringUtils.appendNewline(out);
 			}
@@ -789,6 +888,14 @@ public ISOUPTree() {
 		super();
 	}
 
+	public List<Integer> newInputIndexes() {
+		List<Integer> indexes = new Vector<Integer>();
+		for (int i = 0; i < this.numInputAttributes; i++) {
+			indexes.add(i, i);
+		}
+		return indexes;
+	}
+
 	public String getPurposeString() {
 		return "Implementation of the iSOUP-Tree algorithm as described by Osojnik et al.";
 	}
@@ -801,12 +908,16 @@ public void resetLearningImpl() {
 
 		sumOfAttrValues = new DoubleVector();
 		sumOfAttrSquares = new DoubleVector();
-		
+
 	}
-	
+
 	@Override
 	public void modelContextSet() {
+		assert getModelContext() != null;
+		this.numInputAttributes = getModelContext().numInputAttributes();
+		this.numOutputAttributes = getModelContext().numOutputAttributes();
 		loadWeights();
+		checkRoot();
 	}
 
 	public void loadWeights() {
@@ -815,10 +926,11 @@ public void loadWeights() {
 			List<String> lines = Files.readAllLines(Paths.get(weightFile.getValue()), Charset.defaultCharset());
 			for (int i = 0 ; i < lines.size(); i++) targetWeights.setValue(i, Double.valueOf(lines.get(i)));
 		} catch (Exception e) {
-			for (int i = 0; i < getModelContext().numOutputAttributes(); i++) targetWeights.setValue(i, 1.0);
+			for (int i = 0; i < this.numOutputAttributes; i++)
+				targetWeights.setValue(i, 1.0);
 		}
 	}
-	
+
 	public boolean isRandomizable() {
 		return true;
 	}
@@ -826,7 +938,7 @@ public boolean isRandomizable() {
 	public void getModelDescription(StringBuilder out, int indent) {
 		if (treeRoot != null) treeRoot.describeSubtree(out, indent);
 	}
-	
+
 	protected Measurement[] getModelMeasurementsImpl() {
 		return new Measurement[]{ 
 				//new Measurement("tree size (nodes)", this.leafNodeCount + this.splitNodeCount),
@@ -834,19 +946,25 @@ protected Measurement[] getModelMeasurementsImpl() {
 		};
 	}
 
-	public int calcByteSize() {
-		int size = (int) SizeOf.sizeOf(this);
+	public long measureByteSize() {
+		return calcByteSize();
+	}
+
+	public long calcByteSize() {
+		long size = SizeOf.sizeOf(this);
 		if (this.treeRoot != null) {
 			size += this.treeRoot.calcByteSize();
 		}
+		size += SizeOf.sizeOf(sumOfValues) + SizeOf.sizeOf(sumOfSquares);
+		size += SizeOf.sizeOf(sumOfAttrValues) + SizeOf.sizeOf(sumOfAttrSquares);
+		size += SizeOf.sizeOf(targetWeights);
 		return size;
 	}
 
 	public Prediction getPredictionForInstance(StructuredInstance inst) {
-		checkRoot();
 		double[] predictionVector = treeRoot.getPrediction(inst);
-		MultiLabelPrediction prediction = new MultiLabelPrediction(getModelContext().numOutputAttributes());
-		for (int i = 0; i < getModelContext().numOutputAttributes(); i++) {
+		MultiLabelPrediction prediction = new MultiLabelPrediction(this.numOutputAttributes);
+		for (int i = 0; i < this.numOutputAttributes; i++) {
 			prediction.setVote(i, 1, predictionVector[i]);
 		}
 		return prediction;
@@ -854,9 +972,9 @@ public Prediction getPredictionForInstance(StructuredInstance inst) {
 
 	public double[] normalizedInputVector(StructuredInstance inst) {
 		// Normalize Instance
-		double[] normalizedInput = new double[inst.numInputAttributes()+1];
+		double[] normalizedInput = new double[this.numInputAttributes+1];
 		if (normalize()) {
-			for (int j = 0; j < inst.numInputAttributes(); j++) {
+			for (int j = 0; j < this.numInputAttributes; j++) {
 				Attribute attr = inst.inputAttribute(j);
 				double value =  inst.valueInputAttribute(j);
 				double mean = sumOfAttrValues.getValue(j) / examplesSeen;
@@ -870,33 +988,35 @@ public double[] normalizedInputVector(StructuredInstance inst) {
 					normalizedInput[j] = 0;
 			}
 			if (examplesSeen > 1)
-				normalizedInput[inst.numInputAttributes()] = 1.0; // Value to be multiplied with the constant factor
+				normalizedInput[this.numInputAttributes] = 1.0; // Value to be multiplied with the constant factor
 			else
-				normalizedInput[inst.numInputAttributes()] =  0.0;
+				normalizedInput[this.numInputAttributes] =  0.0;
 		} else {
-			for (int j = 0; j < inst.numInputAttributes(); j++) {
+			for (int j = 0; j < this.numInputAttributes; j++) {
 				normalizedInput[j] = inst.valueInputAttribute(j);
 			}
-			normalizedInput[inst.numInputAttributes()] = 1.0;
+			normalizedInput[this.numInputAttributes] = 1.0;
 		}
 		return normalizedInput;
 	}
 
 	public double[] normalizedTargetVector(StructuredInstance inst) {
-		double[] out = new double[getModelContext().numOutputAttributes()];
+		double[] out = new double[this.numOutputAttributes];
 		if (normalize()) {
-			for (int i = 0; i < inst.numOutputAttributes(); i++) {
-				double value = inst.valueOutputAttribute(i);
-				double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen);
-				double average = sumOfValues.getValue(i) / examplesSeen;
-				if (sd > 0 && examplesSeen > 1)
-					out[i] = (value - average) / (sd);
-				else
-					out[i] = 0;
+			for (int i = 0; i < this.numOutputAttributes; i++) {
+				double value = (inst.isOutputMissing(i)) ? Double.NaN : inst.valueOutputAttribute(i);;
+				if (value != Double.NaN) {
+					double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen);
+					double average = sumOfValues.getValue(i) / examplesSeen;
+					if (sd > 0 && examplesSeen > 1)
+						out[i] = (value - average) / (sd);
+					else
+						out[i] = 0;
+				} else out[i] = value;
 			}
 		} else {
-			for (int i = 0; i < inst.numOutputAttributes(); i++) {
-				out[i] = inst.valueOutputAttribute(i);
+			for (int i = 0; i < this.numOutputAttributes; i++) {
+				out[i] = (inst.isOutputMissing(i)) ? Double.NaN : inst.valueOutputAttribute(i);
 			}
 		}
 		return out;
@@ -951,8 +1071,8 @@ public double normalizeTargetValue(double value, int i) {
 	public double[] getNormalizedError(StructuredInstance inst, double[] prediction) {
 		double[] normalPrediction = normalizeTargetVector(prediction);
 		double[] normalValue = normalizedTargetVector(inst);
-		double[] out = new double[getModelContext().numOutputAttributes()];
-		for (int i = 0; i < inst.numOutputAttributes(); i++) {
+		double[] out = new double[this.numOutputAttributes];
+		for (int i = 0; i < this.numOutputAttributes; i++) {
 			out[i] = Math.abs(normalValue[i] - normalPrediction[i]);
 		}
 		return out;
@@ -962,281 +1082,304 @@ public double[] getNormalizedError(StructuredInstance inst, double[] prediction)
 	/**
 	 * Method for updating (training) the model using a new instance
 	 */
-	 public void trainOnInstanceImpl(StructuredInstance inst) {
-		 if (inst.weight() > 0) {
-			 checkRoot();
-
-			 double[] prediction = treeRoot.getPrediction(inst);
-			 double[] normalError = getNormalizedError(inst, prediction);
-
-			 processInstance(inst, treeRoot, prediction, normalError, true, false);
-
-			 examplesSeen += inst.weight();
-			 for (int i = 0; i < inst.numberOutputTargets(); i++) {
-				 sumOfValues.addToValue(i, inst.weight() * inst.valueOutputAttribute(i));
-				 sumOfSquares.addToValue(i, inst.weight() * inst.valueOutputAttribute(i) * inst.valueOutputAttribute(i));
-			 }
-
-			 for (int i = 0; i < inst.numInputAttributes(); i++) {
-				 sumOfAttrValues.addToValue(i, inst.weight() * inst.valueInputAttribute(i));
-				 sumOfAttrSquares.addToValue(i, inst.weight() * inst.valueInputAttribute(i) * inst.valueInputAttribute(i));
-			 }
-		 }
-	 }
-
-	 public void processInstance(StructuredInstance inst, Node node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
-		 Node currentNode = node;
-		 while (true) {
-			 if (currentNode instanceof LeafNode) {
-				 ((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
-				 break;
-			 } else {
-				 currentNode.examplesSeen += inst.weight();
-				 //currentNode.sumOfAbsErrors.addValues(normalError);
-				 //				SplitNode iNode = (SplitNode) currentNode;
-				 //				if (!inAlternate && iNode.alternateTree != null) {
-				 //					boolean altTree = true;
-				 //					double lossO = Math.pow(inst.valueOutputAttribute() - prediction, 2);
-				 //					double lossA = Math.pow(inst.valueOutputAttribute() - iNode.alternateTree.getPrediction(inst), 2);
-				 //
-				 //					iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
-				 //					iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
-				 //					iNode.lossExamplesSeen++;
-				 //
-				 //					double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
-				 //					double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
-				 //					iNode.lossSumQi += Qi;
-				 //					iNode.lossNumQiTests += 1;
-				 //					double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
-				 //
-				 //					if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
-				 //						iNode.previousWeight = iNode.lossExamplesSeen;
-				 //						if (Qi > 0) {
-				 //							SplitNode parent = currentNode.getParent();
-				 //
-				 //							if (parent != null) {
-				 //								Node replacementTree = iNode.alternateTree;
-				 //								parent.setChild(parent.getChildIndex(currentNode), replacementTree);
-				 //								if (growthAllowed) replacementTree.restartChangeDetection();
-				 //							} else {
-				 //								treeRoot = iNode.alternateTree;
-				 //								treeRoot.restartChangeDetection();
-				 //							}
-				 //
-				 //							currentNode = iNode.alternateTree;
-				 //							altTree = false;
-				 //						} else if (
-				 //								(QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * this.gracePeriodOption.getValue()))
-				 //								|| iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()
-				 //								) {
-				 //							iNode.alternateTree = null;
-				 //							if (growthAllowed) iNode.restartChangeDetection();
-				 //							altTree = false;
-				 //						}
-				 //					}
-				 //
-				 //					if (altTree) {
-				 //						growthAllowed = false;
-				 //						processInstance(inst, iNode.alternateTree, prediction, normalError, true, true);
-				 //					}
-				 //				}
-
-				 //				if (iNode.changeDetection && !inAlternate) {
-				 //					if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
-				 //						iNode.initializeAlternateTree(this);
-				 //					}
-				 //				}
-				 if (currentNode instanceof SplitNode) {
-					 currentNode = ((SplitNode) currentNode).getChild(((SplitNode) currentNode).instanceChildIndex(inst));
-				 } else { // if the replaced alternate tree is just a leaf node
-					 ((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
-					 break;
-				 }
-			 }
-		 }
-	 }
-
-	 //region --- Object instatiation methods
-
-	 protected NumericStatisticsObserver newNumericClassObserver() {
-		 return new MultiLabelBSTree();
-	 }
-
-	 public NominalStatisticsObserver newNominalClassObserver() {
-		 return new MultiLabelNominalAttributeObserver();
-	 }
-
-	 //	protected SplitNode newSplitNode(InstanceConditionalTest splitTest) {
-	 //		maxID++;
-	 //		return new SplitNode(splitTest, this);
-	 //	}
-
-	 protected SplitNode newSplitNode(Predicate predicate) {
-		 maxID++;
-		 return new SplitNode(predicate, this);
-	 }
-
-	 protected LeafNode newLeafNode() {
-		 maxID++;
-		 return new LeafNode(this);
-	 }
-
-	 public MultitargetPerceptron newLeafModel() {
-		 return new MultitargetPerceptron(this);
-	 }
-
-	 //endregion --- Object instatiation methods
-
-	 //region --- Processing methods
-	 protected void checkRoot() {
-		 if (treeRoot == null) {
-			 treeRoot = newLeafNode();
-		 }
-	 }
-
-	 public static double computeHoeffdingBound(double range, double confidence, double n) {
-		 return Math.sqrt(((range * range) * Math.log(1 / confidence)) / (2.0 * n));
-	 }
-
-	 public boolean buildingModelTree() {
-		 return !regressionTreeOption.isSet();
-	 }
-	 
-	 public boolean buildingRandomForestTree() {
-		 return randomForestBaseModelOption.isSet();
-	 }
-
-	 public boolean normalize() {
-		 return !doNotNormalizeOption.isSet();
-	 }
-
-	 protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex) {
-		 // Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
-		 MultiLabelSplitCriterion splitCriterion = new WeightedICVarianceReduction(targetWeights);
-
-		 // Using this criterion, find the best split per attribute and rank the results
-		 AttributeExpansionSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion); // TODO update with split criterion option
-		 Arrays.sort(bestSplitSuggestions);
-
-		 // Declare a variable to determine if any of the splits should be performed
-		 boolean shouldSplit = false;
-		 // If only one split was returned, use it
-		 if (bestSplitSuggestions.length < 2) {
-			 shouldSplit = bestSplitSuggestions.length > 0;
-		 } else { // Otherwise, consider which of the splits proposed may be worth trying
-
-			 // Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
-			 // to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
-			 double hoeffdingBound = computeHoeffdingBound(1, splitConfidenceOption.getValue(), node.examplesSeen);
-			 // Determine the top two ranked splitting suggestions
-			 AttributeExpansionSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-			 AttributeExpansionSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
-
-			 // If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
-			 // as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
-			 // particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
-			 // splitting should occur.
-			 // Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
-			 // (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
-			 // competing attributes are equally good, and the split will be made on the one with the higher SDR value.
-			 if ((secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) || (hoeffdingBound < this.tieThresholdOption.getValue())) {
-				 shouldSplit = true;
-			 }
-			 // If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
-			 else {
-				 // TODO pruning is currently disabled
-				 for (int i = 0; i < node.attributeObservers.size(); i++) {
-					 AttributeStatisticsObserver obs = node.attributeObservers.get(i);
-					 if (obs != null) {
-						 if (getModelContext().attribute(i).isNumeric());
-						 //TODO obs.removeBadSplits(null, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound, getModelContext().numOutputAttributes());
-						 if (getModelContext().attribute(i).isNominal());
-						 // TODO nominal class observers
-					 }
-				 }
-			 }
-		 }
-
-		 // If the splitting criterion were met, split the current node using the chosen attribute test, and
-		 // make two new branches leading to (empty) leaves
-		 if (shouldSplit) {
-			 AttributeExpansionSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-
-			 SplitNode newSplit = newSplitNode(splitDecision.predicate);
-			 newSplit.ID = node.ID;
-			 newSplit.copyStatistics(node);
-			 newSplit.changeDetection = node.changeDetection;
-			 newSplit.ID = node.ID;
-			 log(Integer.toString(node.ID) + ',' + Integer.toString((int) this.examplesSeen));
-			 for (int i = 0; i < 2; i++) { // Hardcoded for 2 values (due to the use of the Predicate class)
-				 LeafNode newChild = newLeafNode();
-				 if (buildingModelTree()) {
-					 // Copy the splitting node's perceptron to it's children
-					 newChild.learningModel = new MultitargetPerceptron(this, (MultitargetPerceptron) node.learningModel);
-
-				 }
-				 newChild.changeDetection = node.changeDetection;
-				 newChild.setParent(newSplit);
-				 newSplit.setChild(i, newChild);
-			 }
-			 if (parent == null && node.originalNode == null) {
-				 treeRoot = newSplit;
-			 } else if (parent == null && node.originalNode != null) {
-				 node.originalNode.alternateTree = newSplit;
-			 } else {
-				 parent.setChild(parentIndex, newSplit);
-				 newSplit.setParent(parent);
-			 }
-		 }
-	 }
-
-	 public double computeSD(double squaredVal, double val, double size) {
-		 if (size > 1)
-			 return Math.sqrt((squaredVal - ((val * val) / size)) / size);
-		 else
-			 return 0.0;
-	 }
-
-	 public static double scalarProduct(DoubleVector u, DoubleVector v) {
-		 double ret = 0.0;
-		 for (int i = 0; i < Math.max(u.numValues(), v.numValues()); i++) {
-			 ret += u.getValue(i) * v.getValue(i);
-		 }
-		 return ret;
-	 }
-	 //endregion --- Processing methods
-	 
-	 public void initWriter(String filename) {
-		 try {
-			 writer = new BufferedWriter(new FileWriter(filename));
-			 writer.write("");
-			 writer.close();
-			 writer = new BufferedWriter(new FileWriter(filename, true));
-		 } catch (Exception e) {
-			 e.printStackTrace();
-		 }
-	 }
-	 
-	 public void closeWriter() {
-		 try {
-		 writer.close();
-		 } catch (Exception e) {
-			 e.printStackTrace();
-		 }
-		 writer = null;
-		 
-	 }
-	 
-	 public void log(String s) {
-		 if (writer != null) {
-			 try {
-				 writer.write(s + "\n");
-				 writer.flush();
-			 } catch (Exception e) {
-				 e.printStackTrace();
-			 }
-		 }
-	 }
-	 
-	 //endregion ================ METHODS ================
+	public void trainOnInstanceImpl(StructuredInstance inst) {
+		if (inst.weight() > 0) {
+
+			double[] prediction = treeRoot.getPrediction(inst);
+			double[] normalError = getNormalizedError(inst, prediction);
+
+			processInstance(inst, treeRoot, prediction, normalError, true, false);
+
+			double weight = inst.weight();
+
+			examplesSeen += weight;
+			for (int i = 0; i < this.numOutputAttributes; i++) {
+				double iVal = inst.valueOutputAttribute(i);
+				sumOfValues.addToValue(i, weight * iVal);
+				sumOfSquares.addToValue(i, weight * iVal * iVal);
+			}
+
+			for (int i = 0; i < this.numInputAttributes; i++) {
+				double iVal = inst.valueInputAttribute(i);
+				sumOfAttrValues.addToValue(i, weight * iVal);
+				sumOfAttrSquares.addToValue(i, weight * iVal * iVal);
+			}
+		}
+	}
+
+	public void processInstance(StructuredInstance inst, Node node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
+		Node currentNode = node;
+		while (true) {
+			if (currentNode instanceof LeafNode) {
+				((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
+				break;
+			} else {
+				currentNode.examplesSeen += inst.weight();
+				//currentNode.sumOfAbsErrors.addValues(normalError);
+				//				SplitNode iNode = (SplitNode) currentNode;
+				//				if (!inAlternate && iNode.alternateTree != null) {
+				//					boolean altTree = true;
+				//					double lossO = Math.pow(inst.valueOutputAttribute() - prediction, 2);
+				//					double lossA = Math.pow(inst.valueOutputAttribute() - iNode.alternateTree.getPrediction(inst), 2);
+				//
+				//					iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
+				//					iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
+				//					iNode.lossExamplesSeen++;
+				//
+				//					double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
+				//					double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+				//					iNode.lossSumQi += Qi;
+				//					iNode.lossNumQiTests += 1;
+				//					double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+				//
+				//					if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
+				//						iNode.previousWeight = iNode.lossExamplesSeen;
+				//						if (Qi > 0) {
+				//							SplitNode parent = currentNode.getParent();
+				//
+				//							if (parent != null) {
+				//								Node replacementTree = iNode.alternateTree;
+				//								parent.setChild(parent.getChildIndex(currentNode), replacementTree);
+				//								if (growthAllowed) replacementTree.restartChangeDetection();
+				//							} else {
+				//								treeRoot = iNode.alternateTree;
+				//								treeRoot.restartChangeDetection();
+				//							}
+				//
+				//							currentNode = iNode.alternateTree;
+				//							altTree = false;
+				//						} else if (
+				//								(QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * this.gracePeriodOption.getValue()))
+				//								|| iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()
+				//								) {
+				//							iNode.alternateTree = null;
+				//							if (growthAllowed) iNode.restartChangeDetection();
+				//							altTree = false;
+				//						}
+				//					}
+				//
+				//					if (altTree) {
+				//						growthAllowed = false;
+				//						processInstance(inst, iNode.alternateTree, prediction, normalError, true, true);
+				//					}
+				//				}
+
+				//				if (iNode.changeDetection && !inAlternate) {
+				//					if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+				//						iNode.initializeAlternateTree(this);
+				//					}
+				//				}
+				//if (currentNode instanceof SplitNode) {
+				currentNode = ((SplitNode) currentNode).getChild(((SplitNode) currentNode).instanceChildIndex(inst));
+				//} else { // if the replaced alternate tree is just a leaf node
+				//	 ((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
+				//break;
+			}
+		}
+	}
+
+	//region --- Object instatiation methods
+
+	protected NumericStatisticsObserver newNumericClassObserver() {
+		try {
+			//NumericStatisticsObserver o = (NumericStatisticsObserver) ClassOption.cliStringToObject("MultiLabelBSTree -z 2000", MultiLabelBSTree.class, null);
+			//NumericStatisticsObserver o = (NumericStatisticsObserver) ClassOption.cliStringToObject("MultiLabelBSTree2 -z 2000", MultiLabelBSTree2.class, null);
+			if (runAsPCTOption.isSet()) {
+				return new MultiLabelBSTreePCT();
+			} else {
+				return new MultiLabelBSTree();
+			}
+
+		} catch (Exception e) {
+			return null;
+		}
+	}
+
+	public NominalStatisticsObserver newNominalClassObserver() {
+		return new MultiLabelNominalAttributeObserver();
+	}
+
+	//	protected SplitNode newSplitNode(InstanceConditionalTest splitTest) {
+	//		maxID++;
+	//		return new SplitNode(splitTest, this);
+	//	}
+
+	protected SplitNode newSplitNode(Predicate predicate) {
+		maxID++;
+		return new SplitNode(predicate, this);
+	}
+
+	protected LeafNode newLeafNode() {
+		maxID++;
+		return new LeafNode(this);
+	}
+
+	public MultitargetPerceptron newLeafModel() {
+		return new MultitargetPerceptron(this);
+	}
+
+	//endregion --- Object instatiation methods
+
+	//region --- Processing methods
+	protected void checkRoot() {
+		if (treeRoot == null) {
+			treeRoot = newLeafNode();
+		}
+	}
+
+	public static double computeHoeffdingBound(double range, double confidence, double n) {
+		return Math.sqrt(((range * range) * Math.log(1 / confidence)) / (2.0 * n));
+	}
+
+	public boolean buildingModelTree() {
+		return !regressionTreeOption.isSet();
+	}
+
+	public boolean normalize() {
+		return !doNotNormalizeOption.isSet();
+	}
+
+	protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex) {
+		// Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al.
+		MultiLabelSplitCriterion splitCriterion = null;
+		if (!runAsPCTOption.isSet()) {
+			splitCriterion = new WeightedICVarianceReduction(targetWeights);
+		} else {
+			DoubleVector inputWeights = new DoubleVector();
+			for (int i = 0; i < numInputAttributes; i++) inputWeights.setValue(i, 1);
+			splitCriterion = new PCTWeightedICVarianceReduction(targetWeights, new DoubleVector(), 0.5);
+		}
+
+		// Using this criterion, find the best split per attribute and rank the results
+		AttributeExpansionSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion); // TODO update with split criterion option
+		Arrays.sort(bestSplitSuggestions);
+
+		// Declare a variable to determine if any of the splits should be performed
+		boolean shouldSplit = false;
+		// If only one split was returned, use it
+		if (bestSplitSuggestions.length < 2) {
+			shouldSplit = bestSplitSuggestions.length > 0;
+		} else { // Otherwise, consider which of the splits proposed may be worth trying
+
+			// Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
+			// to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
+			double hoeffdingBound = computeHoeffdingBound(1, splitConfidenceOption.getValue(), node.examplesSeen);
+			// Determine the top two ranked splitting suggestions
+			AttributeExpansionSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+			AttributeExpansionSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
+
+			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
+			// as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
+			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
+			// splitting should occur.
+			// Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
+			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
+			// competing attributes are equally good, and the split will be made on the one with the higher SDR value.
+			if ((secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) || (hoeffdingBound < this.tieThresholdOption.getValue())) {
+				shouldSplit = true;
+			}
+			// If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
+			else {
+				// TODO pruning is currently disabled
+				for (int i = 0; i < node.attributeObservers.size(); i++) {
+					AttributeStatisticsObserver obs = node.attributeObservers.get(i);
+					if (obs != null) {
+						if (getModelContext().attribute(i).isNumeric());
+						//TODO obs.removeBadSplits(null, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound, getModelContext().numOutputAttributes());
+						if (getModelContext().attribute(i).isNominal());
+						// TODO nominal class observers
+					}
+				}
+			}
+		}
+
+		// If the splitting criterion were met, split the current node using the chosen attribute test, and
+		// make two new branches leading to (empty) leaves
+		//		try {
+		//			Thread.sleep(20000);
+		//		} catch (InterruptedException e) {
+		//			// TODO Auto-generated catch block
+		//			e.printStackTrace();
+		//		}
+
+		if (shouldSplit) {
+			AttributeExpansionSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+
+			SplitNode newSplit = newSplitNode(splitDecision.predicate);
+			newSplit.ID = node.ID;
+			newSplit.copyStatistics(node);
+			newSplit.changeDetection = node.changeDetection;
+			newSplit.ID = node.ID;
+			log(Integer.toString(node.ID) + ',' + Integer.toString((int) this.examplesSeen));
+			for (int i = 0; i < 2; i++) { // Hardcoded for 2 values (due to the use of the Predicate class)
+				LeafNode newChild = newLeafNode();
+				if (buildingModelTree()) {
+					// Copy the splitting node's perceptron to it's children
+					newChild.learningModel = new MultitargetPerceptron(this, node.learningModel);
+
+				}
+				newChild.changeDetection = node.changeDetection;
+				newChild.setParent(newSplit);
+				newSplit.setChild(i, newChild);
+			}
+			if (parent == null && node.originalNode == null) {
+				treeRoot = newSplit;
+			} else if (parent == null && node.originalNode != null) {
+				node.originalNode.alternateTree = newSplit;
+			} else {
+				parent.setChild(parentIndex, newSplit);
+				newSplit.setParent(parent);
+			}
+		}
+	}
+
+	public double computeSD(double squaredVal, double val, double size) {
+		if (size > 1)
+			return Math.sqrt((squaredVal - ((val * val) / size)) / size);
+		else
+			return 0.0;
+	}
+
+	public static double scalarProduct(DoubleVector u, DoubleVector v) {
+		double ret = 0.0;
+		for (int i = 0; i < Math.max(u.numValues(), v.numValues()); i++) {
+			ret += u.getValue(i) * v.getValue(i);
+		}
+		return ret;
+	}
+	//endregion --- Processing methods
+
+	public void initWriter(String filename) {
+		try {
+			writer = new BufferedWriter(new FileWriter(filename));
+			writer.write("");
+			writer.close();
+			writer = new BufferedWriter(new FileWriter(filename, true));
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	public void closeWriter() {
+		try {
+			writer.close();
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		writer = null;
+
+	}
+
+	public void log(String s) {
+		if (writer != null) {
+			try {
+				writer.write(s + "\n");
+				writer.flush();
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+		}
+	}
+
+	//endregion ================ METHODS ================
 }
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTreeRF.java b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTreeRF.java
new file mode 100644
index 000000000..ea8193d91
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTreeRF.java
@@ -0,0 +1,46 @@
+package moa.classifiers.multilabel.trees;
+
+import java.util.List;
+import java.util.Vector;
+
+import com.github.javacliparser.MultiChoiceOption;
+
+public class ISOUPTreeRF extends ISOUPTree {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 3145263568676115808L;
+	public MultiChoiceOption radndomForestFunAttrsOption = new MultiChoiceOption(
+			"randomForestFunAttr",
+			'z',
+			"The function of the number of input attribtues to use in the random forest construction.", 
+			new String[]{"sqrt", "log", "percent"}, new String[]{"Square root", "Logarithm", "10% percent"}, 0);
+	
+	
+	public int numRFAttrs() {
+		switch (radndomForestFunAttrsOption.getChosenLabel()) {
+		case "sqrt": return (int) Math.ceil(Math.sqrt(this.getModelContext().numInputAttributes()));
+		case "log": return (int) Math.ceil(Math.log(this.getModelContext().numInputAttributes())) + 1;
+		case "percent": return (int) Math.ceil(0.1 * this.getModelContext().numInputAttributes());
+		}
+		return 0;
+	}
+	
+	@Override
+	public List<Integer> newInputIndexes() {
+		List<Integer> indexes = new Vector<Integer>();
+		int numAttrs = this.getModelContext().numInputAttributes();
+		for (int i = 0; i < numAttrs; i++) {
+			indexes.add(i, i);
+		}
+		for (int i = 0; i < Math.ceil(numRFAttrs()); i++) {
+			int swap = i + this.classifierRandom.nextInt(numAttrs - i);
+			int temp = indexes.get(i);
+			indexes.set(i, indexes.get(swap));
+			indexes.set(swap, temp);
+		}
+		return indexes.subList(0, numRFAttrs());
+	}
+	
+}
diff --git a/moa/src/main/java/moa/classifiers/multitarget/BasicMultiTargetRegressor.java b/moa/src/main/java/moa/classifiers/multitarget/BasicMultiTargetRegressor.java
index edad24332..a7a1a1ac1 100644
--- a/moa/src/main/java/moa/classifiers/multitarget/BasicMultiTargetRegressor.java
+++ b/moa/src/main/java/moa/classifiers/multitarget/BasicMultiTargetRegressor.java
@@ -1,6 +1,13 @@
 
 package moa.classifiers.multitarget;
 
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
+import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.AbstractMultiLabelLearner;
 import moa.classifiers.Classifier;
@@ -12,14 +19,6 @@
 import moa.options.ClassOption;
 import moa.streams.InstanceStream;
 
-import com.yahoo.labs.samoa.instances.DenseInstance;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
-import com.yahoo.labs.samoa.instances.Prediction;
-
 
 public class BasicMultiTargetRegressor extends AbstractMultiLabelLearner implements MultiTargetRegressor{
 
diff --git a/moa/src/main/java/moa/classifiers/multitarget/functions/MultiTargetNoChange.java b/moa/src/main/java/moa/classifiers/multitarget/functions/MultiTargetNoChange.java
index 9f08ed855..cae16376a 100644
--- a/moa/src/main/java/moa/classifiers/multitarget/functions/MultiTargetNoChange.java
+++ b/moa/src/main/java/moa/classifiers/multitarget/functions/MultiTargetNoChange.java
@@ -1,14 +1,10 @@
 package moa.classifiers.multitarget.functions;
 
 
-import com.yahoo.labs.samoa.instances.DenseInstanceData;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
-import moa.classifiers.AbstractClassifier;
 import moa.classifiers.AbstractMultiLabelLearner;
 import moa.classifiers.MultiTargetRegressor;
 import moa.core.Measurement;
diff --git a/moa/src/main/java/moa/classifiers/rules/AMRulesRegressorOld.java b/moa/src/main/java/moa/classifiers/rules/AMRulesRegressorOld.java
index 63b1d3f9f..8a8020529 100644
--- a/moa/src/main/java/moa/classifiers/rules/AMRulesRegressorOld.java
+++ b/moa/src/main/java/moa/classifiers/rules/AMRulesRegressorOld.java
@@ -64,11 +64,10 @@
 import com.github.javacliparser.MultiChoiceOption;
 
 import moa.classifiers.Regressor;
-import moa.classifiers.core.splitcriteria.VarianceReductionSplitCriterion;
 import moa.classifiers.rules.core.Rule;
+import moa.classifiers.rules.core.Rule.Builder;
 import moa.classifiers.rules.core.RuleActiveLearningNode;
 import moa.classifiers.rules.core.RuleActiveRegressionNode;
-import moa.classifiers.rules.core.Rule.Builder;
 import moa.classifiers.rules.core.splitcriteria.AMRulesSplitCriterion;
 import moa.classifiers.rules.core.voting.ErrorWeightedVote;
 import moa.classifiers.rules.functions.Perceptron;
diff --git a/moa/src/main/java/moa/classifiers/rules/AbstractAMRules.java b/moa/src/main/java/moa/classifiers/rules/AbstractAMRules.java
index ab2555b7a..8f6911d14 100644
--- a/moa/src/main/java/moa/classifiers/rules/AbstractAMRules.java
+++ b/moa/src/main/java/moa/classifiers/rules/AbstractAMRules.java
@@ -31,19 +31,19 @@
  * 
  **/
 
+import java.util.Arrays;
+import java.util.Iterator;
+
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
-import java.util.Arrays;
-import java.util.Iterator;
-
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.rules.core.Rule;
+import moa.classifiers.rules.core.Rule.Builder;
 import moa.classifiers.rules.core.RuleActiveLearningNode;
 import moa.classifiers.rules.core.RuleSet;
-import moa.classifiers.rules.core.Rule.Builder;
 import moa.classifiers.rules.core.attributeclassobservers.FIMTDDNumericAttributeClassLimitObserver;
 import moa.classifiers.rules.core.voting.ErrorWeightedVote;
 import moa.classifiers.rules.core.voting.Vote;
diff --git a/moa/src/main/java/moa/classifiers/rules/Predicates.java b/moa/src/main/java/moa/classifiers/rules/Predicates.java
index 76b96f084..db1583359 100644
--- a/moa/src/main/java/moa/classifiers/rules/Predicates.java
+++ b/moa/src/main/java/moa/classifiers/rules/Predicates.java
@@ -21,6 +21,8 @@
 
 package moa.classifiers.rules;
 
+import com.yahoo.labs.samoa.instances.Instance;
+
 /**
  * Class that creates and evaluates the predicates
  * 
@@ -32,7 +34,6 @@
  */
 
 import moa.AbstractMOAObject;
-import com.yahoo.labs.samoa.instances.Instance;
 
 public class Predicates extends AbstractMOAObject{
 	
diff --git a/moa/src/main/java/moa/classifiers/rules/RuleClassification.java b/moa/src/main/java/moa/classifiers/rules/RuleClassification.java
index c7b9866e4..3d6fdcda9 100644
--- a/moa/src/main/java/moa/classifiers/rules/RuleClassification.java
+++ b/moa/src/main/java/moa/classifiers/rules/RuleClassification.java
@@ -33,11 +33,13 @@
  */
 
 import java.util.ArrayList;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.AbstractMOAObject;
-import moa.classifiers.core.attributeclassobservers.*;
+import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
-import com.yahoo.labs.samoa.instances.Instance;
 
 public class RuleClassification extends AbstractMOAObject{
 	
diff --git a/moa/src/main/java/moa/classifiers/rules/RuleClassifier.java b/moa/src/main/java/moa/classifiers/rules/RuleClassifier.java
index 0e8dbd6e3..6d4f860d6 100644
--- a/moa/src/main/java/moa/classifiers/rules/RuleClassifier.java
+++ b/moa/src/main/java/moa/classifiers/rules/RuleClassifier.java
@@ -25,21 +25,26 @@
 import java.io.IOException;
 import java.io.PrintWriter;
 import java.math.BigDecimal;
-import java.util.*;
-import com.github.javacliparser.FlagOption; 
+import java.util.ArrayList;
+import java.util.Collections;
 
+import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
-import moa.classifiers.core.attributeclassobservers.*;
+import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
+import moa.classifiers.core.attributeclassobservers.BinaryTreeNumericAttributeClassObserver;
 import moa.classifiers.core.attributeclassobservers.BinaryTreeNumericAttributeClassObserver.Node;
+import moa.classifiers.core.attributeclassobservers.GaussianNumericAttributeClassObserver;
+import moa.classifiers.core.attributeclassobservers.NominalAttributeClassObserver;
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.StringUtils;
 import moa.core.Utils;
-import com.yahoo.labs.samoa.instances.Instance;
 
 
 
diff --git a/moa/src/main/java/moa/classifiers/rules/RuleClassifierNBayes.java b/moa/src/main/java/moa/classifiers/rules/RuleClassifierNBayes.java
index 6a23e9f06..d495592f3 100644
--- a/moa/src/main/java/moa/classifiers/rules/RuleClassifierNBayes.java
+++ b/moa/src/main/java/moa/classifiers/rules/RuleClassifierNBayes.java
@@ -22,10 +22,12 @@
 
 import java.util.ArrayList;
 import java.util.Collections;
+
 import com.github.javacliparser.IntOption;
-import moa.classifiers.bayes.NaiveBayes;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.classifiers.bayes.NaiveBayes;
+
 /**
  * This classifier learn ordered and unordered rule set from data stream with naive Bayes learners.
  * <p> This algorithm also does the detection of anomalies.
diff --git a/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java
index 7e5febe56..fb5505ef7 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java
@@ -2,7 +2,6 @@
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.AbstractMOAObject;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java
index a6b313c12..8387610c0 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java
@@ -2,7 +2,6 @@
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.AbstractMOAObject;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/Rule.java b/moa/src/main/java/moa/classifiers/rules/core/Rule.java
index c12befcb2..4cea1b6dc 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/Rule.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/Rule.java
@@ -19,6 +19,10 @@
  */
 package moa.classifiers.rules.core;
 
+import java.io.Serializable;
+import java.util.LinkedList;
+import java.util.List;
+
 /**
  * Class that stores an arrayList of predicates of a rule and the observers
  * (statistics). This class implements a function that evaluates a rule.
@@ -36,10 +40,6 @@
 import com.github.javacliparser.FloatOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
-import java.io.Serializable;
-import java.util.LinkedList;
-import java.util.List;
-
 import moa.AbstractMOAObject;
 import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
 import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/RuleActiveLearningNode.java b/moa/src/main/java/moa/classifiers/rules/core/RuleActiveLearningNode.java
index 1613a7049..1eaff66bd 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/RuleActiveLearningNode.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/RuleActiveLearningNode.java
@@ -24,8 +24,8 @@
 import moa.classifiers.core.AttributeSplitSuggestion;
 import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
 import moa.classifiers.rules.AbstractAMRules;
-import moa.classifiers.rules.driftdetection.PageHinkleyTest;
 import moa.classifiers.rules.driftdetection.PageHinkleyFading;
+import moa.classifiers.rules.driftdetection.PageHinkleyTest;
 import moa.classifiers.trees.HoeffdingTree;
 import moa.classifiers.trees.HoeffdingTree.ActiveLearningNode;
 import moa.core.AutoExpandVector;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/RuleActiveRegressionNode.java b/moa/src/main/java/moa/classifiers/rules/core/RuleActiveRegressionNode.java
index 1eebdfad7..0f39b9f91 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/RuleActiveRegressionNode.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/RuleActiveRegressionNode.java
@@ -20,28 +20,20 @@
 
 package moa.classifiers.rules.core;
 
-import com.yahoo.labs.samoa.instances.Instance;
-
-import java.io.BufferedWriter;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.io.PrintWriter;
-import java.sql.PreparedStatement;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
 
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.core.AttributeSplitSuggestion;
 import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
 import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
 import moa.classifiers.rules.AMRulesRegressorOld;
-import moa.classifiers.rules.AbstractAMRules;
 import moa.classifiers.rules.core.splitcriteria.AMRulesSplitCriterion;
-import moa.classifiers.rules.core.splitcriteria.SDRSplitCriterionAMRules;
 import moa.classifiers.rules.functions.Perceptron;
 import moa.classifiers.rules.functions.TargetMean;
 import moa.core.DoubleVector;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/Utils.java b/moa/src/main/java/moa/classifiers/rules/core/Utils.java
index 1c60f8dfb..5340ea695 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/Utils.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/Utils.java
@@ -14,6 +14,11 @@ public static double computeVariance(DoubleVector statistics)
 		return computeVariance(statistics.getValue(0),statistics.getValue(1),statistics.getValue(2));
 	}
 
+	public static double computeVariance(double[] statistics)
+	{
+		return computeVariance(statistics[0],statistics[1],statistics[2]);
+	}
+	
 	public static double computeSD(double squaredSum, double sum, double weightSeen) {
 		if (weightSeen > 1) {
 			return Math.sqrt((squaredSum - ((sum * sum) / weightSeen)) / (weightSeen - 1.0));
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AbstractAnomalyDetector.java b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AbstractAnomalyDetector.java
index 13a4f85ba..5d91180e4 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AbstractAnomalyDetector.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AbstractAnomalyDetector.java
@@ -1,8 +1,9 @@
 package moa.classifiers.rules.core.anomalydetection;
 
-import moa.options.AbstractOptionHandler;
 import com.yahoo.labs.samoa.instances.StructuredInstance;
 
+import moa.options.AbstractOptionHandler;
+
 
 public abstract class AbstractAnomalyDetector extends AbstractOptionHandler implements AnomalyDetector {
 
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalinessRatioScore.java b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalinessRatioScore.java
index 9297ebe1e..a6a3bdae6 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalinessRatioScore.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalinessRatioScore.java
@@ -1,18 +1,16 @@
 package moa.classifiers.rules.core.anomalydetection;
 
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.classifiers.rules.core.Utils;
 import moa.classifiers.rules.core.anomalydetection.probabilityfunctions.ProbabilityFunction;
-import moa.classifiers.rules.core.attributeclassobservers.FIMTDDNumericAttributeClassLimitObserver;
 import moa.core.AutoExpandVector;
 import moa.core.ObjectRepository;
 import moa.options.ClassOption;
 import moa.tasks.TaskMonitor;
 
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-
 public class AnomalinessRatioScore extends AbstractAnomalyDetector {
 
 	/**
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/NoAnomalyDetection.java b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/NoAnomalyDetection.java
index 722f15dfa..6ad69595a 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/NoAnomalyDetection.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/NoAnomalyDetection.java
@@ -1,8 +1,9 @@
 package moa.classifiers.rules.core.anomalydetection;
 
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 public class NoAnomalyDetection extends AbstractAnomalyDetector{
 
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/OddsRatioScore.java b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/OddsRatioScore.java
index 53cc8556c..ee841f6f2 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/OddsRatioScore.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/OddsRatioScore.java
@@ -1,5 +1,10 @@
 package moa.classifiers.rules.core.anomalydetection;
 
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.classifiers.rules.core.Utils;
 import moa.classifiers.rules.core.anomalydetection.probabilityfunctions.CantellisInequality;
 import moa.classifiers.rules.core.anomalydetection.probabilityfunctions.ProbabilityFunction;
@@ -8,11 +13,6 @@
 import moa.options.ClassOption;
 import moa.tasks.TaskMonitor;
 
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-
 public class OddsRatioScore extends AbstractAnomalyDetector {
 
 	/**
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/CantellisInequality.java b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/CantellisInequality.java
index c021dad34..63aad5315 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/CantellisInequality.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/CantellisInequality.java
@@ -2,11 +2,8 @@
 
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-import moa.options.OptionHandler;
 import moa.tasks.TaskMonitor;
 
-import com.github.javacliparser.Options;
-
 public class CantellisInequality extends AbstractOptionHandler implements ProbabilityFunction {
 
 	/**
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/ChebyshevInequality.java b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/ChebyshevInequality.java
index 52d897aa1..f32fb6243 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/ChebyshevInequality.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/ChebyshevInequality.java
@@ -2,11 +2,8 @@
 
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-import moa.options.OptionHandler;
 import moa.tasks.TaskMonitor;
 
-import com.github.javacliparser.Options;
-
 public class ChebyshevInequality extends AbstractOptionHandler implements ProbabilityFunction {
 
 	/**
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/GaussInequality.java b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/GaussInequality.java
index aa73a67a5..ea587e6dd 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/GaussInequality.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/GaussInequality.java
@@ -2,11 +2,8 @@
 
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-import moa.options.OptionHandler;
 import moa.tasks.TaskMonitor;
 
-import com.github.javacliparser.Options;
-
 public class GaussInequality extends AbstractOptionHandler implements ProbabilityFunction {
 
 	/**
diff --git a/moa/src/main/java/moa/classifiers/rules/core/attributeclassobservers/FIMTDDNumericAttributeClassLimitObserver.java b/moa/src/main/java/moa/classifiers/rules/core/attributeclassobservers/FIMTDDNumericAttributeClassLimitObserver.java
index de93184cf..83740c403 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/attributeclassobservers/FIMTDDNumericAttributeClassLimitObserver.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/attributeclassobservers/FIMTDDNumericAttributeClassLimitObserver.java
@@ -20,6 +20,7 @@
 package moa.classifiers.rules.core.attributeclassobservers;
 
 import com.github.javacliparser.IntOption;
+
 import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
 
 
@@ -99,9 +100,6 @@ else if (val < this.cut_point) {
 		// right (>) distribution and send the value down to the right child node.
 		// If no right child exists, create one
 		else { // val > cut_point
-			this.rightStatistics.addToValue(0,1);
-			this.rightStatistics.addToValue(1,label);
-			this.rightStatistics.addToValue(2,label*label);
 			if (this.right == null) {
 				if(numNodes<maxNodes){
 					this.right = new Node(val, label, weight);
diff --git a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java
index 93d962149..df2405a5a 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java
@@ -21,7 +21,6 @@
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import moa.classifiers.core.conditionaltests.NominalAttributeBinaryTest;
 import moa.classifiers.rules.core.Predicate;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java
index ff4c0c350..37650e7ca 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java
@@ -21,7 +21,6 @@
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import moa.classifiers.core.conditionaltests.InstanceConditionalBinaryTest;
 import moa.classifiers.rules.core.Predicate;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/SDRSplitCriterionAMRules.java b/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/SDRSplitCriterionAMRules.java
index 8442a9006..b5fc4d1fa 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/SDRSplitCriterionAMRules.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/SDRSplitCriterionAMRules.java
@@ -20,7 +20,6 @@
 package moa.classifiers.rules.core.splitcriteria;
 
 import moa.classifiers.core.splitcriteria.SDRSplitCriterion;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
 
 
 public class SDRSplitCriterionAMRules extends SDRSplitCriterion implements AMRulesSplitCriterion {
diff --git a/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/SDRSplitCriterionAMRulesNode.java b/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/SDRSplitCriterionAMRulesNode.java
index bfdab536b..c95cf7ab0 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/SDRSplitCriterionAMRulesNode.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/SDRSplitCriterionAMRulesNode.java
@@ -19,8 +19,6 @@
  */
 package moa.classifiers.rules.core.splitcriteria;
 
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-
 public class SDRSplitCriterionAMRulesNode extends SDRSplitCriterionAMRules implements AMRulesSplitCriterion {
 
     private static final long serialVersionUID = 1L;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/voting/AbstractErrorWeightedVote.java b/moa/src/main/java/moa/classifiers/rules/core/voting/AbstractErrorWeightedVote.java
index 483f62591..98ce19126 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/voting/AbstractErrorWeightedVote.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/voting/AbstractErrorWeightedVote.java
@@ -22,6 +22,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+
 import moa.AbstractMOAObject;
 
 /**
diff --git a/moa/src/main/java/moa/classifiers/rules/errormeasurers/MeanAbsoluteDeviation.java b/moa/src/main/java/moa/classifiers/rules/errormeasurers/MeanAbsoluteDeviation.java
index 1844f2bdf..e76609a9c 100644
--- a/moa/src/main/java/moa/classifiers/rules/errormeasurers/MeanAbsoluteDeviation.java
+++ b/moa/src/main/java/moa/classifiers/rules/errormeasurers/MeanAbsoluteDeviation.java
@@ -1,6 +1,5 @@
 package moa.classifiers.rules.errormeasurers;
 
-import com.github.javacliparser.FloatOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
 /*
diff --git a/moa/src/main/java/moa/classifiers/rules/errormeasurers/RootMeanSquaredError.java b/moa/src/main/java/moa/classifiers/rules/errormeasurers/RootMeanSquaredError.java
index fe334910a..3c706662e 100644
--- a/moa/src/main/java/moa/classifiers/rules/errormeasurers/RootMeanSquaredError.java
+++ b/moa/src/main/java/moa/classifiers/rules/errormeasurers/RootMeanSquaredError.java
@@ -2,8 +2,6 @@
 
 import com.yahoo.labs.samoa.instances.Instance;
 
-import moa.AbstractMOAObject;
-
 public class RootMeanSquaredError extends ErrorMeasurement {
 
 	/**
diff --git a/moa/src/main/java/moa/classifiers/rules/functions/AMRulesLearner.java b/moa/src/main/java/moa/classifiers/rules/functions/AMRulesLearner.java
index 5fd8f7ff3..5d9a4761b 100644
--- a/moa/src/main/java/moa/classifiers/rules/functions/AMRulesLearner.java
+++ b/moa/src/main/java/moa/classifiers/rules/functions/AMRulesLearner.java
@@ -1,10 +1,10 @@
 package moa.classifiers.rules.functions;
 
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.core.Example;
 import moa.learners.Learner;
 
-import com.yahoo.labs.samoa.instances.Instance;
-
 public interface AMRulesLearner extends Learner<Example<Instance>>{
 	
 	public double getCurrentError();
diff --git a/moa/src/main/java/moa/classifiers/rules/functions/Perceptron.java b/moa/src/main/java/moa/classifiers/rules/functions/Perceptron.java
index a5e48b1a8..d8d6bdd81 100644
--- a/moa/src/main/java/moa/classifiers/rules/functions/Perceptron.java
+++ b/moa/src/main/java/moa/classifiers/rules/functions/Perceptron.java
@@ -25,10 +25,8 @@
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.classifiers.AbstractClassifier;
-import moa.classifiers.Regressor;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 
diff --git a/moa/src/main/java/moa/classifiers/rules/functions/TargetMean.java b/moa/src/main/java/moa/classifiers/rules/functions/TargetMean.java
index 53f8c63c1..fcb7e6f8d 100644
--- a/moa/src/main/java/moa/classifiers/rules/functions/TargetMean.java
+++ b/moa/src/main/java/moa/classifiers/rules/functions/TargetMean.java
@@ -26,8 +26,8 @@
  *  */
 import com.github.javacliparser.FloatOption;
 import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
-import moa.classifiers.Regressor;
 import moa.core.Measurement;
 import moa.core.StringUtils;
 
diff --git a/moa/src/main/java/moa/classifiers/rules/meta/RandomAMRulesOld.java b/moa/src/main/java/moa/classifiers/rules/meta/RandomAMRulesOld.java
index 8828c1d84..5037efd76 100644
--- a/moa/src/main/java/moa/classifiers/rules/meta/RandomAMRulesOld.java
+++ b/moa/src/main/java/moa/classifiers/rules/meta/RandomAMRulesOld.java
@@ -21,13 +21,10 @@
 
 import java.util.Arrays;
 
-import moa.options.ClassOption;
-
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
@@ -38,11 +35,9 @@
 import moa.classifiers.rules.AbstractAMRules;
 import moa.classifiers.rules.core.voting.ErrorWeightedVote;
 import moa.classifiers.rules.core.voting.Vote;
-import moa.core.DoubleVector;
-import moa.core.FastVector;
 import moa.core.Measurement;
 import moa.core.MiscUtils;
-import moa.streams.InstanceStream;
+import moa.options.ClassOption;
 
 
 public class RandomAMRulesOld extends AbstractClassifier implements Regressor {
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java b/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java
index 44a24ae5f..0ad8c1ec2 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java
@@ -33,6 +33,12 @@
 
 import java.util.Iterator;
 
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.classifiers.AbstractMultiLabelLearner;
 import moa.classifiers.MultiLabelLearner;
 import moa.classifiers.core.driftdetection.ChangeDetector;
@@ -44,7 +50,6 @@
 import moa.classifiers.rules.multilabel.core.MultiLabelRule;
 import moa.classifiers.rules.multilabel.core.MultiLabelRuleSet;
 import moa.classifiers.rules.multilabel.core.voting.ErrorWeightedVoteMultiLabel;
-import moa.classifiers.rules.multilabel.core.voting.MultiLabelVote;
 import moa.classifiers.rules.multilabel.errormeasurers.MultiLabelErrorMeasurer;
 import moa.classifiers.rules.multilabel.outputselectors.OutputAttributesSelector;
 import moa.classifiers.rules.multilabel.outputselectors.SelectAllOutputs;
@@ -52,12 +57,6 @@
 import moa.core.StringUtils;
 import moa.options.ClassOption;
 
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.Prediction;
-
 
 public abstract class AMRulesMultiLabelLearner extends AbstractMultiLabelLearner implements MultiLabelLearner{
 
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressor.java b/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressor.java
index 146a6be85..461c63925 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressor.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressor.java
@@ -2,12 +2,10 @@
 
 import moa.classifiers.MultiLabelLearner;
 import moa.classifiers.MultiTargetRegressor;
-import moa.classifiers.Regressor;
 import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.rules.multilabel.core.MultiLabelRule;
 import moa.classifiers.rules.multilabel.core.MultiLabelRuleRegression;
 import moa.classifiers.rules.multilabel.core.voting.ErrorWeightedVoteMultiLabel;
-import moa.classifiers.rules.multilabel.core.voting.InverseErrorWeightedVoteMultiLabel;
 import moa.classifiers.rules.multilabel.errormeasurers.MultiLabelErrorMeasurer;
 import moa.options.ClassOption;
 
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java
index 9c179d2f6..a8bafb4a1 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java
@@ -7,15 +7,10 @@
 import java.util.Random;
 
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.classifiers.MultiLabelLearner;
-import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.NumericAttributeClassObserver;
 import moa.classifiers.core.driftdetection.ChangeDetector;
 import moa.classifiers.multilabel.core.attributeclassobservers.AttributeStatisticsObserver;
 import moa.classifiers.multilabel.core.attributeclassobservers.NominalStatisticsObserver;
@@ -23,13 +18,11 @@
 import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.rules.core.AttributeExpansionSuggestion;
 import moa.classifiers.rules.core.anomalydetection.AnomalyDetector;
-import moa.classifiers.rules.multilabel.errormeasurers.AbstractMultiTargetErrorMeasurer;
 import moa.classifiers.rules.multilabel.errormeasurers.MultiLabelErrorMeasurer;
 import moa.classifiers.rules.multilabel.outputselectors.OutputAttributesSelector;
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
 import moa.options.AbstractOptionHandler;
-import moa.options.ClassOption;
 
 
 public abstract class LearningLiteral extends AbstractOptionHandler {
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java
index f9e2c5c82..282ca1dba 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java
@@ -1,20 +1,14 @@
 package moa.classifiers.rules.multilabel.core;
 
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.Prediction;
-
 import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
 
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.classifiers.MultiLabelLearner;
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
-import moa.classifiers.core.driftdetection.ChangeDetector;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
 import moa.classifiers.multilabel.core.attributeclassobservers.AttributeStatisticsObserver;
 import moa.classifiers.multilabel.core.attributeclassobservers.NominalStatisticsObserver;
 import moa.classifiers.multilabel.core.attributeclassobservers.NumericStatisticsObserver;
@@ -25,7 +19,6 @@
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
 import moa.core.ObjectRepository;
-import moa.learners.Learner;
 import moa.tasks.TaskMonitor;
 
 public class LearningLiteralRegression extends LearningLiteral {
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java
index 0fb2aba8b..23e58b418 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java
@@ -5,22 +5,16 @@
 import java.util.List;
 import java.util.Random;
 
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.AbstractMOAObject;
 import moa.classifiers.MultiLabelLearner;
-import moa.classifiers.core.attributeclassobservers.NumericAttributeClassObserver;
-import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
-import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
 import moa.classifiers.core.driftdetection.ChangeDetector;
 import moa.classifiers.multilabel.core.attributeclassobservers.NominalStatisticsObserver;
 import moa.classifiers.multilabel.core.attributeclassobservers.NumericStatisticsObserver;
 import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
-import moa.classifiers.rules.core.RuleActiveLearningNode;
-import moa.classifiers.rules.core.RuleSplitNode;
 import moa.classifiers.rules.core.anomalydetection.AnomalyDetector;
-import moa.classifiers.rules.core.conditionaltests.NumericAttributeBinaryRulePredicate;
 import moa.classifiers.rules.multilabel.errormeasurers.MultiLabelErrorMeasurer;
 import moa.classifiers.rules.multilabel.outputselectors.OutputAttributesSelector;
 import moa.core.StringUtils;
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/AbstractErrorWeightedVoteMultiLabel.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/AbstractErrorWeightedVoteMultiLabel.java
index 8572a8b5a..59cada880 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/AbstractErrorWeightedVoteMultiLabel.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/AbstractErrorWeightedVoteMultiLabel.java
@@ -26,7 +26,6 @@
 import com.yahoo.labs.samoa.instances.Prediction;
 
 import moa.AbstractMOAObject;
-import moa.core.DoubleVector;
 
 /**
  * AbstractErrorWeightedVote class for weighted votes based on estimates of errors. 
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/ErrorWeightedVoteMultiLabel.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/ErrorWeightedVoteMultiLabel.java
index 5bdb2530e..22d49cc75 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/ErrorWeightedVoteMultiLabel.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/ErrorWeightedVoteMultiLabel.java
@@ -20,8 +20,6 @@
 
 package moa.classifiers.rules.multilabel.core.voting;
 
-import java.util.List;
-
 import com.yahoo.labs.samoa.instances.Prediction;
 
 import moa.MOAObject;
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiLabelErrorMeasurer.java b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiLabelErrorMeasurer.java
index b96ddd2a7..1d393bf4b 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiLabelErrorMeasurer.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiLabelErrorMeasurer.java
@@ -1,13 +1,13 @@
 package moa.classifiers.rules.multilabel.errormeasurers;
 
+import com.github.javacliparser.FloatOption;
+import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.tasks.TaskMonitor;
 
-import com.github.javacliparser.FloatOption;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.Prediction;
-
 public abstract class AbstractMultiLabelErrorMeasurer  extends AbstractOptionHandler implements MultiTargetErrorMeasurer{
 
 	/**
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiTargetErrorMeasurer.java b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiTargetErrorMeasurer.java
index 5b2bc3be8..bb22ff469 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiTargetErrorMeasurer.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiTargetErrorMeasurer.java
@@ -1,8 +1,8 @@
 package moa.classifiers.rules.multilabel.errormeasurers;
 
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 public abstract class AbstractMultiTargetErrorMeasurer extends AbstractMultiLabelErrorMeasurer implements MultiLabelErrorMeasurer{
 
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/MultiLabelErrorMeasurer.java b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/MultiLabelErrorMeasurer.java
index 66259cfe6..9f280d765 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/MultiLabelErrorMeasurer.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/MultiLabelErrorMeasurer.java
@@ -1,7 +1,7 @@
 package moa.classifiers.rules.multilabel.errormeasurers;
 
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.options.OptionHandler;
 
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/RootMeanSquaredErrorMT.java b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/RootMeanSquaredErrorMT.java
index cab1cab93..08d5d319d 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/RootMeanSquaredErrorMT.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/RootMeanSquaredErrorMT.java
@@ -1,8 +1,5 @@
 package moa.classifiers.rules.multilabel.errormeasurers;
 
-import moa.core.ObjectRepository;
-import moa.tasks.TaskMonitor;
-
 import com.yahoo.labs.samoa.instances.Prediction;
 
 public class RootMeanSquaredErrorMT extends AbstractMultiTargetErrorMeasurer {
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/AdaptiveMultiTargetRegressor.java b/moa/src/main/java/moa/classifiers/rules/multilabel/functions/AdaptiveMultiTargetRegressor.java
index 1f0adf4b4..7541446ac 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/AdaptiveMultiTargetRegressor.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/functions/AdaptiveMultiTargetRegressor.java
@@ -1,16 +1,15 @@
 package moa.classifiers.rules.multilabel.functions;
 
+import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.classifiers.AbstractMultiLabelLearner;
 import moa.classifiers.MultiTargetRegressor;
 import moa.classifiers.rules.multilabel.errormeasurers.AbstractMultiTargetErrorMeasurer;
 import moa.classifiers.rules.multilabel.errormeasurers.MultiTargetErrorMeasurer;
 import moa.core.Measurement;
-import moa.learners.Learner;
 import moa.options.ClassOption;
 
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.Prediction;
-
 public class AdaptiveMultiTargetRegressor extends AbstractMultiLabelLearner
 implements MultiTargetRegressor, AMRulesFunction {
 
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/MultiLabelTargetMeanRegressor.java b/moa/src/main/java/moa/classifiers/rules/multilabel/functions/MultiLabelTargetMeanRegressor.java
index ce744a59f..4a80a690d 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/MultiLabelTargetMeanRegressor.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/functions/MultiLabelTargetMeanRegressor.java
@@ -4,7 +4,6 @@
 
 import moa.classifiers.MultiTargetRegressor;
 import moa.classifiers.multitarget.BasicMultiTargetRegressor;
-import moa.classifiers.rules.functions.Perceptron;
 import moa.classifiers.rules.functions.TargetMean;
 import moa.options.ClassOption;
 
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/meta/MultiLabelRandomAMRules.java b/moa/src/main/java/moa/classifiers/rules/multilabel/meta/MultiLabelRandomAMRules.java
index 7c08a3eed..8085c13bb 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/meta/MultiLabelRandomAMRules.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/meta/MultiLabelRandomAMRules.java
@@ -1,9 +1,15 @@
 package moa.classifiers.rules.multilabel.meta;
 
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.classifiers.AbstractMultiLabelLearner;
 import moa.classifiers.MultiTargetRegressor;
-import moa.classifiers.rules.AbstractAMRules;
-import moa.classifiers.rules.core.voting.ErrorWeightedVote;
 import moa.classifiers.rules.multilabel.AMRulesMultiLabelLearner;
 import moa.classifiers.rules.multilabel.core.voting.ErrorWeightedVoteMultiLabel;
 import moa.classifiers.rules.multilabel.core.voting.UniformWeightedVoteMultiLabel;
@@ -13,14 +19,6 @@
 import moa.core.MiscUtils;
 import moa.options.ClassOption;
 
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.Prediction;
-
 public class MultiLabelRandomAMRules extends AbstractMultiLabelLearner
 implements MultiTargetRegressor {
 
diff --git a/moa/src/main/java/moa/classifiers/trees/AdaHoeffdingOptionTree.java b/moa/src/main/java/moa/classifiers/trees/AdaHoeffdingOptionTree.java
index 6e6db6109..2cefc4f0e 100644
--- a/moa/src/main/java/moa/classifiers/trees/AdaHoeffdingOptionTree.java
+++ b/moa/src/main/java/moa/classifiers/trees/AdaHoeffdingOptionTree.java
@@ -19,9 +19,10 @@
  */
 package moa.classifiers.trees;
 
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.bayes.NaiveBayes;
 import moa.core.Utils;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Adaptive decision option tree for streaming data with adaptive Naive
diff --git a/moa/src/main/java/moa/classifiers/trees/DecisionStump.java b/moa/src/main/java/moa/classifiers/trees/DecisionStump.java
index 10f4e0fa0..705c73348 100644
--- a/moa/src/main/java/moa/classifiers/trees/DecisionStump.java
+++ b/moa/src/main/java/moa/classifiers/trees/DecisionStump.java
@@ -21,6 +21,8 @@
 
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.core.AttributeSplitSuggestion;
 import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
@@ -31,7 +33,6 @@
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.options.ClassOption;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Decision trees of one level.<br />
diff --git a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java b/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
index f986c3d60..8962cd12c 100644
--- a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
+++ b/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
@@ -25,24 +25,24 @@
 import java.util.LinkedList;
 import java.util.List;
 
-import com.yahoo.labs.samoa.instances.Instance;
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
 
-import moa.options.ClassOption;
 import moa.AbstractMOAObject;
+import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Regressor;
 import moa.classifiers.core.AttributeSplitSuggestion;
 import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
 import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.classifiers.AbstractClassifier;
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.SizeOf;
 import moa.core.StringUtils;
+import moa.options.ClassOption;
 
 /*
  * Implementation of FIMTDD, regression and model trees for data streams.
@@ -159,8 +159,8 @@ public void copyStatistics(Node node) {
 			sumOfAbsErrors = node.sumOfAbsErrors;
 		}
 
-		public int calcByteSize() {
-			return (int) SizeOf.fullSizeOf(this);
+		public long calcByteSize() {
+			return SizeOf.sizeOf(this) + (originalNode == null && alternateTree != null ? alternateTree.calcByteSize() : 0);
 		}
 
 		/**
@@ -259,6 +259,14 @@ public LeafNode(FIMTDD tree) {
 			sumOfAbsErrors = 0;
 		}
 
+		public long calcByteSize() {
+			long size = super.calcByteSize();
+			if (tree.buildingModelTree())
+				size += learningModel.calcByteSize();
+			size += SizeOf.fullSizeOf(attributeObservers);
+			return size;
+		}
+		
 		public void setChild(int parentBranch, Node node) {
 		}
 
@@ -416,6 +424,13 @@ public abstract static class InnerNode extends Node {
 		public InnerNode(FIMTDD tree) {
 			super(tree);
 		}
+		
+		public long calcByteSize() {
+			long size = super.calcByteSize();
+			for (Node child : children)
+				size += child.calcByteSize();
+			return size;
+		}
 
 		public int numChildren() {
 			return children.size();
@@ -505,6 +520,12 @@ public SplitNode(InstanceConditionalTest splitTest, FIMTDD tree) {
 			super(tree);
 			this.splitTest = splitTest;
 		}
+		
+		public long calcByteSize() {
+			long size = super.calcByteSize();
+			size += SizeOf.sizeOf(splitTest);
+			return size;
+		}
 
 		public int instanceChildIndex(Instance inst) {
 			return splitTest.branchForInstance(inst);
@@ -561,6 +582,10 @@ public FIMTDDPerceptron(FIMTDD tree) {
 
 		}
 
+		public long calcByteSize() {
+			return SizeOf.sizeOf(this);
+		}
+		
 		public void initializeWeights() {
 			weightAttribute = new double[tree.getModelContext().numInputAttributes()+1];
 			instancesSeen = 0;
@@ -710,8 +735,15 @@ protected Measurement[] getModelMeasurementsImpl() {
 		};
 	}
 
-	public int calcByteSize() {
-		return (int) SizeOf.fullSizeOf(this);
+	@Override
+	public long measureByteSize() {
+		return calcByteSize();
+	}
+	
+	public long calcByteSize() {
+		long size = (long) (SizeOf.sizeOf(this)) + this.treeRoot.calcByteSize();
+		size += (long) (SizeOf.sizeOf(this.sumOfAttrValues)) + (int) (SizeOf.sizeOf(this.sumOfAttrSquares));
+		return size;
 	}
 
 	public double[] getVotesForInstance(Instance inst) {
diff --git a/moa/src/main/java/moa/classifiers/trees/HoeffdingAdaptiveTree.java b/moa/src/main/java/moa/classifiers/trees/HoeffdingAdaptiveTree.java
index dd1691fd2..c68657bc0 100644
--- a/moa/src/main/java/moa/classifiers/trees/HoeffdingAdaptiveTree.java
+++ b/moa/src/main/java/moa/classifiers/trees/HoeffdingAdaptiveTree.java
@@ -22,13 +22,15 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Random;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.bayes.NaiveBayes;
 import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
 import moa.classifiers.core.driftdetection.ADWIN;
 import moa.core.DoubleVector;
 import moa.core.MiscUtils;
 import moa.core.Utils;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Hoeffding Adaptive Tree for evolving data streams.
diff --git a/moa/src/main/java/moa/classifiers/trees/HoeffdingOptionTree.java b/moa/src/main/java/moa/classifiers/trees/HoeffdingOptionTree.java
index e4dd74b0a..3ba18b87d 100644
--- a/moa/src/main/java/moa/classifiers/trees/HoeffdingOptionTree.java
+++ b/moa/src/main/java/moa/classifiers/trees/HoeffdingOptionTree.java
@@ -28,11 +28,14 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Set;
+
 import com.github.javacliparser.FileOption;
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.AbstractMOAObject;
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.bayes.NaiveBayes;
@@ -51,7 +54,6 @@
 import moa.core.StringUtils;
 import moa.core.Utils;
 import moa.options.ClassOption;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Hoeffding Option Tree.
@@ -612,8 +614,8 @@ public void disableAttribute(int attIndex) {
 
     protected int maxPredictionPaths;
 
-    public int calcByteSize() {
-        int size = (int) SizeOf.sizeOf(this);
+    public long calcByteSize() {
+        long size = SizeOf.sizeOf(this);
         if (this.treeRoot != null) {
             size += this.treeRoot.calcByteSizeIncludingSubtree();
         }
@@ -621,7 +623,7 @@ public int calcByteSize() {
     }
 
     @Override
-    public int measureByteSize() {
+    public long measureByteSize() {
         return calcByteSize();
     }
 
@@ -1035,7 +1037,7 @@ public void estimateModelByteSizes() {
             this.inactiveLeafByteSizeEstimate = (double) totalInactiveSize
                     / this.inactiveLeafNodeCount;
         }
-        int actualModelSize = this.measureByteSize();
+        long actualModelSize = this.measureByteSize();
         double estimatedModelSize = (this.activeLeafNodeCount
                 * this.activeLeafByteSizeEstimate + this.inactiveLeafNodeCount
                 * this.inactiveLeafByteSizeEstimate);
diff --git a/moa/src/main/java/moa/classifiers/trees/HoeffdingTree.java b/moa/src/main/java/moa/classifiers/trees/HoeffdingTree.java
index c6729b9d8..d8d64f17c 100644
--- a/moa/src/main/java/moa/classifiers/trees/HoeffdingTree.java
+++ b/moa/src/main/java/moa/classifiers/trees/HoeffdingTree.java
@@ -25,10 +25,13 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Set;
+
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.AbstractMOAObject;
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.bayes.NaiveBayes;
@@ -46,7 +49,6 @@
 import moa.core.StringUtils;
 import moa.core.Utils;
 import moa.options.ClassOption;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Hoeffding Tree or VFDT.
@@ -149,7 +151,7 @@ public String getPurposeString() {
             't', "Threshold below which a split will be forced to break ties.",
             0.05, 0.0, 1.0);
 
-public FlagOption binarySplitsOption = new FlagOption("binarySplits", 'b',
+    public FlagOption binarySplitsOption = new FlagOption("binarySplits", 'b',
         "Only allow binary splits.");
 
     public FlagOption stopMemManagementOption = new FlagOption(
@@ -479,8 +481,8 @@ public void disableAttribute(int attIndex) {
 
     protected boolean growthAllowed;
 
-    public int calcByteSize() {
-        int size = (int) SizeOf.sizeOf(this);
+    public long calcByteSize() {
+        long size = SizeOf.sizeOf(this);
         if (this.treeRoot != null) {
             size += this.treeRoot.calcByteSizeIncludingSubtree();
         }
@@ -488,7 +490,7 @@ public int calcByteSize() {
     }
 
     @Override
-    public int measureByteSize() {
+    public long measureByteSize() {
         return calcByteSize();
     }
 
@@ -764,7 +766,7 @@ public void estimateModelByteSizes() {
             this.inactiveLeafByteSizeEstimate = (double) totalInactiveSize
                     / this.inactiveLeafNodeCount;
         }
-        int actualModelSize = this.measureByteSize();
+        long actualModelSize = this.measureByteSize();
         double estimatedModelSize = (this.activeLeafNodeCount
                 * this.activeLeafByteSizeEstimate + this.inactiveLeafNodeCount
                 * this.inactiveLeafByteSizeEstimate);
diff --git a/moa/src/main/java/moa/classifiers/trees/LimAttHoeffdingTree.java b/moa/src/main/java/moa/classifiers/trees/LimAttHoeffdingTree.java
index 05b02df91..6c0b669a6 100644
--- a/moa/src/main/java/moa/classifiers/trees/LimAttHoeffdingTree.java
+++ b/moa/src/main/java/moa/classifiers/trees/LimAttHoeffdingTree.java
@@ -19,10 +19,11 @@
  */
 package moa.classifiers.trees;
 
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.bayes.NaiveBayes;
 import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
 import moa.core.Utils;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Hoeffding decision trees with a restricted number of attributes for data
diff --git a/moa/src/main/java/moa/classifiers/trees/ORTO.java b/moa/src/main/java/moa/classifiers/trees/ORTO.java
index 5c48c0e21..519486b45 100644
--- a/moa/src/main/java/moa/classifiers/trees/ORTO.java
+++ b/moa/src/main/java/moa/classifiers/trees/ORTO.java
@@ -20,22 +20,21 @@
 
 package moa.classifiers.trees;
 
-import java.util.Stack;
 import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Stack;
 
-import com.yahoo.labs.samoa.instances.Instance;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
 
 import moa.classifiers.Regressor;
 import moa.classifiers.core.AttributeSplitSuggestion;
 import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
 import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
-
 import moa.core.AutoExpandVector;
 import moa.core.Measurement;
 import moa.core.StringUtils;
@@ -101,7 +100,7 @@ public static class OptionNode extends InnerNode {
 		public OptionNode(FIMTDD tree) {
 			super(tree);
 		}
-
+		
 		public void resetFF() {
 			optionFFSSL = new double[children.size()];
 			optionFFSeen = new double[children.size()];
diff --git a/moa/src/main/java/moa/classifiers/trees/RandomHoeffdingTree.java b/moa/src/main/java/moa/classifiers/trees/RandomHoeffdingTree.java
index f4b86a209..884c285b3 100644
--- a/moa/src/main/java/moa/classifiers/trees/RandomHoeffdingTree.java
+++ b/moa/src/main/java/moa/classifiers/trees/RandomHoeffdingTree.java
@@ -19,10 +19,11 @@
  */
 package moa.classifiers.trees;
 
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.bayes.NaiveBayes;
 import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
 import moa.core.Utils;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Random decision trees for data streams.
diff --git a/moa/src/main/java/moa/cluster/CFCluster.java b/moa/src/main/java/moa/cluster/CFCluster.java
index 727b0c567..bd6e83b33 100644
--- a/moa/src/main/java/moa/cluster/CFCluster.java
+++ b/moa/src/main/java/moa/cluster/CFCluster.java
@@ -20,6 +20,7 @@
 
 package moa.cluster;
 import java.util.Arrays;
+
 import com.yahoo.labs.samoa.instances.Instance;
 
 /* micro cluster, as defined by Aggarwal et al, On Clustering Massive Data Streams: A Summarization Praradigm 
diff --git a/moa/src/main/java/moa/cluster/Cluster.java b/moa/src/main/java/moa/cluster/Cluster.java
index 42c175c24..caab641ed 100644
--- a/moa/src/main/java/moa/cluster/Cluster.java
+++ b/moa/src/main/java/moa/cluster/Cluster.java
@@ -25,9 +25,11 @@
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Random;
-import moa.AbstractMOAObject;
+
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.AbstractMOAObject;
+
 public abstract class Cluster extends AbstractMOAObject {
 
 	private static final long serialVersionUID = 1L;
diff --git a/moa/src/main/java/moa/cluster/Clustering.java b/moa/src/main/java/moa/cluster/Clustering.java
index 079e1b3ef..afc47799d 100644
--- a/moa/src/main/java/moa/cluster/Clustering.java
+++ b/moa/src/main/java/moa/cluster/Clustering.java
@@ -28,11 +28,13 @@
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
+
+import com.yahoo.labs.samoa.instances.Attribute;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.AbstractMOAObject;
 import moa.core.AutoExpandVector;
 import moa.gui.visualization.DataPoint;
-import com.yahoo.labs.samoa.instances.Attribute;
-import com.yahoo.labs.samoa.instances.Instance;
 
 public class Clustering extends AbstractMOAObject{
 
diff --git a/moa/src/main/java/moa/cluster/SphereCluster.java b/moa/src/main/java/moa/cluster/SphereCluster.java
index 0991500dc..533ba108e 100644
--- a/moa/src/main/java/moa/cluster/SphereCluster.java
+++ b/moa/src/main/java/moa/cluster/SphereCluster.java
@@ -23,6 +23,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Random;
+
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 
diff --git a/moa/src/main/java/moa/clusterers/AbstractClusterer.java b/moa/src/main/java/moa/clusterers/AbstractClusterer.java
index a8f23f48e..3e32c4d50 100644
--- a/moa/src/main/java/moa/clusterers/AbstractClusterer.java
+++ b/moa/src/main/java/moa/clusterers/AbstractClusterer.java
@@ -22,19 +22,19 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Random;
-import moa.cluster.Clustering;
 
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
+
+import moa.cluster.Clustering;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
 import moa.core.StringUtils;
 import moa.gui.AWTRenderer;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public abstract class AbstractClusterer extends AbstractOptionHandler
 		implements Clusterer {
diff --git a/moa/src/main/java/moa/clusterers/ClusterGenerator.java b/moa/src/main/java/moa/clusterers/ClusterGenerator.java
index 2c1a5cd63..4ad2e09f8 100644
--- a/moa/src/main/java/moa/clusterers/ClusterGenerator.java
+++ b/moa/src/main/java/moa/clusterers/ClusterGenerator.java
@@ -23,13 +23,15 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Random;
+
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.Clustering;
 import moa.cluster.SphereCluster;
 import moa.core.Measurement;
 import moa.gui.visualization.DataPoint;
-import com.yahoo.labs.samoa.instances.Instance;
 
 public class ClusterGenerator extends AbstractClusterer{
 
diff --git a/moa/src/main/java/moa/clusterers/Clusterer.java b/moa/src/main/java/moa/clusterers/Clusterer.java
index b018b421f..b7badff51 100644
--- a/moa/src/main/java/moa/clusterers/Clusterer.java
+++ b/moa/src/main/java/moa/clusterers/Clusterer.java
@@ -19,13 +19,14 @@
  */
 package moa.clusterers;
 
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.MOAObject;
 import moa.cluster.Clustering;
 import moa.core.Measurement;
 import moa.gui.AWTRenderable;
 import moa.options.OptionHandler;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public interface Clusterer extends MOAObject, OptionHandler, AWTRenderable {
 
diff --git a/moa/src/main/java/moa/clusterers/CobWeb.java b/moa/src/main/java/moa/clusterers/CobWeb.java
index 03e34a5f9..6f315ba9e 100644
--- a/moa/src/main/java/moa/clusterers/CobWeb.java
+++ b/moa/src/main/java/moa/clusterers/CobWeb.java
@@ -21,16 +21,16 @@
 
 import java.io.Serializable;
 
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import moa.cluster.Clustering;
 import moa.cluster.SphereCluster;
+import moa.core.FastVector;
 import moa.core.Measurement;
 import moa.core.StringUtils;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import moa.core.FastVector;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import weka.core.AttributeStats;
 import weka.experiment.Stats;
 import weka.filters.unsupervised.attribute.Add;
diff --git a/moa/src/main/java/moa/clusterers/KMeans.java b/moa/src/main/java/moa/clusterers/KMeans.java
index b7014b5f7..d509f26a7 100644
--- a/moa/src/main/java/moa/clusterers/KMeans.java
+++ b/moa/src/main/java/moa/clusterers/KMeans.java
@@ -22,6 +22,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+
 import moa.cluster.CFCluster;
 import moa.cluster.Cluster;
 import moa.cluster.Clustering;
diff --git a/moa/src/main/java/moa/clusterers/WekaClusteringAlgorithm.java b/moa/src/main/java/moa/clusterers/WekaClusteringAlgorithm.java
index 978290119..ef5ddaeda 100644
--- a/moa/src/main/java/moa/clusterers/WekaClusteringAlgorithm.java
+++ b/moa/src/main/java/moa/clusterers/WekaClusteringAlgorithm.java
@@ -21,21 +21,22 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import moa.cluster.Clustering;
-import moa.core.AutoClassDiscovery;
-import moa.core.AutoExpandVector;
-import moa.core.Measurement;
-import moa.options.ClassOption;
+
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.MultiChoiceOption;
 import com.github.javacliparser.StringOption;
-import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
 
+import moa.cluster.Clustering;
+import moa.core.AutoClassDiscovery;
+import moa.core.AutoExpandVector;
+import moa.core.FastVector;
+import moa.core.Measurement;
+import moa.options.ClassOption;
 import weka.core.Utils;
 
 public class WekaClusteringAlgorithm extends AbstractClusterer {
diff --git a/moa/src/main/java/moa/clusterers/clustream/Clustream.java b/moa/src/main/java/moa/clusterers/clustream/Clustream.java
index 85edb1c81..b10a2e029 100644
--- a/moa/src/main/java/moa/clusterers/clustream/Clustream.java
+++ b/moa/src/main/java/moa/clusterers/clustream/Clustream.java
@@ -24,14 +24,16 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Random;
+
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.Cluster;
 import moa.cluster.Clustering;
 import moa.cluster.SphereCluster;
 import moa.clusterers.AbstractClusterer;
 import moa.core.Measurement;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.DenseInstance;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /** Citation: CluStream: Charu C. Aggarwal, Jiawei Han, Jianyong Wang, Philip S. Yu:
  * A Framework for Clustering Evolving Data Streams. VLDB 2003: 81-92
diff --git a/moa/src/main/java/moa/clusterers/clustream/ClustreamKernel.java b/moa/src/main/java/moa/clusterers/clustream/ClustreamKernel.java
index 83ae0324d..73ef8a6a7 100644
--- a/moa/src/main/java/moa/clusterers/clustream/ClustreamKernel.java
+++ b/moa/src/main/java/moa/clusterers/clustream/ClustreamKernel.java
@@ -20,10 +20,11 @@
 package moa.clusterers.clustream;
 
 import java.util.ArrayList;
-import java.util.Random;
-import moa.cluster.CFCluster;
+
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.cluster.CFCluster;
+
 public class ClustreamKernel extends CFCluster {
 	private static final long serialVersionUID = 1L;
 
diff --git a/moa/src/main/java/moa/clusterers/clustream/WithKmeans.java b/moa/src/main/java/moa/clusterers/clustream/WithKmeans.java
index 281c02813..175e1137e 100644
--- a/moa/src/main/java/moa/clusterers/clustream/WithKmeans.java
+++ b/moa/src/main/java/moa/clusterers/clustream/WithKmeans.java
@@ -32,15 +32,16 @@
 import java.util.List;
 import java.util.Random;
 
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.CFCluster;
 import moa.cluster.Cluster;
 import moa.cluster.Clustering;
 import moa.cluster.SphereCluster;
 import moa.clusterers.AbstractClusterer;
 import moa.core.Measurement;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.DenseInstance;
-import com.yahoo.labs.samoa.instances.Instance;
 
 public class WithKmeans extends AbstractClusterer {
 	
diff --git a/moa/src/main/java/moa/clusterers/clustree/ClusKernel.java b/moa/src/main/java/moa/clusterers/clustree/ClusKernel.java
index 025f86f92..fdddc6f31 100644
--- a/moa/src/main/java/moa/clusterers/clustree/ClusKernel.java
+++ b/moa/src/main/java/moa/clusterers/clustree/ClusKernel.java
@@ -20,11 +20,12 @@
 
 package moa.clusterers.clustree;
 
-import moa.clusterers.clustree.util.*;
 import java.util.Arrays;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.CFCluster;
 import moa.cluster.Cluster;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Representation of an Entry in the tree
diff --git a/moa/src/main/java/moa/clusterers/clustree/ClusTree.java b/moa/src/main/java/moa/clusterers/clustree/ClusTree.java
index d6200debc..4c5f3fe14 100644
--- a/moa/src/main/java/moa/clusterers/clustree/ClusTree.java
+++ b/moa/src/main/java/moa/clusterers/clustree/ClusTree.java
@@ -21,14 +21,16 @@
 package moa.clusterers.clustree;
 
 import java.util.ArrayList;
-
 import java.util.LinkedList;
-import moa.clusterers.clustree.util.*;
+
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.Clustering;
 import moa.clusterers.AbstractClusterer;
+import moa.clusterers.clustree.util.Budget;
+import moa.clusterers.clustree.util.SimpleBudget;
 import moa.core.Measurement;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Citation: ClusTree: Philipp Kranen, Ira Assent, Corinna Baldauf, Thomas Seidl:
diff --git a/moa/src/main/java/moa/clusterers/denstream/MicroCluster.java b/moa/src/main/java/moa/clusterers/denstream/MicroCluster.java
index 4b98a5606..cf6c25dba 100644
--- a/moa/src/main/java/moa/clusterers/denstream/MicroCluster.java
+++ b/moa/src/main/java/moa/clusterers/denstream/MicroCluster.java
@@ -19,9 +19,10 @@
  */
 package moa.clusterers.denstream;
 
-import moa.cluster.CFCluster;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.cluster.CFCluster;
+
 public class MicroCluster extends CFCluster {
 
     private long lastEditT = -1;
diff --git a/moa/src/main/java/moa/clusterers/denstream/WithDBSCAN.java b/moa/src/main/java/moa/clusterers/denstream/WithDBSCAN.java
index fbc55d462..f243d664a 100644
--- a/moa/src/main/java/moa/clusterers/denstream/WithDBSCAN.java
+++ b/moa/src/main/java/moa/clusterers/denstream/WithDBSCAN.java
@@ -26,15 +26,16 @@
 
 import java.util.ArrayList;
 
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.Cluster;
 import moa.cluster.Clustering;
 import moa.clusterers.AbstractClusterer;
 import moa.clusterers.macro.dbscan.DBScan;
 import moa.core.Measurement;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.DenseInstance;
-import com.yahoo.labs.samoa.instances.Instance;
 
 public class WithDBSCAN extends AbstractClusterer {
 	
diff --git a/moa/src/main/java/moa/clusterers/macro/NonConvexCluster.java b/moa/src/main/java/moa/clusterers/macro/NonConvexCluster.java
index d264f8564..e132b69d2 100644
--- a/moa/src/main/java/moa/clusterers/macro/NonConvexCluster.java
+++ b/moa/src/main/java/moa/clusterers/macro/NonConvexCluster.java
@@ -26,9 +26,10 @@
 import java.util.List;
 import java.util.Vector;
 
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.CFCluster;
 import moa.cluster.Clustering;
-import com.yahoo.labs.samoa.instances.Instance;
 
 public class NonConvexCluster extends CFCluster implements IDenseMacroCluster {
 
diff --git a/moa/src/main/java/moa/clusterers/outliers/AbstractC/AbstractC.java b/moa/src/main/java/moa/clusterers/outliers/AbstractC/AbstractC.java
index 4b67c3e78..9ac25bf0a 100644
--- a/moa/src/main/java/moa/clusterers/outliers/AbstractC/AbstractC.java
+++ b/moa/src/main/java/moa/clusterers/outliers/AbstractC/AbstractC.java
@@ -21,13 +21,15 @@
 package moa.clusterers.outliers.AbstractC;
 
 import java.util.Vector;
-import moa.clusterers.outliers.AbstractC.ISBIndex.ISBNode;
-import moa.clusterers.outliers.AbstractC.ISBIndex.ISBSearchResult;
+
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.clusterers.outliers.AbstractC.ISBIndex.ISBNode;
+import moa.clusterers.outliers.AbstractC.ISBIndex.ISBSearchResult;
+
 //The algorithm is presented in:
 //D. Yang, E. Rundensteiner, and M. Ward.
 //Neighbor-based pattern detection for windows over streaming data. 
diff --git a/moa/src/main/java/moa/clusterers/outliers/AbstractC/AbstractCBase.java b/moa/src/main/java/moa/clusterers/outliers/AbstractC/AbstractCBase.java
index 6e39b8360..67150fa8b 100644
--- a/moa/src/main/java/moa/clusterers/outliers/AbstractC/AbstractCBase.java
+++ b/moa/src/main/java/moa/clusterers/outliers/AbstractC/AbstractCBase.java
@@ -23,8 +23,9 @@
 
 import java.util.ArrayList;
 import java.util.Vector;
-import moa.clusterers.outliers.AbstractC.ISBIndex.ISBNode;
+
 import moa.clusterers.outliers.MyBaseOutlierDetector;
+import moa.clusterers.outliers.AbstractC.ISBIndex.ISBNode;
 
 public abstract class AbstractCBase extends MyBaseOutlierDetector {    
     protected static final Long FIRST_OBJ_ID = 1L;
diff --git a/moa/src/main/java/moa/clusterers/outliers/AbstractC/ISBIndex.java b/moa/src/main/java/moa/clusterers/outliers/AbstractC/ISBIndex.java
index 9a0be6f04..26c4292ad 100644
--- a/moa/src/main/java/moa/clusterers/outliers/AbstractC/ISBIndex.java
+++ b/moa/src/main/java/moa/clusterers/outliers/AbstractC/ISBIndex.java
@@ -28,6 +28,7 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.Vector;
+
 import com.yahoo.labs.samoa.instances.Instance;
 
 
diff --git a/moa/src/main/java/moa/clusterers/outliers/AbstractC/MyMTree.java b/moa/src/main/java/moa/clusterers/outliers/AbstractC/MyMTree.java
index af419a92f..5a2f5d531 100644
--- a/moa/src/main/java/moa/clusterers/outliers/AbstractC/MyMTree.java
+++ b/moa/src/main/java/moa/clusterers/outliers/AbstractC/MyMTree.java
@@ -22,6 +22,7 @@
 package moa.clusterers.outliers.AbstractC;
 
 import java.util.Set;
+
 import moa.clusterers.outliers.utils.mtree.ComposedSplitFunction;
 import moa.clusterers.outliers.utils.mtree.DistanceFunction;
 import moa.clusterers.outliers.utils.mtree.DistanceFunctions;
diff --git a/moa/src/main/java/moa/clusterers/outliers/AbstractC/Test.java b/moa/src/main/java/moa/clusterers/outliers/AbstractC/Test.java
index 430a2c82f..46cc09f59 100644
--- a/moa/src/main/java/moa/clusterers/outliers/AbstractC/Test.java
+++ b/moa/src/main/java/moa/clusterers/outliers/AbstractC/Test.java
@@ -21,9 +21,10 @@
 
 package moa.clusterers.outliers.AbstractC;
 
-import moa.streams.clustering.RandomRBFGeneratorEvents;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.streams.clustering.RandomRBFGeneratorEvents;
+
 public class Test {    
     public static void main(String[] args) throws Exception 
     {
diff --git a/moa/src/main/java/moa/clusterers/outliers/Angiulli/ApproxSTORM.java b/moa/src/main/java/moa/clusterers/outliers/Angiulli/ApproxSTORM.java
index 4eb279806..7b965ee9c 100644
--- a/moa/src/main/java/moa/clusterers/outliers/Angiulli/ApproxSTORM.java
+++ b/moa/src/main/java/moa/clusterers/outliers/Angiulli/ApproxSTORM.java
@@ -26,12 +26,14 @@
 import java.util.Random;
 import java.util.Set;
 import java.util.Vector;
-import moa.clusterers.outliers.Angiulli.ISBIndex.ISBNode;
-import moa.clusterers.outliers.Angiulli.ISBIndex.ISBSearchResult;
+
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.clusterers.outliers.Angiulli.ISBIndex.ISBNode;
+import moa.clusterers.outliers.Angiulli.ISBIndex.ISBSearchResult;
+
 
 public class ApproxSTORM extends STORMBase {
     public class ISBNodeAppr extends ISBNode {
diff --git a/moa/src/main/java/moa/clusterers/outliers/Angiulli/ExactSTORM.java b/moa/src/main/java/moa/clusterers/outliers/Angiulli/ExactSTORM.java
index 7bcd76f2f..652632ae1 100644
--- a/moa/src/main/java/moa/clusterers/outliers/Angiulli/ExactSTORM.java
+++ b/moa/src/main/java/moa/clusterers/outliers/Angiulli/ExactSTORM.java
@@ -24,12 +24,14 @@
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.Vector;
-import moa.clusterers.outliers.Angiulli.ISBIndex.ISBNode;
-import moa.clusterers.outliers.Angiulli.ISBIndex.ISBSearchResult;
+
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.clusterers.outliers.Angiulli.ISBIndex.ISBNode;
+import moa.clusterers.outliers.Angiulli.ISBIndex.ISBSearchResult;
+
 
 // The algorithm is presented in "Distance-based outlier queries in data streams: the novel task and algorithms.
 //Data Mining and Knowledge Discovery, 20(2):290–324,2010.
diff --git a/moa/src/main/java/moa/clusterers/outliers/Angiulli/ISBIndex.java b/moa/src/main/java/moa/clusterers/outliers/Angiulli/ISBIndex.java
index c92781052..47bb87b5c 100644
--- a/moa/src/main/java/moa/clusterers/outliers/Angiulli/ISBIndex.java
+++ b/moa/src/main/java/moa/clusterers/outliers/Angiulli/ISBIndex.java
@@ -25,6 +25,7 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.Vector;
+
 import com.yahoo.labs.samoa.instances.Instance;
 
 
diff --git a/moa/src/main/java/moa/clusterers/outliers/Angiulli/MyMTree.java b/moa/src/main/java/moa/clusterers/outliers/Angiulli/MyMTree.java
index e71e17623..96ba2625c 100644
--- a/moa/src/main/java/moa/clusterers/outliers/Angiulli/MyMTree.java
+++ b/moa/src/main/java/moa/clusterers/outliers/Angiulli/MyMTree.java
@@ -21,6 +21,7 @@
 package moa.clusterers.outliers.Angiulli;
 
 import java.util.Set;
+
 import moa.clusterers.outliers.utils.mtree.ComposedSplitFunction;
 import moa.clusterers.outliers.utils.mtree.DistanceFunction;
 import moa.clusterers.outliers.utils.mtree.DistanceFunctions;
diff --git a/moa/src/main/java/moa/clusterers/outliers/Angiulli/STORMBase.java b/moa/src/main/java/moa/clusterers/outliers/Angiulli/STORMBase.java
index 7cc8b4f80..d1e2cbf28 100644
--- a/moa/src/main/java/moa/clusterers/outliers/Angiulli/STORMBase.java
+++ b/moa/src/main/java/moa/clusterers/outliers/Angiulli/STORMBase.java
@@ -21,10 +21,12 @@
 package moa.clusterers.outliers.Angiulli;
 
 import java.util.Vector;
-import moa.clusterers.outliers.Angiulli.ISBIndex.ISBNode;
-import moa.clusterers.outliers.MyBaseOutlierDetector;
+
 import com.github.javacliparser.FlagOption;
 
+import moa.clusterers.outliers.MyBaseOutlierDetector;
+import moa.clusterers.outliers.Angiulli.ISBIndex.ISBNode;
+
 public abstract class STORMBase extends MyBaseOutlierDetector {   
     public FlagOption waitWinFullOption = new FlagOption("waitWinFull", 'a', "Output outliers when windows is full.");
      
diff --git a/moa/src/main/java/moa/clusterers/outliers/Angiulli/Test.java b/moa/src/main/java/moa/clusterers/outliers/Angiulli/Test.java
index 4921d99f7..dc6de05d5 100644
--- a/moa/src/main/java/moa/clusterers/outliers/Angiulli/Test.java
+++ b/moa/src/main/java/moa/clusterers/outliers/Angiulli/Test.java
@@ -20,9 +20,10 @@
 
 package moa.clusterers.outliers.Angiulli;
 
-import moa.streams.clustering.RandomRBFGeneratorEvents;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.streams.clustering.RandomRBFGeneratorEvents;
+
 
 public class Test {    
     public static void main(String[] args) throws Exception 
diff --git a/moa/src/main/java/moa/clusterers/outliers/AnyOut/AnyOut.java b/moa/src/main/java/moa/clusterers/outliers/AnyOut/AnyOut.java
index 6086e6964..16e4a0f45 100644
--- a/moa/src/main/java/moa/clusterers/outliers/AnyOut/AnyOut.java
+++ b/moa/src/main/java/moa/clusterers/outliers/AnyOut/AnyOut.java
@@ -21,9 +21,11 @@
 
 package moa.clusterers.outliers.AnyOut;
 
+import java.util.ArrayList;
+
 import com.github.javacliparser.Options;
 import com.yahoo.labs.samoa.instances.Instance;
-import java.util.ArrayList;
+
 import moa.clusterers.outliers.MyBaseOutlierDetector;
 import moa.clusterers.outliers.AnyOut.util.DataObject;
 import moa.clusterers.outliers.AnyOut.util.DataSet;
diff --git a/moa/src/main/java/moa/clusterers/outliers/AnyOut/AnyOutCore.java b/moa/src/main/java/moa/clusterers/outliers/AnyOut/AnyOutCore.java
index a714f2d10..a56728cc8 100644
--- a/moa/src/main/java/moa/clusterers/outliers/AnyOut/AnyOutCore.java
+++ b/moa/src/main/java/moa/clusterers/outliers/AnyOut/AnyOutCore.java
@@ -21,12 +21,14 @@
 
 package moa.clusterers.outliers.AnyOut;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.DenseInstance;
-import java.util.ArrayList;
-import java.util.HashMap;
+
 import moa.clusterers.clustree.ClusKernel;
 import moa.clusterers.clustree.ClusTree;
 import moa.clusterers.clustree.Entry;
diff --git a/moa/src/main/java/moa/clusterers/outliers/MCOD/ISBIndex.java b/moa/src/main/java/moa/clusterers/outliers/MCOD/ISBIndex.java
index d151e92dd..047c964ff 100644
--- a/moa/src/main/java/moa/clusterers/outliers/MCOD/ISBIndex.java
+++ b/moa/src/main/java/moa/clusterers/outliers/MCOD/ISBIndex.java
@@ -30,6 +30,7 @@
 import java.util.Set;
 import java.util.TreeSet;
 import java.util.Vector;
+
 import com.yahoo.labs.samoa.instances.Instance;
 
 
diff --git a/moa/src/main/java/moa/clusterers/outliers/MCOD/MCOD.java b/moa/src/main/java/moa/clusterers/outliers/MCOD/MCOD.java
index 60ed3df4d..0d58e7b02 100644
--- a/moa/src/main/java/moa/clusterers/outliers/MCOD/MCOD.java
+++ b/moa/src/main/java/moa/clusterers/outliers/MCOD/MCOD.java
@@ -23,13 +23,15 @@
 import java.util.ArrayList;
 import java.util.TreeSet;
 import java.util.Vector;
-import moa.clusterers.outliers.MCOD.ISBIndex.ISBNode;
-import moa.clusterers.outliers.MCOD.ISBIndex.ISBNode.NodeType;
-import moa.clusterers.outliers.MCOD.ISBIndex.ISBSearchResult;
+
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.clusterers.outliers.MCOD.ISBIndex.ISBNode;
+import moa.clusterers.outliers.MCOD.ISBIndex.ISBNode.NodeType;
+import moa.clusterers.outliers.MCOD.ISBIndex.ISBSearchResult;
+
 
 //The algorithm is described in 
 // M. Kontaki, A. Gounaris, A. N. Papadopoulos, K. Tsichlas, and Y. Manolopoulos. 
diff --git a/moa/src/main/java/moa/clusterers/outliers/MCOD/MCODBase.java b/moa/src/main/java/moa/clusterers/outliers/MCOD/MCODBase.java
index 66548a726..94f7ba167 100644
--- a/moa/src/main/java/moa/clusterers/outliers/MCOD/MCODBase.java
+++ b/moa/src/main/java/moa/clusterers/outliers/MCOD/MCODBase.java
@@ -25,9 +25,10 @@
 import java.util.Set;
 import java.util.TreeSet;
 import java.util.Vector;
+
+import moa.clusterers.outliers.MyBaseOutlierDetector;
 import moa.clusterers.outliers.MCOD.ISBIndex.ISBNode;
 import moa.clusterers.outliers.MCOD.ISBIndex.ISBNode.NodeType;
-import moa.clusterers.outliers.MyBaseOutlierDetector;
 
 public abstract class MCODBase extends MyBaseOutlierDetector {    
     protected static class EventItem implements Comparable<EventItem> {
diff --git a/moa/src/main/java/moa/clusterers/outliers/MCOD/MTreeMicroClusters.java b/moa/src/main/java/moa/clusterers/outliers/MCOD/MTreeMicroClusters.java
index 575b42b63..42be983f2 100644
--- a/moa/src/main/java/moa/clusterers/outliers/MCOD/MTreeMicroClusters.java
+++ b/moa/src/main/java/moa/clusterers/outliers/MCOD/MTreeMicroClusters.java
@@ -21,6 +21,7 @@
 package moa.clusterers.outliers.MCOD;
 
 import java.util.Set;
+
 import moa.clusterers.outliers.utils.mtree.ComposedSplitFunction;
 import moa.clusterers.outliers.utils.mtree.DistanceFunction;
 import moa.clusterers.outliers.utils.mtree.DistanceFunctions;
diff --git a/moa/src/main/java/moa/clusterers/outliers/MCOD/MTreeStreamObjects.java b/moa/src/main/java/moa/clusterers/outliers/MCOD/MTreeStreamObjects.java
index 77679064b..20f44c653 100644
--- a/moa/src/main/java/moa/clusterers/outliers/MCOD/MTreeStreamObjects.java
+++ b/moa/src/main/java/moa/clusterers/outliers/MCOD/MTreeStreamObjects.java
@@ -21,6 +21,7 @@
 package moa.clusterers.outliers.MCOD;
 
 import java.util.Set;
+
 import moa.clusterers.outliers.utils.mtree.ComposedSplitFunction;
 import moa.clusterers.outliers.utils.mtree.DistanceFunction;
 import moa.clusterers.outliers.utils.mtree.DistanceFunctions;
diff --git a/moa/src/main/java/moa/clusterers/outliers/MCOD/MicroCluster.java b/moa/src/main/java/moa/clusterers/outliers/MCOD/MicroCluster.java
index 8b8fd6a1d..40741a868 100644
--- a/moa/src/main/java/moa/clusterers/outliers/MCOD/MicroCluster.java
+++ b/moa/src/main/java/moa/clusterers/outliers/MCOD/MicroCluster.java
@@ -21,6 +21,7 @@
 package moa.clusterers.outliers.MCOD;
 
 import java.util.ArrayList;
+
 import moa.clusterers.outliers.MCOD.ISBIndex.ISBNode;
 import moa.clusterers.outliers.utils.mtree.DistanceFunctions.EuclideanCoordinate;
 
diff --git a/moa/src/main/java/moa/clusterers/outliers/MCOD/Test.java b/moa/src/main/java/moa/clusterers/outliers/MCOD/Test.java
index d22e61aaf..5b8474cab 100644
--- a/moa/src/main/java/moa/clusterers/outliers/MCOD/Test.java
+++ b/moa/src/main/java/moa/clusterers/outliers/MCOD/Test.java
@@ -20,9 +20,10 @@
 
 package moa.clusterers.outliers.MCOD;
 
-import moa.streams.clustering.RandomRBFGeneratorEvents;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.streams.clustering.RandomRBFGeneratorEvents;
+
 
 public class Test {    
     public static void main(String[] args) throws Exception 
diff --git a/moa/src/main/java/moa/clusterers/outliers/MyBaseOutlierDetector.java b/moa/src/main/java/moa/clusterers/outliers/MyBaseOutlierDetector.java
index a9be5efb7..1ffe3e98a 100644
--- a/moa/src/main/java/moa/clusterers/outliers/MyBaseOutlierDetector.java
+++ b/moa/src/main/java/moa/clusterers/outliers/MyBaseOutlierDetector.java
@@ -27,13 +27,15 @@
 import java.util.Set;
 import java.util.TreeSet;
 import java.util.Vector;
+
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.Cluster;
 import moa.cluster.Clustering;
 import moa.cluster.SphereCluster;
 import moa.clusterers.AbstractClusterer;
 import moa.core.Measurement;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
 
 public abstract class MyBaseOutlierDetector extends AbstractClusterer { 
     public static class Outlier implements Comparable<Outlier> {
diff --git a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/ISBIndex.java b/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/ISBIndex.java
index e088c2edb..4a12a6459 100644
--- a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/ISBIndex.java
+++ b/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/ISBIndex.java
@@ -30,6 +30,7 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.Vector;
+
 import com.yahoo.labs.samoa.instances.Instance;
 
 public class ISBIndex {    
diff --git a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/MyMTree.java b/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/MyMTree.java
index 9cfa7e925..722ee5687 100644
--- a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/MyMTree.java
+++ b/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/MyMTree.java
@@ -21,6 +21,7 @@
 package moa.clusterers.outliers.SimpleCOD;
 
 import java.util.Set;
+
 import moa.clusterers.outliers.utils.mtree.ComposedSplitFunction;
 import moa.clusterers.outliers.utils.mtree.DistanceFunction;
 import moa.clusterers.outliers.utils.mtree.DistanceFunctions;
diff --git a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/SimpleCOD.java b/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/SimpleCOD.java
index c7ed23161..2e8a1fb80 100644
--- a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/SimpleCOD.java
+++ b/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/SimpleCOD.java
@@ -21,12 +21,14 @@
 package moa.clusterers.outliers.SimpleCOD;
 
 import java.util.Vector;
-import moa.clusterers.outliers.SimpleCOD.ISBIndex.ISBNode;
-import moa.clusterers.outliers.SimpleCOD.ISBIndex.ISBSearchResult;
+
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.clusterers.outliers.SimpleCOD.ISBIndex.ISBNode;
+import moa.clusterers.outliers.SimpleCOD.ISBIndex.ISBSearchResult;
+
 
 ////The algorithm is described in 
 // M. Kontaki, A. Gounaris, A. N. Papadopoulos, K. Tsichlas, and Y. Manolopoulos. 
diff --git a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/SimpleCODBase.java b/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/SimpleCODBase.java
index b94e0992f..cd8ac90d3 100644
--- a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/SimpleCODBase.java
+++ b/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/SimpleCODBase.java
@@ -24,6 +24,7 @@
 import java.util.Set;
 import java.util.TreeSet;
 import java.util.Vector;
+
 import moa.clusterers.outliers.MyBaseOutlierDetector;
 import moa.clusterers.outliers.SimpleCOD.ISBIndex.ISBNode;
 
diff --git a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/Test.java b/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/Test.java
index 8039566ff..a8ed48e79 100644
--- a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/Test.java
+++ b/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/Test.java
@@ -20,9 +20,10 @@
 
 package moa.clusterers.outliers.SimpleCOD;
 
-import moa.streams.ArffFileStream;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.streams.ArffFileStream;
+
 
 public class Test {    
     public static void main(String[] args) throws Exception 
diff --git a/moa/src/main/java/moa/clusterers/outliers/TestSpeed.java b/moa/src/main/java/moa/clusterers/outliers/TestSpeed.java
index 019b74f91..31e903388 100644
--- a/moa/src/main/java/moa/clusterers/outliers/TestSpeed.java
+++ b/moa/src/main/java/moa/clusterers/outliers/TestSpeed.java
@@ -20,12 +20,13 @@
 
 package moa.clusterers.outliers;
 
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.clusterers.outliers.AbstractC.AbstractC;
 import moa.clusterers.outliers.Angiulli.ExactSTORM;
 import moa.clusterers.outliers.MCOD.MCOD;
 import moa.clusterers.outliers.SimpleCOD.SimpleCOD;
 import moa.streams.clustering.RandomRBFGeneratorEvents;
-import com.yahoo.labs.samoa.instances.Instance;
 
 public class TestSpeed {    
     public static void main(String[] args) throws Exception 
diff --git a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/MTree.java b/moa/src/main/java/moa/clusterers/outliers/utils/mtree/MTree.java
index 9c135a799..e2c8db618 100644
--- a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/MTree.java
+++ b/moa/src/main/java/moa/clusterers/outliers/utils/mtree/MTree.java
@@ -24,6 +24,7 @@
 import java.util.NoSuchElementException;
 import java.util.PriorityQueue;
 import java.util.Set;
+
 import moa.clusterers.outliers.utils.mtree.SplitFunction.SplitResult;
 
 
diff --git a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/PromotionFunctions.java b/moa/src/main/java/moa/clusterers/outliers/utils/mtree/PromotionFunctions.java
index d7aa38ba4..b603935b4 100644
--- a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/PromotionFunctions.java
+++ b/moa/src/main/java/moa/clusterers/outliers/utils/mtree/PromotionFunctions.java
@@ -18,6 +18,7 @@
 
 import java.util.List;
 import java.util.Set;
+
 import moa.clusterers.outliers.utils.mtree.utils.Pair;
 import moa.clusterers.outliers.utils.mtree.utils.Utils;
 
diff --git a/moa/src/main/java/moa/clusterers/streamkm/Point.java b/moa/src/main/java/moa/clusterers/streamkm/Point.java
index 28fa9d232..b272a41d6 100644
--- a/moa/src/main/java/moa/clusterers/streamkm/Point.java
+++ b/moa/src/main/java/moa/clusterers/streamkm/Point.java
@@ -1,10 +1,10 @@
 package moa.clusterers.streamkm;
 
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.Cluster;
 import moa.cluster.SphereCluster;
 
-import com.yahoo.labs.samoa.instances.Instance;
-
 /**
  *
  * @author Marcel R. Ackermann, Christiane Lammersen, Marcus Maertens, Christoph Raupach, 
diff --git a/moa/src/main/java/moa/clusterers/streamkm/StreamKM.java b/moa/src/main/java/moa/clusterers/streamkm/StreamKM.java
index ac66163eb..599db86f8 100644
--- a/moa/src/main/java/moa/clusterers/streamkm/StreamKM.java
+++ b/moa/src/main/java/moa/clusterers/streamkm/StreamKM.java
@@ -1,10 +1,11 @@
 package moa.clusterers.streamkm;
 
 import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.Clustering;
 import moa.clusterers.AbstractClusterer;
 import moa.core.Measurement;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  *
diff --git a/moa/src/main/java/moa/core/AutoClassDiscovery.java b/moa/src/main/java/moa/core/AutoClassDiscovery.java
index 9b085e5ca..d8e456893 100644
--- a/moa/src/main/java/moa/core/AutoClassDiscovery.java
+++ b/moa/src/main/java/moa/core/AutoClassDiscovery.java
@@ -21,9 +21,9 @@
 
 import java.io.File;
 import java.io.IOException;
+import java.net.URISyntaxException;
 import java.net.URL;
 import java.net.URLClassLoader;
-import java.net.URISyntaxException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Enumeration;
diff --git a/moa/src/main/java/moa/core/AutoExpandVector.java b/moa/src/main/java/moa/core/AutoExpandVector.java
index 33c3ed53e..938f70a78 100644
--- a/moa/src/main/java/moa/core/AutoExpandVector.java
+++ b/moa/src/main/java/moa/core/AutoExpandVector.java
@@ -121,7 +121,7 @@ public MOAObject copy() {
     }
 
     @Override
-    public int measureByteSize() {
+    public long measureByteSize() {
         return AbstractMOAObject.measureByteSize(this);
     }
 
diff --git a/moa/src/main/java/moa/core/MultilabelInstancesHeader.java b/moa/src/main/java/moa/core/MultilabelInstancesHeader.java
index b8dc3b3c2..7ae45510a 100644
--- a/moa/src/main/java/moa/core/MultilabelInstancesHeader.java
+++ b/moa/src/main/java/moa/core/MultilabelInstancesHeader.java
@@ -19,7 +19,6 @@
  */
 package moa.core;
 
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
diff --git a/moa/src/main/java/moa/core/Utils.java b/moa/src/main/java/moa/core/Utils.java
index ecb4cf19d..d3ec5a4e2 100644
--- a/moa/src/main/java/moa/core/Utils.java
+++ b/moa/src/main/java/moa/core/Utils.java
@@ -21,17 +21,9 @@
 
 package moa.core;
 
-import java.io.BufferedReader;
-import java.io.BufferedWriter;
 import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileReader;
-import java.io.FileWriter;
 import java.lang.reflect.Array;
-import java.net.URL;
 import java.text.BreakIterator;
-import java.util.Enumeration;
-import java.util.Properties;
 import java.util.Random;
 import java.util.Vector;
 
diff --git a/moa/src/main/java/moa/core/utils/Converter.java b/moa/src/main/java/moa/core/utils/Converter.java
index a3f976c38..5a06a8490 100755
--- a/moa/src/main/java/moa/core/utils/Converter.java
+++ b/moa/src/main/java/moa/core/utils/Converter.java
@@ -21,10 +21,12 @@
 
 import java.util.LinkedList;
 import java.util.List;
-import moa.AbstractMOAObject;
+
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.AbstractMOAObject;
+
 /**
  * Converter. This class can be used to convert a multi-label instance into a
  * single-label instance.
diff --git a/moa/src/main/java/moa/evaluation/Accuracy.java b/moa/src/main/java/moa/evaluation/Accuracy.java
index d8925799d..049ef9913 100644
--- a/moa/src/main/java/moa/evaluation/Accuracy.java
+++ b/moa/src/main/java/moa/evaluation/Accuracy.java
@@ -20,6 +20,7 @@
 package moa.evaluation;
 
 import java.util.ArrayList;
+
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
 
diff --git a/moa/src/main/java/moa/evaluation/AdwinClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/AdwinClassificationPerformanceEvaluator.java
index a0c79202c..aea7cf19e 100644
--- a/moa/src/main/java/moa/evaluation/AdwinClassificationPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/AdwinClassificationPerformanceEvaluator.java
@@ -19,7 +19,6 @@
  */
 package moa.evaluation;
 
-import com.github.javacliparser.IntOption;
 import moa.classifiers.core.driftdetection.ADWIN;
 
 /**
diff --git a/moa/src/main/java/moa/evaluation/BasicClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/BasicClassificationPerformanceEvaluator.java
index f2bba1612..eeb29f978 100644
--- a/moa/src/main/java/moa/evaluation/BasicClassificationPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/BasicClassificationPerformanceEvaluator.java
@@ -20,20 +20,18 @@
  */
 package moa.evaluation;
 
-import moa.AbstractMOAObject;
+import java.io.Serializable;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.Prediction;
+
 import moa.core.Example;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
 import moa.core.Utils;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.Prediction;
 import moa.options.AbstractOptionHandler;
 import moa.tasks.TaskMonitor;
 
-import java.io.Serializable;
-
 /**
  * Classification evaluator that performs basic incremental evaluation.
  *
diff --git a/moa/src/main/java/moa/evaluation/BasicConceptDriftPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/BasicConceptDriftPerformanceEvaluator.java
index d5df7cf06..40057d4cc 100644
--- a/moa/src/main/java/moa/evaluation/BasicConceptDriftPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/BasicConceptDriftPerformanceEvaluator.java
@@ -20,7 +20,6 @@
 package moa.evaluation;
 
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 import moa.AbstractMOAObject;
diff --git a/moa/src/main/java/moa/evaluation/BasicMultiLabelPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/BasicMultiLabelPerformanceEvaluator.java
index 33e6b18d1..d18061094 100644
--- a/moa/src/main/java/moa/evaluation/BasicMultiLabelPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/BasicMultiLabelPerformanceEvaluator.java
@@ -19,14 +19,14 @@
  */
 package moa.evaluation;
 
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.AbstractMOAObject;
 import moa.core.Example;
 import moa.core.Measurement;
 
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.Prediction;
-
 /**
  * Multilabel Window Classification Performance Evaluator.
  * 
diff --git a/moa/src/main/java/moa/evaluation/BasicMultiTargetPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/BasicMultiTargetPerformanceEvaluator.java
index 5b87a670b..0f522b1e6 100644
--- a/moa/src/main/java/moa/evaluation/BasicMultiTargetPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/BasicMultiTargetPerformanceEvaluator.java
@@ -19,17 +19,14 @@
  */
 package moa.evaluation;
 
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.AbstractMOAObject;
 import moa.core.Example;
 import moa.core.Measurement;
 
-import com.yahoo.labs.samoa.instances.DenseInstance;
-import com.yahoo.labs.samoa.instances.DenseInstanceData;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.Prediction;
-
 /**
  * Regression evaluator that performs basic incremental evaluation.
  *
diff --git a/moa/src/main/java/moa/evaluation/BasicRegressionPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/BasicRegressionPerformanceEvaluator.java
index 3948cfeba..f4ca38547 100644
--- a/moa/src/main/java/moa/evaluation/BasicRegressionPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/BasicRegressionPerformanceEvaluator.java
@@ -19,14 +19,13 @@
  */
 package moa.evaluation;
 
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.Prediction;
+
 import moa.AbstractMOAObject;
 import moa.core.Example;
 import moa.core.Measurement;
 
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.Prediction;
-
 /**
  * Regression evaluator that performs basic incremental evaluation.
  *
diff --git a/moa/src/main/java/moa/evaluation/CMM_GTAnalysis.java b/moa/src/main/java/moa/evaluation/CMM_GTAnalysis.java
index 204909e2e..db4f8273b 100644
--- a/moa/src/main/java/moa/evaluation/CMM_GTAnalysis.java
+++ b/moa/src/main/java/moa/evaluation/CMM_GTAnalysis.java
@@ -36,10 +36,12 @@
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.Clustering;
 import moa.core.AutoExpandVector;
 import moa.gui.visualization.DataPoint;
-import com.yahoo.labs.samoa.instances.Instance;
 
 public class CMM_GTAnalysis{
 	
diff --git a/moa/src/main/java/moa/evaluation/ChangeDetectionMeasures.java b/moa/src/main/java/moa/evaluation/ChangeDetectionMeasures.java
index c40dda432..faccffcc6 100644
--- a/moa/src/main/java/moa/evaluation/ChangeDetectionMeasures.java
+++ b/moa/src/main/java/moa/evaluation/ChangeDetectionMeasures.java
@@ -21,6 +21,7 @@
 package moa.evaluation;
 
 import java.util.ArrayList;
+
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
 
diff --git a/moa/src/main/java/moa/evaluation/ClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/ClassificationPerformanceEvaluator.java
index 0eb9176c9..d1a6ba878 100644
--- a/moa/src/main/java/moa/evaluation/ClassificationPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/ClassificationPerformanceEvaluator.java
@@ -20,9 +20,8 @@
 package moa.evaluation;
 
 import com.yahoo.labs.samoa.instances.Instance;
-import moa.MOAObject;
+
 import moa.core.Example;
-import moa.core.Measurement;
 
 public interface ClassificationPerformanceEvaluator extends LearningPerformanceEvaluator<Example<Instance>> {
 
diff --git a/moa/src/main/java/moa/evaluation/EWMAClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/EWMAClassificationPerformanceEvaluator.java
index 31f8ace8f..04a33adf2 100644
--- a/moa/src/main/java/moa/evaluation/EWMAClassificationPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/EWMAClassificationPerformanceEvaluator.java
@@ -19,21 +19,8 @@
  */
 package moa.evaluation;
 
-import moa.core.Example;
-import moa.core.Measurement;
-import moa.core.ObjectRepository;
-
 import com.github.javacliparser.FloatOption;
 
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.Prediction;
-
-import moa.core.Utils;
-
 /**
  * Classification evaluator that updates evaluation results using an Exponential Weighted Moving Average.
  *
diff --git a/moa/src/main/java/moa/evaluation/EntropyCollection.java b/moa/src/main/java/moa/evaluation/EntropyCollection.java
index 53a67226b..dcf04e018 100644
--- a/moa/src/main/java/moa/evaluation/EntropyCollection.java
+++ b/moa/src/main/java/moa/evaluation/EntropyCollection.java
@@ -21,6 +21,7 @@
 package moa.evaluation;
 
 import java.util.ArrayList;
+
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
 
diff --git a/moa/src/main/java/moa/evaluation/F1.java b/moa/src/main/java/moa/evaluation/F1.java
index 36e3529ab..de214877c 100644
--- a/moa/src/main/java/moa/evaluation/F1.java
+++ b/moa/src/main/java/moa/evaluation/F1.java
@@ -20,6 +20,7 @@
 package moa.evaluation;
 
 import java.util.ArrayList;
+
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
 
diff --git a/moa/src/main/java/moa/evaluation/FadingFactorClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/FadingFactorClassificationPerformanceEvaluator.java
index ed1cd700e..54bbe72e4 100644
--- a/moa/src/main/java/moa/evaluation/FadingFactorClassificationPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/FadingFactorClassificationPerformanceEvaluator.java
@@ -19,20 +19,8 @@
  */
 package moa.evaluation;
 
-import moa.core.Example;
-import moa.core.Measurement;
-import moa.core.ObjectRepository;
-
 import com.github.javacliparser.FloatOption;
 
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-import moa.core.Utils;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.Prediction;
-
 /**
  * Classification evaluator that updates evaluation results using a fading factor.
  *
diff --git a/moa/src/main/java/moa/evaluation/General.java b/moa/src/main/java/moa/evaluation/General.java
index c50d1ca9f..90682d18b 100644
--- a/moa/src/main/java/moa/evaluation/General.java
+++ b/moa/src/main/java/moa/evaluation/General.java
@@ -22,10 +22,12 @@
 
 
 import java.util.ArrayList;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.Clustering;
 import moa.cluster.SphereCluster;
 import moa.gui.visualization.DataPoint;
-import com.yahoo.labs.samoa.instances.Instance;
 
 public class General extends MeasureCollection{
     private int numPoints;
diff --git a/moa/src/main/java/moa/evaluation/LearningEvaluation.java b/moa/src/main/java/moa/evaluation/LearningEvaluation.java
index e03d8aaed..70bb17315 100644
--- a/moa/src/main/java/moa/evaluation/LearningEvaluation.java
+++ b/moa/src/main/java/moa/evaluation/LearningEvaluation.java
@@ -24,10 +24,8 @@
 import java.util.List;
 
 import moa.AbstractMOAObject;
-import moa.classifiers.Classifier;
-import moa.clusterers.Clusterer;
-import moa.learners.Learner;
 import moa.core.Measurement;
+import moa.learners.Learner;
 
 /**
  * Class that stores an array of evaluation measurements.
diff --git a/moa/src/main/java/moa/evaluation/LearningPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/LearningPerformanceEvaluator.java
index 49b44c3c2..820886e1d 100644
--- a/moa/src/main/java/moa/evaluation/LearningPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/LearningPerformanceEvaluator.java
@@ -19,7 +19,6 @@
  */
 package moa.evaluation;
 
-import com.yahoo.labs.samoa.instances.InstanceData;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 import moa.MOAObject;
diff --git a/moa/src/main/java/moa/evaluation/MeasureCollection.java b/moa/src/main/java/moa/evaluation/MeasureCollection.java
index 521470ccc..236d87328 100644
--- a/moa/src/main/java/moa/evaluation/MeasureCollection.java
+++ b/moa/src/main/java/moa/evaluation/MeasureCollection.java
@@ -22,6 +22,7 @@
 
 import java.util.ArrayList;
 import java.util.HashMap;
+
 import moa.AbstractMOAObject;
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
diff --git a/moa/src/main/java/moa/evaluation/MembershipMatrix.java b/moa/src/main/java/moa/evaluation/MembershipMatrix.java
index b139683df..d29777667 100644
--- a/moa/src/main/java/moa/evaluation/MembershipMatrix.java
+++ b/moa/src/main/java/moa/evaluation/MembershipMatrix.java
@@ -22,6 +22,7 @@
 
 import java.util.ArrayList;
 import java.util.HashMap;
+
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
 
diff --git a/moa/src/main/java/moa/evaluation/MultiTargetPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/MultiTargetPerformanceEvaluator.java
index 38d2c10d1..166f3fe24 100644
--- a/moa/src/main/java/moa/evaluation/MultiTargetPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/MultiTargetPerformanceEvaluator.java
@@ -19,9 +19,10 @@
  */
 package moa.evaluation;
 
-import moa.core.Example;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.core.Example;
+
 
 /**
  * Interface implemented by learner evaluators to monitor
diff --git a/moa/src/main/java/moa/evaluation/MultiTargetWindowRegressionPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/MultiTargetWindowRegressionPerformanceEvaluator.java
index 24d45642d..0e8323c07 100644
--- a/moa/src/main/java/moa/evaluation/MultiTargetWindowRegressionPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/MultiTargetWindowRegressionPerformanceEvaluator.java
@@ -19,20 +19,17 @@
  */
 package moa.evaluation;
 
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.core.Example;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-
-import com.github.javacliparser.IntOption;
-
 import moa.tasks.TaskMonitor;
 
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.Prediction;
-
 /**
  * Multi-target regression evaluator that updates evaluation results using a sliding window.
  *
diff --git a/moa/src/main/java/moa/evaluation/OutlierPerformance.java b/moa/src/main/java/moa/evaluation/OutlierPerformance.java
index f940a631c..298472f54 100644
--- a/moa/src/main/java/moa/evaluation/OutlierPerformance.java
+++ b/moa/src/main/java/moa/evaluation/OutlierPerformance.java
@@ -21,7 +21,7 @@
 package moa.evaluation;
 
 import java.util.ArrayList;
-import java.util.Arrays;
+
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
 
diff --git a/moa/src/main/java/moa/evaluation/RegressionPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/RegressionPerformanceEvaluator.java
index 4934ab79f..78513adb7 100644
--- a/moa/src/main/java/moa/evaluation/RegressionPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/RegressionPerformanceEvaluator.java
@@ -19,9 +19,10 @@
  */
 package moa.evaluation;
 
-import moa.core.Example;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.core.Example;
+
 
 /**
  * Interface implemented by learner evaluators to monitor
diff --git a/moa/src/main/java/moa/evaluation/SSQ.java b/moa/src/main/java/moa/evaluation/SSQ.java
index 34e6dc4ba..37fab259e 100644
--- a/moa/src/main/java/moa/evaluation/SSQ.java
+++ b/moa/src/main/java/moa/evaluation/SSQ.java
@@ -21,6 +21,7 @@
 package moa.evaluation;
 
 import java.util.ArrayList;
+
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
 
diff --git a/moa/src/main/java/moa/evaluation/Separation.java b/moa/src/main/java/moa/evaluation/Separation.java
index 46a151262..fd5c9fbf8 100644
--- a/moa/src/main/java/moa/evaluation/Separation.java
+++ b/moa/src/main/java/moa/evaluation/Separation.java
@@ -1,5 +1,8 @@
 package moa.evaluation;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /*
  * #%L
  * SAMOA
@@ -22,14 +25,12 @@
 
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.Cluster;
 import moa.cluster.Clustering;
 import moa.cluster.SphereCluster;
 import moa.gui.visualization.DataPoint;
 
-import java.util.ArrayList;
-import java.util.List;
-
 public class Separation extends MeasureCollection {
 
   public Separation() {
diff --git a/moa/src/main/java/moa/evaluation/SilhouetteCoefficient.java b/moa/src/main/java/moa/evaluation/SilhouetteCoefficient.java
index 5f2697155..c58a7a8da 100644
--- a/moa/src/main/java/moa/evaluation/SilhouetteCoefficient.java
+++ b/moa/src/main/java/moa/evaluation/SilhouetteCoefficient.java
@@ -21,7 +21,7 @@
 package moa.evaluation; 
 
 import java.util.ArrayList;
-import java.util.HashMap;
+
 import moa.cluster.Cluster;
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
diff --git a/moa/src/main/java/moa/evaluation/StatisticalCollection.java b/moa/src/main/java/moa/evaluation/StatisticalCollection.java
index be51d4605..74f9576d1 100644
--- a/moa/src/main/java/moa/evaluation/StatisticalCollection.java
+++ b/moa/src/main/java/moa/evaluation/StatisticalCollection.java
@@ -22,6 +22,7 @@
 
 import java.util.ArrayList;
 import java.util.Arrays;
+
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
 
diff --git a/moa/src/main/java/moa/evaluation/WindowClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/WindowClassificationPerformanceEvaluator.java
index 31b9f3ef4..c6df7de30 100644
--- a/moa/src/main/java/moa/evaluation/WindowClassificationPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/WindowClassificationPerformanceEvaluator.java
@@ -19,20 +19,8 @@
  */
 package moa.evaluation;
 
-import moa.core.Example;
-import moa.core.Measurement;
-import moa.core.ObjectRepository;
-import moa.options.AbstractOptionHandler;
-
 import com.github.javacliparser.IntOption;
 
-import moa.tasks.TaskMonitor;
-import moa.core.Utils;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.Prediction;
-
 /**
  * Classification evaluator that updates evaluation results using a sliding
  * window.
diff --git a/moa/src/main/java/moa/evaluation/WindowRegressionPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/WindowRegressionPerformanceEvaluator.java
index 45d2f4e5a..280893b11 100644
--- a/moa/src/main/java/moa/evaluation/WindowRegressionPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/WindowRegressionPerformanceEvaluator.java
@@ -19,19 +19,16 @@
  */
 package moa.evaluation;
 
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.Prediction;
+
 import moa.core.Example;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-
-import com.github.javacliparser.IntOption;
-
 import moa.tasks.TaskMonitor;
 
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.Prediction;
-
 /**
  * Regression evaluator that updates evaluation results using a sliding window.
  *
diff --git a/moa/src/main/java/moa/gui/BatchCmd.java b/moa/src/main/java/moa/gui/BatchCmd.java
index c793093c1..eacbc966f 100644
--- a/moa/src/main/java/moa/gui/BatchCmd.java
+++ b/moa/src/main/java/moa/gui/BatchCmd.java
@@ -32,6 +32,9 @@
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.Clustering;
 import moa.clusterers.AbstractClusterer;
 import moa.clusterers.ClusterGenerator;
@@ -46,11 +49,9 @@
 import moa.gui.visualization.DataPoint;
 import moa.gui.visualization.RunVisualizer;
 import moa.streams.clustering.ClusterEvent;
-import com.yahoo.labs.samoa.instances.Instance;
 import moa.streams.clustering.ClusterEventListener;
 import moa.streams.clustering.ClusteringStream;
 import moa.streams.clustering.RandomRBFGeneratorEvents;
-import com.yahoo.labs.samoa.instances.DenseInstance;
 
 public class BatchCmd implements ClusterEventListener{
 
diff --git a/moa/src/main/java/moa/gui/ClassOptionSelectionPanel.java b/moa/src/main/java/moa/gui/ClassOptionSelectionPanel.java
index 16c2fbe74..239c42406 100644
--- a/moa/src/main/java/moa/gui/ClassOptionSelectionPanel.java
+++ b/moa/src/main/java/moa/gui/ClassOptionSelectionPanel.java
@@ -19,7 +19,6 @@
  */
 package moa.gui;
 
-import com.github.javacliparser.gui.OptionsConfigurationPanel;
 import java.awt.BorderLayout;
 import java.awt.Component;
 import java.awt.Window;
@@ -32,6 +31,8 @@
 import javax.swing.JOptionPane;
 import javax.swing.JPanel;
 
+import com.github.javacliparser.gui.OptionsConfigurationPanel;
+
 import moa.core.AutoClassDiscovery;
 import moa.core.AutoExpandVector;
 import moa.options.ClassOption;
diff --git a/moa/src/main/java/moa/gui/ClassOptionWithNamesSelectionPanel.java b/moa/src/main/java/moa/gui/ClassOptionWithNamesSelectionPanel.java
index a0ba8a8c6..524199618 100644
--- a/moa/src/main/java/moa/gui/ClassOptionWithNamesSelectionPanel.java
+++ b/moa/src/main/java/moa/gui/ClassOptionWithNamesSelectionPanel.java
@@ -10,7 +10,6 @@
 
 package moa.gui;
 
-import com.github.javacliparser.gui.OptionsConfigurationPanel;
 import java.awt.BorderLayout;
 import java.awt.Component;
 import java.awt.Window;
@@ -23,6 +22,8 @@
 import javax.swing.JOptionPane;
 import javax.swing.JPanel;
 
+import com.github.javacliparser.gui.OptionsConfigurationPanel;
+
 import moa.core.AutoClassDiscovery;
 import moa.core.AutoExpandVector;
 import moa.options.ClassOption;
diff --git a/moa/src/main/java/moa/gui/ConceptDriftTabPanel.java b/moa/src/main/java/moa/gui/ConceptDriftTabPanel.java
index 5cd80e515..de248e6de 100644
--- a/moa/src/main/java/moa/gui/ConceptDriftTabPanel.java
+++ b/moa/src/main/java/moa/gui/ConceptDriftTabPanel.java
@@ -20,6 +20,7 @@
 package moa.gui;
 
 import java.awt.BorderLayout;
+
 import moa.gui.PreviewPanel.TypePanel;
 import moa.gui.conceptdrift.CDTaskManagerPanel;
 
diff --git a/moa/src/main/java/moa/gui/GUI.java b/moa/src/main/java/moa/gui/GUI.java
index 442566626..ae5be1a43 100644
--- a/moa/src/main/java/moa/gui/GUI.java
+++ b/moa/src/main/java/moa/gui/GUI.java
@@ -21,13 +21,11 @@
 package moa.gui;
 
 import java.awt.BorderLayout;
-import java.util.logging.Level;
-import java.util.logging.Logger;
+
 import javax.swing.JFrame;
 import javax.swing.JPanel;
 import javax.swing.UIManager;
-import javax.swing.UIManager.LookAndFeelInfo;
-import javax.swing.UnsupportedLookAndFeelException;
+
 import moa.DoTask;
 import moa.core.WekaUtils;
 
diff --git a/moa/src/main/java/moa/gui/GUIDefaults.java b/moa/src/main/java/moa/gui/GUIDefaults.java
index 5ff90ed57..466ff3b0c 100644
--- a/moa/src/main/java/moa/gui/GUIDefaults.java
+++ b/moa/src/main/java/moa/gui/GUIDefaults.java
@@ -20,15 +20,15 @@
  */
 package moa.gui;
 
-import moa.core.PropertiesReader;
-import moa.core.Utils;
-
 import java.io.Serializable;
 import java.util.Collections;
 import java.util.Enumeration;
 import java.util.Properties;
 import java.util.Vector;
 
+import moa.core.PropertiesReader;
+import moa.core.Utils;
+
 /**
  * This class offers get methods for the default GUI settings in 
  * the props file <code>moa/gui/GUI.props</code>.
diff --git a/moa/src/main/java/moa/gui/MultiTargetTabPanel.java b/moa/src/main/java/moa/gui/MultiTargetTabPanel.java
index 955cad212..63ef5f263 100644
--- a/moa/src/main/java/moa/gui/MultiTargetTabPanel.java
+++ b/moa/src/main/java/moa/gui/MultiTargetTabPanel.java
@@ -20,6 +20,7 @@
 package moa.gui;
 
 import java.awt.BorderLayout;
+
 import moa.gui.PreviewPanel.TypePanel;
 
 /**
diff --git a/moa/src/main/java/moa/gui/MultiTargetTaskManagerPanel.java b/moa/src/main/java/moa/gui/MultiTargetTaskManagerPanel.java
index 01a9ea4cf..0d5745bd0 100644
--- a/moa/src/main/java/moa/gui/MultiTargetTaskManagerPanel.java
+++ b/moa/src/main/java/moa/gui/MultiTargetTaskManagerPanel.java
@@ -38,6 +38,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.prefs.Preferences;
+
 import javax.swing.JButton;
 import javax.swing.JFileChooser;
 import javax.swing.JFrame;
@@ -56,6 +57,7 @@
 import javax.swing.table.AbstractTableModel;
 import javax.swing.table.DefaultTableCellRenderer;
 import javax.swing.table.TableCellRenderer;
+
 import moa.core.StringUtils;
 import moa.options.ClassOption;
 import moa.options.OptionHandler;
diff --git a/moa/src/main/java/moa/gui/RegressionTabPanel.java b/moa/src/main/java/moa/gui/RegressionTabPanel.java
index 372157ad8..ae99d364c 100644
--- a/moa/src/main/java/moa/gui/RegressionTabPanel.java
+++ b/moa/src/main/java/moa/gui/RegressionTabPanel.java
@@ -20,6 +20,7 @@
 package moa.gui;
 
 import java.awt.BorderLayout;
+
 import moa.gui.PreviewPanel.TypePanel;
 
 /**
diff --git a/moa/src/main/java/moa/gui/RegressionTaskManagerPanel.java b/moa/src/main/java/moa/gui/RegressionTaskManagerPanel.java
index 226421523..4d7fb91ab 100644
--- a/moa/src/main/java/moa/gui/RegressionTaskManagerPanel.java
+++ b/moa/src/main/java/moa/gui/RegressionTaskManagerPanel.java
@@ -23,13 +23,13 @@
 import java.awt.BorderLayout;
 import java.awt.Component;
 import java.awt.Dimension;
+import java.awt.Toolkit;
+import java.awt.datatransfer.Clipboard;
+import java.awt.datatransfer.StringSelection;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
-import java.awt.Toolkit;
-import java.awt.datatransfer.Clipboard;
-import java.awt.datatransfer.StringSelection;
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileWriter;
diff --git a/moa/src/main/java/moa/gui/TaskManagerPanel.java b/moa/src/main/java/moa/gui/TaskManagerPanel.java
index 7ab117cf1..1eb3b29df 100644
--- a/moa/src/main/java/moa/gui/TaskManagerPanel.java
+++ b/moa/src/main/java/moa/gui/TaskManagerPanel.java
@@ -23,13 +23,13 @@
 import java.awt.BorderLayout;
 import java.awt.Component;
 import java.awt.Dimension;
+import java.awt.Toolkit;
+import java.awt.datatransfer.Clipboard;
+import java.awt.datatransfer.StringSelection;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
-import java.awt.Toolkit;
-import java.awt.datatransfer.Clipboard;
-import java.awt.datatransfer.StringSelection;
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileWriter;
diff --git a/moa/src/main/java/moa/gui/TaskTextViewerPanel.java b/moa/src/main/java/moa/gui/TaskTextViewerPanel.java
index 20a28e1f4..27deaba22 100644
--- a/moa/src/main/java/moa/gui/TaskTextViewerPanel.java
+++ b/moa/src/main/java/moa/gui/TaskTextViewerPanel.java
@@ -40,9 +40,8 @@
 import javax.swing.JPanel;
 import javax.swing.JScrollPane;
 import javax.swing.JTextArea;
-import moa.evaluation.Accuracy;
+
 import moa.evaluation.MeasureCollection;
-import moa.evaluation.RegressionAccuracy;
 import moa.gui.PreviewPanel.TypePanel;
 import moa.gui.conceptdrift.CDTaskManagerPanel;
 import moa.streams.clustering.ClusterEvent;
diff --git a/moa/src/main/java/moa/gui/WEKAClassOptionEditComponent.java b/moa/src/main/java/moa/gui/WEKAClassOptionEditComponent.java
index 5288a0ce5..755326f70 100644
--- a/moa/src/main/java/moa/gui/WEKAClassOptionEditComponent.java
+++ b/moa/src/main/java/moa/gui/WEKAClassOptionEditComponent.java
@@ -20,12 +20,6 @@
  */
 package moa.gui;
 
-import com.github.javacliparser.gui.OptionEditComponent;
-import moa.core.Utils;
-import weka.gui.GenericObjectEditor;
-import weka.gui.PropertyDialog;
-import weka.gui.GenericObjectEditor.GOEPanel;
-
 import java.awt.BorderLayout;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
@@ -35,7 +29,13 @@
 import javax.swing.JTextField;
 
 import com.github.javacliparser.Option;
+import com.github.javacliparser.gui.OptionEditComponent;
+
+import moa.core.Utils;
 import moa.options.WEKAClassOption;
+import weka.gui.GenericObjectEditor;
+import weka.gui.GenericObjectEditor.GOEPanel;
+import weka.gui.PropertyDialog;
 
 /**
  * An OptionEditComponent that lets the user edit a WEKA class option.
diff --git a/moa/src/main/java/moa/gui/clustertab/ClusteringAlgoPanel.java b/moa/src/main/java/moa/gui/clustertab/ClusteringAlgoPanel.java
index 0a04c98f9..61385baf7 100644
--- a/moa/src/main/java/moa/gui/clustertab/ClusteringAlgoPanel.java
+++ b/moa/src/main/java/moa/gui/clustertab/ClusteringAlgoPanel.java
@@ -21,7 +21,6 @@
 package moa.gui.clustertab;
 
 import java.awt.BorderLayout;
-
 import java.awt.GridBagConstraints;
 import java.awt.GridBagLayout;
 import java.awt.Insets;
@@ -32,20 +31,21 @@
 import java.util.List;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+
 import javax.swing.JButton;
 import javax.swing.JComponent;
 import javax.swing.JLabel;
 import javax.swing.JPanel;
 
+import com.github.javacliparser.Option;
+import com.github.javacliparser.gui.OptionEditComponent;
+import com.github.javacliparser.gui.OptionsConfigurationPanel;
+
 import moa.clusterers.AbstractClusterer;
 import moa.clusterers.Clusterer;
 import moa.gui.GUIUtils;
-import com.github.javacliparser.gui.OptionEditComponent;
-import com.github.javacliparser.gui.OptionsConfigurationPanel;
 import moa.options.ClassOption;
-import com.github.javacliparser.Option;
 import moa.streams.clustering.ClusteringStream;
-import moa.streams.generators.RandomRBFGenerator;
 
 public class ClusteringAlgoPanel extends javax.swing.JPanel implements ActionListener{
 
diff --git a/moa/src/main/java/moa/gui/clustertab/ClusteringEvalPanel.java b/moa/src/main/java/moa/gui/clustertab/ClusteringEvalPanel.java
index eb9a57d81..9d94481db 100644
--- a/moa/src/main/java/moa/gui/clustertab/ClusteringEvalPanel.java
+++ b/moa/src/main/java/moa/gui/clustertab/ClusteringEvalPanel.java
@@ -22,11 +22,12 @@
 import java.awt.GridBagConstraints;
 import java.util.ArrayList;
 import java.util.logging.Logger;
+
 import javax.swing.JCheckBox;
 import javax.swing.JLabel;
+
 import moa.core.AutoClassDiscovery;
 import moa.core.AutoExpandVector;
-import moa.evaluation.ClassificationMeasureCollection;
 import moa.evaluation.MeasureCollection;
 
 public class ClusteringEvalPanel extends javax.swing.JPanel {
diff --git a/moa/src/main/java/moa/gui/clustertab/ClusteringSetupTab.java b/moa/src/main/java/moa/gui/clustertab/ClusteringSetupTab.java
index beffc7e52..f27f5eece 100644
--- a/moa/src/main/java/moa/gui/clustertab/ClusteringSetupTab.java
+++ b/moa/src/main/java/moa/gui/clustertab/ClusteringSetupTab.java
@@ -24,7 +24,9 @@
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileReader;
+
 import javax.swing.JFileChooser;
+
 import moa.clusterers.AbstractClusterer;
 import moa.evaluation.MeasureCollection;
 import moa.gui.FileExtensionFilter;
diff --git a/moa/src/main/java/moa/gui/clustertab/ClusteringVisualEvalPanel.java b/moa/src/main/java/moa/gui/clustertab/ClusteringVisualEvalPanel.java
index 626bed80a..574a78b96 100644
--- a/moa/src/main/java/moa/gui/clustertab/ClusteringVisualEvalPanel.java
+++ b/moa/src/main/java/moa/gui/clustertab/ClusteringVisualEvalPanel.java
@@ -25,13 +25,13 @@
 import java.awt.Graphics;
 import java.awt.GridBagConstraints;
 import java.awt.event.ActionListener;
-import java.awt.event.ComponentEvent;
-import java.awt.event.ComponentListener;
 import java.text.DecimalFormat;
 import java.util.ArrayList;
+
 import javax.swing.ButtonGroup;
 import javax.swing.JLabel;
 import javax.swing.JRadioButton;
+
 import moa.evaluation.MeasureCollection;
 
 public class ClusteringVisualEvalPanel extends javax.swing.JPanel{
diff --git a/moa/src/main/java/moa/gui/clustertab/ClusteringVisualTab.java b/moa/src/main/java/moa/gui/clustertab/ClusteringVisualTab.java
index ba2f22c94..02fe10e7b 100644
--- a/moa/src/main/java/moa/gui/clustertab/ClusteringVisualTab.java
+++ b/moa/src/main/java/moa/gui/clustertab/ClusteringVisualTab.java
@@ -24,10 +24,12 @@
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.io.File;
+
 import javax.swing.JButton;
 import javax.swing.JComboBox;
 import javax.swing.JFileChooser;
 import javax.swing.ToolTipManager;
+
 import moa.gui.FileExtensionFilter;
 import moa.gui.visualization.GraphCanvas;
 import moa.gui.visualization.RunVisualizer;
diff --git a/moa/src/main/java/moa/gui/conceptdrift/CDTaskManagerPanel.java b/moa/src/main/java/moa/gui/conceptdrift/CDTaskManagerPanel.java
index 2b8ad6651..3794d6667 100644
--- a/moa/src/main/java/moa/gui/conceptdrift/CDTaskManagerPanel.java
+++ b/moa/src/main/java/moa/gui/conceptdrift/CDTaskManagerPanel.java
@@ -20,17 +20,16 @@
  */
 package moa.gui.conceptdrift;
 
-import moa.gui.*;
 import java.awt.BorderLayout;
 import java.awt.Component;
 import java.awt.Dimension;
+import java.awt.Toolkit;
+import java.awt.datatransfer.Clipboard;
+import java.awt.datatransfer.StringSelection;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
-import java.awt.Toolkit;
-import java.awt.datatransfer.Clipboard;
-import java.awt.datatransfer.StringSelection;
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileWriter;
@@ -60,6 +59,10 @@
 import javax.swing.table.TableCellRenderer;
 
 import moa.core.StringUtils;
+import moa.gui.ClassOptionSelectionPanel;
+import moa.gui.FileExtensionFilter;
+import moa.gui.GUIUtils;
+import moa.gui.PreviewPanel;
 import moa.options.ClassOption;
 import moa.options.OptionHandler;
 import moa.tasks.ConceptDriftMainTask;
diff --git a/moa/src/main/java/moa/gui/outliertab/OutlierAlgoPanel.java b/moa/src/main/java/moa/gui/outliertab/OutlierAlgoPanel.java
index d7fd2acd8..9951c4aa7 100644
--- a/moa/src/main/java/moa/gui/outliertab/OutlierAlgoPanel.java
+++ b/moa/src/main/java/moa/gui/outliertab/OutlierAlgoPanel.java
@@ -20,7 +20,11 @@
 
 package moa.gui.outliertab;
 
-import java.awt.*;
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.awt.Insets;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.util.ArrayList;
@@ -28,16 +32,19 @@
 import java.util.List;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+
 import javax.swing.JButton;
 import javax.swing.JComponent;
 import javax.swing.JLabel;
 import javax.swing.JPanel;
-import moa.clusterers.outliers.MyBaseOutlierDetector;
-import moa.gui.GUIUtils;
-import moa.options.ClassOption;
+
 import com.github.javacliparser.Option;
 import com.github.javacliparser.gui.OptionEditComponent;
 import com.github.javacliparser.gui.OptionsConfigurationPanel;
+
+import moa.clusterers.outliers.MyBaseOutlierDetector;
+import moa.gui.GUIUtils;
+import moa.options.ClassOption;
 import moa.streams.clustering.ClusteringStream;
 
 public class OutlierAlgoPanel extends javax.swing.JPanel implements ActionListener{
diff --git a/moa/src/main/java/moa/gui/outliertab/OutlierEvalPanel.java b/moa/src/main/java/moa/gui/outliertab/OutlierEvalPanel.java
index 84500eb92..0883b9034 100644
--- a/moa/src/main/java/moa/gui/outliertab/OutlierEvalPanel.java
+++ b/moa/src/main/java/moa/gui/outliertab/OutlierEvalPanel.java
@@ -22,12 +22,12 @@
 
 import java.awt.GridBagConstraints;
 import java.util.ArrayList;
-import java.util.logging.Logger;
+
 import javax.swing.JCheckBox;
 import javax.swing.JLabel;
+
 import moa.core.AutoClassDiscovery;
 import moa.core.AutoExpandVector;
-import moa.evaluation.ClassificationMeasureCollection;
 import moa.evaluation.MeasureCollection;
 import moa.evaluation.OutlierPerformance;
 
diff --git a/moa/src/main/java/moa/gui/outliertab/OutlierSetupTab.java b/moa/src/main/java/moa/gui/outliertab/OutlierSetupTab.java
index 70b2dd742..56c6889d4 100644
--- a/moa/src/main/java/moa/gui/outliertab/OutlierSetupTab.java
+++ b/moa/src/main/java/moa/gui/outliertab/OutlierSetupTab.java
@@ -24,7 +24,9 @@
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileReader;
+
 import javax.swing.JFileChooser;
+
 import moa.clusterers.outliers.MyBaseOutlierDetector;
 import moa.evaluation.MeasureCollection;
 import moa.gui.FileExtensionFilter;
diff --git a/moa/src/main/java/moa/gui/outliertab/OutlierVisualEvalPanel.java b/moa/src/main/java/moa/gui/outliertab/OutlierVisualEvalPanel.java
index 7c5307f1d..24c410add 100644
--- a/moa/src/main/java/moa/gui/outliertab/OutlierVisualEvalPanel.java
+++ b/moa/src/main/java/moa/gui/outliertab/OutlierVisualEvalPanel.java
@@ -25,13 +25,13 @@
 import java.awt.Graphics;
 import java.awt.GridBagConstraints;
 import java.awt.event.ActionListener;
-import java.awt.event.ComponentEvent;
-import java.awt.event.ComponentListener;
 import java.text.DecimalFormat;
 import java.util.ArrayList;
+
 import javax.swing.ButtonGroup;
 import javax.swing.JLabel;
 import javax.swing.JRadioButton;
+
 import moa.evaluation.MeasureCollection;
 
 public class OutlierVisualEvalPanel extends javax.swing.JPanel{
diff --git a/moa/src/main/java/moa/gui/outliertab/OutlierVisualTab.java b/moa/src/main/java/moa/gui/outliertab/OutlierVisualTab.java
index 2322a01f6..9923bfeed 100644
--- a/moa/src/main/java/moa/gui/outliertab/OutlierVisualTab.java
+++ b/moa/src/main/java/moa/gui/outliertab/OutlierVisualTab.java
@@ -28,10 +28,12 @@
 import java.awt.event.ComponentEvent;
 import java.awt.event.ComponentListener;
 import java.io.File;
+
 import javax.swing.JButton;
 import javax.swing.JComboBox;
 import javax.swing.JFileChooser;
 import javax.swing.ToolTipManager;
+
 import moa.gui.FileExtensionFilter;
 import moa.gui.visualization.GraphCanvas;
 import moa.gui.visualization.RunOutlierVisualizer;
diff --git a/moa/src/main/java/moa/gui/visualization/ClusterPanel.java b/moa/src/main/java/moa/gui/visualization/ClusterPanel.java
index 3db527710..352100b4d 100644
--- a/moa/src/main/java/moa/gui/visualization/ClusterPanel.java
+++ b/moa/src/main/java/moa/gui/visualization/ClusterPanel.java
@@ -24,7 +24,9 @@
 import java.awt.Dimension;
 import java.awt.Graphics;
 import java.awt.Graphics2D;
+
 import javax.swing.JPanel;
+
 import moa.cluster.SphereCluster;
 
 public class ClusterPanel extends JPanel {
diff --git a/moa/src/main/java/moa/gui/visualization/GraphCanvas.java b/moa/src/main/java/moa/gui/visualization/GraphCanvas.java
index 6aecc5a32..fe857f285 100644
--- a/moa/src/main/java/moa/gui/visualization/GraphCanvas.java
+++ b/moa/src/main/java/moa/gui/visualization/GraphCanvas.java
@@ -22,9 +22,11 @@
 import java.awt.Dimension;
 import java.awt.Graphics;
 import java.util.ArrayList;
+
 import javax.swing.JLabel;
 import javax.swing.JPanel;
 import javax.swing.JViewport;
+
 import moa.evaluation.MeasureCollection;
 import moa.streams.clustering.ClusterEvent;
 
diff --git a/moa/src/main/java/moa/gui/visualization/GraphCurve.java b/moa/src/main/java/moa/gui/visualization/GraphCurve.java
index a791cafb3..46518e7a1 100644
--- a/moa/src/main/java/moa/gui/visualization/GraphCurve.java
+++ b/moa/src/main/java/moa/gui/visualization/GraphCurve.java
@@ -23,6 +23,7 @@
 import java.awt.Dimension;
 import java.awt.Graphics;
 import java.util.ArrayList;
+
 import moa.evaluation.MeasureCollection;
 import moa.streams.clustering.ClusterEvent;
 
diff --git a/moa/src/main/java/moa/gui/visualization/OutlierPanel.java b/moa/src/main/java/moa/gui/visualization/OutlierPanel.java
index 68c5c1a48..f917a0ad9 100644
--- a/moa/src/main/java/moa/gui/visualization/OutlierPanel.java
+++ b/moa/src/main/java/moa/gui/visualization/OutlierPanel.java
@@ -21,13 +21,20 @@
 
 package moa.gui.visualization;
 
-import java.awt.*;
-import java.awt.event.WindowEvent;
-import java.awt.event.WindowFocusListener;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.Map;
-import javax.swing.*;
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.MouseInfo;
+import java.awt.Point;
+import java.awt.PointerInfo;
+import java.awt.RenderingHints;
+
+import javax.swing.JDialog;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+
 import moa.cluster.SphereCluster;
 import moa.clusterers.outliers.MyBaseOutlierDetector;
 import moa.clusterers.outliers.MyBaseOutlierDetector.Outlier;
diff --git a/moa/src/main/java/moa/gui/visualization/RunOutlierVisualizer.java b/moa/src/main/java/moa/gui/visualization/RunOutlierVisualizer.java
index ce611e1ba..5dd794716 100644
--- a/moa/src/main/java/moa/gui/visualization/RunOutlierVisualizer.java
+++ b/moa/src/main/java/moa/gui/visualization/RunOutlierVisualizer.java
@@ -39,6 +39,12 @@
 import java.util.Vector;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+
+import com.yahoo.labs.samoa.instances.Attribute;
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.cluster.Cluster;
 import moa.cluster.Clustering;
 import moa.clusterers.outliers.MyBaseOutlierDetector;
@@ -56,10 +62,6 @@
 import moa.streams.clustering.ClusterEventListener;
 import moa.streams.clustering.ClusteringStream;
 import moa.streams.clustering.RandomRBFGeneratorEvents;
-import com.yahoo.labs.samoa.instances.Attribute;
-import com.yahoo.labs.samoa.instances.DenseInstance;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public class RunOutlierVisualizer implements Runnable, ActionListener, ClusterEventListener{	
     /** the pause interval, being read from the gui at startup */
diff --git a/moa/src/main/java/moa/gui/visualization/RunVisualizer.java b/moa/src/main/java/moa/gui/visualization/RunVisualizer.java
index 1e08cab18..0e33cbebb 100644
--- a/moa/src/main/java/moa/gui/visualization/RunVisualizer.java
+++ b/moa/src/main/java/moa/gui/visualization/RunVisualizer.java
@@ -34,25 +34,25 @@
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
+import com.yahoo.labs.samoa.instances.Attribute;
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.cluster.Cluster;
 import moa.cluster.Clustering;
 import moa.clusterers.AbstractClusterer;
 import moa.clusterers.ClusterGenerator;
+import moa.core.FastVector;
 import moa.evaluation.MeasureCollection;
 import moa.gui.TextViewerPanel;
 import moa.gui.clustertab.ClusteringSetupTab;
 import moa.gui.clustertab.ClusteringVisualEvalPanel;
 import moa.gui.clustertab.ClusteringVisualTab;
 import moa.streams.clustering.ClusterEvent;
-import com.yahoo.labs.samoa.instances.Instance;
-import moa.gui.clustertab.ClusteringSetupTab;
 import moa.streams.clustering.ClusterEventListener;
 import moa.streams.clustering.ClusteringStream;
 import moa.streams.clustering.RandomRBFGeneratorEvents;
-import com.yahoo.labs.samoa.instances.Attribute;
-import com.yahoo.labs.samoa.instances.DenseInstance;
-import moa.core.FastVector;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public class RunVisualizer implements Runnable, ActionListener, ClusterEventListener{
 
diff --git a/moa/src/main/java/moa/gui/visualization/StreamOutlierPanel.java b/moa/src/main/java/moa/gui/visualization/StreamOutlierPanel.java
index 039619ad8..58f95e1a7 100644
--- a/moa/src/main/java/moa/gui/visualization/StreamOutlierPanel.java
+++ b/moa/src/main/java/moa/gui/visualization/StreamOutlierPanel.java
@@ -20,19 +20,31 @@
 
 package moa.gui.visualization;
 
-import java.awt.*;
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Point;
+import java.awt.RenderingHints;
 import java.awt.event.ComponentEvent;
 import java.awt.event.ComponentListener;
 import java.awt.geom.Rectangle2D;
 import java.awt.image.BufferedImage;
 import java.awt.image.RescaleOp;
-import java.io.*;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
 import java.util.Vector;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+
 import javax.imageio.ImageIO;
 import javax.swing.JPanel;
 import javax.swing.JScrollPane;
+
 import moa.cluster.SphereCluster;
 import moa.clusterers.outliers.MyBaseOutlierDetector;
 import moa.clusterers.outliers.MyBaseOutlierDetector.Outlier;
diff --git a/moa/src/main/java/moa/gui/visualization/WekaExplorer.java b/moa/src/main/java/moa/gui/visualization/WekaExplorer.java
index cfc1d5254..6ed93c826 100644
--- a/moa/src/main/java/moa/gui/visualization/WekaExplorer.java
+++ b/moa/src/main/java/moa/gui/visualization/WekaExplorer.java
@@ -27,18 +27,21 @@
 
 package moa.gui.visualization;
 
-import weka.gui.explorer.Explorer;
-import weka.core.Memory;
 //import weka.gui.LookAndFeel;
 import java.awt.BorderLayout;
 import java.awt.Image;
 import java.awt.Toolkit;
 import java.awt.event.WindowAdapter;
 import java.awt.event.WindowEvent;
+
 import javax.swing.JFrame;
+
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
 
+import weka.core.Memory;
+import weka.gui.explorer.Explorer;
+
 
 public class WekaExplorer {
 
diff --git a/moa/src/main/java/moa/learners/ChangeDetectorLearner.java b/moa/src/main/java/moa/learners/ChangeDetectorLearner.java
index db3abce46..d13d93025 100644
--- a/moa/src/main/java/moa/learners/ChangeDetectorLearner.java
+++ b/moa/src/main/java/moa/learners/ChangeDetectorLearner.java
@@ -19,9 +19,10 @@
 package moa.learners;
 
 import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
-import moa.core.Measurement;
 import moa.classifiers.core.driftdetection.ChangeDetector;
+import moa.core.Measurement;
 import moa.options.ClassOption;
 
 /**
diff --git a/moa/src/main/java/moa/learners/Learner.java b/moa/src/main/java/moa/learners/Learner.java
index 5d700571e..823e8797f 100644
--- a/moa/src/main/java/moa/learners/Learner.java
+++ b/moa/src/main/java/moa/learners/Learner.java
@@ -19,13 +19,11 @@
  */
 package moa.learners;
 
-import moa.MOAObject;
-import moa.core.Example;
-
-import com.yahoo.labs.samoa.instances.InstanceData;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Prediction;
 
+import moa.MOAObject;
+import moa.core.Example;
 import moa.core.Measurement;
 import moa.gui.AWTRenderable;
 import moa.options.OptionHandler;
diff --git a/moa/src/main/java/moa/options/AbstractClassOption.java b/moa/src/main/java/moa/options/AbstractClassOption.java
index 00b0a10c0..70e1af183 100644
--- a/moa/src/main/java/moa/options/AbstractClassOption.java
+++ b/moa/src/main/java/moa/options/AbstractClassOption.java
@@ -20,8 +20,10 @@
 package moa.options;
 
 import java.io.File;
+
 import com.github.javacliparser.AbstractOption;
 import com.github.javacliparser.SerializeUtils;
+
 import moa.core.ObjectRepository;
 import moa.tasks.Task;
 import moa.tasks.TaskMonitor;
diff --git a/moa/src/main/java/moa/options/AbstractOptionHandler.java b/moa/src/main/java/moa/options/AbstractOptionHandler.java
index 622f969a4..a26009fc4 100644
--- a/moa/src/main/java/moa/options/AbstractOptionHandler.java
+++ b/moa/src/main/java/moa/options/AbstractOptionHandler.java
@@ -20,6 +20,7 @@
 package moa.options;
 
 import com.github.javacliparser.Options;
+
 import moa.AbstractMOAObject;
 import moa.core.ObjectRepository;
 import moa.tasks.NullMonitor;
diff --git a/moa/src/main/java/moa/options/ClassOption.java b/moa/src/main/java/moa/options/ClassOption.java
index 56eaf8d19..8a94d3c78 100644
--- a/moa/src/main/java/moa/options/ClassOption.java
+++ b/moa/src/main/java/moa/options/ClassOption.java
@@ -20,9 +20,10 @@
 package moa.options;
 
 import java.io.File;
+
 import com.github.javacliparser.Option;
 import com.github.javacliparser.Options;
-import moa.options.OptionHandler;
+
 import moa.tasks.Task;
 
 /**
diff --git a/moa/src/main/java/moa/options/ClassOptionWithNames.java b/moa/src/main/java/moa/options/ClassOptionWithNames.java
index 256dfdfc2..59959d90c 100644
--- a/moa/src/main/java/moa/options/ClassOptionWithNames.java
+++ b/moa/src/main/java/moa/options/ClassOptionWithNames.java
@@ -11,13 +11,11 @@
 
 package moa.options;
 
-import com.github.javacliparser.Options;
-import com.github.javacliparser.Option;
 import java.io.File;
 
-import javax.swing.JComponent;
+import com.github.javacliparser.Option;
+import com.github.javacliparser.Options;
 
-import com.github.javacliparser.gui.ClassOptionWithNamesEditComponent;
 import moa.tasks.Task;
 
 public class ClassOptionWithNames extends AbstractClassOption {
diff --git a/moa/src/main/java/moa/options/OptionHandler.java b/moa/src/main/java/moa/options/OptionHandler.java
index 6faba81ad..1fac302da 100644
--- a/moa/src/main/java/moa/options/OptionHandler.java
+++ b/moa/src/main/java/moa/options/OptionHandler.java
@@ -21,6 +21,7 @@
 
 import com.github.javacliparser.Configurable;
 import com.github.javacliparser.Options;
+
 import moa.MOAObject;
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
diff --git a/moa/src/main/java/moa/options/OptionsHandler.java b/moa/src/main/java/moa/options/OptionsHandler.java
index fac313a80..42e0b54f2 100644
--- a/moa/src/main/java/moa/options/OptionsHandler.java
+++ b/moa/src/main/java/moa/options/OptionsHandler.java
@@ -2,8 +2,10 @@
 
 
 import java.util.HashMap;
+
 import com.github.javacliparser.JavaCLIParser;
 import com.github.javacliparser.Option;
+
 import moa.core.ObjectRepository;
 import moa.tasks.NullMonitor;
 import moa.tasks.TaskMonitor;
diff --git a/moa/src/main/java/moa/options/WEKAClassOption.java b/moa/src/main/java/moa/options/WEKAClassOption.java
index f117dbbf9..c46d75476 100644
--- a/moa/src/main/java/moa/options/WEKAClassOption.java
+++ b/moa/src/main/java/moa/options/WEKAClassOption.java
@@ -20,17 +20,17 @@
  */
 package moa.options;
 
-import com.github.javacliparser.Option;
-import weka.core.Utils;
-
 import java.io.File;
 import java.util.Enumeration;
 import java.util.Vector;
 
+import com.github.javacliparser.Option;
+
 //import javax.swing.JComponent;
 
 //import moa.gui.WEKAClassOptionEditComponent;
 import moa.tasks.Task;
+import weka.core.Utils;
 
 /**
  * WEKA class option. This option is used to access options in WEKA.
diff --git a/moa/src/main/java/moa/recommender/dataset/impl/FlixsterDataset.java b/moa/src/main/java/moa/recommender/dataset/impl/FlixsterDataset.java
index 0f1844d5e..19841cc24 100644
--- a/moa/src/main/java/moa/recommender/dataset/impl/FlixsterDataset.java
+++ b/moa/src/main/java/moa/recommender/dataset/impl/FlixsterDataset.java
@@ -28,10 +28,11 @@
 import java.io.InputStreamReader;
 import java.util.logging.Level;
 import java.util.logging.Logger;
-import moa.core.ObjectRepository;
-import moa.options.AbstractOptionHandler;
+
 import com.github.javacliparser.FileOption;
 
+import moa.core.ObjectRepository;
+import moa.options.AbstractOptionHandler;
 import moa.recommender.dataset.Dataset;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/recommender/dataset/impl/JesterDataset.java b/moa/src/main/java/moa/recommender/dataset/impl/JesterDataset.java
index 7ff32b3c0..13716c156 100644
--- a/moa/src/main/java/moa/recommender/dataset/impl/JesterDataset.java
+++ b/moa/src/main/java/moa/recommender/dataset/impl/JesterDataset.java
@@ -23,16 +23,17 @@
 import java.io.BufferedReader;
 import java.io.DataInputStream;
 import java.io.FileInputStream;
+import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStreamReader;
-
-import moa.recommender.dataset.Dataset;
-import java.io.FileNotFoundException;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+
+import com.github.javacliparser.FileOption;
+
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.FileOption;
+import moa.recommender.dataset.Dataset;
 import moa.tasks.TaskMonitor;
 
 public class JesterDataset extends AbstractOptionHandler implements Dataset {
diff --git a/moa/src/main/java/moa/recommender/dataset/impl/MovielensDataset.java b/moa/src/main/java/moa/recommender/dataset/impl/MovielensDataset.java
index 8d42e2221..66c86baa6 100644
--- a/moa/src/main/java/moa/recommender/dataset/impl/MovielensDataset.java
+++ b/moa/src/main/java/moa/recommender/dataset/impl/MovielensDataset.java
@@ -20,7 +20,6 @@
 
 package moa.recommender.dataset.impl;
 
-import moa.recommender.dataset.Dataset;
 import java.io.BufferedReader;
 import java.io.DataInputStream;
 import java.io.FileInputStream;
@@ -29,9 +28,12 @@
 import java.io.InputStreamReader;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+
+import com.github.javacliparser.FileOption;
+
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.FileOption;
+import moa.recommender.dataset.Dataset;
 import moa.tasks.TaskMonitor;
 
 public class MovielensDataset extends AbstractOptionHandler implements Dataset {
diff --git a/moa/src/main/java/moa/recommender/predictor/BRISMFPredictor.java b/moa/src/main/java/moa/recommender/predictor/BRISMFPredictor.java
index 69932b399..8d69c8450 100644
--- a/moa/src/main/java/moa/recommender/predictor/BRISMFPredictor.java
+++ b/moa/src/main/java/moa/recommender/predictor/BRISMFPredictor.java
@@ -21,11 +21,13 @@
 package moa.recommender.predictor;
 
 import java.util.List;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.options.ClassOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
 import moa.recommender.data.RecommenderData;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/recommender/predictor/BaselinePredictor.java b/moa/src/main/java/moa/recommender/predictor/BaselinePredictor.java
index 3433ff24b..1ca885c1e 100644
--- a/moa/src/main/java/moa/recommender/predictor/BaselinePredictor.java
+++ b/moa/src/main/java/moa/recommender/predictor/BaselinePredictor.java
@@ -21,6 +21,7 @@
 package moa.recommender.predictor;
 
 import java.util.List;
+
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.options.ClassOption;
diff --git a/moa/src/main/java/moa/recommender/predictor/RatingPredictor.java b/moa/src/main/java/moa/recommender/predictor/RatingPredictor.java
index 911864980..839821251 100644
--- a/moa/src/main/java/moa/recommender/predictor/RatingPredictor.java
+++ b/moa/src/main/java/moa/recommender/predictor/RatingPredictor.java
@@ -22,6 +22,7 @@
 
 import java.io.Serializable;
 import java.util.List;
+
 import moa.recommender.rc.data.RecommenderData;
 
 /**
diff --git a/moa/src/main/java/moa/recommender/rc/data/AbstractRecommenderData.java b/moa/src/main/java/moa/recommender/rc/data/AbstractRecommenderData.java
index b3d6cab0b..8c755448f 100644
--- a/moa/src/main/java/moa/recommender/rc/data/AbstractRecommenderData.java
+++ b/moa/src/main/java/moa/recommender/rc/data/AbstractRecommenderData.java
@@ -23,6 +23,7 @@
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
+
 import moa.recommender.rc.utils.Updatable;
 
 
diff --git a/moa/src/main/java/moa/recommender/rc/data/RecommenderData.java b/moa/src/main/java/moa/recommender/rc/data/RecommenderData.java
index 455f29f5c..d986dcee2 100644
--- a/moa/src/main/java/moa/recommender/rc/data/RecommenderData.java
+++ b/moa/src/main/java/moa/recommender/rc/data/RecommenderData.java
@@ -24,6 +24,7 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
+
 import moa.recommender.rc.utils.Rating;
 import moa.recommender.rc.utils.SparseVector;
 import moa.recommender.rc.utils.Updatable;
diff --git a/moa/src/main/java/moa/recommender/rc/data/impl/MemRecommenderData.java b/moa/src/main/java/moa/recommender/rc/data/impl/MemRecommenderData.java
index 9e61cbe83..af9b55f9c 100644
--- a/moa/src/main/java/moa/recommender/rc/data/impl/MemRecommenderData.java
+++ b/moa/src/main/java/moa/recommender/rc/data/impl/MemRecommenderData.java
@@ -27,6 +27,7 @@
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
+
 import moa.recommender.rc.data.AbstractRecommenderData;
 import moa.recommender.rc.utils.Rating;
 import moa.recommender.rc.utils.SparseVector;
diff --git a/moa/src/main/java/moa/recommender/rc/predictor/RatingPredictor.java b/moa/src/main/java/moa/recommender/rc/predictor/RatingPredictor.java
index d160de6f2..9033917f9 100644
--- a/moa/src/main/java/moa/recommender/rc/predictor/RatingPredictor.java
+++ b/moa/src/main/java/moa/recommender/rc/predictor/RatingPredictor.java
@@ -22,6 +22,7 @@
 
 import java.io.Serializable;
 import java.util.List;
+
 import moa.recommender.rc.data.RecommenderData;
 
 public interface RatingPredictor extends Serializable {
diff --git a/moa/src/main/java/moa/recommender/rc/predictor/impl/BRISMFPredictor.java b/moa/src/main/java/moa/recommender/rc/predictor/impl/BRISMFPredictor.java
index ccc6e1e25..936496e73 100644
--- a/moa/src/main/java/moa/recommender/rc/predictor/impl/BRISMFPredictor.java
+++ b/moa/src/main/java/moa/recommender/rc/predictor/impl/BRISMFPredictor.java
@@ -25,6 +25,7 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Random;
+
 import moa.recommender.rc.data.RecommenderData;
 import moa.recommender.rc.utils.Pair;
 import moa.recommender.rc.utils.Rating;
diff --git a/moa/src/main/java/moa/recommender/rc/predictor/impl/BaselinePredictor.java b/moa/src/main/java/moa/recommender/rc/predictor/impl/BaselinePredictor.java
index cfc22b2e2..6411ce6e9 100644
--- a/moa/src/main/java/moa/recommender/rc/predictor/impl/BaselinePredictor.java
+++ b/moa/src/main/java/moa/recommender/rc/predictor/impl/BaselinePredictor.java
@@ -22,6 +22,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+
 import moa.recommender.rc.data.RecommenderData;
 import moa.recommender.rc.predictor.RatingPredictor;
 
diff --git a/moa/src/main/java/moa/streams/ArffFileStream.java b/moa/src/main/java/moa/streams/ArffFileStream.java
index 81d639198..3161ac6ba 100644
--- a/moa/src/main/java/moa/streams/ArffFileStream.java
+++ b/moa/src/main/java/moa/streams/ArffFileStream.java
@@ -19,17 +19,17 @@
  */
 package moa.streams;
 
-import com.github.javacliparser.FileOption;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.StringOption;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import java.io.BufferedReader;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
-import java.io.Reader; 
+import java.io.Reader;
+
+import com.github.javacliparser.FileOption;
+import com.github.javacliparser.StringOption;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.core.InputStreamProgressMonitor;
 import moa.core.InstanceExample;
 import moa.core.ObjectRepository;
diff --git a/moa/src/main/java/moa/streams/CachedInstancesStream.java b/moa/src/main/java/moa/streams/CachedInstancesStream.java
index bb618fac8..bd260db04 100644
--- a/moa/src/main/java/moa/streams/CachedInstancesStream.java
+++ b/moa/src/main/java/moa/streams/CachedInstancesStream.java
@@ -19,11 +19,10 @@
  */
 package moa.streams;
 
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.AbstractMOAObject;
 import moa.core.InstanceExample;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Stream generator for representing a stream that is cached in memory.
diff --git a/moa/src/main/java/moa/streams/ConceptDriftRealStream.java b/moa/src/main/java/moa/streams/ConceptDriftRealStream.java
index 46c30398a..b0bd8b18e 100644
--- a/moa/src/main/java/moa/streams/ConceptDriftRealStream.java
+++ b/moa/src/main/java/moa/streams/ConceptDriftRealStream.java
@@ -19,24 +19,20 @@
  */
 package moa.streams;
 
+import java.util.Random;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
-import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Random;
+import moa.core.FastVector;
 import moa.core.InstanceExample;
-
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
-import moa.core.utils.AttributeDefinitionUtil;
 import moa.options.AbstractOptionHandler;
 import moa.options.ClassOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
 
 /**
diff --git a/moa/src/main/java/moa/streams/ConceptDriftStream.java b/moa/src/main/java/moa/streams/ConceptDriftStream.java
index 19ff13c49..50de9fa90 100644
--- a/moa/src/main/java/moa/streams/ConceptDriftStream.java
+++ b/moa/src/main/java/moa/streams/ConceptDriftStream.java
@@ -20,16 +20,16 @@
 package moa.streams;
 
 import java.util.Random;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.core.Example;
-import moa.core.InstanceExample;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.options.ClassOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Stream generator that adds concept drift to examples in a stream.
diff --git a/moa/src/main/java/moa/streams/ExampleStream.java b/moa/src/main/java/moa/streams/ExampleStream.java
index 20877597a..d06f4d915 100644
--- a/moa/src/main/java/moa/streams/ExampleStream.java
+++ b/moa/src/main/java/moa/streams/ExampleStream.java
@@ -19,12 +19,11 @@
  */
 package moa.streams;
 
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.MOAObject;
 import moa.core.Example;
 
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
 /**
  * Interface representing a data stream of examples. 
  *
diff --git a/moa/src/main/java/moa/streams/InstanceStream.java b/moa/src/main/java/moa/streams/InstanceStream.java
index 83e246300..530201337 100644
--- a/moa/src/main/java/moa/streams/InstanceStream.java
+++ b/moa/src/main/java/moa/streams/InstanceStream.java
@@ -19,9 +19,10 @@
  */
 package moa.streams;
 
-import moa.core.Example;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.core.Example;
+
 /**
  * Interface representing a data stream of instances. 
  *
diff --git a/moa/src/main/java/moa/streams/MultiFilteredStream.java b/moa/src/main/java/moa/streams/MultiFilteredStream.java
index befa684b6..b4247be27 100644
--- a/moa/src/main/java/moa/streams/MultiFilteredStream.java
+++ b/moa/src/main/java/moa/streams/MultiFilteredStream.java
@@ -19,18 +19,17 @@
  */
 package moa.streams;
 
+import com.github.javacliparser.ListOption;
+import com.github.javacliparser.Option;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.core.Example;
-import moa.core.InstanceExample;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.options.ClassOption;
-import com.github.javacliparser.ListOption;
-import com.github.javacliparser.Option;
 import moa.options.OptionHandler;
 import moa.streams.filters.StreamFilter;
 import moa.tasks.TaskMonitor;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Class for representing a stream that is filtered.
diff --git a/moa/src/main/java/moa/streams/MultiLabelFilteredStream.java b/moa/src/main/java/moa/streams/MultiLabelFilteredStream.java
index f7c8bdf79..dd722fc2b 100644
--- a/moa/src/main/java/moa/streams/MultiLabelFilteredStream.java
+++ b/moa/src/main/java/moa/streams/MultiLabelFilteredStream.java
@@ -28,7 +28,6 @@
 import moa.options.OptionHandler;
 import moa.streams.filters.MultiLabelStreamFilter;
 import moa.streams.filters.SelectAttributesFilter;
-import moa.streams.filters.StreamFilter;
 import moa.tasks.TaskMonitor;
 
 /**
diff --git a/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java b/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java
index 9ade14c76..54fe69cee 100644
--- a/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java
+++ b/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java
@@ -19,21 +19,6 @@
  */
 package moa.streams;
 
-import com.github.javacliparser.FileOption;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import java.io.BufferedReader;
-import java.io.FileInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.Reader; 
-import moa.core.InputStreamProgressMonitor;
-import moa.core.InstanceExample;
-import moa.core.ObjectRepository;
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
 /**
  * Stream reader of ARFF files.
  *
diff --git a/moa/src/main/java/moa/streams/MultiTargetInstanceStream.java b/moa/src/main/java/moa/streams/MultiTargetInstanceStream.java
index 6e706a8e1..6b5432c90 100644
--- a/moa/src/main/java/moa/streams/MultiTargetInstanceStream.java
+++ b/moa/src/main/java/moa/streams/MultiTargetInstanceStream.java
@@ -19,9 +19,6 @@
  */
 package moa.streams;
 
-import moa.core.Example;
-import com.yahoo.labs.samoa.instances.Instance;
-
 /**
  * Interface representing a data stream of instances. 
  *
diff --git a/moa/src/main/java/moa/streams/RecurrentConceptDriftStream.java b/moa/src/main/java/moa/streams/RecurrentConceptDriftStream.java
index 54476e78a..1082192f9 100644
--- a/moa/src/main/java/moa/streams/RecurrentConceptDriftStream.java
+++ b/moa/src/main/java/moa/streams/RecurrentConceptDriftStream.java
@@ -20,12 +20,13 @@
  */
 package moa.streams;
 
-import moa.core.Example;
 import java.util.Random;
+
+import com.github.javacliparser.IntOption;
+
+import moa.core.Example;
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.github.javacliparser.IntOption;
 
 
 
diff --git a/moa/src/main/java/moa/streams/clustering/ClusteringStream.java b/moa/src/main/java/moa/streams/clustering/ClusteringStream.java
index e7c2b4bf8..c40660b02 100644
--- a/moa/src/main/java/moa/streams/clustering/ClusteringStream.java
+++ b/moa/src/main/java/moa/streams/clustering/ClusteringStream.java
@@ -20,9 +20,10 @@
 
 package moa.streams.clustering;
 
-import moa.options.AbstractOptionHandler;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
+
+import moa.options.AbstractOptionHandler;
 import moa.streams.InstanceStream;
 
 public abstract class ClusteringStream extends AbstractOptionHandler implements InstanceStream{
diff --git a/moa/src/main/java/moa/streams/clustering/FileStream.java b/moa/src/main/java/moa/streams/clustering/FileStream.java
index bd8458fff..422fc23a1 100644
--- a/moa/src/main/java/moa/streams/clustering/FileStream.java
+++ b/moa/src/main/java/moa/streams/clustering/FileStream.java
@@ -34,23 +34,21 @@
 import java.util.Arrays;
 import java.util.HashSet;
 
-import moa.core.InputStreamProgressMonitor;
-import moa.core.InstanceExample;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import moa.core.ObjectRepository;
-import moa.core.utils.AttributeDefinitionUtil;
-
 import com.github.javacliparser.FileOption;
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.ListOption;
 import com.github.javacliparser.Option;
 import com.github.javacliparser.StringOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.core.InputStreamProgressMonitor;
+import moa.core.InstanceExample;
+import moa.core.ObjectRepository;
+import moa.core.utils.AttributeDefinitionUtil;
 import moa.tasks.TaskMonitor;
 
-import com.yahoo.labs.samoa.instances.Instance;
-
 public class FileStream extends ClusteringStream{
 
 	@Override
diff --git a/moa/src/main/java/moa/streams/clustering/RandomRBFGeneratorEvents.java b/moa/src/main/java/moa/streams/clustering/RandomRBFGeneratorEvents.java
index 84b15eebc..f26ca664e 100644
--- a/moa/src/main/java/moa/streams/clustering/RandomRBFGeneratorEvents.java
+++ b/moa/src/main/java/moa/streams/clustering/RandomRBFGeneratorEvents.java
@@ -31,23 +31,22 @@
 import java.util.Random;
 import java.util.Vector;
 
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Attribute;
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.cluster.Clustering;
 import moa.cluster.SphereCluster;
 import moa.core.AutoExpandVector;
 import moa.core.InstanceExample;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
 import moa.gui.visualization.DataPoint;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.InstanceStream;
 import moa.tasks.TaskMonitor;
-import com.yahoo.labs.samoa.instances.Attribute;
-import com.yahoo.labs.samoa.instances.DenseInstance;
-import moa.core.FastVector;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 
 public class RandomRBFGeneratorEvents extends ClusteringStream {
diff --git a/moa/src/main/java/moa/streams/clustering/SimpleCSVStream.java b/moa/src/main/java/moa/streams/clustering/SimpleCSVStream.java
index fe46621be..946b5d728 100644
--- a/moa/src/main/java/moa/streams/clustering/SimpleCSVStream.java
+++ b/moa/src/main/java/moa/streams/clustering/SimpleCSVStream.java
@@ -34,7 +34,6 @@
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import moa.core.InputStreamProgressMonitor;
 import moa.core.InstanceExample;
diff --git a/moa/src/main/java/moa/streams/filters/AbstractMultiLabelStreamFilter.java b/moa/src/main/java/moa/streams/filters/AbstractMultiLabelStreamFilter.java
index e099e7ba3..4206ba4ca 100644
--- a/moa/src/main/java/moa/streams/filters/AbstractMultiLabelStreamFilter.java
+++ b/moa/src/main/java/moa/streams/filters/AbstractMultiLabelStreamFilter.java
@@ -25,7 +25,6 @@
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.streams.ExampleStream;
-import moa.streams.InstanceStream;
 import moa.tasks.TaskMonitor;
 
 /**
diff --git a/moa/src/main/java/moa/streams/filters/AbstractStreamFilter.java b/moa/src/main/java/moa/streams/filters/AbstractStreamFilter.java
index dd6d3ffbb..29b691cc1 100644
--- a/moa/src/main/java/moa/streams/filters/AbstractStreamFilter.java
+++ b/moa/src/main/java/moa/streams/filters/AbstractStreamFilter.java
@@ -20,11 +20,11 @@
 package moa.streams.filters;
 
 import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.core.InstanceExample;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.streams.ExampleStream;
-import moa.streams.InstanceStream;
 import moa.tasks.TaskMonitor;
 
 /**
diff --git a/moa/src/main/java/moa/streams/filters/AddNoiseFilter.java b/moa/src/main/java/moa/streams/filters/AddNoiseFilter.java
index c7968e479..7787ae0b1 100644
--- a/moa/src/main/java/moa/streams/filters/AddNoiseFilter.java
+++ b/moa/src/main/java/moa/streams/filters/AddNoiseFilter.java
@@ -21,16 +21,15 @@
 
 import java.util.Random;
 
-import moa.core.AutoExpandVector;
-import moa.core.DoubleVector;
-import moa.core.GaussianEstimator;
-import moa.core.InstanceExample;
-
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.GaussianEstimator;
+
 /**
  * Filter for adding random noise to examples in a stream.
  * Noise can be added to attribute values or to class labels.
diff --git a/moa/src/main/java/moa/streams/filters/RBFFilter.java b/moa/src/main/java/moa/streams/filters/RBFFilter.java
index df300eb65..3a7e787a8 100644
--- a/moa/src/main/java/moa/streams/filters/RBFFilter.java
+++ b/moa/src/main/java/moa/streams/filters/RBFFilter.java
@@ -4,14 +4,14 @@
 import java.util.List;
 import java.util.Random;
 
-import moa.core.InstanceExample;
-
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceImpl;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.core.InstanceExample;
+
 public class RBFFilter extends AbstractStreamFilter {
 
 	/**
diff --git a/moa/src/main/java/moa/streams/filters/RemoveDiscreteAttributeFilter.java b/moa/src/main/java/moa/streams/filters/RemoveDiscreteAttributeFilter.java
index f2143f080..d5e49c595 100644
--- a/moa/src/main/java/moa/streams/filters/RemoveDiscreteAttributeFilter.java
+++ b/moa/src/main/java/moa/streams/filters/RemoveDiscreteAttributeFilter.java
@@ -21,14 +21,15 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import moa.core.InstanceExample;
-import moa.streams.InstanceStream;
+
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.SparseInstance;
+
 import moa.core.FastVector;
+import moa.core.InstanceExample;
+import moa.streams.InstanceStream;
 
 /**
  * Filter for removing discrete attributes in instances of a stream.
diff --git a/moa/src/main/java/moa/streams/filters/ReplacingMissingValuesFilter.java b/moa/src/main/java/moa/streams/filters/ReplacingMissingValuesFilter.java
index fefe7f955..718de5a27 100644
--- a/moa/src/main/java/moa/streams/filters/ReplacingMissingValuesFilter.java
+++ b/moa/src/main/java/moa/streams/filters/ReplacingMissingValuesFilter.java
@@ -19,11 +19,6 @@
  */
 package moa.streams.filters;
 
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
@@ -31,6 +26,12 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.core.InstanceExample;
 
 
diff --git a/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java b/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java
index 5270011e2..3847bb637 100644
--- a/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java
+++ b/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java
@@ -3,14 +3,14 @@
 import java.util.ArrayList;
 import java.util.List;
 
-import moa.core.InstanceExample;
-
 import com.github.javacliparser.StringOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceImpl;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.core.InstanceExample;
+
 public class SelectAttributesFilter extends AbstractMultiLabelStreamFilter implements MultiLabelStreamFilter{
 
 	/**
diff --git a/moa/src/main/java/moa/streams/filters/StreamFilter.java b/moa/src/main/java/moa/streams/filters/StreamFilter.java
index 2f866dc64..9b864d63a 100644
--- a/moa/src/main/java/moa/streams/filters/StreamFilter.java
+++ b/moa/src/main/java/moa/streams/filters/StreamFilter.java
@@ -20,6 +20,7 @@
 package moa.streams.filters;
 
 import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.streams.ExampleStream;
 
 /**
diff --git a/moa/src/main/java/moa/streams/generators/AgrawalGenerator.java b/moa/src/main/java/moa/streams/generators/AgrawalGenerator.java
index b6fd685eb..9af709ce6 100644
--- a/moa/src/main/java/moa/streams/generators/AgrawalGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/AgrawalGenerator.java
@@ -19,23 +19,20 @@
  */
 package moa.streams.generators;
 
+import java.util.Random;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
-import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
-import java.util.Random;
-import moa.core.Example;
+import moa.core.FastVector;
 import moa.core.InstanceExample;
-
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import moa.streams.ExampleStream;
 import moa.streams.InstanceStream;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/streams/generators/HyperplaneGenerator.java b/moa/src/main/java/moa/streams/generators/HyperplaneGenerator.java
index be6e6aa71..cfaac82ee 100644
--- a/moa/src/main/java/moa/streams/generators/HyperplaneGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/HyperplaneGenerator.java
@@ -20,19 +20,20 @@
 package moa.streams.generators;
 
 import java.util.Random;
+
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Attribute;
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.core.FastVector;
 import moa.core.InstanceExample;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.streams.InstanceStream;
 import moa.tasks.TaskMonitor;
-import com.yahoo.labs.samoa.instances.Attribute;
-import com.yahoo.labs.samoa.instances.DenseInstance;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Stream generator for Hyperplane data stream.
diff --git a/moa/src/main/java/moa/streams/generators/LEDGenerator.java b/moa/src/main/java/moa/streams/generators/LEDGenerator.java
index a57fb1dc1..8479c9479 100644
--- a/moa/src/main/java/moa/streams/generators/LEDGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/LEDGenerator.java
@@ -19,20 +19,19 @@
  */
 package moa.streams.generators;
 
+import java.util.Random;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
-import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
-import java.util.Random;
+import moa.core.FastVector;
 import moa.core.InstanceExample;
-
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.InstanceStream;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/streams/generators/LEDGeneratorDrift.java b/moa/src/main/java/moa/streams/generators/LEDGeneratorDrift.java
index 26ee76a89..01ab912ce 100644
--- a/moa/src/main/java/moa/streams/generators/LEDGeneratorDrift.java
+++ b/moa/src/main/java/moa/streams/generators/LEDGeneratorDrift.java
@@ -19,13 +19,13 @@
  */
 package moa.streams.generators;
 
-import moa.core.InstanceExample;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.core.InstanceExample;
 import moa.core.ObjectRepository;
-import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
 
 /**
diff --git a/moa/src/main/java/moa/streams/generators/RandomRBFGenerator.java b/moa/src/main/java/moa/streams/generators/RandomRBFGenerator.java
index cbbe0202c..fc67d6ab9 100644
--- a/moa/src/main/java/moa/streams/generators/RandomRBFGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/RandomRBFGenerator.java
@@ -19,21 +19,20 @@
  */
 package moa.streams.generators;
 
+import java.io.Serializable;
+import java.util.Random;
+
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
-import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
-import java.io.Serializable;
-import java.util.Random;
+import moa.core.FastVector;
 import moa.core.InstanceExample;
-
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.MiscUtils;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.IntOption;
 import moa.streams.InstanceStream;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/streams/generators/RandomRBFGeneratorDrift.java b/moa/src/main/java/moa/streams/generators/RandomRBFGeneratorDrift.java
index c437a4a95..abcb14e32 100644
--- a/moa/src/main/java/moa/streams/generators/RandomRBFGeneratorDrift.java
+++ b/moa/src/main/java/moa/streams/generators/RandomRBFGeneratorDrift.java
@@ -20,11 +20,11 @@
 package moa.streams.generators;
 
 import java.util.Random;
-import moa.core.InstanceExample;
 
-import com.github.javacliparser.IntOption;
 import com.github.javacliparser.FloatOption;
-import com.yahoo.labs.samoa.instances.Instance;
+import com.github.javacliparser.IntOption;
+
+import moa.core.InstanceExample;
 
 /**
  * Stream generator for a random radial basis function stream with drift.
diff --git a/moa/src/main/java/moa/streams/generators/RandomTreeGenerator.java b/moa/src/main/java/moa/streams/generators/RandomTreeGenerator.java
index 282618a02..157ce8adb 100644
--- a/moa/src/main/java/moa/streams/generators/RandomTreeGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/RandomTreeGenerator.java
@@ -19,22 +19,21 @@
  */
 package moa.streams.generators;
 
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Random;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
-import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.Random;
+import moa.core.FastVector;
 import moa.core.InstanceExample;
-
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.InstanceStream;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/streams/generators/SEAGenerator.java b/moa/src/main/java/moa/streams/generators/SEAGenerator.java
index 06da33f07..e4ede9220 100644
--- a/moa/src/main/java/moa/streams/generators/SEAGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/SEAGenerator.java
@@ -19,20 +19,19 @@
  */
 package moa.streams.generators;
 
+import java.util.Random;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
-import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
-import java.util.Random;
+import moa.core.FastVector;
 import moa.core.InstanceExample;
-
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.InstanceStream;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/streams/generators/STAGGERGenerator.java b/moa/src/main/java/moa/streams/generators/STAGGERGenerator.java
index a92118e17..def9e5ee4 100644
--- a/moa/src/main/java/moa/streams/generators/STAGGERGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/STAGGERGenerator.java
@@ -19,20 +19,19 @@
  */
 package moa.streams.generators;
 
+import java.util.Random;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
-import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
-import java.util.Random;
+import moa.core.FastVector;
 import moa.core.InstanceExample;
-
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.InstanceStream;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/streams/generators/WaveformGenerator.java b/moa/src/main/java/moa/streams/generators/WaveformGenerator.java
index f66e5b0ff..06cc45350 100644
--- a/moa/src/main/java/moa/streams/generators/WaveformGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/WaveformGenerator.java
@@ -19,20 +19,19 @@
  */
 package moa.streams.generators;
 
+import java.util.Random;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
-import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
-import java.util.Random;
+import moa.core.FastVector;
 import moa.core.InstanceExample;
-
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.InstanceStream;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/streams/generators/WaveformGeneratorDrift.java b/moa/src/main/java/moa/streams/generators/WaveformGeneratorDrift.java
index c918ad8b3..e5b17cfdb 100644
--- a/moa/src/main/java/moa/streams/generators/WaveformGeneratorDrift.java
+++ b/moa/src/main/java/moa/streams/generators/WaveformGeneratorDrift.java
@@ -20,13 +20,13 @@
  */
 package moa.streams.generators;
 
-import moa.core.InstanceExample;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.core.InstanceExample;
 import moa.core.ObjectRepository;
-import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
 
 /**
diff --git a/moa/src/main/java/moa/streams/generators/cd/AbstractConceptDriftGenerator.java b/moa/src/main/java/moa/streams/generators/cd/AbstractConceptDriftGenerator.java
index 7dd440d98..6a1ae7979 100644
--- a/moa/src/main/java/moa/streams/generators/cd/AbstractConceptDriftGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/cd/AbstractConceptDriftGenerator.java
@@ -19,15 +19,16 @@
  */
 package moa.streams.generators.cd;
 
+import java.util.ArrayList;
+import java.util.Random;
+
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import java.util.ArrayList;
-import java.util.Random;
+
 import moa.core.FastVector;
 import moa.core.InstanceExample;
 import moa.core.ObjectRepository;
diff --git a/moa/src/main/java/moa/streams/generators/cd/ConceptDriftGenerator.java b/moa/src/main/java/moa/streams/generators/cd/ConceptDriftGenerator.java
index 02ed7c229..732885aa7 100644
--- a/moa/src/main/java/moa/streams/generators/cd/ConceptDriftGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/cd/ConceptDriftGenerator.java
@@ -20,6 +20,7 @@
 package moa.streams.generators.cd;
 
 import java.util.ArrayList;
+
 import moa.streams.InstanceStream;
 import moa.streams.clustering.ClusterEvent;
 
diff --git a/moa/src/main/java/moa/streams/generators/multilabel/MetaMultilabelGenerator.java b/moa/src/main/java/moa/streams/generators/multilabel/MetaMultilabelGenerator.java
index 62536ddc5..f2ac3625e 100644
--- a/moa/src/main/java/moa/streams/generators/multilabel/MetaMultilabelGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/multilabel/MetaMultilabelGenerator.java
@@ -19,22 +19,32 @@
  */
 package moa.streams.generators.multilabel;
 
-import java.util.*;
-import moa.core.InstanceExample;
-import moa.core.MultilabelInstancesHeader;
-import moa.core.ObjectRepository;
-import moa.options.AbstractOptionHandler;
-import moa.options.ClassOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Random;
+
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
-import moa.streams.InstanceStream;
-import moa.tasks.TaskMonitor;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.SparseInstance;
+
 import moa.core.FastVector;
+import moa.core.InstanceExample;
+import moa.core.MultilabelInstancesHeader;
+import moa.core.ObjectRepository;
 import moa.core.Utils;
+import moa.options.AbstractOptionHandler;
+import moa.options.ClassOption;
+import moa.streams.InstanceStream;
+import moa.tasks.TaskMonitor;
 
 /**
  * Stream generator for multilabel data.
diff --git a/moa/src/main/java/moa/streams/generators/multilabel/MultilabelArffFileStream.java b/moa/src/main/java/moa/streams/generators/multilabel/MultilabelArffFileStream.java
index cec7e0aa4..064d4fae0 100644
--- a/moa/src/main/java/moa/streams/generators/multilabel/MultilabelArffFileStream.java
+++ b/moa/src/main/java/moa/streams/generators/multilabel/MultilabelArffFileStream.java
@@ -19,13 +19,13 @@
  */
 package moa.streams.generators.multilabel;
 
-import moa.streams.ArffFileStream;
-import moa.streams.MultiTargetInstanceStream;
-import moa.core.MultilabelInstancesHeader;
-
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.core.MultilabelInstancesHeader;
+import moa.streams.ArffFileStream;
+import moa.streams.MultiTargetInstanceStream;
+
 /**
  * Stream reader for ARFF files of multilabel data.
  *
diff --git a/moa/src/main/java/moa/tasks/CacheShuffledStream.java b/moa/src/main/java/moa/tasks/CacheShuffledStream.java
index ae50c8c53..91cf2194f 100644
--- a/moa/src/main/java/moa/tasks/CacheShuffledStream.java
+++ b/moa/src/main/java/moa/tasks/CacheShuffledStream.java
@@ -21,10 +21,11 @@
 
 import java.util.Random;
 
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.core.ObjectRepository;
 import moa.options.ClassOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.CachedInstancesStream;
 import moa.streams.InstanceStream;
 
diff --git a/moa/src/main/java/moa/tasks/ConceptDriftMainTask.java b/moa/src/main/java/moa/tasks/ConceptDriftMainTask.java
index a5841fc12..1cdfcf560 100644
--- a/moa/src/main/java/moa/tasks/ConceptDriftMainTask.java
+++ b/moa/src/main/java/moa/tasks/ConceptDriftMainTask.java
@@ -20,6 +20,7 @@
 package moa.tasks;
 
 import java.util.ArrayList;
+
 import moa.streams.clustering.ClusterEvent;
 
 public abstract class ConceptDriftMainTask extends MainTask {
diff --git a/moa/src/main/java/moa/tasks/EvaluateClustering.java b/moa/src/main/java/moa/tasks/EvaluateClustering.java
index 0fc7f4f62..df03b8498 100644
--- a/moa/src/main/java/moa/tasks/EvaluateClustering.java
+++ b/moa/src/main/java/moa/tasks/EvaluateClustering.java
@@ -8,13 +8,14 @@
  */
 package moa.tasks;
 
+import com.github.javacliparser.FileOption;
+import com.github.javacliparser.IntOption;
+
 import moa.clusterers.AbstractClusterer;
 import moa.core.ObjectRepository;
 import moa.evaluation.LearningCurve;
 import moa.gui.BatchCmd;
 import moa.options.ClassOption;
-import com.github.javacliparser.FileOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.clustering.ClusteringStream;
 
 /**
diff --git a/moa/src/main/java/moa/tasks/EvaluateConceptDrift.java b/moa/src/main/java/moa/tasks/EvaluateConceptDrift.java
index 5f268ebb4..c59a965f9 100644
--- a/moa/src/main/java/moa/tasks/EvaluateConceptDrift.java
+++ b/moa/src/main/java/moa/tasks/EvaluateConceptDrift.java
@@ -20,12 +20,14 @@
  */
 package moa.tasks;
 
-import com.github.javacliparser.FileOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.PrintStream;
+
+import com.github.javacliparser.FileOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.core.Example;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
@@ -35,7 +37,6 @@
 import moa.evaluation.LearningPerformanceEvaluator;
 import moa.learners.ChangeDetectorLearner;
 import moa.options.ClassOption;
-
 import moa.streams.clustering.ClusterEvent;
 import moa.streams.generators.cd.ConceptDriftGenerator;
 
diff --git a/moa/src/main/java/moa/tasks/EvaluateInterleavedChunks.java b/moa/src/main/java/moa/tasks/EvaluateInterleavedChunks.java
index f8c78b6bb..5ce5a1ec2 100644
--- a/moa/src/main/java/moa/tasks/EvaluateInterleavedChunks.java
+++ b/moa/src/main/java/moa/tasks/EvaluateInterleavedChunks.java
@@ -22,7 +22,12 @@
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.PrintStream;
-import moa.classifiers.Classifier;
+
+import com.github.javacliparser.FileOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.core.Example;
 import moa.core.InstanceExample;
 import moa.core.Measurement;
@@ -33,12 +38,7 @@
 import moa.evaluation.LearningPerformanceEvaluator;
 import moa.learners.Learner;
 import moa.options.ClassOption;
-import com.github.javacliparser.FileOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.ExampleStream;
-import moa.streams.InstanceStream;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public class EvaluateInterleavedChunks extends MainTask {
 
diff --git a/moa/src/main/java/moa/tasks/EvaluateInterleavedTestThenTrain.java b/moa/src/main/java/moa/tasks/EvaluateInterleavedTestThenTrain.java
index 36791f102..46f6ca2c2 100644
--- a/moa/src/main/java/moa/tasks/EvaluateInterleavedTestThenTrain.java
+++ b/moa/src/main/java/moa/tasks/EvaluateInterleavedTestThenTrain.java
@@ -23,7 +23,9 @@
 import java.io.FileOutputStream;
 import java.io.PrintStream;
 
-import moa.classifiers.Classifier;
+import com.github.javacliparser.FileOption;
+import com.github.javacliparser.IntOption;
+
 import moa.core.Example;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
@@ -33,11 +35,8 @@
 import moa.evaluation.LearningPerformanceEvaluator;
 import moa.learners.Learner;
 import moa.options.ClassOption;
-import com.github.javacliparser.FileOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.ExampleStream;
 import moa.streams.InstanceStream;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Task for evaluating a classifier on a stream by testing then training with each example in sequence.
diff --git a/moa/src/main/java/moa/tasks/EvaluateModel.java b/moa/src/main/java/moa/tasks/EvaluateModel.java
index 8a0a04cc1..9ee1feeec 100644
--- a/moa/src/main/java/moa/tasks/EvaluateModel.java
+++ b/moa/src/main/java/moa/tasks/EvaluateModel.java
@@ -22,8 +22,11 @@
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.PrintStream;
+
 import com.github.javacliparser.FileOption;
 import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.Classifier;
 import moa.core.Example;
 import moa.core.ObjectRepository;
@@ -34,7 +37,6 @@
 import moa.options.ClassOption;
 import moa.streams.ExampleStream;
 import moa.streams.InstanceStream;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Task for evaluating a static model on a stream.
diff --git a/moa/src/main/java/moa/tasks/EvaluateModelMultiTarget.java b/moa/src/main/java/moa/tasks/EvaluateModelMultiTarget.java
index df5d18631..0ef68f18f 100644
--- a/moa/src/main/java/moa/tasks/EvaluateModelMultiTarget.java
+++ b/moa/src/main/java/moa/tasks/EvaluateModelMultiTarget.java
@@ -19,12 +19,14 @@
  */
 package moa.tasks;
 
-import com.github.javacliparser.FileOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.PrintStream;
+
+import com.github.javacliparser.FileOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.Classifier;
 import moa.classifiers.MultiTargetRegressor;
 import moa.core.Example;
diff --git a/moa/src/main/java/moa/tasks/EvaluateModelRegression.java b/moa/src/main/java/moa/tasks/EvaluateModelRegression.java
index 34b57232c..3e7318e1a 100644
--- a/moa/src/main/java/moa/tasks/EvaluateModelRegression.java
+++ b/moa/src/main/java/moa/tasks/EvaluateModelRegression.java
@@ -22,13 +22,15 @@
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.PrintStream;
+
 import com.github.javacliparser.FileOption;
 import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.Classifier;
 import moa.classifiers.Regressor;
 import moa.core.Example;
 import moa.core.ObjectRepository;
-import moa.core.Utils;
 import moa.evaluation.LearningEvaluation;
 import moa.evaluation.LearningPerformanceEvaluator;
 import moa.evaluation.RegressionPerformanceEvaluator;
@@ -36,7 +38,6 @@
 import moa.options.ClassOption;
 import moa.streams.ExampleStream;
 import moa.streams.InstanceStream;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Task for evaluating a static model on a stream.
diff --git a/moa/src/main/java/moa/tasks/EvaluateOnlineRecommender.java b/moa/src/main/java/moa/tasks/EvaluateOnlineRecommender.java
index 0fbc8cb32..470382d9c 100644
--- a/moa/src/main/java/moa/tasks/EvaluateOnlineRecommender.java
+++ b/moa/src/main/java/moa/tasks/EvaluateOnlineRecommender.java
@@ -19,12 +19,13 @@
  */
 package moa.tasks;
 
+import com.github.javacliparser.IntOption;
+
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
 import moa.evaluation.LearningCurve;
 import moa.evaluation.LearningEvaluation;
 import moa.options.ClassOption;
-import com.github.javacliparser.IntOption;
 import moa.recommender.dataset.Dataset;
 import moa.recommender.predictor.RatingPredictor;
 import moa.recommender.rc.data.RecommenderData;
diff --git a/moa/src/main/java/moa/tasks/EvaluatePeriodicHeldOutTest.java b/moa/src/main/java/moa/tasks/EvaluatePeriodicHeldOutTest.java
index fac762d2f..3457c743a 100644
--- a/moa/src/main/java/moa/tasks/EvaluatePeriodicHeldOutTest.java
+++ b/moa/src/main/java/moa/tasks/EvaluatePeriodicHeldOutTest.java
@@ -25,9 +25,13 @@
 import java.io.PrintStream;
 import java.util.ArrayList;
 import java.util.List;
+
 import com.github.javacliparser.FileOption;
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.core.Example;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
@@ -40,8 +44,6 @@
 import moa.options.ClassOption;
 import moa.streams.CachedInstancesStream;
 import moa.streams.ExampleStream;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Task for evaluating a classifier on a stream by periodically testing on a heldout set.
diff --git a/moa/src/main/java/moa/tasks/EvaluatePrequential.java b/moa/src/main/java/moa/tasks/EvaluatePrequential.java
index be9e8252d..a2284a403 100644
--- a/moa/src/main/java/moa/tasks/EvaluatePrequential.java
+++ b/moa/src/main/java/moa/tasks/EvaluatePrequential.java
@@ -24,27 +24,25 @@
 import java.io.FileOutputStream;
 import java.io.PrintStream;
 
-import moa.classifiers.Classifier;
+import com.github.javacliparser.FileOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.core.Example;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
 import moa.core.TimingUtils;
-import moa.evaluation.WindowClassificationPerformanceEvaluator;
+import moa.core.Utils;
 import moa.evaluation.EWMAClassificationPerformanceEvaluator;
 import moa.evaluation.FadingFactorClassificationPerformanceEvaluator;
 import moa.evaluation.LearningCurve;
 import moa.evaluation.LearningEvaluation;
 import moa.evaluation.LearningPerformanceEvaluator;
+import moa.evaluation.WindowClassificationPerformanceEvaluator;
 import moa.learners.Learner;
 import moa.options.ClassOption;
-
-import com.github.javacliparser.FileOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.ExampleStream;
-import moa.streams.InstanceStream;
-import com.yahoo.labs.samoa.instances.Instance;
-import moa.core.Utils;
 
 /**
  * Task for evaluating a classifier on a stream by testing then training with each example in sequence.
diff --git a/moa/src/main/java/moa/tasks/EvaluatePrequentialCV.java b/moa/src/main/java/moa/tasks/EvaluatePrequentialCV.java
index 87ea7c9c7..e3eefcee4 100644
--- a/moa/src/main/java/moa/tasks/EvaluatePrequentialCV.java
+++ b/moa/src/main/java/moa/tasks/EvaluatePrequentialCV.java
@@ -20,18 +20,6 @@
  */
 package moa.tasks;
 
-import com.github.javacliparser.FileOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import moa.classifiers.Classifier;
-import moa.core.*;
-import moa.evaluation.*;
-import moa.learners.Learner;
-import moa.options.ClassOption;
-import moa.streams.ExampleStream;
-
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.PrintStream;
@@ -40,6 +28,22 @@
 import java.util.List;
 import java.util.Random;
 
+import com.github.javacliparser.FileOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+
+import moa.core.Example;
+import moa.core.Measurement;
+import moa.core.MiscUtils;
+import moa.core.ObjectRepository;
+import moa.core.TimingUtils;
+import moa.evaluation.LearningCurve;
+import moa.evaluation.LearningEvaluation;
+import moa.evaluation.LearningPerformanceEvaluator;
+import moa.learners.Learner;
+import moa.options.ClassOption;
+import moa.streams.ExampleStream;
+
 /**
  * Task for prequential cross-validation evaluation of a classifier on a stream by testing then training with each
  * example in sequence and doing cross-validation at the same time.
diff --git a/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java b/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
index 61f2ee877..22f209cfe 100644
--- a/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
+++ b/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
@@ -20,19 +20,17 @@
  */
 package moa.tasks;
 
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.PrintStream;
+
 import com.github.javacliparser.FileOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
 import com.yahoo.labs.samoa.instances.Prediction;
 
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.PrintStream;
-
 import moa.classifiers.MultiTargetRegressor;
-import moa.classifiers.Regressor;
 import moa.core.Example;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
@@ -43,7 +41,6 @@
 import moa.evaluation.LearningEvaluation;
 import moa.evaluation.LearningPerformanceEvaluator;
 import moa.evaluation.MultiTargetPerformanceEvaluator;
-import moa.evaluation.RegressionPerformanceEvaluator;
 import moa.evaluation.WindowClassificationPerformanceEvaluator;
 import moa.learners.Learner;
 import moa.options.ClassOption;
diff --git a/moa/src/main/java/moa/tasks/EvaluatePrequentialRegression.java b/moa/src/main/java/moa/tasks/EvaluatePrequentialRegression.java
index 7a3d8b059..56996cb47 100644
--- a/moa/src/main/java/moa/tasks/EvaluatePrequentialRegression.java
+++ b/moa/src/main/java/moa/tasks/EvaluatePrequentialRegression.java
@@ -24,32 +24,28 @@
 import java.io.FileOutputStream;
 import java.io.PrintStream;
 
+import com.github.javacliparser.FileOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.Prediction;
+
+import moa.classifiers.Regressor;
 import moa.core.Example;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
 import moa.core.TimingUtils;
-import moa.evaluation.WindowClassificationPerformanceEvaluator;
 import moa.evaluation.EWMAClassificationPerformanceEvaluator;
 import moa.evaluation.FadingFactorClassificationPerformanceEvaluator;
 import moa.evaluation.LearningCurve;
 import moa.evaluation.LearningEvaluation;
 import moa.evaluation.LearningPerformanceEvaluator;
+import moa.evaluation.RegressionPerformanceEvaluator;
+import moa.evaluation.WindowClassificationPerformanceEvaluator;
 import moa.learners.Learner;
 import moa.options.ClassOption;
-
-import com.github.javacliparser.FileOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-
-import moa.classifiers.Regressor;
 import moa.streams.ExampleStream;
 
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.Prediction;
-
-import moa.evaluation.RegressionPerformanceEvaluator;
-
 /**
  * Task for evaluating a classifier on a stream by testing then training with each example in sequence.
  *
diff --git a/moa/src/main/java/moa/tasks/LearnModel.java b/moa/src/main/java/moa/tasks/LearnModel.java
index a38b6f97c..b9b104300 100644
--- a/moa/src/main/java/moa/tasks/LearnModel.java
+++ b/moa/src/main/java/moa/tasks/LearnModel.java
@@ -19,11 +19,12 @@
  */
 package moa.tasks;
 
+import com.github.javacliparser.IntOption;
+
 import moa.classifiers.Classifier;
 import moa.core.ObjectRepository;
 import moa.learners.Learner;
 import moa.options.ClassOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.ExampleStream;
 import moa.streams.InstanceStream;
 
diff --git a/moa/src/main/java/moa/tasks/LearnModelMultiTarget.java b/moa/src/main/java/moa/tasks/LearnModelMultiTarget.java
index e1ce7f43f..14f30af31 100644
--- a/moa/src/main/java/moa/tasks/LearnModelMultiTarget.java
+++ b/moa/src/main/java/moa/tasks/LearnModelMultiTarget.java
@@ -20,6 +20,7 @@
 package moa.tasks;
 
 import com.github.javacliparser.IntOption;
+
 import moa.classifiers.Classifier;
 import moa.classifiers.MultiTargetRegressor;
 import moa.core.ObjectRepository;
diff --git a/moa/src/main/java/moa/tasks/LearnModelRegression.java b/moa/src/main/java/moa/tasks/LearnModelRegression.java
index 84e1cca2e..4869602e3 100644
--- a/moa/src/main/java/moa/tasks/LearnModelRegression.java
+++ b/moa/src/main/java/moa/tasks/LearnModelRegression.java
@@ -19,12 +19,13 @@
  */
 package moa.tasks;
 
+import com.github.javacliparser.IntOption;
+
 import moa.classifiers.Classifier;
+import moa.classifiers.Regressor;
 import moa.core.ObjectRepository;
 import moa.learners.Learner;
 import moa.options.ClassOption;
-import com.github.javacliparser.IntOption;
-import moa.classifiers.Regressor;
 import moa.streams.ExampleStream;
 import moa.streams.InstanceStream;
 
diff --git a/moa/src/main/java/moa/tasks/MainTask.java b/moa/src/main/java/moa/tasks/MainTask.java
index cc5498311..4a62e816f 100644
--- a/moa/src/main/java/moa/tasks/MainTask.java
+++ b/moa/src/main/java/moa/tasks/MainTask.java
@@ -23,9 +23,10 @@
 import java.io.IOException;
 import java.io.Serializable;
 
+import com.github.javacliparser.FileOption;
+
 import moa.core.ObjectRepository;
 import moa.core.SerializeUtils;
-import com.github.javacliparser.FileOption;
 
 /**
  * Abstract Main Task. All tasks that want to write their result 
diff --git a/moa/src/main/java/moa/tasks/MeasureStreamSpeed.java b/moa/src/main/java/moa/tasks/MeasureStreamSpeed.java
index 49d05a34e..2651db95c 100644
--- a/moa/src/main/java/moa/tasks/MeasureStreamSpeed.java
+++ b/moa/src/main/java/moa/tasks/MeasureStreamSpeed.java
@@ -19,14 +19,14 @@
  */
 package moa.tasks;
 
+import com.github.javacliparser.IntOption;
+
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
 import moa.core.TimingUtils;
 import moa.evaluation.LearningEvaluation;
 import moa.options.ClassOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.ExampleStream;
-import moa.streams.InstanceStream;
 
 /**
  * Task for measuring the speed of the stream.
diff --git a/moa/src/main/java/moa/tasks/MultiTargetMainTask.java b/moa/src/main/java/moa/tasks/MultiTargetMainTask.java
index 0d0797078..1b5ce701e 100644
--- a/moa/src/main/java/moa/tasks/MultiTargetMainTask.java
+++ b/moa/src/main/java/moa/tasks/MultiTargetMainTask.java
@@ -5,7 +5,7 @@
 package moa.tasks;
 
 import java.util.ArrayList;
-import moa.streams.InstanceStream;
+
 import moa.streams.clustering.ClusterEvent;
 
 /**
diff --git a/moa/src/main/java/moa/tasks/Plot.java b/moa/src/main/java/moa/tasks/Plot.java
index 8ea104707..328625433 100644
--- a/moa/src/main/java/moa/tasks/Plot.java
+++ b/moa/src/main/java/moa/tasks/Plot.java
@@ -26,7 +26,6 @@
 import java.io.IOException;
 import java.io.InputStreamReader;
 
-import moa.core.ObjectRepository;
 import com.github.javacliparser.FileOption;
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.IntOption;
@@ -34,6 +33,8 @@
 import com.github.javacliparser.MultiChoiceOption;
 import com.github.javacliparser.StringOption;
 
+import moa.core.ObjectRepository;
+
 /**
  * A task allowing to create and plot gnuplot scripts.
  * 
diff --git a/moa/src/main/java/moa/tasks/RegressionMainTask.java b/moa/src/main/java/moa/tasks/RegressionMainTask.java
index e6eeffa1f..fc45af42d 100644
--- a/moa/src/main/java/moa/tasks/RegressionMainTask.java
+++ b/moa/src/main/java/moa/tasks/RegressionMainTask.java
@@ -5,7 +5,7 @@
 package moa.tasks;
 
 import java.util.ArrayList;
-import moa.streams.InstanceStream;
+
 import moa.streams.clustering.ClusterEvent;
 
 /**
diff --git a/moa/src/main/java/moa/tasks/RunStreamTasks.java b/moa/src/main/java/moa/tasks/RunStreamTasks.java
index ded79182a..43d5621ee 100644
--- a/moa/src/main/java/moa/tasks/RunStreamTasks.java
+++ b/moa/src/main/java/moa/tasks/RunStreamTasks.java
@@ -22,6 +22,7 @@
 
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.StringOption;
+
 import moa.MOAObject;
 import moa.core.ObjectRepository;
 import moa.options.ClassOption;
diff --git a/moa/src/main/java/moa/tasks/RunTasks.java b/moa/src/main/java/moa/tasks/RunTasks.java
index 47314962b..4e79f573e 100644
--- a/moa/src/main/java/moa/tasks/RunTasks.java
+++ b/moa/src/main/java/moa/tasks/RunTasks.java
@@ -20,11 +20,12 @@
  */
 package moa.tasks;
 
-import moa.core.ObjectRepository;
-import moa.options.ClassOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.StringOption;
 
+import moa.core.ObjectRepository;
+import moa.options.ClassOption;
+
 /**
  * Task for running several experiments modifying values of parameters.
  *
diff --git a/moa/src/main/java/moa/tasks/WriteStreamToARFFFile.java b/moa/src/main/java/moa/tasks/WriteStreamToARFFFile.java
index d0f252703..314dde2ad 100644
--- a/moa/src/main/java/moa/tasks/WriteStreamToARFFFile.java
+++ b/moa/src/main/java/moa/tasks/WriteStreamToARFFFile.java
@@ -24,13 +24,12 @@
 import java.io.FileWriter;
 import java.io.Writer;
 
-import moa.core.ObjectRepository;
-import moa.options.ClassOption;
 import com.github.javacliparser.FileOption;
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.InstanceImpl;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
+
+import moa.core.ObjectRepository;
+import moa.options.ClassOption;
 import moa.streams.InstanceStream;
 
 /**
diff --git a/moa/src/main/java/weka/classifiers/meta/MOA.java b/moa/src/main/java/weka/classifiers/meta/MOA.java
index e736f1495..753969d2a 100644
--- a/moa/src/main/java/weka/classifiers/meta/MOA.java
+++ b/moa/src/main/java/weka/classifiers/meta/MOA.java
@@ -21,23 +21,23 @@
 
 package weka.classifiers.meta;
 
+import java.util.Enumeration;
+import java.util.Vector;
+
+import com.yahoo.labs.samoa.instances.WekaToSamoaInstanceConverter;
+
+import moa.classifiers.Classifier;
+import moa.classifiers.trees.DecisionStump;
+import moa.options.ClassOption;
 import weka.classifiers.UpdateableClassifier;
 import weka.core.Capabilities;
+import weka.core.Capabilities.Capability;
 import weka.core.Instance;
 import weka.core.Instances;
 import weka.core.MOAUtils;
 import weka.core.Option;
 import weka.core.RevisionUtils;
 import weka.core.Utils;
-import weka.core.Capabilities.Capability;
-
-import java.util.Enumeration;
-import java.util.Vector;
-
-import moa.classifiers.Classifier;
-import moa.classifiers.trees.DecisionStump;
-import moa.options.ClassOption;
-import com.yahoo.labs.samoa.instances.WekaToSamoaInstanceConverter;
 
 /**
  <!-- globalinfo-start -->
diff --git a/moa/src/main/java/weka/datagenerators/classifiers/classification/MOA.java b/moa/src/main/java/weka/datagenerators/classifiers/classification/MOA.java
index 50537008e..76257e8e6 100644
--- a/moa/src/main/java/weka/datagenerators/classifiers/classification/MOA.java
+++ b/moa/src/main/java/weka/datagenerators/classifiers/classification/MOA.java
@@ -22,24 +22,23 @@
 
 package weka.datagenerators.classifiers.classification;
 
-import weka.core.Instance;
-import weka.core.Instances;
-import weka.core.MOAUtils;
-import weka.core.Option;
-import weka.core.RevisionUtils;
-import weka.core.Utils;
-import weka.datagenerators.ClassificationGenerator;
-
 import java.util.Enumeration;
 import java.util.Random;
 import java.util.Vector;
 
+import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
+
 import moa.options.AbstractOptionHandler;
 import moa.options.ClassOption;
 import moa.streams.InstanceStream;
 import moa.streams.generators.LEDGenerator;
-import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
-import com.yahoo.labs.samoa.instances.WekaToSamoaInstanceConverter;
+import weka.core.Instance;
+import weka.core.Instances;
+import weka.core.MOAUtils;
+import weka.core.Option;
+import weka.core.RevisionUtils;
+import weka.core.Utils;
+import weka.datagenerators.ClassificationGenerator;
 
 /**
  <!-- globalinfo-start -->
diff --git a/moa/src/main/java/weka/gui/MOAClassOptionEditor.java b/moa/src/main/java/weka/gui/MOAClassOptionEditor.java
index 5604cf644..029f0f025 100644
--- a/moa/src/main/java/weka/gui/MOAClassOptionEditor.java
+++ b/moa/src/main/java/weka/gui/MOAClassOptionEditor.java
@@ -20,10 +20,11 @@
 import javax.swing.event.ChangeEvent;
 import javax.swing.event.ChangeListener;
 
+import com.github.javacliparser.Option;
 import com.github.javacliparser.gui.ClassOptionEditComponent;
 import com.github.javacliparser.gui.OptionsConfigurationPanel;
+
 import moa.options.ClassOption;
-import com.github.javacliparser.Option;
 
 /**
  * An editor for MOA ClassOption objects.
diff --git a/moa/src/test/java/com/yahoo/labs/samoa/instances/MultiTargetArffLoaderTest.java b/moa/src/test/java/com/yahoo/labs/samoa/instances/MultiTargetArffLoaderTest.java
index 1171e785b..adf24d539 100644
--- a/moa/src/test/java/com/yahoo/labs/samoa/instances/MultiTargetArffLoaderTest.java
+++ b/moa/src/test/java/com/yahoo/labs/samoa/instances/MultiTargetArffLoaderTest.java
@@ -1,6 +1,7 @@
 package com.yahoo.labs.samoa.instances;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 import java.io.BufferedReader;
 import java.io.FileInputStream;
@@ -9,15 +10,6 @@
 import java.io.InputStreamReader;
 import java.io.Reader;
 
-import moa.core.InputStreamProgressMonitor;
-import moa.streams.ArffFileStream;
-import moa.streams.MultiTargetArffFileStream;
-import moa.test.MoaTestCase;
-import moa.test.TmpFile;
-
-import org.junit.After;
-import org.junit.AfterClass;
-import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
 
diff --git a/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java b/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java
index 4987e2718..7cccd9e5a 100644
--- a/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java
+++ b/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java
@@ -24,6 +24,9 @@
 import java.io.InputStreamReader;
 import java.io.Reader;
 
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.core.Example;
 import moa.core.InstanceExample;
 import moa.core.Measurement;
@@ -34,9 +37,6 @@
 import moa.test.TmpFile;
 import weka.core.MOAUtils;
 
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
 /**
  * Ancestor for all classifier test cases.
  * 
@@ -130,14 +130,8 @@ protected AbstractTestHelper newTestHelper() {
 	 */
 	protected InstancesHeader load(String filename, int classIndex) {
 		InstancesHeader	result = null;
-		//ArffLoader 	loader;
-
-		//result = null;
 
 		try {
-			/*loader = new ArffLoader();
-      loader.setFile(new TmpFile(filename));
-      result = loader.getDataSet();*/ // JD: weka's ARffLoader
 			TmpFile tmp=new TmpFile(filename);
 			FileInputStream fileStream = new FileInputStream(tmp.getAbsolutePath());
 			Reader reader=new BufferedReader(new InputStreamReader(fileStream));
diff --git a/moa/src/test/java/moa/classifiers/AbstractMultipleClassifierTestCase.java b/moa/src/test/java/moa/classifiers/AbstractMultipleClassifierTestCase.java
index bbb6a231f..1c59250f4 100644
--- a/moa/src/test/java/moa/classifiers/AbstractMultipleClassifierTestCase.java
+++ b/moa/src/test/java/moa/classifiers/AbstractMultipleClassifierTestCase.java
@@ -22,7 +22,6 @@
 
 import moa.core.Example;
 import moa.evaluation.BasicClassificationPerformanceEvaluator;
-import moa.evaluation.BasicRegressionPerformanceEvaluator;
 import moa.evaluation.LearningPerformanceEvaluator;
 
 /**
diff --git a/moa/src/test/java/moa/classifiers/AbstractMultipleRegressorTestCase.java b/moa/src/test/java/moa/classifiers/AbstractMultipleRegressorTestCase.java
index 657782eed..1cfab00ef 100644
--- a/moa/src/test/java/moa/classifiers/AbstractMultipleRegressorTestCase.java
+++ b/moa/src/test/java/moa/classifiers/AbstractMultipleRegressorTestCase.java
@@ -22,7 +22,6 @@
 
 import moa.core.Example;
 import moa.evaluation.BasicRegressionPerformanceEvaluator;
-import moa.evaluation.ClassificationPerformanceEvaluator;
 import moa.evaluation.LearningPerformanceEvaluator;
 
 /**
diff --git a/moa/src/test/java/moa/classifiers/active/ActiveClassifierTest.java b/moa/src/test/java/moa/classifiers/active/ActiveClassifierTest.java
index 51cce2895..4ccc930ce 100644
--- a/moa/src/test/java/moa/classifiers/active/ActiveClassifierTest.java
+++ b/moa/src/test/java/moa/classifiers/active/ActiveClassifierTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the ActiveClassifier classifier.
diff --git a/moa/src/test/java/moa/classifiers/drift/SingleClassifierDriftTest.java b/moa/src/test/java/moa/classifiers/drift/SingleClassifierDriftTest.java
index 3fe81a73c..959679e80 100644
--- a/moa/src/test/java/moa/classifiers/drift/SingleClassifierDriftTest.java
+++ b/moa/src/test/java/moa/classifiers/drift/SingleClassifierDriftTest.java
@@ -24,7 +24,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the SingleClassifierDrift classifier.
diff --git a/moa/src/test/java/moa/classifiers/functions/MajorityClassTest.java b/moa/src/test/java/moa/classifiers/functions/MajorityClassTest.java
index c74a92408..05cd19aaa 100644
--- a/moa/src/test/java/moa/classifiers/functions/MajorityClassTest.java
+++ b/moa/src/test/java/moa/classifiers/functions/MajorityClassTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the MajorityClass classifier.
diff --git a/moa/src/test/java/moa/classifiers/functions/NoChangeTest.java b/moa/src/test/java/moa/classifiers/functions/NoChangeTest.java
index 9bb60fb75..f2a16a5ae 100644
--- a/moa/src/test/java/moa/classifiers/functions/NoChangeTest.java
+++ b/moa/src/test/java/moa/classifiers/functions/NoChangeTest.java
@@ -24,7 +24,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the NoChange classifier.
diff --git a/moa/src/test/java/moa/classifiers/functions/PerceptronTest.java b/moa/src/test/java/moa/classifiers/functions/PerceptronTest.java
index b7bf710dc..7019b4a25 100644
--- a/moa/src/test/java/moa/classifiers/functions/PerceptronTest.java
+++ b/moa/src/test/java/moa/classifiers/functions/PerceptronTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the Perceptron classifier.
diff --git a/moa/src/test/java/moa/classifiers/functions/SGDTest.java b/moa/src/test/java/moa/classifiers/functions/SGDTest.java
index 7319242a9..34f6c6783 100644
--- a/moa/src/test/java/moa/classifiers/functions/SGDTest.java
+++ b/moa/src/test/java/moa/classifiers/functions/SGDTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the SGD classifier.
diff --git a/moa/src/test/java/moa/classifiers/functions/SPegasosTest.java b/moa/src/test/java/moa/classifiers/functions/SPegasosTest.java
index 5f6d7c5d7..6586cb408 100644
--- a/moa/src/test/java/moa/classifiers/functions/SPegasosTest.java
+++ b/moa/src/test/java/moa/classifiers/functions/SPegasosTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the SPegasos classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/AccuracyUpdatedEnsembleTest.java b/moa/src/test/java/moa/classifiers/meta/AccuracyUpdatedEnsembleTest.java
index 404dbd614..54044879c 100644
--- a/moa/src/test/java/moa/classifiers/meta/AccuracyUpdatedEnsembleTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/AccuracyUpdatedEnsembleTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the AccuracyUpdatedEnsemble classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/AccuracyWeightedEnsembleTest.java b/moa/src/test/java/moa/classifiers/meta/AccuracyWeightedEnsembleTest.java
index 9a1be3d65..62aa6ff98 100644
--- a/moa/src/test/java/moa/classifiers/meta/AccuracyWeightedEnsembleTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/AccuracyWeightedEnsembleTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the AccuracyWeightedEnsemble classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/LeveragingBagTest.java b/moa/src/test/java/moa/classifiers/meta/LeveragingBagTest.java
index 901b86331..015aa68a4 100644
--- a/moa/src/test/java/moa/classifiers/meta/LeveragingBagTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/LeveragingBagTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the LeveragingBag classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/LimAttClassifierTest.java b/moa/src/test/java/moa/classifiers/meta/LimAttClassifierTest.java
index 17eaf73e3..0daec8b4b 100644
--- a/moa/src/test/java/moa/classifiers/meta/LimAttClassifierTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/LimAttClassifierTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the LimAttClassifier classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/OCBoostTest.java b/moa/src/test/java/moa/classifiers/meta/OCBoostTest.java
index 4954c654a..e536ff91c 100644
--- a/moa/src/test/java/moa/classifiers/meta/OCBoostTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/OCBoostTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the OCBoost classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/OnlineAccuracyUpdatedEnsembleTest.java b/moa/src/test/java/moa/classifiers/meta/OnlineAccuracyUpdatedEnsembleTest.java
index 984aa61fa..3b5070ad3 100644
--- a/moa/src/test/java/moa/classifiers/meta/OnlineAccuracyUpdatedEnsembleTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/OnlineAccuracyUpdatedEnsembleTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the OnlineAccuracyUpdatedEnsemble classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/OzaBagASHTTest.java b/moa/src/test/java/moa/classifiers/meta/OzaBagASHTTest.java
index 5b69c0598..531ec6b4c 100644
--- a/moa/src/test/java/moa/classifiers/meta/OzaBagASHTTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/OzaBagASHTTest.java
@@ -24,7 +24,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the OzaBagASHT classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/OzaBagAdwinTest.java b/moa/src/test/java/moa/classifiers/meta/OzaBagAdwinTest.java
index 653d4ba08..5b63754e8 100644
--- a/moa/src/test/java/moa/classifiers/meta/OzaBagAdwinTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/OzaBagAdwinTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the OzaBagAdwin classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/OzaBagTest.java b/moa/src/test/java/moa/classifiers/meta/OzaBagTest.java
index a70e900d9..8b9975880 100644
--- a/moa/src/test/java/moa/classifiers/meta/OzaBagTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/OzaBagTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the OzaBag classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/OzaBoostAdwinTest.java b/moa/src/test/java/moa/classifiers/meta/OzaBoostAdwinTest.java
index ae14a1fcb..edd191889 100644
--- a/moa/src/test/java/moa/classifiers/meta/OzaBoostAdwinTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/OzaBoostAdwinTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the OzaBoostAdwin classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/OzaBoostTest.java b/moa/src/test/java/moa/classifiers/meta/OzaBoostTest.java
index 313694835..679bb2fbe 100644
--- a/moa/src/test/java/moa/classifiers/meta/OzaBoostTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/OzaBoostTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the OzaBoost classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/TemporallyAugmentedClassifierTest.java b/moa/src/test/java/moa/classifiers/meta/TemporallyAugmentedClassifierTest.java
index 8f4b711ac..e38df4f74 100644
--- a/moa/src/test/java/moa/classifiers/meta/TemporallyAugmentedClassifierTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/TemporallyAugmentedClassifierTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the TemporallyAugmentedClassifier classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/WEKAClassifierTest.java b/moa/src/test/java/moa/classifiers/meta/WEKAClassifierTest.java
index edfb78792..cbed95b51 100644
--- a/moa/src/test/java/moa/classifiers/meta/WEKAClassifierTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/WEKAClassifierTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the WEKAClassifier classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/WeightedMajorityAlgorithmTest.java b/moa/src/test/java/moa/classifiers/meta/WeightedMajorityAlgorithmTest.java
index bbef3c0e7..16061d035 100644
--- a/moa/src/test/java/moa/classifiers/meta/WeightedMajorityAlgorithmTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/WeightedMajorityAlgorithmTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the WeightedMajorityAlgorithm classifier.
diff --git a/moa/src/test/java/moa/classifiers/rules/AMRulesRegressorTest.java b/moa/src/test/java/moa/classifiers/rules/AMRulesRegressorTest.java
index a66b6717d..b07a43514 100644
--- a/moa/src/test/java/moa/classifiers/rules/AMRulesRegressorTest.java
+++ b/moa/src/test/java/moa/classifiers/rules/AMRulesRegressorTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleRegressorTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the AMRulesRegressor classifier.
diff --git a/moa/src/test/java/moa/classifiers/rules/RuleClassifierNBayesTest.java b/moa/src/test/java/moa/classifiers/rules/RuleClassifierNBayesTest.java
index c78ed0149..ba1ac994d 100644
--- a/moa/src/test/java/moa/classifiers/rules/RuleClassifierNBayesTest.java
+++ b/moa/src/test/java/moa/classifiers/rules/RuleClassifierNBayesTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the RuleClassifierNBayes classifier.
diff --git a/moa/src/test/java/moa/classifiers/rules/RuleClassifierTest.java b/moa/src/test/java/moa/classifiers/rules/RuleClassifierTest.java
index 4660bde9b..4d5562a3e 100644
--- a/moa/src/test/java/moa/classifiers/rules/RuleClassifierTest.java
+++ b/moa/src/test/java/moa/classifiers/rules/RuleClassifierTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the RuleClassifier classifier.
diff --git a/moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/InverseErrorWeightedVoteMultiLabeLTest.java b/moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/InverseErrorWeightedVoteMultiLabeLTest.java
index b34e58063..bc3da45c5 100644
--- a/moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/InverseErrorWeightedVoteMultiLabeLTest.java
+++ b/moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/InverseErrorWeightedVoteMultiLabeLTest.java
@@ -1,7 +1,6 @@
 package moa.classifiers.rules.multilabel.core.voting;
 
-import static org.junit.Assert.*;
-import moa.classifiers.rules.core.voting.InverseErrorWeightedVote;
+import static org.junit.Assert.assertEquals;
 
 import org.junit.BeforeClass;
 import org.junit.Test;
diff --git a/moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/UniformWeightedVoteMultiLabelTest.java b/moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/UniformWeightedVoteMultiLabelTest.java
index e9f91997a..92ff6bdcb 100644
--- a/moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/UniformWeightedVoteMultiLabelTest.java
+++ b/moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/UniformWeightedVoteMultiLabelTest.java
@@ -1,10 +1,10 @@
 package moa.classifiers.rules.multilabel.core.voting;
 
+import static org.junit.Assert.assertEquals;
+
 import org.junit.BeforeClass;
 import org.junit.Test;
 
-import static org.junit.Assert.*;
-
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 
diff --git a/moa/src/test/java/moa/classifiers/trees/ASHoeffdingTreeTest.java b/moa/src/test/java/moa/classifiers/trees/ASHoeffdingTreeTest.java
index 1614cb051..4012c9652 100644
--- a/moa/src/test/java/moa/classifiers/trees/ASHoeffdingTreeTest.java
+++ b/moa/src/test/java/moa/classifiers/trees/ASHoeffdingTreeTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the ASHoeffdingTree classifier.
diff --git a/moa/src/test/java/moa/classifiers/trees/AdaHoeffdingOptionTreeTest.java b/moa/src/test/java/moa/classifiers/trees/AdaHoeffdingOptionTreeTest.java
index 3960e6d97..fd343eaea 100644
--- a/moa/src/test/java/moa/classifiers/trees/AdaHoeffdingOptionTreeTest.java
+++ b/moa/src/test/java/moa/classifiers/trees/AdaHoeffdingOptionTreeTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the AdaHoeffdingOptionTree classifier.
diff --git a/moa/src/test/java/moa/classifiers/trees/DecisionStumpTest.java b/moa/src/test/java/moa/classifiers/trees/DecisionStumpTest.java
index 1e4b3297a..407365442 100644
--- a/moa/src/test/java/moa/classifiers/trees/DecisionStumpTest.java
+++ b/moa/src/test/java/moa/classifiers/trees/DecisionStumpTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the DecisionStump classifier.
diff --git a/moa/src/test/java/moa/classifiers/trees/FIMTDDTest.java b/moa/src/test/java/moa/classifiers/trees/FIMTDDTest.java
index eb863020e..fa2876054 100644
--- a/moa/src/test/java/moa/classifiers/trees/FIMTDDTest.java
+++ b/moa/src/test/java/moa/classifiers/trees/FIMTDDTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleRegressorTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the FIMTDD classifier.
@@ -31,8 +30,7 @@
  * @author  fracpete (fracpete at waikato dot ac dot nz)
  * @version $Revision$
  */
-public class FIMTDDTest
-  extends AbstractMultipleRegressorTestCase {  
+public class FIMTDDTest extends AbstractMultipleRegressorTestCase {  
 
   /**
    * Constructs the test case. Called by subclasses.
diff --git a/moa/src/test/java/moa/classifiers/trees/HoeffdingAdaptiveTreeTest.java b/moa/src/test/java/moa/classifiers/trees/HoeffdingAdaptiveTreeTest.java
index 8729f2fe2..20312bb02 100644
--- a/moa/src/test/java/moa/classifiers/trees/HoeffdingAdaptiveTreeTest.java
+++ b/moa/src/test/java/moa/classifiers/trees/HoeffdingAdaptiveTreeTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the HoeffdingAdaptiveTree classifier.
diff --git a/moa/src/test/java/moa/classifiers/trees/HoeffdingOptionTreeTest.java b/moa/src/test/java/moa/classifiers/trees/HoeffdingOptionTreeTest.java
index 1af0b309d..b0ab7fe1c 100644
--- a/moa/src/test/java/moa/classifiers/trees/HoeffdingOptionTreeTest.java
+++ b/moa/src/test/java/moa/classifiers/trees/HoeffdingOptionTreeTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the HoeffdingOptionTree classifier.
diff --git a/moa/src/test/java/moa/classifiers/trees/LimAttHoeffdingTreeTest.java b/moa/src/test/java/moa/classifiers/trees/LimAttHoeffdingTreeTest.java
index 8f59fae43..e19351825 100644
--- a/moa/src/test/java/moa/classifiers/trees/LimAttHoeffdingTreeTest.java
+++ b/moa/src/test/java/moa/classifiers/trees/LimAttHoeffdingTreeTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the LimAttHoeffdingTree classifier.
diff --git a/moa/src/test/java/moa/classifiers/trees/ORTOTest.java b/moa/src/test/java/moa/classifiers/trees/ORTOTest.java
index fd83e41f0..d9ff53950 100644
--- a/moa/src/test/java/moa/classifiers/trees/ORTOTest.java
+++ b/moa/src/test/java/moa/classifiers/trees/ORTOTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleRegressorTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the ORTO classifier.
diff --git a/moa/src/test/java/moa/classifiers/trees/RandomHoeffdingTreeTest.java b/moa/src/test/java/moa/classifiers/trees/RandomHoeffdingTreeTest.java
index 3e804b065..a08f2e4ec 100644
--- a/moa/src/test/java/moa/classifiers/trees/RandomHoeffdingTreeTest.java
+++ b/moa/src/test/java/moa/classifiers/trees/RandomHoeffdingTreeTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the RandomHoeffdingTree classifier.
diff --git a/moa/src/test/java/moa/integration/SimpleClusterTest.java b/moa/src/test/java/moa/integration/SimpleClusterTest.java
index 678627b38..4ac287d82 100644
--- a/moa/src/test/java/moa/integration/SimpleClusterTest.java
+++ b/moa/src/test/java/moa/integration/SimpleClusterTest.java
@@ -1,5 +1,11 @@
 package moa.integration;
 
+import org.junit.Test;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.Option;
+
 import junit.framework.TestCase;
 import moa.core.Globals;
 import moa.core.Measurement;
@@ -10,12 +16,6 @@
 import moa.tasks.Task;
 import moa.tasks.TaskThread;
 
-import org.junit.Test;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.Option;
-
 /* test that all clusterers run, i.e., do not die on simpe input **/
 public class SimpleClusterTest extends TestCase {
 
diff --git a/moa/src/test/java/moa/streams/filters/SelectAttributesFilterTest.java b/moa/src/test/java/moa/streams/filters/SelectAttributesFilterTest.java
index 02ee87bf6..86cf29292 100644
--- a/moa/src/test/java/moa/streams/filters/SelectAttributesFilterTest.java
+++ b/moa/src/test/java/moa/streams/filters/SelectAttributesFilterTest.java
@@ -2,14 +2,13 @@
 
 import static org.junit.Assert.assertEquals;
 
-import moa.streams.ArffFileStream;
-import moa.streams.MultiTargetArffFileStream;
-
 import org.junit.BeforeClass;
 import org.junit.Test;
 
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.streams.ArffFileStream;
+
 public class SelectAttributesFilterTest {
 	private static double EPS=0.00000001;
 	private static SelectAttributesFilter filter;
diff --git a/weka-package/.settings/org.eclipse.jdt.core.prefs b/weka-package/.settings/org.eclipse.jdt.core.prefs
index 60105c1b9..6e80039d3 100644
--- a/weka-package/.settings/org.eclipse.jdt.core.prefs
+++ b/weka-package/.settings/org.eclipse.jdt.core.prefs
@@ -1,5 +1,8 @@
 eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
-org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
 org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
-org.eclipse.jdt.core.compiler.source=1.6
+org.eclipse.jdt.core.compiler.source=1.8

From 16f12141682965aa076cd33a57a5f96246acbd9c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aosojnik@gmail.com>
Date: Tue, 13 Jun 2017 11:58:39 +0200
Subject: [PATCH 15/33] Commit before cleanup

---
 moa/.classpath                                |  2 +-
 .../instances/FeatureRelevanceResult.java     | 14 +++++++
 .../java/moa/classifiers/meta/OzaBag.java     |  3 +-
 .../moa/classifiers/meta/OzaBagAdwin.java     |  3 +-
 .../trees/{FIMTDD.java => FIMTDD2.java}       | 40 ++++++++++++++-----
 .../trees/{ORTO.java => ORTO2.java}           |  8 ++--
 .../tasks/EvaluatePrequentialRegression.java  |  2 +-
 .../java/moa/tasks/LearnModelRegression.java  |  2 +-
 .../moa/classifiers/trees/FIMTDDTest.java     |  2 +-
 .../java/moa/classifiers/trees/ORTOTest.java  |  2 +-
 weka-package/.classpath                       |  2 +-
 11 files changed, 57 insertions(+), 23 deletions(-)
 create mode 100644 moa/src/main/java/com/yahoo/labs/samoa/instances/FeatureRelevanceResult.java
 rename moa/src/main/java/moa/classifiers/trees/{FIMTDD.java => FIMTDD2.java} (96%)
 rename moa/src/main/java/moa/classifiers/trees/{ORTO.java => ORTO2.java} (98%)

diff --git a/moa/.classpath b/moa/.classpath
index 534b5e52f..fae1a2b37 100644
--- a/moa/.classpath
+++ b/moa/.classpath
@@ -22,7 +22,7 @@
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6">
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
 		<attributes>
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/FeatureRelevanceResult.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/FeatureRelevanceResult.java
new file mode 100644
index 000000000..cc29c97d4
--- /dev/null
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/FeatureRelevanceResult.java
@@ -0,0 +1,14 @@
+package com.yahoo.labs.samoa.instances;
+
+import java.util.List;
+
+public interface FeatureRelevanceResult {
+	public void addFeature(Attribute attr);
+	
+	public void setFeatureRelevance(Attribute attr, double relevance);
+	
+	public double getFeatureRelevance(Attribute attr);
+	
+	public List<Attribute> getFeatures();
+
+}
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBag.java b/moa/src/main/java/moa/classifiers/meta/OzaBag.java
index d43f2da0b..2cc5000cc 100644
--- a/moa/src/main/java/moa/classifiers/meta/OzaBag.java
+++ b/moa/src/main/java/moa/classifiers/meta/OzaBag.java
@@ -24,6 +24,7 @@
 
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
+import moa.classifiers.Regressor;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.MiscUtils;
@@ -49,7 +50,7 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class OzaBag extends AbstractClassifier {
+public class OzaBag extends AbstractClassifier implements Regressor, Classifier {
 
     @Override
     public String getPurposeString() {
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBagAdwin.java b/moa/src/main/java/moa/classifiers/meta/OzaBagAdwin.java
index 8f790f339..f88027cfe 100644
--- a/moa/src/main/java/moa/classifiers/meta/OzaBagAdwin.java
+++ b/moa/src/main/java/moa/classifiers/meta/OzaBagAdwin.java
@@ -24,6 +24,7 @@
 
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
+import moa.classifiers.Regressor;
 import moa.classifiers.core.driftdetection.ADWIN;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
@@ -79,7 +80,7 @@
  * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
  * @version $Revision: 7 $
  */
-public class OzaBagAdwin extends AbstractClassifier {
+public class OzaBagAdwin extends AbstractClassifier implements Classifier, Regressor {
 
     private static final long serialVersionUID = 1L;
 
diff --git a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java b/moa/src/main/java/moa/classifiers/trees/FIMTDD2.java
similarity index 96%
rename from moa/src/main/java/moa/classifiers/trees/FIMTDD.java
rename to moa/src/main/java/moa/classifiers/trees/FIMTDD2.java
index 8962cd12c..f98be75d8 100644
--- a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
+++ b/moa/src/main/java/moa/classifiers/trees/FIMTDD2.java
@@ -48,14 +48,14 @@
  * Implementation of FIMTDD, regression and model trees for data streams.
  */
 
-public class FIMTDD extends AbstractClassifier implements Regressor {
+public class FIMTDD2 extends AbstractClassifier implements Regressor {
 
 	private static final long serialVersionUID = 1L;
 
 	public Node treeRoot;
 
-	protected int leafNodeCount = 0;
-	protected int splitNodeCount = 0;
+	public int leafNodeCount = 0;
+	public int splitNodeCount = 0;
 
 	protected double examplesSeen = 0.0;
 	protected double sumOfValues = 0.0;
@@ -117,6 +117,10 @@ public class FIMTDD extends AbstractClassifier implements Regressor {
 
 	public FlagOption learningRatioConstOption = new FlagOption(
 			"learningRatioConst", 'p', "Keep learning rate constant instead of decaying.");
+	
+	public IntOption maxDepthOption = new IntOption(
+			"maxDepthFactor", 'b', "The maximum depth of the tree.",
+			Integer.MAX_VALUE, 0, Integer.MAX_VALUE);
 
 	//endregion ================ OPTIONS ================
 
@@ -128,7 +132,7 @@ public abstract static class Node extends AbstractMOAObject {
 
 		public int ID;
 
-		protected FIMTDD tree;
+		protected FIMTDD2 tree;
 		
 		protected boolean changeDetection = true;
 		
@@ -147,7 +151,7 @@ public abstract static class Node extends AbstractMOAObject {
 		// Sum of absolute errors
 		protected double sumOfAbsErrors; // Needed for PH tracking of mean error
 
-		public Node(FIMTDD tree) {
+		public Node(FIMTDD2 tree) {
 			this.tree = tree;
 			ID = tree.maxID; 
 		}
@@ -226,6 +230,10 @@ public int getNumSubtrees() {
 			return 1;
 		}
 
+		public int numLeaves() {
+			return 1;
+		}
+		
 		protected boolean skipInLevelCount() {
 			return false;
 		}
@@ -248,7 +256,7 @@ public static class LeafNode extends Node {
 		/**
 		 * Create a new LeafNode
 		 */
-		public LeafNode(FIMTDD tree) {
+		public LeafNode(FIMTDD2 tree) {
 			super(tree);
 			if (tree.buildingModelTree()) {
 				learningModel = tree.newLeafModel();
@@ -381,7 +389,7 @@ public double getPrediction(Instance inst) {
 		
 		public void checkForSplit(Instance inst, double prediction) {
 			// If it has seen Nmin examples since it was last tested for splitting, attempt a split of this node
-			if (examplesSeen - examplesSeenAtLastSplitEvaluation >= tree.gracePeriodOption.getValue()) {
+			if (this.getLevel() < tree.maxDepthOption.getValue() && examplesSeen - examplesSeenAtLastSplitEvaluation >= tree.gracePeriodOption.getValue()) {
 				int index = (parent != null) ? parent.getChildIndex(this) : 0;
 				tree.attemptToSplit(this, parent, index, inst, prediction);
 
@@ -421,7 +429,7 @@ public abstract static class InnerNode extends Node {
 		protected double lossSumQi;
 		protected double previousWeight = 0;
 		
-		public InnerNode(FIMTDD tree) {
+		public InnerNode(FIMTDD2 tree) {
 			super(tree);
 		}
 		
@@ -436,6 +444,12 @@ public int numChildren() {
 			return children.size();
 		}
 
+		public int numLeaves() {
+			int leaves = 0;
+			for (Node child : children) leaves += child.numLeaves();
+			return leaves;
+		}
+		
 		public Node getChild(int index) {
 			return children.get(index);
 		}
@@ -516,7 +530,7 @@ public static class SplitNode extends InnerNode {
 		 * Create a new SplitNode
 		 * @param tree 
 		 */
-		public SplitNode(InstanceConditionalTest splitTest, FIMTDD tree) {
+		public SplitNode(InstanceConditionalTest splitTest, FIMTDD2 tree) {
 			super(tree);
 			this.splitTest = splitTest;
 		}
@@ -558,7 +572,7 @@ public class FIMTDDPerceptron implements Serializable {
 
 		private static final long serialVersionUID = 1L;
 		
-		protected FIMTDD tree;
+		protected FIMTDD2 tree;
 		
 		// The Perception weights 
 		protected double[] weightAttribute; 
@@ -576,7 +590,7 @@ public FIMTDDPerceptron(FIMTDDPerceptron original) {
 			instancesSeen = original.instancesSeen / 2;
 		}
 
-		public FIMTDDPerceptron(FIMTDD tree) {
+		public FIMTDDPerceptron(FIMTDD2 tree) {
 			this.tree = tree;
 			initializeWeights();
 
@@ -837,6 +851,7 @@ public void processInstance(Instance inst, Node node, double prediction, double
 							// Switch the subtrees
 							Node parent = iNode.getParent();
 
+							System.out.println("Switching trees!");
 							if (parent != null) {
 								Node replacementTree = iNode.alternateTree;
 								parent.setChild(parent.getChildIndex(iNode), replacementTree);
@@ -845,6 +860,8 @@ public void processInstance(Instance inst, Node node, double prediction, double
 								treeRoot = iNode.alternateTree;
 								treeRoot.restartChangeDetection();
 							}
+							leafNodeCount += iNode.alternateTree.numLeaves() - iNode.numLeaves();
+
 
 							currentNode = iNode.alternateTree;
 							currentNode.originalNode = null;
@@ -865,6 +882,7 @@ public void processInstance(Instance inst, Node node, double prediction, double
 
 				if (iNode.changeDetection && !inAlternate) {
 					if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+						System.out.println("CD triggered!");
 						iNode.initializeAlternateTree();
 						growthAllowed = false;
 					}
diff --git a/moa/src/main/java/moa/classifiers/trees/ORTO.java b/moa/src/main/java/moa/classifiers/trees/ORTO2.java
similarity index 98%
rename from moa/src/main/java/moa/classifiers/trees/ORTO.java
rename to moa/src/main/java/moa/classifiers/trees/ORTO2.java
index 519486b45..a2d5a263c 100644
--- a/moa/src/main/java/moa/classifiers/trees/ORTO.java
+++ b/moa/src/main/java/moa/classifiers/trees/ORTO2.java
@@ -44,7 +44,7 @@
  * Implementation of ORTO, option trees for data streams.
  */
 
-public class ORTO extends FIMTDD implements Regressor {
+public class ORTO2 extends FIMTDD2 implements Regressor {
 
 	private static final long serialVersionUID = 1L;
 
@@ -97,7 +97,7 @@ public static class OptionNode extends InnerNode {
 		protected double[] optionFFSSL;
 		protected double[] optionFFSeen;
 
-		public OptionNode(FIMTDD tree) {
+		public OptionNode(FIMTDD2 tree) {
 			super(tree);
 		}
 		
@@ -141,13 +141,13 @@ public double getPrediction(Instance inst) {
 		}
 
 		private double aggregate(double[] predictions) {
-			if (((ORTO) tree).optionNodeAggregationOption.getChosenIndex() == 0) { // Average
+			if (((ORTO2) tree).optionNodeAggregationOption.getChosenIndex() == 0) { // Average
 				double sum = 0.0;
 				for (int i = 0; i < predictions.length; i++) {
 					sum += predictions[i];
 				}
 				return sum / predictions.length;
-			} else if (((ORTO) tree).optionNodeAggregationOption.getChosenIndex() == 1) {
+			} else if (((ORTO2) tree).optionNodeAggregationOption.getChosenIndex() == 1) {
 				int d = directionForBestTree();
 				return predictions[d];
 			} else {
diff --git a/moa/src/main/java/moa/tasks/EvaluatePrequentialRegression.java b/moa/src/main/java/moa/tasks/EvaluatePrequentialRegression.java
index 56996cb47..8f0d2839a 100644
--- a/moa/src/main/java/moa/tasks/EvaluatePrequentialRegression.java
+++ b/moa/src/main/java/moa/tasks/EvaluatePrequentialRegression.java
@@ -63,7 +63,7 @@ public String getPurposeString() {
     private static final long serialVersionUID = 1L;
 
     public ClassOption learnerOption = new ClassOption("learner", 'l',
-            "Learner to train.", Regressor.class, "moa.classifiers.trees.FIMTDD");
+            "Learner to train.", Regressor.class, "moa.classifiers.trees.ORTO");
 
     public ClassOption streamOption = new ClassOption("stream", 's',
             "Stream to learn from.", ExampleStream.class,
diff --git a/moa/src/main/java/moa/tasks/LearnModelRegression.java b/moa/src/main/java/moa/tasks/LearnModelRegression.java
index 4869602e3..fd92e8453 100644
--- a/moa/src/main/java/moa/tasks/LearnModelRegression.java
+++ b/moa/src/main/java/moa/tasks/LearnModelRegression.java
@@ -45,7 +45,7 @@ public String getPurposeString() {
     private static final long serialVersionUID = 1L;
 
     public ClassOption learnerOption = new ClassOption("learner", 'l',
-            "Learner to train.", Regressor.class, "moa.classifiers.trees.FIMTDD");
+            "Learner to train.", Regressor.class, "moa.classifiers.trees.HoeffdingTree");
 
     public ClassOption streamOption = new ClassOption("stream", 's',
             "Stream to learn from.", ExampleStream.class,
diff --git a/moa/src/test/java/moa/classifiers/trees/FIMTDDTest.java b/moa/src/test/java/moa/classifiers/trees/FIMTDDTest.java
index fa2876054..dc931074a 100644
--- a/moa/src/test/java/moa/classifiers/trees/FIMTDDTest.java
+++ b/moa/src/test/java/moa/classifiers/trees/FIMTDDTest.java
@@ -50,7 +50,7 @@ public FIMTDDTest(String name) {
   @Override
   protected Classifier[] getRegressionClassifierSetups() {
     return new Classifier[]{
-	new FIMTDD(),
+	new FIMTDD2(),
     };
   }
   
diff --git a/moa/src/test/java/moa/classifiers/trees/ORTOTest.java b/moa/src/test/java/moa/classifiers/trees/ORTOTest.java
index d9ff53950..4a86c0099 100644
--- a/moa/src/test/java/moa/classifiers/trees/ORTOTest.java
+++ b/moa/src/test/java/moa/classifiers/trees/ORTOTest.java
@@ -51,7 +51,7 @@ public ORTOTest(String name) {
   @Override
   protected Classifier[] getRegressionClassifierSetups() {
     return new Classifier[]{
-	new ORTO(),
+	new ORTO2(),
     };
   }
   
diff --git a/weka-package/.classpath b/weka-package/.classpath
index fd7ad7fbd..af1430be1 100644
--- a/weka-package/.classpath
+++ b/weka-package/.classpath
@@ -12,7 +12,7 @@
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6">
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
 		<attributes>
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>

From 4d7a7a267c02889f120dcaa6078c075b6abcd5aa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Mon, 9 Nov 2015 14:33:22 +0100
Subject: [PATCH 16/33] Added some classifiers for multi-label classification

---
 .../samoa/instances/MultiLabelPrediction.java |   8 +
 .../LocalMultiTargetClassifier.java           | 145 +++++++++
 .../classifiers/multilabel/meta/MTOzaBag.java | 107 +++++++
 .../multilabel/trees/ISOUPOptionTree.java     | 277 ++++++++++++++++++
 .../tasks/EvaluatePrequentialMultiTarget.java |   7 +-
 5 files changed, 542 insertions(+), 2 deletions(-)
 create mode 100644 moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
 create mode 100644 moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
 create mode 100644 moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java

diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
index 6c53bbd1a..b5731a154 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
@@ -29,6 +29,10 @@ public MultiLabelPrediction(int numOutputAttributes) {
 		for (int i=0; i<numOutputAttributes;i++)
 			prediction[i]= new DoubleVector();
 	}
+
+	public MultiLabelPrediction(DoubleVector[] prediction) {
+		this.prediction = prediction;
+	}
 	
 	@Override
 	public int numOutputAttributes() {
@@ -108,5 +112,9 @@ public boolean hasVotesForAttribute(int outputAttributeIndex) {
     public int size() {
         return prediction.length;
     }
+    
+    public DoubleVector[] getPrediction() {
+    	return prediction;
+    }
 
 }
diff --git a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
new file mode 100644
index 000000000..f28ba2e8f
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
@@ -0,0 +1,145 @@
+package moa.classifiers.multilabel;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Vector;
+
+import com.yahoo.labs.samoa.instances.Attribute;
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
+import com.yahoo.labs.samoa.instances.Prediction;
+
+import moa.classifiers.AbstractClassifier;
+import moa.classifiers.AbstractMultiLabelLearner;
+import moa.classifiers.Classifier;
+import moa.classifiers.MultiLabelClassifier;
+import moa.classifiers.MultiTargetRegressor;
+import moa.classifiers.core.splitcriteria.SplitCriterion;
+import moa.classifiers.trees.FIMTDD;
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.learners.Learner;
+import moa.options.ClassOption;
+
+public class LocalMultiTargetClassifier extends AbstractMultiLabelLearner
+		implements MultiLabelClassifier, MultiTargetRegressor {
+
+	public ClassOption classifierOption = new ClassOption(
+			"classifier",
+			'c',
+			"Classifier to use.",
+			Classifier.class,
+			"moa.classifiers.trees.FIMTDD");
+	
+	LinkedList<Classifier> classifiers = null;
+	LinkedList<InstancesHeader> headers = null;
+	
+	@Override
+	public boolean isRandomizable() {
+		// TODO Auto-generated method stub
+		return true;
+	}
+
+	private InstancesHeader getHeader(int target) {
+		if (headers == null) 
+			makeHeaders();
+		return headers.get(target);
+	
+	}
+	
+	private void makeHeaders() {
+		if (headers == null) {
+			headers = new LinkedList<InstancesHeader>();
+			for (int target = 0; target < getModelContext().numOutputAttributes(); target++) {
+				List<Attribute> attributes = new LinkedList<Attribute>();
+				List<Integer> indexValues = new LinkedList<Integer>();
+				for (int i = 0; i < getModelContext().numInputAttributes(); i++) {
+					attributes.add(getModelContext().inputAttribute(i));
+					indexValues.add(i);
+				}
+				attributes.add(getModelContext().outputAttribute(target));
+				indexValues.add(getModelContext().numInputAttributes());
+				InstancesHeader STHeader = new InstancesHeader();
+				STHeader.setAttributes(attributes, indexValues);
+				STHeader.setClassIndex(getModelContext().numInputAttributes());
+				headers.add(STHeader);
+			}
+		}
+	}
+	
+	private Instance getSTInstance(MultiLabelInstance inst, int target) {
+		double[] instanceData = new double[getModelContext().numInputAttributes() + 1];
+		for (int i = 0; i < inst.numInputAttributes(); i++)
+			instanceData[i] = inst.valueInputAttribute(i);
+		instanceData[inst.numInputAttributes()] = inst.valueOutputAttribute(target);
+		DenseInstance STInst = new DenseInstance(inst.weight(), instanceData);
+		STInst.setDataset(getHeader(target));
+		return STInst;
+	}
+	
+	@Override
+	public void trainOnInstanceImpl(MultiLabelInstance instance) {
+		// TODO Auto-generated method stub
+		initializeClassifiers();
+		
+		for (int j = 0; j < instance.numberOutputTargets(); j++) {
+			Instance STInst = getSTInstance(instance, j);
+			
+			classifiers.get(j).trainOnInstance(STInst);
+		}
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(MultiLabelInstance inst) {
+		initializeClassifiers();
+
+		MultiLabelPrediction prediction = new MultiLabelPrediction(getModelContext().numOutputAttributes());
+		for (int j = 0; j < inst.numberOutputTargets(); j++) {
+			Instance STInst = getSTInstance(inst, j);
+			
+			prediction.setVote(j, 1, classifiers.get(j).getVotesForInstance(STInst)[0]);
+		}
+		return prediction;
+	}
+
+	@Override
+	public void resetLearningImpl() {
+		classifiers = null;
+
+	}
+
+	public void initializeClassifiers() {
+		this.classifierRandom.setSeed(1234);
+		if (classifiers == null) {
+			makeHeaders();
+			classifiers = new LinkedList<Classifier>();
+			for (int i = 0; i < getModelContext().numOutputAttributes(); i++) {
+				Classifier learner = (Classifier) getPreparedClassOption(this.classifierOption);
+				classifiers.add(learner);
+				learner.resetLearning();
+				((AbstractClassifier) learner).classifierRandom = this.classifierRandom;
+				learner.setModelContext(getHeader(i));
+			}
+		}
+	}
+	
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		for (int i =0; i < getModelContext().numOutputAttributes(); i++) {
+			out.append(getModelContext().outputAttribute(i).name() + '\n');
+			((AbstractClassifier) classifiers.get(i)).getModelDescription(out, indent);
+		}
+
+	}
+
+}
+ 
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java b/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
new file mode 100644
index 000000000..e2db81e43
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
@@ -0,0 +1,107 @@
+/*
+ *    MLOzaBag.java
+ *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
+ *    @author Jesse Read (jesse@tsc.uc3m.es)
+ * 
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *    
+ */
+package moa.classifiers.multilabel.meta;
+
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
+import com.yahoo.labs.samoa.instances.Prediction;
+
+import moa.classifiers.Classifier;
+import moa.classifiers.MultiLabelLearner;
+import moa.classifiers.MultiTargetRegressor;
+import moa.classifiers.meta.OzaBag;
+import moa.core.DoubleVector;
+import moa.core.Example;
+import moa.options.ClassOption;
+
+/**
+ * OzaBag for Multi-label data.
+ * 
+ * @author Jesse Read (jesse@tsc.uc3m.es)
+ * @version $Revision: 1 $
+ */
+public class MTOzaBag extends OzaBag implements MultiLabelLearner, MultiTargetRegressor {
+
+    public MTOzaBag() {
+    	super();
+    	this.baseLearnerOption = new ClassOption("baseLearner", 'l',
+                "Classifier to train.", MultiLabelLearner.class, "multilabel.trees.ISOUPTree");
+    	}
+	
+    @Override
+    public void resetLearningImpl() {
+        this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
+        MultiLabelLearner baseLearner = (MultiLabelLearner) getPreparedClassOption(this.baseLearnerOption);
+        baseLearner.resetLearning();
+        for (int i = 0; i < this.ensemble.length; i++) {
+            this.ensemble[i] = baseLearner.copy();
+        }
+    }
+
+    @Override
+    public void setModelContext(InstancesHeader raw_header) {
+
+        //set the multilabel model context
+        this.modelContext = raw_header;
+
+        // reset ensemble
+        this.resetLearningImpl();
+
+        for (int i = 0; i < this.ensemble.length; i++) {
+            this.ensemble[i].setModelContext(raw_header);
+            this.ensemble[i].resetLearning();
+        }
+    }
+
+    @Override // @note don't need this here
+    public boolean isRandomizable() {
+        return true;
+    }
+
+	public Prediction getPredictionForInstance(MultiLabelInstance inst) {
+		DoubleVector[][] predictions = new DoubleVector[this.ensemble.length][getModelContext().numOutputAttributes()];
+		for (int i = 0; i < this.ensemble.length; i++) {
+			Prediction basePrediction = this.ensemble[i].getPredictionForInstance(inst);
+			predictions[i] = ((MultiLabelPrediction) basePrediction).getPrediction();
+		}
+		DoubleVector[] prediction = new DoubleVector[getModelContext().numOutputAttributes()];
+		for (int j = 0; j < getModelContext().numOutputAttributes(); j++) {
+			prediction[j] = new DoubleVector();
+			for (int i = 0; i < this.ensemble.length; i++) {
+				prediction[j].addValues(predictions[i][j]);
+			}
+			prediction[j].scaleValues(1.0 / this.ensemble.length);
+		}
+		return new MultiLabelPrediction(prediction);
+	}
+
+    @Override
+    public void trainOnInstanceImpl(MultiLabelInstance instance) {
+        trainOnInstanceImpl((Instance) instance);
+    }
+    
+    @Override
+	public Prediction getPredictionForInstance(Example<Instance> example) {
+		return getPredictionForInstance((MultiLabelInstance)example.getData());
+	}
+    
+}
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java
new file mode 100644
index 000000000..93de284a0
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java
@@ -0,0 +1,277 @@
+package moa.classifiers.multilabel.trees;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+
+import moa.classifiers.multilabel.trees.ISOUPTree.LeafNode;
+import moa.classifiers.multilabel.trees.ISOUPTree.Node;
+import moa.classifiers.multilabel.trees.ISOUPTree.SplitNode;
+import moa.classifiers.trees.ORTO;
+import moa.classifiers.trees.FIMTDD.InnerNode;
+import moa.classifiers.trees.ORTO.OptionNode;
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+
+public class ISOUPOptionTree extends ISOUPTree {
+
+	private static final long serialVersionUID = 1L;
+
+	private int innerNodeCount = 0;
+	private int optionNodeCount = 0;
+
+	private int numTrees = 1;
+	
+	//region ================ OPTIONS ================
+
+	public IntOption maxTreesOption = new IntOption(
+			"maxTrees",
+			'm',
+			"The maximum number of trees contained in the option tree.",
+			10, 1, Integer.MAX_VALUE);
+
+	public IntOption maxOptionLevelOption = new IntOption(
+			"maxOptionLevel",
+			'x',
+			"The maximal depth at which option nodes can be created.",
+			10, 0, Integer.MAX_VALUE);
+
+	public FloatOption optionDecayFactorOption = new FloatOption(
+			"optionDecayFactor",
+			'z',
+			"The option decay factor that determines how many options can be selected at a given level.",
+			0.9, 0.0, 1.0);
+
+	public MultiChoiceOption optionNodeAggregationOption = new MultiChoiceOption(
+			"optionNodeAggregation",
+			'o',
+			"The aggregation method used to combine predictions in option nodes.", 
+			new String[]{"average", "bestTree"}, new String[]{"Average", "Best tree"}, 0);
+
+	public FloatOption optionFadingFactorOption = new FloatOption(
+			"optionFadingFactor",
+			'q',
+			"The fading factor used for comparing subtrees of an option node.",
+			0.9995, 0.0, 1.0);
+
+	//endregion ================ OPTIONS ================
+
+	//region ================ CLASSES ================
+	
+	public static class OptionNode extends InnerNode {
+		protected AutoExpandVector<DoubleVector> optionFFSSL;
+		protected AutoExpandVector<DoubleVector> optionFFSeen;
+		
+		public OptionNode(ISOUPTree tree) {
+			super(tree);
+		}
+
+		public void resetFF() {
+			optionFFSSL = new AutoExpandVector<DoubleVector>();
+			optionFFSeen = new AutoExpandVector<DoubleVector>();
+			for (int i = 0; i < numChildren(); i++) {
+				optionFFSSL.set(i, new DoubleVector());
+				optionFFSeen.set(i, new DoubleVector());
+				for (int j = 0; j < tree.getModelContext().numOutputAttributes(); j++) {
+					optionFFSSL.get(i).setValue(j, 0.0);
+					optionFFSeen.get(i).setValue(j, 0.0);
+				}
+			}
+		}
+		
+		public int getNumSubtrees() {
+			int num = 0;
+			for (Node child : children) {
+				num += child.getNumSubtrees();
+			}
+			return num;
+		}
+		
+		public double[] getPrediction(MultiLabelInstance inst) {
+			double[][] predictions = new double[numChildren()][tree.getModelContext().numOutputAttributes()];
+			for (int i = 0; i < numChildren(); i++) {
+				predictions[i] = getChild(i).getPrediction(inst);
+			}
+			return aggregate(predictions);
+		}
+		
+		private double[] aggregate(double[][] predictions) {
+			if (((ISOUPOptionTree) tree).optionNodeAggregationOption.getChosenIndex() == 0) { // Average
+				double[] sums = new double[tree.getModelContext().numOutputAttributes()];
+				for (int j = 0; j < tree.getModelContext().numOutputAttributes(); j++) {
+					for (int i = 0; i < numChildren(); i++) {
+						sums[j] += predictions[i][j];
+					}
+					sums[j] = sums[j] / numChildren();
+				}
+				return sums;
+			} else if (((ISOUPOptionTree) tree).optionNodeAggregationOption.getChosenIndex() == 1) {
+				int d = directionForBestTree();
+				return predictions[d];
+			} else {
+				return new double[] {};
+			}
+		}
+		
+		public int directionForBestTree() {
+			int d = 0;
+			double min = Double.MAX_VALUE;
+			for (int i = 0; i < numChildren(); i++) {
+				double avg = 0.0;
+				for (int j = 0; j < tree.getModelContext().numOutputAttributes(); j++) {
+					avg += getFFRatio(i, j);
+				}
+				avg /= tree.getModelContext().numOutputAttributes();
+				if (avg < min) {
+					min = avg;
+					d = i;
+				}
+			}
+			return d;
+		}
+		
+		public double getFFRatio(int childIndex, int targetIndex) {
+			return optionFFSSL.get(childIndex).getValue(targetIndex) / optionFFSeen.get(childIndex).getValue(targetIndex); 
+		}
+		
+		protected boolean skipInLevelCount() {
+			return true;
+		}
+	}
+	
+	//endregion ================ CLASSES ================
+	
+	//region ================ METHODS ================
+	
+	public String getPurposeString() {
+		return "Implementation of the ORTO tree as described by Ikonomovska et al.";
+	}
+
+	public void resetLearningImpl() {
+		super.resetLearningImpl();
+		this.innerNodeCount = 0;
+		this.optionNodeCount = 0;
+	}
+
+	
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[]{ 
+				new Measurement("number of subtrees", this.numTrees),
+				//new Measurement("tree size (nodes)", this.leafNodeCount + this.innerNodeCount),
+				//new Measurement("tree size (leaves)", this.leafNodeCount),
+				new Measurement("number of option nodes", this.optionNodeCount),};
+	}
+	
+	@Override
+	public void processInstance(MultiLabelInstance inst, Node node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
+		if (node instanceof OptionNode) {
+			processInstanceOptionNode(inst, (OptionNode) node, prediction, normalError, growthAllowed, inAlternate);
+		} else {
+			Node currentNode = node;
+			while (true) {
+				if (currentNode instanceof LeafNode) {
+					((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
+					break;
+				} else {
+					currentNode.examplesSeen += inst.weight();
+//					if (!inAlternate && iNode.alternateTree != null) {
+//						boolean altTree = true;
+//						double lossO = Math.pow(inst.classValue() - prediction, 2);
+//						double lossA = Math.pow(inst.classValue() - currentNode.alternateTree.getPrediction(inst), 2);
+//						
+//						iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
+//						iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
+//						iNode.lossExamplesSeen++;
+//						
+//						double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
+//						double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+//						iNode.lossSumQi += Qi;
+//						iNode.lossNumQiTests += 1;
+//						double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+//						
+//						if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
+//							iNode.previousWeight = iNode.lossExamplesSeen;
+//							if (Qi > 0) {
+//								// Switch the subtrees
+//								Node parent = currentNode.parent;
+//								
+//								if (parent != null) {
+//									Node replacementTree = iNode.alternateTree;
+//									parent.setChild(parent.getChildIndex(iNode), replacementTree);
+//									if (growthAllowed) replacementTree.restartChangeDetection();
+//								} else {
+//									treeRoot = iNode.alternateTree;
+//									treeRoot.restartChangeDetection();
+//								}
+//								optionNodeCount += currentNode.alternateTree.getNumSubtrees() - currentNode.getNumSubtrees();
+//								removeExcessTrees();
+//										
+//								currentNode = iNode.alternateTree;
+//								currentNode.originalNode = null;
+//								altTree = false;
+//							} else if (QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * alternateTreeTMinOption.getValue()) || iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()) {
+//								// Remove the alternate tree
+//								iNode.alternateTree = null;
+//								if (growthAllowed) iNode.restartChangeDetection();
+//								altTree = false;
+//							}
+//						}
+//						if (altTree) {
+//							growthAllowed = false; // this is the growth of the original tree
+//							processInstance(inst, currentNode.alternateTree, prediction, normalError, true, true); // growth is allowed in the alt tree
+//						} else if (currentNode instanceof OptionNode) {
+//							// this happens when an option node is switched into the tree
+//							for (Node child : ((OptionNode) currentNode).children) {
+//								processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed, inAlternate);
+//							}
+//							break;
+//						}
+//					}
+				
+//					if (iNode.changeDetection && !inAlternate) {
+//						if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+//							iNode.initializeAlternateTree();
+//						}
+//					}
+					if (currentNode instanceof SplitNode) {
+						currentNode = ((SplitNode) currentNode).getChild(((SplitNode) currentNode).instanceChildIndex(inst));
+					} else if (currentNode instanceof OptionNode) {
+						processInstanceOptionNode(inst, (OptionNode) currentNode, prediction, normalError, growthAllowed, inAlternate);
+						break;
+					}
+				}
+			}
+		}
+		
+	}
+	
+	public void processInstanceOptionNode(MultiLabelInstance inst, OptionNode node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
+//		if (node.changeDetection) {
+//			double error = Math.abs(prediction - inst.classValue());
+//			node.sumOfAbsErrors += error;
+//			
+//			if (((InnerNode) node).PageHinckleyTest(error - node.sumOfAbsErrors / node.examplesSeen + PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+//				node.initializeAlternateTree();
+//			}
+//		}
+
+		for (Node child : node.children) {
+			int i = node.getChildIndex(child);
+			double[] childPrediction = child.getPrediction(inst);
+			for (int j = 0; j < getModelContext().numOutputAttributes(); j++)  {
+				node.optionFFSeen.get(i).setValue(j, node.optionFFSeen.get(i).getValue(j) * optionFadingFactorOption.getValue() + 1);
+				node.optionFFSSL.get(i).setValue(j, node.optionFFSSL.get(i).getValue(j) * optionFadingFactorOption.getValue() + Math.pow(childPrediction[j] - inst.valueOutputAttribute(j), 2));
+			}
+		}
+
+		for (Node child : node.children) {
+			processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed && node.alternateTree == null, inAlternate);
+		}
+	}
+	
+	//endregion ================ METHODS ================
+
+}
diff --git a/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java b/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
index eba9b70b5..55ee5302d 100644
--- a/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
+++ b/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
@@ -202,8 +202,11 @@ protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
             Prediction prediction = learner.getPredictionForInstance(testInst);
             // Output prediction
             if (outputPredictionFile != null) {
-                double trueClass = ((Instance) trainInst.getData()).classValue();
-                outputPredictionResultStream.println(prediction + "," + trueClass);
+            	StringBuilder sb = new StringBuilder();
+            	for (int i = 0; i < ((Instance) trainInst.getData()).numOutputAttributes(); i++) {
+            		sb.append("Out " + i + ": " + ((Instance) trainInst.getData()).valueOutputAttribute(i) + " ");
+            	}
+                outputPredictionResultStream.println(prediction + "," + sb.toString());
             }
 
             //evaluator.addClassificationAttempt(trueClass, prediction, testInst.weight());

From 1cebdabef542a3e1f797a20b08ba801b4a846383 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Mon, 9 Nov 2015 14:43:19 +0100
Subject: [PATCH 17/33] Updates to multi-label methods

---
 .../samoa/instances/MultiLabelPrediction.java  |  4 ++++
 .../multilabel/LocalMultiTargetClassifier.java | 11 ++++++-----
 .../classifiers/multilabel/meta/MTOzaBag.java  | 18 ++++++++++++++++++
 3 files changed, 28 insertions(+), 5 deletions(-)

diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
index b5731a154..fbffed6ae 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
@@ -34,6 +34,10 @@ public MultiLabelPrediction(DoubleVector[] prediction) {
 		this.prediction = prediction;
 	}
 	
+	public MultiLabelPrediction(DoubleVector[] prediction) {
+		this.prediction = prediction;
+	}
+	
 	@Override
 	public int numOutputAttributes() {
 		return prediction.length;
diff --git a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
index f28ba2e8f..21c34b1dc 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
@@ -1,5 +1,6 @@
 package moa.classifiers.multilabel;
 
+import java.util.ArrayList;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Vector;
@@ -34,8 +35,8 @@ public class LocalMultiTargetClassifier extends AbstractMultiLabelLearner
 			Classifier.class,
 			"moa.classifiers.trees.FIMTDD");
 	
-	LinkedList<Classifier> classifiers = null;
-	LinkedList<InstancesHeader> headers = null;
+	ArrayList<Classifier> classifiers = null;
+	ArrayList<InstancesHeader> headers = null;
 	
 	@Override
 	public boolean isRandomizable() {
@@ -52,7 +53,7 @@ private InstancesHeader getHeader(int target) {
 	
 	private void makeHeaders() {
 		if (headers == null) {
-			headers = new LinkedList<InstancesHeader>();
+			headers = new ArrayList<InstancesHeader>();
 			for (int target = 0; target < getModelContext().numOutputAttributes(); target++) {
 				List<Attribute> attributes = new LinkedList<Attribute>();
 				List<Integer> indexValues = new LinkedList<Integer>();
@@ -115,9 +116,9 @@ public void initializeClassifiers() {
 		this.classifierRandom.setSeed(1234);
 		if (classifiers == null) {
 			makeHeaders();
-			classifiers = new LinkedList<Classifier>();
+			classifiers = new ArrayList<Classifier>();
 			for (int i = 0; i < getModelContext().numOutputAttributes(); i++) {
-				Classifier learner = (Classifier) getPreparedClassOption(this.classifierOption);
+				Classifier learner = ((Classifier) getPreparedClassOption(this.classifierOption)).copy();
 				classifiers.add(learner);
 				learner.resetLearning();
 				((AbstractClassifier) learner).classifierRandom = this.classifierRandom;
diff --git a/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java b/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
index e2db81e43..2594f61be 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
@@ -93,6 +93,24 @@ public Prediction getPredictionForInstance(MultiLabelInstance inst) {
 		}
 		return new MultiLabelPrediction(prediction);
 	}
+	
+	public Prediction getPredictionForInstanceUsingN(MultiLabelInstance inst, int n) {
+		int actual = Math.max(1, Math.min(n, this.ensemble.length));
+		DoubleVector[][] predictions = new DoubleVector[actual][getModelContext().numOutputAttributes()];
+		for (int i = 0; i < actual; i++) {
+			Prediction basePrediction = this.ensemble[i].getPredictionForInstance(inst);
+			predictions[i] = ((MultiLabelPrediction) basePrediction).getPrediction();
+		}
+		DoubleVector[] prediction = new DoubleVector[getModelContext().numOutputAttributes()];
+		for (int j = 0; j < getModelContext().numOutputAttributes(); j++) {
+			prediction[j] = new DoubleVector();
+			for (int i = 0; i < actual; i++) {
+				prediction[j].addValues(predictions[i][j]);
+			}
+			prediction[j].scaleValues(1.0 / actual);
+		}
+		return new MultiLabelPrediction(prediction);
+	}
 
     @Override
     public void trainOnInstanceImpl(MultiLabelInstance instance) {

From 12f6b0c1c44a35951b8bf07156699485767cfbec Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Mon, 9 Nov 2015 15:22:23 +0100
Subject: [PATCH 18/33] Removed merging artefacts

---
 .../samoa/instances/MultiLabelPrediction.java |   5 +-
 .../tasks/EvaluatePrequentialMultiTarget.java | 566 +++++++++---------
 2 files changed, 284 insertions(+), 287 deletions(-)

diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
index fbffed6ae..81c9b86f5 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
@@ -33,10 +33,7 @@ public MultiLabelPrediction(int numOutputAttributes) {
 	public MultiLabelPrediction(DoubleVector[] prediction) {
 		this.prediction = prediction;
 	}
-	
-	public MultiLabelPrediction(DoubleVector[] prediction) {
-		this.prediction = prediction;
-	}
+
 	
 	@Override
 	public int numOutputAttributes() {
diff --git a/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java b/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
index 55ee5302d..c7c7b5db0 100644
--- a/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
+++ b/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
@@ -1,283 +1,283 @@
-/*
- *    EvaluatePrequentialMultiTarget.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.tasks;
-
-import com.github.javacliparser.FileOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.Prediction;
-
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.PrintStream;
-
-import moa.classifiers.MultiTargetRegressor;
-import moa.classifiers.Regressor;
-import moa.core.Example;
-import moa.core.Measurement;
-import moa.core.ObjectRepository;
-import moa.core.TimingUtils;
-import moa.evaluation.EWMAClassificationPerformanceEvaluator;
-import moa.evaluation.FadingFactorClassificationPerformanceEvaluator;
-import moa.evaluation.LearningCurve;
-import moa.evaluation.LearningEvaluation;
-import moa.evaluation.LearningPerformanceEvaluator;
-import moa.evaluation.MultiTargetPerformanceEvaluator;
-import moa.evaluation.RegressionPerformanceEvaluator;
-import moa.evaluation.WindowClassificationPerformanceEvaluator;
-import moa.learners.Learner;
-import moa.options.ClassOption;
-import moa.streams.ExampleStream;
-import moa.streams.MultiTargetInstanceStream;
-
-/**
- * Task for evaluating a classifier on a stream by testing then training with each example in sequence.
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @version $Revision: 7 $
- */
-public class EvaluatePrequentialMultiTarget extends MultiTargetMainTask {
-
-    @Override
-    public String getPurposeString() {
-        return "Evaluates a classifier on a stream by testing then training with each example in sequence.";
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    public ClassOption learnerOption = new ClassOption("learner", 'l',
-           "Learner to train.", MultiTargetRegressor.class, "moa.classifiers.multitarget.functions.MultiTargetNoChange");
-
-    public ClassOption streamOption = new ClassOption("stream", 's',
-            "Stream to learn from.", MultiTargetInstanceStream.class,
-            "MultiTargetArffFileStream");
-
-    public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
-            "Classification performance evaluation method.",
-            MultiTargetPerformanceEvaluator.class,
-            "BasicMultiTargetPerformanceEvaluator");
-
-    public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
-            "Maximum number of instances to test/train on  (-1 = no limit).",
-            100000000, -1, Integer.MAX_VALUE);
-
-    public IntOption timeLimitOption = new IntOption("timeLimit", 't',
-            "Maximum number of seconds to test/train for (-1 = no limit).", -1,
-            -1, Integer.MAX_VALUE);
-
-    public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
-            'f',
-            "How many instances between samples of the learning performance.",
-            100000, 0, Integer.MAX_VALUE);
-
-    public IntOption memCheckFrequencyOption = new IntOption(
-            "memCheckFrequency", 'q',
-            "How many instances between memory bound checks.", 100000, 0,
-            Integer.MAX_VALUE);
-
-    public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
-            "File to append intermediate csv results to.", null, "csv", true);
-
-    public FileOption outputPredictionFileOption = new FileOption("outputPredictionFile", 'o',
-            "File to append output predictions to.", null, "pred", true);
-
-    //New for prequential method DEPRECATED
-    public IntOption widthOption = new IntOption("width",
-            'w', "Size of Window", 1000);
-
-    public FloatOption alphaOption = new FloatOption("alpha",
-            'a', "Fading factor or exponential smoothing factor", .01);
-    //End New for prequential methods
-
-    @Override
-    public Class<?> getTaskResultType() {
-        return LearningCurve.class;
-    }
-
-    @Override
-    protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
-        Learner learner = (Learner) getPreparedClassOption(this.learnerOption);
-        ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
-        LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
-        LearningCurve learningCurve = new LearningCurve(
-                "learning evaluation instances");
-
-        //New for prequential methods
-        if (evaluator instanceof WindowClassificationPerformanceEvaluator) {
-            //((WindowClassificationPerformanceEvaluator) evaluator).setWindowWidth(widthOption.getValue());
-            if (widthOption.getValue() != 1000) {
-                System.out.println("DEPRECATED! Use EvaluatePrequential -e (WindowClassificationPerformanceEvaluator -w " + widthOption.getValue() + ")");
-                 return learningCurve;
-            }
-        }
-        if (evaluator instanceof EWMAClassificationPerformanceEvaluator) {
-            //((EWMAClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
-            if (alphaOption.getValue() != .01) {
-                System.out.println("DEPRECATED! Use EvaluatePrequential -e (EWMAClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
-                return learningCurve;
-            }
-        }
-        if (evaluator instanceof FadingFactorClassificationPerformanceEvaluator) {
-            //((FadingFactorClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
-            if (alphaOption.getValue() != .01) {
-                System.out.println("DEPRECATED! Use EvaluatePrequential -e (FadingFactorClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
-                return learningCurve;
-            }
-        }
-        //End New for prequential methods
-
-        learner.setModelContext(stream.getHeader());
-        int maxInstances = this.instanceLimitOption.getValue();
-        long instancesProcessed = 0;
-        int maxSeconds = this.timeLimitOption.getValue();
-        int secondsElapsed = 0;
-        monitor.setCurrentActivity("Evaluating learner...", -1.0);
-
-        File dumpFile = this.dumpFileOption.getFile();
-        PrintStream immediateResultStream = null;
-        if (dumpFile != null) {
-            try {
-                if (dumpFile.exists()) {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile, true), true);
-                } else {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile), true);
-                }
-            } catch (Exception ex) {
-                throw new RuntimeException(
-                        "Unable to open immediate result file: " + dumpFile, ex);
-            }
-        }
-        //File for output predictions
-        File outputPredictionFile = this.outputPredictionFileOption.getFile();
-        PrintStream outputPredictionResultStream = null;
-        if (outputPredictionFile != null) {
-            try {
-                if (outputPredictionFile.exists()) {
-                    outputPredictionResultStream = new PrintStream(
-                            new FileOutputStream(outputPredictionFile, true), true);
-                } else {
-                    outputPredictionResultStream = new PrintStream(
-                            new FileOutputStream(outputPredictionFile), true);
-                }
-            } catch (Exception ex) {
-                throw new RuntimeException(
-                        "Unable to open prediction result file: " + outputPredictionFile, ex);
-            }
-        }
-        boolean firstDump = true;
-        boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
-        long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-        long lastEvaluateStartTime = evaluateStartTime;
-        double RAMHours = 0.0;
-        while (stream.hasMoreInstances()
-                && ((maxInstances < 0) || (instancesProcessed < maxInstances))
-                && ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
-            Example trainInst = stream.nextInstance();
-            Example testInst = (Example) trainInst; //.copy();
-            //testInst.setClassMissing();
-            //double[] prediction = learner.getVotesForInstance(testInst);
-            Prediction prediction = learner.getPredictionForInstance(testInst);
-            // Output prediction
-            if (outputPredictionFile != null) {
-            	StringBuilder sb = new StringBuilder();
-            	for (int i = 0; i < ((Instance) trainInst.getData()).numOutputAttributes(); i++) {
-            		sb.append("Out " + i + ": " + ((Instance) trainInst.getData()).valueOutputAttribute(i) + " ");
-            	}
-                outputPredictionResultStream.println(prediction + "," + sb.toString());
-            }
-
-            //evaluator.addClassificationAttempt(trueClass, prediction, testInst.weight());
-            evaluator.addResult(testInst, prediction);
-            learner.trainOnInstance(trainInst);
-            instancesProcessed++;
-            if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0
-                    || stream.hasMoreInstances() == false) {
-                long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-                double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);
-                double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);
-                double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); //GBs
-                RAMHoursIncrement *= (timeIncrement / 3600.0); //Hours
-                RAMHours += RAMHoursIncrement;
-                lastEvaluateStartTime = evaluateTime;
-                learningCurve.insertEntry(new LearningEvaluation(
-                        new Measurement[]{
-                            new Measurement(
-                            "learning evaluation instances",
-                            instancesProcessed),
-                            new Measurement(
-                            "evaluation time ("
-                            + (preciseCPUTiming ? "cpu "
-                            : "") + "seconds)",
-                            time),
-                            new Measurement(
-                            "model cost (RAM-Hours)",
-                            RAMHours)
-                        },
-                        evaluator, learner));
-
-                if (immediateResultStream != null) {
-                    if (firstDump) {
-                        immediateResultStream.println(learningCurve.headerToString());
-                        firstDump = false;
-                    }
-                    immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
-                    immediateResultStream.flush();
-                }
-            }
-            if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
-                if (monitor.taskShouldAbort()) {
-                    return null;
-                }
-                long estimatedRemainingInstances = stream.estimatedRemainingInstances();
-                if (maxInstances > 0) {
-                    long maxRemaining = maxInstances - instancesProcessed;
-                    if ((estimatedRemainingInstances < 0)
-                            || (maxRemaining < estimatedRemainingInstances)) {
-                        estimatedRemainingInstances = maxRemaining;
-                    }
-                }
-                monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
-                        : (double) instancesProcessed
-                        / (double) (instancesProcessed + estimatedRemainingInstances));
-                if (monitor.resultPreviewRequested()) {
-                    monitor.setLatestResultPreview(learningCurve.copy());
-                }
-                secondsElapsed = (int) TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread()
-                        - evaluateStartTime);
-            }
-        }
-        StringBuilder sb= new StringBuilder();
-        learner.getDescription(sb, 0);
-        System.out.println(sb.toString());
-        if (immediateResultStream != null) {
-            immediateResultStream.close();
-        }
-        if (outputPredictionResultStream != null) {
-            outputPredictionResultStream.close();
-        }
-        return learningCurve;
-    }
-}
+/*
+ *    EvaluatePrequentialMultiTarget.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *    
+ */
+package moa.tasks;
+
+import com.github.javacliparser.FileOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstanceData;
+import com.yahoo.labs.samoa.instances.Prediction;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.PrintStream;
+
+import moa.classifiers.MultiTargetRegressor;
+import moa.classifiers.Regressor;
+import moa.core.Example;
+import moa.core.Measurement;
+import moa.core.ObjectRepository;
+import moa.core.TimingUtils;
+import moa.evaluation.EWMAClassificationPerformanceEvaluator;
+import moa.evaluation.FadingFactorClassificationPerformanceEvaluator;
+import moa.evaluation.LearningCurve;
+import moa.evaluation.LearningEvaluation;
+import moa.evaluation.LearningPerformanceEvaluator;
+import moa.evaluation.MultiTargetPerformanceEvaluator;
+import moa.evaluation.RegressionPerformanceEvaluator;
+import moa.evaluation.WindowClassificationPerformanceEvaluator;
+import moa.learners.Learner;
+import moa.options.ClassOption;
+import moa.streams.ExampleStream;
+import moa.streams.MultiTargetInstanceStream;
+
+/**
+ * Task for evaluating a classifier on a stream by testing then training with each example in sequence.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @version $Revision: 7 $
+ */
+public class EvaluatePrequentialMultiTarget extends MultiTargetMainTask {
+
+    @Override
+    public String getPurposeString() {
+        return "Evaluates a classifier on a stream by testing then training with each example in sequence.";
+    }
+
+    private static final long serialVersionUID = 1L;
+
+    public ClassOption learnerOption = new ClassOption("learner", 'l',
+           "Learner to train.", MultiTargetRegressor.class, "moa.classifiers.multitarget.functions.MultiTargetNoChange");
+
+    public ClassOption streamOption = new ClassOption("stream", 's',
+            "Stream to learn from.", MultiTargetInstanceStream.class,
+            "MultiTargetArffFileStream");
+
+    public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
+            "Classification performance evaluation method.",
+            MultiTargetPerformanceEvaluator.class,
+            "BasicMultiTargetPerformanceEvaluator");
+
+    public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
+            "Maximum number of instances to test/train on  (-1 = no limit).",
+            100000000, -1, Integer.MAX_VALUE);
+
+    public IntOption timeLimitOption = new IntOption("timeLimit", 't',
+            "Maximum number of seconds to test/train for (-1 = no limit).", -1,
+            -1, Integer.MAX_VALUE);
+
+    public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
+            'f',
+            "How many instances between samples of the learning performance.",
+            100000, 0, Integer.MAX_VALUE);
+
+    public IntOption memCheckFrequencyOption = new IntOption(
+            "memCheckFrequency", 'q',
+            "How many instances between memory bound checks.", 100000, 0,
+            Integer.MAX_VALUE);
+
+    public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
+            "File to append intermediate csv results to.", null, "csv", true);
+
+    public FileOption outputPredictionFileOption = new FileOption("outputPredictionFile", 'o',
+            "File to append output predictions to.", null, "pred", true);
+
+    //New for prequential method DEPRECATED
+    public IntOption widthOption = new IntOption("width",
+            'w', "Size of Window", 1000);
+
+    public FloatOption alphaOption = new FloatOption("alpha",
+            'a', "Fading factor or exponential smoothing factor", .01);
+    //End New for prequential methods
+
+    @Override
+    public Class<?> getTaskResultType() {
+        return LearningCurve.class;
+    }
+
+    @Override
+    protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
+        Learner learner = (Learner) getPreparedClassOption(this.learnerOption);
+        ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
+        LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
+        LearningCurve learningCurve = new LearningCurve(
+                "learning evaluation instances");
+
+        //New for prequential methods
+        if (evaluator instanceof WindowClassificationPerformanceEvaluator) {
+            //((WindowClassificationPerformanceEvaluator) evaluator).setWindowWidth(widthOption.getValue());
+            if (widthOption.getValue() != 1000) {
+                System.out.println("DEPRECATED! Use EvaluatePrequential -e (WindowClassificationPerformanceEvaluator -w " + widthOption.getValue() + ")");
+                 return learningCurve;
+            }
+        }
+        if (evaluator instanceof EWMAClassificationPerformanceEvaluator) {
+            //((EWMAClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
+            if (alphaOption.getValue() != .01) {
+                System.out.println("DEPRECATED! Use EvaluatePrequential -e (EWMAClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
+                return learningCurve;
+            }
+        }
+        if (evaluator instanceof FadingFactorClassificationPerformanceEvaluator) {
+            //((FadingFactorClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
+            if (alphaOption.getValue() != .01) {
+                System.out.println("DEPRECATED! Use EvaluatePrequential -e (FadingFactorClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
+                return learningCurve;
+            }
+        }
+        //End New for prequential methods
+
+        learner.setModelContext(stream.getHeader());
+        int maxInstances = this.instanceLimitOption.getValue();
+        long instancesProcessed = 0;
+        int maxSeconds = this.timeLimitOption.getValue();
+        int secondsElapsed = 0;
+        monitor.setCurrentActivity("Evaluating learner...", -1.0);
+
+        File dumpFile = this.dumpFileOption.getFile();
+        PrintStream immediateResultStream = null;
+        if (dumpFile != null) {
+            try {
+                if (dumpFile.exists()) {
+                    immediateResultStream = new PrintStream(
+                            new FileOutputStream(dumpFile, true), true);
+                } else {
+                    immediateResultStream = new PrintStream(
+                            new FileOutputStream(dumpFile), true);
+                }
+            } catch (Exception ex) {
+                throw new RuntimeException(
+                        "Unable to open immediate result file: " + dumpFile, ex);
+            }
+        }
+        //File for output predictions
+        File outputPredictionFile = this.outputPredictionFileOption.getFile();
+        PrintStream outputPredictionResultStream = null;
+        if (outputPredictionFile != null) {
+            try {
+                if (outputPredictionFile.exists()) {
+                    outputPredictionResultStream = new PrintStream(
+                            new FileOutputStream(outputPredictionFile, true), true);
+                } else {
+                    outputPredictionResultStream = new PrintStream(
+                            new FileOutputStream(outputPredictionFile), true);
+                }
+            } catch (Exception ex) {
+                throw new RuntimeException(
+                        "Unable to open prediction result file: " + outputPredictionFile, ex);
+            }
+        }
+        boolean firstDump = true;
+        boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
+        long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+        long lastEvaluateStartTime = evaluateStartTime;
+        double RAMHours = 0.0;
+        while (stream.hasMoreInstances()
+                && ((maxInstances < 0) || (instancesProcessed < maxInstances))
+                && ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
+            Example trainInst = stream.nextInstance();
+            Example testInst = (Example) trainInst; //.copy();
+            //testInst.setClassMissing();
+            //double[] prediction = learner.getVotesForInstance(testInst);
+            Prediction prediction = learner.getPredictionForInstance(testInst);
+            // Output prediction
+            if (outputPredictionFile != null) {
+            	StringBuilder sb = new StringBuilder();
+            	for (int i = 0; i < ((Instance) trainInst.getData()).numOutputAttributes(); i++) {
+            		sb.append("Out " + i + ": " + ((Instance) trainInst.getData()).valueOutputAttribute(i) + " ");
+            	}
+                outputPredictionResultStream.println(prediction + "," + sb.toString());
+            }
+
+            //evaluator.addClassificationAttempt(trueClass, prediction, testInst.weight());
+            evaluator.addResult(testInst, prediction);
+            learner.trainOnInstance(trainInst);
+            instancesProcessed++;
+            if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0
+                    || stream.hasMoreInstances() == false) {
+                long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+                double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);
+                double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);
+                double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); //GBs
+                RAMHoursIncrement *= (timeIncrement / 3600.0); //Hours
+                RAMHours += RAMHoursIncrement;
+                lastEvaluateStartTime = evaluateTime;
+                learningCurve.insertEntry(new LearningEvaluation(
+                        new Measurement[]{
+                            new Measurement(
+                            "learning evaluation instances",
+                            instancesProcessed),
+                            new Measurement(
+                            "evaluation time ("
+                            + (preciseCPUTiming ? "cpu "
+                            : "") + "seconds)",
+                            time),
+                            new Measurement(
+                            "model cost (RAM-Hours)",
+                            RAMHours)
+                        },
+                        evaluator, learner));
+
+                if (immediateResultStream != null) {
+                    if (firstDump) {
+                        immediateResultStream.println(learningCurve.headerToString());
+                        firstDump = false;
+                    }
+                    immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
+                    immediateResultStream.flush();
+                }
+            }
+            if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
+                if (monitor.taskShouldAbort()) {
+                    return null;
+                }
+                long estimatedRemainingInstances = stream.estimatedRemainingInstances();
+                if (maxInstances > 0) {
+                    long maxRemaining = maxInstances - instancesProcessed;
+                    if ((estimatedRemainingInstances < 0)
+                            || (maxRemaining < estimatedRemainingInstances)) {
+                        estimatedRemainingInstances = maxRemaining;
+                    }
+                }
+                monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
+                        : (double) instancesProcessed
+                        / (double) (instancesProcessed + estimatedRemainingInstances));
+                if (monitor.resultPreviewRequested()) {
+                    monitor.setLatestResultPreview(learningCurve.copy());
+                }
+                secondsElapsed = (int) TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread()
+                        - evaluateStartTime);
+            }
+        }
+        StringBuilder sb= new StringBuilder();
+        learner.getDescription(sb, 0);
+        System.out.println(sb.toString());
+        if (immediateResultStream != null) {
+            immediateResultStream.close();
+        }
+        if (outputPredictionResultStream != null) {
+            outputPredictionResultStream.close();
+        }
+        return learningCurve;
+    }
+}

From 3bcb756268a2d3aa4b8f81acdbd1d8f74199cbdd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Mon, 9 Nov 2015 16:07:34 +0100
Subject: [PATCH 19/33] Additional merging artefacts fixed

---
 .../MultitargetAttributeClassObserver.java        | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 moa/src/main/java/moa/classifiers/core/attributeclassobservers/MultitargetAttributeClassObserver.java

diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/MultitargetAttributeClassObserver.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/MultitargetAttributeClassObserver.java
new file mode 100644
index 000000000..0cfc7acb6
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/MultitargetAttributeClassObserver.java
@@ -0,0 +1,15 @@
+package moa.classifiers.core.attributeclassobservers;
+
+import moa.classifiers.core.AttributeSplitSuggestion;
+import moa.classifiers.core.splitcriteria.SplitCriterion;
+import moa.core.DoubleVector;
+
+public interface MultitargetAttributeClassObserver extends AttributeClassObserver {
+
+	public void observeAttributeClassVector(double attVal, DoubleVector classVector, double weight);
+	
+    public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(
+            SplitCriterion criterion, double examlpesSeen, DoubleVector preSplitSums, DoubleVector preSplitSquares, int attIndex,
+            int numTargets, boolean binaryOnly);
+
+}

From 458ac70871477e4a06481edb8cd726e096228aa7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Mon, 9 Nov 2015 16:09:11 +0100
Subject: [PATCH 20/33] Test commit of everything

---
 .classpath                                    |  13 ++
 .project                                      |   6 +
 moa/.classpath                                |  17 +-
 moa/.settings/org.eclipse.jdt.core.prefs      |   3 +
 moa/pom.xml                                   | 149 ------------------
 .../classifiers/DecisionStumpTutorial.java    |   7 +-
 .../classifiers/multilabel/trees/.gitignore   |   1 +
 moa/src/main/java/moa/evaluation/.gitignore   |   2 +
 weka-package/pom.xml                          |  53 -------
 9 files changed, 35 insertions(+), 216 deletions(-)
 create mode 100644 .classpath
 delete mode 100755 moa/pom.xml
 create mode 100644 moa/src/main/java/moa/classifiers/multilabel/trees/.gitignore
 create mode 100644 moa/src/main/java/moa/evaluation/.gitignore
 delete mode 100644 weka-package/pom.xml

diff --git a/.classpath b/.classpath
new file mode 100644
index 000000000..dec9f005e
--- /dev/null
+++ b/.classpath
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="moa/src/examples/java"/>
+	<classpathentry kind="src" path="moa/src/main/java"/>
+	<classpathentry kind="src" path="moa/src/test/java"/>
+	<classpathentry kind="lib" path="weka-package/lib/sizeofag-1.0.0.jar"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/meka"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/weka-dev"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
+	<classpathentry kind="lib" path="/home/aljazo/Work/JARs/diffutils-1.2.1.jar"/>
+	<classpathentry kind="output" path="moa/target/classes"/>
+</classpath>
diff --git a/.project b/.project
index 76bea900b..56c2846a7 100644
--- a/.project
+++ b/.project
@@ -5,6 +5,11 @@
 	<projects>
 	</projects>
 	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
 		<buildCommand>
 			<name>org.eclipse.m2e.core.maven2Builder</name>
 			<arguments>
@@ -13,5 +18,6 @@
 	</buildSpec>
 	<natures>
 		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
 	</natures>
 </projectDescription>
diff --git a/moa/.classpath b/moa/.classpath
index 534b5e52f..f5accf223 100644
--- a/moa/.classpath
+++ b/moa/.classpath
@@ -11,26 +11,21 @@
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
-		<attributes>
-			<attribute name="optional" value="true"/>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
 	<classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources">
 		<attributes>
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6">
-		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
 	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
 		<attributes>
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
+	<classpathentry combineaccessrules="false" kind="src" path="/meka"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/weka-dev"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/weka-package"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="lib" path="/home/aljazo/Work/MT MOA/moa/weka-package/lib/sizeofag-1.0.0.jar"/>
 	<classpathentry kind="output" path="target/classes"/>
 </classpath>
diff --git a/moa/.settings/org.eclipse.jdt.core.prefs b/moa/.settings/org.eclipse.jdt.core.prefs
index 60105c1b9..69c31cd49 100644
--- a/moa/.settings/org.eclipse.jdt.core.prefs
+++ b/moa/.settings/org.eclipse.jdt.core.prefs
@@ -1,5 +1,8 @@
 eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
 org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
 org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
 org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
 org.eclipse.jdt.core.compiler.source=1.6
diff --git a/moa/pom.xml b/moa/pom.xml
deleted file mode 100755
index 11e6a9b6a..000000000
--- a/moa/pom.xml
+++ /dev/null
@@ -1,149 +0,0 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-  <modelVersion>4.0.0</modelVersion>
-
-  <parent>
-    <groupId>nz.ac.waikato.cms.moa</groupId>
-    <artifactId>moa-pom</artifactId>
-    <version>2017.10-SNAPSHOT</version>
-  </parent>
-
-  <artifactId>moa</artifactId>
-  <packaging>jar</packaging>
-
-  <name>MOA: Massive Online Analysis</name>
-  <description>
-  Massive On-line Analysis is an environment for massive data mining. MOA
-  provides a framework for data stream mining and includes tools for evaluation
-  and a collection of machine learning algorithms. Related to the WEKA project,
-  also written in Java, while scaling to more demanding problems.
-  </description>
-  <url>http://moa.cms.waikato.ac.nz/</url>
-  <organization>
-    <name>University of Waikato, Hamilton, NZ</name>
-    <url>http://www.waikato.ac.nz/</url>
-  </organization>
-  <licenses>
-    <license>
-      <name>GNU General Public License 3.0</name>
-      <url>http://www.gnu.org/licenses/gpl-3.0.txt</url>
-      <distribution>repo</distribution>
-    </license>
-  </licenses>
-
-  <developers>
-    <developer>
-      <id>abifet</id>
-      <name>Albert Bifet</name>
-      <email>abifet@waikato.ac.nz</email>
-    </developer>
-    <developer>
-      <id>rkirkby</id>
-      <name>Richard Kirkby</name>
-    </developer>
-  </developers>
-
-  <dependencies>
-    <dependency>
-      <groupId>nz.ac.waikato.cms.weka</groupId>
-      <artifactId>weka-dev</artifactId>
-    </dependency>
-
-    <dependency>
-      <groupId>com.googlecode.sizeofag</groupId>
-      <artifactId>sizeofag</artifactId>
-    </dependency>
-
-      <dependency>
-          <groupId>net.sf.meka</groupId>
-          <artifactId>meka</artifactId>
-      </dependency>
-
-    <dependency>
-      <groupId>junit</groupId>
-      <artifactId>junit</artifactId>
-      <scope>test</scope>
-    </dependency>
-    
-    <dependency>
-    <groupId>org.apache.commons</groupId>
-    <artifactId>commons-math3</artifactId>
-    <version>3.6.1</version>
-    </dependency>
-    
-    <dependency>
-      <groupId>com.googlecode.java-diff-utils</groupId>
-      <artifactId>diffutils</artifactId>
-      <version>1.2.1</version>
-      <scope>test</scope>
-    </dependency>
-  </dependencies>
-
-  <build>
-    <plugins>
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-compiler-plugin</artifactId>
-        <configuration>
-          <source>1.7</source>
-          <target>1.7</target>
-        </configuration>
-      </plugin>
-
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-jar-plugin</artifactId>
-      </plugin>
-
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-javadoc-plugin</artifactId>
-      </plugin>
-      
-      <plugin>
-        <groupId>org.codehaus.mojo</groupId>
-        <artifactId>license-maven-plugin</artifactId>
-      </plugin>
-
-      <plugin>
-        <groupId>org.codehaus.mojo</groupId>
-        <artifactId>latex-maven-plugin</artifactId>
-      </plugin>
-
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-assembly-plugin</artifactId>
-      </plugin>
-    </plugins>
-    <pluginManagement>
-    	<plugins>
-    		<!--This plugin's configuration is used to store Eclipse m2e settings only. It has no influence on the Maven build itself.-->
-    		<plugin>
-    			<groupId>org.eclipse.m2e</groupId>
-    			<artifactId>lifecycle-mapping</artifactId>
-    			<version>1.0.0</version>
-    			<configuration>
-    				<lifecycleMappingMetadata>
-    					<pluginExecutions>
-    						<pluginExecution>
-    							<pluginExecutionFilter>
-    								<groupId>org.codehaus.mojo</groupId>
-    								<artifactId>
-    									license-maven-plugin
-    								</artifactId>
-    								<versionRange>[1.1,)</versionRange>
-    								<goals>
-    									<goal>add-third-party</goal>
-    								</goals>
-    							</pluginExecutionFilter>
-    							<action>
-    								<ignore />
-    							</action>
-    						</pluginExecution>
-    					</pluginExecutions>
-    				</lifecycleMappingMetadata>
-    			</configuration>
-    		</plugin>
-    	</plugins>
-    </pluginManagement>
-  </build>
-</project>
diff --git a/moa/src/examples/java/moa/classifiers/DecisionStumpTutorial.java b/moa/src/examples/java/moa/classifiers/DecisionStumpTutorial.java
index f22f5a04b..0cabab7dc 100644
--- a/moa/src/examples/java/moa/classifiers/DecisionStumpTutorial.java
+++ b/moa/src/examples/java/moa/classifiers/DecisionStumpTutorial.java
@@ -1,7 +1,5 @@
 package moa.classifiers;
 
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
 import moa.classifiers.core.AttributeSplitSuggestion;
 import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
 import moa.classifiers.core.attributeclassobservers.GaussianNumericAttributeClassObserver;
@@ -9,8 +7,11 @@
 import moa.classifiers.core.splitcriteria.SplitCriterion;
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
-import moa.core.Measurement;
 import moa.options.ClassOption;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
+
 import com.yahoo.labs.samoa.instances.Instance;
 
 public class DecisionStumpTutorial extends AbstractClassifier {
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/.gitignore b/moa/src/main/java/moa/classifiers/multilabel/trees/.gitignore
new file mode 100644
index 000000000..8e36d7391
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/multilabel/trees/.gitignore
@@ -0,0 +1 @@
+/BaselinePerceptron.java
diff --git a/moa/src/main/java/moa/evaluation/.gitignore b/moa/src/main/java/moa/evaluation/.gitignore
new file mode 100644
index 000000000..48df8b2bf
--- /dev/null
+++ b/moa/src/main/java/moa/evaluation/.gitignore
@@ -0,0 +1,2 @@
+/MultilabelWindowClassificationPerformanceEvaluatorWithMEKAMetrics.java
+/MultiTargetWindowRegressionPerformanceEvaluator2.java
diff --git a/weka-package/pom.xml b/weka-package/pom.xml
deleted file mode 100644
index 4110e3065..000000000
--- a/weka-package/pom.xml
+++ /dev/null
@@ -1,53 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-
-  <modelVersion>4.0.0</modelVersion>
-
-  <parent>
-    <groupId>nz.ac.waikato.cms.moa</groupId>
-    <artifactId>moa-pom</artifactId>
-    <version>2017.10-SNAPSHOT</version>
-  </parent>
-
-  <artifactId>weka-package</artifactId>
-  <packaging>jar</packaging>
-
-  <name>MOA: WEKA Package</name>
-  <description>
-  Massive On-line Analysis is an environment for massive data mining. MOA provides a framework for data stream mining and includes tools for evaluation and a collection of machine learning algorithms. Related to the WEKA project, also written in Java, while scaling to more demanding problems.
-  This artifact enables you to use MOA from within WEKA.
-  </description>
-  <url>http://moa.cms.waikato.ac.nz/</url>
-  <organization>
-    <name>University of Waikato, Hamilton, NZ</name>
-    <url>http://www.waikato.ac.nz/</url>
-  </organization>
-  <licenses>
-    <license>
-      <name>GNU General Public License 3</name>
-      <url>http://www.gnu.org/licenses/gpl-3.0.txt</url>
-      <distribution>repo</distribution>
-    </license>
-  </licenses>
-
-  <developers>
-    <developer>
-      <id>abifet</id>
-      <name>Albert Bifet</name>
-      <email>abifet@waikato.ac.nz</email>
-    </developer>
-    <developer>
-      <id>fracpete</id>
-      <name>Peter Reutemann</name>
-      <email>fracpete@waikato.ac.nz</email>
-    </developer>
-  </developers>
-
-  <dependencies>
-    <dependency>
-      <groupId>nz.ac.waikato.cms.moa</groupId>
-      <artifactId>moa</artifactId>
-      <version>[${project.version},)</version>
-    </dependency>
-  </dependencies>
-</project>

From a40904dd0e9bcde5b9cc7a3a653fdc8534041381 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Mon, 9 Nov 2015 16:37:42 +0100
Subject: [PATCH 21/33] Revert "Test commit of everything"

This reverts commit 02d26831ad12964b8c91204bb81c22a5fdd5550b.
---
 .classpath                                    |  13 --
 .project                                      |   6 -
 moa/.classpath                                |  17 ++-
 moa/.settings/org.eclipse.jdt.core.prefs      |   3 -
 moa/pom.xml                                   | 138 ++++++++++++++++++
 .../classifiers/DecisionStumpTutorial.java    |  13 +-
 .../classifiers/multilabel/trees/.gitignore   |   1 -
 moa/src/main/java/moa/evaluation/.gitignore   |   2 -
 weka-package/pom.xml                          |  53 +++++++
 9 files changed, 205 insertions(+), 41 deletions(-)
 delete mode 100644 .classpath
 create mode 100755 moa/pom.xml
 delete mode 100644 moa/src/main/java/moa/classifiers/multilabel/trees/.gitignore
 delete mode 100644 moa/src/main/java/moa/evaluation/.gitignore
 create mode 100644 weka-package/pom.xml

diff --git a/.classpath b/.classpath
deleted file mode 100644
index dec9f005e..000000000
--- a/.classpath
+++ /dev/null
@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="moa/src/examples/java"/>
-	<classpathentry kind="src" path="moa/src/main/java"/>
-	<classpathentry kind="src" path="moa/src/test/java"/>
-	<classpathentry kind="lib" path="weka-package/lib/sizeofag-1.0.0.jar"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
-	<classpathentry combineaccessrules="false" kind="src" path="/meka"/>
-	<classpathentry combineaccessrules="false" kind="src" path="/weka-dev"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
-	<classpathentry kind="lib" path="/home/aljazo/Work/JARs/diffutils-1.2.1.jar"/>
-	<classpathentry kind="output" path="moa/target/classes"/>
-</classpath>
diff --git a/.project b/.project
index 56c2846a7..76bea900b 100644
--- a/.project
+++ b/.project
@@ -5,11 +5,6 @@
 	<projects>
 	</projects>
 	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
 		<buildCommand>
 			<name>org.eclipse.m2e.core.maven2Builder</name>
 			<arguments>
@@ -18,6 +13,5 @@
 	</buildSpec>
 	<natures>
 		<nature>org.eclipse.m2e.core.maven2Nature</nature>
-		<nature>org.eclipse.jdt.core.javanature</nature>
 	</natures>
 </projectDescription>
diff --git a/moa/.classpath b/moa/.classpath
index f5accf223..534b5e52f 100644
--- a/moa/.classpath
+++ b/moa/.classpath
@@ -11,21 +11,26 @@
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
+	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
 	<classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources">
 		<attributes>
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
 	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
 		<attributes>
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry combineaccessrules="false" kind="src" path="/meka"/>
-	<classpathentry combineaccessrules="false" kind="src" path="/weka-dev"/>
-	<classpathentry combineaccessrules="false" kind="src" path="/weka-package"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
-	<classpathentry kind="lib" path="/home/aljazo/Work/MT MOA/moa/weka-package/lib/sizeofag-1.0.0.jar"/>
 	<classpathentry kind="output" path="target/classes"/>
 </classpath>
diff --git a/moa/.settings/org.eclipse.jdt.core.prefs b/moa/.settings/org.eclipse.jdt.core.prefs
index 69c31cd49..60105c1b9 100644
--- a/moa/.settings/org.eclipse.jdt.core.prefs
+++ b/moa/.settings/org.eclipse.jdt.core.prefs
@@ -1,8 +1,5 @@
 eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
 org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
 org.eclipse.jdt.core.compiler.compliance=1.6
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
 org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
 org.eclipse.jdt.core.compiler.source=1.6
diff --git a/moa/pom.xml b/moa/pom.xml
new file mode 100755
index 000000000..dd44c7979
--- /dev/null
+++ b/moa/pom.xml
@@ -0,0 +1,138 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <parent>
+    <groupId>nz.ac.waikato.cms.moa</groupId>
+    <artifactId>moa-pom</artifactId>
+    <version>2015.05-SNAPSHOT</version>
+  </parent>
+
+  <artifactId>moa</artifactId>
+  <packaging>jar</packaging>
+
+  <name>MOA: Massive Online Analysis</name>
+  <description>
+  Massive On-line Analysis is an environment for massive data mining. MOA
+  provides a framework for data stream mining and includes tools for evaluation
+  and a collection of machine learning algorithms. Related to the WEKA project,
+  also written in Java, while scaling to more demanding problems.
+  </description>
+  <url>http://moa.cms.waikato.ac.nz/</url>
+  <organization>
+    <name>University of Waikato, Hamilton, NZ</name>
+    <url>http://www.waikato.ac.nz/</url>
+  </organization>
+  <licenses>
+    <license>
+      <name>GNU General Public License 3.0</name>
+      <url>http://www.gnu.org/licenses/gpl-3.0.txt</url>
+      <distribution>repo</distribution>
+    </license>
+  </licenses>
+
+  <developers>
+    <developer>
+      <id>abifet</id>
+      <name>Albert Bifet</name>
+      <email>abifet@waikato.ac.nz</email>
+    </developer>
+    <developer>
+      <id>rkirkby</id>
+      <name>Richard Kirkby</name>
+    </developer>
+  </developers>
+
+  <dependencies>
+    <dependency>
+      <groupId>nz.ac.waikato.cms.weka</groupId>
+      <artifactId>weka-dev</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>com.googlecode.sizeofag</groupId>
+      <artifactId>sizeofag</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <scope>test</scope>
+    </dependency>
+    
+    <dependency>
+      <groupId>com.googlecode.java-diff-utils</groupId>
+      <artifactId>diffutils</artifactId>
+      <version>1.2.1</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <configuration>
+          <source>1.6</source>
+          <target>1.6</target>
+        </configuration>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-jar-plugin</artifactId>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-javadoc-plugin</artifactId>
+      </plugin>
+      
+      <plugin>
+        <groupId>org.codehaus.mojo</groupId>
+        <artifactId>license-maven-plugin</artifactId>
+      </plugin>
+
+      <plugin>
+        <groupId>org.codehaus.mojo</groupId>
+        <artifactId>latex-maven-plugin</artifactId>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-assembly-plugin</artifactId>
+      </plugin>
+    </plugins>
+    <pluginManagement>
+    	<plugins>
+    		<!--This plugin's configuration is used to store Eclipse m2e settings only. It has no influence on the Maven build itself.-->
+    		<plugin>
+    			<groupId>org.eclipse.m2e</groupId>
+    			<artifactId>lifecycle-mapping</artifactId>
+    			<version>1.0.0</version>
+    			<configuration>
+    				<lifecycleMappingMetadata>
+    					<pluginExecutions>
+    						<pluginExecution>
+    							<pluginExecutionFilter>
+    								<groupId>org.codehaus.mojo</groupId>
+    								<artifactId>
+    									license-maven-plugin
+    								</artifactId>
+    								<versionRange>[1.1,)</versionRange>
+    								<goals>
+    									<goal>add-third-party</goal>
+    								</goals>
+    							</pluginExecutionFilter>
+    							<action>
+    								<ignore></ignore>
+    							</action>
+    						</pluginExecution>
+    					</pluginExecutions>
+    				</lifecycleMappingMetadata>
+    			</configuration>
+    		</plugin>
+    	</plugins>
+    </pluginManagement>
+  </build>
+</project>
diff --git a/moa/src/examples/java/moa/classifiers/DecisionStumpTutorial.java b/moa/src/examples/java/moa/classifiers/DecisionStumpTutorial.java
index 0cabab7dc..8d18b0a9d 100644
--- a/moa/src/examples/java/moa/classifiers/DecisionStumpTutorial.java
+++ b/moa/src/examples/java/moa/classifiers/DecisionStumpTutorial.java
@@ -1,18 +1,11 @@
 package moa.classifiers;
 
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.GaussianNumericAttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.NominalAttributeClassObserver;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
 import moa.options.ClassOption;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
-
-import com.yahoo.labs.samoa.instances.Instance;
+import moa.options.FlagOption;
+import moa.options.IntOption;
+import weka.core.Instance;
 
 public class DecisionStumpTutorial extends AbstractClassifier {
 
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/.gitignore b/moa/src/main/java/moa/classifiers/multilabel/trees/.gitignore
deleted file mode 100644
index 8e36d7391..000000000
--- a/moa/src/main/java/moa/classifiers/multilabel/trees/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-/BaselinePerceptron.java
diff --git a/moa/src/main/java/moa/evaluation/.gitignore b/moa/src/main/java/moa/evaluation/.gitignore
deleted file mode 100644
index 48df8b2bf..000000000
--- a/moa/src/main/java/moa/evaluation/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-/MultilabelWindowClassificationPerformanceEvaluatorWithMEKAMetrics.java
-/MultiTargetWindowRegressionPerformanceEvaluator2.java
diff --git a/weka-package/pom.xml b/weka-package/pom.xml
new file mode 100644
index 000000000..6cd73530c
--- /dev/null
+++ b/weka-package/pom.xml
@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+
+  <modelVersion>4.0.0</modelVersion>
+
+  <parent>
+    <groupId>nz.ac.waikato.cms.moa</groupId>
+    <artifactId>moa-pom</artifactId>
+    <version>2012.09-SNAPSHOT</version>
+  </parent>
+
+  <artifactId>weka-package</artifactId>
+  <packaging>jar</packaging>
+
+  <name>MOA: WEKA Package</name>
+  <description>
+  Massive On-line Analysis is an environment for massive data mining. MOA provides a framework for data stream mining and includes tools for evaluation and a collection of machine learning algorithms. Related to the WEKA project, also written in Java, while scaling to more demanding problems.
+  This artifact enables you to use MOA from within WEKA.
+  </description>
+  <url>http://moa.cms.waikato.ac.nz/</url>
+  <organization>
+    <name>University of Waikato, Hamilton, NZ</name>
+    <url>http://www.waikato.ac.nz/</url>
+  </organization>
+  <licenses>
+    <license>
+      <name>GNU General Public License 3</name>
+      <url>http://www.gnu.org/licenses/gpl-3.0.txt</url>
+      <distribution>repo</distribution>
+    </license>
+  </licenses>
+
+  <developers>
+    <developer>
+      <id>abifet</id>
+      <name>Albert Bifet</name>
+      <email>abifet@waikato.ac.nz</email>
+    </developer>
+    <developer>
+      <id>fracpete</id>
+      <name>Peter Reutemann</name>
+      <email>fracpete@waikato.ac.nz</email>
+    </developer>
+  </developers>
+
+  <dependencies>
+    <dependency>
+      <groupId>nz.ac.waikato.cms.moa</groupId>
+      <artifactId>moa</artifactId>
+      <version>[${project.version},)</version>
+    </dependency>
+  </dependencies>
+</project>

From 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Mon, 9 Nov 2015 16:37:46 +0100
Subject: [PATCH 22/33] Revert "Additional merging artefacts fixed"

This reverts commit 5dec8c12eaac8f4785df76b61e4d40a591a13321.
---
 .../MultitargetAttributeClassObserver.java        | 15 ---------------
 1 file changed, 15 deletions(-)
 delete mode 100644 moa/src/main/java/moa/classifiers/core/attributeclassobservers/MultitargetAttributeClassObserver.java

diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/MultitargetAttributeClassObserver.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/MultitargetAttributeClassObserver.java
deleted file mode 100644
index 0cfc7acb6..000000000
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/MultitargetAttributeClassObserver.java
+++ /dev/null
@@ -1,15 +0,0 @@
-package moa.classifiers.core.attributeclassobservers;
-
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.core.DoubleVector;
-
-public interface MultitargetAttributeClassObserver extends AttributeClassObserver {
-
-	public void observeAttributeClassVector(double attVal, DoubleVector classVector, double weight);
-	
-    public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(
-            SplitCriterion criterion, double examlpesSeen, DoubleVector preSplitSums, DoubleVector preSplitSquares, int attIndex,
-            int numTargets, boolean binaryOnly);
-
-}

From e4f2eb61e5ef780975d8948c9f132b8d2e4199f4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Mon, 9 Nov 2015 16:38:13 +0100
Subject: [PATCH 23/33] Revert "Removed merging artefacts"

This reverts commit 4e3116ae22afc259caa4f4e7d967ae369aae367c.
---
 .../samoa/instances/MultiLabelPrediction.java |    5 +-
 .../LocalMultiTargetClassifier.java           |    3 +-
 .../multilabel/trees/ISOUPTree.java           |   43 +-
 .../java/moa/classifiers/trees/FIMTDD.java    | 1001 +++++++++++++++++
 .../main/java/moa/classifiers/trees/ORTO.java |  203 ++++
 5 files changed, 1238 insertions(+), 17 deletions(-)

diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
index 81c9b86f5..fbffed6ae 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
@@ -33,7 +33,10 @@ public MultiLabelPrediction(int numOutputAttributes) {
 	public MultiLabelPrediction(DoubleVector[] prediction) {
 		this.prediction = prediction;
 	}
-
+	
+	public MultiLabelPrediction(DoubleVector[] prediction) {
+		this.prediction = prediction;
+	}
 	
 	@Override
 	public int numOutputAttributes() {
diff --git a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
index 21c34b1dc..428434562 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
@@ -28,6 +28,8 @@
 public class LocalMultiTargetClassifier extends AbstractMultiLabelLearner
 		implements MultiLabelClassifier, MultiTargetRegressor {
 
+	private static final long serialVersionUID = 1L;
+
 	public ClassOption classifierOption = new ClassOption(
 			"classifier",
 			'c',
@@ -100,7 +102,6 @@ public Prediction getPredictionForInstance(MultiLabelInstance inst) {
 		MultiLabelPrediction prediction = new MultiLabelPrediction(getModelContext().numOutputAttributes());
 		for (int j = 0; j < inst.numberOutputTargets(); j++) {
 			Instance STInst = getSTInstance(inst, j);
-			
 			prediction.setVote(j, 1, classifiers.get(j).getVotesForInstance(STInst)[0]);
 		}
 		return prediction;
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
index 6b6df7e18..c657f290d 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
@@ -82,6 +82,14 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 
 	//region ================ OPTIONS ================
 
+	//	public ClassOption splitCriterionOption = new ClassOption(
+	//			"splitCriterion",
+	//			's',
+	//			"Split criterion to use.",
+	//			SplitCriterion.class,
+	//			"moa.classifiers.core.splitcriteria.VarianceReductionSplitCriterion");
+	// TODO not used at the moment, consider later when the implementation catches up	
+
 	public IntOption gracePeriodOption = new IntOption(
 			"gracePeriod",
 			'g',
@@ -305,6 +313,7 @@ public LeafNode(ISOUPTree tree) {
 		 */
 		public void learnFromInstance(MultiLabelInstance inst, double[] prediction, boolean growthAllowed) {
 			// Update the statistics for this node
+			
 			double[] predictionP = tree.buildingModelTree() ? getPredictionModel(inst) : null;
 			double[] predictionM = getPredictionTargetMean(inst);
 
@@ -323,6 +332,7 @@ public void learnFromInstance(MultiLabelInstance inst, double[] prediction, bool
 					errorM.setValue(i, errorM.getValue(i) * 0.95 + Math.abs(predictionM[i] - inst.valueOutputAttribute(i)));
 				}
 			}
+
 			if (tree.buildingModelTree()) learningModel.updatePerceptron(inst);
 
 			for (int i = 0; i < inst.numInputAttributes(); i++) {
@@ -398,6 +408,8 @@ public double[] getPredictionTargetMean(MultiLabelInstance inst) {
 			if (examplesSeen > 0) {
 				for (int i = 0; i < inst.numOutputAttributes(); i++) {
 					pred[i] = sumOfValues.getValue(i) / examplesSeen;
+				} else {
+					pred[i] = 0;
 				}
 			}
 			return pred;
@@ -598,7 +610,8 @@ public class MultitargetPerceptron {
 		protected ISOUPTree tree;
 
 		// The Perception weights 
-		protected double[][] weights; 
+		public double[][] weights; 
+
 
 		// The number of instances contributing to this model
 		protected int instancesSeen = 0;
@@ -629,6 +642,7 @@ public void initializeWeights() {
 					weights[i][j] = 2 * tree.classifierRandom.nextDouble() - 1;
 				}
 			}
+			normalizeWeights();
 		}
 
 		/**
@@ -730,6 +744,7 @@ public void getModelDescription(StringBuilder out, int indent) {
 				}
 				StringUtils.appendNewline(out);
 			}
+			StringUtils.appendNewline(out);
 		}
 	}
 
@@ -746,9 +761,12 @@ public String getPurposeString() {
 
 	public void resetLearningImpl() {
 		treeRoot = null;
-		leafNodeCount = 0;
-		splitNodeCount = 0;
-		maxID = 0;
+		examplesSeen = 0.0;
+		sumOfValues = new DoubleVector();
+		sumOfSquares = new DoubleVector();
+
+		sumOfAttrValues = new DoubleVector();
+		sumOfAttrSquares = new DoubleVector();
 	}
 
 	public boolean isRandomizable() {
@@ -842,7 +860,7 @@ public double[] normalizeTargetVector(double[] pred) {
 				double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen);
 				double average = sumOfValues.getValue(i) / examplesSeen;
 				if (sd > 0 && examplesSeen > 1)
-					out[i] = (value - average) / (3 * sd);
+					out[i] = (value - average) / sd;
 				else
 					out[i] = 0;
 			}
@@ -858,7 +876,7 @@ public double normalizeTargetValue(MultiLabelInstance inst, int i) {
 				double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen);
 				double average = sumOfValues.getValue(i) / examplesSeen;
 				if (sd > 0)
-					return (value - average) / (3 * sd);
+					return (value - average) / sd;
 				else
 					return 0;
 			}
@@ -872,7 +890,7 @@ public double normalizeTargetValue(double value, int i) {
 				double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen);
 				double average = sumOfValues.getValue(i) / examplesSeen;
 				if (sd > 0)
-					return (value - average) / (3 * sd);
+					return (value - average) / sd;
 				else
 					return 0;
 			}
@@ -900,9 +918,9 @@ public void trainOnInstanceImpl(MultiLabelInstance inst) {
 
 			double[] prediction = treeRoot.getPrediction(inst);
 			double[] normalError = getNormalizedError(inst, prediction);
-			//normalError.scaleValues(inst.weight());
+			
 			processInstance(inst, treeRoot, prediction, normalError, true, false);
-
+			
 			examplesSeen += inst.weight();
 			for (int i = 0; i < inst.numberOutputTargets(); i++) {
 				sumOfValues.addToValue(i, inst.weight() * inst.valueOutputAttribute(i));
@@ -1013,7 +1031,7 @@ protected LeafNode newLeafNode() {
 		return new LeafNode(this);
 	}
 
-	protected MultitargetPerceptron newLeafModel() {
+	public MultitargetPerceptron newLeafModel() {
 		return new MultitargetPerceptron(this);
 	}
 
@@ -1023,7 +1041,6 @@ protected MultitargetPerceptron newLeafModel() {
 	protected void checkRoot() {
 		if (treeRoot == null) {
 			treeRoot = newLeafNode();
-			leafNodeCount = 1;
 		}
 	}
 
@@ -1101,7 +1118,6 @@ protected void attemptToSplit(LeafNode node, SplitNode parent, int parentIndex)
 			newSplit.copyStatistics(node);
 			newSplit.changeDetection = node.changeDetection;
 			newSplit.ID = node.ID;
-			leafNodeCount--;
 			//System.out.println("Splitting");
 			//System.out.println(examplesSeen);
 			for (int i = 0; i < 2; i++) { // Hardcoded for 2 values (due to the use of the Predicate class)
@@ -1114,7 +1130,6 @@ protected void attemptToSplit(LeafNode node, SplitNode parent, int parentIndex)
 				newChild.changeDetection = node.changeDetection;
 				newChild.setParent(newSplit);
 				newSplit.setChild(i, newChild);
-				leafNodeCount++;
 			}
 			if (parent == null && node.originalNode == null) {
 				treeRoot = newSplit;
@@ -1124,8 +1139,6 @@ protected void attemptToSplit(LeafNode node, SplitNode parent, int parentIndex)
 				parent.setChild(parentIndex, newSplit);
 				newSplit.setParent(parent);
 			}
-
-			splitNodeCount++;
 		}
 	}
 
diff --git a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java b/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
index 219fd3a2a..a2dcd0b7c 100644
--- a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
+++ b/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
@@ -1,3 +1,1000 @@
+<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
+=======
+<<<<<<< HEAD
+/*
+ *    FIMTDD.java
+ *    Copyright (C) 2015 Jožef Stefan Institute, Ljubljana, Slovenia
+ *    @author Aljaž Osojnik <aljaz.osojnik@ijs.si>
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *    
+ *    
+ */
+
+package moa.classifiers.trees;
+
+import java.io.Serializable;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+
+import moa.options.ClassOption;
+import moa.AbstractMOAObject;
+import moa.classifiers.Regressor;
+import moa.classifiers.core.AttributeSplitSuggestion;
+import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
+import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
+import moa.classifiers.core.splitcriteria.SplitCriterion;
+import moa.classifiers.AbstractClassifier;
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.SizeOf;
+import moa.core.StringUtils;
+
+/*
+ * Implementation of FIMTDD, regression and model trees for data streams.
+ */
+
+public class FIMTDD extends AbstractClassifier implements Regressor {
+
+	private static final long serialVersionUID = 1L;
+
+	protected Node treeRoot;
+
+	protected int leafNodeCount = 0;
+	protected int splitNodeCount = 0;
+
+	protected double examplesSeen = 0.0;
+	protected double sumOfValues = 0.0;
+	protected double sumOfSquares = 0.0;
+
+	protected DoubleVector sumOfAttrValues = new DoubleVector();
+	protected DoubleVector sumOfAttrSquares = new DoubleVector();
+
+	public int maxID = 0;
+
+	//region ================ OPTIONS ================
+
+	public ClassOption splitCriterionOption = new ClassOption(
+			"splitCriterion", 's', "Split criterion to use.",
+			SplitCriterion.class, "moa.classifiers.core.splitcriteria.VarianceReductionSplitCriterion");
+
+	public IntOption gracePeriodOption = new IntOption(
+			"gracePeriod", 'g', "Number of instances a leaf should observe between split attempts.",
+			200, 0, Integer.MAX_VALUE);
+
+	public FloatOption splitConfidenceOption = new FloatOption(
+			"splitConfidence", 'c', "Allowed error in split decision, values close to 0 will take long to decide.",
+			0.0000001, 0.0, 1.0);
+
+	public FloatOption tieThresholdOption = new FloatOption(
+			"tieThreshold", 't', "Threshold below which a split will be forced to break ties.",
+			0.05, 0.0, 1.0);
+
+	public FloatOption PageHinckleyAlphaOption = new FloatOption(
+			"PageHinckleyAlpha", 'a', "Alpha value to use in the Page Hinckley change detection tests.",
+			0.005, 0.0, 1.0);
+
+	public IntOption PageHinckleyThresholdOption = new IntOption(
+			"PageHinckleyThreshold", 'h', "Threshold value used in the Page Hinckley change detection tests.",
+			50, 0, Integer.MAX_VALUE);
+
+	public FloatOption alternateTreeFadingFactorOption = new FloatOption(
+			"alternateTreeFadingFactor", 'f', "Fading factor used to decide if an alternate tree should replace an original.",
+			0.995, 0.0, 1.0);
+
+	public IntOption alternateTreeTMinOption = new IntOption(
+			"alternateTreeTMin", 'y', "Tmin value used to decide if an alternate tree should replace an original.",
+			150, 0, Integer.MAX_VALUE);
+
+	public IntOption alternateTreeTimeOption = new IntOption(
+			"alternateTreeTime", 'u', "The number of instances used to decide if an alternate tree should be discarded.",
+			1500, 0, Integer.MAX_VALUE);
+
+	public FlagOption regressionTreeOption = new FlagOption(
+			"regressionTree", 'e', "Build a regression tree instead of a model tree.");
+
+	public FloatOption learningRatioOption = new FloatOption(
+			"learningRatio", 'l', "Learning ratio to used for training the Perceptrons in the leaves.",
+			0.003, 0, 1.00);
+
+	public FloatOption learningRateDecayFactorOption = new FloatOption(
+			"learningRatioDecayFactor", 'd', "Learning rate decay factor (not used when learning rate is constant).",
+			0.001, 0, 1.00);
+
+	public FlagOption learningRatioConstOption = new FlagOption(
+			"learningRatioConst", 'p', "Keep learning rate constant instead of decaying.");
+
+	//endregion ================ OPTIONS ================
+
+	//region ================ CLASSES ================
+
+	public abstract static class Node extends AbstractMOAObject {
+
+		private static final long serialVersionUID = 1L;
+
+		public int ID;
+
+		protected FIMTDD tree;
+		
+		protected boolean changeDetection = true;
+		
+		protected Node parent;
+
+		protected Node alternateTree;
+		protected Node originalNode;
+
+		// The statistics for this node:
+		// Number of instances that have reached it
+		protected double examplesSeen;
+		// Sum of y values
+		protected double sumOfValues;
+		// Sum of squared y values
+		protected double sumOfSquares;
+		// Sum of absolute errors
+		protected double sumOfAbsErrors; // Needed for PH tracking of mean error
+
+		public Node(FIMTDD tree) {
+			this.tree = tree;
+			ID = tree.maxID; 
+		}
+
+		public void copyStatistics(Node node) {
+			examplesSeen = node.examplesSeen;
+			sumOfValues = node.sumOfValues;
+			sumOfSquares = node.sumOfSquares;
+			sumOfAbsErrors = node.sumOfAbsErrors;
+		}
+
+		public int calcByteSize() {
+			return (int) SizeOf.fullSizeOf(this);
+		}
+
+		/**
+		 * Set the parent node
+		 */
+		public void setParent(Node parent) {
+			this.parent = parent;    
+		}
+
+		/**
+		 * Return the parent node
+		 */
+		public Node getParent() {
+			return parent;
+		}
+
+		public void disableChangeDetection() {
+			changeDetection = false;
+		}
+
+		public void restartChangeDetection() {
+			changeDetection = true;
+		}
+		
+		public void getDescription(StringBuilder sb, int indent) {
+			
+		}
+
+		public double getPrediction(Instance inst) {
+			return 0;
+		}
+		
+		public void describeSubtree(StringBuilder out, int indent) {
+			StringUtils.appendIndented(out, indent, "Leaf");
+		}
+		
+		public int getLevel() {
+			Node target = this;
+			int level = 0;
+			while (target.getParent() != null) {
+				if (target.skipInLevelCount()) {
+					target = target.getParent();
+					continue;
+				}
+				level = level + 1;
+				target = target.getParent();
+			}
+			if (target.originalNode == null) {
+				return level;
+			} else {
+				return level + originalNode.getLevel();
+			}
+		}
+
+		public void setChild(int parentBranch, Node node) {
+		}
+
+		public int getChildIndex(Node child) {
+			return -1;
+		}
+
+		public int getNumSubtrees() {
+			return 1;
+		}
+
+		protected boolean skipInLevelCount() {
+			return false;
+		}
+	}
+
+	public static class LeafNode extends Node {
+
+		private static final long serialVersionUID = 1L;
+
+		public double errorModel = 0.0;
+		public double errorTargetMean = 0.0;
+		
+		// Perceptron model that carries out the actual learning in each node
+		public FIMTDDPerceptron learningModel;
+
+		protected AutoExpandVector<FIMTDDNumericAttributeClassObserver> attributeObservers = new AutoExpandVector<FIMTDDNumericAttributeClassObserver>();
+		
+		protected double examplesSeenAtLastSplitEvaluation = 0;
+
+		/**
+		 * Create a new LeafNode
+		 */
+		public LeafNode(FIMTDD tree) {
+			super(tree);
+			if (tree.buildingModelTree()) {
+				learningModel = tree.newLeafModel();
+			}
+			examplesSeen = 0;
+			sumOfValues = 0;
+			sumOfSquares = 0;
+			sumOfAbsErrors = 0;
+		}
+
+		public void setChild(int parentBranch, Node node) {
+		}
+
+		public int getChildIndex(Node child) {
+			return -1;
+		}
+
+		public int getNumSubtrees() {
+			return 1;
+		}
+
+		protected boolean skipInLevelCount() {
+			return false;
+		}
+		
+		/**
+		 * Method to learn from an instance that passes the new instance to the perceptron learner,
+		 * and also prevents the class value from being truncated to an int when it is passed to the
+		 * attribute observer
+		 */
+		public void learnFromInstance(Instance inst, boolean growthAllowed, double prediction) {
+			//The prediction must be calculated here -- it may be different from the tree's prediction due to alternate trees
+			
+			// Update the statistics for this node
+			// number of instances passing through the node
+			examplesSeen += inst.weight();
+
+			// sum of y values
+			sumOfValues += inst.weight() * inst.classValue();
+
+			// sum of squared y values
+			sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
+
+			// sum of absolute errors
+			sumOfAbsErrors += inst.weight() * Math.abs(tree.normalizeTargetValue(Math.abs(inst.classValue() - prediction)));
+			
+			if (tree.buildingModelTree()) {
+				double predictionModel = getPredictionModel(inst);
+				double predictionTargetMean = getPredictionTargetMean(inst);
+				
+				errorModel = errorModel * 0.95 + Math.abs(predictionModel - inst.classValue());
+				errorTargetMean = errorTargetMean * 0.95 + Math.abs(predictionTargetMean - inst.classValue());
+				
+				learningModel.updatePerceptron(inst);
+			}
+
+			for (int i = 0; i < inst.numAttributes() - 1; i++) {
+				int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
+				FIMTDDNumericAttributeClassObserver obs = attributeObservers.get(i);
+				if (obs == null) {
+					// At this stage all nominal attributes are ignored
+					if (inst.attribute(instAttIndex).isNumeric()) {
+						obs = tree.newNumericClassObserver();
+						this.attributeObservers.set(i, obs);
+					}
+				}
+				if (obs != null) {
+					obs.observeAttributeClass(inst.value(instAttIndex), inst.classValue(), inst.weight());
+				}
+			}
+
+			if (growthAllowed) {
+				checkForSplit();
+			}
+		}
+
+		/**
+		 * Return the best split suggestions for this node using the given split criteria
+		 */
+		public AttributeSplitSuggestion[] getBestSplitSuggestions(SplitCriterion criterion) {
+
+			List<AttributeSplitSuggestion> bestSuggestions = new LinkedList<AttributeSplitSuggestion>();
+
+			// Set the nodeStatistics up as the preSplitDistribution, rather than the observedClassDistribution
+			double[] nodeSplitDist = new double[] {examplesSeen, sumOfValues, sumOfSquares};
+
+			for (int i = 0; i < this.attributeObservers.size(); i++) {
+				FIMTDDNumericAttributeClassObserver obs = this.attributeObservers.get(i);
+				if (obs != null) {
+
+					// AT THIS STAGE NON-NUMERIC ATTRIBUTES ARE IGNORED
+					AttributeSplitSuggestion bestSuggestion = null;
+					if (obs instanceof FIMTDDNumericAttributeClassObserver) {
+						bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion, nodeSplitDist, i, true);
+					}
+
+					if (bestSuggestion != null) {
+						bestSuggestions.add(bestSuggestion);
+					}
+				}
+			}
+			return bestSuggestions.toArray(new AttributeSplitSuggestion[bestSuggestions.size()]);
+		}
+
+		/**
+		 * Retrieve the class votes using the perceptron learner
+		 */
+		public double getPredictionModel(Instance inst) {
+			return learningModel.prediction(inst);
+		}
+
+		public double getPredictionTargetMean(Instance inst) {
+			return (examplesSeen > 0.0) ? sumOfValues / examplesSeen : 0.0;
+		}
+
+		public double getPrediction(Instance inst) {
+			if (tree.buildingModelTree()) {
+				//return getPredictionModel(inst);
+				return (errorModel < errorTargetMean) ? getPredictionModel(inst) : getPredictionTargetMean(inst);
+			} else
+				return getPredictionTargetMean(inst);
+		}
+		
+		public void checkForSplit() {
+			// If it has seen Nmin examples since it was last tested for splitting, attempt a split of this node
+			if (examplesSeen - examplesSeenAtLastSplitEvaluation >= tree.gracePeriodOption.getValue()) {
+				int index = (parent != null) ? parent.getChildIndex(this) : 0;
+				tree.attemptToSplit(this, parent, index);
+
+				// Take note of how many instances were seen when this split evaluation was made, so we know when to perform the next split evaluation
+				examplesSeenAtLastSplitEvaluation = examplesSeen;
+			}
+		}
+
+		public void describeSubtree(StringBuilder out, int indent) {
+			StringUtils.appendIndented(out, indent, "Leaf ");
+			if (tree.buildingModelTree()) {
+				learningModel.getModelDescription(out, 0);
+			} else {
+				out.append(tree.getClassNameString() + " = " + String.format("%.4f", sumOfValues / examplesSeen));
+				StringUtils.appendNewline(out);
+			}
+		}
+	}
+
+	public abstract static class InnerNode extends Node {
+		// The InnerNode and SplitNode design is used for easy extension in ORTO
+		private static final long serialVersionUID = 1L;
+
+		protected AutoExpandVector<Node> children = new AutoExpandVector<Node>();
+
+		// The error values for the Page Hinckley test
+		// PHmT = the cumulative sum of the errors
+		// PHMT = the minimum error value seen so far
+		protected double PHsum = 0;
+		protected double PHmin = Double.MAX_VALUE;
+
+		// Keep track of the statistics for loss error calculations
+		protected double lossExamplesSeen;
+		protected double lossFadedSumOriginal;
+		protected double lossFadedSumAlternate;
+		protected double lossNumQiTests;
+		protected double lossSumQi;
+		protected double previousWeight = 0;
+		
+		public InnerNode(FIMTDD tree) {
+			super(tree);
+		}
+
+		public int numChildren() {
+			return children.size();
+		}
+
+		public Node getChild(int index) {
+			return children.get(index);
+		}
+
+		public int getChildIndex(Node child) {
+			return children.indexOf(child);
+		}
+
+		public void setChild(int index, Node child) {
+			children.set(index, child);
+		}
+
+		public void disableChangeDetection() {
+			changeDetection = false;
+			for (Node child : children) {
+				child.disableChangeDetection();
+			}
+		}
+
+		public void restartChangeDetection() {
+			if (alternateTree == null) {
+				changeDetection = true;
+				PHsum = 0;
+				PHmin = Integer.MAX_VALUE;
+				for (Node child : children)
+					child.restartChangeDetection();
+			}
+		}
+		
+		/**
+		 * Check to see if the tree needs updating
+		 */
+		public boolean PageHinckleyTest(double error, double threshold) {    
+			// Update the cumulative mT sum
+			PHsum += error;
+
+			// Update the minimum mT value if the new mT is
+			// smaller than the current minimum
+			if(PHsum < PHmin) {
+				PHmin = PHsum;
+			}
+			// Return true if the cumulative value - the current minimum is
+			// greater than the current threshold (in which case we should adapt)
+			return PHsum - PHmin > threshold;
+		}
+		
+		public void initializeAlternateTree() {
+			// Start a new alternate tree, beginning with a learning node
+			alternateTree = tree.newLeafNode();
+			alternateTree.originalNode = this;
+
+			// Set up the blank statistics
+			// Number of instances reaching this node since the alternate tree was started
+			lossExamplesSeen = 0;
+			// Faded squared error (original tree)
+			lossFadedSumOriginal = 0;
+			// Faded squared error (alternate tree)
+			lossFadedSumAlternate = 0;
+			// Number of evaluations of alternate tree
+			lossNumQiTests = 0;
+			// Sum of Qi values
+			lossSumQi = 0;
+			// Number of examples at last test
+			previousWeight = 0;
+
+			// Disable the change detection mechanism bellow this node
+			disableChangeDetection();
+		}
+	}
+	
+	public static class SplitNode extends InnerNode {
+
+		private static final long serialVersionUID = 1L;
+
+		protected InstanceConditionalTest splitTest;
+
+		/**
+		 * Create a new SplitNode
+		 * @param tree 
+		 */
+		public SplitNode(InstanceConditionalTest splitTest, FIMTDD tree) {
+			super(tree);
+			this.splitTest = splitTest;
+		}
+
+		public int instanceChildIndex(Instance inst) {
+			return splitTest.branchForInstance(inst);
+		}
+		
+		public Node descendOneStep(Instance inst) {
+			return children.get(splitTest.branchForInstance(inst));
+		}
+
+		public void describeSubtree(StringBuilder out, int indent) {
+			for (int branch = 0; branch < children.size(); branch++) {
+				Node child = getChild(branch);
+				if (child != null) {
+					StringUtils.appendIndented(out, indent, "if ");
+					out.append(this.splitTest.describeConditionForBranch(branch,
+							tree.getModelContext()));
+					out.append(": ");
+					StringUtils.appendNewline(out);
+					child.describeSubtree(out, indent + 2);
+				}
+			}
+		}
+
+		public double getPrediction(Instance inst) {
+			return children.get(splitTest.branchForInstance(inst)).getPrediction(inst);
+		}
+	}
+
+	public class FIMTDDPerceptron implements Serializable {
+
+		private static final long serialVersionUID = 1L;
+		
+		protected FIMTDD tree;
+		
+		// The Perception weights 
+		protected double[] weightAttribute; 
+
+		// The number of instances contributing to this model
+		protected double instancesSeen = 0;
+
+		public String getPurposeString() {
+			return "A perceptron regressor as specified by Ikonomovska et al. used for FIMTDD";
+		}
+
+		public FIMTDDPerceptron(FIMTDDPerceptron original) {
+			this.tree = original.tree;
+			weightAttribute = original.weightAttribute.clone();
+		}
+
+		public FIMTDDPerceptron(FIMTDD tree) {
+			this.tree = tree;
+			initializeWeights();
+
+		}
+
+		public void initializeWeights() {
+			weightAttribute = new double[tree.getModelContext().numInputAttributes()+1];
+			instancesSeen = 0;
+			for (int j = 0; j < tree.getModelContext().numInputAttributes()+1; j++) {
+				// The last index corresponds to the constant b
+				weightAttribute[j] = 2 * tree.classifierRandom.nextDouble() - 1;
+			}
+			normalizeWeights();
+		}
+		
+		/**
+		 * Update the model using the provided instance
+		 */
+		public void updatePerceptron(Instance inst) {
+
+			// Update attribute statistics
+			instancesSeen += inst.weight();
+
+			// Update weights
+			double learningRatio = 0.0;
+			if (tree.learningRatioConstOption.isSet()) {
+				learningRatio = learningRatioOption.getValue();
+			} else {
+				learningRatio = learningRatioOption.getValue() / (1 + instancesSeen * tree.learningRateDecayFactorOption.getValue());
+			}
+
+			// Loop for compatibility with bagging methods 
+			for (int i = 0; i < (int) inst.weight(); i++) {
+				updateWeights(inst, learningRatio);
+			}
+		
+		}
+
+		public void updateWeights(Instance inst, double learningRatio) {
+			// Compute the normalized instance and the delta
+			double[] normalizedInstance = normalizedInstance(inst); 
+			double normalizedPrediction = prediction(normalizedInstance);
+			double normalizedValue = tree.normalizeTargetValue(inst.classValue());
+			double delta = normalizedValue - normalizedPrediction;
+			for (int i = 0; i < weightAttribute.length; i++) {
+				weightAttribute[i] += delta * learningRatio * normalizedInstance[i];
+			}
+			
+			normalizeWeights();
+		}
+		
+		public void normalizeWeights() {
+			double sum = 0;
+			for (int i = 0; i < this.weightAttribute.length; i++)
+				sum += Math.abs(weightAttribute[i]);
+			for (int i = 0; i < this.weightAttribute.length; i++)
+				weightAttribute[i] /= sum;
+		}
+
+		public double[] normalizedInstance(Instance inst) {
+			// Normalize Instance
+			double[] normalizedInstance = new double[inst.numInputAttributes()+1];
+			for (int j = 0; j < inst.numInputAttributes(); j++) {
+				double mean = tree.sumOfAttrValues.getValue(j) / tree.examplesSeen;
+				double sd = computeSD(tree.sumOfAttrSquares.getValue(j), tree.sumOfAttrValues.getValue(j), tree.examplesSeen);
+				if (inst.inputAttribute(j).isNumeric() && tree.examplesSeen > 1 && sd > 0.0000001)
+					normalizedInstance[j] = (inst.valueInputAttribute(j) - mean) / (sd);
+				else
+					normalizedInstance[j] = 0;
+			}
+			normalizedInstance[inst.numInputAttributes()] = tree.examplesSeen > 1 ? 1 : 0; // Value to be multiplied with the constant factor
+			return normalizedInstance;
+		}
+
+		/**
+		 * Output the prediction made by this perceptron on the given instance
+		 */
+		public double prediction(double[] instanceValues) {
+			double ret = 0;
+			for (int i = 0; i < instanceValues.length; i++)
+				ret += instanceValues[i] * weightAttribute[i];
+			return ret;
+		}
+
+		protected double prediction(Instance inst) {
+			double[] normalizedInstance = normalizedInstance(inst);
+			double normalizedPrediction = prediction(normalizedInstance);
+			return denormalizePrediction(normalizedPrediction);
+		}
+
+		private double denormalizePrediction(double normalizedPrediction) {
+			double mean = tree.sumOfValues / tree.examplesSeen;
+			double sd = computeSD(tree.sumOfSquares, tree.sumOfValues, tree.examplesSeen);
+			if (examplesSeen > 1) 
+				return normalizedPrediction * sd + mean;
+			else
+				return 0.0;
+		}
+		
+		public void getModelDescription(StringBuilder out, int indent) {
+	        StringUtils.appendIndented(out, indent, getClassNameString() + " =");
+			if (getModelContext() != null) {
+				for (int j = 0; j < getModelContext().numAttributes() - 1; j++) {
+					if (getModelContext().attribute(j).isNumeric()) {
+						out.append((j == 0 || weightAttribute[j] < 0) ? " " : " + ");
+		                out.append(String.format("%.4f", weightAttribute[j]));
+		                out.append(" * ");
+		                out.append(getAttributeNameString(j));
+		            }
+		        }
+				out.append(" + " + weightAttribute[getModelContext().numInputAttributes()]);
+			}
+	        StringUtils.appendNewline(out);
+		}
+	}
+
+
+	//endregion ================ CLASSES ================
+
+	//region ================ METHODS ================
+
+	// region --- Regressor methods
+	
+	public String getPurposeString() {
+		return "Implementation of the FIMT-DD tree as described by Ikonomovska et al.";
+	}
+
+	public void resetLearningImpl() {
+		this.treeRoot = null;
+		this.leafNodeCount = 0;
+		this.splitNodeCount = 0;
+		this.maxID = 0;
+		this.examplesSeen = 0;
+		this.sumOfValues = 0.0;
+		this.sumOfSquares = 0.0;
+
+		this.sumOfAttrValues = new DoubleVector();
+		this.sumOfAttrSquares = new DoubleVector();
+	}
+
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	public void getModelDescription(StringBuilder out, int indent) {
+		if (treeRoot != null) treeRoot.describeSubtree(out, indent);
+	}
+
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[]{ 
+				new Measurement("tree size (leaves)", this.leafNodeCount)
+		};
+	}
+
+	public int calcByteSize() {
+		return (int) SizeOf.fullSizeOf(this);
+	}
+
+	public double[] getVotesForInstance(Instance inst) {
+		if (treeRoot == null) {
+			return new double[] {0};
+		}
+
+		double prediction = treeRoot.getPrediction(inst);
+
+		return new double[] {prediction};
+	}
+
+	public double normalizeTargetValue(double value) {
+		if (examplesSeen > 1) {
+			double sd = Math.sqrt((sumOfSquares - ((sumOfValues * sumOfValues)/examplesSeen))/examplesSeen);
+			double average = sumOfValues / examplesSeen;
+			if (sd > 0 && examplesSeen > 1)
+				return (value - average) / sd;
+			else
+				return 0.0;
+		}
+		return 0.0;
+	}
+
+	public double getNormalizedError(Instance inst, double prediction) {
+		double normalPrediction = normalizeTargetValue(prediction);
+		double normalValue = normalizeTargetValue(inst.classValue());
+		return Math.abs(normalValue - normalPrediction);
+	}
+
+
+	/**
+	 * Method for updating (training) the model using a new instance
+	 */
+	public void trainOnInstanceImpl(Instance inst) {
+		checkRoot();
+
+		double prediction = treeRoot.getPrediction(inst);
+		double normalError = getNormalizedError(inst, prediction);
+	
+		processInstance(inst, treeRoot, prediction, normalError, true, false);
+		
+		examplesSeen += inst.weight();
+		sumOfValues += inst.weight() * inst.classValue();
+		sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
+
+		for (int i = 0; i < inst.numAttributes() - 1; i++) {
+			int aIndex = modelAttIndexToInstanceAttIndex(i, inst);
+			sumOfAttrValues.addToValue(i, inst.weight() * inst.value(aIndex));
+			sumOfAttrSquares.addToValue(i, inst.weight() * inst.value(aIndex) * inst.value(aIndex));
+		}
+
+
+	}
+
+	public void processInstance(Instance inst, Node node, double prediction, double normalError, boolean growthAllowed, boolean inAlternate) {
+		Node currentNode = node;
+		while (true) {
+			if (currentNode instanceof LeafNode) {
+				((LeafNode) currentNode).learnFromInstance(inst, growthAllowed, prediction);
+				break;
+			} else {
+				currentNode.examplesSeen += inst.weight();
+				currentNode.sumOfAbsErrors += inst.weight() * normalError;
+				InnerNode iNode = (InnerNode) currentNode;
+				if (!inAlternate && iNode.alternateTree != null) {
+					boolean altTree = true;
+					double lossO = Math.pow(inst.classValue() - prediction, 2);
+					double lossA = Math.pow(inst.classValue() - iNode.alternateTree.getPrediction(inst), 2);
+					
+					// Loop for compatibility with bagging methods
+					for (int i = 0; i < inst.weight(); i++) {
+						iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
+						iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
+						iNode.lossExamplesSeen++;
+						
+						double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
+						iNode.lossSumQi += Qi;
+						iNode.lossNumQiTests += 1;
+					}
+					double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
+					double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+					double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+					
+					if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
+						iNode.previousWeight = iNode.lossExamplesSeen;
+						if (Qi > 0) {
+							// Switch the subtrees
+							Node parent = iNode.getParent();
+
+							if (parent != null) {
+								Node replacementTree = iNode.alternateTree;
+								parent.setChild(parent.getChildIndex(iNode), replacementTree);
+								if (growthAllowed) replacementTree.restartChangeDetection();
+							} else {
+								treeRoot = iNode.alternateTree;
+								treeRoot.restartChangeDetection();
+							}
+
+							currentNode = iNode.alternateTree;
+							currentNode.originalNode = null;
+							altTree = false;
+						} else if (QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * alternateTreeTMinOption.getValue()) || iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()) {
+							// Remove the alternate tree
+							iNode.alternateTree = null;
+							if (growthAllowed) iNode.restartChangeDetection();
+							altTree = false;
+						}
+					}
+
+					if (altTree) {
+						growthAllowed = false;
+						processInstance(inst, iNode.alternateTree, prediction, normalError, true, true);
+					}
+				}
+
+				if (false && iNode.changeDetection && !inAlternate) {
+					if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+						iNode.initializeAlternateTree();
+						growthAllowed = false;
+					}
+				}
+				if (currentNode instanceof SplitNode) {
+					currentNode = ((SplitNode) currentNode).descendOneStep(inst);
+				} 
+			}
+		}
+	}
+
+	// endregion --- Regressor methods
+	
+	// region --- Object instatiation methods
+
+	protected FIMTDDNumericAttributeClassObserver newNumericClassObserver() {
+		return new FIMTDDNumericAttributeClassObserver();
+	}
+
+	protected SplitNode newSplitNode(InstanceConditionalTest splitTest) {
+		maxID++;
+		return new SplitNode(splitTest, this);
+	}
+
+	protected LeafNode newLeafNode() {
+		maxID++;
+		return new LeafNode(this);
+	}
+
+	protected FIMTDDPerceptron newLeafModel() {
+		return new FIMTDDPerceptron(this);
+	}
+
+	//endregion --- Object instatiation methods
+	
+	// region --- Processing methods
+	
+	protected void checkRoot() {
+		if (treeRoot == null) {
+			treeRoot = newLeafNode();
+			leafNodeCount = 1;
+		}
+	}
+
+	public static double computeHoeffdingBound(double range, double confidence, double n) {
+		return Math.sqrt(( (range * range) * Math.log(1 / confidence)) / (2.0 * n));
+	}
+
+	public boolean buildingModelTree() {
+		return !regressionTreeOption.isSet();
+	}
+
+	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
+
+		// Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
+ 		SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
+
+		// Using this criterion, find the best split per attribute and rank the results
+		AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion);
+		Arrays.sort(bestSplitSuggestions);
+
+		// Declare a variable to determine if any of the splits should be performed
+		boolean shouldSplit = false;
+
+		// If only one split was returned, use it
+		if (bestSplitSuggestions.length < 2) {
+			shouldSplit = bestSplitSuggestions.length > 0;
+		} else { // Otherwise, consider which of the splits proposed may be worth trying
+
+			// Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
+			// to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
+			double hoeffdingBound = computeHoeffdingBound(1, this.splitConfidenceOption.getValue(), node.examplesSeen);
+			// Determine the top two ranked splitting suggestions
+			AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+			AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
+
+			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
+			// as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
+			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
+			// splitting should occur.
+			// Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
+			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
+			// competing attributes are equally good, and the split will be made on the one with the higher SDR value.
+			if ((secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) || (hoeffdingBound < this.tieThresholdOption.getValue())) {
+				shouldSplit = true;
+			}
+			// If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
+			else {
+				for (int i = 0; i < node.attributeObservers.size(); i++) {
+					FIMTDDNumericAttributeClassObserver obs = node.attributeObservers.get(i);
+					if (obs != null) {
+						obs.removeBadSplits(splitCriterion, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound);    
+					}
+				}
+			}
+//			if (hoeffdingBound < this.tieThresholdOption.getValue() && !(secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound)) {
+//				System.out.println("Forced to split due to tie at " + this.examplesSeen);
+//				System.out.println(SizeOf.fullSizeOf(node.attributeObservers) / 1000000.0);
+//			}
+		}
+
+		// If the splitting criterion were met, split the current node using the chosen attribute test, and
+		// make two new branches leading to (empty) leaves
+		if (shouldSplit) {
+//			System.out.println("splitting node");
+//			System.out.println(SizeOf.fullSizeOf(node.attributeObservers) / 1000000.0);
+//			if (node.parent == null) {
+//				System.out.println("splitting root node at " + this.examplesSeen);
+//			}
+			AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+						
+			SplitNode newSplit = newSplitNode(splitDecision.splitTest);
+			newSplit.copyStatistics(node);
+			newSplit.changeDetection = node.changeDetection;
+			newSplit.ID = node.ID;
+			leafNodeCount--;
+			for (int i = 0; i < splitDecision.numSplits(); i++) {
+				LeafNode newChild = newLeafNode();
+				if (buildingModelTree()) {
+					// Copy the splitting node's perceptron to it's children
+					newChild.learningModel = new FIMTDDPerceptron((FIMTDDPerceptron) node.learningModel);
+					
+				}
+				newChild.changeDetection = node.changeDetection;
+				newChild.setParent(newSplit);
+				newSplit.setChild(i, newChild);
+				leafNodeCount++;
+			}
+			if (parent == null && node.originalNode == null) {
+				treeRoot = newSplit;
+			} else if (parent == null && node.originalNode != null) {
+				node.originalNode.alternateTree = newSplit;
+			} else {
+				((SplitNode) parent).setChild(parentIndex, newSplit);
+				newSplit.setParent(parent);
+			}
+			
+			splitNodeCount++;
+		}
+	}
+	
+	public double computeSD(double squaredVal, double val, double size) {
+		if (size > 1)
+			return Math.sqrt((squaredVal - ((val * val) / size)) / size);
+		else
+			return 0.0;
+	}
+	
+	public double scalarProduct(DoubleVector u, DoubleVector v) {
+		double ret = 0.0;
+		for (int i = 0; i < Math.max(u.numValues(), v.numValues()); i++) {
+			ret += u.getValue(i) * v.getValue(i);
+		}
+		return ret;
+	}
+	//endregion --- Processing methods
+	
+	//endregion ================ METHODS ================
+}
+
+=======
+>>>>>>> Revert "Removed merging artefacts"
 /*
  *    FIMTDD.java
  *    Copyright (C) 2015 Jožef Stefan Institute, Ljubljana, Slovenia
@@ -967,3 +1964,7 @@ public double scalarProduct(DoubleVector u, DoubleVector v) {
 	//endregion ================ METHODS ================
 }
 
+<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
+=======
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+>>>>>>> Revert "Removed merging artefacts"
diff --git a/moa/src/main/java/moa/classifiers/trees/ORTO.java b/moa/src/main/java/moa/classifiers/trees/ORTO.java
index eda46103c..d2e697d6e 100644
--- a/moa/src/main/java/moa/classifiers/trees/ORTO.java
+++ b/moa/src/main/java/moa/classifiers/trees/ORTO.java
@@ -35,8 +35,21 @@
 import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
 import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
+<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
 import moa.core.AutoExpandVector;
 import moa.core.Measurement;
+=======
+<<<<<<< HEAD
+import moa.classifiers.trees.FIMTDD.InnerNode;
+import moa.classifiers.trees.FIMTDD.Node;
+import moa.core.AutoExpandVector;
+import moa.core.Measurement;
+import moa.core.StringUtils;
+=======
+import moa.core.AutoExpandVector;
+import moa.core.Measurement;
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+>>>>>>> Revert "Removed merging artefacts"
 
 /*
  * Implementation of ORTO, option trees for data streams.
@@ -119,9 +132,15 @@ public int getNumSubtrees() {
 
 		public int directionForBestTree() {
 			int d = 0;
+<<<<<<< HEAD
+			double min = Double.MAX_VALUE;
+			for (int i = 0; i < numChildren(); i++) {
+				double tmp = getFFRatio(i);
+=======
 			double tmp = 0.0, min = Double.MAX_VALUE;
 			for (int i = 0; i < children.size(); i++) {
 				tmp = getFFRatio(i);
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				if (tmp < min) {
 					min = tmp;
 					d = i;
@@ -130,22 +149,54 @@ public int directionForBestTree() {
 			return d;
 		}
 
+<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
+		public double getPrediction(Instance inst, ORTO tree) {
+=======
+<<<<<<< HEAD
+		public double getPrediction(Instance inst) {
+=======
 		public double getPrediction(Instance inst, ORTO tree) {
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+>>>>>>> Revert "Removed merging artefacts"
 			double[] predictions = new double[numChildren()];
 			for (int i = 0; i < numChildren(); i++) {
 				predictions[i] = getChild(i).getPrediction(inst);
 			}
+<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
 			return aggregate(predictions, tree);
 		}
 
 		private double aggregate(double[] predictions, ORTO tree) {
 			if (tree.optionNodeAggregationOption.getChosenIndex() == 0) { // Average
+=======
+<<<<<<< HEAD
+			return aggregate(predictions);
+		}
+
+		private double aggregate(double[] predictions) {
+			if (((ORTO) tree).optionNodeAggregationOption.getChosenIndex() == 0) { // Average
+=======
+			return aggregate(predictions, tree);
+		}
+
+		private double aggregate(double[] predictions, ORTO tree) {
+			if (tree.optionNodeAggregationOption.getChosenIndex() == 0) { // Average
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+>>>>>>> Revert "Removed merging artefacts"
 				double sum = 0.0;
 				for (int i = 0; i < predictions.length; i++) {
 					sum += predictions[i];
 				}
 				return sum / predictions.length;
+<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
+			} else if (tree.optionNodeAggregationOption.getChosenIndex() == 1) {
+=======
+<<<<<<< HEAD
+			} else if (((ORTO) tree).optionNodeAggregationOption.getChosenIndex() == 1) {
+=======
 			} else if (tree.optionNodeAggregationOption.getChosenIndex() == 1) {
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+>>>>>>> Revert "Removed merging artefacts"
 				int d = directionForBestTree();
 				return predictions[d];
 			} else {
@@ -160,6 +211,24 @@ public double getFFRatio(int childIndex) {
 		protected boolean skipInLevelCount() {
 			return true;
 		}
+<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
+=======
+<<<<<<< HEAD
+		
+		@Override
+		public void describeSubtree(StringBuilder out, int indent) {
+			StringUtils.appendIndented(out, indent, "[option node]");
+			StringUtils.appendNewline(out);
+			for (int childIndex = 0; childIndex < children.size(); childIndex++) {
+				Node split = getChild(childIndex);
+				StringUtils.appendIndented(out, indent, "[" + childIndex + "]");
+				StringUtils.appendNewline(out);
+				split.describeSubtree(out, indent + 2);
+			}
+		}
+=======
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+>>>>>>> Revert "Removed merging artefacts"
 	}
 
 	//endregion ================ CLASSES ================
@@ -194,7 +263,15 @@ public void processInstance(Instance inst, Node node, double prediction, double
 			Node currentNode = node;
 			while (true) {
 				if (currentNode instanceof LeafNode) {
+<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
+					((LeafNode) currentNode).learnFromInstance(inst, growthAllowed);
+=======
+<<<<<<< HEAD
+					((LeafNode) currentNode).learnFromInstance(inst, growthAllowed, prediction);
+=======
 					((LeafNode) currentNode).learnFromInstance(inst, growthAllowed);
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+>>>>>>> Revert "Removed merging artefacts"
 					break;
 				} else {
 					currentNode.examplesSeen += inst.weight();
@@ -203,7 +280,15 @@ public void processInstance(Instance inst, Node node, double prediction, double
 					if (!inAlternate && iNode.alternateTree != null) {
 						boolean altTree = true;
 						double lossO = Math.pow(inst.classValue() - prediction, 2);
+<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
+						double lossA = Math.pow(inst.classValue() - currentNode.alternateTree.getPrediction(inst), 2);
+=======
+<<<<<<< HEAD
+						double lossA = Math.pow(inst.classValue() - iNode.alternateTree.getPrediction(inst), 2);
+=======
 						double lossA = Math.pow(inst.classValue() - currentNode.alternateTree.getPrediction(inst), 2);
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+>>>>>>> Revert "Removed merging artefacts"
 						
 						// Loop for compatibility with bagging methods
 						for (int i = 0; i < inst.weight(); i++) {
@@ -223,7 +308,15 @@ public void processInstance(Instance inst, Node node, double prediction, double
 							iNode.previousWeight = iNode.lossExamplesSeen;
 							if (Qi > 0) {
 								// Switch the subtrees
+<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
 								Node parent = currentNode.parent;
+=======
+<<<<<<< HEAD
+								Node parent = iNode.getParent();
+=======
+								Node parent = currentNode.parent;
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+>>>>>>> Revert "Removed merging artefacts"
 								
 								if (parent != null) {
 									Node replacementTree = iNode.alternateTree;
@@ -233,7 +326,15 @@ public void processInstance(Instance inst, Node node, double prediction, double
 									treeRoot = iNode.alternateTree;
 									treeRoot.restartChangeDetection();
 								}
+<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
+								optionNodeCount += currentNode.alternateTree.getNumSubtrees() - currentNode.getNumSubtrees();
+=======
+<<<<<<< HEAD
+								optionNodeCount += iNode.alternateTree.getNumSubtrees() - iNode.getNumSubtrees();
+=======
 								optionNodeCount += currentNode.alternateTree.getNumSubtrees() - currentNode.getNumSubtrees();
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+>>>>>>> Revert "Removed merging artefacts"
 								removeExcessTrees();
 										
 								currentNode = iNode.alternateTree;
@@ -248,7 +349,15 @@ public void processInstance(Instance inst, Node node, double prediction, double
 						}
 						if (altTree) {
 							growthAllowed = false; // this is the growth of the original tree
+<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
 							processInstance(inst, currentNode.alternateTree, prediction, normalError, true, true); // growth is allowed in the alt tree
+=======
+<<<<<<< HEAD
+							processInstance(inst, iNode.alternateTree, prediction, normalError, true, true); // growth is allowed in the alt tree
+=======
+							processInstance(inst, currentNode.alternateTree, prediction, normalError, true, true); // growth is allowed in the alt tree
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+>>>>>>> Revert "Removed merging artefacts"
 						} else if (currentNode instanceof OptionNode) {
 							// this happens when an option node is switched into the tree
 							for (Node child : ((OptionNode) currentNode).children) {
@@ -276,18 +385,44 @@ public void processInstance(Instance inst, Node node, double prediction, double
 	}
 	
 	public void processInstanceOptionNode(Instance inst, OptionNode node, double prediction, double normalError, boolean growthAllowed, boolean inAlternate) {
+<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
+=======
+<<<<<<< HEAD
+		node.examplesSeen += inst.weight();
+		node.sumOfAbsErrors += inst.weight() * normalError;
+=======
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+>>>>>>> Revert "Removed merging artefacts"
 		if (node.changeDetection) {
 			double error = Math.abs(prediction - inst.classValue());
 			node.sumOfAbsErrors += error;
 			
 			if (((InnerNode) node).PageHinckleyTest(error - node.sumOfAbsErrors / node.examplesSeen + PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
 				node.initializeAlternateTree();
+<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
+=======
+<<<<<<< HEAD
+				growthAllowed = false;
+=======
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+>>>>>>> Revert "Removed merging artefacts"
 			}
 		}
 
 		for (Node child : node.children) {
 			int index = node.getChildIndex(child);
 			double childPrediction = child.getPrediction(inst);
+<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
+=======
+<<<<<<< HEAD
+			node.optionFFSeen[index] = node.optionFFSeen[index] * optionFadingFactorOption.getValue() + 1;
+			node.optionFFSSL[index] = node.optionFFSSL[index] * optionFadingFactorOption.getValue() + Math.pow(childPrediction - inst.classValue(), 2);
+		}
+
+		for (Node child : node.children) {
+			processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed, inAlternate);
+=======
+>>>>>>> Revert "Removed merging artefacts"
 			// Loop for compatibility with bagging methods
 			for (int i = 0; i < inst.weight(); i++) {
 				node.optionFFSeen[index] = node.optionFFSeen[index] * optionFadingFactorOption.getValue() + 1;
@@ -297,6 +432,7 @@ public void processInstanceOptionNode(Instance inst, OptionNode node, double pre
 
 		for (Node child : node.children) {
 			processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed && node.alternateTree == null, inAlternate);
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		}
 	}
 	
@@ -314,6 +450,10 @@ protected OptionNode newOptionNode() {
 	// region --- Processing methods
 
 	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
+<<<<<<< HEAD
+
+=======
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		// Initialize the split criterion 
 		SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(splitCriterionOption);
 
@@ -321,7 +461,11 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 		AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion);
 		List<AttributeSplitSuggestion> acceptedSplits = new LinkedList<AttributeSplitSuggestion>();
 		Arrays.sort(bestSplitSuggestions);
+<<<<<<< HEAD
+		
+=======
 
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		// Declare a variable to determine the number of splits to be performed
 		int numSplits = 0;
 
@@ -339,6 +483,13 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 			AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
 			AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
 
+<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
+=======
+<<<<<<< HEAD
+			
+=======
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+>>>>>>> Revert "Removed merging artefacts"
 			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
 			// as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
 			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
@@ -350,12 +501,30 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 				numSplits = 1;
 				acceptedSplits.add(bestSuggestion);
 			} else if (numTrees < maxTreesOption.getValue() && node.getLevel() <= maxOptionLevelOption.getValue()) {
+<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
+				for (AttributeSplitSuggestion suggestion : bestSplitSuggestions) {
+=======
+<<<<<<< HEAD
+				for (int i = 0; i < bestSplitSuggestions.length; i++) {
+					AttributeSplitSuggestion suggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1 - i];
+>>>>>>> Revert "Removed merging artefacts"
+					if (suggestion.merit / bestSuggestion.merit >= 1 - hoeffdingBound) {
+						numSplits++;
+						acceptedSplits.add(suggestion);
+					}
+				}
+<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
+=======
+				
+=======
 				for (AttributeSplitSuggestion suggestion : bestSplitSuggestions) {
 					if (suggestion.merit / bestSuggestion.merit >= 1 - hoeffdingBound) {
 						numSplits++;
 						acceptedSplits.add(suggestion);
 					}
 				}
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+>>>>>>> Revert "Removed merging artefacts"
 			} else if (hoeffdingBound < tieThresholdOption.getValue()) {
 				numSplits = 1;
 				acceptedSplits.add(bestSplitSuggestions[0]);
@@ -374,7 +543,11 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 		if (numSplits > 0) {
 			double optionFactor = numSplits * Math.pow(optionDecayFactorOption.getValue(), (double) node.getLevel());
 
+<<<<<<< HEAD
+			if (numSplits == 1 || optionFactor < 2.0 || maxTreesOption.getValue() - numTrees <= 0) {
+=======
 			if (numSplits == 1 || optionFactor < 2.0 || maxTreesOption.getValue() - numTrees <= 1) {
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				AttributeSplitSuggestion splitDecision = acceptedSplits.get(0);
 				SplitNode newSplit = newSplitNode(splitDecision.splitTest);
 				for (int i = 0; i < splitDecision.numSplits(); i++) {
@@ -385,10 +558,25 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 				leafNodeCount--;
 				innerNodeCount++;
 				leafNodeCount += splitDecision.numSplits();
+<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
+				if (parent == null) {
+=======
+<<<<<<< HEAD
+				if (parent == null && node.originalNode == null) {
+>>>>>>> Revert "Removed merging artefacts"
+					treeRoot = newSplit;
+				} else {
+<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
+					parent.setChild(parent.getChildIndex(node), newSplit);
+=======
+					parent.setChild(parentIndex, newSplit);
+=======
 				if (parent == null) {
 					treeRoot = newSplit;
 				} else {
 					parent.setChild(parent.getChildIndex(node), newSplit);
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+>>>>>>> Revert "Removed merging artefacts"
 					newSplit.setParent(parent);
 				}
 			} else {
@@ -422,7 +610,15 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 				if (parent == null) {
 					treeRoot = optionNode;
 				} else {
+<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
 					parent.setChild(parent.getChildIndex(node), optionNode);
+=======
+<<<<<<< HEAD
+					parent.setChild(parentIndex, optionNode);
+=======
+					parent.setChild(parent.getChildIndex(node), optionNode);
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+>>>>>>> Revert "Removed merging artefacts"
 					optionNode.setParent(parent);
 				}
 
@@ -505,4 +701,11 @@ protected void removeExcessTrees() {
 	// endregion --- Option tree methods
 	
 	//endregion ================ METHODS ================
+<<<<<<< HEAD
+}
+<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
+=======
+=======
 }
+>>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
+>>>>>>> Revert "Removed merging artefacts"

From b6037c6d877eb624fb9752730977fb5eec5aecd3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Fri, 13 Nov 2015 13:57:24 +0100
Subject: [PATCH 24/33] Updates with the new versions of the algorithms (some
 code is imported from the 2015.10 prerelease version, so the pom files were
 updated back to the 2014.04 version)

---
 Release.key                                   |   19 +
 moa/pom.xml                                   |    2 +-
 .../samoa/instances/MultiLabelPrediction.java |    4 -
 .../LocalMultiTargetClassifier.java           |    6 -
 .../AttributeStatisticsObserver.java          |    6 +-
 .../MultiLabelBSTree.java                     |    6 +-
 .../MultiLabelNominalAttributeObserver.java   |    6 +-
 .../NominalStatisticsObserver.java            |    3 +-
 .../NumericStatisticsObserver.java            |    3 +-
 .../splitcriteria/ICVarianceReduction.java    |    1 -
 .../MultiLabelSplitCriterion.java             |    2 +-
 .../multilabel/trees/ISOUPOptionTree.java     |   15 +-
 .../multilabel/trees/ISOUPTree.java           |  230 +-
 .../core/AttributeExpansionSuggestion.java    |    3 +-
 .../multilabel/AMRulesMultiLabelLearner.java  |    6 +-
 .../AMRulesMultiTargetRegressor.java          |    2 +-
 .../multilabel/core/LearningLiteral.java      |   10 +-
 .../core/LearningLiteralRegression.java       |    9 +-
 .../rules/multilabel/core/MultiLabelRule.java |    6 +-
 .../MultiTargetVarianceRatio.java             |    1 +
 .../java/moa/classifiers/trees/FIMTDD.java    | 1982 ++++++++---------
 .../main/java/moa/classifiers/trees/ORTO.java |  191 +-
 .../tasks/EvaluatePrequentialMultiTarget.java |  404 ++--
 weka-package/pom.xml                          |    2 +-
 24 files changed, 1358 insertions(+), 1561 deletions(-)
 create mode 100644 Release.key
 rename moa/src/main/java/moa/classifiers/{rules/multilabel => multilabel/core}/attributeclassobservers/AttributeStatisticsObserver.java (90%)
 rename moa/src/main/java/moa/classifiers/{rules/multilabel => multilabel/core}/attributeclassobservers/MultiLabelBSTree.java (96%)
 rename moa/src/main/java/moa/classifiers/{rules/multilabel => multilabel/core}/attributeclassobservers/MultiLabelNominalAttributeObserver.java (93%)
 rename moa/src/main/java/moa/classifiers/{rules/multilabel => multilabel/core}/attributeclassobservers/NominalStatisticsObserver.java (56%)
 rename moa/src/main/java/moa/classifiers/{rules/multilabel => multilabel/core}/attributeclassobservers/NumericStatisticsObserver.java (56%)
 rename moa/src/main/java/moa/classifiers/{rules => }/multilabel/core/splitcriteria/MultiLabelSplitCriterion.java (85%)
 rename moa/src/main/java/moa/classifiers/rules/{multilabel => }/core/AttributeExpansionSuggestion.java (95%)

diff --git a/Release.key b/Release.key
new file mode 100644
index 000000000..549e44194
--- /dev/null
+++ b/Release.key
@@ -0,0 +1,19 @@
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+Version: GnuPG v1.4.5 (GNU/Linux)
+
+mQGiBE8ySNwRBACKcsg4AceGW7vuOSywcGiiNZg4I8vIzn7zphgj+s6/i2/hs8TQ
+TOHy1s3b0f32ani3sBRmTWtgNv8+HSaKSVUcNqqNL+Jy6Pulyao7amGTtvqVKmuz
+6ADrbVz0SxWmzTlSctdxK3g3yRSb+vfYrBPrbXNCNB5g9C/uK1uh0fpj1wCgn3MX
+GFlZsO3bF7SNqqYlzpV6DM0D/AjnBlxTwRJOA1sLAVSXipLOdkjo00OQ8jgOFDio
+oJsqLtsscNGocPCqNRo6QSVQKNs5sfYP2GXWTnPVM5oJI1p6bjuADRE8mneJrJvF
+Uc+Mt1MdS6ttF4tVqd5Ncc8LKYQJRn+AtiuxAAayAA35JOslnMM0bqSYMlw4BJTP
+8TlPA/4r+k+ucz3cJtM2aaL/ngUdrhmGKfGK7npXA3Ic6FzQo2NlJyKfWjSsR8x+
+oN7tKEpuYxE5fcdbWd3v+4Ypx0LYMgBT1pUgI09AXxrx1cLRZI4yovrvQJgiA4Mh
+CZ0eFkJJ1nwQR3NPMj5soar+7d3Ubc2EqkESGm0CgGtjgg+7HrQ6aXN2Om93bkNs
+b3VkIE9CUyBQcm9qZWN0IDxpc3Y6b3duQ2xvdWRAYnVpbGQub3BlbnN1c2Uub3Jn
+PohmBBMRAgAmBQJU2MJUAhsDBQkJxSl4BgsJCAcDAgQVAggDBBYCAwECHgECF4AA
+CgkQl3xDqLpoQiMpOQCggCpaq5yz8C3ckqEr0RkTjICcQYMAnRvjarxoY6iSThDN
+7vgxE1Fe8X5EiEYEExECAAYFAk8ySNwACgkQOzARt2udZSPlpwCfQZKNN8Rxx0LE
+BF32EYXBdEvkMYYAoIt3lfXL8uwmjvyljzb0JgBQN1cF
+=FJ6Q
+-----END PGP PUBLIC KEY BLOCK-----
diff --git a/moa/pom.xml b/moa/pom.xml
index dd44c7979..ec5e36169 100755
--- a/moa/pom.xml
+++ b/moa/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <groupId>nz.ac.waikato.cms.moa</groupId>
     <artifactId>moa-pom</artifactId>
-    <version>2015.05-SNAPSHOT</version>
+    <version>2014.04</version>
   </parent>
 
   <artifactId>moa</artifactId>
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
index fbffed6ae..12b35c5a3 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
@@ -29,10 +29,6 @@ public MultiLabelPrediction(int numOutputAttributes) {
 		for (int i=0; i<numOutputAttributes;i++)
 			prediction[i]= new DoubleVector();
 	}
-
-	public MultiLabelPrediction(DoubleVector[] prediction) {
-		this.prediction = prediction;
-	}
 	
 	public MultiLabelPrediction(DoubleVector[] prediction) {
 		this.prediction = prediction;
diff --git a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
index 428434562..c23396899 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
@@ -18,18 +18,12 @@
 import moa.classifiers.Classifier;
 import moa.classifiers.MultiLabelClassifier;
 import moa.classifiers.MultiTargetRegressor;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.classifiers.trees.FIMTDD;
-import moa.core.DoubleVector;
 import moa.core.Measurement;
-import moa.learners.Learner;
 import moa.options.ClassOption;
 
 public class LocalMultiTargetClassifier extends AbstractMultiLabelLearner
 		implements MultiLabelClassifier, MultiTargetRegressor {
 
-	private static final long serialVersionUID = 1L;
-
 	public ClassOption classifierOption = new ClassOption(
 			"classifier",
 			'c',
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/AttributeStatisticsObserver.java b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/AttributeStatisticsObserver.java
similarity index 90%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/AttributeStatisticsObserver.java
rename to moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/AttributeStatisticsObserver.java
index e760469e8..34be2f026 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/AttributeStatisticsObserver.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/AttributeStatisticsObserver.java
@@ -17,10 +17,10 @@
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
  *    
  */
-package moa.classifiers.rules.multilabel.attributeclassobservers;
+package moa.classifiers.multilabel.core.attributeclassobservers;
 
-import moa.classifiers.rules.multilabel.core.AttributeExpansionSuggestion;
-import moa.classifiers.rules.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.classifiers.rules.core.AttributeExpansionSuggestion;
 import moa.core.DoubleVector;
 import moa.options.OptionHandler;
 
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/MultiLabelBSTree.java b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelBSTree.java
similarity index 96%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/MultiLabelBSTree.java
rename to moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelBSTree.java
index 9058f9479..58fd92faa 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/MultiLabelBSTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelBSTree.java
@@ -1,13 +1,13 @@
-package moa.classifiers.rules.multilabel.attributeclassobservers;
+package moa.classifiers.multilabel.core.attributeclassobservers;
 
 import java.io.Serializable;
 
 import com.github.javacliparser.IntOption;
 
+import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.classifiers.rules.core.AttributeExpansionSuggestion;
 import moa.classifiers.rules.core.NumericRulePredicate;
 import moa.classifiers.rules.core.Utils;
-import moa.classifiers.rules.multilabel.core.AttributeExpansionSuggestion;
-import moa.classifiers.rules.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.core.DoubleVector;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/MultiLabelNominalAttributeObserver.java b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelNominalAttributeObserver.java
similarity index 93%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/MultiLabelNominalAttributeObserver.java
rename to moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelNominalAttributeObserver.java
index 969f28576..2495b158f 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/MultiLabelNominalAttributeObserver.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelNominalAttributeObserver.java
@@ -1,13 +1,13 @@
-package moa.classifiers.rules.multilabel.attributeclassobservers;
+package moa.classifiers.multilabel.core.attributeclassobservers;
 
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map.Entry;
 
+import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.classifiers.rules.core.AttributeExpansionSuggestion;
 import moa.classifiers.rules.core.NominalRulePredicate;
 import moa.classifiers.rules.core.Utils;
-import moa.classifiers.rules.multilabel.core.AttributeExpansionSuggestion;
-import moa.classifiers.rules.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.core.DoubleVector;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/NominalStatisticsObserver.java b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/NominalStatisticsObserver.java
similarity index 56%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/NominalStatisticsObserver.java
rename to moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/NominalStatisticsObserver.java
index 64ce01864..e52a0cb42 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/NominalStatisticsObserver.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/NominalStatisticsObserver.java
@@ -1,4 +1,5 @@
-package moa.classifiers.rules.multilabel.attributeclassobservers;
+package moa.classifiers.multilabel.core.attributeclassobservers;
+
 
 
 public interface NominalStatisticsObserver extends AttributeStatisticsObserver {
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/NumericStatisticsObserver.java b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/NumericStatisticsObserver.java
similarity index 56%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/NumericStatisticsObserver.java
rename to moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/NumericStatisticsObserver.java
index 5914dbb15..b899ce1dc 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/NumericStatisticsObserver.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/NumericStatisticsObserver.java
@@ -1,4 +1,5 @@
-package moa.classifiers.rules.multilabel.attributeclassobservers;
+package moa.classifiers.multilabel.core.attributeclassobservers;
+
 
 
 public interface NumericStatisticsObserver extends AttributeStatisticsObserver {
diff --git a/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java b/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java
index c3f2299d2..176f3dfd0 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java
@@ -5,7 +5,6 @@
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.tasks.TaskMonitor;
-import moa.classifiers.rules.multilabel.core.splitcriteria.MultiLabelSplitCriterion;;
 
 
 
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/splitcriteria/MultiLabelSplitCriterion.java b/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/MultiLabelSplitCriterion.java
similarity index 85%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/core/splitcriteria/MultiLabelSplitCriterion.java
rename to moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/MultiLabelSplitCriterion.java
index 099748611..cc9247039 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/splitcriteria/MultiLabelSplitCriterion.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/MultiLabelSplitCriterion.java
@@ -1,4 +1,4 @@
-package moa.classifiers.rules.multilabel.core.splitcriteria;
+package moa.classifiers.multilabel.core.splitcriteria;
 
 
 import moa.core.DoubleVector;
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java
index 93de284a0..a0ce07563 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java
@@ -3,15 +3,7 @@
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.MultiLabelInstance;
-
-import moa.classifiers.multilabel.trees.ISOUPTree.LeafNode;
-import moa.classifiers.multilabel.trees.ISOUPTree.Node;
-import moa.classifiers.multilabel.trees.ISOUPTree.SplitNode;
-import moa.classifiers.trees.ORTO;
-import moa.classifiers.trees.FIMTDD.InnerNode;
-import moa.classifiers.trees.ORTO.OptionNode;
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
@@ -20,7 +12,6 @@ public class ISOUPOptionTree extends ISOUPTree {
 
 	private static final long serialVersionUID = 1L;
 
-	private int innerNodeCount = 0;
 	private int optionNodeCount = 0;
 
 	private int numTrees = 1;
@@ -62,6 +53,11 @@ public class ISOUPOptionTree extends ISOUPTree {
 	//region ================ CLASSES ================
 	
 	public static class OptionNode extends InnerNode {
+		/**
+		 * 
+		 */
+		private static final long serialVersionUID = 1L;
+		
 		protected AutoExpandVector<DoubleVector> optionFFSSL;
 		protected AutoExpandVector<DoubleVector> optionFFSeen;
 		
@@ -152,7 +148,6 @@ public String getPurposeString() {
 
 	public void resetLearningImpl() {
 		super.resetLearningImpl();
-		this.innerNodeCount = 0;
 		this.optionNodeCount = 0;
 	}
 
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
index c657f290d..4ce0c89b6 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
@@ -66,10 +66,7 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 
 	private static final long serialVersionUID = 1L;
 
-	protected Node treeRoot;
-
-	private int leafNodeCount = 0;
-	private int splitNodeCount = 0;
+	public Node treeRoot;
 
 	private double examplesSeen = 0.0;
 	private DoubleVector sumOfValues = new DoubleVector();
@@ -82,14 +79,6 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 
 	//region ================ OPTIONS ================
 
-	//	public ClassOption splitCriterionOption = new ClassOption(
-	//			"splitCriterion",
-	//			's',
-	//			"Split criterion to use.",
-	//			SplitCriterion.class,
-	//			"moa.classifiers.core.splitcriteria.VarianceReductionSplitCriterion");
-	// TODO not used at the moment, consider later when the implementation catches up	
-
 	public IntOption gracePeriodOption = new IntOption(
 			"gracePeriod",
 			'g',
@@ -108,17 +97,17 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 			"Threshold below which a split will be forced to break ties.",
 			0.05, 0.0, 1.0);
 
-//	public FloatOption PageHinckleyAlphaOption = new FloatOption(
-//			"PageHinckleyAlpha",
-//			'a',
-//			"The alpha value to use in the Page Hinckley change detection tests.",
-//			0.005, 0.0, 1.0);
-//
-//	public IntOption PageHinckleyThresholdOption = new IntOption(
-//			"PageHinckleyThreshold",
-//			'h',
-//			"The threshold value to be used in the Page Hinckley change detection tests.",
-//			50, 0, Integer.MAX_VALUE);
+	public FloatOption PageHinckleyAlphaOption = new FloatOption(
+			"PageHinckleyAlpha",
+			'a',
+			"The alpha value to use in the Page Hinckley change detection tests.",
+			0.005, 0.0, 1.0);
+
+	public IntOption PageHinckleyThresholdOption = new IntOption(
+			"PageHinckleyThreshold",
+			'h',
+			"The threshold value to be used in the Page Hinckley change detection tests.",
+			50, 0, Integer.MAX_VALUE);
 
 	public FloatOption alternateTreeFadingFactorOption = new FloatOption(
 			"alternateTreeFadingFactor",
@@ -165,7 +154,6 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 			'n',
 			"Don't normalize.");
 
-
 	//endregion ================ OPTIONS ================
 
 	//region ================ CLASSES ================
@@ -313,7 +301,6 @@ public LeafNode(ISOUPTree tree) {
 		 */
 		public void learnFromInstance(MultiLabelInstance inst, double[] prediction, boolean growthAllowed) {
 			// Update the statistics for this node
-			
 			double[] predictionP = tree.buildingModelTree() ? getPredictionModel(inst) : null;
 			double[] predictionM = getPredictionTargetMean(inst);
 
@@ -332,7 +319,6 @@ public void learnFromInstance(MultiLabelInstance inst, double[] prediction, bool
 					errorM.setValue(i, errorM.getValue(i) * 0.95 + Math.abs(predictionM[i] - inst.valueOutputAttribute(i)));
 				}
 			}
-
 			if (tree.buildingModelTree()) learningModel.updatePerceptron(inst);
 
 			for (int i = 0; i < inst.numInputAttributes(); i++) {
@@ -405,8 +391,8 @@ public double[] getPredictionModel(MultiLabelInstance inst) {
 
 		public double[] getPredictionTargetMean(MultiLabelInstance inst) {
 			double[] pred = new double[inst.numOutputAttributes()];
-			if (examplesSeen > 0) {
-				for (int i = 0; i < inst.numOutputAttributes(); i++) {
+			for (int i = 0; i < inst.numOutputAttributes(); i++) {
+				if (examplesSeen > 0) {
 					pred[i] = sumOfValues.getValue(i) / examplesSeen;
 				} else {
 					pred[i] = 0;
@@ -612,7 +598,6 @@ public class MultitargetPerceptron {
 		// The Perception weights 
 		public double[][] weights; 
 
-
 		// The number of instances contributing to this model
 		protected int instancesSeen = 0;
 
@@ -670,7 +655,7 @@ public void updateWeights(MultiLabelInstance inst, double learningRatio) {
 			if (instancesSeen > 1.0) {
 				// Compute the normalized instance and the delta
 				double[] normalizedInput = tree.normalizedInputVector(inst); 
-			    double[] normalizedPrediction = prediction(normalizedInput);
+				double[] normalizedPrediction = prediction(normalizedInput);
 
 				double[] normalizedTarget = tree.normalizedTargetVector(inst);
 				for (int i = 0; i < inst.numOutputAttributes(); i++){
@@ -732,19 +717,18 @@ public void getModelDescription(StringBuilder out, int indent) {
 			for (int i = 0; i < tree.getModelContext().numOutputAttributes(); i++) {
 				StringUtils.appendIndented(out, indent, " [" + tree.getModelContext().outputAttribute(i).name() + "]");
 				if (getModelContext() != null) {
-				for (int j = 0; j < getModelContext().numOutputAttributes(); j++) {
-									if (getModelContext().attribute(j).isNumeric()) {
-										out.append((j == 0 || weights[i][j] < 0) ? " " : " + ");
-										out.append(String.format("%.4f", weights[i][j]));
-										out.append(" * ");
-										out.append(getAttributeNameString(j));
-									}
-				}
-				out.append(" + " + weights[i][getModelContext().numOutputAttributes()]);
+					for (int j = 0; j < getModelContext().numOutputAttributes(); j++) {
+						if (getModelContext().attribute(j).isNumeric()) {
+							out.append((j == 0 || weights[i][j] < 0) ? " " : " + ");
+							out.append(String.format("%.4f", weights[i][j]));
+							out.append(" * ");
+							out.append(getAttributeNameString(j));
+						}
+					}
+					out.append(" + " + weights[i][getModelContext().numOutputAttributes()]);
 				}
 				StringUtils.appendNewline(out);
 			}
-			StringUtils.appendNewline(out);
 		}
 	}
 
@@ -916,23 +900,23 @@ public void trainOnInstanceImpl(MultiLabelInstance inst) {
 		if (inst.weight() > 0) {
 			checkRoot();
 
-			double[] prediction = treeRoot.getPrediction(inst);
-			double[] normalError = getNormalizedError(inst, prediction);
-			
-			processInstance(inst, treeRoot, prediction, normalError, true, false);
-			
-			examplesSeen += inst.weight();
-			for (int i = 0; i < inst.numberOutputTargets(); i++) {
-				sumOfValues.addToValue(i, inst.weight() * inst.valueOutputAttribute(i));
-				sumOfSquares.addToValue(i, inst.weight() * inst.valueOutputAttribute(i) * inst.valueOutputAttribute(i));
-			}
+			 double[] prediction = treeRoot.getPrediction(inst);
+			 double[] normalError = getNormalizedError(inst, prediction);
 
-			for (int i = 0; i < inst.numInputAttributes(); i++) {
-				sumOfAttrValues.addToValue(i, inst.weight() * inst.valueInputAttribute(i));
-				sumOfAttrSquares.addToValue(i, inst.weight() * inst.valueInputAttribute(i) * inst.valueInputAttribute(i));
-			}
-		}
-	}
+			 processInstance(inst, treeRoot, prediction, normalError, true, false);
+
+			 examplesSeen += inst.weight();
+			 for (int i = 0; i < inst.numberOutputTargets(); i++) {
+				 sumOfValues.addToValue(i, inst.weight() * inst.valueOutputAttribute(i));
+				 sumOfSquares.addToValue(i, inst.weight() * inst.valueOutputAttribute(i) * inst.valueOutputAttribute(i));
+			 }
+
+			 for (int i = 0; i < inst.numInputAttributes(); i++) {
+				 sumOfAttrValues.addToValue(i, inst.weight() * inst.valueInputAttribute(i));
+				 sumOfAttrSquares.addToValue(i, inst.weight() * inst.valueInputAttribute(i) * inst.valueInputAttribute(i));
+			 }
+		 }
+	 }
 
 	public void processInstance(MultiLabelInstance inst, Node node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
 		Node currentNode = node;
@@ -1031,18 +1015,18 @@ protected LeafNode newLeafNode() {
 		return new LeafNode(this);
 	}
 
-	public MultitargetPerceptron newLeafModel() {
-		return new MultitargetPerceptron(this);
-	}
+	 public MultitargetPerceptron newLeafModel() {
+		 return new MultitargetPerceptron(this);
+	 }
 
 	//endregion --- Object instatiation methods
 
-	//region --- Processing methods
-	protected void checkRoot() {
-		if (treeRoot == null) {
-			treeRoot = newLeafNode();
-		}
-	}
+	 //region --- Processing methods
+	 protected void checkRoot() {
+		 if (treeRoot == null) {
+			 treeRoot = newLeafNode();
+		 }
+	 }
 
 	public static double computeHoeffdingBound(double range, double confidence, double n) {
 		return Math.sqrt(( (range * range) * Math.log(1 / confidence)) / (2.0 * n));
@@ -1081,66 +1065,66 @@ protected void attemptToSplit(LeafNode node, SplitNode parent, int parentIndex)
 			AttributeExpansionSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
 			AttributeExpansionSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
 
-			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
-			// as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
-			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
-			// splitting should occur.
-			// Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
-			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
-			// competing attributes are equally good, and the split will be made on the one with the higher SDR value.
-			//System.out.print(hoeffdingBound);
-			//System.out.print(" ");
-			///System.out.println(secondBestSuggestion.merit / bestSuggestion.merit);
-			if ((secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) || (hoeffdingBound < this.tieThresholdOption.getValue())) {
-				shouldSplit = true;
-			}
-			// If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
-			else {
-				// TODO pruning is currently disabled
-				for (int i = 0; i < node.attributeObservers.size(); i++) {
-					AttributeStatisticsObserver obs = node.attributeObservers.get(i);
-					if (obs != null) {
-						if (getModelContext().attribute(i).isNumeric());
-						//TODO obs.removeBadSplits(null, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound, getModelContext().numOutputAttributes());
-						if (getModelContext().attribute(i).isNominal());
-						// TODO nominal class observers
-					}
-				}
-			}
-		}
+			 // If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
+			 // as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
+			 // particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
+			 // splitting should occur.
+			 // Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
+			 // (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
+			 // competing attributes are equally good, and the split will be made on the one with the higher SDR value.
+			 //System.out.print(hoeffdingBound);
+			 //System.out.print(" ");
+			 ///System.out.println(secondBestSuggestion.merit / bestSuggestion.merit);
+			 if ((secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) || (hoeffdingBound < this.tieThresholdOption.getValue())) {
+				 shouldSplit = true;
+			 }
+			 // If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
+			 else {
+				 // TODO pruning is currently disabled
+				 for (int i = 0; i < node.attributeObservers.size(); i++) {
+					 AttributeStatisticsObserver obs = node.attributeObservers.get(i);
+					 if (obs != null) {
+						 if (getModelContext().attribute(i).isNumeric());
+						 //TODO obs.removeBadSplits(null, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound, getModelContext().numOutputAttributes());
+						 if (getModelContext().attribute(i).isNominal());
+						 // TODO nominal class observers
+					 }
+				 }
+			 }
+		 }
+
+		 // If the splitting criterion were met, split the current node using the chosen attribute test, and
+		 // make two new branches leading to (empty) leaves
+		 if (shouldSplit) {
+			 AttributeExpansionSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+
+			 SplitNode newSplit = newSplitNode(splitDecision.predicate);
+			 newSplit.copyStatistics(node);
+			 newSplit.changeDetection = node.changeDetection;
+			 newSplit.ID = node.ID;
+			 for (int i = 0; i < 2; i++) { // Hardcoded for 2 values (due to the use of the Predicate class)
+				 LeafNode newChild = newLeafNode();
+				 if (buildingModelTree()) {
+					 // Copy the splitting node's perceptron to it's children
+					 newChild.learningModel = new MultitargetPerceptron(this, (MultitargetPerceptron) node.learningModel);
+
+				 }
+				 newChild.changeDetection = node.changeDetection;
+				 newChild.setParent(newSplit);
+				 newSplit.setChild(i, newChild);
+			 }
+			 if (parent == null && node.originalNode == null) {
+				 treeRoot = newSplit;
+			 } else if (parent == null && node.originalNode != null) {
+				 node.originalNode.alternateTree = newSplit;
+			 } else {
+				 parent.setChild(parentIndex, newSplit);
+				 newSplit.setParent(parent);
+			 }
+		 }
+	 }
 
-		// If the splitting criterion were met, split the current node using the chosen attribute test, and
-		// make two new branches leading to (empty) leaves
-		if (shouldSplit) {
-			AttributeExpansionSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-
-			SplitNode newSplit = newSplitNode(splitDecision.predicate);
-			newSplit.copyStatistics(node);
-			newSplit.changeDetection = node.changeDetection;
-			newSplit.ID = node.ID;
-			//System.out.println("Splitting");
-			//System.out.println(examplesSeen);
-			for (int i = 0; i < 2; i++) { // Hardcoded for 2 values (due to the use of the Predicate class)
-				LeafNode newChild = newLeafNode();
-				if (buildingModelTree()) {
-					// Copy the splitting node's perceptron to it's children
-					newChild.learningModel = new MultitargetPerceptron(this, (MultitargetPerceptron) node.learningModel);
 
-				}
-				newChild.changeDetection = node.changeDetection;
-				newChild.setParent(newSplit);
-				newSplit.setChild(i, newChild);
-			}
-			if (parent == null && node.originalNode == null) {
-				treeRoot = newSplit;
-			} else if (parent == null && node.originalNode != null) {
-				node.originalNode.alternateTree = newSplit;
-			} else {
-				parent.setChild(parentIndex, newSplit);
-				newSplit.setParent(parent);
-			}
-		}
-	}
 
 	public  double computeSD(double squaredVal, double val, double size) {
 		if (size > 1)
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/AttributeExpansionSuggestion.java b/moa/src/main/java/moa/classifiers/rules/core/AttributeExpansionSuggestion.java
similarity index 95%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/core/AttributeExpansionSuggestion.java
rename to moa/src/main/java/moa/classifiers/rules/core/AttributeExpansionSuggestion.java
index b39b52ba0..a1e24bbb6 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/AttributeExpansionSuggestion.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/AttributeExpansionSuggestion.java
@@ -17,10 +17,9 @@
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
  *    
  */
-package moa.classifiers.rules.multilabel.core;
+package moa.classifiers.rules.core;
 
 import moa.AbstractMOAObject;
-import moa.classifiers.rules.core.Predicate;
 import moa.core.DoubleVector;
 
 /**
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java b/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java
index 8014b5e20..2672f58f5 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java
@@ -36,13 +36,13 @@
 import moa.classifiers.AbstractMultiLabelLearner;
 import moa.classifiers.MultiLabelLearner;
 import moa.classifiers.core.driftdetection.ChangeDetector;
+import moa.classifiers.multilabel.core.attributeclassobservers.NominalStatisticsObserver;
+import moa.classifiers.multilabel.core.attributeclassobservers.NumericStatisticsObserver;
+import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.rules.core.anomalydetection.AnomalyDetector;
 import moa.classifiers.rules.core.anomalydetection.OddsRatioScore;
-import moa.classifiers.rules.multilabel.attributeclassobservers.NominalStatisticsObserver;
-import moa.classifiers.rules.multilabel.attributeclassobservers.NumericStatisticsObserver;
 import moa.classifiers.rules.multilabel.core.MultiLabelRule;
 import moa.classifiers.rules.multilabel.core.MultiLabelRuleSet;
-import moa.classifiers.rules.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.rules.multilabel.core.voting.ErrorWeightedVoteMultiLabel;
 import moa.classifiers.rules.multilabel.core.voting.MultiLabelVote;
 import moa.classifiers.rules.multilabel.errormeasurers.MultiLabelErrorMeasurer;
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressor.java b/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressor.java
index 5b192f525..146a6be85 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressor.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressor.java
@@ -3,9 +3,9 @@
 import moa.classifiers.MultiLabelLearner;
 import moa.classifiers.MultiTargetRegressor;
 import moa.classifiers.Regressor;
+import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.rules.multilabel.core.MultiLabelRule;
 import moa.classifiers.rules.multilabel.core.MultiLabelRuleRegression;
-import moa.classifiers.rules.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.rules.multilabel.core.voting.ErrorWeightedVoteMultiLabel;
 import moa.classifiers.rules.multilabel.core.voting.InverseErrorWeightedVoteMultiLabel;
 import moa.classifiers.rules.multilabel.errormeasurers.MultiLabelErrorMeasurer;
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java
index a2765587b..4a8a18ccf 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java
@@ -11,16 +11,18 @@
 import com.yahoo.labs.samoa.instances.MultiLabelInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
+
 import moa.classifiers.MultiLabelLearner;
 import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
 import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
 import moa.classifiers.core.attributeclassobservers.NumericAttributeClassObserver;
 import moa.classifiers.core.driftdetection.ChangeDetector;
+import moa.classifiers.multilabel.core.attributeclassobservers.AttributeStatisticsObserver;
+import moa.classifiers.multilabel.core.attributeclassobservers.NominalStatisticsObserver;
+import moa.classifiers.multilabel.core.attributeclassobservers.NumericStatisticsObserver;
+import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.classifiers.rules.core.AttributeExpansionSuggestion;
 import moa.classifiers.rules.core.anomalydetection.AnomalyDetector;
-import moa.classifiers.rules.multilabel.attributeclassobservers.AttributeStatisticsObserver;
-import moa.classifiers.rules.multilabel.attributeclassobservers.NominalStatisticsObserver;
-import moa.classifiers.rules.multilabel.attributeclassobservers.NumericStatisticsObserver;
-import moa.classifiers.rules.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.rules.multilabel.errormeasurers.AbstractMultiTargetErrorMeasurer;
 import moa.classifiers.rules.multilabel.errormeasurers.MultiLabelErrorMeasurer;
 import moa.classifiers.rules.multilabel.outputselectors.OutputAttributesSelector;
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java
index fb96cae96..26ae4e0d9 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java
@@ -15,11 +15,12 @@
 import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
 import moa.classifiers.core.driftdetection.ChangeDetector;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
+import moa.classifiers.multilabel.core.attributeclassobservers.AttributeStatisticsObserver;
+import moa.classifiers.multilabel.core.attributeclassobservers.NominalStatisticsObserver;
+import moa.classifiers.multilabel.core.attributeclassobservers.NumericStatisticsObserver;
+import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.classifiers.rules.core.AttributeExpansionSuggestion;
 import moa.classifiers.rules.core.Utils;
-import moa.classifiers.rules.multilabel.attributeclassobservers.AttributeStatisticsObserver;
-import moa.classifiers.rules.multilabel.attributeclassobservers.NominalStatisticsObserver;
-import moa.classifiers.rules.multilabel.attributeclassobservers.NumericStatisticsObserver;
-import moa.classifiers.rules.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.rules.multilabel.functions.AMRulesFunction;
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java
index 9312ce86a..6bd641395 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java
@@ -14,13 +14,13 @@
 import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
 import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
 import moa.classifiers.core.driftdetection.ChangeDetector;
+import moa.classifiers.multilabel.core.attributeclassobservers.NominalStatisticsObserver;
+import moa.classifiers.multilabel.core.attributeclassobservers.NumericStatisticsObserver;
+import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.rules.core.RuleActiveLearningNode;
 import moa.classifiers.rules.core.RuleSplitNode;
 import moa.classifiers.rules.core.anomalydetection.AnomalyDetector;
 import moa.classifiers.rules.core.conditionaltests.NumericAttributeBinaryRulePredicate;
-import moa.classifiers.rules.multilabel.attributeclassobservers.NominalStatisticsObserver;
-import moa.classifiers.rules.multilabel.attributeclassobservers.NumericStatisticsObserver;
-import moa.classifiers.rules.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.rules.multilabel.errormeasurers.MultiLabelErrorMeasurer;
 import moa.classifiers.rules.multilabel.outputselectors.OutputAttributesSelector;
 import moa.core.StringUtils;
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/splitcriteria/MultiTargetVarianceRatio.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/splitcriteria/MultiTargetVarianceRatio.java
index c9a3a9904..4f64f7c44 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/splitcriteria/MultiTargetVarianceRatio.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/core/splitcriteria/MultiTargetVarianceRatio.java
@@ -1,5 +1,6 @@
 package moa.classifiers.rules.multilabel.core.splitcriteria;
 
+import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.rules.core.Utils;
 import moa.core.DoubleVector;
 import moa.core.ObjectRepository;
diff --git a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java b/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
index a2dcd0b7c..74bbeabe8 100644
--- a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
+++ b/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
@@ -1,1000 +1,987 @@
-<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
-=======
-<<<<<<< HEAD
-/*
- *    FIMTDD.java
- *    Copyright (C) 2015 Jožef Stefan Institute, Ljubljana, Slovenia
- *    @author Aljaž Osojnik <aljaz.osojnik@ijs.si>
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.classifiers.trees;
-
-import java.io.Serializable;
-import java.util.Arrays;
-import java.util.LinkedList;
-import java.util.List;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-
-import moa.options.ClassOption;
-import moa.AbstractMOAObject;
-import moa.classifiers.Regressor;
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
-import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.classifiers.AbstractClassifier;
-import moa.core.AutoExpandVector;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.core.SizeOf;
-import moa.core.StringUtils;
-
-/*
- * Implementation of FIMTDD, regression and model trees for data streams.
- */
-
-public class FIMTDD extends AbstractClassifier implements Regressor {
-
-	private static final long serialVersionUID = 1L;
-
-	protected Node treeRoot;
-
-	protected int leafNodeCount = 0;
-	protected int splitNodeCount = 0;
-
-	protected double examplesSeen = 0.0;
-	protected double sumOfValues = 0.0;
-	protected double sumOfSquares = 0.0;
-
-	protected DoubleVector sumOfAttrValues = new DoubleVector();
-	protected DoubleVector sumOfAttrSquares = new DoubleVector();
-
-	public int maxID = 0;
-
-	//region ================ OPTIONS ================
-
-	public ClassOption splitCriterionOption = new ClassOption(
-			"splitCriterion", 's', "Split criterion to use.",
-			SplitCriterion.class, "moa.classifiers.core.splitcriteria.VarianceReductionSplitCriterion");
-
-	public IntOption gracePeriodOption = new IntOption(
-			"gracePeriod", 'g', "Number of instances a leaf should observe between split attempts.",
-			200, 0, Integer.MAX_VALUE);
-
-	public FloatOption splitConfidenceOption = new FloatOption(
-			"splitConfidence", 'c', "Allowed error in split decision, values close to 0 will take long to decide.",
-			0.0000001, 0.0, 1.0);
-
-	public FloatOption tieThresholdOption = new FloatOption(
-			"tieThreshold", 't', "Threshold below which a split will be forced to break ties.",
-			0.05, 0.0, 1.0);
-
-	public FloatOption PageHinckleyAlphaOption = new FloatOption(
-			"PageHinckleyAlpha", 'a', "Alpha value to use in the Page Hinckley change detection tests.",
-			0.005, 0.0, 1.0);
-
-	public IntOption PageHinckleyThresholdOption = new IntOption(
-			"PageHinckleyThreshold", 'h', "Threshold value used in the Page Hinckley change detection tests.",
-			50, 0, Integer.MAX_VALUE);
-
-	public FloatOption alternateTreeFadingFactorOption = new FloatOption(
-			"alternateTreeFadingFactor", 'f', "Fading factor used to decide if an alternate tree should replace an original.",
-			0.995, 0.0, 1.0);
-
-	public IntOption alternateTreeTMinOption = new IntOption(
-			"alternateTreeTMin", 'y', "Tmin value used to decide if an alternate tree should replace an original.",
-			150, 0, Integer.MAX_VALUE);
-
-	public IntOption alternateTreeTimeOption = new IntOption(
-			"alternateTreeTime", 'u', "The number of instances used to decide if an alternate tree should be discarded.",
-			1500, 0, Integer.MAX_VALUE);
-
-	public FlagOption regressionTreeOption = new FlagOption(
-			"regressionTree", 'e', "Build a regression tree instead of a model tree.");
-
-	public FloatOption learningRatioOption = new FloatOption(
-			"learningRatio", 'l', "Learning ratio to used for training the Perceptrons in the leaves.",
-			0.003, 0, 1.00);
-
-	public FloatOption learningRateDecayFactorOption = new FloatOption(
-			"learningRatioDecayFactor", 'd', "Learning rate decay factor (not used when learning rate is constant).",
-			0.001, 0, 1.00);
-
-	public FlagOption learningRatioConstOption = new FlagOption(
-			"learningRatioConst", 'p', "Keep learning rate constant instead of decaying.");
-
-	//endregion ================ OPTIONS ================
-
-	//region ================ CLASSES ================
-
-	public abstract static class Node extends AbstractMOAObject {
-
-		private static final long serialVersionUID = 1L;
-
-		public int ID;
-
-		protected FIMTDD tree;
-		
-		protected boolean changeDetection = true;
-		
-		protected Node parent;
-
-		protected Node alternateTree;
-		protected Node originalNode;
-
-		// The statistics for this node:
-		// Number of instances that have reached it
-		protected double examplesSeen;
-		// Sum of y values
-		protected double sumOfValues;
-		// Sum of squared y values
-		protected double sumOfSquares;
-		// Sum of absolute errors
-		protected double sumOfAbsErrors; // Needed for PH tracking of mean error
-
-		public Node(FIMTDD tree) {
-			this.tree = tree;
-			ID = tree.maxID; 
-		}
-
-		public void copyStatistics(Node node) {
-			examplesSeen = node.examplesSeen;
-			sumOfValues = node.sumOfValues;
-			sumOfSquares = node.sumOfSquares;
-			sumOfAbsErrors = node.sumOfAbsErrors;
-		}
-
-		public int calcByteSize() {
-			return (int) SizeOf.fullSizeOf(this);
-		}
-
-		/**
-		 * Set the parent node
-		 */
-		public void setParent(Node parent) {
-			this.parent = parent;    
-		}
-
-		/**
-		 * Return the parent node
-		 */
-		public Node getParent() {
-			return parent;
-		}
-
-		public void disableChangeDetection() {
-			changeDetection = false;
-		}
-
-		public void restartChangeDetection() {
-			changeDetection = true;
-		}
-		
-		public void getDescription(StringBuilder sb, int indent) {
-			
-		}
-
-		public double getPrediction(Instance inst) {
-			return 0;
-		}
-		
-		public void describeSubtree(StringBuilder out, int indent) {
-			StringUtils.appendIndented(out, indent, "Leaf");
-		}
-		
-		public int getLevel() {
-			Node target = this;
-			int level = 0;
-			while (target.getParent() != null) {
-				if (target.skipInLevelCount()) {
-					target = target.getParent();
-					continue;
-				}
-				level = level + 1;
-				target = target.getParent();
-			}
-			if (target.originalNode == null) {
-				return level;
-			} else {
-				return level + originalNode.getLevel();
-			}
-		}
-
-		public void setChild(int parentBranch, Node node) {
-		}
-
-		public int getChildIndex(Node child) {
-			return -1;
-		}
-
-		public int getNumSubtrees() {
-			return 1;
-		}
-
-		protected boolean skipInLevelCount() {
-			return false;
-		}
-	}
-
-	public static class LeafNode extends Node {
-
-		private static final long serialVersionUID = 1L;
-
-		public double errorModel = 0.0;
-		public double errorTargetMean = 0.0;
-		
-		// Perceptron model that carries out the actual learning in each node
-		public FIMTDDPerceptron learningModel;
-
-		protected AutoExpandVector<FIMTDDNumericAttributeClassObserver> attributeObservers = new AutoExpandVector<FIMTDDNumericAttributeClassObserver>();
-		
-		protected double examplesSeenAtLastSplitEvaluation = 0;
-
-		/**
-		 * Create a new LeafNode
-		 */
-		public LeafNode(FIMTDD tree) {
-			super(tree);
-			if (tree.buildingModelTree()) {
-				learningModel = tree.newLeafModel();
-			}
-			examplesSeen = 0;
-			sumOfValues = 0;
-			sumOfSquares = 0;
-			sumOfAbsErrors = 0;
-		}
-
-		public void setChild(int parentBranch, Node node) {
-		}
-
-		public int getChildIndex(Node child) {
-			return -1;
-		}
-
-		public int getNumSubtrees() {
-			return 1;
-		}
-
-		protected boolean skipInLevelCount() {
-			return false;
-		}
-		
-		/**
-		 * Method to learn from an instance that passes the new instance to the perceptron learner,
-		 * and also prevents the class value from being truncated to an int when it is passed to the
-		 * attribute observer
-		 */
-		public void learnFromInstance(Instance inst, boolean growthAllowed, double prediction) {
-			//The prediction must be calculated here -- it may be different from the tree's prediction due to alternate trees
-			
-			// Update the statistics for this node
-			// number of instances passing through the node
-			examplesSeen += inst.weight();
-
-			// sum of y values
-			sumOfValues += inst.weight() * inst.classValue();
-
-			// sum of squared y values
-			sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
-
-			// sum of absolute errors
-			sumOfAbsErrors += inst.weight() * Math.abs(tree.normalizeTargetValue(Math.abs(inst.classValue() - prediction)));
-			
-			if (tree.buildingModelTree()) {
-				double predictionModel = getPredictionModel(inst);
-				double predictionTargetMean = getPredictionTargetMean(inst);
-				
-				errorModel = errorModel * 0.95 + Math.abs(predictionModel - inst.classValue());
-				errorTargetMean = errorTargetMean * 0.95 + Math.abs(predictionTargetMean - inst.classValue());
-				
-				learningModel.updatePerceptron(inst);
-			}
-
-			for (int i = 0; i < inst.numAttributes() - 1; i++) {
-				int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
-				FIMTDDNumericAttributeClassObserver obs = attributeObservers.get(i);
-				if (obs == null) {
-					// At this stage all nominal attributes are ignored
-					if (inst.attribute(instAttIndex).isNumeric()) {
-						obs = tree.newNumericClassObserver();
-						this.attributeObservers.set(i, obs);
-					}
-				}
-				if (obs != null) {
-					obs.observeAttributeClass(inst.value(instAttIndex), inst.classValue(), inst.weight());
-				}
-			}
-
-			if (growthAllowed) {
-				checkForSplit();
-			}
-		}
-
-		/**
-		 * Return the best split suggestions for this node using the given split criteria
-		 */
-		public AttributeSplitSuggestion[] getBestSplitSuggestions(SplitCriterion criterion) {
-
-			List<AttributeSplitSuggestion> bestSuggestions = new LinkedList<AttributeSplitSuggestion>();
-
-			// Set the nodeStatistics up as the preSplitDistribution, rather than the observedClassDistribution
-			double[] nodeSplitDist = new double[] {examplesSeen, sumOfValues, sumOfSquares};
-
-			for (int i = 0; i < this.attributeObservers.size(); i++) {
-				FIMTDDNumericAttributeClassObserver obs = this.attributeObservers.get(i);
-				if (obs != null) {
-
-					// AT THIS STAGE NON-NUMERIC ATTRIBUTES ARE IGNORED
-					AttributeSplitSuggestion bestSuggestion = null;
-					if (obs instanceof FIMTDDNumericAttributeClassObserver) {
-						bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion, nodeSplitDist, i, true);
-					}
-
-					if (bestSuggestion != null) {
-						bestSuggestions.add(bestSuggestion);
-					}
-				}
-			}
-			return bestSuggestions.toArray(new AttributeSplitSuggestion[bestSuggestions.size()]);
-		}
-
-		/**
-		 * Retrieve the class votes using the perceptron learner
-		 */
-		public double getPredictionModel(Instance inst) {
-			return learningModel.prediction(inst);
-		}
-
-		public double getPredictionTargetMean(Instance inst) {
-			return (examplesSeen > 0.0) ? sumOfValues / examplesSeen : 0.0;
-		}
-
-		public double getPrediction(Instance inst) {
-			if (tree.buildingModelTree()) {
-				//return getPredictionModel(inst);
-				return (errorModel < errorTargetMean) ? getPredictionModel(inst) : getPredictionTargetMean(inst);
-			} else
-				return getPredictionTargetMean(inst);
-		}
-		
-		public void checkForSplit() {
-			// If it has seen Nmin examples since it was last tested for splitting, attempt a split of this node
-			if (examplesSeen - examplesSeenAtLastSplitEvaluation >= tree.gracePeriodOption.getValue()) {
-				int index = (parent != null) ? parent.getChildIndex(this) : 0;
-				tree.attemptToSplit(this, parent, index);
-
-				// Take note of how many instances were seen when this split evaluation was made, so we know when to perform the next split evaluation
-				examplesSeenAtLastSplitEvaluation = examplesSeen;
-			}
-		}
-
-		public void describeSubtree(StringBuilder out, int indent) {
-			StringUtils.appendIndented(out, indent, "Leaf ");
-			if (tree.buildingModelTree()) {
-				learningModel.getModelDescription(out, 0);
-			} else {
-				out.append(tree.getClassNameString() + " = " + String.format("%.4f", sumOfValues / examplesSeen));
-				StringUtils.appendNewline(out);
-			}
-		}
-	}
-
-	public abstract static class InnerNode extends Node {
-		// The InnerNode and SplitNode design is used for easy extension in ORTO
-		private static final long serialVersionUID = 1L;
-
-		protected AutoExpandVector<Node> children = new AutoExpandVector<Node>();
-
-		// The error values for the Page Hinckley test
-		// PHmT = the cumulative sum of the errors
-		// PHMT = the minimum error value seen so far
-		protected double PHsum = 0;
-		protected double PHmin = Double.MAX_VALUE;
-
-		// Keep track of the statistics for loss error calculations
-		protected double lossExamplesSeen;
-		protected double lossFadedSumOriginal;
-		protected double lossFadedSumAlternate;
-		protected double lossNumQiTests;
-		protected double lossSumQi;
-		protected double previousWeight = 0;
-		
-		public InnerNode(FIMTDD tree) {
-			super(tree);
-		}
-
-		public int numChildren() {
-			return children.size();
-		}
-
-		public Node getChild(int index) {
-			return children.get(index);
-		}
-
-		public int getChildIndex(Node child) {
-			return children.indexOf(child);
-		}
-
-		public void setChild(int index, Node child) {
-			children.set(index, child);
-		}
-
-		public void disableChangeDetection() {
-			changeDetection = false;
-			for (Node child : children) {
-				child.disableChangeDetection();
-			}
-		}
-
-		public void restartChangeDetection() {
-			if (alternateTree == null) {
-				changeDetection = true;
-				PHsum = 0;
-				PHmin = Integer.MAX_VALUE;
-				for (Node child : children)
-					child.restartChangeDetection();
-			}
-		}
-		
-		/**
-		 * Check to see if the tree needs updating
-		 */
-		public boolean PageHinckleyTest(double error, double threshold) {    
-			// Update the cumulative mT sum
-			PHsum += error;
-
-			// Update the minimum mT value if the new mT is
-			// smaller than the current minimum
-			if(PHsum < PHmin) {
-				PHmin = PHsum;
-			}
-			// Return true if the cumulative value - the current minimum is
-			// greater than the current threshold (in which case we should adapt)
-			return PHsum - PHmin > threshold;
-		}
-		
-		public void initializeAlternateTree() {
-			// Start a new alternate tree, beginning with a learning node
-			alternateTree = tree.newLeafNode();
-			alternateTree.originalNode = this;
-
-			// Set up the blank statistics
-			// Number of instances reaching this node since the alternate tree was started
-			lossExamplesSeen = 0;
-			// Faded squared error (original tree)
-			lossFadedSumOriginal = 0;
-			// Faded squared error (alternate tree)
-			lossFadedSumAlternate = 0;
-			// Number of evaluations of alternate tree
-			lossNumQiTests = 0;
-			// Sum of Qi values
-			lossSumQi = 0;
-			// Number of examples at last test
-			previousWeight = 0;
-
-			// Disable the change detection mechanism bellow this node
-			disableChangeDetection();
-		}
-	}
-	
-	public static class SplitNode extends InnerNode {
-
-		private static final long serialVersionUID = 1L;
-
-		protected InstanceConditionalTest splitTest;
-
-		/**
-		 * Create a new SplitNode
-		 * @param tree 
-		 */
-		public SplitNode(InstanceConditionalTest splitTest, FIMTDD tree) {
-			super(tree);
-			this.splitTest = splitTest;
-		}
-
-		public int instanceChildIndex(Instance inst) {
-			return splitTest.branchForInstance(inst);
-		}
-		
-		public Node descendOneStep(Instance inst) {
-			return children.get(splitTest.branchForInstance(inst));
-		}
-
-		public void describeSubtree(StringBuilder out, int indent) {
-			for (int branch = 0; branch < children.size(); branch++) {
-				Node child = getChild(branch);
-				if (child != null) {
-					StringUtils.appendIndented(out, indent, "if ");
-					out.append(this.splitTest.describeConditionForBranch(branch,
-							tree.getModelContext()));
-					out.append(": ");
-					StringUtils.appendNewline(out);
-					child.describeSubtree(out, indent + 2);
-				}
-			}
-		}
-
-		public double getPrediction(Instance inst) {
-			return children.get(splitTest.branchForInstance(inst)).getPrediction(inst);
-		}
-	}
-
-	public class FIMTDDPerceptron implements Serializable {
-
-		private static final long serialVersionUID = 1L;
-		
-		protected FIMTDD tree;
-		
-		// The Perception weights 
-		protected double[] weightAttribute; 
-
-		// The number of instances contributing to this model
-		protected double instancesSeen = 0;
-
-		public String getPurposeString() {
-			return "A perceptron regressor as specified by Ikonomovska et al. used for FIMTDD";
-		}
-
-		public FIMTDDPerceptron(FIMTDDPerceptron original) {
-			this.tree = original.tree;
-			weightAttribute = original.weightAttribute.clone();
-		}
-
-		public FIMTDDPerceptron(FIMTDD tree) {
-			this.tree = tree;
-			initializeWeights();
-
-		}
-
-		public void initializeWeights() {
-			weightAttribute = new double[tree.getModelContext().numInputAttributes()+1];
-			instancesSeen = 0;
-			for (int j = 0; j < tree.getModelContext().numInputAttributes()+1; j++) {
-				// The last index corresponds to the constant b
-				weightAttribute[j] = 2 * tree.classifierRandom.nextDouble() - 1;
-			}
-			normalizeWeights();
-		}
-		
-		/**
-		 * Update the model using the provided instance
-		 */
-		public void updatePerceptron(Instance inst) {
-
-			// Update attribute statistics
-			instancesSeen += inst.weight();
-
-			// Update weights
-			double learningRatio = 0.0;
-			if (tree.learningRatioConstOption.isSet()) {
-				learningRatio = learningRatioOption.getValue();
-			} else {
-				learningRatio = learningRatioOption.getValue() / (1 + instancesSeen * tree.learningRateDecayFactorOption.getValue());
-			}
-
-			// Loop for compatibility with bagging methods 
-			for (int i = 0; i < (int) inst.weight(); i++) {
-				updateWeights(inst, learningRatio);
-			}
-		
-		}
-
-		public void updateWeights(Instance inst, double learningRatio) {
-			// Compute the normalized instance and the delta
-			double[] normalizedInstance = normalizedInstance(inst); 
-			double normalizedPrediction = prediction(normalizedInstance);
-			double normalizedValue = tree.normalizeTargetValue(inst.classValue());
-			double delta = normalizedValue - normalizedPrediction;
-			for (int i = 0; i < weightAttribute.length; i++) {
-				weightAttribute[i] += delta * learningRatio * normalizedInstance[i];
-			}
-			
-			normalizeWeights();
-		}
-		
-		public void normalizeWeights() {
-			double sum = 0;
-			for (int i = 0; i < this.weightAttribute.length; i++)
-				sum += Math.abs(weightAttribute[i]);
-			for (int i = 0; i < this.weightAttribute.length; i++)
-				weightAttribute[i] /= sum;
-		}
-
-		public double[] normalizedInstance(Instance inst) {
-			// Normalize Instance
-			double[] normalizedInstance = new double[inst.numInputAttributes()+1];
-			for (int j = 0; j < inst.numInputAttributes(); j++) {
-				double mean = tree.sumOfAttrValues.getValue(j) / tree.examplesSeen;
-				double sd = computeSD(tree.sumOfAttrSquares.getValue(j), tree.sumOfAttrValues.getValue(j), tree.examplesSeen);
-				if (inst.inputAttribute(j).isNumeric() && tree.examplesSeen > 1 && sd > 0.0000001)
-					normalizedInstance[j] = (inst.valueInputAttribute(j) - mean) / (sd);
-				else
-					normalizedInstance[j] = 0;
-			}
-			normalizedInstance[inst.numInputAttributes()] = tree.examplesSeen > 1 ? 1 : 0; // Value to be multiplied with the constant factor
-			return normalizedInstance;
-		}
-
-		/**
-		 * Output the prediction made by this perceptron on the given instance
-		 */
-		public double prediction(double[] instanceValues) {
-			double ret = 0;
-			for (int i = 0; i < instanceValues.length; i++)
-				ret += instanceValues[i] * weightAttribute[i];
-			return ret;
-		}
-
-		protected double prediction(Instance inst) {
-			double[] normalizedInstance = normalizedInstance(inst);
-			double normalizedPrediction = prediction(normalizedInstance);
-			return denormalizePrediction(normalizedPrediction);
-		}
-
-		private double denormalizePrediction(double normalizedPrediction) {
-			double mean = tree.sumOfValues / tree.examplesSeen;
-			double sd = computeSD(tree.sumOfSquares, tree.sumOfValues, tree.examplesSeen);
-			if (examplesSeen > 1) 
-				return normalizedPrediction * sd + mean;
-			else
-				return 0.0;
-		}
-		
-		public void getModelDescription(StringBuilder out, int indent) {
-	        StringUtils.appendIndented(out, indent, getClassNameString() + " =");
-			if (getModelContext() != null) {
-				for (int j = 0; j < getModelContext().numAttributes() - 1; j++) {
-					if (getModelContext().attribute(j).isNumeric()) {
-						out.append((j == 0 || weightAttribute[j] < 0) ? " " : " + ");
-		                out.append(String.format("%.4f", weightAttribute[j]));
-		                out.append(" * ");
-		                out.append(getAttributeNameString(j));
-		            }
-		        }
-				out.append(" + " + weightAttribute[getModelContext().numInputAttributes()]);
-			}
-	        StringUtils.appendNewline(out);
-		}
-	}
-
-
-	//endregion ================ CLASSES ================
-
-	//region ================ METHODS ================
-
-	// region --- Regressor methods
-	
-	public String getPurposeString() {
-		return "Implementation of the FIMT-DD tree as described by Ikonomovska et al.";
-	}
-
-	public void resetLearningImpl() {
-		this.treeRoot = null;
-		this.leafNodeCount = 0;
-		this.splitNodeCount = 0;
-		this.maxID = 0;
-		this.examplesSeen = 0;
-		this.sumOfValues = 0.0;
-		this.sumOfSquares = 0.0;
-
-		this.sumOfAttrValues = new DoubleVector();
-		this.sumOfAttrSquares = new DoubleVector();
-	}
-
-	public boolean isRandomizable() {
-		return true;
-	}
-
-	public void getModelDescription(StringBuilder out, int indent) {
-		if (treeRoot != null) treeRoot.describeSubtree(out, indent);
-	}
-
-	protected Measurement[] getModelMeasurementsImpl() {
-		return new Measurement[]{ 
-				new Measurement("tree size (leaves)", this.leafNodeCount)
-		};
-	}
-
-	public int calcByteSize() {
-		return (int) SizeOf.fullSizeOf(this);
-	}
-
-	public double[] getVotesForInstance(Instance inst) {
-		if (treeRoot == null) {
-			return new double[] {0};
-		}
-
-		double prediction = treeRoot.getPrediction(inst);
-
-		return new double[] {prediction};
-	}
-
-	public double normalizeTargetValue(double value) {
-		if (examplesSeen > 1) {
-			double sd = Math.sqrt((sumOfSquares - ((sumOfValues * sumOfValues)/examplesSeen))/examplesSeen);
-			double average = sumOfValues / examplesSeen;
-			if (sd > 0 && examplesSeen > 1)
-				return (value - average) / sd;
-			else
-				return 0.0;
-		}
-		return 0.0;
-	}
-
-	public double getNormalizedError(Instance inst, double prediction) {
-		double normalPrediction = normalizeTargetValue(prediction);
-		double normalValue = normalizeTargetValue(inst.classValue());
-		return Math.abs(normalValue - normalPrediction);
-	}
-
-
-	/**
-	 * Method for updating (training) the model using a new instance
-	 */
-	public void trainOnInstanceImpl(Instance inst) {
-		checkRoot();
-
-		double prediction = treeRoot.getPrediction(inst);
-		double normalError = getNormalizedError(inst, prediction);
-	
-		processInstance(inst, treeRoot, prediction, normalError, true, false);
-		
-		examplesSeen += inst.weight();
-		sumOfValues += inst.weight() * inst.classValue();
-		sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
-
-		for (int i = 0; i < inst.numAttributes() - 1; i++) {
-			int aIndex = modelAttIndexToInstanceAttIndex(i, inst);
-			sumOfAttrValues.addToValue(i, inst.weight() * inst.value(aIndex));
-			sumOfAttrSquares.addToValue(i, inst.weight() * inst.value(aIndex) * inst.value(aIndex));
-		}
-
-
-	}
-
-	public void processInstance(Instance inst, Node node, double prediction, double normalError, boolean growthAllowed, boolean inAlternate) {
-		Node currentNode = node;
-		while (true) {
-			if (currentNode instanceof LeafNode) {
-				((LeafNode) currentNode).learnFromInstance(inst, growthAllowed, prediction);
-				break;
-			} else {
-				currentNode.examplesSeen += inst.weight();
-				currentNode.sumOfAbsErrors += inst.weight() * normalError;
-				InnerNode iNode = (InnerNode) currentNode;
-				if (!inAlternate && iNode.alternateTree != null) {
-					boolean altTree = true;
-					double lossO = Math.pow(inst.classValue() - prediction, 2);
-					double lossA = Math.pow(inst.classValue() - iNode.alternateTree.getPrediction(inst), 2);
-					
-					// Loop for compatibility with bagging methods
-					for (int i = 0; i < inst.weight(); i++) {
-						iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
-						iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
-						iNode.lossExamplesSeen++;
-						
-						double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
-						iNode.lossSumQi += Qi;
-						iNode.lossNumQiTests += 1;
-					}
-					double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
-					double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
-					double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
-					
-					if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
-						iNode.previousWeight = iNode.lossExamplesSeen;
-						if (Qi > 0) {
-							// Switch the subtrees
-							Node parent = iNode.getParent();
-
-							if (parent != null) {
-								Node replacementTree = iNode.alternateTree;
-								parent.setChild(parent.getChildIndex(iNode), replacementTree);
-								if (growthAllowed) replacementTree.restartChangeDetection();
-							} else {
-								treeRoot = iNode.alternateTree;
-								treeRoot.restartChangeDetection();
-							}
-
-							currentNode = iNode.alternateTree;
-							currentNode.originalNode = null;
-							altTree = false;
-						} else if (QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * alternateTreeTMinOption.getValue()) || iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()) {
-							// Remove the alternate tree
-							iNode.alternateTree = null;
-							if (growthAllowed) iNode.restartChangeDetection();
-							altTree = false;
-						}
-					}
-
-					if (altTree) {
-						growthAllowed = false;
-						processInstance(inst, iNode.alternateTree, prediction, normalError, true, true);
-					}
-				}
-
-				if (false && iNode.changeDetection && !inAlternate) {
-					if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
-						iNode.initializeAlternateTree();
-						growthAllowed = false;
-					}
-				}
-				if (currentNode instanceof SplitNode) {
-					currentNode = ((SplitNode) currentNode).descendOneStep(inst);
-				} 
-			}
-		}
-	}
-
-	// endregion --- Regressor methods
-	
-	// region --- Object instatiation methods
-
-	protected FIMTDDNumericAttributeClassObserver newNumericClassObserver() {
-		return new FIMTDDNumericAttributeClassObserver();
-	}
-
-	protected SplitNode newSplitNode(InstanceConditionalTest splitTest) {
-		maxID++;
-		return new SplitNode(splitTest, this);
-	}
-
-	protected LeafNode newLeafNode() {
-		maxID++;
-		return new LeafNode(this);
-	}
-
-	protected FIMTDDPerceptron newLeafModel() {
-		return new FIMTDDPerceptron(this);
-	}
-
-	//endregion --- Object instatiation methods
-	
-	// region --- Processing methods
-	
-	protected void checkRoot() {
-		if (treeRoot == null) {
-			treeRoot = newLeafNode();
-			leafNodeCount = 1;
-		}
-	}
-
-	public static double computeHoeffdingBound(double range, double confidence, double n) {
-		return Math.sqrt(( (range * range) * Math.log(1 / confidence)) / (2.0 * n));
-	}
-
-	public boolean buildingModelTree() {
-		return !regressionTreeOption.isSet();
-	}
-
-	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
-
-		// Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
- 		SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
-
-		// Using this criterion, find the best split per attribute and rank the results
-		AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion);
-		Arrays.sort(bestSplitSuggestions);
-
-		// Declare a variable to determine if any of the splits should be performed
-		boolean shouldSplit = false;
-
-		// If only one split was returned, use it
-		if (bestSplitSuggestions.length < 2) {
-			shouldSplit = bestSplitSuggestions.length > 0;
-		} else { // Otherwise, consider which of the splits proposed may be worth trying
-
-			// Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
-			// to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
-			double hoeffdingBound = computeHoeffdingBound(1, this.splitConfidenceOption.getValue(), node.examplesSeen);
-			// Determine the top two ranked splitting suggestions
-			AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-			AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
-
-			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
-			// as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
-			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
-			// splitting should occur.
-			// Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
-			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
-			// competing attributes are equally good, and the split will be made on the one with the higher SDR value.
-			if ((secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) || (hoeffdingBound < this.tieThresholdOption.getValue())) {
-				shouldSplit = true;
-			}
-			// If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
-			else {
-				for (int i = 0; i < node.attributeObservers.size(); i++) {
-					FIMTDDNumericAttributeClassObserver obs = node.attributeObservers.get(i);
-					if (obs != null) {
-						obs.removeBadSplits(splitCriterion, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound);    
-					}
-				}
-			}
-//			if (hoeffdingBound < this.tieThresholdOption.getValue() && !(secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound)) {
-//				System.out.println("Forced to split due to tie at " + this.examplesSeen);
-//				System.out.println(SizeOf.fullSizeOf(node.attributeObservers) / 1000000.0);
-//			}
-		}
-
-		// If the splitting criterion were met, split the current node using the chosen attribute test, and
-		// make two new branches leading to (empty) leaves
-		if (shouldSplit) {
-//			System.out.println("splitting node");
-//			System.out.println(SizeOf.fullSizeOf(node.attributeObservers) / 1000000.0);
-//			if (node.parent == null) {
-//				System.out.println("splitting root node at " + this.examplesSeen);
-//			}
-			AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-						
-			SplitNode newSplit = newSplitNode(splitDecision.splitTest);
-			newSplit.copyStatistics(node);
-			newSplit.changeDetection = node.changeDetection;
-			newSplit.ID = node.ID;
-			leafNodeCount--;
-			for (int i = 0; i < splitDecision.numSplits(); i++) {
-				LeafNode newChild = newLeafNode();
-				if (buildingModelTree()) {
-					// Copy the splitting node's perceptron to it's children
-					newChild.learningModel = new FIMTDDPerceptron((FIMTDDPerceptron) node.learningModel);
-					
-				}
-				newChild.changeDetection = node.changeDetection;
-				newChild.setParent(newSplit);
-				newSplit.setChild(i, newChild);
-				leafNodeCount++;
-			}
-			if (parent == null && node.originalNode == null) {
-				treeRoot = newSplit;
-			} else if (parent == null && node.originalNode != null) {
-				node.originalNode.alternateTree = newSplit;
-			} else {
-				((SplitNode) parent).setChild(parentIndex, newSplit);
-				newSplit.setParent(parent);
-			}
-			
-			splitNodeCount++;
-		}
-	}
-	
-	public double computeSD(double squaredVal, double val, double size) {
-		if (size > 1)
-			return Math.sqrt((squaredVal - ((val * val) / size)) / size);
-		else
-			return 0.0;
-	}
-	
-	public double scalarProduct(DoubleVector u, DoubleVector v) {
-		double ret = 0.0;
-		for (int i = 0; i < Math.max(u.numValues(), v.numValues()); i++) {
-			ret += u.getValue(i) * v.getValue(i);
-		}
-		return ret;
-	}
-	//endregion --- Processing methods
-	
-	//endregion ================ METHODS ================
-}
-
+/*
+ *    FIMTDD.java
+ *    Copyright (C) 2015 Jožef Stefan Institute, Ljubljana, Slovenia
+ *    @author Aljaž Osojnik <aljaz.osojnik@ijs.si>
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *    
+ *    
+ */
+
+package moa.classifiers.trees;
+
+import java.io.Serializable;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+
+import moa.options.ClassOption;
+import moa.AbstractMOAObject;
+import moa.classifiers.Regressor;
+import moa.classifiers.core.AttributeSplitSuggestion;
+import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
+import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
+import moa.classifiers.core.splitcriteria.SplitCriterion;
+import moa.classifiers.AbstractClassifier;
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.SizeOf;
+import moa.core.StringUtils;
+
+/*
+ * Implementation of FIMTDD, regression and model trees for data streams.
+ */
+
+public class FIMTDD extends AbstractClassifier implements Regressor {
+
+	private static final long serialVersionUID = 1L;
+
+	protected Node treeRoot;
+
+	protected int leafNodeCount = 0;
+	protected int splitNodeCount = 0;
+
+	protected double examplesSeen = 0.0;
+	protected double sumOfValues = 0.0;
+	protected double sumOfSquares = 0.0;
+
+	protected DoubleVector sumOfAttrValues = new DoubleVector();
+	protected DoubleVector sumOfAttrSquares = new DoubleVector();
+
+	public int maxID = 0;
+
+	//region ================ OPTIONS ================
+
+	public ClassOption splitCriterionOption = new ClassOption(
+			"splitCriterion", 's', "Split criterion to use.",
+			SplitCriterion.class, "moa.classifiers.core.splitcriteria.VarianceReductionSplitCriterion");
+
+	public IntOption gracePeriodOption = new IntOption(
+			"gracePeriod", 'g', "Number of instances a leaf should observe between split attempts.",
+			200, 0, Integer.MAX_VALUE);
+
+	public FloatOption splitConfidenceOption = new FloatOption(
+			"splitConfidence", 'c', "Allowed error in split decision, values close to 0 will take long to decide.",
+			0.0000001, 0.0, 1.0);
+
+	public FloatOption tieThresholdOption = new FloatOption(
+			"tieThreshold", 't', "Threshold below which a split will be forced to break ties.",
+			0.05, 0.0, 1.0);
+
+	public FloatOption PageHinckleyAlphaOption = new FloatOption(
+			"PageHinckleyAlpha", 'a', "Alpha value to use in the Page Hinckley change detection tests.",
+			0.005, 0.0, 1.0);
+
+	public IntOption PageHinckleyThresholdOption = new IntOption(
+			"PageHinckleyThreshold", 'h', "Threshold value used in the Page Hinckley change detection tests.",
+			50, 0, Integer.MAX_VALUE);
+
+	public FloatOption alternateTreeFadingFactorOption = new FloatOption(
+			"alternateTreeFadingFactor", 'f', "Fading factor used to decide if an alternate tree should replace an original.",
+			0.995, 0.0, 1.0);
+
+	public IntOption alternateTreeTMinOption = new IntOption(
+			"alternateTreeTMin", 'y', "Tmin value used to decide if an alternate tree should replace an original.",
+			150, 0, Integer.MAX_VALUE);
+
+	public IntOption alternateTreeTimeOption = new IntOption(
+			"alternateTreeTime", 'u', "The number of instances used to decide if an alternate tree should be discarded.",
+			1500, 0, Integer.MAX_VALUE);
+
+	public FlagOption regressionTreeOption = new FlagOption(
+			"regressionTree", 'e', "Build a regression tree instead of a model tree.");
+
+	public FloatOption learningRatioOption = new FloatOption(
+			"learningRatio", 'l', "Learning ratio to used for training the Perceptrons in the leaves.",
+			0.003, 0, 1.00);
+
+	public FloatOption learningRateDecayFactorOption = new FloatOption(
+			"learningRatioDecayFactor", 'd', "Learning rate decay factor (not used when learning rate is constant).",
+			0.001, 0, 1.00);
+
+	public FlagOption learningRatioConstOption = new FlagOption(
+			"learningRatioConst", 'p', "Keep learning rate constant instead of decaying.");
+
+	//endregion ================ OPTIONS ================
+
+	//region ================ CLASSES ================
+
+	public abstract static class Node extends AbstractMOAObject {
+
+		private static final long serialVersionUID = 1L;
+
+		public int ID;
+
+		protected FIMTDD tree;
+		
+		protected boolean changeDetection = true;
+		
+		protected Node parent;
+
+		protected Node alternateTree;
+		protected Node originalNode;
+
+		// The statistics for this node:
+		// Number of instances that have reached it
+		protected double examplesSeen;
+		// Sum of y values
+		protected double sumOfValues;
+		// Sum of squared y values
+		protected double sumOfSquares;
+		// Sum of absolute errors
+		protected double sumOfAbsErrors; // Needed for PH tracking of mean error
+
+		public Node(FIMTDD tree) {
+			this.tree = tree;
+			ID = tree.maxID; 
+		}
+
+		public void copyStatistics(Node node) {
+			examplesSeen = node.examplesSeen;
+			sumOfValues = node.sumOfValues;
+			sumOfSquares = node.sumOfSquares;
+			sumOfAbsErrors = node.sumOfAbsErrors;
+		}
+
+		public int calcByteSize() {
+			return (int) SizeOf.fullSizeOf(this);
+		}
+
+		/**
+		 * Set the parent node
+		 */
+		public void setParent(Node parent) {
+			this.parent = parent;    
+		}
+
+		/**
+		 * Return the parent node
+		 */
+		public Node getParent() {
+			return parent;
+		}
+
+		public void disableChangeDetection() {
+			changeDetection = false;
+		}
+
+		public void restartChangeDetection() {
+			changeDetection = true;
+		}
+		
+		public void getDescription(StringBuilder sb, int indent) {
+			
+		}
+
+		public double getPrediction(Instance inst) {
+			return 0;
+		}
+		
+		public void describeSubtree(StringBuilder out, int indent) {
+			StringUtils.appendIndented(out, indent, "Leaf");
+		}
+		
+		public int getLevel() {
+			Node target = this;
+			int level = 0;
+			while (target.getParent() != null) {
+				if (target.skipInLevelCount()) {
+					target = target.getParent();
+					continue;
+				}
+				level = level + 1;
+				target = target.getParent();
+			}
+			if (target.originalNode == null) {
+				return level;
+			} else {
+				return level + originalNode.getLevel();
+			}
+		}
+
+		public void setChild(int parentBranch, Node node) {
+		}
+
+		public int getChildIndex(Node child) {
+			return -1;
+		}
+
+		public int getNumSubtrees() {
+			return 1;
+		}
+
+		protected boolean skipInLevelCount() {
+			return false;
+		}
+	}
+
+	public static class LeafNode extends Node {
+
+		private static final long serialVersionUID = 1L;
+
+		public double errorModel = 0.0;
+		public double errorTargetMean = 0.0;
+		
+		// Perceptron model that carries out the actual learning in each node
+		public FIMTDDPerceptron learningModel;
+
+		protected AutoExpandVector<FIMTDDNumericAttributeClassObserver> attributeObservers = new AutoExpandVector<FIMTDDNumericAttributeClassObserver>();
+		
+		protected double examplesSeenAtLastSplitEvaluation = 0;
+
+		/**
+		 * Create a new LeafNode
+		 */
+		public LeafNode(FIMTDD tree) {
+			super(tree);
+			if (tree.buildingModelTree()) {
+				learningModel = tree.newLeafModel();
+			}
+			examplesSeen = 0;
+			sumOfValues = 0;
+			sumOfSquares = 0;
+			sumOfAbsErrors = 0;
+		}
+
+		public void setChild(int parentBranch, Node node) {
+		}
+
+		public int getChildIndex(Node child) {
+			return -1;
+		}
+
+		public int getNumSubtrees() {
+			return 1;
+		}
+
+		protected boolean skipInLevelCount() {
+			return false;
+		}
+		
+		/**
+		 * Method to learn from an instance that passes the new instance to the perceptron learner,
+		 * and also prevents the class value from being truncated to an int when it is passed to the
+		 * attribute observer
+		 */
+		public void learnFromInstance(Instance inst, boolean growthAllowed, double prediction) {
+			//The prediction must be calculated here -- it may be different from the tree's prediction due to alternate trees
+			
+			// Update the statistics for this node
+			// number of instances passing through the node
+			examplesSeen += inst.weight();
+
+			// sum of y values
+			sumOfValues += inst.weight() * inst.classValue();
+
+			// sum of squared y values
+			sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
+
+			// sum of absolute errors
+			sumOfAbsErrors += inst.weight() * Math.abs(tree.normalizeTargetValue(Math.abs(inst.classValue() - prediction)));
+			
+			if (tree.buildingModelTree()) {
+				double predictionModel = getPredictionModel(inst);
+				double predictionTargetMean = getPredictionTargetMean(inst);
+				
+				errorModel = errorModel * 0.95 + Math.abs(predictionModel - inst.classValue());
+				errorTargetMean = errorTargetMean * 0.95 + Math.abs(predictionTargetMean - inst.classValue());
+				
+				learningModel.updatePerceptron(inst);
+			}
+
+			for (int i = 0; i < inst.numAttributes() - 1; i++) {
+				int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
+				FIMTDDNumericAttributeClassObserver obs = attributeObservers.get(i);
+				if (obs == null) {
+					// At this stage all nominal attributes are ignored
+					if (inst.attribute(instAttIndex).isNumeric()) {
+						obs = tree.newNumericClassObserver();
+						this.attributeObservers.set(i, obs);
+					}
+				}
+				if (obs != null) {
+					obs.observeAttributeClass(inst.value(instAttIndex), inst.classValue(), inst.weight());
+				}
+			}
+
+			if (growthAllowed) {
+				checkForSplit();
+			}
+		}
+
+		/**
+		 * Return the best split suggestions for this node using the given split criteria
+		 */
+		public AttributeSplitSuggestion[] getBestSplitSuggestions(SplitCriterion criterion) {
+
+			List<AttributeSplitSuggestion> bestSuggestions = new LinkedList<AttributeSplitSuggestion>();
+
+			// Set the nodeStatistics up as the preSplitDistribution, rather than the observedClassDistribution
+			double[] nodeSplitDist = new double[] {examplesSeen, sumOfValues, sumOfSquares};
+
+			for (int i = 0; i < this.attributeObservers.size(); i++) {
+				FIMTDDNumericAttributeClassObserver obs = this.attributeObservers.get(i);
+				if (obs != null) {
+
+					// AT THIS STAGE NON-NUMERIC ATTRIBUTES ARE IGNORED
+					AttributeSplitSuggestion bestSuggestion = null;
+					if (obs instanceof FIMTDDNumericAttributeClassObserver) {
+						bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion, nodeSplitDist, i, true);
+					}
+
+					if (bestSuggestion != null) {
+						bestSuggestions.add(bestSuggestion);
+					}
+				}
+			}
+			return bestSuggestions.toArray(new AttributeSplitSuggestion[bestSuggestions.size()]);
+		}
+
+		/**
+		 * Retrieve the class votes using the perceptron learner
+		 */
+		public double getPredictionModel(Instance inst) {
+			return learningModel.prediction(inst);
+		}
+
+		public double getPredictionTargetMean(Instance inst) {
+			return (examplesSeen > 0.0) ? sumOfValues / examplesSeen : 0.0;
+		}
+
+		public double getPrediction(Instance inst) {
+			if (tree.buildingModelTree()) {
+				//return getPredictionModel(inst);
+				return (errorModel < errorTargetMean) ? getPredictionModel(inst) : getPredictionTargetMean(inst);
+			} else
+				return getPredictionTargetMean(inst);
+		}
+		
+		public void checkForSplit() {
+			// If it has seen Nmin examples since it was last tested for splitting, attempt a split of this node
+			if (examplesSeen - examplesSeenAtLastSplitEvaluation >= tree.gracePeriodOption.getValue()) {
+				int index = (parent != null) ? parent.getChildIndex(this) : 0;
+				tree.attemptToSplit(this, parent, index);
+
+				// Take note of how many instances were seen when this split evaluation was made, so we know when to perform the next split evaluation
+				examplesSeenAtLastSplitEvaluation = examplesSeen;
+			}
+		}
+
+		public void describeSubtree(StringBuilder out, int indent) {
+			StringUtils.appendIndented(out, indent, "Leaf ");
+			if (tree.buildingModelTree()) {
+				learningModel.getModelDescription(out, 0);
+			} else {
+				out.append(tree.getClassNameString() + " = " + String.format("%.4f", sumOfValues / examplesSeen));
+				StringUtils.appendNewline(out);
+			}
+		}
+	}
+
+	public abstract static class InnerNode extends Node {
+		// The InnerNode and SplitNode design is used for easy extension in ORTO
+		private static final long serialVersionUID = 1L;
+
+		protected AutoExpandVector<Node> children = new AutoExpandVector<Node>();
+
+		// The error values for the Page Hinckley test
+		// PHmT = the cumulative sum of the errors
+		// PHMT = the minimum error value seen so far
+		protected double PHsum = 0;
+		protected double PHmin = Double.MAX_VALUE;
+
+		// Keep track of the statistics for loss error calculations
+		protected double lossExamplesSeen;
+		protected double lossFadedSumOriginal;
+		protected double lossFadedSumAlternate;
+		protected double lossNumQiTests;
+		protected double lossSumQi;
+		protected double previousWeight = 0;
+		
+		public InnerNode(FIMTDD tree) {
+			super(tree);
+		}
+
+		public int numChildren() {
+			return children.size();
+		}
+
+		public Node getChild(int index) {
+			return children.get(index);
+		}
+
+		public int getChildIndex(Node child) {
+			return children.indexOf(child);
+		}
+
+		public void setChild(int index, Node child) {
+			children.set(index, child);
+		}
+
+		public void disableChangeDetection() {
+			changeDetection = false;
+			for (Node child : children) {
+				child.disableChangeDetection();
+			}
+		}
+
+		public void restartChangeDetection() {
+			if (alternateTree == null) {
+				changeDetection = true;
+				PHsum = 0;
+				PHmin = Integer.MAX_VALUE;
+				for (Node child : children)
+					child.restartChangeDetection();
+			}
+		}
+		
+		/**
+		 * Check to see if the tree needs updating
+		 */
+		public boolean PageHinckleyTest(double error, double threshold) {    
+			// Update the cumulative mT sum
+			PHsum += error;
+
+			// Update the minimum mT value if the new mT is
+			// smaller than the current minimum
+			if(PHsum < PHmin) {
+				PHmin = PHsum;
+			}
+			// Return true if the cumulative value - the current minimum is
+			// greater than the current threshold (in which case we should adapt)
+			return PHsum - PHmin > threshold;
+		}
+		
+		public void initializeAlternateTree() {
+			// Start a new alternate tree, beginning with a learning node
+			alternateTree = tree.newLeafNode();
+			alternateTree.originalNode = this;
+
+			// Set up the blank statistics
+			// Number of instances reaching this node since the alternate tree was started
+			lossExamplesSeen = 0;
+			// Faded squared error (original tree)
+			lossFadedSumOriginal = 0;
+			// Faded squared error (alternate tree)
+			lossFadedSumAlternate = 0;
+			// Number of evaluations of alternate tree
+			lossNumQiTests = 0;
+			// Sum of Qi values
+			lossSumQi = 0;
+			// Number of examples at last test
+			previousWeight = 0;
+
+			// Disable the change detection mechanism bellow this node
+			disableChangeDetection();
+		}
+	}
+	
+	public static class SplitNode extends InnerNode {
+
+		private static final long serialVersionUID = 1L;
+
+		protected InstanceConditionalTest splitTest;
+
+		/**
+		 * Create a new SplitNode
+		 * @param tree 
+		 */
+		public SplitNode(InstanceConditionalTest splitTest, FIMTDD tree) {
+			super(tree);
+			this.splitTest = splitTest;
+		}
+
+		public int instanceChildIndex(Instance inst) {
+			return splitTest.branchForInstance(inst);
+		}
+		
+		public Node descendOneStep(Instance inst) {
+			return children.get(splitTest.branchForInstance(inst));
+		}
+
+		public void describeSubtree(StringBuilder out, int indent) {
+			for (int branch = 0; branch < children.size(); branch++) {
+				Node child = getChild(branch);
+				if (child != null) {
+					StringUtils.appendIndented(out, indent, "if ");
+					out.append(this.splitTest.describeConditionForBranch(branch,
+							tree.getModelContext()));
+					out.append(": ");
+					StringUtils.appendNewline(out);
+					child.describeSubtree(out, indent + 2);
+				}
+			}
+		}
+
+		public double getPrediction(Instance inst) {
+			return children.get(splitTest.branchForInstance(inst)).getPrediction(inst);
+		}
+	}
+
+	public class FIMTDDPerceptron implements Serializable {
+
+		private static final long serialVersionUID = 1L;
+		
+		protected FIMTDD tree;
+		
+		// The Perception weights 
+		protected double[] weightAttribute; 
+
+		// The number of instances contributing to this model
+		protected double instancesSeen = 0;
+
+		public String getPurposeString() {
+			return "A perceptron regressor as specified by Ikonomovska et al. used for FIMTDD";
+		}
+
+		public FIMTDDPerceptron(FIMTDDPerceptron original) {
+			this.tree = original.tree;
+			weightAttribute = original.weightAttribute.clone();
+		}
+
+		public FIMTDDPerceptron(FIMTDD tree) {
+			this.tree = tree;
+			initializeWeights();
+
+		}
+
+		public void initializeWeights() {
+			weightAttribute = new double[tree.getModelContext().numInputAttributes()+1];
+			instancesSeen = 0;
+			for (int j = 0; j < tree.getModelContext().numInputAttributes()+1; j++) {
+				// The last index corresponds to the constant b
+				weightAttribute[j] = 2 * tree.classifierRandom.nextDouble() - 1;
+			}
+			normalizeWeights();
+		}
+		
+		/**
+		 * Update the model using the provided instance
+		 */
+		public void updatePerceptron(Instance inst) {
+
+			// Update attribute statistics
+			instancesSeen += inst.weight();
+
+			// Update weights
+			double learningRatio = 0.0;
+			if (tree.learningRatioConstOption.isSet()) {
+				learningRatio = learningRatioOption.getValue();
+			} else {
+				learningRatio = learningRatioOption.getValue() / (1 + instancesSeen * tree.learningRateDecayFactorOption.getValue());
+			}
+
+			// Loop for compatibility with bagging methods 
+			for (int i = 0; i < (int) inst.weight(); i++) {
+				updateWeights(inst, learningRatio);
+			}
+		
+		}
+
+		public void updateWeights(Instance inst, double learningRatio) {
+			// Compute the normalized instance and the delta
+			double[] normalizedInstance = normalizedInstance(inst); 
+			double normalizedPrediction = prediction(normalizedInstance);
+			double normalizedValue = tree.normalizeTargetValue(inst.classValue());
+			double delta = normalizedValue - normalizedPrediction;
+			for (int i = 0; i < weightAttribute.length; i++) {
+				weightAttribute[i] += delta * learningRatio * normalizedInstance[i];
+			}
+			
+			normalizeWeights();
+		}
+		
+		public void normalizeWeights() {
+			double sum = 0;
+			for (int i = 0; i < this.weightAttribute.length; i++)
+				sum += Math.abs(weightAttribute[i]);
+			for (int i = 0; i < this.weightAttribute.length; i++)
+				weightAttribute[i] /= sum;
+		}
+
+		public double[] normalizedInstance(Instance inst) {
+			// Normalize Instance
+			double[] normalizedInstance = new double[inst.numInputAttributes()+1];
+			for (int j = 0; j < inst.numInputAttributes(); j++) {
+				double mean = tree.sumOfAttrValues.getValue(j) / tree.examplesSeen;
+				double sd = computeSD(tree.sumOfAttrSquares.getValue(j), tree.sumOfAttrValues.getValue(j), tree.examplesSeen);
+				if (inst.inputAttribute(j).isNumeric() && tree.examplesSeen > 1 && sd > 0.0000001)
+					normalizedInstance[j] = (inst.valueInputAttribute(j) - mean) / (sd);
+				else
+					normalizedInstance[j] = 0;
+			}
+			normalizedInstance[inst.numInputAttributes()] = tree.examplesSeen > 1 ? 1 : 0; // Value to be multiplied with the constant factor
+			return normalizedInstance;
+		}
+
+		/**
+		 * Output the prediction made by this perceptron on the given instance
+		 */
+		public double prediction(double[] instanceValues) {
+			double ret = 0;
+			for (int i = 0; i < instanceValues.length; i++)
+				ret += instanceValues[i] * weightAttribute[i];
+			return ret;
+		}
+
+		protected double prediction(Instance inst) {
+			double[] normalizedInstance = normalizedInstance(inst);
+			double normalizedPrediction = prediction(normalizedInstance);
+			return denormalizePrediction(normalizedPrediction);
+		}
+
+		private double denormalizePrediction(double normalizedPrediction) {
+			double mean = tree.sumOfValues / tree.examplesSeen;
+			double sd = computeSD(tree.sumOfSquares, tree.sumOfValues, tree.examplesSeen);
+			if (examplesSeen > 1) 
+				return normalizedPrediction * sd + mean;
+			else
+				return 0.0;
+		}
+		
+		public void getModelDescription(StringBuilder out, int indent) {
+	        StringUtils.appendIndented(out, indent, getClassNameString() + " =");
+			if (getModelContext() != null) {
+				for (int j = 0; j < getModelContext().numAttributes() - 1; j++) {
+					if (getModelContext().attribute(j).isNumeric()) {
+						out.append((j == 0 || weightAttribute[j] < 0) ? " " : " + ");
+		                out.append(String.format("%.4f", weightAttribute[j]));
+		                out.append(" * ");
+		                out.append(getAttributeNameString(j));
+		            }
+		        }
+				out.append(" + " + weightAttribute[getModelContext().numInputAttributes()]);
+			}
+	        StringUtils.appendNewline(out);
+		}
+	}
+
+
+	//endregion ================ CLASSES ================
+
+	//region ================ METHODS ================
+
+	// region --- Regressor methods
+	
+	public String getPurposeString() {
+		return "Implementation of the FIMT-DD tree as described by Ikonomovska et al.";
+	}
+
+	public void resetLearningImpl() {
+		this.treeRoot = null;
+		this.leafNodeCount = 0;
+		this.splitNodeCount = 0;
+		this.maxID = 0;
+		this.examplesSeen = 0;
+		this.sumOfValues = 0.0;
+		this.sumOfSquares = 0.0;
+
+		this.sumOfAttrValues = new DoubleVector();
+		this.sumOfAttrSquares = new DoubleVector();
+	}
+
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	public void getModelDescription(StringBuilder out, int indent) {
+		if (treeRoot != null) treeRoot.describeSubtree(out, indent);
+	}
+
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[]{ 
+				new Measurement("tree size (leaves)", this.leafNodeCount)
+		};
+	}
+
+	public int calcByteSize() {
+		return (int) SizeOf.fullSizeOf(this);
+	}
+
+	public double[] getVotesForInstance(Instance inst) {
+		if (treeRoot == null) {
+			return new double[] {0};
+		}
+
+		double prediction = treeRoot.getPrediction(inst);
+
+		return new double[] {prediction};
+	}
+
+	public double normalizeTargetValue(double value) {
+		if (examplesSeen > 1) {
+			double sd = Math.sqrt((sumOfSquares - ((sumOfValues * sumOfValues)/examplesSeen))/examplesSeen);
+			double average = sumOfValues / examplesSeen;
+			if (sd > 0 && examplesSeen > 1)
+				return (value - average) / sd;
+			else
+				return 0.0;
+		}
+		return 0.0;
+	}
+
+	public double getNormalizedError(Instance inst, double prediction) {
+		double normalPrediction = normalizeTargetValue(prediction);
+		double normalValue = normalizeTargetValue(inst.classValue());
+		return Math.abs(normalValue - normalPrediction);
+	}
+
+
+	/**
+	 * Method for updating (training) the model using a new instance
+	 */
+	public void trainOnInstanceImpl(Instance inst) {
+		checkRoot();
+
+		double prediction = treeRoot.getPrediction(inst);
+		double normalError = getNormalizedError(inst, prediction);
+	
+		processInstance(inst, treeRoot, prediction, normalError, true, false);
+		
+		examplesSeen += inst.weight();
+		sumOfValues += inst.weight() * inst.classValue();
+		sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
+
+		for (int i = 0; i < inst.numAttributes() - 1; i++) {
+			int aIndex = modelAttIndexToInstanceAttIndex(i, inst);
+			sumOfAttrValues.addToValue(i, inst.weight() * inst.value(aIndex));
+			sumOfAttrSquares.addToValue(i, inst.weight() * inst.value(aIndex) * inst.value(aIndex));
+		}
+
+
+	}
+
+	public void processInstance(Instance inst, Node node, double prediction, double normalError, boolean growthAllowed, boolean inAlternate) {
+		Node currentNode = node;
+		while (true) {
+			if (currentNode instanceof LeafNode) {
+				((LeafNode) currentNode).learnFromInstance(inst, growthAllowed, prediction);
+				break;
+			} else {
+				currentNode.examplesSeen += inst.weight();
+				currentNode.sumOfAbsErrors += inst.weight() * normalError;
+				InnerNode iNode = (InnerNode) currentNode;
+				if (!inAlternate && iNode.alternateTree != null) {
+					boolean altTree = true;
+					double lossO = Math.pow(inst.classValue() - prediction, 2);
+					double lossA = Math.pow(inst.classValue() - iNode.alternateTree.getPrediction(inst), 2);
+					
+					// Loop for compatibility with bagging methods
+					for (int i = 0; i < inst.weight(); i++) {
+						iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
+						iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
+						iNode.lossExamplesSeen++;
+						
+						double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
+						iNode.lossSumQi += Qi;
+						iNode.lossNumQiTests += 1;
+					}
+					double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
+					double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+					double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+					
+					if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
+						iNode.previousWeight = iNode.lossExamplesSeen;
+						if (Qi > 0) {
+							// Switch the subtrees
+							Node parent = iNode.getParent();
+
+							if (parent != null) {
+								Node replacementTree = iNode.alternateTree;
+								parent.setChild(parent.getChildIndex(iNode), replacementTree);
+								if (growthAllowed) replacementTree.restartChangeDetection();
+							} else {
+								treeRoot = iNode.alternateTree;
+								treeRoot.restartChangeDetection();
+							}
+
+							currentNode = iNode.alternateTree;
+							currentNode.originalNode = null;
+							altTree = false;
+						} else if (QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * alternateTreeTMinOption.getValue()) || iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()) {
+							// Remove the alternate tree
+							iNode.alternateTree = null;
+							if (growthAllowed) iNode.restartChangeDetection();
+							altTree = false;
+						}
+					}
+
+					if (altTree) {
+						growthAllowed = false;
+						processInstance(inst, iNode.alternateTree, prediction, normalError, true, true);
+					}
+				}
+
+				if (iNode.changeDetection && !inAlternate) {
+					if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+						iNode.initializeAlternateTree();
+						growthAllowed = false;
+					}
+				}
+				if (currentNode instanceof SplitNode) {
+					currentNode = ((SplitNode) currentNode).descendOneStep(inst);
+				} 
+			}
+		}
+	}
+
+	// endregion --- Regressor methods
+	
+	// region --- Object instatiation methods
+
+	protected FIMTDDNumericAttributeClassObserver newNumericClassObserver() {
+		return new FIMTDDNumericAttributeClassObserver();
+	}
+
+	protected SplitNode newSplitNode(InstanceConditionalTest splitTest) {
+		maxID++;
+		return new SplitNode(splitTest, this);
+	}
+
+	protected LeafNode newLeafNode() {
+		maxID++;
+		return new LeafNode(this);
+	}
+
+	protected FIMTDDPerceptron newLeafModel() {
+		return new FIMTDDPerceptron(this);
+	}
+
+	//endregion --- Object instatiation methods
+	
+	// region --- Processing methods
+	
+	protected void checkRoot() {
+		if (treeRoot == null) {
+			treeRoot = newLeafNode();
+			leafNodeCount = 1;
+		}
+	}
+
+	public static double computeHoeffdingBound(double range, double confidence, double n) {
+		return Math.sqrt(( (range * range) * Math.log(1 / confidence)) / (2.0 * n));
+	}
+
+	public boolean buildingModelTree() {
+		return !regressionTreeOption.isSet();
+	}
+
+	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
+
+		// Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
+ 		SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
+
+		// Using this criterion, find the best split per attribute and rank the results
+		AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion);
+		Arrays.sort(bestSplitSuggestions);
+
+		// Declare a variable to determine if any of the splits should be performed
+		boolean shouldSplit = false;
+
+		// If only one split was returned, use it
+		if (bestSplitSuggestions.length < 2) {
+			shouldSplit = bestSplitSuggestions.length > 0;
+		} else { // Otherwise, consider which of the splits proposed may be worth trying
+
+			// Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
+			// to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
+			double hoeffdingBound = computeHoeffdingBound(1, this.splitConfidenceOption.getValue(), node.examplesSeen);
+			// Determine the top two ranked splitting suggestions
+			AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+			AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
+
+			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
+			// as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
+			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
+			// splitting should occur.
+			// Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
+			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
+			// competing attributes are equally good, and the split will be made on the one with the higher SDR value.
+			if ((secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) || (hoeffdingBound < this.tieThresholdOption.getValue())) {
+				shouldSplit = true;
+			}
+			// If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
+			else {
+				for (int i = 0; i < node.attributeObservers.size(); i++) {
+					FIMTDDNumericAttributeClassObserver obs = node.attributeObservers.get(i);
+					if (obs != null) {
+						obs.removeBadSplits(splitCriterion, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound);    
+					}
+				}
+			}
+		}
+
+		// If the splitting criterion were met, split the current node using the chosen attribute test, and
+		// make two new branches leading to (empty) leaves
+		if (shouldSplit) {
+			AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+						
+			SplitNode newSplit = newSplitNode(splitDecision.splitTest);
+			newSplit.copyStatistics(node);
+			newSplit.changeDetection = node.changeDetection;
+			newSplit.ID = node.ID;
+			leafNodeCount--;
+			for (int i = 0; i < splitDecision.numSplits(); i++) {
+				LeafNode newChild = newLeafNode();
+				if (buildingModelTree()) {
+					// Copy the splitting node's perceptron to it's children
+					newChild.learningModel = new FIMTDDPerceptron((FIMTDDPerceptron) node.learningModel);
+					
+				}
+				newChild.changeDetection = node.changeDetection;
+				newChild.setParent(newSplit);
+				newSplit.setChild(i, newChild);
+				leafNodeCount++;
+			}
+			if (parent == null && node.originalNode == null) {
+				treeRoot = newSplit;
+			} else if (parent == null && node.originalNode != null) {
+				node.originalNode.alternateTree = newSplit;
+			} else {
+				((SplitNode) parent).setChild(parentIndex, newSplit);
+				newSplit.setParent(parent);
+			}
+			
+			splitNodeCount++;
+		}
+	}
+	
+	public double computeSD(double squaredVal, double val, double size) {
+		if (size > 1)
+			return Math.sqrt((squaredVal - ((val * val) / size)) / size);
+		else
+			return 0.0;
+	}
+	
+	public double scalarProduct(DoubleVector u, DoubleVector v) {
+		double ret = 0.0;
+		for (int i = 0; i < Math.max(u.numValues(), v.numValues()); i++) {
+			ret += u.getValue(i) * v.getValue(i);
+		}
+		return ret;
+	}
+	//endregion --- Processing methods
+	
+	//endregion ================ METHODS ================
+}
+
 =======
->>>>>>> Revert "Removed merging artefacts"
 /*
  *    FIMTDD.java
  *    Copyright (C) 2015 Jožef Stefan Institute, Ljubljana, Slovenia
@@ -1964,7 +1951,4 @@ public double scalarProduct(DoubleVector u, DoubleVector v) {
 	//endregion ================ METHODS ================
 }
 
-<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
-=======
 >>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
->>>>>>> Revert "Removed merging artefacts"
diff --git a/moa/src/main/java/moa/classifiers/trees/ORTO.java b/moa/src/main/java/moa/classifiers/trees/ORTO.java
index d2e697d6e..1808a5466 100644
--- a/moa/src/main/java/moa/classifiers/trees/ORTO.java
+++ b/moa/src/main/java/moa/classifiers/trees/ORTO.java
@@ -35,21 +35,10 @@
 import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
 import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
-<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
-import moa.core.AutoExpandVector;
-import moa.core.Measurement;
-=======
-<<<<<<< HEAD
-import moa.classifiers.trees.FIMTDD.InnerNode;
-import moa.classifiers.trees.FIMTDD.Node;
+
 import moa.core.AutoExpandVector;
 import moa.core.Measurement;
 import moa.core.StringUtils;
-=======
-import moa.core.AutoExpandVector;
-import moa.core.Measurement;
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
->>>>>>> Revert "Removed merging artefacts"
 
 /*
  * Implementation of ORTO, option trees for data streams.
@@ -132,15 +121,9 @@ public int getNumSubtrees() {
 
 		public int directionForBestTree() {
 			int d = 0;
-<<<<<<< HEAD
-			double min = Double.MAX_VALUE;
-			for (int i = 0; i < numChildren(); i++) {
-				double tmp = getFFRatio(i);
-=======
 			double tmp = 0.0, min = Double.MAX_VALUE;
 			for (int i = 0; i < children.size(); i++) {
 				tmp = getFFRatio(i);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				if (tmp < min) {
 					min = tmp;
 					d = i;
@@ -149,54 +132,22 @@ public int directionForBestTree() {
 			return d;
 		}
 
-<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
-		public double getPrediction(Instance inst, ORTO tree) {
-=======
-<<<<<<< HEAD
 		public double getPrediction(Instance inst) {
-=======
-		public double getPrediction(Instance inst, ORTO tree) {
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
->>>>>>> Revert "Removed merging artefacts"
 			double[] predictions = new double[numChildren()];
 			for (int i = 0; i < numChildren(); i++) {
 				predictions[i] = getChild(i).getPrediction(inst);
 			}
-<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
-			return aggregate(predictions, tree);
-		}
-
-		private double aggregate(double[] predictions, ORTO tree) {
-			if (tree.optionNodeAggregationOption.getChosenIndex() == 0) { // Average
-=======
-<<<<<<< HEAD
 			return aggregate(predictions);
 		}
 
 		private double aggregate(double[] predictions) {
 			if (((ORTO) tree).optionNodeAggregationOption.getChosenIndex() == 0) { // Average
-=======
-			return aggregate(predictions, tree);
-		}
-
-		private double aggregate(double[] predictions, ORTO tree) {
-			if (tree.optionNodeAggregationOption.getChosenIndex() == 0) { // Average
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
->>>>>>> Revert "Removed merging artefacts"
 				double sum = 0.0;
 				for (int i = 0; i < predictions.length; i++) {
 					sum += predictions[i];
 				}
 				return sum / predictions.length;
-<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
-			} else if (tree.optionNodeAggregationOption.getChosenIndex() == 1) {
-=======
-<<<<<<< HEAD
 			} else if (((ORTO) tree).optionNodeAggregationOption.getChosenIndex() == 1) {
-=======
-			} else if (tree.optionNodeAggregationOption.getChosenIndex() == 1) {
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
->>>>>>> Revert "Removed merging artefacts"
 				int d = directionForBestTree();
 				return predictions[d];
 			} else {
@@ -211,9 +162,6 @@ public double getFFRatio(int childIndex) {
 		protected boolean skipInLevelCount() {
 			return true;
 		}
-<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
-=======
-<<<<<<< HEAD
 		
 		@Override
 		public void describeSubtree(StringBuilder out, int indent) {
@@ -226,9 +174,6 @@ public void describeSubtree(StringBuilder out, int indent) {
 				split.describeSubtree(out, indent + 2);
 			}
 		}
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
->>>>>>> Revert "Removed merging artefacts"
 	}
 
 	//endregion ================ CLASSES ================
@@ -263,15 +208,7 @@ public void processInstance(Instance inst, Node node, double prediction, double
 			Node currentNode = node;
 			while (true) {
 				if (currentNode instanceof LeafNode) {
-<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
-					((LeafNode) currentNode).learnFromInstance(inst, growthAllowed);
-=======
-<<<<<<< HEAD
 					((LeafNode) currentNode).learnFromInstance(inst, growthAllowed, prediction);
-=======
-					((LeafNode) currentNode).learnFromInstance(inst, growthAllowed);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
->>>>>>> Revert "Removed merging artefacts"
 					break;
 				} else {
 					currentNode.examplesSeen += inst.weight();
@@ -280,15 +217,7 @@ public void processInstance(Instance inst, Node node, double prediction, double
 					if (!inAlternate && iNode.alternateTree != null) {
 						boolean altTree = true;
 						double lossO = Math.pow(inst.classValue() - prediction, 2);
-<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
-						double lossA = Math.pow(inst.classValue() - currentNode.alternateTree.getPrediction(inst), 2);
-=======
-<<<<<<< HEAD
 						double lossA = Math.pow(inst.classValue() - iNode.alternateTree.getPrediction(inst), 2);
-=======
-						double lossA = Math.pow(inst.classValue() - currentNode.alternateTree.getPrediction(inst), 2);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
->>>>>>> Revert "Removed merging artefacts"
 						
 						// Loop for compatibility with bagging methods
 						for (int i = 0; i < inst.weight(); i++) {
@@ -308,15 +237,7 @@ public void processInstance(Instance inst, Node node, double prediction, double
 							iNode.previousWeight = iNode.lossExamplesSeen;
 							if (Qi > 0) {
 								// Switch the subtrees
-<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
-								Node parent = currentNode.parent;
-=======
-<<<<<<< HEAD
 								Node parent = iNode.getParent();
-=======
-								Node parent = currentNode.parent;
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
->>>>>>> Revert "Removed merging artefacts"
 								
 								if (parent != null) {
 									Node replacementTree = iNode.alternateTree;
@@ -326,15 +247,7 @@ public void processInstance(Instance inst, Node node, double prediction, double
 									treeRoot = iNode.alternateTree;
 									treeRoot.restartChangeDetection();
 								}
-<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
-								optionNodeCount += currentNode.alternateTree.getNumSubtrees() - currentNode.getNumSubtrees();
-=======
-<<<<<<< HEAD
 								optionNodeCount += iNode.alternateTree.getNumSubtrees() - iNode.getNumSubtrees();
-=======
-								optionNodeCount += currentNode.alternateTree.getNumSubtrees() - currentNode.getNumSubtrees();
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
->>>>>>> Revert "Removed merging artefacts"
 								removeExcessTrees();
 										
 								currentNode = iNode.alternateTree;
@@ -349,15 +262,7 @@ public void processInstance(Instance inst, Node node, double prediction, double
 						}
 						if (altTree) {
 							growthAllowed = false; // this is the growth of the original tree
-<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
-							processInstance(inst, currentNode.alternateTree, prediction, normalError, true, true); // growth is allowed in the alt tree
-=======
-<<<<<<< HEAD
 							processInstance(inst, iNode.alternateTree, prediction, normalError, true, true); // growth is allowed in the alt tree
-=======
-							processInstance(inst, currentNode.alternateTree, prediction, normalError, true, true); // growth is allowed in the alt tree
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
->>>>>>> Revert "Removed merging artefacts"
 						} else if (currentNode instanceof OptionNode) {
 							// this happens when an option node is switched into the tree
 							for (Node child : ((OptionNode) currentNode).children) {
@@ -385,44 +290,22 @@ public void processInstance(Instance inst, Node node, double prediction, double
 	}
 	
 	public void processInstanceOptionNode(Instance inst, OptionNode node, double prediction, double normalError, boolean growthAllowed, boolean inAlternate) {
-<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
-=======
-<<<<<<< HEAD
 		node.examplesSeen += inst.weight();
 		node.sumOfAbsErrors += inst.weight() * normalError;
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
->>>>>>> Revert "Removed merging artefacts"
 		if (node.changeDetection) {
 			double error = Math.abs(prediction - inst.classValue());
 			node.sumOfAbsErrors += error;
 			
 			if (((InnerNode) node).PageHinckleyTest(error - node.sumOfAbsErrors / node.examplesSeen + PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
 				node.initializeAlternateTree();
-<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
-=======
-<<<<<<< HEAD
 				growthAllowed = false;
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
->>>>>>> Revert "Removed merging artefacts"
 			}
 		}
 
 		for (Node child : node.children) {
 			int index = node.getChildIndex(child);
 			double childPrediction = child.getPrediction(inst);
-<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
-=======
-<<<<<<< HEAD
-			node.optionFFSeen[index] = node.optionFFSeen[index] * optionFadingFactorOption.getValue() + 1;
-			node.optionFFSSL[index] = node.optionFFSSL[index] * optionFadingFactorOption.getValue() + Math.pow(childPrediction - inst.classValue(), 2);
-		}
 
-		for (Node child : node.children) {
-			processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed, inAlternate);
-=======
->>>>>>> Revert "Removed merging artefacts"
 			// Loop for compatibility with bagging methods
 			for (int i = 0; i < inst.weight(); i++) {
 				node.optionFFSeen[index] = node.optionFFSeen[index] * optionFadingFactorOption.getValue() + 1;
@@ -432,7 +315,6 @@ public void processInstanceOptionNode(Instance inst, OptionNode node, double pre
 
 		for (Node child : node.children) {
 			processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed && node.alternateTree == null, inAlternate);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		}
 	}
 	
@@ -450,10 +332,6 @@ protected OptionNode newOptionNode() {
 	// region --- Processing methods
 
 	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
-<<<<<<< HEAD
-
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		// Initialize the split criterion 
 		SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(splitCriterionOption);
 
@@ -461,11 +339,7 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 		AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion);
 		List<AttributeSplitSuggestion> acceptedSplits = new LinkedList<AttributeSplitSuggestion>();
 		Arrays.sort(bestSplitSuggestions);
-<<<<<<< HEAD
-		
-=======
 
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 		// Declare a variable to determine the number of splits to be performed
 		int numSplits = 0;
 
@@ -483,13 +357,6 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 			AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
 			AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
 
-<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
-=======
-<<<<<<< HEAD
-			
-=======
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
->>>>>>> Revert "Removed merging artefacts"
 			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
 			// as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
 			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
@@ -501,30 +368,16 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 				numSplits = 1;
 				acceptedSplits.add(bestSuggestion);
 			} else if (numTrees < maxTreesOption.getValue() && node.getLevel() <= maxOptionLevelOption.getValue()) {
-<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
-				for (AttributeSplitSuggestion suggestion : bestSplitSuggestions) {
-=======
-<<<<<<< HEAD
 				for (int i = 0; i < bestSplitSuggestions.length; i++) {
 					AttributeSplitSuggestion suggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1 - i];
->>>>>>> Revert "Removed merging artefacts"
-					if (suggestion.merit / bestSuggestion.merit >= 1 - hoeffdingBound) {
-						numSplits++;
-						acceptedSplits.add(suggestion);
-					}
-				}
-<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
-=======
-				
-=======
-				for (AttributeSplitSuggestion suggestion : bestSplitSuggestions) {
 					if (suggestion.merit / bestSuggestion.merit >= 1 - hoeffdingBound) {
 						numSplits++;
 						acceptedSplits.add(suggestion);
+					} else {
+						break;
 					}
+						
 				}
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
->>>>>>> Revert "Removed merging artefacts"
 			} else if (hoeffdingBound < tieThresholdOption.getValue()) {
 				numSplits = 1;
 				acceptedSplits.add(bestSplitSuggestions[0]);
@@ -543,11 +396,7 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 		if (numSplits > 0) {
 			double optionFactor = numSplits * Math.pow(optionDecayFactorOption.getValue(), (double) node.getLevel());
 
-<<<<<<< HEAD
-			if (numSplits == 1 || optionFactor < 2.0 || maxTreesOption.getValue() - numTrees <= 0) {
-=======
 			if (numSplits == 1 || optionFactor < 2.0 || maxTreesOption.getValue() - numTrees <= 1) {
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
 				AttributeSplitSuggestion splitDecision = acceptedSplits.get(0);
 				SplitNode newSplit = newSplitNode(splitDecision.splitTest);
 				for (int i = 0; i < splitDecision.numSplits(); i++) {
@@ -558,25 +407,12 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 				leafNodeCount--;
 				innerNodeCount++;
 				leafNodeCount += splitDecision.numSplits();
-<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
-				if (parent == null) {
-=======
-<<<<<<< HEAD
 				if (parent == null && node.originalNode == null) {
->>>>>>> Revert "Removed merging artefacts"
 					treeRoot = newSplit;
+				} else if (parent == null && node.originalNode != null) {
+					node.originalNode.alternateTree = newSplit;
 				} else {
-<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
-					parent.setChild(parent.getChildIndex(node), newSplit);
-=======
 					parent.setChild(parentIndex, newSplit);
-=======
-				if (parent == null) {
-					treeRoot = newSplit;
-				} else {
-					parent.setChild(parent.getChildIndex(node), newSplit);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
->>>>>>> Revert "Removed merging artefacts"
 					newSplit.setParent(parent);
 				}
 			} else {
@@ -610,15 +446,7 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 				if (parent == null) {
 					treeRoot = optionNode;
 				} else {
-<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
-					parent.setChild(parent.getChildIndex(node), optionNode);
-=======
-<<<<<<< HEAD
 					parent.setChild(parentIndex, optionNode);
-=======
-					parent.setChild(parent.getChildIndex(node), optionNode);
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
->>>>>>> Revert "Removed merging artefacts"
 					optionNode.setParent(parent);
 				}
 
@@ -701,11 +529,4 @@ protected void removeExcessTrees() {
 	// endregion --- Option tree methods
 	
 	//endregion ================ METHODS ================
-<<<<<<< HEAD
-}
-<<<<<<< 5a48cb8458f9db3cf55cf428d50f81dc14c31ee3
-=======
-=======
 }
->>>>>>> 5c49882b22b3a8314c6dfcc8c026456c887262fa
->>>>>>> Revert "Removed merging artefacts"
diff --git a/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java b/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
index c7c7b5db0..9b3a1920b 100644
--- a/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
+++ b/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
@@ -59,225 +59,225 @@
  */
 public class EvaluatePrequentialMultiTarget extends MultiTargetMainTask {
 
-    @Override
-    public String getPurposeString() {
-        return "Evaluates a classifier on a stream by testing then training with each example in sequence.";
-    }
+	@Override
+	public String getPurposeString() {
+		return "Evaluates a classifier on a stream by testing then training with each example in sequence.";
+	}
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public ClassOption learnerOption = new ClassOption("learner", 'l',
-           "Learner to train.", MultiTargetRegressor.class, "moa.classifiers.multitarget.functions.MultiTargetNoChange");
+	public ClassOption learnerOption = new ClassOption("learner", 'l',
+			"Learner to train.", MultiTargetRegressor.class, "moa.classifiers.multitarget.functions.MultiTargetNoChange");
 
-    public ClassOption streamOption = new ClassOption("stream", 's',
-            "Stream to learn from.", MultiTargetInstanceStream.class,
-            "MultiTargetArffFileStream");
+	public ClassOption streamOption = new ClassOption("stream", 's',
+			"Stream to learn from.", MultiTargetInstanceStream.class,
+			"MultiTargetArffFileStream");
 
-    public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
-            "Classification performance evaluation method.",
-            MultiTargetPerformanceEvaluator.class,
-            "BasicMultiTargetPerformanceEvaluator");
+	public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
+			"Classification performance evaluation method.",
+			MultiTargetPerformanceEvaluator.class,
+			"BasicMultiTargetPerformanceEvaluator");
 
-    public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
-            "Maximum number of instances to test/train on  (-1 = no limit).",
-            100000000, -1, Integer.MAX_VALUE);
+	public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
+			"Maximum number of instances to test/train on  (-1 = no limit).",
+			100000000, -1, Integer.MAX_VALUE);
 
-    public IntOption timeLimitOption = new IntOption("timeLimit", 't',
-            "Maximum number of seconds to test/train for (-1 = no limit).", -1,
-            -1, Integer.MAX_VALUE);
+	public IntOption timeLimitOption = new IntOption("timeLimit", 't',
+			"Maximum number of seconds to test/train for (-1 = no limit).", -1,
+			-1, Integer.MAX_VALUE);
 
-    public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
-            'f',
-            "How many instances between samples of the learning performance.",
-            100000, 0, Integer.MAX_VALUE);
+	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
+			'f',
+			"How many instances between samples of the learning performance.",
+			100000, 0, Integer.MAX_VALUE);
 
-    public IntOption memCheckFrequencyOption = new IntOption(
-            "memCheckFrequency", 'q',
-            "How many instances between memory bound checks.", 100000, 0,
-            Integer.MAX_VALUE);
+	public IntOption memCheckFrequencyOption = new IntOption(
+			"memCheckFrequency", 'q',
+			"How many instances between memory bound checks.", 100000, 0,
+			Integer.MAX_VALUE);
 
-    public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
-            "File to append intermediate csv results to.", null, "csv", true);
+	public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
+			"File to append intermediate csv results to.", null, "csv", true);
 
-    public FileOption outputPredictionFileOption = new FileOption("outputPredictionFile", 'o',
-            "File to append output predictions to.", null, "pred", true);
+	public FileOption outputPredictionFileOption = new FileOption("outputPredictionFile", 'o',
+			"File to append output predictions to.", null, "pred", true);
 
-    //New for prequential method DEPRECATED
-    public IntOption widthOption = new IntOption("width",
-            'w', "Size of Window", 1000);
+	//New for prequential method DEPRECATED
+	public IntOption widthOption = new IntOption("width",
+			'w', "Size of Window", 1000);
 
-    public FloatOption alphaOption = new FloatOption("alpha",
-            'a', "Fading factor or exponential smoothing factor", .01);
-    //End New for prequential methods
+	public FloatOption alphaOption = new FloatOption("alpha",
+			'a', "Fading factor or exponential smoothing factor", .01);
+	//End New for prequential methods
 
-    @Override
-    public Class<?> getTaskResultType() {
-        return LearningCurve.class;
-    }
+	@Override
+	public Class<?> getTaskResultType() {
+		return LearningCurve.class;
+	}
 
-    @Override
-    protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
-        Learner learner = (Learner) getPreparedClassOption(this.learnerOption);
-        ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
-        LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
-        LearningCurve learningCurve = new LearningCurve(
-                "learning evaluation instances");
+	@Override
+	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
+		Learner learner = (Learner) getPreparedClassOption(this.learnerOption);
+		ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
+		LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
+		LearningCurve learningCurve = new LearningCurve(
+				"learning evaluation instances");
 
-        //New for prequential methods
-        if (evaluator instanceof WindowClassificationPerformanceEvaluator) {
-            //((WindowClassificationPerformanceEvaluator) evaluator).setWindowWidth(widthOption.getValue());
-            if (widthOption.getValue() != 1000) {
-                System.out.println("DEPRECATED! Use EvaluatePrequential -e (WindowClassificationPerformanceEvaluator -w " + widthOption.getValue() + ")");
-                 return learningCurve;
-            }
-        }
-        if (evaluator instanceof EWMAClassificationPerformanceEvaluator) {
-            //((EWMAClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
-            if (alphaOption.getValue() != .01) {
-                System.out.println("DEPRECATED! Use EvaluatePrequential -e (EWMAClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
-                return learningCurve;
-            }
-        }
-        if (evaluator instanceof FadingFactorClassificationPerformanceEvaluator) {
-            //((FadingFactorClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
-            if (alphaOption.getValue() != .01) {
-                System.out.println("DEPRECATED! Use EvaluatePrequential -e (FadingFactorClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
-                return learningCurve;
-            }
-        }
-        //End New for prequential methods
+		//New for prequential methods
+		if (evaluator instanceof WindowClassificationPerformanceEvaluator) {
+			//((WindowClassificationPerformanceEvaluator) evaluator).setWindowWidth(widthOption.getValue());
+			if (widthOption.getValue() != 1000) {
+				System.out.println("DEPRECATED! Use EvaluatePrequential -e (WindowClassificationPerformanceEvaluator -w " + widthOption.getValue() + ")");
+				return learningCurve;
+			}
+		}
+		if (evaluator instanceof EWMAClassificationPerformanceEvaluator) {
+			//((EWMAClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
+			if (alphaOption.getValue() != .01) {
+				System.out.println("DEPRECATED! Use EvaluatePrequential -e (EWMAClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
+				return learningCurve;
+			}
+		}
+		if (evaluator instanceof FadingFactorClassificationPerformanceEvaluator) {
+			//((FadingFactorClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
+			if (alphaOption.getValue() != .01) {
+				System.out.println("DEPRECATED! Use EvaluatePrequential -e (FadingFactorClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
+				return learningCurve;
+			}
+		}
+		//End New for prequential methods
 
-        learner.setModelContext(stream.getHeader());
-        int maxInstances = this.instanceLimitOption.getValue();
-        long instancesProcessed = 0;
-        int maxSeconds = this.timeLimitOption.getValue();
-        int secondsElapsed = 0;
-        monitor.setCurrentActivity("Evaluating learner...", -1.0);
+		learner.setModelContext(stream.getHeader());
+		int maxInstances = this.instanceLimitOption.getValue();
+		long instancesProcessed = 0;
+		int maxSeconds = this.timeLimitOption.getValue();
+		int secondsElapsed = 0;
+		monitor.setCurrentActivity("Evaluating learner...", -1.0);
 
-        File dumpFile = this.dumpFileOption.getFile();
-        PrintStream immediateResultStream = null;
-        if (dumpFile != null) {
-            try {
-                if (dumpFile.exists()) {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile, true), true);
-                } else {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile), true);
-                }
-            } catch (Exception ex) {
-                throw new RuntimeException(
-                        "Unable to open immediate result file: " + dumpFile, ex);
-            }
-        }
-        //File for output predictions
-        File outputPredictionFile = this.outputPredictionFileOption.getFile();
-        PrintStream outputPredictionResultStream = null;
-        if (outputPredictionFile != null) {
-            try {
-                if (outputPredictionFile.exists()) {
-                    outputPredictionResultStream = new PrintStream(
-                            new FileOutputStream(outputPredictionFile, true), true);
-                } else {
-                    outputPredictionResultStream = new PrintStream(
-                            new FileOutputStream(outputPredictionFile), true);
-                }
-            } catch (Exception ex) {
-                throw new RuntimeException(
-                        "Unable to open prediction result file: " + outputPredictionFile, ex);
-            }
-        }
-        boolean firstDump = true;
-        boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
-        long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-        long lastEvaluateStartTime = evaluateStartTime;
-        double RAMHours = 0.0;
-        while (stream.hasMoreInstances()
-                && ((maxInstances < 0) || (instancesProcessed < maxInstances))
-                && ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
-            Example trainInst = stream.nextInstance();
-            Example testInst = (Example) trainInst; //.copy();
-            //testInst.setClassMissing();
-            //double[] prediction = learner.getVotesForInstance(testInst);
-            Prediction prediction = learner.getPredictionForInstance(testInst);
-            // Output prediction
-            if (outputPredictionFile != null) {
-            	StringBuilder sb = new StringBuilder();
-            	for (int i = 0; i < ((Instance) trainInst.getData()).numOutputAttributes(); i++) {
-            		sb.append("Out " + i + ": " + ((Instance) trainInst.getData()).valueOutputAttribute(i) + " ");
-            	}
-                outputPredictionResultStream.println(prediction + "," + sb.toString());
-            }
+		File dumpFile = this.dumpFileOption.getFile();
+		PrintStream immediateResultStream = null;
+		if (dumpFile != null) {
+			try {
+				if (dumpFile.exists()) {
+					immediateResultStream = new PrintStream(
+							new FileOutputStream(dumpFile, true), true);
+				} else {
+					immediateResultStream = new PrintStream(
+							new FileOutputStream(dumpFile), true);
+				}
+			} catch (Exception ex) {
+				throw new RuntimeException(
+						"Unable to open immediate result file: " + dumpFile, ex);
+			}
+		}
+		//File for output predictions
+		File outputPredictionFile = this.outputPredictionFileOption.getFile();
+		PrintStream outputPredictionResultStream = null;
+		if (outputPredictionFile != null) {
+			try {
+				if (outputPredictionFile.exists()) {
+					outputPredictionResultStream = new PrintStream(
+							new FileOutputStream(outputPredictionFile, true), true);
+				} else {
+					outputPredictionResultStream = new PrintStream(
+							new FileOutputStream(outputPredictionFile), true);
+				}
+			} catch (Exception ex) {
+				throw new RuntimeException(
+						"Unable to open prediction result file: " + outputPredictionFile, ex);
+			}
+		}
+		boolean firstDump = true;
+		boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
+		long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+		long lastEvaluateStartTime = evaluateStartTime;
+		double RAMHours = 0.0;
+		while (stream.hasMoreInstances()
+				&& ((maxInstances < 0) || (instancesProcessed < maxInstances))
+				&& ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
+			Example trainInst = stream.nextInstance();
+			Example testInst = (Example) trainInst; //.copy();
+			//testInst.setClassMissing();
+			//double[] prediction = learner.getVotesForInstance(testInst);
+			Prediction prediction = learner.getPredictionForInstance(testInst);
+			// Output prediction
+			if (outputPredictionFile != null) {
+				StringBuilder sb = new StringBuilder();
+				for (int i = 0; i < ((Instance) trainInst.getData()).numOutputAttributes(); i++) {
+					sb.append("Out " + i + ": " + ((Instance) trainInst.getData()).valueOutputAttribute(i) + " ");
+				}
+				outputPredictionResultStream.println(prediction + "," + sb.toString());
+			}
 
-            //evaluator.addClassificationAttempt(trueClass, prediction, testInst.weight());
-            evaluator.addResult(testInst, prediction);
-            learner.trainOnInstance(trainInst);
-            instancesProcessed++;
-            if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0
-                    || stream.hasMoreInstances() == false) {
-                long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-                double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);
-                double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);
-                double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); //GBs
-                RAMHoursIncrement *= (timeIncrement / 3600.0); //Hours
-                RAMHours += RAMHoursIncrement;
-                lastEvaluateStartTime = evaluateTime;
-                learningCurve.insertEntry(new LearningEvaluation(
-                        new Measurement[]{
-                            new Measurement(
-                            "learning evaluation instances",
-                            instancesProcessed),
-                            new Measurement(
-                            "evaluation time ("
-                            + (preciseCPUTiming ? "cpu "
-                            : "") + "seconds)",
-                            time),
-                            new Measurement(
-                            "model cost (RAM-Hours)",
-                            RAMHours)
-                        },
-                        evaluator, learner));
+			//evaluator.addClassificationAttempt(trueClass, prediction, testInst.weight());
+			evaluator.addResult(testInst, prediction);
+			learner.trainOnInstance(trainInst);
+			instancesProcessed++;
+			if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0
+					|| stream.hasMoreInstances() == false) {
+				long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+				double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);
+				double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);
+				double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); //GBs
+				RAMHoursIncrement *= (timeIncrement / 3600.0); //Hours
+				RAMHours += RAMHoursIncrement;
+				lastEvaluateStartTime = evaluateTime;
+				learningCurve.insertEntry(new LearningEvaluation(
+						new Measurement[]{
+								new Measurement(
+										"learning evaluation instances",
+										instancesProcessed),
+										new Measurement(
+												"evaluation time ("
+														+ (preciseCPUTiming ? "cpu "
+																: "") + "seconds)",
+																time),
+																new Measurement(
+																		"model cost (RAM-Hours)",
+																		RAMHours)
+						},
+						evaluator, learner));
 
-                if (immediateResultStream != null) {
-                    if (firstDump) {
-                        immediateResultStream.println(learningCurve.headerToString());
-                        firstDump = false;
-                    }
-                    immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
-                    immediateResultStream.flush();
-                }
-            }
-            if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
-                if (monitor.taskShouldAbort()) {
-                    return null;
-                }
-                long estimatedRemainingInstances = stream.estimatedRemainingInstances();
-                if (maxInstances > 0) {
-                    long maxRemaining = maxInstances - instancesProcessed;
-                    if ((estimatedRemainingInstances < 0)
-                            || (maxRemaining < estimatedRemainingInstances)) {
-                        estimatedRemainingInstances = maxRemaining;
-                    }
-                }
-                monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
-                        : (double) instancesProcessed
-                        / (double) (instancesProcessed + estimatedRemainingInstances));
-                if (monitor.resultPreviewRequested()) {
-                    monitor.setLatestResultPreview(learningCurve.copy());
-                }
-                secondsElapsed = (int) TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread()
-                        - evaluateStartTime);
-            }
-        }
-        StringBuilder sb= new StringBuilder();
-        learner.getDescription(sb, 0);
-        System.out.println(sb.toString());
-        if (immediateResultStream != null) {
-            immediateResultStream.close();
-        }
-        if (outputPredictionResultStream != null) {
-            outputPredictionResultStream.close();
-        }
-        return learningCurve;
-    }
+				if (immediateResultStream != null) {
+					if (firstDump) {
+						immediateResultStream.println(learningCurve.headerToString());
+						firstDump = false;
+					}
+					immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
+					immediateResultStream.flush();
+				}
+			}
+			if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
+				if (monitor.taskShouldAbort()) {
+					return null;
+				}
+				long estimatedRemainingInstances = stream.estimatedRemainingInstances();
+				if (maxInstances > 0) {
+					long maxRemaining = maxInstances - instancesProcessed;
+					if ((estimatedRemainingInstances < 0)
+							|| (maxRemaining < estimatedRemainingInstances)) {
+						estimatedRemainingInstances = maxRemaining;
+					}
+				}
+				monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
+						: (double) instancesProcessed
+						/ (double) (instancesProcessed + estimatedRemainingInstances));
+				if (monitor.resultPreviewRequested()) {
+					monitor.setLatestResultPreview(learningCurve.copy());
+				}
+				secondsElapsed = (int) TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread()
+						- evaluateStartTime);
+			}
+		}
+		StringBuilder sb= new StringBuilder();
+		learner.getDescription(sb, 0);
+		System.out.println(sb.toString());
+		if (immediateResultStream != null) {
+			immediateResultStream.close();
+		}
+		if (outputPredictionResultStream != null) {
+			outputPredictionResultStream.close();
+		}
+		return learningCurve;
+	}
 }
diff --git a/weka-package/pom.xml b/weka-package/pom.xml
index 6cd73530c..693727f08 100644
--- a/weka-package/pom.xml
+++ b/weka-package/pom.xml
@@ -6,7 +6,7 @@
   <parent>
     <groupId>nz.ac.waikato.cms.moa</groupId>
     <artifactId>moa-pom</artifactId>
-    <version>2012.09-SNAPSHOT</version>
+    <version>2014.04</version>
   </parent>
 
   <artifactId>weka-package</artifactId>

From 1b6cdbfea6bcbe57e38e4d151de39992caa346bd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Wed, 23 Mar 2016 11:06:20 +0100
Subject: [PATCH 25/33] Intermediary commit for multi-label changes

---
 .../labs/samoa/instances/ArffLoader.java      |  15 +-
 .../yahoo/labs/samoa/instances/Attribute.java | 510 ++++++++++--------
 .../samoa/instances/AttributeStructure.java   |   7 +
 .../labs/samoa/instances/DAGStructure.java    |  86 +++
 .../instances/HierarhicalInstanceImpl.java    | 452 ++++++++++++++++
 .../yahoo/labs/samoa/instances/Instance.java  |  11 +
 .../labs/samoa/instances/InstanceImpl.java    |  31 +-
 .../samoa/instances/InstanceInformation.java  |   9 +
 .../labs/samoa/instances/InstancesHeader.java |   4 +
 ...lInstance.java => StructuredInstance.java} |   4 +-
 .../moa/classifiers/AbstractClassifier.java   |  11 +-
 .../AbstractMultiLabelLearner.java            |  10 +-
 .../moa/classifiers/MultiLabelLearner.java    |   6 +-
 .../java/moa/classifiers/meta/OzaBag.java     |   2 +-
 .../LocalMultiTargetClassifier.java           |  16 +-
 .../multilabel/MEKAClassifier.java            |  28 +-
 .../multilabel/MajorityLabelset.java          |  15 +-
 .../multilabel/MultilabelHoeffdingTree.java   |  11 +-
 .../splitcriteria/ICVarianceReduction.java    |   1 -
 .../WeightedICVarianceReduction.java          |  46 ++
 .../classifiers/multilabel/meta/MLOzaBag.java | 126 +++++
 .../multilabel/meta/MLOzaBagAdwin.java        | 182 +++++++
 .../classifiers/multilabel/meta/MTOzaBag.java |  40 +-
 .../multilabel/trees/ISOUPOptionTree.java     | 319 +++++++++--
 .../multilabel/trees/ISOUPTree.java           | 428 ++++++++-------
 .../BasicMultiTargetRegressor.java            |   8 +-
 .../functions/MultiTargetNoChange.java        |   6 +-
 .../rules/core/NominalRulePredicate.java      |  15 +-
 .../rules/core/NumericRulePredicate.java      |  16 +-
 .../moa/classifiers/rules/core/Predicate.java |   2 +
 .../AbstractAnomalyDetector.java              |   4 +-
 .../AnomalinessRatioScore.java                |   4 +-
 .../anomalydetection/AnomalyDetector.java     |   4 +-
 .../anomalydetection/NoAnomalyDetection.java  |   4 +-
 .../core/anomalydetection/OddsRatioScore.java |   4 +-
 .../NominalAttributeBinaryRulePredicate.java  |   9 +
 .../NumericAttributeBinaryRulePredicate.java  |   7 +
 .../rules/functions/Perceptron.java           |   2 +-
 .../multilabel/AMRulesMultiLabelLearner.java  |  10 +-
 .../multilabel/core/LearningLiteral.java      |  12 +-
 .../core/LearningLiteralRegression.java       |   4 +-
 .../rules/multilabel/core/MultiLabelRule.java |  12 +-
 .../AbstractMultiLabelErrorMeasurer.java      |   4 +-
 .../AbstractMultiTargetErrorMeasurer.java     |   4 +-
 .../MultiLabelErrorMeasurer.java              |   4 +-
 .../AdaptiveMultiTargetRegressor.java         |   6 +-
 .../meta/MultiLabelRandomAMRules.java         |   6 +-
 .../java/moa/classifiers/trees/FIMTDD.java    |  37 +-
 .../main/java/moa/classifiers/trees/ORTO.java |   5 +-
 .../BasicMultiTargetPerformanceEvaluator.java |   4 +-
 ...tWindowRegressionPerformanceEvaluator.java |   4 +-
 ...dowClassificationPerformanceEvaluator.java | 152 ++++++
 .../main/java/moa/streams/ArffFileStream.java |   9 +-
 53 files changed, 2117 insertions(+), 611 deletions(-)
 create mode 100644 moa/src/main/java/com/yahoo/labs/samoa/instances/AttributeStructure.java
 create mode 100644 moa/src/main/java/com/yahoo/labs/samoa/instances/DAGStructure.java
 create mode 100644 moa/src/main/java/com/yahoo/labs/samoa/instances/HierarhicalInstanceImpl.java
 rename moa/src/main/java/com/yahoo/labs/samoa/instances/{MultiLabelInstance.java => StructuredInstance.java} (87%)
 create mode 100644 moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/WeightedICVarianceReduction.java
 create mode 100644 moa/src/main/java/moa/classifiers/multilabel/meta/MLOzaBag.java
 create mode 100644 moa/src/main/java/moa/classifiers/multilabel/meta/MLOzaBagAdwin.java
 create mode 100644 moa/src/main/java/moa/evaluation/MultilabelWindowClassificationPerformanceEvaluator.java

diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
index 124b1d5d6..a6bddce59 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
@@ -352,10 +352,6 @@ private InstanceInformation getHeader() {
     	//commented JD
         //this.range.setUpper(10000); //TO DO: Create a new range object with isInRange that does not need the upper limit
         String relation = "file stream";
-        //System.out.println("RELATION " + relation);
-        //inputAttributes = new ArrayList<Attribute>();
-        //outputAttributes = new ArrayList<Attribute>();
-        //ArrayList<Attribute> 
         auxAttributes = new ArrayList<Attribute>();//JD
         int numAttributes = 0;
         try {
@@ -405,6 +401,17 @@ private InstanceInformation getHeader() {
                              }*/
                             auxAttributes.add(new Attribute(name, attributeLabels));
                             numAttributes++;
+                        } else if (streamTokenizer.sval != null && streamTokenizer.sval.toUpperCase() == "HIERARCHICAL") {
+                        	streamTokenizer.nextToken();
+                        	DAGStructure attributeStructure = new DAGStructure();
+                        	if (streamTokenizer.ttype == '{') {
+                        		while(streamTokenizer.ttype == '}') {
+                        			streamTokenizer.nextToken();
+                        			System.out.println(streamTokenizer.sval);
+                        		}
+                        		
+                        	}
+                        	
                         } else {
                             // Add attribute
                             //commented JD
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java
index 5b05ad652..44d552dba 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java
@@ -25,94 +25,84 @@
  */
 public class Attribute implements Serializable {
 
-    /** The keyword used to denote the start of an arff attribute declaration */
-    public final static String ARFF_ATTRIBUTE = "@attribute";
+	/** The keyword used to denote the start of an arff attribute declaration */
+	public final static String ARFF_ATTRIBUTE = "@attribute";
 
-    /** A keyword used to denote a numeric attribute */
-    public final static String ARFF_ATTRIBUTE_INTEGER = "integer";
+	/** A keyword used to denote a numeric attribute */
+	public final static String ARFF_ATTRIBUTE_INTEGER = "integer";
 
-    /** A keyword used to denote a numeric attribute */
-    public final static String ARFF_ATTRIBUTE_REAL = "real";
+	/** A keyword used to denote a numeric attribute */
+	public final static String ARFF_ATTRIBUTE_REAL = "real";
 
-    /** A keyword used to denote a numeric attribute */
-    public final static String ARFF_ATTRIBUTE_NUMERIC = "numeric";
+	/** A keyword used to denote a numeric attribute */
+	public final static String ARFF_ATTRIBUTE_NUMERIC = "numeric";
 
-    /** The keyword used to denote a string attribute */
-    public final static String ARFF_ATTRIBUTE_STRING = "string";
+	/** The keyword used to denote a string attribute */
+	public final static String ARFF_ATTRIBUTE_STRING = "string";
 
-    /** The keyword used to denote a date attribute */
-    public final static String ARFF_ATTRIBUTE_DATE = "date";
+	/** The keyword used to denote a date attribute */
+	public final static String ARFF_ATTRIBUTE_DATE = "date";
 
-    /** The keyword used to denote a relation-valued attribute */
-    public final static String ARFF_ATTRIBUTE_RELATIONAL = "relational";
+	/** The keyword used to denote a (nominal) hierarchical attribute */
+	public final static String ARFF_ATTRIBUTE_HIERARCHICAL = "hierarchical";
 
-    /** The keyword used to denote the end of the declaration of a subrelation */
-    public final static String ARFF_END_SUBRELATION = "@end";
+	/** The keyword used to denote a relation-valued attribute */
+	public final static String ARFF_ATTRIBUTE_RELATIONAL = "relational";
 
-    /** Strings longer than this will be stored compressed. */
-    private static final int STRING_COMPRESS_THRESHOLD = 200;
+	/** The keyword used to denote the end of the declaration of a subrelation */
+	public final static String ARFF_END_SUBRELATION = "@end";
 
-    /**
-     * The is nominal.
-     */
-    protected boolean isNominal;
+	/** Strings longer than this will be stored compressed. */
+	private static final int STRING_COMPRESS_THRESHOLD = 200;
 
-    /**
-     * The is numeric.
-     */
-    protected boolean isNumeric;
+	/**
+	 * The is nominal.
+	 */
+	protected boolean isNominal;
 
-    /**
-    * The is date.
-    */
-    protected boolean isDate;
+	/**
+	 * The is numeric.
+	 */
+	protected boolean isNumeric;
 
-     /** 
-     * Date format specification for date attributes 
-     */
-    protected SimpleDateFormat m_DateFormat;
-  
-    /**
-     * The name.
-     */
-    protected String name;
+	/**
+	 * The is date.
+	 */
+	protected boolean isDate;
 
-    /**
-     * The attribute values.
-     */
-    protected List<String> attributeValues;
+	/**
+	 * The is hierarchical.
+	 */
+	protected boolean isHierarchical;
 
-    /**
-     * Gets the attribute values.
-     *
-     * @return the attribute values
-     */
-    public List<String> getAttributeValues() {
-        return attributeValues;
-    }
-    
-
-    /**
-     * Instantiates a new attribute.
-     *
-     * @param string the string
-     */
-    public Attribute(String string) {
-        this.name = string;
-        this.isNumeric = true;
-    }
+	/** 
+	 * Date format specification for date attributes 
+	 */
+	protected SimpleDateFormat m_DateFormat;
 
     /**
-     * Instantiates a new attribute.
-     *
-     * @param attributeName the attribute name
-     * @param attributeValues the attribute values
+     * The index.
      */
-    public Attribute(String attributeName, List<String> attributeValues) {
-        this.name = attributeName;
-        this.attributeValues = attributeValues;
-        this.isNominal = true;
-    }
+    protected int index;
+
+	/**
+	 * The attribute values.
+	 */
+	protected List<String> attributeValues;
+	
+	/**
+	 * The attribute structure.
+	 */
+	protected AttributeStructure attributeStructure;
+
+	/**
+	 * Gets the attribute values.
+	 *
+	 * @return the attribute values
+	 */
+	public List<String> getAttributeValues() {
+		return attributeValues;
+	}
 
     /**
      * Instantiates a new attribute.
@@ -121,7 +111,8 @@ public Attribute(String attributeName, List<String> attributeValues) {
      * @param dateFormat the format of the date used
      */
     public Attribute(String attributeName, String dateFormat) {
-        this.name = attributeName;        
+        this.name = attributeName;
+        this.index  = -1;
         this.valuesStringAttribute = null;
         this.isDate = true;
         
@@ -139,160 +130,239 @@ public Attribute() {
         this("");
     }
 
-    /**
-     * Checks if is nominal.
-     *
-     * @return true, if is nominal
-     */
-    public boolean isNominal() {
-        return this.isNominal;
-    }
-
-    /**
-     * Name.
-     *
-     * @return the string
-     */
-    public String name() {
-        return this.name;
-    }
-
-    /**
-     * Value.
-     *
-     * @param value the value
-     * @return the string
-     */
-    public String value(int value) {
-        return attributeValues.get(value);
-    }
-
-    /**
-     * Checks if is numeric.
-     *
-     * @return true, if is numeric
-     */
-    public boolean isNumeric() {
-        return isNumeric;
-    }
-
-    /**
-     * Num values.
-     *
-     * @return the int
-     */
-    public int numValues() {
-        if (isNumeric()) {
-            return 0;
-        } else {
-            return attributeValues.size();
-        }
-    }
+	/**
+	 * Instantiates a new attribute.
+	 *
+	 * @param string the string
+	 */
+	public Attribute(String string) {
+		this.name = string;
+		this.isNumeric = true;
+	}
+
+	/**
+	 * Instantiates a new attribute.
+	 *
+	 * @param attributeName the attribute name
+	 * @param attributeValues the attribute values
+	 */
+	public Attribute(String attributeName, List<String> attributeValues) {
+		this.name = attributeName;
+		this.attributeValues = attributeValues;
+		this.isNominal = true;
+	}
+
+	/**
+	 * Instantiates a new attribute.
+	 *
+	 * @param attributeName the attribute name
+	 * @param dateFormat the format of the date used
+	 */
+	public Attribute(String attributeName, String dateFormat) {
+		this.name = attributeName;
+		this.index  = -1;
+		this.valuesStringAttribute = null;
+		this.isDate = true;
+
+		if (dateFormat != null) {
+			m_DateFormat = new SimpleDateFormat(dateFormat);
+		} else {
+			m_DateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
+		}
+	}
+	
+	/**
+	 * Instantiates a new attribute.
+	 *
+	 * @param attributeName the attribute name
+	 * @param attributeValues the attribute values
+	 * @param attributeStructure the attribute structure 
+	 */
+	public Attribute(String attributeName, List<String> attributeValues, AttributeStructure attributeStructure) {
+		this.name = attributeName;
+		this.attributeValues = attributeValues;
+		this.attributeStructure = attributeStructure;
+		this.isHierarchical = true;
+	}
+	/**
+	 * Instantiates a new attribute.
+	 */
+	public Attribute() {
+		this("");
+	}
+
+	/**
+	 * Checks if is nominal.
+	 *
+	 * @return true, if is nominal
+	 */
+	public boolean isNominal() {
+		return this.isNominal;
+	}
 
     /**
      * Index.
      *
      * @return the int
      */
-//    public int index() { //RuleClassifier        
-//        return this.index;
-//    }
-
-    /**
-     * Format date.
-     *
-     * @param value the value
-     * @return the string
-     */
-    String formatDate(double value) {
-        return this.m_DateFormat.format(new Date((long) value));
-    }
-
-    /**
-     * Checks if is date.
-     *
-     * @return true, if is date
-     */
-    boolean isDate() {
-        return isDate;
+    public int index() { //RuleClassifier
+        return this.index;
     }
 
-    /**
-     * The values string attribute.
-     */
-    private Map<String, Integer> valuesStringAttribute;
-
-    /**
-     * Index of value.
-     *
-     * @param value the value
-     * @return the int
-     */
-    public final int indexOfValue(String value) {
-
-        if (isNominal() == false) {
-            return -1;
-        }
-        if (this.valuesStringAttribute == null) {
-            this.valuesStringAttribute = new HashMap<String, Integer>();
-            int count = 0;
-            for (String stringValue : attributeValues) {
-                this.valuesStringAttribute.put(stringValue, count);
-                count++;
-            }
-        }
-        Integer val = (Integer) this.valuesStringAttribute.get(value);
-        if (val == null) {
-            return -1;
-        } else {
-            return val.intValue();
-        }
-    }
-    
-    /**
-    * Returns a description of this attribute in ARFF format. Quotes
-    * strings if they contain whitespace characters, or if they
-     * are a question mark.
-     *
-     * @return a description of this attribute as a string
-     */
-    public final String toString() {
-    
-    StringBuffer text = new StringBuffer();
-    
-    text.append(ARFF_ATTRIBUTE).append(" ").append(Utils.quote(this.name())).append(" ");
-    
-    if (this.isNominal){
-        text.append('{');
-        Enumeration enu =  enumerateValues();
-        while (enu.hasMoreElements()) {
-            text.append(Utils.quote((String) enu.nextElement()));
-            if (enu.hasMoreElements())
-                text.append(',');
-        }
-        text.append('}');
-    } else if (this.isNumeric){
-        text.append(ARFF_ATTRIBUTE_NUMERIC);
-    } else if (this.isDate){
-        text.append(ARFF_ATTRIBUTE_DATE).append(" ").append(Utils.quote(m_DateFormat.toPattern()));
-    } else{
-        text.append("UNKNOW");
-    }
-    
-    return text.toString();
-  }
-  
-    /**
-   * Returns an enumeration of all the attribute's values if the
-   * attribute is nominal, null otherwise.
-   *
-   * @return enumeration of all the attribute's values
-   */
-  public final /*@ pure @*/ Enumeration enumerateValues() {
-
-    if (this.isNominal()) {
-      return Collections.enumeration(this.attributeValues);
-    }
-    return null;
-  }
+	/**
+	 * Value.
+	 *
+	 * @param value the value
+	 * @return the string
+	 */
+	public String value(int value) {
+		return attributeValues.get(value);
+	}
+
+	/**
+	 * Checks if is numeric.
+	 *
+	 * @return true, if is numeric
+	 */
+	public boolean isNumeric() {
+		return isNumeric;
+	}
+
+	/**
+	 * Num values.
+	 *
+	 * @return the int
+	 */
+	public int numValues() {
+		if (isNumeric()) {
+			return 0;
+		} else {
+			return attributeValues.size();
+		}
+	}
+
+	/**
+	 * Checks if is hierarchical.
+	 *
+	 * @return true, if is hierarchical
+	 */
+	public boolean isHierarchical() {
+		return this.isHierarchical;
+	}
+
+	
+	/**
+	 * Index.
+	 *
+	 * @return the int
+	 */
+	public int index() { //RuleClassifier
+		return this.index;
+	}
+
+	/**
+	 * Format date.
+	 *
+	 * @param value the value
+	 * @return the string
+	 */
+	String formatDate(double value) {
+		return this.m_DateFormat.format(new Date((long) value));
+	}
+
+	/**
+	 * Checks if is date.
+	 *
+	 * @return true, if is date
+	 */
+	boolean isDate() {
+		return isDate;
+	}
+
+	/**
+	 * The values string attribute.
+	 */
+	private Map<String, Integer> valuesStringAttribute;
+
+	/**
+	 * Index of value.
+	 *
+	 * @param value the value
+	 * @return the int
+	 */
+	public final int indexOfValue(String value) {
+
+		if (!isNominal()) {
+			return -1;
+		}
+		// TODO check how this affects hierarchies
+		if (this.valuesStringAttribute == null) {
+			this.valuesStringAttribute = new HashMap<String, Integer>();
+			int count = 0;
+			for (String stringValue : attributeValues) {
+				this.valuesStringAttribute.put(stringValue, count);
+				count++;
+			}
+		}
+		Integer val = (Integer) this.valuesStringAttribute.get(value);
+		if (val == null) {
+			return -1;
+		} else {
+			return val.intValue();
+		}
+	}
+
+	/**
+	 * Returns a description of this attribute in ARFF format. Quotes
+	 * strings if they contain whitespace characters, or if they
+	 * are a question mark.
+	 *
+	 * @return a description of this attribute as a string
+	 */
+	public final String toString() {
+
+		StringBuffer text = new StringBuffer();
+
+		text.append(ARFF_ATTRIBUTE).append(" ").append(Utils.quote(this.name())).append(" ");
+
+		if (this.isNominal){
+			text.append('{');
+			Enumeration enu = enumerateValues();
+			while (enu.hasMoreElements()) {
+				text.append(Utils.quote((String) enu.nextElement()));
+				if (enu.hasMoreElements())
+					text.append(',');
+			}
+			text.append('}');
+		} else if (this.isNumeric){
+			text.append(ARFF_ATTRIBUTE_NUMERIC);
+		} else if (this.isDate){
+			text.append(ARFF_ATTRIBUTE_DATE).append(" ").append(Utils.quote(m_DateFormat.toPattern()));
+		} else if (this.isHierarchical) {
+			text.append(ARFF_ATTRIBUTE_HIERARCHICAL).append(" ");
+
+			text.append("{");
+			// TODO output hierarchy
+			text.append("}");
+			
+		} else {
+			text.append("UNKNOW");
+		}
+
+		return text.toString();
+	}
+
+	/**
+	 * Returns an enumeration of all the attribute's values if the
+	 * attribute is nominal, null otherwise.
+	 *
+	 * @return enumeration of all the attribute's values
+	 */
+	public final /*@ pure @*/ Enumeration enumerateValues() {
+
+		if (this.isNominal()) {
+			return Collections.enumeration(this.attributeValues);
+		}
+		return null;
+	}
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/AttributeStructure.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/AttributeStructure.java
new file mode 100644
index 000000000..afcd53e38
--- /dev/null
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/AttributeStructure.java
@@ -0,0 +1,7 @@
+package com.yahoo.labs.samoa.instances;
+
+import java.io.Serializable;
+
+public interface AttributeStructure extends Serializable {
+
+}
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/DAGStructure.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/DAGStructure.java
new file mode 100644
index 000000000..b26cd433c
--- /dev/null
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/DAGStructure.java
@@ -0,0 +1,86 @@
+package com.yahoo.labs.samoa.instances;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class DAGStructure implements AttributeStructure {
+	public Node root;
+	
+	public Map<String, Node> nodes;
+	
+	public int type;
+	
+	public static int HIERARCHY_TYPE = 0;
+	public static int DAG_TYPE = 1;
+	
+	public DAGStructure() {
+		this.type = DAGStructure.HIERARCHY_TYPE;
+		this.nodes = new HashMap<String, Node>();
+		this.root = null;
+	}
+	
+	public boolean hasNode(String description) {
+		return nodes.containsKey(description);
+	}
+	
+	public void addNode(String description) {
+		nodes.put(description, new Node(description));
+	}
+	
+	public void addChild(String parent, String child) {
+		Node p = nodes.get(parent);
+		Node c = nodes.get(child);
+		p.addChild(c);
+		c.addAncestor(p);
+		if (c.ancestors.size() > 1) {
+			this.type = DAGStructure.DAG_TYPE;
+		}
+	}
+	
+	public void setRoot(String description) {
+		if (this.nodes.containsKey(description)) {
+			this.root = this.nodes.get(description);
+		}
+	}
+	
+	public class Node {
+		public String description;
+		
+		public List<Node> ancestors;
+		public List<Node> children;
+		
+		public Node(String description) {
+			this.description = description;
+			this.ancestors = new ArrayList<Node>();
+			this.children = new ArrayList<Node>();
+		}
+		
+		public void addAncestor(Node ancestor) {
+			this.ancestors.add(ancestor);
+		}
+		
+		public void addChild(Node child) {
+			this.ancestors.add(child);
+		}
+		
+		public boolean isRoot() {
+			// Should only be called when the structure is built
+			return this.ancestors.isEmpty();
+		}
+		
+		public double getLevel() {
+			// Check how this is done when a DAG is used instead of a hierarchy
+			if (this.isRoot()) return 0;
+			else {
+				double total = Integer.MAX_VALUE; 
+				for (Node ancestor : this.ancestors) {
+					total = total + ancestor.getLevel();
+				}
+				return total / ancestors.size() + 1;
+			}
+		}
+	}
+
+}
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/HierarhicalInstanceImpl.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/HierarhicalInstanceImpl.java
new file mode 100644
index 000000000..c9ed7728c
--- /dev/null
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/HierarhicalInstanceImpl.java
@@ -0,0 +1,452 @@
+/*
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * 	        http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific
+ * language governing permissions and limitations under the
+ * License.  
+ */
+package com.yahoo.labs.samoa.instances;
+
+import moa.AbstractMOAObject;
+
+/**
+ * The Class InstanceImpl.
+ *
+ * @author abifet
+ */
+public class HierarhicalInstanceImpl implements StructuredInstance {
+
+    /**
+	 * 
+	 */
+	private static final long serialVersionUID = 1L;
+
+	/**
+     * The weight.
+     */
+    protected double weight;
+
+    /**
+     * The instance data.
+     */
+    protected InstanceData instanceData;
+
+    /**
+     * The instance information.
+     */
+    protected InstancesHeader instanceHeader;
+
+    /**
+     * Instantiates a new instance.
+     *
+     * @param inst the inst
+     */
+    public HierarhicalInstanceImpl(HierarhicalInstanceImpl inst) {
+        this.weight = inst.weight;
+        this.instanceData = inst.instanceData.copy();
+        this.instanceHeader = inst.instanceHeader;
+    }
+
+    //Dense
+    /**
+     * Instantiates a new instance.
+     *
+     * @param weight the weight
+     * @param res the res
+     */
+    public HierarhicalInstanceImpl(double weight, double[] res) {
+        this.weight = weight;
+        this.instanceData = new DenseInstanceData(res);
+    }
+
+    //Sparse
+    /**
+     * Instantiates a new instance.
+     *
+     * @param weight the weight
+     * @param attributeValues the attribute values
+     * @param indexValues the index values
+     * @param numberAttributes the number attributes
+     */
+    public HierarhicalInstanceImpl(double weight, double[] attributeValues, int[] indexValues, int numberAttributes) {
+        this.weight = weight;
+        this.instanceData = new SparseInstanceData(attributeValues, indexValues, numberAttributes);
+    }
+
+    /**
+     * Instantiates a new instance.
+     *
+     * @param weight the weight
+     * @param instanceData the instance data
+     */
+    public HierarhicalInstanceImpl(double weight, InstanceData instanceData) {
+        this.weight = weight;
+        this.instanceData = instanceData;
+    }
+
+    /**
+     * Instantiates a new instance.
+     *
+     * @param numAttributes the num attributes
+     */
+    public HierarhicalInstanceImpl(int numAttributes) {
+        this.instanceData = new DenseInstanceData(new double[numAttributes]); //JD
+        this.weight = 1;
+    }
+
+    /**
+     * Weight.
+     *
+     * @return the double
+     */
+    @Override
+    public double weight() {
+        return weight;
+    }
+
+    /**
+     * Sets the weight.
+     *
+     * @param weight the new weight
+     */
+    @Override
+    public void setWeight(double weight) {
+        this.weight = weight;
+    }
+
+    /**
+     * Attribute.
+     *
+     * @param instAttIndex the inst att index
+     * @return the attribute
+     */
+    @Override
+    public Attribute attribute(int instAttIndex) {
+        return this.instanceHeader.attribute(instAttIndex);
+    }
+
+    /**
+     * Delete attribute at.
+     *
+     * @param i the i
+     */
+    @Override
+    public void deleteAttributeAt(int i) {
+        //throw new UnsupportedOperationException("Not yet implemented");
+        this.instanceData.deleteAttributeAt(i);
+    }
+
+    /**
+     * Insert attribute at.
+     *
+     * @param i the i
+     */
+    @Override
+    public void insertAttributeAt(int i) {
+        throw new UnsupportedOperationException("Not yet implemented");
+    }
+
+    /**
+     * Num attributes.
+     *
+     * @return the int
+     */
+    @Override
+    public int numAttributes() {
+        return this.instanceData.numAttributes();
+    }
+
+    /**
+     * Value.
+     *
+     * @param instAttIndex the inst att index
+     * @return the double
+     */
+    @Override
+    public double value(int instAttIndex) {
+        return this.instanceData.value(instAttIndex);
+    }
+
+    /**
+     * Checks if is missing.
+     *
+     * @param instAttIndex the inst att index
+     * @return true, if is missing
+     */
+    @Override
+    public boolean isMissing(int instAttIndex) {
+        return this.instanceData.isMissing(instAttIndex);
+    }
+
+    /**
+     * Num values.
+     *
+     * @return the int
+     */
+    @Override
+    public int numValues() {
+        return this.instanceData.numValues();
+    }
+
+    /**
+     * Index.
+     *
+     * @param i the i
+     * @return the int
+     */
+    @Override
+    public int index(int i) {
+        return this.instanceData.index(i);
+    }
+
+    /**
+     * Value sparse.
+     *
+     * @param i the i
+     * @return the double
+     */
+    @Override
+    public double valueSparse(int i) {
+        return this.instanceData.valueSparse(i);
+    }
+
+    /**
+     * Checks if is missing sparse.
+     *
+     * @param p the p
+     * @return true, if is missing sparse
+     */
+    @Override
+    public boolean isMissingSparse(int p) {
+        return this.instanceData.isMissingSparse(p);
+    }
+
+    /**
+     * Value.
+     *
+     * @param attribute the attribute
+     * @return the double
+     */
+    @Override
+    public double value(Attribute attribute) {
+        return value(attribute.index());
+
+    }
+
+    /**
+     * String value.
+     *
+     * @param i the i
+     * @return the string
+     */
+    @Override
+    public String stringValue(int i) {
+        throw new UnsupportedOperationException("Not yet implemented");
+    }
+
+    /**
+     * To double array.
+     *
+     * @return the double[]
+     */
+    @Override
+    public double[] toDoubleArray() {
+        return this.instanceData.toDoubleArray();
+    }
+
+    /**
+     * Sets the value.
+     *
+     * @param numAttribute the num attribute
+     * @param d the d
+     */
+    @Override
+    public void setValue(int numAttribute, double d) {
+        this.instanceData.setValue(numAttribute, d);
+    }
+
+    /**
+     * Class value.
+     *
+     * @return the double
+     */
+    @Override
+    public double classValue() {
+        return this.instanceData.value(classIndex());
+    }
+
+    /**
+     * Class index.
+     *
+     * @return the int
+     */
+    @Override
+    public int classIndex() {
+        int classIndex = instanceHeader.classIndex();
+        return classIndex != Integer.MAX_VALUE ? classIndex : 0;
+    }
+
+    /**
+     * Num classes.
+     *
+     * @return the int
+     */
+    @Override
+    public int numClasses() {
+        return this.instanceHeader.numClasses();
+    }
+
+    /**
+     * Class is missing.
+     *
+     * @return true, if successful
+     */
+    @Override
+    public boolean classIsMissing() {
+        return this.instanceData.isMissing(classIndex());
+    }
+
+    /**
+     * Class attribute.
+     *
+     * @return the attribute
+     */
+    @Override
+    public Attribute classAttribute() {
+        return this.instanceHeader.attribute(classIndex());
+    }
+
+    /**
+     * Sets the class value.
+     *
+     * @param d the new class value
+     */
+    @Override
+    public void setClassValue(double d) {
+        this.setValue(classIndex(), d);
+    }
+
+    /**
+     * Copy.
+     *
+     * @return the instance
+     */
+    @Override
+    public Instance copy() {
+        HierarhicalInstanceImpl inst = new HierarhicalInstanceImpl(this);
+        return inst;
+    }
+
+    /**
+     * Dataset.
+     *
+     * @return the instances
+     */
+    @Override
+    public Instances dataset() {
+        return this.instanceHeader;
+    }
+
+    /**
+     * Sets the dataset.
+     *
+     * @param dataset the new dataset
+     */
+    @Override
+    public void setDataset(Instances dataset) {
+        this.instanceHeader = new InstancesHeader(dataset);
+    }
+
+    /**
+     * Adds the sparse values.
+     *
+     * @param indexValues the index values
+     * @param attributeValues the attribute values
+     * @param numberAttributes the number attributes
+     */
+    @Override
+    public void addSparseValues(int[] indexValues, double[] attributeValues, int numberAttributes) {
+        this.instanceData = new SparseInstanceData(attributeValues, indexValues, numberAttributes); //???
+    }
+
+    /**
+     * Text representation of a InstanceImpl.
+     */
+    @Override
+    public String toString() {
+        double[] aux = this.instanceData.toDoubleArray();
+        StringBuilder str = new StringBuilder();
+        for (int i = 0; i < aux.length; i++) {
+            str.append(aux[i]).append(" ");
+        }
+
+        return str.toString();
+    }
+
+    @Override
+    public int numInputAttributes() {
+        return this.instanceHeader.numInputAttributes();
+    }
+
+    @Override
+    public int numOutputAttributes() {
+        return numberOutputTargets();
+    }
+    
+    @Override
+    public int numberOutputTargets() {
+        return this.instanceHeader.numOutputAttributes();
+    }
+
+    @Override
+    public double classValue(int instAttIndex) {
+        return valueOutputAttribute(instAttIndex);
+    }
+
+    @Override
+    public void setClassValue(int indexClass, double valueAttribute) {
+        InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
+        this.instanceData.setValue(instanceInformation.outputAttributeIndex(indexClass), valueAttribute);
+
+    }
+
+    @Override
+    public Attribute outputAttribute(int outputIndex) {
+        InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
+        return instanceInformation.outputAttribute(outputIndex);
+    }
+
+    @Override
+    public Attribute inputAttribute(int attributeIndex) {
+        InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
+        return instanceInformation.inputAttribute(attributeIndex);
+    }
+
+    @Override
+    public double valueInputAttribute(int attributeIndex) {
+        InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
+        return this.instanceData.value(instanceInformation.inputAttributeIndex(attributeIndex));
+    }
+
+    @Override
+    public double valueOutputAttribute(int attributeIndex) {
+        InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
+        return this.instanceData.value(instanceInformation.outputAttributeIndex(attributeIndex));
+    }
+    
+    public int structureType() {
+    	return Instance.STRUCTURE_TYPE_HIERARHICAL;
+    }
+    
+    public AttributeStructure getStructure() {
+    	return this.instanceHeader.getInstanceStructure();
+    }
+}
\ No newline at end of file
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
index 928ad4c5a..e85621700 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
@@ -17,6 +17,8 @@
 
 import java.io.Serializable;
 
+import moa.AbstractMOAObject;
+
 /**
  * The Interface Instance.
  *
@@ -24,6 +26,11 @@
  */
 public interface Instance extends Serializable {
 
+	public static int STRUCTURE_TYPE_SINGLE_TARGET = 0;
+	public static int STRUCTURE_TYPE_MULTI_TARGET = 1;
+	public static int STRUCTURE_TYPE_TIME_SERIES = 2;
+	public static int STRUCTURE_TYPE_HIERARHICAL = 3;
+	
     /**
      * Gets the weight of the instance.
      *
@@ -327,5 +334,9 @@ public interface Instance extends Serializable {
      * @return the value
      */
     public double valueOutputAttribute(int attributeIndex);
+    
+    public int structureType();
+    
+    public AttributeStructure getStructure();
 
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
index 59c88d5b8..6cfb34dbd 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
@@ -15,8 +15,6 @@
  */
 package com.yahoo.labs.samoa.instances;
 
-import java.text.SimpleDateFormat;
-
 /**
  * The Class InstanceImpl.
  *
@@ -128,10 +126,6 @@ public Attribute attribute(int instAttIndex) {
         return this.instanceHeader.attribute(instAttIndex);
     }
 
-    public int indexOfAttribute(Attribute attribute){
-        return this.instanceHeader.indexOf(attribute);
-    }
-    
     /**
      * Delete attribute at.
      *
@@ -139,6 +133,7 @@ public int indexOfAttribute(Attribute attribute){
      */
     @Override
     public void deleteAttributeAt(int i) {
+        //throw new UnsupportedOperationException("Not yet implemented");
         this.instanceData.deleteAttributeAt(i);
     }
 
@@ -235,8 +230,8 @@ public boolean isMissingSparse(int p) {
      */
     @Override
     public double value(Attribute attribute) {
-        int index = this.instanceHeader.indexOf(attribute);
-        return value(index);
+        return value(attribute.index());
+
     }
 
     /**
@@ -409,7 +404,7 @@ public int numInputAttributes() {
     public int numOutputAttributes() {
         return numberOutputTargets();
     }
-
+    
     @Override
     public int numberOutputTargets() {
         return this.instanceHeader.numOutputAttributes();
@@ -461,16 +456,12 @@ public void setMissing(Attribute attribute) {
         int index = this.instanceHeader.indexOf(attribute);
         this.setMissing(index);
     }
-
-    @Override
-    public boolean isMissing(Attribute attribute) {
-        int index = this.instanceHeader.indexOf(attribute);
-        return this.isMissing(index);
+    
+    public int structureType() {
+    	return (numOutputAttributes() > 1) ? Instance.STRUCTURE_TYPE_MULTI_TARGET : Instance.STRUCTURE_TYPE_SINGLE_TARGET;
     }
-
-    @Override
-    public void setValue(Attribute attribute, double value) {
-        int index = this.instanceHeader.indexOf(attribute);
-        this.setValue(index, value);
+    
+    public AttributeStructure getStructure() {
+    	return null;
     }
-}
+}
\ No newline at end of file
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
index dd59d6f27..7a8aae816 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
@@ -18,6 +18,8 @@
 import java.io.Serializable;
 import java.util.List;
 
+import moa.AbstractMOAObject;
+
 /**
  * The Class InstanceInformation.
  *
@@ -31,6 +33,8 @@ public class InstanceInformation implements Serializable {
     protected String relationName;
 
     protected AttributesInformation attributesInformation;
+    
+    protected AttributeStructure structure = null;
 
     /**
      * The class index.
@@ -58,6 +62,7 @@ public Attribute outputAttribute(int w) {
     public InstanceInformation(InstanceInformation chunk) {
         this.relationName = chunk.relationName;
         this.attributesInformation = chunk.attributesInformation;
+        this.structure = chunk.structure;
         this.classIndex = chunk.classIndex;
     }
 
@@ -212,5 +217,9 @@ public void setAttributes(List<Attribute> v, List<Integer> indexValues) {
         this.attributesInformation.setAttributes(v,indexValues);
 		
 	}
+	
+	public AttributeStructure getStructure() {
+		return this.structure;
+	}
 
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
index e4088a237..6086fa888 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
@@ -123,4 +123,8 @@ public int numOutputAttributes() {
     public InstanceInformation getInstanceInformation() {
         return this.instanceInformation;
     }
+    
+    public AttributeStructure getInstanceStructure() {
+    	return this.instanceInformation.getStructure();
+    }
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelInstance.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/StructuredInstance.java
similarity index 87%
rename from moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelInstance.java
rename to moa/src/main/java/com/yahoo/labs/samoa/instances/StructuredInstance.java
index 0978bd332..279d6baed 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelInstance.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/StructuredInstance.java
@@ -16,12 +16,12 @@
 package com.yahoo.labs.samoa.instances;
 
 /**
- * The Interface MultiLabelInstance.
+ * The Interface StructuredInstance.
  *
  * @author abifet
  */
    
-public interface MultiLabelInstance extends Instance {
+public interface StructuredInstance extends Instance {
 
 }
  
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/AbstractClassifier.java b/moa/src/main/java/moa/classifiers/AbstractClassifier.java
index 9511a24f6..ee1c01c47 100644
--- a/moa/src/main/java/moa/classifiers/AbstractClassifier.java
+++ b/moa/src/main/java/moa/classifiers/AbstractClassifier.java
@@ -85,14 +85,15 @@ public AbstractClassifier() {
     }
 
     @Override
-    public void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
+    public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
         if (this.randomSeedOption != null) {
             this.randomSeed = this.randomSeedOption.getValue();
         }
-        if (!trainingHasStarted()) {
-            resetLearning();
-        }
+        
+        // resetLearning should not be called if the classifier has not yet received the context
+//        if (!trainingHasStarted()) {
+//            resetLearning();
+//        }
     }
 
 	
diff --git a/moa/src/main/java/moa/classifiers/AbstractMultiLabelLearner.java b/moa/src/main/java/moa/classifiers/AbstractMultiLabelLearner.java
index 641228cf0..3fefdd9ce 100644
--- a/moa/src/main/java/moa/classifiers/AbstractMultiLabelLearner.java
+++ b/moa/src/main/java/moa/classifiers/AbstractMultiLabelLearner.java
@@ -2,7 +2,7 @@
 
 import moa.core.Example;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 public abstract class AbstractMultiLabelLearner extends AbstractClassifier implements MultiLabelLearner {
@@ -13,11 +13,11 @@ public abstract class AbstractMultiLabelLearner extends AbstractClassifier imple
     private static final long serialVersionUID = 1L;
 
     @Override
-    abstract public void trainOnInstanceImpl(MultiLabelInstance instance);
+    abstract public void trainOnInstanceImpl(StructuredInstance instance);
 
     @Override
     public void trainOnInstanceImpl(Instance instance) {
-        trainOnInstanceImpl((MultiLabelInstance) instance);
+        trainOnInstanceImpl((StructuredInstance) instance);
     }
 
     @Override
@@ -27,10 +27,10 @@ public Prediction getPredictionForInstance(Example<Instance> example) {
 
     @Override
     public Prediction getPredictionForInstance(Instance inst) {
-        return getPredictionForInstance((MultiLabelInstance) inst);
+        return getPredictionForInstance((StructuredInstance) inst);
     }
 
-    abstract public Prediction getPredictionForInstance(MultiLabelInstance inst);
+    abstract public Prediction getPredictionForInstance(StructuredInstance inst);
 
     @Override
     public double[] getVotesForInstance(Instance inst) {
diff --git a/moa/src/main/java/moa/classifiers/MultiLabelLearner.java b/moa/src/main/java/moa/classifiers/MultiLabelLearner.java
index b42a37085..ee875ee60 100644
--- a/moa/src/main/java/moa/classifiers/MultiLabelLearner.java
+++ b/moa/src/main/java/moa/classifiers/MultiLabelLearner.java
@@ -1,12 +1,12 @@
 package moa.classifiers;
 
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 public interface MultiLabelLearner extends Classifier{
 	
-	public void trainOnInstanceImpl(MultiLabelInstance instance);
+	public void trainOnInstanceImpl(StructuredInstance instance);
 	
-	public Prediction getPredictionForInstance(MultiLabelInstance instance);
+	public Prediction getPredictionForInstance(StructuredInstance instance);
 
 }
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBag.java b/moa/src/main/java/moa/classifiers/meta/OzaBag.java
index d7c935590..9ca3dd639 100644
--- a/moa/src/main/java/moa/classifiers/meta/OzaBag.java
+++ b/moa/src/main/java/moa/classifiers/meta/OzaBag.java
@@ -70,9 +70,9 @@ public String getPurposeString() {
     public void resetLearningImpl() {
         this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
         Classifier baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
-        baseLearner.resetLearning();
         for (int i = 0; i < this.ensemble.length; i++) {
             this.ensemble[i] = baseLearner.copy();
+            
         }
     }
 
diff --git a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
index c23396899..4c78071f9 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
@@ -1,15 +1,13 @@
 package moa.classifiers.multilabel;
 
 import java.util.ArrayList;
-import java.util.LinkedList;
 import java.util.List;
-import java.util.Vector;
 
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 
@@ -36,7 +34,6 @@ public class LocalMultiTargetClassifier extends AbstractMultiLabelLearner
 	
 	@Override
 	public boolean isRandomizable() {
-		// TODO Auto-generated method stub
 		return true;
 	}
 
@@ -51,8 +48,8 @@ private void makeHeaders() {
 		if (headers == null) {
 			headers = new ArrayList<InstancesHeader>();
 			for (int target = 0; target < getModelContext().numOutputAttributes(); target++) {
-				List<Attribute> attributes = new LinkedList<Attribute>();
-				List<Integer> indexValues = new LinkedList<Integer>();
+				List<Attribute> attributes = new ArrayList<Attribute>();
+				List<Integer> indexValues = new ArrayList<Integer>();
 				for (int i = 0; i < getModelContext().numInputAttributes(); i++) {
 					attributes.add(getModelContext().inputAttribute(i));
 					indexValues.add(i);
@@ -67,7 +64,7 @@ private void makeHeaders() {
 		}
 	}
 	
-	private Instance getSTInstance(MultiLabelInstance inst, int target) {
+	private Instance getSTInstance(StructuredInstance inst, int target) {
 		double[] instanceData = new double[getModelContext().numInputAttributes() + 1];
 		for (int i = 0; i < inst.numInputAttributes(); i++)
 			instanceData[i] = inst.valueInputAttribute(i);
@@ -78,8 +75,7 @@ private Instance getSTInstance(MultiLabelInstance inst, int target) {
 	}
 	
 	@Override
-	public void trainOnInstanceImpl(MultiLabelInstance instance) {
-		// TODO Auto-generated method stub
+	public void trainOnInstanceImpl(StructuredInstance instance) {
 		initializeClassifiers();
 		
 		for (int j = 0; j < instance.numberOutputTargets(); j++) {
@@ -90,7 +86,7 @@ public void trainOnInstanceImpl(MultiLabelInstance instance) {
 	}
 
 	@Override
-	public Prediction getPredictionForInstance(MultiLabelInstance inst) {
+	public Prediction getPredictionForInstance(StructuredInstance inst) {
 		initializeClassifiers();
 
 		MultiLabelPrediction prediction = new MultiLabelPrediction(getModelContext().numOutputAttributes());
diff --git a/moa/src/main/java/moa/classifiers/multilabel/MEKAClassifier.java b/moa/src/main/java/moa/classifiers/multilabel/MEKAClassifier.java
index 7691b603f..8d5aed722 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/MEKAClassifier.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/MEKAClassifier.java
@@ -1,7 +1,7 @@
 /*
  *    MEKAClassifier.java
  *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
- *    @author Jesse Read
+ *    @author Jesse Read (jesse@tsc.uc3m.es)
  * 
  *    This program is free software; you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
@@ -33,7 +33,7 @@
 import com.yahoo.labs.samoa.instances.Instances;
 import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
 
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
@@ -111,6 +111,9 @@ public void trainOnInstanceImpl(MultiLabelInstance samoaInstance) {
 				//System.exit(1);
 			}
 			this.isClassificationEnabled = true;
+		} else {
+			System.err.println("Only suports UpdateableClassifiers for now.");
+			System.exit(1);
 		}
 		else {
 			/*
@@ -130,10 +133,30 @@ public void trainOnInstanceImpl(MultiLabelInstance samoaInstance) {
 	@Override
 	public double[] getVotesForInstance(Instance samoaInstance) {
 
+
+	@Override
+	public void trainOnInstanceImpl(MultiLabelInstance samoaInstance) {
 		weka.core.Instance inst = this.instanceConverter.wekaInstance(samoaInstance);
+		//System.out.println(""+m_L);                   // <--  this is correct
+		//System.out.println(""+inst.classIndex());     // <--- this one is wrong
+		inst.dataset().setClassIndex(m_L);                      // <-- so, fix it!
 
 		double votes[] = new double[L];
 
+		//System.out.println(inst.classIndex());
+		try {
+			//System.out.println("UPDATE   WITH instances of "+instancesBuffer.classIndex()+" labels :\n"+inst);
+			((UpdateableClassifier) classifier).updateClassifier(inst);
+		} catch (Exception e) {
+			e.printStackTrace();
+			System.exit(1);
+		}
+	}
+
+	@Override
+	public double[] getVotesForInstance(Instance samoaInstance) {
+		weka.core.Instance inst = this.instanceConverter.wekaInstance(samoaInstance);
+		double votes[] = null;
 		try {
 			votes = this.classifier.distributionForInstance(inst);
 		} catch(Exception e) {
@@ -141,7 +164,6 @@ public double[] getVotesForInstance(Instance samoaInstance) {
 			//e.printStackTrace();
 			//System.exit(1);
 		}
-
 		return votes;
 	}
 
diff --git a/moa/src/main/java/moa/classifiers/multilabel/MajorityLabelset.java b/moa/src/main/java/moa/classifiers/multilabel/MajorityLabelset.java
index 8810b36ab..23cea6b0b 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/MajorityLabelset.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/MajorityLabelset.java
@@ -24,7 +24,7 @@
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.Measurement;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 import moa.classifiers.AbstractMultiLabelLearner;
@@ -60,7 +60,7 @@ public void resetLearningImpl() {
     }
 
     @Override
-    public void trainOnInstanceImpl(MultiLabelInstance x) {
+    public void trainOnInstanceImpl(StructuredInstance x) {
 		int L = x.numberOutputTargets();
 
         MultiLabelPrediction y = new MultiLabelPrediction(L);
@@ -80,7 +80,16 @@ public void trainOnInstanceImpl(MultiLabelInstance x) {
     }
 
     @Override
-    public Prediction getPredictionForInstance(MultiLabelInstance x){
+    //public double[] getVotesForInstance(Instance x) {
+    public Prediction getPredictionForInstance(StructuredInstance x){
+        
+		System.out.println("-------- start MC vote   ---------------");
+        int L = x.numOutputAttributes(); //x.classIndex() + 1;
+        if (m_L != L) {
+            System.err.println("set L = " + L);
+            m_L = L;
+            predictionArray = new double[m_L];
+        }
 
 		if (this.majorityLabelset == null)  {
 			int L = x.numberOutputTargets();
diff --git a/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java b/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java
index 544e6f0d5..08a7141ac 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java
@@ -30,7 +30,7 @@
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.Instances;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 import java.util.LinkedList;
@@ -149,9 +149,11 @@ public void learnFromInstance(Instance inst, HoeffdingTree ht) {
 				}
 				for (int l : labels){
 					obs.observeAttributeClass(inst.valueInputAttribute(i), l, inst.weight());
+					//obs.observeAttributeClass(inst.value(instAttIndex), 0, inst.weight());
 				}
 			}
 		}
+	}
 
 		public void describeSubtree(HoeffdingTree ht, StringBuilder out,
 									int indent) {
@@ -182,11 +184,11 @@ protected void deactivateLearningNode(ActiveLearningNode toDeactivate,
 
 	@Override
 	public Prediction getPredictionForInstance(Example<Instance> example) {
-		return getPredictionForInstance((MultiLabelInstance)example.getData());
+		return getPredictionForInstance((StructuredInstance)example.getData());
 	}
 
 	@Override
-	public Prediction getPredictionForInstance(MultiLabelInstance inst){
+	public Prediction getPredictionForInstance(StructuredInstance inst){
 
 		if (this.treeRoot != null) {
 			FoundNode foundNode = this.treeRoot.filterInstanceToLeaf(inst, null, -1);
@@ -215,7 +217,7 @@ public void trainOnInstance(Instance inst) {
 	}
 
 	@Override
-	public void trainOnInstanceImpl(MultiLabelInstance instance) {
+	public void trainOnInstanceImpl(StructuredInstance instance) {
 		trainOnInstanceImpl((Instance) instance);
 	}
         
@@ -229,5 +231,4 @@ public static List<Integer> getRelevantLabels(Instance x) {
 		}
 		return classValues;
 	}
-
 }
diff --git a/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java b/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java
index 176f3dfd0..24f9839b0 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java
@@ -1,6 +1,5 @@
 package moa.classifiers.multilabel.core.splitcriteria;
 
-import moa.classifiers.rules.core.Utils;
 import moa.core.DoubleVector;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
diff --git a/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/WeightedICVarianceReduction.java b/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/WeightedICVarianceReduction.java
new file mode 100644
index 000000000..9d5d181ea
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/WeightedICVarianceReduction.java
@@ -0,0 +1,46 @@
+package moa.classifiers.multilabel.core.splitcriteria;
+
+import moa.core.DoubleVector;
+import moa.core.ObjectRepository;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Weighted intra cluster variance reduction split criterion 
+ * @author Aljaž Osojnik <aljaz.osojnik@ijs.si>
+ *
+ */
+
+public class WeightedICVarianceReduction extends ICVarianceReduction {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 1L;
+	
+	public DoubleVector weights;
+	
+	public WeightedICVarianceReduction(DoubleVector targetWeights) {
+		super();
+		this.weights = targetWeights;
+	}
+	
+	@Override
+	public double getMeritOfSplit(DoubleVector[] preSplitDist, DoubleVector[][] postSplitDists) {
+		double error=0;
+		int numOutputs=preSplitDist.length;
+		for (int i=0; i<numOutputs; i++)
+			error += weights.getValue(i) * getMeritOfSplitForOutput(preSplitDist,postSplitDists,i);
+		return error / weights.sumOfValues();
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor,
+			ObjectRepository repository) {		
+	}
+	
+}
diff --git a/moa/src/main/java/moa/classifiers/multilabel/meta/MLOzaBag.java b/moa/src/main/java/moa/classifiers/multilabel/meta/MLOzaBag.java
new file mode 100644
index 000000000..f5d1dff78
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/multilabel/meta/MLOzaBag.java
@@ -0,0 +1,126 @@
+/*
+ *    MLOzaBag.java
+ *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
+ *    @author Jesse Read (jesse@tsc.uc3m.es)
+ * 
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *    
+ */
+package moa.classifiers.multilabel.meta;
+
+import moa.classifiers.Classifier;
+import moa.classifiers.meta.OzaBag;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
+import com.yahoo.labs.samoa.instances.Prediction;
+import moa.classifiers.MultiLabelLearner;
+import moa.classifiers.MultiTargetRegressor;
+import moa.core.Example;
+
+/**
+ * OzaBag for Multi-label data.
+ * 
+ * @author Jesse Read (jesse@tsc.uc3m.es)
+ * @version $Revision: 1 $
+ */
+public class MLOzaBag extends OzaBag implements MultiLabelLearner, MultiTargetRegressor{
+
+    protected int m_L = -1;
+
+    //protected Random random = null;
+
+    /*
+     * @Override public void resetLearningImpl() { super.resetLearningImpl();
+     * //this.random = new Random(randomSeedOption.getValue()); }
+     */
+    @Override
+    public void resetLearningImpl() {
+        this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
+        Classifier baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
+        baseLearner.resetLearning();
+        for (int i = 0; i < this.ensemble.length; i++) {
+            this.ensemble[i] = baseLearner.copy();
+        }
+    }
+
+    @Override
+    public void setModelContext(InstancesHeader raw_header) {
+
+        //set the multilabel model context
+        this.modelContext = raw_header;
+
+        m_L = raw_header.classIndex() + 1;
+
+        // reset ensemble
+        this.resetLearningImpl();
+
+        for (int i = 0; i < this.ensemble.length; i++) {
+            this.ensemble[i].setModelContext(raw_header);
+            this.ensemble[i].resetLearning();
+        }
+    }
+
+    @Override // @note don't need this here
+    public boolean isRandomizable() {
+        return true;
+    }
+
+    @Override
+    public double[] getVotesForInstance(Instance x) {
+
+        int L = x.classIndex() + 1;
+        if (m_L != L) {
+            m_L = L;
+        }
+
+        double y[] = new double[m_L];
+
+        for (int i = 0; i < this.ensemble.length; i++) {
+            double w[] = this.ensemble[i].getVotesForInstance(x);
+            for (int j = 0; j < w.length; j++) {
+                y[j] += w[j];
+            }
+        }
+
+        return y;
+    }
+
+    @Override
+    public void trainOnInstanceImpl(StructuredInstance instance) {
+        trainOnInstanceImpl((Instance) instance);
+    }
+    
+    @Override
+	public Prediction getPredictionForInstance(Example<Instance> example) {
+		return getPredictionForInstance((StructuredInstance)example.getData());
+	} 
+    
+    @Override
+	public Prediction getPredictionForInstance(StructuredInstance instance) {
+
+		double[] predictionArray = this.getVotesForInstance(instance);
+
+		//System.out.println("y = "+Arrays.toString(predictionArray));
+
+		Prediction prediction = new MultiLabelPrediction(predictionArray.length);
+		for (int j = 0; j < predictionArray.length; j++){
+			prediction.setVote(j, 1, predictionArray[j]);
+			//prediction.setVote(j, 0, 1. - predictionArray[j]);
+		}
+		return prediction;
+	}
+
+}
diff --git a/moa/src/main/java/moa/classifiers/multilabel/meta/MLOzaBagAdwin.java b/moa/src/main/java/moa/classifiers/multilabel/meta/MLOzaBagAdwin.java
new file mode 100644
index 000000000..65e25b533
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/multilabel/meta/MLOzaBagAdwin.java
@@ -0,0 +1,182 @@
+/*
+ *    MLOzaBagAdwin.java
+ *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
+ *    @author Jesse Read (jesse@tsc.uc3m.es)
+ * 
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *    
+ */
+package moa.classifiers.multilabel.meta;
+
+import moa.classifiers.Classifier;
+import moa.classifiers.core.driftdetection.ADWIN;
+import moa.classifiers.meta.OzaBagAdwin;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import moa.core.MiscUtils;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
+import com.yahoo.labs.samoa.instances.Prediction;
+import moa.classifiers.MultiLabelLearner;
+import moa.classifiers.MultiTargetRegressor;
+import moa.core.Example;
+
+/**
+ * MLOzaBagAdwin: Changes the way to compute accuracy as an input for Adwin
+ * 
+ * @author Jesse Read (jesse@tsc.uc3m.es)
+ * @version $Revision: 1 $
+ */
+public class MLOzaBagAdwin extends OzaBagAdwin implements MultiLabelLearner, MultiTargetRegressor {
+
+    protected int m_L = -1;
+
+    @Override
+    public void setModelContext(InstancesHeader raw_header) {
+
+        //set the multilabel model context
+        this.modelContext = raw_header;
+        m_L = raw_header.classIndex() + 1;
+
+        // reset ensemble
+        this.resetLearningImpl();
+
+        for (int i = 0; i < this.ensemble.length; i++) {
+            this.ensemble[i].setModelContext(raw_header);
+            this.ensemble[i].resetLearning();
+        }
+    }
+
+    @Override
+    public void trainOnInstanceImpl(Instance inst) {
+
+        boolean Change = false;
+        for (int i = 0; i < this.ensemble.length; i++) {
+            int k = MiscUtils.poisson(1.0, this.classifierRandom);
+            if (k > 0) {
+                Instance weightedInst = (Instance) inst.copy();
+                weightedInst.setWeight(inst.weight() * k);
+                this.ensemble[i].trainOnInstance(weightedInst);
+            }
+            double[] prediction = this.ensemble[i].getVotesForInstance(inst);
+            //Compute accuracy
+            double actual[] = new double[prediction.length];
+            for (short j = 0; j < prediction.length; j++) {
+                actual[j] = inst.value(j);
+            }
+            // calculate
+            int p_sum = 0, r_sum = 0;
+            int set_union = 0;
+            int set_inter = 0;
+            double t = 0.01;
+            for (int j = 0; j < prediction.length; j++) {
+                int p = (prediction[j] >= t) ? 1 : 0;
+                int R = (int) actual[j];
+                if (p == 1) {
+                    p_sum++;
+                    // predt 1, real 1
+                    if (R == 1) {
+                        set_inter++;
+                        set_union++;
+                    } // predt 1, real 0
+                    else {
+                        set_union++;
+                    }
+                } else {
+                    // predt 0, real 1
+                    if (R == 1) {
+                        set_union++;
+                    } // predt 0, real 0
+                    else {
+                    }
+                }
+            }
+            double accuracy = 0.0;
+            if (set_union > 0) //avoid NaN
+            {
+                accuracy = ((double) set_inter / (double) set_union);
+            }
+            double ErrEstim = this.ADError[i].getEstimation();
+            if (this.ADError[i].setInput(1.0 - accuracy)) {
+                if (this.ADError[i].getEstimation() > ErrEstim) {
+                    Change = true;
+                }
+            }
+        }
+        if (Change) {
+            System.err.println("change!");
+            double max = 0.0;
+            int imax = -1;
+            for (int i = 0; i < this.ensemble.length; i++) {
+                if (max < this.ADError[i].getEstimation()) {
+                    max = this.ADError[i].getEstimation();
+                    imax = i;
+                }
+            }
+            if (imax != -1) {
+
+                this.ensemble[imax] = null;
+                this.ensemble[imax] = (Classifier) getPreparedClassOption(this.baseLearnerOption);
+                this.ensemble[imax].setModelContext(this.modelContext);
+                this.ensemble[imax].trainOnInstance(inst);
+                this.ADError[imax] = new ADWIN();
+            }
+        }
+    }
+
+    @Override
+    public double[] getVotesForInstance(Instance x) {
+
+        int L = x.classIndex() + 1;
+        if (m_L != L) {
+            m_L = L;
+        }
+
+        double y[] = new double[m_L];
+
+        for (int i = 0; i < this.ensemble.length; i++) {
+            double w[] = this.ensemble[i].getVotesForInstance(x);
+            for (int j = 0; j < w.length; j++) {
+                y[j] += w[j];
+            }
+        }
+
+        return y;
+    }
+
+    @Override
+    public void trainOnInstanceImpl(StructuredInstance instance) {
+        trainOnInstanceImpl((Instance) instance);
+    }
+
+    @Override
+    public Prediction getPredictionForInstance(Example<Instance> example) {
+        return getPredictionForInstance((StructuredInstance) example.getData());
+    }
+
+    @Override
+    public Prediction getPredictionForInstance(StructuredInstance instance) {
+
+        double[] predictionArray = this.getVotesForInstance(instance);
+
+		//System.out.println("y = "+Arrays.toString(predictionArray));
+        Prediction prediction = new MultiLabelPrediction(predictionArray.length);
+        for (int j = 0; j < predictionArray.length; j++) {
+            prediction.setVote(j, 1, predictionArray[j]);
+            //prediction.setVote(j, 0, 1. - predictionArray[j]);
+        }
+        return prediction;
+    }
+
+}
diff --git a/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java b/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
index 2594f61be..b4675887f 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
@@ -21,7 +21,7 @@
 
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 
@@ -41,7 +41,12 @@
  */
 public class MTOzaBag extends OzaBag implements MultiLabelLearner, MultiTargetRegressor {
 
-    public MTOzaBag() {
+    /**
+	 * 
+	 */
+	private static final long serialVersionUID = 1L;
+
+	public MTOzaBag() {
     	super();
     	this.baseLearnerOption = new ClassOption("baseLearner", 'l',
                 "Classifier to train.", MultiLabelLearner.class, "multilabel.trees.ISOUPTree");
@@ -51,23 +56,9 @@ public MTOzaBag() {
     public void resetLearningImpl() {
         this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
         MultiLabelLearner baseLearner = (MultiLabelLearner) getPreparedClassOption(this.baseLearnerOption);
-        baseLearner.resetLearning();
+        baseLearner.setModelContext(this.modelContext);
         for (int i = 0; i < this.ensemble.length; i++) {
             this.ensemble[i] = baseLearner.copy();
-        }
-    }
-
-    @Override
-    public void setModelContext(InstancesHeader raw_header) {
-
-        //set the multilabel model context
-        this.modelContext = raw_header;
-
-        // reset ensemble
-        this.resetLearningImpl();
-
-        for (int i = 0; i < this.ensemble.length; i++) {
-            this.ensemble[i].setModelContext(raw_header);
             this.ensemble[i].resetLearning();
         }
     }
@@ -77,14 +68,15 @@ public boolean isRandomizable() {
         return true;
     }
 
-	public Prediction getPredictionForInstance(MultiLabelInstance inst) {
-		DoubleVector[][] predictions = new DoubleVector[this.ensemble.length][getModelContext().numOutputAttributes()];
+	public Prediction getPredictionForInstance(StructuredInstance inst) {
+		int numTargets = getModelContext().numOutputAttributes();
+		DoubleVector[][] predictions = new DoubleVector[this.ensemble.length][numTargets];
 		for (int i = 0; i < this.ensemble.length; i++) {
 			Prediction basePrediction = this.ensemble[i].getPredictionForInstance(inst);
 			predictions[i] = ((MultiLabelPrediction) basePrediction).getPrediction();
 		}
-		DoubleVector[] prediction = new DoubleVector[getModelContext().numOutputAttributes()];
-		for (int j = 0; j < getModelContext().numOutputAttributes(); j++) {
+		DoubleVector[] prediction = new DoubleVector[numTargets];
+		for (int j = 0; j < numTargets; j++) {
 			prediction[j] = new DoubleVector();
 			for (int i = 0; i < this.ensemble.length; i++) {
 				prediction[j].addValues(predictions[i][j]);
@@ -94,7 +86,7 @@ public Prediction getPredictionForInstance(MultiLabelInstance inst) {
 		return new MultiLabelPrediction(prediction);
 	}
 	
-	public Prediction getPredictionForInstanceUsingN(MultiLabelInstance inst, int n) {
+	public Prediction getPredictionForInstanceUsingN(StructuredInstance inst, int n) {
 		int actual = Math.max(1, Math.min(n, this.ensemble.length));
 		DoubleVector[][] predictions = new DoubleVector[actual][getModelContext().numOutputAttributes()];
 		for (int i = 0; i < actual; i++) {
@@ -113,13 +105,13 @@ public Prediction getPredictionForInstanceUsingN(MultiLabelInstance inst, int n)
 	}
 
     @Override
-    public void trainOnInstanceImpl(MultiLabelInstance instance) {
+    public void trainOnInstanceImpl(StructuredInstance instance) {
         trainOnInstanceImpl((Instance) instance);
     }
     
     @Override
 	public Prediction getPredictionForInstance(Example<Instance> example) {
-		return getPredictionForInstance((MultiLabelInstance)example.getData());
+		return getPredictionForInstance((StructuredInstance)example.getData());
 	}
     
 }
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java
index a0ce07563..da8fdadd3 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java
@@ -1,12 +1,31 @@
 package moa.classifiers.multilabel.trees;
 
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Stack;
+
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
+import moa.classifiers.core.AttributeSplitSuggestion;
+import moa.classifiers.multilabel.core.attributeclassobservers.AttributeStatisticsObserver;
+import moa.classifiers.multilabel.core.splitcriteria.ICVarianceReduction;
+import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.classifiers.multilabel.core.splitcriteria.WeightedICVarianceReduction;
+import moa.classifiers.multilabel.trees.ISOUPTree.LeafNode;
+import moa.classifiers.multilabel.trees.ISOUPTree.MultitargetPerceptron;
+import moa.classifiers.multilabel.trees.ISOUPTree.Node;
+import moa.classifiers.multilabel.trees.ISOUPTree.SplitNode;
+import moa.classifiers.rules.core.AttributeExpansionSuggestion;
+import moa.classifiers.trees.FIMTDD.InnerNode;
+import moa.classifiers.trees.ORTO.OptionNode;
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
+import moa.core.StringUtils;
 
 public class ISOUPOptionTree extends ISOUPTree {
 
@@ -15,7 +34,7 @@ public class ISOUPOptionTree extends ISOUPTree {
 	private int optionNodeCount = 0;
 
 	private int numTrees = 1;
-	
+
 	//region ================ OPTIONS ================
 
 	public IntOption maxTreesOption = new IntOption(
@@ -38,7 +57,7 @@ public class ISOUPOptionTree extends ISOUPTree {
 
 	public MultiChoiceOption optionNodeAggregationOption = new MultiChoiceOption(
 			"optionNodeAggregation",
-			'o',
+			'p',
 			"The aggregation method used to combine predictions in option nodes.", 
 			new String[]{"average", "bestTree"}, new String[]{"Average", "Best tree"}, 0);
 
@@ -51,16 +70,16 @@ public class ISOUPOptionTree extends ISOUPTree {
 	//endregion ================ OPTIONS ================
 
 	//region ================ CLASSES ================
-	
+
 	public static class OptionNode extends InnerNode {
 		/**
 		 * 
 		 */
 		private static final long serialVersionUID = 1L;
-		
+
 		protected AutoExpandVector<DoubleVector> optionFFSSL;
 		protected AutoExpandVector<DoubleVector> optionFFSeen;
-		
+
 		public OptionNode(ISOUPTree tree) {
 			super(tree);
 		}
@@ -77,7 +96,7 @@ public void resetFF() {
 				}
 			}
 		}
-		
+
 		public int getNumSubtrees() {
 			int num = 0;
 			for (Node child : children) {
@@ -85,15 +104,15 @@ public int getNumSubtrees() {
 			}
 			return num;
 		}
-		
-		public double[] getPrediction(MultiLabelInstance inst) {
+
+		public double[] getPrediction(StructuredInstance inst) {
 			double[][] predictions = new double[numChildren()][tree.getModelContext().numOutputAttributes()];
 			for (int i = 0; i < numChildren(); i++) {
 				predictions[i] = getChild(i).getPrediction(inst);
 			}
 			return aggregate(predictions);
 		}
-		
+
 		private double[] aggregate(double[][] predictions) {
 			if (((ISOUPOptionTree) tree).optionNodeAggregationOption.getChosenIndex() == 0) { // Average
 				double[] sums = new double[tree.getModelContext().numOutputAttributes()];
@@ -111,7 +130,7 @@ private double[] aggregate(double[][] predictions) {
 				return new double[] {};
 			}
 		}
-		
+
 		public int directionForBestTree() {
 			int d = 0;
 			double min = Double.MAX_VALUE;
@@ -128,22 +147,34 @@ public int directionForBestTree() {
 			}
 			return d;
 		}
-		
+
 		public double getFFRatio(int childIndex, int targetIndex) {
 			return optionFFSSL.get(childIndex).getValue(targetIndex) / optionFFSeen.get(childIndex).getValue(targetIndex); 
 		}
-		
+
 		protected boolean skipInLevelCount() {
 			return true;
 		}
+
+		public void describeSubtree(StringBuilder out, int indent) {
+			for (int branch = 0; branch < children.size(); branch++) {
+				Node child = getChild(branch);
+				if (child != null) {
+					StringUtils.appendIndented(out, indent, "option");
+					out.append(branch);
+					StringUtils.appendNewline(out);
+					child.describeSubtree(out, indent + 2);
+				}
+			}			
+		}
 	}
-	
+
 	//endregion ================ CLASSES ================
-	
+
 	//region ================ METHODS ================
-	
+
 	public String getPurposeString() {
-		return "Implementation of the ORTO tree as described by Ikonomovska et al.";
+		return "Implementation of the iSOUPOptionTree";
 	}
 
 	public void resetLearningImpl() {
@@ -151,7 +182,7 @@ public void resetLearningImpl() {
 		this.optionNodeCount = 0;
 	}
 
-	
+
 	protected Measurement[] getModelMeasurementsImpl() {
 		return new Measurement[]{ 
 				new Measurement("number of subtrees", this.numTrees),
@@ -159,9 +190,18 @@ protected Measurement[] getModelMeasurementsImpl() {
 				//new Measurement("tree size (leaves)", this.leafNodeCount),
 				new Measurement("number of option nodes", this.optionNodeCount),};
 	}
-	
+
+	// region --- Object instantiation methods
+
+	protected OptionNode newOptionNode() {
+		maxID++;
+		return new OptionNode(this);
+	}
+
+	// endregion --- Object instantiation methods
+
 	@Override
-	public void processInstance(MultiLabelInstance inst, Node node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
+	public void processInstance(StructuredInstance inst, Node node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
 		if (node instanceof OptionNode) {
 			processInstanceOptionNode(inst, (OptionNode) node, prediction, normalError, growthAllowed, inAlternate);
 		} else {
@@ -225,7 +265,7 @@ public void processInstance(MultiLabelInstance inst, Node node, double[] predict
 //							break;
 //						}
 //					}
-				
+
 //					if (iNode.changeDetection && !inAlternate) {
 //						if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
 //							iNode.initializeAlternateTree();
@@ -240,18 +280,18 @@ public void processInstance(MultiLabelInstance inst, Node node, double[] predict
 				}
 			}
 		}
-		
+
 	}
-	
-	public void processInstanceOptionNode(MultiLabelInstance inst, OptionNode node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
-//		if (node.changeDetection) {
-//			double error = Math.abs(prediction - inst.classValue());
-//			node.sumOfAbsErrors += error;
-//			
-//			if (((InnerNode) node).PageHinckleyTest(error - node.sumOfAbsErrors / node.examplesSeen + PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
-//				node.initializeAlternateTree();
-//			}
-//		}
+
+	public void processInstanceOptionNode(StructuredInstance inst, OptionNode node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
+		//		if (node.changeDetection) {
+		//			double error = Math.abs(prediction - inst.classValue());
+		//			node.sumOfAbsErrors += error;
+		//			
+		//			if (((InnerNode) node).PageHinckleyTest(error - node.sumOfAbsErrors / node.examplesSeen + PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+		//				node.initializeAlternateTree();
+		//			}
+		//		}
 
 		for (Node child : node.children) {
 			int i = node.getChildIndex(child);
@@ -266,7 +306,220 @@ public void processInstanceOptionNode(MultiLabelInstance inst, OptionNode node,
 			processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed && node.alternateTree == null, inAlternate);
 		}
 	}
-	
+
 	//endregion ================ METHODS ================
 
+	protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex) {
+		//System.out.println("Evaluating splits");
+		//System.out.println(examplesSeen);
+		// Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
+		MultiLabelSplitCriterion splitCriterion = new WeightedICVarianceReduction(targetWeights);
+
+		// Using this criterion, find the best split per attribute and rank the results
+		AttributeExpansionSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion); // TODO update with split criterion option
+		List<AttributeExpansionSuggestion> acceptedSplits = new LinkedList<AttributeExpansionSuggestion>();
+		Arrays.sort(bestSplitSuggestions);
+
+		// Declare a variable to determine the number of splits to be performed
+		int numSplits = 0;
+
+		// If only one split was returned, use it
+		if (bestSplitSuggestions.length == 1) {
+			numSplits = 1;
+			acceptedSplits.add(bestSplitSuggestions[0]);
+		} else if (bestSplitSuggestions.length > 1) { // Otherwise, consider which of the splits proposed may be worth trying
+
+			// Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
+			// to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
+			double hoeffdingBound = computeHoeffdingBound(1, splitConfidenceOption.getValue(), node.examplesSeen);
+			// Determine the top two ranked splitting suggestions
+			AttributeExpansionSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+			AttributeExpansionSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
+
+			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
+			// as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
+			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
+			// splitting should occur.
+			// Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
+			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
+			// competing attributes are equally good, and the split will be made on the one with the higher SDR value.
+			//System.out.print(hoeffdingBound);
+			//System.out.print(" ");
+			///System.out.println(secondBestSuggestion.merit / bestSuggestion.merit);
+			if (secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) {
+				numSplits = 1;
+				acceptedSplits.add(bestSuggestion);
+			} else if (numTrees < maxTreesOption.getValue() && node.getLevel() <= maxOptionLevelOption.getValue()) {
+				for (int i = 0; i < bestSplitSuggestions.length; i++) {
+					AttributeExpansionSuggestion suggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1 - i];
+					if (suggestion.merit / bestSuggestion.merit >= 1 - hoeffdingBound) {
+						numSplits++;
+						acceptedSplits.add(suggestion);
+					} else {
+						break;
+					}
+				}
+
+			} else if (hoeffdingBound < this.tieThresholdOption.getValue()) {
+				numSplits = 1;
+				acceptedSplits.add(bestSuggestion);
+			}
+			else {
+				// If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
+				// TODO pruning is currently disabled
+				for (int i = 0; i < node.attributeObservers.size(); i++) {
+					AttributeStatisticsObserver obs = node.attributeObservers.get(i);
+					if (obs != null) {
+						if (getModelContext().attribute(i).isNumeric());
+						//TODO obs.removeBadSplits(null, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound, getModelContext().numOutputAttributes());
+						if (getModelContext().attribute(i).isNominal());
+						// TODO nominal class observers
+					}
+				}
+			}
+		}
+
+		// If the splitting criterion were met, split the current node using the chosen attribute test, and
+		// make two new branches leading to (empty) leaves
+		if (numSplits > 0) {
+			double optionFactor = numSplits * Math.pow(optionDecayFactorOption.getValue(), (double) node.getLevel());
+			log(Integer.toString(node.ID) + ',' + Integer.toString((int) this.examplesSeen));
+
+			if (numSplits == 1 || optionFactor < 2.0 || maxTreesOption.getValue() - numTrees <= 1) {
+				AttributeExpansionSuggestion splitDecision = acceptedSplits.get(0);
+				SplitNode newSplit = newSplitNode(splitDecision.getPredicate());
+				newSplit.ID = node.ID;
+
+				for (int i = 0; i < 2 /* TODO Hardcoded for Predicate class */; i++) {
+					LeafNode newChild = newLeafNode();
+					newChild.setParent(newSplit);
+					newSplit.setChild(i, newChild);
+				}
+				//leafNodeCount--;
+				//innerNodeCount++;
+				//leafNodeCount += splitDecision.numSplits();
+				if (parent == null && node.originalNode == null) {
+					treeRoot = newSplit;
+				} else if (parent == null && node.originalNode != null) {
+					node.originalNode.alternateTree = newSplit;
+				} else {
+					parent.setChild(parentIndex, newSplit);
+					newSplit.setParent(parent);
+				}
+			} else {
+
+				OptionNode optionNode = newOptionNode();
+				optionNode.ID = node.ID;
+
+				//leafNodeCount--;
+				int j = 0;
+
+				for (AttributeExpansionSuggestion splitDecision : acceptedSplits) {
+					if (j > optionFactor || maxTreesOption.getValue() - numTrees <= 0) {
+						break;
+					}
+					SplitNode newSplit = newSplitNode(splitDecision.getPredicate());
+					for (int i = 0; i < 2 /* TODO Hardcoded for Predicate class */; i++) {
+						LeafNode newChild = newLeafNode();
+						newChild.setParent(newSplit);
+						newSplit.setChild(i, newChild);
+					}
+
+					//leafNodeCount += splitDecision.numSplits();
+					//innerNodeCount++;
+					numTrees++;
+
+					newSplit.setParent(optionNode);
+					optionNode.setChild(j, newSplit);
+					j++;
+				}
+
+				//innerNodeCount++;
+				optionNodeCount++;
+
+				if (parent == null) {
+					treeRoot = optionNode;
+				} else {
+					parent.setChild(parentIndex, optionNode);
+					optionNode.setParent(parent);
+				}
+
+				optionNode.resetFF();
+			}
+		}
+	}
+
+	// region --- Option tree methods
+	protected Node findWorstOption() {
+		Stack<Node> stack = new Stack<Node>();
+		stack.add(treeRoot);
+
+		double ratio = Double.MIN_VALUE;
+		Node out = null;
+
+		while (!stack.empty()) {
+			Node node = stack.pop();
+			if (node.getParent() instanceof OptionNode) {
+				OptionNode myParent = (OptionNode) node.getParent();
+				int nodeIndex = myParent.getChildIndex(node);
+				DoubleVector nodeRatios = new DoubleVector();
+				for (int i = 0; i < getModelContext().numOutputAttributes(); i++) {
+					nodeRatios.setValue(i, myParent.getFFRatio(nodeIndex, i));
+				}
+				double nodeRatio = nodeRatios.sumOfValues() / nodeRatios.numValues(); 
+
+				if (nodeRatio > ratio) {
+					ratio = nodeRatio;
+					out = node;
+				}
+			}
+			if (node instanceof InnerNode) {
+				for (Node child : ((InnerNode) node).children) {
+					stack.add(child);
+				}
+			}
+		}
+
+		return out;
+	}
+
+	protected void removeExcessTrees() {
+		while (numTrees > maxTreesOption.getValue()) {
+			Node option = findWorstOption();
+			OptionNode parent = (OptionNode) option.parent;
+			int index = parent.getChildIndex(option);
+
+			if (parent.children.size() == 2) {
+				parent.children.remove(index);
+				for (Node chld : parent.children) {
+					chld.parent = parent.parent;
+					parent.parent.setChild(parent.parent.getChildIndex(parent), chld);
+				}
+			} else {
+				AutoExpandVector<Node> children = new AutoExpandVector<Node>();
+				AutoExpandVector<DoubleVector> optionFFSSL = new AutoExpandVector<DoubleVector>();
+				AutoExpandVector<DoubleVector> optionFFSeen = new AutoExpandVector<DoubleVector>();
+
+				int seen = 0;
+
+				for (int i = 0; i < parent.children.size() - 1; i++) {
+					if (parent.getChild(i) != option) {
+						children.add(parent.getChild(i));
+						optionFFSSL.set(i, parent.optionFFSSL.get(i + seen));
+						optionFFSeen.set(i, parent.optionFFSeen.get(i + seen));
+					} else {
+						seen = 1;
+					}
+				}
+
+				parent.children = children;
+				parent.optionFFSSL = optionFFSSL;
+				parent.optionFFSeen = optionFFSeen;
+
+				assert parent.children.size() == parent.optionFFSSL.size();
+			}
+			numTrees--;
+		}
+	}
+
 }
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
index 4ce0c89b6..db8bf9843 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
@@ -29,27 +29,31 @@
 import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Vector;
 
+import com.github.javacliparser.FileOption;
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 import moa.AbstractMOAObject;
 import moa.classifiers.AbstractMultiLabelLearner;
 import moa.classifiers.MultiTargetRegressor;
+import moa.classifiers.multilabel.core.attributeclassobservers.AttributeStatisticsObserver;
+import moa.classifiers.multilabel.core.attributeclassobservers.MultiLabelBSTree;
+import moa.classifiers.multilabel.core.attributeclassobservers.MultiLabelNominalAttributeObserver;
+import moa.classifiers.multilabel.core.attributeclassobservers.NominalStatisticsObserver;
+import moa.classifiers.multilabel.core.attributeclassobservers.NumericStatisticsObserver;
 import moa.classifiers.multilabel.core.splitcriteria.ICVarianceReduction;
+import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.classifiers.multilabel.core.splitcriteria.WeightedICVarianceReduction;
+import moa.classifiers.rules.core.AttributeExpansionSuggestion;
 import moa.classifiers.rules.core.Predicate;
-import moa.classifiers.rules.multilabel.attributeclassobservers.AttributeStatisticsObserver;
-import moa.classifiers.rules.multilabel.attributeclassobservers.MultiLabelBSTree;
-import moa.classifiers.rules.multilabel.attributeclassobservers.MultiLabelNominalAttributeObserver;
-import moa.classifiers.rules.multilabel.attributeclassobservers.NominalStatisticsObserver;
-import moa.classifiers.rules.multilabel.attributeclassobservers.NumericStatisticsObserver;
-import moa.classifiers.rules.multilabel.core.AttributeExpansionSuggestion;
-import moa.classifiers.rules.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
@@ -57,7 +61,7 @@
 import moa.core.StringUtils;
 
 /**
- * iSOUPTrees class for structured output prediction.
+ * iSOUPTree class for structured output prediction.
  *
  * @author Aljaž Osojnik (aljaz.osojnik@ijs.si)
  * @version $Revision: 1 $
@@ -68,7 +72,7 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 
 	public Node treeRoot;
 
-	private double examplesSeen = 0.0;
+	protected double examplesSeen = 0.0;
 	private DoubleVector sumOfValues = new DoubleVector();
 	private DoubleVector sumOfSquares = new DoubleVector();
 
@@ -76,6 +80,8 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 	private DoubleVector sumOfAttrSquares = new DoubleVector();
 
 	public int maxID = 0;
+	
+	public DoubleVector targetWeights;
 
 	//region ================ OPTIONS ================
 
@@ -154,6 +160,13 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 			'n',
 			"Don't normalize.");
 
+	public FlagOption randomForestBaseModelOption = new FlagOption(
+			"randomForestBaseModel",
+			'z',
+			"Use the learner as a base model in a random forest.");
+	
+	public FileOption weightFile = new FileOption("targetWeightFile", 'w', "File with the weights of the targets.", null, null, false);
+
 	//endregion ================ OPTIONS ================
 
 	//region ================ CLASSES ================
@@ -169,7 +182,7 @@ public abstract static class Node extends AbstractMOAObject {
 		protected ISOUPTree tree;
 
 		// The parent of this particular node
-		protected SplitNode parent;
+		protected InnerNode parent;
 
 		protected Node alternateTree;
 		protected Node originalNode;
@@ -191,6 +204,7 @@ public abstract static class Node extends AbstractMOAObject {
 
 		public Node(ISOUPTree tree) {
 			this.tree = tree;
+			this.ID = tree.maxID;
 		}
 
 		public void copyStatistics(Node node) {
@@ -206,7 +220,7 @@ public int calcByteSize() {
 		/**
 		 * Set the parent node
 		 */
-		public void setParent(SplitNode parent) {
+		public void setParent(InnerNode parent) {
 			this.parent = parent;    
 		}
 
@@ -227,10 +241,10 @@ public void restartChangeDetection() {
 
 		public void getDescription(StringBuilder sb, int i) {}
 
-		public double[] getPrediction(MultiLabelInstance inst) {
+		public double[] getPrediction(StructuredInstance inst) {
 			return null;
 		}
-
+		
 		public void describeSubtree(StringBuilder out, int indent) {
 			StringUtils.appendIndented(out, indent, "Leaf");
 		}
@@ -278,6 +292,8 @@ public static class LeafNode extends Node {
 
 		public DoubleVector errorP = new DoubleVector();
 		public DoubleVector errorM = new DoubleVector();
+		
+		public List<Integer> inputIndexes = null;
 
 		protected double examplesSeenAtLastSplitEvaluation = 0;
 
@@ -289,18 +305,40 @@ public LeafNode(ISOUPTree tree) {
 			if (tree.buildingModelTree()) {
 				learningModel = tree.newLeafModel();
 			}
+			initializeInputIndexes();
 			examplesSeen = 0;
 			sumOfValues = new DoubleVector();
 			sumOfSquares = new DoubleVector();
 		}
 
+		public void initializeInputIndexes() {
+			List<Integer> indexes = new Vector<Integer>();
+			int numAttrs = tree.getModelContext().numInputAttributes();
+			for (int i = 0; i < numAttrs; i++) {
+				indexes.add(i, i);
+			}
+			if (tree.buildingRandomForestTree()) {
+				// Select the first sqrt(n) attribute indexes
+				for (int i = 0; i < Math.ceil(Math.sqrt(numAttrs)); i++) {
+					int swap = i + tree.classifierRandom.nextInt(numAttrs - i);
+					int temp = indexes.get(i);
+					indexes.set(i, indexes.get(swap));
+					indexes.set(swap, temp);
+				}
+				inputIndexes = indexes.subList(0, (int) Math.ceil(Math.sqrt(numAttrs)));
+			} else {
+				inputIndexes = indexes;
+			}
+		}
+		
 		/**
 		 * Method to learn from an instance that passes the new instance to the perceptron learner,
 		 * and also prevents the class value from being truncated to an int when it is passed to the
 		 * attribute observer
 		 */
-		public void learnFromInstance(MultiLabelInstance inst, double[] prediction, boolean growthAllowed) {
+		public void learnFromInstance(StructuredInstance inst, double[] prediction, boolean growthAllowed) {
 			// Update the statistics for this node
+
 			double[] predictionP = tree.buildingModelTree() ? getPredictionModel(inst) : null;
 			double[] predictionM = getPredictionTargetMean(inst);
 
@@ -319,9 +357,10 @@ public void learnFromInstance(MultiLabelInstance inst, double[] prediction, bool
 					errorM.setValue(i, errorM.getValue(i) * 0.95 + Math.abs(predictionM[i] - inst.valueOutputAttribute(i)));
 				}
 			}
+
 			if (tree.buildingModelTree()) learningModel.updatePerceptron(inst);
 
-			for (int i = 0; i < inst.numInputAttributes(); i++) {
+			for (int i : inputIndexes) {
 				AttributeStatisticsObserver obs = attributeObservers.get(i);
 				if (obs == null) {
 					// At this stage all nominal attributes are ignored
@@ -360,7 +399,7 @@ public AttributeExpansionSuggestion[] getBestSplitSuggestions(MultiLabelSplitCri
 
 			List<AttributeExpansionSuggestion> bestSuggestions = new LinkedList<AttributeExpansionSuggestion>();
 
-			for (int i = 0; i < attributeObservers.size(); i++) {
+			for (int i : inputIndexes) {
 				AttributeStatisticsObserver obs = attributeObservers.get(i);
 				if (obs != null) {
 					DoubleVector[] preSplitStatistics = new DoubleVector[tree.getModelContext().numOutputAttributes()];
@@ -385,11 +424,11 @@ public AttributeExpansionSuggestion[] getBestSplitSuggestions(MultiLabelSplitCri
 		/**
 		 * Retrieve the class votes using the perceptron learner
 		 */
-		public double[] getPredictionModel(MultiLabelInstance inst) {
+		public double[] getPredictionModel(StructuredInstance inst) {
 			return learningModel.prediction(inst);
 		}
 
-		public double[] getPredictionTargetMean(MultiLabelInstance inst) {
+		public double[] getPredictionTargetMean(StructuredInstance inst) {
 			double[] pred = new double[inst.numOutputAttributes()];
 			for (int i = 0; i < inst.numOutputAttributes(); i++) {
 				if (examplesSeen > 0) {
@@ -401,7 +440,7 @@ public double[] getPredictionTargetMean(MultiLabelInstance inst) {
 			return pred;
 		}
 
-		public double[] getPrediction(MultiLabelInstance inst) {
+		public double[] getPrediction(StructuredInstance inst) {
 			if (tree.buildingModelTree()) {
 				double[] predictionP = getPredictionModel(inst);
 				double[] predictionM = getPredictionTargetMean(inst);
@@ -436,11 +475,14 @@ public void checkForSplit() {
 		}
 
 		public void describeSubtree(StringBuilder out, int indent) {
-			StringUtils.appendIndented(out, indent, "Leaf ");
+			StringUtils.appendIndented(out, indent, "Leaf");
+			StringUtils.appendNewline(out);
+			
 			if (tree.buildingModelTree()) {
-				learningModel.getModelDescription(out, 0);
+				learningModel.getModelDescription(out, indent + 2);
 			} else {
 				//out.append(tree.getClassNameString() + " = " + String.format("%.4f", (sumOfValues / examplesSeen)));
+				out.append("Leaf node");
 				StringUtils.appendNewline(out);
 			}
 		}
@@ -455,7 +497,7 @@ public static abstract class InnerNode extends Node {
 
 		// Sum of absolute errors
 		protected DoubleVector sumOfAbsErrors = new DoubleVector(); // Needed for PH tracking of mean error
-		
+
 		protected DoubleVector PHsums = new DoubleVector();
 		protected DoubleVector PHmins = new DoubleVector();
 
@@ -565,7 +607,7 @@ public SplitNode(Predicate predicate, ISOUPTree tree) {
 			ID = tree.maxID;
 		}
 
-		public int instanceChildIndex(MultiLabelInstance inst) {
+		public int instanceChildIndex(StructuredInstance inst) {
 			return (predicate.evaluate(inst)) ? 0 : 1;
 		}
 
@@ -575,7 +617,7 @@ public void describeSubtree(StringBuilder out, int indent) {
 				if (child != null) {
 					if (branch == 0) {
 						StringUtils.appendIndented(out, indent, "if ");
-						this.predicate.getDescription(out, 0);
+						this.predicate.getDescription(out, 0, tree.getModelContext());
 					} else {
 						StringUtils.appendIndented(out, indent, "else");
 					}
@@ -586,7 +628,7 @@ public void describeSubtree(StringBuilder out, int indent) {
 			}
 		}
 
-		public double[] getPrediction(MultiLabelInstance inst) {
+		public double[] getPrediction(StructuredInstance inst) {
 			return children.get(predicate.evaluate(inst) ? 0 : 1).getPrediction(inst);
 		}
 	}
@@ -633,10 +675,10 @@ public void initializeWeights() {
 		/**
 		 * Update the model using the provided instance
 		 */
-		public void updatePerceptron(MultiLabelInstance inst) {
+		public void updatePerceptron(StructuredInstance inst) {
 			// Update attribute statistics
 			instancesSeen += inst.weight();
-			
+
 			// Update weights
 			double learningRatio = 0.0;
 			if (tree.learningRatioConstOption.isSet()) {
@@ -651,7 +693,7 @@ public void updatePerceptron(MultiLabelInstance inst) {
 			}
 		}
 
-		public void updateWeights(MultiLabelInstance inst, double learningRatio) {
+		public void updateWeights(StructuredInstance inst, double learningRatio) {
 			if (instancesSeen > 1.0) {
 				// Compute the normalized instance and the delta
 				double[] normalizedInput = tree.normalizedInputVector(inst); 
@@ -692,7 +734,7 @@ public double[] prediction(double[] instanceValues) {
 			return out;
 		}
 
-		private double[] prediction(MultiLabelInstance inst) {
+		private double[] prediction(StructuredInstance inst) {
 			double[] normalizedInput = tree.normalizedInputVector(inst);
 			double[] normalizedPrediction = prediction(normalizedInput);
 			return denormalizePrediction(normalizedPrediction);
@@ -714,18 +756,18 @@ private double[] denormalizePrediction(double[] normalizedPrediction) {
 		}
 
 		public void getModelDescription(StringBuilder out, int indent) {
-			for (int i = 0; i < tree.getModelContext().numOutputAttributes(); i++) {
-				StringUtils.appendIndented(out, indent, " [" + tree.getModelContext().outputAttribute(i).name() + "]");
-				if (getModelContext() != null) {
-					for (int j = 0; j < getModelContext().numOutputAttributes(); j++) {
-						if (getModelContext().attribute(j).isNumeric()) {
-							out.append((j == 0 || weights[i][j] < 0) ? " " : " + ");
-							out.append(String.format("%.4f", weights[i][j]));
+			if (getModelContext() != null) {
+				for (int i = 0; i < tree.getModelContext().numOutputAttributes(); i++) {
+					StringUtils.appendIndented(out, indent, " [" + tree.getModelContext().outputAttribute(i).name() + "] =");
+					for (int j = 0; j < getModelContext().numInputAttributes(); j++) {
+						if (getModelContext().inputAttribute(j).isNumeric()) {
+							out.append((j == 0 && weights[i][j] >= 0) ? " " : (weights[i][j] < 0) ? " - " : " + ");
+							out.append(String.format("%.4f", Math.abs(weights[i][j])));
 							out.append(" * ");
-							out.append(getAttributeNameString(j));
+							out.append(getModelContext().inputAttribute(j).name());
 						}
 					}
-					out.append(" + " + weights[i][getModelContext().numOutputAttributes()]);
+					out.append((weights[i][getModelContext().numInputAttributes()] < 0 ? " - " : " + ") + String.format("%.4f", Math.abs(weights[i][getModelContext().numInputAttributes()])));
 				}
 				StringUtils.appendNewline(out);
 			}
@@ -737,7 +779,9 @@ public void getModelDescription(StringBuilder out, int indent) {
 	//region ================ METHODS ================
 
 	// Regressor methods
-	public ISOUPTree() {}
+	public ISOUPTree() {
+		super();
+	}
 
 	public String getPurposeString() {
 		return "Implementation of the iSOUP-Tree algorithm as described by Osojnik et al.";
@@ -751,8 +795,19 @@ public void resetLearningImpl() {
 
 		sumOfAttrValues = new DoubleVector();
 		sumOfAttrSquares = new DoubleVector();
+		loadWeights();
 	}
 
+	public void loadWeights() {
+		targetWeights = new DoubleVector();
+		try {
+			List<String> lines = Files.readAllLines(Paths.get(weightFile.getValue()), Charset.defaultCharset());
+			for (int i = 0 ; i < lines.size(); i++) targetWeights.setValue(i, Double.valueOf(lines.get(i)));
+		} catch (Exception e) {
+			for (int i = 0; i < getModelContext().numOutputAttributes(); i++) targetWeights.setValue(i, 1.0);
+		}
+	}
+	
 	public boolean isRandomizable() {
 		return true;
 	}
@@ -760,7 +815,7 @@ public boolean isRandomizable() {
 	public void getModelDescription(StringBuilder out, int indent) {
 		if (treeRoot != null) treeRoot.describeSubtree(out, indent);
 	}
-
+	
 	protected Measurement[] getModelMeasurementsImpl() {
 		return new Measurement[]{ 
 				//new Measurement("tree size (nodes)", this.leafNodeCount + this.splitNodeCount),
@@ -776,7 +831,7 @@ public int calcByteSize() {
 		return size;
 	}
 
-	public Prediction getPredictionForInstance(MultiLabelInstance inst) {
+	public Prediction getPredictionForInstance(StructuredInstance inst) {
 		checkRoot();
 		double[] predictionVector = treeRoot.getPrediction(inst);
 		MultiLabelPrediction prediction = new MultiLabelPrediction(getModelContext().numOutputAttributes());
@@ -786,7 +841,7 @@ public Prediction getPredictionForInstance(MultiLabelInstance inst) {
 		return prediction;
 	}
 
-	public double[] normalizedInputVector(MultiLabelInstance inst) {
+	public double[] normalizedInputVector(StructuredInstance inst) {
 		// Normalize Instance
 		double[] normalizedInput = new double[inst.numInputAttributes()+1];
 		if (normalize()) {
@@ -816,7 +871,7 @@ public double[] normalizedInputVector(MultiLabelInstance inst) {
 		return normalizedInput;
 	}
 
-	public double[] normalizedTargetVector(MultiLabelInstance inst) {
+	public double[] normalizedTargetVector(StructuredInstance inst) {
 		double[] out = new double[getModelContext().numOutputAttributes()];
 		if (normalize()) {
 			for (int i = 0; i < inst.numOutputAttributes(); i++) {
@@ -853,7 +908,7 @@ public double[] normalizeTargetVector(double[] pred) {
 	}
 
 
-	public double normalizeTargetValue(MultiLabelInstance inst, int i) {
+	public double normalizeTargetValue(StructuredInstance inst, int i) {
 		if (normalize()) {
 			if (examplesSeen > 1) {
 				double value = inst.valueOutputAttribute(i);
@@ -882,7 +937,7 @@ public double normalizeTargetValue(double value, int i) {
 		} else return value;
 	}
 
-	public double[] getNormalizedError(MultiLabelInstance inst, double[] prediction) {
+	public double[] getNormalizedError(StructuredInstance inst, double[] prediction) {
 		double[] normalPrediction = normalizeTargetVector(prediction);
 		double[] normalValue = normalizedTargetVector(inst);
 		double[] out = new double[getModelContext().numOutputAttributes()];
@@ -896,9 +951,9 @@ public double[] getNormalizedError(MultiLabelInstance inst, double[] prediction)
 	/**
 	 * Method for updating (training) the model using a new instance
 	 */
-	public void trainOnInstanceImpl(MultiLabelInstance inst) {
-		if (inst.weight() > 0) {
-			checkRoot();
+	 public void trainOnInstanceImpl(StructuredInstance inst) {
+		 if (inst.weight() > 0) {
+			 checkRoot();
 
 			 double[] prediction = treeRoot.getPrediction(inst);
 			 double[] normalError = getNormalizedError(inst, prediction);
@@ -918,108 +973,108 @@ public void trainOnInstanceImpl(MultiLabelInstance inst) {
 		 }
 	 }
 
-	public void processInstance(MultiLabelInstance inst, Node node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
-		Node currentNode = node;
-		while (true) {
-			if (currentNode instanceof LeafNode) {
-				((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
-				break;
-			} else {
-				currentNode.examplesSeen += inst.weight();
-				//currentNode.sumOfAbsErrors.addValues(normalError);
-				//				SplitNode iNode = (SplitNode) currentNode;
-				//				if (!inAlternate && iNode.alternateTree != null) {
-				//					boolean altTree = true;
-				//					double lossO = Math.pow(inst.valueOutputAttribute() - prediction, 2);
-				//					double lossA = Math.pow(inst.valueOutputAttribute() - iNode.alternateTree.getPrediction(inst), 2);
-				//
-				//					iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
-				//					iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
-				//					iNode.lossExamplesSeen++;
-				//
-				//					double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
-				//					double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
-				//					iNode.lossSumQi += Qi;
-				//					iNode.lossNumQiTests += 1;
-				//					double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
-				//
-				//					if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
-				//						iNode.previousWeight = iNode.lossExamplesSeen;
-				//						if (Qi > 0) {
-				//							SplitNode parent = currentNode.getParent();
-				//
-				//							if (parent != null) {
-				//								Node replacementTree = iNode.alternateTree;
-				//								parent.setChild(parent.getChildIndex(currentNode), replacementTree);
-				//								if (growthAllowed) replacementTree.restartChangeDetection();
-				//							} else {
-				//								treeRoot = iNode.alternateTree;
-				//								treeRoot.restartChangeDetection();
-				//							}
-				//
-				//							currentNode = iNode.alternateTree;
-				//							altTree = false;
-				//						} else if (
-				//								(QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * this.gracePeriodOption.getValue()))
-				//								|| iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()
-				//								) {
-				//							iNode.alternateTree = null;
-				//							if (growthAllowed) iNode.restartChangeDetection();
-				//							altTree = false;
-				//						}
-				//					}
-				//
-				//					if (altTree) {
-				//						growthAllowed = false;
-				//						processInstance(inst, iNode.alternateTree, prediction, normalError, true, true);
-				//					}
-				//				}
-
-				//				if (iNode.changeDetection && !inAlternate) {
-				//					if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
-				//						iNode.initializeAlternateTree(this);
-				//					}
-				//				}
-				if (currentNode instanceof SplitNode) {
-					currentNode = ((SplitNode) currentNode).getChild(((SplitNode) currentNode).instanceChildIndex(inst));
-				} else { // if the replaced alternate tree is just a leaf node
-					((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
-					break;
-				}
-			}
-		}
-	}
+	 public void processInstance(StructuredInstance inst, Node node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
+		 Node currentNode = node;
+		 while (true) {
+			 if (currentNode instanceof LeafNode) {
+				 ((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
+				 break;
+			 } else {
+				 currentNode.examplesSeen += inst.weight();
+				 //currentNode.sumOfAbsErrors.addValues(normalError);
+				 //				SplitNode iNode = (SplitNode) currentNode;
+				 //				if (!inAlternate && iNode.alternateTree != null) {
+				 //					boolean altTree = true;
+				 //					double lossO = Math.pow(inst.valueOutputAttribute() - prediction, 2);
+				 //					double lossA = Math.pow(inst.valueOutputAttribute() - iNode.alternateTree.getPrediction(inst), 2);
+				 //
+				 //					iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
+				 //					iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
+				 //					iNode.lossExamplesSeen++;
+				 //
+				 //					double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
+				 //					double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+				 //					iNode.lossSumQi += Qi;
+				 //					iNode.lossNumQiTests += 1;
+				 //					double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+				 //
+				 //					if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
+				 //						iNode.previousWeight = iNode.lossExamplesSeen;
+				 //						if (Qi > 0) {
+				 //							SplitNode parent = currentNode.getParent();
+				 //
+				 //							if (parent != null) {
+				 //								Node replacementTree = iNode.alternateTree;
+				 //								parent.setChild(parent.getChildIndex(currentNode), replacementTree);
+				 //								if (growthAllowed) replacementTree.restartChangeDetection();
+				 //							} else {
+				 //								treeRoot = iNode.alternateTree;
+				 //								treeRoot.restartChangeDetection();
+				 //							}
+				 //
+				 //							currentNode = iNode.alternateTree;
+				 //							altTree = false;
+				 //						} else if (
+				 //								(QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * this.gracePeriodOption.getValue()))
+				 //								|| iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()
+				 //								) {
+				 //							iNode.alternateTree = null;
+				 //							if (growthAllowed) iNode.restartChangeDetection();
+				 //							altTree = false;
+				 //						}
+				 //					}
+				 //
+				 //					if (altTree) {
+				 //						growthAllowed = false;
+				 //						processInstance(inst, iNode.alternateTree, prediction, normalError, true, true);
+				 //					}
+				 //				}
+
+				 //				if (iNode.changeDetection && !inAlternate) {
+				 //					if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+				 //						iNode.initializeAlternateTree(this);
+				 //					}
+				 //				}
+				 if (currentNode instanceof SplitNode) {
+					 currentNode = ((SplitNode) currentNode).getChild(((SplitNode) currentNode).instanceChildIndex(inst));
+				 } else { // if the replaced alternate tree is just a leaf node
+					 ((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
+					 break;
+				 }
+			 }
+		 }
+	 }
 
-	//region --- Object instatiation methods
+	 //region --- Object instatiation methods
 
-	protected NumericStatisticsObserver newNumericClassObserver() {
-		return new MultiLabelBSTree();
-	}
+	 protected NumericStatisticsObserver newNumericClassObserver() {
+		 return new MultiLabelBSTree();
+	 }
 
-	public NominalStatisticsObserver newNominalClassObserver() {
-		return new MultiLabelNominalAttributeObserver();
-	}
+	 public NominalStatisticsObserver newNominalClassObserver() {
+		 return new MultiLabelNominalAttributeObserver();
+	 }
 
-	//	protected SplitNode newSplitNode(InstanceConditionalTest splitTest) {
-	//		maxID++;
-	//		return new SplitNode(splitTest, this);
-	//	}
+	 //	protected SplitNode newSplitNode(InstanceConditionalTest splitTest) {
+	 //		maxID++;
+	 //		return new SplitNode(splitTest, this);
+	 //	}
 
-	protected SplitNode newSplitNode(Predicate predicate) {
-		maxID++;
-		return new SplitNode(predicate, this);
-	}
+	 protected SplitNode newSplitNode(Predicate predicate) {
+		 maxID++;
+		 return new SplitNode(predicate, this);
+	 }
 
-	protected LeafNode newLeafNode() {
-		maxID++;
-		return new LeafNode(this);
-	}
+	 protected LeafNode newLeafNode() {
+		 maxID++;
+		 return new LeafNode(this);
+	 }
 
 	 public MultitargetPerceptron newLeafModel() {
 		 return new MultitargetPerceptron(this);
 	 }
 
-	//endregion --- Object instatiation methods
+	 //endregion --- Object instatiation methods
 
 	 //region --- Processing methods
 	 protected void checkRoot() {
@@ -1028,42 +1083,44 @@ protected void checkRoot() {
 		 }
 	 }
 
-	public static double computeHoeffdingBound(double range, double confidence, double n) {
-		return Math.sqrt(( (range * range) * Math.log(1 / confidence)) / (2.0 * n));
-	}
+	 public static double computeHoeffdingBound(double range, double confidence, double n) {
+		 return Math.sqrt(((range * range) * Math.log(1 / confidence)) / (2.0 * n));
+	 }
 
-	public boolean buildingModelTree() {
-		return !regressionTreeOption.isSet();
-	}
+	 public boolean buildingModelTree() {
+		 return !regressionTreeOption.isSet();
+	 }
+	 
+	 public boolean buildingRandomForestTree() {
+		 return randomForestBaseModelOption.isSet();
+	 }
 
-	public boolean normalize() {
-		return !doNotNormalizeOption.isSet();
-	}
+	 public boolean normalize() {
+		 return !doNotNormalizeOption.isSet();
+	 }
 
-	protected void attemptToSplit(LeafNode node, SplitNode parent, int parentIndex) {
-		//System.out.println("Evaluating splits");
-		//System.out.println(examplesSeen);
-		// Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
-		MultiLabelSplitCriterion splitCriterion = new ICVarianceReduction();
+	 protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex) {
+		 // Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
+		 MultiLabelSplitCriterion splitCriterion = new WeightedICVarianceReduction(targetWeights);
 
-		// Using this criterion, find the best split per attribute and rank the results
-		AttributeExpansionSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion); // TODO update with split criterion option
-		Arrays.sort(bestSplitSuggestions);
+		 // Using this criterion, find the best split per attribute and rank the results
+		 AttributeExpansionSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion); // TODO update with split criterion option
+		 Arrays.sort(bestSplitSuggestions);
 
-		// Declare a variable to determine if any of the splits should be performed
-		boolean shouldSplit = false;
+		 // Declare a variable to determine if any of the splits should be performed
+		 boolean shouldSplit = false;
 
-		// If only one split was returned, use it
-		if (bestSplitSuggestions.length < 2) {
-			shouldSplit = bestSplitSuggestions.length > 0;
-		} else { // Otherwise, consider which of the splits proposed may be worth trying
+		 // If only one split was returned, use it
+		 if (bestSplitSuggestions.length < 2) {
+			 shouldSplit = bestSplitSuggestions.length > 0;
+		 } else { // Otherwise, consider which of the splits proposed may be worth trying
 
-			// Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
-			// to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
-			double hoeffdingBound = computeHoeffdingBound(1, splitConfidenceOption.getValue(), node.examplesSeen);
-			// Determine the top two ranked splitting suggestions
-			AttributeExpansionSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-			AttributeExpansionSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
+			 // Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
+			 // to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
+			 double hoeffdingBound = computeHoeffdingBound(1, splitConfidenceOption.getValue(), node.examplesSeen);
+			 // Determine the top two ranked splitting suggestions
+			 AttributeExpansionSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+			 AttributeExpansionSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
 
 			 // If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
 			 // as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
@@ -1099,6 +1156,7 @@ protected void attemptToSplit(LeafNode node, SplitNode parent, int parentIndex)
 			 AttributeExpansionSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
 
 			 SplitNode newSplit = newSplitNode(splitDecision.predicate);
+			 newSplit.ID = node.ID;
 			 newSplit.copyStatistics(node);
 			 newSplit.changeDetection = node.changeDetection;
 			 newSplit.ID = node.ID;
@@ -1124,23 +1182,21 @@ protected void attemptToSplit(LeafNode node, SplitNode parent, int parentIndex)
 		 }
 	 }
 
+	 public double computeSD(double squaredVal, double val, double size) {
+		 if (size > 1)
+			 return Math.sqrt((squaredVal - ((val * val) / size)) / size);
+		 else
+			 return 0.0;
+	 }
 
+	 public static double scalarProduct(DoubleVector u, DoubleVector v) {
+		 double ret = 0.0;
+		 for (int i = 0; i < Math.max(u.numValues(), v.numValues()); i++) {
+			 ret += u.getValue(i) * v.getValue(i);
+		 }
+		 return ret;
+	 }
+	 //endregion --- Processing methods
 
-	public  double computeSD(double squaredVal, double val, double size) {
-		if (size > 1)
-			return Math.sqrt((squaredVal - ((val * val) / size)) / size);
-		else
-			return 0.0;
-	}
-
-	public static double scalarProduct(DoubleVector u, DoubleVector v) {
-		double ret = 0.0;
-		for (int i = 0; i < Math.max(u.numValues(), v.numValues()); i++) {
-			ret += u.getValue(i) * v.getValue(i);
-		}
-		return ret;
-	}
-	//endregion --- Processing methods
-
-	//endregion ================ METHODS ================
+	 //endregion ================ METHODS ================
 }
diff --git a/moa/src/main/java/moa/classifiers/multitarget/BasicMultiTargetRegressor.java b/moa/src/main/java/moa/classifiers/multitarget/BasicMultiTargetRegressor.java
index 56c3985a5..93c1c94a1 100644
--- a/moa/src/main/java/moa/classifiers/multitarget/BasicMultiTargetRegressor.java
+++ b/moa/src/main/java/moa/classifiers/multitarget/BasicMultiTargetRegressor.java
@@ -16,7 +16,7 @@
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.Instances;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 
@@ -47,7 +47,7 @@ public void resetLearningImpl() {
 	}
 
 	@Override
-	public void trainOnInstanceImpl(MultiLabelInstance instance) {
+	public void trainOnInstanceImpl(StructuredInstance instance) {
 		if (this.hasStarted == false){		
 			this.ensemble = new Classifier[instance.numberOutputTargets()];
 			Classifier baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
@@ -65,7 +65,7 @@ public void trainOnInstanceImpl(MultiLabelInstance instance) {
 
 	protected InstancesHeader[] header;
 
-	protected Instance transformInstance(MultiLabelInstance inst, int outputIndex) {
+	protected Instance transformInstance(StructuredInstance inst, int outputIndex) {
 		if (header == null) {
 			this.header = new InstancesHeader[this.ensemble.length];
 		}
@@ -128,7 +128,7 @@ public void getModelDescription(StringBuilder out, int indent) {
 	
 
 	@Override
-	public Prediction getPredictionForInstance(MultiLabelInstance instance) {
+	public Prediction getPredictionForInstance(StructuredInstance instance) {
 		Prediction prediction=null;
 		if (this.hasStarted){ 
 			prediction=new MultiLabelPrediction(ensemble.length);
diff --git a/moa/src/main/java/moa/classifiers/multitarget/functions/MultiTargetNoChange.java b/moa/src/main/java/moa/classifiers/multitarget/functions/MultiTargetNoChange.java
index 0f61f4e73..9f08ed855 100644
--- a/moa/src/main/java/moa/classifiers/multitarget/functions/MultiTargetNoChange.java
+++ b/moa/src/main/java/moa/classifiers/multitarget/functions/MultiTargetNoChange.java
@@ -4,7 +4,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstanceData;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 
@@ -37,7 +37,7 @@ public void resetLearningImpl() {
     }
 
     @Override
-    public void trainOnInstanceImpl(MultiLabelInstance inst) {
+    public void trainOnInstanceImpl(StructuredInstance inst) {
     	int numOutputs = inst.numberOutputTargets();
     	Prediction prediction = new MultiLabelPrediction(numOutputs);
     	
@@ -65,7 +65,7 @@ public boolean isRandomizable() {
     }
 
 	@Override
-	public Prediction getPredictionForInstance(MultiLabelInstance inst) {
+	public Prediction getPredictionForInstance(StructuredInstance inst) {
 		//return (lastSeenClasses!=null) ? this.lastSeenClasses : new MultiLabelPrediction();
 		return (lastSeenClasses!=null) ? this.lastSeenClasses : null;
 	}
diff --git a/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java
index 8d835fb5a..fb5505ef7 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java
@@ -1,7 +1,8 @@
 package moa.classifiers.rules.core;
 
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.AbstractMOAObject;
 import moa.core.StringUtils;
@@ -23,10 +24,10 @@ public NominalRulePredicate(int inputAttributeIndex, double attributeValue, bool
 	}
 	@Override
 	public boolean evaluate(Instance instance){
-		return evaluate((MultiLabelInstance) instance);
+		return evaluate((StructuredInstance) instance);
 	}
 
-	public boolean evaluate(MultiLabelInstance instance) {
+	public boolean evaluate(StructuredInstance instance) {
 		if (instance.isMissing(inputAttributeIndex)) {
 			return false;
 		}
@@ -68,5 +69,11 @@ public int getAttributeIndex() {
 	public boolean isEqualOrLess() {
 		return isEqual;
 	}
-
+	@Override
+	public void getDescription(StringBuilder sb, int indent, InstancesHeader header) {
+		if(isEqual)
+			StringUtils.appendIndented(sb, indent, InstancesHeader.getAttributeNameString(header, inputAttributeIndex) + " == " + attributeValue);
+		else
+			StringUtils.appendIndented(sb, indent, InstancesHeader.getAttributeNameString(header, inputAttributeIndex) + " <> " + attributeValue);
+	}
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java
index 6084fbae6..8387610c0 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java
@@ -1,7 +1,8 @@
 package moa.classifiers.rules.core;
 
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.AbstractMOAObject;
 import moa.core.StringUtils;
@@ -23,10 +24,10 @@ public NumericRulePredicate(int inputAttributeIndex, double attributeValue, bool
 	}
 	@Override
 	public boolean evaluate(Instance instance){
-		return evaluate((MultiLabelInstance) instance);
+		return evaluate((StructuredInstance) instance);
 	}
 
-	public boolean evaluate(MultiLabelInstance instance) {
+	public boolean evaluate(StructuredInstance instance) {
 		if (instance.isMissing(inputAttributeIndex)) {
 			return false;
 		}
@@ -69,5 +70,14 @@ public boolean isEqualOrLess() {
 		return isEqualOrLower;
 	}
 
+	public double getAttributeValue() {
+		return attributeValue;
+	}
+	@Override
+	public void getDescription(StringBuilder sb, int indent, InstancesHeader header) {
+		if(isEqualOrLower)
+			StringUtils.appendIndented(sb, indent, InstancesHeader.getAttributeNameString(header, inputAttributeIndex) + " <= " + attributeValue);
+		else
+			StringUtils.appendIndented(sb, indent, InstancesHeader.getAttributeNameString(header, inputAttributeIndex) + " > " + attributeValue);	}
 
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/core/Predicate.java b/moa/src/main/java/moa/classifiers/rules/core/Predicate.java
index f7f120d5d..75517efc3 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/Predicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/Predicate.java
@@ -20,6 +20,7 @@
 package moa.classifiers.rules.core;
 
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public interface Predicate {
 	
@@ -28,5 +29,6 @@ public interface Predicate {
 	 public int getAttributeIndex();
 	 public boolean isEqualOrLess();
 	 public void getDescription(StringBuilder sb, int indent);
+	 public void getDescription(StringBuilder sb, int indent, InstancesHeader header);
 	 
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AbstractAnomalyDetector.java b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AbstractAnomalyDetector.java
index dea1adf2c..13a4f85ba 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AbstractAnomalyDetector.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AbstractAnomalyDetector.java
@@ -1,7 +1,7 @@
 package moa.classifiers.rules.core.anomalydetection;
 
 import moa.options.AbstractOptionHandler;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 
 public abstract class AbstractAnomalyDetector extends AbstractOptionHandler implements AnomalyDetector {
@@ -12,7 +12,7 @@ public abstract class AbstractAnomalyDetector extends AbstractOptionHandler impl
 	private static final long serialVersionUID = 1L;
 
 	@Override
-	public abstract boolean updateAndCheckAnomalyDetection(MultiLabelInstance instance);
+	public abstract boolean updateAndCheckAnomalyDetection(StructuredInstance instance);
 
 	@Override
 	public AnomalyDetector copy() {
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalinessRatioScore.java b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalinessRatioScore.java
index 211fbbc29..9297ebe1e 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalinessRatioScore.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalinessRatioScore.java
@@ -11,7 +11,7 @@
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 public class AnomalinessRatioScore extends AbstractAnomalyDetector {
 
@@ -54,7 +54,7 @@ public class AnomalinessRatioScore extends AbstractAnomalyDetector {
 
 
 	@Override
-	public boolean updateAndCheckAnomalyDetection(MultiLabelInstance instance) {
+	public boolean updateAndCheckAnomalyDetection(StructuredInstance instance) {
 		boolean isAnomaly=false;
 		if(probabilityFunction==null){
 			weightSeen=0.0;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalyDetector.java b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalyDetector.java
index f4d4647d7..6e9361842 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalyDetector.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalyDetector.java
@@ -1,5 +1,5 @@
 package moa.classifiers.rules.core.anomalydetection;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.options.OptionHandler;
 
@@ -18,7 +18,7 @@ public interface AnomalyDetector extends OptionHandler {
      *
      * @return true if anomaly is detected and false otherwise
      */
-    public boolean updateAndCheckAnomalyDetection(MultiLabelInstance instance);
+    public boolean updateAndCheckAnomalyDetection(StructuredInstance instance);
 
     
     @Override
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/NoAnomalyDetection.java b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/NoAnomalyDetection.java
index e7e44a113..722f15dfa 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/NoAnomalyDetection.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/NoAnomalyDetection.java
@@ -2,7 +2,7 @@
 
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 public class NoAnomalyDetection extends AbstractAnomalyDetector{
 
@@ -17,7 +17,7 @@ public void getDescription(StringBuilder sb, int indent) {
 	}
 
 	@Override
-	public boolean updateAndCheckAnomalyDetection(MultiLabelInstance instance) {
+	public boolean updateAndCheckAnomalyDetection(StructuredInstance instance) {
 		return false;
 	}
 
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/OddsRatioScore.java b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/OddsRatioScore.java
index 08d846ea9..53cc8556c 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/OddsRatioScore.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/OddsRatioScore.java
@@ -11,7 +11,7 @@
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 public class OddsRatioScore extends AbstractAnomalyDetector {
 
@@ -48,7 +48,7 @@ public class OddsRatioScore extends AbstractAnomalyDetector {
 	private ProbabilityFunction probabilityFunction;
 
 	@Override
-	public boolean updateAndCheckAnomalyDetection(MultiLabelInstance instance) {
+	public boolean updateAndCheckAnomalyDetection(StructuredInstance instance) {
 		boolean isAnomaly=false;
 		if(probabilityFunction==null){
 			weightSeen=0.0;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java
index 49a82a67d..df2405a5a 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java
@@ -20,6 +20,7 @@
 package moa.classifiers.rules.core.conditionaltests;
 
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import moa.classifiers.core.conditionaltests.NominalAttributeBinaryTest;
 import moa.classifiers.rules.core.Predicate;
@@ -78,6 +79,14 @@ public int getAttributeIndex() {
 	public boolean isEqualOrLess() {
 		return state;
 	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent, InstancesHeader header) {
+		if(state)
+			StringUtils.appendIndented(sb, indent, InstancesHeader.getAttributeNameString(header, attIndex) + " = " + attValue);
+		else
+			StringUtils.appendIndented(sb, indent, InstancesHeader.getAttributeNameString(header, attIndex) + " <> " + attValue);		
+	}
 	
 	
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java
index 90560586b..37650e7ca 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java
@@ -169,4 +169,11 @@ public boolean isEqualOrLess() {
 		return state;
 	}
 
+	@Override
+	public void getDescription(StringBuilder sb, int indent, InstancesHeader header) {
+		String compareChar = (operator == 0) ? "=" : (operator == 1) ? "<=" : ">";
+		StringUtils.appendIndented(sb, indent, InstancesHeader.getAttributeNameString(header, attIndex) + compareChar + attValue);		
+	}
+	
+
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/functions/Perceptron.java b/moa/src/main/java/moa/classifiers/rules/functions/Perceptron.java
index 45ae75b74..a5e48b1a8 100644
--- a/moa/src/main/java/moa/classifiers/rules/functions/Perceptron.java
+++ b/moa/src/main/java/moa/classifiers/rules/functions/Perceptron.java
@@ -25,7 +25,7 @@
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Regressor;
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java b/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java
index 2672f58f5..44a24ae5f 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java
@@ -55,7 +55,7 @@
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 
@@ -147,7 +147,7 @@ public AMRulesMultiLabelLearner(double attributesPercentage) {
 
 
 	@Override
-	public Prediction getPredictionForInstance(MultiLabelInstance inst) {
+	public Prediction getPredictionForInstance(StructuredInstance inst) {
 		/*MultiLabelVote vote=getVotes(inst);
 		if(vote!=null)	
 			return vote.getVote();
@@ -166,7 +166,7 @@ public Prediction getPredictionForInstance(MultiLabelInstance inst) {
 	 * returns the prediction of the instance.
 	 * Called in WeightedRandomRules
 	 */
-	public ErrorWeightedVoteMultiLabel getVotes(MultiLabelInstance instance) {
+	public ErrorWeightedVoteMultiLabel getVotes(StructuredInstance instance) {
 		ErrorWeightedVoteMultiLabel errorWeightedVote=newErrorWeightedVote();
 		//DoubleVector combinedVote = new DoubleVector();
 		debug("Test",3);    
@@ -237,7 +237,7 @@ public boolean isRandomizable(){
 	private double numInstances; //Just for statistics
 
 	@Override
-	public void trainOnInstanceImpl(MultiLabelInstance instance) {
+	public void trainOnInstanceImpl(StructuredInstance instance) {
 		/**
 		 * AMRules Algorithm
 		 * 
@@ -398,7 +398,7 @@ protected void debug(String string, int level) {
 		}
 	}
 
-	protected void VerboseToConsole(MultiLabelInstance inst) {
+	protected void VerboseToConsole(StructuredInstance inst) {
 		if(VerbosityOption.getValue()>=5){	
 			System.out.println(); 
 			System.out.println("I) Dataset: "+inst.dataset().getRelationName()); 
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java
index 4a8a18ccf..9c179d2f6 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java
@@ -8,7 +8,7 @@
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 
@@ -95,9 +95,9 @@ public LearningLiteral(int [] outputsToLearn){
 		this.outputsToLearn=outputsToLearn.clone();
 	}
 
-	abstract public void trainOnInstance(MultiLabelInstance instance);
+	abstract public void trainOnInstance(StructuredInstance instance);
 
-	public Prediction getPredictionForInstance(MultiLabelInstance instance) {
+	public Prediction getPredictionForInstance(StructuredInstance instance) {
 		if (learner!=null)
 			return learner.getPredictionForInstance(instance);
 		else
@@ -107,7 +107,7 @@ public Prediction getPredictionForInstance(MultiLabelInstance instance) {
 
 	public abstract boolean tryToExpand(double splitConfidence, double tieThresholdOption);
 
-	public boolean updateAndCheckChange(MultiLabelInstance instance) {
+	public boolean updateAndCheckChange(StructuredInstance instance) {
 		boolean hasChanged=false;
 		if (hasStarted){
 			if (changeDetectors==null){
@@ -133,7 +133,7 @@ public boolean updateAndCheckChange(MultiLabelInstance instance) {
 	protected abstract double[] getNormalizedErrors(Prediction prediction,
 			Instance inst);
 
-	public boolean updateAndCheckAnomalyDetection(MultiLabelInstance instance) {
+	public boolean updateAndCheckAnomalyDetection(StructuredInstance instance) {
 		if(hasStarted)
 			return anomalyDetector.updateAndCheckAnomalyDetection(instance);
 		else
@@ -239,7 +239,7 @@ public void setAttributesPercentage(double attributesPercentage) {
 		this.attributesPercentage=attributesPercentage;
 	}
 	
-	protected void initializeAttibutesMask(MultiLabelInstance inst) {
+	protected void initializeAttibutesMask(StructuredInstance inst) {
 		int numInputAttributes=inst.numInputAttributes();
 		int numAttributesSelected=(int)Math.round(numInputAttributes*attributesPercentage/100);
 		
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java
index 26ae4e0d9..f9e2c5c82 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java
@@ -2,7 +2,7 @@
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 import java.util.Arrays;
@@ -157,7 +157,7 @@ private AttributeExpansionSuggestion[] getBestSplitSuggestions(MultiLabelSplitCr
 	}
 
 	@Override
-	public void trainOnInstance(MultiLabelInstance instance)  {
+	public void trainOnInstance(StructuredInstance instance)  {
 		if (attributesMask==null)
 			initializeAttibutesMask(instance);
 		
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java
index 6bd641395..0fb2aba8b 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java
@@ -5,7 +5,7 @@
 import java.util.List;
 import java.util.Random;
 
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 import moa.AbstractMOAObject;
@@ -63,7 +63,7 @@ public void setRuleNumberID(int ruleNumberID) {
 		this.ruleNumberID = ruleNumberID;
 	}
 	
-	public boolean isCovering(MultiLabelInstance inst) {
+	public boolean isCovering(StructuredInstance inst) {
 		boolean isCovering = true;
 		for (Literal l : literalList) {
 			if (l.evaluate(inst) == false) {
@@ -90,15 +90,15 @@ public void getDescription(StringBuilder out, int indent) {
 		StringUtils.appendNewline(out);
 	}
 
-	public boolean updateChangeDetection(MultiLabelInstance instance) {
+	public boolean updateChangeDetection(StructuredInstance instance) {
 		return this.learningLiteral.updateAndCheckChange(instance);
 	}
 
-	public boolean updateAnomalyDetection(MultiLabelInstance instance) {
+	public boolean updateAnomalyDetection(StructuredInstance instance) {
 		return this.learningLiteral.updateAndCheckAnomalyDetection(instance);
 	}
 
-	public void trainOnInstance(MultiLabelInstance instance) {
+	public void trainOnInstance(StructuredInstance instance) {
 		learningLiteral.trainOnInstance(instance);
 	}
 
@@ -114,7 +114,7 @@ public LearningLiteral getLearningNode() {
 		return learningLiteral.getErrors();
 	}
 
-	public  Prediction getPredictionForInstance(MultiLabelInstance instance) {
+	public  Prediction getPredictionForInstance(StructuredInstance instance) {
 		return learningLiteral.getPredictionForInstance(instance);
 	}
 	
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiLabelErrorMeasurer.java b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiLabelErrorMeasurer.java
index ddcad8f6c..b96ddd2a7 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiLabelErrorMeasurer.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiLabelErrorMeasurer.java
@@ -5,7 +5,7 @@
 import moa.tasks.TaskMonitor;
 
 import com.github.javacliparser.FloatOption;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 public abstract class AbstractMultiLabelErrorMeasurer  extends AbstractOptionHandler implements MultiTargetErrorMeasurer{
@@ -27,7 +27,7 @@ public void addPrediction(Prediction prediction, Prediction trueClass){
 		addPrediction(prediction, trueClass);
 	}
 	
-	abstract public void addPrediction(Prediction prediction, MultiLabelInstance inst);
+	abstract public void addPrediction(Prediction prediction, StructuredInstance inst);
 	
 	abstract public double getCurrentError();
 	
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiTargetErrorMeasurer.java b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiTargetErrorMeasurer.java
index 97ee491ac..5b2bc3be8 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiTargetErrorMeasurer.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiTargetErrorMeasurer.java
@@ -1,6 +1,6 @@
 package moa.classifiers.rules.multilabel.errormeasurers;
 
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 
@@ -11,7 +11,7 @@ public abstract class AbstractMultiTargetErrorMeasurer extends AbstractMultiLabe
 	 */
 	private static final long serialVersionUID = 1L;
 
-	public void addPrediction(Prediction prediction, MultiLabelInstance inst){
+	public void addPrediction(Prediction prediction, StructuredInstance inst){
 		int numOutputs=inst.numberOutputTargets();
 		Prediction trueClass= new MultiLabelPrediction(numOutputs);
 		for (int i=0; i<numOutputs; i++){
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/MultiLabelErrorMeasurer.java b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/MultiLabelErrorMeasurer.java
index f66d3e4d3..66259cfe6 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/MultiLabelErrorMeasurer.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/MultiLabelErrorMeasurer.java
@@ -1,6 +1,6 @@
 package moa.classifiers.rules.multilabel.errormeasurers;
 
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 import moa.options.OptionHandler;
@@ -11,7 +11,7 @@ public interface MultiLabelErrorMeasurer extends OptionHandler {
 
 	public void addPrediction(Prediction prediction, Prediction trueClass);
 
-	public void addPrediction(Prediction prediction, MultiLabelInstance inst);
+	public void addPrediction(Prediction prediction, StructuredInstance inst);
 
 	public double getCurrentError();
 
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/AdaptiveMultiTargetRegressor.java b/moa/src/main/java/moa/classifiers/rules/multilabel/functions/AdaptiveMultiTargetRegressor.java
index e8a16a8d4..1f0adf4b4 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/AdaptiveMultiTargetRegressor.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/functions/AdaptiveMultiTargetRegressor.java
@@ -8,7 +8,7 @@
 import moa.learners.Learner;
 import moa.options.ClassOption;
 
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 public class AdaptiveMultiTargetRegressor extends AbstractMultiLabelLearner
@@ -43,7 +43,7 @@ public AdaptiveMultiTargetRegressor(){
 
 	}
 	@Override
-	public void trainOnInstanceImpl(MultiLabelInstance instance) {
+	public void trainOnInstanceImpl(StructuredInstance instance) {
 		if (!this.hasStarted){	
 			baseLearner=new MultiTargetRegressor[NUM_LEARNERS];
 			errorMeasurer= new MultiTargetErrorMeasurer[NUM_LEARNERS];
@@ -67,7 +67,7 @@ public void trainOnInstanceImpl(MultiLabelInstance instance) {
 	}
 
 	@Override
-	public Prediction getPredictionForInstance(MultiLabelInstance inst) {
+	public Prediction getPredictionForInstance(StructuredInstance inst) {
 		Prediction prediction=null;
 		if(hasStarted){
 			int bestIndex=0;
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/meta/MultiLabelRandomAMRules.java b/moa/src/main/java/moa/classifiers/rules/multilabel/meta/MultiLabelRandomAMRules.java
index b499ace51..7c08a3eed 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/meta/MultiLabelRandomAMRules.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/meta/MultiLabelRandomAMRules.java
@@ -18,7 +18,7 @@
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.MultiChoiceOption;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 public class MultiLabelRandomAMRules extends AbstractMultiLabelLearner
@@ -93,7 +93,7 @@ public void resetLearningImpl() {
 		this.isRegression = (baseLearner instanceof MultiTargetRegressor);
 	}
 
-	public void trainOnInstanceImpl(MultiLabelInstance instance) {
+	public void trainOnInstanceImpl(StructuredInstance instance) {
 		for (int i = 0; i < this.ensemble.length; i++) {
 			Instance inst=instance.copy();
 			int k = 1;
@@ -114,7 +114,7 @@ public void trainOnInstanceImpl(MultiLabelInstance instance) {
 	}
 
 	@Override
-	public Prediction getPredictionForInstance(MultiLabelInstance inst) {
+	public Prediction getPredictionForInstance(StructuredInstance inst) {
 		Prediction vote=null;
 		//ErrorWeightedVote combinedVote = (ErrorWeightedVote)((ErrorWeightedVote) votingTypeOption.getPreMaterializedObject()).copy();
 		ErrorWeightedVoteMultiLabel combinedVote = (ErrorWeightedVoteMultiLabel)((ErrorWeightedVoteMultiLabel) getPreparedClassOption(this.votingFunctionOption)).copy();
diff --git a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java b/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
index 74bbeabe8..5ca826b98 100644
--- a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
+++ b/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
@@ -52,7 +52,7 @@ public class FIMTDD extends AbstractClassifier implements Regressor {
 
 	private static final long serialVersionUID = 1L;
 
-	protected Node treeRoot;
+	public Node treeRoot;
 
 	protected int leafNodeCount = 0;
 	protected int splitNodeCount = 0;
@@ -321,7 +321,7 @@ public void learnFromInstance(Instance inst, boolean growthAllowed, double predi
 			}
 
 			if (growthAllowed) {
-				checkForSplit();
+				checkForSplit(inst, prediction);
 			}
 		}
 
@@ -366,17 +366,16 @@ public double getPredictionTargetMean(Instance inst) {
 
 		public double getPrediction(Instance inst) {
 			if (tree.buildingModelTree()) {
-				//return getPredictionModel(inst);
 				return (errorModel < errorTargetMean) ? getPredictionModel(inst) : getPredictionTargetMean(inst);
 			} else
 				return getPredictionTargetMean(inst);
 		}
 		
-		public void checkForSplit() {
+		public void checkForSplit(Instance inst, double prediction) {
 			// If it has seen Nmin examples since it was last tested for splitting, attempt a split of this node
 			if (examplesSeen - examplesSeenAtLastSplitEvaluation >= tree.gracePeriodOption.getValue()) {
 				int index = (parent != null) ? parent.getChildIndex(this) : 0;
-				tree.attemptToSplit(this, parent, index);
+				tree.attemptToSplit(this, parent, index, inst, prediction);
 
 				// Take note of how many instances were seen when this split evaluation was made, so we know when to perform the next split evaluation
 				examplesSeenAtLastSplitEvaluation = examplesSeen;
@@ -553,6 +552,7 @@ public String getPurposeString() {
 		public FIMTDDPerceptron(FIMTDDPerceptron original) {
 			this.tree = original.tree;
 			weightAttribute = original.weightAttribute.clone();
+			instancesSeen = original.instancesSeen / 2;
 		}
 
 		public FIMTDDPerceptron(FIMTDD tree) {
@@ -742,6 +742,18 @@ public double getNormalizedError(Instance inst, double prediction) {
 		return Math.abs(normalValue - normalPrediction);
 	}
 
+	
+	public void updateStatistics(Instance inst) {
+		examplesSeen += inst.weight();
+		sumOfValues += inst.weight() * inst.classValue();
+		sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
+
+		for (int i = 0; i < inst.numAttributes() - 1; i++) {
+			int aIndex = modelAttIndexToInstanceAttIndex(i, inst);
+			sumOfAttrValues.addToValue(i, inst.weight() * inst.value(aIndex));
+			sumOfAttrSquares.addToValue(i, inst.weight() * inst.value(aIndex) * inst.value(aIndex));
+		}
+	}
 
 	/**
 	 * Method for updating (training) the model using a new instance
@@ -754,16 +766,7 @@ public void trainOnInstanceImpl(Instance inst) {
 	
 		processInstance(inst, treeRoot, prediction, normalError, true, false);
 		
-		examplesSeen += inst.weight();
-		sumOfValues += inst.weight() * inst.classValue();
-		sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
-
-		for (int i = 0; i < inst.numAttributes() - 1; i++) {
-			int aIndex = modelAttIndexToInstanceAttIndex(i, inst);
-			sumOfAttrValues.addToValue(i, inst.weight() * inst.value(aIndex));
-			sumOfAttrSquares.addToValue(i, inst.weight() * inst.value(aIndex) * inst.value(aIndex));
-		}
-
+		updateStatistics(inst);
 
 	}
 
@@ -867,7 +870,7 @@ protected FIMTDDPerceptron newLeafModel() {
 	
 	// region --- Processing methods
 	
-	protected void checkRoot() {
+	public void checkRoot() {
 		if (treeRoot == null) {
 			treeRoot = newLeafNode();
 			leafNodeCount = 1;
@@ -882,7 +885,7 @@ public boolean buildingModelTree() {
 		return !regressionTreeOption.isSet();
 	}
 
-	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
+	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex, Instance inst, double prediction) {
 
 		// Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
  		SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
diff --git a/moa/src/main/java/moa/classifiers/trees/ORTO.java b/moa/src/main/java/moa/classifiers/trees/ORTO.java
index 1808a5466..34108ef59 100644
--- a/moa/src/main/java/moa/classifiers/trees/ORTO.java
+++ b/moa/src/main/java/moa/classifiers/trees/ORTO.java
@@ -331,7 +331,7 @@ protected OptionNode newOptionNode() {
 
 	// region --- Processing methods
 
-	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
+	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex, Instance inst, double prediction) {
 		// Initialize the split criterion 
 		SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(splitCriterionOption);
 
@@ -376,11 +376,10 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
 					} else {
 						break;
 					}
-						
 				}
 			} else if (hoeffdingBound < tieThresholdOption.getValue()) {
 				numSplits = 1;
-				acceptedSplits.add(bestSplitSuggestions[0]);
+				acceptedSplits.add(bestSuggestion);
 			} else { // If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
 				for (int i = 0; i < node.attributeObservers.size(); i++) {
 					AttributeClassObserver obs = node.attributeObservers.get(i);
diff --git a/moa/src/main/java/moa/evaluation/BasicMultiTargetPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/BasicMultiTargetPerformanceEvaluator.java
index aec992e29..5b87a670b 100644
--- a/moa/src/main/java/moa/evaluation/BasicMultiTargetPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/BasicMultiTargetPerformanceEvaluator.java
@@ -27,7 +27,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstanceData;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 /**
@@ -59,7 +59,7 @@ public void reset() {
     @Override
     public void addResult(Example<Instance> example, Prediction prediction) {
 
-    MultiLabelInstance inst = (MultiLabelInstance) example.getData();
+    StructuredInstance inst = (StructuredInstance) example.getData();
     if (numberOutputs == 0) {
     	numberOutputs = inst.numberOutputTargets();
     }
diff --git a/moa/src/main/java/moa/evaluation/MultiTargetWindowRegressionPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/MultiTargetWindowRegressionPerformanceEvaluator.java
index 2b43a72a6..24d45642d 100644
--- a/moa/src/main/java/moa/evaluation/MultiTargetWindowRegressionPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/MultiTargetWindowRegressionPerformanceEvaluator.java
@@ -30,7 +30,7 @@
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 /**
@@ -152,7 +152,7 @@ public void prepareForUseImpl(TaskMonitor monitor,
 
 	@Override
 	public void addResult(Example<Instance> testInst, Prediction prediction) {
-		MultiLabelInstance inst=(MultiLabelInstance) testInst.getData();
+		StructuredInstance inst=(StructuredInstance) testInst.getData();
        double weight = inst.weight();
         if (numberOutputs == 0) {
         	numberOutputs = inst.numberOutputTargets();
diff --git a/moa/src/main/java/moa/evaluation/MultilabelWindowClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/MultilabelWindowClassificationPerformanceEvaluator.java
new file mode 100644
index 000000000..b26c131c0
--- /dev/null
+++ b/moa/src/main/java/moa/evaluation/MultilabelWindowClassificationPerformanceEvaluator.java
@@ -0,0 +1,152 @@
+/*
+ *    ClassificationPerformanceEvaluator.java
+ *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
+ *    @author Jesse Read (jesse@tsc.uc3m.es)
+ * 
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *    
+ */
+package moa.evaluation;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import moa.core.Example;
+import moa.core.Measurement;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+import com.yahoo.labs.samoa.instances.Prediction;
+
+/**
+ * Multilabel Window Classification Performance Evaluator.
+ * 
+ * @author Jesse Read (jesse@tsc.uc3m.es)
+ * @version $Revision: 1 $
+ */
+public class MultilabelWindowClassificationPerformanceEvaluator extends WindowClassificationPerformanceEvaluator implements MultiTargetPerformanceEvaluator {
+
+	/** running sum of accuracy */
+    double sumAccuracy = 0.0;
+	double sumHamming = 0.0;
+
+	/** running number of examples */
+    int sumExamples = 0;
+
+	/** preset threshold */
+    private double t = 0.5;
+
+    @Override
+    public void reset() {
+		sumAccuracy = 0.0;
+		sumHamming = 0.0;
+		sumExamples = 0;
+    }
+
+    @Override
+    public void reset(int L) {
+        numClasses = L;
+		reset();
+    }
+
+    /**
+     * Add a Result. NOTE: In theory, the size of y[] could change, although we
+     * do not take into account this possibility *yet*. (for this, we would have
+     * to use y[] differently, another format for y[] e.g. HashMap, or store
+     * more info in x)
+     */
+    @Override
+    public void addResult(Example<Instance> example, double[] p_y) {
+
+		//int L = example.numOutputAttributes();      // <-- doesn't work!
+		int L = p_y.length;
+
+        Instance x = example.getData();
+        if (p_y.length < 2) {
+            System.err.println("FATAL ERROR: Not enough labels, we've lost track of the number of labels.");
+            System.exit(1);
+        }
+
+		//System.out.println("------- new result -------------");
+		//System.out.println("x = "+x);
+		//System.out.println("p(y) = "+Arrays.toString(p_y));
+
+		// Threshold to binary output (optional)
+		int y[] = new int[L];
+		for(int j = 0; j < L; j++) {
+			y[j] = (p_y[j] > t) ? 1 : 0;
+		}
+		//System.out.println("y =    "+Arrays.toString(y));
+		
+		sumExamples++;
+		int correct = 0;
+		for(int j = 0; j < y.length; j++) {
+			//int y_true = //]example.valueOutputAttribute(j);  // <-- doesn't work!
+			int y_true = (int)x.value(j); 
+			//int y_pred = (p_y[j] > t) ? 1 : 0;
+			if (y_true == y[j])
+				correct++;
+		}
+
+		// Hamming Score
+		sumHamming+=(correct/(double)L);
+
+		// Exact Match
+		if (correct == L)
+			sumAccuracy++;
+    }
+
+    
+    @Override
+    public void addResult(Example<Instance> example, Prediction prediction) {
+
+        StructuredInstance inst = (StructuredInstance) example.getData();
+        if (inst.weight() > 0.0) {
+            int numberOutputs = inst.numOutputAttributes();
+			if (numberOutputs <= 1) {
+				System.err.println("FATAL ERROR: This is not a multi-label dataset!");
+				System.exit(1);
+			}
+			if (prediction.numOutputAttributes()==0) {
+				System.err.println("FATAL ERROR: This is not a multi-label prediction!");
+				System.exit(1);
+			}
+            double[] result = new double[numberOutputs];
+            for (int i = 0; i< prediction.size();i++){
+				result[i] = prediction.getVote(i,1); 
+            }
+            addResult(example, result);
+        }
+            //System.out.println(inst.classValue()+", "+prediction);
+    }
+
+    @Override
+    public Measurement[] getPerformanceMeasurements() {
+
+        // gather measurements
+        Measurement m[] = new Measurement[]{
+            new Measurement("Exact Match", sumAccuracy/sumExamples),
+			new Measurement("Hamming Score", sumHamming/sumExamples),
+        };
+
+        // reset
+        reset();
+
+        return m;
+    }
+
+    @Override
+    public void getDescription(StringBuilder sb, int indent) {
+        sb.append("Multi-label Window Classification Performance Evaluator");
+    }
+}
diff --git a/moa/src/main/java/moa/streams/ArffFileStream.java b/moa/src/main/java/moa/streams/ArffFileStream.java
index c701d431d..408c6d2da 100644
--- a/moa/src/main/java/moa/streams/ArffFileStream.java
+++ b/moa/src/main/java/moa/streams/ArffFileStream.java
@@ -41,8 +41,7 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class ArffFileStream extends AbstractOptionHandler implements
-        InstanceStream {
+public class ArffFileStream extends AbstractOptionHandler implements InstanceStream {
 
     @Override
     public String getPurposeString() {
@@ -82,8 +81,7 @@ public ArffFileStream(String arffFileName, int classIndex) {
     }
 
     @Override
-    public void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
+    public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
         restart();
     }
 
@@ -127,8 +125,7 @@ public void restart() {
             InputStream fileStream = new FileInputStream(this.arffFileOption.getFile());
             this.fileProgressMonitor = new InputStreamProgressMonitor(
                     fileStream);
-            this.fileReader = new BufferedReader(new InputStreamReader(
-                    this.fileProgressMonitor));
+            this.fileReader = new BufferedReader(new InputStreamReader(this.fileProgressMonitor));
             int classIndex = this.classIndexOption.getValue();
             this.instances = new Instances(this.fileReader, 1, classIndex);
             if (classIndex < 0) {

From 90e39b23cb3c310558c808dc37f49adc6c8b780c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Thu, 24 Mar 2016 13:16:58 +0100
Subject: [PATCH 26/33] Instance, InstanceHeader, ArffReader, etc. rework

---
 .../labs/samoa/instances/ArffLoader.java      | 147 ++--
 .../instances/HierarhicalInstanceImpl.java    | 452 ------------
 .../yahoo/labs/samoa/instances/Instance.java  |  12 +-
 .../labs/samoa/instances/InstanceImpl.java    |  17 +-
 .../samoa/instances/InstanceInformation.java  | 127 ++--
 .../yahoo/labs/samoa/instances/Instances.java | 582 ---------------
 .../labs/samoa/instances/InstancesHeader.java | 674 ++++++++++++++++--
 .../instances/MultiTargetArffLoader.java      |  43 +-
 .../com/yahoo/labs/samoa/instances/Range.java |   1 +
 .../SamoaToWekaInstanceConverter.java         |   4 +-
 .../samoa/instances/StructuredInstance.java   |   3 +
 .../WekaToSamoaInstanceConverter.java         |  12 +-
 .../moa/classifiers/AbstractClassifier.java   |  20 +-
 .../bayes/NaiveBayesMultinomial.java          |   4 +-
 .../InstanceConditionalTest.java              |   3 +-
 .../NominalAttributeBinaryTest.java           |   1 +
 .../NominalAttributeMultiwayTest.java         |   1 +
 .../NumericAttributeBinaryTest.java           |   1 +
 .../main/java/moa/classifiers/lazy/kNN.java   |   9 +-
 .../java/moa/classifiers/lazy/kNNwithPAW.java |   4 +-
 .../classifiers/lazy/kNNwithPAWandADWIN.java  |   4 +-
 .../neighboursearch/DistanceFunction.java     |   6 +-
 .../neighboursearch/EuclideanDistance.java    |   6 +-
 .../lazy/neighboursearch/KDTree.java          |  22 +-
 .../lazy/neighboursearch/LinearNNSearch.java  |  10 +-
 .../NearestNeighbourSearch.java               |  12 +-
 .../neighboursearch/NormalizableDistance.java |  10 +-
 .../kdtrees/KDTreeNodeSplitter.java           |   8 +-
 .../kdtrees/KMeansInpiredMethod.java          |   8 +-
 .../main/java/moa/classifiers/meta/ADACC.java |   6 +-
 .../meta/AccuracyUpdatedEnsemble.java         |   8 +-
 .../meta/AccuracyWeightedEnsemble.java        |  16 +-
 .../moa/classifiers/meta/RandomRules.java     |   4 +-
 .../meta/TemporallyAugmentedClassifier.java   |  13 +-
 .../moa/classifiers/meta/WEKAClassifier.java  |   2 +-
 .../LocalMultiTargetClassifier.java           |   1 +
 .../multilabel/MEKAClassifier.java            |   6 +-
 .../multilabel/MajorityLabelset.java          |   9 -
 .../multilabel/MultilabelHoeffdingTree.java   |   3 +-
 .../multilabel/meta/OzaBagAdwinML.java        |   6 +-
 .../classifiers/multilabel/meta/OzaBagML.java |   6 +-
 .../multilabel/trees/ISOUPTree.java           |   5 +
 .../BasicMultiTargetRegressor.java            |   4 +-
 .../rules/core/NominalRulePredicate.java      |   1 +
 .../rules/core/NumericRulePredicate.java      |   1 +
 .../NominalAttributeBinaryRulePredicate.java  |   1 +
 .../NumericAttributeBinaryRulePredicate.java  |   1 +
 .../rules/meta/RandomAMRulesOld.java          |   1 -
 .../moa/clusterers/AbstractClusterer.java     |   4 +-
 .../main/java/moa/clusterers/Clusterer.java   |   2 +-
 moa/src/main/java/moa/clusterers/CobWeb.java  |  14 +-
 .../clusterers/WekaClusteringAlgorithm.java   |  10 +-
 .../moa/core/MultilabelInstancesHeader.java   |   4 +-
 moa/src/main/java/moa/core/SizeOf.java        |   2 +-
 .../core/utils/AttributeDefinitionUtil.java   | 121 ++++
 .../main/java/moa/core/utils/Converter.java   |   8 +-
 .../BasicMultiLabelPerformanceEvaluator.java  |   4 +-
 .../visualization/RunOutlierVisualizer.java   |   4 +-
 .../moa/gui/visualization/RunVisualizer.java  |   4 +-
 .../moa/gui/visualization/WekaExplorer.java   |   4 +-
 .../main/java/moa/streams/ArffFileStream.java |  55 +-
 .../moa/streams/CachedInstancesStream.java    |   6 +-
 .../moa/streams/ConceptDriftRealStream.java   |  13 +-
 .../java/moa/streams/ConceptDriftStream.java  |   3 +-
 .../main/java/moa/streams/ExampleStream.java  |   3 +-
 .../main/java/moa/streams/FilteredStream.java |   3 +-
 .../java/moa/streams/MultiFilteredStream.java |   2 +-
 .../moa/streams/MultiLabelFilteredStream.java |   4 +-
 .../streams/MultiTargetArffFileStream.java    | 290 ++++----
 .../moa/streams/clustering/FileStream.java    |  43 +-
 .../clustering/RandomRBFGeneratorEvents.java  |   4 +-
 .../streams/clustering/SimpleCSVStream.java   |   6 +-
 .../moa/streams/filters/AddNoiseFilter.java   |   3 +-
 .../java/moa/streams/filters/RBFFilter.java   |   7 +-
 .../java/moa/streams/filters/ReLUFilter.java  |   6 +-
 .../RemoveDiscreteAttributeFilter.java        |   4 +-
 .../filters/ReplacingMissingValuesFilter.java |   1 +
 .../filters/SelectAttributesFilter.java       |  16 +-
 .../streams/generators/AgrawalGenerator.java  |   4 +-
 .../generators/HyperplaneGenerator.java       |   4 +-
 .../moa/streams/generators/LEDGenerator.java  |   4 +-
 .../streams/generators/LEDGeneratorDrift.java |   1 +
 .../generators/RandomRBFGenerator.java        |   4 +-
 .../generators/RandomTreeGenerator.java       |   4 +-
 .../moa/streams/generators/SEAGenerator.java  |   4 +-
 .../streams/generators/STAGGERGenerator.java  |   4 +-
 .../streams/generators/WaveformGenerator.java |   4 +-
 .../generators/WaveformGeneratorDrift.java    |   1 +
 .../cd/AbstractConceptDriftGenerator.java     |   4 +-
 .../multilabel/MetaMultilabelGenerator.java   |   7 +-
 .../multilabel/MultilabelArffFileStream.java  |   4 +-
 .../java/moa/tasks/CacheShuffledStream.java   |   4 +-
 .../moa/tasks/EvaluateInterleavedChunks.java  |   4 +-
 .../tasks/EvaluatePeriodicHeldOutTest.java    |   4 +-
 .../instances/MultiTargetArffLoaderTest.java  |  31 +-
 .../AbstractClassifierTestCase.java           |  14 +-
 .../filters/SelectAttributesFilterTest.java   |   4 +-
 97 files changed, 1355 insertions(+), 1702 deletions(-)
 delete mode 100644 moa/src/main/java/com/yahoo/labs/samoa/instances/HierarhicalInstanceImpl.java
 delete mode 100644 moa/src/main/java/com/yahoo/labs/samoa/instances/Instances.java
 create mode 100644 moa/src/main/java/moa/core/utils/AttributeDefinitionUtil.java

diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
index a6bddce59..c427141d8 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
@@ -20,10 +20,13 @@
 import java.io.Reader;
 import java.io.StreamTokenizer;
 import java.util.ArrayList;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
+import moa.core.utils.AttributeDefinitionUtil;
+
 /**
  * The Class ArffLoader. Loads an Arff file with sparse or dense format.
  */
@@ -41,8 +44,9 @@ public class ArffLoader {
      */
     protected StreamTokenizer streamTokenizer;
 
+   
     /**
-     * Instantiates a new arff loader.
+     * Instantiates a new arff loader. Constructor for backwards compatibility.
      *
      * @param reader the reader
      * @param size the size
@@ -50,39 +54,43 @@ public class ArffLoader {
      */
     public ArffLoader(Reader reader, int size, int classAttribute) {
         // size is not used
-        this(reader);
-        if (classAttribute < 0) {
-            this.instanceInformation.setClassIndex(this.instanceInformation.numAttributes() - 1);
-            //System.out.print(this.instanceInformation.classIndex());
-        } else if (classAttribute > 0) {
-            this.instanceInformation.setClassIndex(classAttribute - 1);
-        }
+    	this(reader,String.valueOf(classAttribute));
     }
 
-    protected Range range;
 
     /**
      * Instantiates a new arff loader.
      *
      * @param reader the reader
-     * @param range
-     * @param size the size
-     * @param classAttribute the class attribute
+     * @param outputDefinition the string definition of output attributes
+     * @param inputDefinition the string definition of input attributes
      */
-    public ArffLoader(Reader reader) {
-        this(reader, null);
+    public ArffLoader(Reader reader, String outputDefinition, String inputDefinition) {
+        BufferedReader br = new BufferedReader(reader);
+
+        //Init streamTokenizer
+        streamTokenizer = new StreamTokenizer(br);
+        streamTokenizer.resetSyntax();
+        streamTokenizer.whitespaceChars(0, ' ');
+        streamTokenizer.wordChars(' ' + 1, '\u00FF');
+        streamTokenizer.whitespaceChars(',', ',');
+        streamTokenizer.commentChar('%');
+        streamTokenizer.quoteChar('"');
+        streamTokenizer.quoteChar('\'');
+        streamTokenizer.ordinaryChar('{');
+        streamTokenizer.ordinaryChar('}');
+        streamTokenizer.eolIsSignificant(true);
+
+        this.instanceInformation = this.getHeader(outputDefinition, inputDefinition);
     }
 
     /**
      * Instantiates a new arff loader.
      *
      * @param reader the reader
-     * @param range
-     * @param size the size
-     * @param classAttribute the class attribute
+     * @param outputDefinition the string definition of output attributes (others are taken as inputs)
      */
-    public ArffLoader(Reader reader, Range range) {
-        this.range = range;
+    public ArffLoader(Reader reader, String outputDefinition) {
         BufferedReader br = new BufferedReader(reader);
 
         //Init streamTokenizer
@@ -98,23 +106,9 @@ public ArffLoader(Reader reader, Range range) {
         streamTokenizer.ordinaryChar('}');
         streamTokenizer.eolIsSignificant(true);
 
-        this.instanceInformation = this.getHeader();
-
-        if (range != null) { //is MultiLabel
-            this.instanceInformation.setRangeOutputIndices(range);
-        }
-
-    }
-
-    /**
-     * Gets the structure.
-     *
-     * @return the structure
-     */
-    public InstanceInformation getStructure() {
-        return this.instanceInformation;
+        this.instanceInformation = this.getHeader(outputDefinition, AttributeDefinitionUtil.nonIgnoredDefinition);
     }
-
+    
     /**
      * Reads instance. It detects if it is dense or sparse.
      *
@@ -144,7 +138,6 @@ public Instance readInstance() {
      */
     public Instance readInstanceDense() {
         Instance instance = newDenseInstance(this.instanceInformation.numAttributes());
-        //System.out.println(this.instanceInformation.numAttributes());
         int numAttribute = 0;
         try {
             while (numAttribute == 0 && streamTokenizer.ttype != StreamTokenizer.TT_EOF) {
@@ -196,7 +189,7 @@ protected void setValue(Instance instance, int numAttribute, double value, boole
             valueAttribute = value;
             //System.out.println(value +"/"+valueAttribute+" ");
         }
-        if (this.instanceInformation.classIndex() == numAttribute) {
+        if (this.instanceInformation.numOutputAttributes() == 1 && this.instanceInformation.classIndex() == numAttribute) {
             setClassValue(instance, valueAttribute);
             //System.out.println(value +"<"+this.instanceInformation.classIndex()+">");
         } else {
@@ -219,17 +212,11 @@ private Instance readInstanceSparse() {
         ArrayList<Double> attributeValues = new ArrayList<Double>();
         List<Integer> indexValues = new ArrayList<Integer>();
         try {
-            //while (streamTokenizer.ttype != StreamTokenizer.TT_EOF) {
-            streamTokenizer.nextToken(); // Remove the '{' char
             //For each line
             while (streamTokenizer.ttype != StreamTokenizer.TT_EOL
                     && streamTokenizer.ttype != StreamTokenizer.TT_EOF) {
                 while (streamTokenizer.ttype != '}') {
                     //For each item
-                    //streamTokenizer.nextToken();
-                    //while (streamTokenizer.ttype != '}'){
-                    //System.out.println(streamTokenizer.nval +"-"+ streamTokenizer.sval);
-                    //numAttribute = (int) streamTokenizer.nval;
                     if (streamTokenizer.ttype == StreamTokenizer.TT_NUMBER) {
                         numAttribute = (int) streamTokenizer.nval;
                     } else {
@@ -342,25 +329,20 @@ private Instance readDenseInstanceSparse() {
         }
         return instance;
     }
-
-    //protected List<Attribute> inputAttributes;
-   // protected List<Attribute> outputAttributes;
     
     protected List<Attribute> auxAttributes;
 
-    private InstanceInformation getHeader() {
-    	//commented JD
-        //this.range.setUpper(10000); //TO DO: Create a new range object with isInRange that does not need the upper limit
+    private InstanceInformation getHeader(String outputDefinition, String inputDefinition) {
         String relation = "file stream";
         auxAttributes = new ArrayList<Attribute>();//JD
         int numAttributes = 0;
+        List<Integer> inputIndexes = new ArrayList<Integer>();
+        List<Integer> outputIndexes = new ArrayList<Integer>();
         try {
             streamTokenizer.nextToken();
             while (streamTokenizer.ttype != StreamTokenizer.TT_EOF) {
                 //For each line
-                //if (streamTokenizer.ttype == '@') {
                 if (streamTokenizer.ttype == StreamTokenizer.TT_WORD && streamTokenizer.sval.startsWith("@") == true) {
-                    //streamTokenizer.nextToken();
                     String token = streamTokenizer.sval.toUpperCase();
                     if (token.startsWith("@RELATION")) {
                         streamTokenizer.nextToken();
@@ -369,13 +351,11 @@ private InstanceInformation getHeader() {
                     } else if (token.startsWith("@ATTRIBUTE")) {
                         streamTokenizer.nextToken();
                         String name = streamTokenizer.sval;
-                        //System.out.println("* " + name);
                         if (name == null) {
                             name = Double.toString(streamTokenizer.nval);
                         }
                         streamTokenizer.nextToken();
                         String type = streamTokenizer.sval;
-                       // System.out.println("* " + name + ":" + type + " ");
                         if (streamTokenizer.ttype == '{') {
                             streamTokenizer.nextToken();
                             List<String> attributeLabels = new ArrayList<String>();
@@ -391,35 +371,21 @@ private InstanceInformation getHeader() {
 
                                 streamTokenizer.nextToken();
                             }
-                           // System.out.println();
-                            //attributes.add(new Attribute(name, attributeLabels));
-                            //commented JD
-                           /* if (this.range.isInRange(numAttribute)) {
-                             outputAttributes.add(new Attribute(name, attributeLabels));
-                             } else {
-                             inputAttributes.add(new Attribute(name, attributeLabels));
-                             }*/
                             auxAttributes.add(new Attribute(name, attributeLabels));
                             numAttributes++;
-                        } else if (streamTokenizer.sval != null && streamTokenizer.sval.toUpperCase() == "HIERARCHICAL") {
-                        	streamTokenizer.nextToken();
-                        	DAGStructure attributeStructure = new DAGStructure();
-                        	if (streamTokenizer.ttype == '{') {
-                        		while(streamTokenizer.ttype == '}') {
-                        			streamTokenizer.nextToken();
-                        			System.out.println(streamTokenizer.sval);
-                        		}
-                        		
-                        	}
-                        	
+//                        } else if (streamTokenizer.sval != null && streamTokenizer.sval.toUpperCase() == "HIERARCHICAL") {
+//                        	streamTokenizer.nextToken();
+//                        	DAGStructure attributeStructure = new DAGStructure();
+//                        	if (streamTokenizer.ttype == '{') {
+//                        		while(streamTokenizer.ttype != '}') {
+//                        			streamTokenizer.nextToken();
+//                        			System.out.println(streamTokenizer.sval);
+//                        		}
+//                        		
+//                        	}
+//                        	
                         } else {
-                            // Add attribute
-                            //commented JD
-                        	/*if (this.range.isInRange(numAttribute)) {
-                             outputAttributes.add(new Attribute(name));
-                             } else {
-                             inputAttributes.add(new Attribute(name));
-                             }*/
+
                             auxAttributes.add(new Attribute(name));
                             numAttributes++;
                         }
@@ -432,29 +398,16 @@ private InstanceInformation getHeader() {
                 }
                 streamTokenizer.nextToken();
             }
-            if (range != null) {
-                this.range.setUpper(numAttributes);
-            }
-            /*if (range==null) //is single-target. All instances should go to inputAtrributes (see setClassIndex(int) from InstanceInformation )
-             inputAttributes=auxAttributes;
-             else//is multi-target
-             {
-             this.range.setUpper(numAttribute);
-             for (int i=0; i<auxAttributes.size();i++)
-             {
-             //if (this.range.isInRange(i))
-             //	outputAttributes.add(auxAttributes.get(i));
-             //else
-             inputAttributes.add(auxAttributes.get(i));
-	            	
-             }
-             }*/
+            
+            outputIndexes = AttributeDefinitionUtil.parseAttributeDefinition(outputDefinition, numAttributes, null);
+            // TODO don't remove output attributes for online PCTs 
+            inputIndexes = AttributeDefinitionUtil.parseAttributeDefinition(inputDefinition, numAttributes, outputIndexes);
 
         } catch (IOException ex) {
             Logger.getLogger(ArffLoader.class.getName()).log(Level.SEVERE, null, ex);
         }
         // this.range.setUpper(inputAttributes.size()+outputAttributes.size());
-        return new InstanceInformation(relation, auxAttributes);
+        return new InstanceInformation(relation, auxAttributes, outputIndexes, inputIndexes);
     }
 
     protected Instance newSparseInstance(double d, double[] res) {
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/HierarhicalInstanceImpl.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/HierarhicalInstanceImpl.java
deleted file mode 100644
index c9ed7728c..000000000
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/HierarhicalInstanceImpl.java
+++ /dev/null
@@ -1,452 +0,0 @@
-/*
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
- * either express or implied. See the License for the specific
- * language governing permissions and limitations under the
- * License.  
- */
-package com.yahoo.labs.samoa.instances;
-
-import moa.AbstractMOAObject;
-
-/**
- * The Class InstanceImpl.
- *
- * @author abifet
- */
-public class HierarhicalInstanceImpl implements StructuredInstance {
-
-    /**
-	 * 
-	 */
-	private static final long serialVersionUID = 1L;
-
-	/**
-     * The weight.
-     */
-    protected double weight;
-
-    /**
-     * The instance data.
-     */
-    protected InstanceData instanceData;
-
-    /**
-     * The instance information.
-     */
-    protected InstancesHeader instanceHeader;
-
-    /**
-     * Instantiates a new instance.
-     *
-     * @param inst the inst
-     */
-    public HierarhicalInstanceImpl(HierarhicalInstanceImpl inst) {
-        this.weight = inst.weight;
-        this.instanceData = inst.instanceData.copy();
-        this.instanceHeader = inst.instanceHeader;
-    }
-
-    //Dense
-    /**
-     * Instantiates a new instance.
-     *
-     * @param weight the weight
-     * @param res the res
-     */
-    public HierarhicalInstanceImpl(double weight, double[] res) {
-        this.weight = weight;
-        this.instanceData = new DenseInstanceData(res);
-    }
-
-    //Sparse
-    /**
-     * Instantiates a new instance.
-     *
-     * @param weight the weight
-     * @param attributeValues the attribute values
-     * @param indexValues the index values
-     * @param numberAttributes the number attributes
-     */
-    public HierarhicalInstanceImpl(double weight, double[] attributeValues, int[] indexValues, int numberAttributes) {
-        this.weight = weight;
-        this.instanceData = new SparseInstanceData(attributeValues, indexValues, numberAttributes);
-    }
-
-    /**
-     * Instantiates a new instance.
-     *
-     * @param weight the weight
-     * @param instanceData the instance data
-     */
-    public HierarhicalInstanceImpl(double weight, InstanceData instanceData) {
-        this.weight = weight;
-        this.instanceData = instanceData;
-    }
-
-    /**
-     * Instantiates a new instance.
-     *
-     * @param numAttributes the num attributes
-     */
-    public HierarhicalInstanceImpl(int numAttributes) {
-        this.instanceData = new DenseInstanceData(new double[numAttributes]); //JD
-        this.weight = 1;
-    }
-
-    /**
-     * Weight.
-     *
-     * @return the double
-     */
-    @Override
-    public double weight() {
-        return weight;
-    }
-
-    /**
-     * Sets the weight.
-     *
-     * @param weight the new weight
-     */
-    @Override
-    public void setWeight(double weight) {
-        this.weight = weight;
-    }
-
-    /**
-     * Attribute.
-     *
-     * @param instAttIndex the inst att index
-     * @return the attribute
-     */
-    @Override
-    public Attribute attribute(int instAttIndex) {
-        return this.instanceHeader.attribute(instAttIndex);
-    }
-
-    /**
-     * Delete attribute at.
-     *
-     * @param i the i
-     */
-    @Override
-    public void deleteAttributeAt(int i) {
-        //throw new UnsupportedOperationException("Not yet implemented");
-        this.instanceData.deleteAttributeAt(i);
-    }
-
-    /**
-     * Insert attribute at.
-     *
-     * @param i the i
-     */
-    @Override
-    public void insertAttributeAt(int i) {
-        throw new UnsupportedOperationException("Not yet implemented");
-    }
-
-    /**
-     * Num attributes.
-     *
-     * @return the int
-     */
-    @Override
-    public int numAttributes() {
-        return this.instanceData.numAttributes();
-    }
-
-    /**
-     * Value.
-     *
-     * @param instAttIndex the inst att index
-     * @return the double
-     */
-    @Override
-    public double value(int instAttIndex) {
-        return this.instanceData.value(instAttIndex);
-    }
-
-    /**
-     * Checks if is missing.
-     *
-     * @param instAttIndex the inst att index
-     * @return true, if is missing
-     */
-    @Override
-    public boolean isMissing(int instAttIndex) {
-        return this.instanceData.isMissing(instAttIndex);
-    }
-
-    /**
-     * Num values.
-     *
-     * @return the int
-     */
-    @Override
-    public int numValues() {
-        return this.instanceData.numValues();
-    }
-
-    /**
-     * Index.
-     *
-     * @param i the i
-     * @return the int
-     */
-    @Override
-    public int index(int i) {
-        return this.instanceData.index(i);
-    }
-
-    /**
-     * Value sparse.
-     *
-     * @param i the i
-     * @return the double
-     */
-    @Override
-    public double valueSparse(int i) {
-        return this.instanceData.valueSparse(i);
-    }
-
-    /**
-     * Checks if is missing sparse.
-     *
-     * @param p the p
-     * @return true, if is missing sparse
-     */
-    @Override
-    public boolean isMissingSparse(int p) {
-        return this.instanceData.isMissingSparse(p);
-    }
-
-    /**
-     * Value.
-     *
-     * @param attribute the attribute
-     * @return the double
-     */
-    @Override
-    public double value(Attribute attribute) {
-        return value(attribute.index());
-
-    }
-
-    /**
-     * String value.
-     *
-     * @param i the i
-     * @return the string
-     */
-    @Override
-    public String stringValue(int i) {
-        throw new UnsupportedOperationException("Not yet implemented");
-    }
-
-    /**
-     * To double array.
-     *
-     * @return the double[]
-     */
-    @Override
-    public double[] toDoubleArray() {
-        return this.instanceData.toDoubleArray();
-    }
-
-    /**
-     * Sets the value.
-     *
-     * @param numAttribute the num attribute
-     * @param d the d
-     */
-    @Override
-    public void setValue(int numAttribute, double d) {
-        this.instanceData.setValue(numAttribute, d);
-    }
-
-    /**
-     * Class value.
-     *
-     * @return the double
-     */
-    @Override
-    public double classValue() {
-        return this.instanceData.value(classIndex());
-    }
-
-    /**
-     * Class index.
-     *
-     * @return the int
-     */
-    @Override
-    public int classIndex() {
-        int classIndex = instanceHeader.classIndex();
-        return classIndex != Integer.MAX_VALUE ? classIndex : 0;
-    }
-
-    /**
-     * Num classes.
-     *
-     * @return the int
-     */
-    @Override
-    public int numClasses() {
-        return this.instanceHeader.numClasses();
-    }
-
-    /**
-     * Class is missing.
-     *
-     * @return true, if successful
-     */
-    @Override
-    public boolean classIsMissing() {
-        return this.instanceData.isMissing(classIndex());
-    }
-
-    /**
-     * Class attribute.
-     *
-     * @return the attribute
-     */
-    @Override
-    public Attribute classAttribute() {
-        return this.instanceHeader.attribute(classIndex());
-    }
-
-    /**
-     * Sets the class value.
-     *
-     * @param d the new class value
-     */
-    @Override
-    public void setClassValue(double d) {
-        this.setValue(classIndex(), d);
-    }
-
-    /**
-     * Copy.
-     *
-     * @return the instance
-     */
-    @Override
-    public Instance copy() {
-        HierarhicalInstanceImpl inst = new HierarhicalInstanceImpl(this);
-        return inst;
-    }
-
-    /**
-     * Dataset.
-     *
-     * @return the instances
-     */
-    @Override
-    public Instances dataset() {
-        return this.instanceHeader;
-    }
-
-    /**
-     * Sets the dataset.
-     *
-     * @param dataset the new dataset
-     */
-    @Override
-    public void setDataset(Instances dataset) {
-        this.instanceHeader = new InstancesHeader(dataset);
-    }
-
-    /**
-     * Adds the sparse values.
-     *
-     * @param indexValues the index values
-     * @param attributeValues the attribute values
-     * @param numberAttributes the number attributes
-     */
-    @Override
-    public void addSparseValues(int[] indexValues, double[] attributeValues, int numberAttributes) {
-        this.instanceData = new SparseInstanceData(attributeValues, indexValues, numberAttributes); //???
-    }
-
-    /**
-     * Text representation of a InstanceImpl.
-     */
-    @Override
-    public String toString() {
-        double[] aux = this.instanceData.toDoubleArray();
-        StringBuilder str = new StringBuilder();
-        for (int i = 0; i < aux.length; i++) {
-            str.append(aux[i]).append(" ");
-        }
-
-        return str.toString();
-    }
-
-    @Override
-    public int numInputAttributes() {
-        return this.instanceHeader.numInputAttributes();
-    }
-
-    @Override
-    public int numOutputAttributes() {
-        return numberOutputTargets();
-    }
-    
-    @Override
-    public int numberOutputTargets() {
-        return this.instanceHeader.numOutputAttributes();
-    }
-
-    @Override
-    public double classValue(int instAttIndex) {
-        return valueOutputAttribute(instAttIndex);
-    }
-
-    @Override
-    public void setClassValue(int indexClass, double valueAttribute) {
-        InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
-        this.instanceData.setValue(instanceInformation.outputAttributeIndex(indexClass), valueAttribute);
-
-    }
-
-    @Override
-    public Attribute outputAttribute(int outputIndex) {
-        InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
-        return instanceInformation.outputAttribute(outputIndex);
-    }
-
-    @Override
-    public Attribute inputAttribute(int attributeIndex) {
-        InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
-        return instanceInformation.inputAttribute(attributeIndex);
-    }
-
-    @Override
-    public double valueInputAttribute(int attributeIndex) {
-        InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
-        return this.instanceData.value(instanceInformation.inputAttributeIndex(attributeIndex));
-    }
-
-    @Override
-    public double valueOutputAttribute(int attributeIndex) {
-        InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
-        return this.instanceData.value(instanceInformation.outputAttributeIndex(attributeIndex));
-    }
-    
-    public int structureType() {
-    	return Instance.STRUCTURE_TYPE_HIERARHICAL;
-    }
-    
-    public AttributeStructure getStructure() {
-    	return this.instanceHeader.getInstanceStructure();
-    }
-}
\ No newline at end of file
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
index e85621700..8d71cea66 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
@@ -224,6 +224,14 @@ public interface Instance extends Serializable {
      */
     public boolean classIsMissing();
 
+    /**
+     * Are any of the output values missing.
+     *
+     * @return true, if any output has missing value
+     */
+    public boolean missingOutputs();
+
+    
     /**
      * Class value.
      *
@@ -257,14 +265,14 @@ public interface Instance extends Serializable {
      *
      * @param dataset the new dataset
      */
-    public void setDataset(Instances dataset);
+    public void setDataset(InstancesHeader dataset);
 
     /**
      * Dataset.
      *
      * @return the instances
      */
-    public Instances dataset();
+    public InstancesHeader dataset();
 
     /**
      * Gets the number of input attributes.
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
index 6cfb34dbd..e5fd9321a 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
@@ -306,6 +306,19 @@ public int numClasses() {
     public boolean classIsMissing() {
         return this.instanceData.isMissing(classIndex());
     }
+    
+    public boolean missingOutputs() {
+    	if (this.instanceHeader.numOutputAttributes() == 1)
+    		return classIsMissing();
+    	else {
+    		for (int i = 0; i < this.instanceHeader.numOutputAttributes(); i++) {
+    			if (this.instanceData.isMissing(outputAttribute(i).index)) {
+    				return true;
+    			}
+    		}
+    	}
+    	return false;
+    }
 
     /**
      * Class attribute.
@@ -344,7 +357,7 @@ public Instance copy() {
      * @return the instances
      */
     @Override
-    public Instances dataset() {
+    public InstancesHeader dataset() {
         return this.instanceHeader;
     }
 
@@ -354,7 +367,7 @@ public Instances dataset() {
      * @param dataset the new dataset
      */
     @Override
-    public void setDataset(Instances dataset) {
+    public void setDataset(InstancesHeader dataset) {
         this.instanceHeader = new InstancesHeader(dataset);
     }
 
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
index 7a8aae816..d9d769f77 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
@@ -16,6 +16,7 @@
 package com.yahoo.labs.samoa.instances;
 
 import java.io.Serializable;
+import java.util.ArrayList;
 import java.util.List;
 
 import moa.AbstractMOAObject;
@@ -34,18 +35,10 @@ public class InstanceInformation implements Serializable {
 
     protected AttributesInformation attributesInformation;
     
-    protected AttributeStructure structure = null;
-
-    /**
-     * The class index.
-     */
-    protected int classIndex = Integer.MAX_VALUE; //By default is multilabel
-
-    /**
-     * Range for multi-label instances.
-     */
-    protected Range range;
-
+    protected List<Integer> outputIndexes;
+    protected List<Integer> inputIndexes;
+    
+    
     public Attribute inputAttribute(int w) {
         return this.attributesInformation.attribute(inputAttributeIndex(w));
     }
@@ -54,6 +47,8 @@ public Attribute outputAttribute(int w) {
         return this.attributesInformation.attribute(outputAttributeIndex(w));
     }
 
+    
+    
     /**
      * Instantiates a new instance information.
      *
@@ -61,9 +56,9 @@ public Attribute outputAttribute(int w) {
      */
     public InstanceInformation(InstanceInformation chunk) {
         this.relationName = chunk.relationName;
+        this.outputIndexes = chunk.outputIndexes;
+        this.inputIndexes = chunk.inputIndexes;
         this.attributesInformation = chunk.attributesInformation;
-        this.structure = chunk.structure;
-        this.classIndex = chunk.classIndex;
     }
 
     /**
@@ -72,16 +67,38 @@ public InstanceInformation(InstanceInformation chunk) {
      * @param st the st
      * @param v the v
      */
-    public InstanceInformation(String st, List<Attribute> input) {
+    public InstanceInformation(String st, List<Attribute> attributes, List<Integer> outputIndexes, List<Integer> inputIndexes) {
+        this.relationName = st;
+        this.outputIndexes = outputIndexes;
+        this.inputIndexes = inputIndexes;
+        this.attributesInformation = new AttributesInformation(attributes, attributes.size());
+    }
+    
+    public InstanceInformation(String st, List<Attribute> input, List<Integer> indexes) {
         this.relationName = st;
-        this.attributesInformation = new AttributesInformation(input, input.size());
+        this.outputIndexes = new ArrayList<Integer>();
+        this.inputIndexes = new ArrayList<Integer>();
+        this.attributesInformation = new AttributesInformation(input, indexes, indexes.size());
     }
 
+    public InstanceInformation(String st, List<Attribute> input) {
+        this.relationName = st;
+        this.outputIndexes = new ArrayList<Integer>();
+        this.inputIndexes = new ArrayList<Integer>();
+        List<Integer> indexes = new ArrayList<Integer>();
+        for (int i = 0; i < input.size(); i++) {
+        	indexes.add(i);
+        }
+        this.attributesInformation = new AttributesInformation(input, indexes, indexes.size());
+    }
+    
     /**
      * Instantiates a new instance information.
      */
     public InstanceInformation() {
         this.relationName = null;
+        this.inputIndexes = null;
+        this.outputIndexes = null;
         this.attributesInformation = null;
     }
 
@@ -104,15 +121,16 @@ public String getRelationName() {
      * @see com.yahoo.labs.samoa.instances.InstanceInformationInterface#classIndex()
      */
     public int classIndex() {
-        return this.classIndex;
+    	if (this.outputIndexes.size() > 1)
+    		throw new UnsupportedOperationException("This instance has multiple output attributes.");
+        return this.outputIndexes.get(0);
     }
 
-    /* (non-Javadoc)
-     * @see com.yahoo.labs.samoa.instances.InstanceInformationInterface#setClassIndex(int)
-     */
-    public void setClassIndex(int classIndex) {
-        this.classIndex = classIndex;
+    public void setClassIndex(int index) {
+    	this.outputIndexes = new ArrayList<Integer>();
+    	this.outputIndexes.add(index);
     }
+    
 
     /* (non-Javadoc)
      * @see com.yahoo.labs.samoa.instances.InstanceInformationInterface#classAttribute()
@@ -163,63 +181,48 @@ public void setAttributes(List<Attribute> v) {
     }
 
     public int inputAttributeIndex(int index) {
-        int ret = 0;
-        if (classIndex == Integer.MAX_VALUE) {//Multi Label
-        	if(index<range.getStart())//JD
-        		ret= index;
-        	else 
-        		ret= index+range.getSelectionLength();
-	
-        } else { //Single Label
-            ret = classIndex() > index ? index : index + 1;
-        }
-        return ret;
+    	// Returns actual instance attribute index!
+        return inputIndexes.get(index);
     }
 
-    public int outputAttributeIndex(int attributeIndex) {
-        int ret = 0;
-        if (classIndex == Integer.MAX_VALUE) {//Multi Label
-        		ret=attributeIndex+range.getStart(); //JD - Range should be a "block"
-        } else { //Single Label
-            ret = classIndex;
-        }
-        return ret;
+    public int outputAttributeIndex(int index) {
+    	// Returns actual instance attribute index!
+    	return outputIndexes.get(index);    
     }
 
     public int numInputAttributes() {
-        int ret = 0;
-        if (classIndex == Integer.MAX_VALUE) {//Multi Label
-        	ret=this.numAttributes()-range.getSelectionLength(); //JD
-        } else { //Single Label
-            ret = this.numAttributes() - 1;
-        }
-        return ret;
+        return inputIndexes.size();
     }
 
     public int numOutputAttributes() {
-        int ret = 0;
-        if (classIndex == Integer.MAX_VALUE) {//Multi Label
-        	ret=range.getSelectionLength(); //JD
-        } else { //Single Label
-            ret = 1;
-        }
-        return ret;
-    }
 
-    public void setRangeOutputIndices(Range range) {
-        this.setClassIndex(Integer.MAX_VALUE);
-        this.range = range;
+    	return outputIndexes.size();
     }
 
 	public void setAttributes(List<Attribute> v, List<Integer> indexValues) {
     	if(this.attributesInformation==null)
     		this.attributesInformation= new AttributesInformation();
         this.attributesInformation.setAttributes(v,indexValues);
-		
+	}
+
+	public void setOutputIndexes(List<Integer> outputIndexes) {
+		this.outputIndexes = outputIndexes;
 	}
 	
-	public AttributeStructure getStructure() {
-		return this.structure;
+	public void setInputIndexes(List<Integer> inputIndexes) {
+		this.inputIndexes = inputIndexes;
+	}
+
+	/** 
+	 * Sets all non-output attributes as input attributes.
+	 */
+	public void setInputIndexes() {
+		this.inputIndexes = new ArrayList<Integer>();
+		for (int i = 0; i < attributesInformation.indexValues.size(); i++) {
+			if (!outputIndexes.contains(attributesInformation.indexValues.get(i))) {
+				inputIndexes.add(attributesInformation.indexValues.get(i));
+			}
+		}
 	}
 
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/Instances.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/Instances.java
deleted file mode 100644
index 559e3bdfd..000000000
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/Instances.java
+++ /dev/null
@@ -1,582 +0,0 @@
-/*
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
- * either express or implied. See the License for the specific
- * language governing permissions and limitations under the
- * License.  
- */
-package com.yahoo.labs.samoa.instances;
-
-import java.io.Reader;
-import java.io.Serializable;
-import java.io.StringReader;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Random;
-import moa.core.Utils;
-
-/**
- * The Class Instances.
- *
- * @author abifet
- */
-public class Instances implements Serializable {
-
-    /**
-     * The keyword used to denote the start of an arff header
-     */
-    public final static String ARFF_RELATION = "@relation";
-
-    /**
-     * The keyword used to denote the start of the arff data section
-     */
-    public final static String ARFF_DATA = "@data";
-
-    private static final long serialVersionUID = 8110510475535581577L;
-    /**
-     * The instance information.
-     */
-    protected InstanceInformation instanceInformation;
-    /**
-     * The instances.
-     */
-    protected List<Instance> instances;
-
-    /**
-     * The arff.
-     */
-    protected ArffLoader arff;
-
-    /**
-     * A Hash that stores the indices of features.
-     */
-    protected HashMap<String, Integer> hsAttributesIndices;
-
-    /**
-     * Instantiates a new instances.
-     *
-     * @param chunk the chunk
-     */
-    public Instances(Instances chunk) {
-        this(chunk, chunk.numInstances());
-        chunk.copyInstances(0, this, chunk.numInstances());
-        this.computeAttributesIndices();
-    }
-
-    /**
-     * Instantiates a new instances.
-     */
-    public Instances() {
-    }
-
-    /**
-     * Instantiates a new instances.
-     *
-     * @param reader the reader
-     * @param size the size
-     * @param classAttribute the class attribute
-     */
-    public Instances(Reader reader, int size, int classAttribute) {
-        arff = new ArffLoader(reader, 0, classAttribute);
-        this.instanceInformation = arff.getStructure();
-        this.instances = new ArrayList<Instance>();
-        this.computeAttributesIndices();
-    }
-
-    /**
-     * Instantiates a new instances.
-     *
-     * @param reader the reader
-     * @param range
-     */
-    public Instances(Reader reader, Range range) {
-        this.arff = new MultiTargetArffLoader(reader, range);
-        this.instanceInformation = arff.getStructure();
-        this.instances = new ArrayList<Instance>();
-        this.computeAttributesIndices();
-    }
-
-    /**
-     * Instantiates a new instances.
-     *
-     * @param chunk the chunk
-     * @param capacity the capacity
-     */
-    public Instances(Instances chunk, int capacity) {
-        this.instanceInformation = chunk.instanceInformation();
-        if (capacity < 0) {
-            capacity = 0;
-        }
-        this.instances = new ArrayList<Instance>(capacity);
-        this.computeAttributesIndices();
-    }
-
-    /**
-     * Instantiates a new instances.
-     *
-     * @param st the st
-     * @param v the v
-     * @param capacity the capacity
-     */
-    public Instances(String st, List<Attribute> v, int capacity) {
-        this.instanceInformation = new InstanceInformation(st, v);
-        this.instances = new ArrayList<Instance>(capacity);
-        this.computeAttributesIndices();
-    }
-
-    /**
-     * Instantiates a new instances.
-     *
-     * @param chunk the chunk
-     * @param first the first instance
-     * @param toCopy the j
-     */
-    public Instances(Instances chunk, int first, int toCopy) {
-
-        this(chunk, toCopy);
-
-        if ((first < 0) || ((first + toCopy) > chunk.numInstances())) {
-            throw new IllegalArgumentException("Parameters first and/or toCopy out "
-                    + "of range");
-        }
-        chunk.copyInstances(first, this, toCopy);
-        this.computeAttributesIndices();
-    }
-
-    /**
-     * Instantiates a new instances.
-     *
-     * @param st the st
-     * @param capacity the capacity
-     */
-    public Instances(StringReader st, int capacity) {
-        this.instances = new ArrayList<Instance>(capacity);
-        this.computeAttributesIndices();
-    }
-
-    //Information Instances
-    /**
-     * Sets the relation name.
-     *
-     * @param string the new relation name
-     */
-    public void setRelationName(String string) {
-        this.instanceInformation.setRelationName(string);
-    }
-
-    /**
-     * Gets the relation name.
-     *
-     * @return the relation name
-     */
-    public String getRelationName() {
-        return this.instanceInformation.getRelationName();
-    }
-
-    /**
-     * Class index.
-     *
-     * @return the int
-     */
-    public int classIndex() {
-        return this.instanceInformation.classIndex();
-    }
-
-    /**
-     * Sets the class index.
-     *
-     * @param classIndex the new class index
-     */
-    public void setClassIndex(int classIndex) {
-        this.instanceInformation.setClassIndex(classIndex);
-    }
-
-    /**
-     * Class attribute.
-     *
-     * @return the attribute
-     */
-    public Attribute classAttribute() {
-        return this.instanceInformation.classAttribute();
-    }
-
-    /**
-     * Num attributes.
-     *
-     * @return the int
-     */
-    public int numAttributes() {
-        return this.instanceInformation.numAttributes();
-    }
-
-    /**
-     * Attribute.
-     *
-     * @param w the w
-     * @return the attribute
-     */
-    public Attribute attribute(int w) {
-        return this.instanceInformation.attribute(w);
-    }
-
-    /**
-     * Num classes.
-     *
-     * @return the int
-     */
-    public int numClasses() {
-        return this.instanceInformation.numClasses();
-    }
-
-    /**
-     * Delete attribute at.
-     *
-     * @param integer the integer
-     */
-    public void deleteAttributeAt(Integer integer) {
-        this.instanceInformation.deleteAttributeAt(integer);
-    }
-
-    /**
-     * Insert attribute at.
-     *
-     * @param attribute the attribute
-     * @param i the i
-     */
-    public void insertAttributeAt(Attribute attribute, int i) {
-        if (this.instanceInformation == null) {
-            this.instanceInformation = new InstanceInformation();
-        }
-        this.instanceInformation.insertAttributeAt(attribute, i);
-    }
-
-    //List of Instances
-    /**
-     * Instance.
-     *
-     * @param num the num
-     * @return the instance
-     */
-    public Instance instance(int num) {
-        return this.instances.get(num);
-    }
-
-    /**
-     * Num instances.
-     *
-     * @return the int
-     */
-    public int numInstances() {
-        return this.instances.size();
-    }
-
-    /**
-     * Adds the.
-     *
-     * @param inst the inst
-     */
-    public void add(Instance inst) {
-        this.instances.add(inst.copy());
-    }
-
-    /**
-     * Randomize.
-     *
-     * @param random the random
-     */
-    public void randomize(Random random) {
-        for (int j = numInstances() - 1; j > 0; j--) {
-            swap(j, random.nextInt(j + 1));
-        }
-    }
-
-    /**
-     * Stratify.
-     *
-     * @param numFolds the num folds
-     */
-    public void stratify(int numFolds) {
-
-        if (classAttribute().isNominal()) {
-
-            // sort by class
-            int index = 1;
-            while (index < numInstances()) {
-                Instance instance1 = instance(index - 1);
-                for (int j = index; j < numInstances(); j++) {
-                    Instance instance2 = instance(j);
-                    if ((instance1.classValue() == instance2.classValue())
-                            || (instance1.classIsMissing()
-                            && instance2.classIsMissing())) {
-                        swap(index, j);
-                        index++;
-                    }
-                }
-                index++;
-            }
-            stratStep(numFolds);
-        }
-    }
-
-    protected void stratStep(int numFolds) {
-        ArrayList<Instance> newVec = new ArrayList<Instance>(this.instances.size());
-        int start = 0, j;
-
-        // create stratified batch
-        while (newVec.size() < numInstances()) {
-            j = start;
-            while (j < numInstances()) {
-                newVec.add(instance(j));
-                j = j + numFolds;
-            }
-            start++;
-        }
-        this.instances = newVec;
-    }
-
-    /**
-     * Train cv.
-     *
-     * @param numFolds the num folds
-     * @param numFold
-     * @param n the n
-     * @param random the random
-     * @return the instances
-     */
-    public Instances trainCV(int numFolds, int numFold, Random random) {
-        Instances train = trainCV(numFolds, numFold);
-        train.randomize(random);
-        return train;
-    }
-
-    public Instances trainCV(int numFolds, int numFold) {
-        int numInstForFold, first, offset;
-        Instances train;
-
-        numInstForFold = numInstances() / numFolds;
-        if (numFold < numInstances() % numFolds) {
-            numInstForFold++;
-            offset = numFold;
-        } else {
-            offset = numInstances() % numFolds;
-        }
-        train = new Instances(this, numInstances() - numInstForFold);
-        first = numFold * (numInstances() / numFolds) + offset;
-        copyInstances(0, train, first);
-        copyInstances(first + numInstForFold, train,
-                numInstances() - first - numInstForFold);
-        return train;
-    }
-
-    protected void copyInstances(int from, Instances dest, int num) {
-        for (int i = 0; i < num; i++) {
-            dest.add(instance(from + i));
-        }
-    }
-
-    /**
-     * Test cv.
-     *
-     * @param numFolds the num folds
-     * @param numFold the num fold
-     * @return the instances
-     */
-    public Instances testCV(int numFolds, int numFold) {
-
-        int numInstForFold, first, offset;
-        Instances test;
-
-        numInstForFold = numInstances() / numFolds;
-        if (numFold < numInstances() % numFolds) {
-            numInstForFold++;
-            offset = numFold;
-        } else {
-            offset = numInstances() % numFolds;
-        }
-        test = new Instances(this, numInstForFold);
-        first = numFold * (numInstances() / numFolds) + offset;
-        copyInstances(first, test, numInstForFold);
-        return test;
-    }
-
-    /*  public Instances dataset() {
-     throw new UnsupportedOperationException("Not yet implemented");
-     }*/
-    /**
-     * Mean or mode.
-     *
-     * @param j the j
-     * @return the double
-     */
-    public double meanOrMode(int j) {
-        throw new UnsupportedOperationException("Not yet implemented"); //CobWeb
-    }
-
-    /**
-     * Read instance.
-     *
-     * @param fileReader the file reader
-     * @return true, if successful
-     */
-    public boolean readInstance(Reader fileReader) {
-
-        //ArffReader arff = new ArffReader(reader, this, m_Lines, 1);
-        Instance inst = arff.readInstance();
-        if (inst != null) {
-            inst.setDataset(this);
-            add(inst);
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    /**
-     * Delete.
-     */
-    public void delete() {
-        this.instances = new ArrayList<Instance>();
-    }
-
-    /**
-     * Delete.
-     */
-    public void delete(int index) {
-        this.instances.remove(index);
-    }
-
-    /**
-     * Swap.
-     *
-     * @param i the i
-     * @param j the j
-     */
-    public void swap(int i, int j) {
-        Instance in = instances.get(i);
-        instances.set(i, instances.get(j));
-        instances.set(j, in);
-    }
-
-    /**
-     * Instance information.
-     *
-     * @return the instance information
-     */
-    private InstanceInformation instanceInformation() {
-        return this.instanceInformation;
-    }
-
-    public Attribute attribute(String name) {
-
-        for (int i = 0; i < numAttributes(); i++) {
-            if (attribute(i).name().equals(name)) {
-                return attribute(i);
-            }
-        }
-        return null;
-    }
-
-    public int size() {
-        return this.numInstances();
-    }
-
-    public void set(int i, Instance inst) {
-        this.instances.set(i, inst);
-    }
-
-    public Instance get(int k) {
-        return this.instance(k);
-    }
-
-    public void setRangeOutputIndices(Range range) {
-        this.instanceInformation.setRangeOutputIndices(range);
-
-    }
-
-    public void setAttributes(List<Attribute> v) {
-        if (this.instanceInformation == null) {
-            this.instanceInformation = new InstanceInformation();
-        }
-        this.instanceInformation.setAttributes(v);
-    }
-
-    public void setAttributes(List<Attribute> v, List<Integer> indexValues) {
-        if (this.instanceInformation == null) {
-            this.instanceInformation = new InstanceInformation();
-        }
-        this.instanceInformation.setAttributes(v, indexValues);
-    }
-
-    /**
-     * Returns the dataset as a string in ARFF format. Strings are quoted if
-     * they contain whitespace characters, or if they are a question mark.
-     *
-     * @return the dataset in ARFF format as a string
-     */
-    public String toString() {
-
-        StringBuffer text = new StringBuffer();
-
-        text.append(ARFF_RELATION).append(" ").
-                append(Utils.quote(this.instanceInformation.getRelationName())).append("\n\n");
-        for (int i = 0; i < numAttributes(); i++) {
-            text.append(attribute(i).toString()).append("\n");
-        }
-        text.append("\n").append(ARFF_DATA).append("\n");
-
-        text.append(stringWithoutHeader());
-        return text.toString();
-    }
-
-    /**
-     * Returns the instances in the dataset as a string in ARFF format. Strings
-     * are quoted if they contain whitespace characters, or if they are a
-     * question mark.
-     *
-     * @return the dataset in ARFF format as a string
-     */
-    protected String stringWithoutHeader() {
-
-        StringBuffer text = new StringBuffer();
-
-        for (int i = 0; i < numInstances(); i++) {
-            text.append(instance(i));
-            if (i < numInstances() - 1) {
-                text.append('\n');
-            }
-        }
-        return text.toString();
-
-    }
-
-    /**
-     * Returns the index of an Attribute.
-     *
-     * @param att, the attribute.
-     */
-    protected int indexOf(Attribute att) {
-        return this.hsAttributesIndices.get(att.name());
-    }
-
-    /**
-     * Completes the hashset with attributes indices.
-     */
-    private void computeAttributesIndices() {
-        this.hsAttributesIndices = new HashMap<String, Integer>();
-        // iterates through all existing attributes 
-        // and sets an unique identifier for each one of them
-        for (int i = 0; i < this.numAttributes(); i++) {
-            hsAttributesIndices.put(this.attribute(i).name(), i);
-        }
-    }
-
-}
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
index 6086fa888..421cbb74e 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
@@ -15,116 +15,642 @@
  */
 package com.yahoo.labs.samoa.instances;
 
+import java.io.Reader;
+import java.io.Serializable;
+import java.io.StringReader;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import org.junit.experimental.theories.Theories;
+
+import moa.core.Utils;
+
 /**
- * Class for storing the header or context of a data stream. It allows to know
- * the number of attributes and classes.
+ * The Class Instances.
  *
- * @version $Revision: 7 $
+ * @author abifet
  */
-public class InstancesHeader extends Instances {
+public class InstancesHeader implements Serializable {
 
+    /** The keyword used to denote the start of an arff header */
+    public final static String ARFF_RELATION = "@relation";
+  
+    /** The keyword used to denote the start of the arff data section */
+    public final static String ARFF_DATA = "@data";
+    
     private static final long serialVersionUID = 1L;
 
-    public InstancesHeader(Instances i) {
-        super(i, 0);
+	/**
+     * The instance information.
+     */
+    protected InstanceInformation instanceInformation;
+    /**
+     * The instances.
+     */
+    protected List<Instance> instances;
+
+    /**
+     * The arff.
+     */
+    protected ArffLoader arff;
+
+    /**
+     * Instantiates a new instances.
+     *
+     * @param chunk the chunk
+     */
+    public InstancesHeader(InstancesHeader chunk) {
+        this(chunk, chunk.numInstances());
+        chunk.copyInstances(0, this, chunk.numInstances());
     }
 
+    /**
+     * Instantiates a new instances.
+     */
     public InstancesHeader() {
-        super();
     }
 
-    public static String getClassNameString(InstancesHeader context) {
-        if (context == null) {
-            return "[class]";
-        }
-        return "[class:" + context.classAttribute().name() + "]";
+    /**
+     * Instantiates a new instances.
+     *
+     * @param reader the reader
+     * @param size the size
+     * @param classAttribute the class attribute
+     */
+    public InstancesHeader(Reader reader, int size, int classAttribute) {
+        arff = new ArffLoader(reader, String.valueOf(classAttribute));
+    	this.instanceInformation = arff.instanceInformation;
+        this.instances = new ArrayList<Instance>();
     }
 
-    public static String getClassLabelString(InstancesHeader context,
-            int classLabelIndex) {
-        if ((context == null) || (classLabelIndex >= context.numClasses())) {
-            return "<class " + (classLabelIndex + 1) + ">";
+    public InstancesHeader(Reader reader, String outputDefinition) {
+    	this.arff = new ArffLoader(reader, outputDefinition);
+    	this.instanceInformation = arff.instanceInformation;
+    	this.instances = new ArrayList<Instance>();
+    }
+    
+    public InstancesHeader(Reader reader, String outputDefinition, String inputDefinition) {
+    	this.arff = new ArffLoader(reader, outputDefinition, inputDefinition);
+    	this.instanceInformation = arff.instanceInformation;
+    	this.instances = new ArrayList<Instance>();
+    }
+    
+    public InstancesHeader(Reader reader, int size, String outputDefinition, String inputDefinition) {
+    	this.arff = new ArffLoader(reader, outputDefinition, inputDefinition);
+    	this.instanceInformation = arff.instanceInformation;
+    	this.instances = new ArrayList<Instance>();
+    }
+    
+    /**
+     * Instantiates a new instances.
+     *
+     * @param reader the reader
+     * @param range
+     */
+//    public Instances(Reader reader, Range range) {
+//        this.arff = new MultiTargetArffLoader(reader, range);
+//        this.instanceInformation = arff.getStructure();
+//        this.instances = new ArrayList<Instance>();
+//    }
+
+    /**
+     * Instantiates a new instances.
+     *
+     * @param chunk the chunk
+     * @param capacity the capacity
+     */
+    public InstancesHeader(InstancesHeader chunk, int capacity) {
+        this.instanceInformation = chunk.instanceInformation();
+        if (capacity < 0) {
+            capacity = 0;
         }
-        return "<class " + (classLabelIndex + 1) + ":"
-                + context.classAttribute().value(classLabelIndex) + ">";
+        this.instances = new ArrayList<Instance>(capacity);
     }
 
-    // is impervious to class index changes - attIndex is true attribute index
-    // regardless of class position
-    public static String getAttributeNameString(InstancesHeader context,
-            int attIndex) {
-        if ((context == null) || (attIndex >= context.numAttributes())) {
-            return "[att " + (attIndex + 1) + "]";
+    /**
+     * Instantiates a new instances.
+     *
+     * @param st the st
+     * @param v the v
+     * @param capacity the capacity
+     */
+    public InstancesHeader(String st, List<Attribute> v, int capacity) {
+        this.instanceInformation = new InstanceInformation(st, v);
+    }
+
+    /**
+     * Instantiates a new instances.
+     *
+     * @param chunk the chunk
+     * @param first the first instance
+     * @param toCopy the j
+     */
+    public InstancesHeader(InstancesHeader chunk, int first, int toCopy) {
+
+        this(chunk, toCopy);
+
+        if ((first < 0) || ((first + toCopy) > chunk.numInstances())) {
+            throw new IllegalArgumentException("Parameters first and/or toCopy out "
+                    + "of range");
         }
-        int instAttIndex = attIndex < context.classIndex() ? attIndex
-                : attIndex + 1;
-        return "[att " + (attIndex + 1) + ":"
-                + context.attribute(instAttIndex).name() + "]";
+        chunk.copyInstances(first, this, toCopy);
+    }
+
+    /**
+     * Instantiates a new instances.
+     *
+     * @param st the st
+     * @param capacity the capacity
+     */
+    public InstancesHeader(StringReader st, int capacity) {
+         this.instances = new ArrayList<Instance>(capacity);
+    }
+
+    //Information Instances
+    /**
+     * Sets the relation name.
+     *
+     * @param string the new relation name
+     */
+    public void setRelationName(String string) {
+        this.instanceInformation.setRelationName(string);
     }
 
-    public static String getInputAttributeNameString(InstancesHeader context,
-                                                int attIndex) {
-        if ((context == null) || (attIndex >= context.numInputAttributes())) {
-            return "[att " + (attIndex + 1) + "]";
+    /**
+     * Gets the relation name.
+     *
+     * @return the relation name
+     */
+    public String getRelationName() {
+        return this.instanceInformation.getRelationName();
+    }
+
+    /**
+     * Class index.
+     *
+     * @return the int
+     */
+    public int classIndex() {
+        return this.instanceInformation.classIndex();
+    }
+
+    /**
+     * Sets the class index. Also sets all other attributes as input attributes for backward compatibility.
+     *
+     * @param classIndex the new class index
+     */
+    public void setClassIndex(int classIndex) {
+        this.instanceInformation.setClassIndex(classIndex);
+        this.instanceInformation.setInputIndexes();
+    }
+
+    public void setOutputIndexes(List<Integer> outputIndexes) {
+        this.instanceInformation.setOutputIndexes(outputIndexes);
+    }
+
+    public void setInputIndexes(List<Integer> inputIndexes) {
+        this.instanceInformation.setInputIndexes(inputIndexes);
+    }
+
+	/** 
+	 * Sets all non-output attributes as input attributes.
+	 */
+	public void setInputIndexes() {
+        this.instanceInformation.setInputIndexes();
+	}
+    
+    /**
+     * Class attribute.
+     *
+     * @return the attribute
+     */
+    public Attribute classAttribute() {
+        return this.instanceInformation.classAttribute();
+    }
+
+    /**
+     * Num attributes.
+     *
+     * @return the int
+     */
+    public int numAttributes() {
+        return this.instanceInformation.numAttributes();
+    }
+
+    /**
+     * Attribute.
+     *
+     * @param w the w
+     * @return the attribute
+     */
+    public Attribute attribute(int w) {
+        return this.instanceInformation.attribute(w);
+    }
+
+    /**
+     * Num classes.
+     *
+     * @return the int
+     */
+    public int numClasses() {
+        return this.instanceInformation.numClasses();
+    }
+
+    /**
+     * Delete attribute at.
+     *
+     * @param integer the integer
+     */
+    public void deleteAttributeAt(Integer integer) {
+        this.instanceInformation.deleteAttributeAt(integer);
+    }
+
+    /**
+     * Insert attribute at.
+     *
+     * @param attribute the attribute
+     * @param i the i
+     */
+    public void insertAttributeAt(Attribute attribute, int i) {
+    	if (this.instanceInformation==null)
+    		this.instanceInformation= new InstanceInformation();
+        this.instanceInformation.insertAttributeAt(attribute, i);
+    }
+
+    //List of Instances
+    /**
+     * Instance.
+     *
+     * @param num the num
+     * @return the instance
+     */
+    public Instance instance(int num) {
+        return this.instances.get(num);
+    }
+
+    /**
+     * Num instances.
+     *
+     * @return the int
+     */
+    public int numInstances() {
+        return this.instances.size();
+    }
+
+    /**
+     * Adds the.
+     *
+     * @param inst the inst
+     */
+    public void add(Instance inst) {
+        this.instances.add(inst.copy());
+    }
+
+    /**
+     * Randomize.
+     *
+     * @param random the random
+     */
+    public void randomize(Random random) {
+        for (int j = numInstances() - 1; j > 0; j--) {
+            swap(j, random.nextInt(j + 1));
         }
-        int instAttIndex = attIndex;
-        return "[att " + (attIndex + 1) + ":"
-                + context.inputAttribute(instAttIndex).name() + "]";
-    }
-
-    // is impervious to class index changes - attIndex is true attribute index
-    // regardless of class position
-    public static String getNominalValueString(InstancesHeader context,
-            int attIndex, int valIndex) {
-        if (context != null) {
-            int instAttIndex = attIndex < context.classIndex() ? attIndex
-                    : attIndex + 1;
-            if ((instAttIndex < context.numAttributes())
-                    && (valIndex < context.attribute(instAttIndex).numValues())) {
-                return "{val " + (valIndex + 1) + ":"
-                        + context.attribute(instAttIndex).value(valIndex) + "}";
+    }
+
+    /**
+     * Stratify.
+     *
+     * @param numFolds the num folds
+     */
+    public void stratify(int numFolds) {
+
+        if (classAttribute().isNominal()) {
+
+            // sort by class
+            int index = 1;
+            while (index < numInstances()) {
+                Instance instance1 = instance(index - 1);
+                for (int j = index; j < numInstances(); j++) {
+                    Instance instance2 = instance(j);
+                    if ((instance1.classValue() == instance2.classValue())
+                            || (instance1.classIsMissing()
+                            && instance2.classIsMissing())) {
+                        swap(index, j);
+                        index++;
+                    }
+                }
+                index++;
             }
+            stratStep(numFolds);
         }
-        return "{val " + (valIndex + 1) + "}";
-    }
-
-    // is impervious to class index changes - attIndex is true attribute index
-    // regardless of class position
-    public static String getNumericValueString(InstancesHeader context,
-            int attIndex, double value) {
-        if (context != null) {
-            int instAttIndex = attIndex < context.classIndex() ? attIndex
-                    : attIndex + 1;
-            if (instAttIndex < context.numAttributes()) {
-                if (context.attribute(instAttIndex).isDate()) {
-                    return context.attribute(instAttIndex).formatDate(value);
-                }
+    }
+
+    protected void stratStep(int numFolds) {
+        ArrayList<Instance> newVec = new ArrayList<Instance>(this.instances.size());
+        int start = 0, j;
+
+        // create stratified batch
+        while (newVec.size() < numInstances()) {
+            j = start;
+            while (j < numInstances()) {
+                newVec.add(instance(j));
+                j = j + numFolds;
             }
+            start++;
+        }
+        this.instances = newVec;
+    }
+
+    /**
+     * Train cv.
+     *
+     * @param numFolds the num folds
+     * @param numFold
+     * @param n the n
+     * @param random the random
+     * @return the instances
+     */
+    public InstancesHeader trainCV(int numFolds, int numFold, Random random) {
+        InstancesHeader train = trainCV(numFolds, numFold);
+        train.randomize(random);
+        return train;
+    }
+
+    public InstancesHeader trainCV(int numFolds, int numFold) {
+        int numInstForFold, first, offset;
+        InstancesHeader train;
+
+        numInstForFold = numInstances() / numFolds;
+        if (numFold < numInstances() % numFolds) {
+            numInstForFold++;
+            offset = numFold;
+        } else {
+            offset = numInstances() % numFolds;
+        }
+        train = new InstancesHeader(this, numInstances() - numInstForFold);
+        first = numFold * (numInstances() / numFolds) + offset;
+        copyInstances(0, train, first);
+        copyInstances(first + numInstForFold, train,
+                numInstances() - first - numInstForFold);
+        return train;
+    }
+
+    protected void copyInstances(int from, InstancesHeader dest, int num) {
+        for (int i = 0; i < num; i++) {
+            dest.add(instance(from + i));
+        }
+    }
+
+    /**
+     * Test cv.
+     *
+     * @param numFolds the num folds
+     * @param numFold the num fold
+     * @return the instances
+     */
+    public InstancesHeader testCV(int numFolds, int numFold) {
+
+        int numInstForFold, first, offset;
+        InstancesHeader test;
+
+        numInstForFold = numInstances() / numFolds;
+        if (numFold < numInstances() % numFolds) {
+            numInstForFold++;
+            offset = numFold;
+        } else {
+            offset = numInstances() % numFolds;
         }
-        return Double.toString(value);
+        test = new InstancesHeader(this, numInstForFold);
+        first = numFold * (numInstances() / numFolds) + offset;
+        copyInstances(first, test, numInstForFold);
+        return test;
     }
 
-    public Attribute inputAttribute(int w) {
-        return this.instanceInformation.inputAttribute(w);
+    /*  public Instances dataset() {
+     throw new UnsupportedOperationException("Not yet implemented");
+     }*/
+    /**
+     * Mean or mode.
+     *
+     * @param j the j
+     * @return the double
+     */
+    public double meanOrMode(int j) {
+        throw new UnsupportedOperationException("Not yet implemented"); //CobWeb
     }
 
-    public Attribute outputAttribute(int w) {
-        return this.instanceInformation.outputAttribute(w);
+    /**
+     * Read instance.
+     *
+     * @param fileReader the file reader
+     * @return true, if successful
+     */
+    public boolean readInstance(Reader fileReader) {
+
+        //ArffReader arff = new ArffReader(reader, this, m_Lines, 1);
+        Instance inst = arff.readInstance();
+        if (inst != null) {
+            inst.setDataset(this);
+            add(inst);
+            return true;
+        } else {
+            return false;
+        }
     }
 
-    public int numInputAttributes() {
-        return this.instanceInformation.numInputAttributes();
+    /**
+     * Delete.
+     */
+    public void delete() {
+        this.instances = new ArrayList<Instance>();
+    }
+    
+     /**
+     * Delete.
+     */
+    public void delete(int index) {
+        this.instances.remove(index);
     }
 
-    public int numOutputAttributes() {
-        return this.instanceInformation.numOutputAttributes();
+
+    /**
+     * Swap.
+     *
+     * @param i the i
+     * @param j the j
+     */
+    public void swap(int i, int j) {
+        Instance in = instances.get(i);
+        instances.set(i, instances.get(j));
+        instances.set(j, in);
     }
 
-    public InstanceInformation getInstanceInformation() {
+    /**
+     * Instance information.
+     *
+     * @return the instance information
+     */
+    private InstanceInformation instanceInformation() {
         return this.instanceInformation;
     }
+
+    public Attribute attribute(String name) {
+
+        for (int i = 0; i < numAttributes(); i++) {
+            if (attribute(i).name().equals(name)) {
+                return attribute(i);
+            }
+        }
+        return null;
+    }
+
+    public int size() {
+        return this.numInstances();
+    }
+
+    public void set(int i, Instance inst) {
+        this.instances.set(i, inst);
+    }
+
+    public Instance get(int k) {
+        return this.instance(k);
+    }
+
+//	public void setRangeOutputIndices(Range range) {
+//		this.instanceInformation.setRangeOutputIndices(range);
+//		
+//	}
+	
+    public void setAttributes(List<Attribute> v) {
+    	if(this.instanceInformation==null)
+    		this.instanceInformation= new InstanceInformation();
+        this.instanceInformation.setAttributes(v);
+    }
+    
+    public void setAttributes(List<Attribute> v, List<Integer> indexValues) {
+    	if(this.instanceInformation==null)
+    		this.instanceInformation= new InstanceInformation();
+        this.instanceInformation.setAttributes(v, indexValues);
+    }
+    
+      /**
+   * Returns the dataset as a string in ARFF format. Strings
+   * are quoted if they contain whitespace characters, or if they
+   * are a question mark.
+   *
+   * @return the dataset in ARFF format as a string
+   */
+  public String toString() {
+    
+    StringBuffer text = new StringBuffer();
+    
+    text.append(ARFF_RELATION).append(" ").
+      append(Utils.quote( this.instanceInformation.getRelationName())).append("\n\n");
+    for (int i = 0; i < numAttributes(); i++) {
+      text.append(attribute(i).toString()).append("\n");
+    }
+    text.append("\n").append(ARFF_DATA).append("\n");
+
+    text.append(stringWithoutHeader());
+    return text.toString();
+  }
+  
+    /**
+   * Returns the instances in the dataset as a string in ARFF format. Strings
+   * are quoted if they contain whitespace characters, or if they
+   * are a question mark.
+   *
+   * @return the dataset in ARFF format as a string
+   */
+  protected String stringWithoutHeader() {
     
-    public AttributeStructure getInstanceStructure() {
-    	return this.instanceInformation.getStructure();
+    StringBuffer text = new StringBuffer();
+
+    for (int i = 0; i < numInstances(); i++) {
+      text.append(instance(i));
+      if (i < numInstances() - 1) {
+	text.append('\n');
+      }
     }
+    return text.toString();
+    
+  }
+
+	public Attribute inputAttribute(int w) {
+	    return this.instanceInformation.inputAttribute(w);
+	}
+
+	public Attribute outputAttribute(int w) {
+	    return this.instanceInformation.outputAttribute(w);
+	}
+
+	public int numInputAttributes() {
+	    return this.instanceInformation.numInputAttributes();
+	}
+
+	public int numOutputAttributes() {
+	    return this.instanceInformation.numOutputAttributes();
+	}
+
+	public InstanceInformation getInstanceInformation() {
+	    return this.instanceInformation;
+	}
+
+	public static String getClassNameString(InstancesHeader context) {
+	    if (context == null) {
+	        return "[class]";
+	    }
+	    return "[class:" + context.classAttribute().name() + "]";
+	}
+
+	public static String getClassLabelString(InstancesHeader context, int classLabelIndex) {
+	    if ((context == null) || (classLabelIndex >= context.numClasses())) {
+	        return "<class " + (classLabelIndex + 1) + ">";
+	    }
+	    return "<class " + (classLabelIndex + 1) + ":"
+	            + context.classAttribute().value(classLabelIndex) + ">";
+	}
+
+	public static String getAttributeNameString(InstancesHeader context, int attIndex) {
+	    if ((context == null) || (attIndex >= context.numAttributes())) {
+	        return "[att " + (attIndex + 1) + "]";
+	    }
+	    return "[att " + (attIndex + 1) + ":"
+	            + context.attribute(attIndex).name() + "]";
+	}
+
+	public static String getInputAttributeNameString(InstancesHeader context, int attIndex) {
+	    if ((context == null) || (attIndex >= context.numInputAttributes())) {
+	        return "[att " + (attIndex + 1) + "]";
+	    }
+	    return "[att " + (attIndex + 1) + ":"
+	            + context.inputAttribute(attIndex).name() + "]";
+	}
+
+	public static String getNominalValueString(InstancesHeader context, int attIndex, int valIndex) {
+	    if (context != null) {
+	        if ((attIndex < context.numInputAttributes())
+	                && (valIndex < context.inputAttribute(attIndex).numValues())) {
+	            return "{val " + (valIndex + 1) + ":"
+	                    + context.inputAttribute(attIndex).value(valIndex) + "}";
+	        }
+	    }
+	    return "{val " + (valIndex + 1) + "}";
+	}
+
+	public static String getNumericValueString(InstancesHeader context, int attIndex, double value) {
+	    if (context != null) {
+	        int instAttIndex = attIndex < context.classIndex() ? attIndex
+	                : attIndex + 1;
+	        if (instAttIndex < context.numAttributes()) {
+	            if (context.attribute(instAttIndex).isDate()) {
+	                return context.attribute(instAttIndex).formatDate(value);
+	            }
+	        }
+	    }
+	    return Double.toString(value);
+	}
+
+	
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiTargetArffLoader.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiTargetArffLoader.java
index fc7392e68..a0a4b0b48 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiTargetArffLoader.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiTargetArffLoader.java
@@ -19,24 +19,31 @@
 
 public class MultiTargetArffLoader extends ArffLoader {
 
-    public MultiTargetArffLoader(Reader reader) {
-        super(reader);
-    }
+	public MultiTargetArffLoader(Reader reader, String outputDefinition, String inputDefinition) {
+		super(reader, outputDefinition, inputDefinition);
+		// TODO Auto-generated constructor stub
+	}
 
-    public MultiTargetArffLoader(Reader reader, Range range) {
-        super(reader, range);
-    }
-
-    @Override
-    protected Instance newSparseInstance(double d, double[] res) {
-        return new SparseInstance(d, res); // TODO
-    }
-
-    @Override
-    protected Instance newDenseInstance(int numAttributes) {
-        // numAttributes is this.instanceInformation.numAttributes()
-        this.range.setUpper(numAttributes);
-        return new DenseInstance(numAttributes);
-    }
+// DEPRECATED
+	
+//    public MultiTargetArffLoader(Reader reader) {
+//        super(reader);
+//    }
+//
+//    public MultiTargetArffLoader(Reader reader, Range range) {
+//        super(reader, range);
+//    }
+//
+//    @Override
+//    protected Instance newSparseInstance(double d, double[] res) {
+//        return new SparseInstance(d, res); // TODO
+//    }
+//
+//    @Override
+//    protected Instance newDenseInstance(int numAttributes) {
+//        // numAttributes is this.instanceInformation.numAttributes()
+//        this.range.setUpper(numAttributes);
+//        return new DenseInstance(numAttributes);
+//    }
 
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/Range.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/Range.java
index ab27c38fb..d02e5fbbc 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/Range.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/Range.java
@@ -1,3 +1,4 @@
+
 /*
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/SamoaToWekaInstanceConverter.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/SamoaToWekaInstanceConverter.java
index f94851d93..3ef342875 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/SamoaToWekaInstanceConverter.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/SamoaToWekaInstanceConverter.java
@@ -77,7 +77,7 @@ public weka.core.Instance wekaInstance(Instance inst) {
      * @param instances the instances
      * @return the weka.core. instances
      */
-    public weka.core.Instances wekaInstances(Instances instances) {
+    public weka.core.Instances wekaInstances(InstancesHeader instances) {
         weka.core.Instances wekaInstances = wekaInstancesInformation(instances);
         //We assume that we have only one WekaInstanceInformation for SamoaToWekaInstanceConverter
         this.wekaInstanceInformation = wekaInstances;
@@ -93,7 +93,7 @@ public weka.core.Instances wekaInstances(Instances instances) {
      * @param instances the instances
      * @return the weka.core. instances
      */
-    public weka.core.Instances wekaInstancesInformation(Instances instances) {
+    public weka.core.Instances wekaInstancesInformation(InstancesHeader instances) {
         weka.core.Instances wekaInstances;
         ArrayList<weka.core.Attribute> attInfo = new ArrayList<weka.core.Attribute>();
         for (int i = 0; i < instances.numAttributes(); i++) {
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/StructuredInstance.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/StructuredInstance.java
index 279d6baed..9867f74ca 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/StructuredInstance.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/StructuredInstance.java
@@ -19,6 +19,9 @@
  * The Interface StructuredInstance.
  *
  * @author abifet
+ * 
+ * A placeholder for structured instances.
+ * 
  */
    
 public interface StructuredInstance extends Instance {
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/WekaToSamoaInstanceConverter.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/WekaToSamoaInstanceConverter.java
index f49d7397d..1937f6274 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/WekaToSamoaInstanceConverter.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/WekaToSamoaInstanceConverter.java
@@ -26,7 +26,7 @@
  */
 public class WekaToSamoaInstanceConverter implements Serializable{
 
-    protected Instances samoaInstanceInformation;
+    protected InstancesHeader samoaInstanceInformation;
     
     /**
      * Samoa instance from weka instance.
@@ -65,8 +65,8 @@ public Instance samoaInstance(weka.core.Instance inst) {
      * @param instances the instances
      * @return the instances
      */
-    public Instances samoaInstances(weka.core.Instances instances) {
-        Instances samoaInstances = samoaInstancesInformation(instances);
+    public InstancesHeader samoaInstances(weka.core.Instances instances) {
+        InstancesHeader samoaInstances = samoaInstancesInformation(instances);
         //We assume that we have only one samoaInstanceInformation for WekaToSamoaInstanceConverter
         this.samoaInstanceInformation = samoaInstances;
         for (int i = 0; i < instances.numInstances(); i++) {
@@ -81,13 +81,13 @@ public Instances samoaInstances(weka.core.Instances instances) {
      * @param instances the instances
      * @return the instances
      */
-    public Instances samoaInstancesInformation(weka.core.Instances instances) {
-        Instances samoaInstances;
+    public InstancesHeader samoaInstancesInformation(weka.core.Instances instances) {
+        InstancesHeader samoaInstances;
         List<Attribute> attInfo = new ArrayList<Attribute>();
         for (int i = 0; i < instances.numAttributes(); i++) {
             attInfo.add(samoaAttribute(i, instances.attribute(i)));
         }
-        samoaInstances = new Instances(instances.relationName(), attInfo, 0);
+        samoaInstances = new InstancesHeader(instances.relationName(), attInfo, 0);
         samoaInstances.setClassIndex(instances.classIndex());
         return samoaInstances;
     }
diff --git a/moa/src/main/java/moa/classifiers/AbstractClassifier.java b/moa/src/main/java/moa/classifiers/AbstractClassifier.java
index ee1c01c47..fb8daca38 100644
--- a/moa/src/main/java/moa/classifiers/AbstractClassifier.java
+++ b/moa/src/main/java/moa/classifiers/AbstractClassifier.java
@@ -44,7 +44,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstanceData;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 
@@ -68,7 +68,7 @@ public String getPurposeString() {
     protected int randomSeed = 1;
 
     /** Option for randomizable learners to change the random seed */
-    protected IntOption randomSeedOption;
+    public IntOption randomSeedOption;
 
     /** Random Generator used in randomizable learners  */
     public Random classifierRandom;
@@ -91,9 +91,9 @@ public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository)
         }
         
         // resetLearning should not be called if the classifier has not yet received the context
-//        if (!trainingHasStarted()) {
-//            resetLearning();
-//        }
+        if (!trainingHasStarted()) {
+            resetLearning();
+        }
     }
 
 	
@@ -120,7 +120,7 @@ public Prediction getPredictionForInstance(Instance inst){
     
     @Override
     public void setModelContext(InstancesHeader ih) {
-        if ((ih != null) && (ih.classIndex() < 0)) {
+        if ((ih != null) && (ih.numOutputAttributes() < 1)) {
             throw new IllegalArgumentException(
                     "Context for a classifier must include a class to learn");
         }
@@ -131,6 +131,10 @@ public void setModelContext(InstancesHeader ih) {
                     "New context is not compatible with existing model");
         }
         this.modelContext = ih;
+        this.modelContextSet();
+    }
+    
+    public void modelContextSet() {
     }
 
     @Override
@@ -170,7 +174,7 @@ public void resetLearning() {
     public void trainOnInstance(Instance inst) {
         boolean isTraining = (inst.weight() > 0.0);
         if (this instanceof SemiSupervisedLearner == false &&
-                inst.classIsMissing() == true){
+                inst.missingOutputs() == true){
             isTraining = false;
         }
         if (isTraining) {
@@ -430,7 +434,7 @@ protected static int modelAttIndexToInstanceAttIndex(int index,
      * @return the index of the attribute in the instances
      */
     protected static int modelAttIndexToInstanceAttIndex(int index,
-            Instances insts) {
+            InstancesHeader insts) {
         return insts.classIndex() > index ? index : index + 1;
     }
 }
diff --git a/moa/src/main/java/moa/classifiers/bayes/NaiveBayesMultinomial.java b/moa/src/main/java/moa/classifiers/bayes/NaiveBayesMultinomial.java
index 523e8d6c8..5e474770e 100644
--- a/moa/src/main/java/moa/classifiers/bayes/NaiveBayesMultinomial.java
+++ b/moa/src/main/java/moa/classifiers/bayes/NaiveBayesMultinomial.java
@@ -28,7 +28,7 @@
 import moa.core.StringUtils;
 import moa.core.Utils;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * <!-- globalinfo-start --> Class for building and using a multinomial Naive
@@ -77,7 +77,7 @@ public String getPurposeString() {
     /**
      * copy of header information for use in toString method
      */
-    protected Instances m_headerInfo;
+    protected InstancesHeader m_headerInfo;
 
     /**
      * number of class values
diff --git a/moa/src/main/java/moa/classifiers/core/conditionaltests/InstanceConditionalTest.java b/moa/src/main/java/moa/classifiers/core/conditionaltests/InstanceConditionalTest.java
index fad4d9a30..9d5160136 100644
--- a/moa/src/main/java/moa/classifiers/core/conditionaltests/InstanceConditionalTest.java
+++ b/moa/src/main/java/moa/classifiers/core/conditionaltests/InstanceConditionalTest.java
@@ -20,8 +20,9 @@
 package moa.classifiers.core.conditionaltests;
 
 import moa.AbstractMOAObject;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Abstract conditional test for instances to use to split nodes in Hoeffding trees.
diff --git a/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeBinaryTest.java b/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeBinaryTest.java
index 73498ff6b..519ec6a42 100644
--- a/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeBinaryTest.java
+++ b/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeBinaryTest.java
@@ -21,6 +21,7 @@
 
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Nominal binary conditional test for instances to use to split nodes in Hoeffding trees.
diff --git a/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeMultiwayTest.java b/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeMultiwayTest.java
index 003cf416c..a0dd5ff7b 100644
--- a/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeMultiwayTest.java
+++ b/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeMultiwayTest.java
@@ -21,6 +21,7 @@
 
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Nominal multi way conditional test for instances to use to split nodes in Hoeffding trees.
diff --git a/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java b/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
index d8cb5e8c3..597a7c07f 100644
--- a/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
+++ b/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
@@ -21,6 +21,7 @@
 
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Numeric binary conditional test for instances to use to split nodes in Hoeffding trees.
diff --git a/moa/src/main/java/moa/classifiers/lazy/kNN.java b/moa/src/main/java/moa/classifiers/lazy/kNN.java
index da99909e9..1cf765b1d 100644
--- a/moa/src/main/java/moa/classifiers/lazy/kNN.java
+++ b/moa/src/main/java/moa/classifiers/lazy/kNN.java
@@ -24,7 +24,6 @@
 import moa.classifiers.lazy.neighboursearch.NearestNeighbourSearch;
 import moa.core.Measurement;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.MultiChoiceOption;
@@ -62,12 +61,12 @@ public String getPurposeString() {
         return "kNN: special.";
     }
 
-    protected Instances window; 
+    protected InstancesHeader window; 
 
 	@Override
 	public void setModelContext(InstancesHeader context) {
 		try {
-			this.window = new Instances(context,0); //new StringReader(context.toString())
+			this.window = new InstancesHeader(context,0); //new StringReader(context.toString())
 			this.window.setClassIndex(context.classIndex());
 		} catch(Exception e) {
 			System.err.println("Error: no Model Context available.");
@@ -86,7 +85,7 @@ public void trainOnInstanceImpl(Instance inst) {
 		if (inst.classValue() > C)
 			C = (int)inst.classValue();
 		if (this.window == null) {
-			this.window = new Instances(inst.dataset());
+			this.window = new InstancesHeader(inst.dataset());
 		}
 		if (this.limitOption.getValue() <= this.window.numInstances()) {
 			this.window.delete(0);
@@ -106,7 +105,7 @@ public double[] getVotesForInstance(Instance inst) {
 				search.setInstances(this.window);
 			}	
 			if (this.window.numInstances()>0) {	
-				Instances neighbours = search.kNearestNeighbours(inst,Math.min(kOption.getValue(),this.window.numInstances()));
+				InstancesHeader neighbours = search.kNearestNeighbours(inst,Math.min(kOption.getValue(),this.window.numInstances()));
 				for(int i = 0; i < neighbours.numInstances(); i++) {
 					v[(int)neighbours.instance(i).classValue()]++;
 				}
diff --git a/moa/src/main/java/moa/classifiers/lazy/kNNwithPAW.java b/moa/src/main/java/moa/classifiers/lazy/kNNwithPAW.java
index 9d7103053..6b78777a3 100644
--- a/moa/src/main/java/moa/classifiers/lazy/kNNwithPAW.java
+++ b/moa/src/main/java/moa/classifiers/lazy/kNNwithPAW.java
@@ -19,7 +19,7 @@
 
 import moa.classifiers.core.driftdetection.ADWIN;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * k Nearest Neighbor ADAPTIVE with PAW.<p>
@@ -57,7 +57,7 @@ public void trainOnInstanceImpl(Instance inst) {
             C = (int) inst.classValue();
         }
         if (this.window == null) {
-            this.window = new Instances(inst.dataset());
+            this.window = new InstancesHeader(inst.dataset());
         }
 
         for (int i = 0; i < this.window.size(); i++) {
diff --git a/moa/src/main/java/moa/classifiers/lazy/kNNwithPAWandADWIN.java b/moa/src/main/java/moa/classifiers/lazy/kNNwithPAWandADWIN.java
index 1ff1b2412..65e9266ed 100644
--- a/moa/src/main/java/moa/classifiers/lazy/kNNwithPAWandADWIN.java
+++ b/moa/src/main/java/moa/classifiers/lazy/kNNwithPAWandADWIN.java
@@ -20,7 +20,7 @@
 import java.util.ArrayList;
 import moa.classifiers.core.driftdetection.ADWIN;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * k Nearest Neighbor ADAPTIVE with ADWIN+PAW.<p>
@@ -67,7 +67,7 @@ public void trainOnInstanceImpl(Instance inst) {
         }
         // ADWIN
         if (this.window == null) {
-            this.window = new Instances(inst.dataset());
+            this.window = new InstancesHeader(inst.dataset());
         }
 
         if (this.timeStamp == null) {
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/DistanceFunction.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/DistanceFunction.java
index 9df3b3a4c..ef0723941 100644
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/DistanceFunction.java
+++ b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/DistanceFunction.java
@@ -22,7 +22,7 @@
 package moa.classifiers.lazy.neighboursearch;
 
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Interface for any class that can compute and return distances between two
@@ -38,14 +38,14 @@ public interface DistanceFunction  {
    * 
    * @param insts 	the instances to use
    */
-  public void setInstances(Instances insts);
+  public void setInstances(InstancesHeader insts);
 
   /**
    * returns the instances currently set.
    * 
    * @return 		the current instances
    */
-  public Instances getInstances();
+  public InstancesHeader getInstances();
 
   /**
    * Sets the range of attributes to use in the calculation of the distance.
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/EuclideanDistance.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/EuclideanDistance.java
index f21197d81..ac9743bbc 100644
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/EuclideanDistance.java
+++ b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/EuclideanDistance.java
@@ -22,7 +22,7 @@
 package moa.classifiers.lazy.neighboursearch;
 
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  <!-- globalinfo-start -->
@@ -92,7 +92,7 @@ public EuclideanDistance() {
    * 
    * @param data 	the instances the distance function should work on
    */
-  public EuclideanDistance(Instances data) {
+  public EuclideanDistance(InstancesHeader data) {
     super(data);
   }
 
@@ -195,7 +195,7 @@ public double getMiddle(double[] ranges) {
    * @return 		the index of the closest point
    * @throws Exception	if something goes wrong
    */
-  public int closestPoint(Instance instance, Instances allPoints,
+  public int closestPoint(Instance instance, InstancesHeader allPoints,
       			  int[] pointList) throws Exception {
     double minDist = Integer.MAX_VALUE;
     int bestPoint = 0;
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/KDTree.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/KDTree.java
index 3a44f2b70..b3b6d7a0d 100644
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/KDTree.java
+++ b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/KDTree.java
@@ -27,7 +27,7 @@
 import moa.classifiers.lazy.neighboursearch.kdtrees.KDTreeNodeSplitter;
 import moa.classifiers.lazy.neighboursearch.kdtrees.SlidingMidPointOfWidestSide;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 
 
@@ -151,7 +151,7 @@ public KDTree() {
    * @param insts The instances/points on which the BallTree 
    * should be built on.
    */
-  public KDTree(Instances insts) {
+  public KDTree(InstancesHeader insts) {
     super(insts);
   }
 
@@ -166,7 +166,7 @@ public KDTree(Instances insts) {
    * @param instances	The instances to build the tree on
    * @throws Exception	if something goes wrong
    */
-  protected void buildKDTree(Instances instances) throws Exception {
+  protected void buildKDTree(InstancesHeader instances) throws Exception {
 
     checkMissing(instances);
     if (m_EuclideanDistance == null)
@@ -325,13 +325,13 @@ protected void findNearestNeighbours(Instance target, KDTreeNode node, int k,
    * one neighbours at the kth boundary). 
    * @throws Exception 	if the nearest neighbour could not be found.
    */
-  public Instances kNearestNeighbours(Instance target, int k) throws Exception {
+  public InstancesHeader kNearestNeighbours(Instance target, int k) throws Exception {
     checkMissing(target);
     
     MyHeap heap = new MyHeap(k);
     findNearestNeighbours(target, m_Root, k, heap, 0.0);
 
-    Instances neighbours = new Instances(m_Instances, (heap.size() + heap
+    InstancesHeader neighbours = new InstancesHeader(m_Instances, (heap.size() + heap
         .noOfKthNearest()));
     m_DistanceList = new double[heap.size() + heap.noOfKthNearest()];
     int[] indices = new int[heap.size() + heap.noOfKthNearest()];
@@ -399,7 +399,7 @@ public double[] getDistances() throws Exception {
    * @throws Exception If some error occurs while 
    * building the KDTree
    */
-  public void setInstances(Instances instances) throws Exception {
+  public void setInstances(InstancesHeader instances) throws Exception {
     super.setInstances(instances);
     buildKDTree(instances);
   }
@@ -527,7 +527,7 @@ public void addInstanceInfo(Instance instance) {
    * @param instances	the instances to check
    * @throws Exception	if missing values are encountered
    */
-  protected void checkMissing(Instances instances) throws Exception {
+  protected void checkMissing(InstancesHeader instances) throws Exception {
     for (int i = 0; i < instances.numInstances(); i++) {
       Instance ins = instances.instance(i);
       for (int j = 0; j < ins.numValues(); j++) {
@@ -698,7 +698,7 @@ public void setMeasurePerformance(boolean measurePerformance) {
    * @throws Exception If there is some problem 
    * assigning instances to centers.
    */
-  public void centerInstances(Instances centers, int[] assignments, double pc)
+  public void centerInstances(InstancesHeader centers, int[] assignments, double pc)
       throws Exception {
 
     int[] centList = new int[centers.numInstances()];
@@ -719,7 +719,7 @@ public void centerInstances(Instances centers, int[] assignments, double pc)
    * @throws Exception If there is some problem assigning 
    * instances to centers.
    */
-  protected void determineAssignments(KDTreeNode node, Instances centers,
+  protected void determineAssignments(KDTreeNode node, InstancesHeader centers,
       int[] candidates, int[] assignments, double pc) throws Exception {
 
     // reduce number of owners for current hyper rectangle
@@ -752,7 +752,7 @@ protected void determineAssignments(KDTreeNode node, Instances centers,
    * @return list of owners
    * @throws Exception If some problem occurs in refining.
    */
-  protected int[] refineOwners(KDTreeNode node, Instances centers,
+  protected int[] refineOwners(KDTreeNode node, InstancesHeader centers,
       int[] candidates) throws Exception {
 
     int[] owners = new int[candidates.length];
@@ -907,7 +907,7 @@ protected boolean candidateIsFullOwner(KDTreeNode node, Instance candidate,
    * @param assignments	index list of last assignments
    * @throws Exception If there is error assigning the instances.
    */
-  public void assignSubToCenters(KDTreeNode node, Instances centers,
+  public void assignSubToCenters(KDTreeNode node, InstancesHeader centers,
       int[] centList, int[] assignments) throws Exception {
     // todo: undecided situations
     int numCent = centList.length;
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/LinearNNSearch.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/LinearNNSearch.java
index 59b1f07bb..3c51f26c5 100644
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/LinearNNSearch.java
+++ b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/LinearNNSearch.java
@@ -22,7 +22,7 @@
 
 
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 //import weka.core.Option;
 //import weka.core.RevisionUtils;
 //import weka.core.Utils;
@@ -73,7 +73,7 @@ public LinearNNSearch() {
    * 
    * @param insts	the instances to use
    */
-  public LinearNNSearch(Instances insts) {
+  public LinearNNSearch(InstancesHeader insts) {
     super(insts);
     m_DistanceFunction.setInstances(insts);
   }
@@ -143,7 +143,7 @@ public Instance nearestNeighbour(Instance target) throws Exception {
    * @return		the k nearest neighbors
    * @throws Exception  if the neighbours could not be found.
    */
-  public Instances kNearestNeighbours(Instance target, int kNN) throws Exception {
+  public InstancesHeader kNearestNeighbours(Instance target, int kNN) throws Exception {
   
     //debug
     boolean print=false;
@@ -182,7 +182,7 @@ else if(distance == temp.distance) {
       }
     }
     
-    Instances neighbours = new Instances(m_Instances, (heap.size()+heap.noOfKthNearest()));
+    InstancesHeader neighbours = new InstancesHeader(m_Instances, (heap.size()+heap.noOfKthNearest()));
     m_Distances = new double[heap.size()+heap.noOfKthNearest()];
     int [] indices = new int[heap.size()+heap.noOfKthNearest()];
     int i=1; MyHeapElement h;
@@ -240,7 +240,7 @@ public double[] getDistances() throws Exception {
    * 			training set. 
    * @throws Exception	if setting of instances fails
    */
-  public void setInstances(Instances insts) throws Exception {
+  public void setInstances(InstancesHeader insts) throws Exception {
     m_Instances = insts;
     m_DistanceFunction.setInstances(insts);
   }
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NearestNeighbourSearch.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NearestNeighbourSearch.java
index 5b8402c35..ddefd58ae 100644
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NearestNeighbourSearch.java
+++ b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NearestNeighbourSearch.java
@@ -22,7 +22,7 @@
 
 import java.io.Serializable;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Abstract class for nearest neighbour search. All algorithms (classes) that
@@ -482,7 +482,7 @@ public NeighborNode getLast() {
   }
   
   /** The neighbourhood of instances to find neighbours in. */
-  protected Instances m_Instances;
+  protected InstancesHeader m_Instances;
   
   /** The number of neighbours to find. */
   protected int m_kNN;
@@ -504,7 +504,7 @@ public NearestNeighbourSearch() {
    * 
    * @param insts 	The set of instances that constitute the neighbourhood.
    */
-  public NearestNeighbourSearch(Instances insts) {
+  public NearestNeighbourSearch(InstancesHeader insts) {
     this();
     m_Instances = insts;
   }
@@ -592,7 +592,7 @@ public boolean getMeasurePerformance() {
    * @return		the k nearest neighbors
    * @throws Exception 	if the neighbours could not be found.
    */
-  public abstract Instances kNearestNeighbours(Instance target, int k) throws Exception;
+  public abstract InstancesHeader kNearestNeighbours(Instance target, int k) throws Exception;
  
   /**
    * Returns the distances of the k nearest neighbours. The kNearestNeighbours
@@ -629,7 +629,7 @@ public void addInstanceInfo(Instance ins) {
    * @param insts	the instances to use
    * @throws Exception	if setting fails
    */
-  public void setInstances(Instances insts) throws Exception {
+  public void setInstances(InstancesHeader insts) throws Exception {
     m_Instances = insts;
   }
   
@@ -638,7 +638,7 @@ public void setInstances(Instances insts) throws Exception {
    * 
    * @return		the current instances
    */
-  public Instances getInstances() {
+  public InstancesHeader getInstances() {
     return m_Instances;
   }
 
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NormalizableDistance.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NormalizableDistance.java
index 0c815a686..7800a8576 100644
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NormalizableDistance.java
+++ b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NormalizableDistance.java
@@ -23,7 +23,7 @@
 
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Represents the abstract ancestor for normalizable distance functions, like
@@ -48,7 +48,7 @@ public abstract class NormalizableDistance
   public static final int R_WIDTH = 2;
 
   /** the instances used internally. */
-  protected Instances m_Data = null;
+  protected InstancesHeader m_Data = null;
 
   /** True if normalization is turned off (default false).*/
   protected boolean m_DontNormalize = false;
@@ -78,7 +78,7 @@ public NormalizableDistance() {
    * 
    * @param data 	the instances the distance function should work on
    */
-  public NormalizableDistance(Instances data) {
+  public NormalizableDistance(InstancesHeader data) {
     setInstances(data);
   }
   
@@ -230,7 +230,7 @@ protected void initializeAttributeIndices() {
    * 
    * @param insts 	the instances to use
    */
-  public void setInstances(Instances insts) {
+  public void setInstances(InstancesHeader insts) {
     m_Data = insts;
     invalidate();
   }
@@ -240,7 +240,7 @@ public void setInstances(Instances insts) {
    * 
    * @return 		the current instances
    */
-  public Instances getInstances() {
+  public InstancesHeader getInstances() {
     return m_Data;
   }
 
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KDTreeNodeSplitter.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KDTreeNodeSplitter.java
index 431cfd972..f69760c9f 100644
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KDTreeNodeSplitter.java
+++ b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KDTreeNodeSplitter.java
@@ -25,7 +25,7 @@
 import java.util.Vector;
 import moa.classifiers.lazy.neighboursearch.EuclideanDistance;
 
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Class that splits up a KDTreeNode.
@@ -37,7 +37,7 @@ public abstract class KDTreeNodeSplitter
   implements Serializable {
   
   /** The instances that'll be used for tree construction. */
-  protected Instances m_Instances;
+  protected InstancesHeader m_Instances;
   
   /** The distance function used for building the tree. */
   protected EuclideanDistance m_EuclideanDistance;
@@ -78,7 +78,7 @@ public KDTreeNodeSplitter() {
    * @param e The EuclideanDistance object that is used
    * in tree contruction.
    */
-  public KDTreeNodeSplitter(int[] instList, Instances insts, EuclideanDistance e) { 
+  public KDTreeNodeSplitter(int[] instList, InstancesHeader insts, EuclideanDistance e) { 
     m_InstList = instList;
     m_Instances = insts;
     m_EuclideanDistance = e;
@@ -155,7 +155,7 @@ public abstract void splitNode(KDTreeNode node, int numNodesCreated,
    * to be) built. 
    * @param inst The training instances.
    */
-  public void setInstances(Instances inst) {
+  public void setInstances(InstancesHeader inst) {
     m_Instances = inst;
   }
   
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KMeansInpiredMethod.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KMeansInpiredMethod.java
index 6e19a86a0..6d834c9be 100644
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KMeansInpiredMethod.java
+++ b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KMeansInpiredMethod.java
@@ -21,7 +21,7 @@
 package moa.classifiers.lazy.neighboursearch.kdtrees;
 
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  <!-- globalinfo-start -->
@@ -227,7 +227,7 @@ public void splitNode(KDTreeNode node, int numNodesCreated,
    * that should be partitioned.
    * @return the index of the middle element
    */
-  protected static int partition(Instances insts, int[] index, int attidx, int l, int r) {
+  protected static int partition(InstancesHeader insts, int[] index, int attidx, int l, int r) {
     
     double pivot = insts.instance(index[(l + r) / 2]).value(attidx);
     int help;
@@ -270,7 +270,7 @@ protected static int partition(Instances insts, int[] index, int attidx, int l,
    * @param right The end index of the portion of the master index 
    * array that needs to be sorted.
    */
-  protected static void quickSort(Instances insts, int[] indices, int attidx, int left, int right) {
+  protected static void quickSort(InstancesHeader insts, int[] indices, int attidx, int left, int right) {
 
     if (left < right) {
       int middle = partition(insts, indices, attidx, left, right);
@@ -295,7 +295,7 @@ protected static void quickSort(Instances insts, int[] indices, int attidx, int
    * @throws Exception If the indices of the instances 
    * are not in sorted order.
    */
-  private static void checkSort(Instances insts, int[] indices, int attidx, 
+  private static void checkSort(InstancesHeader insts, int[] indices, int attidx, 
                                int start, int end) throws Exception {
     for(int i=start+1; i<=end; i++) {
       if( insts.instance(indices[i-1]).value(attidx) > 
diff --git a/moa/src/main/java/moa/classifiers/meta/ADACC.java b/moa/src/main/java/moa/classifiers/meta/ADACC.java
index 3c000f353..8aa324af8 100644
--- a/moa/src/main/java/moa/classifiers/meta/ADACC.java
+++ b/moa/src/main/java/moa/classifiers/meta/ADACC.java
@@ -23,7 +23,7 @@
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.classifiers.Classifier;
 import moa.core.Measurement;
 
@@ -74,7 +74,7 @@ public String getPurposeString() {
     /**
      * Last chunk of data of size (tau_size) to compute the stability index   
      */
-    protected Instances recentChunk;
+    protected InstancesHeader recentChunk;
     /**
      * Threshold values for the stability index and concept equivalence
      */
@@ -112,7 +112,7 @@ protected void initVariables(){
     public void trainOnInstanceImpl(Instance inst) {
 	
     	if (recentChunk == null)
-            recentChunk = new Instances(this.getModelContext());
+            recentChunk = new InstancesHeader(this.getModelContext());
     	
     	if (recentChunk.size() < this.tau_size)
     		recentChunk.add(inst);
diff --git a/moa/src/main/java/moa/classifiers/meta/AccuracyUpdatedEnsemble.java b/moa/src/main/java/moa/classifiers/meta/AccuracyUpdatedEnsemble.java
index c017c5fe7..f9764fa19 100644
--- a/moa/src/main/java/moa/classifiers/meta/AccuracyUpdatedEnsemble.java
+++ b/moa/src/main/java/moa/classifiers/meta/AccuracyUpdatedEnsemble.java
@@ -29,7 +29,7 @@
 import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * The revised version of the Accuracy Updated Ensemble as proposed by
@@ -94,7 +94,7 @@ public class AccuracyUpdatedEnsemble extends AbstractClassifier {
 	/**
 	 * Current chunk of instances.
 	 */
-	protected Instances currentChunk;
+	protected InstancesHeader currentChunk;
 
 	@Override
 	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
@@ -247,7 +247,7 @@ protected double computeMseR() {
 	 * @param chunk chunk of examples
 	 * @return the computed error.
 	 */
-	protected double computeMse(Classifier learner, Instances chunk) {
+	protected double computeMse(Classifier learner, InstancesHeader chunk) {
 		double mse_i = 0;
 
 		double f_ci;
@@ -348,7 +348,7 @@ private int getPoorestClassifierIndex() {
 	 */
 	private void initVariables() {
 		if (this.currentChunk == null) {
-			this.currentChunk = new Instances(this.getModelContext());
+			this.currentChunk = new InstancesHeader(this.getModelContext());
 		}
 
 		if (this.classDistributions == null) {
diff --git a/moa/src/main/java/moa/classifiers/meta/AccuracyWeightedEnsemble.java b/moa/src/main/java/moa/classifiers/meta/AccuracyWeightedEnsemble.java
index ddcd76d70..df7e6fea1 100644
--- a/moa/src/main/java/moa/classifiers/meta/AccuracyWeightedEnsemble.java
+++ b/moa/src/main/java/moa/classifiers/meta/AccuracyWeightedEnsemble.java
@@ -30,7 +30,7 @@
 import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.Utils;
 
 /**
@@ -119,7 +119,7 @@ public int compare(double[] o1, double[] o2) {
 
     protected Classifier candidateClassifier;
 
-    protected Instances currentChunk;
+    protected InstancesHeader currentChunk;
 
     @Override
     public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
@@ -168,7 +168,7 @@ public void trainOnInstanceImpl(Instance inst) {
      */
     private void initVariables() {
         if (this.currentChunk == null) {
-            this.currentChunk = new Instances(this.getModelContext());
+            this.currentChunk = new InstancesHeader(this.getModelContext());
         }
 
         if (this.classDistributions == null) {
@@ -243,18 +243,18 @@ protected void processChunk() {
      * @param useMseR Determines whether to use the MSEr threshold.
      * @return Candidate classifier weight.
      */
-    protected double computeCandidateWeight(Classifier candidate, Instances chunk, int numFolds) {
+    protected double computeCandidateWeight(Classifier candidate, InstancesHeader chunk, int numFolds) {
         double candidateWeight = 0.0;
         Random random = new Random(1);
-        Instances randData = new Instances(chunk);
+        InstancesHeader randData = new InstancesHeader(chunk);
         randData.randomize(random);
         if (randData.classAttribute().isNominal()) {
             randData.stratify(numFolds);
         }
 
         for (int n = 0; n < numFolds; n++) {
-            Instances train = randData.trainCV(numFolds, n, random);
-            Instances test = randData.testCV(numFolds, n);
+            InstancesHeader train = randData.trainCV(numFolds, n, random);
+            InstancesHeader test = randData.testCV(numFolds, n);
 
             Classifier learner = candidate.copy();
 
@@ -282,7 +282,7 @@ protected double computeCandidateWeight(Classifier candidate, Instances chunk, i
      * @param useMseR Determines whether to use the MSEr threshold.
      * @return The given classifier's weight.
      */
-    protected double computeWeight(Classifier learner, Instances chunk) {
+    protected double computeWeight(Classifier learner, InstancesHeader chunk) {
         double mse_i = 0;
         double mse_r = 0;
 
diff --git a/moa/src/main/java/moa/classifiers/meta/RandomRules.java b/moa/src/main/java/moa/classifiers/meta/RandomRules.java
index 694b8b37e..e170e1ef7 100644
--- a/moa/src/main/java/moa/classifiers/meta/RandomRules.java
+++ b/moa/src/main/java/moa/classifiers/meta/RandomRules.java
@@ -25,7 +25,7 @@
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import moa.classifiers.AbstractClassifier;
@@ -174,7 +174,7 @@ protected Instance transformInstance(Instance inst, int classifierIndex) {
 				//System.out.println("Number of attributes: "+this.numAttributes+ ","+inst.numAttributes()); //JD
 				System.out.println("Number of attributes: "+this.numAttributes+ ","+(inst.numAttributes()-1));
 				attributes.addElement(inst.classAttribute());
-				this.dataset[ensembleIndex] =  new InstancesHeader(new Instances(
+				this.dataset[ensembleIndex] =  new InstancesHeader(new InstancesHeader(
 						getCLICreationString(InstanceStream.class), attributes, 0));
 				this.dataset[ensembleIndex].setClassIndex(this.numAttributes);
 				this.ensemble[ensembleIndex].setModelContext(this.dataset[ensembleIndex]);
diff --git a/moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java b/moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java
index c39b0ae84..eac49168d 100644
--- a/moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java
+++ b/moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java
@@ -25,13 +25,15 @@
 import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
-
-import com.yahoo.labs.samoa.instances.*;
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
 import moa.core.Measurement;
 import moa.core.Utils;
 import moa.options.ClassOption;
+import com.yahoo.labs.samoa.instances.Attribute;
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Include labels of previous instances into the training data
@@ -63,7 +65,7 @@ public String getPurposeString() {
     
     protected double[] oldLabels;
     
-    protected Instances header;
+    protected InstancesHeader header;
 
     public FlagOption labelDelayOption = new FlagOption("labelDelay", 'd',
         "Labels arrive with Delay. Use predictions instead of true Labels.");
@@ -95,7 +97,7 @@ public void addOldLabel(double newPrediction) {
         }
     }
 
-    public void initHeader(Instances dataset) {
+    public void initHeader(InstancesHeader dataset) {
         int numLabels = this.numOldLabelsOption.getValue();
         Attribute target = dataset.classAttribute();
 
@@ -122,14 +124,13 @@ public void initHeader(Instances dataset) {
                 attrs.add(newAttribute);
             }
         }
-        this.header = new Instances("extended_" + dataset.getRelationName(), attrs, 0);
+        this.header = new InstancesHeader("extended_" + dataset.getRelationName(), attrs, 0);
         this.header.setClassIndex(numLabels + dataset.classIndex());
     }
 
     public Instance extendWithOldLabels(Instance instance) {
         if (this.header == null) {
             initHeader(instance.dataset());
-            this.baseLearner.setModelContext(new InstancesHeader(this.header));
         }
         int numLabels = this.oldLabels.length;
         if (numLabels == 0) {
diff --git a/moa/src/main/java/moa/classifiers/meta/WEKAClassifier.java b/moa/src/main/java/moa/classifiers/meta/WEKAClassifier.java
index 13bb3e338..d9ac321c8 100644
--- a/moa/src/main/java/moa/classifiers/meta/WEKAClassifier.java
+++ b/moa/src/main/java/moa/classifiers/meta/WEKAClassifier.java
@@ -27,7 +27,7 @@
 import weka.classifiers.Classifier;
 import weka.classifiers.UpdateableClassifier;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
 
 /**
diff --git a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
index 4c78071f9..070665e55 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
@@ -7,6 +7,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
diff --git a/moa/src/main/java/moa/classifiers/multilabel/MEKAClassifier.java b/moa/src/main/java/moa/classifiers/multilabel/MEKAClassifier.java
index 8d5aed722..0544bdfb9 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/MEKAClassifier.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/MEKAClassifier.java
@@ -30,7 +30,7 @@
 import weka.classifiers.Classifier;
 import weka.classifiers.UpdateableClassifier;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
 
 import com.yahoo.labs.samoa.instances.StructuredInstance;
@@ -90,7 +90,7 @@ public void resetLearningImpl() {
     }
 
 	@Override
-	public void trainOnInstanceImpl(MultiLabelInstance samoaInstance) {
+	public void trainOnInstanceImpl(StructuredInstance samoaInstance) {
 
 		// Convert Samoa instance to Weka instance (as used in Meka)
 		L = samoaInstance.numberOutputTargets();
@@ -168,7 +168,7 @@ public double[] getVotesForInstance(Instance samoaInstance) {
 	}
 
 	@Override
-	public Prediction getPredictionForInstance(MultiLabelInstance samoaInstance) {
+	public Prediction getPredictionForInstance(StructuredInstance samoaInstance) {
 
 		MultiLabelPrediction prediction = new MultiLabelPrediction(L);
 
diff --git a/moa/src/main/java/moa/classifiers/multilabel/MajorityLabelset.java b/moa/src/main/java/moa/classifiers/multilabel/MajorityLabelset.java
index 23cea6b0b..135f8f88e 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/MajorityLabelset.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/MajorityLabelset.java
@@ -80,16 +80,7 @@ public void trainOnInstanceImpl(StructuredInstance x) {
     }
 
     @Override
-    //public double[] getVotesForInstance(Instance x) {
     public Prediction getPredictionForInstance(StructuredInstance x){
-        
-		System.out.println("-------- start MC vote   ---------------");
-        int L = x.numOutputAttributes(); //x.classIndex() + 1;
-        if (m_L != L) {
-            System.err.println("set L = " + L);
-            m_L = L;
-            predictionArray = new double[m_L];
-        }
 
 		if (this.majorityLabelset == null)  {
 			int L = x.numberOutputTargets();
diff --git a/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java b/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java
index 08a7141ac..9a8bf0e96 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java
@@ -28,7 +28,6 @@
 import moa.core.StringUtils;
 import moa.core.utils.Converter;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
@@ -212,7 +211,7 @@ public void trainOnInstance(Instance inst) {
 		boolean isTraining = (inst.weight() > 0.0);
 		if (isTraining) {
 			this.trainingWeightSeenByModel += inst.weight();
-			trainOnInstanceImpl((MultiLabelInstance) inst);
+			trainOnInstanceImpl((StructuredInstance) inst);
 		}
 	}
 
diff --git a/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagAdwinML.java b/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagAdwinML.java
index d07673f02..a94b89b6f 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagAdwinML.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagAdwinML.java
@@ -25,7 +25,7 @@
 import moa.core.InstanceExample;
 import moa.core.MiscUtils;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 import moa.classifiers.MultiLabelLearner;
@@ -84,7 +84,7 @@ public void trainOnInstanceImpl(Instance inst) {
 	}
 
 	@Override
-	public void trainOnInstanceImpl(MultiLabelInstance instance) {
+	public void trainOnInstanceImpl(StructuredInstance instance) {
 		trainOnInstanceImpl((Instance) instance);
 	}
 
@@ -101,7 +101,7 @@ public double[] getVotesForInstance(Instance inst) {
 	}
 
 	@Override
-	public Prediction getPredictionForInstance(MultiLabelInstance instance) {
+	public Prediction getPredictionForInstance(StructuredInstance instance) {
 		return getPredictionForInstance((new InstanceExample(instance)));
 	}
 
diff --git a/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagML.java b/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagML.java
index 66c9c470a..20acefa4e 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagML.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagML.java
@@ -22,7 +22,7 @@
 import moa.classifiers.meta.OzaBag;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 import moa.classifiers.MultiLabelLearner;
@@ -43,7 +43,7 @@ public class OzaBagML extends OzaBag implements MultiLabelLearner, MultiTargetRe
 
 	//Training
 	@Override
-	public void trainOnInstanceImpl(MultiLabelInstance inst) {
+	public void trainOnInstanceImpl(StructuredInstance inst) {
 		trainOnInstanceImpl((Instance) inst);
 	}
 
@@ -119,7 +119,7 @@ public static double[] compileVotes(Classifier h[], Instance inst) {
 	}
 
 	 @Override
-    public Prediction getPredictionForInstance(MultiLabelInstance instance) {
+    public Prediction getPredictionForInstance(StructuredInstance instance) {
         return getPredictionForInstance((new InstanceExample(instance)));
     }
 
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
index db8bf9843..28b52d3b9 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
@@ -795,6 +795,11 @@ public void resetLearningImpl() {
 
 		sumOfAttrValues = new DoubleVector();
 		sumOfAttrSquares = new DoubleVector();
+		
+	}
+	
+	@Override
+	public void modelContextSet() {
 		loadWeights();
 	}
 
diff --git a/moa/src/main/java/moa/classifiers/multitarget/BasicMultiTargetRegressor.java b/moa/src/main/java/moa/classifiers/multitarget/BasicMultiTargetRegressor.java
index 93c1c94a1..edad24332 100644
--- a/moa/src/main/java/moa/classifiers/multitarget/BasicMultiTargetRegressor.java
+++ b/moa/src/main/java/moa/classifiers/multitarget/BasicMultiTargetRegressor.java
@@ -14,7 +14,7 @@
 
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
@@ -77,7 +77,7 @@ protected Instance transformInstance(StructuredInstance inst, int outputIndex) {
 			}
 			//System.out.println("Number of attributes: "+this.numAttributes+ ","+inst.numAttributes());
 			attributes.addElement(inst.outputAttribute(outputIndex));
-			this.header[outputIndex] =  new InstancesHeader(new Instances(
+			this.header[outputIndex] =  new InstancesHeader(new InstancesHeader(
 					getCLICreationString(InstanceStream.class), attributes, 0));
 			this.header[outputIndex].setClassIndex(attributes.size()-1);
 			this.ensemble[outputIndex].setModelContext(this.header[outputIndex]);
diff --git a/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java
index fb5505ef7..7e5febe56 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java
@@ -2,6 +2,7 @@
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.AbstractMOAObject;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java
index 8387610c0..a6b313c12 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java
@@ -2,6 +2,7 @@
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.AbstractMOAObject;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java
index df2405a5a..93d962149 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java
@@ -21,6 +21,7 @@
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import moa.classifiers.core.conditionaltests.NominalAttributeBinaryTest;
 import moa.classifiers.rules.core.Predicate;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java
index 37650e7ca..ff4c0c350 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java
@@ -21,6 +21,7 @@
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import moa.classifiers.core.conditionaltests.InstanceConditionalBinaryTest;
 import moa.classifiers.rules.core.Predicate;
diff --git a/moa/src/main/java/moa/classifiers/rules/meta/RandomAMRulesOld.java b/moa/src/main/java/moa/classifiers/rules/meta/RandomAMRulesOld.java
index b860ad10e..8828c1d84 100644
--- a/moa/src/main/java/moa/classifiers/rules/meta/RandomAMRulesOld.java
+++ b/moa/src/main/java/moa/classifiers/rules/meta/RandomAMRulesOld.java
@@ -29,7 +29,6 @@
 import com.github.javacliparser.MultiChoiceOption;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import moa.classifiers.AbstractClassifier;
diff --git a/moa/src/main/java/moa/clusterers/AbstractClusterer.java b/moa/src/main/java/moa/clusterers/AbstractClusterer.java
index db3a2a8a4..a8f23f48e 100644
--- a/moa/src/main/java/moa/clusterers/AbstractClusterer.java
+++ b/moa/src/main/java/moa/clusterers/AbstractClusterer.java
@@ -34,7 +34,7 @@
 import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public abstract class AbstractClusterer extends AbstractOptionHandler
 		implements Clusterer {
@@ -286,7 +286,7 @@ protected static int modelAttIndexToInstanceAttIndex(int index,
 	}
 
 	protected static int modelAttIndexToInstanceAttIndex(int index,
-			Instances insts) {
+			InstancesHeader insts) {
 		return insts.classIndex() > index ? index : index + 1;
 	}
 
diff --git a/moa/src/main/java/moa/clusterers/Clusterer.java b/moa/src/main/java/moa/clusterers/Clusterer.java
index 36bdbf79c..b018b421f 100644
--- a/moa/src/main/java/moa/clusterers/Clusterer.java
+++ b/moa/src/main/java/moa/clusterers/Clusterer.java
@@ -21,11 +21,11 @@
 
 import moa.MOAObject;
 import moa.cluster.Clustering;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.Measurement;
 import moa.gui.AWTRenderable;
 import moa.options.OptionHandler;
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public interface Clusterer extends MOAObject, OptionHandler, AWTRenderable {
 
diff --git a/moa/src/main/java/moa/clusterers/CobWeb.java b/moa/src/main/java/moa/clusterers/CobWeb.java
index c6c451098..03e34a5f9 100644
--- a/moa/src/main/java/moa/clusterers/CobWeb.java
+++ b/moa/src/main/java/moa/clusterers/CobWeb.java
@@ -30,7 +30,7 @@
 import com.github.javacliparser.IntOption;
 import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import weka.core.AttributeStats;
 import weka.experiment.Stats;
 import weka.filters.unsupervised.attribute.Add;
@@ -73,7 +73,7 @@ private class CNode implements Serializable {
         /**
          * Instances at this node
          */
-        protected Instances m_clusterInstances = null;
+        protected InstancesHeader m_clusterInstances = null;
         /**
          * Children of this node
          */
@@ -107,7 +107,7 @@ public CNode(int numAttributes, Instance leafInstance) {
             if (m_clusterInstances == null) {
 		//System.out.println(leafInstance.numAttributes()+"-"+leafInstance.value(0)+"-"+leafInstance.value(1)+"-"+leafInstance.value(2));
 		//System.out.println(leafInstance.numAttributes()+"-"+leafInstance.attribute(0).type()+"-"+leafInstance.attribute(1).type()+"-"+leafInstance.attribute(2).type());
-                m_clusterInstances = new Instances(leafInstance.dataset(), 1);
+                m_clusterInstances = new InstancesHeader(leafInstance.dataset(), 1);
             }
             m_clusterInstances.add(leafInstance);
             updateStats(leafInstance, false);
@@ -122,7 +122,7 @@ protected void addInstance(Instance newInstance) {
             // Add the instance to this cluster
 
             if (m_clusterInstances == null) {
-                m_clusterInstances = new Instances(newInstance.dataset(), 1);
+                m_clusterInstances = new InstancesHeader(newInstance.dataset(), 1);
                 m_clusterInstances.add(newInstance);
                 updateStats(newInstance, false);
                 return;
@@ -196,7 +196,7 @@ private double cuScoreForBestTwoMerged(CNode merged,
             double mergedCU = -Double.MAX_VALUE;
             // consider merging the best and second
             // best.
-            merged.m_clusterInstances = new Instances(m_clusterInstances, 1);
+            merged.m_clusterInstances = new InstancesHeader(m_clusterInstances, 1);
 
             merged.addChildNode(a);
             merged.addChildNode(b);
@@ -620,11 +620,11 @@ protected String dumpData() { //throws Exception {
 
             // construct instances string with cluster numbers attached
             CNode tempNode = new CNode(m_numAttributes);
-            tempNode.m_clusterInstances = new Instances(m_clusterInstances, 1);
+            tempNode.m_clusterInstances = new InstancesHeader(m_clusterInstances, 1);
             for (int i = 0; i < m_children.size(); i++) {
                 tempNode.addChildNode((CNode) m_children.elementAt(i));
             }
-            Instances tempInst = tempNode.m_clusterInstances;
+            InstancesHeader tempInst = tempNode.m_clusterInstances;
             tempNode = null;
 
             Add af = new Add();
diff --git a/moa/src/main/java/moa/clusterers/WekaClusteringAlgorithm.java b/moa/src/main/java/moa/clusterers/WekaClusteringAlgorithm.java
index 774e675dc..978290119 100644
--- a/moa/src/main/java/moa/clusterers/WekaClusteringAlgorithm.java
+++ b/moa/src/main/java/moa/clusterers/WekaClusteringAlgorithm.java
@@ -33,7 +33,7 @@
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
 
 import weka.core.Utils;
@@ -52,7 +52,7 @@ public class WekaClusteringAlgorithm extends AbstractClusterer {
     
     private Class<?>[] clustererClasses;
     
-    private Instances instances;
+    private InstancesHeader instances;
     
     private weka.clusterers.AbstractClusterer clusterer;
     
@@ -136,7 +136,7 @@ public Clustering getClusteringResult() {
             
             clusterer.buildClusterer(wekaInstances);
             int numClusters = clusterer.numberOfClusters();
-            Instances dataset = getDataset(instances.numAttributes(), numClusters);
+            InstancesHeader dataset = getDataset(instances.numAttributes(), numClusters);
             List<Instance> newInstances = new ArrayList<Instance>() ; //Instances(dataset);
 
             for (int i = 0; i < wekaInstances.numInstances(); i++) {
@@ -159,7 +159,7 @@ public Clustering getClusteringResult() {
         return clustering;
     }
 
-    public Instances getDataset(int numdim, int numclass) {
+    public InstancesHeader getDataset(int numdim, int numclass) {
         FastVector attributes = new FastVector();
         for (int i = 0; i < numdim; i++) {
             attributes.addElement(new Attribute("att" + (i + 1)));
@@ -173,7 +173,7 @@ public Instances getDataset(int numdim, int numclass) {
             attributes.addElement(new Attribute("class", classLabels));
         }
 
-        Instances myDataset = new Instances("horizion", attributes, 0);
+        InstancesHeader myDataset = new InstancesHeader("horizion", attributes, 0);
         if (numclass > 0) {
             myDataset.setClassIndex(myDataset.numAttributes() - 1);
         }
diff --git a/moa/src/main/java/moa/core/MultilabelInstancesHeader.java b/moa/src/main/java/moa/core/MultilabelInstancesHeader.java
index cc7e57c59..b8dc3b3c2 100644
--- a/moa/src/main/java/moa/core/MultilabelInstancesHeader.java
+++ b/moa/src/main/java/moa/core/MultilabelInstancesHeader.java
@@ -19,7 +19,7 @@
  */
 package moa.core;
 
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
@@ -33,7 +33,7 @@ public class MultilabelInstancesHeader extends InstancesHeader {
 
     private int m_NumLabels = -1;
 
-    public MultilabelInstancesHeader(Instances i, int numLabels) {
+    public MultilabelInstancesHeader(InstancesHeader i, int numLabels) {
         super(i);
         m_NumLabels = numLabels;
     }
diff --git a/moa/src/main/java/moa/core/SizeOf.java b/moa/src/main/java/moa/core/SizeOf.java
index 6e7b4e168..ff3def4c8 100644
--- a/moa/src/main/java/moa/core/SizeOf.java
+++ b/moa/src/main/java/moa/core/SizeOf.java
@@ -34,7 +34,7 @@ public class SizeOf {
     protected static Boolean m_Present;
 
     /**
-     * Checks whteher the agent is present.
+     * Checks whether the agent is present.
      *
      * @return true if the agent is present, false otherwise
      */
diff --git a/moa/src/main/java/moa/core/utils/AttributeDefinitionUtil.java b/moa/src/main/java/moa/core/utils/AttributeDefinitionUtil.java
new file mode 100644
index 000000000..a47df6c0d
--- /dev/null
+++ b/moa/src/main/java/moa/core/utils/AttributeDefinitionUtil.java
@@ -0,0 +1,121 @@
+package moa.core.utils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+public class AttributeDefinitionUtil {
+	//public static String definitionTotal = "(!?-?[0-9]+?)|(!?[0-9]+?-[0-9]+?)|(!?-?[0-9]+?~-?[0-9]+?)";
+	
+	public static String nonIgnoredDefinition = "0";
+	
+	public static String definitionSingle = "-?[0-9]+?";
+	public static String definitionPositiveRange = "-?[0-9]+?-[0-9]+?";
+	public static String definitionArbitraryRange = "-?[0-9]+?~-?[0-9]+?";
+	
+	public static String getDefinitionTotal() {
+		return "(!?" + definitionSingle + ")|" + "(!?" + definitionPositiveRange + ")|" + "(!?" + definitionArbitraryRange + ")";
+	}
+	
+	public static List<Integer> parseDefinition(String definition, int numAttributes, List<Integer> ignoredAttributes) {
+		List<Integer> ret = new ArrayList<Integer>();
+		if (Pattern.matches(definitionArbitraryRange, definition)) {
+			String[] split = definition.split("~");
+			int start = Integer.valueOf(split[0]);
+			int end = Integer.valueOf(split[1]);
+			if (start < 0) {
+				start = numAttributes + start + 1; // + 1 for so that -1 maps to last attribute 
+			}
+			if (end < 0) {
+				end = numAttributes + end + 1; // + 1 for so that -1 maps to last attribute 
+			}
+			start = Math.max(0, start);
+			end = Math.max(0, end);
+			if (start == end) {
+				System.err.println("[Warning] Strage attribute range definition '" + definition + "', start equals end");
+			}
+			Integer i = start;
+			if (start <= end)
+				while(i <= end) {
+					if (!ignoredAttributes.contains(i - 1)) ret.add(i - 1);
+					i++;
+				}
+			else 
+				System.err.println("[Warning] Strage attribute range definition '" + definition + "', end smaller of start, ignoring...");
+		} else if (Pattern.matches(definitionPositiveRange, definition)) {
+			String[] split = definition.split("-");
+			int start = Integer.valueOf(split[0]);
+			int end = Integer.valueOf(split[1]);
+			if (start == 0 || end == 0) {
+				throw new UnsupportedOperationException("Attribute definition range error - start or end equals 0: " + definition);
+			}
+			if (start == end) {
+				System.err.println("[Warning] Strage attribute range definition '" + definition + "', start equals end");
+			}
+			Integer i = start;
+			if (start <= end)
+				while(i <= end) {
+					if (!ignoredAttributes.contains(i - 1)) ret.add(i - 1);
+					i++;
+				}
+			else 
+				System.err.println("[Warning] Strage attribute range definition '" + definition + "', end smaller of start, ignoring...");
+		} else if (Pattern.matches(definitionSingle, definition)) {
+			int index = Integer.valueOf(definition);
+			if (index == 0) {
+	    		// Add all non-ignored attributes
+				for (Integer i = 0; i < numAttributes; i++)
+	   				if (!ignoredAttributes.contains(i)) ret.add(i);
+			} else {
+				if (index < 0){
+					index = numAttributes + index + 1;
+					if (index <= 0) {
+						throw new UnsupportedOperationException("Attribute definition range error - negative index overflows the number of attributes: " + definition);
+					}
+				}
+				if (!ignoredAttributes.contains(index - 1)) ret.add(index - 1);
+			}
+		}
+		return ret;
+	}
+	
+    public static List<Integer> parseAttributeDefinition(String attributeDefinition, int numAttributes, List<Integer> ignoredAttributes) {
+    	List<Integer> ret = new ArrayList<Integer>();
+    	if (ignoredAttributes == null) ignoredAttributes = new ArrayList<Integer>();
+    	if (attributeDefinition != "") {
+	    	String[] definitions = attributeDefinition.split("[,;]");
+	    	Pattern definitionsPattern = Pattern.compile(getDefinitionTotal());
+	    	for (int i = 0; i < definitions.length; i++) {
+	    		String definition = definitions[i];
+	    		boolean negative = false;
+	    		if (definition.isEmpty()) {
+	    			continue;
+	    		}
+	    		if (!definitionsPattern.matcher(definition).matches()) throw new UnsupportedOperationException("The attribute definition '" + definition + "' is not recognised.");
+	
+	    		if (definition.startsWith("!")) {
+	    			definition = definition.substring(1);
+	    			negative = true;
+	    		}
+	
+	    		List<Integer> candidates = parseDefinition(definition, numAttributes, ignoredAttributes);
+	    		if (negative) {
+	    			for (Integer j : candidates) {
+	    				if (ret.contains(j)) ret.remove(j);
+	    			}
+	    		} else {
+	    			for (Integer j : candidates) {
+	    				if (!ret.contains(j)) ret.add(j);
+	    			}
+	    		}
+	    	}
+    	} else {
+    		// Add all non-ignored attributes (this is the default behavior for input attributes)
+ 			for (Integer i = 0; i < numAttributes; i++)
+   				if (!ignoredAttributes.contains(i)) ret.add(i);
+    	}
+    	return ret;
+    }
+	
+	
+}
diff --git a/moa/src/main/java/moa/core/utils/Converter.java b/moa/src/main/java/moa/core/utils/Converter.java
index 3e3110557..a3f976c38 100755
--- a/moa/src/main/java/moa/core/utils/Converter.java
+++ b/moa/src/main/java/moa/core/utils/Converter.java
@@ -23,7 +23,7 @@
 import java.util.List;
 import moa.AbstractMOAObject;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Converter. This class can be used to convert a multi-label instance into a
@@ -34,7 +34,7 @@
  */
 public class Converter extends AbstractMOAObject {
 
-    protected Instances m_InstancesTemplate = null;
+    protected InstancesHeader m_InstancesTemplate = null;
 
     protected int m_L = -1;
 
@@ -49,8 +49,8 @@ public Converter(int n) {
         m_L = n;
     }
 
-    public Instances createTemplate(Instances i) {
-        this.m_InstancesTemplate = new Instances(i, 0, 0);
+    public InstancesHeader createTemplate(InstancesHeader i) {
+        this.m_InstancesTemplate = new InstancesHeader(i, 0, 0);
         return this.m_InstancesTemplate;
     }
 
diff --git a/moa/src/main/java/moa/evaluation/BasicMultiLabelPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/BasicMultiLabelPerformanceEvaluator.java
index 6f677c93c..33e6b18d1 100644
--- a/moa/src/main/java/moa/evaluation/BasicMultiLabelPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/BasicMultiLabelPerformanceEvaluator.java
@@ -24,7 +24,7 @@
 import moa.core.Measurement;
 
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 /**
@@ -57,7 +57,7 @@ public void reset() {
     @Override
 	public void addResult(Example<Instance> example, Prediction y) {
 
-		MultiLabelInstance x = (MultiLabelInstance) example.getData();
+		StructuredInstance x = (StructuredInstance) example.getData();
 
 		if (L == 0) {
 			L = x.numberOutputTargets();
diff --git a/moa/src/main/java/moa/gui/visualization/RunOutlierVisualizer.java b/moa/src/main/java/moa/gui/visualization/RunOutlierVisualizer.java
index 380b31204..ce611e1ba 100644
--- a/moa/src/main/java/moa/gui/visualization/RunOutlierVisualizer.java
+++ b/moa/src/main/java/moa/gui/visualization/RunOutlierVisualizer.java
@@ -59,7 +59,7 @@
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public class RunOutlierVisualizer implements Runnable, ActionListener, ClusterEventListener{	
     /** the pause interval, being read from the gui at startup */
@@ -646,7 +646,7 @@ public void weka() {
         for(int i = 0; i < dims; i++)
                 attributes.addElement( new Attribute("att" + i) );
 
-        Instances instances = new Instances("trainset",attributes,0);
+        InstancesHeader instances = new InstancesHeader("trainset",attributes,0);
 
         for(int c = 0; c < wekaClustering.size(); c++){
             Cluster cluster = wekaClustering.get(c);
diff --git a/moa/src/main/java/moa/gui/visualization/RunVisualizer.java b/moa/src/main/java/moa/gui/visualization/RunVisualizer.java
index e95cb7551..1e08cab18 100644
--- a/moa/src/main/java/moa/gui/visualization/RunVisualizer.java
+++ b/moa/src/main/java/moa/gui/visualization/RunVisualizer.java
@@ -52,7 +52,7 @@
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import moa.core.FastVector;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public class RunVisualizer implements Runnable, ActionListener, ClusterEventListener{
 
@@ -606,7 +606,7 @@ public void weka() {
         for(int i = 0; i < dims; i++)
                 attributes.addElement( new Attribute("att" + i) );
 
-        Instances instances = new Instances("trainset",attributes,0);
+        InstancesHeader instances = new InstancesHeader("trainset",attributes,0);
 
         for(int c = 0; c < wekaClustering.size(); c++){
             Cluster cluster = wekaClustering.get(c);
diff --git a/moa/src/main/java/moa/gui/visualization/WekaExplorer.java b/moa/src/main/java/moa/gui/visualization/WekaExplorer.java
index 7825f5433..cfc1d5254 100644
--- a/moa/src/main/java/moa/gui/visualization/WekaExplorer.java
+++ b/moa/src/main/java/moa/gui/visualization/WekaExplorer.java
@@ -36,7 +36,7 @@
 import java.awt.event.WindowAdapter;
 import java.awt.event.WindowEvent;
 import javax.swing.JFrame;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
 
 
@@ -46,7 +46,7 @@ public class WekaExplorer {
     /** for monitoring the Memory consumption */
     private static Memory m_Memory = new Memory(true);
 
-    public WekaExplorer(Instances instances) {
+    public WekaExplorer(InstancesHeader instances) {
         //weka.core.logging.Logger.log(weka.core.logging.Logger.Level.INFO, "Logging started");
         try {
             javax.swing.UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
diff --git a/moa/src/main/java/moa/streams/ArffFileStream.java b/moa/src/main/java/moa/streams/ArffFileStream.java
index 408c6d2da..5d0d10ef9 100644
--- a/moa/src/main/java/moa/streams/ArffFileStream.java
+++ b/moa/src/main/java/moa/streams/ArffFileStream.java
@@ -21,7 +21,8 @@
 
 import com.github.javacliparser.FileOption;
 import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.github.javacliparser.StringOption;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import java.io.BufferedReader;
 import java.io.FileInputStream;
@@ -41,7 +42,7 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class ArffFileStream extends AbstractOptionHandler implements InstanceStream {
+public class ArffFileStream extends AbstractOptionHandler implements InstanceStream, MultiTargetInstanceStream {
 
     @Override
     public String getPurposeString() {
@@ -53,13 +54,26 @@ public String getPurposeString() {
     public FileOption arffFileOption = new FileOption("arffFile", 'f',
             "ARFF file to load.", null, "arff", false);
 
-    public IntOption classIndexOption = new IntOption(
-            "classIndex",
-            'c',
-            "Class index of data. 0 for none or -1 for last attribute in file.",
-            -1, -1, Integer.MAX_VALUE);
+//    public IntOption classIndexOption = new IntOption(
+//            "classIndex",
+//            'c',
+//            "Class index of data. 0 for none or -1 for last attribute in file.",
+//            -1, -1, Integer.MAX_VALUE);
+
+    public StringOption outputIndexesOption = new StringOption(
+    		"outputIndexes",
+    		'c',
+    		"Indices of output (class) attributes. Can be provided in a comma or semicolon separated list of single values or ranges.",
+    		"-1");
+
+    public StringOption inputIndexesOption = new StringOption(
+    		"inputIndexes",
+    		'i',
+    		"Indices of input (class) attributes. Can be provided in a comma or semicolon separated list of single values or ranges. Leave blank for all non-output attributes.",
+    		"");
 
-    protected Instances instances;
+    
+    protected InstancesHeader instances;
 
     protected Reader fileReader;
 
@@ -76,7 +90,22 @@ public ArffFileStream() {
 
     public ArffFileStream(String arffFileName, int classIndex) {
         this.arffFileOption.setValue(arffFileName);
-        this.classIndexOption.setValue(classIndex);
+        this.outputIndexesOption.setValue(Integer.toString(classIndex));
+        this.inputIndexesOption.setValue("");
+        restart();
+    }
+
+    
+    public ArffFileStream(String arffFileName, String outputIndexes) {
+        this.arffFileOption.setValue(arffFileName);
+        this.outputIndexesOption.setValue(outputIndexes);
+        restart();
+    }
+    
+    public ArffFileStream(String arffFileName, String outputIndexes, String inputIndexes) {
+        this.arffFileOption.setValue(arffFileName);
+        this.outputIndexesOption.setValue(outputIndexes);
+        this.inputIndexesOption.setValue(inputIndexes);
         restart();
     }
 
@@ -126,13 +155,7 @@ public void restart() {
             this.fileProgressMonitor = new InputStreamProgressMonitor(
                     fileStream);
             this.fileReader = new BufferedReader(new InputStreamReader(this.fileProgressMonitor));
-            int classIndex = this.classIndexOption.getValue();
-            this.instances = new Instances(this.fileReader, 1, classIndex);
-            if (classIndex < 0) {
-		this.instances.setClassIndex(this.instances.numAttributes() - 1);
-            } else if (this.classIndexOption.getValue() > 0) {
-                this.instances.setClassIndex(this.classIndexOption.getValue() - 1);
-				}
+            this.instances = new InstancesHeader(this.fileReader, 1, this.outputIndexesOption.getValue(), this.inputIndexesOption.getValue());
             this.numInstancesRead = 0;
             this.lastInstanceRead = null;
             this.hitEndOfFile = !readNextInstanceFromFile();
diff --git a/moa/src/main/java/moa/streams/CachedInstancesStream.java b/moa/src/main/java/moa/streams/CachedInstancesStream.java
index 4faa60832..bb618fac8 100644
--- a/moa/src/main/java/moa/streams/CachedInstancesStream.java
+++ b/moa/src/main/java/moa/streams/CachedInstancesStream.java
@@ -23,7 +23,7 @@
 import moa.core.InstanceExample;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Stream generator for representing a stream that is cached in memory.
@@ -38,11 +38,11 @@ public class CachedInstancesStream extends AbstractMOAObject implements
 
 	private static final long serialVersionUID = 1L;
 
-	protected Instances toStream;
+	protected InstancesHeader toStream;
 
 	protected int streamPos;
 
-	public CachedInstancesStream(Instances toStream) {
+	public CachedInstancesStream(InstancesHeader toStream) {
 		this.toStream = toStream;
 	}
 
diff --git a/moa/src/main/java/moa/streams/ConceptDriftRealStream.java b/moa/src/main/java/moa/streams/ConceptDriftRealStream.java
index fd7b8c313..46c30398a 100644
--- a/moa/src/main/java/moa/streams/ConceptDriftRealStream.java
+++ b/moa/src/main/java/moa/streams/ConceptDriftRealStream.java
@@ -23,13 +23,16 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Random;
 import moa.core.InstanceExample;
 
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
+import moa.core.utils.AttributeDefinitionUtil;
 import moa.options.AbstractOptionHandler;
 import moa.options.ClassOption;
 import com.github.javacliparser.FloatOption;
@@ -111,8 +114,8 @@ public void prepareForUseImpl(TaskMonitor monitor,
         }
 
         // generate header
-        Instances first = this.inputStream.getHeader();
-        Instances second = this.driftStream.getHeader();
+        InstancesHeader first = this.inputStream.getHeader();
+        InstancesHeader second = this.driftStream.getHeader();
         FastVector newAttributes = new FastVector();
         for (int i = 0; i < first.numAttributes() - 1; i++) {
             newAttributes.addElement(first.attribute(i));
@@ -130,9 +133,11 @@ public void prepareForUseImpl(TaskMonitor monitor,
         }
         newAttributes.addElement(classLabels);
 
-        this.streamHeader = new InstancesHeader(new Instances(
+        this.streamHeader = new InstancesHeader(new InstancesHeader(
                 getCLICreationString(InstanceStream.class), newAttributes, 0));
         this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
+        // TODO adapt for multi-target streaming
+        this.streamHeader.setInputIndexes();
         restart();
 
     }
diff --git a/moa/src/main/java/moa/streams/ConceptDriftStream.java b/moa/src/main/java/moa/streams/ConceptDriftStream.java
index c0775b447..19ff13c49 100644
--- a/moa/src/main/java/moa/streams/ConceptDriftStream.java
+++ b/moa/src/main/java/moa/streams/ConceptDriftStream.java
@@ -22,8 +22,6 @@
 import java.util.Random;
 import moa.core.Example;
 import moa.core.InstanceExample;
-
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.options.ClassOption;
@@ -31,6 +29,7 @@
 import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Stream generator that adds concept drift to examples in a stream.
diff --git a/moa/src/main/java/moa/streams/ExampleStream.java b/moa/src/main/java/moa/streams/ExampleStream.java
index f5e9ec500..20877597a 100644
--- a/moa/src/main/java/moa/streams/ExampleStream.java
+++ b/moa/src/main/java/moa/streams/ExampleStream.java
@@ -21,8 +21,9 @@
 
 import moa.MOAObject;
 import moa.core.Example;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Interface representing a data stream of examples. 
diff --git a/moa/src/main/java/moa/streams/FilteredStream.java b/moa/src/main/java/moa/streams/FilteredStream.java
index 1eb0803a5..6cf072f88 100644
--- a/moa/src/main/java/moa/streams/FilteredStream.java
+++ b/moa/src/main/java/moa/streams/FilteredStream.java
@@ -19,8 +19,9 @@
  */
 package moa.streams;
 
-import moa.core.Example;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
+
+import moa.core.Example;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.options.ClassOption;
diff --git a/moa/src/main/java/moa/streams/MultiFilteredStream.java b/moa/src/main/java/moa/streams/MultiFilteredStream.java
index 6e35c4994..befa684b6 100644
--- a/moa/src/main/java/moa/streams/MultiFilteredStream.java
+++ b/moa/src/main/java/moa/streams/MultiFilteredStream.java
@@ -21,7 +21,6 @@
 
 import moa.core.Example;
 import moa.core.InstanceExample;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.options.ClassOption;
@@ -31,6 +30,7 @@
 import moa.streams.filters.StreamFilter;
 import moa.tasks.TaskMonitor;
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Class for representing a stream that is filtered.
diff --git a/moa/src/main/java/moa/streams/MultiLabelFilteredStream.java b/moa/src/main/java/moa/streams/MultiLabelFilteredStream.java
index d63b0e451..f7c8bdf79 100644
--- a/moa/src/main/java/moa/streams/MultiLabelFilteredStream.java
+++ b/moa/src/main/java/moa/streams/MultiLabelFilteredStream.java
@@ -19,6 +19,8 @@
  */
 package moa.streams;
 
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.core.Example;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
@@ -29,8 +31,6 @@
 import moa.streams.filters.StreamFilter;
 import moa.tasks.TaskMonitor;
 
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
 /**
  * Class for representing a stream that is filtered.
  *
diff --git a/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java b/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java
index 4eb9dbff0..80e2ae84f 100644
--- a/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java
+++ b/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java
@@ -20,7 +20,7 @@
 package moa.streams;
 
 import com.github.javacliparser.FileOption;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import java.io.BufferedReader;
 import java.io.FileInputStream;
@@ -41,149 +41,151 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class MultiTargetArffFileStream extends AbstractOptionHandler implements
+public class MultiTargetArffFileStream extends ArffFileStream implements
         MultiTargetInstanceStream {
 
-    @Override
-    public String getPurposeString() {
-        return "A stream read from an ARFF file.";
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    public FileOption arffFileOption = new FileOption("arffFile", 'f',
-            "ARFF file to load.", null, "arff", false);
-
-    public RangeOption outputAttributesOption = new RangeOption(
-            "outputAttributes",
-            'c',
-            "Output attributes:  n for first n attributes,  -n for last n attributes  For example, 2 for the two first attributes, -2 for the two last attributes.",
-			"-1");
-
-    protected Instances instances;
-
-    protected Reader fileReader;
-
-    protected boolean hitEndOfFile;
-
-    protected InstanceExample lastInstanceRead;
-
-    protected int numInstancesRead;
-
-    protected InputStreamProgressMonitor fileProgressMonitor;
-
-    public MultiTargetArffFileStream() {
-    }
-
-	// jesse
-    public MultiTargetArffFileStream(String arffFileName, String classIndices) {
-		this.arffFileOption.setValue(arffFileName);
-		this.outputAttributesOption.setValue(classIndices);
-		restart();
-    }
-
-	/*
-    public ArffFileStream(String arffFileName, int classIndex) {
-        this.arffFileOption.setValue(arffFileName);
-        this.outputAttributesOption.setValue(classIndex);
-        restart();
-    }
-	*/
-
-    @Override
-    public void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        restart();
-    }
-
-    @Override
-    public InstancesHeader getHeader() {
-        return new InstancesHeader(this.instances);
-    }
-
-    @Override
-    public long estimatedRemainingInstances() {
-        double progressFraction = this.fileProgressMonitor.getProgressFraction();
-        if ((progressFraction > 0.0) && (this.numInstancesRead > 0)) {
-            return (long) ((this.numInstancesRead / progressFraction) - this.numInstancesRead);
-        }
-        return -1;
-    }
-
-    @Override
-    public boolean hasMoreInstances() {
-        return !this.hitEndOfFile;
-    }
-
-    @Override
-    public InstanceExample nextInstance() {
-        InstanceExample prevInstance = this.lastInstanceRead;
-        this.hitEndOfFile = !readNextInstanceFromFile();
-        return prevInstance;
-    }
-
-    @Override
-    public boolean isRestartable() {
-        return true;
-    }
-
-    @Override
-    public void restart() {
-        try {
-            if (this.fileReader != null) {
-                this.fileReader.close();
-            }
-            InputStream fileStream = new FileInputStream(this.arffFileOption.getFile());
-            this.fileProgressMonitor = new InputStreamProgressMonitor(
-                    fileStream);
-            this.fileReader = new BufferedReader(new InputStreamReader(
-                    this.fileProgressMonitor));
-			// jesse -----
-			/*int cs[] = this.outputAttributesOption.getRange(); 
-			if (cs.length == 1) {
-				// single label
-				int c = cs[0]; 
-				this.instances = new Instances(this.fileReader, 1, c);
-				if (c < 0) {
-					this.instances.setClassIndex(this.instances.numAttributes() - 1);
-				} else if (c > 0) {
-					this.instances.setClassIndex(c - 1);
-				}
-			}
-			else {*/
-				// multi-label since cs[] contains _multipe_ class indices, e.g., cs[] = {9,10,11} 
-				// what to do here?
-			this.instances = new Instances(this.fileReader, this.outputAttributesOption.getRange());
-			//}
-            this.numInstancesRead = 0;
-            this.lastInstanceRead = null;
-            this.hitEndOfFile = !readNextInstanceFromFile();
-        } catch (IOException ioe) {
-            throw new RuntimeException("ArffFileStream restart failed.", ioe);
-        }
-    }
-
-    protected boolean readNextInstanceFromFile() {
-        try {
-            if (this.instances.readInstance(this.fileReader)) {
-                this.lastInstanceRead = new InstanceExample(this.instances.instance(0));
-                this.instances.delete(); // keep instances clean
-                this.numInstancesRead++;
-                return true;
-            }
-            if (this.fileReader != null) {
-                this.fileReader.close();
-                this.fileReader = null;
-            }
-            return false;
-        } catch (IOException ioe) {
-            throw new RuntimeException(
-                    "ArffFileStream failed to read instance from stream.", ioe);
-        }
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
+	// deprecated
+	
+//    @Override
+//    public String getPurposeString() {
+//        return "A stream read from an ARFF file.";
+//    }
+//
+//    private static final long serialVersionUID = 1L;
+//
+//    public FileOption arffFileOption = new FileOption("arffFile", 'f',
+//            "ARFF file to load.", null, "arff", false);
+//
+//    public RangeOption outputAttributesOption = new RangeOption(
+//            "outputAttributes",
+//            'c',
+//            "Output attributes:  n for first n attributes,  -n for last n attributes  For example, 2 for the two first attributes, -2 for the two last attributes.",
+//			"-1");
+//
+//    protected Instances instances;
+//
+//    protected Reader fileReader;
+//
+//    protected boolean hitEndOfFile;
+//
+//    protected InstanceExample lastInstanceRead;
+//
+//    protected int numInstancesRead;
+//
+//    protected InputStreamProgressMonitor fileProgressMonitor;
+//
+//    public MultiTargetArffFileStream() {
+//    }
+//
+//	// jesse
+//    public MultiTargetArffFileStream(String arffFileName, String classIndices) {
+//		this.arffFileOption.setValue(arffFileName);
+//		this.outputAttributesOption.setValue(classIndices);
+//		restart();
+//    }
+//
+//	/*
+//    public ArffFileStream(String arffFileName, int classIndex) {
+//        this.arffFileOption.setValue(arffFileName);
+//        this.outputAttributesOption.setValue(classIndex);
+//        restart();
+//    }
+//	*/
+//
+//    @Override
+//    public void prepareForUseImpl(TaskMonitor monitor,
+//            ObjectRepository repository) {
+//        restart();
+//    }
+//
+//    @Override
+//    public InstancesHeader getHeader() {
+//        return new InstancesHeader(this.instances);
+//    }
+//
+//    @Override
+//    public long estimatedRemainingInstances() {
+//        double progressFraction = this.fileProgressMonitor.getProgressFraction();
+//        if ((progressFraction > 0.0) && (this.numInstancesRead > 0)) {
+//            return (long) ((this.numInstancesRead / progressFraction) - this.numInstancesRead);
+//        }
+//        return -1;
+//    }
+//
+//    @Override
+//    public boolean hasMoreInstances() {
+//        return !this.hitEndOfFile;
+//    }
+//
+//    @Override
+//    public InstanceExample nextInstance() {
+//        InstanceExample prevInstance = this.lastInstanceRead;
+//        this.hitEndOfFile = !readNextInstanceFromFile();
+//        return prevInstance;
+//    }
+//
+//    @Override
+//    public boolean isRestartable() {
+//        return true;
+//    }
+//
+//    @Override
+//    public void restart() {
+//        try {
+//            if (this.fileReader != null) {
+//                this.fileReader.close();
+//            }
+//            InputStream fileStream = new FileInputStream(this.arffFileOption.getFile());
+//            this.fileProgressMonitor = new InputStreamProgressMonitor(
+//                    fileStream);
+//            this.fileReader = new BufferedReader(new InputStreamReader(
+//                    this.fileProgressMonitor));
+//			// jesse -----
+//			/*int cs[] = this.outputAttributesOption.getRange(); 
+//			if (cs.length == 1) {
+//				// single label
+//				int c = cs[0]; 
+//				this.instances = new Instances(this.fileReader, 1, c);
+//				if (c < 0) {
+//					this.instances.setClassIndex(this.instances.numAttributes() - 1);
+//				} else if (c > 0) {
+//					this.instances.setClassIndex(c - 1);
+//				}
+//			}
+//			else {*/
+//				// multi-label since cs[] contains _multipe_ class indices, e.g., cs[] = {9,10,11} 
+//				// what to do here?
+//			this.instances = new Instances(this.fileReader, this.outputAttributesOption.getRange());
+//			//}
+//            this.numInstancesRead = 0;
+//            this.lastInstanceRead = null;
+//            this.hitEndOfFile = !readNextInstanceFromFile();
+//        } catch (IOException ioe) {
+//            throw new RuntimeException("ArffFileStream restart failed.", ioe);
+//        }
+//    }
+//
+//    protected boolean readNextInstanceFromFile() {
+//        try {
+//            if (this.instances.readInstance(this.fileReader)) {
+//                this.lastInstanceRead = new InstanceExample(this.instances.instance(0));
+//                this.instances.delete(); // keep instances clean
+//                this.numInstancesRead++;
+//                return true;
+//            }
+//            if (this.fileReader != null) {
+//                this.fileReader.close();
+//                this.fileReader = null;
+//            }
+//            return false;
+//        } catch (IOException ioe) {
+//            throw new RuntimeException(
+//                    "ArffFileStream failed to read instance from stream.", ioe);
+//        }
+//    }
+//
+//    @Override
+//    public void getDescription(StringBuilder sb, int indent) {
+//        // TODO Auto-generated method stub
+//    }
 }
diff --git a/moa/src/main/java/moa/streams/clustering/FileStream.java b/moa/src/main/java/moa/streams/clustering/FileStream.java
index 9b122de65..7ef557add 100644
--- a/moa/src/main/java/moa/streams/clustering/FileStream.java
+++ b/moa/src/main/java/moa/streams/clustering/FileStream.java
@@ -43,10 +43,12 @@
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.ListOption;
 import com.github.javacliparser.Option;
+import com.github.javacliparser.StringOption;
+
 import moa.tasks.TaskMonitor;
 
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public class FileStream extends ClusteringStream{
 
@@ -63,12 +65,24 @@ public String getPurposeString() {
 	public FileOption arffFileOption = new FileOption("arffFile", 'f',
 			"ARFF file to load.", defaultfile, "arff", false);
 
-	public IntOption classIndexOption = new IntOption(
-			"classIndex",
-			'c',
-			"Class index of data. 0 for none or -1 for last attribute in file.",
-			-1, -1, Integer.MAX_VALUE);
-
+//	public IntOption classIndexOption = new IntOption(
+//			"classIndex",
+//			'c',
+//			"Class index of data. 0 for none or -1 for last attribute in file.",
+//			-1, -1, Integer.MAX_VALUE);
+
+    public StringOption outputIndicesOption = new StringOption(
+    		"outputIndices",
+    		'c',
+    		"Indices of output (class) attributes. Can be provided in a comma or semicolon separated list of single values or ranges.",
+    		"-1");
+
+    public StringOption inputIndicesOption = new StringOption(
+    		"outputIndices",
+    		'i',
+    		"Indices of input (class) attributes. Can be provided in a comma or semicolon separated list of single values or ranges. Leave blank for all non-output attributes.",
+    		"");
+	
     public FlagOption normalizeOption = 
     		new FlagOption("normalize", 'n', 
     				"Numerical data will be normalized to 0-1 " +
@@ -90,7 +104,7 @@ public String getPurposeString() {
 
     
   
-	protected Instances instances;
+	protected InstancesHeader instances;
 
 	protected Reader fileReader;
 
@@ -104,7 +118,7 @@ public String getPurposeString() {
 	
 	private Integer[] removeAttributes = null;
     
-	private Instances filteredDataset = null;
+	private InstancesHeader filteredDataset = null;
     
 	private ArrayList<Double[]> valuesMinMaxDiff = null;
 
@@ -155,12 +169,7 @@ public void restart() {
 			InputStream fileStream = new FileInputStream(arffFileOption.getFile());
 			fileProgressMonitor = new InputStreamProgressMonitor(fileStream);
 			fileReader = new BufferedReader(new InputStreamReader(fileProgressMonitor));
-            instances = new Instances(fileReader, 1, this.classIndexOption.getValue());
-			if (classIndexOption.getValue() < 0) {
-				instances.setClassIndex(instances.numAttributes() - 1);
-			} else if (classIndexOption.getValue() > 0) {
-				instances.setClassIndex(classIndexOption.getValue() - 1);
-			}
+            instances = new InstancesHeader(fileReader, 1, this.outputIndicesOption.getValue(), this.inputIndicesOption.getValue());
 
 
 			//use hashset to delete duplicates and attributes numbers that aren't valid
@@ -206,7 +215,7 @@ public void restart() {
 			}
             
 			//create filtered dataset
-			filteredDataset = new Instances(instances);
+			filteredDataset = new InstancesHeader(instances);
 			for (int i = removeAttributes.length-1; i >= 0 ; i--) {
 				filteredDataset.deleteAttributeAt(removeAttributes[i]);
 				if(true){
@@ -278,7 +287,7 @@ protected ArrayList<Double[]> readMinMaxDiffValues(HashSet<Integer> ignoredAttri
 			InputStream fileStream = new FileInputStream(arffFileOption.getFile());
 			InputStreamProgressMonitor fileProgressMonitor = new InputStreamProgressMonitor(fileStream);
 			Reader fileReader = new BufferedReader(new InputStreamReader(fileProgressMonitor));
-            Instances instances = new Instances(fileReader, 1, this.classIndexOption.getValue());
+            InstancesHeader instances = new InstancesHeader(fileReader, 1, this.outputIndicesOption.getValue(), this.inputIndicesOption.getValue());
 
 			valuesMinMaxDiff = new ArrayList<Double[]>();
 			for (int i = 0; i < instances.numAttributes()-ignoredAttributes.size(); i++) {
diff --git a/moa/src/main/java/moa/streams/clustering/RandomRBFGeneratorEvents.java b/moa/src/main/java/moa/streams/clustering/RandomRBFGeneratorEvents.java
index 4ade99a71..84b15eebc 100644
--- a/moa/src/main/java/moa/streams/clustering/RandomRBFGeneratorEvents.java
+++ b/moa/src/main/java/moa/streams/clustering/RandomRBFGeneratorEvents.java
@@ -47,7 +47,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 
 public class RandomRBFGeneratorEvents extends ClusteringStream {
@@ -510,7 +510,7 @@ protected void generateHeader() {	// 2013/06/02: Noise label
         if (noiseLevelOption.getValue() > 0) classLabels.add("noise");	// The last label = "noise"
         
         attributes.add(new Attribute("class", classLabels));
-        streamHeader = new InstancesHeader(new Instances(getCLICreationString(InstanceStream.class), attributes, 0));
+        streamHeader = new InstancesHeader(new InstancesHeader(getCLICreationString(InstanceStream.class), attributes, 0));
         streamHeader.setClassIndex(streamHeader.numAttributes() - 1);
     }
 
diff --git a/moa/src/main/java/moa/streams/clustering/SimpleCSVStream.java b/moa/src/main/java/moa/streams/clustering/SimpleCSVStream.java
index d554e0eaf..fe46621be 100644
--- a/moa/src/main/java/moa/streams/clustering/SimpleCSVStream.java
+++ b/moa/src/main/java/moa/streams/clustering/SimpleCSVStream.java
@@ -33,7 +33,7 @@
 import com.github.javacliparser.StringOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import moa.core.InputStreamProgressMonitor;
@@ -61,7 +61,7 @@ public class SimpleCSVStream extends ClusteringStream {
 	public FlagOption classIndexOption = new FlagOption("classIndex", 'c',
 			"Last attribute is class index.");
 
-	protected Instances dataset;
+	protected InstancesHeader dataset;
 
 	protected BufferedReader fileReader;
 
@@ -252,7 +252,7 @@ public void restart() {
 				ArrayList<String> classLabels = new ArrayList<String>();
 				classLabels.add("0");
 		        attributes.add(new Attribute("class", classLabels));
-				this.dataset = new Instances(csvFileOption.getFile().getName(),
+				this.dataset = new InstancesHeader(csvFileOption.getFile().getName(),
 						attributes, 0);
 				this.dataset.setClassIndex(this.numAttributes - 1);
 				numAttsOption = new IntOption("numAtts", 'a', "",
diff --git a/moa/src/main/java/moa/streams/filters/AddNoiseFilter.java b/moa/src/main/java/moa/streams/filters/AddNoiseFilter.java
index 3caa94559..c7968e479 100644
--- a/moa/src/main/java/moa/streams/filters/AddNoiseFilter.java
+++ b/moa/src/main/java/moa/streams/filters/AddNoiseFilter.java
@@ -25,10 +25,11 @@
 import moa.core.DoubleVector;
 import moa.core.GaussianEstimator;
 import moa.core.InstanceExample;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Filter for adding random noise to examples in a stream.
diff --git a/moa/src/main/java/moa/streams/filters/RBFFilter.java b/moa/src/main/java/moa/streams/filters/RBFFilter.java
index 4b9901d83..bf90b324c 100644
--- a/moa/src/main/java/moa/streams/filters/RBFFilter.java
+++ b/moa/src/main/java/moa/streams/filters/RBFFilter.java
@@ -11,7 +11,7 @@
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceImpl;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Range;
 
@@ -88,7 +88,7 @@ private void initialize(Instance instance) {
 		}
 
 		// initialize instance space
-		Instances ds = new Instances();
+		InstancesHeader ds = new InstancesHeader();
 		List<Attribute> v = new ArrayList<Attribute>(h);
 		List<Integer> indexValues = new ArrayList<Integer>(h);
 
@@ -101,9 +101,6 @@ private void initialize(Instance instance) {
 
 
 		ds.setAttributes(v,indexValues);
-		Range r= new Range("start-end");
-		//r.setUpper(h);
-		ds.setRangeOutputIndices(r);
 		dataset=(new InstancesHeader(ds));
 		dataset.setClassIndex(h);
 		System.out.println(""+dataset);
diff --git a/moa/src/main/java/moa/streams/filters/ReLUFilter.java b/moa/src/main/java/moa/streams/filters/ReLUFilter.java
index f50c6ac60..3f6eb7f55 100644
--- a/moa/src/main/java/moa/streams/filters/ReLUFilter.java
+++ b/moa/src/main/java/moa/streams/filters/ReLUFilter.java
@@ -11,7 +11,7 @@
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceImpl;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Range;
 
@@ -99,7 +99,7 @@ private void initialize(Instance instance) {
 		}
 
 		// initialize instance space
-		Instances ds = new Instances();
+		InstancesHeader ds = new InstancesHeader();
 		List<Attribute> v = new ArrayList<Attribute>(H);
 		List<Integer> indexValues = new ArrayList<Integer>(H);
 
@@ -112,8 +112,6 @@ private void initialize(Instance instance) {
 
 
 		ds.setAttributes(v,indexValues);
-		Range r= new Range("start-end");
-		ds.setRangeOutputIndices(r);
 		dataset=(new InstancesHeader(ds));
 		dataset.setClassIndex(H);
 
diff --git a/moa/src/main/java/moa/streams/filters/RemoveDiscreteAttributeFilter.java b/moa/src/main/java/moa/streams/filters/RemoveDiscreteAttributeFilter.java
index fa80d5230..f2143f080 100644
--- a/moa/src/main/java/moa/streams/filters/RemoveDiscreteAttributeFilter.java
+++ b/moa/src/main/java/moa/streams/filters/RemoveDiscreteAttributeFilter.java
@@ -25,7 +25,7 @@
 import moa.streams.InstanceStream;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.SparseInstance;
 import moa.core.FastVector;
@@ -74,7 +74,7 @@ public InstanceExample nextInstance() {
             }
             attributes.addElement(inst.classAttribute());
             numericAttributes.add(inst.classIndex());
-            this.streamHeader = new InstancesHeader(new Instances(
+            this.streamHeader = new InstancesHeader(new InstancesHeader(
                     getCLICreationString(InstanceStream.class), attributes, 0));
             this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
 
diff --git a/moa/src/main/java/moa/streams/filters/ReplacingMissingValuesFilter.java b/moa/src/main/java/moa/streams/filters/ReplacingMissingValuesFilter.java
index 29aa407bc..fefe7f955 100644
--- a/moa/src/main/java/moa/streams/filters/ReplacingMissingValuesFilter.java
+++ b/moa/src/main/java/moa/streams/filters/ReplacingMissingValuesFilter.java
@@ -23,6 +23,7 @@
 import com.github.javacliparser.MultiChoiceOption;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
diff --git a/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java b/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java
index 808f3641f..b5905e34a 100644
--- a/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java
+++ b/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java
@@ -3,6 +3,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import moa.core.Example;
 import moa.core.InstanceExample;
 import moa.streams.MultiTargetInstanceStream;
 
@@ -10,11 +11,12 @@
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceImpl;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Range;
 
 public class SelectAttributesFilter extends AbstractMultiLabelStreamFilter implements MultiLabelStreamFilter{
+
 	/**
 	 * 
 	 */
@@ -48,15 +50,18 @@ private void initialize(Instance instance) {
 		inputsSelected=getSelection(inputStringOption.getValue());
 		outputsSelected=getSelection(outputStringOption.getValue());
 		int totAttributes=inputsSelected.numValues()+outputsSelected.numValues();
-		Instances ds= new Instances();
+		InstancesHeader ds= new InstancesHeader();
 		List<Attribute> v = new ArrayList<Attribute>(totAttributes);
 		List<Integer> indexValues = new ArrayList<Integer>(totAttributes);
 		int ct=0;
+		List<Integer> inputIndexes = new ArrayList<Integer>();
+		List<Integer> outputIndexes = new ArrayList<Integer>();
 		for (int i=0; i<inputsSelected.numEntries();i++)
 		{
 			for (int j=inputsSelected.getStart(i); j<=inputsSelected.getEnd(i);j++){
 				v.add(instance.attribute(j-1));
 				indexValues.add(ct);
+				inputIndexes.add(ct);
 				ct++;
 			}
 		}
@@ -66,13 +71,13 @@ private void initialize(Instance instance) {
 			for (int j=outputsSelected.getStart(i); j<=outputsSelected.getEnd(i);j++){
 				v.add(instance.attribute(j-1));
 				indexValues.add(ct);
+				outputIndexes.add(ct);
 				ct++;
 			}
 		}		
 		ds.setAttributes(v,indexValues);
-		Range r= new Range("-" + outputsSelected.numValues());
-		r.setUpper(totAttributes);
-		ds.setRangeOutputIndices(r);
+		ds.setOutputIndexes(outputIndexes);
+		ds.setInputIndexes(inputIndexes);
 		dataset=(new InstancesHeader(ds));
 	}
 
@@ -128,5 +133,4 @@ private Instance processInstance(Instance instance) {
 		newInstance.setDataset(dataset);
 		return newInstance;
 	}
-
 }
diff --git a/moa/src/main/java/moa/streams/generators/AgrawalGenerator.java b/moa/src/main/java/moa/streams/generators/AgrawalGenerator.java
index ba8a96f74..b6fd685eb 100644
--- a/moa/src/main/java/moa/streams/generators/AgrawalGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/AgrawalGenerator.java
@@ -23,7 +23,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import java.util.Random;
 import moa.core.Example;
@@ -306,7 +306,7 @@ protected void prepareForUseImpl(TaskMonitor monitor,
         classLabels.addElement("groupA");
         classLabels.addElement("groupB");
         attributes.addElement(new Attribute("class", classLabels));
-        this.streamHeader = new InstancesHeader(new Instances(
+        this.streamHeader = new InstancesHeader(new InstancesHeader(
                 getCLICreationString(InstanceStream.class), attributes, 0));
         this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
         restart();
diff --git a/moa/src/main/java/moa/streams/generators/HyperplaneGenerator.java b/moa/src/main/java/moa/streams/generators/HyperplaneGenerator.java
index d5bd99e01..be6e6aa71 100644
--- a/moa/src/main/java/moa/streams/generators/HyperplaneGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/HyperplaneGenerator.java
@@ -31,7 +31,7 @@
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
@@ -101,7 +101,7 @@ protected void generateHeader() {
             classLabels.addElement("class" + (i + 1));
         }
         attributes.addElement(new Attribute("class", classLabels));
-        this.streamHeader = new InstancesHeader(new Instances(
+        this.streamHeader = new InstancesHeader(new InstancesHeader(
                 getCLICreationString(InstanceStream.class), attributes, 0));
         this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
     }
diff --git a/moa/src/main/java/moa/streams/generators/LEDGenerator.java b/moa/src/main/java/moa/streams/generators/LEDGenerator.java
index f6c78d868..a57fb1dc1 100644
--- a/moa/src/main/java/moa/streams/generators/LEDGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/LEDGenerator.java
@@ -23,7 +23,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import java.util.Random;
 import moa.core.InstanceExample;
@@ -96,7 +96,7 @@ protected void prepareForUseImpl(TaskMonitor monitor,
             classLabels.addElement(Integer.toString(i));
         }
         attributes.addElement(new Attribute("class", classLabels));
-        this.streamHeader = new InstancesHeader(new Instances(
+        this.streamHeader = new InstancesHeader(new InstancesHeader(
                 getCLICreationString(InstanceStream.class), attributes, 0));
         this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
         restart();
diff --git a/moa/src/main/java/moa/streams/generators/LEDGeneratorDrift.java b/moa/src/main/java/moa/streams/generators/LEDGeneratorDrift.java
index bde9241ca..26ee76a89 100644
--- a/moa/src/main/java/moa/streams/generators/LEDGeneratorDrift.java
+++ b/moa/src/main/java/moa/streams/generators/LEDGeneratorDrift.java
@@ -23,6 +23,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.core.ObjectRepository;
 import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
diff --git a/moa/src/main/java/moa/streams/generators/RandomRBFGenerator.java b/moa/src/main/java/moa/streams/generators/RandomRBFGenerator.java
index 5fbbf8390..cbbe0202c 100644
--- a/moa/src/main/java/moa/streams/generators/RandomRBFGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/RandomRBFGenerator.java
@@ -23,7 +23,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import java.io.Serializable;
 import java.util.Random;
@@ -158,7 +158,7 @@ protected void generateHeader() {
             classLabels.addElement("class" + (i + 1));
         }
         attributes.addElement(new Attribute("class", classLabels));
-        this.streamHeader = new InstancesHeader(new Instances(
+        this.streamHeader = new InstancesHeader(new InstancesHeader(
                 getCLICreationString(InstanceStream.class), attributes, 0));
         this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
     }
diff --git a/moa/src/main/java/moa/streams/generators/RandomTreeGenerator.java b/moa/src/main/java/moa/streams/generators/RandomTreeGenerator.java
index c48d690f0..282618a02 100644
--- a/moa/src/main/java/moa/streams/generators/RandomTreeGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/RandomTreeGenerator.java
@@ -23,7 +23,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import java.io.Serializable;
 import java.util.ArrayList;
@@ -191,7 +191,7 @@ protected void generateHeader() {
             classLabels.addElement("class" + (i + 1));
         }
         attributes.addElement(new Attribute("class", classLabels));
-        this.streamHeader = new InstancesHeader(new Instances(
+        this.streamHeader = new InstancesHeader(new InstancesHeader(
                 getCLICreationString(InstanceStream.class), attributes, 0));
         this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
     }
diff --git a/moa/src/main/java/moa/streams/generators/SEAGenerator.java b/moa/src/main/java/moa/streams/generators/SEAGenerator.java
index 231722231..06da33f07 100644
--- a/moa/src/main/java/moa/streams/generators/SEAGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/SEAGenerator.java
@@ -23,7 +23,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import java.util.Random;
 import moa.core.InstanceExample;
@@ -135,7 +135,7 @@ protected void prepareForUseImpl(TaskMonitor monitor,
         classLabels.addElement("groupA");
         classLabels.addElement("groupB");
         attributes.addElement(new Attribute("class", classLabels));
-        this.streamHeader = new InstancesHeader(new Instances(
+        this.streamHeader = new InstancesHeader(new InstancesHeader(
                 getCLICreationString(InstanceStream.class), attributes, 0));
         this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
         restart();
diff --git a/moa/src/main/java/moa/streams/generators/STAGGERGenerator.java b/moa/src/main/java/moa/streams/generators/STAGGERGenerator.java
index d1b94c8c6..a92118e17 100644
--- a/moa/src/main/java/moa/streams/generators/STAGGERGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/STAGGERGenerator.java
@@ -23,7 +23,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import java.util.Random;
 import moa.core.InstanceExample;
@@ -137,7 +137,7 @@ protected void prepareForUseImpl(TaskMonitor monitor,
         classLabels.addElement("false");
         classLabels.addElement("true");
         attributes.addElement(new Attribute("class", classLabels));
-        this.streamHeader = new InstancesHeader(new Instances(
+        this.streamHeader = new InstancesHeader(new InstancesHeader(
                 getCLICreationString(InstanceStream.class), attributes, 0));
         this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
         restart();
diff --git a/moa/src/main/java/moa/streams/generators/WaveformGenerator.java b/moa/src/main/java/moa/streams/generators/WaveformGenerator.java
index d58eedd73..f66e5b0ff 100644
--- a/moa/src/main/java/moa/streams/generators/WaveformGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/WaveformGenerator.java
@@ -23,7 +23,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import java.util.Random;
 import moa.core.InstanceExample;
@@ -89,7 +89,7 @@ protected void prepareForUseImpl(TaskMonitor monitor,
             classLabels.addElement("class" + (i + 1));
         }
         attributes.addElement(new Attribute("class", classLabels));
-        this.streamHeader = new InstancesHeader(new Instances(
+        this.streamHeader = new InstancesHeader(new InstancesHeader(
                 getCLICreationString(InstanceStream.class), attributes, 0));
         this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
         restart();
diff --git a/moa/src/main/java/moa/streams/generators/WaveformGeneratorDrift.java b/moa/src/main/java/moa/streams/generators/WaveformGeneratorDrift.java
index 719267e88..c918ad8b3 100644
--- a/moa/src/main/java/moa/streams/generators/WaveformGeneratorDrift.java
+++ b/moa/src/main/java/moa/streams/generators/WaveformGeneratorDrift.java
@@ -24,6 +24,7 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.core.ObjectRepository;
 import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
diff --git a/moa/src/main/java/moa/streams/generators/cd/AbstractConceptDriftGenerator.java b/moa/src/main/java/moa/streams/generators/cd/AbstractConceptDriftGenerator.java
index 607b53511..7dd440d98 100644
--- a/moa/src/main/java/moa/streams/generators/cd/AbstractConceptDriftGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/cd/AbstractConceptDriftGenerator.java
@@ -24,7 +24,7 @@
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import java.util.ArrayList;
 import java.util.Random;
@@ -96,7 +96,7 @@ protected void prepareForUseImpl(TaskMonitor monitor,
         attributes.addElement(new Attribute("change", binaryLabels));
         attributes.addElement(new Attribute("ground truth input"));
 
-        this.streamHeader = new InstancesHeader(new Instances(
+        this.streamHeader = new InstancesHeader(new InstancesHeader(
                 getCLICreationString(InstanceStream.class), attributes, 0));
         this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
 
diff --git a/moa/src/main/java/moa/streams/generators/multilabel/MetaMultilabelGenerator.java b/moa/src/main/java/moa/streams/generators/multilabel/MetaMultilabelGenerator.java
index 7517e7566..62536ddc5 100644
--- a/moa/src/main/java/moa/streams/generators/multilabel/MetaMultilabelGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/multilabel/MetaMultilabelGenerator.java
@@ -31,7 +31,6 @@
 import moa.tasks.TaskMonitor;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.SparseInstance;
 import moa.core.FastVector;
@@ -75,7 +74,7 @@ public class MetaMultilabelGenerator extends AbstractOptionHandler implements In
 
     protected InstanceStream m_BinaryGenerator = null;
 
-    protected Instances multilabelStreamTemplate = null;
+    protected InstancesHeader multilabelStreamTemplate = null;
 
     protected Random m_MetaRandom = new Random();
 
@@ -152,8 +151,8 @@ public void restart() {
      *
      * @param	si	single-label Instances
      */
-    protected MultilabelInstancesHeader generateMultilabelHeader(Instances si) {
-        Instances mi = new Instances(si, 0, 0);
+    protected MultilabelInstancesHeader generateMultilabelHeader(InstancesHeader si) {
+        InstancesHeader mi = new InstancesHeader(si, 0, 0);
         mi.setClassIndex(-1);
         mi.deleteAttributeAt(mi.numAttributes() - 1);
         FastVector bfv = new FastVector();
diff --git a/moa/src/main/java/moa/streams/generators/multilabel/MultilabelArffFileStream.java b/moa/src/main/java/moa/streams/generators/multilabel/MultilabelArffFileStream.java
index 2da61df1d..cec7e0aa4 100644
--- a/moa/src/main/java/moa/streams/generators/multilabel/MultilabelArffFileStream.java
+++ b/moa/src/main/java/moa/streams/generators/multilabel/MultilabelArffFileStream.java
@@ -21,12 +21,10 @@
 
 import moa.streams.ArffFileStream;
 import moa.streams.MultiTargetInstanceStream;
-
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
 import moa.core.MultilabelInstancesHeader;
 
 import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Stream reader for ARFF files of multilabel data.
diff --git a/moa/src/main/java/moa/tasks/CacheShuffledStream.java b/moa/src/main/java/moa/tasks/CacheShuffledStream.java
index fa623d3aa..ae50c8c53 100644
--- a/moa/src/main/java/moa/tasks/CacheShuffledStream.java
+++ b/moa/src/main/java/moa/tasks/CacheShuffledStream.java
@@ -21,7 +21,7 @@
 
 import java.util.Random;
 
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
 import moa.options.ClassOption;
 import com.github.javacliparser.IntOption;
@@ -58,7 +58,7 @@ public String getPurposeString() {
     @Override
     protected Object doTaskImpl(TaskMonitor monitor, ObjectRepository repository) {
         InstanceStream stream = (InstanceStream) getPreparedClassOption(this.streamOption);
-        Instances cache = new Instances(stream.getHeader(), 0);
+        InstancesHeader cache = new InstancesHeader(stream.getHeader(), 0);
         monitor.setCurrentActivity("Caching instances...", -1.0);
         while ((cache.numInstances() < this.maximumCacheSizeOption.getValue())
                 && stream.hasMoreInstances()) {
diff --git a/moa/src/main/java/moa/tasks/EvaluateInterleavedChunks.java b/moa/src/main/java/moa/tasks/EvaluateInterleavedChunks.java
index 1badc058d..f8c78b6bb 100644
--- a/moa/src/main/java/moa/tasks/EvaluateInterleavedChunks.java
+++ b/moa/src/main/java/moa/tasks/EvaluateInterleavedChunks.java
@@ -38,7 +38,7 @@
 import moa.streams.ExampleStream;
 import moa.streams.InstanceStream;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public class EvaluateInterleavedChunks extends MainTask {
 
@@ -169,7 +169,7 @@ protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
 				&& ((maxInstances < 0) || (instancesProcessed < maxInstances))
 				&& ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
 			
-			Instances chunkInstances = new Instances(stream.getHeader(), chunkSize);
+			InstancesHeader chunkInstances = new InstancesHeader(stream.getHeader(), chunkSize);
 			
 			while (stream.hasMoreInstances() && chunkInstances.numInstances() < chunkSize) {
 				chunkInstances.add((Instance) stream.nextInstance().getData());
diff --git a/moa/src/main/java/moa/tasks/EvaluatePeriodicHeldOutTest.java b/moa/src/main/java/moa/tasks/EvaluatePeriodicHeldOutTest.java
index 1b975d54d..22e8975e6 100644
--- a/moa/src/main/java/moa/tasks/EvaluatePeriodicHeldOutTest.java
+++ b/moa/src/main/java/moa/tasks/EvaluatePeriodicHeldOutTest.java
@@ -42,7 +42,7 @@
 import moa.streams.CachedInstancesStream;
 import moa.streams.ExampleStream;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Task for evaluating a classifier on a stream by periodically testing on a heldout set.
@@ -122,7 +122,7 @@ protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
         int testSize = this.testSizeOption.getValue();
         if (this.cacheTestOption.isSet()) {
             monitor.setCurrentActivity("Caching test examples...", -1.0);
-            Instances testInstances = new Instances(stream.getHeader(),
+            InstancesHeader testInstances = new InstancesHeader(stream.getHeader(),
                     this.testSizeOption.getValue());
             while (testInstances.numInstances() < testSize) {
                 testInstances.add((Instance) stream.nextInstance().getData());
diff --git a/moa/src/test/java/com/yahoo/labs/samoa/instances/MultiTargetArffLoaderTest.java b/moa/src/test/java/com/yahoo/labs/samoa/instances/MultiTargetArffLoaderTest.java
index 42242bebe..1171e785b 100644
--- a/moa/src/test/java/com/yahoo/labs/samoa/instances/MultiTargetArffLoaderTest.java
+++ b/moa/src/test/java/com/yahoo/labs/samoa/instances/MultiTargetArffLoaderTest.java
@@ -23,18 +23,18 @@
 
 public class MultiTargetArffLoaderTest {
 	private static double EPS=0.00000001;
-	private static Instances instancesRegression;
-	private static Instances instancesClassification;
+	private static InstancesHeader instancesRegression;
+	private static InstancesHeader instancesClassification;
 	
 	@BeforeClass
 	public static void setUpBeforeClassRegression() throws Exception {
 		try {
             InputStream fileStream = new FileInputStream(ClassLoader.getSystemResource("moa/classifiers/data/small_regression.arff").getPath());
             Reader  reader= new BufferedReader(new InputStreamReader(fileStream));
-    		instancesRegression = new Instances(reader,new Range("4-6"));
+    		instancesRegression = new InstancesHeader(reader,"4-6");
     		fileStream = new FileInputStream(ClassLoader.getSystemResource("moa/classifiers/data/small_classification.arff").getPath());
     		reader = new BufferedReader(new InputStreamReader(fileStream));
-    		instancesClassification = new Instances(reader,new Range("2"));
+    		instancesClassification = new InstancesHeader(reader,"2");
         } catch (IOException ioe) {
             throw new RuntimeException("ArffFileStream restart failed.", ioe);
         }
@@ -43,12 +43,13 @@ public static void setUpBeforeClassRegression() throws Exception {
 	/*
 	 * TESTS REGRESSION DATASET
 	 */
-	@Test
-	public void testRangeRegression(){
-		assertEquals(3,instancesRegression.arff.range.getStart());
-		assertEquals(5,instancesRegression.arff.range.getEnd());
-	}
+//	@Test
+//	public void testRangeRegression(){
+//		assertEquals(3,instancesRegression.);
+//		assertEquals(5,instancesRegression.arff.range.getEnd());
+//	}
 	
+	@Test
 	public void testClassRegression(){
 		assertEquals(3,instancesRegression.arff.instanceInformation.numOutputAttributes());
 		assertTrue(instancesRegression.arff.instanceInformation.outputAttribute(0).name.equals("R1"));
@@ -155,12 +156,14 @@ public void testInstancesRegression() {
 	 * TESTS REGRESSION DATASET
 	 */
 
-	@Test
-	public void testRangeClassification(){
-		assertEquals(0,instancesClassification.arff.range.getStart());
-		assertEquals(1,instancesClassification.arff.range.getEnd());
-	}
+	// DEPRECATED
 	
+//	@Test
+//	public void testRangeClassification(){
+//		assertEquals(0,instancesClassification.arff.range.getStart());
+//		assertEquals(1,instancesClassification.arff.range.getEnd());
+//	}
+	@Test
 	public void testClassClassification(){
 		assertEquals(2,instancesClassification.arff.instanceInformation.numOutputAttributes());
 		assertTrue(instancesClassification.arff.instanceInformation.outputAttribute(0).name.equals("C1"));
diff --git a/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java b/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java
index 0c5a65e47..5c99a5e92 100644
--- a/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java
+++ b/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java
@@ -37,7 +37,7 @@
 
 import com.yahoo.labs.samoa.instances.ArffLoader;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Instances;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Range;
 
@@ -132,8 +132,8 @@ protected AbstractTestHelper newTestHelper() {
 	 * @return		the data, null if it could not be loaded
 	 * @see		#getDataDirectory()
 	 */
-	protected Instances load(String filename, int classIndex) {
-		Instances	result = null;
+	protected InstancesHeader load(String filename, int classIndex) {
+		InstancesHeader	result = null;
 		//ArffLoader 	loader;
 
 		//result = null;
@@ -145,8 +145,7 @@ protected Instances load(String filename, int classIndex) {
 			TmpFile tmp=new TmpFile(filename);
 			FileInputStream fileStream = new FileInputStream(tmp.getAbsolutePath());
 			Reader reader=new BufferedReader(new InputStreamReader(fileStream));
-			Range range = new Range("-1");
-			result = new Instances(reader,range);
+			result = new InstancesHeader(reader,"-1");
 			result.setClassIndex(classIndex);
 			while (result.readInstance(null));
 		}
@@ -168,7 +167,7 @@ protected Instances load(String filename, int classIndex) {
 	 * @param scheme		the scheme to process the data with
 	 * @return			the processed data
 	 */
-	protected InspectionData[] inspect(Instances data, int[] inspectionPoints, LearningPerformanceEvaluator<Example<Instance>>  evaluator, Classifier scheme) {
+	protected InspectionData[] inspect(InstancesHeader data, int[] inspectionPoints, LearningPerformanceEvaluator<Example<Instance>>  evaluator, Classifier scheme) {
 		InspectionData[]	result;
 		int			i;
 		int			point;
@@ -178,6 +177,7 @@ protected InspectionData[] inspect(Instances data, int[] inspectionPoints, Learn
 		result = new InspectionData[inspectionPoints.length];
 
 		scheme.prepareForUse();
+		scheme.setModelContext(data);
 
 		point = 0;
 		for (i = 0; i < data.numInstances(); i++) {
@@ -296,7 +296,7 @@ protected String createOutputFilename(String input, int no) {
 	 * Compares the processed data against previously saved output data.
 	 */
 	public void testRegression() {
-		Instances					data;
+		InstancesHeader					data;
 		InspectionData[]				processed;
 		boolean					ok;
 		String					regression;
diff --git a/moa/src/test/java/moa/streams/filters/SelectAttributesFilterTest.java b/moa/src/test/java/moa/streams/filters/SelectAttributesFilterTest.java
index 4d6879edf..02ee87bf6 100644
--- a/moa/src/test/java/moa/streams/filters/SelectAttributesFilterTest.java
+++ b/moa/src/test/java/moa/streams/filters/SelectAttributesFilterTest.java
@@ -1,6 +1,8 @@
 package moa.streams.filters;
 
 import static org.junit.Assert.assertEquals;
+
+import moa.streams.ArffFileStream;
 import moa.streams.MultiTargetArffFileStream;
 
 import org.junit.BeforeClass;
@@ -14,7 +16,7 @@ public class SelectAttributesFilterTest {
 
 	@BeforeClass
 	public static void setUpBeforeClass() throws Exception {
-		MultiTargetArffFileStream stream=new MultiTargetArffFileStream(ClassLoader.getSystemResource("moa/classifiers/data/small_regression.arff").getPath(), "4-6");
+		ArffFileStream stream=new ArffFileStream(ClassLoader.getSystemResource("moa/classifiers/data/small_regression.arff").getPath(), "4-6");
 		filter= new SelectAttributesFilter();
 		filter.setInputStream(stream);   
 		filter.inputStringOption.setValue("2-5,8");

From c4a46917f06a4f4c3c08e67d06f6762cca1b47f9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Thu, 24 Mar 2016 13:45:02 +0100
Subject: [PATCH 27/33] AttributeInformation streamlining and other fixes

---
 .../com/github/javacliparser/RangeOption.java |   57 -
 .../labs/samoa/instances/ArffLoader.java      |   17 -
 .../yahoo/labs/samoa/instances/Attribute.java |    5 +
 .../instances/AttributesInformation.java      |   83 +-
 .../labs/samoa/instances/DenseInstance.java   |    5 +
 .../samoa/instances/DenseInstanceData.java    |    5 +
 .../yahoo/labs/samoa/instances/Instance.java  |    2 -
 .../labs/samoa/instances/InstanceImpl.java    |    5 +
 .../samoa/instances/InstanceInformation.java  |   65 +-
 .../labs/samoa/instances/InstancesHeader.java | 1165 ++++++++---------
 .../samoa/instances/MultiLabelPrediction.java |    5 +
 .../com/yahoo/labs/samoa/instances/Range.java |  110 --
 .../LocalMultiTargetClassifier.java           |   11 +-
 .../main/java/moa/streams/ArffFileStream.java |    2 +-
 .../streams/MultiTargetArffFileStream.java    |    1 -
 .../moa/streams/clustering/FileStream.java    |   14 +-
 .../java/moa/streams/filters/RBFFilter.java   |    7 +-
 .../java/moa/streams/filters/ReLUFilter.java  |    7 +-
 .../filters/SelectAttributesFilter.java       |    9 +-
 .../AbstractClassifierTestCase.java           |    4 -
 20 files changed, 668 insertions(+), 911 deletions(-)
 delete mode 100644 moa/src/main/java/com/github/javacliparser/RangeOption.java
 delete mode 100644 moa/src/main/java/com/yahoo/labs/samoa/instances/Range.java

diff --git a/moa/src/main/java/com/github/javacliparser/RangeOption.java b/moa/src/main/java/com/github/javacliparser/RangeOption.java
deleted file mode 100644
index 56f4da850..000000000
--- a/moa/src/main/java/com/github/javacliparser/RangeOption.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright 2007 University of Waikato.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
- * either express or implied. See the License for the specific
- * language governing permissions and limitations under the
- * License.  
- */
-
-package com.github.javacliparser;
-
-import java.util.Arrays;
-import com.yahoo.labs.samoa.instances.Range;
-
-/**
- * Range option.
- *
- * @author Jesse Read (jesse@tsc.uc3m.es)
- * @version $Revision: 7 $
- */
-public class RangeOption extends StringOption {
-
-    private static final long serialVersionUID = 1L;
-
-	public RangeOption(String name, char cliChar, String purpose, String defaultValue) {
-        super(name, cliChar, purpose, defaultValue);
-    }
-
-	/*
-	 * This class will be like StringOption, but expect a string of numbers like Weka's Range
-	 * e.g., 1,2,5-9,end will return something like [0,1,4,5,6,7,8,-1] which we will use later indicate e.g. multiple class attributes
-	 */
-
-	public void setRange(int indices[]) {
-        this.currentVal = Arrays.toString(indices); 								// "[1,2,3]"
-		this.currentVal = this.currentVal.substring(1,this.currentVal.length()-1);	// "1,2,3"
-    }
-    
-	public Range getRange() {	
-        return new Range(this.getValue());
-    }
-
-    /*public int[] getRange() {
-		Range r = new Range(this.getValue());
-        return r.getSelection();
-    }*/
-
-}
-
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
index c427141d8..fa92fc81e 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
@@ -20,7 +20,6 @@
 import java.io.Reader;
 import java.io.StreamTokenizer;
 import java.util.ArrayList;
-import java.util.LinkedList;
 import java.util.List;
 import java.util.logging.Level;
 import java.util.logging.Logger;
@@ -285,35 +284,25 @@ private void setSparseValue(Instance instance, List<Integer> indexValues, List<D
     private Instance readDenseInstanceSparse() {
         //Returns a dense instance
         Instance instance = newDenseInstance(this.instanceInformation.numAttributes());
-        //System.out.println(this.instanceInformation.numAttributes());
         int numAttribute;
         try {
-            //while (streamTokenizer.ttype != StreamTokenizer.TT_EOF) {
             streamTokenizer.nextToken(); // Remove the '{' char
             //For each line
             while (streamTokenizer.ttype != StreamTokenizer.TT_EOL
                     && streamTokenizer.ttype != StreamTokenizer.TT_EOF) {
                 while (streamTokenizer.ttype != '}') {
                     //For each item
-                    //streamTokenizer.nextToken();
-                    //while (streamTokenizer.ttype != '}'){
-                    //System.out.print(streamTokenizer.nval+":");
                     numAttribute = (int) streamTokenizer.nval;
                     streamTokenizer.nextToken();
 
                     if (streamTokenizer.ttype == StreamTokenizer.TT_NUMBER) {
-                        //System.out.print(streamTokenizer.nval + " ");
                         this.setValue(instance, numAttribute, streamTokenizer.nval, true);
-                        //numAttribute++;
-
                     } else if (streamTokenizer.sval != null && (streamTokenizer.ttype == StreamTokenizer.TT_WORD
                             || streamTokenizer.ttype == 34)) {
-                        //System.out.print(streamTokenizer.sval + "/"+this.instanceInformation.attribute(numAttribute).indexOfValue(streamTokenizer.sval)+" ");
                         if (this.auxAttributes.get(numAttribute).isNumeric()) {
                             this.setValue(instance, numAttribute, Double.valueOf(streamTokenizer.sval).doubleValue(), true);
                         } else {
                             this.setValue(instance, numAttribute, this.instanceInformation.attribute(numAttribute).indexOfValue(streamTokenizer.sval), false);
-                            //numAttribute++;
                         }
                     }
                     streamTokenizer.nextToken();
@@ -321,9 +310,6 @@ private Instance readDenseInstanceSparse() {
                 streamTokenizer.nextToken(); //Remove the '}' char
             }
             streamTokenizer.nextToken();
-            //System.out.println("EOL");
-            //}
-
         } catch (IOException ex) {
             Logger.getLogger(ArffLoader.class.getName()).log(Level.SEVERE, null, ex);
         }
@@ -355,7 +341,6 @@ private InstanceInformation getHeader(String outputDefinition, String inputDefin
                             name = Double.toString(streamTokenizer.nval);
                         }
                         streamTokenizer.nextToken();
-                        String type = streamTokenizer.sval;
                         if (streamTokenizer.ttype == '{') {
                             streamTokenizer.nextToken();
                             List<String> attributeLabels = new ArrayList<String>();
@@ -363,10 +348,8 @@ private InstanceInformation getHeader(String outputDefinition, String inputDefin
 
                                 if (streamTokenizer.sval != null) {
                                     attributeLabels.add(streamTokenizer.sval);
-                                   // System.out.print(streamTokenizer.sval + ",");
                                 } else {
                                     attributeLabels.add(Double.toString(streamTokenizer.nval));
-                                    //System.out.print(streamTokenizer.nval + ",");
                                 }
 
                                 streamTokenizer.nextToken();
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java
index 44d552dba..b4bd6dee2 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java
@@ -25,6 +25,11 @@
  */
 public class Attribute implements Serializable {
 
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -3739913325563469730L;
+
 	/** The keyword used to denote the start of an arff attribute declaration */
 	public final static String ARFF_ATTRIBUTE = "@attribute";
 
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/AttributesInformation.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/AttributesInformation.java
index 8fcbb1330..dae542dd4 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/AttributesInformation.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/AttributesInformation.java
@@ -16,7 +16,6 @@
 package com.yahoo.labs.samoa.instances;
 
 import java.io.Serializable;
-import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -27,16 +26,15 @@
  * @version $Revision: 7 $
  */
 public class AttributesInformation implements Serializable {
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 1666190771085863695L;
 
-    /**
+	/**
      * The attribute information.
      */
     protected List<Attribute> attributes;
-    protected List<Integer> indexValues;
-    /**
-     * The number of attributes.
-     */
-    protected int numberAttributes;
 
     /**
      * The attribute used for default for numerical values
@@ -45,29 +43,14 @@ public class AttributesInformation implements Serializable {
 
     public AttributesInformation(AttributesInformation chunk) {
         this.attributes = chunk.attributes;
-        this.indexValues = chunk.indexValues;
-        this.numberAttributes = chunk.numberAttributes;
     }
 
-    public AttributesInformation(List<Attribute> v, List<Integer> i, int numberAttributes) {
+    public AttributesInformation(List<Attribute> v) {
         this.attributes = v;
-        this.indexValues = i;
-        this.numberAttributes = numberAttributes;
-    }
-
-    public AttributesInformation(List<Attribute> v, int numberAttributes) {
-        this.attributes = v;
-        this.indexValues = new ArrayList<Integer>(numberAttributes);
-        for (int i = 0; i < numberAttributes; i++) {
-            this.indexValues.add(i);
-        }
-        this.numberAttributes = numberAttributes;
     }
 
     public AttributesInformation() {
         this.attributes = null;
-        this.indexValues = null;
-        this.numberAttributes = 0;
         this.defaultNumericAttribute = null;
     }
 
@@ -82,17 +65,11 @@ public Attribute attribute(int indexAttribute) {
             //All attributes are numeric
             return defaultNumericAttribute();
         }
-        int location = locateIndex(indexAttribute);
-        if (location == -1) {
-            //if there is not attribute information, it is numeric
-            return defaultNumericAttribute();
-        }
-        return attributes.get(location);
+        return attributes.get(indexAttribute);
     }
 
-    public void add(Attribute attribute, int value) {
+    public void add(Attribute attribute) {
         this.attributes.add(attribute);
-        this.indexValues.add(value);
     }
 
     /**
@@ -102,40 +79,6 @@ public void add(Attribute attribute, int value) {
      */
     public void setAttributes(List<Attribute> v) {
         this.attributes = v;
-        this.numberAttributes=v.size();
-    }
-
-    /**
-     * Locates the greatest index that is not greater than the given index.
-     *
-     * @return the internal index of the attribute index. Returns -1 if no index
-     * with this property could be found
-     */
-    public int locateIndex(int index) {
-
-        int min = 0;
-        int max = this.indexValues.size() - 1;
-
-        if (max == -1) {
-            return -1;
-        }
-
-        // Binary search
-        while ((this.indexValues.get(min) <= index) && (this.indexValues.get(max) >= index)) {
-            int current = (max + min) / 2;
-            if (this.indexValues.get(current) > index) {
-                max = current - 1;
-            } else if (this.indexValues.get(current) < index) {
-                min = current + 1;
-            } else {
-                return current;
-            }
-        }
-        if (this.indexValues.get(max) < index) {
-            return max;
-        } else {
-            return min - 1;
-        }
     }
 
     private Attribute defaultNumericAttribute() {
@@ -145,10 +88,8 @@ private Attribute defaultNumericAttribute() {
         return this.defaultNumericAttribute;
     }
 
-	public void setAttributes(List<Attribute> v, List<Integer> indexValues) {
-	        this.attributes = v;
-	        this.numberAttributes=v.size();	
-	        this.indexValues=indexValues;
-	}
-
+    public int numAttributes() {
+    	return attributes.size();
+    }
+    
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/DenseInstance.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/DenseInstance.java
index bae288728..f8bc4b60d 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/DenseInstance.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/DenseInstance.java
@@ -21,6 +21,11 @@
 public class DenseInstance extends InstanceImpl {
 
     /**
+	 * 
+	 */
+	private static final long serialVersionUID = 2470663722464623836L;
+
+	/**
      * Instantiates a new dense instance.
      *
      * @param weight the weight
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/DenseInstanceData.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/DenseInstanceData.java
index c4ec564ff..200e450a3 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/DenseInstanceData.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/DenseInstanceData.java
@@ -22,6 +22,11 @@
 public class DenseInstanceData implements InstanceData{
 
     /**
+	 * 
+	 */
+	private static final long serialVersionUID = 8799186995568094103L;
+
+	/**
      * Instantiates a new dense instance data.
      *
      * @param array the array
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
index 8d71cea66..d855144a7 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
@@ -17,8 +17,6 @@
 
 import java.io.Serializable;
 
-import moa.AbstractMOAObject;
-
 /**
  * The Interface Instance.
  *
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
index e5fd9321a..434e9492b 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
@@ -23,6 +23,11 @@
 public class InstanceImpl implements MultiLabelInstance {
 
     /**
+	 * 
+	 */
+	private static final long serialVersionUID = -7908832747696137766L;
+
+	/**
      * The weight.
      */
     protected double weight;
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
index d9d769f77..ebb0d8940 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
@@ -19,8 +19,6 @@
 import java.util.ArrayList;
 import java.util.List;
 
-import moa.AbstractMOAObject;
-
 /**
  * The Class InstanceInformation.
  *
@@ -28,7 +26,9 @@
  */
 public class InstanceInformation implements Serializable {
 
-    /**
+	private static final long serialVersionUID = 4240189973932498979L;
+
+	/**
      * The dataset's name.
      */
     protected String relationName;
@@ -39,15 +39,25 @@ public class InstanceInformation implements Serializable {
     protected List<Integer> inputIndexes;
     
     
+    /**
+     * Returns the input attribute.
+     * 
+     * @param w the input attribute index (indexes only input attributes)
+     * @return the input attribute.
+     */
     public Attribute inputAttribute(int w) {
         return this.attributesInformation.attribute(inputAttributeIndex(w));
     }
 
+    /**
+     * Returns the output attribute.
+     * 
+     * @param w the output attribute index (indexes only output attributes)
+     * @return the output attribute.
+     */
     public Attribute outputAttribute(int w) {
         return this.attributesInformation.attribute(outputAttributeIndex(w));
     }
-
-    
     
     /**
      * Instantiates a new instance information.
@@ -71,27 +81,16 @@ public InstanceInformation(String st, List<Attribute> attributes, List<Integer>
         this.relationName = st;
         this.outputIndexes = outputIndexes;
         this.inputIndexes = inputIndexes;
-        this.attributesInformation = new AttributesInformation(attributes, attributes.size());
+        this.attributesInformation = new AttributesInformation(attributes);
     }
     
-    public InstanceInformation(String st, List<Attribute> input, List<Integer> indexes) {
-        this.relationName = st;
-        this.outputIndexes = new ArrayList<Integer>();
-        this.inputIndexes = new ArrayList<Integer>();
-        this.attributesInformation = new AttributesInformation(input, indexes, indexes.size());
-    }
-
     public InstanceInformation(String st, List<Attribute> input) {
         this.relationName = st;
         this.outputIndexes = new ArrayList<Integer>();
         this.inputIndexes = new ArrayList<Integer>();
-        List<Integer> indexes = new ArrayList<Integer>();
-        for (int i = 0; i < input.size(); i++) {
-        	indexes.add(i);
-        }
-        this.attributesInformation = new AttributesInformation(input, indexes, indexes.size());
+        this.attributesInformation = new AttributesInformation(input);
     }
-    
+
     /**
      * Instantiates a new instance information.
      */
@@ -143,7 +142,7 @@ public Attribute classAttribute() {
      * @see com.yahoo.labs.samoa.instances.InstanceInformationInterface#numAttributes()
      */
     public int numAttributes() {
-        return this.attributesInformation.numberAttributes;
+        return this.attributesInformation.numAttributes();
     }
 
     /* (non-Javadoc)
@@ -175,7 +174,7 @@ public void insertAttributeAt(Attribute attribute, int i) {
     }
 
     public void setAttributes(List<Attribute> v) {
-    	if(this.attributesInformation==null)
+    	if(this.attributesInformation == null)
     		this.attributesInformation= new AttributesInformation();
         this.attributesInformation.setAttributes(v);
     }
@@ -198,17 +197,21 @@ public int numOutputAttributes() {
 
     	return outputIndexes.size();
     }
-
-	public void setAttributes(List<Attribute> v, List<Integer> indexValues) {
-    	if(this.attributesInformation==null)
-    		this.attributesInformation= new AttributesInformation();
-        this.attributesInformation.setAttributes(v,indexValues);
-	}
-
+    
+    /**
+     * Sets the output attribute indexes, i.e., the targets. 
+     * 
+     * @param outputIndexes
+     */
 	public void setOutputIndexes(List<Integer> outputIndexes) {
 		this.outputIndexes = outputIndexes;
 	}
 	
+	/**
+     * Sets the input attribute indexes. 
+     * 
+     * @param inputIndexes
+     */
 	public void setInputIndexes(List<Integer> inputIndexes) {
 		this.inputIndexes = inputIndexes;
 	}
@@ -218,9 +221,9 @@ public void setInputIndexes(List<Integer> inputIndexes) {
 	 */
 	public void setInputIndexes() {
 		this.inputIndexes = new ArrayList<Integer>();
-		for (int i = 0; i < attributesInformation.indexValues.size(); i++) {
-			if (!outputIndexes.contains(attributesInformation.indexValues.get(i))) {
-				inputIndexes.add(attributesInformation.indexValues.get(i));
+		for (int i = 0; i < attributesInformation.numAttributes(); i++) {
+			if (!outputIndexes.contains(i)) {
+				inputIndexes.add(i);
 			}
 		}
 	}
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
index 421cbb74e..30401fdf5 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
@@ -22,8 +22,6 @@
 import java.util.List;
 import java.util.Random;
 
-import org.junit.experimental.theories.Theories;
-
 import moa.core.Utils;
 
 /**
@@ -33,624 +31,625 @@
  */
 public class InstancesHeader implements Serializable {
 
-    /** The keyword used to denote the start of an arff header */
-    public final static String ARFF_RELATION = "@relation";
-  
-    /** The keyword used to denote the start of the arff data section */
-    public final static String ARFF_DATA = "@data";
-    
-    private static final long serialVersionUID = 1L;
-
-	/**
-     * The instance information.
-     */
-    protected InstanceInformation instanceInformation;
-    /**
-     * The instances.
-     */
-    protected List<Instance> instances;
-
-    /**
-     * The arff.
-     */
-    protected ArffLoader arff;
-
-    /**
-     * Instantiates a new instances.
-     *
-     * @param chunk the chunk
-     */
-    public InstancesHeader(InstancesHeader chunk) {
-        this(chunk, chunk.numInstances());
-        chunk.copyInstances(0, this, chunk.numInstances());
-    }
-
-    /**
-     * Instantiates a new instances.
-     */
-    public InstancesHeader() {
-    }
-
-    /**
-     * Instantiates a new instances.
-     *
-     * @param reader the reader
-     * @param size the size
-     * @param classAttribute the class attribute
-     */
-    public InstancesHeader(Reader reader, int size, int classAttribute) {
-        arff = new ArffLoader(reader, String.valueOf(classAttribute));
-    	this.instanceInformation = arff.instanceInformation;
-        this.instances = new ArrayList<Instance>();
-    }
-
-    public InstancesHeader(Reader reader, String outputDefinition) {
-    	this.arff = new ArffLoader(reader, outputDefinition);
-    	this.instanceInformation = arff.instanceInformation;
-    	this.instances = new ArrayList<Instance>();
-    }
-    
-    public InstancesHeader(Reader reader, String outputDefinition, String inputDefinition) {
-    	this.arff = new ArffLoader(reader, outputDefinition, inputDefinition);
-    	this.instanceInformation = arff.instanceInformation;
-    	this.instances = new ArrayList<Instance>();
-    }
-    
-    public InstancesHeader(Reader reader, int size, String outputDefinition, String inputDefinition) {
-    	this.arff = new ArffLoader(reader, outputDefinition, inputDefinition);
-    	this.instanceInformation = arff.instanceInformation;
-    	this.instances = new ArrayList<Instance>();
-    }
-    
-    /**
-     * Instantiates a new instances.
-     *
-     * @param reader the reader
-     * @param range
-     */
-//    public Instances(Reader reader, Range range) {
-//        this.arff = new MultiTargetArffLoader(reader, range);
-//        this.instanceInformation = arff.getStructure();
-//        this.instances = new ArrayList<Instance>();
-//    }
-
-    /**
-     * Instantiates a new instances.
-     *
-     * @param chunk the chunk
-     * @param capacity the capacity
-     */
-    public InstancesHeader(InstancesHeader chunk, int capacity) {
-        this.instanceInformation = chunk.instanceInformation();
-        if (capacity < 0) {
-            capacity = 0;
-        }
-        this.instances = new ArrayList<Instance>(capacity);
-    }
-
-    /**
-     * Instantiates a new instances.
-     *
-     * @param st the st
-     * @param v the v
-     * @param capacity the capacity
-     */
-    public InstancesHeader(String st, List<Attribute> v, int capacity) {
-        this.instanceInformation = new InstanceInformation(st, v);
-    }
-
-    /**
-     * Instantiates a new instances.
-     *
-     * @param chunk the chunk
-     * @param first the first instance
-     * @param toCopy the j
-     */
-    public InstancesHeader(InstancesHeader chunk, int first, int toCopy) {
-
-        this(chunk, toCopy);
-
-        if ((first < 0) || ((first + toCopy) > chunk.numInstances())) {
-            throw new IllegalArgumentException("Parameters first and/or toCopy out "
-                    + "of range");
-        }
-        chunk.copyInstances(first, this, toCopy);
-    }
-
-    /**
-     * Instantiates a new instances.
-     *
-     * @param st the st
-     * @param capacity the capacity
-     */
-    public InstancesHeader(StringReader st, int capacity) {
-         this.instances = new ArrayList<Instance>(capacity);
-    }
-
-    //Information Instances
-    /**
-     * Sets the relation name.
-     *
-     * @param string the new relation name
-     */
-    public void setRelationName(String string) {
-        this.instanceInformation.setRelationName(string);
-    }
-
-    /**
-     * Gets the relation name.
-     *
-     * @return the relation name
-     */
-    public String getRelationName() {
-        return this.instanceInformation.getRelationName();
-    }
-
-    /**
-     * Class index.
-     *
-     * @return the int
-     */
-    public int classIndex() {
-        return this.instanceInformation.classIndex();
-    }
-
-    /**
-     * Sets the class index. Also sets all other attributes as input attributes for backward compatibility.
-     *
-     * @param classIndex the new class index
-     */
-    public void setClassIndex(int classIndex) {
-        this.instanceInformation.setClassIndex(classIndex);
-        this.instanceInformation.setInputIndexes();
-    }
-
-    public void setOutputIndexes(List<Integer> outputIndexes) {
-        this.instanceInformation.setOutputIndexes(outputIndexes);
-    }
-
-    public void setInputIndexes(List<Integer> inputIndexes) {
-        this.instanceInformation.setInputIndexes(inputIndexes);
-    }
+	/** The keyword used to denote the start of an arff header */
+	public final static String ARFF_RELATION = "@relation";
+
+	/** The keyword used to denote the start of the arff data section */
+	public final static String ARFF_DATA = "@data";
+
+	private static final long serialVersionUID = 1L;
+
+	/**
+	 * The instance information.
+	 */
+	protected InstanceInformation instanceInformation;
+	/**
+	 * The instances.
+	 */
+	protected List<Instance> instances;
+
+	/**
+	 * The arff.
+	 */
+	protected ArffLoader arff;
+
+	/**
+	 * Instantiates a new instances.
+	 *
+	 * @param chunk the chunk
+	 */
+	public InstancesHeader(InstancesHeader chunk) {
+		this(chunk, chunk.numInstances());
+		chunk.copyInstances(0, this, chunk.numInstances());
+	}
+
+	/**
+	 * Instantiates a new instances.
+	 */
+	public InstancesHeader() {
+	}
+
+	/**
+	 * Instantiates a new instances.
+	 *
+	 * @param reader the reader
+	 * @param size the size
+	 * @param classAttribute the class attribute
+	 */
+	public InstancesHeader(Reader reader, int size, int classAttribute) {
+		arff = new ArffLoader(reader, String.valueOf(classAttribute));
+		this.instanceInformation = arff.instanceInformation;
+		this.instances = new ArrayList<Instance>();
+	}
+
+	/**
+	 * Instantiates a new intances header.
+	 * 
+	 * @param reader 
+	 * @param outputDefinition defines the output attributes (others are treated as inputs)
+	 */
+	public InstancesHeader(Reader reader, String outputDefinition) {
+		this.arff = new ArffLoader(reader, outputDefinition);
+		this.instanceInformation = arff.instanceInformation;
+		this.instances = new ArrayList<Instance>();
+	}
+
+	/**
+	 * Instantiates a new intances header.
+	 * 
+	 * @param reader
+	 * @param outputDefinition defines the output attributes
+	 * @param inputDefinition defines the input attributes
+	 */
+	public InstancesHeader(Reader reader, String outputDefinition, String inputDefinition) {
+		this.arff = new ArffLoader(reader, outputDefinition, inputDefinition);
+		this.instanceInformation = arff.instanceInformation;
+		this.instances = new ArrayList<Instance>();
+	}
+
+	/**
+	 * Instantiates a new instances.
+	 *
+	 * @param reader the reader
+	 * @param range
+	 */
+	//    public Instances(Reader reader, Range range) {
+	//        this.arff = new MultiTargetArffLoader(reader, range);
+	//        this.instanceInformation = arff.getStructure();
+	//        this.instances = new ArrayList<Instance>();
+	//    }
+
+	/**
+	 * Instantiates a new instances.
+	 *
+	 * @param chunk the chunk
+	 * @param capacity the capacity
+	 */
+	public InstancesHeader(InstancesHeader chunk, int capacity) {
+		this.instanceInformation = chunk.instanceInformation();
+		if (capacity < 0) {
+			capacity = 0;
+		}
+		this.instances = new ArrayList<Instance>(capacity);
+	}
+
+	/**
+	 * Instantiates a new instances.
+	 *
+	 * @param st the st
+	 * @param v the v
+	 * @param capacity the capacity
+	 */
+	public InstancesHeader(String st, List<Attribute> v, int capacity) {
+		this.instanceInformation = new InstanceInformation(st, v);
+	}
+
+	/**
+	 * Instantiates a new instances.
+	 *
+	 * @param chunk the chunk
+	 * @param first the first instance
+	 * @param toCopy the j
+	 */
+	public InstancesHeader(InstancesHeader chunk, int first, int toCopy) {
+
+		this(chunk, toCopy);
+
+		if ((first < 0) || ((first + toCopy) > chunk.numInstances())) {
+			throw new IllegalArgumentException("Parameters first and/or toCopy out "
+					+ "of range");
+		}
+		chunk.copyInstances(first, this, toCopy);
+	}
+
+	/**
+	 * Instantiates a new instances.
+	 *
+	 * @param st the st
+	 * @param capacity the capacity
+	 */
+	public InstancesHeader(StringReader st, int capacity) {
+		this.instances = new ArrayList<Instance>(capacity);
+	}
+
+	//Information Instances
+	/**
+	 * Sets the relation name.
+	 *
+	 * @param string the new relation name
+	 */
+	public void setRelationName(String string) {
+		this.instanceInformation.setRelationName(string);
+	}
+
+	/**
+	 * Gets the relation name.
+	 *
+	 * @return the relation name
+	 */
+	public String getRelationName() {
+		return this.instanceInformation.getRelationName();
+	}
+
+	/**
+	 * Class index.
+	 *
+	 * @return the int
+	 */
+	public int classIndex() {
+		return this.instanceInformation.classIndex();
+	}
+
+	/**
+	 * Sets the class index. Also sets all other attributes as input attributes for backward compatibility.
+	 *
+	 * @param classIndex the new class index
+	 */
+	public void setClassIndex(int classIndex) {
+		this.instanceInformation.setClassIndex(classIndex);
+		this.instanceInformation.setInputIndexes();
+	}
+
+	public void setOutputIndexes(List<Integer> outputIndexes) {
+		this.instanceInformation.setOutputIndexes(outputIndexes);
+	}
+
+	public void setInputIndexes(List<Integer> inputIndexes) {
+		this.instanceInformation.setInputIndexes(inputIndexes);
+	}
 
 	/** 
 	 * Sets all non-output attributes as input attributes.
 	 */
 	public void setInputIndexes() {
-        this.instanceInformation.setInputIndexes();
-	}
-    
-    /**
-     * Class attribute.
-     *
-     * @return the attribute
-     */
-    public Attribute classAttribute() {
-        return this.instanceInformation.classAttribute();
-    }
-
-    /**
-     * Num attributes.
-     *
-     * @return the int
-     */
-    public int numAttributes() {
-        return this.instanceInformation.numAttributes();
-    }
-
-    /**
-     * Attribute.
-     *
-     * @param w the w
-     * @return the attribute
-     */
-    public Attribute attribute(int w) {
-        return this.instanceInformation.attribute(w);
-    }
-
-    /**
-     * Num classes.
-     *
-     * @return the int
-     */
-    public int numClasses() {
-        return this.instanceInformation.numClasses();
-    }
-
-    /**
-     * Delete attribute at.
-     *
-     * @param integer the integer
-     */
-    public void deleteAttributeAt(Integer integer) {
-        this.instanceInformation.deleteAttributeAt(integer);
-    }
-
-    /**
-     * Insert attribute at.
-     *
-     * @param attribute the attribute
-     * @param i the i
-     */
-    public void insertAttributeAt(Attribute attribute, int i) {
-    	if (this.instanceInformation==null)
-    		this.instanceInformation= new InstanceInformation();
-        this.instanceInformation.insertAttributeAt(attribute, i);
-    }
-
-    //List of Instances
-    /**
-     * Instance.
-     *
-     * @param num the num
-     * @return the instance
-     */
-    public Instance instance(int num) {
-        return this.instances.get(num);
-    }
-
-    /**
-     * Num instances.
-     *
-     * @return the int
-     */
-    public int numInstances() {
-        return this.instances.size();
-    }
-
-    /**
-     * Adds the.
-     *
-     * @param inst the inst
-     */
-    public void add(Instance inst) {
-        this.instances.add(inst.copy());
-    }
-
-    /**
-     * Randomize.
-     *
-     * @param random the random
-     */
-    public void randomize(Random random) {
-        for (int j = numInstances() - 1; j > 0; j--) {
-            swap(j, random.nextInt(j + 1));
-        }
-    }
-
-    /**
-     * Stratify.
-     *
-     * @param numFolds the num folds
-     */
-    public void stratify(int numFolds) {
-
-        if (classAttribute().isNominal()) {
-
-            // sort by class
-            int index = 1;
-            while (index < numInstances()) {
-                Instance instance1 = instance(index - 1);
-                for (int j = index; j < numInstances(); j++) {
-                    Instance instance2 = instance(j);
-                    if ((instance1.classValue() == instance2.classValue())
-                            || (instance1.classIsMissing()
-                            && instance2.classIsMissing())) {
-                        swap(index, j);
-                        index++;
-                    }
-                }
-                index++;
-            }
-            stratStep(numFolds);
-        }
-    }
-
-    protected void stratStep(int numFolds) {
-        ArrayList<Instance> newVec = new ArrayList<Instance>(this.instances.size());
-        int start = 0, j;
-
-        // create stratified batch
-        while (newVec.size() < numInstances()) {
-            j = start;
-            while (j < numInstances()) {
-                newVec.add(instance(j));
-                j = j + numFolds;
-            }
-            start++;
-        }
-        this.instances = newVec;
-    }
-
-    /**
-     * Train cv.
-     *
-     * @param numFolds the num folds
-     * @param numFold
-     * @param n the n
-     * @param random the random
-     * @return the instances
-     */
-    public InstancesHeader trainCV(int numFolds, int numFold, Random random) {
-        InstancesHeader train = trainCV(numFolds, numFold);
-        train.randomize(random);
-        return train;
-    }
-
-    public InstancesHeader trainCV(int numFolds, int numFold) {
-        int numInstForFold, first, offset;
-        InstancesHeader train;
-
-        numInstForFold = numInstances() / numFolds;
-        if (numFold < numInstances() % numFolds) {
-            numInstForFold++;
-            offset = numFold;
-        } else {
-            offset = numInstances() % numFolds;
-        }
-        train = new InstancesHeader(this, numInstances() - numInstForFold);
-        first = numFold * (numInstances() / numFolds) + offset;
-        copyInstances(0, train, first);
-        copyInstances(first + numInstForFold, train,
-                numInstances() - first - numInstForFold);
-        return train;
-    }
-
-    protected void copyInstances(int from, InstancesHeader dest, int num) {
-        for (int i = 0; i < num; i++) {
-            dest.add(instance(from + i));
-        }
-    }
-
-    /**
-     * Test cv.
-     *
-     * @param numFolds the num folds
-     * @param numFold the num fold
-     * @return the instances
-     */
-    public InstancesHeader testCV(int numFolds, int numFold) {
-
-        int numInstForFold, first, offset;
-        InstancesHeader test;
-
-        numInstForFold = numInstances() / numFolds;
-        if (numFold < numInstances() % numFolds) {
-            numInstForFold++;
-            offset = numFold;
-        } else {
-            offset = numInstances() % numFolds;
-        }
-        test = new InstancesHeader(this, numInstForFold);
-        first = numFold * (numInstances() / numFolds) + offset;
-        copyInstances(first, test, numInstForFold);
-        return test;
-    }
-
-    /*  public Instances dataset() {
+		this.instanceInformation.setInputIndexes();
+	}
+
+	/**
+	 * Class attribute.
+	 *
+	 * @return the attribute
+	 */
+	public Attribute classAttribute() {
+		return this.instanceInformation.classAttribute();
+	}
+
+	/**
+	 * Num attributes.
+	 *
+	 * @return the int
+	 */
+	public int numAttributes() {
+		return this.instanceInformation.numAttributes();
+	}
+
+	/**
+	 * Attribute.
+	 *
+	 * @param w the w
+	 * @return the attribute
+	 */
+	public Attribute attribute(int w) {
+		return this.instanceInformation.attribute(w);
+	}
+
+	/**
+	 * Num classes.
+	 *
+	 * @return the int
+	 */
+	public int numClasses() {
+		return this.instanceInformation.numClasses();
+	}
+
+	/**
+	 * Delete attribute at.
+	 *
+	 * @param integer the integer
+	 */
+	public void deleteAttributeAt(Integer integer) {
+		this.instanceInformation.deleteAttributeAt(integer);
+	}
+
+	/**
+	 * Insert attribute at.
+	 *
+	 * @param attribute the attribute
+	 * @param i the i
+	 */
+	public void insertAttributeAt(Attribute attribute, int i) {
+		if (this.instanceInformation==null)
+			this.instanceInformation= new InstanceInformation();
+		this.instanceInformation.insertAttributeAt(attribute, i);
+	}
+
+	//List of Instances
+	/**
+	 * Instance.
+	 *
+	 * @param num the num
+	 * @return the instance
+	 */
+	public Instance instance(int num) {
+		return this.instances.get(num);
+	}
+
+	/**
+	 * Num instances.
+	 *
+	 * @return the int
+	 */
+	public int numInstances() {
+		return this.instances.size();
+	}
+
+	/**
+	 * Adds the.
+	 *
+	 * @param inst the inst
+	 */
+	public void add(Instance inst) {
+		this.instances.add(inst.copy());
+	}
+
+	/**
+	 * Randomize.
+	 *
+	 * @param random the random
+	 */
+	public void randomize(Random random) {
+		for (int j = numInstances() - 1; j > 0; j--) {
+			swap(j, random.nextInt(j + 1));
+		}
+	}
+
+	/**
+	 * Stratify.
+	 *
+	 * @param numFolds the num folds
+	 */
+	public void stratify(int numFolds) {
+
+		if (classAttribute().isNominal()) {
+
+			// sort by class
+			int index = 1;
+			while (index < numInstances()) {
+				Instance instance1 = instance(index - 1);
+				for (int j = index; j < numInstances(); j++) {
+					Instance instance2 = instance(j);
+					if ((instance1.classValue() == instance2.classValue())
+							|| (instance1.classIsMissing()
+									&& instance2.classIsMissing())) {
+						swap(index, j);
+						index++;
+					}
+				}
+				index++;
+			}
+			stratStep(numFolds);
+		}
+	}
+
+	protected void stratStep(int numFolds) {
+		ArrayList<Instance> newVec = new ArrayList<Instance>(this.instances.size());
+		int start = 0, j;
+
+		// create stratified batch
+		while (newVec.size() < numInstances()) {
+			j = start;
+			while (j < numInstances()) {
+				newVec.add(instance(j));
+				j = j + numFolds;
+			}
+			start++;
+		}
+		this.instances = newVec;
+	}
+
+	/**
+	 * Train cv.
+	 *
+	 * @param numFolds the num folds
+	 * @param numFold
+	 * @param n the n
+	 * @param random the random
+	 * @return the instances
+	 */
+	public InstancesHeader trainCV(int numFolds, int numFold, Random random) {
+		InstancesHeader train = trainCV(numFolds, numFold);
+		train.randomize(random);
+		return train;
+	}
+
+	public InstancesHeader trainCV(int numFolds, int numFold) {
+		int numInstForFold, first, offset;
+		InstancesHeader train;
+
+		numInstForFold = numInstances() / numFolds;
+		if (numFold < numInstances() % numFolds) {
+			numInstForFold++;
+			offset = numFold;
+		} else {
+			offset = numInstances() % numFolds;
+		}
+		train = new InstancesHeader(this, numInstances() - numInstForFold);
+		first = numFold * (numInstances() / numFolds) + offset;
+		copyInstances(0, train, first);
+		copyInstances(first + numInstForFold, train,
+				numInstances() - first - numInstForFold);
+		return train;
+	}
+
+	protected void copyInstances(int from, InstancesHeader dest, int num) {
+		for (int i = 0; i < num; i++) {
+			dest.add(instance(from + i));
+		}
+	}
+
+	/**
+	 * Test cv.
+	 *
+	 * @param numFolds the num folds
+	 * @param numFold the num fold
+	 * @return the instances
+	 */
+	public InstancesHeader testCV(int numFolds, int numFold) {
+
+		int numInstForFold, first, offset;
+		InstancesHeader test;
+
+		numInstForFold = numInstances() / numFolds;
+		if (numFold < numInstances() % numFolds) {
+			numInstForFold++;
+			offset = numFold;
+		} else {
+			offset = numInstances() % numFolds;
+		}
+		test = new InstancesHeader(this, numInstForFold);
+		first = numFold * (numInstances() / numFolds) + offset;
+		copyInstances(first, test, numInstForFold);
+		return test;
+	}
+
+	/*  public Instances dataset() {
      throw new UnsupportedOperationException("Not yet implemented");
      }*/
-    /**
-     * Mean or mode.
-     *
-     * @param j the j
-     * @return the double
-     */
-    public double meanOrMode(int j) {
-        throw new UnsupportedOperationException("Not yet implemented"); //CobWeb
-    }
-
-    /**
-     * Read instance.
-     *
-     * @param fileReader the file reader
-     * @return true, if successful
-     */
-    public boolean readInstance(Reader fileReader) {
-
-        //ArffReader arff = new ArffReader(reader, this, m_Lines, 1);
-        Instance inst = arff.readInstance();
-        if (inst != null) {
-            inst.setDataset(this);
-            add(inst);
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    /**
-     * Delete.
-     */
-    public void delete() {
-        this.instances = new ArrayList<Instance>();
-    }
-    
-     /**
-     * Delete.
-     */
-    public void delete(int index) {
-        this.instances.remove(index);
-    }
-
-
-    /**
-     * Swap.
-     *
-     * @param i the i
-     * @param j the j
-     */
-    public void swap(int i, int j) {
-        Instance in = instances.get(i);
-        instances.set(i, instances.get(j));
-        instances.set(j, in);
-    }
-
-    /**
-     * Instance information.
-     *
-     * @return the instance information
-     */
-    private InstanceInformation instanceInformation() {
-        return this.instanceInformation;
-    }
-
-    public Attribute attribute(String name) {
-
-        for (int i = 0; i < numAttributes(); i++) {
-            if (attribute(i).name().equals(name)) {
-                return attribute(i);
-            }
-        }
-        return null;
-    }
-
-    public int size() {
-        return this.numInstances();
-    }
-
-    public void set(int i, Instance inst) {
-        this.instances.set(i, inst);
-    }
-
-    public Instance get(int k) {
-        return this.instance(k);
-    }
-
-//	public void setRangeOutputIndices(Range range) {
-//		this.instanceInformation.setRangeOutputIndices(range);
-//		
-//	}
-	
-    public void setAttributes(List<Attribute> v) {
-    	if(this.instanceInformation==null)
-    		this.instanceInformation= new InstanceInformation();
-        this.instanceInformation.setAttributes(v);
-    }
-    
-    public void setAttributes(List<Attribute> v, List<Integer> indexValues) {
-    	if(this.instanceInformation==null)
-    		this.instanceInformation= new InstanceInformation();
-        this.instanceInformation.setAttributes(v, indexValues);
-    }
-    
-      /**
-   * Returns the dataset as a string in ARFF format. Strings
-   * are quoted if they contain whitespace characters, or if they
-   * are a question mark.
-   *
-   * @return the dataset in ARFF format as a string
-   */
-  public String toString() {
-    
-    StringBuffer text = new StringBuffer();
-    
-    text.append(ARFF_RELATION).append(" ").
-      append(Utils.quote( this.instanceInformation.getRelationName())).append("\n\n");
-    for (int i = 0; i < numAttributes(); i++) {
-      text.append(attribute(i).toString()).append("\n");
-    }
-    text.append("\n").append(ARFF_DATA).append("\n");
-
-    text.append(stringWithoutHeader());
-    return text.toString();
-  }
-  
-    /**
-   * Returns the instances in the dataset as a string in ARFF format. Strings
-   * are quoted if they contain whitespace characters, or if they
-   * are a question mark.
-   *
-   * @return the dataset in ARFF format as a string
-   */
-  protected String stringWithoutHeader() {
-    
-    StringBuffer text = new StringBuffer();
-
-    for (int i = 0; i < numInstances(); i++) {
-      text.append(instance(i));
-      if (i < numInstances() - 1) {
-	text.append('\n');
-      }
-    }
-    return text.toString();
-    
-  }
+	/**
+	 * Mean or mode.
+	 *
+	 * @param j the j
+	 * @return the double
+	 */
+	public double meanOrMode(int j) {
+		throw new UnsupportedOperationException("Not yet implemented"); //CobWeb
+	}
+
+	/**
+	 * Read instance.
+	 *
+	 * @param fileReader the file reader
+	 * @return true, if successful
+	 */
+	public boolean readInstance(Reader fileReader) {
+
+		//ArffReader arff = new ArffReader(reader, this, m_Lines, 1);
+		Instance inst = arff.readInstance();
+		if (inst != null) {
+			inst.setDataset(this);
+			add(inst);
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	/**
+	 * Delete.
+	 */
+	public void delete() {
+		this.instances = new ArrayList<Instance>();
+	}
+
+	/**
+	 * Delete.
+	 */
+	public void delete(int index) {
+		this.instances.remove(index);
+	}
+
+
+	/**
+	 * Swap.
+	 *
+	 * @param i the i
+	 * @param j the j
+	 */
+	public void swap(int i, int j) {
+		Instance in = instances.get(i);
+		instances.set(i, instances.get(j));
+		instances.set(j, in);
+	}
+
+	/**
+	 * Instance information.
+	 *
+	 * @return the instance information
+	 */
+	private InstanceInformation instanceInformation() {
+		return this.instanceInformation;
+	}
+
+	public Attribute attribute(String name) {
+
+		for (int i = 0; i < numAttributes(); i++) {
+			if (attribute(i).name().equals(name)) {
+				return attribute(i);
+			}
+		}
+		return null;
+	}
+
+	public int size() {
+		return this.numInstances();
+	}
+
+	public void set(int i, Instance inst) {
+		this.instances.set(i, inst);
+	}
+
+	public Instance get(int k) {
+		return this.instance(k);
+	}
+
+	//	public void setRangeOutputIndices(Range range) {
+	//		this.instanceInformation.setRangeOutputIndices(range);
+	//		
+	//	}
+
+	public void setAttributes(List<Attribute> v) {
+		if(this.instanceInformation==null)
+			this.instanceInformation= new InstanceInformation();
+		this.instanceInformation.setAttributes(v);
+	}
+
+	/**
+	 * Returns the dataset as a string in ARFF format. Strings
+	 * are quoted if they contain whitespace characters, or if they
+	 * are a question mark.
+	 *
+	 * @return the dataset in ARFF format as a string
+	 */
+	public String toString() {
+
+		StringBuffer text = new StringBuffer();
+
+		text.append(ARFF_RELATION).append(" ").
+		append(Utils.quote( this.instanceInformation.getRelationName())).append("\n\n");
+		for (int i = 0; i < numAttributes(); i++) {
+			text.append(attribute(i).toString()).append("\n");
+		}
+		text.append("\n").append(ARFF_DATA).append("\n");
+
+		text.append(stringWithoutHeader());
+		return text.toString();
+	}
+
+	/**
+	 * Returns the instances in the dataset as a string in ARFF format. Strings
+	 * are quoted if they contain whitespace characters, or if they
+	 * are a question mark.
+	 *
+	 * @return the dataset in ARFF format as a string
+	 */
+	protected String stringWithoutHeader() {
+
+		StringBuffer text = new StringBuffer();
+
+		for (int i = 0; i < numInstances(); i++) {
+			text.append(instance(i));
+			if (i < numInstances() - 1) {
+				text.append('\n');
+			}
+		}
+		return text.toString();
+
+	}
 
 	public Attribute inputAttribute(int w) {
-	    return this.instanceInformation.inputAttribute(w);
+		return this.instanceInformation.inputAttribute(w);
 	}
 
 	public Attribute outputAttribute(int w) {
-	    return this.instanceInformation.outputAttribute(w);
+		return this.instanceInformation.outputAttribute(w);
 	}
 
 	public int numInputAttributes() {
-	    return this.instanceInformation.numInputAttributes();
+		return this.instanceInformation.numInputAttributes();
 	}
 
 	public int numOutputAttributes() {
-	    return this.instanceInformation.numOutputAttributes();
+		return this.instanceInformation.numOutputAttributes();
 	}
 
 	public InstanceInformation getInstanceInformation() {
-	    return this.instanceInformation;
+		return this.instanceInformation;
 	}
 
 	public static String getClassNameString(InstancesHeader context) {
-	    if (context == null) {
-	        return "[class]";
-	    }
-	    return "[class:" + context.classAttribute().name() + "]";
+		if (context == null) {
+			return "[class]";
+		}
+		return "[class:" + context.classAttribute().name() + "]";
 	}
 
 	public static String getClassLabelString(InstancesHeader context, int classLabelIndex) {
-	    if ((context == null) || (classLabelIndex >= context.numClasses())) {
-	        return "<class " + (classLabelIndex + 1) + ">";
-	    }
-	    return "<class " + (classLabelIndex + 1) + ":"
-	            + context.classAttribute().value(classLabelIndex) + ">";
+		if ((context == null) || (classLabelIndex >= context.numClasses())) {
+			return "<class " + (classLabelIndex + 1) + ">";
+		}
+		return "<class " + (classLabelIndex + 1) + ":"
+		+ context.classAttribute().value(classLabelIndex) + ">";
 	}
 
 	public static String getAttributeNameString(InstancesHeader context, int attIndex) {
-	    if ((context == null) || (attIndex >= context.numAttributes())) {
-	        return "[att " + (attIndex + 1) + "]";
-	    }
-	    return "[att " + (attIndex + 1) + ":"
-	            + context.attribute(attIndex).name() + "]";
+		if ((context == null) || (attIndex >= context.numAttributes())) {
+			return "[att " + (attIndex + 1) + "]";
+		}
+		return "[att " + (attIndex + 1) + ":"
+		+ context.attribute(attIndex).name() + "]";
 	}
 
 	public static String getInputAttributeNameString(InstancesHeader context, int attIndex) {
-	    if ((context == null) || (attIndex >= context.numInputAttributes())) {
-	        return "[att " + (attIndex + 1) + "]";
-	    }
-	    return "[att " + (attIndex + 1) + ":"
-	            + context.inputAttribute(attIndex).name() + "]";
+		if ((context == null) || (attIndex >= context.numInputAttributes())) {
+			return "[att " + (attIndex + 1) + "]";
+		}
+		return "[att " + (attIndex + 1) + ":"
+		+ context.inputAttribute(attIndex).name() + "]";
 	}
 
 	public static String getNominalValueString(InstancesHeader context, int attIndex, int valIndex) {
-	    if (context != null) {
-	        if ((attIndex < context.numInputAttributes())
-	                && (valIndex < context.inputAttribute(attIndex).numValues())) {
-	            return "{val " + (valIndex + 1) + ":"
-	                    + context.inputAttribute(attIndex).value(valIndex) + "}";
-	        }
-	    }
-	    return "{val " + (valIndex + 1) + "}";
+		if (context != null) {
+			if ((attIndex < context.numInputAttributes())
+					&& (valIndex < context.inputAttribute(attIndex).numValues())) {
+				return "{val " + (valIndex + 1) + ":"
+						+ context.inputAttribute(attIndex).value(valIndex) + "}";
+			}
+		}
+		return "{val " + (valIndex + 1) + "}";
 	}
 
 	public static String getNumericValueString(InstancesHeader context, int attIndex, double value) {
-	    if (context != null) {
-	        int instAttIndex = attIndex < context.classIndex() ? attIndex
-	                : attIndex + 1;
-	        if (instAttIndex < context.numAttributes()) {
-	            if (context.attribute(instAttIndex).isDate()) {
-	                return context.attribute(instAttIndex).formatDate(value);
-	            }
-	        }
-	    }
-	    return Double.toString(value);
-	}
-
-	
+		if (context != null) {
+			int instAttIndex = attIndex < context.classIndex() ? attIndex
+					: attIndex + 1;
+			if (instAttIndex < context.numAttributes()) {
+				if (context.attribute(instAttIndex).isDate()) {
+					return context.attribute(instAttIndex).formatDate(value);
+				}
+			}
+		}
+		return Double.toString(value);
+	}
+
+
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
index 12b35c5a3..7e8fb2bdc 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
@@ -18,6 +18,11 @@
 import java.io.Serializable;
 
 public class MultiLabelPrediction implements Prediction, Serializable {
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 1413498152667626736L;
+	
 	protected DoubleVector [] prediction;
 
 	public MultiLabelPrediction() {
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/Range.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/Range.java
deleted file mode 100644
index d02e5fbbc..000000000
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/Range.java
+++ /dev/null
@@ -1,110 +0,0 @@
-
-/*
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
- * either express or implied. See the License for the specific
- * language governing permissions and limitations under the
- * License.  
- */
-package com.yahoo.labs.samoa.instances;
-
-import java.io.Serializable;
-
-public class Range implements Serializable {
-
-    //Only works for ranges "start-end"
-    private int start = 0;
-    private int end = 0;
-    private int upperLimit = 0;
-    private final String rangeText;
-
-    public Range(String range) {
-        this.rangeText = range;
-        //this.setRange(range); //needs upperLimit
-    }
-
-    /**
-     * Sets the range from a string representation.
-     *
-     * @param range the start and end string
-     *
-     */
-    public void setRange(String range) {
-        String single = range.trim();
-        int hyphenIndex = range.indexOf('-');
-
-        if (hyphenIndex > 0) {
-            this.start = rangeSingle(range.substring(0, hyphenIndex));
-            this.end = rangeSingle(range.substring(hyphenIndex + 1));
-        } else {
-            int number = rangeSingle(range);
-            if (number >= 0) { // first n attributes
-                this.start = 0;
-                this.end = number;
-            } else { // last n attributes
-                this.start = this.upperLimit + number > 0 ? this.upperLimit + number : 0;
-                this.end = this.upperLimit - 1;
-            }
-        }
-    }
-
-    /**
-     * Translates a single string selection into it's internal 0-based
-     * equivalent.
-     *
-     * @param single the string representing the selection (eg: 1 first last)
-     * @return the number corresponding to the selected value
-     */
-    protected /*@pure@*/ int rangeSingle(/*@non_null@*/String singleSelection) {
-
-        String single = singleSelection.trim();
-        if (single.toLowerCase().equals("first")) {
-            return 0;
-        }
-        if (single.toLowerCase().equals("last") || single.toLowerCase().equals("-1")) {
-            return -1;
-        }
-        int index = Integer.parseInt(single);
-        if (index >= 1) { //Non for negatives
-            index--;
-        }
-        return index;
-    }
-
-    boolean isInRange(int value) {
-        boolean ret = false;
-        if (value >= start && value <= end) {
-            ret = true;
-        }
-        return ret;
-    }
-
-    int getSelectionLength() {
-        return end - start + 1;
-    }
-
-    public void setUpper(int attributeNumber) {
-        this.upperLimit = attributeNumber;
-        this.setRange(this.rangeText);
-    }
-
-    //JD
-    public int getStart() {
-        return start;
-    }
-
-    //JD
-
-    public int getEnd() {
-        return end;
-    }
-
-}
diff --git a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
index 070665e55..7ac2b2825 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
@@ -7,7 +7,6 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
@@ -23,6 +22,11 @@
 public class LocalMultiTargetClassifier extends AbstractMultiLabelLearner
 		implements MultiLabelClassifier, MultiTargetRegressor {
 
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 5437749202546674734L;
+
 	public ClassOption classifierOption = new ClassOption(
 			"classifier",
 			'c',
@@ -50,15 +54,12 @@ private void makeHeaders() {
 			headers = new ArrayList<InstancesHeader>();
 			for (int target = 0; target < getModelContext().numOutputAttributes(); target++) {
 				List<Attribute> attributes = new ArrayList<Attribute>();
-				List<Integer> indexValues = new ArrayList<Integer>();
 				for (int i = 0; i < getModelContext().numInputAttributes(); i++) {
 					attributes.add(getModelContext().inputAttribute(i));
-					indexValues.add(i);
 				}
 				attributes.add(getModelContext().outputAttribute(target));
-				indexValues.add(getModelContext().numInputAttributes());
 				InstancesHeader STHeader = new InstancesHeader();
-				STHeader.setAttributes(attributes, indexValues);
+				STHeader.setAttributes(attributes);
 				STHeader.setClassIndex(getModelContext().numInputAttributes());
 				headers.add(STHeader);
 			}
diff --git a/moa/src/main/java/moa/streams/ArffFileStream.java b/moa/src/main/java/moa/streams/ArffFileStream.java
index 5d0d10ef9..81d639198 100644
--- a/moa/src/main/java/moa/streams/ArffFileStream.java
+++ b/moa/src/main/java/moa/streams/ArffFileStream.java
@@ -155,7 +155,7 @@ public void restart() {
             this.fileProgressMonitor = new InputStreamProgressMonitor(
                     fileStream);
             this.fileReader = new BufferedReader(new InputStreamReader(this.fileProgressMonitor));
-            this.instances = new InstancesHeader(this.fileReader, 1, this.outputIndexesOption.getValue(), this.inputIndexesOption.getValue());
+            this.instances = new InstancesHeader(this.fileReader, this.outputIndexesOption.getValue(), this.inputIndexesOption.getValue());
             this.numInstancesRead = 0;
             this.lastInstanceRead = null;
             this.hitEndOfFile = !readNextInstanceFromFile();
diff --git a/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java b/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java
index 80e2ae84f..9ade14c76 100644
--- a/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java
+++ b/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java
@@ -28,7 +28,6 @@
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.Reader; 
-import com.github.javacliparser.RangeOption;  // jesse
 import moa.core.InputStreamProgressMonitor;
 import moa.core.InstanceExample;
 import moa.core.ObjectRepository;
diff --git a/moa/src/main/java/moa/streams/clustering/FileStream.java b/moa/src/main/java/moa/streams/clustering/FileStream.java
index 7ef557add..bd8458fff 100644
--- a/moa/src/main/java/moa/streams/clustering/FileStream.java
+++ b/moa/src/main/java/moa/streams/clustering/FileStream.java
@@ -38,6 +38,8 @@
 import moa.core.InstanceExample;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
+import moa.core.utils.AttributeDefinitionUtil;
+
 import com.github.javacliparser.FileOption;
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.IntOption;
@@ -48,7 +50,6 @@
 import moa.tasks.TaskMonitor;
 
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public class FileStream extends ClusteringStream{
 
@@ -65,11 +66,6 @@ public String getPurposeString() {
 	public FileOption arffFileOption = new FileOption("arffFile", 'f',
 			"ARFF file to load.", defaultfile, "arff", false);
 
-//	public IntOption classIndexOption = new IntOption(
-//			"classIndex",
-//			'c',
-//			"Class index of data. 0 for none or -1 for last attribute in file.",
-//			-1, -1, Integer.MAX_VALUE);
 
     public StringOption outputIndicesOption = new StringOption(
     		"outputIndices",
@@ -81,7 +77,7 @@ public String getPurposeString() {
     		"outputIndices",
     		'i',
     		"Indices of input (class) attributes. Can be provided in a comma or semicolon separated list of single values or ranges. Leave blank for all non-output attributes.",
-    		"");
+    		AttributeDefinitionUtil.nonIgnoredDefinition);
 	
     public FlagOption normalizeOption = 
     		new FlagOption("normalize", 'n', 
@@ -169,7 +165,7 @@ public void restart() {
 			InputStream fileStream = new FileInputStream(arffFileOption.getFile());
 			fileProgressMonitor = new InputStreamProgressMonitor(fileStream);
 			fileReader = new BufferedReader(new InputStreamReader(fileProgressMonitor));
-            instances = new InstancesHeader(fileReader, 1, this.outputIndicesOption.getValue(), this.inputIndicesOption.getValue());
+            instances = new InstancesHeader(fileReader, this.outputIndicesOption.getValue(), this.inputIndicesOption.getValue());
 
 
 			//use hashset to delete duplicates and attributes numbers that aren't valid
@@ -287,7 +283,7 @@ protected ArrayList<Double[]> readMinMaxDiffValues(HashSet<Integer> ignoredAttri
 			InputStream fileStream = new FileInputStream(arffFileOption.getFile());
 			InputStreamProgressMonitor fileProgressMonitor = new InputStreamProgressMonitor(fileStream);
 			Reader fileReader = new BufferedReader(new InputStreamReader(fileProgressMonitor));
-            InstancesHeader instances = new InstancesHeader(fileReader, 1, this.outputIndicesOption.getValue(), this.inputIndicesOption.getValue());
+            InstancesHeader instances = new InstancesHeader(fileReader, this.outputIndicesOption.getValue(), this.inputIndicesOption.getValue());
 
 			valuesMinMaxDiff = new ArrayList<Double[]>();
 			for (int i = 0; i < instances.numAttributes()-ignoredAttributes.size(); i++) {
diff --git a/moa/src/main/java/moa/streams/filters/RBFFilter.java b/moa/src/main/java/moa/streams/filters/RBFFilter.java
index bf90b324c..df300eb65 100644
--- a/moa/src/main/java/moa/streams/filters/RBFFilter.java
+++ b/moa/src/main/java/moa/streams/filters/RBFFilter.java
@@ -5,15 +5,12 @@
 import java.util.Random;
 
 import moa.core.InstanceExample;
-import moa.streams.MultiTargetInstanceStream;
 
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceImpl;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.Range;
 
 public class RBFFilter extends AbstractStreamFilter {
 
@@ -53,14 +50,12 @@ public InstanceExample nextInstance() {
 
 		int d = x.numAttributes();
 		int h = numLatentOption.getValue();
-		int j_c = x.classIndex();
 
 		for(int k = 0; k < h; k++) {
 			double sum_k = 0.;
 			for(int j = 0; j < d; j++) {
 				sum_k += (x.value(j) - c[k]);
 			}
-			double v = sum_k / Math.pow(r[k],2);
 			z.setValue(k,Math.exp(-sum_k));
 		}
 		z.setValue(h,x.classValue());
@@ -100,7 +95,7 @@ private void initialize(Instance instance) {
 		indexValues.add(h);
 
 
-		ds.setAttributes(v,indexValues);
+		ds.setAttributes(v);
 		dataset=(new InstancesHeader(ds));
 		dataset.setClassIndex(h);
 		System.out.println(""+dataset);
diff --git a/moa/src/main/java/moa/streams/filters/ReLUFilter.java b/moa/src/main/java/moa/streams/filters/ReLUFilter.java
index 3f6eb7f55..4023e2194 100644
--- a/moa/src/main/java/moa/streams/filters/ReLUFilter.java
+++ b/moa/src/main/java/moa/streams/filters/ReLUFilter.java
@@ -4,16 +4,11 @@
 import java.util.List;
 import java.util.Random;
 
-import moa.core.InstanceExample;
-import moa.streams.MultiTargetInstanceStream;
-
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceImpl;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.Range;
 
 public class ReLUFilter extends AbstractStreamFilter {
 
@@ -111,7 +106,7 @@ private void initialize(Instance instance) {
 		indexValues.add(H);
 
 
-		ds.setAttributes(v,indexValues);
+		ds.setAttributes(v);
 		dataset=(new InstancesHeader(ds));
 		dataset.setClassIndex(H);
 
diff --git a/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java b/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java
index b5905e34a..5270011e2 100644
--- a/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java
+++ b/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java
@@ -3,17 +3,13 @@
 import java.util.ArrayList;
 import java.util.List;
 
-import moa.core.Example;
 import moa.core.InstanceExample;
-import moa.streams.MultiTargetInstanceStream;
 
 import com.github.javacliparser.StringOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceImpl;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.Range;
 
 public class SelectAttributesFilter extends AbstractMultiLabelStreamFilter implements MultiLabelStreamFilter{
 
@@ -52,7 +48,6 @@ private void initialize(Instance instance) {
 		int totAttributes=inputsSelected.numValues()+outputsSelected.numValues();
 		InstancesHeader ds= new InstancesHeader();
 		List<Attribute> v = new ArrayList<Attribute>(totAttributes);
-		List<Integer> indexValues = new ArrayList<Integer>(totAttributes);
 		int ct=0;
 		List<Integer> inputIndexes = new ArrayList<Integer>();
 		List<Integer> outputIndexes = new ArrayList<Integer>();
@@ -60,7 +55,6 @@ private void initialize(Instance instance) {
 		{
 			for (int j=inputsSelected.getStart(i); j<=inputsSelected.getEnd(i);j++){
 				v.add(instance.attribute(j-1));
-				indexValues.add(ct);
 				inputIndexes.add(ct);
 				ct++;
 			}
@@ -70,12 +64,11 @@ private void initialize(Instance instance) {
 		{
 			for (int j=outputsSelected.getStart(i); j<=outputsSelected.getEnd(i);j++){
 				v.add(instance.attribute(j-1));
-				indexValues.add(ct);
 				outputIndexes.add(ct);
 				ct++;
 			}
 		}		
-		ds.setAttributes(v,indexValues);
+		ds.setAttributes(v);
 		ds.setOutputIndexes(outputIndexes);
 		ds.setInputIndexes(inputIndexes);
 		dataset=(new InstancesHeader(ds));
diff --git a/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java b/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java
index 5c99a5e92..4987e2718 100644
--- a/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java
+++ b/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java
@@ -21,7 +21,6 @@
 
 import java.io.BufferedReader;
 import java.io.FileInputStream;
-import java.io.FileReader;
 import java.io.InputStreamReader;
 import java.io.Reader;
 
@@ -35,11 +34,8 @@
 import moa.test.TmpFile;
 import weka.core.MOAUtils;
 
-import com.yahoo.labs.samoa.instances.ArffLoader;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.Range;
 
 /**
  * Ancestor for all classifier test cases.

From bdffa94288880631866d7a98275a1266d3f3b60d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Tue, 10 Jan 2017 14:30:50 +0100
Subject: [PATCH 28/33] Instances rework, new iSOUPTree models and import
 cleanup

---
 moa/.settings/org.eclipse.jdt.core.prefs      |  13 +-
 .../github/javacliparser/JavaCLIParser.java   |   1 -
 .../gui/ClassOptionEditComponent.java         |   3 +-
 .../ClassOptionWithNamesEditComponent.java    |   3 +-
 .../gui/FileOptionEditComponent.java          |   1 +
 .../gui/ListOptionEditComponent.java          |   4 +-
 .../gui/OptionsConfigurationPanel.java        |   8 +-
 .../labs/samoa/instances/ArffLoader.java      |   1 +
 .../yahoo/labs/samoa/instances/Attribute.java |   7 +-
 .../yahoo/labs/samoa/instances/Instance.java  |  34 +-
 .../labs/samoa/instances/InstanceImpl.java    |  22 +
 .../samoa/instances/InstanceInformation.java  |   1 -
 .../labs/samoa/instances/InstancesHeader.java |  13 +
 .../samoa/instances/MultiLabelPrediction.java |   3 +-
 .../SamoaToWekaInstanceConverter.java         |   2 +-
 moa/src/main/java/moa/AbstractMOAObject.java  |   6 +-
 moa/src/main/java/moa/DoTask.java             |  10 +-
 moa/src/main/java/moa/MOAObject.java          |   2 +-
 .../moa/classifiers/AbstractClassifier.java   |  34 +-
 .../AbstractMultiLabelLearner.java            |   5 +-
 .../main/java/moa/classifiers/Classifier.java |   7 +-
 .../moa/classifiers/MultiLabelLearner.java    |   2 +-
 .../classifiers/active/ActiveClassifier.java  |  10 +-
 .../moa/classifiers/bayes/NaiveBayes.java     |   3 +-
 .../bayes/NaiveBayesMultinomial.java          |   6 +-
 .../core/AttributeSplitSuggestion.java        |   2 +-
 ...naryTreeNumericAttributeClassObserver.java |   1 +
 ...mericAttributeClassObserverRegression.java |   1 +
 .../FIMTDDNumericAttributeClassObserver.java  |  61 +-
 ...GaussianNumericAttributeClassObserver.java |  12 +-
 ...ldKhannaNumericAttributeClassObserver.java |   6 +-
 .../NominalAttributeClassObserver.java        |   7 +-
 .../VFMLNumericAttributeClassObserver.java    |   8 +-
 .../InstanceConditionalTest.java              |   4 +-
 .../NominalAttributeBinaryTest.java           |   1 -
 .../NominalAttributeMultiwayTest.java         |   1 -
 .../NumericAttributeBinaryTest.java           |   1 -
 .../driftdetection/ADWINChangeDetector.java   |   1 +
 .../core/driftdetection/CusumDM.java          |   1 +
 .../classifiers/core/driftdetection/DDM.java  |   1 +
 .../core/driftdetection/EWMAChartDM.java      |   1 +
 .../EnsembleDriftDetectionMethods.java        |   1 +
 .../GeometricMovingAverageDM.java             |   1 +
 .../core/driftdetection/HDDM_A_Test.java      |   1 +
 .../core/driftdetection/HDDM_W_Test.java      |   1 +
 .../core/driftdetection/PageHinkleyDM.java    |   1 +
 .../driftdetection/SEEDChangeDetector.java    |   1 +
 .../SeqDrift1ChangeDetector.java              |   8 +-
 .../SeqDrift2ChangeDetector.java              |   8 +-
 .../splitcriteria/InfoGainSplitCriterion.java |   1 +
 .../drift/DriftDetectionMethodClassifier.java |   6 +-
 .../classifiers/functions/MajorityClass.java  |   3 +-
 .../moa/classifiers/functions/NoChange.java   |   3 +-
 .../moa/classifiers/functions/Perceptron.java |   5 +-
 .../java/moa/classifiers/functions/SGD.java   |   9 +-
 .../classifiers/functions/SGDMultiClass.java  |   7 +-
 .../moa/classifiers/functions/SPegasos.java   |   7 +-
 .../main/java/moa/classifiers/lazy/kNN.java   |  10 +-
 .../java/moa/classifiers/lazy/kNNwithPAW.java |   1 -
 .../classifiers/lazy/kNNwithPAWandADWIN.java  |   4 +-
 .../lazy/neighboursearch/KDTree.java          |   6 +-
 .../NearestNeighbourSearch.java               |   1 +
 .../neighboursearch/NormalizableDistance.java |   1 -
 .../kdtrees/KDTreeNodeSplitter.java           |   3 +-
 .../main/java/moa/classifiers/meta/ADACC.java |   7 +-
 .../meta/AccuracyUpdatedEnsemble.java         |   7 +-
 .../meta/AccuracyWeightedEnsemble.java        |  16 +-
 .../main/java/moa/classifiers/meta/DACC.java  |  11 +-
 .../moa/classifiers/meta/LeveragingBag.java   |  13 +-
 .../classifiers/meta/LimAttClassifier.java    |  18 +-
 .../java/moa/classifiers/meta/OCBoost.java    |  10 +-
 .../meta/OnlineAccuracyUpdatedEnsemble.java   |   1 +
 .../classifiers/meta/OnlineSmoothBoost.java   |   1 +
 .../java/moa/classifiers/meta/OzaBag.java     |  14 +-
 .../java/moa/classifiers/meta/OzaBagASHT.java |  35 +-
 .../moa/classifiers/meta/OzaBagAdwin.java     |  10 +-
 .../java/moa/classifiers/meta/OzaBoost.java   |   8 +-
 .../moa/classifiers/meta/OzaBoostAdwin.java   |  11 +-
 .../moa/classifiers/meta/PairedLearners.java  |   9 +-
 .../moa/classifiers/meta/RandomRules.java     |   3 +-
 .../meta/TemporallyAugmentedClassifier.java   |  14 +-
 .../moa/classifiers/meta/WEKAClassifier.java  |   8 +-
 .../meta/WeightedMajorityAlgorithm.java       |  17 +-
 .../LocalMultiTargetClassifier.java           |  46 +-
 .../multilabel/MEKAClassifier.java            |  22 +-
 .../multilabel/MajorityLabelset.java          |   9 +-
 .../multilabel/MultilabelHoeffdingTree.java   |  17 +-
 .../MultiLabelBSTree.java                     |  72 +-
 .../MultiLabelBSTreePCT.java                  | 270 +++++++
 .../MultiLabelNominalAttributeObserver.java   |   4 +-
 .../splitcriteria/ICVarianceReduction.java    |   8 +-
 .../PCTWeightedICVarianceReduction.java       |  76 ++
 .../classifiers/multilabel/meta/MTOzaBag.java |  16 +-
 .../multilabel/meta/OzaBagAdwinML.java        | 109 ++-
 .../classifiers/multilabel/meta/OzaBagML.java |  13 +-
 .../multilabel/trees/ISOUPOptionTree.java     |  68 +-
 .../multilabel/trees/ISOUPTree.java           | 688 +++++++++++-------
 .../multilabel/trees/ISOUPTreeRF.java         |  46 ++
 .../BasicMultiTargetRegressor.java            |  15 +-
 .../functions/MultiTargetNoChange.java        |   6 +-
 .../rules/AMRulesRegressorOld.java            |   3 +-
 .../classifiers/rules/AbstractAMRules.java    |   8 +-
 .../moa/classifiers/rules/Predicates.java     |   3 +-
 .../classifiers/rules/RuleClassification.java |   6 +-
 .../moa/classifiers/rules/RuleClassifier.java |  13 +-
 .../rules/RuleClassifierNBayes.java           |   4 +-
 .../rules/core/NominalRulePredicate.java      |   1 -
 .../rules/core/NumericRulePredicate.java      |   1 -
 .../java/moa/classifiers/rules/core/Rule.java |   8 +-
 .../rules/core/RuleActiveLearningNode.java    |   2 +-
 .../rules/core/RuleActiveRegressionNode.java  |  12 +-
 .../moa/classifiers/rules/core/Utils.java     |   5 +
 .../AbstractAnomalyDetector.java              |   3 +-
 .../AnomalinessRatioScore.java                |  10 +-
 .../anomalydetection/NoAnomalyDetection.java  |   3 +-
 .../core/anomalydetection/OddsRatioScore.java |  10 +-
 .../CantellisInequality.java                  |   3 -
 .../ChebyshevInequality.java                  |   3 -
 .../probabilityfunctions/GaussInequality.java |   3 -
 ...TDDNumericAttributeClassLimitObserver.java |   4 +-
 .../NominalAttributeBinaryRulePredicate.java  |   1 -
 .../NumericAttributeBinaryRulePredicate.java  |   1 -
 .../SDRSplitCriterionAMRules.java             |   1 -
 .../SDRSplitCriterionAMRulesNode.java         |   2 -
 .../voting/AbstractErrorWeightedVote.java     |   1 +
 .../errormeasurers/MeanAbsoluteDeviation.java |   1 -
 .../errormeasurers/RootMeanSquaredError.java  |   2 -
 .../rules/functions/AMRulesLearner.java       |   4 +-
 .../rules/functions/Perceptron.java           |   2 -
 .../rules/functions/TargetMean.java           |   2 +-
 .../rules/meta/RandomAMRulesOld.java          |   7 +-
 .../multilabel/AMRulesMultiLabelLearner.java  |  13 +-
 .../AMRulesMultiTargetRegressor.java          |   2 -
 .../multilabel/core/LearningLiteral.java      |   9 +-
 .../core/LearningLiteralRegression.java       |  15 +-
 .../rules/multilabel/core/MultiLabelRule.java |   8 +-
 .../AbstractErrorWeightedVoteMultiLabel.java  |   1 -
 .../voting/ErrorWeightedVoteMultiLabel.java   |   2 -
 .../AbstractMultiLabelErrorMeasurer.java      |   8 +-
 .../AbstractMultiTargetErrorMeasurer.java     |   2 +-
 .../MultiLabelErrorMeasurer.java              |   2 +-
 .../RootMeanSquaredErrorMT.java               |   3 -
 .../AdaptiveMultiTargetRegressor.java         |   7 +-
 .../MultiLabelTargetMeanRegressor.java        |   1 -
 .../meta/MultiLabelRandomAMRules.java         |  18 +-
 .../trees/AdaHoeffdingOptionTree.java         |   3 +-
 .../moa/classifiers/trees/DecisionStump.java  |   3 +-
 .../java/moa/classifiers/trees/FIMTDD.java    |  46 +-
 .../trees/HoeffdingAdaptiveTree.java          |   4 +-
 .../trees/HoeffdingOptionTree.java            |  12 +-
 .../moa/classifiers/trees/HoeffdingTree.java  |  14 +-
 .../trees/HoeffdingTreeClassifLeaves.java     |   4 +-
 .../trees/LimAttHoeffdingTree.java            |   3 +-
 .../main/java/moa/classifiers/trees/ORTO.java |   7 +-
 .../trees/RandomHoeffdingTree.java            |   3 +-
 moa/src/main/java/moa/cluster/CFCluster.java  |   1 +
 moa/src/main/java/moa/cluster/Cluster.java    |   4 +-
 moa/src/main/java/moa/cluster/Clustering.java |   6 +-
 .../main/java/moa/cluster/SphereCluster.java  |   1 +
 .../moa/clusterers/AbstractClusterer.java     |  10 +-
 .../java/moa/clusterers/ClusterGenerator.java |   4 +-
 .../main/java/moa/clusterers/Clusterer.java   |   5 +-
 moa/src/main/java/moa/clusterers/CobWeb.java  |  10 +-
 moa/src/main/java/moa/clusterers/KMeans.java  |   1 +
 .../clusterers/WekaClusteringAlgorithm.java   |  13 +-
 .../moa/clusterers/clustream/Clustream.java   |   8 +-
 .../clusterers/clustream/ClustreamKernel.java |   5 +-
 .../moa/clusterers/clustream/WithKmeans.java  |   7 +-
 .../moa/clusterers/clustree/ClusKernel.java   |   5 +-
 .../moa/clusterers/clustree/ClusTree.java     |  11 +-
 .../clusterers/denstream/MicroCluster.java    |   3 +-
 .../moa/clusterers/denstream/WithDBSCAN.java  |   9 +-
 .../clusterers/macro/NonConvexCluster.java    |   3 +-
 .../outliers/AbstractC/AbstractC.java         |   6 +-
 .../outliers/AbstractC/AbstractCBase.java     |   3 +-
 .../outliers/AbstractC/ISBIndex.java          |   1 +
 .../outliers/AbstractC/MyMTree.java           |   1 +
 .../clusterers/outliers/AbstractC/Test.java   |   3 +-
 .../outliers/Angiulli/ApproxSTORM.java        |   6 +-
 .../outliers/Angiulli/ExactSTORM.java         |   6 +-
 .../outliers/Angiulli/ISBIndex.java           |   1 +
 .../clusterers/outliers/Angiulli/MyMTree.java |   1 +
 .../outliers/Angiulli/STORMBase.java          |   6 +-
 .../clusterers/outliers/Angiulli/Test.java    |   3 +-
 .../clusterers/outliers/AnyOut/AnyOut.java    |   4 +-
 .../outliers/AnyOut/AnyOutCore.java           |   6 +-
 .../clusterers/outliers/MCOD/ISBIndex.java    |   1 +
 .../moa/clusterers/outliers/MCOD/MCOD.java    |   8 +-
 .../clusterers/outliers/MCOD/MCODBase.java    |   3 +-
 .../outliers/MCOD/MTreeMicroClusters.java     |   1 +
 .../outliers/MCOD/MTreeStreamObjects.java     |   1 +
 .../outliers/MCOD/MicroCluster.java           |   1 +
 .../moa/clusterers/outliers/MCOD/Test.java    |   3 +-
 .../outliers/MyBaseOutlierDetector.java       |   6 +-
 .../outliers/SimpleCOD/ISBIndex.java          |   1 +
 .../outliers/SimpleCOD/MyMTree.java           |   1 +
 .../outliers/SimpleCOD/SimpleCOD.java         |   6 +-
 .../outliers/SimpleCOD/SimpleCODBase.java     |   1 +
 .../clusterers/outliers/SimpleCOD/Test.java   |   3 +-
 .../moa/clusterers/outliers/TestSpeed.java    |   3 +-
 .../outliers/utils/mtree/MTree.java           |   1 +
 .../utils/mtree/PromotionFunctions.java       |   1 +
 .../java/moa/clusterers/streamkm/Point.java   |   4 +-
 .../moa/clusterers/streamkm/StreamKM.java     |   3 +-
 .../java/moa/core/AutoClassDiscovery.java     |   2 +-
 .../main/java/moa/core/AutoExpandVector.java  |   2 +-
 .../moa/core/MultilabelInstancesHeader.java   |   1 -
 moa/src/main/java/moa/core/Utils.java         |   8 -
 .../main/java/moa/core/utils/Converter.java   |   4 +-
 .../main/java/moa/evaluation/Accuracy.java    |   1 +
 ...winClassificationPerformanceEvaluator.java |   1 -
 ...sicClassificationPerformanceEvaluator.java |  12 +-
 ...BasicConceptDriftPerformanceEvaluator.java |   1 -
 .../BasicMultiLabelPerformanceEvaluator.java  |   8 +-
 .../BasicMultiTargetPerformanceEvaluator.java |  11 +-
 .../BasicRegressionPerformanceEvaluator.java  |   7 +-
 .../java/moa/evaluation/CMM_GTAnalysis.java   |   4 +-
 .../evaluation/ChangeDetectionMeasures.java   |   1 +
 .../ClassificationPerformanceEvaluator.java   |   3 +-
 ...WMAClassificationPerformanceEvaluator.java |  13 -
 .../moa/evaluation/EntropyCollection.java     |   1 +
 moa/src/main/java/moa/evaluation/F1.java      |   1 +
 ...torClassificationPerformanceEvaluator.java |  12 -
 moa/src/main/java/moa/evaluation/General.java |   4 +-
 .../moa/evaluation/LearningEvaluation.java    |   4 +-
 .../LearningPerformanceEvaluator.java         |   1 -
 .../moa/evaluation/MeasureCollection.java     |   1 +
 .../java/moa/evaluation/MembershipMatrix.java |   1 +
 .../MultiTargetPerformanceEvaluator.java      |   3 +-
 ...tWindowRegressionPerformanceEvaluator.java |  13 +-
 .../moa/evaluation/OutlierPerformance.java    |   2 +-
 .../RegressionPerformanceEvaluator.java       |   3 +-
 moa/src/main/java/moa/evaluation/SSQ.java     |   1 +
 .../main/java/moa/evaluation/Separation.java  |   7 +-
 .../moa/evaluation/SilhouetteCoefficient.java |   2 +-
 .../moa/evaluation/StatisticalCollection.java |   1 +
 ...dowClassificationPerformanceEvaluator.java |  12 -
 .../WindowRegressionPerformanceEvaluator.java |  11 +-
 moa/src/main/java/moa/gui/BatchCmd.java       |   5 +-
 .../moa/gui/ClassOptionSelectionPanel.java    |   3 +-
 .../ClassOptionWithNamesSelectionPanel.java   |   3 +-
 .../java/moa/gui/ConceptDriftTabPanel.java    |   1 +
 moa/src/main/java/moa/gui/GUI.java            |   6 +-
 moa/src/main/java/moa/gui/GUIDefaults.java    |   6 +-
 .../java/moa/gui/MultiTargetTabPanel.java     |   1 +
 .../moa/gui/MultiTargetTaskManagerPanel.java  |   2 +
 .../main/java/moa/gui/RegressionTabPanel.java |   1 +
 .../moa/gui/RegressionTaskManagerPanel.java   |   6 +-
 .../main/java/moa/gui/TaskManagerPanel.java   |   6 +-
 .../java/moa/gui/TaskTextViewerPanel.java     |   3 +-
 .../moa/gui/WEKAClassOptionEditComponent.java |  12 +-
 .../gui/clustertab/ClusteringAlgoPanel.java   |  10 +-
 .../gui/clustertab/ClusteringEvalPanel.java   |   3 +-
 .../gui/clustertab/ClusteringSetupTab.java    |   2 +
 .../clustertab/ClusteringVisualEvalPanel.java |   4 +-
 .../gui/clustertab/ClusteringVisualTab.java   |   2 +
 .../gui/conceptdrift/CDTaskManagerPanel.java  |  11 +-
 .../moa/gui/outliertab/OutlierAlgoPanel.java  |  15 +-
 .../moa/gui/outliertab/OutlierEvalPanel.java  |   4 +-
 .../moa/gui/outliertab/OutlierSetupTab.java   |   2 +
 .../outliertab/OutlierVisualEvalPanel.java    |   4 +-
 .../moa/gui/outliertab/OutlierVisualTab.java  |   2 +
 .../moa/gui/visualization/ClusterPanel.java   |   2 +
 .../moa/gui/visualization/GraphCanvas.java    |   2 +
 .../moa/gui/visualization/GraphCurve.java     |   1 +
 .../moa/gui/visualization/OutlierPanel.java   |  21 +-
 .../visualization/RunOutlierVisualizer.java   |  10 +-
 .../moa/gui/visualization/RunVisualizer.java  |  12 +-
 .../gui/visualization/StreamOutlierPanel.java |  16 +-
 .../moa/gui/visualization/WekaExplorer.java   |   7 +-
 .../moa/learners/ChangeDetectorLearner.java   |   3 +-
 moa/src/main/java/moa/learners/Learner.java   |   6 +-
 .../java/moa/options/AbstractClassOption.java |   2 +
 .../moa/options/AbstractOptionHandler.java    |   1 +
 .../main/java/moa/options/ClassOption.java    |   3 +-
 .../moa/options/ClassOptionWithNames.java     |   6 +-
 .../main/java/moa/options/OptionHandler.java  |   1 +
 .../main/java/moa/options/OptionsHandler.java |   2 +
 .../java/moa/options/WEKAClassOption.java     |   6 +-
 .../dataset/impl/FlixsterDataset.java         |   5 +-
 .../dataset/impl/JesterDataset.java           |   9 +-
 .../dataset/impl/MovielensDataset.java        |   6 +-
 .../predictor/BRISMFPredictor.java            |   6 +-
 .../predictor/BaselinePredictor.java          |   1 +
 .../predictor/RatingPredictor.java            |   1 +
 .../rc/data/AbstractRecommenderData.java      |   1 +
 .../recommender/rc/data/RecommenderData.java  |   1 +
 .../rc/data/impl/MemRecommenderData.java      |   1 +
 .../rc/predictor/RatingPredictor.java         |   1 +
 .../rc/predictor/impl/BRISMFPredictor.java    |   1 +
 .../rc/predictor/impl/BaselinePredictor.java  |   1 +
 .../main/java/moa/streams/ArffFileStream.java |  12 +-
 .../moa/streams/CachedInstancesStream.java    |   5 +-
 .../moa/streams/ConceptDriftRealStream.java   |  14 +-
 .../java/moa/streams/ConceptDriftStream.java  |  10 +-
 .../main/java/moa/streams/ExampleStream.java  |   5 +-
 .../main/java/moa/streams/InstanceStream.java |   3 +-
 .../java/moa/streams/MultiFilteredStream.java |   9 +-
 .../moa/streams/MultiLabelFilteredStream.java |   1 -
 .../streams/MultiTargetArffFileStream.java    |  15 -
 .../streams/MultiTargetInstanceStream.java    |   3 -
 .../streams/RecurrentConceptDriftStream.java  |   7 +-
 .../streams/clustering/ClusteringStream.java  |   3 +-
 .../moa/streams/clustering/FileStream.java    |  14 +-
 .../clustering/RandomRBFGeneratorEvents.java  |  17 +-
 .../streams/clustering/SimpleCSVStream.java   |   1 -
 .../AbstractMultiLabelStreamFilter.java       |   1 -
 .../streams/filters/AbstractStreamFilter.java |   2 +-
 .../moa/streams/filters/AddNoiseFilter.java   |   9 +-
 .../java/moa/streams/filters/RBFFilter.java   |   4 +-
 .../RemoveDiscreteAttributeFilter.java        |   7 +-
 .../filters/ReplacingMissingValuesFilter.java |  11 +-
 .../filters/SelectAttributesFilter.java       |   4 +-
 .../moa/streams/filters/StreamFilter.java     |   1 +
 .../streams/generators/AgrawalGenerator.java  |  15 +-
 .../generators/HyperplaneGenerator.java       |  11 +-
 .../moa/streams/generators/LEDGenerator.java  |  11 +-
 .../streams/generators/LEDGeneratorDrift.java |   4 +-
 .../generators/RandomRBFGenerator.java        |  11 +-
 .../generators/RandomRBFGeneratorDrift.java   |   6 +-
 .../generators/RandomTreeGenerator.java       |  15 +-
 .../moa/streams/generators/SEAGenerator.java  |  11 +-
 .../streams/generators/STAGGERGenerator.java  |  11 +-
 .../streams/generators/WaveformGenerator.java |  11 +-
 .../generators/WaveformGeneratorDrift.java    |   4 +-
 .../cd/AbstractConceptDriftGenerator.java     |   7 +-
 .../generators/cd/ConceptDriftGenerator.java  |   1 +
 .../multilabel/MetaMultilabelGenerator.java   |  26 +-
 .../multilabel/MultilabelArffFileStream.java  |   8 +-
 .../java/moa/tasks/CacheShuffledStream.java   |   3 +-
 .../java/moa/tasks/ConceptDriftMainTask.java  |   1 +
 .../java/moa/tasks/EvaluateClustering.java    |   5 +-
 .../java/moa/tasks/EvaluateConceptDrift.java  |   9 +-
 .../moa/tasks/EvaluateInterleavedChunks.java  |  12 +-
 .../EvaluateInterleavedTestThenTrain.java     |   7 +-
 .../main/java/moa/tasks/EvaluateModel.java    |   4 +-
 .../moa/tasks/EvaluateModelMultiTarget.java   |   8 +-
 .../moa/tasks/EvaluateModelRegression.java    |   5 +-
 .../moa/tasks/EvaluateOnlineRecommender.java  |   3 +-
 .../tasks/EvaluatePeriodicHeldOutTest.java    |   9 +-
 .../java/moa/tasks/EvaluatePrequential.java   |  16 +-
 .../java/moa/tasks/EvaluatePrequentialCV.java |  28 +-
 .../tasks/EvaluatePrequentialMultiTarget.java | 209 ++++++
 .../tasks/EvaluatePrequentialRegression.java  |  22 +-
 moa/src/main/java/moa/tasks/LearnModel.java   |   3 +-
 .../java/moa/tasks/LearnModelMultiTarget.java |   1 +
 .../java/moa/tasks/LearnModelRegression.java  |   5 +-
 moa/src/main/java/moa/tasks/MainTask.java     |   3 +-
 .../java/moa/tasks/MeasureStreamSpeed.java    |   4 +-
 .../java/moa/tasks/MultiTargetMainTask.java   |   2 +-
 moa/src/main/java/moa/tasks/Plot.java         |   3 +-
 .../java/moa/tasks/RegressionMainTask.java    |   2 +-
 .../main/java/moa/tasks/RunStreamTasks.java   |   1 +
 moa/src/main/java/moa/tasks/RunTasks.java     |   5 +-
 .../java/moa/tasks/WriteStreamToARFFFile.java |   7 +-
 .../main/java/weka/classifiers/meta/MOA.java  |  18 +-
 .../classifiers/classification/MOA.java       |  19 +-
 .../java/weka/gui/MOAClassOptionEditor.java   |   3 +-
 .../instances/MultiTargetArffLoaderTest.java  |  12 +-
 .../AbstractClassifierTestCase.java           |  12 +-
 .../AbstractMultipleClassifierTestCase.java   |   1 -
 .../AbstractMultipleRegressorTestCase.java    |   1 -
 .../active/ActiveClassifierTest.java          |   1 -
 .../drift/SingleClassifierDriftTest.java      |   1 -
 .../functions/MajorityClassTest.java          |   1 -
 .../classifiers/functions/NoChangeTest.java   |   1 -
 .../classifiers/functions/PerceptronTest.java |   1 -
 .../moa/classifiers/functions/SGDTest.java    |   1 -
 .../classifiers/functions/SPegasosTest.java   |   1 -
 .../meta/AccuracyUpdatedEnsembleTest.java     |   1 -
 .../meta/AccuracyWeightedEnsembleTest.java    |   1 -
 .../classifiers/meta/LeveragingBagTest.java   |   1 -
 .../meta/LimAttClassifierTest.java            |   1 -
 .../moa/classifiers/meta/OCBoostTest.java     |   1 -
 .../OnlineAccuracyUpdatedEnsembleTest.java    |   1 -
 .../moa/classifiers/meta/OzaBagASHTTest.java  |   1 -
 .../moa/classifiers/meta/OzaBagAdwinTest.java |   1 -
 .../java/moa/classifiers/meta/OzaBagTest.java |   1 -
 .../classifiers/meta/OzaBoostAdwinTest.java   |   1 -
 .../moa/classifiers/meta/OzaBoostTest.java    |   1 -
 .../TemporallyAugmentedClassifierTest.java    |   1 -
 .../classifiers/meta/WEKAClassifierTest.java  |   1 -
 .../meta/WeightedMajorityAlgorithmTest.java   |   1 -
 .../rules/AMRulesRegressorTest.java           |   1 -
 .../rules/RuleClassifierNBayesTest.java       |   1 -
 .../classifiers/rules/RuleClassifierTest.java |   1 -
 ...nverseErrorWeightedVoteMultiLabeLTest.java |   3 +-
 .../UniformWeightedVoteMultiLabelTest.java    |   4 +-
 .../trees/ASHoeffdingTreeTest.java            |   1 -
 .../trees/AdaHoeffdingOptionTreeTest.java     |   1 -
 .../classifiers/trees/DecisionStumpTest.java  |   1 -
 .../moa/classifiers/trees/FIMTDDTest.java     |   4 +-
 .../trees/HoeffdingAdaptiveTreeTest.java      |   1 -
 .../trees/HoeffdingOptionTreeTest.java        |   1 -
 .../trees/LimAttHoeffdingTreeTest.java        |   1 -
 .../java/moa/classifiers/trees/ORTOTest.java  |   1 -
 .../trees/RandomHoeffdingTreeTest.java        |   1 -
 .../moa/integration/SimpleClusterTest.java    |  12 +-
 .../filters/SelectAttributesFilterTest.java   |   5 +-
 .../.settings/org.eclipse.jdt.core.prefs      |   9 +-
 400 files changed, 2361 insertions(+), 1486 deletions(-)
 create mode 100644 moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelBSTreePCT.java
 create mode 100644 moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/PCTWeightedICVarianceReduction.java
 create mode 100644 moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTreeRF.java

diff --git a/moa/.settings/org.eclipse.jdt.core.prefs b/moa/.settings/org.eclipse.jdt.core.prefs
index 60105c1b9..672496e10 100644
--- a/moa/.settings/org.eclipse.jdt.core.prefs
+++ b/moa/.settings/org.eclipse.jdt.core.prefs
@@ -1,5 +1,12 @@
 eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
-org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
 org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
-org.eclipse.jdt.core.compiler.source=1.6
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/moa/src/main/java/com/github/javacliparser/JavaCLIParser.java b/moa/src/main/java/com/github/javacliparser/JavaCLIParser.java
index 23522e085..68191078c 100644
--- a/moa/src/main/java/com/github/javacliparser/JavaCLIParser.java
+++ b/moa/src/main/java/com/github/javacliparser/JavaCLIParser.java
@@ -73,7 +73,6 @@ public Option[] discoverOptionsViaReflection() {
         Field[] fields = c.getFields();
         List<Option> optList = new LinkedList<Option>();
         for (Field field : fields) {
-            String fName = field.getName();
             Class<?> fType = field.getType();
             if (fType.getName().endsWith("Option")) {
                 if (Option.class.isAssignableFrom(fType)) {
diff --git a/moa/src/main/java/com/github/javacliparser/gui/ClassOptionEditComponent.java b/moa/src/main/java/com/github/javacliparser/gui/ClassOptionEditComponent.java
index 7eb583603..5ba9ec261 100644
--- a/moa/src/main/java/com/github/javacliparser/gui/ClassOptionEditComponent.java
+++ b/moa/src/main/java/com/github/javacliparser/gui/ClassOptionEditComponent.java
@@ -32,9 +32,10 @@
 import javax.swing.event.DocumentEvent;
 import javax.swing.event.DocumentListener;
 
-import moa.options.ClassOption;
 import com.github.javacliparser.Option;
+
 import moa.gui.ClassOptionSelectionPanel;
+import moa.options.ClassOption;
 
 /**
  * An OptionEditComponent that lets the user edit a class option.
diff --git a/moa/src/main/java/com/github/javacliparser/gui/ClassOptionWithNamesEditComponent.java b/moa/src/main/java/com/github/javacliparser/gui/ClassOptionWithNamesEditComponent.java
index 7df51c402..f311f1d54 100644
--- a/moa/src/main/java/com/github/javacliparser/gui/ClassOptionWithNamesEditComponent.java
+++ b/moa/src/main/java/com/github/javacliparser/gui/ClassOptionWithNamesEditComponent.java
@@ -23,9 +23,10 @@
 import javax.swing.event.DocumentEvent;
 import javax.swing.event.DocumentListener;
 
-import moa.options.ClassOptionWithNames;
 import com.github.javacliparser.Option;
+
 import moa.gui.ClassOptionWithNamesSelectionPanel;
+import moa.options.ClassOptionWithNames;
 
 public class ClassOptionWithNamesEditComponent extends JPanel implements OptionEditComponent {
 
diff --git a/moa/src/main/java/com/github/javacliparser/gui/FileOptionEditComponent.java b/moa/src/main/java/com/github/javacliparser/gui/FileOptionEditComponent.java
index db0d3803b..5e3f6871a 100644
--- a/moa/src/main/java/com/github/javacliparser/gui/FileOptionEditComponent.java
+++ b/moa/src/main/java/com/github/javacliparser/gui/FileOptionEditComponent.java
@@ -31,6 +31,7 @@
 
 import com.github.javacliparser.FileOption;
 import com.github.javacliparser.Option;
+
 import moa.gui.FileExtensionFilter;
 
 /**
diff --git a/moa/src/main/java/com/github/javacliparser/gui/ListOptionEditComponent.java b/moa/src/main/java/com/github/javacliparser/gui/ListOptionEditComponent.java
index 0b295155c..53721bf3a 100644
--- a/moa/src/main/java/com/github/javacliparser/gui/ListOptionEditComponent.java
+++ b/moa/src/main/java/com/github/javacliparser/gui/ListOptionEditComponent.java
@@ -19,9 +19,9 @@
  */
 package com.github.javacliparser.gui;
 
-import com.github.javacliparser.Option;
+import javax.swing.JTextField;
 
-import javax.swing.*;
+import com.github.javacliparser.Option;
 
 /**
  * An OptionEditComponent that lets the user edit a list option.
diff --git a/moa/src/main/java/com/github/javacliparser/gui/OptionsConfigurationPanel.java b/moa/src/main/java/com/github/javacliparser/gui/OptionsConfigurationPanel.java
index c30b765f6..b099ed8c0 100644
--- a/moa/src/main/java/com/github/javacliparser/gui/OptionsConfigurationPanel.java
+++ b/moa/src/main/java/com/github/javacliparser/gui/OptionsConfigurationPanel.java
@@ -30,11 +30,8 @@
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.logging.Level;
-import java.util.logging.Logger;
 
 import javax.swing.BorderFactory;
 import javax.swing.JButton;
@@ -48,11 +45,12 @@
 import javax.swing.ScrollPaneConstants;
 import javax.swing.UIManager;
 
-import moa.classifiers.trees.HoeffdingTree;
 import com.github.javacliparser.Option;
-import moa.options.OptionHandler;
 import com.github.javacliparser.Options;
+
+import moa.classifiers.trees.HoeffdingTree;
 import moa.gui.GUIUtils;
+import moa.options.OptionHandler;
 
 /**
  * This panel displays an options configuration.
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
index fa92fc81e..bec02f2e5 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
@@ -211,6 +211,7 @@ private Instance readInstanceSparse() {
         ArrayList<Double> attributeValues = new ArrayList<Double>();
         List<Integer> indexValues = new ArrayList<Integer>();
         try {
+        	streamTokenizer.nextToken(); // Remove the '{' char
             //For each line
             while (streamTokenizer.ttype != StreamTokenizer.TT_EOL
                     && streamTokenizer.ttype != StreamTokenizer.TT_EOF) {
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java
index b4bd6dee2..245b73616 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java
@@ -17,7 +17,12 @@
 
 import java.io.Serializable;
 import java.text.SimpleDateFormat;
-import java.util.*;
+import java.util.Collections;
+import java.util.Date;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
 import moa.core.Utils;
 /**
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
index d855144a7..a52a2fd20 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
@@ -120,21 +120,6 @@ public interface Instance extends Serializable {
      */
     public double value(Attribute attribute);
 
-    /**
-     * Sets an attribute as missing
-     *
-     * @param instAttIndex, the attribute's index     
-     */
-    public void setMissing(int instAttIndex);        
-    
-    
-    /**
-     * Sets an attribute as missing
-     *
-     * @param attribute, the Attribute
-     */
-    public void setMissing(Attribute attribute);
-    
     /**
      * Sets the value of an attribute.
      *
@@ -143,30 +128,29 @@ public interface Instance extends Serializable {
      */
     public void setValue(int instAttIndex, double value);
 
-    
     /**
-     * Sets the value of an attribute.
+     * Checks if an attribute is missing.
      *
-     * @param attribute, the Attribute
-     * @param value the value
+     * @param instAttIndex the inst att index
+     * @return true, if is missing
      */
-    public void setValue(Attribute attribute, double value);
-    
+    public boolean isMissing(int instAttIndex);
+
     /**
      * Checks if an attribute is missing.
      *
-     * @param instAttIndex the inst att index
+     * @param index the instance input attribute index
      * @return true, if is missing
      */
-    public boolean isMissing(int instAttIndex);
+    public boolean isInputMissing(int index);
 
     /**
      * Checks if an attribute is missing.
      *
-     * @param attribute, the Attribute
+     * @param index the instance output attribute index
      * @return true, if is missing
      */
-    public boolean isMissing(Attribute attribute);
+    public boolean isOutputMissing(int index);
     
     /**
      * Gets the index of the attribute given the index of the array in a sparse
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
index 434e9492b..ad8f4b7f8 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
@@ -184,6 +184,28 @@ public boolean isMissing(int instAttIndex) {
         return this.instanceData.isMissing(instAttIndex);
     }
 
+    /**
+     * Checks if is missing.
+     *
+     * @param instAttIndex the instance input attribute index
+     * @return true, if is missing
+     */
+    @Override
+    public boolean isInputMissing(int index) {
+        return this.instanceData.isMissing(this.instanceHeader.getInputInstanceIndex(index));
+    }
+
+    /**
+     * Checks if is missing.
+     *
+     * @param instAttIndex the instance output attribute index
+     * @return true, if is missing
+     */
+    @Override
+    public boolean isOutputMissing(int index) {
+        return this.instanceData.isMissing(this.instanceHeader.getOutputInstanceIndex(index));
+    }
+    
     /**
      * Num values.
      *
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
index ebb0d8940..8df8da3cd 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
@@ -194,7 +194,6 @@ public int numInputAttributes() {
     }
 
     public int numOutputAttributes() {
-
     	return outputIndexes.size();
     }
     
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
index 30401fdf5..ece3f6d58 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
@@ -217,7 +217,16 @@ public void setOutputIndexes(List<Integer> outputIndexes) {
 	public void setInputIndexes(List<Integer> inputIndexes) {
 		this.instanceInformation.setInputIndexes(inputIndexes);
 	}
+	
+	public int getInputInstanceIndex(int index) {
+		return this.instanceInformation.inputAttributeIndex(index);
+	}
+
+	public int getOutputInstanceIndex(int index) {
+		return this.instanceInformation.outputAttributeIndex(index);
+	}
 
+	
 	/** 
 	 * Sets all non-output attributes as input attributes.
 	 */
@@ -478,6 +487,10 @@ public void delete(int index) {
 		this.instances.remove(index);
 	}
 
+	
+	public void setInstances(List<Instance> instances) {
+		this.instances = instances;
+	}
 
 	/**
 	 * Swap.
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
index 7e8fb2bdc..55b335f4b 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelPrediction.java
@@ -14,9 +14,10 @@
  */
 package com.yahoo.labs.samoa.instances;
 
-import moa.core.DoubleVector;
 import java.io.Serializable;
 
+import moa.core.DoubleVector;
+
 public class MultiLabelPrediction implements Prediction, Serializable {
 	/**
 	 * 
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/SamoaToWekaInstanceConverter.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/SamoaToWekaInstanceConverter.java
index 3ef342875..ad1acfad7 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/SamoaToWekaInstanceConverter.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/SamoaToWekaInstanceConverter.java
@@ -15,8 +15,8 @@
  */
 package com.yahoo.labs.samoa.instances;
 
-import java.util.ArrayList;
 import java.io.Serializable;
+import java.util.ArrayList;
 
 /**
  * The Class SamoaToWekaInstanceConverter.
diff --git a/moa/src/main/java/moa/AbstractMOAObject.java b/moa/src/main/java/moa/AbstractMOAObject.java
index 60310da9e..3cea8bf11 100644
--- a/moa/src/main/java/moa/AbstractMOAObject.java
+++ b/moa/src/main/java/moa/AbstractMOAObject.java
@@ -37,7 +37,7 @@ public MOAObject copy() {
     }
 
     @Override
-    public int measureByteSize() {
+    public long measureByteSize() {
         return measureByteSize(this);
     }
 
@@ -73,7 +73,7 @@ public static MOAObject copy(MOAObject obj) {
      * @param obj object to measure the memory size
      * @return the memory size of this object
      */
-    public static int measureByteSize(MOAObject obj) {
-        return (int) SizeOf.fullSizeOf(obj);
+    public static long measureByteSize(MOAObject obj) {
+        return SizeOf.fullSizeOf(obj);
     }
 }
diff --git a/moa/src/main/java/moa/DoTask.java b/moa/src/main/java/moa/DoTask.java
index 0365bc2cb..0f7e51789 100644
--- a/moa/src/main/java/moa/DoTask.java
+++ b/moa/src/main/java/moa/DoTask.java
@@ -19,7 +19,10 @@
  */
 package moa;
 
-import weka.core.Version;
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.Option;
+
 import moa.core.Globals;
 import moa.core.Measurement;
 import moa.core.StringUtils;
@@ -29,10 +32,7 @@
 import moa.tasks.FailedTaskReport;
 import moa.tasks.Task;
 import moa.tasks.TaskThread;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.Option;
+import weka.core.Version;
 
 /**
  * Class for running a MOA task from the command line.
diff --git a/moa/src/main/java/moa/MOAObject.java b/moa/src/main/java/moa/MOAObject.java
index 497547634..4ec56618d 100644
--- a/moa/src/main/java/moa/MOAObject.java
+++ b/moa/src/main/java/moa/MOAObject.java
@@ -36,7 +36,7 @@ public interface MOAObject extends Serializable {
      *
      * @return the memory size of this object
      */
-    public int measureByteSize();
+    public long measureByteSize();
 
     /**
      * This method produces a copy of this object.
diff --git a/moa/src/main/java/moa/classifiers/AbstractClassifier.java b/moa/src/main/java/moa/classifiers/AbstractClassifier.java
index fb8daca38..7b050c020 100644
--- a/moa/src/main/java/moa/classifiers/AbstractClassifier.java
+++ b/moa/src/main/java/moa/classifiers/AbstractClassifier.java
@@ -25,31 +25,23 @@
 import java.util.List;
 import java.util.Random;
 
-import moa.MOAObject;
-import moa.core.Example;
-
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
+import com.yahoo.labs.samoa.instances.Prediction;
 
+import moa.MOAObject;
+import moa.core.Example;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
 import moa.core.StringUtils;
+import moa.core.Utils;
 import moa.gui.AWTRenderer;
 import moa.learners.Learner;
 import moa.options.AbstractOptionHandler;
-
-import com.github.javacliparser.IntOption;
-
 import moa.tasks.TaskMonitor;
 
-import com.yahoo.labs.samoa.instances.DenseInstanceData;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
-import com.yahoo.labs.samoa.instances.Prediction;
-
-import moa.core.Utils;
-
 public abstract class AbstractClassifier extends AbstractOptionHandler
         implements Classifier { //Learner<Example<Instance>> {
 
@@ -78,10 +70,10 @@ public String getPurposeString() {
      * if the classifier is randomizable.
      */
     public AbstractClassifier() {
-        if (isRandomizable()) {
-            this.randomSeedOption = new IntOption("randomSeed", 'r',
-                    "Seed for random behaviour of the classifier.", 1);
-        }
+//        if (isRandomizable()) {
+//            this.randomSeedOption = new IntOption("randomSeed", 'r',
+//                    "Seed for random behaviour of the classifier.", 1);
+//        }
     }
 
     @Override
@@ -112,8 +104,8 @@ public Prediction getPredictionForInstance(Example<Instance> example){
 
     @Override
     public Prediction getPredictionForInstance(Instance inst){
-    	Prediction prediction= new MultiLabelPrediction(1);
-    	prediction.setVotes(getVotesForInstance(inst));
+    	Prediction prediction= new MultiLabelPrediction(inst.numOutputAttributes());
+  		prediction.setVotes(getVotesForInstance(inst));
     	return prediction;
     }
 
diff --git a/moa/src/main/java/moa/classifiers/AbstractMultiLabelLearner.java b/moa/src/main/java/moa/classifiers/AbstractMultiLabelLearner.java
index 3fefdd9ce..c4ea71475 100644
--- a/moa/src/main/java/moa/classifiers/AbstractMultiLabelLearner.java
+++ b/moa/src/main/java/moa/classifiers/AbstractMultiLabelLearner.java
@@ -1,9 +1,10 @@
 package moa.classifiers;
 
-import moa.core.Example;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
+import moa.core.Example;
 
 public abstract class AbstractMultiLabelLearner extends AbstractClassifier implements MultiLabelLearner {
 
diff --git a/moa/src/main/java/moa/classifiers/Classifier.java b/moa/src/main/java/moa/classifiers/Classifier.java
index 101d7fe3d..d246bee77 100644
--- a/moa/src/main/java/moa/classifiers/Classifier.java
+++ b/moa/src/main/java/moa/classifiers/Classifier.java
@@ -19,13 +19,12 @@
  */
 package moa.classifiers;
 
-import moa.core.Example;
-import moa.learners.Learner;
-
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
 import com.yahoo.labs.samoa.instances.Prediction;
 
+import moa.core.Example;
+import moa.learners.Learner;
+
 /**
  * Classifier interface for incremental classification models.
  *
diff --git a/moa/src/main/java/moa/classifiers/MultiLabelLearner.java b/moa/src/main/java/moa/classifiers/MultiLabelLearner.java
index ee875ee60..97e995a1c 100644
--- a/moa/src/main/java/moa/classifiers/MultiLabelLearner.java
+++ b/moa/src/main/java/moa/classifiers/MultiLabelLearner.java
@@ -1,7 +1,7 @@
 package moa.classifiers;
 
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 public interface MultiLabelLearner extends Classifier{
 	
diff --git a/moa/src/main/java/moa/classifiers/active/ActiveClassifier.java b/moa/src/main/java/moa/classifiers/active/ActiveClassifier.java
index da8922e85..6b44087f3 100644
--- a/moa/src/main/java/moa/classifiers/active/ActiveClassifier.java
+++ b/moa/src/main/java/moa/classifiers/active/ActiveClassifier.java
@@ -22,17 +22,17 @@
 
 import java.util.LinkedList;
 import java.util.List;
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.Classifier;
 
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.MultiChoiceOption;
 import com.yahoo.labs.samoa.instances.Instance;
-import moa.core.Utils;
 
+import moa.classifiers.AbstractClassifier;
+import moa.classifiers.Classifier;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
+import moa.core.Utils;
 import moa.options.ClassOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.MultiChoiceOption;
 
 /**
  * Active learning setting for evolving data streams.
diff --git a/moa/src/main/java/moa/classifiers/bayes/NaiveBayes.java b/moa/src/main/java/moa/classifiers/bayes/NaiveBayes.java
index 6c9ab92ff..4ff1ad0af 100644
--- a/moa/src/main/java/moa/classifiers/bayes/NaiveBayes.java
+++ b/moa/src/main/java/moa/classifiers/bayes/NaiveBayes.java
@@ -19,6 +19,8 @@
  */
 package moa.classifiers.bayes;
 
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
 import moa.classifiers.core.attributeclassobservers.GaussianNumericAttributeClassObserver;
@@ -27,7 +29,6 @@
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.StringUtils;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Naive Bayes incremental learner.
diff --git a/moa/src/main/java/moa/classifiers/bayes/NaiveBayesMultinomial.java b/moa/src/main/java/moa/classifiers/bayes/NaiveBayesMultinomial.java
index 5e474770e..4f5cf8063 100644
--- a/moa/src/main/java/moa/classifiers/bayes/NaiveBayesMultinomial.java
+++ b/moa/src/main/java/moa/classifiers/bayes/NaiveBayesMultinomial.java
@@ -21,14 +21,16 @@
 package moa.classifiers.bayes;
 
 import java.util.Arrays;
+
 import com.github.javacliparser.FloatOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.classifiers.AbstractClassifier;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.StringUtils;
 import moa.core.Utils;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * <!-- globalinfo-start --> Class for building and using a multinomial Naive
diff --git a/moa/src/main/java/moa/classifiers/core/AttributeSplitSuggestion.java b/moa/src/main/java/moa/classifiers/core/AttributeSplitSuggestion.java
index d8f08b3ac..8c5f21837 100644
--- a/moa/src/main/java/moa/classifiers/core/AttributeSplitSuggestion.java
+++ b/moa/src/main/java/moa/classifiers/core/AttributeSplitSuggestion.java
@@ -19,8 +19,8 @@
  */
 package moa.classifiers.core;
 
-import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
 import moa.AbstractMOAObject;
+import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
 
 /**
  * Class for computing attribute split suggestions given a split test.
diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserver.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserver.java
index d64b4f569..269039fb6 100644
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserver.java
+++ b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserver.java
@@ -21,6 +21,7 @@
 package moa.classifiers.core.attributeclassobservers;
 
 import java.io.Serializable;
+
 import moa.classifiers.core.AttributeSplitSuggestion;
 import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserverRegression.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserverRegression.java
index 7155bb235..2a084d630 100644
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserverRegression.java
+++ b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserverRegression.java
@@ -22,6 +22,7 @@
 package moa.classifiers.core.attributeclassobservers;
 
 import java.io.Serializable;
+
 import moa.classifiers.core.AttributeSplitSuggestion;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
 import moa.core.ObjectRepository;
diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/FIMTDDNumericAttributeClassObserver.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/FIMTDDNumericAttributeClassObserver.java
index cd822e4e6..c36862652 100644
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/FIMTDDNumericAttributeClassObserver.java
+++ b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/FIMTDDNumericAttributeClassObserver.java
@@ -27,6 +27,7 @@
 package moa.classifiers.core.attributeclassobservers;
 
 import java.io.Serializable;
+
 import moa.classifiers.core.AttributeSplitSuggestion;
 import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
@@ -47,7 +48,7 @@ protected class Node implements Serializable {
 
         // E-BST statistics
         public DoubleVector leftStatistics = new DoubleVector();
-        public DoubleVector rightStatistics = new DoubleVector();
+        //public DoubleVector rightStatistics = new DoubleVector();
 
         // Child nodes
         public Node left;
@@ -55,9 +56,9 @@ protected class Node implements Serializable {
 
         public Node(double val, double label, double weight) {
             this.cut_point = val;
-            this.leftStatistics.addToValue(0, 1);
-            this.leftStatistics.addToValue(1, label);
-            this.leftStatistics.addToValue(2, label * label);
+            this.leftStatistics.addToValue(0, weight);
+            this.leftStatistics.addToValue(1, weight * label);
+            this.leftStatistics.addToValue(2, weight * label * label);
         }
 
         /**
@@ -69,16 +70,16 @@ public void insertValue(double val, double label, double weight) {
 		// If the new value equals the value stored in a node, update
             // the left (<=) node information
             if (val == this.cut_point) {
-                this.leftStatistics.addToValue(0, 1);
-                this.leftStatistics.addToValue(1, label);
-                this.leftStatistics.addToValue(2, label * label);
+                this.leftStatistics.addToValue(0, weight);
+                this.leftStatistics.addToValue(1, weight * label);
+                this.leftStatistics.addToValue(2, weight * label * label);
             } // If the new value is less than the value in a node, update the
             // left distribution and send the value down to the left child node.
             // If no left child exists, create one
             else if (val <= this.cut_point) {
-                this.leftStatistics.addToValue(0, 1);
-                this.leftStatistics.addToValue(1, label);
-                this.leftStatistics.addToValue(2, label * label);
+                this.leftStatistics.addToValue(0, weight);
+                this.leftStatistics.addToValue(1, weight * label);
+                this.leftStatistics.addToValue(2, weight * label * label);
                 if (this.left == null) {
                     this.left = new Node(val, label, weight);
                 } else {
@@ -88,14 +89,14 @@ else if (val <= this.cut_point) {
             // right (>) distribution and send the value down to the right child node.
             // If no right child exists, create one
             else { // val > cut_point
-                this.rightStatistics.addToValue(0, 1);
-                this.rightStatistics.addToValue(1, label);
-                this.rightStatistics.addToValue(2, label * label);
-                if (this.right == null) {
-                    this.right = new Node(val, label, weight);
-                } else {
-                    this.right.insertValue(val, label, weight);
-                }
+                //this.rightStatistics.addToValue(0, weight);
+                //this.rightStatistics.addToValue(1, weight * label);
+                //this.rightStatistics.addToValue(2, weight * label * label);
+                //if (this.right == null) {
+                //    this.right = new Node(val, label, weight);
+                //} else {
+                //    this.right.insertValue(val, label, weight);
+                //}
             }
         }
     }
@@ -111,10 +112,20 @@ else if (val <= this.cut_point) {
     double countRightTotal;
     double countLeftTotal;
 
+	public static double roundToSignificantFigures(double num, int n) {
+	    final double d = Math.ceil(Math.log10(num < 0 ? -num: num));
+	    final int power = n - (int) d;
+
+	    final double magnitude = Math.pow(10, power);
+	    final long shifted = (long) (num*magnitude);
+	    return shifted/magnitude;
+	}
+    
     public void observeAttributeClass(double attVal, double classVal, double weight) {
         if (Double.isNaN(attVal)) { //Instance.isMissingValue(attVal)
         } else {
             if (this.root == null) {
+//            	if ((long) attVal != attVal) attVal = roundToSignificantFigures(attVal, 4);
                 this.root = new Node(attVal, classVal, weight);
             } else {
                 this.root.insertValue(attVal, classVal, weight);
@@ -215,14 +226,14 @@ private boolean removeBadSplitNodes(SplitCriterion criterion, Node currentNode,
 
         if (isBad) {
 
-            double[][] postSplitDists = new double[][]{{currentNode.leftStatistics.getValue(0), currentNode.leftStatistics.getValue(1), currentNode.leftStatistics.getValue(2)}, {currentNode.rightStatistics.getValue(0), currentNode.rightStatistics.getValue(1), currentNode.rightStatistics.getValue(2)}};
-            double[] preSplitDist = new double[]{(currentNode.leftStatistics.getValue(0) + currentNode.rightStatistics.getValue(0)), (currentNode.leftStatistics.getValue(1) + currentNode.rightStatistics.getValue(1)), (currentNode.leftStatistics.getValue(2) + currentNode.rightStatistics.getValue(2))};
-            double merit = criterion.getMeritOfSplit(preSplitDist, postSplitDists);
+            //double[][] postSplitDists = new double[][]{{currentNode.leftStatistics.getValue(0), currentNode.leftStatistics.getValue(1), currentNode.leftStatistics.getValue(2)}, {currentNode.rightStatistics.getValue(0), currentNode.rightStatistics.getValue(1), currentNode.rightStatistics.getValue(2)}};
+            //double[] preSplitDist = new double[]{(currentNode.leftStatistics.getValue(0) + currentNode.rightStatistics.getValue(0)), (currentNode.leftStatistics.getValue(1) + currentNode.rightStatistics.getValue(1)), (currentNode.leftStatistics.getValue(2) + currentNode.rightStatistics.getValue(2))};
+            //double merit = criterion.getMeritOfSplit(preSplitDist, postSplitDists);
 
-            if ((merit / lastCheckSDR) < (lastCheckRatio - (2 * lastCheckE))) {
-                currentNode = null;
-                return true;
-            }
+            //if ((merit / lastCheckSDR) < (lastCheckRatio - (2 * lastCheckE))) {
+            //    currentNode = null;
+            //    return true;
+            //}
         }
 
         return false;
diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/GaussianNumericAttributeClassObserver.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/GaussianNumericAttributeClassObserver.java
index dbc0e0e17..9d5620eee 100644
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/GaussianNumericAttributeClassObserver.java
+++ b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/GaussianNumericAttributeClassObserver.java
@@ -19,21 +19,21 @@
  */
 package moa.classifiers.core.attributeclassobservers;
 
-import moa.core.ObjectRepository;
-import moa.tasks.TaskMonitor;
-import moa.core.Utils;
-
 import java.util.Set;
 import java.util.TreeSet;
+
+import com.github.javacliparser.IntOption;
+
 import moa.classifiers.core.AttributeSplitSuggestion;
 import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
-
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
 import moa.core.GaussianEstimator;
+import moa.core.ObjectRepository;
+import moa.core.Utils;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.IntOption;
+import moa.tasks.TaskMonitor;
 
 /**
  * Class for observing the class data distribution for a numeric attribute using gaussian estimators.
diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/GreenwaldKhannaNumericAttributeClassObserver.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/GreenwaldKhannaNumericAttributeClassObserver.java
index 32061a92b..f1f3b0076 100644
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/GreenwaldKhannaNumericAttributeClassObserver.java
+++ b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/GreenwaldKhannaNumericAttributeClassObserver.java
@@ -19,17 +19,17 @@
  */
 package moa.classifiers.core.attributeclassobservers;
 
+import com.github.javacliparser.IntOption;
+
 import moa.classifiers.core.AttributeSplitSuggestion;
 import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.core.Utils;
-
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
 import moa.core.GreenwaldKhannaQuantileSummary;
 import moa.core.ObjectRepository;
+import moa.core.Utils;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
 
 /**
diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/NominalAttributeClassObserver.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/NominalAttributeClassObserver.java
index ce8021017..4ae978569 100644
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/NominalAttributeClassObserver.java
+++ b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/NominalAttributeClassObserver.java
@@ -23,13 +23,12 @@
 import moa.classifiers.core.conditionaltests.NominalAttributeBinaryTest;
 import moa.classifiers.core.conditionaltests.NominalAttributeMultiwayTest;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.core.ObjectRepository;
-import moa.tasks.TaskMonitor;
-import moa.core.Utils;
-
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
+import moa.core.ObjectRepository;
+import moa.core.Utils;
 import moa.options.AbstractOptionHandler;
+import moa.tasks.TaskMonitor;
 
 /**
  * Class for observing the class data distribution for a nominal attribute.
diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/VFMLNumericAttributeClassObserver.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/VFMLNumericAttributeClassObserver.java
index c3a4cbed7..0b4f7b3ae 100644
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/VFMLNumericAttributeClassObserver.java
+++ b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/VFMLNumericAttributeClassObserver.java
@@ -19,19 +19,19 @@
  */
 package moa.classifiers.core.attributeclassobservers;
 
-import moa.core.Utils;
-
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.List;
+
+import com.github.javacliparser.IntOption;
+
 import moa.classifiers.core.AttributeSplitSuggestion;
 import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
-
 import moa.core.DoubleVector;
 import moa.core.ObjectRepository;
+import moa.core.Utils;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
 
 /**
diff --git a/moa/src/main/java/moa/classifiers/core/conditionaltests/InstanceConditionalTest.java b/moa/src/main/java/moa/classifiers/core/conditionaltests/InstanceConditionalTest.java
index 9d5160136..08f7c7100 100644
--- a/moa/src/main/java/moa/classifiers/core/conditionaltests/InstanceConditionalTest.java
+++ b/moa/src/main/java/moa/classifiers/core/conditionaltests/InstanceConditionalTest.java
@@ -19,11 +19,11 @@
  */
 package moa.classifiers.core.conditionaltests;
 
-import moa.AbstractMOAObject;
-
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.AbstractMOAObject;
+
 /**
  * Abstract conditional test for instances to use to split nodes in Hoeffding trees.
  *
diff --git a/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeBinaryTest.java b/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeBinaryTest.java
index 519ec6a42..62f1e73bc 100644
--- a/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeBinaryTest.java
+++ b/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeBinaryTest.java
@@ -19,7 +19,6 @@
  */
 package moa.classifiers.core.conditionaltests;
 
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
diff --git a/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeMultiwayTest.java b/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeMultiwayTest.java
index a0dd5ff7b..eb1135ef1 100644
--- a/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeMultiwayTest.java
+++ b/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeMultiwayTest.java
@@ -19,7 +19,6 @@
  */
 package moa.classifiers.core.conditionaltests;
 
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
diff --git a/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java b/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
index 597a7c07f..ca81135f5 100644
--- a/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
+++ b/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
@@ -19,7 +19,6 @@
  */
 package moa.classifiers.core.conditionaltests;
 
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/ADWINChangeDetector.java b/moa/src/main/java/moa/classifiers/core/driftdetection/ADWINChangeDetector.java
index a2755fee6..fb9366e7f 100644
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/ADWINChangeDetector.java
+++ b/moa/src/main/java/moa/classifiers/core/driftdetection/ADWINChangeDetector.java
@@ -19,6 +19,7 @@
 package moa.classifiers.core.driftdetection;
 
 import com.github.javacliparser.FloatOption;
+
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/CusumDM.java b/moa/src/main/java/moa/classifiers/core/driftdetection/CusumDM.java
index 6b65bead3..8653a1007 100644
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/CusumDM.java
+++ b/moa/src/main/java/moa/classifiers/core/driftdetection/CusumDM.java
@@ -20,6 +20,7 @@
 
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
+
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/DDM.java b/moa/src/main/java/moa/classifiers/core/driftdetection/DDM.java
index be0baac1e..f1e5bb3aa 100644
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/DDM.java
+++ b/moa/src/main/java/moa/classifiers/core/driftdetection/DDM.java
@@ -19,6 +19,7 @@
 package moa.classifiers.core.driftdetection;
 
 import com.github.javacliparser.IntOption;
+
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/EWMAChartDM.java b/moa/src/main/java/moa/classifiers/core/driftdetection/EWMAChartDM.java
index 381998ebf..83b5c4981 100644
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/EWMAChartDM.java
+++ b/moa/src/main/java/moa/classifiers/core/driftdetection/EWMAChartDM.java
@@ -20,6 +20,7 @@
 
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
+
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/EnsembleDriftDetectionMethods.java b/moa/src/main/java/moa/classifiers/core/driftdetection/EnsembleDriftDetectionMethods.java
index 3a887fa63..08e68c8d3 100644
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/EnsembleDriftDetectionMethods.java
+++ b/moa/src/main/java/moa/classifiers/core/driftdetection/EnsembleDriftDetectionMethods.java
@@ -22,6 +22,7 @@
 import com.github.javacliparser.ListOption;
 import com.github.javacliparser.MultiChoiceOption;
 import com.github.javacliparser.Option;
+
 import moa.core.ObjectRepository;
 import moa.options.ClassOption;
 import moa.options.OptionHandler;
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/GeometricMovingAverageDM.java b/moa/src/main/java/moa/classifiers/core/driftdetection/GeometricMovingAverageDM.java
index e3bbee7bf..1b7074ed2 100644
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/GeometricMovingAverageDM.java
+++ b/moa/src/main/java/moa/classifiers/core/driftdetection/GeometricMovingAverageDM.java
@@ -20,6 +20,7 @@
 
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
+
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/HDDM_A_Test.java b/moa/src/main/java/moa/classifiers/core/driftdetection/HDDM_A_Test.java
index 92b963bdd..37d4118da 100644
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/HDDM_A_Test.java
+++ b/moa/src/main/java/moa/classifiers/core/driftdetection/HDDM_A_Test.java
@@ -23,6 +23,7 @@
 
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.MultiChoiceOption;
+
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/HDDM_W_Test.java b/moa/src/main/java/moa/classifiers/core/driftdetection/HDDM_W_Test.java
index 0ed125f45..b4c6111e4 100644
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/HDDM_W_Test.java
+++ b/moa/src/main/java/moa/classifiers/core/driftdetection/HDDM_W_Test.java
@@ -21,6 +21,7 @@
 
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.MultiChoiceOption;
+
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/PageHinkleyDM.java b/moa/src/main/java/moa/classifiers/core/driftdetection/PageHinkleyDM.java
index a9c916ea2..fecdb775d 100644
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/PageHinkleyDM.java
+++ b/moa/src/main/java/moa/classifiers/core/driftdetection/PageHinkleyDM.java
@@ -20,6 +20,7 @@
 
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
+
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/SEEDChangeDetector.java b/moa/src/main/java/moa/classifiers/core/driftdetection/SEEDChangeDetector.java
index 8b6226430..8f7124b0e 100644
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/SEEDChangeDetector.java
+++ b/moa/src/main/java/moa/classifiers/core/driftdetection/SEEDChangeDetector.java
@@ -21,6 +21,7 @@
 
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
+
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/SeqDrift1ChangeDetector.java b/moa/src/main/java/moa/classifiers/core/driftdetection/SeqDrift1ChangeDetector.java
index bc5bca3d6..72aae962a 100644
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/SeqDrift1ChangeDetector.java
+++ b/moa/src/main/java/moa/classifiers/core/driftdetection/SeqDrift1ChangeDetector.java
@@ -18,13 +18,15 @@
  */
 package moa.classifiers.core.driftdetection;
 
+import java.util.ArrayList;
+
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
-import moa.core.ObjectRepository;
-import moa.tasks.TaskMonitor;
-import java.util.ArrayList;
+
 import moa.AbstractMOAObject;
 import moa.classifiers.core.driftdetection.SeqDrift2ChangeDetector.Repository;
+import moa.core.ObjectRepository;
+import moa.tasks.TaskMonitor;
 
 /**
  * SeqDrift1ChangeDetector.java. This extends Abstract Change Detector 
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/SeqDrift2ChangeDetector.java b/moa/src/main/java/moa/classifiers/core/driftdetection/SeqDrift2ChangeDetector.java
index 6278e15fc..37de7e7fc 100644
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/SeqDrift2ChangeDetector.java
+++ b/moa/src/main/java/moa/classifiers/core/driftdetection/SeqDrift2ChangeDetector.java
@@ -18,13 +18,15 @@
  */
 package moa.classifiers.core.driftdetection;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
+
+import moa.AbstractMOAObject;
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
-import java.util.ArrayList;
-import java.util.List;
-import moa.AbstractMOAObject;
 
 /**
  * SeqDriftChangeDetector.java. This extends Abstract Change Detector 
diff --git a/moa/src/main/java/moa/classifiers/core/splitcriteria/InfoGainSplitCriterion.java b/moa/src/main/java/moa/classifiers/core/splitcriteria/InfoGainSplitCriterion.java
index bbb6a0eea..516ac8823 100644
--- a/moa/src/main/java/moa/classifiers/core/splitcriteria/InfoGainSplitCriterion.java
+++ b/moa/src/main/java/moa/classifiers/core/splitcriteria/InfoGainSplitCriterion.java
@@ -20,6 +20,7 @@
 package moa.classifiers.core.splitcriteria;
 
 import com.github.javacliparser.FloatOption;
+
 import moa.core.ObjectRepository;
 import moa.core.Utils;
 import moa.options.AbstractOptionHandler;
diff --git a/moa/src/main/java/moa/classifiers/drift/DriftDetectionMethodClassifier.java b/moa/src/main/java/moa/classifiers/drift/DriftDetectionMethodClassifier.java
index 06a4f60d2..b920e82fa 100644
--- a/moa/src/main/java/moa/classifiers/drift/DriftDetectionMethodClassifier.java
+++ b/moa/src/main/java/moa/classifiers/drift/DriftDetectionMethodClassifier.java
@@ -18,15 +18,17 @@
  */
 package moa.classifiers.drift;
 
-import com.yahoo.labs.samoa.instances.Instance;
 import java.util.LinkedList;
 import java.util.List;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
+import moa.classifiers.core.driftdetection.ChangeDetector;
 import moa.classifiers.meta.WEKAClassifier;
 import moa.core.Measurement;
 import moa.core.Utils;
-import moa.classifiers.core.driftdetection.ChangeDetector;
 import moa.options.ClassOption;
 
 /**
diff --git a/moa/src/main/java/moa/classifiers/functions/MajorityClass.java b/moa/src/main/java/moa/classifiers/functions/MajorityClass.java
index e92892bcc..bf254d191 100644
--- a/moa/src/main/java/moa/classifiers/functions/MajorityClass.java
+++ b/moa/src/main/java/moa/classifiers/functions/MajorityClass.java
@@ -19,11 +19,12 @@
  */
 package moa.classifiers.functions;
 
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.StringUtils;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Majority class learner. This is the simplest classifier.
diff --git a/moa/src/main/java/moa/classifiers/functions/NoChange.java b/moa/src/main/java/moa/classifiers/functions/NoChange.java
index e52b5608a..ee45de0ee 100644
--- a/moa/src/main/java/moa/classifiers/functions/NoChange.java
+++ b/moa/src/main/java/moa/classifiers/functions/NoChange.java
@@ -19,9 +19,10 @@
  */
 package moa.classifiers.functions;
 
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.core.Measurement;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * NoChange class classifier. It always predicts the last class seen.
diff --git a/moa/src/main/java/moa/classifiers/functions/Perceptron.java b/moa/src/main/java/moa/classifiers/functions/Perceptron.java
index ca4c997ff..8e5fa11d5 100644
--- a/moa/src/main/java/moa/classifiers/functions/Perceptron.java
+++ b/moa/src/main/java/moa/classifiers/functions/Perceptron.java
@@ -19,11 +19,12 @@
  */
 package moa.classifiers.functions;
 
+import com.github.javacliparser.FloatOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.core.Measurement;
 import moa.core.Utils;
-import com.github.javacliparser.FloatOption;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Single perceptron classifier.
diff --git a/moa/src/main/java/moa/classifiers/functions/SGD.java b/moa/src/main/java/moa/classifiers/functions/SGD.java
index 12df09340..8c5100f56 100644
--- a/moa/src/main/java/moa/classifiers/functions/SGD.java
+++ b/moa/src/main/java/moa/classifiers/functions/SGD.java
@@ -27,14 +27,15 @@
 
 package moa.classifiers.functions;
 
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
+import moa.classifiers.Regressor;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.StringUtils;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.MultiChoiceOption;
-import moa.classifiers.Regressor;
-import com.yahoo.labs.samoa.instances.Instance;
 import moa.core.Utils;
 
 /**
diff --git a/moa/src/main/java/moa/classifiers/functions/SGDMultiClass.java b/moa/src/main/java/moa/classifiers/functions/SGDMultiClass.java
index 3b7c274b1..f7c824815 100644
--- a/moa/src/main/java/moa/classifiers/functions/SGDMultiClass.java
+++ b/moa/src/main/java/moa/classifiers/functions/SGDMultiClass.java
@@ -27,14 +27,15 @@
 
 package moa.classifiers.functions;
 
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Regressor;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.StringUtils;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
 import moa.core.Utils;
 
 
diff --git a/moa/src/main/java/moa/classifiers/functions/SPegasos.java b/moa/src/main/java/moa/classifiers/functions/SPegasos.java
index cf562e6e5..3b418f734 100644
--- a/moa/src/main/java/moa/classifiers/functions/SPegasos.java
+++ b/moa/src/main/java/moa/classifiers/functions/SPegasos.java
@@ -25,12 +25,13 @@
  */
 package moa.classifiers.functions;
 
-import moa.classifiers.AbstractClassifier;
-import moa.core.Measurement;
-import moa.core.StringUtils;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.MultiChoiceOption;
 import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.classifiers.AbstractClassifier;
+import moa.core.Measurement;
+import moa.core.StringUtils;
 import moa.core.Utils;
 
 /**
diff --git a/moa/src/main/java/moa/classifiers/lazy/kNN.java b/moa/src/main/java/moa/classifiers/lazy/kNN.java
index 1cf765b1d..f3ad62446 100644
--- a/moa/src/main/java/moa/classifiers/lazy/kNN.java
+++ b/moa/src/main/java/moa/classifiers/lazy/kNN.java
@@ -17,16 +17,16 @@
  */
 package moa.classifiers.lazy;
 
-import java.io.StringReader;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.lazy.neighboursearch.KDTree;
 import moa.classifiers.lazy.neighboursearch.LinearNNSearch;
 import moa.classifiers.lazy.neighboursearch.NearestNeighbourSearch;
 import moa.core.Measurement;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.MultiChoiceOption;
 
 /**
  * k Nearest Neighbor.<p>
diff --git a/moa/src/main/java/moa/classifiers/lazy/kNNwithPAW.java b/moa/src/main/java/moa/classifiers/lazy/kNNwithPAW.java
index 6b78777a3..ae232b9b0 100644
--- a/moa/src/main/java/moa/classifiers/lazy/kNNwithPAW.java
+++ b/moa/src/main/java/moa/classifiers/lazy/kNNwithPAW.java
@@ -17,7 +17,6 @@
  */
 package moa.classifiers.lazy;
 
-import moa.classifiers.core.driftdetection.ADWIN;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
diff --git a/moa/src/main/java/moa/classifiers/lazy/kNNwithPAWandADWIN.java b/moa/src/main/java/moa/classifiers/lazy/kNNwithPAWandADWIN.java
index 65e9266ed..74670860e 100644
--- a/moa/src/main/java/moa/classifiers/lazy/kNNwithPAWandADWIN.java
+++ b/moa/src/main/java/moa/classifiers/lazy/kNNwithPAWandADWIN.java
@@ -18,10 +18,12 @@
 package moa.classifiers.lazy;
 
 import java.util.ArrayList;
-import moa.classifiers.core.driftdetection.ADWIN;
+
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.classifiers.core.driftdetection.ADWIN;
+
 /**
  * k Nearest Neighbor ADAPTIVE with ADWIN+PAW.<p>
  *
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/KDTree.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/KDTree.java
index b3b6d7a0d..684f063d8 100644
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/KDTree.java
+++ b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/KDTree.java
@@ -23,11 +23,13 @@
 
 import java.util.Enumeration;
 import java.util.Vector;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.classifiers.lazy.neighboursearch.kdtrees.KDTreeNode;
 import moa.classifiers.lazy.neighboursearch.kdtrees.KDTreeNodeSplitter;
 import moa.classifiers.lazy.neighboursearch.kdtrees.SlidingMidPointOfWidestSide;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 
 
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NearestNeighbourSearch.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NearestNeighbourSearch.java
index ddefd58ae..541d0f527 100644
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NearestNeighbourSearch.java
+++ b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NearestNeighbourSearch.java
@@ -21,6 +21,7 @@
 package moa.classifiers.lazy.neighboursearch;
 
 import java.io.Serializable;
+
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NormalizableDistance.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NormalizableDistance.java
index 7800a8576..46da24f3e 100644
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NormalizableDistance.java
+++ b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NormalizableDistance.java
@@ -21,7 +21,6 @@
 
 package moa.classifiers.lazy.neighboursearch;
 
-import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KDTreeNodeSplitter.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KDTreeNodeSplitter.java
index f69760c9f..61126b4a0 100644
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KDTreeNodeSplitter.java
+++ b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KDTreeNodeSplitter.java
@@ -23,10 +23,11 @@
 import java.io.Serializable;
 import java.util.Enumeration;
 import java.util.Vector;
-import moa.classifiers.lazy.neighboursearch.EuclideanDistance;
 
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.classifiers.lazy.neighboursearch.EuclideanDistance;
+
 /**
  * Class that splits up a KDTreeNode.
  * 
diff --git a/moa/src/main/java/moa/classifiers/meta/ADACC.java b/moa/src/main/java/moa/classifiers/meta/ADACC.java
index 8aa324af8..f5dbe47c1 100644
--- a/moa/src/main/java/moa/classifiers/meta/ADACC.java
+++ b/moa/src/main/java/moa/classifiers/meta/ADACC.java
@@ -20,15 +20,16 @@
 
 package moa.classifiers.meta;
 
+import java.util.Arrays;
+import java.util.Collections;
+
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.classifiers.Classifier;
 import moa.core.Measurement;
-
-import java.util.Arrays;
-import java.util.Collections;
 import moa.core.Utils;
 
 /**
diff --git a/moa/src/main/java/moa/classifiers/meta/AccuracyUpdatedEnsemble.java b/moa/src/main/java/moa/classifiers/meta/AccuracyUpdatedEnsemble.java
index f9764fa19..7a935202d 100644
--- a/moa/src/main/java/moa/classifiers/meta/AccuracyUpdatedEnsemble.java
+++ b/moa/src/main/java/moa/classifiers/meta/AccuracyUpdatedEnsemble.java
@@ -19,6 +19,10 @@
  */
 package moa.classifiers.meta;
 
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
 import moa.classifiers.trees.HoeffdingTree;
@@ -26,10 +30,7 @@
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
 import moa.options.ClassOption;
-import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * The revised version of the Accuracy Updated Ensemble as proposed by
diff --git a/moa/src/main/java/moa/classifiers/meta/AccuracyWeightedEnsemble.java b/moa/src/main/java/moa/classifiers/meta/AccuracyWeightedEnsemble.java
index df7e6fea1..3fd651d59 100644
--- a/moa/src/main/java/moa/classifiers/meta/AccuracyWeightedEnsemble.java
+++ b/moa/src/main/java/moa/classifiers/meta/AccuracyWeightedEnsemble.java
@@ -20,18 +20,20 @@
 package moa.classifiers.meta;
 
 import java.util.Random;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
+import moa.core.Utils;
 import moa.options.ClassOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import moa.core.Utils;
 
 /**
  * The Accuracy Weighted Ensemble classifier as proposed by Wang et al. in
@@ -433,9 +435,9 @@ protected Classifier addToStored(Classifier newClassifier, double newClassifiers
      *
      * @return the size of the removed classifier.
      */
-    protected int removePoorestModelBytes() {
+    protected long removePoorestModelBytes() {
         int poorestIndex = Utils.minIndex(this.ensembleWeights);
-        int byteSize = this.ensemble[poorestIndex].measureByteSize();
+        long byteSize = this.ensemble[poorestIndex].measureByteSize();
         discardModel(poorestIndex);
         return byteSize;
     }
diff --git a/moa/src/main/java/moa/classifiers/meta/DACC.java b/moa/src/main/java/moa/classifiers/meta/DACC.java
index 8cb76472b..dfb470e1e 100644
--- a/moa/src/main/java/moa/classifiers/meta/DACC.java
+++ b/moa/src/main/java/moa/classifiers/meta/DACC.java
@@ -20,18 +20,19 @@
 
 package moa.classifiers.meta;
 
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.MultiChoiceOption;
 import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
 import moa.options.ClassOption;
 
 /**
diff --git a/moa/src/main/java/moa/classifiers/meta/LeveragingBag.java b/moa/src/main/java/moa/classifiers/meta/LeveragingBag.java
index 6d6e78830..3edcf5ae1 100644
--- a/moa/src/main/java/moa/classifiers/meta/LeveragingBag.java
+++ b/moa/src/main/java/moa/classifiers/meta/LeveragingBag.java
@@ -19,20 +19,19 @@
  */
 package moa.classifiers.meta;
 
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.FlagOption;
-import moa.options.ClassOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
 import com.github.javacliparser.MultiChoiceOption;
-import moa.classifiers.core.driftdetection.ADWIN;
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.Classifier;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.classifiers.AbstractClassifier;
+import moa.classifiers.Classifier;
+import moa.classifiers.core.driftdetection.ADWIN;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.MiscUtils;
-import moa.options.*;
+import moa.options.ClassOption;
 
 /**
  * Leveraging Bagging for evolving data streams using ADWIN. Leveraging Bagging
diff --git a/moa/src/main/java/moa/classifiers/meta/LimAttClassifier.java b/moa/src/main/java/moa/classifiers/meta/LimAttClassifier.java
index 8cb281802..d223111dc 100644
--- a/moa/src/main/java/moa/classifiers/meta/LimAttClassifier.java
+++ b/moa/src/main/java/moa/classifiers/meta/LimAttClassifier.java
@@ -20,21 +20,21 @@
  */
 package moa.classifiers.meta;
 
-import moa.classifiers.trees.LimAttHoeffdingTree;
-import com.yahoo.labs.samoa.instances.Instance;
-import moa.core.Utils;
-
 import java.math.BigInteger;
 import java.util.Arrays;
-import moa.classifiers.core.driftdetection.ADWIN;
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.Classifier;
 
-import moa.core.Measurement;
-import moa.options.ClassOption;
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.classifiers.AbstractClassifier;
+import moa.classifiers.Classifier;
+import moa.classifiers.core.driftdetection.ADWIN;
+import moa.classifiers.trees.LimAttHoeffdingTree;
+import moa.core.Measurement;
+import moa.core.Utils;
+import moa.options.ClassOption;
 
 /**
  * Ensemble Combining Restricted Hoeffding Trees using Stacking.
diff --git a/moa/src/main/java/moa/classifiers/meta/OCBoost.java b/moa/src/main/java/moa/classifiers/meta/OCBoost.java
index 9e796ff7b..e9c33ff73 100644
--- a/moa/src/main/java/moa/classifiers/meta/OCBoost.java
+++ b/moa/src/main/java/moa/classifiers/meta/OCBoost.java
@@ -19,15 +19,15 @@
  */
 package moa.classifiers.meta;
 
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.Classifier;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
-import moa.core.Utils;
 
+import moa.classifiers.AbstractClassifier;
+import moa.classifiers.Classifier;
 import moa.core.Measurement;
+import moa.core.Utils;
 import moa.options.ClassOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
 
 /**
  * Online Coordinate boosting for two classes evolving data streams. 
diff --git a/moa/src/main/java/moa/classifiers/meta/OnlineAccuracyUpdatedEnsemble.java b/moa/src/main/java/moa/classifiers/meta/OnlineAccuracyUpdatedEnsemble.java
index 790599ff4..44e381d78 100644
--- a/moa/src/main/java/moa/classifiers/meta/OnlineAccuracyUpdatedEnsemble.java
+++ b/moa/src/main/java/moa/classifiers/meta/OnlineAccuracyUpdatedEnsemble.java
@@ -23,6 +23,7 @@
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
 import moa.classifiers.trees.HoeffdingTree;
diff --git a/moa/src/main/java/moa/classifiers/meta/OnlineSmoothBoost.java b/moa/src/main/java/moa/classifiers/meta/OnlineSmoothBoost.java
index 0810d2153..445ca1027 100644
--- a/moa/src/main/java/moa/classifiers/meta/OnlineSmoothBoost.java
+++ b/moa/src/main/java/moa/classifiers/meta/OnlineSmoothBoost.java
@@ -22,6 +22,7 @@
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
 import moa.core.DoubleVector;
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBag.java b/moa/src/main/java/moa/classifiers/meta/OzaBag.java
index 9ca3dd639..d43f2da0b 100644
--- a/moa/src/main/java/moa/classifiers/meta/OzaBag.java
+++ b/moa/src/main/java/moa/classifiers/meta/OzaBag.java
@@ -19,15 +19,15 @@
  */
 package moa.classifiers.meta;
 
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.Classifier;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.classifiers.AbstractClassifier;
+import moa.classifiers.Classifier;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.MiscUtils;
 import moa.options.ClassOption;
-import com.github.javacliparser.IntOption;
 
 /**
  * Incremental on-line bagging of Oza and Russell.
@@ -66,6 +66,14 @@ public String getPurposeString() {
 
     protected Classifier[] ensemble;
 
+    @Override
+    public long measureByteSize() {
+    	long size = 0;
+    	for (Classifier c : ensemble) 
+    		size += c.measureByteSize();
+    	return size;
+    }
+    
     @Override
     public void resetLearningImpl() {
         this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBagASHT.java b/moa/src/main/java/moa/classifiers/meta/OzaBagASHT.java
index 09bca78da..aba193b3b 100644
--- a/moa/src/main/java/moa/classifiers/meta/OzaBagASHT.java
+++ b/moa/src/main/java/moa/classifiers/meta/OzaBagASHT.java
@@ -19,7 +19,6 @@
  */
 package moa.classifiers.meta;
 
-import moa.options.ClassOption;
 import moa.classifiers.Classifier;
 import moa.classifiers.trees.ASHoeffdingTree;
 import moa.core.DoubleVector;
@@ -27,8 +26,6 @@
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.FlagOption;
 import com.yahoo.labs.samoa.instances.Instance;
-import moa.classifiers.AbstractClassifier;
-import moa.core.Measurement;
 import moa.core.Utils;
 
 /**
@@ -85,7 +82,7 @@
  * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
  * @version $Revision: 7 $
  */
-public class OzaBagASHT extends AbstractClassifier {
+public class OzaBagASHT extends OzaBag {
 
     private static final long serialVersionUID = 1L;
 
@@ -94,9 +91,6 @@ public String getPurposeString() {
         return "Bagging using trees of different size.";
     }
     
-    public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's',
-        "The number of models in the bag.", 10, 1, Integer.MAX_VALUE);
-    
     public IntOption firstClassifierSizeOption = new IntOption("firstClassifierSize", 'f',
             "The size of first classifier in the bag.", 1, 1, Integer.MAX_VALUE);
 
@@ -112,24 +106,25 @@ public String getPurposeString() {
     
     protected ASHoeffdingTree[] ensemble;
     protected double[] error;
+
     protected double alpha = 0.01;
 
     @Override
     public void resetLearningImpl() {
-        this.ensemble = new ASHoeffdingTree[this.ensembleSizeOption.getValue()];
+        this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
         this.error = new double[this.ensembleSizeOption.getValue()];
         Classifier baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
         baseLearner.resetLearning();
-        int pow = this.firstClassifierSizeOption.getValue();
+        int pow = this.firstClassifierSizeOption.getValue(); //EXTENSION TO ASHT
         for (int i = 0; i < this.ensemble.length; i++) {
-            this.ensemble[i] = (ASHoeffdingTree) baseLearner.copy();
+            this.ensemble[i] = baseLearner.copy();
             this.error[i] = 0.0;
-            ((ASHoeffdingTree) this.ensemble[i]).setMaxSize(pow);
+            ((ASHoeffdingTree) this.ensemble[i]).setMaxSize(pow); //EXTENSION TO ASHT
             if ((this.resetTreesOption != null)
                     && this.resetTreesOption.isSet()) {
                 ((ASHoeffdingTree) this.ensemble[i]).setResetTree();
             }
-            pow *= 2;
+            pow *= 2; //EXTENSION TO ASHT
         }
     }
 
@@ -171,20 +166,4 @@ public double[] getVotesForInstance(Instance inst) {
     public void getModelDescription(StringBuilder out, int indent) {
         // TODO Auto-generated method stub
     }
-    
-    @Override
-    public boolean isRandomizable() {
-        return true;
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return new Measurement[]{new Measurement("ensemble size",
-                    this.ensemble != null ? this.ensemble.length : 0)};
-    }
-    
-    @Override
-    public Classifier[] getSubClassifiers() {
-        return this.ensemble.clone();
-    }
 }
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBagAdwin.java b/moa/src/main/java/moa/classifiers/meta/OzaBagAdwin.java
index fa688e426..8f790f339 100644
--- a/moa/src/main/java/moa/classifiers/meta/OzaBagAdwin.java
+++ b/moa/src/main/java/moa/classifiers/meta/OzaBagAdwin.java
@@ -19,16 +19,16 @@
  */
 package moa.classifiers.meta;
 
-import moa.classifiers.core.driftdetection.ADWIN;
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.Classifier;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.classifiers.AbstractClassifier;
+import moa.classifiers.Classifier;
+import moa.classifiers.core.driftdetection.ADWIN;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.MiscUtils;
 import moa.options.ClassOption;
-import com.github.javacliparser.IntOption;
 
 /**
  * Bagging for evolving data streams using ADWIN.
@@ -141,7 +141,7 @@ public void trainOnInstanceImpl(Instance inst) {
             }
             if (imax != -1) {
                 this.ensemble[imax].resetLearning();
-                //this.ensemble[imax].trainOnInstance(inst);
+                this.ensemble[imax].trainOnInstance(inst);
                 this.ADError[imax] = new ADWIN();
             }
         }
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBoost.java b/moa/src/main/java/moa/classifiers/meta/OzaBoost.java
index 54fc8e15b..cf149c8c9 100644
--- a/moa/src/main/java/moa/classifiers/meta/OzaBoost.java
+++ b/moa/src/main/java/moa/classifiers/meta/OzaBoost.java
@@ -19,16 +19,16 @@
  */
 package moa.classifiers.meta;
 
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.Classifier;
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.classifiers.AbstractClassifier;
+import moa.classifiers.Classifier;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.MiscUtils;
 import moa.options.ClassOption;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
 
 /**
  * Incremental on-line boosting of Oza and Russell.
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBoostAdwin.java b/moa/src/main/java/moa/classifiers/meta/OzaBoostAdwin.java
index 17d370547..1e60ba154 100644
--- a/moa/src/main/java/moa/classifiers/meta/OzaBoostAdwin.java
+++ b/moa/src/main/java/moa/classifiers/meta/OzaBoostAdwin.java
@@ -19,17 +19,18 @@
  */
 package moa.classifiers.meta;
 
-import moa.classifiers.core.driftdetection.ADWIN;
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
+import moa.classifiers.core.driftdetection.ADWIN;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.MiscUtils;
 import moa.options.ClassOption;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Boosting for evolving data streams using ADWIN.
diff --git a/moa/src/main/java/moa/classifiers/meta/PairedLearners.java b/moa/src/main/java/moa/classifiers/meta/PairedLearners.java
index dc071be46..9ec64027e 100644
--- a/moa/src/main/java/moa/classifiers/meta/PairedLearners.java
+++ b/moa/src/main/java/moa/classifiers/meta/PairedLearners.java
@@ -18,18 +18,19 @@
  */
 package moa.classifiers.meta;
 
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
 import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
 
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
 import moa.core.Measurement;
-import moa.options.ClassOption;
-import com.yahoo.labs.samoa.instances.Instance;
 import moa.core.MiscUtils;
+import moa.options.ClassOption;
 
 /**
  * Creates two classifiers: a stable and a reactive. The first represents the
diff --git a/moa/src/main/java/moa/classifiers/meta/RandomRules.java b/moa/src/main/java/moa/classifiers/meta/RandomRules.java
index e170e1ef7..143849bdb 100644
--- a/moa/src/main/java/moa/classifiers/meta/RandomRules.java
+++ b/moa/src/main/java/moa/classifiers/meta/RandomRules.java
@@ -19,14 +19,12 @@
  */
 package moa.classifiers.meta;
 
-import moa.options.ClassOption;
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
@@ -35,6 +33,7 @@
 import moa.core.FastVector;
 import moa.core.Measurement;
 import moa.core.MiscUtils;
+import moa.options.ClassOption;
 import moa.streams.InstanceStream;
 
 
diff --git a/moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java b/moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java
index eac49168d..431348c5d 100644
--- a/moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java
+++ b/moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java
@@ -19,21 +19,23 @@
  */
 package moa.classifiers.meta;
 
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Attribute;
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
 import moa.core.Measurement;
 import moa.core.Utils;
 import moa.options.ClassOption;
-import com.yahoo.labs.samoa.instances.Attribute;
-import com.yahoo.labs.samoa.instances.DenseInstance;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Include labels of previous instances into the training data
diff --git a/moa/src/main/java/moa/classifiers/meta/WEKAClassifier.java b/moa/src/main/java/moa/classifiers/meta/WEKAClassifier.java
index d9ac321c8..b2595ff28 100644
--- a/moa/src/main/java/moa/classifiers/meta/WEKAClassifier.java
+++ b/moa/src/main/java/moa/classifiers/meta/WEKAClassifier.java
@@ -20,15 +20,15 @@
  */
 package moa.classifiers.meta;
 
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
+
 import moa.classifiers.AbstractClassifier;
 import moa.core.Measurement;
-import com.github.javacliparser.IntOption;
 import moa.options.WEKAClassOption;
 import weka.classifiers.Classifier;
 import weka.classifiers.UpdateableClassifier;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
 
 /**
  * Class for using a classifier from WEKA.
diff --git a/moa/src/main/java/moa/classifiers/meta/WeightedMajorityAlgorithm.java b/moa/src/main/java/moa/classifiers/meta/WeightedMajorityAlgorithm.java
index c08bdfe6a..8ee34158b 100644
--- a/moa/src/main/java/moa/classifiers/meta/WeightedMajorityAlgorithm.java
+++ b/moa/src/main/java/moa/classifiers/meta/WeightedMajorityAlgorithm.java
@@ -19,19 +19,20 @@
  */
 package moa.classifiers.meta;
 
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.ListOption;
+import com.github.javacliparser.Option;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
+import moa.core.Utils;
 import moa.options.ClassOption;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.ListOption;
-import com.github.javacliparser.Option;
 import moa.tasks.TaskMonitor;
-import com.yahoo.labs.samoa.instances.Instance;
-import moa.core.Utils;
 
 /**
  * Weighted majority algorithm for data streams.
@@ -196,9 +197,9 @@ public void discardModel(int index) {
         this.ensembleWeights = newEnsembleWeights;
     }
 
-    protected int removePoorestModelBytes() {
+    protected long removePoorestModelBytes() {
         int poorestIndex = Utils.minIndex(this.ensembleWeights);
-        int byteSize = this.ensemble[poorestIndex].measureByteSize();
+        long byteSize = this.ensemble[poorestIndex].measureByteSize();
         discardModel(poorestIndex);
         return byteSize;
     }
diff --git a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
index 7ac2b2825..6924b00e9 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/LocalMultiTargetClassifier.java
@@ -7,9 +7,9 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.AbstractMultiLabelLearner;
@@ -17,6 +17,7 @@
 import moa.classifiers.MultiLabelClassifier;
 import moa.classifiers.MultiTargetRegressor;
 import moa.core.Measurement;
+import moa.core.SizeOf;
 import moa.options.ClassOption;
 
 public class LocalMultiTargetClassifier extends AbstractMultiLabelLearner
@@ -36,6 +37,17 @@ public class LocalMultiTargetClassifier extends AbstractMultiLabelLearner
 	
 	ArrayList<Classifier> classifiers = null;
 	ArrayList<InstancesHeader> headers = null;
+
+	@Override
+	public long measureByteSize() {
+		long size = 0;
+		for (Classifier c : classifiers)
+			size += c.measureByteSize();
+		for (InstancesHeader h : headers) {
+			size += SizeOf.sizeOf(h);
+		}
+		return size;
+	}
 	
 	@Override
 	public boolean isRandomizable() {
@@ -60,6 +72,7 @@ private void makeHeaders() {
 				attributes.add(getModelContext().outputAttribute(target));
 				InstancesHeader STHeader = new InstancesHeader();
 				STHeader.setAttributes(attributes);
+				STHeader.setInstances(new ArrayList<Instance>()); 
 				STHeader.setClassIndex(getModelContext().numInputAttributes());
 				headers.add(STHeader);
 			}
@@ -77,9 +90,7 @@ private Instance getSTInstance(StructuredInstance inst, int target) {
 	}
 	
 	@Override
-	public void trainOnInstanceImpl(StructuredInstance instance) {
-		initializeClassifiers();
-		
+	public void trainOnInstanceImpl(StructuredInstance instance) {		
 		for (int j = 0; j < instance.numberOutputTargets(); j++) {
 			Instance STInst = getSTInstance(instance, j);
 			
@@ -89,8 +100,6 @@ public void trainOnInstanceImpl(StructuredInstance instance) {
 
 	@Override
 	public Prediction getPredictionForInstance(StructuredInstance inst) {
-		initializeClassifiers();
-
 		MultiLabelPrediction prediction = new MultiLabelPrediction(getModelContext().numOutputAttributes());
 		for (int j = 0; j < inst.numberOutputTargets(); j++) {
 			Instance STInst = getSTInstance(inst, j);
@@ -102,21 +111,22 @@ public Prediction getPredictionForInstance(StructuredInstance inst) {
 	@Override
 	public void resetLearningImpl() {
 		classifiers = null;
-
+	}
+	
+	public void modelContextSet() {
+		initializeClassifiers();
+		makeHeaders();
+		for (int i = 0; i < classifiers.size(); i++)
+			classifiers.get(i).setModelContext(getHeader(i));
 	}
 
 	public void initializeClassifiers() {
-		this.classifierRandom.setSeed(1234);
-		if (classifiers == null) {
-			makeHeaders();
-			classifiers = new ArrayList<Classifier>();
-			for (int i = 0; i < getModelContext().numOutputAttributes(); i++) {
-				Classifier learner = ((Classifier) getPreparedClassOption(this.classifierOption)).copy();
-				classifiers.add(learner);
-				learner.resetLearning();
-				((AbstractClassifier) learner).classifierRandom = this.classifierRandom;
-				learner.setModelContext(getHeader(i));
-			}
+		classifiers = new ArrayList<Classifier>();
+		for (int i = 0; i < getModelContext().numOutputAttributes(); i++) {
+			Classifier learner = ((Classifier) getPreparedClassOption(this.classifierOption)).copy();
+			classifiers.add(learner);
+			learner.resetLearning();
+			((AbstractClassifier) learner).classifierRandom = this.classifierRandom;
 		}
 	}
 	
diff --git a/moa/src/main/java/moa/classifiers/multilabel/MEKAClassifier.java b/moa/src/main/java/moa/classifiers/multilabel/MEKAClassifier.java
index 0544bdfb9..c7587552f 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/MEKAClassifier.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/MEKAClassifier.java
@@ -19,28 +19,20 @@
  */
 package moa.classifiers.multilabel;
 
-import java.util.Arrays;
 import java.io.Serializable;
-import moa.core.Measurement;
-import weka.classifiers.UpdateableClassifier;
-import moa.classifiers.AbstractClassifier;
-import moa.core.Measurement;
-import com.github.javacliparser.IntOption;
-import moa.options.WEKAClassOption;
-import weka.classifiers.Classifier;
-import weka.classifiers.UpdateableClassifier;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
 
-import com.yahoo.labs.samoa.instances.StructuredInstance;
+import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
-import moa.classifiers.MultiLabelLearner;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.classifiers.AbstractMultiLabelLearner;
 import moa.classifiers.MultiTargetRegressor;
-import moa.core.Example;
+import moa.core.Measurement;
+import moa.options.WEKAClassOption;
+import weka.classifiers.Classifier;
+import weka.classifiers.UpdateableClassifier;
 
 /**
  * Wrapper for MEKA classifiers. 
diff --git a/moa/src/main/java/moa/classifiers/multilabel/MajorityLabelset.java b/moa/src/main/java/moa/classifiers/multilabel/MajorityLabelset.java
index 135f8f88e..9ac0dd346 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/MajorityLabelset.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/MajorityLabelset.java
@@ -19,16 +19,15 @@
  */
 package moa.classifiers.multilabel;
 
-import java.util.Arrays;
 import java.util.HashMap;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import moa.core.Measurement;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.classifiers.AbstractMultiLabelLearner;
 import moa.classifiers.MultiTargetRegressor;
+import moa.core.Measurement;
 import moa.core.StringUtils;
 
 /**
diff --git a/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java b/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java
index 9a8bf0e96..43c0deffa 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/MultilabelHoeffdingTree.java
@@ -19,7 +19,6 @@
  */
 package moa.classifiers.multilabel;
 
-import moa.classifiers.trees.HoeffdingTreeClassifLeaves;
 import java.io.StringReader;
 import java.util.List;
 import moa.classifiers.Classifier;
@@ -47,7 +46,7 @@
  * 
  * 
  */ 
-public class MultilabelHoeffdingTree extends HoeffdingTreeClassifLeaves implements MultiLabelLearner, MultiTargetRegressor { 
+public class MultilabelHoeffdingTree extends HoeffdingTreeClassifLeaves implements MultiLabelLearner, MultiTargetRegressor, Classifier { 
 // Needs to use InfoGainSplitCriterionMultiLabel, since multilabel entropy is calculated in a different way 
 // Trains a mlinstance adding statistics of several class values and training node classifiers
 // Get votes from the classifier in the learning node of the tree
@@ -83,7 +82,7 @@ public MultilabelInactiveLearningNode(double[] initialClassObservations) {
 		public void learnFromInstance(Instance inst, HoeffdingTree ht) {
 			List<Integer> labels = ((MultilabelHoeffdingTree) ht).getRelevantLabels(inst);
 			for (int l : labels){
-				this.observedClassDistribution.addToValue( l, inst.weight());
+				this.observedClassDistribution.addToValue(l, inst.weight());
 			}
 		}
 	}
@@ -95,7 +94,7 @@ public class MultilabelLearningNodeClassifier extends LearningNodeClassifier {
 
 		public MultilabelLearningNodeClassifier(double[] initialClassObservations, Classifier cl, MultilabelHoeffdingTree ht ) {
 			super(initialClassObservations);
-		
+
 			if (cl== null) {
 				this.classifier = ((Classifier) getPreparedClassOption(ht.learnerOption)).copy();
 				this.classifier.resetLearning();
@@ -123,7 +122,7 @@ public Prediction getPredictionForInstance(Instance inst, HoeffdingTree ht) {
 		public void disableAttribute(int attIndex) {
 			// should not disable poor atts - they are used in NB calc
 		}
-		
+
 		public Classifier getClassifier() {
 			return this.classifier;
 		}
@@ -148,11 +147,9 @@ public void learnFromInstance(Instance inst, HoeffdingTree ht) {
 				}
 				for (int l : labels){
 					obs.observeAttributeClass(inst.valueInputAttribute(i), l, inst.weight());
-					//obs.observeAttributeClass(inst.value(instAttIndex), 0, inst.weight());
 				}
 			}
 		}
-	}
 
 		public void describeSubtree(HoeffdingTree ht, StringBuilder out,
 									int indent) {
@@ -186,8 +183,12 @@ public Prediction getPredictionForInstance(Example<Instance> example) {
 		return getPredictionForInstance((StructuredInstance)example.getData());
 	}
 
+	public Prediction getPredictionForInstance(StructuredInstance inst) {
+		return getPredictionForInstance((Instance) inst);
+	}
+	
 	@Override
-	public Prediction getPredictionForInstance(StructuredInstance inst){
+	public Prediction getPredictionForInstance(Instance inst){
 
 		if (this.treeRoot != null) {
 			FoundNode foundNode = this.treeRoot.filterInstanceToLeaf(inst, null, -1);
diff --git a/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelBSTree.java b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelBSTree.java
index 58fd92faa..6a23d619d 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelBSTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelBSTree.java
@@ -18,7 +18,7 @@ public class MultiLabelBSTree extends AbstractOptionHandler implements NumericSt
 	/**
 	 * 
 	 */
-	public IntOption maxNodesOption = new IntOption("maxNodesOption", 'z', "Maximum number of nodes", 50, 0, Integer.MAX_VALUE);
+	public IntOption maxNodesOption = new IntOption("maxNodesOption", 'z', "Maximum number of nodes", 2000, 0, Integer.MAX_VALUE);
 	protected int maxNodes;
 	protected int numNodes;
 
@@ -26,14 +26,25 @@ public class MultiLabelBSTree extends AbstractOptionHandler implements NumericSt
 
 	protected Node root = null;
 
-	protected DoubleVector [] leftStatistics;
-	protected DoubleVector [] rightStatistics;
+	protected DoubleVector[] leftStatistics;
+	protected DoubleVector[] rightStatistics;
 
+	public static double roundToSignificantFigures(double num, int n) {
+	    final double d = Math.ceil(Math.log10(num < 0 ? -num: num));
+	    final int power = n - (int) d;
+
+	    final double magnitude = Math.pow(10, power);
+	    final long shifted = (long) (num*magnitude);
+	    return shifted/magnitude;
+	}
+	
 	@Override
 	public void observeAttribute(double inputAttributeValue,
 			DoubleVector[] statistics) {
 		if (!Double.isNaN(inputAttributeValue))
 		{
+//			if ((long) inputAttributeValue != inputAttributeValue) 
+//				inputAttributeValue = roundToSignificantFigures(inputAttributeValue, 4);
 			if (this.root == null) {
 				this.root = new Node(inputAttributeValue, statistics);
 				maxNodes=maxNodesOption.getValue();
@@ -49,13 +60,13 @@ public void observeAttribute(double inputAttributeValue,
 	public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(
 			MultiLabelSplitCriterion criterion, DoubleVector[] preSplitStatistics, int inputAttributeIndex) {
 		// Initialize global variables
-		int numOutputs=preSplitStatistics.length;
-		leftStatistics=new DoubleVector[numOutputs];
-		rightStatistics=new DoubleVector[numOutputs];
+		int numOutputs = preSplitStatistics.length;
+		leftStatistics = new DoubleVector[numOutputs];
+		rightStatistics = new DoubleVector[numOutputs];
 		for (int i=0; i< numOutputs; i++)
 		{
-			leftStatistics[i]=new DoubleVector(new double [preSplitStatistics[i].numValues()]); //sets statistics to zeros
-			rightStatistics[i]=new DoubleVector(preSplitStatistics[i]);
+			leftStatistics[i] = new DoubleVector(new double [preSplitStatistics[i].numValues()]); //sets statistics to zeros
+			rightStatistics[i] = new DoubleVector(preSplitStatistics[i]);
 		}
 
 		return searchForBestSplitOption(this.root, null, criterion, preSplitStatistics, inputAttributeIndex);
@@ -70,34 +81,36 @@ protected AttributeExpansionSuggestion searchForBestSplitOption(Node currentNode
 		if (currentNode.left != null) {
 			currentBestOption = searchForBestSplitOption(currentNode.left, currentBestOption, criterion, preSplitStatistics, inputAttributeIndex);
 		}
+		
 		for (int i=0; i<leftStatistics.length; i++)
 		{
-			leftStatistics[i].addValues(currentNode.leftStatistics[i]);
-			rightStatistics[i].subtractValues(currentNode.leftStatistics[i]);
+			leftStatistics[i].addValues(currentNode.statistics[i]);
+			rightStatistics[i].subtractValues(currentNode.statistics[i]);
 		}
 
 		DoubleVector[][] postSplitDists = new DoubleVector [leftStatistics.length][2];
 		for (int i=0; i<leftStatistics.length; i++)
 		{
-			postSplitDists[i]= new DoubleVector[2];
-			postSplitDists[i][0]=leftStatistics[i];
-			postSplitDists[i][1]=rightStatistics[i];
+			postSplitDists[i] = new DoubleVector[2];
+			postSplitDists[i][0] = leftStatistics[i];
+			postSplitDists[i][1] = rightStatistics[i];
 		}
 
 		double merit = criterion.getMeritOfSplit(preSplitStatistics, postSplitDists);
 
 		if ((currentBestOption == null) || (merit > currentBestOption.merit)) {
-			currentBestOption= new AttributeExpansionSuggestion(new NumericRulePredicate(inputAttributeIndex, currentNode.cutPoint, true), Utils.copy(postSplitDists), merit);
+			currentBestOption = new AttributeExpansionSuggestion(new NumericRulePredicate(inputAttributeIndex, currentNode.cutPoint, true), Utils.copy(postSplitDists), merit);
 		}
 
 		if (currentNode.right != null) {
 			currentBestOption = searchForBestSplitOption(currentNode.right, currentBestOption, criterion, preSplitStatistics, inputAttributeIndex);
 		}
-		for (int i=0; i<leftStatistics.length; i++)
+		for (int i = 0; i < leftStatistics.length; i++)
 		{
-			leftStatistics[i].subtractValues(currentNode.leftStatistics[i]);
-			rightStatistics[i].addValues(currentNode.leftStatistics[i]);
+			leftStatistics[i].subtractValues(currentNode.statistics[i]);
+			rightStatistics[i].addValues(currentNode.statistics[i]);
 		}
+		
 		return currentBestOption;
 	}
 
@@ -130,8 +143,7 @@ protected class Node implements Serializable {
 		private double cutPoint;
 
 		// E-BST statistics
-		private DoubleVector [] leftStatistics;
-		private DoubleVector [] rightStatistics;
+		private DoubleVector[] statistics;
 
 		// Child nodes
 		private Node left;
@@ -139,31 +151,23 @@ protected class Node implements Serializable {
 
 		public Node(double inputAttributeValue, DoubleVector [] statistics) {
 			cutPoint = inputAttributeValue;
-			int numOutputAttributes=statistics.length;
-			leftStatistics=new DoubleVector[numOutputAttributes];
+			int numOutputAttributes = statistics.length;
+			this.statistics=new DoubleVector[numOutputAttributes];
 			for (int i=0; i<numOutputAttributes; i++)
 			{					
-				leftStatistics[i]=new DoubleVector(statistics[i]);
+				this.statistics[i]=new DoubleVector(statistics[i]);
 			}
-			//this.leftStatistics=statistics.clone();
-
-			this.rightStatistics=new DoubleVector[numOutputAttributes];
-			for (int i=0; i<numOutputAttributes; i++)
-				this.rightStatistics[i]= new DoubleVector();
 		}
 
 		/**
 		 * Updates tree with new observation
 		 */
 		public void observeAttribute(double inputAttributeValue, DoubleVector [] statistics) {
-			if (inputAttributeValue == this.cutPoint) {
-				for (int i=0; i<statistics.length; i++)
-					this.leftStatistics[i].addValues(statistics[i]);
+			if (inputAttributeValue <= this.cutPoint) {
+				for (int i=0; i < statistics.length; i++)
+					this.statistics[i].addValues(statistics[i]);
 			}
 			else if (inputAttributeValue < this.cutPoint) {
-				for (int i=0; i<statistics.length; i++)
-					this.leftStatistics[i].addValues(statistics[i]);
-				
 				if (this.left == null) {
 					if(numNodes<maxNodes){
 						this.left = new Node(inputAttributeValue, statistics);
@@ -174,8 +178,6 @@ else if (inputAttributeValue < this.cutPoint) {
 				}
 			}
 			else { 
-				for (int i=0; i<statistics.length; i++)
-					this.rightStatistics[i].addValues(statistics[i]);
 				if (this.right == null) {
 					if(numNodes<maxNodes){
 						this.right = new Node(inputAttributeValue, statistics);
diff --git a/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelBSTreePCT.java b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelBSTreePCT.java
new file mode 100644
index 000000000..94f016788
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelBSTreePCT.java
@@ -0,0 +1,270 @@
+package moa.classifiers.multilabel.core.attributeclassobservers;
+
+import java.io.Serializable;
+
+import com.github.javacliparser.IntOption;
+
+import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.classifiers.multilabel.core.splitcriteria.PCTWeightedICVarianceReduction;
+import moa.classifiers.rules.core.AttributeExpansionSuggestion;
+import moa.classifiers.rules.core.NumericRulePredicate;
+import moa.classifiers.rules.core.Utils;
+import moa.core.DoubleVector;
+import moa.core.ObjectRepository;
+import moa.options.AbstractOptionHandler;
+import moa.tasks.TaskMonitor;
+
+public class MultiLabelBSTreePCT extends AbstractOptionHandler implements NumericStatisticsObserver {
+
+	/**
+	 * 
+	 */
+	public IntOption maxNodesOption = new IntOption("maxNodesOption", 'z', "Maximum number of nodes", 2000, 0, Integer.MAX_VALUE);
+	protected int maxNodes;
+	protected int numNodes;
+
+	private static final long serialVersionUID = 1L;
+
+	protected Node root = null;
+
+	protected DoubleVector[] leftTargetStatistics;
+	protected DoubleVector[] rightTargetStatistics;
+
+	protected DoubleVector[] leftInputStatistics;
+	protected DoubleVector[] rightInputStatistics;
+
+	
+	public static double roundToSignificantFigures(double num, int n) {
+	    final double d = Math.ceil(Math.log10(num < 0 ? -num: num));
+	    final int power = n - (int) d;
+
+	    final double magnitude = Math.pow(10, power);
+	    final long shifted = (long) (num*magnitude);
+	    return shifted/magnitude;
+	}
+	
+	@Override
+	public void observeAttribute(double inputAttributeValue, DoubleVector[] statistics) {
+		// DON'T CALL THIS
+		if (!Double.isNaN(inputAttributeValue))
+		{
+//			if ((long) inputAttributeValue != inputAttributeValue) 
+////				inputAttributeValue = roundToSignificantFigures(inputAttributeValue, 4);
+//			if (this.root == null) {
+//				this.root = new Node(inputAttributeValue, statistics);
+//				maxNodes=maxNodesOption.getValue();
+//			} else {
+//				this.root.observeAttribute(inputAttributeValue, statistics);
+//			}
+		}
+
+	}
+
+	public void observeAttribute(double inputAttributeValue, DoubleVector[] targetStatistics, DoubleVector[] inputStatistics) {
+		// DON'T CALL THIS
+		if (!Double.isNaN(inputAttributeValue))
+		{
+//			if ((long) inputAttributeValue != inputAttributeValue) 
+////				inputAttributeValue = roundToSignificantFigures(inputAttributeValue, 4);
+			if (this.root == null) {
+				this.root = new Node(inputAttributeValue, targetStatistics, inputStatistics);
+				maxNodes=maxNodesOption.getValue();
+			} else {
+				this.root.observeAttribute(inputAttributeValue, targetStatistics, inputStatistics);
+			}
+		}
+
+	}
+
+
+	@Override
+	public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(
+			MultiLabelSplitCriterion criterion, DoubleVector[] preSplitStatistics, int inputAttributeIndex) {
+		// Initialize global variables
+//		int numOutputs = preSplitStatistics.length;
+//		leftStatistics = new DoubleVector[numOutputs];
+//		rightStatistics = new DoubleVector[numOutputs];
+//		for (int i=0; i< numOutputs; i++)
+//		{
+//			leftStatistics[i] = new DoubleVector(new double [preSplitStatistics[i].numValues()]); //sets statistics to zeros
+//			rightStatistics[i] = new DoubleVector(preSplitStatistics[i]);
+//		}
+
+//		return searchForBestSplitOption(this.root, null, criterion, preSplitStatistics, inputAttributeIndex);
+		return null;
+	}
+
+	public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(
+			MultiLabelSplitCriterion criterion, DoubleVector[] preSplitTargetStatistics, DoubleVector[] preSplitInputStatistics, int inputAttributeIndex) {
+		// Initialize global variables
+		int numOutputs = preSplitTargetStatistics.length;
+		int numInputs = preSplitInputStatistics.length;
+
+		leftTargetStatistics = new DoubleVector[numOutputs];
+		rightTargetStatistics = new DoubleVector[numOutputs];
+
+		leftInputStatistics = new DoubleVector[numInputs];
+		rightInputStatistics = new DoubleVector[numInputs];
+
+		for (int i=0; i< numOutputs; i++)
+		{
+			leftTargetStatistics[i] = new DoubleVector(new double [preSplitTargetStatistics[i].numValues()]); //sets statistics to zeros
+			rightTargetStatistics[i] = new DoubleVector(preSplitTargetStatistics[i]);
+		}
+		for (int i=0; i< numInputs; i++)
+		{
+			leftInputStatistics[i] = new DoubleVector(new double [preSplitInputStatistics[i].numValues()]); //sets statistics to zeros
+			rightInputStatistics[i] = new DoubleVector(preSplitInputStatistics[i]);
+		}
+
+		return searchForBestSplitOption(this.root, null, criterion, preSplitTargetStatistics, preSplitInputStatistics, inputAttributeIndex);
+	}
+
+	
+	protected AttributeExpansionSuggestion searchForBestSplitOption(Node currentNode, AttributeExpansionSuggestion currentBestOption,
+			MultiLabelSplitCriterion criterion, DoubleVector [] preSplitTargetStatistics, DoubleVector [] preSplitInputStatistics, int inputAttributeIndex) {
+		// Return null if the current node is null or we have finished looking through all the possible splits
+		if (currentNode == null) { // TODO: JD check || countRightTotal == 0.0
+			return currentBestOption;
+		}
+
+		if (currentNode.left != null) {
+			currentBestOption = searchForBestSplitOption(currentNode.left, currentBestOption, criterion, preSplitTargetStatistics, preSplitInputStatistics, inputAttributeIndex);
+		}
+		
+		for (int i=0; i<leftTargetStatistics.length; i++)
+		{
+			leftTargetStatistics[i].addValues(currentNode.targetStatistics[i]);
+			rightTargetStatistics[i].subtractValues(currentNode.targetStatistics[i]);
+		}
+
+		for (int i=0; i<leftInputStatistics.length; i++)
+		{
+			leftInputStatistics[i].addValues(currentNode.inputStatistics[i]);
+			rightInputStatistics[i].subtractValues(currentNode.inputStatistics[i]);
+		}
+
+		
+		DoubleVector[][] postSplitTargetDists = new DoubleVector [leftTargetStatistics.length + leftInputStatistics.length][2];
+		DoubleVector[][] postSplitInputDists = new DoubleVector [leftTargetStatistics.length + leftInputStatistics.length][2];
+		for (int i=0; i<leftTargetStatistics.length; i++)
+		{
+			postSplitTargetDists[i] = new DoubleVector[2];
+			postSplitTargetDists[i][0] = leftTargetStatistics[i];
+			postSplitTargetDists[i][1] = rightTargetStatistics[i];
+		}
+		for (int i=0; i<leftInputStatistics.length; i++)
+		{
+			postSplitInputDists[i] = new DoubleVector[2];
+			postSplitInputDists[i][0] = leftInputStatistics[i];
+			postSplitInputDists[i][1] = rightInputStatistics[i];
+		}
+
+
+		double merit = ((PCTWeightedICVarianceReduction) criterion).getMeritOfSplit(preSplitTargetStatistics, postSplitTargetDists, preSplitInputStatistics, postSplitInputDists);
+
+		if ((currentBestOption == null) || (merit > currentBestOption.merit)) {
+			currentBestOption = new AttributeExpansionSuggestion(new NumericRulePredicate(inputAttributeIndex, currentNode.cutPoint, true), Utils.copy(postSplitTargetDists), merit);
+		}
+
+		if (currentNode.right != null) {
+			currentBestOption = searchForBestSplitOption(currentNode.right, currentBestOption, criterion, preSplitTargetStatistics, preSplitInputStatistics, inputAttributeIndex);
+		}
+		for (int i = 0; i < leftTargetStatistics.length; i++) {
+			leftTargetStatistics[i].subtractValues(currentNode.targetStatistics[i]);
+			rightTargetStatistics[i].addValues(currentNode.targetStatistics[i]);
+		}
+		for (int i = 0; i < leftInputStatistics.length; i++) {
+			leftInputStatistics[i].subtractValues(currentNode.inputStatistics[i]);
+			rightInputStatistics[i].addValues(currentNode.inputStatistics[i]);
+		}
+		
+		return currentBestOption;
+	}
+
+
+
+
+	@Override
+	public String getPurposeString() {
+		return "Stores statistics for all output and input attributes for a giver input attribute.";
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {	
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor,
+			ObjectRepository repository) {
+
+	}
+
+
+	//Inner classes inspired in FIMTDDNumericalAttributeClassObserver
+
+	protected class Node implements Serializable {
+
+		private static final long serialVersionUID = 1L;
+
+		// The split point to use
+		private double cutPoint;
+
+		// E-BST statistics
+		private DoubleVector[] targetStatistics;
+		private DoubleVector[] inputStatistics;
+		
+
+		// Child nodes
+		private Node left;
+		private Node right;
+
+		public Node(double inputAttributeValue, DoubleVector[] targetStatistics, DoubleVector[] inputStatistics) {
+			cutPoint = inputAttributeValue;
+			int numOutputAttributes = targetStatistics.length;
+			int numInputAttributes = inputStatistics.length;
+			this.targetStatistics = new DoubleVector[numOutputAttributes];
+			this.inputStatistics = new DoubleVector[numInputAttributes];
+			for (int i=0; i<numOutputAttributes; i++) {					
+				this.targetStatistics[i]=new DoubleVector(targetStatistics[i]);
+			}
+			for (int i=0; i<numInputAttributes; i++) {					
+				this.inputStatistics[i]=new DoubleVector(inputStatistics[i]);
+			}
+		}
+
+		/**
+		 * Updates tree with new observation
+		 */
+		public void observeAttribute(double inputAttributeValue, DoubleVector[]targetStatistics, DoubleVector[] inputStatistics) {
+			if (inputAttributeValue <= this.cutPoint) {
+				for (int i=0; i < targetStatistics.length; i++)
+					this.targetStatistics[i].addValues(targetStatistics[i]);
+				for (int i=0; i < inputStatistics.length; i++)
+					this.inputStatistics[i].addValues(inputStatistics[i]);
+			}
+			else if (inputAttributeValue < this.cutPoint) {
+				if (this.left == null) {
+					if (numNodes<maxNodes) {
+						this.left = new Node(inputAttributeValue, targetStatistics, inputStatistics);
+						++numNodes;
+					}
+				} else {
+					this.left.observeAttribute(inputAttributeValue, targetStatistics, inputStatistics);
+				}
+			}
+			else { 
+				if (this.right == null) {
+					if(numNodes<maxNodes){
+						this.right = new Node(inputAttributeValue, targetStatistics, inputStatistics);
+						++numNodes;
+					}
+				} else {
+					this.right.observeAttribute(inputAttributeValue, targetStatistics, inputStatistics);
+				}
+			}
+		}
+	}
+
+
+}
diff --git a/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelNominalAttributeObserver.java b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelNominalAttributeObserver.java
index 2495b158f..bba7cbd0d 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelNominalAttributeObserver.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/attributeclassobservers/MultiLabelNominalAttributeObserver.java
@@ -4,6 +4,8 @@
 import java.util.Iterator;
 import java.util.Map.Entry;
 
+import com.github.javacliparser.FlagOption;
+
 import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.rules.core.AttributeExpansionSuggestion;
 import moa.classifiers.rules.core.NominalRulePredicate;
@@ -13,8 +15,6 @@
 import moa.options.AbstractOptionHandler;
 import moa.tasks.TaskMonitor;
 
-import com.github.javacliparser.FlagOption;
-
 public class MultiLabelNominalAttributeObserver extends AbstractOptionHandler
 		implements NominalStatisticsObserver {
 
diff --git a/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java b/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java
index 24f9839b0..da15f568f 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/ICVarianceReduction.java
@@ -31,14 +31,14 @@ public double[] getBranchSplitVarianceOutput(DoubleVector[] postSplitDists) {
 
 	}
 	
-	private double computeVariance(double n, double sum, double squares) {
+	public double computeVariance(double n, double sum, double squares) {
 		if (n > 1) {
 			return (squares - sum * sum / n) / (n - 1);
 		}
 		return 0;
 	}
 	
-	private double computeVariance(DoubleVector v) {
+	public double computeVariance(DoubleVector v) {
 		return computeVariance(v.getValue(0), v.getValue(1), v.getValue(2));
 	}
 
@@ -62,10 +62,10 @@ private double computeVariance(DoubleVector v) {
 	}
 	
 	protected double getMeritOfSplitForOutput(DoubleVector[] preSplitDist, DoubleVector[][] postSplitDists, int outputAttributeIndex){
-		return getMeritOfSplitForOutput(preSplitDist[outputAttributeIndex],postSplitDists[outputAttributeIndex]);
+		return getMeritOfSplitForAttribute(preSplitDist[outputAttributeIndex],postSplitDists[outputAttributeIndex]);
 	}
 
-	protected double getMeritOfSplitForOutput(DoubleVector preSplitDist, DoubleVector[] postSplitDists) {
+	protected double getMeritOfSplitForAttribute(DoubleVector preSplitDist, DoubleVector[] postSplitDists) {
 		double merit=0;
 		//count number of branches with weightSeen higher than threshold
 		int count = 0; 
diff --git a/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/PCTWeightedICVarianceReduction.java b/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/PCTWeightedICVarianceReduction.java
new file mode 100644
index 000000000..adb022397
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/multilabel/core/splitcriteria/PCTWeightedICVarianceReduction.java
@@ -0,0 +1,76 @@
+package moa.classifiers.multilabel.core.splitcriteria;
+
+import moa.core.DoubleVector;
+
+public class PCTWeightedICVarianceReduction extends WeightedICVarianceReduction {
+
+	public DoubleVector inputWeights;
+	
+	public double targetInputTradeoff; // \in [0, 1]
+	
+	public PCTWeightedICVarianceReduction(DoubleVector targetWeights, DoubleVector inputWeights, double targetInputTradeoff) {
+		super(targetWeights);
+		this.inputWeights = inputWeights;
+		this.targetInputTradeoff = targetInputTradeoff;
+	}
+	
+	public double getMeritOfSplit(DoubleVector[] preSplitTargetDist, DoubleVector[][] postSplitTargetDists, DoubleVector[] preSplitInputDist, DoubleVector[][] postSplitInputDists) {
+		double targetError = 0;
+		double inputError = 0;
+		int numTargets=preSplitTargetDist.length;
+		int numInputs=preSplitInputDist.length;
+		for (int i=0; i<numTargets; i++)
+			targetError += weights.getValue(i) * getMeritOfSplitForAttribute(preSplitTargetDist[i],postSplitTargetDists[i]);
+		for (int i=0; i<numInputs; i++)
+			targetError += inputWeights.getValue(i) * getMeritOfSplitForAttribute(preSplitInputDist[i],postSplitInputDists[i]);
+
+		
+		return targetInputTradeoff * targetError / weights.sumOfValues() + (1 - targetInputTradeoff) * inputError / inputWeights.sumOfValues();
+	}
+
+	protected double getMeritOfSplitForAttribute(DoubleVector preSplitDist, DoubleVector[] postSplitDists) {
+		double merit=0;
+		//count number of branches with weightSeen higher than threshold
+		int count = 0; 
+		for(int i = 0; i < postSplitDists.length; i++)
+			if(postSplitDists[i].getValue(0) >= 0.05*preSplitDist.getValue(0))
+				count = count +1;
+		//Consider split if all branches have required weight seen
+		if(count == postSplitDists.length){
+			double varPreSplit=computeVariance(preSplitDist);
+			double sumVarPostSplit=0;
+			double weightTotal=0;
+			for (int i=0; i<postSplitDists.length;i++){
+				weightTotal+=postSplitDists[i].getValue(0);
+			}
+			double [] variances=getBranchSplitVarianceOutput(postSplitDists);
+			for(int i = 0; i < variances.length; i++)
+				if(postSplitDists[i].getValue(0)>0)
+					sumVarPostSplit+=(postSplitDists[i].getValue(0)/weightTotal*variances[i]);  //weight variance
+			merit= 1 - sumVarPostSplit / varPreSplit;
+		}
+		/*if(merit<0 || merit>1)
+			System.out.println("out of range");*/
+		return merit;
+	}
+	
+
+//	private double computeVariance(double n, double sum, double squares) {
+//		if (n > 1) {
+//			return (squares - sum * sum / n) / (n - 1);
+//		}
+//		return 0;
+//	}
+	
+//	private double computeVariance(DoubleVector v) {
+//		return computeVariance(v.getValue(0), v.getValue(1), v.getValue(2));
+//	}
+	
+	public double getMeritOfSplit(DoubleVector[] preSplitTargetDist, DoubleVector[] preSplitInputDist, DoubleVector[][] postSplitTargetDists, DoubleVector[][] postSplitInputDists) {
+		double error=0;
+		int numOutputs=preSplitTargetDist.length;
+		for (int i=0; i<numOutputs; i++)
+			error += weights.getValue(i) * getMeritOfSplitForOutput(preSplitTargetDist,postSplitTargetDists,i);
+		return error / weights.sumOfValues();
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java b/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
index b4675887f..1f42cb747 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/meta/MTOzaBag.java
@@ -19,11 +19,10 @@
  */
 package moa.classifiers.multilabel.meta;
 
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.classifiers.Classifier;
 import moa.classifiers.MultiLabelLearner;
@@ -51,18 +50,25 @@ public MTOzaBag() {
     	this.baseLearnerOption = new ClassOption("baseLearner", 'l',
                 "Classifier to train.", MultiLabelLearner.class, "multilabel.trees.ISOUPTree");
     	}
-	
-    @Override
+
+	@Override
     public void resetLearningImpl() {
         this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
         MultiLabelLearner baseLearner = (MultiLabelLearner) getPreparedClassOption(this.baseLearnerOption);
-        baseLearner.setModelContext(this.modelContext);
         for (int i = 0; i < this.ensemble.length; i++) {
             this.ensemble[i] = baseLearner.copy();
             this.ensemble[i].resetLearning();
+            this.ensemble[i].setRandomSeed(this.randomSeed + i * 100);
         }
     }
 
+    
+    @Override    
+    public void modelContextSet() {
+        for (int i = 0; i < this.ensemble.length; i++) {
+            this.ensemble[i].setModelContext(this.getModelContext());;
+        }
+    }
     @Override // @note don't need this here
     public boolean isRandomizable() {
         return true;
diff --git a/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagAdwinML.java b/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagAdwinML.java
index a94b89b6f..4ce25720a 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagAdwinML.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagAdwinML.java
@@ -18,21 +18,17 @@
  */
 package moa.classifiers.multilabel.meta;
 
-import moa.classifiers.Classifier;
-import moa.classifiers.core.driftdetection.ADWIN;
-import moa.classifiers.meta.OzaBagAdwin;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import moa.core.InstanceExample;
-import moa.core.MiscUtils;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.classifiers.MultiLabelLearner;
 import moa.classifiers.MultiTargetRegressor;
+import moa.classifiers.core.driftdetection.ADWIN;
+import moa.classifiers.meta.OzaBagAdwin;
 import moa.core.Example;
-import meka.core.Metrics;
-import meka.core.A;
+import moa.core.InstanceExample;
+import moa.core.MiscUtils;
 
 /**
  * OzaBagAdwinML: Changes the way to compute accuracy as an input for Adwin
@@ -45,44 +41,93 @@ public class OzaBagAdwinML extends OzaBagAdwin implements MultiLabelLearner, Mul
     @Override
     public void trainOnInstanceImpl(Instance inst) {
 		// train
-		try {
-			super.trainOnInstanceImpl(inst);
-		} catch(NullPointerException e) {
-			System.err.println("[Warning] NullPointer on train.");
-			//e.printStackTrace();
-		}
-
-		for (int i = 0; i < this.ensemble.length; i++) {
+        boolean Change = false;
+        for (int i = 0; i < this.ensemble.length; i++) {
+            int k = MiscUtils.poisson(1.0, this.classifierRandom);
+            if (k > 0) {
+                Instance weightedInst = (Instance) inst.copy();
+                weightedInst.setWeight(inst.weight() * k);
+                this.ensemble[i].trainOnInstance(weightedInst);
+            }
 
 			// get prediction
-			double prediction[] = this.ensemble[i].getVotesForInstance(inst);
-			if (prediction == null) {
-				prediction = new double[]{};
+			Prediction P = this.ensemble[i].getPredictionForInstance(inst);
+			if (P == null) {
+				continue; // TODO what to do here?
 			}
 
-			// get true value
-			double actual[] = new double[prediction.length];
-			for (int j = 0; j < prediction.length; j++) {
-				actual[j] = (double)inst.classValue(j);
+			// get true value and prediction arrays
+			double actual[] = new double[inst.numOutputAttributes()];
+			double prediction[] = new double[inst.numOutputAttributes()];
+			for (int j = 0; j < inst.numOutputAttributes(); j++) {
+				actual[j] = (double)inst.valueOutputAttribute(j);
+				prediction[j] = P.getVote(j, 1);
 			}
 
 			// compute loss
-			double loss = Metrics.L_ZeroOne(A.toIntArray(actual,0.5), A.toIntArray(prediction,0.5));
+			//double loss = Metrics.L_ZeroOne(A.toIntArray(actual,0.5), A.toIntArray(prediction,0.5));
 			//System.err.println("loss["+i+"] = "+loss);
 
+			int p_sum = 0, r_sum = 0;
+			int set_union = 0;
+			int set_inter = 0;
+			double t = 0.01;
+			for(int j = 0; j < prediction.length; j++) {
+				int p = (prediction[j] >= t) ? 1 : 0;
+				int R = (int) actual[j];
+				if (p==1) {
+					p_sum++;
+					// predt 1, real 1
+					if(R==1) {
+						set_inter++;
+						set_union++;
+					}
+					// predt 1, real 0
+					else {
+						set_union++;
+					}
+				}
+				else {                      
+					// predt 0, real 1
+					if(R==1) { 
+						set_union++;
+					}
+					// predt 0, real 0
+					else {   
+					}
+				}
+			}
+			double accuracy = 0.0;
+			if(set_union > 0)	//avoid NaN
+				accuracy = ((double)set_inter / (double)set_union);
+			
 			// adwin stuff
 			double ErrEstim = this.ADError[i].getEstimation();
-			if (this.ADError[i].setInput(loss)) {
+			
+			if (this.ADError[i].setInput(1-accuracy)) {
 				if (this.ADError[i].getEstimation() > ErrEstim) {
-					System.err.println("Change model "+i+"!");
-					this.ensemble[i].resetLearning();
-					this.ensemble[i].trainOnInstance(inst);
-					this.ADError[i] = new ADWIN();
+				Change = true;
 				}
 			}
 		}
+        
+        if (Change) {
+			double max=0.0; int imax=-1;
+			for (int i = 0; i < this.ensemble.length; i++) {
+				if (max<this.ADError[i].getEstimation()) {
+					max=this.ADError[i].getEstimation();
+					imax=i;
+				}
+			}
+			if (imax!=-1) {
+				 
+				this.ensemble[imax].resetLearning();
+				this.ensemble[imax].trainOnInstance(inst);
+				this.ADError[imax]=new ADWIN();
+			}
+        }
 	}
-
+    
 	@Override
 	public void trainOnInstanceImpl(StructuredInstance instance) {
 		trainOnInstanceImpl((Instance) instance);
diff --git a/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagML.java b/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagML.java
index 20acefa4e..9a44b2e9f 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagML.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/meta/OzaBagML.java
@@ -18,20 +18,17 @@
  */
 package moa.classifiers.multilabel.meta;
 
-import moa.classifiers.Classifier;
-import moa.classifiers.meta.OzaBag;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
+import moa.classifiers.Classifier;
 import moa.classifiers.MultiLabelLearner;
 import moa.classifiers.MultiTargetRegressor;
-import moa.core.InstanceExample;
-import moa.core.MiscUtils;
+import moa.classifiers.meta.OzaBag;
 import moa.core.Example;
-
-import java.util.Arrays;
+import moa.core.InstanceExample;
 
 /**
  * OzaBag for Multi-label data.
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java
index da8fdadd3..a5ac4c6a9 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPOptionTree.java
@@ -10,21 +10,13 @@
 import com.github.javacliparser.MultiChoiceOption;
 import com.yahoo.labs.samoa.instances.StructuredInstance;
 
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.multilabel.core.attributeclassobservers.AttributeStatisticsObserver;
-import moa.classifiers.multilabel.core.splitcriteria.ICVarianceReduction;
 import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.multilabel.core.splitcriteria.WeightedICVarianceReduction;
-import moa.classifiers.multilabel.trees.ISOUPTree.LeafNode;
-import moa.classifiers.multilabel.trees.ISOUPTree.MultitargetPerceptron;
-import moa.classifiers.multilabel.trees.ISOUPTree.Node;
-import moa.classifiers.multilabel.trees.ISOUPTree.SplitNode;
 import moa.classifiers.rules.core.AttributeExpansionSuggestion;
-import moa.classifiers.trees.FIMTDD.InnerNode;
-import moa.classifiers.trees.ORTO.OptionNode;
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
+import moa.core.SizeOf;
 import moa.core.StringUtils;
 
 public class ISOUPOptionTree extends ISOUPTree {
@@ -41,13 +33,13 @@ public class ISOUPOptionTree extends ISOUPTree {
 			"maxTrees",
 			'm',
 			"The maximum number of trees contained in the option tree.",
-			10, 1, Integer.MAX_VALUE);
+			125, 1, Integer.MAX_VALUE);
 
 	public IntOption maxOptionLevelOption = new IntOption(
 			"maxOptionLevel",
 			'x',
 			"The maximal depth at which option nodes can be created.",
-			10, 0, Integer.MAX_VALUE);
+			3, 0, Integer.MAX_VALUE);
 
 	public FloatOption optionDecayFactorOption = new FloatOption(
 			"optionDecayFactor",
@@ -83,6 +75,12 @@ public static class OptionNode extends InnerNode {
 		public OptionNode(ISOUPTree tree) {
 			super(tree);
 		}
+		
+		public long calcByteSize() {
+			long size = super.calcByteSize();
+			size += SizeOf.fullSizeOf(optionFFSSL) + SizeOf.fullSizeOf(optionFFSeen); 
+			return size;
+		}
 
 		public void resetFF() {
 			optionFFSSL = new AutoExpandVector<DoubleVector>();
@@ -293,24 +291,21 @@ public void processInstanceOptionNode(StructuredInstance inst, OptionNode node,
 		//			}
 		//		}
 
+		double[][] childPredictions = new double[node.numChildren()][];
 		for (Node child : node.children) {
 			int i = node.getChildIndex(child);
-			double[] childPrediction = child.getPrediction(inst);
+			childPredictions[i] = child.getPrediction(inst);
 			for (int j = 0; j < getModelContext().numOutputAttributes(); j++)  {
 				node.optionFFSeen.get(i).setValue(j, node.optionFFSeen.get(i).getValue(j) * optionFadingFactorOption.getValue() + 1);
-				node.optionFFSSL.get(i).setValue(j, node.optionFFSSL.get(i).getValue(j) * optionFadingFactorOption.getValue() + Math.pow(childPrediction[j] - inst.valueOutputAttribute(j), 2));
+				node.optionFFSSL.get(i).setValue(j, node.optionFFSSL.get(i).getValue(j) * optionFadingFactorOption.getValue() + (childPredictions[i][j] - inst.valueOutputAttribute(j)) * (childPredictions[i][j] - inst.valueOutputAttribute(j)));
 			}
-		}
-
-		for (Node child : node.children) {
-			processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed && node.alternateTree == null, inAlternate);
+			processInstance(inst, child, childPredictions[node.getChildIndex(child)], normalError, growthAllowed && node.alternateTree == null, inAlternate);
 		}
 	}
 
 	//endregion ================ METHODS ================
 
 	protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex) {
-		//System.out.println("Evaluating splits");
 		//System.out.println(examplesSeen);
 		// Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
 		MultiLabelSplitCriterion splitCriterion = new WeightedICVarianceReduction(targetWeights);
@@ -364,28 +359,30 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 				numSplits = 1;
 				acceptedSplits.add(bestSuggestion);
 			}
-			else {
-				// If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
-				// TODO pruning is currently disabled
-				for (int i = 0; i < node.attributeObservers.size(); i++) {
-					AttributeStatisticsObserver obs = node.attributeObservers.get(i);
-					if (obs != null) {
-						if (getModelContext().attribute(i).isNumeric());
-						//TODO obs.removeBadSplits(null, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound, getModelContext().numOutputAttributes());
-						if (getModelContext().attribute(i).isNominal());
-						// TODO nominal class observers
-					}
-				}
-			}
+//			else {
+//				// If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
+//				// TODO pruning is currently disabled
+////				for (int i = 0; i < node.attributeObservers.size(); i++) {
+////					AttributeStatisticsObserver obs = node.attributeObservers.get(i);
+////					if (obs != null) {
+////						if (getModelContext().attribute(i).isNumeric());
+////						//TODO obs.removeBadSplits(null, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound, getModelContext().numOutputAttributes());
+////						if (getModelContext().attribute(i).isNominal());
+////						// TODO nominal class observers
+////					}
+////				}
+//			}
 		}
 
+		//System.out.println("Found " + numSplits + " candidates.");
+		
 		// If the splitting criterion were met, split the current node using the chosen attribute test, and
 		// make two new branches leading to (empty) leaves
 		if (numSplits > 0) {
 			double optionFactor = numSplits * Math.pow(optionDecayFactorOption.getValue(), (double) node.getLevel());
 			log(Integer.toString(node.ID) + ',' + Integer.toString((int) this.examplesSeen));
 
-			if (numSplits == 1 || optionFactor < 2.0 || maxTreesOption.getValue() - numTrees <= 1) {
+			if (numSplits == 1) {
 				AttributeExpansionSuggestion splitDecision = acceptedSplits.get(0);
 				SplitNode newSplit = newSplitNode(splitDecision.getPredicate());
 				newSplit.ID = node.ID;
@@ -406,7 +403,7 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 					parent.setChild(parentIndex, newSplit);
 					newSplit.setParent(parent);
 				}
-			} else {
+			} else if (optionFactor >= 2.0 || maxTreesOption.getValue() - numTrees > 1) {
 
 				OptionNode optionNode = newOptionNode();
 				optionNode.ID = node.ID;
@@ -415,7 +412,7 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 				int j = 0;
 
 				for (AttributeExpansionSuggestion splitDecision : acceptedSplits) {
-					if (j > optionFactor || maxTreesOption.getValue() - numTrees <= 0) {
+					if (j > optionFactor || maxTreesOption.getValue() - numTrees <= 0 || j > 4) {
 						break;
 					}
 					SplitNode newSplit = newSplitNode(splitDecision.getPredicate());
@@ -447,6 +444,7 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 				optionNode.resetFF();
 			}
 		}
+		//System.out.println("Splits finished...");
 	}
 
 	// region --- Option tree methods
@@ -522,4 +520,4 @@ protected void removeExcessTrees() {
 		}
 	}
 
-}
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
index 28b52d3b9..3829f21bb 100644
--- a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
+++ b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTree.java
@@ -26,6 +26,11 @@
 package moa.classifiers.multilabel.trees;
 
 
+import java.io.BufferedWriter;
+import java.io.FileWriter;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Paths;
 import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
@@ -36,21 +41,21 @@
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.AbstractMOAObject;
 import moa.classifiers.AbstractMultiLabelLearner;
 import moa.classifiers.MultiTargetRegressor;
 import moa.classifiers.multilabel.core.attributeclassobservers.AttributeStatisticsObserver;
 import moa.classifiers.multilabel.core.attributeclassobservers.MultiLabelBSTree;
+import moa.classifiers.multilabel.core.attributeclassobservers.MultiLabelBSTreePCT;
 import moa.classifiers.multilabel.core.attributeclassobservers.MultiLabelNominalAttributeObserver;
 import moa.classifiers.multilabel.core.attributeclassobservers.NominalStatisticsObserver;
 import moa.classifiers.multilabel.core.attributeclassobservers.NumericStatisticsObserver;
-import moa.classifiers.multilabel.core.splitcriteria.ICVarianceReduction;
 import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.classifiers.multilabel.core.splitcriteria.PCTWeightedICVarianceReduction;
 import moa.classifiers.multilabel.core.splitcriteria.WeightedICVarianceReduction;
 import moa.classifiers.rules.core.AttributeExpansionSuggestion;
 import moa.classifiers.rules.core.Predicate;
@@ -79,7 +84,12 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 	private DoubleVector sumOfAttrValues = new DoubleVector();
 	private DoubleVector sumOfAttrSquares = new DoubleVector();
 
+	private int numInputAttributes;
+	private int numOutputAttributes;
+
 	public int maxID = 0;
+
+	private BufferedWriter writer;
 	
 	public DoubleVector targetWeights;
 
@@ -155,16 +165,17 @@ public class ISOUPTree extends AbstractMultiLabelLearner implements MultiTargetR
 			'o',
 			"Keep learning rate constant instead of decaying (if kept constant learning ratio is suggested to be 0.001).");
 
+	public FlagOption runAsPCTOption = new FlagOption(
+			"runAsPCT",
+			'p',
+			"Run as a predictive clustering tree, i.e., use input attributes in heuristic calculation.");
+
+
 	public FlagOption doNotNormalizeOption = new FlagOption(
 			"doNotNormalize",
 			'n',
 			"Don't normalize.");
 
-	public FlagOption randomForestBaseModelOption = new FlagOption(
-			"randomForestBaseModel",
-			'z',
-			"Use the learner as a base model in a random forest.");
-	
 	public FileOption weightFile = new FileOption("targetWeightFile", 'w', "File with the weights of the targets.", null, null, false);
 
 	//endregion ================ OPTIONS ================
@@ -187,7 +198,6 @@ public abstract static class Node extends AbstractMOAObject {
 		protected Node alternateTree;
 		protected Node originalNode;
 
-		protected AutoExpandVector<AttributeStatisticsObserver> attributeObservers = new AutoExpandVector<AttributeStatisticsObserver>();
 
 		// The error values for the Page Hinckley test
 		// PHmT = the cumulative sum of the errors
@@ -202,6 +212,12 @@ public abstract static class Node extends AbstractMOAObject {
 		// Sum of squared y values
 		protected DoubleVector sumOfSquares = new DoubleVector();
 
+		// Sum of y values
+		protected DoubleVector sumOfInputValues;
+		// Sum of squared y values
+		protected DoubleVector sumOfInputSquares;
+
+
 		public Node(ISOUPTree tree) {
 			this.tree = tree;
 			this.ID = tree.maxID;
@@ -211,10 +227,18 @@ public void copyStatistics(Node node) {
 			examplesSeen = node.examplesSeen;
 			sumOfValues = (DoubleVector) node.sumOfValues.copy();
 			sumOfSquares = (DoubleVector) node.sumOfSquares.copy();
+			if (tree.runAsPCTOption.isSet()) {
+				sumOfInputValues = (DoubleVector) node.sumOfInputValues.copy();
+				sumOfInputSquares = (DoubleVector) node.sumOfInputSquares.copy();
+			}
 		}
 
-		public int calcByteSize() {
-			return (int) SizeOf.fullSizeOf(this);
+		public long calcByteSize() {
+			long size = SizeOf.sizeOf(this) + SizeOf.sizeOf(sumOfSquares) + SizeOf.sizeOf(sumOfValues);
+			if (tree.runAsPCTOption.isSet()) {
+				size += SizeOf.sizeOf(sumOfInputSquares) + SizeOf.sizeOf(sumOfInputValues);
+			}
+			return size;
 		}
 
 		/**
@@ -244,7 +268,7 @@ public void getDescription(StringBuilder sb, int i) {}
 		public double[] getPrediction(StructuredInstance inst) {
 			return null;
 		}
-		
+
 		public void describeSubtree(StringBuilder out, int indent) {
 			StringUtils.appendIndented(out, indent, "Leaf");
 		}
@@ -292,11 +316,13 @@ public static class LeafNode extends Node {
 
 		public DoubleVector errorP = new DoubleVector();
 		public DoubleVector errorM = new DoubleVector();
-		
+
 		public List<Integer> inputIndexes = null;
 
 		protected double examplesSeenAtLastSplitEvaluation = 0;
 
+		protected AutoExpandVector<AttributeStatisticsObserver> attributeObservers = new AutoExpandVector<AttributeStatisticsObserver>();
+
 		/**
 		 * Create a new LeafNode
 		 */
@@ -309,28 +335,28 @@ public LeafNode(ISOUPTree tree) {
 			examplesSeen = 0;
 			sumOfValues = new DoubleVector();
 			sumOfSquares = new DoubleVector();
+			if (tree.runAsPCTOption.isSet()) {
+				sumOfInputValues = new DoubleVector();
+				sumOfInputSquares = new DoubleVector();
+			}
 		}
 
-		public void initializeInputIndexes() {
-			List<Integer> indexes = new Vector<Integer>();
-			int numAttrs = tree.getModelContext().numInputAttributes();
-			for (int i = 0; i < numAttrs; i++) {
-				indexes.add(i, i);
-			}
-			if (tree.buildingRandomForestTree()) {
-				// Select the first sqrt(n) attribute indexes
-				for (int i = 0; i < Math.ceil(Math.sqrt(numAttrs)); i++) {
-					int swap = i + tree.classifierRandom.nextInt(numAttrs - i);
-					int temp = indexes.get(i);
-					indexes.set(i, indexes.get(swap));
-					indexes.set(swap, temp);
-				}
-				inputIndexes = indexes.subList(0, (int) Math.ceil(Math.sqrt(numAttrs)));
-			} else {
-				inputIndexes = indexes;
+		public long calcByteSize() {
+			long size = super.calcByteSize();
+			if (tree.buildingModelTree()) {
+				size += learningModel.calcByteSize();
+				size += SizeOf.sizeOf(errorP);
+				size += SizeOf.sizeOf(errorM);
 			}
+			size += SizeOf.sizeOf(inputIndexes);
+			size += SizeOf.fullSizeOf(attributeObservers);
+			return size;
+		}
+
+		public void initializeInputIndexes() {
+			this.inputIndexes = tree.newInputIndexes();
 		}
-		
+
 		/**
 		 * Method to learn from an instance that passes the new instance to the perceptron learner,
 		 * and also prevents the class value from being truncated to an int when it is passed to the
@@ -338,28 +364,75 @@ public void initializeInputIndexes() {
 		 */
 		public void learnFromInstance(StructuredInstance inst, double[] prediction, boolean growthAllowed) {
 			// Update the statistics for this node
+			double weight = inst.weight();
 
 			double[] predictionP = tree.buildingModelTree() ? getPredictionModel(inst) : null;
 			double[] predictionM = getPredictionTargetMean(inst);
 
 			// number of instances passing through the node
-			examplesSeen += inst.weight();
+			examplesSeen += weight;
 
-			for (int i = 0; i < tree.getModelContext().numOutputAttributes(); i++) {
-				// sum of y values
-				sumOfValues.addToValue(i, inst.weight() * inst.valueOutputAttribute(i));
+			for (int i = 0; i < tree.numOutputAttributes; i++) {
+				if (!inst.isOutputMissing(i)) {
+					double outVal = inst.valueOutputAttribute(i);
+					// sum of y values
+					sumOfValues.addToValue(i, weight * outVal);
 
-				// sum of squared y values
-				sumOfSquares.addToValue(i, inst.weight() * inst.valueOutputAttribute(i) * inst.valueOutputAttribute(i));
+					// sum of squared y values
+					sumOfSquares.addToValue(i, weight * outVal * outVal);
 
-				if (tree.buildingModelTree()) {
-					errorP.setValue(i, errorP.getValue(i) * 0.95 + Math.abs(predictionP[i] - inst.valueOutputAttribute(i)));
-					errorM.setValue(i, errorM.getValue(i) * 0.95 + Math.abs(predictionM[i] - inst.valueOutputAttribute(i)));
+					if (tree.buildingModelTree()) {
+						errorP.setValue(i, errorP.getValue(i) * 0.95 + Math.abs(predictionP[i] - outVal));
+						errorM.setValue(i, errorM.getValue(i) * 0.95 + Math.abs(predictionM[i] - outVal));
+					}
 				}
 			}
 
+			if (tree.runAsPCTOption.isSet()) {
+				for (int i = 0; i < tree.numInputAttributes; i++) {
+					if (!inst.isInputMissing(i)) {
+						double inVal = inst.valueInputAttribute(i);
+
+						// sum of attr values
+						sumOfInputValues.addToValue(i, weight * inVal);
+
+						// sum of squared attr values
+						sumOfInputSquares.addToValue(i, weight * inVal * inVal);
+					}
+				}
+			}
+
+
+
 			if (tree.buildingModelTree()) learningModel.updatePerceptron(inst);
 
+			DoubleVector[] observations = new DoubleVector[tree.numOutputAttributes];
+			DoubleVector[] inputObservations = null;
+
+			for (int j = 0; j < tree.numOutputAttributes; j++) {
+				observations[j] = new DoubleVector();
+				if (!inst.isOutputMissing(j)) {
+					double outVal = inst.valueOutputAttribute(j);
+					observations[j].setValue(0, weight);
+					observations[j].setValue(1, weight * outVal);
+					observations[j].setValue(2, weight * outVal * outVal);
+				}
+			}
+			
+			if (tree.runAsPCTOption.isSet()) {
+				inputObservations = new DoubleVector[tree.numInputAttributes];
+				for (int j = 0; j < tree.numInputAttributes; j++) {
+					
+					inputObservations[j] = new DoubleVector();
+					if (!inst.isInputMissing(j)) {
+						double inVal = inst.valueInputAttribute(j);
+						inputObservations[j].setValue(0, weight);
+						inputObservations[j].setValue(1, weight * inVal);
+						inputObservations[j].setValue(2, weight * inVal * inVal);
+					}
+				}
+			}
+
 			for (int i : inputIndexes) {
 				AttributeStatisticsObserver obs = attributeObservers.get(i);
 				if (obs == null) {
@@ -373,15 +446,12 @@ public void learnFromInstance(StructuredInstance inst, double[] prediction, bool
 					}
 
 				}
-				if (obs != null) {
-					DoubleVector[] observations = new DoubleVector[inst.numOutputAttributes()];
-					for (int j = 0; j < inst.numOutputAttributes(); j++) {
-						observations[j] = new DoubleVector();
-						observations[j].setValue(0, inst.weight());
-						observations[j].setValue(1, inst.weight() * inst.valueOutputAttribute(j));
-						observations[j].setValue(2, inst.weight() * inst.valueOutputAttribute(j) * inst.valueOutputAttribute(j));
+				if (obs != null ) {
+					if (!tree.runAsPCTOption.isSet() || !inst.inputAttribute(i).isNumeric()) {
+						obs.observeAttribute(inst.valueInputAttribute(i), observations);
+					} else {
+						((MultiLabelBSTreePCT) obs).observeAttribute(inst.valueInputAttribute(i), observations, inputObservations);
 					}
-					obs.observeAttribute(inst.valueInputAttribute(i), observations);
 
 					//obs.observeAttributeClassVector(inst.valueInputAttribute(i), getTargetVector(inst), inst.weight());
 				}
@@ -402,16 +472,32 @@ public AttributeExpansionSuggestion[] getBestSplitSuggestions(MultiLabelSplitCri
 			for (int i : inputIndexes) {
 				AttributeStatisticsObserver obs = attributeObservers.get(i);
 				if (obs != null) {
-					DoubleVector[] preSplitStatistics = new DoubleVector[tree.getModelContext().numOutputAttributes()];
-					for (int j = 0; j < tree.getModelContext().numOutputAttributes(); j++) {
+					DoubleVector[] preSplitStatistics = new DoubleVector[tree.numOutputAttributes];
+					DoubleVector[] preSplitInputStatistics = null;
+					for (int j = 0; j < tree.numOutputAttributes; j++) {
 						preSplitStatistics[j] = new DoubleVector();
 						preSplitStatistics[j].setValue(0, examplesSeen);
 						preSplitStatistics[j].setValue(1, sumOfValues.getValue(j));
 						preSplitStatistics[j].setValue(2, sumOfSquares.getValue(j));
 					}
+					
+					if (tree.runAsPCTOption.isSet() && tree.modelContext.inputAttribute(i).isNumeric()) {
+						preSplitInputStatistics = new DoubleVector[tree.numInputAttributes];
+						for (int j = 0; j < tree.numInputAttributes; j++) {
+							preSplitInputStatistics[j] = new DoubleVector();
+							preSplitInputStatistics[j].setValue(0, examplesSeen);
+							preSplitInputStatistics[j].setValue(1, sumOfInputValues.getValue(j));
+							preSplitInputStatistics[j].setValue(2, sumOfInputSquares.getValue(j));
+						}
+
+					}
 
 					AttributeExpansionSuggestion bestSuggestion = null;
-					bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion, preSplitStatistics, i);
+					if (tree.runAsPCTOption.isSet() && tree.modelContext.inputAttribute(i).isNumeric()) {
+						bestSuggestion = ((MultiLabelBSTreePCT) obs).getBestEvaluatedSplitSuggestion(criterion, preSplitStatistics, preSplitInputStatistics, i);
+					} else {
+						bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion, preSplitStatistics, i);
+					}
 
 					if (bestSuggestion != null) {
 						bestSuggestions.add(bestSuggestion);
@@ -429,8 +515,8 @@ public double[] getPredictionModel(StructuredInstance inst) {
 		}
 
 		public double[] getPredictionTargetMean(StructuredInstance inst) {
-			double[] pred = new double[inst.numOutputAttributes()];
-			for (int i = 0; i < inst.numOutputAttributes(); i++) {
+			double[] pred = new double[tree.numOutputAttributes];
+			for (int i = 0; i < tree.numOutputAttributes; i++) {
 				if (examplesSeen > 0) {
 					pred[i] = sumOfValues.getValue(i) / examplesSeen;
 				} else {
@@ -477,7 +563,7 @@ public void checkForSplit() {
 		public void describeSubtree(StringBuilder out, int indent) {
 			StringUtils.appendIndented(out, indent, "Leaf");
 			StringUtils.appendNewline(out);
-			
+
 			if (tree.buildingModelTree()) {
 				learningModel.getModelDescription(out, indent + 2);
 			} else {
@@ -513,6 +599,14 @@ public InnerNode(ISOUPTree tree) {
 			super(tree);
 		}
 
+		public long calcByteSize() {
+			long size = super.calcByteSize();
+			size += SizeOf.sizeOf(PHsums) + SizeOf.sizeOf(PHmins) + SizeOf.sizeOf(sumOfAbsErrors);
+			for (Node child : children)
+				size += child.calcByteSize();
+			return size;
+		}
+
 		public int numChildren() {
 			return children.size();
 		}
@@ -541,7 +635,7 @@ public void restartChangeDetection() {
 				changeDetection = true;
 				PHsums = new DoubleVector();
 				PHmins = new DoubleVector();
-				for (int i = 0; i < tree.getModelContext().numOutputAttributes(); i++) {
+				for (int i = 0; i < tree.numOutputAttributes; i++) {
 					PHmins.setValue(i, Double.MAX_VALUE);
 				}				
 				for (Node child : children)
@@ -607,6 +701,10 @@ public SplitNode(Predicate predicate, ISOUPTree tree) {
 			ID = tree.maxID;
 		}
 
+		public long calcByteSize() {
+			return super.calcByteSize() + SizeOf.sizeOf(predicate);
+		}
+
 		public int instanceChildIndex(StructuredInstance inst) {
 			return (predicate.evaluate(inst)) ? 0 : 1;
 		}
@@ -643,10 +741,6 @@ public class MultitargetPerceptron {
 		// The number of instances contributing to this model
 		protected int instancesSeen = 0;
 
-		public String getPurposeString() {
-			return "A multi-target perceptron";
-		}
-
 		public MultitargetPerceptron(ISOUPTree tree, MultitargetPerceptron original) {
 			this.tree = tree;
 			weights = original.weights.clone();
@@ -657,10 +751,19 @@ public MultitargetPerceptron(ISOUPTree tree) {
 			initializeWeights();
 		}
 
+		public long calcByteSize() {
+			return SizeOf.sizeOf(this);
+		}
+
+		public String getPurposeString() {
+			return "A multi-target perceptron";
+		}
+
+
 		public void initializeWeights() {
 			instancesSeen = 0;
-			int numTargets = tree.getModelContext().numOutputAttributes();
-			int numInputs = tree.getModelContext().numInputAttributes();
+			int numTargets = tree.numOutputAttributes;
+			int numInputs = tree.numInputAttributes;
 			weights = new double[numTargets][numInputs+1];
 			tree.classifierRandom.setSeed(1234);
 			for (int i = 0; i < numTargets; i++) {
@@ -700,10 +803,12 @@ public void updateWeights(StructuredInstance inst, double learningRatio) {
 				double[] normalizedPrediction = prediction(normalizedInput);
 
 				double[] normalizedTarget = tree.normalizedTargetVector(inst);
-				for (int i = 0; i < inst.numOutputAttributes(); i++){
-					double delta = normalizedTarget[i] - normalizedPrediction[i];
-					for (int j = 0; j < normalizedInput.length; j++) {
-						weights[i][j] += delta * learningRatio * normalizedInput[j];
+				for (int i = 0; i < tree.numOutputAttributes; i++){
+					if (normalizedTarget[i] != Double.NaN) { /* to account for missing target values */
+						double delta = normalizedTarget[i] - normalizedPrediction[i];
+						for (int j = 0; j < normalizedInput.length; j++) {
+							weights[i][j] += delta * learningRatio * normalizedInput[j];
+						}
 					}
 				}
 				normalizeWeights();
@@ -724,8 +829,8 @@ public void normalizeWeights() {
 		 * Output the prediction made by this perceptron on the given instance
 		 */
 		public double[] prediction(double[] instanceValues) {
-			double[] out = new double[tree.getModelContext().numOutputAttributes()];
-			for (int i = 0; i < tree.getModelContext().numOutputAttributes(); i++) {
+			double[] out = new double[tree.numOutputAttributes];
+			for (int i = 0; i < tree.numOutputAttributes; i++) {
 				out[i] = 0;
 				for (int j = 0; j < instanceValues.length; j++) {
 					out[i] += weights[i][j] * instanceValues[j];
@@ -743,7 +848,7 @@ private double[] prediction(StructuredInstance inst) {
 		private double[] denormalizePrediction(double[] normalizedPrediction) {
 			double[] out = new double[normalizedPrediction.length];
 			if (tree.normalize()) {
-				for (int i = 0; i < tree.getModelContext().numOutputAttributes(); i++) {
+				for (int i = 0; i < tree.numOutputAttributes; i++) {
 					double mean = tree.sumOfValues.getValue(i) / tree.examplesSeen;
 					double sd = computeSD(tree.sumOfSquares.getValue(i), tree.sumOfValues.getValue(i), tree.examplesSeen);
 					if (examplesSeen > 1) 
@@ -757,9 +862,9 @@ private double[] denormalizePrediction(double[] normalizedPrediction) {
 
 		public void getModelDescription(StringBuilder out, int indent) {
 			if (getModelContext() != null) {
-				for (int i = 0; i < tree.getModelContext().numOutputAttributes(); i++) {
+				for (int i = 0; i < tree.numOutputAttributes; i++) {
 					StringUtils.appendIndented(out, indent, " [" + tree.getModelContext().outputAttribute(i).name() + "] =");
-					for (int j = 0; j < getModelContext().numInputAttributes(); j++) {
+					for (int j = 0; j < tree.numInputAttributes; j++) {
 						if (getModelContext().inputAttribute(j).isNumeric()) {
 							out.append((j == 0 && weights[i][j] >= 0) ? " " : (weights[i][j] < 0) ? " - " : " + ");
 							out.append(String.format("%.4f", Math.abs(weights[i][j])));
@@ -767,7 +872,7 @@ public void getModelDescription(StringBuilder out, int indent) {
 							out.append(getModelContext().inputAttribute(j).name());
 						}
 					}
-					out.append((weights[i][getModelContext().numInputAttributes()] < 0 ? " - " : " + ") + String.format("%.4f", Math.abs(weights[i][getModelContext().numInputAttributes()])));
+					out.append((weights[i][tree.numInputAttributes] < 0 ? " - " : " + ") + String.format("%.4f", Math.abs(weights[i][tree.numInputAttributes])));
 				}
 				StringUtils.appendNewline(out);
 			}
@@ -783,6 +888,14 @@ public ISOUPTree() {
 		super();
 	}
 
+	public List<Integer> newInputIndexes() {
+		List<Integer> indexes = new Vector<Integer>();
+		for (int i = 0; i < this.numInputAttributes; i++) {
+			indexes.add(i, i);
+		}
+		return indexes;
+	}
+
 	public String getPurposeString() {
 		return "Implementation of the iSOUP-Tree algorithm as described by Osojnik et al.";
 	}
@@ -795,12 +908,16 @@ public void resetLearningImpl() {
 
 		sumOfAttrValues = new DoubleVector();
 		sumOfAttrSquares = new DoubleVector();
-		
+
 	}
-	
+
 	@Override
 	public void modelContextSet() {
+		assert getModelContext() != null;
+		this.numInputAttributes = getModelContext().numInputAttributes();
+		this.numOutputAttributes = getModelContext().numOutputAttributes();
 		loadWeights();
+		checkRoot();
 	}
 
 	public void loadWeights() {
@@ -809,10 +926,11 @@ public void loadWeights() {
 			List<String> lines = Files.readAllLines(Paths.get(weightFile.getValue()), Charset.defaultCharset());
 			for (int i = 0 ; i < lines.size(); i++) targetWeights.setValue(i, Double.valueOf(lines.get(i)));
 		} catch (Exception e) {
-			for (int i = 0; i < getModelContext().numOutputAttributes(); i++) targetWeights.setValue(i, 1.0);
+			for (int i = 0; i < this.numOutputAttributes; i++)
+				targetWeights.setValue(i, 1.0);
 		}
 	}
-	
+
 	public boolean isRandomizable() {
 		return true;
 	}
@@ -820,7 +938,7 @@ public boolean isRandomizable() {
 	public void getModelDescription(StringBuilder out, int indent) {
 		if (treeRoot != null) treeRoot.describeSubtree(out, indent);
 	}
-	
+
 	protected Measurement[] getModelMeasurementsImpl() {
 		return new Measurement[]{ 
 				//new Measurement("tree size (nodes)", this.leafNodeCount + this.splitNodeCount),
@@ -828,19 +946,25 @@ protected Measurement[] getModelMeasurementsImpl() {
 		};
 	}
 
-	public int calcByteSize() {
-		int size = (int) SizeOf.sizeOf(this);
+	public long measureByteSize() {
+		return calcByteSize();
+	}
+
+	public long calcByteSize() {
+		long size = SizeOf.sizeOf(this);
 		if (this.treeRoot != null) {
 			size += this.treeRoot.calcByteSize();
 		}
+		size += SizeOf.sizeOf(sumOfValues) + SizeOf.sizeOf(sumOfSquares);
+		size += SizeOf.sizeOf(sumOfAttrValues) + SizeOf.sizeOf(sumOfAttrSquares);
+		size += SizeOf.sizeOf(targetWeights);
 		return size;
 	}
 
 	public Prediction getPredictionForInstance(StructuredInstance inst) {
-		checkRoot();
 		double[] predictionVector = treeRoot.getPrediction(inst);
-		MultiLabelPrediction prediction = new MultiLabelPrediction(getModelContext().numOutputAttributes());
-		for (int i = 0; i < getModelContext().numOutputAttributes(); i++) {
+		MultiLabelPrediction prediction = new MultiLabelPrediction(this.numOutputAttributes);
+		for (int i = 0; i < this.numOutputAttributes; i++) {
 			prediction.setVote(i, 1, predictionVector[i]);
 		}
 		return prediction;
@@ -848,9 +972,9 @@ public Prediction getPredictionForInstance(StructuredInstance inst) {
 
 	public double[] normalizedInputVector(StructuredInstance inst) {
 		// Normalize Instance
-		double[] normalizedInput = new double[inst.numInputAttributes()+1];
+		double[] normalizedInput = new double[this.numInputAttributes+1];
 		if (normalize()) {
-			for (int j = 0; j < inst.numInputAttributes(); j++) {
+			for (int j = 0; j < this.numInputAttributes; j++) {
 				Attribute attr = inst.inputAttribute(j);
 				double value =  inst.valueInputAttribute(j);
 				double mean = sumOfAttrValues.getValue(j) / examplesSeen;
@@ -864,33 +988,35 @@ public double[] normalizedInputVector(StructuredInstance inst) {
 					normalizedInput[j] = 0;
 			}
 			if (examplesSeen > 1)
-				normalizedInput[inst.numInputAttributes()] = 1.0; // Value to be multiplied with the constant factor
+				normalizedInput[this.numInputAttributes] = 1.0; // Value to be multiplied with the constant factor
 			else
-				normalizedInput[inst.numInputAttributes()] =  0.0;
+				normalizedInput[this.numInputAttributes] =  0.0;
 		} else {
-			for (int j = 0; j < inst.numInputAttributes(); j++) {
+			for (int j = 0; j < this.numInputAttributes; j++) {
 				normalizedInput[j] = inst.valueInputAttribute(j);
 			}
-			normalizedInput[inst.numInputAttributes()] = 1.0;
+			normalizedInput[this.numInputAttributes] = 1.0;
 		}
 		return normalizedInput;
 	}
 
 	public double[] normalizedTargetVector(StructuredInstance inst) {
-		double[] out = new double[getModelContext().numOutputAttributes()];
+		double[] out = new double[this.numOutputAttributes];
 		if (normalize()) {
-			for (int i = 0; i < inst.numOutputAttributes(); i++) {
-				double value = inst.valueOutputAttribute(i);
-				double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen);
-				double average = sumOfValues.getValue(i) / examplesSeen;
-				if (sd > 0 && examplesSeen > 1)
-					out[i] = (value - average) / (sd);
-				else
-					out[i] = 0;
+			for (int i = 0; i < this.numOutputAttributes; i++) {
+				double value = (inst.isOutputMissing(i)) ? Double.NaN : inst.valueOutputAttribute(i);;
+				if (value != Double.NaN) {
+					double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen);
+					double average = sumOfValues.getValue(i) / examplesSeen;
+					if (sd > 0 && examplesSeen > 1)
+						out[i] = (value - average) / (sd);
+					else
+						out[i] = 0;
+				} else out[i] = value;
 			}
 		} else {
-			for (int i = 0; i < inst.numOutputAttributes(); i++) {
-				out[i] = inst.valueOutputAttribute(i);
+			for (int i = 0; i < this.numOutputAttributes; i++) {
+				out[i] = (inst.isOutputMissing(i)) ? Double.NaN : inst.valueOutputAttribute(i);
 			}
 		}
 		return out;
@@ -945,8 +1071,8 @@ public double normalizeTargetValue(double value, int i) {
 	public double[] getNormalizedError(StructuredInstance inst, double[] prediction) {
 		double[] normalPrediction = normalizeTargetVector(prediction);
 		double[] normalValue = normalizedTargetVector(inst);
-		double[] out = new double[getModelContext().numOutputAttributes()];
-		for (int i = 0; i < inst.numOutputAttributes(); i++) {
+		double[] out = new double[this.numOutputAttributes];
+		for (int i = 0; i < this.numOutputAttributes; i++) {
 			out[i] = Math.abs(normalValue[i] - normalPrediction[i]);
 		}
 		return out;
@@ -956,176 +1082,173 @@ public double[] getNormalizedError(StructuredInstance inst, double[] prediction)
 	/**
 	 * Method for updating (training) the model using a new instance
 	 */
-	 public void trainOnInstanceImpl(StructuredInstance inst) {
-		 if (inst.weight() > 0) {
-			 checkRoot();
+	public void trainOnInstanceImpl(StructuredInstance inst) {
+		if (inst.weight() > 0) {
 
-			 double[] prediction = treeRoot.getPrediction(inst);
-			 double[] normalError = getNormalizedError(inst, prediction);
+			double[] prediction = treeRoot.getPrediction(inst);
+			double[] normalError = getNormalizedError(inst, prediction);
 
-			 processInstance(inst, treeRoot, prediction, normalError, true, false);
+			processInstance(inst, treeRoot, prediction, normalError, true, false);
 
-			 examplesSeen += inst.weight();
-			 for (int i = 0; i < inst.numberOutputTargets(); i++) {
-				 sumOfValues.addToValue(i, inst.weight() * inst.valueOutputAttribute(i));
-				 sumOfSquares.addToValue(i, inst.weight() * inst.valueOutputAttribute(i) * inst.valueOutputAttribute(i));
-			 }
+			double weight = inst.weight();
 
-			 for (int i = 0; i < inst.numInputAttributes(); i++) {
-				 sumOfAttrValues.addToValue(i, inst.weight() * inst.valueInputAttribute(i));
-				 sumOfAttrSquares.addToValue(i, inst.weight() * inst.valueInputAttribute(i) * inst.valueInputAttribute(i));
-			 }
-		 }
-	 }
+			examplesSeen += weight;
+			for (int i = 0; i < this.numOutputAttributes; i++) {
+				double iVal = inst.valueOutputAttribute(i);
+				sumOfValues.addToValue(i, weight * iVal);
+				sumOfSquares.addToValue(i, weight * iVal * iVal);
+			}
 
-	 public void processInstance(StructuredInstance inst, Node node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
-		 Node currentNode = node;
-		 while (true) {
-			 if (currentNode instanceof LeafNode) {
-				 ((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
-				 break;
-			 } else {
-				 currentNode.examplesSeen += inst.weight();
-				 //currentNode.sumOfAbsErrors.addValues(normalError);
-				 //				SplitNode iNode = (SplitNode) currentNode;
-				 //				if (!inAlternate && iNode.alternateTree != null) {
-				 //					boolean altTree = true;
-				 //					double lossO = Math.pow(inst.valueOutputAttribute() - prediction, 2);
-				 //					double lossA = Math.pow(inst.valueOutputAttribute() - iNode.alternateTree.getPrediction(inst), 2);
-				 //
-				 //					iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
-				 //					iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
-				 //					iNode.lossExamplesSeen++;
-				 //
-				 //					double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
-				 //					double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
-				 //					iNode.lossSumQi += Qi;
-				 //					iNode.lossNumQiTests += 1;
-				 //					double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
-				 //
-				 //					if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
-				 //						iNode.previousWeight = iNode.lossExamplesSeen;
-				 //						if (Qi > 0) {
-				 //							SplitNode parent = currentNode.getParent();
-				 //
-				 //							if (parent != null) {
-				 //								Node replacementTree = iNode.alternateTree;
-				 //								parent.setChild(parent.getChildIndex(currentNode), replacementTree);
-				 //								if (growthAllowed) replacementTree.restartChangeDetection();
-				 //							} else {
-				 //								treeRoot = iNode.alternateTree;
-				 //								treeRoot.restartChangeDetection();
-				 //							}
-				 //
-				 //							currentNode = iNode.alternateTree;
-				 //							altTree = false;
-				 //						} else if (
-				 //								(QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * this.gracePeriodOption.getValue()))
-				 //								|| iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()
-				 //								) {
-				 //							iNode.alternateTree = null;
-				 //							if (growthAllowed) iNode.restartChangeDetection();
-				 //							altTree = false;
-				 //						}
-				 //					}
-				 //
-				 //					if (altTree) {
-				 //						growthAllowed = false;
-				 //						processInstance(inst, iNode.alternateTree, prediction, normalError, true, true);
-				 //					}
-				 //				}
-
-				 //				if (iNode.changeDetection && !inAlternate) {
-				 //					if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
-				 //						iNode.initializeAlternateTree(this);
-				 //					}
-				 //				}
-				 if (currentNode instanceof SplitNode) {
-					 currentNode = ((SplitNode) currentNode).getChild(((SplitNode) currentNode).instanceChildIndex(inst));
-				 } else { // if the replaced alternate tree is just a leaf node
-					 ((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
-					 break;
-				 }
-			 }
-		 }
-	 }
+			for (int i = 0; i < this.numInputAttributes; i++) {
+				double iVal = inst.valueInputAttribute(i);
+				sumOfAttrValues.addToValue(i, weight * iVal);
+				sumOfAttrSquares.addToValue(i, weight * iVal * iVal);
+			}
+		}
+	}
 
-	 //region --- Object instatiation methods
+	public void processInstance(StructuredInstance inst, Node node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
+		Node currentNode = node;
+		while (true) {
+			if (currentNode instanceof LeafNode) {
+				((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
+				break;
+			} else {
+				currentNode.examplesSeen += inst.weight();
+				//currentNode.sumOfAbsErrors.addValues(normalError);
+				//				SplitNode iNode = (SplitNode) currentNode;
+				//				if (!inAlternate && iNode.alternateTree != null) {
+				//					boolean altTree = true;
+				//					double lossO = Math.pow(inst.valueOutputAttribute() - prediction, 2);
+				//					double lossA = Math.pow(inst.valueOutputAttribute() - iNode.alternateTree.getPrediction(inst), 2);
+				//
+				//					iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
+				//					iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
+				//					iNode.lossExamplesSeen++;
+				//
+				//					double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
+				//					double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+				//					iNode.lossSumQi += Qi;
+				//					iNode.lossNumQiTests += 1;
+				//					double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+				//
+				//					if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
+				//						iNode.previousWeight = iNode.lossExamplesSeen;
+				//						if (Qi > 0) {
+				//							SplitNode parent = currentNode.getParent();
+				//
+				//							if (parent != null) {
+				//								Node replacementTree = iNode.alternateTree;
+				//								parent.setChild(parent.getChildIndex(currentNode), replacementTree);
+				//								if (growthAllowed) replacementTree.restartChangeDetection();
+				//							} else {
+				//								treeRoot = iNode.alternateTree;
+				//								treeRoot.restartChangeDetection();
+				//							}
+				//
+				//							currentNode = iNode.alternateTree;
+				//							altTree = false;
+				//						} else if (
+				//								(QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * this.gracePeriodOption.getValue()))
+				//								|| iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()
+				//								) {
+				//							iNode.alternateTree = null;
+				//							if (growthAllowed) iNode.restartChangeDetection();
+				//							altTree = false;
+				//						}
+				//					}
+				//
+				//					if (altTree) {
+				//						growthAllowed = false;
+				//						processInstance(inst, iNode.alternateTree, prediction, normalError, true, true);
+				//					}
+				//				}
+
+				//				if (iNode.changeDetection && !inAlternate) {
+				//					if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+				//						iNode.initializeAlternateTree(this);
+				//					}
+				//				}
+				//if (currentNode instanceof SplitNode) {
+				currentNode = ((SplitNode) currentNode).getChild(((SplitNode) currentNode).instanceChildIndex(inst));
+				//} else { // if the replaced alternate tree is just a leaf node
+				//	 ((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
+				//break;
+			}
+		}
+	}
 
-	 protected NumericStatisticsObserver newNumericClassObserver() {
-		 return new MultiLabelBSTree();
-	 }
+	//region --- Object instatiation methods
 
-	 public NominalStatisticsObserver newNominalClassObserver() {
-		 return new MultiLabelNominalAttributeObserver();
-	 }
+	protected NumericStatisticsObserver newNumericClassObserver() {
+		try {
+			//NumericStatisticsObserver o = (NumericStatisticsObserver) ClassOption.cliStringToObject("MultiLabelBSTree -z 2000", MultiLabelBSTree.class, null);
+			//NumericStatisticsObserver o = (NumericStatisticsObserver) ClassOption.cliStringToObject("MultiLabelBSTree2 -z 2000", MultiLabelBSTree2.class, null);
+			if (runAsPCTOption.isSet()) {
+				return new MultiLabelBSTreePCT();
+			} else {
+				return new MultiLabelBSTree();
+			}
 
-	 //	protected SplitNode newSplitNode(InstanceConditionalTest splitTest) {
-	 //		maxID++;
-	 //		return new SplitNode(splitTest, this);
-	 //	}
+		} catch (Exception e) {
+			return null;
+		}
+	}
 
-	 protected SplitNode newSplitNode(Predicate predicate) {
-		 maxID++;
-		 return new SplitNode(predicate, this);
-	 }
+	public NominalStatisticsObserver newNominalClassObserver() {
+		return new MultiLabelNominalAttributeObserver();
+	}
 
-	 protected LeafNode newLeafNode() {
-		 maxID++;
-		 return new LeafNode(this);
-	 }
+	//	protected SplitNode newSplitNode(InstanceConditionalTest splitTest) {
+	//		maxID++;
+	//		return new SplitNode(splitTest, this);
+	//	}
 
-	 public MultitargetPerceptron newLeafModel() {
-		 return new MultitargetPerceptron(this);
-	 }
+	protected SplitNode newSplitNode(Predicate predicate) {
+		maxID++;
+		return new SplitNode(predicate, this);
+	}
 
-	 //endregion --- Object instatiation methods
+	protected LeafNode newLeafNode() {
+		maxID++;
+		return new LeafNode(this);
+	}
 
-	 //region --- Processing methods
-	 protected void checkRoot() {
-		 if (treeRoot == null) {
-			 treeRoot = newLeafNode();
-		 }
-	 }
+	public MultitargetPerceptron newLeafModel() {
+		return new MultitargetPerceptron(this);
+	}
 
-	 public static double computeHoeffdingBound(double range, double confidence, double n) {
-		 return Math.sqrt(((range * range) * Math.log(1 / confidence)) / (2.0 * n));
-	 }
+	//endregion --- Object instatiation methods
 
-	 public boolean buildingModelTree() {
-		 return !regressionTreeOption.isSet();
-	 }
-	 
-	 public boolean buildingRandomForestTree() {
-		 return randomForestBaseModelOption.isSet();
-	 }
+	//region --- Processing methods
+	protected void checkRoot() {
+		if (treeRoot == null) {
+			treeRoot = newLeafNode();
+		}
+	}
 
-	 public boolean normalize() {
-		 return !doNotNormalizeOption.isSet();
-	 }
+	public static double computeHoeffdingBound(double range, double confidence, double n) {
+		return Math.sqrt(((range * range) * Math.log(1 / confidence)) / (2.0 * n));
+	}
 
-	 protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex) {
-		 // Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
-		 MultiLabelSplitCriterion splitCriterion = new WeightedICVarianceReduction(targetWeights);
+	public boolean buildingModelTree() {
+		return !regressionTreeOption.isSet();
+	}
 
-		 // Using this criterion, find the best split per attribute and rank the results
-		 AttributeExpansionSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion); // TODO update with split criterion option
-		 Arrays.sort(bestSplitSuggestions);
+	public boolean normalize() {
+		return !doNotNormalizeOption.isSet();
+	}
 
 		 // Declare a variable to determine if any of the splits should be performed
 		 boolean shouldSplit = false;
-
 		 // If only one split was returned, use it
 		 if (bestSplitSuggestions.length < 2) {
 			 shouldSplit = bestSplitSuggestions.length > 0;
 		 } else { // Otherwise, consider which of the splits proposed may be worth trying
 
-			 // Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
-			 // to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
-			 double hoeffdingBound = computeHoeffdingBound(1, splitConfidenceOption.getValue(), node.examplesSeen);
-			 // Determine the top two ranked splitting suggestions
-			 AttributeExpansionSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-			 AttributeExpansionSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
+		// Using this criterion, find the best split per attribute and rank the results
+		AttributeExpansionSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion); // TODO update with split criterion option
+		Arrays.sort(bestSplitSuggestions);
 
 			 // If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
 			 // as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
@@ -1134,9 +1257,6 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 			 // Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
 			 // (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
 			 // competing attributes are equally good, and the split will be made on the one with the higher SDR value.
-			 //System.out.print(hoeffdingBound);
-			 //System.out.print(" ");
-			 ///System.out.println(secondBestSuggestion.merit / bestSuggestion.merit);
 			 if ((secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) || (hoeffdingBound < this.tieThresholdOption.getValue())) {
 				 shouldSplit = true;
 			 }
@@ -1155,44 +1275,36 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 			 }
 		 }
 
-		 // If the splitting criterion were met, split the current node using the chosen attribute test, and
-		 // make two new branches leading to (empty) leaves
-		 if (shouldSplit) {
-			 AttributeExpansionSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+			// Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
+			// to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
+			double hoeffdingBound = computeHoeffdingBound(1, splitConfidenceOption.getValue(), node.examplesSeen);
+			// Determine the top two ranked splitting suggestions
+			AttributeExpansionSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+			AttributeExpansionSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
 
 			 SplitNode newSplit = newSplitNode(splitDecision.predicate);
 			 newSplit.ID = node.ID;
 			 newSplit.copyStatistics(node);
 			 newSplit.changeDetection = node.changeDetection;
 			 newSplit.ID = node.ID;
+			 log(Integer.toString(node.ID) + ',' + Integer.toString((int) this.examplesSeen));
 			 for (int i = 0; i < 2; i++) { // Hardcoded for 2 values (due to the use of the Predicate class)
 				 LeafNode newChild = newLeafNode();
 				 if (buildingModelTree()) {
 					 // Copy the splitting node's perceptron to it's children
 					 newChild.learningModel = new MultitargetPerceptron(this, (MultitargetPerceptron) node.learningModel);
 
-				 }
-				 newChild.changeDetection = node.changeDetection;
-				 newChild.setParent(newSplit);
-				 newSplit.setChild(i, newChild);
-			 }
-			 if (parent == null && node.originalNode == null) {
-				 treeRoot = newSplit;
-			 } else if (parent == null && node.originalNode != null) {
-				 node.originalNode.alternateTree = newSplit;
-			 } else {
-				 parent.setChild(parentIndex, newSplit);
-				 newSplit.setParent(parent);
-			 }
-		 }
-	 }
+		// If the splitting criterion were met, split the current node using the chosen attribute test, and
+		// make two new branches leading to (empty) leaves
+		//		try {
+		//			Thread.sleep(20000);
+		//		} catch (InterruptedException e) {
+		//			// TODO Auto-generated catch block
+		//			e.printStackTrace();
+		//		}
 
-	 public double computeSD(double squaredVal, double val, double size) {
-		 if (size > 1)
-			 return Math.sqrt((squaredVal - ((val * val) / size)) / size);
-		 else
-			 return 0.0;
-	 }
+		if (shouldSplit) {
+			AttributeExpansionSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
 
 	 public static double scalarProduct(DoubleVector u, DoubleVector v) {
 		 double ret = 0.0;
@@ -1202,6 +1314,38 @@ public static double scalarProduct(DoubleVector u, DoubleVector v) {
 		 return ret;
 	 }
 	 //endregion --- Processing methods
-
+	 
+	 public void initWriter(String filename) {
+		 try {
+			 writer = new BufferedWriter(new FileWriter(filename));
+			 writer.write("");
+			 writer.close();
+			 writer = new BufferedWriter(new FileWriter(filename, true));
+		 } catch (Exception e) {
+			 e.printStackTrace();
+		 }
+	 }
+	 
+	 public void closeWriter() {
+		 try {
+		 writer.close();
+		 } catch (Exception e) {
+			 e.printStackTrace();
+		 }
+		 writer = null;
+		 
+	 }
+	 
+	 public void log(String s) {
+		 if (writer != null) {
+			 try {
+				 writer.write(s + "\n");
+				 writer.flush();
+			 } catch (Exception e) {
+				 e.printStackTrace();
+			 }
+		 }
+	 }
+	 
 	 //endregion ================ METHODS ================
 }
diff --git a/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTreeRF.java b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTreeRF.java
new file mode 100644
index 000000000..ea8193d91
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/multilabel/trees/ISOUPTreeRF.java
@@ -0,0 +1,46 @@
+package moa.classifiers.multilabel.trees;
+
+import java.util.List;
+import java.util.Vector;
+
+import com.github.javacliparser.MultiChoiceOption;
+
+public class ISOUPTreeRF extends ISOUPTree {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 3145263568676115808L;
+	public MultiChoiceOption radndomForestFunAttrsOption = new MultiChoiceOption(
+			"randomForestFunAttr",
+			'z',
+			"The function of the number of input attribtues to use in the random forest construction.", 
+			new String[]{"sqrt", "log", "percent"}, new String[]{"Square root", "Logarithm", "10% percent"}, 0);
+	
+	
+	public int numRFAttrs() {
+		switch (radndomForestFunAttrsOption.getChosenLabel()) {
+		case "sqrt": return (int) Math.ceil(Math.sqrt(this.getModelContext().numInputAttributes()));
+		case "log": return (int) Math.ceil(Math.log(this.getModelContext().numInputAttributes())) + 1;
+		case "percent": return (int) Math.ceil(0.1 * this.getModelContext().numInputAttributes());
+		}
+		return 0;
+	}
+	
+	@Override
+	public List<Integer> newInputIndexes() {
+		List<Integer> indexes = new Vector<Integer>();
+		int numAttrs = this.getModelContext().numInputAttributes();
+		for (int i = 0; i < numAttrs; i++) {
+			indexes.add(i, i);
+		}
+		for (int i = 0; i < Math.ceil(numRFAttrs()); i++) {
+			int swap = i + this.classifierRandom.nextInt(numAttrs - i);
+			int temp = indexes.get(i);
+			indexes.set(i, indexes.get(swap));
+			indexes.set(swap, temp);
+		}
+		return indexes.subList(0, numRFAttrs());
+	}
+	
+}
diff --git a/moa/src/main/java/moa/classifiers/multitarget/BasicMultiTargetRegressor.java b/moa/src/main/java/moa/classifiers/multitarget/BasicMultiTargetRegressor.java
index edad24332..a7a1a1ac1 100644
--- a/moa/src/main/java/moa/classifiers/multitarget/BasicMultiTargetRegressor.java
+++ b/moa/src/main/java/moa/classifiers/multitarget/BasicMultiTargetRegressor.java
@@ -1,6 +1,13 @@
 
 package moa.classifiers.multitarget;
 
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
+import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.AbstractMultiLabelLearner;
 import moa.classifiers.Classifier;
@@ -12,14 +19,6 @@
 import moa.options.ClassOption;
 import moa.streams.InstanceStream;
 
-import com.yahoo.labs.samoa.instances.DenseInstance;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
-import com.yahoo.labs.samoa.instances.Prediction;
-
 
 public class BasicMultiTargetRegressor extends AbstractMultiLabelLearner implements MultiTargetRegressor{
 
diff --git a/moa/src/main/java/moa/classifiers/multitarget/functions/MultiTargetNoChange.java b/moa/src/main/java/moa/classifiers/multitarget/functions/MultiTargetNoChange.java
index 9f08ed855..cae16376a 100644
--- a/moa/src/main/java/moa/classifiers/multitarget/functions/MultiTargetNoChange.java
+++ b/moa/src/main/java/moa/classifiers/multitarget/functions/MultiTargetNoChange.java
@@ -1,14 +1,10 @@
 package moa.classifiers.multitarget.functions;
 
 
-import com.yahoo.labs.samoa.instances.DenseInstanceData;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
-import moa.classifiers.AbstractClassifier;
 import moa.classifiers.AbstractMultiLabelLearner;
 import moa.classifiers.MultiTargetRegressor;
 import moa.core.Measurement;
diff --git a/moa/src/main/java/moa/classifiers/rules/AMRulesRegressorOld.java b/moa/src/main/java/moa/classifiers/rules/AMRulesRegressorOld.java
index 63b1d3f9f..8a8020529 100644
--- a/moa/src/main/java/moa/classifiers/rules/AMRulesRegressorOld.java
+++ b/moa/src/main/java/moa/classifiers/rules/AMRulesRegressorOld.java
@@ -64,11 +64,10 @@
 import com.github.javacliparser.MultiChoiceOption;
 
 import moa.classifiers.Regressor;
-import moa.classifiers.core.splitcriteria.VarianceReductionSplitCriterion;
 import moa.classifiers.rules.core.Rule;
+import moa.classifiers.rules.core.Rule.Builder;
 import moa.classifiers.rules.core.RuleActiveLearningNode;
 import moa.classifiers.rules.core.RuleActiveRegressionNode;
-import moa.classifiers.rules.core.Rule.Builder;
 import moa.classifiers.rules.core.splitcriteria.AMRulesSplitCriterion;
 import moa.classifiers.rules.core.voting.ErrorWeightedVote;
 import moa.classifiers.rules.functions.Perceptron;
diff --git a/moa/src/main/java/moa/classifiers/rules/AbstractAMRules.java b/moa/src/main/java/moa/classifiers/rules/AbstractAMRules.java
index ab2555b7a..8f6911d14 100644
--- a/moa/src/main/java/moa/classifiers/rules/AbstractAMRules.java
+++ b/moa/src/main/java/moa/classifiers/rules/AbstractAMRules.java
@@ -31,19 +31,19 @@
  * 
  **/
 
+import java.util.Arrays;
+import java.util.Iterator;
+
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
-import java.util.Arrays;
-import java.util.Iterator;
-
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.rules.core.Rule;
+import moa.classifiers.rules.core.Rule.Builder;
 import moa.classifiers.rules.core.RuleActiveLearningNode;
 import moa.classifiers.rules.core.RuleSet;
-import moa.classifiers.rules.core.Rule.Builder;
 import moa.classifiers.rules.core.attributeclassobservers.FIMTDDNumericAttributeClassLimitObserver;
 import moa.classifiers.rules.core.voting.ErrorWeightedVote;
 import moa.classifiers.rules.core.voting.Vote;
diff --git a/moa/src/main/java/moa/classifiers/rules/Predicates.java b/moa/src/main/java/moa/classifiers/rules/Predicates.java
index 76b96f084..db1583359 100644
--- a/moa/src/main/java/moa/classifiers/rules/Predicates.java
+++ b/moa/src/main/java/moa/classifiers/rules/Predicates.java
@@ -21,6 +21,8 @@
 
 package moa.classifiers.rules;
 
+import com.yahoo.labs.samoa.instances.Instance;
+
 /**
  * Class that creates and evaluates the predicates
  * 
@@ -32,7 +34,6 @@
  */
 
 import moa.AbstractMOAObject;
-import com.yahoo.labs.samoa.instances.Instance;
 
 public class Predicates extends AbstractMOAObject{
 	
diff --git a/moa/src/main/java/moa/classifiers/rules/RuleClassification.java b/moa/src/main/java/moa/classifiers/rules/RuleClassification.java
index c7b9866e4..3d6fdcda9 100644
--- a/moa/src/main/java/moa/classifiers/rules/RuleClassification.java
+++ b/moa/src/main/java/moa/classifiers/rules/RuleClassification.java
@@ -33,11 +33,13 @@
  */
 
 import java.util.ArrayList;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.AbstractMOAObject;
-import moa.classifiers.core.attributeclassobservers.*;
+import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
-import com.yahoo.labs.samoa.instances.Instance;
 
 public class RuleClassification extends AbstractMOAObject{
 	
diff --git a/moa/src/main/java/moa/classifiers/rules/RuleClassifier.java b/moa/src/main/java/moa/classifiers/rules/RuleClassifier.java
index 0e8dbd6e3..6d4f860d6 100644
--- a/moa/src/main/java/moa/classifiers/rules/RuleClassifier.java
+++ b/moa/src/main/java/moa/classifiers/rules/RuleClassifier.java
@@ -25,21 +25,26 @@
 import java.io.IOException;
 import java.io.PrintWriter;
 import java.math.BigDecimal;
-import java.util.*;
-import com.github.javacliparser.FlagOption; 
+import java.util.ArrayList;
+import java.util.Collections;
 
+import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
-import moa.classifiers.core.attributeclassobservers.*;
+import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
+import moa.classifiers.core.attributeclassobservers.BinaryTreeNumericAttributeClassObserver;
 import moa.classifiers.core.attributeclassobservers.BinaryTreeNumericAttributeClassObserver.Node;
+import moa.classifiers.core.attributeclassobservers.GaussianNumericAttributeClassObserver;
+import moa.classifiers.core.attributeclassobservers.NominalAttributeClassObserver;
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.StringUtils;
 import moa.core.Utils;
-import com.yahoo.labs.samoa.instances.Instance;
 
 
 
diff --git a/moa/src/main/java/moa/classifiers/rules/RuleClassifierNBayes.java b/moa/src/main/java/moa/classifiers/rules/RuleClassifierNBayes.java
index 6a23e9f06..d495592f3 100644
--- a/moa/src/main/java/moa/classifiers/rules/RuleClassifierNBayes.java
+++ b/moa/src/main/java/moa/classifiers/rules/RuleClassifierNBayes.java
@@ -22,10 +22,12 @@
 
 import java.util.ArrayList;
 import java.util.Collections;
+
 import com.github.javacliparser.IntOption;
-import moa.classifiers.bayes.NaiveBayes;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.classifiers.bayes.NaiveBayes;
+
 /**
  * This classifier learn ordered and unordered rule set from data stream with naive Bayes learners.
  * <p> This algorithm also does the detection of anomalies.
diff --git a/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java
index 7e5febe56..fb5505ef7 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java
@@ -2,7 +2,6 @@
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.AbstractMOAObject;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java
index a6b313c12..8387610c0 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java
@@ -2,7 +2,6 @@
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.AbstractMOAObject;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/Rule.java b/moa/src/main/java/moa/classifiers/rules/core/Rule.java
index c12befcb2..4cea1b6dc 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/Rule.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/Rule.java
@@ -19,6 +19,10 @@
  */
 package moa.classifiers.rules.core;
 
+import java.io.Serializable;
+import java.util.LinkedList;
+import java.util.List;
+
 /**
  * Class that stores an arrayList of predicates of a rule and the observers
  * (statistics). This class implements a function that evaluates a rule.
@@ -36,10 +40,6 @@
 import com.github.javacliparser.FloatOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
-import java.io.Serializable;
-import java.util.LinkedList;
-import java.util.List;
-
 import moa.AbstractMOAObject;
 import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
 import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/RuleActiveLearningNode.java b/moa/src/main/java/moa/classifiers/rules/core/RuleActiveLearningNode.java
index 1613a7049..1eaff66bd 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/RuleActiveLearningNode.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/RuleActiveLearningNode.java
@@ -24,8 +24,8 @@
 import moa.classifiers.core.AttributeSplitSuggestion;
 import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
 import moa.classifiers.rules.AbstractAMRules;
-import moa.classifiers.rules.driftdetection.PageHinkleyTest;
 import moa.classifiers.rules.driftdetection.PageHinkleyFading;
+import moa.classifiers.rules.driftdetection.PageHinkleyTest;
 import moa.classifiers.trees.HoeffdingTree;
 import moa.classifiers.trees.HoeffdingTree.ActiveLearningNode;
 import moa.core.AutoExpandVector;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/RuleActiveRegressionNode.java b/moa/src/main/java/moa/classifiers/rules/core/RuleActiveRegressionNode.java
index 1eebdfad7..0f39b9f91 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/RuleActiveRegressionNode.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/RuleActiveRegressionNode.java
@@ -20,28 +20,20 @@
 
 package moa.classifiers.rules.core;
 
-import com.yahoo.labs.samoa.instances.Instance;
-
-import java.io.BufferedWriter;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.io.PrintWriter;
-import java.sql.PreparedStatement;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
 
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.core.AttributeSplitSuggestion;
 import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
 import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
 import moa.classifiers.rules.AMRulesRegressorOld;
-import moa.classifiers.rules.AbstractAMRules;
 import moa.classifiers.rules.core.splitcriteria.AMRulesSplitCriterion;
-import moa.classifiers.rules.core.splitcriteria.SDRSplitCriterionAMRules;
 import moa.classifiers.rules.functions.Perceptron;
 import moa.classifiers.rules.functions.TargetMean;
 import moa.core.DoubleVector;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/Utils.java b/moa/src/main/java/moa/classifiers/rules/core/Utils.java
index 1c60f8dfb..5340ea695 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/Utils.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/Utils.java
@@ -14,6 +14,11 @@ public static double computeVariance(DoubleVector statistics)
 		return computeVariance(statistics.getValue(0),statistics.getValue(1),statistics.getValue(2));
 	}
 
+	public static double computeVariance(double[] statistics)
+	{
+		return computeVariance(statistics[0],statistics[1],statistics[2]);
+	}
+	
 	public static double computeSD(double squaredSum, double sum, double weightSeen) {
 		if (weightSeen > 1) {
 			return Math.sqrt((squaredSum - ((sum * sum) / weightSeen)) / (weightSeen - 1.0));
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AbstractAnomalyDetector.java b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AbstractAnomalyDetector.java
index 13a4f85ba..5d91180e4 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AbstractAnomalyDetector.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AbstractAnomalyDetector.java
@@ -1,8 +1,9 @@
 package moa.classifiers.rules.core.anomalydetection;
 
-import moa.options.AbstractOptionHandler;
 import com.yahoo.labs.samoa.instances.StructuredInstance;
 
+import moa.options.AbstractOptionHandler;
+
 
 public abstract class AbstractAnomalyDetector extends AbstractOptionHandler implements AnomalyDetector {
 
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalinessRatioScore.java b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalinessRatioScore.java
index 9297ebe1e..a6a3bdae6 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalinessRatioScore.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalinessRatioScore.java
@@ -1,18 +1,16 @@
 package moa.classifiers.rules.core.anomalydetection;
 
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.classifiers.rules.core.Utils;
 import moa.classifiers.rules.core.anomalydetection.probabilityfunctions.ProbabilityFunction;
-import moa.classifiers.rules.core.attributeclassobservers.FIMTDDNumericAttributeClassLimitObserver;
 import moa.core.AutoExpandVector;
 import moa.core.ObjectRepository;
 import moa.options.ClassOption;
 import moa.tasks.TaskMonitor;
 
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-
 public class AnomalinessRatioScore extends AbstractAnomalyDetector {
 
 	/**
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/NoAnomalyDetection.java b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/NoAnomalyDetection.java
index 722f15dfa..6ad69595a 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/NoAnomalyDetection.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/NoAnomalyDetection.java
@@ -1,8 +1,9 @@
 package moa.classifiers.rules.core.anomalydetection;
 
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 public class NoAnomalyDetection extends AbstractAnomalyDetector{
 
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/OddsRatioScore.java b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/OddsRatioScore.java
index 53cc8556c..ee841f6f2 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/OddsRatioScore.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/OddsRatioScore.java
@@ -1,5 +1,10 @@
 package moa.classifiers.rules.core.anomalydetection;
 
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.classifiers.rules.core.Utils;
 import moa.classifiers.rules.core.anomalydetection.probabilityfunctions.CantellisInequality;
 import moa.classifiers.rules.core.anomalydetection.probabilityfunctions.ProbabilityFunction;
@@ -8,11 +13,6 @@
 import moa.options.ClassOption;
 import moa.tasks.TaskMonitor;
 
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-
 public class OddsRatioScore extends AbstractAnomalyDetector {
 
 	/**
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/CantellisInequality.java b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/CantellisInequality.java
index c021dad34..63aad5315 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/CantellisInequality.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/CantellisInequality.java
@@ -2,11 +2,8 @@
 
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-import moa.options.OptionHandler;
 import moa.tasks.TaskMonitor;
 
-import com.github.javacliparser.Options;
-
 public class CantellisInequality extends AbstractOptionHandler implements ProbabilityFunction {
 
 	/**
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/ChebyshevInequality.java b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/ChebyshevInequality.java
index 52d897aa1..f32fb6243 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/ChebyshevInequality.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/ChebyshevInequality.java
@@ -2,11 +2,8 @@
 
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-import moa.options.OptionHandler;
 import moa.tasks.TaskMonitor;
 
-import com.github.javacliparser.Options;
-
 public class ChebyshevInequality extends AbstractOptionHandler implements ProbabilityFunction {
 
 	/**
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/GaussInequality.java b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/GaussInequality.java
index aa73a67a5..ea587e6dd 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/GaussInequality.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/GaussInequality.java
@@ -2,11 +2,8 @@
 
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-import moa.options.OptionHandler;
 import moa.tasks.TaskMonitor;
 
-import com.github.javacliparser.Options;
-
 public class GaussInequality extends AbstractOptionHandler implements ProbabilityFunction {
 
 	/**
diff --git a/moa/src/main/java/moa/classifiers/rules/core/attributeclassobservers/FIMTDDNumericAttributeClassLimitObserver.java b/moa/src/main/java/moa/classifiers/rules/core/attributeclassobservers/FIMTDDNumericAttributeClassLimitObserver.java
index de93184cf..83740c403 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/attributeclassobservers/FIMTDDNumericAttributeClassLimitObserver.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/attributeclassobservers/FIMTDDNumericAttributeClassLimitObserver.java
@@ -20,6 +20,7 @@
 package moa.classifiers.rules.core.attributeclassobservers;
 
 import com.github.javacliparser.IntOption;
+
 import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
 
 
@@ -99,9 +100,6 @@ else if (val < this.cut_point) {
 		// right (>) distribution and send the value down to the right child node.
 		// If no right child exists, create one
 		else { // val > cut_point
-			this.rightStatistics.addToValue(0,1);
-			this.rightStatistics.addToValue(1,label);
-			this.rightStatistics.addToValue(2,label*label);
 			if (this.right == null) {
 				if(numNodes<maxNodes){
 					this.right = new Node(val, label, weight);
diff --git a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java
index 93d962149..df2405a5a 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java
@@ -21,7 +21,6 @@
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import moa.classifiers.core.conditionaltests.NominalAttributeBinaryTest;
 import moa.classifiers.rules.core.Predicate;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java
index ff4c0c350..37650e7ca 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java
@@ -21,7 +21,6 @@
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import moa.classifiers.core.conditionaltests.InstanceConditionalBinaryTest;
 import moa.classifiers.rules.core.Predicate;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/SDRSplitCriterionAMRules.java b/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/SDRSplitCriterionAMRules.java
index 8442a9006..b5fc4d1fa 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/SDRSplitCriterionAMRules.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/SDRSplitCriterionAMRules.java
@@ -20,7 +20,6 @@
 package moa.classifiers.rules.core.splitcriteria;
 
 import moa.classifiers.core.splitcriteria.SDRSplitCriterion;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
 
 
 public class SDRSplitCriterionAMRules extends SDRSplitCriterion implements AMRulesSplitCriterion {
diff --git a/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/SDRSplitCriterionAMRulesNode.java b/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/SDRSplitCriterionAMRulesNode.java
index bfdab536b..c95cf7ab0 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/SDRSplitCriterionAMRulesNode.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/SDRSplitCriterionAMRulesNode.java
@@ -19,8 +19,6 @@
  */
 package moa.classifiers.rules.core.splitcriteria;
 
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-
 public class SDRSplitCriterionAMRulesNode extends SDRSplitCriterionAMRules implements AMRulesSplitCriterion {
 
     private static final long serialVersionUID = 1L;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/voting/AbstractErrorWeightedVote.java b/moa/src/main/java/moa/classifiers/rules/core/voting/AbstractErrorWeightedVote.java
index 483f62591..98ce19126 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/voting/AbstractErrorWeightedVote.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/voting/AbstractErrorWeightedVote.java
@@ -22,6 +22,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+
 import moa.AbstractMOAObject;
 
 /**
diff --git a/moa/src/main/java/moa/classifiers/rules/errormeasurers/MeanAbsoluteDeviation.java b/moa/src/main/java/moa/classifiers/rules/errormeasurers/MeanAbsoluteDeviation.java
index 1844f2bdf..e76609a9c 100644
--- a/moa/src/main/java/moa/classifiers/rules/errormeasurers/MeanAbsoluteDeviation.java
+++ b/moa/src/main/java/moa/classifiers/rules/errormeasurers/MeanAbsoluteDeviation.java
@@ -1,6 +1,5 @@
 package moa.classifiers.rules.errormeasurers;
 
-import com.github.javacliparser.FloatOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
 /*
diff --git a/moa/src/main/java/moa/classifiers/rules/errormeasurers/RootMeanSquaredError.java b/moa/src/main/java/moa/classifiers/rules/errormeasurers/RootMeanSquaredError.java
index fe334910a..3c706662e 100644
--- a/moa/src/main/java/moa/classifiers/rules/errormeasurers/RootMeanSquaredError.java
+++ b/moa/src/main/java/moa/classifiers/rules/errormeasurers/RootMeanSquaredError.java
@@ -2,8 +2,6 @@
 
 import com.yahoo.labs.samoa.instances.Instance;
 
-import moa.AbstractMOAObject;
-
 public class RootMeanSquaredError extends ErrorMeasurement {
 
 	/**
diff --git a/moa/src/main/java/moa/classifiers/rules/functions/AMRulesLearner.java b/moa/src/main/java/moa/classifiers/rules/functions/AMRulesLearner.java
index 5fd8f7ff3..5d9a4761b 100644
--- a/moa/src/main/java/moa/classifiers/rules/functions/AMRulesLearner.java
+++ b/moa/src/main/java/moa/classifiers/rules/functions/AMRulesLearner.java
@@ -1,10 +1,10 @@
 package moa.classifiers.rules.functions;
 
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.core.Example;
 import moa.learners.Learner;
 
-import com.yahoo.labs.samoa.instances.Instance;
-
 public interface AMRulesLearner extends Learner<Example<Instance>>{
 	
 	public double getCurrentError();
diff --git a/moa/src/main/java/moa/classifiers/rules/functions/Perceptron.java b/moa/src/main/java/moa/classifiers/rules/functions/Perceptron.java
index a5e48b1a8..d8d6bdd81 100644
--- a/moa/src/main/java/moa/classifiers/rules/functions/Perceptron.java
+++ b/moa/src/main/java/moa/classifiers/rules/functions/Perceptron.java
@@ -25,10 +25,8 @@
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.classifiers.AbstractClassifier;
-import moa.classifiers.Regressor;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 
diff --git a/moa/src/main/java/moa/classifiers/rules/functions/TargetMean.java b/moa/src/main/java/moa/classifiers/rules/functions/TargetMean.java
index 53f8c63c1..fcb7e6f8d 100644
--- a/moa/src/main/java/moa/classifiers/rules/functions/TargetMean.java
+++ b/moa/src/main/java/moa/classifiers/rules/functions/TargetMean.java
@@ -26,8 +26,8 @@
  *  */
 import com.github.javacliparser.FloatOption;
 import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
-import moa.classifiers.Regressor;
 import moa.core.Measurement;
 import moa.core.StringUtils;
 
diff --git a/moa/src/main/java/moa/classifiers/rules/meta/RandomAMRulesOld.java b/moa/src/main/java/moa/classifiers/rules/meta/RandomAMRulesOld.java
index 8828c1d84..5037efd76 100644
--- a/moa/src/main/java/moa/classifiers/rules/meta/RandomAMRulesOld.java
+++ b/moa/src/main/java/moa/classifiers/rules/meta/RandomAMRulesOld.java
@@ -21,13 +21,10 @@
 
 import java.util.Arrays;
 
-import moa.options.ClassOption;
-
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
@@ -38,11 +35,9 @@
 import moa.classifiers.rules.AbstractAMRules;
 import moa.classifiers.rules.core.voting.ErrorWeightedVote;
 import moa.classifiers.rules.core.voting.Vote;
-import moa.core.DoubleVector;
-import moa.core.FastVector;
 import moa.core.Measurement;
 import moa.core.MiscUtils;
-import moa.streams.InstanceStream;
+import moa.options.ClassOption;
 
 
 public class RandomAMRulesOld extends AbstractClassifier implements Regressor {
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java b/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java
index 44a24ae5f..0ad8c1ec2 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java
@@ -33,6 +33,12 @@
 
 import java.util.Iterator;
 
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.classifiers.AbstractMultiLabelLearner;
 import moa.classifiers.MultiLabelLearner;
 import moa.classifiers.core.driftdetection.ChangeDetector;
@@ -44,7 +50,6 @@
 import moa.classifiers.rules.multilabel.core.MultiLabelRule;
 import moa.classifiers.rules.multilabel.core.MultiLabelRuleSet;
 import moa.classifiers.rules.multilabel.core.voting.ErrorWeightedVoteMultiLabel;
-import moa.classifiers.rules.multilabel.core.voting.MultiLabelVote;
 import moa.classifiers.rules.multilabel.errormeasurers.MultiLabelErrorMeasurer;
 import moa.classifiers.rules.multilabel.outputselectors.OutputAttributesSelector;
 import moa.classifiers.rules.multilabel.outputselectors.SelectAllOutputs;
@@ -52,12 +57,6 @@
 import moa.core.StringUtils;
 import moa.options.ClassOption;
 
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.Prediction;
-
 
 public abstract class AMRulesMultiLabelLearner extends AbstractMultiLabelLearner implements MultiLabelLearner{
 
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressor.java b/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressor.java
index 146a6be85..461c63925 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressor.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressor.java
@@ -2,12 +2,10 @@
 
 import moa.classifiers.MultiLabelLearner;
 import moa.classifiers.MultiTargetRegressor;
-import moa.classifiers.Regressor;
 import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.rules.multilabel.core.MultiLabelRule;
 import moa.classifiers.rules.multilabel.core.MultiLabelRuleRegression;
 import moa.classifiers.rules.multilabel.core.voting.ErrorWeightedVoteMultiLabel;
-import moa.classifiers.rules.multilabel.core.voting.InverseErrorWeightedVoteMultiLabel;
 import moa.classifiers.rules.multilabel.errormeasurers.MultiLabelErrorMeasurer;
 import moa.options.ClassOption;
 
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java
index 9c179d2f6..a8bafb4a1 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java
@@ -7,15 +7,10 @@
 import java.util.Random;
 
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.classifiers.MultiLabelLearner;
-import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.NumericAttributeClassObserver;
 import moa.classifiers.core.driftdetection.ChangeDetector;
 import moa.classifiers.multilabel.core.attributeclassobservers.AttributeStatisticsObserver;
 import moa.classifiers.multilabel.core.attributeclassobservers.NominalStatisticsObserver;
@@ -23,13 +18,11 @@
 import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.rules.core.AttributeExpansionSuggestion;
 import moa.classifiers.rules.core.anomalydetection.AnomalyDetector;
-import moa.classifiers.rules.multilabel.errormeasurers.AbstractMultiTargetErrorMeasurer;
 import moa.classifiers.rules.multilabel.errormeasurers.MultiLabelErrorMeasurer;
 import moa.classifiers.rules.multilabel.outputselectors.OutputAttributesSelector;
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
 import moa.options.AbstractOptionHandler;
-import moa.options.ClassOption;
 
 
 public abstract class LearningLiteral extends AbstractOptionHandler {
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java
index f9e2c5c82..282ca1dba 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java
@@ -1,20 +1,14 @@
 package moa.classifiers.rules.multilabel.core;
 
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.Prediction;
-
 import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
 
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.classifiers.MultiLabelLearner;
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
-import moa.classifiers.core.driftdetection.ChangeDetector;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
 import moa.classifiers.multilabel.core.attributeclassobservers.AttributeStatisticsObserver;
 import moa.classifiers.multilabel.core.attributeclassobservers.NominalStatisticsObserver;
 import moa.classifiers.multilabel.core.attributeclassobservers.NumericStatisticsObserver;
@@ -25,7 +19,6 @@
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
 import moa.core.ObjectRepository;
-import moa.learners.Learner;
 import moa.tasks.TaskMonitor;
 
 public class LearningLiteralRegression extends LearningLiteral {
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java
index 0fb2aba8b..23e58b418 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java
@@ -5,22 +5,16 @@
 import java.util.List;
 import java.util.Random;
 
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.AbstractMOAObject;
 import moa.classifiers.MultiLabelLearner;
-import moa.classifiers.core.attributeclassobservers.NumericAttributeClassObserver;
-import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
-import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
 import moa.classifiers.core.driftdetection.ChangeDetector;
 import moa.classifiers.multilabel.core.attributeclassobservers.NominalStatisticsObserver;
 import moa.classifiers.multilabel.core.attributeclassobservers.NumericStatisticsObserver;
 import moa.classifiers.multilabel.core.splitcriteria.MultiLabelSplitCriterion;
-import moa.classifiers.rules.core.RuleActiveLearningNode;
-import moa.classifiers.rules.core.RuleSplitNode;
 import moa.classifiers.rules.core.anomalydetection.AnomalyDetector;
-import moa.classifiers.rules.core.conditionaltests.NumericAttributeBinaryRulePredicate;
 import moa.classifiers.rules.multilabel.errormeasurers.MultiLabelErrorMeasurer;
 import moa.classifiers.rules.multilabel.outputselectors.OutputAttributesSelector;
 import moa.core.StringUtils;
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/AbstractErrorWeightedVoteMultiLabel.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/AbstractErrorWeightedVoteMultiLabel.java
index 8572a8b5a..59cada880 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/AbstractErrorWeightedVoteMultiLabel.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/AbstractErrorWeightedVoteMultiLabel.java
@@ -26,7 +26,6 @@
 import com.yahoo.labs.samoa.instances.Prediction;
 
 import moa.AbstractMOAObject;
-import moa.core.DoubleVector;
 
 /**
  * AbstractErrorWeightedVote class for weighted votes based on estimates of errors. 
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/ErrorWeightedVoteMultiLabel.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/ErrorWeightedVoteMultiLabel.java
index 5bdb2530e..22d49cc75 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/ErrorWeightedVoteMultiLabel.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/ErrorWeightedVoteMultiLabel.java
@@ -20,8 +20,6 @@
 
 package moa.classifiers.rules.multilabel.core.voting;
 
-import java.util.List;
-
 import com.yahoo.labs.samoa.instances.Prediction;
 
 import moa.MOAObject;
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiLabelErrorMeasurer.java b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiLabelErrorMeasurer.java
index b96ddd2a7..1d393bf4b 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiLabelErrorMeasurer.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiLabelErrorMeasurer.java
@@ -1,13 +1,13 @@
 package moa.classifiers.rules.multilabel.errormeasurers;
 
+import com.github.javacliparser.FloatOption;
+import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.tasks.TaskMonitor;
 
-import com.github.javacliparser.FloatOption;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.Prediction;
-
 public abstract class AbstractMultiLabelErrorMeasurer  extends AbstractOptionHandler implements MultiTargetErrorMeasurer{
 
 	/**
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiTargetErrorMeasurer.java b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiTargetErrorMeasurer.java
index 5b2bc3be8..bb22ff469 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiTargetErrorMeasurer.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiTargetErrorMeasurer.java
@@ -1,8 +1,8 @@
 package moa.classifiers.rules.multilabel.errormeasurers;
 
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 public abstract class AbstractMultiTargetErrorMeasurer extends AbstractMultiLabelErrorMeasurer implements MultiLabelErrorMeasurer{
 
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/MultiLabelErrorMeasurer.java b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/MultiLabelErrorMeasurer.java
index 66259cfe6..9f280d765 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/MultiLabelErrorMeasurer.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/MultiLabelErrorMeasurer.java
@@ -1,7 +1,7 @@
 package moa.classifiers.rules.multilabel.errormeasurers;
 
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.options.OptionHandler;
 
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/RootMeanSquaredErrorMT.java b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/RootMeanSquaredErrorMT.java
index cab1cab93..08d5d319d 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/RootMeanSquaredErrorMT.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/RootMeanSquaredErrorMT.java
@@ -1,8 +1,5 @@
 package moa.classifiers.rules.multilabel.errormeasurers;
 
-import moa.core.ObjectRepository;
-import moa.tasks.TaskMonitor;
-
 import com.yahoo.labs.samoa.instances.Prediction;
 
 public class RootMeanSquaredErrorMT extends AbstractMultiTargetErrorMeasurer {
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/AdaptiveMultiTargetRegressor.java b/moa/src/main/java/moa/classifiers/rules/multilabel/functions/AdaptiveMultiTargetRegressor.java
index 1f0adf4b4..7541446ac 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/AdaptiveMultiTargetRegressor.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/functions/AdaptiveMultiTargetRegressor.java
@@ -1,16 +1,15 @@
 package moa.classifiers.rules.multilabel.functions;
 
+import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.classifiers.AbstractMultiLabelLearner;
 import moa.classifiers.MultiTargetRegressor;
 import moa.classifiers.rules.multilabel.errormeasurers.AbstractMultiTargetErrorMeasurer;
 import moa.classifiers.rules.multilabel.errormeasurers.MultiTargetErrorMeasurer;
 import moa.core.Measurement;
-import moa.learners.Learner;
 import moa.options.ClassOption;
 
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.Prediction;
-
 public class AdaptiveMultiTargetRegressor extends AbstractMultiLabelLearner
 implements MultiTargetRegressor, AMRulesFunction {
 
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/MultiLabelTargetMeanRegressor.java b/moa/src/main/java/moa/classifiers/rules/multilabel/functions/MultiLabelTargetMeanRegressor.java
index ce744a59f..4a80a690d 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/MultiLabelTargetMeanRegressor.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/functions/MultiLabelTargetMeanRegressor.java
@@ -4,7 +4,6 @@
 
 import moa.classifiers.MultiTargetRegressor;
 import moa.classifiers.multitarget.BasicMultiTargetRegressor;
-import moa.classifiers.rules.functions.Perceptron;
 import moa.classifiers.rules.functions.TargetMean;
 import moa.options.ClassOption;
 
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/meta/MultiLabelRandomAMRules.java b/moa/src/main/java/moa/classifiers/rules/multilabel/meta/MultiLabelRandomAMRules.java
index 7c08a3eed..8085c13bb 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/meta/MultiLabelRandomAMRules.java
+++ b/moa/src/main/java/moa/classifiers/rules/multilabel/meta/MultiLabelRandomAMRules.java
@@ -1,9 +1,15 @@
 package moa.classifiers.rules.multilabel.meta;
 
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.classifiers.AbstractMultiLabelLearner;
 import moa.classifiers.MultiTargetRegressor;
-import moa.classifiers.rules.AbstractAMRules;
-import moa.classifiers.rules.core.voting.ErrorWeightedVote;
 import moa.classifiers.rules.multilabel.AMRulesMultiLabelLearner;
 import moa.classifiers.rules.multilabel.core.voting.ErrorWeightedVoteMultiLabel;
 import moa.classifiers.rules.multilabel.core.voting.UniformWeightedVoteMultiLabel;
@@ -13,14 +19,6 @@
 import moa.core.MiscUtils;
 import moa.options.ClassOption;
 
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.Prediction;
-
 public class MultiLabelRandomAMRules extends AbstractMultiLabelLearner
 implements MultiTargetRegressor {
 
diff --git a/moa/src/main/java/moa/classifiers/trees/AdaHoeffdingOptionTree.java b/moa/src/main/java/moa/classifiers/trees/AdaHoeffdingOptionTree.java
index 6e6db6109..2cefc4f0e 100644
--- a/moa/src/main/java/moa/classifiers/trees/AdaHoeffdingOptionTree.java
+++ b/moa/src/main/java/moa/classifiers/trees/AdaHoeffdingOptionTree.java
@@ -19,9 +19,10 @@
  */
 package moa.classifiers.trees;
 
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.bayes.NaiveBayes;
 import moa.core.Utils;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Adaptive decision option tree for streaming data with adaptive Naive
diff --git a/moa/src/main/java/moa/classifiers/trees/DecisionStump.java b/moa/src/main/java/moa/classifiers/trees/DecisionStump.java
index 10f4e0fa0..705c73348 100644
--- a/moa/src/main/java/moa/classifiers/trees/DecisionStump.java
+++ b/moa/src/main/java/moa/classifiers/trees/DecisionStump.java
@@ -21,6 +21,8 @@
 
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.core.AttributeSplitSuggestion;
 import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
@@ -31,7 +33,6 @@
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.options.ClassOption;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Decision trees of one level.<br />
diff --git a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java b/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
index 5ca826b98..b41e55c5a 100644
--- a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
+++ b/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
@@ -25,24 +25,24 @@
 import java.util.LinkedList;
 import java.util.List;
 
-import com.yahoo.labs.samoa.instances.Instance;
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
 
-import moa.options.ClassOption;
 import moa.AbstractMOAObject;
+import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Regressor;
 import moa.classifiers.core.AttributeSplitSuggestion;
 import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
 import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.classifiers.AbstractClassifier;
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.SizeOf;
 import moa.core.StringUtils;
+import moa.options.ClassOption;
 
 /*
  * Implementation of FIMTDD, regression and model trees for data streams.
@@ -159,8 +159,8 @@ public void copyStatistics(Node node) {
 			sumOfAbsErrors = node.sumOfAbsErrors;
 		}
 
-		public int calcByteSize() {
-			return (int) SizeOf.fullSizeOf(this);
+		public long calcByteSize() {
+			return SizeOf.sizeOf(this) + (originalNode == null && alternateTree != null ? alternateTree.calcByteSize() : 0);
 		}
 
 		/**
@@ -259,6 +259,14 @@ public LeafNode(FIMTDD tree) {
 			sumOfAbsErrors = 0;
 		}
 
+		public long calcByteSize() {
+			long size = super.calcByteSize();
+			if (tree.buildingModelTree())
+				size += learningModel.calcByteSize();
+			size += SizeOf.fullSizeOf(attributeObservers);
+			return size;
+		}
+		
 		public void setChild(int parentBranch, Node node) {
 		}
 
@@ -416,6 +424,13 @@ public abstract static class InnerNode extends Node {
 		public InnerNode(FIMTDD tree) {
 			super(tree);
 		}
+		
+		public long calcByteSize() {
+			long size = super.calcByteSize();
+			for (Node child : children)
+				size += child.calcByteSize();
+			return size;
+		}
 
 		public int numChildren() {
 			return children.size();
@@ -505,6 +520,12 @@ public SplitNode(InstanceConditionalTest splitTest, FIMTDD tree) {
 			super(tree);
 			this.splitTest = splitTest;
 		}
+		
+		public long calcByteSize() {
+			long size = super.calcByteSize();
+			size += SizeOf.sizeOf(splitTest);
+			return size;
+		}
 
 		public int instanceChildIndex(Instance inst) {
 			return splitTest.branchForInstance(inst);
@@ -561,6 +582,10 @@ public FIMTDDPerceptron(FIMTDD tree) {
 
 		}
 
+		public long calcByteSize() {
+			return SizeOf.sizeOf(this);
+		}
+		
 		public void initializeWeights() {
 			weightAttribute = new double[tree.getModelContext().numInputAttributes()+1];
 			instancesSeen = 0;
@@ -710,8 +735,15 @@ protected Measurement[] getModelMeasurementsImpl() {
 		};
 	}
 
-	public int calcByteSize() {
-		return (int) SizeOf.fullSizeOf(this);
+	@Override
+	public long measureByteSize() {
+		return calcByteSize();
+	}
+	
+	public long calcByteSize() {
+		long size = (long) (SizeOf.sizeOf(this)) + this.treeRoot.calcByteSize();
+		size += (long) (SizeOf.sizeOf(this.sumOfAttrValues)) + (int) (SizeOf.sizeOf(this.sumOfAttrSquares));
+		return size;
 	}
 
 	public double[] getVotesForInstance(Instance inst) {
diff --git a/moa/src/main/java/moa/classifiers/trees/HoeffdingAdaptiveTree.java b/moa/src/main/java/moa/classifiers/trees/HoeffdingAdaptiveTree.java
index dd1691fd2..c68657bc0 100644
--- a/moa/src/main/java/moa/classifiers/trees/HoeffdingAdaptiveTree.java
+++ b/moa/src/main/java/moa/classifiers/trees/HoeffdingAdaptiveTree.java
@@ -22,13 +22,15 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Random;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.bayes.NaiveBayes;
 import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
 import moa.classifiers.core.driftdetection.ADWIN;
 import moa.core.DoubleVector;
 import moa.core.MiscUtils;
 import moa.core.Utils;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Hoeffding Adaptive Tree for evolving data streams.
diff --git a/moa/src/main/java/moa/classifiers/trees/HoeffdingOptionTree.java b/moa/src/main/java/moa/classifiers/trees/HoeffdingOptionTree.java
index e4dd74b0a..3ba18b87d 100644
--- a/moa/src/main/java/moa/classifiers/trees/HoeffdingOptionTree.java
+++ b/moa/src/main/java/moa/classifiers/trees/HoeffdingOptionTree.java
@@ -28,11 +28,14 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Set;
+
 import com.github.javacliparser.FileOption;
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.AbstractMOAObject;
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.bayes.NaiveBayes;
@@ -51,7 +54,6 @@
 import moa.core.StringUtils;
 import moa.core.Utils;
 import moa.options.ClassOption;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Hoeffding Option Tree.
@@ -612,8 +614,8 @@ public void disableAttribute(int attIndex) {
 
     protected int maxPredictionPaths;
 
-    public int calcByteSize() {
-        int size = (int) SizeOf.sizeOf(this);
+    public long calcByteSize() {
+        long size = SizeOf.sizeOf(this);
         if (this.treeRoot != null) {
             size += this.treeRoot.calcByteSizeIncludingSubtree();
         }
@@ -621,7 +623,7 @@ public int calcByteSize() {
     }
 
     @Override
-    public int measureByteSize() {
+    public long measureByteSize() {
         return calcByteSize();
     }
 
@@ -1035,7 +1037,7 @@ public void estimateModelByteSizes() {
             this.inactiveLeafByteSizeEstimate = (double) totalInactiveSize
                     / this.inactiveLeafNodeCount;
         }
-        int actualModelSize = this.measureByteSize();
+        long actualModelSize = this.measureByteSize();
         double estimatedModelSize = (this.activeLeafNodeCount
                 * this.activeLeafByteSizeEstimate + this.inactiveLeafNodeCount
                 * this.inactiveLeafByteSizeEstimate);
diff --git a/moa/src/main/java/moa/classifiers/trees/HoeffdingTree.java b/moa/src/main/java/moa/classifiers/trees/HoeffdingTree.java
index c6729b9d8..d8d64f17c 100644
--- a/moa/src/main/java/moa/classifiers/trees/HoeffdingTree.java
+++ b/moa/src/main/java/moa/classifiers/trees/HoeffdingTree.java
@@ -25,10 +25,13 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Set;
+
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.AbstractMOAObject;
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.bayes.NaiveBayes;
@@ -46,7 +49,6 @@
 import moa.core.StringUtils;
 import moa.core.Utils;
 import moa.options.ClassOption;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Hoeffding Tree or VFDT.
@@ -149,7 +151,7 @@ public String getPurposeString() {
             't', "Threshold below which a split will be forced to break ties.",
             0.05, 0.0, 1.0);
 
-public FlagOption binarySplitsOption = new FlagOption("binarySplits", 'b',
+    public FlagOption binarySplitsOption = new FlagOption("binarySplits", 'b',
         "Only allow binary splits.");
 
     public FlagOption stopMemManagementOption = new FlagOption(
@@ -479,8 +481,8 @@ public void disableAttribute(int attIndex) {
 
     protected boolean growthAllowed;
 
-    public int calcByteSize() {
-        int size = (int) SizeOf.sizeOf(this);
+    public long calcByteSize() {
+        long size = SizeOf.sizeOf(this);
         if (this.treeRoot != null) {
             size += this.treeRoot.calcByteSizeIncludingSubtree();
         }
@@ -488,7 +490,7 @@ public int calcByteSize() {
     }
 
     @Override
-    public int measureByteSize() {
+    public long measureByteSize() {
         return calcByteSize();
     }
 
@@ -764,7 +766,7 @@ public void estimateModelByteSizes() {
             this.inactiveLeafByteSizeEstimate = (double) totalInactiveSize
                     / this.inactiveLeafNodeCount;
         }
-        int actualModelSize = this.measureByteSize();
+        long actualModelSize = this.measureByteSize();
         double estimatedModelSize = (this.activeLeafNodeCount
                 * this.activeLeafByteSizeEstimate + this.inactiveLeafNodeCount
                 * this.inactiveLeafByteSizeEstimate);
diff --git a/moa/src/main/java/moa/classifiers/trees/HoeffdingTreeClassifLeaves.java b/moa/src/main/java/moa/classifiers/trees/HoeffdingTreeClassifLeaves.java
index 99e409f46..47587b236 100644
--- a/moa/src/main/java/moa/classifiers/trees/HoeffdingTreeClassifLeaves.java
+++ b/moa/src/main/java/moa/classifiers/trees/HoeffdingTreeClassifLeaves.java
@@ -22,12 +22,14 @@
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Set;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.Classifier;
 import moa.classifiers.core.AttributeSplitSuggestion;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
 import moa.classifiers.trees.HoeffdingTree;
 import moa.options.ClassOption;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Hoeffding Tree that have a classifier at the leaves.
diff --git a/moa/src/main/java/moa/classifiers/trees/LimAttHoeffdingTree.java b/moa/src/main/java/moa/classifiers/trees/LimAttHoeffdingTree.java
index 05b02df91..6c0b669a6 100644
--- a/moa/src/main/java/moa/classifiers/trees/LimAttHoeffdingTree.java
+++ b/moa/src/main/java/moa/classifiers/trees/LimAttHoeffdingTree.java
@@ -19,10 +19,11 @@
  */
 package moa.classifiers.trees;
 
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.bayes.NaiveBayes;
 import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
 import moa.core.Utils;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Hoeffding decision trees with a restricted number of attributes for data
diff --git a/moa/src/main/java/moa/classifiers/trees/ORTO.java b/moa/src/main/java/moa/classifiers/trees/ORTO.java
index 34108ef59..f31e2b480 100644
--- a/moa/src/main/java/moa/classifiers/trees/ORTO.java
+++ b/moa/src/main/java/moa/classifiers/trees/ORTO.java
@@ -20,22 +20,21 @@
 
 package moa.classifiers.trees;
 
-import java.util.Stack;
 import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Stack;
 
-import com.yahoo.labs.samoa.instances.Instance;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
 
 import moa.classifiers.Regressor;
 import moa.classifiers.core.AttributeSplitSuggestion;
 import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
 import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
 import moa.classifiers.core.splitcriteria.SplitCriterion;
-
 import moa.core.AutoExpandVector;
 import moa.core.Measurement;
 import moa.core.StringUtils;
@@ -100,7 +99,7 @@ public static class OptionNode extends InnerNode {
 		public OptionNode(FIMTDD tree) {
 			super(tree);
 		}
-
+		
 		public void resetFF() {
 			optionFFSSL = new double[children.size()];
 			optionFFSeen = new double[children.size()];
diff --git a/moa/src/main/java/moa/classifiers/trees/RandomHoeffdingTree.java b/moa/src/main/java/moa/classifiers/trees/RandomHoeffdingTree.java
index f4b86a209..884c285b3 100644
--- a/moa/src/main/java/moa/classifiers/trees/RandomHoeffdingTree.java
+++ b/moa/src/main/java/moa/classifiers/trees/RandomHoeffdingTree.java
@@ -19,10 +19,11 @@
  */
 package moa.classifiers.trees;
 
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.bayes.NaiveBayes;
 import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
 import moa.core.Utils;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Random decision trees for data streams.
diff --git a/moa/src/main/java/moa/cluster/CFCluster.java b/moa/src/main/java/moa/cluster/CFCluster.java
index 727b0c567..bd6e83b33 100644
--- a/moa/src/main/java/moa/cluster/CFCluster.java
+++ b/moa/src/main/java/moa/cluster/CFCluster.java
@@ -20,6 +20,7 @@
 
 package moa.cluster;
 import java.util.Arrays;
+
 import com.yahoo.labs.samoa.instances.Instance;
 
 /* micro cluster, as defined by Aggarwal et al, On Clustering Massive Data Streams: A Summarization Praradigm 
diff --git a/moa/src/main/java/moa/cluster/Cluster.java b/moa/src/main/java/moa/cluster/Cluster.java
index 42c175c24..caab641ed 100644
--- a/moa/src/main/java/moa/cluster/Cluster.java
+++ b/moa/src/main/java/moa/cluster/Cluster.java
@@ -25,9 +25,11 @@
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Random;
-import moa.AbstractMOAObject;
+
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.AbstractMOAObject;
+
 public abstract class Cluster extends AbstractMOAObject {
 
 	private static final long serialVersionUID = 1L;
diff --git a/moa/src/main/java/moa/cluster/Clustering.java b/moa/src/main/java/moa/cluster/Clustering.java
index 079e1b3ef..afc47799d 100644
--- a/moa/src/main/java/moa/cluster/Clustering.java
+++ b/moa/src/main/java/moa/cluster/Clustering.java
@@ -28,11 +28,13 @@
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
+
+import com.yahoo.labs.samoa.instances.Attribute;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.AbstractMOAObject;
 import moa.core.AutoExpandVector;
 import moa.gui.visualization.DataPoint;
-import com.yahoo.labs.samoa.instances.Attribute;
-import com.yahoo.labs.samoa.instances.Instance;
 
 public class Clustering extends AbstractMOAObject{
 
diff --git a/moa/src/main/java/moa/cluster/SphereCluster.java b/moa/src/main/java/moa/cluster/SphereCluster.java
index 0991500dc..533ba108e 100644
--- a/moa/src/main/java/moa/cluster/SphereCluster.java
+++ b/moa/src/main/java/moa/cluster/SphereCluster.java
@@ -23,6 +23,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Random;
+
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 
diff --git a/moa/src/main/java/moa/clusterers/AbstractClusterer.java b/moa/src/main/java/moa/clusterers/AbstractClusterer.java
index a8f23f48e..3e32c4d50 100644
--- a/moa/src/main/java/moa/clusterers/AbstractClusterer.java
+++ b/moa/src/main/java/moa/clusterers/AbstractClusterer.java
@@ -22,19 +22,19 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Random;
-import moa.cluster.Clustering;
 
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
+
+import moa.cluster.Clustering;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
 import moa.core.StringUtils;
 import moa.gui.AWTRenderer;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public abstract class AbstractClusterer extends AbstractOptionHandler
 		implements Clusterer {
diff --git a/moa/src/main/java/moa/clusterers/ClusterGenerator.java b/moa/src/main/java/moa/clusterers/ClusterGenerator.java
index 2c1a5cd63..4ad2e09f8 100644
--- a/moa/src/main/java/moa/clusterers/ClusterGenerator.java
+++ b/moa/src/main/java/moa/clusterers/ClusterGenerator.java
@@ -23,13 +23,15 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Random;
+
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.Clustering;
 import moa.cluster.SphereCluster;
 import moa.core.Measurement;
 import moa.gui.visualization.DataPoint;
-import com.yahoo.labs.samoa.instances.Instance;
 
 public class ClusterGenerator extends AbstractClusterer{
 
diff --git a/moa/src/main/java/moa/clusterers/Clusterer.java b/moa/src/main/java/moa/clusterers/Clusterer.java
index b018b421f..b7badff51 100644
--- a/moa/src/main/java/moa/clusterers/Clusterer.java
+++ b/moa/src/main/java/moa/clusterers/Clusterer.java
@@ -19,13 +19,14 @@
  */
 package moa.clusterers;
 
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.MOAObject;
 import moa.cluster.Clustering;
 import moa.core.Measurement;
 import moa.gui.AWTRenderable;
 import moa.options.OptionHandler;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public interface Clusterer extends MOAObject, OptionHandler, AWTRenderable {
 
diff --git a/moa/src/main/java/moa/clusterers/CobWeb.java b/moa/src/main/java/moa/clusterers/CobWeb.java
index 03e34a5f9..6f315ba9e 100644
--- a/moa/src/main/java/moa/clusterers/CobWeb.java
+++ b/moa/src/main/java/moa/clusterers/CobWeb.java
@@ -21,16 +21,16 @@
 
 import java.io.Serializable;
 
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import moa.cluster.Clustering;
 import moa.cluster.SphereCluster;
+import moa.core.FastVector;
 import moa.core.Measurement;
 import moa.core.StringUtils;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import moa.core.FastVector;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import weka.core.AttributeStats;
 import weka.experiment.Stats;
 import weka.filters.unsupervised.attribute.Add;
diff --git a/moa/src/main/java/moa/clusterers/KMeans.java b/moa/src/main/java/moa/clusterers/KMeans.java
index b7014b5f7..d509f26a7 100644
--- a/moa/src/main/java/moa/clusterers/KMeans.java
+++ b/moa/src/main/java/moa/clusterers/KMeans.java
@@ -22,6 +22,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+
 import moa.cluster.CFCluster;
 import moa.cluster.Cluster;
 import moa.cluster.Clustering;
diff --git a/moa/src/main/java/moa/clusterers/WekaClusteringAlgorithm.java b/moa/src/main/java/moa/clusterers/WekaClusteringAlgorithm.java
index 978290119..ef5ddaeda 100644
--- a/moa/src/main/java/moa/clusterers/WekaClusteringAlgorithm.java
+++ b/moa/src/main/java/moa/clusterers/WekaClusteringAlgorithm.java
@@ -21,21 +21,22 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import moa.cluster.Clustering;
-import moa.core.AutoClassDiscovery;
-import moa.core.AutoExpandVector;
-import moa.core.Measurement;
-import moa.options.ClassOption;
+
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.MultiChoiceOption;
 import com.github.javacliparser.StringOption;
-import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
 
+import moa.cluster.Clustering;
+import moa.core.AutoClassDiscovery;
+import moa.core.AutoExpandVector;
+import moa.core.FastVector;
+import moa.core.Measurement;
+import moa.options.ClassOption;
 import weka.core.Utils;
 
 public class WekaClusteringAlgorithm extends AbstractClusterer {
diff --git a/moa/src/main/java/moa/clusterers/clustream/Clustream.java b/moa/src/main/java/moa/clusterers/clustream/Clustream.java
index 85edb1c81..b10a2e029 100644
--- a/moa/src/main/java/moa/clusterers/clustream/Clustream.java
+++ b/moa/src/main/java/moa/clusterers/clustream/Clustream.java
@@ -24,14 +24,16 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Random;
+
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.Cluster;
 import moa.cluster.Clustering;
 import moa.cluster.SphereCluster;
 import moa.clusterers.AbstractClusterer;
 import moa.core.Measurement;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.DenseInstance;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /** Citation: CluStream: Charu C. Aggarwal, Jiawei Han, Jianyong Wang, Philip S. Yu:
  * A Framework for Clustering Evolving Data Streams. VLDB 2003: 81-92
diff --git a/moa/src/main/java/moa/clusterers/clustream/ClustreamKernel.java b/moa/src/main/java/moa/clusterers/clustream/ClustreamKernel.java
index 83ae0324d..73ef8a6a7 100644
--- a/moa/src/main/java/moa/clusterers/clustream/ClustreamKernel.java
+++ b/moa/src/main/java/moa/clusterers/clustream/ClustreamKernel.java
@@ -20,10 +20,11 @@
 package moa.clusterers.clustream;
 
 import java.util.ArrayList;
-import java.util.Random;
-import moa.cluster.CFCluster;
+
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.cluster.CFCluster;
+
 public class ClustreamKernel extends CFCluster {
 	private static final long serialVersionUID = 1L;
 
diff --git a/moa/src/main/java/moa/clusterers/clustream/WithKmeans.java b/moa/src/main/java/moa/clusterers/clustream/WithKmeans.java
index 281c02813..175e1137e 100644
--- a/moa/src/main/java/moa/clusterers/clustream/WithKmeans.java
+++ b/moa/src/main/java/moa/clusterers/clustream/WithKmeans.java
@@ -32,15 +32,16 @@
 import java.util.List;
 import java.util.Random;
 
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.CFCluster;
 import moa.cluster.Cluster;
 import moa.cluster.Clustering;
 import moa.cluster.SphereCluster;
 import moa.clusterers.AbstractClusterer;
 import moa.core.Measurement;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.DenseInstance;
-import com.yahoo.labs.samoa.instances.Instance;
 
 public class WithKmeans extends AbstractClusterer {
 	
diff --git a/moa/src/main/java/moa/clusterers/clustree/ClusKernel.java b/moa/src/main/java/moa/clusterers/clustree/ClusKernel.java
index 025f86f92..fdddc6f31 100644
--- a/moa/src/main/java/moa/clusterers/clustree/ClusKernel.java
+++ b/moa/src/main/java/moa/clusterers/clustree/ClusKernel.java
@@ -20,11 +20,12 @@
 
 package moa.clusterers.clustree;
 
-import moa.clusterers.clustree.util.*;
 import java.util.Arrays;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.CFCluster;
 import moa.cluster.Cluster;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Representation of an Entry in the tree
diff --git a/moa/src/main/java/moa/clusterers/clustree/ClusTree.java b/moa/src/main/java/moa/clusterers/clustree/ClusTree.java
index 1b5891461..034e182ad 100644
--- a/moa/src/main/java/moa/clusterers/clustree/ClusTree.java
+++ b/moa/src/main/java/moa/clusterers/clustree/ClusTree.java
@@ -21,15 +21,22 @@
 package moa.clusterers.clustree;
 
 import java.util.ArrayList;
-
 import java.util.LinkedList;
-import moa.clusterers.clustree.util.*;
+
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.Clustering;
 import moa.clusterers.AbstractClusterer;
+import moa.clusterers.clustree.util.Budget;
+import moa.clusterers.clustree.util.SimpleBudget;
 import moa.core.Measurement;
+<<<<<<< c4a46917f06a4f4c3c08e67d06f6762cca1b47f9
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.FlagOption;
 import com.yahoo.labs.samoa.instances.Instance;
+=======
+>>>>>>> Instances rework, new iSOUPTree models and import cleanup
 
 /**
  * Citation: ClusTree: Philipp Kranen, Ira Assent, Corinna Baldauf, Thomas Seidl:
diff --git a/moa/src/main/java/moa/clusterers/denstream/MicroCluster.java b/moa/src/main/java/moa/clusterers/denstream/MicroCluster.java
index 4b98a5606..cf6c25dba 100644
--- a/moa/src/main/java/moa/clusterers/denstream/MicroCluster.java
+++ b/moa/src/main/java/moa/clusterers/denstream/MicroCluster.java
@@ -19,9 +19,10 @@
  */
 package moa.clusterers.denstream;
 
-import moa.cluster.CFCluster;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.cluster.CFCluster;
+
 public class MicroCluster extends CFCluster {
 
     private long lastEditT = -1;
diff --git a/moa/src/main/java/moa/clusterers/denstream/WithDBSCAN.java b/moa/src/main/java/moa/clusterers/denstream/WithDBSCAN.java
index fbc55d462..f243d664a 100644
--- a/moa/src/main/java/moa/clusterers/denstream/WithDBSCAN.java
+++ b/moa/src/main/java/moa/clusterers/denstream/WithDBSCAN.java
@@ -26,15 +26,16 @@
 
 import java.util.ArrayList;
 
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.Cluster;
 import moa.cluster.Clustering;
 import moa.clusterers.AbstractClusterer;
 import moa.clusterers.macro.dbscan.DBScan;
 import moa.core.Measurement;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.DenseInstance;
-import com.yahoo.labs.samoa.instances.Instance;
 
 public class WithDBSCAN extends AbstractClusterer {
 	
diff --git a/moa/src/main/java/moa/clusterers/macro/NonConvexCluster.java b/moa/src/main/java/moa/clusterers/macro/NonConvexCluster.java
index d264f8564..e132b69d2 100644
--- a/moa/src/main/java/moa/clusterers/macro/NonConvexCluster.java
+++ b/moa/src/main/java/moa/clusterers/macro/NonConvexCluster.java
@@ -26,9 +26,10 @@
 import java.util.List;
 import java.util.Vector;
 
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.CFCluster;
 import moa.cluster.Clustering;
-import com.yahoo.labs.samoa.instances.Instance;
 
 public class NonConvexCluster extends CFCluster implements IDenseMacroCluster {
 
diff --git a/moa/src/main/java/moa/clusterers/outliers/AbstractC/AbstractC.java b/moa/src/main/java/moa/clusterers/outliers/AbstractC/AbstractC.java
index 4b67c3e78..9ac25bf0a 100644
--- a/moa/src/main/java/moa/clusterers/outliers/AbstractC/AbstractC.java
+++ b/moa/src/main/java/moa/clusterers/outliers/AbstractC/AbstractC.java
@@ -21,13 +21,15 @@
 package moa.clusterers.outliers.AbstractC;
 
 import java.util.Vector;
-import moa.clusterers.outliers.AbstractC.ISBIndex.ISBNode;
-import moa.clusterers.outliers.AbstractC.ISBIndex.ISBSearchResult;
+
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.clusterers.outliers.AbstractC.ISBIndex.ISBNode;
+import moa.clusterers.outliers.AbstractC.ISBIndex.ISBSearchResult;
+
 //The algorithm is presented in:
 //D. Yang, E. Rundensteiner, and M. Ward.
 //Neighbor-based pattern detection for windows over streaming data. 
diff --git a/moa/src/main/java/moa/clusterers/outliers/AbstractC/AbstractCBase.java b/moa/src/main/java/moa/clusterers/outliers/AbstractC/AbstractCBase.java
index 6e39b8360..67150fa8b 100644
--- a/moa/src/main/java/moa/clusterers/outliers/AbstractC/AbstractCBase.java
+++ b/moa/src/main/java/moa/clusterers/outliers/AbstractC/AbstractCBase.java
@@ -23,8 +23,9 @@
 
 import java.util.ArrayList;
 import java.util.Vector;
-import moa.clusterers.outliers.AbstractC.ISBIndex.ISBNode;
+
 import moa.clusterers.outliers.MyBaseOutlierDetector;
+import moa.clusterers.outliers.AbstractC.ISBIndex.ISBNode;
 
 public abstract class AbstractCBase extends MyBaseOutlierDetector {    
     protected static final Long FIRST_OBJ_ID = 1L;
diff --git a/moa/src/main/java/moa/clusterers/outliers/AbstractC/ISBIndex.java b/moa/src/main/java/moa/clusterers/outliers/AbstractC/ISBIndex.java
index 9a0be6f04..26c4292ad 100644
--- a/moa/src/main/java/moa/clusterers/outliers/AbstractC/ISBIndex.java
+++ b/moa/src/main/java/moa/clusterers/outliers/AbstractC/ISBIndex.java
@@ -28,6 +28,7 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.Vector;
+
 import com.yahoo.labs.samoa.instances.Instance;
 
 
diff --git a/moa/src/main/java/moa/clusterers/outliers/AbstractC/MyMTree.java b/moa/src/main/java/moa/clusterers/outliers/AbstractC/MyMTree.java
index af419a92f..5a2f5d531 100644
--- a/moa/src/main/java/moa/clusterers/outliers/AbstractC/MyMTree.java
+++ b/moa/src/main/java/moa/clusterers/outliers/AbstractC/MyMTree.java
@@ -22,6 +22,7 @@
 package moa.clusterers.outliers.AbstractC;
 
 import java.util.Set;
+
 import moa.clusterers.outliers.utils.mtree.ComposedSplitFunction;
 import moa.clusterers.outliers.utils.mtree.DistanceFunction;
 import moa.clusterers.outliers.utils.mtree.DistanceFunctions;
diff --git a/moa/src/main/java/moa/clusterers/outliers/AbstractC/Test.java b/moa/src/main/java/moa/clusterers/outliers/AbstractC/Test.java
index 430a2c82f..46cc09f59 100644
--- a/moa/src/main/java/moa/clusterers/outliers/AbstractC/Test.java
+++ b/moa/src/main/java/moa/clusterers/outliers/AbstractC/Test.java
@@ -21,9 +21,10 @@
 
 package moa.clusterers.outliers.AbstractC;
 
-import moa.streams.clustering.RandomRBFGeneratorEvents;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.streams.clustering.RandomRBFGeneratorEvents;
+
 public class Test {    
     public static void main(String[] args) throws Exception 
     {
diff --git a/moa/src/main/java/moa/clusterers/outliers/Angiulli/ApproxSTORM.java b/moa/src/main/java/moa/clusterers/outliers/Angiulli/ApproxSTORM.java
index 4eb279806..7b965ee9c 100644
--- a/moa/src/main/java/moa/clusterers/outliers/Angiulli/ApproxSTORM.java
+++ b/moa/src/main/java/moa/clusterers/outliers/Angiulli/ApproxSTORM.java
@@ -26,12 +26,14 @@
 import java.util.Random;
 import java.util.Set;
 import java.util.Vector;
-import moa.clusterers.outliers.Angiulli.ISBIndex.ISBNode;
-import moa.clusterers.outliers.Angiulli.ISBIndex.ISBSearchResult;
+
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.clusterers.outliers.Angiulli.ISBIndex.ISBNode;
+import moa.clusterers.outliers.Angiulli.ISBIndex.ISBSearchResult;
+
 
 public class ApproxSTORM extends STORMBase {
     public class ISBNodeAppr extends ISBNode {
diff --git a/moa/src/main/java/moa/clusterers/outliers/Angiulli/ExactSTORM.java b/moa/src/main/java/moa/clusterers/outliers/Angiulli/ExactSTORM.java
index 7bcd76f2f..652632ae1 100644
--- a/moa/src/main/java/moa/clusterers/outliers/Angiulli/ExactSTORM.java
+++ b/moa/src/main/java/moa/clusterers/outliers/Angiulli/ExactSTORM.java
@@ -24,12 +24,14 @@
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.Vector;
-import moa.clusterers.outliers.Angiulli.ISBIndex.ISBNode;
-import moa.clusterers.outliers.Angiulli.ISBIndex.ISBSearchResult;
+
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.clusterers.outliers.Angiulli.ISBIndex.ISBNode;
+import moa.clusterers.outliers.Angiulli.ISBIndex.ISBSearchResult;
+
 
 // The algorithm is presented in "Distance-based outlier queries in data streams: the novel task and algorithms.
 //Data Mining and Knowledge Discovery, 20(2):290–324,2010.
diff --git a/moa/src/main/java/moa/clusterers/outliers/Angiulli/ISBIndex.java b/moa/src/main/java/moa/clusterers/outliers/Angiulli/ISBIndex.java
index c92781052..47bb87b5c 100644
--- a/moa/src/main/java/moa/clusterers/outliers/Angiulli/ISBIndex.java
+++ b/moa/src/main/java/moa/clusterers/outliers/Angiulli/ISBIndex.java
@@ -25,6 +25,7 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.Vector;
+
 import com.yahoo.labs.samoa.instances.Instance;
 
 
diff --git a/moa/src/main/java/moa/clusterers/outliers/Angiulli/MyMTree.java b/moa/src/main/java/moa/clusterers/outliers/Angiulli/MyMTree.java
index e71e17623..96ba2625c 100644
--- a/moa/src/main/java/moa/clusterers/outliers/Angiulli/MyMTree.java
+++ b/moa/src/main/java/moa/clusterers/outliers/Angiulli/MyMTree.java
@@ -21,6 +21,7 @@
 package moa.clusterers.outliers.Angiulli;
 
 import java.util.Set;
+
 import moa.clusterers.outliers.utils.mtree.ComposedSplitFunction;
 import moa.clusterers.outliers.utils.mtree.DistanceFunction;
 import moa.clusterers.outliers.utils.mtree.DistanceFunctions;
diff --git a/moa/src/main/java/moa/clusterers/outliers/Angiulli/STORMBase.java b/moa/src/main/java/moa/clusterers/outliers/Angiulli/STORMBase.java
index 7cc8b4f80..d1e2cbf28 100644
--- a/moa/src/main/java/moa/clusterers/outliers/Angiulli/STORMBase.java
+++ b/moa/src/main/java/moa/clusterers/outliers/Angiulli/STORMBase.java
@@ -21,10 +21,12 @@
 package moa.clusterers.outliers.Angiulli;
 
 import java.util.Vector;
-import moa.clusterers.outliers.Angiulli.ISBIndex.ISBNode;
-import moa.clusterers.outliers.MyBaseOutlierDetector;
+
 import com.github.javacliparser.FlagOption;
 
+import moa.clusterers.outliers.MyBaseOutlierDetector;
+import moa.clusterers.outliers.Angiulli.ISBIndex.ISBNode;
+
 public abstract class STORMBase extends MyBaseOutlierDetector {   
     public FlagOption waitWinFullOption = new FlagOption("waitWinFull", 'a', "Output outliers when windows is full.");
      
diff --git a/moa/src/main/java/moa/clusterers/outliers/Angiulli/Test.java b/moa/src/main/java/moa/clusterers/outliers/Angiulli/Test.java
index 4921d99f7..dc6de05d5 100644
--- a/moa/src/main/java/moa/clusterers/outliers/Angiulli/Test.java
+++ b/moa/src/main/java/moa/clusterers/outliers/Angiulli/Test.java
@@ -20,9 +20,10 @@
 
 package moa.clusterers.outliers.Angiulli;
 
-import moa.streams.clustering.RandomRBFGeneratorEvents;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.streams.clustering.RandomRBFGeneratorEvents;
+
 
 public class Test {    
     public static void main(String[] args) throws Exception 
diff --git a/moa/src/main/java/moa/clusterers/outliers/AnyOut/AnyOut.java b/moa/src/main/java/moa/clusterers/outliers/AnyOut/AnyOut.java
index 6086e6964..16e4a0f45 100644
--- a/moa/src/main/java/moa/clusterers/outliers/AnyOut/AnyOut.java
+++ b/moa/src/main/java/moa/clusterers/outliers/AnyOut/AnyOut.java
@@ -21,9 +21,11 @@
 
 package moa.clusterers.outliers.AnyOut;
 
+import java.util.ArrayList;
+
 import com.github.javacliparser.Options;
 import com.yahoo.labs.samoa.instances.Instance;
-import java.util.ArrayList;
+
 import moa.clusterers.outliers.MyBaseOutlierDetector;
 import moa.clusterers.outliers.AnyOut.util.DataObject;
 import moa.clusterers.outliers.AnyOut.util.DataSet;
diff --git a/moa/src/main/java/moa/clusterers/outliers/AnyOut/AnyOutCore.java b/moa/src/main/java/moa/clusterers/outliers/AnyOut/AnyOutCore.java
index a714f2d10..a56728cc8 100644
--- a/moa/src/main/java/moa/clusterers/outliers/AnyOut/AnyOutCore.java
+++ b/moa/src/main/java/moa/clusterers/outliers/AnyOut/AnyOutCore.java
@@ -21,12 +21,14 @@
 
 package moa.clusterers.outliers.AnyOut;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.DenseInstance;
-import java.util.ArrayList;
-import java.util.HashMap;
+
 import moa.clusterers.clustree.ClusKernel;
 import moa.clusterers.clustree.ClusTree;
 import moa.clusterers.clustree.Entry;
diff --git a/moa/src/main/java/moa/clusterers/outliers/MCOD/ISBIndex.java b/moa/src/main/java/moa/clusterers/outliers/MCOD/ISBIndex.java
index d151e92dd..047c964ff 100644
--- a/moa/src/main/java/moa/clusterers/outliers/MCOD/ISBIndex.java
+++ b/moa/src/main/java/moa/clusterers/outliers/MCOD/ISBIndex.java
@@ -30,6 +30,7 @@
 import java.util.Set;
 import java.util.TreeSet;
 import java.util.Vector;
+
 import com.yahoo.labs.samoa.instances.Instance;
 
 
diff --git a/moa/src/main/java/moa/clusterers/outliers/MCOD/MCOD.java b/moa/src/main/java/moa/clusterers/outliers/MCOD/MCOD.java
index 60ed3df4d..0d58e7b02 100644
--- a/moa/src/main/java/moa/clusterers/outliers/MCOD/MCOD.java
+++ b/moa/src/main/java/moa/clusterers/outliers/MCOD/MCOD.java
@@ -23,13 +23,15 @@
 import java.util.ArrayList;
 import java.util.TreeSet;
 import java.util.Vector;
-import moa.clusterers.outliers.MCOD.ISBIndex.ISBNode;
-import moa.clusterers.outliers.MCOD.ISBIndex.ISBNode.NodeType;
-import moa.clusterers.outliers.MCOD.ISBIndex.ISBSearchResult;
+
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.clusterers.outliers.MCOD.ISBIndex.ISBNode;
+import moa.clusterers.outliers.MCOD.ISBIndex.ISBNode.NodeType;
+import moa.clusterers.outliers.MCOD.ISBIndex.ISBSearchResult;
+
 
 //The algorithm is described in 
 // M. Kontaki, A. Gounaris, A. N. Papadopoulos, K. Tsichlas, and Y. Manolopoulos. 
diff --git a/moa/src/main/java/moa/clusterers/outliers/MCOD/MCODBase.java b/moa/src/main/java/moa/clusterers/outliers/MCOD/MCODBase.java
index 66548a726..94f7ba167 100644
--- a/moa/src/main/java/moa/clusterers/outliers/MCOD/MCODBase.java
+++ b/moa/src/main/java/moa/clusterers/outliers/MCOD/MCODBase.java
@@ -25,9 +25,10 @@
 import java.util.Set;
 import java.util.TreeSet;
 import java.util.Vector;
+
+import moa.clusterers.outliers.MyBaseOutlierDetector;
 import moa.clusterers.outliers.MCOD.ISBIndex.ISBNode;
 import moa.clusterers.outliers.MCOD.ISBIndex.ISBNode.NodeType;
-import moa.clusterers.outliers.MyBaseOutlierDetector;
 
 public abstract class MCODBase extends MyBaseOutlierDetector {    
     protected static class EventItem implements Comparable<EventItem> {
diff --git a/moa/src/main/java/moa/clusterers/outliers/MCOD/MTreeMicroClusters.java b/moa/src/main/java/moa/clusterers/outliers/MCOD/MTreeMicroClusters.java
index 575b42b63..42be983f2 100644
--- a/moa/src/main/java/moa/clusterers/outliers/MCOD/MTreeMicroClusters.java
+++ b/moa/src/main/java/moa/clusterers/outliers/MCOD/MTreeMicroClusters.java
@@ -21,6 +21,7 @@
 package moa.clusterers.outliers.MCOD;
 
 import java.util.Set;
+
 import moa.clusterers.outliers.utils.mtree.ComposedSplitFunction;
 import moa.clusterers.outliers.utils.mtree.DistanceFunction;
 import moa.clusterers.outliers.utils.mtree.DistanceFunctions;
diff --git a/moa/src/main/java/moa/clusterers/outliers/MCOD/MTreeStreamObjects.java b/moa/src/main/java/moa/clusterers/outliers/MCOD/MTreeStreamObjects.java
index 77679064b..20f44c653 100644
--- a/moa/src/main/java/moa/clusterers/outliers/MCOD/MTreeStreamObjects.java
+++ b/moa/src/main/java/moa/clusterers/outliers/MCOD/MTreeStreamObjects.java
@@ -21,6 +21,7 @@
 package moa.clusterers.outliers.MCOD;
 
 import java.util.Set;
+
 import moa.clusterers.outliers.utils.mtree.ComposedSplitFunction;
 import moa.clusterers.outliers.utils.mtree.DistanceFunction;
 import moa.clusterers.outliers.utils.mtree.DistanceFunctions;
diff --git a/moa/src/main/java/moa/clusterers/outliers/MCOD/MicroCluster.java b/moa/src/main/java/moa/clusterers/outliers/MCOD/MicroCluster.java
index 8b8fd6a1d..40741a868 100644
--- a/moa/src/main/java/moa/clusterers/outliers/MCOD/MicroCluster.java
+++ b/moa/src/main/java/moa/clusterers/outliers/MCOD/MicroCluster.java
@@ -21,6 +21,7 @@
 package moa.clusterers.outliers.MCOD;
 
 import java.util.ArrayList;
+
 import moa.clusterers.outliers.MCOD.ISBIndex.ISBNode;
 import moa.clusterers.outliers.utils.mtree.DistanceFunctions.EuclideanCoordinate;
 
diff --git a/moa/src/main/java/moa/clusterers/outliers/MCOD/Test.java b/moa/src/main/java/moa/clusterers/outliers/MCOD/Test.java
index d22e61aaf..5b8474cab 100644
--- a/moa/src/main/java/moa/clusterers/outliers/MCOD/Test.java
+++ b/moa/src/main/java/moa/clusterers/outliers/MCOD/Test.java
@@ -20,9 +20,10 @@
 
 package moa.clusterers.outliers.MCOD;
 
-import moa.streams.clustering.RandomRBFGeneratorEvents;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.streams.clustering.RandomRBFGeneratorEvents;
+
 
 public class Test {    
     public static void main(String[] args) throws Exception 
diff --git a/moa/src/main/java/moa/clusterers/outliers/MyBaseOutlierDetector.java b/moa/src/main/java/moa/clusterers/outliers/MyBaseOutlierDetector.java
index a9be5efb7..1ffe3e98a 100644
--- a/moa/src/main/java/moa/clusterers/outliers/MyBaseOutlierDetector.java
+++ b/moa/src/main/java/moa/clusterers/outliers/MyBaseOutlierDetector.java
@@ -27,13 +27,15 @@
 import java.util.Set;
 import java.util.TreeSet;
 import java.util.Vector;
+
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.Cluster;
 import moa.cluster.Clustering;
 import moa.cluster.SphereCluster;
 import moa.clusterers.AbstractClusterer;
 import moa.core.Measurement;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
 
 public abstract class MyBaseOutlierDetector extends AbstractClusterer { 
     public static class Outlier implements Comparable<Outlier> {
diff --git a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/ISBIndex.java b/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/ISBIndex.java
index e088c2edb..4a12a6459 100644
--- a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/ISBIndex.java
+++ b/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/ISBIndex.java
@@ -30,6 +30,7 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.Vector;
+
 import com.yahoo.labs.samoa.instances.Instance;
 
 public class ISBIndex {    
diff --git a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/MyMTree.java b/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/MyMTree.java
index 9cfa7e925..722ee5687 100644
--- a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/MyMTree.java
+++ b/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/MyMTree.java
@@ -21,6 +21,7 @@
 package moa.clusterers.outliers.SimpleCOD;
 
 import java.util.Set;
+
 import moa.clusterers.outliers.utils.mtree.ComposedSplitFunction;
 import moa.clusterers.outliers.utils.mtree.DistanceFunction;
 import moa.clusterers.outliers.utils.mtree.DistanceFunctions;
diff --git a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/SimpleCOD.java b/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/SimpleCOD.java
index c7ed23161..2e8a1fb80 100644
--- a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/SimpleCOD.java
+++ b/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/SimpleCOD.java
@@ -21,12 +21,14 @@
 package moa.clusterers.outliers.SimpleCOD;
 
 import java.util.Vector;
-import moa.clusterers.outliers.SimpleCOD.ISBIndex.ISBNode;
-import moa.clusterers.outliers.SimpleCOD.ISBIndex.ISBSearchResult;
+
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.clusterers.outliers.SimpleCOD.ISBIndex.ISBNode;
+import moa.clusterers.outliers.SimpleCOD.ISBIndex.ISBSearchResult;
+
 
 ////The algorithm is described in 
 // M. Kontaki, A. Gounaris, A. N. Papadopoulos, K. Tsichlas, and Y. Manolopoulos. 
diff --git a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/SimpleCODBase.java b/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/SimpleCODBase.java
index b94e0992f..cd8ac90d3 100644
--- a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/SimpleCODBase.java
+++ b/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/SimpleCODBase.java
@@ -24,6 +24,7 @@
 import java.util.Set;
 import java.util.TreeSet;
 import java.util.Vector;
+
 import moa.clusterers.outliers.MyBaseOutlierDetector;
 import moa.clusterers.outliers.SimpleCOD.ISBIndex.ISBNode;
 
diff --git a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/Test.java b/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/Test.java
index 8039566ff..a8ed48e79 100644
--- a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/Test.java
+++ b/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/Test.java
@@ -20,9 +20,10 @@
 
 package moa.clusterers.outliers.SimpleCOD;
 
-import moa.streams.ArffFileStream;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.streams.ArffFileStream;
+
 
 public class Test {    
     public static void main(String[] args) throws Exception 
diff --git a/moa/src/main/java/moa/clusterers/outliers/TestSpeed.java b/moa/src/main/java/moa/clusterers/outliers/TestSpeed.java
index 019b74f91..31e903388 100644
--- a/moa/src/main/java/moa/clusterers/outliers/TestSpeed.java
+++ b/moa/src/main/java/moa/clusterers/outliers/TestSpeed.java
@@ -20,12 +20,13 @@
 
 package moa.clusterers.outliers;
 
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.clusterers.outliers.AbstractC.AbstractC;
 import moa.clusterers.outliers.Angiulli.ExactSTORM;
 import moa.clusterers.outliers.MCOD.MCOD;
 import moa.clusterers.outliers.SimpleCOD.SimpleCOD;
 import moa.streams.clustering.RandomRBFGeneratorEvents;
-import com.yahoo.labs.samoa.instances.Instance;
 
 public class TestSpeed {    
     public static void main(String[] args) throws Exception 
diff --git a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/MTree.java b/moa/src/main/java/moa/clusterers/outliers/utils/mtree/MTree.java
index 9c135a799..e2c8db618 100644
--- a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/MTree.java
+++ b/moa/src/main/java/moa/clusterers/outliers/utils/mtree/MTree.java
@@ -24,6 +24,7 @@
 import java.util.NoSuchElementException;
 import java.util.PriorityQueue;
 import java.util.Set;
+
 import moa.clusterers.outliers.utils.mtree.SplitFunction.SplitResult;
 
 
diff --git a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/PromotionFunctions.java b/moa/src/main/java/moa/clusterers/outliers/utils/mtree/PromotionFunctions.java
index d7aa38ba4..b603935b4 100644
--- a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/PromotionFunctions.java
+++ b/moa/src/main/java/moa/clusterers/outliers/utils/mtree/PromotionFunctions.java
@@ -18,6 +18,7 @@
 
 import java.util.List;
 import java.util.Set;
+
 import moa.clusterers.outliers.utils.mtree.utils.Pair;
 import moa.clusterers.outliers.utils.mtree.utils.Utils;
 
diff --git a/moa/src/main/java/moa/clusterers/streamkm/Point.java b/moa/src/main/java/moa/clusterers/streamkm/Point.java
index 28fa9d232..b272a41d6 100644
--- a/moa/src/main/java/moa/clusterers/streamkm/Point.java
+++ b/moa/src/main/java/moa/clusterers/streamkm/Point.java
@@ -1,10 +1,10 @@
 package moa.clusterers.streamkm;
 
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.Cluster;
 import moa.cluster.SphereCluster;
 
-import com.yahoo.labs.samoa.instances.Instance;
-
 /**
  *
  * @author Marcel R. Ackermann, Christiane Lammersen, Marcus Maertens, Christoph Raupach, 
diff --git a/moa/src/main/java/moa/clusterers/streamkm/StreamKM.java b/moa/src/main/java/moa/clusterers/streamkm/StreamKM.java
index ac66163eb..599db86f8 100644
--- a/moa/src/main/java/moa/clusterers/streamkm/StreamKM.java
+++ b/moa/src/main/java/moa/clusterers/streamkm/StreamKM.java
@@ -1,10 +1,11 @@
 package moa.clusterers.streamkm;
 
 import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.Clustering;
 import moa.clusterers.AbstractClusterer;
 import moa.core.Measurement;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  *
diff --git a/moa/src/main/java/moa/core/AutoClassDiscovery.java b/moa/src/main/java/moa/core/AutoClassDiscovery.java
index 9b085e5ca..d8e456893 100644
--- a/moa/src/main/java/moa/core/AutoClassDiscovery.java
+++ b/moa/src/main/java/moa/core/AutoClassDiscovery.java
@@ -21,9 +21,9 @@
 
 import java.io.File;
 import java.io.IOException;
+import java.net.URISyntaxException;
 import java.net.URL;
 import java.net.URLClassLoader;
-import java.net.URISyntaxException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Enumeration;
diff --git a/moa/src/main/java/moa/core/AutoExpandVector.java b/moa/src/main/java/moa/core/AutoExpandVector.java
index 33c3ed53e..938f70a78 100644
--- a/moa/src/main/java/moa/core/AutoExpandVector.java
+++ b/moa/src/main/java/moa/core/AutoExpandVector.java
@@ -121,7 +121,7 @@ public MOAObject copy() {
     }
 
     @Override
-    public int measureByteSize() {
+    public long measureByteSize() {
         return AbstractMOAObject.measureByteSize(this);
     }
 
diff --git a/moa/src/main/java/moa/core/MultilabelInstancesHeader.java b/moa/src/main/java/moa/core/MultilabelInstancesHeader.java
index b8dc3b3c2..7ae45510a 100644
--- a/moa/src/main/java/moa/core/MultilabelInstancesHeader.java
+++ b/moa/src/main/java/moa/core/MultilabelInstancesHeader.java
@@ -19,7 +19,6 @@
  */
 package moa.core;
 
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
diff --git a/moa/src/main/java/moa/core/Utils.java b/moa/src/main/java/moa/core/Utils.java
index ecb4cf19d..d3ec5a4e2 100644
--- a/moa/src/main/java/moa/core/Utils.java
+++ b/moa/src/main/java/moa/core/Utils.java
@@ -21,17 +21,9 @@
 
 package moa.core;
 
-import java.io.BufferedReader;
-import java.io.BufferedWriter;
 import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileReader;
-import java.io.FileWriter;
 import java.lang.reflect.Array;
-import java.net.URL;
 import java.text.BreakIterator;
-import java.util.Enumeration;
-import java.util.Properties;
 import java.util.Random;
 import java.util.Vector;
 
diff --git a/moa/src/main/java/moa/core/utils/Converter.java b/moa/src/main/java/moa/core/utils/Converter.java
index a3f976c38..5a06a8490 100755
--- a/moa/src/main/java/moa/core/utils/Converter.java
+++ b/moa/src/main/java/moa/core/utils/Converter.java
@@ -21,10 +21,12 @@
 
 import java.util.LinkedList;
 import java.util.List;
-import moa.AbstractMOAObject;
+
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.AbstractMOAObject;
+
 /**
  * Converter. This class can be used to convert a multi-label instance into a
  * single-label instance.
diff --git a/moa/src/main/java/moa/evaluation/Accuracy.java b/moa/src/main/java/moa/evaluation/Accuracy.java
index d8925799d..049ef9913 100644
--- a/moa/src/main/java/moa/evaluation/Accuracy.java
+++ b/moa/src/main/java/moa/evaluation/Accuracy.java
@@ -20,6 +20,7 @@
 package moa.evaluation;
 
 import java.util.ArrayList;
+
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
 
diff --git a/moa/src/main/java/moa/evaluation/AdwinClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/AdwinClassificationPerformanceEvaluator.java
index a0c79202c..aea7cf19e 100644
--- a/moa/src/main/java/moa/evaluation/AdwinClassificationPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/AdwinClassificationPerformanceEvaluator.java
@@ -19,7 +19,6 @@
  */
 package moa.evaluation;
 
-import com.github.javacliparser.IntOption;
 import moa.classifiers.core.driftdetection.ADWIN;
 
 /**
diff --git a/moa/src/main/java/moa/evaluation/BasicClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/BasicClassificationPerformanceEvaluator.java
index f2bba1612..eeb29f978 100644
--- a/moa/src/main/java/moa/evaluation/BasicClassificationPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/BasicClassificationPerformanceEvaluator.java
@@ -20,20 +20,18 @@
  */
 package moa.evaluation;
 
-import moa.AbstractMOAObject;
+import java.io.Serializable;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.Prediction;
+
 import moa.core.Example;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
 import moa.core.Utils;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.Prediction;
 import moa.options.AbstractOptionHandler;
 import moa.tasks.TaskMonitor;
 
-import java.io.Serializable;
-
 /**
  * Classification evaluator that performs basic incremental evaluation.
  *
diff --git a/moa/src/main/java/moa/evaluation/BasicConceptDriftPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/BasicConceptDriftPerformanceEvaluator.java
index d5df7cf06..40057d4cc 100644
--- a/moa/src/main/java/moa/evaluation/BasicConceptDriftPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/BasicConceptDriftPerformanceEvaluator.java
@@ -20,7 +20,6 @@
 package moa.evaluation;
 
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 import moa.AbstractMOAObject;
diff --git a/moa/src/main/java/moa/evaluation/BasicMultiLabelPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/BasicMultiLabelPerformanceEvaluator.java
index 33e6b18d1..d18061094 100644
--- a/moa/src/main/java/moa/evaluation/BasicMultiLabelPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/BasicMultiLabelPerformanceEvaluator.java
@@ -19,14 +19,14 @@
  */
 package moa.evaluation;
 
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.AbstractMOAObject;
 import moa.core.Example;
 import moa.core.Measurement;
 
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.Prediction;
-
 /**
  * Multilabel Window Classification Performance Evaluator.
  * 
diff --git a/moa/src/main/java/moa/evaluation/BasicMultiTargetPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/BasicMultiTargetPerformanceEvaluator.java
index 5b87a670b..0f522b1e6 100644
--- a/moa/src/main/java/moa/evaluation/BasicMultiTargetPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/BasicMultiTargetPerformanceEvaluator.java
@@ -19,17 +19,14 @@
  */
 package moa.evaluation;
 
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.AbstractMOAObject;
 import moa.core.Example;
 import moa.core.Measurement;
 
-import com.yahoo.labs.samoa.instances.DenseInstance;
-import com.yahoo.labs.samoa.instances.DenseInstanceData;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.Prediction;
-
 /**
  * Regression evaluator that performs basic incremental evaluation.
  *
diff --git a/moa/src/main/java/moa/evaluation/BasicRegressionPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/BasicRegressionPerformanceEvaluator.java
index 3948cfeba..f4ca38547 100644
--- a/moa/src/main/java/moa/evaluation/BasicRegressionPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/BasicRegressionPerformanceEvaluator.java
@@ -19,14 +19,13 @@
  */
 package moa.evaluation;
 
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.Prediction;
+
 import moa.AbstractMOAObject;
 import moa.core.Example;
 import moa.core.Measurement;
 
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.Prediction;
-
 /**
  * Regression evaluator that performs basic incremental evaluation.
  *
diff --git a/moa/src/main/java/moa/evaluation/CMM_GTAnalysis.java b/moa/src/main/java/moa/evaluation/CMM_GTAnalysis.java
index 204909e2e..db4f8273b 100644
--- a/moa/src/main/java/moa/evaluation/CMM_GTAnalysis.java
+++ b/moa/src/main/java/moa/evaluation/CMM_GTAnalysis.java
@@ -36,10 +36,12 @@
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.Clustering;
 import moa.core.AutoExpandVector;
 import moa.gui.visualization.DataPoint;
-import com.yahoo.labs.samoa.instances.Instance;
 
 public class CMM_GTAnalysis{
 	
diff --git a/moa/src/main/java/moa/evaluation/ChangeDetectionMeasures.java b/moa/src/main/java/moa/evaluation/ChangeDetectionMeasures.java
index c40dda432..faccffcc6 100644
--- a/moa/src/main/java/moa/evaluation/ChangeDetectionMeasures.java
+++ b/moa/src/main/java/moa/evaluation/ChangeDetectionMeasures.java
@@ -21,6 +21,7 @@
 package moa.evaluation;
 
 import java.util.ArrayList;
+
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
 
diff --git a/moa/src/main/java/moa/evaluation/ClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/ClassificationPerformanceEvaluator.java
index 0eb9176c9..d1a6ba878 100644
--- a/moa/src/main/java/moa/evaluation/ClassificationPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/ClassificationPerformanceEvaluator.java
@@ -20,9 +20,8 @@
 package moa.evaluation;
 
 import com.yahoo.labs.samoa.instances.Instance;
-import moa.MOAObject;
+
 import moa.core.Example;
-import moa.core.Measurement;
 
 public interface ClassificationPerformanceEvaluator extends LearningPerformanceEvaluator<Example<Instance>> {
 
diff --git a/moa/src/main/java/moa/evaluation/EWMAClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/EWMAClassificationPerformanceEvaluator.java
index 31f8ace8f..04a33adf2 100644
--- a/moa/src/main/java/moa/evaluation/EWMAClassificationPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/EWMAClassificationPerformanceEvaluator.java
@@ -19,21 +19,8 @@
  */
 package moa.evaluation;
 
-import moa.core.Example;
-import moa.core.Measurement;
-import moa.core.ObjectRepository;
-
 import com.github.javacliparser.FloatOption;
 
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.Prediction;
-
-import moa.core.Utils;
-
 /**
  * Classification evaluator that updates evaluation results using an Exponential Weighted Moving Average.
  *
diff --git a/moa/src/main/java/moa/evaluation/EntropyCollection.java b/moa/src/main/java/moa/evaluation/EntropyCollection.java
index 53a67226b..dcf04e018 100644
--- a/moa/src/main/java/moa/evaluation/EntropyCollection.java
+++ b/moa/src/main/java/moa/evaluation/EntropyCollection.java
@@ -21,6 +21,7 @@
 package moa.evaluation;
 
 import java.util.ArrayList;
+
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
 
diff --git a/moa/src/main/java/moa/evaluation/F1.java b/moa/src/main/java/moa/evaluation/F1.java
index 36e3529ab..de214877c 100644
--- a/moa/src/main/java/moa/evaluation/F1.java
+++ b/moa/src/main/java/moa/evaluation/F1.java
@@ -20,6 +20,7 @@
 package moa.evaluation;
 
 import java.util.ArrayList;
+
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
 
diff --git a/moa/src/main/java/moa/evaluation/FadingFactorClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/FadingFactorClassificationPerformanceEvaluator.java
index ed1cd700e..54bbe72e4 100644
--- a/moa/src/main/java/moa/evaluation/FadingFactorClassificationPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/FadingFactorClassificationPerformanceEvaluator.java
@@ -19,20 +19,8 @@
  */
 package moa.evaluation;
 
-import moa.core.Example;
-import moa.core.Measurement;
-import moa.core.ObjectRepository;
-
 import com.github.javacliparser.FloatOption;
 
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-import moa.core.Utils;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.Prediction;
-
 /**
  * Classification evaluator that updates evaluation results using a fading factor.
  *
diff --git a/moa/src/main/java/moa/evaluation/General.java b/moa/src/main/java/moa/evaluation/General.java
index c50d1ca9f..90682d18b 100644
--- a/moa/src/main/java/moa/evaluation/General.java
+++ b/moa/src/main/java/moa/evaluation/General.java
@@ -22,10 +22,12 @@
 
 
 import java.util.ArrayList;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.Clustering;
 import moa.cluster.SphereCluster;
 import moa.gui.visualization.DataPoint;
-import com.yahoo.labs.samoa.instances.Instance;
 
 public class General extends MeasureCollection{
     private int numPoints;
diff --git a/moa/src/main/java/moa/evaluation/LearningEvaluation.java b/moa/src/main/java/moa/evaluation/LearningEvaluation.java
index e03d8aaed..70bb17315 100644
--- a/moa/src/main/java/moa/evaluation/LearningEvaluation.java
+++ b/moa/src/main/java/moa/evaluation/LearningEvaluation.java
@@ -24,10 +24,8 @@
 import java.util.List;
 
 import moa.AbstractMOAObject;
-import moa.classifiers.Classifier;
-import moa.clusterers.Clusterer;
-import moa.learners.Learner;
 import moa.core.Measurement;
+import moa.learners.Learner;
 
 /**
  * Class that stores an array of evaluation measurements.
diff --git a/moa/src/main/java/moa/evaluation/LearningPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/LearningPerformanceEvaluator.java
index 49b44c3c2..820886e1d 100644
--- a/moa/src/main/java/moa/evaluation/LearningPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/LearningPerformanceEvaluator.java
@@ -19,7 +19,6 @@
  */
 package moa.evaluation;
 
-import com.yahoo.labs.samoa.instances.InstanceData;
 import com.yahoo.labs.samoa.instances.Prediction;
 
 import moa.MOAObject;
diff --git a/moa/src/main/java/moa/evaluation/MeasureCollection.java b/moa/src/main/java/moa/evaluation/MeasureCollection.java
index 85b08ac8b..0016239e7 100644
--- a/moa/src/main/java/moa/evaluation/MeasureCollection.java
+++ b/moa/src/main/java/moa/evaluation/MeasureCollection.java
@@ -22,6 +22,7 @@
 
 import java.util.ArrayList;
 import java.util.HashMap;
+
 import moa.AbstractMOAObject;
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
diff --git a/moa/src/main/java/moa/evaluation/MembershipMatrix.java b/moa/src/main/java/moa/evaluation/MembershipMatrix.java
index b139683df..d29777667 100644
--- a/moa/src/main/java/moa/evaluation/MembershipMatrix.java
+++ b/moa/src/main/java/moa/evaluation/MembershipMatrix.java
@@ -22,6 +22,7 @@
 
 import java.util.ArrayList;
 import java.util.HashMap;
+
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
 
diff --git a/moa/src/main/java/moa/evaluation/MultiTargetPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/MultiTargetPerformanceEvaluator.java
index 38d2c10d1..166f3fe24 100644
--- a/moa/src/main/java/moa/evaluation/MultiTargetPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/MultiTargetPerformanceEvaluator.java
@@ -19,9 +19,10 @@
  */
 package moa.evaluation;
 
-import moa.core.Example;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.core.Example;
+
 
 /**
  * Interface implemented by learner evaluators to monitor
diff --git a/moa/src/main/java/moa/evaluation/MultiTargetWindowRegressionPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/MultiTargetWindowRegressionPerformanceEvaluator.java
index 24d45642d..0e8323c07 100644
--- a/moa/src/main/java/moa/evaluation/MultiTargetWindowRegressionPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/MultiTargetWindowRegressionPerformanceEvaluator.java
@@ -19,20 +19,17 @@
  */
 package moa.evaluation;
 
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
 import moa.core.Example;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-
-import com.github.javacliparser.IntOption;
-
 import moa.tasks.TaskMonitor;
 
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.Prediction;
-
 /**
  * Multi-target regression evaluator that updates evaluation results using a sliding window.
  *
diff --git a/moa/src/main/java/moa/evaluation/OutlierPerformance.java b/moa/src/main/java/moa/evaluation/OutlierPerformance.java
index f940a631c..298472f54 100644
--- a/moa/src/main/java/moa/evaluation/OutlierPerformance.java
+++ b/moa/src/main/java/moa/evaluation/OutlierPerformance.java
@@ -21,7 +21,7 @@
 package moa.evaluation;
 
 import java.util.ArrayList;
-import java.util.Arrays;
+
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
 
diff --git a/moa/src/main/java/moa/evaluation/RegressionPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/RegressionPerformanceEvaluator.java
index 4934ab79f..78513adb7 100644
--- a/moa/src/main/java/moa/evaluation/RegressionPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/RegressionPerformanceEvaluator.java
@@ -19,9 +19,10 @@
  */
 package moa.evaluation;
 
-import moa.core.Example;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.core.Example;
+
 
 /**
  * Interface implemented by learner evaluators to monitor
diff --git a/moa/src/main/java/moa/evaluation/SSQ.java b/moa/src/main/java/moa/evaluation/SSQ.java
index 34e6dc4ba..37fab259e 100644
--- a/moa/src/main/java/moa/evaluation/SSQ.java
+++ b/moa/src/main/java/moa/evaluation/SSQ.java
@@ -21,6 +21,7 @@
 package moa.evaluation;
 
 import java.util.ArrayList;
+
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
 
diff --git a/moa/src/main/java/moa/evaluation/Separation.java b/moa/src/main/java/moa/evaluation/Separation.java
index 46a151262..fd5c9fbf8 100644
--- a/moa/src/main/java/moa/evaluation/Separation.java
+++ b/moa/src/main/java/moa/evaluation/Separation.java
@@ -1,5 +1,8 @@
 package moa.evaluation;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /*
  * #%L
  * SAMOA
@@ -22,14 +25,12 @@
 
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.Cluster;
 import moa.cluster.Clustering;
 import moa.cluster.SphereCluster;
 import moa.gui.visualization.DataPoint;
 
-import java.util.ArrayList;
-import java.util.List;
-
 public class Separation extends MeasureCollection {
 
   public Separation() {
diff --git a/moa/src/main/java/moa/evaluation/SilhouetteCoefficient.java b/moa/src/main/java/moa/evaluation/SilhouetteCoefficient.java
index 5f2697155..c58a7a8da 100644
--- a/moa/src/main/java/moa/evaluation/SilhouetteCoefficient.java
+++ b/moa/src/main/java/moa/evaluation/SilhouetteCoefficient.java
@@ -21,7 +21,7 @@
 package moa.evaluation; 
 
 import java.util.ArrayList;
-import java.util.HashMap;
+
 import moa.cluster.Cluster;
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
diff --git a/moa/src/main/java/moa/evaluation/StatisticalCollection.java b/moa/src/main/java/moa/evaluation/StatisticalCollection.java
index be51d4605..74f9576d1 100644
--- a/moa/src/main/java/moa/evaluation/StatisticalCollection.java
+++ b/moa/src/main/java/moa/evaluation/StatisticalCollection.java
@@ -22,6 +22,7 @@
 
 import java.util.ArrayList;
 import java.util.Arrays;
+
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
 
diff --git a/moa/src/main/java/moa/evaluation/WindowClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/WindowClassificationPerformanceEvaluator.java
index 31b9f3ef4..c6df7de30 100644
--- a/moa/src/main/java/moa/evaluation/WindowClassificationPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/WindowClassificationPerformanceEvaluator.java
@@ -19,20 +19,8 @@
  */
 package moa.evaluation;
 
-import moa.core.Example;
-import moa.core.Measurement;
-import moa.core.ObjectRepository;
-import moa.options.AbstractOptionHandler;
-
 import com.github.javacliparser.IntOption;
 
-import moa.tasks.TaskMonitor;
-import moa.core.Utils;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.Prediction;
-
 /**
  * Classification evaluator that updates evaluation results using a sliding
  * window.
diff --git a/moa/src/main/java/moa/evaluation/WindowRegressionPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/WindowRegressionPerformanceEvaluator.java
index 45d2f4e5a..280893b11 100644
--- a/moa/src/main/java/moa/evaluation/WindowRegressionPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/WindowRegressionPerformanceEvaluator.java
@@ -19,19 +19,16 @@
  */
 package moa.evaluation;
 
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.Prediction;
+
 import moa.core.Example;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-
-import com.github.javacliparser.IntOption;
-
 import moa.tasks.TaskMonitor;
 
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.Prediction;
-
 /**
  * Regression evaluator that updates evaluation results using a sliding window.
  *
diff --git a/moa/src/main/java/moa/gui/BatchCmd.java b/moa/src/main/java/moa/gui/BatchCmd.java
index c793093c1..eacbc966f 100644
--- a/moa/src/main/java/moa/gui/BatchCmd.java
+++ b/moa/src/main/java/moa/gui/BatchCmd.java
@@ -32,6 +32,9 @@
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.cluster.Clustering;
 import moa.clusterers.AbstractClusterer;
 import moa.clusterers.ClusterGenerator;
@@ -46,11 +49,9 @@
 import moa.gui.visualization.DataPoint;
 import moa.gui.visualization.RunVisualizer;
 import moa.streams.clustering.ClusterEvent;
-import com.yahoo.labs.samoa.instances.Instance;
 import moa.streams.clustering.ClusterEventListener;
 import moa.streams.clustering.ClusteringStream;
 import moa.streams.clustering.RandomRBFGeneratorEvents;
-import com.yahoo.labs.samoa.instances.DenseInstance;
 
 public class BatchCmd implements ClusterEventListener{
 
diff --git a/moa/src/main/java/moa/gui/ClassOptionSelectionPanel.java b/moa/src/main/java/moa/gui/ClassOptionSelectionPanel.java
index 16c2fbe74..239c42406 100644
--- a/moa/src/main/java/moa/gui/ClassOptionSelectionPanel.java
+++ b/moa/src/main/java/moa/gui/ClassOptionSelectionPanel.java
@@ -19,7 +19,6 @@
  */
 package moa.gui;
 
-import com.github.javacliparser.gui.OptionsConfigurationPanel;
 import java.awt.BorderLayout;
 import java.awt.Component;
 import java.awt.Window;
@@ -32,6 +31,8 @@
 import javax.swing.JOptionPane;
 import javax.swing.JPanel;
 
+import com.github.javacliparser.gui.OptionsConfigurationPanel;
+
 import moa.core.AutoClassDiscovery;
 import moa.core.AutoExpandVector;
 import moa.options.ClassOption;
diff --git a/moa/src/main/java/moa/gui/ClassOptionWithNamesSelectionPanel.java b/moa/src/main/java/moa/gui/ClassOptionWithNamesSelectionPanel.java
index a0ba8a8c6..524199618 100644
--- a/moa/src/main/java/moa/gui/ClassOptionWithNamesSelectionPanel.java
+++ b/moa/src/main/java/moa/gui/ClassOptionWithNamesSelectionPanel.java
@@ -10,7 +10,6 @@
 
 package moa.gui;
 
-import com.github.javacliparser.gui.OptionsConfigurationPanel;
 import java.awt.BorderLayout;
 import java.awt.Component;
 import java.awt.Window;
@@ -23,6 +22,8 @@
 import javax.swing.JOptionPane;
 import javax.swing.JPanel;
 
+import com.github.javacliparser.gui.OptionsConfigurationPanel;
+
 import moa.core.AutoClassDiscovery;
 import moa.core.AutoExpandVector;
 import moa.options.ClassOption;
diff --git a/moa/src/main/java/moa/gui/ConceptDriftTabPanel.java b/moa/src/main/java/moa/gui/ConceptDriftTabPanel.java
index 5cd80e515..de248e6de 100644
--- a/moa/src/main/java/moa/gui/ConceptDriftTabPanel.java
+++ b/moa/src/main/java/moa/gui/ConceptDriftTabPanel.java
@@ -20,6 +20,7 @@
 package moa.gui;
 
 import java.awt.BorderLayout;
+
 import moa.gui.PreviewPanel.TypePanel;
 import moa.gui.conceptdrift.CDTaskManagerPanel;
 
diff --git a/moa/src/main/java/moa/gui/GUI.java b/moa/src/main/java/moa/gui/GUI.java
index 442566626..ae5be1a43 100644
--- a/moa/src/main/java/moa/gui/GUI.java
+++ b/moa/src/main/java/moa/gui/GUI.java
@@ -21,13 +21,11 @@
 package moa.gui;
 
 import java.awt.BorderLayout;
-import java.util.logging.Level;
-import java.util.logging.Logger;
+
 import javax.swing.JFrame;
 import javax.swing.JPanel;
 import javax.swing.UIManager;
-import javax.swing.UIManager.LookAndFeelInfo;
-import javax.swing.UnsupportedLookAndFeelException;
+
 import moa.DoTask;
 import moa.core.WekaUtils;
 
diff --git a/moa/src/main/java/moa/gui/GUIDefaults.java b/moa/src/main/java/moa/gui/GUIDefaults.java
index 5ff90ed57..466ff3b0c 100644
--- a/moa/src/main/java/moa/gui/GUIDefaults.java
+++ b/moa/src/main/java/moa/gui/GUIDefaults.java
@@ -20,15 +20,15 @@
  */
 package moa.gui;
 
-import moa.core.PropertiesReader;
-import moa.core.Utils;
-
 import java.io.Serializable;
 import java.util.Collections;
 import java.util.Enumeration;
 import java.util.Properties;
 import java.util.Vector;
 
+import moa.core.PropertiesReader;
+import moa.core.Utils;
+
 /**
  * This class offers get methods for the default GUI settings in 
  * the props file <code>moa/gui/GUI.props</code>.
diff --git a/moa/src/main/java/moa/gui/MultiTargetTabPanel.java b/moa/src/main/java/moa/gui/MultiTargetTabPanel.java
index 955cad212..63ef5f263 100644
--- a/moa/src/main/java/moa/gui/MultiTargetTabPanel.java
+++ b/moa/src/main/java/moa/gui/MultiTargetTabPanel.java
@@ -20,6 +20,7 @@
 package moa.gui;
 
 import java.awt.BorderLayout;
+
 import moa.gui.PreviewPanel.TypePanel;
 
 /**
diff --git a/moa/src/main/java/moa/gui/MultiTargetTaskManagerPanel.java b/moa/src/main/java/moa/gui/MultiTargetTaskManagerPanel.java
index 01a9ea4cf..0d5745bd0 100644
--- a/moa/src/main/java/moa/gui/MultiTargetTaskManagerPanel.java
+++ b/moa/src/main/java/moa/gui/MultiTargetTaskManagerPanel.java
@@ -38,6 +38,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.prefs.Preferences;
+
 import javax.swing.JButton;
 import javax.swing.JFileChooser;
 import javax.swing.JFrame;
@@ -56,6 +57,7 @@
 import javax.swing.table.AbstractTableModel;
 import javax.swing.table.DefaultTableCellRenderer;
 import javax.swing.table.TableCellRenderer;
+
 import moa.core.StringUtils;
 import moa.options.ClassOption;
 import moa.options.OptionHandler;
diff --git a/moa/src/main/java/moa/gui/RegressionTabPanel.java b/moa/src/main/java/moa/gui/RegressionTabPanel.java
index 372157ad8..ae99d364c 100644
--- a/moa/src/main/java/moa/gui/RegressionTabPanel.java
+++ b/moa/src/main/java/moa/gui/RegressionTabPanel.java
@@ -20,6 +20,7 @@
 package moa.gui;
 
 import java.awt.BorderLayout;
+
 import moa.gui.PreviewPanel.TypePanel;
 
 /**
diff --git a/moa/src/main/java/moa/gui/RegressionTaskManagerPanel.java b/moa/src/main/java/moa/gui/RegressionTaskManagerPanel.java
index 226421523..4d7fb91ab 100644
--- a/moa/src/main/java/moa/gui/RegressionTaskManagerPanel.java
+++ b/moa/src/main/java/moa/gui/RegressionTaskManagerPanel.java
@@ -23,13 +23,13 @@
 import java.awt.BorderLayout;
 import java.awt.Component;
 import java.awt.Dimension;
+import java.awt.Toolkit;
+import java.awt.datatransfer.Clipboard;
+import java.awt.datatransfer.StringSelection;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
-import java.awt.Toolkit;
-import java.awt.datatransfer.Clipboard;
-import java.awt.datatransfer.StringSelection;
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileWriter;
diff --git a/moa/src/main/java/moa/gui/TaskManagerPanel.java b/moa/src/main/java/moa/gui/TaskManagerPanel.java
index 7ab117cf1..1eb3b29df 100644
--- a/moa/src/main/java/moa/gui/TaskManagerPanel.java
+++ b/moa/src/main/java/moa/gui/TaskManagerPanel.java
@@ -23,13 +23,13 @@
 import java.awt.BorderLayout;
 import java.awt.Component;
 import java.awt.Dimension;
+import java.awt.Toolkit;
+import java.awt.datatransfer.Clipboard;
+import java.awt.datatransfer.StringSelection;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
-import java.awt.Toolkit;
-import java.awt.datatransfer.Clipboard;
-import java.awt.datatransfer.StringSelection;
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileWriter;
diff --git a/moa/src/main/java/moa/gui/TaskTextViewerPanel.java b/moa/src/main/java/moa/gui/TaskTextViewerPanel.java
index 6f250579c..195098150 100644
--- a/moa/src/main/java/moa/gui/TaskTextViewerPanel.java
+++ b/moa/src/main/java/moa/gui/TaskTextViewerPanel.java
@@ -40,9 +40,8 @@
 import javax.swing.JPanel;
 import javax.swing.JScrollPane;
 import javax.swing.JTextArea;
-import moa.evaluation.Accuracy;
+
 import moa.evaluation.MeasureCollection;
-import moa.evaluation.RegressionAccuracy;
 import moa.gui.PreviewPanel.TypePanel;
 import moa.gui.conceptdrift.CDTaskManagerPanel;
 import moa.streams.clustering.ClusterEvent;
diff --git a/moa/src/main/java/moa/gui/WEKAClassOptionEditComponent.java b/moa/src/main/java/moa/gui/WEKAClassOptionEditComponent.java
index 5288a0ce5..755326f70 100644
--- a/moa/src/main/java/moa/gui/WEKAClassOptionEditComponent.java
+++ b/moa/src/main/java/moa/gui/WEKAClassOptionEditComponent.java
@@ -20,12 +20,6 @@
  */
 package moa.gui;
 
-import com.github.javacliparser.gui.OptionEditComponent;
-import moa.core.Utils;
-import weka.gui.GenericObjectEditor;
-import weka.gui.PropertyDialog;
-import weka.gui.GenericObjectEditor.GOEPanel;
-
 import java.awt.BorderLayout;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
@@ -35,7 +29,13 @@
 import javax.swing.JTextField;
 
 import com.github.javacliparser.Option;
+import com.github.javacliparser.gui.OptionEditComponent;
+
+import moa.core.Utils;
 import moa.options.WEKAClassOption;
+import weka.gui.GenericObjectEditor;
+import weka.gui.GenericObjectEditor.GOEPanel;
+import weka.gui.PropertyDialog;
 
 /**
  * An OptionEditComponent that lets the user edit a WEKA class option.
diff --git a/moa/src/main/java/moa/gui/clustertab/ClusteringAlgoPanel.java b/moa/src/main/java/moa/gui/clustertab/ClusteringAlgoPanel.java
index 0a04c98f9..61385baf7 100644
--- a/moa/src/main/java/moa/gui/clustertab/ClusteringAlgoPanel.java
+++ b/moa/src/main/java/moa/gui/clustertab/ClusteringAlgoPanel.java
@@ -21,7 +21,6 @@
 package moa.gui.clustertab;
 
 import java.awt.BorderLayout;
-
 import java.awt.GridBagConstraints;
 import java.awt.GridBagLayout;
 import java.awt.Insets;
@@ -32,20 +31,21 @@
 import java.util.List;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+
 import javax.swing.JButton;
 import javax.swing.JComponent;
 import javax.swing.JLabel;
 import javax.swing.JPanel;
 
+import com.github.javacliparser.Option;
+import com.github.javacliparser.gui.OptionEditComponent;
+import com.github.javacliparser.gui.OptionsConfigurationPanel;
+
 import moa.clusterers.AbstractClusterer;
 import moa.clusterers.Clusterer;
 import moa.gui.GUIUtils;
-import com.github.javacliparser.gui.OptionEditComponent;
-import com.github.javacliparser.gui.OptionsConfigurationPanel;
 import moa.options.ClassOption;
-import com.github.javacliparser.Option;
 import moa.streams.clustering.ClusteringStream;
-import moa.streams.generators.RandomRBFGenerator;
 
 public class ClusteringAlgoPanel extends javax.swing.JPanel implements ActionListener{
 
diff --git a/moa/src/main/java/moa/gui/clustertab/ClusteringEvalPanel.java b/moa/src/main/java/moa/gui/clustertab/ClusteringEvalPanel.java
index eb9a57d81..9d94481db 100644
--- a/moa/src/main/java/moa/gui/clustertab/ClusteringEvalPanel.java
+++ b/moa/src/main/java/moa/gui/clustertab/ClusteringEvalPanel.java
@@ -22,11 +22,12 @@
 import java.awt.GridBagConstraints;
 import java.util.ArrayList;
 import java.util.logging.Logger;
+
 import javax.swing.JCheckBox;
 import javax.swing.JLabel;
+
 import moa.core.AutoClassDiscovery;
 import moa.core.AutoExpandVector;
-import moa.evaluation.ClassificationMeasureCollection;
 import moa.evaluation.MeasureCollection;
 
 public class ClusteringEvalPanel extends javax.swing.JPanel {
diff --git a/moa/src/main/java/moa/gui/clustertab/ClusteringSetupTab.java b/moa/src/main/java/moa/gui/clustertab/ClusteringSetupTab.java
index beffc7e52..f27f5eece 100644
--- a/moa/src/main/java/moa/gui/clustertab/ClusteringSetupTab.java
+++ b/moa/src/main/java/moa/gui/clustertab/ClusteringSetupTab.java
@@ -24,7 +24,9 @@
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileReader;
+
 import javax.swing.JFileChooser;
+
 import moa.clusterers.AbstractClusterer;
 import moa.evaluation.MeasureCollection;
 import moa.gui.FileExtensionFilter;
diff --git a/moa/src/main/java/moa/gui/clustertab/ClusteringVisualEvalPanel.java b/moa/src/main/java/moa/gui/clustertab/ClusteringVisualEvalPanel.java
index 626bed80a..574a78b96 100644
--- a/moa/src/main/java/moa/gui/clustertab/ClusteringVisualEvalPanel.java
+++ b/moa/src/main/java/moa/gui/clustertab/ClusteringVisualEvalPanel.java
@@ -25,13 +25,13 @@
 import java.awt.Graphics;
 import java.awt.GridBagConstraints;
 import java.awt.event.ActionListener;
-import java.awt.event.ComponentEvent;
-import java.awt.event.ComponentListener;
 import java.text.DecimalFormat;
 import java.util.ArrayList;
+
 import javax.swing.ButtonGroup;
 import javax.swing.JLabel;
 import javax.swing.JRadioButton;
+
 import moa.evaluation.MeasureCollection;
 
 public class ClusteringVisualEvalPanel extends javax.swing.JPanel{
diff --git a/moa/src/main/java/moa/gui/clustertab/ClusteringVisualTab.java b/moa/src/main/java/moa/gui/clustertab/ClusteringVisualTab.java
index ba2f22c94..02fe10e7b 100644
--- a/moa/src/main/java/moa/gui/clustertab/ClusteringVisualTab.java
+++ b/moa/src/main/java/moa/gui/clustertab/ClusteringVisualTab.java
@@ -24,10 +24,12 @@
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.io.File;
+
 import javax.swing.JButton;
 import javax.swing.JComboBox;
 import javax.swing.JFileChooser;
 import javax.swing.ToolTipManager;
+
 import moa.gui.FileExtensionFilter;
 import moa.gui.visualization.GraphCanvas;
 import moa.gui.visualization.RunVisualizer;
diff --git a/moa/src/main/java/moa/gui/conceptdrift/CDTaskManagerPanel.java b/moa/src/main/java/moa/gui/conceptdrift/CDTaskManagerPanel.java
index 2b8ad6651..3794d6667 100644
--- a/moa/src/main/java/moa/gui/conceptdrift/CDTaskManagerPanel.java
+++ b/moa/src/main/java/moa/gui/conceptdrift/CDTaskManagerPanel.java
@@ -20,17 +20,16 @@
  */
 package moa.gui.conceptdrift;
 
-import moa.gui.*;
 import java.awt.BorderLayout;
 import java.awt.Component;
 import java.awt.Dimension;
+import java.awt.Toolkit;
+import java.awt.datatransfer.Clipboard;
+import java.awt.datatransfer.StringSelection;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
-import java.awt.Toolkit;
-import java.awt.datatransfer.Clipboard;
-import java.awt.datatransfer.StringSelection;
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileWriter;
@@ -60,6 +59,10 @@
 import javax.swing.table.TableCellRenderer;
 
 import moa.core.StringUtils;
+import moa.gui.ClassOptionSelectionPanel;
+import moa.gui.FileExtensionFilter;
+import moa.gui.GUIUtils;
+import moa.gui.PreviewPanel;
 import moa.options.ClassOption;
 import moa.options.OptionHandler;
 import moa.tasks.ConceptDriftMainTask;
diff --git a/moa/src/main/java/moa/gui/outliertab/OutlierAlgoPanel.java b/moa/src/main/java/moa/gui/outliertab/OutlierAlgoPanel.java
index d7fd2acd8..9951c4aa7 100644
--- a/moa/src/main/java/moa/gui/outliertab/OutlierAlgoPanel.java
+++ b/moa/src/main/java/moa/gui/outliertab/OutlierAlgoPanel.java
@@ -20,7 +20,11 @@
 
 package moa.gui.outliertab;
 
-import java.awt.*;
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.awt.Insets;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.util.ArrayList;
@@ -28,16 +32,19 @@
 import java.util.List;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+
 import javax.swing.JButton;
 import javax.swing.JComponent;
 import javax.swing.JLabel;
 import javax.swing.JPanel;
-import moa.clusterers.outliers.MyBaseOutlierDetector;
-import moa.gui.GUIUtils;
-import moa.options.ClassOption;
+
 import com.github.javacliparser.Option;
 import com.github.javacliparser.gui.OptionEditComponent;
 import com.github.javacliparser.gui.OptionsConfigurationPanel;
+
+import moa.clusterers.outliers.MyBaseOutlierDetector;
+import moa.gui.GUIUtils;
+import moa.options.ClassOption;
 import moa.streams.clustering.ClusteringStream;
 
 public class OutlierAlgoPanel extends javax.swing.JPanel implements ActionListener{
diff --git a/moa/src/main/java/moa/gui/outliertab/OutlierEvalPanel.java b/moa/src/main/java/moa/gui/outliertab/OutlierEvalPanel.java
index 84500eb92..0883b9034 100644
--- a/moa/src/main/java/moa/gui/outliertab/OutlierEvalPanel.java
+++ b/moa/src/main/java/moa/gui/outliertab/OutlierEvalPanel.java
@@ -22,12 +22,12 @@
 
 import java.awt.GridBagConstraints;
 import java.util.ArrayList;
-import java.util.logging.Logger;
+
 import javax.swing.JCheckBox;
 import javax.swing.JLabel;
+
 import moa.core.AutoClassDiscovery;
 import moa.core.AutoExpandVector;
-import moa.evaluation.ClassificationMeasureCollection;
 import moa.evaluation.MeasureCollection;
 import moa.evaluation.OutlierPerformance;
 
diff --git a/moa/src/main/java/moa/gui/outliertab/OutlierSetupTab.java b/moa/src/main/java/moa/gui/outliertab/OutlierSetupTab.java
index 70b2dd742..56c6889d4 100644
--- a/moa/src/main/java/moa/gui/outliertab/OutlierSetupTab.java
+++ b/moa/src/main/java/moa/gui/outliertab/OutlierSetupTab.java
@@ -24,7 +24,9 @@
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileReader;
+
 import javax.swing.JFileChooser;
+
 import moa.clusterers.outliers.MyBaseOutlierDetector;
 import moa.evaluation.MeasureCollection;
 import moa.gui.FileExtensionFilter;
diff --git a/moa/src/main/java/moa/gui/outliertab/OutlierVisualEvalPanel.java b/moa/src/main/java/moa/gui/outliertab/OutlierVisualEvalPanel.java
index 7c5307f1d..24c410add 100644
--- a/moa/src/main/java/moa/gui/outliertab/OutlierVisualEvalPanel.java
+++ b/moa/src/main/java/moa/gui/outliertab/OutlierVisualEvalPanel.java
@@ -25,13 +25,13 @@
 import java.awt.Graphics;
 import java.awt.GridBagConstraints;
 import java.awt.event.ActionListener;
-import java.awt.event.ComponentEvent;
-import java.awt.event.ComponentListener;
 import java.text.DecimalFormat;
 import java.util.ArrayList;
+
 import javax.swing.ButtonGroup;
 import javax.swing.JLabel;
 import javax.swing.JRadioButton;
+
 import moa.evaluation.MeasureCollection;
 
 public class OutlierVisualEvalPanel extends javax.swing.JPanel{
diff --git a/moa/src/main/java/moa/gui/outliertab/OutlierVisualTab.java b/moa/src/main/java/moa/gui/outliertab/OutlierVisualTab.java
index 2322a01f6..9923bfeed 100644
--- a/moa/src/main/java/moa/gui/outliertab/OutlierVisualTab.java
+++ b/moa/src/main/java/moa/gui/outliertab/OutlierVisualTab.java
@@ -28,10 +28,12 @@
 import java.awt.event.ComponentEvent;
 import java.awt.event.ComponentListener;
 import java.io.File;
+
 import javax.swing.JButton;
 import javax.swing.JComboBox;
 import javax.swing.JFileChooser;
 import javax.swing.ToolTipManager;
+
 import moa.gui.FileExtensionFilter;
 import moa.gui.visualization.GraphCanvas;
 import moa.gui.visualization.RunOutlierVisualizer;
diff --git a/moa/src/main/java/moa/gui/visualization/ClusterPanel.java b/moa/src/main/java/moa/gui/visualization/ClusterPanel.java
index 3db527710..352100b4d 100644
--- a/moa/src/main/java/moa/gui/visualization/ClusterPanel.java
+++ b/moa/src/main/java/moa/gui/visualization/ClusterPanel.java
@@ -24,7 +24,9 @@
 import java.awt.Dimension;
 import java.awt.Graphics;
 import java.awt.Graphics2D;
+
 import javax.swing.JPanel;
+
 import moa.cluster.SphereCluster;
 
 public class ClusterPanel extends JPanel {
diff --git a/moa/src/main/java/moa/gui/visualization/GraphCanvas.java b/moa/src/main/java/moa/gui/visualization/GraphCanvas.java
index 6aecc5a32..fe857f285 100644
--- a/moa/src/main/java/moa/gui/visualization/GraphCanvas.java
+++ b/moa/src/main/java/moa/gui/visualization/GraphCanvas.java
@@ -22,9 +22,11 @@
 import java.awt.Dimension;
 import java.awt.Graphics;
 import java.util.ArrayList;
+
 import javax.swing.JLabel;
 import javax.swing.JPanel;
 import javax.swing.JViewport;
+
 import moa.evaluation.MeasureCollection;
 import moa.streams.clustering.ClusterEvent;
 
diff --git a/moa/src/main/java/moa/gui/visualization/GraphCurve.java b/moa/src/main/java/moa/gui/visualization/GraphCurve.java
index a791cafb3..46518e7a1 100644
--- a/moa/src/main/java/moa/gui/visualization/GraphCurve.java
+++ b/moa/src/main/java/moa/gui/visualization/GraphCurve.java
@@ -23,6 +23,7 @@
 import java.awt.Dimension;
 import java.awt.Graphics;
 import java.util.ArrayList;
+
 import moa.evaluation.MeasureCollection;
 import moa.streams.clustering.ClusterEvent;
 
diff --git a/moa/src/main/java/moa/gui/visualization/OutlierPanel.java b/moa/src/main/java/moa/gui/visualization/OutlierPanel.java
index 68c5c1a48..f917a0ad9 100644
--- a/moa/src/main/java/moa/gui/visualization/OutlierPanel.java
+++ b/moa/src/main/java/moa/gui/visualization/OutlierPanel.java
@@ -21,13 +21,20 @@
 
 package moa.gui.visualization;
 
-import java.awt.*;
-import java.awt.event.WindowEvent;
-import java.awt.event.WindowFocusListener;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.Map;
-import javax.swing.*;
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.MouseInfo;
+import java.awt.Point;
+import java.awt.PointerInfo;
+import java.awt.RenderingHints;
+
+import javax.swing.JDialog;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+
 import moa.cluster.SphereCluster;
 import moa.clusterers.outliers.MyBaseOutlierDetector;
 import moa.clusterers.outliers.MyBaseOutlierDetector.Outlier;
diff --git a/moa/src/main/java/moa/gui/visualization/RunOutlierVisualizer.java b/moa/src/main/java/moa/gui/visualization/RunOutlierVisualizer.java
index ce611e1ba..5dd794716 100644
--- a/moa/src/main/java/moa/gui/visualization/RunOutlierVisualizer.java
+++ b/moa/src/main/java/moa/gui/visualization/RunOutlierVisualizer.java
@@ -39,6 +39,12 @@
 import java.util.Vector;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+
+import com.yahoo.labs.samoa.instances.Attribute;
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.cluster.Cluster;
 import moa.cluster.Clustering;
 import moa.clusterers.outliers.MyBaseOutlierDetector;
@@ -56,10 +62,6 @@
 import moa.streams.clustering.ClusterEventListener;
 import moa.streams.clustering.ClusteringStream;
 import moa.streams.clustering.RandomRBFGeneratorEvents;
-import com.yahoo.labs.samoa.instances.Attribute;
-import com.yahoo.labs.samoa.instances.DenseInstance;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public class RunOutlierVisualizer implements Runnable, ActionListener, ClusterEventListener{	
     /** the pause interval, being read from the gui at startup */
diff --git a/moa/src/main/java/moa/gui/visualization/RunVisualizer.java b/moa/src/main/java/moa/gui/visualization/RunVisualizer.java
index 1e08cab18..0e33cbebb 100644
--- a/moa/src/main/java/moa/gui/visualization/RunVisualizer.java
+++ b/moa/src/main/java/moa/gui/visualization/RunVisualizer.java
@@ -34,25 +34,25 @@
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
+import com.yahoo.labs.samoa.instances.Attribute;
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.cluster.Cluster;
 import moa.cluster.Clustering;
 import moa.clusterers.AbstractClusterer;
 import moa.clusterers.ClusterGenerator;
+import moa.core.FastVector;
 import moa.evaluation.MeasureCollection;
 import moa.gui.TextViewerPanel;
 import moa.gui.clustertab.ClusteringSetupTab;
 import moa.gui.clustertab.ClusteringVisualEvalPanel;
 import moa.gui.clustertab.ClusteringVisualTab;
 import moa.streams.clustering.ClusterEvent;
-import com.yahoo.labs.samoa.instances.Instance;
-import moa.gui.clustertab.ClusteringSetupTab;
 import moa.streams.clustering.ClusterEventListener;
 import moa.streams.clustering.ClusteringStream;
 import moa.streams.clustering.RandomRBFGeneratorEvents;
-import com.yahoo.labs.samoa.instances.Attribute;
-import com.yahoo.labs.samoa.instances.DenseInstance;
-import moa.core.FastVector;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public class RunVisualizer implements Runnable, ActionListener, ClusterEventListener{
 
diff --git a/moa/src/main/java/moa/gui/visualization/StreamOutlierPanel.java b/moa/src/main/java/moa/gui/visualization/StreamOutlierPanel.java
index 039619ad8..58f95e1a7 100644
--- a/moa/src/main/java/moa/gui/visualization/StreamOutlierPanel.java
+++ b/moa/src/main/java/moa/gui/visualization/StreamOutlierPanel.java
@@ -20,19 +20,31 @@
 
 package moa.gui.visualization;
 
-import java.awt.*;
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Point;
+import java.awt.RenderingHints;
 import java.awt.event.ComponentEvent;
 import java.awt.event.ComponentListener;
 import java.awt.geom.Rectangle2D;
 import java.awt.image.BufferedImage;
 import java.awt.image.RescaleOp;
-import java.io.*;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
 import java.util.Vector;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+
 import javax.imageio.ImageIO;
 import javax.swing.JPanel;
 import javax.swing.JScrollPane;
+
 import moa.cluster.SphereCluster;
 import moa.clusterers.outliers.MyBaseOutlierDetector;
 import moa.clusterers.outliers.MyBaseOutlierDetector.Outlier;
diff --git a/moa/src/main/java/moa/gui/visualization/WekaExplorer.java b/moa/src/main/java/moa/gui/visualization/WekaExplorer.java
index cfc1d5254..6ed93c826 100644
--- a/moa/src/main/java/moa/gui/visualization/WekaExplorer.java
+++ b/moa/src/main/java/moa/gui/visualization/WekaExplorer.java
@@ -27,18 +27,21 @@
 
 package moa.gui.visualization;
 
-import weka.gui.explorer.Explorer;
-import weka.core.Memory;
 //import weka.gui.LookAndFeel;
 import java.awt.BorderLayout;
 import java.awt.Image;
 import java.awt.Toolkit;
 import java.awt.event.WindowAdapter;
 import java.awt.event.WindowEvent;
+
 import javax.swing.JFrame;
+
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
 
+import weka.core.Memory;
+import weka.gui.explorer.Explorer;
+
 
 public class WekaExplorer {
 
diff --git a/moa/src/main/java/moa/learners/ChangeDetectorLearner.java b/moa/src/main/java/moa/learners/ChangeDetectorLearner.java
index db3abce46..d13d93025 100644
--- a/moa/src/main/java/moa/learners/ChangeDetectorLearner.java
+++ b/moa/src/main/java/moa/learners/ChangeDetectorLearner.java
@@ -19,9 +19,10 @@
 package moa.learners;
 
 import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.AbstractClassifier;
-import moa.core.Measurement;
 import moa.classifiers.core.driftdetection.ChangeDetector;
+import moa.core.Measurement;
 import moa.options.ClassOption;
 
 /**
diff --git a/moa/src/main/java/moa/learners/Learner.java b/moa/src/main/java/moa/learners/Learner.java
index 5d700571e..823e8797f 100644
--- a/moa/src/main/java/moa/learners/Learner.java
+++ b/moa/src/main/java/moa/learners/Learner.java
@@ -19,13 +19,11 @@
  */
 package moa.learners;
 
-import moa.MOAObject;
-import moa.core.Example;
-
-import com.yahoo.labs.samoa.instances.InstanceData;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Prediction;
 
+import moa.MOAObject;
+import moa.core.Example;
 import moa.core.Measurement;
 import moa.gui.AWTRenderable;
 import moa.options.OptionHandler;
diff --git a/moa/src/main/java/moa/options/AbstractClassOption.java b/moa/src/main/java/moa/options/AbstractClassOption.java
index 00b0a10c0..70e1af183 100644
--- a/moa/src/main/java/moa/options/AbstractClassOption.java
+++ b/moa/src/main/java/moa/options/AbstractClassOption.java
@@ -20,8 +20,10 @@
 package moa.options;
 
 import java.io.File;
+
 import com.github.javacliparser.AbstractOption;
 import com.github.javacliparser.SerializeUtils;
+
 import moa.core.ObjectRepository;
 import moa.tasks.Task;
 import moa.tasks.TaskMonitor;
diff --git a/moa/src/main/java/moa/options/AbstractOptionHandler.java b/moa/src/main/java/moa/options/AbstractOptionHandler.java
index 622f969a4..a26009fc4 100644
--- a/moa/src/main/java/moa/options/AbstractOptionHandler.java
+++ b/moa/src/main/java/moa/options/AbstractOptionHandler.java
@@ -20,6 +20,7 @@
 package moa.options;
 
 import com.github.javacliparser.Options;
+
 import moa.AbstractMOAObject;
 import moa.core.ObjectRepository;
 import moa.tasks.NullMonitor;
diff --git a/moa/src/main/java/moa/options/ClassOption.java b/moa/src/main/java/moa/options/ClassOption.java
index 56eaf8d19..8a94d3c78 100644
--- a/moa/src/main/java/moa/options/ClassOption.java
+++ b/moa/src/main/java/moa/options/ClassOption.java
@@ -20,9 +20,10 @@
 package moa.options;
 
 import java.io.File;
+
 import com.github.javacliparser.Option;
 import com.github.javacliparser.Options;
-import moa.options.OptionHandler;
+
 import moa.tasks.Task;
 
 /**
diff --git a/moa/src/main/java/moa/options/ClassOptionWithNames.java b/moa/src/main/java/moa/options/ClassOptionWithNames.java
index 256dfdfc2..59959d90c 100644
--- a/moa/src/main/java/moa/options/ClassOptionWithNames.java
+++ b/moa/src/main/java/moa/options/ClassOptionWithNames.java
@@ -11,13 +11,11 @@
 
 package moa.options;
 
-import com.github.javacliparser.Options;
-import com.github.javacliparser.Option;
 import java.io.File;
 
-import javax.swing.JComponent;
+import com.github.javacliparser.Option;
+import com.github.javacliparser.Options;
 
-import com.github.javacliparser.gui.ClassOptionWithNamesEditComponent;
 import moa.tasks.Task;
 
 public class ClassOptionWithNames extends AbstractClassOption {
diff --git a/moa/src/main/java/moa/options/OptionHandler.java b/moa/src/main/java/moa/options/OptionHandler.java
index 6faba81ad..1fac302da 100644
--- a/moa/src/main/java/moa/options/OptionHandler.java
+++ b/moa/src/main/java/moa/options/OptionHandler.java
@@ -21,6 +21,7 @@
 
 import com.github.javacliparser.Configurable;
 import com.github.javacliparser.Options;
+
 import moa.MOAObject;
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
diff --git a/moa/src/main/java/moa/options/OptionsHandler.java b/moa/src/main/java/moa/options/OptionsHandler.java
index fac313a80..42e0b54f2 100644
--- a/moa/src/main/java/moa/options/OptionsHandler.java
+++ b/moa/src/main/java/moa/options/OptionsHandler.java
@@ -2,8 +2,10 @@
 
 
 import java.util.HashMap;
+
 import com.github.javacliparser.JavaCLIParser;
 import com.github.javacliparser.Option;
+
 import moa.core.ObjectRepository;
 import moa.tasks.NullMonitor;
 import moa.tasks.TaskMonitor;
diff --git a/moa/src/main/java/moa/options/WEKAClassOption.java b/moa/src/main/java/moa/options/WEKAClassOption.java
index f117dbbf9..c46d75476 100644
--- a/moa/src/main/java/moa/options/WEKAClassOption.java
+++ b/moa/src/main/java/moa/options/WEKAClassOption.java
@@ -20,17 +20,17 @@
  */
 package moa.options;
 
-import com.github.javacliparser.Option;
-import weka.core.Utils;
-
 import java.io.File;
 import java.util.Enumeration;
 import java.util.Vector;
 
+import com.github.javacliparser.Option;
+
 //import javax.swing.JComponent;
 
 //import moa.gui.WEKAClassOptionEditComponent;
 import moa.tasks.Task;
+import weka.core.Utils;
 
 /**
  * WEKA class option. This option is used to access options in WEKA.
diff --git a/moa/src/main/java/moa/recommender/dataset/impl/FlixsterDataset.java b/moa/src/main/java/moa/recommender/dataset/impl/FlixsterDataset.java
index 0f1844d5e..19841cc24 100644
--- a/moa/src/main/java/moa/recommender/dataset/impl/FlixsterDataset.java
+++ b/moa/src/main/java/moa/recommender/dataset/impl/FlixsterDataset.java
@@ -28,10 +28,11 @@
 import java.io.InputStreamReader;
 import java.util.logging.Level;
 import java.util.logging.Logger;
-import moa.core.ObjectRepository;
-import moa.options.AbstractOptionHandler;
+
 import com.github.javacliparser.FileOption;
 
+import moa.core.ObjectRepository;
+import moa.options.AbstractOptionHandler;
 import moa.recommender.dataset.Dataset;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/recommender/dataset/impl/JesterDataset.java b/moa/src/main/java/moa/recommender/dataset/impl/JesterDataset.java
index 7ff32b3c0..13716c156 100644
--- a/moa/src/main/java/moa/recommender/dataset/impl/JesterDataset.java
+++ b/moa/src/main/java/moa/recommender/dataset/impl/JesterDataset.java
@@ -23,16 +23,17 @@
 import java.io.BufferedReader;
 import java.io.DataInputStream;
 import java.io.FileInputStream;
+import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStreamReader;
-
-import moa.recommender.dataset.Dataset;
-import java.io.FileNotFoundException;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+
+import com.github.javacliparser.FileOption;
+
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.FileOption;
+import moa.recommender.dataset.Dataset;
 import moa.tasks.TaskMonitor;
 
 public class JesterDataset extends AbstractOptionHandler implements Dataset {
diff --git a/moa/src/main/java/moa/recommender/dataset/impl/MovielensDataset.java b/moa/src/main/java/moa/recommender/dataset/impl/MovielensDataset.java
index 8d42e2221..66c86baa6 100644
--- a/moa/src/main/java/moa/recommender/dataset/impl/MovielensDataset.java
+++ b/moa/src/main/java/moa/recommender/dataset/impl/MovielensDataset.java
@@ -20,7 +20,6 @@
 
 package moa.recommender.dataset.impl;
 
-import moa.recommender.dataset.Dataset;
 import java.io.BufferedReader;
 import java.io.DataInputStream;
 import java.io.FileInputStream;
@@ -29,9 +28,12 @@
 import java.io.InputStreamReader;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+
+import com.github.javacliparser.FileOption;
+
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.FileOption;
+import moa.recommender.dataset.Dataset;
 import moa.tasks.TaskMonitor;
 
 public class MovielensDataset extends AbstractOptionHandler implements Dataset {
diff --git a/moa/src/main/java/moa/recommender/predictor/BRISMFPredictor.java b/moa/src/main/java/moa/recommender/predictor/BRISMFPredictor.java
index 69932b399..8d69c8450 100644
--- a/moa/src/main/java/moa/recommender/predictor/BRISMFPredictor.java
+++ b/moa/src/main/java/moa/recommender/predictor/BRISMFPredictor.java
@@ -21,11 +21,13 @@
 package moa.recommender.predictor;
 
 import java.util.List;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.options.ClassOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
 import moa.recommender.data.RecommenderData;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/recommender/predictor/BaselinePredictor.java b/moa/src/main/java/moa/recommender/predictor/BaselinePredictor.java
index 3433ff24b..1ca885c1e 100644
--- a/moa/src/main/java/moa/recommender/predictor/BaselinePredictor.java
+++ b/moa/src/main/java/moa/recommender/predictor/BaselinePredictor.java
@@ -21,6 +21,7 @@
 package moa.recommender.predictor;
 
 import java.util.List;
+
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.options.ClassOption;
diff --git a/moa/src/main/java/moa/recommender/predictor/RatingPredictor.java b/moa/src/main/java/moa/recommender/predictor/RatingPredictor.java
index 911864980..839821251 100644
--- a/moa/src/main/java/moa/recommender/predictor/RatingPredictor.java
+++ b/moa/src/main/java/moa/recommender/predictor/RatingPredictor.java
@@ -22,6 +22,7 @@
 
 import java.io.Serializable;
 import java.util.List;
+
 import moa.recommender.rc.data.RecommenderData;
 
 /**
diff --git a/moa/src/main/java/moa/recommender/rc/data/AbstractRecommenderData.java b/moa/src/main/java/moa/recommender/rc/data/AbstractRecommenderData.java
index b3d6cab0b..8c755448f 100644
--- a/moa/src/main/java/moa/recommender/rc/data/AbstractRecommenderData.java
+++ b/moa/src/main/java/moa/recommender/rc/data/AbstractRecommenderData.java
@@ -23,6 +23,7 @@
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
+
 import moa.recommender.rc.utils.Updatable;
 
 
diff --git a/moa/src/main/java/moa/recommender/rc/data/RecommenderData.java b/moa/src/main/java/moa/recommender/rc/data/RecommenderData.java
index 455f29f5c..d986dcee2 100644
--- a/moa/src/main/java/moa/recommender/rc/data/RecommenderData.java
+++ b/moa/src/main/java/moa/recommender/rc/data/RecommenderData.java
@@ -24,6 +24,7 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
+
 import moa.recommender.rc.utils.Rating;
 import moa.recommender.rc.utils.SparseVector;
 import moa.recommender.rc.utils.Updatable;
diff --git a/moa/src/main/java/moa/recommender/rc/data/impl/MemRecommenderData.java b/moa/src/main/java/moa/recommender/rc/data/impl/MemRecommenderData.java
index 9e61cbe83..af9b55f9c 100644
--- a/moa/src/main/java/moa/recommender/rc/data/impl/MemRecommenderData.java
+++ b/moa/src/main/java/moa/recommender/rc/data/impl/MemRecommenderData.java
@@ -27,6 +27,7 @@
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
+
 import moa.recommender.rc.data.AbstractRecommenderData;
 import moa.recommender.rc.utils.Rating;
 import moa.recommender.rc.utils.SparseVector;
diff --git a/moa/src/main/java/moa/recommender/rc/predictor/RatingPredictor.java b/moa/src/main/java/moa/recommender/rc/predictor/RatingPredictor.java
index d160de6f2..9033917f9 100644
--- a/moa/src/main/java/moa/recommender/rc/predictor/RatingPredictor.java
+++ b/moa/src/main/java/moa/recommender/rc/predictor/RatingPredictor.java
@@ -22,6 +22,7 @@
 
 import java.io.Serializable;
 import java.util.List;
+
 import moa.recommender.rc.data.RecommenderData;
 
 public interface RatingPredictor extends Serializable {
diff --git a/moa/src/main/java/moa/recommender/rc/predictor/impl/BRISMFPredictor.java b/moa/src/main/java/moa/recommender/rc/predictor/impl/BRISMFPredictor.java
index ccc6e1e25..936496e73 100644
--- a/moa/src/main/java/moa/recommender/rc/predictor/impl/BRISMFPredictor.java
+++ b/moa/src/main/java/moa/recommender/rc/predictor/impl/BRISMFPredictor.java
@@ -25,6 +25,7 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Random;
+
 import moa.recommender.rc.data.RecommenderData;
 import moa.recommender.rc.utils.Pair;
 import moa.recommender.rc.utils.Rating;
diff --git a/moa/src/main/java/moa/recommender/rc/predictor/impl/BaselinePredictor.java b/moa/src/main/java/moa/recommender/rc/predictor/impl/BaselinePredictor.java
index cfc22b2e2..6411ce6e9 100644
--- a/moa/src/main/java/moa/recommender/rc/predictor/impl/BaselinePredictor.java
+++ b/moa/src/main/java/moa/recommender/rc/predictor/impl/BaselinePredictor.java
@@ -22,6 +22,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+
 import moa.recommender.rc.data.RecommenderData;
 import moa.recommender.rc.predictor.RatingPredictor;
 
diff --git a/moa/src/main/java/moa/streams/ArffFileStream.java b/moa/src/main/java/moa/streams/ArffFileStream.java
index 81d639198..3161ac6ba 100644
--- a/moa/src/main/java/moa/streams/ArffFileStream.java
+++ b/moa/src/main/java/moa/streams/ArffFileStream.java
@@ -19,17 +19,17 @@
  */
 package moa.streams;
 
-import com.github.javacliparser.FileOption;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.StringOption;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import java.io.BufferedReader;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
-import java.io.Reader; 
+import java.io.Reader;
+
+import com.github.javacliparser.FileOption;
+import com.github.javacliparser.StringOption;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.core.InputStreamProgressMonitor;
 import moa.core.InstanceExample;
 import moa.core.ObjectRepository;
diff --git a/moa/src/main/java/moa/streams/CachedInstancesStream.java b/moa/src/main/java/moa/streams/CachedInstancesStream.java
index bb618fac8..bd260db04 100644
--- a/moa/src/main/java/moa/streams/CachedInstancesStream.java
+++ b/moa/src/main/java/moa/streams/CachedInstancesStream.java
@@ -19,11 +19,10 @@
  */
 package moa.streams;
 
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.AbstractMOAObject;
 import moa.core.InstanceExample;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Stream generator for representing a stream that is cached in memory.
diff --git a/moa/src/main/java/moa/streams/ConceptDriftRealStream.java b/moa/src/main/java/moa/streams/ConceptDriftRealStream.java
index 46c30398a..b0bd8b18e 100644
--- a/moa/src/main/java/moa/streams/ConceptDriftRealStream.java
+++ b/moa/src/main/java/moa/streams/ConceptDriftRealStream.java
@@ -19,24 +19,20 @@
  */
 package moa.streams;
 
+import java.util.Random;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
-import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Random;
+import moa.core.FastVector;
 import moa.core.InstanceExample;
-
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
-import moa.core.utils.AttributeDefinitionUtil;
 import moa.options.AbstractOptionHandler;
 import moa.options.ClassOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
 
 /**
diff --git a/moa/src/main/java/moa/streams/ConceptDriftStream.java b/moa/src/main/java/moa/streams/ConceptDriftStream.java
index 19ff13c49..50de9fa90 100644
--- a/moa/src/main/java/moa/streams/ConceptDriftStream.java
+++ b/moa/src/main/java/moa/streams/ConceptDriftStream.java
@@ -20,16 +20,16 @@
 package moa.streams;
 
 import java.util.Random;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.core.Example;
-import moa.core.InstanceExample;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.options.ClassOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Stream generator that adds concept drift to examples in a stream.
diff --git a/moa/src/main/java/moa/streams/ExampleStream.java b/moa/src/main/java/moa/streams/ExampleStream.java
index 20877597a..d06f4d915 100644
--- a/moa/src/main/java/moa/streams/ExampleStream.java
+++ b/moa/src/main/java/moa/streams/ExampleStream.java
@@ -19,12 +19,11 @@
  */
 package moa.streams;
 
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.MOAObject;
 import moa.core.Example;
 
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
 /**
  * Interface representing a data stream of examples. 
  *
diff --git a/moa/src/main/java/moa/streams/InstanceStream.java b/moa/src/main/java/moa/streams/InstanceStream.java
index 83e246300..530201337 100644
--- a/moa/src/main/java/moa/streams/InstanceStream.java
+++ b/moa/src/main/java/moa/streams/InstanceStream.java
@@ -19,9 +19,10 @@
  */
 package moa.streams;
 
-import moa.core.Example;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.core.Example;
+
 /**
  * Interface representing a data stream of instances. 
  *
diff --git a/moa/src/main/java/moa/streams/MultiFilteredStream.java b/moa/src/main/java/moa/streams/MultiFilteredStream.java
index befa684b6..b4247be27 100644
--- a/moa/src/main/java/moa/streams/MultiFilteredStream.java
+++ b/moa/src/main/java/moa/streams/MultiFilteredStream.java
@@ -19,18 +19,17 @@
  */
 package moa.streams;
 
+import com.github.javacliparser.ListOption;
+import com.github.javacliparser.Option;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.core.Example;
-import moa.core.InstanceExample;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.options.ClassOption;
-import com.github.javacliparser.ListOption;
-import com.github.javacliparser.Option;
 import moa.options.OptionHandler;
 import moa.streams.filters.StreamFilter;
 import moa.tasks.TaskMonitor;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Class for representing a stream that is filtered.
diff --git a/moa/src/main/java/moa/streams/MultiLabelFilteredStream.java b/moa/src/main/java/moa/streams/MultiLabelFilteredStream.java
index f7c8bdf79..dd722fc2b 100644
--- a/moa/src/main/java/moa/streams/MultiLabelFilteredStream.java
+++ b/moa/src/main/java/moa/streams/MultiLabelFilteredStream.java
@@ -28,7 +28,6 @@
 import moa.options.OptionHandler;
 import moa.streams.filters.MultiLabelStreamFilter;
 import moa.streams.filters.SelectAttributesFilter;
-import moa.streams.filters.StreamFilter;
 import moa.tasks.TaskMonitor;
 
 /**
diff --git a/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java b/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java
index 9ade14c76..54fe69cee 100644
--- a/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java
+++ b/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java
@@ -19,21 +19,6 @@
  */
 package moa.streams;
 
-import com.github.javacliparser.FileOption;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import java.io.BufferedReader;
-import java.io.FileInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.Reader; 
-import moa.core.InputStreamProgressMonitor;
-import moa.core.InstanceExample;
-import moa.core.ObjectRepository;
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
 /**
  * Stream reader of ARFF files.
  *
diff --git a/moa/src/main/java/moa/streams/MultiTargetInstanceStream.java b/moa/src/main/java/moa/streams/MultiTargetInstanceStream.java
index 6e706a8e1..6b5432c90 100644
--- a/moa/src/main/java/moa/streams/MultiTargetInstanceStream.java
+++ b/moa/src/main/java/moa/streams/MultiTargetInstanceStream.java
@@ -19,9 +19,6 @@
  */
 package moa.streams;
 
-import moa.core.Example;
-import com.yahoo.labs.samoa.instances.Instance;
-
 /**
  * Interface representing a data stream of instances. 
  *
diff --git a/moa/src/main/java/moa/streams/RecurrentConceptDriftStream.java b/moa/src/main/java/moa/streams/RecurrentConceptDriftStream.java
index 54476e78a..1082192f9 100644
--- a/moa/src/main/java/moa/streams/RecurrentConceptDriftStream.java
+++ b/moa/src/main/java/moa/streams/RecurrentConceptDriftStream.java
@@ -20,12 +20,13 @@
  */
 package moa.streams;
 
-import moa.core.Example;
 import java.util.Random;
+
+import com.github.javacliparser.IntOption;
+
+import moa.core.Example;
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.github.javacliparser.IntOption;
 
 
 
diff --git a/moa/src/main/java/moa/streams/clustering/ClusteringStream.java b/moa/src/main/java/moa/streams/clustering/ClusteringStream.java
index e7c2b4bf8..c40660b02 100644
--- a/moa/src/main/java/moa/streams/clustering/ClusteringStream.java
+++ b/moa/src/main/java/moa/streams/clustering/ClusteringStream.java
@@ -20,9 +20,10 @@
 
 package moa.streams.clustering;
 
-import moa.options.AbstractOptionHandler;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
+
+import moa.options.AbstractOptionHandler;
 import moa.streams.InstanceStream;
 
 public abstract class ClusteringStream extends AbstractOptionHandler implements InstanceStream{
diff --git a/moa/src/main/java/moa/streams/clustering/FileStream.java b/moa/src/main/java/moa/streams/clustering/FileStream.java
index bd8458fff..422fc23a1 100644
--- a/moa/src/main/java/moa/streams/clustering/FileStream.java
+++ b/moa/src/main/java/moa/streams/clustering/FileStream.java
@@ -34,23 +34,21 @@
 import java.util.Arrays;
 import java.util.HashSet;
 
-import moa.core.InputStreamProgressMonitor;
-import moa.core.InstanceExample;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import moa.core.ObjectRepository;
-import moa.core.utils.AttributeDefinitionUtil;
-
 import com.github.javacliparser.FileOption;
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.ListOption;
 import com.github.javacliparser.Option;
 import com.github.javacliparser.StringOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.core.InputStreamProgressMonitor;
+import moa.core.InstanceExample;
+import moa.core.ObjectRepository;
+import moa.core.utils.AttributeDefinitionUtil;
 import moa.tasks.TaskMonitor;
 
-import com.yahoo.labs.samoa.instances.Instance;
-
 public class FileStream extends ClusteringStream{
 
 	@Override
diff --git a/moa/src/main/java/moa/streams/clustering/RandomRBFGeneratorEvents.java b/moa/src/main/java/moa/streams/clustering/RandomRBFGeneratorEvents.java
index 84b15eebc..f26ca664e 100644
--- a/moa/src/main/java/moa/streams/clustering/RandomRBFGeneratorEvents.java
+++ b/moa/src/main/java/moa/streams/clustering/RandomRBFGeneratorEvents.java
@@ -31,23 +31,22 @@
 import java.util.Random;
 import java.util.Vector;
 
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Attribute;
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.cluster.Clustering;
 import moa.cluster.SphereCluster;
 import moa.core.AutoExpandVector;
 import moa.core.InstanceExample;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
 import moa.gui.visualization.DataPoint;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.InstanceStream;
 import moa.tasks.TaskMonitor;
-import com.yahoo.labs.samoa.instances.Attribute;
-import com.yahoo.labs.samoa.instances.DenseInstance;
-import moa.core.FastVector;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 
 public class RandomRBFGeneratorEvents extends ClusteringStream {
diff --git a/moa/src/main/java/moa/streams/clustering/SimpleCSVStream.java b/moa/src/main/java/moa/streams/clustering/SimpleCSVStream.java
index fe46621be..946b5d728 100644
--- a/moa/src/main/java/moa/streams/clustering/SimpleCSVStream.java
+++ b/moa/src/main/java/moa/streams/clustering/SimpleCSVStream.java
@@ -34,7 +34,6 @@
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import moa.core.InputStreamProgressMonitor;
 import moa.core.InstanceExample;
diff --git a/moa/src/main/java/moa/streams/filters/AbstractMultiLabelStreamFilter.java b/moa/src/main/java/moa/streams/filters/AbstractMultiLabelStreamFilter.java
index e099e7ba3..4206ba4ca 100644
--- a/moa/src/main/java/moa/streams/filters/AbstractMultiLabelStreamFilter.java
+++ b/moa/src/main/java/moa/streams/filters/AbstractMultiLabelStreamFilter.java
@@ -25,7 +25,6 @@
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.streams.ExampleStream;
-import moa.streams.InstanceStream;
 import moa.tasks.TaskMonitor;
 
 /**
diff --git a/moa/src/main/java/moa/streams/filters/AbstractStreamFilter.java b/moa/src/main/java/moa/streams/filters/AbstractStreamFilter.java
index dd6d3ffbb..29b691cc1 100644
--- a/moa/src/main/java/moa/streams/filters/AbstractStreamFilter.java
+++ b/moa/src/main/java/moa/streams/filters/AbstractStreamFilter.java
@@ -20,11 +20,11 @@
 package moa.streams.filters;
 
 import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.core.InstanceExample;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.streams.ExampleStream;
-import moa.streams.InstanceStream;
 import moa.tasks.TaskMonitor;
 
 /**
diff --git a/moa/src/main/java/moa/streams/filters/AddNoiseFilter.java b/moa/src/main/java/moa/streams/filters/AddNoiseFilter.java
index c7968e479..7787ae0b1 100644
--- a/moa/src/main/java/moa/streams/filters/AddNoiseFilter.java
+++ b/moa/src/main/java/moa/streams/filters/AddNoiseFilter.java
@@ -21,16 +21,15 @@
 
 import java.util.Random;
 
-import moa.core.AutoExpandVector;
-import moa.core.DoubleVector;
-import moa.core.GaussianEstimator;
-import moa.core.InstanceExample;
-
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.GaussianEstimator;
+
 /**
  * Filter for adding random noise to examples in a stream.
  * Noise can be added to attribute values or to class labels.
diff --git a/moa/src/main/java/moa/streams/filters/RBFFilter.java b/moa/src/main/java/moa/streams/filters/RBFFilter.java
index df300eb65..3a7e787a8 100644
--- a/moa/src/main/java/moa/streams/filters/RBFFilter.java
+++ b/moa/src/main/java/moa/streams/filters/RBFFilter.java
@@ -4,14 +4,14 @@
 import java.util.List;
 import java.util.Random;
 
-import moa.core.InstanceExample;
-
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceImpl;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.core.InstanceExample;
+
 public class RBFFilter extends AbstractStreamFilter {
 
 	/**
diff --git a/moa/src/main/java/moa/streams/filters/RemoveDiscreteAttributeFilter.java b/moa/src/main/java/moa/streams/filters/RemoveDiscreteAttributeFilter.java
index f2143f080..d5e49c595 100644
--- a/moa/src/main/java/moa/streams/filters/RemoveDiscreteAttributeFilter.java
+++ b/moa/src/main/java/moa/streams/filters/RemoveDiscreteAttributeFilter.java
@@ -21,14 +21,15 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import moa.core.InstanceExample;
-import moa.streams.InstanceStream;
+
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.SparseInstance;
+
 import moa.core.FastVector;
+import moa.core.InstanceExample;
+import moa.streams.InstanceStream;
 
 /**
  * Filter for removing discrete attributes in instances of a stream.
diff --git a/moa/src/main/java/moa/streams/filters/ReplacingMissingValuesFilter.java b/moa/src/main/java/moa/streams/filters/ReplacingMissingValuesFilter.java
index fefe7f955..718de5a27 100644
--- a/moa/src/main/java/moa/streams/filters/ReplacingMissingValuesFilter.java
+++ b/moa/src/main/java/moa/streams/filters/ReplacingMissingValuesFilter.java
@@ -19,11 +19,6 @@
  */
 package moa.streams.filters;
 
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
@@ -31,6 +26,12 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.core.InstanceExample;
 
 
diff --git a/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java b/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java
index 5270011e2..3847bb637 100644
--- a/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java
+++ b/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java
@@ -3,14 +3,14 @@
 import java.util.ArrayList;
 import java.util.List;
 
-import moa.core.InstanceExample;
-
 import com.github.javacliparser.StringOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstanceImpl;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.core.InstanceExample;
+
 public class SelectAttributesFilter extends AbstractMultiLabelStreamFilter implements MultiLabelStreamFilter{
 
 	/**
diff --git a/moa/src/main/java/moa/streams/filters/StreamFilter.java b/moa/src/main/java/moa/streams/filters/StreamFilter.java
index 2f866dc64..9b864d63a 100644
--- a/moa/src/main/java/moa/streams/filters/StreamFilter.java
+++ b/moa/src/main/java/moa/streams/filters/StreamFilter.java
@@ -20,6 +20,7 @@
 package moa.streams.filters;
 
 import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.streams.ExampleStream;
 
 /**
diff --git a/moa/src/main/java/moa/streams/generators/AgrawalGenerator.java b/moa/src/main/java/moa/streams/generators/AgrawalGenerator.java
index b6fd685eb..9af709ce6 100644
--- a/moa/src/main/java/moa/streams/generators/AgrawalGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/AgrawalGenerator.java
@@ -19,23 +19,20 @@
  */
 package moa.streams.generators;
 
+import java.util.Random;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
-import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
-import java.util.Random;
-import moa.core.Example;
+import moa.core.FastVector;
 import moa.core.InstanceExample;
-
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import moa.streams.ExampleStream;
 import moa.streams.InstanceStream;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/streams/generators/HyperplaneGenerator.java b/moa/src/main/java/moa/streams/generators/HyperplaneGenerator.java
index be6e6aa71..cfaac82ee 100644
--- a/moa/src/main/java/moa/streams/generators/HyperplaneGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/HyperplaneGenerator.java
@@ -20,19 +20,20 @@
 package moa.streams.generators;
 
 import java.util.Random;
+
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Attribute;
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.core.FastVector;
 import moa.core.InstanceExample;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.streams.InstanceStream;
 import moa.tasks.TaskMonitor;
-import com.yahoo.labs.samoa.instances.Attribute;
-import com.yahoo.labs.samoa.instances.DenseInstance;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Stream generator for Hyperplane data stream.
diff --git a/moa/src/main/java/moa/streams/generators/LEDGenerator.java b/moa/src/main/java/moa/streams/generators/LEDGenerator.java
index a57fb1dc1..8479c9479 100644
--- a/moa/src/main/java/moa/streams/generators/LEDGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/LEDGenerator.java
@@ -19,20 +19,19 @@
  */
 package moa.streams.generators;
 
+import java.util.Random;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
-import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
-import java.util.Random;
+import moa.core.FastVector;
 import moa.core.InstanceExample;
-
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.InstanceStream;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/streams/generators/LEDGeneratorDrift.java b/moa/src/main/java/moa/streams/generators/LEDGeneratorDrift.java
index 26ee76a89..01ab912ce 100644
--- a/moa/src/main/java/moa/streams/generators/LEDGeneratorDrift.java
+++ b/moa/src/main/java/moa/streams/generators/LEDGeneratorDrift.java
@@ -19,13 +19,13 @@
  */
 package moa.streams.generators;
 
-import moa.core.InstanceExample;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.core.InstanceExample;
 import moa.core.ObjectRepository;
-import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
 
 /**
diff --git a/moa/src/main/java/moa/streams/generators/RandomRBFGenerator.java b/moa/src/main/java/moa/streams/generators/RandomRBFGenerator.java
index cbbe0202c..fc67d6ab9 100644
--- a/moa/src/main/java/moa/streams/generators/RandomRBFGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/RandomRBFGenerator.java
@@ -19,21 +19,20 @@
  */
 package moa.streams.generators;
 
+import java.io.Serializable;
+import java.util.Random;
+
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
-import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
-import java.io.Serializable;
-import java.util.Random;
+import moa.core.FastVector;
 import moa.core.InstanceExample;
-
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.MiscUtils;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.IntOption;
 import moa.streams.InstanceStream;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/streams/generators/RandomRBFGeneratorDrift.java b/moa/src/main/java/moa/streams/generators/RandomRBFGeneratorDrift.java
index c437a4a95..abcb14e32 100644
--- a/moa/src/main/java/moa/streams/generators/RandomRBFGeneratorDrift.java
+++ b/moa/src/main/java/moa/streams/generators/RandomRBFGeneratorDrift.java
@@ -20,11 +20,11 @@
 package moa.streams.generators;
 
 import java.util.Random;
-import moa.core.InstanceExample;
 
-import com.github.javacliparser.IntOption;
 import com.github.javacliparser.FloatOption;
-import com.yahoo.labs.samoa.instances.Instance;
+import com.github.javacliparser.IntOption;
+
+import moa.core.InstanceExample;
 
 /**
  * Stream generator for a random radial basis function stream with drift.
diff --git a/moa/src/main/java/moa/streams/generators/RandomTreeGenerator.java b/moa/src/main/java/moa/streams/generators/RandomTreeGenerator.java
index 282618a02..157ce8adb 100644
--- a/moa/src/main/java/moa/streams/generators/RandomTreeGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/RandomTreeGenerator.java
@@ -19,22 +19,21 @@
  */
 package moa.streams.generators;
 
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Random;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
-import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.Random;
+import moa.core.FastVector;
 import moa.core.InstanceExample;
-
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.InstanceStream;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/streams/generators/SEAGenerator.java b/moa/src/main/java/moa/streams/generators/SEAGenerator.java
index 06da33f07..e4ede9220 100644
--- a/moa/src/main/java/moa/streams/generators/SEAGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/SEAGenerator.java
@@ -19,20 +19,19 @@
  */
 package moa.streams.generators;
 
+import java.util.Random;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
-import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
-import java.util.Random;
+import moa.core.FastVector;
 import moa.core.InstanceExample;
-
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.InstanceStream;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/streams/generators/STAGGERGenerator.java b/moa/src/main/java/moa/streams/generators/STAGGERGenerator.java
index a92118e17..def9e5ee4 100644
--- a/moa/src/main/java/moa/streams/generators/STAGGERGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/STAGGERGenerator.java
@@ -19,20 +19,19 @@
  */
 package moa.streams.generators;
 
+import java.util.Random;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
-import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
-import java.util.Random;
+import moa.core.FastVector;
 import moa.core.InstanceExample;
-
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.InstanceStream;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/streams/generators/WaveformGenerator.java b/moa/src/main/java/moa/streams/generators/WaveformGenerator.java
index f66e5b0ff..06cc45350 100644
--- a/moa/src/main/java/moa/streams/generators/WaveformGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/WaveformGenerator.java
@@ -19,20 +19,19 @@
  */
 package moa.streams.generators;
 
+import java.util.Random;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
-import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
-import java.util.Random;
+import moa.core.FastVector;
 import moa.core.InstanceExample;
-
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.InstanceStream;
 import moa.tasks.TaskMonitor;
 
diff --git a/moa/src/main/java/moa/streams/generators/WaveformGeneratorDrift.java b/moa/src/main/java/moa/streams/generators/WaveformGeneratorDrift.java
index c918ad8b3..e5b17cfdb 100644
--- a/moa/src/main/java/moa/streams/generators/WaveformGeneratorDrift.java
+++ b/moa/src/main/java/moa/streams/generators/WaveformGeneratorDrift.java
@@ -20,13 +20,13 @@
  */
 package moa.streams.generators;
 
-import moa.core.InstanceExample;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.core.InstanceExample;
 import moa.core.ObjectRepository;
-import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
 
 /**
diff --git a/moa/src/main/java/moa/streams/generators/cd/AbstractConceptDriftGenerator.java b/moa/src/main/java/moa/streams/generators/cd/AbstractConceptDriftGenerator.java
index 7dd440d98..6a1ae7979 100644
--- a/moa/src/main/java/moa/streams/generators/cd/AbstractConceptDriftGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/cd/AbstractConceptDriftGenerator.java
@@ -19,15 +19,16 @@
  */
 package moa.streams.generators.cd;
 
+import java.util.ArrayList;
+import java.util.Random;
+
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import java.util.ArrayList;
-import java.util.Random;
+
 import moa.core.FastVector;
 import moa.core.InstanceExample;
 import moa.core.ObjectRepository;
diff --git a/moa/src/main/java/moa/streams/generators/cd/ConceptDriftGenerator.java b/moa/src/main/java/moa/streams/generators/cd/ConceptDriftGenerator.java
index 02ed7c229..732885aa7 100644
--- a/moa/src/main/java/moa/streams/generators/cd/ConceptDriftGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/cd/ConceptDriftGenerator.java
@@ -20,6 +20,7 @@
 package moa.streams.generators.cd;
 
 import java.util.ArrayList;
+
 import moa.streams.InstanceStream;
 import moa.streams.clustering.ClusterEvent;
 
diff --git a/moa/src/main/java/moa/streams/generators/multilabel/MetaMultilabelGenerator.java b/moa/src/main/java/moa/streams/generators/multilabel/MetaMultilabelGenerator.java
index 62536ddc5..f2ac3625e 100644
--- a/moa/src/main/java/moa/streams/generators/multilabel/MetaMultilabelGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/multilabel/MetaMultilabelGenerator.java
@@ -19,22 +19,32 @@
  */
 package moa.streams.generators.multilabel;
 
-import java.util.*;
-import moa.core.InstanceExample;
-import moa.core.MultilabelInstancesHeader;
-import moa.core.ObjectRepository;
-import moa.options.AbstractOptionHandler;
-import moa.options.ClassOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Random;
+
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
-import moa.streams.InstanceStream;
-import moa.tasks.TaskMonitor;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.SparseInstance;
+
 import moa.core.FastVector;
+import moa.core.InstanceExample;
+import moa.core.MultilabelInstancesHeader;
+import moa.core.ObjectRepository;
 import moa.core.Utils;
+import moa.options.AbstractOptionHandler;
+import moa.options.ClassOption;
+import moa.streams.InstanceStream;
+import moa.tasks.TaskMonitor;
 
 /**
  * Stream generator for multilabel data.
diff --git a/moa/src/main/java/moa/streams/generators/multilabel/MultilabelArffFileStream.java b/moa/src/main/java/moa/streams/generators/multilabel/MultilabelArffFileStream.java
index cec7e0aa4..064d4fae0 100644
--- a/moa/src/main/java/moa/streams/generators/multilabel/MultilabelArffFileStream.java
+++ b/moa/src/main/java/moa/streams/generators/multilabel/MultilabelArffFileStream.java
@@ -19,13 +19,13 @@
  */
 package moa.streams.generators.multilabel;
 
-import moa.streams.ArffFileStream;
-import moa.streams.MultiTargetInstanceStream;
-import moa.core.MultilabelInstancesHeader;
-
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.core.MultilabelInstancesHeader;
+import moa.streams.ArffFileStream;
+import moa.streams.MultiTargetInstanceStream;
+
 /**
  * Stream reader for ARFF files of multilabel data.
  *
diff --git a/moa/src/main/java/moa/tasks/CacheShuffledStream.java b/moa/src/main/java/moa/tasks/CacheShuffledStream.java
index ae50c8c53..91cf2194f 100644
--- a/moa/src/main/java/moa/tasks/CacheShuffledStream.java
+++ b/moa/src/main/java/moa/tasks/CacheShuffledStream.java
@@ -21,10 +21,11 @@
 
 import java.util.Random;
 
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.core.ObjectRepository;
 import moa.options.ClassOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.CachedInstancesStream;
 import moa.streams.InstanceStream;
 
diff --git a/moa/src/main/java/moa/tasks/ConceptDriftMainTask.java b/moa/src/main/java/moa/tasks/ConceptDriftMainTask.java
index a5841fc12..1cdfcf560 100644
--- a/moa/src/main/java/moa/tasks/ConceptDriftMainTask.java
+++ b/moa/src/main/java/moa/tasks/ConceptDriftMainTask.java
@@ -20,6 +20,7 @@
 package moa.tasks;
 
 import java.util.ArrayList;
+
 import moa.streams.clustering.ClusterEvent;
 
 public abstract class ConceptDriftMainTask extends MainTask {
diff --git a/moa/src/main/java/moa/tasks/EvaluateClustering.java b/moa/src/main/java/moa/tasks/EvaluateClustering.java
index 0fc7f4f62..df03b8498 100644
--- a/moa/src/main/java/moa/tasks/EvaluateClustering.java
+++ b/moa/src/main/java/moa/tasks/EvaluateClustering.java
@@ -8,13 +8,14 @@
  */
 package moa.tasks;
 
+import com.github.javacliparser.FileOption;
+import com.github.javacliparser.IntOption;
+
 import moa.clusterers.AbstractClusterer;
 import moa.core.ObjectRepository;
 import moa.evaluation.LearningCurve;
 import moa.gui.BatchCmd;
 import moa.options.ClassOption;
-import com.github.javacliparser.FileOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.clustering.ClusteringStream;
 
 /**
diff --git a/moa/src/main/java/moa/tasks/EvaluateConceptDrift.java b/moa/src/main/java/moa/tasks/EvaluateConceptDrift.java
index 5f268ebb4..c59a965f9 100644
--- a/moa/src/main/java/moa/tasks/EvaluateConceptDrift.java
+++ b/moa/src/main/java/moa/tasks/EvaluateConceptDrift.java
@@ -20,12 +20,14 @@
  */
 package moa.tasks;
 
-import com.github.javacliparser.FileOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.PrintStream;
+
+import com.github.javacliparser.FileOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.core.Example;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
@@ -35,7 +37,6 @@
 import moa.evaluation.LearningPerformanceEvaluator;
 import moa.learners.ChangeDetectorLearner;
 import moa.options.ClassOption;
-
 import moa.streams.clustering.ClusterEvent;
 import moa.streams.generators.cd.ConceptDriftGenerator;
 
diff --git a/moa/src/main/java/moa/tasks/EvaluateInterleavedChunks.java b/moa/src/main/java/moa/tasks/EvaluateInterleavedChunks.java
index f8c78b6bb..5ce5a1ec2 100644
--- a/moa/src/main/java/moa/tasks/EvaluateInterleavedChunks.java
+++ b/moa/src/main/java/moa/tasks/EvaluateInterleavedChunks.java
@@ -22,7 +22,12 @@
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.PrintStream;
-import moa.classifiers.Classifier;
+
+import com.github.javacliparser.FileOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.core.Example;
 import moa.core.InstanceExample;
 import moa.core.Measurement;
@@ -33,12 +38,7 @@
 import moa.evaluation.LearningPerformanceEvaluator;
 import moa.learners.Learner;
 import moa.options.ClassOption;
-import com.github.javacliparser.FileOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.ExampleStream;
-import moa.streams.InstanceStream;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public class EvaluateInterleavedChunks extends MainTask {
 
diff --git a/moa/src/main/java/moa/tasks/EvaluateInterleavedTestThenTrain.java b/moa/src/main/java/moa/tasks/EvaluateInterleavedTestThenTrain.java
index 36791f102..46f6ca2c2 100644
--- a/moa/src/main/java/moa/tasks/EvaluateInterleavedTestThenTrain.java
+++ b/moa/src/main/java/moa/tasks/EvaluateInterleavedTestThenTrain.java
@@ -23,7 +23,9 @@
 import java.io.FileOutputStream;
 import java.io.PrintStream;
 
-import moa.classifiers.Classifier;
+import com.github.javacliparser.FileOption;
+import com.github.javacliparser.IntOption;
+
 import moa.core.Example;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
@@ -33,11 +35,8 @@
 import moa.evaluation.LearningPerformanceEvaluator;
 import moa.learners.Learner;
 import moa.options.ClassOption;
-import com.github.javacliparser.FileOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.ExampleStream;
 import moa.streams.InstanceStream;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Task for evaluating a classifier on a stream by testing then training with each example in sequence.
diff --git a/moa/src/main/java/moa/tasks/EvaluateModel.java b/moa/src/main/java/moa/tasks/EvaluateModel.java
index a9fe3f056..04dbd4aab 100644
--- a/moa/src/main/java/moa/tasks/EvaluateModel.java
+++ b/moa/src/main/java/moa/tasks/EvaluateModel.java
@@ -22,8 +22,11 @@
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.PrintStream;
+
 import com.github.javacliparser.FileOption;
 import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.Classifier;
 import moa.core.Example;
 import moa.core.ObjectRepository;
@@ -34,7 +37,6 @@
 import moa.options.ClassOption;
 import moa.streams.ExampleStream;
 import moa.streams.InstanceStream;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Task for evaluating a static model on a stream.
diff --git a/moa/src/main/java/moa/tasks/EvaluateModelMultiTarget.java b/moa/src/main/java/moa/tasks/EvaluateModelMultiTarget.java
index df5d18631..0ef68f18f 100644
--- a/moa/src/main/java/moa/tasks/EvaluateModelMultiTarget.java
+++ b/moa/src/main/java/moa/tasks/EvaluateModelMultiTarget.java
@@ -19,12 +19,14 @@
  */
 package moa.tasks;
 
-import com.github.javacliparser.FileOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.PrintStream;
+
+import com.github.javacliparser.FileOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.Classifier;
 import moa.classifiers.MultiTargetRegressor;
 import moa.core.Example;
diff --git a/moa/src/main/java/moa/tasks/EvaluateModelRegression.java b/moa/src/main/java/moa/tasks/EvaluateModelRegression.java
index 34b57232c..3e7318e1a 100644
--- a/moa/src/main/java/moa/tasks/EvaluateModelRegression.java
+++ b/moa/src/main/java/moa/tasks/EvaluateModelRegression.java
@@ -22,13 +22,15 @@
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.PrintStream;
+
 import com.github.javacliparser.FileOption;
 import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.classifiers.Classifier;
 import moa.classifiers.Regressor;
 import moa.core.Example;
 import moa.core.ObjectRepository;
-import moa.core.Utils;
 import moa.evaluation.LearningEvaluation;
 import moa.evaluation.LearningPerformanceEvaluator;
 import moa.evaluation.RegressionPerformanceEvaluator;
@@ -36,7 +38,6 @@
 import moa.options.ClassOption;
 import moa.streams.ExampleStream;
 import moa.streams.InstanceStream;
-import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Task for evaluating a static model on a stream.
diff --git a/moa/src/main/java/moa/tasks/EvaluateOnlineRecommender.java b/moa/src/main/java/moa/tasks/EvaluateOnlineRecommender.java
index 0fbc8cb32..470382d9c 100644
--- a/moa/src/main/java/moa/tasks/EvaluateOnlineRecommender.java
+++ b/moa/src/main/java/moa/tasks/EvaluateOnlineRecommender.java
@@ -19,12 +19,13 @@
  */
 package moa.tasks;
 
+import com.github.javacliparser.IntOption;
+
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
 import moa.evaluation.LearningCurve;
 import moa.evaluation.LearningEvaluation;
 import moa.options.ClassOption;
-import com.github.javacliparser.IntOption;
 import moa.recommender.dataset.Dataset;
 import moa.recommender.predictor.RatingPredictor;
 import moa.recommender.rc.data.RecommenderData;
diff --git a/moa/src/main/java/moa/tasks/EvaluatePeriodicHeldOutTest.java b/moa/src/main/java/moa/tasks/EvaluatePeriodicHeldOutTest.java
index 22e8975e6..b79a1cb03 100644
--- a/moa/src/main/java/moa/tasks/EvaluatePeriodicHeldOutTest.java
+++ b/moa/src/main/java/moa/tasks/EvaluatePeriodicHeldOutTest.java
@@ -25,10 +25,17 @@
 import java.io.PrintStream;
 import java.util.ArrayList;
 import java.util.List;
+
 import com.github.javacliparser.FileOption;
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.IntOption;
+<<<<<<< c4a46917f06a4f4c3c08e67d06f6762cca1b47f9
 import moa.classifiers.Classifier;
+=======
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
+>>>>>>> Instances rework, new iSOUPTree models and import cleanup
 import moa.core.Example;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
@@ -41,8 +48,6 @@
 import moa.options.ClassOption;
 import moa.streams.CachedInstancesStream;
 import moa.streams.ExampleStream;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
  * Task for evaluating a classifier on a stream by periodically testing on a heldout set.
diff --git a/moa/src/main/java/moa/tasks/EvaluatePrequential.java b/moa/src/main/java/moa/tasks/EvaluatePrequential.java
index 51a4019b5..22adf218e 100644
--- a/moa/src/main/java/moa/tasks/EvaluatePrequential.java
+++ b/moa/src/main/java/moa/tasks/EvaluatePrequential.java
@@ -24,27 +24,25 @@
 import java.io.FileOutputStream;
 import java.io.PrintStream;
 
-import moa.classifiers.Classifier;
+import com.github.javacliparser.FileOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
 import moa.core.Example;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
 import moa.core.TimingUtils;
-import moa.evaluation.WindowClassificationPerformanceEvaluator;
+import moa.core.Utils;
 import moa.evaluation.EWMAClassificationPerformanceEvaluator;
 import moa.evaluation.FadingFactorClassificationPerformanceEvaluator;
 import moa.evaluation.LearningCurve;
 import moa.evaluation.LearningEvaluation;
 import moa.evaluation.LearningPerformanceEvaluator;
+import moa.evaluation.WindowClassificationPerformanceEvaluator;
 import moa.learners.Learner;
 import moa.options.ClassOption;
-
-import com.github.javacliparser.FileOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.ExampleStream;
-import moa.streams.InstanceStream;
-import com.yahoo.labs.samoa.instances.Instance;
-import moa.core.Utils;
 
 /**
  * Task for evaluating a classifier on a stream by testing then training with each example in sequence.
diff --git a/moa/src/main/java/moa/tasks/EvaluatePrequentialCV.java b/moa/src/main/java/moa/tasks/EvaluatePrequentialCV.java
index f68d5036a..68b5b2545 100644
--- a/moa/src/main/java/moa/tasks/EvaluatePrequentialCV.java
+++ b/moa/src/main/java/moa/tasks/EvaluatePrequentialCV.java
@@ -20,18 +20,6 @@
  */
 package moa.tasks;
 
-import com.github.javacliparser.FileOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import moa.classifiers.Classifier;
-import moa.core.*;
-import moa.evaluation.*;
-import moa.learners.Learner;
-import moa.options.ClassOption;
-import moa.streams.ExampleStream;
-
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.PrintStream;
@@ -40,6 +28,22 @@
 import java.util.List;
 import java.util.Random;
 
+import com.github.javacliparser.FileOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+
+import moa.core.Example;
+import moa.core.Measurement;
+import moa.core.MiscUtils;
+import moa.core.ObjectRepository;
+import moa.core.TimingUtils;
+import moa.evaluation.LearningCurve;
+import moa.evaluation.LearningEvaluation;
+import moa.evaluation.LearningPerformanceEvaluator;
+import moa.learners.Learner;
+import moa.options.ClassOption;
+import moa.streams.ExampleStream;
+
 /**
  * Task for prequential cross-validation evaluation of a classifier on a stream by testing then training with each
  * example in sequence and doing cross-validation at the same time.
diff --git a/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java b/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
index 9b3a1920b..ec057e886 100644
--- a/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
+++ b/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java
@@ -1,3 +1,4 @@
+<<<<<<< c4a46917f06a4f4c3c08e67d06f6762cca1b47f9
 /*
  *    EvaluatePrequentialMultiTarget.java
  *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
@@ -129,6 +130,214 @@ protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
 			if (widthOption.getValue() != 1000) {
 				System.out.println("DEPRECATED! Use EvaluatePrequential -e (WindowClassificationPerformanceEvaluator -w " + widthOption.getValue() + ")");
 				return learningCurve;
+=======
+/*
+ *    EvaluatePrequentialMultiTarget.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *    
+ */
+package moa.tasks;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.PrintStream;
+
+import com.github.javacliparser.FileOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.Prediction;
+
+import moa.classifiers.MultiTargetRegressor;
+import moa.core.Example;
+import moa.core.Measurement;
+import moa.core.ObjectRepository;
+import moa.core.TimingUtils;
+import moa.evaluation.EWMAClassificationPerformanceEvaluator;
+import moa.evaluation.FadingFactorClassificationPerformanceEvaluator;
+import moa.evaluation.LearningCurve;
+import moa.evaluation.LearningEvaluation;
+import moa.evaluation.LearningPerformanceEvaluator;
+import moa.evaluation.MultiTargetPerformanceEvaluator;
+import moa.evaluation.WindowClassificationPerformanceEvaluator;
+import moa.learners.Learner;
+import moa.options.ClassOption;
+import moa.streams.ExampleStream;
+import moa.streams.MultiTargetInstanceStream;
+
+/**
+ * Task for evaluating a classifier on a stream by testing then training with each example in sequence.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @version $Revision: 7 $
+ */
+public class EvaluatePrequentialMultiTarget extends MultiTargetMainTask {
+
+	@Override
+	public String getPurposeString() {
+		return "Evaluates a classifier on a stream by testing then training with each example in sequence.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption learnerOption = new ClassOption("learner", 'l',
+			"Learner to train.", MultiTargetRegressor.class, "moa.classifiers.multitarget.functions.MultiTargetNoChange");
+
+	public ClassOption streamOption = new ClassOption("stream", 's',
+			"Stream to learn from.", MultiTargetInstanceStream.class,
+			"MultiTargetArffFileStream");
+
+	public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
+			"Classification performance evaluation method.",
+			MultiTargetPerformanceEvaluator.class,
+			"BasicMultiTargetPerformanceEvaluator");
+
+	public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
+			"Maximum number of instances to test/train on  (-1 = no limit).",
+			100000000, -1, Integer.MAX_VALUE);
+
+	public IntOption timeLimitOption = new IntOption("timeLimit", 't',
+			"Maximum number of seconds to test/train for (-1 = no limit).", -1,
+			-1, Integer.MAX_VALUE);
+
+	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
+			'f',
+			"How many instances between samples of the learning performance.",
+			100000, 0, Integer.MAX_VALUE);
+
+	public IntOption memCheckFrequencyOption = new IntOption(
+			"memCheckFrequency", 'q',
+			"How many instances between memory bound checks.", 100000, 0,
+			Integer.MAX_VALUE);
+
+	public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
+			"File to append intermediate csv results to.", null, "csv", true);
+
+	public FileOption outputPredictionFileOption = new FileOption("outputPredictionFile", 'o',
+			"File to append output predictions to.", null, "pred", true);
+
+	//New for prequential method DEPRECATED
+	public IntOption widthOption = new IntOption("width",
+			'w', "Size of Window", 1000);
+
+	public FloatOption alphaOption = new FloatOption("alpha",
+			'a', "Fading factor or exponential smoothing factor", .01);
+	//End New for prequential methods
+
+	@Override
+	public Class<?> getTaskResultType() {
+		return LearningCurve.class;
+	}
+
+	@Override
+	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
+		Learner learner = (Learner) getPreparedClassOption(this.learnerOption);
+		ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
+		LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
+		LearningCurve learningCurve = new LearningCurve(
+				"learning evaluation instances");
+
+		//New for prequential methods
+		if (evaluator instanceof WindowClassificationPerformanceEvaluator) {
+			//((WindowClassificationPerformanceEvaluator) evaluator).setWindowWidth(widthOption.getValue());
+			if (widthOption.getValue() != 1000) {
+				System.out.println("DEPRECATED! Use EvaluatePrequential -e (WindowClassificationPerformanceEvaluator -w " + widthOption.getValue() + ")");
+				return learningCurve;
+			}
+		}
+		if (evaluator instanceof EWMAClassificationPerformanceEvaluator) {
+			//((EWMAClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
+			if (alphaOption.getValue() != .01) {
+				System.out.println("DEPRECATED! Use EvaluatePrequential -e (EWMAClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
+				return learningCurve;
+			}
+		}
+		if (evaluator instanceof FadingFactorClassificationPerformanceEvaluator) {
+			//((FadingFactorClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
+			if (alphaOption.getValue() != .01) {
+				System.out.println("DEPRECATED! Use EvaluatePrequential -e (FadingFactorClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
+				return learningCurve;
+			}
+		}
+		//End New for prequential methods
+
+		learner.setModelContext(stream.getHeader());
+		int maxInstances = this.instanceLimitOption.getValue();
+		long instancesProcessed = 0;
+		int maxSeconds = this.timeLimitOption.getValue();
+		int secondsElapsed = 0;
+		monitor.setCurrentActivity("Evaluating learner...", -1.0);
+
+		File dumpFile = this.dumpFileOption.getFile();
+		PrintStream immediateResultStream = null;
+		if (dumpFile != null) {
+			try {
+				if (dumpFile.exists()) {
+					immediateResultStream = new PrintStream(
+							new FileOutputStream(dumpFile, true), true);
+				} else {
+					immediateResultStream = new PrintStream(
+							new FileOutputStream(dumpFile), true);
+				}
+			} catch (Exception ex) {
+				throw new RuntimeException(
+						"Unable to open immediate result file: " + dumpFile, ex);
+			}
+		}
+		//File for output predictions
+		File outputPredictionFile = this.outputPredictionFileOption.getFile();
+		PrintStream outputPredictionResultStream = null;
+		if (outputPredictionFile != null) {
+			try {
+				if (outputPredictionFile.exists()) {
+					outputPredictionResultStream = new PrintStream(
+							new FileOutputStream(outputPredictionFile, true), true);
+				} else {
+					outputPredictionResultStream = new PrintStream(
+							new FileOutputStream(outputPredictionFile), true);
+				}
+			} catch (Exception ex) {
+				throw new RuntimeException(
+						"Unable to open prediction result file: " + outputPredictionFile, ex);
+			}
+		}
+		boolean firstDump = true;
+		boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
+		long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+		long lastEvaluateStartTime = evaluateStartTime;
+		double RAMHours = 0.0;
+		while (stream.hasMoreInstances()
+				&& ((maxInstances < 0) || (instancesProcessed < maxInstances))
+				&& ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
+			Example trainInst = stream.nextInstance();
+			Example testInst = (Example) trainInst; //.copy();
+			//testInst.setClassMissing();
+			//double[] prediction = learner.getVotesForInstance(testInst);
+			Prediction prediction = learner.getPredictionForInstance(testInst);
+			// Output prediction
+			if (outputPredictionFile != null) {
+				StringBuilder sb = new StringBuilder();
+				for (int i = 0; i < ((Instance) trainInst.getData()).numOutputAttributes(); i++) {
+					sb.append("Out " + i + ": " + ((Instance) trainInst.getData()).valueOutputAttribute(i) + " ");
+				}
+				outputPredictionResultStream.println(prediction + "," + sb.toString());
+>>>>>>> Instances rework, new iSOUPTree models and import cleanup
 			}
 		}
 		if (evaluator instanceof EWMAClassificationPerformanceEvaluator) {
diff --git a/moa/src/main/java/moa/tasks/EvaluatePrequentialRegression.java b/moa/src/main/java/moa/tasks/EvaluatePrequentialRegression.java
index 7a3d8b059..56996cb47 100644
--- a/moa/src/main/java/moa/tasks/EvaluatePrequentialRegression.java
+++ b/moa/src/main/java/moa/tasks/EvaluatePrequentialRegression.java
@@ -24,32 +24,28 @@
 import java.io.FileOutputStream;
 import java.io.PrintStream;
 
+import com.github.javacliparser.FileOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.Prediction;
+
+import moa.classifiers.Regressor;
 import moa.core.Example;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
 import moa.core.TimingUtils;
-import moa.evaluation.WindowClassificationPerformanceEvaluator;
 import moa.evaluation.EWMAClassificationPerformanceEvaluator;
 import moa.evaluation.FadingFactorClassificationPerformanceEvaluator;
 import moa.evaluation.LearningCurve;
 import moa.evaluation.LearningEvaluation;
 import moa.evaluation.LearningPerformanceEvaluator;
+import moa.evaluation.RegressionPerformanceEvaluator;
+import moa.evaluation.WindowClassificationPerformanceEvaluator;
 import moa.learners.Learner;
 import moa.options.ClassOption;
-
-import com.github.javacliparser.FileOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-
-import moa.classifiers.Regressor;
 import moa.streams.ExampleStream;
 
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.Prediction;
-
-import moa.evaluation.RegressionPerformanceEvaluator;
-
 /**
  * Task for evaluating a classifier on a stream by testing then training with each example in sequence.
  *
diff --git a/moa/src/main/java/moa/tasks/LearnModel.java b/moa/src/main/java/moa/tasks/LearnModel.java
index f9fa58608..cb5362421 100644
--- a/moa/src/main/java/moa/tasks/LearnModel.java
+++ b/moa/src/main/java/moa/tasks/LearnModel.java
@@ -19,11 +19,12 @@
  */
 package moa.tasks;
 
+import com.github.javacliparser.IntOption;
+
 import moa.classifiers.Classifier;
 import moa.core.ObjectRepository;
 import moa.learners.Learner;
 import moa.options.ClassOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.ExampleStream;
 import moa.streams.InstanceStream;
 
diff --git a/moa/src/main/java/moa/tasks/LearnModelMultiTarget.java b/moa/src/main/java/moa/tasks/LearnModelMultiTarget.java
index e1ce7f43f..14f30af31 100644
--- a/moa/src/main/java/moa/tasks/LearnModelMultiTarget.java
+++ b/moa/src/main/java/moa/tasks/LearnModelMultiTarget.java
@@ -20,6 +20,7 @@
 package moa.tasks;
 
 import com.github.javacliparser.IntOption;
+
 import moa.classifiers.Classifier;
 import moa.classifiers.MultiTargetRegressor;
 import moa.core.ObjectRepository;
diff --git a/moa/src/main/java/moa/tasks/LearnModelRegression.java b/moa/src/main/java/moa/tasks/LearnModelRegression.java
index 84e1cca2e..4869602e3 100644
--- a/moa/src/main/java/moa/tasks/LearnModelRegression.java
+++ b/moa/src/main/java/moa/tasks/LearnModelRegression.java
@@ -19,12 +19,13 @@
  */
 package moa.tasks;
 
+import com.github.javacliparser.IntOption;
+
 import moa.classifiers.Classifier;
+import moa.classifiers.Regressor;
 import moa.core.ObjectRepository;
 import moa.learners.Learner;
 import moa.options.ClassOption;
-import com.github.javacliparser.IntOption;
-import moa.classifiers.Regressor;
 import moa.streams.ExampleStream;
 import moa.streams.InstanceStream;
 
diff --git a/moa/src/main/java/moa/tasks/MainTask.java b/moa/src/main/java/moa/tasks/MainTask.java
index cc5498311..4a62e816f 100644
--- a/moa/src/main/java/moa/tasks/MainTask.java
+++ b/moa/src/main/java/moa/tasks/MainTask.java
@@ -23,9 +23,10 @@
 import java.io.IOException;
 import java.io.Serializable;
 
+import com.github.javacliparser.FileOption;
+
 import moa.core.ObjectRepository;
 import moa.core.SerializeUtils;
-import com.github.javacliparser.FileOption;
 
 /**
  * Abstract Main Task. All tasks that want to write their result 
diff --git a/moa/src/main/java/moa/tasks/MeasureStreamSpeed.java b/moa/src/main/java/moa/tasks/MeasureStreamSpeed.java
index 49d05a34e..2651db95c 100644
--- a/moa/src/main/java/moa/tasks/MeasureStreamSpeed.java
+++ b/moa/src/main/java/moa/tasks/MeasureStreamSpeed.java
@@ -19,14 +19,14 @@
  */
 package moa.tasks;
 
+import com.github.javacliparser.IntOption;
+
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
 import moa.core.TimingUtils;
 import moa.evaluation.LearningEvaluation;
 import moa.options.ClassOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.ExampleStream;
-import moa.streams.InstanceStream;
 
 /**
  * Task for measuring the speed of the stream.
diff --git a/moa/src/main/java/moa/tasks/MultiTargetMainTask.java b/moa/src/main/java/moa/tasks/MultiTargetMainTask.java
index 0d0797078..1b5ce701e 100644
--- a/moa/src/main/java/moa/tasks/MultiTargetMainTask.java
+++ b/moa/src/main/java/moa/tasks/MultiTargetMainTask.java
@@ -5,7 +5,7 @@
 package moa.tasks;
 
 import java.util.ArrayList;
-import moa.streams.InstanceStream;
+
 import moa.streams.clustering.ClusterEvent;
 
 /**
diff --git a/moa/src/main/java/moa/tasks/Plot.java b/moa/src/main/java/moa/tasks/Plot.java
index 8ea104707..328625433 100644
--- a/moa/src/main/java/moa/tasks/Plot.java
+++ b/moa/src/main/java/moa/tasks/Plot.java
@@ -26,7 +26,6 @@
 import java.io.IOException;
 import java.io.InputStreamReader;
 
-import moa.core.ObjectRepository;
 import com.github.javacliparser.FileOption;
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.IntOption;
@@ -34,6 +33,8 @@
 import com.github.javacliparser.MultiChoiceOption;
 import com.github.javacliparser.StringOption;
 
+import moa.core.ObjectRepository;
+
 /**
  * A task allowing to create and plot gnuplot scripts.
  * 
diff --git a/moa/src/main/java/moa/tasks/RegressionMainTask.java b/moa/src/main/java/moa/tasks/RegressionMainTask.java
index e6eeffa1f..fc45af42d 100644
--- a/moa/src/main/java/moa/tasks/RegressionMainTask.java
+++ b/moa/src/main/java/moa/tasks/RegressionMainTask.java
@@ -5,7 +5,7 @@
 package moa.tasks;
 
 import java.util.ArrayList;
-import moa.streams.InstanceStream;
+
 import moa.streams.clustering.ClusterEvent;
 
 /**
diff --git a/moa/src/main/java/moa/tasks/RunStreamTasks.java b/moa/src/main/java/moa/tasks/RunStreamTasks.java
index ded79182a..43d5621ee 100644
--- a/moa/src/main/java/moa/tasks/RunStreamTasks.java
+++ b/moa/src/main/java/moa/tasks/RunStreamTasks.java
@@ -22,6 +22,7 @@
 
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.StringOption;
+
 import moa.MOAObject;
 import moa.core.ObjectRepository;
 import moa.options.ClassOption;
diff --git a/moa/src/main/java/moa/tasks/RunTasks.java b/moa/src/main/java/moa/tasks/RunTasks.java
index 47314962b..4e79f573e 100644
--- a/moa/src/main/java/moa/tasks/RunTasks.java
+++ b/moa/src/main/java/moa/tasks/RunTasks.java
@@ -20,11 +20,12 @@
  */
 package moa.tasks;
 
-import moa.core.ObjectRepository;
-import moa.options.ClassOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.StringOption;
 
+import moa.core.ObjectRepository;
+import moa.options.ClassOption;
+
 /**
  * Task for running several experiments modifying values of parameters.
  *
diff --git a/moa/src/main/java/moa/tasks/WriteStreamToARFFFile.java b/moa/src/main/java/moa/tasks/WriteStreamToARFFFile.java
index d0f252703..314dde2ad 100644
--- a/moa/src/main/java/moa/tasks/WriteStreamToARFFFile.java
+++ b/moa/src/main/java/moa/tasks/WriteStreamToARFFFile.java
@@ -24,13 +24,12 @@
 import java.io.FileWriter;
 import java.io.Writer;
 
-import moa.core.ObjectRepository;
-import moa.options.ClassOption;
 import com.github.javacliparser.FileOption;
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.InstanceImpl;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
+
+import moa.core.ObjectRepository;
+import moa.options.ClassOption;
 import moa.streams.InstanceStream;
 
 /**
diff --git a/moa/src/main/java/weka/classifiers/meta/MOA.java b/moa/src/main/java/weka/classifiers/meta/MOA.java
index e736f1495..753969d2a 100644
--- a/moa/src/main/java/weka/classifiers/meta/MOA.java
+++ b/moa/src/main/java/weka/classifiers/meta/MOA.java
@@ -21,23 +21,23 @@
 
 package weka.classifiers.meta;
 
+import java.util.Enumeration;
+import java.util.Vector;
+
+import com.yahoo.labs.samoa.instances.WekaToSamoaInstanceConverter;
+
+import moa.classifiers.Classifier;
+import moa.classifiers.trees.DecisionStump;
+import moa.options.ClassOption;
 import weka.classifiers.UpdateableClassifier;
 import weka.core.Capabilities;
+import weka.core.Capabilities.Capability;
 import weka.core.Instance;
 import weka.core.Instances;
 import weka.core.MOAUtils;
 import weka.core.Option;
 import weka.core.RevisionUtils;
 import weka.core.Utils;
-import weka.core.Capabilities.Capability;
-
-import java.util.Enumeration;
-import java.util.Vector;
-
-import moa.classifiers.Classifier;
-import moa.classifiers.trees.DecisionStump;
-import moa.options.ClassOption;
-import com.yahoo.labs.samoa.instances.WekaToSamoaInstanceConverter;
 
 /**
  <!-- globalinfo-start -->
diff --git a/moa/src/main/java/weka/datagenerators/classifiers/classification/MOA.java b/moa/src/main/java/weka/datagenerators/classifiers/classification/MOA.java
index 50537008e..76257e8e6 100644
--- a/moa/src/main/java/weka/datagenerators/classifiers/classification/MOA.java
+++ b/moa/src/main/java/weka/datagenerators/classifiers/classification/MOA.java
@@ -22,24 +22,23 @@
 
 package weka.datagenerators.classifiers.classification;
 
-import weka.core.Instance;
-import weka.core.Instances;
-import weka.core.MOAUtils;
-import weka.core.Option;
-import weka.core.RevisionUtils;
-import weka.core.Utils;
-import weka.datagenerators.ClassificationGenerator;
-
 import java.util.Enumeration;
 import java.util.Random;
 import java.util.Vector;
 
+import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
+
 import moa.options.AbstractOptionHandler;
 import moa.options.ClassOption;
 import moa.streams.InstanceStream;
 import moa.streams.generators.LEDGenerator;
-import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
-import com.yahoo.labs.samoa.instances.WekaToSamoaInstanceConverter;
+import weka.core.Instance;
+import weka.core.Instances;
+import weka.core.MOAUtils;
+import weka.core.Option;
+import weka.core.RevisionUtils;
+import weka.core.Utils;
+import weka.datagenerators.ClassificationGenerator;
 
 /**
  <!-- globalinfo-start -->
diff --git a/moa/src/main/java/weka/gui/MOAClassOptionEditor.java b/moa/src/main/java/weka/gui/MOAClassOptionEditor.java
index 5604cf644..029f0f025 100644
--- a/moa/src/main/java/weka/gui/MOAClassOptionEditor.java
+++ b/moa/src/main/java/weka/gui/MOAClassOptionEditor.java
@@ -20,10 +20,11 @@
 import javax.swing.event.ChangeEvent;
 import javax.swing.event.ChangeListener;
 
+import com.github.javacliparser.Option;
 import com.github.javacliparser.gui.ClassOptionEditComponent;
 import com.github.javacliparser.gui.OptionsConfigurationPanel;
+
 import moa.options.ClassOption;
-import com.github.javacliparser.Option;
 
 /**
  * An editor for MOA ClassOption objects.
diff --git a/moa/src/test/java/com/yahoo/labs/samoa/instances/MultiTargetArffLoaderTest.java b/moa/src/test/java/com/yahoo/labs/samoa/instances/MultiTargetArffLoaderTest.java
index 1171e785b..adf24d539 100644
--- a/moa/src/test/java/com/yahoo/labs/samoa/instances/MultiTargetArffLoaderTest.java
+++ b/moa/src/test/java/com/yahoo/labs/samoa/instances/MultiTargetArffLoaderTest.java
@@ -1,6 +1,7 @@
 package com.yahoo.labs.samoa.instances;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 import java.io.BufferedReader;
 import java.io.FileInputStream;
@@ -9,15 +10,6 @@
 import java.io.InputStreamReader;
 import java.io.Reader;
 
-import moa.core.InputStreamProgressMonitor;
-import moa.streams.ArffFileStream;
-import moa.streams.MultiTargetArffFileStream;
-import moa.test.MoaTestCase;
-import moa.test.TmpFile;
-
-import org.junit.After;
-import org.junit.AfterClass;
-import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
 
diff --git a/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java b/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java
index 4987e2718..7cccd9e5a 100644
--- a/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java
+++ b/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java
@@ -24,6 +24,9 @@
 import java.io.InputStreamReader;
 import java.io.Reader;
 
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.core.Example;
 import moa.core.InstanceExample;
 import moa.core.Measurement;
@@ -34,9 +37,6 @@
 import moa.test.TmpFile;
 import weka.core.MOAUtils;
 
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
 /**
  * Ancestor for all classifier test cases.
  * 
@@ -130,14 +130,8 @@ protected AbstractTestHelper newTestHelper() {
 	 */
 	protected InstancesHeader load(String filename, int classIndex) {
 		InstancesHeader	result = null;
-		//ArffLoader 	loader;
-
-		//result = null;
 
 		try {
-			/*loader = new ArffLoader();
-      loader.setFile(new TmpFile(filename));
-      result = loader.getDataSet();*/ // JD: weka's ARffLoader
 			TmpFile tmp=new TmpFile(filename);
 			FileInputStream fileStream = new FileInputStream(tmp.getAbsolutePath());
 			Reader reader=new BufferedReader(new InputStreamReader(fileStream));
diff --git a/moa/src/test/java/moa/classifiers/AbstractMultipleClassifierTestCase.java b/moa/src/test/java/moa/classifiers/AbstractMultipleClassifierTestCase.java
index bbb6a231f..1c59250f4 100644
--- a/moa/src/test/java/moa/classifiers/AbstractMultipleClassifierTestCase.java
+++ b/moa/src/test/java/moa/classifiers/AbstractMultipleClassifierTestCase.java
@@ -22,7 +22,6 @@
 
 import moa.core.Example;
 import moa.evaluation.BasicClassificationPerformanceEvaluator;
-import moa.evaluation.BasicRegressionPerformanceEvaluator;
 import moa.evaluation.LearningPerformanceEvaluator;
 
 /**
diff --git a/moa/src/test/java/moa/classifiers/AbstractMultipleRegressorTestCase.java b/moa/src/test/java/moa/classifiers/AbstractMultipleRegressorTestCase.java
index 657782eed..1cfab00ef 100644
--- a/moa/src/test/java/moa/classifiers/AbstractMultipleRegressorTestCase.java
+++ b/moa/src/test/java/moa/classifiers/AbstractMultipleRegressorTestCase.java
@@ -22,7 +22,6 @@
 
 import moa.core.Example;
 import moa.evaluation.BasicRegressionPerformanceEvaluator;
-import moa.evaluation.ClassificationPerformanceEvaluator;
 import moa.evaluation.LearningPerformanceEvaluator;
 
 /**
diff --git a/moa/src/test/java/moa/classifiers/active/ActiveClassifierTest.java b/moa/src/test/java/moa/classifiers/active/ActiveClassifierTest.java
index 51cce2895..4ccc930ce 100644
--- a/moa/src/test/java/moa/classifiers/active/ActiveClassifierTest.java
+++ b/moa/src/test/java/moa/classifiers/active/ActiveClassifierTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the ActiveClassifier classifier.
diff --git a/moa/src/test/java/moa/classifiers/drift/SingleClassifierDriftTest.java b/moa/src/test/java/moa/classifiers/drift/SingleClassifierDriftTest.java
index 3fe81a73c..959679e80 100644
--- a/moa/src/test/java/moa/classifiers/drift/SingleClassifierDriftTest.java
+++ b/moa/src/test/java/moa/classifiers/drift/SingleClassifierDriftTest.java
@@ -24,7 +24,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the SingleClassifierDrift classifier.
diff --git a/moa/src/test/java/moa/classifiers/functions/MajorityClassTest.java b/moa/src/test/java/moa/classifiers/functions/MajorityClassTest.java
index c74a92408..05cd19aaa 100644
--- a/moa/src/test/java/moa/classifiers/functions/MajorityClassTest.java
+++ b/moa/src/test/java/moa/classifiers/functions/MajorityClassTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the MajorityClass classifier.
diff --git a/moa/src/test/java/moa/classifiers/functions/NoChangeTest.java b/moa/src/test/java/moa/classifiers/functions/NoChangeTest.java
index 9bb60fb75..f2a16a5ae 100644
--- a/moa/src/test/java/moa/classifiers/functions/NoChangeTest.java
+++ b/moa/src/test/java/moa/classifiers/functions/NoChangeTest.java
@@ -24,7 +24,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the NoChange classifier.
diff --git a/moa/src/test/java/moa/classifiers/functions/PerceptronTest.java b/moa/src/test/java/moa/classifiers/functions/PerceptronTest.java
index b7bf710dc..7019b4a25 100644
--- a/moa/src/test/java/moa/classifiers/functions/PerceptronTest.java
+++ b/moa/src/test/java/moa/classifiers/functions/PerceptronTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the Perceptron classifier.
diff --git a/moa/src/test/java/moa/classifiers/functions/SGDTest.java b/moa/src/test/java/moa/classifiers/functions/SGDTest.java
index 7319242a9..34f6c6783 100644
--- a/moa/src/test/java/moa/classifiers/functions/SGDTest.java
+++ b/moa/src/test/java/moa/classifiers/functions/SGDTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the SGD classifier.
diff --git a/moa/src/test/java/moa/classifiers/functions/SPegasosTest.java b/moa/src/test/java/moa/classifiers/functions/SPegasosTest.java
index 5f6d7c5d7..6586cb408 100644
--- a/moa/src/test/java/moa/classifiers/functions/SPegasosTest.java
+++ b/moa/src/test/java/moa/classifiers/functions/SPegasosTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the SPegasos classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/AccuracyUpdatedEnsembleTest.java b/moa/src/test/java/moa/classifiers/meta/AccuracyUpdatedEnsembleTest.java
index 404dbd614..54044879c 100644
--- a/moa/src/test/java/moa/classifiers/meta/AccuracyUpdatedEnsembleTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/AccuracyUpdatedEnsembleTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the AccuracyUpdatedEnsemble classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/AccuracyWeightedEnsembleTest.java b/moa/src/test/java/moa/classifiers/meta/AccuracyWeightedEnsembleTest.java
index 9a1be3d65..62aa6ff98 100644
--- a/moa/src/test/java/moa/classifiers/meta/AccuracyWeightedEnsembleTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/AccuracyWeightedEnsembleTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the AccuracyWeightedEnsemble classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/LeveragingBagTest.java b/moa/src/test/java/moa/classifiers/meta/LeveragingBagTest.java
index 901b86331..015aa68a4 100644
--- a/moa/src/test/java/moa/classifiers/meta/LeveragingBagTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/LeveragingBagTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the LeveragingBag classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/LimAttClassifierTest.java b/moa/src/test/java/moa/classifiers/meta/LimAttClassifierTest.java
index 17eaf73e3..0daec8b4b 100644
--- a/moa/src/test/java/moa/classifiers/meta/LimAttClassifierTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/LimAttClassifierTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the LimAttClassifier classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/OCBoostTest.java b/moa/src/test/java/moa/classifiers/meta/OCBoostTest.java
index 4954c654a..e536ff91c 100644
--- a/moa/src/test/java/moa/classifiers/meta/OCBoostTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/OCBoostTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the OCBoost classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/OnlineAccuracyUpdatedEnsembleTest.java b/moa/src/test/java/moa/classifiers/meta/OnlineAccuracyUpdatedEnsembleTest.java
index 984aa61fa..3b5070ad3 100644
--- a/moa/src/test/java/moa/classifiers/meta/OnlineAccuracyUpdatedEnsembleTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/OnlineAccuracyUpdatedEnsembleTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the OnlineAccuracyUpdatedEnsemble classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/OzaBagASHTTest.java b/moa/src/test/java/moa/classifiers/meta/OzaBagASHTTest.java
index 2a3e0ef96..5c77a5fea 100644
--- a/moa/src/test/java/moa/classifiers/meta/OzaBagASHTTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/OzaBagASHTTest.java
@@ -24,7 +24,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the OzaBagASHT classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/OzaBagAdwinTest.java b/moa/src/test/java/moa/classifiers/meta/OzaBagAdwinTest.java
index 653d4ba08..5b63754e8 100644
--- a/moa/src/test/java/moa/classifiers/meta/OzaBagAdwinTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/OzaBagAdwinTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the OzaBagAdwin classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/OzaBagTest.java b/moa/src/test/java/moa/classifiers/meta/OzaBagTest.java
index a70e900d9..8b9975880 100644
--- a/moa/src/test/java/moa/classifiers/meta/OzaBagTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/OzaBagTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the OzaBag classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/OzaBoostAdwinTest.java b/moa/src/test/java/moa/classifiers/meta/OzaBoostAdwinTest.java
index ae14a1fcb..edd191889 100644
--- a/moa/src/test/java/moa/classifiers/meta/OzaBoostAdwinTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/OzaBoostAdwinTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the OzaBoostAdwin classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/OzaBoostTest.java b/moa/src/test/java/moa/classifiers/meta/OzaBoostTest.java
index 313694835..679bb2fbe 100644
--- a/moa/src/test/java/moa/classifiers/meta/OzaBoostTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/OzaBoostTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the OzaBoost classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/TemporallyAugmentedClassifierTest.java b/moa/src/test/java/moa/classifiers/meta/TemporallyAugmentedClassifierTest.java
index 8f4b711ac..e38df4f74 100644
--- a/moa/src/test/java/moa/classifiers/meta/TemporallyAugmentedClassifierTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/TemporallyAugmentedClassifierTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the TemporallyAugmentedClassifier classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/WEKAClassifierTest.java b/moa/src/test/java/moa/classifiers/meta/WEKAClassifierTest.java
index edfb78792..cbed95b51 100644
--- a/moa/src/test/java/moa/classifiers/meta/WEKAClassifierTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/WEKAClassifierTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the WEKAClassifier classifier.
diff --git a/moa/src/test/java/moa/classifiers/meta/WeightedMajorityAlgorithmTest.java b/moa/src/test/java/moa/classifiers/meta/WeightedMajorityAlgorithmTest.java
index bbef3c0e7..16061d035 100644
--- a/moa/src/test/java/moa/classifiers/meta/WeightedMajorityAlgorithmTest.java
+++ b/moa/src/test/java/moa/classifiers/meta/WeightedMajorityAlgorithmTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the WeightedMajorityAlgorithm classifier.
diff --git a/moa/src/test/java/moa/classifiers/rules/AMRulesRegressorTest.java b/moa/src/test/java/moa/classifiers/rules/AMRulesRegressorTest.java
index a66b6717d..b07a43514 100644
--- a/moa/src/test/java/moa/classifiers/rules/AMRulesRegressorTest.java
+++ b/moa/src/test/java/moa/classifiers/rules/AMRulesRegressorTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleRegressorTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the AMRulesRegressor classifier.
diff --git a/moa/src/test/java/moa/classifiers/rules/RuleClassifierNBayesTest.java b/moa/src/test/java/moa/classifiers/rules/RuleClassifierNBayesTest.java
index c78ed0149..ba1ac994d 100644
--- a/moa/src/test/java/moa/classifiers/rules/RuleClassifierNBayesTest.java
+++ b/moa/src/test/java/moa/classifiers/rules/RuleClassifierNBayesTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the RuleClassifierNBayes classifier.
diff --git a/moa/src/test/java/moa/classifiers/rules/RuleClassifierTest.java b/moa/src/test/java/moa/classifiers/rules/RuleClassifierTest.java
index 4660bde9b..4d5562a3e 100644
--- a/moa/src/test/java/moa/classifiers/rules/RuleClassifierTest.java
+++ b/moa/src/test/java/moa/classifiers/rules/RuleClassifierTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the RuleClassifier classifier.
diff --git a/moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/InverseErrorWeightedVoteMultiLabeLTest.java b/moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/InverseErrorWeightedVoteMultiLabeLTest.java
index b34e58063..bc3da45c5 100644
--- a/moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/InverseErrorWeightedVoteMultiLabeLTest.java
+++ b/moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/InverseErrorWeightedVoteMultiLabeLTest.java
@@ -1,7 +1,6 @@
 package moa.classifiers.rules.multilabel.core.voting;
 
-import static org.junit.Assert.*;
-import moa.classifiers.rules.core.voting.InverseErrorWeightedVote;
+import static org.junit.Assert.assertEquals;
 
 import org.junit.BeforeClass;
 import org.junit.Test;
diff --git a/moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/UniformWeightedVoteMultiLabelTest.java b/moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/UniformWeightedVoteMultiLabelTest.java
index e9f91997a..92ff6bdcb 100644
--- a/moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/UniformWeightedVoteMultiLabelTest.java
+++ b/moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/UniformWeightedVoteMultiLabelTest.java
@@ -1,10 +1,10 @@
 package moa.classifiers.rules.multilabel.core.voting;
 
+import static org.junit.Assert.assertEquals;
+
 import org.junit.BeforeClass;
 import org.junit.Test;
 
-import static org.junit.Assert.*;
-
 import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
 import com.yahoo.labs.samoa.instances.Prediction;
 
diff --git a/moa/src/test/java/moa/classifiers/trees/ASHoeffdingTreeTest.java b/moa/src/test/java/moa/classifiers/trees/ASHoeffdingTreeTest.java
index 1614cb051..4012c9652 100644
--- a/moa/src/test/java/moa/classifiers/trees/ASHoeffdingTreeTest.java
+++ b/moa/src/test/java/moa/classifiers/trees/ASHoeffdingTreeTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the ASHoeffdingTree classifier.
diff --git a/moa/src/test/java/moa/classifiers/trees/AdaHoeffdingOptionTreeTest.java b/moa/src/test/java/moa/classifiers/trees/AdaHoeffdingOptionTreeTest.java
index 3960e6d97..fd343eaea 100644
--- a/moa/src/test/java/moa/classifiers/trees/AdaHoeffdingOptionTreeTest.java
+++ b/moa/src/test/java/moa/classifiers/trees/AdaHoeffdingOptionTreeTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the AdaHoeffdingOptionTree classifier.
diff --git a/moa/src/test/java/moa/classifiers/trees/DecisionStumpTest.java b/moa/src/test/java/moa/classifiers/trees/DecisionStumpTest.java
index 1e4b3297a..407365442 100644
--- a/moa/src/test/java/moa/classifiers/trees/DecisionStumpTest.java
+++ b/moa/src/test/java/moa/classifiers/trees/DecisionStumpTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the DecisionStump classifier.
diff --git a/moa/src/test/java/moa/classifiers/trees/FIMTDDTest.java b/moa/src/test/java/moa/classifiers/trees/FIMTDDTest.java
index eb863020e..fa2876054 100644
--- a/moa/src/test/java/moa/classifiers/trees/FIMTDDTest.java
+++ b/moa/src/test/java/moa/classifiers/trees/FIMTDDTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleRegressorTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the FIMTDD classifier.
@@ -31,8 +30,7 @@
  * @author  fracpete (fracpete at waikato dot ac dot nz)
  * @version $Revision$
  */
-public class FIMTDDTest
-  extends AbstractMultipleRegressorTestCase {  
+public class FIMTDDTest extends AbstractMultipleRegressorTestCase {  
 
   /**
    * Constructs the test case. Called by subclasses.
diff --git a/moa/src/test/java/moa/classifiers/trees/HoeffdingAdaptiveTreeTest.java b/moa/src/test/java/moa/classifiers/trees/HoeffdingAdaptiveTreeTest.java
index 8729f2fe2..20312bb02 100644
--- a/moa/src/test/java/moa/classifiers/trees/HoeffdingAdaptiveTreeTest.java
+++ b/moa/src/test/java/moa/classifiers/trees/HoeffdingAdaptiveTreeTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the HoeffdingAdaptiveTree classifier.
diff --git a/moa/src/test/java/moa/classifiers/trees/HoeffdingOptionTreeTest.java b/moa/src/test/java/moa/classifiers/trees/HoeffdingOptionTreeTest.java
index 1af0b309d..b0ab7fe1c 100644
--- a/moa/src/test/java/moa/classifiers/trees/HoeffdingOptionTreeTest.java
+++ b/moa/src/test/java/moa/classifiers/trees/HoeffdingOptionTreeTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the HoeffdingOptionTree classifier.
diff --git a/moa/src/test/java/moa/classifiers/trees/LimAttHoeffdingTreeTest.java b/moa/src/test/java/moa/classifiers/trees/LimAttHoeffdingTreeTest.java
index 8f59fae43..e19351825 100644
--- a/moa/src/test/java/moa/classifiers/trees/LimAttHoeffdingTreeTest.java
+++ b/moa/src/test/java/moa/classifiers/trees/LimAttHoeffdingTreeTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the LimAttHoeffdingTree classifier.
diff --git a/moa/src/test/java/moa/classifiers/trees/ORTOTest.java b/moa/src/test/java/moa/classifiers/trees/ORTOTest.java
index fd83e41f0..d9ff53950 100644
--- a/moa/src/test/java/moa/classifiers/trees/ORTOTest.java
+++ b/moa/src/test/java/moa/classifiers/trees/ORTOTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleRegressorTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the ORTO classifier.
diff --git a/moa/src/test/java/moa/classifiers/trees/RandomHoeffdingTreeTest.java b/moa/src/test/java/moa/classifiers/trees/RandomHoeffdingTreeTest.java
index 3e804b065..a08f2e4ec 100644
--- a/moa/src/test/java/moa/classifiers/trees/RandomHoeffdingTreeTest.java
+++ b/moa/src/test/java/moa/classifiers/trees/RandomHoeffdingTreeTest.java
@@ -23,7 +23,6 @@
 import junit.framework.TestSuite;
 import moa.classifiers.AbstractMultipleClassifierTestCase;
 import moa.classifiers.Classifier;
-import static moa.test.MoaTestCase.runTest;
 
 /**
  * Tests the RandomHoeffdingTree classifier.
diff --git a/moa/src/test/java/moa/integration/SimpleClusterTest.java b/moa/src/test/java/moa/integration/SimpleClusterTest.java
index 678627b38..4ac287d82 100644
--- a/moa/src/test/java/moa/integration/SimpleClusterTest.java
+++ b/moa/src/test/java/moa/integration/SimpleClusterTest.java
@@ -1,5 +1,11 @@
 package moa.integration;
 
+import org.junit.Test;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.Option;
+
 import junit.framework.TestCase;
 import moa.core.Globals;
 import moa.core.Measurement;
@@ -10,12 +16,6 @@
 import moa.tasks.Task;
 import moa.tasks.TaskThread;
 
-import org.junit.Test;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.Option;
-
 /* test that all clusterers run, i.e., do not die on simpe input **/
 public class SimpleClusterTest extends TestCase {
 
diff --git a/moa/src/test/java/moa/streams/filters/SelectAttributesFilterTest.java b/moa/src/test/java/moa/streams/filters/SelectAttributesFilterTest.java
index 02ee87bf6..86cf29292 100644
--- a/moa/src/test/java/moa/streams/filters/SelectAttributesFilterTest.java
+++ b/moa/src/test/java/moa/streams/filters/SelectAttributesFilterTest.java
@@ -2,14 +2,13 @@
 
 import static org.junit.Assert.assertEquals;
 
-import moa.streams.ArffFileStream;
-import moa.streams.MultiTargetArffFileStream;
-
 import org.junit.BeforeClass;
 import org.junit.Test;
 
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.streams.ArffFileStream;
+
 public class SelectAttributesFilterTest {
 	private static double EPS=0.00000001;
 	private static SelectAttributesFilter filter;
diff --git a/weka-package/.settings/org.eclipse.jdt.core.prefs b/weka-package/.settings/org.eclipse.jdt.core.prefs
index 60105c1b9..6e80039d3 100644
--- a/weka-package/.settings/org.eclipse.jdt.core.prefs
+++ b/weka-package/.settings/org.eclipse.jdt.core.prefs
@@ -1,5 +1,8 @@
 eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
-org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
 org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
-org.eclipse.jdt.core.compiler.source=1.6
+org.eclipse.jdt.core.compiler.source=1.8

From 32d534d2e43c28db1711ab2fe7ff580d214e22fe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aosojnik@gmail.com>
Date: Tue, 13 Jun 2017 11:58:39 +0200
Subject: [PATCH 29/33] Commit before cleanup

---
 moa/.classpath                                |  2 +-
 .../instances/FeatureRelevanceResult.java     | 14 +++++++
 .../java/moa/classifiers/meta/OzaBag.java     |  3 +-
 .../moa/classifiers/meta/OzaBagAdwin.java     |  3 +-
 .../trees/{FIMTDD.java => FIMTDD2.java}       | 40 ++++++++++++++-----
 .../trees/{ORTO.java => ORTO2.java}           |  8 ++--
 .../tasks/EvaluatePrequentialRegression.java  |  2 +-
 .../java/moa/tasks/LearnModelRegression.java  |  2 +-
 .../moa/classifiers/trees/FIMTDDTest.java     |  2 +-
 .../java/moa/classifiers/trees/ORTOTest.java  |  2 +-
 weka-package/.classpath                       |  2 +-
 11 files changed, 57 insertions(+), 23 deletions(-)
 create mode 100644 moa/src/main/java/com/yahoo/labs/samoa/instances/FeatureRelevanceResult.java
 rename moa/src/main/java/moa/classifiers/trees/{FIMTDD.java => FIMTDD2.java} (98%)
 rename moa/src/main/java/moa/classifiers/trees/{ORTO.java => ORTO2.java} (98%)

diff --git a/moa/.classpath b/moa/.classpath
index 534b5e52f..fae1a2b37 100644
--- a/moa/.classpath
+++ b/moa/.classpath
@@ -22,7 +22,7 @@
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6">
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
 		<attributes>
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/FeatureRelevanceResult.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/FeatureRelevanceResult.java
new file mode 100644
index 000000000..cc29c97d4
--- /dev/null
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/FeatureRelevanceResult.java
@@ -0,0 +1,14 @@
+package com.yahoo.labs.samoa.instances;
+
+import java.util.List;
+
+public interface FeatureRelevanceResult {
+	public void addFeature(Attribute attr);
+	
+	public void setFeatureRelevance(Attribute attr, double relevance);
+	
+	public double getFeatureRelevance(Attribute attr);
+	
+	public List<Attribute> getFeatures();
+
+}
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBag.java b/moa/src/main/java/moa/classifiers/meta/OzaBag.java
index d43f2da0b..2cc5000cc 100644
--- a/moa/src/main/java/moa/classifiers/meta/OzaBag.java
+++ b/moa/src/main/java/moa/classifiers/meta/OzaBag.java
@@ -24,6 +24,7 @@
 
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
+import moa.classifiers.Regressor;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.MiscUtils;
@@ -49,7 +50,7 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class OzaBag extends AbstractClassifier {
+public class OzaBag extends AbstractClassifier implements Regressor, Classifier {
 
     @Override
     public String getPurposeString() {
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBagAdwin.java b/moa/src/main/java/moa/classifiers/meta/OzaBagAdwin.java
index 8f790f339..f88027cfe 100644
--- a/moa/src/main/java/moa/classifiers/meta/OzaBagAdwin.java
+++ b/moa/src/main/java/moa/classifiers/meta/OzaBagAdwin.java
@@ -24,6 +24,7 @@
 
 import moa.classifiers.AbstractClassifier;
 import moa.classifiers.Classifier;
+import moa.classifiers.Regressor;
 import moa.classifiers.core.driftdetection.ADWIN;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
@@ -79,7 +80,7 @@
  * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
  * @version $Revision: 7 $
  */
-public class OzaBagAdwin extends AbstractClassifier {
+public class OzaBagAdwin extends AbstractClassifier implements Classifier, Regressor {
 
     private static final long serialVersionUID = 1L;
 
diff --git a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java b/moa/src/main/java/moa/classifiers/trees/FIMTDD2.java
similarity index 98%
rename from moa/src/main/java/moa/classifiers/trees/FIMTDD.java
rename to moa/src/main/java/moa/classifiers/trees/FIMTDD2.java
index b41e55c5a..6c24de38a 100644
--- a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
+++ b/moa/src/main/java/moa/classifiers/trees/FIMTDD2.java
@@ -48,14 +48,14 @@
  * Implementation of FIMTDD, regression and model trees for data streams.
  */
 
-public class FIMTDD extends AbstractClassifier implements Regressor {
+public class FIMTDD2 extends AbstractClassifier implements Regressor {
 
 	private static final long serialVersionUID = 1L;
 
 	public Node treeRoot;
 
-	protected int leafNodeCount = 0;
-	protected int splitNodeCount = 0;
+	public int leafNodeCount = 0;
+	public int splitNodeCount = 0;
 
 	protected double examplesSeen = 0.0;
 	protected double sumOfValues = 0.0;
@@ -117,6 +117,10 @@ public class FIMTDD extends AbstractClassifier implements Regressor {
 
 	public FlagOption learningRatioConstOption = new FlagOption(
 			"learningRatioConst", 'p', "Keep learning rate constant instead of decaying.");
+	
+	public IntOption maxDepthOption = new IntOption(
+			"maxDepthFactor", 'b', "The maximum depth of the tree.",
+			Integer.MAX_VALUE, 0, Integer.MAX_VALUE);
 
 	//endregion ================ OPTIONS ================
 
@@ -128,7 +132,7 @@ public abstract static class Node extends AbstractMOAObject {
 
 		public int ID;
 
-		protected FIMTDD tree;
+		protected FIMTDD2 tree;
 		
 		protected boolean changeDetection = true;
 		
@@ -147,7 +151,7 @@ public abstract static class Node extends AbstractMOAObject {
 		// Sum of absolute errors
 		protected double sumOfAbsErrors; // Needed for PH tracking of mean error
 
-		public Node(FIMTDD tree) {
+		public Node(FIMTDD2 tree) {
 			this.tree = tree;
 			ID = tree.maxID; 
 		}
@@ -226,6 +230,10 @@ public int getNumSubtrees() {
 			return 1;
 		}
 
+		public int numLeaves() {
+			return 1;
+		}
+		
 		protected boolean skipInLevelCount() {
 			return false;
 		}
@@ -248,7 +256,7 @@ public static class LeafNode extends Node {
 		/**
 		 * Create a new LeafNode
 		 */
-		public LeafNode(FIMTDD tree) {
+		public LeafNode(FIMTDD2 tree) {
 			super(tree);
 			if (tree.buildingModelTree()) {
 				learningModel = tree.newLeafModel();
@@ -381,7 +389,7 @@ public double getPrediction(Instance inst) {
 		
 		public void checkForSplit(Instance inst, double prediction) {
 			// If it has seen Nmin examples since it was last tested for splitting, attempt a split of this node
-			if (examplesSeen - examplesSeenAtLastSplitEvaluation >= tree.gracePeriodOption.getValue()) {
+			if (this.getLevel() < tree.maxDepthOption.getValue() && examplesSeen - examplesSeenAtLastSplitEvaluation >= tree.gracePeriodOption.getValue()) {
 				int index = (parent != null) ? parent.getChildIndex(this) : 0;
 				tree.attemptToSplit(this, parent, index, inst, prediction);
 
@@ -421,7 +429,7 @@ public abstract static class InnerNode extends Node {
 		protected double lossSumQi;
 		protected double previousWeight = 0;
 		
-		public InnerNode(FIMTDD tree) {
+		public InnerNode(FIMTDD2 tree) {
 			super(tree);
 		}
 		
@@ -436,6 +444,12 @@ public int numChildren() {
 			return children.size();
 		}
 
+		public int numLeaves() {
+			int leaves = 0;
+			for (Node child : children) leaves += child.numLeaves();
+			return leaves;
+		}
+		
 		public Node getChild(int index) {
 			return children.get(index);
 		}
@@ -516,7 +530,7 @@ public static class SplitNode extends InnerNode {
 		 * Create a new SplitNode
 		 * @param tree 
 		 */
-		public SplitNode(InstanceConditionalTest splitTest, FIMTDD tree) {
+		public SplitNode(InstanceConditionalTest splitTest, FIMTDD2 tree) {
 			super(tree);
 			this.splitTest = splitTest;
 		}
@@ -558,7 +572,7 @@ public class FIMTDDPerceptron implements Serializable {
 
 		private static final long serialVersionUID = 1L;
 		
-		protected FIMTDD tree;
+		protected FIMTDD2 tree;
 		
 		// The Perception weights 
 		protected double[] weightAttribute; 
@@ -576,7 +590,7 @@ public FIMTDDPerceptron(FIMTDDPerceptron original) {
 			instancesSeen = original.instancesSeen / 2;
 		}
 
-		public FIMTDDPerceptron(FIMTDD tree) {
+		public FIMTDDPerceptron(FIMTDD2 tree) {
 			this.tree = tree;
 			initializeWeights();
 
@@ -837,6 +851,7 @@ public void processInstance(Instance inst, Node node, double prediction, double
 							// Switch the subtrees
 							Node parent = iNode.getParent();
 
+							System.out.println("Switching trees!");
 							if (parent != null) {
 								Node replacementTree = iNode.alternateTree;
 								parent.setChild(parent.getChildIndex(iNode), replacementTree);
@@ -845,6 +860,8 @@ public void processInstance(Instance inst, Node node, double prediction, double
 								treeRoot = iNode.alternateTree;
 								treeRoot.restartChangeDetection();
 							}
+							leafNodeCount += iNode.alternateTree.numLeaves() - iNode.numLeaves();
+
 
 							currentNode = iNode.alternateTree;
 							currentNode.originalNode = null;
@@ -865,6 +882,7 @@ public void processInstance(Instance inst, Node node, double prediction, double
 
 				if (iNode.changeDetection && !inAlternate) {
 					if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+						System.out.println("CD triggered!");
 						iNode.initializeAlternateTree();
 						growthAllowed = false;
 					}
diff --git a/moa/src/main/java/moa/classifiers/trees/ORTO.java b/moa/src/main/java/moa/classifiers/trees/ORTO2.java
similarity index 98%
rename from moa/src/main/java/moa/classifiers/trees/ORTO.java
rename to moa/src/main/java/moa/classifiers/trees/ORTO2.java
index f31e2b480..05e41a208 100644
--- a/moa/src/main/java/moa/classifiers/trees/ORTO.java
+++ b/moa/src/main/java/moa/classifiers/trees/ORTO2.java
@@ -43,7 +43,7 @@
  * Implementation of ORTO, option trees for data streams.
  */
 
-public class ORTO extends FIMTDD implements Regressor {
+public class ORTO2 extends FIMTDD2 implements Regressor {
 
 	private static final long serialVersionUID = 1L;
 
@@ -96,7 +96,7 @@ public static class OptionNode extends InnerNode {
 		protected double[] optionFFSSL;
 		protected double[] optionFFSeen;
 
-		public OptionNode(FIMTDD tree) {
+		public OptionNode(FIMTDD2 tree) {
 			super(tree);
 		}
 		
@@ -140,13 +140,13 @@ public double getPrediction(Instance inst) {
 		}
 
 		private double aggregate(double[] predictions) {
-			if (((ORTO) tree).optionNodeAggregationOption.getChosenIndex() == 0) { // Average
+			if (((ORTO2) tree).optionNodeAggregationOption.getChosenIndex() == 0) { // Average
 				double sum = 0.0;
 				for (int i = 0; i < predictions.length; i++) {
 					sum += predictions[i];
 				}
 				return sum / predictions.length;
-			} else if (((ORTO) tree).optionNodeAggregationOption.getChosenIndex() == 1) {
+			} else if (((ORTO2) tree).optionNodeAggregationOption.getChosenIndex() == 1) {
 				int d = directionForBestTree();
 				return predictions[d];
 			} else {
diff --git a/moa/src/main/java/moa/tasks/EvaluatePrequentialRegression.java b/moa/src/main/java/moa/tasks/EvaluatePrequentialRegression.java
index 56996cb47..8f0d2839a 100644
--- a/moa/src/main/java/moa/tasks/EvaluatePrequentialRegression.java
+++ b/moa/src/main/java/moa/tasks/EvaluatePrequentialRegression.java
@@ -63,7 +63,7 @@ public String getPurposeString() {
     private static final long serialVersionUID = 1L;
 
     public ClassOption learnerOption = new ClassOption("learner", 'l',
-            "Learner to train.", Regressor.class, "moa.classifiers.trees.FIMTDD");
+            "Learner to train.", Regressor.class, "moa.classifiers.trees.ORTO");
 
     public ClassOption streamOption = new ClassOption("stream", 's',
             "Stream to learn from.", ExampleStream.class,
diff --git a/moa/src/main/java/moa/tasks/LearnModelRegression.java b/moa/src/main/java/moa/tasks/LearnModelRegression.java
index 4869602e3..fd92e8453 100644
--- a/moa/src/main/java/moa/tasks/LearnModelRegression.java
+++ b/moa/src/main/java/moa/tasks/LearnModelRegression.java
@@ -45,7 +45,7 @@ public String getPurposeString() {
     private static final long serialVersionUID = 1L;
 
     public ClassOption learnerOption = new ClassOption("learner", 'l',
-            "Learner to train.", Regressor.class, "moa.classifiers.trees.FIMTDD");
+            "Learner to train.", Regressor.class, "moa.classifiers.trees.HoeffdingTree");
 
     public ClassOption streamOption = new ClassOption("stream", 's',
             "Stream to learn from.", ExampleStream.class,
diff --git a/moa/src/test/java/moa/classifiers/trees/FIMTDDTest.java b/moa/src/test/java/moa/classifiers/trees/FIMTDDTest.java
index fa2876054..dc931074a 100644
--- a/moa/src/test/java/moa/classifiers/trees/FIMTDDTest.java
+++ b/moa/src/test/java/moa/classifiers/trees/FIMTDDTest.java
@@ -50,7 +50,7 @@ public FIMTDDTest(String name) {
   @Override
   protected Classifier[] getRegressionClassifierSetups() {
     return new Classifier[]{
-	new FIMTDD(),
+	new FIMTDD2(),
     };
   }
   
diff --git a/moa/src/test/java/moa/classifiers/trees/ORTOTest.java b/moa/src/test/java/moa/classifiers/trees/ORTOTest.java
index d9ff53950..4a86c0099 100644
--- a/moa/src/test/java/moa/classifiers/trees/ORTOTest.java
+++ b/moa/src/test/java/moa/classifiers/trees/ORTOTest.java
@@ -51,7 +51,7 @@ public ORTOTest(String name) {
   @Override
   protected Classifier[] getRegressionClassifierSetups() {
     return new Classifier[]{
-	new ORTO(),
+	new ORTO2(),
     };
   }
   
diff --git a/weka-package/.classpath b/weka-package/.classpath
index fd7ad7fbd..af1430be1 100644
--- a/weka-package/.classpath
+++ b/weka-package/.classpath
@@ -12,7 +12,7 @@
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6">
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
 		<attributes>
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>

From 5c0c858ce4883b6cbe3b73563540aa08d9be8f6b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Sun, 2 Jul 2017 23:49:22 +0200
Subject: [PATCH 30/33] Learner, Prediction rework

---
 README.md                                     |    0
 moa/pom.xml.orig                              |  156 +++
 .../predictions/ClassificationPrediction.java |  132 +++
 .../MultiTargetRegressionPrediction.java      |  134 +++
 .../predictions/RegressionPrediction.java     |  119 ++
 .../moa/classifiers/AbstractClassifier.java   |    7 +
 .../classifiers/AbstractEnsembleLearner.java  |   77 ++
 .../AbstractMultiLabelClassifier.java         |   20 +
 .../AbstractMultiLabelLearner.java            |   46 -
 .../AbstractMultiTargetRegressor.java         |   22 +
 .../moa/classifiers/AbstractRegressor.java    |    9 +
 .../moa/classifiers/MultiLabelLearner.java    |   12 -
 .../moa/classifiers/meta/OzaBagASHT.java.orig |  200 ++++
 .../meta/OzaBagAdwinClassification.java       |   31 +
 .../meta/OzaBagAdwinRegression.java           |   28 +
 .../meta/OzaBagClassification.java            |   33 +
 .../classifiers/meta/OzaBagRegression.java    |   24 +
 .../meta/OzaBoostClassification.java          |   46 +
 .../classifiers/meta/RegressionViaMTR.java    |   54 +
 .../TemporallyAugmentedClassifier.java.orig   |  190 +++
 .../mlc/MultilabelHoeffdingTree.java.orig     |  237 ++++
 .../moa/classifiers/mlc/meta/MLOzaBag.java    |  126 --
 .../java/moa/classifiers/trees/FIMTDD.java    | 1031 +++++++++++++++++
 .../moa/classifiers/trees/ORTO2.java.orig     |  543 +++++++++
 .../clusterers/clustree/ClusTree.java.orig    |  891 ++++++++++++++
 .../java/moa/learners/InstanceLearner.java    |   56 +
 .../moa/tasks/ClassificationMainTask.java     |    5 +
 .../EvaluateInterleavedTestThenTrain.java     |  218 ----
 .../EvaluatePeriodicHeldOutTest.java.orig     |  308 +++++
 .../EvaluatePrequentialClassification.java    |   30 +
 ...tePrequentialMultiLabelClassification.java |   27 +
 .../EvaluatePrequentialMultiTarget.java.orig  |  713 ++++++++++++
 .../moa/tasks/LearnModelClassification.java   |   19 +
 .../LearnModelMultiLabelClassification.java   |   20 +
 .../java/moa/tasks/MainTaskInterface.java     |   10 +
 .../MultiLabelClassificatioMainTask.java      |    5 +
 weka-package/.classpath                       |    2 +-
 .../.settings/org.eclipse.jdt.core.prefs      |    6 +-
 weka-package/pom.xml.orig                     |   57 +
 39 files changed, 5238 insertions(+), 406 deletions(-)
 mode change 100755 => 100644 README.md
 create mode 100644 moa/pom.xml.orig
 create mode 100644 moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/ClassificationPrediction.java
 create mode 100644 moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/MultiTargetRegressionPrediction.java
 create mode 100644 moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/RegressionPrediction.java
 create mode 100644 moa/src/main/java/moa/classifiers/AbstractClassifier.java
 create mode 100644 moa/src/main/java/moa/classifiers/AbstractEnsembleLearner.java
 create mode 100644 moa/src/main/java/moa/classifiers/AbstractMultiLabelClassifier.java
 delete mode 100644 moa/src/main/java/moa/classifiers/AbstractMultiLabelLearner.java
 create mode 100644 moa/src/main/java/moa/classifiers/AbstractMultiTargetRegressor.java
 create mode 100644 moa/src/main/java/moa/classifiers/AbstractRegressor.java
 delete mode 100644 moa/src/main/java/moa/classifiers/MultiLabelLearner.java
 create mode 100644 moa/src/main/java/moa/classifiers/meta/OzaBagASHT.java.orig
 create mode 100644 moa/src/main/java/moa/classifiers/meta/OzaBagAdwinClassification.java
 create mode 100644 moa/src/main/java/moa/classifiers/meta/OzaBagAdwinRegression.java
 create mode 100644 moa/src/main/java/moa/classifiers/meta/OzaBagClassification.java
 create mode 100644 moa/src/main/java/moa/classifiers/meta/OzaBagRegression.java
 create mode 100644 moa/src/main/java/moa/classifiers/meta/OzaBoostClassification.java
 create mode 100644 moa/src/main/java/moa/classifiers/meta/RegressionViaMTR.java
 create mode 100644 moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java.orig
 create mode 100644 moa/src/main/java/moa/classifiers/mlc/MultilabelHoeffdingTree.java.orig
 delete mode 100644 moa/src/main/java/moa/classifiers/mlc/meta/MLOzaBag.java
 create mode 100644 moa/src/main/java/moa/classifiers/trees/FIMTDD.java
 create mode 100644 moa/src/main/java/moa/classifiers/trees/ORTO2.java.orig
 create mode 100644 moa/src/main/java/moa/clusterers/clustree/ClusTree.java.orig
 create mode 100644 moa/src/main/java/moa/learners/InstanceLearner.java
 create mode 100644 moa/src/main/java/moa/tasks/ClassificationMainTask.java
 delete mode 100644 moa/src/main/java/moa/tasks/EvaluateInterleavedTestThenTrain.java
 create mode 100644 moa/src/main/java/moa/tasks/EvaluatePeriodicHeldOutTest.java.orig
 create mode 100644 moa/src/main/java/moa/tasks/EvaluatePrequentialClassification.java
 create mode 100644 moa/src/main/java/moa/tasks/EvaluatePrequentialMultiLabelClassification.java
 create mode 100644 moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java.orig
 create mode 100644 moa/src/main/java/moa/tasks/LearnModelClassification.java
 create mode 100644 moa/src/main/java/moa/tasks/LearnModelMultiLabelClassification.java
 create mode 100644 moa/src/main/java/moa/tasks/MainTaskInterface.java
 create mode 100644 moa/src/main/java/moa/tasks/MultiLabelClassificatioMainTask.java
 create mode 100644 weka-package/pom.xml.orig

diff --git a/README.md b/README.md
old mode 100755
new mode 100644
diff --git a/moa/pom.xml.orig b/moa/pom.xml.orig
new file mode 100644
index 000000000..8edfa56e1
--- /dev/null
+++ b/moa/pom.xml.orig
@@ -0,0 +1,156 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <parent>
+    <groupId>nz.ac.waikato.cms.moa</groupId>
+    <artifactId>moa-pom</artifactId>
+<<<<<<< Updated upstream
+    <version>2014.04</version>
+=======
+    <version>2017.10-SNAPSHOT</version>
+>>>>>>> Stashed changes
+  </parent>
+
+  <artifactId>moa</artifactId>
+  <packaging>jar</packaging>
+
+  <name>MOA: Massive Online Analysis</name>
+  <description>
+  Massive On-line Analysis is an environment for massive data mining. MOA
+  provides a framework for data stream mining and includes tools for evaluation
+  and a collection of machine learning algorithms. Related to the WEKA project,
+  also written in Java, while scaling to more demanding problems.
+  </description>
+  <url>http://moa.cms.waikato.ac.nz/</url>
+  <organization>
+    <name>University of Waikato, Hamilton, NZ</name>
+    <url>http://www.waikato.ac.nz/</url>
+  </organization>
+  <licenses>
+    <license>
+      <name>GNU General Public License 3.0</name>
+      <url>http://www.gnu.org/licenses/gpl-3.0.txt</url>
+      <distribution>repo</distribution>
+    </license>
+  </licenses>
+
+  <developers>
+    <developer>
+      <id>abifet</id>
+      <name>Albert Bifet</name>
+      <email>abifet@waikato.ac.nz</email>
+    </developer>
+    <developer>
+      <id>rkirkby</id>
+      <name>Richard Kirkby</name>
+    </developer>
+  </developers>
+
+  <dependencies>
+    <dependency>
+      <groupId>nz.ac.waikato.cms.weka</groupId>
+      <artifactId>weka-dev</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>com.googlecode.sizeofag</groupId>
+      <artifactId>sizeofag</artifactId>
+    </dependency>
+
+<<<<<<< Updated upstream
+=======
+      <dependency>
+          <groupId>net.sf.meka</groupId>
+          <artifactId>meka</artifactId>
+      </dependency>
+
+>>>>>>> Stashed changes
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <scope>test</scope>
+    </dependency>
+    
+    <dependency>
+    <groupId>org.apache.commons</groupId>
+    <artifactId>commons-math3</artifactId>
+    <version>3.6.1</version>
+    </dependency>
+    
+    <dependency>
+      <groupId>com.googlecode.java-diff-utils</groupId>
+      <artifactId>diffutils</artifactId>
+      <version>1.2.1</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <configuration>
+          <source>1.7</source>
+          <target>1.7</target>
+        </configuration>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-jar-plugin</artifactId>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-javadoc-plugin</artifactId>
+      </plugin>
+      
+      <plugin>
+        <groupId>org.codehaus.mojo</groupId>
+        <artifactId>license-maven-plugin</artifactId>
+      </plugin>
+
+      <plugin>
+        <groupId>org.codehaus.mojo</groupId>
+        <artifactId>latex-maven-plugin</artifactId>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-assembly-plugin</artifactId>
+      </plugin>
+    </plugins>
+    <pluginManagement>
+    	<plugins>
+    		<!--This plugin's configuration is used to store Eclipse m2e settings only. It has no influence on the Maven build itself.-->
+    		<plugin>
+    			<groupId>org.eclipse.m2e</groupId>
+    			<artifactId>lifecycle-mapping</artifactId>
+    			<version>1.0.0</version>
+    			<configuration>
+    				<lifecycleMappingMetadata>
+    					<pluginExecutions>
+    						<pluginExecution>
+    							<pluginExecutionFilter>
+    								<groupId>org.codehaus.mojo</groupId>
+    								<artifactId>
+    									license-maven-plugin
+    								</artifactId>
+    								<versionRange>[1.1,)</versionRange>
+    								<goals>
+    									<goal>add-third-party</goal>
+    								</goals>
+    							</pluginExecutionFilter>
+    							<action>
+    								<ignore></ignore>
+    							</action>
+    						</pluginExecution>
+    					</pluginExecutions>
+    				</lifecycleMappingMetadata>
+    			</configuration>
+    		</plugin>
+    	</plugins>
+    </pluginManagement>
+  </build>
+</project>
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/ClassificationPrediction.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/ClassificationPrediction.java
new file mode 100644
index 000000000..9e311f188
--- /dev/null
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/ClassificationPrediction.java
@@ -0,0 +1,132 @@
+/* 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * 	        http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific
+ * language governing permissions and limitations under the
+ * License.  
+ */
+package com.yahoo.labs.samoa.instances.predictions;
+
+import java.io.Serializable;
+
+import com.yahoo.labs.samoa.instances.Attribute;
+
+import moa.core.DoubleVector;
+
+public class ClassificationPrediction implements Prediction, Serializable {
+	
+	private static final long serialVersionUID = 1L;
+
+	protected double[] prediction;
+
+	protected Attribute classAttribute;
+	
+	public ClassificationPrediction() {
+	}
+
+	public ClassificationPrediction(double[] prediction) {
+		this.prediction = prediction;
+	}
+	
+	public void setClassAttribute(Attribute a) {
+		this.classAttribute = a;	
+	}
+	
+	@Override
+	public int numOutputAttributes() {
+		return 1;
+	}
+
+	@Override
+	public int numClasses(int outputAttributeIndex) {
+		throw new UnsupportedOperationException("This is a single-target classification prediction.");
+	}
+
+	@Override
+	public double[] getVotes(int outputAttributeIndex) {
+		throw new UnsupportedOperationException("This is a single-target classification prediction.");
+	}
+	
+	@Override
+	public double[] getVotes() {
+		return prediction;
+	}
+
+	@Override
+	public double getVote(int outputAttributeIndex, int classIndex) {
+		throw new UnsupportedOperationException("This is a single-target classification prediction.");
+	}
+
+	@Override
+	public void setVotes(int outputAttributeIndex, double[] votes) {
+		throw new UnsupportedOperationException("This is a single-target classification prediction.");
+	}
+	
+	@Override
+	public void setVotes(double[] votes) {
+		this.prediction = votes;
+	}
+
+	@Override
+	public void setVote(int outputAttributeIndex, int classIndex, double vote) {
+		throw new UnsupportedOperationException("This is a single-target classification prediction.");
+	}
+	
+	@Override
+	public String toString() {
+		StringBuffer sb= new StringBuffer();
+		sb.append("Out: ");
+		int id = 0;
+		double max = Double.NEGATIVE_INFINITY; 
+		for (int i = 0; i < prediction.length; i++) {
+			if (prediction[i] > max) {
+				id = i;
+				max = prediction[i];
+			}
+		}
+		if (classAttribute != null) {
+			sb.append(classAttribute.value(id));
+		} else
+			sb.append(id);
+		return sb.toString();
+	}
+
+	@Override
+	public boolean hasVotesForAttribute(int outputAttributeIndex) {
+		throw new UnsupportedOperationException("This is a single-target classification prediction.");
+	}
+
+    @Override
+    public int size() {
+        return 1;
+    }
+    
+    public double asDouble() {
+		throw new UnsupportedOperationException("This is a classification prediction.");
+    }
+    
+    public DoubleVector asDoubleVector() {
+    	return new DoubleVector(prediction);
+    }
+
+    public double[] asDoubleArray() {
+    	return prediction;
+    }
+    
+	public String asPredictionString() {
+		return String.valueOf(prediction.toString());
+	}
+
+	@Override
+	public double getPrediction(int outputAttributeIndex) {
+		throw new UnsupportedOperationException("This is a single-target classification prediction.");
+	}
+    
+}
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/MultiTargetRegressionPrediction.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/MultiTargetRegressionPrediction.java
new file mode 100644
index 000000000..7023a1316
--- /dev/null
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/MultiTargetRegressionPrediction.java
@@ -0,0 +1,134 @@
+/* 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * 	        http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific
+ * language governing permissions and limitations under the
+ * License.  
+ */
+package com.yahoo.labs.samoa.instances.predictions;
+
+import java.io.Serializable;
+
+import moa.core.DoubleVector;
+
+public class MultiTargetRegressionPrediction implements Prediction, Serializable {
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 1L;
+	
+	protected DoubleVector prediction;
+
+	public MultiTargetRegressionPrediction() {
+		this(0);
+	}
+	
+	public MultiTargetRegressionPrediction(int numOutputAttributes) {
+		prediction=new DoubleVector();
+		for (int i=0; i < numOutputAttributes;i++)
+			prediction.setValue(i, 0.0);;
+	}
+	
+	public MultiTargetRegressionPrediction(DoubleVector prediction) {
+		this.prediction = prediction;
+	}
+	
+	public MultiTargetRegressionPrediction(double[] prediction) {
+		this.prediction = new DoubleVector(prediction);
+	}
+	
+	
+	@Override
+	public int numOutputAttributes() {
+		return prediction.numValues();
+	}
+
+	@Override
+	public int numClasses(int outputAttributeIndex) {
+		throw new UnsupportedOperationException("This is a multi-target regression prediction. Each output attribute corresponds to a continuouos variable.");
+	}
+
+	@Override
+	public double[] getVotes(int outputAttributeIndex) {
+		throw new UnsupportedOperationException("This is a multi-target regression prediction. Each output attribute corresponds to a continuouos variable.");
+	}
+	
+	@Override
+	public double[] getVotes() {
+		return this.asDoubleArray();
+	}
+
+	@Override
+	public double getVote(int outputAttributeIndex, int classIndex) {
+		throw new UnsupportedOperationException("This is a multi-target regression prediction. Each output attribute corresponds to a continuouos variable.");
+	}
+
+	@Override
+	public void setVotes(int outputAttributeIndex, double[] votes) {
+		throw new UnsupportedOperationException("This is a multi-target regression prediction. Each output attribute corresponds to a continuouos variable.");
+	}
+	
+	@Override
+	public void setVotes(double[] votes) {
+		setVotes(0, votes);
+	}
+
+	@Override
+	public void setVote(int outputAttributeIndex, int classIndex, double vote) {
+		throw new UnsupportedOperationException("This is a multi-target regression prediction. Each output attribute corresponds to a continuouos variable.");
+	}
+	
+	@Override
+	public String toString() {
+		StringBuffer sb= new StringBuffer();
+		// TODO
+//		for (int i=0; i<prediction.length; i++){
+//			sb.append("Out " + i + ": ");
+//			for (int c=0; c<prediction[i].numValues(); c++)
+//			{
+//				sb.append(((int)(prediction[i].getValue(c)*1000)/1000.0)+ " ");
+//			}
+//		}
+		return sb.toString();
+	}
+
+	@Override
+	public boolean hasVotesForAttribute(int outputAttributeIndex) {
+		throw new UnsupportedOperationException("This is a multi-target regression prediction. Each output attribute corresponds to a continuouos variable.");
+	}
+
+    @Override
+    public int size() {
+        return prediction.numValues();
+    }
+
+    public double asDouble() {
+		throw new UnsupportedOperationException("This is a multi-target regression prediction.");
+    }
+    
+    public DoubleVector asDoubleVector() {
+    	return (DoubleVector) prediction.copy();
+    }
+
+    public double[] asDoubleArray() {
+    	return prediction.getArrayCopy();
+    }
+    
+	public String asPredictionString() {
+		return String.valueOf(prediction.toString());
+	}
+
+	@Override
+	public double getPrediction(int outputAttributeIndex) {
+		return prediction.getValue(outputAttributeIndex);
+	}
+
+
+}
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/RegressionPrediction.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/RegressionPrediction.java
new file mode 100644
index 000000000..d94235f71
--- /dev/null
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/RegressionPrediction.java
@@ -0,0 +1,119 @@
+/* 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * 	        http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific
+ * language governing permissions and limitations under the
+ * License.  
+ */
+package com.yahoo.labs.samoa.instances.predictions;
+
+import java.io.Serializable;
+
+import moa.core.DoubleVector;
+
+public class RegressionPrediction implements Prediction, Serializable {
+	
+	private static final long serialVersionUID = 1L;
+	
+	protected double prediction;
+
+	public RegressionPrediction() {
+	}
+
+	public RegressionPrediction(double prediction) {
+		this.prediction = prediction;
+	}
+	
+	@Override
+	public int numOutputAttributes() {
+		return 1;
+	}
+
+	@Override
+	public int numClasses(int outputAttributeIndex) {
+		throw new UnsupportedOperationException("This is a single-target regression prediction.");
+	}
+
+	@Override
+	public double[] getVotes(int outputAttributeIndex) {
+		throw new UnsupportedOperationException("This is a single-target regression prediction.");
+	}
+	
+	@Override
+	public double[] getVotes() {
+		throw new UnsupportedOperationException("This is a single-target regression prediction.");
+	}
+
+	@Override
+	public double getVote(int outputAttributeIndex, int classIndex) {
+		if (outputAttributeIndex != 0)
+			throw new UnsupportedOperationException("This is a single-target regression prediction.");
+		return prediction;
+	}
+
+	@Override
+	public void setVotes(int outputAttributeIndex, double[] votes) {
+		throw new UnsupportedOperationException("This is a single-target regression prediction.");
+	}
+	
+	@Override
+	public void setVotes(double[] votes) {
+		throw new UnsupportedOperationException("This is a single-target regression prediction.");
+	}
+
+	@Override
+	public void setVote(int outputAttributeIndex, int classIndex, double vote) {
+		throw new UnsupportedOperationException("This is a single-target regression prediction.");
+	}
+	
+	@Override
+	public String toString(){
+		StringBuffer sb= new StringBuffer();
+		sb.append("Out " + 0 + ": ");
+		sb.append(((int) (prediction*1000)/1000.0)+ " ");
+		return sb.toString();
+	}
+
+	@Override
+	public boolean hasVotesForAttribute(int outputAttributeIndex) {
+		throw new UnsupportedOperationException("This is a single-target regression prediction.");
+	}
+
+    @Override
+    public int size() {
+        return 1;
+    }
+    
+    public double asDouble() {
+    	return prediction;
+    }
+    
+    public DoubleVector asDoubleVector() {
+    	return new DoubleVector(new double[] {prediction});
+    }
+
+    public double[] asDoubleArray() {
+    	return new double[] {prediction};
+    }
+
+	@Override
+	public String asPredictionString() {
+		return String.valueOf(prediction);
+	}
+
+	@Override
+	public double getPrediction(int outputAttributeIndex) {
+		if (outputAttributeIndex != 0)
+			throw new UnsupportedOperationException("This is a single-target regression prediction.");
+		return prediction;
+	}
+
+    
+}
diff --git a/moa/src/main/java/moa/classifiers/AbstractClassifier.java b/moa/src/main/java/moa/classifiers/AbstractClassifier.java
new file mode 100644
index 000000000..b673c2f33
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/AbstractClassifier.java
@@ -0,0 +1,7 @@
+package moa.classifiers;
+
+import moa.learners.Classifier;
+
+public abstract class AbstractClassifier extends AbstractInstanceLearner<Classifier> implements Classifier {
+
+}
diff --git a/moa/src/main/java/moa/classifiers/AbstractEnsembleLearner.java b/moa/src/main/java/moa/classifiers/AbstractEnsembleLearner.java
new file mode 100644
index 000000000..67984cfa3
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/AbstractEnsembleLearner.java
@@ -0,0 +1,77 @@
+package moa.classifiers;
+
+import java.util.ArrayList;
+
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Measurement;
+import moa.learners.InstanceLearner;
+import moa.options.ClassOption;
+
+public abstract class AbstractEnsembleLearner<MLTask extends InstanceLearner> extends AbstractInstanceLearner<MLTask> {
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption baseLearnerOption;
+
+    public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's',
+            "The number of models in the ensemble.", 10, 1, Integer.MAX_VALUE);
+    
+    public ArrayList<MLTask> ensemble;
+
+    public long measureByteSize() {
+    	long size = 0;
+    	for (MLTask c : ensemble) 
+    		size += c.measureByteSize();
+    	return size;
+    }
+    
+    @SuppressWarnings("unchecked")
+	@Override
+    public void resetLearningImpl() {
+        this.ensemble = new ArrayList<MLTask>(this.ensembleSizeOption.getValue());
+        MLTask baseLearner = (MLTask) getPreparedClassOption(this.baseLearnerOption);
+        for (int i = 0; i < this.ensemble.size(); i++) {
+            this.ensemble.set(i, (MLTask) baseLearner.copy());
+            this.ensemble.get(i).setRandomSeed(this.randomSeed + i * 100);
+        }
+    }
+
+	public abstract Prediction combinePredictions(Prediction[] predictions);
+	
+	public Prediction getPredictionForInstance(Instance inst) {
+		Prediction[] predictions = new Prediction[this.ensemble.size()];
+		for (int i = 0; i < this.ensemble.size(); i++) {
+			predictions[i] = this.ensemble.get(i).getPredictionForInstance(inst);
+		}
+		return combinePredictions(predictions);
+	}
+
+	public Prediction getPredictionForInstanceUsingN(Instance inst, int n) {
+		Prediction[] predictions = new Prediction[this.ensemble.size()];
+		for (int i = 0; i < n; i++) {
+			predictions[i] = this.ensemble.get(i).getPredictionForInstance(inst);
+		}
+		return combinePredictions(predictions);
+	}
+	
+    @Override    
+    public void modelContextSet() {
+        for (int i = 0; i < this.ensemble.size(); i++) {
+            this.ensemble.get(i).setModelContext(this.getModelContext());;
+        }
+    }
+    
+    @Override
+    protected Measurement[] getModelMeasurementsImpl() {
+        return new Measurement[]{new Measurement("ensemble size",
+                    this.ensemble != null ? this.ensemble.size() : 0)};
+    }
+    
+    @SuppressWarnings("unchecked")
+	public MLTask[] getSubClassifiers() {
+        return (MLTask[]) this.ensemble.clone();
+    }
+}
diff --git a/moa/src/main/java/moa/classifiers/AbstractMultiLabelClassifier.java b/moa/src/main/java/moa/classifiers/AbstractMultiLabelClassifier.java
new file mode 100644
index 000000000..a220d147a
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/AbstractMultiLabelClassifier.java
@@ -0,0 +1,20 @@
+package moa.classifiers;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.learners.MultiLabelClassifier;
+
+public abstract class AbstractMultiLabelClassifier extends AbstractInstanceLearner<MultiLabelClassifier> {
+	
+	private static final long serialVersionUID = 1L;
+
+	public Prediction getPredictionForInstance(MultiLabelInstance inst) {
+		return this.getPredictionForInstance((Instance) inst);
+	}
+	
+	public void trainOnInstanceImpl(MultiLabelInstance inst) {
+		this.trainOnInstanceImpl((Instance) inst);
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/AbstractMultiLabelLearner.java b/moa/src/main/java/moa/classifiers/AbstractMultiLabelLearner.java
deleted file mode 100644
index c4ea71475..000000000
--- a/moa/src/main/java/moa/classifiers/AbstractMultiLabelLearner.java
+++ /dev/null
@@ -1,46 +0,0 @@
-package moa.classifiers;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Prediction;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-
-import moa.core.Example;
-
-public abstract class AbstractMultiLabelLearner extends AbstractClassifier implements MultiLabelLearner {
-
-    /**
-     *
-     */
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    abstract public void trainOnInstanceImpl(StructuredInstance instance);
-
-    @Override
-    public void trainOnInstanceImpl(Instance instance) {
-        trainOnInstanceImpl((StructuredInstance) instance);
-    }
-
-    @Override
-    public Prediction getPredictionForInstance(Example<Instance> example) {
-        return getPredictionForInstance(example.getData());
-    }
-
-    @Override
-    public Prediction getPredictionForInstance(Instance inst) {
-        return getPredictionForInstance((StructuredInstance) inst);
-    }
-
-    abstract public Prediction getPredictionForInstance(StructuredInstance inst);
-
-    @Override
-    public double[] getVotesForInstance(Instance inst) {
-        Prediction pred = getPredictionForInstance(inst);
-        if (pred != null) {
-            return pred.getVotes();
-        } else {
-            return new double[]{0}; //for compatibility with single target code
-        }
-    }
-
-}
diff --git a/moa/src/main/java/moa/classifiers/AbstractMultiTargetRegressor.java b/moa/src/main/java/moa/classifiers/AbstractMultiTargetRegressor.java
new file mode 100644
index 000000000..54ee2a713
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/AbstractMultiTargetRegressor.java
@@ -0,0 +1,22 @@
+package moa.classifiers;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.learners.MultiTargetRegressor;
+
+public abstract class AbstractMultiTargetRegressor extends AbstractInstanceLearner<MultiTargetRegressor> implements MultiTargetRegressor {
+
+	private static final long serialVersionUID = 1L;
+
+	public Prediction getPredictionForInstance(StructuredInstance instance) {
+		return this.getPredictionForInstance((Instance) instance);
+	}
+
+	@Override
+	public void trainOnInstanceImpl(StructuredInstance inst) {
+		this.trainOnInstanceImpl((Instance) inst); 
+	}
+
+}
diff --git a/moa/src/main/java/moa/classifiers/AbstractRegressor.java b/moa/src/main/java/moa/classifiers/AbstractRegressor.java
new file mode 100644
index 000000000..9e8bfc3b4
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/AbstractRegressor.java
@@ -0,0 +1,9 @@
+package moa.classifiers;
+
+import moa.learners.Regressor;
+
+public abstract class AbstractRegressor extends AbstractInstanceLearner<Regressor> implements Regressor {
+
+	private static final long serialVersionUID = 1L;
+
+}
diff --git a/moa/src/main/java/moa/classifiers/MultiLabelLearner.java b/moa/src/main/java/moa/classifiers/MultiLabelLearner.java
deleted file mode 100644
index 97e995a1c..000000000
--- a/moa/src/main/java/moa/classifiers/MultiLabelLearner.java
+++ /dev/null
@@ -1,12 +0,0 @@
-package moa.classifiers;
-
-import com.yahoo.labs.samoa.instances.Prediction;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-
-public interface MultiLabelLearner extends Classifier{
-	
-	public void trainOnInstanceImpl(StructuredInstance instance);
-	
-	public Prediction getPredictionForInstance(StructuredInstance instance);
-
-}
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBagASHT.java.orig b/moa/src/main/java/moa/classifiers/meta/OzaBagASHT.java.orig
new file mode 100644
index 000000000..6b78f94de
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/meta/OzaBagASHT.java.orig
@@ -0,0 +1,200 @@
+/*
+ *    OzaBagASHT.java
+ *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *    
+ */
+package moa.classifiers.meta;
+
+<<<<<<< HEAD
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
+=======
+import moa.options.ClassOption;
+>>>>>>> 3d07f07a8e1662963b332241c1fcfe85cebe0609
+import moa.classifiers.Classifier;
+import moa.classifiers.trees.ASHoeffdingTree;
+import moa.core.DoubleVector;
+import moa.core.MiscUtils;
+<<<<<<< HEAD
+=======
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.FlagOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import moa.classifiers.AbstractClassifier;
+import moa.core.Measurement;
+>>>>>>> 3d07f07a8e1662963b332241c1fcfe85cebe0609
+import moa.core.Utils;
+
+/**
+ * Bagging using trees of different size.
+ * The Adaptive-Size Hoeffding Tree (ASHT) is derived from the Hoeffding Tree
+ * algorithm with the following differences:
+ * <ul>
+ * <li> it has a maximum number of split nodes, or size
+ * <li> after one node splits, if the number of split nodes of the ASHT tree
+ * is higher than the maximum value, then it deletes some nodes to reduce its size
+ * </ul>
+ * The intuition behind this method is as follows: smaller trees adapt
+ * more quickly to changes, and larger trees do better during periods with
+ * no or little change, simply because they were built on more data. Trees
+ * limited to size s will be reset about twice as often as trees with a size
+ * limit of 2s. This creates a set of different reset-speeds for an ensemble of such
+ * trees, and therefore a subset of trees that are a good approximation for the
+ * current rate of change. It is important to note that resets will happen all
+ * the time, even for stationary datasets, but this behaviour should not have
+ * a negative impact on the ensemble’s predictive performance.
+ * When the tree size exceeds the maximun size value, there are two different
+ * delete options: <ul>
+ * <li> delete the oldest node, the root, and all of its children except the one
+ * where the split has been made. After that, the root of the child not
+ * deleted becomes the new root
+ * <li> delete all the nodes of the tree, i.e., restart from a new root.
+ * </ul>
+ * The maximum allowed size for the n-th ASHT tree is twice the maximum
+ * allowed size for the (n-1)-th tree. Moreover, each tree has a weight
+ * proportional to the inverse of the square of its error, and it monitors its
+ * error with an exponential weighted moving average (EWMA) with alpha = .01.
+ * The size of the first tree is 2.
+ * <br/><br/>
+ * With this new method, it is attempted to improve bagging performance
+ * by increasing tree diversity. It has been observed that boosting tends to
+ * produce a more diverse set of classifiers than bagging, and this has been
+ * cited as a factor in increased performance.<br/>
+ * See more details in:<br/><br/>
+ * Albert Bifet, Geoff Holmes, Bernhard Pfahringer, Richard Kirkby,
+ * and Ricard Gavaldà. New ensemble methods for evolving data
+ * streams. In 15th ACM SIGKDD International Conference on Knowledge
+ * Discovery and Data Mining, 2009.<br/><br/>
+ * The learner must be ASHoeffdingTree, a Hoeffding Tree with a maximum
+ * size value.<br/><br/>
+ * Example:<br/><br/>
+ * <code>OzaBagASHT -l ASHoeffdingTree -s 10 -u -r </code>
+ * Parameters:<ul>
+ * <li>Same parameters as <code>OzaBag</code>
+ * <li>-f : the size of first classifier in the bag.
+ * <li>-u : Enable weight classifiers
+ * <li>-e : Reset trees when size is higher than the max
+ * </ul>
+ *
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @version $Revision: 7 $
+ */
+public class OzaBagASHT extends AbstractClassifier {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public String getPurposeString() {
+        return "Bagging using trees of different size.";
+    }
+    
+    public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's',
+        "The number of models in the bag.", 10, 1, Integer.MAX_VALUE);
+    
+    public IntOption firstClassifierSizeOption = new IntOption("firstClassifierSize", 'f',
+            "The size of first classifier in the bag.", 1, 1, Integer.MAX_VALUE);
+
+    public FlagOption useWeightOption = new FlagOption("useWeight",
+            'u', "Enable weight classifiers.");
+
+    public FlagOption resetTreesOption = new FlagOption("resetTrees",
+            'e', "Reset trees when size is higher than the max.");
+
+        public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l',
+    		"ASHoeffdingTree to train.", ASHoeffdingTree.class,
+    		"moa.classifiers.trees.ASHoeffdingTree");
+    
+    protected ASHoeffdingTree[] ensemble;
+    protected double[] error;
+    protected double alpha = 0.01;
+
+    @Override
+    public void resetLearningImpl() {
+        this.ensemble = new ASHoeffdingTree[this.ensembleSizeOption.getValue()];
+        this.error = new double[this.ensembleSizeOption.getValue()];
+        Classifier baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
+        baseLearner.resetLearning();
+        int pow = this.firstClassifierSizeOption.getValue();
+        for (int i = 0; i < this.ensemble.length; i++) {
+            this.ensemble[i] = (ASHoeffdingTree) baseLearner.copy();
+            this.error[i] = 0.0;
+            ((ASHoeffdingTree) this.ensemble[i]).setMaxSize(pow);
+            if ((this.resetTreesOption != null)
+                    && this.resetTreesOption.isSet()) {
+                ((ASHoeffdingTree) this.ensemble[i]).setResetTree();
+            }
+            pow *= 2;
+        }
+    }
+
+    @Override
+    public void trainOnInstanceImpl(Instance inst) {
+        int trueClass = (int) inst.classValue();
+        for (int i = 0; i < this.ensemble.length; i++) {
+            int k = MiscUtils.poisson(1.0, this.classifierRandom);
+            if (k > 0) {
+                Instance weightedInst = (Instance) inst.copy();
+                weightedInst.setWeight(inst.weight() * k);
+                if (Utils.maxIndex(this.ensemble[i].getPredictionForInstance(inst)) == trueClass) {
+                    this.error[i] += alpha * (0.0 - this.error[i]); //EWMA
+                } else {
+                    this.error[i] += alpha * (1.0 - this.error[i]); //EWMA
+                }
+                this.ensemble[i].trainOnInstance(weightedInst);
+            }
+        }
+    }
+
+    public Prediction getPredictionForInstance(Instance inst) {
+        DoubleVector combinedVote = new DoubleVector();
+        for (int i = 0; i < this.ensemble.length; i++) {
+            DoubleVector vote = new DoubleVector(this.ensemble[i].getPredictionForInstance(inst));
+            if (vote.sumOfValues() > 0.0) {
+                vote.normalize();
+                if ((this.useWeightOption != null)
+                        && this.useWeightOption.isSet()) {
+                    vote.scaleValues(1.0 / (this.error[i] * this.error[i]));
+                }
+                combinedVote.addValues(vote);
+            }
+        }
+        return combinedVote.getArrayRef();
+    }
+
+    @Override
+    public void getModelDescription(StringBuilder out, int indent) {
+        // TODO Auto-generated method stub
+    }
+    
+    @Override
+    public boolean isRandomizable() {
+        return true;
+    }
+
+    @Override
+    protected Measurement[] getModelMeasurementsImpl() {
+        return new Measurement[]{new Measurement("ensemble size",
+                    this.ensemble != null ? this.ensemble.length : 0)};
+    }
+    
+    @Override
+    public Classifier[] getSubClassifiers() {
+        return this.ensemble.clone();
+    }
+}
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBagAdwinClassification.java b/moa/src/main/java/moa/classifiers/meta/OzaBagAdwinClassification.java
new file mode 100644
index 000000000..ae568d20e
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/meta/OzaBagAdwinClassification.java
@@ -0,0 +1,31 @@
+package moa.classifiers.meta;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.MultiTargetRegressionPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.DoubleVector;
+import moa.learners.Classifier;
+
+public class OzaBagAdwinClassification extends AbstractOzaBagAdwin<Classifier> implements Classifier{
+
+	private static final long serialVersionUID = 1L;
+
+	public OzaBagAdwinClassification() {
+		super(Classifier.class, "moa.classifiers.trees.HoeffdingTree");
+	}
+
+	public double getAdwinError(Instance inst, int i) {
+		return this.ensemble.get(i).correctlyClassifies(inst) ? 0 : 1;
+	}
+
+	public Prediction combinePredictions(Prediction[] predictions) {
+		DoubleVector sums = new DoubleVector();
+		for (Prediction p : predictions) {
+			sums.addValues(p.asDoubleVector());
+		}
+		sums.scaleValues(1 / sums.numValues());
+		return new MultiTargetRegressionPrediction(sums);
+	}
+
+}
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBagAdwinRegression.java b/moa/src/main/java/moa/classifiers/meta/OzaBagAdwinRegression.java
new file mode 100644
index 000000000..868594834
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/meta/OzaBagAdwinRegression.java
@@ -0,0 +1,28 @@
+package moa.classifiers.meta;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+import com.yahoo.labs.samoa.instances.predictions.RegressionPrediction;
+
+import moa.learners.Regressor;
+
+public class OzaBagAdwinRegression extends AbstractOzaBagAdwin<Regressor> {
+
+	private static final long serialVersionUID = 1L;
+
+	public OzaBagAdwinRegression() {
+		super(Regressor.class, "classifiers.trees.FIMTD");
+	}
+
+	public double getAdwinError(Instance inst, int i) {
+		return Math.abs(this.ensemble.get(i).getPredictionForInstance(inst).asDouble() - inst.classValue());
+	}
+
+	public Prediction combinePredictions(Prediction[] predictions) {
+		double sum = 0;
+		for (Prediction p : predictions) {
+			sum += p.asDouble();
+		}
+		return new RegressionPrediction(sum / predictions.length);
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBagClassification.java b/moa/src/main/java/moa/classifiers/meta/OzaBagClassification.java
new file mode 100644
index 000000000..41acd896a
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/meta/OzaBagClassification.java
@@ -0,0 +1,33 @@
+package moa.classifiers.meta;
+
+import com.yahoo.labs.samoa.instances.predictions.MultiTargetRegressionPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.DoubleVector;
+import moa.learners.Classifier;
+
+public class OzaBagClassification extends AbstractOzaBag<Classifier> implements Classifier {
+
+
+	private static final long serialVersionUID = 1L;
+
+	public OzaBagClassification() {
+		super(Classifier.class, "moa.classifiers.trees.HoeffdingTree");
+	}
+	
+	public Prediction combinePredictions(Prediction[] predictions) {
+		DoubleVector sums = new DoubleVector();
+		for (Prediction p : predictions) {
+			sums.addValues(p.asDoubleVector());
+		}
+		sums.scaleValues(1 / sums.numValues());
+		return new MultiTargetRegressionPrediction(sums);
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		// TODO Auto-generated method stub
+		
+	}
+	
+}
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBagRegression.java b/moa/src/main/java/moa/classifiers/meta/OzaBagRegression.java
new file mode 100644
index 000000000..4f715b8c1
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/meta/OzaBagRegression.java
@@ -0,0 +1,24 @@
+package moa.classifiers.meta;
+
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+import com.yahoo.labs.samoa.instances.predictions.RegressionPrediction;
+
+import moa.learners.Regressor;
+
+public class OzaBagRegression extends AbstractOzaBag<Regressor> implements Regressor {
+	
+	private static final long serialVersionUID = 1L;
+
+	public OzaBagRegression() {
+		super(Regressor.class, "moa.classifiers.trees.FIMTDD");
+	}
+	
+	public Prediction combinePredictions(Prediction[] predictions) {
+		double sum = 0;
+		for (Prediction p : predictions) {
+			sum += p.asDouble();
+		}
+		return new RegressionPrediction(sum / predictions.length);
+	}
+
+}
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBoostClassification.java b/moa/src/main/java/moa/classifiers/meta/OzaBoostClassification.java
new file mode 100644
index 000000000..9ed60eaee
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/meta/OzaBoostClassification.java
@@ -0,0 +1,46 @@
+package moa.classifiers.meta;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.DoubleVector;
+import moa.learners.Classifier;
+
+public class OzaBoostClassification extends AbstractOzaBoost<Classifier> implements Classifier {
+
+	private static final long serialVersionUID = 1L;
+
+	public OzaBoostClassification() {
+		super(Classifier.class, "moa.classifiers.trees.HoeffdingTree");
+	}
+
+	@Override
+	public void updateWeight(int i, Instance inst) {
+		double lambda_d = 1.0;
+		if (this.ensemble.get(i).correctlyClassifies(inst)) {
+			this.scms[i] += lambda_d;
+			lambda_d *= this.trainingWeightSeenByModel / (2 * this.scms[i]);
+		} else {
+			this.swms[i] += lambda_d;
+			lambda_d *= this.trainingWeightSeenByModel / (2 * this.swms[i]);
+		}		
+	}
+
+	@Override
+	public Prediction combinePredictions(Prediction[] predictions, double[] weights) {
+		DoubleVector combinedVote = new DoubleVector();
+		for (int i = 0; i < predictions.length; i++) {
+			if (weights[i] > 0.0) {
+				DoubleVector vote = predictions[i].asDoubleVector();
+				if (vote.sumOfValues() > 0.0) {
+					vote.normalize();
+					vote.scaleValues(weights[i]);
+					combinedVote.addValues(vote);
+				}
+			}
+		}
+		return new ClassificationPrediction(combinedVote.getArrayRef());
+	}
+
+}
diff --git a/moa/src/main/java/moa/classifiers/meta/RegressionViaMTR.java b/moa/src/main/java/moa/classifiers/meta/RegressionViaMTR.java
new file mode 100644
index 000000000..578286f9f
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/meta/RegressionViaMTR.java
@@ -0,0 +1,54 @@
+package moa.classifiers.meta;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+import com.yahoo.labs.samoa.instances.predictions.RegressionPrediction;
+
+import moa.classifiers.AbstractRegressor;
+import moa.core.Measurement;
+import moa.learners.MultiTargetRegressor;
+import moa.learners.Regressor;
+import moa.options.ClassOption;
+
+public class RegressionViaMTR extends AbstractRegressor implements Regressor {
+
+	public MultiTargetRegressor mtr;
+
+	public ClassOption regressorOption = new ClassOption("MTregessor", 'c', "Multi-target regressor to be used as a single target regressor.", MultiTargetRegressor.class, "moa.classifiers.mtr.ISOUPTree");
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		out.append("Meta single-target regressor which uses a multi-target regressor with a single target.");
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance instance) {
+		Prediction p = mtr.getPredictionForInstance(instance);
+		return new RegressionPrediction(p.getPrediction(0));
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		mtr.trainOnInstance(inst);
+	}
+
+	@Override
+	public void resetLearningImpl() {
+		if (this.mtr == null)
+			this.mtr = (MultiTargetRegressor) getPreparedClassOption(this.regressorOption);
+		this.mtr.resetLearning();
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return this.mtr.getModelMeasurements();
+	}
+
+
+
+}
diff --git a/moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java.orig b/moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java.orig
new file mode 100644
index 000000000..15378090c
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java.orig
@@ -0,0 +1,190 @@
+/*
+ *    TemporallyAugmentedClassifier.java
+ *    Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ *    @author Bernhard Pfahringer (bernhard@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *    
+ */
+package moa.classifiers.meta;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+<<<<<<< HEAD
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Attribute;
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
+=======
+import com.yahoo.labs.samoa.instances.*;
+>>>>>>> 3d07f07a8e1662963b332241c1fcfe85cebe0609
+import moa.classifiers.AbstractClassifier;
+import moa.classifiers.Classifier;
+import moa.core.Measurement;
+import moa.core.Utils;
+import moa.options.ClassOption;
+
+/**
+ * Include labels of previous instances into the training data
+ *
+ * <p>This enables a classifier to exploit potentially present auto-correlation
+ * </p>
+ *
+ * <p>Parameters:</p> <ul> <li>-l : Classifier to train</li> <li>-n : The number
+ * of old labels to include</li> </ul>
+ *
+ * @author Bernhard Pfahringer (bernhard@cs.waikato.ac.nz)
+ * @version $Revision: 1 $
+ */
+public class TemporallyAugmentedClassifier extends AbstractClassifier {
+
+    @Override
+    public String getPurposeString() {
+        return "Add some old labels to every instance";
+    }
+    private static final long serialVersionUID = 1L;
+    
+    public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l',
+            "Classifier to train.", Classifier.class, "trees.HoeffdingTree");
+    
+    public IntOption numOldLabelsOption = new IntOption("numOldLabels", 'n',
+            "The number of old labels to add to each example.", 1, 0, Integer.MAX_VALUE);
+    
+    protected Classifier baseLearner;
+    
+    protected double[] oldLabels;
+    
+    protected InstancesHeader header;
+
+    public FlagOption labelDelayOption = new FlagOption("labelDelay", 'd',
+        "Labels arrive with Delay. Use predictions instead of true Labels.");
+    
+    @Override
+    public void resetLearningImpl() {
+        this.baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
+        this.oldLabels = new double[this.numOldLabelsOption.getValue()];
+        this.header = null;
+        baseLearner.resetLearning();
+    }
+
+    @Override
+    public void trainOnInstanceImpl(Instance instance) {
+        this.baseLearner.trainOnInstance(extendWithOldLabels(instance));
+        if (this.labelDelayOption.isSet() == false) {
+            // Use true old Labels to add attributes to instances
+            addOldLabel(instance.classValue());
+        }
+    }
+
+    public void addOldLabel(double newPrediction) {
+        int numLabels = this.oldLabels.length;
+        if (numLabels > 0) {
+            for (int i = 1; i < numLabels; i++) {
+                this.oldLabels[i - 1] = this.oldLabels[i];
+            }
+            this.oldLabels[ numLabels - 1] = newPrediction;
+        }
+    }
+
+    public void initHeader(InstancesHeader dataset) {
+        int numLabels = this.numOldLabelsOption.getValue();
+        Attribute target = dataset.classAttribute();
+
+        List<String> possibleValues = new ArrayList<String>();
+        int n = target.numValues();
+        for (int i = 0; i < n; i++) {
+            possibleValues.add(target.value(i));
+        }
+
+        ArrayList<Attribute> attrs = new ArrayList<Attribute>(numLabels + dataset.numAttributes());
+        for (int i = 0; i < numLabels; i++) {
+            attrs.add(new Attribute(target.name() + "_" + i, possibleValues));
+        }
+        for (int i = 0; i < dataset.numAttributes(); i++) {
+            Attribute attr = dataset.attribute(i);
+            Attribute newAttribute = null;
+            if (attr.isNominal() == true) {
+                newAttribute = new Attribute(attr.name(), attr.getAttributeValues());
+            }
+            if (attr.isNumeric() == true) {
+                newAttribute = new Attribute(attr.name());
+            }
+            if (newAttribute != null) {
+                attrs.add(newAttribute);
+            }
+        }
+        this.header = new InstancesHeader("extended_" + dataset.getRelationName(), attrs, 0);
+        this.header.setClassIndex(numLabels + dataset.classIndex());
+    }
+
+    public Instance extendWithOldLabels(Instance instance) {
+        if (this.header == null) {
+            initHeader(instance.dataset());
+            this.baseLearner.setModelContext(new InstancesHeader(this.header));
+        }
+        int numLabels = this.oldLabels.length;
+        if (numLabels == 0) {
+            return instance;
+        }
+        double[] x = instance.toDoubleArray();
+        double[] x2 = Arrays.copyOfRange(this.oldLabels, 0, numLabels + x.length);
+        System.arraycopy(x, 0, x2, numLabels, x.length);
+        Instance extendedInstance = new DenseInstance(instance.weight(), x2);
+        extendedInstance.setDataset(this.header);
+        //System.out.println( extendedInstance);
+        return extendedInstance;
+    }
+
+    @Override
+    public Prediction getPredictionForInstance(Instance instance) {
+        double[] prediction = this.baseLearner.getPredictionForInstance(extendWithOldLabels(instance));
+        if (this.labelDelayOption.isSet() == true) {
+            // Use predicted Labels to add attributes to instances
+            addOldLabel(Utils.maxIndex(prediction));
+        }
+        return prediction;
+    }
+
+    @Override
+    public boolean isRandomizable() {
+        return false; // ??? this.baseLearner.isRandomizable;
+    }
+
+    @Override
+    protected Measurement[] getModelMeasurementsImpl() {
+        List<Measurement> measurementList = new LinkedList<Measurement>();
+        Measurement[] modelMeasurements = ((AbstractClassifier) this.baseLearner).getModelMeasurements();
+        if (modelMeasurements != null) {
+            for (Measurement measurement : modelMeasurements) {
+                measurementList.add(measurement);
+            }
+        }
+        return measurementList.toArray(new Measurement[measurementList.size()]);
+    }
+
+    @Override
+    public void getModelDescription(StringBuilder out, int indent) {
+        // TODO Auto-generated method stub
+    }
+
+    public String toString() {
+        return "TemporallyAugmentedClassifier using " + this.numOldLabelsOption.getValue() + " labels\n" + this.baseLearner;
+    }
+}
diff --git a/moa/src/main/java/moa/classifiers/mlc/MultilabelHoeffdingTree.java.orig b/moa/src/main/java/moa/classifiers/mlc/MultilabelHoeffdingTree.java.orig
new file mode 100644
index 000000000..e0a4c43a7
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/mlc/MultilabelHoeffdingTree.java.orig
@@ -0,0 +1,237 @@
+/*
+ *    MultilabelHoeffdingTree.java
+ *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
+ *    @author Jesse Read (jesse@tsc.uc3m.es)
+ * 
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *    
+ */
+package moa.classifiers.multilabel;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+<<<<<<< HEAD
+=======
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
+>>>>>>> 32d534d2e43c28db1711ab2fe7ff580d214e22fe
+import com.yahoo.labs.samoa.instances.Prediction;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+
+import moa.classifiers.Classifier;
+import moa.classifiers.MultiLabelClassifier;
+import moa.classifiers.MultiTargetRegressor;
+import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
+import moa.classifiers.trees.HoeffdingTree;
+import moa.core.Example;
+import moa.core.StringUtils;
+
+/**
+ * Hoeffding Tree for classifying multi-label data.
+ *
+ * A Hoeffding tree is an incremental, anytime decision tree induction algorithm
+ * that is capable of learning from massive data streams, assuming that the
+ * distribution generating examples does not change over time.
+ * 
+ * 
+ */ 
+public class MultilabelHoeffdingTree extends HoeffdingTreeClassifLeaves implements MultiLabelClassifier, MultiTargetRegressor, Classifier { 
+// Needs to use InfoGainSplitCriterionMultiLabel, since multilabel entropy is calculated in a different way 
+// Trains a mlinstance adding statistics of several class values and training node classifiers
+// Get votes from the classifier in the learning node of the tree
+
+	private static final long serialVersionUID = 1L;
+
+
+	/*public MultilabelHoeffdingTree() {
+		this.removePoorAttsOption = null;
+	}*/
+
+	@Override
+	protected LearningNode newLearningNode(double[] initialClassObservations) {
+		// Create new Learning Node with a null classifier
+		return new MultilabelLearningNodeClassifier(initialClassObservations,null,this);
+	}
+
+	//@Override
+	protected LearningNode newLearningNode(double[] initialClassObservations, Classifier cl) {
+		// Create new Learning Node
+		return new MultilabelLearningNodeClassifier(initialClassObservations,cl,this);
+	}
+
+	public static class MultilabelInactiveLearningNode extends InactiveLearningNode {
+
+		private static final long serialVersionUID = 1L;
+
+		public MultilabelInactiveLearningNode(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, HoeffdingTree ht) {
+			List<Integer> labels = ((MultilabelHoeffdingTree) ht).getRelevantLabels(inst);
+			for (int l : labels){
+				this.observedClassDistribution.addToValue(l, inst.weight());
+			}
+		}
+	}
+
+	public class MultilabelLearningNodeClassifier extends LearningNodeClassifier {
+		// It uses classifier at nodes, and to be able to train with several class values
+
+		private static final long serialVersionUID = 1L;
+
+		public MultilabelLearningNodeClassifier(double[] initialClassObservations, Classifier cl, MultilabelHoeffdingTree ht ) {
+			super(initialClassObservations);
+
+			if (cl== null) {
+				this.classifier = ((Classifier) getPreparedClassOption(ht.learnerOption)).copy();
+				this.classifier.resetLearning();
+
+				InstancesHeader raw_header = ht.getModelContext();
+				this.classifier.setModelContext(raw_header);
+			}
+			else{
+				this.classifier = cl.copy();
+			}
+		}
+
+		@Override
+		public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
+
+			return this.classifier.getPredictionForInstance(inst); 			
+		}
+
+		public Prediction getPredictionForInstance(Instance inst, HoeffdingTree ht) {
+
+			return this.classifier.getPredictionForInstance(inst);
+		}
+		
+		@Override
+		public void disableAttribute(int attIndex) {
+			// should not disable poor atts - they are used in NB calc
+		}
+
+		public Classifier getClassifier() {
+			return this.classifier;
+		}
+
+	    @Override
+		public void learnFromInstance(Instance inst, HoeffdingTree ht) {
+
+			//It uses different class values, not only one
+			this.classifier.trainOnInstance(inst);
+			MultilabelHoeffdingTree mht = ((MultilabelHoeffdingTree) ht);
+			List<Integer> labels = mht.getRelevantLabels(inst);
+			for (int l : labels){
+				this.observedClassDistribution.addToValue( l, inst.weight());
+			}
+
+			for (int i = 0; i < inst.numInputAttributes(); i++) {
+				int instAttIndex = i;
+				AttributeClassObserver obs = this.attributeObservers.get(instAttIndex); //i
+				if (obs == null) {
+					obs = inst.inputAttribute(i).isNominal() ? mht.newNominalClassObserver() : mht.newNumericClassObserver();
+					this.attributeObservers.set(i, obs);
+				}
+				for (int l : labels){
+					obs.observeAttributeClass(inst.valueInputAttribute(i), l, inst.weight());
+				}
+			}
+		}
+
+		public void describeSubtree(HoeffdingTree ht, StringBuilder out,
+									int indent) {
+			StringUtils.appendIndented(out, indent, "Leaf ");
+			out.append(" = ");
+			out.append(" weights: ");
+			this.observedClassDistribution.getSingleLineDescription(out,
+					this.observedClassDistribution.numValues());
+			StringUtils.appendNewline(out);
+		}
+	}
+
+	@Override
+	protected void deactivateLearningNode(ActiveLearningNode toDeactivate,
+			SplitNode parent, int parentBranch) {
+		//It uses MultilabelInactiveLearningNode since there are several class values
+		Node newLeaf = new MultilabelInactiveLearningNode(toDeactivate
+				.getObservedClassDistribution());
+		if (parent == null) {
+			this.treeRoot = newLeaf;
+		} else {
+			parent.setChild(parentBranch, newLeaf);
+		}
+		this.activeLeafNodeCount--;
+		this.inactiveLeafNodeCount++;
+	}
+
+
+	@Override
+	public Prediction getPredictionForInstance(Example<Instance> example) {
+		return getPredictionForInstance((StructuredInstance)example.getData());
+	}
+
+	public Prediction getPredictionForInstance(StructuredInstance inst) {
+		return getPredictionForInstance((Instance) inst);
+	}
+	
+	@Override
+	public Prediction getPredictionForInstance(Instance inst){
+
+		if (this.treeRoot != null) {
+			FoundNode foundNode = this.treeRoot.filterInstanceToLeaf(inst, null, -1);
+			Node leafNode = (MultilabelLearningNodeClassifier) foundNode.node;
+			MultilabelLearningNodeClassifier multilabelLeafNode = (MultilabelLearningNodeClassifier) leafNode;
+			if (leafNode == null) {
+				leafNode = foundNode.parent;
+			}
+			return multilabelLeafNode.getPredictionForInstance(inst, this);
+		}
+		else {
+			System.err.println("[WARNING] Root Node == Null !!!!!!");
+		}
+
+		// Return empty array (this should only happen once! -- before we build the root node).
+		return null;
+	}
+
+	@Override
+	public void trainOnInstance(Instance inst) {
+		boolean isTraining = (inst.weight() > 0.0);
+		if (isTraining) {
+			this.trainingWeightSeenByModel += inst.weight();
+			trainOnInstanceImpl((StructuredInstance) inst);
+		}
+	}
+
+	@Override
+	public void trainOnInstanceImpl(StructuredInstance instance) {
+		trainOnInstanceImpl((Instance) instance);
+	}
+        
+	public static List<Integer> getRelevantLabels(Instance x) {
+		List<Integer> classValues = new LinkedList<Integer>();
+		//get all class attributes
+		for (int j = 0; j < x.numberOutputTargets(); j++) {
+			if (x.classValue(j) > 0.0) {
+				classValues.add(j);
+			}
+		}
+		return classValues;
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/mlc/meta/MLOzaBag.java b/moa/src/main/java/moa/classifiers/mlc/meta/MLOzaBag.java
deleted file mode 100644
index f5d1dff78..000000000
--- a/moa/src/main/java/moa/classifiers/mlc/meta/MLOzaBag.java
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
- *    MLOzaBag.java
- *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
- *    @author Jesse Read (jesse@tsc.uc3m.es)
- * 
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.multilabel.meta;
-
-import moa.classifiers.Classifier;
-import moa.classifiers.meta.OzaBag;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
-import com.yahoo.labs.samoa.instances.Prediction;
-import moa.classifiers.MultiLabelLearner;
-import moa.classifiers.MultiTargetRegressor;
-import moa.core.Example;
-
-/**
- * OzaBag for Multi-label data.
- * 
- * @author Jesse Read (jesse@tsc.uc3m.es)
- * @version $Revision: 1 $
- */
-public class MLOzaBag extends OzaBag implements MultiLabelLearner, MultiTargetRegressor{
-
-    protected int m_L = -1;
-
-    //protected Random random = null;
-
-    /*
-     * @Override public void resetLearningImpl() { super.resetLearningImpl();
-     * //this.random = new Random(randomSeedOption.getValue()); }
-     */
-    @Override
-    public void resetLearningImpl() {
-        this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
-        Classifier baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
-        baseLearner.resetLearning();
-        for (int i = 0; i < this.ensemble.length; i++) {
-            this.ensemble[i] = baseLearner.copy();
-        }
-    }
-
-    @Override
-    public void setModelContext(InstancesHeader raw_header) {
-
-        //set the multilabel model context
-        this.modelContext = raw_header;
-
-        m_L = raw_header.classIndex() + 1;
-
-        // reset ensemble
-        this.resetLearningImpl();
-
-        for (int i = 0; i < this.ensemble.length; i++) {
-            this.ensemble[i].setModelContext(raw_header);
-            this.ensemble[i].resetLearning();
-        }
-    }
-
-    @Override // @note don't need this here
-    public boolean isRandomizable() {
-        return true;
-    }
-
-    @Override
-    public double[] getVotesForInstance(Instance x) {
-
-        int L = x.classIndex() + 1;
-        if (m_L != L) {
-            m_L = L;
-        }
-
-        double y[] = new double[m_L];
-
-        for (int i = 0; i < this.ensemble.length; i++) {
-            double w[] = this.ensemble[i].getVotesForInstance(x);
-            for (int j = 0; j < w.length; j++) {
-                y[j] += w[j];
-            }
-        }
-
-        return y;
-    }
-
-    @Override
-    public void trainOnInstanceImpl(StructuredInstance instance) {
-        trainOnInstanceImpl((Instance) instance);
-    }
-    
-    @Override
-	public Prediction getPredictionForInstance(Example<Instance> example) {
-		return getPredictionForInstance((StructuredInstance)example.getData());
-	} 
-    
-    @Override
-	public Prediction getPredictionForInstance(StructuredInstance instance) {
-
-		double[] predictionArray = this.getVotesForInstance(instance);
-
-		//System.out.println("y = "+Arrays.toString(predictionArray));
-
-		Prediction prediction = new MultiLabelPrediction(predictionArray.length);
-		for (int j = 0; j < predictionArray.length; j++){
-			prediction.setVote(j, 1, predictionArray[j]);
-			//prediction.setVote(j, 0, 1. - predictionArray[j]);
-		}
-		return prediction;
-	}
-
-}
diff --git a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java b/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
new file mode 100644
index 000000000..e4cc9792d
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
@@ -0,0 +1,1031 @@
+/*
+ *    FIMTDD.java
+ *    Copyright (C) 2015 Jožef Stefan Institute, Ljubljana, Slovenia
+ *    @author Aljaž Osojnik <aljaz.osojnik@ijs.si>
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *    
+ *    
+ */
+
+package moa.classifiers.trees;
+
+import java.io.Serializable;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+import com.yahoo.labs.samoa.instances.predictions.RegressionPrediction;
+
+import moa.AbstractMOAObject;
+import moa.classifiers.AbstractRegressor;
+import moa.classifiers.core.AttributeSplitSuggestion;
+import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
+import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
+import moa.classifiers.core.splitcriteria.SplitCriterion;
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.SizeOf;
+import moa.core.StringUtils;
+import moa.learners.Regressor;
+import moa.options.ClassOption;
+
+/*
+ * Implementation of FIMTDD, regression and model trees for data streams.
+ */
+
+public class FIMTDD extends AbstractRegressor implements Regressor {
+
+	private static final long serialVersionUID = 1L;
+
+	public Node treeRoot;
+
+	public int leafNodeCount = 0;
+	public int splitNodeCount = 0;
+
+	protected double examplesSeen = 0.0;
+	protected double sumOfValues = 0.0;
+	protected double sumOfSquares = 0.0;
+
+	protected DoubleVector sumOfAttrValues = new DoubleVector();
+	protected DoubleVector sumOfAttrSquares = new DoubleVector();
+
+	public int maxID = 0;
+
+	//region ================ OPTIONS ================
+
+	public ClassOption splitCriterionOption = new ClassOption(
+			"splitCriterion", 's', "Split criterion to use.",
+			SplitCriterion.class, "moa.classifiers.core.splitcriteria.VarianceReductionSplitCriterion");
+
+	public IntOption gracePeriodOption = new IntOption(
+			"gracePeriod", 'g', "Number of instances a leaf should observe between split attempts.",
+			200, 0, Integer.MAX_VALUE);
+
+	public FloatOption splitConfidenceOption = new FloatOption(
+			"splitConfidence", 'c', "Allowed error in split decision, values close to 0 will take long to decide.",
+			0.0000001, 0.0, 1.0);
+
+	public FloatOption tieThresholdOption = new FloatOption(
+			"tieThreshold", 't', "Threshold below which a split will be forced to break ties.",
+			0.05, 0.0, 1.0);
+
+	public FloatOption PageHinckleyAlphaOption = new FloatOption(
+			"PageHinckleyAlpha", 'a', "Alpha value to use in the Page Hinckley change detection tests.",
+			0.005, 0.0, 1.0);
+
+	public IntOption PageHinckleyThresholdOption = new IntOption(
+			"PageHinckleyThreshold", 'h', "Threshold value used in the Page Hinckley change detection tests.",
+			50, 0, Integer.MAX_VALUE);
+
+	public FloatOption alternateTreeFadingFactorOption = new FloatOption(
+			"alternateTreeFadingFactor", 'f', "Fading factor used to decide if an alternate tree should replace an original.",
+			0.995, 0.0, 1.0);
+
+	public IntOption alternateTreeTMinOption = new IntOption(
+			"alternateTreeTMin", 'y', "Tmin value used to decide if an alternate tree should replace an original.",
+			150, 0, Integer.MAX_VALUE);
+
+	public IntOption alternateTreeTimeOption = new IntOption(
+			"alternateTreeTime", 'u', "The number of instances used to decide if an alternate tree should be discarded.",
+			1500, 0, Integer.MAX_VALUE);
+
+	public FlagOption regressionTreeOption = new FlagOption(
+			"regressionTree", 'e', "Build a regression tree instead of a model tree.");
+
+	public FloatOption learningRatioOption = new FloatOption(
+			"learningRatio", 'l', "Learning ratio to used for training the Perceptrons in the leaves.",
+			0.003, 0, 1.00);
+
+	public FloatOption learningRateDecayFactorOption = new FloatOption(
+			"learningRatioDecayFactor", 'd', "Learning rate decay factor (not used when learning rate is constant).",
+			0.001, 0, 1.00);
+
+	public FlagOption learningRatioConstOption = new FlagOption(
+			"learningRatioConst", 'p', "Keep learning rate constant instead of decaying.");
+	
+	public IntOption maxDepthOption = new IntOption(
+			"maxDepthFactor", 'b', "The maximum depth of the tree.",
+			Integer.MAX_VALUE, 0, Integer.MAX_VALUE);
+
+	//endregion ================ OPTIONS ================
+
+	//region ================ CLASSES ================
+
+	public abstract static class Node extends AbstractMOAObject {
+
+		private static final long serialVersionUID = 1L;
+
+		public int ID;
+
+		protected FIMTDD tree;
+		
+		protected boolean changeDetection = true;
+		
+		protected Node parent;
+
+		protected Node alternateTree;
+		protected Node originalNode;
+
+		// The statistics for this node:
+		// Number of instances that have reached it
+		protected double examplesSeen;
+		// Sum of y values
+		protected double sumOfValues;
+		// Sum of squared y values
+		protected double sumOfSquares;
+		// Sum of absolute errors
+		protected double sumOfAbsErrors; // Needed for PH tracking of mean error
+
+		public Node(FIMTDD tree) {
+			this.tree = tree;
+			ID = tree.maxID; 
+		}
+
+		public void copyStatistics(Node node) {
+			examplesSeen = node.examplesSeen;
+			sumOfValues = node.sumOfValues;
+			sumOfSquares = node.sumOfSquares;
+			sumOfAbsErrors = node.sumOfAbsErrors;
+		}
+
+		public long calcByteSize() {
+			return SizeOf.sizeOf(this) + (originalNode == null && alternateTree != null ? alternateTree.calcByteSize() : 0);
+		}
+
+		/**
+		 * Set the parent node
+		 */
+		public void setParent(Node parent) {
+			this.parent = parent;    
+		}
+
+		/**
+		 * Return the parent node
+		 */
+		public Node getParent() {
+			return parent;
+		}
+
+		public void disableChangeDetection() {
+			changeDetection = false;
+		}
+
+		public void restartChangeDetection() {
+			changeDetection = true;
+		}
+		
+		public void getDescription(StringBuilder sb, int indent) {
+			
+		}
+
+		public double getPrediction(Instance inst) {
+			return 0;
+		}
+		
+		public void describeSubtree(StringBuilder out, int indent) {
+			StringUtils.appendIndented(out, indent, "Leaf");
+		}
+		
+		public int getLevel() {
+			Node target = this;
+			int level = 0;
+			while (target.getParent() != null) {
+				if (target.skipInLevelCount()) {
+					target = target.getParent();
+					continue;
+				}
+				level = level + 1;
+				target = target.getParent();
+			}
+			if (target.originalNode == null) {
+				return level;
+			} else {
+				return level + originalNode.getLevel();
+			}
+		}
+
+		public void setChild(int parentBranch, Node node) {
+		}
+
+		public int getChildIndex(Node child) {
+			return -1;
+		}
+
+		public int getNumSubtrees() {
+			return 1;
+		}
+
+		public int numLeaves() {
+			return 1;
+		}
+		
+		protected boolean skipInLevelCount() {
+			return false;
+		}
+	}
+
+	public static class LeafNode extends Node {
+
+		private static final long serialVersionUID = 1L;
+
+		public double errorModel = 0.0;
+		public double errorTargetMean = 0.0;
+		
+		// Perceptron model that carries out the actual learning in each node
+		public FIMTDDPerceptron learningModel;
+
+		protected AutoExpandVector<FIMTDDNumericAttributeClassObserver> attributeObservers = new AutoExpandVector<FIMTDDNumericAttributeClassObserver>();
+		
+		protected double examplesSeenAtLastSplitEvaluation = 0;
+
+		/**
+		 * Create a new LeafNode
+		 */
+		public LeafNode(FIMTDD tree) {
+			super(tree);
+			if (tree.buildingModelTree()) {
+				learningModel = tree.newLeafModel();
+			}
+			examplesSeen = 0;
+			sumOfValues = 0;
+			sumOfSquares = 0;
+			sumOfAbsErrors = 0;
+		}
+
+		public long calcByteSize() {
+			long size = super.calcByteSize();
+			if (tree.buildingModelTree())
+				size += learningModel.calcByteSize();
+			size += SizeOf.fullSizeOf(attributeObservers);
+			return size;
+		}
+		
+		public void setChild(int parentBranch, Node node) {
+		}
+
+		public int getChildIndex(Node child) {
+			return -1;
+		}
+
+		public int getNumSubtrees() {
+			return 1;
+		}
+
+		protected boolean skipInLevelCount() {
+			return false;
+		}
+		
+		/**
+		 * Method to learn from an instance that passes the new instance to the perceptron learner,
+		 * and also prevents the class value from being truncated to an int when it is passed to the
+		 * attribute observer
+		 */
+		public void learnFromInstance(Instance inst, boolean growthAllowed, double prediction) {
+			//The prediction must be calculated here -- it may be different from the tree's prediction due to alternate trees
+			
+			// Update the statistics for this node
+			// number of instances passing through the node
+			examplesSeen += inst.weight();
+
+			// sum of y values
+			sumOfValues += inst.weight() * inst.classValue();
+
+			// sum of squared y values
+			sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
+
+			// sum of absolute errors
+			sumOfAbsErrors += inst.weight() * Math.abs(tree.normalizeTargetValue(Math.abs(inst.classValue() - prediction)));
+			
+			if (tree.buildingModelTree()) {
+				double predictionModel = getPredictionModel(inst);
+				double predictionTargetMean = getPredictionTargetMean(inst);
+				
+				errorModel = errorModel * 0.95 + Math.abs(predictionModel - inst.classValue());
+				errorTargetMean = errorTargetMean * 0.95 + Math.abs(predictionTargetMean - inst.classValue());
+				
+				learningModel.updatePerceptron(inst);
+			}
+
+			for (int i = 0; i < inst.numAttributes() - 1; i++) {
+				int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
+				FIMTDDNumericAttributeClassObserver obs = attributeObservers.get(i);
+				if (obs == null) {
+					// At this stage all nominal attributes are ignored
+					if (inst.attribute(instAttIndex).isNumeric()) {
+						obs = tree.newNumericClassObserver();
+						this.attributeObservers.set(i, obs);
+					}
+				}
+				if (obs != null) {
+					obs.observeAttributeClass(inst.value(instAttIndex), inst.classValue(), inst.weight());
+				}
+			}
+
+			if (growthAllowed) {
+				checkForSplit(inst, prediction);
+			}
+		}
+
+		/**
+		 * Return the best split suggestions for this node using the given split criteria
+		 */
+		public AttributeSplitSuggestion[] getBestSplitSuggestions(SplitCriterion criterion) {
+
+			List<AttributeSplitSuggestion> bestSuggestions = new LinkedList<AttributeSplitSuggestion>();
+
+			// Set the nodeStatistics up as the preSplitDistribution, rather than the observedClassDistribution
+			double[] nodeSplitDist = new double[] {examplesSeen, sumOfValues, sumOfSquares};
+
+			for (int i = 0; i < this.attributeObservers.size(); i++) {
+				FIMTDDNumericAttributeClassObserver obs = this.attributeObservers.get(i);
+				if (obs != null) {
+
+					// AT THIS STAGE NON-NUMERIC ATTRIBUTES ARE IGNORED
+					AttributeSplitSuggestion bestSuggestion = null;
+					if (obs instanceof FIMTDDNumericAttributeClassObserver) {
+						bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion, nodeSplitDist, i, true);
+					}
+
+					if (bestSuggestion != null) {
+						bestSuggestions.add(bestSuggestion);
+					}
+				}
+			}
+			return bestSuggestions.toArray(new AttributeSplitSuggestion[bestSuggestions.size()]);
+		}
+
+		/**
+		 * Retrieve the class votes using the perceptron learner
+		 */
+		public double getPredictionModel(Instance inst) {
+			return learningModel.prediction(inst);
+		}
+
+		public double getPredictionTargetMean(Instance inst) {
+			return (examplesSeen > 0.0) ? sumOfValues / examplesSeen : 0.0;
+		}
+
+		public double getPrediction(Instance inst) {
+			if (tree.buildingModelTree()) {
+				return (errorModel < errorTargetMean) ? getPredictionModel(inst) : getPredictionTargetMean(inst);
+			} else
+				return getPredictionTargetMean(inst);
+		}
+		
+		public void checkForSplit(Instance inst, double prediction) {
+			// If it has seen Nmin examples since it was last tested for splitting, attempt a split of this node
+			if (this.getLevel() < tree.maxDepthOption.getValue() && examplesSeen - examplesSeenAtLastSplitEvaluation >= tree.gracePeriodOption.getValue()) {
+				int index = (parent != null) ? parent.getChildIndex(this) : 0;
+				tree.attemptToSplit(this, parent, index, inst, prediction);
+
+				// Take note of how many instances were seen when this split evaluation was made, so we know when to perform the next split evaluation
+				examplesSeenAtLastSplitEvaluation = examplesSeen;
+			}
+		}
+
+		public void describeSubtree(StringBuilder out, int indent) {
+			StringUtils.appendIndented(out, indent, "Leaf ");
+			if (tree.buildingModelTree()) {
+				learningModel.getModelDescription(out, 0);
+			} else {
+				out.append(tree.getClassNameString() + " = " + String.format("%.4f", sumOfValues / examplesSeen));
+				StringUtils.appendNewline(out);
+			}
+		}
+	}
+
+	public abstract static class InnerNode extends Node {
+		// The InnerNode and SplitNode design is used for easy extension in ORTO
+		private static final long serialVersionUID = 1L;
+
+		protected AutoExpandVector<Node> children = new AutoExpandVector<Node>();
+
+		// The error values for the Page Hinckley test
+		// PHmT = the cumulative sum of the errors
+		// PHMT = the minimum error value seen so far
+		protected double PHsum = 0;
+		protected double PHmin = Double.MAX_VALUE;
+
+		// Keep track of the statistics for loss error calculations
+		protected double lossExamplesSeen;
+		protected double lossFadedSumOriginal;
+		protected double lossFadedSumAlternate;
+		protected double lossNumQiTests;
+		protected double lossSumQi;
+		protected double previousWeight = 0;
+		
+		public InnerNode(FIMTDD tree) {
+			super(tree);
+		}
+		
+		public long calcByteSize() {
+			long size = super.calcByteSize();
+			for (Node child : children)
+				size += child.calcByteSize();
+			return size;
+		}
+
+		public int numChildren() {
+			return children.size();
+		}
+
+		public int numLeaves() {
+			int leaves = 0;
+			for (Node child : children) leaves += child.numLeaves();
+			return leaves;
+		}
+		
+		public Node getChild(int index) {
+			return children.get(index);
+		}
+
+		public int getChildIndex(Node child) {
+			return children.indexOf(child);
+		}
+
+		public void setChild(int index, Node child) {
+			children.set(index, child);
+		}
+
+		public void disableChangeDetection() {
+			changeDetection = false;
+			for (Node child : children) {
+				child.disableChangeDetection();
+			}
+		}
+
+		public void restartChangeDetection() {
+			if (alternateTree == null) {
+				changeDetection = true;
+				PHsum = 0;
+				PHmin = Integer.MAX_VALUE;
+				for (Node child : children)
+					child.restartChangeDetection();
+			}
+		}
+		
+		/**
+		 * Check to see if the tree needs updating
+		 */
+		public boolean PageHinckleyTest(double error, double threshold) {    
+			// Update the cumulative mT sum
+			PHsum += error;
+
+			// Update the minimum mT value if the new mT is
+			// smaller than the current minimum
+			if(PHsum < PHmin) {
+				PHmin = PHsum;
+			}
+			// Return true if the cumulative value - the current minimum is
+			// greater than the current threshold (in which case we should adapt)
+			return PHsum - PHmin > threshold;
+		}
+		
+		public void initializeAlternateTree() {
+			// Start a new alternate tree, beginning with a learning node
+			alternateTree = tree.newLeafNode();
+			alternateTree.originalNode = this;
+
+			// Set up the blank statistics
+			// Number of instances reaching this node since the alternate tree was started
+			lossExamplesSeen = 0;
+			// Faded squared error (original tree)
+			lossFadedSumOriginal = 0;
+			// Faded squared error (alternate tree)
+			lossFadedSumAlternate = 0;
+			// Number of evaluations of alternate tree
+			lossNumQiTests = 0;
+			// Sum of Qi values
+			lossSumQi = 0;
+			// Number of examples at last test
+			previousWeight = 0;
+
+			// Disable the change detection mechanism bellow this node
+			disableChangeDetection();
+		}
+	}
+	
+	public static class SplitNode extends InnerNode {
+
+		private static final long serialVersionUID = 1L;
+
+		protected InstanceConditionalTest splitTest;
+
+		/**
+		 * Create a new SplitNode
+		 * @param tree 
+		 */
+		public SplitNode(InstanceConditionalTest splitTest, FIMTDD tree) {
+			super(tree);
+			this.splitTest = splitTest;
+		}
+		
+		public long calcByteSize() {
+			long size = super.calcByteSize();
+			size += SizeOf.sizeOf(splitTest);
+			return size;
+		}
+
+		public int instanceChildIndex(Instance inst) {
+			return splitTest.branchForInstance(inst);
+		}
+		
+		public Node descendOneStep(Instance inst) {
+			return children.get(splitTest.branchForInstance(inst));
+		}
+
+		public void describeSubtree(StringBuilder out, int indent) {
+			for (int branch = 0; branch < children.size(); branch++) {
+				Node child = getChild(branch);
+				if (child != null) {
+					StringUtils.appendIndented(out, indent, "if ");
+					out.append(this.splitTest.describeConditionForBranch(branch,
+							tree.getModelContext()));
+					out.append(": ");
+					StringUtils.appendNewline(out);
+					child.describeSubtree(out, indent + 2);
+				}
+			}
+		}
+
+		public double getPrediction(Instance inst) {
+			return children.get(splitTest.branchForInstance(inst)).getPrediction(inst);
+		}
+	}
+
+	public class FIMTDDPerceptron implements Serializable {
+
+		private static final long serialVersionUID = 1L;
+		
+		protected FIMTDD tree;
+		
+		// The Perception weights 
+		protected double[] weightAttribute; 
+
+		// The number of instances contributing to this model
+		protected double instancesSeen = 0;
+
+		public String getPurposeString() {
+			return "A perceptron regressor as specified by Ikonomovska et al. used for FIMTDD";
+		}
+
+		public FIMTDDPerceptron(FIMTDDPerceptron original) {
+			this.tree = original.tree;
+			weightAttribute = original.weightAttribute.clone();
+			instancesSeen = original.instancesSeen / 2;
+		}
+
+		public FIMTDDPerceptron(FIMTDD tree) {
+			this.tree = tree;
+			initializeWeights();
+
+		}
+
+		public long calcByteSize() {
+			return SizeOf.sizeOf(this);
+		}
+		
+		public void initializeWeights() {
+			weightAttribute = new double[tree.getModelContext().numInputAttributes()+1];
+			instancesSeen = 0;
+			for (int j = 0; j < tree.getModelContext().numInputAttributes()+1; j++) {
+				// The last index corresponds to the constant b
+				weightAttribute[j] = 2 * tree.classifierRandom.nextDouble() - 1;
+			}
+			normalizeWeights();
+		}
+		
+		/**
+		 * Update the model using the provided instance
+		 */
+		public void updatePerceptron(Instance inst) {
+
+			// Update attribute statistics
+			instancesSeen += inst.weight();
+
+			// Update weights
+			double learningRatio = 0.0;
+			if (tree.learningRatioConstOption.isSet()) {
+				learningRatio = learningRatioOption.getValue();
+			} else {
+				learningRatio = learningRatioOption.getValue() / (1 + instancesSeen * tree.learningRateDecayFactorOption.getValue());
+			}
+
+			// Loop for compatibility with bagging methods 
+			for (int i = 0; i < (int) inst.weight(); i++) {
+				updateWeights(inst, learningRatio);
+			}
+		
+		}
+
+		public void updateWeights(Instance inst, double learningRatio) {
+			// Compute the normalized instance and the delta
+			double[] normalizedInstance = normalizedInstance(inst); 
+			double normalizedPrediction = prediction(normalizedInstance);
+			double normalizedValue = tree.normalizeTargetValue(inst.classValue());
+			double delta = normalizedValue - normalizedPrediction;
+			for (int i = 0; i < weightAttribute.length; i++) {
+				weightAttribute[i] += delta * learningRatio * normalizedInstance[i];
+			}
+			
+			normalizeWeights();
+		}
+		
+		public void normalizeWeights() {
+			double sum = 0;
+			for (int i = 0; i < this.weightAttribute.length; i++)
+				sum += Math.abs(weightAttribute[i]);
+			for (int i = 0; i < this.weightAttribute.length; i++)
+				weightAttribute[i] /= sum;
+		}
+
+		public double[] normalizedInstance(Instance inst) {
+			// Normalize Instance
+			double[] normalizedInstance = new double[inst.numInputAttributes()+1];
+			for (int j = 0; j < inst.numInputAttributes(); j++) {
+				double mean = tree.sumOfAttrValues.getValue(j) / tree.examplesSeen;
+				double sd = computeSD(tree.sumOfAttrSquares.getValue(j), tree.sumOfAttrValues.getValue(j), tree.examplesSeen);
+				if (inst.inputAttribute(j).isNumeric() && tree.examplesSeen > 1 && sd > 0.0000001)
+					normalizedInstance[j] = (inst.valueInputAttribute(j) - mean) / (sd);
+				else
+					normalizedInstance[j] = 0;
+			}
+			normalizedInstance[inst.numInputAttributes()] = tree.examplesSeen > 1 ? 1 : 0; // Value to be multiplied with the constant factor
+			return normalizedInstance;
+		}
+
+		/**
+		 * Output the prediction made by this perceptron on the given instance
+		 */
+		public double prediction(double[] instanceValues) {
+			double ret = 0;
+			for (int i = 0; i < instanceValues.length; i++)
+				ret += instanceValues[i] * weightAttribute[i];
+			return ret;
+		}
+
+		protected double prediction(Instance inst) {
+			double[] normalizedInstance = normalizedInstance(inst);
+			double normalizedPrediction = prediction(normalizedInstance);
+			return denormalizePrediction(normalizedPrediction);
+		}
+
+		private double denormalizePrediction(double normalizedPrediction) {
+			double mean = tree.sumOfValues / tree.examplesSeen;
+			double sd = computeSD(tree.sumOfSquares, tree.sumOfValues, tree.examplesSeen);
+			if (examplesSeen > 1) 
+				return normalizedPrediction * sd + mean;
+			else
+				return 0.0;
+		}
+		
+		public void getModelDescription(StringBuilder out, int indent) {
+	        StringUtils.appendIndented(out, indent, getClassNameString() + " =");
+			if (getModelContext() != null) {
+				for (int j = 0; j < getModelContext().numAttributes() - 1; j++) {
+					if (getModelContext().attribute(j).isNumeric()) {
+						out.append((j == 0 || weightAttribute[j] < 0) ? " " : " + ");
+		                out.append(String.format("%.4f", weightAttribute[j]));
+		                out.append(" * ");
+		                out.append(getAttributeNameString(j));
+		            }
+		        }
+				out.append(" + " + weightAttribute[getModelContext().numInputAttributes()]);
+			}
+	        StringUtils.appendNewline(out);
+		}
+	}
+
+
+	//endregion ================ CLASSES ================
+
+	//region ================ METHODS ================
+
+	// region --- Regressor methods
+	
+	public String getPurposeString() {
+		return "Implementation of the FIMT-DD tree as described by Ikonomovska et al.";
+	}
+
+	public void resetLearningImpl() {
+		this.treeRoot = null;
+		this.leafNodeCount = 0;
+		this.splitNodeCount = 0;
+		this.maxID = 0;
+		this.examplesSeen = 0;
+		this.sumOfValues = 0.0;
+		this.sumOfSquares = 0.0;
+
+		this.sumOfAttrValues = new DoubleVector();
+		this.sumOfAttrSquares = new DoubleVector();
+	}
+
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	public void getModelDescription(StringBuilder out, int indent) {
+		if (treeRoot != null) treeRoot.describeSubtree(out, indent);
+	}
+
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[]{ 
+				new Measurement("tree size (leaves)", this.leafNodeCount)
+		};
+	}
+
+	@Override
+	public long measureByteSize() {
+		return calcByteSize();
+	}
+	
+	public long calcByteSize() {
+		long size = (long) (SizeOf.sizeOf(this)) + this.treeRoot.calcByteSize();
+		size += (long) (SizeOf.sizeOf(this.sumOfAttrValues)) + (int) (SizeOf.sizeOf(this.sumOfAttrSquares));
+		return size;
+	}
+
+	public Prediction getPredictionForInstance(Instance inst) {
+		return new RegressionPrediction((treeRoot == null) ? 0 : treeRoot.getPrediction(inst));
+	}
+
+	public double normalizeTargetValue(double value) {
+		if (examplesSeen > 1) {
+			double sd = Math.sqrt((sumOfSquares - ((sumOfValues * sumOfValues)/examplesSeen))/examplesSeen);
+			double average = sumOfValues / examplesSeen;
+			if (sd > 0 && examplesSeen > 1)
+				return (value - average) / sd;
+			else
+				return 0.0;
+		}
+		return 0.0;
+	}
+
+	public double getNormalizedError(Instance inst, double prediction) {
+		double normalPrediction = normalizeTargetValue(prediction);
+		double normalValue = normalizeTargetValue(inst.classValue());
+		return Math.abs(normalValue - normalPrediction);
+	}
+
+	
+	public void updateStatistics(Instance inst) {
+		examplesSeen += inst.weight();
+		sumOfValues += inst.weight() * inst.classValue();
+		sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
+
+		for (int i = 0; i < inst.numAttributes() - 1; i++) {
+			int aIndex = modelAttIndexToInstanceAttIndex(i, inst);
+			sumOfAttrValues.addToValue(i, inst.weight() * inst.value(aIndex));
+			sumOfAttrSquares.addToValue(i, inst.weight() * inst.value(aIndex) * inst.value(aIndex));
+		}
+	}
+
+	/**
+	 * Method for updating (training) the model using a new instance
+	 */
+	public void trainOnInstanceImpl(Instance inst) {
+		checkRoot();
+
+		double prediction = treeRoot.getPrediction(inst);
+		double normalError = getNormalizedError(inst, prediction);
+	
+		processInstance(inst, treeRoot, prediction, normalError, true, false);
+		
+		updateStatistics(inst);
+
+	}
+
+	public void processInstance(Instance inst, Node node, double prediction, double normalError, boolean growthAllowed, boolean inAlternate) {
+		Node currentNode = node;
+		while (true) {
+			if (currentNode instanceof LeafNode) {
+				((LeafNode) currentNode).learnFromInstance(inst, growthAllowed, prediction);
+				break;
+			} else {
+				currentNode.examplesSeen += inst.weight();
+				currentNode.sumOfAbsErrors += inst.weight() * normalError;
+				InnerNode iNode = (InnerNode) currentNode;
+				if (!inAlternate && iNode.alternateTree != null) {
+					boolean altTree = true;
+					double lossO = Math.pow(inst.classValue() - prediction, 2);
+					double lossA = Math.pow(inst.classValue() - iNode.alternateTree.getPrediction(inst), 2);
+					
+					// Loop for compatibility with bagging methods
+					for (int i = 0; i < inst.weight(); i++) {
+						iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
+						iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
+						iNode.lossExamplesSeen++;
+						
+						double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
+						iNode.lossSumQi += Qi;
+						iNode.lossNumQiTests += 1;
+					}
+					double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
+					double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+					double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+					
+					if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
+						iNode.previousWeight = iNode.lossExamplesSeen;
+						if (Qi > 0) {
+							// Switch the subtrees
+							Node parent = iNode.getParent();
+
+							System.out.println("Switching trees!");
+							if (parent != null) {
+								Node replacementTree = iNode.alternateTree;
+								parent.setChild(parent.getChildIndex(iNode), replacementTree);
+								if (growthAllowed) replacementTree.restartChangeDetection();
+							} else {
+								treeRoot = iNode.alternateTree;
+								treeRoot.restartChangeDetection();
+							}
+							leafNodeCount += iNode.alternateTree.numLeaves() - iNode.numLeaves();
+
+
+							currentNode = iNode.alternateTree;
+							currentNode.originalNode = null;
+							altTree = false;
+						} else if (QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * alternateTreeTMinOption.getValue()) || iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()) {
+							// Remove the alternate tree
+							iNode.alternateTree = null;
+							if (growthAllowed) iNode.restartChangeDetection();
+							altTree = false;
+						}
+					}
+
+					if (altTree) {
+						growthAllowed = false;
+						processInstance(inst, iNode.alternateTree, prediction, normalError, true, true);
+					}
+				}
+
+				if (iNode.changeDetection && !inAlternate) {
+					if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+						System.out.println("CD triggered!");
+						iNode.initializeAlternateTree();
+						growthAllowed = false;
+					}
+				}
+				if (currentNode instanceof SplitNode) {
+					currentNode = ((SplitNode) currentNode).descendOneStep(inst);
+				} 
+			}
+		}
+	}
+
+	// endregion --- Regressor methods
+	
+	// region --- Object instatiation methods
+
+	protected FIMTDDNumericAttributeClassObserver newNumericClassObserver() {
+		return new FIMTDDNumericAttributeClassObserver();
+	}
+
+	protected SplitNode newSplitNode(InstanceConditionalTest splitTest) {
+		maxID++;
+		return new SplitNode(splitTest, this);
+	}
+
+	protected LeafNode newLeafNode() {
+		maxID++;
+		return new LeafNode(this);
+	}
+
+	protected FIMTDDPerceptron newLeafModel() {
+		return new FIMTDDPerceptron(this);
+	}
+
+	//endregion --- Object instatiation methods
+	
+	// region --- Processing methods
+	
+	public void checkRoot() {
+		if (treeRoot == null) {
+			treeRoot = newLeafNode();
+			leafNodeCount = 1;
+		}
+	}
+
+	public static double computeHoeffdingBound(double range, double confidence, double n) {
+		return Math.sqrt(( (range * range) * Math.log(1 / confidence)) / (2.0 * n));
+	}
+
+	public boolean buildingModelTree() {
+		return !regressionTreeOption.isSet();
+	}
+
+	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex, Instance inst, double prediction) {
+
+		// Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
+ 		SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
+
+		// Using this criterion, find the best split per attribute and rank the results
+		AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion);
+		Arrays.sort(bestSplitSuggestions);
+
+		// Declare a variable to determine if any of the splits should be performed
+		boolean shouldSplit = false;
+
+		// If only one split was returned, use it
+		if (bestSplitSuggestions.length < 2) {
+			shouldSplit = bestSplitSuggestions.length > 0;
+		} else { // Otherwise, consider which of the splits proposed may be worth trying
+
+			// Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
+			// to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
+			double hoeffdingBound = computeHoeffdingBound(1, this.splitConfidenceOption.getValue(), node.examplesSeen);
+			// Determine the top two ranked splitting suggestions
+			AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+			AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
+
+			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
+			// as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
+			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
+			// splitting should occur.
+			// Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
+			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
+			// competing attributes are equally good, and the split will be made on the one with the higher SDR value.
+			if ((secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) || (hoeffdingBound < this.tieThresholdOption.getValue())) {
+				shouldSplit = true;
+			}
+			// If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
+			else {
+				for (int i = 0; i < node.attributeObservers.size(); i++) {
+					FIMTDDNumericAttributeClassObserver obs = node.attributeObservers.get(i);
+					if (obs != null) {
+						obs.removeBadSplits(splitCriterion, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound);    
+					}
+				}
+			}
+		}
+
+		// If the splitting criterion were met, split the current node using the chosen attribute test, and
+		// make two new branches leading to (empty) leaves
+		if (shouldSplit) {
+			AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+						
+			SplitNode newSplit = newSplitNode(splitDecision.splitTest);
+			newSplit.copyStatistics(node);
+			newSplit.changeDetection = node.changeDetection;
+			newSplit.ID = node.ID;
+			leafNodeCount--;
+			for (int i = 0; i < splitDecision.numSplits(); i++) {
+				LeafNode newChild = newLeafNode();
+				if (buildingModelTree()) {
+					// Copy the splitting node's perceptron to it's children
+					newChild.learningModel = new FIMTDDPerceptron((FIMTDDPerceptron) node.learningModel);
+					
+				}
+				newChild.changeDetection = node.changeDetection;
+				newChild.setParent(newSplit);
+				newSplit.setChild(i, newChild);
+				leafNodeCount++;
+			}
+			if (parent == null && node.originalNode == null) {
+				treeRoot = newSplit;
+			} else if (parent == null && node.originalNode != null) {
+				node.originalNode.alternateTree = newSplit;
+			} else {
+				((SplitNode) parent).setChild(parentIndex, newSplit);
+				newSplit.setParent(parent);
+			}
+			
+			splitNodeCount++;
+		}
+	}
+	
+	public double computeSD(double squaredVal, double val, double size) {
+		if (size > 1)
+			return Math.sqrt((squaredVal - ((val * val) / size)) / size);
+		else
+			return 0.0;
+	}
+	
+	public double scalarProduct(DoubleVector u, DoubleVector v) {
+		double ret = 0.0;
+		for (int i = 0; i < Math.max(u.numValues(), v.numValues()); i++) {
+			ret += u.getValue(i) * v.getValue(i);
+		}
+		return ret;
+	}
+	//endregion --- Processing methods
+	
+	//endregion ================ METHODS ================
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/trees/ORTO2.java.orig b/moa/src/main/java/moa/classifiers/trees/ORTO2.java.orig
new file mode 100644
index 000000000..99b0cc910
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/trees/ORTO2.java.orig
@@ -0,0 +1,543 @@
+/*
+ *    ORTO.java
+ *    Copyright (C) 2015 Jožef Stefan Institute, Ljubljana, Slovenia
+ *    @author Aljaž Osojnik <aljaz.osojnik@ijs.si>
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *    
+ *    
+ */
+
+package moa.classifiers.trees;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Stack;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.classifiers.Regressor;
+import moa.classifiers.core.AttributeSplitSuggestion;
+import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
+import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
+import moa.classifiers.core.splitcriteria.SplitCriterion;
+import moa.core.AutoExpandVector;
+import moa.core.Measurement;
+import moa.core.StringUtils;
+<<<<<<< HEAD:moa/src/main/java/moa/classifiers/trees/ORTO2.java
+
+=======
+>>>>>>> 32d534d2e43c28db1711ab2fe7ff580d214e22fe:moa/src/main/java/moa/classifiers/trees/ORTO2.java
+
+/*
+ * Implementation of ORTO, option trees for data streams.
+ */
+
+public class ORTO2 extends FIMTDD2 implements Regressor {
+
+	private static final long serialVersionUID = 1L;
+
+	private int innerNodeCount = 0;
+	private int optionNodeCount = 0;
+
+	private int numTrees = 1;
+
+
+	//region ================ OPTIONS ================
+
+	public IntOption maxTreesOption = new IntOption(
+			"maxTrees",
+			'm',
+			"The maximum number of trees contained in the option tree.",
+			10, 1, Integer.MAX_VALUE);
+
+	public IntOption maxOptionLevelOption = new IntOption(
+			"maxOptionLevel",
+			'x',
+			"The maximal depth at which option nodes can be created.",
+			10, 0, Integer.MAX_VALUE);
+
+	public FloatOption optionDecayFactorOption = new FloatOption(
+			"optionDecayFactor",
+			'z',
+			"The option decay factor that determines how many options can be selected at a given level.",
+			0.9, 0.0, 1.0);
+
+	public MultiChoiceOption optionNodeAggregationOption = new MultiChoiceOption(
+			"optionNodeAggregation",
+			'o',
+			"The aggregation method used to combine predictions in option nodes.", 
+			new String[]{"average", "bestTree"}, new String[]{"Average", "Best tree"}, 0);
+
+	public FloatOption optionFadingFactorOption = new FloatOption(
+			"optionFadingFactor",
+			'q',
+			"The fading factor used for comparing subtrees of an option node.",
+			0.9995, 0.0, 1.0);
+
+	//endregion ================ OPTIONS ================
+
+	//region ================ CLASSES ================
+
+	public static class OptionNode extends InnerNode {
+
+		private static final long serialVersionUID = 1L;
+
+		protected double[] optionFFSSL;
+		protected double[] optionFFSeen;
+
+		public OptionNode(FIMTDD2 tree) {
+			super(tree);
+		}
+		
+		public void resetFF() {
+			optionFFSSL = new double[children.size()];
+			optionFFSeen = new double[children.size()];
+			
+			for (int i = 0; i < children.size(); i++) {
+				optionFFSSL[i] = 0.0;
+				optionFFSeen[i] = 0.0;
+			}
+		}
+
+		public int getNumSubtrees() {
+			int num = 0;
+			for (Node child : children) {
+				num += child.getNumSubtrees();
+			}
+			return num;
+		}
+
+		public int directionForBestTree() {
+			int d = 0;
+			double tmp = 0.0, min = Double.MAX_VALUE;
+			for (int i = 0; i < children.size(); i++) {
+				tmp = getFFRatio(i);
+				if (tmp < min) {
+					min = tmp;
+					d = i;
+				}
+			}
+			return d;
+		}
+
+		public double getPrediction(Instance inst) {
+			double[] predictions = new double[numChildren()];
+			for (int i = 0; i < numChildren(); i++) {
+				predictions[i] = getChild(i).getPrediction(inst);
+			}
+			return aggregate(predictions);
+		}
+
+		private double aggregate(double[] predictions) {
+			if (((ORTO2) tree).optionNodeAggregationOption.getChosenIndex() == 0) { // Average
+				double sum = 0.0;
+				for (int i = 0; i < predictions.length; i++) {
+					sum += predictions[i];
+				}
+				return sum / predictions.length;
+			} else if (((ORTO2) tree).optionNodeAggregationOption.getChosenIndex() == 1) {
+				int d = directionForBestTree();
+				return predictions[d];
+			} else {
+				return 0.0;
+			}
+		}
+
+		public double getFFRatio(int childIndex) {
+			return optionFFSSL[childIndex] / optionFFSeen[childIndex];
+		}
+		
+		protected boolean skipInLevelCount() {
+			return true;
+		}
+		
+		@Override
+		public void describeSubtree(StringBuilder out, int indent) {
+			StringUtils.appendIndented(out, indent, "[option node]");
+			StringUtils.appendNewline(out);
+			for (int childIndex = 0; childIndex < children.size(); childIndex++) {
+				Node split = getChild(childIndex);
+				StringUtils.appendIndented(out, indent, "[" + childIndex + "]");
+				StringUtils.appendNewline(out);
+				split.describeSubtree(out, indent + 2);
+			}
+		}
+<<<<<<< HEAD:moa/src/main/java/moa/classifiers/trees/ORTO2.java
+
+=======
+>>>>>>> 32d534d2e43c28db1711ab2fe7ff580d214e22fe:moa/src/main/java/moa/classifiers/trees/ORTO2.java
+	}
+
+	//endregion ================ CLASSES ================
+
+	//region ================ METHODS ================
+
+	// region --- Regressor methods
+
+	public String getPurposeString() {
+		return "Implementation of the ORTO tree as described by Ikonomovska et al.";
+	}
+
+	public void resetLearningImpl() {
+		super.resetLearningImpl();
+		this.innerNodeCount = 0;
+		this.optionNodeCount = 0;
+	}
+
+	
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[]{ 
+				new Measurement("number of subtrees", this.numTrees),
+				new Measurement("tree size (nodes)", this.leafNodeCount + this.innerNodeCount),
+				new Measurement("tree size (leaves)", this.leafNodeCount),
+				new Measurement("number of option nodes", this.optionNodeCount),};
+	}
+
+	public void processInstance(Instance inst, Node node, double prediction, double normalError, boolean growthAllowed, boolean inAlternate) {
+		if (node instanceof OptionNode) {
+			processInstanceOptionNode(inst, (OptionNode) node, prediction, normalError, growthAllowed, inAlternate);
+		} else {
+			Node currentNode = node;
+			while (true) {
+				if (currentNode instanceof LeafNode) {
+					((LeafNode) currentNode).learnFromInstance(inst, growthAllowed, prediction);
+					break;
+				} else {
+					currentNode.examplesSeen += inst.weight();
+					currentNode.sumOfAbsErrors += inst.weight() * normalError;
+					InnerNode iNode = (InnerNode) currentNode;
+					if (!inAlternate && iNode.alternateTree != null) {
+						boolean altTree = true;
+						double lossO = Math.pow(inst.classValue() - prediction, 2);
+						double lossA = Math.pow(inst.classValue() - iNode.alternateTree.getPrediction(inst), 2);
+						
+						// Loop for compatibility with bagging methods
+						for (int i = 0; i < inst.weight(); i++) {
+							iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
+							iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
+							iNode.lossExamplesSeen++;
+							
+							double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
+							iNode.lossSumQi += Qi;
+							iNode.lossNumQiTests += 1;
+						}
+						double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
+						double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+						double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+						
+						if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
+							iNode.previousWeight = iNode.lossExamplesSeen;
+							if (Qi > 0) {
+								// Switch the subtrees
+								Node parent = iNode.getParent();
+								
+								if (parent != null) {
+									Node replacementTree = iNode.alternateTree;
+									parent.setChild(parent.getChildIndex(iNode), replacementTree);
+									if (growthAllowed) replacementTree.restartChangeDetection();
+								} else {
+									treeRoot = iNode.alternateTree;
+									treeRoot.restartChangeDetection();
+								}
+								optionNodeCount += iNode.alternateTree.getNumSubtrees() - iNode.getNumSubtrees();
+								removeExcessTrees();
+										
+								currentNode = iNode.alternateTree;
+								currentNode.originalNode = null;
+								altTree = false;
+							} else if (QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * alternateTreeTMinOption.getValue()) || iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()) {
+								// Remove the alternate tree
+								iNode.alternateTree = null;
+								if (growthAllowed) iNode.restartChangeDetection();
+								altTree = false;
+							}
+						}
+						if (altTree) {
+							growthAllowed = false; // this is the growth of the original tree
+							processInstance(inst, iNode.alternateTree, prediction, normalError, true, true); // growth is allowed in the alt tree
+						} else if (currentNode instanceof OptionNode) {
+							// this happens when an option node is switched into the tree
+							for (Node child : ((OptionNode) currentNode).children) {
+								processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed, inAlternate);
+							}
+							break;
+						}
+					}
+				
+					if (iNode.changeDetection && !inAlternate) {
+						if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+							iNode.initializeAlternateTree();
+						}
+					}
+					if (currentNode instanceof SplitNode) {
+						currentNode = ((SplitNode) currentNode).descendOneStep(inst);
+					} else if (currentNode instanceof OptionNode) {
+						processInstanceOptionNode(inst, (OptionNode) currentNode, prediction, normalError, growthAllowed, inAlternate);
+						break;
+					}
+				}
+			}
+		}
+		
+	}
+	
+	public void processInstanceOptionNode(Instance inst, OptionNode node, double prediction, double normalError, boolean growthAllowed, boolean inAlternate) {
+		node.examplesSeen += inst.weight();
+		node.sumOfAbsErrors += inst.weight() * normalError;
+<<<<<<< HEAD:moa/src/main/java/moa/classifiers/trees/ORTO2.java
+
+=======
+>>>>>>> 32d534d2e43c28db1711ab2fe7ff580d214e22fe:moa/src/main/java/moa/classifiers/trees/ORTO2.java
+		if (node.changeDetection) {
+			double error = Math.abs(prediction - inst.classValue());
+			node.sumOfAbsErrors += error;
+			
+			if (((InnerNode) node).PageHinckleyTest(error - node.sumOfAbsErrors / node.examplesSeen + PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+				node.initializeAlternateTree();
+				growthAllowed = false;
+			}
+		}
+
+		for (Node child : node.children) {
+			int index = node.getChildIndex(child);
+			double childPrediction = child.getPrediction(inst);
+
+			// Loop for compatibility with bagging methods
+			for (int i = 0; i < inst.weight(); i++) {
+				node.optionFFSeen[index] = node.optionFFSeen[index] * optionFadingFactorOption.getValue() + 1;
+				node.optionFFSSL[index] = node.optionFFSSL[index] * optionFadingFactorOption.getValue() + Math.pow(childPrediction - inst.classValue(), 2);
+			}
+		}
+
+		for (Node child : node.children) {
+			processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed && node.alternateTree == null, inAlternate);
+		}
+	}
+	
+	// endregion --- Regressor methods
+	
+	// region --- Object instantiation methods
+
+	protected OptionNode newOptionNode() {
+		maxID++;
+		return new OptionNode(this);
+	}
+	
+	// endregion --- Object instantiation methods
+
+	// region --- Processing methods
+
+	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex, Instance inst, double prediction) {
+		// Initialize the split criterion 
+		SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(splitCriterionOption);
+
+		// Using this criterion, find the best split per attribute and rank the results
+		AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion);
+		List<AttributeSplitSuggestion> acceptedSplits = new LinkedList<AttributeSplitSuggestion>();
+		Arrays.sort(bestSplitSuggestions);
+
+		// Declare a variable to determine the number of splits to be performed
+		int numSplits = 0;
+
+		// If only one split was returned, use it (this generally shouldn't happen)
+		if (bestSplitSuggestions.length == 1) {
+			numSplits = 1;
+			acceptedSplits.add(bestSplitSuggestions[0]);
+		} else if (bestSplitSuggestions.length > 1) { // Otherwise, consider which of the splits proposed may be worth trying
+
+			// Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
+			// to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
+			double hoeffdingBound = computeHoeffdingBound(1, splitConfidenceOption.getValue(), node.examplesSeen);
+
+			// Determine the top two ranked splitting suggestions
+			AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+			AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
+
+
+			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
+			// as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
+			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
+			// splitting should occur.
+			// Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
+			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
+			// competing attributes are equally good, and the split will be made on the one with the higher SDR value.
+			if (secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) {
+				numSplits = 1;
+				acceptedSplits.add(bestSuggestion);
+			} else if (numTrees < maxTreesOption.getValue() && node.getLevel() <= maxOptionLevelOption.getValue()) {
+				for (int i = 0; i < bestSplitSuggestions.length; i++) {
+					AttributeSplitSuggestion suggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1 - i];
+					if (suggestion.merit / bestSuggestion.merit >= 1 - hoeffdingBound) {
+						numSplits++;
+						acceptedSplits.add(suggestion);
+					} else {
+						break;
+					}
+				}
+			} else if (hoeffdingBound < tieThresholdOption.getValue()) {
+				numSplits = 1;
+				acceptedSplits.add(bestSuggestion);
+			} else { // If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
+				for (int i = 0; i < node.attributeObservers.size(); i++) {
+					AttributeClassObserver obs = node.attributeObservers.get(i);
+					if (obs != null) {
+						((FIMTDDNumericAttributeClassObserver) obs).removeBadSplits(splitCriterion, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound);    
+					}
+				}
+			}
+		}
+
+		// If the splitting criterion was met, split the current node using the chosen attribute test, and
+		// make two new branches leading to (empty) leaves
+		if (numSplits > 0) {
+			double optionFactor = numSplits * Math.pow(optionDecayFactorOption.getValue(), (double) node.getLevel());
+
+			if (numSplits == 1 || optionFactor < 2.0 || maxTreesOption.getValue() - numTrees <= 1) {
+				AttributeSplitSuggestion splitDecision = acceptedSplits.get(0);
+				SplitNode newSplit = newSplitNode(splitDecision.splitTest);
+				for (int i = 0; i < splitDecision.numSplits(); i++) {
+					LeafNode newChild = newLeafNode();
+					newChild.setParent(newSplit);
+					newSplit.setChild(i, newChild);
+				}
+				leafNodeCount--;
+				innerNodeCount++;
+				leafNodeCount += splitDecision.numSplits();
+				if (parent == null && node.originalNode == null) {
+					treeRoot = newSplit;
+				} else if (parent == null && node.originalNode != null) {
+					node.originalNode.alternateTree = newSplit;
+				} else {
+					parent.setChild(parentIndex, newSplit);
+					newSplit.setParent(parent);
+				}
+			} else {
+				OptionNode optionNode = newOptionNode();
+				leafNodeCount--;
+				int j = 0;
+
+				for (AttributeSplitSuggestion splitDecision : acceptedSplits) {
+					if (j > optionFactor || maxTreesOption.getValue() - numTrees <= 0) {
+						break;
+					}
+					SplitNode newSplit = newSplitNode(splitDecision.splitTest);
+					for (int i = 0; i < splitDecision.numSplits(); i++) {
+						LeafNode newChild = newLeafNode();
+						newChild.setParent(newSplit);
+						newSplit.setChild(i, newChild);
+					}
+
+					leafNodeCount += splitDecision.numSplits();
+					innerNodeCount++;
+					numTrees++;
+
+					newSplit.setParent(optionNode);
+					optionNode.setChild(j, newSplit);
+					j++;
+				}
+
+				innerNodeCount++;
+				optionNodeCount++;
+
+				if (parent == null) {
+					treeRoot = optionNode;
+				} else {
+					parent.setChild(parentIndex, optionNode);
+					optionNode.setParent(parent);
+				}
+
+				optionNode.resetFF();
+			}
+		}
+	}
+
+	// endregion --- Processing methods 
+	
+	// region --- Option tree methods
+	protected Node findWorstOption() {
+		Stack<Node> stack = new Stack<Node>();
+		stack.add(treeRoot);
+
+		double ratio = Double.MIN_VALUE;
+		Node out = null;
+
+		while (!stack.empty()) {
+			Node node = stack.pop();
+			if (node.getParent() instanceof OptionNode) {
+				OptionNode myParent = (OptionNode) node.getParent();
+				int nodeIndex = myParent.getChildIndex(node);
+				double nodeRatio = myParent.getFFRatio(nodeIndex); 
+
+				if (nodeRatio > ratio) {
+					ratio = nodeRatio;
+					out = node;
+				}
+			}
+			if (node instanceof InnerNode) {
+				for (Node child : ((InnerNode) node).children) {
+					stack.add(child);
+				}
+			}
+		}
+
+		return out;
+	}
+
+	protected void removeExcessTrees() {
+		while (numTrees > maxTreesOption.getValue()) {
+			Node option = findWorstOption();
+			OptionNode parent = (OptionNode) option.parent;
+			int index = parent.getChildIndex(option);
+
+			if (parent.children.size() == 2) {
+				parent.children.remove(index);
+				for (Node chld : parent.children) {
+					chld.parent = parent.parent;
+					parent.parent.setChild(parent.parent.getChildIndex(parent), chld);
+				}
+			} else {
+				AutoExpandVector<Node> children = new AutoExpandVector<Node>();
+				double[] optionFFSSL = new double[parent.children.size() - 1];
+				double[] optionFFSeen = new double[parent.children.size() - 1];
+
+				int seen = 0;
+
+				for (int i = 0; i < parent.children.size() - 1; i++) {
+					if (parent.getChild(i) != option) {
+						children.add(parent.getChild(i));
+						optionFFSSL[i] = parent.optionFFSSL[i + seen];
+						optionFFSeen[i] = parent.optionFFSeen[i + seen];
+					} else {
+						seen = 1;
+					}
+				}
+
+				parent.children = children;
+				parent.optionFFSSL = optionFFSSL;
+				parent.optionFFSeen = optionFFSeen;
+
+				assert parent.children.size() == parent.optionFFSSL.length;
+			}
+			numTrees--;
+		}
+	}
+	
+	// endregion --- Option tree methods
+	
+	//endregion ================ METHODS ================
+}
diff --git a/moa/src/main/java/moa/clusterers/clustree/ClusTree.java.orig b/moa/src/main/java/moa/clusterers/clustree/ClusTree.java.orig
new file mode 100644
index 000000000..ed142e454
--- /dev/null
+++ b/moa/src/main/java/moa/clusterers/clustree/ClusTree.java.orig
@@ -0,0 +1,891 @@
+/*
+ *    ClusTree.java
+ *    Copyright (C) 2010 RWTH Aachen University, Germany
+ *    @author Sanchez Villaamil (moa@cs.rwth-aachen.de)
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *    
+ *    
+ */
+
+package moa.clusterers.clustree;
+
+import java.util.ArrayList;
+
+import java.util.LinkedList;
+import moa.clusterers.clustree.util.*;
+import moa.cluster.Clustering;
+import moa.clusterers.AbstractClusterer;
+import moa.core.Measurement;
+<<<<<<< Updated upstream
+<<<<<<< HEAD
+=======
+<<<<<<< c4a46917f06a4f4c3c08e67d06f6762cca1b47f9
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.FlagOption;
+import com.yahoo.labs.samoa.instances.Instance;
+=======
+>>>>>>> Instances rework, new iSOUPTree models and import cleanup
+>>>>>>> 32d534d2e43c28db1711ab2fe7ff580d214e22fe
+=======
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.FlagOption;
+import com.yahoo.labs.samoa.instances.Instance;
+>>>>>>> Stashed changes
+
+/**
+ * Citation: ClusTree: Philipp Kranen, Ira Assent, Corinna Baldauf, Thomas Seidl:
+ * The ClusTree: indexing micro-clusters for anytime stream mining.
+ * Knowl. Inf. Syst. 29(2): 249-272 (2011) 
+*/
+public class ClusTree extends AbstractClusterer{
+	private static final long serialVersionUID = 1L;
+	
+	public IntOption horizonOption = new IntOption("horizon",
+			'h', "Range of the window.", 1000);
+
+    public IntOption maxHeightOption = new IntOption(
+			"maxHeight", 'H',
+			"The maximal height of the tree", getDefaultHeight());
+
+	public FlagOption breadthFirstStrategyOption = new FlagOption(
+			"breadthFirstStrategy", 'B',
+			"Use breadth first strategy");
+    
+    public FlagOption breadthFirstStrategyOption = new FlagOption(
+			"breadthFirstStrategy", 'B',
+			"Use breadth first strategy");
+    
+    protected int getDefaultHeight() {
+    	return 8;
+    }
+    
+    private static int INSERTIONS_BETWEEN_CLEANUPS = 10000;
+    /**
+     * The root node of the tree.
+     */
+    protected Node root;
+    // Information about the data represented in this tree.
+    /**
+     * Dimensionality of the data points managed by this tree.
+     */
+    private int numberDimensions;
+    /**
+     * Parameter for the weighting function use to weight the entries.
+     */
+    protected double negLambda;
+    /**
+     * The current height of the tree. Should always be smaller than maxHeight.
+     */
+    private int height;
+    /**
+     * The maximal height of the tree.
+     */
+    protected int maxHeight;
+    /**
+     * This variable is used to keep the inverse height that is stored in every
+     * node correct.
+     */
+    private int numRootSplits;
+    /**
+     * The threshold for the weighting of an Entry. An Entry is irrelevant, if
+     * it is in a leaf and the weightedN of the data Cluster is smaller than
+     * this threshold.
+     * @see Entry#data
+     */
+    private double weightThreshold = 0.05;
+    /**
+     * Number of points inserted into the tree.
+     */
+    private int numberInsertions;
+    private long timestamp;
+
+    /**
+     * Parameter to determine wich strategy to use
+     */
+    protected boolean breadthFirstStrat = false;
+    
+    //TODO: cleanup
+    private Entry alsoUpdate;
+    
+    @Override
+    public void resetLearningImpl() {
+        breadthFirstStrat = breadthFirstStrategyOption.isSet();
+        negLambda = (1.0 / (double) horizonOption.getValue())
+                * (Math.log(weightThreshold) / Math.log(2));
+        maxHeight = maxHeightOption.getValue();
+        numberDimensions = -1;
+        root = null;
+        timestamp = 0;
+        height = 0;
+        numRootSplits = 0;
+        numberInsertions = 0;
+    }
+
+
+    @Override
+    protected Measurement[] getModelMeasurementsImpl() {
+        return null;
+    }
+
+    public boolean isRandomizable() {
+        return false;
+    }
+
+    @Override
+    public void getModelDescription(StringBuilder out, int indent) {
+    }
+
+    public Prediction getPredictionForInstance(Instance inst) {
+        return null;
+    }
+
+    @Override
+    public boolean implementsMicroClusterer() {
+        return true;
+    }
+
+
+
+    @Override
+    public void trainOnInstanceImpl(Instance instance) {
+        timestamp++;
+        
+        //TODO check if instance contains label
+        if(root == null){
+            numberDimensions = instance.numAttributes();
+            root = new Node(numberDimensions, 0);
+        }
+        else{
+            if(numberDimensions!=instance.numAttributes())
+                System.out.println("Wrong dimensionality, expected:"+numberDimensions+ "found:"+instance.numAttributes());
+        }
+
+        ClusKernel newPointAsKernel = new ClusKernel(instance.toDoubleArray(), numberDimensions);
+        insert(newPointAsKernel, new SimpleBudget(1000),timestamp);
+    }
+
+
+    /**
+     * Insert a new point in the <code>Tree</code>. The point should be 
+     * represented as a cluster with a single data point(i.e. N = 1). A
+     * <code>Budget</code> class is also given, which is informed of the number
+     * of operation the tree does, and informs the tree when it does not have
+     * time left and should stop the insertion.
+     * @param newPoint The point to be inserted.
+     * @param budget The budget and statistics recollector for the insertion.
+     * @param timestamp The moment at which this point is inserted.
+     * @see Kernel
+     * @see Budget
+     */
+    public void insert(ClusKernel newPoint, Budget budget, long timestamp) {
+        if (breadthFirstStrat){
+          	insertBreadthFirst(newPoint, budget, timestamp);
+       }
+        else{
+	    	Entry rootEntry = new Entry(this.numberDimensions,
+	                root, timestamp, null, null);
+	        ClusKernel carriedBuffer = new ClusKernel(this.numberDimensions);
+	        Entry toInsertHere = insert(newPoint, carriedBuffer, root, rootEntry,
+	                budget, timestamp);
+	
+	        if (toInsertHere != null) {
+	            this.numRootSplits++;
+	            this.height += this.height < this.maxHeight ? 1 : 0;
+	            
+	            Node newRoot = new Node(this.numberDimensions,
+	                    toInsertHere.getChild().getRawLevel() + 1);
+	            newRoot.addEntry(rootEntry, timestamp);
+	            newRoot.addEntry(toInsertHere, timestamp);
+	            rootEntry.setNode(newRoot);
+	            toInsertHere.setNode(newRoot);
+	            this.root = newRoot;
+	        }
+        }
+
+        this.numberInsertions++;
+        if (this.numberInsertions % INSERTIONS_BETWEEN_CLEANUPS == 0) {
+            cleanUp(this.root, 0);
+        }
+    }
+
+    /**
+     * insert newPoint into the tree using the BreadthFirst strategy, i.e.: insert into
+     * the closest entry in a leaf node.
+     * @param newPoint
+     * @param budget
+     * @param timestamp
+     * @return
+     */
+	private Entry insertBreadthFirst(ClusKernel newPoint, Budget budget, long timestamp) {
+    	//check all leaf nodes and get the one with the closest entry to newPoint
+		Node bestFit = findBestLeafNode(newPoint);
+    	bestFit.makeOlder(timestamp, negLambda);
+    	Entry parent = bestFit.getEntries()[0].getParentEntry(); 	
+    	// Search for an Entry with a weight under the threshold.
+   	    Entry irrelevantEntry = bestFit.getIrrelevantEntry(this.weightThreshold);
+        int numFreeEntries = bestFit.numFreeEntries();
+        Entry newEntry = new Entry(newPoint.getCenter().length,
+    			newPoint, timestamp, parent, bestFit);
+        //if there is space, add it to the node ( doesn't ever occur, since nodes are created with 3 entries) 
+        if (numFreeEntries>0){
+        	bestFit.addEntry(newEntry, timestamp);
+        }
+        //if outdated cluster in this best fitting node, replace it
+         else if (irrelevantEntry != null) {
+	        irrelevantEntry.overwriteOldEntry(newEntry);
+        }
+        //if there is space/outdated cluster on path to top, split. Else merge without split
+        else {
+        	if (existsOutdatedEntryOnPath(bestFit)||!this.hasMaximalSize()){
+	            // We have to split.
+	        	insertHereWithSplit(newEntry, bestFit, timestamp);
+	        }
+        	else {
+	            mergeEntryWithoutSplit(bestFit, newEntry,
+	                    timestamp);
+	        }
+        }
+        //update all nodes on path to top.
+        if (bestFit.getEntries()[0].getParentEntry()!=null)
+        	updateToTop(bestFit.getEntries()[0].getParentEntry().getNode());
+        return null;
+    }
+ /**
+  * This method checks if there is an outdated (or empty) entry on the path from node to root.
+  * It updates the weights of nodes on path and then checks if it is outdated.
+  * @param node
+  * @return true if an outdated/empty entry exists on the path
+  */
+	private boolean existsOutdatedEntryOnPath(Node node) {
+    	if (node == root){
+    		node.makeOlder(timestamp, negLambda);
+    		return node.getIrrelevantEntry(this.weightThreshold)!=null;
+    	}
+    	do{
+    		node = node.getEntries()[0].getParentEntry().getNode();
+    		node.makeOlder(timestamp, negLambda);
+    		for (Entry e : node.getEntries()){
+    			e.recalculateData();
+    		}
+    		if (node.numFreeEntries()>0)
+    			return true;
+    		if (node.getIrrelevantEntry(this.weightThreshold)!=null)
+    			return true;
+    	}while(node.getEntries()[0].getParentEntry()!=null);
+		return false;
+	}
+    
+    /**
+     * recalculates data for all entries, that lie on the path from the root to the 
+     * Entry toUpdate.
+     */
+	private void updateToTop(Node toUpdate) {
+    	while(toUpdate!=null){
+    		for (Entry e: toUpdate.getEntries())
+    			e.recalculateData();
+    		if (toUpdate.getEntries()[0].getParentEntry()==null)
+    			break;
+    		toUpdate=toUpdate.getEntries()[0].getParentEntry().getNode();
+    	}
+	}
+
+	/**
+	 * Method called by insertBreadthFirst.
+	 * @param toInsert
+	 * @param insertNode
+	 * @param timestamp
+	 * @return
+	 */
+	private Entry insertHereWithSplit(Entry toInsert, Node insertNode,
+			long timestamp) {
+		//Handle root split
+   	    if (insertNode.getEntries()[0].getParentEntry()==null){
+   	    	root.makeOlder(timestamp, negLambda);
+   	    	Entry irrelevantEntry = insertNode.getIrrelevantEntry(this.weightThreshold);
+   	        int numFreeEntries = insertNode.numFreeEntries();
+   	        if (irrelevantEntry != null) {
+   		        irrelevantEntry.overwriteOldEntry(toInsert);
+   	        }
+   	        else if (numFreeEntries>0){
+   	        	insertNode.addEntry(toInsert, timestamp);
+   	        }
+   	        else{
+	            this.numRootSplits++;
+	            this.height += this.height < this.maxHeight ? 1 : 0;
+	            Entry oldRootEntry = new Entry(this.numberDimensions,
+	                    root, timestamp, null, null);
+	            Node newRoot = new Node(this.numberDimensions,
+	                    this.height);
+	            Entry newRootEntry = split(toInsert, root, oldRootEntry, timestamp);
+	            newRoot.addEntry(oldRootEntry, timestamp);
+	            newRoot.addEntry(newRootEntry, timestamp);
+	            this.root = newRoot;
+	            for (Entry c : oldRootEntry.getChild().getEntries())
+	            	c.setParentEntry(root.getEntries()[0]);
+	            for (Entry c : newRootEntry.getChild().getEntries())
+	            	c.setParentEntry(root.getEntries()[1]);
+   	        }
+            return null;
+   	    }
+   	    insertNode.makeOlder(timestamp, negLambda);
+    	Entry irrelevantEntry = insertNode.getIrrelevantEntry(this.weightThreshold);
+        int numFreeEntries = insertNode.numFreeEntries();
+        if (irrelevantEntry != null) {
+	        irrelevantEntry.overwriteOldEntry(toInsert);
+        }
+        else if (numFreeEntries>0){
+        	insertNode.addEntry(toInsert, timestamp);
+        }
+        else {
+	            // We have to split.
+	        	Entry parentEntry = insertNode.getEntries()[0].getParentEntry();
+	        	Entry residualEntry = split(toInsert, insertNode, parentEntry, timestamp);
+	        	if (alsoUpdate!=null){
+	        		alsoUpdate = residualEntry;
+	        	}
+	        	Node nodeForResidualEntry = insertNode.getEntries()[0].getParentEntry().getNode();
+	        	//recursive call
+	        	return insertHereWithSplit(residualEntry, nodeForResidualEntry, timestamp);
+	    }
+        
+        //no Split
+        return null;
+	}
+
+
+	// XXX: Document the insertion when the final implementation is done.
+	private Entry insertHere(Entry newEntry, Node currentNode,
+	        Entry parentEntry, ClusKernel carriedBuffer, Budget budget,
+	        long timestamp) {
+	
+	    int numFreeEntries = currentNode.numFreeEntries();
+	
+	    // Insert the buffer that we carry.
+	    if (!carriedBuffer.isEmpty()) {
+	        Entry bufferEntry = new Entry(this.numberDimensions,
+	                carriedBuffer, timestamp, parentEntry, currentNode);
+	
+	        if (numFreeEntries <= 1) {
+	            // Distance from buffer to entries.
+	            Entry nearestEntryToCarriedBuffer =
+	                    currentNode.nearestEntry(newEntry);
+	            double distanceNearestEntryToBuffer =
+	                    nearestEntryToCarriedBuffer.calcDistance(newEntry);
+	
+	            // Distance between buffer and point to insert.
+	            double distanceBufferNewEntry =
+	                    newEntry.calcDistance(carriedBuffer);
+	
+	            // Best distance between Entrys in the Node.
+	            BestMergeInNode bestMergeInNode =
+	                    calculateBestMergeInNode(currentNode);
+	
+	            // See what the minimal distance is and do the correspoding
+	            // action.
+	            if (distanceNearestEntryToBuffer <= distanceBufferNewEntry
+	                    && distanceNearestEntryToBuffer <= bestMergeInNode.distance) {
+	                // Aggregate buffer entry to nearest entry in node.
+	                nearestEntryToCarriedBuffer.aggregateEntry(bufferEntry,
+	                        timestamp, this.negLambda);
+	            } else if (distanceBufferNewEntry <= distanceNearestEntryToBuffer
+	                    && distanceBufferNewEntry <= bestMergeInNode.distance) {
+	                newEntry.mergeWith(bufferEntry);
+	            } else {
+	                currentNode.mergeEntries(bestMergeInNode.entryPos1,
+	                        bestMergeInNode.entryPos2);
+	                currentNode.addEntry(bufferEntry, timestamp);
+	            }
+	
+	        } else {
+	            assert (currentNode.isLeaf());
+	            currentNode.addEntry(bufferEntry, timestamp);
+	        }
+	    }
+	
+	    // Normally the insertion of the carries buffer does not change the
+	    // number of free entries, but in case of future changes we calculate
+	    // the number again.
+	    numFreeEntries = currentNode.numFreeEntries();
+	
+	    // Search for an Entry with a weight under the threshold.
+	    Entry irrelevantEntry = currentNode.getIrrelevantEntry(this.weightThreshold);
+	    if (currentNode.isLeaf() && irrelevantEntry != null) {
+	        irrelevantEntry.overwriteOldEntry(newEntry);
+	    } else if (numFreeEntries >= 1) {
+	        currentNode.addEntry(newEntry, timestamp);
+	    } else {
+	        if (currentNode.isLeaf() && (this.hasMaximalSize()
+	                || !budget.hasMoreTime())) {
+	            mergeEntryWithoutSplit(currentNode, newEntry,
+	                    timestamp);
+	        } else {
+	            // We have to split.
+	            return split(newEntry, currentNode, parentEntry, timestamp);
+	        }
+	    }
+	
+	    return null;
+	}
+
+	/**
+	 * This method calculates the distances between the new point and each Entry in a leaf node.
+	 * It returns the node that contains the entry with the smallest distance
+	 * to the new point.
+	 * @param newPoint
+	 * @return best fitting node
+	 */
+	private Node findBestLeafNode(ClusKernel newPoint) {
+    	double minDist = Double.MAX_VALUE;
+    	Node bestFit = null;
+    	for (Node e: collectLeafNodes(root)){
+    		if (newPoint.calcDistance(e.nearestEntry(newPoint).getData())<minDist){
+    			bestFit = e;
+    			minDist = newPoint.calcDistance(e.nearestEntry(newPoint).getData());
+    		}
+    	}
+    	if (bestFit!=null)
+    		return bestFit;
+    	else
+    		return root;
+	}
+    
+    private ArrayList<Node> collectLeafNodes(Node curr){
+    	ArrayList<Node> toReturn = new ArrayList<Node>();
+    	if (curr==null)
+    		return toReturn;
+    	if	(curr.isLeaf()){
+    		toReturn.add(curr);
+    		return toReturn;
+    	}
+    	else{
+    		for (Entry e : curr.getEntries())
+    			toReturn.addAll(collectLeafNodes(e.getChild()));
+    		return toReturn;
+    	}
+    }
+
+	// TODO: Expand all function that work on entries to work with the Budget.
+    private Entry insert(ClusKernel pointToInsert, ClusKernel carriedBuffer,
+            Node currentNode, Entry parentEntry, Budget budget, long timestamp) {
+        assert (currentNode != null);
+        assert (currentNode.isLeaf()
+                || currentNode.getEntries()[0].getChild() != null);
+
+        currentNode.makeOlder(timestamp, this.negLambda);
+
+        // This variable will be changed from to null to an actual reference
+        // in the following if-else block if we have to insert something here,
+        // either because this is a leaf, or because of split propagation.
+        Entry toInsertHere = null;
+
+        if (currentNode.isLeaf()) {
+            // At the end of the function the entry will be inserted.
+            toInsertHere = new Entry(this.numberDimensions,
+                    pointToInsert, timestamp, parentEntry, currentNode);
+        } else {
+
+            Entry bestEntry = currentNode.nearestEntry(pointToInsert);
+            bestEntry.aggregateCluster(pointToInsert, timestamp,
+                    this.negLambda);
+
+            boolean isCarriedBufferEmpty = carriedBuffer.isEmpty();
+
+            Entry bestBufferEntry = null;
+            if (!isCarriedBufferEmpty) {
+                bestBufferEntry = currentNode.nearestEntry(carriedBuffer);
+                bestBufferEntry.aggregateCluster(carriedBuffer, timestamp,
+                        this.negLambda);
+            }
+
+            if (!budget.hasMoreTime()) {
+                bestEntry.aggregateToBuffer(pointToInsert, timestamp,
+                        this.negLambda);
+                if (!isCarriedBufferEmpty) {
+                    bestBufferEntry.aggregateToBuffer(carriedBuffer,
+                            timestamp, this.negLambda);
+                }
+                return null;
+            }
+
+            // If the way of the buffer differs from the way of the point to
+            // be inserted, leave the buffer here.
+            if (!isCarriedBufferEmpty && (bestEntry != bestBufferEntry)) {
+                bestBufferEntry.aggregateToBuffer(carriedBuffer, timestamp,
+                        this.negLambda);
+                carriedBuffer.clear();
+            }
+            // Take the buffer of the best entry for the point to be inserted
+            // along.
+            ClusKernel takeAlongBuffer = bestEntry.emptyBuffer(timestamp,
+                    this.negLambda);
+            carriedBuffer.add(takeAlongBuffer);
+
+            // Recursive call.
+            toInsertHere = insert(pointToInsert, carriedBuffer,
+                    bestEntry.getChild(), bestEntry, budget, timestamp);
+        }
+
+        // If the above block has a new Entry for this place insert it.
+        if (toInsertHere != null) {
+            return this.insertHere(toInsertHere, currentNode, parentEntry,
+                    carriedBuffer, budget, timestamp);
+        }
+
+        // If nothing else needs to be done in all the above levels
+        // return null to signalize it.
+        return null;
+    }
+
+    /**
+     * Inserts an <code>Entry</code> into a <code>Node</code> without inducing
+     * a split.
+     * @param node The node at which the entry is to be inserted.
+     * @param newEntry The entry to be inserted.
+     * @param timestamp The moment at which this occurs.
+     */
+    private void mergeEntryWithoutSplit(Node node,
+            Entry newEntry, long timestamp) {
+
+        Entry nearestEntryToCarriedBuffer =
+                node.nearestEntry(newEntry);
+        double distanceNearestEntryToBuffer =
+                nearestEntryToCarriedBuffer.calcDistance(newEntry);
+
+        BestMergeInNode bestMergeInNode =
+                calculateBestMergeInNode(node);
+
+        if (distanceNearestEntryToBuffer < bestMergeInNode.distance) {
+            nearestEntryToCarriedBuffer.aggregateEntry(newEntry, timestamp,
+                    this.negLambda);
+        } else {
+            node.mergeEntries(bestMergeInNode.entryPos1,
+                    bestMergeInNode.entryPos2);
+            node.addEntry(newEntry, timestamp);
+        }
+    }
+
+    /**
+     * Calculates the best merge possible between two nodes in a node. This
+     * means that the pair with the smallest distance is found.
+     * @param node The node in which these two entries have to be found.
+     * @return An object which encodes the two position of the entries with the
+     * smallest distance in the node and the distance between them.
+     * @see BestMergeInNode
+     * @see Entry#calcDistance(tree.Entry) 
+     */
+    private BestMergeInNode calculateBestMergeInNode(Node node) {
+        assert (node.numFreeEntries() == 0);
+
+        Entry[] entries = node.getEntries();
+
+        int toMerge1 = -1;
+        int toMerge2 = -1;
+        double distanceBetweenMergeEntries = Double.NaN;
+
+        double minDistance = Double.MAX_VALUE;
+        for (int i = 0; i < entries.length; i++) {
+            Entry e1 = entries[i];
+            for (int j = i + 1; j < entries.length; j++) {
+                Entry e2 = entries[j];
+                double distance = e1.calcDistance(e2);
+                if (distance < minDistance) {
+                    toMerge1 = i;
+                    toMerge2 = j;
+                    distanceBetweenMergeEntries = distance;
+                }
+            }
+        }
+
+        assert (toMerge1 != -1 && toMerge2 != -1);
+        if (Double.isNaN(distanceBetweenMergeEntries)) {
+            throw new RuntimeException("The minimal distance between two "
+                    + "Entrys in a Node was Double.MAX_VAUE. That can hardly "
+                    + "be right.");
+        }
+
+        return new BestMergeInNode(toMerge1, toMerge2,
+                distanceBetweenMergeEntries);
+    }
+
+    private boolean hasMaximalSize() {
+        // TODO: Improve hasMaximalSize(). For now it just works somehow for testing.
+        return this.height == this.maxHeight;
+    }
+
+    /**
+     * Performs a (2,2) split on the given node with the given entry. This
+     * implementation only works if the nodes have three entries each. The split
+     * will generate two new nodes. One of them will be put where the old node
+     * was, and for the other a new <code>Entry</code> will be generated and
+     * returned.
+     * @param newEntry The entry to be added to the node.
+     * @param node The node that is going to be splitted.
+     * @param parentEntry The entry in the tree that points at the node that
+     * is going to be splitted.
+     * @param timestamp The moment at which this split occurs.
+     * @return An entry which points at the second node created in the split.
+     * This entry has to be introduced later in the tree.
+     */
+    private Entry split(Entry newEntry, Node node, Entry parentEntry,
+            long timestamp) {
+        // The implemented split function only works in trees where node
+        // have three entries.
+        // Splitting only makes sense on full nodes.
+        assert (node.numFreeEntries() == 0);
+        assert (parentEntry.getChild() == node);
+
+        // All the entries we have to separate in two nodes.
+        Entry[] allEntries = new Entry[4];
+        Entry[] nodeEntries = node.getEntries();
+        for (int i = 0; i < nodeEntries.length; i++) {
+            allEntries[i] = new Entry(nodeEntries[i]);
+        }
+        allEntries[3] = newEntry;
+
+        // Clear the given node, since we are going to refill it later.
+        node = new Node(this.numberDimensions, node.getRawLevel());
+
+        // Calculate the distance of all the possible pairings, since we want
+        // to do a (2,2) split.
+        double select01 = allEntries[0].calcDistance(allEntries[1])
+                + allEntries[2].calcDistance(allEntries[3]);
+
+        double select02 = allEntries[0].calcDistance(allEntries[2])
+                + allEntries[1].calcDistance(allEntries[3]);
+
+        double select03 = allEntries[0].calcDistance(allEntries[3])
+                + allEntries[1].calcDistance(allEntries[2]);
+
+        // See which of the pairings is minimal and distribute the entries
+        // accordingly.
+        Node residualNode = new Node(this.numberDimensions,
+                node.getRawLevel());
+        if (select01 < select02) {
+            if (select01 < select03) {//select01 smallest
+                node.addEntry(allEntries[0], timestamp);
+                node.addEntry(allEntries[1], timestamp);
+                residualNode.addEntry(allEntries[2], timestamp);
+                residualNode.addEntry(allEntries[3], timestamp);
+            } else {//select03 smallest
+                node.addEntry(allEntries[0], timestamp);
+                node.addEntry(allEntries[3], timestamp);
+                residualNode.addEntry(allEntries[1], timestamp);
+                residualNode.addEntry(allEntries[2], timestamp);
+            }
+        } else {
+            if (select02 < select03) {//select02 smallest
+                node.addEntry(allEntries[0], timestamp);
+                node.addEntry(allEntries[2], timestamp);
+                residualNode.addEntry(allEntries[1], timestamp);
+                residualNode.addEntry(allEntries[3], timestamp);
+            } else {//select03 smallest
+                node.addEntry(allEntries[0], timestamp);
+                node.addEntry(allEntries[3], timestamp);
+                residualNode.addEntry(allEntries[1], timestamp);
+                residualNode.addEntry(allEntries[2], timestamp);
+            }
+        }
+
+        // Set the other node into the tree.
+        parentEntry.setChild(node);
+        parentEntry.recalculateData();
+        int count = 0;
+        for (Entry e : node.getEntries()){
+        	e.setParentEntry(parentEntry);
+        	if (e.getData().getN() != 0)
+        		count++;
+        }
+        //System.out.println(count);
+        // Generate a new entry for the residual node.
+        Entry residualEntry = new Entry(this.numberDimensions,
+                residualNode, timestamp, parentEntry, node);
+        count=0;
+        for (Entry e: residualNode.getEntries()){
+        	e.setParentEntry(residualEntry);
+        	if (e.getData().getN() != 0)
+        		count++;
+        }
+        //System.out.println(count);
+        return residualEntry;
+    }
+
+    /**
+     * Return the number of time the tree has grown in size. If the tree grows
+     * and is then cutted from a certain depth, it also counts.
+     * @return The number of times the root node was splitted.
+     */
+    public int getNumRootSplits() {
+        return numRootSplits;
+    }
+
+    /**
+     * Return the current height of the tree. This should never be greater than
+     * <code>maxHeight</code>.
+     * @return The height of the tree.
+     * @see #maxHeight
+     */
+    public int getHeight() {
+        assert (height <= maxHeight);
+        return height;
+    }
+
+    private void cleanUp(Node currentNode, int level) {
+        if (currentNode == null) {
+            return;
+        }
+
+        Entry[] entries = currentNode.getEntries();
+        if (level == this.maxHeight) {
+            for (int i = 0; i < entries.length; i++) {
+                Entry e = entries[i];
+                e.setChild(null);
+            }
+        } else {
+            for (int i = 0; i < entries.length; i++) {
+                Entry e = entries[i];
+                cleanUp(e.getChild(), level + 1);
+            }
+        }
+    }
+
+    /**
+     * @param currentTime The current time
+     * @return The kernels at the leaf level as a clustering
+     */
+    //TODO: Microcluster unter dem Threshhold nich zur�ckgeben (WIe bei outdated entries)
+    @Override
+    public Clustering getMicroClusteringResult() {
+        return getClustering(timestamp, -1);
+    }
+
+    @Override
+    public Clustering getClusteringResult() {
+        return null;
+    }
+
+
+    /**
+     * @param currentTime The current time
+     * @return The kernels at the given level as a clustering.
+     */
+    public Clustering getClustering(long currentTime, int targetLevel) {
+        if (root == null) {
+            return null;
+        }
+
+        Clustering clusters = new Clustering();
+        LinkedList<Node> queue = new LinkedList<Node>();
+        queue.add(root);
+
+        while (!queue.isEmpty()) {
+            Node current = queue.remove();
+           // if (current == null)
+           // 	continue;
+            int currentLevel = current.getLevel(this);
+            boolean isLeaf = (current.isLeaf() && currentLevel <= maxHeight)
+                    || currentLevel == maxHeight;
+
+            if (currentLevel == targetLevel
+                    || (targetLevel == - 1 && isLeaf)) {
+                assert (currentLevel <= maxHeight);
+
+                Entry[] entries = current.getEntries();
+                for (int i = 0; i < entries.length; i++) {
+                    Entry entry = entries[i];
+                    if (entry == null || entry.isEmpty()) {
+                        continue;
+                    }
+                    // XXX
+                    entry.makeOlder(currentTime, this.negLambda);
+                    if (entry.isIrrelevant(this.weightThreshold))
+                    	continue;
+
+                    ClusKernel gaussKernel = new ClusKernel(entry.getData());
+
+//                  long diff = currentTime - entry.getTimestamp();
+//                    if (diff > 0) {
+//                        gaussKernel.makeOlder(diff, negLambda);
+//                    }
+
+                    clusters.add(gaussKernel);
+                }
+            } else if (!current.isLeaf()) {
+                Entry[] entries = current.getEntries();
+                for (int i = 0; i < entries.length; i++) {
+                    Entry entry = entries[i];
+
+                    if (entry.isEmpty()) {
+                        continue;
+                    }
+
+                    if (entry.isIrrelevant(weightThreshold)) {
+                        continue;
+                    }
+
+                    queue.add(entry.getChild());
+                }
+            }
+        }
+
+        return clusters;
+    }
+
+
+
+    /**************************************************************************
+     * LOCAL CLASSES
+     **************************************************************************/
+    /**
+     * A class to code the return value of searching the smallest merge in a
+     * node.
+     */
+    class BestMergeInNode {
+
+        /**
+         * The position of the first entry in the array of the node.
+         */
+        public int entryPos1;
+        /**
+         * The position of the second entry in the array of the node.
+         */
+        public int entryPos2;
+        /**
+         * The distance between the two entries.
+         */
+        public double distance;
+
+        /**
+         * The constructor of this return value. It will automatically make
+         * sure that the first position is the smaller one of the two.
+         * @param pos1 One of the position.
+         * @param pos2 One of the position.
+         * @param distance The distance between the entries at these positions.
+         */
+        public BestMergeInNode(int pos1, int pos2,
+                double distance) {
+            assert (pos1 != pos2);
+
+            this.distance = distance;
+
+            if (pos1 < pos2) {
+                this.entryPos1 = pos1;
+                this.entryPos2 = pos2;
+            } else {
+                this.entryPos1 = pos2;
+                this.entryPos2 = pos1;
+            }
+        }
+    }
+
+}
diff --git a/moa/src/main/java/moa/learners/InstanceLearner.java b/moa/src/main/java/moa/learners/InstanceLearner.java
new file mode 100644
index 000000000..5a57e8163
--- /dev/null
+++ b/moa/src/main/java/moa/learners/InstanceLearner.java
@@ -0,0 +1,56 @@
+/*
+ *    Learner.java
+ *    Copyright (C) 2011 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 2 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program; if not, write to the Free Software
+ *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+package moa.learners;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Example;
+
+/**
+ * Learner interface for incremental learning models. 
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public interface InstanceLearner extends Learner<Example<Instance>> {
+
+
+        /**
+     * Trains this learner incrementally using the given example.
+     *
+     * @param inst the instance to be used for training
+     */
+    public void trainOnInstance(Instance example);
+
+    /**
+     * Predicts the class memberships for a given instance. If
+     * an instance is unclassified, the returned array elements
+     * must be all zero.
+     *
+     * @param inst the instance to be classified
+     * @return an array containing the estimated membership
+     * probabilities of the test instance in each class
+     */
+	public Prediction getPredictionForInstance(Instance testInst);
+}
+
+
+
diff --git a/moa/src/main/java/moa/tasks/ClassificationMainTask.java b/moa/src/main/java/moa/tasks/ClassificationMainTask.java
new file mode 100644
index 000000000..86339d21f
--- /dev/null
+++ b/moa/src/main/java/moa/tasks/ClassificationMainTask.java
@@ -0,0 +1,5 @@
+package moa.tasks;
+
+public interface ClassificationMainTask extends MainTaskInterface {
+
+}
diff --git a/moa/src/main/java/moa/tasks/EvaluateInterleavedTestThenTrain.java b/moa/src/main/java/moa/tasks/EvaluateInterleavedTestThenTrain.java
deleted file mode 100644
index 46f6ca2c2..000000000
--- a/moa/src/main/java/moa/tasks/EvaluateInterleavedTestThenTrain.java
+++ /dev/null
@@ -1,218 +0,0 @@
-/*
- *    EvaluateInterleavedTestThenTrain.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.tasks;
-
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.PrintStream;
-
-import com.github.javacliparser.FileOption;
-import com.github.javacliparser.IntOption;
-
-import moa.core.Example;
-import moa.core.Measurement;
-import moa.core.ObjectRepository;
-import moa.core.TimingUtils;
-import moa.evaluation.LearningCurve;
-import moa.evaluation.LearningEvaluation;
-import moa.evaluation.LearningPerformanceEvaluator;
-import moa.learners.Learner;
-import moa.options.ClassOption;
-import moa.streams.ExampleStream;
-import moa.streams.InstanceStream;
-
-/**
- * Task for evaluating a classifier on a stream by testing then training with each example in sequence.
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $
- */
-public class EvaluateInterleavedTestThenTrain extends MainTask {
-
-    @Override
-    public String getPurposeString() {
-        return "Evaluates a classifier on a stream by testing then training with each example in sequence.";
-    }
-
-    private static final long serialVersionUID = 1L;
-
-     public ClassOption learnerOption = new ClassOption("learner", 'l',
-            "Learner to train.", Learner.class, "moa.classifiers.bayes.NaiveBayes");
-
-    public ClassOption streamOption = new ClassOption("stream", 's',
-            "Stream to learn from.", ExampleStream.class,
-            "generators.RandomTreeGenerator");
-
-    public IntOption randomSeedOption = new IntOption(
-            "instanceRandomSeed", 'r',
-            "Seed for random generation of instances.", 1);
-
-    public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
-            "Classification performance evaluation method.",
-            LearningPerformanceEvaluator.class,
-            "BasicClassificationPerformanceEvaluator");
-
-    public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
-            "Maximum number of instances to test/train on  (-1 = no limit).",
-            100000000, -1, Integer.MAX_VALUE);
-
-    public IntOption timeLimitOption = new IntOption("timeLimit", 't',
-            "Maximum number of seconds to test/train for (-1 = no limit).", -1,
-            -1, Integer.MAX_VALUE);
-
-    public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
-            'f',
-            "How many instances between samples of the learning performance.",
-            100000, 0, Integer.MAX_VALUE);
-
-    public IntOption memCheckFrequencyOption = new IntOption(
-            "memCheckFrequency", 'q',
-            "How many instances between memory bound checks.", 100000, 0,
-            Integer.MAX_VALUE);
-
-    public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
-            "File to append intermediate csv reslts to.", null, "csv", true);
-
-    @Override
-    public Class<?> getTaskResultType() {
-        return LearningCurve.class;
-    }
-
-    @Override
-    protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
-
-        String learnerString = this.learnerOption.getValueAsCLIString();
-        String streamString = this.streamOption.getValueAsCLIString();
-        //this.learnerOption.setValueViaCLIString(this.learnerOption.getValueAsCLIString() + " -r " +this.randomSeedOption);
-       // this.streamOption.setValueViaCLIString(streamString + " -i " + this.randomSeedOption.getValueAsCLIString());
-        
-        Learner learner = (Learner) getPreparedClassOption(this.learnerOption);
-        if (learner.isRandomizable()) {
-            learner.setRandomSeed(this.randomSeedOption.getValue());
-            learner.resetLearning();
-        }
-        ExampleStream stream = (InstanceStream) getPreparedClassOption(this.streamOption);
-        
-        LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
-        learner.setModelContext(stream.getHeader());
-        int maxInstances = this.instanceLimitOption.getValue();
-        long instancesProcessed = 0;
-        int maxSeconds = this.timeLimitOption.getValue();
-        int secondsElapsed = 0;
-        monitor.setCurrentActivity("Evaluating learner...", -1.0);
-        LearningCurve learningCurve = new LearningCurve(
-                "learning evaluation instances");
-        File dumpFile = this.dumpFileOption.getFile();
-        PrintStream immediateResultStream = null;
-        if (dumpFile != null) {
-            try {
-                if (dumpFile.exists()) {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile, true), true);
-                } else {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile), true);
-                }
-            } catch (Exception ex) {
-                throw new RuntimeException(
-                        "Unable to open immediate result file: " + dumpFile, ex);
-            }
-        }
-        boolean firstDump = true;
-        boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
-        long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-        long lastEvaluateStartTime = evaluateStartTime;
-        double RAMHours = 0.0;
-        while (stream.hasMoreInstances()
-                && ((maxInstances < 0) || (instancesProcessed < maxInstances))
-                && ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
-            Example trainInst = stream.nextInstance();
-            Example testInst = trainInst; //.copy();
-            //int trueClass = (int) trainInst.classValue();
-            //testInst.setClassMissing();
-            double[] prediction = learner.getVotesForInstance(testInst);
-            //evaluator.addClassificationAttempt(trueClass, prediction, testInst
-            //		.weight());
-            evaluator.addResult(testInst, prediction);
-            learner.trainOnInstance(trainInst);
-            instancesProcessed++;
-            if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0
-                  ||  stream.hasMoreInstances() == false) {
-                long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-                double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);
-                double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);
-                double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); //GBs
-                RAMHoursIncrement *= (timeIncrement / 3600.0); //Hours
-                RAMHours += RAMHoursIncrement;
-                lastEvaluateStartTime = evaluateTime;
-                learningCurve.insertEntry(new LearningEvaluation(
-                        new Measurement[]{
-                            new Measurement(
-                            "learning evaluation instances",
-                            instancesProcessed),
-                            new Measurement(
-                            "evaluation time ("
-                            + (preciseCPUTiming ? "cpu "
-                            : "") + "seconds)",
-                            time),
-                            new Measurement(
-                            "model cost (RAM-Hours)",
-                            RAMHours)
-                        },
-                        evaluator, learner));
-                if (immediateResultStream != null) {
-                    if (firstDump) {
-                        immediateResultStream.print("Learner,stream,randomSeed,");
-                        immediateResultStream.println(learningCurve.headerToString());
-                        firstDump = false;
-                    }
-                    immediateResultStream.print(learnerString + "," + streamString + "," + this.randomSeedOption.getValueAsCLIString() + ",");
-                    immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
-                    immediateResultStream.flush();
-                }
-            }
-            if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
-                if (monitor.taskShouldAbort()) {
-                    return null;
-                }
-                long estimatedRemainingInstances = stream.estimatedRemainingInstances();
-                if (maxInstances > 0) {
-                    long maxRemaining = maxInstances - instancesProcessed;
-                    if ((estimatedRemainingInstances < 0)
-                            || (maxRemaining < estimatedRemainingInstances)) {
-                        estimatedRemainingInstances = maxRemaining;
-                    }
-                }
-                monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
-                        : (double) instancesProcessed
-                        / (double) (instancesProcessed + estimatedRemainingInstances));
-                if (monitor.resultPreviewRequested()) {
-                    monitor.setLatestResultPreview(learningCurve.copy());
-                }
-                secondsElapsed = (int) TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread()
-                        - evaluateStartTime);
-            }
-        }
-        if (immediateResultStream != null) {
-            immediateResultStream.close();
-        }
-        return learningCurve;
-    }
-}
diff --git a/moa/src/main/java/moa/tasks/EvaluatePeriodicHeldOutTest.java.orig b/moa/src/main/java/moa/tasks/EvaluatePeriodicHeldOutTest.java.orig
new file mode 100644
index 000000000..a9f314477
--- /dev/null
+++ b/moa/src/main/java/moa/tasks/EvaluatePeriodicHeldOutTest.java.orig
@@ -0,0 +1,308 @@
+/*
+ *    EvaluatePeriodicHeldOutTest.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *    @author Ammar Shaker (shaker@mathematik.uni-marburg.de)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *    
+ */
+package moa.tasks;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.PrintStream;
+import java.util.ArrayList;
+import java.util.List;
+import com.github.javacliparser.FileOption;
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
+<<<<<<< Updated upstream
+<<<<<<< HEAD
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
+=======
+<<<<<<< c4a46917f06a4f4c3c08e67d06f6762cca1b47f9
+import moa.classifiers.Classifier;
+=======
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
+>>>>>>> Instances rework, new iSOUPTree models and import cleanup
+>>>>>>> 32d534d2e43c28db1711ab2fe7ff580d214e22fe
+=======
+import moa.classifiers.Classifier;
+>>>>>>> Stashed changes
+import moa.core.Example;
+import moa.core.Measurement;
+import moa.core.ObjectRepository;
+import moa.core.StringUtils;
+import moa.core.TimingUtils;
+import moa.evaluation.LearningCurve;
+import moa.evaluation.LearningEvaluation;
+import moa.evaluation.LearningPerformanceEvaluator;
+import moa.learners.Learner;
+import moa.options.ClassOption;
+import moa.streams.CachedInstancesStream;
+import moa.streams.ExampleStream;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstanceHeader;
+
+/**
+ * Task for evaluating a classifier on a stream by periodically testing on a heldout set.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public class EvaluatePeriodicHeldOutTest extends MainTask {
+
+    @Override
+    public String getPurposeString() {
+        return "Evaluates a classifier on a stream by periodically testing on a heldout set.";
+    }
+
+    private static final long serialVersionUID = 1L;
+
+    public ClassOption learnerOption = new ClassOption("learner", 'l',
+            "Classifier to train.", Classifier.class, "moa.classifiers.trees.HoeffdingTree");
+
+    public ClassOption streamOption = new ClassOption("stream", 's',
+            "Stream to learn from.", ExampleStream.class,
+            "generators.RandomTreeGenerator");
+
+    public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
+            "Learning performance evaluation method.",
+            LearningPerformanceEvaluator.class,
+            "BasicClassificationPerformanceEvaluator");
+
+    public IntOption testSizeOption = new IntOption("testSize", 'n',
+            "Number of testing examples.", 1000000, 0, Integer.MAX_VALUE);
+
+    public IntOption trainSizeOption = new IntOption("trainSize", 'i',
+            "Number of training examples, <1 = unlimited.", 0, 0,
+            Integer.MAX_VALUE);
+
+    public IntOption trainTimeOption = new IntOption("trainTime", 't',
+            "Number of training seconds.", 10 * 60 * 60, 0, Integer.MAX_VALUE);
+
+    public IntOption sampleFrequencyOption = new IntOption(
+            "sampleFrequency",
+            'f',
+            "Number of training examples between samples of learning performance.",
+            100000, 0, Integer.MAX_VALUE);
+
+    public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
+            "File to append intermediate csv results to.", null, "csv", true);
+
+    public FlagOption cacheTestOption = new FlagOption("cacheTest", 'c',
+            "Cache test instances in memory.");
+
+    @Override
+    protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
+        Learner learner = (Learner) getPreparedClassOption(this.learnerOption);
+        ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
+        LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
+        learner.setModelContext(stream.getHeader());
+        long instancesProcessed = 0;
+        LearningCurve learningCurve = new LearningCurve("evaluation instances");
+        File dumpFile = this.dumpFileOption.getFile();
+        PrintStream immediateResultStream = null;
+        if (dumpFile != null) {
+            try {
+                if (dumpFile.exists()) {
+                    immediateResultStream = new PrintStream(
+                            new FileOutputStream(dumpFile, true), true);
+                } else {
+                    immediateResultStream = new PrintStream(
+                            new FileOutputStream(dumpFile), true);
+                }
+            } catch (Exception ex) {
+                throw new RuntimeException(
+                        "Unable to open immediate result file: " + dumpFile, ex);
+            }
+        }
+        boolean firstDump = true;
+        ExampleStream testStream = null;
+        int testSize = this.testSizeOption.getValue();
+        if (this.cacheTestOption.isSet()) {
+            monitor.setCurrentActivity("Caching test examples...", -1.0);
+            InstancesHeader testInstances = new InstancesHeader(stream.getHeader(),
+                    this.testSizeOption.getValue());
+            while (testInstances.numInstances() < testSize) {
+                testInstances.add((Instance) stream.nextInstance().getData());
+                if (testInstances.numInstances()
+                        % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
+                    if (monitor.taskShouldAbort()) {
+                        return null;
+                    }
+                    monitor.setCurrentActivityFractionComplete((double) testInstances.numInstances()
+                            / (double) (this.testSizeOption.getValue()));
+                }
+            }
+            testStream = new CachedInstancesStream(testInstances);
+        } else {
+            //testStream = (InstanceStream) stream.copy();
+            testStream = stream;
+            /*monitor.setCurrentActivity("Skipping test examples...", -1.0);
+            for (int i = 0; i < testSize; i++) {
+            stream.nextInstance();
+            }*/
+        }
+        instancesProcessed = 0;
+        TimingUtils.enablePreciseTiming();
+        double totalTrainTime = 0.0;
+        while ((this.trainSizeOption.getValue() < 1
+                || instancesProcessed < this.trainSizeOption.getValue())
+                && stream.hasMoreInstances() == true) {
+            monitor.setCurrentActivityDescription("Training...");
+            long instancesTarget = instancesProcessed
+                    + this.sampleFrequencyOption.getValue();
+            long trainStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+            while (instancesProcessed < instancesTarget && stream.hasMoreInstances() == true) {
+                learner.trainOnInstance(stream.nextInstance());
+                instancesProcessed++;
+                if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
+                    if (monitor.taskShouldAbort()) {
+                        return null;
+                    }
+                    monitor.setCurrentActivityFractionComplete((double) (instancesProcessed)
+                            / (double) (this.trainSizeOption.getValue()));
+                }
+            }
+            double lastTrainTime = TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread()
+                    - trainStartTime);
+            totalTrainTime += lastTrainTime;
+            if (totalTrainTime > this.trainTimeOption.getValue()) {
+                break;
+            }
+	    if (this.cacheTestOption.isSet()) {
+                testStream.restart();
+            } 
+            evaluator.reset();
+            long testInstancesProcessed = 0;
+            monitor.setCurrentActivityDescription("Testing (after "
+                    + StringUtils.doubleToString(
+                    ((double) (instancesProcessed)
+                    / (double) (this.trainSizeOption.getValue()) * 100.0), 2)
+                    + "% training)...");
+            long testStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+            int instCount = 0 ;
+            for (instCount = 0; instCount < testSize; instCount++) {
+				if (stream.hasMoreInstances() == false) {
+					break;
+				}
+                Example testInst = (Example) testStream.nextInstance(); //.copy();
+                double trueClass = ((Instance) testInst.getData()).classValue();
+                //testInst.setClassMissing();
+                double[] prediction = learner.getPredictionForInstance(testInst);
+                //testInst.setClassValue(trueClass);
+                evaluator.addResult(testInst, prediction);
+                testInstancesProcessed++;
+                if (testInstancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
+                    if (monitor.taskShouldAbort()) {
+                        return null;
+                    }
+                    monitor.setCurrentActivityFractionComplete((double) testInstancesProcessed
+                            / (double) (testSize));
+                }
+            }
+        	if ( instCount != testSize) {
+				break;
+			}
+            double testTime = TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread()
+                    - testStartTime);
+            List<Measurement> measurements = new ArrayList<Measurement>();
+            measurements.add(new Measurement("evaluation instances",            		
+                    instancesProcessed));
+            measurements.add(new Measurement("total train time", totalTrainTime));
+            measurements.add(new Measurement("total train speed",
+                    instancesProcessed / totalTrainTime));
+            measurements.add(new Measurement("last train time", lastTrainTime));
+            measurements.add(new Measurement("last train speed",
+                    this.sampleFrequencyOption.getValue() / lastTrainTime));
+            measurements.add(new Measurement("test time", testTime));
+            measurements.add(new Measurement("test speed", this.testSizeOption.getValue()
+                    / testTime));
+            Measurement[] performanceMeasurements = evaluator.getPerformanceMeasurements();
+            for (Measurement measurement : performanceMeasurements) {
+                measurements.add(measurement);
+            }
+            Measurement[] modelMeasurements = learner.getModelMeasurements();
+            for (Measurement measurement : modelMeasurements) {
+                measurements.add(measurement);
+            }
+            learningCurve.insertEntry(new LearningEvaluation(measurements.toArray(new Measurement[measurements.size()])));
+            if (immediateResultStream != null) {
+                if (firstDump) {
+                    immediateResultStream.println(learningCurve.headerToString());
+                    firstDump = false;
+                }
+                immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
+                immediateResultStream.flush();
+            }
+            if (monitor.resultPreviewRequested()) {
+                monitor.setLatestResultPreview(learningCurve.copy());
+            }
+            // if (learner instanceof HoeffdingTree
+            // || learner instanceof HoeffdingOptionTree) {
+            // int numActiveNodes = (int) Measurement.getMeasurementNamed(
+            // "active learning leaves",
+            // modelMeasurements).getValue();
+            // // exit if tree frozen
+            // if (numActiveNodes < 1) {
+            // break;
+            // }
+            // int numNodes = (int) Measurement.getMeasurementNamed(
+            // "tree size (nodes)", modelMeasurements)
+            // .getValue();
+            // if (numNodes == lastNumNodes) {
+            // noGrowthCount++;
+            // } else {
+            // noGrowthCount = 0;
+            // }
+            // lastNumNodes = numNodes;
+            // } else if (learner instanceof OzaBoost || learner instanceof
+            // OzaBag) {
+            // double numActiveNodes = Measurement.getMeasurementNamed(
+            // "[avg] active learning leaves",
+            // modelMeasurements).getValue();
+            // // exit if all trees frozen
+            // if (numActiveNodes == 0.0) {
+            // break;
+            // }
+            // int numNodes = (int) (Measurement.getMeasurementNamed(
+            // "[avg] tree size (nodes)",
+            // learner.getModelMeasurements()).getValue() * Measurement
+            // .getMeasurementNamed("ensemble size",
+            // modelMeasurements).getValue());
+            // if (numNodes == lastNumNodes) {
+            // noGrowthCount++;
+            // } else {
+            // noGrowthCount = 0;
+            // }
+            // lastNumNodes = numNodes;
+            // }
+        }
+        if (immediateResultStream != null) {
+            immediateResultStream.close();
+        }
+        return learningCurve;
+    }
+
+    @Override
+    public Class<?> getTaskResultType() {
+        return LearningCurve.class;
+    }
+}
diff --git a/moa/src/main/java/moa/tasks/EvaluatePrequentialClassification.java b/moa/src/main/java/moa/tasks/EvaluatePrequentialClassification.java
new file mode 100644
index 000000000..287bb51d2
--- /dev/null
+++ b/moa/src/main/java/moa/tasks/EvaluatePrequentialClassification.java
@@ -0,0 +1,30 @@
+package moa.tasks;
+
+import java.io.PrintStream;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Utils;
+import moa.learners.Classifier;
+
+public class EvaluatePrequentialClassification extends AbstractEvaluatePrequential<Classifier> implements ClassificationMainTask {
+
+	private static final long serialVersionUID = 1L;
+	
+	public EvaluatePrequentialClassification() {
+		super(Classifier.class, "moa.classifiers.trees.HoeffdingTree");
+	}
+
+	@Override
+    public String getPurposeString() {
+        return "Evaluates a classifier on a stream by testing then training with each example in sequence.";
+    }
+	@Override
+	public void printPrediction(PrintStream print, Instance inst, Prediction prediction) {
+		int trueClass = (int) inst.classValue();
+		print.println(Utils.maxIndex(prediction.asDoubleArray()) + "," + (inst.classIsMissing() ? " ? " : trueClass));
+
+	}
+
+}
diff --git a/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiLabelClassification.java b/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiLabelClassification.java
new file mode 100644
index 000000000..26108f057
--- /dev/null
+++ b/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiLabelClassification.java
@@ -0,0 +1,27 @@
+package moa.tasks;
+
+import java.io.PrintStream;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.learners.MultiLabelClassifier;
+
+public class EvaluatePrequentialMultiLabelClassification extends AbstractEvaluatePrequential<MultiLabelClassifier> {
+
+	private static final long serialVersionUID = 1L;
+
+	public EvaluatePrequentialMultiLabelClassification() {
+		super(MultiLabelClassifier.class, "moa.classifiers.mlc.trees.MultilabelHoeffdingTree");
+	}
+	
+	@Override
+    public String getPurposeString() {
+        return "Evaluates a multi-label classifier on a stream by testing then training with each example in sequence.";
+    }
+	
+	@Override
+	public void printPrediction(PrintStream print, Instance inst, Prediction prediction) {
+		print.println(prediction.asPredictionString() + "," + inst.outputAttributesToString());	
+	}
+}
diff --git a/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java.orig b/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java.orig
new file mode 100644
index 000000000..55b4ceade
--- /dev/null
+++ b/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java.orig
@@ -0,0 +1,713 @@
+<<<<<<< c4a46917f06a4f4c3c08e67d06f6762cca1b47f9
+/*
+ *    EvaluatePrequentialMultiTarget.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *    
+ */
+package moa.tasks;
+
+import com.github.javacliparser.FileOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstanceData;
+import com.yahoo.labs.samoa.instances.Prediction;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.PrintStream;
+
+import moa.classifiers.MultiTargetRegressor;
+import moa.classifiers.Regressor;
+import moa.core.Example;
+import moa.core.Measurement;
+import moa.core.ObjectRepository;
+import moa.core.TimingUtils;
+import moa.evaluation.EWMAClassificationPerformanceEvaluator;
+import moa.evaluation.FadingFactorClassificationPerformanceEvaluator;
+import moa.evaluation.LearningCurve;
+import moa.evaluation.LearningEvaluation;
+import moa.evaluation.LearningPerformanceEvaluator;
+import moa.evaluation.MultiTargetPerformanceEvaluator;
+import moa.evaluation.RegressionPerformanceEvaluator;
+import moa.evaluation.WindowClassificationPerformanceEvaluator;
+import moa.learners.Learner;
+import moa.options.ClassOption;
+import moa.streams.ExampleStream;
+import moa.streams.MultiTargetInstanceStream;
+
+/**
+ * Task for evaluating a classifier on a stream by testing then training with each example in sequence.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @version $Revision: 7 $
+ */
+public class EvaluatePrequentialMultiTarget extends MultiTargetMainTask {
+
+	@Override
+	public String getPurposeString() {
+		return "Evaluates a classifier on a stream by testing then training with each example in sequence.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption learnerOption = new ClassOption("learner", 'l',
+			"Learner to train.", MultiTargetRegressor.class, "moa.classifiers.multitarget.functions.MultiTargetNoChange");
+
+	public ClassOption streamOption = new ClassOption("stream", 's',
+			"Stream to learn from.", MultiTargetInstanceStream.class,
+			"MultiTargetArffFileStream");
+
+	public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
+			"Classification performance evaluation method.",
+			MultiTargetPerformanceEvaluator.class,
+			"BasicMultiTargetPerformanceEvaluator");
+
+	public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
+			"Maximum number of instances to test/train on  (-1 = no limit).",
+			100000000, -1, Integer.MAX_VALUE);
+
+	public IntOption timeLimitOption = new IntOption("timeLimit", 't',
+			"Maximum number of seconds to test/train for (-1 = no limit).", -1,
+			-1, Integer.MAX_VALUE);
+
+	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
+			'f',
+			"How many instances between samples of the learning performance.",
+			100000, 0, Integer.MAX_VALUE);
+
+	public IntOption memCheckFrequencyOption = new IntOption(
+			"memCheckFrequency", 'q',
+			"How many instances between memory bound checks.", 100000, 0,
+			Integer.MAX_VALUE);
+
+	public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
+			"File to append intermediate csv results to.", null, "csv", true);
+
+	public FileOption outputPredictionFileOption = new FileOption("outputPredictionFile", 'o',
+			"File to append output predictions to.", null, "pred", true);
+
+	//New for prequential method DEPRECATED
+	public IntOption widthOption = new IntOption("width",
+			'w', "Size of Window", 1000);
+
+	public FloatOption alphaOption = new FloatOption("alpha",
+			'a', "Fading factor or exponential smoothing factor", .01);
+	//End New for prequential methods
+
+	@Override
+	public Class<?> getTaskResultType() {
+		return LearningCurve.class;
+	}
+
+	@Override
+	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
+		Learner learner = (Learner) getPreparedClassOption(this.learnerOption);
+		ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
+		LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
+		LearningCurve learningCurve = new LearningCurve(
+				"learning evaluation instances");
+
+		//New for prequential methods
+		if (evaluator instanceof WindowClassificationPerformanceEvaluator) {
+			//((WindowClassificationPerformanceEvaluator) evaluator).setWindowWidth(widthOption.getValue());
+			if (widthOption.getValue() != 1000) {
+				System.out.println("DEPRECATED! Use EvaluatePrequential -e (WindowClassificationPerformanceEvaluator -w " + widthOption.getValue() + ")");
+				return learningCurve;
+=======
+/*
+ *    EvaluatePrequentialMultiTarget.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *    
+ */
+package moa.tasks;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.PrintStream;
+
+import com.github.javacliparser.FileOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.Prediction;
+
+import moa.classifiers.MultiTargetRegressor;
+import moa.core.Example;
+import moa.core.Measurement;
+import moa.core.ObjectRepository;
+import moa.core.TimingUtils;
+import moa.evaluation.EWMAClassificationPerformanceEvaluator;
+import moa.evaluation.FadingFactorClassificationPerformanceEvaluator;
+import moa.evaluation.LearningCurve;
+import moa.evaluation.LearningEvaluation;
+import moa.evaluation.LearningPerformanceEvaluator;
+import moa.evaluation.MultiTargetPerformanceEvaluator;
+import moa.evaluation.WindowClassificationPerformanceEvaluator;
+import moa.learners.Learner;
+import moa.options.ClassOption;
+import moa.streams.ExampleStream;
+import moa.streams.MultiTargetInstanceStream;
+
+/**
+ * Task for evaluating a classifier on a stream by testing then training with each example in sequence.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @version $Revision: 7 $
+ */
+public class EvaluatePrequentialMultiTarget extends MultiTargetMainTask {
+
+	@Override
+	public String getPurposeString() {
+		return "Evaluates a classifier on a stream by testing then training with each example in sequence.";
+	}
+<<<<<<< HEAD
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption learnerOption = new ClassOption("learner", 'l',
+			"Learner to train.", MultiTargetRegressor.class, "moa.classifiers.multitarget.functions.MultiTargetNoChange");
+
+	public ClassOption streamOption = new ClassOption("stream", 's',
+			"Stream to learn from.", MultiTargetInstanceStream.class,
+			"MultiTargetArffFileStream");
+
+	public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
+			"Classification performance evaluation method.",
+			MultiTargetPerformanceEvaluator.class,
+			"BasicMultiTargetPerformanceEvaluator");
+
+	public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
+			"Maximum number of instances to test/train on  (-1 = no limit).",
+			100000000, -1, Integer.MAX_VALUE);
+
+	public IntOption timeLimitOption = new IntOption("timeLimit", 't',
+			"Maximum number of seconds to test/train for (-1 = no limit).", -1,
+			-1, Integer.MAX_VALUE);
+
+	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
+			'f',
+			"How many instances between samples of the learning performance.",
+			100000, 0, Integer.MAX_VALUE);
+
+	public IntOption memCheckFrequencyOption = new IntOption(
+			"memCheckFrequency", 'q',
+			"How many instances between memory bound checks.", 100000, 0,
+			Integer.MAX_VALUE);
+
+	public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
+			"File to append intermediate csv results to.", null, "csv", true);
+
+	public FileOption outputPredictionFileOption = new FileOption("outputPredictionFile", 'o',
+			"File to append output predictions to.", null, "pred", true);
+
+	//New for prequential method DEPRECATED
+	public IntOption widthOption = new IntOption("width",
+			'w', "Size of Window", 1000);
+
+	public FloatOption alphaOption = new FloatOption("alpha",
+			'a', "Fading factor or exponential smoothing factor", .01);
+	//End New for prequential methods
+
+	@Override
+	public Class<?> getTaskResultType() {
+		return LearningCurve.class;
+	}
+
+	@Override
+	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
+		Learner learner = (Learner) getPreparedClassOption(this.learnerOption);
+		ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
+		LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
+		LearningCurve learningCurve = new LearningCurve(
+				"learning evaluation instances");
+
+		//New for prequential methods
+		if (evaluator instanceof WindowClassificationPerformanceEvaluator) {
+			//((WindowClassificationPerformanceEvaluator) evaluator).setWindowWidth(widthOption.getValue());
+			if (widthOption.getValue() != 1000) {
+				System.out.println("DEPRECATED! Use EvaluatePrequential -e (WindowClassificationPerformanceEvaluator -w " + widthOption.getValue() + ")");
+				return learningCurve;
+			}
+		}
+		if (evaluator instanceof EWMAClassificationPerformanceEvaluator) {
+			//((EWMAClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
+			if (alphaOption.getValue() != .01) {
+				System.out.println("DEPRECATED! Use EvaluatePrequential -e (EWMAClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
+				return learningCurve;
+			}
+		}
+		if (evaluator instanceof FadingFactorClassificationPerformanceEvaluator) {
+			//((FadingFactorClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
+			if (alphaOption.getValue() != .01) {
+				System.out.println("DEPRECATED! Use EvaluatePrequential -e (FadingFactorClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
+				return learningCurve;
+			}
+		}
+		//End New for prequential methods
+
+		learner.setModelContext(stream.getHeader());
+		int maxInstances = this.instanceLimitOption.getValue();
+		long instancesProcessed = 0;
+		int maxSeconds = this.timeLimitOption.getValue();
+		int secondsElapsed = 0;
+		monitor.setCurrentActivity("Evaluating learner...", -1.0);
+
+		File dumpFile = this.dumpFileOption.getFile();
+		PrintStream immediateResultStream = null;
+		if (dumpFile != null) {
+			try {
+				if (dumpFile.exists()) {
+					immediateResultStream = new PrintStream(
+							new FileOutputStream(dumpFile, true), true);
+				} else {
+					immediateResultStream = new PrintStream(
+							new FileOutputStream(dumpFile), true);
+				}
+			} catch (Exception ex) {
+				throw new RuntimeException(
+						"Unable to open immediate result file: " + dumpFile, ex);
+			}
+		}
+		//File for output predictions
+		File outputPredictionFile = this.outputPredictionFileOption.getFile();
+		PrintStream outputPredictionResultStream = null;
+		if (outputPredictionFile != null) {
+			try {
+				if (outputPredictionFile.exists()) {
+					outputPredictionResultStream = new PrintStream(
+							new FileOutputStream(outputPredictionFile, true), true);
+				} else {
+					outputPredictionResultStream = new PrintStream(
+							new FileOutputStream(outputPredictionFile), true);
+				}
+			} catch (Exception ex) {
+				throw new RuntimeException(
+						"Unable to open prediction result file: " + outputPredictionFile, ex);
+			}
+		}
+		boolean firstDump = true;
+		boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
+		long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+		long lastEvaluateStartTime = evaluateStartTime;
+		double RAMHours = 0.0;
+		while (stream.hasMoreInstances()
+				&& ((maxInstances < 0) || (instancesProcessed < maxInstances))
+				&& ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
+			Example trainInst = stream.nextInstance();
+			Example testInst = (Example) trainInst; //.copy();
+			//testInst.setClassMissing();
+			//double[] prediction = learner.getPredictionForInstance(testInst);
+			Prediction prediction = learner.getPredictionForInstance(testInst);
+			// Output prediction
+			if (outputPredictionFile != null) {
+				StringBuilder sb = new StringBuilder();
+				for (int i = 0; i < ((Instance) trainInst.getData()).numOutputAttributes(); i++) {
+					sb.append("Out " + i + ": " + ((Instance) trainInst.getData()).valueOutputAttribute(i) + " ");
+				}
+				outputPredictionResultStream.println(prediction + "," + sb.toString());
+			}
+
+			//evaluator.addClassificationAttempt(trueClass, prediction, testInst.weight());
+			evaluator.addResult(testInst, prediction);
+			learner.trainOnInstance(trainInst);
+			instancesProcessed++;
+			if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0
+					|| stream.hasMoreInstances() == false) {
+				long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+				double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);
+				double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);
+				double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); //GBs
+				RAMHoursIncrement *= (timeIncrement / 3600.0); //Hours
+				RAMHours += RAMHoursIncrement;
+				lastEvaluateStartTime = evaluateTime;
+				learningCurve.insertEntry(new LearningEvaluation(
+						new Measurement[]{
+								new Measurement(
+										"learning evaluation instances",
+										instancesProcessed),
+										new Measurement(
+												"evaluation time ("
+														+ (preciseCPUTiming ? "cpu "
+																: "") + "seconds)",
+																time),
+																new Measurement(
+																		"model cost (RAM-Hours)",
+																		RAMHours)
+						},
+						evaluator, learner));
+
+				if (immediateResultStream != null) {
+					if (firstDump) {
+						immediateResultStream.println(learningCurve.headerToString());
+						firstDump = false;
+					}
+					immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
+					immediateResultStream.flush();
+				}
+			}
+			if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
+				if (monitor.taskShouldAbort()) {
+					return null;
+				}
+				long estimatedRemainingInstances = stream.estimatedRemainingInstances();
+				if (maxInstances > 0) {
+					long maxRemaining = maxInstances - instancesProcessed;
+					if ((estimatedRemainingInstances < 0)
+							|| (maxRemaining < estimatedRemainingInstances)) {
+						estimatedRemainingInstances = maxRemaining;
+					}
+				}
+				monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
+						: (double) instancesProcessed
+						/ (double) (instancesProcessed + estimatedRemainingInstances));
+				if (monitor.resultPreviewRequested()) {
+					monitor.setLatestResultPreview(learningCurve.copy());
+				}
+				secondsElapsed = (int) TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread()
+						- evaluateStartTime);
+			}
+		}
+		StringBuilder sb= new StringBuilder();
+		learner.getDescription(sb, 0);
+		System.out.println(sb.toString());
+		if (immediateResultStream != null) {
+			immediateResultStream.close();
+		}
+		if (outputPredictionResultStream != null) {
+			outputPredictionResultStream.close();
+		}
+		return learningCurve;
+	}
+}
+=======
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption learnerOption = new ClassOption("learner", 'l',
+			"Learner to train.", MultiTargetRegressor.class, "moa.classifiers.multitarget.functions.MultiTargetNoChange");
+
+	public ClassOption streamOption = new ClassOption("stream", 's',
+			"Stream to learn from.", MultiTargetInstanceStream.class,
+			"MultiTargetArffFileStream");
+
+	public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
+			"Classification performance evaluation method.",
+			MultiTargetPerformanceEvaluator.class,
+			"BasicMultiTargetPerformanceEvaluator");
+
+	public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
+			"Maximum number of instances to test/train on  (-1 = no limit).",
+			100000000, -1, Integer.MAX_VALUE);
+
+	public IntOption timeLimitOption = new IntOption("timeLimit", 't',
+			"Maximum number of seconds to test/train for (-1 = no limit).", -1,
+			-1, Integer.MAX_VALUE);
+
+	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
+			'f',
+			"How many instances between samples of the learning performance.",
+			100000, 0, Integer.MAX_VALUE);
+
+	public IntOption memCheckFrequencyOption = new IntOption(
+			"memCheckFrequency", 'q',
+			"How many instances between memory bound checks.", 100000, 0,
+			Integer.MAX_VALUE);
+
+	public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
+			"File to append intermediate csv results to.", null, "csv", true);
+
+	public FileOption outputPredictionFileOption = new FileOption("outputPredictionFile", 'o',
+			"File to append output predictions to.", null, "pred", true);
+
+	//New for prequential method DEPRECATED
+	public IntOption widthOption = new IntOption("width",
+			'w', "Size of Window", 1000);
+
+	public FloatOption alphaOption = new FloatOption("alpha",
+			'a', "Fading factor or exponential smoothing factor", .01);
+	//End New for prequential methods
+
+	@Override
+	public Class<?> getTaskResultType() {
+		return LearningCurve.class;
+	}
+
+	@Override
+	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
+		Learner learner = (Learner) getPreparedClassOption(this.learnerOption);
+		ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
+		LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
+		LearningCurve learningCurve = new LearningCurve(
+				"learning evaluation instances");
+
+		//New for prequential methods
+		if (evaluator instanceof WindowClassificationPerformanceEvaluator) {
+			//((WindowClassificationPerformanceEvaluator) evaluator).setWindowWidth(widthOption.getValue());
+			if (widthOption.getValue() != 1000) {
+				System.out.println("DEPRECATED! Use EvaluatePrequential -e (WindowClassificationPerformanceEvaluator -w " + widthOption.getValue() + ")");
+				return learningCurve;
+			}
+		}
+		if (evaluator instanceof EWMAClassificationPerformanceEvaluator) {
+			//((EWMAClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
+			if (alphaOption.getValue() != .01) {
+				System.out.println("DEPRECATED! Use EvaluatePrequential -e (EWMAClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
+				return learningCurve;
+			}
+		}
+		if (evaluator instanceof FadingFactorClassificationPerformanceEvaluator) {
+			//((FadingFactorClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
+			if (alphaOption.getValue() != .01) {
+				System.out.println("DEPRECATED! Use EvaluatePrequential -e (FadingFactorClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
+				return learningCurve;
+			}
+		}
+		//End New for prequential methods
+
+		learner.setModelContext(stream.getHeader());
+		int maxInstances = this.instanceLimitOption.getValue();
+		long instancesProcessed = 0;
+		int maxSeconds = this.timeLimitOption.getValue();
+		int secondsElapsed = 0;
+		monitor.setCurrentActivity("Evaluating learner...", -1.0);
+
+		File dumpFile = this.dumpFileOption.getFile();
+		PrintStream immediateResultStream = null;
+		if (dumpFile != null) {
+			try {
+				if (dumpFile.exists()) {
+					immediateResultStream = new PrintStream(
+							new FileOutputStream(dumpFile, true), true);
+				} else {
+					immediateResultStream = new PrintStream(
+							new FileOutputStream(dumpFile), true);
+				}
+			} catch (Exception ex) {
+				throw new RuntimeException(
+						"Unable to open immediate result file: " + dumpFile, ex);
+			}
+		}
+		//File for output predictions
+		File outputPredictionFile = this.outputPredictionFileOption.getFile();
+		PrintStream outputPredictionResultStream = null;
+		if (outputPredictionFile != null) {
+			try {
+				if (outputPredictionFile.exists()) {
+					outputPredictionResultStream = new PrintStream(
+							new FileOutputStream(outputPredictionFile, true), true);
+				} else {
+					outputPredictionResultStream = new PrintStream(
+							new FileOutputStream(outputPredictionFile), true);
+				}
+			} catch (Exception ex) {
+				throw new RuntimeException(
+						"Unable to open prediction result file: " + outputPredictionFile, ex);
+			}
+		}
+		boolean firstDump = true;
+		boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
+		long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+		long lastEvaluateStartTime = evaluateStartTime;
+		double RAMHours = 0.0;
+		while (stream.hasMoreInstances()
+				&& ((maxInstances < 0) || (instancesProcessed < maxInstances))
+				&& ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
+			Example trainInst = stream.nextInstance();
+			Example testInst = (Example) trainInst; //.copy();
+			//testInst.setClassMissing();
+			//double[] prediction = learner.getPredictionForInstance(testInst);
+			Prediction prediction = learner.getPredictionForInstance(testInst);
+			// Output prediction
+			if (outputPredictionFile != null) {
+				StringBuilder sb = new StringBuilder();
+				for (int i = 0; i < ((Instance) trainInst.getData()).numOutputAttributes(); i++) {
+					sb.append("Out " + i + ": " + ((Instance) trainInst.getData()).valueOutputAttribute(i) + " ");
+				}
+				outputPredictionResultStream.println(prediction + "," + sb.toString());
+>>>>>>> Instances rework, new iSOUPTree models and import cleanup
+			}
+		}
+		if (evaluator instanceof EWMAClassificationPerformanceEvaluator) {
+			//((EWMAClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
+			if (alphaOption.getValue() != .01) {
+				System.out.println("DEPRECATED! Use EvaluatePrequential -e (EWMAClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
+				return learningCurve;
+			}
+		}
+		if (evaluator instanceof FadingFactorClassificationPerformanceEvaluator) {
+			//((FadingFactorClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
+			if (alphaOption.getValue() != .01) {
+				System.out.println("DEPRECATED! Use EvaluatePrequential -e (FadingFactorClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
+				return learningCurve;
+			}
+		}
+		//End New for prequential methods
+
+		learner.setModelContext(stream.getHeader());
+		int maxInstances = this.instanceLimitOption.getValue();
+		long instancesProcessed = 0;
+		int maxSeconds = this.timeLimitOption.getValue();
+		int secondsElapsed = 0;
+		monitor.setCurrentActivity("Evaluating learner...", -1.0);
+
+		File dumpFile = this.dumpFileOption.getFile();
+		PrintStream immediateResultStream = null;
+		if (dumpFile != null) {
+			try {
+				if (dumpFile.exists()) {
+					immediateResultStream = new PrintStream(
+							new FileOutputStream(dumpFile, true), true);
+				} else {
+					immediateResultStream = new PrintStream(
+							new FileOutputStream(dumpFile), true);
+				}
+			} catch (Exception ex) {
+				throw new RuntimeException(
+						"Unable to open immediate result file: " + dumpFile, ex);
+			}
+		}
+		//File for output predictions
+		File outputPredictionFile = this.outputPredictionFileOption.getFile();
+		PrintStream outputPredictionResultStream = null;
+		if (outputPredictionFile != null) {
+			try {
+				if (outputPredictionFile.exists()) {
+					outputPredictionResultStream = new PrintStream(
+							new FileOutputStream(outputPredictionFile, true), true);
+				} else {
+					outputPredictionResultStream = new PrintStream(
+							new FileOutputStream(outputPredictionFile), true);
+				}
+			} catch (Exception ex) {
+				throw new RuntimeException(
+						"Unable to open prediction result file: " + outputPredictionFile, ex);
+			}
+		}
+		boolean firstDump = true;
+		boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
+		long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+		long lastEvaluateStartTime = evaluateStartTime;
+		double RAMHours = 0.0;
+		while (stream.hasMoreInstances()
+				&& ((maxInstances < 0) || (instancesProcessed < maxInstances))
+				&& ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
+			Example trainInst = stream.nextInstance();
+			Example testInst = (Example) trainInst; //.copy();
+			//testInst.setClassMissing();
+			//double[] prediction = learner.getPredictionForInstance(testInst);
+			Prediction prediction = learner.getPredictionForInstance(testInst);
+			// Output prediction
+			if (outputPredictionFile != null) {
+				StringBuilder sb = new StringBuilder();
+				for (int i = 0; i < ((Instance) trainInst.getData()).numOutputAttributes(); i++) {
+					sb.append("Out " + i + ": " + ((Instance) trainInst.getData()).valueOutputAttribute(i) + " ");
+				}
+				outputPredictionResultStream.println(prediction + "," + sb.toString());
+			}
+
+			//evaluator.addClassificationAttempt(trueClass, prediction, testInst.weight());
+			evaluator.addResult(testInst, prediction);
+			learner.trainOnInstance(trainInst);
+			instancesProcessed++;
+			if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0
+					|| stream.hasMoreInstances() == false) {
+				long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+				double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);
+				double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);
+				double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); //GBs
+				RAMHoursIncrement *= (timeIncrement / 3600.0); //Hours
+				RAMHours += RAMHoursIncrement;
+				lastEvaluateStartTime = evaluateTime;
+				learningCurve.insertEntry(new LearningEvaluation(
+						new Measurement[]{
+								new Measurement(
+										"learning evaluation instances",
+										instancesProcessed),
+										new Measurement(
+												"evaluation time ("
+														+ (preciseCPUTiming ? "cpu "
+																: "") + "seconds)",
+																time),
+																new Measurement(
+																		"model cost (RAM-Hours)",
+																		RAMHours)
+						},
+						evaluator, learner));
+
+				if (immediateResultStream != null) {
+					if (firstDump) {
+						immediateResultStream.println(learningCurve.headerToString());
+						firstDump = false;
+					}
+					immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
+					immediateResultStream.flush();
+				}
+			}
+			if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
+				if (monitor.taskShouldAbort()) {
+					return null;
+				}
+				long estimatedRemainingInstances = stream.estimatedRemainingInstances();
+				if (maxInstances > 0) {
+					long maxRemaining = maxInstances - instancesProcessed;
+					if ((estimatedRemainingInstances < 0)
+							|| (maxRemaining < estimatedRemainingInstances)) {
+						estimatedRemainingInstances = maxRemaining;
+					}
+				}
+				monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
+						: (double) instancesProcessed
+						/ (double) (instancesProcessed + estimatedRemainingInstances));
+				if (monitor.resultPreviewRequested()) {
+					monitor.setLatestResultPreview(learningCurve.copy());
+				}
+				secondsElapsed = (int) TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread()
+						- evaluateStartTime);
+			}
+		}
+		StringBuilder sb= new StringBuilder();
+		learner.getDescription(sb, 0);
+		System.out.println(sb.toString());
+		if (immediateResultStream != null) {
+			immediateResultStream.close();
+		}
+		if (outputPredictionResultStream != null) {
+			outputPredictionResultStream.close();
+		}
+		return learningCurve;
+	}
+}
+>>>>>>> 32d534d2e43c28db1711ab2fe7ff580d214e22fe
diff --git a/moa/src/main/java/moa/tasks/LearnModelClassification.java b/moa/src/main/java/moa/tasks/LearnModelClassification.java
new file mode 100644
index 000000000..751337858
--- /dev/null
+++ b/moa/src/main/java/moa/tasks/LearnModelClassification.java
@@ -0,0 +1,19 @@
+package moa.tasks;
+
+import moa.learners.Classifier;
+import moa.options.ClassOption;
+
+public class LearnModelClassification extends AbstractLearnModel<Classifier> implements ClassificationMainTask {
+
+    @Override
+    public String getPurposeString() {
+        return "Learns a Classification model from a stream.";
+    }
+
+    private static final long serialVersionUID = 1L;
+
+    public LearnModelClassification() {
+		this.learnerOption = new ClassOption("learner", 'l', "Learner to train.", Classifier.class, "moa.classifiers.trees.HoeffdingTree");
+	}
+	
+}
diff --git a/moa/src/main/java/moa/tasks/LearnModelMultiLabelClassification.java b/moa/src/main/java/moa/tasks/LearnModelMultiLabelClassification.java
new file mode 100644
index 000000000..51f85e8da
--- /dev/null
+++ b/moa/src/main/java/moa/tasks/LearnModelMultiLabelClassification.java
@@ -0,0 +1,20 @@
+package moa.tasks;
+
+import moa.learners.MultiLabelClassifier;
+import moa.options.ClassOption;
+
+public class LearnModelMultiLabelClassification extends AbstractLearnModel<MultiLabelClassifier> {
+
+    @Override
+    public String getPurposeString() {
+        return "Learns a multi-label classification model from a stream.";
+    }
+
+    private static final long serialVersionUID = 1L;
+
+    public LearnModelMultiLabelClassification() {
+		this.learnerOption = new ClassOption("learner", 'l', "Learner to train.", MultiLabelClassifier.class, "moa.classifiers.mlc.trees.MultiLabelHoeffdingTree");
+	}
+    
+	
+}
diff --git a/moa/src/main/java/moa/tasks/MainTaskInterface.java b/moa/src/main/java/moa/tasks/MainTaskInterface.java
new file mode 100644
index 000000000..10eaf61c4
--- /dev/null
+++ b/moa/src/main/java/moa/tasks/MainTaskInterface.java
@@ -0,0 +1,10 @@
+package moa.tasks;
+
+public interface MainTaskInterface {
+
+	public Object doTask();
+	
+	public String getCLICreationString(Class<?> c);
+	
+	public Object copy();
+}
diff --git a/moa/src/main/java/moa/tasks/MultiLabelClassificatioMainTask.java b/moa/src/main/java/moa/tasks/MultiLabelClassificatioMainTask.java
new file mode 100644
index 000000000..bdb4f6b40
--- /dev/null
+++ b/moa/src/main/java/moa/tasks/MultiLabelClassificatioMainTask.java
@@ -0,0 +1,5 @@
+package moa.tasks;
+
+public interface MultiLabelClassificatioMainTask extends MainTaskInterface {
+
+}
diff --git a/weka-package/.classpath b/weka-package/.classpath
index af1430be1..f619a5369 100644
--- a/weka-package/.classpath
+++ b/weka-package/.classpath
@@ -12,7 +12,7 @@
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7">
 		<attributes>
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
diff --git a/weka-package/.settings/org.eclipse.jdt.core.prefs b/weka-package/.settings/org.eclipse.jdt.core.prefs
index 6e80039d3..443e08599 100644
--- a/weka-package/.settings/org.eclipse.jdt.core.prefs
+++ b/weka-package/.settings/org.eclipse.jdt.core.prefs
@@ -1,8 +1,8 @@
 eclipse.preferences.version=1
 org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
-org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
+org.eclipse.jdt.core.compiler.compliance=1.7
 org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
 org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
 org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
-org.eclipse.jdt.core.compiler.source=1.8
+org.eclipse.jdt.core.compiler.source=1.7
diff --git a/weka-package/pom.xml.orig b/weka-package/pom.xml.orig
new file mode 100644
index 000000000..8068f153f
--- /dev/null
+++ b/weka-package/pom.xml.orig
@@ -0,0 +1,57 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+
+  <modelVersion>4.0.0</modelVersion>
+
+  <parent>
+    <groupId>nz.ac.waikato.cms.moa</groupId>
+    <artifactId>moa-pom</artifactId>
+<<<<<<< Updated upstream
+    <version>2014.04</version>
+=======
+    <version>2017.10-SNAPSHOT</version>
+>>>>>>> Stashed changes
+  </parent>
+
+  <artifactId>weka-package</artifactId>
+  <packaging>jar</packaging>
+
+  <name>MOA: WEKA Package</name>
+  <description>
+  Massive On-line Analysis is an environment for massive data mining. MOA provides a framework for data stream mining and includes tools for evaluation and a collection of machine learning algorithms. Related to the WEKA project, also written in Java, while scaling to more demanding problems.
+  This artifact enables you to use MOA from within WEKA.
+  </description>
+  <url>http://moa.cms.waikato.ac.nz/</url>
+  <organization>
+    <name>University of Waikato, Hamilton, NZ</name>
+    <url>http://www.waikato.ac.nz/</url>
+  </organization>
+  <licenses>
+    <license>
+      <name>GNU General Public License 3</name>
+      <url>http://www.gnu.org/licenses/gpl-3.0.txt</url>
+      <distribution>repo</distribution>
+    </license>
+  </licenses>
+
+  <developers>
+    <developer>
+      <id>abifet</id>
+      <name>Albert Bifet</name>
+      <email>abifet@waikato.ac.nz</email>
+    </developer>
+    <developer>
+      <id>fracpete</id>
+      <name>Peter Reutemann</name>
+      <email>fracpete@waikato.ac.nz</email>
+    </developer>
+  </developers>
+
+  <dependencies>
+    <dependency>
+      <groupId>nz.ac.waikato.cms.moa</groupId>
+      <artifactId>moa</artifactId>
+      <version>[${project.version},)</version>
+    </dependency>
+  </dependencies>
+</project>

From 374ba36441bc65c9167c0581b346c451f670594c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aosojnik@gmail.com>
Date: Mon, 3 Jul 2017 10:11:16 +0200
Subject: [PATCH 31/33] Removed merging artifacts

---
 moa/pom.xml.orig                              | 156 ---
 .../moa/classifiers/meta/OzaBagASHT.java.orig | 200 ----
 .../TemporallyAugmentedClassifier.java.orig   | 190 ----
 .../mlc/MultilabelHoeffdingTree.java.orig     | 237 -----
 .../moa/classifiers/trees/ORTO2.java.orig     | 543 -----------
 .../clusterers/clustree/ClusTree.java.orig    | 891 ------------------
 .../EvaluatePeriodicHeldOutTest.java.orig     | 308 ------
 .../EvaluatePrequentialMultiTarget.java.orig  | 713 --------------
 8 files changed, 3238 deletions(-)
 delete mode 100644 moa/pom.xml.orig
 delete mode 100644 moa/src/main/java/moa/classifiers/meta/OzaBagASHT.java.orig
 delete mode 100644 moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java.orig
 delete mode 100644 moa/src/main/java/moa/classifiers/mlc/MultilabelHoeffdingTree.java.orig
 delete mode 100644 moa/src/main/java/moa/classifiers/trees/ORTO2.java.orig
 delete mode 100644 moa/src/main/java/moa/clusterers/clustree/ClusTree.java.orig
 delete mode 100644 moa/src/main/java/moa/tasks/EvaluatePeriodicHeldOutTest.java.orig
 delete mode 100644 moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java.orig

diff --git a/moa/pom.xml.orig b/moa/pom.xml.orig
deleted file mode 100644
index 8edfa56e1..000000000
--- a/moa/pom.xml.orig
+++ /dev/null
@@ -1,156 +0,0 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-  <modelVersion>4.0.0</modelVersion>
-
-  <parent>
-    <groupId>nz.ac.waikato.cms.moa</groupId>
-    <artifactId>moa-pom</artifactId>
-<<<<<<< Updated upstream
-    <version>2014.04</version>
-=======
-    <version>2017.10-SNAPSHOT</version>
->>>>>>> Stashed changes
-  </parent>
-
-  <artifactId>moa</artifactId>
-  <packaging>jar</packaging>
-
-  <name>MOA: Massive Online Analysis</name>
-  <description>
-  Massive On-line Analysis is an environment for massive data mining. MOA
-  provides a framework for data stream mining and includes tools for evaluation
-  and a collection of machine learning algorithms. Related to the WEKA project,
-  also written in Java, while scaling to more demanding problems.
-  </description>
-  <url>http://moa.cms.waikato.ac.nz/</url>
-  <organization>
-    <name>University of Waikato, Hamilton, NZ</name>
-    <url>http://www.waikato.ac.nz/</url>
-  </organization>
-  <licenses>
-    <license>
-      <name>GNU General Public License 3.0</name>
-      <url>http://www.gnu.org/licenses/gpl-3.0.txt</url>
-      <distribution>repo</distribution>
-    </license>
-  </licenses>
-
-  <developers>
-    <developer>
-      <id>abifet</id>
-      <name>Albert Bifet</name>
-      <email>abifet@waikato.ac.nz</email>
-    </developer>
-    <developer>
-      <id>rkirkby</id>
-      <name>Richard Kirkby</name>
-    </developer>
-  </developers>
-
-  <dependencies>
-    <dependency>
-      <groupId>nz.ac.waikato.cms.weka</groupId>
-      <artifactId>weka-dev</artifactId>
-    </dependency>
-
-    <dependency>
-      <groupId>com.googlecode.sizeofag</groupId>
-      <artifactId>sizeofag</artifactId>
-    </dependency>
-
-<<<<<<< Updated upstream
-=======
-      <dependency>
-          <groupId>net.sf.meka</groupId>
-          <artifactId>meka</artifactId>
-      </dependency>
-
->>>>>>> Stashed changes
-    <dependency>
-      <groupId>junit</groupId>
-      <artifactId>junit</artifactId>
-      <scope>test</scope>
-    </dependency>
-    
-    <dependency>
-    <groupId>org.apache.commons</groupId>
-    <artifactId>commons-math3</artifactId>
-    <version>3.6.1</version>
-    </dependency>
-    
-    <dependency>
-      <groupId>com.googlecode.java-diff-utils</groupId>
-      <artifactId>diffutils</artifactId>
-      <version>1.2.1</version>
-      <scope>test</scope>
-    </dependency>
-  </dependencies>
-
-  <build>
-    <plugins>
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-compiler-plugin</artifactId>
-        <configuration>
-          <source>1.7</source>
-          <target>1.7</target>
-        </configuration>
-      </plugin>
-
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-jar-plugin</artifactId>
-      </plugin>
-
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-javadoc-plugin</artifactId>
-      </plugin>
-      
-      <plugin>
-        <groupId>org.codehaus.mojo</groupId>
-        <artifactId>license-maven-plugin</artifactId>
-      </plugin>
-
-      <plugin>
-        <groupId>org.codehaus.mojo</groupId>
-        <artifactId>latex-maven-plugin</artifactId>
-      </plugin>
-
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-assembly-plugin</artifactId>
-      </plugin>
-    </plugins>
-    <pluginManagement>
-    	<plugins>
-    		<!--This plugin's configuration is used to store Eclipse m2e settings only. It has no influence on the Maven build itself.-->
-    		<plugin>
-    			<groupId>org.eclipse.m2e</groupId>
-    			<artifactId>lifecycle-mapping</artifactId>
-    			<version>1.0.0</version>
-    			<configuration>
-    				<lifecycleMappingMetadata>
-    					<pluginExecutions>
-    						<pluginExecution>
-    							<pluginExecutionFilter>
-    								<groupId>org.codehaus.mojo</groupId>
-    								<artifactId>
-    									license-maven-plugin
-    								</artifactId>
-    								<versionRange>[1.1,)</versionRange>
-    								<goals>
-    									<goal>add-third-party</goal>
-    								</goals>
-    							</pluginExecutionFilter>
-    							<action>
-    								<ignore></ignore>
-    							</action>
-    						</pluginExecution>
-    					</pluginExecutions>
-    				</lifecycleMappingMetadata>
-    			</configuration>
-    		</plugin>
-    	</plugins>
-    </pluginManagement>
-  </build>
-</project>
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBagASHT.java.orig b/moa/src/main/java/moa/classifiers/meta/OzaBagASHT.java.orig
deleted file mode 100644
index 6b78f94de..000000000
--- a/moa/src/main/java/moa/classifiers/meta/OzaBagASHT.java.orig
+++ /dev/null
@@ -1,200 +0,0 @@
-/*
- *    OzaBagASHT.java
- *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.meta;
-
-<<<<<<< HEAD
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-
-=======
-import moa.options.ClassOption;
->>>>>>> 3d07f07a8e1662963b332241c1fcfe85cebe0609
-import moa.classifiers.Classifier;
-import moa.classifiers.trees.ASHoeffdingTree;
-import moa.core.DoubleVector;
-import moa.core.MiscUtils;
-<<<<<<< HEAD
-=======
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.FlagOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import moa.classifiers.AbstractClassifier;
-import moa.core.Measurement;
->>>>>>> 3d07f07a8e1662963b332241c1fcfe85cebe0609
-import moa.core.Utils;
-
-/**
- * Bagging using trees of different size.
- * The Adaptive-Size Hoeffding Tree (ASHT) is derived from the Hoeffding Tree
- * algorithm with the following differences:
- * <ul>
- * <li> it has a maximum number of split nodes, or size
- * <li> after one node splits, if the number of split nodes of the ASHT tree
- * is higher than the maximum value, then it deletes some nodes to reduce its size
- * </ul>
- * The intuition behind this method is as follows: smaller trees adapt
- * more quickly to changes, and larger trees do better during periods with
- * no or little change, simply because they were built on more data. Trees
- * limited to size s will be reset about twice as often as trees with a size
- * limit of 2s. This creates a set of different reset-speeds for an ensemble of such
- * trees, and therefore a subset of trees that are a good approximation for the
- * current rate of change. It is important to note that resets will happen all
- * the time, even for stationary datasets, but this behaviour should not have
- * a negative impact on the ensemble’s predictive performance.
- * When the tree size exceeds the maximun size value, there are two different
- * delete options: <ul>
- * <li> delete the oldest node, the root, and all of its children except the one
- * where the split has been made. After that, the root of the child not
- * deleted becomes the new root
- * <li> delete all the nodes of the tree, i.e., restart from a new root.
- * </ul>
- * The maximum allowed size for the n-th ASHT tree is twice the maximum
- * allowed size for the (n-1)-th tree. Moreover, each tree has a weight
- * proportional to the inverse of the square of its error, and it monitors its
- * error with an exponential weighted moving average (EWMA) with alpha = .01.
- * The size of the first tree is 2.
- * <br/><br/>
- * With this new method, it is attempted to improve bagging performance
- * by increasing tree diversity. It has been observed that boosting tends to
- * produce a more diverse set of classifiers than bagging, and this has been
- * cited as a factor in increased performance.<br/>
- * See more details in:<br/><br/>
- * Albert Bifet, Geoff Holmes, Bernhard Pfahringer, Richard Kirkby,
- * and Ricard Gavaldà. New ensemble methods for evolving data
- * streams. In 15th ACM SIGKDD International Conference on Knowledge
- * Discovery and Data Mining, 2009.<br/><br/>
- * The learner must be ASHoeffdingTree, a Hoeffding Tree with a maximum
- * size value.<br/><br/>
- * Example:<br/><br/>
- * <code>OzaBagASHT -l ASHoeffdingTree -s 10 -u -r </code>
- * Parameters:<ul>
- * <li>Same parameters as <code>OzaBag</code>
- * <li>-f : the size of first classifier in the bag.
- * <li>-u : Enable weight classifiers
- * <li>-e : Reset trees when size is higher than the max
- * </ul>
- *
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @version $Revision: 7 $
- */
-public class OzaBagASHT extends AbstractClassifier {
-
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public String getPurposeString() {
-        return "Bagging using trees of different size.";
-    }
-    
-    public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's',
-        "The number of models in the bag.", 10, 1, Integer.MAX_VALUE);
-    
-    public IntOption firstClassifierSizeOption = new IntOption("firstClassifierSize", 'f',
-            "The size of first classifier in the bag.", 1, 1, Integer.MAX_VALUE);
-
-    public FlagOption useWeightOption = new FlagOption("useWeight",
-            'u', "Enable weight classifiers.");
-
-    public FlagOption resetTreesOption = new FlagOption("resetTrees",
-            'e', "Reset trees when size is higher than the max.");
-
-        public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l',
-    		"ASHoeffdingTree to train.", ASHoeffdingTree.class,
-    		"moa.classifiers.trees.ASHoeffdingTree");
-    
-    protected ASHoeffdingTree[] ensemble;
-    protected double[] error;
-    protected double alpha = 0.01;
-
-    @Override
-    public void resetLearningImpl() {
-        this.ensemble = new ASHoeffdingTree[this.ensembleSizeOption.getValue()];
-        this.error = new double[this.ensembleSizeOption.getValue()];
-        Classifier baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
-        baseLearner.resetLearning();
-        int pow = this.firstClassifierSizeOption.getValue();
-        for (int i = 0; i < this.ensemble.length; i++) {
-            this.ensemble[i] = (ASHoeffdingTree) baseLearner.copy();
-            this.error[i] = 0.0;
-            ((ASHoeffdingTree) this.ensemble[i]).setMaxSize(pow);
-            if ((this.resetTreesOption != null)
-                    && this.resetTreesOption.isSet()) {
-                ((ASHoeffdingTree) this.ensemble[i]).setResetTree();
-            }
-            pow *= 2;
-        }
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        int trueClass = (int) inst.classValue();
-        for (int i = 0; i < this.ensemble.length; i++) {
-            int k = MiscUtils.poisson(1.0, this.classifierRandom);
-            if (k > 0) {
-                Instance weightedInst = (Instance) inst.copy();
-                weightedInst.setWeight(inst.weight() * k);
-                if (Utils.maxIndex(this.ensemble[i].getPredictionForInstance(inst)) == trueClass) {
-                    this.error[i] += alpha * (0.0 - this.error[i]); //EWMA
-                } else {
-                    this.error[i] += alpha * (1.0 - this.error[i]); //EWMA
-                }
-                this.ensemble[i].trainOnInstance(weightedInst);
-            }
-        }
-    }
-
-    public Prediction getPredictionForInstance(Instance inst) {
-        DoubleVector combinedVote = new DoubleVector();
-        for (int i = 0; i < this.ensemble.length; i++) {
-            DoubleVector vote = new DoubleVector(this.ensemble[i].getPredictionForInstance(inst));
-            if (vote.sumOfValues() > 0.0) {
-                vote.normalize();
-                if ((this.useWeightOption != null)
-                        && this.useWeightOption.isSet()) {
-                    vote.scaleValues(1.0 / (this.error[i] * this.error[i]));
-                }
-                combinedVote.addValues(vote);
-            }
-        }
-        return combinedVote.getArrayRef();
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        // TODO Auto-generated method stub
-    }
-    
-    @Override
-    public boolean isRandomizable() {
-        return true;
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return new Measurement[]{new Measurement("ensemble size",
-                    this.ensemble != null ? this.ensemble.length : 0)};
-    }
-    
-    @Override
-    public Classifier[] getSubClassifiers() {
-        return this.ensemble.clone();
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java.orig b/moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java.orig
deleted file mode 100644
index 15378090c..000000000
--- a/moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java.orig
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
- *    TemporallyAugmentedClassifier.java
- *    Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- *    @author Bernhard Pfahringer (bernhard@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.meta;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.LinkedList;
-import java.util.List;
-
-<<<<<<< HEAD
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Attribute;
-import com.yahoo.labs.samoa.instances.DenseInstance;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
-=======
-import com.yahoo.labs.samoa.instances.*;
->>>>>>> 3d07f07a8e1662963b332241c1fcfe85cebe0609
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.Classifier;
-import moa.core.Measurement;
-import moa.core.Utils;
-import moa.options.ClassOption;
-
-/**
- * Include labels of previous instances into the training data
- *
- * <p>This enables a classifier to exploit potentially present auto-correlation
- * </p>
- *
- * <p>Parameters:</p> <ul> <li>-l : Classifier to train</li> <li>-n : The number
- * of old labels to include</li> </ul>
- *
- * @author Bernhard Pfahringer (bernhard@cs.waikato.ac.nz)
- * @version $Revision: 1 $
- */
-public class TemporallyAugmentedClassifier extends AbstractClassifier {
-
-    @Override
-    public String getPurposeString() {
-        return "Add some old labels to every instance";
-    }
-    private static final long serialVersionUID = 1L;
-    
-    public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l',
-            "Classifier to train.", Classifier.class, "trees.HoeffdingTree");
-    
-    public IntOption numOldLabelsOption = new IntOption("numOldLabels", 'n',
-            "The number of old labels to add to each example.", 1, 0, Integer.MAX_VALUE);
-    
-    protected Classifier baseLearner;
-    
-    protected double[] oldLabels;
-    
-    protected InstancesHeader header;
-
-    public FlagOption labelDelayOption = new FlagOption("labelDelay", 'd',
-        "Labels arrive with Delay. Use predictions instead of true Labels.");
-    
-    @Override
-    public void resetLearningImpl() {
-        this.baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
-        this.oldLabels = new double[this.numOldLabelsOption.getValue()];
-        this.header = null;
-        baseLearner.resetLearning();
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance instance) {
-        this.baseLearner.trainOnInstance(extendWithOldLabels(instance));
-        if (this.labelDelayOption.isSet() == false) {
-            // Use true old Labels to add attributes to instances
-            addOldLabel(instance.classValue());
-        }
-    }
-
-    public void addOldLabel(double newPrediction) {
-        int numLabels = this.oldLabels.length;
-        if (numLabels > 0) {
-            for (int i = 1; i < numLabels; i++) {
-                this.oldLabels[i - 1] = this.oldLabels[i];
-            }
-            this.oldLabels[ numLabels - 1] = newPrediction;
-        }
-    }
-
-    public void initHeader(InstancesHeader dataset) {
-        int numLabels = this.numOldLabelsOption.getValue();
-        Attribute target = dataset.classAttribute();
-
-        List<String> possibleValues = new ArrayList<String>();
-        int n = target.numValues();
-        for (int i = 0; i < n; i++) {
-            possibleValues.add(target.value(i));
-        }
-
-        ArrayList<Attribute> attrs = new ArrayList<Attribute>(numLabels + dataset.numAttributes());
-        for (int i = 0; i < numLabels; i++) {
-            attrs.add(new Attribute(target.name() + "_" + i, possibleValues));
-        }
-        for (int i = 0; i < dataset.numAttributes(); i++) {
-            Attribute attr = dataset.attribute(i);
-            Attribute newAttribute = null;
-            if (attr.isNominal() == true) {
-                newAttribute = new Attribute(attr.name(), attr.getAttributeValues());
-            }
-            if (attr.isNumeric() == true) {
-                newAttribute = new Attribute(attr.name());
-            }
-            if (newAttribute != null) {
-                attrs.add(newAttribute);
-            }
-        }
-        this.header = new InstancesHeader("extended_" + dataset.getRelationName(), attrs, 0);
-        this.header.setClassIndex(numLabels + dataset.classIndex());
-    }
-
-    public Instance extendWithOldLabels(Instance instance) {
-        if (this.header == null) {
-            initHeader(instance.dataset());
-            this.baseLearner.setModelContext(new InstancesHeader(this.header));
-        }
-        int numLabels = this.oldLabels.length;
-        if (numLabels == 0) {
-            return instance;
-        }
-        double[] x = instance.toDoubleArray();
-        double[] x2 = Arrays.copyOfRange(this.oldLabels, 0, numLabels + x.length);
-        System.arraycopy(x, 0, x2, numLabels, x.length);
-        Instance extendedInstance = new DenseInstance(instance.weight(), x2);
-        extendedInstance.setDataset(this.header);
-        //System.out.println( extendedInstance);
-        return extendedInstance;
-    }
-
-    @Override
-    public Prediction getPredictionForInstance(Instance instance) {
-        double[] prediction = this.baseLearner.getPredictionForInstance(extendWithOldLabels(instance));
-        if (this.labelDelayOption.isSet() == true) {
-            // Use predicted Labels to add attributes to instances
-            addOldLabel(Utils.maxIndex(prediction));
-        }
-        return prediction;
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return false; // ??? this.baseLearner.isRandomizable;
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        List<Measurement> measurementList = new LinkedList<Measurement>();
-        Measurement[] modelMeasurements = ((AbstractClassifier) this.baseLearner).getModelMeasurements();
-        if (modelMeasurements != null) {
-            for (Measurement measurement : modelMeasurements) {
-                measurementList.add(measurement);
-            }
-        }
-        return measurementList.toArray(new Measurement[measurementList.size()]);
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    public String toString() {
-        return "TemporallyAugmentedClassifier using " + this.numOldLabelsOption.getValue() + " labels\n" + this.baseLearner;
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/mlc/MultilabelHoeffdingTree.java.orig b/moa/src/main/java/moa/classifiers/mlc/MultilabelHoeffdingTree.java.orig
deleted file mode 100644
index e0a4c43a7..000000000
--- a/moa/src/main/java/moa/classifiers/mlc/MultilabelHoeffdingTree.java.orig
+++ /dev/null
@@ -1,237 +0,0 @@
-/*
- *    MultilabelHoeffdingTree.java
- *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
- *    @author Jesse Read (jesse@tsc.uc3m.es)
- * 
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.multilabel;
-
-import java.util.LinkedList;
-import java.util.List;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-<<<<<<< HEAD
-=======
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.MultiLabelPrediction;
->>>>>>> 32d534d2e43c28db1711ab2fe7ff580d214e22fe
-import com.yahoo.labs.samoa.instances.Prediction;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-
-import moa.classifiers.Classifier;
-import moa.classifiers.MultiLabelClassifier;
-import moa.classifiers.MultiTargetRegressor;
-import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
-import moa.classifiers.trees.HoeffdingTree;
-import moa.core.Example;
-import moa.core.StringUtils;
-
-/**
- * Hoeffding Tree for classifying multi-label data.
- *
- * A Hoeffding tree is an incremental, anytime decision tree induction algorithm
- * that is capable of learning from massive data streams, assuming that the
- * distribution generating examples does not change over time.
- * 
- * 
- */ 
-public class MultilabelHoeffdingTree extends HoeffdingTreeClassifLeaves implements MultiLabelClassifier, MultiTargetRegressor, Classifier { 
-// Needs to use InfoGainSplitCriterionMultiLabel, since multilabel entropy is calculated in a different way 
-// Trains a mlinstance adding statistics of several class values and training node classifiers
-// Get votes from the classifier in the learning node of the tree
-
-	private static final long serialVersionUID = 1L;
-
-
-	/*public MultilabelHoeffdingTree() {
-		this.removePoorAttsOption = null;
-	}*/
-
-	@Override
-	protected LearningNode newLearningNode(double[] initialClassObservations) {
-		// Create new Learning Node with a null classifier
-		return new MultilabelLearningNodeClassifier(initialClassObservations,null,this);
-	}
-
-	//@Override
-	protected LearningNode newLearningNode(double[] initialClassObservations, Classifier cl) {
-		// Create new Learning Node
-		return new MultilabelLearningNodeClassifier(initialClassObservations,cl,this);
-	}
-
-	public static class MultilabelInactiveLearningNode extends InactiveLearningNode {
-
-		private static final long serialVersionUID = 1L;
-
-		public MultilabelInactiveLearningNode(double[] initialClassObservations) {
-			super(initialClassObservations);
-		}
-
-		@Override
-		public void learnFromInstance(Instance inst, HoeffdingTree ht) {
-			List<Integer> labels = ((MultilabelHoeffdingTree) ht).getRelevantLabels(inst);
-			for (int l : labels){
-				this.observedClassDistribution.addToValue(l, inst.weight());
-			}
-		}
-	}
-
-	public class MultilabelLearningNodeClassifier extends LearningNodeClassifier {
-		// It uses classifier at nodes, and to be able to train with several class values
-
-		private static final long serialVersionUID = 1L;
-
-		public MultilabelLearningNodeClassifier(double[] initialClassObservations, Classifier cl, MultilabelHoeffdingTree ht ) {
-			super(initialClassObservations);
-
-			if (cl== null) {
-				this.classifier = ((Classifier) getPreparedClassOption(ht.learnerOption)).copy();
-				this.classifier.resetLearning();
-
-				InstancesHeader raw_header = ht.getModelContext();
-				this.classifier.setModelContext(raw_header);
-			}
-			else{
-				this.classifier = cl.copy();
-			}
-		}
-
-		@Override
-		public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
-
-			return this.classifier.getPredictionForInstance(inst); 			
-		}
-
-		public Prediction getPredictionForInstance(Instance inst, HoeffdingTree ht) {
-
-			return this.classifier.getPredictionForInstance(inst);
-		}
-		
-		@Override
-		public void disableAttribute(int attIndex) {
-			// should not disable poor atts - they are used in NB calc
-		}
-
-		public Classifier getClassifier() {
-			return this.classifier;
-		}
-
-	    @Override
-		public void learnFromInstance(Instance inst, HoeffdingTree ht) {
-
-			//It uses different class values, not only one
-			this.classifier.trainOnInstance(inst);
-			MultilabelHoeffdingTree mht = ((MultilabelHoeffdingTree) ht);
-			List<Integer> labels = mht.getRelevantLabels(inst);
-			for (int l : labels){
-				this.observedClassDistribution.addToValue( l, inst.weight());
-			}
-
-			for (int i = 0; i < inst.numInputAttributes(); i++) {
-				int instAttIndex = i;
-				AttributeClassObserver obs = this.attributeObservers.get(instAttIndex); //i
-				if (obs == null) {
-					obs = inst.inputAttribute(i).isNominal() ? mht.newNominalClassObserver() : mht.newNumericClassObserver();
-					this.attributeObservers.set(i, obs);
-				}
-				for (int l : labels){
-					obs.observeAttributeClass(inst.valueInputAttribute(i), l, inst.weight());
-				}
-			}
-		}
-
-		public void describeSubtree(HoeffdingTree ht, StringBuilder out,
-									int indent) {
-			StringUtils.appendIndented(out, indent, "Leaf ");
-			out.append(" = ");
-			out.append(" weights: ");
-			this.observedClassDistribution.getSingleLineDescription(out,
-					this.observedClassDistribution.numValues());
-			StringUtils.appendNewline(out);
-		}
-	}
-
-	@Override
-	protected void deactivateLearningNode(ActiveLearningNode toDeactivate,
-			SplitNode parent, int parentBranch) {
-		//It uses MultilabelInactiveLearningNode since there are several class values
-		Node newLeaf = new MultilabelInactiveLearningNode(toDeactivate
-				.getObservedClassDistribution());
-		if (parent == null) {
-			this.treeRoot = newLeaf;
-		} else {
-			parent.setChild(parentBranch, newLeaf);
-		}
-		this.activeLeafNodeCount--;
-		this.inactiveLeafNodeCount++;
-	}
-
-
-	@Override
-	public Prediction getPredictionForInstance(Example<Instance> example) {
-		return getPredictionForInstance((StructuredInstance)example.getData());
-	}
-
-	public Prediction getPredictionForInstance(StructuredInstance inst) {
-		return getPredictionForInstance((Instance) inst);
-	}
-	
-	@Override
-	public Prediction getPredictionForInstance(Instance inst){
-
-		if (this.treeRoot != null) {
-			FoundNode foundNode = this.treeRoot.filterInstanceToLeaf(inst, null, -1);
-			Node leafNode = (MultilabelLearningNodeClassifier) foundNode.node;
-			MultilabelLearningNodeClassifier multilabelLeafNode = (MultilabelLearningNodeClassifier) leafNode;
-			if (leafNode == null) {
-				leafNode = foundNode.parent;
-			}
-			return multilabelLeafNode.getPredictionForInstance(inst, this);
-		}
-		else {
-			System.err.println("[WARNING] Root Node == Null !!!!!!");
-		}
-
-		// Return empty array (this should only happen once! -- before we build the root node).
-		return null;
-	}
-
-	@Override
-	public void trainOnInstance(Instance inst) {
-		boolean isTraining = (inst.weight() > 0.0);
-		if (isTraining) {
-			this.trainingWeightSeenByModel += inst.weight();
-			trainOnInstanceImpl((StructuredInstance) inst);
-		}
-	}
-
-	@Override
-	public void trainOnInstanceImpl(StructuredInstance instance) {
-		trainOnInstanceImpl((Instance) instance);
-	}
-        
-	public static List<Integer> getRelevantLabels(Instance x) {
-		List<Integer> classValues = new LinkedList<Integer>();
-		//get all class attributes
-		for (int j = 0; j < x.numberOutputTargets(); j++) {
-			if (x.classValue(j) > 0.0) {
-				classValues.add(j);
-			}
-		}
-		return classValues;
-	}
-}
diff --git a/moa/src/main/java/moa/classifiers/trees/ORTO2.java.orig b/moa/src/main/java/moa/classifiers/trees/ORTO2.java.orig
deleted file mode 100644
index 99b0cc910..000000000
--- a/moa/src/main/java/moa/classifiers/trees/ORTO2.java.orig
+++ /dev/null
@@ -1,543 +0,0 @@
-/*
- *    ORTO.java
- *    Copyright (C) 2015 Jožef Stefan Institute, Ljubljana, Slovenia
- *    @author Aljaž Osojnik <aljaz.osojnik@ijs.si>
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.classifiers.trees;
-
-import java.util.Arrays;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Stack;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.classifiers.Regressor;
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.core.AutoExpandVector;
-import moa.core.Measurement;
-import moa.core.StringUtils;
-<<<<<<< HEAD:moa/src/main/java/moa/classifiers/trees/ORTO2.java
-
-=======
->>>>>>> 32d534d2e43c28db1711ab2fe7ff580d214e22fe:moa/src/main/java/moa/classifiers/trees/ORTO2.java
-
-/*
- * Implementation of ORTO, option trees for data streams.
- */
-
-public class ORTO2 extends FIMTDD2 implements Regressor {
-
-	private static final long serialVersionUID = 1L;
-
-	private int innerNodeCount = 0;
-	private int optionNodeCount = 0;
-
-	private int numTrees = 1;
-
-
-	//region ================ OPTIONS ================
-
-	public IntOption maxTreesOption = new IntOption(
-			"maxTrees",
-			'm',
-			"The maximum number of trees contained in the option tree.",
-			10, 1, Integer.MAX_VALUE);
-
-	public IntOption maxOptionLevelOption = new IntOption(
-			"maxOptionLevel",
-			'x',
-			"The maximal depth at which option nodes can be created.",
-			10, 0, Integer.MAX_VALUE);
-
-	public FloatOption optionDecayFactorOption = new FloatOption(
-			"optionDecayFactor",
-			'z',
-			"The option decay factor that determines how many options can be selected at a given level.",
-			0.9, 0.0, 1.0);
-
-	public MultiChoiceOption optionNodeAggregationOption = new MultiChoiceOption(
-			"optionNodeAggregation",
-			'o',
-			"The aggregation method used to combine predictions in option nodes.", 
-			new String[]{"average", "bestTree"}, new String[]{"Average", "Best tree"}, 0);
-
-	public FloatOption optionFadingFactorOption = new FloatOption(
-			"optionFadingFactor",
-			'q',
-			"The fading factor used for comparing subtrees of an option node.",
-			0.9995, 0.0, 1.0);
-
-	//endregion ================ OPTIONS ================
-
-	//region ================ CLASSES ================
-
-	public static class OptionNode extends InnerNode {
-
-		private static final long serialVersionUID = 1L;
-
-		protected double[] optionFFSSL;
-		protected double[] optionFFSeen;
-
-		public OptionNode(FIMTDD2 tree) {
-			super(tree);
-		}
-		
-		public void resetFF() {
-			optionFFSSL = new double[children.size()];
-			optionFFSeen = new double[children.size()];
-			
-			for (int i = 0; i < children.size(); i++) {
-				optionFFSSL[i] = 0.0;
-				optionFFSeen[i] = 0.0;
-			}
-		}
-
-		public int getNumSubtrees() {
-			int num = 0;
-			for (Node child : children) {
-				num += child.getNumSubtrees();
-			}
-			return num;
-		}
-
-		public int directionForBestTree() {
-			int d = 0;
-			double tmp = 0.0, min = Double.MAX_VALUE;
-			for (int i = 0; i < children.size(); i++) {
-				tmp = getFFRatio(i);
-				if (tmp < min) {
-					min = tmp;
-					d = i;
-				}
-			}
-			return d;
-		}
-
-		public double getPrediction(Instance inst) {
-			double[] predictions = new double[numChildren()];
-			for (int i = 0; i < numChildren(); i++) {
-				predictions[i] = getChild(i).getPrediction(inst);
-			}
-			return aggregate(predictions);
-		}
-
-		private double aggregate(double[] predictions) {
-			if (((ORTO2) tree).optionNodeAggregationOption.getChosenIndex() == 0) { // Average
-				double sum = 0.0;
-				for (int i = 0; i < predictions.length; i++) {
-					sum += predictions[i];
-				}
-				return sum / predictions.length;
-			} else if (((ORTO2) tree).optionNodeAggregationOption.getChosenIndex() == 1) {
-				int d = directionForBestTree();
-				return predictions[d];
-			} else {
-				return 0.0;
-			}
-		}
-
-		public double getFFRatio(int childIndex) {
-			return optionFFSSL[childIndex] / optionFFSeen[childIndex];
-		}
-		
-		protected boolean skipInLevelCount() {
-			return true;
-		}
-		
-		@Override
-		public void describeSubtree(StringBuilder out, int indent) {
-			StringUtils.appendIndented(out, indent, "[option node]");
-			StringUtils.appendNewline(out);
-			for (int childIndex = 0; childIndex < children.size(); childIndex++) {
-				Node split = getChild(childIndex);
-				StringUtils.appendIndented(out, indent, "[" + childIndex + "]");
-				StringUtils.appendNewline(out);
-				split.describeSubtree(out, indent + 2);
-			}
-		}
-<<<<<<< HEAD:moa/src/main/java/moa/classifiers/trees/ORTO2.java
-
-=======
->>>>>>> 32d534d2e43c28db1711ab2fe7ff580d214e22fe:moa/src/main/java/moa/classifiers/trees/ORTO2.java
-	}
-
-	//endregion ================ CLASSES ================
-
-	//region ================ METHODS ================
-
-	// region --- Regressor methods
-
-	public String getPurposeString() {
-		return "Implementation of the ORTO tree as described by Ikonomovska et al.";
-	}
-
-	public void resetLearningImpl() {
-		super.resetLearningImpl();
-		this.innerNodeCount = 0;
-		this.optionNodeCount = 0;
-	}
-
-	
-	protected Measurement[] getModelMeasurementsImpl() {
-		return new Measurement[]{ 
-				new Measurement("number of subtrees", this.numTrees),
-				new Measurement("tree size (nodes)", this.leafNodeCount + this.innerNodeCount),
-				new Measurement("tree size (leaves)", this.leafNodeCount),
-				new Measurement("number of option nodes", this.optionNodeCount),};
-	}
-
-	public void processInstance(Instance inst, Node node, double prediction, double normalError, boolean growthAllowed, boolean inAlternate) {
-		if (node instanceof OptionNode) {
-			processInstanceOptionNode(inst, (OptionNode) node, prediction, normalError, growthAllowed, inAlternate);
-		} else {
-			Node currentNode = node;
-			while (true) {
-				if (currentNode instanceof LeafNode) {
-					((LeafNode) currentNode).learnFromInstance(inst, growthAllowed, prediction);
-					break;
-				} else {
-					currentNode.examplesSeen += inst.weight();
-					currentNode.sumOfAbsErrors += inst.weight() * normalError;
-					InnerNode iNode = (InnerNode) currentNode;
-					if (!inAlternate && iNode.alternateTree != null) {
-						boolean altTree = true;
-						double lossO = Math.pow(inst.classValue() - prediction, 2);
-						double lossA = Math.pow(inst.classValue() - iNode.alternateTree.getPrediction(inst), 2);
-						
-						// Loop for compatibility with bagging methods
-						for (int i = 0; i < inst.weight(); i++) {
-							iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
-							iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
-							iNode.lossExamplesSeen++;
-							
-							double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
-							iNode.lossSumQi += Qi;
-							iNode.lossNumQiTests += 1;
-						}
-						double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
-						double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
-						double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
-						
-						if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
-							iNode.previousWeight = iNode.lossExamplesSeen;
-							if (Qi > 0) {
-								// Switch the subtrees
-								Node parent = iNode.getParent();
-								
-								if (parent != null) {
-									Node replacementTree = iNode.alternateTree;
-									parent.setChild(parent.getChildIndex(iNode), replacementTree);
-									if (growthAllowed) replacementTree.restartChangeDetection();
-								} else {
-									treeRoot = iNode.alternateTree;
-									treeRoot.restartChangeDetection();
-								}
-								optionNodeCount += iNode.alternateTree.getNumSubtrees() - iNode.getNumSubtrees();
-								removeExcessTrees();
-										
-								currentNode = iNode.alternateTree;
-								currentNode.originalNode = null;
-								altTree = false;
-							} else if (QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * alternateTreeTMinOption.getValue()) || iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()) {
-								// Remove the alternate tree
-								iNode.alternateTree = null;
-								if (growthAllowed) iNode.restartChangeDetection();
-								altTree = false;
-							}
-						}
-						if (altTree) {
-							growthAllowed = false; // this is the growth of the original tree
-							processInstance(inst, iNode.alternateTree, prediction, normalError, true, true); // growth is allowed in the alt tree
-						} else if (currentNode instanceof OptionNode) {
-							// this happens when an option node is switched into the tree
-							for (Node child : ((OptionNode) currentNode).children) {
-								processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed, inAlternate);
-							}
-							break;
-						}
-					}
-				
-					if (iNode.changeDetection && !inAlternate) {
-						if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
-							iNode.initializeAlternateTree();
-						}
-					}
-					if (currentNode instanceof SplitNode) {
-						currentNode = ((SplitNode) currentNode).descendOneStep(inst);
-					} else if (currentNode instanceof OptionNode) {
-						processInstanceOptionNode(inst, (OptionNode) currentNode, prediction, normalError, growthAllowed, inAlternate);
-						break;
-					}
-				}
-			}
-		}
-		
-	}
-	
-	public void processInstanceOptionNode(Instance inst, OptionNode node, double prediction, double normalError, boolean growthAllowed, boolean inAlternate) {
-		node.examplesSeen += inst.weight();
-		node.sumOfAbsErrors += inst.weight() * normalError;
-<<<<<<< HEAD:moa/src/main/java/moa/classifiers/trees/ORTO2.java
-
-=======
->>>>>>> 32d534d2e43c28db1711ab2fe7ff580d214e22fe:moa/src/main/java/moa/classifiers/trees/ORTO2.java
-		if (node.changeDetection) {
-			double error = Math.abs(prediction - inst.classValue());
-			node.sumOfAbsErrors += error;
-			
-			if (((InnerNode) node).PageHinckleyTest(error - node.sumOfAbsErrors / node.examplesSeen + PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
-				node.initializeAlternateTree();
-				growthAllowed = false;
-			}
-		}
-
-		for (Node child : node.children) {
-			int index = node.getChildIndex(child);
-			double childPrediction = child.getPrediction(inst);
-
-			// Loop for compatibility with bagging methods
-			for (int i = 0; i < inst.weight(); i++) {
-				node.optionFFSeen[index] = node.optionFFSeen[index] * optionFadingFactorOption.getValue() + 1;
-				node.optionFFSSL[index] = node.optionFFSSL[index] * optionFadingFactorOption.getValue() + Math.pow(childPrediction - inst.classValue(), 2);
-			}
-		}
-
-		for (Node child : node.children) {
-			processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed && node.alternateTree == null, inAlternate);
-		}
-	}
-	
-	// endregion --- Regressor methods
-	
-	// region --- Object instantiation methods
-
-	protected OptionNode newOptionNode() {
-		maxID++;
-		return new OptionNode(this);
-	}
-	
-	// endregion --- Object instantiation methods
-
-	// region --- Processing methods
-
-	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex, Instance inst, double prediction) {
-		// Initialize the split criterion 
-		SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(splitCriterionOption);
-
-		// Using this criterion, find the best split per attribute and rank the results
-		AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion);
-		List<AttributeSplitSuggestion> acceptedSplits = new LinkedList<AttributeSplitSuggestion>();
-		Arrays.sort(bestSplitSuggestions);
-
-		// Declare a variable to determine the number of splits to be performed
-		int numSplits = 0;
-
-		// If only one split was returned, use it (this generally shouldn't happen)
-		if (bestSplitSuggestions.length == 1) {
-			numSplits = 1;
-			acceptedSplits.add(bestSplitSuggestions[0]);
-		} else if (bestSplitSuggestions.length > 1) { // Otherwise, consider which of the splits proposed may be worth trying
-
-			// Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
-			// to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
-			double hoeffdingBound = computeHoeffdingBound(1, splitConfidenceOption.getValue(), node.examplesSeen);
-
-			// Determine the top two ranked splitting suggestions
-			AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-			AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
-
-
-			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
-			// as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
-			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
-			// splitting should occur.
-			// Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
-			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
-			// competing attributes are equally good, and the split will be made on the one with the higher SDR value.
-			if (secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) {
-				numSplits = 1;
-				acceptedSplits.add(bestSuggestion);
-			} else if (numTrees < maxTreesOption.getValue() && node.getLevel() <= maxOptionLevelOption.getValue()) {
-				for (int i = 0; i < bestSplitSuggestions.length; i++) {
-					AttributeSplitSuggestion suggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1 - i];
-					if (suggestion.merit / bestSuggestion.merit >= 1 - hoeffdingBound) {
-						numSplits++;
-						acceptedSplits.add(suggestion);
-					} else {
-						break;
-					}
-				}
-			} else if (hoeffdingBound < tieThresholdOption.getValue()) {
-				numSplits = 1;
-				acceptedSplits.add(bestSuggestion);
-			} else { // If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
-				for (int i = 0; i < node.attributeObservers.size(); i++) {
-					AttributeClassObserver obs = node.attributeObservers.get(i);
-					if (obs != null) {
-						((FIMTDDNumericAttributeClassObserver) obs).removeBadSplits(splitCriterion, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound);    
-					}
-				}
-			}
-		}
-
-		// If the splitting criterion was met, split the current node using the chosen attribute test, and
-		// make two new branches leading to (empty) leaves
-		if (numSplits > 0) {
-			double optionFactor = numSplits * Math.pow(optionDecayFactorOption.getValue(), (double) node.getLevel());
-
-			if (numSplits == 1 || optionFactor < 2.0 || maxTreesOption.getValue() - numTrees <= 1) {
-				AttributeSplitSuggestion splitDecision = acceptedSplits.get(0);
-				SplitNode newSplit = newSplitNode(splitDecision.splitTest);
-				for (int i = 0; i < splitDecision.numSplits(); i++) {
-					LeafNode newChild = newLeafNode();
-					newChild.setParent(newSplit);
-					newSplit.setChild(i, newChild);
-				}
-				leafNodeCount--;
-				innerNodeCount++;
-				leafNodeCount += splitDecision.numSplits();
-				if (parent == null && node.originalNode == null) {
-					treeRoot = newSplit;
-				} else if (parent == null && node.originalNode != null) {
-					node.originalNode.alternateTree = newSplit;
-				} else {
-					parent.setChild(parentIndex, newSplit);
-					newSplit.setParent(parent);
-				}
-			} else {
-				OptionNode optionNode = newOptionNode();
-				leafNodeCount--;
-				int j = 0;
-
-				for (AttributeSplitSuggestion splitDecision : acceptedSplits) {
-					if (j > optionFactor || maxTreesOption.getValue() - numTrees <= 0) {
-						break;
-					}
-					SplitNode newSplit = newSplitNode(splitDecision.splitTest);
-					for (int i = 0; i < splitDecision.numSplits(); i++) {
-						LeafNode newChild = newLeafNode();
-						newChild.setParent(newSplit);
-						newSplit.setChild(i, newChild);
-					}
-
-					leafNodeCount += splitDecision.numSplits();
-					innerNodeCount++;
-					numTrees++;
-
-					newSplit.setParent(optionNode);
-					optionNode.setChild(j, newSplit);
-					j++;
-				}
-
-				innerNodeCount++;
-				optionNodeCount++;
-
-				if (parent == null) {
-					treeRoot = optionNode;
-				} else {
-					parent.setChild(parentIndex, optionNode);
-					optionNode.setParent(parent);
-				}
-
-				optionNode.resetFF();
-			}
-		}
-	}
-
-	// endregion --- Processing methods 
-	
-	// region --- Option tree methods
-	protected Node findWorstOption() {
-		Stack<Node> stack = new Stack<Node>();
-		stack.add(treeRoot);
-
-		double ratio = Double.MIN_VALUE;
-		Node out = null;
-
-		while (!stack.empty()) {
-			Node node = stack.pop();
-			if (node.getParent() instanceof OptionNode) {
-				OptionNode myParent = (OptionNode) node.getParent();
-				int nodeIndex = myParent.getChildIndex(node);
-				double nodeRatio = myParent.getFFRatio(nodeIndex); 
-
-				if (nodeRatio > ratio) {
-					ratio = nodeRatio;
-					out = node;
-				}
-			}
-			if (node instanceof InnerNode) {
-				for (Node child : ((InnerNode) node).children) {
-					stack.add(child);
-				}
-			}
-		}
-
-		return out;
-	}
-
-	protected void removeExcessTrees() {
-		while (numTrees > maxTreesOption.getValue()) {
-			Node option = findWorstOption();
-			OptionNode parent = (OptionNode) option.parent;
-			int index = parent.getChildIndex(option);
-
-			if (parent.children.size() == 2) {
-				parent.children.remove(index);
-				for (Node chld : parent.children) {
-					chld.parent = parent.parent;
-					parent.parent.setChild(parent.parent.getChildIndex(parent), chld);
-				}
-			} else {
-				AutoExpandVector<Node> children = new AutoExpandVector<Node>();
-				double[] optionFFSSL = new double[parent.children.size() - 1];
-				double[] optionFFSeen = new double[parent.children.size() - 1];
-
-				int seen = 0;
-
-				for (int i = 0; i < parent.children.size() - 1; i++) {
-					if (parent.getChild(i) != option) {
-						children.add(parent.getChild(i));
-						optionFFSSL[i] = parent.optionFFSSL[i + seen];
-						optionFFSeen[i] = parent.optionFFSeen[i + seen];
-					} else {
-						seen = 1;
-					}
-				}
-
-				parent.children = children;
-				parent.optionFFSSL = optionFFSSL;
-				parent.optionFFSeen = optionFFSeen;
-
-				assert parent.children.size() == parent.optionFFSSL.length;
-			}
-			numTrees--;
-		}
-	}
-	
-	// endregion --- Option tree methods
-	
-	//endregion ================ METHODS ================
-}
diff --git a/moa/src/main/java/moa/clusterers/clustree/ClusTree.java.orig b/moa/src/main/java/moa/clusterers/clustree/ClusTree.java.orig
deleted file mode 100644
index ed142e454..000000000
--- a/moa/src/main/java/moa/clusterers/clustree/ClusTree.java.orig
+++ /dev/null
@@ -1,891 +0,0 @@
-/*
- *    ClusTree.java
- *    Copyright (C) 2010 RWTH Aachen University, Germany
- *    @author Sanchez Villaamil (moa@cs.rwth-aachen.de)
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.clustree;
-
-import java.util.ArrayList;
-
-import java.util.LinkedList;
-import moa.clusterers.clustree.util.*;
-import moa.cluster.Clustering;
-import moa.clusterers.AbstractClusterer;
-import moa.core.Measurement;
-<<<<<<< Updated upstream
-<<<<<<< HEAD
-=======
-<<<<<<< c4a46917f06a4f4c3c08e67d06f6762cca1b47f9
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.FlagOption;
-import com.yahoo.labs.samoa.instances.Instance;
-=======
->>>>>>> Instances rework, new iSOUPTree models and import cleanup
->>>>>>> 32d534d2e43c28db1711ab2fe7ff580d214e22fe
-=======
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.FlagOption;
-import com.yahoo.labs.samoa.instances.Instance;
->>>>>>> Stashed changes
-
-/**
- * Citation: ClusTree: Philipp Kranen, Ira Assent, Corinna Baldauf, Thomas Seidl:
- * The ClusTree: indexing micro-clusters for anytime stream mining.
- * Knowl. Inf. Syst. 29(2): 249-272 (2011) 
-*/
-public class ClusTree extends AbstractClusterer{
-	private static final long serialVersionUID = 1L;
-	
-	public IntOption horizonOption = new IntOption("horizon",
-			'h', "Range of the window.", 1000);
-
-    public IntOption maxHeightOption = new IntOption(
-			"maxHeight", 'H',
-			"The maximal height of the tree", getDefaultHeight());
-
-	public FlagOption breadthFirstStrategyOption = new FlagOption(
-			"breadthFirstStrategy", 'B',
-			"Use breadth first strategy");
-    
-    public FlagOption breadthFirstStrategyOption = new FlagOption(
-			"breadthFirstStrategy", 'B',
-			"Use breadth first strategy");
-    
-    protected int getDefaultHeight() {
-    	return 8;
-    }
-    
-    private static int INSERTIONS_BETWEEN_CLEANUPS = 10000;
-    /**
-     * The root node of the tree.
-     */
-    protected Node root;
-    // Information about the data represented in this tree.
-    /**
-     * Dimensionality of the data points managed by this tree.
-     */
-    private int numberDimensions;
-    /**
-     * Parameter for the weighting function use to weight the entries.
-     */
-    protected double negLambda;
-    /**
-     * The current height of the tree. Should always be smaller than maxHeight.
-     */
-    private int height;
-    /**
-     * The maximal height of the tree.
-     */
-    protected int maxHeight;
-    /**
-     * This variable is used to keep the inverse height that is stored in every
-     * node correct.
-     */
-    private int numRootSplits;
-    /**
-     * The threshold for the weighting of an Entry. An Entry is irrelevant, if
-     * it is in a leaf and the weightedN of the data Cluster is smaller than
-     * this threshold.
-     * @see Entry#data
-     */
-    private double weightThreshold = 0.05;
-    /**
-     * Number of points inserted into the tree.
-     */
-    private int numberInsertions;
-    private long timestamp;
-
-    /**
-     * Parameter to determine wich strategy to use
-     */
-    protected boolean breadthFirstStrat = false;
-    
-    //TODO: cleanup
-    private Entry alsoUpdate;
-    
-    @Override
-    public void resetLearningImpl() {
-        breadthFirstStrat = breadthFirstStrategyOption.isSet();
-        negLambda = (1.0 / (double) horizonOption.getValue())
-                * (Math.log(weightThreshold) / Math.log(2));
-        maxHeight = maxHeightOption.getValue();
-        numberDimensions = -1;
-        root = null;
-        timestamp = 0;
-        height = 0;
-        numRootSplits = 0;
-        numberInsertions = 0;
-    }
-
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return null;
-    }
-
-    public boolean isRandomizable() {
-        return false;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-    }
-
-    public Prediction getPredictionForInstance(Instance inst) {
-        return null;
-    }
-
-    @Override
-    public boolean implementsMicroClusterer() {
-        return true;
-    }
-
-
-
-    @Override
-    public void trainOnInstanceImpl(Instance instance) {
-        timestamp++;
-        
-        //TODO check if instance contains label
-        if(root == null){
-            numberDimensions = instance.numAttributes();
-            root = new Node(numberDimensions, 0);
-        }
-        else{
-            if(numberDimensions!=instance.numAttributes())
-                System.out.println("Wrong dimensionality, expected:"+numberDimensions+ "found:"+instance.numAttributes());
-        }
-
-        ClusKernel newPointAsKernel = new ClusKernel(instance.toDoubleArray(), numberDimensions);
-        insert(newPointAsKernel, new SimpleBudget(1000),timestamp);
-    }
-
-
-    /**
-     * Insert a new point in the <code>Tree</code>. The point should be 
-     * represented as a cluster with a single data point(i.e. N = 1). A
-     * <code>Budget</code> class is also given, which is informed of the number
-     * of operation the tree does, and informs the tree when it does not have
-     * time left and should stop the insertion.
-     * @param newPoint The point to be inserted.
-     * @param budget The budget and statistics recollector for the insertion.
-     * @param timestamp The moment at which this point is inserted.
-     * @see Kernel
-     * @see Budget
-     */
-    public void insert(ClusKernel newPoint, Budget budget, long timestamp) {
-        if (breadthFirstStrat){
-          	insertBreadthFirst(newPoint, budget, timestamp);
-       }
-        else{
-	    	Entry rootEntry = new Entry(this.numberDimensions,
-	                root, timestamp, null, null);
-	        ClusKernel carriedBuffer = new ClusKernel(this.numberDimensions);
-	        Entry toInsertHere = insert(newPoint, carriedBuffer, root, rootEntry,
-	                budget, timestamp);
-	
-	        if (toInsertHere != null) {
-	            this.numRootSplits++;
-	            this.height += this.height < this.maxHeight ? 1 : 0;
-	            
-	            Node newRoot = new Node(this.numberDimensions,
-	                    toInsertHere.getChild().getRawLevel() + 1);
-	            newRoot.addEntry(rootEntry, timestamp);
-	            newRoot.addEntry(toInsertHere, timestamp);
-	            rootEntry.setNode(newRoot);
-	            toInsertHere.setNode(newRoot);
-	            this.root = newRoot;
-	        }
-        }
-
-        this.numberInsertions++;
-        if (this.numberInsertions % INSERTIONS_BETWEEN_CLEANUPS == 0) {
-            cleanUp(this.root, 0);
-        }
-    }
-
-    /**
-     * insert newPoint into the tree using the BreadthFirst strategy, i.e.: insert into
-     * the closest entry in a leaf node.
-     * @param newPoint
-     * @param budget
-     * @param timestamp
-     * @return
-     */
-	private Entry insertBreadthFirst(ClusKernel newPoint, Budget budget, long timestamp) {
-    	//check all leaf nodes and get the one with the closest entry to newPoint
-		Node bestFit = findBestLeafNode(newPoint);
-    	bestFit.makeOlder(timestamp, negLambda);
-    	Entry parent = bestFit.getEntries()[0].getParentEntry(); 	
-    	// Search for an Entry with a weight under the threshold.
-   	    Entry irrelevantEntry = bestFit.getIrrelevantEntry(this.weightThreshold);
-        int numFreeEntries = bestFit.numFreeEntries();
-        Entry newEntry = new Entry(newPoint.getCenter().length,
-    			newPoint, timestamp, parent, bestFit);
-        //if there is space, add it to the node ( doesn't ever occur, since nodes are created with 3 entries) 
-        if (numFreeEntries>0){
-        	bestFit.addEntry(newEntry, timestamp);
-        }
-        //if outdated cluster in this best fitting node, replace it
-         else if (irrelevantEntry != null) {
-	        irrelevantEntry.overwriteOldEntry(newEntry);
-        }
-        //if there is space/outdated cluster on path to top, split. Else merge without split
-        else {
-        	if (existsOutdatedEntryOnPath(bestFit)||!this.hasMaximalSize()){
-	            // We have to split.
-	        	insertHereWithSplit(newEntry, bestFit, timestamp);
-	        }
-        	else {
-	            mergeEntryWithoutSplit(bestFit, newEntry,
-	                    timestamp);
-	        }
-        }
-        //update all nodes on path to top.
-        if (bestFit.getEntries()[0].getParentEntry()!=null)
-        	updateToTop(bestFit.getEntries()[0].getParentEntry().getNode());
-        return null;
-    }
- /**
-  * This method checks if there is an outdated (or empty) entry on the path from node to root.
-  * It updates the weights of nodes on path and then checks if it is outdated.
-  * @param node
-  * @return true if an outdated/empty entry exists on the path
-  */
-	private boolean existsOutdatedEntryOnPath(Node node) {
-    	if (node == root){
-    		node.makeOlder(timestamp, negLambda);
-    		return node.getIrrelevantEntry(this.weightThreshold)!=null;
-    	}
-    	do{
-    		node = node.getEntries()[0].getParentEntry().getNode();
-    		node.makeOlder(timestamp, negLambda);
-    		for (Entry e : node.getEntries()){
-    			e.recalculateData();
-    		}
-    		if (node.numFreeEntries()>0)
-    			return true;
-    		if (node.getIrrelevantEntry(this.weightThreshold)!=null)
-    			return true;
-    	}while(node.getEntries()[0].getParentEntry()!=null);
-		return false;
-	}
-    
-    /**
-     * recalculates data for all entries, that lie on the path from the root to the 
-     * Entry toUpdate.
-     */
-	private void updateToTop(Node toUpdate) {
-    	while(toUpdate!=null){
-    		for (Entry e: toUpdate.getEntries())
-    			e.recalculateData();
-    		if (toUpdate.getEntries()[0].getParentEntry()==null)
-    			break;
-    		toUpdate=toUpdate.getEntries()[0].getParentEntry().getNode();
-    	}
-	}
-
-	/**
-	 * Method called by insertBreadthFirst.
-	 * @param toInsert
-	 * @param insertNode
-	 * @param timestamp
-	 * @return
-	 */
-	private Entry insertHereWithSplit(Entry toInsert, Node insertNode,
-			long timestamp) {
-		//Handle root split
-   	    if (insertNode.getEntries()[0].getParentEntry()==null){
-   	    	root.makeOlder(timestamp, negLambda);
-   	    	Entry irrelevantEntry = insertNode.getIrrelevantEntry(this.weightThreshold);
-   	        int numFreeEntries = insertNode.numFreeEntries();
-   	        if (irrelevantEntry != null) {
-   		        irrelevantEntry.overwriteOldEntry(toInsert);
-   	        }
-   	        else if (numFreeEntries>0){
-   	        	insertNode.addEntry(toInsert, timestamp);
-   	        }
-   	        else{
-	            this.numRootSplits++;
-	            this.height += this.height < this.maxHeight ? 1 : 0;
-	            Entry oldRootEntry = new Entry(this.numberDimensions,
-	                    root, timestamp, null, null);
-	            Node newRoot = new Node(this.numberDimensions,
-	                    this.height);
-	            Entry newRootEntry = split(toInsert, root, oldRootEntry, timestamp);
-	            newRoot.addEntry(oldRootEntry, timestamp);
-	            newRoot.addEntry(newRootEntry, timestamp);
-	            this.root = newRoot;
-	            for (Entry c : oldRootEntry.getChild().getEntries())
-	            	c.setParentEntry(root.getEntries()[0]);
-	            for (Entry c : newRootEntry.getChild().getEntries())
-	            	c.setParentEntry(root.getEntries()[1]);
-   	        }
-            return null;
-   	    }
-   	    insertNode.makeOlder(timestamp, negLambda);
-    	Entry irrelevantEntry = insertNode.getIrrelevantEntry(this.weightThreshold);
-        int numFreeEntries = insertNode.numFreeEntries();
-        if (irrelevantEntry != null) {
-	        irrelevantEntry.overwriteOldEntry(toInsert);
-        }
-        else if (numFreeEntries>0){
-        	insertNode.addEntry(toInsert, timestamp);
-        }
-        else {
-	            // We have to split.
-	        	Entry parentEntry = insertNode.getEntries()[0].getParentEntry();
-	        	Entry residualEntry = split(toInsert, insertNode, parentEntry, timestamp);
-	        	if (alsoUpdate!=null){
-	        		alsoUpdate = residualEntry;
-	        	}
-	        	Node nodeForResidualEntry = insertNode.getEntries()[0].getParentEntry().getNode();
-	        	//recursive call
-	        	return insertHereWithSplit(residualEntry, nodeForResidualEntry, timestamp);
-	    }
-        
-        //no Split
-        return null;
-	}
-
-
-	// XXX: Document the insertion when the final implementation is done.
-	private Entry insertHere(Entry newEntry, Node currentNode,
-	        Entry parentEntry, ClusKernel carriedBuffer, Budget budget,
-	        long timestamp) {
-	
-	    int numFreeEntries = currentNode.numFreeEntries();
-	
-	    // Insert the buffer that we carry.
-	    if (!carriedBuffer.isEmpty()) {
-	        Entry bufferEntry = new Entry(this.numberDimensions,
-	                carriedBuffer, timestamp, parentEntry, currentNode);
-	
-	        if (numFreeEntries <= 1) {
-	            // Distance from buffer to entries.
-	            Entry nearestEntryToCarriedBuffer =
-	                    currentNode.nearestEntry(newEntry);
-	            double distanceNearestEntryToBuffer =
-	                    nearestEntryToCarriedBuffer.calcDistance(newEntry);
-	
-	            // Distance between buffer and point to insert.
-	            double distanceBufferNewEntry =
-	                    newEntry.calcDistance(carriedBuffer);
-	
-	            // Best distance between Entrys in the Node.
-	            BestMergeInNode bestMergeInNode =
-	                    calculateBestMergeInNode(currentNode);
-	
-	            // See what the minimal distance is and do the correspoding
-	            // action.
-	            if (distanceNearestEntryToBuffer <= distanceBufferNewEntry
-	                    && distanceNearestEntryToBuffer <= bestMergeInNode.distance) {
-	                // Aggregate buffer entry to nearest entry in node.
-	                nearestEntryToCarriedBuffer.aggregateEntry(bufferEntry,
-	                        timestamp, this.negLambda);
-	            } else if (distanceBufferNewEntry <= distanceNearestEntryToBuffer
-	                    && distanceBufferNewEntry <= bestMergeInNode.distance) {
-	                newEntry.mergeWith(bufferEntry);
-	            } else {
-	                currentNode.mergeEntries(bestMergeInNode.entryPos1,
-	                        bestMergeInNode.entryPos2);
-	                currentNode.addEntry(bufferEntry, timestamp);
-	            }
-	
-	        } else {
-	            assert (currentNode.isLeaf());
-	            currentNode.addEntry(bufferEntry, timestamp);
-	        }
-	    }
-	
-	    // Normally the insertion of the carries buffer does not change the
-	    // number of free entries, but in case of future changes we calculate
-	    // the number again.
-	    numFreeEntries = currentNode.numFreeEntries();
-	
-	    // Search for an Entry with a weight under the threshold.
-	    Entry irrelevantEntry = currentNode.getIrrelevantEntry(this.weightThreshold);
-	    if (currentNode.isLeaf() && irrelevantEntry != null) {
-	        irrelevantEntry.overwriteOldEntry(newEntry);
-	    } else if (numFreeEntries >= 1) {
-	        currentNode.addEntry(newEntry, timestamp);
-	    } else {
-	        if (currentNode.isLeaf() && (this.hasMaximalSize()
-	                || !budget.hasMoreTime())) {
-	            mergeEntryWithoutSplit(currentNode, newEntry,
-	                    timestamp);
-	        } else {
-	            // We have to split.
-	            return split(newEntry, currentNode, parentEntry, timestamp);
-	        }
-	    }
-	
-	    return null;
-	}
-
-	/**
-	 * This method calculates the distances between the new point and each Entry in a leaf node.
-	 * It returns the node that contains the entry with the smallest distance
-	 * to the new point.
-	 * @param newPoint
-	 * @return best fitting node
-	 */
-	private Node findBestLeafNode(ClusKernel newPoint) {
-    	double minDist = Double.MAX_VALUE;
-    	Node bestFit = null;
-    	for (Node e: collectLeafNodes(root)){
-    		if (newPoint.calcDistance(e.nearestEntry(newPoint).getData())<minDist){
-    			bestFit = e;
-    			minDist = newPoint.calcDistance(e.nearestEntry(newPoint).getData());
-    		}
-    	}
-    	if (bestFit!=null)
-    		return bestFit;
-    	else
-    		return root;
-	}
-    
-    private ArrayList<Node> collectLeafNodes(Node curr){
-    	ArrayList<Node> toReturn = new ArrayList<Node>();
-    	if (curr==null)
-    		return toReturn;
-    	if	(curr.isLeaf()){
-    		toReturn.add(curr);
-    		return toReturn;
-    	}
-    	else{
-    		for (Entry e : curr.getEntries())
-    			toReturn.addAll(collectLeafNodes(e.getChild()));
-    		return toReturn;
-    	}
-    }
-
-	// TODO: Expand all function that work on entries to work with the Budget.
-    private Entry insert(ClusKernel pointToInsert, ClusKernel carriedBuffer,
-            Node currentNode, Entry parentEntry, Budget budget, long timestamp) {
-        assert (currentNode != null);
-        assert (currentNode.isLeaf()
-                || currentNode.getEntries()[0].getChild() != null);
-
-        currentNode.makeOlder(timestamp, this.negLambda);
-
-        // This variable will be changed from to null to an actual reference
-        // in the following if-else block if we have to insert something here,
-        // either because this is a leaf, or because of split propagation.
-        Entry toInsertHere = null;
-
-        if (currentNode.isLeaf()) {
-            // At the end of the function the entry will be inserted.
-            toInsertHere = new Entry(this.numberDimensions,
-                    pointToInsert, timestamp, parentEntry, currentNode);
-        } else {
-
-            Entry bestEntry = currentNode.nearestEntry(pointToInsert);
-            bestEntry.aggregateCluster(pointToInsert, timestamp,
-                    this.negLambda);
-
-            boolean isCarriedBufferEmpty = carriedBuffer.isEmpty();
-
-            Entry bestBufferEntry = null;
-            if (!isCarriedBufferEmpty) {
-                bestBufferEntry = currentNode.nearestEntry(carriedBuffer);
-                bestBufferEntry.aggregateCluster(carriedBuffer, timestamp,
-                        this.negLambda);
-            }
-
-            if (!budget.hasMoreTime()) {
-                bestEntry.aggregateToBuffer(pointToInsert, timestamp,
-                        this.negLambda);
-                if (!isCarriedBufferEmpty) {
-                    bestBufferEntry.aggregateToBuffer(carriedBuffer,
-                            timestamp, this.negLambda);
-                }
-                return null;
-            }
-
-            // If the way of the buffer differs from the way of the point to
-            // be inserted, leave the buffer here.
-            if (!isCarriedBufferEmpty && (bestEntry != bestBufferEntry)) {
-                bestBufferEntry.aggregateToBuffer(carriedBuffer, timestamp,
-                        this.negLambda);
-                carriedBuffer.clear();
-            }
-            // Take the buffer of the best entry for the point to be inserted
-            // along.
-            ClusKernel takeAlongBuffer = bestEntry.emptyBuffer(timestamp,
-                    this.negLambda);
-            carriedBuffer.add(takeAlongBuffer);
-
-            // Recursive call.
-            toInsertHere = insert(pointToInsert, carriedBuffer,
-                    bestEntry.getChild(), bestEntry, budget, timestamp);
-        }
-
-        // If the above block has a new Entry for this place insert it.
-        if (toInsertHere != null) {
-            return this.insertHere(toInsertHere, currentNode, parentEntry,
-                    carriedBuffer, budget, timestamp);
-        }
-
-        // If nothing else needs to be done in all the above levels
-        // return null to signalize it.
-        return null;
-    }
-
-    /**
-     * Inserts an <code>Entry</code> into a <code>Node</code> without inducing
-     * a split.
-     * @param node The node at which the entry is to be inserted.
-     * @param newEntry The entry to be inserted.
-     * @param timestamp The moment at which this occurs.
-     */
-    private void mergeEntryWithoutSplit(Node node,
-            Entry newEntry, long timestamp) {
-
-        Entry nearestEntryToCarriedBuffer =
-                node.nearestEntry(newEntry);
-        double distanceNearestEntryToBuffer =
-                nearestEntryToCarriedBuffer.calcDistance(newEntry);
-
-        BestMergeInNode bestMergeInNode =
-                calculateBestMergeInNode(node);
-
-        if (distanceNearestEntryToBuffer < bestMergeInNode.distance) {
-            nearestEntryToCarriedBuffer.aggregateEntry(newEntry, timestamp,
-                    this.negLambda);
-        } else {
-            node.mergeEntries(bestMergeInNode.entryPos1,
-                    bestMergeInNode.entryPos2);
-            node.addEntry(newEntry, timestamp);
-        }
-    }
-
-    /**
-     * Calculates the best merge possible between two nodes in a node. This
-     * means that the pair with the smallest distance is found.
-     * @param node The node in which these two entries have to be found.
-     * @return An object which encodes the two position of the entries with the
-     * smallest distance in the node and the distance between them.
-     * @see BestMergeInNode
-     * @see Entry#calcDistance(tree.Entry) 
-     */
-    private BestMergeInNode calculateBestMergeInNode(Node node) {
-        assert (node.numFreeEntries() == 0);
-
-        Entry[] entries = node.getEntries();
-
-        int toMerge1 = -1;
-        int toMerge2 = -1;
-        double distanceBetweenMergeEntries = Double.NaN;
-
-        double minDistance = Double.MAX_VALUE;
-        for (int i = 0; i < entries.length; i++) {
-            Entry e1 = entries[i];
-            for (int j = i + 1; j < entries.length; j++) {
-                Entry e2 = entries[j];
-                double distance = e1.calcDistance(e2);
-                if (distance < minDistance) {
-                    toMerge1 = i;
-                    toMerge2 = j;
-                    distanceBetweenMergeEntries = distance;
-                }
-            }
-        }
-
-        assert (toMerge1 != -1 && toMerge2 != -1);
-        if (Double.isNaN(distanceBetweenMergeEntries)) {
-            throw new RuntimeException("The minimal distance between two "
-                    + "Entrys in a Node was Double.MAX_VAUE. That can hardly "
-                    + "be right.");
-        }
-
-        return new BestMergeInNode(toMerge1, toMerge2,
-                distanceBetweenMergeEntries);
-    }
-
-    private boolean hasMaximalSize() {
-        // TODO: Improve hasMaximalSize(). For now it just works somehow for testing.
-        return this.height == this.maxHeight;
-    }
-
-    /**
-     * Performs a (2,2) split on the given node with the given entry. This
-     * implementation only works if the nodes have three entries each. The split
-     * will generate two new nodes. One of them will be put where the old node
-     * was, and for the other a new <code>Entry</code> will be generated and
-     * returned.
-     * @param newEntry The entry to be added to the node.
-     * @param node The node that is going to be splitted.
-     * @param parentEntry The entry in the tree that points at the node that
-     * is going to be splitted.
-     * @param timestamp The moment at which this split occurs.
-     * @return An entry which points at the second node created in the split.
-     * This entry has to be introduced later in the tree.
-     */
-    private Entry split(Entry newEntry, Node node, Entry parentEntry,
-            long timestamp) {
-        // The implemented split function only works in trees where node
-        // have three entries.
-        // Splitting only makes sense on full nodes.
-        assert (node.numFreeEntries() == 0);
-        assert (parentEntry.getChild() == node);
-
-        // All the entries we have to separate in two nodes.
-        Entry[] allEntries = new Entry[4];
-        Entry[] nodeEntries = node.getEntries();
-        for (int i = 0; i < nodeEntries.length; i++) {
-            allEntries[i] = new Entry(nodeEntries[i]);
-        }
-        allEntries[3] = newEntry;
-
-        // Clear the given node, since we are going to refill it later.
-        node = new Node(this.numberDimensions, node.getRawLevel());
-
-        // Calculate the distance of all the possible pairings, since we want
-        // to do a (2,2) split.
-        double select01 = allEntries[0].calcDistance(allEntries[1])
-                + allEntries[2].calcDistance(allEntries[3]);
-
-        double select02 = allEntries[0].calcDistance(allEntries[2])
-                + allEntries[1].calcDistance(allEntries[3]);
-
-        double select03 = allEntries[0].calcDistance(allEntries[3])
-                + allEntries[1].calcDistance(allEntries[2]);
-
-        // See which of the pairings is minimal and distribute the entries
-        // accordingly.
-        Node residualNode = new Node(this.numberDimensions,
-                node.getRawLevel());
-        if (select01 < select02) {
-            if (select01 < select03) {//select01 smallest
-                node.addEntry(allEntries[0], timestamp);
-                node.addEntry(allEntries[1], timestamp);
-                residualNode.addEntry(allEntries[2], timestamp);
-                residualNode.addEntry(allEntries[3], timestamp);
-            } else {//select03 smallest
-                node.addEntry(allEntries[0], timestamp);
-                node.addEntry(allEntries[3], timestamp);
-                residualNode.addEntry(allEntries[1], timestamp);
-                residualNode.addEntry(allEntries[2], timestamp);
-            }
-        } else {
-            if (select02 < select03) {//select02 smallest
-                node.addEntry(allEntries[0], timestamp);
-                node.addEntry(allEntries[2], timestamp);
-                residualNode.addEntry(allEntries[1], timestamp);
-                residualNode.addEntry(allEntries[3], timestamp);
-            } else {//select03 smallest
-                node.addEntry(allEntries[0], timestamp);
-                node.addEntry(allEntries[3], timestamp);
-                residualNode.addEntry(allEntries[1], timestamp);
-                residualNode.addEntry(allEntries[2], timestamp);
-            }
-        }
-
-        // Set the other node into the tree.
-        parentEntry.setChild(node);
-        parentEntry.recalculateData();
-        int count = 0;
-        for (Entry e : node.getEntries()){
-        	e.setParentEntry(parentEntry);
-        	if (e.getData().getN() != 0)
-        		count++;
-        }
-        //System.out.println(count);
-        // Generate a new entry for the residual node.
-        Entry residualEntry = new Entry(this.numberDimensions,
-                residualNode, timestamp, parentEntry, node);
-        count=0;
-        for (Entry e: residualNode.getEntries()){
-        	e.setParentEntry(residualEntry);
-        	if (e.getData().getN() != 0)
-        		count++;
-        }
-        //System.out.println(count);
-        return residualEntry;
-    }
-
-    /**
-     * Return the number of time the tree has grown in size. If the tree grows
-     * and is then cutted from a certain depth, it also counts.
-     * @return The number of times the root node was splitted.
-     */
-    public int getNumRootSplits() {
-        return numRootSplits;
-    }
-
-    /**
-     * Return the current height of the tree. This should never be greater than
-     * <code>maxHeight</code>.
-     * @return The height of the tree.
-     * @see #maxHeight
-     */
-    public int getHeight() {
-        assert (height <= maxHeight);
-        return height;
-    }
-
-    private void cleanUp(Node currentNode, int level) {
-        if (currentNode == null) {
-            return;
-        }
-
-        Entry[] entries = currentNode.getEntries();
-        if (level == this.maxHeight) {
-            for (int i = 0; i < entries.length; i++) {
-                Entry e = entries[i];
-                e.setChild(null);
-            }
-        } else {
-            for (int i = 0; i < entries.length; i++) {
-                Entry e = entries[i];
-                cleanUp(e.getChild(), level + 1);
-            }
-        }
-    }
-
-    /**
-     * @param currentTime The current time
-     * @return The kernels at the leaf level as a clustering
-     */
-    //TODO: Microcluster unter dem Threshhold nich zur�ckgeben (WIe bei outdated entries)
-    @Override
-    public Clustering getMicroClusteringResult() {
-        return getClustering(timestamp, -1);
-    }
-
-    @Override
-    public Clustering getClusteringResult() {
-        return null;
-    }
-
-
-    /**
-     * @param currentTime The current time
-     * @return The kernels at the given level as a clustering.
-     */
-    public Clustering getClustering(long currentTime, int targetLevel) {
-        if (root == null) {
-            return null;
-        }
-
-        Clustering clusters = new Clustering();
-        LinkedList<Node> queue = new LinkedList<Node>();
-        queue.add(root);
-
-        while (!queue.isEmpty()) {
-            Node current = queue.remove();
-           // if (current == null)
-           // 	continue;
-            int currentLevel = current.getLevel(this);
-            boolean isLeaf = (current.isLeaf() && currentLevel <= maxHeight)
-                    || currentLevel == maxHeight;
-
-            if (currentLevel == targetLevel
-                    || (targetLevel == - 1 && isLeaf)) {
-                assert (currentLevel <= maxHeight);
-
-                Entry[] entries = current.getEntries();
-                for (int i = 0; i < entries.length; i++) {
-                    Entry entry = entries[i];
-                    if (entry == null || entry.isEmpty()) {
-                        continue;
-                    }
-                    // XXX
-                    entry.makeOlder(currentTime, this.negLambda);
-                    if (entry.isIrrelevant(this.weightThreshold))
-                    	continue;
-
-                    ClusKernel gaussKernel = new ClusKernel(entry.getData());
-
-//                  long diff = currentTime - entry.getTimestamp();
-//                    if (diff > 0) {
-//                        gaussKernel.makeOlder(diff, negLambda);
-//                    }
-
-                    clusters.add(gaussKernel);
-                }
-            } else if (!current.isLeaf()) {
-                Entry[] entries = current.getEntries();
-                for (int i = 0; i < entries.length; i++) {
-                    Entry entry = entries[i];
-
-                    if (entry.isEmpty()) {
-                        continue;
-                    }
-
-                    if (entry.isIrrelevant(weightThreshold)) {
-                        continue;
-                    }
-
-                    queue.add(entry.getChild());
-                }
-            }
-        }
-
-        return clusters;
-    }
-
-
-
-    /**************************************************************************
-     * LOCAL CLASSES
-     **************************************************************************/
-    /**
-     * A class to code the return value of searching the smallest merge in a
-     * node.
-     */
-    class BestMergeInNode {
-
-        /**
-         * The position of the first entry in the array of the node.
-         */
-        public int entryPos1;
-        /**
-         * The position of the second entry in the array of the node.
-         */
-        public int entryPos2;
-        /**
-         * The distance between the two entries.
-         */
-        public double distance;
-
-        /**
-         * The constructor of this return value. It will automatically make
-         * sure that the first position is the smaller one of the two.
-         * @param pos1 One of the position.
-         * @param pos2 One of the position.
-         * @param distance The distance between the entries at these positions.
-         */
-        public BestMergeInNode(int pos1, int pos2,
-                double distance) {
-            assert (pos1 != pos2);
-
-            this.distance = distance;
-
-            if (pos1 < pos2) {
-                this.entryPos1 = pos1;
-                this.entryPos2 = pos2;
-            } else {
-                this.entryPos1 = pos2;
-                this.entryPos2 = pos1;
-            }
-        }
-    }
-
-}
diff --git a/moa/src/main/java/moa/tasks/EvaluatePeriodicHeldOutTest.java.orig b/moa/src/main/java/moa/tasks/EvaluatePeriodicHeldOutTest.java.orig
deleted file mode 100644
index a9f314477..000000000
--- a/moa/src/main/java/moa/tasks/EvaluatePeriodicHeldOutTest.java.orig
+++ /dev/null
@@ -1,308 +0,0 @@
-/*
- *    EvaluatePeriodicHeldOutTest.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *    @author Ammar Shaker (shaker@mathematik.uni-marburg.de)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.tasks;
-
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.PrintStream;
-import java.util.ArrayList;
-import java.util.List;
-import com.github.javacliparser.FileOption;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
-<<<<<<< Updated upstream
-<<<<<<< HEAD
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
-=======
-<<<<<<< c4a46917f06a4f4c3c08e67d06f6762cca1b47f9
-import moa.classifiers.Classifier;
-=======
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
->>>>>>> Instances rework, new iSOUPTree models and import cleanup
->>>>>>> 32d534d2e43c28db1711ab2fe7ff580d214e22fe
-=======
-import moa.classifiers.Classifier;
->>>>>>> Stashed changes
-import moa.core.Example;
-import moa.core.Measurement;
-import moa.core.ObjectRepository;
-import moa.core.StringUtils;
-import moa.core.TimingUtils;
-import moa.evaluation.LearningCurve;
-import moa.evaluation.LearningEvaluation;
-import moa.evaluation.LearningPerformanceEvaluator;
-import moa.learners.Learner;
-import moa.options.ClassOption;
-import moa.streams.CachedInstancesStream;
-import moa.streams.ExampleStream;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceHeader;
-
-/**
- * Task for evaluating a classifier on a stream by periodically testing on a heldout set.
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $
- */
-public class EvaluatePeriodicHeldOutTest extends MainTask {
-
-    @Override
-    public String getPurposeString() {
-        return "Evaluates a classifier on a stream by periodically testing on a heldout set.";
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    public ClassOption learnerOption = new ClassOption("learner", 'l',
-            "Classifier to train.", Classifier.class, "moa.classifiers.trees.HoeffdingTree");
-
-    public ClassOption streamOption = new ClassOption("stream", 's',
-            "Stream to learn from.", ExampleStream.class,
-            "generators.RandomTreeGenerator");
-
-    public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
-            "Learning performance evaluation method.",
-            LearningPerformanceEvaluator.class,
-            "BasicClassificationPerformanceEvaluator");
-
-    public IntOption testSizeOption = new IntOption("testSize", 'n',
-            "Number of testing examples.", 1000000, 0, Integer.MAX_VALUE);
-
-    public IntOption trainSizeOption = new IntOption("trainSize", 'i',
-            "Number of training examples, <1 = unlimited.", 0, 0,
-            Integer.MAX_VALUE);
-
-    public IntOption trainTimeOption = new IntOption("trainTime", 't',
-            "Number of training seconds.", 10 * 60 * 60, 0, Integer.MAX_VALUE);
-
-    public IntOption sampleFrequencyOption = new IntOption(
-            "sampleFrequency",
-            'f',
-            "Number of training examples between samples of learning performance.",
-            100000, 0, Integer.MAX_VALUE);
-
-    public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
-            "File to append intermediate csv results to.", null, "csv", true);
-
-    public FlagOption cacheTestOption = new FlagOption("cacheTest", 'c',
-            "Cache test instances in memory.");
-
-    @Override
-    protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
-        Learner learner = (Learner) getPreparedClassOption(this.learnerOption);
-        ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
-        LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
-        learner.setModelContext(stream.getHeader());
-        long instancesProcessed = 0;
-        LearningCurve learningCurve = new LearningCurve("evaluation instances");
-        File dumpFile = this.dumpFileOption.getFile();
-        PrintStream immediateResultStream = null;
-        if (dumpFile != null) {
-            try {
-                if (dumpFile.exists()) {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile, true), true);
-                } else {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile), true);
-                }
-            } catch (Exception ex) {
-                throw new RuntimeException(
-                        "Unable to open immediate result file: " + dumpFile, ex);
-            }
-        }
-        boolean firstDump = true;
-        ExampleStream testStream = null;
-        int testSize = this.testSizeOption.getValue();
-        if (this.cacheTestOption.isSet()) {
-            monitor.setCurrentActivity("Caching test examples...", -1.0);
-            InstancesHeader testInstances = new InstancesHeader(stream.getHeader(),
-                    this.testSizeOption.getValue());
-            while (testInstances.numInstances() < testSize) {
-                testInstances.add((Instance) stream.nextInstance().getData());
-                if (testInstances.numInstances()
-                        % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
-                    if (monitor.taskShouldAbort()) {
-                        return null;
-                    }
-                    monitor.setCurrentActivityFractionComplete((double) testInstances.numInstances()
-                            / (double) (this.testSizeOption.getValue()));
-                }
-            }
-            testStream = new CachedInstancesStream(testInstances);
-        } else {
-            //testStream = (InstanceStream) stream.copy();
-            testStream = stream;
-            /*monitor.setCurrentActivity("Skipping test examples...", -1.0);
-            for (int i = 0; i < testSize; i++) {
-            stream.nextInstance();
-            }*/
-        }
-        instancesProcessed = 0;
-        TimingUtils.enablePreciseTiming();
-        double totalTrainTime = 0.0;
-        while ((this.trainSizeOption.getValue() < 1
-                || instancesProcessed < this.trainSizeOption.getValue())
-                && stream.hasMoreInstances() == true) {
-            monitor.setCurrentActivityDescription("Training...");
-            long instancesTarget = instancesProcessed
-                    + this.sampleFrequencyOption.getValue();
-            long trainStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-            while (instancesProcessed < instancesTarget && stream.hasMoreInstances() == true) {
-                learner.trainOnInstance(stream.nextInstance());
-                instancesProcessed++;
-                if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
-                    if (monitor.taskShouldAbort()) {
-                        return null;
-                    }
-                    monitor.setCurrentActivityFractionComplete((double) (instancesProcessed)
-                            / (double) (this.trainSizeOption.getValue()));
-                }
-            }
-            double lastTrainTime = TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread()
-                    - trainStartTime);
-            totalTrainTime += lastTrainTime;
-            if (totalTrainTime > this.trainTimeOption.getValue()) {
-                break;
-            }
-	    if (this.cacheTestOption.isSet()) {
-                testStream.restart();
-            } 
-            evaluator.reset();
-            long testInstancesProcessed = 0;
-            monitor.setCurrentActivityDescription("Testing (after "
-                    + StringUtils.doubleToString(
-                    ((double) (instancesProcessed)
-                    / (double) (this.trainSizeOption.getValue()) * 100.0), 2)
-                    + "% training)...");
-            long testStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-            int instCount = 0 ;
-            for (instCount = 0; instCount < testSize; instCount++) {
-				if (stream.hasMoreInstances() == false) {
-					break;
-				}
-                Example testInst = (Example) testStream.nextInstance(); //.copy();
-                double trueClass = ((Instance) testInst.getData()).classValue();
-                //testInst.setClassMissing();
-                double[] prediction = learner.getPredictionForInstance(testInst);
-                //testInst.setClassValue(trueClass);
-                evaluator.addResult(testInst, prediction);
-                testInstancesProcessed++;
-                if (testInstancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
-                    if (monitor.taskShouldAbort()) {
-                        return null;
-                    }
-                    monitor.setCurrentActivityFractionComplete((double) testInstancesProcessed
-                            / (double) (testSize));
-                }
-            }
-        	if ( instCount != testSize) {
-				break;
-			}
-            double testTime = TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread()
-                    - testStartTime);
-            List<Measurement> measurements = new ArrayList<Measurement>();
-            measurements.add(new Measurement("evaluation instances",            		
-                    instancesProcessed));
-            measurements.add(new Measurement("total train time", totalTrainTime));
-            measurements.add(new Measurement("total train speed",
-                    instancesProcessed / totalTrainTime));
-            measurements.add(new Measurement("last train time", lastTrainTime));
-            measurements.add(new Measurement("last train speed",
-                    this.sampleFrequencyOption.getValue() / lastTrainTime));
-            measurements.add(new Measurement("test time", testTime));
-            measurements.add(new Measurement("test speed", this.testSizeOption.getValue()
-                    / testTime));
-            Measurement[] performanceMeasurements = evaluator.getPerformanceMeasurements();
-            for (Measurement measurement : performanceMeasurements) {
-                measurements.add(measurement);
-            }
-            Measurement[] modelMeasurements = learner.getModelMeasurements();
-            for (Measurement measurement : modelMeasurements) {
-                measurements.add(measurement);
-            }
-            learningCurve.insertEntry(new LearningEvaluation(measurements.toArray(new Measurement[measurements.size()])));
-            if (immediateResultStream != null) {
-                if (firstDump) {
-                    immediateResultStream.println(learningCurve.headerToString());
-                    firstDump = false;
-                }
-                immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
-                immediateResultStream.flush();
-            }
-            if (monitor.resultPreviewRequested()) {
-                monitor.setLatestResultPreview(learningCurve.copy());
-            }
-            // if (learner instanceof HoeffdingTree
-            // || learner instanceof HoeffdingOptionTree) {
-            // int numActiveNodes = (int) Measurement.getMeasurementNamed(
-            // "active learning leaves",
-            // modelMeasurements).getValue();
-            // // exit if tree frozen
-            // if (numActiveNodes < 1) {
-            // break;
-            // }
-            // int numNodes = (int) Measurement.getMeasurementNamed(
-            // "tree size (nodes)", modelMeasurements)
-            // .getValue();
-            // if (numNodes == lastNumNodes) {
-            // noGrowthCount++;
-            // } else {
-            // noGrowthCount = 0;
-            // }
-            // lastNumNodes = numNodes;
-            // } else if (learner instanceof OzaBoost || learner instanceof
-            // OzaBag) {
-            // double numActiveNodes = Measurement.getMeasurementNamed(
-            // "[avg] active learning leaves",
-            // modelMeasurements).getValue();
-            // // exit if all trees frozen
-            // if (numActiveNodes == 0.0) {
-            // break;
-            // }
-            // int numNodes = (int) (Measurement.getMeasurementNamed(
-            // "[avg] tree size (nodes)",
-            // learner.getModelMeasurements()).getValue() * Measurement
-            // .getMeasurementNamed("ensemble size",
-            // modelMeasurements).getValue());
-            // if (numNodes == lastNumNodes) {
-            // noGrowthCount++;
-            // } else {
-            // noGrowthCount = 0;
-            // }
-            // lastNumNodes = numNodes;
-            // }
-        }
-        if (immediateResultStream != null) {
-            immediateResultStream.close();
-        }
-        return learningCurve;
-    }
-
-    @Override
-    public Class<?> getTaskResultType() {
-        return LearningCurve.class;
-    }
-}
diff --git a/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java.orig b/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java.orig
deleted file mode 100644
index 55b4ceade..000000000
--- a/moa/src/main/java/moa/tasks/EvaluatePrequentialMultiTarget.java.orig
+++ /dev/null
@@ -1,713 +0,0 @@
-<<<<<<< c4a46917f06a4f4c3c08e67d06f6762cca1b47f9
-/*
- *    EvaluatePrequentialMultiTarget.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.tasks;
-
-import com.github.javacliparser.FileOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstanceData;
-import com.yahoo.labs.samoa.instances.Prediction;
-
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.PrintStream;
-
-import moa.classifiers.MultiTargetRegressor;
-import moa.classifiers.Regressor;
-import moa.core.Example;
-import moa.core.Measurement;
-import moa.core.ObjectRepository;
-import moa.core.TimingUtils;
-import moa.evaluation.EWMAClassificationPerformanceEvaluator;
-import moa.evaluation.FadingFactorClassificationPerformanceEvaluator;
-import moa.evaluation.LearningCurve;
-import moa.evaluation.LearningEvaluation;
-import moa.evaluation.LearningPerformanceEvaluator;
-import moa.evaluation.MultiTargetPerformanceEvaluator;
-import moa.evaluation.RegressionPerformanceEvaluator;
-import moa.evaluation.WindowClassificationPerformanceEvaluator;
-import moa.learners.Learner;
-import moa.options.ClassOption;
-import moa.streams.ExampleStream;
-import moa.streams.MultiTargetInstanceStream;
-
-/**
- * Task for evaluating a classifier on a stream by testing then training with each example in sequence.
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @version $Revision: 7 $
- */
-public class EvaluatePrequentialMultiTarget extends MultiTargetMainTask {
-
-	@Override
-	public String getPurposeString() {
-		return "Evaluates a classifier on a stream by testing then training with each example in sequence.";
-	}
-
-	private static final long serialVersionUID = 1L;
-
-	public ClassOption learnerOption = new ClassOption("learner", 'l',
-			"Learner to train.", MultiTargetRegressor.class, "moa.classifiers.multitarget.functions.MultiTargetNoChange");
-
-	public ClassOption streamOption = new ClassOption("stream", 's',
-			"Stream to learn from.", MultiTargetInstanceStream.class,
-			"MultiTargetArffFileStream");
-
-	public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
-			"Classification performance evaluation method.",
-			MultiTargetPerformanceEvaluator.class,
-			"BasicMultiTargetPerformanceEvaluator");
-
-	public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
-			"Maximum number of instances to test/train on  (-1 = no limit).",
-			100000000, -1, Integer.MAX_VALUE);
-
-	public IntOption timeLimitOption = new IntOption("timeLimit", 't',
-			"Maximum number of seconds to test/train for (-1 = no limit).", -1,
-			-1, Integer.MAX_VALUE);
-
-	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
-			'f',
-			"How many instances between samples of the learning performance.",
-			100000, 0, Integer.MAX_VALUE);
-
-	public IntOption memCheckFrequencyOption = new IntOption(
-			"memCheckFrequency", 'q',
-			"How many instances between memory bound checks.", 100000, 0,
-			Integer.MAX_VALUE);
-
-	public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
-			"File to append intermediate csv results to.", null, "csv", true);
-
-	public FileOption outputPredictionFileOption = new FileOption("outputPredictionFile", 'o',
-			"File to append output predictions to.", null, "pred", true);
-
-	//New for prequential method DEPRECATED
-	public IntOption widthOption = new IntOption("width",
-			'w', "Size of Window", 1000);
-
-	public FloatOption alphaOption = new FloatOption("alpha",
-			'a', "Fading factor or exponential smoothing factor", .01);
-	//End New for prequential methods
-
-	@Override
-	public Class<?> getTaskResultType() {
-		return LearningCurve.class;
-	}
-
-	@Override
-	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
-		Learner learner = (Learner) getPreparedClassOption(this.learnerOption);
-		ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
-		LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
-		LearningCurve learningCurve = new LearningCurve(
-				"learning evaluation instances");
-
-		//New for prequential methods
-		if (evaluator instanceof WindowClassificationPerformanceEvaluator) {
-			//((WindowClassificationPerformanceEvaluator) evaluator).setWindowWidth(widthOption.getValue());
-			if (widthOption.getValue() != 1000) {
-				System.out.println("DEPRECATED! Use EvaluatePrequential -e (WindowClassificationPerformanceEvaluator -w " + widthOption.getValue() + ")");
-				return learningCurve;
-=======
-/*
- *    EvaluatePrequentialMultiTarget.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.tasks;
-
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.PrintStream;
-
-import com.github.javacliparser.FileOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.Prediction;
-
-import moa.classifiers.MultiTargetRegressor;
-import moa.core.Example;
-import moa.core.Measurement;
-import moa.core.ObjectRepository;
-import moa.core.TimingUtils;
-import moa.evaluation.EWMAClassificationPerformanceEvaluator;
-import moa.evaluation.FadingFactorClassificationPerformanceEvaluator;
-import moa.evaluation.LearningCurve;
-import moa.evaluation.LearningEvaluation;
-import moa.evaluation.LearningPerformanceEvaluator;
-import moa.evaluation.MultiTargetPerformanceEvaluator;
-import moa.evaluation.WindowClassificationPerformanceEvaluator;
-import moa.learners.Learner;
-import moa.options.ClassOption;
-import moa.streams.ExampleStream;
-import moa.streams.MultiTargetInstanceStream;
-
-/**
- * Task for evaluating a classifier on a stream by testing then training with each example in sequence.
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @version $Revision: 7 $
- */
-public class EvaluatePrequentialMultiTarget extends MultiTargetMainTask {
-
-	@Override
-	public String getPurposeString() {
-		return "Evaluates a classifier on a stream by testing then training with each example in sequence.";
-	}
-<<<<<<< HEAD
-
-	private static final long serialVersionUID = 1L;
-
-	public ClassOption learnerOption = new ClassOption("learner", 'l',
-			"Learner to train.", MultiTargetRegressor.class, "moa.classifiers.multitarget.functions.MultiTargetNoChange");
-
-	public ClassOption streamOption = new ClassOption("stream", 's',
-			"Stream to learn from.", MultiTargetInstanceStream.class,
-			"MultiTargetArffFileStream");
-
-	public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
-			"Classification performance evaluation method.",
-			MultiTargetPerformanceEvaluator.class,
-			"BasicMultiTargetPerformanceEvaluator");
-
-	public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
-			"Maximum number of instances to test/train on  (-1 = no limit).",
-			100000000, -1, Integer.MAX_VALUE);
-
-	public IntOption timeLimitOption = new IntOption("timeLimit", 't',
-			"Maximum number of seconds to test/train for (-1 = no limit).", -1,
-			-1, Integer.MAX_VALUE);
-
-	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
-			'f',
-			"How many instances between samples of the learning performance.",
-			100000, 0, Integer.MAX_VALUE);
-
-	public IntOption memCheckFrequencyOption = new IntOption(
-			"memCheckFrequency", 'q',
-			"How many instances between memory bound checks.", 100000, 0,
-			Integer.MAX_VALUE);
-
-	public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
-			"File to append intermediate csv results to.", null, "csv", true);
-
-	public FileOption outputPredictionFileOption = new FileOption("outputPredictionFile", 'o',
-			"File to append output predictions to.", null, "pred", true);
-
-	//New for prequential method DEPRECATED
-	public IntOption widthOption = new IntOption("width",
-			'w', "Size of Window", 1000);
-
-	public FloatOption alphaOption = new FloatOption("alpha",
-			'a', "Fading factor or exponential smoothing factor", .01);
-	//End New for prequential methods
-
-	@Override
-	public Class<?> getTaskResultType() {
-		return LearningCurve.class;
-	}
-
-	@Override
-	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
-		Learner learner = (Learner) getPreparedClassOption(this.learnerOption);
-		ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
-		LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
-		LearningCurve learningCurve = new LearningCurve(
-				"learning evaluation instances");
-
-		//New for prequential methods
-		if (evaluator instanceof WindowClassificationPerformanceEvaluator) {
-			//((WindowClassificationPerformanceEvaluator) evaluator).setWindowWidth(widthOption.getValue());
-			if (widthOption.getValue() != 1000) {
-				System.out.println("DEPRECATED! Use EvaluatePrequential -e (WindowClassificationPerformanceEvaluator -w " + widthOption.getValue() + ")");
-				return learningCurve;
-			}
-		}
-		if (evaluator instanceof EWMAClassificationPerformanceEvaluator) {
-			//((EWMAClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
-			if (alphaOption.getValue() != .01) {
-				System.out.println("DEPRECATED! Use EvaluatePrequential -e (EWMAClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
-				return learningCurve;
-			}
-		}
-		if (evaluator instanceof FadingFactorClassificationPerformanceEvaluator) {
-			//((FadingFactorClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
-			if (alphaOption.getValue() != .01) {
-				System.out.println("DEPRECATED! Use EvaluatePrequential -e (FadingFactorClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
-				return learningCurve;
-			}
-		}
-		//End New for prequential methods
-
-		learner.setModelContext(stream.getHeader());
-		int maxInstances = this.instanceLimitOption.getValue();
-		long instancesProcessed = 0;
-		int maxSeconds = this.timeLimitOption.getValue();
-		int secondsElapsed = 0;
-		monitor.setCurrentActivity("Evaluating learner...", -1.0);
-
-		File dumpFile = this.dumpFileOption.getFile();
-		PrintStream immediateResultStream = null;
-		if (dumpFile != null) {
-			try {
-				if (dumpFile.exists()) {
-					immediateResultStream = new PrintStream(
-							new FileOutputStream(dumpFile, true), true);
-				} else {
-					immediateResultStream = new PrintStream(
-							new FileOutputStream(dumpFile), true);
-				}
-			} catch (Exception ex) {
-				throw new RuntimeException(
-						"Unable to open immediate result file: " + dumpFile, ex);
-			}
-		}
-		//File for output predictions
-		File outputPredictionFile = this.outputPredictionFileOption.getFile();
-		PrintStream outputPredictionResultStream = null;
-		if (outputPredictionFile != null) {
-			try {
-				if (outputPredictionFile.exists()) {
-					outputPredictionResultStream = new PrintStream(
-							new FileOutputStream(outputPredictionFile, true), true);
-				} else {
-					outputPredictionResultStream = new PrintStream(
-							new FileOutputStream(outputPredictionFile), true);
-				}
-			} catch (Exception ex) {
-				throw new RuntimeException(
-						"Unable to open prediction result file: " + outputPredictionFile, ex);
-			}
-		}
-		boolean firstDump = true;
-		boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
-		long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-		long lastEvaluateStartTime = evaluateStartTime;
-		double RAMHours = 0.0;
-		while (stream.hasMoreInstances()
-				&& ((maxInstances < 0) || (instancesProcessed < maxInstances))
-				&& ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
-			Example trainInst = stream.nextInstance();
-			Example testInst = (Example) trainInst; //.copy();
-			//testInst.setClassMissing();
-			//double[] prediction = learner.getPredictionForInstance(testInst);
-			Prediction prediction = learner.getPredictionForInstance(testInst);
-			// Output prediction
-			if (outputPredictionFile != null) {
-				StringBuilder sb = new StringBuilder();
-				for (int i = 0; i < ((Instance) trainInst.getData()).numOutputAttributes(); i++) {
-					sb.append("Out " + i + ": " + ((Instance) trainInst.getData()).valueOutputAttribute(i) + " ");
-				}
-				outputPredictionResultStream.println(prediction + "," + sb.toString());
-			}
-
-			//evaluator.addClassificationAttempt(trueClass, prediction, testInst.weight());
-			evaluator.addResult(testInst, prediction);
-			learner.trainOnInstance(trainInst);
-			instancesProcessed++;
-			if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0
-					|| stream.hasMoreInstances() == false) {
-				long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-				double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);
-				double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);
-				double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); //GBs
-				RAMHoursIncrement *= (timeIncrement / 3600.0); //Hours
-				RAMHours += RAMHoursIncrement;
-				lastEvaluateStartTime = evaluateTime;
-				learningCurve.insertEntry(new LearningEvaluation(
-						new Measurement[]{
-								new Measurement(
-										"learning evaluation instances",
-										instancesProcessed),
-										new Measurement(
-												"evaluation time ("
-														+ (preciseCPUTiming ? "cpu "
-																: "") + "seconds)",
-																time),
-																new Measurement(
-																		"model cost (RAM-Hours)",
-																		RAMHours)
-						},
-						evaluator, learner));
-
-				if (immediateResultStream != null) {
-					if (firstDump) {
-						immediateResultStream.println(learningCurve.headerToString());
-						firstDump = false;
-					}
-					immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
-					immediateResultStream.flush();
-				}
-			}
-			if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
-				if (monitor.taskShouldAbort()) {
-					return null;
-				}
-				long estimatedRemainingInstances = stream.estimatedRemainingInstances();
-				if (maxInstances > 0) {
-					long maxRemaining = maxInstances - instancesProcessed;
-					if ((estimatedRemainingInstances < 0)
-							|| (maxRemaining < estimatedRemainingInstances)) {
-						estimatedRemainingInstances = maxRemaining;
-					}
-				}
-				monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
-						: (double) instancesProcessed
-						/ (double) (instancesProcessed + estimatedRemainingInstances));
-				if (monitor.resultPreviewRequested()) {
-					monitor.setLatestResultPreview(learningCurve.copy());
-				}
-				secondsElapsed = (int) TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread()
-						- evaluateStartTime);
-			}
-		}
-		StringBuilder sb= new StringBuilder();
-		learner.getDescription(sb, 0);
-		System.out.println(sb.toString());
-		if (immediateResultStream != null) {
-			immediateResultStream.close();
-		}
-		if (outputPredictionResultStream != null) {
-			outputPredictionResultStream.close();
-		}
-		return learningCurve;
-	}
-}
-=======
-
-	private static final long serialVersionUID = 1L;
-
-	public ClassOption learnerOption = new ClassOption("learner", 'l',
-			"Learner to train.", MultiTargetRegressor.class, "moa.classifiers.multitarget.functions.MultiTargetNoChange");
-
-	public ClassOption streamOption = new ClassOption("stream", 's',
-			"Stream to learn from.", MultiTargetInstanceStream.class,
-			"MultiTargetArffFileStream");
-
-	public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
-			"Classification performance evaluation method.",
-			MultiTargetPerformanceEvaluator.class,
-			"BasicMultiTargetPerformanceEvaluator");
-
-	public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
-			"Maximum number of instances to test/train on  (-1 = no limit).",
-			100000000, -1, Integer.MAX_VALUE);
-
-	public IntOption timeLimitOption = new IntOption("timeLimit", 't',
-			"Maximum number of seconds to test/train for (-1 = no limit).", -1,
-			-1, Integer.MAX_VALUE);
-
-	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
-			'f',
-			"How many instances between samples of the learning performance.",
-			100000, 0, Integer.MAX_VALUE);
-
-	public IntOption memCheckFrequencyOption = new IntOption(
-			"memCheckFrequency", 'q',
-			"How many instances between memory bound checks.", 100000, 0,
-			Integer.MAX_VALUE);
-
-	public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
-			"File to append intermediate csv results to.", null, "csv", true);
-
-	public FileOption outputPredictionFileOption = new FileOption("outputPredictionFile", 'o',
-			"File to append output predictions to.", null, "pred", true);
-
-	//New for prequential method DEPRECATED
-	public IntOption widthOption = new IntOption("width",
-			'w', "Size of Window", 1000);
-
-	public FloatOption alphaOption = new FloatOption("alpha",
-			'a', "Fading factor or exponential smoothing factor", .01);
-	//End New for prequential methods
-
-	@Override
-	public Class<?> getTaskResultType() {
-		return LearningCurve.class;
-	}
-
-	@Override
-	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
-		Learner learner = (Learner) getPreparedClassOption(this.learnerOption);
-		ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
-		LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
-		LearningCurve learningCurve = new LearningCurve(
-				"learning evaluation instances");
-
-		//New for prequential methods
-		if (evaluator instanceof WindowClassificationPerformanceEvaluator) {
-			//((WindowClassificationPerformanceEvaluator) evaluator).setWindowWidth(widthOption.getValue());
-			if (widthOption.getValue() != 1000) {
-				System.out.println("DEPRECATED! Use EvaluatePrequential -e (WindowClassificationPerformanceEvaluator -w " + widthOption.getValue() + ")");
-				return learningCurve;
-			}
-		}
-		if (evaluator instanceof EWMAClassificationPerformanceEvaluator) {
-			//((EWMAClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
-			if (alphaOption.getValue() != .01) {
-				System.out.println("DEPRECATED! Use EvaluatePrequential -e (EWMAClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
-				return learningCurve;
-			}
-		}
-		if (evaluator instanceof FadingFactorClassificationPerformanceEvaluator) {
-			//((FadingFactorClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
-			if (alphaOption.getValue() != .01) {
-				System.out.println("DEPRECATED! Use EvaluatePrequential -e (FadingFactorClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
-				return learningCurve;
-			}
-		}
-		//End New for prequential methods
-
-		learner.setModelContext(stream.getHeader());
-		int maxInstances = this.instanceLimitOption.getValue();
-		long instancesProcessed = 0;
-		int maxSeconds = this.timeLimitOption.getValue();
-		int secondsElapsed = 0;
-		monitor.setCurrentActivity("Evaluating learner...", -1.0);
-
-		File dumpFile = this.dumpFileOption.getFile();
-		PrintStream immediateResultStream = null;
-		if (dumpFile != null) {
-			try {
-				if (dumpFile.exists()) {
-					immediateResultStream = new PrintStream(
-							new FileOutputStream(dumpFile, true), true);
-				} else {
-					immediateResultStream = new PrintStream(
-							new FileOutputStream(dumpFile), true);
-				}
-			} catch (Exception ex) {
-				throw new RuntimeException(
-						"Unable to open immediate result file: " + dumpFile, ex);
-			}
-		}
-		//File for output predictions
-		File outputPredictionFile = this.outputPredictionFileOption.getFile();
-		PrintStream outputPredictionResultStream = null;
-		if (outputPredictionFile != null) {
-			try {
-				if (outputPredictionFile.exists()) {
-					outputPredictionResultStream = new PrintStream(
-							new FileOutputStream(outputPredictionFile, true), true);
-				} else {
-					outputPredictionResultStream = new PrintStream(
-							new FileOutputStream(outputPredictionFile), true);
-				}
-			} catch (Exception ex) {
-				throw new RuntimeException(
-						"Unable to open prediction result file: " + outputPredictionFile, ex);
-			}
-		}
-		boolean firstDump = true;
-		boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
-		long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-		long lastEvaluateStartTime = evaluateStartTime;
-		double RAMHours = 0.0;
-		while (stream.hasMoreInstances()
-				&& ((maxInstances < 0) || (instancesProcessed < maxInstances))
-				&& ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
-			Example trainInst = stream.nextInstance();
-			Example testInst = (Example) trainInst; //.copy();
-			//testInst.setClassMissing();
-			//double[] prediction = learner.getPredictionForInstance(testInst);
-			Prediction prediction = learner.getPredictionForInstance(testInst);
-			// Output prediction
-			if (outputPredictionFile != null) {
-				StringBuilder sb = new StringBuilder();
-				for (int i = 0; i < ((Instance) trainInst.getData()).numOutputAttributes(); i++) {
-					sb.append("Out " + i + ": " + ((Instance) trainInst.getData()).valueOutputAttribute(i) + " ");
-				}
-				outputPredictionResultStream.println(prediction + "," + sb.toString());
->>>>>>> Instances rework, new iSOUPTree models and import cleanup
-			}
-		}
-		if (evaluator instanceof EWMAClassificationPerformanceEvaluator) {
-			//((EWMAClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
-			if (alphaOption.getValue() != .01) {
-				System.out.println("DEPRECATED! Use EvaluatePrequential -e (EWMAClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
-				return learningCurve;
-			}
-		}
-		if (evaluator instanceof FadingFactorClassificationPerformanceEvaluator) {
-			//((FadingFactorClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
-			if (alphaOption.getValue() != .01) {
-				System.out.println("DEPRECATED! Use EvaluatePrequential -e (FadingFactorClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
-				return learningCurve;
-			}
-		}
-		//End New for prequential methods
-
-		learner.setModelContext(stream.getHeader());
-		int maxInstances = this.instanceLimitOption.getValue();
-		long instancesProcessed = 0;
-		int maxSeconds = this.timeLimitOption.getValue();
-		int secondsElapsed = 0;
-		monitor.setCurrentActivity("Evaluating learner...", -1.0);
-
-		File dumpFile = this.dumpFileOption.getFile();
-		PrintStream immediateResultStream = null;
-		if (dumpFile != null) {
-			try {
-				if (dumpFile.exists()) {
-					immediateResultStream = new PrintStream(
-							new FileOutputStream(dumpFile, true), true);
-				} else {
-					immediateResultStream = new PrintStream(
-							new FileOutputStream(dumpFile), true);
-				}
-			} catch (Exception ex) {
-				throw new RuntimeException(
-						"Unable to open immediate result file: " + dumpFile, ex);
-			}
-		}
-		//File for output predictions
-		File outputPredictionFile = this.outputPredictionFileOption.getFile();
-		PrintStream outputPredictionResultStream = null;
-		if (outputPredictionFile != null) {
-			try {
-				if (outputPredictionFile.exists()) {
-					outputPredictionResultStream = new PrintStream(
-							new FileOutputStream(outputPredictionFile, true), true);
-				} else {
-					outputPredictionResultStream = new PrintStream(
-							new FileOutputStream(outputPredictionFile), true);
-				}
-			} catch (Exception ex) {
-				throw new RuntimeException(
-						"Unable to open prediction result file: " + outputPredictionFile, ex);
-			}
-		}
-		boolean firstDump = true;
-		boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
-		long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-		long lastEvaluateStartTime = evaluateStartTime;
-		double RAMHours = 0.0;
-		while (stream.hasMoreInstances()
-				&& ((maxInstances < 0) || (instancesProcessed < maxInstances))
-				&& ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
-			Example trainInst = stream.nextInstance();
-			Example testInst = (Example) trainInst; //.copy();
-			//testInst.setClassMissing();
-			//double[] prediction = learner.getPredictionForInstance(testInst);
-			Prediction prediction = learner.getPredictionForInstance(testInst);
-			// Output prediction
-			if (outputPredictionFile != null) {
-				StringBuilder sb = new StringBuilder();
-				for (int i = 0; i < ((Instance) trainInst.getData()).numOutputAttributes(); i++) {
-					sb.append("Out " + i + ": " + ((Instance) trainInst.getData()).valueOutputAttribute(i) + " ");
-				}
-				outputPredictionResultStream.println(prediction + "," + sb.toString());
-			}
-
-			//evaluator.addClassificationAttempt(trueClass, prediction, testInst.weight());
-			evaluator.addResult(testInst, prediction);
-			learner.trainOnInstance(trainInst);
-			instancesProcessed++;
-			if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0
-					|| stream.hasMoreInstances() == false) {
-				long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-				double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);
-				double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);
-				double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); //GBs
-				RAMHoursIncrement *= (timeIncrement / 3600.0); //Hours
-				RAMHours += RAMHoursIncrement;
-				lastEvaluateStartTime = evaluateTime;
-				learningCurve.insertEntry(new LearningEvaluation(
-						new Measurement[]{
-								new Measurement(
-										"learning evaluation instances",
-										instancesProcessed),
-										new Measurement(
-												"evaluation time ("
-														+ (preciseCPUTiming ? "cpu "
-																: "") + "seconds)",
-																time),
-																new Measurement(
-																		"model cost (RAM-Hours)",
-																		RAMHours)
-						},
-						evaluator, learner));
-
-				if (immediateResultStream != null) {
-					if (firstDump) {
-						immediateResultStream.println(learningCurve.headerToString());
-						firstDump = false;
-					}
-					immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
-					immediateResultStream.flush();
-				}
-			}
-			if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
-				if (monitor.taskShouldAbort()) {
-					return null;
-				}
-				long estimatedRemainingInstances = stream.estimatedRemainingInstances();
-				if (maxInstances > 0) {
-					long maxRemaining = maxInstances - instancesProcessed;
-					if ((estimatedRemainingInstances < 0)
-							|| (maxRemaining < estimatedRemainingInstances)) {
-						estimatedRemainingInstances = maxRemaining;
-					}
-				}
-				monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
-						: (double) instancesProcessed
-						/ (double) (instancesProcessed + estimatedRemainingInstances));
-				if (monitor.resultPreviewRequested()) {
-					monitor.setLatestResultPreview(learningCurve.copy());
-				}
-				secondsElapsed = (int) TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread()
-						- evaluateStartTime);
-			}
-		}
-		StringBuilder sb= new StringBuilder();
-		learner.getDescription(sb, 0);
-		System.out.println(sb.toString());
-		if (immediateResultStream != null) {
-			immediateResultStream.close();
-		}
-		if (outputPredictionResultStream != null) {
-			outputPredictionResultStream.close();
-		}
-		return learningCurve;
-	}
-}
->>>>>>> 32d534d2e43c28db1711ab2fe7ff580d214e22fe

From e3549e933bc02f752c7e7e5a221a20b7af52e1c3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Tue, 17 Apr 2018 13:33:01 +0200
Subject: [PATCH 32/33] Transitional commit

---
 .../yahoo/labs/samoa/instances/Attribute.java |  12 +
 .../yahoo/labs/samoa/instances/Instance.java  |  15 +
 .../labs/samoa/instances/InstanceImpl.java    |  17 +-
 .../MultiTargetRegressionPrediction.java      |   8 +-
 .../classifiers/AbstractEnsembleLearner.java  |  23 +-
 .../classifiers/AbstractInstanceLearner.java  |  55 +-
 .../classifiers/meta/AbstractOzaBagAdwin.java |   3 +-
 .../MultiLabelBSTree.java                     |  44 +-
 .../MultiLabelBSTreePCT.java                  | 104 ++--
 .../splitcriteria/ICVarianceReduction.java    |  11 +-
 .../PCTWeightedICVarianceReduction.java       |  22 +-
 .../WeightedICVarianceReduction.java          |   2 +
 ...tiveRandomForestMultiTargetRegression.java | 516 ++++++++++++++++++
 .../OzaBagAdwinMultiTargetRegression.java     |  17 +-
 .../mlc/meta/OzaBagMultiTargetRegression.java |   2 +-
 .../LocalMultiTargetRegressor.java            |  10 +-
 .../mtr/trees/ISOUPOptionTree.java            |  13 +-
 .../moa/classifiers/mtr/trees/ISOUPTree.java  | 310 +++++------
 .../classifiers/mtr/trees/ISOUPTreeRF.java    |  42 +-
 .../core/AttributeExpansionSuggestion.java    |   3 +
 .../rules/core/NominalRulePredicate.java      |   5 +
 .../rules/core/NumericRulePredicate.java      |   5 +-
 moa/src/main/java/moa/core/DoubleVector.java  |   4 +-
 moa/src/main/java/moa/learners/Learner.java   |   6 +
 24 files changed, 928 insertions(+), 321 deletions(-)
 create mode 100644 moa/src/main/java/moa/classifiers/mlc/meta/AdaptiveRandomForestMultiTargetRegression.java
 rename moa/src/main/java/moa/classifiers/{mlc => mtr}/LocalMultiTargetRegressor.java (91%)

diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java
index 0d1dc9a3a..2122a1796 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java
@@ -336,4 +336,16 @@ public final String toString() {
 		}
 		return null;
 	}
+
+
+	public String attributeType() {
+		if (this.isNominal())
+			return "nominal";
+		else if (this.isNumeric())
+			return "numeric";
+		else if (this.isHierarchical()) 
+			return "hierarchical";
+		else
+			return "other";
+	}
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
index b188919bf..336134838 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
@@ -176,6 +176,21 @@ public interface Instance extends Serializable {
      * @param instAttIndex, the attribute's index
      */
     public void setMissing(int instAttIndex);        
+
+    /**
+     * Sets an input attribute as missing
+     *
+     * @param inputAttributeIndex the index of the input attribute
+     */
+    public void setInputMissing(int inputAttributeIndex);        
+
+    /**
+     * Sets an output attribute as missing
+     *
+     * @param outputAttributeIndex the index of the output attribute
+     */
+    public void setOutputMissing(int outputAttributeIndex);        
+
     
     /**
      * Sets an attribute as missing
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
index 831866220..d4c8e8194 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
@@ -24,6 +24,8 @@
  */
 public class InstanceImpl implements StructuredInstance {
 
+	private static final long serialVersionUID = 1L;
+
 	/**
      * The weight.
      */
@@ -328,7 +330,7 @@ public boolean missingOutputs() {
     		return classIsMissing();
     	else {
     		for (int i = 0; i < this.instanceHeader.numOutputAttributes(); i++) {
-    			if (this.instanceData.isMissing(this.indexOf(outputAttribute(i)))) {
+    			if (this.isOutputMissing(i)) {
     				return true;
     			}
     		}
@@ -508,11 +510,22 @@ public String outputAttributesToString() {
 		else {
 			String ret = "{";
 			for (int i = 0; i < numOutputAttributes(); i++) {
-				ret += String.valueOf(this.valueOutputAttribute(i)) + (i != numOutputAttributes() - 1 ? "," : "");
+				ret += String.valueOf(this.valueOutputAttribute(i)) + (i != numOutputAttributes() - 1 ? "|" : "");
 			}
 			ret += "}";
 			return ret;
 		}
 	}
 
+	@Override
+	public void setInputMissing(int inputAttributeIndex) {
+		this.setMissing(this.instanceHeader.getInputInstanceIndex(inputAttributeIndex));
+		
+	}
+
+	@Override
+	public void setOutputMissing(int outputAttributeIndex) {
+		this.setMissing(this.instanceHeader.getOutputInstanceIndex(outputAttributeIndex));
+	}
+
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/MultiTargetRegressionPrediction.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/MultiTargetRegressionPrediction.java
index 7023a1316..ff0543994 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/MultiTargetRegressionPrediction.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/MultiTargetRegressionPrediction.java
@@ -41,7 +41,8 @@ public MultiTargetRegressionPrediction(DoubleVector prediction) {
 	}
 	
 	public MultiTargetRegressionPrediction(double[] prediction) {
-		this.prediction = new DoubleVector(prediction);
+		if (prediction != null)
+			this.prediction = new DoubleVector(prediction);
 	}
 	
 	
@@ -122,7 +123,10 @@ public double[] asDoubleArray() {
     }
     
 	public String asPredictionString() {
-		return String.valueOf(prediction.toString());
+		if (prediction != null)
+			return String.valueOf(prediction.toString().replace(",", ""));
+		else
+			return "?";
 	}
 
 	@Override
diff --git a/moa/src/main/java/moa/classifiers/AbstractEnsembleLearner.java b/moa/src/main/java/moa/classifiers/AbstractEnsembleLearner.java
index 67984cfa3..22d8c759e 100644
--- a/moa/src/main/java/moa/classifiers/AbstractEnsembleLearner.java
+++ b/moa/src/main/java/moa/classifiers/AbstractEnsembleLearner.java
@@ -27,18 +27,29 @@ public long measureByteSize() {
     		size += c.measureByteSize();
     	return size;
     }
-    
+
     @SuppressWarnings("unchecked")
 	@Override
     public void resetLearningImpl() {
-        this.ensemble = new ArrayList<MLTask>(this.ensembleSizeOption.getValue());
+        this.ensemble = new ArrayList<>(this.ensembleSizeOption.getValue());
         MLTask baseLearner = (MLTask) getPreparedClassOption(this.baseLearnerOption);
-        for (int i = 0; i < this.ensemble.size(); i++) {
-            this.ensemble.set(i, (MLTask) baseLearner.copy());
-            this.ensemble.get(i).setRandomSeed(this.randomSeed + i * 100);
+        for (int i = 0; i < this.ensembleSizeOption.getValue(); i++) {
+        	MLTask learner = (MLTask) baseLearner.copy();
+        	learner.setRandomSeed(this.randomSeed + i + 1);
+        	learner.prepareForUse();
+            this.ensemble.add(learner);
         }
     }
-
+   
+    public void setRandomSeed(int seed) {
+    	super.setRandomSeed(seed);
+    	if (this.ensemble != null) 
+    		for (int i = 0; i < this.ensembleSizeOption.getValue(); i++) {
+    			if (this.ensemble.get(i) != null)
+    				this.ensemble.get(i).setRandomSeed(this.randomSeed + i + 1);
+    		}	
+    }
+    
 	public abstract Prediction combinePredictions(Prediction[] predictions);
 	
 	public Prediction getPredictionForInstance(Instance inst) {
diff --git a/moa/src/main/java/moa/classifiers/AbstractInstanceLearner.java b/moa/src/main/java/moa/classifiers/AbstractInstanceLearner.java
index 723e3b831..62522c20a 100644
--- a/moa/src/main/java/moa/classifiers/AbstractInstanceLearner.java
+++ b/moa/src/main/java/moa/classifiers/AbstractInstanceLearner.java
@@ -57,7 +57,7 @@ public String getPurposeString() {
     protected double trainingWeightSeenByModel = 0.0;
 
     /** Random seed used in randomizable learners */
-    protected int randomSeed = 1;
+    public int randomSeed = 1;
 
     /** Option for randomizable learners to change the random seed */
     public IntOption randomSeedOption;
@@ -127,6 +127,11 @@ public void setRandomSeed(int s) {
         }
     }
 
+    @Override
+    public int getRandomSeed() {
+    	return this.randomSeed;
+    }
+    
     @Override
     public boolean trainingHasStarted() {
         return this.trainingWeightSeenByModel > 0.0;
@@ -289,40 +294,30 @@ public String getNominalValueString(int attIndex, int valIndex) {
      */
     public static boolean contextIsCompatible(InstancesHeader originalContext,
             InstancesHeader newContext) {
-
-        if (newContext.numClasses() < originalContext.numClasses()) {
-            return false; // rule 1
-        }
-        if (newContext.numAttributes() < originalContext.numAttributes()) {
-            return false; // rule 2
-        }
-        int oPos = 0;
-        int nPos = 0;
-        while (oPos < originalContext.numAttributes()) {
-            if (oPos == originalContext.classIndex()) {
-                oPos++;
-                if (!(oPos < originalContext.numAttributes())) {
-                    break;
-                }
+		if (newContext.numInputAttributes() < originalContext.numInputAttributes()) {
+			return false; // rule 2
+		}
+		if (newContext.numOutputAttributes() < originalContext.numOutputAttributes()) {
+			return false; // rule 2
+		}
+    	for (int i = 0; i < originalContext.numOutputAttributes(); i++) {
+    		if (originalContext.inputAttribute(i).attributeType() != newContext.inputAttribute(i).attributeType()) {
+                return false; // rule 4
             }
-            if (nPos == newContext.classIndex()) {
-                nPos++;
+    		if (newContext.outputAttribute(i).numValues() < originalContext.outputAttribute(i).numValues()) {
+    			return false; // rule 1
+    		}
+    	}
+        // Input attributes
+        for (int i = 0; i < originalContext.numInputAttributes(); i++) {
+            if (originalContext.inputAttribute(i).attributeType() != newContext.inputAttribute(i).attributeType()) {
+                return false; // rule 4
             }
-            if (originalContext.attribute(oPos).isNominal()) {
-                if (!newContext.attribute(nPos).isNominal()) {
-                    return false; // rule 4
-                }
-                if (newContext.attribute(nPos).numValues() < originalContext.attribute(oPos).numValues()) {
+            else if (originalContext.inputAttribute(i).isNumeric()) {
+                if (newContext.inputAttribute(i).numValues() < originalContext.inputAttribute(i).numValues()) {
                     return false; // rule 3
                 }
-            } else {
-                assert (originalContext.attribute(oPos).isNumeric());
-                if (!newContext.attribute(nPos).isNumeric()) {
-                    return false; // rule 4
-                }
             }
-            oPos++;
-            nPos++;
         }
         return true; // all checks clear
     }
diff --git a/moa/src/main/java/moa/classifiers/meta/AbstractOzaBagAdwin.java b/moa/src/main/java/moa/classifiers/meta/AbstractOzaBagAdwin.java
index e20c2dfeb..30573ad0e 100644
--- a/moa/src/main/java/moa/classifiers/meta/AbstractOzaBagAdwin.java
+++ b/moa/src/main/java/moa/classifiers/meta/AbstractOzaBagAdwin.java
@@ -104,7 +104,7 @@ public void resetLearningImpl() {
     public void trainOnInstanceImpl(Instance inst) {
         boolean Change = false;
         for (int i = 0; i < this.ensemble.size(); i++) {
-            int k = MiscUtils.poisson(1.0, this.classifierRandom);
+            int k = MiscUtils.poisson(6.0, this.classifierRandom);
             if (k > 0) {
                 Instance weightedInst = (Instance) inst.copy();
                 weightedInst.setWeight(inst.weight() * k);
@@ -128,6 +128,7 @@ public void trainOnInstanceImpl(Instance inst) {
             }
             if (imax != -1) {
                 this.ensemble.get(imax).resetLearning();
+                this.ensemble.get(imax).setRandomSeed(this.ensemble.get(imax).getRandomSeed() * 2);
                 this.ensemble.get(imax).trainOnInstance(inst);
                 this.ADError[imax] = new ADWIN();
             }
diff --git a/moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/MultiLabelBSTree.java b/moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/MultiLabelBSTree.java
index 2bd4160ea..97b2a82cd 100644
--- a/moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/MultiLabelBSTree.java
+++ b/moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/MultiLabelBSTree.java
@@ -30,24 +30,20 @@ public class MultiLabelBSTree extends AbstractOptionHandler implements NumericSt
 	protected DoubleVector[] rightStatistics;
 
 	public static double roundToSignificantFigures(double num, int n) {
-	    final double d = Math.ceil(Math.log10(num < 0 ? -num: num));
-	    final int power = n - (int) d;
+		final double d = Math.ceil(Math.log10(num < 0 ? -num: num));
+		final int power = n - (int) d;
 
-	    final double magnitude = Math.pow(10, power);
-	    final long shifted = (long) (num*magnitude);
-	    return shifted/magnitude;
+		final double magnitude = Math.pow(10, power);
+		final long shifted = (long) (num*magnitude);
+		return shifted/magnitude;
 	}
-	
+
 	@Override
-	public void observeAttribute(double inputAttributeValue,
-			DoubleVector[] statistics) {
-		if (!Double.isNaN(inputAttributeValue))
-		{
-//			if ((long) inputAttributeValue != inputAttributeValue) 
-//				inputAttributeValue = roundToSignificantFigures(inputAttributeValue, 4);
+	public void observeAttribute(double inputAttributeValue, DoubleVector[] statistics) {
+		if (!Double.isNaN(inputAttributeValue)) {
 			if (this.root == null) {
 				this.root = new Node(inputAttributeValue, statistics);
-				maxNodes=maxNodesOption.getValue();
+				maxNodes = maxNodesOption.getValue();
 			} else {
 				this.root.observeAttribute(inputAttributeValue, statistics);
 			}
@@ -57,8 +53,7 @@ public void observeAttribute(double inputAttributeValue,
 
 
 	@Override
-	public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(
-			MultiLabelSplitCriterion criterion, DoubleVector[] preSplitStatistics, int inputAttributeIndex) {
+	public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(MultiLabelSplitCriterion criterion, DoubleVector[] preSplitStatistics, int inputAttributeIndex) {
 		// Initialize global variables
 		int numOutputs = preSplitStatistics.length;
 		leftStatistics = new DoubleVector[numOutputs];
@@ -69,10 +64,13 @@ public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(
 			rightStatistics[i] = new DoubleVector(preSplitStatistics[i]);
 		}
 
-		return searchForBestSplitOption(this.root, null, criterion, preSplitStatistics, inputAttributeIndex);
+		AttributeExpansionSuggestion out = searchForBestSplitOption(this.root, null, criterion, preSplitStatistics, inputAttributeIndex);
+		leftStatistics = null;
+		rightStatistics = null;
+		return out;
 	}
 
-	protected AttributeExpansionSuggestion searchForBestSplitOption(Node currentNode, AttributeExpansionSuggestion currentBestOption, MultiLabelSplitCriterion criterion, DoubleVector [] preSplitStatistics, int inputAttributeIndex) {
+	protected AttributeExpansionSuggestion searchForBestSplitOption(Node currentNode, AttributeExpansionSuggestion currentBestOption, MultiLabelSplitCriterion criterion, DoubleVector[] preSplitStatistics, int inputAttributeIndex) {
 		// Return null if the current node is null or we have finished looking through all the possible splits
 		if (currentNode == null) { // TODO: JD check || countRightTotal == 0.0
 			return currentBestOption;
@@ -81,7 +79,7 @@ protected AttributeExpansionSuggestion searchForBestSplitOption(Node currentNode
 		if (currentNode.left != null) {
 			currentBestOption = searchForBestSplitOption(currentNode.left, currentBestOption, criterion, preSplitStatistics, inputAttributeIndex);
 		}
-		
+
 		for (int i=0; i<leftStatistics.length; i++)
 		{
 			leftStatistics[i].addValues(currentNode.statistics[i]);
@@ -110,7 +108,7 @@ protected AttributeExpansionSuggestion searchForBestSplitOption(Node currentNode
 			leftStatistics[i].subtractValues(currentNode.statistics[i]);
 			rightStatistics[i].addValues(currentNode.statistics[i]);
 		}
-		
+
 		return currentBestOption;
 	}
 
@@ -149,7 +147,7 @@ protected class Node implements Serializable {
 		private Node left;
 		private Node right;
 
-		public Node(double inputAttributeValue, DoubleVector [] statistics) {
+		public Node(double inputAttributeValue, DoubleVector[] statistics) {
 			cutPoint = inputAttributeValue;
 			int numOutputAttributes = statistics.length;
 			this.statistics=new DoubleVector[numOutputAttributes];
@@ -162,8 +160,8 @@ public Node(double inputAttributeValue, DoubleVector [] statistics) {
 		/**
 		 * Updates tree with new observation
 		 */
-		public void observeAttribute(double inputAttributeValue, DoubleVector [] statistics) {
-			if (inputAttributeValue <= this.cutPoint) {
+		public void observeAttribute(double inputAttributeValue, DoubleVector[] statistics) {
+			if (inputAttributeValue == this.cutPoint) {
 				for (int i=0; i < statistics.length; i++)
 					this.statistics[i].addValues(statistics[i]);
 			}
@@ -189,6 +187,4 @@ else if (inputAttributeValue < this.cutPoint) {
 			}
 		}
 	}
-
-
 }
diff --git a/moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/MultiLabelBSTreePCT.java b/moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/MultiLabelBSTreePCT.java
index 595772256..b61d18bad 100644
--- a/moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/MultiLabelBSTreePCT.java
+++ b/moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/MultiLabelBSTreePCT.java
@@ -33,42 +33,27 @@ public class MultiLabelBSTreePCT extends AbstractOptionHandler implements Numeri
 	protected DoubleVector[] leftInputStatistics;
 	protected DoubleVector[] rightInputStatistics;
 
-	
+
 	public static double roundToSignificantFigures(double num, int n) {
-	    final double d = Math.ceil(Math.log10(num < 0 ? -num: num));
-	    final int power = n - (int) d;
+		final double d = Math.ceil(Math.log10(num < 0 ? -num: num));
+		final int power = n - (int) d;
 
-	    final double magnitude = Math.pow(10, power);
-	    final long shifted = (long) (num*magnitude);
-	    return shifted/magnitude;
+		final double magnitude = Math.pow(10, power);
+		final long shifted = (long) (num*magnitude);
+		return shifted/magnitude;
 	}
-	
+
 	@Override
 	public void observeAttribute(double inputAttributeValue, DoubleVector[] statistics) {
-		// DON'T CALL THIS
-		if (!Double.isNaN(inputAttributeValue))
-		{
-//			if ((long) inputAttributeValue != inputAttributeValue) 
-////				inputAttributeValue = roundToSignificantFigures(inputAttributeValue, 4);
-//			if (this.root == null) {
-//				this.root = new Node(inputAttributeValue, statistics);
-//				maxNodes=maxNodesOption.getValue();
-//			} else {
-//				this.root.observeAttribute(inputAttributeValue, statistics);
-//			}
-		}
-
+		throw new UnsupportedOperationException("This is an attribute observer used for PCTs and needs both input and output statistics.");
 	}
 
 	public void observeAttribute(double inputAttributeValue, DoubleVector[] targetStatistics, DoubleVector[] inputStatistics) {
-		// DON'T CALL THIS
 		if (!Double.isNaN(inputAttributeValue))
 		{
-//			if ((long) inputAttributeValue != inputAttributeValue) 
-////				inputAttributeValue = roundToSignificantFigures(inputAttributeValue, 4);
 			if (this.root == null) {
 				this.root = new Node(inputAttributeValue, targetStatistics, inputStatistics);
-				maxNodes=maxNodesOption.getValue();
+				maxNodes = maxNodesOption.getValue();
 			} else {
 				this.root.observeAttribute(inputAttributeValue, targetStatistics, inputStatistics);
 			}
@@ -78,24 +63,11 @@ public void observeAttribute(double inputAttributeValue, DoubleVector[] targetSt
 
 
 	@Override
-	public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(
-			MultiLabelSplitCriterion criterion, DoubleVector[] preSplitStatistics, int inputAttributeIndex) {
-		// Initialize global variables
-//		int numOutputs = preSplitStatistics.length;
-//		leftStatistics = new DoubleVector[numOutputs];
-//		rightStatistics = new DoubleVector[numOutputs];
-//		for (int i=0; i< numOutputs; i++)
-//		{
-//			leftStatistics[i] = new DoubleVector(new double [preSplitStatistics[i].numValues()]); //sets statistics to zeros
-//			rightStatistics[i] = new DoubleVector(preSplitStatistics[i]);
-//		}
-
-//		return searchForBestSplitOption(this.root, null, criterion, preSplitStatistics, inputAttributeIndex);
-		return null;
+	public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(MultiLabelSplitCriterion criterion, DoubleVector[] preSplitStatistics, int inputAttributeIndex) {
+		throw new UnsupportedOperationException("This is an attribute observer used for PCTs and needs both input and output statistics.");
 	}
 
-	public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(
-			MultiLabelSplitCriterion criterion, DoubleVector[] preSplitTargetStatistics, DoubleVector[] preSplitInputStatistics, int inputAttributeIndex) {
+	public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(MultiLabelSplitCriterion criterion, DoubleVector[] preSplitTargetStatistics, DoubleVector[] preSplitInputStatistics, int inputAttributeIndex) {
 		// Initialize global variables
 		int numOutputs = preSplitTargetStatistics.length;
 		int numInputs = preSplitInputStatistics.length;
@@ -106,12 +78,12 @@ public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(
 		leftInputStatistics = new DoubleVector[numInputs];
 		rightInputStatistics = new DoubleVector[numInputs];
 
-		for (int i=0; i< numOutputs; i++)
+		for (int i=0; i < numOutputs; i++)
 		{
 			leftTargetStatistics[i] = new DoubleVector(new double [preSplitTargetStatistics[i].numValues()]); //sets statistics to zeros
 			rightTargetStatistics[i] = new DoubleVector(preSplitTargetStatistics[i]);
 		}
-		for (int i=0; i< numInputs; i++)
+		for (int i=0; i < numInputs; i++)
 		{
 			leftInputStatistics[i] = new DoubleVector(new double [preSplitInputStatistics[i].numValues()]); //sets statistics to zeros
 			rightInputStatistics[i] = new DoubleVector(preSplitInputStatistics[i]);
@@ -120,9 +92,8 @@ public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(
 		return searchForBestSplitOption(this.root, null, criterion, preSplitTargetStatistics, preSplitInputStatistics, inputAttributeIndex);
 	}
 
-	
-	protected AttributeExpansionSuggestion searchForBestSplitOption(Node currentNode, AttributeExpansionSuggestion currentBestOption,
-			MultiLabelSplitCriterion criterion, DoubleVector [] preSplitTargetStatistics, DoubleVector [] preSplitInputStatistics, int inputAttributeIndex) {
+
+	protected AttributeExpansionSuggestion searchForBestSplitOption(Node currentNode, AttributeExpansionSuggestion currentBestOption, MultiLabelSplitCriterion criterion, DoubleVector[] preSplitTargetStatistics, DoubleVector[] preSplitInputStatistics, int inputAttributeIndex) {
 		// Return null if the current node is null or we have finished looking through all the possible splits
 		if (currentNode == null) { // TODO: JD check || countRightTotal == 0.0
 			return currentBestOption;
@@ -131,7 +102,7 @@ protected AttributeExpansionSuggestion searchForBestSplitOption(Node currentNode
 		if (currentNode.left != null) {
 			currentBestOption = searchForBestSplitOption(currentNode.left, currentBestOption, criterion, preSplitTargetStatistics, preSplitInputStatistics, inputAttributeIndex);
 		}
-		
+
 		for (int i=0; i<leftTargetStatistics.length; i++)
 		{
 			leftTargetStatistics[i].addValues(currentNode.targetStatistics[i]);
@@ -144,9 +115,9 @@ protected AttributeExpansionSuggestion searchForBestSplitOption(Node currentNode
 			rightInputStatistics[i].subtractValues(currentNode.inputStatistics[i]);
 		}
 
-		
-		DoubleVector[][] postSplitTargetDists = new DoubleVector [leftTargetStatistics.length + leftInputStatistics.length][2];
-		DoubleVector[][] postSplitInputDists = new DoubleVector [leftTargetStatistics.length + leftInputStatistics.length][2];
+
+		DoubleVector[][] postSplitTargetDists = new DoubleVector [leftTargetStatistics.length][2];
+		DoubleVector[][] postSplitInputDists = new DoubleVector [leftInputStatistics.length][2];
 		for (int i=0; i<leftTargetStatistics.length; i++)
 		{
 			postSplitTargetDists[i] = new DoubleVector[2];
@@ -163,7 +134,7 @@ protected AttributeExpansionSuggestion searchForBestSplitOption(Node currentNode
 
 		double merit = ((PCTWeightedICVarianceReduction) criterion).getMeritOfSplit(preSplitTargetStatistics, postSplitTargetDists, preSplitInputStatistics, postSplitInputDists);
 
-		if ((currentBestOption == null) || (merit > currentBestOption.merit)) {
+		if ((!Double.isNaN(merit)) && (currentBestOption == null || (merit > currentBestOption.merit))) {
 			currentBestOption = new AttributeExpansionSuggestion(new NumericRulePredicate(inputAttributeIndex, currentNode.cutPoint, true), Utils.copy(postSplitTargetDists), merit);
 		}
 
@@ -178,7 +149,7 @@ protected AttributeExpansionSuggestion searchForBestSplitOption(Node currentNode
 			leftInputStatistics[i].subtractValues(currentNode.inputStatistics[i]);
 			rightInputStatistics[i].addValues(currentNode.inputStatistics[i]);
 		}
-		
+
 		return currentBestOption;
 	}
 
@@ -213,7 +184,7 @@ protected class Node implements Serializable {
 		// E-BST statistics
 		private DoubleVector[] targetStatistics;
 		private DoubleVector[] inputStatistics;
-		
+
 
 		// Child nodes
 		private Node left;
@@ -225,8 +196,11 @@ public Node(double inputAttributeValue, DoubleVector[] targetStatistics, DoubleV
 			int numInputAttributes = inputStatistics.length;
 			this.targetStatistics = new DoubleVector[numOutputAttributes];
 			this.inputStatistics = new DoubleVector[numInputAttributes];
-			for (int i=0; i<numOutputAttributes; i++) {					
-				this.targetStatistics[i]=new DoubleVector(targetStatistics[i]);
+			for (int i=0; i<numOutputAttributes; i++) {		
+				if (targetStatistics[i] != null)
+					this.targetStatistics[i]= new DoubleVector(targetStatistics[i]);
+				else
+					this.targetStatistics[i] = new DoubleVector();
 			}
 			for (int i=0; i<numInputAttributes; i++) {					
 				this.inputStatistics[i]=new DoubleVector(inputStatistics[i]);
@@ -236,28 +210,28 @@ public Node(double inputAttributeValue, DoubleVector[] targetStatistics, DoubleV
 		/**
 		 * Updates tree with new observation
 		 */
-		public void observeAttribute(double inputAttributeValue, DoubleVector[]targetStatistics, DoubleVector[] inputStatistics) {
-			if (inputAttributeValue <= this.cutPoint) {
+		public void observeAttribute(double inputAttributeValue, DoubleVector[] targetStatistics, DoubleVector[] inputStatistics) {
+			if (inputAttributeValue == this.cutPoint) {
 				for (int i=0; i < targetStatistics.length; i++)
-					this.targetStatistics[i].addValues(targetStatistics[i]);
+					if (targetStatistics[i] != null)
+						this.targetStatistics[i].addValues(targetStatistics[i]);
 				for (int i=0; i < inputStatistics.length; i++)
 					this.inputStatistics[i].addValues(inputStatistics[i]);
-			}
-			else if (inputAttributeValue < this.cutPoint) {
+
+			} else if (inputAttributeValue < this.cutPoint) {
 				if (this.left == null) {
-					if (numNodes<maxNodes) {
+					if (numNodes < maxNodes) {
 						this.left = new Node(inputAttributeValue, targetStatistics, inputStatistics);
-						++numNodes;
+						numNodes++;
 					}
 				} else {
 					this.left.observeAttribute(inputAttributeValue, targetStatistics, inputStatistics);
 				}
-			}
-			else { 
+			} else { 
 				if (this.right == null) {
-					if(numNodes<maxNodes){
+					if(numNodes < maxNodes){
 						this.right = new Node(inputAttributeValue, targetStatistics, inputStatistics);
-						++numNodes;
+						numNodes++;
 					}
 				} else {
 					this.right.observeAttribute(inputAttributeValue, targetStatistics, inputStatistics);
diff --git a/moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/ICVarianceReduction.java b/moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/ICVarianceReduction.java
index 72c723b2d..b8b85620e 100644
--- a/moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/ICVarianceReduction.java
+++ b/moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/ICVarianceReduction.java
@@ -70,7 +70,7 @@ protected double getMeritOfSplitForAttribute(DoubleVector preSplitDist, DoubleVe
 		//count number of branches with weightSeen higher than threshold
 		int count = 0; 
 		for(int i = 0; i < postSplitDists.length; i++)
-			if(postSplitDists[i].getValue(0) >=0.05*preSplitDist.getValue(0))
+			if(postSplitDists[i].getValue(0) >= 0.05 * preSplitDist.getValue(0))
 				count = count +1;
 		//Consider split if all branches have required weight seen
 		if(count == postSplitDists.length){
@@ -82,9 +82,12 @@ protected double getMeritOfSplitForAttribute(DoubleVector preSplitDist, DoubleVe
 			}
 			double [] variances=getBranchSplitVarianceOutput(postSplitDists);
 			for(int i = 0; i < variances.length; i++)
-				if(postSplitDists[i].getValue(0)>0)
-					sumVarPostSplit+=(postSplitDists[i].getValue(0)/weightTotal*variances[i]);  //weight variance
-			merit= 1 - sumVarPostSplit / varPreSplit;
+				if(postSplitDists[i].getValue(0) > 0)
+					sumVarPostSplit += (postSplitDists[i].getValue(0)/weightTotal*variances[i]);  //weight variance
+			if (sumVarPostSplit == 0 && varPreSplit == 0)
+				merit = 0;
+			else
+				merit= 1 - sumVarPostSplit / varPreSplit;
 		}
 		/*if(merit<0 || merit>1)
 			System.out.println("out of range");*/
diff --git a/moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/PCTWeightedICVarianceReduction.java b/moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/PCTWeightedICVarianceReduction.java
index 5efe79e7b..0f74bb7fb 100644
--- a/moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/PCTWeightedICVarianceReduction.java
+++ b/moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/PCTWeightedICVarianceReduction.java
@@ -4,6 +4,8 @@
 
 public class PCTWeightedICVarianceReduction extends WeightedICVarianceReduction {
 
+	private static final long serialVersionUID = 1L;
+
 	public DoubleVector inputWeights;
 	
 	public double targetInputTradeoff; // \in [0, 1]
@@ -19,12 +21,15 @@ public double getMeritOfSplit(DoubleVector[] preSplitTargetDist, DoubleVector[][
 		double inputError = 0;
 		int numTargets=preSplitTargetDist.length;
 		int numInputs=preSplitInputDist.length;
-		for (int i=0; i<numTargets; i++)
-			targetError += weights.getValue(i) * getMeritOfSplitForAttribute(preSplitTargetDist[i],postSplitTargetDists[i]);
+		for (int i=0; i<numTargets; i++) {
+			if (postSplitTargetDists[i][0].getValue(0) == 0 || postSplitTargetDists[i][1].getValue(0) == 0)
+				// If the split would result in a leaf without labeled instances, discard it
+				return Double.NaN;
+			targetError += weights.getValue(i) * getMeritOfSplitForAttribute(preSplitTargetDist[i], postSplitTargetDists[i]);
+		}
 		for (int i=0; i<numInputs; i++)
-			targetError += inputWeights.getValue(i) * getMeritOfSplitForAttribute(preSplitInputDist[i],postSplitInputDists[i]);
+			inputError += inputWeights.getValue(i) * getMeritOfSplitForAttribute(preSplitInputDist[i], postSplitInputDists[i]);
 
-		
 		return targetInputTradeoff * targetError / weights.sumOfValues() + (1 - targetInputTradeoff) * inputError / inputWeights.sumOfValues();
 	}
 
@@ -37,7 +42,7 @@ protected double getMeritOfSplitForAttribute(DoubleVector preSplitDist, DoubleVe
 				count = count +1;
 		//Consider split if all branches have required weight seen
 		if(count == postSplitDists.length){
-			double varPreSplit=computeVariance(preSplitDist);
+			double varPreSplit = computeVariance(preSplitDist);
 			double sumVarPostSplit=0;
 			double weightTotal=0;
 			for (int i=0; i<postSplitDists.length;i++){
@@ -46,8 +51,11 @@ protected double getMeritOfSplitForAttribute(DoubleVector preSplitDist, DoubleVe
 			double [] variances=getBranchSplitVarianceOutput(postSplitDists);
 			for(int i = 0; i < variances.length; i++)
 				if(postSplitDists[i].getValue(0)>0)
-					sumVarPostSplit+=(postSplitDists[i].getValue(0)/weightTotal*variances[i]);  //weight variance
-			merit= 1 - sumVarPostSplit / varPreSplit;
+					sumVarPostSplit += (postSplitDists[i].getValue(0)/weightTotal*variances[i]);  //weight variance
+			if (varPreSplit > 0.0)
+				merit = 1 - sumVarPostSplit / varPreSplit;
+			else
+				merit = 0.0;
 		}
 		/*if(merit<0 || merit>1)
 			System.out.println("out of range");*/
diff --git a/moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/WeightedICVarianceReduction.java b/moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/WeightedICVarianceReduction.java
index 98f9d3c19..a78ffab05 100644
--- a/moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/WeightedICVarianceReduction.java
+++ b/moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/WeightedICVarianceReduction.java
@@ -29,6 +29,8 @@ public double getMeritOfSplit(DoubleVector[] preSplitDist, DoubleVector[][] post
 		double error=0;
 		int numOutputs=preSplitDist.length;
 		for (int i=0; i<numOutputs; i++)
+			// TEMPORARY
+			//error += (1 / weights.getValue(i)) * getMeritOfSplitForOutput(preSplitDist,postSplitDists,i);
 			error += weights.getValue(i) * getMeritOfSplitForOutput(preSplitDist,postSplitDists,i);
 		return error / weights.sumOfValues();
 	}
diff --git a/moa/src/main/java/moa/classifiers/mlc/meta/AdaptiveRandomForestMultiTargetRegression.java b/moa/src/main/java/moa/classifiers/mlc/meta/AdaptiveRandomForestMultiTargetRegression.java
new file mode 100644
index 000000000..5ce00ca7f
--- /dev/null
+++ b/moa/src/main/java/moa/classifiers/mlc/meta/AdaptiveRandomForestMultiTargetRegression.java
@@ -0,0 +1,516 @@
+/*
+ *    AdaptiveRandomForest.java
+ * 
+ *    @author Heitor Murilo Gomes (heitor_murilo_gomes at yahoo dot com dot br)
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ */
+package moa.classifiers.mlc.meta;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.StructuredInstance;
+import com.yahoo.labs.samoa.instances.predictions.MultiTargetRegressionPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.classifiers.AbstractClassifier;
+import moa.classifiers.AbstractMultiTargetRegressor;
+import moa.classifiers.AbstractRegressor;
+// import moa.classifiers.MultiClassClassifier;
+import moa.core.DoubleVector;
+import moa.core.InstanceExample;
+import moa.core.Measurement;
+import moa.core.MiscUtils;
+import moa.options.ClassOption;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.concurrent.Callable;
+
+// import moa.classifiers.trees.ARFHoeffdingTree;
+import moa.evaluation.BasicClassificationPerformanceEvaluator;
+import moa.learners.MultiTargetRegressor;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import moa.AbstractMOAObject;
+import moa.classifiers.core.driftdetection.ChangeDetector;
+import moa.classifiers.mtr.trees.ISOUPTree;
+import moa.classifiers.mtr.trees.ISOUPTreeRF;
+
+
+/**
+ * Adaptive Random Forest
+ *
+ * <p>Adaptive Random Forest (ARF). The 3 most important aspects of this 
+ * ensemble classifier are: (1) inducing diversity through resampling;
+ * (2) inducing diversity through randomly selecting subsets of features for 
+ * node splits (See moa.classifiers.trees.ARFHoeffdingTree.java); (3) drift 
+ * detectors per base tree, which cause selective resets in response to drifts. 
+ * It also allows training background trees, which start training if a warning
+ * is detected and replace the active tree if the warning escalates to a drift. </p>
+ *
+ * <p>See details in:<br> Heitor Murilo Gomes, Albert Bifet, Jesse Read, 
+ * Jean Paul Barddal, Fabricio Enembreck, Bernhard Pfharinger, Geoff Holmes, 
+ * Talel Abdessalem. Adaptive random forests for evolving data stream classification. 
+ * In Machine Learning, DOI: 10.1007/s10994-017-5642-8, Springer, 2017.</p>
+ *
+ * <p>Parameters:</p> <ul>
+ * <li>-l : Classifier to train. Must be set to ARFHoeffdingTree</li>
+ * <li>-s : The number of trees in the ensemble</li>
+ * <li>-o : How the number of features is interpreted (4 options): 
+ * "Specified m (integer value)", "sqrt(M)+1", "M-(sqrt(M)+1)"</li>
+ * <li>-m : Number of features allowed considered for each split. Negative 
+ * values corresponds to M - m</li>
+ * <li>-a : The lambda value for bagging (lambda=6 corresponds to levBag)</li>
+ * <li>-j : Number of threads to be used for training</li>
+ * <li>-x : Change detector for drifts and its parameters</li>
+ * <li>-p : Change detector for warnings (start training bkg learner)</li>
+ * <li>-w : Should use weighted voting?</li>
+ * <li>-u : Should use drift detection? If disabled then bkg learner is also disabled</li>
+ * <li>-q : Should use bkg learner? If disabled then reset tree immediately</li>
+ * </ul>
+ *
+ * @author Heitor Murilo Gomes (heitor_murilo_gomes at yahoo dot com dot br)
+ * @version $Revision: 1 $
+ */
+public class AdaptiveRandomForestMultiTargetRegression extends AbstractMultiTargetRegressor implements MultiTargetRegressor {
+
+    @Override
+    public String getPurposeString() {
+        return "Adaptive Random Forest algorithm for evolving data streams from Gomes et al.";
+    }
+    
+    private static final long serialVersionUID = 1L;
+
+    public ClassOption treeLearnerOption = new ClassOption("treeLearner", 'l',
+            "Random Forest Tree.", MultiTargetRegressor.class,
+            "iSOUPTreeRF");
+
+    public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's',
+        "The number of trees.", 10, 1, Integer.MAX_VALUE);
+    
+    public MultiChoiceOption mFeaturesModeOption = new MultiChoiceOption("mFeaturesMode", 'o', 
+        "Defines how m, defined by mFeaturesPerTreeSize, is interpreted. M represents the total number of features.",
+        new String[]{"Specified m (integer value)", "sqrt(M)+1", "M-(sqrt(M)+1)",
+            "Percentage (M * (m / 100))"},
+        new String[]{"SpecifiedM", "SqrtM1", "MSqrtM1", "Percentage"}, 1);
+    
+    public IntOption mFeaturesPerTreeSizeOption = new IntOption("mFeaturesPerTreeSize", 'm',
+        "Number of features allowed considered for each split. Negative values corresponds to M - m", 2, Integer.MIN_VALUE, Integer.MAX_VALUE);
+    
+    public FloatOption lambdaOption = new FloatOption("lambda", 'a',
+        "The lambda parameter for bagging.", 6.0, 1.0, Float.MAX_VALUE);
+
+    public IntOption numberOfJobsOption = new IntOption("numberOfJobs", 'j',
+        "Total number of concurrent jobs used for processing (-1 = as much as possible, 0 = do not use multithreading)", 1, -1, Integer.MAX_VALUE);
+    
+    public ClassOption driftDetectionMethodOption = new ClassOption("driftDetectionMethod", 'x',
+        "Change detector for drifts and its parameters", ChangeDetector.class, "ADWINChangeDetector -a 1.0E-5");
+
+    public ClassOption warningDetectionMethodOption = new ClassOption("warningDetectionMethod", 'p',
+        "Change detector for warnings (start training bkg learner)", ChangeDetector.class, "ADWINChangeDetector -a 1.0E-4");
+    
+    public FlagOption disableWeightedVote = new FlagOption("disableWeightedVote", 'w', 
+            "Should use weighted voting?");
+    
+    public FlagOption disableDriftDetectionOption = new FlagOption("disableDriftDetection", 'u',
+        "Should use drift detection? If disabled then bkg learner is also disabled");
+
+    public FlagOption disableBackgroundLearnerOption = new FlagOption("disableBackgroundLearner", 'q', 
+        "Should use bkg learner? If disabled then reset tree immediately.");
+    
+    protected static final int FEATURES_M = 0;
+    protected static final int FEATURES_SQRT = 1;
+    protected static final int FEATURES_SQRT_INV = 2;
+    protected static final int FEATURES_PERCENT = 3;
+    
+    protected static final int SINGLE_THREAD = 0;
+	
+    protected ARFBaseLearnerMTR[] ensemble;
+    protected long instancesSeen;
+    protected int subspaceSize;
+    protected BasicClassificationPerformanceEvaluator evaluator;
+
+    private ExecutorService executor;
+    
+    @Override
+    public void resetLearningImpl() {
+        // Reset attributes
+        this.ensemble = null;
+        this.subspaceSize = 0;
+        this.instancesSeen = 0;
+        this.evaluator = new BasicClassificationPerformanceEvaluator();
+        
+        // Multi-threading
+        int numberOfJobs;
+        if(this.numberOfJobsOption.getValue() == -1) 
+            numberOfJobs = Runtime.getRuntime().availableProcessors();
+        else 
+            numberOfJobs = this.numberOfJobsOption.getValue();
+        // SINGLE_THREAD and requesting for only 1 thread are equivalent. 
+        // this.executor will be null and not used...
+        if(numberOfJobs != AdaptiveRandomForestMultiTargetRegression.SINGLE_THREAD && numberOfJobs != 1)
+            this.executor = Executors.newFixedThreadPool(numberOfJobs);
+    }
+
+    @Override
+    public void trainOnInstanceImpl(Instance instance) {
+        ++this.instancesSeen;
+        if(this.ensemble == null) 
+            initEnsemble(instance);
+        
+        Collection<TrainingRunnable> trainers = new ArrayList<TrainingRunnable>();
+        for (int i = 0 ; i < this.ensemble.length ; i++) {
+            DoubleVector vote = this.ensemble[i].getPredictionForInstance(instance).asDoubleVector();
+            InstanceExample example = new InstanceExample(instance);
+            this.ensemble[i].evaluator.addResult(example, vote.getArrayRef());
+            int k = MiscUtils.poisson(this.lambdaOption.getValue(), this.classifierRandom);
+            if (k > 0) {
+                if(this.executor != null) {
+                    TrainingRunnable trainer = new TrainingRunnable(this.ensemble[i], 
+                        instance, k, this.instancesSeen);
+                    trainers.add(trainer);
+                }
+                else { // SINGLE_THREAD is in-place... 
+                    this.ensemble[i].trainOnInstance(instance, k, this.instancesSeen);
+                }
+            }
+        }
+        if(this.executor != null) {
+            try {
+                this.executor.invokeAll(trainers);
+            } catch (InterruptedException ex) {
+                throw new RuntimeException("Could not call invokeAll() on training threads.");
+            }
+        }
+    }
+
+   public Prediction getPredictionForInstance(Instance instance) {
+    	Instance testInstance = instance.copy();
+        if(this.ensemble == null) 
+            initEnsemble(testInstance);
+        DoubleVector combinedVote = new DoubleVector();
+
+        for(int i = 0 ; i < this.ensemble.length ; ++i) {
+            DoubleVector vote = this.ensemble[i].getPredictionForInstance(testInstance).asDoubleVector();
+            if (vote.sumOfValues() > 0.0) {
+                vote.normalize();
+                double acc = this.ensemble[i].evaluator.getPerformanceMeasurements()[1].getValue();
+                if(! this.disableWeightedVote.isSet() && acc > 0.0) {                        
+                    for(int v = 0 ; v < vote.numValues() ; ++v) {
+                        vote.setValue(v, vote.getValue(v) * acc);
+                    }
+                }
+                combinedVote.addValues(vote);
+            }
+        }
+        return new MultiTargetRegressionPrediction(combinedVote);
+    }
+    
+    //@Override
+    public double[] getVotesForInstance(Instance instance) {
+        Instance testInstance = instance.copy();
+        if(this.ensemble == null) 
+            initEnsemble(testInstance);
+        DoubleVector combinedVote = new DoubleVector();
+
+        for(int i = 0 ; i < this.ensemble.length ; ++i) {
+            DoubleVector vote = new DoubleVector(this.ensemble[i].getVotesForInstance(testInstance));
+            if (vote.sumOfValues() > 0.0) {
+                vote.normalize();
+                double acc = this.ensemble[i].evaluator.getPerformanceMeasurements()[1].getValue();
+                if(! this.disableWeightedVote.isSet() && acc > 0.0) {                        
+                    for(int v = 0 ; v < vote.numValues() ; ++v) {
+                        vote.setValue(v, vote.getValue(v) * acc);
+                    }
+                }
+                combinedVote.addValues(vote);
+            }
+        }
+        return combinedVote.getArrayRef();
+    }
+
+    @Override
+    public boolean isRandomizable() {
+        return true;
+    }
+
+    @Override
+    public void getModelDescription(StringBuilder arg0, int arg1) {
+    }
+
+    @Override
+    protected Measurement[] getModelMeasurementsImpl() {
+        return null;
+    }
+
+    protected void initEnsemble(Instance instance) {
+        // Init the ensemble.
+        int ensembleSize = this.ensembleSizeOption.getValue();
+        this.ensemble = new ARFBaseLearnerMTR[ensembleSize];
+        
+        // TODO: this should be an option with default = BasicClassificationPerformanceEvaluator
+//        BasicClassificationPerformanceEvaluator classificationEvaluator = (BasicClassificationPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
+        BasicClassificationPerformanceEvaluator classificationEvaluator = new BasicClassificationPerformanceEvaluator();
+        
+        this.subspaceSize = this.mFeaturesPerTreeSizeOption.getValue();
+  
+        // The size of m depends on:
+        // 1) mFeaturesPerTreeSizeOption
+        // 2) mFeaturesModeOption
+        int n = instance.numAttributes()-1; // Ignore class label ( -1 )
+        
+        switch(this.mFeaturesModeOption.getChosenIndex()) {
+            case AdaptiveRandomForestMultiTargetRegression.FEATURES_SQRT:
+                this.subspaceSize = (int) Math.round(Math.sqrt(n)) + 1;
+                break;
+            case AdaptiveRandomForestMultiTargetRegression.FEATURES_SQRT_INV:
+                this.subspaceSize = n - (int) Math.round(Math.sqrt(n) + 1);
+                break;
+            case AdaptiveRandomForestMultiTargetRegression.FEATURES_PERCENT:
+                // If subspaceSize is negative, then first find out the actual percent, i.e., 100% - m.
+                double percent = this.subspaceSize < 0 ? (100 + this.subspaceSize)/100.0 : this.subspaceSize / 100.0;
+                this.subspaceSize = (int) Math.round(n * percent);
+                break;
+        }
+        // Notice that if the selected mFeaturesModeOption was 
+        //  AdaptiveRandomForest.FEATURES_M then nothing is performed in the
+        //  previous switch-case, still it is necessary to check (and adjusted) 
+        //  for when a negative value was used. 
+        
+        // m is negative, use size(features) + -m
+        if(this.subspaceSize < 0)
+            this.subspaceSize = n + this.subspaceSize;
+        // Other sanity checks to avoid runtime errors. 
+        //  m <= 0 (m can be negative if this.subspace was negative and 
+        //  abs(m) > n), then use m = 1
+        if(this.subspaceSize <= 0)
+            this.subspaceSize = 1;
+        // m > n, then it should use n
+        if(this.subspaceSize > n)
+            this.subspaceSize = n;
+        
+        ISOUPTreeRF treeLearner = (ISOUPTreeRF) getPreparedClassOption(this.treeLearnerOption);
+        treeLearner.resetLearning();
+        
+        for(int i = 0 ; i < ensembleSize ; ++i) {
+            treeLearner.subspaceSize = this.subspaceSize;
+            this.ensemble[i] = new ARFBaseLearnerMTR(
+                i, 
+                (ISOUPTreeRF) treeLearner.copy(), 
+                (BasicClassificationPerformanceEvaluator) classificationEvaluator.copy(), 
+                this.instancesSeen, 
+                ! this.disableBackgroundLearnerOption.isSet(),
+                ! this.disableDriftDetectionOption.isSet(), 
+                driftDetectionMethodOption,
+                warningDetectionMethodOption,
+                false);
+        }
+    }
+    
+    /**
+     * Inner class that represents a single tree member of the forest. 
+     * It contains some analysis information, such as the numberOfDriftsDetected, 
+     */
+    protected final class ARFBaseLearnerMTR extends AbstractMOAObject {
+        public int indexOriginal;
+        public long createdOn;
+        public long lastDriftOn;
+        public long lastWarningOn;
+        public ISOUPTreeRF classifier;
+        public boolean isBackgroundLearner;
+        
+        // The drift and warning object parameters. 
+        protected ClassOption driftOption;
+        protected ClassOption warningOption;
+        
+        // Drift and warning detection
+        protected ChangeDetector driftDetectionMethod;
+        protected ChangeDetector warningDetectionMethod;
+        
+        public boolean useBkgLearner;
+        public boolean useDriftDetector;
+        
+        // Bkg learner
+        protected ARFBaseLearnerMTR bkgLearner;
+        // Statistics
+        public BasicClassificationPerformanceEvaluator evaluator;
+        protected int numberOfDriftsDetected;
+        protected int numberOfWarningsDetected;
+
+        private void init(int indexOriginal, ISOUPTreeRF instantiatedClassifier, BasicClassificationPerformanceEvaluator evaluatorInstantiated, 
+            long instancesSeen, boolean useBkgLearner, boolean useDriftDetector, ClassOption driftOption, ClassOption warningOption, boolean isBackgroundLearner) {
+            this.indexOriginal = indexOriginal;
+            this.createdOn = instancesSeen;
+            this.lastDriftOn = 0;
+            this.lastWarningOn = 0;
+            
+            this.classifier = instantiatedClassifier;
+            this.evaluator = evaluatorInstantiated;
+            this.useBkgLearner = useBkgLearner;
+            this.useDriftDetector = useDriftDetector;
+            
+            this.numberOfDriftsDetected = 0;
+            this.numberOfWarningsDetected = 0;
+            this.isBackgroundLearner = isBackgroundLearner;
+
+            if(this.useDriftDetector) {
+                this.driftOption = driftOption;
+                this.driftDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.driftOption)).copy();
+            }
+
+            // Init Drift Detector for Warning detection. 
+            if(this.useBkgLearner) {
+                this.warningOption = warningOption;
+                this.warningDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.warningOption)).copy();
+            }
+        }
+
+        public ARFBaseLearnerMTR(int indexOriginal, ISOUPTreeRF instantiatedClassifier, BasicClassificationPerformanceEvaluator evaluatorInstantiated, 
+                    long instancesSeen, boolean useBkgLearner, boolean useDriftDetector, ClassOption driftOption, ClassOption warningOption, boolean isBackgroundLearner) {
+            init(indexOriginal, instantiatedClassifier, evaluatorInstantiated, instancesSeen, useBkgLearner, useDriftDetector, driftOption, warningOption, isBackgroundLearner);
+        }
+
+        public void reset() {
+            if(this.useBkgLearner && this.bkgLearner != null) {
+                this.classifier = this.bkgLearner.classifier;
+                
+                this.driftDetectionMethod = this.bkgLearner.driftDetectionMethod;
+                this.warningDetectionMethod = this.bkgLearner.warningDetectionMethod;
+                
+                this.evaluator = this.bkgLearner.evaluator;
+                this.createdOn = this.bkgLearner.createdOn;
+                this.bkgLearner = null;
+            }
+            else {
+                this.classifier.resetLearning();
+                this.createdOn = instancesSeen;
+                this.driftDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.driftOption)).copy();
+            }
+            this.evaluator.reset();
+        }
+
+        public void trainOnInstance(Instance instance, double weight, long instancesSeen) {
+            Instance weightedInstance = (Instance) instance.copy();
+            weightedInstance.setWeight(instance.weight() * weight);
+            this.classifier.trainOnInstance(weightedInstance);
+            
+            if(this.bkgLearner != null)
+                this.bkgLearner.classifier.trainOnInstance(instance);
+            
+            // Should it use a drift detector? Also, is it a backgroundLearner? If so, then do not "incept" another one. 
+            if(this.useDriftDetector && !this.isBackgroundLearner) {
+                // boolean correctlyClassifies = this.classifier.(instance);
+            	// public double getAdwinError(Instance inst, int i) {
+        		double sum = 0.0;
+        		if (this.classifier instanceof ISOUPTree) {
+        			double[] normalizedError = ((ISOUPTree) this.classifier).getNormalizedError(instance, this.classifier.getPredictionForInstance(instance).asDoubleArray());
+        			for (int j = 0; j < instance.numOutputAttributes(); j++) {
+        				sum += normalizedError[j];
+        			}
+        		} else {
+        			Prediction prediction = this.classifier.getPredictionForInstance(instance);
+        			for (int j = 0; j < instance.numOutputAttributes(); j++) {
+        				sum += Math.abs(prediction.getPrediction(j) - instance.valueOutputAttribute(j));
+        			}
+        		}
+        		sum = sum / instance.numOutputAttributes();
+        		//return sum;
+            	//}
+                // Check for warning only if useBkgLearner is active
+                if(this.useBkgLearner) {
+                    // Update the warning detection method
+                    this.warningDetectionMethod.input(sum);
+                    // Check if there was a change
+                    if(this.warningDetectionMethod.getChange()) {
+                        this.lastWarningOn = instancesSeen;
+                        this.numberOfWarningsDetected++;
+                        // Create a new bkgTree classifier
+                        ISOUPTreeRF bkgClassifier = (ISOUPTreeRF) this.classifier.copy();
+                        bkgClassifier.resetLearning();
+                        
+                        // Resets the evaluator
+                        BasicClassificationPerformanceEvaluator bkgEvaluator = (BasicClassificationPerformanceEvaluator) this.evaluator.copy();
+                        bkgEvaluator.reset();
+                        
+                        // Create a new bkgLearner object
+                        this.bkgLearner = new ARFBaseLearnerMTR(indexOriginal, bkgClassifier, bkgEvaluator, instancesSeen, 
+                            this.useBkgLearner, this.useDriftDetector, this.driftOption, this.warningOption, true);
+                        
+                        // Update the warning detection object for the current object 
+                        // (this effectively resets changes made to the object while it was still a bkg learner). 
+                        this.warningDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.warningOption)).copy();
+                    }
+                }
+                
+                /*********** drift detection ***********/
+                
+                // Update the DRIFT detection method
+                this.driftDetectionMethod.input(sum);
+                // Check if there was a change
+                if(this.driftDetectionMethod.getChange()) {
+                    this.lastDriftOn = instancesSeen;
+                    this.numberOfDriftsDetected++;
+                    this.reset();
+                }
+            }
+        }
+
+        public Prediction getPredictionForInstance(Instance instance) {
+        	return this.classifier.getPredictionForInstance(instance);
+        }
+        
+        public double[] getVotesForInstance(Instance instance) {
+            DoubleVector vote = new DoubleVector(this.classifier.getPredictionForInstance(instance).asDoubleArray());
+            return vote.getArrayRef();
+        }
+
+        @Override
+        public void getDescription(StringBuilder sb, int indent) {
+        }
+    }
+    
+    /***
+     * Inner class to assist with the multi-thread execution. 
+     */
+    protected class TrainingRunnable implements Runnable, Callable<Integer> {
+        final private ARFBaseLearnerMTR learner;
+        final private Instance instance;
+        final private double weight;
+        final private long instancesSeen;
+
+        public TrainingRunnable(ARFBaseLearnerMTR learner, Instance instance, 
+                double weight, long instancesSeen) {
+            this.learner = learner;
+            this.instance = instance;
+            this.weight = weight;
+            this.instancesSeen = instancesSeen;
+        }
+
+        @Override
+        public void run() {
+            learner.trainOnInstance(this.instance, this.weight, this.instancesSeen);
+        }
+
+        @Override
+        public Integer call() throws Exception {
+            run();
+            return 0;
+        }
+    }
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/mlc/meta/OzaBagAdwinMultiTargetRegression.java b/moa/src/main/java/moa/classifiers/mlc/meta/OzaBagAdwinMultiTargetRegression.java
index 76fda53b4..3ad3f21ea 100644
--- a/moa/src/main/java/moa/classifiers/mlc/meta/OzaBagAdwinMultiTargetRegression.java
+++ b/moa/src/main/java/moa/classifiers/mlc/meta/OzaBagAdwinMultiTargetRegression.java
@@ -25,6 +25,7 @@
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
 import moa.classifiers.meta.AbstractOzaBagAdwin;
+import moa.classifiers.mtr.trees.ISOUPTree;
 import moa.core.DoubleVector;
 import moa.learners.MultiTargetRegressor;
 
@@ -33,14 +34,22 @@ public class OzaBagAdwinMultiTargetRegression extends AbstractOzaBagAdwin<MultiT
 	private static final long serialVersionUID = 1L;
 
 	public OzaBagAdwinMultiTargetRegression() {
-		super(MultiTargetRegressor.class, "classifiers.trees.FIMTD");
+		super(MultiTargetRegressor.class, "moa.classifiers.mtr.trees.ISOUPTree");
 	}
 
 	public double getAdwinError(Instance inst, int i) {
 		// TODO this needs a rework
 		double sum = 0.0;
-		for (int j = 0; j < inst.numOutputAttributes(); j++) {
-			sum += Math.abs(this.ensemble.get(i).getPredictionForInstance(inst).asDouble() - inst.valueOutputAttribute(j));
+		if (this.ensemble.get(i) instanceof ISOUPTree) {
+			double[] normalizedError = ((ISOUPTree) this.ensemble.get(i)).getNormalizedError(inst, this.ensemble.get(i).getPredictionForInstance(inst).asDoubleArray());
+			for (int j = 0; j < inst.numOutputAttributes(); j++) {
+				sum += normalizedError[j];
+			}
+		} else {
+			Prediction prediction = this.ensemble.get(i).getPredictionForInstance(inst);
+			for (int j = 0; j < inst.numOutputAttributes(); j++) {
+				sum += Math.abs(prediction.getPrediction(j) - inst.valueOutputAttribute(j));
+			}
 		}
 		sum = sum / inst.numOutputAttributes();
 		return sum;
@@ -52,7 +61,7 @@ public Prediction combinePredictions(Prediction[] predictions) {
 		for (Prediction p : predictions) {
 			sums.addValues(p.asDoubleVector());
 		}
-		sums.scaleValues(1 / sums.numValues());
+		sums.scaleValues(1.0 / predictions.length);
 		return new MultiTargetRegressionPrediction(sums);
 	}
 
diff --git a/moa/src/main/java/moa/classifiers/mlc/meta/OzaBagMultiTargetRegression.java b/moa/src/main/java/moa/classifiers/mlc/meta/OzaBagMultiTargetRegression.java
index 2bf4f49ab..2ddd290f8 100644
--- a/moa/src/main/java/moa/classifiers/mlc/meta/OzaBagMultiTargetRegression.java
+++ b/moa/src/main/java/moa/classifiers/mlc/meta/OzaBagMultiTargetRegression.java
@@ -39,7 +39,7 @@ public class OzaBagMultiTargetRegression extends AbstractOzaBag<MultiTargetRegre
 	private static final long serialVersionUID = 1L;
 
 	public OzaBagMultiTargetRegression() {
-    	super(MultiTargetRegressor.class, "multilabel.trees.ISOUPTree");
+    	super(MultiTargetRegressor.class, "moa.classifiers.mtr.trees.ISOUPTree");
     }
 
 	@Override
diff --git a/moa/src/main/java/moa/classifiers/mlc/LocalMultiTargetRegressor.java b/moa/src/main/java/moa/classifiers/mtr/LocalMultiTargetRegressor.java
similarity index 91%
rename from moa/src/main/java/moa/classifiers/mlc/LocalMultiTargetRegressor.java
rename to moa/src/main/java/moa/classifiers/mtr/LocalMultiTargetRegressor.java
index d5bb0b65f..681cf98a5 100644
--- a/moa/src/main/java/moa/classifiers/mlc/LocalMultiTargetRegressor.java
+++ b/moa/src/main/java/moa/classifiers/mtr/LocalMultiTargetRegressor.java
@@ -1,4 +1,4 @@
-package moa.classifiers.mlc;
+package moa.classifiers.mtr;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -12,6 +12,7 @@
 
 import moa.classifiers.AbstractMultiTargetRegressor;
 import moa.classifiers.AbstractRegressor;
+import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.SizeOf;
 import moa.learners.MultiTargetRegressor;
@@ -94,12 +95,13 @@ public void trainOnInstanceImpl(Instance instance) {
 
 	@Override
 	public Prediction getPredictionForInstance(Instance inst) {
-		MultiTargetRegressionPrediction prediction = new MultiTargetRegressionPrediction(getModelContext().numOutputAttributes());
+		DoubleVector pred = new DoubleVector();
+		// MultiTargetRegressionPrediction prediction = new MultiTargetRegressionPrediction(getModelContext().numOutputAttributes());
 		for (int j = 0; j < inst.numOutputAttributes(); j++) {
 			Instance STInst = getSTInstance(inst, j);
-			prediction.setVote(j, 1, regressors.get(j).getPredictionForInstance(STInst).asDouble());
+			pred.setValue(j, regressors.get(j).getPredictionForInstance(STInst).asDouble());
 		}
-		return prediction;
+		return new MultiTargetRegressionPrediction(pred);
 	}
 
 	@Override
diff --git a/moa/src/main/java/moa/classifiers/mtr/trees/ISOUPOptionTree.java b/moa/src/main/java/moa/classifiers/mtr/trees/ISOUPOptionTree.java
index 566d894d0..f0e35d3f2 100644
--- a/moa/src/main/java/moa/classifiers/mtr/trees/ISOUPOptionTree.java
+++ b/moa/src/main/java/moa/classifiers/mtr/trees/ISOUPOptionTree.java
@@ -9,7 +9,6 @@
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.MultiChoiceOption;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.classifiers.mlc.core.splitcriteria.MultiLabelSplitCriterion;
 import moa.classifiers.mlc.core.splitcriteria.WeightedICVarianceReduction;
@@ -104,7 +103,7 @@ public int getNumSubtrees() {
 			return num;
 		}
 
-		public double[] getPrediction(StructuredInstance inst) {
+		public double[] getPrediction(Instance inst) {
 			double[][] predictions = new double[numChildren()][tree.getModelContext().numOutputAttributes()];
 			for (int i = 0; i < numChildren(); i++) {
 				predictions[i] = getChild(i).getPrediction(inst);
@@ -210,7 +209,7 @@ public void processInstance(Instance inst, Node node, double[] prediction, doubl
 					((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
 					break;
 				} else {
-					currentNode.examplesSeen += inst.weight();
+					//currentNode.examplesSeen += inst.weight();
 //					if (!inAlternate && iNode.alternateTree != null) {
 //						boolean altTree = true;
 //						double lossO = Math.pow(inst.classValue() - prediction, 2);
@@ -314,7 +313,6 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 		// Using this criterion, find the best split per attribute and rank the results
 		AttributeExpansionSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion); // TODO update with split criterion option
 		List<AttributeExpansionSuggestion> acceptedSplits = new LinkedList<AttributeExpansionSuggestion>();
-		Arrays.sort(bestSplitSuggestions);
 
 		// Declare a variable to determine the number of splits to be performed
 		int numSplits = 0;
@@ -324,10 +322,11 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 			numSplits = 1;
 			acceptedSplits.add(bestSplitSuggestions[0]);
 		} else if (bestSplitSuggestions.length > 1) { // Otherwise, consider which of the splits proposed may be worth trying
-
+			Arrays.sort(bestSplitSuggestions);
 			// Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
 			// to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
-			double hoeffdingBound = computeHoeffdingBound(1, splitConfidenceOption.getValue(), node.examplesSeen);
+			double numExamples = node.examplesSeen.getValue(node.examplesSeen.maxIndex()); // Use the max index (TODO for partially labeled)
+			double hoeffdingBound = computeHoeffdingBound(1, splitConfidenceOption.getValue(), numExamples);
 			// Determine the top two ranked splitting suggestions
 			AttributeExpansionSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
 			AttributeExpansionSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
@@ -381,7 +380,7 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 		// make two new branches leading to (empty) leaves
 		if (numSplits > 0) {
 			double optionFactor = numSplits * Math.pow(optionDecayFactorOption.getValue(), (double) node.getLevel());
-			log(Integer.toString(node.ID) + ',' + Integer.toString((int) this.examplesSeen));
+			log(Integer.toString(node.ID) + ',' + this.examplesSeen.toString());
 
 			if (numSplits == 1) {
 				AttributeExpansionSuggestion splitDecision = acceptedSplits.get(0);
diff --git a/moa/src/main/java/moa/classifiers/mtr/trees/ISOUPTree.java b/moa/src/main/java/moa/classifiers/mtr/trees/ISOUPTree.java
index 33d476674..b1ccf9312 100644
--- a/moa/src/main/java/moa/classifiers/mtr/trees/ISOUPTree.java
+++ b/moa/src/main/java/moa/classifiers/mtr/trees/ISOUPTree.java
@@ -1,5 +1,5 @@
 /*
- *    FIMTDDMultilabel.java
+ *    ISOUPTree.java
  *    Copyright (C) 2014 Jožef Stefan Institute, Ljubljana, Slovenia
  *    @author Aljaž Osojnik <aljaz.osojnik@ijs.si>
  *
@@ -43,11 +43,11 @@
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.MultiTargetRegressionPrediction;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
 import moa.classifiers.AbstractMultiTargetRegressor;
+import moa.classifiers.SemiSupervisedLearner;
 import moa.classifiers.mlc.core.attributeclassobservers.AttributeStatisticsObserver;
 import moa.classifiers.mlc.core.attributeclassobservers.MultiLabelBSTree;
 import moa.classifiers.mlc.core.attributeclassobservers.MultiLabelBSTreePCT;
@@ -72,18 +72,21 @@
  * @author Aljaž Osojnik (aljaz.osojnik@ijs.si)
  * @version $Revision: 1 $
  */
-public class ISOUPTree extends AbstractMultiTargetRegressor implements MultiTargetRegressor {
+public class ISOUPTree extends AbstractMultiTargetRegressor implements MultiTargetRegressor, SemiSupervisedLearner {
 
 	private static final long serialVersionUID = 1L;
 
 	public Node treeRoot;
 
-	protected double examplesSeen = 0.0;
-	private DoubleVector sumOfValues = new DoubleVector();
-	private DoubleVector sumOfSquares = new DoubleVector();
+	protected double learningWeight = 0.0;
 
-	private DoubleVector sumOfAttrValues = new DoubleVector();
-	private DoubleVector sumOfAttrSquares = new DoubleVector();
+	public DoubleVector examplesSeen = new DoubleVector();
+	public DoubleVector sumOfValues = new DoubleVector();
+	public DoubleVector sumOfSquares = new DoubleVector();
+
+	public DoubleVector weightOfInputs = new DoubleVector();
+	public DoubleVector sumOfAttrValues = new DoubleVector();
+	public DoubleVector sumOfAttrSquares = new DoubleVector();
 
 	private int numInputAttributes;
 	private int numOutputAttributes;
@@ -205,17 +208,19 @@ public abstract static class Node implements Serializable {
 		protected boolean changeDetection = true;
 
 		// The statistics for this node:
-		// Number of instances that have reached it
-		protected double examplesSeen;
+		// Number of instances with the given target that have reached it
+		public DoubleVector examplesSeen = new DoubleVector();
 		// Sum of y values
-		protected DoubleVector sumOfValues = new DoubleVector();
+		public DoubleVector sumOfValues = new DoubleVector();
 		// Sum of squared y values
-		protected DoubleVector sumOfSquares = new DoubleVector();
+		public DoubleVector sumOfSquares = new DoubleVector();
 
 		// Sum of y values
-		protected DoubleVector sumOfInputValues;
+		public DoubleVector weightOfInputs;
+		// Sum of y values
+		public DoubleVector sumOfInputValues;
 		// Sum of squared y values
-		protected DoubleVector sumOfInputSquares;
+		public DoubleVector sumOfInputSquares;
 
 
 		public Node(ISOUPTree tree) {
@@ -224,19 +229,20 @@ public Node(ISOUPTree tree) {
 		}
 
 		public void copyStatistics(Node node) {
-			examplesSeen = node.examplesSeen;
+			examplesSeen = (DoubleVector) node.examplesSeen.copy();
 			sumOfValues = (DoubleVector) node.sumOfValues.copy();
 			sumOfSquares = (DoubleVector) node.sumOfSquares.copy();
 			if (tree.runAsPCTOption.isSet()) {
+				weightOfInputs = (DoubleVector) node.weightOfInputs.copy();
 				sumOfInputValues = (DoubleVector) node.sumOfInputValues.copy();
 				sumOfInputSquares = (DoubleVector) node.sumOfInputSquares.copy();
 			}
 		}
 
 		public long calcByteSize() {
-			long size = SizeOf.sizeOf(this) + SizeOf.sizeOf(sumOfSquares) + SizeOf.sizeOf(sumOfValues);
+			long size = SizeOf.sizeOf(this) + SizeOf.sizeOf(sumOfSquares) + SizeOf.sizeOf(sumOfValues) + SizeOf.sizeOf(examplesSeen);
 			if (tree.runAsPCTOption.isSet()) {
-				size += SizeOf.sizeOf(sumOfInputSquares) + SizeOf.sizeOf(sumOfInputValues);
+				size += SizeOf.sizeOf(sumOfInputSquares) + SizeOf.sizeOf(sumOfInputValues) + SizeOf.sizeOf(weightOfInputs);
 			}
 			return size;
 		}
@@ -265,9 +271,7 @@ public void restartChangeDetection() {
 
 		public void getDescription(StringBuilder sb, int i) {}
 
-		public double[] getPrediction(Instance inst) {
-			return null;
-		}
+		public abstract double[] getPrediction(Instance inst);
 
 		public void describeSubtree(StringBuilder out, int indent) {
 			StringUtils.appendIndented(out, indent, "Leaf");
@@ -313,6 +317,8 @@ public static class LeafNode extends Node {
 
 		// Perceptron model that carries out the actual learning in each node
 		public MultitargetPerceptron learningModel;
+		
+		public double learningWeight = 0.0;
 
 		public DoubleVector errorP = new DoubleVector();
 		public DoubleVector errorM = new DoubleVector();
@@ -332,10 +338,12 @@ public LeafNode(ISOUPTree tree) {
 				learningModel = tree.newLeafModel();
 			}
 			initializeInputIndexes();
-			examplesSeen = 0;
+			learningWeight = 0.0;
+			examplesSeen = new DoubleVector();
 			sumOfValues = new DoubleVector();
 			sumOfSquares = new DoubleVector();
 			if (tree.runAsPCTOption.isSet()) {
+				weightOfInputs = new DoubleVector();
 				sumOfInputValues = new DoubleVector();
 				sumOfInputSquares = new DoubleVector();
 			}
@@ -369,12 +377,19 @@ public void learnFromInstance(Instance inst, double[] prediction, boolean growth
 			double[] predictionP = tree.buildingModelTree() ? getPredictionModel(inst) : null;
 			double[] predictionM = getPredictionTargetMean(inst);
 
+			DoubleVector[] observations = new DoubleVector[tree.numOutputAttributes];
+			DoubleVector[] inputObservations = null;
+			
+			learningWeight += weight;
+
 			// number of instances passing through the node
-			examplesSeen += weight;
 
+			if (tree.buildingModelTree() && !inst.missingOutputs()) learningModel.updatePerceptron(inst);
+			
 			for (int i = 0; i < tree.numOutputAttributes; i++) {
 				if (!inst.isOutputMissing(i)) {
 					double outVal = inst.valueOutputAttribute(i);
+					examplesSeen.addToValue(i, weight);
 					// sum of y values
 					sumOfValues.addToValue(i, weight * outVal);
 
@@ -385,50 +400,25 @@ public void learnFromInstance(Instance inst, double[] prediction, boolean growth
 						errorP.setValue(i, errorP.getValue(i) * 0.95 + Math.abs(predictionP[i] - outVal));
 						errorM.setValue(i, errorM.getValue(i) * 0.95 + Math.abs(predictionM[i] - outVal));
 					}
+
+					observations[i] = new DoubleVector(new double[] {weight, weight * outVal, weight * outVal * outVal}); 
 				}
 			}
 
 			if (tree.runAsPCTOption.isSet()) {
-				for (int i = 0; i < tree.numInputAttributes; i++) {
+				inputObservations = new DoubleVector[tree.numInputAttributes];
+				for (int i : inputIndexes) {
 					if (!inst.isInputMissing(i)) {
 						double inVal = inst.valueInputAttribute(i);
+						weightOfInputs.addToValue(i, weight);
 
 						// sum of attr values
 						sumOfInputValues.addToValue(i, weight * inVal);
 
 						// sum of squared attr values
 						sumOfInputSquares.addToValue(i, weight * inVal * inVal);
-					}
-				}
-			}
 
-
-
-			if (tree.buildingModelTree()) learningModel.updatePerceptron(inst);
-
-			DoubleVector[] observations = new DoubleVector[tree.numOutputAttributes];
-			DoubleVector[] inputObservations = null;
-
-			for (int j = 0; j < tree.numOutputAttributes; j++) {
-				observations[j] = new DoubleVector();
-				if (!inst.isOutputMissing(j)) {
-					double outVal = inst.valueOutputAttribute(j);
-					observations[j].setValue(0, weight);
-					observations[j].setValue(1, weight * outVal);
-					observations[j].setValue(2, weight * outVal * outVal);
-				}
-			}
-			
-			if (tree.runAsPCTOption.isSet()) {
-				inputObservations = new DoubleVector[tree.numInputAttributes];
-				for (int j = 0; j < tree.numInputAttributes; j++) {
-					
-					inputObservations[j] = new DoubleVector();
-					if (!inst.isInputMissing(j)) {
-						double inVal = inst.valueInputAttribute(j);
-						inputObservations[j].setValue(0, weight);
-						inputObservations[j].setValue(1, weight * inVal);
-						inputObservations[j].setValue(2, weight * inVal * inVal);
+						inputObservations[i] = new DoubleVector(new double[] {weight, weight * inVal, weight * inVal * inVal}); 
 					}
 				}
 			}
@@ -436,7 +426,6 @@ public void learnFromInstance(Instance inst, double[] prediction, boolean growth
 			for (int i : inputIndexes) {
 				AttributeStatisticsObserver obs = attributeObservers.get(i);
 				if (obs == null) {
-					// At this stage all nominal attributes are ignored
 					if (inst.inputAttribute(i).isNumeric()) {
 						obs = tree.newNumericClassObserver();
 						attributeObservers.set(i, obs);
@@ -446,14 +435,10 @@ public void learnFromInstance(Instance inst, double[] prediction, boolean growth
 					}
 
 				}
-				if (obs != null ) {
-					if (!tree.runAsPCTOption.isSet() || !inst.inputAttribute(i).isNumeric()) {
-						obs.observeAttribute(inst.valueInputAttribute(i), observations);
-					} else {
-						((MultiLabelBSTreePCT) obs).observeAttribute(inst.valueInputAttribute(i), observations, inputObservations);
-					}
-
-					//obs.observeAttributeClassVector(inst.valueInputAttribute(i), getTargetVector(inst), inst.weight());
+				if (!tree.runAsPCTOption.isSet() || !inst.inputAttribute(i).isNumeric()) {
+					obs.observeAttribute(inst.valueInputAttribute(i), observations);
+				} else {
+					((MultiLabelBSTreePCT) obs).observeAttribute(inst.valueInputAttribute(i), observations, inputObservations);
 				}
 			}
 
@@ -476,16 +461,16 @@ public AttributeExpansionSuggestion[] getBestSplitSuggestions(MultiLabelSplitCri
 					DoubleVector[] preSplitInputStatistics = null;
 					for (int j = 0; j < tree.numOutputAttributes; j++) {
 						preSplitStatistics[j] = new DoubleVector();
-						preSplitStatistics[j].setValue(0, examplesSeen);
+						preSplitStatistics[j].setValue(0, examplesSeen.getValue(j));
 						preSplitStatistics[j].setValue(1, sumOfValues.getValue(j));
 						preSplitStatistics[j].setValue(2, sumOfSquares.getValue(j));
 					}
-					
+
 					if (tree.runAsPCTOption.isSet() && tree.modelContext.inputAttribute(i).isNumeric()) {
 						preSplitInputStatistics = new DoubleVector[tree.numInputAttributes];
 						for (int j = 0; j < tree.numInputAttributes; j++) {
 							preSplitInputStatistics[j] = new DoubleVector();
-							preSplitInputStatistics[j].setValue(0, examplesSeen);
+							preSplitInputStatistics[j].setValue(0, weightOfInputs.getValue(j));
 							preSplitInputStatistics[j].setValue(1, sumOfInputValues.getValue(j));
 							preSplitInputStatistics[j].setValue(2, sumOfInputSquares.getValue(j));
 						}
@@ -517,8 +502,8 @@ public double[] getPredictionModel(Instance inst) {
 		public double[] getPredictionTargetMean(Instance inst) {
 			double[] pred = new double[tree.numOutputAttributes];
 			for (int i = 0; i < tree.numOutputAttributes; i++) {
-				if (examplesSeen > 0) {
-					pred[i] = sumOfValues.getValue(i) / examplesSeen;
+				if (examplesSeen.getValue(i) > 0) {
+					pred[i] = sumOfValues.getValue(i) / examplesSeen.getValue(i);
 				} else {
 					pred[i] = 0;
 				}
@@ -526,7 +511,7 @@ public double[] getPredictionTargetMean(Instance inst) {
 			return pred;
 		}
 
-		public double[] getPrediction(StructuredInstance inst) {
+		public double[] getPrediction(Instance inst) {
 			if (tree.buildingModelTree()) {
 				double[] predictionP = getPredictionModel(inst);
 				double[] predictionM = getPredictionTargetMean(inst);
@@ -551,12 +536,13 @@ public double[] getPrediction(StructuredInstance inst) {
 
 		public void checkForSplit() {
 			// If it has seen Nmin examples since it was last tested for splitting, attempt a split of this node
-			if (examplesSeen - examplesSeenAtLastSplitEvaluation >= tree.gracePeriodOption.getValue()) {
+			// TODO How does this interact with partially labeled examples
+			if (learningWeight - examplesSeenAtLastSplitEvaluation >= tree.gracePeriodOption.getValue()) {
 				int index = (parent != null) ? parent.getChildIndex(this) : 0;
 				tree.attemptToSplit(this, parent, index);
 
 				// Take note of how many instances were seen when this split evaluation was made, so we know when to perform the next split evaluation
-				examplesSeenAtLastSplitEvaluation = examplesSeen;
+				examplesSeenAtLastSplitEvaluation = learningWeight;
 			}
 		}
 
@@ -688,7 +674,7 @@ public static class SplitNode extends InnerNode {
 
 		private static final long serialVersionUID = 1L;
 
-		protected Predicate predicate;
+		public Predicate predicate;
 
 		/**
 		 * Create a new SplitNode
@@ -731,7 +717,12 @@ public double[] getPrediction(Instance inst) {
 		}
 	}
 
-	public class MultitargetPerceptron {
+	public class MultitargetPerceptron implements Serializable {
+
+		/**
+		 * 
+		 */
+		private static final long serialVersionUID = 1L;
 
 		protected ISOUPTree tree;
 
@@ -743,7 +734,10 @@ public class MultitargetPerceptron {
 
 		public MultitargetPerceptron(ISOUPTree tree, MultitargetPerceptron original) {
 			this.tree = tree;
-			weights = original.weights.clone();
+			weights = new double[original.weights.length][original.weights[0].length];
+			for (int i = 0; i < original.weights.length; i++)
+				for (int j = 0; j < original.weights[0].length; j++)
+					weights[i][j] = original.weights[i][j];
 		}
 
 		public MultitargetPerceptron(ISOUPTree tree) {
@@ -765,7 +759,6 @@ public void initializeWeights() {
 			int numTargets = tree.numOutputAttributes;
 			int numInputs = tree.numInputAttributes;
 			weights = new double[numTargets][numInputs+1];
-			tree.classifierRandom.setSeed(1234);
 			for (int i = 0; i < numTargets; i++) {
 				for (int j = 0; j < numInputs + 1; j++) { 
 					// The last index corresponds to the constant b
@@ -787,7 +780,7 @@ public void updatePerceptron(Instance inst) {
 			if (tree.learningRatioConstOption.isSet()) {
 				learningRatio = tree.learningRatioOption.getValue();
 			} else {
-				learningRatio = learningRatioOption.getValue() / (1 + instancesSeen * tree.learningRateDecayFactorOption.getValue());
+				learningRatio = tree.learningRatioOption.getValue() / (1 + instancesSeen * tree.learningRateDecayFactorOption.getValue());
 			}
 
 			// Loop for compatibility with bagging methods 
@@ -804,7 +797,7 @@ public void updateWeights(Instance inst, double learningRatio) {
 
 				double[] normalizedTarget = tree.normalizedTargetVector(inst);
 				for (int i = 0; i < tree.numOutputAttributes; i++){
-					if (normalizedTarget[i] != Double.NaN) { /* to account for missing target values */
+					if (!Double.isNaN(normalizedTarget[i])) { /* to account for missing target values */
 						double delta = normalizedTarget[i] - normalizedPrediction[i];
 						for (int j = 0; j < normalizedInput.length; j++) {
 							weights[i][j] += delta * learningRatio * normalizedInput[j];
@@ -849,9 +842,9 @@ private double[] denormalizePrediction(double[] normalizedPrediction) {
 			double[] out = new double[normalizedPrediction.length];
 			if (tree.normalize()) {
 				for (int i = 0; i < tree.numOutputAttributes; i++) {
-					double mean = tree.sumOfValues.getValue(i) / tree.examplesSeen;
-					double sd = computeSD(tree.sumOfSquares.getValue(i), tree.sumOfValues.getValue(i), tree.examplesSeen);
-					if (examplesSeen > 1) 
+					double mean = tree.sumOfValues.getValue(i) / tree.examplesSeen.getValue(i);
+					double sd = computeSD(tree.sumOfSquares.getValue(i), tree.sumOfValues.getValue(i), tree.examplesSeen.getValue(i));
+					if (examplesSeen.getValue(i) > 1) 
 						out[i] = normalizedPrediction[i] * sd + mean;
 					else
 						out[i] = 0;
@@ -902,10 +895,16 @@ public String getPurposeString() {
 
 	public void resetLearningImpl() {
 		treeRoot = null;
-		examplesSeen = 0.0;
+		
+		if (this.getModelContext() != null)
+			checkRoot();
+
+		learningWeight = 0.0;
+		examplesSeen = new DoubleVector();
 		sumOfValues = new DoubleVector();
 		sumOfSquares = new DoubleVector();
 
+		weightOfInputs = new DoubleVector();
 		sumOfAttrValues = new DoubleVector();
 		sumOfAttrSquares = new DoubleVector();
 
@@ -913,7 +912,6 @@ public void resetLearningImpl() {
 
 	@Override
 	public void modelContextSet() {
-		assert getModelContext() != null;
 		this.numInputAttributes = getModelContext().numInputAttributes();
 		this.numOutputAttributes = getModelContext().numOutputAttributes();
 		loadWeights();
@@ -946,15 +944,16 @@ protected Measurement[] getModelMeasurementsImpl() {
 		};
 	}
 
-	public long measureByteSize() {
-		return calcByteSize();
-	}
+//	public long measureByteSize() {
+//		return calcByteSize();
+//	}
 
 	public long calcByteSize() {
 		long size = SizeOf.sizeOf(this);
 		if (this.treeRoot != null) {
 			size += this.treeRoot.calcByteSize();
 		}
+		size += SizeOf.sizeOf(examplesSeen) + SizeOf.sizeOf(weightOfInputs);
 		size += SizeOf.sizeOf(sumOfValues) + SizeOf.sizeOf(sumOfSquares);
 		size += SizeOf.sizeOf(sumOfAttrValues) + SizeOf.sizeOf(sumOfAttrSquares);
 		size += SizeOf.sizeOf(targetWeights);
@@ -963,11 +962,7 @@ public long calcByteSize() {
 
 	public Prediction getPredictionForInstance(Instance inst) {
 		double[] predictionVector = treeRoot.getPrediction(inst);
-		MultiLabelClassificationPrediction prediction = new MultiLabelClassificationPrediction(this.numOutputAttributes);
-		for (int i = 0; i < this.numOutputAttributes; i++) {
-			prediction.setVote(i, 1, predictionVector[i]);
-		}
-		return prediction;
+		return new MultiTargetRegressionPrediction(predictionVector);
 	}
 
 	public double[] normalizedInputVector(Instance inst) {
@@ -977,9 +972,9 @@ public double[] normalizedInputVector(Instance inst) {
 			for (int j = 0; j < this.numInputAttributes; j++) {
 				Attribute attr = inst.inputAttribute(j);
 				double value =  inst.valueInputAttribute(j);
-				double mean = sumOfAttrValues.getValue(j) / examplesSeen;
-				double sd = computeSD(sumOfAttrSquares.getValue(j), sumOfAttrValues.getValue(j), examplesSeen);
-				if (examplesSeen > 1 && sd > 0.00001) {
+				double mean = sumOfAttrValues.getValue(j) / weightOfInputs.getValue(j);
+				double sd = computeSD(sumOfAttrSquares.getValue(j), sumOfAttrValues.getValue(j), weightOfInputs.getValue(j));
+				if (weightOfInputs.getValue(j) > 1 && sd > 0.00001) {
 					if (attr.isNumeric())
 						normalizedInput[j] = (value - mean) / sd;
 					else
@@ -987,10 +982,7 @@ public double[] normalizedInputVector(Instance inst) {
 				} else
 					normalizedInput[j] = 0;
 			}
-			if (examplesSeen > 1)
-				normalizedInput[this.numInputAttributes] = 1.0; // Value to be multiplied with the constant factor
-			else
-				normalizedInput[this.numInputAttributes] =  0.0;
+			normalizedInput[this.numInputAttributes] = 1.0; // Value to be multiplied with the constant factor
 		} else {
 			for (int j = 0; j < this.numInputAttributes; j++) {
 				normalizedInput[j] = inst.valueInputAttribute(j);
@@ -1005,10 +997,10 @@ public double[] normalizedTargetVector(Instance inst) {
 		if (normalize()) {
 			for (int i = 0; i < this.numOutputAttributes; i++) {
 				double value = (inst.isOutputMissing(i)) ? Double.NaN : inst.valueOutputAttribute(i);;
-				if (value != Double.NaN) {
-					double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen);
-					double average = sumOfValues.getValue(i) / examplesSeen;
-					if (sd > 0 && examplesSeen > 1)
+				if (!Double.isNaN(value)) {
+					double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen.getValue(i));
+					double average = sumOfValues.getValue(i) / examplesSeen.getValue(i);
+					if (sd > 0 && examplesSeen.getValue(i) > 1)
 						out[i] = (value - average) / (sd);
 					else
 						out[i] = 0;
@@ -1023,13 +1015,13 @@ public double[] normalizedTargetVector(Instance inst) {
 	}
 
 	public double[] normalizeTargetVector(double[] pred) {
-		if (normalize()) {
+		if (pred != null && normalize()) {
 			double[] out = new double[pred.length];
 			for (int i = 0; i < pred.length; i++) {
 				double value = pred[i];
-				double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen);
-				double average = sumOfValues.getValue(i) / examplesSeen;
-				if (sd > 0 && examplesSeen > 1)
+				double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen.getValue(i));
+				double average = sumOfValues.getValue(i) / examplesSeen.getValue(i);
+				if (sd > 0 && examplesSeen.getValue(i) > 1)
 					out[i] = (value - average) / sd;
 				else
 					out[i] = 0;
@@ -1039,12 +1031,12 @@ public double[] normalizeTargetVector(double[] pred) {
 	}
 
 
-	public double normalizeTargetValue(StructuredInstance inst, int i) {
+	public double normalizeTargetValue(Instance inst, int i) {
 		if (normalize()) {
-			if (examplesSeen > 1) {
+			if (examplesSeen.getValue(i) > 1) {
 				double value = inst.valueOutputAttribute(i);
-				double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen);
-				double average = sumOfValues.getValue(i) / examplesSeen;
+				double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen.getValue(i));
+				double average = sumOfValues.getValue(i) / examplesSeen.getValue(i);
 				if (sd > 0)
 					return (value - average) / sd;
 				else
@@ -1056,9 +1048,9 @@ public double normalizeTargetValue(StructuredInstance inst, int i) {
 
 	public double normalizeTargetValue(double value, int i) {
 		if (normalize()) {
-			if (examplesSeen > 1) {
-				double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen);
-				double average = sumOfValues.getValue(i) / examplesSeen;
+			if (examplesSeen.getValue(i) > 1) {
+				double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen.getValue(i));
+				double average = sumOfValues.getValue(i) / examplesSeen.getValue(i);
 				if (sd > 0)
 					return (value - average) / sd;
 				else
@@ -1072,9 +1064,10 @@ public double[] getNormalizedError(Instance inst, double[] prediction) {
 		double[] normalPrediction = normalizeTargetVector(prediction);
 		double[] normalValue = normalizedTargetVector(inst);
 		double[] out = new double[this.numOutputAttributes];
-		for (int i = 0; i < this.numOutputAttributes; i++) {
-			out[i] = Math.abs(normalValue[i] - normalPrediction[i]);
-		}
+		if (normalPrediction != null)
+			for (int i = 0; i < this.numOutputAttributes; i++) {
+				out[i] = Math.abs(normalValue[i] - normalPrediction[i]);
+			}
 		return out;
 	}
 
@@ -1086,23 +1079,30 @@ public void trainOnInstanceImpl(Instance inst) {
 		if (inst.weight() > 0) {
 
 			double[] prediction = treeRoot.getPrediction(inst);
-			double[] normalError = getNormalizedError(inst, prediction);
+			//double[] normalError = getNormalizedError(inst, prediction);
+			double[] normalError = null;
 
 			processInstance(inst, treeRoot, prediction, normalError, true, false);
 
 			double weight = inst.weight();
 
-			examplesSeen += weight;
+			learningWeight += weight;
 			for (int i = 0; i < this.numOutputAttributes; i++) {
-				double iVal = inst.valueOutputAttribute(i);
-				sumOfValues.addToValue(i, weight * iVal);
-				sumOfSquares.addToValue(i, weight * iVal * iVal);
+				if (!inst.isOutputMissing(i)) {
+					double iVal = inst.valueOutputAttribute(i);
+					examplesSeen.addToValue(i, weight);
+					sumOfValues.addToValue(i, weight * iVal);
+					sumOfSquares.addToValue(i, weight * iVal * iVal);
+				}
 			}
 
 			for (int i = 0; i < this.numInputAttributes; i++) {
-				double iVal = inst.valueInputAttribute(i);
-				sumOfAttrValues.addToValue(i, weight * iVal);
-				sumOfAttrSquares.addToValue(i, weight * iVal * iVal);
+				if (!inst.isInputMissing(i)) {
+					double iVal = inst.valueInputAttribute(i);
+					weightOfInputs.addToValue(i, weight);
+					sumOfAttrValues.addToValue(i, weight * iVal);
+					sumOfAttrSquares.addToValue(i, weight * iVal * iVal);
+				}
 			}
 		}
 	}
@@ -1114,8 +1114,8 @@ public void processInstance(Instance inst, Node node, double[] prediction, doubl
 				((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
 				break;
 			} else {
-				currentNode.examplesSeen += inst.weight();
-				//currentNode.sumOfAbsErrors.addValues(normalError);
+				// currentNode.examplesSeen += inst.weight();
+				//  currentNode.sumOfAbsErrors.addValues(normalError);
 				//				SplitNode iNode = (SplitNode) currentNode;
 				//				if (!inAlternate && iNode.alternateTree != null) {
 				//					boolean altTree = true;
@@ -1247,12 +1247,12 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 		} else {
 			DoubleVector inputWeights = new DoubleVector();
 			for (int i = 0; i < numInputAttributes; i++) inputWeights.setValue(i, 1);
-			splitCriterion = new PCTWeightedICVarianceReduction(targetWeights, new DoubleVector(), 0.5);
+			splitCriterion = new PCTWeightedICVarianceReduction(targetWeights, inputWeights, 0.5);
 		}
 
 		// Using this criterion, find the best split per attribute and rank the results
 		AttributeExpansionSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion); // TODO update with split criterion option
-		
+
 
 
 		// Declare a variable to determine if any of the splits should be performed
@@ -1264,7 +1264,8 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 			Arrays.sort(bestSplitSuggestions);
 			// Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
 			// to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
-			double hoeffdingBound = computeHoeffdingBound(1, splitConfidenceOption.getValue(), node.examplesSeen);
+			double numExamples = node.learningWeight;
+			double hoeffdingBound = computeHoeffdingBound(1, splitConfidenceOption.getValue(), numExamples);
 			// Determine the top two ranked splitting suggestions
 			AttributeExpansionSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
 			AttributeExpansionSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
@@ -1276,33 +1277,27 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 			// Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
 			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
 			// competing attributes are equally good, and the split will be made on the one with the higher SDR value.
-			if ((secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) || (hoeffdingBound < this.tieThresholdOption.getValue())) {
-				shouldSplit = true;
-			}
+			shouldSplit = (secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) || (hoeffdingBound < this.tieThresholdOption.getValue());
+			// shouldSplit = true;
+
 			// If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
-			else {
-				// TODO pruning is currently disabled
-				for (int i = 0; i < node.attributeObservers.size(); i++) {
-					AttributeStatisticsObserver obs = node.attributeObservers.get(i);
-					if (obs != null) {
-						if (getModelContext().attribute(i).isNumeric());
-						//TODO obs.removeBadSplits(null, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound, getModelContext().numOutputAttributes());
-						if (getModelContext().attribute(i).isNominal());
-						// TODO nominal class observers
-					}
-				}
-			}
+//			if (!shouldSplit) {
+//				// TODO pruning is currently disabled
+//				for (int i = 0; i < node.attributeObservers.size(); i++) {
+//					AttributeStatisticsObserver obs = node.attributeObservers.get(i);
+//					if (obs != null) {
+//						if (getModelContext().attribute(i).isNumeric());
+//						//TODO obs.removeBadSplits(null, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound, getModelContext().numOutputAttributes());
+//						if (getModelContext().attribute(i).isNominal());
+//						// TODO nominal class observers
+//					}
+//				}
+//			}
 		}
 
+		
+		
 		// If the splitting criterion were met, split the current node using the chosen attribute test, and
-		// make two new branches leading to (empty) leaves
-		//		try {
-		//			Thread.sleep(20000);
-		//		} catch (InterruptedException e) {
-		//			// TODO Auto-generated catch block
-		//			e.printStackTrace();
-		//		}
-
 		if (shouldSplit) {
 			AttributeExpansionSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
 
@@ -1310,14 +1305,21 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 			newSplit.ID = node.ID;
 			newSplit.copyStatistics(node);
 			newSplit.changeDetection = node.changeDetection;
-			newSplit.ID = node.ID;
-			log(Integer.toString(node.ID) + ',' + Integer.toString((int) this.examplesSeen));
+			log(Integer.toString(node.ID) + ',' + this.examplesSeen.toString());
 			for (int i = 0; i < 2; i++) { // Hardcoded for 2 values (due to the use of the Predicate class)
 				LeafNode newChild = newLeafNode();
 				if (buildingModelTree()) {
 					// Copy the splitting node's perceptron to it's children
 					newChild.learningModel = new MultitargetPerceptron(this, node.learningModel);
-
+					newChild.errorM = (DoubleVector) node.errorM.copy();
+					newChild.errorP = (DoubleVector) node.errorP.copy();
+				} else {
+					// Retrieve the seen average from the split
+					for (int j = 0; j < getModelContext().numOutputAttributes(); j++) {
+						newChild.examplesSeen.setValue(j, splitDecision.getResultingNodeStatistics()[j][i].getValue(0));
+						newChild.sumOfValues.setValue(j, splitDecision.getResultingNodeStatistics()[j][i].getValue(1));
+						newChild.sumOfSquares.setValue(j, splitDecision.getResultingNodeStatistics()[j][i].getValue(2));
+					}
 				}
 				newChild.changeDetection = node.changeDetection;
 				newChild.setParent(newSplit);
diff --git a/moa/src/main/java/moa/classifiers/mtr/trees/ISOUPTreeRF.java b/moa/src/main/java/moa/classifiers/mtr/trees/ISOUPTreeRF.java
index d2d92e6c9..1ac0b1075 100644
--- a/moa/src/main/java/moa/classifiers/mtr/trees/ISOUPTreeRF.java
+++ b/moa/src/main/java/moa/classifiers/mtr/trees/ISOUPTreeRF.java
@@ -5,24 +5,37 @@
 
 import com.github.javacliparser.MultiChoiceOption;
 
+import moa.core.DoubleVector;
+
 public class ISOUPTreeRF extends ISOUPTree {
 
-	public MultiChoiceOption radndomForestFunAttrsOption = new MultiChoiceOption(
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 1L;
+	
+	public MultiChoiceOption subspaceSizeOption = new MultiChoiceOption(
 			"randomForestFunAttr",
 			'z',
 			"The function of the number of input attribtues to use in the random forest construction.", 
 			new String[]{"sqrt", "log", "percent"}, new String[]{"Square root", "Logarithm", "10% percent"}, 0);
 	
 	
+	public Integer subspaceSize = null;
+	
 	public int numRFAttrs() {
-		switch (radndomForestFunAttrsOption.getChosenLabel()) {
-		case "sqrt": return (int) Math.ceil(Math.sqrt(this.getModelContext().numInputAttributes()));
-		case "log": return (int) Math.ceil(Math.log(this.getModelContext().numInputAttributes())) + 1;
-		case "percent": return (int) Math.ceil(0.1 * this.getModelContext().numInputAttributes());
+		if (subspaceSize == null) {
+			switch (subspaceSizeOption.getChosenLabel()) {
+				case "sqrt": this.subspaceSize = 1 + (int) Math.ceil(Math.sqrt(this.getModelContext().numInputAttributes()));
+				case "log": this.subspaceSize = 1 + (int) Math.ceil(Math.log(this.getModelContext().numInputAttributes()));
+				case "percent": this.subspaceSize = (int) Math.ceil(0.1 * this.getModelContext().numInputAttributes());
+			}
 		}
-		return 0;
+		return this.subspaceSize;
 	}
 	
+	
+	
 	@Override
 	public List<Integer> newInputIndexes() {
 		List<Integer> indexes = new Vector<Integer>();
@@ -39,4 +52,21 @@ public List<Integer> newInputIndexes() {
 		return indexes.subList(0, numRFAttrs());
 	}
 	
+	public DoubleVector getFeatureScores() {
+		return getNodeFeatureScore(treeRoot);
+	}
+	
+	public DoubleVector getNodeFeatureScore(ISOUPTree.Node node) {
+		if (node instanceof ISOUPTree.SplitNode) {
+			DoubleVector scores = new DoubleVector(new double[getModelContext().numInputAttributes()]);
+			for (ISOUPTree.Node child : ((ISOUPTree.SplitNode) node).children) {
+				scores.addValues(getNodeFeatureScore(child));
+			}
+			scores.setValue(((ISOUPTree.SplitNode) node).predicate.getAttributeIndex(), Math.pow(0.5, node.getLevel()));
+			return scores;
+		} else {
+			return new DoubleVector();
+		}
+	}
+	
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/core/AttributeExpansionSuggestion.java b/moa/src/main/java/moa/classifiers/rules/core/AttributeExpansionSuggestion.java
index a1e24bbb6..05f8dd162 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/AttributeExpansionSuggestion.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/AttributeExpansionSuggestion.java
@@ -73,6 +73,9 @@ public AttributeExpansionSuggestion(Predicate predicate,  DoubleVector[][] resul
 
     @Override
     public int compareTo(AttributeExpansionSuggestion comp) {
+    	if (Double.isNaN(this.merit) && Double.isNaN(comp.merit)) return 0;
+    	if (Double.isNaN(this.merit)) return -1;
+    	if (Double.isNaN(comp.merit)) return 1;
         return Double.compare(this.merit, comp.merit);
     }
 
diff --git a/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java
index fb5505ef7..3e493ba81 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java
@@ -40,6 +40,11 @@ public boolean evaluate(StructuredInstance instance) {
 
 	}
 
+	public double getAttributeValue() {
+		return attributeValue;
+	}
+
+	
 	@Override
 	public void negateCondition() {
 		isEqual=!isEqual;
diff --git a/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java
index 8387610c0..c246d2ce7 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java
+++ b/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java
@@ -49,9 +49,9 @@ public void negateCondition() {
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
 		if(isEqualOrLower)
-			StringUtils.appendIndented(sb, indent+1, "In" + inputAttributeIndex + " <= " + attributeValue);
+			StringUtils.appendIndented(sb, indent+1, inputAttributeIndex + " <= " + attributeValue);
 		else
-			StringUtils.appendIndented(sb, indent+1, "In" + inputAttributeIndex + " > " + attributeValue);
+			StringUtils.appendIndented(sb, indent+1, inputAttributeIndex + " > " + attributeValue);
 	}
 	@Override
 	public String toString(){
@@ -73,6 +73,7 @@ public boolean isEqualOrLess() {
 	public double getAttributeValue() {
 		return attributeValue;
 	}
+	
 	@Override
 	public void getDescription(StringBuilder sb, int indent, InstancesHeader header) {
 		if(isEqualOrLower)
diff --git a/moa/src/main/java/moa/core/DoubleVector.java b/moa/src/main/java/moa/core/DoubleVector.java
index c929911a0..9d7f94f27 100644
--- a/moa/src/main/java/moa/core/DoubleVector.java
+++ b/moa/src/main/java/moa/core/DoubleVector.java
@@ -43,7 +43,7 @@ public DoubleVector(double[] toCopy) {
     }
 
     public DoubleVector(DoubleVector toCopy) {
-        this(toCopy.getArrayRef());
+        this(toCopy.getArrayCopy());
     }
 
     public int numValues() {
@@ -190,7 +190,7 @@ public void getSingleLineDescription(StringBuilder out, int numValues) {
             if (i > 0) {
                 out.append("|");
             }
-            out.append(StringUtils.doubleToString(getValue(i), 3));
+            out.append(String.valueOf(this.array[i]));
         }
         out.append("}");
     }
diff --git a/moa/src/main/java/moa/learners/Learner.java b/moa/src/main/java/moa/learners/Learner.java
index aeaa9a589..7da113f7a 100644
--- a/moa/src/main/java/moa/learners/Learner.java
+++ b/moa/src/main/java/moa/learners/Learner.java
@@ -52,6 +52,12 @@ public interface Learner<E extends Example> extends MOAObject, OptionHandler, AW
      */
     public void setRandomSeed(int s);
 
+    /**
+     * Gets the seed for random number generation.
+     */
+    public int getRandomSeed();
+
+    
     /**
      * Gets whether training has started.
      *

From 5e8945eaee00e4d72cf69768c7fcfe0c08d02395 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alja=C5=BE=20Osojnik?= <aljaz.osojnik@ijs.si>
Date: Mon, 16 Sep 2019 15:20:20 +0200
Subject: [PATCH 33/33] Code reorganization

---
 moa/.classpath                                |    1 -
 .../javacliparser/AbstractClassOption.java    |  390 +-
 .../github/javacliparser/AbstractOption.java  |  195 +-
 .../com/github/javacliparser/ClassOption.java |  298 +-
 .../github/javacliparser/Configurable.java    |   84 +-
 .../com/github/javacliparser/FileOption.java  |   58 +-
 .../com/github/javacliparser/FlagOption.java  |   82 +-
 .../com/github/javacliparser/FloatOption.java |  159 +-
 .../com/github/javacliparser/IntOption.java   |  158 +-
 .../github/javacliparser/JavaCLIParser.java   |  188 +-
 .../com/github/javacliparser/ListOption.java  |  126 +-
 .../javacliparser/MultiChoiceOption.java      |  175 +-
 .../java/com/github/javacliparser/Option.java |  130 +-
 .../com/github/javacliparser/Options.java     |  470 +--
 .../github/javacliparser/SerializeUtils.java  |  117 +-
 .../github/javacliparser/StringOption.java    |   61 +-
 .../com/github/javacliparser/StringUtils.java |  100 +-
 .../gui/ClassOptionEditComponent.java         |  217 +-
 .../ClassOptionWithNamesEditComponent.java    |  182 +-
 .../gui/FileOptionEditComponent.java          |  117 +-
 .../gui/FlagOptionEditComponent.java          |   43 +-
 .../gui/FloatOptionEditComponent.java         |  144 +-
 .../gui/IntOptionEditComponent.java           |   89 +-
 .../gui/ListOptionEditComponent.java          |   11 +-
 .../gui/MultiChoiceOptionEditComponent.java   |   59 +-
 .../gui/OptionEditComponent.java              |   40 +-
 .../gui/OptionsConfigurationPanel.java        |  398 +-
 .../gui/RangeOptionEditComponent.java         |   10 +-
 .../gui/StringOptionEditComponent.java        |   41 +-
 .../labs/samoa/instances/ArffLoader.java      |  860 ++--
 .../yahoo/labs/samoa/instances/Attribute.java |  536 +--
 .../instances/AttributesInformation.java      |   38 +-
 .../labs/samoa/instances/DAGStructure.java    |   41 +-
 .../labs/samoa/instances/DenseInstance.java   |   76 +-
 .../samoa/instances/DenseInstanceData.java    |  335 +-
 .../instances/FeatureRelevanceResult.java     |   14 +-
 .../instances/FilteredSparseInstance.java     |   94 +-
 .../instances/FilteredSparseInstanceData.java |   77 +-
 .../yahoo/labs/samoa/instances/Instance.java  |  697 ++--
 .../labs/samoa/instances/InstanceData.java    |  167 +-
 .../labs/samoa/instances/InstanceImpl.java    |  976 ++---
 .../samoa/instances/InstanceInformation.java  |  114 +-
 .../labs/samoa/instances/InstancesHeader.java |  148 +-
 .../samoa/instances/MultiLabelInstance.java   |   26 +-
 .../instances/MultilabelInstancesHeader.java  |   22 +-
 .../SamoaToWekaInstanceConverter.java         |  222 +-
 .../labs/samoa/instances/SparseInstance.java  |   78 +-
 .../samoa/instances/SparseInstanceData.java   |  638 ++-
 .../samoa/instances/StructuredInstance.java   |   30 -
 .../WekaToSamoaInstanceConverter.java         |  195 +-
 .../predictions/ClassificationPrediction.java |   66 +-
 .../MultiLabelClassificationPrediction.java   |   95 +-
 .../MultiTargetRegressionPrediction.java      |   88 +-
 .../instances/predictions/Prediction.java     |  241 +-
 .../predictions/RegressionPrediction.java     |   64 +-
 moa/src/main/java/moa/AbstractMOAObject.java  |   88 +-
 moa/src/main/java/moa/DoTask.java             |  390 +-
 moa/src/main/java/moa/MOAObject.java          |   50 +-
 moa/src/main/java/moa/MakeObject.java         |   67 +-
 .../java/moa/capabilities/Capabilities.java   |  149 +-
 .../moa/capabilities/CapabilitiesHandler.java |   48 +-
 .../java/moa/capabilities/Capability.java     |   62 +-
 .../capabilities/CapabilityRequirement.java   |  258 +-
 .../capabilities/ImmutableCapabilities.java   |  197 +-
 .../moa/classifiers/AbstractClassifier.java   |  280 --
 .../classifiers/AbstractEnsembleLearner.java  |   96 -
 .../classifiers/AbstractInstanceLearner.java  |  397 --
 .../MultiTargetLearnerSemiSupervised.java     |   41 -
 .../moa/classifiers/active/ALUncertainty.java |  278 --
 .../moa/classifiers/bayes/NaiveBayes.java     |  198 -
 .../bayes/NaiveBayesMultinomial.java          |  270 --
 .../core/AttributeSplitSuggestion.java        |   66 -
 .../AttributeClassObserver.java               |   74 -
 ...naryTreeNumericAttributeClassObserver.java |  184 -
 ...mericAttributeClassObserverRegression.java |  151 -
 .../FIMTDDNumericAttributeClassObserver.java  |  251 --
 ...GaussianNumericAttributeClassObserver.java |  176 -
 ...ldKhannaNumericAttributeClassObserver.java |  126 -
 .../NominalAttributeClassObserver.java        |  177 -
 .../NullAttributeClassObserver.java           |   80 -
 .../VFMLNumericAttributeClassObserver.java    |  225 -
 .../InstanceConditionalTest.java              |   76 -
 .../NominalAttributeBinaryTest.java           |   72 -
 .../NumericAttributeBinaryTest.java           |   91 -
 .../core/driftdetection/ADWIN.java            |  608 ---
 .../AbstractChangeDetector.java               |  148 -
 .../core/driftdetection/ChangeDetector.java   |  100 -
 .../core/driftdetection/CusumDM.java          |  116 -
 .../classifiers/core/driftdetection/DDM.java  |  142 -
 .../classifiers/core/driftdetection/EDDM.java |  159 -
 .../core/driftdetection/EWMAChartDM.java      |  131 -
 .../EnsembleDriftDetectionMethods.java        |  144 -
 .../GeometricMovingAverageDM.java             |  114 -
 .../core/driftdetection/HDDM_A_Test.java      |  182 -
 .../core/driftdetection/HDDM_W_Test.java      |  215 -
 .../core/driftdetection/PageHinkleyDM.java    |  117 -
 .../classifiers/core/driftdetection/RDDM.java |  238 --
 .../driftdetection/SEEDChangeDetector.java    |  626 ---
 .../core/driftdetection/STEPD.java            |  144 -
 .../SeqDrift1ChangeDetector.java              |  510 ---
 .../SeqDrift2ChangeDetector.java              |  595 ---
 .../splitcriteria/GiniSplitCriterion.java     |   86 -
 .../splitcriteria/InfoGainSplitCriterion.java |  119 -
 .../VarianceReductionSplitCriterion.java      |  106 -
 .../core/statisticaltests/Cramer.java         |  744 ----
 .../core/statisticaltests/KNN.java            |  434 --
 .../drift/DriftDetectionMethodClassifier.java |  201 -
 .../moa/classifiers/functions/AdaGrad.java    |  190 -
 .../classifiers/functions/MajorityClass.java  |   97 -
 .../moa/classifiers/functions/Perceptron.java |  159 -
 .../java/moa/classifiers/functions/SGD.java   |  390 --
 .../classifiers/functions/SGDMultiClass.java  |  408 --
 .../moa/classifiers/functions/SPegasos.java   |  357 --
 .../main/java/moa/classifiers/lazy/kNN.java   |  137 -
 .../java/moa/classifiers/lazy/kNNwithPAW.java |   80 -
 .../classifiers/lazy/kNNwithPAWandADWIN.java  |  111 -
 .../neighboursearch/DistanceFunction.java     |  129 -
 .../neighboursearch/EuclideanDistance.java    |  228 -
 .../lazy/neighboursearch/KDTree.java          | 1129 -----
 .../lazy/neighboursearch/LinearNNSearch.java  |  281 --
 .../NearestNeighbourSearch.java               |  742 ----
 .../neighboursearch/NormalizableDistance.java |  722 ----
 .../neighboursearch/kdtrees/KDTreeNode.java   |  186 -
 .../kdtrees/KDTreeNodeSplitter.java           |  242 --
 .../kdtrees/KMeansInpiredMethod.java          |  348 --
 .../kdtrees/MedianOfWidestDimension.java      |  189 -
 .../kdtrees/MidPointOfWidestDimension.java    |  156 -
 .../kdtrees/SlidingMidPointOfWidestSide.java  |  229 -
 .../main/java/moa/classifiers/meta/ADACC.java |  307 --
 .../main/java/moa/classifiers/meta/ADOB.java  |  208 -
 .../classifiers/meta/AbstractOzaBagAdwin.java |  168 -
 .../classifiers/meta/AbstractOzaBoost.java    |  147 -
 .../meta/AccuracyWeightedEnsemble.java        |  468 ---
 .../meta/AdaptiveRandomForest.java            |  477 ---
 .../meta/AdaptiveRandomForestRegressor.java   |  370 --
 .../main/java/moa/classifiers/meta/BOLE.java  |  225 -
 .../main/java/moa/classifiers/meta/DACC.java  |  430 --
 .../meta/DynamicWeightedMajority.java         |  187 -
 .../java/moa/classifiers/meta/LearnNSE.java   |  283 --
 .../moa/classifiers/meta/LeveragingBag.java   |  285 --
 .../classifiers/meta/LimAttClassifier.java    |  539 ---
 .../java/moa/classifiers/meta/OCBoost.java    |  189 -
 .../classifiers/meta/OnlineSmoothBoost.java   |  149 -
 .../java/moa/classifiers/meta/OzaBagASHT.java |  192 -
 .../moa/classifiers/meta/OzaBoostAdwin.java   |  280 --
 .../moa/classifiers/meta/PairedLearners.java  |  147 -
 .../main/java/moa/classifiers/meta/RCD.java   |  287 --
 .../meta/TemporallyAugmentedClassifier.java   |  189 -
 .../moa/classifiers/meta/WEKAClassifier.java  |  209 -
 .../meta/WeightedMajorityAlgorithm.java       |  208 -
 .../moa/classifiers/mlc/MEKAClassifier.java   |  194 -
 .../moa/classifiers/mlc/MajorityLabelset.java |  110 -
 .../mlc/MultilabelHoeffdingTree.java          |  986 -----
 .../AttributeStatisticsObserver.java          |   59 -
 .../MultiLabelNominalAttributeObserver.java   |  109 -
 .../splitcriteria/ICVarianceReduction.java    |  114 -
 .../MultiLabelSplitCriterion.java             |   16 -
 .../PCTWeightedICVarianceReduction.java       |   84 -
 ...tiveRandomForestMultiTargetRegression.java |  511 ---
 .../mtr/BasicMultiTargetRegressor.java        |  160 -
 .../mtr/functions/MultiTargetNoChange.java    |   70 -
 .../classifiers/rules/AbstractAMRules.java    |  453 --
 .../classifiers/rules/RuleClassification.java |  125 -
 .../moa/classifiers/rules/RuleClassifier.java | 1316 ------
 .../rules/RuleClassifierNBayes.java           |  248 --
 .../rules/core/RuleActiveLearningNode.java    |  337 --
 .../moa/classifiers/rules/core/Utils.java     |  142 -
 .../AnomalinessRatioScore.java                |  165 -
 .../core/anomalydetection/OddsRatioScore.java |  193 -
 ...TDDNumericAttributeClassLimitObserver.java |  114 -
 .../changedetection/NoChangeDetection.java    |   49 -
 .../NumericAttributeBinaryRulePredicate.java  |  179 -
 .../splitcriteria/AMRulesSplitCriterion.java  |   12 -
 .../SDRSplitCriterionAMRulesNode.java         |   67 -
 .../core/splitcriteria/VRSplitCriterion.java  |   52 -
 .../VarianceRatioSplitCriterion.java          |   79 -
 .../rules/driftdetection/PageHinkleyTest.java |   74 -
 .../featureranking/MeritFeatureRanking.java   |  181 -
 .../WeightedMajorityFeatureRanking.java       |  214 -
 .../functions/AMRulesRegressorFunction.java   |   26 -
 .../rules/meta/RandomAMRulesOld.java          |  208 -
 .../AMRulesMultiLabelClassifier.java          |   96 -
 .../multilabel/AMRulesMultiLabelLearner.java  |  572 ---
 .../AMRulesMultiLabelLearnerSemiSuper.java    |  613 ---
 .../AMRulesMultiTargetRegressor.java          |  104 -
 .../AMRulesMultiTargetRegressorSemiSuper.java |   67 -
 .../MultiLabelBSTreeFloat.java                |  224 -
 .../attributeclassobservers/SingleVector.java |  204 -
 .../core/LearningLiteralClassification.java   |  381 --
 .../core/LearningLiteralRegression.java       |  335 --
 .../MultiTargetVarianceRatio.java             |  110 -
 .../MultilabelInformationGain.java            |  144 -
 .../core/voting/MultiLabelVote.java           |   51 -
 .../RelativeMeanAbsoluteDeviationMT.java      |  101 -
 .../RelativeRootMeanSquaredErrorMT.java       |  101 -
 .../AdaptiveMultiTargetRegressor.java         |  176 -
 .../MultiLabelPerceptronClassification.java   |   57 -
 .../functions/StackedPredictor.java           |  419 --
 .../inputselectors/MeritThreshold.java        |   85 -
 .../meta/MultiLabelRandomAMRules.java         |  243 --
 .../java/moa/classifiers/trees/ARFFIMTDD.java | 1010 -----
 .../classifiers/trees/ARFHoeffdingTree.java   |  188 -
 .../classifiers/trees/ASHoeffdingTree.java    |  183 -
 .../trees/AdaHoeffdingOptionTree.java         |  114 -
 .../moa/classifiers/trees/DecisionStump.java  |  160 -
 .../main/java/moa/classifiers/trees/EFDT.java | 1615 --------
 .../trees/HoeffdingAdaptiveTree.java          |  521 ---
 .../HoeffdingAdaptiveTreeClassifLeaves.java   |  189 -
 .../trees/HoeffdingOptionTree.java            | 1219 ------
 .../moa/classifiers/trees/HoeffdingTree.java  |  938 -----
 .../trees/HoeffdingTreeClassifLeaves.java     |  190 -
 .../trees/LimAttHoeffdingTree.java            |  196 -
 .../trees/RandomHoeffdingTree.java            |  171 -
 .../moa/classifiers/trees/iadem/Iadem2.java   | 2072 ----------
 .../moa/classifiers/trees/iadem/Iadem3.java   | 1323 ------
 .../trees/iadem/Iadem3Subtree.java            |  163 -
 .../trees/iadem/IademCommonProcedures.java    |  166 -
 ...GaussianNumericAttributeClassObserver.java |  223 -
 ...ldKhannaNumericAttributeClassObserver.java |  262 --
 .../iadem/IademNumericAttributeObserver.java  |   62 -
 .../trees/iadem/IademSplitCriterion.java      |  367 --
 ...ademVFMLNumericAttributeClassObserver.java |  651 ---
 moa/src/main/java/moa/cluster/CFCluster.java  |  133 +-
 moa/src/main/java/moa/cluster/Cluster.java    |  270 +-
 moa/src/main/java/moa/cluster/Clustering.java |  499 ++-
 moa/src/main/java/moa/cluster/Miniball.java   |  840 ++--
 .../main/java/moa/cluster/SphereCluster.java  |  133 +-
 .../java/moa/clusterers/ClusterGenerator.java |  370 --
 moa/src/main/java/moa/clusterers/CobWeb.java  |  997 -----
 moa/src/main/java/moa/clusterers/KMeans.java  |  202 -
 .../clusterers/WekaClusteringAlgorithm.java   |  227 -
 .../clusterers/clustream/ClustreamKernel.java |  274 --
 .../moa/clusterers/clustree/ClusKernel.java   |  338 --
 .../moa/clusterers/clustree/ClusTree.java     |  879 ----
 .../java/moa/clusterers/clustree/Entry.java   |  464 ---
 .../java/moa/clusterers/clustree/Node.java    |  332 --
 .../moa/clusterers/clustree/util/Budget.java  |  117 -
 .../clustree/util/SimpleBudget.java           |  102 -
 .../clusterers/denstream/MicroCluster.java    |  157 -
 .../java/moa/clusterers/macro/ColorArray.java |  148 -
 .../outliers/AbstractC/AbstractC.java         |  168 -
 .../outliers/AbstractC/AbstractCBase.java     |  213 -
 .../outliers/AbstractC/ISBIndex.java          |  173 -
 .../outliers/AbstractC/MyMTree.java           |   67 -
 .../outliers/AbstractC/StreamObj.java         |   96 -
 .../clusterers/outliers/AbstractC/Test.java   |   63 -
 .../outliers/Angiulli/ApproxSTORM.java        |  354 --
 .../outliers/Angiulli/ExactSTORM.java         |  305 --
 .../outliers/Angiulli/ISBIndex.java           |  167 -
 .../clusterers/outliers/Angiulli/MyMTree.java |   65 -
 .../outliers/Angiulli/STORMBase.java          |  160 -
 .../outliers/Angiulli/StreamObj.java          |   96 -
 .../clusterers/outliers/Angiulli/Test.java    |   62 -
 .../outliers/AnyOut/util/DataObject.java      |  133 -
 .../outliers/AnyOut/util/DataSet.java         |  273 --
 .../clusterers/outliers/MCOD/ISBIndex.java    |  275 --
 .../moa/clusterers/outliers/MCOD/MCOD.java    |  408 --
 .../clusterers/outliers/MCOD/MCODBase.java    |  372 --
 .../outliers/MCOD/MTreeMicroClusters.java     |   65 -
 .../outliers/MCOD/MTreeStreamObjects.java     |   65 -
 .../outliers/MCOD/MicroCluster.java           |  104 -
 .../clusterers/outliers/MCOD/StreamObj.java   |   96 -
 .../moa/clusterers/outliers/MCOD/Test.java    |   63 -
 .../outliers/MyBaseOutlierDetector.java       |  476 ---
 .../outliers/SimpleCOD/ISBIndex.java          |  262 --
 .../outliers/SimpleCOD/MyMTree.java           |   65 -
 .../outliers/SimpleCOD/SimpleCOD.java         |  208 -
 .../outliers/SimpleCOD/SimpleCODBase.java     |  319 --
 .../outliers/SimpleCOD/StreamObj.java         |   96 -
 .../clusterers/outliers/SimpleCOD/Test.java   |   57 -
 .../moa/clusterers/outliers/TestSpeed.java    |   74 -
 .../clusterers/streamkm/BucketManager.java    |  159 -
 .../moa/clusterers/streamkm/MTRandom.java     |  390 --
 .../moa/clusterers/streamkm/StreamKM.java     |  386 --
 .../moa/clusterers/streamkm/TreeCoreset.java  |  614 ---
 .../java/moa/core/AutoClassDiscovery.java     |  272 +-
 .../main/java/moa/core/AutoExpandVector.java  |  194 +-
 moa/src/main/java/moa/core/DoubleVector.java  |  350 +-
 moa/src/main/java/moa/core/Example.java       |   14 +-
 moa/src/main/java/moa/core/FastVector.java    |   52 +-
 .../main/java/moa/core/FixedLengthList.java   |   73 +-
 .../main/java/moa/core/GaussianEstimator.java |  183 +-
 moa/src/main/java/moa/core/Globals.java       |   38 +-
 .../core/GreenwaldKhannaQuantileSummary.java  |  430 +-
 .../moa/core/InputStreamProgressMonitor.java  |   12 +-
 .../main/java/moa/core/InstanceExample.java   |   15 +-
 moa/src/main/java/moa/core/Measurement.java   |  147 +-
 moa/src/main/java/moa/core/MiscUtils.java     |   75 +-
 .../main/java/moa/core/ObjectRepository.java  |    4 +-
 .../main/java/moa/core/PropertiesReader.java  |  129 +-
 .../main/java/moa/core/SerializeUtils.java    |  111 +-
 moa/src/main/java/moa/core/SizeOf.java        |   96 +-
 moa/src/main/java/moa/core/Statistics.java    | 1993 +++++----
 moa/src/main/java/moa/core/StringUtils.java   |  112 +-
 moa/src/main/java/moa/core/TimingUtils.java   |   62 +-
 moa/src/main/java/moa/core/Utils.java         | 3679 ++++++++---------
 moa/src/main/java/moa/core/WekaUtils.java     |   56 +-
 .../core/utils/AttributeDefinitionUtil.java   |  229 +-
 .../main/java/moa/core/utils/Converter.java   |   89 +-
 .../moa/evaluation/ALMeasureCollection.java   |   15 +-
 .../main/java/moa/evaluation/Accuracy.java    |   35 +-
 ...sicClassificationPerformanceEvaluator.java |  339 --
 ...BasicConceptDriftPerformanceEvaluator.java |  210 -
 .../BasicMultiLabelPerformanceEvaluator.java  |  187 -
 .../BasicMultiTargetPerformanceEvaluator.java |  113 -
 .../BasicRegressionPerformanceEvaluator.java  |  146 -
 moa/src/main/java/moa/evaluation/CMM.java     |  920 ++---
 .../java/moa/evaluation/CMM_GTAnalysis.java   | 1567 ++++---
 .../evaluation/ChangeDetectionMeasures.java   |   41 +-
 .../ClassificationMeasureCollection.java      |    5 +-
 .../moa/evaluation/EntropyCollection.java     |  307 +-
 moa/src/main/java/moa/evaluation/F1.java      |  168 +-
 moa/src/main/java/moa/evaluation/General.java |  291 +-
 .../moa/evaluation/LearningEvaluation.java    |   54 +-
 .../moa/evaluation/MeasureCollection.java     |  457 +-
 .../java/moa/evaluation/MembershipMatrix.java |  238 +-
 ...dowClassificationPerformanceEvaluator.java |  150 -
 .../moa/evaluation/OutlierPerformance.java    |   42 +-
 .../moa/evaluation/RegressionAccuracy.java    |   22 +-
 moa/src/main/java/moa/evaluation/SSQ.java     |   76 +-
 .../main/java/moa/evaluation/Separation.java  |   93 +-
 .../moa/evaluation/SilhouetteCoefficient.java |  224 +-
 .../moa/evaluation/StatisticalCollection.java |  318 +-
 ...dowClassificationPerformanceEvaluator.java |  102 -
 ...iTargetRegressionPerformanceEvaluator.java |  175 -
 ...nPerformanceRelativeMeasuresEvaluator.java |  213 -
 .../WindowRegressionPerformanceEvaluator.java |  172 -
 .../ALClassificationPerformanceEvaluator.java |   25 +-
 ...dowClassificationPerformanceEvaluator.java |   65 +-
 ...winClassificationPerformanceEvaluator.java |   48 +-
 ...asicAUCImbalancedPerformanceEvaluator.java |   28 +-
 ...sicClassificationPerformanceEvaluator.java |  332 ++
 ...BasicConceptDriftPerformanceEvaluator.java |  191 +
 .../BasicMultiLabelPerformanceEvaluator.java  |  179 +
 .../BasicMultiTargetPerformanceEvaluator.java |  107 +
 ...tPerformanceRelativeMeasuresEvaluator.java |   92 +-
 .../BasicRegressionPerformanceEvaluator.java  |  130 +
 .../ClassificationPerformanceEvaluator.java   |    4 +-
 ...WMAClassificationPerformanceEvaluator.java |   55 +-
 ...torClassificationPerformanceEvaluator.java |   77 +-
 .../LearningPerformanceEvaluator.java         |   55 +-
 ...belClassificationPerformanceEvaluator.java |   10 +-
 ...dowClassificationPerformanceEvaluator.java |  147 +
 ...iTargetRegressionPerformanceEvaluator.java |   10 +-
 .../RegressionPerformanceEvaluator.java       |   10 +-
 ...ndowAUCImbalancedPerformanceEvaluator.java |  311 +-
 ...dowClassificationPerformanceEvaluator.java |  105 +
 ...iTargetRegressionPerformanceEvaluator.java |  168 +
 ...nPerformanceRelativeMeasuresEvaluator.java |  205 +
 .../WindowRegressionPerformanceEvaluator.java |  162 +
 .../moa/evaluation/preview/LearningCurve.java |  250 +-
 .../preview/MeanPreviewCollection.java        |  613 ++-
 .../java/moa/evaluation/preview/Preview.java  |   17 +-
 .../evaluation/preview/PreviewCollection.java |   29 +-
 ...PreviewCollectionLearningCurveWrapper.java |   31 +-
 moa/src/main/java/moa/gui/ALTabPanel.java     |   16 +-
 .../java/moa/gui/AWTInteractiveRenderer.java  |    4 +-
 moa/src/main/java/moa/gui/AWTRenderable.java  |    8 +-
 moa/src/main/java/moa/gui/AWTRenderer.java    |    9 +-
 .../main/java/moa/gui/AbstractTabPanel.java   |   29 +-
 .../main/java/moa/gui/AuxiliarTabPanel.java   |   16 +-
 .../moa/gui/AuxiliarTaskManagerPanel.java     |  923 ++---
 moa/src/main/java/moa/gui/BatchCmd.java       |  162 +-
 .../moa/gui/ClassOptionSelectionPanel.java    |  274 +-
 ...OptionWithListenerOptionEditComponent.java |   16 +-
 .../ClassOptionWithNamesSelectionPanel.java   |  275 +-
 .../java/moa/gui/ClassificationTabPanel.java  |   16 +-
 .../java/moa/gui/ConceptDriftTabPanel.java    |   16 +-
 ...ditableMultiChoiceOptionEditComponent.java |   21 +-
 .../java/moa/gui/FileExtensionFilter.java     |   42 +-
 moa/src/main/java/moa/gui/GUI.java            |  199 +-
 moa/src/main/java/moa/gui/GUIDefaults.java    |  534 ++-
 moa/src/main/java/moa/gui/GUIUtils.java       |   27 +-
 .../main/java/moa/gui/LineGraphViewPanel.java |  263 +-
 moa/src/main/java/moa/gui/LookAndFeel.java    |  381 +-
 .../gui/MultiLabelClassificationTabPanel.java |   16 +-
 ...tiLabelClassificationTaskManagerPanel.java |  926 ++---
 .../gui/MultiTargetRegressionTabPanel.java    |   16 +-
 ...MultiTargetRegressionTaskManagerPanel.java |  903 ++--
 moa/src/main/java/moa/gui/PreviewPanel.java   |  338 +-
 .../main/java/moa/gui/PreviewTableModel.java  |   58 +-
 .../main/java/moa/gui/RegressionTabPanel.java |   16 +-
 .../moa/gui/RegressionTaskManagerPanel.java   |  900 ++--
 .../main/java/moa/gui/ScriptingTabPanel.java  |  101 +-
 moa/src/main/java/moa/gui/TaskLauncher.java   |    7 +-
 .../main/java/moa/gui/TaskManagerPanel.java   |  972 +++--
 .../java/moa/gui/TaskTextViewerPanel.java     | 1344 +++---
 .../main/java/moa/gui/TextViewerPanel.java    |  114 +-
 .../moa/gui/WEKAClassOptionEditComponent.java |  160 +-
 .../java/moa/gui/active/ALPreviewPanel.java   |  403 +-
 .../moa/gui/active/ALTaskManagerPanel.java    |  914 ++--
 .../moa/gui/active/ALTaskTextViewerPanel.java |  383 +-
 .../java/moa/gui/active/MeasureOverview.java  |  476 +--
 .../gui/clustertab/ClusteringAlgoPanel.java   |  411 +-
 .../gui/clustertab/ClusteringEvalPanel.java   |  313 +-
 .../gui/clustertab/ClusteringSetupTab.java    |  563 +--
 .../gui/clustertab/ClusteringTabPanel.java    |  158 +-
 .../clustertab/ClusteringVisualEvalPanel.java |  484 ++-
 .../gui/clustertab/ClusteringVisualTab.java   | 1457 +++----
 .../gui/colorGenerator/ColorGenerator.java    |   12 +-
 .../gui/colorGenerator/HSVColorGenerator.java |   74 +-
 .../gui/conceptdrift/CDTaskManagerPanel.java  |  936 ++---
 .../moa/gui/experimentertab/Algorithm.java    |  283 +-
 .../moa/gui/experimentertab/AnalyzeTab.java   | 1248 +++---
 .../java/moa/gui/experimentertab/Buffer.java  |   77 +-
 .../gui/experimentertab/ExpPreviewPanel.java  |  308 +-
 .../gui/experimentertab/ExpTaskThread.java    |  321 +-
 .../experimentertab/ExperimenterTabPanel.java |   79 +-
 .../gui/experimentertab/ExperimeterCLI.java   |  622 +--
 .../moa/gui/experimentertab/ImageChart.java   |  397 +-
 .../moa/gui/experimentertab/ImagePanel.java   |  235 +-
 .../gui/experimentertab/ImageTreePanel.java   |  215 +-
 .../moa/gui/experimentertab/ImageViewer.java  |  151 +-
 .../java/moa/gui/experimentertab/Measure.java |  326 +-
 .../java/moa/gui/experimentertab/PlotTab.java | 2573 ++++++------
 .../experimentertab/PreviewExperiments.java   |   50 +-
 .../moa/gui/experimentertab/RankingGraph.java |  976 +++--
 .../moa/gui/experimentertab/ReadFile.java     |  607 ++-
 .../java/moa/gui/experimentertab/Stream.java  |  125 +-
 .../java/moa/gui/experimentertab/Summary.java | 1132 +++--
 .../moa/gui/experimentertab/SummaryTab.java   | 1090 +++--
 .../moa/gui/experimentertab/SummaryTable.java |   13 +-
 .../gui/experimentertab/SummaryViewer.java    |  193 +-
 .../gui/experimentertab/TaskManagerForm.java  |  511 ++-
 .../experimentertab/TaskManagerTabPanel.java  | 2555 ++++++------
 .../experimentertab/TaskTextViewerPanel.java  |  944 ++---
 .../statisticaltests/CDF_Normal.java          |  334 +-
 .../statisticaltests/Fichero.java             |  143 +-
 .../PValuePerTwoAlgorithm.java                |   81 +-
 .../statisticaltests/Pareja.java              |   47 +-
 .../statisticaltests/RankPerAlgorithm.java    |   48 +-
 .../statisticaltests/Relation.java            |   33 +-
 .../statisticaltests/StatisticalTest.java     | 1271 +++---
 .../tasks/ConceptDriftMainTask.java           |   19 +-
 .../tasks/EvaluateConceptDrift.java           |   67 +-
 .../tasks/EvaluateInterleavedChunks.java      |   65 +-
 .../EvaluateInterleavedTestThenTrain.java     |   72 +-
 .../tasks/EvaluatePeriodicHeldOutTest.java    |   68 +-
 .../tasks/EvaluatePrequential.java            |   78 +-
 .../tasks/EvaluatePrequentialCV.java          |  124 +-
 .../tasks/ExperimenterTask.java               |    5 +-
 .../moa/gui/outliertab/OutlierAlgoPanel.java  |  416 +-
 .../moa/gui/outliertab/OutlierEvalPanel.java  |  254 +-
 .../moa/gui/outliertab/OutlierSetupTab.java   |  582 +--
 .../moa/gui/outliertab/OutlierTabPanel.java   |  158 +-
 .../outliertab/OutlierVisualEvalPanel.java    |  442 +-
 .../moa/gui/outliertab/OutlierVisualTab.java  | 1666 ++++----
 .../gui/visualization/AbstractGraphAxes.java  |  424 +-
 .../visualization/AbstractGraphCanvas.java    |  644 ++-
 .../gui/visualization/AbstractGraphPlot.java  |  236 +-
 .../moa/gui/visualization/ClusterPanel.java   |  356 +-
 .../java/moa/gui/visualization/DataPoint.java |  206 +-
 .../java/moa/gui/visualization/GraphAxes.java |  275 +-
 .../moa/gui/visualization/GraphCanvas.java    |  476 +--
 .../moa/gui/visualization/GraphCurve.java     |  301 +-
 .../gui/visualization/GraphMultiCurve.java    |  117 +-
 .../moa/gui/visualization/GraphScatter.java   |  128 +-
 .../java/moa/gui/visualization/InfoPanel.java |   57 +-
 .../moa/gui/visualization/OutlierEvent.java   |   62 +-
 .../moa/gui/visualization/OutlierPanel.java   |  410 +-
 .../moa/gui/visualization/ParamGraphAxes.java |   53 +-
 .../gui/visualization/ParamGraphCanvas.java   |  128 +-
 .../moa/gui/visualization/PointPanel.java     |  521 ++-
 .../gui/visualization/ProcessGraphAxes.java   |   42 +-
 .../gui/visualization/ProcessGraphCanvas.java |   28 +-
 .../visualization/RunOutlierVisualizer.java   | 1221 +++---
 .../moa/gui/visualization/RunVisualizer.java  | 1108 ++---
 .../gui/visualization/StreamOutlierPanel.java |  850 ++--
 .../moa/gui/visualization/StreamPanel.java    |  783 ++--
 .../moa/gui/visualization/WekaExplorer.java   |  166 +-
 .../moa/learners/ChangeDetectorLearner.java   |   80 -
 .../main/java/moa/learners/Classifier.java    |   63 -
 moa/src/main/java/moa/learners/MLTask.java    |  221 +-
 .../moa/learners/MultiLabelClassifier.java    |   51 -
 .../moa/learners/MultiTargetRegressor.java    |   75 -
 .../clusterers/AbstractClusterer.java         |  119 +-
 .../learners/clusterers/ClusterGenerator.java |  355 ++
 .../{ => learners}/clusterers/Clusterer.java  |   39 +-
 .../java/moa/learners/clusterers/CobWeb.java  |  964 +++++
 .../java/moa/learners/clusterers/KMeans.java  |  197 +
 .../clusterers/WekaClusteringAlgorithm.java   |  223 +
 .../clusterers/clustream/Clustream.java       |  185 +-
 .../clusterers/clustream/ClustreamKernel.java |  274 ++
 .../clusterers/clustream/WithKmeans.java      |  246 +-
 .../clusterers/clustree/ClusKernel.java       |  340 ++
 .../clusterers/clustree/ClusTree.java         |  832 ++++
 .../learners/clusterers/clustree/Entry.java   |  480 +++
 .../learners/clusterers/clustree/Node.java    |  340 ++
 .../clusterers/clustree/util/Budget.java      |  124 +
 .../clustree/util/SimpleBudget.java           |  102 +
 .../clusterers/denstream/MicroCluster.java    |  159 +
 .../clusterers/denstream/Timestamp.java       |   46 +-
 .../clusterers/denstream/WithDBSCAN.java      |  107 +-
 .../dstream/CharacteristicVector.java         |  219 +-
 .../clusterers/dstream/DensityGrid.java       |  204 +-
 .../clusterers/dstream/Dstream.java           | 1254 +++---
 .../clusterers/dstream/GridCluster.java       |  270 +-
 .../clusterers/kmeanspm/BICO.java             |  123 +-
 .../kmeanspm/ClusteringFeature.java           |  102 +-
 .../kmeanspm/ClusteringTreeHeadNode.java      |   95 +-
 .../kmeanspm/ClusteringTreeNode.java          |   46 +-
 .../clusterers/kmeanspm/CoresetKMeans.java    |   37 +-
 .../clusterers/kmeanspm/CuckooHashing.java    |   99 +-
 .../kmeanspm/DietzfelbingerHash.java          |   18 +-
 .../clusterers/kmeanspm/Metric.java           |  164 +-
 .../macro/AbstractMacroClusterer.java         |   17 +-
 .../learners/clusterers/macro/ColorArray.java |  124 +
 .../clusterers/macro/ColorObject.java         |    9 +-
 .../clusterers/macro/IDenseMacroCluster.java  |   12 +-
 .../clusterers/macro/IMacroClusterer.java     |   10 +-
 .../clusterers/macro/NonConvexCluster.java    |   16 +-
 .../clusterers/macro/dbscan/DBScan.java       |   48 +-
 .../macro/dbscan/DenseMicroCluster.java       |   36 +-
 .../outliers/AbstractC/AbstractC.java         |  182 +
 .../outliers/AbstractC/AbstractCBase.java     |  216 +
 .../outliers/AbstractC/ISBIndex.java          |  170 +
 .../outliers/AbstractC/MyMTree.java           |   66 +
 .../outliers/AbstractC/StreamObj.java         |   96 +
 .../clusterers/outliers/AbstractC/Test.java   |   65 +
 .../outliers/Angiulli/ApproxSTORM.java        |  359 ++
 .../outliers/Angiulli/ExactSTORM.java         |  308 ++
 .../outliers/Angiulli/ISBIndex.java           |  165 +
 .../clusterers/outliers/Angiulli/MyMTree.java |   65 +
 .../outliers/Angiulli/STORMBase.java          |  163 +
 .../outliers/Angiulli/StreamObj.java          |   96 +
 .../clusterers/outliers/Angiulli/Test.java    |   60 +
 .../clusterers/outliers/AnyOut/AnyOut.java    |  143 +-
 .../outliers/AnyOut/AnyOutCore.java           |  226 +-
 .../outliers/AnyOut/util/DataObject.java      |  140 +
 .../outliers/AnyOut/util/DataSet.java         |  296 ++
 .../AnyOut/util/EMProjectedClustering.java    |  141 +-
 .../AnyOut/util/EMTopDownTreeBuilder.java     |   85 +-
 .../clusterers/outliers/MCOD/ISBIndex.java    |  273 ++
 .../clusterers/outliers/MCOD/MCOD.java        |  464 +++
 .../clusterers/outliers/MCOD/MCODBase.java    |  374 ++
 .../outliers/MCOD/MTreeMicroClusters.java     |   66 +
 .../outliers/MCOD/MTreeStreamObjects.java     |   65 +
 .../outliers/MCOD/MicroCluster.java           |  104 +
 .../clusterers/outliers/MCOD/StreamObj.java   |   96 +
 .../clusterers/outliers/MCOD/Test.java        |   64 +
 .../outliers/MyBaseOutlierDetector.java       |  457 ++
 .../outliers/SimpleCOD/ISBIndex.java          |  259 ++
 .../outliers/SimpleCOD/MyMTree.java           |   65 +
 .../outliers/SimpleCOD/SimpleCOD.java         |  229 +
 .../outliers/SimpleCOD/SimpleCODBase.java     |  321 ++
 .../outliers/SimpleCOD/StreamObj.java         |   96 +
 .../clusterers/outliers/SimpleCOD/Test.java   |   55 +
 .../clusterers/outliers/TestSpeed.java        |   73 +
 .../utils/mtree/ComposedSplitFunction.java    |   19 +-
 .../utils/mtree/DistanceFunction.java         |    8 +-
 .../utils/mtree/DistanceFunctions.java        |  139 +-
 .../outliers/utils/mtree/MTree.java           |  551 ++-
 .../utils/mtree/PartitionFunction.java        |   26 +-
 .../utils/mtree/PartitionFunctions.java       |   77 +-
 .../utils/mtree/PromotionFunction.java        |   18 +-
 .../utils/mtree/PromotionFunctions.java       |   28 +-
 .../outliers/utils/mtree/SplitFunction.java   |   37 +-
 .../outliers/utils/mtree/utils/Pair.java      |   33 +-
 .../outliers/utils/mtree/utils/Utils.java     |   55 +-
 .../clusterers/streamkm/BucketManager.java    |  157 +
 .../streamkm/CoresetCostTriple.java           |   31 +-
 .../clusterers/streamkm/MTRandom.java         |  410 ++
 .../clusterers/streamkm/Point.java            |  141 +-
 .../clusterers/streamkm/StreamKM.java         |  365 ++
 .../clusterers/streamkm/TreeCoreset.java      |  613 +++
 .../predictors/AbstractClassifier.java        |  248 ++
 .../predictors/AbstractEnsembleLearner.java   |   97 +
 .../predictors/AbstractInstanceLearner.java   |  385 ++
 .../AbstractMultiLabelClassifier.java         |    7 +-
 .../AbstractMultiTargetRegressor.java         |    7 +-
 .../predictors}/AbstractRegressor.java        |    4 +-
 .../predictors/ChangeDetectorLearner.java     |   86 +
 .../moa/learners/predictors/Classifier.java   |   63 +
 .../{ => predictors}/InstanceLearner.java     |   46 +-
 .../LearnerSemiSupervised.java                |   15 +-
 .../predictors/MultiLabelClassifier.java      |   51 +
 .../predictors/MultiTargetRegressor.java      |   76 +
 .../predictors}/OneClassClassifier.java       |   29 +-
 .../learners/{ => predictors}/Regressor.java  |   12 +-
 .../predictors/SemiSupervisedClassifier.java} |   29 +-
 .../SemiSupervisedInstanceLearner.java        |   35 +
 .../SemiSupervisedMultiLabelClassifier.java   |   31 +
 .../SemiSupervisedMultiTargetRegressor.java   |   31 +
 .../predictors/SemiSupervisedRegressor.java}  |   13 +-
 .../predictors}/active/ALClassifier.java      |   21 +-
 .../predictors}/active/ALRandom.java          |   68 +-
 .../predictors/active/ALUncertainty.java      |  277 ++
 .../active/budget/BudgetManager.java          |   20 +-
 .../predictors}/active/budget/FixedBM.java    |   30 +-
 .../learners/predictors/bayes/NaiveBayes.java |  198 +
 .../bayes/NaiveBayesMultinomial.java          |  278 ++
 .../core/AttributeSplitSuggestion.java        |   65 +
 .../predictors}/core/LearningLiteral.java     |  199 +-
 .../core/LearningLiteralClassification.java   |  381 ++
 .../core/LearningLiteralRegression.java       |  341 ++
 .../predictors}/core/Literal.java             |   27 +-
 .../predictors}/core/MultiLabelRule.java      |  155 +-
 .../core/MultiLabelRuleClassification.java    |   14 +-
 .../core/MultiLabelRuleRegression.java        |   11 +-
 .../predictors}/core/MultiLabelRuleSet.java   |    8 +-
 .../predictors}/core/ObservableMOAObject.java |   29 +-
 .../predictors}/core/ObserverMOAObject.java   |    4 +-
 .../AbstractAttributeClassObserver.java       |    4 +-
 .../AttributeClassObserver.java               |   71 +
 .../AttributeStatisticsObserver.java          |   58 +
 ...naryTreeNumericAttributeClassObserver.java |  177 +
 ...mericAttributeClassObserverRegression.java |  151 +
 .../DiscreteAttributeClassObserver.java       |   14 +-
 ...TDDNumericAttributeClassLimitObserver.java |  106 +
 .../FIMTDDNumericAttributeClassObserver.java  |  268 ++
 ...GaussianNumericAttributeClassObserver.java |  170 +
 ...ldKhannaNumericAttributeClassObserver.java |  122 +
 .../MultiLabelBSTree.java                     |  111 +-
 .../MultiLabelBSTreeFloat.java                |  218 +
 .../MultiLabelBSTreePCT.java                  |  132 +-
 .../MultiLabelNominalAttributeObserver.java   |  101 +
 .../NominalAttributeClassObserver.java        |  166 +
 .../NominalStatisticsObserver.java            |    3 +-
 .../NullAttributeClassObserver.java           |   76 +
 .../NumericAttributeClassObserver.java        |   11 +-
 .../NumericStatisticsObserver.java            |    3 +-
 .../attributeclassobservers/SingleVector.java |  202 +
 .../VFMLNumericAttributeClassObserver.java    |  212 +
 .../InstanceConditionalBinaryTest.java        |   15 +-
 .../InstanceConditionalTest.java              |   77 +
 .../NominalAttributeBinaryTest.java           |   69 +
 .../NominalAttributeMultiwayTest.java         |   65 +-
 .../NumericAttributeBinaryTest.java           |   88 +
 .../predictors/core/driftdetection/ADWIN.java |  597 +++
 .../driftdetection/ADWINChangeDetector.java   |   65 +-
 .../AbstractChangeDetector.java               |  153 +
 .../core/driftdetection/ChangeDetector.java   |  102 +
 .../core/driftdetection/CusumDM.java          |  107 +
 .../predictors/core/driftdetection/DDM.java   |  137 +
 .../predictors/core/driftdetection/EDDM.java  |  158 +
 .../core/driftdetection/EWMAChartDM.java      |  130 +
 .../EnsembleDriftDetectionMethods.java        |  136 +
 .../GeometricMovingAverageDM.java             |  109 +
 .../core/driftdetection/HDDM_A_Test.java      |  184 +
 .../core/driftdetection/HDDM_W_Test.java      |  223 +
 .../driftdetection/NoChangeDetection.java     |   45 +
 .../core/driftdetection/PageHinkleyDM.java    |  113 +
 .../predictors/core/driftdetection/RDDM.java  |  228 +
 .../driftdetection/SEEDChangeDetector.java    |  536 +++
 .../predictors/core/driftdetection/STEPD.java |  140 +
 .../SeqDrift1ChangeDetector.java              |  513 +++
 .../SeqDrift2ChangeDetector.java              |  584 +++
 .../AbstractMultiLabelErrorMeasurer.java      |   55 +-
 .../AbstractMultiTargetErrorMeasurer.java     |   16 +-
 .../MeanAbsoluteDeviationMT.java              |   58 +-
 .../MultiLabelErrorMeasurer.java              |   14 +-
 .../MultiTargetErrorMeasurer.java             |    2 +-
 .../RelativeMeanAbsoluteDeviationMT.java      |  100 +
 .../RelativeRootMeanSquaredErrorMT.java       |   97 +
 .../RootMeanSquaredErrorMT.java               |   59 +-
 .../AbstractFeatureRanking.java               |   18 +-
 .../featureranking/BasicFeatureRanking.java   |   83 +-
 .../core}/featureranking/FeatureRanking.java  |    8 +-
 .../featureranking/MeritFeatureRanking.java   |  164 +
 .../featureranking/NoFeatureRanking.java      |   19 +-
 .../WeightedMajorityFeatureRanking.java       |  199 +
 .../messages/ChangeDetectedMessage.java       |    3 +-
 .../messages/FeatureRankingMessage.java       |    2 +-
 .../messages/MeritCheckMessage.java           |   17 +-
 .../messages/RuleExpandedMessage.java         |    6 +-
 .../core}/functions/AMRulesFunction.java      |    7 +-
 ...AbstractAMRulesFunctionBasicMlLearner.java |   26 +-
 .../AdaptiveMultiTargetRegressor.java         |  175 +
 .../functions/DominantLabelsClassifier.java   |   54 +-
 .../core}/functions/MultiLabelNaiveBayes.java |   30 +-
 .../MultiLabelPerceptronClassification.java   |   57 +
 .../functions/MultiTargetMeanRegressor.java   |   33 +-
 .../MultiTargetPerceptronRegressor.java       |   36 +-
 .../core/functions/StackedPredictor.java      |  405 ++
 .../InputAttributesSelector.java              |    8 +-
 .../core/inputselectors/MeritThreshold.java   |   82 +
 .../core}/inputselectors/SelectAllInputs.java |   32 +-
 .../InstanceAttributesSelector.java           |   55 +-
 .../InstanceOutputAttributesSelector.java     |   55 +-
 .../InstanceTransformer.java                  |   11 +-
 .../NoInstanceTransformation.java             |   13 +-
 .../outputselectors/EntropyThreshold.java     |   75 +-
 .../OutputAttributesSelector.java             |    7 +-
 .../outputselectors/SelectAllOutputs.java     |   11 +-
 .../outputselectors/StdDevThreshold.java      |   55 +-
 .../outputselectors/VarianceThreshold.java    |   55 +-
 .../splitcriteria/GiniSplitCriterion.java     |   81 +
 .../splitcriteria/ICVarianceReduction.java    |  110 +
 .../splitcriteria/InfoGainSplitCriterion.java |  112 +
 .../InfoGainSplitCriterionMultilabel.java     |   38 +-
 .../MultiLabelSplitCriterion.java             |   14 +
 .../MultiTargetVarianceRatio.java             |  104 +
 .../MultilabelInformationGain.java            |  131 +
 .../PCTWeightedICVarianceReduction.java       |   91 +
 .../core/splitcriteria/SDRSplitCriterion.java |   18 +-
 .../core/splitcriteria/SplitCriterion.java    |   49 +-
 .../VarianceReductionSplitCriterion.java      |   97 +
 .../WeightedICVarianceReduction.java          |   29 +-
 .../core/statisticaltests/Cramer.java         |  740 ++++
 .../predictors/core/statisticaltests/KNN.java |  412 ++
 .../statisticaltests/StatisticalTest.java     |   35 +-
 .../AbstractErrorWeightedVoteMultiLabel.java  |  127 +-
 .../voting/ErrorWeightedVoteMultiLabel.java   |   93 +-
 .../core/voting/FirstHitVoteMultiLabel.java   |   44 +-
 .../InverseErrorWeightedVoteMultiLabel.java   |   61 +-
 .../core/voting/MultiLabelVote.java           |   48 +
 .../voting/UniformWeightedVoteMultiLabel.java |   49 +-
 .../drift/DriftDetectionMethodClassifier.java |  204 +
 .../predictors/functions/AdaGrad.java         |  182 +
 .../predictors/functions/MajorityClass.java   |   99 +
 .../functions/MajorityLabelset.java           |  110 +
 .../predictors}/functions/Mean.java           |   10 +-
 .../functions/MultiTargetNoChange.java        |   70 +
 .../predictors}/functions/NoChange.java       |   70 +-
 .../predictors/functions/Perceptron.java      |  166 +
 .../learners/predictors/functions/SGD.java    |  383 ++
 .../predictors/functions/SGDMultiClass.java   |  402 ++
 .../predictors/functions/SPegasos.java        |  354 ++
 .../predictors}/lazy/SAMkNN.java              |  352 +-
 .../moa/learners/predictors/lazy/kNN.java     |  141 +
 .../learners/predictors/lazy/kNNwithPAW.java  |   80 +
 .../predictors/lazy/kNNwithPAWandADWIN.java   |  111 +
 .../neighboursearch/DistanceFunction.java     |  126 +
 .../neighboursearch/EuclideanDistance.java    |  231 ++
 .../lazy/neighboursearch/KDTree.java          | 1091 +++++
 .../lazy/neighboursearch/LinearNNSearch.java  |  284 ++
 .../NearestNeighbourSearch.java               |  717 ++++
 .../neighboursearch/NormalizableDistance.java |  702 ++++
 .../neighboursearch/kdtrees/KDTreeNode.java   |  172 +
 .../kdtrees/KDTreeNodeSplitter.java           |  227 +
 .../kdtrees/KMeansInpiredMethod.java          |  320 ++
 .../kdtrees/MedianOfWidestDimension.java      |  183 +
 .../kdtrees/MidPointOfWidestDimension.java    |  143 +
 .../kdtrees/SlidingMidPointOfWidestSide.java  |  211 +
 .../moa/learners/predictors/meta/ADACC.java   |  295 ++
 .../moa/learners/predictors/meta/ADOB.java    |  208 +
 .../predictors}/meta/AbstractOzaBag.java      |   58 +-
 .../predictors/meta/AbstractOzaBagAdwin.java  |  175 +
 .../predictors/meta/AbstractOzaBoost.java     |  154 +
 .../meta/AccuracyUpdatedEnsemble.java         |   94 +-
 .../meta/AccuracyWeightedEnsemble.java        |  481 +++
 .../predictors/meta/AdaptiveRandomForest.java |  486 +++
 .../moa/learners/predictors/meta/BOLE.java    |  221 +
 .../moa/learners/predictors/meta/DACC.java    |  430 ++
 .../meta/DynamicWeightedMajority.java         |  184 +
 .../meta/HeterogeneousEnsembleAbstract.java   |   53 +-
 .../meta/HeterogeneousEnsembleBlast.java      |   15 +-
 ...terogeneousEnsembleBlastFadingFactors.java |   13 +-
 .../learners/predictors/meta/LearnNSE.java    |  276 ++
 .../predictors/meta/LeveragingBag.java        |  285 ++
 .../predictors/meta/LimAttClassifier.java     |  538 +++
 .../moa/learners/predictors/meta/OCBoost.java |  200 +
 .../meta/OnlineAccuracyUpdatedEnsemble.java   |  328 +-
 .../predictors/meta/OnlineSmoothBoost.java    |  153 +
 .../learners/predictors/meta/OzaBagASHT.java  |  192 +
 .../predictors/meta/OzaBoostAdwin.java        |  277 ++
 .../predictors/meta/PairedLearners.java       |  147 +
 .../moa/learners/predictors/meta/RCD.java     |  272 ++
 .../predictors}/meta/RandomRules.java         |   96 +-
 .../predictors}/meta/RegressionViaMTR.java    |   19 +-
 .../meta/TemporallyAugmentedClassifier.java   |  198 +
 .../predictors/meta/WEKAClassifier.java       |  207 +
 .../meta/WeightedMajorityAlgorithm.java       |  193 +
 .../predictors/meta/classifiers/OzaBag.java}  |   19 +-
 .../meta/classifiers/OzaBagAdwin.java}        |   13 +-
 .../meta/classifiers/OzaBoost.java}           |   11 +-
 .../meta/mlc/LocalMultiLabelClassifier.java}  |  141 +-
 .../predictors/meta/mlc/MEKAClassifier.java   |  174 +
 .../OzaBagAdwinMultiLabelClassification.java  |   46 +-
 .../mlc}/OzaBagMultiLabelClassification.java  |   28 +-
 .../meta/mtr/AdaptiveRandomForest.java        |  523 +++
 .../meta}/mtr/LocalMultiTargetRegressor.java  |   81 +-
 .../predictors/meta/mtr/OzaBag.java}          |   28 +-
 .../predictors/meta/mtr/OzaBagAdwin.java}     |   27 +-
 .../AdaptiveRandomForestRegressor.java        |  376 ++
 .../predictors/meta/regressors/OzaBag.java}   |   16 +-
 .../meta/regressors/OzaBagAdwin.java}         |   13 +-
 .../predictors}/oneclass/Autoencoder.java     |  348 +-
 .../predictors}/oneclass/HSTreeNode.java      |  140 +-
 .../predictors}/oneclass/HSTrees.java         |  197 +-
 .../oneclass/NearestNeighbourDescription.java |  218 +-
 .../rules/AMRulesMultiLabelClassifier.java    |   86 +
 .../rules/AMRulesMultiLabelLearner.java       |  552 +++
 .../AMRulesMultiLabelLearnerSemiSuper.java    |  608 +++
 .../rules/AMRulesMultiTargetRegressor.java    |   96 +
 .../AMRulesMultiTargetRegressorSemiSuper.java |   71 +
 .../predictors}/rules/AMRulesRegressor.java   |    7 +-
 .../rules/AMRulesRegressorOld.java            |  173 +-
 .../predictors/rules/AbstractAMRules.java     |  410 ++
 .../rules/BinaryClassifierFromRegressor.java  |   46 +-
 .../rules/MultiLabelRandomAMRules.java        |  234 ++
 .../predictors}/rules/Predicates.java         |   70 +-
 .../predictors/rules/RuleClassification.java  |  124 +
 .../predictors/rules/RuleClassifier.java      | 1426 +++++++
 .../rules/RuleClassifierNBayes.java           |  261 ++
 .../core/AttributeExpansionSuggestion.java    |   67 +-
 .../rules/core/NominalRulePredicate.java      |   53 +-
 .../rules/core/NumericRulePredicate.java      |   56 +-
 .../predictors}/rules/core/Predicate.java     |   27 +-
 .../predictors}/rules/core/Rule.java          |  112 +-
 .../rules/core/RuleActiveLearningNode.java    |  399 ++
 .../rules/core/RuleActiveRegressionNode.java  |  413 +-
 .../predictors}/rules/core/RuleSet.java       |    8 +-
 .../predictors}/rules/core/RuleSplitNode.java |   42 +-
 .../learners/predictors/rules/core/Utils.java |  132 +
 .../AbstractAnomalyDetector.java              |    5 +-
 .../AnomalinessRatioScore.java                |  149 +
 .../anomalydetection/AnomalyDetector.java     |   26 +-
 .../anomalydetection/NoAnomalyDetection.java  |   37 +-
 .../core/anomalydetection/OddsRatioScore.java |  176 +
 .../CantellisInequality.java                  |   31 +-
 .../ChebyshevInequality.java                  |   44 +-
 .../probabilityfunctions/GaussInequality.java |   60 +-
 .../ProbabilityFunction.java                  |    2 +-
 .../NominalAttributeBinaryRulePredicate.java  |   48 +-
 .../NumericAttributeBinaryRulePredicate.java  |  165 +
 .../splitcriteria/AMRulesSplitCriterion.java  |   14 +
 .../SDRSplitCriterionAMRules.java             |   40 +-
 .../SDRSplitCriterionAMRulesNode.java         |   64 +
 .../core/splitcriteria/VRSplitCriterion.java  |   49 +
 .../VarianceRatioSplitCriterion.java          |   73 +
 .../voting/AbstractErrorWeightedVote.java     |   47 +-
 .../rules/core/voting/ErrorWeightedVote.java  |   65 +-
 .../core/voting/ExpNegErrorWeightedVote.java  |   68 +-
 .../core/voting/InverseErrorWeightedVote.java |   79 +-
 .../core/voting/MinErrorWeightedVote.java     |   43 +-
 .../voting/OneMinusErrorWeightedVote.java     |   47 +-
 .../core/voting/UniformWeightedVote.java      |   35 +-
 .../predictors}/rules/core/voting/Vote.java   |   47 +-
 .../driftdetection/PageHinkleyFading.java     |   46 +-
 .../rules/driftdetection/PageHinkleyTest.java |   74 +
 .../errormeasurers/ErrorMeasurement.java      |   27 +-
 .../errormeasurers/MeanAbsoluteDeviation.java |   18 +-
 .../errormeasurers/RootMeanSquaredError.java  |   24 +-
 .../functions/AMRulesClassifierFunction.java  |    2 +-
 .../rules/functions/AMRulesLearner.java       |    8 +-
 .../functions/AdaptiveNodePredictor.java      |   41 +-
 .../rules/functions/FadingTargetMean.java     |   27 +-
 .../functions/LowPassFilteredLearner.java     |   58 +-
 .../rules/functions/Perceptron.java           |  281 +-
 .../rules/functions/TargetMean.java           |   97 +-
 .../predictors}/rules/meta/RandomAMRules.java |   13 +-
 .../rules/meta/RandomAMRulesOld.java          |  204 +
 .../learners/predictors/trees/ARFFIMTDD.java  | 1049 +++++
 .../predictors/trees/ARFHoeffdingTree.java    |  189 +
 .../predictors/trees/ASHoeffdingTree.java     |  184 +
 .../trees/AdaHoeffdingOptionTree.java         |  115 +
 .../predictors/trees/DecisionStump.java       |  157 +
 .../moa/learners/predictors/trees/EFDT.java   | 1536 +++++++
 .../predictors}/trees/FIMTDD.java             |  402 +-
 .../trees/HoeffdingAdaptiveTree.java          |  514 +++
 .../HoeffdingAdaptiveTreeClassifLeaves.java   |  185 +
 .../predictors/trees/HoeffdingOptionTree.java | 1157 ++++++
 .../predictors/trees/HoeffdingTree.java       |  888 ++++
 .../trees/HoeffdingTreeClassifLeaves.java     |  189 +
 .../predictors}/trees/ISOUPOptionTree.java    |  232 +-
 .../predictors}/trees/ISOUPTree.java          |  596 +--
 .../predictors}/trees/ISOUPTreeRF.java        |   40 +-
 .../predictors/trees/LimAttHoeffdingTree.java |  196 +
 .../trees/MultilabelHoeffdingTree.java        |  919 ++++
 .../predictors}/trees/ORTO.java               |  220 +-
 .../predictors/trees/RandomHoeffdingTree.java |  168 +
 .../predictors/trees/iadem/Iadem2.java        | 1900 +++++++++
 .../predictors/trees/iadem/Iadem3.java        | 1151 ++++++
 .../predictors/trees/iadem/Iadem3Subtree.java |  158 +
 .../iadem/IademAttributeSplitSuggestion.java  |   34 +-
 .../trees/iadem/IademCommonProcedures.java    |  161 +
 .../trees/iadem/IademException.java           |   41 +-
 ...GaussianNumericAttributeClassObserver.java |  219 +
 ...ldKhannaNumericAttributeClassObserver.java |  261 ++
 .../IademGreenwaldKhannaQuantileSummary.java  |   38 +-
 .../IademNominalAttributeBinaryTest.java      |   27 +-
 .../IademNominalAttributeMultiwayTest.java    |   30 +-
 .../IademNumericAttributeBinaryTest.java      |   24 +-
 .../iadem/IademNumericAttributeObserver.java  |   60 +
 .../trees/iadem/IademSplitCriterion.java      |  359 ++
 ...ademVFMLNumericAttributeClassObserver.java |  632 +++
 .../java/moa/options/AbstractClassOption.java |  388 +-
 .../moa/options/AbstractOptionHandler.java    |  284 +-
 .../main/java/moa/options/ClassOption.java    |  247 +-
 .../ClassOptionWithListenerOption.java        |   61 +-
 .../moa/options/ClassOptionWithNames.java     |  262 +-
 .../moa/options/DependentOptionsUpdater.java  |  142 +-
 .../options/EditableMultiChoiceOption.java    |   70 +-
 .../main/java/moa/options/OptionHandler.java  |   80 +-
 .../main/java/moa/options/OptionsHandler.java |  291 +-
 .../RequiredOptionNotSpecifiedException.java  |    1 -
 .../java/moa/options/WEKAClassOption.java     |   70 +-
 .../recommender/data/MemRecommenderData.java  |   40 +-
 .../moa/recommender/data/RecommenderData.java |    8 +-
 .../java/moa/recommender/dataset/Dataset.java |   18 +-
 .../dataset/impl/FlixsterDataset.java         |  173 +-
 .../dataset/impl/JesterDataset.java           |  172 +-
 .../dataset/impl/MovielensDataset.java        |  166 +-
 .../predictor/BRISMFPredictor.java            |  161 +-
 .../predictor/BaselinePredictor.java          |   78 +-
 .../predictor/RatingPredictor.java            |   25 +-
 .../rc/data/AbstractRecommenderData.java      |  179 +-
 .../recommender/rc/data/RecommenderData.java  |   90 +-
 .../rc/data/impl/MemRecommenderData.java      |  641 ++-
 .../rc/predictor/RatingPredictor.java         |   15 +-
 .../rc/predictor/impl/BRISMFPredictor.java    |  793 ++--
 .../rc/predictor/impl/BaselinePredictor.java  |   71 +-
 .../moa/recommender/rc/utils/DenseVector.java |  149 +-
 .../java/moa/recommender/rc/utils/Hash.java   |   22 +-
 .../java/moa/recommender/rc/utils/Pair.java   |   68 +-
 .../java/moa/recommender/rc/utils/Rating.java |   22 +-
 .../recommender/rc/utils/SparseVector.java    |  141 +-
 .../moa/recommender/rc/utils/Updatable.java   |   21 +-
 .../java/moa/recommender/rc/utils/Vector.java |   85 +-
 .../main/java/moa/streams/ArffFileStream.java |  297 +-
 .../java/moa/streams/BootstrappedStream.java  |   77 +-
 .../moa/streams/CachedInstancesStream.java    |   25 +-
 .../moa/streams/ConceptDriftRealStream.java   |  338 +-
 .../java/moa/streams/ConceptDriftStream.java  |  220 +-
 .../main/java/moa/streams/ExampleStream.java  |   93 +-
 .../main/java/moa/streams/FilteredStream.java |  154 +-
 .../java/moa/streams/ImbalancedStream.java    |  257 +-
 .../main/java/moa/streams/InstanceStream.java |    8 +-
 .../IrrelevantFeatureAppenderStream.java      |  311 +-
 .../java/moa/streams/MultiFilteredStream.java |  163 +-
 .../moa/streams/MultiLabelFilteredStream.java |  154 +-
 .../streams/MultiTargetArffFileStream.java    |   13 +-
 .../streams/MultiTargetInstanceStream.java    |    9 +-
 .../java/moa/streams/PartitioningStream.java  |   88 +-
 .../streams/RecurrentConceptDriftStream.java  |  139 +-
 .../moa/streams/clustering/ClusterEvent.java  |   40 +-
 .../clustering/ClusterEventListener.java      |    7 +-
 .../streams/clustering/ClusteringStream.java  |   41 +-
 .../moa/streams/clustering/FileStream.java    |  238 +-
 .../clustering/RandomRBFGeneratorEvents.java  | 1777 ++++----
 .../streams/clustering/SimpleCSVStream.java   |   82 +-
 .../AbstractMultiLabelStreamFilter.java       |   75 +-
 .../streams/filters/AbstractStreamFilter.java |   97 +-
 .../moa/streams/filters/AddNoiseFilter.java   |  132 +-
 .../filters/MultiLabelStreamFilter.java       |   12 +-
 .../java/moa/streams/filters/RBFFilter.java   |   58 +-
 .../java/moa/streams/filters/ReLUFilter.java  |   50 +-
 .../RemoveDiscreteAttributeFilter.java        |  128 +-
 .../filters/ReplacingMissingValuesFilter.java |  212 +-
 .../filters/SelectAttributesFilter.java       |   59 +-
 .../moa/streams/filters/StreamFilter.java     |   22 +-
 .../streams/generators/AgrawalGenerator.java  |  739 ++--
 .../generators/AssetNegotiationGenerator.java |  682 ++-
 .../generators/HyperplaneGenerator.java       |  299 +-
 .../moa/streams/generators/LEDGenerator.java  |  243 +-
 .../streams/generators/LEDGeneratorDrift.java |  130 +-
 .../streams/generators/MixedGenerator.java    |  293 +-
 .../generators/RandomRBFGenerator.java        |  303 +-
 .../generators/RandomRBFGeneratorDrift.java   |  142 +-
 .../generators/RandomTreeGenerator.java       |  436 +-
 .../moa/streams/generators/SEAGenerator.java  |  356 +-
 .../streams/generators/STAGGERGenerator.java  |  345 +-
 .../moa/streams/generators/SineGenerator.java |  335 +-
 .../moa/streams/generators/TextGenerator.java |  331 +-
 .../streams/generators/WaveformGenerator.java |  258 +-
 .../generators/WaveformGeneratorDrift.java    |  158 +-
 .../generators/cd/AbruptChangeGenerator.java  |   18 +-
 .../cd/AbstractConceptDriftGenerator.java     |  250 +-
 .../generators/cd/ConceptDriftGenerator.java  |    2 +-
 .../generators/cd/GradualChangeGenerator.java |   26 +-
 .../generators/cd/NoChangeGenerator.java      |   12 +-
 .../multilabel/MetaMultilabelGenerator.java   | 1039 ++---
 .../multilabel/MultilabelArffFileStream.java  |   41 +-
 ...tractEvaluateInterleavedTestThenTrain.java |  332 +-
 .../java/moa/tasks/AbstractEvaluateModel.java |  231 +-
 .../tasks/AbstractEvaluatePrequential.java    |  151 +-
 .../tasks/AbstractEvaluatePrequentialCV.java  |  147 +-
 .../java/moa/tasks/AbstractLearnModel.java    |  161 +-
 moa/src/main/java/moa/tasks/AbstractTask.java |   89 +-
 .../java/moa/tasks/CacheShuffledStream.java   |   88 +-
 .../main/java/moa/tasks/FailedTaskReport.java |   40 +-
 moa/src/main/java/moa/tasks/MainTask.java     |  112 +-
 .../java/moa/tasks/MainTaskInterface.java     |   10 +-
 moa/src/main/java/moa/tasks/NullMonitor.java  |  143 +-
 moa/src/main/java/moa/tasks/Plot.java         |  916 ++--
 .../java/moa/tasks/ResultPreviewListener.java |   21 +-
 .../main/java/moa/tasks/RunStreamTasks.java   |   77 +-
 moa/src/main/java/moa/tasks/RunTasks.java     |   90 +-
 .../java/moa/tasks/StandardTaskMonitor.java   |  231 +-
 moa/src/main/java/moa/tasks/Task.java         |   54 +-
 .../moa/tasks/TaskCompletionListener.java     |   22 +-
 moa/src/main/java/moa/tasks/TaskMonitor.java  |  223 +-
 moa/src/main/java/moa/tasks/TaskThread.java   |  326 +-
 .../moa/tasks/auxiliar/AuxiliarMainTask.java  |   20 +-
 .../auxiliar/EvaluateOnlineRecommender.java   |  187 +-
 .../tasks/auxiliar/MeasureStreamSpeed.java    |   65 +-
 .../auxiliar/WriteMultipleStreamsToARFF.java  |  116 +-
 .../tasks/auxiliar/WriteStreamToARFFFile.java |   90 +-
 .../EvaluateInterleavedChunks.java            |  201 +-
 .../EvaluateInterleavedTestThenTrain.java     |   38 +-
 .../EvaluatePeriodicHeldOutTest.java          |  447 +-
 .../classification/EvaluatePrequential.java   |   21 +-
 .../classification/EvaluatePrequentialCV.java |   19 +-
 .../EvaluatePrequentialDelayed.java           |  543 ++-
 .../EvaluatePrequentialDelayedCV.java         |  503 ++-
 .../moa/tasks/classification/LearnModel.java  |   31 +-
 .../tasks/clustering/EvaluateClustering.java  |  196 +-
 .../EvaluateMultipleClusterings.java          |  325 +-
 .../conceptdrift/ConceptDriftMainTask.java    |   22 +-
 .../conceptdrift/EvaluateConceptDrift.java    |  369 +-
 .../main/java/moa/tasks/meta/ALMainTask.java  |   17 +-
 .../java/moa/tasks/meta/ALMultiParamTask.java |  314 +-
 .../tasks/meta/ALPartitionEvaluationTask.java |  162 +-
 .../meta/ALPrequentialEvaluationTask.java     |  354 +-
 .../java/moa/tasks/meta/ALTaskThread.java     |  127 +-
 .../java/moa/tasks/meta/MetaMainTask.java     |  101 +-
 .../moa/tasks/regression/EvaluateModel.java   |   32 +-
 .../tasks/regression/EvaluatePrequential.java |   31 +-
 .../regression/EvaluatePrequentialCV.java     |   21 +-
 .../java/moa/tasks/regression/LearnModel.java |   37 +-
 .../tasks/regression/RegressionMainTask.java  |    1 -
 .../EvaluateModel.java                        |  224 +-
 .../EvaluatePrequential.java                  |   43 +-
 .../multilabelclassification/LearnModel.java  |   28 +-
 .../multitargetregression/EvaluateModel.java  |   23 +-
 .../EvaluatePrequential.java                  |   37 +-
 ...aluatePrequentialMultiTargetSemiSuper.java |  401 --
 .../EvaluatePrequentialSemiSupervised.java    |  382 ++
 .../multitargetregression/LearnModel.java     |   29 +-
 .../main/java/weka/classifiers/meta/MOA.java  |  139 +-
 moa/src/main/java/weka/core/MOAUtils.java     |  144 +-
 .../classifiers/classification/MOA.java       |  607 +--
 .../java/weka/gui/MOAClassOptionEditor.java   |   56 +-
 .../gui/clustertab/ClusteringSetupTab.form    |    6 +-
 .../gui/clustertab/ClusteringTabPanel.form    |    4 +-
 .../gui/clustertab/ClusteringVisualTab.form   |    8 +-
 .../ArffLoaderAttributeSelectionTest.java     |   15 +-
 .../ArffLoaderClassificationTest.java         |    3 +-
 ...rffLoaderMultiLabelClassificationTest.java |    5 +-
 .../ArffLoaderMultiTargetRegressionTest.java  |   15 +-
 .../instances/ArffLoaderRegressionTest.java   |   15 +-
 .../AbstractClassifierTestCase.java           |  149 -
 .../AbstractMultiTargetRegressorTestCase.java |  148 -
 .../AbstractRegressorTestCase.java            |  148 -
 .../moa/classifiers/active/ALRandomTest.java  |   74 -
 .../classifiers/active/ALUncertaintyTest.java |   85 -
 .../bayes/NaiveBayesMultinomialTest.java      |   75 -
 .../moa/classifiers/bayes/NaiveBayesTest.java |   75 -
 .../DriftDetectionMethodClassifierTest.java   |   75 -
 .../drift/SingleClassifierDriftTest.java      |   76 -
 .../functions/MajorityClassTest.java          |   75 -
 .../classifiers/functions/NoChangeTest.java   |   76 -
 .../classifiers/functions/PerceptronTest.java |   75 -
 .../moa/classifiers/functions/SGDTest.java    |   75 -
 .../classifiers/functions/SPegasosTest.java   |   75 -
 .../java/moa/classifiers/meta/ADOBTest.java   |   74 -
 .../meta/AccuracyUpdatedEnsembleTest.java     |   75 -
 .../meta/AccuracyWeightedEnsembleTest.java    |   76 -
 .../meta/AdaptiveRandomForestTest.java        |   76 -
 .../java/moa/classifiers/meta/BOLETest.java   |   74 -
 .../meta/DynamicWeightedMajorityTest.java     |   73 -
 .../classifiers/meta/LeveragingBagTest.java   |   76 -
 .../meta/LimAttClassifierTest.java            |   75 -
 .../moa/classifiers/meta/OCBoostTest.java     |   75 -
 .../OnlineAccuracyUpdatedEnsembleTest.java    |   76 -
 .../moa/classifiers/meta/OzaBagASHTTest.java  |   79 -
 .../meta/OzaBagAdwinClassificationTest.java   |   75 -
 .../meta/OzaBagClassificationTest.java        |   75 -
 .../classifiers/meta/OzaBoostAdwinTest.java   |   75 -
 .../meta/OzaBoostClassificationTest.java      |   74 -
 .../TemporallyAugmentedClassifierTest.java    |   75 -
 .../classifiers/meta/WEKAClassifierTest.java  |   76 -
 .../meta/WeightedMajorityAlgorithmTest.java   |   75 -
 .../rules/RuleClassifierNBayesTest.java       |   75 -
 .../classifiers/rules/RuleClassifierTest.java |   75 -
 .../moa/classifiers/rules/core/UtilsTest.java |   58 -
 ...ulesMultiTargetRegressorSemiSuperTest.java |   75 -
 .../voting/FirstHitVoteMultiLabelTest.java    |  112 -
 ...nverseErrorWeightedVoteMultiLabelTest.java |   99 -
 .../UniformWeightedVoteMultiLabelTest.java    |  105 -
 .../RelativeMeanAbsoluteDeviationMTTest.java  |   80 -
 .../RelativeRootMeanSquaredErrorMTTest.java   |   76 -
 .../InstanceOutputAttributesSelectorTest.java |   71 -
 .../trees/ASHoeffdingTreeTest.java            |   76 -
 .../trees/AdaHoeffdingOptionTreeTest.java     |   75 -
 .../classifiers/trees/DecisionStumpTest.java  |   75 -
 .../java/moa/classifiers/trees/EFDTTest.java  |   80 -
 .../moa/classifiers/trees/FIMTDDTest.java     |   75 -
 .../trees/HoeffdingAdaptiveTreeTest.java      |   76 -
 .../trees/HoeffdingOptionTreeTest.java        |   76 -
 .../classifiers/trees/HoeffdingTreeTest.java  |   80 -
 .../trees/LimAttHoeffdingTreeTest.java        |   78 -
 .../java/moa/classifiers/trees/ORTOTest.java  |   76 -
 .../trees/RandomHoeffdingTreeTest.java        |   76 -
 .../moa/integration/SimpleClusterTest.java    |  271 +-
 .../AbstractClassifierTestCase.java           |  149 +
 .../AbstractInstanceLearnerTestCase.java      |  176 +-
 .../AbstractMultiTargetRegressorTestCase.java |  150 +
 .../predictors/AbstractRegressorTestCase.java |  149 +
 .../predictors/active/ALRandomTest.java       |   72 +
 .../predictors/active/ALUncertaintyTest.java  |   83 +
 .../bayes/NaiveBayesMultinomialTest.java      |   73 +
 .../predictors/bayes/NaiveBayesTest.java      |   73 +
 .../DriftDetectionMethodClassifierTest.java   |   73 +
 .../functions/MajorityClassTest.java          |   73 +
 .../predictors/functions/NoChangeTest.java    |   73 +
 .../predictors/functions/PerceptronTest.java  |   73 +
 .../predictors/functions/SGDTest.java         |   73 +
 .../predictors/functions/SPegasosTest.java    |   73 +
 .../learners/predictors/meta/ADOBTest.java    |   72 +
 .../meta/AccuracyUpdatedEnsembleTest.java     |   73 +
 .../meta/AccuracyWeightedEnsembleTest.java    |   73 +
 .../meta/AdaptiveRandomForestTest.java        |   74 +
 .../learners/predictors/meta/BOLETest.java    |   72 +
 .../meta/DynamicWeightedMajorityTest.java     |   72 +
 .../meta/HeterogeneousEnsembleBlastTest.java  |   29 +-
 .../predictors/meta/LeveragingBagTest.java    |   73 +
 .../predictors/meta/LimAttClassifierTest.java |   73 +
 .../learners/predictors/meta/OCBoostTest.java |   73 +
 .../OnlineAccuracyUpdatedEnsembleTest.java    |   73 +
 .../predictors/meta/OzaBagASHTTest.java       |   77 +
 .../predictors/meta/OzaBoostAdwinTest.java    |   73 +
 .../TemporallyAugmentedClassifierTest.java    |   73 +
 .../predictors/meta/WEKAClassifierTest.java   |   73 +
 .../meta/WeightedMajorityAlgorithmTest.java   |   73 +
 .../meta/classifiers/OzaBagAdwinTest.java     |   73 +
 .../meta/classifiers/OzaBagTest.java          |   73 +
 .../meta/classifiers/OzaBoostTest.java        |   73 +
 ...ulesMultiTargetRegressorSemiSuperTest.java |   71 +
 .../rules/AMRulesRegressorTest.java           |   29 +-
 .../rules/RuleClassifierNBayesTest.java       |   73 +
 .../predictors/rules/RuleClassifierTest.java  |   73 +
 .../predictors/rules/core/UtilsTest.java      |   61 +
 .../voting/FirstHitVoteMultiLabelTest.java    |  114 +
 ...nverseErrorWeightedVoteMultiLabelTest.java |  101 +
 .../UniformWeightedVoteMultiLabelTest.java    |  104 +
 .../RelativeMeanAbsoluteDeviationMTTest.java  |   81 +
 .../RelativeRootMeanSquaredErrorMTTest.java   |   80 +
 .../InstanceOutputAttributesSelectorTest.java |   74 +
 .../predictors/trees/ASHoeffdingTreeTest.java |   73 +
 .../trees/AdaHoeffdingOptionTreeTest.java     |   73 +
 .../predictors/trees/DecisionStumpTest.java   |   73 +
 .../learners/predictors/trees/EFDTTest.java   |   79 +
 .../learners/predictors/trees/FIMTDDTest.java |   73 +
 .../trees/HoeffdingAdaptiveTreeTest.java      |   73 +
 .../trees/HoeffdingOptionTreeTest.java        |   73 +
 .../predictors/trees/HoeffdingTreeTest.java   |   79 +
 .../trees/LimAttHoeffdingTreeTest.java        |   77 +
 .../learners/predictors/trees/ORTOTest.java   |   73 +
 .../trees/RandomHoeffdingTreeTest.java        |   73 +
 .../filters/SelectAttributesFilterTest.java   |   44 +-
 .../java/moa/test/AbstractTestHelper.java     |  404 +-
 moa/src/test/java/moa/test/DiffUtils.java     | 1308 +++---
 moa/src/test/java/moa/test/FileUtils.java     |  476 ++-
 moa/src/test/java/moa/test/MoaTestCase.java   |  551 ++-
 moa/src/test/java/moa/test/Regression.java    |  488 +--
 .../test/java/moa/test/SerializedObject.java  |  383 +-
 moa/src/test/java/moa/test/TestHelper.java    |   67 +-
 moa/src/test/java/moa/test/TmpFile.java       |   51 +-
 moa/src/test/java/moa/test/Utils.java         |  194 +-
 .../drift/SingleClassifierDrift.ref           |  175 -
 .../moa/classifiers/functions/Perceptron.ref  |  145 -
 .../moa/classifiers/meta/OzaBagAdwin.ref      |  315 --
 .../classifiers/meta/OzaBagClassification.ref |  315 --
 .../meta/OzaBoostClassification.ref           |  315 --
 .../classifiers/rules/AMRulesRegressor.ref    |  185 -
 .../AMRulesMultiTargetRegressorSemiSuper.ref  |  185 -
 .../predictors}/active/ALRandom.ref           |    2 +-
 .../predictors}/active/ALUncertainty.ref      |    8 +-
 .../predictors}/bayes/NaiveBayes.ref          |    2 +-
 .../bayes/NaiveBayesMultinomial.ref           |    2 +-
 .../predictors}/data/classification.arff      |    0
 .../predictors}/data/regression.arff          |    0
 .../data/small_classification.arff            |    0
 .../predictors}/data/small_regression.arff    |    0
 .../drift/DriftDetectionMethodClassifier.ref  |    2 +-
 .../predictors}/functions/MajorityClass.ref   |    2 +-
 .../predictors}/functions/NoChange.ref        |    2 +-
 .../predictors/functions/Perceptron.ref       |  145 +
 .../predictors}/functions/SGD.ref             |    2 +-
 .../predictors}/functions/SPegasos.ref        |    2 +-
 .../predictors}/meta/ADOB.ref                 |    2 +-
 .../meta/AccuracyUpdatedEnsemble.ref          |    2 +-
 .../meta/AccuracyWeightedEnsemble.ref         |    2 +-
 .../predictors}/meta/AdaptiveRandomForest.ref |    2 +-
 .../predictors}/meta/BOLE.ref                 |    2 +-
 .../meta/DynamicWeightedMajority.ref          |    2 +-
 .../meta/HeterogeneousEnsembleBlast.ref       |    4 +-
 .../predictors}/meta/LeveragingBag.ref        |    2 +-
 .../predictors}/meta/LimAttClassifier.ref     |    2 +-
 .../predictors}/meta/OCBoost.ref              |   80 +-
 .../meta/OnlineAccuracyUpdatedEnsemble.ref    |    2 +-
 .../predictors}/meta/OzaBagASHT.ref           |    2 +-
 .../predictors}/meta/OzaBoostAdwin.ref        |    2 +-
 .../meta/TemporallyAugmentedClassifier.ref    |    2 +-
 .../predictors}/meta/WEKAClassifier.ref       |    2 +-
 .../meta/WeightedMajorityAlgorithm.ref        |    2 +-
 .../predictors/meta/classifiers}/OzaBag.ref   |  122 +-
 .../meta/classifiers/OzaBagAdwin.ref}         |    2 +-
 .../predictors/meta/classifiers}/OzaBoost.ref |    2 +-
 .../AMRulesMultiTargetRegressorSemiSuper.ref  |  185 +
 .../predictors/rules/AMRulesRegressor.ref     |  195 +
 .../predictors}/rules/RuleClassifier.ref      |    2 +-
 .../rules/RuleClassifierNBayes.ref            |    2 +-
 .../predictors}/trees/ASHoeffdingTree.ref     |    2 +-
 .../trees/AdaHoeffdingOptionTree.ref          |    2 +-
 .../predictors}/trees/DecisionStump.ref       |    2 +-
 .../predictors}/trees/EFDT.ref                |    4 +-
 .../predictors}/trees/FIMTDD.ref              |    2 +-
 .../trees/HoeffdingAdaptiveTree.ref           |    2 +-
 .../predictors}/trees/HoeffdingOptionTree.ref |    2 +-
 .../predictors}/trees/HoeffdingTree.ref       |    4 +-
 .../predictors}/trees/LimAttHoeffdingTree.ref |    2 +-
 .../predictors}/trees/ORTO.ref                |    2 +-
 .../predictors}/trees/RandomHoeffdingTree.ref |    2 +-
 1206 files changed, 120425 insertions(+), 124939 deletions(-)
 delete mode 100644 moa/src/main/java/com/yahoo/labs/samoa/instances/StructuredInstance.java
 delete mode 100644 moa/src/main/java/moa/classifiers/AbstractClassifier.java
 delete mode 100644 moa/src/main/java/moa/classifiers/AbstractEnsembleLearner.java
 delete mode 100644 moa/src/main/java/moa/classifiers/AbstractInstanceLearner.java
 delete mode 100644 moa/src/main/java/moa/classifiers/MultiTargetLearnerSemiSupervised.java
 delete mode 100644 moa/src/main/java/moa/classifiers/active/ALUncertainty.java
 delete mode 100644 moa/src/main/java/moa/classifiers/bayes/NaiveBayes.java
 delete mode 100644 moa/src/main/java/moa/classifiers/bayes/NaiveBayesMultinomial.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/AttributeSplitSuggestion.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/attributeclassobservers/AttributeClassObserver.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserver.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserverRegression.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/attributeclassobservers/FIMTDDNumericAttributeClassObserver.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/attributeclassobservers/GaussianNumericAttributeClassObserver.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/attributeclassobservers/GreenwaldKhannaNumericAttributeClassObserver.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/attributeclassobservers/NominalAttributeClassObserver.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/attributeclassobservers/NullAttributeClassObserver.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/attributeclassobservers/VFMLNumericAttributeClassObserver.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/conditionaltests/InstanceConditionalTest.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeBinaryTest.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/driftdetection/ADWIN.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/driftdetection/AbstractChangeDetector.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/driftdetection/ChangeDetector.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/driftdetection/CusumDM.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/driftdetection/DDM.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/driftdetection/EDDM.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/driftdetection/EWMAChartDM.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/driftdetection/EnsembleDriftDetectionMethods.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/driftdetection/GeometricMovingAverageDM.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/driftdetection/HDDM_A_Test.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/driftdetection/HDDM_W_Test.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/driftdetection/PageHinkleyDM.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/driftdetection/RDDM.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/driftdetection/SEEDChangeDetector.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/driftdetection/STEPD.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/driftdetection/SeqDrift1ChangeDetector.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/driftdetection/SeqDrift2ChangeDetector.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/splitcriteria/GiniSplitCriterion.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/splitcriteria/InfoGainSplitCriterion.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/splitcriteria/VarianceReductionSplitCriterion.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/statisticaltests/Cramer.java
 delete mode 100644 moa/src/main/java/moa/classifiers/core/statisticaltests/KNN.java
 delete mode 100644 moa/src/main/java/moa/classifiers/drift/DriftDetectionMethodClassifier.java
 delete mode 100644 moa/src/main/java/moa/classifiers/functions/AdaGrad.java
 delete mode 100644 moa/src/main/java/moa/classifiers/functions/MajorityClass.java
 delete mode 100644 moa/src/main/java/moa/classifiers/functions/Perceptron.java
 delete mode 100644 moa/src/main/java/moa/classifiers/functions/SGD.java
 delete mode 100644 moa/src/main/java/moa/classifiers/functions/SGDMultiClass.java
 delete mode 100644 moa/src/main/java/moa/classifiers/functions/SPegasos.java
 delete mode 100644 moa/src/main/java/moa/classifiers/lazy/kNN.java
 delete mode 100644 moa/src/main/java/moa/classifiers/lazy/kNNwithPAW.java
 delete mode 100644 moa/src/main/java/moa/classifiers/lazy/kNNwithPAWandADWIN.java
 delete mode 100644 moa/src/main/java/moa/classifiers/lazy/neighboursearch/DistanceFunction.java
 delete mode 100644 moa/src/main/java/moa/classifiers/lazy/neighboursearch/EuclideanDistance.java
 delete mode 100644 moa/src/main/java/moa/classifiers/lazy/neighboursearch/KDTree.java
 delete mode 100644 moa/src/main/java/moa/classifiers/lazy/neighboursearch/LinearNNSearch.java
 delete mode 100644 moa/src/main/java/moa/classifiers/lazy/neighboursearch/NearestNeighbourSearch.java
 delete mode 100644 moa/src/main/java/moa/classifiers/lazy/neighboursearch/NormalizableDistance.java
 delete mode 100644 moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KDTreeNode.java
 delete mode 100644 moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KDTreeNodeSplitter.java
 delete mode 100644 moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KMeansInpiredMethod.java
 delete mode 100644 moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/MedianOfWidestDimension.java
 delete mode 100644 moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/MidPointOfWidestDimension.java
 delete mode 100644 moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/SlidingMidPointOfWidestSide.java
 delete mode 100644 moa/src/main/java/moa/classifiers/meta/ADACC.java
 delete mode 100644 moa/src/main/java/moa/classifiers/meta/ADOB.java
 delete mode 100644 moa/src/main/java/moa/classifiers/meta/AbstractOzaBagAdwin.java
 delete mode 100644 moa/src/main/java/moa/classifiers/meta/AbstractOzaBoost.java
 delete mode 100644 moa/src/main/java/moa/classifiers/meta/AccuracyWeightedEnsemble.java
 delete mode 100644 moa/src/main/java/moa/classifiers/meta/AdaptiveRandomForest.java
 delete mode 100644 moa/src/main/java/moa/classifiers/meta/AdaptiveRandomForestRegressor.java
 delete mode 100644 moa/src/main/java/moa/classifiers/meta/BOLE.java
 delete mode 100644 moa/src/main/java/moa/classifiers/meta/DACC.java
 delete mode 100644 moa/src/main/java/moa/classifiers/meta/DynamicWeightedMajority.java
 delete mode 100644 moa/src/main/java/moa/classifiers/meta/LearnNSE.java
 delete mode 100644 moa/src/main/java/moa/classifiers/meta/LeveragingBag.java
 delete mode 100644 moa/src/main/java/moa/classifiers/meta/LimAttClassifier.java
 delete mode 100644 moa/src/main/java/moa/classifiers/meta/OCBoost.java
 delete mode 100644 moa/src/main/java/moa/classifiers/meta/OnlineSmoothBoost.java
 delete mode 100644 moa/src/main/java/moa/classifiers/meta/OzaBagASHT.java
 delete mode 100644 moa/src/main/java/moa/classifiers/meta/OzaBoostAdwin.java
 delete mode 100644 moa/src/main/java/moa/classifiers/meta/PairedLearners.java
 delete mode 100644 moa/src/main/java/moa/classifiers/meta/RCD.java
 delete mode 100644 moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java
 delete mode 100644 moa/src/main/java/moa/classifiers/meta/WEKAClassifier.java
 delete mode 100644 moa/src/main/java/moa/classifiers/meta/WeightedMajorityAlgorithm.java
 delete mode 100644 moa/src/main/java/moa/classifiers/mlc/MEKAClassifier.java
 delete mode 100644 moa/src/main/java/moa/classifiers/mlc/MajorityLabelset.java
 delete mode 100644 moa/src/main/java/moa/classifiers/mlc/MultilabelHoeffdingTree.java
 delete mode 100644 moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/AttributeStatisticsObserver.java
 delete mode 100644 moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/MultiLabelNominalAttributeObserver.java
 delete mode 100644 moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/ICVarianceReduction.java
 delete mode 100644 moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/MultiLabelSplitCriterion.java
 delete mode 100644 moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/PCTWeightedICVarianceReduction.java
 delete mode 100644 moa/src/main/java/moa/classifiers/mlc/meta/AdaptiveRandomForestMultiTargetRegression.java
 delete mode 100644 moa/src/main/java/moa/classifiers/mtr/BasicMultiTargetRegressor.java
 delete mode 100644 moa/src/main/java/moa/classifiers/mtr/functions/MultiTargetNoChange.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/AbstractAMRules.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/RuleClassification.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/RuleClassifier.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/RuleClassifierNBayes.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/core/RuleActiveLearningNode.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/core/Utils.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalinessRatioScore.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/core/anomalydetection/OddsRatioScore.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/core/attributeclassobservers/FIMTDDNumericAttributeClassLimitObserver.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/core/changedetection/NoChangeDetection.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/core/splitcriteria/AMRulesSplitCriterion.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/core/splitcriteria/SDRSplitCriterionAMRulesNode.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/core/splitcriteria/VRSplitCriterion.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/core/splitcriteria/VarianceRatioSplitCriterion.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/driftdetection/PageHinkleyTest.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/featureranking/MeritFeatureRanking.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/featureranking/WeightedMajorityFeatureRanking.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/functions/AMRulesRegressorFunction.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/meta/RandomAMRulesOld.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelClassifier.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearnerSemiSuper.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressor.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressorSemiSuper.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/MultiLabelBSTreeFloat.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/SingleVector.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralClassification.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/multilabel/core/splitcriteria/MultiTargetVarianceRatio.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/multilabel/core/splitcriteria/MultilabelInformationGain.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/MultiLabelVote.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/RelativeMeanAbsoluteDeviationMT.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/RelativeRootMeanSquaredErrorMT.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/multilabel/functions/AdaptiveMultiTargetRegressor.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/multilabel/functions/MultiLabelPerceptronClassification.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/multilabel/functions/StackedPredictor.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/multilabel/inputselectors/MeritThreshold.java
 delete mode 100644 moa/src/main/java/moa/classifiers/rules/multilabel/meta/MultiLabelRandomAMRules.java
 delete mode 100644 moa/src/main/java/moa/classifiers/trees/ARFFIMTDD.java
 delete mode 100644 moa/src/main/java/moa/classifiers/trees/ARFHoeffdingTree.java
 delete mode 100644 moa/src/main/java/moa/classifiers/trees/ASHoeffdingTree.java
 delete mode 100644 moa/src/main/java/moa/classifiers/trees/AdaHoeffdingOptionTree.java
 delete mode 100644 moa/src/main/java/moa/classifiers/trees/DecisionStump.java
 delete mode 100644 moa/src/main/java/moa/classifiers/trees/EFDT.java
 delete mode 100644 moa/src/main/java/moa/classifiers/trees/HoeffdingAdaptiveTree.java
 delete mode 100644 moa/src/main/java/moa/classifiers/trees/HoeffdingAdaptiveTreeClassifLeaves.java
 delete mode 100644 moa/src/main/java/moa/classifiers/trees/HoeffdingOptionTree.java
 delete mode 100644 moa/src/main/java/moa/classifiers/trees/HoeffdingTree.java
 delete mode 100644 moa/src/main/java/moa/classifiers/trees/HoeffdingTreeClassifLeaves.java
 delete mode 100644 moa/src/main/java/moa/classifiers/trees/LimAttHoeffdingTree.java
 delete mode 100644 moa/src/main/java/moa/classifiers/trees/RandomHoeffdingTree.java
 delete mode 100644 moa/src/main/java/moa/classifiers/trees/iadem/Iadem2.java
 delete mode 100644 moa/src/main/java/moa/classifiers/trees/iadem/Iadem3.java
 delete mode 100644 moa/src/main/java/moa/classifiers/trees/iadem/Iadem3Subtree.java
 delete mode 100644 moa/src/main/java/moa/classifiers/trees/iadem/IademCommonProcedures.java
 delete mode 100644 moa/src/main/java/moa/classifiers/trees/iadem/IademGaussianNumericAttributeClassObserver.java
 delete mode 100644 moa/src/main/java/moa/classifiers/trees/iadem/IademGreenwaldKhannaNumericAttributeClassObserver.java
 delete mode 100644 moa/src/main/java/moa/classifiers/trees/iadem/IademNumericAttributeObserver.java
 delete mode 100644 moa/src/main/java/moa/classifiers/trees/iadem/IademSplitCriterion.java
 delete mode 100644 moa/src/main/java/moa/classifiers/trees/iadem/IademVFMLNumericAttributeClassObserver.java
 delete mode 100644 moa/src/main/java/moa/clusterers/ClusterGenerator.java
 delete mode 100644 moa/src/main/java/moa/clusterers/CobWeb.java
 delete mode 100644 moa/src/main/java/moa/clusterers/KMeans.java
 delete mode 100644 moa/src/main/java/moa/clusterers/WekaClusteringAlgorithm.java
 delete mode 100644 moa/src/main/java/moa/clusterers/clustream/ClustreamKernel.java
 delete mode 100644 moa/src/main/java/moa/clusterers/clustree/ClusKernel.java
 delete mode 100644 moa/src/main/java/moa/clusterers/clustree/ClusTree.java
 delete mode 100644 moa/src/main/java/moa/clusterers/clustree/Entry.java
 delete mode 100644 moa/src/main/java/moa/clusterers/clustree/Node.java
 delete mode 100644 moa/src/main/java/moa/clusterers/clustree/util/Budget.java
 delete mode 100644 moa/src/main/java/moa/clusterers/clustree/util/SimpleBudget.java
 delete mode 100644 moa/src/main/java/moa/clusterers/denstream/MicroCluster.java
 delete mode 100644 moa/src/main/java/moa/clusterers/macro/ColorArray.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/AbstractC/AbstractC.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/AbstractC/AbstractCBase.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/AbstractC/ISBIndex.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/AbstractC/MyMTree.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/AbstractC/StreamObj.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/AbstractC/Test.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/Angiulli/ApproxSTORM.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/Angiulli/ExactSTORM.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/Angiulli/ISBIndex.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/Angiulli/MyMTree.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/Angiulli/STORMBase.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/Angiulli/StreamObj.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/Angiulli/Test.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/AnyOut/util/DataObject.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/AnyOut/util/DataSet.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/MCOD/ISBIndex.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/MCOD/MCOD.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/MCOD/MCODBase.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/MCOD/MTreeMicroClusters.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/MCOD/MTreeStreamObjects.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/MCOD/MicroCluster.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/MCOD/StreamObj.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/MCOD/Test.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/MyBaseOutlierDetector.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/SimpleCOD/ISBIndex.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/SimpleCOD/MyMTree.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/SimpleCOD/SimpleCOD.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/SimpleCOD/SimpleCODBase.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/SimpleCOD/StreamObj.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/SimpleCOD/Test.java
 delete mode 100644 moa/src/main/java/moa/clusterers/outliers/TestSpeed.java
 delete mode 100644 moa/src/main/java/moa/clusterers/streamkm/BucketManager.java
 delete mode 100644 moa/src/main/java/moa/clusterers/streamkm/MTRandom.java
 delete mode 100644 moa/src/main/java/moa/clusterers/streamkm/StreamKM.java
 delete mode 100644 moa/src/main/java/moa/clusterers/streamkm/TreeCoreset.java
 delete mode 100644 moa/src/main/java/moa/evaluation/BasicClassificationPerformanceEvaluator.java
 delete mode 100644 moa/src/main/java/moa/evaluation/BasicConceptDriftPerformanceEvaluator.java
 delete mode 100644 moa/src/main/java/moa/evaluation/BasicMultiLabelPerformanceEvaluator.java
 delete mode 100644 moa/src/main/java/moa/evaluation/BasicMultiTargetPerformanceEvaluator.java
 delete mode 100644 moa/src/main/java/moa/evaluation/BasicRegressionPerformanceEvaluator.java
 delete mode 100644 moa/src/main/java/moa/evaluation/MultiLabelWindowClassificationPerformanceEvaluator.java
 delete mode 100644 moa/src/main/java/moa/evaluation/WindowClassificationPerformanceEvaluator.java
 delete mode 100644 moa/src/main/java/moa/evaluation/WindowMultiTargetRegressionPerformanceEvaluator.java
 delete mode 100644 moa/src/main/java/moa/evaluation/WindowMultiTargetRegressionPerformanceRelativeMeasuresEvaluator.java
 delete mode 100644 moa/src/main/java/moa/evaluation/WindowRegressionPerformanceEvaluator.java
 rename moa/src/main/java/moa/evaluation/{ => evaluators}/ALClassificationPerformanceEvaluator.java (74%)
 rename moa/src/main/java/moa/evaluation/{ => evaluators}/ALWindowClassificationPerformanceEvaluator.java (62%)
 rename moa/src/main/java/moa/evaluation/{ => evaluators}/AdwinClassificationPerformanceEvaluator.java (63%)
 rename moa/src/main/java/moa/evaluation/{ => evaluators}/BasicAUCImbalancedPerformanceEvaluator.java (95%)
 create mode 100644 moa/src/main/java/moa/evaluation/evaluators/BasicClassificationPerformanceEvaluator.java
 create mode 100644 moa/src/main/java/moa/evaluation/evaluators/BasicConceptDriftPerformanceEvaluator.java
 create mode 100644 moa/src/main/java/moa/evaluation/evaluators/BasicMultiLabelPerformanceEvaluator.java
 create mode 100644 moa/src/main/java/moa/evaluation/evaluators/BasicMultiTargetPerformanceEvaluator.java
 rename moa/src/main/java/moa/evaluation/{ => evaluators}/BasicMultiTargetPerformanceRelativeMeasuresEvaluator.java (58%)
 create mode 100644 moa/src/main/java/moa/evaluation/evaluators/BasicRegressionPerformanceEvaluator.java
 rename moa/src/main/java/moa/evaluation/{ => evaluators}/ClassificationPerformanceEvaluator.java (96%)
 rename moa/src/main/java/moa/evaluation/{ => evaluators}/EWMAClassificationPerformanceEvaluator.java (57%)
 rename moa/src/main/java/moa/evaluation/{ => evaluators}/FadingFactorClassificationPerformanceEvaluator.java (50%)
 rename moa/src/main/java/moa/evaluation/{ => evaluators}/LearningPerformanceEvaluator.java (58%)
 rename moa/src/main/java/moa/evaluation/{ => evaluators}/MultiLabelClassificationPerformanceEvaluator.java (88%)
 create mode 100644 moa/src/main/java/moa/evaluation/evaluators/MultiLabelWindowClassificationPerformanceEvaluator.java
 rename moa/src/main/java/moa/evaluation/{ => evaluators}/MultiTargetRegressionPerformanceEvaluator.java (88%)
 rename moa/src/main/java/moa/evaluation/{ => evaluators}/RegressionPerformanceEvaluator.java (88%)
 rename moa/src/main/java/moa/evaluation/{ => evaluators}/WindowAUCImbalancedPerformanceEvaluator.java (66%)
 create mode 100644 moa/src/main/java/moa/evaluation/evaluators/WindowClassificationPerformanceEvaluator.java
 create mode 100644 moa/src/main/java/moa/evaluation/evaluators/WindowMultiTargetRegressionPerformanceEvaluator.java
 create mode 100644 moa/src/main/java/moa/evaluation/evaluators/WindowMultiTargetRegressionPerformanceRelativeMeasuresEvaluator.java
 create mode 100644 moa/src/main/java/moa/evaluation/evaluators/WindowRegressionPerformanceEvaluator.java
 delete mode 100644 moa/src/main/java/moa/learners/ChangeDetectorLearner.java
 delete mode 100644 moa/src/main/java/moa/learners/Classifier.java
 delete mode 100644 moa/src/main/java/moa/learners/MultiLabelClassifier.java
 delete mode 100644 moa/src/main/java/moa/learners/MultiTargetRegressor.java
 rename moa/src/main/java/moa/{ => learners}/clusterers/AbstractClusterer.java (79%)
 create mode 100644 moa/src/main/java/moa/learners/clusterers/ClusterGenerator.java
 rename moa/src/main/java/moa/{ => learners}/clusterers/Clusterer.java (63%)
 create mode 100644 moa/src/main/java/moa/learners/clusterers/CobWeb.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/KMeans.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/WekaClusteringAlgorithm.java
 rename moa/src/main/java/moa/{ => learners}/clusterers/clustream/Clustream.java (56%)
 create mode 100644 moa/src/main/java/moa/learners/clusterers/clustream/ClustreamKernel.java
 rename moa/src/main/java/moa/{ => learners}/clusterers/clustream/WithKmeans.java (72%)
 create mode 100644 moa/src/main/java/moa/learners/clusterers/clustree/ClusKernel.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/clustree/ClusTree.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/clustree/Entry.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/clustree/Node.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/clustree/util/Budget.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/clustree/util/SimpleBudget.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/denstream/MicroCluster.java
 rename moa/src/main/java/moa/{ => learners}/clusterers/denstream/Timestamp.java (56%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/denstream/WithDBSCAN.java (83%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/dstream/CharacteristicVector.java (63%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/dstream/DensityGrid.java (60%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/dstream/Dstream.java (54%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/dstream/GridCluster.java (60%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/kmeanspm/BICO.java (76%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/kmeanspm/ClusteringFeature.java (72%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/kmeanspm/ClusteringTreeHeadNode.java (70%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/kmeanspm/ClusteringTreeNode.java (85%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/kmeanspm/CoresetKMeans.java (85%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/kmeanspm/CuckooHashing.java (72%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/kmeanspm/DietzfelbingerHash.java (81%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/kmeanspm/Metric.java (70%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/macro/AbstractMacroClusterer.java (90%)
 create mode 100644 moa/src/main/java/moa/learners/clusterers/macro/ColorArray.java
 rename moa/src/main/java/moa/{ => learners}/clusterers/macro/ColorObject.java (95%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/macro/IDenseMacroCluster.java (87%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/macro/IMacroClusterer.java (88%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/macro/NonConvexCluster.java (91%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/macro/dbscan/DBScan.java (83%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/macro/dbscan/DenseMicroCluster.java (80%)
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/AbstractC/AbstractC.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/AbstractC/AbstractCBase.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/AbstractC/ISBIndex.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/AbstractC/MyMTree.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/AbstractC/StreamObj.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/AbstractC/Test.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/ApproxSTORM.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/ExactSTORM.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/ISBIndex.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/MyMTree.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/STORMBase.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/StreamObj.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/Test.java
 rename moa/src/main/java/moa/{ => learners}/clusterers/outliers/AnyOut/AnyOut.java (57%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/outliers/AnyOut/AnyOutCore.java (61%)
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/AnyOut/util/DataObject.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/AnyOut/util/DataSet.java
 rename moa/src/main/java/moa/{ => learners}/clusterers/outliers/AnyOut/util/EMProjectedClustering.java (83%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/outliers/AnyOut/util/EMTopDownTreeBuilder.java (81%)
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/MCOD/ISBIndex.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/MCOD/MCOD.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/MCOD/MCODBase.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/MCOD/MTreeMicroClusters.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/MCOD/MTreeStreamObjects.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/MCOD/MicroCluster.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/MCOD/StreamObj.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/MCOD/Test.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/MyBaseOutlierDetector.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/SimpleCOD/ISBIndex.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/SimpleCOD/MyMTree.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/SimpleCOD/SimpleCOD.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/SimpleCOD/SimpleCODBase.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/SimpleCOD/StreamObj.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/SimpleCOD/Test.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/outliers/TestSpeed.java
 rename moa/src/main/java/moa/{ => learners}/clusterers/outliers/utils/mtree/ComposedSplitFunction.java (81%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/outliers/utils/mtree/DistanceFunction.java (93%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/outliers/utils/mtree/DistanceFunctions.java (73%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/outliers/utils/mtree/MTree.java (72%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/outliers/utils/mtree/PartitionFunction.java (71%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/outliers/utils/mtree/PartitionFunctions.java (71%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/outliers/utils/mtree/PromotionFunction.java (82%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/outliers/utils/mtree/PromotionFunctions.java (73%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/outliers/utils/mtree/SplitFunction.java (76%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/outliers/utils/mtree/utils/Pair.java (85%)
 rename moa/src/main/java/moa/{ => learners}/clusterers/outliers/utils/mtree/utils/Utils.java (72%)
 create mode 100644 moa/src/main/java/moa/learners/clusterers/streamkm/BucketManager.java
 rename moa/src/main/java/moa/{ => learners}/clusterers/streamkm/CoresetCostTriple.java (80%)
 create mode 100644 moa/src/main/java/moa/learners/clusterers/streamkm/MTRandom.java
 rename moa/src/main/java/moa/{ => learners}/clusterers/streamkm/Point.java (54%)
 create mode 100644 moa/src/main/java/moa/learners/clusterers/streamkm/StreamKM.java
 create mode 100644 moa/src/main/java/moa/learners/clusterers/streamkm/TreeCoreset.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/AbstractClassifier.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/AbstractEnsembleLearner.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/AbstractInstanceLearner.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/AbstractMultiLabelClassifier.java (56%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/AbstractMultiTargetRegressor.java (56%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/AbstractRegressor.java (76%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/ChangeDetectorLearner.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/Classifier.java
 rename moa/src/main/java/moa/learners/{ => predictors}/InstanceLearner.java (61%)
 rename moa/src/main/java/moa/learners/{ => predictors}/LearnerSemiSupervised.java (80%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/MultiLabelClassifier.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/MultiTargetRegressor.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/OneClassClassifier.java (64%)
 rename moa/src/main/java/moa/learners/{ => predictors}/Regressor.java (90%)
 rename moa/src/main/java/moa/{classifiers/drift/SingleClassifierDrift.java => learners/predictors/SemiSupervisedClassifier.java} (54%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/SemiSupervisedInstanceLearner.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/SemiSupervisedMultiLabelClassifier.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/SemiSupervisedMultiTargetRegressor.java
 rename moa/src/main/java/moa/{classifiers/SemiSupervisedLearner.java => learners/predictors/SemiSupervisedRegressor.java} (78%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/active/ALClassifier.java (79%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/active/ALRandom.java (57%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/active/ALUncertainty.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/active/budget/BudgetManager.java (87%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/active/budget/FixedBM.java (82%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/bayes/NaiveBayes.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/bayes/NaiveBayesMultinomial.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/AttributeSplitSuggestion.java
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors}/core/LearningLiteral.java (54%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/LearningLiteralClassification.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/LearningLiteralRegression.java
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors}/core/Literal.java (75%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors}/core/MultiLabelRule.java (51%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors}/core/MultiLabelRuleClassification.java (73%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors}/core/MultiLabelRuleRegression.java (72%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors}/core/MultiLabelRuleSet.java (90%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors}/core/ObservableMOAObject.java (70%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors}/core/ObserverMOAObject.java (87%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/core/attributeclassobservers/AbstractAttributeClassObserver.java (79%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/AttributeClassObserver.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/AttributeStatisticsObserver.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserver.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserverRegression.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/core/attributeclassobservers/DiscreteAttributeClassObserver.java (79%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/FIMTDDNumericAttributeClassLimitObserver.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/FIMTDDNumericAttributeClassObserver.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/GaussianNumericAttributeClassObserver.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/GreenwaldKhannaNumericAttributeClassObserver.java
 rename moa/src/main/java/moa/{classifiers/mlc => learners/predictors}/core/attributeclassobservers/MultiLabelBSTree.java (55%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/MultiLabelBSTreeFloat.java
 rename moa/src/main/java/moa/{classifiers/mlc => learners/predictors}/core/attributeclassobservers/MultiLabelBSTreePCT.java (60%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/MultiLabelNominalAttributeObserver.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/NominalAttributeClassObserver.java
 rename moa/src/main/java/moa/{classifiers/mlc => learners/predictors}/core/attributeclassobservers/NominalStatisticsObserver.java (57%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/NullAttributeClassObserver.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/core/attributeclassobservers/NumericAttributeClassObserver.java (86%)
 rename moa/src/main/java/moa/{classifiers/mlc => learners/predictors}/core/attributeclassobservers/NumericStatisticsObserver.java (57%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/SingleVector.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/VFMLNumericAttributeClassObserver.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/core/conditionaltests/InstanceConditionalBinaryTest.java (87%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/conditionaltests/InstanceConditionalTest.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/conditionaltests/NominalAttributeBinaryTest.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/core/conditionaltests/NominalAttributeMultiwayTest.java (51%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/conditionaltests/NumericAttributeBinaryTest.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/driftdetection/ADWIN.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/core/driftdetection/ADWINChangeDetector.java (56%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/driftdetection/AbstractChangeDetector.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/driftdetection/ChangeDetector.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/driftdetection/CusumDM.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/driftdetection/DDM.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/driftdetection/EDDM.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/driftdetection/EWMAChartDM.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/driftdetection/EnsembleDriftDetectionMethods.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/driftdetection/GeometricMovingAverageDM.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/driftdetection/HDDM_A_Test.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/driftdetection/HDDM_W_Test.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/driftdetection/NoChangeDetection.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/driftdetection/PageHinkleyDM.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/driftdetection/RDDM.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/driftdetection/SEEDChangeDetector.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/driftdetection/STEPD.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/driftdetection/SeqDrift1ChangeDetector.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/driftdetection/SeqDrift2ChangeDetector.java
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors/core}/errormeasurers/AbstractMultiLabelErrorMeasurer.java (73%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors/core}/errormeasurers/AbstractMultiTargetErrorMeasurer.java (80%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors/core}/errormeasurers/MeanAbsoluteDeviationMT.java (58%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors/core}/errormeasurers/MultiLabelErrorMeasurer.java (70%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors/core}/errormeasurers/MultiTargetErrorMeasurer.java (93%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/errormeasurers/RelativeMeanAbsoluteDeviationMT.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/errormeasurers/RelativeRootMeanSquaredErrorMT.java
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors/core}/errormeasurers/RootMeanSquaredErrorMT.java (55%)
 rename moa/src/main/java/moa/{classifiers/rules => learners/predictors/core}/featureranking/AbstractFeatureRanking.java (82%)
 rename moa/src/main/java/moa/{classifiers/rules => learners/predictors/core}/featureranking/BasicFeatureRanking.java (56%)
 rename moa/src/main/java/moa/{classifiers/rules => learners/predictors/core}/featureranking/FeatureRanking.java (77%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/featureranking/MeritFeatureRanking.java
 rename moa/src/main/java/moa/{classifiers/rules => learners/predictors/core}/featureranking/NoFeatureRanking.java (84%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/featureranking/WeightedMajorityFeatureRanking.java
 rename moa/src/main/java/moa/{classifiers/rules => learners/predictors/core}/featureranking/messages/ChangeDetectedMessage.java (92%)
 rename moa/src/main/java/moa/{classifiers/rules => learners/predictors/core}/featureranking/messages/FeatureRankingMessage.java (92%)
 rename moa/src/main/java/moa/{classifiers/rules => learners/predictors/core}/featureranking/messages/MeritCheckMessage.java (79%)
 rename moa/src/main/java/moa/{classifiers/rules => learners/predictors/core}/featureranking/messages/RuleExpandedMessage.java (95%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors/core}/functions/AMRulesFunction.java (83%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors/core}/functions/AbstractAMRulesFunctionBasicMlLearner.java (65%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/functions/AdaptiveMultiTargetRegressor.java
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors/core}/functions/DominantLabelsClassifier.java (62%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors/core}/functions/MultiLabelNaiveBayes.java (68%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/functions/MultiLabelPerceptronClassification.java
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors/core}/functions/MultiTargetMeanRegressor.java (69%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors/core}/functions/MultiTargetPerceptronRegressor.java (67%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/functions/StackedPredictor.java
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors/core}/inputselectors/InputAttributesSelector.java (79%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/inputselectors/MeritThreshold.java
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors/core}/inputselectors/SelectAllInputs.java (65%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors/core}/instancetransformers/InstanceAttributesSelector.java (64%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors/core}/instancetransformers/InstanceOutputAttributesSelector.java (63%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors/core}/instancetransformers/InstanceTransformer.java (78%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors/core}/instancetransformers/NoInstanceTransformation.java (88%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors/core}/outputselectors/EntropyThreshold.java (53%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors/core}/outputselectors/OutputAttributesSelector.java (81%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors/core}/outputselectors/SelectAllOutputs.java (89%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors/core}/outputselectors/StdDevThreshold.java (53%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors/core}/outputselectors/VarianceThreshold.java (53%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/splitcriteria/GiniSplitCriterion.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/splitcriteria/ICVarianceReduction.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/splitcriteria/InfoGainSplitCriterion.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/core/splitcriteria/InfoGainSplitCriterionMultilabel.java (67%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/splitcriteria/MultiLabelSplitCriterion.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/splitcriteria/MultiTargetVarianceRatio.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/splitcriteria/MultilabelInformationGain.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/splitcriteria/PCTWeightedICVarianceReduction.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/core/splitcriteria/SDRSplitCriterion.java (83%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/core/splitcriteria/SplitCriterion.java (50%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/splitcriteria/VarianceReductionSplitCriterion.java
 rename moa/src/main/java/moa/{classifiers/mlc => learners/predictors}/core/splitcriteria/WeightedICVarianceReduction.java (62%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/statisticaltests/Cramer.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/statisticaltests/KNN.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/core/statisticaltests/StatisticalTest.java (65%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors}/core/voting/AbstractErrorWeightedVoteMultiLabel.java (54%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors}/core/voting/ErrorWeightedVoteMultiLabel.java (59%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors}/core/voting/FirstHitVoteMultiLabel.java (67%)
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors}/core/voting/InverseErrorWeightedVoteMultiLabel.java (55%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/core/voting/MultiLabelVote.java
 rename moa/src/main/java/moa/{classifiers/rules/multilabel => learners/predictors}/core/voting/UniformWeightedVoteMultiLabel.java (64%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/drift/DriftDetectionMethodClassifier.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/functions/AdaGrad.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/functions/MajorityClass.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/functions/MajorityLabelset.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/functions/Mean.java (85%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/functions/MultiTargetNoChange.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/functions/NoChange.java (55%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/functions/Perceptron.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/functions/SGD.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/functions/SGDMultiClass.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/functions/SPegasos.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/lazy/SAMkNN.java (65%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/lazy/kNN.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/lazy/kNNwithPAW.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/lazy/kNNwithPAWandADWIN.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/DistanceFunction.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/EuclideanDistance.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/KDTree.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/LinearNNSearch.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/NearestNeighbourSearch.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/NormalizableDistance.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/kdtrees/KDTreeNode.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/kdtrees/KDTreeNodeSplitter.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/kdtrees/KMeansInpiredMethod.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/kdtrees/MedianOfWidestDimension.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/kdtrees/MidPointOfWidestDimension.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/kdtrees/SlidingMidPointOfWidestSide.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/meta/ADACC.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/meta/ADOB.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/meta/AbstractOzaBag.java (70%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/meta/AbstractOzaBagAdwin.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/meta/AbstractOzaBoost.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/meta/AccuracyUpdatedEnsemble.java (84%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/meta/AccuracyWeightedEnsemble.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/meta/AdaptiveRandomForest.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/meta/BOLE.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/meta/DACC.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/meta/DynamicWeightedMajority.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/meta/HeterogeneousEnsembleAbstract.java (81%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/meta/HeterogeneousEnsembleBlast.java (95%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/meta/HeterogeneousEnsembleBlastFadingFactors.java (91%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/meta/LearnNSE.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/meta/LeveragingBag.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/meta/LimAttClassifier.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/meta/OCBoost.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/meta/OnlineAccuracyUpdatedEnsemble.java (61%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/meta/OnlineSmoothBoost.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/meta/OzaBagASHT.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/meta/OzaBoostAdwin.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/meta/PairedLearners.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/meta/RCD.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/meta/RandomRules.java (69%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/meta/RegressionViaMTR.java (72%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/meta/TemporallyAugmentedClassifier.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/meta/WEKAClassifier.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/meta/WeightedMajorityAlgorithm.java
 rename moa/src/main/java/moa/{classifiers/meta/OzaBagClassification.java => learners/predictors/meta/classifiers/OzaBag.java} (65%)
 rename moa/src/main/java/moa/{classifiers/meta/OzaBagAdwinClassification.java => learners/predictors/meta/classifiers/OzaBagAdwin.java} (65%)
 rename moa/src/main/java/moa/{classifiers/meta/OzaBoostClassification.java => learners/predictors/meta/classifiers/OzaBoost.java} (76%)
 rename moa/src/main/java/moa/{classifiers/mlc/BasicMultiLabelLearner.java => learners/predictors/meta/mlc/LocalMultiLabelClassifier.java} (55%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/meta/mlc/MEKAClassifier.java
 rename moa/src/main/java/moa/{classifiers/mlc/meta => learners/predictors/meta/mlc}/OzaBagAdwinMultiLabelClassification.java (78%)
 rename moa/src/main/java/moa/{classifiers/mlc/meta => learners/predictors/meta/mlc}/OzaBagMultiLabelClassification.java (81%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/meta/mtr/AdaptiveRandomForest.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors/meta}/mtr/LocalMultiTargetRegressor.java (67%)
 rename moa/src/main/java/moa/{classifiers/mlc/meta/OzaBagMultiTargetRegression.java => learners/predictors/meta/mtr/OzaBag.java} (77%)
 rename moa/src/main/java/moa/{classifiers/mlc/meta/OzaBagAdwinMultiTargetRegression.java => learners/predictors/meta/mtr/OzaBagAdwin.java} (77%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/meta/regressors/AdaptiveRandomForestRegressor.java
 rename moa/src/main/java/moa/{classifiers/meta/OzaBagRegression.java => learners/predictors/meta/regressors/OzaBag.java} (55%)
 rename moa/src/main/java/moa/{classifiers/meta/OzaBagAdwinRegression.java => learners/predictors/meta/regressors/OzaBagAdwin.java} (63%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/oneclass/Autoencoder.java (61%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/oneclass/HSTreeNode.java (61%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/oneclass/HSTrees.java (69%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/oneclass/NearestNeighbourDescription.java (59%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/rules/AMRulesMultiLabelClassifier.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/rules/AMRulesMultiLabelLearner.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/rules/AMRulesMultiLabelLearnerSemiSuper.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/rules/AMRulesMultiTargetRegressor.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/rules/AMRulesMultiTargetRegressorSemiSuper.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/AMRulesRegressor.java (69%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/AMRulesRegressorOld.java (55%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/rules/AbstractAMRules.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/BinaryClassifierFromRegressor.java (67%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/rules/MultiLabelRandomAMRules.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/Predicates.java (69%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/rules/RuleClassification.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/rules/RuleClassifier.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/rules/RuleClassifierNBayes.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/core/AttributeExpansionSuggestion.java (55%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/core/NominalRulePredicate.java (60%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/core/NumericRulePredicate.java (62%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/core/Predicate.java (69%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/core/Rule.java (75%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/rules/core/RuleActiveLearningNode.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/core/RuleActiveRegressionNode.java (50%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/core/RuleSet.java (91%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/core/RuleSplitNode.java (53%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/rules/core/Utils.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/core/anomalydetection/AbstractAnomalyDetector.java (94%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/AnomalinessRatioScore.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/core/anomalydetection/AnomalyDetector.java (68%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/core/anomalydetection/NoAnomalyDetection.java (68%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/OddsRatioScore.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/core/anomalydetection/probabilityfunctions/CantellisInequality.java (73%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/core/anomalydetection/probabilityfunctions/ChebyshevInequality.java (65%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/core/anomalydetection/probabilityfunctions/GaussInequality.java (62%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/core/anomalydetection/probabilityfunctions/ProbabilityFunction.java (91%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java (66%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/rules/core/splitcriteria/AMRulesSplitCriterion.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/core/splitcriteria/SDRSplitCriterionAMRules.java (71%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/rules/core/splitcriteria/SDRSplitCriterionAMRulesNode.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/rules/core/splitcriteria/VRSplitCriterion.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/rules/core/splitcriteria/VarianceRatioSplitCriterion.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/core/voting/AbstractErrorWeightedVote.java (73%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/core/voting/ErrorWeightedVote.java (62%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/core/voting/ExpNegErrorWeightedVote.java (58%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/core/voting/InverseErrorWeightedVote.java (54%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/core/voting/MinErrorWeightedVote.java (71%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/core/voting/OneMinusErrorWeightedVote.java (62%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/core/voting/UniformWeightedVote.java (75%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/core/voting/Vote.java (74%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/driftdetection/PageHinkleyFading.java (56%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/rules/driftdetection/PageHinkleyTest.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/errormeasurers/ErrorMeasurement.java (75%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/errormeasurers/MeanAbsoluteDeviation.java (76%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/errormeasurers/RootMeanSquaredError.java (73%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/functions/AMRulesClassifierFunction.java (94%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/functions/AMRulesLearner.java (86%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/functions/AdaptiveNodePredictor.java (76%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/functions/FadingTargetMean.java (78%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/functions/LowPassFilteredLearner.java (68%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/functions/Perceptron.java (54%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/functions/TargetMean.java (65%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/rules/meta/RandomAMRules.java (76%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/rules/meta/RandomAMRulesOld.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/trees/ARFFIMTDD.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/trees/ARFHoeffdingTree.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/trees/ASHoeffdingTree.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/trees/AdaHoeffdingOptionTree.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/trees/DecisionStump.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/trees/EFDT.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/trees/FIMTDD.java (77%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/trees/HoeffdingAdaptiveTree.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/trees/HoeffdingAdaptiveTreeClassifLeaves.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/trees/HoeffdingOptionTree.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/trees/HoeffdingTree.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/trees/HoeffdingTreeClassifLeaves.java
 rename moa/src/main/java/moa/{classifiers/mtr => learners/predictors}/trees/ISOUPOptionTree.java (75%)
 rename moa/src/main/java/moa/{classifiers/mtr => learners/predictors}/trees/ISOUPTree.java (74%)
 rename moa/src/main/java/moa/{classifiers/mtr => learners/predictors}/trees/ISOUPTreeRF.java (71%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/trees/LimAttHoeffdingTree.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/trees/MultilabelHoeffdingTree.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/trees/ORTO.java (77%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/trees/RandomHoeffdingTree.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/trees/iadem/Iadem2.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/trees/iadem/Iadem3.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/trees/iadem/Iadem3Subtree.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/trees/iadem/IademAttributeSplitSuggestion.java (53%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/trees/iadem/IademCommonProcedures.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/trees/iadem/IademException.java (56%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/trees/iadem/IademGaussianNumericAttributeClassObserver.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/trees/iadem/IademGreenwaldKhannaNumericAttributeClassObserver.java
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/trees/iadem/IademGreenwaldKhannaQuantileSummary.java (57%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/trees/iadem/IademNominalAttributeBinaryTest.java (66%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/trees/iadem/IademNominalAttributeMultiwayTest.java (66%)
 rename moa/src/main/java/moa/{classifiers => learners/predictors}/trees/iadem/IademNumericAttributeBinaryTest.java (66%)
 create mode 100644 moa/src/main/java/moa/learners/predictors/trees/iadem/IademNumericAttributeObserver.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/trees/iadem/IademSplitCriterion.java
 create mode 100644 moa/src/main/java/moa/learners/predictors/trees/iadem/IademVFMLNumericAttributeClassObserver.java
 delete mode 100644 moa/src/main/java/moa/tasks/structuredoutput/multitargetregression/EvaluatePrequentialMultiTargetSemiSuper.java
 create mode 100644 moa/src/main/java/moa/tasks/structuredoutput/multitargetregression/EvaluatePrequentialSemiSupervised.java
 delete mode 100644 moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java
 delete mode 100644 moa/src/test/java/moa/classifiers/AbstractMultiTargetRegressorTestCase.java
 delete mode 100644 moa/src/test/java/moa/classifiers/AbstractRegressorTestCase.java
 delete mode 100644 moa/src/test/java/moa/classifiers/active/ALRandomTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/active/ALUncertaintyTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/bayes/NaiveBayesMultinomialTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/bayes/NaiveBayesTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/drift/DriftDetectionMethodClassifierTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/drift/SingleClassifierDriftTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/functions/MajorityClassTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/functions/NoChangeTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/functions/PerceptronTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/functions/SGDTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/functions/SPegasosTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/meta/ADOBTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/meta/AccuracyUpdatedEnsembleTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/meta/AccuracyWeightedEnsembleTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/meta/AdaptiveRandomForestTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/meta/BOLETest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/meta/DynamicWeightedMajorityTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/meta/LeveragingBagTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/meta/LimAttClassifierTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/meta/OCBoostTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/meta/OnlineAccuracyUpdatedEnsembleTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/meta/OzaBagASHTTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/meta/OzaBagAdwinClassificationTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/meta/OzaBagClassificationTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/meta/OzaBoostAdwinTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/meta/OzaBoostClassificationTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/meta/TemporallyAugmentedClassifierTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/meta/WEKAClassifierTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/meta/WeightedMajorityAlgorithmTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/rules/RuleClassifierNBayesTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/rules/RuleClassifierTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/rules/core/UtilsTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressorSemiSuperTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/FirstHitVoteMultiLabelTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/InverseErrorWeightedVoteMultiLabelTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/UniformWeightedVoteMultiLabelTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/rules/multilabel/errormeasurers/RelativeMeanAbsoluteDeviationMTTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/rules/multilabel/errormeasurers/RelativeRootMeanSquaredErrorMTTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/rules/multilabel/instancetransformers/InstanceOutputAttributesSelectorTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/trees/ASHoeffdingTreeTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/trees/AdaHoeffdingOptionTreeTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/trees/DecisionStumpTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/trees/EFDTTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/trees/FIMTDDTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/trees/HoeffdingAdaptiveTreeTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/trees/HoeffdingOptionTreeTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/trees/HoeffdingTreeTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/trees/LimAttHoeffdingTreeTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/trees/ORTOTest.java
 delete mode 100644 moa/src/test/java/moa/classifiers/trees/RandomHoeffdingTreeTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/AbstractClassifierTestCase.java
 rename moa/src/test/java/moa/{classifiers => learners/predictors}/AbstractInstanceLearnerTestCase.java (69%)
 create mode 100644 moa/src/test/java/moa/learners/predictors/AbstractMultiTargetRegressorTestCase.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/AbstractRegressorTestCase.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/active/ALRandomTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/active/ALUncertaintyTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/bayes/NaiveBayesMultinomialTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/bayes/NaiveBayesTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/drift/DriftDetectionMethodClassifierTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/functions/MajorityClassTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/functions/NoChangeTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/functions/PerceptronTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/functions/SGDTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/functions/SPegasosTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/meta/ADOBTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/meta/AccuracyUpdatedEnsembleTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/meta/AccuracyWeightedEnsembleTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/meta/AdaptiveRandomForestTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/meta/BOLETest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/meta/DynamicWeightedMajorityTest.java
 rename moa/src/test/java/moa/{classifiers => learners/predictors}/meta/HeterogeneousEnsembleBlastTest.java (75%)
 create mode 100644 moa/src/test/java/moa/learners/predictors/meta/LeveragingBagTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/meta/LimAttClassifierTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/meta/OCBoostTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/meta/OnlineAccuracyUpdatedEnsembleTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/meta/OzaBagASHTTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/meta/OzaBoostAdwinTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/meta/TemporallyAugmentedClassifierTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/meta/WEKAClassifierTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/meta/WeightedMajorityAlgorithmTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/meta/classifiers/OzaBagAdwinTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/meta/classifiers/OzaBagTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/meta/classifiers/OzaBoostTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/rules/AMRulesMultiTargetRegressorSemiSuperTest.java
 rename moa/src/test/java/moa/{classifiers => learners/predictors}/rules/AMRulesRegressorTest.java (72%)
 create mode 100644 moa/src/test/java/moa/learners/predictors/rules/RuleClassifierNBayesTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/rules/RuleClassifierTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/rules/core/UtilsTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/rules/multilabel/core/voting/FirstHitVoteMultiLabelTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/rules/multilabel/core/voting/InverseErrorWeightedVoteMultiLabelTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/rules/multilabel/core/voting/UniformWeightedVoteMultiLabelTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/rules/multilabel/errormeasurers/RelativeMeanAbsoluteDeviationMTTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/rules/multilabel/errormeasurers/RelativeRootMeanSquaredErrorMTTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/rules/multilabel/instancetransformers/InstanceOutputAttributesSelectorTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/trees/ASHoeffdingTreeTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/trees/AdaHoeffdingOptionTreeTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/trees/DecisionStumpTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/trees/EFDTTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/trees/FIMTDDTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/trees/HoeffdingAdaptiveTreeTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/trees/HoeffdingOptionTreeTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/trees/HoeffdingTreeTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/trees/LimAttHoeffdingTreeTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/trees/ORTOTest.java
 create mode 100644 moa/src/test/java/moa/learners/predictors/trees/RandomHoeffdingTreeTest.java
 delete mode 100644 moa/src/test/resources/moa/classifiers/drift/SingleClassifierDrift.ref
 delete mode 100644 moa/src/test/resources/moa/classifiers/functions/Perceptron.ref
 delete mode 100644 moa/src/test/resources/moa/classifiers/meta/OzaBagAdwin.ref
 delete mode 100644 moa/src/test/resources/moa/classifiers/meta/OzaBagClassification.ref
 delete mode 100644 moa/src/test/resources/moa/classifiers/meta/OzaBoostClassification.ref
 delete mode 100644 moa/src/test/resources/moa/classifiers/rules/AMRulesRegressor.ref
 delete mode 100644 moa/src/test/resources/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressorSemiSuper.ref
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/active/ALRandom.ref (97%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/active/ALUncertainty.ref (98%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/bayes/NaiveBayes.ref (98%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/bayes/NaiveBayesMultinomial.ref (98%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/data/classification.arff (100%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/data/regression.arff (100%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/data/small_classification.arff (100%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/data/small_regression.arff (100%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/drift/DriftDetectionMethodClassifier.ref (98%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/functions/MajorityClass.ref (98%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/functions/NoChange.ref (98%)
 create mode 100644 moa/src/test/resources/moa/learners/predictors/functions/Perceptron.ref
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/functions/SGD.ref (98%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/functions/SPegasos.ref (98%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/meta/ADOB.ref (98%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/meta/AccuracyUpdatedEnsemble.ref (99%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/meta/AccuracyWeightedEnsemble.ref (99%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/meta/AdaptiveRandomForest.ref (97%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/meta/BOLE.ref (99%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/meta/DynamicWeightedMajority.ref (98%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/meta/HeterogeneousEnsembleBlast.ref (98%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/meta/LeveragingBag.ref (99%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/meta/LimAttClassifier.ref (99%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/meta/OCBoost.ref (84%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/meta/OnlineAccuracyUpdatedEnsemble.ref (99%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/meta/OzaBagASHT.ref (99%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/meta/OzaBoostAdwin.ref (99%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/meta/TemporallyAugmentedClassifier.ref (98%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/meta/WEKAClassifier.ref (98%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/meta/WeightedMajorityAlgorithm.ref (99%)
 rename moa/src/test/resources/moa/{classifiers/meta => learners/predictors/meta/classifiers}/OzaBag.ref (77%)
 rename moa/src/test/resources/moa/{classifiers/meta/OzaBagAdwinClassification.ref => learners/predictors/meta/classifiers/OzaBagAdwin.ref} (99%)
 rename moa/src/test/resources/moa/{classifiers/meta => learners/predictors/meta/classifiers}/OzaBoost.ref (99%)
 create mode 100644 moa/src/test/resources/moa/learners/predictors/rules/AMRulesMultiTargetRegressorSemiSuper.ref
 create mode 100644 moa/src/test/resources/moa/learners/predictors/rules/AMRulesRegressor.ref
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/rules/RuleClassifier.ref (98%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/rules/RuleClassifierNBayes.ref (98%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/trees/ASHoeffdingTree.ref (99%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/trees/AdaHoeffdingOptionTree.ref (99%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/trees/DecisionStump.ref (98%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/trees/EFDT.ref (99%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/trees/FIMTDD.ref (98%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/trees/HoeffdingAdaptiveTree.ref (99%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/trees/HoeffdingOptionTree.ref (99%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/trees/HoeffdingTree.ref (99%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/trees/LimAttHoeffdingTree.ref (99%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/trees/ORTO.ref (98%)
 rename moa/src/test/resources/moa/{classifiers => learners/predictors}/trees/RandomHoeffdingTree.ref (99%)

diff --git a/moa/.classpath b/moa/.classpath
index 079c3f879..0ca1374d8 100644
--- a/moa/.classpath
+++ b/moa/.classpath
@@ -20,7 +20,6 @@
 	</classpathentry>
 	<classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources">
 		<attributes>
-			<attribute name="test" value="true"/>
 			<attribute name="maven.pomderived" value="true"/>
 			<attribute name="test" value="true"/>
 		</attributes>
diff --git a/moa/src/main/java/com/github/javacliparser/AbstractClassOption.java b/moa/src/main/java/com/github/javacliparser/AbstractClassOption.java
index b232a7d3b..c9c34cd49 100644
--- a/moa/src/main/java/com/github/javacliparser/AbstractClassOption.java
+++ b/moa/src/main/java/com/github/javacliparser/AbstractClassOption.java
@@ -1,18 +1,18 @@
 /*
  * Copyright 2007 University of Waikato.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 
 package com.github.javacliparser;
@@ -27,201 +27,189 @@
  */
 public abstract class AbstractClassOption extends AbstractOption {
 
-    private static final long serialVersionUID = 1L;
-
-    /** The prefix text to use to indicate file.  */
-    public static final String FILE_PREFIX_STRING = "file:";
-
-    /** The prefix text to use to indicate inmem.  */
-    public static final String INMEM_PREFIX_STRING = "inmem:";
-
-    /** The current object */
-    protected Object currentValue;
-
-    /** The class type */
-    protected Class<?> requiredType;
-
-    /** The default command line interface text. */
-    protected String defaultCLIString;
-
-    /** The null text. */
-    protected String nullString;
-
-    /**
-     * Creates a new instance of an abstract option given its class name,
-     * command line interface text, its purpose, its class type and its default
-     * command line interface text.
-     *
-     * @param name the name of this option
-     * @param cliChar the command line interface text
-     * @param purpose the text describing the purpose of this option
-     * @param requiredType the class type
-     * @param defaultCLIString the default command line interface text
-     */
-    public AbstractClassOption(String name, char cliChar, String purpose,
-            Class<?> requiredType, String defaultCLIString) {
-        this(name, cliChar, purpose, requiredType, defaultCLIString, null);
-    }
-
-    /**
-     * Creates a new instance of an abstract option given its class name,
-     * command line interface text, its purpose, its class type, default
-     * command line interface text, and its null text.
-     *
-     * @param name the name of this option
-     * @param cliChar the command line interface text
-     * @param purpose the text describing the purpose of this option
-     * @param requiredType the class type
-     * @param defaultCLIString the default command line interface text
-     * @param nullString the null text
-     */
-    public AbstractClassOption(String name, char cliChar, String purpose,
-            Class<?> requiredType, String defaultCLIString, String nullString) {
-        super(name, cliChar, purpose);
-        this.requiredType = requiredType;
-        this.defaultCLIString = defaultCLIString;
-        this.nullString = nullString;
-        resetToDefault();
-    }
-
-    /**
-     * Sets current object.
-     *
-     * @param obj the object to set as current.
-     */
-    public void setCurrentObject(Object obj) {
-        if (((obj == null) && (this.nullString != null))
-                || this.requiredType.isInstance(obj)
-                || (obj instanceof String)
-                || (obj instanceof File)
-             //   || ((obj instanceof Task) && this.requiredType.isAssignableFrom(((Task) obj).getTaskResultType()))
-                ) {
-            this.currentValue = obj;
-        } else {
-            throw new IllegalArgumentException("Object not of required type.");
-        }
-    }
-
-    /**
-     * Returns the current object.
-     *
-     * @return the current object
-     */
-    public Object getValue() { //getPreMaterializedObject() {
-        return this.currentValue;
-    }
-
-    /**
-     * Gets the class type of this option.
-     *
-     * @return the class type of this option
-     */
-    public Class<?> getRequiredType() {
-        return this.requiredType;
-    }
-
-    /**
-     * Gets the null string of this option.
-     *
-     * @return the null string of this option
-     */
-    public String getNullString() {
-        return this.nullString;
-    }
-
-    /**
-     * Gets a materialized object of this option.
-     * 
-     * @return the materialized object
-     */
-    public Object materializeObject() {
-        if ((this.currentValue == null)
-                || this.requiredType.isInstance(this.currentValue)) {
-            return this.currentValue;
-       /* } else if (this.currentValue instanceof String) {
-            if (repository != null) {
-                Object inmemObj = repository.getObjectNamed((String) this.currentValue);
-                if (inmemObj == null) {
-                    throw new RuntimeException("No object named "
-                            + this.currentValue + " found in repository.");
-                }
-                return inmemObj;
-            }
-            throw new RuntimeException("No object repository available.");
-            */ 
-      //  } else if (this.currentValue instanceof Task) {
-      //      Task task = (Task) this.currentValue;
-      //      Object result = task.doTask(monitor, repository);
-      //      return result;
-        } else if (this.currentValue instanceof File) {
-            File inputFile = (File) this.currentValue;
-            Object result = null;
-            try {
-                result = SerializeUtils.readFromFile(inputFile);
-            } catch (Exception ex) {
-                throw new RuntimeException("Problem loading "
-                        + this.requiredType.getName() + " object from file '"
-                        + inputFile.getName() + "':\n" + ex.getMessage(), ex);
-            }
-            return result;
-        } else {
-            throw new RuntimeException(
-                    "Could not materialize object of required type "
-                    + this.requiredType.getName() + ", found "
-                    + this.currentValue.getClass().getName()
-                    + " instead.");
-        }
-    }
-
-    @Override
-    public String getDefaultCLIString() {
-        return this.defaultCLIString;
-    }
-
-    /**
-     * Gets the command line interface text of the class.
-     *
-     * @param aClass the class
-     * @param requiredType the class type
-     * @return the command line interface text of the class
-     */
-    public static String classToCLIString(Class<?> aClass, Class<?> requiredType) {
-        String className = aClass.getName();
-        String packageName = requiredType.getPackage().getName();
-        if (className.startsWith(packageName)) {
-            // cut off package name
-            className = className.substring(packageName.length() + 1, className.length());
-        } /*else if (Task.class.isAssignableFrom(aClass)) {
-            packageName = Task.class.getPackage().getName();
-            if (className.startsWith(packageName)) {
-                // cut off task package name
-                className = className.substring(packageName.length() + 1,
-                        className.length());
-            }
-        }*/
-        return className;
-    }
-
-    @Override
-    public abstract String getValueAsCLIString();
-
-    @Override
-    public abstract void setValueViaCLIString(String s);
-
-    //@Override
-    //public abstract JComponent getEditComponent();
-
-    /**
-     * Gets the class name without its package name prefix.
-     *
-     * @param className the name of the class
-     * @param expectedType the type of the class
-     * @return the class name without its package name prefix
-     */
-    public static String stripPackagePrefix(String className, Class<?> expectedType) {
-        if (className.startsWith(expectedType.getPackage().getName())) {
-            return className.substring(expectedType.getPackage().getName().length() + 1);
-        }
-        return className;
-    }
+	private static final long serialVersionUID = 1L;
+
+	/** The prefix text to use to indicate file. */
+	public static final String FILE_PREFIX_STRING = "file:";
+
+	/** The prefix text to use to indicate inmem. */
+	public static final String INMEM_PREFIX_STRING = "inmem:";
+
+	/** The current object */
+	protected Object currentValue;
+
+	/** The class type */
+	protected Class<?> requiredType;
+
+	/** The default command line interface text. */
+	protected String defaultCLIString;
+
+	/** The null text. */
+	protected String nullString;
+
+	/**
+	 * Creates a new instance of an abstract option given its class name, command
+	 * line interface text, its purpose, its class type and its default command line
+	 * interface text.
+	 *
+	 * @param name             the name of this option
+	 * @param cliChar          the command line interface text
+	 * @param purpose          the text describing the purpose of this option
+	 * @param requiredType     the class type
+	 * @param defaultCLIString the default command line interface text
+	 */
+	public AbstractClassOption(String name, char cliChar, String purpose, Class<?> requiredType,
+			String defaultCLIString) {
+		this(name, cliChar, purpose, requiredType, defaultCLIString, null);
+	}
+
+	/**
+	 * Creates a new instance of an abstract option given its class name, command
+	 * line interface text, its purpose, its class type, default command line
+	 * interface text, and its null text.
+	 *
+	 * @param name             the name of this option
+	 * @param cliChar          the command line interface text
+	 * @param purpose          the text describing the purpose of this option
+	 * @param requiredType     the class type
+	 * @param defaultCLIString the default command line interface text
+	 * @param nullString       the null text
+	 */
+	public AbstractClassOption(String name, char cliChar, String purpose, Class<?> requiredType,
+			String defaultCLIString, String nullString) {
+		super(name, cliChar, purpose);
+		this.requiredType = requiredType;
+		this.defaultCLIString = defaultCLIString;
+		this.nullString = nullString;
+		resetToDefault();
+	}
+
+	/**
+	 * Sets current object.
+	 *
+	 * @param obj the object to set as current.
+	 */
+	public void setCurrentObject(Object obj) {
+		if (((obj == null) && (this.nullString != null)) || this.requiredType.isInstance(obj) || (obj instanceof String)
+				|| (obj instanceof File)
+		// || ((obj instanceof Task) && this.requiredType.isAssignableFrom(((Task)
+		// obj).getTaskResultType()))
+		) {
+			this.currentValue = obj;
+		} else {
+			throw new IllegalArgumentException("Object not of required type.");
+		}
+	}
+
+	/**
+	 * Returns the current object.
+	 *
+	 * @return the current object
+	 */
+	public Object getValue() { // getPreMaterializedObject() {
+		return this.currentValue;
+	}
+
+	/**
+	 * Gets the class type of this option.
+	 *
+	 * @return the class type of this option
+	 */
+	public Class<?> getRequiredType() {
+		return this.requiredType;
+	}
+
+	/**
+	 * Gets the null string of this option.
+	 *
+	 * @return the null string of this option
+	 */
+	public String getNullString() {
+		return this.nullString;
+	}
+
+	/**
+	 * Gets a materialized object of this option.
+	 * 
+	 * @return the materialized object
+	 */
+	public Object materializeObject() {
+		if ((this.currentValue == null) || this.requiredType.isInstance(this.currentValue)) {
+			return this.currentValue;
+			/*
+			 * } else if (this.currentValue instanceof String) { if (repository != null) {
+			 * Object inmemObj = repository.getObjectNamed((String) this.currentValue); if
+			 * (inmemObj == null) { throw new RuntimeException("No object named " +
+			 * this.currentValue + " found in repository."); } return inmemObj; } throw new
+			 * RuntimeException("No object repository available.");
+			 */
+			// } else if (this.currentValue instanceof Task) {
+			// Task task = (Task) this.currentValue;
+			// Object result = task.doTask(monitor, repository);
+			// return result;
+		} else if (this.currentValue instanceof File) {
+			File inputFile = (File) this.currentValue;
+			Object result = null;
+			try {
+				result = SerializeUtils.readFromFile(inputFile);
+			} catch (Exception ex) {
+				throw new RuntimeException("Problem loading " + this.requiredType.getName() + " object from file '"
+						+ inputFile.getName() + "':\n" + ex.getMessage(), ex);
+			}
+			return result;
+		} else {
+			throw new RuntimeException("Could not materialize object of required type " + this.requiredType.getName()
+					+ ", found " + this.currentValue.getClass().getName() + " instead.");
+		}
+	}
+
+	@Override
+	public String getDefaultCLIString() {
+		return this.defaultCLIString;
+	}
+
+	/**
+	 * Gets the command line interface text of the class.
+	 *
+	 * @param aClass       the class
+	 * @param requiredType the class type
+	 * @return the command line interface text of the class
+	 */
+	public static String classToCLIString(Class<?> aClass, Class<?> requiredType) {
+		String className = aClass.getName();
+		String packageName = requiredType.getPackage().getName();
+		if (className.startsWith(packageName)) {
+			// cut off package name
+			className = className.substring(packageName.length() + 1, className.length());
+		} /*
+			 * else if (Task.class.isAssignableFrom(aClass)) { packageName =
+			 * Task.class.getPackage().getName(); if (className.startsWith(packageName)) {
+			 * // cut off task package name className =
+			 * className.substring(packageName.length() + 1, className.length()); } }
+			 */
+		return className;
+	}
+
+	@Override
+	public abstract String getValueAsCLIString();
+
+	@Override
+	public abstract void setValueViaCLIString(String s);
+
+	// @Override
+	// public abstract JComponent getEditComponent();
+
+	/**
+	 * Gets the class name without its package name prefix.
+	 *
+	 * @param className    the name of the class
+	 * @param expectedType the type of the class
+	 * @return the class name without its package name prefix
+	 */
+	public static String stripPackagePrefix(String className, Class<?> expectedType) {
+		if (className.startsWith(expectedType.getPackage().getName())) {
+			return className.substring(expectedType.getPackage().getName().length() + 1);
+		}
+		return className;
+	}
 }
diff --git a/moa/src/main/java/com/github/javacliparser/AbstractOption.java b/moa/src/main/java/com/github/javacliparser/AbstractOption.java
index 7c5e8a5c4..88082158c 100644
--- a/moa/src/main/java/com/github/javacliparser/AbstractOption.java
+++ b/moa/src/main/java/com/github/javacliparser/AbstractOption.java
@@ -1,18 +1,18 @@
 /*
  * Copyright 2007 University of Waikato.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 
 package com.github.javacliparser;
@@ -25,99 +25,96 @@
  */
 public abstract class AbstractOption implements Option {
 
-    /** Array of characters not valid to use in option names. */
-    public static final char[] illegalNameCharacters = new char[]{' ', '-',
-        '(', ')'};
-
-    /** Name of this option. */
-    protected String name;
-
-    /** Command line interface text of this option. */
-    protected char cliChar;
-
-    /** Text of the purpose of this option. */
-    protected String purpose;
-
-    /**
-     * Gets whether the name is valid or not.
-     *
-     * @param optionName the name of the option
-     * @return true if the name that not contain any illegal character
-     */
-    public static boolean nameIsLegal(String optionName) {
-        for (char illegalChar : illegalNameCharacters) {
-            if (optionName.indexOf(illegalChar) >= 0) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /**
-     * Creates a new instance of an abstract option given its class name,
-     * command line interface text and its purpose.
-     *
-     * @param name the name of this option
-     * @param cliChar the command line interface text
-     * @param purpose the text describing the purpose of this option
-     */
-    public AbstractOption(String name, char cliChar, String purpose) {
-        if (!nameIsLegal(name)) {
-            throw new IllegalArgumentException("Illegal option name: " + name);
-        }
-        this.name = name;
-        this.cliChar = cliChar;
-        this.purpose = purpose;
-    }
-
-    @Override
-    public String getName() {
-        return this.name;
-    }
-
-    @Override
-    public char getCLIChar() {
-        return this.cliChar;
-    }
-
-    @Override
-    public String getPurpose() {
-        return this.purpose;
-    }
-
-    @Override
-    public void resetToDefault() {
-        setValueViaCLIString(getDefaultCLIString());
-    }
-
-    @Override
-    public String getStateString() {
-        return getValueAsCLIString();
-    }
-
-   
-    @Override
-    public Option copy() {
-        try {
-            return (Option) SerializeUtils.copyObject(this);
-        } catch (Exception e) {
-            throw new RuntimeException("Object copy failed.", e);
-        }
-    }
-    
-    //@Override
-    //public Option copy() {
-    //    return (Option) super.copy();
-    //}
-
-    
-    //@Override
-    //public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    //}
-
-    //@Override
-    //public JComponent getEditComponent() {
-    //    return new StringOptionEditComponent(this);
-    //}
+	/** Array of characters not valid to use in option names. */
+	public static final char[] illegalNameCharacters = new char[] { ' ', '-', '(', ')' };
+
+	/** Name of this option. */
+	protected String name;
+
+	/** Command line interface text of this option. */
+	protected char cliChar;
+
+	/** Text of the purpose of this option. */
+	protected String purpose;
+
+	/**
+	 * Gets whether the name is valid or not.
+	 *
+	 * @param optionName the name of the option
+	 * @return true if the name that not contain any illegal character
+	 */
+	public static boolean nameIsLegal(String optionName) {
+		for (char illegalChar : illegalNameCharacters) {
+			if (optionName.indexOf(illegalChar) >= 0) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	/**
+	 * Creates a new instance of an abstract option given its class name, command
+	 * line interface text and its purpose.
+	 *
+	 * @param name    the name of this option
+	 * @param cliChar the command line interface text
+	 * @param purpose the text describing the purpose of this option
+	 */
+	public AbstractOption(String name, char cliChar, String purpose) {
+		if (!nameIsLegal(name)) {
+			throw new IllegalArgumentException("Illegal option name: " + name);
+		}
+		this.name = name;
+		this.cliChar = cliChar;
+		this.purpose = purpose;
+	}
+
+	@Override
+	public String getName() {
+		return this.name;
+	}
+
+	@Override
+	public char getCLIChar() {
+		return this.cliChar;
+	}
+
+	@Override
+	public String getPurpose() {
+		return this.purpose;
+	}
+
+	@Override
+	public void resetToDefault() {
+		setValueViaCLIString(getDefaultCLIString());
+	}
+
+	@Override
+	public String getStateString() {
+		return getValueAsCLIString();
+	}
+
+	@Override
+	public Option copy() {
+		try {
+			return (Option) SerializeUtils.copyObject(this);
+		} catch (Exception e) {
+			throw new RuntimeException("Object copy failed.", e);
+		}
+	}
+
+	// @Override
+	// public Option copy() {
+	// return (Option) super.copy();
+	// }
+
+	// @Override
+	// public void getDescription(StringBuilder sb, int indent) {
+	// TODO Auto-generated method stub
+	// }
+
+	// @Override
+	// public JComponent getEditComponent() {
+	// return new StringOptionEditComponent(this);
+	// }
 }
diff --git a/moa/src/main/java/com/github/javacliparser/ClassOption.java b/moa/src/main/java/com/github/javacliparser/ClassOption.java
index da14691e6..09801c5d5 100644
--- a/moa/src/main/java/com/github/javacliparser/ClassOption.java
+++ b/moa/src/main/java/com/github/javacliparser/ClassOption.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package com.github.javacliparser;
 
@@ -31,166 +31,152 @@
  */
 public class ClassOption extends AbstractClassOption {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption(String name, char cliChar, String purpose, Class<?> requiredType, String defaultCLIString) {
+		super(name, cliChar, purpose, requiredType, defaultCLIString);
+	}
+
+	public ClassOption(String name, char cliChar, String purpose, Class<?> requiredType, String defaultCLIString,
+			String nullString) {
+		super(name, cliChar, purpose, requiredType, defaultCLIString, nullString);
+	}
 
-    public ClassOption(String name, char cliChar, String purpose,
-            Class<?> requiredType, String defaultCLIString) {
-        super(name, cliChar, purpose, requiredType, defaultCLIString);
-    }
+	@Override
+	public String getValueAsCLIString() {
+		if ((this.currentValue == null) && (this.nullString != null)) {
+			return this.nullString;
+		}
+		return objectToCLIString(this.currentValue, this.requiredType);
+	}
 
-    public ClassOption(String name, char cliChar, String purpose,
-            Class<?> requiredType, String defaultCLIString, String nullString) {
-        super(name, cliChar, purpose, requiredType, defaultCLIString, nullString);
-    }
+	@Override
+	public void setValueViaCLIString(String s) {
+		if ((this.nullString != null) && ((s == null) || (s.length() == 0) || s.equals(this.nullString))) {
+			this.currentValue = null;
+		} else {
+			try {
+				this.currentValue = cliStringToObject(s, this.requiredType, null);
+			} catch (Exception e) {
+				throw new IllegalArgumentException("Problems with option: " + getName(), e);
+			}
+		}
+	}
 
-    @Override
-    public String getValueAsCLIString() {
-        if ((this.currentValue == null) && (this.nullString != null)) {
-            return this.nullString;
-        }
-        return objectToCLIString(this.currentValue, this.requiredType);
-    }
+	public static String objectToCLIString(Object obj, Class<?> requiredType) {
+		if (obj == null) {
+			return "";
+		}
+		if (obj instanceof File) {
+			return (FILE_PREFIX_STRING + ((File) obj).getPath());
+		}
+		if (obj instanceof String) {
+			return (INMEM_PREFIX_STRING + obj);
+		}
+		String className = classToCLIString(obj.getClass(), requiredType);
+		if (obj instanceof Configurable) {
+			// String subOptions = ((Configurable) obj).getOptions().getAsCLIString();
+			// Add cli parser
+			JavaCLIParser config = new JavaCLIParser(obj, "");
+			String subOptions = config.getOptions().getAsCLIString();
+			if (subOptions.length() > 0) {
+				return (className + " " + subOptions);
+			}
+		}
+		return className;
+	}
 
-    @Override
-    public void setValueViaCLIString(String s) {
-        if ((this.nullString != null)
-                && ((s == null) || (s.length() == 0) || s.equals(this.nullString))) {
-            this.currentValue = null;
-        } else {
-            try {
-                this.currentValue = cliStringToObject(s, this.requiredType,
-                        null);
-            } catch (Exception e) {
-                throw new IllegalArgumentException("Problems with option: " + getName(), e);
-            }
-        }
-    }
+	public static Object createObject(String cliString, Class<?> requiredType) throws Exception {
+		return cliStringToObject(cliString, requiredType, null);
+	}
 
-    public static String objectToCLIString(Object obj, Class<?> requiredType) {
-        if (obj == null) {
-            return "";
-        }
-        if (obj instanceof File) {
-            return (FILE_PREFIX_STRING + ((File) obj).getPath());
-        }
-        if (obj instanceof String) {
-            return (INMEM_PREFIX_STRING + obj);
-        }
-        String className = classToCLIString(obj.getClass(), requiredType);
-        if (obj instanceof Configurable) {
-            //String subOptions = ((Configurable) obj).getOptions().getAsCLIString();
-            //Add cli parser
-            JavaCLIParser config = new JavaCLIParser(obj, "");
-            String subOptions = config.getOptions().getAsCLIString();
-            if (subOptions.length() > 0) {
-                return (className + " " + subOptions);
-            }
-        }
-        return className;
-    }
+	public static Object createObject(String[] args, Class<?> requiredType) throws Exception {
+		// build a single string by concatenating cli options
+		StringBuilder cliString = new StringBuilder();
+		for (int i = 0; i < args.length; i++) {
+			cliString.append(" ").append(args[i]);
+		}
+		return cliStringToObject(cliString.toString(), requiredType, null);
+	}
 
-    public static Object createObject(String cliString,
-            Class<?> requiredType) throws Exception {
-        return cliStringToObject(cliString, requiredType, null);
-    }
-    
-        
-   public static Object createObject(String[] args,
-            Class<?> requiredType) throws Exception {
-            // build a single string by concatenating cli options
-            StringBuilder cliString = new StringBuilder();
-            for (int i = 0; i < args.length; i++) {
-                cliString.append(" ").append(args[i]);
-            }
-            return cliStringToObject(cliString.toString(), requiredType, null);
-    }
-    
-    
-    public static Object cliStringToObject(String cliString,
-            Class<?> requiredType, Option[] externalOptions) throws Exception {
-        if (cliString.startsWith(FILE_PREFIX_STRING)) {
-            return new File(cliString.substring(FILE_PREFIX_STRING.length()));
-        }
-        if (cliString.startsWith(INMEM_PREFIX_STRING)) {
-            return cliString.substring(INMEM_PREFIX_STRING.length());
-        }
-        cliString = cliString.trim();
-        int firstSpaceIndex = cliString.indexOf(' ', 0);
-        String className;
-        String classOptions;
-        if (firstSpaceIndex > 0) {
-            className = cliString.substring(0, firstSpaceIndex);
-            classOptions = cliString.substring(firstSpaceIndex + 1, cliString.length());
-            classOptions = classOptions.trim();
-        } else {
-            className = cliString;
-            classOptions = "";
-        }
-        Class<?> classObject;
-        try {
-            classObject = Class.forName(className);
-        } catch (Throwable t1) {
-            try {
-                // try prepending default package
-                classObject = Class.forName(requiredType.getPackage().getName()
-                        + "." + className);
-            /*} catch (Throwable t2) {
-                try {
-                    // try prepending task package
-                    classObject = Class.forName(Task.class.getPackage().getName()
-                            + "." + className);
-                */} catch (Throwable t3) {
-                    throw new Exception("Class not found: " + className);
-                //}
-            }
-        }
-        Object classInstance;
-        try {
-            classInstance = classObject.newInstance();
-        } catch (Exception ex) {
-            throw new Exception("Problem creating instance of class: "
-                    + className, ex);
-        }
-        if (requiredType.isInstance(classInstance)
- //               || ((classInstance instanceof Task) && requiredType.isAssignableFrom(((Task) classInstance).getTaskResultType()))
-                ) {
-            Options options = new Options();
-            JavaCLIParser config = null;
-            if (externalOptions != null) {
-                for (Option option : externalOptions) {
-                    options.addOption(option);
-                }
-            }
-            if (classInstance instanceof Configurable) {
-                 config = new JavaCLIParser(classInstance, "");
-                 Option[] objectOptions = config.getOptions().getOptionArray();
-                //Option[] objectOptions = ((Configurable) classInstance).getOptions().getOptionArray();
-                for (Option option : objectOptions) {
-                    options.addOption(option);
-                }
-            }
-            try {
-                options.setViaCLIString(classOptions);
-            } catch (Exception ex) {
-                throw new Exception("Problem with options to '"
-                        + className
-                        + "'."
-                        + "\n\nValid options for "
-                        + className
-                        + ":\n"
-                        + config == null ? "": config.getOptions().getHelpString(), ex);
-            } finally {
-                options.removeAllOptions(); // clean up listener refs
-            }
-        } else {
-            throw new Exception("Class named '" + className
-                    + "' is not an instance of " + requiredType.getName() + ".");
-        }
-        return classInstance;
-    }
+	public static Object cliStringToObject(String cliString, Class<?> requiredType, Option[] externalOptions)
+			throws Exception {
+		if (cliString.startsWith(FILE_PREFIX_STRING)) {
+			return new File(cliString.substring(FILE_PREFIX_STRING.length()));
+		}
+		if (cliString.startsWith(INMEM_PREFIX_STRING)) {
+			return cliString.substring(INMEM_PREFIX_STRING.length());
+		}
+		cliString = cliString.trim();
+		int firstSpaceIndex = cliString.indexOf(' ', 0);
+		String className;
+		String classOptions;
+		if (firstSpaceIndex > 0) {
+			className = cliString.substring(0, firstSpaceIndex);
+			classOptions = cliString.substring(firstSpaceIndex + 1, cliString.length());
+			classOptions = classOptions.trim();
+		} else {
+			className = cliString;
+			classOptions = "";
+		}
+		Class<?> classObject;
+		try {
+			classObject = Class.forName(className);
+		} catch (Throwable t1) {
+			try {
+				// try prepending default package
+				classObject = Class.forName(requiredType.getPackage().getName() + "." + className);
+				/*
+				 * } catch (Throwable t2) { try { // try prepending task package classObject =
+				 * Class.forName(Task.class.getPackage().getName() + "." + className);
+				 */} catch (Throwable t3) {
+				throw new Exception("Class not found: " + className);
+				// }
+			}
+		}
+		Object classInstance;
+		try {
+			classInstance = classObject.newInstance();
+		} catch (Exception ex) {
+			throw new Exception("Problem creating instance of class: " + className, ex);
+		}
+		if (requiredType.isInstance(classInstance)
+		// || ((classInstance instanceof Task) && requiredType.isAssignableFrom(((Task)
+		// classInstance).getTaskResultType()))
+		) {
+			Options options = new Options();
+			JavaCLIParser config = null;
+			if (externalOptions != null) {
+				for (Option option : externalOptions) {
+					options.addOption(option);
+				}
+			}
+			if (classInstance instanceof Configurable) {
+				config = new JavaCLIParser(classInstance, "");
+				Option[] objectOptions = config.getOptions().getOptionArray();
+				// Option[] objectOptions = ((Configurable)
+				// classInstance).getOptions().getOptionArray();
+				for (Option option : objectOptions) {
+					options.addOption(option);
+				}
+			}
+			try {
+				options.setViaCLIString(classOptions);
+			} catch (Exception ex) {
+				throw new Exception("Problem with options to '" + className + "'." + "\n\nValid options for "
+						+ className + ":\n" + config == null ? "" : config.getOptions().getHelpString(), ex);
+			} finally {
+				options.removeAllOptions(); // clean up listener refs
+			}
+		} else {
+			throw new Exception(
+					"Class named '" + className + "' is not an instance of " + requiredType.getName() + ".");
+		}
+		return classInstance;
+	}
 
-    //@Override
-    //public JComponent getEditComponent() {
-    //    return new ClassOptionEditComponent(this);
-    //}
+	// @Override
+	// public JComponent getEditComponent() {
+	// return new ClassOptionEditComponent(this);
+	// }
 }
diff --git a/moa/src/main/java/com/github/javacliparser/Configurable.java b/moa/src/main/java/com/github/javacliparser/Configurable.java
index 0fae2408d..98c181bab 100644
--- a/moa/src/main/java/com/github/javacliparser/Configurable.java
+++ b/moa/src/main/java/com/github/javacliparser/Configurable.java
@@ -1,18 +1,18 @@
 /*
  * Copyright 2007 University of Waikato.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 package com.github.javacliparser;
 
@@ -20,50 +20,50 @@
 
 /**
  * Configurable interface.
- * 
+ *
  * @author abifet
  */
 public interface Configurable extends Serializable {
-   
-    /**
-     * Gets the purpose of this object
-     *
-     * @return the string with the purpose of this object
-     */
-    //public String getPurposeString();
 
-    /**
-     * Gets the options of this object
-     *
-     * @return the options of this object
-     */
-    //public Options getOptions();
+	/**
+	 * Gets the purpose of this object
+	 *
+	 * @return the string with the purpose of this object
+	 */
+	// public String getPurposeString();
 
-    /**
-     * This method prepares this object for use.
-     *
-     */
-    //public void prepareForUse();
+	/**
+	 * Gets the options of this object
+	 *
+	 * @return the options of this object
+	 */
+	// public Options getOptions();
 
-    /**
-     * This method prepares this object for use.
-     *
-     * @param monitor the TaskMonitor to use
-     * @param repository  the ObjectRepository to use
-     */
-    //public void prepareForUse(TaskMonitor monitor, ObjectRepository repository);
+	/**
+	 * This method prepares this object for use.
+	 *
+	 */
+	// public void prepareForUse();
 
-    /**
-     * This method produces a copy of this object.
-     *
-     * @return a copy of this object
-     */
-    //public Configurable copy();
+	/**
+	 * This method prepares this object for use.
+	 *
+	 * @param monitor    the TaskMonitor to use
+	 * @param repository the ObjectRepository to use
+	 */
+	// public void prepareForUse(TaskMonitor monitor, ObjectRepository repository);
 
-    /**
-     * Gets the Command Line Interface text to create the object
-     *
-     * @return the Command Line Interface text to create the object
-     */
-    //public String getCLICreationString(Class<?> expectedType); 
+	/**
+	 * This method produces a copy of this object.
+	 *
+	 * @return a copy of this object
+	 */
+	// public Configurable copy();
+
+	/**
+	 * Gets the Command Line Interface text to create the object
+	 *
+	 * @return the Command Line Interface text to create the object
+	 */
+	// public String getCLICreationString(Class<?> expectedType);
 }
diff --git a/moa/src/main/java/com/github/javacliparser/FileOption.java b/moa/src/main/java/com/github/javacliparser/FileOption.java
index d706e498f..19b2b3b7f 100644
--- a/moa/src/main/java/com/github/javacliparser/FileOption.java
+++ b/moa/src/main/java/com/github/javacliparser/FileOption.java
@@ -1,18 +1,18 @@
 /*
  * Copyright 2007 University of Waikato.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 
 package com.github.javacliparser;
@@ -27,36 +27,36 @@
  */
 public class FileOption extends StringOption {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    protected String defaultFileExtension;
+	protected String defaultFileExtension;
 
-    protected boolean isOutputFile;
+	protected boolean isOutputFile;
 
-    public FileOption(String name, char cliChar, String purpose,
-            String defaultFileName, String defaultExtension, boolean isOutput) {
-        super(name, cliChar, purpose, defaultFileName);
-        this.defaultFileExtension = defaultExtension;
-        this.isOutputFile = isOutput;
-    }
+	public FileOption(String name, char cliChar, String purpose, String defaultFileName, String defaultExtension,
+			boolean isOutput) {
+		super(name, cliChar, purpose, defaultFileName);
+		this.defaultFileExtension = defaultExtension;
+		this.isOutputFile = isOutput;
+	}
 
-    public String getDefaultFileExtension() {
-        return this.defaultFileExtension;
-    }
+	public String getDefaultFileExtension() {
+		return this.defaultFileExtension;
+	}
 
-    public boolean isOutputFile() {
-        return this.isOutputFile;
-    }
+	public boolean isOutputFile() {
+		return this.isOutputFile;
+	}
 
-    public File getFile() {
-        if ((getValue() != null) && (getValue().length() > 0)) {
-            return new File(getValue());
-        }
-        return null;
-    }
+	public File getFile() {
+		if ((getValue() != null) && (getValue().length() > 0)) {
+			return new File(getValue());
+		}
+		return null;
+	}
 
-    //@Override
-    //public JComponent getEditComponent() {
-    //    return new FileOptionEditComponent(this);
-    //}
+	// @Override
+	// public JComponent getEditComponent() {
+	// return new FileOptionEditComponent(this);
+	// }
 }
diff --git a/moa/src/main/java/com/github/javacliparser/FlagOption.java b/moa/src/main/java/com/github/javacliparser/FlagOption.java
index ec51549a1..731a307e0 100644
--- a/moa/src/main/java/com/github/javacliparser/FlagOption.java
+++ b/moa/src/main/java/com/github/javacliparser/FlagOption.java
@@ -1,18 +1,18 @@
 /*
  * Copyright 2007 University of Waikato.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 
 package com.github.javacliparser;
@@ -25,52 +25,52 @@
  */
 public class FlagOption extends AbstractOption {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    protected boolean isSet = false;
+	protected boolean isSet = false;
 
-    public FlagOption(String name, char cliChar, String purpose) {
-        super(name, cliChar, purpose);
-    }
+	public FlagOption(String name, char cliChar, String purpose) {
+		super(name, cliChar, purpose);
+	}
 
-    public void setValue(boolean v) {
-        this.isSet = v;
-    }
+	public void setValue(boolean v) {
+		this.isSet = v;
+	}
 
-    public void set() {
-        setValue(true);
-    }
+	public void set() {
+		setValue(true);
+	}
 
-    public void unset() {
-        setValue(false);
-    }
+	public void unset() {
+		setValue(false);
+	}
 
-    public boolean isSet() {
-        return this.isSet;
-    }
+	public boolean isSet() {
+		return this.isSet;
+	}
 
-    @Override
-    public String getDefaultCLIString() {
-        return null;
-    }
+	@Override
+	public String getDefaultCLIString() {
+		return null;
+	}
 
-    @Override
-    public String getValueAsCLIString() {
-        return this.isSet ? "" : null;
-    }
+	@Override
+	public String getValueAsCLIString() {
+		return this.isSet ? "" : null;
+	}
 
-    @Override
-    public void setValueViaCLIString(String s) {
-        this.isSet = (s != null);
-    }
+	@Override
+	public void setValueViaCLIString(String s) {
+		this.isSet = (s != null);
+	}
 
-    @Override
-    public String getStateString() {
-        return this.isSet ? "true" : "false";
-    }
+	@Override
+	public String getStateString() {
+		return this.isSet ? "true" : "false";
+	}
 
-    //@Override
-    //public JComponent getEditComponent() {
-    //    return new FlagOptionEditComponent(this);
-    //}
+	// @Override
+	// public JComponent getEditComponent() {
+	// return new FlagOptionEditComponent(this);
+	// }
 }
diff --git a/moa/src/main/java/com/github/javacliparser/FloatOption.java b/moa/src/main/java/com/github/javacliparser/FloatOption.java
index 72dc33ab0..eda92b0a4 100644
--- a/moa/src/main/java/com/github/javacliparser/FloatOption.java
+++ b/moa/src/main/java/com/github/javacliparser/FloatOption.java
@@ -1,18 +1,18 @@
 /*
  * Copyright 2007 University of Waikato.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 
 package com.github.javacliparser;
@@ -25,82 +25,77 @@
  */
 public class FloatOption extends AbstractOption {
 
-    private static final long serialVersionUID = 1L;
-
-    protected double currentVal;
-
-    protected double defaultVal;
-
-    protected double minVal;
-
-    protected double maxVal;
-
-    public FloatOption(String name, char cliChar, String purpose,
-            double defaultVal) {
-        this(name, cliChar, purpose, defaultVal, Double.NEGATIVE_INFINITY,
-                Double.POSITIVE_INFINITY);
-    }
-
-    public FloatOption(String name, char cliChar, String purpose,
-            double defaultVal, double minVal, double maxVal) {
-        super(name, cliChar, purpose);
-        this.defaultVal = defaultVal;
-        this.minVal = minVal;
-        this.maxVal = maxVal;
-        resetToDefault();
-    }
-
-    public void setValue(double v) {
-        if (v < this.minVal) {
-            throw new IllegalArgumentException("Option " + getName()
-                    + " cannot be less than " + this.minVal
-                    + ", out of range: " + v);
-        }
-        if (v > this.maxVal) {
-            throw new IllegalArgumentException("Option " + getName()
-                    + " cannot be greater than " + this.maxVal
-                    + ", out of range: " + v);
-        }
-        this.currentVal = v;
-    }
-
-    public double getValue() {
-        return this.currentVal;
-    }
-
-    public double getMinValue() {
-        return this.minVal;
-    }
-
-    public double getMaxValue() {
-        return this.maxVal;
-    }
-
-    @Override
-    public String getDefaultCLIString() {
-        return doubleToCLIString(this.defaultVal);
-    }
-
-    @Override
-    public String getValueAsCLIString() {
-        return doubleToCLIString(this.currentVal);
-    }
-
-    @Override
-    public void setValueViaCLIString(String s) {
-        setValue(cliStringToDouble(s));
-    }
-
-    public static double cliStringToDouble(String s) {
-        return Double.parseDouble(s.trim());
-    }
-
-    public static String doubleToCLIString(double d) {
-        return Double.toString(d);
-    }
-
-    //@Override
-    //public JComponent getEditComponent() {
-    //    return new FloatOptionEditComponent(this);
-    //}
+	private static final long serialVersionUID = 1L;
+
+	protected double currentVal;
+
+	protected double defaultVal;
+
+	protected double minVal;
+
+	protected double maxVal;
+
+	public FloatOption(String name, char cliChar, String purpose, double defaultVal) {
+		this(name, cliChar, purpose, defaultVal, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY);
+	}
+
+	public FloatOption(String name, char cliChar, String purpose, double defaultVal, double minVal, double maxVal) {
+		super(name, cliChar, purpose);
+		this.defaultVal = defaultVal;
+		this.minVal = minVal;
+		this.maxVal = maxVal;
+		resetToDefault();
+	}
+
+	public void setValue(double v) {
+		if (v < this.minVal) {
+			throw new IllegalArgumentException(
+					"Option " + getName() + " cannot be less than " + this.minVal + ", out of range: " + v);
+		}
+		if (v > this.maxVal) {
+			throw new IllegalArgumentException(
+					"Option " + getName() + " cannot be greater than " + this.maxVal + ", out of range: " + v);
+		}
+		this.currentVal = v;
+	}
+
+	public double getValue() {
+		return this.currentVal;
+	}
+
+	public double getMinValue() {
+		return this.minVal;
+	}
+
+	public double getMaxValue() {
+		return this.maxVal;
+	}
+
+	@Override
+	public String getDefaultCLIString() {
+		return doubleToCLIString(this.defaultVal);
+	}
+
+	@Override
+	public String getValueAsCLIString() {
+		return doubleToCLIString(this.currentVal);
+	}
+
+	@Override
+	public void setValueViaCLIString(String s) {
+		setValue(cliStringToDouble(s));
+	}
+
+	public static double cliStringToDouble(String s) {
+		return Double.parseDouble(s.trim());
+	}
+
+	public static String doubleToCLIString(double d) {
+		return Double.toString(d);
+	}
+
+	// @Override
+	// public JComponent getEditComponent() {
+	// return new FloatOptionEditComponent(this);
+	// }
 }
diff --git a/moa/src/main/java/com/github/javacliparser/IntOption.java b/moa/src/main/java/com/github/javacliparser/IntOption.java
index e7cf6b24f..6c64104d7 100644
--- a/moa/src/main/java/com/github/javacliparser/IntOption.java
+++ b/moa/src/main/java/com/github/javacliparser/IntOption.java
@@ -1,18 +1,18 @@
 /*
  * Copyright 2007 University of Waikato.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 
 package com.github.javacliparser;
@@ -25,81 +25,77 @@
  */
 public class IntOption extends AbstractOption {
 
-    private static final long serialVersionUID = 1L;
-
-    protected int currentVal;
-
-    protected int defaultVal;
-
-    protected int minVal;
-
-    protected int maxVal;
-
-    public IntOption(String name, char cliChar, String purpose, int defaultVal) {
-        this(name, cliChar, purpose, defaultVal, Integer.MIN_VALUE,
-                Integer.MAX_VALUE);
-    }
-
-    public IntOption(String name, char cliChar, String purpose, int defaultVal,
-            int minVal, int maxVal) {
-        super(name, cliChar, purpose);
-        this.defaultVal = defaultVal;
-        this.minVal = minVal;
-        this.maxVal = maxVal;
-        resetToDefault();
-    }
-
-    public void setValue(int v) {
-        if (v < this.minVal) {
-            throw new IllegalArgumentException("Option " + getName()
-                    + " cannot be less than " + this.minVal
-                    + ", out of range: " + v);
-        }
-        if (v > this.maxVal) {
-            throw new IllegalArgumentException("Option " + getName()
-                    + " cannot be greater than " + this.maxVal
-                    + ", out of range: " + v);
-        }
-        this.currentVal = v;
-    }
-
-    public int getValue() {
-        return this.currentVal;
-    }
-
-    public int getMinValue() {
-        return this.minVal;
-    }
-
-    public int getMaxValue() {
-        return this.maxVal;
-    }
-
-    @Override
-    public String getDefaultCLIString() {
-        return intToCLIString(this.defaultVal);
-    }
-
-    @Override
-    public String getValueAsCLIString() {
-        return intToCLIString(this.currentVal);
-    }
-
-    @Override
-    public void setValueViaCLIString(String s) {
-        setValue(cliStringToInt(s));
-    }
-
-    public static int cliStringToInt(String s) {
-        return Integer.parseInt(s.trim());
-    }
-
-    public static String intToCLIString(int i) {
-        return Integer.toString(i);
-    }
-
-    //@Override
-    //public JComponent getEditComponent() {
-    //    return new IntOptionEditComponent(this);
-    //}
+	private static final long serialVersionUID = 1L;
+
+	protected int currentVal;
+
+	protected int defaultVal;
+
+	protected int minVal;
+
+	protected int maxVal;
+
+	public IntOption(String name, char cliChar, String purpose, int defaultVal) {
+		this(name, cliChar, purpose, defaultVal, Integer.MIN_VALUE, Integer.MAX_VALUE);
+	}
+
+	public IntOption(String name, char cliChar, String purpose, int defaultVal, int minVal, int maxVal) {
+		super(name, cliChar, purpose);
+		this.defaultVal = defaultVal;
+		this.minVal = minVal;
+		this.maxVal = maxVal;
+		resetToDefault();
+	}
+
+	public void setValue(int v) {
+		if (v < this.minVal) {
+			throw new IllegalArgumentException(
+					"Option " + getName() + " cannot be less than " + this.minVal + ", out of range: " + v);
+		}
+		if (v > this.maxVal) {
+			throw new IllegalArgumentException(
+					"Option " + getName() + " cannot be greater than " + this.maxVal + ", out of range: " + v);
+		}
+		this.currentVal = v;
+	}
+
+	public int getValue() {
+		return this.currentVal;
+	}
+
+	public int getMinValue() {
+		return this.minVal;
+	}
+
+	public int getMaxValue() {
+		return this.maxVal;
+	}
+
+	@Override
+	public String getDefaultCLIString() {
+		return intToCLIString(this.defaultVal);
+	}
+
+	@Override
+	public String getValueAsCLIString() {
+		return intToCLIString(this.currentVal);
+	}
+
+	@Override
+	public void setValueViaCLIString(String s) {
+		setValue(cliStringToInt(s));
+	}
+
+	public static int cliStringToInt(String s) {
+		return Integer.parseInt(s.trim());
+	}
+
+	public static String intToCLIString(int i) {
+		return Integer.toString(i);
+	}
+
+	// @Override
+	// public JComponent getEditComponent() {
+	// return new IntOptionEditComponent(this);
+	// }
 }
diff --git a/moa/src/main/java/com/github/javacliparser/JavaCLIParser.java b/moa/src/main/java/com/github/javacliparser/JavaCLIParser.java
index 68191078c..269ae7b11 100644
--- a/moa/src/main/java/com/github/javacliparser/JavaCLIParser.java
+++ b/moa/src/main/java/com/github/javacliparser/JavaCLIParser.java
@@ -1,18 +1,18 @@
 /*
  * Copyright 2007 University of Waikato.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 
 package com.github.javacliparser;
@@ -32,103 +32,101 @@
  */
 public class JavaCLIParser implements Serializable {
 
-    public Object handler;
-    
-    public JavaCLIParser(Object c, String cliString) {
-        this.handler = c;
-    }
-    
-    private static final long serialVersionUID = 1L;
+	public Object handler;
+
+	public JavaCLIParser(Object c, String cliString) {
+		this.handler = c;
+	}
 
-    /** Options to handle */
-    protected Options options;
+	private static final long serialVersionUID = 1L;
 
-    /** Dictionary with option texts and objects */
-    protected Map<String, Object> classOptionNamesToPreparedObjects;
+	/** Options to handle */
+	protected Options options;
 
+	/** Dictionary with option texts and objects */
+	protected Map<String, Object> classOptionNamesToPreparedObjects;
 
-    public String getPurposeString() {
-        return "Anonymous object: purpose undocumented.";
-    }
+	public String getPurposeString() {
+		return "Anonymous object: purpose undocumented.";
+	}
 
-    public Options getOptions() {
-        if (this.options == null) {
-            this.options = new Options();
-            Option[] myOptions = discoverOptionsViaReflection();
-            for (Option option : myOptions) {
-                this.options.addOption(option);
-            }
-        }
-        return this.options;
-    }
+	public Options getOptions() {
+		if (this.options == null) {
+			this.options = new Options();
+			Option[] myOptions = discoverOptionsViaReflection();
+			for (Option option : myOptions) {
+				this.options.addOption(option);
+			}
+		}
+		return this.options;
+	}
 
-    /**
-     * Gets the options of this class via reflection.
-     *
-     * @return an array of options
-     */
-    public Option[] discoverOptionsViaReflection() {
-        //Class<? extends AbstractOptionHandler> c = this.getClass();
-        Class c = this.handler.getClass();
-        Field[] fields = c.getFields();
-        List<Option> optList = new LinkedList<Option>();
-        for (Field field : fields) {
-            Class<?> fType = field.getType();
-            if (fType.getName().endsWith("Option")) {
-                if (Option.class.isAssignableFrom(fType)) {
-                    Option oVal = null;
-                    try {
-                        field.setAccessible(true);
-                        oVal = (Option) field.get(this.handler);
-                    } catch (IllegalAccessException ignored) {
-                        // cannot access this field
-                    }
-                    if (oVal != null) {
-                        optList.add(oVal);
-                    }
-                }
-            }
-        }
-        return optList.toArray(new Option[optList.size()]);
-    }
+	/**
+	 * Gets the options of this class via reflection.
+	 *
+	 * @return an array of options
+	 */
+	public Option[] discoverOptionsViaReflection() {
+		// Class<? extends AbstractOptionHandler> c = this.getClass();
+		Class c = this.handler.getClass();
+		Field[] fields = c.getFields();
+		List<Option> optList = new LinkedList<>();
+		for (Field field : fields) {
+			Class<?> fType = field.getType();
+			if (fType.getName().endsWith("Option")) {
+				if (Option.class.isAssignableFrom(fType)) {
+					Option oVal = null;
+					try {
+						field.setAccessible(true);
+						oVal = (Option) field.get(this.handler);
+					} catch (IllegalAccessException ignored) {
+						// cannot access this field
+					}
+					if (oVal != null) {
+						optList.add(oVal);
+					}
+				}
+			}
+		}
+		return optList.toArray(new Option[optList.size()]);
+	}
 
-    /**
-     * Prepares the options of this class.
-     * 
-     * @param monitor the TaskMonitor to use
-     * @param repository  the ObjectRepository to use
-     */
-    public void prepareClassOptions() { //TaskMonitor monitor,
-            //ObjectRepository repository) {
-        this.classOptionNamesToPreparedObjects = null;
-        Option[] optionArray = getOptions().getOptionArray();
-        for (Option option : optionArray) {
-            if (option instanceof ClassOption) {
-                ClassOption classOption = (ClassOption) option;
-               // monitor.setCurrentActivity("Materializing option "
-               //         + classOption.getName() + "...", -1.0);
-                Object optionObj = classOption.materializeObject(); //monitor,
-                        //repository);
-                //if (monitor.taskShouldAbort()) {
-                //    return;
-                //}
-                if (optionObj instanceof Configurable) {
-                 //   monitor.setCurrentActivity("Preparing option "
-                 //           + classOption.getName() + "...", -1.0);
-                    JavaCLIParser config = new JavaCLIParser(optionObj, "");
-                    //((Configurable) optionObj).prepareForUse(); //monitor,
-                            //repository);
-                 //   if (monitor.taskShouldAbort()) {
-                 //       return;
-                 //   }
-                }
-                if (this.classOptionNamesToPreparedObjects == null) {
-                    this.classOptionNamesToPreparedObjects = new HashMap<String, Object>();
-                }
-                this.classOptionNamesToPreparedObjects.put(option.getName(),
-                        optionObj);
-            }
-        }
-    }
+	/**
+	 * Prepares the options of this class.
+	 * 
+	 * @param monitor    the TaskMonitor to use
+	 * @param repository the ObjectRepository to use
+	 */
+	public void prepareClassOptions() { // TaskMonitor monitor,
+		// ObjectRepository repository) {
+		this.classOptionNamesToPreparedObjects = null;
+		Option[] optionArray = getOptions().getOptionArray();
+		for (Option option : optionArray) {
+			if (option instanceof ClassOption) {
+				ClassOption classOption = (ClassOption) option;
+				// monitor.setCurrentActivity("Materializing option "
+				// + classOption.getName() + "...", -1.0);
+				Object optionObj = classOption.materializeObject(); // monitor,
+				// repository);
+				// if (monitor.taskShouldAbort()) {
+				// return;
+				// }
+				if (optionObj instanceof Configurable) {
+					// monitor.setCurrentActivity("Preparing option "
+					// + classOption.getName() + "...", -1.0);
+					// JavaCLIParser config = new JavaCLIParser(optionObj, "");
+					// ((Configurable) optionObj).prepareForUse(); //monitor,
+					// repository);
+					// if (monitor.taskShouldAbort()) {
+					// return;
+					// }
+				}
+				if (this.classOptionNamesToPreparedObjects == null) {
+					this.classOptionNamesToPreparedObjects = new HashMap<>();
+				}
+				this.classOptionNamesToPreparedObjects.put(option.getName(), optionObj);
+			}
+		}
+	}
 
 }
diff --git a/moa/src/main/java/com/github/javacliparser/ListOption.java b/moa/src/main/java/com/github/javacliparser/ListOption.java
index 6572bff6a..389a33966 100644
--- a/moa/src/main/java/com/github/javacliparser/ListOption.java
+++ b/moa/src/main/java/com/github/javacliparser/ListOption.java
@@ -1,18 +1,18 @@
 /*
  * Copyright 2007 University of Waikato.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 
 package com.github.javacliparser;
@@ -25,76 +25,74 @@
  */
 public class ListOption extends AbstractOption {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    protected Option[] currentList;
+	protected Option[] currentList;
 
-    protected Option expectedType;
+	protected Option expectedType;
 
-    protected Option[] defaultList;
+	protected Option[] defaultList;
 
-    protected char separatorChar;
+	protected char separatorChar;
 
-    public ListOption(String name, char cliChar, String purpose,
-            Option expectedType, Option[] defaultList, char separatorChar) {
-        super(name, cliChar, purpose);
-        this.expectedType = expectedType;
-        this.defaultList = defaultList.clone();
-        this.separatorChar = separatorChar;
-        resetToDefault();
-    }
+	public ListOption(String name, char cliChar, String purpose, Option expectedType, Option[] defaultList,
+			char separatorChar) {
+		super(name, cliChar, purpose);
+		this.expectedType = expectedType;
+		this.defaultList = defaultList.clone();
+		this.separatorChar = separatorChar;
+		resetToDefault();
+	}
 
-    public void setList(Option[] optList) {
-        Option[] newArray = new Option[optList.length];
-        for (int i = 0; i < optList.length; i++) {
-            newArray[i] = this.expectedType.copy();
-            newArray[i].setValueViaCLIString(optList[i].getValueAsCLIString());
-        }
-        this.currentList = newArray;
-    }
+	public void setList(Option[] optList) {
+		Option[] newArray = new Option[optList.length];
+		for (int i = 0; i < optList.length; i++) {
+			newArray[i] = this.expectedType.copy();
+			newArray[i].setValueViaCLIString(optList[i].getValueAsCLIString());
+		}
+		this.currentList = newArray;
+	}
 
-    public Option[] getList() {
-        return this.currentList.clone();
-    }
+	public Option[] getList() {
+		return this.currentList.clone();
+	}
 
-    @Override
-    public String getDefaultCLIString() {
-        return optionArrayToCLIString(this.defaultList, this.separatorChar);
-    }
+	@Override
+	public String getDefaultCLIString() {
+		return optionArrayToCLIString(this.defaultList, this.separatorChar);
+	}
 
-    @Override
-    public String getValueAsCLIString() {
-        return optionArrayToCLIString(this.currentList, this.separatorChar);
-    }
+	@Override
+	public String getValueAsCLIString() {
+		return optionArrayToCLIString(this.currentList, this.separatorChar);
+	}
 
-    @Override
-    public void setValueViaCLIString(String s) {
-        this.currentList = cliStringToOptionArray(s, this.separatorChar,
-                this.expectedType);
-    }
+	@Override
+	public void setValueViaCLIString(String s) {
+		this.currentList = cliStringToOptionArray(s, this.separatorChar, this.expectedType);
+	}
 
-    public static Option[] cliStringToOptionArray(String s, char separator,
-            Option expectedType) {
-	 if (s == null || s.length() < 1) {
-             return new Option[0];
-         }
-        String[] subStrings = s.split(Character.toString(separator));
-        Option[] options = new Option[subStrings.length];
-        for (int i = 0; i < options.length; i++) {
-            options[i] = expectedType.copy();
-            options[i].setValueViaCLIString(subStrings[i]);
-        }
-        return options;
-    }
+	public static Option[] cliStringToOptionArray(String s, char separator, Option expectedType) {
+		if (s == null || s.length() < 1) {
+			return new Option[0];
+		}
+		String[] subStrings = s.split(Character.toString(separator));
+		Option[] options = new Option[subStrings.length];
+		for (int i = 0; i < options.length; i++) {
+			options[i] = expectedType.copy();
+			options[i].setValueViaCLIString(subStrings[i]);
+		}
+		return options;
+	}
 
-    public static String optionArrayToCLIString(Option[] os, char separator) {
-        StringBuilder sb = new StringBuilder();
-        for (int i = 0; i < os.length; i++) {
-            if (i > 0) {
-                sb.append(separator);
-            }
-            sb.append(os[i].getValueAsCLIString());
-        }
-        return sb.toString();
-    }
+	public static String optionArrayToCLIString(Option[] os, char separator) {
+		StringBuilder sb = new StringBuilder();
+		for (int i = 0; i < os.length; i++) {
+			if (i > 0) {
+				sb.append(separator);
+			}
+			sb.append(os[i].getValueAsCLIString());
+		}
+		return sb.toString();
+	}
 }
diff --git a/moa/src/main/java/com/github/javacliparser/MultiChoiceOption.java b/moa/src/main/java/com/github/javacliparser/MultiChoiceOption.java
index 18f42c4b9..11ce97be1 100644
--- a/moa/src/main/java/com/github/javacliparser/MultiChoiceOption.java
+++ b/moa/src/main/java/com/github/javacliparser/MultiChoiceOption.java
@@ -1,18 +1,18 @@
 /*
  * Copyright 2007 University of Waikato.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 
 package com.github.javacliparser;
@@ -25,88 +25,87 @@
  */
 public class MultiChoiceOption extends AbstractOption {
 
-    private static final long serialVersionUID = 1L;
-
-    protected String[] optionLabels;
-
-    protected String[] optionDescriptions;
-
-    protected int defaultOptionIndex;
-
-    protected int chosenOptionIndex;
-
-    public MultiChoiceOption(String name, char cliChar, String purpose,
-            String[] optionLabels, String[] optionDescriptions,
-            int defaultOptionIndex) {
-        super(name, cliChar, purpose);
-        if (optionLabels.length != optionDescriptions.length) {
-            throw new IllegalArgumentException("Labels/descriptions mismatch.");
-        }
-        this.optionLabels = optionLabels.clone();
-        this.optionDescriptions = optionDescriptions.clone();
-        this.defaultOptionIndex = defaultOptionIndex;
-        resetToDefault();
-    }
-
-    @Override
-    public String getDefaultCLIString() {
-        return this.optionLabels[this.defaultOptionIndex];
-    }
-
-    @Override
-    public String getValueAsCLIString() {
-        return getChosenLabel();
-    }
-
-    @Override
-    public void setValueViaCLIString(String s) {
-        try {
-            setChosenIndex(Integer.parseInt(s.trim()));
-        } catch (NumberFormatException nfe) {
-            setChosenLabel(s);
-        }
-    }
-
-    public void setChosenLabel(String label) {
-        label = label.trim();
-        for (int i = 0; i < this.optionLabels.length; i++) {
-            if (this.optionLabels[i].equals(label)) {
-                this.chosenOptionIndex = i;
-                return;
-            }
-        }
-        throw new IllegalArgumentException("Label not recognised: " + label);
-    }
-
-    public void setChosenIndex(int index) {
-        if ((index < 0) || (index >= this.optionLabels.length)) {
-            throw new IndexOutOfBoundsException();
-        }
-        this.chosenOptionIndex = index;
-    }
-
-    public String[] getOptionLabels() {
-        return this.optionLabels.clone();
-    }
-    
-    public String[] getOptionDescriptions() {
-        return this.optionDescriptions.clone();
-    }
-    
-    public int getDefaultOptionIndex() {
-        return this.defaultOptionIndex;
-    }
-
-    public String getChosenLabel() {
-        return this.optionLabels[this.chosenOptionIndex];
-    }
-
-    public int getChosenIndex() {
-        return this.chosenOptionIndex;
-    }
-
-    //@Override
-    //public JComponent getEditComponent() {
-    //    return new MultiChoiceOptionEditComponent(this);
-    //}
+	private static final long serialVersionUID = 1L;
+
+	protected String[] optionLabels;
+
+	protected String[] optionDescriptions;
+
+	protected int defaultOptionIndex;
+
+	protected int chosenOptionIndex;
+
+	public MultiChoiceOption(String name, char cliChar, String purpose, String[] optionLabels,
+			String[] optionDescriptions, int defaultOptionIndex) {
+		super(name, cliChar, purpose);
+		if (optionLabels.length != optionDescriptions.length) {
+			throw new IllegalArgumentException("Labels/descriptions mismatch.");
+		}
+		this.optionLabels = optionLabels.clone();
+		this.optionDescriptions = optionDescriptions.clone();
+		this.defaultOptionIndex = defaultOptionIndex;
+		resetToDefault();
+	}
+
+	@Override
+	public String getDefaultCLIString() {
+		return this.optionLabels[this.defaultOptionIndex];
+	}
+
+	@Override
+	public String getValueAsCLIString() {
+		return getChosenLabel();
+	}
+
+	@Override
+	public void setValueViaCLIString(String s) {
+		try {
+			setChosenIndex(Integer.parseInt(s.trim()));
+		} catch (NumberFormatException nfe) {
+			setChosenLabel(s);
+		}
+	}
+
+	public void setChosenLabel(String label) {
+		label = label.trim();
+		for (int i = 0; i < this.optionLabels.length; i++) {
+			if (this.optionLabels[i].equals(label)) {
+				this.chosenOptionIndex = i;
+				return;
+			}
+		}
+		throw new IllegalArgumentException("Label not recognised: " + label);
+	}
+
+	public void setChosenIndex(int index) {
+		if ((index < 0) || (index >= this.optionLabels.length)) {
+			throw new IndexOutOfBoundsException();
+		}
+		this.chosenOptionIndex = index;
+	}
+
+	public String[] getOptionLabels() {
+		return this.optionLabels.clone();
+	}
+
+	public String[] getOptionDescriptions() {
+		return this.optionDescriptions.clone();
+	}
+
+	public int getDefaultOptionIndex() {
+		return this.defaultOptionIndex;
+	}
+
+	public String getChosenLabel() {
+		return this.optionLabels[this.chosenOptionIndex];
+	}
+
+	public int getChosenIndex() {
+		return this.chosenOptionIndex;
+	}
+
+	// @Override
+	// public JComponent getEditComponent() {
+	// return new MultiChoiceOptionEditComponent(this);
+	// }
 }
diff --git a/moa/src/main/java/com/github/javacliparser/Option.java b/moa/src/main/java/com/github/javacliparser/Option.java
index aaa59d168..02115b85a 100644
--- a/moa/src/main/java/com/github/javacliparser/Option.java
+++ b/moa/src/main/java/com/github/javacliparser/Option.java
@@ -1,18 +1,18 @@
 /*
  * Copyright 2007 University of Waikato.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 
 package com.github.javacliparser;
@@ -20,79 +20,79 @@
 import java.io.Serializable;
 
 /**
- * Interface representing an option or parameter. 
+ * Interface representing an option or parameter.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $ 
+ * @version $Revision: 7 $
  */
 public interface Option extends Serializable {
 
-    /**
-     * Gets the name of this option
-     *
-     * @return the name of this option
-     */
-    public String getName();
+	/**
+	 * Gets the name of this option
+	 *
+	 * @return the name of this option
+	 */
+	String getName();
 
-    /**
-     * Gets the Command Line Interface text of this option
-     *
-     * @return the Command Line Interface text
-     */
-    public char getCLIChar();
+	/**
+	 * Gets the Command Line Interface text of this option
+	 *
+	 * @return the Command Line Interface text
+	 */
+	char getCLIChar();
 
-    /**
-     * Gets the purpose of this option
-     *
-     * @return the purpose of this option
-     */
-    public String getPurpose();
+	/**
+	 * Gets the purpose of this option
+	 *
+	 * @return the purpose of this option
+	 */
+	String getPurpose();
 
-    /**
-     * Gets the Command Line Interface text
-     *
-     * @return the Command Line Interface text
-     */
-    public String getDefaultCLIString();
+	/**
+	 * Gets the Command Line Interface text
+	 *
+	 * @return the Command Line Interface text
+	 */
+	String getDefaultCLIString();
 
-    /**
-     * Sets value of this option via the Command Line Interface text
-     *
-     * @param s the Command Line Interface text
-     */
-    public void setValueViaCLIString(String s);
+	/**
+	 * Sets value of this option via the Command Line Interface text
+	 *
+	 * @param s the Command Line Interface text
+	 */
+	void setValueViaCLIString(String s);
 
-    /**
-     * Gets the value of a Command Line Interface text as a string
-     *
-     * @return the string with the value of the Command Line Interface text
-     */
-    public String getValueAsCLIString();
+	/**
+	 * Gets the value of a Command Line Interface text as a string
+	 *
+	 * @return the string with the value of the Command Line Interface text
+	 */
+	String getValueAsCLIString();
 
-    /**
-     * Resets this option to the default value
-     *
-     */
-    public void resetToDefault();
+	/**
+	 * Resets this option to the default value
+	 *
+	 */
+	void resetToDefault();
 
-    /**
-     * Gets the state of this option in human readable form
-     *
-     * @return the string with state of this option in human readable form
-     */
-    public String getStateString();
+	/**
+	 * Gets the state of this option in human readable form
+	 *
+	 * @return the string with state of this option in human readable form
+	 */
+	String getStateString();
 
-    /**
-     * Gets a copy of this option
-     *
-     * @return the copy of this option
-     */
-    public Option copy();
+	/**
+	 * Gets a copy of this option
+	 *
+	 * @return the copy of this option
+	 */
+	Option copy();
 
-    /**
-     * Gets the GUI component to edit
-     *
-     * @return the component to edit
-     */
-    //public JComponent getEditComponent();
+	/**
+	 * Gets the GUI component to edit
+	 *
+	 * @return the component to edit
+	 */
+	// public JComponent getEditComponent();
 }
diff --git a/moa/src/main/java/com/github/javacliparser/Options.java b/moa/src/main/java/com/github/javacliparser/Options.java
index 53c95b35d..0d6961a76 100644
--- a/moa/src/main/java/com/github/javacliparser/Options.java
+++ b/moa/src/main/java/com/github/javacliparser/Options.java
@@ -1,18 +1,18 @@
 /*
  * Copyright 2007 University of Waikato.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 
 package com.github.javacliparser;
@@ -27,241 +27,229 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class Options implements Serializable {//extends AbstractMOAObject {
-
-    private static final long serialVersionUID = 1L;
-
-    protected List<Option> optionList = new LinkedList<Option>();
-
-    public void addOption(Option opt) {
-        if (getOption(opt.getName()) != null) {
-            throw new IllegalArgumentException("Duplicate option name: "
-                    + opt.getName());
-        }
-        if (getOption(opt.getCLIChar()) != null) {
-            throw new IllegalArgumentException(
-                    "Duplicate option command line character: "
-                    + opt.getCLIChar());
-        }
-        this.optionList.add(opt);
-    }
-
-    public int numOptions() {
-        return this.optionList.size();
-    }
-
-    public Option getOption(String optName) {
-        for (Option option : this.optionList) {
-            if (optName.equals(option.getName())) {
-                return option;
-            }
-        }
-        return null;
-    }
-
-    public Option getOption(char cliChar) {
-        for (Option option : this.optionList) {
-            if (option.getCLIChar() == cliChar) {
-                return option;
-            }
-        }
-        return null;
-    }
-
-    public Option[] getOptionArray() {
-        return this.optionList.toArray(new Option[this.optionList.size()]);
-    }
-
-    public void removeOption(String optName) {
-        removeOption(getOption(optName));
-    }
-
-    public void removeOption(Option opt) {
-        this.optionList.remove(opt);
-    }
-
-    public void removeAllOptions() {
-        this.optionList = new LinkedList<Option>();
-    }
-
-    public void resetToDefaults() {
-        for (Option option : this.optionList) {
-            option.resetToDefault();
-        }
-    }
-
-    public void setViaCLIString(String cliString) {
-        cliString = cliString.trim();
-        while (cliString.length() > 0) {
-            if (cliString.startsWith("-")) {
-                boolean flagClusterFound = false;
-                String optionString = null;
-                int nextSpaceIndex = cliString.indexOf(' ', 1);
-                Option opt;
-                if (nextSpaceIndex > 0) {
-                    optionString = cliString.substring(1, nextSpaceIndex);
-                } else {
-                    optionString = cliString.substring(1, cliString.length());
-                    nextSpaceIndex = cliString.length() - 1;
-                }
-                if (optionString.length() == 1) {
-                    opt = getOption(optionString.charAt(0));
-                } else {
-                    opt = getOption(optionString);
-                    if (opt == null) {
-                        // check for cluster of flags
-                        flagClusterFound = true;
-                        for (int i = 0; i < optionString.length(); i++) {
-                            opt = getOption(optionString.charAt(i));
-                            if (!(opt instanceof FlagOption)) {
-                                flagClusterFound = false;
-                                opt = null;
-                                break;
-                            }
-                        }
-                        if (flagClusterFound) {
-                            for (int i = 0; i < optionString.length(); i++) {
-                                opt = getOption(optionString.charAt(i));
-                                opt.setValueViaCLIString("");
-                            }
-                            cliString = cliString.substring(nextSpaceIndex + 1,
-                                    cliString.length());
-                        }
-                    }
-                }
-                if (!flagClusterFound) {
-                    if (opt != null) {
-                        String parameters = cliString.substring(
-                                nextSpaceIndex + 1, cliString.length());
-                        if (opt instanceof FlagOption) {
-                            opt.setValueViaCLIString("");
-                            cliString = parameters;
-                        } else {
-                            String[] paramSplit = splitParameterFromRemainingOptions(parameters);
-                            opt.setValueViaCLIString(paramSplit[0]);
-                            cliString = paramSplit[1];
-                        }
-                    } else {
-                        throw new IllegalArgumentException("Unknown option: -"
-                                + optionString);
-                    }
-                }
-            } else {
-                throw new IllegalArgumentException("Expecting option, found: '"
-                        + cliString + "'.");
-            }
-            cliString = cliString.trim();
-        }
-    }
-
-    public String getAsCLIString() {
-        StringBuilder commandLine = new StringBuilder();
-        for (Option option : this.optionList) {
-            String value = option.getValueAsCLIString();
-            if ((value != null) && !value.equals(option.getDefaultCLIString())) {
-                if (commandLine.length() > 0) {
-                    commandLine.append(" ");
-                }
-                commandLine.append("-" + option.getCLIChar());
-                if (value.length() > 0) {
-                    if (value.indexOf(' ') < 0) {
-                        commandLine.append(" " + value);
-                    } else {
-                        commandLine.append(" (" + value + ")");
-                    }
-                }
-            }
-        }
-        return commandLine.toString();
-    }
-
-    public String getHelpString() {
-        StringBuilder sb = new StringBuilder();
-        getHelp(sb, 0);
-        return sb.toString();
-    }
-
-    public void getHelp(StringBuilder sb, int indent) {
-        if (optionList.size() > 0) {
-            for (Option option : optionList) {
-                StringUtils.appendIndent(sb, indent);
-                sb.append('-');
-                sb.append(option.getCLIChar());
-                sb.append(' ');
-                sb.append(option.getName());
-                String defaultString = option.getDefaultCLIString();
-                if (defaultString != null && defaultString.length() > 0) {
-                    sb.append(" (default: ");
-                    sb.append(defaultString);
-                    sb.append(')');
-                }
-                StringUtils.appendNewline(sb);
-                StringUtils.appendIndent(sb, indent);
-                sb.append(option.getPurpose());
-                StringUtils.appendNewline(sb);
-            }
-        } else {
-            StringUtils.appendIndented(sb, indent, "No options.");
-        }
-    }
-
-    /**
-     * Internal method that splits a string into two parts - the parameter for
-     * the current option, and the remaining options.
-     *
-     * @param cliString
-     *            the command line string, beginning at an option parameter
-     * @return an array of two strings - the first is the option paramter, the
-     *         second is the remaining cli string
-     */
-    protected static String[] splitParameterFromRemainingOptions(
-            String cliString) {
-        String[] paramSplit = new String[2];
-        cliString = cliString.trim();
-        if (cliString.startsWith("\"") || cliString.startsWith("'")) {
-            int endQuoteIndex = cliString.indexOf(cliString.charAt(0), 1);
-            if (endQuoteIndex < 0) {
-                throw new IllegalArgumentException(
-                        "Quotes not terminated correctly.");
-            }
-            paramSplit[0] = cliString.substring(1, endQuoteIndex);
-            paramSplit[1] = cliString.substring(endQuoteIndex + 1, cliString.length());
-        } else if (cliString.startsWith("(")) {
-            int bracketsOpen = 1;
-            int currPos = 1;
-            int nextCloseIndex = cliString.indexOf(")", currPos);
-            int nextOpenIndex = cliString.indexOf("(", currPos);
-            while (bracketsOpen != 0) {
-                if (nextCloseIndex < 0) {
-                    throw new IllegalArgumentException("Brackets do not match.");
-                } else if ((nextOpenIndex < 0)
-                        || (nextCloseIndex < nextOpenIndex)) {
-                    bracketsOpen--;
-                    currPos = nextCloseIndex + 1;
-                    nextCloseIndex = cliString.indexOf(")", currPos);
-                } else {
-                    bracketsOpen++;
-                    currPos = nextOpenIndex + 1;
-                    nextOpenIndex = cliString.indexOf("(", currPos);
-                }
-            }
-            paramSplit[0] = cliString.substring(1, currPos - 1);
-            paramSplit[1] = cliString.substring(currPos, cliString.length());
-        } else {
-            int firstSpaceIndex = cliString.indexOf(" ", 0);
-            if (firstSpaceIndex >= 0) {
-                paramSplit[0] = cliString.substring(0, firstSpaceIndex);
-                paramSplit[1] = cliString.substring(firstSpaceIndex + 1,
-                        cliString.length());
-            } else {
-                paramSplit[0] = cliString;
-                paramSplit[1] = "";
-            }
-        }
-        return paramSplit;
-    }
-
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
+public class Options implements Serializable {// extends AbstractMOAObject {
+
+	private static final long serialVersionUID = 1L;
+
+	protected List<Option> optionList = new LinkedList<>();
+
+	public void addOption(Option opt) {
+		if (getOption(opt.getName()) != null) {
+			throw new IllegalArgumentException("Duplicate option name: " + opt.getName());
+		}
+		if (getOption(opt.getCLIChar()) != null) {
+			throw new IllegalArgumentException("Duplicate option command line character: " + opt.getCLIChar());
+		}
+		this.optionList.add(opt);
+	}
+
+	public int numOptions() {
+		return this.optionList.size();
+	}
+
+	public Option getOption(String optName) {
+		for (Option option : this.optionList) {
+			if (optName.equals(option.getName())) {
+				return option;
+			}
+		}
+		return null;
+	}
+
+	public Option getOption(char cliChar) {
+		for (Option option : this.optionList) {
+			if (option.getCLIChar() == cliChar) {
+				return option;
+			}
+		}
+		return null;
+	}
+
+	public Option[] getOptionArray() {
+		return this.optionList.toArray(new Option[this.optionList.size()]);
+	}
+
+	public void removeOption(String optName) {
+		removeOption(getOption(optName));
+	}
+
+	public void removeOption(Option opt) {
+		this.optionList.remove(opt);
+	}
+
+	public void removeAllOptions() {
+		this.optionList = new LinkedList<>();
+	}
+
+	public void resetToDefaults() {
+		for (Option option : this.optionList) {
+			option.resetToDefault();
+		}
+	}
+
+	public void setViaCLIString(String cliString) {
+		cliString = cliString.trim();
+		while (cliString.length() > 0) {
+			if (cliString.startsWith("-")) {
+				boolean flagClusterFound = false;
+				String optionString = null;
+				int nextSpaceIndex = cliString.indexOf(' ', 1);
+				Option opt;
+				if (nextSpaceIndex > 0) {
+					optionString = cliString.substring(1, nextSpaceIndex);
+				} else {
+					optionString = cliString.substring(1, cliString.length());
+					nextSpaceIndex = cliString.length() - 1;
+				}
+				if (optionString.length() == 1) {
+					opt = getOption(optionString.charAt(0));
+				} else {
+					opt = getOption(optionString);
+					if (opt == null) {
+						// check for cluster of flags
+						flagClusterFound = true;
+						for (int i = 0; i < optionString.length(); i++) {
+							opt = getOption(optionString.charAt(i));
+							if (!(opt instanceof FlagOption)) {
+								flagClusterFound = false;
+								opt = null;
+								break;
+							}
+						}
+						if (flagClusterFound) {
+							for (int i = 0; i < optionString.length(); i++) {
+								opt = getOption(optionString.charAt(i));
+								opt.setValueViaCLIString("");
+							}
+							cliString = cliString.substring(nextSpaceIndex + 1, cliString.length());
+						}
+					}
+				}
+				if (!flagClusterFound) {
+					if (opt != null) {
+						String parameters = cliString.substring(nextSpaceIndex + 1, cliString.length());
+						if (opt instanceof FlagOption) {
+							opt.setValueViaCLIString("");
+							cliString = parameters;
+						} else {
+							String[] paramSplit = splitParameterFromRemainingOptions(parameters);
+							opt.setValueViaCLIString(paramSplit[0]);
+							cliString = paramSplit[1];
+						}
+					} else {
+						throw new IllegalArgumentException("Unknown option: -" + optionString);
+					}
+				}
+			} else {
+				throw new IllegalArgumentException("Expecting option, found: '" + cliString + "'.");
+			}
+			cliString = cliString.trim();
+		}
+	}
+
+	public String getAsCLIString() {
+		StringBuilder commandLine = new StringBuilder();
+		for (Option option : this.optionList) {
+			String value = option.getValueAsCLIString();
+			if ((value != null) && !value.equals(option.getDefaultCLIString())) {
+				if (commandLine.length() > 0) {
+					commandLine.append(" ");
+				}
+				commandLine.append("-" + option.getCLIChar());
+				if (value.length() > 0) {
+					if (value.indexOf(' ') < 0) {
+						commandLine.append(" " + value);
+					} else {
+						commandLine.append(" (" + value + ")");
+					}
+				}
+			}
+		}
+		return commandLine.toString();
+	}
+
+	public String getHelpString() {
+		StringBuilder sb = new StringBuilder();
+		getHelp(sb, 0);
+		return sb.toString();
+	}
+
+	public void getHelp(StringBuilder sb, int indent) {
+		if (optionList.size() > 0) {
+			for (Option option : optionList) {
+				StringUtils.appendIndent(sb, indent);
+				sb.append('-');
+				sb.append(option.getCLIChar());
+				sb.append(' ');
+				sb.append(option.getName());
+				String defaultString = option.getDefaultCLIString();
+				if (defaultString != null && defaultString.length() > 0) {
+					sb.append(" (default: ");
+					sb.append(defaultString);
+					sb.append(')');
+				}
+				StringUtils.appendNewline(sb);
+				StringUtils.appendIndent(sb, indent);
+				sb.append(option.getPurpose());
+				StringUtils.appendNewline(sb);
+			}
+		} else {
+			StringUtils.appendIndented(sb, indent, "No options.");
+		}
+	}
+
+	/**
+	 * Internal method that splits a string into two parts - the parameter for the
+	 * current option, and the remaining options.
+	 *
+	 * @param cliString the command line string, beginning at an option parameter
+	 * @return an array of two strings - the first is the option paramter, the
+	 *         second is the remaining cli string
+	 */
+	protected static String[] splitParameterFromRemainingOptions(String cliString) {
+		String[] paramSplit = new String[2];
+		cliString = cliString.trim();
+		if (cliString.startsWith("\"") || cliString.startsWith("'")) {
+			int endQuoteIndex = cliString.indexOf(cliString.charAt(0), 1);
+			if (endQuoteIndex < 0) {
+				throw new IllegalArgumentException("Quotes not terminated correctly.");
+			}
+			paramSplit[0] = cliString.substring(1, endQuoteIndex);
+			paramSplit[1] = cliString.substring(endQuoteIndex + 1, cliString.length());
+		} else if (cliString.startsWith("(")) {
+			int bracketsOpen = 1;
+			int currPos = 1;
+			int nextCloseIndex = cliString.indexOf(")", currPos);
+			int nextOpenIndex = cliString.indexOf("(", currPos);
+			while (bracketsOpen != 0) {
+				if (nextCloseIndex < 0) {
+					throw new IllegalArgumentException("Brackets do not match.");
+				} else if ((nextOpenIndex < 0) || (nextCloseIndex < nextOpenIndex)) {
+					bracketsOpen--;
+					currPos = nextCloseIndex + 1;
+					nextCloseIndex = cliString.indexOf(")", currPos);
+				} else {
+					bracketsOpen++;
+					currPos = nextOpenIndex + 1;
+					nextOpenIndex = cliString.indexOf("(", currPos);
+				}
+			}
+			paramSplit[0] = cliString.substring(1, currPos - 1);
+			paramSplit[1] = cliString.substring(currPos, cliString.length());
+		} else {
+			int firstSpaceIndex = cliString.indexOf(" ", 0);
+			if (firstSpaceIndex >= 0) {
+				paramSplit[0] = cliString.substring(0, firstSpaceIndex);
+				paramSplit[1] = cliString.substring(firstSpaceIndex + 1, cliString.length());
+			} else {
+				paramSplit[0] = cliString;
+				paramSplit[1] = "";
+			}
+		}
+		return paramSplit;
+	}
+
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
 }
diff --git a/moa/src/main/java/com/github/javacliparser/SerializeUtils.java b/moa/src/main/java/com/github/javacliparser/SerializeUtils.java
index e4e2e6f8f..76d78b987 100644
--- a/moa/src/main/java/com/github/javacliparser/SerializeUtils.java
+++ b/moa/src/main/java/com/github/javacliparser/SerializeUtils.java
@@ -1,18 +1,18 @@
 /*
  * Copyright 2007 University of Waikato.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 
 package com.github.javacliparser;
@@ -40,70 +40,65 @@
  */
 public class SerializeUtils {
 
-    public static class ByteCountingOutputStream extends OutputStream {
+	public static class ByteCountingOutputStream extends OutputStream {
 
-        protected int numBytesWritten = 0;
+		protected int numBytesWritten = 0;
 
-        public int getNumBytesWritten() {
-            return this.numBytesWritten;
-        }
+		public int getNumBytesWritten() {
+			return this.numBytesWritten;
+		}
 
-        @Override
-        public void write(int b) throws IOException {
-            this.numBytesWritten++;
-        }
+		@Override
+		public void write(int b) throws IOException {
+			this.numBytesWritten++;
+		}
 
-        @Override
-        public void write(byte[] b, int off, int len) throws IOException {
-            this.numBytesWritten += len;
-        }
+		@Override
+		public void write(byte[] b, int off, int len) throws IOException {
+			this.numBytesWritten += len;
+		}
 
-        @Override
-        public void write(byte[] b) throws IOException {
-            this.numBytesWritten += b.length;
-        }
-    }
+		@Override
+		public void write(byte[] b) throws IOException {
+			this.numBytesWritten += b.length;
+		}
+	}
 
-    public static void writeToFile(File file, Serializable obj)
-            throws IOException {
-        ObjectOutputStream out = new ObjectOutputStream(new GZIPOutputStream(
-                new BufferedOutputStream(new FileOutputStream(file))));
-        out.writeObject(obj);
-        out.flush();
-        out.close();
-    }
+	public static void writeToFile(File file, Serializable obj) throws IOException {
+		ObjectOutputStream out = new ObjectOutputStream(
+				new GZIPOutputStream(new BufferedOutputStream(new FileOutputStream(file))));
+		out.writeObject(obj);
+		out.flush();
+		out.close();
+	}
 
-    public static Object readFromFile(File file) throws IOException,
-            ClassNotFoundException {
-        ObjectInputStream in = new ObjectInputStream(new GZIPInputStream(
-                new BufferedInputStream(new FileInputStream(file))));
-        Object obj = in.readObject();
-        in.close();
-        return obj;
-    }
+	public static Object readFromFile(File file) throws IOException, ClassNotFoundException {
+		ObjectInputStream in = new ObjectInputStream(
+				new GZIPInputStream(new BufferedInputStream(new FileInputStream(file))));
+		Object obj = in.readObject();
+		in.close();
+		return obj;
+	}
 
-    public static Object copyObject(Serializable obj) throws Exception {
-        ByteArrayOutputStream baoStream = new ByteArrayOutputStream();
-        ObjectOutputStream out = new ObjectOutputStream(
-                new BufferedOutputStream(baoStream));
-        out.writeObject(obj);
-        out.flush();
-        out.close();
-        byte[] byteArray = baoStream.toByteArray();
-        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(
-                new ByteArrayInputStream(byteArray)));
-        Object copy = in.readObject();
-        in.close();
-        return copy;
-    }
+	public static Object copyObject(Serializable obj) throws Exception {
+		ByteArrayOutputStream baoStream = new ByteArrayOutputStream();
+		ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(baoStream));
+		out.writeObject(obj);
+		out.flush();
+		out.close();
+		byte[] byteArray = baoStream.toByteArray();
+		ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(new ByteArrayInputStream(byteArray)));
+		Object copy = in.readObject();
+		in.close();
+		return copy;
+	}
 
-    public static int measureObjectByteSize(Serializable obj) throws Exception {
-        ByteCountingOutputStream bcoStream = new ByteCountingOutputStream();
-        ObjectOutputStream out = new ObjectOutputStream(
-                new BufferedOutputStream(bcoStream));
-        out.writeObject(obj);
-        out.flush();
-        out.close();
-        return bcoStream.getNumBytesWritten();
-    }
+	public static int measureObjectByteSize(Serializable obj) throws Exception {
+		ByteCountingOutputStream bcoStream = new ByteCountingOutputStream();
+		ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bcoStream));
+		out.writeObject(obj);
+		out.flush();
+		out.close();
+		return bcoStream.getNumBytesWritten();
+	}
 }
diff --git a/moa/src/main/java/com/github/javacliparser/StringOption.java b/moa/src/main/java/com/github/javacliparser/StringOption.java
index fe6eeeb40..2bdc62204 100644
--- a/moa/src/main/java/com/github/javacliparser/StringOption.java
+++ b/moa/src/main/java/com/github/javacliparser/StringOption.java
@@ -1,18 +1,18 @@
 /*
  * Copyright 2007 University of Waikato.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 
 package com.github.javacliparser;
@@ -25,39 +25,38 @@
  */
 public class StringOption extends AbstractOption {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    protected String currentVal;
+	protected String currentVal;
 
-    protected String defaultVal;
+	protected String defaultVal;
 
-    public StringOption(String name, char cliChar, String purpose,
-            String defaultVal) {
-        super(name, cliChar, purpose);
-        this.defaultVal = defaultVal;
-        resetToDefault();
-    }
+	public StringOption(String name, char cliChar, String purpose, String defaultVal) {
+		super(name, cliChar, purpose);
+		this.defaultVal = defaultVal;
+		resetToDefault();
+	}
 
-    public void setValue(String v) {
-        this.currentVal = v;
-    }
+	public void setValue(String v) {
+		this.currentVal = v;
+	}
 
-    public String getValue() {
-        return this.currentVal;
-    }
+	public String getValue() {
+		return this.currentVal;
+	}
 
-    @Override
-    public String getDefaultCLIString() {
-        return this.defaultVal;
-    }
+	@Override
+	public String getDefaultCLIString() {
+		return this.defaultVal;
+	}
 
-    @Override
-    public String getValueAsCLIString() {
-        return this.currentVal;
-    }
+	@Override
+	public String getValueAsCLIString() {
+		return this.currentVal;
+	}
 
-    @Override
-    public void setValueViaCLIString(String s) {
-        setValue(s);
-    }
+	@Override
+	public void setValueViaCLIString(String s) {
+		setValue(s);
+	}
 }
diff --git a/moa/src/main/java/com/github/javacliparser/StringUtils.java b/moa/src/main/java/com/github/javacliparser/StringUtils.java
index 3167c84ee..95455270e 100644
--- a/moa/src/main/java/com/github/javacliparser/StringUtils.java
+++ b/moa/src/main/java/com/github/javacliparser/StringUtils.java
@@ -1,18 +1,18 @@
 /*
  * Copyright 2007 University of Waikato.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 
 package com.github.javacliparser;
@@ -27,67 +27,47 @@
  */
 public class StringUtils {
 
-    public static final String newline = System.getProperty("line.separator");
+	public static final String newline = System.getProperty("line.separator");
 
-    public static String doubleToString(double value, int fractionDigits) {
-        return doubleToString(value, 0, fractionDigits);
-    }
+	public static String doubleToString(double value, int fractionDigits) {
+		return doubleToString(value, 0, fractionDigits);
+	}
 
-    public static String doubleToString(double value, int minFractionDigits,
-            int maxFractionDigits) {
-        DecimalFormat numberFormat = new DecimalFormat();
-        numberFormat.setMinimumFractionDigits(minFractionDigits);
-        numberFormat.setMaximumFractionDigits(maxFractionDigits);
-        return numberFormat.format(value);
-    }
+	public static String doubleToString(double value, int minFractionDigits, int maxFractionDigits) {
+		DecimalFormat numberFormat = new DecimalFormat();
+		numberFormat.setMinimumFractionDigits(minFractionDigits);
+		numberFormat.setMaximumFractionDigits(maxFractionDigits);
+		return numberFormat.format(value);
+	}
 
-    public static void appendNewline(StringBuilder out) {
-        out.append(newline);
-    }
+	public static void appendNewline(StringBuilder out) {
+		out.append(newline);
+	}
 
-    public static void appendIndent(StringBuilder out, int indent) {
-        for (int i = 0; i < indent; i++) {
-            out.append(' ');
-        }
-    }
+	public static void appendIndent(StringBuilder out, int indent) {
+		for (int i = 0; i < indent; i++) {
+			out.append(' ');
+		}
+	}
 
-    public static void appendIndented(StringBuilder out, int indent, String s) {
-        appendIndent(out, indent);
-        out.append(s);
-    }
+	public static void appendIndented(StringBuilder out, int indent, String s) {
+		appendIndent(out, indent);
+		out.append(s);
+	}
 
-    public static void appendNewlineIndented(StringBuilder out, int indent,
-            String s) {
-        appendNewline(out);
-        appendIndented(out, indent, s);
-    }
+	public static void appendNewlineIndented(StringBuilder out, int indent, String s) {
+		appendNewline(out);
+		appendIndented(out, indent, s);
+	}
 
-    /*public static String secondsToDHMSString(double seconds) {
-        if (seconds < 60) {
-            return doubleToString(seconds, 2, 2) + 's';
-        }
-        long secs = (int) (seconds);
-        long mins = secs / 60;
-        long hours = mins / 60;
-        long days = hours / 24;
-        secs %= 60;
-        mins %= 60;
-        hours %= 24;
-        StringBuilder result = new StringBuilder();
-        if (days > 0) {
-            result.append(days);
-            result.append('d');
-        }
-        if ((hours > 0) || (days > 0)) {
-            result.append(hours);
-            result.append('h');
-        }
-        if ((hours > 0) || (days > 0) || (mins > 0)) {
-            result.append(mins);
-            result.append('m');
-        }
-        result.append(secs);
-        result.append('s');
-        return result.toString();
-    }*/
+	/*
+	 * public static String secondsToDHMSString(double seconds) { if (seconds < 60)
+	 * { return doubleToString(seconds, 2, 2) + 's'; } long secs = (int) (seconds);
+	 * long mins = secs / 60; long hours = mins / 60; long days = hours / 24; secs
+	 * %= 60; mins %= 60; hours %= 24; StringBuilder result = new StringBuilder();
+	 * if (days > 0) { result.append(days); result.append('d'); } if ((hours > 0) ||
+	 * (days > 0)) { result.append(hours); result.append('h'); } if ((hours > 0) ||
+	 * (days > 0) || (mins > 0)) { result.append(mins); result.append('m'); }
+	 * result.append(secs); result.append('s'); return result.toString(); }
+	 */
 }
diff --git a/moa/src/main/java/com/github/javacliparser/gui/ClassOptionEditComponent.java b/moa/src/main/java/com/github/javacliparser/gui/ClassOptionEditComponent.java
index 72f7ef40b..9de36935b 100644
--- a/moa/src/main/java/com/github/javacliparser/gui/ClassOptionEditComponent.java
+++ b/moa/src/main/java/com/github/javacliparser/gui/ClassOptionEditComponent.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package com.github.javacliparser.gui;
 
@@ -43,112 +43,111 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class ClassOptionEditComponent extends JPanel implements
-        OptionEditComponent {
-
-    private static final long serialVersionUID = 1L;
-
-    protected ClassOption editedOption;
-
-    protected JTextField textField = new JTextField();
-
-    protected JButton editButton = new JButton("Edit");
-
-    /**
-     * Flag that says the text field is in the middle of an update operation.
-     * This is to prevent two change notifications from going out when the
-     * update is implemented as a remove followed by an insert.
-     */
-    protected boolean midUpdate = false;
-
-    /** listeners that listen to changes to the chosen option. */
-    protected HashSet<ChangeListener> changeListeners = new HashSet<ChangeListener>();
-
-    public ClassOptionEditComponent(Option opt) {
-        ClassOption option = (ClassOption) opt;
-        this.editedOption = option;
-        this.textField.setEditable(false);
-        this.textField.getDocument().addDocumentListener(new DocumentListener() {
-
-            @Override
-            public void removeUpdate(DocumentEvent e) {
-                if (!midUpdate)
-                    notifyChangeListeners();
-            }
-
-            @Override
-            public void insertUpdate(DocumentEvent e) {
-                notifyChangeListeners();
-            }
-
-            @Override
-            public void changedUpdate(DocumentEvent e) {
-                notifyChangeListeners();
-            }
-        });
-        setLayout(new BorderLayout());
-        add(this.textField, BorderLayout.CENTER);
-        add(this.editButton, BorderLayout.EAST);
-        this.editButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                editObject();
-            }
-        });
-        setEditState(this.editedOption.getValueAsCLIString());
-    }
-
-    @Override
-    public void applyState() {
-        this.editedOption.setValueViaCLIString(this.textField.getText());
-    }
-
-    @Override
-    public Option getEditedOption() {
-        return this.editedOption;
-    }
-
-    @Override
-    public void setEditState(String cliString) {
-        if (cliString.length() > 0) midUpdate = true;
-        this.textField.setText(cliString);
-        midUpdate = false;
-    }
-
-    public void editObject() {
-        setEditState(ClassOptionSelectionPanel.showSelectClassDialog(this,
-                "Editing option: " + this.editedOption.getName(),
-                this.editedOption.getRequiredType(), this.textField.getText(),
-                this.editedOption.getNullString()));
-    }
-
-    /**
-     * Adds the listener to the internal set of listeners. Gets notified when
-     * the option string changes.
-     *
-     * @param l the listener to add
-     */
-    public void addChangeListener(ChangeListener l) {
-        changeListeners.add(l);
-    }
-
-    /**
-     * Removes the listener from the internal set of listeners.
-     *
-     * @param l the listener to remove
-     */
-    public void removeChangeListener(ChangeListener l) {
-        changeListeners.remove(l);
-    }
-
-    /**
-     * Notifies all registered change listeners that the options have changed.
-     */
-    protected void notifyChangeListeners() {
-        ChangeEvent e = new ChangeEvent(this);
-        for (ChangeListener l : changeListeners) {
-            l.stateChanged(e);
-        }
-    }
+public class ClassOptionEditComponent extends JPanel implements OptionEditComponent {
+
+	private static final long serialVersionUID = 1L;
+
+	protected ClassOption editedOption;
+
+	protected JTextField textField = new JTextField();
+
+	protected JButton editButton = new JButton("Edit");
+
+	/**
+	 * Flag that says the text field is in the middle of an update operation. This
+	 * is to prevent two change notifications from going out when the update is
+	 * implemented as a remove followed by an insert.
+	 */
+	protected boolean midUpdate = false;
+
+	/** listeners that listen to changes to the chosen option. */
+	protected HashSet<ChangeListener> changeListeners = new HashSet<>();
+
+	public ClassOptionEditComponent(Option opt) {
+		ClassOption option = (ClassOption) opt;
+		this.editedOption = option;
+		this.textField.setEditable(false);
+		this.textField.getDocument().addDocumentListener(new DocumentListener() {
+
+			@Override
+			public void removeUpdate(DocumentEvent e) {
+				if (!midUpdate)
+					notifyChangeListeners();
+			}
+
+			@Override
+			public void insertUpdate(DocumentEvent e) {
+				notifyChangeListeners();
+			}
+
+			@Override
+			public void changedUpdate(DocumentEvent e) {
+				notifyChangeListeners();
+			}
+		});
+		setLayout(new BorderLayout());
+		add(this.textField, BorderLayout.CENTER);
+		add(this.editButton, BorderLayout.EAST);
+		this.editButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				editObject();
+			}
+		});
+		setEditState(this.editedOption.getValueAsCLIString());
+	}
+
+	@Override
+	public void applyState() {
+		this.editedOption.setValueViaCLIString(this.textField.getText());
+	}
+
+	@Override
+	public Option getEditedOption() {
+		return this.editedOption;
+	}
+
+	@Override
+	public void setEditState(String cliString) {
+		if (cliString.length() > 0)
+			midUpdate = true;
+		this.textField.setText(cliString);
+		midUpdate = false;
+	}
+
+	public void editObject() {
+		setEditState(ClassOptionSelectionPanel.showSelectClassDialog(this,
+				"Editing option: " + this.editedOption.getName(), this.editedOption.getRequiredType(),
+				this.textField.getText(), this.editedOption.getNullString()));
+	}
+
+	/**
+	 * Adds the listener to the internal set of listeners. Gets notified when the
+	 * option string changes.
+	 *
+	 * @param l the listener to add
+	 */
+	public void addChangeListener(ChangeListener l) {
+		changeListeners.add(l);
+	}
+
+	/**
+	 * Removes the listener from the internal set of listeners.
+	 *
+	 * @param l the listener to remove
+	 */
+	public void removeChangeListener(ChangeListener l) {
+		changeListeners.remove(l);
+	}
+
+	/**
+	 * Notifies all registered change listeners that the options have changed.
+	 */
+	protected void notifyChangeListeners() {
+		ChangeEvent e = new ChangeEvent(this);
+		for (ChangeListener l : changeListeners) {
+			l.stateChanged(e);
+		}
+	}
 }
diff --git a/moa/src/main/java/com/github/javacliparser/gui/ClassOptionWithNamesEditComponent.java b/moa/src/main/java/com/github/javacliparser/gui/ClassOptionWithNamesEditComponent.java
index f311f1d54..9e6754427 100644
--- a/moa/src/main/java/com/github/javacliparser/gui/ClassOptionWithNamesEditComponent.java
+++ b/moa/src/main/java/com/github/javacliparser/gui/ClassOptionWithNamesEditComponent.java
@@ -1,8 +1,8 @@
 /**
  * [ClassOptionWithNamesEditComponent.java]
- * 
+ *
  * ClassOptionWithNames: Editing window
- * 
+ *
  * @author Yunsu Kim
  * 		   based on the implementation of Richard Kirkby
  * Data Management and Data Exploration Group, RWTH Aachen University
@@ -32,90 +32,96 @@ public class ClassOptionWithNamesEditComponent extends JPanel implements OptionE
 
 	private static final long serialVersionUID = 1L;
 
-    protected ClassOptionWithNames editedOption;
-
-    protected JTextField textField = new JTextField();
-
-    protected JButton editButton = new JButton("Edit");
-
-    /** listeners that listen to changes to the chosen option. */
-    protected HashSet<ChangeListener> changeListeners = new HashSet<ChangeListener>();
-
-    public ClassOptionWithNamesEditComponent(ClassOptionWithNames option) {
-        this.editedOption = option;
-        this.textField.setEditable(false);
-        this.textField.getDocument().addDocumentListener(new DocumentListener() {
-
-            public void removeUpdate(DocumentEvent e) {
-                notifyChangeListeners();
-            }
-
-            public void insertUpdate(DocumentEvent e) {
-                notifyChangeListeners();
-            }
-
-            public void changedUpdate(DocumentEvent e) {
-                notifyChangeListeners();
-            }
-        });
-        
-        setLayout(new BorderLayout());
-        add(this.textField, BorderLayout.CENTER);
-        add(this.editButton, BorderLayout.EAST);
-        this.editButton.addActionListener(new ActionListener() {
-            public void actionPerformed(ActionEvent arg0) {
-                editObject();
-            }
-        });
-        
-        setEditState(this.editedOption.getValueAsCLIString());
-    }
-
-    public void applyState() {
-        this.editedOption.setValueViaCLIString(this.textField.getText());
-    }
-
-    public Option getEditedOption() {
-        return this.editedOption;
-    }
-
-    public void setEditState(String cliString) {
-        this.textField.setText(cliString);
-    }
-
-    public void editObject() {
-        setEditState(ClassOptionWithNamesSelectionPanel.showSelectClassDialog(this,
-                "Editing option: " + this.editedOption.getName(),
-                this.editedOption.getRequiredType(), this.textField.getText(),
-                this.editedOption.getNullString(), this.editedOption.getClassNames()));
-    }
-
-    /**
-     * Adds the listener to the internal set of listeners. Gets notified when
-     * the option string changes.
-     *
-     * @param l the listener to add
-     */
-    public void addChangeListener(ChangeListener l) {
-        changeListeners.add(l);
-    }
-
-    /**
-     * Removes the listener from the internal set of listeners.
-     *
-     * @param l the listener to remove
-     */
-    public void removeChangeListener(ChangeListener l) {
-        changeListeners.remove(l);
-    }
-
-    /**
-     * Notifies all registered change listeners that the options have changed.
-     */
-    protected void notifyChangeListeners() {
-        ChangeEvent e = new ChangeEvent(this);
-        for (ChangeListener l : changeListeners) {
-            l.stateChanged(e);
-        }
-    }
+	protected ClassOptionWithNames editedOption;
+
+	protected JTextField textField = new JTextField();
+
+	protected JButton editButton = new JButton("Edit");
+
+	/** listeners that listen to changes to the chosen option. */
+	protected HashSet<ChangeListener> changeListeners = new HashSet<>();
+
+	public ClassOptionWithNamesEditComponent(ClassOptionWithNames option) {
+		this.editedOption = option;
+		this.textField.setEditable(false);
+		this.textField.getDocument().addDocumentListener(new DocumentListener() {
+
+			@Override
+			public void removeUpdate(DocumentEvent e) {
+				notifyChangeListeners();
+			}
+
+			@Override
+			public void insertUpdate(DocumentEvent e) {
+				notifyChangeListeners();
+			}
+
+			@Override
+			public void changedUpdate(DocumentEvent e) {
+				notifyChangeListeners();
+			}
+		});
+
+		setLayout(new BorderLayout());
+		add(this.textField, BorderLayout.CENTER);
+		add(this.editButton, BorderLayout.EAST);
+		this.editButton.addActionListener(new ActionListener() {
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				editObject();
+			}
+		});
+
+		setEditState(this.editedOption.getValueAsCLIString());
+	}
+
+	@Override
+	public void applyState() {
+		this.editedOption.setValueViaCLIString(this.textField.getText());
+	}
+
+	@Override
+	public Option getEditedOption() {
+		return this.editedOption;
+	}
+
+	@Override
+	public void setEditState(String cliString) {
+		this.textField.setText(cliString);
+	}
+
+	public void editObject() {
+		setEditState(ClassOptionWithNamesSelectionPanel.showSelectClassDialog(this,
+				"Editing option: " + this.editedOption.getName(), this.editedOption.getRequiredType(),
+				this.textField.getText(), this.editedOption.getNullString(), this.editedOption.getClassNames()));
+	}
+
+	/**
+	 * Adds the listener to the internal set of listeners. Gets notified when the
+	 * option string changes.
+	 *
+	 * @param l the listener to add
+	 */
+	public void addChangeListener(ChangeListener l) {
+		changeListeners.add(l);
+	}
+
+	/**
+	 * Removes the listener from the internal set of listeners.
+	 *
+	 * @param l the listener to remove
+	 */
+	public void removeChangeListener(ChangeListener l) {
+		changeListeners.remove(l);
+	}
+
+	/**
+	 * Notifies all registered change listeners that the options have changed.
+	 */
+	protected void notifyChangeListeners() {
+		ChangeEvent e = new ChangeEvent(this);
+		for (ChangeListener l : changeListeners) {
+			l.stateChanged(e);
+		}
+	}
 }
diff --git a/moa/src/main/java/com/github/javacliparser/gui/FileOptionEditComponent.java b/moa/src/main/java/com/github/javacliparser/gui/FileOptionEditComponent.java
index 1e8c4b59f..0751e9150 100644
--- a/moa/src/main/java/com/github/javacliparser/gui/FileOptionEditComponent.java
+++ b/moa/src/main/java/com/github/javacliparser/gui/FileOptionEditComponent.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package com.github.javacliparser.gui;
 
@@ -25,6 +25,7 @@
 import java.io.File;
 
 import javax.swing.JButton;
+import javax.swing.JFileChooser;
 import javax.swing.JPanel;
 import javax.swing.JTextField;
 
@@ -40,72 +41,70 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class FileOptionEditComponent extends JPanel implements
-        OptionEditComponent {
+public class FileOptionEditComponent extends JPanel implements OptionEditComponent {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    protected FileOption editedOption;
+	protected FileOption editedOption;
 
-    protected JTextField textField = new JTextField();
+	protected JTextField textField = new JTextField();
 
-    protected JButton browseButton = new JButton("Browse");
+	protected JButton browseButton = new JButton("Browse");
 
-    public FileOptionEditComponent(Option opt) {
-        FileOption option = (FileOption) opt;
-        this.editedOption = option;
-        setLayout(new BorderLayout());
-        add(this.textField, BorderLayout.CENTER);
-        add(this.browseButton, BorderLayout.EAST);
-        this.browseButton.addActionListener(new ActionListener() {
+	public FileOptionEditComponent(Option opt) {
+		FileOption option = (FileOption) opt;
+		this.editedOption = option;
+		setLayout(new BorderLayout());
+		add(this.textField, BorderLayout.CENTER);
+		add(this.browseButton, BorderLayout.EAST);
+		this.browseButton.addActionListener(new ActionListener() {
 
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                browseForFile();
-            }
-        });
-        setEditState(this.editedOption.getValueAsCLIString());
-    }
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				browseForFile();
+			}
+		});
+		setEditState(this.editedOption.getValueAsCLIString());
+	}
 
-    @Override
-    public void applyState() {
-        this.editedOption.setValueViaCLIString(this.textField.getText().length() > 0 ? this.textField.getText() : null);
-    }
+	@Override
+	public void applyState() {
+		this.editedOption.setValueViaCLIString(this.textField.getText().length() > 0 ? this.textField.getText() : null);
+	}
 
-    @Override
-    public Option getEditedOption() {
-        return this.editedOption;
-    }
+	@Override
+	public Option getEditedOption() {
+		return this.editedOption;
+	}
 
-    @Override
-    public void setEditState(String cliString) {
-        this.textField.setText(cliString);
-    }
+	@Override
+	public void setEditState(String cliString) {
+		this.textField.setText(cliString);
+	}
 
-    public void browseForFile() {
-        BaseFileChooser fileChooser = new BaseFileChooser();
-        fileChooser.setAcceptAllFileFilterUsed(true);
-        String extension = this.editedOption.getDefaultFileExtension();
-        if (extension != null) {
-            fileChooser.addChoosableFileFilter(new FileExtensionFilter(
-                    extension));
-        }
-        fileChooser.setSelectedFile(new File(this.textField.getText()));
-        if (this.editedOption.isOutputFile()) {
-            if (fileChooser.showSaveDialog(this.browseButton) == BaseFileChooser.APPROVE_OPTION) {
-                File chosenFile = fileChooser.getSelectedFile();
-                String fileName = chosenFile.getPath();
-                if (!chosenFile.exists()) {
-                    if ((extension != null) && !fileName.endsWith(extension)) {
-                        fileName = fileName + "." + extension;
-                    }
-                }
-                this.textField.setText(fileName);
-            }
-        } else {
-            if (fileChooser.showOpenDialog(this.browseButton) == BaseFileChooser.APPROVE_OPTION) {
-                this.textField.setText(fileChooser.getSelectedFile().getPath());
-            }
-        }
-    }
+	public void browseForFile() {
+		BaseFileChooser fileChooser = new BaseFileChooser();
+		fileChooser.setAcceptAllFileFilterUsed(true);
+		String extension = this.editedOption.getDefaultFileExtension();
+		if (extension != null) {
+			fileChooser.addChoosableFileFilter(new FileExtensionFilter(extension));
+		}
+		fileChooser.setSelectedFile(new File(this.textField.getText()));
+		if (this.editedOption.isOutputFile()) {
+			if (fileChooser.showSaveDialog(this.browseButton) == JFileChooser.APPROVE_OPTION) {
+				File chosenFile = fileChooser.getSelectedFile();
+				String fileName = chosenFile.getPath();
+				if (!chosenFile.exists()) {
+					if ((extension != null) && !fileName.endsWith(extension)) {
+						fileName = fileName + "." + extension;
+					}
+				}
+				this.textField.setText(fileName);
+			}
+		} else {
+			if (fileChooser.showOpenDialog(this.browseButton) == JFileChooser.APPROVE_OPTION) {
+				this.textField.setText(fileChooser.getSelectedFile().getPath());
+			}
+		}
+	}
 }
diff --git a/moa/src/main/java/com/github/javacliparser/gui/FlagOptionEditComponent.java b/moa/src/main/java/com/github/javacliparser/gui/FlagOptionEditComponent.java
index 763a79d76..7d9f45b24 100644
--- a/moa/src/main/java/com/github/javacliparser/gui/FlagOptionEditComponent.java
+++ b/moa/src/main/java/com/github/javacliparser/gui/FlagOptionEditComponent.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package com.github.javacliparser.gui;
 
@@ -30,31 +30,30 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class FlagOptionEditComponent extends JCheckBox implements
-        OptionEditComponent {
+public class FlagOptionEditComponent extends JCheckBox implements OptionEditComponent {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    protected FlagOption editedOption;
+	protected FlagOption editedOption;
 
-    public FlagOptionEditComponent(Option opt) {
-        FlagOption option = (FlagOption) opt;
-        this.editedOption = option;
-        setEditState(this.editedOption.getValueAsCLIString());
-    }
+	public FlagOptionEditComponent(Option opt) {
+		FlagOption option = (FlagOption) opt;
+		this.editedOption = option;
+		setEditState(this.editedOption.getValueAsCLIString());
+	}
 
-    @Override
-    public Option getEditedOption() {
-        return this.editedOption;
-    }
+	@Override
+	public Option getEditedOption() {
+		return this.editedOption;
+	}
 
-    @Override
-    public void setEditState(String cliString) {
-        setSelected(cliString != null);
-    }
+	@Override
+	public void setEditState(String cliString) {
+		setSelected(cliString != null);
+	}
 
-    @Override
-    public void applyState() {
-        this.editedOption.setValue(isSelected());
-    }
+	@Override
+	public void applyState() {
+		this.editedOption.setValue(isSelected());
+	}
 }
diff --git a/moa/src/main/java/com/github/javacliparser/gui/FloatOptionEditComponent.java b/moa/src/main/java/com/github/javacliparser/gui/FloatOptionEditComponent.java
index f2a5989a2..ffff51a7e 100644
--- a/moa/src/main/java/com/github/javacliparser/gui/FloatOptionEditComponent.java
+++ b/moa/src/main/java/com/github/javacliparser/gui/FloatOptionEditComponent.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package com.github.javacliparser.gui;
 
@@ -37,77 +37,73 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class FloatOptionEditComponent extends JPanel implements
-        OptionEditComponent {
-
-    private static final long serialVersionUID = 1L;
-
-    public static final int SLIDER_RESOLUTION = 100000;
-
-    protected FloatOption editedOption;
-
-    protected JSpinner spinner;
-
-    protected JSlider slider;
-
-    public FloatOptionEditComponent(Option opt) {
-        FloatOption option = (FloatOption) opt;
-        this.editedOption = option;
-        double minVal = option.getMinValue();
-        double maxVal = option.getMaxValue();
-        setLayout(new GridLayout(1, 0));
-        this.spinner = new JSpinner(new SpinnerNumberModel(option.getValue(),
-                minVal, maxVal, 0.001));
-        add(this.spinner);
-        if ((minVal > Double.NEGATIVE_INFINITY)
-                && (maxVal < Double.POSITIVE_INFINITY)) {
-            this.slider = new JSlider(0, SLIDER_RESOLUTION,
-                    floatValueToSliderValue(option.getValue()));
-            add(this.slider);
-            this.slider.addChangeListener(new ChangeListener() {
-
-                @Override
-                public void stateChanged(ChangeEvent e) {
-                    FloatOptionEditComponent.this.spinner.setValue(sliderValueToFloatValue(FloatOptionEditComponent.this.slider.getValue()));
-                }
-            });
-            this.spinner.addChangeListener(new ChangeListener() {
-
-                @Override
-                public void stateChanged(ChangeEvent e) {
-                    FloatOptionEditComponent.this.slider.setValue(floatValueToSliderValue(((Double) FloatOptionEditComponent.this.spinner.getValue()).doubleValue()));
-                }
-            });
-        }
-    }
-
-    protected int floatValueToSliderValue(double floatValue) {
-        double minVal = this.editedOption.getMinValue();
-        double maxVal = this.editedOption.getMaxValue();
-        return (int) Math.round((floatValue - minVal) / (maxVal - minVal)
-                * SLIDER_RESOLUTION);
-    }
-
-    protected double sliderValueToFloatValue(int sliderValue) {
-        double minVal = this.editedOption.getMinValue();
-        double maxVal = this.editedOption.getMaxValue();
-        return minVal
-                + (((double) sliderValue / SLIDER_RESOLUTION) * (maxVal - minVal));
-    }
-
-    @Override
-    public void applyState() {
-        this.editedOption.setValue(((Double) this.spinner.getValue()).doubleValue());
-        // this.editedOption.setValue(Double.parseDouble(this.spinner.getValue().toString()));
-    }
-
-    @Override
-    public Option getEditedOption() {
-        return this.editedOption;
-    }
-
-    @Override
-    public void setEditState(String cliString) {
-        this.spinner.setValue(FloatOption.cliStringToDouble(cliString));
-    }
+public class FloatOptionEditComponent extends JPanel implements OptionEditComponent {
+
+	private static final long serialVersionUID = 1L;
+
+	public static final int SLIDER_RESOLUTION = 100000;
+
+	protected FloatOption editedOption;
+
+	protected JSpinner spinner;
+
+	protected JSlider slider;
+
+	public FloatOptionEditComponent(Option opt) {
+		FloatOption option = (FloatOption) opt;
+		this.editedOption = option;
+		double minVal = option.getMinValue();
+		double maxVal = option.getMaxValue();
+		setLayout(new GridLayout(1, 0));
+		this.spinner = new JSpinner(new SpinnerNumberModel(option.getValue(), minVal, maxVal, 0.001));
+		add(this.spinner);
+		if ((minVal > Double.NEGATIVE_INFINITY) && (maxVal < Double.POSITIVE_INFINITY)) {
+			this.slider = new JSlider(0, SLIDER_RESOLUTION, floatValueToSliderValue(option.getValue()));
+			add(this.slider);
+			this.slider.addChangeListener(new ChangeListener() {
+
+				@Override
+				public void stateChanged(ChangeEvent e) {
+					FloatOptionEditComponent.this.spinner
+							.setValue(sliderValueToFloatValue(FloatOptionEditComponent.this.slider.getValue()));
+				}
+			});
+			this.spinner.addChangeListener(new ChangeListener() {
+
+				@Override
+				public void stateChanged(ChangeEvent e) {
+					FloatOptionEditComponent.this.slider.setValue(floatValueToSliderValue(
+							((Double) FloatOptionEditComponent.this.spinner.getValue())));
+				}
+			});
+		}
+	}
+
+	protected int floatValueToSliderValue(double floatValue) {
+		double minVal = this.editedOption.getMinValue();
+		double maxVal = this.editedOption.getMaxValue();
+		return (int) Math.round((floatValue - minVal) / (maxVal - minVal) * SLIDER_RESOLUTION);
+	}
+
+	protected double sliderValueToFloatValue(int sliderValue) {
+		double minVal = this.editedOption.getMinValue();
+		double maxVal = this.editedOption.getMaxValue();
+		return minVal + (((double) sliderValue / SLIDER_RESOLUTION) * (maxVal - minVal));
+	}
+
+	@Override
+	public void applyState() {
+		this.editedOption.setValue(((Double) this.spinner.getValue()));
+		// this.editedOption.setValue(Double.parseDouble(this.spinner.getValue().toString()));
+	}
+
+	@Override
+	public Option getEditedOption() {
+		return this.editedOption;
+	}
+
+	@Override
+	public void setEditState(String cliString) {
+		this.spinner.setValue(FloatOption.cliStringToDouble(cliString));
+	}
 }
diff --git a/moa/src/main/java/com/github/javacliparser/gui/IntOptionEditComponent.java b/moa/src/main/java/com/github/javacliparser/gui/IntOptionEditComponent.java
index f73d64d8a..aa3d9a519 100644
--- a/moa/src/main/java/com/github/javacliparser/gui/IntOptionEditComponent.java
+++ b/moa/src/main/java/com/github/javacliparser/gui/IntOptionEditComponent.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package com.github.javacliparser.gui;
 
@@ -37,58 +37,57 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class IntOptionEditComponent extends JPanel implements
-        OptionEditComponent {
+public class IntOptionEditComponent extends JPanel implements OptionEditComponent {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    protected IntOption editedOption;
+	protected IntOption editedOption;
 
-    protected JSpinner spinner;
+	protected JSpinner spinner;
 
-    protected JSlider slider;
+	protected JSlider slider;
 
-    public IntOptionEditComponent(Option opt) {
-        IntOption option = (IntOption) opt;
-        this.editedOption = option;
-        int minVal = option.getMinValue();
-        int maxVal = option.getMaxValue();
-        setLayout(new GridLayout(1, 0));
-        this.spinner = new JSpinner(new SpinnerNumberModel(option.getValue(),
-                minVal, maxVal, 1));
-        add(this.spinner);
-        if ((minVal > Integer.MIN_VALUE) && (maxVal < Integer.MAX_VALUE)) {
-            this.slider = new JSlider(minVal, maxVal, option.getValue());
-            add(this.slider);
-            this.slider.addChangeListener(new ChangeListener() {
+	public IntOptionEditComponent(Option opt) {
+		IntOption option = (IntOption) opt;
+		this.editedOption = option;
+		int minVal = option.getMinValue();
+		int maxVal = option.getMaxValue();
+		setLayout(new GridLayout(1, 0));
+		this.spinner = new JSpinner(new SpinnerNumberModel(option.getValue(), minVal, maxVal, 1));
+		add(this.spinner);
+		if ((minVal > Integer.MIN_VALUE) && (maxVal < Integer.MAX_VALUE)) {
+			this.slider = new JSlider(minVal, maxVal, option.getValue());
+			add(this.slider);
+			this.slider.addChangeListener(new ChangeListener() {
 
-                @Override
-                public void stateChanged(ChangeEvent e) {
-                    IntOptionEditComponent.this.spinner.setValue(IntOptionEditComponent.this.slider.getValue());
-                }
-            });
-            this.spinner.addChangeListener(new ChangeListener() {
+				@Override
+				public void stateChanged(ChangeEvent e) {
+					IntOptionEditComponent.this.spinner.setValue(IntOptionEditComponent.this.slider.getValue());
+				}
+			});
+			this.spinner.addChangeListener(new ChangeListener() {
 
-                @Override
-                public void stateChanged(ChangeEvent e) {
-                    IntOptionEditComponent.this.slider.setValue(((Integer) IntOptionEditComponent.this.spinner.getValue()).intValue());
-                }
-            });
-        }
-    }
+				@Override
+				public void stateChanged(ChangeEvent e) {
+					IntOptionEditComponent.this.slider
+							.setValue(((Integer) IntOptionEditComponent.this.spinner.getValue()));
+				}
+			});
+		}
+	}
 
-    @Override
-    public void applyState() {
-        this.editedOption.setValue(((Integer) this.spinner.getValue()).intValue());
-    }
+	@Override
+	public void applyState() {
+		this.editedOption.setValue(((Integer) this.spinner.getValue()));
+	}
 
-    @Override
-    public Option getEditedOption() {
-        return this.editedOption;
-    }
+	@Override
+	public Option getEditedOption() {
+		return this.editedOption;
+	}
 
-    @Override
-    public void setEditState(String cliString) {
-        this.spinner.setValue(IntOption.cliStringToInt(cliString));
-    }
+	@Override
+	public void setEditState(String cliString) {
+		this.spinner.setValue(IntOption.cliStringToInt(cliString));
+	}
 }
diff --git a/moa/src/main/java/com/github/javacliparser/gui/ListOptionEditComponent.java b/moa/src/main/java/com/github/javacliparser/gui/ListOptionEditComponent.java
index c150b035a..e8283b1d5 100644
--- a/moa/src/main/java/com/github/javacliparser/gui/ListOptionEditComponent.java
+++ b/moa/src/main/java/com/github/javacliparser/gui/ListOptionEditComponent.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package com.github.javacliparser.gui;
 
@@ -29,10 +29,9 @@
  */
 public class ListOptionEditComponent extends StringOptionEditComponent {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public ListOptionEditComponent(Option option) {
-    	super(option);
-    }
+	public ListOptionEditComponent(Option option) {
+		super(option);
+	}
 }
-
diff --git a/moa/src/main/java/com/github/javacliparser/gui/MultiChoiceOptionEditComponent.java b/moa/src/main/java/com/github/javacliparser/gui/MultiChoiceOptionEditComponent.java
index 3fa636c4c..873bbd45f 100644
--- a/moa/src/main/java/com/github/javacliparser/gui/MultiChoiceOptionEditComponent.java
+++ b/moa/src/main/java/com/github/javacliparser/gui/MultiChoiceOptionEditComponent.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package com.github.javacliparser.gui;
 
@@ -30,33 +30,32 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class MultiChoiceOptionEditComponent extends JComboBox<String> implements
-        OptionEditComponent {
-
-    private static final long serialVersionUID = 1L;
-
-    protected MultiChoiceOption editedOption;
-
-    public MultiChoiceOptionEditComponent(Option option) {
-        super(((MultiChoiceOption) option).getOptionLabels());
-        this.editedOption = (MultiChoiceOption) option;
-        setSelectedIndex(this.editedOption.getChosenIndex());
-    }
-
-    @Override
-    public void applyState() {
-        this.editedOption.setChosenIndex(getSelectedIndex());
-    }
-
-    @Override
-    public Option getEditedOption() {
-        return this.editedOption;
-    }
-
-    @Override
-    public void setEditState(String cliString) {
-        MultiChoiceOption tempOpt = (MultiChoiceOption) this.editedOption.copy();
-        tempOpt.setValueViaCLIString(cliString);
-        setSelectedIndex(tempOpt.getChosenIndex());
-    }
+public class MultiChoiceOptionEditComponent extends JComboBox<String> implements OptionEditComponent {
+
+	private static final long serialVersionUID = 1L;
+
+	protected MultiChoiceOption editedOption;
+
+	public MultiChoiceOptionEditComponent(Option option) {
+		super(((MultiChoiceOption) option).getOptionLabels());
+		this.editedOption = (MultiChoiceOption) option;
+		setSelectedIndex(this.editedOption.getChosenIndex());
+	}
+
+	@Override
+	public void applyState() {
+		this.editedOption.setChosenIndex(getSelectedIndex());
+	}
+
+	@Override
+	public Option getEditedOption() {
+		return this.editedOption;
+	}
+
+	@Override
+	public void setEditState(String cliString) {
+		MultiChoiceOption tempOpt = (MultiChoiceOption) this.editedOption.copy();
+		tempOpt.setValueViaCLIString(cliString);
+		setSelectedIndex(tempOpt.getChosenIndex());
+	}
 }
diff --git a/moa/src/main/java/com/github/javacliparser/gui/OptionEditComponent.java b/moa/src/main/java/com/github/javacliparser/gui/OptionEditComponent.java
index 6d42e4eba..75648e8b3 100644
--- a/moa/src/main/java/com/github/javacliparser/gui/OptionEditComponent.java
+++ b/moa/src/main/java/com/github/javacliparser/gui/OptionEditComponent.java
@@ -15,37 +15,37 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package com.github.javacliparser.gui;
 
 import com.github.javacliparser.Option;
 
 /**
- * Interface representing a component to edit an option. 
+ * Interface representing a component to edit an option.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $ 
+ * @version $Revision: 7 $
  */
 public interface OptionEditComponent {
 
-    /**
-     * Gets the option of this component
-     *
-     * @return the option of this component
-     */
-    public Option getEditedOption();
+	/**
+	 * Gets the option of this component
+	 *
+	 * @return the option of this component
+	 */
+	Option getEditedOption();
 
-    /**
-     * Sets the state of the component
-     *
-     * @param cliString the state of the component
-     */
-    public void setEditState(String cliString);
+	/**
+	 * Sets the state of the component
+	 *
+	 * @param cliString the state of the component
+	 */
+	void setEditState(String cliString);
 
-    /**
-     * This method applies the state
-     *
-     */
-    public void applyState();
+	/**
+	 * This method applies the state
+	 *
+	 */
+	void applyState();
 }
diff --git a/moa/src/main/java/com/github/javacliparser/gui/OptionsConfigurationPanel.java b/moa/src/main/java/com/github/javacliparser/gui/OptionsConfigurationPanel.java
index 007fff3dd..52291cb2e 100644
--- a/moa/src/main/java/com/github/javacliparser/gui/OptionsConfigurationPanel.java
+++ b/moa/src/main/java/com/github/javacliparser/gui/OptionsConfigurationPanel.java
@@ -15,27 +15,10 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package com.github.javacliparser.gui;
 
-import com.github.javacliparser.Option;
-import com.github.javacliparser.Options;
-import moa.classifiers.trees.HoeffdingTree;
-import moa.gui.GUIUtils;
-import moa.gui.LookAndFeel;
-import moa.options.OptionHandler;
-
-import javax.swing.BorderFactory;
-import javax.swing.JButton;
-import javax.swing.JComponent;
-import javax.swing.JFrame;
-import javax.swing.JLabel;
-import javax.swing.JOptionPane;
-import javax.swing.JPanel;
-import javax.swing.JScrollPane;
-import javax.swing.JTextArea;
-import javax.swing.ScrollPaneConstants;
 import java.awt.BorderLayout;
 import java.awt.Component;
 import java.awt.Dimension;
@@ -50,6 +33,25 @@
 import java.util.LinkedList;
 import java.util.List;
 
+import javax.swing.BorderFactory;
+import javax.swing.JButton;
+import javax.swing.JComponent;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTextArea;
+import javax.swing.ScrollPaneConstants;
+
+import com.github.javacliparser.Option;
+import com.github.javacliparser.Options;
+
+import moa.gui.GUIUtils;
+import moa.gui.LookAndFeel;
+import moa.learners.predictors.trees.HoeffdingTree;
+import moa.options.OptionHandler;
+
 /**
  * This panel displays an options configuration.
  *
@@ -57,208 +59,202 @@
  */
 public class OptionsConfigurationPanel extends JPanel {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
+
+	public static final int FIXED_PANEL_WIDTH = 400;
+
+	public static final int MAX_PANEL_HEIGHT = 300;
+
+	protected Options options;
 
-    public static final int FIXED_PANEL_WIDTH = 400;
+	protected List<OptionEditComponent> editComponents = new LinkedList<>();
 
-    public static final int MAX_PANEL_HEIGHT = 300;
+	protected JButton helpButton = new JButton("Help");
 
-    protected Options options;
+	protected JButton resetButton = new JButton("Reset to defaults");
 
-    protected List<OptionEditComponent> editComponents = new LinkedList<OptionEditComponent>();
+	public OptionsConfigurationPanel(String purposeString, Options options) {
+		this.options = options;
+		setLayout(new BorderLayout());
+		if (purposeString != null) {
+			JTextArea purposeTextArea = new JTextArea(purposeString, 3, 0);
+			purposeTextArea.setEditable(false);
+			purposeTextArea.setLineWrap(true);
+			purposeTextArea.setWrapStyleWord(true);
+			purposeTextArea.setEnabled(false);
+			purposeTextArea.setBorder(BorderFactory.createTitledBorder("Purpose"));
+			purposeTextArea.setBackground(getBackground());
+			JScrollPane scrollPanePurpose = new JScrollPane(purposeTextArea,
+					ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED, ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
+			scrollPanePurpose.setBorder(null);
+			add(scrollPanePurpose, BorderLayout.NORTH);
+		}
+		JPanel optionsPanel = createLabelledOptionComponentListPanel(options.getOptionArray(), this.editComponents);
+		JScrollPane scrollPane = new JScrollPane(optionsPanel, ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED,
+				ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
+		scrollPane.setBorder(null);
+		int optionPanelHeight = (int) optionsPanel.getPreferredSize().getHeight();
+		int scrollPaneHeight = (int) scrollPane.getPreferredSize().getHeight();
+		scrollPane.setPreferredSize(new Dimension(FIXED_PANEL_WIDTH,
+				scrollPaneHeight > MAX_PANEL_HEIGHT ? MAX_PANEL_HEIGHT : scrollPaneHeight));
+		optionsPanel.setPreferredSize(new Dimension(0, optionPanelHeight));
+		add(scrollPane, BorderLayout.CENTER);
+		JPanel lowerButtons = new JPanel();
+		lowerButtons.setLayout(new FlowLayout());
+		lowerButtons.add(this.helpButton);
+		lowerButtons.add(this.resetButton);
+		add(lowerButtons, BorderLayout.SOUTH);
+		this.helpButton.addActionListener(new ActionListener() {
 
-    protected JButton helpButton = new JButton("Help");
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				showHelpDialog();
+			}
+		});
+		this.resetButton.addActionListener(new ActionListener() {
 
-    protected JButton resetButton = new JButton("Reset to defaults");
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				resetToDefaults();
+			}
+		});
+	}
 
-    public OptionsConfigurationPanel(String purposeString, Options options) {
-        this.options = options;
-        setLayout(new BorderLayout());
-        if (purposeString != null) {
-            JTextArea purposeTextArea = new JTextArea(purposeString, 3, 0);
-            purposeTextArea.setEditable(false);
-            purposeTextArea.setLineWrap(true);
-            purposeTextArea.setWrapStyleWord(true);
-            purposeTextArea.setEnabled(false);
-            purposeTextArea.setBorder(BorderFactory.createTitledBorder("Purpose"));
-            purposeTextArea.setBackground(getBackground());
-            JScrollPane scrollPanePurpose = new JScrollPane(purposeTextArea,
-            ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED,
-            ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
-            scrollPanePurpose.setBorder(null);
-            add(scrollPanePurpose, BorderLayout.NORTH);
-        }
-        JPanel optionsPanel = createLabelledOptionComponentListPanel(options.getOptionArray(), this.editComponents);
-        JScrollPane scrollPane = new JScrollPane(optionsPanel,
-                ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED,
-                ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
-        scrollPane.setBorder(null);
-        int optionPanelHeight = (int) optionsPanel.getPreferredSize().getHeight();
-        int scrollPaneHeight = (int) scrollPane.getPreferredSize().getHeight();
-        scrollPane.setPreferredSize(new Dimension(FIXED_PANEL_WIDTH,
-                scrollPaneHeight > MAX_PANEL_HEIGHT ? MAX_PANEL_HEIGHT
-                : scrollPaneHeight));
-        optionsPanel.setPreferredSize(new Dimension(0, optionPanelHeight));
-        add(scrollPane, BorderLayout.CENTER);
-        JPanel lowerButtons = new JPanel();
-        lowerButtons.setLayout(new FlowLayout());
-        lowerButtons.add(this.helpButton);
-        lowerButtons.add(this.resetButton);
-        add(lowerButtons, BorderLayout.SOUTH);
-        this.helpButton.addActionListener(new ActionListener() {
+	public static boolean showEditOptionsDialog(Component parent, String title, OptionHandler optionHandler) {
+		OptionsConfigurationPanel panel = new OptionsConfigurationPanel(optionHandler.getPurposeString(),
+				optionHandler.getOptions());
+		if (JOptionPane.showOptionDialog(parent, panel, title, JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE,
+				null, null, null) == JOptionPane.OK_OPTION) {
+			panel.applyChanges();
+			return true;
+		}
+		return false;
+	}
 
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                showHelpDialog();
-            }
-        });
-        this.resetButton.addActionListener(new ActionListener() {
+	public String getHelpText() {
+		return this.options.getHelpString();
+	}
 
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                resetToDefaults();
-            }
-        });
-    }
+	public void showHelpDialog() {
+		JTextArea helpTextArea = new JTextArea(getHelpText(), 20, 80);
+		helpTextArea.setFont(new Font("Monospaced", Font.PLAIN, 12));
+		helpTextArea.setEditable(false);
+		JOptionPane.showMessageDialog(this, new JScrollPane(helpTextArea), "Options Help",
+				JOptionPane.INFORMATION_MESSAGE);
+	}
 
-    public static boolean showEditOptionsDialog(Component parent, String title,
-            OptionHandler optionHandler) {
-        OptionsConfigurationPanel panel = new OptionsConfigurationPanel(
-                optionHandler.getPurposeString(), optionHandler.getOptions());
-        if (JOptionPane.showOptionDialog(parent, panel, title,
-                JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE, null,
-                null, null) == JOptionPane.OK_OPTION) {
-            panel.applyChanges();
-            return true;
-        }
-        return false;
-    }
+	public void resetToDefaults() {
+		for (OptionEditComponent editor : this.editComponents) {
+			editor.setEditState(editor.getEditedOption().getDefaultCLIString());
+		}
+	}
 
-    public String getHelpText() {
-        return this.options.getHelpString();
-    }
+	public void applyChanges() {
+		for (OptionEditComponent editor : this.editComponents) {
+			try {
+				editor.applyState();
+			} catch (Exception ex) {
+				GUIUtils.showExceptionDialog(this, "Problem with option " + editor.getEditedOption().getName(), ex);
+			}
+		}
+	}
 
-    public void showHelpDialog() {
-        JTextArea helpTextArea = new JTextArea(getHelpText(), 20, 80);
-        helpTextArea.setFont(new Font("Monospaced", Font.PLAIN, 12));
-        helpTextArea.setEditable(false);
-        JOptionPane.showMessageDialog(this, new JScrollPane(helpTextArea),
-                "Options Help", JOptionPane.INFORMATION_MESSAGE);
-    }
+	protected static JPanel createLabelledOptionComponentListPanel(Option[] options,
+			List<OptionEditComponent> editComponents) {
+		JPanel panel = new JPanel();
+		if ((options != null) && (options.length > 0)) {
+			GridBagLayout gbLayout = new GridBagLayout();
+			GridBagConstraints gbc = new GridBagConstraints();
+			panel.setLayout(gbLayout);
+			for (int i = 0; i < options.length; i++) {
+				JLabel label = new JLabel(options[i].getName());
+				label.setToolTipText(options[i].getPurpose());
+				gbc.gridx = 0;
+				gbc.fill = GridBagConstraints.NONE;
+				gbc.anchor = GridBagConstraints.EAST;
+				gbc.weightx = 0;
+				gbc.insets = new Insets(5, 5, 5, 5);
+				gbLayout.setConstraints(label, gbc);
+				panel.add(label);
+				JComponent editor = getEditComponent(options[i]);
+				label.setLabelFor(editor);
+				if (editComponents != null) {
+					editComponents.add((OptionEditComponent) editor);
+				}
+				gbc.gridx = 1;
+				gbc.fill = GridBagConstraints.HORIZONTAL;
+				gbc.anchor = GridBagConstraints.CENTER;
+				gbc.weightx = 1;
+				gbc.insets = new Insets(5, 5, 5, 5);
+				gbLayout.setConstraints(editor, gbc);
+				panel.add(editor);
+			}
+		} else {
+			panel.add(new JLabel("No options."));
+		}
+		return panel;
+	}
 
-    public void resetToDefaults() {
-        for (OptionEditComponent editor : this.editComponents) {
-            editor.setEditState(editor.getEditedOption().getDefaultCLIString());
-        }
-    }
+	public static JComponent getEditComponent(Option option) {
 
-    public void applyChanges() {
-        for (OptionEditComponent editor : this.editComponents) {
-            try {
-                editor.applyState();
-            } catch (Exception ex) {
-                GUIUtils.showExceptionDialog(this, "Problem with option "
-                        + editor.getEditedOption().getName(), ex);
-            }
-        }
-    }
+		// Object classInstance;
 
-    protected static JPanel createLabelledOptionComponentListPanel(
-            Option[] options, List<OptionEditComponent> editComponents) {
-        JPanel panel = new JPanel();
-        if ((options != null) && (options.length > 0)) {
-            GridBagLayout gbLayout = new GridBagLayout();
-            GridBagConstraints gbc = new GridBagConstraints();
-            panel.setLayout(gbLayout);
-            for (int i = 0; i < options.length; i++) {
-                JLabel label = new JLabel(options[i].getName());
-                label.setToolTipText(options[i].getPurpose());
-                gbc.gridx = 0;
-                gbc.fill = GridBagConstraints.NONE;
-                gbc.anchor = GridBagConstraints.EAST;
-                gbc.weightx = 0;
-                gbc.insets = new Insets(5, 5, 5, 5);
-                gbLayout.setConstraints(label, gbc);
-                panel.add(label);
-                JComponent editor = getEditComponent(options[i]);
-                label.setLabelFor(editor);
-                if (editComponents != null) {
-                    editComponents.add((OptionEditComponent) editor);
-                }
-                gbc.gridx = 1;
-                gbc.fill = GridBagConstraints.HORIZONTAL;
-                gbc.anchor = GridBagConstraints.CENTER;
-                gbc.weightx = 1;
-                gbc.insets = new Insets(5, 5, 5, 5);
-                gbLayout.setConstraints(editor, gbc);
-                panel.add(editor);
-            }
-        } else {
-            panel.add(new JLabel("No options."));
-        }
-        return panel;
-    }
+		// classInstance = classObject.newInstance(option);
+		Class<?> classObject;
+		Constructor<?> ctor = null;
+		JComponent ret = null;
+		String className = "";
+		try {
+			className = "com.github.javacliparser.gui." + option.getClass().getSimpleName() + "EditComponent";
+			classObject = Class.forName(className);
+			ctor = classObject.getConstructor(Option.class);
+			ret = (JComponent) ctor.newInstance(option);
+		} catch (Throwable t1) {
+			try {
+				className = "moa.gui." + option.getClass().getSimpleName() + "EditComponent";
+				classObject = Class.forName(className);
+				ctor = classObject.getConstructor(Option.class);
+				ret = (JComponent) ctor.newInstance(option);
+			} catch (Throwable t3) {
+				// throw new Exception("Class not found: " + className);
+				System.out.println("Class not found: " + className);
+			}
+		}
+		return ret;
+	}
 
-    public static JComponent getEditComponent(Option option){
-     
-        //Object classInstance;
-        
-        //classInstance = classObject.newInstance(option);
-        Class<?> classObject;
-        Constructor<?> ctor = null;
-        JComponent ret = null;
-        String className="";
-        try {
-            className = "com.github.javacliparser.gui."+option.getClass().getSimpleName()+"EditComponent";
-            classObject = Class.forName(className);
-            ctor = classObject.getConstructor(Option.class);
-            ret = (JComponent) ctor.newInstance(option);
-        } catch (Throwable t1) {
-            try{
-                className = "moa.gui."+option.getClass().getSimpleName()+"EditComponent";
-                classObject = Class.forName(className);
-                ctor = classObject.getConstructor(Option.class);
-                ret = (JComponent) ctor.newInstance(option);
-            } catch (Throwable t3) {
-                    //throw new Exception("Class not found: " + className);
-                System.out.println("Class not found: " + className);
-            }
-        }
-        return ret;
-    }
-    
-    private static void createAndShowGUI() {
+	private static void createAndShowGUI() {
 
-        // Create and set up the window.
-        JFrame frame = new JFrame("Test");
-        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+		// Create and set up the window.
+		JFrame frame = new JFrame("Test");
+		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
-        // Create and set up the content pane.
-        Options options = new HoeffdingTree().getOptions();
-        JPanel panel = new OptionsConfigurationPanel(null, options);
-        // createLabelledOptionComponentListPanel(options
-        // .getOptionArray(), null);
-        panel.setOpaque(true); // content panes must be opaque
-        frame.setContentPane(panel);
+		// Create and set up the content pane.
+		Options options = new HoeffdingTree().getOptions();
+		JPanel panel = new OptionsConfigurationPanel(null, options);
+		// createLabelledOptionComponentListPanel(options
+		// .getOptionArray(), null);
+		panel.setOpaque(true); // content panes must be opaque
+		frame.setContentPane(panel);
 
-        // Display the window.
-        frame.pack();
-        // frame.setSize(400, 400);
-        frame.setVisible(true);
-    }
+		// Display the window.
+		frame.pack();
+		// frame.setSize(400, 400);
+		frame.setVisible(true);
+	}
 
-    public static void main(String[] args) {
-        try {
-            LookAndFeel.install();
-            javax.swing.SwingUtilities.invokeLater(new Runnable() {
+	public static void main(String[] args) {
+		try {
+			LookAndFeel.install();
+			javax.swing.SwingUtilities.invokeLater(new Runnable() {
 
-                @Override
-                public void run() {
-                    createAndShowGUI();
-                }
-            });
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
+				@Override
+				public void run() {
+					createAndShowGUI();
+				}
+			});
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
 }
diff --git a/moa/src/main/java/com/github/javacliparser/gui/RangeOptionEditComponent.java b/moa/src/main/java/com/github/javacliparser/gui/RangeOptionEditComponent.java
index 7cc9197fc..7dcca362e 100644
--- a/moa/src/main/java/com/github/javacliparser/gui/RangeOptionEditComponent.java
+++ b/moa/src/main/java/com/github/javacliparser/gui/RangeOptionEditComponent.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package com.github.javacliparser.gui;
 
@@ -29,8 +29,8 @@
  */
 public class RangeOptionEditComponent extends StringOptionEditComponent {
 
-    public RangeOptionEditComponent(Option option) {
-        super(option);
-    }
-    
+	public RangeOptionEditComponent(Option option) {
+		super(option);
+	}
+
 }
diff --git a/moa/src/main/java/com/github/javacliparser/gui/StringOptionEditComponent.java b/moa/src/main/java/com/github/javacliparser/gui/StringOptionEditComponent.java
index abbdb9373..1bea2f6e7 100644
--- a/moa/src/main/java/com/github/javacliparser/gui/StringOptionEditComponent.java
+++ b/moa/src/main/java/com/github/javacliparser/gui/StringOptionEditComponent.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package com.github.javacliparser.gui;
 
@@ -29,30 +29,29 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class StringOptionEditComponent extends JTextField implements
-        OptionEditComponent {
+public class StringOptionEditComponent extends JTextField implements OptionEditComponent {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    protected Option editedOption;
+	protected Option editedOption;
 
-    public StringOptionEditComponent(Option option) {
-        this.editedOption = option;
-        setEditState(this.editedOption.getValueAsCLIString());
-    }
+	public StringOptionEditComponent(Option option) {
+		this.editedOption = option;
+		setEditState(this.editedOption.getValueAsCLIString());
+	}
 
-    @Override
-    public Option getEditedOption() {
-        return this.editedOption;
-    }
+	@Override
+	public Option getEditedOption() {
+		return this.editedOption;
+	}
 
-    @Override
-    public void setEditState(String cliString) {
-        setText(cliString);
-    }
+	@Override
+	public void setEditState(String cliString) {
+		setText(cliString);
+	}
 
-    @Override
-    public void applyState() {
-        this.editedOption.setValueViaCLIString(getText().length() > 0 ? getText() : null);
-    }
+	@Override
+	public void applyState() {
+		this.editedOption.setValueViaCLIString(getText().length() > 0 ? getText() : null);
+	}
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
index 87df078cd..d595e70d6 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/ArffLoader.java
@@ -1,17 +1,17 @@
 /*
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 package com.yahoo.labs.samoa.instances;
 
@@ -31,170 +31,170 @@
  */
 public class ArffLoader {
 
-    /**
-     * The instance information.
-     */
-    protected InstanceInformation instanceInformation;
-
-    protected InstancesHeader streamHeader;
-
-    /**
-     * Stores the indexes which are used. Values are positions read from the file,
-     * indexes correspond to Instance indexes.
-     */
-    protected List<Integer> attributeIndexes;
-    
-    /**
-     * List of loaded attributes. Only includes the attributes which are selected.
-     * Indexes are the same as Instance indexes.
-     */
-    protected List<Attribute> attributes;
-
-    /**
-     * The stream tokenizer.
-     */
-    protected StreamTokenizer streamTokenizer;
-
-   
-    /**
-     * Instantiates a new arff loader. Constructor for backwards compatibility.
-     *
-     * @param reader the reader
-     * @param size the size
-     * @param classAttribute the class attribute
-     */
-    public ArffLoader(Reader reader, int size, int classAttribute) {
-        // size is not used
-    	this(reader,String.valueOf(classAttribute));
-    }
-
-
-    /**
-     * Instantiates a new arff loader.
-     *
-     * @param reader the reader
-     * @param outputDefinition the string definition of output attributes
-     * @param inputDefinition the string definition of input attributes
-     */
-    public ArffLoader(Reader reader, String outputDefinition, String inputDefinition) {
-        BufferedReader br = new BufferedReader(reader);
-
-        // Initialize streamTokenizer
-        streamTokenizer = new StreamTokenizer(br);
-        streamTokenizer.resetSyntax();
-        streamTokenizer.whitespaceChars(0, ' ');
-        streamTokenizer.wordChars(' ' + 1, '\u00FF');
-        streamTokenizer.whitespaceChars(',', ',');
-        streamTokenizer.commentChar('%');
-        streamTokenizer.quoteChar('"');
-        streamTokenizer.quoteChar('\'');
-        streamTokenizer.ordinaryChar('{');
-        streamTokenizer.ordinaryChar('}');
-        streamTokenizer.eolIsSignificant(true);
-
-        this.instanceInformation = this.getHeader(outputDefinition, inputDefinition);
-    }
-
-    /**
-     * Instantiates a new arff loader.
-     *
-     * @param reader the reader
-     * @param outputDefinition the string definition of output attributes (others are taken as inputs)
-     */
-    public ArffLoader(Reader reader, String outputDefinition) {
-        BufferedReader br = new BufferedReader(reader);
-
-        //Initialize streamTokenizer
-        streamTokenizer = new StreamTokenizer(br);
-        streamTokenizer.resetSyntax();
-        streamTokenizer.whitespaceChars(0, ' ');
-        streamTokenizer.wordChars(' ' + 1, '\u00FF');
-        streamTokenizer.whitespaceChars(',', ',');
-        streamTokenizer.commentChar('%');
-        streamTokenizer.quoteChar('"');
-        streamTokenizer.quoteChar('\'');
-        streamTokenizer.ordinaryChar('{');
-        streamTokenizer.ordinaryChar('}');
-        streamTokenizer.eolIsSignificant(true);
-
-        this.instanceInformation = this.getHeader(outputDefinition, AttributeDefinitionUtil.nonIgnoredDefinition);
-    }
-
-    /**
-     * Returns the attribute at the index in the arff file
-     * 
-     * @param index arff file index
-     * @return corresponding attritbue
-     */
-    protected Attribute instanceAttribute(int index) {
-    	return this.attributes.get(instanceIndex(index));
-    }
-    
-    /**
-     * Remaps the arff file intex to the instance index
-     * 
-     * @param index arff file index
-     * @return instance index
-     */
-    protected int instanceIndex(int index) {
-    	return this.attributeIndexes.indexOf(index);
-    }
-    
-    /**
-     * Checks whether the arff file index has been selected
-     * 
-     * @param index arff file index
-     * @return
-     */
-    protected boolean isIndexSelected(int index) {
-    	return this.attributeIndexes.contains(index);
-    }
-
-    /**
-     * Creates the InstancesInformation from the arff header and selected input and output definitions
-     * 
-     * @param outputDefinition the selected output indexes
-     * @param inputDefinition the selected input indexes
-     * @return the InstancesInformation header
-     */
-    private InstanceInformation getHeader(String outputDefinition, String inputDefinition) {
-        String relation = "file stream";
-        List<Attribute> allAttributes = new ArrayList<Attribute>();//JD
-        int numAttributes = 0;
-        List<Integer> inputIndexes = new ArrayList<Integer>();
-        List<Integer> outputIndexes = new ArrayList<Integer>();
-        try {
-            streamTokenizer.nextToken();
-            while (streamTokenizer.ttype != StreamTokenizer.TT_EOF) {
-                //For each line
-                if (streamTokenizer.ttype == StreamTokenizer.TT_WORD && streamTokenizer.sval.startsWith("@") == true) {
-                    String token = streamTokenizer.sval.toUpperCase();
-                    if (token.startsWith("@RELATION")) {
-                        streamTokenizer.nextToken();
-                        relation = streamTokenizer.sval;
-                    } else if (token.startsWith("@ATTRIBUTE")) {
-                        streamTokenizer.nextToken();
-                        String name = streamTokenizer.sval;
-                        if (name == null) {
-                            name = Double.toString(streamTokenizer.nval);
-                        }
-                        streamTokenizer.nextToken();
-                        if (streamTokenizer.ttype == '{') {
-                            streamTokenizer.nextToken();
-                            List<String> attributeLabels = new ArrayList<String>();
-                            while (streamTokenizer.ttype != '}') {
-
-                                if (streamTokenizer.sval != null) {
-                                    attributeLabels.add(streamTokenizer.sval);
-                                } else {
-                                    attributeLabels.add(Double.toString(streamTokenizer.nval));
-                                }
-
-                                streamTokenizer.nextToken();
-                            }
-                            allAttributes.add(new Attribute(name, attributeLabels));
-                            numAttributes++;
-                            /* TODO Hierarchical loading */
+	/**
+	 * The instance information.
+	 */
+	protected InstanceInformation instanceInformation;
+
+	protected InstancesHeader streamHeader;
+
+	/**
+	 * Stores the indexes which are used. Values are positions read from the file,
+	 * indexes correspond to Instance indexes.
+	 */
+	protected List<Integer> attributeIndexes;
+
+	/**
+	 * List of loaded attributes. Only includes the attributes which are selected.
+	 * Indexes are the same as Instance indexes.
+	 */
+	protected List<Attribute> attributes;
+
+	/**
+	 * The stream tokenizer.
+	 */
+	protected StreamTokenizer streamTokenizer;
+
+	/**
+	 * Instantiates a new arff loader. Constructor for backwards compatibility.
+	 *
+	 * @param reader         the reader
+	 * @param size           the size
+	 * @param classAttribute the class attribute
+	 */
+	public ArffLoader(Reader reader, int size, int classAttribute) {
+		// size is not used
+		this(reader, String.valueOf(classAttribute));
+	}
+
+	/**
+	 * Instantiates a new arff loader.
+	 *
+	 * @param reader           the reader
+	 * @param outputDefinition the string definition of output attributes
+	 * @param inputDefinition  the string definition of input attributes
+	 */
+	public ArffLoader(Reader reader, String outputDefinition, String inputDefinition) {
+		BufferedReader br = new BufferedReader(reader);
+
+		// Initialize streamTokenizer
+		streamTokenizer = new StreamTokenizer(br);
+		streamTokenizer.resetSyntax();
+		streamTokenizer.whitespaceChars(0, ' ');
+		streamTokenizer.wordChars(' ' + 1, '\u00FF');
+		streamTokenizer.whitespaceChars(',', ',');
+		streamTokenizer.commentChar('%');
+		streamTokenizer.quoteChar('"');
+		streamTokenizer.quoteChar('\'');
+		streamTokenizer.ordinaryChar('{');
+		streamTokenizer.ordinaryChar('}');
+		streamTokenizer.eolIsSignificant(true);
+
+		this.instanceInformation = this.getHeader(outputDefinition, inputDefinition);
+	}
+
+	/**
+	 * Instantiates a new arff loader.
+	 *
+	 * @param reader           the reader
+	 * @param outputDefinition the string definition of output attributes (others
+	 *                         are taken as inputs)
+	 */
+	public ArffLoader(Reader reader, String outputDefinition) {
+		BufferedReader br = new BufferedReader(reader);
+
+		// Initialize streamTokenizer
+		streamTokenizer = new StreamTokenizer(br);
+		streamTokenizer.resetSyntax();
+		streamTokenizer.whitespaceChars(0, ' ');
+		streamTokenizer.wordChars(' ' + 1, '\u00FF');
+		streamTokenizer.whitespaceChars(',', ',');
+		streamTokenizer.commentChar('%');
+		streamTokenizer.quoteChar('"');
+		streamTokenizer.quoteChar('\'');
+		streamTokenizer.ordinaryChar('{');
+		streamTokenizer.ordinaryChar('}');
+		streamTokenizer.eolIsSignificant(true);
+
+		this.instanceInformation = this.getHeader(outputDefinition, AttributeDefinitionUtil.nonIgnoredDefinition);
+	}
+
+	/**
+	 * Returns the attribute at the index in the arff file
+	 * 
+	 * @param index arff file index
+	 * @return corresponding attritbue
+	 */
+	protected Attribute instanceAttribute(int index) {
+		return this.attributes.get(instanceIndex(index));
+	}
+
+	/**
+	 * Remaps the arff file intex to the instance index
+	 * 
+	 * @param index arff file index
+	 * @return instance index
+	 */
+	protected int instanceIndex(int index) {
+		return this.attributeIndexes.indexOf(index);
+	}
+
+	/**
+	 * Checks whether the arff file index has been selected
+	 * 
+	 * @param index arff file index
+	 * @return
+	 */
+	protected boolean isIndexSelected(int index) {
+		return this.attributeIndexes.contains(index);
+	}
+
+	/**
+	 * Creates the InstancesInformation from the arff header and selected input and
+	 * output definitions
+	 * 
+	 * @param outputDefinition the selected output indexes
+	 * @param inputDefinition  the selected input indexes
+	 * @return the InstancesInformation header
+	 */
+	private InstanceInformation getHeader(String outputDefinition, String inputDefinition) {
+		String relation = "file stream";
+		List<Attribute> allAttributes = new ArrayList<>();// JD
+		int numAttributes = 0;
+		List<Integer> inputIndexes = new ArrayList<>();
+		List<Integer> outputIndexes = new ArrayList<>();
+		try {
+			streamTokenizer.nextToken();
+			while (streamTokenizer.ttype != StreamTokenizer.TT_EOF) {
+				// For each line
+				if (streamTokenizer.ttype == StreamTokenizer.TT_WORD && streamTokenizer.sval.startsWith("@") == true) {
+					String token = streamTokenizer.sval.toUpperCase();
+					if (token.startsWith("@RELATION")) {
+						streamTokenizer.nextToken();
+						relation = streamTokenizer.sval;
+					} else if (token.startsWith("@ATTRIBUTE")) {
+						streamTokenizer.nextToken();
+						String name = streamTokenizer.sval;
+						if (name == null) {
+							name = Double.toString(streamTokenizer.nval);
+						}
+						streamTokenizer.nextToken();
+						if (streamTokenizer.ttype == '{') {
+							streamTokenizer.nextToken();
+							List<String> attributeLabels = new ArrayList<>();
+							while (streamTokenizer.ttype != '}') {
+
+								if (streamTokenizer.sval != null) {
+									attributeLabels.add(streamTokenizer.sval);
+								} else {
+									attributeLabels.add(Double.toString(streamTokenizer.nval));
+								}
+
+								streamTokenizer.nextToken();
+							}
+							allAttributes.add(new Attribute(name, attributeLabels));
+							numAttributes++;
+							/* TODO Hierarchical loading */
 //                        } else if (streamTokenizer.sval != null && streamTokenizer.sval.toUpperCase() == "HIERARCHICAL") {
 //                        	streamTokenizer.nextToken();
 //                        	DAGStructure attributeStructure = new DAGStructure();
@@ -203,262 +203,274 @@ private InstanceInformation getHeader(String outputDefinition, String inputDefin
 //                        			streamTokenizer.nextToken();
 //                        			System.out.println(streamTokenizer.sval);
 //                        		}
-//                        		
+//
 //                        	}
 //                        	
-                        } else {
-                            allAttributes.add(new Attribute(name));
-                            numAttributes++;
-                        }
-
-                    } else if (token.startsWith("@DATA")) {
-                        //System.out.print("END");
-                        streamTokenizer.nextToken();
-                        break;
-                    }
-                }
-                streamTokenizer.nextToken();
-            }
-            
-            outputIndexes = AttributeDefinitionUtil.parseAttributeDefinition(outputDefinition, numAttributes, null);
-            inputIndexes = AttributeDefinitionUtil.parseAttributeDefinition(inputDefinition, numAttributes, outputIndexes);
-
-            attributes = new ArrayList<Attribute>();
-            attributeIndexes = new ArrayList<Integer>();
-            
-            // Keep only used attributes
-            for (int i = 0; i < allAttributes.size(); i++)
-            	if (inputIndexes.contains(i) || outputIndexes.contains(i)) {
-            		attributes.add(allAttributes.get(i));
-            		attributeIndexes.add(i);
-            	}
-            
-            inputIndexes = AttributeDefinitionUtil.remapAttributeDefitinion(inputIndexes, attributeIndexes);		
-            outputIndexes = AttributeDefinitionUtil.remapAttributeDefitinion(outputIndexes, attributeIndexes);
-            
-        } catch (IOException ex) {
-            Logger.getLogger(ArffLoader.class.getName()).log(Level.SEVERE, null, ex);
-        }
-        return new InstanceInformation(relation, attributes, outputIndexes, inputIndexes);
-    }
-
-    
-    /**
-     * Reads instance. It detects if it is dense or sparse.
-     *
-     * @return the instance
-     */
-    public Instance readInstance() {
-        while (streamTokenizer.ttype == StreamTokenizer.TT_EOL) {
-            try {
-                streamTokenizer.nextToken();
-            } catch (IOException ex) {
-                Logger.getLogger(ArffLoader.class.getName()).log(Level.SEVERE, null, ex);
-            }
-        }
-        if (streamTokenizer.ttype == '{') {
-            return readInstanceSparse();
-        } else {
-            return readInstanceDense();
-        }
-
-    }
-
-    /**
-     * Reads a dense instance from the file.
-     *
-     * @return the instance
-     */
-    public Instance readInstanceDense() {
-        Instance instance = newDenseInstance(this.instanceInformation.numInputAttributes() + this.instanceInformation.numOutputAttributes());
-        int numAttribute = 0; // Instance index
-        try {
-            while (numAttribute == 0 && streamTokenizer.ttype != StreamTokenizer.TT_EOF) {
-                //For each line
-            	int valueNum = 0; // File index
-                while (streamTokenizer.ttype != StreamTokenizer.TT_EOL && streamTokenizer.ttype != StreamTokenizer.TT_EOF) {
-                    //For each item
-                	if (isIndexSelected(valueNum)) { // Check that the index is included in the selected indexes 
-	                    if (streamTokenizer.ttype == StreamTokenizer.TT_NUMBER) {
-	                        this.setValue(instance, numAttribute, streamTokenizer.nval, true);
-	                        numAttribute++;
-	
-	                    } else if (streamTokenizer.sval != null && (streamTokenizer.ttype == StreamTokenizer.TT_WORD || streamTokenizer.ttype == 34)) {
-	                        boolean isNumeric = this.instanceInformation.attribute(numAttribute).isNumeric();
-	                        double value;
-	                        if ("?".equals(streamTokenizer.sval)) {
-	                            value = Double.NaN;
-	                        } else if (isNumeric == true) {
-	                            value = Double.valueOf(streamTokenizer.sval).doubleValue();
-	                        } else {
-	                            value = this.instanceInformation.attribute(numAttribute).indexOfValue(streamTokenizer.sval);
-	                        }
-	                        this.setValue(instance, numAttribute, value, isNumeric);
-	                        numAttribute++;
-	                    }
-                    }
-                	valueNum++;
-                    streamTokenizer.nextToken();
-                }
-                streamTokenizer.nextToken();
-            }
-
-        } catch (IOException ex) {
-            Logger.getLogger(ArffLoader.class.getName()).log(Level.SEVERE, null, ex);
-        }
-        return (numAttribute > 0) ? instance : null;
-    }
-
-    /**
-     * Reads a sparse instance from the file.
-     *
-     * @return the instance
-     */
-    private Instance readInstanceSparse() {
-        //Return a sparse Instance
-        Instance instance = newSparseInstance(1.0);
-        int numAttribute;
-        ArrayList<Double> attributeValues = new ArrayList<Double>();
-        List<Integer> indexValues = new ArrayList<Integer>();
-        try {
-        	streamTokenizer.nextToken(); // Remove the '{' char
-            //For each line
-            while (streamTokenizer.ttype != StreamTokenizer.TT_EOL
-                    && streamTokenizer.ttype != StreamTokenizer.TT_EOF) {
-                while (streamTokenizer.ttype != '}') {
-                    //For each item
-                    if (streamTokenizer.ttype == StreamTokenizer.TT_NUMBER) {
-                        numAttribute = (int) streamTokenizer.nval;
-                    } else {
-                        numAttribute = Integer.parseInt(streamTokenizer.sval);
-                    }
-                    streamTokenizer.nextToken(); //The ':' char
-
-                    if (streamTokenizer.ttype == StreamTokenizer.TT_NUMBER) {
-                        if (isIndexSelected(numAttribute))
-                        	this.setSparseValue(instance, indexValues, attributeValues, instanceIndex(numAttribute), streamTokenizer.nval, true);
-
-                    } else if (streamTokenizer.sval != null && (streamTokenizer.ttype == StreamTokenizer.TT_WORD || streamTokenizer.ttype == 34)) {
-                        if (this.instanceAttribute(numAttribute).isNumeric()) {
-                            this.setSparseValue(instance, indexValues, attributeValues, instanceIndex(numAttribute), Double.valueOf(streamTokenizer.sval).doubleValue(), true);
-                        } else {
-                            this.setSparseValue(instance, indexValues, attributeValues, instanceIndex(numAttribute), instanceAttribute(numAttribute).indexOfValue(streamTokenizer.sval), false);
-                        }
-                    }
-                    streamTokenizer.nextToken();
-                }
-                streamTokenizer.nextToken(); //Remove the '}' char
-            }
-            streamTokenizer.nextToken();
-        } catch (IOException ex) {
-            Logger.getLogger(ArffLoader.class.getName()).log(Level.SEVERE, null, ex);
-        }
-        int[] arrayIndexValues = new int[attributeValues.size()];
-        double[] arrayAttributeValues = new double[attributeValues.size()];
-        for (int i = 0; i < arrayIndexValues.length; i++) {
-            arrayIndexValues[i] = indexValues.get(i).intValue();
-            arrayAttributeValues[i] = attributeValues.get(i).doubleValue();
-        }
-        instance.addSparseValues(arrayIndexValues, arrayAttributeValues, this.instanceInformation.numInputAttributes() + this.instanceInformation.numOutputAttributes());
-        return instance;
-
-    }
-
-    /**
-     * Reads an instance sparse and returns a dense one.
-     *
-     * @return the instance
-     */
-    private Instance readDenseInstanceSparse() {
-        //Returns a dense instance
-        Instance instance = newDenseInstance(this.instanceInformation.numAttributes());
-        int numAttribute;
-        try {
-            streamTokenizer.nextToken(); // Remove the '{' char
-            //For each line
-            while (streamTokenizer.ttype != StreamTokenizer.TT_EOL
-                    && streamTokenizer.ttype != StreamTokenizer.TT_EOF) {
-                while (streamTokenizer.ttype != '}') {
-                    //For each item
-                    numAttribute = (int) streamTokenizer.nval;
-                    streamTokenizer.nextToken();
-
-                    if (streamTokenizer.ttype == StreamTokenizer.TT_NUMBER) {
-                        this.setValue(instance, numAttribute, streamTokenizer.nval, true);
-                    } else if (streamTokenizer.sval != null && (streamTokenizer.ttype == StreamTokenizer.TT_WORD
-                            || streamTokenizer.ttype == 34)) {
-                        if (this.instanceAttribute(numAttribute).isNumeric()) {
-                            this.setValue(instance, numAttribute, Double.valueOf(streamTokenizer.sval).doubleValue(), true);
-                        } else {
-                            this.setValue(instance, numAttribute, this.instanceInformation.attribute(numAttribute).indexOfValue(streamTokenizer.sval), false);
-                        }
-                    }
-                    streamTokenizer.nextToken();
-                }
-                streamTokenizer.nextToken(); //Remove the '}' char
-            }
-            streamTokenizer.nextToken();
-        } catch (IOException ex) {
-            Logger.getLogger(ArffLoader.class.getName()).log(Level.SEVERE, null, ex);
-        }
-        return instance;
-    }
-
-    /**
-     * Sets the appropriate value of the instance
-     * 
-     * @param instance the instance for which the value is being set
-     * @param numAttribute the index of attribute for which the value is being set
-     * @param value the value
-     * @param isNumber whether the value is a number
-     */
-    protected void setValue(Instance instance, int numAttribute, double value, boolean isNumber) {
-        double valueAttribute;
-
-        // Correct the value for nominal attributes
-        if (isNumber && this.instanceInformation.attribute(numAttribute).isNominal()) {
-            valueAttribute = this.instanceInformation.attribute(numAttribute).indexOfValue(Double.toString(value));
-        } else {
-            valueAttribute = value;
-        }
-        
-        instance.setValue(numAttribute, valueAttribute);
-    }
-    
-    /** 
-     * Updates the list of indexes and values for the instance.
-     * No values are assigned in this method, they are all assigned at once, when the instance is done loading. 
-     * 
-     * @param instance the instance
-     * @param indexValues the assigned indexes
-     * @param attributeValues the assigned values
-     * @param numAttribute the index of the attribute which is being assigned
-     * @param value the value which is being assigned
-     * @param isNumber whether the value is a number
-     */
-    private void setSparseValue(Instance instance, List<Integer> indexValues, List<Double> attributeValues, int numAttribute, double value, boolean isNumber) {
-        double valueAttribute;
-        if (isNumber && this.instanceInformation.attribute(numAttribute).isNominal()) {
-            valueAttribute = this.instanceInformation.attribute(numAttribute).indexOfValue(Double.toString(value));
-        } else {
-            valueAttribute = value;
-        }
-        indexValues.add(numAttribute);
-        attributeValues.add(valueAttribute);
-    }
-
-    protected Instance newSparseInstance(double d, double[] res) {
-        Instance inst = new SparseInstance(d, res); //is it dense?
-        return inst;
-    }
-    
-    protected Instance newSparseInstance(double d) {
-        Instance inst = new SparseInstance(d);
-        return inst;
-    }
-
-    protected Instance newDenseInstance(int numberAttributes) {
-        Instance inst = new DenseInstance(numberAttributes);
-        return inst;
-    }
+						} else {
+							allAttributes.add(new Attribute(name));
+							numAttributes++;
+						}
+
+					} else if (token.startsWith("@DATA")) {
+						// System.out.print("END");
+						streamTokenizer.nextToken();
+						break;
+					}
+				}
+				streamTokenizer.nextToken();
+			}
+
+			outputIndexes = AttributeDefinitionUtil.parseAttributeDefinition(outputDefinition, numAttributes, null);
+			inputIndexes = AttributeDefinitionUtil.parseAttributeDefinition(inputDefinition, numAttributes,
+					outputIndexes);
+
+			attributes = new ArrayList<>();
+			attributeIndexes = new ArrayList<>();
+
+			// Keep only used attributes
+			for (int i = 0; i < allAttributes.size(); i++)
+				if (inputIndexes.contains(i) || outputIndexes.contains(i)) {
+					attributes.add(allAttributes.get(i));
+					attributeIndexes.add(i);
+				}
+
+			inputIndexes = AttributeDefinitionUtil.remapAttributeDefitinion(inputIndexes, attributeIndexes);
+			outputIndexes = AttributeDefinitionUtil.remapAttributeDefitinion(outputIndexes, attributeIndexes);
+
+		} catch (IOException ex) {
+			Logger.getLogger(ArffLoader.class.getName()).log(Level.SEVERE, null, ex);
+		}
+		return new InstanceInformation(relation, attributes, outputIndexes, inputIndexes);
+	}
+
+	/**
+	 * Reads instance. It detects if it is dense or sparse.
+	 *
+	 * @return the instance
+	 */
+	public Instance readInstance() {
+		while (streamTokenizer.ttype == StreamTokenizer.TT_EOL) {
+			try {
+				streamTokenizer.nextToken();
+			} catch (IOException ex) {
+				Logger.getLogger(ArffLoader.class.getName()).log(Level.SEVERE, null, ex);
+			}
+		}
+		if (streamTokenizer.ttype == '{') {
+			return readInstanceSparse();
+		} else {
+			return readInstanceDense();
+		}
+
+	}
+
+	/**
+	 * Reads a dense instance from the file.
+	 *
+	 * @return the instance
+	 */
+	public Instance readInstanceDense() {
+		Instance instance = newDenseInstance(
+				this.instanceInformation.numInputAttributes() + this.instanceInformation.numOutputAttributes());
+		int numAttribute = 0; // Instance index
+		try {
+			while (numAttribute == 0 && streamTokenizer.ttype != StreamTokenizer.TT_EOF) {
+				// For each line
+				int valueNum = 0; // File index
+				while (streamTokenizer.ttype != StreamTokenizer.TT_EOL
+						&& streamTokenizer.ttype != StreamTokenizer.TT_EOF) {
+					// For each item
+					if (isIndexSelected(valueNum)) { // Check that the index is included in the selected indexes
+						if (streamTokenizer.ttype == StreamTokenizer.TT_NUMBER) {
+							this.setValue(instance, numAttribute, streamTokenizer.nval, true);
+							numAttribute++;
+
+						} else if (streamTokenizer.sval != null
+								&& (streamTokenizer.ttype == StreamTokenizer.TT_WORD || streamTokenizer.ttype == 34)) {
+							boolean isNumeric = this.instanceInformation.attribute(numAttribute).isNumeric();
+							double value;
+							if ("?".equals(streamTokenizer.sval)) {
+								value = Double.NaN;
+							} else if (isNumeric == true) {
+								value = Double.valueOf(streamTokenizer.sval);
+							} else {
+								value = this.instanceInformation.attribute(numAttribute)
+										.indexOfValue(streamTokenizer.sval);
+							}
+							this.setValue(instance, numAttribute, value, isNumeric);
+							numAttribute++;
+						}
+					}
+					valueNum++;
+					streamTokenizer.nextToken();
+				}
+				streamTokenizer.nextToken();
+			}
+
+		} catch (IOException ex) {
+			Logger.getLogger(ArffLoader.class.getName()).log(Level.SEVERE, null, ex);
+		}
+		return (numAttribute > 0) ? instance : null;
+	}
+
+	/**
+	 * Reads a sparse instance from the file.
+	 *
+	 * @return the instance
+	 */
+	private Instance readInstanceSparse() {
+		// Return a sparse Instance
+		Instance instance = newSparseInstance(1.0);
+		int numAttribute;
+		ArrayList<Double> attributeValues = new ArrayList<>();
+		List<Integer> indexValues = new ArrayList<>();
+		try {
+			streamTokenizer.nextToken(); // Remove the '{' char
+			// For each line
+			while (streamTokenizer.ttype != StreamTokenizer.TT_EOL && streamTokenizer.ttype != StreamTokenizer.TT_EOF) {
+				while (streamTokenizer.ttype != '}') {
+					// For each item
+					if (streamTokenizer.ttype == StreamTokenizer.TT_NUMBER) {
+						numAttribute = (int) streamTokenizer.nval;
+					} else {
+						numAttribute = Integer.parseInt(streamTokenizer.sval);
+					}
+					streamTokenizer.nextToken(); // The ':' char
+
+					if (streamTokenizer.ttype == StreamTokenizer.TT_NUMBER) {
+						if (isIndexSelected(numAttribute))
+							this.setSparseValue(instance, indexValues, attributeValues, instanceIndex(numAttribute),
+									streamTokenizer.nval, true);
+
+					} else if (streamTokenizer.sval != null
+							&& (streamTokenizer.ttype == StreamTokenizer.TT_WORD || streamTokenizer.ttype == 34)) {
+						if (this.instanceAttribute(numAttribute).isNumeric()) {
+							this.setSparseValue(instance, indexValues, attributeValues, instanceIndex(numAttribute),
+									Double.valueOf(streamTokenizer.sval), true);
+						} else {
+							this.setSparseValue(instance, indexValues, attributeValues, instanceIndex(numAttribute),
+									instanceAttribute(numAttribute).indexOfValue(streamTokenizer.sval), false);
+						}
+					}
+					streamTokenizer.nextToken();
+				}
+				streamTokenizer.nextToken(); // Remove the '}' char
+			}
+			streamTokenizer.nextToken();
+		} catch (IOException ex) {
+			Logger.getLogger(ArffLoader.class.getName()).log(Level.SEVERE, null, ex);
+		}
+		int[] arrayIndexValues = new int[attributeValues.size()];
+		double[] arrayAttributeValues = new double[attributeValues.size()];
+		for (int i = 0; i < arrayIndexValues.length; i++) {
+			arrayIndexValues[i] = indexValues.get(i);
+			arrayAttributeValues[i] = attributeValues.get(i);
+		}
+		instance.addSparseValues(arrayIndexValues, arrayAttributeValues,
+				this.instanceInformation.numInputAttributes() + this.instanceInformation.numOutputAttributes());
+		return instance;
+
+	}
+
+	/**
+	 * Reads an instance sparse and returns a dense one.
+	 *
+	 * @return the instance
+	 */
+	private Instance readDenseInstanceSparse() {
+		// Returns a dense instance
+		Instance instance = newDenseInstance(this.instanceInformation.numAttributes());
+		int numAttribute;
+		try {
+			streamTokenizer.nextToken(); // Remove the '{' char
+			// For each line
+			while (streamTokenizer.ttype != StreamTokenizer.TT_EOL && streamTokenizer.ttype != StreamTokenizer.TT_EOF) {
+				while (streamTokenizer.ttype != '}') {
+					// For each item
+					numAttribute = (int) streamTokenizer.nval;
+					streamTokenizer.nextToken();
+
+					if (streamTokenizer.ttype == StreamTokenizer.TT_NUMBER) {
+						this.setValue(instance, numAttribute, streamTokenizer.nval, true);
+					} else if (streamTokenizer.sval != null
+							&& (streamTokenizer.ttype == StreamTokenizer.TT_WORD || streamTokenizer.ttype == 34)) {
+						if (this.instanceAttribute(numAttribute).isNumeric()) {
+							this.setValue(instance, numAttribute, Double.valueOf(streamTokenizer.sval),
+									true);
+						} else {
+							this.setValue(instance, numAttribute,
+									this.instanceInformation.attribute(numAttribute).indexOfValue(streamTokenizer.sval),
+									false);
+						}
+					}
+					streamTokenizer.nextToken();
+				}
+				streamTokenizer.nextToken(); // Remove the '}' char
+			}
+			streamTokenizer.nextToken();
+		} catch (IOException ex) {
+			Logger.getLogger(ArffLoader.class.getName()).log(Level.SEVERE, null, ex);
+		}
+		return instance;
+	}
+
+	/**
+	 * Sets the appropriate value of the instance
+	 * 
+	 * @param instance     the instance for which the value is being set
+	 * @param numAttribute the index of attribute for which the value is being set
+	 * @param value        the value
+	 * @param isNumber     whether the value is a number
+	 */
+	protected void setValue(Instance instance, int numAttribute, double value, boolean isNumber) {
+		double valueAttribute;
+
+		// Correct the value for nominal attributes
+		if (isNumber && this.instanceInformation.attribute(numAttribute).isNominal()) {
+			valueAttribute = this.instanceInformation.attribute(numAttribute).indexOfValue(Double.toString(value));
+		} else {
+			valueAttribute = value;
+		}
+
+		instance.setValue(numAttribute, valueAttribute);
+	}
+
+	/**
+	 * Updates the list of indexes and values for the instance. No values are
+	 * assigned in this method, they are all assigned at once, when the instance is
+	 * done loading.
+	 * 
+	 * @param instance        the instance
+	 * @param indexValues     the assigned indexes
+	 * @param attributeValues the assigned values
+	 * @param numAttribute    the index of the attribute which is being assigned
+	 * @param value           the value which is being assigned
+	 * @param isNumber        whether the value is a number
+	 */
+	private void setSparseValue(Instance instance, List<Integer> indexValues, List<Double> attributeValues,
+			int numAttribute, double value, boolean isNumber) {
+		double valueAttribute;
+		if (isNumber && this.instanceInformation.attribute(numAttribute).isNominal()) {
+			valueAttribute = this.instanceInformation.attribute(numAttribute).indexOfValue(Double.toString(value));
+		} else {
+			valueAttribute = value;
+		}
+		indexValues.add(numAttribute);
+		attributeValues.add(valueAttribute);
+	}
+
+	protected Instance newSparseInstance(double d, double[] res) {
+		Instance inst = new SparseInstance(d, res); // is it dense?
+		return inst;
+	}
+
+	protected Instance newSparseInstance(double d) {
+		Instance inst = new SparseInstance(d);
+		return inst;
+	}
+
+	protected Instance newDenseInstance(int numberAttributes) {
+		Instance inst = new DenseInstance(numberAttributes);
+		return inst;
+	}
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java
index 8ba3cabc1..b8f0c767e 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/Attribute.java
@@ -1,17 +1,17 @@
 /*
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 package com.yahoo.labs.samoa.instances;
 
@@ -25,137 +25,137 @@
 import java.util.Map;
 
 import moa.core.Utils;
+
 /**
  * The Class Attribute.
  */
 public class Attribute implements Serializable {
 
-    /** The keyword used to denote the start of an arff attribute declaration */
-    public final static String ARFF_ATTRIBUTE = "@attribute";
+	/** The keyword used to denote the start of an arff attribute declaration */
+	public final static String ARFF_ATTRIBUTE = "@attribute";
 
-    /** A keyword used to denote a numeric attribute */
-    public final static String ARFF_ATTRIBUTE_INTEGER = "integer";
+	/** A keyword used to denote a numeric attribute */
+	public final static String ARFF_ATTRIBUTE_INTEGER = "integer";
 
-    /** A keyword used to denote a numeric attribute */
-    public final static String ARFF_ATTRIBUTE_REAL = "real";
+	/** A keyword used to denote a numeric attribute */
+	public final static String ARFF_ATTRIBUTE_REAL = "real";
 
-    /** A keyword used to denote a numeric attribute */
-    public final static String ARFF_ATTRIBUTE_NUMERIC = "numeric";
+	/** A keyword used to denote a numeric attribute */
+	public final static String ARFF_ATTRIBUTE_NUMERIC = "numeric";
 
-    /** The keyword used to denote a string attribute */
-    public final static String ARFF_ATTRIBUTE_STRING = "string";
+	/** The keyword used to denote a string attribute */
+	public final static String ARFF_ATTRIBUTE_STRING = "string";
 
-    /** The keyword used to denote a date attribute */
-    public final static String ARFF_ATTRIBUTE_DATE = "date";
+	/** The keyword used to denote a date attribute */
+	public final static String ARFF_ATTRIBUTE_DATE = "date";
 
-    /** The keyword used to denote a hierarchical attribute */
+	/** The keyword used to denote a hierarchical attribute */
 	public final static String ARFF_ATTRIBUTE_HIERARCHICAL = "hierarchical";
 
 	/** The keyword used to denote a relation-valued attribute */
-    public final static String ARFF_ATTRIBUTE_RELATIONAL = "relational";
+	public final static String ARFF_ATTRIBUTE_RELATIONAL = "relational";
 
-    /** The keyword used to denote the end of the declaration of a subrelation */
-    public final static String ARFF_END_SUBRELATION = "@end";
+	/** The keyword used to denote the end of the declaration of a subrelation */
+	public final static String ARFF_END_SUBRELATION = "@end";
 
-    /** Strings longer than this will be stored compressed. */
-    private static final int STRING_COMPRESS_THRESHOLD = 200;
+	/** Strings longer than this will be stored compressed. */
+	private static final int STRING_COMPRESS_THRESHOLD = 200;
 
-    /**
-     * The is nominal.
-     */
-    protected boolean isNominal;
+	/**
+	 * The is nominal.
+	 */
+	protected boolean isNominal;
 
-    /**
-     * The is numeric.
-     */
-    protected boolean isNumeric;
+	/**
+	 * The is numeric.
+	 */
+	protected boolean isNumeric;
 
-    /**
-    * The is date.
-    */
-    protected boolean isDate;
+	/**
+	 * The is date.
+	 */
+	protected boolean isDate;
 
-     /** 
+	/**
 	 * The is hierarchical.
 	 */
 	protected boolean isHierarchical;
 
-	/** 
-     * Date format specification for date attributes 
-     */
-    protected SimpleDateFormat m_DateFormat;
-  
-    /**
-     * The name.
-     */
-    protected String name;
-
-    /**
-     * The attribute values.
-     */
-    protected List<String> attributeValues;
-
-    /**
+	/**
+	 * Date format specification for date attributes
+	 */
+	protected SimpleDateFormat m_DateFormat;
+
+	/**
+	 * The name.
+	 */
+	protected String name;
+
+	/**
+	 * The attribute values.
+	 */
+	protected List<String> attributeValues;
+
+	/**
 	 * The attribute structure.
 	 */
 	protected AttributeStructure attributeStructure;
 
 	/**
-     * Gets the attribute values.
-     *
-     * @return the attribute values
-     */
-    public List<String> getAttributeValues() {
-        return attributeValues;
-    }
-    
-
-    /**
-     * Instantiates a new attribute.
-     *
-     * @param string the string
-     */
-    public Attribute(String string) {
-        this.name = string;
-        this.isNumeric = true;
-    }
-
-    /**
-     * Instantiates a new attribute.
-     *
-     * @param attributeName the attribute name
-     * @param attributeValues the attribute values
-     */
-    public Attribute(String attributeName, List<String> attributeValues) {
-        this.name = attributeName;
-        this.attributeValues = attributeValues;
-        this.isNominal = true;
-    }
-
-    /**
-     * Instantiates a new attribute.
-     *
-     * @param attributeName the attribute name
-     * @param dateFormat the format of the date used
-     */
-    public Attribute(String attributeName, String dateFormat) {
-        this.name = attributeName;        
-        this.valuesStringAttribute = null;
-        this.isDate = true;
-        
-        if (dateFormat != null) {
-          m_DateFormat = new SimpleDateFormat(dateFormat);
-        } else {
-          m_DateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
-        }
-  }
-                   
-    /**
-     * Instantiates a new attribute.
+	 * Gets the attribute values.
 	 *
-	 * @param attributeName the attribute name
+	 * @return the attribute values
+	 */
+	public List<String> getAttributeValues() {
+		return attributeValues;
+	}
+
+	/**
+	 * Instantiates a new attribute.
+	 *
+	 * @param string the string
+	 */
+	public Attribute(String string) {
+		this.name = string;
+		this.isNumeric = true;
+	}
+
+	/**
+	 * Instantiates a new attribute.
+	 *
+	 * @param attributeName   the attribute name
 	 * @param attributeValues the attribute values
-	 * @param attributeStructure the attribute structure 
+	 */
+	public Attribute(String attributeName, List<String> attributeValues) {
+		this.name = attributeName;
+		this.attributeValues = attributeValues;
+		this.isNominal = true;
+	}
+
+	/**
+	 * Instantiates a new attribute.
+	 *
+	 * @param attributeName the attribute name
+	 * @param dateFormat    the format of the date used
+	 */
+	public Attribute(String attributeName, String dateFormat) {
+		this.name = attributeName;
+		this.valuesStringAttribute = null;
+		this.isDate = true;
+
+		if (dateFormat != null) {
+			m_DateFormat = new SimpleDateFormat(dateFormat);
+		} else {
+			m_DateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
+		}
+	}
+
+	/**
+	 * Instantiates a new attribute.
+	 *
+	 * @param attributeName      the attribute name
+	 * @param attributeValues    the attribute values
+	 * @param attributeStructure the attribute structure
 	 */
 	public Attribute(String attributeName, List<String> attributeValues, AttributeStructure attributeStructure) {
 		this.name = attributeName;
@@ -163,193 +163,195 @@ public Attribute(String attributeName, List<String> attributeValues, AttributeSt
 		this.attributeStructure = attributeStructure;
 		this.isHierarchical = true;
 	}
+
 	/**
 	 * Instantiates a new attribute.
-     */
-    public Attribute() {
-        this("");
-    }
-
-    /**
-     * Checks if is nominal.
-     *
-     * @return true, if is nominal
-     */
-    public boolean isNominal() {
-        return this.isNominal;
-    }
-
-    /**
-     * Name.
-     *
-     * @return the string
-     */
-    public String name() {
-        return this.name;
-    }
-
-    /**
-     * Value.
-     *
-     * @param value the value
-     * @return the string
-     */
-    public String value(int value) {
-        return attributeValues.get(value);
-    }
-
-    /**
-     * Checks if is numeric.
-     *
-     * @return true, if is numeric
-     */
-    public boolean isNumeric() {
-        return isNumeric;
-    }
-
-    /**
-     * Num values.
-     *
-     * @return the int
-     */
-    public int numValues() {
-        if (isNumeric()) {
-            return 0;
-        } else {
-            return attributeValues.size();
-        }
-    }
-
-    /**
+	 */
+	public Attribute() {
+		this("");
+	}
+
+	/**
+	 * Checks if is nominal.
+	 *
+	 * @return true, if is nominal
+	 */
+	public boolean isNominal() {
+		return this.isNominal;
+	}
+
+	/**
+	 * Name.
+	 *
+	 * @return the string
+	 */
+	public String name() {
+		return this.name;
+	}
+
+	/**
+	 * Value.
+	 *
+	 * @param value the value
+	 * @return the string
+	 */
+	public String value(int value) {
+		return attributeValues.get(value);
+	}
+
+	/**
+	 * Checks if is numeric.
+	 *
+	 * @return true, if is numeric
+	 */
+	public boolean isNumeric() {
+		return isNumeric;
+	}
+
+	/**
+	 * Num values.
+	 *
+	 * @return the int
+	 */
+	public int numValues() {
+		if (isNumeric()) {
+			return 0;
+		} else {
+			return attributeValues.size();
+		}
+	}
+
+	/**
 	 * Checks if is hierarchical.
-     *
+	 *
 	 * @return true, if is hierarchical
-     */
+	 */
 	public boolean isHierarchical() {
 		return this.isHierarchical;
 	}
 
-    /**
-     * Format date.
-     *
-     * @param value the value
-     * @return the string
-     */
-    String formatDate(double value) {
-        return this.m_DateFormat.format(new Date((long) value));
-    }
-
-    /**
-     * Checks if is date.
-     *
-     * @return true, if is date
-     */
-    boolean isDate() {
-        return isDate;
-    }
-
-    /**
-     * The values string attribute.
-     */
-    private Map<String, Integer> valuesStringAttribute;
-
-    /**
-     * Index of value.
-     *
-     * @param value the value
-     * @return the int
-     */
-    public final int indexOfValue(String value) {
-
-        if (isNominal() == false) {
-            return -1;
-        }
+	/**
+	 * Format date.
+	 *
+	 * @param value the value
+	 * @return the string
+	 */
+	String formatDate(double value) {
+		return this.m_DateFormat.format(new Date((long) value));
+	}
+
+	/**
+	 * Checks if is date.
+	 *
+	 * @return true, if is date
+	 */
+	boolean isDate() {
+		return isDate;
+	}
+
+	/**
+	 * The values string attribute.
+	 */
+	private Map<String, Integer> valuesStringAttribute;
+
+	/**
+	 * Index of value.
+	 *
+	 * @param value the value
+	 * @return the int
+	 */
+	public final int indexOfValue(String value) {
+
+		if (isNominal() == false) {
+			return -1;
+		}
 		// TODO check how this affects hierarchies
-        if (this.valuesStringAttribute == null) {
-            this.valuesStringAttribute = new HashMap<String, Integer>();
-            int count = 0;
-            for (String stringValue : attributeValues) {
-                this.valuesStringAttribute.put(stringValue, count);
-                count++;
-            }
-        }
-        Integer val = (Integer) this.valuesStringAttribute.get(value);
-        
-        // in case value was not on a list of unique values of nominal attribute yet, add it
-        // Hence, the list of values can be extended with new entries arriving in the stream
-        if (val == null) {
-          int currentValueCount=this.valuesStringAttribute.size();
-          this.valuesStringAttribute.put(value,currentValueCount);
-          this.attributeValues.add(value);
-          return currentValueCount;
-        } else {
-            return val.intValue();
-        }
-    }
-    
-    /**
-    * Returns a description of this attribute in ARFF format. Quotes
-    * strings if they contain whitespace characters, or if they
-     * are a question mark.
-     *
-     * @return a description of this attribute as a string
-     */
-    public final String toString() {
-    
-    StringBuffer text = new StringBuffer();
-    
-    text.append(ARFF_ATTRIBUTE).append(" ").append(Utils.quote(this.name())).append(" ");
-    
-    if (this.isNominal){
-        text.append('{');
-        Enumeration enu =  enumerateValues();
-        while (enu.hasMoreElements()) {
-            text.append(Utils.quote((String) enu.nextElement()));
-            if (enu.hasMoreElements())
-                text.append(',');
-        }
-        text.append('}');
-    } else if (this.isNumeric){
-        text.append(ARFF_ATTRIBUTE_NUMERIC);
-    } else if (this.isDate){
-        text.append(ARFF_ATTRIBUTE_DATE).append(" ").append(Utils.quote(m_DateFormat.toPattern()));
+		if (this.valuesStringAttribute == null) {
+			this.valuesStringAttribute = new HashMap<>();
+			int count = 0;
+			for (String stringValue : attributeValues) {
+				this.valuesStringAttribute.put(stringValue, count);
+				count++;
+			}
+		}
+		Integer val = this.valuesStringAttribute.get(value);
+
+		// in case value was not on a list of unique values of nominal attribute yet,
+		// add it
+		// Hence, the list of values can be extended with new entries arriving in the
+		// stream
+		if (val == null) {
+			int currentValueCount = this.valuesStringAttribute.size();
+			this.valuesStringAttribute.put(value, currentValueCount);
+			this.attributeValues.add(value);
+			return currentValueCount;
+		} else {
+			return val;
+		}
+	}
+
+	/**
+	 * Returns a description of this attribute in ARFF format. Quotes strings if
+	 * they contain whitespace characters, or if they are a question mark.
+	 *
+	 * @return a description of this attribute as a string
+	 */
+	@Override
+	public final String toString() {
+
+		StringBuffer text = new StringBuffer();
+
+		text.append(ARFF_ATTRIBUTE).append(" ").append(Utils.quote(this.name())).append(" ");
+
+		if (this.isNominal) {
+			text.append('{');
+			Enumeration enu = enumerateValues();
+			while (enu.hasMoreElements()) {
+				text.append(Utils.quote((String) enu.nextElement()));
+				if (enu.hasMoreElements())
+					text.append(',');
+			}
+			text.append('}');
+		} else if (this.isNumeric) {
+			text.append(ARFF_ATTRIBUTE_NUMERIC);
+		} else if (this.isDate) {
+			text.append(ARFF_ATTRIBUTE_DATE).append(" ").append(Utils.quote(m_DateFormat.toPattern()));
 		} else if (this.isHierarchical) {
 			text.append(ARFF_ATTRIBUTE_HIERARCHICAL).append(" ");
 
 			text.append("{");
 			// TODO output hierarchy
 			text.append("}");
-			
-    } else{
-        text.append("UNKNOW");
-    }
-    
-    return text.toString();
-  }
-  
-    /**
-   * Returns an enumeration of all the attribute's values if the
-   * attribute is nominal, null otherwise.
-   *
-   * @return enumeration of all the attribute's values
-   */
-  public final /*@ pure @*/ Enumeration enumerateValues() {
-
-    if (this.isNominal()) {
-      return Collections.enumeration(this.attributeValues);
-    }
-    return null;
+
+		} else {
+			text.append("UNKNOW");
+		}
+
+		return text.toString();
 	}
 
+	/**
+	 * Returns an enumeration of all the attribute's values if the attribute is
+	 * nominal, null otherwise.
+	 *
+	 * @return enumeration of all the attribute's values
+	 */
+	public final /* @ pure @ */ Enumeration enumerateValues() {
+
+		if (this.isNominal()) {
+			return Collections.enumeration(this.attributeValues);
+		}
+		return null;
+	}
 
 	public String attributeType() {
 		if (this.isNominal())
 			return "nominal";
 		else if (this.isNumeric())
 			return "numeric";
-		else if (this.isHierarchical()) 
+		else if (this.isHierarchical())
 			return "hierarchical";
 		else
 			return "other";
-  }
+	}
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/AttributesInformation.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/AttributesInformation.java
index 0932d3502..b026b4e71 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/AttributesInformation.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/AttributesInformation.java
@@ -1,17 +1,17 @@
 /*
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 package com.yahoo.labs.samoa.instances;
 
@@ -19,9 +19,9 @@
 import java.util.List;
 
 /**
- * Class for storing the information of the attributes.
- * It stores only information about discrete attributes and suppose that
- * the default attribute is numeric.
+ * Class for storing the information of the attributes. It stores only
+ * information about discrete attributes and suppose that the default attribute
+ * is numeric.
  *
  * @version $Revision: 7 $
  */
@@ -58,25 +58,25 @@ public AttributesInformation() {
 	 */
 	public Attribute attribute(int indexAttribute) {
 		if (this.attributes == null) {
-			//All attributes are numeric
+			// All attributes are numeric
 			return defaultNumericAttribute();
 		}
 		return attributes.get(indexAttribute);
 	}
 
-	/*public void add(Attribute attribute, int value) {
-        this.attributes.add(attribute);
-        this.indexValues.add(value);
-    }*/
+	/*
+	 * public void add(Attribute attribute, int value) {
+	 * this.attributes.add(attribute); this.indexValues.add(value); }
+	 */
 
 	/**
 	 * Sets the attribute information.
 	 *
 	 * @param v the new attribute information
 	 */
-    public void setAttributes(List<Attribute> v) {
-        this.attributes = v;
-    }
+	public void setAttributes(List<Attribute> v) {
+		this.attributes = v;
+	}
 
 	public int numAttributes() {
 		return this.attributes.size();
@@ -91,8 +91,7 @@ private Attribute defaultNumericAttribute() {
 
 	public void deleteAttributeAt(int index) {
 		if ((index < 0) || (index > this.attributes.size() - 1)) {
-			throw new IllegalArgumentException("Can't delete attribute: index out "
-					+ "of range");
+			throw new IllegalArgumentException("Can't delete attribute: index out " + "of range");
 		}
 
 		this.attributes.remove(index);
@@ -100,10 +99,9 @@ public void deleteAttributeAt(int index) {
 
 	public void insertAttributeAt(Attribute attribute, int index) {
 		if ((index < 0) || (index > this.attributes.size())) {
-			throw new IllegalArgumentException("Can't insert attribute: index out "
-					+ "of range");
+			throw new IllegalArgumentException("Can't insert attribute: index out " + "of range");
 		}
-		
+
 		this.attributes.add(index, attribute);
 	}
 
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/DAGStructure.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/DAGStructure.java
index b26cd433c..40745e451 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/DAGStructure.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/DAGStructure.java
@@ -7,28 +7,28 @@
 
 public class DAGStructure implements AttributeStructure {
 	public Node root;
-	
+
 	public Map<String, Node> nodes;
-	
+
 	public int type;
-	
+
 	public static int HIERARCHY_TYPE = 0;
 	public static int DAG_TYPE = 1;
-	
+
 	public DAGStructure() {
 		this.type = DAGStructure.HIERARCHY_TYPE;
-		this.nodes = new HashMap<String, Node>();
+		this.nodes = new HashMap<>();
 		this.root = null;
 	}
-	
+
 	public boolean hasNode(String description) {
 		return nodes.containsKey(description);
 	}
-	
+
 	public void addNode(String description) {
 		nodes.put(description, new Node(description));
 	}
-	
+
 	public void addChild(String parent, String child) {
 		Node p = nodes.get(parent);
 		Node c = nodes.get(child);
@@ -38,43 +38,44 @@ public void addChild(String parent, String child) {
 			this.type = DAGStructure.DAG_TYPE;
 		}
 	}
-	
+
 	public void setRoot(String description) {
 		if (this.nodes.containsKey(description)) {
 			this.root = this.nodes.get(description);
 		}
 	}
-	
+
 	public class Node {
 		public String description;
-		
+
 		public List<Node> ancestors;
 		public List<Node> children;
-		
+
 		public Node(String description) {
 			this.description = description;
-			this.ancestors = new ArrayList<Node>();
-			this.children = new ArrayList<Node>();
+			this.ancestors = new ArrayList<>();
+			this.children = new ArrayList<>();
 		}
-		
+
 		public void addAncestor(Node ancestor) {
 			this.ancestors.add(ancestor);
 		}
-		
+
 		public void addChild(Node child) {
 			this.ancestors.add(child);
 		}
-		
+
 		public boolean isRoot() {
 			// Should only be called when the structure is built
 			return this.ancestors.isEmpty();
 		}
-		
+
 		public double getLevel() {
 			// Check how this is done when a DAG is used instead of a hierarchy
-			if (this.isRoot()) return 0;
+			if (this.isRoot())
+				return 0;
 			else {
-				double total = Integer.MAX_VALUE; 
+				double total = Integer.MAX_VALUE;
 				for (Node ancestor : this.ancestors) {
 					total = total + ancestor.getLevel();
 				}
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/DenseInstance.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/DenseInstance.java
index f8bc4b60d..56200853a 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/DenseInstance.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/DenseInstance.java
@@ -1,17 +1,17 @@
 /*
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 package com.yahoo.labs.samoa.instances;
 
@@ -20,45 +20,45 @@
  */
 public class DenseInstance extends InstanceImpl {
 
-    /**
-	 * 
+	/**
+	 *
 	 */
 	private static final long serialVersionUID = 2470663722464623836L;
 
 	/**
-     * Instantiates a new dense instance.
-     *
-     * @param weight the weight
-     * @param res the res
-     */
-    public DenseInstance(double weight, double[] res) {
-        super(weight, res);
-    }
+	 * Instantiates a new dense instance.
+	 *
+	 * @param weight the weight
+	 * @param res    the res
+	 */
+	public DenseInstance(double weight, double[] res) {
+		super(weight, res);
+	}
 
-    /**
-     * Instantiates a new dense instance.
-     *
-     * @param inst the inst
-     */
-    public DenseInstance(InstanceImpl inst) {
-        super(inst);
-    }
+	/**
+	 * Instantiates a new dense instance.
+	 *
+	 * @param inst the inst
+	 */
+	public DenseInstance(InstanceImpl inst) {
+		super(inst);
+	}
 
-    /**
-     * Instantiates a new dense instance.
-     *
-     * @param inst the inst
-     */
-    public DenseInstance(Instance inst) {
-        super((InstanceImpl) inst);
-    }
+	/**
+	 * Instantiates a new dense instance.
+	 *
+	 * @param inst the inst
+	 */
+	public DenseInstance(Instance inst) {
+		super((InstanceImpl) inst);
+	}
 
-    /**
-     * Instantiates a new dense instance.
-     *
-     * @param numberAttributes the number attributes
-     */
-    public DenseInstance(double numberAttributes) {
-        super((int) numberAttributes);
-    }
+	/**
+	 * Instantiates a new dense instance.
+	 *
+	 * @param numberAttributes the number attributes
+	 */
+	public DenseInstance(double numberAttributes) {
+		super((int) numberAttributes);
+	}
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/DenseInstanceData.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/DenseInstanceData.java
index 38ae074f4..4735b99b0 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/DenseInstanceData.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/DenseInstanceData.java
@@ -1,17 +1,17 @@
 /*
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 
 package com.yahoo.labs.samoa.instances;
@@ -22,169 +22,166 @@
 public class DenseInstanceData implements InstanceData {
 
 	/**
-     * Instantiates a new dense instance data.
-     *
-     * @param array the array
-     */
-    public DenseInstanceData(double[] array) {
-       this.attributeValues = array;
-    }
-    
-    /**
-     * Instantiates a new dense instance data.
-     *
-     * @param length the length
-     */
-    public DenseInstanceData(int length) {
-       this.attributeValues = new double[length];
-    }
-    
-    /**
-     * Instantiates a new dense instance data.
-     */
-    public DenseInstanceData() {
-       this(0);
-    }
-    
-    /** The attribute values. */
-    protected double[] attributeValues;
-
-    /**
-     * Num attributes.
-     *
-     * @return the int
-     */
-    @Override
-    public int numAttributes() {
-        return this.attributeValues.length;
-    }
-
-    /**
-     * Value.
-     *
-     * @param indexAttribute the index attribute
-     * @return the double
-     */
-    @Override
-    public double value(int indexAttribute) {
-        return this.attributeValues[indexAttribute];
-    }
-
-    /**
-     * Checks if is missing.
-     *
-     * @param indexAttribute the index attribute
-     * @return true, if is missing
-     */
-    @Override
-    public boolean isMissing(int indexAttribute) {
-       return Double.isNaN(this.value(indexAttribute));
-    }
-
-    /**
-     * Num values.
-     *
-     * @return the int
-     */
-    @Override
-    public int numValues() {
-        return numAttributes();
-    }
-
-    /**
-     * Index.
-     *
-     * @param indexAttribute the index attribute
-     * @return the int
-     */
-    @Override
-    public int index(int indexAttribute) {
-        return indexAttribute;
-    }
-
-    /**
-     * Value sparse.
-     *
-     * @param indexAttribute the index attribute
-     * @return the double
-     */
-    @Override
-    public double valueSparse(int indexAttribute) {
-        return value(indexAttribute);
-    }
-
-    /**
-     * Checks if is missing sparse.
-     *
-     * @param indexAttribute the index attribute
-     * @return true, if is missing sparse
-     */
-    @Override
-    public boolean isMissingSparse(int indexAttribute) {
-        return isMissing(indexAttribute);
-    }
-
-    /**
-     * To double array.
-     *
-     * @return the double[]
-     */
-    @Override
-    public double[] toDoubleArray() {
-        return attributeValues.clone();
-    }
-
-    /**
-     * Sets the value.
-     *
-     * @param attributeIndex the attribute index
-     * @param d the d
-     */
-    @Override
-    public void setValue(int attributeIndex, double d) {
-        this.attributeValues[attributeIndex] = d;
-    }
-
-    @Override
-    public void deleteAttributeAt(int index) {
-        double[] newValues = new double[attributeValues.length - 1];
-
-        System.arraycopy(attributeValues, 0, newValues, 0, index);
-        if (index < attributeValues.length - 1) {
-          System.arraycopy(attributeValues, index + 1, newValues, index,
-              attributeValues.length - (index + 1));
-        }
-        attributeValues = newValues;
-    }
-
-    @Override
-    public void insertAttributeAt(int index) {
-        if ((index< 0) || (index > numAttributes())) {
-                throw new IllegalArgumentException("Can't insert attribute: index out "
-                        + "of range");
-            }
-        double[] newValues = new double[attributeValues.length + 1];
-
-        System.arraycopy(attributeValues , 0, newValues, 0, index);
-        newValues[index] = Double.NaN; //Missing Value
-        System.arraycopy(attributeValues , index, newValues, index + 1,
-                attributeValues .length - index);
-        attributeValues  = newValues;
-
-    }
-
-    @Override
-    public InstanceData copy() {
-        return new DenseInstanceData(this.attributeValues.clone());
-    }
-     
-    @Override
-    public String toString() {
-    	StringBuilder out = new StringBuilder();
-    	for (int i = 0; i < attributeValues.length; i++) {
-    		out.append(attributeValues[i]);
-    		out.append(",");
-    	}
-    	return out.toString();
-    }
+	 * Instantiates a new dense instance data.
+	 *
+	 * @param array the array
+	 */
+	public DenseInstanceData(double[] array) {
+		this.attributeValues = array;
+	}
+
+	/**
+	 * Instantiates a new dense instance data.
+	 *
+	 * @param length the length
+	 */
+	public DenseInstanceData(int length) {
+		this.attributeValues = new double[length];
+	}
+
+	/**
+	 * Instantiates a new dense instance data.
+	 */
+	public DenseInstanceData() {
+		this(0);
+	}
+
+	/** The attribute values. */
+	protected double[] attributeValues;
+
+	/**
+	 * Num attributes.
+	 *
+	 * @return the int
+	 */
+	@Override
+	public int numAttributes() {
+		return this.attributeValues.length;
+	}
+
+	/**
+	 * Value.
+	 *
+	 * @param indexAttribute the index attribute
+	 * @return the double
+	 */
+	@Override
+	public double value(int indexAttribute) {
+		return this.attributeValues[indexAttribute];
+	}
+
+	/**
+	 * Checks if is missing.
+	 *
+	 * @param indexAttribute the index attribute
+	 * @return true, if is missing
+	 */
+	@Override
+	public boolean isMissing(int indexAttribute) {
+		return Double.isNaN(this.value(indexAttribute));
+	}
+
+	/**
+	 * Num values.
+	 *
+	 * @return the int
+	 */
+	@Override
+	public int numValues() {
+		return numAttributes();
+	}
+
+	/**
+	 * Index.
+	 *
+	 * @param indexAttribute the index attribute
+	 * @return the int
+	 */
+	@Override
+	public int index(int indexAttribute) {
+		return indexAttribute;
+	}
+
+	/**
+	 * Value sparse.
+	 *
+	 * @param indexAttribute the index attribute
+	 * @return the double
+	 */
+	@Override
+	public double valueSparse(int indexAttribute) {
+		return value(indexAttribute);
+	}
+
+	/**
+	 * Checks if is missing sparse.
+	 *
+	 * @param indexAttribute the index attribute
+	 * @return true, if is missing sparse
+	 */
+	@Override
+	public boolean isMissingSparse(int indexAttribute) {
+		return isMissing(indexAttribute);
+	}
+
+	/**
+	 * To double array.
+	 *
+	 * @return the double[]
+	 */
+	@Override
+	public double[] toDoubleArray() {
+		return attributeValues.clone();
+	}
+
+	/**
+	 * Sets the value.
+	 *
+	 * @param attributeIndex the attribute index
+	 * @param d              the d
+	 */
+	@Override
+	public void setValue(int attributeIndex, double d) {
+		this.attributeValues[attributeIndex] = d;
+	}
+
+	@Override
+	public void deleteAttributeAt(int index) {
+		double[] newValues = new double[attributeValues.length - 1];
+
+		System.arraycopy(attributeValues, 0, newValues, 0, index);
+		if (index < attributeValues.length - 1) {
+			System.arraycopy(attributeValues, index + 1, newValues, index, attributeValues.length - (index + 1));
+		}
+		attributeValues = newValues;
+	}
+
+	@Override
+	public void insertAttributeAt(int index) {
+		if ((index < 0) || (index > numAttributes())) {
+			throw new IllegalArgumentException("Can't insert attribute: index out " + "of range");
+		}
+		double[] newValues = new double[attributeValues.length + 1];
+
+		System.arraycopy(attributeValues, 0, newValues, 0, index);
+		newValues[index] = Double.NaN; // Missing Value
+		System.arraycopy(attributeValues, index, newValues, index + 1, attributeValues.length - index);
+		attributeValues = newValues;
+
+	}
+
+	@Override
+	public InstanceData copy() {
+		return new DenseInstanceData(this.attributeValues.clone());
+	}
+
+	@Override
+	public String toString() {
+		StringBuilder out = new StringBuilder();
+		for (int i = 0; i < attributeValues.length; i++) {
+			out.append(attributeValues[i]);
+			out.append(",");
+		}
+		return out.toString();
+	}
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/FeatureRelevanceResult.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/FeatureRelevanceResult.java
index cc29c97d4..5e8f77d86 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/FeatureRelevanceResult.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/FeatureRelevanceResult.java
@@ -3,12 +3,12 @@
 import java.util.List;
 
 public interface FeatureRelevanceResult {
-	public void addFeature(Attribute attr);
-	
-	public void setFeatureRelevance(Attribute attr, double relevance);
-	
-	public double getFeatureRelevance(Attribute attr);
-	
-	public List<Attribute> getFeatures();
+	void addFeature(Attribute attr);
+
+	void setFeatureRelevance(Attribute attr, double relevance);
+
+	double getFeatureRelevance(Attribute attr);
+
+	List<Attribute> getFeatures();
 
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/FilteredSparseInstance.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/FilteredSparseInstance.java
index ab8e6d52e..a2c1b8af2 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/FilteredSparseInstance.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/FilteredSparseInstance.java
@@ -2,73 +2,71 @@
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 package com.yahoo.labs.samoa.instances;
 
 /**
  * The Class FilteredSparseInstance.
  *
- * This class is an extension to the original SparseInstance.
- * It has been created to be used with feature selection
- * algorithms for data streams.
- * In contrast to SparseInstance objects, missing values are
- * represented as NaNs instead of 0s (zeros).
- * This allows learners to skip features with missing values.
+ * This class is an extension to the original SparseInstance. It has been
+ * created to be used with feature selection algorithms for data streams. In
+ * contrast to SparseInstance objects, missing values are represented as NaNs
+ * instead of 0s (zeros). This allows learners to skip features with missing
+ * values.
  *
  * @author Jean Paul Barddal
  */
 public class FilteredSparseInstance extends SparseInstance {
 
-    /**
-     * Instantiates a new sparse instance.
-     *
-     * @param d         the d
-     * @param res       the res
-     */
-    public FilteredSparseInstance(double d, double[] res) {
-        super(d, res);
-    }
-
+	/**
+	 * Instantiates a new sparse instance.
+	 *
+	 * @param d   the d
+	 * @param res the res
+	 */
+	public FilteredSparseInstance(double d, double[] res) {
+		super(d, res);
+	}
 
-    /**
-     * Instantiates a new sparse instance.
-     *
-     * @param inst the inst
-     */
-    public FilteredSparseInstance(InstanceImpl inst) {
-        super(inst);
-    }
+	/**
+	 * Instantiates a new sparse instance.
+	 *
+	 * @param inst the inst
+	 */
+	public FilteredSparseInstance(InstanceImpl inst) {
+		super(inst);
+	}
 
-    /**
-     * Instantiates a new sparse instance.
-     *
-     * @param numberAttributes the number attributes
-     */
-    public FilteredSparseInstance(double numberAttributes) {
-        super(numberAttributes);
-    }
+	/**
+	 * Instantiates a new sparse instance.
+	 *
+	 * @param numberAttributes the number attributes
+	 */
+	public FilteredSparseInstance(double numberAttributes) {
+		super(numberAttributes);
+	}
 
-    /**
-     * Instantiates a new sparse instance.
-     *
-     * @param weight           the weight
-     * @param attributeValues  the attribute values
-     * @param indexValues      the index values
-     * @param numberAttributes the number attributes
-     */
-    public FilteredSparseInstance(double weight, double[] attributeValues, int[] indexValues, int numberAttributes) {
-        super(numberAttributes);
-        this.weight = weight;
-        this.instanceData = new FilteredSparseInstanceData(attributeValues, indexValues, numberAttributes);
-    }
+	/**
+	 * Instantiates a new sparse instance.
+	 *
+	 * @param weight           the weight
+	 * @param attributeValues  the attribute values
+	 * @param indexValues      the index values
+	 * @param numberAttributes the number attributes
+	 */
+	public FilteredSparseInstance(double weight, double[] attributeValues, int[] indexValues, int numberAttributes) {
+		super(numberAttributes);
+		this.weight = weight;
+		this.instanceData = new FilteredSparseInstanceData(attributeValues, indexValues, numberAttributes);
+	}
 
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/FilteredSparseInstanceData.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/FilteredSparseInstanceData.java
index 512224dfd..233b411bc 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/FilteredSparseInstanceData.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/FilteredSparseInstanceData.java
@@ -1,62 +1,59 @@
-/* 
+/*
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 package com.yahoo.labs.samoa.instances;
 
 /**
  * The Class FilteredSparseInstanceData.
  *
- * This class is an extension to the original SparseInstanceData.
- * It has been created to be used with feature selection
- * algorithms for data streams.
- * In contrast to SparseInstanceData objects, missing values are
- * represented as NaNs instead of 0s (zeros).
- * This allows learners to skip features with missing values.
+ * This class is an extension to the original SparseInstanceData. It has been
+ * created to be used with feature selection algorithms for data streams. In
+ * contrast to SparseInstanceData objects, missing values are represented as
+ * NaNs instead of 0s (zeros). This allows learners to skip features with
+ * missing values.
  *
  * @author Jean Paul Barddal
  */
 public class FilteredSparseInstanceData extends SparseInstanceData {
 
+	/**
+	 * Instantiates a new sparse instance data.
+	 *
+	 * @param attributeValues  the attribute values
+	 * @param indexValues      the index values
+	 * @param numberAttributes the number attributes
+	 */
+	public FilteredSparseInstanceData(double[] attributeValues, int[] indexValues, int numberAttributes) {
+		super(attributeValues, indexValues, numberAttributes);
+	}
 
-    /**
-     * Instantiates a new sparse instance data.
-     *
-     * @param attributeValues  the attribute values
-     * @param indexValues      the index values
-     * @param numberAttributes the number attributes
-     */
-    public FilteredSparseInstanceData(double[] attributeValues, int[] indexValues, int numberAttributes) {
-        super(attributeValues, indexValues, numberAttributes);
-    }
-
-
-    /**
-     * Value of the attribute in the indexAttribute position.
-     * If this value is absent, a NaN value (marker of missing value)
-     * is returned, otherwise this method returns the actual value.
-     *
-     * @param indexAttribute the index attribute
-     * @return the double
-     */
-    @Override
-    public double value(int indexAttribute) {
-        int location = locateIndex(indexAttribute);
-        if ((location >= 0) && (indexValues[location] == indexAttribute)) {
-            return attributeValues[location];
-        } else {
-            // returns a NaN value which represents missing values instead of a 0 (zero)
-            return Double.NaN;
-        }
-    }
+	/**
+	 * Value of the attribute in the indexAttribute position. If this value is
+	 * absent, a NaN value (marker of missing value) is returned, otherwise this
+	 * method returns the actual value.
+	 *
+	 * @param indexAttribute the index attribute
+	 * @return the double
+	 */
+	@Override
+	public double value(int indexAttribute) {
+		int location = locateIndex(indexAttribute);
+		if ((location >= 0) && (indexValues[location] == indexAttribute)) {
+			return attributeValues[location];
+		} else {
+			// returns a NaN value which represents missing values instead of a 0 (zero)
+			return Double.NaN;
+		}
+	}
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
index ddf73c9ab..2859f59a1 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/Instance.java
@@ -1,17 +1,17 @@
 /*
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 package com.yahoo.labs.samoa.instances;
 
@@ -24,352 +24,347 @@
  */
 public interface Instance extends Serializable {
 
-	public static int STRUCTURE_TYPE_SINGLE_TARGET = 0;
-	public static int STRUCTURE_TYPE_MULTI_TARGET = 1;
-	public static int STRUCTURE_TYPE_TIME_SERIES = 2;
-	public static int STRUCTURE_TYPE_HIERARHICAL = 3;
-	
-    /**
-     * Gets the weight of the instance.
-     *
-     * @return the weight
-     */
-    public double weight();
-
-    /**
-     * Sets the weight.
-     *
-     * @param weight the new weight
-     */
-    public void setWeight(double weight);
-
-    /**
-     * Attribute.
-     *
-     * @param instAttIndex the inst att index
-     * @return the attribute
-     */
-    public Attribute attribute(int instAttIndex);
-
-    
-     public int indexOf(Attribute attribute);
-    
-    /**
-     * Index of an Attribute.
-     *
-     * @param Attribute, the attribute to be found.
-     * @return the index of an attribute
-     */
+	int STRUCTURE_TYPE_SINGLE_TARGET = 0;
+	int STRUCTURE_TYPE_MULTI_TARGET = 1;
+	int STRUCTURE_TYPE_TIME_SERIES = 2;
+	int STRUCTURE_TYPE_HIERARHICAL = 3;
+
+	/**
+	 * Gets the weight of the instance.
+	 *
+	 * @return the weight
+	 */
+	double weight();
+
+	/**
+	 * Sets the weight.
+	 *
+	 * @param weight the new weight
+	 */
+	void setWeight(double weight);
+
+	/**
+	 * Attribute.
+	 *
+	 * @param instAttIndex the inst att index
+	 * @return the attribute
+	 */
+	Attribute attribute(int instAttIndex);
+
+	int indexOf(Attribute attribute);
+
+	/**
+	 * Index of an Attribute.
+	 *
+	 * @param Attribute, the attribute to be found.
+	 * @return the index of an attribute
+	 */
 //    public int indexOfAttribute(Attribute attribute);
-    
-    /**
-     * Delete attribute at.
-     *
-     * @param i the index
-     */
-    public void deleteAttributeAt(int i);
-
-    /**
-     * Insert attribute at.
-     *
-     * @param i the index
-     */
-    public void insertAttributeAt(int i);
-
-    /**
-     * Gets the number of attributes.
-     *
-     * @return the number of attributes
-     */
-    public int numAttributes();
-
-    /**
-     * Adds the sparse values.
-     *
-     * @param indexValues the index values
-     * @param attributeValues the attribute values
-     * @param numberAttributes the number attributes
-     */
-    public void addSparseValues(int[] indexValues, double[] attributeValues, int numberAttributes);
-
-    /**
-     * Gets the number of values, mainly for sparse instances.
-     *
-     * @return the number of values
-     */
-    public int numValues();
-
-    /**
-     * Gets the value of a discrete attribute as a string.
-     *
-     * @param i the i
-     * @return the string
-     */
-    public String stringValue(int i);
-
-    /**
-     * Gets the value of an attribute.
-     *
-     * @param instAttIndex the inst att index
-     * @return the double
-     */
-    public double value(int instAttIndex);
-
-    /**
-     * Gets the value of an attribute, given the attribute.
-     *
-     * @param attribute the attribute
-     * @return the double
-     */
-    public double value(Attribute attribute);
-
-    /**
-     * Sets the value of an attribute.
-     *
-     * @param instAttIndex the index
-     * @param value the value
-     */
-    public void setValue(int instAttIndex, double value);
-
-    /**
-     * Sets the value of an attribute.
-     *
-     * @param attribute, the Attribute
-     * @param value the value
-     */
-    public void setValue(Attribute attribute, double value);
-    
-    /**
-     * Checks if an attribute is missing.
-     *
-     * @param instAttIndex the inst att index
-     * @return true, if is missing
-     */
-    public boolean isMissing(int instAttIndex);
-
-    /**
-     * Checks if an attribute is missing.
-     *
-     * @param attribute, the Attribute
-     * @return true, if is missing
-     */
-    public boolean isMissing(Attribute attribute);
-
-    /**
-     * Checks if an attribute is missing.
-     *
-     * @param index the instance input attribute index
-     * @return true, if is missing
-     */
-    public boolean isInputMissing(int index);
-
-    /**
-     * Are any of the output values missing.
-     *
-     * @return true, if any output has missing value
-     */
-    public boolean missingOutputs();
-
-    /**
-     * Sets an attribute as missing
-     *
-     * @param instAttIndex, the attribute's index
-     */
-    public void setMissing(int instAttIndex);        
-
-    /**
-     * Sets an input attribute as missing
-     *
-     * @param inputAttributeIndex the index of the input attribute
-     */
-    public void setInputMissing(int inputAttributeIndex);        
-
-    /**
-     * Sets an output attribute as missing
-     *
-     * @param outputAttributeIndex the index of the output attribute
-     */
-    public void setOutputMissing(int outputAttributeIndex);        
-
-    
-    /**
-     * Sets an attribute as missing
-     *
-     * @param attribute, the Attribute
-     */
-    public void setMissing(Attribute attribute);
-    
-    
-    /**
-     * Gets the index of the attribute given the index of the array in a sparse
-     * representation.
-     *
-     * @param arrayIndex the index of the array
-     * @return the index
-     */
-    public int index(int arrayIndex);
-
-    /**
-     * Gets the value of an attribute in a sparse representation of the
-     * instance.
-     *
-     * @param i the i
-     * @return the value
-     */
-    public double valueSparse(int i);
-
-    /**
-     * Checks if the attribute is missing sparse.
-     *
-     * @param p1 the p1
-     * @return true, if is missing sparse
-     */
-    public boolean isMissingSparse(int p1);
-
-    /**
-     * To double array.
-     *
-     * @return the double[]
-     */
-    public double[] toDoubleArray();
-
-    /**
-     * Class attribute.
-     *
-     * @return the attribute
-     */
-    public Attribute classAttribute();
-
-    /**
-     * Class index.
-     *
-     * @return the int
-     */
-    public int classIndex();
-
-    /**
-     * Class is missing.
-     *
-     * @return true, if successful
-     */
-    public boolean classIsMissing();
-    
-    /**
-     * Class value.
-     *
-     * @return the double
-     */
-    public double classValue();
-
-    /**
-     * Num classes.
-     *
-     * @return the int
-     */
-    public int numClasses();
-
-    /**
-     * Sets the class value.
-     *
-     * @param d the new class value
-     */
-    public void setClassValue(double d);
-
-    /**
-     * Copy.
-     *
-     * @return the instance
-     */
-    public Instance copy();
-
-    /**
-     * Sets the dataset.
-     *
-     * @param dataset the new dataset
-     */
-    public void setDataset(InstancesHeader dataset);
-
-    /**
-     * Dataset.
-     *
-     * @return the instances
-     */
-    public InstancesHeader dataset();
-
-    /**
-     * Gets the number of input attributes.
-     *
-     * @return the number of input attributes
-     */
-    public int numInputAttributes();
-
-    /**
-     * Gets the number of output attributes.
-     *
-     * @return the number of output attributes
-     */
-    public int numOutputAttributes();
-    
-    /**
-     * Gets an input attribute given its index.
-     *
-     * @param attributeIndex the index
-     * @return the attribute
-     */
-    public Attribute inputAttribute(int attributeIndex);
-
-    /**
-     * Gets the value of an input attribute.
-     *
-     * @param attributeIndex the index
-     * @return the value
-     */
-    public double valueInputAttribute(int attributeIndex);
-
-    /**
-     * Checks if an output attribute is missing.
-     *
-     * @param index the instance output attribute index
-     * @return true, if is missing
-     */
-    public boolean isOutputMissing(int index);
-
-    /**
-     * Gets an output attribute given its index.
-     *
-     * @param attributeIndex the index
-     * @return the attribute
-     */
-    public Attribute outputAttribute(int attributeIndex);
-
-    /**
-     * Gets the value of an output attribute.
-     *
-     * @param attributeIndex the index
-     * @return the value
-     */
-    public double classValue(int attributeIndex);
-
-    /**
-     * Sets the value of an output attribute.
-     *
-     * @param indexClass the output attribute index
-     * @param valueAttribute the value of the attribute
-     */
-    public void setClassValue(int indexClass, double valueAttribute);
-    
-    /**
-     * Gets the value of an output attribute.
-     *
-     * @param attributeIndex the index
-     * @return the value
-     */
-    public double valueOutputAttribute(int attributeIndex);
-	
-    
-    public int structureType();
-    
-    public AttributeStructure getStructure();
-
-    public String outputAttributesToString();
+
+	/**
+	 * Delete attribute at.
+	 *
+	 * @param i the index
+	 */
+	void deleteAttributeAt(int i);
+
+	/**
+	 * Insert attribute at.
+	 *
+	 * @param i the index
+	 */
+	void insertAttributeAt(int i);
+
+	/**
+	 * Gets the number of attributes.
+	 *
+	 * @return the number of attributes
+	 */
+	int numAttributes();
+
+	/**
+	 * Adds the sparse values.
+	 *
+	 * @param indexValues      the index values
+	 * @param attributeValues  the attribute values
+	 * @param numberAttributes the number attributes
+	 */
+	void addSparseValues(int[] indexValues, double[] attributeValues, int numberAttributes);
+
+	/**
+	 * Gets the number of values, mainly for sparse instances.
+	 *
+	 * @return the number of values
+	 */
+	int numValues();
+
+	/**
+	 * Gets the value of a discrete attribute as a string.
+	 *
+	 * @param i the i
+	 * @return the string
+	 */
+	String stringValue(int i);
+
+	/**
+	 * Gets the value of an attribute.
+	 *
+	 * @param instAttIndex the inst att index
+	 * @return the double
+	 */
+	double value(int instAttIndex);
+
+	/**
+	 * Gets the value of an attribute, given the attribute.
+	 *
+	 * @param attribute the attribute
+	 * @return the double
+	 */
+	double value(Attribute attribute);
+
+	/**
+	 * Sets the value of an attribute.
+	 *
+	 * @param instAttIndex the index
+	 * @param value        the value
+	 */
+	void setValue(int instAttIndex, double value);
+
+	/**
+	 * Sets the value of an attribute.
+	 *
+	 * @param attribute, the Attribute
+	 * @param value      the value
+	 */
+	void setValue(Attribute attribute, double value);
+
+	/**
+	 * Checks if an attribute is missing.
+	 *
+	 * @param instAttIndex the inst att index
+	 * @return true, if is missing
+	 */
+	boolean isMissing(int instAttIndex);
+
+	/**
+	 * Checks if an attribute is missing.
+	 *
+	 * @param attribute, the Attribute
+	 * @return true, if is missing
+	 */
+	boolean isMissing(Attribute attribute);
+
+	/**
+	 * Checks if an attribute is missing.
+	 *
+	 * @param index the instance input attribute index
+	 * @return true, if is missing
+	 */
+	boolean isInputMissing(int index);
+
+	/**
+	 * Are any of the output values missing.
+	 *
+	 * @return true, if any output has missing value
+	 */
+	boolean missingOutputs();
+
+	/**
+	 * Sets an attribute as missing
+	 *
+	 * @param instAttIndex, the attribute's index
+	 */
+	void setMissing(int instAttIndex);
+
+	/**
+	 * Sets an input attribute as missing
+	 *
+	 * @param inputAttributeIndex the index of the input attribute
+	 */
+	void setInputMissing(int inputAttributeIndex);
+
+	/**
+	 * Sets an output attribute as missing
+	 *
+	 * @param outputAttributeIndex the index of the output attribute
+	 */
+	void setOutputMissing(int outputAttributeIndex);
+
+	/**
+	 * Sets an attribute as missing
+	 *
+	 * @param attribute, the Attribute
+	 */
+	void setMissing(Attribute attribute);
+
+	/**
+	 * Gets the index of the attribute given the index of the array in a sparse
+	 * representation.
+	 *
+	 * @param arrayIndex the index of the array
+	 * @return the index
+	 */
+	int index(int arrayIndex);
+
+	/**
+	 * Gets the value of an attribute in a sparse representation of the instance.
+	 *
+	 * @param i the i
+	 * @return the value
+	 */
+	double valueSparse(int i);
+
+	/**
+	 * Checks if the attribute is missing sparse.
+	 *
+	 * @param p1 the p1
+	 * @return true, if is missing sparse
+	 */
+	boolean isMissingSparse(int p1);
+
+	/**
+	 * To double array.
+	 *
+	 * @return the double[]
+	 */
+	double[] toDoubleArray();
+
+	/**
+	 * Class attribute.
+	 *
+	 * @return the attribute
+	 */
+	Attribute classAttribute();
+
+	/**
+	 * Class index.
+	 *
+	 * @return the int
+	 */
+	int classIndex();
+
+	/**
+	 * Class is missing.
+	 *
+	 * @return true, if successful
+	 */
+	boolean classIsMissing();
+
+	/**
+	 * Class value.
+	 *
+	 * @return the double
+	 */
+	double classValue();
+
+	/**
+	 * Num classes.
+	 *
+	 * @return the int
+	 */
+	int numClasses();
+
+	/**
+	 * Sets the class value.
+	 *
+	 * @param d the new class value
+	 */
+	void setClassValue(double d);
+
+	/**
+	 * Copy.
+	 *
+	 * @return the instance
+	 */
+	Instance copy();
+
+	/**
+	 * Sets the dataset.
+	 *
+	 * @param dataset the new dataset
+	 */
+	void setDataset(InstancesHeader dataset);
+
+	/**
+	 * Dataset.
+	 *
+	 * @return the instances
+	 */
+	InstancesHeader dataset();
+
+	/**
+	 * Gets the number of input attributes.
+	 *
+	 * @return the number of input attributes
+	 */
+	int numInputAttributes();
+
+	/**
+	 * Gets the number of output attributes.
+	 *
+	 * @return the number of output attributes
+	 */
+	int numOutputAttributes();
+
+	/**
+	 * Gets an input attribute given its index.
+	 *
+	 * @param attributeIndex the index
+	 * @return the attribute
+	 */
+	Attribute inputAttribute(int attributeIndex);
+
+	/**
+	 * Gets the value of an input attribute.
+	 *
+	 * @param attributeIndex the index
+	 * @return the value
+	 */
+	double valueInputAttribute(int attributeIndex);
+
+	/**
+	 * Checks if an output attribute is missing.
+	 *
+	 * @param index the instance output attribute index
+	 * @return true, if is missing
+	 */
+	boolean isOutputMissing(int index);
+
+	/**
+	 * Gets an output attribute given its index.
+	 *
+	 * @param attributeIndex the index
+	 * @return the attribute
+	 */
+	Attribute outputAttribute(int attributeIndex);
+
+	/**
+	 * Gets the value of an output attribute.
+	 *
+	 * @param attributeIndex the index
+	 * @return the value
+	 */
+	double classValue(int attributeIndex);
+
+	/**
+	 * Sets the value of an output attribute.
+	 *
+	 * @param indexClass     the output attribute index
+	 * @param valueAttribute the value of the attribute
+	 */
+	void setClassValue(int indexClass, double valueAttribute);
+
+	/**
+	 * Gets the value of an output attribute.
+	 *
+	 * @param attributeIndex the index
+	 * @return the value
+	 */
+	double valueOutputAttribute(int attributeIndex);
+
+	int structureType();
+
+	AttributeStructure getStructure();
+
+	String outputAttributesToString();
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceData.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceData.java
index 7d684bdee..83c999716 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceData.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceData.java
@@ -1,17 +1,17 @@
 /*
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 package com.yahoo.labs.samoa.instances;
 
@@ -24,95 +24,94 @@
  */
 public interface InstanceData extends Serializable {
 
-    /**
-     * Num attributes.
-     *
-     * @return the int
-     */
-    public int numAttributes();
+	/**
+	 * Num attributes.
+	 *
+	 * @return the int
+	 */
+	int numAttributes();
+
+	/**
+	 * Value.
+	 *
+	 * @param instAttIndex the inst att index
+	 * @return the double
+	 */
+	double value(int instAttIndex);
 
-    /**
-     * Value.
-     *
-     * @param instAttIndex the inst att index
-     * @return the double
-     */
-    public double value(int instAttIndex);
+	/**
+	 * Checks if is missing.
+	 *
+	 * @param instAttIndex the inst att index
+	 * @return true, if is missing
+	 */
+	boolean isMissing(int instAttIndex);
 
-    /**
-     * Checks if is missing.
-     *
-     * @param instAttIndex the inst att index
-     * @return true, if is missing
-     */
-    public boolean isMissing(int instAttIndex);
+	/**
+	 * Num values.
+	 *
+	 * @return the int
+	 */
+	int numValues();
 
-    /**
-     * Num values.
-     *
-     * @return the int
-     */
-    public int numValues();
+	/**
+	 * Index.
+	 *
+	 * @param i the i
+	 * @return the int
+	 */
+	int index(int i);
 
-    /**
-     * Index.
-     *
-     * @param i the i
-     * @return the int
-     */
-    public int index(int i);
+	/**
+	 * Value sparse.
+	 *
+	 * @param i the i
+	 * @return the double
+	 */
+	double valueSparse(int i);
 
-    /**
-     * Value sparse.
-     *
-     * @param i the i
-     * @return the double
-     */
-    public double valueSparse(int i);
+	/**
+	 * Checks if is missing sparse.
+	 *
+	 * @param p1 the p1
+	 * @return true, if is missing sparse
+	 */
+	boolean isMissingSparse(int p1);
 
-    /**
-     * Checks if is missing sparse.
-     *
-     * @param p1 the p1
-     * @return true, if is missing sparse
-     */
-    public boolean isMissingSparse(int p1);
+	/**
+	 * To double array.
+	 *
+	 * @return the double[]
+	 */
+	double[] toDoubleArray();
 
-    /**
-     * To double array.
-     *
-     * @return the double[]
-     */
-    public double[] toDoubleArray();
+	/**
+	 * Sets the value.
+	 *
+	 * @param m_numAttributes the m_num attributes
+	 * @param d               the d
+	 */
+	void setValue(int m_numAttributes, double d);
 
-    /**
-     * Sets the value.
-     *
-     * @param m_numAttributes the m_num attributes
-     * @param d the d
-     */
-    public void setValue(int m_numAttributes, double d);
+	/**
+	 * Deletes an attribute.
+	 *
+	 * @param index the indes
+	 */
+	void deleteAttributeAt(int index);
 
-    
-     /**
-     * Deletes an attribute.
-     *
-     * @param index the indes
-     */
-    public void deleteAttributeAt(int index);
+	/**
+	 * Inserts an attribute.
+	 *
+	 * @param index the indes
+	 */
+	void insertAttributeAt(int index);
 
-    /**
-     * Inserts an attribute.
-     *
-     * @param index the indes
-     */
-    public void insertAttributeAt(int index);
-    
-   /**
-   * Produces a shallow copy of this instance data. 
-   * 
-   * @return the shallow copy
-   */
-    public InstanceData copy();
+	/**
+	 * Produces a shallow copy of this instance data.
+	 * 
+	 * @return the shallow copy
+	 */
+	InstanceData copy();
 
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
index 24db52d83..b737b6f5b 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceImpl.java
@@ -1,17 +1,17 @@
 /*
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 package com.yahoo.labs.samoa.instances;
 
@@ -22,483 +22,501 @@
  *
  * @author abifet
  */
-public class InstanceImpl implements StructuredInstance {
+public class InstanceImpl implements Instance {
 
 	private static final long serialVersionUID = 1L;
 
-    /**
-     * The weight.
-     */
-    protected double weight;
-
-    /**
-     * The instance data.
-     */
-    protected InstanceData instanceData;
-
-    /**
-     * The instance information.
-     */
-    protected InstancesHeader instanceHeader;
-
-    /**
-     * Instantiates a new instance.
-     *
-     * @param inst the inst
-     */
-    public InstanceImpl(InstanceImpl inst) {
-        this.weight = inst.weight;
-        this.instanceData = inst.instanceData.copy();
-        this.instanceHeader = inst.instanceHeader;
-    }
-
-    //Dense
-    /**
-     * Instantiates a new instance.
-     *
-     * @param weight the weight
-     * @param res the res
-     */
-    public InstanceImpl(double weight, double[] res) {
-        this.weight = weight;
-        this.instanceData = new DenseInstanceData(res);
-    }
-
-    //Sparse
-    /**
-     * Instantiates a new instance.
-     *
-     * @param weight the weight
-     * @param attributeValues the attribute values
-     * @param indexValues the index values
-     * @param numberAttributes the number attributes
-     */
-    public InstanceImpl(double weight, double[] attributeValues, int[] indexValues, int numberAttributes) {
-        this.weight = weight;
-        this.instanceData = new SparseInstanceData(attributeValues, indexValues, numberAttributes);
-    }
-
-    /**
-     * Instantiates a new instance.
-     *
-     * @param weight the weight
-     * @param instanceData the instance data
-     */
-    public InstanceImpl(double weight, InstanceData instanceData) {
-        this.weight = weight;
-        this.instanceData = instanceData;
-    }
-
-    /**
-     * Instantiates a new instance.
-     *
-     * @param numAttributes the num attributes
-     */
-    public InstanceImpl(int numAttributes) {
-        this.instanceData = new DenseInstanceData(new double[numAttributes]); //JD
-        this.weight = 1;
-    }
-
-    /**
-     * Weight.
-     *
-     * @return the double
-     */
-    public double weight() {
-        return weight;
-    }
-
-    /**
-     * Sets the weight.
-     *
-     * @param weight the new weight
-     */
-    public void setWeight(double weight) {
-        this.weight = weight;
-    }
-
-    /**
-     * Attribute.
-     *
-     * @param index the attribute index
-     * @return the attribute
-     */
-    public Attribute attribute(int index) {
-        return this.instanceHeader.attribute(index);
-    }
-
-    public int indexOf(Attribute attribute) {
-    	return instanceHeader.instanceInformation.attributesInformation.indexOfAttribute(attribute);
-    }
-    
-    /**
-     * Delete attribute at.
-     *
-     * @param i the i
-     */
-    @Override
-    public void deleteAttributeAt(int i) {
-        this.instanceData.deleteAttributeAt(i);
-    }
-
-    /**
-     * Insert attribute at.
-     *
-     * @param i the i
-     */
-    @Override
-    public void insertAttributeAt(int i) {
-    	this.instanceData.insertAttributeAt(i);
-    }
-
-    /**
-     * Num attributes.
-     *
-     * @return the int
-     */
-    public int numAttributes() {
-        return this.instanceData.numAttributes();
-    }
-
-    /**
-     * Value.
-     *
-     * @param index the attribute index
-     * @return the double
-     */
-    public double value(int index) {
-        return this.instanceData.value(index);
-    }
-
-    /**
-     * Checks if is missing.
-     *
-     * @param instAttIndex the inst att index
-     * @return true, if is missing
-     */
-    public boolean isMissing(int instAttIndex) {
-        return this.instanceData.isMissing(instAttIndex);
-    }
-
-    /**
-     * Checks if is missing.
-     *
-     * @param instAttIndex the instance input attribute index
-     * @return true, if is missing
-     */
-    public boolean isInputMissing(int index) {
-        return this.instanceData.isMissing(this.instanceHeader.getInputInstanceIndex(index));
-    }
-
-    /**
-     * Checks if is missing.
-     *
-     * @param instAttIndex the instance output attribute index
-     * @return true, if is missing
-     */
-    public boolean isOutputMissing(int index) {
-        return this.instanceData.isMissing(this.instanceHeader.getOutputInstanceIndex(index));
-    }
-
-    /**
-     * Num values.
-     *
-     * @return the int
-     */
-    public int numValues() {
-        return this.instanceData.numValues();
-    }
-
-    /**
-     * Index.
-     *
-     * @param i the i
-     * @return the int
-     */
-    public int index(int i) {
-        return this.instanceData.index(i);
-    }
-
-    /**
-     * Value sparse.
-     *
-     * @param i the i
-     * @return the double
-     */
-    public double valueSparse(int i) {
-        return this.instanceData.valueSparse(i);
-    }
-
-    /**
-     * Checks if is missing sparse.
-     *
-     * @param p the p
-     * @return true, if is missing sparse
-     */
-    public boolean isMissingSparse(int p) {
-        return this.instanceData.isMissingSparse(p);
-    }
-
-    /**
-     * Value.
-     *
-     * @param attribute the attribute
-     * @return the double
-     */
-    public double value(Attribute attribute) {
-        return value(this.indexOf(attribute));
-    }
-
-    /**
-     * String value.
-     *
-     * @param i the i
-     * @return the string
-     */
-    @Override
-    public String stringValue(int i) {
-        throw new UnsupportedOperationException("Not yet implemented");
-    }
-
-    /**
-     * To double array.
-     *
-     * @return the double[]
-     */
-    @Override
-    public double[] toDoubleArray() {
-        return this.instanceData.toDoubleArray();
-    }
-
-    /**
-     * Sets the value.
-     *
-     * @param numAttribute the num attribute
-     * @param d the d
-     */
-    @Override
-    public void setValue(int numAttribute, double d) {
-        this.instanceData.setValue(numAttribute, d);
-    }
-
-    /**
-     * Class value.
-     *
-     * @return the double
-     */
-    @Override
-    public double classValue() {
-        return this.instanceData.value(classIndex());
-    }
-
-    /**
-     * Class index.
-     *
-     * @return the int
-     */
-    @Override
-    public int classIndex() {
-        return this.instanceHeader.classIndex();
-
-    }
-
-    /**
-     * Num classes.
-     *
-     * @return the int
-     */
-    @Override
-    public int numClasses() {
-        return this.instanceHeader.numClasses();
-    }
-
-    /**
-     * Class is missing.
-     *
-     * @return true, if successful
-     */
-    @Override
-    public boolean classIsMissing() {
-        return this.instanceData.isMissing(classIndex());
-    }
-    
-    public boolean missingOutputs() {
-    	if (this.instanceHeader.numOutputAttributes() == 1)
-    		return classIsMissing();
-    	else {
-    		for (int i = 0; i < this.instanceHeader.numOutputAttributes(); i++) {
-    			if (this.isOutputMissing(i)) {
-    				return true;
-    			}
-    		}
-    	}
-    	return false;
-    }
-
-    /**
-     * Class attribute.
-     *
-     * @return the attribute
-     */
-    @Override
-    public Attribute classAttribute() {
-        return this.instanceHeader.attribute(classIndex());
-    }
-
-    /**
-     * Sets the class value.
-     *
-     * @param d the new class value
-     */
-    @Override
-    public void setClassValue(double d) {
-        this.setValue(classIndex(), d);
-    }
-
-    /**
-     * Copy.
-     *
-     * @return the instance
-     */
-    @Override
-    public Instance copy() {
-        InstanceImpl inst = new InstanceImpl(this);
-        return inst;
-    }
-
-    /**
-     * Dataset.
-     *
-     * @return the instances
-     */
-    @Override
-    public InstancesHeader dataset() {
-        return this.instanceHeader;
-    }
-
-    /**
-     * Sets the dataset.
-     *
-     * @param dataset the new dataset
-     */
-    @Override
-    public void setDataset(InstancesHeader dataset) {
-   		this.instanceHeader = dataset;
-    }
-
-    /**
-     * Adds the sparse values.
-     *
-     * @param indexValues the index values
-     * @param attributeValues the attribute values
-     * @param numberAttributes the number attributes
-     */
-    @Override
-    public void addSparseValues(int[] indexValues, double[] attributeValues, int numberAttributes) {
-        this.instanceData = new SparseInstanceData(attributeValues, indexValues, numberAttributes); //???
-    }
-
-    /**
-     * Text representation of a InstanceImpl.
-     */
-    @Override
-    public String toString() {
-        StringBuilder str = new StringBuilder();
-        for (int index = 0; index < this.numInputAttributes() + this.numOutputAttributes(); index++) {
-            if (!this.isMissing(index)) {
-                if (this.attribute(index).isNominal()) {
-                    int valueIndex = (int) this.value(index);
-                    String stringValue = this.attribute(index).value(valueIndex);
-                    str.append(stringValue).append(",");
-                } else if (this.attribute(index).isNumeric()) {
-                    str.append(this.value(index)).append(",");
-                } else if (this.attribute(index).isDate()) {
-                    SimpleDateFormat dateFormatter = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
-                    str.append(dateFormatter.format(this.value(index))).append(",");
-                }
-            } else {
-                str.append("?,");
-            }
-        }
-        return str.toString();
-    }
-
-    @Override
-    public int numInputAttributes() {
-        return this.instanceHeader.numInputAttributes();
-    }
-
-    @Override
-    public int numOutputAttributes() {
-        return this.instanceHeader.numOutputAttributes();
-    }
-
-    @Override
-    public double classValue(int instAttIndex) {
-        return valueOutputAttribute(instAttIndex);
-    }
-
-    @Override
-    public void setClassValue(int indexClass, double valueAttribute) {
-        InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
-        this.instanceData.setValue(instanceInformation.outputAttributeIndex(indexClass), valueAttribute);
-
-    }
-
-    @Override
-    public Attribute outputAttribute(int outputIndex) {
-        InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
-        return instanceInformation.outputAttribute(outputIndex);
-    }
-
-    @Override
-    public Attribute inputAttribute(int attributeIndex) {
-        InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
-        return instanceInformation.inputAttribute(attributeIndex);
-    }
-
-    @Override
-    public double valueInputAttribute(int attributeIndex) {
-        InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
-        return this.instanceData.value(instanceInformation.inputAttributeIndex(attributeIndex));
-    }
-
-    @Override
-    public double valueOutputAttribute(int attributeIndex) {
-        InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
-        return this.instanceData.value(instanceInformation.outputAttributeIndex(attributeIndex));
-    }
-
-    @Override
-    public void setMissing(int instAttIndex) {
-        this.setValue(instAttIndex, Double.NaN);
-    }
-
-    @Override
-    public void setMissing(Attribute attribute) {
-        int index = this.indexOf(attribute);
-        this.setMissing(index);
-    }
-
-    @Override
-    public boolean isMissing(Attribute attribute) {
-        int index = this.indexOf(attribute);
-        return this.isMissing(index);
-    }
-
-    @Override
-    public void setValue(Attribute attribute, double value) {
-        int index = this.indexOf(attribute);
-        this.setValue(index, value);
-    }
-    
-    public int structureType() {
-    	return (numOutputAttributes() > 1) ? Instance.STRUCTURE_TYPE_MULTI_TARGET : Instance.STRUCTURE_TYPE_SINGLE_TARGET;
-    }
-    
-    public AttributeStructure getStructure() {
-    	return null;
-    }
+	/**
+	 * The weight.
+	 */
+	protected double weight;
+
+	/**
+	 * The instance data.
+	 */
+	protected InstanceData instanceData;
+
+	/**
+	 * The instance information.
+	 */
+	protected InstancesHeader instanceHeader;
+
+	/**
+	 * Instantiates a new instance.
+	 *
+	 * @param inst the inst
+	 */
+	public InstanceImpl(InstanceImpl inst) {
+		this.weight = inst.weight;
+		this.instanceData = inst.instanceData.copy();
+		this.instanceHeader = inst.instanceHeader;
+	}
+
+	// Dense
+	/**
+	 * Instantiates a new instance.
+	 *
+	 * @param weight the weight
+	 * @param res    the res
+	 */
+	public InstanceImpl(double weight, double[] res) {
+		this.weight = weight;
+		this.instanceData = new DenseInstanceData(res);
+	}
+
+	// Sparse
+	/**
+	 * Instantiates a new instance.
+	 *
+	 * @param weight           the weight
+	 * @param attributeValues  the attribute values
+	 * @param indexValues      the index values
+	 * @param numberAttributes the number attributes
+	 */
+	public InstanceImpl(double weight, double[] attributeValues, int[] indexValues, int numberAttributes) {
+		this.weight = weight;
+		this.instanceData = new SparseInstanceData(attributeValues, indexValues, numberAttributes);
+	}
+
+	/**
+	 * Instantiates a new instance.
+	 *
+	 * @param weight       the weight
+	 * @param instanceData the instance data
+	 */
+	public InstanceImpl(double weight, InstanceData instanceData) {
+		this.weight = weight;
+		this.instanceData = instanceData;
+	}
+
+	/**
+	 * Instantiates a new instance.
+	 *
+	 * @param numAttributes the num attributes
+	 */
+	public InstanceImpl(int numAttributes) {
+		this.instanceData = new DenseInstanceData(new double[numAttributes]); // JD
+		this.weight = 1;
+	}
+
+	/**
+	 * Weight.
+	 *
+	 * @return the double
+	 */
+	@Override
+	public double weight() {
+		return weight;
+	}
+
+	/**
+	 * Sets the weight.
+	 *
+	 * @param weight the new weight
+	 */
+	@Override
+	public void setWeight(double weight) {
+		this.weight = weight;
+	}
+
+	/**
+	 * Attribute.
+	 *
+	 * @param index the attribute index
+	 * @return the attribute
+	 */
+	@Override
+	public Attribute attribute(int index) {
+		return this.instanceHeader.attribute(index);
+	}
+
+	@Override
+	public int indexOf(Attribute attribute) {
+		return instanceHeader.instanceInformation.attributesInformation.indexOfAttribute(attribute);
+	}
+
+	/**
+	 * Delete attribute at.
+	 *
+	 * @param i the i
+	 */
+	@Override
+	public void deleteAttributeAt(int i) {
+		this.instanceData.deleteAttributeAt(i);
+	}
+
+	/**
+	 * Insert attribute at.
+	 *
+	 * @param i the i
+	 */
+	@Override
+	public void insertAttributeAt(int i) {
+		this.instanceData.insertAttributeAt(i);
+	}
+
+	/**
+	 * Num attributes.
+	 *
+	 * @return the int
+	 */
+	@Override
+	public int numAttributes() {
+		return this.instanceData.numAttributes();
+	}
+
+	/**
+	 * Value.
+	 *
+	 * @param index the attribute index
+	 * @return the double
+	 */
+	@Override
+	public double value(int index) {
+		return this.instanceData.value(index);
+	}
+
+	/**
+	 * Checks if is missing.
+	 *
+	 * @param instAttIndex the inst att index
+	 * @return true, if is missing
+	 */
+	@Override
+	public boolean isMissing(int instAttIndex) {
+		return this.instanceData.isMissing(instAttIndex);
+	}
+
+	/**
+	 * Checks if is missing.
+	 *
+	 * @param instAttIndex the instance input attribute index
+	 * @return true, if is missing
+	 */
+	@Override
+	public boolean isInputMissing(int index) {
+		return this.instanceData.isMissing(this.instanceHeader.getInputInstanceIndex(index));
+	}
+
+	/**
+	 * Checks if is missing.
+	 *
+	 * @param instAttIndex the instance output attribute index
+	 * @return true, if is missing
+	 */
+	@Override
+	public boolean isOutputMissing(int index) {
+		return this.instanceData.isMissing(this.instanceHeader.getOutputInstanceIndex(index));
+	}
+
+	/**
+	 * Num values.
+	 *
+	 * @return the int
+	 */
+	@Override
+	public int numValues() {
+		return this.instanceData.numValues();
+	}
+
+	/**
+	 * Index.
+	 *
+	 * @param i the i
+	 * @return the int
+	 */
+	@Override
+	public int index(int i) {
+		return this.instanceData.index(i);
+	}
+
+	/**
+	 * Value sparse.
+	 *
+	 * @param i the i
+	 * @return the double
+	 */
+	@Override
+	public double valueSparse(int i) {
+		return this.instanceData.valueSparse(i);
+	}
+
+	/**
+	 * Checks if is missing sparse.
+	 *
+	 * @param p the p
+	 * @return true, if is missing sparse
+	 */
+	@Override
+	public boolean isMissingSparse(int p) {
+		return this.instanceData.isMissingSparse(p);
+	}
+
+	/**
+	 * Value.
+	 *
+	 * @param attribute the attribute
+	 * @return the double
+	 */
+	@Override
+	public double value(Attribute attribute) {
+		return value(this.indexOf(attribute));
+	}
+
+	/**
+	 * String value.
+	 *
+	 * @param i the i
+	 * @return the string
+	 */
+	@Override
+	public String stringValue(int i) {
+		throw new UnsupportedOperationException("Not yet implemented");
+	}
+
+	/**
+	 * To double array.
+	 *
+	 * @return the double[]
+	 */
+	@Override
+	public double[] toDoubleArray() {
+		return this.instanceData.toDoubleArray();
+	}
+
+	/**
+	 * Sets the value.
+	 *
+	 * @param numAttribute the num attribute
+	 * @param d            the d
+	 */
+	@Override
+	public void setValue(int numAttribute, double d) {
+		this.instanceData.setValue(numAttribute, d);
+	}
+
+	/**
+	 * Class value.
+	 *
+	 * @return the double
+	 */
+	@Override
+	public double classValue() {
+		return this.instanceData.value(classIndex());
+	}
+
+	/**
+	 * Class index.
+	 *
+	 * @return the int
+	 */
+	@Override
+	public int classIndex() {
+		return this.instanceHeader.classIndex();
+
+	}
+
+	/**
+	 * Num classes.
+	 *
+	 * @return the int
+	 */
+	@Override
+	public int numClasses() {
+		return this.instanceHeader.numClasses();
+	}
+
+	/**
+	 * Class is missing.
+	 *
+	 * @return true, if successful
+	 */
+	@Override
+	public boolean classIsMissing() {
+		return this.instanceData.isMissing(classIndex());
+	}
+
+	@Override
+	public boolean missingOutputs() {
+		if (this.instanceHeader.numOutputAttributes() == 1)
+			return classIsMissing();
+		else {
+			for (int i = 0; i < this.instanceHeader.numOutputAttributes(); i++) {
+				if (this.isOutputMissing(i)) {
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Class attribute.
+	 *
+	 * @return the attribute
+	 */
+	@Override
+	public Attribute classAttribute() {
+		return this.instanceHeader.attribute(classIndex());
+	}
+
+	/**
+	 * Sets the class value.
+	 *
+	 * @param d the new class value
+	 */
+	@Override
+	public void setClassValue(double d) {
+		this.setValue(classIndex(), d);
+	}
+
+	/**
+	 * Copy.
+	 *
+	 * @return the instance
+	 */
+	@Override
+	public Instance copy() {
+		InstanceImpl inst = new InstanceImpl(this);
+		return inst;
+	}
+
+	/**
+	 * Dataset.
+	 *
+	 * @return the instances
+	 */
+	@Override
+	public InstancesHeader dataset() {
+		return this.instanceHeader;
+	}
+
+	/**
+	 * Sets the dataset.
+	 *
+	 * @param dataset the new dataset
+	 */
+	@Override
+	public void setDataset(InstancesHeader dataset) {
+		this.instanceHeader = dataset;
+	}
+
+	/**
+	 * Adds the sparse values.
+	 *
+	 * @param indexValues      the index values
+	 * @param attributeValues  the attribute values
+	 * @param numberAttributes the number attributes
+	 */
+	@Override
+	public void addSparseValues(int[] indexValues, double[] attributeValues, int numberAttributes) {
+		this.instanceData = new SparseInstanceData(attributeValues, indexValues, numberAttributes); // ???
+	}
+
+	/**
+	 * Text representation of a InstanceImpl.
+	 */
+	@Override
+	public String toString() {
+		StringBuilder str = new StringBuilder();
+		for (int index = 0; index < this.numInputAttributes() + this.numOutputAttributes(); index++) {
+			if (!this.isMissing(index)) {
+				if (this.attribute(index).isNominal()) {
+					int valueIndex = (int) this.value(index);
+					String stringValue = this.attribute(index).value(valueIndex);
+					str.append(stringValue).append(",");
+				} else if (this.attribute(index).isNumeric()) {
+					str.append(this.value(index)).append(",");
+				} else if (this.attribute(index).isDate()) {
+					SimpleDateFormat dateFormatter = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
+					str.append(dateFormatter.format(this.value(index))).append(",");
+				}
+			} else {
+				str.append("?,");
+			}
+		}
+		return str.toString();
+	}
+
+	@Override
+	public int numInputAttributes() {
+		return this.instanceHeader.numInputAttributes();
+	}
+
+	@Override
+	public int numOutputAttributes() {
+		return this.instanceHeader.numOutputAttributes();
+	}
+
+	@Override
+	public double classValue(int instAttIndex) {
+		return valueOutputAttribute(instAttIndex);
+	}
+
+	@Override
+	public void setClassValue(int indexClass, double valueAttribute) {
+		InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
+		this.instanceData.setValue(instanceInformation.outputAttributeIndex(indexClass), valueAttribute);
+
+	}
+
+	@Override
+	public Attribute outputAttribute(int outputIndex) {
+		InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
+		return instanceInformation.outputAttribute(outputIndex);
+	}
+
+	@Override
+	public Attribute inputAttribute(int attributeIndex) {
+		InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
+		return instanceInformation.inputAttribute(attributeIndex);
+	}
+
+	@Override
+	public double valueInputAttribute(int attributeIndex) {
+		InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
+		return this.instanceData.value(instanceInformation.inputAttributeIndex(attributeIndex));
+	}
+
+	@Override
+	public double valueOutputAttribute(int attributeIndex) {
+		InstanceInformation instanceInformation = this.instanceHeader.getInstanceInformation();
+		return this.instanceData.value(instanceInformation.outputAttributeIndex(attributeIndex));
+	}
+
+	@Override
+	public void setMissing(int instAttIndex) {
+		this.setValue(instAttIndex, Double.NaN);
+	}
+
+	@Override
+	public void setMissing(Attribute attribute) {
+		int index = this.indexOf(attribute);
+		this.setMissing(index);
+	}
+
+	@Override
+	public boolean isMissing(Attribute attribute) {
+		int index = this.indexOf(attribute);
+		return this.isMissing(index);
+	}
+
+	@Override
+	public void setValue(Attribute attribute, double value) {
+		int index = this.indexOf(attribute);
+		this.setValue(index, value);
+	}
+
+	@Override
+	public int structureType() {
+		return (numOutputAttributes() > 1) ? Instance.STRUCTURE_TYPE_MULTI_TARGET
+				: Instance.STRUCTURE_TYPE_SINGLE_TARGET;
+	}
+
+	@Override
+	public AttributeStructure getStructure() {
+		return null;
+	}
 
 	@Override
 	public String outputAttributesToString() {
@@ -517,7 +535,7 @@ public String outputAttributesToString() {
 	@Override
 	public void setInputMissing(int inputAttributeIndex) {
 		this.setMissing(this.instanceHeader.getInputInstanceIndex(inputAttributeIndex));
-		
+
 	}
 
 	@Override
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
index d875796e8..9469cd3d5 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstanceInformation.java
@@ -1,17 +1,17 @@
 /*
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 package com.yahoo.labs.samoa.instances;
 
@@ -52,9 +52,10 @@ public InstanceInformation(InstanceInformation chunk) {
 	 * Instantiates a new instance information.
 	 *
 	 * @param st the st
-	 * @param v the v
+	 * @param v  the v
 	 */
-	public InstanceInformation(String st, List<Attribute> attributes, List<Integer> outputIndexes, List<Integer> inputIndexes) {
+	public InstanceInformation(String st, List<Attribute> attributes, List<Integer> outputIndexes,
+			List<Integer> inputIndexes) {
 		this.relationName = st;
 		this.outputIndexes = outputIndexes;
 		this.inputIndexes = inputIndexes;
@@ -64,13 +65,16 @@ public InstanceInformation(String st, List<Attribute> attributes, List<Integer>
 	/**
 	 * Instantiates a new instance information.
 	 *
-	 * @param st the st
+	 * @param st    the st
 	 * @param input the inputs
 	 */
 	public InstanceInformation(String st, List<Attribute> input) {
 		this.relationName = st;
-		this.outputIndexes = new ArrayList<Integer>();
-		this.inputIndexes = new ArrayList<Integer>();
+		this.outputIndexes = new ArrayList<>();
+		this.inputIndexes = new ArrayList<>();
+		for (int i = 0; i < input.size(); i++) {
+			this.inputIndexes.add(i);
+		}
 		this.attributesInformation = new AttributesInformation(input);
 	}
 
@@ -86,7 +90,7 @@ public InstanceInformation() {
 
 	/**
 	 * Returns the input attribute.
-	 * 
+	 *
 	 * @param w the input attribute index (indexes only input attributes)
 	 * @return the input attribute.
 	 */
@@ -96,7 +100,7 @@ public Attribute inputAttribute(int w) {
 
 	/**
 	 * Returns the output attribute.
-	 * 
+	 *
 	 * @param w the output attribute index (indexes only output attributes)
 	 * @return the output attribute.
 	 */
@@ -104,22 +108,31 @@ public Attribute outputAttribute(int w) {
 		return this.attributesInformation.attribute(outputAttributeIndex(w));
 	}
 
-	//Information Instances
-	/* (non-Javadoc)
-	 * @see com.yahoo.labs.samoa.instances.InstanceInformationInterface#setRelationName(java.lang.String)
+	// Information Instances
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * com.yahoo.labs.samoa.instances.InstanceInformationInterface#setRelationName(
+	 * java.lang.String)
 	 */
 	public void setRelationName(String string) {
 		this.relationName = string;
 	}
 
-	/* (non-Javadoc)
-	 * @see com.yahoo.labs.samoa.instances.InstanceInformationInterface#getRelationName()
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * com.yahoo.labs.samoa.instances.InstanceInformationInterface#getRelationName()
 	 */
 	public String getRelationName() {
 		return this.relationName;
 	}
 
-	/* (non-Javadoc)
+	/*
+	 * (non-Javadoc)
+	 * 
 	 * @see com.yahoo.labs.samoa.instances.InstanceInformationInterface#classIndex()
 	 */
 	public int classIndex() {
@@ -129,12 +142,15 @@ public int classIndex() {
 	}
 
 	public void setClassIndex(int index) {
-		this.outputIndexes = new ArrayList<Integer>();
+		this.outputIndexes = new ArrayList<>();
 		this.outputIndexes.add(index);
 	}
 
-	/* (non-Javadoc)
-	 * @see com.yahoo.labs.samoa.instances.InstanceInformationInterface#classAttribute()
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * com.yahoo.labs.samoa.instances.InstanceInformationInterface#classAttribute()
 	 */
 	public Attribute classAttribute() {
 		if (this.outputIndexes.size() > 1)
@@ -142,33 +158,45 @@ public Attribute classAttribute() {
 		return this.attribute(this.classIndex());
 	}
 
-	/* (non-Javadoc)
-	 * @see com.yahoo.labs.samoa.instances.InstanceInformationInterface#numAttributes()
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * com.yahoo.labs.samoa.instances.InstanceInformationInterface#numAttributes()
 	 */
 	public int numAttributes() {
-		return this.numInputAttributes();
+		return this.attributesInformation.numAttributes();
 	}
 
-	/* (non-Javadoc)
-	 * @see com.yahoo.labs.samoa.instances.InstanceInformationInterface#attribute(int)
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * com.yahoo.labs.samoa.instances.InstanceInformationInterface#attribute(int)
 	 */
 	public Attribute attribute(int w) {
 		return this.attributesInformation.attribute(w);
 	}
 
-	/* (non-Javadoc)
+	/*
+	 * (non-Javadoc)
+	 * 
 	 * @see com.yahoo.labs.samoa.instances.InstanceInformationInterface#numClasses()
 	 */
 	public int numClasses() {
 		return this.attributesInformation.attribute(classIndex()).numValues();
 	}
 
-	/* (non-Javadoc)
-	 * @see com.yahoo.labs.samoa.instances.InstanceInformationInterface#deleteAttributeAt(java.lang.Integer)
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * com.yahoo.labs.samoa.instances.InstanceInformationInterface#deleteAttributeAt
+	 * (java.lang.Integer)
 	 */
 	public void deleteAttributeAt(int index) {
 		this.attributesInformation.deleteAttributeAt(index);
-		
+
 		for (int j = 0; j < outputIndexes.size(); j++) {
 			if (j > index) {
 				outputIndexes.set(j, outputIndexes.get(j) - 1);
@@ -176,11 +204,15 @@ public void deleteAttributeAt(int index) {
 		}
 	}
 
-	/* (non-Javadoc)
-	 * @see com.yahoo.labs.samoa.instances.InstanceInformationInterface#insertAttributeAt(com.yahoo.labs.samoa.instances.Attribute, int)
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * com.yahoo.labs.samoa.instances.InstanceInformationInterface#insertAttributeAt
+	 * (com.yahoo.labs.samoa.instances.Attribute, int)
 	 */
 	public void insertAttributeAt(Attribute attribute, int index) {
-		this.attributesInformation.insertAttributeAt(attribute,index) ;
+		this.attributesInformation.insertAttributeAt(attribute, index);
 
 		for (int j = 0; j < outputIndexes.size(); j++) {
 			if (j >= index) {
@@ -190,8 +222,8 @@ public void insertAttributeAt(Attribute attribute, int index) {
 	}
 
 	public void setAttributes(List<Attribute> v) {
-		if(this.attributesInformation==null)
-			this.attributesInformation= new AttributesInformation();
+		if (this.attributesInformation == null)
+			this.attributesInformation = new AttributesInformation();
 		this.attributesInformation.setAttributes(v);
 	}
 
@@ -201,7 +233,7 @@ public int inputAttributeIndex(int index) {
 
 	public int outputAttributeIndex(int index) {
 		// Returns actual instance attribute index!
-		return outputIndexes.get(index);    
+		return outputIndexes.get(index);
 	}
 
 	public int numInputAttributes() {
@@ -213,8 +245,8 @@ public int numOutputAttributes() {
 	}
 
 	/**
-	 * Sets the output attribute indexes, i.e., the targets. 
-	 * 
+	 * Sets the output attribute indexes, i.e., the targets.
+	 *
 	 * @param outputIndexes
 	 */
 	public void setOutputIndexes(List<Integer> outputIndexes) {
@@ -222,19 +254,19 @@ public void setOutputIndexes(List<Integer> outputIndexes) {
 	}
 
 	/**
-	 * Sets the input attribute indexes. 
-	 * 
+	 * Sets the input attribute indexes.
+	 *
 	 * @param inputIndexes
 	 */
 	public void setInputIndexes(List<Integer> inputIndexes) {
 		this.inputIndexes = inputIndexes;
 	}
 
-	/** 
+	/**
 	 * Sets all non-output attributes as input attributes.
 	 */
 	public void setInputIndexes() {
-		this.inputIndexes = new ArrayList<Integer>();
+		this.inputIndexes = new ArrayList<>();
 		for (int i = 0; i < attributesInformation.numAttributes(); i++) {
 			if (!outputIndexes.contains(i)) {
 				inputIndexes.add(i);
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
index 29c0bbd30..5b9d8e532 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/InstancesHeader.java
@@ -1,17 +1,17 @@
 /*
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 package com.yahoo.labs.samoa.instances;
 
@@ -72,39 +72,40 @@ public InstancesHeader() {
 	/**
 	 * Instantiates a new instances.
 	 *
-	 * @param reader the reader
-	 * @param size the size
+	 * @param reader         the reader
+	 * @param size           the size
 	 * @param classAttribute the class attribute
 	 */
 	public InstancesHeader(Reader reader, int size, int classAttribute) {
 		arff = new ArffLoader(reader, String.valueOf(classAttribute));
 		this.instanceInformation = arff.instanceInformation;
-		this.instances = new ArrayList<Instance>();
+		this.instances = new ArrayList<>();
 	}
 
 	/**
 	 * Instantiates a new intances header.
-	 * 
-	 * @param reader 
-	 * @param outputDefinition defines the output attributes (others are treated as inputs)
+	 *
+	 * @param reader
+	 * @param outputDefinition defines the output attributes (others are treated as
+	 *                         inputs)
 	 */
 	public InstancesHeader(Reader reader, String outputDefinition) {
 		this.arff = new ArffLoader(reader, outputDefinition);
 		this.instanceInformation = arff.instanceInformation;
-		this.instances = new ArrayList<Instance>();
+		this.instances = new ArrayList<>();
 	}
 
 	/**
 	 * Instantiates a new intances header.
-	 * 
+	 *
 	 * @param reader
 	 * @param outputDefinition defines the output attributes
-	 * @param inputDefinition defines the input attributes
+	 * @param inputDefinition  defines the input attributes
 	 */
 	public InstancesHeader(Reader reader, String outputDefinition, String inputDefinition) {
 		this.arff = new ArffLoader(reader, outputDefinition, inputDefinition);
 		this.instanceInformation = arff.instanceInformation;
-		this.instances = new ArrayList<Instance>();
+		this.instances = new ArrayList<>();
 	}
 
 	/**
@@ -113,16 +114,16 @@ public InstancesHeader(Reader reader, String outputDefinition, String inputDefin
 	 * @param reader the reader
 	 * @param range
 	 */
-	//    public Instances(Reader reader, Range range) {
-	//        this.arff = new MultiTargetArffLoader(reader, range);
-	//        this.instanceInformation = arff.getStructure();
-	//        this.instances = new ArrayList<Instance>();
-	//    }
+	// public Instances(Reader reader, Range range) {
+	// this.arff = new MultiTargetArffLoader(reader, range);
+	// this.instanceInformation = arff.getStructure();
+	// this.instances = new ArrayList<Instance>();
+	// }
 
 	/**
 	 * Instantiates a new instances.
 	 *
-	 * @param chunk the chunk
+	 * @param chunk    the chunk
 	 * @param capacity the capacity
 	 */
 	public InstancesHeader(InstancesHeader chunk, int capacity) {
@@ -130,14 +131,14 @@ public InstancesHeader(InstancesHeader chunk, int capacity) {
 		if (capacity < 0) {
 			capacity = 0;
 		}
-		this.instances = new ArrayList<Instance>(capacity);
+		this.instances = new ArrayList<>(capacity);
 	}
 
 	/**
 	 * Instantiates a new instances.
 	 *
-	 * @param st the st
-	 * @param v the v
+	 * @param st       the st
+	 * @param v        the v
 	 * @param capacity the capacity
 	 */
 	public InstancesHeader(String st, List<Attribute> v, int capacity) {
@@ -147,8 +148,8 @@ public InstancesHeader(String st, List<Attribute> v, int capacity) {
 	/**
 	 * Instantiates a new instances.
 	 *
-	 * @param chunk the chunk
-	 * @param first the first instance
+	 * @param chunk  the chunk
+	 * @param first  the first instance
 	 * @param toCopy the j
 	 */
 	public InstancesHeader(InstancesHeader chunk, int first, int toCopy) {
@@ -156,8 +157,7 @@ public InstancesHeader(InstancesHeader chunk, int first, int toCopy) {
 		this(chunk, toCopy);
 
 		if ((first < 0) || ((first + toCopy) > chunk.numInstances())) {
-			throw new IllegalArgumentException("Parameters first and/or toCopy out "
-					+ "of range");
+			throw new IllegalArgumentException("Parameters first and/or toCopy out " + "of range");
 		}
 		chunk.copyInstances(first, this, toCopy);
 	}
@@ -165,18 +165,18 @@ public InstancesHeader(InstancesHeader chunk, int first, int toCopy) {
 	/**
 	 * Instantiates a new instances.
 	 *
-	 * @param st the st
+	 * @param st       the st
 	 * @param capacity the capacity
 	 */
 	public InstancesHeader(StringReader st, int capacity) {
-		this.instances = new ArrayList<Instance>(capacity);
+		this.instances = new ArrayList<>(capacity);
 	}
 
 	public InstancesHeader getEmptyHeader() {
 		return new InstancesHeader(this, 0);
 	}
-	
-	//Information Instances
+
+	// Information Instances
 	/**
 	 * Sets the relation name.
 	 *
@@ -205,7 +205,8 @@ public int classIndex() {
 	}
 
 	/**
-	 * Sets the class index. Also sets all other attributes as input attributes for backward compatibility.
+	 * Sets the class index. Also sets all other attributes as input attributes for
+	 * backward compatibility.
 	 *
 	 * @param classIndex the new class index
 	 */
@@ -221,7 +222,7 @@ public void setOutputIndexes(List<Integer> outputIndexes) {
 	public void setInputIndexes(List<Integer> inputIndexes) {
 		this.instanceInformation.setInputIndexes(inputIndexes);
 	}
-	
+
 	public int getInputInstanceIndex(int index) {
 		return this.instanceInformation.inputAttributeIndex(index);
 	}
@@ -230,8 +231,7 @@ public int getOutputInstanceIndex(int index) {
 		return this.instanceInformation.outputAttributeIndex(index);
 	}
 
-	
-	/** 
+	/**
 	 * Sets all non-output attributes as input attributes.
 	 */
 	public void setInputIndexes() {
@@ -288,15 +288,15 @@ public void deleteAttributeAt(Integer integer) {
 	 * Insert attribute at.
 	 *
 	 * @param attribute the attribute
-	 * @param i the i
+	 * @param i         the i
 	 */
 	public void insertAttributeAt(Attribute attribute, int i) {
-		if (this.instanceInformation==null)
-			this.instanceInformation= new InstanceInformation();
+		if (this.instanceInformation == null)
+			this.instanceInformation = new InstanceInformation();
 		this.instanceInformation.insertAttributeAt(attribute, i);
 	}
 
-	//List of Instances
+	// List of Instances
 	/**
 	 * Instance.
 	 *
@@ -355,8 +355,7 @@ public void stratify(int numFolds) {
 				for (int j = index; j < numInstances(); j++) {
 					Instance instance2 = instance(j);
 					if ((instance1.classValue() == instance2.classValue())
-							|| (instance1.classIsMissing()
-									&& instance2.classIsMissing())) {
+							|| (instance1.classIsMissing() && instance2.classIsMissing())) {
 						swap(index, j);
 						index++;
 					}
@@ -368,7 +367,7 @@ public void stratify(int numFolds) {
 	}
 
 	protected void stratStep(int numFolds) {
-		ArrayList<Instance> newVec = new ArrayList<Instance>(this.instances.size());
+		ArrayList<Instance> newVec = new ArrayList<>(this.instances.size());
 		int start = 0, j;
 
 		// create stratified batch
@@ -388,8 +387,8 @@ protected void stratStep(int numFolds) {
 	 *
 	 * @param numFolds the num folds
 	 * @param numFold
-	 * @param n the n
-	 * @param random the random
+	 * @param n        the n
+	 * @param random   the random
 	 * @return the instances
 	 */
 	public InstancesHeader trainCV(int numFolds, int numFold, Random random) {
@@ -412,8 +411,7 @@ public InstancesHeader trainCV(int numFolds, int numFold) {
 		train = new InstancesHeader(this, numInstances() - numInstForFold);
 		first = numFold * (numInstances() / numFolds) + offset;
 		copyInstances(0, train, first);
-		copyInstances(first + numInstForFold, train,
-				numInstances() - first - numInstForFold);
+		copyInstances(first + numInstForFold, train, numInstances() - first - numInstForFold);
 		return train;
 	}
 
@@ -427,7 +425,7 @@ protected void copyInstances(int from, InstancesHeader dest, int num) {
 	 * Test cv.
 	 *
 	 * @param numFolds the num folds
-	 * @param numFold the num fold
+	 * @param numFold  the num fold
 	 * @return the instances
 	 */
 	public InstancesHeader testCV(int numFolds, int numFold) {
@@ -448,9 +446,10 @@ public InstancesHeader testCV(int numFolds, int numFold) {
 		return test;
 	}
 
-	/*  public Instances dataset() {
-     throw new UnsupportedOperationException("Not yet implemented");
-     }*/
+	/*
+	 * public Instances dataset() { throw new
+	 * UnsupportedOperationException("Not yet implemented"); }
+	 */
 	/**
 	 * Mean or mode.
 	 *
@@ -458,7 +457,7 @@ public InstancesHeader testCV(int numFolds, int numFold) {
 	 * @return the double
 	 */
 	public double meanOrMode(int j) {
-		throw new UnsupportedOperationException("Not yet implemented"); //CobWeb
+		throw new UnsupportedOperationException("Not yet implemented"); // CobWeb
 	}
 
 	/**
@@ -469,7 +468,7 @@ public double meanOrMode(int j) {
 	 */
 	public boolean readInstance(Reader fileReader) {
 
-		//ArffReader arff = new ArffReader(reader, this, m_Lines, 1);
+		// ArffReader arff = new ArffReader(reader, this, m_Lines, 1);
 		Instance inst = arff.readInstance();
 		if (inst != null) {
 			inst.setDataset(this);
@@ -484,7 +483,7 @@ public boolean readInstance(Reader fileReader) {
 	 * Delete.
 	 */
 	public void delete() {
-		this.instances = new ArrayList<Instance>();
+		this.instances = new ArrayList<>();
 	}
 
 	/**
@@ -494,7 +493,6 @@ public void delete(int index) {
 		this.instances.remove(index);
 	}
 
-	
 	public void setInstances(List<Instance> instances) {
 		this.instances = instances;
 	}
@@ -542,21 +540,20 @@ public Instance get(int k) {
 		return this.instance(k);
 	}
 
-	//	public void setRangeOutputIndices(Range range) {
-	//		this.instanceInformation.setRangeOutputIndices(range);
-	//		
-	//	}
+	// public void setRangeOutputIndices(Range range) {
+	// this.instanceInformation.setRangeOutputIndices(range);
+	//
+	// }
 
 	public void setAttributes(List<Attribute> v) {
-		if(this.instanceInformation==null)
-			this.instanceInformation= new InstanceInformation();
+		if (this.instanceInformation == null)
+			this.instanceInformation = new InstanceInformation();
 		this.instanceInformation.setAttributes(v);
 	}
 
 	/**
-	 * Returns the dataset as a string in ARFF format. Strings
-	 * are quoted if they contain whitespace characters, or if they
-	 * are a question mark.
+	 * Returns the dataset as a string in ARFF format. Strings are quoted if they
+	 * contain whitespace characters, or if they are a question mark.
 	 *
 	 * @return the dataset in ARFF format as a string
 	 */
@@ -564,8 +561,8 @@ public String toArff() {
 
 		StringBuffer text = new StringBuffer();
 
-		text.append(ARFF_RELATION).append(" ").
-		append(Utils.quote( this.instanceInformation.getRelationName())).append("\n\n");
+		text.append(ARFF_RELATION).append(" ").append(Utils.quote(this.instanceInformation.getRelationName()))
+				.append("\n\n");
 		for (int i = 0; i < numAttributes(); i++) {
 			text.append(attribute(i).toString()).append("\n");
 		}
@@ -576,9 +573,8 @@ public String toArff() {
 	}
 
 	/**
-	 * Returns the instances in the dataset as a string in ARFF format. Strings
-	 * are quoted if they contain whitespace characters, or if they
-	 * are a question mark.
+	 * Returns the instances in the dataset as a string in ARFF format. Strings are
+	 * quoted if they contain whitespace characters, or if they are a question mark.
 	 *
 	 * @return the dataset in ARFF format as a string
 	 */
@@ -627,32 +623,28 @@ public static String getClassLabelString(InstancesHeader context, int classLabel
 		if ((context == null) || (classLabelIndex >= context.numClasses())) {
 			return "<class " + (classLabelIndex + 1) + ">";
 		}
-		return "<class " + (classLabelIndex + 1) + ":"
-		+ context.classAttribute().value(classLabelIndex) + ">";
+		return "<class " + (classLabelIndex + 1) + ":" + context.classAttribute().value(classLabelIndex) + ">";
 	}
 
 	public static String getAttributeNameString(InstancesHeader context, int attIndex) {
 		if ((context == null) || (attIndex >= context.numAttributes())) {
 			return "[att " + (attIndex + 1) + "]";
 		}
-		return "[att " + (attIndex + 1) + ":"
-		+ context.attribute(attIndex).name() + "]";
+		return "[att " + (attIndex + 1) + ":" + context.attribute(attIndex).name() + "]";
 	}
 
 	public static String getInputAttributeNameString(InstancesHeader context, int attIndex) {
 		if ((context == null) || (attIndex >= context.numInputAttributes())) {
 			return "[att " + (attIndex + 1) + "]";
 		}
-		return "[att " + (attIndex + 1) + ":"
-		+ context.inputAttribute(attIndex).name() + "]";
+		return "[att " + (attIndex + 1) + ":" + context.inputAttribute(attIndex).name() + "]";
 	}
 
 	public static String getNominalValueString(InstancesHeader context, int attIndex, int valIndex) {
 		if (context != null) {
 			if ((attIndex < context.numInputAttributes())
 					&& (valIndex < context.inputAttribute(attIndex).numValues())) {
-				return "{val " + (valIndex + 1) + ":"
-						+ context.inputAttribute(attIndex).value(valIndex) + "}";
+				return "{val " + (valIndex + 1) + ":" + context.inputAttribute(attIndex).value(valIndex) + "}";
 			}
 		}
 		return "{val " + (valIndex + 1) + "}";
@@ -660,8 +652,7 @@ public static String getNominalValueString(InstancesHeader context, int attIndex
 
 	public static String getNumericValueString(InstancesHeader context, int attIndex, double value) {
 		if (context != null) {
-			int instAttIndex = attIndex < context.classIndex() ? attIndex
-					: attIndex + 1;
+			int instAttIndex = attIndex < context.classIndex() ? attIndex : attIndex + 1;
 			if (instAttIndex < context.numAttributes()) {
 				if (context.attribute(instAttIndex).isDate()) {
 					return context.attribute(instAttIndex).formatDate(value);
@@ -671,5 +662,4 @@ public static String getNumericValueString(InstancesHeader context, int attIndex
 		return Double.toString(value);
 	}
 
-
 }
\ No newline at end of file
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelInstance.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelInstance.java
index 842f41093..bcbffc7ec 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelInstance.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultiLabelInstance.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package com.yahoo.labs.samoa.instances;
 
@@ -30,20 +30,20 @@ public class MultiLabelInstance extends InstanceImpl {
 	private static final long serialVersionUID = 1L;
 
 	public MultiLabelInstance(double d, double[] res) {
-         super(d,res);
-    }
+		super(d, res);
+	}
 
-    public MultiLabelInstance(InstanceImpl inst) {
-        super(inst);
-    }
+	public MultiLabelInstance(InstanceImpl inst) {
+		super(inst);
+	}
 
-    int L = -1;
+	int L = -1;
 
-    public void setNumLabels(int n) {
-        this.L = n;
-    }
+	public void setNumLabels(int n) {
+		this.L = n;
+	}
 
-    public int getNumLabels() {
-        return this.L;
-    }
+	public int getNumLabels() {
+		return this.L;
+	}
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultilabelInstancesHeader.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultilabelInstancesHeader.java
index 4e84b1487..5c37f203a 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/MultilabelInstancesHeader.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/MultilabelInstancesHeader.java
@@ -15,27 +15,27 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package com.yahoo.labs.samoa.instances;
 
 /**
- * Class for storing the header or context of a multilabel data stream.
- * It allows to know the number of attributes and class labels.
+ * Class for storing the header or context of a multilabel data stream. It
+ * allows to know the number of attributes and class labels.
  *
  * @author Jesse Read (jmr30@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
 public class MultilabelInstancesHeader extends InstancesHeader {
 
-    private int m_NumLabels = -1;
+	private int m_NumLabels = -1;
 
-    public MultilabelInstancesHeader(InstancesHeader i, int numLabels) {
-        super(i);
-        m_NumLabels = numLabels;
-    }
+	public MultilabelInstancesHeader(InstancesHeader i, int numLabels) {
+		super(i);
+		m_NumLabels = numLabels;
+	}
 
-    public int getNumClassLabels() {
-        return m_NumLabels;
-    }
+	public int getNumClassLabels() {
+		return m_NumLabels;
+	}
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/SamoaToWekaInstanceConverter.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/SamoaToWekaInstanceConverter.java
index ad1acfad7..f0f00ae32 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/SamoaToWekaInstanceConverter.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/SamoaToWekaInstanceConverter.java
@@ -1,17 +1,17 @@
 /*
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 package com.yahoo.labs.samoa.instances;
 
@@ -25,112 +25,116 @@
  */
 public class SamoaToWekaInstanceConverter implements Serializable {
 
-    /** The weka instance information. */
-    protected weka.core.Instances wekaInstanceInformation;
+	/** The weka instance information. */
+	protected weka.core.Instances wekaInstanceInformation;
+
+	/**
+	 * Weka instance.
+	 *
+	 * @param inst the inst
+	 * @return the weka.core. instance
+	 */
+	public weka.core.Instance wekaInstance(Instance inst) {
+		weka.core.Instance wekaInstance;
+		if (((InstanceImpl) inst).instanceData instanceof SparseInstanceData) {
+			InstanceImpl instance = (InstanceImpl) inst;
+			SparseInstanceData sparseInstanceData = (SparseInstanceData) instance.instanceData;
+			wekaInstance = new weka.core.SparseInstance(instance.weight(), sparseInstanceData.getAttributeValues(),
+					sparseInstanceData.getIndexValues(), sparseInstanceData.getNumberAttributes());
+			/*
+			 * if (this.wekaInstanceInformation == null) { this.wekaInstanceInformation =
+			 * this.wekaInstancesInformation(inst.dataset()); }
+			 * wekaInstance.insertAttributeAt(inst.classIndex());
+			 * wekaInstance.setDataset(wekaInstanceInformation);
+			 * wekaInstance.setClassValue(inst.classValue());
+			 * //wekaInstance.setValueSparse(wekaInstance.numAttributes(),
+			 * inst.classValue());
+			 */
+		} else {
+			Instance instance = inst;
+			wekaInstance = new weka.core.DenseInstance(instance.weight(), instance.toDoubleArray());
+			/*
+			 * if (this.wekaInstanceInformation == null) { this.wekaInstanceInformation =
+			 * this.wekaInstancesInformation(inst.dataset()); } //We suppose that the class
+			 * is the last attibute. We should deal when this is not the case
+			 * wekaInstance.insertAttributeAt(inst.classIndex());
+			 * wekaInstance.setDataset(wekaInstanceInformation);
+			 * wekaInstance.setClassValue(inst.classValue());
+			 */
+		}
+		if (this.wekaInstanceInformation == null) {
+			this.wekaInstanceInformation = this.wekaInstancesInformation(inst.dataset());
+		}
+		// wekaInstance.insertAttributeAt(inst.classIndex());
+		wekaInstance.setDataset(wekaInstanceInformation);
+		if (inst.numOutputAttributes() == 1) {
+			wekaInstance.setClassValue(inst.classValue());
+		}
+
+		return wekaInstance;
+	}
+
+	/**
+	 * Weka instances.
+	 *
+	 * @param instances the instances
+	 * @return the weka.core. instances
+	 */
+	public weka.core.Instances wekaInstances(InstancesHeader instances) {
+		weka.core.Instances wekaInstances = wekaInstancesInformation(instances);
+		// We assume that we have only one WekaInstanceInformation for
+		// SamoaToWekaInstanceConverter
+		this.wekaInstanceInformation = wekaInstances;
+		for (int i = 0; i < instances.numInstances(); i++) {
+			wekaInstances.add(wekaInstance(instances.instance(i)));
+		}
+		return wekaInstances;
+	}
 
-     /**
-     * Weka instance.
-     *
-     * @param inst the inst
-     * @return the weka.core. instance
-     */
-    public weka.core.Instance wekaInstance(Instance inst) {
-        weka.core.Instance wekaInstance;
-        if (((InstanceImpl) inst).instanceData instanceof SparseInstanceData) {
-            InstanceImpl instance = (InstanceImpl) inst;
-            SparseInstanceData sparseInstanceData = (SparseInstanceData) instance.instanceData;
-            wekaInstance = new weka.core.SparseInstance(instance.weight(), sparseInstanceData.getAttributeValues(),
-                    sparseInstanceData.getIndexValues(), sparseInstanceData.getNumberAttributes());
-            /*if (this.wekaInstanceInformation == null) {
-                this.wekaInstanceInformation = this.wekaInstancesInformation(inst.dataset());
-            }
-            wekaInstance.insertAttributeAt(inst.classIndex());
-            wekaInstance.setDataset(wekaInstanceInformation);
-            wekaInstance.setClassValue(inst.classValue());
-            //wekaInstance.setValueSparse(wekaInstance.numAttributes(), inst.classValue());*/
-        } else {
-            Instance instance = inst;
-            wekaInstance = new weka.core.DenseInstance(instance.weight(), instance.toDoubleArray());
-           /* if (this.wekaInstanceInformation == null) {
-                this.wekaInstanceInformation = this.wekaInstancesInformation(inst.dataset());
-            }
-            //We suppose that the class is the last attibute. We should deal when this is not the case
-            wekaInstance.insertAttributeAt(inst.classIndex());
-            wekaInstance.setDataset(wekaInstanceInformation);
-            wekaInstance.setClassValue(inst.classValue());*/
-        }
-        if (this.wekaInstanceInformation == null) {
-            this.wekaInstanceInformation = this.wekaInstancesInformation(inst.dataset());
-        }
-        //wekaInstance.insertAttributeAt(inst.classIndex());
-        wekaInstance.setDataset(wekaInstanceInformation);
-        if (inst.numOutputAttributes() == 1){
-            wekaInstance.setClassValue(inst.classValue());
-        }
-        
-        return wekaInstance;
-    }
-    
-     /**
-     * Weka instances.
-     *
-     * @param instances the instances
-     * @return the weka.core. instances
-     */
-    public weka.core.Instances wekaInstances(InstancesHeader instances) {
-        weka.core.Instances wekaInstances = wekaInstancesInformation(instances);
-        //We assume that we have only one WekaInstanceInformation for SamoaToWekaInstanceConverter
-        this.wekaInstanceInformation = wekaInstances;
-        for (int i = 0; i < instances.numInstances(); i++) {
-            wekaInstances.add(wekaInstance(instances.instance(i)));
-        }
-        return wekaInstances;
-    }
+	/**
+	 * Weka instances information.
+	 *
+	 * @param instances the instances
+	 * @return the weka.core. instances
+	 */
+	public weka.core.Instances wekaInstancesInformation(InstancesHeader instances) {
+		weka.core.Instances wekaInstances;
+		ArrayList<weka.core.Attribute> attInfo = new ArrayList<>();
+		for (int i = 0; i < instances.numAttributes(); i++) {
+			attInfo.add(wekaAttribute(i, instances.attribute(i)));
+		}
+		wekaInstances = new weka.core.Instances(instances.getRelationName(), attInfo, 0);
+		if (instances.instanceInformation.numOutputAttributes() == 1) {
+			wekaInstances.setClassIndex(instances.classIndex());
+		} else {
+			// Assign a classIndex to a MultiLabel instance for compatibility reasons
+			wekaInstances.setClassIndex(instances.instanceInformation.numOutputAttributes() - 1); // instances.numAttributes()-1);
+																									// //Last
+		}
+		// System.out.println(attInfo.get(3).name());
+		// System.out.println(attInfo.get(3).isNominal());
+		// System.out.println(wekaInstances.attribute(3).name());
+		// System.out.println(wekaInstances.attribute(3).isNominal());
+		return wekaInstances;
+	}
 
-     /**
-     * Weka instances information.
-     *
-     * @param instances the instances
-     * @return the weka.core. instances
-     */
-    public weka.core.Instances wekaInstancesInformation(InstancesHeader instances) {
-        weka.core.Instances wekaInstances;
-        ArrayList<weka.core.Attribute> attInfo = new ArrayList<weka.core.Attribute>();
-        for (int i = 0; i < instances.numAttributes(); i++) {
-            attInfo.add(wekaAttribute(i, instances.attribute(i)));
-        }
-        wekaInstances = new weka.core.Instances(instances.getRelationName(), attInfo, 0);
-        if (instances.instanceInformation.numOutputAttributes() == 1){
-            wekaInstances.setClassIndex(instances.classIndex());
-        }
-        else {
-            //Assign a classIndex to a MultiLabel instance for compatibility reasons
-            wekaInstances.setClassIndex(instances.instanceInformation.numOutputAttributes()-1); //instances.numAttributes()-1); //Last
-        }
-        //System.out.println(attInfo.get(3).name());
-        //System.out.println(attInfo.get(3).isNominal());
-        //System.out.println(wekaInstances.attribute(3).name());
-        //System.out.println(wekaInstances.attribute(3).isNominal());
-        return wekaInstances;
-    }
+	/**
+	 * Weka attribute.
+	 *
+	 * @param index     the index
+	 * @param attribute the attribute
+	 * @return the weka.core. attribute
+	 */
+	protected weka.core.Attribute wekaAttribute(int index, Attribute attribute) {
+		weka.core.Attribute wekaAttribute;
+		if (attribute.isNominal()) {
+			wekaAttribute = new weka.core.Attribute(attribute.name(), attribute.getAttributeValues(), index);
 
-     /**
-     * Weka attribute.
-     *
-     * @param index the index
-     * @param attribute the attribute
-     * @return the weka.core. attribute
-     */
-    protected weka.core.Attribute wekaAttribute(int index, Attribute attribute) {
-        weka.core.Attribute wekaAttribute;
-        if (attribute.isNominal()) {
-            wekaAttribute = new weka.core.Attribute(attribute.name(), attribute.getAttributeValues(), index);
-          
-        } else {
-            wekaAttribute = new weka.core.Attribute(attribute.name(), index);
-        }
-        //System.out.println(wekaAttribute.name());
-        //System.out.println(wekaAttribute.isNominal());
-        return wekaAttribute;
-    }
+		} else {
+			wekaAttribute = new weka.core.Attribute(attribute.name(), index);
+		}
+		// System.out.println(wekaAttribute.name());
+		// System.out.println(wekaAttribute.isNominal());
+		return wekaAttribute;
+	}
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/SparseInstance.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/SparseInstance.java
index 1b8ff6e75..d0ba871f5 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/SparseInstance.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/SparseInstance.java
@@ -2,15 +2,15 @@
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 package com.yahoo.labs.samoa.instances;
 
@@ -21,44 +21,44 @@
  */
 public class SparseInstance extends InstanceImpl {
 
-    /**
-     * Instantiates a new sparse instance.
-     *
-     * @param d the d
-     * @param res the res
-     */
-    public SparseInstance(double d, double[] res) {
-        super(d, res);
-    }
+	/**
+	 * Instantiates a new sparse instance.
+	 *
+	 * @param d   the d
+	 * @param res the res
+	 */
+	public SparseInstance(double d, double[] res) {
+		super(d, res);
+	}
 
-    /**
-     * Instantiates a new sparse instance.
-     *
-     * @param inst the inst
-     */
-    public SparseInstance(InstanceImpl inst) {
-        super(inst);
-    }
+	/**
+	 * Instantiates a new sparse instance.
+	 *
+	 * @param inst the inst
+	 */
+	public SparseInstance(InstanceImpl inst) {
+		super(inst);
+	}
 
-    /**
-     * Instantiates a new sparse instance.
-     *
-     * @param numberAttributes the number attributes
-     */
-    public SparseInstance(double numberAttributes) {
-        super(1, null, null, (int) numberAttributes);
-    }
+	/**
+	 * Instantiates a new sparse instance.
+	 *
+	 * @param numberAttributes the number attributes
+	 */
+	public SparseInstance(double numberAttributes) {
+		super(1, null, null, (int) numberAttributes);
+	}
 
-    /**
-     * Instantiates a new sparse instance.
-     *
-     * @param weight the weight
-     * @param attributeValues the attribute values
-     * @param indexValues the index values
-     * @param numberAttributes the number attributes
-     */
-    public SparseInstance(double weight, double[] attributeValues, int[] indexValues, int numberAttributes) {
-        super(weight, attributeValues, indexValues, numberAttributes);
-    }
+	/**
+	 * Instantiates a new sparse instance.
+	 *
+	 * @param weight           the weight
+	 * @param attributeValues  the attribute values
+	 * @param indexValues      the index values
+	 * @param numberAttributes the number attributes
+	 */
+	public SparseInstance(double weight, double[] attributeValues, int[] indexValues, int numberAttributes) {
+		super(weight, attributeValues, indexValues, numberAttributes);
+	}
 
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/SparseInstanceData.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/SparseInstanceData.java
index e2d1a2403..7398d3048 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/SparseInstanceData.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/SparseInstanceData.java
@@ -1,16 +1,16 @@
-/* 
+/*
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 package com.yahoo.labs.samoa.instances;
 
@@ -21,321 +21,319 @@
  */
 public class SparseInstanceData implements InstanceData {
 
-    /**
-     * Instantiates a new sparse instance data.
-     *
-     * @param attributeValues the attribute values
-     * @param indexValues the index values
-     * @param numberAttributes the number attributes
-     */
-    public SparseInstanceData(double[] attributeValues, int[] indexValues, int numberAttributes) {
-        this.attributeValues = attributeValues;
-        this.indexValues = indexValues;
-        this.numberAttributes = numberAttributes;
-    }
-
-    /**
-     * Instantiates a new sparse instance data.
-     *
-     * @param length the length
-     */
-    public SparseInstanceData(int length) {
-        this.attributeValues = new double[length];
-        this.indexValues = new int[length];
-    }
-
-    /**
-     * The attribute values.
-     */
-    protected double[] attributeValues;
-
-    /**
-     * Gets the attribute values.
-     *
-     * @return the attribute values
-     */
-    public double[] getAttributeValues() {
-        return attributeValues;
-    }
-
-    /**
-     * Sets the attribute values.
-     *
-     * @param attributeValues the new attribute values
-     */
-    public void setAttributeValues(double[] attributeValues) {
-        this.attributeValues = attributeValues;
-    }
-
-    /**
-     * Gets the index values.
-     *
-     * @return the index values
-     */
-    public int[] getIndexValues() {
-        return indexValues;
-    }
-
-    /**
-     * Sets the index values.
-     *
-     * @param indexValues the new index values
-     */
-    public void setIndexValues(int[] indexValues) {
-        this.indexValues = indexValues;
-    }
-
-    /**
-     * Gets the number attributes.
-     *
-     * @return the number attributes
-     */
-    public int getNumberAttributes() {
-        return numberAttributes;
-    }
-
-    /**
-     * Sets the number of attributes.
-     *
-     * @param numberAttributes the new number attributes
-     */
-    public void setNumberAttributes(int numberAttributes) {
-        this.numberAttributes = numberAttributes;
-    }
-
-    /**
-     * The index values.
-     */
-    protected int[] indexValues;
-
-    /**
-     * The number of attributes.
-     */
-    protected int numberAttributes;
-
-    /**
-     * Gets the number of attributes.
-     *
-     * @return the int
-     */
-    @Override
-    public int numAttributes() {
-        return this.numberAttributes;
-    }
-
-    /**
-     * Value.
-     *
-     * @param indexAttribute the index attribute
-     * @return the double
-     */
-    @Override
-    public double value(int indexAttribute) {
-        int location = locateIndex(indexAttribute);
-        //return location == -1 ? 0 : this.attributeValues[location];
-        //      int index = locateIndex(attIndex);
-        if ((location >= 0) && (indexValues[location] == indexAttribute)) {
-            return attributeValues[location];
-        } else {
-            return 0.0;
-        }
-    }
-
-    /**
-     * Checks if is missing.
-     *
-     * @param indexAttribute the index attribute
-     * @return true, if is missing
-     */
-    @Override
-    public boolean isMissing(int indexAttribute) {
-        return Double.isNaN(this.value(indexAttribute));
-    }
-
-    /**
-     * Num values.
-     *
-     * @return the int
-     */
-    @Override
-    public int numValues() {
-        return this.attributeValues.length;
-    }
-
-    /**
-     * Index.
-     *
-     * @param indexAttribute the index attribute
-     * @return the int
-     */
-    @Override
-    public int index(int indexAttribute) {
-        return this.indexValues[indexAttribute];
-    }
-
-    /**
-     * Value sparse.
-     *
-     * @param indexAttribute the index attribute
-     * @return the double
-     */
-    @Override
-    public double valueSparse(int indexAttribute) {
-        return this.attributeValues[indexAttribute];
-    }
-
-    /**
-     * Checks if is missing sparse.
-     *
-     * @param indexAttribute the index attribute
-     * @return true, if is missing sparse
-     */
-    @Override
-    public boolean isMissingSparse(int indexAttribute) {
-        return Double.isNaN(this.valueSparse(indexAttribute));
-    }
-
-    /**
-     * To double array.
-     *
-     * @return the double[]
-     */
-    @Override
-    public double[] toDoubleArray() {
-        double[] array = new double[numAttributes()];
-        for (int i = 0; i < numValues(); i++) {
-            array[index(i)] = valueSparse(i);
-        }
-        return array;
-    }
-
-    /**
-     * Sets the value.
-     *
-     * @param attributeIndex the attribute index
-     * @param d the d
-     */
-    @Override
-    public void setValue(int attributeIndex, double d) {
-        int index = locateIndex(attributeIndex);
-        if (index(index) == attributeIndex) {
-            this.attributeValues[index] = d;
-        } else {
-            // We need to add the value
-        }
-    }
-
-    /**
-     * Locates the greatest index that is not greater than the given index.
-     *
-     * @return the internal index of the attribute index. Returns -1 if no index
-     * with this property could be found
-     */
-    public int locateIndex(int index) {
-
-        int min = 0;
-        int max = this.indexValues.length - 1;
-
-        if (max == -1) {
-            return -1;
-        }
-
-        // Binary search
-        while ((this.indexValues[min] <= index) && (this.indexValues[max] >= index)) {
-            int current = (max + min) / 2;
-            if (this.indexValues[current] > index) {
-                max = current - 1;
-            } else if (this.indexValues[current] < index) {
-                min = current + 1;
-            } else {
-                return current;
-            }
-        }
-        if (this.indexValues[max] < index) {
-            return max;
-        } else {
-            return min - 1;
-        }
-    }
-
-   /**
-   * Deletes an attribute at the given position (0 to numAttributes() - 1).
-   * 
-   * @param position the attribute's position
-   */
-  @Override
-  public void deleteAttributeAt(int position) {
-
-    int index = locateIndex(position);
-
-    this.numberAttributes--;
-    if ((index >= 0) && (indexValues[index] == position)) {
-      int[] tempIndices = new int[indexValues.length - 1];
-      double[] tempValues = new double[attributeValues.length - 1];
-      System.arraycopy(indexValues, 0, tempIndices, 0, index);
-      System.arraycopy(attributeValues, 0, tempValues, 0, index);
-      for (int i = index; i < indexValues.length - 1; i++) {
-        tempIndices[i] = indexValues[i + 1] - 1;
-        tempValues[i] = attributeValues[i + 1];
-      }
-      indexValues = tempIndices;
-      attributeValues = tempValues;
-    } else {
-      int[] tempIndices = new int[indexValues.length];
-      double[] tempValues = new double[attributeValues.length];
-      System.arraycopy(indexValues, 0, tempIndices, 0, index + 1);
-      System.arraycopy(attributeValues, 0, tempValues, 0, index + 1);
-      for (int i = index + 1; i < indexValues.length; i++) {
-        tempIndices[i] = indexValues[i] - 1;
-        tempValues[i] = attributeValues[i];
-      }
-      indexValues = tempIndices;
-      attributeValues = tempValues;
-    }
-  }
-
-    @Override
-    public void insertAttributeAt(int position) {
-        if ((position< 0) || (position > numAttributes())) {
-            throw new IllegalArgumentException("Can't insert attribute: index out "
-                    + "of range");
-        }
-        int index = locateIndex(position);
-
-        this.numberAttributes++;
-        if ((index >= 0) && (indexValues[index] == position)) {
-            int[] tempIndices = new int[indexValues.length + 1];
-            double[] tempValues = new double[attributeValues.length + 1];
-            System.arraycopy(indexValues, 0, tempIndices, 0, index);
-            System.arraycopy(attributeValues, 0, tempValues, 0, index);
-            tempIndices[index] = position;
-            tempValues[index] =  Double.NaN; //Missing Value
-            for (int i = index; i < indexValues.length; i++) {
-                tempIndices[i + 1] = indexValues[i] + 1;
-                tempValues[i + 1] = attributeValues[i];
-            }
-            indexValues = tempIndices;
-            attributeValues = tempValues;
-        } else {
-            int[] tempIndices = new int[indexValues.length + 1];
-            double[] tempValues = new double[attributeValues.length + 1];
-            System.arraycopy(indexValues, 0, tempIndices, 0, index + 1);
-            System.arraycopy(attributeValues, 0, tempValues, 0, index + 1);
-            tempIndices[index + 1] = position;
-            tempValues[index + 1] =  Double.NaN; //Missing Value
-            for (int i = index + 1; i < indexValues.length; i++) {
-                tempIndices[i + 1] = indexValues[i] + 1;
-                tempValues[i + 1] = attributeValues[i];
-            }
-            indexValues = tempIndices;
-            attributeValues = tempValues;
-        }
-    }
-
-    @Override
-    public InstanceData copy() {
-      return new SparseInstanceData(this.attributeValues.clone(),this.indexValues.clone(),this.numberAttributes);   
-    }
-
+	/**
+	 * Instantiates a new sparse instance data.
+	 *
+	 * @param attributeValues  the attribute values
+	 * @param indexValues      the index values
+	 * @param numberAttributes the number attributes
+	 */
+	public SparseInstanceData(double[] attributeValues, int[] indexValues, int numberAttributes) {
+		this.attributeValues = attributeValues;
+		this.indexValues = indexValues;
+		this.numberAttributes = numberAttributes;
+	}
+
+	/**
+	 * Instantiates a new sparse instance data.
+	 *
+	 * @param length the length
+	 */
+	public SparseInstanceData(int length) {
+		this.attributeValues = new double[length];
+		this.indexValues = new int[length];
+	}
+
+	/**
+	 * The attribute values.
+	 */
+	protected double[] attributeValues;
+
+	/**
+	 * Gets the attribute values.
+	 *
+	 * @return the attribute values
+	 */
+	public double[] getAttributeValues() {
+		return attributeValues;
+	}
+
+	/**
+	 * Sets the attribute values.
+	 *
+	 * @param attributeValues the new attribute values
+	 */
+	public void setAttributeValues(double[] attributeValues) {
+		this.attributeValues = attributeValues;
+	}
+
+	/**
+	 * Gets the index values.
+	 *
+	 * @return the index values
+	 */
+	public int[] getIndexValues() {
+		return indexValues;
+	}
+
+	/**
+	 * Sets the index values.
+	 *
+	 * @param indexValues the new index values
+	 */
+	public void setIndexValues(int[] indexValues) {
+		this.indexValues = indexValues;
+	}
+
+	/**
+	 * Gets the number attributes.
+	 *
+	 * @return the number attributes
+	 */
+	public int getNumberAttributes() {
+		return numberAttributes;
+	}
+
+	/**
+	 * Sets the number of attributes.
+	 *
+	 * @param numberAttributes the new number attributes
+	 */
+	public void setNumberAttributes(int numberAttributes) {
+		this.numberAttributes = numberAttributes;
+	}
+
+	/**
+	 * The index values.
+	 */
+	protected int[] indexValues;
+
+	/**
+	 * The number of attributes.
+	 */
+	protected int numberAttributes;
+
+	/**
+	 * Gets the number of attributes.
+	 *
+	 * @return the int
+	 */
+	@Override
+	public int numAttributes() {
+		return this.numberAttributes;
+	}
+
+	/**
+	 * Value.
+	 *
+	 * @param indexAttribute the index attribute
+	 * @return the double
+	 */
+	@Override
+	public double value(int indexAttribute) {
+		int location = locateIndex(indexAttribute);
+		// return location == -1 ? 0 : this.attributeValues[location];
+		// int index = locateIndex(attIndex);
+		if ((location >= 0) && (indexValues[location] == indexAttribute)) {
+			return attributeValues[location];
+		} else {
+			return 0.0;
+		}
+	}
+
+	/**
+	 * Checks if is missing.
+	 *
+	 * @param indexAttribute the index attribute
+	 * @return true, if is missing
+	 */
+	@Override
+	public boolean isMissing(int indexAttribute) {
+		return Double.isNaN(this.value(indexAttribute));
+	}
+
+	/**
+	 * Num values.
+	 *
+	 * @return the int
+	 */
+	@Override
+	public int numValues() {
+		return this.attributeValues.length;
+	}
+
+	/**
+	 * Index.
+	 *
+	 * @param indexAttribute the index attribute
+	 * @return the int
+	 */
+	@Override
+	public int index(int indexAttribute) {
+		return this.indexValues[indexAttribute];
+	}
+
+	/**
+	 * Value sparse.
+	 *
+	 * @param indexAttribute the index attribute
+	 * @return the double
+	 */
+	@Override
+	public double valueSparse(int indexAttribute) {
+		return this.attributeValues[indexAttribute];
+	}
+
+	/**
+	 * Checks if is missing sparse.
+	 *
+	 * @param indexAttribute the index attribute
+	 * @return true, if is missing sparse
+	 */
+	@Override
+	public boolean isMissingSparse(int indexAttribute) {
+		return Double.isNaN(this.valueSparse(indexAttribute));
+	}
+
+	/**
+	 * To double array.
+	 *
+	 * @return the double[]
+	 */
+	@Override
+	public double[] toDoubleArray() {
+		double[] array = new double[numAttributes()];
+		for (int i = 0; i < numValues(); i++) {
+			array[index(i)] = valueSparse(i);
+		}
+		return array;
+	}
+
+	/**
+	 * Sets the value.
+	 *
+	 * @param attributeIndex the attribute index
+	 * @param d              the d
+	 */
+	@Override
+	public void setValue(int attributeIndex, double d) {
+		int index = locateIndex(attributeIndex);
+		if (index(index) == attributeIndex) {
+			this.attributeValues[index] = d;
+		} else {
+			// We need to add the value
+		}
+	}
+
+	/**
+	 * Locates the greatest index that is not greater than the given index.
+	 *
+	 * @return the internal index of the attribute index. Returns -1 if no index
+	 *         with this property could be found
+	 */
+	public int locateIndex(int index) {
+
+		int min = 0;
+		int max = this.indexValues.length - 1;
+
+		if (max == -1) {
+			return -1;
+		}
+
+		// Binary search
+		while ((this.indexValues[min] <= index) && (this.indexValues[max] >= index)) {
+			int current = (max + min) / 2;
+			if (this.indexValues[current] > index) {
+				max = current - 1;
+			} else if (this.indexValues[current] < index) {
+				min = current + 1;
+			} else {
+				return current;
+			}
+		}
+		if (this.indexValues[max] < index) {
+			return max;
+		} else {
+			return min - 1;
+		}
+	}
+
+	/**
+	 * Deletes an attribute at the given position (0 to numAttributes() - 1).
+	 * 
+	 * @param position the attribute's position
+	 */
+	@Override
+	public void deleteAttributeAt(int position) {
+
+		int index = locateIndex(position);
+
+		this.numberAttributes--;
+		if ((index >= 0) && (indexValues[index] == position)) {
+			int[] tempIndices = new int[indexValues.length - 1];
+			double[] tempValues = new double[attributeValues.length - 1];
+			System.arraycopy(indexValues, 0, tempIndices, 0, index);
+			System.arraycopy(attributeValues, 0, tempValues, 0, index);
+			for (int i = index; i < indexValues.length - 1; i++) {
+				tempIndices[i] = indexValues[i + 1] - 1;
+				tempValues[i] = attributeValues[i + 1];
+			}
+			indexValues = tempIndices;
+			attributeValues = tempValues;
+		} else {
+			int[] tempIndices = new int[indexValues.length];
+			double[] tempValues = new double[attributeValues.length];
+			System.arraycopy(indexValues, 0, tempIndices, 0, index + 1);
+			System.arraycopy(attributeValues, 0, tempValues, 0, index + 1);
+			for (int i = index + 1; i < indexValues.length; i++) {
+				tempIndices[i] = indexValues[i] - 1;
+				tempValues[i] = attributeValues[i];
+			}
+			indexValues = tempIndices;
+			attributeValues = tempValues;
+		}
+	}
+
+	@Override
+	public void insertAttributeAt(int position) {
+		if ((position < 0) || (position > numAttributes())) {
+			throw new IllegalArgumentException("Can't insert attribute: index out " + "of range");
+		}
+		int index = locateIndex(position);
+
+		this.numberAttributes++;
+		if ((index >= 0) && (indexValues[index] == position)) {
+			int[] tempIndices = new int[indexValues.length + 1];
+			double[] tempValues = new double[attributeValues.length + 1];
+			System.arraycopy(indexValues, 0, tempIndices, 0, index);
+			System.arraycopy(attributeValues, 0, tempValues, 0, index);
+			tempIndices[index] = position;
+			tempValues[index] = Double.NaN; // Missing Value
+			for (int i = index; i < indexValues.length; i++) {
+				tempIndices[i + 1] = indexValues[i] + 1;
+				tempValues[i + 1] = attributeValues[i];
+			}
+			indexValues = tempIndices;
+			attributeValues = tempValues;
+		} else {
+			int[] tempIndices = new int[indexValues.length + 1];
+			double[] tempValues = new double[attributeValues.length + 1];
+			System.arraycopy(indexValues, 0, tempIndices, 0, index + 1);
+			System.arraycopy(attributeValues, 0, tempValues, 0, index + 1);
+			tempIndices[index + 1] = position;
+			tempValues[index + 1] = Double.NaN; // Missing Value
+			for (int i = index + 1; i < indexValues.length; i++) {
+				tempIndices[i + 1] = indexValues[i] + 1;
+				tempValues[i + 1] = attributeValues[i];
+			}
+			indexValues = tempIndices;
+			attributeValues = tempValues;
+		}
+	}
+
+	@Override
+	public InstanceData copy() {
+		return new SparseInstanceData(this.attributeValues.clone(), this.indexValues.clone(), this.numberAttributes);
+	}
 
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/StructuredInstance.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/StructuredInstance.java
deleted file mode 100644
index 9867f74ca..000000000
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/StructuredInstance.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
- * either express or implied. See the License for the specific
- * language governing permissions and limitations under the
- * License.  
- */
-package com.yahoo.labs.samoa.instances;
-
-/**
- * The Interface StructuredInstance.
- *
- * @author abifet
- * 
- * A placeholder for structured instances.
- * 
- */
-   
-public interface StructuredInstance extends Instance {
-
-}
- 
\ No newline at end of file
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/WekaToSamoaInstanceConverter.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/WekaToSamoaInstanceConverter.java
index 43b581b44..b3e2f1758 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/WekaToSamoaInstanceConverter.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/WekaToSamoaInstanceConverter.java
@@ -1,16 +1,16 @@
-/* 
+/*
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 package com.yahoo.labs.samoa.instances;
 
@@ -24,103 +24,102 @@
  *
  * @author abifet
  */
-public class WekaToSamoaInstanceConverter implements Serializable{
+public class WekaToSamoaInstanceConverter implements Serializable {
+
+	protected InstancesHeader samoaInstanceInformation;
+
+	/**
+	 * Samoa instance from weka instance.
+	 *
+	 * @param inst the inst
+	 * @return the instance
+	 */
+	public Instance samoaInstance(weka.core.Instance inst) {
+		Instance samoaInstance;
+		if (inst instanceof weka.core.SparseInstance) {
+			double[] attributeValues = new double[inst.numValues()];
+			int[] indexValues = new int[inst.numValues()];
+			for (int i = 0; i < inst.numValues(); i++) {
+				if (inst.index(i) != inst.classIndex()) {
+					attributeValues[i] = inst.valueSparse(i);
+					indexValues[i] = inst.index(i);
+				}
+			}
+			samoaInstance = new SparseInstance(inst.weight(), attributeValues, indexValues, inst.numAttributes());
+		} else {
+			samoaInstance = new DenseInstance(inst.weight(), inst.toDoubleArray());
+			// samoaInstance.deleteAttributeAt(inst.classIndex());
+		}
+		if (this.samoaInstanceInformation == null) {
+			this.samoaInstanceInformation = this.samoaInstancesInformation(inst.dataset());
+		}
+		samoaInstance.setDataset(samoaInstanceInformation);
+
+		if (inst.classIndex() >= 0) { // class attribute is present
+			samoaInstance.setClassValue(inst.classValue());
+		}
+
+		return samoaInstance;
+	}
 
-    protected InstancesHeader samoaInstanceInformation;
-    
-    /**
-     * Samoa instance from weka instance.
-     *
-     * @param inst the inst
-     * @return the instance
-     */
-    public Instance samoaInstance(weka.core.Instance inst) {
-        Instance samoaInstance;
-        if (inst instanceof weka.core.SparseInstance) {
-            double[] attributeValues = new double[inst.numValues()];
-            int[] indexValues = new int[inst.numValues()];
-            for (int i = 0; i < inst.numValues(); i++) {
-                if (inst.index(i) != inst.classIndex()) {
-                    attributeValues[i] = inst.valueSparse(i);
-                    indexValues[i] = inst.index(i);
-                }
-            }
-            samoaInstance = new SparseInstance(inst.weight(), attributeValues,
-                    indexValues, inst.numAttributes());
-        } else {
-            samoaInstance = new DenseInstance(inst.weight(), inst.toDoubleArray());
-            //samoaInstance.deleteAttributeAt(inst.classIndex());
-        }
-        if (this.samoaInstanceInformation == null) {
-            this.samoaInstanceInformation = this.samoaInstancesInformation(inst.dataset());
-        }
-        samoaInstance.setDataset(samoaInstanceInformation);
+	/**
+	 * Samoa instances from weka instances.
+	 *
+	 * @param instances the instances
+	 * @return the instances
+	 */
+	public InstancesHeader samoaInstances(weka.core.Instances instances) {
+		InstancesHeader samoaInstances = samoaInstancesInformation(instances);
+		// We assume that we have only one samoaInstanceInformation for
+		// WekaToSamoaInstanceConverter
+		this.samoaInstanceInformation = samoaInstances;
+		for (int i = 0; i < instances.numInstances(); i++) {
+			samoaInstances.add(samoaInstance(instances.instance(i)));
+		}
+		return samoaInstances;
+	}
 
-        if(inst.classIndex() >= 0) { // class attribute is present
-            samoaInstance.setClassValue(inst.classValue());
-        }
-        
-        return samoaInstance;
-    }
+	/**
+	 * Samoa instances information.
+	 *
+	 * @param instances the instances
+	 * @return the instances
+	 */
+	public InstancesHeader samoaInstancesInformation(weka.core.Instances instances) {
+		InstancesHeader samoaInstances;
+		List<Attribute> attInfo = new ArrayList<>();
+		for (int i = 0; i < instances.numAttributes(); i++) {
+			attInfo.add(samoaAttribute(i, instances.attribute(i)));
+		}
+		samoaInstances = new InstancesHeader(instances.relationName(), attInfo, 0);
+		samoaInstances.setClassIndex(instances.classIndex());
 
-     /**
-     * Samoa instances from weka instances.
-     *
-     * @param instances the instances
-     * @return the instances
-     */
-    public InstancesHeader samoaInstances(weka.core.Instances instances) {
-        InstancesHeader samoaInstances = samoaInstancesInformation(instances);
-        //We assume that we have only one samoaInstanceInformation for WekaToSamoaInstanceConverter
-        this.samoaInstanceInformation = samoaInstances;
-        for (int i = 0; i < instances.numInstances(); i++) {
-            samoaInstances.add(samoaInstance(instances.instance(i)));
-        }
-        return samoaInstances;
-    }
+		if (instances.classIndex() >= 0) { // class attribute is present
+			samoaInstances.setClassIndex(instances.classIndex());
+		}
 
-     /**
-     * Samoa instances information.
-     *
-     * @param instances the instances
-     * @return the instances
-     */
-    public InstancesHeader samoaInstancesInformation(weka.core.Instances instances) {
-        InstancesHeader samoaInstances;
-        List<Attribute> attInfo = new ArrayList<Attribute>();
-        for (int i = 0; i < instances.numAttributes(); i++) {
-            attInfo.add(samoaAttribute(i, instances.attribute(i)));
-        }
-        samoaInstances = new InstancesHeader(instances.relationName(), attInfo, 0);
-        samoaInstances.setClassIndex(instances.classIndex());
-        
-        if(instances.classIndex() >= 0) { // class attribute is present
-            samoaInstances.setClassIndex(instances.classIndex());
-        }
-        
-        return samoaInstances;
-    }
+		return samoaInstances;
+	}
 
-    
-     /**
-     * Get Samoa attribute from a weka attribute.
-     *
-     * @param index the index
-     * @param attribute the attribute
-     * @return the attribute
-     */
-    protected Attribute samoaAttribute(int index, weka.core.Attribute attribute) {
-        Attribute samoaAttribute;
-        if (attribute.isNominal()) {
-            Enumeration enu = attribute.enumerateValues();
-            List<String> attributeValues = new ArrayList<String>();
-            while (enu.hasMoreElements()) {
-                attributeValues.add((String) enu.nextElement());
-            }
-            samoaAttribute = new Attribute(attribute.name(), attributeValues);
-        } else {
-            samoaAttribute = new Attribute(attribute.name());
-        }
-        return samoaAttribute;
-    }
+	/**
+	 * Get Samoa attribute from a weka attribute.
+	 *
+	 * @param index     the index
+	 * @param attribute the attribute
+	 * @return the attribute
+	 */
+	protected Attribute samoaAttribute(int index, weka.core.Attribute attribute) {
+		Attribute samoaAttribute;
+		if (attribute.isNominal()) {
+			Enumeration enu = attribute.enumerateValues();
+			List<String> attributeValues = new ArrayList<>();
+			while (enu.hasMoreElements()) {
+				attributeValues.add((String) enu.nextElement());
+			}
+			samoaAttribute = new Attribute(attribute.name(), attributeValues);
+		} else {
+			samoaAttribute = new Attribute(attribute.name());
+		}
+		return samoaAttribute;
+	}
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/ClassificationPrediction.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/ClassificationPrediction.java
index bf7e42c21..0f6d02ffd 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/ClassificationPrediction.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/ClassificationPrediction.java
@@ -1,16 +1,16 @@
-/* 
+/*
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 package com.yahoo.labs.samoa.instances.predictions;
 
@@ -21,24 +21,24 @@
 import moa.core.DoubleVector;
 
 public class ClassificationPrediction implements Prediction, Serializable {
-	
+
 	private static final long serialVersionUID = 1L;
 
 	protected double[] prediction = new double[0];
 
 	protected Attribute classAttribute;
-	
+
 	public ClassificationPrediction() {
 	}
 
 	public ClassificationPrediction(double[] prediction) {
 		this.prediction = prediction;
 	}
-	
+
 	public void setClassAttribute(Attribute a) {
-		this.classAttribute = a;	
+		this.classAttribute = a;
 	}
-	
+
 	@Override
 	public int numOutputAttributes() {
 		return 1;
@@ -53,7 +53,7 @@ public int numClasses(int outputAttributeIndex) {
 	public double[] getVotes(int outputAttributeIndex) {
 		throw new UnsupportedOperationException("This is a single-target classification prediction.");
 	}
-	
+
 	@Override
 	public double[] getVotes() {
 		return prediction;
@@ -64,12 +64,11 @@ public double getVote(int outputAttributeIndex, int classIndex) {
 		throw new UnsupportedOperationException("This is a single-target classification prediction.");
 	}
 
-	
 	@Override
 	public void setVotes(int outputAttributeIndex, double[] votes) {
 		throw new UnsupportedOperationException("This is a single-target classification prediction.");
 	}
-	
+
 	@Override
 	public void setVotes(double[] votes) {
 		this.prediction = votes;
@@ -79,19 +78,18 @@ public void setVotes(double[] votes) {
 	public void setVote(int outputAttributeIndex, int classIndex, double vote) {
 		throw new UnsupportedOperationException("This is a single-target classification prediction.");
 	}
-	
 
 	@Override
 	public void setVote(int outputAttributeIndex, double vote) {
 		throw new UnsupportedOperationException("This is a single-target classification prediction.");
 	}
-	
+
 	@Override
 	public String toString() {
-		StringBuffer sb= new StringBuffer();
+		StringBuffer sb = new StringBuffer();
 		sb.append("Out: ");
 		int id = 0;
-		double max = Double.NEGATIVE_INFINITY; 
+		double max = Double.NEGATIVE_INFINITY;
 		for (int i = 0; i < prediction.length; i++) {
 			if (prediction[i] > max) {
 				id = i;
@@ -110,23 +108,27 @@ public boolean hasVotesForAttribute(int outputAttributeIndex) {
 		throw new UnsupportedOperationException("This is a single-target classification prediction.");
 	}
 
-    @Override
-    public int size() {
-        return 1;
-    }
-    
-    public double asDouble() {
+	@Override
+	public int size() {
+		return 1;
+	}
+
+	@Override
+	public double asDouble() {
 		throw new UnsupportedOperationException("This is a classification prediction.");
-    }
-    
-    public DoubleVector asDoubleVector() {
-    	return new DoubleVector(prediction);
-    }
-
-    public double[] asDoubleArray() {
-    	return prediction;
-    }
-    
+	}
+
+	@Override
+	public DoubleVector asDoubleVector() {
+		return new DoubleVector(prediction);
+	}
+
+	@Override
+	public double[] asDoubleArray() {
+		return prediction;
+	}
+
+	@Override
 	public String asPredictionString() {
 		return String.valueOf(prediction.toString());
 	}
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/MultiLabelClassificationPrediction.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/MultiLabelClassificationPrediction.java
index 006f1bcbd..9ccf075cb 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/MultiLabelClassificationPrediction.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/MultiLabelClassificationPrediction.java
@@ -1,16 +1,16 @@
-/* 
+/*
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 package com.yahoo.labs.samoa.instances.predictions;
 
@@ -20,31 +20,30 @@
 
 public class MultiLabelClassificationPrediction implements Prediction, Serializable {
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
-	
+
 	protected DoubleVector prediction;
 
 	public MultiLabelClassificationPrediction() {
 		this(0);
 	}
-	
+
 	public MultiLabelClassificationPrediction(int numOutputAttributes) {
-		prediction=new DoubleVector();
-		for (int i=0; i < numOutputAttributes;i++)
-			prediction.setValue(i, 0.0);;
+		prediction = new DoubleVector();
+		for (int i = 0; i < numOutputAttributes; i++)
+			prediction.setValue(i, 0.0);
 	}
-	
+
 	public MultiLabelClassificationPrediction(DoubleVector prediction) {
 		this.prediction = prediction;
 	}
-	
+
 	public MultiLabelClassificationPrediction(double[] prediction) {
 		this.prediction = new DoubleVector(prediction);
 	}
-	
-	
+
 	@Override
 	public int numOutputAttributes() {
 		return prediction.numValues();
@@ -52,14 +51,16 @@ public int numOutputAttributes() {
 
 	@Override
 	public int numClasses(int outputAttributeIndex) {
-		throw new UnsupportedOperationException("This is a multi-label classification prediction. Each output attribute corresponds to a label.");
+		throw new UnsupportedOperationException(
+				"This is a multi-label classification prediction. Each output attribute corresponds to a label.");
 	}
 
 	@Override
 	public double[] getVotes(int outputAttributeIndex) {
-		throw new UnsupportedOperationException("This is a multi-label classification prediction. Each output attribute corresponds to a label.");
+		throw new UnsupportedOperationException(
+				"This is a multi-label classification prediction. Each output attribute corresponds to a label.");
 	}
-	
+
 	@Override
 	public double[] getVotes() {
 		return this.asDoubleArray();
@@ -68,18 +69,20 @@ public double[] getVotes() {
 	@Override
 	public double getVote(int outputAttributeIndex, int classIndex) {
 		if (classIndex != 0) {
-			throw new UnsupportedOperationException("This is a multi-label classification prediction. Each output attribute corresponds to a label.");
+			throw new UnsupportedOperationException(
+					"This is a multi-label classification prediction. Each output attribute corresponds to a label.");
 		} else {
 			// Simulate multi-nominal output with 2 class variables on each target.
-			return getPrediction(outputAttributeIndex); 
+			return getPrediction(outputAttributeIndex);
 		}
 	}
-	
+
 	@Override
 	public void setVotes(int outputAttributeIndex, double[] votes) {
-		throw new UnsupportedOperationException("This is a multi-label classification prediction. Each output attribute corresponds to a label.");
+		throw new UnsupportedOperationException(
+				"This is a multi-label classification prediction. Each output attribute corresponds to a label.");
 	}
-	
+
 	@Override
 	public void setVotes(double[] votes) {
 		this.prediction = new DoubleVector(votes);
@@ -88,20 +91,22 @@ public void setVotes(double[] votes) {
 	@Override
 	public void setVote(int outputAttributeIndex, int classIndex, double vote) {
 		if (classIndex != 0) {
-			throw new UnsupportedOperationException("This is a multi-label classification prediction. Each output attribute corresponds to a label.");
+			throw new UnsupportedOperationException(
+					"This is a multi-label classification prediction. Each output attribute corresponds to a label.");
 		} else {
 			// Simulate multi-nominal output with 2 class variables on each target.
-			setVote(outputAttributeIndex, vote); 
+			setVote(outputAttributeIndex, vote);
 		}
 	}
 
+	@Override
 	public void setVote(int outputAttributeIndex, double vote) {
-		this.prediction.setValue(outputAttributeIndex, vote); 
+		this.prediction.setValue(outputAttributeIndex, vote);
 	}
-	
+
 	@Override
 	public String toString() {
-		StringBuffer sb= new StringBuffer();
+		StringBuffer sb = new StringBuffer();
 		// TODO
 //		for (int i=0; i<prediction.length; i++){
 //			sb.append("Out " + i + ": ");
@@ -115,33 +120,37 @@ public String toString() {
 
 	@Override
 	public boolean hasVotesForAttribute(int outputAttributeIndex) {
-		return prediction.getValue(outputAttributeIndex) != 0; 
+		return prediction.getValue(outputAttributeIndex) != 0;
 	}
 
-    @Override
-    public int size() {
-        return prediction.numValues();
-    }
+	@Override
+	public int size() {
+		return prediction.numValues();
+	}
 
-    public double asDouble() {
+	@Override
+	public double asDouble() {
 		throw new UnsupportedOperationException("This is a multi-label classification prediction.");
-    }
-    
-    public DoubleVector asDoubleVector() {
-    	return (DoubleVector) prediction.copy();
-    }
+	}
 
-    public double[] asDoubleArray() {
-    	return prediction.getArrayCopy();
-    }
+	@Override
+	public DoubleVector asDoubleVector() {
+		return (DoubleVector) prediction.copy();
+	}
 
+	@Override
+	public double[] asDoubleArray() {
+		return prediction.getArrayCopy();
+	}
+
+	@Override
 	public String asPredictionString() {
 		return String.valueOf(prediction.toString());
 	}
-	
+
 	@Override
 	public double getPrediction(int outputAttributeIndex) {
 		return prediction.getValue(outputAttributeIndex);
 	}
-	
+
 }
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/MultiTargetRegressionPrediction.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/MultiTargetRegressionPrediction.java
index b75a61fc6..4ca6487c4 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/MultiTargetRegressionPrediction.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/MultiTargetRegressionPrediction.java
@@ -1,16 +1,16 @@
-/* 
+/*
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 package com.yahoo.labs.samoa.instances.predictions;
 
@@ -20,32 +20,31 @@
 
 public class MultiTargetRegressionPrediction implements Prediction, Serializable {
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
-	
+
 	protected DoubleVector prediction;
 
 	public MultiTargetRegressionPrediction() {
 		this(0);
 	}
-	
+
 	public MultiTargetRegressionPrediction(int numOutputAttributes) {
-		prediction=new DoubleVector();
-		for (int i=0; i < numOutputAttributes;i++)
-			prediction.setValue(i, 0.0);;
+		prediction = new DoubleVector();
+		for (int i = 0; i < numOutputAttributes; i++)
+			prediction.setValue(i, 0.0);
 	}
-	
+
 	public MultiTargetRegressionPrediction(DoubleVector prediction) {
 		this.prediction = prediction;
 	}
-	
+
 	public MultiTargetRegressionPrediction(double[] prediction) {
 		if (prediction != null)
 			this.prediction = new DoubleVector(prediction);
 	}
-	
-	
+
 	@Override
 	public int numOutputAttributes() {
 		return prediction.numValues();
@@ -53,14 +52,16 @@ public int numOutputAttributes() {
 
 	@Override
 	public int numClasses(int outputAttributeIndex) {
-		throw new UnsupportedOperationException("This is a multi-target regression prediction. Each output attribute corresponds to a continuouos variable.");
+		throw new UnsupportedOperationException(
+				"This is a multi-target regression prediction. Each output attribute corresponds to a continuouos variable.");
 	}
 
 	@Override
 	public double[] getVotes(int outputAttributeIndex) {
-		throw new UnsupportedOperationException("This is a multi-target regression prediction. Each output attribute corresponds to a continuouos variable.");
+		throw new UnsupportedOperationException(
+				"This is a multi-target regression prediction. Each output attribute corresponds to a continuouos variable.");
 	}
-	
+
 	@Override
 	public double[] getVotes() {
 		return this.asDoubleArray();
@@ -68,7 +69,8 @@ public double[] getVotes() {
 
 	@Override
 	public double getVote(int outputAttributeIndex, int classIndex) {
-		throw new UnsupportedOperationException("This is a multi-target regression prediction. Each output attribute corresponds to a continuouos variable.");
+		throw new UnsupportedOperationException(
+				"This is a multi-target regression prediction. Each output attribute corresponds to a continuouos variable.");
 	}
 
 	@Override
@@ -78,9 +80,10 @@ public double getPrediction(int outputAttributeIndex) {
 
 	@Override
 	public void setVotes(int outputAttributeIndex, double[] votes) {
-		throw new UnsupportedOperationException("This is a multi-target regression prediction. Each output attribute corresponds to a continuouos variable.");
+		throw new UnsupportedOperationException(
+				"This is a multi-target regression prediction. Each output attribute corresponds to a continuouos variable.");
 	}
-	
+
 	@Override
 	public void setVotes(double[] votes) {
 		this.prediction = new DoubleVector(votes);
@@ -88,17 +91,18 @@ public void setVotes(double[] votes) {
 
 	@Override
 	public void setVote(int outputAttributeIndex, int classIndex, double vote) {
-		throw new UnsupportedOperationException("This is a multi-target regression prediction. Each output attribute corresponds to a continuouos variable.");
+		throw new UnsupportedOperationException(
+				"This is a multi-target regression prediction. Each output attribute corresponds to a continuouos variable.");
 	}
 
 	@Override
 	public void setVote(int outputAttributeIndex, double vote) {
 		this.prediction.setValue(outputAttributeIndex, vote);
 	}
-	
+
 	@Override
 	public String toString() {
-		StringBuffer sb= new StringBuffer();
+		StringBuffer sb = new StringBuffer();
 		// TODO
 //		for (int i=0; i<prediction.length; i++){
 //			sb.append("Out " + i + ": ");
@@ -112,26 +116,32 @@ public String toString() {
 
 	@Override
 	public boolean hasVotesForAttribute(int outputAttributeIndex) {
-		throw new UnsupportedOperationException("This is a multi-target regression prediction. Each output attribute corresponds to a continuouos variable.");
+//		throw new UnsupportedOperationException(
+//		"This is a multi-target regression prediction. Each output attribute corresponds to a continuous variable.");
+		return prediction.getValue(outputAttributeIndex) != 0;
 	}
 
-    @Override
-    public int size() {
-        return prediction.numValues();
-    }
+	@Override
+	public int size() {
+		return prediction.numValues();
+	}
 
-    public double asDouble() {
+	@Override
+	public double asDouble() {
 		throw new UnsupportedOperationException("This is a multi-target regression prediction.");
-    }
-    
-    public DoubleVector asDoubleVector() {
-    	return (DoubleVector) prediction.copy();
-    }
-
-    public double[] asDoubleArray() {
-    	return prediction.getArrayCopy();
-    }
-    
+	}
+
+	@Override
+	public DoubleVector asDoubleVector() {
+		return (DoubleVector) prediction.copy();
+	}
+
+	@Override
+	public double[] asDoubleArray() {
+		return prediction.getArrayCopy();
+	}
+
+	@Override
 	public String asPredictionString() {
 		if (prediction != null)
 			return String.valueOf(prediction.toString().replace(",", ""));
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/Prediction.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/Prediction.java
index 8cc198b9a..7561286b1 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/Prediction.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/Prediction.java
@@ -1,138 +1,141 @@
-/* 
+/*
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 package com.yahoo.labs.samoa.instances.predictions;
 
 import moa.core.DoubleVector;
 
 public interface Prediction {
-	
-    /**
-     * Number of output attributes.
-     *
-     * @return the number of output attributes
-     */
-	public int numOutputAttributes();
-	
-    /**
-     * Different output attributes may have different number of classes.
-     * Used for multi-target classification.
-     *
-     * @return the number of classes for attribute attributeIndex
-     */
-	public int numClasses(int outputAttributeIndex);
-	
-    /*
-     * The predictions for each output attribute.
-     *
-     * @return the classes for each output attribute
-     */
-	public double getPrediction(int outputAttributeIndex);
-	
-    /**
-     * The votes for a given output attribute
-     *
-     * @return the votes for a given output attribute outputAttributeIndex.
-     */
-	public double[] getVotes(int outputAttributeIndex);
-	
-    /**
-     * The vote assigned to a class of an output attribute
-     *
-     * @return the vote for an output attribute outputAttributeIndex and a class classIndex.
-     */
-	public double getVote(int outputAttributeIndex, int classIndex);
-	
-	/**
-     * Sets the votes for a given output attribute
-     *
-     */
-	public void setVotes(int outputAttributeIndex, double [] votes);
-	
-    /**
-     * Sets the votes for the first output attribute
-     *
-     */
-	public void setVotes(double[] votes);
-	
-    /**
-     * Sets the vote for class of a given output attribute
-     *
-     */
-	public void setVote(int outputAttributeIndex, int classIndex, double vote);
-
-    /**
-     * Sets the vote for class of a given output attribute
-     *
-     */
-	public void setVote(int outputAttributeIndex, double vote);
-	
-    /**
-     * The votes for the first output attribute
-     *
-     * @return the votes for the first output attribute outputAttributeIndex.
-     */
+
+	/**
+	 * Number of output attributes.
+	 *
+	 * @return the number of output attributes
+	 */
+	int numOutputAttributes();
+
+	/**
+	 * Different output attributes may have different number of classes. Used for
+	 * multi-target classification.
+	 *
+	 * @return the number of classes for attribute attributeIndex
+	 */
+	int numClasses(int outputAttributeIndex);
+
+	/*
+	 * The predictions for each output attribute.
+	 *
+	 * @return the classes for each output attribute
+	 */
+	double getPrediction(int outputAttributeIndex);
+
+	/**
+	 * The votes for a given output attribute
+	 *
+	 * @return the votes for a given output attribute outputAttributeIndex.
+	 */
+	double[] getVotes(int outputAttributeIndex);
+
+	/**
+	 * The vote assigned to a class of an output attribute
+	 *
+	 * @return the vote for an output attribute outputAttributeIndex and a class
+	 *         classIndex.
+	 */
+	double getVote(int outputAttributeIndex, int classIndex);
+
+	/**
+	 * Sets the votes for a given output attribute
+	 *
+	 */
+	void setVotes(int outputAttributeIndex, double[] votes);
+
+	/**
+	 * Sets the votes for the first output attribute
+	 *
+	 */
+	void setVotes(double[] votes);
+
+	/**
+	 * Sets the vote for class of a given output attribute
+	 *
+	 */
+	void setVote(int outputAttributeIndex, int classIndex, double vote);
+
+	/**
+	 * Sets the vote for class of a given output attribute
+	 *
+	 */
+	void setVote(int outputAttributeIndex, double vote);
+
+	/**
+	 * The votes for the first output attribute
+	 *
+	 * @return the votes for the first output attribute outputAttributeIndex.
+	 */
 	double[] getVotes();
-	
-    /**
-     * Checks if there are votes for a given output attribute
-     *
-     * @return the votes for the first output attribute outputAttributeIndex.
-     */
+
+	/**
+	 * Checks if there are votes for a given output attribute
+	 *
+	 * @return the votes for the first output attribute outputAttributeIndex.
+	 */
 	boolean hasVotesForAttribute(int outputAttributeIndex);
 
+	/**
+	 * The size of the prediction, that is the number of output attributes
+	 *
+	 * @return the votes for the first output attribute outputAttributeIndex.
+	 */
+	int size();
+
+	/**
+	 * The text of the prediction, that is the description of the values of the
+	 * prediction
+	 *
+	 * @return the text
+	 */
+	@Override
+	String toString();
 
-     /**
-     * The size of the prediction, that is the number of output attributes
-     *
-     * @return the votes for the first output attribute outputAttributeIndex.
-     */
-     public int size();
-
-    /**
-     * The text of the prediction, that is the description of the values of the prediction
-     *
-     * @return the text
-     */
-     public String toString();
-    
-     
-     /**
-      * The single double value of the prediction. Used for regression.
-      *
-      * @return the prediction value
-      */
-     public double asDouble();
-     
-     /**
-      * The DoubleVector of the predictions. Used for multi-target regression and multi-label classification.
-      *
-      * @return the prediction vector
-      */
-     public DoubleVector asDoubleVector();
-     
-     /**
-      * The double array of votes for specific labels. Used for classification and multi-label classification.
-      *
-      * @return the array of votes
-      */
-     public double[] asDoubleArray();
-     
-     /**
-      * The representation string of the prediction used in output files.
-      *
-      * @return the representation of the prediction
-      */
-     public String asPredictionString();
-  }
+	/**
+	 * The single double value of the prediction. Used for regression.
+	 *
+	 * @return the prediction value
+	 */
+	double asDouble();
+
+	/**
+	 * The DoubleVector of the predictions. Used for multi-target regression and
+	 * multi-label classification.
+	 *
+	 * @return the prediction vector
+	 */
+	DoubleVector asDoubleVector();
+
+	/**
+	 * The double array of votes for specific labels. Used for classification and
+	 * multi-label classification.
+	 *
+	 * @return the array of votes
+	 */
+	double[] asDoubleArray();
+
+	/**
+	 * The representation string of the prediction used in output files.
+	 *
+	 * @return the representation of the prediction
+	 */
+	String asPredictionString();
+}
diff --git a/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/RegressionPrediction.java b/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/RegressionPrediction.java
index 05409f25c..48b450f9c 100644
--- a/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/RegressionPrediction.java
+++ b/moa/src/main/java/com/yahoo/labs/samoa/instances/predictions/RegressionPrediction.java
@@ -1,16 +1,16 @@
-/* 
+/*
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * 	        http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  * either express or implied. See the License for the specific
  * language governing permissions and limitations under the
- * License.  
+ * License.
  */
 package com.yahoo.labs.samoa.instances.predictions;
 
@@ -19,9 +19,9 @@
 import moa.core.DoubleVector;
 
 public class RegressionPrediction implements Prediction, Serializable {
-	
+
 	private static final long serialVersionUID = 1L;
-	
+
 	protected double prediction;
 
 	public RegressionPrediction() {
@@ -30,7 +30,7 @@ public RegressionPrediction() {
 	public RegressionPrediction(double prediction) {
 		this.prediction = prediction;
 	}
-	
+
 	@Override
 	public int numOutputAttributes() {
 		return 1;
@@ -45,7 +45,7 @@ public int numClasses(int outputAttributeIndex) {
 	public double[] getVotes(int outputAttributeIndex) {
 		throw new UnsupportedOperationException("This is a single-target regression prediction.");
 	}
-	
+
 	@Override
 	public double[] getVotes() {
 		throw new UnsupportedOperationException("This is a single-target regression prediction.");
@@ -62,7 +62,7 @@ public double getVote(int outputAttributeIndex, int classIndex) {
 	public void setVotes(int outputAttributeIndex, double[] votes) {
 		throw new UnsupportedOperationException("This is a single-target regression prediction.");
 	}
-	
+
 	@Override
 	public void setVotes(double[] votes) {
 		throw new UnsupportedOperationException("This is a single-target regression prediction.");
@@ -73,17 +73,16 @@ public void setVote(int outputAttributeIndex, int classIndex, double vote) {
 		throw new UnsupportedOperationException("This is a single-target regression prediction.");
 	}
 
-
 	@Override
 	public void setVote(int outputAttributeIndex, double vote) {
-		throw new UnsupportedOperationException("This is a single-target regression prediction.");		
+		throw new UnsupportedOperationException("This is a single-target regression prediction.");
 	}
-	
+
 	@Override
-	public String toString(){
-		StringBuffer sb= new StringBuffer();
+	public String toString() {
+		StringBuffer sb = new StringBuffer();
 		sb.append("Out " + 0 + ": ");
-		sb.append(((int) (prediction*1000)/1000.0)+ " ");
+		sb.append(((int) (prediction * 1000) / 1000.0) + " ");
 		return sb.toString();
 	}
 
@@ -92,22 +91,25 @@ public boolean hasVotesForAttribute(int outputAttributeIndex) {
 		throw new UnsupportedOperationException("This is a single-target regression prediction.");
 	}
 
-    @Override
-    public int size() {
-        return 1;
-    }
-    
-    public double asDouble() {
-    	return prediction;
-    }
-    
-    public DoubleVector asDoubleVector() {
-    	return new DoubleVector(new double[] {prediction});
-    }
-
-    public double[] asDoubleArray() {
-    	return new double[] {prediction};
-    }
+	@Override
+	public int size() {
+		return 1;
+	}
+
+	@Override
+	public double asDouble() {
+		return prediction;
+	}
+
+	@Override
+	public DoubleVector asDoubleVector() {
+		return new DoubleVector(new double[] { prediction });
+	}
+
+	@Override
+	public double[] asDoubleArray() {
+		return new double[] { prediction };
+	}
 
 	@Override
 	public String asPredictionString() {
diff --git a/moa/src/main/java/moa/AbstractMOAObject.java b/moa/src/main/java/moa/AbstractMOAObject.java
index 3cea8bf11..8c62a85d9 100644
--- a/moa/src/main/java/moa/AbstractMOAObject.java
+++ b/moa/src/main/java/moa/AbstractMOAObject.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa;
 
@@ -23,57 +23,57 @@
 import moa.core.SizeOf;
 
 /**
- * Abstract MOA Object. All classes that are serializable, copiable,
- * can measure its size, and can give a description, extend this class.
+ * Abstract MOA Object. All classes that are serializable, copiable, can measure
+ * its size, and can give a description, extend this class.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
 public abstract class AbstractMOAObject implements MOAObject {
 
-    @Override
-    public MOAObject copy() {
-        return copy(this);
-    }
+	@Override
+	public MOAObject copy() {
+		return copy(this);
+	}
 
-    @Override
-    public long measureByteSize() {
-        return measureByteSize(this);
-    }
+	@Override
+	public long measureByteSize() {
+		return measureByteSize(this);
+	}
 
-    /**
-     * Returns a description of the object.
-     *
-     * @return a description of the object
-     */
-    @Override
-    public String toString() {
-        StringBuilder sb = new StringBuilder();
-        getDescription(sb, 0);
-        return sb.toString();
-    }
+	/**
+	 * Returns a description of the object.
+	 *
+	 * @return a description of the object
+	 */
+	@Override
+	public String toString() {
+		StringBuilder sb = new StringBuilder();
+		getDescription(sb, 0);
+		return sb.toString();
+	}
 
-    /**
-     * This method produces a copy of an object.
-     *
-     * @param obj object to copy
-     * @return a copy of the object
-     */
-    public static MOAObject copy(MOAObject obj) {
-        try {
-            return (MOAObject) SerializeUtils.copyObject(obj);
-        } catch (Exception e) {
-            throw new RuntimeException("Object copy failed.", e);
-        }
-    }
+	/**
+	 * This method produces a copy of an object.
+	 *
+	 * @param obj object to copy
+	 * @return a copy of the object
+	 */
+	public static MOAObject copy(MOAObject obj) {
+		try {
+			return (MOAObject) SerializeUtils.copyObject(obj);
+		} catch (Exception e) {
+			throw new RuntimeException("Object copy failed.", e);
+		}
+	}
 
-    /**
-     * Gets the memory size of an object.
-     *
-     * @param obj object to measure the memory size
-     * @return the memory size of this object
-     */
-    public static long measureByteSize(MOAObject obj) {
-        return SizeOf.fullSizeOf(obj);
-    }
+	/**
+	 * Gets the memory size of an object.
+	 *
+	 * @param obj object to measure the memory size
+	 * @return the memory size of this object
+	 */
+	public static long measureByteSize(MOAObject obj) {
+		return SizeOf.fullSizeOf(obj);
+	}
 }
diff --git a/moa/src/main/java/moa/DoTask.java b/moa/src/main/java/moa/DoTask.java
index 0eb0c70fc..bba107c7e 100644
--- a/moa/src/main/java/moa/DoTask.java
+++ b/moa/src/main/java/moa/DoTask.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa;
 
@@ -44,211 +44,197 @@
  */
 public class DoTask {
 
-    /** Array of characters to use to animate the progress of tasks running. */
-    public static final char[] progressAnimSequence = new char[]{'-', '\\',
-        '|', '/'};
+	/** Array of characters to use to animate the progress of tasks running. */
+	public static final char[] progressAnimSequence = new char[] { '-', '\\', '|', '/' };
 
-    /** Maximum length of the status string that shows the progress of tasks running.  */
-    public static final int MAX_STATUS_STRING_LENGTH = 79;
+	/**
+	 * Maximum length of the status string that shows the progress of tasks running.
+	 */
+	public static final int MAX_STATUS_STRING_LENGTH = 79;
 
-    /**
-     * Checks if the Java version is recent enough to run MOA.
-     *
-     * @return true if the Java version is recent.
-     */
-    public static boolean isJavaVersionOK() {
-        boolean isJavaVersionOK = true;
-        String versionStr = System.getProperty("java.version");
-        String[] parts;
-        double version;
-        if (versionStr.contains(".")) {
-          parts = versionStr.split("\\.");
-	}
-	else {
-          parts = new String[]{versionStr};
-	}
-	if (parts.length == 1) {
-          try {
-            version = Double.parseDouble(parts[0]);
-	  }
-	  catch (Exception e) {
-            System.err.println("Unparsable Java version: " + versionStr);
-            return false;
-	  }
+	/**
+	 * Checks if the Java version is recent enough to run MOA.
+	 *
+	 * @return true if the Java version is recent.
+	 */
+	public static boolean isJavaVersionOK() {
+		boolean isJavaVersionOK = true;
+		String versionStr = System.getProperty("java.version");
+		String[] parts;
+		double version;
+		if (versionStr.contains(".")) {
+			parts = versionStr.split("\\.");
+		} else {
+			parts = new String[] { versionStr };
+		}
+		if (parts.length == 1) {
+			try {
+				version = Double.parseDouble(parts[0]);
+			} catch (Exception e) {
+				System.err.println("Unparsable Java version: " + versionStr);
+				return false;
+			}
+		} else {
+			try {
+				version = Double.parseDouble(parts[0]) + Double.parseDouble(parts[1]) / 10;
+			} catch (Exception e) {
+				System.err.println("Unparsable Java version: " + versionStr);
+				return false;
+			}
+		}
+		if (version < 1.8) {
+			isJavaVersionOK = false;
+			System.err.println();
+			System.err.println(Globals.getWorkbenchInfoString());
+			System.err.println();
+			System.err.print("Java 8 or higher is required to run MOA. ");
+			System.err.println("Java version " + versionStr + " found");
+		}
+		return isJavaVersionOK;
 	}
-	else {
-          try {
-            version = Double.parseDouble(parts[0]) + Double.parseDouble(parts[1]) / 10;
-	  }
-	  catch (Exception e) {
-            System.err.println("Unparsable Java version: " + versionStr);
-            return false;
-	  }
+
+	/**
+	 * Checks if the Weka version is recent enough to run MOA. For example, if the
+	 * Weka version is not recent, there may be problems due to the fact that
+	 * <code>Instance</code> was a class before 3.7.1 and now is an interface.
+	 *
+	 * @return true if the Weka version is recent.
+	 */
+	public static boolean isWekaVersionOK() {
+		Version version = new Version();
+		if (version.isOlder("3.9.2")) {
+			System.err.println();
+			System.err.println(Globals.getWorkbenchInfoString());
+			System.err.println();
+			System.err.print("Weka 3.9.2 or higher is required to run MOA. ");
+			System.err.println("Weka version " + Version.VERSION + " found");
+			return false;
+		} else {
+			return true;
+		}
 	}
-        if (version < 1.8) {
-            isJavaVersionOK = false;
-            System.err.println();
-            System.err.println(Globals.getWorkbenchInfoString());
-            System.err.println();
-            System.err.print("Java 8 or higher is required to run MOA. ");
-            System.err.println("Java version " + versionStr + " found");
-        }
-        return isJavaVersionOK;
-    }
 
-    /**
-     * Checks if the Weka version is recent enough to run MOA.
-     * For example, if the Weka version is not recent, there may be problems
-     * due to the fact that <code>Instance</code> was a class before 3.7.1 and
-     * now is an interface.
-     *
-     * @return true if the Weka version is recent.
-     */
-    public static boolean isWekaVersionOK() {
-        Version version = new Version();
-        if (version.isOlder("3.9.2")) {
-            System.err.println();
-            System.err.println(Globals.getWorkbenchInfoString());
-            System.err.println();
-            System.err.print("Weka 3.9.2 or higher is required to run MOA. ");
-            System.err.println("Weka version " + Version.VERSION + " found");
-            return false;
-        } else {
-            return true;
-        }
-    }
-   
+	/**
+	 * Main method for running tasks from the command line.
+	 *
+	 * @param args the options
+	 */
+	public static void main(String[] args) {
+		try {
+			if (args.length < 1) {
+				System.err.println();
+				System.err.println(Globals.getWorkbenchInfoString());
+				System.err.println();
+				System.err.println("No task specified.");
+			} else {
+				if (isJavaVersionOK() == false || WekaUtils.isWekaVersionOK() == false) {
+					return;
+				}
+				// create standard options
+				FlagOption suppressStatusOutputOption = new FlagOption("suppressStatusOutput", 'S',
+						"Suppress the task status output that is normally send to stderr.");
+				FlagOption suppressResultOutputOption = new FlagOption("suppressResultOutput", 'R',
+						"Suppress the task result output that is normally send to stdout.");
+				IntOption statusUpdateFrequencyOption = new IntOption("statusUpdateFrequency", 'F',
+						"How many milliseconds to wait between status updates.", 1000, 0, Integer.MAX_VALUE);
+				Option[] extraOptions = new Option[] { suppressStatusOutputOption, suppressResultOutputOption,
+						statusUpdateFrequencyOption };
+				// build a single string by concatenating cli options
+				StringBuilder cliString = new StringBuilder();
+				for (int i = 0; i < args.length; i++) {
+					cliString.append(" ").append(args[i]);
+				}
+				// parse options
+				AbstractTask task;
+				try {
+					task = (AbstractTask) ClassOption.cliStringToObject(cliString.toString(), MainTask.class,
+							extraOptions);
+				} catch (Exception e) {
+					// regular task could not be found, maybe it is a meta task
+					task = (AbstractTask) ClassOption.cliStringToObject(cliString.toString(), MetaMainTask.class,
+							extraOptions);
+				}
+				task.prepareForUse();
 
-    /**
-     * Main method for running tasks from the command line.
-     *
-     * @param args the options
-     */
-    public static void main(String[] args) {
-        try {
-            if (args.length < 1) {
-                System.err.println();
-                System.err.println(Globals.getWorkbenchInfoString());
-                System.err.println();
-                System.err.println("No task specified.");
-            } else {
-                if (isJavaVersionOK() == false || WekaUtils.isWekaVersionOK() == false) {
-                    return;
-                }
-                // create standard options
-                FlagOption suppressStatusOutputOption = new FlagOption(
-                        "suppressStatusOutput", 'S',
-                        "Suppress the task status output that is normally send to stderr.");
-                FlagOption suppressResultOutputOption = new FlagOption(
-                        "suppressResultOutput", 'R',
-                        "Suppress the task result output that is normally send to stdout.");
-                IntOption statusUpdateFrequencyOption = new IntOption(
-                        "statusUpdateFrequency",
-                        'F',
-                        "How many milliseconds to wait between status updates.",
-                        1000, 0, Integer.MAX_VALUE);
-                Option[] extraOptions = new Option[]{
-                    suppressStatusOutputOption, suppressResultOutputOption,
-                    statusUpdateFrequencyOption};
-                // build a single string by concatenating cli options
-                StringBuilder cliString = new StringBuilder();
-                for (int i = 0; i < args.length; i++) {
-                    cliString.append(" ").append(args[i]);
-                }
-                // parse options
-                AbstractTask task;
-                try {
-                	task = (AbstractTask) ClassOption.cliStringToObject(
-                			cliString.toString(), MainTask.class, extraOptions);
-                } catch(Exception e) {
-                	// regular task could not be found, maybe it is a meta task
-            		task = (AbstractTask) ClassOption.cliStringToObject(
-            				cliString.toString(), MetaMainTask.class, extraOptions);
-                }
-                task.prepareForUse();
-                
-                Object result = null;
-                if (suppressStatusOutputOption.isSet()) {
-                    result = task.doTask();
-                } else {
-                    System.err.println();
-                    System.err.println(Globals.getWorkbenchInfoString());
-                    System.err.println();
-                    boolean preciseTiming = TimingUtils.enablePreciseTiming();
-                    // start the task thread
-                    TaskThread taskThread = new TaskThread(task);
-                    taskThread.start();
-                    int progressAnimIndex = 0;
-                    // inform user of progress
-                    while (!taskThread.isComplete()) {
-                        StringBuilder progressLine = new StringBuilder();
-                        progressLine.append(progressAnimSequence[progressAnimIndex]);
-                        progressLine.append(' ');
-                        progressLine.append(StringUtils.secondsToDHMSString(taskThread.getCPUSecondsElapsed()));
-                        progressLine.append(" [");
-                        progressLine.append(taskThread.getCurrentStatusString());
-                        progressLine.append("] ");
-                        double fracComplete = taskThread.getCurrentActivityFracComplete();
-                        if (fracComplete >= 0.0) {
-                            progressLine.append(StringUtils.doubleToString(
-                                    fracComplete * 100.0, 2, 2));
-                            progressLine.append("% ");
-                        }
-                        progressLine.append(taskThread.getCurrentActivityString());
-                        while (progressLine.length() < MAX_STATUS_STRING_LENGTH) {
-                            progressLine.append(" ");
-                        }
-                        if (progressLine.length() > MAX_STATUS_STRING_LENGTH) {
-                            progressLine.setLength(MAX_STATUS_STRING_LENGTH);
-                            progressLine.setCharAt(
-                                    MAX_STATUS_STRING_LENGTH - 1, '~');
-                        }
-                        System.err.print(progressLine.toString());
-                        System.err.print('\r');
-                        if (++progressAnimIndex >= progressAnimSequence.length) {
-                            progressAnimIndex = 0;
-                        }
-                        try {
-                            Thread.sleep(statusUpdateFrequencyOption.getValue());
-                        } catch (InterruptedException ignored) {
-                            // wake up
-                        }
-                    }
-                    StringBuilder cleanupString = new StringBuilder();
-                    for (int i = 0; i < MAX_STATUS_STRING_LENGTH; i++) {
-                        cleanupString.append(' ');
-                    }
-                    System.err.println(cleanupString);
-                    result = taskThread.getFinalResult();
-                    if (!(result instanceof FailedTaskReport)) {
-                        System.err.print("Task completed in "
-                                + StringUtils.secondsToDHMSString(taskThread.getCPUSecondsElapsed()));
-                        if (preciseTiming) {
-                            System.err.print(" (CPU time)");
-                        }
-                        System.err.println();
-                        System.err.println();
-                    }
-                }
-                if (result instanceof FailedTaskReport) {
-                    System.err.println("Task failed. Reason: ");
-                    ((FailedTaskReport) result).getFailureReason().printStackTrace();
-                } else {
-                    if (!suppressResultOutputOption.isSet()) {
-                        if (result instanceof Measurement[]) {
-                            StringBuilder sb = new StringBuilder();
-                            Measurement.getMeasurementsDescription(
-                                    (Measurement[]) result, sb, 0);
-                            System.out.println(sb.toString());
-                        } else {
-                            System.out.println(result);
-                        }
-                        System.out.flush();
-                    }
-                }
-            }
-        } catch (Exception ex) {
-            ex.printStackTrace();
-        }
-    }
+				Object result = null;
+				if (suppressStatusOutputOption.isSet()) {
+					result = task.doTask();
+				} else {
+					System.err.println();
+					System.err.println(Globals.getWorkbenchInfoString());
+					System.err.println();
+					boolean preciseTiming = TimingUtils.enablePreciseTiming();
+					// start the task thread
+					TaskThread taskThread = new TaskThread(task);
+					taskThread.start();
+					int progressAnimIndex = 0;
+					// inform user of progress
+					while (!taskThread.isComplete()) {
+						StringBuilder progressLine = new StringBuilder();
+						progressLine.append(progressAnimSequence[progressAnimIndex]);
+						progressLine.append(' ');
+						progressLine.append(StringUtils.secondsToDHMSString(taskThread.getCPUSecondsElapsed()));
+						progressLine.append(" [");
+						progressLine.append(taskThread.getCurrentStatusString());
+						progressLine.append("] ");
+						double fracComplete = taskThread.getCurrentActivityFracComplete();
+						if (fracComplete >= 0.0) {
+							progressLine.append(StringUtils.doubleToString(fracComplete * 100.0, 2, 2));
+							progressLine.append("% ");
+						}
+						progressLine.append(taskThread.getCurrentActivityString());
+						while (progressLine.length() < MAX_STATUS_STRING_LENGTH) {
+							progressLine.append(" ");
+						}
+						if (progressLine.length() > MAX_STATUS_STRING_LENGTH) {
+							progressLine.setLength(MAX_STATUS_STRING_LENGTH);
+							progressLine.setCharAt(MAX_STATUS_STRING_LENGTH - 1, '~');
+						}
+						System.err.print(progressLine.toString());
+						System.err.print('\r');
+						if (++progressAnimIndex >= progressAnimSequence.length) {
+							progressAnimIndex = 0;
+						}
+						try {
+							Thread.sleep(statusUpdateFrequencyOption.getValue());
+						} catch (InterruptedException ignored) {
+							// wake up
+						}
+					}
+					StringBuilder cleanupString = new StringBuilder();
+					for (int i = 0; i < MAX_STATUS_STRING_LENGTH; i++) {
+						cleanupString.append(' ');
+					}
+					System.err.println(cleanupString);
+					result = taskThread.getFinalResult();
+					if (!(result instanceof FailedTaskReport)) {
+						System.err.print("Task completed in "
+								+ StringUtils.secondsToDHMSString(taskThread.getCPUSecondsElapsed()));
+						if (preciseTiming) {
+							System.err.print(" (CPU time)");
+						}
+						System.err.println();
+						System.err.println();
+					}
+				}
+				if (result instanceof FailedTaskReport) {
+					System.err.println("Task failed. Reason: ");
+					((FailedTaskReport) result).getFailureReason().printStackTrace();
+				} else {
+					if (!suppressResultOutputOption.isSet()) {
+						if (result instanceof Measurement[]) {
+							StringBuilder sb = new StringBuilder();
+							Measurement.getMeasurementsDescription((Measurement[]) result, sb, 0);
+							System.out.println(sb.toString());
+						} else {
+							System.out.println(result);
+						}
+						System.out.flush();
+					}
+				}
+			}
+		} catch (Exception ex) {
+			ex.printStackTrace();
+		}
+	}
 }
diff --git a/moa/src/main/java/moa/MOAObject.java b/moa/src/main/java/moa/MOAObject.java
index 4ec56618d..dc127a1f8 100644
--- a/moa/src/main/java/moa/MOAObject.java
+++ b/moa/src/main/java/moa/MOAObject.java
@@ -15,43 +15,43 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa;
 
 import java.io.Serializable;
 
 /**
- * Interface implemented by classes in MOA, so that all are serializable,
- * can produce copies of their objects, and can measure its memory size.
- * They also give a string description. 
+ * Interface implemented by classes in MOA, so that all are serializable, can
+ * produce copies of their objects, and can measure its memory size. They also
+ * give a string description.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
 public interface MOAObject extends Serializable {
 
-    /**
-     * Gets the memory size of this object.
-     *
-     * @return the memory size of this object
-     */
-    public long measureByteSize();
+	/**
+	 * Gets the memory size of this object.
+	 *
+	 * @return the memory size of this object
+	 */
+	long measureByteSize();
 
-    /**
-     * This method produces a copy of this object.
-     *
-     * @return a copy of this object
-     */
-    public MOAObject copy();
+	/**
+	 * This method produces a copy of this object.
+	 *
+	 * @return a copy of this object
+	 */
+	MOAObject copy();
 
-    /**
-     * Returns a string representation of this object.
-     * Used in <code>AbstractMOAObject.toString</code>
-     * to give a string representation of the object.
-     *
-     * @param sb	the stringbuilder to add the description
-     * @param indent	the number of characters to indent
-     */
-    public void getDescription(StringBuilder sb, int indent);
+	/**
+	 * Returns a string representation of this object. Used in
+	 * <code>AbstractMOAObject.toString</code> to give a string representation of
+	 * the object.
+	 *
+	 * @param sb     the stringbuilder to add the description
+	 * @param indent the number of characters to indent
+	 */
+	void getDescription(StringBuilder sb, int indent);
 }
diff --git a/moa/src/main/java/moa/MakeObject.java b/moa/src/main/java/moa/MakeObject.java
index 7e8051d96..7ef0419a5 100644
--- a/moa/src/main/java/moa/MakeObject.java
+++ b/moa/src/main/java/moa/MakeObject.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa;
 
@@ -34,37 +34,36 @@
  */
 public class MakeObject {
 
-    /**
-     * Main method for writing an object to a file from the command line.
-     *
-     * @param args the options
-     */
-    public static void main(String[] args) {
-        try {
-            System.err.println();
-            System.err.println(Globals.getWorkbenchInfoString());
-            System.err.println();
-            if (args.length < 2) {
-                System.err.println("usage: java " + MakeObject.class.getName()
-                        + " outputfile.moa \"<object name> <options>\"");
-                System.err.println();
-            } else {
-                String filename = args[0];
-                // build a single string by concatenating cli options
-                StringBuilder cliString = new StringBuilder();
-                for (int i = 1; i < args.length; i++) {
-                    cliString.append(" " + args[i]);
-                }
-                // parse options
-                System.err.println("Making object...");
-                Object result = ClassOption.cliStringToObject(cliString.toString(), Object.class, null);
-                System.err.println("Writing object to file: " + filename);
-                SerializeUtils.writeToFile(new File(filename),
-                        (Serializable) result);
-                System.err.println("Done.");
-            }
-        } catch (Exception ex) {
-            ex.printStackTrace();
-        }
-    }
+	/**
+	 * Main method for writing an object to a file from the command line.
+	 *
+	 * @param args the options
+	 */
+	public static void main(String[] args) {
+		try {
+			System.err.println();
+			System.err.println(Globals.getWorkbenchInfoString());
+			System.err.println();
+			if (args.length < 2) {
+				System.err.println(
+						"usage: java " + MakeObject.class.getName() + " outputfile.moa \"<object name> <options>\"");
+				System.err.println();
+			} else {
+				String filename = args[0];
+				// build a single string by concatenating cli options
+				StringBuilder cliString = new StringBuilder();
+				for (int i = 1; i < args.length; i++) {
+					cliString.append(" " + args[i]);
+				}
+				// parse options
+				System.err.println("Making object...");
+				Object result = ClassOption.cliStringToObject(cliString.toString(), Object.class, null);
+				System.err.println("Writing object to file: " + filename);
+				SerializeUtils.writeToFile(new File(filename), (Serializable) result);
+				System.err.println("Done.");
+			}
+		} catch (Exception ex) {
+			ex.printStackTrace();
+		}
+	}
 }
diff --git a/moa/src/main/java/moa/capabilities/Capabilities.java b/moa/src/main/java/moa/capabilities/Capabilities.java
index 646fbf949..281c8059f 100644
--- a/moa/src/main/java/moa/capabilities/Capabilities.java
+++ b/moa/src/main/java/moa/capabilities/Capabilities.java
@@ -25,94 +25,93 @@
 import java.util.Set;
 
 /**
- * Container class representing the set of capabilities an object
- * has.
+ * Container class representing the set of capabilities an object has.
  *
  * @author Corey Sterling (csterlin at waikato dot ac dot nz)
  */
 public class Capabilities {
 
-  /** The set of capabilities. */
-  protected Set<Capability> m_Capabilities = new HashSet<>();
+	/** The set of capabilities. */
+	protected Set<Capability> m_Capabilities = new HashSet<>();
 
-  /** Creates a capabilities object with no capabilities. */
-  public Capabilities() {
-  }
+	/** Creates a capabilities object with no capabilities. */
+	public Capabilities() {
+	}
 
-  /**
-   * Creates a capabilities object with the given capabilities.
-   *
-   * @param capabilities  The capabilities to initially have.
-   */
-  public Capabilities(Capability... capabilities) {
-    addCapabilities(capabilities);
-  }
+	/**
+	 * Creates a capabilities object with the given capabilities.
+	 *
+	 * @param capabilities The capabilities to initially have.
+	 */
+	public Capabilities(Capability... capabilities) {
+		addCapabilities(capabilities);
+	}
 
-  /**
-   * Augments this capabilities object with the given capabilities.
-   *
-   * @param capabilities  The capabilities to add.
-   */
-  public void addCapabilities(Capability... capabilities) {
-    for (Capability capability : capabilities) {
-      addCapability(capability);
-    }
-  }
+	/**
+	 * Augments this capabilities object with the given capabilities.
+	 *
+	 * @param capabilities The capabilities to add.
+	 */
+	public void addCapabilities(Capability... capabilities) {
+		for (Capability capability : capabilities) {
+			addCapability(capability);
+		}
+	}
 
-  /**
-   * Augments this capabilities object with the given capabilities.
-   *
-   * @param capabilities  The capabilities to add.
-   */
-  public void addCapabilities(Collection<Capability> capabilities) {
-    m_Capabilities.addAll(capabilities);
-  }
+	/**
+	 * Augments this capabilities object with the given capabilities.
+	 *
+	 * @param capabilities The capabilities to add.
+	 */
+	public void addCapabilities(Collection<Capability> capabilities) {
+		m_Capabilities.addAll(capabilities);
+	}
 
-  /**
-   * Augments this capabilities object with the given capabilities.
-   *
-   * @param other  The capabilities to add.
-   */
-  public void addCapabilities(Capabilities other) {
-    for (Capability capability : other.m_Capabilities) {
-      addCapability(capability);
-    }
-  }
+	/**
+	 * Augments this capabilities object with the given capabilities.
+	 *
+	 * @param other The capabilities to add.
+	 */
+	public void addCapabilities(Capabilities other) {
+		for (Capability capability : other.m_Capabilities) {
+			addCapability(capability);
+		}
+	}
 
-  /**
-   * Augments this capabilities object with the given capability.
-   *
-   * @param capability  The capability to add.
-   */
-  public void addCapability(Capability capability) {
-    m_Capabilities.add(capability);
-  }
+	/**
+	 * Augments this capabilities object with the given capability.
+	 *
+	 * @param capability The capability to add.
+	 */
+	public void addCapability(Capability capability) {
+		m_Capabilities.add(capability);
+	}
 
-  /**
-   * Returns whether this capabilities object contains the given capability.
-   *
-   * @return  True if this capabilities object contains the given capability,
-   *          false if not.
-   */
-  public boolean hasCapability(Capability capability) {
-    return m_Capabilities.contains(capability);
-  }
+	/**
+	 * Returns whether this capabilities object contains the given capability.
+	 *
+	 * @return True if this capabilities object contains the given capability, false
+	 *         if not.
+	 */
+	public boolean hasCapability(Capability capability) {
+		return m_Capabilities.contains(capability);
+	}
 
-  @Override
-  public boolean equals(Object other) {
-    if (other instanceof Capabilities)
-      return equals((Capabilities) other);
-    else if (other instanceof Capability)
-      return equals((Capability) other);
-    else
-      return false;
-  }
+	@Override
+	public boolean equals(Object other) {
+		if (other instanceof Capabilities)
+			return equals((Capabilities) other);
+		else if (other instanceof Capability)
+			return equals((Capability) other);
+		else
+			return false;
+	}
 
-  public boolean equals(Capabilities other) {
-    return m_Capabilities.equals(other.m_Capabilities);
-  }
+	public boolean equals(Capabilities other) {
+		return m_Capabilities.equals(other.m_Capabilities);
+	}
 
-  public boolean equals(Capability other) {
-    return m_Capabilities.size() == 1 && m_Capabilities.contains(other);
-  }
+	public boolean equals(Capability other) {
+		return m_Capabilities.size() == 1 && m_Capabilities.contains(other);
+	}
 }
diff --git a/moa/src/main/java/moa/capabilities/CapabilitiesHandler.java b/moa/src/main/java/moa/capabilities/CapabilitiesHandler.java
index b7c55d51a..e3914b4c3 100644
--- a/moa/src/main/java/moa/capabilities/CapabilitiesHandler.java
+++ b/moa/src/main/java/moa/capabilities/CapabilitiesHandler.java
@@ -21,35 +21,35 @@
 package moa.capabilities;
 
 /**
- * Interface marking classes as being able to specify the capabilities
- * they can handle.
+ * Interface marking classes as being able to specify the capabilities they can
+ * handle.
  *
  * @author Corey Sterling (csterlin at waikato dot ac dot nz)
  */
 public interface CapabilitiesHandler {
 
-  /**
-   * Gets the capabilities of the object. Should be overridden if
-   * the object's capabilities can change.
-   *
-   * @return  The capabilities of the object.
-   */
-  default Capabilities getCapabilities() {
-    // On first access, register with the immutable capabilities lookup
-    if (!ImmutableCapabilities.StaticLookup.isDefined(this))
-      ImmutableCapabilities.StaticLookup.define(this, defineImmutableCapabilities());
+	/**
+	 * Gets the capabilities of the object. Should be overridden if the object's
+	 * capabilities can change.
+	 *
+	 * @return The capabilities of the object.
+	 */
+	default Capabilities getCapabilities() {
+		// On first access, register with the immutable capabilities lookup
+		if (!ImmutableCapabilities.StaticLookup.isDefined(this))
+			ImmutableCapabilities.StaticLookup.define(this, defineImmutableCapabilities());
 
-    // Get our capabilities from the lookup
-    return ImmutableCapabilities.StaticLookup.get(this);
-  }
+		// Get our capabilities from the lookup
+		return ImmutableCapabilities.StaticLookup.get(this);
+	}
 
-  /**
-   * Defines the set of capabilities the object has. Should be overridden
-   * if the object's capabilities do not change.
-   *
-   * @return  The capabilities of the object.
-   */
-  default ImmutableCapabilities defineImmutableCapabilities() {
-    return CapabilityRequirement.NON_HANDLER_CAPABILITIES;
-  }
+	/**
+	 * Defines the set of capabilities the object has. Should be overridden if the
+	 * object's capabilities do not change.
+	 *
+	 * @return The capabilities of the object.
+	 */
+	default ImmutableCapabilities defineImmutableCapabilities() {
+		return CapabilityRequirement.NON_HANDLER_CAPABILITIES;
+	}
 }
diff --git a/moa/src/main/java/moa/capabilities/Capability.java b/moa/src/main/java/moa/capabilities/Capability.java
index 4c84e0afe..a589dc28c 100644
--- a/moa/src/main/java/moa/capabilities/Capability.java
+++ b/moa/src/main/java/moa/capabilities/Capability.java
@@ -21,40 +21,38 @@
 package moa.capabilities;
 
 /**
- * Class enumerating the different possible capabilities of objects in
- * MOA.
+ * Class enumerating the different possible capabilities of objects in MOA.
  *
  * @author Corey Sterling (csterlin at waikato dot ac dot nz)
  */
 public enum Capability {
-  VIEW_STANDARD, // Can be viewed in STANDARD mode
-  VIEW_LITE, // Can be viewed in LITE mode
-  VIEW_EXPERIMENTAL; // Can be viewed in EXPERIMENTAL mode
-
-  @Override
-  public String toString() {
-    // Removes the "VIEW_" part of the name
-    return name().substring(5);
-  }
-
-  /**
-   * Creates an array of the string representation
-   * of each value.
-   *
-   * @return  The array of strings.
-   */
-  public static String[] stringValues() {
-    Capability[] values = values();
-    String[] stringValues = new String[values.length];
-
-    for (int i = 0; i < values.length; i++) {
-      stringValues[i] = values[i].toString();
-    }
-
-    return stringValues;
-  }
-
-  public static Capability forShortName(String shortName) {
-    return Enum.valueOf(Capability.class, "VIEW_" + shortName.toUpperCase());
-  }
+	VIEW_STANDARD, // Can be viewed in STANDARD mode
+	VIEW_LITE, // Can be viewed in LITE mode
+	VIEW_EXPERIMENTAL; // Can be viewed in EXPERIMENTAL mode
+
+	@Override
+	public String toString() {
+		// Removes the "VIEW_" part of the name
+		return name().substring(5);
+	}
+
+	/**
+	 * Creates an array of the string representation of each value.
+	 *
+	 * @return The array of strings.
+	 */
+	public static String[] stringValues() {
+		Capability[] values = values();
+		String[] stringValues = new String[values.length];
+
+		for (int i = 0; i < values.length; i++) {
+			stringValues[i] = values[i].toString();
+		}
+
+		return stringValues;
+	}
+
+	public static Capability forShortName(String shortName) {
+		return Enum.valueOf(Capability.class, "VIEW_" + shortName.toUpperCase());
+	}
 }
diff --git a/moa/src/main/java/moa/capabilities/CapabilityRequirement.java b/moa/src/main/java/moa/capabilities/CapabilityRequirement.java
index f77fee442..607439986 100644
--- a/moa/src/main/java/moa/capabilities/CapabilityRequirement.java
+++ b/moa/src/main/java/moa/capabilities/CapabilityRequirement.java
@@ -27,136 +27,130 @@
  *
  * @author Corey Sterling (csterlin at waikato dot ac dot nz)
  */
-public class CapabilityRequirement
-{
-
-  /**
-   * The capabilities to assume a class has if it does not implement
-   * the CapabilitiesHandler interface.
-   */
-  public static final ImmutableCapabilities NON_HANDLER_CAPABILITIES = new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-
-  /** The function to use to test if the requirement is met. */
-  private Predicate<Capabilities> m_Test;
-
-  /**
-   * Creates a capabilities requirement with the given predicate
-   * as its method of checking if the requirement is met.
-   *
-   * @param check	The test for adherence.
-   */
-  public CapabilityRequirement(Predicate<Capabilities> check) {
-    // Can't create a null test
-    if (check == null)
-      throw new IllegalArgumentException("Capability requirement cannot be null");
-
-    m_Test = check;
-  }
-
-  /**
-   * Tests if the requirement is met by the given set of capabilities.
-   *
-   * @param capabilities	The set of capabilities to test.
-   * @return			True if the requirement is met,
-   * 				false if not.
-   */
-  public boolean isMetBy(Capabilities capabilities) {
-    return m_Test.test(capabilities);
-  }
-
-  /**
-   * Tests if the requirement is met by the given capabilities handler.
-   *
-   * @param handler	The handler to test.
-   * @return		True if the handler meets the requirements,
-   * 			false if not.
-   */
-  public boolean isMetBy(CapabilitiesHandler handler) {
-    return isMetBy(handler.getCapabilities());
-  }
-
-  /**
-   * Tests if the requirement is met by the given class.
-   *
-   * @param klass	The class to test.
-   * @return		True if the class meets the requirements,
-   * 			false if not.
-   */
-  public boolean isMetBy(Class<?> klass) {
-    // Classes which aren't capabilities handlers have an assumed
-    // set of capabilities
-    if (!CapabilitiesHandler.class.isAssignableFrom(klass))
-      return isMetBy(NON_HANDLER_CAPABILITIES);
-
-    // Attempt to instantiate an instance of the class
-    CapabilitiesHandler instance;
-    try {
-       instance = (CapabilitiesHandler) klass.newInstance();
-    }
-    catch (InstantiationException | IllegalAccessException e) {
-      throw new RuntimeException("Couldn't instantiate CapabilitiesHandler " +
-	klass.getSimpleName(),
-	e);
-    }
-
-    // Test the instance
-    return isMetBy(instance);
-  }
-
-  /**
-   * Creates a requirement which is the logical OR of this and the given
-   * requirement.
-   *
-   * @param other	The other operand to the OR.
-   * @return		The resulting requirement.
-   */
-  public CapabilityRequirement or(CapabilityRequirement other) {
-    return new CapabilityRequirement(this.m_Test.or(other.m_Test));
-  }
-
-  /**
-   * Creates a requirement that a given set of capabilities have all of the
-   * specified capabilities.
-   *
-   * @param capabilities	The capabilities that a tested set must have.
-   * @return			The requirement.
-   */
-  public static CapabilityRequirement hasAll(Capability... capabilities) {
-    return new CapabilityRequirement(c -> {
-      for (Capability capability : capabilities) {
-        if (!c.hasCapability(capability))
-          return false;
-      }
-      return true;
-    });
-  }
-
-  /**
-   * Creates a requirement that a given set of capabilities have at least on
-   * of the specified capabilities.
-   *
-   * @param capabilities	The capabilities that a tested set must have
-   *                            at least one of.
-   * @return			The requirement.
-   */
-  public static CapabilityRequirement hasAny(Capability... capabilities) {
-    return new CapabilityRequirement(c -> {
-      for (Capability capability : capabilities) {
-	if (c.hasCapability(capability))
-	  return true;
-      }
-      return false;
-    });
-  }
-
-  /**
-   * Creates a requirement that a given set of capabilities must have the
-   * given capability.
-   *
-   * @param capability	The capability a tested set must have.
-   * @return		The requirement.
-   */
-  public static CapabilityRequirement has(Capability capability) {
-    return new CapabilityRequirement(c -> c.hasCapability(capability));
-  }
+public class CapabilityRequirement {
+
+	/**
+	 * The capabilities to assume a class has if it does not implement the
+	 * CapabilitiesHandler interface.
+	 */
+	public static final ImmutableCapabilities NON_HANDLER_CAPABILITIES = new ImmutableCapabilities(
+			Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+
+	/** The function to use to test if the requirement is met. */
+	private Predicate<Capabilities> m_Test;
+
+	/**
+	 * Creates a capabilities requirement with the given predicate as its method of
+	 * checking if the requirement is met.
+	 *
+	 * @param check The test for adherence.
+	 */
+	public CapabilityRequirement(Predicate<Capabilities> check) {
+		// Can't create a null test
+		if (check == null)
+			throw new IllegalArgumentException("Capability requirement cannot be null");
+
+		m_Test = check;
+	}
+
+	/**
+	 * Tests if the requirement is met by the given set of capabilities.
+	 *
+	 * @param capabilities The set of capabilities to test.
+	 * @return True if the requirement is met, false if not.
+	 */
+	public boolean isMetBy(Capabilities capabilities) {
+		return m_Test.test(capabilities);
+	}
+
+	/**
+	 * Tests if the requirement is met by the given capabilities handler.
+	 *
+	 * @param handler The handler to test.
+	 * @return True if the handler meets the requirements, false if not.
+	 */
+	public boolean isMetBy(CapabilitiesHandler handler) {
+		return isMetBy(handler.getCapabilities());
+	}
+
+	/**
+	 * Tests if the requirement is met by the given class.
+	 *
+	 * @param klass The class to test.
+	 * @return True if the class meets the requirements, false if not.
+	 */
+	public boolean isMetBy(Class<?> klass) {
+		// Classes which aren't capabilities handlers have an assumed
+		// set of capabilities
+		if (!CapabilitiesHandler.class.isAssignableFrom(klass))
+			return isMetBy(NON_HANDLER_CAPABILITIES);
+
+		// Attempt to instantiate an instance of the class
+		CapabilitiesHandler instance;
+		try {
+			instance = (CapabilitiesHandler) klass.newInstance();
+		} catch (InstantiationException | IllegalAccessException e) {
+			throw new RuntimeException("Couldn't instantiate CapabilitiesHandler " + klass.getSimpleName(), e);
+		}
+
+		// Test the instance
+		return isMetBy(instance);
+	}
+
+	/**
+	 * Creates a requirement which is the logical OR of this and the given
+	 * requirement.
+	 *
+	 * @param other The other operand to the OR.
+	 * @return The resulting requirement.
+	 */
+	public CapabilityRequirement or(CapabilityRequirement other) {
+		return new CapabilityRequirement(this.m_Test.or(other.m_Test));
+	}
+
+	/**
+	 * Creates a requirement that a given set of capabilities have all of the
+	 * specified capabilities.
+	 *
+	 * @param capabilities The capabilities that a tested set must have.
+	 * @return The requirement.
+	 */
+	public static CapabilityRequirement hasAll(Capability... capabilities) {
+		return new CapabilityRequirement(c -> {
+			for (Capability capability : capabilities) {
+				if (!c.hasCapability(capability))
+					return false;
+			}
+			return true;
+		});
+	}
+
+	/**
+	 * Creates a requirement that a given set of capabilities have at least on of
+	 * the specified capabilities.
+	 *
+	 * @param capabilities The capabilities that a tested set must have at least one
+	 *                     of.
+	 * @return The requirement.
+	 */
+	public static CapabilityRequirement hasAny(Capability... capabilities) {
+		return new CapabilityRequirement(c -> {
+			for (Capability capability : capabilities) {
+				if (c.hasCapability(capability))
+					return true;
+			}
+			return false;
+		});
+	}
+
+	/**
+	 * Creates a requirement that a given set of capabilities must have the given
+	 * capability.
+	 *
+	 * @param capability The capability a tested set must have.
+	 * @return The requirement.
+	 */
+	public static CapabilityRequirement has(Capability capability) {
+		return new CapabilityRequirement(c -> c.hasCapability(capability));
+	}
 }
diff --git a/moa/src/main/java/moa/capabilities/ImmutableCapabilities.java b/moa/src/main/java/moa/capabilities/ImmutableCapabilities.java
index 2b58165e8..d799c5f91 100644
--- a/moa/src/main/java/moa/capabilities/ImmutableCapabilities.java
+++ b/moa/src/main/java/moa/capabilities/ImmutableCapabilities.java
@@ -22,11 +22,8 @@
 
 import java.util.Arrays;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.Map;
-import java.util.Set;
 import java.util.WeakHashMap;
 
 /**
@@ -36,103 +33,101 @@
  */
 public final class ImmutableCapabilities extends Capabilities {
 
-  /**
-   * Creates an immutable set of capabilities.
-   *
-   * @param capabilities  The final set of capabilities the object will contain.
-   */
-  public ImmutableCapabilities(Capability... capabilities) {
-    m_Capabilities.addAll(Arrays.asList(capabilities));
-  }
-
-  @Override
-  public final void addCapabilities(Capability... capabilities) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public final void addCapabilities(Collection<Capability> capabilities) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public void addCapabilities(Capabilities other) {
-    throw new UnsupportedOperationException();
-  }
-
-  @Override
-  public final void addCapability(Capability capability) {
-    throw new UnsupportedOperationException();
-  }
-
-  /**
-   * Static class containing a lookup of immutable capabilities objects. This allows
-   * CapabilitiesHandlers that have identical sets of capabilities to share a single
-   * unique set, rather than having one each.
-   */
-  static class StaticLookup {
-
-    /** The set of unique immutable capabilities objects. */
-    private static Map<ImmutableCapabilities, ImmutableCapabilities> m_UniqueSet = new HashMap<>();
-
-    /** The mapping from handlers to their canonical set of capabilities. */
-    private static Map<CapabilitiesHandler, ImmutableCapabilities> m_Lookup = new WeakHashMap<>();
-
-    /**
-     * Whether the given capabilities handler has defined an
-     * immutable set of capabilities.
-     *
-     * @param owner   The handler in question.
-     * @return        True if it has specified its capabilities,
-     *                false if not.
-     */
-    public static boolean isDefined(CapabilitiesHandler owner) {
-      // Can't check a null owner
-      if (owner == null)
-        throw new IllegalArgumentException("Null is not a valid capabilities handler.");
-
-      return m_Lookup.containsKey(owner);
-    }
-
-    /**
-     * Defines the given handler as having the given immutable set of capabilities.
-     *
-     * @param owner         The handler.
-     * @param capabilities  The set of capabilities.
-     */
-    public static void define(CapabilitiesHandler owner,
-                              ImmutableCapabilities capabilities) {
-      // Can't redefine a handler's capabilities
-      if (isDefined(owner))
-        throw new IllegalArgumentException("Illegal attempt to redefine capabilities.");
-
-      // If given null, interpret as the empty set
-      if (capabilities == null)
-        capabilities = new ImmutableCapabilities();
-
-      // Substitute the canonical object, or make canonical
-      if (m_UniqueSet.containsKey(capabilities))
-        capabilities = m_UniqueSet.get(capabilities);
-      else
-        m_UniqueSet.put(capabilities, capabilities);
-
-      // Save the mapping from owner to capabilities
-      m_Lookup.put(owner, capabilities);
-    }
-
-    /**
-     * Get the stored capabilities of the given handler.
-     *
-     * @param owner   The capabilities handler.
-     * @return        The capabilities of that handler.
-     */
-    public static ImmutableCapabilities get(CapabilitiesHandler owner) {
-      // Owner must be defined before being accessed
-      if (!isDefined(owner))
-        throw new IllegalArgumentException("Illegal attempt to get capabilities for undefined owner.");
-
-      return m_Lookup.get(owner);
-    }
-  }
+	/**
+	 * Creates an immutable set of capabilities.
+	 *
+	 * @param capabilities The final set of capabilities the object will contain.
+	 */
+	public ImmutableCapabilities(Capability... capabilities) {
+		m_Capabilities.addAll(Arrays.asList(capabilities));
+	}
+
+	@Override
+	public void addCapabilities(Capability... capabilities) {
+		throw new UnsupportedOperationException();
+	}
+
+	@Override
+	public void addCapabilities(Collection<Capability> capabilities) {
+		throw new UnsupportedOperationException();
+	}
+
+	@Override
+	public void addCapabilities(Capabilities other) {
+		throw new UnsupportedOperationException();
+	}
+
+	@Override
+	public void addCapability(Capability capability) {
+		throw new UnsupportedOperationException();
+	}
+
+	/**
+	 * Static class containing a lookup of immutable capabilities objects. This
+	 * allows CapabilitiesHandlers that have identical sets of capabilities to share
+	 * a single unique set, rather than having one each.
+	 */
+	static class StaticLookup {
+
+		/** The set of unique immutable capabilities objects. */
+		private static Map<ImmutableCapabilities, ImmutableCapabilities> m_UniqueSet = new HashMap<>();
+
+		/** The mapping from handlers to their canonical set of capabilities. */
+		private static Map<CapabilitiesHandler, ImmutableCapabilities> m_Lookup = new WeakHashMap<>();
+
+		/**
+		 * Whether the given capabilities handler has defined an immutable set of
+		 * capabilities.
+		 *
+		 * @param owner The handler in question.
+		 * @return True if it has specified its capabilities, false if not.
+		 */
+		public static boolean isDefined(CapabilitiesHandler owner) {
+			// Can't check a null owner
+			if (owner == null)
+				throw new IllegalArgumentException("Null is not a valid capabilities handler.");
+
+			return m_Lookup.containsKey(owner);
+		}
+
+		/**
+		 * Defines the given handler as having the given immutable set of capabilities.
+		 *
+		 * @param owner        The handler.
+		 * @param capabilities The set of capabilities.
+		 */
+		public static void define(CapabilitiesHandler owner, ImmutableCapabilities capabilities) {
+			// Can't redefine a handler's capabilities
+			if (isDefined(owner))
+				throw new IllegalArgumentException("Illegal attempt to redefine capabilities.");
+
+			// If given null, interpret as the empty set
+			if (capabilities == null)
+				capabilities = new ImmutableCapabilities();
+
+			// Substitute the canonical object, or make canonical
+			if (m_UniqueSet.containsKey(capabilities))
+				capabilities = m_UniqueSet.get(capabilities);
+			else
+				m_UniqueSet.put(capabilities, capabilities);
+
+			// Save the mapping from owner to capabilities
+			m_Lookup.put(owner, capabilities);
+		}
+
+		/**
+		 * Get the stored capabilities of the given handler.
+		 *
+		 * @param owner The capabilities handler.
+		 * @return The capabilities of that handler.
+		 */
+		public static ImmutableCapabilities get(CapabilitiesHandler owner) {
+			// Owner must be defined before being accessed
+			if (!isDefined(owner))
+				throw new IllegalArgumentException("Illegal attempt to get capabilities for undefined owner.");
+
+			return m_Lookup.get(owner);
+		}
+	}
 
 }
diff --git a/moa/src/main/java/moa/classifiers/AbstractClassifier.java b/moa/src/main/java/moa/classifiers/AbstractClassifier.java
deleted file mode 100644
index 048d3347b..000000000
--- a/moa/src/main/java/moa/classifiers/AbstractClassifier.java
+++ /dev/null
@@ -1,280 +0,0 @@
-package moa.classifiers;
-
-import moa.learners.Classifier;
-
-import java.util.Arrays;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Random;
-
-import moa.MOAObject;
-import moa.capabilities.CapabilitiesHandler;
-import moa.capabilities.Capability;
-import moa.capabilities.ImmutableCapabilities;
-import moa.core.Example;
-
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
-import moa.core.Measurement;
-import moa.core.ObjectRepository;
-import moa.core.StringUtils;
-import moa.gui.AWTRenderer;
-import moa.options.AbstractOptionHandler;
-
-import com.github.javacliparser.IntOption;
-
-import moa.tasks.TaskMonitor;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.core.Utils;
-
-public abstract class AbstractClassifier extends AbstractInstanceLearner<Classifier> implements Classifier, CapabilitiesHandler {
-
-    @Override
-    public String getPurposeString() {
-        return "MOA Classifier: " + getClass().getCanonicalName();
-    }
-
-    /** Header of the instances of the data stream */
-    protected InstancesHeader modelContext;
-
-    /** Sum of the weights of the instances trained by this model */
-    protected double trainingWeightSeenByModel = 0.0;
-
-    /** Random seed used in randomizable learners */
-    protected int randomSeed = 1;
-
-    /** Option for randomizable learners to change the random seed */
-    protected IntOption randomSeedOption;
-
-    /** Random Generator used in randomizable learners  */
-    public Random classifierRandom;
-
-    /**
-     * Creates an classifier and setups the random seed option
-     * if the classifier is randomizable.
-     */
-    public AbstractClassifier() {
-        super(Classifier.class);
-    }
-
-    @Override
-    public void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        if (this.randomSeedOption != null) {
-            this.randomSeed = this.randomSeedOption.getValue();
-        }
-        if (!trainingHasStarted()) {
-            resetLearning();
-        }
-    }
-
-    @Override
-    public void setModelContext(InstancesHeader ih) {
-        if ((ih != null) && (ih.classIndex() < 0)) {
-            throw new IllegalArgumentException(
-                    "Context for a classifier must include a class to learn");
-        }
-        if (trainingHasStarted()
-                && (this.modelContext != null)
-                && ((ih == null) || !contextIsCompatible(this.modelContext, ih))) {
-            throw new IllegalArgumentException(
-                    "New context is not compatible with existing model");
-        }
-        this.modelContext = ih;
-    }
-
-
-    @Override
-    public boolean correctlyClassifies(Instance inst) {
-        return Utils.maxIndex(getPredictionForInstance(inst).asDoubleArray()) == (int) inst.classValue();
-    }
-
-    /**
-     * Gets the name of the attribute of the class from the header.
-     *
-     * @return the string with name of the attribute of the class
-     */
-    public String getClassNameString() {
-        return InstancesHeader.getClassNameString(this.modelContext);
-    }
-
-    /**
-     * Gets the name of a label of the class from the header.
-     *
-     * @param classLabelIndex the label index
-     * @return the name of the label of the class
-     */
-    public String getClassLabelString(int classLabelIndex) {
-        return InstancesHeader.getClassLabelString(this.modelContext,
-                classLabelIndex);
-    }
-
-    /**
-     * Gets the name of an attribute from the header.
-     *
-     * @param attIndex the attribute index
-     * @return the name of the attribute
-     */
-    public String getAttributeNameString(int attIndex) {
-        return InstancesHeader.getAttributeNameString(this.modelContext,
-                attIndex);
-    }
-
-    /**
-     * Gets the name of a value of an attribute from the header.
-     *
-     * @param attIndex the attribute index
-     * @param valIndex the value of the attribute
-     * @return the name of the value of the attribute
-     */
-    public String getNominalValueString(int attIndex, int valIndex) {
-        return InstancesHeader.getNominalValueString(this.modelContext,
-                attIndex, valIndex);
-    }
-
-
-    /**
-     * Returns if two contexts or headers of instances are compatible.<br><br>
-     *
-     * Two contexts are compatible if they follow the following rules:<br>
-     * Rule 1: num classes can increase but never decrease<br>
-     * Rule 2: num attributes can increase but never decrease<br>
-     * Rule 3: num nominal attribute values can increase but never decrease<br>
-     * Rule 4: attribute types must stay in the same order (although class
-     * can move; is always skipped over)<br><br>
-     *
-     * Attribute names are free to change, but should always still represent
-     * the original attributes.
-     *
-     * @param originalContext the first context to compare
-     * @param newContext the second context to compare
-     * @return true if the two contexts are compatible.
-     */
-    public static boolean contextIsCompatible(InstancesHeader originalContext,
-            InstancesHeader newContext) {
-
-        if (newContext.numClasses() < originalContext.numClasses()) {
-            return false; // rule 1
-        }
-        if (newContext.numAttributes() < originalContext.numAttributes()) {
-            return false; // rule 2
-        }
-        int oPos = 0;
-        int nPos = 0;
-        while (oPos < originalContext.numAttributes()) {
-            if (oPos == originalContext.classIndex()) {
-                oPos++;
-                if (!(oPos < originalContext.numAttributes())) {
-                    break;
-                }
-            }
-            if (nPos == newContext.classIndex()) {
-                nPos++;
-            }
-            if (originalContext.attribute(oPos).isNominal()) {
-                if (!newContext.attribute(nPos).isNominal()) {
-                    return false; // rule 4
-                }
-                if (newContext.attribute(nPos).numValues() < originalContext.attribute(oPos).numValues()) {
-                    return false; // rule 3
-                }
-            } else {
-                assert (originalContext.attribute(oPos).isNumeric());
-                if (!newContext.attribute(nPos).isNumeric()) {
-                    return false; // rule 4
-                }
-            }
-            oPos++;
-            nPos++;
-        }
-        return true; // all checks clear
-    }
-
-    /**
-     * Returns the AWT Renderer
-     *
-     * @return the AWT Renderer
-     */
-    @Override
-    public AWTRenderer getAWTRenderer() {
-        // TODO should return a default renderer here
-        // - or should null be interpreted as the default?
-        return null;
-    }
-
-
-    /**
-     * Resets this classifier. It must be similar to
-     * starting a new classifier from scratch. <br><br>
-     * 
-     * The reason for ...Impl methods: ease programmer burden by not requiring 
-     * them to remember calls to super in overridden methods. 
-     * Note that this will produce compiler errors if not overridden.
-     */
-    public abstract void resetLearningImpl();
-
-    /**
-     * Trains this classifier incrementally using the given instance.<br><br>
-     * 
-     * The reason for ...Impl methods: ease programmer burden by not requiring 
-     * them to remember calls to super in overridden methods. 
-     * Note that this will produce compiler errors if not overridden.
-     *
-     * @param inst the instance to be used for training
-     */
-    public abstract void trainOnInstanceImpl(Instance inst);
-
-    /**
-     * Gets the current measurements of this classifier.<br><br>
-     * 
-     * The reason for ...Impl methods: ease programmer burden by not requiring 
-     * them to remember calls to super in overridden methods. 
-     * Note that this will produce compiler errors if not overridden.
-     *
-     * @return an array of measurements to be used in evaluation tasks
-     */
-    protected abstract Measurement[] getModelMeasurementsImpl();
-
-    /**
-     * Returns a string representation of the model.
-     *
-     * @param out	the stringbuilder to add the description
-     * @param indent	the number of characters to indent
-     */
-    public abstract void getModelDescription(StringBuilder out, int indent);
-
-    /**
-     * Gets the index of the attribute in the instance,
-     * given the index of the attribute in the learner.
-     *
-     * @param index the index of the attribute in the learner
-     * @param inst the instance
-     * @return the index in the instance
-     */
-    protected static int modelAttIndexToInstanceAttIndex(int index,
-            Instance inst) {
-        return inst.classIndex() > index ? index : index + 1;
-    }
-
-    /**
-     * Gets the index of the attribute in a set of instances,
-     * given the index of the attribute in the learner.
-     * 
-     * @param index the index of the attribute in the learner
-     * @param insts the instances
-     * @return the index of the attribute in the instances
-     */
-    protected static int modelAttIndexToInstanceAttIndex(int index,
-            InstancesHeader insts) {
-        return insts.classIndex() > index ? index : index + 1;
-    }
-
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        // We are restricting classifiers based on view mode
-        return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/AbstractEnsembleLearner.java b/moa/src/main/java/moa/classifiers/AbstractEnsembleLearner.java
deleted file mode 100644
index d69e565f4..000000000
--- a/moa/src/main/java/moa/classifiers/AbstractEnsembleLearner.java
+++ /dev/null
@@ -1,96 +0,0 @@
-package moa.classifiers;
-
-import java.util.ArrayList;
-
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.core.Measurement;
-import moa.learners.InstanceLearner;
-import moa.options.ClassOption;
-
-public abstract class AbstractEnsembleLearner<MLTask extends InstanceLearner> extends AbstractInstanceLearner<MLTask> {
-
-	private static final long serialVersionUID = 1L;
-
-	public ClassOption baseLearnerOption;
-
-    public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's',
-            "The number of models in the ensemble.", 10, 1, Integer.MAX_VALUE);
-    
-    public ArrayList<MLTask> ensemble;
-
-    public AbstractEnsembleLearner(Class<MLTask> task) {
-    	super(task);
-    }
-    
-    public long measureByteSize() {
-    	long size = 0;
-    	for (MLTask c : ensemble) 
-    		size += c.measureByteSize();
-    	return size;
-    }
-
-    @SuppressWarnings("unchecked")
-	@Override
-    public void resetLearningImpl() {
-        this.ensemble = new ArrayList<>(this.ensembleSizeOption.getValue());
-        MLTask baseLearner = (MLTask) getPreparedClassOption(baseLearnerOption);
-        for (int i = 0; i < this.ensembleSizeOption.getValue(); i++) {
-        	MLTask learner = (MLTask) baseLearner.copy();
-        	learner.prepareForUse();
-            this.ensemble.add(learner);
-        }
-        this.setRandomSeed(randomSeed);
-    }
-   
-    public void setRandomSeed(int seed) {
-    	super.setRandomSeed(seed);
-    	if (this.ensemble != null) 
-    		for (int i = 0; i < this.ensembleSizeOption.getValue(); i++) {
-    			if (this.ensemble.get(i) != null)
-    				this.ensemble.get(i).setRandomSeed(this.randomSeed + i + 1);
-    		}	
-    }
-    
-	public abstract Prediction combinePredictions(Prediction[] predictions);
-	
-	public Prediction getPredictionForInstance(Instance inst) {
-		Prediction[] predictions = new Prediction[this.ensemble.size()];
-		for (int i = 0; i < this.ensemble.size(); i++) {
-			predictions[i] = this.ensemble.get(i).getPredictionForInstance(inst);
-		}
-		return combinePredictions(predictions);
-	}
-
-	public Prediction getPredictionForInstanceUsingN(Instance inst, int n) {
-		Prediction[] predictions = new Prediction[this.ensemble.size()];
-		for (int i = 0; i < n; i++) {
-			predictions[i] = this.ensemble.get(i).getPredictionForInstance(inst);
-		}
-		return combinePredictions(predictions);
-	}
-	
-    @Override    
-    public void modelContextSet() {
-        for (int i = 0; i < this.ensemble.size(); i++) {
-            this.ensemble.get(i).setModelContext(this.getModelContext());;
-        }
-    }
-    
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return new Measurement[]{new Measurement("ensemble size",
-                    this.ensemble != null ? this.ensemble.size() : 0)};
-    }
-    
-    @Override
-	public MLTask[] getSublearners() {
-        MLTask[] out = ((MLTask[])java.lang.reflect.Array.newInstance(TaskClass, this.ensemble.size()));
-        for (int i = 0; i < this.ensemble.size(); i++) {
-        	out[i] = this.ensemble.get(i);
-        }
-        return out;
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/AbstractInstanceLearner.java b/moa/src/main/java/moa/classifiers/AbstractInstanceLearner.java
deleted file mode 100644
index 248f90746..000000000
--- a/moa/src/main/java/moa/classifiers/AbstractInstanceLearner.java
+++ /dev/null
@@ -1,397 +0,0 @@
-/*
- *    AbstractClassifier.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-
-package moa.classifiers;
-
-import java.util.Arrays;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Random;
-
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.MOAObject;
-import moa.core.Example;
-import moa.core.Measurement;
-import moa.core.ObjectRepository;
-import moa.core.StringUtils;
-import moa.core.Utils;
-import moa.gui.AWTRenderer;
-import moa.learners.InstanceLearner;
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
-public abstract class AbstractInstanceLearner<MLTask extends InstanceLearner> extends AbstractOptionHandler implements InstanceLearner {
-
-	private static final long serialVersionUID = 1L;
-
-	@Override
-    public String getPurposeString() {
-        return "MOA Classifier: " + getClass().getCanonicalName();
-    }
-
-    /** Header of the instances of the data stream */
-    protected InstancesHeader modelContext;
-
-	protected Class<MLTask> TaskClass;
-    
-    /** Sum of the weights of the instances trained by this model */
-    protected double trainingWeightSeenByModel = 0.0;
-
-    /** Random seed used in randomizable learners */
-    public int randomSeed = 1;
-
-    /** Option for randomizable learners to change the random seed */
-    public IntOption randomSeedOption;
-
-    /** Random Generator used in randomizable learners  */
-    public Random classifierRandom;
-
-    /**
-     * Creates an classifier and setups the random seed option
-     * if the classifier is randomizable.
-     */
-    @SuppressWarnings("unchecked")
-	public AbstractInstanceLearner(Class<MLTask> task) {
-    	TaskClass = task;
-        if (isRandomizable()) {
-        	this.randomSeedOption = new IntOption("randomSeed", 'r', "Seed for random behaviour of the classifier.", 1);
-        }
-    }
-
-    @Override
-    public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-        if (this.randomSeedOption != null) {
-            this.randomSeed = this.randomSeedOption.getValue();
-        }
-        
-        // resetLearning should not be called if the classifier has not yet received the context
-        if (!trainingHasStarted()) {
-            resetLearning();
-        }
-    }
-
-	public abstract Prediction getPredictionForInstance(Instance instance);
-    
-    @Override
-    public Prediction getPredictionForInstance(Example<Instance> example){
-		return getPredictionForInstance(example.getData());
-	}
-
-    @Override
-    public void setModelContext(InstancesHeader ih) {
-        if ((ih != null) && (ih.numOutputAttributes() < 1)) {
-            throw new IllegalArgumentException(
-                    "Context for a classifier must include a class to learn");
-        }
-        if (trainingHasStarted()
-                && (this.modelContext != null)
-                && ((ih == null) || !contextIsCompatible(this.modelContext, ih))) {
-            throw new IllegalArgumentException(
-                    "New context is not compatible with existing model");
-        }
-        this.modelContext = ih;
-        this.modelContextSet();
-    }
-    
-    public void modelContextSet() {
-    }
-
-    @Override
-    public InstancesHeader getModelContext() {
-        return this.modelContext;
-    }
-
-    @Override
-    public void setRandomSeed(int s) {
-        this.randomSeed = s;
-        if (this.randomSeedOption != null) {
-            // keep option consistent
-            this.randomSeedOption.setValue(s);
-        }
-    }
-
-    @Override
-    public int getRandomSeed() {
-    	return this.randomSeed;
-    }
-    
-    @Override
-    public boolean trainingHasStarted() {
-        return this.trainingWeightSeenByModel > 0.0;
-    }
-
-    @Override
-    public double trainingWeightSeenByModel() {
-        return this.trainingWeightSeenByModel;
-    }
-
-    @Override
-    public void resetLearning() {
-        this.trainingWeightSeenByModel = 0.0;
-        if (isRandomizable()) {
-            this.classifierRandom = new Random(this.randomSeed);
-        }
-        resetLearningImpl();
-    }
-
-    public void trainOnInstance(Instance inst) {
-        boolean isTraining = (inst.weight() > 0.0);
-        if (!(this instanceof SemiSupervisedLearner) && inst.missingOutputs()) {
-            isTraining = false;
-        }
-        if (isTraining) {
-            this.trainingWeightSeenByModel += inst.weight();
-            trainOnInstanceImpl(inst);
-        }
-    }
-    
-    public abstract void trainOnInstanceImpl(Instance inst);
-    
-    @Override
-    public Measurement[] getModelMeasurements() {
-        List<Measurement> measurementList = new LinkedList<Measurement>();
-        measurementList.add(new Measurement("model training instances",
-                trainingWeightSeenByModel()));
-        measurementList.add(new Measurement("model serialized size (bytes)",
-                measureByteSize()));
-        Measurement[] modelMeasurements = getModelMeasurementsImpl();
-        if (modelMeasurements != null) {
-            measurementList.addAll(Arrays.asList(modelMeasurements));
-        }
-        // add average of sub-model measurements
-        InstanceLearner[] subModels = getSublearners();
-        if ((subModels != null) && (subModels.length > 0)) {
-            List<Measurement[]> subMeasurements = new LinkedList<Measurement[]>();
-            for (InstanceLearner subModel : subModels) {
-                if (subModel != null) {
-                    subMeasurements.add(subModel.getModelMeasurements());
-                }
-            }
-            Measurement[] avgMeasurements = Measurement.averageMeasurements(subMeasurements.toArray(new Measurement[subMeasurements.size()][]));
-            measurementList.addAll(Arrays.asList(avgMeasurements));
-        }
-        return measurementList.toArray(new Measurement[measurementList.size()]);
-    }
-
-    @Override
-    public void getDescription(StringBuilder out, int indent) {
-        StringUtils.appendIndented(out, indent, "Model type: ");
-        out.append(this.getClass().getName());
-        StringUtils.appendNewline(out);
-        Measurement.getMeasurementsDescription(getModelMeasurements(), out,
-                indent);
-        StringUtils.appendNewlineIndented(out, indent, "Model description:");
-        StringUtils.appendNewline(out);
-        if (trainingHasStarted()) {
-            getModelDescription(out, indent);
-        } else {
-            StringUtils.appendIndented(out, indent,
-                    "Model has not been trained.");
-        }
-    }
-
-    @Override
-    public InstanceLearner[] getSublearners() {
-        return getSubClassifiers();
-    }
-    
-    public MLTask[] getSubClassifiers() {
-    	return null;
-    }
-    
-    
-    
-	public InstanceLearner copy() {
-        return (InstanceLearner) super.copy();
-    }
-
-   
-    @Override
-    public MOAObject getModel(){
-        return this;
-    };
-    
-    @Override
-    public void trainOnInstance(Example<Instance> example){
-		trainOnInstance(example.getData());
-	}
-
-    /**
-     * Gets the name of the attribute of the class from the header.
-     *
-     * @return the string with name of the attribute of the class
-     */
-    public String getClassNameString() {
-        return InstancesHeader.getClassNameString(this.modelContext);
-    }
-
-    /**
-     * Gets the name of a label of the class from the header.
-     *
-     * @param classLabelIndex the label index
-     * @return the name of the label of the class
-     */
-    public String getClassLabelString(int classLabelIndex) {
-        return InstancesHeader.getClassLabelString(this.modelContext,
-                classLabelIndex);
-    }
-
-    /**
-     * Gets the name of an attribute from the header.
-     *
-     * @param attIndex the attribute index
-     * @return the name of the attribute
-     */
-    public String getAttributeNameString(int attIndex) {
-        return InstancesHeader.getAttributeNameString(this.modelContext,
-                attIndex);
-    }
-
-    /**
-     * Gets the name of a value of an attribute from the header.
-     *
-     * @param attIndex the attribute index
-     * @param valIndex the value of the attribute
-     * @return the name of the value of the attribute
-     */
-    public String getNominalValueString(int attIndex, int valIndex) {
-        return InstancesHeader.getNominalValueString(this.modelContext,
-                attIndex, valIndex);
-    }
-
-
-    /**
-     * Returns if two contexts or headers of instances are compatible.<br><br>
-     *
-     * Two contexts are compatible if they follow the following rules:<br>
-     * Rule 1: num classes can increase but never decrease<br>
-     * Rule 2: num attributes can increase but never decrease<br>
-     * Rule 3: num nominal attribute values can increase but never decrease<br>
-     * Rule 4: attribute types must stay in the same order (although class
-     * can move; is always skipped over)<br><br>
-     *
-     * Attribute names are free to change, but should always still represent
-     * the original attributes.
-     *
-     * @param originalContext the first context to compare
-     * @param newContext the second context to compare
-     * @return true if the two contexts are compatible.
-     */
-    public static boolean contextIsCompatible(InstancesHeader originalContext,
-            InstancesHeader newContext) {
-		if (newContext.numInputAttributes() < originalContext.numInputAttributes()) {
-			return false; // rule 2
-		}
-		if (newContext.numOutputAttributes() < originalContext.numOutputAttributes()) {
-			return false; // rule 2
-		}
-    	for (int i = 0; i < originalContext.numOutputAttributes(); i++) {
-    		if (originalContext.inputAttribute(i).attributeType() != newContext.inputAttribute(i).attributeType()) {
-                return false; // rule 4
-            }
-    		if (newContext.outputAttribute(i).numValues() < originalContext.outputAttribute(i).numValues()) {
-    			return false; // rule 1
-    		}
-    	}
-        // Input attributes
-        for (int i = 0; i < originalContext.numInputAttributes(); i++) {
-            if (originalContext.inputAttribute(i).attributeType() != newContext.inputAttribute(i).attributeType()) {
-                return false; // rule 4
-            }
-            else if (originalContext.inputAttribute(i).isNumeric()) {
-                if (newContext.inputAttribute(i).numValues() < originalContext.inputAttribute(i).numValues()) {
-                    return false; // rule 3
-                }
-            }
-        }
-        return true; // all checks clear
-    }
-
-    /**
-     * Returns the AWT Renderer
-     *
-     * @return the AWT Renderer
-     */
-    @Override
-    public AWTRenderer getAWTRenderer() {
-        // TODO should return a default renderer here
-        // - or should null be interpreted as the default?
-        return null;
-    }
-
-
-    /**
-     * Resets this classifier. It must be similar to
-     * starting a new classifier from scratch. <br><br>
-     * 
-     * The reason for ...Impl methods: ease programmer burden by not requiring 
-     * them to remember calls to super in overridden methods. 
-     * Note that this will produce compiler errors if not overridden.
-     */
-    public abstract void resetLearningImpl();
-
-    /**
-     * Gets the current measurements of this classifier.<br><br>
-     * 
-     * The reason for ...Impl methods: ease programmer burden by not requiring 
-     * them to remember calls to super in overridden methods. 
-     * Note that this will produce compiler errors if not overridden.
-     *
-     * @return an array of measurements to be used in evaluation MLTasks
-     */
-    protected abstract Measurement[] getModelMeasurementsImpl();
-
-    /**
-     * Gets the index of the attribute in the instance,
-     * given the index of the attribute in the learner.I
-     *
-     * @param index the index of the attribute in the learner
-     * @param inst the instance
-     * @return the index in the instance
-     */
-    protected static int modelAttIndexToInstanceAttIndex(int index,
-            Instance inst) {
-        return inst.classIndex() > index ? index : index + 1;
-    }
-
-    /**
-     * Gets the index of the attribute in a set of instances,
-     * given the index of the attribute in the learner.
-     * 
-     * @param index the index of the attribute in the learner
-     * @param insts the instances
-     * @return the index of the attribute in the instances
-     */
-    protected static int modelAttIndexToInstanceAttIndex(int index,
-            InstancesHeader insts) {
-        return insts.classIndex() > index ? index : index + 1;
-    }
-
-    public boolean correctlyClassifies(Instance inst) {
-    	// This is included here for ease of use. It should only be used by classifiers.
-        return Utils.maxIndex(getPredictionForInstance(inst)) == (int) inst.classValue();
-    }
-
-	
-}
diff --git a/moa/src/main/java/moa/classifiers/MultiTargetLearnerSemiSupervised.java b/moa/src/main/java/moa/classifiers/MultiTargetLearnerSemiSupervised.java
deleted file mode 100644
index abb43ac29..000000000
--- a/moa/src/main/java/moa/classifiers/MultiTargetLearnerSemiSupervised.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- *    MultiTargetLearnerSemiSupervised.java
- *    Copyright (C) 2017 University of Porto, Portugal
- *    @author R. Sousa, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-package moa.classifiers;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.learners.MultiLabelClassifier;
-
-/**
-* @author RSousa
-*/
-
-
-// TODO Split into SSL MTR and SSL MLC learners
-
-public interface MultiTargetLearnerSemiSupervised extends MultiLabelClassifier {
-    
-    public Prediction getTrainingPrediction();
-    
-    public void trainOnInstanceImpl(Instance instance);
-	
-    public Prediction getPredictionForInstance(Instance instance);
-}
diff --git a/moa/src/main/java/moa/classifiers/active/ALUncertainty.java b/moa/src/main/java/moa/classifiers/active/ALUncertainty.java
deleted file mode 100644
index cb49a424e..000000000
--- a/moa/src/main/java/moa/classifiers/active/ALUncertainty.java
+++ /dev/null
@@ -1,278 +0,0 @@
-/*
- *    ALUncertainty.java
- *    Copyright (C) 2011 University of Waikato, Hamilton, New Zealand
- *    @author Indre Zliobaite (zliobaite at gmail dot com)
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.active;
-
-import java.util.LinkedList;
-import java.util.List;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractClassifier;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.core.Utils;
-import moa.learners.Classifier;
-import moa.learners.InstanceLearner;
-import moa.options.ClassOption;
-
-/**
- * Active learning setting for evolving data streams.
- *
- * <p>Active learning focuses on learning an accurate model with as few labels
- * as possible. Streaming data poses additional challenges for active learning,
- * since the data distribution may change over time (concept drift) and
- * classifiers need to adapt. Conventional active learning strategies
- * concentrate on querying the most uncertain instances, which are typically
- * concentrated around the decision boundary. If changes do not occur close to
- * the boundary, they will be missed and classifiers will fail to adapt. This
- * class contains three active learning strategies for streaming data that
- * explicitly handle concept drift. They are based on fixed uncertainty,
- * dynamic allocation of labeling efforts over time and randomization of the
- * search space [ZBPH]. It also contains the Selective Sampling strategy, which
- * is adapted from [CGZ] and uses a variable labeling threshold.
- * </p>
- *
- * <p>[ZBPH] Indre Zliobaite, Albert Bifet, Bernhard Pfahringer, Geoff Holmes:
- * Active Learning with Evolving Streaming Data. ECML/PKDD (3) 2011: 597-612</p>
- *
- * <p>[CGZ] N. Cesa-Bianchi, C. Gentile, and L. Zaniboni. Worst-case analysis of
- * selective sampling for linear classification. J. Mach. Learn. Res. (7) 2006:
- * 1205-1230</p>.
- *
- * <p>Parameters:</p>
- * <ul>
- *   <li>-l : Classifier to train</li>
- *   <li>-d : Strategy to use: FixedUncertainty, VarUncertainty,
- *            RandVarUncertainty, SelSampling</li>
- *   <li>-b : Budget to use</li>
- *   <li>-u : Fixed threshold</li>
- *   <li>-s : Floating budget step</li>
- *   <li>-n : Number of instances at beginning without active learning</li>
- * </ul>
- *
- * <p>Structural changes to match active learning framework by Daniel Kottke.
- * </p>
- *
- * @author Indre Zliobaite (zliobaite at gmail dot com)
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @author Daniel Kottke (daniel dot kottke at ovgu dot de) - adapted to AL framework
- * @version $Revision: 7 $
- */
-public class ALUncertainty extends AbstractClassifier implements ALClassifier {
-
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public String getPurposeString() {
-        return "Active learning classifier for evolving data streams based on uncertainty";
-    }
-
-    public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l',
-            "Classifier to train.", Classifier.class, "moa.classifiers.drift.SingleClassifierDrift");
-
-    public MultiChoiceOption activeLearningStrategyOption = new MultiChoiceOption(
-            "activeLearningStrategy", 'd', "Active Learning Strategy to use.",
-            new String[]{
-                    "FixedUncertainty",
-                    "VarUncertainty",
-                    "RandVarUncertainty",
-                    "SelSampling"},
-            new String[]{
-                "Fixed uncertainty strategy",
-                "Uncertainty strategy with variable threshold",
-                "Uncertainty strategy with randomized variable threshold",
-                    "Selective Sampling"}, 
-            0);
-
-    public FloatOption budgetOption = new FloatOption("budget",
-            'b', "Budget to use.",
-            0.1, 0.0, 1.0);
-
-    public FloatOption fixedThresholdOption = new FloatOption("fixedThreshold",
-            'u', "Fixed threshold.",
-            0.9, 0.00, 1.00);
-
-    public FloatOption stepOption = new FloatOption("step",
-            's', "Floating budget step.",
-            0.01, 0.00, 1.00);
-
-    public FloatOption numInstancesInitOption = new FloatOption("numInstancesInit",
-            'n', "Number of instances at beginning without active learning.",
-            0.0, 0.00, Integer.MAX_VALUE);
-
-    public Classifier classifier;
-
-    public int lastLabelAcq = 0;
-
-    public int costLabeling;
-
-    public int iterationControl;
-
-    public double newThreshold;
-
-    public double maxPosterior;
-
-    public double accuracyBaseLearner;
-
-    private double outPosterior;
-
-    private double getMaxPosterior(double[] incomingPrediction) {
-        if (incomingPrediction.length > 1) {
-            DoubleVector vote = new DoubleVector(incomingPrediction);
-            if (vote.sumOfValues() > 0.0) {
-                vote.normalize();
-            }
-            incomingPrediction = vote.getArrayRef();
-            outPosterior = (incomingPrediction[Utils.maxIndex(incomingPrediction)]);
-        } else {
-            outPosterior = 0;
-        }
-        return outPosterior;
-    }
-
-    private void labelFixed(double incomingPosterior, Instance inst) {
-        if (incomingPosterior < this.fixedThresholdOption.getValue()) {
-            this.classifier.trainOnInstance(inst);
-            this.costLabeling++;
-            this.lastLabelAcq += 1;
-        }
-    }
-
-    private void labelVar(double incomingPosterior, Instance inst) {
-        if (incomingPosterior < this.newThreshold) {
-            this.classifier.trainOnInstance(inst);
-            this.costLabeling++;
-            this.lastLabelAcq += 1;
-            this.newThreshold *= (1 - this.stepOption.getValue());
-        } else {
-            this.newThreshold *= (1 + this.stepOption.getValue());
-        }
-    }
-
-    private void labelSelSampling(double incomingPosterior, Instance inst) {
-        double p = Math.abs(incomingPosterior - 1.0 / (inst.numClasses()));
-        double budget = this.budgetOption.getValue() / (this.budgetOption.getValue() + p);
-        if (this.classifierRandom.nextDouble() < budget) {
-            this.classifier.trainOnInstance(inst);
-            this.costLabeling++;
-            this.lastLabelAcq += 1;
-        }
-    }
-
-    @Override
-    public void resetLearningImpl() {
-        this.classifier = (Classifier) ((InstanceLearner) getPreparedClassOption(this.baseLearnerOption)).copy();
-        this.classifier.resetLearning();
-        this.costLabeling = 0;
-        this.iterationControl = 0;
-        this.newThreshold = 1.0;
-        this.accuracyBaseLearner = 0;
-        this.lastLabelAcq = 0;
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-
-        this.iterationControl++;
-
-        double costNow;
-
-        if (this.iterationControl <= this.numInstancesInitOption.getValue()) {
-            costNow = 0;
-            //Use all instances at the beginning
-            this.classifier.trainOnInstance(inst);
-	    this.costLabeling++;
-            return;
-        } else {
-            costNow = (this.costLabeling - this.numInstancesInitOption.getValue()) / ((double) this.iterationControl - this.numInstancesInitOption.getValue());
-        }
-
-        if (costNow < this.budgetOption.getValue()) { //allow to label
-            switch (this.activeLearningStrategyOption.getChosenIndex()) {
-                case 0: //Random
-                    maxPosterior = getMaxPosterior(this.classifier.getPredictionForInstance(inst).asDoubleArray());
-                    labelFixed(maxPosterior, inst);
-                    break;
-                case 1: //variable
-                    maxPosterior = getMaxPosterior(this.classifier.getPredictionForInstance(inst).asDoubleArray());
-                    labelVar(maxPosterior, inst);
-                    break;
-                case 2: //randomized
-                    maxPosterior = getMaxPosterior(this.classifier.getPredictionForInstance(inst).asDoubleArray());
-                    maxPosterior = maxPosterior / (this.classifierRandom.nextGaussian() + 1.0);
-                    labelVar(maxPosterior, inst);
-                    break;
-                case 3: //selective-sampling
-                    maxPosterior = getMaxPosterior(this.classifier.getPredictionForInstance(inst).asDoubleArray());
-                    labelSelSampling(maxPosterior, inst);
-                    break;
-            }
-        }
-    }
-
-    @Override
-    public Prediction getPredictionForInstance(Instance inst) {
-        return this.classifier.getPredictionForInstance(inst);
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return true;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        ((AbstractClassifier) this.classifier).getModelDescription(out, indent);
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        List<Measurement> measurementList = new LinkedList<Measurement>();
-        measurementList.add(new Measurement("labeling cost", this.costLabeling));
-        measurementList.add(new Measurement("newThreshold", this.newThreshold));
-        measurementList.add(new Measurement("maxPosterior", this.maxPosterior));
-        measurementList.add(new Measurement("accuracyBaseLearner (percent)", 100 * this.accuracyBaseLearner / this.costLabeling));
-        Measurement[] modelMeasurements = ((AbstractClassifier) this.classifier).getModelMeasurements();
-        if (modelMeasurements != null) {
-            for (Measurement measurement : modelMeasurements) {
-                measurementList.add(measurement);
-            }
-        }
-        return measurementList.toArray(new Measurement[measurementList.size()]);
-    }
-
-	@Override
-	public int getLastLabelAcqReport() {
-		int help = this.lastLabelAcq;
-		this.lastLabelAcq = 0;
-		return help; 
-	}
-	
-	@Override
-	public void setModelContext(InstancesHeader ih) {
-		super.setModelContext(ih);
-		classifier.setModelContext(ih);
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/bayes/NaiveBayes.java b/moa/src/main/java/moa/classifiers/bayes/NaiveBayes.java
deleted file mode 100644
index 0f19a7687..000000000
--- a/moa/src/main/java/moa/classifiers/bayes/NaiveBayes.java
+++ /dev/null
@@ -1,198 +0,0 @@
-/*
- *    NaiveBayes.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.bayes;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.capabilities.CapabilitiesHandler;
-import moa.capabilities.Capability;
-import moa.capabilities.ImmutableCapabilities;
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.GaussianNumericAttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.NominalAttributeClassObserver;
-import moa.core.AutoExpandVector;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.core.StringUtils;
-import moa.learners.Classifier;
-
-/**
- * Naive Bayes incremental learner.
- *
- * <p>Performs classic bayesian prediction while making naive assumption that
- * all inputs are independent.<br /> Naive Bayes is a classifier algorithm known
- * for its simplicity and low computational cost. Given n different classes, the
- * trained Naive Bayes classifier predicts for every unlabelled instance I the
- * class C to which it belongs with high accuracy.</p>
- *
- * <p>Parameters:</p> <ul> <li>-r : Seed for random behaviour of the
- * classifier</li> </ul>
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $
- */
-public class NaiveBayes extends AbstractClassifier  implements Classifier, CapabilitiesHandler {
-
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public String getPurposeString() {
-        return "Naive Bayes classifier: performs classic bayesian prediction while making naive assumption that all inputs are independent.";
-    }
-    protected DoubleVector observedClassDistribution;
-
-    protected AutoExpandVector<AttributeClassObserver> attributeObservers;
-
-    @Override
-    public void resetLearningImpl() {
-        this.observedClassDistribution = new DoubleVector();
-        this.attributeObservers = new AutoExpandVector<AttributeClassObserver>();
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight());
-        for (int i = 0; i < inst.numAttributes() - 1; i++) {
-            int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
-            AttributeClassObserver obs = this.attributeObservers.get(i);
-            if (obs == null) {
-                obs = inst.attribute(instAttIndex).isNominal() ? newNominalClassObserver()
-                        : newNumericClassObserver();
-                this.attributeObservers.set(i, obs);
-            }
-            obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
-        }
-    }
-
-    @Override
-    public Prediction getPredictionForInstance(Instance inst) {
-        return new ClassificationPrediction(doNaiveBayesPrediction(inst, this.observedClassDistribution,
-                this.attributeObservers));
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return null;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        for (int i = 0; i < this.observedClassDistribution.numValues(); i++) {
-            StringUtils.appendIndented(out, indent, "Observations for ");
-            out.append(getClassNameString());
-            out.append(" = ");
-            out.append(getClassLabelString(i));
-            out.append(":");
-            StringUtils.appendNewlineIndented(out, indent + 1,
-                    "Total observed weight = ");
-            out.append(this.observedClassDistribution.getValue(i));
-            out.append(" / prob = ");
-            out.append(this.observedClassDistribution.getValue(i)
-                    / this.observedClassDistribution.sumOfValues());
-            for (int j = 0; j < this.attributeObservers.size(); j++) {
-                StringUtils.appendNewlineIndented(out, indent + 1,
-                        "Observations for ");
-                out.append(getAttributeNameString(j));
-                out.append(": ");
-                // TODO: implement observer output
-                out.append(this.attributeObservers.get(j));
-            }
-            StringUtils.appendNewline(out);
-        }
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return false;
-    }
-
-    protected AttributeClassObserver newNominalClassObserver() {
-        return new NominalAttributeClassObserver();
-    }
-
-    protected AttributeClassObserver newNumericClassObserver() {
-        return new GaussianNumericAttributeClassObserver();
-    }
-
-    public static double[] doNaiveBayesPrediction(Instance inst,
-            DoubleVector observedClassDistribution,
-            AutoExpandVector<AttributeClassObserver> attributeObservers) {
-        double[] votes = new double[observedClassDistribution.numValues()];
-        double observedClassSum = observedClassDistribution.sumOfValues();
-        for (int classIndex = 0; classIndex < votes.length; classIndex++) {
-            votes[classIndex] = observedClassDistribution.getValue(classIndex)
-                    / observedClassSum;
-            for (int attIndex = 0; attIndex < inst.numAttributes() - 1; attIndex++) {
-                int instAttIndex = modelAttIndexToInstanceAttIndex(attIndex,
-                        inst);
-                AttributeClassObserver obs = attributeObservers.get(attIndex);
-                if ((obs != null) && !inst.isMissing(instAttIndex)) {
-                    votes[classIndex] *= obs.probabilityOfAttributeValueGivenClass(inst.value(instAttIndex), classIndex);
-                }
-            }
-        }
-        // TODO: need logic to prevent underflow?
-        return votes;
-    }
-
-    // Naive Bayes Prediction using log10 for VFDR rules 
-    public static double[] doNaiveBayesPredictionLog(Instance inst,
-            DoubleVector observedClassDistribution,
-            AutoExpandVector<AttributeClassObserver> observers, AutoExpandVector<AttributeClassObserver> observers2) {
-        AttributeClassObserver obs;
-        double[] votes = new double[observedClassDistribution.numValues()];
-        double observedClassSum = observedClassDistribution.sumOfValues();
-        for (int classIndex = 0; classIndex < votes.length; classIndex++) {
-            votes[classIndex] = Math.log10(observedClassDistribution.getValue(classIndex)
-                    / observedClassSum);
-            for (int attIndex = 0; attIndex < inst.numAttributes() - 1; attIndex++) {
-                int instAttIndex = modelAttIndexToInstanceAttIndex(attIndex,
-                        inst);
-                if (inst.attribute(instAttIndex).isNominal()) {
-                    obs = observers.get(attIndex);
-                } else {
-                    obs = observers2.get(attIndex);
-                }
-
-                if ((obs != null) && !inst.isMissing(instAttIndex)) {
-                    votes[classIndex] += Math.log10(obs.probabilityOfAttributeValueGivenClass(inst.value(instAttIndex), classIndex));
-
-                }
-            }
-        }
-        return votes;
-
-    }
-
-    public void manageMemory(int currentByteSize, int maxByteSize) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == NaiveBayes.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/bayes/NaiveBayesMultinomial.java b/moa/src/main/java/moa/classifiers/bayes/NaiveBayesMultinomial.java
deleted file mode 100644
index 8be2539f8..000000000
--- a/moa/src/main/java/moa/classifiers/bayes/NaiveBayesMultinomial.java
+++ /dev/null
@@ -1,270 +0,0 @@
-/*
- *    NaiveBayesMultinomial.java
- *    Copyright (C) 2011 University of Waikato, Hamilton, New Zealand
- *    @author Bernhard Pfahringer (bernhard@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-
-package moa.classifiers.bayes;
-
-import java.util.Arrays;
-
-import com.github.javacliparser.FloatOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.capabilities.Capability;
-import moa.capabilities.ImmutableCapabilities;
-import moa.classifiers.AbstractClassifier;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.core.StringUtils;
-import moa.core.Utils;
-import moa.learners.Classifier;
-
-/**
- * <!-- globalinfo-start --> Class for building and using a multinomial Naive
- * Bayes classifier. Performs text classic bayesian prediction while making
- * naive assumption that all inputs are independent. For more information
- * see,<br/> <br/> Andrew Mccallum, Kamal Nigam: A Comparison of Event Models
- * for Naive Bayes Text Classification. In: AAAI-98 Workshop on 'Learning for
- * Text Categorization', 1998.<br/> <br/> The core equation for this
- * classifier:<br/> <br/> P[Ci|D] = (P[D|Ci] x P[Ci]) / P[D] (Bayes rule)<br/>
- * <br/> where Ci is class i and D is a document.<br/> <br/> Incremental version
- * of the algorithm.
- * <p/>
- * <!-- globalinfo-end --> * <!-- technical-bibtex-start --> BibTeX:
- * <pre>
- * &#64;inproceedings{Mccallum1998,
- *    author = {Andrew Mccallum and Kamal Nigam},
- *    booktitle = {AAAI-98 Workshop on 'Learning for Text Categorization'},
- *    title = {A Comparison of Event Models for Naive Bayes Text Classification},
- *    year = {1998}
- * }
- * </pre>
- * <p/>
- * <!-- technical-bibtex-end -->
- */
-public class NaiveBayesMultinomial extends AbstractClassifier implements Classifier {
-
-    public FloatOption laplaceCorrectionOption = new FloatOption("laplaceCorrection",
-            'l', "Laplace correction factor.",
-            1.0, 0.00, Integer.MAX_VALUE);
-
-    /**
-     * for serialization
-     */
-    private static final long serialVersionUID = -7204398796974263187L;
-
-    @Override
-    public String getPurposeString() {
-        return "Multinomial Naive Bayes classifier: performs classic bayesian prediction while making naive assumption that all inputs are independent.";
-    }
-
-    /**
-     * sum of weight_of_instance * word_count_of_instance for each class
-     */
-    protected double[] m_classTotals;
-
-    /**
-     * copy of header information for use in toString method
-     */
-    protected InstancesHeader m_headerInfo;
-
-    /**
-     * number of class values
-     */
-    protected int m_numClasses;
-
-    /**
-     * the probability of a class (i.e. Pr[H])
-     */
-    protected double[] m_probOfClass;
-
-    /**
-     * probability that a word (w) exists in a class (H) (i.e. Pr[w|H]) The
-     * matrix is in the this format: m_wordTotalForClass[wordAttribute][class]
-     */
-    protected DoubleVector[] m_wordTotalForClass;
-
-    protected boolean reset = false;
-
-    @Override
-    public void resetLearningImpl() {
-        this.reset = true;
-    }
-
-    /**
-     * Trains the classifier with the given instance.
-     *
-     * @param inst the new training instance to include in the model
-     */
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        if (this.reset == true) {
-            this.m_numClasses = inst.numClasses();
-            double laplace = this.laplaceCorrectionOption.getValue();
-            int numAttributes = inst.numAttributes();
-
-            m_probOfClass = new double[m_numClasses];
-            Arrays.fill(m_probOfClass, laplace);
-
-            m_classTotals = new double[m_numClasses];
-            Arrays.fill(m_classTotals, laplace * numAttributes);
-
-            m_wordTotalForClass = new DoubleVector[m_numClasses];
-            for (int i = 0; i< m_numClasses; i++) {
-                //Arrays.fill(wordTotal, laplace);
-                m_wordTotalForClass[i] = new DoubleVector();
-            }
-            this.reset = false;
-        }
-        // Update classifier
-        int classIndex = inst.classIndex();
-        int classValue = (int) inst.classValue();//value(classIndex);
-
-        double w = inst.weight();
-        m_probOfClass[classValue] += w;
-
-        m_classTotals[classValue] += w * totalSize(inst);
-        double total = m_classTotals[classValue];
-
-        for (int i = 0; i < inst.numValues(); i++) {
-            int index = inst.index(i);
-            if (index != classIndex && !inst.isMissing(i)) {
-                //m_wordTotalForClass[index][classValue] += w * inst.valueSparse(i);
-                double laplaceCorrection = 0.0;
-                if (m_wordTotalForClass[classValue].getValue(index)== 0) {
-                    laplaceCorrection = this.laplaceCorrectionOption.getValue();
-                }
-                m_wordTotalForClass[classValue].addToValue(index, w * inst.valueSparse(i) + laplaceCorrection);
-            }
-        }
-    }
-
-    /**
-     * Calculates the class membership probabilities for the given test
-     * instance.
-     *
-     * @param instance the instance to be classified
-     * @return predicted class probability distribution
-     */
-    @Override
-    public Prediction getPredictionForInstance(Instance instance) {
-        if (this.reset == true) {
-            return new ClassificationPrediction();
-        }
-        double[] probOfClassGivenDoc = new double[m_numClasses];
-        double totalSize = totalSize(instance);
-
-        for (int i = 0; i < m_numClasses; i++) {
-            probOfClassGivenDoc[i] = Math.log(m_probOfClass[i]) - totalSize * Math.log(m_classTotals[i]);
-        }
-
-        for (int i = 0; i < instance.numValues(); i++) {
-
-            int index = instance.index(i);
-            if (index == instance.classIndex() || instance.isMissing(i)) {
-                continue;
-            }
-
-            double wordCount = instance.valueSparse(i);
-            for (int c = 0; c < m_numClasses; c++) {
-                double value = m_wordTotalForClass[c].getValue(index);
-                probOfClassGivenDoc[c] += wordCount * Math.log(value == 0 ? this.laplaceCorrectionOption.getValue() : value );
-            }
-        }
-
-        return new ClassificationPrediction(Utils.logs2probs(probOfClassGivenDoc));
-    }
-
-    public double totalSize(Instance instance) {
-        int classIndex = instance.classIndex();
-        double total = 0.0;
-        for (int i = 0; i < instance.numValues(); i++) {
-            int index = instance.index(i);
-            if (index == classIndex || instance.isMissing(i)) {
-                continue;
-            }
-            double count = instance.valueSparse(i);
-            if (count >= 0) {
-                total += count;
-            } else {
-                //throw new Exception("Numeric attribute value is not >= 0. " + i + " " + index + " " +
-                //		    instance.valueSparse(i) + " " + " " + instance);
-            }
-        }
-        return total;
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return null;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder result, int indent) {
-        StringUtils.appendIndented(result, indent, "xxx MNB1 xxx\n\n");
-
-        result.append("The independent probability of a class\n");
-        result.append("--------------------------------------\n");
-
-        for (int c = 0; c < m_numClasses; c++) {
-            result.append(m_headerInfo.classAttribute().value(c)).append("\t").
-                    append(Double.toString(m_probOfClass[c])).append("\n");
-        }
-
-        result.append("\nThe probability of a word given the class\n");
-        result.append("-----------------------------------------\n\t");
-
-        for (int c = 0; c < m_numClasses; c++) {
-            result.append(m_headerInfo.classAttribute().value(c)).append("\t");
-        }
-
-        result.append("\n");
-
-        for (int w = 0; w < m_headerInfo.numAttributes(); w++) {
-            if (w == m_headerInfo.classIndex()) {
-                continue;
-            }
-            result.append(m_headerInfo.attribute(w).name()).append("\t");
-            for (int c = 0; c < m_numClasses; c++) {
-                double value = m_wordTotalForClass[c].getValue(w);
-                if (value == 0){
-                    value = this.laplaceCorrectionOption.getValue();
-                }
-                result.append(value / m_classTotals[c]).append("\t");
-            }
-            result.append("\n");
-        }
-        StringUtils.appendNewline(result);
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return false;
-    }
-
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == NaiveBayesMultinomial.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/core/AttributeSplitSuggestion.java b/moa/src/main/java/moa/classifiers/core/AttributeSplitSuggestion.java
deleted file mode 100644
index 8c5f21837..000000000
--- a/moa/src/main/java/moa/classifiers/core/AttributeSplitSuggestion.java
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- *    AttributeSplitSuggestion.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.core;
-
-import moa.AbstractMOAObject;
-import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
-
-/**
- * Class for computing attribute split suggestions given a split test.
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $
- */
-public class AttributeSplitSuggestion extends AbstractMOAObject implements
-        Comparable<AttributeSplitSuggestion> {
-
-    private static final long serialVersionUID = 1L;
-
-    public InstanceConditionalTest splitTest;
-
-    public double[][] resultingClassDistributions;
-
-    public double merit;
-
-    public AttributeSplitSuggestion(InstanceConditionalTest splitTest,
-            double[][] resultingClassDistributions, double merit) {
-        this.splitTest = splitTest;
-        this.resultingClassDistributions = resultingClassDistributions.clone();
-        this.merit = merit;
-    }
-
-    public int numSplits() {
-        return this.resultingClassDistributions.length;
-    }
-
-    public double[] resultingClassDistributionFromSplit(int splitIndex) {
-        return this.resultingClassDistributions[splitIndex].clone();
-    }
-
-    @Override
-    public int compareTo(AttributeSplitSuggestion comp) {
-        return Double.compare(this.merit, comp.merit);
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/AttributeClassObserver.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/AttributeClassObserver.java
deleted file mode 100644
index c58c73cfc..000000000
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/AttributeClassObserver.java
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- *    AttributeClassObserver.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.core.attributeclassobservers;
-
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.options.OptionHandler;
-
-/**
- * Interface for observing the class data distribution for an attribute.
- * This observer monitors the class distribution of a given attribute.
- * Used in naive Bayes and decision trees to monitor data statistics on leaves.
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $ 
- */
-public interface AttributeClassObserver extends OptionHandler {
-
-    /**
-     * Updates statistics of this observer given an attribute value, a class
-     * and the weight of the instance observed
-     *
-     * @param attVal the value of the attribute
-     * @param classVal the class
-     * @param weight the weight of the instance
-     */
-    public void observeAttributeClass(double attVal, int classVal, double weight);
-
-    /**
-     * Gets the probability for an attribute value given a class
-     *
-     * @param attVal the attribute value
-     * @param classVal the class
-     * @return probability for an attribute value given a class
-     */
-    public double probabilityOfAttributeValueGivenClass(double attVal,
-            int classVal);
-
-    /**
-     * Gets the best split suggestion given a criterion and a class distribution
-     *
-     * @param criterion the split criterion to use
-     * @param preSplitDist the class distribution before the split
-     * @param attIndex the attribute index
-     * @param binaryOnly true to use binary splits
-     * @return suggestion of best attribute split
-     */
-    public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(
-            SplitCriterion criterion, double[] preSplitDist, int attIndex,
-            boolean binaryOnly);
-
-
-    public void observeAttributeTarget(double attVal, double target);
-    
-    public void observeAttributeValue(double attVal, double value, double weight);
-    
-}
diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserver.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserver.java
deleted file mode 100644
index d02c69593..000000000
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserver.java
+++ /dev/null
@@ -1,184 +0,0 @@
-/*
- *    BinaryTreeNumericAttributeClassObserver.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz), Andreas Hapfelmeier (Andreas.Hapfelmeier@in.tum.de)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- *    
- */
-package moa.classifiers.core.attributeclassobservers;
-
-import java.io.Serializable;
-
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.core.DoubleVector;
-import moa.core.ObjectRepository;
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
-/**
- * Class for observing the class data distribution for a numeric attribute using a binary tree.
- * This observer monitors the class distribution of a given attribute.
- * Used in naive Bayes and decision trees to monitor data statistics on leaves.
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $
- */
-public class BinaryTreeNumericAttributeClassObserver extends AbstractAttributeClassObserver
-        implements NumericAttributeClassObserver {
-
-    private static final long serialVersionUID = 1L;
-
-    public class Node implements Serializable {
-
-        private static final long serialVersionUID = 1L;
-
-        public double cut_point;
-
-        public DoubleVector classCountsLeft = new DoubleVector();
-
-        public DoubleVector classCountsRight = new DoubleVector();
-
-        public Node left;
-
-        public Node right;
-
-        public Node(double val, int label, double weight) {
-            this.cut_point = val;
-            this.classCountsLeft.addToValue(label, weight);
-        }
-
-        public void insertValue(double val, int label, double weight) {
-            if (val == this.cut_point) {
-                this.classCountsLeft.addToValue(label, weight);
-            } else if (val <= this.cut_point) {
-                this.classCountsLeft.addToValue(label, weight);
-                if (this.left == null) {
-                    this.left = new Node(val, label, weight);
-                } else {
-                    this.left.insertValue(val, label, weight);
-                }
-            } else { // val > cut_point
-                this.classCountsRight.addToValue(label, weight);
-                if (this.right == null) {
-                    this.right = new Node(val, label, weight);
-                } else {
-                    this.right.insertValue(val, label, weight);
-                }
-            }
-        }
-    }
-
-    public Node root = null;
-
-    @Override
-    public void observeAttributeClass(double attVal, int classVal, double weight) {
-        if (Double.isNaN(attVal)) { //Instance.isMissingValue(attVal)
-        } else {
-            if (this.root == null) {
-                this.root = new Node(attVal, classVal, weight);
-            } else {
-                this.root.insertValue(attVal, classVal, weight);
-            }
-        }
-    }
-
-    @Override
-    public double probabilityOfAttributeValueGivenClass(double attVal,
-            int classVal) {
-        // TODO: NaiveBayes broken until implemented
-        return 0.0;
-    }
-
-    @Override
-    public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(
-            SplitCriterion criterion, double[] preSplitDist, int attIndex,
-            boolean binaryOnly) {
-        return searchForBestSplitOption(this.root, null, null, null, null, false,
-                criterion, preSplitDist, attIndex);
-    }
-
-    protected AttributeSplitSuggestion searchForBestSplitOption(
-            Node currentNode, AttributeSplitSuggestion currentBestOption,
-            double[] actualParentLeft,
-            double[] parentLeft, double[] parentRight, boolean leftChild,
-            SplitCriterion criterion, double[] preSplitDist, int attIndex) {
-        if (currentNode == null) {
-            return currentBestOption;
-        }
-        DoubleVector leftDist = new DoubleVector();
-        DoubleVector rightDist = new DoubleVector();
-        if (parentLeft == null) {
-            leftDist.addValues(currentNode.classCountsLeft);
-            rightDist.addValues(currentNode.classCountsRight);
-        } else {
-            leftDist.addValues(parentLeft);
-            rightDist.addValues(parentRight);
-            if (leftChild) {
-                //get the exact statistics of the parent value
-                DoubleVector exactParentDist = new DoubleVector();
-                exactParentDist.addValues(actualParentLeft);
-                exactParentDist.subtractValues(currentNode.classCountsLeft);
-                exactParentDist.subtractValues(currentNode.classCountsRight);
-
-                // move the subtrees
-                leftDist.subtractValues(currentNode.classCountsRight);
-                rightDist.addValues(currentNode.classCountsRight);
-
-                // move the exact value from the parent
-                rightDist.addValues(exactParentDist);
-                leftDist.subtractValues(exactParentDist);
-
-            } else {
-                leftDist.addValues(currentNode.classCountsLeft);
-                rightDist.subtractValues(currentNode.classCountsLeft);
-            }
-        }
-        double[][] postSplitDists = new double[][]{leftDist.getArrayRef(),
-            rightDist.getArrayRef()};
-        double merit = criterion.getMeritOfSplit(preSplitDist, postSplitDists);
-        if ((currentBestOption == null) || (merit > currentBestOption.merit)) {
-            currentBestOption = new AttributeSplitSuggestion(
-                    new NumericAttributeBinaryTest(attIndex,
-                    currentNode.cut_point, true), postSplitDists, merit);
-
-        }
-        currentBestOption = searchForBestSplitOption(currentNode.left,
-                currentBestOption, currentNode.classCountsLeft.getArrayRef(), postSplitDists[0], postSplitDists[1], true,
-                criterion, preSplitDist, attIndex);
-        currentBestOption = searchForBestSplitOption(currentNode.right,
-                currentBestOption, currentNode.classCountsLeft.getArrayRef(), postSplitDists[0], postSplitDists[1], false,
-                criterion, preSplitDist, attIndex);
-        return currentBestOption;
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-        // TODO Auto-generated method stub
-    }
-    
-    @Override
-    public void observeAttributeTarget(double attVal, double target) {
-        throw new UnsupportedOperationException("Not supported yet.");
-    }
-   
-}
diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserverRegression.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserverRegression.java
deleted file mode 100644
index 1d51ed665..000000000
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserverRegression.java
+++ /dev/null
@@ -1,151 +0,0 @@
-/*
- *    BinaryTreeNumericAttributeClassObserverRegression.java
- *    Copyright (C) 2013 University of Porto, Portugal
- *    @author E. Almeida, J. Gama
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- *    
- */
-
-package moa.classifiers.core.attributeclassobservers;
-
-import java.io.Serializable;
-
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.core.ObjectRepository;
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
-/**
- * Class for observing the class data distribution for a numeric attribute using a binary tree.
- * This observer monitors the class distribution of a given attribute.
- *
- * <p>Learning Adaptive Model Rules from High-Speed Data Streams, ECML 2013, E. Almeida, C. Ferreira, P. Kosina and J. Gama; </p>
- *
- * @author E. Almeida, J. Gama
- * @version $Revision: 2$
- */
-public class BinaryTreeNumericAttributeClassObserverRegression extends AbstractAttributeClassObserver
-        implements NumericAttributeClassObserver {
-
-    public static final long serialVersionUID = 1L;
-	
-        public class Node implements Serializable {
-
-        private static final long serialVersionUID = 1L;
-
-        public double cut_point;
-        
-        public double[] lessThan; //This array maintains statistics for the instance reaching the node with attribute values less than or iqual to the cutpoint.
-        
-        public double[] greaterThan; //This array maintains statistics for the instance reaching the node with attribute values greater than to the cutpoint.
-
-        public Node left;
-
-        public Node right;
-
-        public Node(double val, double target) {
-            this.cut_point = val;
-            this.lessThan = new double[3];
-            this.greaterThan = new double[3];
-            this.lessThan[0] = target; //The sum of their target attribute values.
-            this.lessThan[1] = target * target; //The sum of the squared target attribute values.
-            this.lessThan[2] = 1.0; //A counter of the number of instances that have reached the node.
-            this.greaterThan[0] = 0.0;
-            this.greaterThan[1] = 0.0;
-            this.greaterThan[2] = 0.0;
-      }
-
-        public void insertValue(double val, double target) {
-            if (val == this.cut_point) {
-            	 this.lessThan[0] = this.lessThan[0] + target;
-                 this.lessThan[1] = this.lessThan[1] + (target * target);
-                 this.lessThan[2] = this.lessThan[2] + 1;
-            } else if (val <= this.cut_point) {
-            	 this.lessThan[0] = this.lessThan[0] + target;
-                 this.lessThan[1] = this.lessThan[1] + (target * target);
-                 this.lessThan[2] = this.lessThan[2] + 1;
-                if (this.left == null) {
-                    this.left = new Node(val, target);
-                } else {
-                    this.left.insertValue(val, target);
-                }
-            } else {
-            	 this.greaterThan[0] = this.greaterThan[0] + target;
-                 this.greaterThan[1] = this.greaterThan[1] + (target*target);
-                 this.greaterThan[2] = this.greaterThan[2] + 1;
-                if (this.right == null) {
-                   this.right = new Node(val, target);
-                } else {
-                   this.right.insertValue(val, target);
-                }
-            }
-        }
-    }
-
-    public Node root1 = null;
-    
-    public void observeAttributeTarget(double attVal, double target){
-    	 if (Double.isNaN(attVal)) {
-         } else {
-             if (this.root1 == null) {
-                 this.root1 = new Node(attVal, target);
-             } else {
-                 this.root1.insertValue(attVal, target);
-             }
-         }
-    }
-
-    @Override
-    public void observeAttributeClass(double attVal, int classVal, double weight) {
-       
-    }
-
-    @Override
-    public double probabilityOfAttributeValueGivenClass(double attVal,
-            int classVal) {
-        // TODO: NaiveBayes broken until implemented
-        return 0.0;
-    }
-
-    @Override
-    public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(
-            SplitCriterion criterion, double[] preSplitDist, int attIndex,
-            boolean binaryOnly) {
-        return searchForBestSplitOption(this.root1, null, null, null, null, false,
-                criterion, preSplitDist, attIndex);
-    }
-
-    protected AttributeSplitSuggestion searchForBestSplitOption(
-            Node currentNode, AttributeSplitSuggestion currentBestOption,
-            double[] actualParentLeft,
-            double[] parentLeft, double[] parentRight, boolean leftChild,
-            SplitCriterion criterion, double[] preSplitDist, int attIndex) {
-       
-        return currentBestOption;
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-        // TODO Auto-generated method stub
-    }
-}
-
diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/FIMTDDNumericAttributeClassObserver.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/FIMTDDNumericAttributeClassObserver.java
deleted file mode 100644
index c36862652..000000000
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/FIMTDDNumericAttributeClassObserver.java
+++ /dev/null
@@ -1,251 +0,0 @@
-/*
- *    FIMTDDNumericAttributeClassObserver.java
- *    Copyright (C) 2013 University of Porto, Portugal
- *    @author Katie de Lange, E. Almeida, J. Gama
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- *    
- */
-
-/* Project Knowledge Discovery from Data Streams, FCT LIAAD-INESC TEC, 
- *
- * Contact: jgama@fep.up.pt
- */
-
-package moa.classifiers.core.attributeclassobservers;
-
-import java.io.Serializable;
-
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.core.DoubleVector;
-import moa.core.ObjectRepository;
-import moa.tasks.TaskMonitor;
-
-public class FIMTDDNumericAttributeClassObserver extends BinaryTreeNumericAttributeClassObserver implements NumericAttributeClassObserver {
-
-    private static final long serialVersionUID = 1L;
-
-    protected class Node implements Serializable {
-
-        private static final long serialVersionUID = 1L;
-
-        // The split point to use
-        public double cut_point;
-
-        // E-BST statistics
-        public DoubleVector leftStatistics = new DoubleVector();
-        //public DoubleVector rightStatistics = new DoubleVector();
-
-        // Child nodes
-        public Node left;
-        public Node right;
-
-        public Node(double val, double label, double weight) {
-            this.cut_point = val;
-            this.leftStatistics.addToValue(0, weight);
-            this.leftStatistics.addToValue(1, weight * label);
-            this.leftStatistics.addToValue(2, weight * label * label);
-        }
-
-        /**
-         * Insert a new value into the tree, updating both the sum of values and
-         * sum of squared values arrays
-         */
-        public void insertValue(double val, double label, double weight) {
-
-		// If the new value equals the value stored in a node, update
-            // the left (<=) node information
-            if (val == this.cut_point) {
-                this.leftStatistics.addToValue(0, weight);
-                this.leftStatistics.addToValue(1, weight * label);
-                this.leftStatistics.addToValue(2, weight * label * label);
-            } // If the new value is less than the value in a node, update the
-            // left distribution and send the value down to the left child node.
-            // If no left child exists, create one
-            else if (val <= this.cut_point) {
-                this.leftStatistics.addToValue(0, weight);
-                this.leftStatistics.addToValue(1, weight * label);
-                this.leftStatistics.addToValue(2, weight * label * label);
-                if (this.left == null) {
-                    this.left = new Node(val, label, weight);
-                } else {
-                    this.left.insertValue(val, label, weight);
-                }
-            } // If the new value is greater than the value in a node, update the
-            // right (>) distribution and send the value down to the right child node.
-            // If no right child exists, create one
-            else { // val > cut_point
-                //this.rightStatistics.addToValue(0, weight);
-                //this.rightStatistics.addToValue(1, weight * label);
-                //this.rightStatistics.addToValue(2, weight * label * label);
-                //if (this.right == null) {
-                //    this.right = new Node(val, label, weight);
-                //} else {
-                //    this.right.insertValue(val, label, weight);
-                //}
-            }
-        }
-    }
-
-    // Root node of the E-BST structure for this attribute
-    protected Node root = null;
-
-    // Global variables for use in the FindBestSplit algorithm
-    double sumTotalLeft;
-    double sumTotalRight;
-    double sumSqTotalLeft;
-    double sumSqTotalRight;
-    double countRightTotal;
-    double countLeftTotal;
-
-	public static double roundToSignificantFigures(double num, int n) {
-	    final double d = Math.ceil(Math.log10(num < 0 ? -num: num));
-	    final int power = n - (int) d;
-
-	    final double magnitude = Math.pow(10, power);
-	    final long shifted = (long) (num*magnitude);
-	    return shifted/magnitude;
-	}
-    
-    public void observeAttributeClass(double attVal, double classVal, double weight) {
-        if (Double.isNaN(attVal)) { //Instance.isMissingValue(attVal)
-        } else {
-            if (this.root == null) {
-//            	if ((long) attVal != attVal) attVal = roundToSignificantFigures(attVal, 4);
-                this.root = new Node(attVal, classVal, weight);
-            } else {
-                this.root.insertValue(attVal, classVal, weight);
-            }
-        }
-    }
-
-    @Override
-    public double probabilityOfAttributeValueGivenClass(double attVal,
-            int classVal) {
-        // TODO: NaiveBayes broken until implemented
-        return 0.0;
-    }
-
-    @Override
-    public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(SplitCriterion criterion, double[] preSplitDist, int attIndex, boolean binaryOnly) {
-
-        // Initialise global variables
-        sumTotalLeft = 0;
-        sumTotalRight = preSplitDist[1];
-        sumSqTotalLeft = 0;
-        sumSqTotalRight = preSplitDist[2];
-        countLeftTotal = 0;
-        countRightTotal = preSplitDist[0];
-        return searchForBestSplitOption(this.root, null, criterion, attIndex);
-    }
-
-    /**
-     * Implementation of the FindBestSplit algorithm from E.Ikonomovska et al.
-     */
-    protected AttributeSplitSuggestion searchForBestSplitOption(Node currentNode, AttributeSplitSuggestion currentBestOption, SplitCriterion criterion, int attIndex) {
-        // Return null if the current node is null or we have finished looking through all the possible splits
-        if (currentNode == null || countRightTotal == 0.0) {
-            return currentBestOption;
-        }
-
-        if (currentNode.left != null) {
-            currentBestOption = searchForBestSplitOption(currentNode.left, currentBestOption, criterion, attIndex);
-        }
-
-        sumTotalLeft += currentNode.leftStatistics.getValue(1);
-        sumTotalRight -= currentNode.leftStatistics.getValue(1);
-        sumSqTotalLeft += currentNode.leftStatistics.getValue(2);
-        sumSqTotalRight -= currentNode.leftStatistics.getValue(2);
-        countLeftTotal += currentNode.leftStatistics.getValue(0);
-        countRightTotal -= currentNode.leftStatistics.getValue(0);
-
-        double[][] postSplitDists = new double[][]{{countLeftTotal, sumTotalLeft, sumSqTotalLeft}, {countRightTotal, sumTotalRight, sumSqTotalRight}};
-        double[] preSplitDist = new double[]{(countLeftTotal + countRightTotal), (sumTotalLeft + sumTotalRight), (sumSqTotalLeft + sumSqTotalRight)};
-        double merit = criterion.getMeritOfSplit(preSplitDist, postSplitDists);
-
-        if ((currentBestOption == null) || (merit > currentBestOption.merit)) {
-            currentBestOption = new AttributeSplitSuggestion(
-                    new NumericAttributeBinaryTest(attIndex,
-                            currentNode.cut_point, true), postSplitDists, merit);
-
-        }
-
-        if (currentNode.right != null) {
-            currentBestOption = searchForBestSplitOption(currentNode.right, currentBestOption, criterion, attIndex);
-        }
-        sumTotalLeft -= currentNode.leftStatistics.getValue(1);
-        sumTotalRight += currentNode.leftStatistics.getValue(1);
-        sumSqTotalLeft -= currentNode.leftStatistics.getValue(2);
-        sumSqTotalRight += currentNode.leftStatistics.getValue(2);
-        countLeftTotal -= currentNode.leftStatistics.getValue(0);
-        countRightTotal += currentNode.leftStatistics.getValue(0);
-
-        return currentBestOption;
-    }
-
-    /**
-     * A method to remove all nodes in the E-BST in which it and all it's
-     * children represent 'bad' split points
-     */
-    public void removeBadSplits(SplitCriterion criterion, double lastCheckRatio, double lastCheckSDR, double lastCheckE) {
-        removeBadSplitNodes(criterion, this.root, lastCheckRatio, lastCheckSDR, lastCheckE);
-    }
-
-    /**
-     * Recursive method that first checks all of a node's children before
-     * deciding if it is 'bad' and may be removed
-     */
-    private boolean removeBadSplitNodes(SplitCriterion criterion, Node currentNode, double lastCheckRatio, double lastCheckSDR, double lastCheckE) {
-        boolean isBad = false;
-
-        if (currentNode == null) {
-            return true;
-        }
-
-        if (currentNode.left != null) {
-            isBad = removeBadSplitNodes(criterion, currentNode.left, lastCheckRatio, lastCheckSDR, lastCheckE);
-        }
-
-        if (currentNode.right != null && isBad) {
-            isBad = removeBadSplitNodes(criterion, currentNode.left, lastCheckRatio, lastCheckSDR, lastCheckE);
-        }
-
-        if (isBad) {
-
-            //double[][] postSplitDists = new double[][]{{currentNode.leftStatistics.getValue(0), currentNode.leftStatistics.getValue(1), currentNode.leftStatistics.getValue(2)}, {currentNode.rightStatistics.getValue(0), currentNode.rightStatistics.getValue(1), currentNode.rightStatistics.getValue(2)}};
-            //double[] preSplitDist = new double[]{(currentNode.leftStatistics.getValue(0) + currentNode.rightStatistics.getValue(0)), (currentNode.leftStatistics.getValue(1) + currentNode.rightStatistics.getValue(1)), (currentNode.leftStatistics.getValue(2) + currentNode.rightStatistics.getValue(2))};
-            //double merit = criterion.getMeritOfSplit(preSplitDist, postSplitDists);
-
-            //if ((merit / lastCheckSDR) < (lastCheckRatio - (2 * lastCheckE))) {
-            //    currentNode = null;
-            //    return true;
-            //}
-        }
-
-        return false;
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-        // TODO Auto-generated method stub
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/GaussianNumericAttributeClassObserver.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/GaussianNumericAttributeClassObserver.java
deleted file mode 100644
index 117ceb276..000000000
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/GaussianNumericAttributeClassObserver.java
+++ /dev/null
@@ -1,176 +0,0 @@
-/*
- *    GaussianNumericAttributeClassObserver.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.core.attributeclassobservers;
-
-import java.util.Set;
-import java.util.TreeSet;
-
-import com.github.javacliparser.IntOption;
-
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.core.AutoExpandVector;
-import moa.core.DoubleVector;
-import moa.core.GaussianEstimator;
-import moa.core.ObjectRepository;
-import moa.core.Utils;
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
-/**
- * Class for observing the class data distribution for a numeric attribute using gaussian estimators.
- * This observer monitors the class distribution of a given attribute.
- * Used in naive Bayes and decision trees to monitor data statistics on leaves.
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $
- */
-public class GaussianNumericAttributeClassObserver extends AbstractAttributeClassObserver
-        implements NumericAttributeClassObserver {
-
-    private static final long serialVersionUID = 1L;
-
-    protected DoubleVector minValueObservedPerClass = new DoubleVector();
-
-    protected DoubleVector maxValueObservedPerClass = new DoubleVector();
-
-    protected AutoExpandVector<GaussianEstimator> attValDistPerClass = new AutoExpandVector<GaussianEstimator>();
-
-    public IntOption numBinsOption = new IntOption("numBins", 'n',
-            "The number of bins.", 10, 1, Integer.MAX_VALUE);
-
-    @Override
-    public void observeAttributeClass(double attVal, int classVal, double weight) {
-        if (Utils.isMissingValue(attVal)) {
-        } else {
-            GaussianEstimator valDist = this.attValDistPerClass.get(classVal);
-            if (valDist == null) {
-                valDist = new GaussianEstimator();
-                this.attValDistPerClass.set(classVal, valDist);
-                this.minValueObservedPerClass.setValue(classVal, attVal);
-                this.maxValueObservedPerClass.setValue(classVal, attVal);
-            } else {
-                if (attVal < this.minValueObservedPerClass.getValue(classVal)) {
-                    this.minValueObservedPerClass.setValue(classVal, attVal);
-                }
-                if (attVal > this.maxValueObservedPerClass.getValue(classVal)) {
-                    this.maxValueObservedPerClass.setValue(classVal, attVal);
-                }
-            }
-            valDist.addObservation(attVal, weight);
-        }
-    }
-
-    @Override
-    public double probabilityOfAttributeValueGivenClass(double attVal,
-            int classVal) {
-        GaussianEstimator obs = this.attValDistPerClass.get(classVal);
-        return obs != null ? obs.probabilityDensity(attVal) : 0.0;
-    }
-
-    @Override
-    public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(
-            SplitCriterion criterion, double[] preSplitDist, int attIndex,
-            boolean binaryOnly) {
-        AttributeSplitSuggestion bestSuggestion = null;
-        double[] suggestedSplitValues = getSplitPointSuggestions();
-        for (double splitValue : suggestedSplitValues) {
-            double[][] postSplitDists = getClassDistsResultingFromBinarySplit(splitValue);
-            double merit = criterion.getMeritOfSplit(preSplitDist,
-                    postSplitDists);
-            if ((bestSuggestion == null) || (merit > bestSuggestion.merit)) {
-                bestSuggestion = new AttributeSplitSuggestion(
-                        new NumericAttributeBinaryTest(attIndex, splitValue,
-                        true), postSplitDists, merit);
-            }
-        }
-        return bestSuggestion;
-    }
-
-    public double[] getSplitPointSuggestions() {
-        Set<Double> suggestedSplitValues = new TreeSet<Double>();
-        double minValue = Double.POSITIVE_INFINITY;
-        double maxValue = Double.NEGATIVE_INFINITY;
-        for (int i = 0; i < this.attValDistPerClass.size(); i++) {
-            GaussianEstimator estimator = this.attValDistPerClass.get(i);
-            if (estimator != null) {
-                if (this.minValueObservedPerClass.getValue(i) < minValue) {
-                    minValue = this.minValueObservedPerClass.getValue(i);
-                }
-                if (this.maxValueObservedPerClass.getValue(i) > maxValue) {
-                    maxValue = this.maxValueObservedPerClass.getValue(i);
-                }
-            }
-        }
-        if (minValue < Double.POSITIVE_INFINITY) {
-            double range = maxValue - minValue;
-            for (int i = 0; i < this.numBinsOption.getValue(); i++) {
-                double splitValue = range / (this.numBinsOption.getValue() + 1.0) * (i + 1)
-                        + minValue;
-                if ((splitValue > minValue) && (splitValue < maxValue)) {
-                    suggestedSplitValues.add(splitValue);
-                }
-            }
-        }
-        double[] suggestions = new double[suggestedSplitValues.size()];
-        int i = 0;
-        for (double suggestion : suggestedSplitValues) {
-            suggestions[i++] = suggestion;
-        }
-        return suggestions;
-    }
-
-    // assume all values equal to splitValue go to lhs
-    public double[][] getClassDistsResultingFromBinarySplit(double splitValue) {
-        DoubleVector lhsDist = new DoubleVector();
-        DoubleVector rhsDist = new DoubleVector();
-        for (int i = 0; i < this.attValDistPerClass.size(); i++) {
-            GaussianEstimator estimator = this.attValDistPerClass.get(i);
-            if (estimator != null) {
-                if (splitValue < this.minValueObservedPerClass.getValue(i)) {
-                    rhsDist.addToValue(i, estimator.getTotalWeightObserved());
-                } else if (splitValue >= this.maxValueObservedPerClass.getValue(i)) {
-                    lhsDist.addToValue(i, estimator.getTotalWeightObserved());
-                } else {
-                    double[] weightDist = estimator.estimatedWeight_LessThan_EqualTo_GreaterThan_Value(splitValue);
-                    lhsDist.addToValue(i, weightDist[0] + weightDist[1]);
-                    rhsDist.addToValue(i, weightDist[2]);
-                }
-            }
-        }
-        return new double[][]{lhsDist.getArrayRef(), rhsDist.getArrayRef()};
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    public void observeAttributeTarget(double attVal, double target) {
-        throw new UnsupportedOperationException("Not supported yet.");
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/GreenwaldKhannaNumericAttributeClassObserver.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/GreenwaldKhannaNumericAttributeClassObserver.java
deleted file mode 100644
index df91e1a8e..000000000
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/GreenwaldKhannaNumericAttributeClassObserver.java
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
- *    GreenwaldKhannaNumericAttributeClassObserver.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.core.attributeclassobservers;
-
-import com.github.javacliparser.IntOption;
-
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.core.AutoExpandVector;
-import moa.core.DoubleVector;
-import moa.core.GreenwaldKhannaQuantileSummary;
-import moa.core.ObjectRepository;
-import moa.core.Utils;
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
-/**
- * Class for observing the class data distribution for a numeric attribute using Greenwald and Khanna methodology.
- * This observer monitors the class distribution of a given attribute.
- * Used in naive Bayes and decision trees to monitor data statistics on leaves.
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $
- */
-public class GreenwaldKhannaNumericAttributeClassObserver extends AbstractAttributeClassObserver implements NumericAttributeClassObserver {
-
-    private static final long serialVersionUID = 1L;
-
-    protected AutoExpandVector<GreenwaldKhannaQuantileSummary> attValDistPerClass = new AutoExpandVector<GreenwaldKhannaQuantileSummary>();
-
-    public IntOption numTuplesOption = new IntOption("numTuples", 'n',
-        "The number of tuples.", 10, 1, Integer.MAX_VALUE);
-
-    @Override
-    public void observeAttributeClass(double attVal, int classVal, double weight) {
-        if (Utils.isMissingValue(attVal)) {
-        } else {
-            GreenwaldKhannaQuantileSummary valDist = this.attValDistPerClass.get(classVal);
-            if (valDist == null) {
-                valDist = new GreenwaldKhannaQuantileSummary(this.numTuplesOption.getValue());
-                this.attValDistPerClass.set(classVal, valDist);
-            }
-            // TODO: not taking weight into account
-            valDist.insert(attVal);
-        }
-    }
-
-    @Override
-    public double probabilityOfAttributeValueGivenClass(double attVal,
-            int classVal) {
-        // TODO: NaiveBayes broken until implemented
-        return 0.0;
-    }
-
-    @Override
-    public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(
-            SplitCriterion criterion, double[] preSplitDist, int attIndex,
-            boolean binaryOnly) {
-        AttributeSplitSuggestion bestSuggestion = null;
-        for (GreenwaldKhannaQuantileSummary qs : this.attValDistPerClass) {
-            if (qs != null) {
-                double[] cutpoints = qs.getSuggestedCutpoints();
-                for (double cutpoint : cutpoints) {
-                    double[][] postSplitDists = getClassDistsResultingFromBinarySplit(cutpoint);
-                    double merit = criterion.getMeritOfSplit(preSplitDist,
-                            postSplitDists);
-                    if ((bestSuggestion == null)
-                            || (merit > bestSuggestion.merit)) {
-                        bestSuggestion = new AttributeSplitSuggestion(
-                                new NumericAttributeBinaryTest(attIndex,
-                                cutpoint, true), postSplitDists, merit);
-                    }
-                }
-            }
-        }
-        return bestSuggestion;
-    }
-
-    // assume all values equal to splitValue go to lhs
-    public double[][] getClassDistsResultingFromBinarySplit(double splitValue) {
-        DoubleVector lhsDist = new DoubleVector();
-        DoubleVector rhsDist = new DoubleVector();
-        for (int i = 0; i < this.attValDistPerClass.size(); i++) {
-            GreenwaldKhannaQuantileSummary estimator = this.attValDistPerClass.get(i);
-            if (estimator != null) {
-                long countBelow = estimator.getCountBelow(splitValue);
-                lhsDist.addToValue(i, countBelow);
-                rhsDist.addToValue(i, estimator.getTotalCount() - countBelow);
-            }
-        }
-        return new double[][]{lhsDist.getArrayRef(), rhsDist.getArrayRef()};
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    public void observeAttributeTarget(double attVal, double target) {
-        throw new UnsupportedOperationException("Not supported yet.");
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/NominalAttributeClassObserver.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/NominalAttributeClassObserver.java
deleted file mode 100644
index 1a2ca20fc..000000000
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/NominalAttributeClassObserver.java
+++ /dev/null
@@ -1,177 +0,0 @@
-/*
- *    NominalAttributeClassObserver.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.core.attributeclassobservers;
-
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.conditionaltests.NominalAttributeBinaryTest;
-import moa.classifiers.core.conditionaltests.NominalAttributeMultiwayTest;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.core.AutoExpandVector;
-import moa.core.DoubleVector;
-import moa.core.ObjectRepository;
-import moa.core.Utils;
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
-/**
- * Class for observing the class data distribution for a nominal attribute.
- * This observer monitors the class distribution of a given attribute.
- * Used in naive Bayes and decision trees to monitor data statistics on leaves.
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $
- */
-public class NominalAttributeClassObserver extends AbstractAttributeClassObserver implements
-        DiscreteAttributeClassObserver {
-
-    private static final long serialVersionUID = 1L;
-
-    protected double totalWeightObserved = 0.0;
-
-    protected double missingWeightObserved = 0.0;
-
-    public AutoExpandVector<DoubleVector> attValDistPerClass = new AutoExpandVector<DoubleVector>();
-
-    @Override
-    public void observeAttributeClass(double attVal, int classVal, double weight) {
-        if (Utils.isMissingValue(attVal)) {
-            this.missingWeightObserved += weight;
-        } else {
-            int attValInt = (int) attVal;
-            DoubleVector valDist = this.attValDistPerClass.get(classVal);
-            if (valDist == null) {
-                valDist = new DoubleVector();
-                this.attValDistPerClass.set(classVal, valDist);
-            }
-            valDist.addToValue(attValInt, weight);
-        }
-        this.totalWeightObserved += weight;
-    }
-
-    @Override
-    public double probabilityOfAttributeValueGivenClass(double attVal,
-            int classVal) {
-        DoubleVector obs = this.attValDistPerClass.get(classVal);
-        return obs != null ? (obs.getValue((int) attVal) + 1.0)
-                / (obs.sumOfValues() + obs.numValues()) : 0.0;
-    }
-
-    public double totalWeightOfClassObservations() {
-        return this.totalWeightObserved;
-    }
-
-    public double weightOfObservedMissingValues() {
-        return this.missingWeightObserved;
-    }
-
-    @Override
-    public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(
-            SplitCriterion criterion, double[] preSplitDist, int attIndex,
-            boolean binaryOnly) {
-        AttributeSplitSuggestion bestSuggestion = null;
-        int maxAttValsObserved = getMaxAttValsObserved();
-        if (!binaryOnly) {
-            double[][] postSplitDists = getClassDistsResultingFromMultiwaySplit(maxAttValsObserved);
-            double merit = criterion.getMeritOfSplit(preSplitDist,
-                    postSplitDists);
-            bestSuggestion = new AttributeSplitSuggestion(
-                    new NominalAttributeMultiwayTest(attIndex), postSplitDists,
-                    merit);
-        }
-        for (int valIndex = 0; valIndex < maxAttValsObserved; valIndex++) {
-            double[][] postSplitDists = getClassDistsResultingFromBinarySplit(valIndex);
-            double merit = criterion.getMeritOfSplit(preSplitDist,
-                    postSplitDists);
-            if ((bestSuggestion == null) || (merit > bestSuggestion.merit)) {
-                bestSuggestion = new AttributeSplitSuggestion(
-                        new NominalAttributeBinaryTest(attIndex, valIndex),
-                        postSplitDists, merit);
-            }
-        }
-        return bestSuggestion;
-    }
-
-    public int getMaxAttValsObserved() {
-        int maxAttValsObserved = 0;
-        for (DoubleVector attValDist : this.attValDistPerClass) {
-            if ((attValDist != null)
-                    && (attValDist.numValues() > maxAttValsObserved)) {
-                maxAttValsObserved = attValDist.numValues();
-            }
-        }
-        return maxAttValsObserved;
-    }
-
-    public double[][] getClassDistsResultingFromMultiwaySplit(
-            int maxAttValsObserved) {
-        DoubleVector[] resultingDists = new DoubleVector[maxAttValsObserved];
-        for (int i = 0; i < resultingDists.length; i++) {
-            resultingDists[i] = new DoubleVector();
-        }
-        for (int i = 0; i < this.attValDistPerClass.size(); i++) {
-            DoubleVector attValDist = this.attValDistPerClass.get(i);
-            if (attValDist != null) {
-                for (int j = 0; j < attValDist.numValues(); j++) {
-                    resultingDists[j].addToValue(i, attValDist.getValue(j));
-                }
-            }
-        }
-        double[][] distributions = new double[maxAttValsObserved][];
-        for (int i = 0; i < distributions.length; i++) {
-            distributions[i] = resultingDists[i].getArrayRef();
-        }
-        return distributions;
-    }
-
-    public double[][] getClassDistsResultingFromBinarySplit(int valIndex) {
-        DoubleVector equalsDist = new DoubleVector();
-        DoubleVector notEqualDist = new DoubleVector();
-        for (int i = 0; i < this.attValDistPerClass.size(); i++) {
-            DoubleVector attValDist = this.attValDistPerClass.get(i);
-            if (attValDist != null) {
-                for (int j = 0; j < attValDist.numValues(); j++) {
-                    if (j == valIndex) {
-                        equalsDist.addToValue(i, attValDist.getValue(j));
-                    } else {
-                        notEqualDist.addToValue(i, attValDist.getValue(j));
-                    }
-                }
-            }
-        }
-        return new double[][]{equalsDist.getArrayRef(),
-                    notEqualDist.getArrayRef()};
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    public void observeAttributeTarget(double attVal, double target) {
-        throw new UnsupportedOperationException("Not supported yet.");
-    }
-
-}
diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/NullAttributeClassObserver.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/NullAttributeClassObserver.java
deleted file mode 100644
index 2c5a36e26..000000000
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/NullAttributeClassObserver.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- *    NullAttributeClassObserver.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.core.attributeclassobservers;
-
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.core.ObjectRepository;
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
-/**
- * Class for observing the class data distribution for a null attribute.
- * This method is used to disable the observation for an attribute.
- * Used in decision trees to monitor data statistics on leaves.
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $
- */
-public class NullAttributeClassObserver extends AbstractAttributeClassObserver implements
-        AttributeClassObserver {
-
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public void observeAttributeClass(double attVal, int classVal, double weight) {
-    }
-
-    @Override
-    public double probabilityOfAttributeValueGivenClass(double attVal,
-            int classVal) {
-        return 0.0;
-    }
-
-    public double totalWeightOfClassObservations() {
-        return 0.0;
-    }
-
-    public double weightOfObservedMissingValues() {
-        return 0.0;
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(
-            SplitCriterion criterion, double[] preSplitDist, int attIndex,
-            boolean binaryOnly) {
-        return null;
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    public void observeAttributeTarget(double attVal, double target) {
-        throw new UnsupportedOperationException("Not supported yet.");
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/VFMLNumericAttributeClassObserver.java b/moa/src/main/java/moa/classifiers/core/attributeclassobservers/VFMLNumericAttributeClassObserver.java
deleted file mode 100644
index 720dd0ab3..000000000
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/VFMLNumericAttributeClassObserver.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/*
- *    VFMLNumericAttributeClassObserver.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.core.attributeclassobservers;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.List;
-
-import com.github.javacliparser.IntOption;
-
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.core.DoubleVector;
-import moa.core.ObjectRepository;
-import moa.core.Utils;
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
-/**
- * Class for observing the class data distribution for a numeric attribute as in VFML.
- * Used in naive Bayes and decision trees to monitor data statistics on leaves.
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $
- */
-public class VFMLNumericAttributeClassObserver extends AbstractAttributeClassObserver
-        implements NumericAttributeClassObserver {
-
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public void observeAttributeTarget(double attVal, double target) {
-        throw new UnsupportedOperationException("Not supported yet.");
-    }
-
-    protected class Bin implements Serializable {
-
-        private static final long serialVersionUID = 1L;
-
-        public double lowerBound, upperBound;
-
-        public DoubleVector classWeights = new DoubleVector();
-
-        public int boundaryClass;
-
-        public double boundaryWeight;
-    }
-
-    protected List<Bin> binList = new ArrayList<Bin>();
-
-    public IntOption numBinsOption = new IntOption("numBins", 'n',
-        "The number of bins.", 10, 1, Integer.MAX_VALUE);
-
-
-    @Override
-    public void observeAttributeClass(double attVal, int classVal, double weight) {
-        if (Utils.isMissingValue(attVal)) {
-        } else {
-            if (this.binList.size() < 1) {
-                // create the first bin
-                Bin newBin = new Bin();
-                newBin.classWeights.addToValue(classVal, weight);
-                newBin.boundaryClass = classVal;
-                newBin.boundaryWeight = weight;
-                newBin.upperBound = attVal;
-                newBin.lowerBound = attVal;
-                this.binList.add(newBin);
-            } else {
-                // find bin containing new example with binary search
-                int index = -1;
-                boolean found = false;
-                int min = 0;
-                int max = this.binList.size() - 1;
-                index = 0;
-                while ((min <= max) && !found) {
-                    int i = (min + max) / 2;
-                    Bin bin = this.binList.get(i);
-                    if (((attVal >= bin.lowerBound) && (attVal < bin.upperBound))
-                            || ((i == this.binList.size() - 1)
-                            && (attVal >= bin.lowerBound) && (attVal <= bin.upperBound))) {
-                        found = true;
-                        index = i;
-                    } else if (attVal < bin.lowerBound) {
-                        max = i - 1;
-                    } else {
-                        min = i + 1;
-                    }
-                }
-                boolean first = false;
-                boolean last = false;
-                if (!found) {
-                    // determine if it is before or after the existing range
-                    Bin bin = this.binList.get(0);
-                    if (bin.lowerBound > attVal) {
-                        // go before the first bin
-                        index = 0;
-                        first = true;
-                    } else {
-                        // if we haven't found it yet value must be > last bins
-                        // upperBound
-                        index = this.binList.size() - 1;
-                        last = true;
-                    }
-                }
-                Bin bin = this.binList.get(index); // VLIndex(ct->bins, index);
-                if ((bin.lowerBound == attVal)
-                        || (this.binList.size() >= this.numBinsOption.getValue())) {// Option.getValue())
-                    // {//1000)
-                    // {
-                    // if this is the exact same boundary and class as the bin
-                    // boundary or we aren't adding new bins any more then
-                    // increment
-                    // boundary counts
-                    bin.classWeights.addToValue(classVal, weight);
-                    if ((bin.boundaryClass == classVal)
-                            && (bin.lowerBound == attVal)) {
-                        // if it is also the same class then special case it
-                        bin.boundaryWeight += weight;
-                    }
-                } else {
-                    // create a new bin
-                    Bin newBin = new Bin();
-                    newBin.classWeights.addToValue(classVal, weight);
-                    newBin.boundaryWeight = weight;
-                    newBin.boundaryClass = classVal;
-                    newBin.upperBound = bin.upperBound;
-                    newBin.lowerBound = attVal;
-
-                    double percent = 0.0;
-                    // estimate initial counts with a linear interpolation
-                    if (!((bin.upperBound - bin.lowerBound == 0) || last || first)) {
-                        percent = 1.0 - ((attVal - bin.lowerBound) / (bin.upperBound - bin.lowerBound));
-                    }
-
-                    // take out the boundry points, they stay with the old bin
-                    bin.classWeights.addToValue(bin.boundaryClass,
-                            -bin.boundaryWeight);
-                    DoubleVector weightToShift = new DoubleVector(
-                            bin.classWeights);
-                    weightToShift.scaleValues(percent);
-                    newBin.classWeights.addValues(weightToShift);
-                    bin.classWeights.subtractValues(weightToShift);
-                    // put the boundry examples back in
-                    bin.classWeights.addToValue(bin.boundaryClass,
-                            bin.boundaryWeight);
-
-                    // insert the new bin in the right place
-                    if (last) {
-                        bin.upperBound = attVal;
-                        newBin.upperBound = attVal;
-                        this.binList.add(newBin);
-                    } else if (first) {
-                        newBin.upperBound = bin.lowerBound;
-                        this.binList.add(0, newBin);
-                    } else {
-                        newBin.upperBound = bin.upperBound;
-                        bin.upperBound = attVal;
-                        this.binList.add(index + 1, newBin);
-                    }
-                }
-            }
-        }
-    }
-
-    @Override
-    public double probabilityOfAttributeValueGivenClass(double attVal,
-            int classVal) {
-        // TODO: NaiveBayes broken until implemented
-        return 0.0;
-    }
-
-    @Override
-    public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(
-            SplitCriterion criterion, double[] preSplitDist, int attIndex,
-            boolean binaryOnly) {
-        AttributeSplitSuggestion bestSuggestion = null;
-        DoubleVector rightDist = new DoubleVector();
-        for (Bin bin : this.binList) {
-            rightDist.addValues(bin.classWeights);
-        }
-        DoubleVector leftDist = new DoubleVector();
-        for (Bin bin : this.binList) {
-            leftDist.addValues(bin.classWeights);
-            rightDist.subtractValues(bin.classWeights);
-            double[][] postSplitDists = new double[][]{
-                leftDist.getArrayCopy(), rightDist.getArrayCopy()};
-            double merit = criterion.getMeritOfSplit(preSplitDist,
-                    postSplitDists);
-            if ((bestSuggestion == null) || (merit > bestSuggestion.merit)) {
-                bestSuggestion = new AttributeSplitSuggestion(
-                        new NumericAttributeBinaryTest(attIndex,
-                        bin.upperBound, false), postSplitDists, merit);
-            }
-        }
-        return bestSuggestion;
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-        // TODO Auto-generated method stub
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/core/conditionaltests/InstanceConditionalTest.java b/moa/src/main/java/moa/classifiers/core/conditionaltests/InstanceConditionalTest.java
deleted file mode 100644
index 08f7c7100..000000000
--- a/moa/src/main/java/moa/classifiers/core/conditionaltests/InstanceConditionalTest.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- *    InstanceConditionalTest.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.core.conditionaltests;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
-import moa.AbstractMOAObject;
-
-/**
- * Abstract conditional test for instances to use to split nodes in Hoeffding trees.
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $
- */
-public abstract class InstanceConditionalTest extends AbstractMOAObject {
-
-    /**
-     *  Returns the number of the branch for an instance, -1 if unknown.
-     *
-     * @param inst the instance to be used
-     * @return the number of the branch for an instance, -1 if unknown.
-     */
-    public abstract int branchForInstance(Instance inst);
-
-    /**
-     * Gets whether the number of the branch for an instance is known.
-     *
-     * @param inst
-     * @return true if the number of the branch for an instance is known
-     */
-    public boolean resultKnownForInstance(Instance inst) {
-        return branchForInstance(inst) >= 0;
-    }
-
-    /**
-     * Gets the number of maximum branches, -1 if unknown.
-     *
-     * @return the number of maximum branches, -1 if unknown..
-     */
-    public abstract int maxBranches();
-
-    /**
-     * Gets the text that describes the condition of a branch. It is used to describe the branch.
-     *
-     * @param branch the number of the branch to describe
-     * @param context the context or header of the data stream
-     * @return the text that describes the condition of the branch
-     */
-    public abstract String describeConditionForBranch(int branch,
-            InstancesHeader context);
-
-    /**
-     * Returns an array with the attributes that the test depends on.
-     *
-     * @return  an array with the attributes that the test depends on
-     */
-    public abstract int[] getAttsTestDependsOn();
-}
diff --git a/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeBinaryTest.java b/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeBinaryTest.java
deleted file mode 100644
index 62f1e73bc..000000000
--- a/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeBinaryTest.java
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- *    NominalAttributeBinaryTest.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.core.conditionaltests;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
-/**
- * Nominal binary conditional test for instances to use to split nodes in Hoeffding trees.
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $
- */
-public class NominalAttributeBinaryTest extends InstanceConditionalBinaryTest {
-
-    private static final long serialVersionUID = 1L;
-
-    protected int attIndex;
-
-    protected int attValue;
-
-    public NominalAttributeBinaryTest(int attIndex, int attValue) {
-        this.attIndex = attIndex;
-        this.attValue = attValue;
-    }
-
-    @Override
-    public int branchForInstance(Instance inst) {
-        int instAttIndex = this.attIndex < inst.classIndex() ? this.attIndex
-                : this.attIndex + 1;
-        return inst.isMissing(instAttIndex) ? -1 : ((int) inst.value(instAttIndex) == this.attValue ? 0 : 1);
-    }
-
-    @Override
-    public String describeConditionForBranch(int branch, InstancesHeader context) {
-        if ((branch == 0) || (branch == 1)) {
-            return InstancesHeader.getInputAttributeNameString(context,
-                    this.attIndex)
-                    + (branch == 0 ? " = " : " != ")
-                    + InstancesHeader.getNominalValueString(context,
-                    this.attIndex, this.attValue);
-        }
-        throw new IndexOutOfBoundsException();
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    public int[] getAttsTestDependsOn() {
-        return new int[]{this.attIndex};
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java b/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
deleted file mode 100644
index ca81135f5..000000000
--- a/moa/src/main/java/moa/classifiers/core/conditionaltests/NumericAttributeBinaryTest.java
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- *    NumericAttributeBinaryTest.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.core.conditionaltests;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
-/**
- * Numeric binary conditional test for instances to use to split nodes in Hoeffding trees.
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $
- */
-public class NumericAttributeBinaryTest extends InstanceConditionalBinaryTest {
-
-    private static final long serialVersionUID = 1L;
-
-    protected int attIndex;
-
-    protected double attValue;
-
-    protected boolean equalsPassesTest;
-
-    public NumericAttributeBinaryTest(int attIndex, double attValue,
-            boolean equalsPassesTest) {
-        this.attIndex = attIndex;
-        this.attValue = attValue;
-        this.equalsPassesTest = equalsPassesTest;
-    }
-
-    @Override
-    public int branchForInstance(Instance inst) {
-        int instAttIndex = this.attIndex ; // < inst.classIndex() ? this.attIndex
-               // : this.attIndex + 1;
-        if (inst.isMissing(instAttIndex)) {
-            return -1;
-        }
-        double v = inst.valueInputAttribute(instAttIndex); // if the attIndex is not calculated above this is the correct method call
-        if (v == this.attValue) {
-            return this.equalsPassesTest ? 0 : 1;
-        }
-        return v < this.attValue ? 0 : 1;
-    }
-
-    @Override
-    public String describeConditionForBranch(int branch, InstancesHeader context) {
-        if ((branch == 0) || (branch == 1)) {
-            char compareChar = branch == 0 ? '<' : '>';
-            int equalsBranch = this.equalsPassesTest ? 0 : 1;
-            return InstancesHeader.getInputAttributeNameString(context,
-                    this.attIndex)
-                    + ' '
-                    + compareChar
-                    + (branch == equalsBranch ? "= " : " ")
-                    + InstancesHeader.getNumericValueString(context,
-                    this.attIndex, this.attValue);
-        }
-        throw new IndexOutOfBoundsException();
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    public int[] getAttsTestDependsOn() {
-        return new int[]{this.attIndex};
-    }
-
-    public double getSplitValue() {
-        return this.attValue;
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/ADWIN.java b/moa/src/main/java/moa/classifiers/core/driftdetection/ADWIN.java
deleted file mode 100644
index 93fc64692..000000000
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/ADWIN.java
+++ /dev/null
@@ -1,608 +0,0 @@
-/*
- *    ADWIN.java
- *    Copyright (C) 2008 UPC-Barcelona Tech, Catalonia
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.core.driftdetection;
-
-import moa.AbstractMOAObject;
-
-/**
- * ADaptive sliding WINdow method. This method is a change detector and estimator.
- * It keeps a variable-length window of recently seen
- * items, with the property that the window has the maximal length statistically
- * consistent with the hypothesis "there has been no change in the average value
- * inside the window".
- *
- *
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @version $Revision: 7 $
- */
-public class ADWIN extends AbstractMOAObject {
-
-    private class List extends AbstractMOAObject {
-
-        protected int count;
-
-        protected ListItem head;
-
-        protected ListItem tail;
-
-        public List() {
-//			post: initializes the list to be empty.
-            clear();
-            addToHead();
-        }
-
-        /* Interface Store Methods */
-        public int size() {
-            //	post: returns the number of elements in the list.
-            return this.count;
-        }
-
-        public ListItem head() {
-            //	post: returns the number of elements in the list.
-            return this.head;
-        }
-
-        public ListItem tail() {
-            //	post: returns the number of elements in the list.
-            return this.tail;
-        }
-
-        public boolean isEmpty() {
-            //	 post: returns the true iff store is empty.
-            return (this.size() == 0);
-        }
-
-        public void clear() {
-            //	 post: clears the list so that it contains no elements.
-            this.head = null;
-            this.tail = null;
-            this.count = 0;
-        }
-
-        /* Interface List Methods */
-        public void addToHead() {
-            //	 pre: anObject is non-null
-            //	 post: the object is added to the beginning of the list
-            this.head = new ListItem(this.head, null);
-            if (this.tail == null) {
-                this.tail = this.head;
-            }
-            this.count++;
-        }
-
-        public void removeFromHead() {
-            //		 pre: list is not empty
-            //		 post: removes and returns first object from the list
-//			ListItem temp;
-//			temp = this.head;
-            this.head = this.head.next();
-            if (this.head != null) {
-                this.head.setPrevious(null);
-            } else {
-                this.tail = null;
-            }
-            this.count--;
-            //temp=null;
-            return;
-        }
-
-        public void addToTail() {
-//			pre: anObject is non-null
-//			post: the object is added at the end of the list
-            this.tail = new ListItem(null, this.tail);
-            if (this.head == null) {
-                this.head = this.tail;
-            }
-            this.count++;
-        }
-
-        public void removeFromTail() {
-//			pre: list is not empty
-//			post: the last object in the list is removed and returned
-//			ListItem temp;
-//			temp = this.tail;
-            this.tail = this.tail.previous();
-            if (this.tail == null) {
-                this.head = null;
-            } else {
-                this.tail.setNext(null);
-            }
-            this.count--;
-            //temp=null;
-            return;
-        }
-
-        @Override
-        public void getDescription(StringBuilder sb, int indent) {
-        }
-    }
-
-    private class ListItem extends AbstractMOAObject {
-//		protected Object data;
-
-        protected ListItem next;
-
-        protected ListItem previous;
-
-        protected int bucketSizeRow = 0;
-
-        protected int MAXBUCKETS = ADWIN.MAXBUCKETS;
-
-        protected double bucketTotal[] = new double[MAXBUCKETS + 1];
-
-        protected double bucketVariance[] = new double[MAXBUCKETS + 1];
-
-        public ListItem() {
-//			post: initializes the node to be a tail node
-//			containing the given value.
-            this(null, null);
-        }
-
-        public void clear() {
-            bucketSizeRow = 0;
-            for (int k = 0; k <= MAXBUCKETS; k++) {
-                clearBucket(k);
-            }
-        }
-
-        private void clearBucket(int k) {
-            setTotal(0, k);
-            setVariance(0, k);
-        }
-
-        public ListItem(ListItem nextNode, ListItem previousNode) {
-//			post: initializes the node to contain the given
-//			object and link to the given next node.
-            //this.data = element;
-            this.next = nextNode;
-            this.previous = previousNode;
-            if (nextNode != null) {
-                nextNode.previous = this;
-            }
-            if (previousNode != null) {
-                previousNode.next = this;
-            }
-            clear();
-        }
-
-        public void insertBucket(double Value, double Variance) {
-//			insert a Bucket at the end
-            int k = bucketSizeRow;
-            bucketSizeRow++;
-            //Insert new bucket
-            setTotal(Value, k);
-            setVariance(Variance, k);
-        }
-
-        public void RemoveBucket() {
-//			Removes the first Buvket
-            compressBucketsRow(1);
-        }
-
-        public void compressBucketsRow(int NumberItemsDeleted) {
-            //Delete first elements
-            for (int k = NumberItemsDeleted; k <= MAXBUCKETS; k++) {
-                bucketTotal[k - NumberItemsDeleted] = bucketTotal[k];
-                bucketVariance[k - NumberItemsDeleted] = bucketVariance[k];
-            }
-            for (int k = 1; k <= NumberItemsDeleted; k++) {
-                clearBucket(MAXBUCKETS - k + 1);
-            }
-            bucketSizeRow -= NumberItemsDeleted;
-            //BucketNumber-=NumberItemsDeleted;
-        }
-
-        public ListItem previous() {
-//			post: returns the previous node.
-            return this.previous;
-        }
-
-        public void setPrevious(ListItem previous) {
-//			post: sets the previous node to be the given node
-            this.previous = previous;
-        }
-
-        public ListItem next() {
-//			post: returns the next node.
-            return this.next;
-        }
-
-        public void setNext(ListItem next) {
-//			post: sets the next node to be the given node
-            this.next = next;
-        }
-
-        public double Total(int k) {
-//			post: returns the element in this node
-            return bucketTotal[k];
-        }
-
-        public double Variance(int k) {
-//			post: returns the element in this node
-            return bucketVariance[k];
-        }
-
-        public void setTotal(double value, int k) {
-//			post: sets the element in this node to the given
-//			object.
-            bucketTotal[k] = value;
-        }
-
-        public void setVariance(double value, int k) {
-//			post: sets the element in this node to the given
-//			object.
-            bucketVariance[k] = value;
-        }
-        /*
-        public ListItem(Object element,
-        ListItem nextNode){
-        //		post: initializes the node to contain the given
-        //		 object and link to the given next node.
-        this.data = element;
-        this.next = nextNode;
-        }
-        public ListItem(Object element) {
-        //		post: initializes the node to be a tail node
-        //		 containing the given value.
-        this(element, null);
-        }
-
-
-        public Object value() {
-        //			 post: returns the element in this node
-        return this.data;
-        }
-        public void setValue(Object anObject) {
-        //			 post: sets the element in this node to the given
-        //			 object.
-        this.data = anObject;
-        }
-         */
-
-        @Override
-        public void getDescription(StringBuilder sb, int indent) {
-        }
-    }
-
-    public static final double DELTA = .002; //.1;
-
-    private static final int mintMinimLongitudWindow = 10; //10
-
-    private double mdbldelta = .002; //.1;
-
-    private int mintTime = 0;
-
-    private int mintClock = 32;
-
-    private double mdblWidth = 0; // Mean of Width = mdblWidth/Number of items
-    //BUCKET
-
-    public static final int MAXBUCKETS = 5;
-
-    private int lastBucketRow = 0;
-
-    private double TOTAL = 0;
-
-    private double VARIANCE = 0;
-
-    private int WIDTH = 0;
-
-    private int BucketNumber = 0;
-
-    private int Detect = 0;
-
-    private int numberDetections = 0;
-
-    private int DetectTwice = 0;
-
-    private boolean blnBucketDeleted = false;
-
-    private int BucketNumberMAX = 0;
-
-    private int mintMinWinLength = 5;
-
-    private List listRowBuckets;
-
-    public boolean getChange() {
-        return blnBucketDeleted;
-    }
-
-    public void resetChange() {
-        blnBucketDeleted = false;
-    }
-
-    public int getBucketsUsed() {
-        return BucketNumberMAX;
-    }
-
-    public int getWidth() {
-        return WIDTH;
-    }
-
-    public void setClock(int intClock) {
-        mintClock = intClock;
-    }
-
-    public int getClock() {
-        return mintClock;
-    }
-
-    public boolean getWarning() {
-        return false;
-    }
-
-    public boolean getDetect() {
-        return (Detect == mintTime);
-    }
-
-    public int getNumberDetections() {
-        return numberDetections;
-    }
-
-    public double getTotal() {
-        return TOTAL;
-    }
-
-    public double getEstimation() {
-        return TOTAL / WIDTH;
-    }
-
-    public double getVariance() {
-        return VARIANCE / WIDTH;
-    }
-
-    public double getWidthT() {
-        return mdblWidth;
-    }
-
-    private void initBuckets() {
-        //Init buckets
-        listRowBuckets = new List();
-        lastBucketRow = 0;
-        TOTAL = 0;
-        VARIANCE = 0;
-        WIDTH = 0;
-        BucketNumber = 0;
-    }
-
-    private void insertElement(double Value) {
-        WIDTH++;
-        insertElementBucket(0, Value, listRowBuckets.head());
-        double incVariance = 0;
-        if (WIDTH > 1) {
-            incVariance = (WIDTH - 1) * (Value - TOTAL / (WIDTH - 1)) * (Value - TOTAL / (WIDTH - 1)) / WIDTH;
-        }
-        VARIANCE += incVariance;
-        TOTAL += Value;
-        compressBuckets();
-    }
-
-    private void insertElementBucket(double Variance, double Value, ListItem Node) {
-        //Insert new bucket
-        Node.insertBucket(Value, Variance);
-        BucketNumber++;
-        if (BucketNumber > BucketNumberMAX) {
-            BucketNumberMAX = BucketNumber;
-        }
-    }
-
-    private int bucketSize(int Row) {
-        return (int) Math.pow(2, Row);
-    }
-
-    public int deleteElement() {
-        //LIST
-        //Update statistics
-        ListItem Node;
-        Node = listRowBuckets.tail();
-        int n1 = bucketSize(lastBucketRow);
-        WIDTH -= n1;
-        TOTAL -= Node.Total(0);
-        double u1 = Node.Total(0) / n1;
-        double incVariance = Node.Variance(0) + n1 * WIDTH * (u1 - TOTAL / WIDTH) * (u1 - TOTAL / WIDTH) / (n1 + WIDTH);
-        VARIANCE -= incVariance;
-
-        //Delete Bucket
-        Node.RemoveBucket();
-        BucketNumber--;
-        if (Node.bucketSizeRow == 0) {
-            listRowBuckets.removeFromTail();
-            lastBucketRow--;
-        }
-        return n1;
-    }
-
-    public void compressBuckets() {
-        //Traverse the list of buckets in increasing order
-        int n1, n2;
-        double u2, u1, incVariance;
-        ListItem cursor;
-        ListItem nextNode;
-        cursor = listRowBuckets.head();
-        int i = 0;
-        do {
-            //Find the number of buckets in a row
-            int k = cursor.bucketSizeRow;
-            //If the row is full, merge buckets
-            if (k == MAXBUCKETS + 1) {
-                nextNode = cursor.next();
-                if (nextNode == null) {
-                    listRowBuckets.addToTail();
-                    nextNode = cursor.next();
-                    lastBucketRow++;
-                }
-                n1 = bucketSize(i);
-                n2 = bucketSize(i);
-                u1 = cursor.Total(0) / n1;
-                u2 = cursor.Total(1) / n2;
-                incVariance = n1 * n2 * (u1 - u2) * (u1 - u2) / (n1 + n2);
-
-                nextNode.insertBucket(cursor.Total(0) + cursor.Total(1), cursor.Variance(0) + cursor.Variance(1) + incVariance);
-                BucketNumber++;
-                cursor.compressBucketsRow(2);
-                if (nextNode.bucketSizeRow <= MAXBUCKETS) {
-                    break;
-                }
-            } else {
-                break;
-            }
-            cursor = cursor.next();
-            i++;
-        } while (cursor != null);
-    }
-
-    public boolean setInput(double intEntrada) {
-        return setInput(intEntrada, mdbldelta);
-    }
-
-    public boolean setInput(double intEntrada, double delta) {
-        boolean blnChange = false;
-        boolean blnExit = false;
-        ListItem cursor;
-        mintTime++;
-
-        //1,2)Increment window in one element
-        insertElement(intEntrada);
-        blnBucketDeleted = false;
-        //3)Reduce  window
-        if (mintTime % mintClock == 0 && getWidth() > mintMinimLongitudWindow) {
-            boolean blnReduceWidth = true; // Diference
-
-            while (blnReduceWidth) // Diference
-            {
-                blnReduceWidth = false; // Diference
-                blnExit = false;
-                int n0 = 0;
-                int n1 = WIDTH;
-                double u0 = 0;
-                double u1 = getTotal();
-                double v0 = 0;
-                double v1 = VARIANCE;
-                double n2 = 0;
-                double u2 = 0;
-
-                cursor = listRowBuckets.tail();
-                int i = lastBucketRow;
-                do {
-                    for (int k = 0; k <= (cursor.bucketSizeRow - 1); k++) {
-                        n2 = bucketSize(i);
-                        u2 = cursor.Total(k);
-                        if (n0 > 0) {
-                            v0 += cursor.Variance(k) + (double) n0 * n2 * (u0 / n0 - u2 / n2) * (u0 / n0 - u2 / n2) / (n0 + n2);
-                        }
-                        if (n1 > 0) {
-                            v1 -= cursor.Variance(k) + (double) n1 * n2 * (u1 / n1 - u2 / n2) * (u1 / n1 - u2 / n2) / (n1 + n2);
-                        }
-
-                        n0 += bucketSize(i);
-                        n1 -= bucketSize(i);
-                        u0 += cursor.Total(k);
-                        u1 -= cursor.Total(k);
-
-                        if (i == 0 && k == cursor.bucketSizeRow - 1) {
-                            blnExit = true;
-                            break;
-                        }
-                        double absvalue = (double) (u0 / n0) - (u1 / n1);       //n1<WIDTH-mintMinWinLength-1
-                        if ((n1 > mintMinWinLength + 1 && n0 > mintMinWinLength + 1) && // Diference NEGATIVE
-                                //if(
-                                blnCutexpression(n0, n1, u0, u1, v0, v1, absvalue, delta)) {
-                            blnBucketDeleted = true;
-                            Detect = mintTime;
-
-                            if (Detect == 0) {
-                                Detect = mintTime;
-                                //blnFirst=true;
-                                //blnWarning=true;
-                            } else if (DetectTwice == 0) {
-                                DetectTwice = mintTime;
-                                //blnDetect=true;
-                            }
-                            blnReduceWidth = true; // Diference
-                            blnChange = true;
-                            if (getWidth() > 0) { //Reduce width of the window
-                                //while (n0>0)  // Diference NEGATIVE
-                                n0 -= deleteElement();
-                                blnExit = true;
-                                break;
-                            }
-                        } //End if
-                    }//Next k
-                    cursor = cursor.previous();
-                    i--;
-                } while (((!blnExit && cursor != null)));
-            }//End While // Diference
-        }//End if
-
-        mdblWidth += getWidth();
-        if (blnChange) {
-            numberDetections++;
-        }
-        return blnChange;
-    }
-
-    private boolean blnCutexpression(int n0, int n1, double u0, double u1, double v0, double v1, double absvalue, double delta) {
-        int n = getWidth();
-        double dd = Math.log(2 * Math.log(n) / delta);     // -- ull perque el ln n va al numerador.
-        // Formula Gener 2008
-        double v = getVariance();
-        double m = ((double) 1 / ((n0 - mintMinWinLength + 1))) + ((double) 1 / ((n1 - mintMinWinLength + 1)));
-        double epsilon = Math.sqrt(2 * m * v * dd) + (double) 2 / 3 * dd * m;
-
-        return (Math.abs(absvalue) > epsilon);
-    }
-
-    public ADWIN() {
-        mdbldelta = DELTA;
-        initBuckets();
-        Detect = 0;
-        numberDetections = 0;
-        DetectTwice = 0;
-
-    }
-
-    public ADWIN(double d) {
-        mdbldelta = d;
-        initBuckets();
-        Detect = 0;
-        numberDetections = 0;
-        DetectTwice = 0;
-    }
-
-    public ADWIN(int cl) {
-        mdbldelta = DELTA;
-        initBuckets();
-        Detect = 0;
-        numberDetections = 0;
-        DetectTwice = 0;
-        mintClock = cl;
-    }
-
-    public String getEstimatorInfo() {
-        return "ADWIN;;";
-    }
-
-    public void setW(int W0) {
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/AbstractChangeDetector.java b/moa/src/main/java/moa/classifiers/core/driftdetection/AbstractChangeDetector.java
deleted file mode 100644
index e46a71a1f..000000000
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/AbstractChangeDetector.java
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
- *    AbstractChangeDetector.java
- *    Copyright (C) 2011 University of Waikato, Hamilton, New Zealand
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package moa.classifiers.core.driftdetection;
-
-import moa.options.AbstractOptionHandler;
-
-/**
- * Abstract Change Detector. All change detectors in MOA extend this class.
- *
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @version $Revision: 7 $
- */
-public abstract class AbstractChangeDetector extends AbstractOptionHandler
-        implements ChangeDetector {
-
-
-
-    /**
-     * Change was detected
-     */
-    protected boolean isChangeDetected;
-
-    /**
-     * Warning Zone: after a warning and before a change 
-     */
-    protected boolean isWarningZone;
-
-    /**
-     * Prediction for the next value based in previous seen values
-     */
-    protected double estimation;
-
-    /**
-     * Delay in detecting change
-     */
-    protected double delay;
-
-    /**
-     * The change detector has been initialized with the option values
-     */
-    protected boolean isInitialized;
-
-    /**
-     * Resets this change detector. It must be similar to starting a new change
-     * detector from scratch.
-     *
-     */
-    public void resetLearning() {
-        this.isChangeDetected = false;
-        this.isWarningZone = false;
-        this.estimation = 0.0;
-        this.delay = 0.0;
-        this.isInitialized = false;
-    }
-
-    /**
-     * Adding a numeric value to the change detector<br><br>
-     *
-     * The output of the change detector is modified after the insertion of a
-     * new item inside.
-     *
-     * @param inputValue the number to insert into the change detector
-     */
-    public abstract void input(double inputValue);
-
-    /**
-     * Gets whether there is change detected.
-     *
-     * @return true if there is change
-     */
-    public boolean getChange() {
-        return this.isChangeDetected;
-    }
-
-    /**
-     * Gets whether the change detector is in the warning zone, after a warning
-     * alert and before a change alert.
-     *
-     * @return true if the change detector is in the warning zone
-     */
-    public boolean getWarningZone() {
-        return this.isWarningZone;
-    }
-
-    /**
-     * Gets the prediction of next values.
-     *
-     * @return a prediction of the next value
-     */
-    public double getEstimation() {
-        return this.estimation;
-    }
-
-    /**
-     * Gets the length of the delay in the change detected.
-     *
-     * @return he length of the delay in the change detected
-     */
-    public double getDelay() {
-        return this.delay;
-    }
-
-    /**
-     * Gets the output state of the change detection.
-     *
-     * @return an array with the number of change detections, number of
-     * warnings, delay, and estimation.
-     */
-    public double[] getOutput() {
-        double[] res = {this.isChangeDetected ? 1 : 0, this.isWarningZone ? 1 : 0, this.delay, this.estimation};
-        return res;
-    }
-
-    /**
-     * Returns a string representation of the model.
-     *
-     * @param out	the stringbuilder to add the description
-     * @param indent	the number of characters to indent
-     */
-    @Override
-    public abstract void getDescription(StringBuilder sb, int indent);
-
-    /**
-     * Produces a copy of this change detector method
-     *
-     * @return the copy of this change detector method
-     */
-    @Override
-    public ChangeDetector copy() {
-        return (ChangeDetector) super.copy();
-    }
-}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/ChangeDetector.java b/moa/src/main/java/moa/classifiers/core/driftdetection/ChangeDetector.java
deleted file mode 100644
index 6a6e97b18..000000000
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/ChangeDetector.java
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- *    ChangeDetector.java
- *    Copyright (C) 2011 University of Waikato, Hamilton, New Zealand
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package moa.classifiers.core.driftdetection;
-
-import moa.options.OptionHandler;
-
-/**
- *  Change Detector interface to implement methods that detects change.
- *
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @version $Revision: 7 $
- */
-public interface ChangeDetector extends OptionHandler {
-
-    /**
-     * Resets this change detector. It must be similar to starting a new change
-     * detector from scratch.
-     *
-     */
-    public void resetLearning();
-
-    /**
-     * Adding a numeric value to the change detector<br><br>
-     *
-     * The output of the change detector is modified after the insertion of a
-     * new item inside.
-     *
-     * @param inputValue the number to insert into the change detector
-     */
-    public void input(double inputValue);
-
-    /**
-     * Gets whether there is change detected.
-     *
-     * @return true if there is change
-     */
-    public boolean getChange();
-
-    /**
-     * Gets whether the change detector is in the warning zone, after a warning alert and before a change alert.
-     *
-     * @return true if the change detector is in the warning zone
-     */
-    public boolean getWarningZone();
-
-    /**
-     * Gets the prediction of next values.
-     *
-     * @return a prediction of the next value
-     */
-    public double getEstimation();
-
-    /**
-     * Gets the length of the delay in the change detected.
-     *
-     * @return he length of the delay in the change detected
-     */
-    public double getDelay();
-
-    /**
-     * Gets the output state of the change detection.
-     *
-     * @return an array with the number of change detections, number of
-     * warnings, delay, and estimation.
-     */
-    public double[] getOutput();
-
-    /**
-     * Returns a string representation of the model.
-     *
-     * @param out	the stringbuilder to add the description
-     * @param indent	the number of characters to indent
-     */
-    @Override
-    public void getDescription(StringBuilder sb, int indent);
-
-    /**
-     * Produces a copy of this drift detection method
-     *
-     * @return the copy of this drift detection method
-     */
-    @Override
-    public ChangeDetector copy();
-}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/CusumDM.java b/moa/src/main/java/moa/classifiers/core/driftdetection/CusumDM.java
deleted file mode 100644
index 8653a1007..000000000
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/CusumDM.java
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
- *    DDM.java
- *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
- *    @author Manuel Baena (mbaena@lcc.uma.es)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package moa.classifiers.core.driftdetection;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-
-import moa.core.ObjectRepository;
-import moa.tasks.TaskMonitor;
-
-/**
- * Drift detection method based in Cusum
- *
- *
- * @author Manuel Baena (mbaena@lcc.uma.es)
- * @version $Revision: 7 $
- */
-public class CusumDM extends AbstractChangeDetector {
-
-    private static final long serialVersionUID = -3518369648142099719L;
-
-    public IntOption minNumInstancesOption = new IntOption(
-            "minNumInstances",
-            'n',
-            "The minimum number of instances before permitting detecting change.",
-            30, 0, Integer.MAX_VALUE);
-
-    public FloatOption deltaOption = new FloatOption("delta", 'd',
-            "Delta parameter of the Cusum Test", 0.005, 0.0, 1.0);
-
-    public FloatOption lambdaOption = new FloatOption("lambda", 'l',
-            "Threshold parameter of the Cusum Test", 50, 0.0, Float.MAX_VALUE);
-
-    private int m_n;
-
-    private double sum;
-
-    private double x_mean;
-
-    private double alpha;
-
-    private double delta;
-
-    private double lambda;
-
-    public CusumDM() {
-        resetLearning();
-    }
-
-    @Override
-    public void resetLearning() {
-        m_n = 1;
-        x_mean = 0.0;
-        sum = 0.0;
-        delta = this.deltaOption.getValue();
-        lambda = this.lambdaOption.getValue();
-    }
-
-    @Override
-    public void input(double x) {
-        // It monitors the error rate
-        if (this.isChangeDetected == true || this.isInitialized == false) {
-            resetLearning();
-            this.isInitialized = true;
-        }
-
-        x_mean = x_mean + (x - x_mean) / (double) m_n;
-        sum = Math.max(0, sum + x - x_mean - this.delta);
-
-        
-
-
-        m_n++;
-
-        // System.out.print(prediction + " " + m_n + " " + (m_p+m_s) + " ");
-        this.estimation = x_mean;
-        this.isChangeDetected = false;
-        this.isWarningZone = false;
-        this.delay = 0;
-
-        if (m_n < this.minNumInstancesOption.getValue()) {
-            return;
-        }
-
-        if (sum > this.lambda) {
-            this.isChangeDetected = true;
-        } 
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        // TODO Auto-generated method stub
-    }
-}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/DDM.java b/moa/src/main/java/moa/classifiers/core/driftdetection/DDM.java
deleted file mode 100644
index c0b8e3fd8..000000000
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/DDM.java
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
- *    DDM.java
- *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
- *    @author Manuel Baena (mbaena@lcc.uma.es)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package moa.classifiers.core.driftdetection;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-
-import moa.core.ObjectRepository;
-import moa.tasks.TaskMonitor;
-
-/**
- *  Drift detection method based in DDM method of Joao Gama SBIA 2004.
- *
- *  <p>João Gama, Pedro Medas, Gladys Castillo, Pedro Pereira Rodrigues: Learning
- * with Drift Detection. SBIA 2004: 286-295 </p>
- *
- *  @author Manuel Baena (mbaena@lcc.uma.es)
- *  @version $Revision: 7 $
- */
-public class DDM extends AbstractChangeDetector {
-
-    private static final long serialVersionUID = -3518369648142099719L;
-
-    //private static final int DDM_MINNUMINST = 30;
-    public IntOption minNumInstancesOption = new IntOption(
-            "minNumInstances",
-            'n',
-            "The minimum number of instances before permitting detecting change.",
-            30, 0, Integer.MAX_VALUE);
-    
-    public FloatOption warningLevelOption = new FloatOption(
-            "warningLevel", 'w', "Warning Level.",
-            2.0, 1.0, 4.0);
-        
-    public FloatOption outcontrolLevelOption = new FloatOption(
-            "outcontrolLevel", 'o', "Outcontrol Level.",
-            3.0, 1.0, 5.0);
-    
-    private int m_n;
-
-    private int minNumInstances;
-
-    private double m_p;
-
-    private double m_s;
-
-    private double m_psmin;
-
-    private double m_pmin;
-
-    private double m_smin;
-
-    private double warningLevel;
-
-    private double outcontrolLevel;
-
-    public DDM() {
-        resetLearning();
-    }
-
-    @Override
-    public void resetLearning() {
-        m_n = 1;
-        m_p = 1;
-        m_s = 0;
-        m_psmin = Double.MAX_VALUE;
-        m_pmin = Double.MAX_VALUE;
-        m_smin = Double.MAX_VALUE;
-        minNumInstances = this.minNumInstancesOption.getValue();
-        warningLevel = this.warningLevelOption.getValue();
-        outcontrolLevel = this.outcontrolLevelOption.getValue();
-    }
-
-    @Override
-    public void input(double prediction) {
-        // prediction must be 1 or 0
-        // It monitors the error rate
-        if (this.isChangeDetected == true || this.isInitialized == false) {
-            resetLearning();
-            this.isInitialized = true;
-        }
-        m_p = m_p + (prediction - m_p) / (double) m_n;
-        m_s = Math.sqrt(m_p * (1 - m_p) / (double) m_n);
-
-        m_n++;
-
-        // System.out.print(prediction + " " + m_n + " " + (m_p+m_s) + " ");
-        this.estimation = m_p;
-        this.isChangeDetected = false;
-        this.isWarningZone = false;
-        this.delay = 0;
-
-        if (m_n < minNumInstances) {
-            return;
-        }
-
-        if (m_p + m_s <= m_psmin) {
-            m_pmin = m_p;
-            m_smin = m_s;
-            m_psmin = m_p + m_s;
-        }
-
-        if (m_n > minNumInstances && m_p + m_s > m_pmin + outcontrolLevel * m_smin) {
-            //System.out.println(m_p + ",D");
-            this.isChangeDetected = true;
-            //resetLearning();
-        } else if (m_p + m_s > m_pmin + warningLevel * m_smin) {
-            //System.out.println(m_p + ",W");
-            this.isWarningZone = true;
-        } else {
-            this.isWarningZone = false;
-            //System.out.println(m_p + ",N");
-        }
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        // TODO Auto-generated method stub
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/EDDM.java b/moa/src/main/java/moa/classifiers/core/driftdetection/EDDM.java
deleted file mode 100644
index 2e21adc71..000000000
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/EDDM.java
+++ /dev/null
@@ -1,159 +0,0 @@
-/*
- *    EDDM.java
- *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
- *    @author Manuel Baena (mbaena@lcc.uma.es)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package moa.classifiers.core.driftdetection;
-
-import moa.core.ObjectRepository;
-import moa.tasks.TaskMonitor;
-
-/**
- * Drift detection method based in EDDM method of Manuel Baena et al.
- *
- * <p>Early Drift Detection Method. Manuel Baena-Garcia, Jose Del Campo-Avila,
- * Raúl Fidalgo, Albert Bifet, Ricard Gavalda, Rafael Morales-Bueno. In Fourth
- * International Workshop on Knowledge Discovery from Data Streams, 2006.</p>
- *
- * @author Manuel Baena (mbaena@lcc.uma.es)
- * @version $Revision: 7 $
- */
-public class EDDM extends AbstractChangeDetector {
-
-    /**
-     *
-     */
-    private static final long serialVersionUID = 140980267062162000L;
-
-    private static final double FDDM_OUTCONTROL = 0.9;
-
-    private static final double FDDM_WARNING = 0.95;
-
-    private static final double FDDM_MINNUMINSTANCES = 30;
-
-    private double m_numErrors;
-
-    private int m_minNumErrors = 30;
-
-    private int m_n;
-
-    private int m_d;
-
-    private int m_lastd;
-
-    private double m_mean;
-
-    private double m_stdTemp;
-
-    private double m_m2smax;
-
-    private int m_lastLevel;
-
-    public EDDM() {
-        resetLearning();
-    }
-
-    @Override
-    public void resetLearning() {
-        m_n = 1;
-        m_numErrors = 0;
-        m_d = 0;
-        m_lastd = 0;
-        m_mean = 0.0;
-        m_stdTemp = 0.0;
-        m_m2smax = 0.0;
-        //m_lastLevel = DDM_INCONTROL_LEVEL;
-        this.estimation = 0.0;
-    }
-
-    @Override
-    public void input(double prediction) {
-        // prediction must be 1 or 0
-        // It monitors the error rate
-        // System.out.print(prediction + " " + m_n + " " + probability + " ");
-        if (this.isChangeDetected == true || this.isInitialized == false) {
-            resetLearning();
-            this.isInitialized = true;
-        }
-        
-        this.isChangeDetected = false;
-        
-        m_n++;
-        if (prediction == 1.0) {
-            this.isWarningZone = false;
-            this.delay = 0;
-            m_numErrors += 1;
-            m_lastd = m_d;
-            m_d = m_n - 1;
-            int distance = m_d - m_lastd;
-            double oldmean = m_mean;
-            m_mean = m_mean + ((double) distance - m_mean) / m_numErrors;
-            this.estimation = m_mean;
-            m_stdTemp = m_stdTemp + (distance - m_mean) * (distance - oldmean);
-            double std = Math.sqrt(m_stdTemp / m_numErrors);
-            double m2s = m_mean + 2 * std;
-
-            // System.out.print(m_numErrors + " " + m_mean + " " + std + " " +
-            // m2s + " " + m_m2smax + " ");
-
-            if (m2s > m_m2smax) {
-                if (m_n > FDDM_MINNUMINSTANCES) {
-                    m_m2smax = m2s;
-                }
-                //m_lastLevel = DDM_INCONTROL_LEVEL;
-                // System.out.print(1 + " ");
-            } else {
-                double p = m2s / m_m2smax;
-                // System.out.print(p + " ");
-                if (m_n > FDDM_MINNUMINSTANCES && m_numErrors > m_minNumErrors
-                        && p < FDDM_OUTCONTROL) {
-                    //System.out.println(m_mean + ",D");
-                    this.isChangeDetected = true;
-                    //resetLearning();
-                    //return DDM_OUTCONTROL_LEVEL;
-                } else if (m_n > FDDM_MINNUMINSTANCES
-                        && m_numErrors > m_minNumErrors && p < FDDM_WARNING) {
-                    //System.out.println(m_mean + ",W");
-                    //m_lastLevel = DDM_WARNING_LEVEL;
-                    this.isWarningZone = true;
-                    //return DDM_WARNING_LEVEL;
-                } else {
-                    this.isWarningZone = false;
-                    //System.out.println(m_mean + ",N");
-                    //m_lastLevel = DDM_INCONTROL_LEVEL;
-                    //return DDM_INCONTROL_LEVEL;
-                }
-            }
-        } else {
-            // System.out.print(m_numErrors + " " + m_mean + " " +
-            // Math.sqrt(m_stdTemp/m_numErrors) + " " + (m_mean +
-            // 2*Math.sqrt(m_stdTemp/m_numErrors)) + " " + m_m2smax + " ");
-            // System.out.print(((m_mean +
-            // 2*Math.sqrt(m_stdTemp/m_numErrors))/m_m2smax) + " ");
-        }
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        // TODO Auto-generated method stub
-    }
-}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/EWMAChartDM.java b/moa/src/main/java/moa/classifiers/core/driftdetection/EWMAChartDM.java
deleted file mode 100644
index 83b5c4981..000000000
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/EWMAChartDM.java
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- *    EWMAChartDM.java
- *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
- *    @author Manuel Baena (mbaena@lcc.uma.es)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package moa.classifiers.core.driftdetection;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-
-import moa.core.ObjectRepository;
-import moa.tasks.TaskMonitor;
-
-/**
- * Drift detection method based in EWMA Charts of Ross, Adams, Tasoulis and Hand
- * 2012
- *
- *
- * @author Manuel Baena (mbaena@lcc.uma.es)
- * @version $Revision: 7 $
- */
-public class EWMAChartDM extends AbstractChangeDetector {
-
-    private static final long serialVersionUID = -3518369648142099719L;
-
-    //private static final int DDM_MINNUMINST = 30;
-    public IntOption minNumInstancesOption = new IntOption(
-            "minNumInstances",
-            'n',
-            "The minimum number of instances before permitting detecting change.",
-            30, 0, Integer.MAX_VALUE);
-
-    public FloatOption lambdaOption = new FloatOption("lambda", 'l',
-            "Lambda parameter of the EWMA Chart Method", 0.2, 0.0, Float.MAX_VALUE);
-
-    private double m_n;
-
-    private double m_sum;
-    
-    private double m_p;
-    
-    private double m_s;
-    
-    private double lambda;
-    
-    private double z_t;
-
-    public EWMAChartDM() {
-        resetLearning();
-    }
-
-    @Override
-    public void resetLearning() {
-        m_n = 1.0;
-        m_sum = 0.0;
-        m_p = 0.0;
-        m_s = 0.0;
-        z_t = 0.0;
-        lambda = this.lambdaOption.getValue();
-    }
-
-    @Override
-    public void input(double prediction) {
-        // prediction must be 1 or 0
-        // It monitors the error rate
-         if (this.isChangeDetected == true || this.isInitialized == false) {
-            resetLearning();
-            this.isInitialized = true;
-        }
-
-        m_sum += prediction;
-        
-        m_p = m_sum/m_n; // m_p + (prediction - m_p) / (double) (m_n+1);
-
-        m_s = Math.sqrt(  m_p * (1.0 - m_p)* lambda * (1.0 - Math.pow(1.0 - lambda, 2.0 * m_n)) / (2.0 - lambda));
-
-        m_n++;
-
-        z_t += lambda * (prediction - z_t);
-
-        //double L_t = 2.76 - 6.23 * m_p + 18.12 * Math.pow(m_p, 3) - 312.45 * Math.pow(m_p, 5) + 1002.18 * Math.pow(m_p, 7); //%1 FP
-        double L_t = 3.97 - 6.56 * m_p + 48.73 * Math.pow(m_p, 3) - 330.13 * Math.pow(m_p, 5) + 848.18 * Math.pow(m_p, 7); //%1 FP
-        //double L_t = 1.17 + 7.56 * m_p - 21.24 * Math.pow(m_p, 3) + 112.12 * Math.pow(m_p, 5) - 987.23 * Math.pow(m_p, 7); //%1 FP
-
-        // System.out.print(prediction + " " + m_n + " " + (m_p+m_s) + " ");
-        this.estimation = m_p;
-        this.isChangeDetected = false;
-        this.isWarningZone = false;
-        this.delay = 0;
-
-        if (m_n < this.minNumInstancesOption.getValue()) {
-            return;
-        }
-            
-        if (m_n > this.minNumInstancesOption.getValue() && z_t > m_p + L_t * m_s) {
-            //System.out.println(m_p + ",D");
-            this.isChangeDetected = true;
-            //resetLearning();
-        } else if (z_t > m_p + 0.5 *  L_t * m_s) {
-            //System.out.println(m_p + ",W");
-            this.isWarningZone = true;
-        } else {
-            this.isWarningZone = false;
-            //System.out.println(m_p + ",N");
-        }
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        // TODO Auto-generated method stub
-    }
-}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/EnsembleDriftDetectionMethods.java b/moa/src/main/java/moa/classifiers/core/driftdetection/EnsembleDriftDetectionMethods.java
deleted file mode 100644
index 08e68c8d3..000000000
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/EnsembleDriftDetectionMethods.java
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- *    DDM.java
- *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
- *    @author Manuel Baena (mbaena@lcc.uma.es)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package moa.classifiers.core.driftdetection;
-
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.ListOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.github.javacliparser.Option;
-
-import moa.core.ObjectRepository;
-import moa.options.ClassOption;
-import moa.options.OptionHandler;
-import moa.tasks.TaskMonitor;
-
-/**
- * Ensemble Drift detection method
- *
- *
- * @author Manuel Baena (mbaena@lcc.uma.es)
- * @version $Revision: 7 $
- */
-public class EnsembleDriftDetectionMethods extends AbstractChangeDetector {
-
-    private static final long serialVersionUID = -3518369648142099719L;
-
-    //private static final int DDM_MINNUMINST = 30;
-    public IntOption minNumInstancesOption = new IntOption(
-            "minNumInstances",
-            'n',
-            "The minimum number of instances before permitting detecting change.",
-            30, 0, Integer.MAX_VALUE);
-
-    public ListOption changeDetectorsOption = new ListOption("changeDetectors", 'c',
-            "Change Detectors to use.", new ClassOption("driftDetectionMethod", 'd',
-            "Drift detection method to use.", ChangeDetector.class, "DDM"),
-            new Option[0], ',');
-
-    public MultiChoiceOption predictionOption = new MultiChoiceOption(
-            "prediction", 'l', "Prediction to use.", new String[]{
-                "max", "min", "majority"}, new String[]{
-                "Maximum",
-                "Minimum",
-                "Majority"}, 0);
-
-    public EnsembleDriftDetectionMethods() {
-        resetLearning();
-    }
-
-    @Override
-    public void resetLearning() {
-        //if (preds == null) {
-             preds = new Boolean[this.changeDetectorsOption.getList().length];
-        //}
-        for (int i = 0; i < preds.length; i++) {
-            preds[i] = false;
-        }
-    }
-        
-    protected ChangeDetector[] cds;
-
-    protected Boolean[] preds;
-
-    @Override
-    public void input(double prediction) {
-        for (int i = 0; i < cds.length; i++) {
-            cds[i].input(prediction);
-            if (cds[i].getChange()) {
-                preds[i] = true;
-            }
-        }
-        int typePrediction = this.predictionOption.getChosenIndex();
-                   int numberDetections = 0;
-            for (int i = 0; i < cds.length; i++) {
-                if (preds[i] == true) {
-                    numberDetections++;
-                }
-            }
-        if (typePrediction == 0) { 
-            //Choose Max
-            this.isChangeDetected = (numberDetections == cds.length);
-        } else if (typePrediction == 1) {
-            //Choose Min
-             this.isChangeDetected = (numberDetections > 0);
-        } else if (typePrediction == 2) {
-            //Choose Avg
-            this.isChangeDetected = (numberDetections > cds.length/2) ;
-        }
-        if (this.isChangeDetected == true) {
-            this.resetLearning();
-        }
-    }
-
-    //public double[] getOutput() {
-    //    double[] res = {this.isChangeDetected ? 1 : 0, this.isWarningZone ? 1 : 0, this.delay, this.estimation};
-    //    return res;
-    //}
-    
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        // TODO Auto-generated method stub
-        Option[] changeDetectorOptions = this.changeDetectorsOption.getList();
-        cds = new ChangeDetector[changeDetectorOptions.length];
-        preds = new Boolean[changeDetectorOptions.length];
-        for (int i = 0; i < cds.length; i++) {
-            //monitor.setCurrentActivity("Materializing change detector " + (i + 1)
-            //        + "...", -1.0);
-            cds[i] = ((ChangeDetector) ((ClassOption) changeDetectorOptions[i]).materializeObject(monitor, repository)).copy();
-            if (monitor.taskShouldAbort()) {
-                return;
-            }
-            if (cds[i] instanceof OptionHandler) {
-                monitor.setCurrentActivity("Preparing change detector " + (i + 1)
-                        + "...", -1.0);
-                ((OptionHandler) cds[i]).prepareForUse(monitor, repository);
-                if (monitor.taskShouldAbort()) {
-                    return;
-                }
-            }
-            preds[i] = false;
-        }
-    }
-}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/GeometricMovingAverageDM.java b/moa/src/main/java/moa/classifiers/core/driftdetection/GeometricMovingAverageDM.java
deleted file mode 100644
index 1b7074ed2..000000000
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/GeometricMovingAverageDM.java
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- *    DDM.java
- *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
- *    @author Manuel Baena (mbaena@lcc.uma.es)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package moa.classifiers.core.driftdetection;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-
-import moa.core.ObjectRepository;
-import moa.tasks.TaskMonitor;
-
-/**
- * Drift detection method based in Geometric Moving Average Test
- *
- *
- * @author Manuel Baena (mbaena@lcc.uma.es)
- * @version $Revision: 7 $
- */
-public class GeometricMovingAverageDM extends AbstractChangeDetector {
-
-    private static final long serialVersionUID = -3518369648142099719L;
-
-    public IntOption minNumInstancesOption = new IntOption(
-            "minNumInstances",
-            'n',
-            "The minimum number of instances before permitting detecting change.",
-            30, 0, Integer.MAX_VALUE);
-
-    public FloatOption lambdaOption = new FloatOption("lambda", 'l',
-            "Threshold parameter of the Geometric Moving Average Test", 1, 0.0, Float.MAX_VALUE);
-
-    public FloatOption alphaOption = new FloatOption("alpha", 'a',
-            "Alpha parameter of the Geometric Moving Average Test", .99, 0.0, 1.0);
-
-    private double m_n;
-
-    private double sum;
-
-    private double x_mean;
-                                                                                            
-    private double alpha;
-
-    private double delta;
-
-    private double lambda;
-
-    public GeometricMovingAverageDM() {
-        resetLearning();
-    }
-
-    @Override
-    public void resetLearning() {
-        m_n = 1.0;
-        x_mean = 0.0;
-        sum = 0.0;
-        alpha = this.alphaOption.getValue();
-        lambda = this.lambdaOption.getValue();
-    }
-
-    @Override
-    public void input(double x) {
-        // It monitors the error rate
-        if (this.isChangeDetected == true || this.isInitialized == false) {
-            resetLearning();
-            this.isInitialized = true;
-        }
-
-        x_mean = x_mean + (x - x_mean) / m_n;
-        sum = alpha * sum + ( 1.0- alpha) * (x - x_mean);
-
-
-        m_n++;
-
-        // System.out.print(prediction + " " + m_n + " " + (m_p+m_s) + " ");
-        this.estimation = x_mean;
-        this.isChangeDetected = false;
-        this.isWarningZone = false;
-        this.delay = 0;
-
-        if (m_n < this.minNumInstancesOption.getValue()) {
-            return;
-        }
-
-        if (sum > this.lambda) {
-            this.isChangeDetected = true;
-        } 
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        // TODO Auto-generated method stub
-    }
-}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/HDDM_A_Test.java b/moa/src/main/java/moa/classifiers/core/driftdetection/HDDM_A_Test.java
deleted file mode 100644
index 37d4118da..000000000
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/HDDM_A_Test.java
+++ /dev/null
@@ -1,182 +0,0 @@
-/*
- *    HDDM_A_Test.java
- *
- *    @author Isvani Frias-Blanco (ifriasb@udg.co.cu)
- * 
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
- 
- 
-package moa.classifiers.core.driftdetection;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.MultiChoiceOption;
-
-import moa.core.ObjectRepository;
-import moa.tasks.TaskMonitor;
-
-/**
- * <p>Online drift detection method based on Hoeffding's bounds. 
- * HDDM<sub><i>A</i>-test</sub> uses the average as estimator.
- * It receives as input a stream of real values and returns the estimated status
- * of the stream: STABLE, WARNING or DRIFT.</p>
- *
- * <p>I. Frias-Blanco, J. del Campo-Avila, G. Ramos-Jimenez, R. Morales-Bueno, 
- * A. Ortiz-Diaz, and Y. Caballero-Mota, Online and non-parametric drift 
- * detection methods based on Hoeffding's bound, IEEE Transactions on Knowledge
- * and Data Engineering, 2014. DOI 10.1109/TKDE.2014.2345382.</p>
- *
- * <p>Parameters:</p> <ul> <li>-d : Confidence to the drift</li><li>-w : 
- * Confidence to the warning</li><li>-t : Option to monitor error increments and
- * decrements (two-sided) or only increments (one-sided)</li>
- * </ul>
- *
- * @author Isvani Frias-Blanco (ifriasb@udg.co.cu)
- *
- */
-
-public class HDDM_A_Test extends AbstractChangeDetector {
-    
-    public FloatOption driftConfidenceOption = new FloatOption("driftConfidence", 'd',
-            "Confidence to the drift",
-            0.001, 0, 1);
-    public FloatOption warningConfidenceOption = new FloatOption("warningConfidence", 'w',
-            "Confidence to the warning",
-            0.005, 0, 1);
-    public MultiChoiceOption oneSidedTestOption = new MultiChoiceOption(
-            "typeOfTest", 't',
-            "Monitors error increments and decrements (two-sided) or only increments (one-sided)", new String[]{
-        "One-sided", "Two-sided"}, new String[]{
-        "One-sided", "Two-sided"},
-            1);
-
-    protected int n_min = 0;
-    protected double c_min = 0;
-    protected int total_n = 0;
-    protected double total_c = 0;
-    protected int n_max = 0;
-    protected double c_max = 0;
-    protected double cEstimacion = 0;
-    protected int nEstimacion = 0;
-
-    public HDDM_A_Test() {
-        resetLearning();
-    }
-
-    @Override
-    public void input(double value) {
-        total_n++;
-        total_c += value;
-        if (n_min == 0) {
-            n_min = total_n;
-            c_min = total_c;
-        }
-        if (n_max == 0) {
-            n_max = total_n;
-            c_max = total_c;
-        }
-
-        double cota = Math.sqrt(1.0 / (2 * n_min) * Math.log(1.0 / driftConfidenceOption.getValue())),
-                cota1 = Math.sqrt(1.0 / (2 * total_n) * Math.log(1.0 / driftConfidenceOption.getValue()));
-        if (c_min / n_min + cota >= total_c / total_n + cota1) {
-            c_min = total_c;
-            n_min = total_n;
-        }
-
-        cota = Math.sqrt(1.0 / (2 * n_max) * Math.log(1.0 / driftConfidenceOption.getValue()));
-        if (c_max / n_max - cota <= total_c / total_n - cota1) {
-            c_max = total_c;
-            n_max = total_n;
-        }
-        if (meanIncr(c_min, n_min, total_c, total_n, driftConfidenceOption.getValue())) {
-            nEstimacion = total_n - n_min;
-            cEstimacion = total_c - c_min;
-            n_min = n_max = total_n = 0;
-            c_min = c_max = total_c = 0;
-            this.isChangeDetected = true;
-            this.isWarningZone = false;
-        } else if (meanIncr(c_min, n_min, total_c, total_n, warningConfidenceOption.getValue())) {
-            this.isChangeDetected = false;
-            this.isWarningZone = true;
-        } else {
-            this.isChangeDetected = false;
-            this.isWarningZone = false;
-        }
-        if (this.oneSidedTestOption.getChosenIndex() == 1 
-                && meanDecr(c_max, n_max, total_c, total_n)) {
-            nEstimacion = total_n - n_max;
-            cEstimacion = total_c - c_max;
-            n_min = n_max = total_n = 0;
-            c_min = c_max = total_c = 0;
-        }
-        updateEstimations();
-    }
-
-    private boolean meanIncr(double c_min, int n_min, double total_c, int total_n, double confianzaCambio) {
-        if (n_min == total_n) {
-            return false;
-        }
-        double m = (double) (total_n - n_min) / n_min * (1.0 / total_n);
-        double cota = Math.sqrt(m / 2 * Math.log(2.0 / confianzaCambio));
-        return total_c / total_n - c_min / n_min >= cota;
-    }
-
-    private boolean meanDecr(double c_max, int n_max, double total_c, int total_n) {
-        if (n_max == total_n) {
-            return false;
-        }
-        double m = (double) (total_n - n_max) / n_max * (1.0 / total_n);
-        double cota = Math.sqrt(m / 2 * Math.log(2.0 / driftConfidenceOption.getValue()));
-        return c_max / n_max - total_c / total_n >= cota;
-    }
-
-    @Override
-    public void resetLearning() {
-        super.resetLearning();
-        n_min = 0;
-        c_min = 0;
-        total_n = 0;
-        total_c = 0;
-        n_max = 0;
-        c_max = 0;
-        cEstimacion = 0;
-        nEstimacion = 0;
-    }
-
-    protected void updateEstimations() {
-        if (this.total_n >= this.nEstimacion) {
-            this.cEstimacion = this.nEstimacion = 0;
-            this.estimation = this.total_c / this.total_n;
-            this.delay = this.total_n;
-        } else {
-            this.estimation = this.cEstimacion / this.nEstimacion;
-            this.delay = this.nEstimacion;
-        }
-    }
-
-    @Override
-    public double getEstimation() {
-        return this.estimation;
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-        resetLearning();
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/HDDM_W_Test.java b/moa/src/main/java/moa/classifiers/core/driftdetection/HDDM_W_Test.java
deleted file mode 100644
index b4c6111e4..000000000
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/HDDM_W_Test.java
+++ /dev/null
@@ -1,215 +0,0 @@
-/*
- *    HDDM_W_Test.java
- *
- *    @author Isvani Frias-Blanco (ifriasb@udg.co.cu)
- * 
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-package moa.classifiers.core.driftdetection;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.MultiChoiceOption;
-
-import moa.core.ObjectRepository;
-import moa.tasks.TaskMonitor;
-
-/**
- * <p>Online drift detection method based on McDiarmid's bounds. 
- * HDDM<sub><i>W</i>-test</sub> uses the EWMA statistic as estimator.
- * It receives as input a stream of real values and returns the estimated status
- * of the stream: STABLE, WARNING or DRIFT.</p>
- *
- * <p>I. Frias-Blanco, J. del Campo-Avila, G. Ramos-Jimenez, R. Morales-Bueno, 
- * A. Ortiz-Diaz, and Y. Caballero-Mota, Online and non-parametric drift 
- * detection methods based on Hoeffding's bound, IEEE Transactions on Knowledge
- * and Data Engineering, 2014. DOI 10.1109/TKDE.2014.2345382.</p>
- *
- * <p>Parameters:</p> <ul> <li>-d : Confidence to the drift</li><li>-w : 
- * Confidence to the warning</li><li>-m : Controls how much weight is given to 
- * more recent data compared to older data. Smaller values mean less weight 
- * given to recent data</li><li>-t : Option to monitor error increments and 
- * decrements (two-sided) or only increments (one-sided)</li>
- * </ul>
- *
- * @author Isvani Frias-Blanco (ifriasb@udg.co.cu)
- *
- */
-
-public class HDDM_W_Test extends AbstractChangeDetector {
-
-    protected static final long serialVersionUID = 1L;
-    public FloatOption driftConfidenceOption = new FloatOption("driftConfidence", 'd',
-            "Confidence to the drift",
-            0.001, 0, 1);
-    public FloatOption warningConfidenceOption = new FloatOption("warningConfidence", 'w',
-            "Confidence to the warning",
-            0.005, 0, 1);
-    public FloatOption lambdaOption = new FloatOption("lambda",
-            'm', "Controls how much weight is given to more recent data compared to older data. Smaller values mean less weight given to recent data.",
-            0.050, 0, 1);
-    public MultiChoiceOption oneSidedTestOption = new MultiChoiceOption(
-            "typeOfTest", 't',
-            "Monitors error increments and decrements (two-sided) or only increments (one-sided)", new String[]{
-        "One-sided", "Two-sided"}, new String[]{
-        "One-sided", "Two-sided"},
-            0);
-    
-
-    public static class SampleInfo {
-
-        private static final long serialVersionUID = 1L;
-        public double EWMA_Estimator;
-        public double independentBoundedConditionSum;
-
-        public SampleInfo() {
-            this.EWMA_Estimator = -1.0;
-        }
-    }
-    private static SampleInfo sample1_IncrMonitoring,
-            sample2_IncrMonitoring,
-            sample1_DecrMonitoring,
-            sample2_DecrMonitoring,
-            total;
-    protected double incrCutPoint, decrCutPoint;
-    protected double lambda;
-    protected double warningConfidence;
-    protected double driftConfidence;
-    protected boolean oneSidedTest;
-    protected int width;
-
-    public HDDM_W_Test() {
-        resetLearning();
-    }
-
-    @Override
-    public void resetLearning() {
-        super.resetLearning();
-        this.total = new SampleInfo();
-        this.sample1_DecrMonitoring = new SampleInfo();
-        this.sample1_IncrMonitoring = new SampleInfo();
-        this.sample2_DecrMonitoring = new SampleInfo();
-        this.sample2_IncrMonitoring = new SampleInfo();
-        this.incrCutPoint = Double.MAX_VALUE;
-        this.decrCutPoint = Double.MIN_VALUE;
-        this.lambda = this.lambdaOption.getValue();
-        this.driftConfidence = this.driftConfidenceOption.getValue();
-        this.warningConfidence = this.warningConfidenceOption.getValue();
-        this.oneSidedTest = this.oneSidedTestOption.getChosenIndex() == 0;
-        this.width = 0;
-        this.delay = 0;
-    }
-
-    public void input(boolean prediction) {
-        double value = prediction == false ? 1.0 : 0.0;
-        input(value);
-    }
-
-    @Override
-    public void input(double value) {
-        double auxDecayRate = 1.0 - lambda;
-        this.width++;
-        if (total.EWMA_Estimator < 0) {
-            total.EWMA_Estimator = value;
-            total.independentBoundedConditionSum = 1;
-        } else {
-            total.EWMA_Estimator = lambda * value + auxDecayRate * total.EWMA_Estimator;
-            total.independentBoundedConditionSum = lambda * lambda + auxDecayRate * auxDecayRate * total.independentBoundedConditionSum;
-        }
-        updateIncrStatistics(value, driftConfidence);
-        if (monitorMeanIncr(value, driftConfidence)) {
-            resetLearning();
-            this.isChangeDetected = true;
-            this.isWarningZone = false;
-        } else if (monitorMeanIncr(value, warningConfidence)) {
-            this.isChangeDetected = false;
-            this.isWarningZone = true;
-        } else {
-            this.isChangeDetected = false;
-            this.isWarningZone = false;
-        }
-        updateDecrStatistics(value, driftConfidence);
-        if (!oneSidedTest && monitorMeanDecr(value, driftConfidence)) {
-            resetLearning();
-        }
-        this.estimation = this.total.EWMA_Estimator;
-    }
-
-    public boolean detectMeanIncrement(SampleInfo sample1, SampleInfo sample2, double confidence) {
-        if (sample1.EWMA_Estimator < 0 || sample2.EWMA_Estimator < 0) {
-            return false;
-        }
-        double bound = Math.sqrt((sample1.independentBoundedConditionSum + sample2.independentBoundedConditionSum) * Math.log(1 / confidence) / 2);
-        return sample2.EWMA_Estimator - sample1.EWMA_Estimator > bound;
-    }
-    
-    void updateIncrStatistics(double valor, double confidence) {
-            double auxDecay = 1.0 - lambda;
-            double bound = Math.sqrt(total.independentBoundedConditionSum * Math.log(1.0 / driftConfidence) / 2);
-
-            if (total.EWMA_Estimator + bound < incrCutPoint) {
-                incrCutPoint = total.EWMA_Estimator + bound;
-                sample1_IncrMonitoring.EWMA_Estimator = total.EWMA_Estimator;
-                sample1_IncrMonitoring.independentBoundedConditionSum = total.independentBoundedConditionSum;
-                sample2_IncrMonitoring = new SampleInfo();
-                this.delay = 0;
-            } else {
-                this.delay++;
-                if (sample2_IncrMonitoring.EWMA_Estimator < 0) {
-                    sample2_IncrMonitoring.EWMA_Estimator = valor;
-                    sample2_IncrMonitoring.independentBoundedConditionSum = 1;
-                } else {
-                    sample2_IncrMonitoring.EWMA_Estimator = lambda * valor + auxDecay * sample2_IncrMonitoring.EWMA_Estimator;
-                    sample2_IncrMonitoring.independentBoundedConditionSum = lambda * lambda + auxDecay * auxDecay * sample2_IncrMonitoring.independentBoundedConditionSum;
-                }
-            }
-        
-    }
-
-    protected boolean monitorMeanIncr(double valor, double confidence) {
-        return detectMeanIncrement(sample1_IncrMonitoring, sample2_IncrMonitoring, confidence);
-    }
-    
-    void updateDecrStatistics(double valor, double confidence) {
-            double auxDecay = 1.0 - lambda;
-            double epsilon = Math.sqrt(total.independentBoundedConditionSum * Math.log(1.0 / driftConfidence) / 2);
-
-            if (total.EWMA_Estimator - epsilon > decrCutPoint) {
-                decrCutPoint = total.EWMA_Estimator - epsilon;
-                sample1_DecrMonitoring.EWMA_Estimator = total.EWMA_Estimator;
-                sample1_DecrMonitoring.independentBoundedConditionSum = total.independentBoundedConditionSum;
-                sample2_DecrMonitoring = new SampleInfo();
-            } else {
-                if (sample2_DecrMonitoring.EWMA_Estimator < 0) {
-                    sample2_DecrMonitoring.EWMA_Estimator = valor;
-                    sample2_DecrMonitoring.independentBoundedConditionSum = 1;
-                } else {
-                    sample2_DecrMonitoring.EWMA_Estimator = lambda * valor + auxDecay * sample2_DecrMonitoring.EWMA_Estimator;
-                    sample2_DecrMonitoring.independentBoundedConditionSum = lambda * lambda + auxDecay * auxDecay * sample2_DecrMonitoring.independentBoundedConditionSum;
-                }
-            }
-    }
-
-    protected boolean monitorMeanDecr(double valor, double confidence) {
-        return detectMeanIncrement(sample2_DecrMonitoring, sample1_DecrMonitoring, confidence);
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-        resetLearning();
-    }
-
-    public void getDescription(StringBuilder sb, int indent) {
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/PageHinkleyDM.java b/moa/src/main/java/moa/classifiers/core/driftdetection/PageHinkleyDM.java
deleted file mode 100644
index fecdb775d..000000000
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/PageHinkleyDM.java
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- *    DDM.java
- *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
- *    @author Manuel Baena (mbaena@lcc.uma.es)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package moa.classifiers.core.driftdetection;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-
-import moa.core.ObjectRepository;
-import moa.tasks.TaskMonitor;
-
-/**
- * Drift detection method based in Page Hinkley Test.
- *
- *
- * @author Manuel Baena (mbaena@lcc.uma.es)
- * @version $Revision: 7 $
- */
-public class PageHinkleyDM extends AbstractChangeDetector {
-
-    private static final long serialVersionUID = -3518369648142099719L;
-
-    public IntOption minNumInstancesOption = new IntOption(
-            "minNumInstances",
-            'n',
-            "The minimum number of instances before permitting detecting change.",
-            30, 0, Integer.MAX_VALUE);
-
-    public FloatOption deltaOption = new FloatOption("delta", 'd',
-            "Delta parameter of the Page Hinkley Test", 0.005, 0.0, 1.0);
-
-    public FloatOption lambdaOption = new FloatOption("lambda", 'l',
-            "Lambda parameter of the Page Hinkley Test", 50, 0.0, Float.MAX_VALUE);
-
-    public FloatOption alphaOption = new FloatOption("alpha", 'a',
-            "Alpha parameter of the Page Hinkley Test", 1 - 0.0001, 0.0, 1.0);
-
-    private int m_n;
-
-    private double sum;
-
-    private double x_mean;
-
-    private double alpha;
-
-    private double delta;
-
-    private double lambda;
-
-    public PageHinkleyDM() {
-        resetLearning();
-    }
-
-    @Override
-    public void resetLearning() {
-        m_n = 1;
-        x_mean = 0.0;
-        sum = 0.0;
-        delta = this.deltaOption.getValue();
-        alpha = this.alphaOption.getValue();
-        lambda = this.lambdaOption.getValue();
-    }
-
-    @Override
-    public void input(double x) {
-        // It monitors the error rate
-        if (this.isChangeDetected == true || this.isInitialized == false) {
-            resetLearning();
-            this.isInitialized = true;
-        }
-
-        x_mean = x_mean + (x - x_mean) / (double) m_n;
-        sum = this.alpha * sum + (x - x_mean - this.delta);
-
-        m_n++;
-
-        // System.out.print(prediction + " " + m_n + " " + (m_p+m_s) + " ");
-        this.estimation = x_mean;
-        this.isChangeDetected = false;
-        this.isWarningZone = false;
-        this.delay = 0;
-
-        if (m_n < this.minNumInstancesOption.getValue()) {
-            return;
-        }
-
-        if (sum > this.lambda) {
-            this.isChangeDetected = true;
-        } 
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        // TODO Auto-generated method stub
-    }
-}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/RDDM.java b/moa/src/main/java/moa/classifiers/core/driftdetection/RDDM.java
deleted file mode 100644
index a373b50e1..000000000
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/RDDM.java
+++ /dev/null
@@ -1,238 +0,0 @@
-/*
- *    RDDM.java
- *    Copyright (C) 2016 Barros, Cabral, Goncalves, Santos
- *    @authors Roberto S. M. Barros (roberto@cin.ufpe.br) 
- *             Danilo Cabral (danilocabral@danilocabral.com.br)
- *             Paulo M. Goncalves Jr. (paulomgj@gmail.com)
- *             Silas G. T. C. Santos (sgtcs@cin.ufpe.br)
- *    @version $Version: 1 $
- *    
- *    Evolved from DDM.java
- *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
- *    @author Manuel Baena (mbaena@lcc.uma.es)
- *    @version $Revision: 7 $
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- */
-
-/**
- * Reactive Drift Detection Method (RDDM) 
- * published as:
- *     Roberto S. M. Barros, Danilo R. L. Cabral, Paulo M. Goncalves Jr.,
- *     and Silas G. T. C. Santos: 
- *     RDDM: Reactive Drift Detection Method. 
- *     Expert Systems With Applications 90C (2017) pp. 344-355.
- *     DOI: 10.1016/j.eswa.2017.08.023
- */
-
-package moa.classifiers.core.driftdetection;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-
-import moa.core.ObjectRepository;
-import moa.tasks.TaskMonitor;
-
-public class RDDM extends AbstractChangeDetector {
-    private static final long serialVersionUID = -489867468386968209L;
-
-    public IntOption minNumInstancesOption = new IntOption("minNumInstances", 
-            'n', "Minimum number of instances before monitoring changes.",
-            129, 0, Integer.MAX_VALUE);
-
-    public FloatOption warningLevelOption = new FloatOption("warningLevel", 
-            'w', "Warning Level.",
-            1.773, 1.0, 4.0);
-
-    public FloatOption driftLevelOption = new FloatOption("driftLevel", 
-            'o', "Drift Level.",
-            2.258, 1.0, 5.0);
-
-    public IntOption maxSizeConceptOption = new IntOption("maxSizeConcept", 
-            'x', "Maximum Size of Concept.",
-            40000, 1, Integer.MAX_VALUE);
-
-    public IntOption minSizeStableConceptOption = new IntOption("minSizeStableConcept", 
-            'y', "Minimum Size of Stable Concept.",
-            7000, 1, 20000);
-            
-    public IntOption warnLimitOption = new IntOption("warnLimit", 
-            'z', "Warning Limit of instances",
-            1400, 1, 20000);
-
-    private int minNumInstances;
-    private double warningLevel;
-    private double driftLevel;
-    private int maxSizeConcept;
-    private int minSizeStableConcept;
-    private int warnLimit;
-    
-    private int m_n;
-    private double m_p;
-    private double m_s;
-    private double m_pmin;
-    private double m_smin;
-    private double m_psmin;
-
-    private byte [] storedPredictions;
-    private int numStoredInstances, firstPos, lastPos, pos, i;
-    private int lastWarnInst, lastWarnPos;
-    private int instNum;
-    private boolean rddmDrift;
-
-    public void initialize() {
-        minNumInstances = this.minNumInstancesOption.getValue();
-        warningLevel = this.warningLevelOption.getValue();
-        driftLevel = this.driftLevelOption.getValue();
-        maxSizeConcept = this.maxSizeConceptOption.getValue();
-        minSizeStableConcept = this.minSizeStableConceptOption.getValue();
-        warnLimit = this.warnLimitOption.getValue();
-        storedPredictions = new byte[minSizeStableConcept];
-        numStoredInstances = 0;
-        firstPos = 0;
-        lastPos = -1;   // This means storedPredictions is empty.
-        lastWarnPos  = -1;
-        lastWarnInst = -1;
-        instNum = 0;
-        rddmDrift = false;
-        this.isChangeDetected = false;
-        
-        resetLearning();
-        m_pmin = Double.MAX_VALUE;
-        m_smin = Double.MAX_VALUE;
-        m_psmin = Double.MAX_VALUE; 
-    }
-
-    @Override
-    public void resetLearning() {
-        m_n = 1;
-        m_p = 1;
-        m_s = 0;
-        if (this.isChangeDetected) {
-            m_pmin = Double.MAX_VALUE;
-            m_smin = Double.MAX_VALUE;
-            m_psmin = Double.MAX_VALUE;
-        }
-    }
-
-    @Override
-    public void input(double prediction) {   // In MOA, 1.0=false, 0.0=true.
-        if (!this.isInitialized) {
-            initialize();
-            this.isInitialized = true;
-        }
-        if (rddmDrift) {
-            resetLearning();
-    	    if (lastWarnPos != -1) {
-    	    	firstPos = lastWarnPos;
-    	    	numStoredInstances = lastPos - firstPos + 1;
-    	    	if (numStoredInstances <= 0) {
-    	    	    numStoredInstances += minSizeStableConcept;
-    	    	}
-    	    } 
-    	    
-    	    pos = firstPos;
-    	    for (i = 0; i < numStoredInstances; i++) {
-                m_p = m_p + (storedPredictions[pos] - m_p) / m_n;
-                m_s = Math.sqrt(m_p * (1 - m_p) / m_n);
-                if (this.isChangeDetected && (m_n > minNumInstances) && (m_p + m_s < m_psmin)) {
-                    m_pmin = m_p;
-                    m_smin = m_s;
-                    m_psmin = m_p + m_s;
-                }
-                m_n++;
-                pos = (pos + 1) % minSizeStableConcept;
-            }
-    	    
-            lastWarnPos = -1;
-            lastWarnInst = -1;
-            rddmDrift = false;
-            this.isChangeDetected = false;
-        }
-
-        lastPos = (lastPos + 1) % minSizeStableConcept;   // Adds prediction at the end of the window.
-        storedPredictions[lastPos] = (byte) prediction;
-        if (numStoredInstances < minSizeStableConcept) {   // The window grows.
-            numStoredInstances++;
-        } else {   // The window is full.
-            firstPos = (firstPos + 1) % minSizeStableConcept;    // Start of the window moves.
-            if (lastWarnPos == lastPos) { 
-                lastWarnPos = -1;
-            }
-        }
-	    
-        m_p = m_p + (prediction - m_p) / m_n;
-        m_s = Math.sqrt(m_p * (1 - m_p) / m_n);
-
-        instNum++;
-        m_n++;
-        this.estimation = m_p;
-        this.isWarningZone = false;
-
-        if (m_n <= minNumInstances) {
-            return;
-        }
-
-        if (m_p + m_s < m_psmin) {
-            m_pmin = m_p;
-            m_smin = m_s;
-            m_psmin = m_p + m_s;
-        }
-
-        if (m_p + m_s > m_pmin + driftLevel * m_smin) {  // DDM Drift
-            this.isChangeDetected = true;
-            rddmDrift = true;
-            if (lastWarnInst == -1) {   // DDM Drift without previous warning
-            	firstPos = lastPos;
-                numStoredInstances = 1;
-            }
-    	    return;
-        }
-
-        if (m_p + m_s > m_pmin + warningLevel * m_smin) {  // Warning Level
-            // Warning level for warnLimit consecutive instances will force drifts
-            if ((lastWarnInst != -1) && (lastWarnInst + warnLimit <= instNum)) { 
-                this.isChangeDetected = true;
-                rddmDrift = true;
-                firstPos = lastPos;
-                numStoredInstances = 1;
-                lastWarnPos = -1;
-                lastWarnInst = -1;
-                return;
-            } 
-            // Warning Zone
-            this.isWarningZone = true;
-            if (lastWarnInst == -1) {
-                lastWarnInst = instNum;
-                lastWarnPos = lastPos;
-            }
-        } else {   // Neither DDM Drift nor Warning - disregard false warnings
-            lastWarnInst = -1;
-            lastWarnPos  = -1;
-        }
-        if (m_n > maxSizeConcept && (!isWarningZone)) {  // RDDM Drift
-            rddmDrift = true;
-        }
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        // TODO Auto-generated method stub
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/SEEDChangeDetector.java b/moa/src/main/java/moa/classifiers/core/driftdetection/SEEDChangeDetector.java
deleted file mode 100644
index 8f7124b0e..000000000
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/SEEDChangeDetector.java
+++ /dev/null
@@ -1,626 +0,0 @@
-/*
- * SEEDChangeDetector.java
- * author: David T.J. Huang - The University of Auckland
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *             http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
- * either express or implied. See the License for the specific
- * language governing permissions and limitations under the
- * License.
- * 
- */
-
-package moa.classifiers.core.driftdetection;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-
-import moa.core.ObjectRepository;
-import moa.tasks.TaskMonitor;
-
-/**
- * 
- * Drift detection method as published in:
- * </p>
- * David Tse Jung Huang, Yun Sing Koh, Gillian Dobbie, and Russel Pears: Detecting Volatility Shift in Data Streams. ICDM 2014: 863-868
- * </p>
- * Usage: {@link #setInput(double)}
- * </p>
- * 
- * @author David T.J. Huang - The University of Auckland
- * @version 1.0
- */
-
-public class SEEDChangeDetector extends AbstractChangeDetector
-{
-    protected SEED seed;
-    
-    public FloatOption deltaSEEDOption = new FloatOption("deltaSEED", 'd', "Delta value of SEED Detector", 0.05, 0.0, 1.0);
-    public IntOption blockSizeSEEDOption = new IntOption("blockSizeSEED", 'b', "BlockSize value of SEED Detector", 32, 32, 256);
-    public FloatOption epsilonPrimeSEEDOption = new FloatOption("epsilonPrimeSEED", 'e', "EpsilonPrime value of SEED Detector", 0.01, 0.0025, 0.01);
-    public FloatOption alphaSEEDOption = new FloatOption("alphaSEED", 'a', "Alpha value of SEED Detector", 0.8, 0.2, 0.8);
-    public IntOption compressTermSEEDOption = new IntOption("compressTermSEED", 'c', "CompressTerm value of SEED Detector", 75, 50, 100);
-
-   
-    public void input(double inputValue)
-    {
-	if(this.seed == null)
-	{
-	    resetLearning();
-	}
-	this.isChangeDetected = seed.setInput(inputValue);
-	this.isWarningZone = false;
-	this.delay = 0.0;
-	this.estimation = 0.0;
-    }
-    
-    @Override
-    public void resetLearning()
-    {
-	seed = new SEED((double)this.deltaSEEDOption.getValue(), 
-		this.blockSizeSEEDOption.getValue(), 
-		(double) this.epsilonPrimeSEEDOption.getValue(), 
-		(double)this.alphaSEEDOption.getValue(), 
-		this.compressTermSEEDOption.getValue());
-    }
-    
-    @Override
-    public void getDescription(StringBuilder sb, int indent)
-    {
-	// TODO Auto-generated method stub	
-    }
-    
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository)
-    {
-	// TODO Auto-generated method stub
-    }
-
-    public class SEED
-    {
-	public SEEDWindow window;
-	private double DELTA;
-	private int blockSize;
-	private int elementCount;
-
-	/**
-	 * Constructor for all required parameters.
-	 * @param delta 
-	 * @param blockSize Recommended value: 32
-	 * @param epsilonPrime Recommended values between [0.0025, 0.01]
-	 * @param alpha Growth parameter - Recommended values between [0.2, 0.8]
-	 * @param compressionterm Recommended values between [50, 100]
-	 */
-	public SEED(double delta, int blockSize, double epsilonPrime, double alpha, int term)
-	{
-	    this.DELTA = delta;
-	    this.blockSize = blockSize;
-	    this.window = new SEEDWindow(blockSize, 1, 1, epsilonPrime, alpha, term);
-	}   
-
-	/**
-	 * Main method for passing in input values and performing drift detection
-	 * 
-	 * @param inputValue instance from the stream
-	 * @return boolean value true or false signaling whether a drift has occurred
-	 */
-	public boolean setInput(double inputValue)
-	{
-	    SEEDBlock cursor;
-
-	    addElement(inputValue);
-
-	    if (elementCount % blockSize == 0 && window.getBlockCount() >= 2) // Drift Point Check
-	    {
-		boolean blnReduceWidth = true;
-
-		while (blnReduceWidth)
-		{
-		    blnReduceWidth = false;
-		    int n1 = 0;
-		    int n0 = window.getWidth();
-		    double u1 = 0;
-		    double u0 = window.getTotal();
-
-		    cursor = window.getTail();
-		    while (cursor.getPrevious() != null)
-		    {
-			n0 -= cursor.getItemCount();
-			n1 += cursor.getItemCount();
-			u0 -= cursor.getTotal();
-			u1 += cursor.getTotal();
-			double diff = Math.abs(u1 / n1 - (u0 / n0));
-
-			if (diff > getADWINBound(n0, n1))
-			{
-			    blnReduceWidth = true;
-			    window.setHead(cursor);
-
-			    while (cursor.getPrevious() != null)
-			    {
-				cursor = cursor.getPrevious();
-				window.setWidth(window.getWidth() - cursor.getItemCount());
-				window.setTotal(window.getTotal() - cursor.getTotal());
-				window.setVariance(window.getVariance() - cursor.getVariance());
-				window.setBlockCount(window.getBlockCount() - 1);
-			    }
-
-			    window.getHead().setPrevious(null);
-
-			    return true;
-			}
-			cursor = cursor.getPrevious();
-		    }
-		}
-	    }
-
-	    return false;
-	}
-
-	private double getADWINBound(double n0, double n1)
-	{
-	    double n = n0 + n1;
-	    double dd = Math.log(2 * Math.log(n) / DELTA);
-	    double v = window.getVariance() / window.getWidth();
-	    double m = (1 / (n0)) + (1 / (n1));
-	    double epsilon = Math.sqrt(2 * m * v * dd) + (double) 2 / 3 * dd * m;
-
-	    return epsilon;
-	}
-
-	public void addElement(double value)
-	{
-	    window.addTransaction(value);
-	    elementCount++;
-	}
-    }
-
-    public class SEEDBlock
-    {
-	private SEEDBlock next;
-	private SEEDBlock previous;
-
-	private int blockSize;
-	private double total;
-	private double variance;
-	private int itemCount;
-
-	public SEEDBlock(int blockSize)
-	{
-	    this.next = null;
-	    this.previous = null;
-	    this.blockSize = blockSize;
-
-	    this.total = 0;
-	    this.variance = 0;
-	    this.itemCount = 0;
-	}
-
-	public SEEDBlock(SEEDBlock block)
-	{
-	    this.next = block.getNext();
-	    this.previous = block.getPrevious();
-	    this.blockSize = block.blockSize;
-
-	    this.total = block.total;
-	    this.variance = block.variance;
-	    this.itemCount = block.itemCount;
-	}
-
-	public void setNext(SEEDBlock next)
-	{
-	    this.next = next;
-	}
-
-	public SEEDBlock getNext()
-	{
-	    return this.next;
-	}
-
-	public void setPrevious(SEEDBlock previous)
-	{
-	    this.previous = previous;
-	}
-
-	public SEEDBlock getPrevious()
-	{
-	    return this.previous;
-	}
-
-	public int getBlockSize()
-	{
-	    return blockSize;
-	}
-
-	public void setBlockSize(int blockSize)
-	{
-	    this.blockSize = blockSize;
-	}
-
-	public void add(double value)
-	{
-	    itemCount++;
-	    total += value;
-	}
-
-	public boolean isFull()
-	{
-	    if (itemCount == blockSize)
-	    {
-		return true;
-	    } else
-	    {
-		return false;
-	    }
-	}
-
-	public double getMean()
-	{
-	    return this.total / this.itemCount;
-	}
-
-	public void setTotal(double value)
-	{
-	    this.total = value;
-	}
-
-	public double getTotal()
-	{
-	    return this.total;
-	}
-
-	public void setItemCount(int value)
-	{
-	    this.itemCount = value;
-	}
-
-	public int getItemCount()
-	{
-	    return this.itemCount;
-	}
-
-	public void setVariance(double value)
-	{
-	    this.variance = value;
-	}
-
-	public double getVariance()
-	{
-	    return this.variance;
-	}
-
-    }
-
-
-    public class SEEDWindow
-    {
-	private SEEDBlock head;
-	private SEEDBlock tail;
-
-	private int blockSize;
-	private int width;
-	private double total;
-	private double variance;
-	private int blockCount;
-
-	private int DECAY_MODE = 1;
-	private final int LINEAR_DECAY = 1;
-	private final int EXPONENTIAL_DECAY = 2;
-
-	private int COMPRESSION_MODE = 1;
-	private final int FIXED_TERM = 1;
-
-	private int decayCompressionCount = 0;
-	private int linearFixedTermSize = 50;
-
-	private double epsilonPrime = 0.0;
-	private double alpha = 0.0;
-
-	public SEEDWindow(int blockSize)
-	{
-	    clear();
-	    this.blockSize = blockSize;
-	    addBlockToHead(new SEEDBlock(blockSize));
-	}
-
-	public SEEDWindow(int blockSize, int decayMode, int compressionMode,
-		double epsilonPrime, double alpha, int compressionTerm)
-	{
-	    clear();
-	    this.blockSize = blockSize;
-	    this.DECAY_MODE = decayMode;
-	    this.COMPRESSION_MODE = compressionMode;
-	    this.epsilonPrime = epsilonPrime;
-	    this.alpha = alpha;
-	    setCompressionTerm(compressionTerm);
-	    addBlockToHead(new SEEDBlock(blockSize));
-	}
-
-	public void clear()
-	{
-	    head = null;
-	    tail = null;
-	    width = 0;
-	    blockCount = 0;
-	    total = 0;
-	    variance = 0;
-	}
-
-	public void addTransaction(double value)
-	{
-	    if (tail.isFull())
-	    {
-		if (COMPRESSION_MODE == FIXED_TERM)
-		{
-		    if (tail.getPrevious() != null && decayCompressionCount > linearFixedTermSize)
-		    {
-			decayCompressionCount = 0;
-			SEEDBlock cursor = tail;
-
-			double epsilon = 0.0;
-
-			int i = 0; 
-
-			while (cursor != null && cursor.getPrevious() != null)
-			{
-			    double n0 = cursor.getItemCount();
-			    double n1 = cursor.getPrevious().getItemCount();
-			    double u0 = cursor.getTotal();
-			    double u1 = cursor.getPrevious().getTotal();
-
-			    double diff = Math.abs(u1 / n1 - (u0 / n0));
-
-			    if (DECAY_MODE == LINEAR_DECAY)
-			    {
-				epsilon += epsilonPrime * alpha;
-			    } 
-			    else if (DECAY_MODE == EXPONENTIAL_DECAY)
-			    {
-				epsilon = epsilonPrime * Math.pow(1 + alpha, i);
-			    }
-
-			    if (diff < epsilon)
-			    {
-				compressBlock(cursor);
-			    }
-			    cursor = cursor.getPrevious();
-			    i++; 
-			}
-		    }
-		} 
-
-
-		addBlockToTail(new SEEDBlock(this.blockSize));
-		decayCompressionCount++;
-	    }
-	    tail.add(value);
-	    total += value;
-
-	    width++;
-	    if (width >= 2)
-	    {
-		double incVariance = (width - 1) * (value - total / (width - 1))
-			* (value - total / (width - 1)) / width;
-		variance += incVariance;
-		tail.setVariance(tail.getVariance() + incVariance);
-	    }
-
-	}
-
-	public void compressBlock(SEEDBlock cursor)
-	{
-	    cursor.getPrevious().setTotal(
-		    cursor.getTotal() + cursor.getPrevious().getTotal());
-	    cursor.getPrevious().setItemCount(
-		    cursor.getItemCount() + cursor.getPrevious().getItemCount());
-	    cursor.getPrevious().setVariance(
-		    cursor.getVariance() + cursor.getPrevious().getVariance());
-	    cursor.getPrevious().setBlockSize(
-		    cursor.getBlockSize() + cursor.getPrevious().getBlockSize());
-
-	    if (cursor.getNext() != null)
-	    {
-		cursor.getPrevious().setNext(cursor.getNext());
-		cursor.getNext().setPrevious(cursor.getPrevious());
-	    } else
-	    {
-		cursor.getPrevious().setNext(null);
-		tail = cursor.getPrevious();
-	    }
-
-	    blockCount--;
-	}
-
-	public boolean checkHomogeneity(SEEDBlock block)
-	{
-	    double diff = Math.abs(block.getMean() - block.getPrevious().getMean());
-	    double epsilonPrime = getADWINBound(block.getItemCount(), block
-		    .getPrevious().getItemCount());
-	    // double epsilonPrime = 0.01;
-	    if (diff < epsilonPrime)
-	    {
-		return true;
-	    } else
-	    {
-		return false;
-	    }
-	}
-
-	private double getADWINBound(double n0, double n1)
-	{
-	    double n = n0 + n1;
-	    double dd = Math.log(2 * Math.log(n) / 0.99);
-	    double v = variance / width;
-	    double m = (1 / (n0)) + (1 / (n1));
-	    double epsilon = Math.sqrt(2 * m * v * dd) + (double) 2 / 3 * dd * m;
-
-	    return epsilon;
-	}
-
-	public void addBlockToHead(SEEDBlock block)
-	{
-	    if (head == null)
-	    {
-		head = block;
-		tail = block;
-	    } else
-	    {
-		block.setNext(head);
-		head.setPrevious(block);
-		head = block;
-	    }
-	    blockCount++;
-	}
-
-	public void removeBlock(SEEDBlock block)
-	{
-	    width -= block.getItemCount();
-	    total -= block.getTotal();
-	    variance -= block.getVariance();
-	    blockCount--;
-
-	    if (block.getPrevious() != null && block.getNext() != null)
-	    {
-		block.getPrevious().setNext(block.getNext());
-		block.getNext().setPrevious(block.getPrevious());
-		block.setNext(null);
-		block.setPrevious(null);
-	    } else if (block.getPrevious() == null && block.getNext() != null)
-	    {
-		block.getNext().setPrevious(null);
-		head = block.getNext();
-		block.setNext(null);
-	    } else if (block.getPrevious() != null && block.getNext() == null)
-	    {
-		block.getPrevious().setNext(null);
-		tail = block.getPrevious();
-		block.setPrevious(null);
-	    } else if (block.getPrevious() == null && block.getNext() == null)
-	    {
-		head = null;
-		tail = null;
-	    }
-	}
-
-	public void addBlockToTail(SEEDBlock block)
-	{
-	    if (tail == null)
-	    {
-		tail = block;
-		head = block;
-	    } else
-	    {
-		block.setPrevious(tail);
-		tail.setNext(block);
-		tail = block;
-	    }
-	    blockCount++;
-	}
-
-	public int getBlockCount()
-	{
-	    return this.blockCount;
-	}
-
-	public void setBlockCount(int value)
-	{
-	    this.blockCount = value;
-	}
-
-	public int getWidth()
-	{
-	    return this.width;
-	}
-
-	public void setWidth(int value)
-	{
-	    this.width = value;
-	}
-
-	public void setHead(SEEDBlock head)
-	{
-	    this.head = head;
-	}
-
-	public void setTail(SEEDBlock tail)
-	{
-	    this.tail = tail;
-	}
-
-	public SEEDBlock getHead()
-	{
-	    return this.head;
-	}
-
-	public SEEDBlock getTail()
-	{
-	    return this.tail;
-	}
-
-	public double getTotal()
-	{
-	    return this.total;
-	}
-
-	public void setTotal(double value)
-	{
-	    this.total = value;
-	}
-
-	public double getVariance()
-	{
-	    return this.variance;
-	}
-
-	public void setVariance(double value)
-	{
-	    this.variance = value;
-	}
-
-	public void setBlockSize(int value)
-	{
-	    if (value > 32)
-	    {
-		this.blockSize = value;
-	    } else
-	    {
-		this.blockSize = 32;
-	    }
-	}
-
-	public int getBlockSize()
-	{
-	    return this.blockSize;
-	}
-
-	public double getEpsilonPrime()
-	{
-	    return epsilonPrime;
-	}
-
-	public void setEpsilonPrime(double epsilonPrime)
-	{
-	    this.epsilonPrime = epsilonPrime;
-	}
-
-	public void setAlpha(double alpha)
-	{
-	    this.alpha = alpha;
-	}
-
-	public void setCompressionTerm(int value)
-	{
-	    this.linearFixedTermSize = value;
-	}
-    }
-
-
-
-}
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/STEPD.java b/moa/src/main/java/moa/classifiers/core/driftdetection/STEPD.java
deleted file mode 100644
index 298d6343d..000000000
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/STEPD.java
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- *    STEPD.java
- *    Copyright (C) 2015 Santos, Barros
- *    @authors Silas Garrido T. de Carvalho Santos (sgtcs@cin.ufpe.br)
- *             Roberto S. M. Barros (roberto@cin.ufpe.br) 
- *    @version $Version: 3 $
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * Statistical Test of Equal Proportions method (STEPD), 
- * published as:
- * <p> Kyosuke Nishida and Koichiro Yamauchi: 
- *     Detecting Concept Drift Using Statistical Testing. 
- *     Discovery Science 2007, Springer, vol 4755 of LNCS, pp. 264-269. </p>
- */
-
-package moa.classifiers.core.driftdetection;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-
-import moa.core.ObjectRepository;
-import moa.tasks.TaskMonitor;
-import weka.core.Statistics;
-
-public class STEPD extends AbstractChangeDetector {
-    private static final long serialVersionUID = -3518369648142099719L;
-    
-    public IntOption windowSizeOption = new IntOption("windowSize", 
-            'r', "Recent Window Size.",
-            30, 0, 1000);
-        
-    public FloatOption alphaDriftOption = new FloatOption("alphaDrift",
-            'o', "Drift Significance Level.", 0.003, 0.0, 1.0);
-
-    public FloatOption alphaWarningOption = new FloatOption("alphaWarning",
-            'w', "Warning Significance Level.", 0.05, 0.0, 1.0);
-
-    private int windowSize;
-    private double alphaDrift, alphaWarning;
-    
-    private byte [] storedPredictions;
-    private int firstPos, lastPos;
-    
-    private double ro, rr, wo, wr;   // Correct and incorrect prediction numbers in both windows
-    private int no, nr;   //Number of instances in both windows
-    private double p, Z, sizeInvertedSum;
-
-    public void initialize() {
-    	windowSize = this.windowSizeOption.getValue();
-    	alphaDrift = this.alphaDriftOption.getValue();
-    	alphaWarning = this.alphaWarningOption.getValue();
-        storedPredictions = new byte[windowSize];
-        resetLearning();
-    }
-
-    @Override
-    public void resetLearning() {
-    	firstPos = 0;
-    	lastPos = -1;   // This means storedPredictions is empty.
-        wo = wr = 0.0;
-        no = nr = 0;
-        this.isChangeDetected = false;
-    }
-
-    @Override
-    public void input(double prediction) {   // In MOA, 1.0=false, 0.0=true.
-        if (!this.isInitialized) {
-            initialize();
-            this.isInitialized = true;
-        } else {
-            if (this.isChangeDetected) {
-                resetLearning();
-            }
-        }
-
-        if (nr == windowSize) {   // Recent window is full.
-            wo = wo + storedPredictions[firstPos];  // Oldest prediction in recent window 
-            no++;                                   // is moved to older window,
-            wr = wr - storedPredictions[firstPos];
-            firstPos++;   // Start of recent window moves.
-            if (firstPos == windowSize) {
-            	firstPos = 0;
-            }
-        } else {   // Recent window grows.
-            nr++;
-        }
-        
-        lastPos++;   // Adds prediction at the end of recent window.
-        if (lastPos == windowSize) {
-            lastPos = 0;
-        };
-        storedPredictions[lastPos] = (byte) prediction;
-        wr += prediction;
-
-        this.isWarningZone = false;
-        
-        if (no >= windowSize) {   // The same as: (no + nr) >= 2 * windowSize.
-            ro = no - wo;   // Numbers of correct predictions are calculated.
-            rr = nr - wr;
-            sizeInvertedSum = 1.0 / no + 1.0 / nr;   // Auxiliary variable.
-            p = (ro + rr) / (no + nr);   // Calculation of the statistics of STEPD.
-            Z = Math.abs(ro / no - rr / nr);
-            Z = Z - sizeInvertedSum / 2.0;
-            Z = Z / Math.sqrt(p * (1.0 - p) * sizeInvertedSum);
-            
-            Z = Statistics.normalProbability(Math.abs(Z));
-            Z = 2 * (1 - Z);
-            
-            if (Z < alphaDrift) {  // Drift Level
-                this.isChangeDetected = true;
-            } else { 
-            	if (Z < alphaWarning) {  // Warning Level
-                    this.isWarningZone = true;
-            	}
-            }
-        }
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        // TODO Auto-generated method stub
-    }
-}
-
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/SeqDrift1ChangeDetector.java b/moa/src/main/java/moa/classifiers/core/driftdetection/SeqDrift1ChangeDetector.java
deleted file mode 100644
index 72aae962a..000000000
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/SeqDrift1ChangeDetector.java
+++ /dev/null
@@ -1,510 +0,0 @@
-/*
- *    SeqDrift1ChangeDetector.java
- *    Copyright (C) 2011 University of Waikato, Hamilton, New Zealand
- *    @author Sakthithasan Sripirakas sripirakas363 at yahoo dot com
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package moa.classifiers.core.driftdetection;
-
-import java.util.ArrayList;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-
-import moa.AbstractMOAObject;
-import moa.classifiers.core.driftdetection.SeqDrift2ChangeDetector.Repository;
-import moa.core.ObjectRepository;
-import moa.tasks.TaskMonitor;
-
-/**
- * SeqDrift1ChangeDetector.java. This extends Abstract Change Detector 
- * as required by MOA.
- * 
- * Sakthithasan, S., Pears, R., & Koh, Y. (2013). One Pass Concept Change
- * Detection for Data Streams. In J. Pei, V. Tseng, L. Cao, H. Motoda, & G. Xu
- * (Eds.), Advances in Knowledge Discovery and Data Mining (Vol. 7819, pp.
- * 461-472): Springer Berlin Heidelberg.
- *
- * @author Sakthithasan Sripirakas sripirakas363 at yahoo dot com
- * @version $Revision: 7 $
- */
-public class SeqDrift1ChangeDetector extends AbstractChangeDetector {
-
-    protected SeqDrift1 seqDrift1;
-    //protected ADWIN adwin;
-
-    public FloatOption deltaOption = new FloatOption("deltaSeqDrift1", 'd',
-            "Delta of SeqDrift1 change detection",0.01, 0.0, 1.0);
-    
-    public FloatOption deltaWarningOption = new FloatOption("deltaWarningOption", 
-            'w', "Delta of SeqDrift1 change detector to declare warning state",0.1, 0.0, 1.0);
-    
-    public IntOption blockSeqDriftOption = new IntOption("blockSeqDrift1Option",'b',"Block size of SeqDrift1 change detector", 200, 100, 10000);
-
-    @Override
-    public void input(double inputValue) {
-        if (this.seqDrift1 == null) {
-            resetLearning();
-        }
-        this.isChangeDetected = seqDrift1.setInput(inputValue);
-        this.isWarningZone = false;
-        this.delay = 0.0;
-        this.estimation = seqDrift1.getEstimation();
-    }
-
-    @Override
-    public void resetLearning() {
-        seqDrift1 = new SeqDrift1((double) this.deltaOption.getValue(),((int) this.blockSeqDriftOption.getValue()), ((double) this.deltaWarningOption.getValue()));
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        // TODO Auto-generated method stub
-    }
-    
-
-/**
- * SeqDrift1 uses sliding window to build a sequential change detection model
- * that uses statistically sound guarantees defined using Bernstein Bound on
- * false positive and false negative rates. This is a block based approach and
- * checks for changes in the data values only at block boundaries as opposed to
- * the methods on per instance basis. SeqDrift1 maintains a sliding window and
- * repository. Repository gathers the new instances and sliding window stores
- * only the data values that are statistically not different, in other words
- * from the same distribution. If the data values in the repository are
- * consistent with the values in sliding window the data values of the
- * repository are copied to the sliding window applying reservoir algorithm. The
- * hypothesis is that the mean values of the sliding window and right repository
- * are not statistically different. In addition, SeqDrift1 declares a warning
- * state depending on warning significance level and increases sample size to
- * get a statistically more rigorous mean value
- *
- *
- *
- * Sakthithasan, S., Pears, R., & Koh, Y. (2013). One Pass Concept Change
- * Detection for Data Streams. In J. Pei, V. Tseng, L. Cao, H. Motoda, & G. Xu
- * (Eds.), Advances in Knowledge Discovery and Data Mining (Vol. 7819, pp.
- * 461-472): Springer Berlin Heidelberg.
- *
- * @author Sakthithasan Sripirakas sripirakas363 at yahoo dot com
- */
-public class SeqDrift1 extends AbstractMOAObject {
-
-    private Repository leftRepository = null;
-    private Repository rightRepository = null;
-    private ArrayList<Integer> uniqueRandomNumbers = null;
-
-    //parameters
-    private double significanceLevel = 0.01;
-    private int blockSize = 200;
-    private int sampleSize = 200;
-    private int slidingWindowBlockCount; 
-    private double warningSignificanceLevel = 0.1;
-
-    //variables
-    private int instanceCount = 0;
-    private double leftRepositoryMean = 0.0;
-    private double rightRepositoryMean = 0.0;
-    private int blockCount = 0;
-    private double variance = 0.0;
-    private boolean isWarning = false;
-    private double total = 0.0;
-
-    private Epsilon epsilon = null;
-
-    public final static int DRIFT = 0;
-    public final static int WARNING = 1;
-    public final static int HOMOGENEOUS = 2;
-    public final static int INTERNAL_DRIFT = 3;
-
-    public SeqDrift1(double _significanceLevel, int _blockSize, double _significanceWarningLevel) {
-        //Parameters
-        significanceLevel = _significanceLevel;
-        blockSize = _blockSize;
-        sampleSize = _blockSize;
-        slidingWindowBlockCount = (int) (1 / _significanceLevel); //Sliding window size is automaticall set as 1/delta
-        warningSignificanceLevel = _significanceWarningLevel;
-
-        //Variables
-        instanceCount = 0;
-        blockCount = 0;
-        variance = 0.0;
-        isWarning = false;
-        total = 0.0;
-        epsilon = new Epsilon();
-
-        //Data Structures    
-        SeqDrift2ChangeDetector sd = new SeqDrift2ChangeDetector();
-        leftRepository = sd.new Repository(blockSize);
-        rightRepository = sd.new Repository(blockSize);
-
-        uniqueRandomNumbers = new ArrayList<Integer>();
-    }
-
-    public boolean setInput(double _inputValue) {
-        ++instanceCount;
-
-        addToRightRepository(_inputValue);
-        total = total + _inputValue;
-
-        if ((instanceCount % sampleSize) == 0) //Drift point check
-        {
-            rightRepository.markLastAddedBlock();
-
-            if (isWarning) {
-                removeExcessRightRepositoryValues();
-            }
-            //Assume that there is no warning or drift now
-            isWarning = false;
-
-            //Detect a drift with warning significance level
-            int iDriftType = getDriftType();
-
-            if (iDriftType == DRIFT) 
-            {
-                isWarning = false; //Warning state is set to false as it is an actual drift
-                clearLeftRepository(); 
-                moveValuesFromRightToLeft();
-                sampleSize = blockSize;
-                return true;
-            } else if (iDriftType == WARNING) {
-                isWarning = true;
-                sampleSize = sampleSize * 2;
-                return false;//In warning state no instance is moved from sliding window to repository. Thus returning now               
-            } /*
-             else if(iDriftType == INTERNAL_DRIFT)
-             {
-             isWarning = false;
-             isDrift   = false;  
-             sampleSize = blockSize;
-             clearrepository(); //Due to drift clear the data that belong to the old concept in repository
-             movefromsliding windowTorepository(); 
-             return false;
-             }
-             */
-            else 
-            {
-                isWarning = false;
-                moveValuesFromRightToLeft(); //All instances in sliding window should be moved to repository if no drift or if drift but not in warning             
-                return false;
-            }
-        }
-        return false;
-    }
-
-    /**
-     * Adding new instance to  sliding window
-     * <p>
-     * @param _inputValue A double instance
-     * @return void
-     */
-    private void addToRightRepository(double _inputValue) {
-        if ((rightRepository.getSize() < sampleSize) || isWarning) //By default sliding window should have maximum of blockSize instances except in warning state
-        {
-            rightRepository.add(new Double(_inputValue));
-        } else {
-            System.out.println("request to add to sliding window sliding window size :" + rightRepository.getSize() + " Warning :" + isWarning);
-        }
-    }
-
-    /**
-     * Removes excess instances in sliding window when the number of blocks is more than
-     * the sliding window size threshold
-     * <p>
-     * @param void
-     * @return void
-     */
-    private void removeExcessRightRepositoryValues() {
-        int maxRightRepositorySize = slidingWindowBlockCount * blockSize;
-        while (rightRepository.getSize() > maxRightRepositorySize) {
-            total = total - rightRepository.getFirstBlockTotal();
-            rightRepository.removeFirstBlock();
-        }
-    }
-
-    /**
-     * Moving the instances from  sliding window to  repository
-     * <p>
-     * @param void
-     * @return void
-     */
-    private void moveValuesFromRightToLeft() {
-        for (int iIndex = 0; iIndex < rightRepository.getSize(); iIndex++) // Copy all instances from sliding window to repository
-        {
-            if (((iIndex) % sampleSize) == 0) {
-                leftRepository.add(rightRepository.get(iIndex), true);
-            } else {
-                leftRepository.add(rightRepository.get(iIndex));
-            }
-        }
-        blockCount = blockCount + rightRepository.getSize() / blockSize; //Determine the block counter value after adding the instances
-
-        if (slidingWindowBlockCount > 0) //Sliding is enabled
-        {
-            while (blockCount > slidingWindowBlockCount) //Remove old instances from  repository
-            {
-                total = total - leftRepository.getFirstBlockTotal();
-                leftRepository.removeFirstBlock();
-                --blockCount;
-            }
-        }
-        if (!isWarning) //If in warning do not remove the instances from  sliding window
-        {
-            rightRepository.removeAll();
-        } else {
-            System.out.println("ERROR: requested to move instances from  sliding window to  repository");
-            System.exit(2);
-        }
-    }
-
-    /**
-     * Remove all elements from repository after a drift is detected
-     * <p>
-     * After deletion the block counter is set to zero
-     *
-     * @param void
-     * @return void
-     */
-    private void clearLeftRepository() {
-        blockCount = 0;
-        total = total - leftRepository.getTotal();
-        leftRepository.removeAll();
-    }
-
-    /**
-     * Detects a drift
-     * <p>
-     * @param _bIsWarning Drift detection in warning significance level or
-     * actual significance level
-     * @return boolean True - if drift is detected. False - otherwise
-     */
-    private int getDriftType() {
-        if (getWidth() > blockSize) {
-            leftRepositoryMean = getLeftRepositorySampleMean(); //Get the subsample mean from  repository
-            rightRepositoryMean = getRightRepositorySampleMean(); //Get the subsample mean from  sliding window
-            epsilon = getEpsilon();
-
-            double absValue = Math.abs(rightRepositoryMean - leftRepositoryMean);
-            if (instanceCount > sampleSize && leftRepository.getSize() > 0) {
-                if (epsilon.d_warningEpsilon <= absValue) //Warning Drift is detetced
-                {
-                    if (epsilon.d_driftEpsilon <= absValue) //Drift is detetced
-                    {
-                        //if(rightRepositoryMean > leftRepositoryMean)
-                        //{
-                        return DRIFT;
-                        //}
-                        /*
-                         else
-                         {
-                         return INTERNAL_DRIFT;
-                         }
-                         */
-                    } else {
-                        return WARNING;
-                    }
-                } else {
-                    return HOMOGENEOUS;
-                }
-            }
-            return HOMOGENEOUS;
-        } else {
-            return HOMOGENEOUS;
-        }
-    }
-    private double getLeftRepositorySampleMean() {
-        double leftTotal = 0.0;
-        if (leftRepository.getSize() > 0) {
-            if (leftRepository.getSize() <= sampleSize) {
-                return getLeftResitoryMean();
-            } else {
-                int iPossibleSampleSize = getPossibleSampleSize();
-
-                for (int iCount = 0; iCount < iPossibleSampleSize; iCount++) {
-                    int iNextRandomNumber = getNextRandomNumber(leftRepository.getSize() - 1);
-                    if (isUniqueRandomNumber(iNextRandomNumber)) {
-                        leftTotal = leftTotal + leftRepository.get(iNextRandomNumber);
-                    } else {
-                        iCount--;
-                    }
-                }
-                uniqueRandomNumbers.clear();
-            }
-        }
-        return leftTotal / sampleSize;
-    }
-
-    private int getPossibleSampleSize() {
-        int iNumberSampleElements = 0;
-        int leftResitorySize = leftRepository.getSize();
-        int rightRepositorySize = rightRepository.getSize();
-
-        if (sampleSize <= leftResitorySize && sampleSize <= rightRepositorySize) {
-            iNumberSampleElements = sampleSize;
-        } else {
-            if (leftResitorySize > rightRepositorySize) {
-                sampleSize = leftResitorySize;
-            } else {
-                sampleSize = rightRepositorySize;
-            }
-        }
-        return iNumberSampleElements;
-    }
-
-    private boolean isUniqueRandomNumber(int _iTrialNum) {
-        for (int iIndex = 0; iIndex < uniqueRandomNumbers.size(); iIndex++) {
-            if (uniqueRandomNumbers.get(iIndex) == _iTrialNum) {
-                return false;
-            }
-        }
-        uniqueRandomNumbers.add(_iTrialNum);
-        return true;
-    }
-
-    private double getLeftResitoryMean() {
-        double dTotal = 0.0;
-        dTotal = dTotal + leftRepository.getTotal();
-        return dTotal / sampleSize;
-    }
-
-    private double getRightRepositoryMean() {
-        double dTotal = 0.0;
-        dTotal = dTotal + rightRepository.getTotal();
-        return dTotal / sampleSize;
-    }
-
-    private double getRightRepositorySampleMean() {
-        double dTotal = 0.0;
-        if (rightRepository.getSize() > 0) {
-            if (rightRepository.getSize() <= sampleSize) {
-                return getRightRepositoryMean();
-            } else {
-                int iPossibleSampleSize = getPossibleSampleSize();
-                for (int iCount = 0; iCount < iPossibleSampleSize; iCount++) {
-                    int iNextRandomNumber = getNextRandomNumber(rightRepository.getSize() - 1);
-                    if (isUniqueRandomNumber(iNextRandomNumber)) {
-                        dTotal = dTotal + rightRepository.get(iNextRandomNumber);
-                    } else {
-                        iCount--;
-                    }
-                }
-                uniqueRandomNumbers.clear();
-            }
-        }
-        return dTotal / sampleSize;
-    }
-
-    private int getNextRandomNumber(int _iSize) {
-        double dRandomNumber = _iSize * Math.random();
-        long lRoundedNumber = Math.round(dRandomNumber);
-        return (int) lRoundedNumber;
-    }
-
-    private double getVariance() {
-        double dMean = getPopulationMean();
-        double d1minusMean = dMean - 1;
-        double dtotalsize = getWidth();
-        double x = total * d1minusMean * d1minusMean + (dtotalsize - total) * dMean * dMean;
-        double y = dtotalsize - 1;
-        return x / y;
-    }
-
-    private Epsilon getEpsilon() {
-        int iNumberOfTests = leftRepository.getNumOfTests() + rightRepository.getNumOfTests();
-
-        if (iNumberOfTests > 1) {
-            variance = getVariance();
-
-            //Drift epsilon
-            double ddeltadash = getDriftEpsilon(iNumberOfTests);
-            double x = Math.log(4.0 / ddeltadash);
-            double squareRootValue = Math.sqrt(x * x + 18 * variance * sampleSize * x);
-            double depsilon = (2.0 / (3 * sampleSize)) * (x + squareRootValue);
-            epsilon.d_driftEpsilon = depsilon;
-
-            //warning epsilon                             
-            ddeltadash = getWarningEpsilon(iNumberOfTests);
-            x = Math.log(4.0 / ddeltadash);
-            squareRootValue = Math.sqrt(x * x + 18 * variance * sampleSize * x);
-            depsilon = (2.0 / (3 * sampleSize)) * (x + squareRootValue);
-            epsilon.d_warningEpsilon = depsilon;
-        }
-        return epsilon;
-    }
-
-    private double getDriftEpsilon(int _inumTests) {
-        double errorValue = 2.0 * (1.0 - Math.pow(0.5, _inumTests));
-
-        double ddeltadash = significanceLevel;
-        ddeltadash = significanceLevel / errorValue;
-
-        return ddeltadash;
-    }
-
-    private double getWarningEpsilon(int _inumTests) {
-        double dTotalError = 2.0 * (1.0 - Math.pow(0.5, _inumTests));
-        double ddeltadash = warningSignificanceLevel / dTotalError;
-
-        return ddeltadash;
-    }
-
-    private double getPopulationMean() {
-        return getTotal() / getWidth();
-    }
-
-    private double getTotal() {
-        return total;
-    }
-
-    public int getWidth() {
-        return leftRepository.getSize() + rightRepository.getSize();
-    }
-
-    public double getEstimation() {
-        int iWidth = getWidth();
-
-        if (iWidth != 0) {
-            return getTotal() / getWidth();
-        } else {
-            return 0;
-        }
-    }
-
-    public void getDescription(StringBuilder sb, int indent) {
-    }
-
-}
-
-class Epsilon {
-
-    double d_warningEpsilon = 0.0;
-    double d_driftEpsilon = 0.0;
-
-    public Epsilon() {
-        d_warningEpsilon = 0.0;
-        d_driftEpsilon = 0.0;
-    }
-
-    public void getDescription(StringBuilder sb, int indent) {
-    }
-  }
-}
-
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/SeqDrift2ChangeDetector.java b/moa/src/main/java/moa/classifiers/core/driftdetection/SeqDrift2ChangeDetector.java
deleted file mode 100644
index 37de7e7fc..000000000
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/SeqDrift2ChangeDetector.java
+++ /dev/null
@@ -1,595 +0,0 @@
-/*
- *    SeqDrift2ChangeDetector.java
- *    Copyright (C) 2011 University of Waikato, Hamilton, New Zealand
- *    @author Sakthithasan Sripirakas sripirakas363 at yahoo dot com
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package moa.classifiers.core.driftdetection;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-
-import moa.AbstractMOAObject;
-import moa.core.ObjectRepository;
-import moa.tasks.TaskMonitor;
-
-/**
- * SeqDriftChangeDetector.java. This extends Abstract Change Detector 
- * as required by MOA.
- * 
- * Pears, R., Sakthithasan, S., & Koh, Y. (2014). Detecting concept change in 
- * dynamic data streams. Machine Learning, 97(3), 259-293. doi:10.1007/s10994-013-5433-9
- *
- * @author Sakthithasan Sripirakas sripirakas363 at yahoo dot com
- * @version $Revision: 7 $
- */
-public class SeqDrift2ChangeDetector extends AbstractChangeDetector {
-
-    protected SeqDrift2 seqdrift;
-
-    public FloatOption deltaSeqDrift2Option = new FloatOption("deltaSeq2Drift", 'd',
-            "Delta of SeqDrift2 change detection",0.01, 0.0, 1.0);
-    
-    public IntOption blockSeqDrift2Option = new IntOption("blockSeqDrift2Option",'b',"Block size of SeqDrift2 change detector", 200, 100, 10000);
-
-    @Override
-    public void input(double inputValue) {
-        if (this.seqdrift == null) {
-            resetLearning();
-        }
-        this.isChangeDetected = seqdrift.setInput(inputValue);
-        this.isWarningZone = false;
-        this.delay = 0.0;
-        this.estimation = seqdrift.getEstimation();
-    }
-
-    @Override
-    public void resetLearning() {
-        seqdrift = new SeqDrift2((double) this.deltaSeqDrift2Option.getValue(),((int) this.blockSeqDrift2Option.getValue()));
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        // TODO Auto-generated method stub
-    }
-    
-
-/**
- * SeqDrift2 uses reservoir sampling to build a sequential change detection
-* model that uses statistically sound guarantees defined using Bernstein Bound 
-* on false positive and false negative rates. This is a block based approach and checks 
-* for changes in the data values only at block boundaries as opposed to the 
-* methods on per instance basis. SeqDrift maintains a reservoir and a repository.
-* Repository gathers the new instances and reservoir stores only the data values 
-* that are statistically not different, in other words from the same distribution. 
-* If the data values in the repository are consistent with the values in reservoir, 
-* the data values of the repository are copied to the reservoir applying 
-* reservoir algorithm.The hypothesis is that the mean values of the reservoir and right repository 
-* are not statistically different
- * 
- * 
- * 
- * Pears, R., Sakthithasan, S., & Koh, Y. (2014). Detecting concept change in 
- * dynamic data streams. Machine Learning, 97(3), 259-293. doi:10.1007/s10994-013-5433-9
- * 
- * @author Sakthithasan Sripirakas sripirakas363 at yahoo dot com
- */
-public class SeqDrift2 extends AbstractMOAObject {
-
-    private final Reservoir rightRepository;
-    private final Reservoir leftReservoir;
-
-    //parameters
-    private final int blockSize;
-
-    //parameters that are optimized
-    private final double significanceLevel;
-    private int leftReservoirSize;
-    private final int rightRepositorySize;
-    private final double k;
-
-    //variables
-    private int instanceCount = 0;
-    private double leftReservoirMean = 0.0;
-    private double rightRepositoryMean = 0.0;
-    private double variance = 0.0;
-    private double total = 0.0;
-    private double epsilon = 0.0;
-
-    private final static int DRIFT = 0;
-    private final static int NODRIFT = 2;
-    private final static int INTERNAL_DRIFT = 3;
-
-    /**
-     * SeqDrift change detector requires two parameters: significance level and 
-     * block size. Significance level controls the false positive rate and block 
-     * size sets the interval of two consecutive hypothesis tests
-     * Block Size is a positive integer and significance level is a double value
-     * between 0 and 1
-     * @param _significanceLevel
-     * @param _blockSize
-     */
-    public SeqDrift2(double _significanceLevel, int _blockSize) {
-        significanceLevel = _significanceLevel;
-        blockSize = _blockSize;
-        leftReservoirSize = _blockSize;
-        rightRepositorySize = _blockSize;
-        k = 0.5;
-
-        instanceCount = 0;
-        variance = 0;
-        total = 0.0;
-        epsilon = 0.0;
-
-        //Data Structures        
-        leftReservoir = new Reservoir(leftReservoirSize, blockSize);
-        rightRepository = new Reservoir(rightRepositorySize, blockSize);
-    }
-    /**
-     * This method can be used to directly interface with SeqDrift change
-     * detector. This method requires a numerical value as an input. The return 
-     * value indicates whether there is a change detected or not. 
-     * @param input numerical value
-     */
-    public boolean setInput(double _inputValue) {
-        ++instanceCount;
-        //i_numInstances++;
-
-        addToRightReservoir(_inputValue);
-        total = total + _inputValue;
-
-        if ((instanceCount % blockSize) == 0) //checking for drift at block boundary
-        {
-            int iDriftType = getDriftType();
-
-            if (iDriftType == DRIFT) {
-                clearLeftReservoir();
-                moveFromRepositoryToReservoir();
-                return true;
-            } 
-            /*
-            else if (iDriftType == INTERNAL_DRIFT) { //Ignoring the changes where 
-            mean values decrease
-                clearLeftReservoir();
-                moveFromRepositoryToReservoir();
-                return false;
-            }
-            */
-            else //No drift is detected
-            {
-                moveFromRepositoryToReservoir();
-                return false;
-            }
-        }
-        return false;
-    }
-
-    /**
-     *
-     * <p>
-     * This method adds new value to right reservoir
-     *
-     * @param _inputValue A double data value
-     * @return void
-     */
-    private void addToRightReservoir(double _inputValue) {
-        rightRepository.addElement(_inputValue);
-    }
-
-    /**
-     *
-     * <p>
-     * This method copies the data values of the repository to the reservoir
-     * applying reservoir algorithm
-     *
-     * @param void
-     * @return void
-     */
-    private void moveFromRepositoryToReservoir() {
-        leftReservoir.copy(rightRepository);
-    }
-
-    /**
-     *
-     * <p>
-     * This method removes all elements from the reservoir after a drift is
-     * detected.
-     *
-     * @param void
-     * @return void
-     */
-    private void clearLeftReservoir() {
-        total = total - leftReservoir.getTotal();
-        leftReservoir.clear();
-    }
-
-    /**
-     *
-     * <p>
-     * This method returns the type of drift detected The possible values are:
-     * DRIFT, INTERNAL_DRIFT and NODRIFT
-     *
-     * @param
-     * @return boolean True - if drift is detected. False - otherwise
-     */
-    private int getDriftType() {
-        if (getWidth() > blockSize) {
-            leftReservoirMean = getLeftReservoirMean();
-            rightRepositoryMean = getRightRepositoryMean();
-            optimizeEpsilon();
-
-            if ((instanceCount > blockSize) && (leftReservoir.getSize() > 0)) {
-                if (epsilon <= Math.abs(rightRepositoryMean - leftReservoirMean)) {
-                    //if (rightRepositoryMean > leftReservoirMean) {
-                        return DRIFT;
-                    //} 
-                    /*else {
-                        return INTERNAL_DRIFT;
-                    }
-                    */
-                } else {
-                    return NODRIFT;
-                }
-            }
-            return NODRIFT;
-        } else {
-            return NODRIFT;
-        }
-    }
-
-    private double getLeftReservoirMean() {
-        return leftReservoir.getSampleMean();
-    }
-
-    private double getRightRepositoryMean() {
-        return rightRepository.getSampleMean();
-    }
-
-    private double getVariance() {
-        double mean = getMean();
-        double meanminum1 = mean - 1;
-        double size = getWidth();
-        double x = getTotal() * meanminum1 * meanminum1 + (size - getTotal()) * mean * mean;
-        double y = size - 1;
-        return x / y;
-    }
-
-    private void optimizeEpsilon() {
-        int tests = leftReservoir.getSize() / blockSize;
-
-        if (tests >= 1) {
-            variance = getVariance();
-            if (variance == 0) {
-                variance = 0.0001; // to avoid divide by zero exception
-            }
-
-            //Drift epsilon
-            double ddeltadash = getDriftEpsilon(tests);
-            double x = Math.log(4.0 / ddeltadash);
-            double ktemp = this.k;
-
-            double previousStepEpsilon;
-            double currentStepEpsilon;
-            double squareRootValue = 0.0;
-
-            boolean IsNotOptimized = true;
-            while (IsNotOptimized) {
-                squareRootValue = Math.sqrt(x * x + 18 * rightRepositorySize * x * variance);
-                previousStepEpsilon = (1.0 / (3 * rightRepositorySize * (1 - ktemp))) * (x + squareRootValue);
-                ktemp = 3 * ktemp / 4;
-                currentStepEpsilon = (1.0 / (3 * rightRepositorySize * (1 - ktemp))) * (x + squareRootValue);
-
-                if (((previousStepEpsilon - currentStepEpsilon) / previousStepEpsilon) < 0.0001) {
-                    IsNotOptimized = false;
-                }
-            }
-            ktemp = 4 * ktemp / 3;
-            ktemp = adjustForDataRate(ktemp);
-            leftReservoirSize = (int) (rightRepositorySize * (1 - ktemp) / ktemp);
-            leftReservoir.setMaxSize(leftReservoirSize);
-            squareRootValue = Math.sqrt(x * x + 18 * rightRepositorySize * x * variance);
-            currentStepEpsilon = (1.0 / (3 * rightRepositorySize * (1 - ktemp))) * (x + squareRootValue);
-            epsilon = currentStepEpsilon;
-
-        }
-    }
-
-    private double getDriftEpsilon(int _inumTests) {
-        double dSeriesTotal = 2.0 * (1.0 - Math.pow(0.5, _inumTests));
-        double ddeltadash = significanceLevel / dSeriesTotal;
-        return ddeltadash;
-    }
-
-    private double getMean() {
-        return getTotal() / getWidth();
-    }
-
-    private double getTotal() {
-        return rightRepository.getTotal() + leftReservoir.getTotal();
-    }
-
-    private double adjustForDataRate(double _dKr) {
-        double meanIncrease = (rightRepository.getSampleMean() - leftReservoir.getSampleMean());
-        double dk = _dKr;
-        if (meanIncrease > 0) {
-            dk = dk + ((-1) * (meanIncrease * meanIncrease * meanIncrease * meanIncrease) + 1) * _dKr;
-        } else if (meanIncrease <= 0) {
-            dk = _dKr;
-        }
-        return dk;
-    }
-
-    private int getWidth() {
-        return leftReservoir.getSize() + rightRepository.getSize();
-    }
-
-    /**
-     * Gets the prediction of next values.
-     * @return Predicted value of next data value
-     */
-    public double getEstimation() {
-        int iWidth = getWidth();
-
-        if (iWidth != 0) {
-            return getTotal() / getWidth();
-        } else {
-            return 0;
-        }
-    }
-
-    public void getDescription(StringBuilder sb, int indent) {
-    }
-
-
-}
-
-public class Reservoir {
-
-    private int size;
-    private double total;
-    private final int blocksize;
-    private final Repository dataContainer;
-    private int instanceCount;
-    private int MAX_SIZE;
-
-    public Reservoir(int _iSize, int _iBlockSize) {
-        MAX_SIZE = _iSize;
-        total = 0;
-        blocksize = _iBlockSize;
-        instanceCount = 0;
-        dataContainer = new Repository(blocksize);
-    }
-
-    public double getSampleMean() {
-        return total / size;
-    }
-
-    public void addElement(double _dValue) {
-        try {
-            if (size < MAX_SIZE) {
-                dataContainer.add(new Double(_dValue));
-                total = total + _dValue;
-                size++;
-            } else {
-                int irIndex = (int) (Math.random() * instanceCount);
-                if (irIndex < MAX_SIZE) {
-                    total = total - dataContainer.get(irIndex);
-                    dataContainer.addAt(irIndex, _dValue);
-                    total = total + _dValue;
-                }
-            }
-            instanceCount++;
-        } catch (Exception e) {
-            System.out.println("2 Exception" + e);
-        }
-
-    }
-
-    public double get(int _iIndex) {
-        return dataContainer.get(_iIndex);
-    }
-
-    public int getSize() {
-        return size;
-    }
-
-    public void clear() {
-        dataContainer.removeAll();
-        total = 0;
-        size = 0;
-    }
-
-    public double getTotal() {
-        return total;
-    }
-
-    public void copy(Reservoir _oSource) {
-        for (int iIndex = 0; iIndex < _oSource.getSize(); iIndex++) {
-            addElement(_oSource.get(iIndex));
-        }
-        _oSource.clear();
-    }
-
-    public void setMaxSize(int _iMaxSize) {
-        MAX_SIZE = _iMaxSize;
-    }
-
-}
-
-public class Repository {
-
-    private final int blockSize;
-    private final List<Block> blocks;
-    private int indexOfLastBlock;
-    private int instanceCount;
-    private double total;
-    
-    public Repository(int _iBlockSize) {
-        blockSize = _iBlockSize;
-        indexOfLastBlock = -1;
-        instanceCount = 0;
-        total = 0;
-        blocks = new ArrayList<Block>();
-    }
-
-    public void add(double _dValue) {
-        if ((instanceCount % blockSize) == 0) {
-            blocks.add(new Block(blockSize));
-            indexOfLastBlock++;
-        }
-        blocks.get(indexOfLastBlock).add(_dValue);
-        instanceCount++;
-        total = total + _dValue;
-    }
-    
-    public void add(double _dValue, boolean _isTested)
-	{
-		if((instanceCount % blockSize) == 0)
-		{
-			blocks.add(new Block(blockSize, _isTested));
-			indexOfLastBlock++;
-		}
-		blocks.get(indexOfLastBlock).add(_dValue);
-		instanceCount++;
-		total= total + _dValue;
-	}
-
-    public double get(int _iIndex) {
-        return blocks.get(_iIndex / blockSize).data[(_iIndex % blockSize)];
-    }
-
-    public void addAt(int _iIndex, double _dValue) {
-        blocks.get(_iIndex / blockSize).addAt(_iIndex % blockSize, _dValue);
-    }
-
-    public int getSize() {
-        return instanceCount;
-    }
-
-    public double getTotal() {
-        double dTotal = 0.0;
-        for (int iIndex = 0; iIndex < blocks.size(); iIndex++) {
-            dTotal = dTotal + blocks.get(iIndex).total;
-        }
-        return dTotal;
-    }
-    
-    public double getFirstBlockTotal()
-	{
-		return blocks.get(0).total;
-
-	}
-    
-    public void markLastAddedBlock()
-        {
-            if(blocks.size() > 0)
-            {
-                blocks.get(blocks.size() - 1).setTested(true);
-            }
-        }
-    
-    public void removeFirstBlock()
-	{
-		total = total - blocks.get(0).total;
-		blocks.remove(0);
-		instanceCount = instanceCount - blockSize;
-		indexOfLastBlock--;
-	}
-
-    public void removeAll() {
-        blocks.clear();
-        indexOfLastBlock = -1;
-        instanceCount = 0;
-        total = 0;
-    }
-    
-    public int getNumOfTests()
-        {
-            int iNumTests = 0;
-            for(int iIndex = 0; iIndex < blocks.size(); iIndex++)
-            {
-                if(blocks.get(iIndex).IsTested())
-                    iNumTests++;
-            }
-            return iNumTests;
-        }
-
-}
-
-public class Block {
-
-    public double[] data;
-    public double total;
-    private int indexOfLastValue;
-    
-    private boolean b_IsTested;
-
-    Block(int _iLength) {
-        data = new double[_iLength];
-        total = 0.0;
-        indexOfLastValue = 0;
-        for (int iIndex = 0; iIndex < data.length; iIndex++) {
-            data[iIndex] = -1;
-        }
-    }
-    
-    
-    Block(int _iLength, boolean _isTested)
-	{
-		data = new double[_iLength];
-                total     = 0.0;
-                indexOfLastValue = 0;
-                b_IsTested = _isTested;
-                for(int iIndex=0;iIndex < data.length;iIndex++)
-                {
-                    data[iIndex] = -1;
-                }
-	}
-
-    public void add(double _dValue) {
-        if (indexOfLastValue < data.length) {
-            data[indexOfLastValue] = _dValue;
-            total = total + _dValue;
-            indexOfLastValue++;
-        } else {
-            System.out.println("ERROR in adding to Block. Last Index :" + indexOfLastValue + " Total :" + total + " Array Length :" + data.length);
-            System.exit(2);
-        }
-    }
-
-    public void addAt(int _iIndex, double _dNewValue) {
-        total = total - data[_iIndex] + _dNewValue;
-        data[_iIndex] = _dNewValue;
-    }
-    
-    public void setTested(boolean _isTested)
-        {
-            b_IsTested = _isTested;
-        }
-        public boolean IsTested()
-        {
-            return b_IsTested;
-        }
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/core/splitcriteria/GiniSplitCriterion.java b/moa/src/main/java/moa/classifiers/core/splitcriteria/GiniSplitCriterion.java
deleted file mode 100644
index 63c7048f9..000000000
--- a/moa/src/main/java/moa/classifiers/core/splitcriteria/GiniSplitCriterion.java
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- *    GiniSplitCriterion.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.core.splitcriteria;
-
-import moa.core.ObjectRepository;
-import moa.core.Utils;
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
-/**
- * Class for computing splitting criteria using Gini
- * with respect to distributions of class values.
- * The split criterion is used as a parameter on
- * decision trees and decision stumps.
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $
- */
-public class GiniSplitCriterion extends AbstractOptionHandler implements
-        SplitCriterion {
-
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public double getMeritOfSplit(double[] preSplitDist,
-            double[][] postSplitDists) {
-        double totalWeight = 0.0;
-        double[] distWeights = new double[postSplitDists.length];
-        for (int i = 0; i < postSplitDists.length; i++) {
-            distWeights[i] = Utils.sum(postSplitDists[i]);
-            totalWeight += distWeights[i];
-        }
-        double gini = 0.0;
-        for (int i = 0; i < postSplitDists.length; i++) {
-            gini += (distWeights[i] / totalWeight)
-                    * computeGini(postSplitDists[i], distWeights[i]);
-        }
-        return 1.0 - gini;
-    }
-
-    @Override
-    public double getRangeOfMerit(double[] preSplitDist) {
-        return 1.0;
-    }
-
-    public static double computeGini(double[] dist, double distSumOfWeights) {
-        double gini = 1.0;
-        for (int i = 0; i < dist.length; i++) {
-            double relFreq = dist[i] / distSumOfWeights;
-            gini -= relFreq * relFreq;
-        }
-        return gini;
-    }
-
-    public static double computeGini(double[] dist) {
-        return computeGini(dist, Utils.sum(dist));
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        // TODO Auto-generated method stub
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/core/splitcriteria/InfoGainSplitCriterion.java b/moa/src/main/java/moa/classifiers/core/splitcriteria/InfoGainSplitCriterion.java
deleted file mode 100644
index 516ac8823..000000000
--- a/moa/src/main/java/moa/classifiers/core/splitcriteria/InfoGainSplitCriterion.java
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
- *    InfoGainSplitCriterion.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.core.splitcriteria;
-
-import com.github.javacliparser.FloatOption;
-
-import moa.core.ObjectRepository;
-import moa.core.Utils;
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
-/**
- * Class for computing splitting criteria using information gain
- * with respect to distributions of class values.
- * The split criterion is used as a parameter on
- * decision trees and decision stumps.
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $
- */
-public class InfoGainSplitCriterion extends AbstractOptionHandler implements
-        SplitCriterion {
-
-    private static final long serialVersionUID = 1L;
-
-    public FloatOption minBranchFracOption = new FloatOption("minBranchFrac",
-            'f',
-            "Minimum fraction of weight required down at least two branches.",
-            0.01, 0.0, 0.5);
-
-    @Override
-    public double getMeritOfSplit(double[] preSplitDist,
-            double[][] postSplitDists) {
-        if (numSubsetsGreaterThanFrac(postSplitDists, this.minBranchFracOption.getValue()) < 2) {
-            return Double.NEGATIVE_INFINITY;
-        }
-        return computeEntropy(preSplitDist) - computeEntropy(postSplitDists);
-    }
-
-    @Override
-    public double getRangeOfMerit(double[] preSplitDist) {
-        int numClasses = preSplitDist.length > 2 ? preSplitDist.length : 2;
-        return Utils.log2(numClasses);
-    }
-
-    public static double computeEntropy(double[] dist) {
-        double entropy = 0.0;
-        double sum = 0.0;
-        for (double d : dist) {
-            if (d > 0.0) { // TODO: how small can d be before log2 overflows?
-                entropy -= d * Utils.log2(d);
-                sum += d;
-            }
-        }
-        return sum > 0.0 ? (entropy + sum * Utils.log2(sum)) / sum : 0.0;
-    }
-
-    public static double computeEntropy(double[][] dists) {
-        double totalWeight = 0.0;
-        double[] distWeights = new double[dists.length];
-        for (int i = 0; i < dists.length; i++) {
-            distWeights[i] = Utils.sum(dists[i]);
-            totalWeight += distWeights[i];
-        }
-        double entropy = 0.0;
-        for (int i = 0; i < dists.length; i++) {
-            entropy += distWeights[i] * computeEntropy(dists[i]);
-        }
-        return entropy / totalWeight;
-    }
-
-    public static int numSubsetsGreaterThanFrac(double[][] distributions,
-            double minFrac) {
-        double totalWeight = 0.0;
-        double[] distSums = new double[distributions.length];
-        for (int i = 0; i < distSums.length; i++) {
-            for (int j = 0; j < distributions[i].length; j++) {
-                distSums[i] += distributions[i][j];
-            }
-            totalWeight += distSums[i];
-        }
-        int numGreater = 0;
-        for (double d : distSums) {
-            double frac = d / totalWeight;
-            if (frac > minFrac) {
-                numGreater++;
-            }
-        }
-        return numGreater;
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        // TODO Auto-generated method stub
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/core/splitcriteria/VarianceReductionSplitCriterion.java b/moa/src/main/java/moa/classifiers/core/splitcriteria/VarianceReductionSplitCriterion.java
deleted file mode 100644
index e7a26e067..000000000
--- a/moa/src/main/java/moa/classifiers/core/splitcriteria/VarianceReductionSplitCriterion.java
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
- *    VarianceReductionSplitCriterion.java
- *    Copyright (C) 2013 University of Porto, Portugal
- *    @author Katie de Lange, E. Almeida, J. Gama
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- *    
- */
-
-/* Project Knowledge Discovery from Data Streams, FCT LIAAD-INESC TEC, 
- *
- * Contact: jgama@fep.up.pt
- */
-
-package moa.classifiers.core.splitcriteria;
-
-import moa.core.ObjectRepository;
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
-public class VarianceReductionSplitCriterion extends AbstractOptionHandler implements SplitCriterion {
-
-    private static final long serialVersionUID = 1L;
-
-/*    @Override
-    public double getMeritOfSplit(double[] preSplitDist, double[][] postSplitDists) {
-   
-    	double N = preSplitDist[0];
-    	double SDR = computeSD(preSplitDist);
-
-    //	System.out.print("postSplitDists.length"+postSplitDists.length+"\n");
-    	for(int i = 0; i < postSplitDists.length; i++)
-    	{
-    		double Ni = postSplitDists[i][0];
-    		SDR -= (Ni/N)*computeSD(postSplitDists[i]);
-    	}
-
-        return SDR;
-    }*/
-    
-    @Override
-    public double getMeritOfSplit(double[] preSplitDist, double[][] postSplitDists) {
-        double SDR=0.0;
-    	double N = preSplitDist[0];
-    	int count = 0; 
-    	
-    	for(int i = 0; i < postSplitDists.length; i++)
-    	{
-    		double Ni = postSplitDists[i][0];
-    		if(Ni >=5.0){
-    			count = count +1;
-    		}
-    	}
-    	
-    	if(count == postSplitDists.length){
-    		SDR = computeSD(preSplitDist);
-    		for(int i = 0; i < postSplitDists.length; i++)
-        	{
-        		double Ni = postSplitDists[i][0];
-        		SDR -= (Ni/N)*computeSD(postSplitDists[i]);
-        	}
-    	}
-    	return SDR;
-    }
-    	
-
-
-    @Override
-    public double getRangeOfMerit(double[] preSplitDist) {
-        return 1;
-    }
-
-    public static double computeSD(double[] dist) {
-       
-    	int N = (int)dist[0];
-        double sum = dist[1];
-        double sumSq = dist[2];
-     //   return Math.sqrt((sumSq - ((sum * sum)/N))/N);
-        return (sumSq - ((sum * sum)/N))/N;
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        // TODO Auto-generated method stub
-    }
-    
-}
-
diff --git a/moa/src/main/java/moa/classifiers/core/statisticaltests/Cramer.java b/moa/src/main/java/moa/classifiers/core/statisticaltests/Cramer.java
deleted file mode 100644
index b16964866..000000000
--- a/moa/src/main/java/moa/classifiers/core/statisticaltests/Cramer.java
+++ /dev/null
@@ -1,744 +0,0 @@
-/*
- *    Cramer.java
- *    Copyright (C) 2017 Instituto Federal de Pernambuco
- *    @author Paulo Gonçalves (paulogoncalves@recife.ifpe.edu.br)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.core.statisticaltests;
-
-import java.io.FileNotFoundException;
-import java.io.FileReader;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
-import java.util.TreeMap;
-
-import org.apache.commons.math3.complex.Complex;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.ArffLoader;
-import com.yahoo.labs.samoa.instances.Instance;
-
-import Jama.EigenvalueDecomposition;
-import Jama.Matrix;
-import moa.core.ObjectRepository;
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
-/**
- * Implements the Multivariate Non-parametric Cramer Von Mises Statistical Test.
- *
- * @author Paulo Gonçalves
- *
- */
-public class Cramer extends AbstractOptionHandler implements StatisticalTest {
-
-    private List<Instance> sample1i;
-    private List<Instance> sample2i;
-
-    public FloatOption confidenceLevelOption = new FloatOption(
-            "confidenceLevel",
-            'q',
-            "The confidence level to use in the Cramer test.",
-            0.95, 0, 1);
-
-    public IntOption replicatesOption = new IntOption("replicates", 'r',
-            "Number of replications.", 1000, 1,
-            Integer.MAX_VALUE);
-
-    public MultiChoiceOption kernelOption = new MultiChoiceOption("kernel", 'f',
-            "Kernel function to use.", new String[]{"CRAMER", "BAHR", "LOG", "FRAC A", "FRAC B"},
-            new String[]{"CRAMER", "BAHR", "LOG", "FRAC A", "FRAC B"},
-            0);
-
-    public FloatOption maxMOption = new FloatOption(
-            "maxM",
-            'm',
-            "Maximum M.",
-            Math.pow(2, 14), 1, Float.MAX_VALUE);
-
-    public IntOption kOption = new IntOption("k", 'k',
-            "K value.", 160, 1,
-            Integer.MAX_VALUE);
-
-    public static final int CRAMER = 0;
-    public static final int BAHR = 1;
-    public static final int LOG = 2;
-    public static final int FRACA = 3;
-    public static final int FRACB = 4;
-
-    // compute the FFT of x[], assuming its length is a power of 2
-    private Complex[] fft(Complex[] x) {
-        int N = x.length;
-
-        // base case
-        if (N == 1) {
-            return new Complex[]{x[0]};
-        }
-
-        // radix 2 Cooley-Tukey FFT
-        if (N % 2 != 0) {
-            throw new RuntimeException("N is not a power of 2");
-        }
-
-        // fft of even terms
-        Complex[] even = new Complex[N / 2];
-        for (int k = 0; k < N / 2; k++) {
-            even[k] = x[2 * k];
-        }
-        Complex[] q = fft(even);
-
-        // fft of odd terms
-        Complex[] odd = even;  // reuse the array
-        for (int k = 0; k < N / 2; k++) {
-            odd[k] = x[2 * k + 1];
-        }
-        Complex[] r = fft(odd);
-
-        // combine
-        Complex[] yy = new Complex[N];
-        for (int k = 0; k < N / 2; k++) {
-            double kth = -2 * k * Math.PI / N;
-            Complex wk = new Complex(Math.cos(kth), Math.sin(kth));
-            yy[k] = q[k].add(wk.multiply(r[k]));
-            yy[k + N / 2] = q[k].subtract(wk.multiply(r[k]));
-        }
-        return yy;
-    }
-
-    private double phiCramer(double x) {
-        return (Math.sqrt(x) / 2);
-    }
-
-    private double phiBahr(double x) {
-        return (1 - Math.exp(-x / 2));
-    }
-
-    private double phiLog(double x) {
-        return (Math.log(1 + x));
-    }
-
-    private double phiFracA(double x) {
-        return (1 - 1 / (1 + x));
-    }
-
-    private double phiFracB(double x) {
-        return (1 - 1 / ((1 + x) * (1 + x)));
-    }
-
-    private double subtractRows(double[][] matrix, int i, int j) {
-        double sum = 0;
-        for (int k = 0; k < matrix[i].length; k++) {
-            sum += (matrix[i][k] - matrix[j][k]) * (matrix[i][k] - matrix[j][k]);
-        }
-        return sum;
-    }
-
-    private void kernel(int kernel, double[][] lookup) {
-        for (double[] lookup1 : lookup) {
-            for (int j = 0; j < lookup1.length; j++) {
-                switch (kernel) {
-                    case CRAMER:
-                        lookup1[j] = this.phiCramer(lookup1[j]);
-                        break;
-                    case BAHR:
-                        lookup1[j] = this.phiBahr(lookup1[j]);
-                        break;
-                    case FRACA:
-                        lookup1[j] = this.phiFracA(lookup1[j]);
-                        break;
-                    case FRACB:
-                        lookup1[j] = this.phiFracB(lookup1[j]);
-                        break;
-                    case LOG:
-                        lookup1[j] = this.phiLog(lookup1[j]);
-                        break;
-                }
-            }
-        }
-    }
-
-    private double sumCells(double[][] lookup, int[] xind, int[] yind) {
-        double sum = 0;
-        for (int i = 0; i < xind.length; i++) {
-            for (int j = 0; j < yind.length; j++) {
-                sum += lookup[xind[i]][yind[j]];
-            }
-        }
-        return sum;
-    }
-
-    private double cramerStatistic(int m, int n, double[][] lookup) {
-        int[] xind = new int[m];
-        for (int i = 0; i < m; i++) {
-            xind[i] = i;
-        }
-        int[] yind = new int[n];
-        for (int i = m, j = 0; i < m + n; i++, j++) {
-            yind[j] = i;
-        }
-        double mm = m, nn = n;
-        return mm * nn / (mm + nn) * (2 * this.sumCells(lookup, xind, yind) / (mm * nn) - this.sumCells(lookup, xind, xind) / (mm * mm) - this.sumCells(lookup, yind, yind) / (nn * nn));
-    }
-
-    class Boot {
-
-        double t0;
-        double[][] t;
-    }
-
-    private double rank(double t0, double[][] t) {
-        double[] temp = new double[t.length * t[0].length + 1];
-        temp[0] = t0;
-        int p = 1;
-        for (double[] t1 : t) {
-            for (int j = 0; j < t1.length; j++) {
-                temp[p++] = t1[j];
-            }
-        }
-        double[] ordTemp = temp.clone();
-        Arrays.sort(ordTemp);
-        Map<Double, Double> map = new TreeMap();
-        for (int i = 0; i < ordTemp.length; i++) {
-            double xTemp = ordTemp[i], sum = i;
-            int count = 1;
-            while (i + 1 < ordTemp.length && xTemp == ordTemp[++i]) {
-                sum += i;
-                count++;
-            }
-            map.put(xTemp, 1 + sum / count);
-            if (i + 1 == ordTemp.length) {
-                map.put(ordTemp[i], 1.0 + i);
-                break;
-            } else {
-                i--;
-            }
-        }
-        return map.get(t0);
-    }
-
-    private double[] linearize(double[][] matrix) {
-        double[] vector = new double[matrix.length * matrix[0].length];
-        int p = 0;
-        for (double[] matrix1 : matrix) {
-            for (int j = 0; j < matrix1.length; j++) {
-                vector[p++] = matrix1[j];
-            }
-        }
-        return vector;
-    }
-
-    private double[] createVector(int replicates) {
-        double[] result = new double[replicates];
-        for (int i = 0; i < replicates; i++) {
-            result[i] = (i + 1) / replicates;
-        }
-        return result;
-    }
-
-    private void divide(double[] vector, double divisor) {
-        for (int i = 0; i < vector.length; i++) {
-            vector[i] /= divisor;
-        }
-    }
-
-    private void divide(double[][] matrix, double divisor) {
-        for (double[] matrix1 : matrix) {
-            for (int j = 0; j < matrix1.length; j++) {
-                matrix1[j] /= divisor;
-            }
-        }
-    }
-
-    private double[] createArray(int M, double k) {
-        double[] result = new double[M];
-        for (int i = 0; i < M; i++) {
-            result[i] = i * k / M;
-        }
-        return result;
-    }
-
-    private double[] createArray2(int M, double k) {
-        double[] result = new double[M];
-        for (int i = 0; i < M; i++) {
-            result[i] = i * 2 * Math.PI / k;
-        }
-        return result;
-    }
-
-    private Complex[][] complex(Complex[] v, double[] t) {
-        Complex[][] complex = new Complex[v.length][t.length];
-        for (int i = 0; i < v.length; i++) {
-            for (int j = 0; j < t.length; j++) {
-                complex[i][j] = v[i].multiply(t[j]).add(new Complex(1, 0)).log().multiply(-0.5);
-            }
-        }
-        return complex;
-    }
-
-    private Complex[] characteristic(double[] lambdasquare, double[] t) {
-        // z<--0.5*log(1-2i*lambdasquare%*%t(t));
-        Complex c = new Complex(0, -2);
-        Complex[] temp = new Complex[lambdasquare.length];
-        for (int i = 0; i < temp.length; i++) {
-            temp[i] = c.multiply(lambdasquare[i]);
-        }
-        Complex[][] z = this.complex(temp, t);
-        // return(exp(complex(length(t),rowsum(Re(z),rep(1,length(lambdasquare))),rowsum(Im(z),rep(1,length(lambdasquare))))))
-        double[] real = new double[t.length];
-        double[] imag = new double[t.length];
-        for (int j = 0; j < t.length; j++) {
-            for (Complex[] z1 : z) {
-                real[j] += z1[j].getReal();
-                imag[j] += z1[j].getImaginary();
-            }
-        }
-        Complex[] result = new Complex[t.length];
-        for (int i = 0; i < t.length; i++) {
-            result[i] = new Complex(real[i], imag[i]);
-            result[i] = result[i].exp();
-        }
-        return result;
-    }
-
-    private double[] imaginary(Complex[] c) {
-        double[] ret = new double[c.length];
-        for (int i = 0; i < c.length; i++) {
-            ret[i] = c[i].getImaginary();
-        }
-        return ret;
-    }
-
-    private double[] plus(double[] array, double m) {
-        double[] ret = new double[array.length];
-        for (int i = 0; i < ret.length; i++) {
-            ret[i] = array[i] + m;
-        }
-        return ret;
-    }
-
-    private double sum(double[] lambdasquare) {
-        double sum = 0;
-        for (int i = 0; i < lambdasquare.length; i++) {
-            sum += lambdasquare[i];
-        }
-        return sum;
-    }
-
-    private double[] sum(double[] a, double[] b) {
-        double[] c = new double[a.length];
-        for (int i = 0; i < c.length; i++) {
-            c[i] = a[i] + b[i];
-        }
-        return c;
-    }
-
-    private int whichMin(double[] a, int M, double confLevel) {
-        double[] ret = new double[M / 2];
-        for (int i = 0; i < ret.length; i++) {
-            ret[i] = Math.abs(a[i] - confLevel);
-        }
-        int minIndex = 0;
-        double minValue = Double.MAX_VALUE;
-        for (int i = 0; i < ret.length; i++) {
-            if (ret[i] < minValue) {
-                minValue = ret[i];
-                minIndex = i;
-            }
-        }
-        return minIndex;
-    }
-
-    private int whichMin(double[] ret) {
-        int minIndex = 0;
-        double minValue = Double.MAX_VALUE;
-        for (int i = 0; i < ret.length; i++) {
-            if (ret[i] < minValue) {
-                minValue = ret[i];
-                minIndex = i;
-            }
-        }
-        return minIndex;
-    }
-
-    class Kritwert {
-
-        double quantile;
-        double[] x;
-        double[] Fx;
-
-        public Kritwert(double quantile, double[] x, double[] fx) {
-            super();
-            this.quantile = quantile;
-            this.x = x;
-            Fx = fx;
-        }
-    }
-
-    private Complex[] multiply(double[] t, Complex c) {
-        Complex[] ret = new Complex[t.length];
-        for (int i = 0; i < ret.length; i++) {
-            ret[i] = c.multiply(t[i]);
-        }
-        return ret;
-    }
-
-    private void multiply(double[] t, Complex[] c) {
-        for (int i = 0; i < c.length; i++) {
-            c[i] = c[i].multiply(t[i]);
-        }
-    }
-
-    private void multiply(Complex[] c, double multiply) {
-        for (int i = 0; i < c.length; i++) {
-            c[i] = c[i].multiply(multiply);
-        }
-    }
-
-    private void multiply(double[] c, double multiply) {
-        for (int i = 0; i < c.length; i++) {
-            c[i] *= multiply;
-        }
-    }
-
-    private Kritwert kritwertfft(double[] lambdasquare, double confLevel, double maxM, int k) {
-        double sumLambasquare = this.sum(lambdasquare);
-        // M<-2^11
-        int M = (int) Math.pow(2, 11);
-        // while (150*pi*M/K^2<(2*sum(lambdasquare)+lambdasquare[1])) M<-M*2
-        while (150 * Math.PI * M / (k * k) < (2 * sumLambasquare + lambdasquare[0])) {
-            M *= 2;
-        }
-        // M<-min(c(M,maxM))
-        M = (int) Math.min(M, maxM);
-        // goodlimit<-150*pi*M/K^2
-        double goodlimit = 150 * Math.PI * M / (k * k);
-        // a<-0
-        // t<-0:(M-1)*K/M
-        double[] t = this.createArray(M, k);
-        // x<-0:(M-1)*2*pi/K
-        double[] xx = this.createArray2(M, k);
-        // t[1]<-1
-        t[0] = 1;
-        // h<-.cramer.characteristicfunction(lambdasquare,t)/t*exp(-a*1i*t);
-        Complex[] h = this.characteristic(lambdasquare, t);
-        Complex z = new Complex(0, 1).multiply(-0);
-        Complex[] hTemp = this.multiply(t, z);
-        for (int i = 0; i < hTemp.length; i++) {
-            hTemp[i] = hTemp[i].exp();
-        }
-        this.multiply(t, hTemp);
-        for (int i = 0; i < h.length; i++) {
-            h[i] = h[i].divide(hTemp[i]);
-        }
-        // h[1]<-complex(1,0,1)*sum(lambdasquare)
-        h[0] = new Complex(0, 1).multiply(sumLambasquare);
-        // Fx<-1/2-Im(K/(M*pi)*fft(h,inverse=FALSE))+K/(2*M*pi)*(sum(lambdasquare)+x+a)
-        Complex[] temp = fft(h);
-        this.multiply(temp, k / (M * Math.PI));
-        double[] tempFx = this.imaginary(temp);
-        this.multiply(tempFx, -1);
-        tempFx = this.plus(tempFx, 0.5);
-        double[] tempX = this.plus(xx, sumLambasquare);
-        this.multiply(tempX, k / (2 * M * Math.PI));
-        double[] Fx = this.sum(tempFx, tempX);
-        // xindex<-which.min(abs(Fx[1:(M/2)]-conf.level))
-        int xindex = this.whichMin(Fx, M, confLevel);
-        // if (Fx[xindex]>conf.level) xindex<-xindex-1
-        if (Fx[xindex] > confLevel) {
-            xindex--;
-        }
-        // if (xindex<1) xindex<-1
-        if (xindex < 1) {
-            xindex = 0;
-        }
-        // quantile<-x[xindex]+(conf.level-Fx[xindex])*(x[xindex+1]-x[xindex])/(Fx[xindex+1]-Fx[xindex])
-        double quantile = xx[xindex] + (confLevel - Fx[xindex]) * (xx[xindex + 1] - xx[xindex]) / (Fx[xindex + 1] - Fx[xindex]);
-        if (Fx[M / 2] < confLevel) {
-            System.out.println("Quantile calculation discrepance. Try to increase K!");
-        }
-        if (quantile > goodlimit) {
-            System.out.println("Quantile beyond good approximation limit. Try to increase maxM or decrease K!");
-        }
-        return new Kritwert(quantile, xx, Fx);
-    }
-
-    public CramerTest cramerTest(List<Instance> x, List<Instance> y) {
-        return this.cramerTest(x, y, this.confidenceLevelOption.getValue(), this.replicatesOption.getValue(), "ordinary", false, this.kernelOption.getChosenIndex(), this.maxMOption.getValue(), this.kOption.getValue());
-    }
-
-    public CramerTest cramerTest1(List<List<Double>> x, List<List<Double>> y) {
-        return this.cramerTest1(x, y, this.confidenceLevelOption.getValue(), this.replicatesOption.getValue(), "ordinary", false, this.kernelOption.getChosenIndex(), this.maxMOption.getValue(), this.kOption.getValue());
-    }
-
-    public CramerTest cramerTest1(List<List<Double>> x, List<List<Double>> y, double confLevel, int replicates, String sim, boolean justStatistic, int kernel, double maxM, int k) {
-        CramerTest RVAL = new CramerTest(0, 0, 0, 0, 0, 0, 0, confLevel, replicates, null, null, null);
-        // if ((is.matrix(x))&&(is.matrix(y))) if (ncol(x)==ncol(y)) RVAL$d<-ncol(x)
-        RVAL.d = x.get(0).size();
-        // RVAL$m<-nrow(x)
-        RVAL.m = x.size();
-        // RVAL$n<-nrow(y)
-        RVAL.n = y.size();
-        // daten<-matrix(c(t(x),t(y)),ncol=ncol(x),byrow=TRUE)
-        double[][] daten = new double[RVAL.m + RVAL.n][];
-        for (int i = 0; i < RVAL.m; i++) {
-            double[] values = new double[x.get(i).size() - 1];
-            System.arraycopy(x.get(i).toArray(), 0, values, 0, values.length);
-            daten[i] = values;
-        }
-        for (int i = 0; i < RVAL.n; i++) {
-            double[] values = new double[y.get(i).size() - 1];
-            System.arraycopy(y.get(i).toArray(), 0, values, 0, values.length);
-            daten[i + RVAL.m] = values;
-        }
-        return this.compute(RVAL, daten, replicates, sim, justStatistic, kernel, maxM, k);
-    }
-
-    private CramerTest compute(CramerTest RVAL, double[][] daten, int replicates, String sim, boolean justStatistic, int kernel, double maxM, int k) {
-        // lookup<-matrix(rep(0,(RVAL$m+RVAL$n)^2),ncol=(RVAL$m+RVAL$n))
-        double[][] lookup = new double[RVAL.m + RVAL.n][RVAL.m + RVAL.n];
-        // for (i in 2:(RVAL$m+RVAL$n)) for (j in 1:(i-1)) { lookup[i,j]<-sum((daten[i,]-daten[j,])^2); lookup[j,i]<-lookup[i,j]; }
-        for (int i = 1; i < RVAL.m + RVAL.n; i++) {
-            for (int j = 0; j <= i - 1; j++) {
-                lookup[i][j] = this.subtractRows(daten, i, j);
-                lookup[j][i] = lookup[i][j];
-            }
-        }
-        // lookup<-eval(call(kernel,lookup))
-        this.kernel(kernel, lookup);
-        if (justStatistic) {
-            RVAL.statistic = this.cramerStatistic(RVAL.m, RVAL.n, lookup);
-        } else if (sim.equals("eigenvalue")) {
-            /* To be implemented! */
-            Boot boot = new Boot();
-            RVAL.statistic = boot.t0;
-            RVAL.pValue = 1 - this.rank(boot.t0, boot.t) / (replicates + 1);
-            double[] toSort = this.linearize(boot.t);
-            Arrays.sort(toSort);
-            RVAL.critValue = toSort[(int) Math.round(RVAL.confLevel * RVAL.replicates)];
-            if (RVAL.statistic > RVAL.critValue) {
-                RVAL.result = 1;
-            }
-            RVAL.hypdistX = toSort;
-            RVAL.hypdistFx = this.createVector(replicates);
-        } else {
-            // RVAL$statistic<-.cramer.statistic(daten,1:(RVAL$m+RVAL$n),RVAL$m,RVAL$n,lookup)
-            RVAL.statistic = this.cramerStatistic(RVAL.m, RVAL.n, lookup);
-            // N<-RVAL$m+RVAL$n
-            int N = RVAL.m + RVAL.n;
-            // C1<-rep(0,N)
-            double[] C1 = new double[N];
-            // for (i in 1:N) for (j in 1:N) C1[i]<-C1[i]+lookup[i,j]
-            for (int i = 0; i < N; i++) {
-                for (int j = 0; j < N; j++) {
-                    C1[i] += lookup[i][j];
-                }
-            }
-            // C1<-C1/N
-            this.divide(C1, N);
-            // C2<-0
-            double C2 = 0;
-            // for (i in 1:N) for (j in 1:N) C2<-C2+lookup[i,j]
-            for (int i = 0; i < N; i++) {
-                for (int j = 0; j < N; j++) {
-                    C2 += lookup[i][j];
-                }
-            }
-            // C2<-C2/N^2
-            C2 /= (N * N);
-            // B<-matrix(rep(0,N^2),ncol=N)
-            double[][] B = new double[N][N];
-            // for (i in 1:N) for (j in 1:N) B[i,j]<-C1[i]+C1[j]-C2-lookup[i,j]
-            for (int i = 0; i < N; i++) {
-                for (int j = 0; j < N; j++) {
-                    B[i][j] = C1[i] + C1[j] - C2 - lookup[i][j];
-                }
-            }
-            // B<-B/N
-            this.divide(B, N);
-            // RVAL$ev<-eigen(B,FALSE)
-            Matrix matrix = new Matrix(B);
-            EigenvalueDecomposition evd = matrix.eig();
-            double[] lambdasquare = evd.getRealEigenvalues();
-            Arrays.sort(lambdasquare);
-            this.reverse(lambdasquare);
-            RVAL.ev = lambdasquare;
-            // kritwert<-.cramer.kritwertfft(Re((RVAL$ev)$values),conf.level,maxM,K)
-            Kritwert kw = this.kritwertfft(lambdasquare, RVAL.confLevel, maxM, k);
-            // RVAL$p.value<-1-(kritwert$hypdist.Fx)[which.min(abs((kritwert$hypdist.x)[1:(3*length(kritwert$hypdist.x)/4)]-RVAL$statistic))];
-            double[] temp = Arrays.copyOf(kw.x, 3 * kw.x.length / 4);
-            temp = this.plus(temp, -RVAL.statistic);
-            for (int i = 0; i < temp.length; i++) {
-                temp[i] = Math.abs(temp[i]);
-            }
-            RVAL.pValue = 1 - kw.Fx[this.whichMin(temp)];
-            // RVAL$crit.value<-kritwert$quantile
-            RVAL.critValue = kw.quantile;
-            // RVAL$hypdist.x<-kritwert$hypdist.x
-            RVAL.hypdistX = kw.x;
-            // RVAL$hypdist.Fx<-kritwert$hypdist.Fx
-            RVAL.hypdistFx = kw.Fx;
-            // if (RVAL$statistic>RVAL$crit.value) RVAL$result<-1
-            if (RVAL.statistic > RVAL.critValue) {
-                RVAL.result = 1.0;
-            }
-        }
-        return RVAL;
-    }
-
-    public CramerTest cramerTest(List<Instance> x, List<Instance> y, double confLevel, int replicates, String sim, boolean justStatistic, int kernel, double maxM, int k) {
-        CramerTest RVAL = new CramerTest(0, 0, 0, 0, 0, 0, 0, confLevel, replicates, null, null, null);
-        // if ((is.matrix(x))&&(is.matrix(y))) if (ncol(x)==ncol(y)) RVAL$d<-ncol(x)
-        RVAL.d = x.get(0).numAttributes();
-        // RVAL$m<-nrow(x)
-        RVAL.m = x.size();
-        // RVAL$n<-nrow(y)
-        RVAL.n = y.size();
-        // daten<-matrix(c(t(x),t(y)),ncol=ncol(x),byrow=TRUE)
-        double[][] daten = new double[RVAL.m + RVAL.n][];
-        for (int i = 0; i < RVAL.m; i++) {
-            Instance inst = x.get(i);
-            double[] values = new double[inst.numAttributes() - 1];
-            for (int j = 0; j < values.length; j++) {
-                values[j] = inst.value(j);
-            }
-            daten[i] = values;
-        }
-        for (int i = 0; i < RVAL.n; i++) {
-            Instance inst = y.get(i);
-            double[] values = new double[inst.numAttributes() - 1];
-            for (int j = 0; j < values.length; j++) {
-                values[j] = inst.value(j);
-            }
-            daten[i + RVAL.m] = values;
-        }
-        return this.compute(RVAL, daten, replicates, sim, justStatistic, kernel, maxM, k);
-    }
-
-    private void reverse(double[] array) {
-        double temp;
-        for (int i = 0, j = array.length - 1; i < j; i++, j--) {
-            // swap the elements
-            temp = array[i];
-            array[i] = array[j];
-            array[j] = temp;
-        }
-    }
-
-    public class CramerTest {
-
-        int d, m, n;
-        double pValue, critValue, statistic, result, confLevel, replicates;
-        double[] hypdistX, hypdistFx, ev;
-
-        public CramerTest(int d, int m, int n, double pValue,
-                double critValue, double statistic, double result,
-                double confLevel, double replicates, double[] hypdistX,
-                double[] hypdistFx, double[] ev) {
-            super();
-            this.d = d;
-            this.m = m;
-            this.n = n;
-            this.pValue = pValue;
-            this.critValue = critValue;
-            this.statistic = statistic;
-            this.result = result;
-            this.confLevel = confLevel;
-            this.replicates = replicates;
-            this.hypdistX = hypdistX;
-            this.hypdistFx = hypdistFx;
-            this.ev = ev;
-        }
-    }
-
-    public static List<Instance> fileToInstances(String path) {
-        List<Instance> x = new ArrayList();
-        try {
-            FileReader reader = new FileReader(path);
-            ArffLoader arff = new ArffLoader(reader, 1, -1);
-            Instance inst = arff.readInstance();
-            while (inst != null) {
-                x.add(inst);
-                inst = arff.readInstance();
-            }
-        } catch (FileNotFoundException e) {
-            System.out.println(e);
-        }
-        return x;
-    }
-
-    public static List<List<Double>> fileToMatrix(String path) {
-        List<List<Double>> x = new ArrayList();
-        try {
-            FileReader reader = new FileReader(path);
-            ArffLoader arff = new ArffLoader(reader, 1, -1);
-            Instance inst = arff.readInstance();
-            while (inst != null) {
-                double[] dArray = inst.toDoubleArray();
-                List<Double> list = new ArrayList();
-                for (double d : dArray) {
-                    list.add(d);
-                }
-                x.add(list);
-                inst = arff.readInstance();
-            }
-        } catch (FileNotFoundException e) {
-            System.out.println(e);
-        }
-        return x;
-    }
-
-    public static void main(String[] args) throws Exception {
-        List<Instance> x = Cramer.fileToInstances("c:\\Users\\Paulo\\Documents\\test1-x.arff");
-        List<Instance> y = Cramer.fileToInstances("c:\\Users\\Paulo\\Documents\\test1-y.arff");
-
-        Cramer c = new Cramer();
-        Cramer.CramerTest ct = c.cramerTest(x, y);
-        System.out.println("p Value [Resultado esperado: 0.7092907] [Resultado obtido..: " + ct.pValue + "]");
-        System.out.println("Critical value [Resultado esperado: 2.379552] [Resultado obtido: " + ct.critValue + "]");
-        System.out.println("Statistic [Resultado esperado: 0.8160198] [Resultado obtido: " + ct.statistic + "]");
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    public double test(List<Instance> x, List<Instance> y) {
-        return this.cramerTest(x, y).confLevel;
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    public Double call() throws Exception {
-        return this.test(sample1i, sample2i);
-    }
-
-    @Override
-    public void set(List<Instance> x, List<Instance> y) {
-        this.sample1i = x;
-        this.sample2i = y;
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/core/statisticaltests/KNN.java b/moa/src/main/java/moa/classifiers/core/statisticaltests/KNN.java
deleted file mode 100644
index 1fb65ba7f..000000000
--- a/moa/src/main/java/moa/classifiers/core/statisticaltests/KNN.java
+++ /dev/null
@@ -1,434 +0,0 @@
-/*
- *    KNN.java
- *    Copyright (C) 2017 Instituto Federal de Pernambuco
- *    @author Paulo Gonçalves (paulogoncalves@recife.ifpe.edu.br)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.core.statisticaltests;
-
-import java.util.Arrays;
-import java.util.Comparator;
-import java.util.List;
-import java.util.PriorityQueue;
-
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.core.ObjectRepository;
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
-/**
- * Implements the multivariate non-parametric KNN statistical test.
- *
- * @author Paulo Goncalves
- *
- */
-public class KNN extends AbstractOptionHandler implements StatisticalTest {
-
-    private List<Instance> sample1i;
-    private List<Instance> sample2i;
-
-    public IntOption kValueOption = new IntOption("kValue", 'k',
-            "K value of the K nearest neighbours algorithm.", 5, 1,
-            Integer.MAX_VALUE);
-
-    private double[] compute(double[][] set, int d, int n1, int n2) throws InterruptedException {
-        double n = n1 + n2;
-        Arrays.fill(set[d], 0, n1, 1.0);
-        Arrays.fill(set[d], n1, n1 + n2, 2.0);
-        int[] counts = this.knn(set, n1 + n2, d, this.kValueOption.getValue());
-        double Tk = 0;
-        for (int i = 0; i < counts.length; i++) {
-            Tk += counts[i];
-        }
-        Tk /= (n * this.kValueOption.getValue());
-        double V = (n1 - 1) * (n2 - 1) / ((n - 1) * (n - 1)) + 4
-                * ((n1 - 1) * (n1 - 2) / ((n - 1) * (n - 2)))
-                * ((n2 - 1) * (n2 - 2) / ((n - 1) * (n - 2)));
-        double Z = Math.sqrt(n * this.kValueOption.getValue())
-                * (Tk - (n1 - 1) * (n1 - 2) / ((n - 1) * (n - 2)) - (n2 - 1)
-                * (n2 - 2) / ((n - 1) * (n - 2))) / Math.sqrt(V);
-        double P = this.pnorm(Z, 0, 1, false, false);
-
-        return new double[]{Tk, Z, P};
-    }
-
-    private double[] attributeToDoubleArray(List<Instance> list, int attIndex) {
-        double[] ret = new double[list.size()];
-        for (int i = 0; i < list.size(); i++) {
-            ret[i] = list.get(i).value(attIndex);
-        }
-        return ret;
-    }
-
-    public double[] mtsknn(List<Instance> x, List<Instance> y) throws InterruptedException {
-        if (x.get(0).numAttributes() != y.get(0).numAttributes()) {
-            System.out.println("The dimensions of two samples must match!!!");
-            return null;
-        }
-        int d = x.get(0).numAttributes() - 1;
-        int n1 = x.size();
-        int n2 = y.size();
-        double[][] set = new double[d + 1][n1 + n2];
-        for (int i = 0; i < d; i++) {
-            double[] t1 = this.attributeToDoubleArray(x, i);
-            double[] t2 = this.attributeToDoubleArray(y, i);
-            System.arraycopy(t1, 0, set[i], 0, t1.length);
-            System.arraycopy(t2, 0, set[i], t1.length, t2.length);
-        }
-        return this.compute(set, d, n1, n2);
-    }
-
-    private double pnorm(double x, double mu, double sigma, boolean lower_tail,
-            boolean log_p) {
-        double p;
-
-        if (Double.isNaN(x) || Double.isNaN(mu) || Double.isNaN(sigma)) {
-            return x + mu + sigma;
-        }
-        if (Double.isInfinite(x) && mu == x) {
-            return Double.NaN;/* x-mu is NaN */
-        }
-        if (sigma <= 0) {
-            // if(sigma < 0) ML_ERR_return_NAN;
-            if (x < mu) {
-                R_DT(lower_tail, log_p);
-            }
-        }
-        p = (x - mu) / sigma;
-        if (Double.isInfinite(p)) {
-            if (x < mu) {
-                R_DT(lower_tail, log_p);
-            }
-        }
-        x = p;
-
-        double[] ret = this.pnorm_both(x, p, (lower_tail ? 0 : 1), log_p);
-
-        return (lower_tail ? ret[0] : ret[1]);
-    }
-
-    private class DIPair {
-
-        double e = 0;
-        int i = 0;
-
-        public DIPair(double e0, int i0) {
-            this.e = e0;
-            this.i = i0;
-        }
-
-        public double getE() {
-            return e;
-        }
-
-        public int getI() {
-            return i;
-        }
-    }
-
-    private class HigherComparator implements Comparator<DIPair> {
-
-        @Override
-        public int compare(DIPair o1, DIPair o2) {
-            return (o1.e > o2.e) ? -1 : ((o1.e == o2.e) ? 0 : 1);
-        }
-    }
-
-    // Calculando as distancias entre dois pontos para todos os atributos
-    private double dist(double[][] points, int v1, int v2, int d) {
-        double sum = 0;
-        for (int i = 0; i != d; ++i) {
-            // Do not use Math.pow! It is 8x slower than computing directly
-            sum += (points[i][v1] - points[i][v2])
-                    * (points[i][v1] - points[i][v2]);
-        }
-        return sum;
-    }
-
-    /**
-     * Computes, for each instance, the number of the k nearest neighbors that
-     * are from the same sample.
-     *
-     * @param points Instances of both samples put together, with the last
-     * column having 1 for the first sample and 2 for the second sample.
-     * @param n Number of instances.
-     * @param d Number of attributes + 1 column.
-     * @param k K nearest neighbors.
-     * @return the number of the closest neighbors that are from the same
-     * sample.
-     * @throws InterruptedException
-     */
-    private int[] knn(double[][] points, int n, int d, int k) throws InterruptedException {
-        int[] counts = new int[n];
-        int[] closest = new int[n * k];
-        // Percorrendo todos os atributos
-        for (int i = 0; i != n; ++i) {
-            if (Thread.interrupted()) {
-                // We've been interrupted: no more crunching.
-                throw new InterruptedException();
-            }
-            PriorityQueue<DIPair> q = new PriorityQueue(k,
-                    new HigherComparator());
-            // Percorrendo os valores do atributo
-            for (int j = 0; j != n; ++j) {
-                if (i != j) {
-                    DIPair dis = new DIPair(this.dist(points, i, j, d), j);
-                    if (q.size() == k) {
-                        if (dis.getE() < q.peek().getE()) {
-                            q.add(dis);
-                            q.poll();
-                        }
-                    } else {
-                        q.add(dis);
-                    }
-                }
-            }
-            // Armazenando as posicoes das k menores distancias em ordem
-            // crescente para cada instancia
-            for (int j = 0; j != k; ++j) {
-                closest[i * k + j] = q.poll().getI();
-            }
-        }
-        // Percorrendo todas as instancias
-        for (int i = 0; i != n; ++i) {
-            if (Thread.interrupted()) {
-                // We've been interrupted: no more crunching.
-                throw new InterruptedException();
-            }
-            // Percorrendo os k valores mais proximos
-            for (int j = 0; j != k; ++j) {
-                // Verificando se as instancias mais proximas sao da mesma
-                // amostra
-                if (points[d][closest[i * k + j]] == points[d][i]) {
-                    counts[i] += 1;
-                }
-            }
-        }
-        return counts;
-    }
-
-    private double R_DT(boolean lower_tail, boolean log_p) {
-        return (lower_tail) ? ((log_p) ? Double.NEGATIVE_INFINITY : 0)
-                : ((log_p) ? 0 : 1);
-    }
-
-    private double[] pnorm_both(double x, double cum, int i_tail,
-            boolean log_p) {
-        double ccum = 0;
-        final double a[] = {2.2352520354606839287, 161.02823106855587881,
-            1067.6894854603709582, 18154.981253343561249,
-            0.065682337918207449113};
-        final double b[] = {47.20258190468824187, 976.09855173777669322,
-            10260.932208618978205, 45507.789335026729956};
-        final double c[] = {0.39894151208813466764, 8.8831497943883759412,
-            93.506656132177855979, 597.27027639480026226,
-            2494.5375852903726711, 6848.1904505362823326,
-            11602.651437647350124, 9842.7148383839780218,
-            1.0765576773720192317e-8};
-        final double d[] = {22.266688044328115691, 235.38790178262499861,
-            1519.377599407554805, 6485.558298266760755,
-            18615.571640885098091, 34900.952721145977266,
-            38912.003286093271411, 19685.429676859990727};
-        final double p[] = {0.21589853405795699, 0.1274011611602473639,
-            0.022235277870649807, 0.001421619193227893466,
-            2.9112874951168792e-5, 0.02307344176494017303};
-        final double q[] = {1.28426009614491121, 0.468238212480865118,
-            0.0659881378689285515, 0.00378239633202758244,
-            7.29751555083966205e-5};
-        final double M_SQRT_32 = 5.656854249492380195206754896838;
-        final double M_1_SQRT_2PI = 0.398942280401432677939946059934;
-        double xden, xnum, temp, eps, xsq, y;
-        double min = Double.MIN_VALUE;
-        int i;
-        boolean lower, upper;
-
-        if (Double.isNaN(x)) {
-            cum = ccum = x;
-            return new double[]{cum, ccum};
-        }
-
-        eps = 1E-9 * 0.5;
-
-        lower = i_tail != 1;
-        upper = i_tail != 0;
-
-        y = Math.abs(x);
-        if (y <= 0.67448975) {
-            /*
-								 * qnorm(3/4) = .6744.... -- earlier had
-								 * 0.66291
-             */
-            if (y > eps) {
-                xsq = x * x;
-                xnum = a[4] * xsq;
-                xden = xsq;
-                for (i = 0; i < 3; ++i) {
-                    xnum = (xnum + a[i]) * xsq;
-                    xden = (xden + b[i]) * xsq;
-                }
-            } else {
-                xnum = xden = 0.0;
-            }
-
-            temp = x * (xnum + a[3]) / (xden + b[3]);
-            if (lower) {
-                cum = 0.5 + temp;
-            }
-            if (upper) {
-                ccum = 0.5 - temp;
-            }
-            if (log_p) {
-                if (lower) {
-                    cum = Math.log(cum);
-                }
-                if (upper) {
-                    ccum = Math.log(ccum);
-                }
-            }
-        } else if (y <= M_SQRT_32) {
-            xnum = c[8] * y;
-            xden = y;
-            for (i = 0; i < 7; ++i) {
-                xnum = (xnum + c[i]) * y;
-                xden = (xden + d[i]) * y;
-            }
-            temp = (xnum + c[7]) / (xden + d[7]);
-
-            double[] retorno = do_del(y, log_p, cum, ccum, lower, x, temp,
-                    upper);
-            retorno = swap_tail(x, temp, retorno[0], lower, retorno[1]);
-            cum = retorno[0];
-            ccum = retorno[1];
-        } else if (log_p || (lower && -37.5193 < x && x < 8.2924)
-                || (upper && -8.2924 < x && x < 37.5193)) {
-
-            /* Evaluate pnorm for x in (-37.5, -5.657) union (5.657, 37.5) */
-            xsq = 1.0 / (x * x);
-            xnum = p[5] * xsq;
-            xden = xsq;
-            for (i = 0; i < 4; ++i) {
-                xnum = (xnum + p[i]) * xsq;
-                xden = (xden + q[i]) * xsq;
-            }
-            temp = xsq * (xnum + p[4]) / (xden + q[4]);
-            temp = (M_1_SQRT_2PI - temp) / y;
-
-            double[] retorno = do_del(x, log_p, cum, ccum, lower, x, temp,
-                    upper);
-            retorno = swap_tail(x, temp, retorno[0], lower, retorno[1]);
-            cum = retorno[0];
-            ccum = retorno[1];
-        } else /* no log_p , large x such that probs are 0 or 1 */ if (x > 0) {
-            cum = 1.;
-            ccum = 0.;
-        } else {
-            cum = 0.;
-            ccum = 1.;
-        }
-
-        /* do not return "denormalized" -- we do in R */
-        if (log_p) {
-            if (cum > -min) {
-                cum = -0.;
-            }
-            if (ccum > -min) {
-                ccum = -0.;
-            }
-        } else {
-            if (cum < min) {
-                cum = 0.;
-            }
-            if (ccum < min) {
-                ccum = 0.;
-            }
-        }
-        return new double[]{cum, ccum};
-    }
-
-    private double[] do_del(double X, boolean log_p, double cum,
-            double ccum, boolean lower, double x, double temp, boolean upper) {
-        final int SIXTEN = 16;
-        double xsq = Math.ceil(X * SIXTEN) / SIXTEN;
-        double del = (X - xsq) * (X + xsq);
-        if (log_p) {
-            cum = (-xsq * xsq * 0.5) + (-del * 0.5) + Math.log(temp);
-            if ((lower && x > 0.) || (upper && x <= 0.)) {
-                ccum = Math.log1p(-Math.exp(-xsq * xsq * 0.5)
-                        * Math.exp(-del * 0.5) * temp);
-            }
-        } else {
-            cum = Math.exp(-xsq * xsq * 0.5) * Math.exp(-del * 0.5) * temp;
-            ccum = 1.0 - cum;
-        }
-        return new double[]{cum, ccum};
-    }
-
-    private double[] swap_tail(double x, double temp, double cum,
-            boolean lower, double ccum) {
-        if (x > 0.) {/* swap ccum <--> cum */
-            temp = cum;
-            if (lower) {
-                cum = ccum;
-            }
-            ccum = temp;
-        }
-        return new double[]{cum, ccum};
-    }
-
-    @Override
-    public double test(List<Instance> x, List<Instance> y) {
-        try {
-            return this.mtsknn(x, y)[2];
-        } catch (InterruptedException ie) {
-            return 0.0;
-        }
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub		
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    public Double call() throws Exception {
-        return this.test(sample1i, sample2i);
-    }
-
-    @Override
-    public void set(List<Instance> x, List<Instance> y) {
-        this.sample1i = x;
-        this.sample2i = y;
-    }
-
-    public static void main(String[] args) throws Exception {
-        List<Instance> x = Cramer.fileToInstances("c:\\Users\\Paulo\\Documents\\test1-x.arff");
-        List<Instance> y = Cramer.fileToInstances("c:\\Users\\Paulo\\Documents\\test1-y.arff");
-
-        KNN c = new KNN();
-        double[] ct = c.mtsknn(x, y);
-        System.out.println("p Value [Resultado esperado: 0.09866699171730517] [Resultado obtido..: " + ct[2] + "]");
-        System.out.println("Critical value [Resultado esperado: 0.521] [Resultado obtido: " + ct[0] + "]");
-        System.out.println("Statistic [Resultado esperado: 1.2891844104764096] [Resultado obtido: " + ct[1] + "]");
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/drift/DriftDetectionMethodClassifier.java b/moa/src/main/java/moa/classifiers/drift/DriftDetectionMethodClassifier.java
deleted file mode 100644
index f1537c54d..000000000
--- a/moa/src/main/java/moa/classifiers/drift/DriftDetectionMethodClassifier.java
+++ /dev/null
@@ -1,201 +0,0 @@
-/*
- *    DriftDetectionMethodClassifier.java
- *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
- *    @author Manuel Baena (mbaena@lcc.uma.es)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package moa.classifiers.drift;
-
-import java.util.LinkedList;
-import java.util.List;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.capabilities.CapabilitiesHandler;
-import moa.capabilities.Capability;
-import moa.capabilities.ImmutableCapabilities;
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.AbstractInstanceLearner;
-import moa.classifiers.core.driftdetection.ChangeDetector;
-import moa.classifiers.meta.WEKAClassifier;
-import moa.core.Measurement;
-import moa.core.Utils;
-import moa.learners.Classifier;
-import moa.options.ClassOption;
-
-/**
- * Class for handling concept drift datasets with a wrapper on a
- * classifier.<p>
- *
- * Valid options are:<p>
- *
- * -l classname <br>
- * Specify the full class name of a classifier as the basis for
- * the concept drift classifier.<p>
- * -d Drift detection method to use<br>
- *
- * @author Manuel Baena (mbaena@lcc.uma.es)
- * @version 1.1
- */
-public class DriftDetectionMethodClassifier extends AbstractClassifier implements Classifier, CapabilitiesHandler {
-
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public String getPurposeString() {
-        return "Classifier that replaces the current classifier with a new one when a change is detected in accuracy.";
-    }
-    
-    public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l',
-            "Classifier to train.", Classifier.class, "moa.classifiers.bayes.NaiveBayes");
-    
-    public ClassOption driftDetectionMethodOption = new ClassOption("driftDetectionMethod", 'd',
-             "Drift detection method to use.", ChangeDetector.class, "moa.classifiers.core.driftdetection.DDM");
-
-    protected Classifier classifier;
-
-    protected Classifier newclassifier;
-
-    protected ChangeDetector driftDetectionMethod;
-
-    protected boolean newClassifierReset;
-    //protected int numberInstances = 0;
-
-    protected int ddmLevel;
-
-    public boolean isWarningDetected() {
-        return (this.ddmLevel == DDM_WARNING_LEVEL);
-    }
-
-    public boolean isChangeDetected() {
-        return (this.ddmLevel == DDM_OUTCONTROL_LEVEL);
-    }
-
-    public static final int DDM_INCONTROL_LEVEL = 0;
-
-    public static final int DDM_WARNING_LEVEL = 1;
-
-    public static final int DDM_OUTCONTROL_LEVEL = 2;
-    
-    @Override
-    public void resetLearningImpl() {
-        this.classifier = (Classifier) ((Classifier) getPreparedClassOption(this.baseLearnerOption)).copy();
-        this.newclassifier = (Classifier) this.classifier.copy();
-        this.classifier.resetLearning();
-        this.newclassifier.resetLearning();
-        this.driftDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.driftDetectionMethodOption)).copy();
-        this.newClassifierReset = false;
-    }
-
-    protected int changeDetected = 0;
-
-    protected int warningDetected = 0;
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        //this.numberInstances++;
-        int trueClass = (int) inst.classValue();
-        boolean prediction;
-        if (Utils.maxIndex(this.classifier.getPredictionForInstance(inst)) == trueClass) {
-            prediction = true;
-        } else {
-            prediction = false;
-        }
-        //this.ddmLevel = this.driftDetectionMethod.computeNextVal(prediction);
-        this.driftDetectionMethod.input(prediction ? 0.0 : 1.0);
-        this.ddmLevel = DDM_INCONTROL_LEVEL;
-        if (this.driftDetectionMethod.getChange()) {
-         this.ddmLevel =  DDM_OUTCONTROL_LEVEL;
-        }
-        if (this.driftDetectionMethod.getWarningZone()) {
-           this.ddmLevel =  DDM_WARNING_LEVEL;
-        }
-        switch (this.ddmLevel) {
-            case DDM_WARNING_LEVEL:
-                //System.out.println("1 0 W");
-            	//System.out.println("DDM_WARNING_LEVEL");
-                if (newClassifierReset == true) {
-                    this.warningDetected++;
-                    this.newclassifier.resetLearning();
-                    newClassifierReset = false;
-                }
-                this.newclassifier.trainOnInstance(inst);
-                break;
-
-            case DDM_OUTCONTROL_LEVEL:
-                //System.out.println("0 1 O");
-            	//System.out.println("DDM_OUTCONTROL_LEVEL");
-                this.changeDetected++;
-                this.classifier = null;
-                this.classifier = this.newclassifier;
-                if (this.classifier instanceof WEKAClassifier) {
-                    ((WEKAClassifier) this.classifier).buildClassifier();
-                }
-                this.newclassifier = (Classifier) ((Classifier) getPreparedClassOption(this.baseLearnerOption)).copy();
-                this.newclassifier.resetLearning();
-                break;
-
-            case DDM_INCONTROL_LEVEL:
-                //System.out.println("0 0 I");
-            	//System.out.println("DDM_INCONTROL_LEVEL");
-                newClassifierReset = true;
-                break;
-            default:
-            //System.out.println("ERROR!");
-
-        }
-
-        this.classifier.trainOnInstance(inst);
-    }
-
-    public Prediction getPredictionForInstance(Instance inst) {
-        return this.classifier.getPredictionForInstance(inst);
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return true;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        ((AbstractInstanceLearner) this.classifier).getModelDescription(out, indent);
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        List<Measurement> measurementList = new LinkedList<Measurement>();
-        measurementList.add(new Measurement("Change detected", this.changeDetected));
-        measurementList.add(new Measurement("Warning detected", this.warningDetected));
-        Measurement[] modelMeasurements = ((AbstractInstanceLearner) this.classifier).getModelMeasurements();
-        if (modelMeasurements != null) {
-            for (Measurement measurement : modelMeasurements) {
-                measurementList.add(measurement);
-            }
-        }
-        this.changeDetected = 0;
-        this.warningDetected = 0;
-        return measurementList.toArray(new Measurement[measurementList.size()]);
-    }
-
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == DriftDetectionMethodClassifier.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/functions/AdaGrad.java b/moa/src/main/java/moa/classifiers/functions/AdaGrad.java
deleted file mode 100644
index fb1eb4704..000000000
--- a/moa/src/main/java/moa/classifiers/functions/AdaGrad.java
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
- *    AdaGrad.java
- *    Copyright (C) 2016 University of Waikato, Hamilton, New Zealand
- *    @author Henry Gouk (hgrg1{[at]}students{[dot]}waikato{[dot]}ac{[dot]}nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.functions;
-
-import moa.core.DoubleVector;
-import com.github.javacliparser.FloatOption;
-import com.yahoo.labs.samoa.instances.Instance;
-
-/**
-<!-- globalinfo-start -->
- * Implements the AdaGrad oneline optimiser for learning various linear models (binary class SVM, binary class logistic regression and linear regression). For more information, see<br/> <br/> Duchi, J., Hazan, E., &amp; Singer, Y. (2011). Adaptive subgradient methods for online learning and stochastic optimization. Journal of Machine Learning Research, 12 (Jul), 2121-2159.
- * <p/>
- * <!-- globalinfo-end -->
- * *
-<!-- technical-bibtex-start --> BibTeX:
- * <pre>
- * &#64;inproceedings{duchi2011,
- *    author = {Duchi, John and Hazan, Elad and Singer, Yoram},
- *    booktitle = {Journal of Machine Learning Research},
- *    pages = {2121--2159},
- *    volume={12},
- *    number={Jul},
- *    title = {Adaptive subgradient methods for online learning and stochastic optimization},
- *    year = {2011}
- * }
- * </pre>
- * <p/>
- * <!-- technical-bibtex-end -->
- *
- */
-public class AdaGrad extends SGD{
-
-    /** For serialization */
-    private static final long serialVersionUID = -3732968666673530291L;
-
-    @Override
-    public String getPurposeString() {
-        return "An online optimiser for learning various linear models (binary class SVM, binary class logistic regression and linear regression).";
-    }
- 
-    /** The epsilon value */
-    protected double m_epsilon = 1e-8;
-
-    public FloatOption epsilonOption = new FloatOption("epsilon",
-            'p', "epsilon parameter.",
-            1e-8);
-
-    /** Stores the weights (+ bias in the last element) */
-    protected DoubleVector m_velocity;
-    protected double m_biasVelocity;
-
-    /**
-     * Set the epsilon value.
-     *
-     * @param eps the epsilon value to use.
-     */
-    public void setEpsilon(double eps) {
-        m_epsilon = eps;
-    }
-
-    /**
-     * Get the epsilon value.
-     *
-     * @return the epsilon value
-     */
-    public double getEpsilon() {
-        return m_epsilon;
-    }
-
-    public AdaGrad() {
-        lambdaRegularizationOption = new FloatOption(
-                lambdaRegularizationOption.getName(),
-                lambdaRegularizationOption.getCLIChar(),
-                lambdaRegularizationOption.getPurpose(),
-                0.0);
-
-        learningRateOption = new FloatOption(
-                learningRateOption.getName(),
-                learningRateOption.getCLIChar(),
-                learningRateOption.getPurpose(),
-                0.01);
-    }
-
-    @Override
-    public void resetLearningImpl() {
-        reset();
-        setLambda(this.lambdaRegularizationOption.getValue());
-        setLearningRate(this.learningRateOption.getValue());
-        setEpsilon(this.epsilonOption.getValue());
-        setLossFunction(this.lossFunctionOption.getChosenIndex());
-    }
-
-    /**
-     * Trains the classifier with the given instance.
-     *
-     * @param instance    the new training instance to include in the model
-     */
-    @Override
-    public void trainOnInstanceImpl(Instance instance) {
-
-        if (m_weights == null) {
-            m_weights = new DoubleVector();
-            m_velocity = new DoubleVector();
-            m_bias = 0;
-
-            m_weights.setValue(instance.numAttributes(), 0);
-            m_velocity.setValue(instance.numAttributes(), 0);
-        }
-
-        if (instance.classIsMissing()) {
-            return;
-        }
-   
-        double z = dotProd(instance, m_weights, instance.classIndex()) + m_bias;
-
-        double y;
-        double dldz;
-
-        if (instance.classAttribute().isNominal()) {
-            y = (instance.classValue() == 0) ? 0 : 1;
-            
-            if (m_loss == LOGLOSS) {
-                double yhat = 1.0 / (1.0 + Math.exp(-z));
-                dldz = (yhat - y);
-            }
-            else {
-                y = y * 2 - 1;
-                
-                if(y * z < 1.0)
-                {
-                    dldz = -y;
-                }
-                else
-                {
-                    dldz = 0;
-                }
-            }
-        }
-        else {
-            y = instance.classValue();
-            dldz = z - y;
-        }
-
-        int n = instance.numValues();
-        DoubleVector gradients = new DoubleVector();
-        gradients.setValue(instance.numAttributes(), 0);
-
-        for(int i = 0; i < n; i++)
-        {
-            int idx = instance.index(i);
-            gradients.setValue(idx, instance.valueSparse(i) * dldz + (m_lambda / (m_t + m_epsilon)) * m_weights.getValue(idx));
-        }
-
-        //Weight update for the bias
-        double biasGradient = dldz;
-        m_biasVelocity += biasGradient * biasGradient;
-        m_bias -= (m_learningRate / (Math.sqrt(m_biasVelocity) + m_epsilon)) * biasGradient;
-
-        for(int i = 0; i < m_weights.numValues(); i++) {
-            //Weight update
-            double g = gradients.getValue(i);
-            m_velocity.addToValue(i, g * g);
-            m_weights.addToValue(i, -(m_learningRate / (Math.sqrt(m_velocity.getValue(i)) + m_epsilon)) * g);
-        }
-
-        m_t += 1.0;
-    }
-
-    @Override
-    protected String getModelName() {
-        return "AdaGrad";
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/functions/MajorityClass.java b/moa/src/main/java/moa/classifiers/functions/MajorityClass.java
deleted file mode 100644
index 3471718ff..000000000
--- a/moa/src/main/java/moa/classifiers/functions/MajorityClass.java
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- *    MajorityClass.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.functions;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.capabilities.Capability;
-import moa.capabilities.ImmutableCapabilities;
-import moa.classifiers.AbstractClassifier;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.core.StringUtils;
-import moa.learners.Classifier;
-
-/**
- * Majority class learner. This is the simplest classifier.
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $
- */
-public class MajorityClass extends AbstractClassifier implements Classifier {
-
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public String getPurposeString() {
-        return "Majority class classifier: always predicts the class that has been observed most frequently the in the training data.";
-    }
-
-    protected DoubleVector observedClassDistribution;
-
-    @Override
-    public void resetLearningImpl() {
-        this.observedClassDistribution = new DoubleVector();
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight());
-    }
-
-    public Prediction getPredictionForInstance(Instance i) {
-        return new ClassificationPrediction(this.observedClassDistribution.getArrayCopy());
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return null;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        StringUtils.appendIndented(out, indent, "Predicted majority ");
-        out.append(getClassNameString());
-        out.append(" = ");
-        out.append(getClassLabelString(this.observedClassDistribution.maxIndex()));
-        StringUtils.appendNewline(out);
-        for (int i = 0; i < this.observedClassDistribution.numValues(); i++) {
-            StringUtils.appendIndented(out, indent, "Observed weight of ");
-            out.append(getClassLabelString(i));
-            out.append(": ");
-            out.append(this.observedClassDistribution.getValue(i));
-            StringUtils.appendNewline(out);
-        }
-    }
-
-    public boolean isRandomizable() {
-        return false;
-    }
-
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == MajorityClass.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/functions/Perceptron.java b/moa/src/main/java/moa/classifiers/functions/Perceptron.java
deleted file mode 100644
index a248cfba4..000000000
--- a/moa/src/main/java/moa/classifiers/functions/Perceptron.java
+++ /dev/null
@@ -1,159 +0,0 @@
-/*
- *    Perceptron.java
- *    Copyright (C) 2009 University of Waikato, Hamilton, New Zealand
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.functions;
-
-import com.github.javacliparser.FloatOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractClassifier;
-import moa.core.Measurement;
-import moa.core.Utils;
-import moa.learners.Classifier;
-
-/**
- * Single perceptron classifier.
- *
- * <p>Performs classic perceptron multiclass learning incrementally.</p>
- *
- * <p>Parameters:</p> <ul> <li>-r : Learning ratio of the classifier</li> </ul>
- *
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @version $Revision: 7 $
- */
-public class Perceptron extends AbstractClassifier implements Classifier {
-
-    private static final long serialVersionUID = 221L;
-
-    @Override
-    public String getPurposeString() {
-        return "Perceptron classifier: Single perceptron classifier.";
-    }
-
-    public FloatOption learningRatioOption = new FloatOption("learningRatio", 't', "Learning ratio", 1);
-
-    protected double[][] weightAttribute;
-
-    protected boolean reset;
-
-    protected int numberAttributes;
-
-    protected int numberClasses;
-
-    protected int numberDetections;
-
-    @Override
-    public void resetLearningImpl() {
-        this.reset = true;
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-
-        //Init Perceptron
-        if (this.reset == true) {
-            this.reset = false;
-            this.numberAttributes = inst.numAttributes();
-            this.numberClasses = inst.numClasses();
-            this.weightAttribute = new double[inst.numClasses()][inst.numAttributes()];
-            for (int i = 0; i < inst.numClasses(); i++) {
-                for (int j = 0; j < inst.numAttributes(); j++) {
-                    weightAttribute[i][j] = 0.2 * this.classifierRandom.nextDouble() - 0.1;
-                }
-            }
-        }
-
-        double[] preds = new double[inst.numClasses()];
-        for (int i = 0; i < inst.numClasses(); i++) {
-            preds[i] = prediction(inst, i);
-        }
-        double learningRatio = learningRatioOption.getValue();
-
-        int actualClass = (int) inst.classValue();
-        for (int i = 0; i < inst.numClasses(); i++) {
-            double actual = (i == actualClass) ? 1.0 : 0.0;
-            double delta = (actual - preds[i]) * preds[i] * (1 - preds[i]);
-            for (int j = 0; j < inst.numAttributes() - 1; j++) {
-                this.weightAttribute[i][j] += learningRatio * delta * inst.valueInputAttribute(j);
-            }
-            this.weightAttribute[i][inst.numAttributes() - 1] += learningRatio * delta;
-        }
-    }
-
-    public void setWeights(double[][] w) {
-        //Perceptron Hoeffding Tree
-        this.weightAttribute = w;
-    }
-
-    public double[][] getWeights() {
-        //Perceptron Hoeffding Tree
-        return this.weightAttribute;
-    }
-
-    public int getNumberAttributes() {
-        //Perceptron Hoeffding Tree
-        return this.numberAttributes;
-    }
-
-    public int getNumberClasses() {
-        //Perceptron Hoeffding Tree
-        return this.numberClasses;
-    }
-
-    public double prediction(Instance inst, int classVal) {
-        double sum = 0.0;
-        for (int i = 0; i < inst.numAttributes() - 1; i++) {
-            sum += weightAttribute[classVal][i] * inst.valueInputAttribute(i);
-        }
-        sum += weightAttribute[classVal][inst.numAttributes() - 1];
-        return 1.0 / (1.0 + Math.exp(-sum));
-    }
-
-    @Override
-    public Prediction getPredictionForInstance(Instance inst) {
-        double[] votes = new double[inst.numClasses()];
-        if (this.reset == false) {
-            for (int i = 0; i < votes.length; i++) {
-                votes[i] = prediction(inst, i);
-            }
-            try {
-                Utils.normalize(votes);
-            } catch (Exception e) {
-                // ignore all zero votes error
-            }
-        }
-        return new ClassificationPrediction(votes);
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return null;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return true;
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/functions/SGD.java b/moa/src/main/java/moa/classifiers/functions/SGD.java
deleted file mode 100644
index bd40b7bd1..000000000
--- a/moa/src/main/java/moa/classifiers/functions/SGD.java
+++ /dev/null
@@ -1,390 +0,0 @@
-/*
- *    SGD.java
- *    Copyright (C) 2009 University of Waikato, Hamilton, New Zealand
- *    @author Eibe Frank (eibe{[at]}cs{[dot]}waikato{[dot]}ac{[dot]}nz)
- *    @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-
-/*
- *    SGD.java
- *    Copyright (C) 2009 University of Waikato, Hamilton, New Zealand
- *
- */
-
-package moa.classifiers.functions;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-import com.yahoo.labs.samoa.instances.predictions.RegressionPrediction;
-
-import moa.classifiers.AbstractClassifier;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.core.StringUtils;
-import moa.core.Utils;
-import moa.learners.Classifier;
-import moa.learners.Regressor;
-
-/**
-<!-- globalinfo-start -->
- * Implements stochastic gradient descent for learning various linear models (binary class SVM, binary class logistic regression and linear regression). 
- * <p/>
-<!-- globalinfo-end -->
- *
- */
-public class SGD extends AbstractClassifier implements Classifier, Regressor {
-
-    /** For serialization */
-    private static final long serialVersionUID = -3732968666673530290L;
-
-      @Override
-    public String getPurposeString() {
-        return "AStochastic gradient descent for learning various linear models (binary class SVM, binary class logistic regression and linear regression).";
-    }
-
-    /** The regularization parameter */
-    protected double m_lambda = 0.0001;
-
-    public FloatOption lambdaRegularizationOption = new FloatOption("lambdaRegularization",
-            'l', "Lambda regularization parameter .",
-            0.0001, 0.00, Integer.MAX_VALUE);
-
-    /** The learning rate */
-    protected double m_learningRate = 0.01;
-
-    public FloatOption learningRateOption = new FloatOption("learningRate",
-            'r', "Learning rate parameter.",
-            0.0001, 0.00, Integer.MAX_VALUE);
-
-    /** Stores the weights (+ bias in the last element) */
-    protected DoubleVector m_weights;
-    
-    protected double m_bias;
-
-    /** Holds the current iteration number */
-    protected double m_t;
-
-    /** The number of training instances */
-    protected double m_numInstances;
-
-    protected static final int HINGE = 0;
-
-    protected static final int LOGLOSS = 1;
-
-    protected static final int SQUAREDLOSS = 2;
-
-    /** The current loss function to minimize */
-    protected int m_loss = HINGE;
-
-    public MultiChoiceOption lossFunctionOption = new MultiChoiceOption(
-            "lossFunction", 'o', "The loss function to use.", new String[]{
-                "HINGE", "LOGLOSS", "SQUAREDLOSS"}, new String[]{
-                "Hinge loss (SVM)",
-                "Log loss (logistic regression)",
-                "Squared loss (regression)"}, 0);
-
-    /**
-     * Set the value of lambda to use
-     *
-     * @param lambda the value of lambda to use
-     */
-    public void setLambda(double lambda) {
-        m_lambda = lambda;
-    }
-
-    /**
-     * Get the current value of lambda
-     *
-     * @return the current value of lambda
-     */
-    public double getLambda() {
-        return m_lambda;
-    }
-
-    /**
-     * Set the loss function to use.
-     *
-     * @param function the loss function to use.
-     */
-    public void setLossFunction(int function) {
-        m_loss = function;
-    }
-
-    /**
-     * Get the current loss function.
-     *
-     * @return the current loss function.
-     */
-    public int getLossFunction() {
-        return m_loss;
-    }
-
-    /**
-     * Set the learning rate.
-     *
-     * @param lr the learning rate to use.
-     */
-    public void setLearningRate(double lr) {
-        m_learningRate = lr;
-    }
-
-    /**
-     * Get the learning rate.
-     *
-     * @return the learning rate
-     */
-    public double getLearningRate() {
-        return m_learningRate;
-    }
-
-    /**
-     * Reset the classifier.
-     */
-    public void reset() {
-        m_t = 1;
-        m_weights = null;
-        m_bias = 0.0;
-    }
-
-    protected double dloss(double z) {
-        if (m_loss == HINGE) {
-            return (z < 1) ? 1 : 0;
-        }
-
-        if (m_loss == LOGLOSS) {
-            // log loss
-            if (z < 0) {
-                return 1.0 / (Math.exp(z) + 1.0);
-            } else {
-                double t = Math.exp(-z);
-                return t / (t + 1);
-            }
-        }
-
-        // squared loss
-        return z;
-    }
-
-    protected static double dotProd(Instance inst1, DoubleVector weights, int classIndex) {
-        double result = 0;
-
-        int n1 = inst1.numValues();
-        int n2 = weights.numValues();
-
-        for (int p1 = 0, p2 = 0; p1 < n1 && p2 < n2;) {
-            int ind1 = inst1.index(p1);
-            int ind2 = p2;
-            if (ind1 == ind2) {
-                if (ind1 != classIndex && !inst1.isMissingSparse(p1)) {
-                    result += inst1.valueSparse(p1) * weights.getValue(p2);
-                }
-                p1++;
-                p2++;
-            } else if (ind1 > ind2) {
-                p2++;
-            } else {
-                p1++;
-            }
-        }
-        return (result);
-    }
-
-    @Override
-    public void resetLearningImpl() {
-        reset();
-        setLambda(this.lambdaRegularizationOption.getValue());
-        setLearningRate(this.learningRateOption.getValue());
-        setLossFunction(this.lossFunctionOption.getChosenIndex());
-    }
-
-    /**
-     * Trains the classifier with the given instance.
-     *
-     * @param instance 	the new training instance to include in the model
-     */
-    @Override
-    public void trainOnInstanceImpl(Instance instance) {
-
-        if (m_weights == null) {
-            m_weights = new DoubleVector(); 
-            m_bias = 0.0;
-        }
-
-        if (!instance.classIsMissing()) {
-
-            double wx = dotProd(instance, m_weights, instance.classIndex());
-
-            double y;
-            double z;
-            if (instance.classAttribute().isNominal()) {
-                y = (instance.classValue() == 0) ? -1 : 1;
-                z = y * (wx + m_bias);
-            } else {
-                y = instance.classValue();
-                z = y - (wx + m_bias);
-                y = 1;
-            }
-
-            // Compute multiplier for weight decay
-            double multiplier = 1.0;
-            if (m_numInstances == 0) {
-                multiplier = 1.0 - (m_learningRate * m_lambda) / m_t;
-            } else {
-                multiplier = 1.0 - (m_learningRate * m_lambda) / m_numInstances;
-            }
-            for (int i = 0; i < m_weights.numValues(); i++) {
-                m_weights.setValue(i,m_weights.getValue (i) * multiplier);
-            }
-
-            // Only need to do the following if the loss is non-zero
-            if (m_loss != HINGE || (z < 1)) {
-
-                // Compute Factor for updates
-                double factor = m_learningRate * y * dloss(z);
-
-                // Update coefficients for attributes
-                int n1 = instance.numValues();
-                for (int p1 = 0; p1 < n1; p1++) {
-                    int indS = instance.index(p1);
-                    if (indS != instance.classIndex() && !instance.isMissingSparse(p1)) {
-                        m_weights.addToValue(indS, factor * instance.valueSparse(p1));
-                    }
-                }
-
-                // update the bias
-                m_bias += factor;
-            }
-            m_t++;
-        }
-    }
-
-    /**
-     * Calculates the class membership probabilities for the given test
-     * instance.
-     *
-     * @param instance 	the instance to be classified
-     * @return 		predicted class probability distribution
-     */
-    @Override
-    public Prediction getPredictionForInstance(Instance inst) {
-
-        if (m_weights == null) {
-            return new ClassificationPrediction();
-        }
-        double[] result = (inst.classAttribute().isNominal())
-                ? new double[2]
-                : new double[1];
-
-
-        double wx = dotProd(inst, m_weights, inst.classIndex());// * m_wScale;
-        double z = (wx + m_bias);
-
-        if (inst.classAttribute().isNumeric()) {
-        	// TODO This should not be happening here!
-            result[0] = z;
-            return new RegressionPrediction(result[0]);
-        }
-
-        if (z <= 0) {
-            //  z = 0;
-            if (m_loss == LOGLOSS) {
-                result[0] = 1.0 / (1.0 + Math.exp(z));
-                result[1] = 1.0 - result[0];
-            } else {
-                result[0] = 1;
-            }
-        } else {
-            if (m_loss == LOGLOSS) {
-                result[1] = 1.0 / (1.0 + Math.exp(-z));
-                result[0] = 1.0 - result[1];
-            } else {
-                result[1] = 1;
-            }
-        }
-        return new ClassificationPrediction(result);
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder result, int indent) {
-        StringUtils.appendIndented(result, indent, toString());
-        StringUtils.appendNewline(result);
-    }
-
-    protected String getModelName() {
-        return "SGD";
-    }
-
-    /**
-     * Prints out the classifier.
-     *
-     * @return a description of the classifier as a string
-     */
-    public String toString() {
-        if (m_weights == null) {
-            return getModelName() + ": No model built yet.\n";
-        }
-        StringBuffer buff = new StringBuffer();
-        buff.append("Loss function: ");
-        if (m_loss == HINGE) {
-            buff.append("Hinge loss (SVM)\n\n");
-        } else if (m_loss == LOGLOSS) {
-            buff.append("Log loss (logistic regression)\n\n");
-        } else {
-            buff.append("Squared loss (linear regression)\n\n");
-        }
-
-        // buff.append(m_data.classAttribute().name() + " = \n\n");
-        int printed = 0;
-
-        for (int i = 0; i < m_weights.numValues(); i++) {
-            // if (i != m_data.classIndex()) {
-            if (printed > 0) {
-                buff.append(" + ");
-            } else {
-                buff.append("   ");
-            }
-
-            buff.append(Utils.doubleToString(m_weights.getValue(i), 12, 4) + " "
-                    // + m_data.attribute(i).name()
-                    + "\n");
-
-            printed++;
-            //}
-        }
-
-        if (m_bias > 0) {
-            buff.append(" + " + Utils.doubleToString(m_bias, 12, 4));
-        } else {
-            buff.append(" - " + Utils.doubleToString(-m_bias, 12, 4));
-        }
-
-        return buff.toString();
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return null;
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return false;
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/functions/SGDMultiClass.java b/moa/src/main/java/moa/classifiers/functions/SGDMultiClass.java
deleted file mode 100644
index 00851c059..000000000
--- a/moa/src/main/java/moa/classifiers/functions/SGDMultiClass.java
+++ /dev/null
@@ -1,408 +0,0 @@
-/*
- *    SGDMultiClass.java
- *    Copyright (C) 2009 University of Waikato, Hamilton, New Zealand
- *    @author Eibe Frank (eibe{[at]}cs{[dot]}waikato{[dot]}ac{[dot]}nz)
- *    @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-
-/*
- *    SGDMultiClass.java
- *    Copyright (C) 2009 University of Waikato, Hamilton, New Zealand
- *
- */
-
-package moa.classifiers.functions;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-import com.yahoo.labs.samoa.instances.predictions.RegressionPrediction;
-
-import moa.classifiers.AbstractClassifier;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.core.StringUtils;
-import moa.core.Utils;
-import moa.learners.Classifier;
-import moa.learners.Regressor;
-
-
-/**
-<!-- globalinfo-start -->
- * Implements stochastic gradient descent for learning various linear models (binary class SVM, binary class logistic regression and linear regression). 
- * <p/>
-<!-- globalinfo-end -->
- *
- */
-public class SGDMultiClass extends AbstractClassifier implements Classifier, Regressor {
-
-    /** For serialization */
-    private static final long serialVersionUID = -3732968666673530290L;
-
-      @Override
-    public String getPurposeString() {
-        return "AStochastic gradient descent for learning various linear models (binary class SVM, binary class logistic regression and linear regression).";
-    }
-
-    /** The regularization parameter */
-    protected double m_lambda = 0.0001;
-
-    public FloatOption lambdaRegularizationOption = new FloatOption("lambdaRegularization",
-            'l', "Lambda regularization parameter .",
-            0.0001, 0.00, Integer.MAX_VALUE);
-
-    /** The learning rate */
-    protected double m_learningRate = 0.01;
-
-    public FloatOption learningRateOption = new FloatOption("learningRate",
-            'r', "Learning rate parameter.",
-            0.0001, 0.00, Integer.MAX_VALUE);
-
-    /** Stores the weights (+ bias in the last element) */
-    protected DoubleVector[] m_weights;
-    
-    protected double[] m_bias;
-
-    /** Holds the current iteration number */
-    protected double m_t;
-
-    /** The number of training instances */
-    protected double m_numInstances;
-
-    protected static final int HINGE = 0;
-
-    protected static final int LOGLOSS = 1;
-
-    protected static final int SQUAREDLOSS = 2;
-
-    /** The current loss function to minimize */
-    protected int m_loss = HINGE;
-
-    public MultiChoiceOption lossFunctionOption = new MultiChoiceOption(
-            "lossFunction", 'o', "The loss function to use.", new String[]{
-                "HINGE", "LOGLOSS", "SQUAREDLOSS"}, new String[]{
-                "Hinge loss (SVM)",
-                "Log loss (logistic regression)",
-                "Squared loss (regression)"}, 0);
-
-    /**
-     * Set the value of lambda to use
-     *
-     * @param lambda the value of lambda to use
-     */
-    public void setLambda(double lambda) {
-        m_lambda = lambda;
-    }
-
-    /**
-     * Get the current value of lambda
-     *
-     * @return the current value of lambda
-     */
-    public double getLambda() {
-        return m_lambda;
-    }
-
-    /**
-     * Set the loss function to use.
-     *
-     * @param function the loss function to use.
-     */
-    public void setLossFunction(int function) {
-        m_loss = function;
-    }
-
-    /**
-     * Get the current loss function.
-     *
-     * @return the current loss function.
-     */
-    public int getLossFunction() {
-        return m_loss;
-    }
-
-    /**
-     * Set the learning rate.
-     *
-     * @param lr the learning rate to use.
-     */
-    public void setLearningRate(double lr) {
-        m_learningRate = lr;
-    }
-
-    /**
-     * Get the learning rate.
-     *
-     * @return the learning rate
-     */
-    public double getLearningRate() {
-        return m_learningRate;
-    }
-
-    /**
-     * Reset the classifier.
-     */
-    public void reset() {
-        m_t = 1;
-        m_weights = null;
-        m_bias = null; //0.0;
-    }
-
-    protected double dloss(double z) {
-        if (m_loss == HINGE) {
-            return (z < 1) ? 1 : 0;
-        }
-
-        if (m_loss == LOGLOSS) {
-            // log loss
-            if (z < 0) {
-                return 1.0 / (Math.exp(z) + 1.0);
-            } else {
-                double t = Math.exp(-z);
-                return t / (t + 1);
-            }
-        }
-
-        // squared loss
-        return z;
-    }
-
-    protected static double dotProd(Instance inst1, DoubleVector weights, int classIndex) {
-        double result = 0;
-
-        int n1 = inst1.numValues();
-        int n2 = weights.numValues();
-
-        for (int p1 = 0, p2 = 0; p1 < n1 && p2 < n2;) {
-            int ind1 = inst1.index(p1);
-            int ind2 = p2;
-            if (ind1 == ind2) {
-                if (ind1 != classIndex && !inst1.isMissingSparse(p1)) {
-                    result += inst1.valueSparse(p1) * weights.getValue(p2);
-                }
-                p1++;
-                p2++;
-            } else if (ind1 > ind2) {
-                p2++;
-            } else {
-                p1++;
-            }
-        }
-        return (result);
-    }
-
-    @Override
-    public void resetLearningImpl() {
-        reset();
-        setLambda(this.lambdaRegularizationOption.getValue());
-        setLearningRate(this.learningRateOption.getValue());
-        setLossFunction(this.lossFunctionOption.getChosenIndex());
-    }
-
-    /**
-     * Trains the classifier with the given instance.
-     *
-     * @param instance 	the new training instance to include in the model
-     */
-    @Override
-    public void trainOnInstanceImpl(Instance instance) {
-
-        if (m_weights == null) {
-            int length;
-             if (instance.classAttribute().isNominal()) {
-                 length = instance.numClasses();
-             } else {
-                 length = 1;
-             }
-            m_weights = new DoubleVector[length];
-            m_bias = new double[length];
-            for (int i = 0; i < m_weights.length; i++){
-                m_weights[i] = new DoubleVector(); 
-                m_bias[i] = 0.0;
-            }
-        }
-        for (int i = 0; i < m_weights.length; i++){
-                this.trainOnInstanceImpl(instance, i); 
-            }
-        m_t++;
-    }    
-    public void trainOnInstanceImpl(Instance instance, int classLabel) {    
-        if (!instance.classIsMissing()) {
-
-            double wx = dotProd(instance, m_weights[classLabel], instance.classIndex());
-
-            double y;
-            double z;
-            if (instance.classAttribute().isNominal()) {
-                y = (instance.classValue() != classLabel) ? -1 : 1;
-                z = y * (wx + m_bias[classLabel]);
-            } else {
-                y = instance.classValue();
-                z = y - (wx + m_bias[classLabel]);
-                y = 1;
-            }
-
-            // Compute multiplier for weight decay
-            double multiplier = 1.0;
-            if (m_numInstances == 0) {
-                multiplier = 1.0 - (m_learningRate * m_lambda) / m_t;
-            } else {
-                multiplier = 1.0 - (m_learningRate * m_lambda) / m_numInstances;
-            }
-            for (int i = 0; i < m_weights[classLabel].numValues(); i++) {
-                m_weights[classLabel].setValue(i,m_weights[classLabel].getValue (i) * multiplier);
-            }
-
-            // Only need to do the following if the loss is non-zero
-            if (m_loss != HINGE || (z < 1)) {
-
-                // Compute Factor for updates
-                double factor = m_learningRate * y * dloss(z);
-
-                // Update coefficients for attributes
-                int n1 = instance.numValues();
-                for (int p1 = 0; p1 < n1; p1++) {
-                    int indS = instance.index(p1);
-                    if (indS != instance.classIndex() && !instance.isMissingSparse(p1)) {
-                        m_weights[classLabel].addToValue(indS, factor * instance.valueSparse(p1));
-                    }
-                }
-
-                // update the bias
-                m_bias[classLabel] += factor;
-            }
-            
-        }
-    }
-
-    /**
-     * Calculates the class membership probabilities for the given test
-     * instance.
-     *
-     * @param instance 	the instance to be classified
-     * @return 		predicted class probability distribution
-     */
-    @Override
-    public Prediction getPredictionForInstance(Instance inst) {
-
-        if (m_weights == null) {
-            return new ClassificationPrediction();
-        }
-        double[] result = (inst.classAttribute().isNominal())
-                ? new double[inst.numClasses()]
-                : new double[1];
-        
-        if (inst.classAttribute().isNumeric()) {
-        	// TODO This should not be happening here!
-            double wx = dotProd(inst, m_weights[0], inst.classIndex());// * m_wScale;
-            double z = (wx + m_bias[0]);
-            result[0] = z;
-            return new RegressionPrediction(result[0]);
-        }
-
-        for (int i = 0; i < m_weights.length; i++){
-            double wx = dotProd(inst, m_weights[i], inst.classIndex());// * m_wScale;
-            double z = (wx + m_bias[i]);
-            if (z <= 0) {
-                //  z = 0;
-                if (m_loss == LOGLOSS) {
-                    //result[0] = 1.0 / (1.0 + Math.exp(z));
-                    //result[1] = 1.0 - result[0];
-                    result[i] = 1.0 - 1.0 / (1.0 + Math.exp(z)); 
-                } else {
-                    //result[0] = 1;
-                    result[i] = 0;
-                }
-            } else {
-                if (m_loss == LOGLOSS) {
-                    //result[1] = 1.0 / (1.0 + Math.exp(-z));
-                    //result[0] = 1.0 - result[1];
-                    result[i] = 1.0 / (1.0 + Math.exp(-z)); 
-                } else {
-                    //result[1] = 1;
-                    result[i] = 1;
-                }
-            }
-        }
-        return new ClassificationPrediction(result);
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder result, int indent) {
-        StringUtils.appendIndented(result, indent, toString());
-        StringUtils.appendNewline(result);
-    }
-
-    /**
-     * Prints out the classifier.
-     *
-     * @return a description of the classifier as a string
-     */
-    public String toString() {
-        if (m_weights == null) {
-            return "SGD: No model built yet.\n";
-        }
-        StringBuffer buff = new StringBuffer();
-        buff.append("Loss function: ");
-        if (m_loss == HINGE) {
-            buff.append("Hinge loss (SVM)\n\n");
-        } else if (m_loss == LOGLOSS) {
-            buff.append("Log loss (logistic regression)\n\n");
-        } else {
-            buff.append("Squared loss (linear regression)\n\n");
-        }
-
-        // buff.append(m_data.classAttribute().name() + " = \n\n");
-        int printed = 0;
-
-        for (int i = 0; i < m_weights[0].numValues(); i++) {
-            // if (i != m_data.classIndex()) {
-            if (printed > 0) {
-                buff.append(" + ");
-            } else {
-                buff.append("   ");
-            }
-
-            buff.append(Utils.doubleToString(m_weights[0].getValue(i), 12, 4) + " "
-                    // + m_data.attribute(i).name()
-                    + "\n");
-
-            printed++;
-            //}
-        }
-
-        if (m_bias[0] > 0) {
-            buff.append(" + " + Utils.doubleToString(m_bias[0], 12, 4));
-        } else {
-            buff.append(" - " + Utils.doubleToString(-m_bias[0], 12, 4));
-        }
-
-        return buff.toString();
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return null;
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return false;
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/functions/SPegasos.java b/moa/src/main/java/moa/classifiers/functions/SPegasos.java
deleted file mode 100644
index 53346da64..000000000
--- a/moa/src/main/java/moa/classifiers/functions/SPegasos.java
+++ /dev/null
@@ -1,357 +0,0 @@
-/*
- *    SPegasos.java
- *    Copyright (C) 2009 University of Waikato, Hamilton, New Zealand
- *    @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-
-/*
- *    SPegasos.java
- *    Copyright (C) 2009 University of Waikato, Hamilton, New Zealand
- *
- */
-package moa.classifiers.functions;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractClassifier;
-import moa.core.Measurement;
-import moa.core.StringUtils;
-import moa.core.Utils;
-import moa.learners.Classifier;
-
-/**
- * <!-- globalinfo-start --> Implements the stochastic variant of the Pegasos
- * (Primal Estimated sub-GrAdient SOlver for SVM) method of Shalev-Shwartz et
- * al. (2007). For more information, see<br/> <br/> S. Shalev-Shwartz, Y.
- * Singer, N. Srebro: Pegasos: Primal Estimated sub-GrAdient SOlver for SVM. In:
- * 24th International Conference on MachineLearning, 807-814, 2007.
- * <p/>
- * <!-- globalinfo-end -->
- * * 
-<!-- technical-bibtex-start --> BibTeX:
- * <pre>
- * &#64;inproceedings{Shalev-Shwartz2007,
- *    author = {S. Shalev-Shwartz and Y. Singer and N. Srebro},
- *    booktitle = {24th International Conference on MachineLearning},
- *    pages = {807-814},
- *    title = {Pegasos: Primal Estimated sub-GrAdient SOlver for SVM},
- *    year = {2007}
- * }
- * </pre>
- * <p/>
- * <!-- technical-bibtex-end -->
- *
- */
-public class SPegasos extends AbstractClassifier implements Classifier {
-
-    /**
-     * For serialization
-     */
-    private static final long serialVersionUID = -3732968666673530290L;
-
-    @Override
-    public String getPurposeString() {
-        return "Stochastic variant of the Pegasos (Primal Estimated sub-GrAdient SOlver for SVM) method of Shalev-Shwartz et al. (2007).";
-    }
-
-    /**
-     * The regularization parameter
-     */
-    protected double m_lambda = 0.0001;
-
-    public FloatOption lambdaRegularizationOption = new FloatOption("lambdaRegularization",
-            'l', "Lambda regularization parameter .",
-            0.0001, 0.00, Integer.MAX_VALUE);
-
-    protected static final int HINGE = 0;
-
-    protected static final int LOGLOSS = 1;
-
-    /**
-     * The current loss function to minimize
-     */
-    protected int m_loss = HINGE;
-
-    public MultiChoiceOption lossFunctionOption = new MultiChoiceOption(
-            "lossFunction", 'o', "The loss function to use.", new String[]{
-                "HINGE", "LOGLOSS"}, new String[]{
-                "Hinge loss (SVM)",
-                "Log loss (logistic regression)"}, 0);
-
-    /**
-     * Stores the weights (+ bias in the last element)
-     */
-    protected double[] m_weights;
-
-    /**
-     * Holds the current iteration number
-     */
-    protected double m_t;
-
-    /**
-     * Set the value of lambda to use
-     *
-     * @param lambda the value of lambda to use
-     */
-    public void setLambda(double lambda) {
-        m_lambda = lambda;
-    }
-
-    /**
-     * Get the current value of lambda
-     *
-     * @return the current value of lambda
-     */
-    public double getLambda() {
-        return m_lambda;
-    }
-
-    /**
-     * Set the loss function to use.
-     *
-     * @param function the loss function to use.
-     */
-    public void setLossFunction(int function) {
-        m_loss = function;
-    }
-
-    /**
-     * Get the current loss function.
-     *
-     * @return the current loss function.
-     */
-    public int getLossFunction() {
-        return m_loss;
-    }
-
-    /**
-     * Reset the classifier.
-     */
-    public void reset() {
-        m_t = 2;
-        m_weights = null;
-    }
-
-    protected static double dotProd(Instance inst1, double[] weights, int classIndex) {
-        double result = 0;
-
-        int n1 = inst1.numValues();
-        int n2 = weights.length - 1;
-
-        for (int p1 = 0, p2 = 0; p1 < n1 && p2 < n2;) {
-            int ind1 = inst1.index(p1);
-            int ind2 = p2;
-            if (ind1 == ind2) {
-                if (ind1 != classIndex && !inst1.isMissingSparse(p1)) {
-                    result += inst1.valueSparse(p1) * weights[p2];
-                }
-                p1++;
-                p2++;
-            } else if (ind1 > ind2) {
-                p2++;
-            } else {
-                p1++;
-            }
-        }
-        return (result);
-    }
-
-    protected double dloss(double z) {
-        if (m_loss == HINGE) {
-            return (z < 1) ? 1 : 0;
-        }
-
-        // log loss
-        if (z < 0) {
-            return 1.0 / (Math.exp(z) + 1.0);
-        } else {
-            double t = Math.exp(-z);
-            return t / (t + 1);
-        }
-    }
-
-    @Override
-    public void resetLearningImpl() {
-        reset();
-        setLambda(this.lambdaRegularizationOption.getValue());
-        setLossFunction(this.lossFunctionOption.getChosenIndex());
-    }
-
-    /**
-     * Trains the classifier with the given instance.
-     *
-     * @param instance the new training instance to include in the model
-     */
-    @Override
-    public void trainOnInstanceImpl(Instance instance) {
-
-        if (m_weights == null) {
-            m_weights = new double[instance.numAttributes() + 1];
-        }
-        if (!instance.classIsMissing()) {
-
-            double learningRate = 1.0 / (m_lambda * m_t);
-            //double scale = 1.0 - learningRate * m_lambda;
-            double scale = 1.0 - 1.0 / m_t;
-            double y = (instance.classValue() == 0) ? -1 : 1;
-            double wx = dotProd(instance, m_weights, instance.classIndex());
-            double z = y * (wx + m_weights[m_weights.length - 1]);
-
-            for (int j = 0; j < m_weights.length - 1; j++) {
-                if (j != instance.classIndex()) {
-                    m_weights[j] *= scale;
-                }
-            }
-
-            if (m_loss == LOGLOSS || (z < 1)) {
-                double loss = dloss(z);
-                int n1 = instance.numValues();
-                for (int p1 = 0; p1 < n1; p1++) {
-                    int indS = instance.index(p1);
-                    if (indS != instance.classIndex() && !instance.isMissingSparse(p1)) {
-                        double m = learningRate * loss * (instance.valueSparse(p1) * y);
-                        m_weights[indS] += m;
-                    }
-                }
-
-                // update the bias
-                m_weights[m_weights.length - 1] += learningRate * loss * y;
-            }
-
-            double norm = 0;
-            for (int k = 0; k < m_weights.length - 1; k++) {
-                if (k != instance.classIndex()) {
-                    norm += (m_weights[k] * m_weights[k]);
-                }
-            }
-
-            double scale2 = Math.min(1.0, (1.0 / (m_lambda * norm)));
-            if (scale2 < 1.0) {
-                scale2 = Math.sqrt(scale2);
-                for (int j = 0; j < m_weights.length - 1; j++) {
-                    if (j != instance.classIndex()) {
-                        m_weights[j] *= scale2;
-                    }
-                }
-            }
-            m_t++;
-        }
-    }
-
-    /**
-     * Calculates the class membership probabilities for the given test
-     * instance.
-     *
-     * @param instance the instance to be classified
-     * @return predicted class probability distribution
-     */
-    @Override
-    public Prediction getPredictionForInstance(Instance inst) {
-
-        if (m_weights == null) {
-            return new ClassificationPrediction();
-        }
-
-        double[] result = new double[2];
-
-        double wx = dotProd(inst, m_weights, inst.classIndex());// * m_wScale;
-        double z = (wx + m_weights[m_weights.length - 1]);
-        //System.out.print("" + z + ": ");
-        // System.out.println(1.0 / (1.0 + Math.exp(-z)));
-        if (z <= 0) {
-            //  z = 0;
-            if (m_loss == LOGLOSS) {
-                result[0] = 1.0 / (1.0 + Math.exp(z));
-                result[1] = 1.0 - result[0];
-            } else {
-                result[0] = 1;
-            }
-        } else {
-            if (m_loss == LOGLOSS) {
-                result[1] = 1.0 / (1.0 + Math.exp(-z));
-                result[0] = 1.0 - result[1];
-            } else {
-                result[1] = 1;
-            }
-        }
-        return new ClassificationPrediction(result);
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder result, int indent) {
-        StringUtils.appendIndented(result, indent, toString());
-        StringUtils.appendNewline(result);
-    }
-
-    /**
-     * Prints out the classifier.
-     *
-     * @return a description of the classifier as a string
-     */
-    @Override
-    public String toString() {
-        if (m_weights == null) {
-            return "SPegasos: No model built yet.\n";
-        }
-        StringBuffer buff = new StringBuffer();
-        buff.append("Loss function: ");
-        if (m_loss == HINGE) {
-            buff.append("Hinge loss (SVM)\n\n");
-        } else {
-            buff.append("Log loss (logistic regression)\n\n");
-        }
-        int printed = 0;
-
-        for (int i = 0; i < m_weights.length - 1; i++) {
-            //   if (i != m_data.classIndex()) {
-            if (printed > 0) {
-                buff.append(" + ");
-            } else {
-                buff.append("   ");
-            }
-
-            buff.append(Utils.doubleToString(m_weights[i], 12, 4) + " "
-                    //+ m_data.attribute(i).name()
-                    + "\n");
-
-            printed++;
-        }
-        //}
-
-        if (m_weights[m_weights.length - 1] > 0) {
-            buff.append(" + " + Utils.doubleToString(m_weights[m_weights.length - 1], 12, 4));
-        } else {
-            buff.append(" - " + Utils.doubleToString(-m_weights[m_weights.length - 1], 12, 4));
-        }
-
-        return buff.toString();
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return null;
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return false;
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/lazy/kNN.java b/moa/src/main/java/moa/classifiers/lazy/kNN.java
deleted file mode 100644
index dd7f53d0e..000000000
--- a/moa/src/main/java/moa/classifiers/lazy/kNN.java
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
- *    kNN.java
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.lazy;
-
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.lazy.neighboursearch.KDTree;
-import moa.classifiers.lazy.neighboursearch.LinearNNSearch;
-import moa.classifiers.lazy.neighboursearch.NearestNeighbourSearch;
-import moa.core.Measurement;
-import moa.learners.Classifier;
-
-/**
- * k Nearest Neighbor.<p>
- *
- * Valid options are:<p>
- *
- * -k number of neighbours <br> -m max instances <br> 
- *
- * @author Jesse Read (jesse@tsc.uc3m.es)
- * @version 03.2012
- */
-public class kNN extends AbstractClassifier implements Classifier {
-
-    private static final long serialVersionUID = 1L;
-
-	public IntOption kOption = new IntOption( "k", 'k', "The number of neighbors", 10, 1, Integer.MAX_VALUE);
-
-	public IntOption limitOption = new IntOption( "limit", 'w', "The maximum number of instances to store", 1000, 1, Integer.MAX_VALUE);
-
-        public MultiChoiceOption nearestNeighbourSearchOption = new MultiChoiceOption(
-            "nearestNeighbourSearch", 'n', "Nearest Neighbour Search to use", new String[]{
-                "LinearNN", "KDTree"},
-            new String[]{"Brute force search algorithm for nearest neighbour search. ",
-                "KDTree search algorithm for nearest neighbour search"
-            }, 0);
-
-
-	int C = 0;
-
-    @Override
-    public String getPurposeString() {
-        return "kNN: special.";
-    }
-
-    protected InstancesHeader window; 
-
-	@Override
-	public void setModelContext(InstancesHeader context) {
-		try {
-			this.window = new InstancesHeader(context,0); //new StringReader(context.toString())
-			this.window.setClassIndex(context.classIndex());
-		} catch(Exception e) {
-			System.err.println("Error: no Model Context available.");
-			e.printStackTrace();
-			System.exit(1);
-		}
-	}
-
-    @Override
-    public void resetLearningImpl() {
-		this.window = null;
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-		if (inst.classValue() > C)
-			C = (int)inst.classValue();
-		if (this.window == null) {
-			this.window = inst.dataset().getEmptyHeader();
-		}
-		if (this.limitOption.getValue() <= this.window.numInstances()) {
-			this.window.delete(0);
-		}
-		this.window.add(inst);
-    }
-
-	@Override
-    public Prediction getPredictionForInstance(Instance inst) {
-		double v[] = new double[C+1];
-		try {
-			NearestNeighbourSearch search;
-			if (this.nearestNeighbourSearchOption.getChosenIndex()== 0) {
-				search = new LinearNNSearch(this.window);  
-			} else {
-				search = new KDTree();
-				search.setInstances(this.window);
-			}	
-			if (this.window.numInstances()>0) {	
-				InstancesHeader neighbours = search.kNearestNeighbours(inst,Math.min(kOption.getValue(),this.window.numInstances()));
-				for(int i = 0; i < neighbours.numInstances(); i++) {
-					v[(int)neighbours.instance(i).classValue()]++;
-				}
-			}
-		} catch(Exception e) {
-			//System.err.println("Error: kNN search failed.");
-			//e.printStackTrace();
-			//System.exit(1);
-			return new ClassificationPrediction();
-		}
-		return new ClassificationPrediction(v);
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return null;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-    }
-
-    public boolean isRandomizable() {
-        return false;
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/lazy/kNNwithPAW.java b/moa/src/main/java/moa/classifiers/lazy/kNNwithPAW.java
deleted file mode 100644
index 9ab20ec73..000000000
--- a/moa/src/main/java/moa/classifiers/lazy/kNNwithPAW.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- *    kNNwithPAW.java
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.lazy;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
-/**
- * k Nearest Neighbor ADAPTIVE with PAW.<p>
- *
- * Valid options are:
- * <p>
- *
- * -k number of neighbours <br>
- *
- * @author Jesse Read (jesse@tsc.uc3m.es)
- * @version 03.2012
- */
-public class kNNwithPAW extends kNN {
-
-    private static final long serialVersionUID = 1L;
-
-    protected int marker = 0;
-
-    @Override
-    public String getPurposeString() {
-        return "kNN+PAW: kNN with Probabilistic Approximate Window";
-    }
-
-    protected double prob;
-
-    @Override
-    public void resetLearningImpl() {
-        this.window = null;
-        this.prob = Math.pow(2.0, -1.0 / this.limitOption.getValue());
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        if (inst.classValue() > C) {
-            C = (int) inst.classValue();
-        }
-        if (this.window == null) {
-            this.window = inst.dataset().getEmptyHeader();
-        }
-
-        for (int i = 0; i < this.window.size(); i++) {
-            if (this.classifierRandom.nextDouble() > this.prob) {
-                this.window.delete(i);
-            }
-        }
-        this.window.add(inst);
-
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return true;
-    }
-
-}
diff --git a/moa/src/main/java/moa/classifiers/lazy/kNNwithPAWandADWIN.java b/moa/src/main/java/moa/classifiers/lazy/kNNwithPAWandADWIN.java
deleted file mode 100644
index dc7b35417..000000000
--- a/moa/src/main/java/moa/classifiers/lazy/kNNwithPAWandADWIN.java
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
- *    kNNAdaptive.java
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.lazy;
-
-import java.util.ArrayList;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
-import moa.classifiers.core.driftdetection.ADWIN;
-import moa.learners.Classifier;
-
-/**
- * k Nearest Neighbor ADAPTIVE with ADWIN+PAW.<p>
- *
- * Valid options are:
- * <p>
- *
- * -k number of neighbours <br>
- *
- * @author Jesse Read (jesse@tsc.uc3m.es)
- * @version 03.2012
- */
-public class kNNwithPAWandADWIN extends kNN implements Classifier {
-
-    private static final long serialVersionUID = 1L;
-
-    private ADWIN adwin;
-
-    protected int marker = 0;
-
-    protected ArrayList<Integer> timeStamp;
-
-    @Override
-    public String getPurposeString() {
-        return "kNNwithPAWandADWIN: kNN with Probabilistic Approximate Window and ADWIN";
-    }
-
-    protected double prob;
-
-    @Override
-    public void resetLearningImpl() {
-        this.window = null;
-        this.adwin = new ADWIN();
-        this.prob = Math.pow(2.0, -1.0 / this.limitOption.getValue());
-        this.time = 0;
-    }
-
-    protected int time;
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        if (inst.classValue() > C) {
-            C = (int) inst.classValue();
-        }
-        // ADWIN
-        if (this.window == null) {
-            this.window = inst.dataset().getEmptyHeader();
-        }
-
-        if (this.timeStamp == null) {
-            this.timeStamp = new ArrayList<Integer>(10);
-        }
-        for (int i = 0; i < this.window.size(); i++) {
-            if (this.classifierRandom.nextDouble() > this.prob) {
-                this.window.delete(i);
-                this.timeStamp.remove(i);
-            }
-        }
-        this.window.add(inst);
-        this.timeStamp.add(this.time);
-        this.time++;
-        boolean correctlyClassifies = this.correctlyClassifies(inst);
-        if (this.adwin.setInput(correctlyClassifies ? 0 : 1)) {
-            //Change
-            int size = (int) this.adwin.getWidth();
-            for (int i = 0; i < this.window.size(); i++) {
-                if (this.timeStamp.get(i) < this.time - size) {
-                    this.window.delete(i);
-                    this.timeStamp.remove(i);
-                }
-            }
-        }
-
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return true;
-    }
-
-}
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/DistanceFunction.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/DistanceFunction.java
deleted file mode 100644
index ef0723941..000000000
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/DistanceFunction.java
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/*
- *    DistanceFunction.java
- *    Copyright (C) 1999-2012 University of Waikato, Hamilton, New Zealand
- *
- */
-
-package moa.classifiers.lazy.neighboursearch;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
-/**
- * Interface for any class that can compute and return distances between two
- * instances.
- *
- * @author  Ashraf M. Kibriya (amk14@cs.waikato.ac.nz)
- * @version $Revision: 8034 $ 
- */
-public interface DistanceFunction  {
-
-  /**
-   * Sets the instances.
-   * 
-   * @param insts 	the instances to use
-   */
-  public void setInstances(InstancesHeader insts);
-
-  /**
-   * returns the instances currently set.
-   * 
-   * @return 		the current instances
-   */
-  public InstancesHeader getInstances();
-
-  /**
-   * Sets the range of attributes to use in the calculation of the distance.
-   * The indices start from 1, 'first' and 'last' are valid as well. 
-   * E.g.: first-3,5,6-last
-   * 
-   * @param value	the new attribute index range
-   */
-  public void setAttributeIndices(String value);
-  
-  /**
-   * Gets the range of attributes used in the calculation of the distance.
-   * 
-   * @return		the attribute index range
-   */
-  public String getAttributeIndices();
-  
-  /**
-   * Sets whether the matching sense of attribute indices is inverted or not.
-   * 
-   * @param value	if true the matching sense is inverted
-   */
-  public void setInvertSelection(boolean value);
-  
-  /**
-   * Gets whether the matching sense of attribute indices is inverted or not.
-   * 
-   * @return		true if the matching sense is inverted
-   */
-  public boolean getInvertSelection();
-
-  /**
-   * Calculates the distance between two instances.
-   * 
-   * @param first 	the first instance
-   * @param second 	the second instance
-   * @return 		the distance between the two given instances
-   */
-  public double distance(Instance first, Instance second);
-
-
-  /**
-   * Calculates the distance between two instances. Offers speed up (if the 
-   * distance function class in use supports it) in nearest neighbour search by 
-   * taking into account the cutOff or maximum distance. Depending on the 
-   * distance function class, post processing of the distances by 
-   * postProcessDistances(double []) may be required if this function is used.
-   *
-   * @param first 	the first instance
-   * @param second 	the second instance
-   * @param cutOffValue If the distance being calculated becomes larger than 
-   *                    cutOffValue then the rest of the calculation is 
-   *                    discarded.
-   * @return 		the distance between the two given instances or 
-   * 			Double.POSITIVE_INFINITY if the distance being 
-   * 			calculated becomes larger than cutOffValue. 
-   */
-  public double distance(Instance first, Instance second, double cutOffValue);
-
-
-  /**
-   * Does post processing of the distances (if necessary) returned by
-   * distance(distance(Instance first, Instance second, double cutOffValue). It
-   * may be necessary, depending on the distance function, to do post processing
-   * to set the distances on the correct scale. Some distance function classes
-   * may not return correct distances using the cutOffValue distance function to 
-   * minimize the inaccuracies resulting from floating point comparison and 
-   * manipulation.
-   * 
-   * @param distances	the distances to post-process
-   */
-  public void postProcessDistances(double distances[]);
-
-  /**
-   * Update the distance function (if necessary) for the newly added instance.
-   * 
-   * @param ins		the instance to add
-   */
-  public void update(Instance ins);
-
-}
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/EuclideanDistance.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/EuclideanDistance.java
deleted file mode 100644
index ac9743bbc..000000000
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/EuclideanDistance.java
+++ /dev/null
@@ -1,228 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/*
- *    EuclideanDistance.java
- *    Copyright (C) 1999-2012 University of Waikato, Hamilton, New Zealand
- *
- */
-
-package moa.classifiers.lazy.neighboursearch;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
-/**
- <!-- globalinfo-start -->
- * Implementing Euclidean distance (or similarity) function.<br/>
- * <br/>
- * One object defines not one distance but the data model in which the distances between objects of that data model can be computed.<br/>
- * <br/>
- * Attention: For efficiency reasons the use of consistency checks (like are the data models of the two instances exactly the same), is low.<br/>
- * <br/>
- * For more information, see:<br/>
- * <br/>
- * Wikipedia. Euclidean distance. URL http://en.wikipedia.org/wiki/Euclidean_distance.
- * <p/>
- <!-- globalinfo-end -->
- *
- <!-- technical-bibtex-start -->
- * BibTeX:
- * <pre>
- * &#64;misc{missing_id,
- *    author = {Wikipedia},
- *    title = {Euclidean distance},
- *    URL = {http://en.wikipedia.org/wiki/Euclidean_distance}
- * }
- * </pre>
- * <p/>
- <!-- technical-bibtex-end -->
- *
- <!-- options-start -->
- * Valid options are: <p/>
- * 
- * <pre> -D
- *  Turns off the normalization of attribute 
- *  values in distance calculation.</pre>
- * 
- * <pre> -R &lt;col1,col2-col4,...&gt;
- *  Specifies list of columns to used in the calculation of the 
- *  distance. 'first' and 'last' are valid indices.
- *  (default: first-last)</pre>
- * 
- * <pre> -V
- *  Invert matching sense of column indices.</pre>
- * 
- <!-- options-end --> 
- *
- * @author Gabi Schmidberger (gabi@cs.waikato.ac.nz)
- * @author Ashraf M. Kibriya (amk14@cs.waikato.ac.nz)
- * @author FracPete (fracpete at waikato dot ac dot nz)
- * @version $Revision: 8034 $
- */
-public class EuclideanDistance
-  extends NormalizableDistance
-  implements Cloneable{
-
-  /** for serialization. */
-  private static final long serialVersionUID = 1068606253458807903L;
-
-  /**
-   * Constructs an Euclidean Distance object, Instances must be still set.
-   */
-  public EuclideanDistance() {
-    super();
-  }
-
-  /**
-   * Constructs an Euclidean Distance object and automatically initializes the
-   * ranges.
-   * 
-   * @param data 	the instances the distance function should work on
-   */
-  public EuclideanDistance(InstancesHeader data) {
-    super(data);
-  }
-
-  /**
-   * Returns a string describing this object.
-   * 
-   * @return 		a description of the evaluator suitable for
-   * 			displaying in the explorer/experimenter gui
-   */
-  public String globalInfo() {
-    return 
-        "Implementing Euclidean distance (or similarity) function.\n\n"
-      + "One object defines not one distance but the data model in which "
-      + "the distances between objects of that data model can be computed.\n\n"
-      + "Attention: For efficiency reasons the use of consistency checks "
-      + "(like are the data models of the two instances exactly the same), "
-      + "is low.\n\n";
-  }
-
-  
-  /**
-   * Calculates the distance between two instances.
-   * 
-   * @param first 	the first instance
-   * @param second 	the second instance
-   * @return 		the distance between the two given instances
-   */
-  public double distance(Instance first, Instance second) {
-    return Math.sqrt(distance(first, second, Double.POSITIVE_INFINITY));
-  }
-  
- 
-  /**
-   * Updates the current distance calculated so far with the new difference
-   * between two attributes. The difference between the attributes was 
-   * calculated with the difference(int,double,double) method.
-   * 
-   * @param currDist	the current distance calculated so far
-   * @param diff	the difference between two new attributes
-   * @return		the update distance
-   * @see		#difference(int, double, double)
-   */
-  protected double updateDistance(double currDist, double diff) {
-    double	result;
-    
-    result  = currDist;
-    result += diff * diff;
-    
-    return result;
-  }
-  
-  /**
-   * Does post processing of the distances (if necessary) returned by
-   * distance(distance(Instance first, Instance second, double cutOffValue). It
-   * is necessary to do so to get the correct distances if
-   * distance(distance(Instance first, Instance second, double cutOffValue) is
-   * used. This is because that function actually returns the squared distance
-   * to avoid inaccuracies arising from floating point comparison.
-   * 
-   * @param distances	the distances to post-process
-   */
-  public void postProcessDistances(double distances[]) {
-    for(int i = 0; i < distances.length; i++) {
-      distances[i] = Math.sqrt(distances[i]);
-    }
-  }
-  
-  /**
-   * Returns the squared difference of two values of an attribute.
-   * 
-   * @param index	the attribute index
-   * @param val1	the first value
-   * @param val2	the second value
-   * @return		the squared difference
-   */
-  public double sqDifference(int index, double val1, double val2) {
-    double val = difference(index, val1, val2);
-    return val*val;
-  }
-  
-  /**
-   * Returns value in the middle of the two parameter values.
-   * 
-   * @param ranges 	the ranges to this dimension
-   * @return 		the middle value
-   */
-  public double getMiddle(double[] ranges) {
-
-    double middle = ranges[R_MIN] + ranges[R_WIDTH] * 0.5;
-    return middle;
-  }
-  
-  /**
-   * Returns the index of the closest point to the current instance.
-   * Index is index in Instances object that is the second parameter.
-   *
-   * @param instance 	the instance to assign a cluster to
-   * @param allPoints 	all points
-   * @param pointList 	the list of points
-   * @return 		the index of the closest point
-   * @throws Exception	if something goes wrong
-   */
-  public int closestPoint(Instance instance, InstancesHeader allPoints,
-      			  int[] pointList) throws Exception {
-    double minDist = Integer.MAX_VALUE;
-    int bestPoint = 0;
-    for (int i = 0; i < pointList.length; i++) {
-      double dist = distance(instance, allPoints.instance(pointList[i]), Double.POSITIVE_INFINITY);
-      if (dist < minDist) {
-        minDist = dist;
-        bestPoint = i;
-      }
-    }
-    return pointList[bestPoint];
-  }
-  
-  /**
-   * Returns true if the value of the given dimension is smaller or equal the
-   * value to be compared with.
-   * 
-   * @param instance 	the instance where the value should be taken of
-   * @param dim 	the dimension of the value
-   * @param value 	the value to compare with
-   * @return 		true if value of instance is smaller or equal value
-   */
-  public boolean valueIsSmallerEqual(Instance instance, int dim,
-      				     double value) {  //This stays
-    return instance.value(dim) <= value;
-  }
-  
-
-    
-}
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/KDTree.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/KDTree.java
deleted file mode 100644
index 684f063d8..000000000
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/KDTree.java
+++ /dev/null
@@ -1,1129 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/*
- *    KDTree.java
- *    Copyright (C) 2000-2012 University of Waikato
- *    
- */
-
-package moa.classifiers.lazy.neighboursearch;
-
-import java.util.Enumeration;
-import java.util.Vector;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
-import moa.classifiers.lazy.neighboursearch.kdtrees.KDTreeNode;
-import moa.classifiers.lazy.neighboursearch.kdtrees.KDTreeNodeSplitter;
-import moa.classifiers.lazy.neighboursearch.kdtrees.SlidingMidPointOfWidestSide;
-
-
-
-
-/**
- <!-- globalinfo-start -->
- * Class implementing the KDTree search algorithm for nearest neighbour search.<br/>
- * The connection to dataset is only a reference. For the tree structure the indexes are stored in an array. <br/>
- * Building the tree:<br/>
- * If a node has &lt;maximal-inst-number&gt; (option -L) instances no further splitting is done. Also if the split would leave one side empty, the branch is not split any further even if the instances in the resulting node are more than &lt;maximal-inst-number&gt; instances.<br/>
- * **PLEASE NOTE:** The algorithm can not handle missing values, so it is advisable to run ReplaceMissingValues filter if there are any missing values in the dataset.<br/>
- * <br/>
- * For more information see:<br/>
- * <br/>
- * Jerome H. Friedman, Jon Luis Bentley, Raphael Ari Finkel (1977). An Algorithm for Finding Best Matches in Logarithmic Expected Time. ACM Transactions on Mathematics Software. 3(3):209-226.<br/>
- * <br/>
- * Andrew Moore (1991). A tutorial on kd-trees.
- * <p/>
- <!-- globalinfo-end -->
- * 
- <!-- technical-bibtex-start -->
- * BibTeX:
- * <pre>
- * &#64;article{Friedman1977,
- *    author = {Jerome H. Friedman and Jon Luis Bentley and Raphael Ari Finkel},
- *    journal = {ACM Transactions on Mathematics Software},
- *    month = {September},
- *    number = {3},
- *    pages = {209-226},
- *    title = {An Algorithm for Finding Best Matches in Logarithmic Expected Time},
- *    volume = {3},
- *    year = {1977}
- * }
- * 
- * &#64;techreport{Moore1991,
- *    author = {Andrew Moore},
- *    booktitle = {University of Cambridge Computer Laboratory Technical Report No. 209},
- *    howpublished = {Extract from PhD Thesis},
- *    title = {A tutorial on kd-trees},
- *    year = {1991},
- *    HTTP = {Available from http://www.autonlab.org/autonweb/14665.html}
- * }
- * </pre>
- * <p/>
- <!-- technical-bibtex-end -->
- * 
- <!-- options-start -->
- * Valid options are: <p/>
- * 
- * <pre> -S &lt;classname and options&gt;
- *  Node splitting method to use.
- *  (default: weka.core.neighboursearch.kdtrees.SlidingMidPointOfWidestSide)</pre>
- * 
- * <pre> -W &lt;value&gt;
- *  Set minimal width of a box
- *  (default: 1.0E-2).</pre>
- * 
- * <pre> -L
- *  Maximal number of instances in a leaf
- *  (default: 40).</pre>
- * 
- * <pre> -N
- *  Normalizing will be done
- *  (Select dimension for split, with normalising to universe).</pre>
- * 
- <!-- options-end --> 
- * 
- * @author Gabi Schmidberger (gabi[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
- * @author Malcolm Ware (mfw4[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
- * @author Ashraf M. Kibriya (amk14[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
- * @version $Revision: 8034 $
- */
-public class KDTree
-  extends NearestNeighbourSearch {
-
-  /** For serialization. */
-  private static final long serialVersionUID = 1505717283763272533L;
-
-  /**
-   * Array holding the distances of the nearest neighbours. It is filled up both
-   * by nearestNeighbour() and kNearestNeighbours().
-   */
-  protected double[] m_DistanceList;
-
-  /**
-   * Indexlist of the instances of this kdtree. Instances get sorted according
-   * to the splits. the nodes of the KDTree just hold their start and end
-   * indices
-   */
-  protected int[] m_InstList;
-
-  /** The root node of the tree. */
-  protected KDTreeNode m_Root;
-
-  /** The node splitter. */
-  protected KDTreeNodeSplitter m_Splitter = new SlidingMidPointOfWidestSide();
-
-  /** Tree stats. */
-  protected int m_NumNodes, m_NumLeaves, m_MaxDepth;
-
-  // Constants
-  /** The index of MIN value in attributes' range array. */
-  public static final int MIN = EuclideanDistance.R_MIN;
-  
-  /** The index of MAX value in attributes' range array. */
-  public static final int MAX = EuclideanDistance.R_MAX; 
-  
-  /** The index of WIDTH (MAX-MIN) value in attributes' range array. */
-  public static final int WIDTH = EuclideanDistance.R_WIDTH;
-
-  /**
-   * Creates a new instance of KDTree.
-   */
-  public KDTree() {
-    super();
-  }
-
-  /**
-   * Creates a new instance of KDTree. 
-   * It also builds the tree on supplied set of Instances.
-   * @param insts The instances/points on which the BallTree 
-   * should be built on.
-   */
-  public KDTree(InstancesHeader insts) {
-    super(insts);
-  }
-
-  /**
-   * Builds the KDTree on the supplied set of instances/points. It 
-   * is adviseable to run the replace missing attributes filter 
-   * on the passed instances first.
-   * NOTE: This method should not be called from outside this 
-   * class. Outside classes should call setInstances(Instances)
-   * instead.
-   * 
-   * @param instances	The instances to build the tree on
-   * @throws Exception	if something goes wrong
-   */
-  protected void buildKDTree(InstancesHeader instances) throws Exception {
-
-    checkMissing(instances);
-    if (m_EuclideanDistance == null)
-      m_DistanceFunction = m_EuclideanDistance = new EuclideanDistance(
-          instances);
-    else
-      m_EuclideanDistance.setInstances(instances);
-
-    m_Instances = instances;
-    int numInst = m_Instances.numInstances();
-
-    // Make the global index list
-    m_InstList = new int[numInst];
-
-    for (int i = 0; i < numInst; i++) {
-      m_InstList[i] = i;
-    }
-
-    double[][] universe = m_EuclideanDistance.getRanges();
-
-    // initializing internal fields of KDTreeSplitter
-    m_Splitter.setInstances(m_Instances);
-    m_Splitter.setInstanceList(m_InstList);
-    m_Splitter.setEuclideanDistanceFunction(m_EuclideanDistance);
-    m_Splitter.setNodeWidthNormalization(m_NormalizeNodeWidth);
-
-    // building tree
-    m_NumNodes = m_NumLeaves = 1;
-    m_MaxDepth = 0;
-    m_Root = new KDTreeNode(m_NumNodes, 0, m_Instances.numInstances() - 1,
-        universe);
-
-    splitNodes(m_Root, universe, m_MaxDepth + 1);
-  }
-
-  /** 
-   * Recursively splits nodes of a tree starting from the supplied node.
-   * The splitting stops for any node for which the number of instances/points
-   * falls below a given threshold (given by m_MaxInstInLeaf), or if the 
-   * maximum relative width/range of the instances/points 
-   * (i.e. max_i(max(att_i) - min(att_i)) ) falls below a given threshold 
-   * (given by m_MinBoxRelWidth). 
-   * 
-   * @param node The node to start splitting from.
-   * @param universe The attribute ranges of the whole dataset.
-   * @param depth The depth of the supplied node.  
-   * @throws Exception If there is some problem 
-   * splitting.
-   */
-  protected void splitNodes(KDTreeNode node, double[][] universe,
-      int depth) throws Exception {
-    double[][] nodeRanges = m_EuclideanDistance.initializeRanges(m_InstList,
-                                                 node.m_Start, node.m_End);
-    if (node.numInstances() <= m_MaxInstInLeaf
-        || getMaxRelativeNodeWidth(nodeRanges, universe) <= m_MinBoxRelWidth)
-      return;
-
-    // splitting a node so it is no longer a leaf
-    m_NumLeaves--;
-
-    if (depth > m_MaxDepth)
-      m_MaxDepth = depth;
-
-    m_Splitter.splitNode(node, m_NumNodes, nodeRanges, universe);
-    m_NumNodes += 2;
-    m_NumLeaves += 2;
-
-    splitNodes(node.m_Left, universe, depth + 1);
-    splitNodes(node.m_Right, universe, depth + 1);
-  }
-
-  /**
-   * Returns (in the supplied heap object) the k nearest 
-   * neighbours of the given instance starting from the give 
-   * tree node. &gt;k neighbours are returned if there are more than 
-   * one neighbours at the kth boundary. NOTE: This method should 
-   * not be used from outside this class. Outside classes should 
-   * call kNearestNeighbours(Instance, int).
-   * 
-   * @param target  The instance to find the nearest neighbours for.
-   * @param node The KDTreeNode to start the search from.
-   * @param k    The number of neighbours to find.
-   * @param heap The MyHeap object to store/update the kNNs found
-   * during the search.
-   * @param distanceToParents The distance of the supplied target 
-   * to the parents of the supplied tree node. 
-   * @throws Exception  if the nearest neighbour could not be found.
-   */
-  protected void findNearestNeighbours(Instance target, KDTreeNode node, int k,
-      MyHeap heap, double distanceToParents) throws Exception {
-    if (node.isALeaf()) {
-      double distance;
-      // look at all the instances in this leaf
-      for (int idx = node.m_Start; idx <= node.m_End; idx++) {
-        if (target == m_Instances.instance(m_InstList[idx])) // for
-                                                              // hold-one-out
-                                                              // cross-validation
-          continue;
-        if (heap.size() < k) {
-          distance = m_EuclideanDistance.distance(target, m_Instances
-              .instance(m_InstList[idx]), Double.POSITIVE_INFINITY);
-          heap.put(m_InstList[idx], distance);
-        } else {
-          MyHeapElement temp = heap.peek();
-          distance = m_EuclideanDistance.distance(target, m_Instances
-              .instance(m_InstList[idx]), temp.distance);
-          if (distance < temp.distance) {
-            heap.putBySubstitute(m_InstList[idx], distance);
-          } else if (distance == temp.distance) {
-            heap.putKthNearest(m_InstList[idx], distance);
-          }
-        }// end else heap.size==k
-      }// end for
-
-    } else {
-      KDTreeNode nearer, further;
-      boolean targetInLeft = m_EuclideanDistance.valueIsSmallerEqual(target,
-          node.m_SplitDim, node.m_SplitValue);
-
-      if (targetInLeft) {
-        nearer = node.m_Left;
-        further = node.m_Right;
-      } else {
-        nearer = node.m_Right;
-        further = node.m_Left;
-      }
-      findNearestNeighbours(target, nearer, k, heap, distanceToParents);
-
-      // ... now look in further half if maxDist reaches into it
-      if (heap.size() < k) { // if haven't found the first k
-        double distanceToSplitPlane = distanceToParents
-            + m_EuclideanDistance.sqDifference(node.m_SplitDim, target
-                .value(node.m_SplitDim), node.m_SplitValue);
-        findNearestNeighbours(target, further, k, heap, distanceToSplitPlane);
-        return;
-      } else { // else see if ball centered at query intersects with the other
-                // side.
-        double distanceToSplitPlane = distanceToParents
-            + m_EuclideanDistance.sqDifference(node.m_SplitDim, target
-                .value(node.m_SplitDim), node.m_SplitValue);
-        if (heap.peek().distance >= distanceToSplitPlane) {
-          findNearestNeighbours(target, further, k, heap, distanceToSplitPlane);
-        }
-      }// end else
-    }// end else_if an internal node
-  }
-
-  /**
-   * Returns the k nearest neighbours of the supplied instance.
-   * &gt;k neighbours are returned if there are more than one 
-   * neighbours at the kth boundary. 
-   * 
-   * @param target	The instance to find the nearest neighbours for.
-   * @param k 		The number of neighbours to find.
-   * @return The k nearest neighbours (or &gt;k if more there are than
-   * one neighbours at the kth boundary). 
-   * @throws Exception 	if the nearest neighbour could not be found.
-   */
-  public InstancesHeader kNearestNeighbours(Instance target, int k) throws Exception {
-    checkMissing(target);
-    
-    MyHeap heap = new MyHeap(k);
-    findNearestNeighbours(target, m_Root, k, heap, 0.0);
-
-    InstancesHeader neighbours = new InstancesHeader(m_Instances, (heap.size() + heap
-        .noOfKthNearest()));
-    m_DistanceList = new double[heap.size() + heap.noOfKthNearest()];
-    int[] indices = new int[heap.size() + heap.noOfKthNearest()];
-    int i = indices.length - 1;
-    MyHeapElement h;
-    while (heap.noOfKthNearest() > 0) {
-      h = heap.getKthNearest();
-      indices[i] = h.index;
-      m_DistanceList[i] = h.distance;
-      i--;
-    }
-    while (heap.size() > 0) {
-      h = heap.get();
-      indices[i] = h.index;
-      m_DistanceList[i] = h.distance;
-      i--;
-    }
-    m_DistanceFunction.postProcessDistances(m_DistanceList);
-
-    for (int idx = 0; idx < indices.length; idx++) {
-      neighbours.add(m_Instances.instance(indices[idx]));
-    }
-
-    return neighbours;
-  }
-  
-
-  /**
-   * Returns the nearest neighbour of the supplied target 
-   * instance. 
-   *  
-   * @param target	The instance to find the nearest neighbour for.
-   * @return The nearest neighbour from among the previously 
-   * supplied training instances.
-   * @throws Exception 	if the neighbours could not be found.
-   */
-  public Instance nearestNeighbour(Instance target) throws Exception {
-    return (kNearestNeighbours(target, 1)).instance(0);
-  }
-  
-  /**
-   * Returns the distances to the kNearest or 1 nearest neighbour currently
-   * found with either the kNearestNeighbours or the nearestNeighbour method.
-   * 
-   * @return array containing the distances of the
-   *         nearestNeighbours. The length and ordering of the array 
-   *         is the same as that of the instances returned by 
-   *         nearestNeighbour functions.
-   * @throws Exception 	if called before calling kNearestNeighbours or
-   * 			nearestNeighbours.
-   */
-  public double[] getDistances() throws Exception {
-    if (m_Instances == null || m_DistanceList == null)
-      throw new Exception("The tree has not been supplied with a set of "
-          + "instances or getDistances() has been called "
-          + "before calling kNearestNeighbours().");
-    return m_DistanceList;
-  }
-  
-
-  /**
-   * Builds the KDTree on the given set of instances.
-   * @param instances The insts on which the KDTree is to be 
-   * built. 
-   * @throws Exception If some error occurs while 
-   * building the KDTree
-   */
-  public void setInstances(InstancesHeader instances) throws Exception {
-    super.setInstances(instances);
-    buildKDTree(instances);
-  }
-  
-
-  /**
-   * Adds one instance to the KDTree. This updates the KDTree structure to take
-   * into account the newly added training instance.
-   * 
-   * @param instance 	the instance to be added. Usually the newly added instance in the
-   *          		training set.
-   * @throws Exception If the instance cannot be added.
-   */
-  public void update(Instance instance) throws Exception { // better to change
-                                                            // to addInstance
-    if (m_Instances == null)
-      throw new Exception("No instances supplied yet. Have to call "
-          + "setInstances(instances) with a set of Instances " + "first.");
-
-    addInstanceInfo(instance);
-    addInstanceToTree(instance, m_Root);
-  }
-
-  /**
-   * Recursively adds an instance to the tree starting from
-   * the supplied KDTreeNode.
-   * NOTE: This should not be called by outside classes,
-   * outside classes should instead call update(Instance)
-   * method. 
-   *  
-   * @param inst The instance to add to the tree
-   * @param node The node to start the recursive search 
-   * from, for the leaf node where the supplied instance 
-   * would go.
-   * @throws Exception If some error occurs while adding
-   * the instance.
-   */
-  protected void addInstanceToTree(Instance inst, KDTreeNode node)
-      throws Exception {
-    if (node.isALeaf()) {
-      int instList[] = new int[m_Instances.numInstances()];
-      try {
-        System.arraycopy(m_InstList, 0, instList, 0, node.m_End + 1); // m_InstList.squeezeIn(m_End,
-                                                                      // index);
-        if (node.m_End < m_InstList.length - 1)
-          System.arraycopy(m_InstList, node.m_End + 1, instList,
-              node.m_End + 2, m_InstList.length - node.m_End - 1);
-        instList[node.m_End + 1] = m_Instances.numInstances() - 1;
-      } catch (ArrayIndexOutOfBoundsException ex) {
-        System.err.println("m_InstList.length: " + m_InstList.length
-            + " instList.length: " + instList.length + "node.m_End+1: "
-            + (node.m_End + 1) + "m_InstList.length-node.m_End+1: "
-            + (m_InstList.length - node.m_End - 1));
-        throw ex;
-      }
-      m_InstList = instList;
-
-      node.m_End++;
-      node.m_NodeRanges = m_EuclideanDistance.updateRanges(inst,
-          node.m_NodeRanges);
-
-      m_Splitter.setInstanceList(m_InstList);
-
-      // split this leaf node if necessary
-      double[][] universe = m_EuclideanDistance.getRanges();
-      if (node.numInstances() > m_MaxInstInLeaf
-          && getMaxRelativeNodeWidth(node.m_NodeRanges, universe) > m_MinBoxRelWidth) {
-        m_Splitter.splitNode(node, m_NumNodes, node.m_NodeRanges, universe);
-        m_NumNodes += 2;
-      }
-    }// end if node is a leaf
-    else {
-      if (m_EuclideanDistance.valueIsSmallerEqual(inst, node.m_SplitDim,
-          node.m_SplitValue)) {
-        addInstanceToTree(inst, node.m_Left);
-        afterAddInstance(node.m_Right);
-      } else
-        addInstanceToTree(inst, node.m_Right);
-
-      node.m_End++;
-      node.m_NodeRanges = m_EuclideanDistance.updateRanges(inst,
-          node.m_NodeRanges);
-    }
-  }
-
-  /**
-   * Corrects the start and end indices of a 
-   * KDTreeNode after an instance is added to
-   * the tree. The start and end indices for
-   * the master index array (m_InstList) 
-   * stored in the nodes need to be updated
-   * for all nodes in the subtree on the 
-   * right of a node where the instance 
-   * was added. 
-   * NOTE: No outside class should call this
-   * method.
-   * 
-   * @param node KDTreeNode whose start and end indices 
-   * need to be updated.
-   */
-  protected void afterAddInstance(KDTreeNode node) {
-    node.m_Start++;
-    node.m_End++;
-    if (!node.isALeaf()) {
-      afterAddInstance(node.m_Left);
-      afterAddInstance(node.m_Right);
-    }
-  }
-
-  /**
-   * Adds one instance to KDTree loosly. It only changes the ranges in
-   * EuclideanDistance, and does not affect the structure of the KDTree.
-   * 
-   * @param instance	the new instance. Usually this is the test instance 
-   * 			supplied to update the range of attributes in the distance function.
-   */
-  public void addInstanceInfo(Instance instance) {
-    m_EuclideanDistance.updateRanges(instance);
-  }
-
-  /**
-   * Checks if there is any instance with missing values. Throws an exception if
-   * there is, as KDTree does not handle missing values.
-   * 
-   * @param instances	the instances to check
-   * @throws Exception	if missing values are encountered
-   */
-  protected void checkMissing(InstancesHeader instances) throws Exception {
-    for (int i = 0; i < instances.numInstances(); i++) {
-      Instance ins = instances.instance(i);
-      for (int j = 0; j < ins.numValues(); j++) {
-        if (ins.index(j) != ins.classIndex())
-          if (ins.isMissingSparse(j)) {
-            throw new Exception("ERROR: KDTree can not deal with missing "
-                + "values. Please run ReplaceMissingValues filter "
-                + "on the dataset before passing it on to the KDTree.");
-          }
-      }
-    }
-  }
-
-  /**
-   * Checks if there is any missing value in the given 
-   * instance.
-   * @param ins The instance to check missing values in.
-   * @throws Exception If there is a missing value in the 
-   * instance.
-   */
-  protected void checkMissing(Instance ins) throws Exception {
-    for (int j = 0; j < ins.numValues(); j++) {
-      if (ins.index(j) != ins.classIndex())
-        if (ins.isMissingSparse(j)) {
-          throw new Exception("ERROR: KDTree can not deal with missing "
-              + "values. Please run ReplaceMissingValues filter "
-              + "on the dataset before passing it on to the KDTree.");
-        }
-    }
-  }
-  
-  /** 
-   * Returns the maximum attribute width of instances/points 
-   * in a KDTreeNode relative to the whole dataset. 
-   * 
-   * @param nodeRanges The attribute ranges of the 
-   * KDTreeNode whose maximum relative width is to be 
-   * determined.
-   * @param universe The attribute ranges of the whole
-   * dataset (training instances + test instances so 
-   * far encountered).
-   * @return The maximum relative width
-   */
-  protected double getMaxRelativeNodeWidth(double[][] nodeRanges,
-      double[][] universe) {
-    int widest = widestDim(nodeRanges, universe);
-    if(widest < 0)
-    	return 0.0;
-    else
-    	return nodeRanges[widest][WIDTH] / universe[widest][WIDTH];
-  }
-
-  /**
-   * Returns the widest dimension/attribute in a 
-   * KDTreeNode (widest after normalizing).
-   * @param nodeRanges The attribute ranges of 
-   * the KDTreeNode.
-   * @param universe The attribute ranges of the 
-   * whole dataset (training instances + test 
-   * instances so far encountered).
-   * @return The index of the widest 
-   * dimension/attribute.
-   */
-  protected int widestDim(double[][] nodeRanges, double[][] universe) {
-    final int classIdx = m_Instances.classIndex();
-    double widest = 0.0;
-    int w = -1;
-    if (m_NormalizeNodeWidth) {
-      for (int i = 0; i < nodeRanges.length; i++) {
-        double newWidest = nodeRanges[i][WIDTH] / universe[i][WIDTH];
-        if (newWidest > widest) {
-          if (i == classIdx)
-            continue;
-          widest = newWidest;
-          w = i;
-        }
-      }
-    } else {
-      for (int i = 0; i < nodeRanges.length; i++) {
-        if (nodeRanges[i][WIDTH] > widest) {
-          if (i == classIdx)
-            continue;
-          widest = nodeRanges[i][WIDTH];
-          w = i;
-        }
-      }
-    }
-    return w;
-  }
-
-  /**
-   * Returns the size of the tree.
-   * 
-   * @return 		the size of the tree
-   */
-  public double measureTreeSize() {
-    return m_NumNodes;
-  }
-
-  /**
-   * Returns the number of leaves.
-   * 
-   * @return 		the number of leaves
-   */
-  public double measureNumLeaves() {
-    return m_NumLeaves;
-  }
-
-  /**
-   * Returns the depth of the tree.
-   * 
-   * @return The depth of the tree
-   */
-  public double measureMaxDepth() {
-    return m_MaxDepth;
-  }
-
-  /**
-   * Returns an enumeration of the additional measure names.
-   * 
-   * @return 		an enumeration of the measure names
-   */
-  public Enumeration enumerateMeasures() {
-    Vector<String> newVector = new Vector<String>();
-    newVector.addElement("measureTreeSize");
-    newVector.addElement("measureNumLeaves");
-    newVector.addElement("measureMaxDepth");
-    return newVector.elements();
-  }
-
-  /**
-   * Returns the value of the named measure.
-   * 
-   * @param additionalMeasureName	the name of 
-   * the measure to query for its value.
-   * @return The value of the named measure
-   * @throws IllegalArgumentException	If the named measure 
-   * is not supported.
-   */
-  public double getMeasure(String additionalMeasureName) {
-    if (additionalMeasureName.compareToIgnoreCase("measureMaxDepth") == 0) {
-      return measureMaxDepth();
-    } else if (additionalMeasureName.compareToIgnoreCase("measureTreeSize") == 0) {
-      return measureTreeSize();
-    } else if (additionalMeasureName.compareToIgnoreCase("measureNumLeaves") == 0) {
-      return measureNumLeaves();
-    }  else {
-      throw new IllegalArgumentException(additionalMeasureName
-          + " not supported (KDTree)");
-    }
-  }
-
-  /**
-   * Sets whether to calculate the performance statistics or not.
-   * @param measurePerformance Should be true if performance 
-   * statistics are to be measured.
-   */
-  public void setMeasurePerformance(boolean measurePerformance) {
-    m_MeasurePerformance = measurePerformance;
-  }
-
-  /**
-   * Assigns instances to centers using KDTree.
-   * 
-   * @param centers	the current centers
-   * @param assignments	the centerindex for each instance
-   * @param pc		the threshold value for pruning.
-   * @throws Exception If there is some problem 
-   * assigning instances to centers.
-   */
-  public void centerInstances(InstancesHeader centers, int[] assignments, double pc)
-      throws Exception {
-
-    int[] centList = new int[centers.numInstances()];
-    for (int i = 0; i < centers.numInstances(); i++)
-      centList[i] = i;
-
-    determineAssignments(m_Root, centers, centList, assignments, pc);
-  }
-
-  /**
-   * Assigns instances to the current centers called candidates.
-   * 
-   * @param node The node to start assigning the instances from.
-   * @param centers	all the current centers.
-   * @param candidates	the current centers the method works on.
-   * @param assignments	the center index for each instance.
-   * @param pc the threshold value for pruning.
-   * @throws Exception If there is some problem assigning 
-   * instances to centers.
-   */
-  protected void determineAssignments(KDTreeNode node, InstancesHeader centers,
-      int[] candidates, int[] assignments, double pc) throws Exception {
-
-    // reduce number of owners for current hyper rectangle
-    int[] owners = refineOwners(node, centers, candidates);
-
-    // only one owner
-    if (owners.length == 1) {
-      // all instances of this node are owned by one center
-      for (int i = node.m_Start; i <= node.m_End; i++) {
-        assignments[m_InstList[i]] // the assignment of this instance
-        = owners[0]; // is the current owner
-      }
-    } else if (!node.isALeaf()) {
-      // more than one owner and it is not a leaf
-      determineAssignments(node.m_Left, centers, owners, assignments, pc);
-      determineAssignments(node.m_Right, centers, owners, assignments, pc);
-    } else {
-      // this is a leaf and there are more than 1 owner
-      // XMeans.
-      assignSubToCenters(node, centers, owners, assignments);
-    }
-  }
-
-  /**
-   * Refines the ownerlist.
-   * 
-   * @param node The current tree node.
-   * @param centers	all centers
-   * @param candidates	the indexes of those centers that are candidates.
-   * @return list of owners
-   * @throws Exception If some problem occurs in refining.
-   */
-  protected int[] refineOwners(KDTreeNode node, InstancesHeader centers,
-      int[] candidates) throws Exception {
-
-    int[] owners = new int[candidates.length];
-    double minDistance = Double.POSITIVE_INFINITY;
-    int ownerIndex = -1;
-    Instance owner;
-    int numCand = candidates.length;
-    double[] distance = new double[numCand];
-    boolean[] inside = new boolean[numCand];
-    for (int i = 0; i < numCand; i++) {
-      distance[i] = distanceToHrect(node, centers.instance(candidates[i]));
-      inside[i] = (distance[i] == 0.0);
-      if (distance[i] < minDistance) {
-        minDistance = distance[i];
-        ownerIndex = i;
-      }
-    }
-    owner = (Instance)centers.instance(candidates[ownerIndex]).copy();
-
-    // are there other owners
-    // loop also goes over already found owner, keeps order
-    // in owner list
-    int index = 0;
-    for (int i = 0; i < numCand; i++) {
-      // 1. all centers that are points within rectangle are owners
-      if ((inside[i])
-
-      // 2. take all points with same distance to the rect. as the owner
-          || (distance[i] == distance[ownerIndex])) {
-
-        // add competitor to owners list
-        owners[index++] = candidates[i];
-      } else {
-
-        Instance competitor = (Instance)centers.instance(candidates[i]).copy();
-        if
-
-        // 3. point has larger distance to rectangle but still can compete
-        // with owner for some points in the rectangle
-        (!candidateIsFullOwner(node, owner, competitor))
-
-        {
-          // also add competitor to owners list
-          owners[index++] = candidates[i];
-        }
-      }
-    }
-    int[] result = new int[index];
-    for (int i = 0; i < index; i++)
-      result[i] = owners[i];
-    return result;
-  }
-
-  /**
-   * Returns the distance between a point and an hyperrectangle.
-   * 
-   * @param node The current node from whose hyperrectangle 
-   * the distance is to be measured.
-   * @param x		the point
-   * @return 		the distance
-   * @throws Exception If some problem occurs in determining 
-   * the distance to the hyperrectangle.
-   */
-  protected double distanceToHrect(KDTreeNode node, Instance x) throws Exception {
-    double distance = 0.0;
-
-    Instance closestPoint = (Instance)x.copy();
-    boolean inside;
-    inside = clipToInsideHrect(node, closestPoint);
-    if (!inside)
-      distance = m_EuclideanDistance.distance(closestPoint, x);
-    return distance;
-  }
-
-  /**
-   * Finds the closest point in the hyper rectangle to a given point. Change the
-   * given point to this closest point by clipping of at all the dimensions to
-   * be clipped of. If the point is inside the rectangle it stays unchanged. The
-   * return value is true if the point was not changed, so the the return value
-   * is true if the point was inside the rectangle.
-   * 
-   * @param node The current KDTreeNode in whose hyperrectangle the closest 
-   * point is to be found.
-   * @param x		a point
-   * @return 		true if the input point stayed unchanged.
-   */
-  protected boolean clipToInsideHrect(KDTreeNode node, Instance x) {
-    boolean inside = true;
-    for (int i = 0; i < m_Instances.numAttributes(); i++) {
-      // TODO treat nominals differently!??
-
-      if (x.value(i) < node.m_NodeRanges[i][MIN]) {
-        x.setValue(i, node.m_NodeRanges[i][MIN]);
-        inside = false;
-      } else if (x.value(i) > node.m_NodeRanges[i][MAX]) {
-        x.setValue(i, node.m_NodeRanges[i][MAX]);
-        inside = false;
-      }
-    }
-    return inside;
-  }
-
-  /**
-   * Returns true if candidate is a full owner in respect to a competitor.
-   * <p>
-   * 
-   * The candidate has been the closer point to the current rectangle or even
-   * has been a point within the rectangle. The competitor is competing with the
-   * candidate for a few points out of the rectangle although it is a point
-   * further away from the rectangle then the candidate. The extrem point is the
-   * corner of the rectangle that is furthest away from the candidate towards
-   * the direction of the competitor.
-   * 
-   * If the distance candidate to this extreme point is smaller then the
-   * distance competitor to this extreme point, then it is proven that none of
-   * the points in the rectangle can be owned be the competitor and the
-   * candidate is full owner of the rectangle in respect to this competitor. See
-   * also D. Pelleg and A. Moore's paper 'Accelerating exact k-means Algorithms
-   * with Geometric Reasoning'.
-   * <p>
-   * 
-   * @param node The current KDTreeNode / hyperrectangle.
-   * @param candidate	instance that is candidate to be owner
-   * @param competitor	instance that competes against the candidate
-   * @return 		true if candidate is full owner
-   * @throws Exception If some problem occurs.
-   */
-  protected boolean candidateIsFullOwner(KDTreeNode node, Instance candidate,
-      Instance competitor) throws Exception {
-    // get extreme point
-    Instance extreme = (Instance)candidate.copy();
-    for (int i = 0; i < m_Instances.numAttributes(); i++) {
-      if ((competitor.value(i) - candidate.value(i)) > 0) {
-        extreme.setValue(i, node.m_NodeRanges[i][MAX]);
-      } else {
-        extreme.setValue(i, node.m_NodeRanges[i][MIN]);
-      }
-    }
-    boolean isFullOwner = m_EuclideanDistance.distance(extreme, candidate) < m_EuclideanDistance
-        .distance(extreme, competitor);
-
-    return isFullOwner;
-  }
-
-  /**
-   * Assigns instances of this node to center. Center to be assign to is decided
-   * by the distance function.
-   * 
-   * @param node The KDTreeNode whose instances are to be assigned.
-   * @param centers	all the input centers
-   * @param centList	the list of centers to work with
-   * @param assignments	index list of last assignments
-   * @throws Exception If there is error assigning the instances.
-   */
-  public void assignSubToCenters(KDTreeNode node, InstancesHeader centers,
-      int[] centList, int[] assignments) throws Exception {
-    // todo: undecided situations
-    int numCent = centList.length;
-
-    // WARNING: assignments is "input/output-parameter"
-    // should not be null and the following should not happen
-    if (assignments == null) {
-      assignments = new int[m_Instances.numInstances()];
-      for (int i = 0; i < assignments.length; i++) {
-        assignments[i] = -1;
-      }
-    }
-
-    // set assignments for all instances of this node
-    for (int i = node.m_Start; i <= node.m_End; i++) {
-      int instIndex = m_InstList[i];
-      Instance inst = m_Instances.instance(instIndex);
-      // if (instList[i] == 664) System.out.println("664***");
-      int newC = m_EuclideanDistance.closestPoint(inst, centers, centList);
-      // int newC = clusterProcessedInstance(inst, centers);
-      assignments[instIndex] = newC;
-    }
-  }
-
-  /**
-   * Properties' variables =====================================================
-   */
-
-  /** flag for normalizing. */
-  boolean m_NormalizeNodeWidth = true;
-
-  /** The euclidean distance function to use. */
-  protected EuclideanDistance m_EuclideanDistance;
-  { // to make sure we have only one object of EuclideanDistance
-    if (m_DistanceFunction instanceof EuclideanDistance)
-      m_EuclideanDistance = (EuclideanDistance) m_DistanceFunction;
-    else
-      m_DistanceFunction = m_EuclideanDistance = new EuclideanDistance();
-  }
-
-  /** minimal relative width of a KDTree rectangle. */
-  protected double m_MinBoxRelWidth = 1.0E-2;
-
-  /** maximal number of instances in a leaf. */
-  protected int m_MaxInstInLeaf = 40;
-
-  /**
-   * the GET and SET - functions ===============================================
-   */
-
-  /**
-   * Tip text for this property.
-   * 
-   * @return 		the tip text for this property
-   */
-  public String minBoxRelWidthTipText() {
-    return "The minimum relative width of the box. A node is only made a leaf "
-        + "if the width of the split dimension of the instances in a node "
-        + "normalized over the width of the split dimension of all the "
-        + "instances is less than or equal to this minimum relative width.";
-  }
-
-  /**
-   * Sets the minimum relative box width.
-   * 
-   * @param i		the minimum relative box width
-   */
-  public void setMinBoxRelWidth(double i) {
-    m_MinBoxRelWidth = i;
-  }
-
-  /**
-   * Gets the minimum relative box width.
-   * 
-   * @return 		the minimum relative box width
-   */
-  public double getMinBoxRelWidth() {
-    return m_MinBoxRelWidth;
-  }
-
-  /**
-   * Tip text for this property.
-   * 
-   * @return 		the tip text for this property
-   */
-  public String maxInstInLeafTipText() {
-    return "The max number of instances in a leaf.";
-  }
-
-  /**
-   * Sets the maximum number of instances in a leaf.
-   * 
-   * @param i		the maximum number of instances in a leaf
-   */
-  public void setMaxInstInLeaf(int i) {
-    m_MaxInstInLeaf = i;
-  }
-
-  /**
-   * Get the maximum number of instances in a leaf.
-   * 
-   * @return 		the maximum number of instances in a leaf
-   */
-  public int getMaxInstInLeaf() {
-    return m_MaxInstInLeaf;
-  }
-
-  /**
-   * Tip text for this property.
-   * 
-   * @return 		the tip text for this property
-   */
-  public String normalizeNodeWidthTipText() {
-    return "Whether if the widths of the KDTree node should be normalized "
-        + "by the width of the universe or not. "
-        + "Where, width of the node is the range of the split attribute "
-        + "based on the instances in that node, and width of the "
-        + "universe is the range of the split attribute based on all the "
-        + "instances (default: false).";
-  }
-
-  /**
-   * Sets the flag for normalizing the widths of a KDTree Node by the width of
-   * the dimension in the universe.
-   * 
-   * @param n		true to use normalizing.
-   */
-  public void setNormalizeNodeWidth(boolean n) {
-    m_NormalizeNodeWidth = n;
-  }
-
-  /**
-   * Gets the normalize flag.
-   * 
-   * @return 		True if normalizing
-   */
-  public boolean getNormalizeNodeWidth() {
-    return m_NormalizeNodeWidth;
-  }
-
-  /**
-   * returns the distance function currently in use.
-   * 
-   * @return 		the distance function
-   */
-  public DistanceFunction getDistanceFunction() {
-    return (DistanceFunction) m_EuclideanDistance;
-  }
-
-  /**
-   * sets the distance function to use for nearest neighbour search.
-   * 
-   * @param df		the distance function to use
-   * @throws Exception	if not EuclideanDistance
-   */
-  public void setDistanceFunction(DistanceFunction df) throws Exception {
-    if (!(df instanceof EuclideanDistance))
-      throw new Exception("KDTree currently only works with "
-          + "EuclideanDistanceFunction.");
-    m_DistanceFunction = m_EuclideanDistance = (EuclideanDistance) df;
-  }
-  
-  /**
-   * Returns the tip text for this property.
-   * 
-   * @return 		tip text for this property suitable for
-   * 			displaying in the explorer/experimenter gui
-   */
-  public String nodeSplitterTipText() {
-    return "The the splitting method to split the nodes of the KDTree.";
-  }
-
-  /**
-   * Returns the splitting method currently in use to split the nodes of the
-   * KDTree.
-   * 
-   * @return The KDTreeNodeSplitter currently in use.
-   */
-  public KDTreeNodeSplitter getNodeSplitter() {
-    return m_Splitter;
-  }
-
-  /**
-   * Sets the splitting method to use to split the nodes of the KDTree.
-   * 
-   * @param splitter The KDTreeNodeSplitter to use.
-   */
-  public void setNodeSplitter(KDTreeNodeSplitter splitter) {
-    m_Splitter = splitter;
-  }
-
-  /**
-   * Returns a string describing this nearest neighbour search algorithm.
-   * 
-   * @return 		a description of the algorithm for displaying in the
-   *         		explorer/experimenter gui
-   */
-  public String globalInfo() {
-    return 
-        "Class implementing the KDTree search algorithm for nearest "
-      + "neighbour search.\n"
-      + "The connection to dataset is only a reference. For the tree "
-      + "structure the indexes are stored in an array. \n"
-      + "Building the tree:\n"
-      + "If a node has <maximal-inst-number> (option -L) instances no "
-      + "further splitting is done. Also if the split would leave one "
-      + "side empty, the branch is not split any further even if the "
-      + "instances in the resulting node are more than "
-      + "<maximal-inst-number> instances.\n"
-      + "**PLEASE NOTE:** The algorithm can not handle missing values, so it "
-      + "is advisable to run ReplaceMissingValues filter if there are any "
-      + "missing values in the dataset.\n\n"
-      + "For more information see:\n\n";
-  }
-
-
-}
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/LinearNNSearch.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/LinearNNSearch.java
deleted file mode 100644
index 3c51f26c5..000000000
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/LinearNNSearch.java
+++ /dev/null
@@ -1,281 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/*
- *    LinearNNSearch.java
- *    Copyright (C) 1999-2012 University of Waikato
- */
-
-package moa.classifiers.lazy.neighboursearch;
-
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-//import weka.core.Option;
-//import weka.core.RevisionUtils;
-//import weka.core.Utils;
-
-/**
- <!-- globalinfo-start -->
- * Class implementing the brute force search algorithm for nearest neighbour search.
- * <p/>
- <!-- globalinfo-end -->
- * 
- <!-- options-start -->
- * Valid options are: <p/>
- * 
- * <pre> -S
- *  Skip identical instances (distances equal to zero).
- * </pre>
- * 
- <!-- options-end -->
- *
- * @author Ashraf M. Kibriya (amk14[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
- * @version $Revision: 8034 $
- */
-public class LinearNNSearch
-  extends NearestNeighbourSearch {
-
-  /** for serialization. */
-  private static final long serialVersionUID = 1915484723703917241L;
-
-  /** Array holding the distances of the nearest neighbours. It is filled up
-   *  both by nearestNeighbour() and kNearestNeighbours(). 
-   */
-  protected double[] m_Distances;
-    
-  /** Whether to skip instances from the neighbours that are identical to the query instance. */
-  protected boolean m_SkipIdentical = false;
-
-  /**
-   * Constructor. Needs setInstances(Instances) 
-   * to be called before the class is usable.
-   */
-  public LinearNNSearch() {
-    super();
-  }
-  
-  /**
-   * Constructor that uses the supplied set of 
-   * instances.
-   * 
-   * @param insts	the instances to use
-   */
-  public LinearNNSearch(InstancesHeader insts) {
-    super(insts);
-    m_DistanceFunction.setInstances(insts);
-  }
-  
-  /**
-   * Returns a string describing this nearest neighbour search algorithm.
-   * 
-   * @return 		a description of the algorithm for displaying in the 
-   * 			explorer/experimenter gui
-   */
-  public String globalInfo() {
-    return 
-        "Class implementing the brute force search algorithm for nearest "
-      + "neighbour search.";  
-  }
-  
-  
-
-  /**
-   * Returns the tip text for this property.
-   * 
-   * @return 		tip text for this property suitable for
-   * 			displaying in the explorer/experimenter gui
-   */
-  public String skipIdenticalTipText() {
-    return "Whether to skip identical instances (with distance 0 to the target)";
-  }
-  
-  /**
-   * Sets the property to skip identical instances (with distance zero from 
-   * the target) from the set of neighbours returned.
-   * 
-   * @param skip 	if true, identical intances are skipped
-   */
-  public void setSkipIdentical(boolean skip) {
-    m_SkipIdentical = skip;
-  }
-  
-  /**
-   * Gets whether if identical instances are skipped from the neighbourhood.
-   * 
-   * @return 		true if identical instances are skipped
-   */
-  public boolean getSkipIdentical() {
-    return m_SkipIdentical;
-  }
-
-  
-  /** 
-   * Returns the nearest instance in the current neighbourhood to the supplied
-   * instance.
-   *  
-   * @param target 	The instance to find the nearest neighbour for.
-   * @return		the nearest instance
-   * @throws Exception 	if the nearest neighbour could not be found.
-   */
-  public Instance nearestNeighbour(Instance target) throws Exception {
-    return (kNearestNeighbours(target, 1)).instance(0);
-  }
-  
-  /**
-   * Returns k nearest instances in the current neighbourhood to the supplied
-   * instance.
-   *  
-   * @param target 	The instance to find the k nearest neighbours for.
-   * @param kNN		The number of nearest neighbours to find.
-   * @return		the k nearest neighbors
-   * @throws Exception  if the neighbours could not be found.
-   */
-  public InstancesHeader kNearestNeighbours(Instance target, int kNN) throws Exception {
-  
-    //debug
-    boolean print=false;
- 
-    MyHeap heap = new MyHeap(kNN);
-    double distance; int firstkNN=0;
-    for(int i=0; i<m_Instances.numInstances(); i++) {
-      if(target == m_Instances.instance(i)) //for hold-one-out cross-validation
-        continue;
-      if(firstkNN<kNN) {
-        if(print)
-          System.out.println("K(a): "+(heap.size()+heap.noOfKthNearest()));
-        distance = m_DistanceFunction.distance(target, m_Instances.instance(i), Double.POSITIVE_INFINITY);
-        if(distance == 0.0 && m_SkipIdentical)
-          if(i<m_Instances.numInstances()-1)
-            continue;
-          else
-            heap.put(i, distance);
-        heap.put(i, distance);
-        firstkNN++;
-      }
-      else {
-        MyHeapElement temp = heap.peek();
-        if(print)
-          System.out.println("K(b): "+(heap.size()+heap.noOfKthNearest()));
-        distance = m_DistanceFunction.distance(target, m_Instances.instance(i), temp.distance);
-        if(distance == 0.0 && m_SkipIdentical)
-          continue;
-        if(distance < temp.distance) {
-          heap.putBySubstitute(i, distance);
-        }
-        else if(distance == temp.distance) {
-          heap.putKthNearest(i, distance);
-        }
-
-      }
-    }
-    
-    InstancesHeader neighbours = new InstancesHeader(m_Instances, (heap.size()+heap.noOfKthNearest()));
-    m_Distances = new double[heap.size()+heap.noOfKthNearest()];
-    int [] indices = new int[heap.size()+heap.noOfKthNearest()];
-    int i=1; MyHeapElement h;
-    while(heap.noOfKthNearest()>0) {
-      h = heap.getKthNearest();
-      indices[indices.length-i] = h.index;
-      m_Distances[indices.length-i] = h.distance;
-      i++;
-    }
-    while(heap.size()>0) {
-      h = heap.get();
-      indices[indices.length-i] = h.index;
-      m_Distances[indices.length-i] = h.distance;
-      i++;
-    }
-    
-    m_DistanceFunction.postProcessDistances(m_Distances);
-    
-    for(int k=0; k<indices.length; k++) {
-      neighbours.add(m_Instances.instance(indices[k]));
-    }
-    
-    return neighbours;    
-  }
-  
-  /** 
-   * Returns the distances of the k nearest neighbours. The kNearestNeighbours
-   * or nearestNeighbour must always be called before calling this function. If
-   * this function is called before calling either the kNearestNeighbours or 
-   * the nearestNeighbour, then it throws an exception. If, however, if either
-   * of the nearestNeighbour functions are called at any point in the 
-   * past then no exception is thrown and the distances of the training set from
-   * the last supplied target instance (to either one of the nearestNeighbour 
-   * functions) is/are returned.
-   *
-   * @return 		array containing the distances of the 
-   * 			nearestNeighbours. The length and ordering of the 
-   * 			array is the same as that of the instances returned 
-   * 			by nearestNeighbour functions.
-   * @throws Exception 	if called before calling kNearestNeighbours
-   *            	or nearestNeighbours.
-   */
-  public double[] getDistances() throws Exception {
-    if(m_Distances==null)
-      throw new Exception("No distances available. Please call either "+
-                          "kNearestNeighbours or nearestNeighbours first.");
-    return m_Distances;    
-  }
-
-  /** 
-   * Sets the instances comprising the current neighbourhood.
-   * 
-   * @param insts 	The set of instances on which the nearest neighbour 
-   * 			search is carried out. Usually this set is the 
-   * 			training set. 
-   * @throws Exception	if setting of instances fails
-   */
-  public void setInstances(InstancesHeader insts) throws Exception {
-    m_Instances = insts;
-    m_DistanceFunction.setInstances(insts);
-  }
-  
-  /** 
-   * Updates the LinearNNSearch to cater for the new added instance. This 
-   * implementation only updates the ranges of the DistanceFunction class, 
-   * since our set of instances is passed by reference and should already have 
-   * the newly added instance.
-   * 
-   * @param ins 	The instance to add. Usually this is the instance that 
-   * 			is added to our neighbourhood i.e. the training 
-   * 			instances.
-   * @throws Exception	if the given instances are null
-   */
-  public void update(Instance ins) throws Exception {
-    if(m_Instances==null)
-      throw new Exception("No instances supplied yet. Cannot update without"+
-                          "supplying a set of instances first.");
-    m_DistanceFunction.update(ins);
-  }
-  
-  /** 
-   * Adds the given instance info. This implementation updates the range
-   * datastructures of the DistanceFunction class.
-   * 
-   * @param ins 	The instance to add the information of. Usually this is
-   * 			the test instance supplied to update the range of 
-   * 			attributes in the  distance function.
-   */
-  public void addInstanceInfo(Instance ins) {
-    if(m_Instances!=null)
-      try{ update(ins); }
-      catch(Exception ex) { ex.printStackTrace(); }
-  }
-  
-
-}
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NearestNeighbourSearch.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NearestNeighbourSearch.java
deleted file mode 100644
index 541d0f527..000000000
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NearestNeighbourSearch.java
+++ /dev/null
@@ -1,742 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/*
- *    NearestNeighbourSearch.java
- *    Copyright (C) 1999-2012 University of Waikato
- */
-
-package moa.classifiers.lazy.neighboursearch;
-
-import java.io.Serializable;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
-/**
- * Abstract class for nearest neighbour search. All algorithms (classes) that
- * do nearest neighbour search should extend this class.
- *
- * @author Ashraf M. Kibriya (amk14[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
- * @version $Revision: 8034 $
- */
-public abstract class NearestNeighbourSearch
-  implements Serializable{
-
-  /**
-   * A class for a heap to store the nearest k neighbours to an instance. 
-   * The heap also takes care of cases where multiple neighbours are the same 
-   * distance away.
-   * i.e. the minimum size of the heap is k.
-   *
-   * @author Ashraf M. Kibriya (amk14[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
-   * @version $Revision: 8034 $
-   */
-  protected class MyHeap{
-    
-    /** the heap. */
-    MyHeapElement m_heap[] = null;
-    
-    /**
-     * constructor.
-     * 
-     * @param maxSize		the maximum size of the heap
-     */
-    public MyHeap(int maxSize) {
-      if((maxSize%2)==0)
-        maxSize++;
-      
-      m_heap = new MyHeapElement[maxSize+1];
-      m_heap[0] = new MyHeapElement(0, 0);
-    }
-    
-    /**
-     * returns the size of the heap.
-     * 
-     * @return			the size
-     */
-    public int size() {
-      return m_heap[0].index;
-    }
-    
-    /**
-     * peeks at the first element.
-     * 
-     * @return			the first element
-     */
-    public MyHeapElement peek() {
-      return m_heap[1];
-    }
-    
-    /**
-     * returns the first element and removes it from the heap.
-     * 
-     * @return			the first element
-     * @throws Exception	if no elements in heap
-     */
-    public MyHeapElement get() throws Exception  {
-      if(m_heap[0].index==0)
-        throw new Exception("No elements present in the heap");
-      MyHeapElement r = m_heap[1];
-      m_heap[1] = m_heap[m_heap[0].index];
-      m_heap[0].index--;
-      downheap();
-      return r;
-    }
-    
-    /**
-     * adds the value to the heap.
-     * 
-     * @param i			the index
-     * @param d			the distance
-     * @throws Exception	if the heap gets too large
-     */
-    public void put(int i, double d) throws Exception {
-      if((m_heap[0].index+1)>(m_heap.length-1))
-        throw new Exception("the number of elements cannot exceed the "+
-        "initially set maximum limit");
-      m_heap[0].index++;
-      m_heap[m_heap[0].index] = new MyHeapElement(i, d);
-      upheap();
-    }
-    
-    /**
-     * Puts an element by substituting it in place of 
-     * the top most element.
-     * 
-     * @param i			the index
-     * @param d			the distance
-     * @throws Exception	if distance is smaller than that of the head
-     * 				element
-     */
-    public void putBySubstitute(int i, double d) throws Exception {
-      MyHeapElement head = get();
-      put(i, d);
-      //      System.out.println("previous: "+head.distance+" current: "+m_heap[1].distance);
-      if(head.distance == m_heap[1].distance) { //Utils.eq(head.distance, m_heap[1].distance)) {
-        putKthNearest(head.index, head.distance);
-      }
-      else if(head.distance > m_heap[1].distance) { //Utils.gr(head.distance, m_heap[1].distance)) {
-        m_KthNearest = null;
-        m_KthNearestSize = 0;
-        initSize = 10;
-      }
-      else if(head.distance < m_heap[1].distance) {
-        throw new Exception("The substituted element is smaller than the "+
-        "head element. put() should have been called "+
-        "in place of putBySubstitute()");
-      }
-    }
-    
-    /** the kth nearest ones. */
-    MyHeapElement m_KthNearest[] = null;
-    
-    /** The number of kth nearest elements. */
-    int m_KthNearestSize = 0;
-    
-    /** the initial size of the heap. */
-    int initSize=10;
-
-    /**
-     * returns the number of k nearest.
-     * 
-     * @return the number of k nearest
-     * @see			#m_KthNearestSize
-     */
-    public int noOfKthNearest() {
-      return m_KthNearestSize;
-    }
-    
-    /**
-     * Stores kth nearest elements (if there are 
-     * more than one).
-     * @param i			the index
-     * @param d			the distance
-     */
-    public void putKthNearest(int i,  double d) {
-      if(m_KthNearest==null) {
-        m_KthNearest = new MyHeapElement[initSize];
-      }
-      if(m_KthNearestSize>=m_KthNearest.length) {
-        initSize += initSize;
-        MyHeapElement temp[] = new MyHeapElement[initSize];
-        System.arraycopy(m_KthNearest, 0, temp, 0, m_KthNearest.length);
-        m_KthNearest = temp;
-      }
-      m_KthNearest[m_KthNearestSize++] = new MyHeapElement(i, d);
-    }
-    
-    /**
-     * returns the kth nearest element or null if none there.
-     * 
-     * @return			the kth nearest element
-     */
-    public MyHeapElement getKthNearest() {
-      if(m_KthNearestSize==0)
-        return null;
-      m_KthNearestSize--;
-      return m_KthNearest[m_KthNearestSize];
-    }
-    
-    /** 
-     * performs upheap operation for the heap 
-     * to maintian its properties. 
-     */
-    protected void upheap() {
-      int i = m_heap[0].index;
-      MyHeapElement temp;
-      while( i > 1  && m_heap[i].distance>m_heap[i/2].distance) {
-        temp = m_heap[i];
-        m_heap[i] = m_heap[i/2];
-        i = i/2;
-        m_heap[i] = temp; //this is i/2 done here to avoid another division.
-      }
-    }
-    
-    /** 
-     * performs downheap operation for the heap 
-     * to maintian its properties. 
-     */
-    protected void downheap() {
-      int i = 1;
-      MyHeapElement temp;
-      while( ( (2*i) <= m_heap[0].index &&
-      m_heap[i].distance < m_heap[2*i].distance )
-      ||
-      ( (2*i+1) <= m_heap[0].index &&
-      m_heap[i].distance < m_heap[2*i+1].distance) ) {
-        if((2*i+1)<=m_heap[0].index) {
-          if(m_heap[2*i].distance>m_heap[2*i+1].distance) {
-            temp = m_heap[i];
-            m_heap[i] = m_heap[2*i];
-            i = 2*i;
-            m_heap[i] = temp;
-          }
-          else {
-            temp = m_heap[i];
-            m_heap[i] = m_heap[2*i+1];
-            i = 2*i+1;
-            m_heap[i] = temp;
-          }
-        }
-        else {
-          temp = m_heap[i];
-          m_heap[i] = m_heap[2*i];
-          i = 2*i;
-          m_heap[i] = temp;
-        }
-      }
-    }
-    
-    /**
-     * returns the total size.
-     * 
-     * @return			the total size
-     */
-    public int totalSize() {
-      return size()+noOfKthNearest();
-    }
-    
-  }
-  
-  /**
-   * A class for storing data about a neighboring instance.
-   *
-   * @author Ashraf M. Kibriya (amk14[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
-   * @version $Revision: 8034 $
-   */
-  protected class MyHeapElement{
-    
-    /** the index of this element. */
-    public int index;
-    
-    /** the distance of this element. */
-    public double distance;
-    
-    /**
-     * constructor.
-     * 
-     * @param i		the index
-     * @param d		the distance
-     */
-    public MyHeapElement(int i, double d) {
-      distance = d;
-      index = i;
-    }
-    
-  }
-  
-  /**
-   * A class for storing data about a neighboring instance.
-   *
-   * @author Ashraf M. Kibriya (amk14[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
-   * @version $Revision: 8034 $
-   */ //better to change this into a heap element
-  protected class NeighborNode {
-
-    /** The neighbor instance. */
-    public Instance m_Instance;
-
-    /** The distance from the current instance to this neighbor. */
-    public double m_Distance;
-
-    /** A link to the next neighbor instance. */
-    public NeighborNode m_Next;
-    
-    /**
-     * Create a new neighbor node.
-     *
-     * @param distance 		the distance to the neighbor
-     * @param instance 		the neighbor instance
-     * @param next 		the next neighbor node
-     */
-    public NeighborNode(double distance, Instance instance, NeighborNode next) {
-      m_Distance = distance;
-      m_Instance = instance;
-      m_Next = next;
-    }
-
-    /**
-     * Create a new neighbor node that doesn't link to any other nodes.
-     *
-     * @param distance 		the distance to the neighbor
-     * @param instance 		the neighbor instance
-     */
-    public NeighborNode(double distance, Instance instance) {
-
-      this(distance, instance, null);
-    }
-    
-  } 
-
-  /**
-   * A class for a linked list to store the nearest k neighbours
-   * to an instance. We use a list so that we can take care of
-   * cases where multiple neighbours are the same distance away.
-   * i.e. the minimum length of the list is k.
-   *
-   * @author Ashraf M. Kibriya (amk14[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
-   * @version $Revision: 8034 $
-   */ //better to change this into a heap
-  protected class NeighborList{
-
-    /** The first node in the list. */
-    protected NeighborNode m_First;
-
-    /** The last node in the list. */
-    protected NeighborNode m_Last;
-
-    /** The number of nodes to attempt to maintain in the list. */
-    protected int m_Length = 1;
-        
-    /**
-     * Creates the neighborlist with a desired length.
-     *
-     * @param length 		the length of list to attempt to maintain
-     */
-    public NeighborList(int length) {
-      m_Length = length;
-    }
-
-    /**
-     * Gets whether the list is empty.
-     *
-     * @return 			true if list is empty
-     */
-    public boolean isEmpty() {
-      return (m_First == null);
-    }
-
-    /**
-     * Gets the current length of the list.
-     *
-     * @return 			the current length of the list
-     */
-    public int currentLength() {
-      int i = 0;
-      NeighborNode current = m_First;
-      while (current != null) {
-        i++;
-        current = current.m_Next;
-      }
-      return i;
-    }
-
-    /**
-     * Inserts an instance neighbor into the list, maintaining the list
-     * sorted by distance.
-     *
-     * @param distance 		the distance to the instance
-     * @param instance 		the neighboring instance
-     */
-    public void insertSorted(double distance, Instance instance) {
-      
-      if (isEmpty()) {
-        m_First = m_Last = new NeighborNode(distance, instance);
-      } else {
-        NeighborNode current = m_First;
-        if (distance < m_First.m_Distance) {// Insert at head
-          m_First = new NeighborNode(distance, instance, m_First);
-        } else { // Insert further down the list
-          for( ;(current.m_Next != null) &&
-          (current.m_Next.m_Distance < distance);
-          current = current.m_Next);
-          current.m_Next = new NeighborNode(distance, instance,
-          current.m_Next);
-          if (current.equals(m_Last)) {
-            m_Last = current.m_Next;
-          }
-        }
-        
-        // Trip down the list until we've got k list elements (or more if the
-        // distance to the last elements is the same).
-        int valcount = 0;
-        for(current = m_First; current.m_Next != null;
-        current = current.m_Next) {
-          valcount++;
-          if ((valcount >= m_Length) && (current.m_Distance !=
-          current.m_Next.m_Distance)) {
-            m_Last = current;
-            current.m_Next = null;
-            break;
-          }
-        }
-      }
-    }
-
-    /**
-     * Prunes the list to contain the k nearest neighbors. If there are
-     * multiple neighbors at the k'th distance, all will be kept.
-     *
-     * @param k 		the number of neighbors to keep in the list.
-     */
-    public void pruneToK(int k) {
-      
-      if (isEmpty()) {
-        return;
-      }
-      if (k < 1) {
-        k = 1;
-      }
-      int currentK = 0;
-      double currentDist = m_First.m_Distance;
-      NeighborNode current = m_First;
-      for(; current.m_Next != null; current = current.m_Next) {
-        currentK++;
-        currentDist = current.m_Distance;
-        if ((currentK >= k) && (currentDist != current.m_Next.m_Distance)) {
-          m_Last = current;
-          current.m_Next = null;
-          break;
-        }
-      }
-    }
-    
-    /**
-     * Prints out the contents of the neighborlist.
-     */
-    public void printList() {
-      
-      if (isEmpty()) {
-        System.out.println("Empty list");
-      } else {
-        NeighborNode current = m_First;
-        while (current != null) {
-          System.out.println("Node: instance " + current.m_Instance
-          + ", distance " + current.m_Distance);
-          current = current.m_Next;
-        }
-        System.out.println();
-      }
-    }
-    
-    /**
-     * returns the first element in the list.
-     * 
-     * @return			the first element
-     */
-    public NeighborNode getFirst() {
-      return m_First;
-    }
-    
-    /**
-     * returns the last element in the list.
-     * 
-     * @return			the last element
-     */
-    public NeighborNode getLast() {
-      return m_Last;
-    }
-    
-  }
-  
-  /** The neighbourhood of instances to find neighbours in. */
-  protected InstancesHeader m_Instances;
-  
-  /** The number of neighbours to find. */
-  protected int m_kNN;
-
-  /** the distance function used. */
-  protected DistanceFunction m_DistanceFunction = new EuclideanDistance();
-  
-  /** Should we measure Performance. */
-  protected boolean m_MeasurePerformance = false;
-  
-  /**
-   * Constructor.
-   */
-  public NearestNeighbourSearch() {
-  }
-  
-  /**
-   * Constructor. 
-   * 
-   * @param insts 	The set of instances that constitute the neighbourhood.
-   */
-  public NearestNeighbourSearch(InstancesHeader insts) {
-    this();
-    m_Instances = insts;
-  }
-  
-  /**
-   * Returns a string describing this nearest neighbour search algorithm.
-   * 
-   * @return 		a description of the algorithm for displaying in the 
-   * 			explorer/experimenter gui
-   */
-  public String globalInfo() {
-    return 
-        "Abstract class for nearest neighbour search. All algorithms (classes) that "
-      + "do nearest neighbour search should extend this class.";
-  }
-  
-
-  /** 
-   * Returns the tip text for this property.
-   * 
-   * @return 		tip text for this property suitable for
-   *         		displaying in the explorer/experimenter gui
-   */
-  public String distanceFunctionTipText() {
-    return "The distance function to use for finding neighbours " +
-           "(default: weka.core.EuclideanDistance). ";
-  }
-  
-  /**
-   * returns the distance function currently in use.
-   * 
-   * @return		the distance function
-   */
-  public DistanceFunction getDistanceFunction() {
-    return m_DistanceFunction;
-  }
-  
-  /**
-   * sets the distance function to use for nearest neighbour search.
-   * 
-   * @param df		the new distance function to use
-   * @throws Exception	if instances cannot be processed
-   */
-  public void setDistanceFunction(DistanceFunction df) throws Exception {
-    m_DistanceFunction = df;
-  }
-
-  /** 
-   * Returns the tip text for this property.
-   * 
-   * @return 		tip text for this property suitable for
-   *         		displaying in the explorer/experimenter gui
-   */
-  public String measurePerformanceTipText() {
-    return "Whether to calculate performance statistics " +
-           "for the NN search or not";
-  }
-  
-  /**
-   * Gets whether performance statistics are being calculated or not.
-   * 
-   * @return		true if the measure performance is calculated
-   */
-  public boolean getMeasurePerformance() {
-    return m_MeasurePerformance;
-  }
-  
-    
-  /** 
-   * Returns the nearest instance in the current neighbourhood to the supplied
-   * instance.
-   * 
-   * @param target 	The instance to find the nearest neighbour for.
-   * @return		the nearest neighbor
-   * @throws Exception 	if the nearest neighbour could not be found.
-   */
-  public abstract Instance nearestNeighbour(Instance target) throws Exception;
-  
-  /**
-   * Returns k nearest instances in the current neighbourhood to the supplied
-   * instance.
-   *  
-   * @param target 	The instance to find the k nearest neighbours for.
-   * @param k		The number of nearest neighbours to find.
-   * @return		the k nearest neighbors
-   * @throws Exception 	if the neighbours could not be found.
-   */
-  public abstract InstancesHeader kNearestNeighbours(Instance target, int k) throws Exception;
- 
-  /**
-   * Returns the distances of the k nearest neighbours. The kNearestNeighbours
-   * or nearestNeighbour needs to be called first for this to work.
-   *
-   * @return		the distances
-   * @throws Exception 	if called before calling kNearestNeighbours
-   *            	or nearestNeighbours.
-   */
-  public abstract double[] getDistances() throws Exception;
-  
-  /**
-   * Updates the NearNeighbourSearch algorithm for the new added instance.
-   * P.S.: The method assumes the instance has already been added to the 
-   * m_Instances object by the caller.
-   * 
-   * @param ins		the instance to add
-   * @throws Exception	if updating fails
-   */
-  public abstract void update(Instance ins) throws Exception;
-
-  /** 
-   * Adds information from the given instance without modifying the 
-   * datastructure a lot.
-   * 
-   * @param ins		the instance to add the information from
-   */
-  public void addInstanceInfo(Instance ins) {
-  }
-  
-  /**
-   * Sets the instances.
-   * 
-   * @param insts	the instances to use
-   * @throws Exception	if setting fails
-   */
-  public void setInstances(InstancesHeader insts) throws Exception {
-    m_Instances = insts;
-  }
-  
-  /** 
-   * returns the instances currently set.
-   * 
-   * @return		the current instances
-   */
-  public InstancesHeader getInstances() {
-    return m_Instances;
-  }
-
-
-  /** 
-   * sorts the two given arrays.
-   * 
-   * @param arrayToSort 	The array sorting should be based on.
-   * @param linkedArray		The array that should have the same ordering as 
-   * 				arrayToSort.
-   */
-  public static void combSort11(double arrayToSort[], int linkedArray[]) {
-    int switches, j, top, gap;
-    double hold1; int hold2;
-    gap = arrayToSort.length;
-    do {
-      gap=(int)(gap/1.3);
-      switch(gap) {
-        case 0:
-          gap = 1;
-          break;
-        case 9:
-        case 10:
-          gap=11;
-          break;
-        default:
-          break;
-      }
-      switches=0;
-      top = arrayToSort.length-gap;
-      for(int i=0; i<top; i++) {
-        j=i+gap;
-        if(arrayToSort[i] > arrayToSort[j]) {
-          hold1=arrayToSort[i];
-          hold2=linkedArray[i];
-          arrayToSort[i]=arrayToSort[j];
-          linkedArray[i]=linkedArray[j];
-          arrayToSort[j]=hold1;
-          linkedArray[j]=hold2;
-          switches++;
-        }//endif
-      }//endfor
-    } while(switches>0 || gap>1);
-  }
-   
-  /**
-   * Partitions the instances around a pivot. Used by quicksort and
-   * kthSmallestValue.
-   *
-   * @param arrayToSort 	the array of doubles to be sorted
-   * @param linkedArray		the linked array
-   * @param l 			the first index of the subset 
-   * @param r 			the last index of the subset 
-   * @return 			the index of the middle element
-   */
-  protected static int partition(double[] arrayToSort, double[] linkedArray, int l, int r) {
-    double pivot = arrayToSort[(l + r) / 2];
-    double help;
-
-    while (l < r) {
-      while ((arrayToSort[l] < pivot) && (l < r)) {
-        l++;
-      }
-      while ((arrayToSort[r] > pivot) && (l < r)) {
-        r--;
-      }
-      if (l < r) {
-        help = arrayToSort[l];
-        arrayToSort[l] = arrayToSort[r];
-        arrayToSort[r] = help;
-        help = linkedArray[l];
-        linkedArray[l] = linkedArray[r];
-        linkedArray[r] = help;
-        l++;
-        r--;
-      }
-    }
-    if ((l == r) && (arrayToSort[r] > pivot)) {
-      r--;
-    } 
-
-    return r;
-  }
-  
-  /**
-   * performs quicksort.
-   * 
-   * @param arrayToSort		the array to sort
-   * @param linkedArray		the linked array
-   * @param left 		the first index of the subset 
-   * @param right		the last index of the subset 
-   */
-  public static void quickSort(double[] arrayToSort, double[] linkedArray, int left, int right) {
-    if (left < right) {
-      int middle = partition(arrayToSort, linkedArray, left, right);
-      quickSort(arrayToSort, linkedArray, left, middle);
-      quickSort(arrayToSort, linkedArray, middle + 1, right);
-    }
-  }
-}
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NormalizableDistance.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NormalizableDistance.java
deleted file mode 100644
index 46da24f3e..000000000
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/NormalizableDistance.java
+++ /dev/null
@@ -1,722 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/*
- *    NormalizableDistance.java
- *    Copyright (C) 2007-2012 University of Waikato, Hamilton, New Zealand
- *
- */
-
-package moa.classifiers.lazy.neighboursearch;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
-/**
- * Represents the abstract ancestor for normalizable distance functions, like
- * Euclidean or Manhattan distance.
- *
- * @author Fracpete (fracpete at waikato dot ac dot nz)
- * @author Gabi Schmidberger (gabi@cs.waikato.ac.nz) -- original code from weka.core.EuclideanDistance
- * @author Ashraf M. Kibriya (amk14@cs.waikato.ac.nz) -- original code from weka.core.EuclideanDistance
- * @version $Revision: 8034 $
- */
-public abstract class NormalizableDistance
-  implements DistanceFunction {
-  
-  /** Index in ranges for MIN. */
-  public static final int R_MIN = 0;
-
-  /** Index in ranges for MAX. */
-  
-  public static final int R_MAX = 1;
-  
-  /** Index in ranges for WIDTH. */
-  public static final int R_WIDTH = 2;
-
-  /** the instances used internally. */
-  protected InstancesHeader m_Data = null;
-
-  /** True if normalization is turned off (default false).*/
-  protected boolean m_DontNormalize = false;
-  
-  /** The range of the attributes. */
-  protected double[][] m_Ranges;
-
-  /** The range of attributes to use for calculating the distance. */
-//  protected Range m_AttributeIndices = new Range("first-last");
-
-  /** The boolean flags, whether an attribute will be used or not. */
-  protected boolean[] m_ActiveIndices;
-  
-  /** Whether all the necessary preparations have been done. */
-  protected boolean m_Validated;
-
-  /**
-   * Invalidates the distance function, Instances must be still set.
-   */
-  public NormalizableDistance() {
-    invalidate();
-  }
-
-  /**
-   * Initializes the distance function and automatically initializes the
-   * ranges.
-   * 
-   * @param data 	the instances the distance function should work on
-   */
-  public NormalizableDistance(InstancesHeader data) {
-    setInstances(data);
-  }
-  
-  /**
-   * Returns a string describing this object.
-   * 
-   * @return 		a description of the evaluator suitable for
-   * 			displaying in the explorer/experimenter gui
-   */
-  public abstract String globalInfo();
-  
-  /** 
-   * Returns the tip text for this property.
-   * 
-   * @return 		tip text for this property suitable for
-   *         		displaying in the explorer/experimenter gui
-   */
-  public String dontNormalizeTipText() {
-    return "Whether if the normalization of attributes should be turned off " +
-           "for distance calculation (Default: false i.e. attribute values " +
-           "are normalized). ";
-  }
-  
-  /** 
-   * Sets whether if the attribute values are to be normalized in distance
-   * calculation.
-   * 
-   * @param dontNormalize	if true the values are not normalized
-   */
-  public void setDontNormalize(boolean dontNormalize) {
-    m_DontNormalize = dontNormalize;
-    invalidate();
-  }
-  
-  /**
-   * Gets whether if the attribute values are to be normazlied in distance
-   * calculation. (default false i.e. attribute values are normalized.)
-   * 
-   * @return		false if values get normalized
-   */
-  public boolean getDontNormalize() {
-    return m_DontNormalize;
-  }
-
-  /**
-   * Returns the tip text for this property.
-   *
-   * @return 		tip text for this property suitable for
-   * 			displaying in the explorer/experimenter gui
-   */
-  public String attributeIndicesTipText() {
-    return 
-        "Specify range of attributes to act on. "
-      + "This is a comma separated list of attribute indices, with "
-      + "\"first\" and \"last\" valid values. Specify an inclusive "
-      + "range with \"-\". E.g: \"first-3,5,6-10,last\".";
-  }
-
-  /**
-   * Sets the range of attributes to use in the calculation of the distance.
-   * The indices start from 1, 'first' and 'last' are valid as well. 
-   * E.g.: first-3,5,6-last
-   * 
-   * @param value	the new attribute index range
-   */
-  public void setAttributeIndices(String value) {
-    //m_AttributeIndices.setRanges(value);
-    invalidate();
-  }
-  
-  /**
-   * Gets the range of attributes used in the calculation of the distance.
-   * 
-   * @return		the attribute index range
-   */
-  public String getAttributeIndices() {
-    return null; //m_AttributeIndices.getRanges();
-  }   
-
-  /**
-   * Returns the tip text for this property.
-   *
-   * @return 		tip text for this property suitable for
-   * 			displaying in the explorer/experimenter gui
-   */
-  public String invertSelectionTipText() {
-    return 
-        "Set attribute selection mode. If false, only selected "
-      + "attributes in the range will be used in the distance calculation; if "
-      + "true, only non-selected attributes will be used for the calculation.";
-  }
-  
-  /**
-   * Sets whether the matching sense of attribute indices is inverted or not.
-   * 
-   * @param value	if true the matching sense is inverted
-   */
-  public void setInvertSelection(boolean value) {
-    //m_AttributeIndices.setInvert(value);
-    invalidate();
-  }
-  
-  /**
-   * Gets whether the matching sense of attribute indices is inverted or not.
-   * 
-   * @return		true if the matching sense is inverted
-   */
-  public boolean getInvertSelection() {
-    return false; //m_AttributeIndices.getInvert();
-  }
-  
-  /**
-   * invalidates all initializations.
-   */
-  protected void invalidate() {
-    m_Validated = false;
-  }
-  
-  /**
-   * performs the initializations if necessary.
-   */
-  protected void validate() {
-    if (!m_Validated) {
-      initialize();
-      m_Validated = true;
-    }
-  }
-  
-  /**
-   * initializes the ranges and the attributes being used.
-   */
-  protected void initialize() {
-    initializeAttributeIndices();
-    initializeRanges();
-  }
-
-  /**
-   * initializes the attribute indices.
-   */
-  protected void initializeAttributeIndices() {
-    //m_AttributeIndices.setUpper(m_Data.numAttributes() - 1);
-    m_ActiveIndices = new boolean[m_Data.numAttributes()];
-    for (int i = 0; i < m_ActiveIndices.length; i++)
-      m_ActiveIndices[i] = true; //m_AttributeIndices.isInRange(i);
-  }
-
-  /**
-   * Sets the instances.
-   * 
-   * @param insts 	the instances to use
-   */
-  public void setInstances(InstancesHeader insts) {
-    m_Data = insts;
-    invalidate();
-  }
-
-  /**
-   * returns the instances currently set.
-   * 
-   * @return 		the current instances
-   */
-  public InstancesHeader getInstances() {
-    return m_Data;
-  }
-
-  /**
-   * Does nothing, derived classes may override it though.
-   * 
-   * @param distances	the distances to post-process
-   */
-  public void postProcessDistances(double[] distances) {
-  }
-
-  /**
-   * Update the distance function (if necessary) for the newly added instance.
-   * 
-   * @param ins		the instance to add
-   */
-  public void update(Instance ins) {
-    validate();
-    
-    m_Ranges = updateRanges(ins, m_Ranges);
-  }
-
-  /**
-   * Calculates the distance between two instances.
-   * 
-   * @param first 	the first instance
-   * @param second 	the second instance
-   * @return 		the distance between the two given instances
-   */
-  public double distance(Instance first, Instance second) {
-    return distance(first, second, Double.POSITIVE_INFINITY);
-  }
-
-
-  /**
-   * Calculates the distance between two instances. Offers speed up (if the 
-   * distance function class in use supports it) in nearest neighbour search by 
-   * taking into account the cutOff or maximum distance. Depending on the 
-   * distance function class, post processing of the distances by 
-   * postProcessDistances(double []) may be required if this function is used.
-   *
-   * @param first 	the first instance
-   * @param second 	the second instance
-   * @param cutOffValue If the distance being calculated becomes larger than 
-   *                    cutOffValue then the rest of the calculation is 
-   *                    discarded.
-   * @return 		the distance between the two given instances or 
-   * 			Double.POSITIVE_INFINITY if the distance being 
-   * 			calculated becomes larger than cutOffValue. 
-   */
-  public double distance(Instance first, Instance second, double cutOffValue) {
-    double distance = 0;
-    int firstI, secondI;
-    int firstNumValues = first.numValues();
-    int secondNumValues = second.numValues();
-    int numAttributes = m_Data.numAttributes();
-    int classIndex = m_Data.classIndex();
-    
-    validate();
-    
-    for (int p1 = 0, p2 = 0; p1 < firstNumValues || p2 < secondNumValues; ) {
-      if (p1 >= firstNumValues)
-	firstI = numAttributes;
-      else
-	firstI = first.index(p1); 
-
-      if (p2 >= secondNumValues)
-	secondI = numAttributes;
-      else
-	secondI = second.index(p2);
-
-      if (firstI == classIndex) {
-	p1++; 
-	continue;
-      }
-      if ((firstI < numAttributes) && !m_ActiveIndices[firstI]) {
-	p1++; 
-	continue;
-      }
-       
-      if (secondI == classIndex) {
-	p2++; 
-	continue;
-      }
-      if ((secondI < numAttributes) && !m_ActiveIndices[secondI]) {
-	p2++;
-	continue;
-      }
-       
-      double diff;
-      
-      if (firstI == secondI) {
-	diff = difference(firstI,
-	    		  first.valueSparse(p1),
-	    		  second.valueSparse(p2));
-	p1++;
-	p2++;
-      }
-      else if (firstI > secondI) {
-	diff = difference(secondI, 
-	    		  0, second.valueSparse(p2));
-	p2++;
-      }
-      else {
-	diff = difference(firstI, 
-	    		  first.valueSparse(p1), 0);
-	p1++;
-      }
-      
-      distance = updateDistance(distance, diff);
-      if (distance > cutOffValue)
-        return Double.POSITIVE_INFINITY;
-    }
-
-    return distance;
-  }
-  
-  /**
-   * Updates the current distance calculated so far with the new difference
-   * between two attributes. The difference between the attributes was 
-   * calculated with the difference(int,double,double) method.
-   * 
-   * @param currDist	the current distance calculated so far
-   * @param diff	the difference between two new attributes
-   * @return		the update distance
-   * @see		#difference(int, double, double)
-   */
-  protected abstract double updateDistance(double currDist, double diff);
-  
-  /**
-   * Normalizes a given value of a numeric attribute.
-   *
-   * @param x 		the value to be normalized
-   * @param i 		the attribute's index
-   * @return		the normalized value
-   */
-  protected double norm(double x, int i) {
-    if (Double.isNaN(m_Ranges[i][R_MIN]) || (m_Ranges[i][R_MAX] == m_Ranges[i][R_MIN]))
-      return 0;
-    else
-      return (x - m_Ranges[i][R_MIN]) / (m_Ranges[i][R_WIDTH]);
-  }
-
-  /**
-   * Computes the difference between two given attribute
-   * values.
-   * 
-   * @param index	the attribute index
-   * @param val1	the first value
-   * @param val2	the second value
-   * @return		the difference
-   */
-  protected double difference(int index, double val1, double val2) {
-    //switch (m_Data.attribute(index).type()) {
-      //case Attribute.NOMINAL:
-      if (m_Data.attribute(index).isNominal() == true){
-        if (isMissingValue(val1) ||
-           isMissingValue(val2) ||
-           ((int) val1 != (int) val2)) {
-          return 1;
-        }
-        else {
-          return 0;
-        }
-      } else {  
-      //case Attribute.NUMERIC:
-        if (isMissingValue(val1) ||
-           isMissingValue(val2)) {
-          if (isMissingValue(val1) &&
-             isMissingValue(val2)) {
-            if (!m_DontNormalize)  //We are doing normalization
-              return 1;
-            else
-              return (m_Ranges[index][R_MAX] - m_Ranges[index][R_MIN]);
-          }
-          else {
-            double diff;
-            if (isMissingValue(val2)) {
-              diff = (!m_DontNormalize) ? norm(val1, index) : val1;
-            }
-            else {
-              diff = (!m_DontNormalize) ? norm(val2, index) : val2;
-            }
-            if (!m_DontNormalize && diff < 0.5) {
-              diff = 1.0 - diff;
-            }
-            else if (m_DontNormalize) {
-              if ((m_Ranges[index][R_MAX]-diff) > (diff-m_Ranges[index][R_MIN]))
-                return m_Ranges[index][R_MAX]-diff;
-              else
-                return diff-m_Ranges[index][R_MIN];
-            }
-            return diff;
-          }
-        }
-        else {
-          return (!m_DontNormalize) ? 
-              	 (norm(val1, index) - norm(val2, index)) :
-              	 (val1 - val2);
-        }
-        
-      //default:
-      //  return 0;
-    }
-  }
-  
-  /**
-   * Initializes the ranges using all instances of the dataset.
-   * Sets m_Ranges.
-   * 
-   * @return 		the ranges
-   */
-  public double[][] initializeRanges() {
-    if (m_Data == null) {
-      m_Ranges = null;
-      return m_Ranges;
-    }
-    
-    int numAtt = m_Data.numAttributes();
-    double[][] ranges = new double [numAtt][3];
-    
-    if (m_Data.numInstances() <= 0) {
-      initializeRangesEmpty(numAtt, ranges);
-      m_Ranges = ranges;
-      return m_Ranges;
-    }
-    else {
-      // initialize ranges using the first instance
-      updateRangesFirst(m_Data.instance(0), numAtt, ranges);
-    }
-    
-    // update ranges, starting from the second
-    for (int i = 1; i < m_Data.numInstances(); i++)
-      updateRanges(m_Data.instance(i), numAtt, ranges);
-
-    m_Ranges = ranges;
-    
-    return m_Ranges;
-  }
-  
-  /**
-   * Used to initialize the ranges. For this the values of the first
-   * instance is used to save time.
-   * Sets low and high to the values of the first instance and
-   * width to zero.
-   * 
-   * @param instance 	the new instance
-   * @param numAtt 	number of attributes in the model
-   * @param ranges 	low, high and width values for all attributes
-   */
-  public void updateRangesFirst(Instance instance, int numAtt, double[][] ranges) {
-    for (int j = 0; j < numAtt; j++) {
-      if (!instance.isMissing(j)) {
-        ranges[j][R_MIN] = instance.value(j);
-        ranges[j][R_MAX] = instance.value(j);
-        ranges[j][R_WIDTH] = 0.0;
-      }
-      else { // if value was missing
-        ranges[j][R_MIN] = Double.POSITIVE_INFINITY;
-        ranges[j][R_MAX] = -Double.POSITIVE_INFINITY;
-        ranges[j][R_WIDTH] = Double.POSITIVE_INFINITY;
-      }
-    }
-  }
-  
-  /**
-   * Updates the minimum and maximum and width values for all the attributes
-   * based on a new instance.
-   * 
-   * @param instance 	the new instance
-   * @param numAtt 	number of attributes in the model
-   * @param ranges 	low, high and width values for all attributes
-   */
-  public void updateRanges(Instance instance, int numAtt, double[][] ranges) {
-    // updateRangesFirst must have been called on ranges
-    for (int j = 0; j < numAtt; j++) {
-      double value = instance.value(j);
-      if (!instance.isMissing(j)) {
-        if (value < ranges[j][R_MIN]) {
-          ranges[j][R_MIN] = value;
-          ranges[j][R_WIDTH] = ranges[j][R_MAX] - ranges[j][R_MIN];
-          if (value > ranges[j][R_MAX]) { //if this is the first value that is
-            ranges[j][R_MAX] = value;    //not missing. The,0
-            ranges[j][R_WIDTH] = ranges[j][R_MAX] - ranges[j][R_MIN];
-          }
-        }
-        else {
-          if (value > ranges[j][R_MAX]) {
-            ranges[j][R_MAX] = value;
-            ranges[j][R_WIDTH] = ranges[j][R_MAX] - ranges[j][R_MIN];
-          }
-        }
-      }
-    }
-  }
-  
-  /**
-   * Used to initialize the ranges.
-   * 
-   * @param numAtt 	number of attributes in the model
-   * @param ranges 	low, high and width values for all attributes
-   */
-  public void initializeRangesEmpty(int numAtt, double[][] ranges) {
-    for (int j = 0; j < numAtt; j++) {
-      ranges[j][R_MIN] = Double.POSITIVE_INFINITY;
-      ranges[j][R_MAX] = -Double.POSITIVE_INFINITY;
-      ranges[j][R_WIDTH] = Double.POSITIVE_INFINITY;
-    }
-  }
-  
-  /**
-   * Updates the ranges given a new instance.
-   * 
-   * @param instance 	the new instance
-   * @param ranges 	low, high and width values for all attributes
-   * @return		the updated ranges
-   */
-  public double[][] updateRanges(Instance instance, double[][] ranges) {
-    // updateRangesFirst must have been called on ranges
-    for (int j = 0; j < ranges.length; j++) {
-      double value = instance.value(j);
-      if (!instance.isMissing(j)) {
-        if (value < ranges[j][R_MIN]) {
-          ranges[j][R_MIN] = value;
-          ranges[j][R_WIDTH] = ranges[j][R_MAX] - ranges[j][R_MIN];
-        } else {
-          if (instance.value(j) > ranges[j][R_MAX]) {
-            ranges[j][R_MAX] = value;
-            ranges[j][R_WIDTH] = ranges[j][R_MAX] - ranges[j][R_MIN];
-          }
-        }
-      }
-    }
-    
-    return ranges;
-  }
-  
-  /**
-   * Initializes the ranges of a subset of the instances of this dataset.
-   * Therefore m_Ranges is not set.
-   * 
-   * @param instList 	list of indexes of the subset
-   * @return 		the ranges
-   * @throws Exception	if something goes wrong
-   */
-  public double[][] initializeRanges(int[] instList) throws Exception {
-    if (m_Data == null)
-      throw new Exception("No instances supplied.");
-    
-    int numAtt = m_Data.numAttributes();
-    double[][] ranges = new double [numAtt][3];
-    
-    if (m_Data.numInstances() <= 0) {
-      initializeRangesEmpty(numAtt, ranges);
-      return ranges;
-    }
-    else {
-      // initialize ranges using the first instance
-      updateRangesFirst(m_Data.instance(instList[0]), numAtt, ranges);
-      // update ranges, starting from the second
-      for (int i = 1; i < instList.length; i++) {
-        updateRanges(m_Data.instance(instList[i]), numAtt, ranges);
-      }
-    }
-    return ranges;
-  }
-
-  /**
-   * Initializes the ranges of a subset of the instances of this dataset.
-   * Therefore m_Ranges is not set.
-   * The caller of this method should ensure that the supplied start and end 
-   * indices are valid (start &lt;= end, end&lt;instList.length etc) and
-   * correct.
-   *
-   * @param instList 	list of indexes of the instances
-   * @param startIdx 	start index of the subset of instances in the indices array
-   * @param endIdx 	end index of the subset of instances in the indices array
-   * @return 		the ranges
-   * @throws Exception	if something goes wrong
-   */
-  public double[][] initializeRanges(int[] instList, int startIdx, int endIdx) throws Exception {
-    if (m_Data == null)
-      throw new Exception("No instances supplied.");
-    
-    int numAtt = m_Data.numAttributes();
-    double[][] ranges = new double [numAtt][3];
-    
-    if (m_Data.numInstances() <= 0) {
-      initializeRangesEmpty(numAtt, ranges);
-      return ranges;
-    }
-    else {
-      // initialize ranges using the first instance
-      updateRangesFirst(m_Data.instance(instList[startIdx]), numAtt, ranges);
-      // update ranges, starting from the second
-      for (int i = startIdx+1; i <= endIdx; i++) {
-        updateRanges(m_Data.instance(instList[i]), numAtt, ranges);
-      }
-    }
-    
-    return ranges;
-  }
-  
-  /**
-   * Update the ranges if a new instance comes.
-   * 
-   * @param instance 	the new instance
-   */
-  public void updateRanges(Instance instance) {
-    validate();
-    
-    m_Ranges = updateRanges(instance, m_Ranges);
-  }
-  
-  /**
-   * Test if an instance is within the given ranges.
-   * 
-   * @param instance 	the instance
-   * @param ranges 	the ranges the instance is tested to be in
-   * @return true 	if instance is within the ranges
-   */
-  public boolean inRanges(Instance instance, double[][] ranges) {
-    boolean isIn = true;
-    
-    // updateRangesFirst must have been called on ranges
-    for (int j = 0; isIn && (j < ranges.length); j++) {
-      if (!instance.isMissing(j)) {
-        double value = instance.value(j);
-        isIn = value <= ranges[j][R_MAX];
-        if (isIn) isIn = value >= ranges[j][R_MIN];
-      }
-    }
-    
-    return isIn;
-  }
-  
-  /**
-   * Check if ranges are set.
-   * 
-   * @return 		true if ranges are set
-   */
-  public boolean rangesSet() {
-    return (m_Ranges != null);
-  }
-  
-  /**
-   * Method to get the ranges.
-   * 
-   * @return 		the ranges
-   * @throws Exception	if no randes are set yet
-   */
-  public double[][] getRanges() throws Exception {
-    validate();
-    
-    if (m_Ranges == null)
-      throw new Exception("Ranges not yet set.");
-    
-    return m_Ranges;
-  }
-  
-  /**
-   * Returns an empty string.
-   * 
-   * @return		an empty string
-   */
-  public String toString() {
-    return "";
-  }
-  
-   /**
-   * Tests if the given value codes "missing".
-   *
-   * @param val the value to be tested
-   * @return true if val codes "missing"
-   */
-  public static boolean isMissingValue(double val) {
-
-    return Double.isNaN(val);
-  }
-}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KDTreeNode.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KDTreeNode.java
deleted file mode 100644
index de00b88df..000000000
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KDTreeNode.java
+++ /dev/null
@@ -1,186 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/*
- * KDTreeNode.java
- * Copyright (C) 2007-2012 University of Waikato, Hamilton, New Zealand
- */
-
-package moa.classifiers.lazy.neighboursearch.kdtrees;
-
-import java.io.Serializable;
-
-
-/**
- * A class representing a KDTree node. A node does not explicitly
- * store the instances that it contains. Instead, it only stores 
- * the start and end index of a portion in a master index array. Each
- * node is assigned a portion in the master index array that stores 
- * the indices of the instances that the node contains. Every time a 
- * node is split by the KDTree's contruction method, the instances of 
- * its left child are moved to the left and the instances of its 
- * right child are moved to the right, in the portion of the master 
- * index array belonging to the node. The start and end index in each
- * of its children are then set accordingly within that portion so 
- * that each have their own portion which contains their instances.   
- * P.S.: The master index array is only stored in KDTree class.
- * 
- * @author Ashraf M. Kibriya (amk14[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
- * @version $Revision: 8034 $
- */
-public class KDTreeNode
-  implements Serializable {
-
-  /**
-   * for serialization.
-   */
-  private static final long serialVersionUID = -3660396067582792648L;
-
-  /**
-   * node number (only for debug).
-   */
-  public int m_NodeNumber;
-
-  /**
-   * left subtree; contains instances with smaller or equal to split value.
-   */
-  public KDTreeNode m_Left = null;
-
-  /**
-   * right subtree; contains instances with larger than split value.
-   */
-  public KDTreeNode m_Right = null;
-
-  /**
-   * value to split on.
-   */
-  public double m_SplitValue;
-
-  /**
-   * attribute to split on.
-   */
-  public int m_SplitDim;
-
-  /**
-   * lowest and highest value and width (= high - low) for each
-   * dimension.
-   */
-  public double[][] m_NodeRanges;
-
-  /**
-   * The lo and high bounds of the hyper rectangle described by the
-   * node.
-   */
-  public double[][] m_NodesRectBounds;
-
-  /**
-   * The start index of the portion of the master index array,
-   * which stores the indices of the instances/points the node
-   * contains.
-   */
-  public int m_Start = 0;
-
-  /**
-   * The end index of the portion of the master index array,
-   * which stores indices of the instances/points the node
-   * contains.
-   */
-  public int m_End = 0;
-
-  /**
-   * Constructor.
-   */
-  public KDTreeNode() {
-  }
-
-  /**
-   * Constructor.
-   *
-   * @param nodeNum    The node number/id.
-   * @param startidx   The start index of node's portion
-   *                   in master index array.
-   * @param endidx     The start index of node's portion
-   *                   in master index array.
-   * @param nodeRanges The attribute ranges of the
-   *                   Instances/points contained in this node.
-   */
-  public KDTreeNode(int nodeNum, int startidx, int endidx, double[][] nodeRanges) {
-    m_NodeNumber = nodeNum;
-    m_Start = startidx;
-    m_End = endidx;
-    m_NodeRanges = nodeRanges;
-  }
-
-  /**
-   * @param nodeNum    The node number/id.
-   * @param startidx   The start index of node's portion
-   *                   in master index array.
-   * @param endidx     The start index of node's portion
-   *                   in master index array.
-   * @param nodeRanges The attribute ranges of the
-   *                   Instances/points contained in this node.
-   * @param rectBounds The range of the rectangular
-   *                   region in the point space that this node
-   *                   represents (points inside this rectangular
-   *                   region can have different range).
-   */
-  public KDTreeNode(int nodeNum, int startidx, int endidx, double[][] nodeRanges, double[][] rectBounds) {
-    m_NodeNumber = nodeNum;
-    m_Start = startidx;
-    m_End = endidx;
-    m_NodeRanges = nodeRanges;
-    m_NodesRectBounds = rectBounds;
-  }
-
-  /**
-   * Gets the splitting dimension.
-   *
-   * @return splitting dimension
-   */
-  public int getSplitDim() {
-    return m_SplitDim;
-  }
-
-  /**
-   * Gets the splitting value.
-   *
-   * @return splitting value
-   */
-  public double getSplitValue() {
-    return m_SplitValue;
-  }
-
-  /**
-   * Checks if node is a leaf.
-   *
-   * @return true if it is a leaf
-   */
-  public boolean isALeaf() {
-    return (m_Left == null);
-  }
-
-  /**
-   * Returns the number of Instances
-   * in the rectangular region defined
-   * by this node.
-   *
-   * @return The number of instances in
-   * this KDTreeNode.
-   */
-  public int numInstances() {
-    return (m_End - m_Start + 1);
-  }
-
-}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KDTreeNodeSplitter.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KDTreeNodeSplitter.java
deleted file mode 100644
index 61126b4a0..000000000
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KDTreeNodeSplitter.java
+++ /dev/null
@@ -1,242 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/*
- * KDTreeNodeSplitter.java
- * Copyright (C) 1999-2012 University of Waikato
- */
-
-package moa.classifiers.lazy.neighboursearch.kdtrees;
-
-import java.io.Serializable;
-import java.util.Enumeration;
-import java.util.Vector;
-
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
-import moa.classifiers.lazy.neighboursearch.EuclideanDistance;
-
-/**
- * Class that splits up a KDTreeNode.
- * 
- * @author Ashraf M. Kibriya (amk14[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
- * @version $Revision: 8034 $
- */
-public abstract class KDTreeNodeSplitter
-  implements Serializable {
-  
-  /** The instances that'll be used for tree construction. */
-  protected InstancesHeader m_Instances;
-  
-  /** The distance function used for building the tree. */
-  protected EuclideanDistance m_EuclideanDistance;
-  
-  /** 
-   * The master index array that'll be reshuffled as nodes
-   * are split and the tree is constructed. 
-   */
-  protected int[] m_InstList;
-  
-  /** 
-   * Stores whether if the width of a KDTree
-   * node is normalized or not.
-   */
-  protected boolean m_NormalizeNodeWidth;
- 
-  // Constants
-  /** Index of min value in an array of attributes' range. */
-  public static final int MIN   = EuclideanDistance.R_MIN;
-
-  /** Index of max value in an array of attributes' range. */
-  public static final int MAX   = EuclideanDistance.R_MAX;
-  
-  /** Index of width value (max-min) in an array of attributes' range. */
-  public static final int WIDTH = EuclideanDistance.R_WIDTH;
-
-  /**
-   * default constructor.
-   */
-  public KDTreeNodeSplitter() {
-  }
-  
-  /**
-   * Creates a new instance of KDTreeNodeSplitter.
-   * @param instList Reference of the master index array.
-   * @param insts The set of training instances on which 
-   * the tree is built.
-   * @param e The EuclideanDistance object that is used
-   * in tree contruction.
-   */
-  public KDTreeNodeSplitter(int[] instList, InstancesHeader insts, EuclideanDistance e) { 
-    m_InstList = instList;
-    m_Instances = insts;
-    m_EuclideanDistance = e;
-  }
-
-  /**
-   * Returns an enumeration describing the available options.
-   *
-   * @return 		an enumeration of all the available options.
-   */
-  public Enumeration listOptions() {
-    return new Vector().elements();
-  }
-
-  /**
-   * Parses a given list of options.
-   * 
-   * @param options 	the list of options as an array of strings
-   * @throws Exception 	if an option is not supported
-   */
-  public void setOptions(String[] options) throws Exception {
-  }
-
-  /**
-   * Gets the current settings of the object.
-   *
-   * @return 		an array of strings suitable for passing to setOptions
-   */
-  public String[] getOptions() {
-    return new String[0];
-  }
-
-  /** 
-   * Checks whether an object of this class has been correctly
-   * initialized. Performs checks to see if all the necessary
-   * things (master index array, training instances, distance
-   * function) have been supplied or not.
-   * @throws Exception If the object has not been correctly 
-   * initialized.
-   */
-  protected void correctlyInitialized() throws Exception {
-    if(m_Instances==null)
-      throw new Exception("No instances supplied.");
-    else if(m_InstList==null) 
-      throw new Exception("No instance list supplied.");
-    else if(m_EuclideanDistance==null)
-      throw new Exception("No Euclidean distance function supplied.");
-    else if(m_Instances.numInstances() != m_InstList.length)
-      throw new Exception("The supplied instance list doesn't seem to match " +
-                          "the supplied instances");
-  }
-  
-  /** 
-   * Splits a node into two. After splitting two new nodes are created
-   * and correctly initialised. And, node.left and node.right are 
-   * set appropriately.
-   * @param node The node to split.
-   * @param numNodesCreated The number of nodes that so far have been
-   * created for the tree, so that the newly created nodes are 
-   * assigned correct/meaningful node numbers/ids.
-   * @param nodeRanges The attributes' range for the points inside
-   * the node that is to be split.
-   * @param universe The attributes' range for the whole 
-   * point-space.
-   * @throws Exception If there is some problem in splitting the
-   * given node.
-   */
-  public abstract void splitNode(KDTreeNode node, int numNodesCreated, 
-      				 double[][] nodeRanges, double[][] universe) 
-  throws Exception;
-  
-  /**
-   * Sets the training instances on which the tree is (or is 
-   * to be) built. 
-   * @param inst The training instances.
-   */
-  public void setInstances(InstancesHeader inst) {
-    m_Instances = inst;
-  }
-  
-  /** 
-   * Sets the master index array containing indices of the
-   * training instances. This array will be rearranged as 
-   * the tree is built, so that each node is assigned a 
-   * portion in this array which contain the instances 
-   * insides the node's region.
-   * @param instList The master index array.
-   */
-  public void setInstanceList(int[] instList) {
-    m_InstList = instList;
-  }
-  
-  /**
-   * Sets the EuclideanDistance object to use for 
-   * splitting nodes.
-   * @param func The EuclideanDistance object.
-   */
-  public void setEuclideanDistanceFunction(EuclideanDistance func) {
-    m_EuclideanDistance = func;
-  }
-
-  /**
-   * Sets whether if a nodes region is normalized 
-   * or not. If set to true then, when selecting 
-   * the widest attribute/dimension for splitting, 
-   * the width of each attribute/dimension,
-   * of the points inside the node's region, is 
-   * divided by the width of that 
-   * attribute/dimension for the whole point-space.
-   * Thus, each attribute/dimension of that node
-   * is normalized.
-   *   
-   * @param normalize Should be true if 
-   * normalization is required.
-   */
-  public void setNodeWidthNormalization(boolean normalize) {
-    m_NormalizeNodeWidth = normalize;
-  }
-  
-  /**
-   * Returns the widest dimension. The width of each 
-   * dimension (for the points inside the node) is 
-   * normalized, if m_NormalizeNodeWidth is set to 
-   * true.
-   * @param nodeRanges The attributes' range of the 
-   * points inside the node that is to be split.
-   * @param universe The attributes' range for the
-   * whole point-space.
-   * @return The index of the attribute/dimension
-   * in which the points of the node have widest
-   * spread.
-   */
-  protected int widestDim(double[][] nodeRanges, double[][] universe) {
-    final int classIdx = m_Instances.classIndex();
-    double widest = 0.0;
-    int w = -1;
-    if (m_NormalizeNodeWidth) {
-      for (int i = 0; i < nodeRanges.length; i++) {
-        double newWidest = nodeRanges[i][WIDTH] / universe[i][WIDTH];
-        if (newWidest > widest) {
-          if (i == classIdx)
-            continue;
-          widest = newWidest;
-          w = i;
-        }
-      }
-    } else {
-      for (int i = 0; i < nodeRanges.length; i++) {
-        if (nodeRanges[i][WIDTH] > widest) {
-          if (i == classIdx)
-            continue;
-          widest = nodeRanges[i][WIDTH];
-          w = i;
-        }
-      }
-    }
-    return w;
-  }
-  
-}
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KMeansInpiredMethod.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KMeansInpiredMethod.java
deleted file mode 100644
index 6d834c9be..000000000
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/KMeansInpiredMethod.java
+++ /dev/null
@@ -1,348 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/*
- * KMeansInpiredMethod.java
- * Copyright (C) 2007-2012 University of Waikato, Hamilton, New Zealand
- */
-
-package moa.classifiers.lazy.neighboursearch.kdtrees;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
-/**
- <!-- globalinfo-start -->
- * The class that splits a node into two such that the overall sum of squared distances of points to their centres on both sides of the (axis-parallel) splitting plane is minimum.<br/>
- * <br/>
- * For more information see also:<br/>
- * <br/>
- * Ashraf Masood Kibriya (2007). Fast Algorithms for Nearest Neighbour Search. Hamilton, New Zealand.
- * <p/>
- <!-- globalinfo-end -->
- *
- <!-- technical-bibtex-start -->
- * BibTeX:
- * <pre>
- * &#64;mastersthesis{Kibriya2007,
- *    address = {Hamilton, New Zealand},
- *    author = {Ashraf Masood Kibriya},
- *    school = {Department of Computer Science, School of Computing and Mathematical Sciences, University of Waikato},
- *    title = {Fast Algorithms for Nearest Neighbour Search},
- *    year = {2007}
- * }
- * </pre>
- * <p/>
- <!-- technical-bibtex-end -->
- *
- <!-- options-start -->
- <!-- options-end -->
- *
- * @author Ashraf M. Kibriya (amk14[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
- * @version $Revision: 8034 $
- */
-public class KMeansInpiredMethod
-  extends KDTreeNodeSplitter {
-  
-  /** for serialization. */
-  private static final long serialVersionUID = -866783749124714304L;
-
-  /**
-   * Returns a string describing this nearest neighbour search algorithm.
-   * 
-   * @return 		a description of the algorithm for displaying in the
-   *         		explorer/experimenter gui
-   */
-  public String globalInfo() {
-    return 
-        "The class that splits a node into two such that the overall sum "
-      + "of squared distances of points to their centres on both sides " 
-      + "of the (axis-parallel) splitting plane is minimum.\n\n"
-      + "For more information see also:\n\n";
-  }
-
- 
-
-  /** 
-   * Splits a node into two such that the overall sum of squared distances 
-   * of points to their centres on both sides of the (axis-parallel) 
-   * splitting plane is minimum. The two nodes created after the whole 
-   * splitting are correctly initialised. And, node.left and node.right 
-   * are set appropriately.
-   * @param node The node to split.
-   * @param numNodesCreated The number of nodes that so far have been
-   * created for the tree, so that the newly created nodes are 
-   * assigned correct/meaningful node numbers/ids.
-   * @param nodeRanges The attributes' range for the points inside
-   * the node that is to be split.
-   * @param universe The attributes' range for the whole 
-   * point-space.
-   * @throws Exception If there is some problem in splitting the
-   * given node.
-   */
-  public void splitNode(KDTreeNode node, int numNodesCreated,
-      double[][] nodeRanges, double[][] universe) throws Exception {
-
-    correctlyInitialized();
-
-    int splitDim = -1;
-    double splitVal = Double.NEGATIVE_INFINITY;
-
-    double leftAttSum[] = new double[m_Instances.numAttributes()], 
-           rightAttSum[] = new double[m_Instances.numAttributes()], 
-           leftAttSqSum[] = new double[m_Instances.numAttributes()], 
-           rightAttSqSum[] = new double[m_Instances.numAttributes()], 
-           rightSqMean, leftSqMean, leftSqSum, rightSqSum, 
-           minSum = Double.POSITIVE_INFINITY, val;
-
-    for (int dim = 0; dim < m_Instances.numAttributes(); dim++) {
-      // m_MaxRelativeWidth in KDTree ensure there'll be atleast one dim with
-      // width > 0.0
-      if (node.m_NodeRanges[dim][WIDTH] == 0.0
-          || dim == m_Instances.classIndex())
-        continue;
-
-      quickSort(m_Instances, m_InstList, dim, node.m_Start, node.m_End);
-
-      for (int i = node.m_Start; i <= node.m_End; i++) {
-        for (int j = 0; j < m_Instances.numAttributes(); j++) {
-          if (j == m_Instances.classIndex())
-            continue;
-          val = m_Instances.instance(m_InstList[i]).value(j);
-          if (m_NormalizeNodeWidth) {
-            if (Double.isNaN(universe[j][MIN])
-                || universe[j][MIN] == universe[j][MAX])
-              val = 0.0;
-            else
-              val = ((val - universe[j][MIN]) / universe[j][WIDTH]); // normalizing
-                                                                      // value
-          }
-          if (i == node.m_Start) {
-            leftAttSum[j] = rightAttSum[j] = leftAttSqSum[j] = rightAttSqSum[j] = 0.0;
-          }
-          rightAttSum[j] += val;
-          rightAttSqSum[j] += val * val;
-        }
-      }
-
-      for (int i = node.m_Start; i <= node.m_End - 1; i++) {
-        Instance inst = m_Instances.instance(m_InstList[i]);
-        leftSqSum = rightSqSum = 0.0;
-        for (int j = 0; j < m_Instances.numAttributes(); j++) {
-          if (j == m_Instances.classIndex())
-            continue;
-          val = inst.value(j);
-
-          if (m_NormalizeNodeWidth) {
-            if (Double.isNaN(universe[j][MIN])
-                || universe[j][MIN] == universe[j][MAX])
-              val = 0.0;
-            else
-              val = ((val - universe[j][MIN]) / universe[j][WIDTH]); // normalizing
-                                                                      // value
-          }
-
-          leftAttSum[j] += val;
-          rightAttSum[j] -= val;
-          leftAttSqSum[j] += val * val;
-          rightAttSqSum[j] -= val * val;
-          leftSqMean = leftAttSum[j] / (i - node.m_Start + 1);
-          leftSqMean *= leftSqMean;
-          rightSqMean = rightAttSum[j] / (node.m_End - i);
-          rightSqMean *= rightSqMean;
-
-          leftSqSum += leftAttSqSum[j] - (i - node.m_Start + 1) * leftSqMean;
-          rightSqSum += rightAttSqSum[j] - (node.m_End - i) * rightSqMean;
-        }
-
-        if (minSum > (leftSqSum + rightSqSum)) {
-          minSum = leftSqSum + rightSqSum;
-
-          if (i < node.m_End)
-            splitVal = (m_Instances.instance(m_InstList[i]).value(dim) + m_Instances
-                .instance(m_InstList[i + 1]).value(dim)) / 2;
-          else
-            splitVal = m_Instances.instance(m_InstList[i]).value(dim);
-
-          splitDim = dim;
-        }
-      }// end for instance i
-    }// end for attribute dim
-
-    int rightStart = rearrangePoints(m_InstList, node.m_Start, node.m_End,
-        splitDim, splitVal);
-
-    if (rightStart == node.m_Start || rightStart > node.m_End) {
-      System.out.println("node.m_Start: " + node.m_Start + " node.m_End: "
-          + node.m_End + " splitDim: " + splitDim + " splitVal: " + splitVal
-          + " node.min: " + node.m_NodeRanges[splitDim][MIN] + " node.max: "
-          + node.m_NodeRanges[splitDim][MAX] + " node.numInstances: "
-          + node.numInstances());
-
-      if (rightStart == node.m_Start)
-        throw new Exception("Left child is empty in node " + node.m_NodeNumber
-            + ". Not possible with "
-            + "KMeanInspiredMethod splitting method. Please " + "check code.");
-      else
-        throw new Exception("Right child is empty in node " + node.m_NodeNumber
-            + ". Not possible with "
-            + "KMeansInspiredMethod splitting method. Please " + "check code.");
-    }
-
-    node.m_SplitDim = splitDim;
-    node.m_SplitValue = splitVal;
-    node.m_Left = new KDTreeNode(numNodesCreated + 1, node.m_Start,
-        rightStart - 1, m_EuclideanDistance.initializeRanges(m_InstList,
-            node.m_Start, rightStart - 1));
-    node.m_Right = new KDTreeNode(numNodesCreated + 2, rightStart, node.m_End,
-        m_EuclideanDistance
-            .initializeRanges(m_InstList, rightStart, node.m_End));
-  }
-
-  /**
-   * Partitions the instances around a pivot. Used by quicksort and
-   * kthSmallestValue.
-   *
-   * @param insts	The instances on which the tree is (or is 
-   * to be) built.
-   * @param index The master index array containing indices 
-   * of the instances.
-   * @param attidx The attribution/dimension based on which
-   * the instances should be partitioned.
-   * @param l	The begining index of the portion of master index 
-   * array that should be partitioned. 
-   * @param r	The end index of the portion of master index array 
-   * that should be partitioned.
-   * @return the index of the middle element
-   */
-  protected static int partition(InstancesHeader insts, int[] index, int attidx, int l, int r) {
-    
-    double pivot = insts.instance(index[(l + r) / 2]).value(attidx);
-    int help;
-
-    while (l < r) {
-      while ((insts.instance(index[l]).value(attidx) < pivot) && (l < r)) {
-        l++;
-      }
-      while ((insts.instance(index[r]).value(attidx) > pivot) && (l < r)) {
-        r--;
-      }
-      if (l < r) {
-        help = index[l];
-        index[l] = index[r];
-        index[r] = help;
-        l++;
-        r--;
-      }
-    }
-    if ((l == r) && (insts.instance(index[r]).value(attidx) > pivot)) {
-      r--;
-    } 
-
-    return r;
-  }
-  
-  /**
-   * Sorts the instances according to the given attribute/dimension.
-   * The sorting is done on the master index array and not on the
-   * actual instances object.
-   * 
-   * @param insts The instances on which the tree is (or is 
-   * to be) built.
-   * @param indices The master index array containing indices 
-   * of the instances.
-   * @param attidx The dimension/attribute based on which 
-   * the instances should be sorted.
-   * @param left The begining index of the portion of the master 
-   * index array that needs to be sorted.
-   * @param right The end index of the portion of the master index 
-   * array that needs to be sorted.
-   */
-  protected static void quickSort(InstancesHeader insts, int[] indices, int attidx, int left, int right) {
-
-    if (left < right) {
-      int middle = partition(insts, indices, attidx, left, right);
-      quickSort(insts, indices, attidx, left, middle);
-      quickSort(insts, indices, attidx, middle + 1, right);
-    }
-  }  
-
-  /**
-   * Method to validate the sorting done by quickSort().
-   * 
-   * @param insts The instances on which the tree is (or is 
-   * to be) built.
-   * @param indices The master index array containing indices 
-   * of the instances.
-   * @param attidx The dimension/attribute based on which 
-   * the instances should be sorted.
-   * @param start The start of the portion in master index
-   * array that needs to be sorted.
-   * @param end The end of the portion in master index 
-   * array that needs to be sorted.
-   * @throws Exception If the indices of the instances 
-   * are not in sorted order.
-   */
-  private static void checkSort(InstancesHeader insts, int[] indices, int attidx, 
-                               int start, int end) throws Exception {
-    for(int i=start+1; i<=end; i++) {
-      if( insts.instance(indices[i-1]).value(attidx) > 
-          insts.instance(indices[i]).value(attidx) ) {
-        System.out.println("value[i-1]: "+insts.instance(indices[i-1]).value(attidx));
-        System.out.println("value[i]: "+insts.instance(indices[i]).value(attidx));
-        System.out.println("indices[i-1]: "+indices[i-1]);
-        System.out.println("indices[i]: "+indices[i]);
-        System.out.println("i: "+i);
-        if(insts.instance(indices[i-1]).value(attidx) > insts.instance(indices[i]).value(attidx))
-          System.out.println("value[i-1] > value[i]");
-        
-        throw new Exception("Indices not sorted correctly.");
-      }//end if
-    }
-  }
-  
-  /** 
-   * Re-arranges the indices array so that in the portion of the array
-   * belonging to the node to be split, the points <= to the splitVal 
-   * are on the left of the portion and those > the splitVal are on the right.
-   * 
-   * @param indices The master index array.
-   * @param startidx The begining index of portion of indices that needs 
-   * re-arranging. 
-   * @param endidx The end index of portion of indices that needs 
-   * re-arranging. 
-   * @param splitDim The split dimension/attribute.
-   * @param splitVal The split value.
-   * @return The startIdx of the points > the splitVal (the points 
-   * belonging to the right child of the node).
-   */
-  protected int rearrangePoints(int[] indices, final int startidx, final int endidx,
-      			      final int splitDim, final double splitVal) {
-    
-    int tmp, left = startidx - 1;
-    for (int i = startidx; i <= endidx; i++) {
-      if (m_EuclideanDistance.valueIsSmallerEqual(m_Instances
-          .instance(indices[i]), splitDim, splitVal)) {
-        left++;
-        tmp = indices[left];
-        indices[left] = indices[i];
-        indices[i] = tmp;
-      }// end valueIsSmallerEqual
-    }// endfor
-    return left + 1;
-  }
-  
-
-}
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/MedianOfWidestDimension.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/MedianOfWidestDimension.java
deleted file mode 100644
index 21ede06f2..000000000
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/MedianOfWidestDimension.java
+++ /dev/null
@@ -1,189 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/*
- * MedianOfWidestDimension.java
- * Copyright (C) 2007-2012 University of Waikato, Hamilton, New Zealand
- */
-
-package moa.classifiers.lazy.neighboursearch.kdtrees;
-
-/**
- <!-- globalinfo-start -->
- * The class that splits a KDTree node based on the median value of a dimension in which the node's points have the widest spread.<br/>
- * <br/>
- * For more information see also:<br/>
- * <br/>
- * Jerome H. Friedman, Jon Luis Bentley, Raphael Ari Finkel (1977). An Algorithm for Finding Best Matches in Logarithmic Expected Time. ACM Transactions on Mathematics Software. 3(3):209-226.
- * <p/>
- <!-- globalinfo-end -->
- *
- <!-- technical-bibtex-start -->
- * BibTeX:
- * <pre>
- * &#64;article{Friedman1977,
- *    author = {Jerome H. Friedman and Jon Luis Bentley and Raphael Ari Finkel},
- *    journal = {ACM Transactions on Mathematics Software},
- *    month = {September},
- *    number = {3},
- *    pages = {209-226},
- *    title = {An Algorithm for Finding Best Matches in Logarithmic Expected Time},
- *    volume = {3},
- *    year = {1977}
- * }
- * </pre>
- * <p/>
- <!-- technical-bibtex-end -->
- *
- <!-- options-start -->
- <!-- options-end -->
- *
- * @author Ashraf M. Kibriya (amk14[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
- * @version $Revision: 8034 $
- */
-public class MedianOfWidestDimension
-  extends KDTreeNodeSplitter  {
-
-  /** for serialization. */
-  private static final long serialVersionUID = 1383443320160540663L;
-
-  /**
-   * Returns a string describing this nearest neighbour search algorithm.
-   * 
-   * @return 		a description of the algorithm for displaying in the
-   *         		explorer/experimenter gui
-   */
-  public String globalInfo() {
-    return 
-        "The class that splits a KDTree node based on the median value of "
-      + "a dimension in which the node's points have the widest spread.\n\n"
-      + "For more information see also:\n\n";
-  }
-
- 
-  
-  /** 
-   * Splits a node into two based on the median value of the dimension 
-   * in which the points have the widest spread. After splitting two 
-   * new nodes are created and correctly initialised. And, node.left 
-   * and node.right are set appropriately.
-   * 
-   * @param node The node to split.
-   * @param numNodesCreated The number of nodes that so far have been
-   * created for the tree, so that the newly created nodes are 
-   * assigned correct/meaningful node numbers/ids.
-   * @param nodeRanges The attributes' range for the points inside
-   * the node that is to be split.
-   * @param universe The attributes' range for the whole 
-   * point-space.
-   * @throws Exception If there is some problem in splitting the
-   * given node.
-   */
-  public void splitNode(KDTreeNode node, int numNodesCreated, 
-      			double[][] nodeRanges, double[][] universe) throws Exception {
-    
-    correctlyInitialized();
-    
-    int splitDim = widestDim(nodeRanges, universe);
-    
-    //In this case median is defined to be either the middle value (in case of
-    //odd number of values) or the left of the two middle values (in case of 
-    //even number of values).
-    int medianIdxIdx = node.m_Start + (node.m_End-node.m_Start)/2;
-    //the following finds the median and also re-arranges the array so all 
-    //elements to the left are < median and those to the right are > median.
-    int medianIdx = select(splitDim, m_InstList, node.m_Start, node.m_End, (node.m_End-node.m_Start)/2+1);
-    
-    
-    node.m_SplitDim = splitDim;
-    node.m_SplitValue = m_Instances.instance(m_InstList[medianIdx]).value(splitDim);
-    
-    node.m_Left  = new KDTreeNode(numNodesCreated+1, node.m_Start, medianIdxIdx,
-	m_EuclideanDistance.initializeRanges(m_InstList, node.m_Start, medianIdxIdx));
-    node.m_Right = new KDTreeNode(numNodesCreated+2, medianIdxIdx+1, node.m_End,
-	m_EuclideanDistance.initializeRanges(m_InstList, medianIdxIdx+1, node.m_End));	
-  }
-  
-  /**
-   * Partitions the instances around a pivot. Used by quicksort and
-   * kthSmallestValue.
-   *
-   * @param attIdx The attribution/dimension based on which the 
-   * instances should be partitioned.
-   * @param index The master index array containing indices of the 
-   * instances.
-   * @param l The begining index of the portion of master index 
-   * array that should be partitioned. 
-   * @param r The end index of the portion of master index array 
-   * that should be partitioned.
-   * @return the index of the middle element
-   */
-  protected int partition(int attIdx, int[] index, int l, int r) {
-    
-    double pivot = m_Instances.instance(index[(l + r) / 2]).value(attIdx);
-    int help;
-
-    while (l < r) {
-      while ((m_Instances.instance(index[l]).value(attIdx) < pivot) && (l < r)) {
-        l++;
-      }
-      while ((m_Instances.instance(index[r]).value(attIdx) > pivot) && (l < r)) {
-        r--;
-      }
-      if (l < r) {
-        help = index[l];
-        index[l] = index[r];
-        index[r] = help;
-        l++;
-        r--;
-      }
-    }
-    if ((l == r) && (m_Instances.instance(index[r]).value(attIdx) > pivot)) {
-      r--;
-    } 
-
-    return r;
-  }
-
-  /**
-   * Implements computation of the kth-smallest element according
-   * to Manber's "Introduction to Algorithms".
-   *
-   * @param attIdx The dimension/attribute of the instances in 
-   * which to find the kth-smallest element.
-   * @param indices The master index array containing indices of 
-   * the instances.
-   * @param left The begining index of the portion of the master 
-   * index array in which to find the kth-smallest element.
-   * @param right The end index of the portion of the master index 
-   * array in which to find the kth-smallest element.
-   * @param k The value of k
-   * @return The index of the kth-smallest element
-   */
-  public int select(int attIdx, int[] indices, int left, int right, int k) {
-    
-    if (left == right) {
-      return left;
-    } else {
-      int middle = partition(attIdx, indices, left, right);
-      if ((middle - left + 1) >= k) {
-        return select(attIdx, indices, left, middle, k);
-      } else {
-        return select(attIdx, indices, middle + 1, right, k - (middle - left + 1));
-      }
-    }
-  }
-  
-}
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/MidPointOfWidestDimension.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/MidPointOfWidestDimension.java
deleted file mode 100644
index 22d60ebf0..000000000
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/MidPointOfWidestDimension.java
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/*
- * MidPointOfWidestDimension.java
- * Copyright (C) 2007-2012 University of Waikato, Hamilton, New Zealand
- */
-
-package moa.classifiers.lazy.neighboursearch.kdtrees;
-
-/**
- <!-- globalinfo-start -->
- * The class that splits a KDTree node based on the midpoint value of a dimension in which the node's points have the widest spread.<br/>
- * <br/>
- * For more information see also:<br/>
- * <br/>
- * Andrew Moore (1991). A tutorial on kd-trees.
- * <p/>
- <!-- globalinfo-end -->
- *
- <!-- technical-bibtex-start -->
- * BibTeX:
- * <pre>
- * &#64;techreport{Moore1991,
- *    author = {Andrew Moore},
- *    booktitle = {University of Cambridge Computer Laboratory Technical Report No. 209},
- *    howpublished = {Extract from PhD Thesis},
- *    title = {A tutorial on kd-trees},
- *    year = {1991},
- *    HTTP = {http://www.autonlab.org/autonweb/14665.html}
- * }
- * </pre>
- * <p/>
- <!-- technical-bibtex-end -->
- *
- <!-- options-start -->
- <!-- options-end -->
- *
- * @author Ashraf M. Kibriya (amk14[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
- * @version $Revision: 8034 $
- */
-public class MidPointOfWidestDimension
-  extends KDTreeNodeSplitter  {
-
-  /** for serialization. */
-  private static final long serialVersionUID = -7617277960046591906L;
-
-  /**
-   * Returns a string describing this nearest neighbour search algorithm.
-   * 
-   * @return 		a description of the algorithm for displaying in the
-   *         		explorer/experimenter gui
-   */
-  public String globalInfo() {
-    return 
-        "The class that splits a KDTree node based on the midpoint value of "
-      + "a dimension in which the node's points have the widest spread.\n\n"
-      + "For more information see also:\n\n";
-  }
-
-  
-  /** 
-   * Splits a node into two based on the midpoint value of the dimension 
-   * in which the points have the widest spread. After splitting two 
-   * new nodes are created and correctly initialised. And, node.left 
-   * and node.right are set appropriately.  
-   * @param node The node to split.
-   * @param numNodesCreated The number of nodes that so far have been
-   * created for the tree, so that the newly created nodes are 
-   * assigned correct/meaningful node numbers/ids.
-   * @param nodeRanges The attributes' range for the points inside
-   * the node that is to be split.
-   * @param universe The attributes' range for the whole 
-   * point-space.
-   * @throws Exception If there is some problem in splitting the
-   * given node.
-   */
-  public void splitNode(KDTreeNode node, int numNodesCreated, 
-      			double[][] nodeRanges, double[][] universe) throws Exception {
-    
-    correctlyInitialized();
-
-    int splitDim = widestDim(nodeRanges, universe);
-
-    double splitVal = m_EuclideanDistance.getMiddle(nodeRanges[splitDim]);
-
-    int rightStart = rearrangePoints(m_InstList, node.m_Start, node.m_End,
-        splitDim, splitVal);
-
-    if (rightStart == node.m_Start || rightStart > node.m_End) {
-      if (rightStart == node.m_Start)
-        throw new Exception("Left child is empty in node " 
-                            + node.m_NodeNumber + 
-                            ". Not possible with " + 
-                            "MidPointofWidestDim splitting method. Please " + 
-                            "check code.");
-      else
-        throw new Exception("Right child is empty in node " + node.m_NodeNumber + 
-                            ". Not possible with " + 
-                            "MidPointofWidestDim splitting method. Please " + 
-                            "check code.");
-    }
-    
-    node.m_SplitDim = splitDim;
-    node.m_SplitValue = splitVal;
-    node.m_Left = new KDTreeNode(numNodesCreated + 1, node.m_Start,
-        rightStart - 1, m_EuclideanDistance.initializeRanges(m_InstList,
-            node.m_Start, rightStart - 1));
-    node.m_Right = new KDTreeNode(numNodesCreated + 2, rightStart, node.m_End,
-        m_EuclideanDistance
-            .initializeRanges(m_InstList, rightStart, node.m_End));	
-  }
-  
-  /** 
-   * Re-arranges the indices array such that the points <= to the splitVal 
-   * are on the left of the array and those > the splitVal are on the right.
-   * 
-   * @param indices The master index array.
-   * @param startidx The begining index of portion of indices that needs 
-   * re-arranging. 
-   * @param endidx The end index of portion of indices that needs 
-   * re-arranging. 
-   * @param splitDim The split dimension/attribute.
-   * @param splitVal The split value.
-   * @return The startIdx of the points > the splitVal (the points 
-   * belonging to the right child of the node).
-   */
-  protected int rearrangePoints(int[] indices, final int startidx, final int endidx,
-      			      final int splitDim, final double splitVal) {
-    
-    int tmp, left = startidx - 1;
-    for (int i = startidx; i <= endidx; i++) {
-      if (m_EuclideanDistance.valueIsSmallerEqual(m_Instances
-          .instance(indices[i]), splitDim, splitVal)) {
-        left++;
-        tmp = indices[left];
-        indices[left] = indices[i];
-        indices[i] = tmp;
-      }//end if valueIsSmallerEqual
-    }//end for
-    return left + 1;
-  }
-  
-}
diff --git a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/SlidingMidPointOfWidestSide.java b/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/SlidingMidPointOfWidestSide.java
deleted file mode 100644
index 54a275320..000000000
--- a/moa/src/main/java/moa/classifiers/lazy/neighboursearch/kdtrees/SlidingMidPointOfWidestSide.java
+++ /dev/null
@@ -1,229 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/*
- * SlidingMidPointOfWidestSide.java
- * Copyright (C) 2007-2012 University of Waikato, Hamilton, New Zealand
- */
-
-package moa.classifiers.lazy.neighboursearch.kdtrees;
-
-
-/**
- <!-- globalinfo-start -->
- * The class that splits a node into two based on the midpoint value of the dimension in which the node's rectangle is widest. If after splitting one side is empty then it is slided towards the non-empty side until there is at least one point on the empty side.<br/>
- * <br/>
- * For more information see also:<br/>
- * <br/>
- * David M. Mount (2006). ANN Programming Manual. College Park, MD, USA.
- * <p/>
- <!-- globalinfo-end -->
- *
- <!-- technical-bibtex-start -->
- * BibTeX:
- * <pre>
- * &#64;manual{Mount2006,
- *    address = {College Park, MD, USA},
- *    author = {David M. Mount},
- *    organization = {Department of Computer Science, University of Maryland},
- *    title = {ANN Programming Manual},
- *    year = {2006},
- *    HTTP = {Available from http://www.cs.umd.edu/\~mount/ANN/}
- * }
- * </pre>
- * <p/>
- <!-- technical-bibtex-end -->
- *
- <!-- options-start -->
- <!-- options-end -->
- *
- * @author  Ashraf M. Kibriya (amk14@waikato.ac.nz)
- * @version $Revision: 8034 $
- */
-public class SlidingMidPointOfWidestSide
-  extends KDTreeNodeSplitter  {
-
-  /** for serialization. */
-  private static final long serialVersionUID = 852857628205680562L;
-
-  /** The floating point error to tolerate in finding the widest 
-   * rectangular side. */
-  protected static double ERR = 0.001;
-
-  /**
-   * Returns a string describing this nearest neighbour search algorithm.
-   * 
-   * @return 		a description of the algorithm for displaying in the
-   *         		explorer/experimenter gui
-   */
-  public String globalInfo() {
-    return 
-        "The class that splits a node into two based on the midpoint value of "
-      + "the dimension in which the node's rectangle is widest. If after "
-      + "splitting one side is empty then it is slided towards the non-empty "
-      + "side until there is at least one point on the empty side.\n\n"
-      + "For more information see also:\n\n";
-  }
-  
-
-  /** 
-   * Splits a node into two based on the midpoint value of the dimension 
-   * in which the node's rectangle is widest. If after splitting one side
-   * is empty then it is slided towards the non-empty side until there is 
-   * at least one point on the empty side. The two nodes created after the 
-   * whole splitting are correctly initialised. And, node.left and 
-   * node.right are set appropriately.  
-   * @param node The node to split.
-   * @param numNodesCreated The number of nodes that so far have been
-   * created for the tree, so that the newly created nodes are 
-   * assigned correct/meaningful node numbers/ids.
-   * @param nodeRanges The attributes' range for the points inside
-   * the node that is to be split.
-   * @param universe The attributes' range for the whole 
-   * point-space.
-   * @throws Exception If there is some problem in splitting the
-   * given node.
-   */
-  public void splitNode(KDTreeNode node, int numNodesCreated,
-      double[][] nodeRanges, double[][] universe) throws Exception {
-
-    correctlyInitialized();
-
-    if (node.m_NodesRectBounds == null) {
-      node.m_NodesRectBounds = new double[2][node.m_NodeRanges.length];
-      for (int i = 0; i < node.m_NodeRanges.length; i++) {
-        node.m_NodesRectBounds[MIN][i] = node.m_NodeRanges[i][MIN];
-        node.m_NodesRectBounds[MAX][i] = node.m_NodeRanges[i][MAX];
-      }
-    }
-
-    // finding widest side of the hyper rectangle
-    double maxRectWidth = Double.NEGATIVE_INFINITY, maxPtWidth = Double.NEGATIVE_INFINITY, tempval;
-    int splitDim = -1, classIdx = m_Instances.classIndex();
-
-    for (int i = 0; i < node.m_NodesRectBounds[0].length; i++) {
-      if (i == classIdx)
-        continue;
-      tempval = node.m_NodesRectBounds[MAX][i] - node.m_NodesRectBounds[MIN][i];
-      if (m_NormalizeNodeWidth) {
-        tempval = tempval / universe[i][WIDTH];
-      }
-      if (tempval > maxRectWidth && node.m_NodeRanges[i][WIDTH] > 0.0)
-        maxRectWidth = tempval;
-    }
-
-    for (int i = 0; i < node.m_NodesRectBounds[0].length; i++) {
-      if (i == classIdx)
-        continue;
-      tempval = node.m_NodesRectBounds[MAX][i] - node.m_NodesRectBounds[MIN][i];
-      if (m_NormalizeNodeWidth) {
-        tempval = tempval / universe[i][WIDTH];
-      }
-      if (tempval >= maxRectWidth * (1 - ERR)
-          && node.m_NodeRanges[i][WIDTH] > 0.0) {
-        if (node.m_NodeRanges[i][WIDTH] > maxPtWidth) {
-          maxPtWidth = node.m_NodeRanges[i][WIDTH];
-          if (m_NormalizeNodeWidth)
-            maxPtWidth = maxPtWidth / universe[i][WIDTH];
-          splitDim = i;
-        }
-      }
-    }
-
-    double splitVal = node.m_NodesRectBounds[MIN][splitDim]
-        + (node.m_NodesRectBounds[MAX][splitDim] - node.m_NodesRectBounds[MIN][splitDim])
-        * 0.5;
-    // might want to try to slide it further to contain more than one point on
-    // the
-    // side that is resulting empty
-    if (splitVal < node.m_NodeRanges[splitDim][MIN])
-      splitVal = node.m_NodeRanges[splitDim][MIN];
-    else if (splitVal >= node.m_NodeRanges[splitDim][MAX])
-      splitVal = node.m_NodeRanges[splitDim][MAX]
-          - node.m_NodeRanges[splitDim][WIDTH] * 0.001;
-
-    int rightStart = rearrangePoints(m_InstList, node.m_Start, node.m_End,
-        splitDim, splitVal);
-
-    if (rightStart == node.m_Start || rightStart > node.m_End) {
-      if (rightStart == node.m_Start)
-        throw new Exception("Left child is empty in node " + node.m_NodeNumber
-            + ". Not possible with "
-            + "SlidingMidPointofWidestSide splitting method. Please "
-            + "check code.");
-      else
-        throw new Exception("Right child is empty in node " + node.m_NodeNumber
-            + ". Not possible with "
-            + "SlidingMidPointofWidestSide splitting method. Please "
-            + "check code.");
-    }
-
-    node.m_SplitDim = splitDim;
-    node.m_SplitValue = splitVal;
-
-    double[][] widths = new double[2][node.m_NodesRectBounds[0].length];
-
-    System.arraycopy(node.m_NodesRectBounds[MIN], 0, widths[MIN], 0,
-        node.m_NodesRectBounds[MIN].length);
-    System.arraycopy(node.m_NodesRectBounds[MAX], 0, widths[MAX], 0,
-        node.m_NodesRectBounds[MAX].length);
-    widths[MAX][splitDim] = splitVal;
-
-    node.m_Left = new KDTreeNode(numNodesCreated + 1, node.m_Start,
-        rightStart - 1, m_EuclideanDistance.initializeRanges(m_InstList,
-            node.m_Start, rightStart - 1), widths);
-
-    widths = new double[2][node.m_NodesRectBounds[0].length];
-    System.arraycopy(node.m_NodesRectBounds[MIN], 0, widths[MIN], 0,
-        node.m_NodesRectBounds[MIN].length);
-    System.arraycopy(node.m_NodesRectBounds[MAX], 0, widths[MAX], 0,
-        node.m_NodesRectBounds[MAX].length);
-    widths[MIN][splitDim] = splitVal;
-
-    node.m_Right = new KDTreeNode(numNodesCreated + 2, rightStart, node.m_End,
-        m_EuclideanDistance.initializeRanges(m_InstList, rightStart, node.m_End), widths);
-  }
-  
-  /** 
-   * Re-arranges the indices array such that the points <= to the splitVal 
-   * are on the left of the array and those > the splitVal are on the right.
-   * 
-   * @param indices The master index array.
-   * @param startidx The begining index of portion of indices that needs 
-   * re-arranging. 
-   * @param endidx The end index of portion of indices that needs 
-   * re-arranging. 
-   * @param splitDim The split dimension/attribute.
-   * @param splitVal The split value.
-   * @return The startIdx of the points > the splitVal (the points 
-   * belonging to the right child of the node).
-   */
-  protected int rearrangePoints(int[] indices, final int startidx,
-      final int endidx, final int splitDim, final double splitVal) {
-
-    int tmp, left = startidx - 1;
-    for (int i = startidx; i <= endidx; i++) {
-      if (m_EuclideanDistance.valueIsSmallerEqual(m_Instances
-          .instance(indices[i]), splitDim, splitVal)) {
-        left++;
-        tmp = indices[left];
-        indices[left] = indices[i];
-        indices[i] = tmp;
-      }// end valueIsSmallerEqual
-    }// endfor
-    return left + 1;
-  }
-  
-}
diff --git a/moa/src/main/java/moa/classifiers/meta/ADACC.java b/moa/src/main/java/moa/classifiers/meta/ADACC.java
deleted file mode 100644
index 8a98a19e8..000000000
--- a/moa/src/main/java/moa/classifiers/meta/ADACC.java
+++ /dev/null
@@ -1,307 +0,0 @@
-/*
- *    ADACC.java
- *
- *    @author Ghazal Jaber (ghazal.jaber@gmail.com)
- * 
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.classifiers.meta;
-
-import java.util.Arrays;
-import java.util.Collections;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
-import moa.core.Measurement;
-import moa.core.Utils;
-import moa.learners.Classifier;
-
-/**
- * Anticipative and Dynamic Adaptation to Concept Changes. 
- * Ensemble method for data streams that adapts to concept changes 
- * and deals with concept recurrence.
- * 
- * Reference: JABER, G., CORNUEJOLS, A., and TARROUX, P. A New On-Line Learning Method 
- * for Coping with Recurring Concepts: The ADACC System. In : Neural Information 
- * Processing. Springer Berlin Heidelberg, 2013. p. 595-604.
- * 
- * @author Ghazal Jaber (ghazal.jaber@gmail.com)
- *
- */
-
-public class ADACC extends DACC {
-
-    private static final long serialVersionUID = 1L;
-    
-    @Override
-    public String getPurposeString() {
-        return "Anticipative and Dynamic Adaptation to Concept Changes for data streams.";
-    }
-    /**
-     * Evaluation window for the stability index computation  
-     */
-    public IntOption tauSizeOption = new IntOption("tau", 't',
-            "The size of the evaluation window for the meta-learning.", 100, 1, 10000);
-    /**
-     * Threshold for the stability index
-     */
-    public FloatOption stabIndexSizeOption = new FloatOption("StabThr", 'z',
-            "The threshold for stability", 0.8, 0, 1);    
-    /**
-     * Threshold for concept equivalence
-     */
-    public FloatOption equivIndexSizeOption = new FloatOption("CeThr", 'q',
-            "The threshold for concept equivalence", 0.7, 0, 1);
-    /**
-     * Size of the evaluation window to compute the stability index  
-     */
-    protected int tau_size = 0; 
-    /**
-     * Last chunk of data of size (tau_size) to compute the stability index   
-     */
-    protected InstancesHeader recentChunk;
-    /**
-     * Threshold values for the stability index and concept equivalence
-     */
-	protected double theta_stab, theta_diff; 
-    /**
-	 * Current stability index
-	 */
-	protected double index; 
-    /**
-     * Maximum number of snapshots (copies of classifiers kept in case of recurrence)
-     */
-    protected final static int MAXPERMANENT = 100; 
-    /**
-     * Number of added snapshots
-     */
-    protected int addedPermanent = 0; 
-    
-	@Override
-	protected void initVariables(){
-		    	
-        this.tau_size = this.tauSizeOption.getValue();
-        this.theta_stab = this.stabIndexSizeOption.getValue();
-        this.theta_diff = this.equivIndexSizeOption.getValue();
-        this.recentChunk = null;
-
-        int ensembleSize = (int)this.memberCountOption.getValue() + MAXPERMANENT;
-        this.ensemble = new Classifier[ensembleSize];
-    	this.ensembleAges = new double[ensembleSize];
-        this.ensembleWindows = new int[ensembleSize][(int)this.evaluationSizeOption.getValue()];
-        
-	}
-	
-    
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-	
-    	if (recentChunk == null)
-            recentChunk = this.getModelContext().getEmptyHeader();
-    	
-    	if (recentChunk.size() < this.tau_size)
-    		recentChunk.add(inst);
-    	else
-    		recentChunk.set(this.nbInstances % this.tau_size,inst);
-	    	  
-    	trainAndClassify(inst);
-    	
-        if ((this.nbInstances % this.tau_size)==0)
-        	takeSnapshot();
-    }
-    
-    /**
-     * If the environment is stable enough, take a snapshot
-     * (a copy) of the best adaptive classifier and keep it 
-     * for future use, in case of concept recurrence 
-     */
-    private void takeSnapshot(){
-
-    	this.index = computeStabilityIndex();
-    	 
-    	if (this.index >= this.theta_stab)
-    		if (addedPermanent == 0){
-    			this.ensemble[this.ensemble.length-MAXPERMANENT+addedPermanent] = (Classifier) getBestAdaptiveClassifier().copy();
-    			addedPermanent++;
-    		}
-    		else{
-    			
-    			Classifier candidate = (Classifier) getBestAdaptiveClassifier().copy();
-    			
-    			boolean duplicate = false;
-    			for (int j=0;j<Math.min(MAXPERMANENT,addedPermanent);j++){
-        			Classifier lastSnapshot=this.ensemble[this.ensemble.length-MAXPERMANENT+j];
-        			
-        			int[][] votes=new int[2][tau_size];
-        			for (int k=0;k<tau_size;k++){
-        				votes[0][k]=Utils.maxIndex(candidate.getPredictionForInstance(recentChunk.get(k)));	
-        				votes[1][k]=Utils.maxIndex(lastSnapshot.getPredictionForInstance(recentChunk.get(k)));	
-        			}
-        			double kappa=computeKappa(votes[0],votes[1]);
-        			
-        			if (kappa>=this.theta_diff){
-        				duplicate = true; break;
-        			} 
-    			}
-    			if (!duplicate){
-        			this.ensemble[this.ensemble.length-MAXPERMANENT+(addedPermanent%MAXPERMANENT)]=candidate;
-    				addedPermanent++;
-    			}	
-    		}	
-    	}
-
-                
-    /**
-     * Returns the kappa statistics, 
-     * a statistical measure of agreement in the predictions
-     * of 2 classifiers. Used as a measure of diversity of predictive 
-     * models: the higher the kappa value, the smaller the diversity
-     * @param y1 the predictions of classifier A
-     * @param y2 the predictions of classifier B
-     * @return the kappa measure
-     */
-    private double computeKappa(int[] y1,int[] y2){
-    	
-    	int m=y1.length;
-    	
-    	double theta1=0;
-    	double counts[][]=new double[2][this.modelContext.numClasses()];
-    	
-    	for (int i=0;i<m;i++){
-	    
-    		if (y1[i]==y2[i])
-	    		theta1=theta1+1;
-	    	
-	    	counts[0][y1[i]]=counts[0][y1[i]]+1;
-	    	counts[1][y2[i]]=counts[1][y2[i]]+1;
-	    		
-    	}
-	    
-    	theta1=theta1/m;
-
-    	double theta2=0;
-    	
-    	for(int i=0;i<this.modelContext.numClasses();i++)
-    		theta2+=counts[0][i]/m*counts[1][i]/m;
-    	
-    	if (theta1==theta2 && theta2==1)
-    		return 1;
-    	
-    	return (theta1-theta2)/(1-theta2);
-    }
-
-   /**
-    * Returns the stability index of the adaptive ensemble 
-    * of classifiers. The ensemble is considered stable here 
-    * if its diversity level and error rates are low. 
-    * @return the stability measure value
-    */
-    private double computeStabilityIndex(){
-    	
-    	int m = (int)Math.floor((this.ensemble.length-MAXPERMANENT)/2);
-    	int[][] votes=new int[m][tau_size];
-    	double errors=0;
-    	int count=0;
-   
-    	
-    	Pair[] arr = getHalf(true);
-    	
-    	for (int i=0;i<m;i++){
-    		for (int j=0;j<tau_size;j++){
-    			votes[i][j]=Utils.maxIndex(this.ensemble[arr[i].index].getPredictionForInstance(recentChunk.get(j)));
-    			errors+=(votes[i][j]==(int) this.recentChunk.get(j).classValue())?0:1;
-    			count++;
-    		}
-    	}
-    	errors = errors/count;
-
-    	double res=0;  count=0;
-    	for (int i=0;i<m;i++)
-        	for (int j=i+1;j<m;j++)
-        		if (i!=j){
-        			res+=computeKappa(votes[i],votes[j]);
-        			count++;	
-        		}
-
-    	return res/count-errors;
-    }
-    
-    /**
-     * Returns the adaptive classifier with the highest weight
-     * @return the best adaptive classifier
-     */
-    private Classifier getBestAdaptiveClassifier(){
-    	
-		//take a copy of the ensemble weights (excluding snapshots)
-		Pair[] newEnsembleWeights = new Pair[ensembleWeights.length-MAXPERMANENT];
-		for (int i = 0 ; i < newEnsembleWeights.length; i++)	
-			newEnsembleWeights[i]=ensembleWeights[i];
-		
-	    //sort the weight values	
-		Arrays.sort(newEnsembleWeights,Collections.reverseOrder());
-	    			
-		return (Classifier) this.ensemble[newEnsembleWeights[0].index].copy();
-    }
-
-  
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        Measurement[] measurements  = new Measurement[10];
- 
-        measurements[0] = new Measurement("size ",
-                    this.ensemble.length-MAXPERMANENT);
-        measurements[1] = new Measurement("maturity ",
-                   this.maturityOption.getValue());
-        measurements[2] = new Measurement("evalsize ",
-                   this.evaluationSizeOption.getValue());
-        measurements[3] = new Measurement("cmb ",
-                   this.combinationOption.getChosenIndex());
-        measurements[4] = new Measurement("tau",
-        		this.tau_size);
-        measurements[5] = new Measurement("MaxSnapshotsSize",
-        		MAXPERMANENT);
-        measurements[6] = new Measurement("SnapshotsSize",
-        		this.addedPermanent);
-        measurements[7] = new Measurement("stabilityIndex",
-        		this.index);
-        measurements[8]=new Measurement("stabilityThreshold", 
-        		this.theta_stab);
-        measurements[9]=new Measurement("differenceThreshold", 
-        		this.theta_diff);
-  
-        return measurements;
-    }
-    
-    
-    @Override
-    protected int getNbActiveClassifiers(){
-    	return ensemble.length-MAXPERMANENT+Math.min(addedPermanent,MAXPERMANENT);
-    }
-    
-    @Override
-    protected int getNbAdaptiveClassifiers(){
-    	return this.ensemble.length-MAXPERMANENT;
-    }
-}
-
diff --git a/moa/src/main/java/moa/classifiers/meta/ADOB.java b/moa/src/main/java/moa/classifiers/meta/ADOB.java
deleted file mode 100644
index 2de16a2a5..000000000
--- a/moa/src/main/java/moa/classifiers/meta/ADOB.java
+++ /dev/null
@@ -1,208 +0,0 @@
-/*
- *    ADOB.java
- *    Copyright (C) 2014 Santos, Goncalves, Barros
- *    @author Silas G. T. C. Santos (sgtcs@cin.ufpe.br)
- *            Paulo M. Goncalves Jr. (paulomgj@gmail.com)
- *            Roberto S. M. Barros (roberto@cin.ufpe.br)
- *    @version $Version: 1 $
- *
- *    Evolved from OzaBoost.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *    @version $Revision: 7 $
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- */
-
-package moa.classifiers.meta;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractClassifier;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.core.MiscUtils;
-import moa.learners.Classifier;
-import moa.options.ClassOption;
-
-/**
- * Adaptable Diversity-based Online Boosting (ADOB) is a modified version
- * of the online boosting, as proposed by Oza and Russell, which is aimed
- * at speeding up the experts recovery after concept drifts.
- *
- * published as:
- *     Silas G. T. C. Santos, Paulo M. Goncalves Jr., Geyson D. S. Silva,
- *     and Roberto S. M. Barros:
- *     Speeding Up Recovery from Concept Drifts.
- *     In book: Machine Learning and Knowledge Discovery in Databases,
- *     ECML/PKDD 2014, Part III, LNCS 8726, pp. 179-194. 09/2014.
- *     DOI: 10.1007/978-3-662-44845-8_12
- */
-
-public class ADOB extends AbstractClassifier {
-
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public String getPurposeString() {
-        return "Adaptable Diversity-based Online Boosting (ADOB)";
-    }
-
-    public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l',
-            "Classifier to train.", Classifier.class,
-    		"moa.classifiers.drift.SingleClassifierDrift -l moa.classifiers.trees.HoeffdingTree -d moa.classifiers.core.driftdetection.ADWINChangeDetector");
-
-    public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's',
-            "The number of models to boost.", 10, 1, Integer.MAX_VALUE);
-
-    public FlagOption pureBoostOption = new FlagOption("pureBoost", 'p',
-            "Boost with weights only; no poisson.");
-
-    protected Classifier[] ensemble;
-    
-    protected int[] orderPosition;
-
-    protected double[] scms;
-
-    protected double[] swms;
-
-    @Override
-    public void resetLearningImpl() {
-        this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
-        this.orderPosition = new int[this.ensemble.length];
-        Classifier baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
-        baseLearner.resetLearning();
-        for (int i = 0; i < this.ensemble.length; i++) {
-            this.ensemble[i] = (Classifier) baseLearner.copy();
-            this.orderPosition[i] = i;
-        }
-        this.scms = new double[this.ensemble.length];
-        this.swms = new double[this.ensemble.length];
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-	// Calculates current accuracy of experts
-        double[] acc = new double[this.ensemble.length];
-        for ( int i=0; i<this.ensemble.length; i++ ) {
-            acc[i] = this.scms[this.orderPosition[i]] + this.swms[this.orderPosition[i]];
-            if ( acc[i] != 0.0 ) {
-                acc[i] = this.scms[this.orderPosition[i]] / acc[i];
-            }
-        }
-        
-	// Sort by accuracy in ascending order
-        double key_acc; int key_position, j;
-        for ( int i=1; i<this.ensemble.length; i++ ) {
-            key_position = this.orderPosition[i];
-            key_acc = acc[i];
-            j = i-1;
-            while ( j>=0 && acc[j]<key_acc ) {
-                this.orderPosition[j+1] = this.orderPosition[j];
-                acc[j+1] = acc[j];
-                j--;
-            }
-            this.orderPosition[j+1] = key_position;
-            acc[j+1] = key_acc;
-        }
-        
-        boolean correct=false; int pos;
-        double lambda_d = 1.0; int maxAcc=0, minAcc=this.ensemble.length-1;
-        for (int i = 0; i < this.ensemble.length; i++) {
-            if ( correct ) {
-                pos = this.orderPosition[maxAcc];
-                maxAcc++;
-            } else {
-                pos = this.orderPosition[minAcc];
-                minAcc--;
-            }
-            
-            double k;
-            if ( this.pureBoostOption.isSet() ) {
-                k = lambda_d;
-            } else {
-                k = MiscUtils.poisson(lambda_d, this.classifierRandom);
-            }
-            
-            if (k > 0.0) {
-                Instance weightedInst = (Instance) inst.copy();
-                weightedInst.setWeight(inst.weight() * k);
-                this.ensemble[pos].trainOnInstance(weightedInst);
-            }
-
-	    // Increases or decreases lambda based on the prediction of instance
-            if (this.ensemble[pos].correctlyClassifies(inst)) {
-                this.scms[pos] += lambda_d;
-                lambda_d *= this.trainingWeightSeenByModel / (2 * this.scms[pos]);
-                correct = true;
-            } else {
-                this.swms[pos] += lambda_d;
-                lambda_d *= this.trainingWeightSeenByModel / (2 * this.swms[pos]);
-                correct = false;
-            }
-        }
-    }
-
-    protected double getEnsembleMemberWeight(int i) {
-        if ( this.scms[i]>0.0 && this.swms[i]>0.0 ) {
-            double em = this.swms[i] / (this.scms[i] + this.swms[i]);
-            if (em <= 0.5) {
-                double Bm = em / (1.0 - em);
-                return Math.log(1.0 / Bm);
-            }
-        }
-        return 0.0;
-    }
-
-    public Prediction getPredictionForInstance(Instance inst) {
-        DoubleVector combinedVote = new DoubleVector();
-        for (int i = 0; i < this.ensemble.length; i++) {
-            double memberWeight = getEnsembleMemberWeight(i);
-            if (memberWeight > 0.0) {
-                DoubleVector vote = new DoubleVector(this.ensemble[i].getPredictionForInstance(inst).asDoubleArray());
-                if (vote.sumOfValues() > 0.0) {
-                    vote.normalize();
-                    vote.scaleValues(memberWeight);
-                    combinedVote.addValues(vote);
-                }
-            } else {
-                break;
-            }
-        }
-        
-        return new ClassificationPrediction(combinedVote.getArrayRef());
-    }
-
-    public boolean isRandomizable() {
-        return true;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return new Measurement[]{new Measurement("ensemble size",
-                    this.ensemble != null ? this.ensemble.length : 0)};
-    }
-
-    public Classifier[] getSubClassifiers() {
-        return this.ensemble.clone();
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/meta/AbstractOzaBagAdwin.java b/moa/src/main/java/moa/classifiers/meta/AbstractOzaBagAdwin.java
deleted file mode 100644
index 82936d890..000000000
--- a/moa/src/main/java/moa/classifiers/meta/AbstractOzaBagAdwin.java
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
- *    OzaBagAdwin.java
- *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.meta;
-
-import moa.capabilities.CapabilitiesHandler;
-import moa.capabilities.Capability;
-import moa.capabilities.ImmutableCapabilities;
-import moa.classifiers.core.driftdetection.ADWIN;
-import moa.classifiers.AbstractClassifier;
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.core.MiscUtils;
-import moa.learners.Classifier;
-import moa.learners.InstanceLearner;
-
-/**
- * Bagging for evolving data streams using ADWIN.
- *
- * <p>ADWIN is a change detector and estimator that solves in
- * a well-specified way the problem of tracking the average of
- * a stream of bits or real-valued numbers. ADWIN keeps a
- * variable-length window of recently seen items, with the property
- * that the window has the maximal length statistically consistent
- * with the hypothesis “there has been no change in the average value
- * inside the window”.<br />
- * More precisely, an older fragment of the window is dropped if and only
- * if there is enough evidence that its average value differs from that of
- * the rest of the window. This has two consequences: one, that change
- * reliably declared whenever the window shrinks; and two, that at any time
- * the average over the existing window can be reliably taken as an estimation
- * of the current average in the stream (barring a very small or very recent
- * change that is still not statistically visible). A formal and quantitative
- * statement of these two points (a theorem) appears in<p>
- *
- * Albert Bifet and Ricard Gavaldà. Learning from time-changing data
- * with adaptive windowing. In SIAM International Conference on Data Mining,
- * 2007.</p>
- * <p>ADWIN is parameter- and assumption-free in the sense that it automatically
- * detects and adapts to the current rate of change. Its only parameter is a
- * confidence bound δ, indicating how confident we want to be in the algorithm’s
- * output, inherent to all algorithms dealing with random processes. Also
- * important, ADWIN does not maintain the window explicitly, but compresses it
- * using a variant of the exponential histogram technique. This means that it
- * keeps a window of length W using only O(log W) memory and O(log W) processing
- * time per item.<br />
- * ADWIN Bagging is the online bagging method of Oza and Rusell with the
- * addition of the ADWIN algorithm as a change detector and as an estimator for
- * the weights of the boosting method. When a change is detected, the worst
- * classifier of the ensemble of classifiers is removed and a new classifier is
- * added to the ensemble.</p>
- * <p>See details in:<br />
- * [BHPKG] Albert Bifet, Geoff Holmes, Bernhard Pfahringer, Richard Kirkby,
- * and Ricard Gavaldà . New ensemble methods for evolving data streams.
- * In 15th ACM SIGKDD International Conference on Knowledge Discovery and
- * Data Mining, 2009.</p>
- * <p>Example:</p>
- * <code>OzaBagAdwin -l HoeffdingTreeNBAdaptive -s 10</code>
- * <p>Parameters:</p> <ul>
- * <li>-l : Classifier to train</li>
- * <li>-s : The number of models in the bag</li> </ul>
- *
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @version $Revision: 7 $
- */
-public abstract class AbstractOzaBagAdwin<MLTask extends InstanceLearner> extends AbstractOzaBag<MLTask> implements CapabilitiesHandler {
-
-    private static final long serialVersionUID = 1L;
-
-    public AbstractOzaBagAdwin(Class<MLTask> MLTask, String defaultCLIString) {
-    	super(MLTask, defaultCLIString);
-    }
-
-    @Override
-    public String getPurposeString() {
-        return "Bagging for evolving data streams using ADWIN.";
-    }    
-    
-    protected ADWIN[] ADError;
-
-    @Override
-    public void resetLearningImpl() {
-    	super.resetLearningImpl();
-        this.ADError = new ADWIN[this.ensemble.size()];
-        for (int i = 0; i < this.ensemble.size(); i++) {
-            this.ADError[i] = new ADWIN();
-        }
-    }
-
-    public abstract double getAdwinError(Instance inst, int i);
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        boolean Change = false;
-        for (int i = 0; i < this.ensemble.size(); i++) {
-            int k = MiscUtils.poisson(6.0, this.classifierRandom);
-            if (k > 0) {
-                Instance weightedInst = (Instance) inst.copy();
-                weightedInst.setWeight(inst.weight() * k);
-                this.ensemble.get(i).trainOnInstance(weightedInst);
-            }
-            double ErrEstim = this.ADError[i].getEstimation();
-            if (this.ADError[i].setInput(this.getAdwinError(inst, i))) {
-                if (this.ADError[i].getEstimation() > ErrEstim) {
-                    Change = true;
-                }
-            }
-        }
-        if (Change) {
-            double max = 0.0;
-            int imax = -1;
-            for (int i = 0; i < this.ensemble.size(); i++) {
-                if (max < this.ADError[i].getEstimation()) {
-                    max = this.ADError[i].getEstimation();
-                    imax = i;
-                }
-            }
-            if (imax != -1) {
-                this.ensemble.get(imax).resetLearning();
-                this.ensemble.get(imax).setRandomSeed(this.ensemble.get(imax).getRandomSeed() * 2);
-                this.ensemble.get(imax).trainOnInstance(inst);
-                this.ADError[imax] = new ADWIN();
-            }
-        }
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return true;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return new Measurement[]{new Measurement("ensemble size",
-                    this.ensemble != null ? this.ensemble.size() : 0)};
-    }
-
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == OzaBagAdwin.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/meta/AbstractOzaBoost.java b/moa/src/main/java/moa/classifiers/meta/AbstractOzaBoost.java
deleted file mode 100644
index 7cb42ce32..000000000
--- a/moa/src/main/java/moa/classifiers/meta/AbstractOzaBoost.java
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
- *    OzaBoost.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.meta;
-
-import java.util.ArrayList;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractEnsembleLearner;
-import moa.core.Measurement;
-import moa.core.MiscUtils;
-import moa.learners.InstanceLearner;
-import moa.options.ClassOption;
-
-/**
- * Incremental on-line boosting of Oza and Russell.
- *
- * <p>See details in:<br /> N. Oza and S. Russell. Online bagging and boosting.
- * In Artificial Intelligence and Statistics 2001, pages 105–112. Morgan
- * Kaufmann, 2001.</p> <p>For the boosting method, Oza and Russell note that the
- * weighting procedure of AdaBoost actually divides the total example weight
- * into two halves – half of the weight is assigned to the correctly classified
- * examples, and the other half goes to the misclassified examples. They use the
- * Poisson distribution for deciding the random probability that an example is
- * used for training, only this time the parameter changes according to the
- * boosting weight of the example as it is passed through each model in
- * sequence.</p>
- *
- * <p>Parameters:</p> <ul> <li>-l : Classifier to train</li> <li>-s : The number
- * of models to boost</li> <li>-p : Boost with weights only; no poisson</li>
- * </ul>
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $
- */
-public abstract class AbstractOzaBoost<MLTask extends InstanceLearner> extends AbstractEnsembleLearner<MLTask> {
-
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public String getPurposeString() {
-        return "Incremental on-line boosting of Oza and Russell.";
-    }
-
-	public AbstractOzaBoost(Class<MLTask> task, String defaultCLIString) {
-		super(task);
-		this.baseLearnerOption = new ClassOption("baseLearner", 'l', "Classifier to train.", task, defaultCLIString);
-	}
-	
-    public FlagOption pureBoostOption = new FlagOption("pureBoost", 'p',
-            "Boost with weights only; no poisson.");
-
-    protected double[] scms;
-
-    protected double[] swms;
-
-    @Override
-    public void resetLearningImpl() {
-    	super.resetLearningImpl();
-
-        this.scms = new double[this.ensemble.size()];
-        this.swms = new double[this.ensemble.size()];
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        double lambda_d = 1.0;
-        for (int i = 0; i < this.ensemble.size(); i++) {
-            double k = this.pureBoostOption.isSet() ? lambda_d : MiscUtils.poisson(lambda_d, this.classifierRandom);
-            if (k > 0.0) {
-                Instance weightedInst = (Instance) inst.copy();
-                weightedInst.setWeight(inst.weight() * k);
-                this.ensemble.get(i).trainOnInstance(weightedInst);
-            }
-            lambda_d = updateWeight(i, inst, lambda_d);
-            }
-        }
-    
-    public abstract double updateWeight(int i, Instance inst, double lambda_d);
-
-    protected double getEnsembleMemberWeight(int i) {
-        double em = this.swms[i] / (this.scms[i] + this.swms[i]);
-        if ((em == 0.0) || (em > 0.5)) {
-            return 0.0;
-        }
-        double Bm = em / (1.0 - em);
-        return Math.log(1.0 / Bm);
-    }
-
-    @Override
-    public Prediction getPredictionForInstance(Instance inst) {
-    	Prediction[] predictions = new Prediction[this.ensemble.size()];
-    	double[] weights = new double[this.ensemble.size()];
-        for (int i = 0; i < this.ensemble.size(); i++) {
-            weights[i] = getEnsembleMemberWeight(i);
-            if (weights[i] > 0.0) {
-                predictions[i] = this.ensemble.get(i).getPredictionForInstance(inst);
-
-            } else {
-                break;
-            }
-        }
-        return combinePredictions(predictions, weights);
-    }
-
-    public abstract Prediction combinePredictions(Prediction[] predictions, double[] weights);
-    
-    public Prediction combinePredictions(Prediction[] prediction) {
-		throw new UnsupportedOperationException("This is a boosting ensemble and does not use unweighted combining of predictions.");
-    }
-
-    public boolean isRandomizable() {
-        return true;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return new Measurement[]{new Measurement("ensemble size",
-                    this.ensemble != null ? this.ensemble.size() : 0)};
-    }
-
-}
diff --git a/moa/src/main/java/moa/classifiers/meta/AccuracyWeightedEnsemble.java b/moa/src/main/java/moa/classifiers/meta/AccuracyWeightedEnsemble.java
deleted file mode 100644
index 9fa393df5..000000000
--- a/moa/src/main/java/moa/classifiers/meta/AccuracyWeightedEnsemble.java
+++ /dev/null
@@ -1,468 +0,0 @@
-/*
- *    AccuracyWeightedEnsemble.java
- *    Copyright (C) 2010 Poznan University of Technology, Poznan, Poland
- *    @author Dariusz Brzezinski (dariusz.brzezinski@cs.put.poznan.pl)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.meta;
-
-import java.util.Random;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractClassifier;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.core.ObjectRepository;
-import moa.core.Utils;
-import moa.learners.Classifier;
-import moa.options.ClassOption;
-import moa.tasks.TaskMonitor;
-
-/**
- * The Accuracy Weighted Ensemble classifier as proposed by Wang et al. in
- * "Mining concept-drifting data streams using ensemble classifiers", KDD 2003.
- */
-public class AccuracyWeightedEnsemble extends AbstractClassifier implements Classifier {
-
-    @Override
-    public String getPurposeString() {
-        return "Accuracy Weighted Ensemble classifier as proposed by Wang et al. in 'Mining concept-drifting data streams using ensemble classifiers', KDD 2003";
-    }
-
-    /**
-     * Simple weight comparator. Needed for sorting component classifiers.
-     */
-    private static final class ClassifierWeightComparator implements java.util.Comparator<double[]> {
-
-        @Override
-        public int compare(double[] o1, double[] o2) {
-            if (o1[0] > o2[0]) {
-                return 1;
-            } else if (o1[0] < o2[0]) {
-                return -1;
-            } else {
-                return 0;
-            }
-        }
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    /**
-     * Simple weight comparator.
-     */
-    protected static java.util.Comparator<double[]> weightComparator = new ClassifierWeightComparator();
-
-    /**
-     * Type of classifier to use as a component classifier.
-     */
-    public ClassOption learnerOption = new ClassOption("learner", 'l', "Classifier to train.", Classifier.class, "moa.classifiers.trees.HoeffdingTree -l NB -e 1000 -g 100 -c 0.01");
-
-    /**
-     * Number of component classifiers.
-     */
-    public FloatOption memberCountOption = new FloatOption("memberCount", 'n', "The maximum number of classifier in an ensemble.", 15, 1, Integer.MAX_VALUE);
-
-    /**
-     * Number of classifiers remembered and available for ensemble construction.
-     */
-    public FloatOption storedCountOption = new FloatOption("storedCount", 'r', "The maximum number of classifiers to store and choose from when creating an ensemble.", 30, 1, Integer.MAX_VALUE);
-
-    /**
-     * Chunk size.
-     */
-    public IntOption chunkSizeOption = new IntOption("chunkSize", 'c', "The chunk size used for classifier creation and evaluation.", 500, 1, Integer.MAX_VALUE);
-
-    /**
-     * Number of folds in candidate classifier cross-validation.
-     */
-    public IntOption numFoldsOption = new IntOption("numFolds", 'f', "Number of cross-validation folds for candidate classifier testing.", 10, 1, Integer.MAX_VALUE);
-
-    protected long[] classDistributions;
-
-    protected Classifier[] ensemble;
-
-    protected Classifier[] storedLearners;
-
-    protected double[] ensembleWeights;
-
-    /**
-     * The weights of stored classifiers. storedWeights[x][0] = weight
-     * storedWeights[x][1] = classifier
-     */
-    protected double[][] storedWeights;
-
-    protected int processedInstances;
-
-    protected int chunkSize;
-
-    protected int numFolds;
-
-    protected int maxMemberCount;
-
-    protected int maxStoredCount;
-
-    protected Classifier candidateClassifier;
-
-    protected InstancesHeader currentChunk;
-
-    @Override
-    public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-        this.maxMemberCount = (int) memberCountOption.getValue();
-        this.maxStoredCount = (int) storedCountOption.getValue();
-
-        if (this.maxMemberCount > this.maxStoredCount) {
-            this.maxStoredCount = this.maxMemberCount;
-        }
-
-        this.chunkSize = this.chunkSizeOption.getValue();
-        this.numFolds = this.numFoldsOption.getValue();
-        this.candidateClassifier = (Classifier) getPreparedClassOption(this.learnerOption);
-        this.candidateClassifier.resetLearning();
-
-        super.prepareForUseImpl(monitor, repository);
-    }
-
-    @Override
-    public void resetLearningImpl() {
-        this.currentChunk = null;
-        this.classDistributions = null;
-        this.processedInstances = 0;
-        this.ensemble = new Classifier[0];
-        this.storedLearners = new Classifier[0];
-
-        this.candidateClassifier = (Classifier) getPreparedClassOption(this.learnerOption);
-        this.candidateClassifier.resetLearning();
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        this.initVariables();
-
-        this.classDistributions[(int) inst.classValue()]++;
-        this.currentChunk.add(inst);
-        this.processedInstances++;
-
-        if (this.processedInstances % this.chunkSize == 0) {
-            this.processChunk();
-        }
-    }
-
-    /**
-     * Initiates the current chunk and class distribution variables.
-     */
-    private void initVariables() {
-        if (this.currentChunk == null) {
-            this.currentChunk = this.getModelContext().getEmptyHeader();
-        }
-
-        if (this.classDistributions == null) {
-            this.classDistributions = new long[this.getModelContext().classAttribute().numValues()];
-
-            for (int i = 0; i < this.classDistributions.length; i++) {
-                this.classDistributions[i] = 0;
-            }
-        }
-    }
-
-    /**
-     * Processes a chunk.
-     *
-     * @param useMseR Determines whether to use the MSEr threshold.
-     */
-    protected void processChunk() {
-        // Compute weights
-        double candidateClassifierWeight = this.computeCandidateWeight(this.candidateClassifier, this.currentChunk, this.numFolds);
-
-        for (int i = 0; i < this.storedLearners.length; i++) {
-            this.storedWeights[i][0] = this.computeWeight(this.storedLearners[(int) this.storedWeights[i][1]], this.currentChunk);
-        }
-
-        if (this.storedLearners.length < this.maxStoredCount) {
-            // Train and add classifier
-            for (int num = 0; num < this.chunkSize; num++) {
-                this.candidateClassifier.trainOnInstance(this.currentChunk.instance(num));
-            }
-
-            this.addToStored(this.candidateClassifier, candidateClassifierWeight);
-        } else {
-            // Substitute poorest classifier
-            java.util.Arrays.sort(this.storedWeights, weightComparator);
-
-            if (this.storedWeights[0][0] < candidateClassifierWeight) {
-                for (int num = 0; num < this.chunkSize; num++) {
-                    this.candidateClassifier.trainOnInstance(this.currentChunk.instance(num));
-                }
-
-                this.storedWeights[0][0] = candidateClassifierWeight;
-                this.storedLearners[(int) this.storedWeights[0][1]] = (Classifier) this.candidateClassifier.copy();
-            }
-        }
-
-        int ensembleSize = java.lang.Math.min(this.storedLearners.length, this.maxMemberCount);
-        this.ensemble = new Classifier[ensembleSize];
-        this.ensembleWeights = new double[ensembleSize];
-
-        // Sort learners according to their weights
-        java.util.Arrays.sort(this.storedWeights, weightComparator);
-
-        // Select top k classifiers to construct the ensemble
-        int storeSize = this.storedLearners.length;
-        for (int i = 0; i < ensembleSize; i++) {
-            this.ensembleWeights[i] = this.storedWeights[storeSize - i - 1][0];
-            this.ensemble[i] = this.storedLearners[(int) this.storedWeights[storeSize - i - 1][1]];
-        }
-
-        this.classDistributions = null;
-        this.currentChunk = null;
-        this.candidateClassifier = (Classifier) getPreparedClassOption(this.learnerOption);
-        this.candidateClassifier.resetLearning();
-    }
-
-    /**
-     * Computes the weight of a candidate classifier.
-     *
-     * @param candidate Candidate classifier.
-     * @param chunk Data chunk of examples.
-     * @param numFolds Number of folds in candidate classifier cross-validation.
-     * @param useMseR Determines whether to use the MSEr threshold.
-     * @return Candidate classifier weight.
-     */
-    protected double computeCandidateWeight(Classifier candidate, InstancesHeader chunk, int numFolds) {
-        double candidateWeight = 0.0;
-        Random random = new Random(1);
-        InstancesHeader randData = new InstancesHeader(chunk);
-        randData.randomize(random);
-        if (randData.classAttribute().isNominal()) {
-            randData.stratify(numFolds);
-        }
-
-        for (int n = 0; n < numFolds; n++) {
-            InstancesHeader train = randData.trainCV(numFolds, n, random);
-            InstancesHeader test = randData.testCV(numFolds, n);
-
-            Classifier learner = (Classifier) candidate.copy();
-
-            for (int num = 0; num < train.numInstances(); num++) {
-                learner.trainOnInstance(train.instance(num));
-            }
-
-            candidateWeight += computeWeight(learner, test);
-        }
-
-        double resultWeight = candidateWeight / numFolds;
-
-        if (Double.isInfinite(resultWeight)) {
-            return Double.MAX_VALUE;
-        } else {
-            return resultWeight;
-        }
-    }
-
-    /**
-     * Computes the weight of a given classifie.
-     *
-     * @param learner Classifier to calculate weight for.
-     * @param chunk Data chunk of examples.
-     * @param useMseR Determines whether to use the MSEr threshold.
-     * @return The given classifier's weight.
-     */
-    protected double computeWeight(Classifier learner, InstancesHeader chunk) {
-        double mse_i = 0;
-        double mse_r = 0;
-
-        double f_ci;
-        double voteSum;
-
-        for (int i = 0; i < chunk.numInstances(); i++) {
-            try {
-                voteSum = 0;
-                double[] prediction = learner.getPredictionForInstance(chunk.instance(i)).asDoubleArray();
-                for (double element : prediction) {
-                    voteSum += element;
-                }
-
-                if (voteSum > 0) {
-                    f_ci = prediction[(int) chunk.instance(i).classValue()] / voteSum;
-                    mse_i += (1 - f_ci) * (1 - f_ci);
-                } else {
-                    mse_i += 1;
-                }
-            } catch (Exception e) {
-                mse_i += 1;
-            }
-        }
-
-        mse_i /= this.chunkSize;
-        mse_r = this.computeMseR();
-
-        return java.lang.Math.max(mse_r - mse_i, 0);
-    }
-
-    /**
-     * Computes the MSEr threshold.
-     *
-     * @return The MSEr threshold.
-     */
-    protected double computeMseR() {
-        double p_c;
-        double mse_r = 0;
-
-        for (int i = 0; i < this.classDistributions.length; i++) {
-            p_c = (double) this.classDistributions[i] / (double) this.chunkSize;
-            mse_r += p_c * ((1 - p_c) * (1 - p_c));
-        }
-
-        return mse_r;
-    }
-
-    /**
-     * Predicts a class for an example.
-     */
-    public Prediction getPredictionForInstance(Instance inst) {
-        DoubleVector combinedVote = new DoubleVector();
-
-        if (this.trainingWeightSeenByModel > 0.0) {
-            for (int i = 0; i < this.ensemble.length; i++) {
-                if (this.ensembleWeights[i] > 0.0) {
-                    DoubleVector vote = this.ensemble[i].getPredictionForInstance(inst).asDoubleVector();
-
-                    if (vote.sumOfValues() > 0.0) {
-                        vote.normalize();
-                        //scale weight and prevent overflow
-                        vote.scaleValues(this.ensembleWeights[i] / (1.0 * this.ensemble.length + 1));
-                        combinedVote.addValues(vote);
-                    }
-                }
-            }
-        }
-        combinedVote.normalize();
-        return new ClassificationPrediction(combinedVote.getArrayRef());
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-    }
-
-    /**
-     * Adds ensemble weights to the measurements.
-     */
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        Measurement[] measurements = new Measurement[this.maxStoredCount];
-
-        for (int m = 0; m < this.maxMemberCount; m++) {
-            measurements[m] = new Measurement("Member weight " + (m + 1), -1);
-        }
-
-        for (int s = this.maxMemberCount; s < this.maxStoredCount; s++) {
-            measurements[s] = new Measurement("Stored member weight " + (s + 1), -1);
-        }
-
-        if (this.storedWeights != null) {
-            int storeSize = this.storedWeights.length;
-
-            for (int i = 0; i < storeSize; i++) {
-                if (i < this.ensemble.length) {
-                    measurements[i] = new Measurement("Member weight " + (i + 1), this.storedWeights[storeSize - i - 1][0]);
-                } else {
-                    measurements[i] = new Measurement("Stored member weight " + (i + 1), this.storedWeights[storeSize - i - 1][0]);
-                }
-            }
-        }
-        return measurements;
-    }
-
-    /**
-     * Determines whether the classifier is randomizable.
-     */
-    public boolean isRandomizable() {
-        return false;
-    }
-
-    public Classifier[] getSubClassifiers() {
-        return this.ensemble.clone();
-    }
-
-    /**
-     * Adds a classifier to the storage.
-     *
-     * @param newClassifier The classifier to add.
-     * @param newClassifiersWeight The new classifiers weight.
-     */
-    protected Classifier addToStored(Classifier newClassifier, double newClassifiersWeight) {
-        Classifier addedClassifier = null;
-        Classifier[] newStored = new Classifier[this.storedLearners.length + 1];
-        double[][] newStoredWeights = new double[newStored.length][2];
-
-        for (int i = 0; i < newStored.length; i++) {
-            if (i < this.storedLearners.length) {
-                newStored[i] = this.storedLearners[i];
-                newStoredWeights[i][0] = this.storedWeights[i][0];
-                newStoredWeights[i][1] = this.storedWeights[i][1];
-            } else {
-                newStored[i] = addedClassifier = (Classifier) newClassifier.copy();
-                newStoredWeights[i][0] = newClassifiersWeight;
-                newStoredWeights[i][1] = i;
-            }
-        }
-        this.storedLearners = newStored;
-        this.storedWeights = newStoredWeights;
-
-        return addedClassifier;
-    }
-
-    /**
-     * Removes the poorest classifier from the model, thus decreasing the models
-     * size.
-     *
-     * @return the size of the removed classifier.
-     */
-    protected long removePoorestModelBytes() {
-        int poorestIndex = Utils.minIndex(this.ensembleWeights);
-        long byteSize = this.ensemble[poorestIndex].measureByteSize();
-        discardModel(poorestIndex);
-        return byteSize;
-    }
-
-    /**
-     * Removes the classifier at a given index from the model, thus decreasing
-     * the models size.
-     *
-     * @param index
-     */
-    protected void discardModel(int index) {
-        Classifier[] newEnsemble = new Classifier[this.ensemble.length - 1];
-        double[] newEnsembleWeights = new double[newEnsemble.length];
-        int oldPos = 0;
-        for (int i = 0; i < newEnsemble.length; i++) {
-            if (oldPos == index) {
-                oldPos++;
-            }
-            newEnsemble[i] = this.ensemble[oldPos];
-            newEnsembleWeights[i] = this.ensembleWeights[oldPos];
-            oldPos++;
-        }
-        this.ensemble = newEnsemble;
-        this.ensembleWeights = newEnsembleWeights;
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/meta/AdaptiveRandomForest.java b/moa/src/main/java/moa/classifiers/meta/AdaptiveRandomForest.java
deleted file mode 100644
index 0e2c27596..000000000
--- a/moa/src/main/java/moa/classifiers/meta/AdaptiveRandomForest.java
+++ /dev/null
@@ -1,477 +0,0 @@
-/*
- *    AdaptiveRandomForest.java
- * 
- *    @author Heitor Murilo Gomes (heitor_murilo_gomes at yahoo dot com dot br)
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *
- */
-package moa.classifiers.meta;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.AbstractMOAObject;
-import moa.capabilities.CapabilitiesHandler;
-import moa.capabilities.Capability;
-import moa.capabilities.ImmutableCapabilities;
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.core.driftdetection.ChangeDetector;
-import moa.classifiers.trees.ARFHoeffdingTree;
-import moa.core.DoubleVector;
-import moa.core.InstanceExample;
-import moa.core.Measurement;
-import moa.core.MiscUtils;
-import moa.evaluation.BasicClassificationPerformanceEvaluator;
-import moa.learners.Classifier;
-import moa.options.ClassOption;
-
-
-/**
- * Adaptive Random Forest
- *
- * <p>Adaptive Random Forest (ARF). The 3 most important aspects of this 
- * ensemble classifier are: (1) inducing diversity through resampling;
- * (2) inducing diversity through randomly selecting subsets of features for 
- * node splits (See moa.classifiers.trees.ARFHoeffdingTree.java); (3) drift 
- * detectors per base tree, which cause selective resets in response to drifts. 
- * It also allows training background trees, which start training if a warning
- * is detected and replace the active tree if the warning escalates to a drift. </p>
- *
- * <p>See details in:<br> Heitor Murilo Gomes, Albert Bifet, Jesse Read, 
- * Jean Paul Barddal, Fabricio Enembreck, Bernhard Pfharinger, Geoff Holmes, 
- * Talel Abdessalem. Adaptive random forests for evolving data stream classification. 
- * In Machine Learning, DOI: 10.1007/s10994-017-5642-8, Springer, 2017.</p>
- *
- * <p>Parameters:</p> <ul>
- * <li>-l : Classifier to train. Must be set to ARFHoeffdingTree</li>
- * <li>-s : The number of trees in the ensemble</li>
- * <li>-o : How the number of features is interpreted (4 options): 
- * "Specified m (integer value)", "sqrt(M)+1", "M-(sqrt(M)+1)"</li>
- * <li>-m : Number of features allowed considered for each split. Negative 
- * values corresponds to M - m</li>
- * <li>-a : The lambda value for bagging (lambda=6 corresponds to levBag)</li>
- * <li>-j : Number of threads to be used for training</li>
- * <li>-x : Change detector for drifts and its parameters</li>
- * <li>-p : Change detector for warnings (start training bkg learner)</li>
- * <li>-w : Should use weighted voting?</li>
- * <li>-u : Should use drift detection? If disabled then bkg learner is also disabled</li>
- * <li>-q : Should use bkg learner? If disabled then reset tree immediately</li>
- * </ul>
- *
- * @author Heitor Murilo Gomes (heitor_murilo_gomes at yahoo dot com dot br)
- * @version $Revision: 1 $
- */
-public class AdaptiveRandomForest extends AbstractClassifier implements Classifier, CapabilitiesHandler {
-
-    @Override
-    public String getPurposeString() {
-        return "Adaptive Random Forest algorithm for evolving data streams from Gomes et al.";
-    }
-    
-    private static final long serialVersionUID = 1L;
-
-    public ClassOption treeLearnerOption = new ClassOption("treeLearner", 'l',
-            "Random Forest Tree.", ARFHoeffdingTree.class,
-            "ARFHoeffdingTree -e 2000000 -g 50 -c 0.01");
-
-    public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's',
-        "The number of trees.", 10, 1, Integer.MAX_VALUE);
-    
-    public MultiChoiceOption mFeaturesModeOption = new MultiChoiceOption("mFeaturesMode", 'o', 
-        "Defines how m, defined by mFeaturesPerTreeSize, is interpreted. M represents the total number of features.",
-        new String[]{"Specified m (integer value)", "sqrt(M)+1", "M-(sqrt(M)+1)",
-            "Percentage (M * (m / 100))"},
-        new String[]{"SpecifiedM", "SqrtM1", "MSqrtM1", "Percentage"}, 1);
-    
-    public IntOption mFeaturesPerTreeSizeOption = new IntOption("mFeaturesPerTreeSize", 'm',
-        "Number of features allowed considered for each split. Negative values corresponds to M - m", 2, Integer.MIN_VALUE, Integer.MAX_VALUE);
-    
-    public FloatOption lambdaOption = new FloatOption("lambda", 'a',
-        "The lambda parameter for bagging.", 6.0, 1.0, Float.MAX_VALUE);
-
-    public IntOption numberOfJobsOption = new IntOption("numberOfJobs", 'j',
-        "Total number of concurrent jobs used for processing (-1 = as much as possible, 0 = do not use multithreading)", 1, -1, Integer.MAX_VALUE);
-    
-    public ClassOption driftDetectionMethodOption = new ClassOption("driftDetectionMethod", 'x',
-        "Change detector for drifts and its parameters", ChangeDetector.class, "ADWINChangeDetector -a 1.0E-5");
-
-    public ClassOption warningDetectionMethodOption = new ClassOption("warningDetectionMethod", 'p',
-        "Change detector for warnings (start training bkg learner)", ChangeDetector.class, "ADWINChangeDetector -a 1.0E-4");
-    
-    public FlagOption disableWeightedVote = new FlagOption("disableWeightedVote", 'w', 
-            "Should use weighted voting?");
-    
-    public FlagOption disableDriftDetectionOption = new FlagOption("disableDriftDetection", 'u',
-        "Should use drift detection? If disabled then bkg learner is also disabled");
-
-    public FlagOption disableBackgroundLearnerOption = new FlagOption("disableBackgroundLearner", 'q', 
-        "Should use bkg learner? If disabled then reset tree immediately.");
-    
-    protected static final int FEATURES_M = 0;
-    protected static final int FEATURES_SQRT = 1;
-    protected static final int FEATURES_SQRT_INV = 2;
-    protected static final int FEATURES_PERCENT = 3;
-    
-    protected static final int SINGLE_THREAD = 0;
-	
-    protected ARFBaseLearner[] ensemble;
-    protected long instancesSeen;
-    protected int subspaceSize;
-    protected BasicClassificationPerformanceEvaluator evaluator;
-
-    private ExecutorService executor;
-    
-    @Override
-    public void resetLearningImpl() {
-        // Reset attributes
-        this.ensemble = null;
-        this.subspaceSize = 0;
-        this.instancesSeen = 0;
-        this.evaluator = new BasicClassificationPerformanceEvaluator();
-        
-        // Multi-threading
-        int numberOfJobs;
-        if(this.numberOfJobsOption.getValue() == -1) 
-            numberOfJobs = Runtime.getRuntime().availableProcessors();
-        else 
-            numberOfJobs = this.numberOfJobsOption.getValue();
-        // SINGLE_THREAD and requesting for only 1 thread are equivalent. 
-        // this.executor will be null and not used...
-        if(numberOfJobs != AdaptiveRandomForest.SINGLE_THREAD && numberOfJobs != 1)
-            this.executor = Executors.newFixedThreadPool(numberOfJobs);
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance instance) {
-        ++this.instancesSeen;
-        if(this.ensemble == null) 
-            initEnsemble(instance);
-        
-        Collection<TrainingRunnable> trainers = new ArrayList<TrainingRunnable>();
-        for (int i = 0 ; i < this.ensemble.length ; i++) {
-            DoubleVector vote = new DoubleVector(this.ensemble[i].getVotesForInstance(instance));
-            InstanceExample example = new InstanceExample(instance);
-            this.ensemble[i].evaluator.addResult(example, vote.getArrayRef());
-            int k = MiscUtils.poisson(this.lambdaOption.getValue(), this.classifierRandom);
-            if (k > 0) {
-                if(this.executor != null) {
-                    TrainingRunnable trainer = new TrainingRunnable(this.ensemble[i], 
-                        instance, k, this.instancesSeen);
-                    trainers.add(trainer);
-                }
-                else { // SINGLE_THREAD is in-place... 
-                    this.ensemble[i].trainOnInstance(instance, k, this.instancesSeen);
-                }
-            }
-        }
-        if(this.executor != null) {
-            try {
-                this.executor.invokeAll(trainers);
-            } catch (InterruptedException ex) {
-                throw new RuntimeException("Could not call invokeAll() on training threads.");
-            }
-        }
-    }
-
-    @Override
-    public Prediction getPredictionForInstance(Instance instance) {
-        Instance testInstance = instance.copy();
-        if(this.ensemble == null) 
-            initEnsemble(testInstance);
-        DoubleVector combinedVote = new DoubleVector();
-
-        for(int i = 0 ; i < this.ensemble.length ; ++i) {
-            DoubleVector vote = new DoubleVector(this.ensemble[i].getVotesForInstance(testInstance));
-            if (vote.sumOfValues() > 0.0) {
-                vote.normalize();
-                double acc = this.ensemble[i].evaluator.getPerformanceMeasurements()[1].getValue();
-                if(! this.disableWeightedVote.isSet() && acc > 0.0) {                        
-                    for(int v = 0 ; v < vote.numValues() ; ++v) {
-                        vote.setValue(v, vote.getValue(v) * acc);
-                    }
-                }
-                combinedVote.addValues(vote);
-            }
-        }
-        return new ClassificationPrediction(combinedVote.getArrayRef());
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return true;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder arg0, int arg1) {
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return null;
-    }
-
-    protected void initEnsemble(Instance instance) {
-        // Init the ensemble.
-        int ensembleSize = this.ensembleSizeOption.getValue();
-        this.ensemble = new ARFBaseLearner[ensembleSize];
-        
-        // TODO: this should be an option with default = BasicClassificationPerformanceEvaluator
-//        BasicClassificationPerformanceEvaluator classificationEvaluator = (BasicClassificationPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
-        BasicClassificationPerformanceEvaluator classificationEvaluator = new BasicClassificationPerformanceEvaluator();
-        
-        this.subspaceSize = this.mFeaturesPerTreeSizeOption.getValue();
-  
-        // The size of m depends on:
-        // 1) mFeaturesPerTreeSizeOption
-        // 2) mFeaturesModeOption
-        int n = instance.numAttributes()-1; // Ignore class label ( -1 )
-        
-        switch(this.mFeaturesModeOption.getChosenIndex()) {
-            case AdaptiveRandomForest.FEATURES_SQRT:
-                this.subspaceSize = (int) Math.round(Math.sqrt(n)) + 1;
-                break;
-            case AdaptiveRandomForest.FEATURES_SQRT_INV:
-                this.subspaceSize = n - (int) Math.round(Math.sqrt(n) + 1);
-                break;
-            case AdaptiveRandomForest.FEATURES_PERCENT:
-                // If subspaceSize is negative, then first find out the actual percent, i.e., 100% - m.
-                double percent = this.subspaceSize < 0 ? (100 + this.subspaceSize)/100.0 : this.subspaceSize / 100.0;
-                this.subspaceSize = (int) Math.round(n * percent);
-                break;
-        }
-        // Notice that if the selected mFeaturesModeOption was 
-        //  AdaptiveRandomForest.FEATURES_M then nothing is performed in the
-        //  previous switch-case, still it is necessary to check (and adjusted) 
-        //  for when a negative value was used. 
-        
-        // m is negative, use size(features) + -m
-        if(this.subspaceSize < 0)
-            this.subspaceSize = n + this.subspaceSize;
-        // Other sanity checks to avoid runtime errors. 
-        //  m <= 0 (m can be negative if this.subspace was negative and 
-        //  abs(m) > n), then use m = 1
-        if(this.subspaceSize <= 0)
-            this.subspaceSize = 1;
-        // m > n, then it should use n
-        if(this.subspaceSize > n)
-            this.subspaceSize = n;
-        
-        ARFHoeffdingTree treeLearner = (ARFHoeffdingTree) getPreparedClassOption(this.treeLearnerOption);
-        treeLearner.resetLearning();
-        
-        for(int i = 0 ; i < ensembleSize ; ++i) {
-            treeLearner.subspaceSizeOption.setValue(this.subspaceSize);
-            this.ensemble[i] = new ARFBaseLearner(
-                i, 
-                (ARFHoeffdingTree) treeLearner.copy(), 
-                (BasicClassificationPerformanceEvaluator) classificationEvaluator.copy(), 
-                this.instancesSeen, 
-                ! this.disableBackgroundLearnerOption.isSet(),
-                ! this.disableDriftDetectionOption.isSet(), 
-                driftDetectionMethodOption,
-                warningDetectionMethodOption,
-                false);
-        }
-    }
-
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == AdaptiveRandomForest.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
-    
-    /**
-     * Inner class that represents a single tree member of the forest. 
-     * It contains some analysis information, such as the numberOfDriftsDetected, 
-     */
-    protected final class ARFBaseLearner extends AbstractMOAObject {
-        public int indexOriginal;
-        public long createdOn;
-        public long lastDriftOn;
-        public long lastWarningOn;
-        public ARFHoeffdingTree classifier;
-        public boolean isBackgroundLearner;
-        
-        // The drift and warning object parameters. 
-        protected ClassOption driftOption;
-        protected ClassOption warningOption;
-        
-        // Drift and warning detection
-        protected ChangeDetector driftDetectionMethod;
-        protected ChangeDetector warningDetectionMethod;
-        
-        public boolean useBkgLearner;
-        public boolean useDriftDetector;
-        
-        // Bkg learner
-        protected ARFBaseLearner bkgLearner;
-        // Statistics
-        public BasicClassificationPerformanceEvaluator evaluator;
-        protected int numberOfDriftsDetected;
-        protected int numberOfWarningsDetected;
-
-        private void init(int indexOriginal, ARFHoeffdingTree instantiatedClassifier, BasicClassificationPerformanceEvaluator evaluatorInstantiated, 
-            long instancesSeen, boolean useBkgLearner, boolean useDriftDetector, ClassOption driftOption, ClassOption warningOption, boolean isBackgroundLearner) {
-            this.indexOriginal = indexOriginal;
-            this.createdOn = instancesSeen;
-            this.lastDriftOn = 0;
-            this.lastWarningOn = 0;
-            
-            this.classifier = instantiatedClassifier;
-            this.evaluator = evaluatorInstantiated;
-            this.useBkgLearner = useBkgLearner;
-            this.useDriftDetector = useDriftDetector;
-            
-            this.numberOfDriftsDetected = 0;
-            this.numberOfWarningsDetected = 0;
-            this.isBackgroundLearner = isBackgroundLearner;
-
-            if(this.useDriftDetector) {
-                this.driftOption = driftOption;
-                this.driftDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.driftOption)).copy();
-            }
-
-            // Init Drift Detector for Warning detection. 
-            if(this.useBkgLearner) {
-                this.warningOption = warningOption;
-                this.warningDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.warningOption)).copy();
-            }
-        }
-
-        public ARFBaseLearner(int indexOriginal, ARFHoeffdingTree instantiatedClassifier, BasicClassificationPerformanceEvaluator evaluatorInstantiated, 
-                    long instancesSeen, boolean useBkgLearner, boolean useDriftDetector, ClassOption driftOption, ClassOption warningOption, boolean isBackgroundLearner) {
-            init(indexOriginal, instantiatedClassifier, evaluatorInstantiated, instancesSeen, useBkgLearner, useDriftDetector, driftOption, warningOption, isBackgroundLearner);
-        }
-
-        public void reset() {
-            if(this.useBkgLearner && this.bkgLearner != null) {
-                this.classifier = this.bkgLearner.classifier;
-                
-                this.driftDetectionMethod = this.bkgLearner.driftDetectionMethod;
-                this.warningDetectionMethod = this.bkgLearner.warningDetectionMethod;
-                
-                this.evaluator = this.bkgLearner.evaluator;
-                this.createdOn = this.bkgLearner.createdOn;
-                this.bkgLearner = null;
-            }
-            else {
-                this.classifier.resetLearning();
-                this.createdOn = instancesSeen;
-                this.driftDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.driftOption)).copy();
-            }
-            this.evaluator.reset();
-        }
-
-        public void trainOnInstance(Instance instance, double weight, long instancesSeen) {
-            Instance weightedInstance = (Instance) instance.copy();
-            weightedInstance.setWeight(instance.weight() * weight);
-            this.classifier.trainOnInstance(weightedInstance);
-            
-            if(this.bkgLearner != null)
-                this.bkgLearner.classifier.trainOnInstance(instance);
-            
-            // Should it use a drift detector? Also, is it a backgroundLearner? If so, then do not "incept" another one. 
-            if(this.useDriftDetector && !this.isBackgroundLearner) {
-                boolean correctlyClassifies = this.classifier.correctlyClassifies(instance);
-                // Check for warning only if useBkgLearner is active
-                if(this.useBkgLearner) {
-                    // Update the warning detection method
-                    this.warningDetectionMethod.input(correctlyClassifies ? 0 : 1);
-                    // Check if there was a change
-                    if(this.warningDetectionMethod.getChange()) {
-                        this.lastWarningOn = instancesSeen;
-                        this.numberOfWarningsDetected++;
-                        // Create a new bkgTree classifier
-                        ARFHoeffdingTree bkgClassifier = (ARFHoeffdingTree) this.classifier.copy();
-                        bkgClassifier.resetLearning();
-                        
-                        // Resets the evaluator
-                        BasicClassificationPerformanceEvaluator bkgEvaluator = (BasicClassificationPerformanceEvaluator) this.evaluator.copy();
-                        bkgEvaluator.reset();
-                        
-                        // Create a new bkgLearner object
-                        this.bkgLearner = new ARFBaseLearner(indexOriginal, bkgClassifier, bkgEvaluator, instancesSeen, 
-                            this.useBkgLearner, this.useDriftDetector, this.driftOption, this.warningOption, true);
-                        
-                        // Update the warning detection object for the current object 
-                        // (this effectively resets changes made to the object while it was still a bkg learner). 
-                        this.warningDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.warningOption)).copy();
-                    }
-                }
-                
-                /*********** drift detection ***********/
-                
-                // Update the DRIFT detection method
-                this.driftDetectionMethod.input(correctlyClassifies ? 0 : 1);
-                // Check if there was a change
-                if(this.driftDetectionMethod.getChange()) {
-                    this.lastDriftOn = instancesSeen;
-                    this.numberOfDriftsDetected++;
-                    this.reset();
-                }
-            }
-        }
-
-        public double[] getVotesForInstance(Instance instance) {
-            DoubleVector vote = new DoubleVector(this.classifier.getPredictionForInstance(instance).asDoubleArray());
-            return vote.getArrayRef();
-        }
-
-        @Override
-        public void getDescription(StringBuilder sb, int indent) {
-        }
-    }
-    
-    /***
-     * Inner class to assist with the multi-thread execution. 
-     */
-    protected class TrainingRunnable implements Runnable, Callable<Integer> {
-        final private ARFBaseLearner learner;
-        final private Instance instance;
-        final private double weight;
-        final private long instancesSeen;
-
-        public TrainingRunnable(ARFBaseLearner learner, Instance instance, 
-                double weight, long instancesSeen) {
-            this.learner = learner;
-            this.instance = instance;
-            this.weight = weight;
-            this.instancesSeen = instancesSeen;
-        }
-
-        @Override
-        public void run() {
-            learner.trainOnInstance(this.instance, this.weight, this.instancesSeen);
-        }
-
-        @Override
-        public Integer call() throws Exception {
-            run();
-            return 0;
-        }
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/meta/AdaptiveRandomForestRegressor.java b/moa/src/main/java/moa/classifiers/meta/AdaptiveRandomForestRegressor.java
deleted file mode 100644
index 70e69abd5..000000000
--- a/moa/src/main/java/moa/classifiers/meta/AdaptiveRandomForestRegressor.java
+++ /dev/null
@@ -1,370 +0,0 @@
-/*
- *    AdaptiveRandomForestRegressor.java
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *
- */
-package moa.classifiers.meta;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import moa.AbstractMOAObject;
-import moa.classifiers.Regressor;
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.core.driftdetection.ChangeDetector;
-import moa.classifiers.trees.ARFFIMTDD;
-import moa.core.DoubleVector;
-import moa.core.InstanceExample;
-import moa.core.Measurement;
-import moa.core.MiscUtils;
-import moa.evaluation.BasicRegressionPerformanceEvaluator;
-import moa.options.ClassOption;
-
-/**
- * Implementation of AdaptiveRandomForestRegressor, an extension of AdaptiveRandomForest for classification.
- *
- * <p>See details in:<br> Heitor Murilo Gomes, Jean Paul Barddal, Luis Eduardo Boiko Ferreira, Albert Bifet.
- * Adaptive random forests for data stream regression.
- * In European Symposium on Artificial Neural Networks, Computational Intelligence and Machine Learning (ESANN), 2018.
- * https://www.elen.ucl.ac.be/Proceedings/esann/esannpdf/es2018-183.pdf</p>
- */
-public class AdaptiveRandomForestRegressor extends AbstractClassifier implements Regressor {
-
-    @Override
-    public String getPurposeString() {
-        return "Adaptive Random Forest Regressor algorithm for evolving data streams from Gomes et al.";
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    public ClassOption treeLearnerOption = new ClassOption("treeLearner", 'l',
-            "Random Forest Tree.", ARFFIMTDD.class,
-            "ARFFIMTDD");
-
-    public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's',
-            "The number of trees.", 10, 1, Integer.MAX_VALUE);
-
-    public MultiChoiceOption mFeaturesModeOption = new MultiChoiceOption("mFeaturesMode", 'o',
-            "Defines how m, defined by mFeaturesPerTreeSize, is interpreted. M represents the total number of features.",
-            new String[]{"Specified m (integer value)", "sqrt(M)+1", "M-(sqrt(M)+1)",
-                    "Percentage (M * (m / 100))"},
-            new String[]{"SpecifiedM", "SqrtM1", "MSqrtM1", "Percentage"}, 1);
-
-    public IntOption mFeaturesPerTreeSizeOption = new IntOption("mFeaturesPerTreeSize", 'm',
-            "Number of features allowed considered for each split. Negative values corresponds to M - m", 2, Integer.MIN_VALUE, Integer.MAX_VALUE);
-
-    public FloatOption lambdaOption = new FloatOption("lambda", 'a',
-            "The lambda parameter for bagging.", 6.0, 1.0, Float.MAX_VALUE);
-
-    public ClassOption driftDetectionMethodOption = new ClassOption("driftDetectionMethod", 'x',
-            "Change detector for drifts and its parameters", ChangeDetector.class, "ADWINChangeDetector -a 1.0E-5");
-
-    public ClassOption warningDetectionMethodOption = new ClassOption("warningDetectionMethod", 'p',
-            "Change detector for warnings (start training bkg learner)", ChangeDetector.class, "ADWINChangeDetector -a 1.0E-4");
-
-    public FlagOption disableWeightedVote = new FlagOption("disableWeightedVote", 'w',
-            "Should use weighted voting?");
-
-    public FlagOption disableDriftDetectionOption = new FlagOption("disableDriftDetection", 'u',
-            "Should use drift detection? If disabled then bkg learner is also disabled");
-
-    public FlagOption disableBackgroundLearnerOption = new FlagOption("disableBackgroundLearner", 'q',
-            "Should use bkg learner? If disabled then reset tree immediately.");
-
-    protected static final int FEATURES_M = 0;
-    protected static final int FEATURES_SQRT = 1;
-    protected static final int FEATURES_SQRT_INV = 2;
-    protected static final int FEATURES_PERCENT = 3;
-
-    protected ARFFIMTDDBaseLearner[] ensemble;
-    protected long instancesSeen;
-    protected int subspaceSize;
-    protected BasicRegressionPerformanceEvaluator evaluator;
-
-    @Override
-    public void resetLearningImpl() {
-        // Reset attributes
-        this.ensemble = null;
-        this.subspaceSize = 0;
-        this.instancesSeen = 0;
-        this.evaluator = new BasicRegressionPerformanceEvaluator();
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance instance) {
-        ++this.instancesSeen;
-        if(this.ensemble == null)
-            initEnsemble(instance);
-
-        for (int i = 0 ; i < this.ensemble.length ; i++) {
-            DoubleVector vote = new DoubleVector(this.ensemble[i].getVotesForInstance(instance));
-            InstanceExample example = new InstanceExample(instance);
-            this.ensemble[i].evaluator.addResult(example, vote.getArrayRef());
-            int k = MiscUtils.poisson(this.lambdaOption.getValue(), this.classifierRandom);
-            if (k > 0) {
-                this.ensemble[i].trainOnInstance(instance, k, this.instancesSeen);
-            }
-        }
-    }
-
-    @Override
-    public double[] getVotesForInstance(Instance instance) {
-        Instance testInstance = instance.copy();
-        if(this.ensemble == null)
-            initEnsemble(testInstance);
-        double accounted = 0;
-
-        DoubleVector predictions = new DoubleVector();
-        DoubleVector ages = new DoubleVector();
-        DoubleVector performance = new DoubleVector();
-
-        for(int i = 0 ; i < this.ensemble.length ; ++i) {
-            double currentPrediction = this.ensemble[i].getVotesForInstance(testInstance)[0];
-
-            ages.addToValue(i, this.instancesSeen - this.ensemble[i].createdOn);
-            performance.addToValue(i, this.ensemble[i].evaluator.getSquareError());
-            predictions.addToValue(i, currentPrediction);
-            ++accounted;
-        }
-        double predicted = predictions.sumOfValues() / accounted;
-//        if(predicted >= 1500) {
-//            System.out.println(this.instancesSeen + " = " + predictions);
-//            System.out.println(this.instancesSeen + " = " + ages);
-//            System.out.println(this.instancesSeen + " = " + performance);
-//            System.out.println();
-//        }
-
-        return new double[] {predictions.sumOfValues() / accounted};
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return null;
-    }
-
-    protected void initEnsemble(Instance instance) {
-        // Init the ensemble.
-        int ensembleSize = this.ensembleSizeOption.getValue();
-        this.ensemble = new ARFFIMTDDBaseLearner[ensembleSize];
-
-        // TODO: this should be an option with default = BasicClassificationPerformanceEvaluator
-        BasicRegressionPerformanceEvaluator regressionEvaluator = new BasicRegressionPerformanceEvaluator();
-
-        this.subspaceSize = this.mFeaturesPerTreeSizeOption.getValue();
-
-        // The size of m depends on:
-        // 1) mFeaturesPerTreeSizeOption
-        // 2) mFeaturesModeOption
-        int n = instance.numAttributes()-1; // Ignore class label ( -1 )
-
-        switch(this.mFeaturesModeOption.getChosenIndex()) {
-            case AdaptiveRandomForest.FEATURES_SQRT:
-                this.subspaceSize = (int) Math.round(Math.sqrt(n)) + 1;
-                break;
-            case AdaptiveRandomForest.FEATURES_SQRT_INV:
-                this.subspaceSize = n - (int) Math.round(Math.sqrt(n) + 1);
-                break;
-            case AdaptiveRandomForest.FEATURES_PERCENT:
-                // If subspaceSize is negative, then first find out the actual percent, i.e., 100% - m.
-                double percent = this.subspaceSize < 0 ? (100 + this.subspaceSize)/100.0 : this.subspaceSize / 100.0;
-                this.subspaceSize = (int) Math.round(n * percent);
-                break;
-        }
-        // Notice that if the selected mFeaturesModeOption was
-        //  AdaptiveRandomForest.FEATURES_M then nothing is performed in the
-        //  previous switch-case, still it is necessary to check (and adjusted)
-        //  for when a negative value was used.
-
-        // m is negative, use size(features) + -m
-        if(this.subspaceSize < 0)
-            this.subspaceSize = n + this.subspaceSize;
-        // Other sanity checks to avoid runtime errors.
-        //  m <= 0 (m can be negative if this.subspace was negative and
-        //  abs(m) > n), then use m = 1
-        if(this.subspaceSize <= 0)
-            this.subspaceSize = 1;
-        // m > n, then it should use n
-        if(this.subspaceSize > n)
-            this.subspaceSize = n;
-
-        ARFFIMTDD treeLearner = (ARFFIMTDD) getPreparedClassOption(this.treeLearnerOption);
-        treeLearner.resetLearning();
-
-        for(int i = 0 ; i < ensembleSize ; ++i) {
-            treeLearner.subspaceSizeOption.setValue(this.subspaceSize);
-            this.ensemble[i] = new ARFFIMTDDBaseLearner(
-                    i,
-                    (ARFFIMTDD) treeLearner.copy(),
-                    (BasicRegressionPerformanceEvaluator) regressionEvaluator.copy(),
-                    this.instancesSeen,
-                    ! this.disableBackgroundLearnerOption.isSet(),
-                    ! this.disableDriftDetectionOption.isSet(),
-                    driftDetectionMethodOption,
-                    warningDetectionMethodOption,
-                    false);
-        }
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return true;
-    }
-
-
-    protected final class ARFFIMTDDBaseLearner extends AbstractMOAObject {
-        public int indexOriginal;
-        public long createdOn;
-        public long lastDriftOn;
-        public long lastWarningOn;
-        public ARFFIMTDD classifier;
-        public boolean isBackgroundLearner;
-
-        // The drift and warning object parameters.
-        protected ClassOption driftOption;
-        protected ClassOption warningOption;
-
-        // Drift and warning detection
-        protected ChangeDetector driftDetectionMethod;
-        protected ChangeDetector warningDetectionMethod;
-
-        public boolean useBkgLearner;
-        public boolean useDriftDetector;
-
-        // Bkg learner
-        protected ARFFIMTDDBaseLearner bkgLearner;
-        // Statistics
-        public BasicRegressionPerformanceEvaluator evaluator;
-        protected int numberOfDriftsDetected;
-        protected int numberOfWarningsDetected;
-
-        private void init(int indexOriginal, ARFFIMTDD instantiatedClassifier, BasicRegressionPerformanceEvaluator evaluatorInstantiated,
-                          long instancesSeen, boolean useBkgLearner, boolean useDriftDetector, ClassOption driftOption, ClassOption warningOption, boolean isBackgroundLearner) {
-            this.indexOriginal = indexOriginal;
-            this.createdOn = instancesSeen;
-            this.lastDriftOn = 0;
-            this.lastWarningOn = 0;
-
-            this.classifier = instantiatedClassifier;
-            this.evaluator = evaluatorInstantiated;
-            this.useBkgLearner = useBkgLearner;
-            this.useDriftDetector = useDriftDetector;
-
-            this.numberOfDriftsDetected = 0;
-            this.numberOfWarningsDetected = 0;
-            this.isBackgroundLearner = isBackgroundLearner;
-
-            if(this.useDriftDetector) {
-                this.driftOption = driftOption;
-                this.driftDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.driftOption)).copy();
-            }
-
-            // Init Drift Detector for Warning detection.
-            if(this.useBkgLearner) {
-                this.warningOption = warningOption;
-                this.warningDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.warningOption)).copy();
-            }
-        }
-
-        public ARFFIMTDDBaseLearner(int indexOriginal, ARFFIMTDD instantiatedClassifier, BasicRegressionPerformanceEvaluator evaluatorInstantiated,
-                                    long instancesSeen, boolean useBkgLearner, boolean useDriftDetector, ClassOption driftOption, ClassOption warningOption, boolean isBackgroundLearner) {
-            init(indexOriginal, instantiatedClassifier, evaluatorInstantiated, instancesSeen, useBkgLearner, useDriftDetector, driftOption, warningOption, isBackgroundLearner);
-        }
-
-        public void reset() {
-            if(this.useBkgLearner && this.bkgLearner != null) {
-                this.classifier = this.bkgLearner.classifier;
-
-                this.driftDetectionMethod = this.bkgLearner.driftDetectionMethod;
-                this.warningDetectionMethod = this.bkgLearner.warningDetectionMethod;
-
-                this.evaluator = this.bkgLearner.evaluator;
-                this.createdOn = this.bkgLearner.createdOn;
-                this.bkgLearner = null;
-            }
-            else {
-                this.classifier.resetLearning();
-                this.createdOn = instancesSeen;
-                this.driftDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.driftOption)).copy();
-            }
-            this.evaluator.reset();
-        }
-
-        public void trainOnInstance(Instance instance, double weight, long instancesSeen) {
-            Instance weightedInstance = (Instance) instance.copy();
-            weightedInstance.setWeight(instance.weight() * weight);
-            this.classifier.trainOnInstance(weightedInstance);
-
-            if(this.bkgLearner != null)
-                this.bkgLearner.classifier.trainOnInstance(instance);
-
-            // Should it use a drift detector? Also, is it a backgroundLearner? If so, then do not "incept" another one.
-            if(this.useDriftDetector && !this.isBackgroundLearner) {
-//                boolean correctlyClassifies = this.classifier.correctlyClassifies(instance);
-                double prediction = this.classifier.getVotesForInstance(instance)[0];
-                // Check for warning only if useBkgLearner is active
-                if(this.useBkgLearner) {
-                    // Update the warning detection method
-                    this.warningDetectionMethod.input(prediction);
-                    // Check if there was a change
-                    if(this.warningDetectionMethod.getChange()) {
-                        this.lastWarningOn = instancesSeen;
-                        this.numberOfWarningsDetected++;
-                        // Create a new bkgTree classifier
-                        ARFFIMTDD bkgClassifier = (ARFFIMTDD) this.classifier.copy();
-                        bkgClassifier.resetLearning();
-
-                        // Resets the evaluator
-                        BasicRegressionPerformanceEvaluator bkgEvaluator = (BasicRegressionPerformanceEvaluator) this.evaluator.copy();
-                        bkgEvaluator.reset();
-
-                        // Create a new bkgLearner object
-                        this.bkgLearner = new ARFFIMTDDBaseLearner(indexOriginal, bkgClassifier, bkgEvaluator, instancesSeen,
-                                this.useBkgLearner, this.useDriftDetector, this.driftOption, this.warningOption, true);
-
-                        // Update the warning detection object for the current object
-                        // (this effectively resets changes made to the object while it was still a bkg learner).
-                        this.warningDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.warningOption)).copy();
-                    }
-                }
-
-                /*********** drift detection ***********/
-
-                // Update the DRIFT detection method
-                this.driftDetectionMethod.input(prediction);
-                // Check if there was a change
-                if(this.driftDetectionMethod.getChange()) {
-                    this.lastDriftOn = instancesSeen;
-                    this.numberOfDriftsDetected++;
-                    this.reset();
-                }
-            }
-        }
-
-        public double[] getVotesForInstance(Instance instance) {
-//            DoubleVector vote = new DoubleVector(this.classifier.getVotesForInstance(instance));
-//            return vote.getArrayRef();
-            return this.classifier.getVotesForInstance(instance);
-        }
-
-        @Override
-        public void getDescription(StringBuilder sb, int indent) {
-        }
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/meta/BOLE.java b/moa/src/main/java/moa/classifiers/meta/BOLE.java
deleted file mode 100644
index 06c196669..000000000
--- a/moa/src/main/java/moa/classifiers/meta/BOLE.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/*
- *    BOLE.java
- *    Copyright (C) 2015 Santos, Barros
- *    @authors Silas G. T. C. Santos (sgtcs@cin.ufpe.br)
- *             Roberto Souto Maior de Barros (roberto@cin.ufpe.br) 
- *    @version $Version: 1 $
- *
- *    Evolved from ADOB.java
- *    Copyright (C) 2014 Santos, Goncalves, Barros
- *    @author Silas G. T. C. Santos (sgtcs@cin.ufpe.br)
- *            Paulo M. Goncalves Jr. (paulomgj@gmail.com)
- *            Roberto S. M. Barros (roberto@cin.ufpe.br)
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- */
-
-/**
- * Boosting-like Online Learning Ensemble (BOLE).
- * 
- * published as:
- *     Roberto Souto Maior de Barros, Silas Garrido T. de Carvalho Santos, 
- *     and Paulo Mauricio Goncalves Jr.: 
- *     A Boosting-like Online Learning Ensemble. 
- *     In Proceedings of IEEE International Joint Conference 
- *     on Neural Networks (IJCNN), Vancouver, Canada, 2016.
- *     DOI: 10.1109/IJCNN.2016.7727427
- */
-
-package moa.classifiers.meta;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractClassifier;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.core.MiscUtils;
-import moa.learners.Classifier;
-import moa.options.ClassOption;
-
-public class BOLE extends AbstractClassifier {
-    
-    private static final long serialVersionUID = 1L;
-
-    public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l',
-            "Classifier to train.", Classifier.class,
-            "moa.classifiers.drift.SingleClassifierDrift -l moa.classifiers.trees.HoeffdingTree -d (DDM -n 7 -w 1.2 -o 1.95)");
-
-    public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's',
-            "The number of models to boost.", 10, 1, Integer.MAX_VALUE);
-
-    public FlagOption pureBoostOption = new FlagOption("pureBoost", 
-            'p', "Boost with weights only; no poisson.");
-
-    public FlagOption breakVotesOption = new FlagOption("breakVotes",
-            'b', "Break Votes? unchecked=no, checked=yes");
-
-    public FloatOption errorBoundOption = new FloatOption("errorBound", 
-            'e', "Error bound percentage for allowing experts to vote.",
-            0.5, 0.1, 1.0);
-
-    public FloatOption weightShiftOption = new FloatOption("weightShift", 
-            'w', "Weight shift associated with the error bound.",
-            0.0, 0.0, 5.0);
-    
-    private double memberWeight;
-    private double key_acc; 
-    private int key_position, i, j;
-    private int maxAcc, minAcc, pos;
-    private double lambda_d, k;
-    private boolean correct, okay;
-    private double em, Bm;
-
-    protected Classifier[] ensemble;
-    protected int[] orderPosition;
-    protected double[] scms;
-    protected double[] swms;
-
-    @Override
-    public String getPurposeString() {
-        return "Boosting-like Online Learning Ensemble (BOLE)";
-    }
-
-    @Override
-    public void resetLearningImpl() {
-        this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
-        this.orderPosition = new int[this.ensemble.length];
-        Classifier baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
-        baseLearner.resetLearning();
-        for (i = 0; i < this.ensemble.length; i++) {
-            this.ensemble[i] = (Classifier) baseLearner.copy();
-            this.orderPosition[i] = i;
-        }
-        this.scms = new double[this.ensemble.length];
-        this.swms = new double[this.ensemble.length];
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-	// Calculates current accuracy of experts
-        double[] acc = new double[this.ensemble.length];
-        for (i = 0; i < this.ensemble.length; i++) {
-            acc[i] = this.scms[this.orderPosition[i]] + this.swms[this.orderPosition[i]];
-            if (acc[i] != 0.0) {
-                acc[i] = this.scms[this.orderPosition[i]] / acc[i];
-            }
-        }
-        
-	// Sort by accuracy in ascending order
-        for (i = 1; i < this.ensemble.length; i++) {
-            key_position = this.orderPosition[i];
-            key_acc = acc[i];
-            j = i - 1;
-            while ( (j >=0) && (acc[j] < key_acc) ) {
-                this.orderPosition[j+1] = this.orderPosition[j];
-                acc[j+1] = acc[j];
-                j--;
-            }
-            this.orderPosition[j+1] = key_position;
-            acc[j+1] = key_acc;
-        }
-        
-        correct = false; 
-        maxAcc = 0; 
-        minAcc = this.ensemble.length - 1; 
-        lambda_d = 1.0; 
-        for (i = 0; i < this.ensemble.length; i++) {
-            if (correct) {
-                pos = this.orderPosition[maxAcc];
-                maxAcc++;
-            } else {
-                pos = this.orderPosition[minAcc];
-                minAcc--;
-            }
-            
-            if (this.pureBoostOption.isSet())
-                k = lambda_d;
-            else
-                k = MiscUtils.poisson(lambda_d, this.classifierRandom);
-            
-            if (k > 0.0) {
-                Instance weightedInst = (Instance) inst.copy();
-                weightedInst.setWeight(inst.weight() * k);
-                this.ensemble[pos].trainOnInstance(weightedInst);
-            }
-
-	    // Increases or decreases lambda based on the prediction of instance
-            if (this.ensemble[pos].correctlyClassifies(inst)) {
-                this.scms[pos] += lambda_d;
-                lambda_d *= (this.trainingWeightSeenByModel / (2 * this.scms[pos]));
-                correct = true;
-            } else {
-                this.swms[pos] += lambda_d; 
-                lambda_d *= (this.trainingWeightSeenByModel / (2 * this.swms[pos]));
-                correct = false;
-            }
-        }
-    }
-
-    protected double getEnsembleMemberWeight(int i) {
-        if ( (this.scms[i] > 0.0) && (this.swms[i] > 0.0) ) { 
-            em = this.swms[i] / (this.scms[i] + this.swms[i]);
-            if (em <= this.errorBoundOption.getValue()) {
-                Bm = em / (1.0 - em);
-                okay = true;
-                return Math.log(1.0 / Bm); 
-            } 
-
-        }
-        okay = false;
-        return 0.0;
-    }
-
-    public Prediction getPredictionForInstance(Instance inst) {
-        DoubleVector combinedVote = new DoubleVector(); 
-        for (i = 0; i < this.ensemble.length; i++) {
-            memberWeight = getEnsembleMemberWeight(i) + this.weightShiftOption.getValue(); 
-            if (okay) {
-                DoubleVector vote = new DoubleVector(this.ensemble[i].getPredictionForInstance(inst).asDoubleArray());
-                if (vote.sumOfValues() > 0.0) {
-                    vote.normalize();
-                    vote.scaleValues(memberWeight);
-                    combinedVote.addValues(vote);
-                } 
-            } 
-            else if (this.breakVotesOption.isSet()) {
-                break;
-            }
-        }
-        return new ClassificationPrediction(combinedVote.getArrayRef());
-    }
-
-    public boolean isRandomizable() {
-        return true;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return new Measurement[]{new Measurement("ensemble size",
-                    this.ensemble != null ? this.ensemble.length : 0)};
-    }
-
-    public Classifier[] getSubClassifiers() {
-        return this.ensemble.clone();
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/meta/DACC.java b/moa/src/main/java/moa/classifiers/meta/DACC.java
deleted file mode 100644
index 8b0dd8ca0..000000000
--- a/moa/src/main/java/moa/classifiers/meta/DACC.java
+++ /dev/null
@@ -1,430 +0,0 @@
-/*
- *    DACC.java
- *
- *    @author Ghazal Jaber (ghazal.jaber@gmail.com)
- * 
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.classifiers.meta;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractClassifier;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.learners.Classifier;
-import moa.options.ClassOption;
-
-/**
- * Dynamic Adaptation to Concept Changes. 
- * Ensemble method for data streams that adapts to concept changes.
- * 
- * Reference: JABER, G., CORNUEJOLS, A., and TARROUX, P. A New On-Line Learning Method 
- * for Coping with Recurring Concepts: The ADACC System. In : Neural Information 
- * Processing. Springer Berlin Heidelberg, 2013. p. 595-604.
- * 
- * @author Ghazal Jaber (ghazal.jaber@gmail.com)
- *
- */
-
-public class DACC extends AbstractClassifier implements Classifier {
-
-	private static final long serialVersionUID = 1L;
-	
-	@Override
-    public String getPurposeString() {
-        return "Dynamic Adaptation to Concept Changes for data streams.";
-    }
-        
-    /**
-     * Base classifier
-     */
-    public ClassOption learnerOption = new ClassOption("baseLearner", 'l',
-            "Classifier to train.", Classifier.class, "bayes.NaiveBayes");
-    /**
-     * Ensemble size
-     */
-    public FloatOption memberCountOption = new FloatOption("ensembleSize", 'n', "The maximum number of classifiers in an ensemble.", 20, 1, Integer.MAX_VALUE);
-    /**
-     * Maturity age of classifiers
-     */
-    public FloatOption maturityOption = new FloatOption("maturity", 'a',
-            "The maturity age.", 20, 0, 100);
-    /**
-     * Size of the evaluation window for weights computing
-     */
-    public FloatOption evaluationSizeOption = new FloatOption("evalSize", 'e',
-            "The size of the evaluation window.", 20, 1, 1000);
-    /**
-     * Combination functions: MAX and WVD (MAX leads to a faster reactivity to the change, WVD is more robust to noise) 
-     */
-    public MultiChoiceOption combinationOption= new MultiChoiceOption("cmb", 'c', "The combination function.",
-            new String[]{"MAX","WVD"} , new String[] {"Maximum","Weighted Vote of the best"},
-            0);
-    /**
-     * Ensemble of classifiers
-     */
-    protected Classifier[] ensemble;
-    /**
-     * Weights of classifiers 
-     */
-    protected Pair[] ensembleWeights;
-    /**
-     * Age of classifiers (to compare with maturity age)
-     */
-    protected double[] ensembleAges;    
-    /**
-     * Evaluation windows (recent classification errors)
-     */
-    protected int[][] ensembleWindows;
-    /**
-     * Number of instances from the stream 
-     */
-    protected int nbInstances = 0;
-    
-
-    /**
-     * Initializes the method variables
-     */
-    protected void initVariables(){
-    	int ensembleSize = (int)this.memberCountOption.getValue();
-        this.ensemble = new Classifier[ensembleSize];
-        this.ensembleAges = new double[ensembleSize];
-        this.ensembleWindows = new int[ensembleSize][(int)this.evaluationSizeOption.getValue()];    
-    }
-    
-    @Override
-    public void resetLearningImpl() {
-    
-        Classifier learner = (Classifier) getPreparedClassOption(this.learnerOption);
-        learner.resetLearning();
-
-        initVariables();
-         
-        this.ensembleWeights = new Pair[this.ensemble.length];
-        
-        for (int i = 0; i < this.ensemble.length; i++) {
-            this.ensemble[i] = (Classifier) learner.copy();
-            this.ensembleAges[i] = 0;
-            this.ensembleWeights[i] = new Pair(0.0,i);
-            this.ensembleWindows[i] = new int[(int)this.evaluationSizeOption.getValue()];
-        }
-       
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-    	trainAndClassify(inst);
-    }
-
-    @Override 
-    public Prediction getPredictionForInstance(Instance inst) {
-
-        DoubleVector combinedVote = new DoubleVector();
-        ArrayList<Integer> arr;
-  
-        int cmb = this.combinationOption.getChosenIndex();
-        
-        if (cmb == 0)    
-        	arr = getMAXIndexes();
-        else
-        	arr = getWVDIndexes();
-        
-     
-        if (this.trainingWeightSeenByModel > 0.0) {
-
-            for (int i = 0; i < arr.size(); i++) {
-                if (this.ensembleWeights[arr.get(i)].val > 0.0) {
-
-                    DoubleVector vote = this.ensemble[arr.get(i)].getPredictionForInstance(inst).asDoubleVector();
-
-                    if (vote.sumOfValues() > 0.0) {
-                        vote.normalize();
-                        vote.scaleValues(this.ensembleWeights[arr.get(i)].val);
-                        combinedVote.addValues(vote);
-                    }
-                }
-            }
-        }
-        return new ClassificationPrediction(combinedVote.getArrayRef());
-    }
-
-    
-    /**
-     * Receives a training instance from the stream and 
-     * updates the adaptive classifiers accordingly
-     * @param inst the instance from the stream
-     */
-    protected void trainAndClassify(Instance inst){
-    	
-        nbInstances++;
-    	
-        boolean mature = true;
-        boolean unmature = true;
-        
-    	for (int i = 0; i < getNbActiveClassifiers(); i++) {
-        	
-    		// check if all adaptive learners are mature
-    		if (this.ensembleAges[i] < this.maturityOption.getValue() && i<getNbAdaptiveClassifiers())
-            	mature = false;
-        	
-    		// check if all adaptive learners are not mature 
-        	if (this.ensembleAges[i] >= this.maturityOption.getValue() && i<getNbAdaptiveClassifiers())
-            	unmature = false;
-        	
-        	if (this.nbInstances >= this.ensembleWeights[i].index + 1){
-        
-        		// train adaptive learners
-        		if (i < getNbAdaptiveClassifiers())
-        			this.ensemble[i].trainOnInstance(inst);
-        
-        		int val = this.ensemble[i].correctlyClassifies(inst)?1:0;
-            	double sum = updateEvaluationWindow(i, val);  
-            	this.ensembleWeights[i].val = sum;
-        		this.ensembleAges[i] = this.ensembleAges[i]+1;
-        		
-        	}
-        	
-        }
-    	
-    	// if all adaptive learners are not mature --> set weights to one 
-    	if (unmature)
-        	for (int i = 0; i < getNbAdaptiveClassifiers(); i++)
-        		this.ensembleWeights[i].val=1;
-        		
-    	// if all adaptive learners are mature --> delete one learner
-        if (mature){
-        	Pair[] learners = getHalf(false);
-        	
-        	if (learners.length > 0){
-        		double rand = classifierRandom.nextInt(learners.length);
-        		discardModel(learners[(int)rand].index);		
-        	}
-        }
-	
-    }
-    
-    /**
-     * Resets a classifier in the ensemble
-     * @param index the index of the classifier in the ensemble
-     */
-    public void discardModel(int index) {
-    	this.ensemble[index].resetLearning();
-        this.ensembleWeights[index].val = 0;
-        this.ensembleAges[index] = 0;
-        this.ensembleWindows[index]=new int[(int)this.evaluationSizeOption.getValue()];
-    }
-    
-    /**
-     * Updates the evaluation window of a classifier and returns the
-     * updated weight value.
-     * @param index the index of the classifier in the ensemble
-     * @param val the last evaluation record of the classifier 
-     * @return the updated weight value of the classifier 
-     */
-    protected double updateEvaluationWindow(int index,int val){
-    	
-    	int[] newEnsembleWindows = new int[this.ensembleWindows[index].length]; 	
-    	
-    	int wsize = (int)Math.min(this.evaluationSizeOption.getValue(),this.ensembleAges[index]+1);
-    	
-    	int sum = 0;   
-    	for (int i = 0; i < wsize-1 ; i++){
-    		newEnsembleWindows[i+1] = this.ensembleWindows[index][i];
-    		sum = sum + this.ensembleWindows[index][i];	
-    	}
-    	
-    	newEnsembleWindows[0] = val; 
-    	this.ensembleWindows[index] = newEnsembleWindows; 
-
-    	if (this.ensembleAges[index] >= this.maturityOption.getValue())
-    		return (sum + val) * 1.0/wsize;
-    	else
-    		return 0; 
-    		
-    }
-    
-    /** 
-     * Returns the best (or worst) half of classifiers in the adaptive ensemble.
-     * The best classifiers are used to compute the stability index in ADACC. The worst 
-     * classifiers are returned in order to select a classifier for deletion.  
-     * @param bestHalf boolean value set to true (false) if we want to return 
-     * the best (worst) half of adaptive classifiers.  
-     * @param horizon
-     * @return an array containing the weight values of the corresponding classifiers
-     * and their indexes in the ensemble.
-     */
-    protected Pair[] getHalf(boolean bestHalf){
-    	
-    	Pair[] newEnsembleWeights = new Pair[getNbAdaptiveClassifiers()];
-    	System.arraycopy(ensembleWeights, 0, newEnsembleWeights, 0, newEnsembleWeights.length);
-    	
-    	if (bestHalf)
-    		Arrays.sort(newEnsembleWeights,Collections.reverseOrder());
-    	else
-    		Arrays.sort(newEnsembleWeights);
-    		
-    	Pair[] result = new Pair[(int)Math.floor(newEnsembleWeights.length/2)];
-    	System.arraycopy(newEnsembleWeights, 0, result, 0, result.length);
-    	
-    	return result;
-    }
-    
-    
-    /**
-     * Returns the classifiers that vote for the final prediction
-     * when the MAX combination function is selected
-     * @return the classifiers with the highest weight value
-     */
-    protected ArrayList<Integer> getMAXIndexes(){
-    	
-    	ArrayList<Integer> maxWIndex=new ArrayList<Integer>();
-    	Pair[] newEnsembleWeights = new Pair[getNbActiveClassifiers()];  	
-    	System.arraycopy(ensembleWeights, 0, newEnsembleWeights, 0, newEnsembleWeights.length);
-    	
-    	Arrays.sort(newEnsembleWeights);
-    	
-    	double maxWVal = newEnsembleWeights[newEnsembleWeights.length-1].val;
-    		
-    	for (int i = newEnsembleWeights.length-1 ; i>=0 ; i--){
-    		if (newEnsembleWeights[i].val!=maxWVal)
-    			break;
-    		else
-    			maxWIndex.add(newEnsembleWeights[i].index);
-    		
-    	}
-    	return maxWIndex;
-    }
-
-    /**
-     * Returns the classifiers that vote for the final prediction
-     * when the WVD combination function is selected
-     * @return the classifiers whose weights lie in the higher half 
-     * of the ensemble's weight interval.
-     */
-    protected ArrayList<Integer> getWVDIndexes(){
-    	
-    	ArrayList<Integer> maxWIndex = new ArrayList<Integer>();
-    	
-    	Pair[] newEnsembleWeights = new Pair[getNbActiveClassifiers()];
-    	
-    	System.arraycopy(ensembleWeights, 0, newEnsembleWeights, 0, newEnsembleWeights.length);
-    	
-    	Arrays.sort(newEnsembleWeights);
-    	
-    	double minWVal = newEnsembleWeights[0].val;
-    	double maxWVal = newEnsembleWeights[newEnsembleWeights.length-1].val;
-    	double med = (maxWVal-minWVal)*1.0/2;
-    
-    	for (int i = newEnsembleWeights.length-1 ; i>=0 ; i--)
-    		if (newEnsembleWeights[i].val < med)
-    			break;		
-    		else
-    			maxWIndex.add(newEnsembleWeights[i].index);
-    	
-    	return maxWIndex;
-    }
-    
-    
-    /**
-     * Returns the number of classifiers used for prediction
-     * which includes the adaptive learners and the snapshots in ADACC 
-     * @return the number of classifiers used for prediction
-     */
-    protected int getNbActiveClassifiers(){
-    	return this.ensemble.length;
-    }
-    
-	/** 
-	 * Returns the number of adaptive classifiers in the ensemble 
-	 * which excludes the static snapshots in ADACC  
-	 * @return the number of adaptive classifiers
-	 */
-    protected int getNbAdaptiveClassifiers(){
-    	return this.ensemble.length;
-    }
-    
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        Measurement[] measurements  = new Measurement[4];
-        measurements[0] = new Measurement("size ",
-                    this.ensemble.length);
-        measurements[1] = new Measurement("maturity ",
-                   this.maturityOption.getValue());
-        measurements[2] = new Measurement("evalsize ",
-                   this.evaluationSizeOption.getValue());
-        measurements[3] = new Measurement("cmb ",
-                   this.combinationOption.getChosenIndex());      
-       return measurements;
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return true;
-    }
-
-    public Classifier[] getSubClassifiers() {
-        return this.ensemble.clone();
-    }
-    
-    /**
-     * This helper class is used to sort an array of pairs of integers: val and index. 
-     * The array is sorted based on the val field.
-     * @author Ghazal Jaber
-     *
-     */
-    protected class Pair implements Comparable<Pair>, Serializable   {
- 	   
-		private static final long serialVersionUID = 1L;
-		double val;
-	    int index;
-
-	    public Pair(double d, int i){
-	        this.val = d;
-	        this.index = i;
-	    }
-
-	    @Override
-	    public int compareTo(Pair other){
-	    	if (this.val - other.val > 0 )
-		        	return 1;    
-	    	else
-	    		if (this.val == other.val)
-		        		return 0;    
-	    	return -1;
-	    }
-	    
-	    public double getValue(){
-	    	return val;	
-	    }
-	    
-	}
-
-}
diff --git a/moa/src/main/java/moa/classifiers/meta/DynamicWeightedMajority.java b/moa/src/main/java/moa/classifiers/meta/DynamicWeightedMajority.java
deleted file mode 100644
index 61b642bc0..000000000
--- a/moa/src/main/java/moa/classifiers/meta/DynamicWeightedMajority.java
+++ /dev/null
@@ -1,187 +0,0 @@
-/*
- *    DynamicWeightedMajority.java
- *    Copyright (C) 2016 Instituto Federal de Pernambuco
- *    @author Paulo Gonçalves (paulogoncalves@recife.ifpe.edu.br)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.meta;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractClassifier;
-import moa.core.Measurement;
-import moa.learners.Classifier;
-import moa.options.ClassOption;
-import weka.core.Utils;
-
-/**
- * Dynamic weighted majority algorithm.
- *
- * Extends the Weighted Majority Algorithm to add and remove experts based on
- * local and global accuracy.
- *
- * <p>
- * J. Zico Kolter and Marcus A. Maloof. Dynamic weighted majority: An ensemble
- * method for drifting concepts. The Journal of Machine Learning Research,
- * 8:2755-2790, December 2007. ISSN 1532-4435. URL
- * http://dl.acm.org/citation.cfm?id=1314498.1390333.
- * </p>
- *
- * <p>
- * Based on the source code provided by the author at
- * <a href="http://people.cs.georgetown.edu/~maloof/pubs/jmlr07.php">
- * http://people.cs.georgetown.edu/~maloof/pubs/jmlr07.php</a></p>
- *
- * @author Paulo Goncalves (paulogoncalves at recife dot ifpe dot edu dot br)
- *
- */
-public class DynamicWeightedMajority extends AbstractClassifier implements Classifier {
-
-    public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l',
-            "Base classifiers to train.", Classifier.class, "moa.classifiers.bayes.NaiveBayes");
-
-    public IntOption periodOption = new IntOption("period", 'p',
-            "Period between expert removal, creation, and weight update.", 50,
-            1, Integer.MAX_VALUE);
-
-    public FloatOption betaOption = new FloatOption("beta", 'b',
-            "Factor to punish mistakes by.", 0.5, 0.0, 1.0);
-
-    public FloatOption thetaOption = new FloatOption("theta", 't',
-            "Minimum fraction of weight per model.", 0.01, 0.0, 1.0);
-
-    public IntOption maxExpertsOption = new IntOption("maxExperts", 'e',
-            "Maximum number of allowed experts.", Integer.MAX_VALUE, 2,
-            Integer.MAX_VALUE);
-
-    protected List<Classifier> experts;
-    protected List<Double> weights;
-    protected long epochs;
-
-    @Override
-    public void resetLearningImpl() {
-        this.experts = new ArrayList<>(50);
-        Classifier classifier = (Classifier) ((Classifier) getPreparedClassOption(this.baseLearnerOption)).copy();
-        classifier.resetLearning();
-        this.experts.add(classifier);
-        this.weights = new ArrayList<>(50);
-        this.weights.add(1.0);
-        this.epochs = 0;
-    }
-
-    protected void scaleWeights(double maxWeight) {
-        double sf = 1.0 / maxWeight;
-        for (int i = 0; i < weights.size(); i++) {
-            weights.set(i, weights.get(i) * sf);
-        }
-    }
-
-    protected void removeExperts() {
-        for (int i = experts.size() - 1; i >= 0; i--) {
-            if (weights.get(i) < this.thetaOption.getValue()) {
-                experts.remove(i);
-                weights.remove(i);
-            } // if
-        } // for
-    } // DWM::removeExperts
-
-    protected void removeWeakestExpert(int i) {
-        experts.remove(i);
-        weights.remove(i);
-    } // DWM::removeWeakestExpert
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        this.epochs++;
-        double[] Pr = new double[inst.numClasses()];
-        double maxWeight = 0.0;
-        double weakestExpertWeight = 1.0;
-        int weakestExpertIndex = -1;
-        // Loop over experts
-        for (int i = 0; i < this.experts.size(); i++) {
-            double[] pr = this.experts.get(i).getPredictionForInstance(inst).asDoubleArray();
-            int yHat = Utils.maxIndex(pr);
-            if ((yHat != (int) inst.classValue())
-                    && this.epochs % this.periodOption.getValue() == 0) {
-                this.weights.set(i,
-                        this.weights.get(i) * this.betaOption.getValue());
-            }
-            Pr[yHat] += this.weights.get(i);
-            maxWeight = Math.max(maxWeight, this.weights.get(i));
-            if (this.weights.get(i) < weakestExpertWeight) {
-                weakestExpertIndex = i;
-                weakestExpertWeight = weights.get(i);
-            }
-        }
-        int yHat = Utils.maxIndex(Pr);
-        if (this.epochs % this.periodOption.getValue() == 0) {
-            scaleWeights(maxWeight);
-            removeExperts();
-            if (yHat != (int) inst.classValue()) {
-                if (experts.size() == this.maxExpertsOption.getValue()) {
-                    removeWeakestExpert(weakestExpertIndex);
-                }
-                Classifier classifier = (Classifier) ((Classifier) getPreparedClassOption(this.baseLearnerOption)).copy();
-                classifier.resetLearning();
-                this.experts.add(classifier);
-                this.weights.add(1.0);
-            }
-        }
-        // train experts
-        for (Classifier expert : this.experts) {
-            expert.trainOnInstance(inst);
-        }
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return false;
-    }
-
-    @Override
-    public Prediction getPredictionForInstance(Instance inst) {
-        double[] Pr = new double[inst.numClasses()];
-        for (int i = 0; i < this.experts.size(); i++) {
-            double[] pr = this.experts.get(i).getPredictionForInstance(inst).asDoubleArray();
-            int yHat = Utils.maxIndex(pr);
-            Pr[yHat] += this.weights.get(i);
-        } // for
-        Utils.normalize(Pr);
-        return new ClassificationPrediction(Pr);
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        Measurement[] measurements = null;
-        if (this.weights != null) {
-            measurements = new Measurement[1];
-            measurements[0] = new Measurement("members size", this.weights.size());
-        }
-        return measurements;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/meta/LearnNSE.java b/moa/src/main/java/moa/classifiers/meta/LearnNSE.java
deleted file mode 100644
index 2c38aab19..000000000
--- a/moa/src/main/java/moa/classifiers/meta/LearnNSE.java
+++ /dev/null
@@ -1,283 +0,0 @@
-/*
- *    LearnNSE.java
- *    Copyright (C) 2016 Instituto Federal de Pernambuco
- *    @author Paulo Gonçalves (paulogoncalves@recife.ifpe.edu.br)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.meta;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractClassifier;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.learners.Classifier;
-import moa.options.ClassOption;
-
-/**
- * <p>Ensemble of classifiers-based approach for incremental learning of concept 
- * drift, characterized by nonstationary environments (NSEs), where the 
- * underlying data distributions change over time. It learns from consecutive 
- * batches of data that experience constant or variable rate of drift, 
- * addition or deletion of concept classes, as well as cyclical drift.</p>
- *
- * <p>Based on:
- * Ryan Elwell and Robi Polikar. Incremental learning of concept drift in
- * non-stationary environments. IEEE Transactions on Neural Networks,
- * 22(10):1517-1531, October 2011. ISSN 1045-9227. URL
- * http://dx.doi.org/10.1109/TNN.2011.2160459
- * </p>
- *
- * @author Paulo Gonçalves (paulogoncalves@recife.ifpe.edu.br)
- * @author Dariusz Brzezinski
- *
- *
- */
-public class LearnNSE extends AbstractClassifier implements Classifier {
-
-    public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l',
-            "Classifier to train.", Classifier.class, "bayes.NaiveBayes");
-
-    public IntOption periodOption = new IntOption("period", 'p',
-            "Size of the environments.", 250, 1, Integer.MAX_VALUE);
-
-    public FloatOption sigmoidSlopeOption = new FloatOption(
-            "sigmoidSlope",
-            'a',
-            "Slope of the sigmoid function controlling the number "
-            + "of previous periods taken into account during weighting.",
-            0.5, 0, Float.MAX_VALUE);
-
-    public FloatOption sigmoidCrossingPointOption = new FloatOption(
-            "sigmoidCrossingPoint",
-            'b',
-            "Halfway crossing point of the sigmoid function controlling the number of previous "
-            + "periods taken into account during weighting.", 10, 0,
-            Float.MAX_VALUE);
-
-    public IntOption ensembleSizeOption = new IntOption("ensembleSize", 'e',
-            "Ensemble size.", 15, 1, Integer.MAX_VALUE);
-
-    public MultiChoiceOption pruningStrategyOption = new MultiChoiceOption(
-            "pruningStrategy", 's', "Classifiers pruning strategy to be used.",
-            new String[]{"NO", "AGE", "ERROR"}, new String[]{
-                "Don't prune classifiers", "Age-based", "Error-based"}, 0);
-
-    protected List<Classifier> ensemble;
-    protected List<Double> ensembleWeights;
-    protected List<ArrayList<Double>> bkts, wkts;
-    protected InstancesHeader buffer;
-    protected long index;
-    protected double slope, crossingPoint;
-    protected int pruning, ensembleSize;
-
-    @Override
-    public void resetLearningImpl() {
-        this.ensemble = new ArrayList<>();
-        this.ensembleWeights = new ArrayList<>();
-        this.bkts = new ArrayList<>();
-        this.wkts = new ArrayList<>();
-        this.index = 0;
-        this.buffer = null;
-        this.slope = this.sigmoidSlopeOption.getValue();
-        this.crossingPoint = this.sigmoidCrossingPointOption.getValue();
-        this.pruning = this.pruningStrategyOption.getChosenIndex();
-        this.ensembleSize = this.ensembleSizeOption.getValue();
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        this.index++;
-        // Store instance in the buffer
-        if (this.buffer == null) {
-            this.buffer = inst.dataset().getEmptyHeader();
-        }
-        this.buffer.add(inst);
-
-        if (this.index % this.periodOption.getValue() == 0) {
-            this.index = 0;
-            double mt = this.buffer.numInstances();
-            Classifier classifier = ((Classifier) getPreparedClassOption(this.baseLearnerOption));
-            classifier.resetLearning();
-
-            if (this.ensemble.size() > 0) {
-                double et = 0;
-                // Reading all data chunk instances
-                for (int i = 0; i < mt; i++) {
-                    // Compute error of the existing ensemble on new data
-                    boolean vote = this.correctlyClassifies(this.buffer
-                            .instance(i));
-                    if (!vote) {
-                        et += 1.0 / mt;
-                    }
-                }
-                // Normalizing error
-                double weightSum = 0.0;
-                // Reading all data chunk instances
-                for (int i = 0; i < mt; i++) {
-                    Instance instance = this.buffer.instance(i);
-                    // Updating instance weights
-                    boolean vote = this.correctlyClassifies(instance);
-                    double error = (1.0 / mt) * (vote ? et : 1.0);
-                    instance.setWeight(error);
-                    weightSum += error;
-                }
-                // Reading all data chunk instances
-                for (int i = 0; i < mt; i++) {
-                    Instance instance = this.buffer.instance(i);
-                    // Normalize weights
-                    instance.setWeight(instance.weight() / weightSum);
-
-                    // Call base classifier
-                    Instance trainingInstance = (Instance) instance.copy();
-                    trainingInstance.setWeight(1);
-                    classifier.trainOnInstance(trainingInstance);
-                }
-            } else {
-                // First run! Iterating through all instances in the data chunk
-                for (int i = 0; i < mt; i++) {
-                    Instance instance = this.buffer.instance(i);
-
-                    // Initialize weights
-                    instance.setWeight(1.0 / mt);
-
-                    // Call base classifier
-                    Instance trainingInstance = (Instance) instance.copy();
-                    trainingInstance.setWeight(1);
-                    classifier.trainOnInstance(trainingInstance);
-                }
-            }
-            this.ensemble.add(classifier);
-            this.bkts.add(new ArrayList());
-            this.wkts.add(new ArrayList());
-            this.ensembleWeights.clear();
-            int t = this.ensemble.size();
-            double maxError = Double.NEGATIVE_INFINITY;
-            int errorIndex = Integer.MIN_VALUE;
-            // Evaluate all existing classifiers on new data set
-            for (int k = 1; k <= t; k++) {
-                double ekt = 0;
-                // Reading all data chunk instances
-                for (int i = 0; i < mt; i++) {
-                    Instance instance = this.buffer.instance(i);
-                    if (!this.ensemble.get(k - 1).correctlyClassifies(instance)) {
-                        // Ensemble incorrectly classifies this instance
-                        ekt += instance.weight();
-                    }
-                }
-                if (k == t && ekt > 0.5) {
-                    // Generate a new classifier
-                    Classifier c = (Classifier) getPreparedClassOption(this.baseLearnerOption);
-                    c.resetLearning();
-                    this.ensemble.set(k - 1, c);
-                } else if (ekt > 0.5) {
-                    // Remove voting power of this classifier
-                    ekt = 0.5;
-                }
-				// Storing the index of the classifier with higher error in case
-                // of error-based pruning
-                if (ekt > maxError) {
-                    maxError = ekt;
-                    errorIndex = k;
-                }
-                // Normalizing errors
-                double bkt = ekt / (1.0 - ekt);
-                // Retrieving normalized errors for this classifier
-                ArrayList<Double> nbkt = this.bkts.get(k - 1);
-                nbkt.add(bkt);
-				// Compute the weighted average of all normalized errors for kth
-                // classifier h_k
-                double wkt = 1.0 / (1.0 + Math.exp(-this.slope
-                        * (t - k - this.crossingPoint)));
-                List<Double> weights = this.wkts.get(k - 1);
-                double sum = 0;
-                for (Double weight : weights) {
-                    sum += weight;
-                }
-                weights.add(wkt / (sum + wkt));
-                double sbkt = 0.0;
-                for (int j = 0; j < weights.size(); j++) {
-                    sbkt += weights.get(j) * nbkt.get(j);
-                }
-                // Calculate classifier voting weights
-                this.ensembleWeights.add(Math.log(1.0 / sbkt));
-            }
-            // Ensemble pruning strategy				
-            if (pruning == 1 && t > ensembleSize) { // Age-based
-                this.ensemble.remove(0);
-                this.ensembleWeights.remove(0);
-                this.bkts.remove(0);
-                this.wkts.remove(0);
-            } else if (pruning == 2 && t > ensembleSize) { // Error-based
-                this.ensemble.remove(errorIndex - 1);
-                this.ensembleWeights.remove(errorIndex - 1);
-                this.bkts.remove(errorIndex - 1);
-                this.wkts.remove(errorIndex - 1);
-            }
-            this.buffer = this.getModelContext().getEmptyHeader();
-        }
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return false;
-    }
-
-    @Override
-    public Prediction getPredictionForInstance(Instance inst) {
-        DoubleVector combinedVote = new DoubleVector();
-        if (this.trainingWeightSeenByModel > 0.0) {
-            for (int i = 0; i < this.ensemble.size(); i++) {
-                if (this.ensembleWeights.get(i) > 0.0) {
-                    DoubleVector vote = this.ensemble.get(i)
-                            .getPredictionForInstance(inst).asDoubleVector();
-                    if (vote.sumOfValues() > 0.0) {
-                        vote.normalize();
-                        vote.scaleValues(this.ensembleWeights.get(i));
-                        combinedVote.addValues(vote);
-                    }
-                }
-            }
-        }
-        return new ClassificationPrediction(combinedVote.getArrayRef());
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        Measurement[] measurements = null;
-        if (this.ensembleWeights != null) {
-            measurements = new Measurement[this.ensembleWeights.size()];
-            for (int i = 0; i < this.ensembleWeights.size(); i++) {
-                measurements[i] = new Measurement("member weight " + (i + 1),
-                        this.ensembleWeights.get(i));
-            }
-        }
-        return measurements;
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/meta/LeveragingBag.java b/moa/src/main/java/moa/classifiers/meta/LeveragingBag.java
deleted file mode 100644
index e693007da..000000000
--- a/moa/src/main/java/moa/classifiers/meta/LeveragingBag.java
+++ /dev/null
@@ -1,285 +0,0 @@
-/*
- *    LeveragingBag.java
- *    Copyright (C) 2010 University of Waikato, Hamilton, New Zealand
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.meta;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-
-import moa.capabilities.CapabilitiesHandler;
-import moa.capabilities.Capability;
-import moa.capabilities.ImmutableCapabilities;
-import moa.options.ClassOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.core.driftdetection.ADWIN;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.core.MiscUtils;
-import moa.learners.Classifier;
-
-/**
- * Leveraging Bagging for evolving data streams using ADWIN. Leveraging Bagging
- * and Leveraging Bagging MC using Random Output Codes ( -o option).
- *
- * <p>See details in:<br /> Albert Bifet, Geoffrey Holmes, Bernhard Pfahringer.
- * Leveraging Bagging for Evolving Data Streams Machine Learning and Knowledge
- * Discovery in Databases, European Conference, ECML PKDD}, 2010.</p>
- *
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @version $Revision: 7 $
- */
-public class LeveragingBag extends AbstractClassifier implements Classifier,
-                                                                 CapabilitiesHandler {
-
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public String getPurposeString() {
-        return "Leveraging Bagging for evolving data streams using ADWIN.";
-    }
-
-    public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l',
-            "Classifier to train.", Classifier.class, "moa.classifiers.trees.HoeffdingTree");
-
-    public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's',
-            "The number of models in the bag.", 10, 1, Integer.MAX_VALUE);
-
-    public FloatOption weightShrinkOption = new FloatOption("weightShrink", 'w',
-            "The number to use to compute the weight of new instances.", 6, 0.0, Float.MAX_VALUE);
-
-    public FloatOption deltaAdwinOption = new FloatOption("deltaAdwin", 'a',
-            "Delta of Adwin change detection", 0.002, 0.0, 1.0);
-
-    // Leveraging Bagging MC: uses this option to use Output Codes
-    public FlagOption outputCodesOption = new FlagOption("outputCodes", 'o',
-            "Use Output Codes to use binary classifiers.");
-
-    public MultiChoiceOption leveraginBagAlgorithmOption = new MultiChoiceOption(
-            "leveraginBagAlgorithm", 'm', "Leveraging Bagging to use.", new String[]{
-                "LeveragingBag", "LeveragingBagME", "LeveragingBagHalf", "LeveragingBagWT", "LeveragingSubag"},
-            new String[]{"Leveraging Bagging for evolving data streams using ADWIN",
-                "Leveraging Bagging ME using weight 1 if misclassified, otherwise error/(1-error)",
-                "Leveraging Bagging Half using resampling without replacement half of the instances",
-                "Leveraging Bagging WT without taking out all instances.",
-                "Leveraging Subagging using resampling without replacement."
-            }, 0);
-
-    protected Classifier[] ensemble;
-
-    protected ADWIN[] ADError;
-
-    protected int numberOfChangesDetected;
-
-    protected int[][] matrixCodes;
-
-    protected boolean initMatrixCodes = false;
-
-    @Override
-    public void resetLearningImpl() {
-        this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
-        Classifier baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
-        baseLearner.resetLearning();
-        for (int i = 0; i < this.ensemble.length; i++) {
-            this.ensemble[i] = (Classifier) baseLearner.copy();
-        }
-        this.ADError = new ADWIN[this.ensemble.length];
-        for (int i = 0; i < this.ensemble.length; i++) {
-            this.ADError[i] = new ADWIN((double) this.deltaAdwinOption.getValue());
-        }
-        this.numberOfChangesDetected = 0;
-        if (this.outputCodesOption.isSet()) {
-            this.initMatrixCodes = true;
-        }
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        int numClasses = inst.numClasses();
-        //Output Codes
-        if (this.initMatrixCodes == true) {
-            this.matrixCodes = new int[this.ensemble.length][inst.numClasses()];
-            for (int i = 0; i < this.ensemble.length; i++) {
-                int numberOnes;
-                int numberZeros;
-
-                do { // until we have the same number of zeros and ones
-                    numberOnes = 0;
-                    numberZeros = 0;
-                    for (int j = 0; j < numClasses; j++) {
-                        int result = 0;
-                        if (j == 1 && numClasses == 2) {
-                            result = 1 - this.matrixCodes[i][0];
-                        } else {
-                            result = (this.classifierRandom.nextBoolean() ? 1 : 0);
-                        }
-                        this.matrixCodes[i][j] = result;
-                        if (result == 1) {
-                            numberOnes++;
-                        } else {
-                            numberZeros++;
-                        }
-                    }
-                } while ((numberOnes - numberZeros) * (numberOnes - numberZeros) > (this.ensemble.length % 2));
-
-            }
-            this.initMatrixCodes = false;
-        }
-
-
-        boolean Change = false;
-        Instance weightedInst = (Instance) inst.copy();
-        double w = this.weightShrinkOption.getValue();
-
-        //Train ensemble of classifiers
-        for (int i = 0; i < this.ensemble.length; i++) {
-            double k = 0.0;
-            switch (this.leveraginBagAlgorithmOption.getChosenIndex()) {
-                case 0: //LeveragingBag
-                    k = MiscUtils.poisson(w, this.classifierRandom);
-                    break;
-                case 1: //LeveragingBagME
-                    double error = this.ADError[i].getEstimation();
-                    k = !this.ensemble[i].correctlyClassifies(weightedInst) ? 1.0 : (this.classifierRandom.nextDouble() < (error / (1.0 - error)) ? 1.0 : 0.0);
-                    break;
-                case 2: //LeveragingBagHalf
-                    w = 1.0;
-                    k = this.classifierRandom.nextBoolean() ? 0.0 : w;
-                    break;
-                case 3: //LeveragingBagWT
-                    w = 1.0;
-                    k = 1.0 + MiscUtils.poisson(w, this.classifierRandom);
-                    break;
-                case 4: //LeveragingSubag
-                    w = 1.0;
-                    k = MiscUtils.poisson(1, this.classifierRandom);
-                    k = (k > 0) ? w : 0;
-                    break;
-            }
-            if (k > 0) {
-                if (this.outputCodesOption.isSet()) {
-                    weightedInst.setClassValue((double) this.matrixCodes[i][(int) inst.classValue()]);
-                }
-                weightedInst.setWeight(inst.weight() * k);
-                this.ensemble[i].trainOnInstance(weightedInst);
-            }
-            boolean correctlyClassifies = this.ensemble[i].correctlyClassifies(weightedInst);
-            double ErrEstim = this.ADError[i].getEstimation();
-            if (this.ADError[i].setInput(correctlyClassifies ? 0 : 1)) {
-                if (this.ADError[i].getEstimation() > ErrEstim) {
-                    Change = true;
-                }
-            }
-        }
-        if (Change) {
-            numberOfChangesDetected++;
-            double max = 0.0;
-            int imax = -1;
-            for (int i = 0; i < this.ensemble.length; i++) {
-                if (max < this.ADError[i].getEstimation()) {
-                    max = this.ADError[i].getEstimation();
-                    imax = i;
-                }
-            }
-            if (imax != -1) {
-                this.ensemble[imax].resetLearning();
-                //this.ensemble[imax].trainOnInstance(inst);
-                this.ADError[imax] = new ADWIN((double) this.deltaAdwinOption.getValue());
-            }
-        }
-    }
-
-    @Override
-    public Prediction getPredictionForInstance(Instance inst) {
-        if (this.outputCodesOption.isSet()) {
-            return getPredictionForInstanceBinary(inst);
-        }
-        DoubleVector combinedVote = new DoubleVector();
-        for (int i = 0; i < this.ensemble.length; i++) {
-            DoubleVector vote = this.ensemble[i].getPredictionForInstance(inst).asDoubleVector();
-            if (vote.sumOfValues() > 0.0) {
-                vote.normalize();
-                combinedVote.addValues(vote);
-            }
-        }
-        return new ClassificationPrediction(combinedVote.getArrayRef());
-    }
-
-    public Prediction getPredictionForInstanceBinary(Instance inst) {
-        double combinedVote[] = new double[(int) inst.numClasses()];
-        Instance weightedInst = (Instance) inst.copy();
-        if (this.initMatrixCodes == false) {
-            for (int i = 0; i < this.ensemble.length; i++) {
-                //Replace class by OC
-                weightedInst.setClassValue((double) this.matrixCodes[i][(int) inst.classValue()]);
-
-                double vote[];
-                vote = this.ensemble[i].getPredictionForInstance(weightedInst).asDoubleArray();
-                //Binary Case
-                int voteClass = 0;
-                if (vote.length == 2) {
-                    voteClass = (vote[1] > vote[0] ? 1 : 0);
-                }
-                //Update votes
-                for (int j = 0; j < inst.numClasses(); j++) {
-                    if (this.matrixCodes[i][j] == voteClass) {
-                        combinedVote[j] += 1;
-                    }
-                }
-            }
-        }
-        return new ClassificationPrediction(combinedVote);
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return true;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return new Measurement[]{new Measurement("ensemble size",
-                    this.ensemble != null ? this.ensemble.length : 0),
-                    new Measurement("change detections", this.numberOfChangesDetected)
-                };
-    }
-
-    public Classifier[] getSubClassifiers() {
-        return this.ensemble.clone();
-    }
-
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == LeveragingBag.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
-}
-
diff --git a/moa/src/main/java/moa/classifiers/meta/LimAttClassifier.java b/moa/src/main/java/moa/classifiers/meta/LimAttClassifier.java
deleted file mode 100644
index b697e12d3..000000000
--- a/moa/src/main/java/moa/classifiers/meta/LimAttClassifier.java
+++ /dev/null
@@ -1,539 +0,0 @@
-/*
- *    LimAttClassifier.java
- *    Copyright (C) 2010 University of Waikato, Hamilton, New Zealand
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *    @author Eibe Frank (eibe{[at]}cs{[dot]}waikato{[dot]}ac{[dot]}nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.meta;
-
-import java.math.BigInteger;
-import java.util.Arrays;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.core.driftdetection.ADWIN;
-import moa.classifiers.trees.LimAttHoeffdingTree;
-import moa.core.Measurement;
-import moa.core.Utils;
-import moa.learners.Classifier;
-import moa.options.ClassOption;
-
-/**
- * Ensemble Combining Restricted Hoeffding Trees using Stacking.
- * It produces a classification model based on an
- * ensemble of restricted decision trees, where each tree is built from a
- * distinct subset of the attributes. The overall model is formed by
- * combining the log-odds of the predicted class probabilities of these trees
- * using sigmoid perceptrons, with one perceptron per class.
- * In contrast to the standard boosting approach,
- * which forms an ensemble classifier in a greedy fashion, building each tree in
- * sequence and assigning corresponding weights as a by-product, our
- * method generates each tree in parallel and combines them using perceptron
- * classifiers by adopting the stacking approach.
- *
- * For more information see,<br/>
- * <br/>
- * Albert Bifet, Eibe Frank, Geoffrey Holmes, Bernhard Pfahringer: Accurate
- * Ensembles for Data Streams: Combining Restricted Hoeffding Trees using Stacking.
- * Journal of Machine Learning Research - Proceedings Track 13: 225-240 (2010)
- *
-<!-- technical-bibtex-start -->
- * BibTeX:
- * <pre>
- * &#64;article{BifetFHP10,
- * author    = {Albert Bifet and
- *              Eibe Frank and
- *              Geoffrey Holmes and
- *              Bernhard Pfahringer},
- * title     = {Accurate Ensembles for Data Streams: Combining Restricted
- *              Hoeffding Trees using Stacking},
- * journal   = {Journal of Machine Learning Research - Proceedings Track},
- * volume    = {13},
- * year      = {2010},
- * pages     = {225-240}
- * }
- * </pre>
- * <p/>
-<!-- technical-bibtex-end -->
- *
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @author Eibe Frank (eibe{[at]}cs{[dot]}waikato{[dot]}ac{[dot]}nz)
- * @version $Revision: 7 $
- */
-public class LimAttClassifier extends AbstractClassifier implements Classifier {
-
-    @Override
-    public String getPurposeString() {
-        return "Ensemble Combining Restricted Hoeffding Trees using Stacking";
-    }    
-    
-    /*
-     * Class that generates all combinations of n elements, taken
-     * r at a time. The algorithm is described by
-     *
-     * Kenneth H. Rosen, Discrete Mathematics and Its Applications,
-     * 2nd edition (NY: McGraw-Hill, 1991), pp. 284-286.
-     *
-     *  @author Michael Gilleland (megilleland@yahoo.com)
-     */
-    public class CombinationGenerator {
-
-        private int[] a;
-
-        private int n;
-
-        private int r;
-
-        private BigInteger numLeft;
-
-        private BigInteger total;
-        //------------
-        // Constructor
-        //------------
-
-        public CombinationGenerator(int n, int r) {
-            if (r > n) {
-                throw new IllegalArgumentException();
-            }
-            if (n < 1) {
-                throw new IllegalArgumentException();
-            }
-            this.n = n;
-            this.r = r;
-            a = new int[r];
-            BigInteger nFact = getFactorial(n);
-            BigInteger rFact = getFactorial(r);
-            BigInteger nminusrFact = getFactorial(n - r);
-            total = nFact.divide(rFact.multiply(nminusrFact));
-            reset();
-        }
-        //------
-        // Reset
-        //------
-
-        public void reset() {
-            for (int i = 0; i < a.length; i++) {
-                a[i] = i;
-            }
-            numLeft = new BigInteger(total.toString());
-        }
-        //------------------------------------------------
-        // Return number of combinations not yet generated
-        //------------------------------------------------
-
-        public BigInteger getNumLeft() {
-            return numLeft;
-        }
-        //-----------------------------
-        // Are there more combinations?
-        //-----------------------------
-
-        public boolean hasMore() {
-            return numLeft.compareTo(BigInteger.ZERO) == 1;
-        }
-        //------------------------------------
-        // Return total number of combinations
-        //------------------------------------
-
-        public BigInteger getTotal() {
-            return total;
-        }
-        //------------------
-        // Compute factorial
-        //------------------
-
-        private BigInteger getFactorial(int n) {
-            BigInteger fact = BigInteger.ONE;
-            for (int i = n; i > 1; i--) {
-                fact = fact.multiply(new BigInteger(Integer.toString(i)));
-            }
-            return fact;
-        }
-        //--------------------------------------------------------
-        // Generate next combination (algorithm from Rosen p. 286)
-        //--------------------------------------------------------
-
-        public int[] getNext() {
-            if (numLeft.equals(total)) {
-                numLeft = numLeft.subtract(BigInteger.ONE);
-                int[] b = new int[a.length];
-                for (int k = 0; k < a.length; k++) {
-                    b[k] = a[k];
-                }
-                return b;
-            }
-            int i = r - 1;
-            while (a[i] == n - r + i) {
-                i--;
-            }
-            a[i] = a[i] + 1;
-            for (int j = i + 1; j < r; j++) {
-                a[j] = a[i] + j - i;
-            }
-            numLeft = numLeft.subtract(BigInteger.ONE);
-            int[] b = new int[a.length];
-            for (int k = 0; k < a.length; k++) {
-                b[k] = a[k];
-            }
-            return b;
-        }
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l',
-            "Classifier to train.", Classifier.class, "moa.classifiers.trees.LimAttHoeffdingTree");
-
-    public IntOption numAttributesOption = new IntOption("numAttributes", 'n',
-            "The number of attributes to use per model.", 1, 1, Integer.MAX_VALUE);
-
-    public FloatOption weightShrinkOption = new FloatOption("weightShrink", 'w',
-            "The number to multiply the weight misclassified counts.", 0.5, 0.0, Float.MAX_VALUE);
-
-    public FloatOption deltaAdwinOption = new FloatOption("deltaAdwin", 'a',
-            "Delta of Adwin change detection", 0.002, 0.0, 1.0);
-
-    public FloatOption oddsOffsetOption = new FloatOption("oddsOffset", 'o',
-            "Offset for odds to avoid probabilities that are zero.", 0.001, 0.0, Float.MAX_VALUE);
-
-    public FlagOption pruneOption = new FlagOption("prune", 'x',
-            "Enable pruning.");
-
-    public FlagOption bigTreesOption = new FlagOption("bigTrees", 'b',
-            "Use m-n attributes on the trees.");
-
-    public IntOption numEnsemblePruningOption = new IntOption("numEnsemblePruning", 'm',
-            "The pruned number of classifiers to use to predict.", 10, 1, Integer.MAX_VALUE);
-
-    public FlagOption adwinReplaceWorstClassifierOption = new FlagOption("adwinReplaceWorstClassifier", 'z',
-            "When one Adwin detects change, replace worst classifier.");
-
-    protected Classifier[] ensemble;
-
-    protected ADWIN[] ADError;
-
-    protected int numberOfChangesDetected;
-
-    protected int[][] matrixCodes;
-
-    protected boolean initMatrixCodes = false;
-
-    protected boolean initClassifiers = false;
-
-    protected int numberAttributes = 1;
-
-    protected int numInstances = 0;
-
-    @Override
-    public void resetLearningImpl() {
-        this.initClassifiers = true;
-        this.reset = true;
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        int numClasses = inst.numClasses();
-        //Init Ensemble
-        if (this.initClassifiers == true) {
-            numberAttributes = numAttributesOption.getValue();
-            if (bigTreesOption.isSet()) {
-                numberAttributes = inst.numAttributes() - 1 - numAttributesOption.getValue();
-            }
-            CombinationGenerator x = new CombinationGenerator(inst.numAttributes() - 1, this.numberAttributes);
-            int numberClassifiers = x.getTotal().intValue();
-            this.ensemble = new Classifier[numberClassifiers];
-            Classifier baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
-            baseLearner.resetLearning();
-            for (int i = 0; i < this.ensemble.length; i++) {
-                this.ensemble[i] = (Classifier) baseLearner.copy();
-            }
-            this.ADError = new ADWIN[this.ensemble.length];
-            for (int i = 0; i < this.ensemble.length; i++) {
-                this.ADError[i] = new ADWIN((double) this.deltaAdwinOption.getValue());
-            }
-            this.numberOfChangesDetected = 0;
-            //Prepare combinations
-            int i = 0;
-            if (baseLearner instanceof LimAttHoeffdingTree) {
-                while (x.hasMore()) {
-                    ((LimAttHoeffdingTree) this.ensemble[i]).setlistAttributes(x.getNext());
-                    i++;
-                }
-            }
-
-            this.initClassifiers = false;
-        }
-
-        boolean Change = false;
-        Instance weightedInst = (Instance) inst.copy();
-
-        //Train Perceptron
-        double[][] votes = new double[this.ensemble.length + 1][numClasses];
-        for (int i = 0; i < this.ensemble.length; i++) {
-            double[] v = new double[numClasses];
-            for (int j = 0; j < v.length; j++) {
-                v[j] = (double) this.oddsOffsetOption.getValue();
-            }
-            double[] vt = this.ensemble[i].getPredictionForInstance(inst).asDoubleArray();
-            double sum = Utils.sum(vt);
-            if (!Double.isNaN(sum) && (sum > 0)) {
-                for (int j = 0; j < vt.length; j++) {
-                    vt[j] /= sum;
-                }
-            } else {
-                // Just in case the base learner returns NaN
-                for (int k = 0; k < vt.length; k++) {
-                    vt[k] = 0.0;
-                }
-            }
-            sum = numClasses * (double) this.oddsOffsetOption.getValue();
-            for (int j = 0; j < vt.length; j++) {
-                v[j] += vt[j];
-                sum += vt[j];
-            }
-            for (int j = 0; j < vt.length; j++) {
-                votes[i][j] = Math.log(v[j] / (sum - v[j]));
-            }
-        }
-
-        if (adwinReplaceWorstClassifierOption.isSet() == false) {
-            //Train ensemble of classifiers
-            for (int i = 0; i < this.ensemble.length; i++) {
-                boolean correctlyClassifies = this.ensemble[i].correctlyClassifies(weightedInst);
-                double ErrEstim = this.ADError[i].getEstimation();
-                if (this.ADError[i].setInput(correctlyClassifies ? 0 : 1)) {
-                    numInstances = initialNumInstancesOption.getValue();
-                    if (this.ADError[i].getEstimation() > ErrEstim) {
-                        Change = true;
-                        //Replace classifier if ADWIN has detected change
-                        numberOfChangesDetected++;
-                        this.ensemble[i].resetLearning();
-                        this.ADError[i] = new ADWIN((double) this.deltaAdwinOption.getValue());
-                        for (int ii = 0; ii < inst.numClasses(); ii++) {
-                            weightAttribute[ii][i] = 0.0;// 0.2 * Math.random() - 0.1;
-                        }
-                    }
-                }
-            }
-        } else {
-            //Train ensemble of classifiers
-            for (int i = 0; i < this.ensemble.length; i++) {
-                boolean correctlyClassifies = this.ensemble[i].correctlyClassifies(weightedInst);
-                double ErrEstim = this.ADError[i].getEstimation();
-                if (this.ADError[i].setInput(correctlyClassifies ? 0 : 1)) {
-                    if (this.ADError[i].getEstimation() > ErrEstim) {
-                        Change = true;
-                    }
-                }
-            }
-            //Replace classifier with higher error if ADWIN has detected change
-            if (Change) {
-                numberOfChangesDetected++;
-                double max = 0.0;
-                int imax = -1;
-                for (int i = 0; i < this.ensemble.length; i++) {
-                    if (max < this.ADError[i].getEstimation()) {
-                        max = this.ADError[i].getEstimation();
-                        imax = i;
-                    }
-                }
-                if (imax != -1) {
-                    this.ensemble[imax].resetLearning();
-                    this.ADError[imax] = new ADWIN((double) this.deltaAdwinOption.getValue());
-                    for (int ii = 0; ii < inst.numClasses(); ii++) {
-                        weightAttribute[ii][imax] = 0.0;
-                    }
-                }
-            }
-        }
-
-        trainOnInstanceImplPerceptron(inst.numClasses(), (int) inst.classValue(), votes);
-
-        for (int i = 0; i < this.ensemble.length; i++) {
-            this.ensemble[i].trainOnInstance(inst);
-        }
-    }
-
-    @Override
-    public Prediction getPredictionForInstance(Instance inst) {
-        if (this.initClassifiers == true) {
-            return new ClassificationPrediction();
-        }
-        int numClasses = inst.numClasses();
-
-        int sizeEnsemble = this.ensemble.length;
-        if (pruneOption.isSet()) {
-            sizeEnsemble = this.numEnsemblePruningOption.getValue();
-        }
-
-        double[][] votes = new double[sizeEnsemble + 1][numClasses];
-        int[] bestClassifiers = new int[sizeEnsemble];
-        if (pruneOption.isSet()) {
-            //Check for the best classifiers
-            double[] weight = new double[this.ensemble.length];
-            for (int i = 0; i < numClasses; i++) {
-                for (int j = 0; j < this.ensemble.length; j++) {
-                    weight[j] += weightAttribute[i][j];
-                }
-            }
-            Arrays.sort(weight);
-            double cutValue = weight[this.ensemble.length - sizeEnsemble]; //reverse order
-            int ii = 0;
-            for (int j = 0; j < this.ensemble.length; j++) {
-                if (weight[j] >= cutValue && ii < sizeEnsemble) {
-                    bestClassifiers[ii] = j;
-                    ii++;
-                }
-            }
-        } else { //Not pruning: all classifiers
-            for (int ii = 0; ii < sizeEnsemble; ii++) {
-                bestClassifiers[ii] = ii;
-            }
-        }
-        for (int ii = 0; ii < sizeEnsemble; ii++) {
-            int i = bestClassifiers[ii];
-            double[] v = new double[numClasses];
-            for (int j = 0; j < v.length; j++) {
-                v[j] = (double) this.oddsOffsetOption.getValue();
-            }
-            double[] vt = this.ensemble[i].getPredictionForInstance(inst).asDoubleArray();
-            double sum = Utils.sum(vt);
-            if (!Double.isNaN(sum) && (sum > 0)) {
-                for (int j = 0; j < vt.length; j++) {
-                    vt[j] /= sum;
-                }
-            } else {
-                // Just in case the base learner returns NaN
-                for (int k = 0; k < vt.length; k++) {
-                    vt[k] = 0.0;
-                }
-            }
-            sum = numClasses * (double) this.oddsOffsetOption.getValue();
-            for (int j = 0; j < vt.length; j++) {
-                v[j] += vt[j];
-                sum += vt[j];
-            }
-            for (int j = 0; j < vt.length; j++) {
-                votes[ii][j] = Math.log(v[j] / (sum - v[j]));
-                //                    votes[i][j] = vt[j];
-            }
-        }
-        return getPredictionForInstancePerceptron(votes, bestClassifiers, inst.numClasses());
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return true;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return new Measurement[]{new Measurement("ensemble size",
-                    this.ensemble != null ? this.ensemble.length : 0),
-                    new Measurement("change detections", this.numberOfChangesDetected)
-                };
-    }
-
-    public Classifier[] getSubClassifiers() {
-        return this.ensemble.clone();
-    }
-
-    //Perceptron
-    public FloatOption learningRatioOption = new FloatOption("learningRatio", 't', "Learning ratio", 1);
-
-    public FloatOption penaltyFactorOption = new FloatOption("lambda", 'p', "Lambda", 0.0);
-
-    public IntOption initialNumInstancesOption = new IntOption("initialNumInstances", 'i', "initialNumInstances", 10);
-
-    protected double[][] weightAttribute;
-
-    protected boolean reset;
-
-    public void trainOnInstanceImplPerceptron(int numClasses, int actualClass, double[][] votes) {
-
-        //Init Perceptron
-        if (this.reset == true) {
-            this.reset = false;
-            this.weightAttribute = new double[numClasses][votes.length];
-            for (int i = 0; i < numClasses; i++) {
-                for (int j = 0; j < votes.length - 1; j++) {
-                    weightAttribute[i][j] = 1.0 / (votes.length - 1.0);
-                }
-            }
-            numInstances = initialNumInstancesOption.getValue();
-        }
-
-        // Weight decay
-        double learningRatio = learningRatioOption.getValue() * 2.0 / (numInstances + (votes.length - 1) + 2.0);
-        double lambda = penaltyFactorOption.getValue();
-        numInstances++;
-
-        double[] preds = new double[numClasses];
-
-        for (int i = 0; i < numClasses; i++) {
-            preds[i] = prediction(votes, i);
-        }
-        for (int i = 0; i < numClasses; i++) {
-            double actual = (i == actualClass) ? 1.0 : 0.0;
-            double delta = (actual - preds[i]) * preds[i] * (1 - preds[i]);
-            for (int j = 0; j < this.ensemble.length; j++) {
-                this.weightAttribute[i][j] += learningRatio * (delta * votes[j][i] - lambda * this.weightAttribute[i][j]);
-            }
-            this.weightAttribute[i][this.ensemble.length] += learningRatio * delta;
-        }
-    }
-
-    public double predictionPruning(double[][] votes, int[] bestClassifiers, int classVal) {
-        double sum = 0.0;
-        for (int i = 0; i < votes.length - 1; i++) {
-            sum += (double) weightAttribute[classVal][bestClassifiers[i]] * votes[i][classVal];
-        }
-        sum += weightAttribute[classVal][votes.length - 1];
-        return 1.0 / (1.0 + Math.exp(-sum));
-    }
-
-    public double prediction(double[][] votes, int classVal) {
-        double sum = 0.0;
-        for (int i = 0; i < votes.length - 1; i++) {
-            sum += (double) weightAttribute[classVal][i] * votes[i][classVal];
-        }
-        sum += weightAttribute[classVal][votes.length - 1];
-        return 1.0 / (1.0 + Math.exp(-sum));
-    }
-
-    public Prediction getPredictionForInstancePerceptron(double[][] votesEnsemble, int[] bestClassifiers, int numClasses) {
-        double[] votes = new double[numClasses];
-        if (this.reset == false) {
-            for (int i = 0; i < votes.length; i++) {
-                votes[i] = predictionPruning(votesEnsemble, bestClassifiers, i);
-            }
-        }
-        return new ClassificationPrediction(votes);
-
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/meta/OCBoost.java b/moa/src/main/java/moa/classifiers/meta/OCBoost.java
deleted file mode 100644
index 9b87b93bc..000000000
--- a/moa/src/main/java/moa/classifiers/meta/OCBoost.java
+++ /dev/null
@@ -1,189 +0,0 @@
-/*
- *    OCBoost.java
- *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.meta;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractClassifier;
-import moa.core.Measurement;
-import moa.core.Utils;
-import moa.learners.Classifier;
-import moa.options.ClassOption;
-
-/**
- * Online Coordinate boosting for two classes evolving data streams. 
- *
- * <p>Pelossof et al. presented Online Coordinate Boosting, a new online
- * boosting algorithm for adapting the weights of a boosted classifier,
- * which yields a closer approximation to Freund and Schapire’s AdaBoost
- * algorithm. The weight update procedure is derived by minimizing AdaBoost’s
- * loss when viewed in an incremental form. This boosting method may be reduced
- * to a form similar to Oza and Russell’s algorithm.</p>
- *
- * <p>See details in:<br />
- * Raphael Pelossof, Michael Jones, Ilia Vovsha, and Cynthia Rudin.
- * Online coordinate boosting. 2008.</p>
- * <p>Example:</p>
- * <code>OCBoost -l HoeffdingTreeNBAdaptive -e 0.5</code>
- * <p>Parameters:</p><ul>
- * <li>-l : Classifier to train</li>
- * <li>-s : The number of models to boost</li>
- * <li>-e : Smoothing parameter</li></ul>
- * 
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @version $Revision: 7 $
- */
-
-public class OCBoost extends AbstractClassifier implements Classifier {
-
-    private static final long serialVersionUID = 1L;
-    
-    @Override
-    public String getPurposeString() {
-        return "Online Coordinate boosting for two classes evolving data streams.";
-    }
-        
-    public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l',
-            "Classifier to train.", Classifier.class, "moa.classifiers.trees.HoeffdingTree");
-
-    public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's',
-            "The number of models to boost.", 10, 1, Integer.MAX_VALUE);
-
-    public FloatOption smoothingOption = new FloatOption("smoothingParameter", 'e',
-            "Smoothing parameter.", 0.5, 0.0, 100.0);
-
-    protected Classifier[] ensemble;
-
-    protected double[] alpha;
-
-    protected double[] alphainc;
-
-    protected double[] pipos;
-
-    protected double[] pineg;
-
-    protected double[][] wpos;
-
-    protected double[][] wneg;
-
-    @Override
-    public void resetLearningImpl() {
-        this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
-        this.alpha = new double[this.ensemble.length];
-        this.alphainc = new double[this.ensemble.length];
-        this.pipos = new double[this.ensemble.length];
-        this.pineg = new double[this.ensemble.length];
-        this.wpos = new double[this.ensemble.length][this.ensemble.length];
-        this.wneg = new double[this.ensemble.length][this.ensemble.length];
-
-        Classifier baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
-        baseLearner.resetLearning();
-        for (int i = 0; i < this.ensemble.length; i++) {
-            this.ensemble[i] = (Classifier) baseLearner.copy();
-            alpha[i] = 0.0;
-            alphainc[i] = 0.0;
-            for (int j = 0; j < this.ensemble.length; j++) {
-                wpos[i][j] = this.smoothingOption.getValue();
-                wneg[i][j] = this.smoothingOption.getValue();
-            }
-        }
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        double d = 1.0;
-        int[] m = new int[this.ensemble.length];
-        for (int j = 0; j < this.ensemble.length; j++) {
-            int j0 = 0; //max(0,j-K)
-            pipos[j] = 1.0;
-            pineg[j] = 1.0;
-            m[j] = -1;
-            if (this.ensemble[j].correctlyClassifies(inst) == true) {
-                m[j] = 1;
-            }
-            for (int k = j0; k <= j - 1; k++) {
-                pipos[j] *= wpos[j][k] / wpos[j][j] * Math.exp(-alphainc[k])
-                        + (1.0 - wpos[j][k] / wpos[j][j]) * Math.exp(alphainc[k]);
-                pineg[j] *= wneg[j][k] / wneg[j][j] * Math.exp(-alphainc[k])
-                        + (1.0 - wneg[j][k] / wneg[j][j]) * Math.exp(alphainc[k]);
-            }
-            for (int k = 0; k <= j; k++) {
-                wpos[j][k] = wpos[j][k] * pipos[j] + d * (m[k] == 1 ? 1 : 0) * (m[j] == 1 ? 1 : 0);
-                wneg[j][k] = wneg[j][k] * pineg[j] + d * (m[k] == -1 ? 1 : 0) * (m[j] == -1 ? 1 : 0);
-            }
-            alphainc[j] = -alpha[j];
-            alpha[j] = 0.5 * Math.log(wpos[j][j] / wneg[j][j]);
-            alphainc[j] += alpha[j];
-
-            d = d * Math.exp(-alpha[j] * m[j]);
-
-            if (d > 0.0) {
-                Instance weightedInst = (Instance) inst.copy();
-                weightedInst.setWeight(inst.weight() * d);
-                this.ensemble[j].trainOnInstance(weightedInst);
-            }
-        }
-    }
-
-    protected double getEnsembleMemberWeight(int i) {
-        return alpha[i];
-    }
-
-    public Prediction getPredictionForInstance(Instance inst) {
-        double[] output = new double[2];
-        int vote;
-        double combinedVote = 0.0;
-        for (int i = 0; i < this.ensemble.length; i++) {
-            vote = Utils.maxIndex(this.ensemble[i].getPredictionForInstance(inst));
-            if (vote == 0) {
-                vote = -1;
-            }
-            combinedVote += (double) vote * getEnsembleMemberWeight(i);
-        }
-        output[0] = 0;
-        output[1] = 0;
-        output[combinedVote > 0 ? 1 : 0] = 1;
-        return new ClassificationPrediction(output);
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return true;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return new Measurement[]{new Measurement("ensemble size",
-                    this.ensemble != null ? this.ensemble.length : 0)};
-    }
-
-    public Classifier[] getSubClassifiers() {
-        return this.ensemble.clone();
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/meta/OnlineSmoothBoost.java b/moa/src/main/java/moa/classifiers/meta/OnlineSmoothBoost.java
deleted file mode 100644
index 4bd711ca7..000000000
--- a/moa/src/main/java/moa/classifiers/meta/OnlineSmoothBoost.java
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
- *    OnlineSmoothBoost.java
- *    Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.meta;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractClassifier;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.learners.Classifier;
-import moa.options.ClassOption;
-
-
-/**
- * Incremental on-line boosting with Theoretical Justifications of Shang-Tse Chen,
- * Hsuan-Tien Lin and Chi-Jen Lu.
- *
- * <p>See details in:<br /> </p>
- *
- * <p>Parameters:</p> <ul> <li>-l : Classifier to train</li> <li>-s : The number
- * of models to boost</li> 
- * </ul>
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $
- */
-public class OnlineSmoothBoost extends AbstractClassifier implements Classifier {
-
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public String getPurposeString() {
-        return "Incremental on-line boosting of Shang-Tse Chen, Hsuan-Tien Lin and Chi-Jen Lu.";
-    }
-
-    public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l',
-            "Classifier to train.", Classifier.class, "trees.HoeffdingTree");
-
-    public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's',
-            "The number of models to boost.", 10, 1, Integer.MAX_VALUE);
-
-    //public FlagOption pureBoostOption = new FlagOption("pureBoost", 'p',
-    //        "Boost with weights only; no poisson.");
-    
-        public FloatOption gammaOption = new FloatOption("gamma",
-            'g',
-            "The value of the gamma parameter.",
-            0.1, 0.0, 1.0);
-
-    protected Classifier[] ensemble;
-
-    protected double[] alpha;
-    
-    protected double gamma;
-    
-    protected double theta;
-
-    @Override
-    public void resetLearningImpl() {
-        this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
-        Classifier baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
-        baseLearner.resetLearning();
-        this.alpha = new double[this.ensemble.length];
-        for (int i = 0; i < this.ensemble.length; i++) {
-            this.ensemble[i] = (Classifier) baseLearner.copy();
-            this.alpha[i] = 1.0/ (double) this.ensemble.length;
-        }
-        this.gamma = this.gammaOption.getValue();
-       this.theta = this.gamma/(2.0+this.gamma);
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        double zt = 0.0;
-        double weight = 1.0;
-        for (int i = 0; i < this.ensemble.length; i++) {
-            zt += (this.ensemble[i].correctlyClassifies(inst) ? 1 : -1) - theta;
-                    //normalized_predict(ex.x) * ex.y - theta;
-            Instance weightedInst = (Instance) inst.copy();
-            weightedInst.setWeight(weight);
-            this.ensemble[i].trainOnInstance(weightedInst);
-            weight = (zt<=0)? 1.0 : Math.pow(1.0-gamma, zt/2.0);
-        }
-
-    }
-
-    protected double getEnsembleMemberWeight(int i) {
-        return this.alpha[i];
-    }
-
-    public Prediction getPredictionForInstance(Instance inst) {
-               
-        DoubleVector combinedVote = new DoubleVector();
-        for (int i = 0; i < this.ensemble.length; i++) {
-            double memberWeight = getEnsembleMemberWeight(i);
-            if (memberWeight > 0.0) {
-                DoubleVector vote = this.ensemble[i].getPredictionForInstance(inst).asDoubleVector();
-                if (vote.sumOfValues() > 0.0) {
-                    vote.normalize();
-                    vote.scaleValues(memberWeight);
-                    combinedVote.addValues(vote);
-                }
-            } else {
-                break;
-            }
-        }
-        return new ClassificationPrediction(combinedVote.getArrayRef());
-    }
-
-    public boolean isRandomizable() {
-        return true;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return new Measurement[]{new Measurement("ensemble size",
-                    this.ensemble != null ? this.ensemble.length : 0)};
-    }
-
-    public Classifier[] getSubClassifiers() {
-        return this.ensemble.clone();
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBagASHT.java b/moa/src/main/java/moa/classifiers/meta/OzaBagASHT.java
deleted file mode 100644
index a7cd2dcfd..000000000
--- a/moa/src/main/java/moa/classifiers/meta/OzaBagASHT.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/*
- *    OzaBagASHT.java
- *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.meta;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.trees.ASHoeffdingTree;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.core.MiscUtils;
-import moa.core.Utils;
-import moa.learners.Classifier;
-import moa.options.ClassOption;
-
-/**
- * Bagging using trees of different size.
- * The Adaptive-Size Hoeffding Tree (ASHT) is derived from the Hoeffding Tree
- * algorithm with the following differences:
- * <ul>
- * <li> it has a maximum number of split nodes, or size
- * <li> after one node splits, if the number of split nodes of the ASHT tree
- * is higher than the maximum value, then it deletes some nodes to reduce its size
- * </ul>
- * The intuition behind this method is as follows: smaller trees adapt
- * more quickly to changes, and larger trees do better during periods with
- * no or little change, simply because they were built on more data. Trees
- * limited to size s will be reset about twice as often as trees with a size
- * limit of 2s. This creates a set of different reset-speeds for an ensemble of such
- * trees, and therefore a subset of trees that are a good approximation for the
- * current rate of change. It is important to note that resets will happen all
- * the time, even for stationary datasets, but this behaviour should not have
- * a negative impact on the ensemble’s predictive performance.
- * When the tree size exceeds the maximun size value, there are two different
- * delete options: <ul>
- * <li> delete the oldest node, the root, and all of its children except the one
- * where the split has been made. After that, the root of the child not
- * deleted becomes the new root
- * <li> delete all the nodes of the tree, i.e., restart from a new root.
- * </ul>
- * The maximum allowed size for the n-th ASHT tree is twice the maximum
- * allowed size for the (n-1)-th tree. Moreover, each tree has a weight
- * proportional to the inverse of the square of its error, and it monitors its
- * error with an exponential weighted moving average (EWMA) with alpha = .01.
- * The size of the first tree is 2.
- * <br/><br/>
- * With this new method, it is attempted to improve bagging performance
- * by increasing tree diversity. It has been observed that boosting tends to
- * produce a more diverse set of classifiers than bagging, and this has been
- * cited as a factor in increased performance.<br/>
- * See more details in:<br/><br/>
- * Albert Bifet, Geoff Holmes, Bernhard Pfahringer, Richard Kirkby,
- * and Ricard Gavaldà. New ensemble methods for evolving data
- * streams. In 15th ACM SIGKDD International Conference on Knowledge
- * Discovery and Data Mining, 2009.<br/><br/>
- * The learner must be ASHoeffdingTree, a Hoeffding Tree with a maximum
- * size value.<br/><br/>
- * Example:<br/><br/>
- * <code>OzaBagASHT -l ASHoeffdingTree -s 10 -u -r </code>
- * Parameters:<ul>
- * <li>Same parameters as <code>OzaBag</code>
- * <li>-f : the size of first classifier in the bag.
- * <li>-u : Enable weight classifiers
- * <li>-e : Reset trees when size is higher than the max
- * </ul>
- *
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @version $Revision: 7 $
- */
-public class OzaBagASHT extends AbstractClassifier implements Classifier {
-
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public String getPurposeString() {
-        return "Bagging using trees of different size.";
-    }
-    
-    public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's',
-        "The number of models in the bag.", 10, 1, Integer.MAX_VALUE);
-    
-    public IntOption firstClassifierSizeOption = new IntOption("firstClassifierSize", 'f',
-            "The size of first classifier in the bag.", 1, 1, Integer.MAX_VALUE);
-
-    public FlagOption useWeightOption = new FlagOption("useWeight",
-            'u', "Enable weight classifiers.");
-
-    public FlagOption resetTreesOption = new FlagOption("resetTrees",
-            'e', "Reset trees when size is higher than the max.");
-
-        public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l',
-    		"ASHoeffdingTree to train.", ASHoeffdingTree.class,
-    		"moa.classifiers.trees.ASHoeffdingTree");
-    
-    protected ASHoeffdingTree[] ensemble;
-    protected double[] error;
-    protected double alpha = 0.01;
-
-    @Override
-    public void resetLearningImpl() {
-        this.ensemble = new ASHoeffdingTree[this.ensembleSizeOption.getValue()];
-        this.error = new double[this.ensembleSizeOption.getValue()];
-        Classifier baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
-        baseLearner.resetLearning();
-        int pow = this.firstClassifierSizeOption.getValue();
-        for (int i = 0; i < this.ensemble.length; i++) {
-            this.ensemble[i] = (ASHoeffdingTree) baseLearner.copy();
-            this.error[i] = 0.0;
-            ((ASHoeffdingTree) this.ensemble[i]).setMaxSize(pow);
-            if ((this.resetTreesOption != null)
-                    && this.resetTreesOption.isSet()) {
-                ((ASHoeffdingTree) this.ensemble[i]).setResetTree();
-            }
-            pow *= 2;
-        }
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        int trueClass = (int) inst.classValue();
-        for (int i = 0; i < this.ensemble.length; i++) {
-            int k = MiscUtils.poisson(1.0, this.classifierRandom);
-            if (k > 0) {
-                Instance weightedInst = (Instance) inst.copy();
-                weightedInst.setWeight(inst.weight() * k);
-                if (Utils.maxIndex(this.ensemble[i].getPredictionForInstance(inst)) == trueClass) {
-                    this.error[i] += alpha * (0.0 - this.error[i]); //EWMA
-                } else {
-                    this.error[i] += alpha * (1.0 - this.error[i]); //EWMA
-                }
-                this.ensemble[i].trainOnInstance(weightedInst);
-            }
-        }
-    }
-
-    public Prediction getPredictionForInstance(Instance inst) {
-        DoubleVector combinedVote = new DoubleVector();
-        for (int i = 0; i < this.ensemble.length; i++) {
-            DoubleVector vote = this.ensemble[i].getPredictionForInstance(inst).asDoubleVector();
-            if (vote.sumOfValues() > 0.0) {
-                vote.normalize();
-                if ((this.useWeightOption != null)
-                        && this.useWeightOption.isSet()) {
-                    vote.scaleValues(1.0 / (this.error[i] * this.error[i]));
-                }
-                combinedVote.addValues(vote);
-            }
-        }
-        return new ClassificationPrediction(combinedVote.getArrayRef());
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        // TODO Auto-generated method stub
-    }
-    
-    @Override
-    public boolean isRandomizable() {
-        return true;
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return new Measurement[]{new Measurement("ensemble size",
-                    this.ensemble != null ? this.ensemble.length : 0)};
-    }
-    
-    public Classifier[] getSubClassifiers() {
-        return this.ensemble.clone();
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBoostAdwin.java b/moa/src/main/java/moa/classifiers/meta/OzaBoostAdwin.java
deleted file mode 100644
index fea1084b4..000000000
--- a/moa/src/main/java/moa/classifiers/meta/OzaBoostAdwin.java
+++ /dev/null
@@ -1,280 +0,0 @@
-/*
- *    OzaBoostAdwin.java
- *    Copyright (C) 2010 University of Waikato, Hamilton, New Zealand
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.meta;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.core.driftdetection.ADWIN;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.core.MiscUtils;
-import moa.learners.Classifier;
-import moa.options.ClassOption;
-
-/**
- * Boosting for evolving data streams using ADWIN.
- *
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @version $Revision: 7 $
- */
-public class OzaBoostAdwin extends AbstractClassifier implements Classifier {
-
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public String getPurposeString() {
-        return "Boosting for evolving data streams using ADWIN.";
-    }
-        
-    public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l',
-            "Classifier to train.", Classifier.class, "moa.classifiers.trees.HoeffdingTree");
-
-    public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's',
-            "The number of models to boost.", 10, 1, Integer.MAX_VALUE);
-
-    public FlagOption pureBoostOption = new FlagOption("pureBoost", 'p',
-            "Boost with weights only; no poisson.");
-
-    public FloatOption deltaAdwinOption = new FloatOption("deltaAdwin", 'a',
-            "Delta of Adwin change detection", 0.002, 0.0, 1.0);
-
-    public FlagOption outputCodesOption = new FlagOption("outputCodes", 'o',
-            "Use Output Codes to use binary classifiers.");
-
-    public FlagOption sammeOption = new FlagOption("same", 'e',
-            "Use Samme Algorithm.");
-
-    protected Classifier[] ensemble;
-
-    protected double[] scms;
-
-    protected double[] swms;
-
-    protected ADWIN[] ADError;
-
-    protected int numberOfChangesDetected;
-
-    protected int[][] matrixCodes;
-
-    protected boolean initMatrixCodes = false;
-
-    protected double logKm1 = 0.0;
-
-    protected int Km1 = 1;
-
-    protected boolean initKm1 = false;
-
-    @Override
-    public void resetLearningImpl() {
-        this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
-        Classifier baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
-        baseLearner.resetLearning();
-        for (int i = 0; i < this.ensemble.length; i++) {
-            this.ensemble[i] = (Classifier) baseLearner.copy();
-        }
-        this.scms = new double[this.ensemble.length];
-        this.swms = new double[this.ensemble.length];
-        this.ADError = new ADWIN[this.ensemble.length];
-        for (int i = 0; i < this.ensemble.length; i++) {
-            this.ADError[i] = new ADWIN((double) this.deltaAdwinOption.getValue());
-        }
-        this.numberOfChangesDetected = 0;
-        if (this.outputCodesOption.isSet()) {
-            this.initMatrixCodes = true;
-        }
-        if (this.sammeOption.isSet()) {
-            this.initKm1 = true;
-        }
-
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        int numClasses = inst.numClasses();
-        // Set log (k-1) and (k-1) for SAMME Method
-        if (this.sammeOption.isSet()) {
-            this.Km1 = numClasses - 1;
-            this.logKm1 = Math.log(this.Km1);
-            this.initKm1 = false;
-        }
-        //Output Codes
-        if (this.initMatrixCodes == true) {
-
-            this.matrixCodes = new int[this.ensemble.length][inst.numClasses()];
-            for (int i = 0; i < this.ensemble.length; i++) {
-                int numberOnes;
-                int numberZeros;
-
-                do { // until we have the same number of zeros and ones
-                    numberOnes = 0;
-                    numberZeros = 0;
-                    for (int j = 0; j < numClasses; j++) {
-                        int result = 0;
-                        if (j == 1 && numClasses == 2) {
-                            result = 1 - this.matrixCodes[i][0];
-                        } else {
-                            result = (this.classifierRandom.nextBoolean() ? 1 : 0);
-                        }
-                        this.matrixCodes[i][j] = result;
-                        if (result == 1) {
-                            numberOnes++;
-                        } else {
-                            numberZeros++;
-                        }
-                    }
-                } while ((numberOnes - numberZeros) * (numberOnes - numberZeros) > (this.ensemble.length % 2));
-
-            }
-            this.initMatrixCodes = false;
-        }
-
-
-        boolean Change = false;
-        double lambda_d = 1.0;
-        Instance weightedInst = (Instance) inst.copy();
-        for (int i = 0; i < this.ensemble.length; i++) {
-            double k = this.pureBoostOption.isSet() ? lambda_d : MiscUtils.poisson(lambda_d * this.Km1, this.classifierRandom);
-            if (k > 0.0) {
-                if (this.outputCodesOption.isSet()) {
-                    weightedInst.setClassValue((double) this.matrixCodes[i][(int) inst.classValue()]);
-                }
-                weightedInst.setWeight(inst.weight() * k);
-                this.ensemble[i].trainOnInstance(weightedInst);
-            }
-            boolean correctlyClassifies = this.ensemble[i].correctlyClassifies(weightedInst);
-            if (correctlyClassifies) {
-                this.scms[i] += lambda_d;
-                lambda_d *= this.trainingWeightSeenByModel / (2 * this.scms[i]);
-            } else {
-                this.swms[i] += lambda_d;
-                lambda_d *= this.trainingWeightSeenByModel / (2 * this.swms[i]);
-            }
-
-            double ErrEstim = this.ADError[i].getEstimation();
-            if (this.ADError[i].setInput(correctlyClassifies ? 0 : 1)) {
-                if (this.ADError[i].getEstimation() > ErrEstim) {
-                    Change = true;
-                }
-            }
-        }
-        if (Change) {
-            numberOfChangesDetected++;
-            double max = 0.0;
-            int imax = -1;
-            for (int i = 0; i < this.ensemble.length; i++) {
-                if (max < this.ADError[i].getEstimation()) {
-                    max = this.ADError[i].getEstimation();
-                    imax = i;
-                }
-            }
-            if (imax != -1) {
-                this.ensemble[imax].resetLearning();
-                //this.ensemble[imax].trainOnInstance(inst);
-                this.ADError[imax] = new ADWIN((double) this.deltaAdwinOption.getValue());
-                this.scms[imax] = 0;
-                this.swms[imax] = 0;
-            }
-        }
-    }
-
-    protected double getEnsembleMemberWeight(int i) {
-        double em = this.swms[i] / (this.scms[i] + this.swms[i]);
-        if ((em == 0.0) || (em > 0.5)) {
-            return this.logKm1;
-        }
-        return Math.log((1.0 - em) / em) + this.logKm1;
-    }
-
-    @Override
-    public Prediction getPredictionForInstance(Instance inst) {
-        if (this.outputCodesOption.isSet()) {
-            return getPredictionForInstanceBinary(inst);
-        }
-        DoubleVector combinedVote = new DoubleVector();
-        for (int i = 0; i < this.ensemble.length; i++) {
-            double memberWeight = getEnsembleMemberWeight(i);
-            if (memberWeight > 0.0) {
-                DoubleVector vote = this.ensemble[i].getPredictionForInstance(inst).asDoubleVector();
-                if (vote.sumOfValues() > 0.0) {
-                    vote.normalize();
-                    vote.scaleValues(memberWeight);
-                    combinedVote.addValues(vote);
-                }
-            } else {
-                break;
-            }
-        }
-        return new ClassificationPrediction(combinedVote.getArrayRef());
-    }
-
-    public Prediction getPredictionForInstanceBinary(Instance inst) {
-        double combinedVote[] = new double[(int) inst.numClasses()];
-        Instance weightedInst = (Instance) inst.copy();
-        if (this.initMatrixCodes == false) {
-            for (int i = 0; i < this.ensemble.length; i++) {
-                //Replace class by OC
-                weightedInst.setClassValue((double) this.matrixCodes[i][(int) inst.classValue()]);
-
-                double vote[];
-                vote = this.ensemble[i].getPredictionForInstance(weightedInst).asDoubleArray();
-                //Binary Case
-                int voteClass = 0;
-                if (vote.length == 2) {
-                    voteClass = (vote[1] > vote[0] ? 1 : 0);
-                }
-                //Update votes
-                for (int j = 0; j < inst.numClasses(); j++) {
-                    if (this.matrixCodes[i][j] == voteClass) {
-                        combinedVote[j] += getEnsembleMemberWeight(i);
-                    }
-                }
-            }
-        }
-        return new ClassificationPrediction(combinedVote);
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return true;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return new Measurement[]{new Measurement("ensemble size",
-                    this.ensemble != null ? this.ensemble.length : 0),
-                    new Measurement("change detections", this.numberOfChangesDetected)
-                };
-    }
-
-    public Classifier[] getSubClassifiers() {
-        return this.ensemble.clone();
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/meta/PairedLearners.java b/moa/src/main/java/moa/classifiers/meta/PairedLearners.java
deleted file mode 100644
index da75a2e6b..000000000
--- a/moa/src/main/java/moa/classifiers/meta/PairedLearners.java
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
- *    PairedLearners.java
- *    Copyright (C) 2015 Instituto Federal de Pernambuco, Recife, Brazil
- *    @author Paulo Gonçalves (paulogoncalves@recife.ifpe.edu.br)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package moa.classifiers.meta;
-
-import java.util.Arrays;
-import java.util.LinkedList;
-import java.util.List;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.AbstractInstanceLearner;
-import moa.core.Measurement;
-import moa.core.Utils;
-import moa.learners.Classifier;
-import moa.options.ClassOption;
-
-/**
- * Creates two classifiers: a stable and a reactive. The first represents the
- * actual stable concept, while the second is trained on the most recent data.
- * If the accuracy of the reactive is higher than that of the stable, it means
- * the concept has changed. The stable classifier is then substituted by the
- * reactive, and the reactive is reset.
- *
- * <p>
- * Stephen H. Bach, Marcus A. Maloof, "Paired Learners for Concept Drift",
- * Eighth IEEE International Conference on Data Mining (ICDM), 2008,
- * pp.23-32</p>
- *
- * @author Paulo Gonçalves (paulogoncalves at recife.ifpe.edu.br)
- *
- */
-
-public class PairedLearners extends AbstractClassifier implements Classifier {
-    private static final long serialVersionUID = 1L;
-
-    public ClassOption stableLearnerOption = new ClassOption("stableLearner", 
-            's', "Stable learner", Classifier.class, "bayes.NaiveBayes");
-
-    public ClassOption reactiveLearnerOption = new ClassOption("reactiveLearner", 
-            'r', "Reactive learner", Classifier.class, "bayes.NaiveBayes");
-
-    public IntOption windowSizeOption = new IntOption("windowSize", 
-            'w', "Window size for the reactive learner", 
-            12, 1, Integer.MAX_VALUE);
-
-    public FloatOption thresholdOption = new FloatOption("threshold",
-            't', "Threashold for creating a new stable learner",
-            0.2, 0, 1);
-
-    protected int[] c;
-    protected Classifier stableLearner;
-    protected Classifier reactiveLearner;
-    protected int t;
-    protected int w;
-    protected int theta;
-    protected Instance[] instances;
-    protected int changeDetected = 0;
-    protected int numberOfErrors = 0;
-    protected int i;
-
-    @Override
-    public void resetLearningImpl() {
-        this.t = 0;
-        this.w = this.windowSizeOption.getValue();
-        this.c = new int[this.w];
-        this.theta = (int) (this.w * this.thresholdOption.getValue());
-        this.instances = new Instance[this.w];
-
-        this.stableLearner = (Classifier) ((Classifier) getPreparedClassOption(this.stableLearnerOption)).copy();
-        this.stableLearner.resetLearning();
-        this.reactiveLearner = (Classifier) ((Classifier) getPreparedClassOption(this.reactiveLearnerOption)).copy();
-        this.reactiveLearner.resetLearning();
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        this.instances[this.t] = inst;
-        int trueClass = (int) inst.classValue();
-        boolean stablePrediction = Utils.maxIndex(this.stableLearner.getPredictionForInstance(inst)) == trueClass;
-        boolean reactivePrediction = Utils.maxIndex(this.reactiveLearner.getPredictionForInstance(inst)) == trueClass;
-
-        this.numberOfErrors = this.numberOfErrors - this.c[this.t];
-        if(!stablePrediction && reactivePrediction) {
-            this.c[this.t] = 1;
-            this.numberOfErrors++;
-	} else {
-            this.c[this.t] = 0;
-        }        
-        if (this.theta < this.numberOfErrors) {
-            this.changeDetected++;
-            this.stableLearner = (Classifier) this.reactiveLearner.copy();
-            Arrays.fill(this.c, 0);   // Resets c
-            this.numberOfErrors = 0;
-        }
-        this.stableLearner.trainOnInstance(inst);
-        this.reactiveLearner.resetLearning();
-        for (i=0; i<this.instances.length && this.instances[i] != null; i++) {
-            this.reactiveLearner.trainOnInstance(this.instances[i]);
-        }
-        this.t = (this.t + 1) % this.w;
-    }
-
-    @Override
-    public Prediction getPredictionForInstance(Instance inst) {
-        return this.stableLearner.getPredictionForInstance(inst);
-    }
-    @Override
-    public boolean isRandomizable() {
-        return false;
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        List<Measurement> measurementList = new LinkedList();
-        measurementList.add(new Measurement("Change detected", this.changeDetected));
-        Measurement[] modelMeasurements = ((AbstractInstanceLearner) this.stableLearner).getModelMeasurements();
-        if (modelMeasurements != null) {
-            measurementList.addAll(Arrays.asList(modelMeasurements));
-        }
-        this.changeDetected = 0;
-        return measurementList.toArray(new Measurement[measurementList.size()]);
-    }
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/meta/RCD.java b/moa/src/main/java/moa/classifiers/meta/RCD.java
deleted file mode 100644
index 34dd41131..000000000
--- a/moa/src/main/java/moa/classifiers/meta/RCD.java
+++ /dev/null
@@ -1,287 +0,0 @@
-/*
- *    RCD.java
- *    Copyright (C) 2017 Instituto Federal de Pernambuco
- *    @author Paulo Gonçalves (paulogoncalves@recife.ifpe.edu.br)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.meta;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.core.statisticaltests.StatisticalTest;
-import moa.classifiers.drift.SingleClassifierDrift;
-import moa.core.Utils;
-import moa.learners.Classifier;
-import moa.options.ClassOption;
-
-/**
- * Creates a set of classifiers, each one representing a different context.
- * Reuses classifier associating to each one a sample of data and compares new
- * data to old ones using a multivariate non-parametric statistical test. Tests
- * are performed in parallel and classifiers are stored based on their accuracy
- * and stored time.
- *
- * 1) Parameterized number of classifiers to store. 2) Classifiers are stored
- * removing the older ones if the set is full. 3) Classifier with higher
- * significance value is selected.
- *
- * Based on: Gonçalves Jr, Paulo Mauricio, and Roberto Souto Maior De Barros.
- * "RCD: A recurring concept drift framework." Pattern Recognition Letters 34.9
- * (2013): 1018-1025.
- *
- * @author Paulo Goncalves (paulogoncalves at recife dot ifpe dot edu dot br)
- *
- */
-public class RCD extends SingleClassifierDrift {
-
-    private static final long serialVersionUID = 1L;
-
-    private class ClassifierKS implements Serializable {
-
-        private final Classifier classifier;
-        private final List<Instance> instances;
-
-        public ClassifierKS(Classifier classifier, List<Instance> instances) {
-            this.classifier = classifier;
-            this.instances = instances;
-        }
-
-        public Classifier getClassifier() {
-            return classifier;
-        }
-
-        public List<Instance> getInstances() {
-            return instances;
-        }
-    }
-
-    public ClassOption statisticalTestOption = new ClassOption("statisticalTest",
-            'a', "Non-parametric multivariate statistical test to use.", StatisticalTest.class,
-            "KNN");
-
-    public FloatOption similarityBetweenDistributionsOption = new FloatOption(
-            "similarityBetweenDistributions",
-            's',
-            "The minimum percentual similarity between distributions (p-value).",
-            0.01, 0, 1);
-
-    public IntOption bufferSizeOption = new IntOption("bufferSize", 'b',
-            "The size of the buffer that represents the distributions.", 400,
-            1, Integer.MAX_VALUE);
-
-    public IntOption testFrequencyOption = new IntOption("testFrequency",
-            't', "In the testing phase, test for best stored classifier after how many instances.",
-            400, 1, Integer.MAX_VALUE);
-
-    public IntOption classifiersSizeOption = new IntOption("classifiersSize",
-            'c', "The maximum amount of classifiers to store. 0 means unlimited.", 15, 0,
-            Integer.MAX_VALUE);
-
-    public IntOption threadSizeOption = new IntOption("threadSize",
-            'm', "The thread pool size, indicating how many simultaneous tests are allowed.", 4, 1,
-            Integer.MAX_VALUE);
-
-    public IntOption quantityClassifiersTestOption = new IntOption("quantityClassifiersTest",
-            'q', "Quantity of identified classifiers to check.", 1, 1,
-            Integer.MAX_VALUE);
-
-    private List<ClassifierKS> classifiers;
-
-    protected List<Instance> currentChunk;
-
-    protected List<Instance> currentChunk2;
-
-    protected List<Instance> testChunk;
-
-    protected int bufferSize;
-
-    protected int previousState;
-
-    protected int index;
-
-    @Override
-    public void resetLearningImpl() {
-        super.resetLearningImpl();
-        this.classifiers = new ArrayList();
-        this.bufferSize = bufferSizeOption.getValue();
-        this.currentChunk = null;
-        this.currentChunk2 = null;
-        this.testChunk = null;
-        this.previousState = Integer.MIN_VALUE;
-        this.index = 0;
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        int trueClass = (int) inst.classValue();
-        boolean prediction = Utils.maxIndex(this.classifier
-                .getPredictionForInstance(inst)) == trueClass;
-        this.driftDetectionMethod.input(prediction ? 0.0 : 1.0);
-        this.ddmLevel = DDM_INCONTROL_LEVEL;
-        if (this.driftDetectionMethod.getChange()) {
-            this.ddmLevel = DDM_OUTCONTROL_LEVEL;
-        }
-        if (this.driftDetectionMethod.getWarningZone()) {
-            this.ddmLevel = DDM_WARNING_LEVEL;
-        }
-        switch (this.ddmLevel) {
-            case DDM_WARNING_LEVEL:
-                this.warningDetected++;
-                switch (this.previousState) {
-                    case DDM_INCONTROL_LEVEL:
-                        this.newclassifier.resetLearning();
-                        this.currentChunk2 = new ArrayList();
-                        break;
-                }
-                this.newclassifier.trainOnInstance(inst);
-                this.addInstance(this.currentChunk2, inst);
-                this.previousState = DDM_WARNING_LEVEL;
-                break;
-            case DDM_OUTCONTROL_LEVEL:
-                this.changeDetected++;
-                switch (this.previousState) {
-                    case DDM_WARNING_LEVEL:
-                        ClassifierKS cs = this.getPreviousClassifier(
-                                this.classifier, this.currentChunk2);
-                        if (cs == null) {
-                            this.classifier = this.newclassifier;
-                            this.newclassifier = (Classifier) ((Classifier) getPreparedClassOption(this.baseLearnerOption))
-                                    .copy();
-                            this.classifiers
-                                    .add(new ClassifierKS(
-                                            this.classifier, this.currentChunk2));
-                            this.currentChunk = this.currentChunk2;
-                            int maxSize = this.classifiersSizeOption.getValue();
-                            if (this.classifiers.size() > maxSize && maxSize > 0) {
-                                this.classifiers.remove(0);
-                            }
-                        } else {
-                            this.classifier = cs.getClassifier();
-                            this.currentChunk = cs.getInstances();
-                        }
-                        this.currentChunk2 = null;
-                        this.newclassifier.resetLearning();
-                }
-                this.previousState = DDM_OUTCONTROL_LEVEL;
-                break;
-            case DDM_INCONTROL_LEVEL:
-                switch (this.previousState) {
-                    case DDM_INCONTROL_LEVEL:
-                    case DDM_OUTCONTROL_LEVEL:
-                        break;
-                    case DDM_WARNING_LEVEL:
-                        this.currentChunk2 = null;
-                        break;
-                    default:
-                        this.currentChunk = new ArrayList();
-                        this.classifiers.add(new ClassifierKS(
-                                this.classifier, this.currentChunk));
-                        break;
-                }
-                this.addInstance(this.currentChunk, inst);
-                this.previousState = DDM_INCONTROL_LEVEL;
-                break;
-        }
-        this.classifier.trainOnInstance(inst);
-    }
-
-    private void addInstance(List<Instance> instances, Instance instance) {
-        if (instances.size() >= bufferSize) {
-            instances.remove(0);
-        }
-        instances.add(instance);
-    }
-
-    @Override
-    public Prediction getPredictionForInstance(Instance inst) {
-        if (this.testChunk == null) {
-            this.testChunk = new ArrayList();
-        }
-        this.addInstance(this.testChunk, inst);
-        if (this.index++ == testFrequencyOption.getValue()) {
-            this.index = 0;
-            ClassifierKS cs = this.getPreviousClassifier(
-                    this.classifier, this.testChunk);
-            if (cs != null) {
-                this.classifier = cs.getClassifier();
-            }
-        }
-        return this.classifier.getPredictionForInstance(inst);
-    }
-
-    /**
-     * Searches for the classifier best suited for actual data. All statistical
-     * tests are performed in parallel.
-     *
-     * @param classifier Classifier to be added
-     * @param instances Instances used to build the classifier
-     * @return
-     */
-    private ClassifierKS getPreviousClassifier(Classifier classifier,
-            List<Instance> instances) {
-        ExecutorService threadPool = Executors.newFixedThreadPool(this.threadSizeOption.getValue());
-        int SIZE = this.classifiers.size();
-        Map<Integer, Future<Double>> futures = new HashMap<>();
-        for (int i = 0; i < SIZE; i++) {
-            ClassifierKS cs = this.classifiers.get(i);
-            if (cs != null) {
-                if (cs.getClassifier() != classifier) {
-                    StatisticalTest st = (StatisticalTest) getPreparedClassOption(this.statisticalTestOption);
-                    StatisticalTest temp = (StatisticalTest) st.copy();
-                    temp.set(instances, cs.getInstances());
-                    futures.put(i, threadPool.submit(temp));
-                }
-            } else {
-                break;
-            }
-        }
-        ClassifierKS cks = null;
-        int qtd = this.quantityClassifiersTestOption.getValue();
-        double maxPValue = this.similarityBetweenDistributionsOption.getValue();
-        try {
-            for (int i = 0; i < SIZE && qtd > 0; i++) {
-                Future<Double> f = futures.get(i);
-                if (f != null) {
-                    double p = f.get();
-                    if (p < maxPValue) {
-                        maxPValue = p;
-                        cks = this.classifiers.get(i);
-                        qtd--;
-                    }
-                }
-            }
-        } catch (InterruptedException e) {
-            System.out.println("Processing interrupted.");
-        } catch (ExecutionException e) {
-            throw new RuntimeException("Error computing statistical test.", e);
-        }
-        threadPool.shutdownNow();
-        return cks;
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java b/moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java
deleted file mode 100644
index cebf5b8b8..000000000
--- a/moa/src/main/java/moa/classifiers/meta/TemporallyAugmentedClassifier.java
+++ /dev/null
@@ -1,189 +0,0 @@
-/*
- *    TemporallyAugmentedClassifier.java
- *    Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- *    @author Bernhard Pfahringer (bernhard@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.meta;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.LinkedList;
-import java.util.List;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Attribute;
-import com.yahoo.labs.samoa.instances.DenseInstance;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.AbstractInstanceLearner;
-import moa.core.Measurement;
-import moa.core.Utils;
-import moa.learners.Classifier;
-import moa.options.ClassOption;
-
-/**
- * Include labels of previous instances into the training data
- *
- * <p>This enables a classifier to exploit potentially present auto-correlation
- * </p>
- *
- * <p>Parameters:</p> <ul> <li>-l : Classifier to train</li> <li>-n : The number
- * of old labels to include</li> </ul>
- *
- * @author Bernhard Pfahringer (bernhard@cs.waikato.ac.nz)
- * @version $Revision: 1 $
- */
-public class TemporallyAugmentedClassifier extends AbstractClassifier implements Classifier {
-
-    @Override
-    public String getPurposeString() {
-        return "Add some old labels to every instance";
-    }
-    private static final long serialVersionUID = 1L;
-    
-    public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l',
-            "Classifier to train.", Classifier.class, "moa.classifiers.trees.HoeffdingTree");
-    
-    public IntOption numOldLabelsOption = new IntOption("numOldLabels", 'n',
-            "The number of old labels to add to each example.", 1, 0, Integer.MAX_VALUE);
-    
-    protected Classifier baseLearner;
-    
-    protected double[] oldLabels;
-    
-    protected InstancesHeader header;
-
-    public FlagOption labelDelayOption = new FlagOption("labelDelay", 'd',
-        "Labels arrive with Delay. Use predictions instead of true Labels.");
-    
-    @Override
-    public void resetLearningImpl() {
-        this.baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
-        this.oldLabels = new double[this.numOldLabelsOption.getValue()];
-        this.header = null;
-        baseLearner.resetLearning();
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance instance) {
-        this.baseLearner.trainOnInstance(extendWithOldLabels(instance));
-        if (this.labelDelayOption.isSet() == false) {
-            // Use true old Labels to add attributes to instances
-            addOldLabel(instance.classValue());
-        }
-    }
-
-    public void addOldLabel(double newPrediction) {
-        int numLabels = this.oldLabels.length;
-        if (numLabels > 0) {
-            for (int i = 1; i < numLabels; i++) {
-                this.oldLabels[i - 1] = this.oldLabels[i];
-            }
-            this.oldLabels[ numLabels - 1] = newPrediction;
-        }
-    }
-
-    public void initHeader(InstancesHeader dataset) {
-        int numLabels = this.numOldLabelsOption.getValue();
-        Attribute target = dataset.classAttribute();
-
-        List<String> possibleValues = new ArrayList<String>();
-        int n = target.numValues();
-        for (int i = 0; i < n; i++) {
-            possibleValues.add(target.value(i));
-        }
-
-        ArrayList<Attribute> attrs = new ArrayList<Attribute>(numLabels + dataset.numAttributes());
-        for (int i = 0; i < numLabels; i++) {
-            attrs.add(new Attribute(target.name() + "_" + i, possibleValues));
-        }
-        for (int i = 0; i < dataset.numAttributes(); i++) {
-            Attribute attr = dataset.attribute(i);
-            Attribute newAttribute = null;
-            if (attr.isNominal() == true) {
-                newAttribute = new Attribute(attr.name(), attr.getAttributeValues());
-            }
-            if (attr.isNumeric() == true) {
-                newAttribute = new Attribute(attr.name());
-            }
-            if (newAttribute != null) {
-                attrs.add(newAttribute);
-            }
-        }
-        this.header = new InstancesHeader("extended_" + dataset.getRelationName(), attrs, 0);
-        this.header.setClassIndex(numLabels + dataset.classIndex());
-    }
-
-    public Instance extendWithOldLabels(Instance instance) {
-        if (this.header == null) {
-            initHeader(instance.dataset());
-            this.baseLearner.setModelContext(this.header.getEmptyHeader());
-        }
-        int numLabels = this.oldLabels.length;
-        if (numLabels == 0) {
-            return instance;
-        }
-        double[] x = instance.toDoubleArray();
-        double[] x2 = Arrays.copyOfRange(this.oldLabels, 0, numLabels + x.length);
-        System.arraycopy(x, 0, x2, numLabels, x.length);
-        Instance extendedInstance = new DenseInstance(instance.weight(), x2);
-        extendedInstance.setDataset(this.header);
-        //System.out.println( extendedInstance);
-        return extendedInstance;
-    }
-
-    @Override
-    public Prediction getPredictionForInstance(Instance instance) {
-        double[] prediction = this.baseLearner.getPredictionForInstance(extendWithOldLabels(instance)).asDoubleArray();
-        if (this.labelDelayOption.isSet() == true) {
-            // Use predicted Labels to add attributes to instances
-            addOldLabel(Utils.maxIndex(prediction));
-        }
-        return new ClassificationPrediction(prediction);
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return false; // ??? this.baseLearner.isRandomizable;
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        List<Measurement> measurementList = new LinkedList<Measurement>();
-        Measurement[] modelMeasurements = ((AbstractInstanceLearner) this.baseLearner).getModelMeasurements();
-        if (modelMeasurements != null) {
-            for (Measurement measurement : modelMeasurements) {
-                measurementList.add(measurement);
-            }
-        }
-        return measurementList.toArray(new Measurement[measurementList.size()]);
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    public String toString() {
-        return "TemporallyAugmentedClassifier using " + this.numOldLabelsOption.getValue() + " labels\n" + this.baseLearner;
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/meta/WEKAClassifier.java b/moa/src/main/java/moa/classifiers/meta/WEKAClassifier.java
deleted file mode 100644
index cfd512486..000000000
--- a/moa/src/main/java/moa/classifiers/meta/WEKAClassifier.java
+++ /dev/null
@@ -1,209 +0,0 @@
-/*
- *    WEKAClassifier.java
- *    Copyright (C) 2009 University of Waikato, Hamilton, New Zealand
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *    @author FracPete (fracpete at waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.meta;
-
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractClassifier;
-import moa.core.Measurement;
-import moa.options.WEKAClassOption;
-import weka.classifiers.Classifier;
-import weka.classifiers.UpdateableClassifier;
-
-/**
- * Class for using a classifier from WEKA.
- *
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @author FracPete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class WEKAClassifier extends AbstractClassifier implements moa.learners.Classifier {
-
-    private static final long serialVersionUID = 1L;
-
-    protected SamoaToWekaInstanceConverter instanceConverter;
-
-    @Override
-    public String getPurposeString() {
-        return "Classifier from Weka";
-    }
-    
-    public WEKAClassOption baseLearnerOption = new WEKAClassOption("baseLearner", 'l',
-            "Classifier to train.", weka.classifiers.Classifier.class, "weka.classifiers.bayes.NaiveBayesUpdateable");
-
-    public IntOption widthOption = new IntOption("width",
-            'w', "Size of Window for training learner.", 0, 0, Integer.MAX_VALUE);
-
-    public IntOption widthInitOption = new IntOption("widthInit",
-            'i', "Size of first Window for training learner.", 1000, 0, Integer.MAX_VALUE);
-
-    public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
-            'f',
-            "How many instances between samples of the learning performance.",
-            0, 0, Integer.MAX_VALUE);
-
-    protected Classifier classifier;
-
-    protected int numberInstances;
-
-    protected weka.core.Instances instancesBuffer;
-
-    protected boolean isClassificationEnabled;
-
-    protected boolean isBufferStoring;
-
-    @Override
-    public void resetLearningImpl() {
-
-        try {
-            //System.out.println(baseLearnerOption.getValue());
-            String[] options = weka.core.Utils.splitOptions(baseLearnerOption.getValueAsCLIString());
-            createWekaClassifier(options);
-        } catch (Exception e) {
-            System.err.println("Creating a new classifier: " + e.getMessage());
-        }
-        numberInstances = 0;
-        isClassificationEnabled = false;
-        this.isBufferStoring = true;
-        this.instanceConverter = new SamoaToWekaInstanceConverter();
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance samoaInstance) {
-        weka.core.Instance inst = this.instanceConverter.wekaInstance(samoaInstance);
-        try {
-            if (numberInstances == 0) {
-                this.instancesBuffer = new weka.core.Instances(inst.dataset());
-                if (classifier instanceof UpdateableClassifier) {
-                    classifier.buildClassifier(instancesBuffer);
-                    this.isClassificationEnabled = true;
-                } else {
-                    this.isBufferStoring = true;
-                }
-            }
-            numberInstances++;
-
-            if (classifier instanceof UpdateableClassifier) {
-                if (numberInstances > 0) {
-                    ((UpdateableClassifier) classifier).updateClassifier(inst);
-                }
-            } else {
-                if (numberInstances == widthInitOption.getValue()) {
-                    //Build first time Classifier
-                    buildClassifier();
-                    isClassificationEnabled = true;
-                    //Continue to store instances
-                    if (sampleFrequencyOption.getValue() != 0) {
-                        isBufferStoring = true;
-                    }
-                }
-                if (widthOption.getValue() == 0) {
-                    //Used from SingleClassifierDrift
-                    if (isBufferStoring == true) {
-                        instancesBuffer.add(inst);
-                    }
-                } else {
-                    //Used form WekaClassifier without using SingleClassifierDrift
-                    int numInstances = numberInstances % sampleFrequencyOption.getValue();
-                    if (sampleFrequencyOption.getValue() == 0) {
-                        numInstances = numberInstances;
-                    }
-                    if (numInstances == 0) {
-                        //Begin to store instances
-                        isBufferStoring = true;
-                    }
-                    if (isBufferStoring == true && numInstances <= widthOption.getValue()) {
-                        //Store instances
-                        instancesBuffer.add(inst);
-                    }
-                    if (numInstances == widthOption.getValue()) {
-                        //Build Classifier
-                        buildClassifier();
-                        isClassificationEnabled = true;
-                        this.instancesBuffer = new weka.core.Instances(inst.dataset());
-                    }
-                }
-            }
-        } catch (Exception e) {
-            System.err.println("Training: " + e.getMessage());
-        }
-    }
-
-    public void buildClassifier() {
-        try {
-            if ((classifier instanceof UpdateableClassifier) == false) {
-                Classifier auxclassifier = weka.classifiers.AbstractClassifier.makeCopy(classifier);
-                auxclassifier.buildClassifier(instancesBuffer);
-                classifier = auxclassifier;
-                isBufferStoring = false;
-            }
-        } catch (Exception e) {
-            System.err.println("Building WEKA Classifier: " + e.getMessage());
-        }
-    }
-
-    @Override
-    public Prediction getPredictionForInstance(Instance samoaInstance) {
-        weka.core.Instance inst = this.instanceConverter.wekaInstance(samoaInstance);
-        double[] votes = new double[inst.numClasses()];
-        if (isClassificationEnabled == false) {
-            for (int i = 0; i < inst.numClasses(); i++) {
-                votes[i] = 1.0 / inst.numClasses();
-            }
-		} else {
-			try {
-				votes = this.classifier.distributionForInstance(inst);
-			} catch (Exception e) {
-				System.err.println(e.getMessage());
-			}
-		}
-		return new ClassificationPrediction(votes);
-	}
-
-    @Override
-    public boolean isRandomizable() {
-        return false;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        if (classifier != null) {
-            out.append(classifier.toString());
-        }
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        Measurement[] m = new Measurement[0];
-        return m;
-    }
-
-    public void createWekaClassifier(String[] options) throws Exception {
-        String classifierName = options[0];
-        String[] newoptions = options.clone();
-        newoptions[0] = "";
-        this.classifier = weka.classifiers.AbstractClassifier.forName(classifierName, newoptions);
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/meta/WeightedMajorityAlgorithm.java b/moa/src/main/java/moa/classifiers/meta/WeightedMajorityAlgorithm.java
deleted file mode 100644
index 81b913d31..000000000
--- a/moa/src/main/java/moa/classifiers/meta/WeightedMajorityAlgorithm.java
+++ /dev/null
@@ -1,208 +0,0 @@
-/*
- *    WeightedMajorityAlgorithm.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.meta;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.ListOption;
-import com.github.javacliparser.Option;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractClassifier;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.core.ObjectRepository;
-import moa.core.Utils;
-import moa.learners.Classifier;
-import moa.options.ClassOption;
-import moa.tasks.TaskMonitor;
-
-/**
- * Weighted majority algorithm for data streams.
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $
- */
-public class WeightedMajorityAlgorithm extends AbstractClassifier implements Classifier {
-
-    private static final long serialVersionUID = 1L;
-    
-    @Override
-    public String getPurposeString() {
-        return "Weighted majority algorithm for data streams.";
-    }
-        
-    public ListOption learnerListOption = new ListOption(
-            "learners",
-            'l',
-            "The learners to combine.",
-            new ClassOption("learner", ' ', "", Classifier.class,
-            "moa.classifiers.trees.HoeffdingTree"),
-            new Option[]{
-                new ClassOption("", ' ', "", Classifier.class,
-                "moa.classifiers.trees.HoeffdingTree -l MC"),
-                new ClassOption("", ' ', "", Classifier.class,
-                "moa.classifiers.trees.HoeffdingTree -l NB"),
-                new ClassOption("", ' ', "", Classifier.class,
-                "moa.classifiers.trees.HoeffdingTree -l NBAdaptive"),
-                new ClassOption("", ' ', "", Classifier.class, "moa.classifiers.bayes.NaiveBayes")},
-            ',');
-
-    public FloatOption betaOption = new FloatOption("beta", 'b',
-            "Factor to punish mistakes by.", 0.9, 0.0, 1.0);
-
-    public FloatOption gammaOption = new FloatOption("gamma", 'g',
-            "Minimum fraction of weight per model.", 0.01, 0.0, 0.5);
-
-    public FlagOption pruneOption = new FlagOption("prune", 'p',
-            "Prune poorly performing models from ensemble.");
-
-    protected Classifier[] ensemble;
-
-    protected double[] ensembleWeights;
-
-    @Override
-    public void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        Option[] learnerOptions = this.learnerListOption.getList();
-        this.ensemble = new Classifier[learnerOptions.length];
-        for (int i = 0; i < learnerOptions.length; i++) {
-            monitor.setCurrentActivity("Materializing learner " + (i + 1)
-                    + "...", -1.0);
-            this.ensemble[i] = (Classifier) ((ClassOption) learnerOptions[i]).materializeObject(monitor, repository);
-            if (monitor.taskShouldAbort()) {
-                return;
-            }
-            monitor.setCurrentActivity("Preparing learner " + (i + 1) + "...",
-                    -1.0);
-            this.ensemble[i].prepareForUse(monitor, repository);
-            if (monitor.taskShouldAbort()) {
-                return;
-            }
-        }
-        super.prepareForUseImpl(monitor, repository);
-    }
-
-    @Override
-    public void resetLearningImpl() {
-        this.ensembleWeights = new double[this.ensemble.length];
-        for (int i = 0; i < this.ensemble.length; i++) {
-            this.ensemble[i].resetLearning();
-            this.ensembleWeights[i] = 1.0;
-        }
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        double totalWeight = 0.0;
-        for (int i = 0; i < this.ensemble.length; i++) {
-            boolean prune = false;
-            if (!this.ensemble[i].correctlyClassifies(inst)) {
-                if (this.ensembleWeights[i] > this.gammaOption.getValue()
-                        / this.ensembleWeights.length) {
-                    this.ensembleWeights[i] *= this.betaOption.getValue()
-                            * inst.weight();
-                } else if (this.pruneOption.isSet()) {
-                    prune = true;
-                    discardModel(i);
-                    i--;
-                }
-            }
-            if (!prune) {
-                totalWeight += this.ensembleWeights[i];
-                this.ensemble[i].trainOnInstance(inst);
-            }
-        }
-        // normalize weights
-        for (int i = 0; i < this.ensembleWeights.length; i++) {
-            this.ensembleWeights[i] /= totalWeight;
-        }
-    }
-
-    public Prediction getPredictionForInstance(Instance inst) {
-        DoubleVector combinedVote = new DoubleVector();
-        if (this.trainingWeightSeenByModel > 0.0) {
-            for (int i = 0; i < this.ensemble.length; i++) {
-                if (this.ensembleWeights[i] > 0.0) {
-                    DoubleVector vote = this.ensemble[i].getPredictionForInstance(inst).asDoubleVector();
-                    if (vote.sumOfValues() > 0.0) {
-                        vote.normalize();
-                        vote.scaleValues(this.ensembleWeights[i]);
-                        combinedVote.addValues(vote);
-                    }
-                }
-            }
-        }
-        return new ClassificationPrediction(combinedVote.getArrayRef());
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        Measurement[] measurements = null;
-        if (this.ensembleWeights != null) {
-            measurements = new Measurement[this.ensembleWeights.length];
-            for (int i = 0; i < this.ensembleWeights.length; i++) {
-                measurements[i] = new Measurement("member weight " + (i + 1),
-                        this.ensembleWeights[i]);
-            }
-        }
-        return measurements;
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return false;
-    }
-
-    @Override
-    public Classifier[] getSubClassifiers() {
-        return this.ensemble.clone();
-    }
-
-    public void discardModel(int index) {
-        Classifier[] newEnsemble = new Classifier[this.ensemble.length - 1];
-        double[] newEnsembleWeights = new double[newEnsemble.length];
-        int oldPos = 0;
-        for (int i = 0; i < newEnsemble.length; i++) {
-            if (oldPos == index) {
-                oldPos++;
-            }
-            newEnsemble[i] = this.ensemble[oldPos];
-            newEnsembleWeights[i] = this.ensembleWeights[oldPos];
-            oldPos++;
-        }
-        this.ensemble = newEnsemble;
-        this.ensembleWeights = newEnsembleWeights;
-    }
-
-    protected long removePoorestModelBytes() {
-        int poorestIndex = Utils.minIndex(this.ensembleWeights);
-        long byteSize = this.ensemble[poorestIndex].measureByteSize();
-        discardModel(poorestIndex);
-        return byteSize;
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/mlc/MEKAClassifier.java b/moa/src/main/java/moa/classifiers/mlc/MEKAClassifier.java
deleted file mode 100644
index 10f72a45e..000000000
--- a/moa/src/main/java/moa/classifiers/mlc/MEKAClassifier.java
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
- *    MEKAClassifier.java
- *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
- *    @author Jesse Read
- * 
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.mlc;
-
-import java.io.Serializable;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
-import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractMultiLabelClassifier;
-import moa.core.Measurement;
-import moa.learners.MultiLabelClassifier;
-import moa.options.WEKAClassOption;
-import weka.classifiers.Classifier;
-import weka.classifiers.UpdateableClassifier;
-
-/**
- * Wrapper for MEKA classifiers. 
- *
- * @author Jesse Read
- * @version $Revision: 1 $
- */
-public class MEKAClassifier extends AbstractMultiLabelClassifier implements MultiLabelClassifier, Serializable {
-
-	private static final long serialVersionUID = 1L;
-
-    protected SamoaToWekaInstanceConverter instanceConverter;
-
-    @Override
-    public String getPurposeString() {
-        return "Classifier from Meka";
-    }
-    
-    public WEKAClassOption baseLearnerOption = new WEKAClassOption("baseLearner", 'l',
-            "Classifier to train.", weka.classifiers.Classifier.class, "meka.classifiers.multilabel.incremental.BRUpdateable");
-
-    protected Classifier classifier;
-
-    protected weka.core.Instances instancesBuffer;
-
-    protected boolean isClassificationEnabled;
-
-    //protected boolean isBufferStoring;
-
-
-	private int L = 0;
-
-    public void resetLearningImpl() {
-
-        try {
-            //System.out.println(baseLearnerOption.getValue());
-            String[] options = weka.core.Utils.splitOptions(baseLearnerOption.getValueAsCLIString());
-            createWekaClassifier(options);
-		} catch (Exception e) {
-            System.err.println("[ERROR] Creating a new classifier: " + e.getMessage());
-        }
-        isClassificationEnabled = false;
-        //this.isBufferStoring = true;
-        this.instanceConverter = new SamoaToWekaInstanceConverter();
-
-    }
-
-    public void trainOnInstanceImpl(StructuredInstance samoaInstance) {
-		// This is here so MEKAClassifier can act as a multi-target regressor
-    	trainOnInstance((MultiLabelInstance) samoaInstance);
-    }
-    
-	public void trainOnInstanceImpl(Instance samoaInstance) {
-		// Convert Samoa instance to Weka instance (as used in Meka)
-		L = samoaInstance.numOutputAttributes();
-		weka.core.Instance x = this.instanceConverter.wekaInstance(samoaInstance);
-		x.dataset().setClassIndex(L);
-
-		if (this.isClassificationEnabled == false) {
-			/*
-			 *  INITIALISE
-			 */
-			this.instancesBuffer = new weka.core.Instances(x.dataset());
-			try {
-				instancesBuffer.setClassIndex(L);
-				classifier.buildClassifier(instancesBuffer);
-			} catch(Exception e) {
-				System.err.println("[ERROR] Failed to build classifier, L="+L);
-				e.printStackTrace();
-				//System.exit(1);
-			}
-			this.isClassificationEnabled = true;
-		}
-		else {
-			/*
-			 *  UPDATE
-			 */
-			try {
-				((UpdateableClassifier) classifier).updateClassifier(x);
-			} catch(Exception e) {
-				System.err.println("[ERROR] Failed to update classifier");
-				e.printStackTrace();
-				//System.exit(1);
-			}
-		}
-
-	}
-
-
-	
-	public Prediction getPredictionForInstance(Instance samoaInstance) {
-
-		weka.core.Instance inst = this.instanceConverter.wekaInstance(samoaInstance);
-
-		double votes[] = new double[L];
-
-		try {
-			votes = this.classifier.distributionForInstance(inst);
-		} catch(Exception e) {
-			System.err.println("[WARNING] Failed to get votes from multi-label classifier (not trained yet?).");
-			//e.printStackTrace();
-			//System.exit(1);
-		}
-
-		return new MultiLabelClassificationPrediction(votes);
-	}
-
-	public Prediction getPredictionForInstance(StructuredInstance samoaInstance) {
-		// This is here so MEKAClassifier can act as a multi-target regressor
-		return getPredictionForInstance((MultiLabelInstance) samoaInstance);
-	}
-	
-	public Prediction getPredictionForInstance(MultiLabelInstance samoaInstance) {
-
-		MultiLabelClassificationPrediction prediction = new MultiLabelClassificationPrediction(L);
-
-		if (isClassificationEnabled == true) { 
-
-			double votes[] = getPredictionForInstance(samoaInstance).asDoubleArray();
-
-			for (int j = 0; j < L; j++) {
-				prediction.setVotes(j, new double[]{1.-votes[j],votes[j]});
-			}
-
-		}
-		// else there's no model yet... (just return empty prediction).
-		
-		return prediction;
-	}
-
-    protected Measurement[] getModelMeasurementsImpl() {
-		return null;
-    }
-
-    public boolean isRandomizable() {
-        return false;
-    }
-
-
-    public void getModelDescription(StringBuilder out, int indent) {
-		if (classifier != null) {
-            out.append(classifier.toString());
-        }
-    }
-
-    public void createWekaClassifier(String[] options) throws Exception {
-        String classifierName = options[0];
-        String[] newoptions = options.clone();
-        newoptions[0] = "";
-        this.classifier = weka.classifiers.AbstractClassifier.forName(classifierName, newoptions);
-		if (! (this.classifier instanceof UpdateableClassifier)) {
-			// TODO: Non-Updateable MEKA classifiers could also work here.
-			System.err.println("[ERROR] You must use an Updateable Classifier");
-			throw new Exception("Only Updateable MEKA classifiers can be used.");
-		}
-	}
-
-}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/mlc/MajorityLabelset.java b/moa/src/main/java/moa/classifiers/mlc/MajorityLabelset.java
deleted file mode 100644
index ea31ac875..000000000
--- a/moa/src/main/java/moa/classifiers/mlc/MajorityLabelset.java
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
- *    MajorityLabelset.java
- *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
- *    @author Jesse Read (jesse@tsc.uc3m.es)
- * 
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.mlc;
-
-import java.util.HashMap;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractMultiLabelClassifier;
-import moa.core.Measurement;
-import moa.core.StringUtils;
-import moa.learners.MultiLabelClassifier;
-
-/**
- * Majority Labelset classifier. Each labelset combination of relevances, e.g.
- * [0,0,1,1,0,0], is treated as a single class value.
- * 
- * @author Jesse Read (jesse@tsc.uc3m.es)
- * @version $Revision: 1 $
- */
-public class MajorityLabelset extends AbstractMultiLabelClassifier implements MultiLabelClassifier {
-    //AbstractClassifier {
-
-    private static final long serialVersionUID = 1L;
-
-	@Override
-    public String getPurposeString() {
-        return "Majority labelset classifier: always predicts the labelvector most frequently seen so far.";
-    }
-
-    private double maxValue = -1.0;
-
-    private MultiLabelClassificationPrediction majorityLabelset = null;
-
-    private HashMap<String, Double> vectorCounts = new HashMap<String, Double>();
-
-    @Override
-    public void resetLearningImpl() {
-		this.majorityLabelset = null;
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance x) {
-		int L = x.numOutputAttributes();
-
-        MultiLabelClassificationPrediction y = new MultiLabelClassificationPrediction(L);
-		for(int j=0; j<L;j++)
-    		y.setVotes(j,new double[]{1- x.classValue(j), x.classValue(j)});
-
-        double freq = x.weight();
-		if (this.vectorCounts.containsKey(y.toString())) {
-            freq += this.vectorCounts.get(y.toString());
-        }
-        this.vectorCounts.put(y.toString(), (Double)freq);
-        if (freq > this.maxValue) {
-            this.maxValue = freq;
-            this.majorityLabelset = y;
-        }
-        //System.out.println("---"+this.majorityLabelset);
-    }
-
-    @Override
-    public Prediction getPredictionForInstance(Instance x){
-
-		if (this.majorityLabelset == null)  {
-			int L = x.numOutputAttributes();
-			return new MultiLabelClassificationPrediction(L);
-		}
-
-		return this.majorityLabelset;
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return null;
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return false;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        StringUtils.appendIndented(out, indent, "");
-        out.append(this.majorityLabelset.toString());
-        StringUtils.appendNewline(out);
-
-    }
-
-}
diff --git a/moa/src/main/java/moa/classifiers/mlc/MultilabelHoeffdingTree.java b/moa/src/main/java/moa/classifiers/mlc/MultilabelHoeffdingTree.java
deleted file mode 100644
index dea272a56..000000000
--- a/moa/src/main/java/moa/classifiers/mlc/MultilabelHoeffdingTree.java
+++ /dev/null
@@ -1,986 +0,0 @@
-/*
- *    MultilabelMultilabelHoeffdingTree.java
- *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
- *    @author Jesse Read (jesse@tsc.uc3m.es)
- * 
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.mlc;
-
-import java.util.Arrays;
-import java.util.Comparator;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Set;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.AbstractMOAObject;
-import moa.classifiers.AbstractMultiLabelClassifier;
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.DiscreteAttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.NullAttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.NumericAttributeClassObserver;
-import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.classifiers.trees.HoeffdingTreeClassifLeaves;
-import moa.core.AutoExpandVector;
-import moa.core.DoubleVector;
-import moa.core.Example;
-import moa.core.Measurement;
-import moa.core.SizeOf;
-import moa.core.StringUtils;
-import moa.learners.Classifier;
-import moa.learners.MultiLabelClassifier;
-import moa.options.ClassOption;
-
-/**
- * Hoeffding Tree for classifying multi-label data.
- *
- * A Hoeffding tree is an incremental, anytime decision tree induction algorithm
- * that is capable of learning from massive data streams, assuming that the
- * distribution generating examples does not change over time.
- * 
- * 
- */ 
-public class MultilabelHoeffdingTree extends AbstractMultiLabelClassifier implements MultiLabelClassifier { 
-// Needs to use InfoGainSplitCriterionMultiLabel, since multilabel entropy is calculated in a different way 
-// Trains a mlinstance adding statistics of several class values and training node classifiers
-// Get votes from the classifier in the learning node of the tree
-
-	private static final long serialVersionUID = 1L;
-
-
-    public ClassOption learnerOption = new ClassOption("learner", 'a',
-            "Classifier to train.", Classifier.class, "bayes.NaiveBayes");
-	
-    public IntOption maxByteSizeOption = new IntOption("maxByteSize", 'm',
-            "Maximum memory consumed by the tree.", 33554432, 0,
-            Integer.MAX_VALUE);
-    
-    public ClassOption numericEstimatorOption = new ClassOption("numericEstimator",
-            'n', "Numeric estimator to use.", NumericAttributeClassObserver.class,
-            "GaussianNumericAttributeClassObserver");
-
-    public ClassOption nominalEstimatorOption = new ClassOption("nominalEstimator",
-            'd', "Nominal estimator to use.", DiscreteAttributeClassObserver.class,
-            "NominalAttributeClassObserver");
-
-    public IntOption memoryEstimatePeriodOption = new IntOption(
-            "memoryEstimatePeriod", 'e',
-            "How many instances between memory consumption checks.", 1000000,
-            0, Integer.MAX_VALUE);
-
-    public IntOption gracePeriodOption = new IntOption(
-            "gracePeriod",
-            'g',
-            "The number of instances a leaf should observe between split attempts.",
-            200, 0, Integer.MAX_VALUE);
-
-    public ClassOption splitCriterionOption = new ClassOption("splitCriterion",
-            's', "Split criterion to use.", SplitCriterion.class,
-            "InfoGainSplitCriterion");
-
-    
-    public FloatOption splitConfidenceOption = new FloatOption(
-            "splitConfidence",
-            'c',
-            "The allowable error in split decision, values closer to 0 will take longer to decide.",
-            0.0000001, 0.0, 1.0);
-
-    public FloatOption tieThresholdOption = new FloatOption("tieThreshold",
-            't', "Threshold below which a split will be forced to break ties.",
-            0.05, 0.0, 1.0);
-
-    public FlagOption binarySplitsOption = new FlagOption("binarySplits", 'b',
-        "Only allow binary splits.");
-
-    public FlagOption stopMemManagementOption = new FlagOption(
-            "stopMemManagement", 'z',
-            "Stop growing as soon as memory limit is hit.");
-
-    public FlagOption removePoorAttsOption = new FlagOption("removePoorAtts",
-            'r', "Disable poor attributes.");
-
-    public FlagOption noPrePruneOption = new FlagOption("noPrePrune", 'p',
-            "Disable pre-pruning.");
-    
-    public MultiChoiceOption leafpredictionOption = new MultiChoiceOption(
-            "leafprediction", 'l', "Leaf prediction to use.", new String[]{
-                "MC", "NB", "NBAdaptive"}, new String[]{
-                "Majority class",
-                "Naive Bayes",
-                "Naive Bayes Adaptive"}, 2);
-
-    public IntOption nbThresholdOption = new IntOption(
-            "nbThreshold",
-            'q',
-            "The number of instances a leaf should observe before permitting Naive Bayes.",
-            0, 0, Integer.MAX_VALUE);
-    
-	/*public MultilabelMultilabelHoeffdingTree() {
-		this.removePoorAttsOption = null;
-	}*/
-
-    public static class FoundNode {
-
-        public Node node;
-
-        public SplitNode parent;
-
-        public int parentBranch;
-
-        public FoundNode(Node node, SplitNode parent, int parentBranch) {
-            this.node = node;
-            this.parent = parent;
-            this.parentBranch = parentBranch;
-        }
-    }
-
-    public static class Node extends AbstractMOAObject {
-
-        private static final long serialVersionUID = 1L;
-
-        protected DoubleVector observedClassDistribution;
-
-        public Node(double[] classObservations) {
-            this.observedClassDistribution = new DoubleVector(classObservations);
-        }
-
-        public int calcByteSize() {
-            return (int) (SizeOf.sizeOf(this) + SizeOf.fullSizeOf(this.observedClassDistribution));
-        }
-
-        public int calcByteSizeIncludingSubtree() {
-            return calcByteSize();
-        }
-
-        public boolean isLeaf() {
-            return true;
-        }
-
-        public FoundNode filterInstanceToLeaf(Instance inst, SplitNode parent,
-                int parentBranch) {
-            return new FoundNode(this, parent, parentBranch);
-        }
-
-        public double[] getObservedClassDistribution() {
-            return this.observedClassDistribution.getArrayCopy();
-        }
-
-        public double[] getClassVotes(Instance inst, MultilabelHoeffdingTree ht) {
-            return this.observedClassDistribution.getArrayCopy();
-        }
-
-        public boolean observedClassDistributionIsPure() {
-            return this.observedClassDistribution.numNonZeroEntries() < 2;
-        }
-
-        public void describeSubtree(MultilabelHoeffdingTree ht, StringBuilder out,
-                int indent) {
-            StringUtils.appendIndented(out, indent, "Leaf ");
-            out.append(ht.getClassNameString());
-            out.append(" = ");
-            out.append(ht.getClassLabelString(this.observedClassDistribution.maxIndex()));
-            out.append(" weights: ");
-            this.observedClassDistribution.getSingleLineDescription(out,
-                    ht.treeRoot.observedClassDistribution.numValues());
-            StringUtils.appendNewline(out);
-        }
-
-        public int subtreeDepth() {
-            return 0;
-        }
-
-        public double calculatePromise() {
-            double totalSeen = this.observedClassDistribution.sumOfValues();
-            return totalSeen > 0.0 ? (totalSeen - this.observedClassDistribution.getValue(this.observedClassDistribution.maxIndex()))
-                    : 0.0;
-        }
-
-        @Override
-        public void getDescription(StringBuilder sb, int indent) {
-            describeSubtree(null, sb, indent);
-        }
-    }
-
-    public static class SplitNode extends Node {
-
-        private static final long serialVersionUID = 1L;
-
-        protected InstanceConditionalTest splitTest;
-
-        protected AutoExpandVector<Node> children; // = new AutoExpandVector<Node>();
-
-        @Override
-        public int calcByteSize() {
-            return super.calcByteSize()
-                    + (int) (SizeOf.sizeOf(this.children) + SizeOf.fullSizeOf(this.splitTest));
-        }
-
-        @Override
-        public int calcByteSizeIncludingSubtree() {
-            int byteSize = calcByteSize();
-            for (Node child : this.children) {
-                if (child != null) {
-                    byteSize += child.calcByteSizeIncludingSubtree();
-                }
-            }
-            return byteSize;
-        }
-
-        public SplitNode(InstanceConditionalTest splitTest,
-                double[] classObservations, int size) {
-            super(classObservations);
-            this.splitTest = splitTest;
-            this.children = new AutoExpandVector<Node>(size);
-        }
-        
-        public SplitNode(InstanceConditionalTest splitTest,
-                double[] classObservations) {
-            super(classObservations);
-            this.splitTest = splitTest;
-            this.children = new AutoExpandVector<Node>();
-        }
-
-
-        public int numChildren() {
-            return this.children.size();
-        }
-
-        public void setChild(int index, Node child) {
-            if ((this.splitTest.maxBranches() >= 0)
-                    && (index >= this.splitTest.maxBranches())) {
-                throw new IndexOutOfBoundsException();
-            }
-            this.children.set(index, child);
-        }
-
-        public Node getChild(int index) {
-            return this.children.get(index);
-        }
-
-        public int instanceChildIndex(Instance inst) {
-            return this.splitTest.branchForInstance(inst);
-        }
-
-        @Override
-        public boolean isLeaf() {
-            return false;
-        }
-
-        @Override
-        public FoundNode filterInstanceToLeaf(Instance inst, SplitNode parent,
-                int parentBranch) {
-            int childIndex = instanceChildIndex(inst);
-            if (childIndex >= 0) {
-                Node child = getChild(childIndex);
-                if (child != null) {
-                    return child.filterInstanceToLeaf(inst, this, childIndex);
-                }
-                return new FoundNode(null, this, childIndex);
-            }
-            return new FoundNode(this, parent, parentBranch);
-        }
-
-        @Override
-        public void describeSubtree(MultilabelHoeffdingTree ht, StringBuilder out,
-                int indent) {
-            for (int branch = 0; branch < numChildren(); branch++) {
-                Node child = getChild(branch);
-                if (child != null) {
-                    StringUtils.appendIndented(out, indent, "if ");
-                    out.append(this.splitTest.describeConditionForBranch(branch,
-                            ht.getModelContext()));
-                    out.append(": ");
-                    StringUtils.appendNewline(out);
-                    child.describeSubtree(ht, out, indent + 2);
-                }
-            }
-        }
-
-        @Override
-        public int subtreeDepth() {
-            int maxChildDepth = 0;
-            for (Node child : this.children) {
-                if (child != null) {
-                    int depth = child.subtreeDepth();
-                    if (depth > maxChildDepth) {
-                        maxChildDepth = depth;
-                    }
-                }
-            }
-            return maxChildDepth + 1;
-        }
-    }
-
-    public static abstract class LearningNode extends Node {
-
-        private static final long serialVersionUID = 1L;
-
-        public LearningNode(double[] initialClassObservations) {
-            super(initialClassObservations);
-        }
-
-        public abstract void learnFromInstance(Instance inst, MultilabelHoeffdingTree ht);
-    }
-
-    public static class InactiveLearningNode extends LearningNode {
-
-        private static final long serialVersionUID = 1L;
-
-        public InactiveLearningNode(double[] initialClassObservations) {
-            super(initialClassObservations);
-        }
-
-        @Override
-        public void learnFromInstance(Instance inst, MultilabelHoeffdingTree ht) {
-            this.observedClassDistribution.addToValue((int) inst.classValue(),
-                    inst.weight());
-        }
-    }
-
-    public static class ActiveLearningNode extends LearningNode {
-
-        private static final long serialVersionUID = 1L;
-
-        protected double weightSeenAtLastSplitEvaluation;
-
-        protected AutoExpandVector<AttributeClassObserver> attributeObservers = new AutoExpandVector<AttributeClassObserver>();
-        
-        protected boolean isInitialized;
-
-        public ActiveLearningNode(double[] initialClassObservations) {
-            super(initialClassObservations);
-            this.weightSeenAtLastSplitEvaluation = getWeightSeen();
-            this.isInitialized = false;
-        }
-
-        @Override
-        public int calcByteSize() {
-            return super.calcByteSize()
-                    + (int) (SizeOf.fullSizeOf(this.attributeObservers));
-        }
-
-        @Override
-        public void learnFromInstance(Instance inst, MultilabelHoeffdingTree ht) {
-            if (this.isInitialized == false) {
-                this.attributeObservers = new AutoExpandVector<AttributeClassObserver>(inst.numAttributes());
-                this.isInitialized = true;
-            }
-            this.observedClassDistribution.addToValue((int) inst.classValue(),
-                    inst.weight());
-            for (int i = 0; i < inst.numAttributes() - 1; i++) {
-                int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
-                AttributeClassObserver obs = this.attributeObservers.get(i);
-                if (obs == null) {
-                    obs = inst.attribute(instAttIndex).isNominal() ? ht.newNominalClassObserver() : ht.newNumericClassObserver();
-                    this.attributeObservers.set(i, obs);
-                }
-                obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
-            }
-        }
-
-        public double getWeightSeen() {
-            return this.observedClassDistribution.sumOfValues();
-        }
-
-        public double getWeightSeenAtLastSplitEvaluation() {
-            return this.weightSeenAtLastSplitEvaluation;
-        }
-
-        public void setWeightSeenAtLastSplitEvaluation(double weight) {
-            this.weightSeenAtLastSplitEvaluation = weight;
-        }
-
-        public AttributeSplitSuggestion[] getBestSplitSuggestions(
-                SplitCriterion criterion, MultilabelHoeffdingTree ht) {
-            List<AttributeSplitSuggestion> bestSuggestions = new LinkedList<AttributeSplitSuggestion>();
-            double[] preSplitDist = this.observedClassDistribution.getArrayCopy();
-            if (!ht.noPrePruneOption.isSet()) {
-                // add null split as an option
-                bestSuggestions.add(new AttributeSplitSuggestion(null,
-                        new double[0][], criterion.getMeritOfSplit(
-                        preSplitDist,
-                        new double[][]{preSplitDist})));
-            }
-            for (int i = 0; i < this.attributeObservers.size(); i++) {
-                AttributeClassObserver obs = this.attributeObservers.get(i);
-                if (obs != null) {
-                    AttributeSplitSuggestion bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion,
-                            preSplitDist, i, ht.binarySplitsOption.isSet());
-                    if (bestSuggestion != null) {
-                        bestSuggestions.add(bestSuggestion);
-                    }
-                }
-            }
-            return bestSuggestions.toArray(new AttributeSplitSuggestion[bestSuggestions.size()]);
-        }
-
-        public void disableAttribute(int attIndex) {
-            this.attributeObservers.set(attIndex,
-                    new NullAttributeClassObserver());
-        }
-    }
-
-    public class LearningNodeClassifier extends ActiveLearningNode {
-
-        protected Classifier classifier;
-
-        private static final long serialVersionUID = 1L;
-
-        public LearningNodeClassifier(double[] initialClassObservations) {
-            super(initialClassObservations);
-        }
-
-        public LearningNodeClassifier(double[] initialClassObservations, Classifier cl, HoeffdingTreeClassifLeaves ht) {
-            super(initialClassObservations);
-            //public void LearningNodeClassifier1(double[] initialClassObservations, Classifier cl, HoeffdingTreeClassifLeaves ht ) {
-
-            if (cl == null) {
-                this.classifier = (Classifier) getPreparedClassOption(ht.learnerOption);
-            } else {
-                this.classifier = (Classifier) cl.copy();
-            }
-        }
-	
-        @Override
-        public double[] getClassVotes(Instance inst, MultilabelHoeffdingTree ht) {
-            if (getWeightSeen() >= ht.nbThresholdOption.getValue()) {
-                return this.classifier.getPredictionForInstance(inst).asDoubleArray();
-            }
-            return super.getClassVotes(inst, ht);
-        }
-
-        @Override
-        public void disableAttribute(int attIndex) {
-            // should not disable poor atts - they are used in NB calc
-        }
-
-        @Override
-        public void learnFromInstance(Instance inst, MultilabelHoeffdingTree ht) {
-            this.classifier.trainOnInstance(inst);
-            super.learnFromInstance(inst, ht);
-        }
-
-        public Classifier getClassifier() {
-            return this.classifier;
-        }
-    }
-
-	public static class MultilabelInactiveLearningNode extends InactiveLearningNode {
-
-		private static final long serialVersionUID = 1L;
-
-		public MultilabelInactiveLearningNode(double[] initialClassObservations) {
-			super(initialClassObservations);
-		}
-
-		@Override
-		public void learnFromInstance(Instance inst, MultilabelHoeffdingTree ht) {
-			List<Integer> labels = getRelevantLabels(inst);
-			for (int l : labels){
-				this.observedClassDistribution.addToValue( l, inst.weight());
-			}
-		}
-	}
-
-	public class MultilabelLearningNodeClassifier extends LearningNodeClassifier {
-		// It uses classifier at nodes, and to be able to train with several class values
-
-		private static final long serialVersionUID = 1L;
-
-		public MultilabelLearningNodeClassifier(double[] initialClassObservations, Classifier cl, MultilabelHoeffdingTree ht) {
-			super(initialClassObservations);
-            this.observedClassDistribution = new DoubleVector(initialClassObservations);
-            this.weightSeenAtLastSplitEvaluation = getWeightSeen();
-            this.isInitialized = false;
-            
-            if (cl== null) {
-				this.classifier = (Classifier) ((Classifier) getPreparedClassOption(ht.learnerOption)).copy();
-				this.classifier.resetLearning();
-
-				InstancesHeader raw_header = ht.getModelContext();
-				this.classifier.setModelContext(raw_header);
-			}
-			else{
-				this.classifier = (Classifier) cl.copy();
-			}
-		}
-
-		public Prediction getPrediction(Instance inst, MultilabelHoeffdingTree ht) {
-
-			return this.classifier.getPredictionForInstance(inst); 			
-		}
-
-		public Prediction getPredictionForInstance(Instance inst, MultilabelHoeffdingTree ht) {
-
-			return this.classifier.getPredictionForInstance(inst);
-		}
-
-		@Override
-		public void disableAttribute(int attIndex) {
-			// should not disable poor atts - they are used in NB calc
-		}
-		
-		public Classifier getClassifier() {
-			return this.classifier;
-		}
-
-	    @Override
-		public void learnFromInstance(Instance inst, MultilabelHoeffdingTree ht) {
-
-			//It uses different class values, not only one
-			this.classifier.trainOnInstance(inst);
-			List<Integer> labels = ht.getRelevantLabels(inst);
-			for (int l : labels){
-				this.observedClassDistribution.addToValue( l, inst.weight());
-			}
-
-			for (int i = 0; i < inst.numInputAttributes(); i++) {
-				int instAttIndex = i;
-				AttributeClassObserver obs = this.attributeObservers.get(instAttIndex); //i
-				if (obs == null) {
-					obs = inst.inputAttribute(i).isNominal() ? ht.newNominalClassObserver() : ht.newNumericClassObserver();
-					this.attributeObservers.set(i, obs);
-				}
-				for (int l : labels){
-					obs.observeAttributeClass(inst.valueInputAttribute(i), l, inst.weight());
-				}
-			}
-		}
-
-		public void describeSubtree(MultilabelHoeffdingTree ht, StringBuilder out,
-									int indent) {
-			StringUtils.appendIndented(out, indent, "Leaf ");
-			out.append(" = ");
-			out.append(" weights: ");
-			this.observedClassDistribution.getSingleLineDescription(out,
-					this.observedClassDistribution.numValues());
-			StringUtils.appendNewline(out);
-		}
-	}
-
-    
-    protected Node treeRoot;
-    
-    protected int decisionNodeCount;
-
-    protected int activeLeafNodeCount;
-
-    protected int inactiveLeafNodeCount;
-
-    protected double inactiveLeafByteSizeEstimate;
-
-    protected double activeLeafByteSizeEstimate;
-
-    protected double byteSizeEstimateOverheadFraction;
-
-    protected boolean growthAllowed;
-    
-	protected LearningNode newLearningNode(double[] initialClassObservations) {
-		// Create new Learning Node with a null classifier
-		return new MultilabelLearningNodeClassifier(initialClassObservations,null,this);
-	}
-
-	//@Override
-	protected LearningNode newLearningNode(double[] initialClassObservations, Classifier cl) {
-		// Create new Learning Node
-		return new MultilabelLearningNodeClassifier(initialClassObservations,cl,this);
-	}
-
-
-	protected void deactivateLearningNode(ActiveLearningNode toDeactivate, SplitNode parent, int parentBranch) {
-		//It uses MultilabelInactiveLearningNode since there are several class values
-		Node newLeaf = new MultilabelInactiveLearningNode(toDeactivate
-				.getObservedClassDistribution());
-		if (parent == null) {
-			this.treeRoot = newLeaf;
-		} else {
-			parent.setChild(parentBranch, newLeaf);
-		}
-		this.activeLeafNodeCount--;
-		this.inactiveLeafNodeCount++;
-	}
-
-
-	@Override
-	public Prediction getPredictionForInstance(Example<Instance> example) {
-		return getPredictionForInstance((StructuredInstance)example.getData());
-	}
-
-	public Prediction getPredictionForInstance(StructuredInstance inst) {
-		return getPredictionForInstance((Instance) inst);
-	}
-
-	@Override
-	public Prediction getPredictionForInstance(Instance inst){
-
-		if (this.treeRoot != null) {
-			FoundNode foundNode = this.treeRoot.filterInstanceToLeaf(inst, null, -1);
-			Node leafNode = (MultilabelLearningNodeClassifier) foundNode.node;
-			MultilabelLearningNodeClassifier multilabelLeafNode = (MultilabelLearningNodeClassifier) leafNode;
-			if (leafNode == null) {
-				leafNode = foundNode.parent;
-			}
-			return multilabelLeafNode.getPrediction(inst, this);
-		}
-		else {
-			System.err.println("[WARNING] Root Node == Null !!!!!!");
-		}
-
-		// Return empty array (this should only happen once! -- before we build the root node).
-		return null;
-	}
-
-	@Override
-	public void trainOnInstance(Instance inst) {
-		boolean isTraining = (inst.weight() > 0.0);
-		if (isTraining) {
-			this.trainingWeightSeenByModel += inst.weight();
-			trainOnInstanceImpl((StructuredInstance) inst);
-		}
-	}
-
-        
-	public static List<Integer> getRelevantLabels(Instance x) {
-		List<Integer> classValues = new LinkedList<Integer>();
-		//get all class attributes
-		for (int j = 0; j < x.numOutputAttributes(); j++) {
-			if (x.classValue(j) > 0.0) {
-				classValues.add(j);
-			}
-		}
-		return classValues;
-	}
-	
-    protected AttributeClassObserver newNominalClassObserver() {
-        AttributeClassObserver nominalClassObserver = (AttributeClassObserver) getPreparedClassOption(this.nominalEstimatorOption);
-        return (AttributeClassObserver) nominalClassObserver.copy();
-    }
-
-    protected AttributeClassObserver newNumericClassObserver() {
-        AttributeClassObserver numericClassObserver = (AttributeClassObserver) getPreparedClassOption(this.numericEstimatorOption);
-        return (AttributeClassObserver) numericClassObserver.copy();
-    }
-
-	@Override
-	public boolean isRandomizable() {
-		// TODO Auto-generated method stub
-		return false;
-	}
-	
-    public void estimateModelByteSizes() {
-        FoundNode[] learningNodes = findLearningNodes();
-        long totalActiveSize = 0;
-        long totalInactiveSize = 0;
-        for (FoundNode foundNode : learningNodes) {
-            if (foundNode.node instanceof ActiveLearningNode) {
-                totalActiveSize += SizeOf.fullSizeOf(foundNode.node);
-            } else {
-                totalInactiveSize += SizeOf.fullSizeOf(foundNode.node);
-            }
-        }
-        if (totalActiveSize > 0) {
-            this.activeLeafByteSizeEstimate = (double) totalActiveSize
-                    / this.activeLeafNodeCount;
-        }
-        if (totalInactiveSize > 0) {
-            this.inactiveLeafByteSizeEstimate = (double) totalInactiveSize
-                    / this.inactiveLeafNodeCount;
-        }
-        long actualModelSize = this.measureByteSize();
-        double estimatedModelSize = (this.activeLeafNodeCount
-                * this.activeLeafByteSizeEstimate + this.inactiveLeafNodeCount
-                * this.inactiveLeafByteSizeEstimate);
-        this.byteSizeEstimateOverheadFraction = actualModelSize
-                / estimatedModelSize;
-        if (actualModelSize > this.maxByteSizeOption.getValue()) {
-            enforceTrackerLimit();
-        }
-    }
-
-    public void deactivateAllLeaves() {
-        FoundNode[] learningNodes = findLearningNodes();
-        for (int i = 0; i < learningNodes.length; i++) {
-            if (learningNodes[i].node instanceof ActiveLearningNode) {
-                deactivateLearningNode(
-                        (ActiveLearningNode) learningNodes[i].node,
-                        learningNodes[i].parent, learningNodes[i].parentBranch);
-            }
-        }
-    }
-
-    public void enforceTrackerLimit() {
-        if ((this.inactiveLeafNodeCount > 0)
-                || ((this.activeLeafNodeCount * this.activeLeafByteSizeEstimate + this.inactiveLeafNodeCount
-                * this.inactiveLeafByteSizeEstimate)
-                * this.byteSizeEstimateOverheadFraction > this.maxByteSizeOption.getValue())) {
-            if (this.stopMemManagementOption.isSet()) {
-                this.growthAllowed = false;
-                return;
-            }
-            FoundNode[] learningNodes = findLearningNodes();
-            Arrays.sort(learningNodes, new Comparator<FoundNode>() {
-
-                @Override
-                public int compare(FoundNode fn1, FoundNode fn2) {
-                    return Double.compare(fn1.node.calculatePromise(), fn2.node.calculatePromise());
-                }
-            });
-            int maxActive = 0;
-            while (maxActive < learningNodes.length) {
-                maxActive++;
-                if ((maxActive * this.activeLeafByteSizeEstimate + (learningNodes.length - maxActive)
-                        * this.inactiveLeafByteSizeEstimate)
-                        * this.byteSizeEstimateOverheadFraction > this.maxByteSizeOption.getValue()) {
-                    maxActive--;
-                    break;
-                }
-            }
-            int cutoff = learningNodes.length - maxActive;
-            for (int i = 0; i < cutoff; i++) {
-                if (learningNodes[i].node instanceof ActiveLearningNode) {
-                    deactivateLearningNode(
-                            (ActiveLearningNode) learningNodes[i].node,
-                            learningNodes[i].parent,
-                            learningNodes[i].parentBranch);
-                }
-            }
-            for (int i = cutoff; i < learningNodes.length; i++) {
-                if (learningNodes[i].node instanceof InactiveLearningNode) {
-                    activateLearningNode(
-                            (InactiveLearningNode) learningNodes[i].node,
-                            learningNodes[i].parent,
-                            learningNodes[i].parentBranch);
-                }
-            }
-        }
-    }
-
-    protected void activateLearningNode(InactiveLearningNode toActivate,
-            SplitNode parent, int parentBranch) {
-        Node newLeaf = newLearningNode(toActivate.getObservedClassDistribution());
-        if (parent == null) {
-            this.treeRoot = newLeaf;
-        } else {
-            parent.setChild(parentBranch, newLeaf);
-        }
-        this.activeLeafNodeCount++;
-        this.inactiveLeafNodeCount--;
-    }
-
-    protected FoundNode[] findLearningNodes() {
-        List<FoundNode> foundList = new LinkedList<FoundNode>();
-        findLearningNodes(this.treeRoot, null, -1, foundList);
-        return foundList.toArray(new FoundNode[foundList.size()]);
-    }
-
-    protected void findLearningNodes(Node node, SplitNode parent,
-            int parentBranch, List<FoundNode> found) {
-        if (node != null) {
-            if (node instanceof LearningNode) {
-                found.add(new FoundNode(node, parent, parentBranch));
-            }
-            if (node instanceof SplitNode) {
-                SplitNode splitNode = (SplitNode) node;
-                for (int i = 0; i < splitNode.numChildren(); i++) {
-                    findLearningNodes(splitNode.getChild(i), splitNode, i,
-                            found);
-                }
-            }
-        }
-    }
-
-    public void trainOnInstanceImpl(Instance inst) {
-        if (this.treeRoot == null) {
-            this.treeRoot = newLearningNode();
-            this.activeLeafNodeCount = 1;
-        }
-        FoundNode foundNode = this.treeRoot.filterInstanceToLeaf(inst, null, -1);
-        Node leafNode = foundNode.node;
-        if (leafNode == null) {
-            leafNode = newLearningNode();
-            foundNode.parent.setChild(foundNode.parentBranch, leafNode);
-            this.activeLeafNodeCount++;
-        }
-        if (leafNode instanceof LearningNode) {
-            LearningNode learningNode = (LearningNode) leafNode;
-            learningNode.learnFromInstance(inst, this);
-            if (this.growthAllowed
-                    && (learningNode instanceof ActiveLearningNode)) {
-                ActiveLearningNode activeLearningNode = (ActiveLearningNode) learningNode;
-                double weightSeen = activeLearningNode.getWeightSeen();
-                if (weightSeen
-                        - activeLearningNode.getWeightSeenAtLastSplitEvaluation() >= this.gracePeriodOption.getValue()) {
-                    attemptToSplit(activeLearningNode, foundNode.parent,
-                            foundNode.parentBranch);
-                    activeLearningNode.setWeightSeenAtLastSplitEvaluation(weightSeen);
-                }
-            }
-        }
-        if (this.trainingWeightSeenByModel
-                % this.memoryEstimatePeriodOption.getValue() == 0) {
-            estimateModelByteSizes();
-        }
-    }
-
-    public void resetLearningImpl() {
-        this.treeRoot = null;
-        this.decisionNodeCount = 0;
-        this.activeLeafNodeCount = 0;
-        this.inactiveLeafNodeCount = 0;
-        this.inactiveLeafByteSizeEstimate = 0.0;
-        this.activeLeafByteSizeEstimate = 0.0;
-        this.byteSizeEstimateOverheadFraction = 1.0;
-        this.growthAllowed = true;
-        if (this.leafpredictionOption.getChosenIndex()>0) { 
-            this.removePoorAttsOption = null;
-        }
-    }
-
-    protected Measurement[] getModelMeasurementsImpl() {
-        return new Measurement[]{
-                    new Measurement("tree size (nodes)", this.decisionNodeCount
-                    + this.activeLeafNodeCount + this.inactiveLeafNodeCount),
-                    new Measurement("tree size (leaves)", this.activeLeafNodeCount
-                    + this.inactiveLeafNodeCount),
-                    new Measurement("active learning leaves",
-                    this.activeLeafNodeCount),
-                    new Measurement("tree depth", measureTreeDepth()),
-                    new Measurement("active leaf byte size estimate",
-                    this.activeLeafByteSizeEstimate),
-                    new Measurement("inactive leaf byte size estimate",
-                    this.inactiveLeafByteSizeEstimate),
-                    new Measurement("byte size estimate overhead",
-                    this.byteSizeEstimateOverheadFraction)};
-    }
-    
-    public int measureTreeDepth() {
-        if (this.treeRoot != null) {
-            return this.treeRoot.subtreeDepth();
-        }
-        return 0;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        this.treeRoot.describeSubtree(this, out, indent);
-    }
-    
-    protected void attemptToSplit(ActiveLearningNode node, SplitNode parent,
-            int parentIndex) {
-        if (!node.observedClassDistributionIsPure()) {
-            SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
-            AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion, this);
-            Arrays.sort(bestSplitSuggestions);
-            boolean shouldSplit = false;
-            if (bestSplitSuggestions.length < 2) {
-                shouldSplit = bestSplitSuggestions.length > 0;
-            } else {
-                double hoeffdingBound = computeHoeffdingBound(splitCriterion.getRangeOfMerit(node.getObservedClassDistribution()),
-                        this.splitConfidenceOption.getValue(), node.getWeightSeen());
-                AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-                AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
-                if ((bestSuggestion.merit - secondBestSuggestion.merit > hoeffdingBound)
-                        || (hoeffdingBound < this.tieThresholdOption.getValue())) {
-                    shouldSplit = true;
-                }
-                // }
-                if ((this.removePoorAttsOption != null)
-                        && this.removePoorAttsOption.isSet()) {
-                    Set<Integer> poorAtts = new HashSet<Integer>();
-                    // scan 1 - add any poor to set
-                    for (int i = 0; i < bestSplitSuggestions.length; i++) {
-                        if (bestSplitSuggestions[i].splitTest != null) {
-                            int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
-                            if (splitAtts.length == 1) {
-                                if (bestSuggestion.merit
-                                        - bestSplitSuggestions[i].merit > hoeffdingBound) {
-                                    poorAtts.add(new Integer(splitAtts[0]));
-                                }
-                            }
-                        }
-                    }
-                    // scan 2 - remove good ones from set
-                    for (int i = 0; i < bestSplitSuggestions.length; i++) {
-                        if (bestSplitSuggestions[i].splitTest != null) {
-                            int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
-                            if (splitAtts.length == 1) {
-                                if (bestSuggestion.merit
-                                        - bestSplitSuggestions[i].merit < hoeffdingBound) {
-                                    poorAtts.remove(new Integer(splitAtts[0]));
-                                }
-                            }
-                        }
-                    }
-                    for (int poorAtt : poorAtts) {
-                        node.disableAttribute(poorAtt);
-                    }
-                }
-            }
-            if (shouldSplit) {
-                AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-                if (splitDecision.splitTest == null) {
-                    // preprune - null wins
-                    deactivateLearningNode(node, parent, parentIndex);
-                } else {
-                    SplitNode newSplit = newSplitNode(splitDecision.splitTest,
-                            node.getObservedClassDistribution(),splitDecision.numSplits() );
-                    for (int i = 0; i < splitDecision.numSplits(); i++) {
-                        Node newChild = newLearningNode(splitDecision.resultingClassDistributionFromSplit(i));
-                        newSplit.setChild(i, newChild);
-                    }
-                    this.activeLeafNodeCount--;
-                    this.decisionNodeCount++;
-                    this.activeLeafNodeCount += splitDecision.numSplits();
-                    if (parent == null) {
-                        this.treeRoot = newSplit;
-                    } else {
-                        parent.setChild(parentIndex, newSplit);
-                    }
-                }
-                // manage memory
-                enforceTrackerLimit();
-            }
-        }
-    }
-    //Procedure added for Hoeffding Adaptive Trees (ADWIN)
-    protected SplitNode newSplitNode(InstanceConditionalTest splitTest,
-            double[] classObservations, int size) {
-        return new SplitNode(splitTest, classObservations, size);
-    }
-
-    protected LearningNode newLearningNode() {
-        return newLearningNode(new double[0]);
-    }
-
-    public static double computeHoeffdingBound(double range, double confidence,
-            double n) {
-        return Math.sqrt(((range * range) * Math.log(1.0 / confidence))
-                / (2.0 * n));
-    }
-
-    
-}
diff --git a/moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/AttributeStatisticsObserver.java b/moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/AttributeStatisticsObserver.java
deleted file mode 100644
index 753cf7684..000000000
--- a/moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/AttributeStatisticsObserver.java
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- *    AttributeClassObserver.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.mlc.core.attributeclassobservers;
-
-import moa.classifiers.mlc.core.splitcriteria.MultiLabelSplitCriterion;
-import moa.classifiers.rules.core.AttributeExpansionSuggestion;
-import moa.core.DoubleVector;
-import moa.options.OptionHandler;
-
-/**
- * Interface for observing the statistics for an attribute.
- * This observer monitors the statistics for a given attribute.
- * Used in AMRulesMultiLabelLearners
- *
- * @author João Duarte (joaomaiaduarte@gmail.com)
- * @version $Revision: 1 $ 
- */
-public interface AttributeStatisticsObserver extends OptionHandler {
-
-    /**
-     * Updates statistics of this observer given an attribute value, the index of the statistic
-     * and the weight of the instance observed
-     *
-     * @param inputAttributeValue the value for the attribute attribute
-     * @param statistics numOutputs x numStatistics the index of the statistic to store
-     */
-    public void observeAttribute(double inputAttributeValue, DoubleVector [] statistics);
-
-
-
-    /**
-     * Gets the best split suggestion given a criterion and a class distribution
-     *
-     * @param criterion the split criterion to use
-     * @param preSplitDist the class distribution before the split
-     * @param attIndex the input attribute index
-     * @return suggestion of best attribute split
-     */
-    public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(
-            MultiLabelSplitCriterion criterion, DoubleVector [] preSplitStatistics, int inputAttributeIndex);
-    
-}
diff --git a/moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/MultiLabelNominalAttributeObserver.java b/moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/MultiLabelNominalAttributeObserver.java
deleted file mode 100644
index 1eb28fcfb..000000000
--- a/moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/MultiLabelNominalAttributeObserver.java
+++ /dev/null
@@ -1,109 +0,0 @@
-package moa.classifiers.mlc.core.attributeclassobservers;
-
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Map.Entry;
-
-import com.github.javacliparser.FlagOption;
-
-import moa.classifiers.mlc.core.splitcriteria.MultiLabelSplitCriterion;
-import moa.classifiers.rules.core.AttributeExpansionSuggestion;
-import moa.classifiers.rules.core.NominalRulePredicate;
-import moa.classifiers.rules.core.Utils;
-import moa.core.DoubleVector;
-import moa.core.ObjectRepository;
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
-public class MultiLabelNominalAttributeObserver extends AbstractOptionHandler
-		implements NominalStatisticsObserver {
-
-
-
-	/**
-	 * 
-	 */
-	protected FlagOption addUndeclaredValuesOption = new FlagOption("addUndeclaredValues", 'a',
-			"Add to the domain values not declared? If false, the value is not used.");
-	protected HashMap<Integer, DoubleVector[]> statisticsByNominalValue;
-	
-	
-	private static final long serialVersionUID = 1L;
-
-	@Override
-	public void observeAttribute(double inputAttributeValue,
-			DoubleVector[] observedStatistics) {
-		if (statisticsByNominalValue==null){
-			statisticsByNominalValue=new HashMap<Integer, DoubleVector[]>();
-		}
-		DoubleVector[] current=statisticsByNominalValue.get((int)inputAttributeValue);
-		if(current==null)
-			current=copyOfStatistics(observedStatistics);
-		else
-			addStatistics(current,observedStatistics);
-		
-		statisticsByNominalValue.put((int)inputAttributeValue, current);
-
-	}
-
-
-	@Override
-	public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(
-			MultiLabelSplitCriterion criterion, DoubleVector[] preSplitStatistics,
-			int inputAttributeIndex) {
-		
-		double bestSuggestionMerit=Double.MIN_VALUE;
-		AttributeExpansionSuggestion bestSuggestiong=null;
-		
-		Iterator<Entry<Integer, DoubleVector[]>> it = statisticsByNominalValue.entrySet().iterator();
-	    while (it.hasNext()) {
-	    	Entry<Integer, DoubleVector[]> pair = it.next();
-	    	int splitValue=pair.getKey();
-	    	DoubleVector[] statistics=pair.getValue();
-	    	
-	    	DoubleVector[][] resultingStatistics=new DoubleVector [statistics.length][2];
-			for (int i=0; i<statistics.length; i++){
-				resultingStatistics[i]= new DoubleVector[2];
-				resultingStatistics[i][0]=statistics[i];
-				resultingStatistics[i][1]=new DoubleVector(preSplitStatistics[i]);
-				resultingStatistics[i][1].subtractValues(statistics[i]);
-			}
-			
-	    	double merit=criterion.getMeritOfSplit(preSplitStatistics, resultingStatistics);
-	    	if(merit>bestSuggestionMerit){
-	    		bestSuggestionMerit=merit;
-	    		bestSuggestiong=new AttributeExpansionSuggestion(new NominalRulePredicate(inputAttributeIndex,splitValue,true), Utils.copy(resultingStatistics), merit);
-	    	}
-	    }
-
-		return bestSuggestiong;
-	}
-
-
-	private void addStatistics(DoubleVector[] current,
-			DoubleVector[] observedStatistics) {
-		for(int i=0;i<current.length;i++){
-			current[i].addValues(observedStatistics[i]);
-		}
-	}
-
-	private DoubleVector[] copyOfStatistics(DoubleVector[] statistics) {
-		DoubleVector[] copy= new DoubleVector[statistics.length];
-		for(int i=0;i<statistics.length;i++){
-			copy[i]= new DoubleVector(statistics[i]);
-		}
-		return copy;
-	}
-
-	@Override
-	public void getDescription(StringBuilder sb, int indent) {
-
-	}
-
-	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
-
-	}
-
-}
diff --git a/moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/ICVarianceReduction.java b/moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/ICVarianceReduction.java
deleted file mode 100644
index b8b85620e..000000000
--- a/moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/ICVarianceReduction.java
+++ /dev/null
@@ -1,114 +0,0 @@
-package moa.classifiers.mlc.core.splitcriteria;
-
-import moa.core.DoubleVector;
-import moa.core.ObjectRepository;
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
-
-
-public class ICVarianceReduction extends AbstractOptionHandler implements MultiLabelSplitCriterion {
-
-	/**
-	 * 
-	 */
-	private static final long serialVersionUID = 1L;
-
-	@Override
-	public double getMeritOfSplit(DoubleVector[] preSplitDist, DoubleVector[][] postSplitDists) {
-		double error=0;
-		int numOutputs=preSplitDist.length;
-		for (int i=0; i<numOutputs; i++)
-			error+=getMeritOfSplitForOutput(preSplitDist,postSplitDists,i);
-		return error/numOutputs;
-	}
-	
-	public double[] getBranchSplitVarianceOutput(DoubleVector[] postSplitDists) {
-		double[] variances = new double[postSplitDists.length];
-		for(int i = 0; i < postSplitDists.length; i++)
-			variances[i]=computeVariance(postSplitDists[i]);
-		return variances;
-
-	}
-	
-	public double computeVariance(double n, double sum, double squares) {
-		if (n > 1) {
-			return (squares - sum * sum / n) / (n - 1);
-		}
-		return 0;
-	}
-	
-	public double computeVariance(DoubleVector v) {
-		return computeVariance(v.getValue(0), v.getValue(1), v.getValue(2));
-	}
-
-	@Override
-	public double [] getBranchesSplitMerits(DoubleVector[][] postSplitDists){
-		int numOutputs=postSplitDists.length;
-		int numBranches=postSplitDists[0].length;
-		double [] merits=new double[numBranches];
-			for(int j=0; j<numOutputs;j++)
-			{
-				double [] branchMeritsOutput=getBranchSplitVarianceOutput(postSplitDists[j]);
-				
-				for (int i=0; i<numBranches;i++){
-					if (postSplitDists[j][i].getValue(0)>0)
-						merits[i]-=branchMeritsOutput[i];
-					else
-						merits[i]=Double.MIN_VALUE;
-				}
-			}
-		return merits;
-	}
-	
-	protected double getMeritOfSplitForOutput(DoubleVector[] preSplitDist, DoubleVector[][] postSplitDists, int outputAttributeIndex){
-		return getMeritOfSplitForAttribute(preSplitDist[outputAttributeIndex],postSplitDists[outputAttributeIndex]);
-	}
-
-	protected double getMeritOfSplitForAttribute(DoubleVector preSplitDist, DoubleVector[] postSplitDists) {
-		double merit=0;
-		//count number of branches with weightSeen higher than threshold
-		int count = 0; 
-		for(int i = 0; i < postSplitDists.length; i++)
-			if(postSplitDists[i].getValue(0) >= 0.05 * preSplitDist.getValue(0))
-				count = count +1;
-		//Consider split if all branches have required weight seen
-		if(count == postSplitDists.length){
-			double varPreSplit=computeVariance(preSplitDist);
-			double sumVarPostSplit=0;
-			double weightTotal=0;
-			for (int i=0; i<postSplitDists.length;i++){
-				weightTotal+=postSplitDists[i].getValue(0);
-			}
-			double [] variances=getBranchSplitVarianceOutput(postSplitDists);
-			for(int i = 0; i < variances.length; i++)
-				if(postSplitDists[i].getValue(0) > 0)
-					sumVarPostSplit += (postSplitDists[i].getValue(0)/weightTotal*variances[i]);  //weight variance
-			if (sumVarPostSplit == 0 && varPreSplit == 0)
-				merit = 0;
-			else
-				merit= 1 - sumVarPostSplit / varPreSplit;
-		}
-		/*if(merit<0 || merit>1)
-			System.out.println("out of range");*/
-		return merit;
-	}
-
-	public double getRangeOfMerit(DoubleVector [] preSplitDist) {
-		return 1;
-	}
-
-
-
-	@Override
-	public void getDescription(StringBuilder sb, int indent) {
-
-	}
-
-	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {		
-	}
-
-
-}
diff --git a/moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/MultiLabelSplitCriterion.java b/moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/MultiLabelSplitCriterion.java
deleted file mode 100644
index bc6bc9254..000000000
--- a/moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/MultiLabelSplitCriterion.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package moa.classifiers.mlc.core.splitcriteria;
-
-
-import moa.core.DoubleVector;
-import moa.options.OptionHandler;
-
-public interface MultiLabelSplitCriterion extends OptionHandler{
-		
-	double getMeritOfSplit(DoubleVector[] preSplitDist,DoubleVector[][] postSplitDists);
-	
-	double getRangeOfMerit(DoubleVector [] preSplitDist);
-
-	double [] getBranchesSplitMerits(DoubleVector[][] postSplitDists);
-	
-
-}
diff --git a/moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/PCTWeightedICVarianceReduction.java b/moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/PCTWeightedICVarianceReduction.java
deleted file mode 100644
index 0f74bb7fb..000000000
--- a/moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/PCTWeightedICVarianceReduction.java
+++ /dev/null
@@ -1,84 +0,0 @@
-package moa.classifiers.mlc.core.splitcriteria;
-
-import moa.core.DoubleVector;
-
-public class PCTWeightedICVarianceReduction extends WeightedICVarianceReduction {
-
-	private static final long serialVersionUID = 1L;
-
-	public DoubleVector inputWeights;
-	
-	public double targetInputTradeoff; // \in [0, 1]
-	
-	public PCTWeightedICVarianceReduction(DoubleVector targetWeights, DoubleVector inputWeights, double targetInputTradeoff) {
-		super(targetWeights);
-		this.inputWeights = inputWeights;
-		this.targetInputTradeoff = targetInputTradeoff;
-	}
-	
-	public double getMeritOfSplit(DoubleVector[] preSplitTargetDist, DoubleVector[][] postSplitTargetDists, DoubleVector[] preSplitInputDist, DoubleVector[][] postSplitInputDists) {
-		double targetError = 0;
-		double inputError = 0;
-		int numTargets=preSplitTargetDist.length;
-		int numInputs=preSplitInputDist.length;
-		for (int i=0; i<numTargets; i++) {
-			if (postSplitTargetDists[i][0].getValue(0) == 0 || postSplitTargetDists[i][1].getValue(0) == 0)
-				// If the split would result in a leaf without labeled instances, discard it
-				return Double.NaN;
-			targetError += weights.getValue(i) * getMeritOfSplitForAttribute(preSplitTargetDist[i], postSplitTargetDists[i]);
-		}
-		for (int i=0; i<numInputs; i++)
-			inputError += inputWeights.getValue(i) * getMeritOfSplitForAttribute(preSplitInputDist[i], postSplitInputDists[i]);
-
-		return targetInputTradeoff * targetError / weights.sumOfValues() + (1 - targetInputTradeoff) * inputError / inputWeights.sumOfValues();
-	}
-
-	protected double getMeritOfSplitForAttribute(DoubleVector preSplitDist, DoubleVector[] postSplitDists) {
-		double merit=0;
-		//count number of branches with weightSeen higher than threshold
-		int count = 0; 
-		for(int i = 0; i < postSplitDists.length; i++)
-			if(postSplitDists[i].getValue(0) >= 0.05*preSplitDist.getValue(0))
-				count = count +1;
-		//Consider split if all branches have required weight seen
-		if(count == postSplitDists.length){
-			double varPreSplit = computeVariance(preSplitDist);
-			double sumVarPostSplit=0;
-			double weightTotal=0;
-			for (int i=0; i<postSplitDists.length;i++){
-				weightTotal+=postSplitDists[i].getValue(0);
-			}
-			double [] variances=getBranchSplitVarianceOutput(postSplitDists);
-			for(int i = 0; i < variances.length; i++)
-				if(postSplitDists[i].getValue(0)>0)
-					sumVarPostSplit += (postSplitDists[i].getValue(0)/weightTotal*variances[i]);  //weight variance
-			if (varPreSplit > 0.0)
-				merit = 1 - sumVarPostSplit / varPreSplit;
-			else
-				merit = 0.0;
-		}
-		/*if(merit<0 || merit>1)
-			System.out.println("out of range");*/
-		return merit;
-	}
-	
-
-//	private double computeVariance(double n, double sum, double squares) {
-//		if (n > 1) {
-//			return (squares - sum * sum / n) / (n - 1);
-//		}
-//		return 0;
-//	}
-	
-//	private double computeVariance(DoubleVector v) {
-//		return computeVariance(v.getValue(0), v.getValue(1), v.getValue(2));
-//	}
-	
-	public double getMeritOfSplit(DoubleVector[] preSplitTargetDist, DoubleVector[] preSplitInputDist, DoubleVector[][] postSplitTargetDists, DoubleVector[][] postSplitInputDists) {
-		double error=0;
-		int numOutputs=preSplitTargetDist.length;
-		for (int i=0; i<numOutputs; i++)
-			error += weights.getValue(i) * getMeritOfSplitForOutput(preSplitTargetDist,postSplitTargetDists,i);
-		return error / weights.sumOfValues();
-	}
-}
diff --git a/moa/src/main/java/moa/classifiers/mlc/meta/AdaptiveRandomForestMultiTargetRegression.java b/moa/src/main/java/moa/classifiers/mlc/meta/AdaptiveRandomForestMultiTargetRegression.java
deleted file mode 100644
index 4d64a6f4e..000000000
--- a/moa/src/main/java/moa/classifiers/mlc/meta/AdaptiveRandomForestMultiTargetRegression.java
+++ /dev/null
@@ -1,511 +0,0 @@
-/*
- *    AdaptiveRandomForest.java
- * 
- *    @author Heitor Murilo Gomes (heitor_murilo_gomes at yahoo dot com dot br)
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *
- */
-package moa.classifiers.mlc.meta;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.MultiTargetRegressionPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.AbstractMOAObject;
-import moa.classifiers.AbstractMultiTargetRegressor;
-import moa.classifiers.core.driftdetection.ChangeDetector;
-import moa.classifiers.mtr.trees.ISOUPTree;
-import moa.classifiers.mtr.trees.ISOUPTreeRF;
-// import moa.classifiers.MultiClassClassifier;
-import moa.core.DoubleVector;
-import moa.core.InstanceExample;
-import moa.core.Measurement;
-import moa.core.MiscUtils;
-// import moa.classifiers.trees.ARFHoeffdingTree;
-import moa.evaluation.BasicClassificationPerformanceEvaluator;
-import moa.learners.MultiTargetRegressor;
-import moa.options.ClassOption;
-
-
-/**
- * Adaptive Random Forest
- *
- * <p>Adaptive Random Forest (ARF). The 3 most important aspects of this 
- * ensemble classifier are: (1) inducing diversity through resampling;
- * (2) inducing diversity through randomly selecting subsets of features for 
- * node splits (See moa.classifiers.trees.ARFHoeffdingTree.java); (3) drift 
- * detectors per base tree, which cause selective resets in response to drifts. 
- * It also allows training background trees, which start training if a warning
- * is detected and replace the active tree if the warning escalates to a drift. </p>
- *
- * <p>See details in:<br> Heitor Murilo Gomes, Albert Bifet, Jesse Read, 
- * Jean Paul Barddal, Fabricio Enembreck, Bernhard Pfharinger, Geoff Holmes, 
- * Talel Abdessalem. Adaptive random forests for evolving data stream classification. 
- * In Machine Learning, DOI: 10.1007/s10994-017-5642-8, Springer, 2017.</p>
- *
- * <p>Parameters:</p> <ul>
- * <li>-l : Classifier to train. Must be set to ARFHoeffdingTree</li>
- * <li>-s : The number of trees in the ensemble</li>
- * <li>-o : How the number of features is interpreted (4 options): 
- * "Specified m (integer value)", "sqrt(M)+1", "M-(sqrt(M)+1)"</li>
- * <li>-m : Number of features allowed considered for each split. Negative 
- * values corresponds to M - m</li>
- * <li>-a : The lambda value for bagging (lambda=6 corresponds to levBag)</li>
- * <li>-j : Number of threads to be used for training</li>
- * <li>-x : Change detector for drifts and its parameters</li>
- * <li>-p : Change detector for warnings (start training bkg learner)</li>
- * <li>-w : Should use weighted voting?</li>
- * <li>-u : Should use drift detection? If disabled then bkg learner is also disabled</li>
- * <li>-q : Should use bkg learner? If disabled then reset tree immediately</li>
- * </ul>
- *
- * @author Heitor Murilo Gomes (heitor_murilo_gomes at yahoo dot com dot br)
- * @version $Revision: 1 $
- */
-public class AdaptiveRandomForestMultiTargetRegression extends AbstractMultiTargetRegressor implements MultiTargetRegressor {
-
-    @Override
-    public String getPurposeString() {
-        return "Adaptive Random Forest algorithm for evolving data streams from Gomes et al.";
-    }
-    
-    private static final long serialVersionUID = 1L;
-
-    public ClassOption treeLearnerOption = new ClassOption("treeLearner", 'l',
-            "Random Forest Tree.", MultiTargetRegressor.class,
-            "iSOUPTreeRF");
-
-    public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's',
-        "The number of trees.", 10, 1, Integer.MAX_VALUE);
-    
-    public MultiChoiceOption mFeaturesModeOption = new MultiChoiceOption("mFeaturesMode", 'o', 
-        "Defines how m, defined by mFeaturesPerTreeSize, is interpreted. M represents the total number of features.",
-        new String[]{"Specified m (integer value)", "sqrt(M)+1", "M-(sqrt(M)+1)",
-            "Percentage (M * (m / 100))"},
-        new String[]{"SpecifiedM", "SqrtM1", "MSqrtM1", "Percentage"}, 1);
-    
-    public IntOption mFeaturesPerTreeSizeOption = new IntOption("mFeaturesPerTreeSize", 'm',
-        "Number of features allowed considered for each split. Negative values corresponds to M - m", 2, Integer.MIN_VALUE, Integer.MAX_VALUE);
-    
-    public FloatOption lambdaOption = new FloatOption("lambda", 'a',
-        "The lambda parameter for bagging.", 6.0, 1.0, Float.MAX_VALUE);
-
-    public IntOption numberOfJobsOption = new IntOption("numberOfJobs", 'j',
-        "Total number of concurrent jobs used for processing (-1 = as much as possible, 0 = do not use multithreading)", 1, -1, Integer.MAX_VALUE);
-    
-    public ClassOption driftDetectionMethodOption = new ClassOption("driftDetectionMethod", 'x',
-        "Change detector for drifts and its parameters", ChangeDetector.class, "ADWINChangeDetector -a 1.0E-5");
-
-    public ClassOption warningDetectionMethodOption = new ClassOption("warningDetectionMethod", 'p',
-        "Change detector for warnings (start training bkg learner)", ChangeDetector.class, "ADWINChangeDetector -a 1.0E-4");
-    
-    public FlagOption disableWeightedVote = new FlagOption("disableWeightedVote", 'w', 
-            "Should use weighted voting?");
-    
-    public FlagOption disableDriftDetectionOption = new FlagOption("disableDriftDetection", 'u',
-        "Should use drift detection? If disabled then bkg learner is also disabled");
-
-    public FlagOption disableBackgroundLearnerOption = new FlagOption("disableBackgroundLearner", 'q', 
-        "Should use bkg learner? If disabled then reset tree immediately.");
-    
-    protected static final int FEATURES_M = 0;
-    protected static final int FEATURES_SQRT = 1;
-    protected static final int FEATURES_SQRT_INV = 2;
-    protected static final int FEATURES_PERCENT = 3;
-    
-    protected static final int SINGLE_THREAD = 0;
-	
-    protected ARFBaseLearnerMTR[] ensemble;
-    protected long instancesSeen;
-    protected int subspaceSize;
-    protected BasicClassificationPerformanceEvaluator evaluator;
-
-    private ExecutorService executor;
-    
-    @Override
-    public void resetLearningImpl() {
-        // Reset attributes
-        this.ensemble = null;
-        this.subspaceSize = 0;
-        this.instancesSeen = 0;
-        this.evaluator = new BasicClassificationPerformanceEvaluator();
-        
-        // Multi-threading
-        int numberOfJobs;
-        if(this.numberOfJobsOption.getValue() == -1) 
-            numberOfJobs = Runtime.getRuntime().availableProcessors();
-        else 
-            numberOfJobs = this.numberOfJobsOption.getValue();
-        // SINGLE_THREAD and requesting for only 1 thread are equivalent. 
-        // this.executor will be null and not used...
-        if(numberOfJobs != AdaptiveRandomForestMultiTargetRegression.SINGLE_THREAD && numberOfJobs != 1)
-            this.executor = Executors.newFixedThreadPool(numberOfJobs);
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance instance) {
-        ++this.instancesSeen;
-        if(this.ensemble == null) 
-            initEnsemble(instance);
-        
-        Collection<TrainingRunnable> trainers = new ArrayList<TrainingRunnable>();
-        for (int i = 0 ; i < this.ensemble.length ; i++) {
-            DoubleVector vote = this.ensemble[i].getPredictionForInstance(instance).asDoubleVector();
-            InstanceExample example = new InstanceExample(instance);
-            this.ensemble[i].evaluator.addResult(example, vote.getArrayRef());
-            int k = MiscUtils.poisson(this.lambdaOption.getValue(), this.classifierRandom);
-            if (k > 0) {
-                if(this.executor != null) {
-                    TrainingRunnable trainer = new TrainingRunnable(this.ensemble[i], 
-                        instance, k, this.instancesSeen);
-                    trainers.add(trainer);
-                }
-                else { // SINGLE_THREAD is in-place... 
-                    this.ensemble[i].trainOnInstance(instance, k, this.instancesSeen);
-                }
-            }
-        }
-        if(this.executor != null) {
-            try {
-                this.executor.invokeAll(trainers);
-            } catch (InterruptedException ex) {
-                throw new RuntimeException("Could not call invokeAll() on training threads.");
-            }
-        }
-    }
-
-   public Prediction getPredictionForInstance(Instance instance) {
-    	Instance testInstance = instance.copy();
-        if(this.ensemble == null) 
-            initEnsemble(testInstance);
-        DoubleVector combinedVote = new DoubleVector();
-
-        for(int i = 0 ; i < this.ensemble.length ; ++i) {
-            DoubleVector vote = this.ensemble[i].getPredictionForInstance(testInstance).asDoubleVector();
-            if (vote.sumOfValues() > 0.0) {
-                vote.normalize();
-                double acc = this.ensemble[i].evaluator.getPerformanceMeasurements()[1].getValue();
-                if(! this.disableWeightedVote.isSet() && acc > 0.0) {                        
-                    for(int v = 0 ; v < vote.numValues() ; ++v) {
-                        vote.setValue(v, vote.getValue(v) * acc);
-                    }
-                }
-                combinedVote.addValues(vote);
-            }
-        }
-        return new MultiTargetRegressionPrediction(combinedVote);
-    }
-    
-    //@Override
-    public double[] getVotesForInstance(Instance instance) {
-        Instance testInstance = instance.copy();
-        if(this.ensemble == null) 
-            initEnsemble(testInstance);
-        DoubleVector combinedVote = new DoubleVector();
-
-        for(int i = 0 ; i < this.ensemble.length ; ++i) {
-            DoubleVector vote = new DoubleVector(this.ensemble[i].getVotesForInstance(testInstance));
-            if (vote.sumOfValues() > 0.0) {
-                vote.normalize();
-                double acc = this.ensemble[i].evaluator.getPerformanceMeasurements()[1].getValue();
-                if(! this.disableWeightedVote.isSet() && acc > 0.0) {                        
-                    for(int v = 0 ; v < vote.numValues() ; ++v) {
-                        vote.setValue(v, vote.getValue(v) * acc);
-                    }
-                }
-                combinedVote.addValues(vote);
-            }
-        }
-        return combinedVote.getArrayRef();
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return true;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder arg0, int arg1) {
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return null;
-    }
-
-    protected void initEnsemble(Instance instance) {
-        // Init the ensemble.
-        int ensembleSize = this.ensembleSizeOption.getValue();
-        this.ensemble = new ARFBaseLearnerMTR[ensembleSize];
-        
-        // TODO: this should be an option with default = BasicClassificationPerformanceEvaluator
-//        BasicClassificationPerformanceEvaluator classificationEvaluator = (BasicClassificationPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
-        BasicClassificationPerformanceEvaluator classificationEvaluator = new BasicClassificationPerformanceEvaluator();
-        
-        this.subspaceSize = this.mFeaturesPerTreeSizeOption.getValue();
-  
-        // The size of m depends on:
-        // 1) mFeaturesPerTreeSizeOption
-        // 2) mFeaturesModeOption
-        int n = instance.numAttributes()-1; // Ignore class label ( -1 )
-        
-        switch(this.mFeaturesModeOption.getChosenIndex()) {
-            case AdaptiveRandomForestMultiTargetRegression.FEATURES_SQRT:
-                this.subspaceSize = (int) Math.round(Math.sqrt(n)) + 1;
-                break;
-            case AdaptiveRandomForestMultiTargetRegression.FEATURES_SQRT_INV:
-                this.subspaceSize = n - (int) Math.round(Math.sqrt(n) + 1);
-                break;
-            case AdaptiveRandomForestMultiTargetRegression.FEATURES_PERCENT:
-                // If subspaceSize is negative, then first find out the actual percent, i.e., 100% - m.
-                double percent = this.subspaceSize < 0 ? (100 + this.subspaceSize)/100.0 : this.subspaceSize / 100.0;
-                this.subspaceSize = (int) Math.round(n * percent);
-                break;
-        }
-        // Notice that if the selected mFeaturesModeOption was 
-        //  AdaptiveRandomForest.FEATURES_M then nothing is performed in the
-        //  previous switch-case, still it is necessary to check (and adjusted) 
-        //  for when a negative value was used. 
-        
-        // m is negative, use size(features) + -m
-        if(this.subspaceSize < 0)
-            this.subspaceSize = n + this.subspaceSize;
-        // Other sanity checks to avoid runtime errors. 
-        //  m <= 0 (m can be negative if this.subspace was negative and 
-        //  abs(m) > n), then use m = 1
-        if(this.subspaceSize <= 0)
-            this.subspaceSize = 1;
-        // m > n, then it should use n
-        if(this.subspaceSize > n)
-            this.subspaceSize = n;
-        
-        ISOUPTreeRF treeLearner = (ISOUPTreeRF) getPreparedClassOption(this.treeLearnerOption);
-        treeLearner.resetLearning();
-        
-        for(int i = 0 ; i < ensembleSize ; ++i) {
-            treeLearner.subspaceSize = this.subspaceSize;
-            this.ensemble[i] = new ARFBaseLearnerMTR(
-                i, 
-                (ISOUPTreeRF) treeLearner.copy(), 
-                (BasicClassificationPerformanceEvaluator) classificationEvaluator.copy(), 
-                this.instancesSeen, 
-                ! this.disableBackgroundLearnerOption.isSet(),
-                ! this.disableDriftDetectionOption.isSet(), 
-                driftDetectionMethodOption,
-                warningDetectionMethodOption,
-                false);
-        }
-    }
-    
-    /**
-     * Inner class that represents a single tree member of the forest. 
-     * It contains some analysis information, such as the numberOfDriftsDetected, 
-     */
-    protected final class ARFBaseLearnerMTR extends AbstractMOAObject {
-        public int indexOriginal;
-        public long createdOn;
-        public long lastDriftOn;
-        public long lastWarningOn;
-        public ISOUPTreeRF classifier;
-        public boolean isBackgroundLearner;
-        
-        // The drift and warning object parameters. 
-        protected ClassOption driftOption;
-        protected ClassOption warningOption;
-        
-        // Drift and warning detection
-        protected ChangeDetector driftDetectionMethod;
-        protected ChangeDetector warningDetectionMethod;
-        
-        public boolean useBkgLearner;
-        public boolean useDriftDetector;
-        
-        // Bkg learner
-        protected ARFBaseLearnerMTR bkgLearner;
-        // Statistics
-        public BasicClassificationPerformanceEvaluator evaluator;
-        protected int numberOfDriftsDetected;
-        protected int numberOfWarningsDetected;
-
-        private void init(int indexOriginal, ISOUPTreeRF instantiatedClassifier, BasicClassificationPerformanceEvaluator evaluatorInstantiated, 
-            long instancesSeen, boolean useBkgLearner, boolean useDriftDetector, ClassOption driftOption, ClassOption warningOption, boolean isBackgroundLearner) {
-            this.indexOriginal = indexOriginal;
-            this.createdOn = instancesSeen;
-            this.lastDriftOn = 0;
-            this.lastWarningOn = 0;
-            
-            this.classifier = instantiatedClassifier;
-            this.evaluator = evaluatorInstantiated;
-            this.useBkgLearner = useBkgLearner;
-            this.useDriftDetector = useDriftDetector;
-            
-            this.numberOfDriftsDetected = 0;
-            this.numberOfWarningsDetected = 0;
-            this.isBackgroundLearner = isBackgroundLearner;
-
-            if(this.useDriftDetector) {
-                this.driftOption = driftOption;
-                this.driftDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.driftOption)).copy();
-            }
-
-            // Init Drift Detector for Warning detection. 
-            if(this.useBkgLearner) {
-                this.warningOption = warningOption;
-                this.warningDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.warningOption)).copy();
-            }
-        }
-
-        public ARFBaseLearnerMTR(int indexOriginal, ISOUPTreeRF instantiatedClassifier, BasicClassificationPerformanceEvaluator evaluatorInstantiated, 
-                    long instancesSeen, boolean useBkgLearner, boolean useDriftDetector, ClassOption driftOption, ClassOption warningOption, boolean isBackgroundLearner) {
-            init(indexOriginal, instantiatedClassifier, evaluatorInstantiated, instancesSeen, useBkgLearner, useDriftDetector, driftOption, warningOption, isBackgroundLearner);
-        }
-
-        public void reset() {
-            if(this.useBkgLearner && this.bkgLearner != null) {
-                this.classifier = this.bkgLearner.classifier;
-                
-                this.driftDetectionMethod = this.bkgLearner.driftDetectionMethod;
-                this.warningDetectionMethod = this.bkgLearner.warningDetectionMethod;
-                
-                this.evaluator = this.bkgLearner.evaluator;
-                this.createdOn = this.bkgLearner.createdOn;
-                this.bkgLearner = null;
-            }
-            else {
-                this.classifier.resetLearning();
-                this.createdOn = instancesSeen;
-                this.driftDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.driftOption)).copy();
-            }
-            this.evaluator.reset();
-        }
-
-        public void trainOnInstance(Instance instance, double weight, long instancesSeen) {
-            Instance weightedInstance = (Instance) instance.copy();
-            weightedInstance.setWeight(instance.weight() * weight);
-            this.classifier.trainOnInstance(weightedInstance);
-            
-            if(this.bkgLearner != null)
-                this.bkgLearner.classifier.trainOnInstance(instance);
-            
-            // Should it use a drift detector? Also, is it a backgroundLearner? If so, then do not "incept" another one. 
-            if(this.useDriftDetector && !this.isBackgroundLearner) {
-                // boolean correctlyClassifies = this.classifier.(instance);
-            	// public double getAdwinError(Instance inst, int i) {
-        		double sum = 0.0;
-        		if (this.classifier instanceof ISOUPTree) {
-        			double[] normalizedError = ((ISOUPTree) this.classifier).getNormalizedError(instance, this.classifier.getPredictionForInstance(instance).asDoubleArray());
-        			for (int j = 0; j < instance.numOutputAttributes(); j++) {
-        				sum += normalizedError[j];
-        			}
-        		} else {
-        			Prediction prediction = this.classifier.getPredictionForInstance(instance);
-        			for (int j = 0; j < instance.numOutputAttributes(); j++) {
-        				sum += Math.abs(prediction.getPrediction(j) - instance.valueOutputAttribute(j));
-        			}
-        		}
-        		sum = sum / instance.numOutputAttributes();
-        		//return sum;
-            	//}
-                // Check for warning only if useBkgLearner is active
-                if(this.useBkgLearner) {
-                    // Update the warning detection method
-                    this.warningDetectionMethod.input(sum);
-                    // Check if there was a change
-                    if(this.warningDetectionMethod.getChange()) {
-                        this.lastWarningOn = instancesSeen;
-                        this.numberOfWarningsDetected++;
-                        // Create a new bkgTree classifier
-                        ISOUPTreeRF bkgClassifier = (ISOUPTreeRF) this.classifier.copy();
-                        bkgClassifier.resetLearning();
-                        
-                        // Resets the evaluator
-                        BasicClassificationPerformanceEvaluator bkgEvaluator = (BasicClassificationPerformanceEvaluator) this.evaluator.copy();
-                        bkgEvaluator.reset();
-                        
-                        // Create a new bkgLearner object
-                        this.bkgLearner = new ARFBaseLearnerMTR(indexOriginal, bkgClassifier, bkgEvaluator, instancesSeen, 
-                            this.useBkgLearner, this.useDriftDetector, this.driftOption, this.warningOption, true);
-                        
-                        // Update the warning detection object for the current object 
-                        // (this effectively resets changes made to the object while it was still a bkg learner). 
-                        this.warningDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.warningOption)).copy();
-                    }
-                }
-                
-                /*********** drift detection ***********/
-                
-                // Update the DRIFT detection method
-                this.driftDetectionMethod.input(sum);
-                // Check if there was a change
-                if(this.driftDetectionMethod.getChange()) {
-                    this.lastDriftOn = instancesSeen;
-                    this.numberOfDriftsDetected++;
-                    this.reset();
-                }
-            }
-        }
-
-        public Prediction getPredictionForInstance(Instance instance) {
-        	return this.classifier.getPredictionForInstance(instance);
-        }
-        
-        public double[] getVotesForInstance(Instance instance) {
-            DoubleVector vote = new DoubleVector(this.classifier.getPredictionForInstance(instance).asDoubleArray());
-            return vote.getArrayRef();
-        }
-
-        @Override
-        public void getDescription(StringBuilder sb, int indent) {
-        }
-    }
-    
-    /***
-     * Inner class to assist with the multi-thread execution. 
-     */
-    protected class TrainingRunnable implements Runnable, Callable<Integer> {
-        final private ARFBaseLearnerMTR learner;
-        final private Instance instance;
-        final private double weight;
-        final private long instancesSeen;
-
-        public TrainingRunnable(ARFBaseLearnerMTR learner, Instance instance, 
-                double weight, long instancesSeen) {
-            this.learner = learner;
-            this.instance = instance;
-            this.weight = weight;
-            this.instancesSeen = instancesSeen;
-        }
-
-        @Override
-        public void run() {
-            learner.trainOnInstance(this.instance, this.weight, this.instancesSeen);
-        }
-
-        @Override
-        public Integer call() throws Exception {
-            run();
-            return 0;
-        }
-    }
-}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/mtr/BasicMultiTargetRegressor.java b/moa/src/main/java/moa/classifiers/mtr/BasicMultiTargetRegressor.java
deleted file mode 100644
index 4cfb968a8..000000000
--- a/moa/src/main/java/moa/classifiers/mtr/BasicMultiTargetRegressor.java
+++ /dev/null
@@ -1,160 +0,0 @@
-/*
- *    BasicMultiTargetRegressor.java
- *    Copyright (C) 2017 University of Porto, Portugal
- *    @author J. Duarte, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *
- *
- */
-
-package moa.classifiers.mtr;
-
-import com.yahoo.labs.samoa.instances.DenseInstance;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.predictions.MultiTargetRegressionPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractInstanceLearner;
-import moa.classifiers.AbstractMultiTargetRegressor;
-import moa.core.DoubleVector;
-import moa.core.FastVector;
-import moa.core.Measurement;
-import moa.core.StringUtils;
-import moa.learners.MultiTargetRegressor;
-import moa.learners.Regressor;
-import moa.options.ClassOption;
-import moa.streams.InstanceStream;
-
-
-public class BasicMultiTargetRegressor extends AbstractMultiTargetRegressor implements MultiTargetRegressor {
-
-
-	public BasicMultiTargetRegressor() {
-		init();
-	}
-
-	protected void init() {
-		baseLearnerOption = new ClassOption("baseLearner", 'l',
-				"Classifier to train.", Regressor.class, "rules.AMRulesRegressor");
-	}
-
-	private static final long serialVersionUID = 1L;
-
-	public ClassOption baseLearnerOption; //rules.AMRules"); 
-
-	protected Regressor[] ensemble;
-
-	protected boolean hasStarted = false;
-
-	@Override
-	public void resetLearningImpl() {
-		this.hasStarted = false;
-	}
-
-	@Override
-	public void trainOnInstanceImpl(Instance instance) {
-		if (this.hasStarted == false){		
-			this.ensemble = new Regressor[instance.numOutputAttributes()];
-			Regressor baseLearner = (Regressor) getPreparedClassOption(this.baseLearnerOption);
-			baseLearner.resetLearning();
-			for (int i = 0; i < this.ensemble.length; i++) {
-				this.ensemble[i] = (Regressor) baseLearner.copy();
-			}
-			this.hasStarted = true;
-		}
-		for (int i = 0; i < this.ensemble.length; i++) {
-			Instance weightedInst = transformInstance(instance,i);
-			this.ensemble[i].trainOnInstance(weightedInst); 
-		}
-	}
-
-	protected InstancesHeader[] header;
-
-	protected Instance transformInstance(Instance inst, int outputIndex) {
-		if (header == null) {
-			this.header = new InstancesHeader[this.ensemble.length];
-		}
-		if (header[outputIndex] == null) {
-			//Create Header
-			FastVector attributes = new FastVector();
-			for (int attributeIndex = 0; attributeIndex < inst.numInputAttributes(); attributeIndex++) {
-				attributes.addElement(inst.inputAttribute(attributeIndex));
-			}
-			//System.out.println("Number of attributes: "+this.numAttributes+ ","+inst.numAttributes());
-			attributes.addElement(inst.outputAttribute(outputIndex));
-			this.header[outputIndex] =  new InstancesHeader(new InstancesHeader(
-					getCLICreationString(InstanceStream.class), attributes, 0));
-			this.header[outputIndex].setClassIndex(attributes.size()-1);
-			this.ensemble[outputIndex].setModelContext(this.header[outputIndex]);
-		}
-		//Instance instance = new DenseInstance(this.numAttributes+1);
-		//instance.setDataset(dataset[classifierIndex]);
-		int numAttributes = this.header[outputIndex].numInputAttributes();
-		double[] attVals = new double[numAttributes+1]; //JD - +1 for class
-		for (int attributeIndex = 0; attributeIndex < numAttributes; attributeIndex++) {
-			attVals[attributeIndex] = inst.valueInputAttribute(attributeIndex);
-		}
-		Instance instance = new DenseInstance(1.0, attVals);
-		instance.setDataset(header[outputIndex]);
-		instance.setClassValue(inst.valueOutputAttribute(outputIndex));
-		// System.out.println(inst.toString());
-		// System.out.println(instance.toString());
-		// System.out.println("============");
-		return instance;
-	}
-
-
-	public boolean isRandomizable() {
-		return true;
-	}
-
-
-	@Override
-	protected Measurement[] getModelMeasurementsImpl() {
-		if(ensemble.length>0)
-			return ensemble[0].getModelMeasurements(); 
-		//TODO: JD - get measurements for all outputs
-		else 
-			return null;
-	}
-
-
-	@Override
-	public void getModelDescription(StringBuilder out, int indent) {
-		if(ensemble.length>0 && ensemble[0] instanceof AbstractInstanceLearner)
-		{
-			for (int i=0; i<ensemble.length;i++){
-				StringUtils.appendIndented(out,indent+1,"Model output attribute #" + i + "\n");
-				((AbstractInstanceLearner)ensemble[i]).getModelDescription(out, indent+1);
-			}
-		}
-	}
-	
-
-	@Override
-	public Prediction getPredictionForInstance(Instance instance) {
-		DoubleVector combinedVote = new DoubleVector();
-		if (this.hasStarted){ 
-			
-			for (int i = 0; i < this.ensemble.length; i++) {
-				double vote = this.ensemble[i].getPredictionForInstance(transformInstance(instance,i)).asDoubleArray()[0];
-				combinedVote.setValue(i, vote);
-			}
-		}
-		return new MultiTargetRegressionPrediction(combinedVote);
-	}
-}
-
-
diff --git a/moa/src/main/java/moa/classifiers/mtr/functions/MultiTargetNoChange.java b/moa/src/main/java/moa/classifiers/mtr/functions/MultiTargetNoChange.java
deleted file mode 100644
index b590386f1..000000000
--- a/moa/src/main/java/moa/classifiers/mtr/functions/MultiTargetNoChange.java
+++ /dev/null
@@ -1,70 +0,0 @@
-package moa.classifiers.mtr.functions;
-
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.MultiTargetRegressionPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractMultiTargetRegressor;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.learners.MultiTargetRegressor;
-
-/**
- * MultiTargetNoChange class regressor. It always predicts the last target values seen.
- *
- * @author Albert Bifet (abifet@cs.waikato.ac.nz)
- * @version $Revision: 1 $
- */
-public class MultiTargetNoChange extends AbstractMultiTargetRegressor implements MultiTargetRegressor {
-
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public String getPurposeString() {
-        return "Weather Forecast class classifier: always predicts the last class seen.";
-    }
-
-    //protected InstanceData lastSeenClasses;
-    Prediction lastSeenClasses;
-    
-    @Override
-    public void resetLearningImpl() {
-        this.lastSeenClasses = null;
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-    	int numOutputs = inst.numOutputAttributes();
-    	DoubleVector prediction = new DoubleVector();
-    	
-    	for(int i=0; i<numOutputs;i++)
-    		prediction.setValue(i, inst.classValue(i));
-    	
-        this.lastSeenClasses = new MultiTargetRegressionPrediction(prediction);
-    	
-    }
-   
-    
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return null;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-       
-    }
-
-    public boolean isRandomizable() {
-        return false;
-    }
-
-	@Override
-	public Prediction getPredictionForInstance(Instance inst) {
-		//return (lastSeenClasses!=null) ? this.lastSeenClasses : new MultiLabelPrediction();
-		return (lastSeenClasses!=null) ? this.lastSeenClasses : null;
-	}
-
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/AbstractAMRules.java b/moa/src/main/java/moa/classifiers/rules/AbstractAMRules.java
deleted file mode 100644
index c74931e98..000000000
--- a/moa/src/main/java/moa/classifiers/rules/AbstractAMRules.java
+++ /dev/null
@@ -1,453 +0,0 @@
-/*
- *    AbstractAMRules.java
- *    Copyright (C) 2014 University of Porto, Portugal
- *    @author A. Bifet, J. Duarte, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.classifiers.rules;
-/**
- * Adaptive Model Rules (AMRules), the streaming rule learning algorithm for regression problems.
- * 
- *  @author  A. Bifet, J. Duarte, J. Gama (jgama@fep.up.pt)
- * @version $Revision: 2 $* 
- * 
- * This algorithm learn ordered and unordered rule set from data stream. Each rule in AMRules use a 
- * Page-Hinkley test to detect changes in the processing generating data and react to changes by pruning the rule set.
- * This algorithm also does the detection of anomalies.
- * 
- **/
-
-import java.util.Arrays;
-import java.util.Iterator;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.MultiTargetRegressionPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractMultiTargetRegressor;
-import moa.classifiers.rules.core.Rule;
-import moa.classifiers.rules.core.Rule.Builder;
-import moa.classifiers.rules.core.RuleActiveLearningNode;
-import moa.classifiers.rules.core.RuleSet;
-import moa.classifiers.rules.core.attributeclassobservers.FIMTDDNumericAttributeClassLimitObserver;
-import moa.classifiers.rules.core.voting.ErrorWeightedVote;
-import moa.classifiers.rules.core.voting.Vote;
-import moa.core.Measurement;
-import moa.core.StringUtils;
-import moa.options.ClassOption;
-
-
-public abstract class AbstractAMRules extends AbstractMultiTargetRegressor {
-
-	private static final long serialVersionUID = 1L;
-	protected RuleSet ruleSet = new RuleSet();
-	protected Rule defaultRule;
-	protected int ruleNumberID;
-	protected double[] statistics;
-	public static final double NORMAL_CONSTANT = Math.sqrt(2 * Math.PI);
-	public FloatOption splitConfidenceOption = new FloatOption(
-			"splitConfidence",
-			'c',
-			"Hoeffding Bound Parameter. The allowable error in split decision, values closer to 0 will take longer to decide.",
-			0.0000001, 0.0, 1.0);
-	public FloatOption tieThresholdOption = new FloatOption("tieThreshold",
-			't', "Hoeffding Bound Parameter. Threshold below which a split will be forced to break ties.",
-			0.05, 0.0, 1.0);
-	public IntOption gracePeriodOption = new IntOption("gracePeriod",
-			'g', "Hoeffding Bound Parameter. The number of instances a leaf should observe between split attempts.",
-			200, 1, Integer.MAX_VALUE);
-	public FlagOption DriftDetectionOption = new FlagOption("DoNotDetectChanges", 'H',
-			"Drift Detection. Page-Hinkley.");
-	public FloatOption pageHinckleyAlphaOption = new FloatOption(
-			"pageHinckleyAlpha",
-			'a',
-			"The alpha value to use in the Page Hinckley change detection tests.",
-			0.005, 0.0, 1.0);
-	public IntOption pageHinckleyThresholdOption = new IntOption(
-			"pageHinckleyThreshold",
-			'l',
-			"The threshold value (Lambda) to be used in the Page Hinckley change detection tests.",
-			35, 0, Integer.MAX_VALUE);
-	public FlagOption noAnomalyDetectionOption = new FlagOption("noAnomalyDetection", 'A',
-			"Disable anomaly Detection.");
-	public FloatOption multivariateAnomalyProbabilityThresholdOption = new FloatOption(
-			"multivariateAnomalyProbabilityThresholdd",
-			'm',
-			"Multivariate anomaly threshold value.",
-			0.99, 0.0, 1.0);
-	public FloatOption univariateAnomalyprobabilityThresholdOption = new FloatOption(
-			"univariateAnomalyprobabilityThreshold",
-			'u',
-			"Univariate anomaly threshold value.",
-			0.10, 0.0, 1.0);
-	public IntOption anomalyNumInstThresholdOption = new IntOption(
-			"anomalyThreshold",
-			'n',
-			"The threshold value of anomalies to be used in the anomaly detection.",
-			30, 0, Integer.MAX_VALUE);
-	public FlagOption unorderedRulesOption = new FlagOption("setUnorderedRulesOn", 'U',
-			"unorderedRules.");
-
-	public IntOption VerbosityOption = new IntOption(
-			"verbosity",
-			'v',
-			"Output Verbosity Control Level. 1 (Less) to 5 (More)",
-			1, 1, 5);
-
-	public ClassOption numericObserverOption = new ClassOption("numericObserver",
-			'z', "Numeric observer.", 
-			FIMTDDNumericAttributeClassLimitObserver.class,
-			"FIMTDDNumericAttributeClassLimitObserver");
-	
-
-	protected double attributesPercentage;
-	
-	public double getAttributesPercentage() {
-		return attributesPercentage;
-	}
-
-	public void setAttributesPercentage(double attributesPercentage) {
-		this.attributesPercentage = attributesPercentage;
-	}
-
-	public AbstractAMRules() {
-		super();
-		attributesPercentage=100;
-	}
-	
-	public AbstractAMRules(double attributesPercentage) {
-		this();
-		this.attributesPercentage=attributesPercentage;
-	}
-
-	/**
-	 * description of the Methods used.
-	 * isRandomizable
-	 * resetLearningImpl
-	 * newRule // to build an object with the parameters.
-	 * trainOnInstanceImpl
-	 * isAnomaly
-	 * getPredictionForInstance
-	 * getModelMeasurementsImpl
-	 * getModelDescription // to printout to MOA GUI
-	 * debug // use debug('string') to printout to console
-	 */
-	@Override
-	public abstract boolean isRandomizable();
-
-
-
-	/**
-	 * Rule.Builder() to build an object with the parameters.
-	 * If you have an algorithm with many parameters, especially if some of them are optional, 
-	 * it can be beneficial to define an object that represents all of the parameters.
-	 * @return
-	 */
-	abstract protected Rule newRule(int ID, RuleActiveLearningNode learningNode, double [] statistics); //Learning node and statistics can be null
-
-	/**
-	 * AMRules Algorithm.
-	 * Method for updating (training) the AMRules model using a new instance
-	 */
-
-	private double numChangesDetected; //Just for statistics 
-	private double numAnomaliesDetected; //Just for statistics 
-	private double numInstances; ////Just for statistics
-
-	@Override
-	public void trainOnInstanceImpl(Instance instance) {
-		/**
-		 * AMRules Algorithm
-		 * 
-		 //For each rule in the rule set
-			//If rule covers the instance
-				//if the instance is not an anomaly	
-					//Update Change Detection Tests
-				    	//Compute prediction error
-				    	//Call PHTest
-						//If change is detected then
-							//Remove rule
-						//Else
-							//Update sufficient statistics of rule
-							//If number of examples in rule  > Nmin
-								//Expand rule
-						//If ordered set then
-							//break
-			//If none of the rule covers the instance
-				//Update sufficient statistics of default rule
-				//If number of examples in default rule is multiple of Nmin
-					//Expand default rule and add it to the set of rules
-					//Reset the default rule
-		 */
-		numInstances+=instance.weight();
-		debug("Train",3);
-		debug("Nº instance "+numInstances + " - " + instance.toString(),3);
-		boolean rulesCoveringInstance = false;
-		Iterator<Rule> ruleIterator= this.ruleSet.iterator();
-		while (ruleIterator.hasNext()) { 
-			Rule rule = ruleIterator.next();
-			if (rule.isCovering(instance) == true) {
-				rulesCoveringInstance = true;
-				if (isAnomaly(instance, rule) == false) {
-					//Update Change Detection Tests
-					double error = rule.computeError(instance); //Use adaptive mode error
-					boolean changeDetected = rule.getLearningNode().updateChangeDetection(error);
-					if (changeDetected == true) {
-						debug("I) Drift Detected. Exa. : " +  this.numInstances + " (" + rule.getInstancesSeen() +") Remove Rule: " +rule.getRuleNumberID(),1);
-
-						ruleIterator.remove();
-						this.numChangesDetected+=instance.weight();  //Just for statistics 
-					} else {
-						rule.updateStatistics(instance);
-						if (rule.getInstancesSeen()  % this.gracePeriodOption.getValue() == 0.0) {
-							if (rule.tryToExpand(this.splitConfidenceOption.getValue(), this.tieThresholdOption.getValue()) ) 
-							{
-								rule.split();
-								debug("Rule Expanded:",2);
-								debug(rule.printRule(),2);
-							}	
-						}
-					}
-				}
-				else {
-					debug("Anomaly Detected: " + this.numInstances + " Rule: " +rule.getRuleNumberID() ,1);
-					this.numAnomaliesDetected+=instance.weight();//Just for statistics
-				}
-				if (!this.unorderedRulesOption.isSet()) 
-					break;
-			}
-		}	
-
-		if (rulesCoveringInstance == false){ 
-			defaultRule.updateStatistics(instance);
-			if (defaultRule.getInstancesSeen() % this.gracePeriodOption.getValue() == 0.0) {
-				debug("Nr. examples "+defaultRule.getInstancesSeen(), 4);
-
-				if (defaultRule.tryToExpand(this.splitConfidenceOption.getValue(), this.tieThresholdOption.getValue()) == true) {
-					Rule newDefaultRule=newRule(defaultRule.getRuleNumberID(),defaultRule.getLearningNode(),defaultRule.getLearningNode().getStatisticsOtherBranchSplit()); //other branch
-					defaultRule.split();
-					defaultRule.setRuleNumberID(++ruleNumberID);
-					this.ruleSet.add(this.defaultRule);
-
-					debug("Default rule expanded! New Rule:",2);
-					debug(defaultRule.printRule(),2);
-					debug("New default rule:", 3);	
-					debug(newDefaultRule.printRule(),3);
-					defaultRule=newDefaultRule;
-
-				}
-			}
-		}
-	}
-
-
-
-	/**
-	 * Method to verify if the instance is an anomaly.
-	 * @param instance
-	 * @param rule
-	 * @return
-	 */
-	private boolean isAnomaly(Instance instance, Rule rule) {
-		//AMRUles is equipped with anomaly detection. If on, compute the anomaly value. 			
-		boolean isAnomaly = false;	
-		if (this.noAnomalyDetectionOption.isSet() == false){
-			if (rule.getInstancesSeen() >= this.anomalyNumInstThresholdOption.getValue()) {
-				isAnomaly = rule.isAnomaly(instance, 
-						this.univariateAnomalyprobabilityThresholdOption.getValue(),
-						this.multivariateAnomalyProbabilityThresholdOption.getValue(),
-						this.anomalyNumInstThresholdOption.getValue());
-			}
-		}
-		return isAnomaly;
-	}
-
-	/**
-	 * getPredictionForInstance extension of the instance method getPredictionForInstance 
-	 * in moa.classifier.java
-	 * returns the prediction of the instance.
-	 * Called in EvaluateModelRegression
-	 */
-	@Override
-	public Prediction getPredictionForInstance(Instance instance) {
-		return new MultiTargetRegressionPrediction(getVotes(instance).getVote());
-	}
-
-	/**
-	 * print GUI evaluate model	
-	 */
-	@Override
-	protected Measurement[] getModelMeasurementsImpl() {
-		return new Measurement[]{
-				new Measurement("anomaly detections", this.numAnomaliesDetected),
-				new Measurement("change detections", this.numChangesDetected), 
-				new Measurement("rules (number)", this.ruleSet.size()+1)}; 
-	}
-
-	/**
-	 * print GUI learn model	
-	 */
-	@Override
-	public void getModelDescription(StringBuilder out, int indent) {
-		indent=0;
-		if(!this.unorderedRulesOption.isSet()){
-			StringUtils.appendIndented(out, indent, "Method Ordered");
-			StringUtils.appendNewline(out);
-		}else{
-			StringUtils.appendIndented(out, indent, "Method Unordered");
-			StringUtils.appendNewline(out);
-		}
-		if(this.DriftDetectionOption.isSet()){
-			StringUtils.appendIndented(out, indent, "Change Detection OFF");
-			StringUtils.appendNewline(out);
-		}else{
-			StringUtils.appendIndented(out, indent, "Change Detection ON");
-			StringUtils.appendNewline(out);
-		}
-		if(this.noAnomalyDetectionOption.isSet()){
-			StringUtils.appendIndented(out, indent, "Anomaly Detection OFF");
-			StringUtils.appendNewline(out);
-		}else{
-			StringUtils.appendIndented(out, indent, "Anomaly Detection ON");
-			StringUtils.appendNewline(out);
-		}
-		StringUtils.appendIndented(out, indent, "Number of Rules: " + (this.ruleSet.size()+1));
-		StringUtils.appendNewline(out);		
-	}
-
-	/**
-	 * Print to console
-	 * @param string
-	 */
-	protected void debug(String string, int level) {
-		if (VerbosityOption.getValue()>=level){
-			System.out.println(string); 
-		}
-	}
-
-	protected void VerboseToConsole(Instance inst) {
-		if(VerbosityOption.getValue()>=5){	
-			System.out.println(); 
-			System.out.println("I) Dataset: "+inst.dataset().getRelationName()); 
-
-			if(!this.unorderedRulesOption.isSet()){ 
-				System.out.println("I) Method Ordered");
-			}else{
-				System.out.println("I) Method Unordered");
-			}
-		}    	
-	}
-
-	public void PrintRuleSet() {    	
-		debug("Rule in RuleSet:",2);
-		for (Rule rule: ruleSet) {
-			debug(rule.printRule(),2);
-		}
-
-		debug("Default rule :",2);
-		debug(this.defaultRule.printRule(),2);
-	}
-
-	abstract public RuleActiveLearningNode newRuleActiveLearningNode(Builder builder);
-
-	abstract public RuleActiveLearningNode newRuleActiveLearningNode(double[] initialClassObservations);
-
-	public int getModelAttIndexToInstanceAttIndex(int index, Instance inst){
-		return modelAttIndexToInstanceAttIndex(index, inst);
-	}
-
-	@Override
-	public void resetLearningImpl() {
-		
-
-	}
-
-	/**
-	 * Gets the index of the attribute in the instance,
-	 * given the index of the attribute in the learner.
-	 *
-	 * @param index the index of the attribute in the learner
-	 * @param inst the instance
-	 * @return the index in the instance
-	 */
-	public static int modelAttIndexToInstanceAttIndex(int index,
-			Instance inst) {
-		return  index<= inst.classIndex() ? index : index + 1;
-	}
-	
-	
-	abstract public ErrorWeightedVote newErrorWeightedVote(); 
-
-	
-	/**
-	 * getVotes extension of the instance method getPredictionForInstance 
-	 * in moa.classifier.java
-	 * returns the prediction of the instance.
-	 * Called in WeightedRandomRules
-	 */
-	public Vote getVotes(Instance instance) {
-		ErrorWeightedVote errorWeightedVote=newErrorWeightedVote();
-		//DoubleVector combinedVote = new DoubleVector();
-		debug("Test",3);    
-		int numberOfRulesCovering = 0;
-
-		VerboseToConsole(instance); // Verbose to console Dataset name.
-		for (Rule rule : ruleSet) {
-			if (rule.isCovering(instance) == true){
-				numberOfRulesCovering++;
-				//DoubleVector vote = new DoubleVector(rule.getPrediction(instance));
-				double [] vote=rule.getPrediction(instance);
-				double error= rule.getCurrentError();
-				debug("Rule No"+ rule.getRuleNumberID() + " Vote: " + Arrays.toString(vote) + " Error: " + error + " Y: " + instance.classValue(),3); //predictionValueForThisRule);
-				errorWeightedVote.addVote(vote,error);
-				//combinedVote.addValues(vote);
-				if (!this.unorderedRulesOption.isSet()) { // Ordered Rules Option.
-					break; // Only one rule cover the instance.
-				}
-			}
-		}
-
-		if (numberOfRulesCovering == 0) {
-			//combinedVote = new DoubleVector(defaultRule.getPrediction(instance));
-			double [] vote=defaultRule.getPrediction(instance);
-			double error= defaultRule.getCurrentError();
-			errorWeightedVote.addVote(vote,error);
-			
-			debug("Default Rule Vote " + Arrays.toString(vote) + " Error " + error + "  Y: " + instance.classValue(),3);
-		} 	
-		double[] weightedVote=errorWeightedVote.computeWeightedVote();
-		double weightedError=errorWeightedVote.getWeightedError();
-		
-		debug("Weighted Rule - Vote: " + Arrays.toString(weightedVote) + " Weighted Error: " + weightedError + " Y:" + instance.classValue(),3);
-		return new Vote(weightedVote, weightedError);
-	}
-	
-	public void setRandomSeed(int randomSeed){
-		//this.randomSeed=randomSeed;
-		this.classifierRandom.setSeed(randomSeed);
-	}
-	
-	//public int getRandomSeed(){
-		//return this.randomSeed;
-	//}
-	
-
-
-}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/rules/RuleClassification.java b/moa/src/main/java/moa/classifiers/rules/RuleClassification.java
deleted file mode 100644
index 3d6fdcda9..000000000
--- a/moa/src/main/java/moa/classifiers/rules/RuleClassification.java
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
- *    RuleClassification.java
- *    Copyright (C) 2012 University of Porto, Portugal
- *    @author P. Kosina, E. Almeida, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.classifiers.rules;
-
-/**
- * Class that stores an arrayList  of predicates of a rule and the observers (statistics).
- * This class implements a function that evaluates a rule.
- *
- * <p>Learning Decision Rules from Data Streams, IJCAI 2011, J. Gama,  P. Kosina </p>
- *
- * @author P. Kosina, E. Almeida, J. Gama
- * @version $Revision: 2 $
- * 
- * 
- */
-
-import java.util.ArrayList;
-
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.AbstractMOAObject;
-import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
-import moa.core.AutoExpandVector;
-import moa.core.DoubleVector;
-
-public class RuleClassification extends AbstractMOAObject{
-	
-	private static final long serialVersionUID = 1L;
-	
-    protected  ArrayList<Predicates> predicateSet = new ArrayList<Predicates>();
-    
-	protected AutoExpandVector<AttributeClassObserver> observers = new AutoExpandVector<AttributeClassObserver>(); //Statistics.
-	
-	protected AutoExpandVector<AttributeClassObserver> observersGauss = new AutoExpandVector<AttributeClassObserver>(); //Statistics.
-	
-    protected ArrayList<ArrayList<Double>> attributeStatisticsSupervised = new ArrayList<ArrayList<Double>>();
-	
-	protected ArrayList<ArrayList<Double>> squaredAttributeStatisticsSupervised = new ArrayList<ArrayList<Double>>();
-	
-	protected double[] weightAttribute; // The Perception weights. 
-    
-    protected DoubleVector attributeStatistics = new DoubleVector(); // Statistics used for error calculations.
-    
-    protected DoubleVector attributesProbability = new DoubleVector(); // Probalility of each attribute.
-    
-    protected DoubleVector squaredAttributeStatistics = new DoubleVector();
-    
-    protected DoubleVector obserClassDistrib = new DoubleVector();
-    
-    protected DoubleVector attributeMissingValues = new DoubleVector(); // for each attribute counts the number of missing values.
-    
-    protected int instancesSeen = 0;  // The number of instances contributing to this model.
-    
-    protected int instancesSeenTest = 0;  // The number of instances test seen by the rule.
-    
-    protected boolean reset=true; // If the model should be reset or not.
-    
- // Statistics used for normalize actualClass and predictedClass.
-    protected double actualClassStatistics = 0.0;
-    
-    protected double squaredActualClassStatistics = 0.0;
-    
-    protected double PHmT = 0; //The cumulative sum of the errors.
-    
-    protected double PHMT = Double.MAX_VALUE; // The minimum error value seen so far.
-    
-    protected double XiSum = 0;  //Absolute error.
-    
-    protected double ValorTargetRule=0; // Target value of the rule.
-	
-	
-	public RuleClassification(RuleClassification x) {
-		for (int i = 0; i < x.predicateSet.size(); i++) {
-			Predicates pred = new Predicates(x.predicateSet.get(i).getAttributeValue(), x.predicateSet.get(i).getSymbol(), x.predicateSet.get(i).getValue());
-			this.predicateSet.add(pred);
-		}
-		
-	}
-	
-	public RuleClassification() {
-		
-	}
-    
-    public boolean ruleEvaluate(Instance inst) {
-    	int countTrue = 0;
-		boolean ruleEvalu = false;
-		for (int i = 0; i < predicateSet.size(); i++) {
-			if (predicateSet.get(i).evaluate(inst) == true) {
-				countTrue = countTrue + 1;
-			}
-		}
-		if (countTrue == predicateSet.size()) {
-			ruleEvalu = true;
-		} else {
-			ruleEvalu = false;
-			}
-		return ruleEvalu;
-		}
-	
-	@Override
-	public void getDescription(StringBuilder sb, int indent) {
-		// TODO Auto-generated method stub	
-	}
-         
-
-}
-
diff --git a/moa/src/main/java/moa/classifiers/rules/RuleClassifier.java b/moa/src/main/java/moa/classifiers/rules/RuleClassifier.java
deleted file mode 100644
index 01ad15916..000000000
--- a/moa/src/main/java/moa/classifiers/rules/RuleClassifier.java
+++ /dev/null
@@ -1,1316 +0,0 @@
-/*
- *    RuleClassifier.java
- *    Copyright (C) 2012 University of Porto, Portugal
- *    @author P. Kosina, E. Almeida, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.classifiers.rules;
-
-import java.io.File;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.io.PrintWriter;
-import java.math.BigDecimal;
-import java.util.ArrayList;
-import java.util.Collections;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.BinaryTreeNumericAttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.BinaryTreeNumericAttributeClassObserver.Node;
-import moa.classifiers.core.attributeclassobservers.GaussianNumericAttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.NominalAttributeClassObserver;
-import moa.core.AutoExpandVector;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.core.StringUtils;
-import moa.core.Utils;
-import moa.learners.Classifier;
-
-
-
-/**
- * This classifier learn ordered and unordered rule set from data stream.
- * This algorithm also does the detection of anomalies.
- * 
- * <p>Learning Decision RuleClassifications from Data Streams, IJCAI 2011, J. Gama,  P. Kosina </p>
- *
- * 
- * <p>Parameters:</p>
- * <ul>
- * <li> -p: Minimum value of p </li>
- * <li> -t: Tie Threshold </li>
- * <li> -c: Split Confidence </li>
- * <li> -g: GracePeriod, the number of instances a leaf should observe between split attempts </li>
- * <li> -o: Prediction function to use. Ex:FirstHit </li>
- * <li> -r: Learn ordered or unordered rule </li>
- * </ul>
- * 
- * @author P. Kosina, E. Almeida, J. Gama
- * @version $Revision: 2 $
- */
-
-public class RuleClassifier extends AbstractClassifier implements Classifier {
-	
-	  private static final long serialVersionUID = 1L;
-	  
-	  @Override
-	  public String getPurposeString() {
-	        return "Rule Classifier.";
-	    }
-	  
-	  protected Instance instance; 
-	  
-	  protected AutoExpandVector<AttributeClassObserver> attributeObservers;
-	  
-	  protected AutoExpandVector<AttributeClassObserver> attributeObserversGauss;
-	  
-	  protected DoubleVector observedClassDistribution;
-	  
-	  protected DoubleVector saveBestEntropy = new DoubleVector();		// Saves the best value of entropy, cut_Point and symbol.
-	  
-	  protected DoubleVector saveBestEntropyNominalAttrib = new DoubleVector();	 	// Saves the best value of entropy and their cut_Point.
-	  
-	  protected DoubleVector ruleClassIndex = new DoubleVector();		// The index of the class for each rule.
-	  
-	  protected DoubleVector saveBestGlobalEntropy = new DoubleVector();
-	 
-	  protected ArrayList<ArrayList<Double>> saveBestValGlobalEntropy = new ArrayList<ArrayList<Double>>();		// For each attribute contains the best value of entropy and its cutPoint.
-	  
-	  protected ArrayList<Double> saveTheBest = new ArrayList<Double>();		// Contains the best attribute. 
-	  
-	  protected ArrayList<RuleClassification> ruleSet = new ArrayList<RuleClassification>();
-	  
-	 //   protected DoubleVector ruleClassIndexAnomalis = new DoubleVector();
-	  protected  ArrayList<RuleClassification> ruleSetAnomalies = new ArrayList<RuleClassification>();
-		
-	  protected ArrayList<Integer> ruleAnomaliesIndex = new ArrayList<Integer>();
-	
-	  protected ArrayList<ArrayList<Integer>> caseAnomaly = new ArrayList<ArrayList<Integer>>();
-	  
-	  protected ArrayList<ArrayList<ArrayList<Double>>> ruleAttribAnomalyStatistics = new ArrayList<ArrayList<ArrayList<Double>>>();
-	  
-	  protected  ArrayList<RuleClassification> ruleSetAnomaliesSupervised = new ArrayList<RuleClassification>();
-	  
-	  protected ArrayList<Integer> ruleAnomaliesIndexSupervised = new ArrayList<Integer>();
-	  
-	  protected ArrayList<ArrayList<Integer>> caseAnomalySupervised = new ArrayList<ArrayList<Integer>>();
-	  
-	  protected ArrayList<ArrayList<ArrayList<Double>>> ruleAttribAnomalyStatisticsSupervised = new ArrayList<ArrayList<ArrayList<Double>>>();
-	  
-	  double minEntropyTemp = Double.MAX_VALUE;
-	  
-	  double cutPointTemp = 0.0;
-  
-      double minEntropyNominalAttrib = Double.MAX_VALUE;
-  
-      double symbol = 0.0;
-  
-      int numInstance = 0;
-  
-      int numAttributes = 0;
-  
-      int numClass = 0;
-      
-      Node root;
-  
-      Predicates pred;  
-
-	  public FloatOption PminOption = new FloatOption("Pmin",
-	            'p', "Percentage of the total number of example seen in the node.",
-	             0.1, 0.0, 1.0);
-	  
-	  public FloatOption splitConfidenceOption = new FloatOption(
-	            "splitConfidence",
-	            'c',
-	            "The allowable error in split decision, values closer to 0 will take longer to decide.",
-	            0.000001, 0.0, 1.0);
-	  
-	  public FloatOption tieThresholdOption = new FloatOption("tieThreshold",
-	            't', "Threshold below which a split will be forced to break ties.",
-	             0.05, 0.0, 1.0);
-	  
-	  public FloatOption anomalyProbabilityThresholdOption = new FloatOption(
-				"anomalyprobabilityThreshold",
-				'o',
-				"The threshold value.",
-				0.99, 0.0, 1.0);
-		
-	 public FloatOption probabilityThresholdOption = new FloatOption(
-				"probabilityThreshold",
-				'k',
-				"The threshold value.",
-				0.10, 0.0, 1.0);
-		
-	 public IntOption anomalyNumInstThresholdOption = new IntOption(
-				"anomalyThreshold",
-				'i',
-				"The threshold value to be used in the anomaly detection.",
-				15, 0, Integer.MAX_VALUE);
-	  
-	 public IntOption gracePeriodOption = new IntOption(
-		        "gracePeriod",'g', "The number of instances a leaf should observe between split attempts.",
-		         200, 0, Integer.MAX_VALUE);
-	  
-	 public MultiChoiceOption predictionFunctionOption = new MultiChoiceOption(
-	            "predictionFunctionOption", 'z', "The prediction function to use.", new String[]{
-	            "firstHit", "weightedSum", "weightedMax"}, new String[]{
-	            "first Hit",  "weighted Sum", "weighted Max"}, 0);
-	  
-	 public FlagOption orderedRulesOption = new FlagOption("orderedRules", 'r',
-	            "orderedRules.");
-	  
-	public FlagOption anomalyDetectionOption = new FlagOption("anomalyDetection", 'u',
-				"anomaly Detection.");
-	
-	public FlagOption Supervised = new FlagOption("supervised", 'n',
-			"supervised.");
-	
-	public FlagOption Unsupervised = new FlagOption("unsupervised", 'm',
-			"unsupervised.");
-		
-		
-	  
-	@Override
-	public Prediction getPredictionForInstance(Instance inst) {
-		double[] votes = new double[this.numClass];
-		switch (this.predictionFunctionOption.getChosenIndex()) {
-		case 0:
-			votes = firstHit(inst);
-			break; 
-        case 1:
-        	votes = weightedSum(inst);
-        	break; 
-        case 2:
-        	votes = weightedMax(inst);
-        	break;
-		  }
-		return new ClassificationPrediction(votes); 
-	}
-	
-	@Override
-	protected Measurement[] getModelMeasurementsImpl() {
-		return null;
-		}
-	
-	@Override
-	public void resetLearningImpl() {
-		this.observedClassDistribution = new DoubleVector();
-        this.attributeObservers = new AutoExpandVector<AttributeClassObserver>();
-        this.attributeObserversGauss = new AutoExpandVector<AttributeClassObserver>();	
-	}
-	
-	public double getWeightSeen() {
-		return this.observedClassDistribution.sumOfValues(); 
-      }
-
-	@Override
-	public void trainOnInstanceImpl(Instance inst) {
-		int countRuleFiredTrue = 0;
-		boolean ruleFired = false;
-		this.instance = inst;
-		this.numAttributes = instance.numAttributes()-1;
-		this.numClass = instance.numClasses();
-		this.numInstance = numInstance + 1;
-		int conta1=0;
-		for (int j = 0; j < ruleSet.size(); j++) {
-			if (this.ruleSet.get(j).ruleEvaluate(inst) == true) {
-				countRuleFiredTrue = countRuleFiredTrue + 1;
-				
-				double anomaly = 0.0;
-				if(this.Supervised.isSet()){
-					anomaly = computeAnomalySupervised(this.ruleSet.get(j), j, inst); // compute anomaly (Supervised method)
-				}else if(this.Unsupervised.isSet()){
-					anomaly = computeAnomalyUnsupervised(this.ruleSet.get(j), j, inst); // compute anomaly (Unsupervised method)
-				}
-				
-				if(anomaly >= this.anomalyProbabilityThresholdOption.getValue()){
-				conta1 =conta1+1;
-				}
-			//	System.out.print(numInstance+";"+anomaly+"\n");
-				 try {
-		       	        
-	           		  File dir = new File("SeaAnomaliesUnsupervised.txt");
-	           		  FileWriter fileWriter = new FileWriter(dir, true); 
-	           		  PrintWriter printWriter = new PrintWriter(fileWriter);
-	              	  printWriter.println(numInstance+";"+anomaly);
-	           		  printWriter.flush();
-	           		  printWriter.close();      
-	           	       
-	    			} catch (IOException e) {
-	    				e.printStackTrace();
-	    			}
-				 if((this.ruleSet.get(j).instancesSeen <= this.anomalyNumInstThresholdOption.getValue()) || (anomaly < this.anomalyProbabilityThresholdOption.getValue() && this.anomalyDetectionOption.isSet()) ||!this.anomalyDetectionOption.isSet()){
-				this.ruleSet.get(j).obserClassDistrib.addToValue((int) inst.classValue(), inst.weight());
-				for (int i = 0; i < inst.numAttributes() - 1; i++) {
-					int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
-					
-					if(!inst.isMissing(instAttIndex)){
-		            AttributeClassObserver obs = this.ruleSet.get(j).observers.get(i);		// Nominal and binary tree.
-		            AttributeClassObserver obsGauss = this.ruleSet.get(j).observersGauss.get(i);		// Gaussian.
-		            if (obs == null) {
-		                obs = inst.attribute(instAttIndex).isNominal() ? newNominalClassObserver()
-		                        : newNumericClassObserver();
-		                this.ruleSet.get(j).observers.set(i, obs);     
-		            }
-		            if (obsGauss == null) {
-		                obsGauss = inst.attribute(instAttIndex).isNumeric() ? newNumericClassObserver2():null;
-		                this.ruleSet.get(j).observersGauss.set(i, obsGauss);     
-		            }
-		            obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
-		            if (inst.attribute(instAttIndex).isNumeric()) {
-		            	obsGauss.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
-		            }  
-	            }
-				}
-				expandeRule(this.ruleSet.get(j), inst, j); // This function expands the rule
-				}
-		        if (this.orderedRulesOption.isSet()) {	// Ordered rules
-		        	break;
-		        	}
-		        }
-			}
-		if (countRuleFiredTrue > 0) {
-			ruleFired = true;
-			}else{
-				ruleFired = false;
-		    }
-		if (ruleFired == false) { //If none of the rules cover the example update sufficient statistics of the default rule
-			this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight());
-			for (int i = 0; i < inst.numAttributes() - 1; i++) {
-				int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
-				if(!inst.isMissing(instAttIndex)){
-				AttributeClassObserver obs = this.attributeObservers.get(i);
-			    AttributeClassObserver obsGauss = this.attributeObserversGauss.get(i);
-			    if (obs == null) {
-			    	obs = inst.attribute(instAttIndex).isNominal() ? newNominalClassObserver()
-			    			: newNumericClassObserver();
-			    	this.attributeObservers.set(i, obs); 
-			    	}
-			    if (obsGauss == null) {
-			    	obsGauss = inst.attribute(instAttIndex).isNumeric() ? newNumericClassObserver2():null;
-			    	this.attributeObserversGauss.set(i, obsGauss);
-			    	}
-			    obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
-			    if (inst.attribute(instAttIndex).isNumeric()) {
-			    	obsGauss.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
-			    	}
-			    }
-			}
-			createRule(inst); //This function creates a rule
-			}
-		}
-	
-	@Override	
-	public void getModelDescription(StringBuilder out, int indent) {
-		if(this.anomalyDetectionOption.isSet()){
-			if(this.Supervised.isSet()){
-				this.printAnomaliesSupervised(out, indent); // Get Model Description (Supervised method)
-			}else if(this.Unsupervised.isSet()){
-				this.printAnomaliesUnsupervised(out, indent); // Get Model Description (Unsupervised method)
-			}
-		}else{
-			this.getModelDescriptionNoAnomalyDetection(out, indent);  // Get Model Description no Anomaly detection
-			
-			}
-		}
-	
-	public void printAnomaliesUnsupervised(StringBuilder out, int indent) { // Get Model Description (Unsupervised method)
-		
-		StringUtils.appendNewline(out);
-		StringUtils.appendIndented(out, indent, "**********************UNSUPERVISED*****************");
-		StringUtils.appendNewline(out);
-		StringUtils.appendNewline(out);
-        for (int k = 0; k < this.ruleSetAnomalies.size(); k++) {
-        	StringUtils.appendIndented(out, indent, "Case: "+this.caseAnomaly.get(k).get(0)+"   Anomaly Score: "+this.caseAnomaly.get(k).get(1)+"%");
-			StringUtils.appendNewline(out); //Ver outra parte default
-			StringUtils.appendIndented(out, indent, "Rule "+this.ruleAnomaliesIndex.get(k)+": ");
-        	for (int i = 0; i < this.ruleSetAnomalies.get(k).predicateSet.size(); i++) {
-        		if (this.ruleSetAnomalies.get(k).predicateSet.size() == 1) {
-        			if (this.ruleSetAnomalies.get(k).predicateSet.get(i).getSymbol() == 0.0) {
-    					String nam = this.instance.attribute((int)this.ruleSetAnomalies.get(k).predicateSet.get(i).getAttributeValue()).name();
-    					String val = this.instance.attribute((int)this.ruleSetAnomalies.get(k).predicateSet.get(i).getAttributeValue()).value((int)this.ruleSetAnomalies.get(k).predicateSet.get(i).getValue());
-    					StringUtils.appendIndented(out, indent, nam+" = "+val+" --> "+this.instance.classAttribute().value((int)getRuleMajorityClassIndex(this.ruleSetAnomalies.get(k))));
-    					StringUtils.appendNewline(out);
-    					} else if (this.ruleSetAnomalies.get(k).predicateSet.get(i).getSymbol() == -1.0){
-    						String nam = this.instance.attribute((int)this.ruleSetAnomalies.get(k).predicateSet.get(i).getAttributeValue()).name();
-    						StringUtils.appendIndented(out, indent, nam+" <= "+this.ruleSetAnomalies.get(k).predicateSet.get(i).getValue()+" --> "+this.instance.classAttribute().value((int)ruleClassIndex.getValue(ruleAnomaliesIndex.get(k)-1)));
-    					    StringUtils.appendNewline(out);
-    					    } else {
-    					    	String nam = this.instance.attribute((int)this.ruleSetAnomalies.get(k).predicateSet.get(i).getAttributeValue()).name();
-    			                StringUtils.appendIndented(out, indent, nam+" > "+this.ruleSetAnomalies.get(k).predicateSet.get(i).getValue()+" --> "+this.instance.classAttribute().value((int)this.ruleClassIndex.getValue(ruleAnomaliesIndex.get(k)-1)));
-    					        StringUtils.appendNewline(out);
-    					        }
-        			} else {
-        				if (this.ruleSetAnomalies.get(k).predicateSet.get(i).getSymbol() == 0.0) {
-        					String nam = this.instance.attribute((int)this.ruleSetAnomalies.get(k).predicateSet.get(i).getAttributeValue()).name();
-    					    String val = this.instance.attribute((int)this.ruleSetAnomalies.get(k).predicateSet.get(i).getAttributeValue()).value((int)this.ruleSetAnomalies.get(k).predicateSet.get(i).getValue());
-    					    StringUtils.appendIndented(out, indent, nam+" = "+val+" ");
-    					    } else if (this.ruleSetAnomalies.get(k).predicateSet.get(i).getSymbol()==-1.0){
-    					    	String nam = this.instance.attribute((int)this.ruleSetAnomalies.get(k).predicateSet.get(i).getAttributeValue()).name();
-    					        StringUtils.appendIndented(out, indent, nam+" <= "+this.ruleSetAnomalies.get(k).predicateSet.get(i).getValue()+" ");
-    					        } else {
-    					        	String nam = this.instance.attribute((int)this.ruleSetAnomalies.get(k).predicateSet.get(i).getAttributeValue()).name();
-    					        	StringUtils.appendIndented(out, indent, nam+" > "+this.ruleSetAnomalies.get(k).predicateSet.get(i).getValue()+" ");
-    					        	}
-        				if (i < this.ruleSetAnomalies.get(k).predicateSet.size() - 1) {
-        					StringUtils.appendIndented(out, indent, "and ");
-        					} else {
-        						int count = getCountNominalAttrib(this.ruleSetAnomalies.get(k).predicateSet);
-        						if ((this.ruleSetAnomalies.get(k).predicateSet.get(i).getSymbol() == 0.0) || (count != 0)) {
-        							StringUtils.appendIndented(out, indent, " --> "+this.instance.classAttribute().value((int)getRuleMajorityClassIndex(this.ruleSetAnomalies.get(k))));
-                    		        StringUtils.appendNewline(out);
-                    		        } else {
-                    		        	StringUtils.appendIndented(out, indent, " --> "+this.instance.classAttribute().value((int)this.ruleClassIndex.getValue(ruleAnomaliesIndex.get(k)-1)));
-                    		            StringUtils.appendNewline(out);
-                    		            }
-        						}
-        				}
-        		}
-        	for(int z=0; z < this.ruleAttribAnomalyStatistics.get(k).size(); z++) {
-        		if(this.ruleAttribAnomalyStatistics.get(k).get(z).size() == 5){
-				String s = String.format ("%.3e", this.ruleAttribAnomalyStatistics.get(k).get(z).get(4)); 
-				StringUtils.appendIndented(out, indent, instance.attribute(this.ruleAttribAnomalyStatistics.get(k).get(z).get(0).intValue()).name()+"="+round(this.ruleAttribAnomalyStatistics.get(k).get(z).get(1))+"   ("+round(this.ruleAttribAnomalyStatistics.get(k).get(z).get(2))+" +- "+round(this.ruleAttribAnomalyStatistics.get(k).get(z).get(3))+")   P="+s);
-				StringUtils.appendNewline(out);
-			} else {
-				String s = String.format ("%.3e", this.ruleAttribAnomalyStatistics.get(k).get(z).get(2));
-				String val = this.instance.attribute(this.ruleAttribAnomalyStatistics.get(k).get(z).get(0).intValue()).value(this.ruleAttribAnomalyStatistics.get(k).get(z).get(1).intValue());
-				StringUtils.appendIndented(out, indent, instance.attribute(this.ruleAttribAnomalyStatistics.get(k).get(z).get(0).intValue()).name()+"="+ val+"   P="+s);
-				StringUtils.appendNewline(out);
-			}
-    		
-    	}
-		StringUtils.appendNewline(out);
-	}
-			
-	}
-	
-	
-public void printAnomaliesSupervised(StringBuilder out, int indent) { // Get Model Description (Supervised method)
-		
-		StringUtils.appendNewline(out);
-		StringUtils.appendIndented(out, indent, "************************SUPERVISED*******************");
-		StringUtils.appendNewline(out);
-		StringUtils.appendNewline(out);
-        for (int k = 0; k < this.ruleSetAnomaliesSupervised.size(); k++) {
-        	StringUtils.appendIndented(out, indent, "Case: "+this.caseAnomalySupervised.get(k).get(0)+"   Anomaly Score: "+this.caseAnomalySupervised.get(k).get(1)+"%");
-			StringUtils.appendNewline(out); //Ver outra parte default
-			StringUtils.appendIndented(out, indent, "Rule "+this.ruleAnomaliesIndexSupervised.get(k)+": ");
-        	for (int i = 0; i < this.ruleSetAnomaliesSupervised.get(k).predicateSet.size(); i++) {
-        		if (this.ruleSetAnomaliesSupervised.get(k).predicateSet.size() == 1) {
-        			if (this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getSymbol() == 0.0) {
-    					String nam = this.instance.attribute((int)this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getAttributeValue()).name();
-    					String val = this.instance.attribute((int)this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getAttributeValue()).value((int)this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getValue());
-    					StringUtils.appendIndented(out, indent, nam+" = "+val+" --> "+this.instance.classAttribute().value((int)getRuleMajorityClassIndex(this.ruleSetAnomaliesSupervised.get(k))));
-    					StringUtils.appendNewline(out);
-    					} else if (this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getSymbol() == -1.0){
-    						String nam = this.instance.attribute((int)this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getAttributeValue()).name();
-    						StringUtils.appendIndented(out, indent, nam+" <= "+this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getValue()+" --> "+this.instance.classAttribute().value((int)ruleClassIndex.getValue(ruleAnomaliesIndexSupervised.get(k)-1)));
-    					    StringUtils.appendNewline(out);
-    					    } else {
-    					    	String nam = this.instance.attribute((int)this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getAttributeValue()).name();
-    			                StringUtils.appendIndented(out, indent, nam+" > "+this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getValue()+" --> "+this.instance.classAttribute().value((int)this.ruleClassIndex.getValue(ruleAnomaliesIndexSupervised.get(k)-1)));
-    					        StringUtils.appendNewline(out);
-    					        }
-        			} else {
-        				if (this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getSymbol() == 0.0) {
-        					String nam = this.instance.attribute((int)this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getAttributeValue()).name();
-    					    String val = this.instance.attribute((int)this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getAttributeValue()).value((int)this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getValue());
-    					    StringUtils.appendIndented(out, indent, nam+" = "+val+" ");
-    					    } else if (this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getSymbol()==-1.0){
-    					    	String nam = this.instance.attribute((int)this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getAttributeValue()).name();
-    					        StringUtils.appendIndented(out, indent, nam+" <= "+this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getValue()+" ");
-    					        } else {
-    					        	String nam = this.instance.attribute((int)this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getAttributeValue()).name();
-    					        	StringUtils.appendIndented(out, indent, nam+" > "+this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getValue()+" ");
-    					        	}
-        				if (i < this.ruleSetAnomaliesSupervised.get(k).predicateSet.size() - 1) {
-        					StringUtils.appendIndented(out, indent, "and ");
-        					} else {
-        						int count = getCountNominalAttrib(this.ruleSetAnomaliesSupervised.get(k).predicateSet);
-        						if ((this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getSymbol() == 0.0) || (count != 0)) {
-        							StringUtils.appendIndented(out, indent, " --> "+this.instance.classAttribute().value((int)getRuleMajorityClassIndex(this.ruleSetAnomaliesSupervised.get(k))));
-                    		        StringUtils.appendNewline(out);
-                    		        } else {
-                    		        	StringUtils.appendIndented(out, indent, " --> "+this.instance.classAttribute().value((int)this.ruleClassIndex.getValue(ruleAnomaliesIndexSupervised.get(k)-1)));
-                    		            StringUtils.appendNewline(out);
-                    		            }
-        						}
-        				}
-        		}
-        	for(int z=0; z < this.ruleAttribAnomalyStatisticsSupervised.get(k).size(); z++) {
-        		if(this.ruleAttribAnomalyStatisticsSupervised.get(k).get(z).size() == 5){
-				String s = String.format ("%.3e", this.ruleAttribAnomalyStatisticsSupervised.get(k).get(z).get(4)); 
-				StringUtils.appendIndented(out, indent, instance.attribute(this.ruleAttribAnomalyStatisticsSupervised.get(k).get(z).get(0).intValue()).name()+"="+round(this.ruleAttribAnomalyStatisticsSupervised.get(k).get(z).get(1))+"   ("+round(this.ruleAttribAnomalyStatisticsSupervised.get(k).get(z).get(2))+" +- "+round(this.ruleAttribAnomalyStatisticsSupervised.get(k).get(z).get(3))+")   P="+s);
-				StringUtils.appendNewline(out);
-			} else {
-				String s = String.format ("%.3e", this.ruleAttribAnomalyStatisticsSupervised.get(k).get(z).get(2));
-				String val = this.instance.attribute(this.ruleAttribAnomalyStatisticsSupervised.get(k).get(z).get(0).intValue()).value(this.ruleAttribAnomalyStatisticsSupervised.get(k).get(z).get(1).intValue());
-				StringUtils.appendIndented(out, indent, instance.attribute(this.ruleAttribAnomalyStatisticsSupervised.get(k).get(z).get(0).intValue()).name()+"="+ val+"   P="+s);
-				StringUtils.appendNewline(out);
-			}
-    		
-    	}
-		StringUtils.appendNewline(out);
-	}
-			
-	}
-	
-	
-	public void getModelDescriptionNoAnomalyDetection(StringBuilder out, int indent) { // Get Model Description no Anomaly detection
-		StringUtils.appendNewline(out);
-        StringUtils.appendIndented(out, indent, "Number of Rule: " + ruleSet.size());
-        StringUtils.appendNewline(out);
-        StringUtils.appendNewline(out);
-        for (int k = 0; k < this.ruleSet.size(); k++) {
-        	StringUtils.appendIndented(out, indent, "Rule "+(k+1)+": ");
-        	for (int i = 0; i < this.ruleSet.get(k).predicateSet.size(); i++) {
-        		if (this.ruleSet.get(k).predicateSet.size() == 1) {
-        			if (this.ruleSet.get(k).predicateSet.get(i).getSymbol() == 0.0) {
-    					String nam = this.instance.attribute((int)this.ruleSet.get(k).predicateSet.get(i).getAttributeValue()).name();
-    					String val = this.instance.attribute((int)this.ruleSet.get(k).predicateSet.get(i).getAttributeValue()).value((int)this.ruleSet.get(k).predicateSet.get(i).getValue());
-    					StringUtils.appendIndented(out, indent, nam+" = "+val+" --> "+this.instance.classAttribute().value((int)getRuleMajorityClassIndex(this.ruleSet.get(k))));
-    					StringUtils.appendNewline(out);
-    					} else if (this.ruleSet.get(k).predicateSet.get(i).getSymbol() == -1.0){
-    						String nam = this.instance.attribute((int)this.ruleSet.get(k).predicateSet.get(i).getAttributeValue()).name();
-    						StringUtils.appendIndented(out, indent, nam+" <= "+this.ruleSet.get(k).predicateSet.get(i).getValue()+" --> "+this.instance.classAttribute().value((int)ruleClassIndex.getValue(k)));
-    					    StringUtils.appendNewline(out);
-    					    } else {
-    					    	String nam = this.instance.attribute((int)this.ruleSet.get(k).predicateSet.get(i).getAttributeValue()).name();
-    			                StringUtils.appendIndented(out, indent, nam+" > "+this.ruleSet.get(k).predicateSet.get(i).getValue()+" --> "+this.instance.classAttribute().value((int)this.ruleClassIndex.getValue(k)));
-    					        StringUtils.appendNewline(out);
-    					        }
-        			} else {
-        				if (this.ruleSet.get(k).predicateSet.get(i).getSymbol() == 0.0) {
-        					String nam = this.instance.attribute((int)this.ruleSet.get(k).predicateSet.get(i).getAttributeValue()).name();
-    					    String val = this.instance.attribute((int)this.ruleSet.get(k).predicateSet.get(i).getAttributeValue()).value((int)this.ruleSet.get(k).predicateSet.get(i).getValue());
-    					    StringUtils.appendIndented(out, indent, nam+" = "+val+" ");
-    					    } else if (this.ruleSet.get(k).predicateSet.get(i).getSymbol()==-1.0){
-    					    	String nam = this.instance.attribute((int)this.ruleSet.get(k).predicateSet.get(i).getAttributeValue()).name();
-    					        StringUtils.appendIndented(out, indent, nam+" <= "+this.ruleSet.get(k).predicateSet.get(i).getValue()+" ");
-    					        } else {
-    					        	String nam = this.instance.attribute((int)this.ruleSet.get(k).predicateSet.get(i).getAttributeValue()).name();
-    					        	StringUtils.appendIndented(out, indent, nam+" > "+this.ruleSet.get(k).predicateSet.get(i).getValue()+" ");
-    					        	}
-        				if (i < this.ruleSet.get(k).predicateSet.size() - 1) {
-        					StringUtils.appendIndented(out, indent, "and ");
-        					} else {
-        						int count = getCountNominalAttrib(this.ruleSet.get(k).predicateSet);
-        						if ((this.ruleSet.get(k).predicateSet.get(i).getSymbol() == 0.0) || (count != 0)) {
-        							StringUtils.appendIndented(out, indent, " --> "+this.instance.classAttribute().value((int)getRuleMajorityClassIndex(this.ruleSet.get(k))));
-                    		        StringUtils.appendNewline(out);
-                    		        } else {
-                    		        	StringUtils.appendIndented(out, indent, " --> "+this.instance.classAttribute().value((int)this.ruleClassIndex.getValue(k)));
-                    		            StringUtils.appendNewline(out);
-                    		            }
-        						}
-        				}
-        		}
-        	StringUtils.appendNewline(out);
-        	}
-        }
-	
-	
-	@Override
-	public boolean isRandomizable() {
-		return false;
-	}
-	
-	public int getCountNominalAttrib(ArrayList<Predicates> predicateSet) {
-		int count = 0;
-		for (int i = 0; i < predicateSet.size(); i++) {
-			if (predicateSet.get(i).getSymbol() == 0.0) {
-				count = count + 1;
-				break;
-			}
-		}
-		return count;
-	}
-	
-	//Round an number
-	protected BigDecimal round(double val){
-		BigDecimal value = new BigDecimal(val);
-		if(val!=0.0){
-			value = value.setScale(3, BigDecimal.ROUND_DOWN);
-		}
-		return value;
-	}
-	
-	
-	//This function initializes the statistics of a rule 
-	public void initializeRuleStatistics(RuleClassification rl, Predicates pred, Instance inst) {
-		rl.predicateSet.add(pred);
-		rl.obserClassDistrib=new DoubleVector();
-		rl.observers=new AutoExpandVector<AttributeClassObserver>();
-		rl.observersGauss=new AutoExpandVector<AttributeClassObserver>();
-		rl.instancesSeen = 0;
-		rl.attributeStatistics = new DoubleVector();
-		rl.squaredAttributeStatistics = new DoubleVector();
-		rl.attributeStatisticsSupervised = new ArrayList<ArrayList<Double>>();
-		rl.squaredAttributeStatisticsSupervised = new ArrayList<ArrayList<Double>>();
-		rl.attributeMissingValues = new DoubleVector();
-	}
-	
-	// Update rule statistics
-	public void updateRuleAttribStatistics(Instance inst, RuleClassification rl, int ruleIndex){
-		rl.instancesSeen++; 
-		if(rl.squaredAttributeStatisticsSupervised.size() == 0 && rl.attributeStatisticsSupervised.size() == 0){
-			for (int s = 0; s < inst.numAttributes() -1; s++) {
-				ArrayList<Double> temp1 = new ArrayList<Double>();
-				ArrayList<Double> temp2 = new ArrayList<Double>();
-				rl.attributeStatisticsSupervised.add(temp1);
-				rl.squaredAttributeStatisticsSupervised.add(temp2);
-				int instAttIndex = modelAttIndexToInstanceAttIndex(s, inst);
-				if(instance.attribute(instAttIndex).isNumeric()){
-					for(int i=0; i<inst.numClasses(); i++){
-						rl.attributeStatisticsSupervised.get(s).add(0.0);
-						rl.squaredAttributeStatisticsSupervised.get(s).add(1.0);
-					}
-					}
-				}
-			}
-		for (int s = 0; s < inst.numAttributes() -1; s++) {
-			int instAttIndex = modelAttIndexToInstanceAttIndex(s, inst);
-			if(!inst.isMissing(instAttIndex)){
-			if(instance.attribute(instAttIndex).isNumeric()){
-			rl.attributeStatistics.addToValue(s, inst.value(s));	
-			rl.squaredAttributeStatistics.addToValue(s, inst.value(s) * inst.value(s));
-			double sumValue = rl.attributeStatisticsSupervised.get(s).get((int)inst.classValue()) + inst.value(s);
-			rl.attributeStatisticsSupervised.get(s).set((int)inst.classValue(), sumValue);
-			double squaredSumvalue = rl.squaredAttributeStatisticsSupervised.get(s).get((int)inst.classValue()) + (inst.value(s) * inst.value(s));
-			rl.squaredAttributeStatisticsSupervised.get(s).set((int)inst.classValue(), squaredSumvalue);
-			}
-			}else{
-				rl.attributeMissingValues.addToValue(s, 1);
-				}
-			}
-		}
-	
-	//Compute anomalies unsupervised
-	public double computeAnomalyUnsupervised(RuleClassification rl, int ruleIndex, Instance inst) { //Unsupervised
-		ArrayList<Integer> caseAnomalyTemp = new ArrayList<Integer>();
-	    ArrayList<ArrayList<Double>> AttribAnomalyStatisticTemp2 = new ArrayList<ArrayList<Double>>();
-	    double D = 0.0;
-		double N = 0.0;
-		
-		
-		if (rl.instancesSeen > this.anomalyNumInstThresholdOption.getValue() && this.anomalyDetectionOption.isSet()) { 
-			for (int x = 0; x < inst.numAttributes() - 1; x++) {
-				if(!inst.isMissing(x)){
-					ArrayList<Double> AttribAnomalyStatisticTemp = new ArrayList<Double>();
-					if (inst.attribute(x).isNumeric()) { //Numeric Attributes
-						if((rl.instancesSeen - rl.attributeMissingValues.getValue(x)) > 30){
-						double mean = computeMean(rl.attributeStatistics.getValue(x), rl.instancesSeen);
-						double sd = computeSD(rl.squaredAttributeStatistics.getValue(x),rl.attributeStatistics.getValue(x), rl.instancesSeen);
-						double probability = computeProbability(mean, sd, inst.value(x));
-						if(probability!=0.0) {
-							D = D + Math.log(probability);
-							if(probability < this.probabilityThresholdOption.getValue()){  //0.10
-								N = N + Math.log(probability);
-			            	 	AttribAnomalyStatisticTemp.add((double)x);
-			            	    AttribAnomalyStatisticTemp.add(inst.value(x));
-				                AttribAnomalyStatisticTemp.add(mean);
-				            	AttribAnomalyStatisticTemp.add(sd);
-				            	AttribAnomalyStatisticTemp.add(probability);
-				            	AttribAnomalyStatisticTemp2.add(AttribAnomalyStatisticTemp);
-				            	}
-							}
-						}
-					}else { //Nominal Attributes
-							AutoExpandVector<DoubleVector> attribNominal = ((NominalAttributeClassObserver)rl.observers.get(x)).attValDistPerClass; //Attributes values distribution per class
-							double numbAttribValue = 0.0;
-							double attribVal = inst.value(x); //Attribute value
-							for(int i = 0; i < attribNominal.size(); i++){
-								if(attribNominal.get(i) != null){
-									numbAttribValue = numbAttribValue + attribNominal.get(i).getValue((int)attribVal); 
-								}
-							}
-							double probability = numbAttribValue / rl.instancesSeen;
-							if(probability!= 0.0) {
-								D = D + Math.log(probability);
-								if(probability < this.probabilityThresholdOption.getValue()){  //0.10
-									N = N + Math.log(probability);
-				            	 	AttribAnomalyStatisticTemp.add((double)x);
-				            	    AttribAnomalyStatisticTemp.add(inst.value(x));
-					            	AttribAnomalyStatisticTemp.add(probability);
-					            	AttribAnomalyStatisticTemp2.add(AttribAnomalyStatisticTemp);
-					            	}
-								}
-							}
-					}
-				}
-			}
-		double anomaly=0.0;
-		if(D !=0){
-		 anomaly = Math.abs(N/D);
-		}
-		if(anomaly >= this.anomalyProbabilityThresholdOption.getValue()){
-			caseAnomalyTemp.add(this.numInstance);
-			double val = anomaly * 100;
-			caseAnomalyTemp.add((int)val);
-			this.caseAnomaly.add(caseAnomalyTemp);
-			RuleClassification x = new RuleClassification(this.ruleSet.get(ruleIndex));
-			this.ruleSetAnomalies.add(x);
-			this.ruleAnomaliesIndex.add(ruleIndex + 1);
-			this.ruleAttribAnomalyStatistics.add(AttribAnomalyStatisticTemp2);
-			
-			
-		}
-		return anomaly;
-	}
-	
-	
-	
-	//Compute anomalies unsupervised
-		public double computeAnomalySupervised(RuleClassification rl, int ruleIndex, Instance inst) { //Not supervised
-			ArrayList<Integer> caseAnomalyTemp = new ArrayList<Integer>();
-		    ArrayList<ArrayList<Double>> AttribAnomalyStatisticTemp2 = new ArrayList<ArrayList<Double>>();
-		    double D = 0.0;
-			double N = 0.0;
-			if (rl.instancesSeen > this.anomalyNumInstThresholdOption.getValue() && this.anomalyDetectionOption.isSet()) { 
-				for (int x = 0; x < inst.numAttributes() - 1; x++) {
-					if(!inst.isMissing(x)){
-						ArrayList<Double> AttribAnomalyStatisticTemp = new ArrayList<Double>();
-						if (inst.attribute(x).isNumeric()) { //Numeric Attributes
-							if((rl.instancesSeen - rl.attributeMissingValues.getValue(x)) > 30){
-								double mean = computeMean((double)rl.attributeStatisticsSupervised.get(x).get((int)inst.classValue()), (int)rl.obserClassDistrib.getValue((int)inst.classValue()));
-								double sd = computeSD((double)rl.squaredAttributeStatisticsSupervised.get(x).get((int)inst.classValue()), (double)rl.attributeStatisticsSupervised.get(x).get((int)inst.classValue()), (int)rl.obserClassDistrib.getValue((int)inst.classValue()));
-								double probability = computeProbability(mean, sd, inst.value(x));
-								if(probability!=0.0) {
-									D = D + Math.log(probability);
-									if(probability < this.probabilityThresholdOption.getValue()){  //0.10
-										N = N + Math.log(probability);
-					            	 	AttribAnomalyStatisticTemp.add((double)x);
-					            	    AttribAnomalyStatisticTemp.add(inst.value(x));
-						                AttribAnomalyStatisticTemp.add(mean);
-						            	AttribAnomalyStatisticTemp.add(sd);
-						            	AttribAnomalyStatisticTemp.add(probability);
-						            	AttribAnomalyStatisticTemp2.add(AttribAnomalyStatisticTemp);
-						            	}
-									}
-								}
-							}else { //Nominal
-								double attribVal = inst.value(x); //Attribute value
-								double classVal = inst.classValue(); //Attribute value
-								double probability = rl.observers.get(x).probabilityOfAttributeValueGivenClass(attribVal, (int)classVal);
-								if(probability!=0.0) {
-									D = D + Math.log(probability);
-									if(probability < this.probabilityThresholdOption.getValue()){  //0.10
-										N = N + Math.log(probability);
-					            	 	AttribAnomalyStatisticTemp.add((double)x);
-					            	    AttribAnomalyStatisticTemp.add(inst.value(x));
-						            	AttribAnomalyStatisticTemp.add(probability);
-						            	AttribAnomalyStatisticTemp2.add(AttribAnomalyStatisticTemp);
-						            	}
-									}
-								}
-						}
-					}
-				}
-			double anomaly=0.0;
-			if(D !=0){
-			 anomaly = Math.abs(N/D);
-			}
-			if(anomaly >= this.anomalyProbabilityThresholdOption.getValue()){
-				caseAnomalyTemp.add(this.numInstance);
-				double val = anomaly * 100;
-				caseAnomalyTemp.add((int)val);
-				this.caseAnomalySupervised.add(caseAnomalyTemp);
-				RuleClassification y = new RuleClassification(this.ruleSet.get(ruleIndex));
-				this.ruleSetAnomaliesSupervised.add(y);
-				this.ruleAnomaliesIndexSupervised.add(ruleIndex + 1);
-				this.ruleAttribAnomalyStatisticsSupervised.add(AttribAnomalyStatisticTemp2);
-			}
-			return anomaly;
-			}
-		
-	//Mean
-	public  double computeMean(double sum, int size) {
-		return sum / size;
-	}
-		
-	//Standard Deviation
-	public  double computeSD(double squaredVal, double val, int size) {
-		return  Math.sqrt((squaredVal - ((val * val) / size)) / size);
-	}
-	
-	//Attribute probability
-	public double computeProbability(double mean, double sd, double value) {
-		sd = sd + 0.00001;
-		double probability = 0.0;
-		double diff = value - mean;
-		if (sd > 0.0) {
-			 	double k = (Math.abs(value - mean)/sd);
-			 	if (k > 1.0) {
-			 		probability = 1.0/(k*k);
-			 	}
-			 	else {
-			 		probability=  Math.exp(-(diff * diff / (2.0 * sd * sd)));
-			 	}
-		 }
-		return probability;
-	}
-	
-	//This function creates a rule
-	public void createRule(Instance inst) {
-		int remainder = (int)Double.MAX_VALUE;
-		int numInstanciaObservers = (int)this.observedClassDistribution.sumOfValues();
-		if (numInstanciaObservers != 0 && this.gracePeriodOption.getValue() != 0) {
-			remainder = (numInstanciaObservers) % (this.gracePeriodOption.getValue());
-			}
-		if (remainder == 0) {
-			this.saveBestValGlobalEntropy = new ArrayList<ArrayList<Double>>();
-			this.saveBestGlobalEntropy = new DoubleVector();
-			this.saveTheBest = new ArrayList<Double>();
-			this.minEntropyTemp = Double.MAX_VALUE;
-			this.minEntropyNominalAttrib = Double.MAX_VALUE;
-			theBestAttributes(inst, this.attributeObservers);
-            boolean HB = checkBestAttrib(numInstanciaObservers, this.attributeObservers, this.observedClassDistribution);
-            if (HB == true) {
-            //	System.out.print("this.saveTheBest"+this.saveTheBest+"\n");
-            	double attributeValue = this.saveTheBest.get(3);
-    			double symbol = this.saveTheBest.get(2);		// =, <=, > : (0.0, -1.0, 1.0).
-    			double value = this.saveTheBest.get(0);		// Value of the attribute
-    			this.pred = new Predicates(attributeValue, symbol, value);
-    			RuleClassification Rl = new RuleClassification();		// Create RuleClassification.
-    			Rl.predicateSet.add(pred);
-    			this.ruleSet.add(Rl);
-    			if (Rl.predicateSet.get(0).getSymbol() == -1.0 ||Rl.predicateSet.get(0).getSymbol() == 1.0) {
-    				double posClassDouble = this.saveTheBest.get(4);
-    				this.ruleClassIndex.setValue(this.ruleSet.size()-1, posClassDouble);	
-    				}else{
-    						this.ruleClassIndex.setValue(ruleSet.size()-1, 0.0);
-    						}
-					this.observedClassDistribution = new DoubleVector();
-					this.attributeObservers = new AutoExpandVector<AttributeClassObserver>(); 
-					this.attributeObserversGauss = new AutoExpandVector<AttributeClassObserver>();
-			   	}
-            }
-	}
-	
-	//This function This expands the rule
-	public void expandeRule(RuleClassification rl, Instance inst, int ruleIndex) {
-		int remainder = (int)Double.MAX_VALUE;
-		int numInstanciaObservers = (int)rl.obserClassDistrib.sumOfValues();		// Number of instances for this rule observers.
-		this.updateRuleAttribStatistics(inst, rl, ruleIndex);
-	    if (numInstanciaObservers != 0 && this.gracePeriodOption.getValue() != 0) {
-	        	 remainder = (numInstanciaObservers) % (this.gracePeriodOption.getValue());    
-	        }
-        if (remainder == 0){
-        	this.saveBestValGlobalEntropy = new ArrayList<ArrayList<Double>>();
-			this.saveBestGlobalEntropy = new DoubleVector();
-			this.saveTheBest = new ArrayList<Double>();
-			this.minEntropyTemp = Double.MAX_VALUE;
-			this.minEntropyNominalAttrib = Double.MAX_VALUE;
-	        theBestAttributes(inst, rl.observers);		// The best value of entropy for each attribute.
-            boolean HB = checkBestAttrib(numInstanciaObservers, rl.observers, rl.obserClassDistrib);		// Check if the best attribute value is really the best.
-    		if (HB == true) {
-    			double attributeValue = this.saveTheBest.get(3);
-    			double symbol = this.saveTheBest.get(2);		// =, <=, > (0.0, -1.0, 1.0).
-    			double value = this.saveTheBest.get(0);		// Value of the attribute.
-    			this.pred = new Predicates(attributeValue, symbol, value);
-    			int countPred = 0;
-    			for (int i = 0; i < rl.predicateSet.size(); i++) {		// Checks if the new predicate is not yet in the predicateSet. 
-					 if (this.pred.getSymbol() == 0.0) {		// Nominal Attribute.
-						 if (rl.predicateSet.get(i).getAttributeValue() != this.pred.getAttributeValue()) {
-							 countPred = countPred + 1;
-						 }
-					 }
-					 else {
-						 if (rl.predicateSet.get(i).getAttributeValue() != this.pred.getAttributeValue() 
-								 || rl.predicateSet.get(i).getSymbol() != this.pred.getSymbol() 
-								 || rl.predicateSet.get(i).getValue() != this.pred.getValue()) {
-							 countPred = countPred+1;
-							 }
-						 }
-					 }
-    			if (countPred == rl.predicateSet.size()) {
-    				int countDifPred = 0;
-					ArrayList<Predicates> predicSetTemp = new ArrayList<Predicates>();
-					for (int x = 0; x < rl.predicateSet.size(); x++) {
-						predicSetTemp.add(rl.predicateSet.get(x));
-					 }
-					predicSetTemp.add(this.pred);
-					for (int f = 0; f < this.ruleSet.size(); f++) {
-						int countDifPredTemp = 0;
-						if (this.ruleSet.get(f).predicateSet.size() == predicSetTemp.size()) {
-							for(int x = 0; x < this.ruleSet.get(f).predicateSet.size(); x++) {
-								if (this.ruleSet.get(f).predicateSet.get(x).getAttributeValue() == predicSetTemp.get(x).getAttributeValue() 
-										&& this.ruleSet.get(f).predicateSet.get(x).getSymbol() == predicSetTemp.get(x).getSymbol() 
-										&& this.ruleSet.get(f).predicateSet.get(x).getValue() == predicSetTemp.get(x).getValue()) {
-									countDifPredTemp = countDifPredTemp+1;
-									}
-								}
-							if (countDifPredTemp == predicSetTemp.size()) {
-								break;
-								}else{
-									countDifPred = countDifPred + 1;
-									}
-							}else{
-						countDifPred = countDifPred + 1;
-						}
-						}
-					if (countDifPred == this.ruleSet.size()) {
-						if (this.pred.getSymbol() == 0.0) {
-							initializeRuleStatistics(rl, pred, inst);
-			    			} else if (this.pred.getSymbol() == 1.0) {
-			    				int countIqualPred = 0;
-			    				for (int f = 0; f < rl.predicateSet.size(); f++) {
-			    					if (this.pred.getAttributeValue() == rl.predicateSet.get(f).getAttributeValue()
-			    							&& this.pred.getSymbol() == rl.predicateSet.get(f).getSymbol()) {
-			    						countIqualPred = countIqualPred + 1;
-			    						if (this.pred.getValue() > rl.predicateSet.get(f).getValue()) {
-			    							rl.predicateSet.remove(f);
-			    							initializeRuleStatistics(rl, pred, inst);
-	    				    				}
-			    						}
-			    					}
-			    				if (countIqualPred == 0) {
-			    					initializeRuleStatistics(rl, pred, inst);
-	    				    		}
-			    				}else{
-	    						 int countIqualPred = 0;
-	    						 for (int f = 0; f < rl.predicateSet.size(); f++) {
-	    							 if (this.pred.getAttributeValue() == rl.predicateSet.get(f).getAttributeValue()
-	    									 && this.pred.getSymbol() == rl.predicateSet.get(f).getSymbol()) {
-	    								 countIqualPred = countIqualPred + 1;
-	    								 if (this.pred.getValue() < rl.predicateSet.get(f).getValue()) {
-	    									 rl.predicateSet.remove(f);
-	    									 initializeRuleStatistics(rl, pred, inst);
-	    				    				 }
-	    								 }
-	    							 }
-	    						 if (countIqualPred == 0) {
-	    							 initializeRuleStatistics(rl, pred, inst);
-	    							 }
-	    						 }
-						}
-					}
-    			}
-    		}
-        }
-		
-	// This function gives the best value of entropy for each attribute
-	public void theBestAttributes(Instance instance, 
-			AutoExpandVector<AttributeClassObserver> observersParameter) {
-		for(int z = 0; z < instance.numAttributes() - 1; z++){
-			if(!instance.isMissing(z)){
-			int instAttIndex = modelAttIndexToInstanceAttIndex(z, instance);
-			ArrayList<Double> attribBest = new ArrayList<Double>();
-			if(instance.attribute(instAttIndex).isNominal()){
-				this.minEntropyNominalAttrib=Double.MAX_VALUE;	
-				AutoExpandVector<DoubleVector> attribNominal = ((NominalAttributeClassObserver)observersParameter.get(z)).attValDistPerClass;
-				findBestValEntropyNominalAtt(attribNominal, instance.attribute(z).numValues());		// The best value (lowest entropy) of a nominal attribute.
-	            attribBest.add(this.saveBestEntropyNominalAttrib.getValue(0));
-	            attribBest.add(this.saveBestEntropyNominalAttrib.getValue(1));
-	            attribBest.add(this.saveBestEntropyNominalAttrib.getValue(2));
-	            this.saveBestValGlobalEntropy.add(attribBest);
-	            this.saveBestGlobalEntropy.setValue(z, this.saveBestEntropyNominalAttrib.getValue(1));
-	            } else {
-	            	this.root=((BinaryTreeNumericAttributeClassObserver)observersParameter.get(z)).root;
-					mainFindBestValEntropy(this.root);		// The best value (lowest entropy) of a numeric attribute.
-		            attribBest.add(this.saveBestEntropy.getValue(0));
-		            attribBest.add(this.saveBestEntropy.getValue(1));
-		            attribBest.add(this.saveBestEntropy.getValue(2));
-		            attribBest.add(this.saveBestEntropy.getValue(4));
-		            this.saveBestValGlobalEntropy.add(attribBest);
-		            this.saveBestGlobalEntropy.setValue(z, this.saveBestEntropy.getValue(1));
-		            }
-			}else{
-				 double value = Double.MAX_VALUE;
-				 this.saveBestGlobalEntropy.setValue(z, value);
-				 }
-			}
-	}
-	
-	// Compute Entropy
-	public double entropy(DoubleVector ValorDistClassE) {
-		double entropy = 0.0;
-		double sum = 0.0;
-		for (double d : ValorDistClassE.getArrayCopy()) {
-			if (d > 0.0) {
-				entropy -= d * Utils.log2(d);
-				sum += d;
-				}
-			}
-		return sum > 0.0 ? (entropy + sum * Utils.log2(sum)) / sum : 0.0;
-		}
-	
-	// Get the best value of entropy and its cutPoint for a numeric attribute
-	public void findBestValEntropy(Node node, DoubleVector classCountL, DoubleVector classCountR,
-			boolean status, double minEntropy, DoubleVector parentCCLeft ){
-		if (this.root != null) {
-			if (node != null) {
-				int numClass=0;
-				DoubleVector classCountLTemp = new DoubleVector(); 
-				DoubleVector classCountRTemp = new DoubleVector(); 
-				DoubleVector parentCCL = new DoubleVector();
-				DoubleVector parentCCLParameter = new DoubleVector();
-				for (int f = 0; f < node.classCountsLeft.numValues(); f++) {
-					parentCCLParameter.setValue(f, node.classCountsLeft.getValue(f));
-					}
-				for (int p = 0; p < parentCCLeft.numValues(); p++) {
-					parentCCL.addToValue(p, parentCCLeft.getValue(p));
-					}
-				if (classCountL.numValues() >= classCountR.numValues()) {
-					numClass = classCountL.numValues();
-				} else {
-					numClass = classCountR.numValues();
-				}
-				// Counting the real class count left and the real class count right.
-				if (node.cut_point != this.root.cut_point) {
-					for (int i = 0; i < numClass; i++) {
-						if (status == true) {		// Left node.
-							double parentss = parentCCL.getValue(i) - (node.classCountsLeft.getValue(i) 
-									+ node.classCountsRight.getValue(i));
-						    double left = classCountL.getValue(i) 
-						    		- node.classCountsRight.getValue(i) - parentss;
-						    double right = classCountR.getValue(i) 
-						    		+ node.classCountsRight.getValue(i) + parentss;
-						    classCountLTemp.addToValue(i, left);
-					        classCountRTemp.addToValue(i, right);
-					        }
-						if (status == false) {		// Right node.
-							double left = classCountL.getValue(i)+ node.classCountsLeft.getValue(i);
-							double right = classCountR.getValue(i)- node.classCountsLeft.getValue(i);
-							classCountLTemp.addToValue(i, left);
-							classCountRTemp.addToValue(i, right);
-							}
-						}
-					} else {
-						classCountLTemp = classCountL;
-						classCountRTemp = classCountR;
-						}
-				double classCountLSum = classCountLTemp.sumOfValues();
-				double classCountRSum = classCountRTemp.sumOfValues();
-				double numInst = this.root.classCountsLeft.sumOfValues() + this.root.classCountsRight.sumOfValues();
-				// The entropy value for all nodes except for the root.
-				if ((classCountLSum > this.PminOption.getValue()*numInst) 
-						&& (classCountRSum > this.PminOption.getValue() * numInst)) {
-					double classCountLEntropy = entropy( classCountLTemp);   // Entropy of class count left.
-					double classCountREntropy = entropy(classCountRTemp);    // Entropy of class count right
-					if (((classCountLSum / numInst) * classCountLEntropy + (classCountRSum / numInst)* classCountREntropy) <= minEntropy) {
-						this.minEntropyTemp = (classCountLSum / numInst) * classCountLEntropy 
-								+ (classCountRSum / numInst) * classCountREntropy;
-						this.cutPointTemp = node.cut_point;
-						if (classCountLEntropy <= classCountREntropy) {
-							this.symbol = -1.0;
-							double value = 0.0;
-							double index = 0.0;
-							for (int h = 0; h < numClass; h++) {
-								if (value <= classCountLTemp.getValue(h)) {
-									value = classCountLTemp.getValue(h);
-					    			index = (double)h;
-					    			}
-								}
-							this.saveBestEntropy.setValue(0, this.cutPointTemp);
-							this.saveBestEntropy.setValue(1, classCountLEntropy);
-							this.saveBestEntropy.setValue(2, this.symbol);
-							this.saveBestEntropy.setValue(4, index);
-					    	} else {
-					    		this.symbol = 1.0;
-					    		double value = 0.0;
-					    		double index = 0.0;
-					    		for (int h = 0; h < numClass; h++) {
-					    			if (value <= classCountRTemp.getValue(h)) {
-					    				value = classCountRTemp.getValue(h);
-					    				index = (double)h;
-					    				}
-					    			}
-					    		this.saveBestEntropy.setValue(0, this.cutPointTemp);
-					    		this.saveBestEntropy.setValue(1, classCountREntropy);
-					    		this.saveBestEntropy.setValue(2, this.symbol);
-					    		this.saveBestEntropy.setValue(4, index);
-						    	}
-						}
-					}
-				findBestValEntropy(node.left ,classCountLTemp , classCountRTemp,
-						true, this.minEntropyTemp, parentCCLParameter);
-				findBestValEntropy(node.right ,classCountLTemp , classCountRTemp,
-						false, this.minEntropyTemp, parentCCLParameter);
-				}
-			}
-		}
-	
-	//Best value of entropy 
-	public void mainFindBestValEntropy(Node root) {
-		if (root != null) {
-			DoubleVector parentClassCL = new DoubleVector();
-			DoubleVector classCountL = root.classCountsLeft; //class count left
-			DoubleVector classCountR = root.classCountsRight; //class count left
-			double numInst = root.classCountsLeft.sumOfValues() + root.classCountsRight.sumOfValues();
-			double classCountLSum = root.classCountsLeft.sumOfValues();
-			double classCountRSum = root.classCountsRight.sumOfValues();
-			double classCountLEntropy = entropy(classCountL);
-			double classCountREntropy = entropy(classCountR);
-			this.minEntropyTemp = ( classCountLSum / numInst) * classCountLEntropy 
-					+ (classCountRSum / numInst)* classCountREntropy;
-			for (int f = 0; f < root.classCountsLeft.numValues(); f++) {
-				parentClassCL.setValue(f, root.classCountsLeft.getValue(f));
-				}
-			findBestValEntropy(root ,classCountL , classCountR, true, this.minEntropyTemp, parentClassCL);
-			}
-		}
-	
-	//Find best value of entropy for nominal attributes
-	public void findBestValEntropyNominalAtt(AutoExpandVector<DoubleVector> attrib, int attNumValues) {
-		ArrayList<ArrayList<Double>> distClassValue =  new ArrayList<ArrayList<Double>>();
-	//	System.out.print("attrib"+attrib+"\n");
-		for (int z = 0; z < attrib.size(); z++) {
-			distClassValue.add(new ArrayList<Double>());	
-		}
-		for (int v = 0; v < attNumValues; v++) {
-			DoubleVector saveVal = new DoubleVector();
-			for (int z = 0; z < attrib.size(); z++) {
-				if (attrib.get(z) != null) {
-					distClassValue.get(z).add(attrib.get(z).getValue(v));
-				} else {
-					distClassValue.get(z).add(0.0);
-				}
-				if(distClassValue.get(z).get(v).isNaN()) {
-					distClassValue.get(z).add(0.0);
-				}
-				saveVal.setValue(z, distClassValue.get(z).get(v));
-				}
-			double sumValue = saveVal.sumOfValues();
-			if (sumValue > 0.0) {
-				double entropyVal = entropy(saveVal);
-			    if (entropyVal <= this.minEntropyNominalAttrib) {
-			    	this.minEntropyNominalAttrib = entropyVal;
-			    	this.saveBestEntropyNominalAttrib.setValue(0, v);
-			    	this.saveBestEntropyNominalAttrib.setValue(1, entropyVal);
-			    	this.saveBestEntropyNominalAttrib.setValue(2, 0.0);
-			    	}
-			    }
-			}
-		}
-	
-	
-	//Hoeffding Bound 
-	public  double ComputeHoeffdingBound(double range, double confidence,
-		            double n) {
-		return Math.sqrt(((range * range) * Math.log(1.0 / confidence))
-		                / (2.0 * n));
-		}
-	
-	//Check if the best attribute is really the best
-	public boolean checkBestAttrib(double n,
-			AutoExpandVector<AttributeClassObserver> observerss, DoubleVector observedClassDistribution){
-		double h0 = entropy(observedClassDistribution);
-		boolean  isTheBest = false;
-		double[] entropyValues = getBestSecondBestEntropy(this.saveBestGlobalEntropy);
-		double bestEntropy = entropyValues[0];
-		double secondBestEntropy = entropyValues[1];
-	    double range = Utils.log2(this.numClass);
-		double hoeffdingBound = ComputeHoeffdingBound(range, this.splitConfidenceOption.getValue(), n);
-		if ((h0 > bestEntropy) && ((secondBestEntropy - bestEntropy > hoeffdingBound)
-				|| (hoeffdingBound < this.tieThresholdOption.getValue()))) {
-			for (int i = 0; i < this.saveBestValGlobalEntropy.size(); i++) {
-				if (bestEntropy ==(this.saveBestValGlobalEntropy.get(i).get(1))) {
-					this.saveTheBest.add(this.saveBestValGlobalEntropy.get(i).get(0)); 
-					this.saveTheBest.add(this.saveBestValGlobalEntropy.get(i).get(1));
-					this.saveTheBest.add(this.saveBestValGlobalEntropy.get(i).get(2)); 
-					this.saveTheBest.add((double)i);
-					if (this.saveTheBest.get(2) != 0.0) {
-						this.saveTheBest.add(this.saveBestValGlobalEntropy.get(i).get(3)); 
-						}
-					break;
-					}
-				}
-			isTheBest = true;
-			} else {
-				isTheBest = false;
-				}
-		return isTheBest;
-		}
-	
-	//Get best and second best attributes
-	protected double [] getBestSecondBestEntropy(DoubleVector entropy){
-		double[] entropyValues = new double[2];
-		double best = Double.MAX_VALUE;
-		double secondBest = Double.MAX_VALUE;
-		for (int i = 0; i < entropy.numValues(); i++) {
-			if (entropy.getValue(i) < best) {
-				secondBest = best;
-				best = entropy.getValue(i);
-			} else{
-				if (entropy.getValue(i) < secondBest) {
-					secondBest = entropy.getValue(i);
-				}
-			}
-			}
-		entropyValues[0] = best;
-		entropyValues[1] = secondBest;
-		
-		return entropyValues;
-	}
-	
-	//Get rule majority class index	
-	protected double getRuleMajorityClassIndex(RuleClassification r) {
-		double maxvalue = 0.0;
-		int posMaxValue = 0;
-		for (int i = 0; i < r.obserClassDistrib.numValues(); i++) {
-			if (r.obserClassDistrib.getValue(i) > maxvalue) {
-				maxvalue = r.obserClassDistrib.getValue(i);
-				posMaxValue = i;
-			}
-		}
-		return (double)posMaxValue;
-	}
-		
-    //Get observers class distribution probability
-	protected double[] oberversDistribProb(Instance inst,
-			DoubleVector classDistrib) {
-		double[] votes = new double[this.numClass];
-		double sum = classDistrib.sumOfValues();
-		for (int z = 0; z < this.numClass; z++) {
-			votes[z] = classDistrib.getValue(z) / sum;
-			}
-		return votes;
-		}
-	
-	// The following three functions are used for the prediction 
-	protected double[] firstHit(Instance inst) {
-		boolean fired = false;
-		int countFired = 0;
-		double[] votes = new double[this.numClass];
-		for (int j = 0; j < this.ruleSet.size(); j++) {
-			if (this.ruleSet.get(j).ruleEvaluate(inst) == true) {
-				countFired = countFired + 1;
-				for (int z = 0; z < this.numClass; z++) {
-					votes[z] = this.ruleSet.get(j).obserClassDistrib.getValue(z) 
-							/ this.ruleSet.get(j).obserClassDistrib.sumOfValues();
-					}
-				return votes;
-				}
-			}
-		if (countFired > 0) {
-			fired = true;
-			} else {
-				fired = false;
-				}
-		if (fired == false) {
-			votes = oberversDistribProb(inst, this.observedClassDistribution);
-			}
-		return votes;
-		}
-	
-	//Get the votes using weighted Max
-	protected double[] weightedMax(Instance inst) {
-		int countFired = 0;
-		boolean fired = false;
-		double highest = 0.0;
-		double[] votes = new double[this.numClass];
-		ArrayList<Double> ruleSetVotes = new ArrayList<Double>();
-		ArrayList<ArrayList<Double>> majorityProb = new ArrayList<ArrayList<Double>>();
-		for (int j = 0; j < this.ruleSet.size(); j++) {
-			ArrayList<Double> ruleProb = new ArrayList<Double>();
-			if (this.ruleSet.get(j).ruleEvaluate(inst) == true) {
-				countFired = countFired+1;
-				for (int z = 0; z < this.numClass; z++) {
-					ruleSetVotes.add(this.ruleSet.get(j).obserClassDistrib.getValue(z) / this.ruleSet.get(j).obserClassDistrib.sumOfValues());
-		    	    ruleProb.add(this.ruleSet.get(j).obserClassDistrib.getValue(z) / this.ruleSet.get(j).obserClassDistrib.sumOfValues());
-		    	    }
-				majorityProb.add(ruleProb);
-				}
-			}
-		if (countFired > 0) {
-			fired = true;
-			Collections.sort(ruleSetVotes); 
-		    highest = ruleSetVotes.get(ruleSetVotes.size() - 1);
-		    for (int t = 0; t < majorityProb.size(); t++) {
-				 for(int m = 0; m < majorityProb.get(t).size(); m++) {
-					 if (majorityProb.get(t).get(m) == highest) {
-						 for (int h = 0; h < majorityProb.get(t).size(); h++) {
-							 votes[h] = majorityProb.get(t).get(h);
-							 }
-						 break;
-						 }
-					 }
-				 }
-		    } else {
-		    	fired = false;
-		    	}
-		if (fired == false) {
-			votes = oberversDistribProb(inst, this.observedClassDistribution);
-			}
-		return votes;
-		}
-	
-	//Get the votes using weighted Sum
-	protected double[] weightedSum(Instance inst) {
-		boolean fired = false;
-		int countFired = 0;
-		double[] votes = new double[this.numClass];
-		ArrayList<Double> weightSum = new ArrayList<Double>();
-		ArrayList<ArrayList<Double>> majorityProb = new ArrayList<ArrayList<Double>>();
-		for (int j = 0; j < this.ruleSet.size(); j++) {
-			ArrayList<Double> ruleProb = new ArrayList<Double>();
-			if (this.ruleSet.get(j).ruleEvaluate(inst) == true) {
-				countFired = countFired + 1;
-				for (int z = 0; z < this.numClass; z++) {
-					ruleProb.add(this.ruleSet.get(j).obserClassDistrib.getValue(z) / this.ruleSet.get(j).obserClassDistrib.sumOfValues());
-					}
-				majorityProb.add(ruleProb);
-				}
-			}
-		if (countFired > 0) {
-			fired = true;
-			for (int m = 0; m < majorityProb.get(0).size(); m++) {
-				double sum = 0.0;
-				for (int t = 0; t < majorityProb.size(); t++){
-					sum = sum + majorityProb.get(t).get(m);
-					}
-				weightSum.add(sum);
-				}
-			for (int h = 0; h < weightSum.size(); h++) {
-				votes[h] = weightSum.get(h) / majorityProb.size();
-				}
-			} else {
-				fired = false;
-				}
-		if (fired == false) {
-			votes = oberversDistribProb(inst, this.observedClassDistribution);
-			}
-		return votes;
-		}
-	
-	
-	protected AttributeClassObserver newNominalClassObserver() {
-		return new NominalAttributeClassObserver();
-    }
- 
-    protected AttributeClassObserver newNumericClassObserver() {
-    	return new BinaryTreeNumericAttributeClassObserver();
-    }
-    
-    protected AttributeClassObserver newNumericClassObserver2() {
-    	return new GaussianNumericAttributeClassObserver();
-		    }
-    
-    public void manageMemory(int currentByteSize, int maxByteSize) {
-        // TODO Auto-generated method stub
-    }
-    }
diff --git a/moa/src/main/java/moa/classifiers/rules/RuleClassifierNBayes.java b/moa/src/main/java/moa/classifiers/rules/RuleClassifierNBayes.java
deleted file mode 100644
index 7138734fc..000000000
--- a/moa/src/main/java/moa/classifiers/rules/RuleClassifierNBayes.java
+++ /dev/null
@@ -1,248 +0,0 @@
-/*
- *    RuleClassifierNBayes.java
- *    Copyright (C) 2012 University of Porto, Portugal
- *    @author P. Kosina, E. Almeida, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.classifiers.rules;
-
-import java.util.ArrayList;
-import java.util.Collections;
-
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.bayes.NaiveBayes;
-
-/**
- * This classifier learn ordered and unordered rule set from data stream with naive Bayes learners.
- * <p> This algorithm also does the detection of anomalies.
- * 
- * <p>Learning Decision RuleClassifications from Data Streams, IJCAI 2011, J. Gama,  P. Kosina </p>
- * 
- * <p>Parameters:</p>
- * <ul>
- * <li> -q: The number of instances a leaf should observe before permitting Naive Bayes.</li>
- * <li> -p: Minimum value of p </li>
- * <li> -t: Tie Threshold </li>
- * <li> -c: Split Confidence </li>
- * <li> -g: GracePeriod, the number of instances a leaf should observe between split attempts </li>
- * <li> -o: Prediction function to use. Ex:FirstHit </li>
- * <li> -r: Learn ordered or unordered rule </li>
- * </ul>
- * 
- * @author P. Kosina, E. Almeida, J. Gama
- * @version $Revision: 2 $
- */
-public class RuleClassifierNBayes extends RuleClassifier {
-	
-	private static final long serialVersionUID = 1L;
-	
-	public IntOption nbThresholdOption = new IntOption(
-			"nbThreshold",
-            'q',
-            "The number of instances a leaf should observe before permitting Naive Bayes.",
-            0, 0, Integer.MAX_VALUE);
-	
-	@Override
-	public Prediction getPredictionForInstance(Instance inst) {
-		double[] votes = new double[numClass];
-		switch (super.predictionFunctionOption.getChosenIndex()) {
-        case 0:
-        	votes = firstHitNB(inst);
-        	break;
-        case 1:
-        	votes = weightedSumNB(inst);
-        	break;
-        case 2:
-        	votes = weightedMaxNB(inst);
-        	break;
-        	}
-		return new ClassificationPrediction(votes); 
-		}
-	
-	// The following three functions are used for the prediction 
-	protected double[] firstHitNB(Instance inst) {
-		int countFired = 0;
-		boolean fired = false;
-		double[] votes = new double[this.numClass];
-		for (int j = 0; j < this.ruleSet.size(); j++) {
-			if (this.ruleSet.get(j).ruleEvaluate(inst) == true) {
-				countFired = countFired + 1;
-				if (this.ruleSet.get(j).obserClassDistrib.sumOfValues() >= this.nbThresholdOption.getValue()) {
-					votes = NaiveBayes.doNaiveBayesPredictionLog(inst, this.ruleSet.get(j).obserClassDistrib, this.ruleSet.get(j).observers, this.ruleSet.get(j).observersGauss);
-		    	    votes = exponential(votes);
-		    	    votes = normalize(votes);
-		    	    } else {
-		    	    	for (int z = 0; z < this.numClass; z++) {
-		    	    		votes[z] = this.ruleSet.get(j).obserClassDistrib.getValue(z) 
-		    	    				/ this.ruleSet.get(j).obserClassDistrib.sumOfValues();
-		    	    		}
-		    	    	}
-				break;
-				}
-			}
-		if (countFired > 0) {
-			fired = true;
-			} else {
-				fired = false;
-				}
-		if (fired == false) {
-			if (super.getWeightSeen() >= this.nbThresholdOption.getValue()) {
-				votes = NaiveBayes.doNaiveBayesPredictionLog(inst, this.observedClassDistribution, this.attributeObservers, this.attributeObserversGauss);
-				votes = exponential(votes);
-				votes = normalize(votes);
-				} else {
-					votes = super.oberversDistribProb(inst, this.observedClassDistribution);
-					}
-			}
-		return votes;
-		}
-	
-	protected double[] weightedMaxNB(Instance inst) {
-		int countFired = 0;
-		int count = 0;
-		boolean fired = false;
-		double highest = 0.0;
-		double[] votes = new double[this.numClass];
-		ArrayList<Double> ruleSetVotes = new ArrayList<Double>();
-		ArrayList<ArrayList<Double>> majorityProb = new ArrayList<ArrayList<Double>>();
-		for (int j = 0; j < this.ruleSet.size(); j++) {
-			ArrayList<Double> ruleClassDistribProb=new ArrayList<Double>();
-			if(this.ruleSet.get(j).ruleEvaluate(inst) == true) {
-				countFired = countFired + 1;
-				if (this.ruleSet.get(j).obserClassDistrib.sumOfValues() >= this.nbThresholdOption.getValue()) {
-					votes = NaiveBayes.doNaiveBayesPredictionLog(inst, this.ruleSet.get(j).obserClassDistrib, this.ruleSet.get(j).observers, this.ruleSet.get(j).observersGauss);
-					votes = exponential(votes);
-		    	    votes = normalize(votes);
-		    	    } else {
-		    	    	count = count + 1;
-		    	    	for (int z = 0; z < this.numClass; z++){
-		    	    		ruleSetVotes.add(this.ruleSet.get(j).obserClassDistrib.getValue(z) / this.ruleSet.get(j).obserClassDistrib.sumOfValues());
-		    	    		ruleClassDistribProb.add(this.ruleSet.get(j).obserClassDistrib.getValue(z) / this.ruleSet.get(j).obserClassDistrib.sumOfValues());
-		    	    		}
-		    	    	majorityProb.add(ruleClassDistribProb);
-		    	    	}
-				}
-			}
-		if (count > 0) {
-			Collections.sort(ruleSetVotes); 
-		    highest = ruleSetVotes.get(ruleSetVotes.size() - 1);
-		    for (int t = 0; t < majorityProb.size(); t++) {
-		    	for (int m = 0; m < majorityProb.get(t).size(); m++) {
-		    		if(majorityProb.get(t).get(m) == highest){
-		    			for(int h = 0; h < majorityProb.get(t).size(); h++){
-		    				votes[h]=majorityProb.get(t).get(h);
-		    				}
- 		    			break;
-		    			}
-		    		}
-		    	}
-		    }
-		if (countFired > 0) {
-			fired=true;
-			}  else {
-				fired=false;
-				}
-		if (fired == false) {
-			if(super.getWeightSeen() >= this.nbThresholdOption.getValue()) {
-				votes = NaiveBayes.doNaiveBayesPredictionLog(inst, this.observedClassDistribution, this.attributeObservers, this.attributeObserversGauss);
-				votes = exponential(votes);
-				votes = normalize(votes);
-				} else {
-					votes = super.oberversDistribProb(inst, this.observedClassDistribution);
-					}
-			}
-		return votes;
-		}
-	
-	protected double[] weightedSumNB(Instance inst) {
-		int countFired = 0;
-		int count = 0;
-		boolean fired = false;
-		double[] votes = new double[this.numClass];
-		ArrayList<Double> weightSum = new ArrayList<Double>();
-		ArrayList<ArrayList<Double>> majorityProb = new ArrayList<ArrayList<Double>>();
-		for ( int j = 0; j < this.ruleSet.size(); j++) {
-			ArrayList<Double> ruleClassDistribProb=new ArrayList<Double>();
-			if (this.ruleSet.get(j).ruleEvaluate(inst) == true) {
-				countFired = countFired + 1;
-				if (this.ruleSet.get(j).obserClassDistrib.sumOfValues() >= this.nbThresholdOption.getValue()) {
-					votes = NaiveBayes.doNaiveBayesPredictionLog(inst, this.ruleSet.get(j).obserClassDistrib, ruleSet.get(j).observers, this.ruleSet.get(j).observersGauss);
-	    	        votes = exponential(votes);
-	    	        votes = normalize(votes);
-	    	        } else {
-	    	        	count=count+1;
-	    	        	for (int z = 0; z < this.numClass; z++) {
-	    	        		ruleClassDistribProb.add(this.ruleSet.get(j).obserClassDistrib.getValue(z) / this.ruleSet.get(j).obserClassDistrib.sumOfValues());
-	    	        		}
-	    	        	majorityProb.add(ruleClassDistribProb);
-	    	        	}
-				}
-			}
-		 if(count > 0) {
-			 for (int m = 0; m < majorityProb.get(0).size(); m++) {
-				 double sum = 0.0;
-				 for (int t = 0; t < majorityProb.size(); t++){
-					 sum = sum + majorityProb.get(t).get(m);
-					 }
-				 weightSum.add(sum);
-				 }
-			 for (int h = 0; h < weightSum.size(); h++) {
-				 votes[h] = weightSum.get(h) / majorityProb.size();
-				 }
-			 }
-		 if(countFired>0){
-			 fired = true;
-			 } else {
-				 fired=false;
-				 }
-		 if (fired == false) {
-			 if (super.getWeightSeen() >= this.nbThresholdOption.getValue()) {
-				 votes = NaiveBayes.doNaiveBayesPredictionLog(inst, this.observedClassDistribution, this.attributeObservers, this.attributeObserversGauss);
-			  	 votes = exponential(votes);
-	  		 	 votes = normalize(votes);
-	  		 	 } else {
-	  		 		 votes = super.oberversDistribProb(inst, this.observedClassDistribution);
-	  		 		 }
-			 }
-		 return votes;
-		 }
-	
-	protected double[] normalize(double[] votes) {
-		double sum=0;
-		for (int i = 0; i < votes.length; i++) {
-			sum = sum + votes[i];
-			}
-		for (int j = 0; j < votes.length; j++) {
-			votes[j] = votes[j] / sum;
-			}
-		return votes;
-		}
-	
-	protected double[] exponential(double[] votes) {
-		for (int i = 0; i < votes.length; i++) {
-			votes[i] = Math.exp(votes[i]);
-			}
-		return votes;
-		}
-
-
-  
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/core/RuleActiveLearningNode.java b/moa/src/main/java/moa/classifiers/rules/core/RuleActiveLearningNode.java
deleted file mode 100644
index 1eaff66bd..000000000
--- a/moa/src/main/java/moa/classifiers/rules/core/RuleActiveLearningNode.java
+++ /dev/null
@@ -1,337 +0,0 @@
-/*
- *    RuleActiveLearningNode.java
- *    Copyright (C) 2014 University of Porto, Portugal
- *    @author A. Bifet, J. Duarte, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-package moa.classifiers.rules.core;
-
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
-import moa.classifiers.rules.AbstractAMRules;
-import moa.classifiers.rules.driftdetection.PageHinkleyFading;
-import moa.classifiers.rules.driftdetection.PageHinkleyTest;
-import moa.classifiers.trees.HoeffdingTree;
-import moa.classifiers.trees.HoeffdingTree.ActiveLearningNode;
-import moa.core.AutoExpandVector;
-import moa.core.DoubleVector;
-
-/**
- * A modified ActiveLearningNode that uses a Perceptron as the leaf node model,
- * and ensures that the class values sent to the attribute observers are not
- * truncated to ints if regression is being performed
- */
-public abstract class RuleActiveLearningNode extends ActiveLearningNode {
-
-    protected PageHinkleyTest pageHinckleyTest;
-
-    protected int predictionFunction;
-
-    protected boolean changeDetection;
-
-    protected Rule owner;
-    
-    protected boolean [] attributesMask;
-    protected int numAttributesSelected;
-    
-
-    private static final long serialVersionUID = 9129659494380381126L;
-
-    // The statistics for this node:
-    // Number of instances that have reached it
-    // Sum of y values
-    // Sum of squared y values
-    protected DoubleVector nodeStatistics;
-
-    /**
-     * Create a new RuleActiveLearningNode
-     */
-    public RuleActiveLearningNode(double[] initialClassObservations) {
-        super(initialClassObservations);
-        this.nodeStatistics = new DoubleVector(initialClassObservations);
-    }
-
-    public RuleActiveLearningNode() {
-        this(new double[0]);
-    }
-    
-    protected AbstractAMRules amRules;
-
-
-    public RuleActiveLearningNode(Rule.Builder builder) {
-        this(builder.statistics);
-        this.changeDetection = builder.changeDetection;
-        if (builder.changeDetection == false) { 
-        	this.pageHinckleyTest = new PageHinkleyFading(builder.threshold, builder.alpha);
-        }
-
-        this.amRules = builder.amRules;
-        this.predictionFunction = builder.predictionFunction;
-        this.owner=builder.getOwner();
-        
-    }
-
-
-    /* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#learnFromInstance(weka.core.Instance)
-	 */
-	abstract public void learnFromInstance(Instance inst);
-
-    /* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#learnFromInstance(weka.core.Instance, moa.classifiers.trees.HoeffdingTree)
-	 */
-	@Override
-    public void learnFromInstance(Instance inst, HoeffdingTree ht) {
-        learnFromInstance(inst);
-    }
-
-    protected AttributeClassObserver newNumericClassObserver() {
-        //return new FIMTDDNumericAttributeClassObserver();
-    	//return new FIMTDDNumericAttributeClassLimitObserver();
-    	return (AttributeClassObserver)((AttributeClassObserver)this.amRules.numericObserverOption.getPreMaterializedObject()).copy();
-    }
-
-
-    /* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#updateStatistics(weka.core.Instance)
-	 */
-	public void updateStatistics(Instance instance) {
-        learnFromInstance(instance);
-    }
-
-    /* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#getAttributeObservers()
-	 */
-	public AutoExpandVector<AttributeClassObserver> getAttributeObservers() {
-        return this.attributeObservers;
-    }
-
-    protected void debug(String string,int level) {
-        if (this.amRules.VerbosityOption.getValue() >= level) {
-            System.out.println(string);
-        }
-    }
-
-    /* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#getPrediction(weka.core.Instance)
-	 */
-	public double[] getPrediction(Instance instance) {
-        int predictionMode = this.getLearnerToUse(instance, this.predictionFunction);
-        return getPrediction(instance, predictionMode);
-    }
-
-    /* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#getPrediction(weka.core.Instance, int)
-	 */
-	abstract public double[] getPrediction(Instance instance, int predictionMode);
-	
-
-    /* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#getNormalizedPrediction(weka.core.Instance)
-	 */
-
-	abstract public int getLearnerToUse(Instance instance, int predictionMode);
-
-
-
-    
-
-    /* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#computeError(weka.core.Instance)
-	 */
-	abstract public double computeError(Instance instance);
-
-    /* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#updatePageHinckleyTest(double)
-	 */
-	public boolean updatePageHinckleyTest(double error) {
-        boolean changeDetected = false;
-        if (this.changeDetection == false) { 
-            changeDetected = pageHinckleyTest.update(error);
-        }
-        return changeDetected;
-    }
-
-    /* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#getInstancesSeen()
-	 */
-	public long getInstancesSeen() {
-        return (long) this.getWeightSeen();
-    }
-
-   
-
-    /* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#isAnomaly(weka.core.Instance, double, double, int)
-	 */
-	abstract public boolean isAnomaly(Instance instance,
-            double uniVariateAnomalyProbabilityThreshold,
-            double multiVariateAnomalyProbabilityThreshold,
-            int numberOfInstanceesForAnomaly); 
-
-    //Attribute probability
-    /* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#computeProbability(double, double, double)
-	 */
-	public double computeProbability(double mean, double sd, double value) {
-        double probability = 0.0;
-        
-      /* double diff = value - mean;
-        if (sd > 0.0) {
-            double k = (Math.abs(value - mean) / sd);
-            if (k > 1.0) {
-                probability = 1.0 / (k * k); // Chebyshev's inequality
-            } else {
-                probability = Math.exp(-(diff * diff / (2.0 * sd * sd)));
-            }
-        }*/
-        
-        if (sd > 0.0) {
-            double k = (Math.abs(value - mean) / sd); // One tailed variant of Chebyshev's inequality
-        	probability= 1.0 / (1+k*k); //cantelli's (one-tailed)
-        	double var=Math.pow(sd, 2);
-        	probability= 2*var/(var+Math.pow(Math.abs(value - mean), 2));
-        	//probability= 1.0 / (1+k*k);
-            //probability= 1.0 / (k*k); //chebyshev
-        	//normal distribution
-        	//double diff = value - mean;
-        	//probability = Math.exp(-(diff * diff / (2.0 * sd * sd)));
-        }
-        
-        return probability;
-    }
-
-    
-    protected AttributeSplitSuggestion bestSuggestion = null;
-    
-    /* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#getSplitIndex()
-	 */
-	public int getSplitIndex() {
-		return splitIndex;
-	}
-
-	/* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#setSplitIndex(int)
-	 */
-	public void setSplitIndex(int splitIndex) {
-		this.splitIndex = splitIndex;
-	}
-
-	protected int splitIndex = 0;
-    
-    /* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#getBestSuggestion()
-	 */
-	public AttributeSplitSuggestion getBestSuggestion() {
-		return bestSuggestion;
-	}
-
-	/* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#setBestSuggestion(moa.classifiers.core.AttributeSplitSuggestion)
-	 */
-	public void setBestSuggestion(AttributeSplitSuggestion bestSuggestion) {
-		this.bestSuggestion = bestSuggestion;
-	}
-
-	protected double[] statisticsNewRuleActiveLearningNode = null;
-
-	protected double[] statisticsBranchSplit = null;
-	
-	/* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#getStatisticsBranchSplit()
-	 */
-	public double[] getStatisticsBranchSplit() {
-		return statisticsBranchSplit;
-	}
-
-	/* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#setStatisticsBranchSplit(double[])
-	 */
-	public void setStatisticsBranchSplit(double[] statisticsBranchSplit) {
-		this.statisticsBranchSplit = statisticsBranchSplit;
-	}
-
-	/* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#getStatisticsNewRuleActiveLearningNode()
-	 */
-	public double[] getStatisticsNewRuleActiveLearningNode() {
-		return statisticsNewRuleActiveLearningNode;
-	}
-
-	/* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#setStatisticsNewRuleActiveLearningNode(double[])
-	 */
-	public void setStatisticsNewRuleActiveLearningNode(
-			double[] statisticsNewRuleActiveLearningNode) {
-		this.statisticsNewRuleActiveLearningNode = statisticsNewRuleActiveLearningNode;
-	}
-
-	protected double[] statisticsOtherBranchSplit;
-    
-	/* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#getStatisticsOtherBranchSplit()
-	 */
-	public double[] getStatisticsOtherBranchSplit() {
-		return statisticsOtherBranchSplit;
-	}
-
-	/* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#setStatisticsOtherBranchSplit(double[])
-	 */
-	public void setStatisticsOtherBranchSplit(double[] statisticsOtherBranchSplit) {
-		this.statisticsOtherBranchSplit = statisticsOtherBranchSplit;
-	}
-	
-	/* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#tryToExpand(double, double)
-	 */
-	abstract public boolean tryToExpand(double splitConfidence, double tieThreshold);
-    
-	public static double computeHoeffdingBound(double range, double confidence,
-            double n) {
-        return Math.sqrt(((range * range) * Math.log(1.0 / confidence))
-                / (2.0 * n));
-    }
-
-	/* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#initialize(moa.classifiers.rules.RuleActiveLearningNode)
-	 */
-	abstract public void initialize(RuleActiveLearningNode oldLearningNode);
-		
-
-	/* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#getSimplePrediction()
-	 */
-	abstract public double[] getSimplePrediction();
-
-	
-	public DoubleVector getNodeStatistics(){
-		return this.nodeStatistics;
-	}
-
-	public boolean updateChangeDetection(double error) {
-		if(changeDetection==false){
-			return  pageHinckleyTest.update(error);
-		}
-		else
-			return false;
-	}
-
-	abstract public double getCurrentError();
-}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/rules/core/Utils.java b/moa/src/main/java/moa/classifiers/rules/core/Utils.java
deleted file mode 100644
index 146eef5b8..000000000
--- a/moa/src/main/java/moa/classifiers/rules/core/Utils.java
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
- *    Utils.java
- *    Copyright (C) 2017 University of Porto, Portugal
- *    @author J. Duarte, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *
- *
- */
-package moa.classifiers.rules.core;
-
-import moa.classifiers.rules.multilabel.attributeclassobservers.SingleVector;
-import moa.core.DoubleVector;
-
-/**
- * Class that contains several utilities
- * Variance
- * Standard deviation
- * Vector operations(copy, etc)
- * Entropy
- * Complementary set
- */
-
-
-public final class Utils {
-
-	public static double computeVariance(double count, double sum, double sumSquares)
-	{
-		return (sumSquares - ((sum * sum)/count))/count;
-	}
-	
-	public static double computeVariance(DoubleVector statistics)
-	{
-		return computeVariance(statistics.getValue(0),statistics.getValue(1),statistics.getValue(2));
-	}
-
-	public static double computeVariance(double[] statistics)
-	{
-		return computeVariance(statistics[0],statistics[1],statistics[2]);
-	}
-	
-	public static double computeSD(double squaredSum, double sum, double weightSeen) {
-		if (weightSeen > 1) {
-			return Math.sqrt((squaredSum - ((sum * sum) / weightSeen)) / (weightSeen - 1.0));
-		}
-		return 0.0;
-	}
-	
-	public static double computeSD(DoubleVector statistics)
-	{
-		return computeSD(statistics.getValue(0),statistics.getValue(1),statistics.getValue(2));
-	}
-
-	public static DoubleVector[][] copy(DoubleVector[][] toCopy) {
-		DoubleVector[][] copy = new DoubleVector[toCopy.length][];
-        for (int i=0; i<toCopy.length; i++)
-        	copy[i]=Utils.copy(toCopy[i]);
-        return copy;
-	}
-	
-	public static DoubleVector[]copy(DoubleVector[] toCopy) {
-		DoubleVector[] copy = new DoubleVector[toCopy.length];
-        	for (int i=0; i<toCopy.length; i++)
-        		copy[i]=new DoubleVector(toCopy[i]);
-        return copy;
-	}
-	
-	public static SingleVector[]copyAsFloatVector(DoubleVector[] toCopy) {
-		SingleVector[] toCopyFloat = new SingleVector[toCopy.length];
-        	for (int i=0; i<toCopy.length; i++)
-        		toCopyFloat[i]=new SingleVector(toCopy[i].getArrayRef());
-        return toCopyFloat;
-	}
-	
-	public static SingleVector[]copy(SingleVector[] toCopy) {
-		SingleVector[] copy = new SingleVector[toCopy.length];
-        	for (int i=0; i<toCopy.length; i++)
-        		copy[i]=new SingleVector(toCopy[i]);
-        return copy;
-	}
-	
-	public static DoubleVector floatToDoubleVector(SingleVector toCopy) {
-		float [] ref=toCopy.getArrayRef();
-		double [] array= new double[ref.length];
-		for(int i=0; i<ref.length;i++){
-			array[i]=(double)ref[i];
-		}
-		return new DoubleVector(array);
-	}
-	
-	public static int [] complementSet(int[] referenceSet, int[] comparingSet) {
-		int [] indices= new int[referenceSet.length-comparingSet.length];
-		int j=0,l=0,i;
-		for (i=0; i<referenceSet.length && l<comparingSet.length;i++){
-			if(referenceSet[i]!=comparingSet[l])
-			{
-				indices[j]=referenceSet[i];
-				j++;
-			}
-			else
-				l++;
-		}
-		while(i<referenceSet.length){
-			indices[j]=referenceSet[i];
-			i++; j++;
-		}		
-		return indices;
-	}
-	
-	public static int[] getIndexCorrespondence(int[] originalSet, int[] subSet) {
-		int [] indices= new int[subSet.length];
-		int j=0;
-		for (int i=0; i<subSet.length;i++){
-			while(originalSet[j]!=subSet[i])
-				j++;
-			indices[i]=j;
-		}
-		return indices;
-	}
-	
-	public static double computeEntropy(DoubleVector statistics){
-      return computeEntropy(statistics.getValue(0),statistics.getValue(1));
-	}
-        
-  public static double computeEntropy(double count, double sum){
-            if(sum/count==1 || sum==0)
-                return 0;
-            else
-                return -(sum/count*Math.log(sum/count) + (1-sum/count)*Math.log(1-sum/count) );
-            
-	}
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalinessRatioScore.java b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalinessRatioScore.java
deleted file mode 100644
index 71ef17318..000000000
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalinessRatioScore.java
+++ /dev/null
@@ -1,165 +0,0 @@
-/*
- *    AnomalinessRatioScore.java
- *    Copyright (C) 2017 University of Porto, Portugal
- *    @author J. Duarte, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *
- *
- */
-package moa.classifiers.rules.core.anomalydetection;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.classifiers.rules.core.Utils;
-import moa.classifiers.rules.core.anomalydetection.probabilityfunctions.ProbabilityFunction;
-import moa.core.AutoExpandVector;
-import moa.core.ObjectRepository;
-import moa.options.ClassOption;
-import moa.tasks.TaskMonitor;
-
-/**
- * Score for anomaly detection
- *
- * percentageAnomalousAttributesOption - Percentage of anomalous attributes.
- * univariateAnomalyprobabilityThresholdOption - Univariate anomaly threshold value
- * minNumberInstancesOption - The minimum number of instances required to perform anomaly detection
- * probabilityFunctionOption - Probability function selection
- */
-
-
-
-public class AnomalinessRatioScore extends AbstractAnomalyDetector {
-
-	/**
-	 * 
-	 */
-	private static final long serialVersionUID = 1L;
-	private static final double MINSTD=0.01;
-
-	public FloatOption percentageAnomalousAttributesOption = new FloatOption(
-			"percentageAnomalousAttributes",
-			'm',
-			"Percentage of anomalous attributes.",
-			0.5, 0.0, 1.0);
-	public FloatOption univariateAnomalyprobabilityThresholdOption = new FloatOption(
-			"univariateAnomalyprobabilityThreshold",
-			'u',
-			"Univariate anomaly threshold value.",
-			0.90, 0.0, 1.0);
-
-	public IntOption minNumberInstancesOption = new IntOption(
-			"minNumberInstances",
-			'n',
-			"The minimum number of instances required to perform anomaly detection.",
-			30, 0, Integer.MAX_VALUE);
-
-	public ClassOption probabilityFunctionOption = new ClassOption("probabilityFunction",
-			'p', "Probability function", 
-			ProbabilityFunction.class,
-			"GaussInequality");
-
-
-	private int minInstances;
-	private double weightSeen;
-	private double univariateThreshold;
-	private double percentageAnomalous;
-	AutoExpandVector<double[]> sufficientStatistics;
-	private ProbabilityFunction probabilityFunction;
-
-        public double anomalyScore;
-
-        @Override 
-        public double getAnomalyScore(){
-            return anomalyScore;
-        }
-
-
-	@Override
-	public boolean updateAndCheckAnomalyDetection(Instance instance) {
-		boolean isAnomaly=false;
-		if(probabilityFunction==null){
-			weightSeen=0.0;
-			//load options
-			minInstances=minNumberInstancesOption.getValue();
-			univariateThreshold=univariateAnomalyprobabilityThresholdOption.getValue();
-			percentageAnomalous=percentageAnomalousAttributesOption.getValue();	
-			probabilityFunction=(ProbabilityFunction)getPreparedClassOption(probabilityFunctionOption);
-			
-			//free memory
-			minNumberInstancesOption=null;
-			univariateAnomalyprobabilityThresholdOption=null;
-			percentageAnomalousAttributesOption=null;
-			probabilityFunctionOption=null;
-		}
-		double anomaly=0;
-		if(weightSeen>minInstances){
-			int anomalousTotal=0, total=0;
-			//check if it is anomaly
-			for(int i=0; i<instance.numInputAttributes(); i++){
-				double prob=0;
-				double [] stats=sufficientStatistics.get(i);
-				if(instance.attribute(i).isNumeric()){
-					double val=instance.valueInputAttribute(i);
-					double sd=Utils.computeSD(stats[1], stats[0], weightSeen);
-					if(sd>MINSTD){
-						prob=probabilityFunction.getProbability(stats[0]/weightSeen, Utils.computeSD(stats[1], stats[0], weightSeen), val);
-						if((1-prob)>univariateThreshold)
-							anomalousTotal++;
-						total++;
-					}
-				}
-			}
-			if(total>0)
-				anomaly=anomaly/total;
-			isAnomaly=(anomalousTotal/((double)total)>percentageAnomalous);
-                        anomalyScore=anomaly;
-		}
-		//update stats
-		if(!isAnomaly){
-			if(sufficientStatistics==null)
-				sufficientStatistics= new AutoExpandVector<double[]>();
-				weightSeen+=instance.weight();
-				for(int i=0; i<instance.numInputAttributes(); i++){
-					double [] stats=sufficientStatistics.get(i);
-					if(instance.attribute(i).isNumeric()){
-						double val=instance.valueInputAttribute(i);
-						if(stats!=null){
-							//update statistics for numeric attributes
-							stats[0]+=val;
-							stats[1]+=(val*val);
-						}
-						else{
-							stats=new double[]{instance.weight()*val,instance.weight()*val*val};
-							sufficientStatistics.set(i,stats);
-						}
-					}
-				}
-		}		
-		return isAnomaly;
-	}
-
-
-	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
-
-	}
-
-	@Override
-	public void getDescription(StringBuilder sb, int indent) {
-	}
-
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/OddsRatioScore.java b/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/OddsRatioScore.java
deleted file mode 100644
index d11943940..000000000
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/OddsRatioScore.java
+++ /dev/null
@@ -1,193 +0,0 @@
-/*
- *    OddsRatioScore.java
- *    Copyright (C) 2017 University of Porto, Portugal
- *    @author J. Duarte, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *
- *
- */
-package moa.classifiers.rules.core.anomalydetection;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.classifiers.rules.core.Utils;
-import moa.classifiers.rules.core.anomalydetection.probabilityfunctions.CantellisInequality;
-import moa.classifiers.rules.core.anomalydetection.probabilityfunctions.ProbabilityFunction;
-import moa.core.AutoExpandVector;
-import moa.core.ObjectRepository;
-import moa.options.ClassOption;
-import moa.tasks.TaskMonitor;
-
-
-/**
- * Score for anomaly detection: OddsRatio
- *
- * thresholdOption - The threshold value for detecting anomalies
- * minNumberInstancesOption - The minimum number of instances required to perform anomaly detection
- * probabilityFunctionOption - Probability function selection
- */
-
-
-
-public class OddsRatioScore extends AbstractAnomalyDetector {
-
-	/**
-	 * 
-	 */
-	private static final long serialVersionUID = 1L;
-	private static final double MINSTD=0.01;
-	private static final double MINPROB=0.01;
-	private static final double MAXPROB=1-MINPROB;
-
-	public IntOption minNumberInstancesOption = new IntOption(
-			"minNumberInstances",
-			'n',
-			"The minimum number of instances required to perform anomaly detection.",
-			30, 0, Integer.MAX_VALUE);
-
-	public FloatOption thresholdOption = new FloatOption(
-			"threshold",
-			't',
-			"The threshold value for detecting anomalies.",
-			-0.75, -10, 0);
-
-	public ClassOption probabilityFunctionOption = new ClassOption("probabilityFunction",
-			'p', "Probability function", 
-			ProbabilityFunction.class,
-			CantellisInequality.class.getName());
-
-
-	private int minInstances;
-	private double weightSeen;
-	private double threshold;
-	AutoExpandVector<double[]> sufficientStatistics;
-	private ProbabilityFunction probabilityFunction;
-        public double anomalyScore;
-
-	@Override
-        public double getAnomalyScore(){
-            return anomalyScore;
-        }
-
-	@Override
-	public boolean updateAndCheckAnomalyDetection(Instance instance) {
-		boolean isAnomaly=false;
-		if(probabilityFunction==null){
-			weightSeen=0.0;
-			//load options
-			minInstances=minNumberInstancesOption.getValue();
-			threshold=thresholdOption.getValue();
-			probabilityFunction=(ProbabilityFunction)getPreparedClassOption(probabilityFunctionOption);
-			//free memory
-			minNumberInstancesOption=null;
-			probabilityFunctionOption=null;
-		}
-		double anomaly=0;
-		if(weightSeen>minInstances){
-			int ct=0;
-			//check if it is anomaly
-			for(int i=0; i<instance.numInputAttributes(); i++){
-				double prob=0;
-				double [] stats=sufficientStatistics.get(i);
-				if(instance.attribute(i).isNumeric()){
-					double val=instance.valueInputAttribute(i);
-					double sd=Utils.computeSD(stats[1], stats[0], weightSeen);
-					if(sd>MINSTD){
-						prob=probabilityFunction.getProbability(stats[0]/weightSeen, sd, val);
-						if(prob>MAXPROB)
-							prob=MAXPROB;
-						else if(prob<MINPROB)
-							prob=MINPROB;
-						anomaly+=Math.log(prob)-Math.log(1-prob);
-						ct++;
-					}
-				}
-			}
-			if(ct>0)
-				anomaly=anomaly/ct;
-			isAnomaly=anomaly<threshold;
-		}
-		//update stats
-		if(!isAnomaly){
-			if(sufficientStatistics==null)
-				sufficientStatistics= new AutoExpandVector<double[]>();
-				weightSeen+=instance.weight();
-				for(int i=0; i<instance.numInputAttributes(); i++){
-					double [] stats=sufficientStatistics.get(i);
-					if(instance.attribute(i).isNumeric()){
-						double val=instance.valueInputAttribute(i);
-						if(stats!=null){
-							//update statistics for numeric attributes
-							stats[0]+=val;
-							stats[1]+=(val*val);
-						}
-						else{
-							stats=new double[]{instance.weight()*val,instance.weight()*val*val};
-							sufficientStatistics.set(i,stats);
-						}
-					}
-				}
-		}			
-		/*else
-			{
-				//System.out.println("Anomaly = " + anomaly + "#instances: " + weightSeen);
-			printAnomaly(instance, anomaly);
-		}*/
-		return isAnomaly;
-	}
-
-	protected void printAnomaly(Instance inst, double anomaly) {
-		StringBuffer sb= new StringBuffer();
-		for(int i=0; i<inst.numInputAttributes(); i++){
-			if(inst.attribute(i).isNumeric()){
-				double [] stats;
-				//Attribute name
-				sb.append("Attribute " + i +" (" + inst.attribute(i).name()+ ") - ");
-				//Val for instance
-				double val=inst.valueInputAttribute(i);
-				sb.append("Value: ").append(val);
-				stats=sufficientStatistics.get(i);	
-				double mean=stats[0]/weightSeen;
-				double std=Utils.computeSD(stats[1], stats[0], weightSeen);
-				double prob=probabilityFunction.getProbability(mean, Utils.computeSD(stats[1], stats[0], weightSeen), val);
-				//Mean
-				sb.append(" - Prob: ").append(prob);
-				//Mean
-				sb.append(" - Mean: ").append(mean);
-				//SD
-				sb.append(" - Std: ").append(std).append("\n");	
-			}
-		}
-		sb.append("Score - ").append(anomaly);
-		System.out.println(sb);
-
-	}
-
-
-
-
-
-	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
-
-	}
-
-	@Override
-	public void getDescription(StringBuilder sb, int indent) {
-	}
-
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/core/attributeclassobservers/FIMTDDNumericAttributeClassLimitObserver.java b/moa/src/main/java/moa/classifiers/rules/core/attributeclassobservers/FIMTDDNumericAttributeClassLimitObserver.java
deleted file mode 100644
index b481df55f..000000000
--- a/moa/src/main/java/moa/classifiers/rules/core/attributeclassobservers/FIMTDDNumericAttributeClassLimitObserver.java
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- *    FIMTDDNumericAttributeClassLimitObserver.java
- *    Copyright (C) 2014 University of Porto, Portugal
- *    @author A. Bifet, J. Duarte, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-package moa.classifiers.rules.core.attributeclassobservers;
-
-import com.github.javacliparser.IntOption;
-
-import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
-
-
-public class FIMTDDNumericAttributeClassLimitObserver extends FIMTDDNumericAttributeClassObserver {
-
-    /**
-	 * 
-	 */
-	private static final long serialVersionUID = 1L;
-	protected int maxNodes;
-	public IntOption maxNodesOption = new IntOption("maxNodesOption", 'z', "Maximum number of nodes", 50, 0, Integer.MAX_VALUE);
-    
-
-	protected int numNodes;
-
-	@Override
-    public void observeAttributeClass(double attVal, double  classVal, double weight) {
-        if (Double.isNaN(attVal)) { //Instance.isMissingValue(attVal)
-        } else {
-            if (this.root == null) {
-        		maxNodes=maxNodesOption.getValue();
-                this.root = new FIMTDDNumericAttributeClassLimitObserver.Node(attVal, classVal, weight);
-            } else {
-                this.root.insertValue(attVal, classVal, weight);
-            }
-        }
-    }
-    
-    protected class Node extends FIMTDDNumericAttributeClassObserver.Node {
-        /**
-		 * 
-		 */
-		private static final long serialVersionUID = -4484141636424708465L;
-
-
-
-		public Node(double val, double label, double weight) {
-			super(val, label, weight);
-		}
-
-        protected Node root = null;
-        
-
-
-        /**
-         * Insert a new value into the tree, updating both the sum of values and
-         * sum of squared values arrays
-         */
-        @Override
-        public void insertValue(double val, double label, double weight) {
-           
-		// If the new value equals the value stored in a node, update
-		// the left (<=) node information
-		if (val == this.cut_point) 
-		{
-		    this.leftStatistics.addToValue(0,1);
-		    this.leftStatistics.addToValue(1,label);
-		    this.leftStatistics.addToValue(2,label*label);
-		} 
-		// If the new value is less than the value in a node, update the
-		// left distribution and send the value down to the left child node.
-		// If no left child exists, create one
-		else if (val < this.cut_point) {
-			this.leftStatistics.addToValue(0,1);
-			this.leftStatistics.addToValue(1,label);
-			this.leftStatistics.addToValue(2,label*label);
-			if (this.left == null) {
-				if(numNodes<maxNodes){
-					this.left = new Node(val, label, weight);
-					++numNodes;
-				}
-			} else {
-			    this.left.insertValue(val, label, weight);
-			}
-		} 
-		// If the new value is greater than the value in a node, update the
-		// right (>) distribution and send the value down to the right child node.
-		// If no right child exists, create one
-		else { // val > cut_point
-			if (this.right == null) {
-				if(numNodes<maxNodes){
-					this.right = new Node(val, label, weight);
-					++numNodes;
-				}
-			} else {
-			    this.right.insertValue(val, label, weight);
-			}
-		}
-        }
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/core/changedetection/NoChangeDetection.java b/moa/src/main/java/moa/classifiers/rules/core/changedetection/NoChangeDetection.java
deleted file mode 100644
index 6b8426066..000000000
--- a/moa/src/main/java/moa/classifiers/rules/core/changedetection/NoChangeDetection.java
+++ /dev/null
@@ -1,49 +0,0 @@
-package moa.classifiers.rules.core.changedetection;
-
-import moa.classifiers.core.driftdetection.AbstractChangeDetector;
-import moa.classifiers.core.driftdetection.ChangeDetector;
-import moa.core.ObjectRepository;
-import moa.tasks.TaskMonitor;
-
-public class NoChangeDetection extends AbstractChangeDetector implements
-		ChangeDetector {
-
-	/**
-	 * 
-	 */
-	private static final long serialVersionUID = 1L;
-
-	public NoChangeDetection()
-	{
-		resetLearning();
-	}
-	@Override
-	public void input(double inputValue) {
-	}
-
-	@Override
-	public void getDescription(StringBuilder sb, int indent) {
-
-	}
-
-	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
-
-	}
-	@Override
-	public void resetLearning()
-	{
-		this.isInitialized=true;
-		this.isChangeDetected=false;
-		this.isWarningZone=false;
-        this.estimation = 0.0;
-        this.delay = 0.0;
-	}
-	
-    @Override
-    public String getPurposeString() {
-        return "Use this class to NOT detect changes.";
-    }
-
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java b/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java
deleted file mode 100644
index 8db202421..000000000
--- a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java
+++ /dev/null
@@ -1,179 +0,0 @@
-/*
- *    NumericAttributeBinaryRulePredicate.java
- *    Copyright (C) 2013 University of Porto, Portugal
- *    @author E. Almeida, A. Carvalho, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-package moa.classifiers.rules.core.conditionaltests;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
-import moa.classifiers.core.conditionaltests.InstanceConditionalBinaryTest;
-import moa.classifiers.rules.core.Predicate;
-import moa.core.StringUtils;
-
-
-
-/**
- * Numeric binary conditional test for instances to use to split nodes in
- * AMRules.
- *
- * @version $Revision: 1 $
- */
-public class NumericAttributeBinaryRulePredicate extends InstanceConditionalBinaryTest implements Predicate {
-
-	private static final long serialVersionUID = 1L;
-
-	protected int attIndex;
-
-	protected double attValue;
-
-	protected int operator; // 0 =, 1<=, 2>
-
-	protected boolean state=true;
-
-	public NumericAttributeBinaryRulePredicate(int attIndex, double attValue,
-			int operator) {
-		this.attIndex = attIndex;
-		this.attValue = attValue;
-		this.operator = operator;
-	}
-
-	@Override
-	public void negateCondition() {
-		state=!state;
-
-	}
-
-	@Override
-	public int branchForInstance(Instance inst) {
-		int instAttIndex = this.attIndex < inst.classIndex() ? this.attIndex
-				: this.attIndex + 1;
-		if (inst.isMissing(instAttIndex)) {
-			return -1;
-		}
-		double v = inst.value(instAttIndex);
-		int ret = 0;
-		switch (this.operator) {
-		case 0:
-			ret = (v == this.attValue) ? 0 : 1;
-			break;
-		case 1:
-			ret = (v <= this.attValue) ? 0 : 1;
-			break;
-		case 2:
-			ret = (v > this.attValue) ? 0 : 1;
-		}
-		return ret;
-	}
-
-	/**
-	 *
-	 */
-	 @Override
-	 public String describeConditionForBranch(int branch, InstancesHeader context) {
-		if ((branch >= 0) && (branch <= 2)) {
-			String compareChar = (branch == 0) ? "=" : (branch == 1) ? "<=" : ">";
-			return InstancesHeader.getAttributeNameString(context,
-					this.attIndex)
-					+ ' '
-					+ compareChar
-					+ InstancesHeader.getNumericValueString(context,
-							this.attIndex, this.attValue);
-		}
-		throw new IndexOutOfBoundsException();
-	 }
-
-
-	 @Override
-	 public int[] getAttsTestDependsOn() {
-		 return new int[]{this.attIndex};
-	 }
-
-	 public double getSplitValue() {
-		 return this.attValue;
-	 }
-
-	 @Override
-	 public boolean evaluate(Instance inst) {
-		 if(state)
-			 return (branchForInstance(inst) == 0) ;
-		 else
-			 return (branchForInstance(inst) != 0);
-	 }
-
-	 public boolean isEqual(NumericAttributeBinaryRulePredicate predicate) {
-		 return (this.attIndex == predicate.attIndex
-				 && this.attValue == predicate.attValue
-				 && this.operator == predicate.operator);
-	 }
-
-	 public boolean isUsingSameAttribute(NumericAttributeBinaryRulePredicate predicate) {
-		 return (this.attIndex == predicate.attIndex
-				 && this.operator == predicate.operator);
-	 }
-
-	 public boolean isIncludedInRuleNode(
-			 NumericAttributeBinaryRulePredicate predicate) {
-		 boolean ret;
-		 if (this.operator == 1) { // <=
-				 ret = (predicate.attValue <= this.attValue);
-		 } else { // >
-			 ret = (predicate.attValue > this.attValue);
-		 }
-
-		 return ret;
-	 }
-
-	 public void setAttributeValue(
-			 NumericAttributeBinaryRulePredicate ruleSplitNodeTest) {
-		 this.attValue = ruleSplitNodeTest.attValue;
-
-	 }
-
-
-	 @Override
-	 public void getDescription(StringBuilder sb, int indent) {   
-		 String compareChar = (operator == 0) ? "=" : (operator == 1) ? "<=" : ">";
-		 StringUtils.appendIndented(sb, indent+1, "In" + attIndex + compareChar + attValue);
-	 }
-
-	 @Override
-	 public String toString(){
-		 StringBuilder sb = new StringBuilder();
-		 getDescription(sb,0);
-		 return sb.toString();
-	 }
-
-	 @Override
-	 public int getAttributeIndex() {
-		 return attIndex;
-	 }
-
-	 @Override
-	 public boolean isEqualOrLess() {
-		 return state;
-	 }
-
-	@Override
-	public void getDescription(StringBuilder sb, int indent, InstancesHeader header) {
-		String compareChar = (operator == 0) ? "=" : (operator == 1) ? "<=" : ">";
-		StringUtils.appendIndented(sb, indent, InstancesHeader.getAttributeNameString(header, attIndex) + compareChar + attValue);		
-	}
-	
-
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/AMRulesSplitCriterion.java b/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/AMRulesSplitCriterion.java
deleted file mode 100644
index ee46c4994..000000000
--- a/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/AMRulesSplitCriterion.java
+++ /dev/null
@@ -1,12 +0,0 @@
-package moa.classifiers.rules.core.splitcriteria;
-
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-
-public interface AMRulesSplitCriterion extends SplitCriterion{
-
-	public double[] computeBranchSplitMerits(double[][] postSplitDists);
-	
-	public double getMeritOfSplit(double[] preSplitDist, double[][] postSplitDists);
-	
-	public double getRangeOfMerit(double[] preSplitDist);
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/SDRSplitCriterionAMRulesNode.java b/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/SDRSplitCriterionAMRulesNode.java
deleted file mode 100644
index c95cf7ab0..000000000
--- a/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/SDRSplitCriterionAMRulesNode.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- *    SDRSplitCriterionAMRulesNode.java
- *    Copyright (C) 2014 University of Porto, Portugal
- *    @author A. Bifet, J. Duarte, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-package moa.classifiers.rules.core.splitcriteria;
-
-public class SDRSplitCriterionAMRulesNode extends SDRSplitCriterionAMRules implements AMRulesSplitCriterion {
-
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public double getMeritOfSplit(double[] preSplitDist, double[][] postSplitDists) {
-        double SDR=0.0;
-    	int count = 0; 
-    	
-    	for(int i = 0; i < postSplitDists.length; i++)
-    	{
-    		double Ni = postSplitDists[i][0];
-    		if(Ni >=0.05*preSplitDist[0]){
-    			count = count +1;
-    		}
-    	}
-    	if(count == postSplitDists.length){
-    		SDR = computeSD(preSplitDist);
-    		double min=Double.MAX_VALUE;
-    		for(int i = 0; i < postSplitDists.length; i++)
-        	{
-        		double val=computeSD(postSplitDists[i]);
-        		if (val<min)
-        			min=val;
-        	}
-    		SDR-=min;
-    	}
-    	return SDR;
-    }
-
-    public double[] computeBranchSplitMerits(double[][] postSplitDists) {
-    	double[] SDR = new double[postSplitDists.length];
-    	for(int i = 0; i < postSplitDists.length; i++)
-    		SDR[i] = computeSD(postSplitDists[i]);
-    	return SDR;
-
-    }
-
-
-    @Override
-    public double getRangeOfMerit(double[] preSplitDist) {
-        return 1;
-    }
-
-
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/VRSplitCriterion.java b/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/VRSplitCriterion.java
deleted file mode 100644
index ca48ad899..000000000
--- a/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/VRSplitCriterion.java
+++ /dev/null
@@ -1,52 +0,0 @@
-package moa.classifiers.rules.core.splitcriteria;
-
-import moa.classifiers.core.splitcriteria.VarianceReductionSplitCriterion;
-
-public class VRSplitCriterion extends VarianceReductionSplitCriterion implements AMRulesSplitCriterion{
-
-	private static final long serialVersionUID = -1066043659710778883L;
-
-	public double[] computeBranchSplitMerits(double[][] postSplitDists) {
-		double[] SDR = new double[postSplitDists.length];
-		double N = 0;
-
-		for(int i = 0; i < postSplitDists.length; i++)
-		{
-			double Ni = postSplitDists[i][0];
-			N += Ni;
-		}
-		for(int i = 0; i < postSplitDists.length; i++)
-		{
-			double Ni = postSplitDists[i][0];
-			SDR[i] = (Ni/N)*computeSD(postSplitDists[i]);
-		}
-		return SDR;
-
-	}
-	
-    @Override
-    public double getMeritOfSplit(double[] preSplitDist, double[][] postSplitDists) {
-        double SDR=0.0;
-    	double N = preSplitDist[0];
-    	int count = 0; 
-    	
-    	for(int i = 0; i < postSplitDists.length; i++)
-    	{
-    		double Ni = postSplitDists[i][0];
-    		if(Ni >=0.05*N){
-    			count = count +1;
-    		}
-    	}
-    	
-    	if(count == postSplitDists.length){
-    		SDR = computeSD(preSplitDist);
-    		for(int i = 0; i < postSplitDists.length; i++)
-        	{
-        		double Ni = postSplitDists[i][0];
-        		SDR -= (Ni/N)*computeSD(postSplitDists[i]);
-        	}
-    	}
-    	return SDR;
-    }
-
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/VarianceRatioSplitCriterion.java b/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/VarianceRatioSplitCriterion.java
deleted file mode 100644
index 0699bc1e4..000000000
--- a/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/VarianceRatioSplitCriterion.java
+++ /dev/null
@@ -1,79 +0,0 @@
-package moa.classifiers.rules.core.splitcriteria;
-
-import moa.classifiers.core.splitcriteria.VarianceReductionSplitCriterion;
-import moa.core.ObjectRepository;
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
-public class VarianceRatioSplitCriterion extends AbstractOptionHandler implements AMRulesSplitCriterion{
-
-	private static final long serialVersionUID = -1066043659710778883L;
-
-	public double[] computeBranchSplitMerits(double[][] postSplitDists) {
-		double[] SDR = new double[postSplitDists.length];
-		double N = 0;
-
-		for(int i = 0; i < postSplitDists.length; i++)
-		{
-			double Ni = postSplitDists[i][0];
-			N += Ni;
-		}
-		for(int i = 0; i < postSplitDists.length; i++)
-		{
-			double Ni = postSplitDists[i][0];
-			//SDR[i] = Ni/N*VarianceReductionSplitCriterion.computeSD(postSplitDists[i]);
-			SDR[i] = VarianceReductionSplitCriterion.computeSD(postSplitDists[i]);
-		}
-		return SDR;
-
-	}
-	
-	@Override
-	public double getMeritOfSplit(double[] preSplitDist, double[][] postSplitDists) {
-
-	    	double N = preSplitDist[0];
-	    	int count = 0; 
-	    	
-	    	for(int i = 0; i < postSplitDists.length; i++)
-	    	{
-	    		double Ni = postSplitDists[i][0];
-	    		if(Ni >=0.05*preSplitDist[0]){
-	    			count = count +1;
-	    		}
-	    	}
-	    	
-	    	if(count == postSplitDists.length){
-	    		double SDR = VarianceReductionSplitCriterion.computeSD(preSplitDist);
-	    		double sumPostSDR=0;
-	    		for(int i = 0; i < postSplitDists.length; i++)
-	        	{
-	        		double Ni = postSplitDists[i][0];
-	        		sumPostSDR += (Ni/N)*VarianceReductionSplitCriterion.computeSD(postSplitDists[i]);
-	        		//sumPostSDR += VarianceReductionSplitCriterion.computeSD(postSplitDists[i]);
-	        	}
-	    		//SDR=1-(sumPostSDR)/SDR;
-	    		return (1-(sumPostSDR/postSplitDists.length)/SDR);
-	    	}
-	    	else
-	    		return -Double.MAX_VALUE;
-	    	
-	}
-
-	@Override
-	public double getRangeOfMerit(double[] preSplitDist) {
-		return 1;
-	}
-
-	@Override
-	public void getDescription(StringBuilder sb, int indent) {
-		
-	}
-
-
-	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
-		
-	}
-
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/driftdetection/PageHinkleyTest.java b/moa/src/main/java/moa/classifiers/rules/driftdetection/PageHinkleyTest.java
deleted file mode 100644
index dbe04224c..000000000
--- a/moa/src/main/java/moa/classifiers/rules/driftdetection/PageHinkleyTest.java
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- *    SDRSplitCriterionAMRules.java
- *    Copyright (C) 2014 University of Porto, Portugal
- *    @author A. Bifet, J. Duarte, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-package moa.classifiers.rules.driftdetection;
-
-import java.io.Serializable;
-
-public class PageHinkleyTest implements Serializable {
-
-    private static final long serialVersionUID = 1L;
-    protected double cumulativeSum;
-    
-    public double getCumulativeSum() {
-		return cumulativeSum;
-	}
-
-	public double getMinimumValue() {
-		return minimumValue;
-	}
-
-
-	protected double minimumValue;
-    protected double sumAbsolutError;
-    protected long phinstancesSeen;
-    protected double threshold;
-    protected double alpha;
-
-    public PageHinkleyTest(double threshold, double alpha) {
-        this.threshold = threshold;
-        this.alpha = alpha;
-        this.reset();
-    }
-
-    public void reset() {
-        this.cumulativeSum = 0.0;
-        this.minimumValue = Double.MAX_VALUE;
-        this.sumAbsolutError = 0.0;
-        this.phinstancesSeen = 0;
-    }
-
-    //Compute Page-Hinkley test
-    public boolean update(double error) {
-
-        this.phinstancesSeen++;
-        double absolutError = Math.abs(error);
-        this.sumAbsolutError = this.sumAbsolutError + absolutError;
-        if (this.phinstancesSeen > 30) {
-        	double mT = absolutError - (this.sumAbsolutError / this.phinstancesSeen) - this.alpha;
-        	this.cumulativeSum = this.cumulativeSum + mT; // Update the cumulative mT sum
-        	if (this.cumulativeSum < this.minimumValue) { // Update the minimum mT value if the new mT is smaller than the current minimum
-        		this.minimumValue = this.cumulativeSum;
-        	}
-        	return (((this.cumulativeSum - this.minimumValue) > this.threshold));
-        }
-        return false;
-    }
-
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/featureranking/MeritFeatureRanking.java b/moa/src/main/java/moa/classifiers/rules/featureranking/MeritFeatureRanking.java
deleted file mode 100644
index ca75e85f2..000000000
--- a/moa/src/main/java/moa/classifiers/rules/featureranking/MeritFeatureRanking.java
+++ /dev/null
@@ -1,181 +0,0 @@
-/*
- *    MeritFeatureRanking.java
- *    Copyright (C) 2017 University of Porto, Portugal
- *    @author J. Duarte, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *
- *
- */
-package moa.classifiers.rules.featureranking;
-
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Map.Entry;
-
-import moa.classifiers.rules.featureranking.messages.ChangeDetectedMessage;
-import moa.classifiers.rules.featureranking.messages.MeritCheckMessage;
-import moa.classifiers.rules.featureranking.messages.RuleExpandedMessage;
-import moa.classifiers.rules.multilabel.core.ObservableMOAObject;
-import moa.core.DoubleVector;
-
-/**
- * Merit Feature Ranking method
- * João Duarte, João Gama,Feature ranking in hoeffding algorithms for regression. SAC 2017: 836-841
- */
-
-
-public class MeritFeatureRanking extends AbstractFeatureRanking implements FeatureRanking{
-
-	/**
-	 * 
-	 */
-	private static final long serialVersionUID = 1L;
-	
-	
-
-	protected DoubleVector attributeImportance;
-	protected HashMap<ObservableMOAObject, RuleInformation> ruleInformation;
-	
-
-
-	public MeritFeatureRanking() {
-		super();
-		this.attributeImportance = new DoubleVector();
-		this.ruleInformation =  new HashMap<ObservableMOAObject, RuleInformation>();
-	}
-
-	public void update(ObservableMOAObject o, Object arg) {
-		
-		if (arg instanceof MeritCheckMessage){
-			RuleInformation ri=ruleInformation.get(o);
-			if(ri==null)
-			{
-				ri=new RuleInformation();
-				ruleInformation.put(o, ri);
-			}
-			DoubleVector merits=ri.getCurrent();
-			if(!ri.isFirstAfterExpansion())
-				this.attributeImportance.subtractValues(merits);
-			MeritCheckMessage msg = (MeritCheckMessage) arg;
-			ri.updateCurrent(msg.getMerits());
-			merits=ri.getCurrent();
-			this.attributeImportance.addValues(merits);
-		}
-		else if (arg instanceof RuleExpandedMessage){
-			RuleInformation ri=ruleInformation.get(o);
-			if(!((RuleExpandedMessage)arg).isSpecialization())
-				ri.addNumLiterals();
-		}
-		else if (arg instanceof ChangeDetectedMessage) {
-			RuleInformation ri=ruleInformation.get(o);
-			this.attributeImportance.subtractValues(ri.getAccumulated());
-			ruleInformation.remove(o);		
-		}
-		
-
-	}
-
-	@Override
-	public DoubleVector getFeatureRankings() {
-		/*DoubleVector normRankings=null;
-		if(attributeImportance!=null){
-			double total=0;
-			for (int i=0; i<attributeImportance.numValues();i++)
-				total+=attributeImportance.getValue(i);
-			
-			//
-			normRankings=new DoubleVector();
-			double[] aux= new double[attributeImportance.numValues()];
-			for (int i=0; i<attributeImportance.numValues();i++)
-				aux[i]=attributeImportance.getValue(i)/total;	
-			normRankings= new DoubleVector(aux);
-		}
-		return normRankings;
-		*/
-		
-		if(attributeImportance==null)
-			return new DoubleVector();
-		return attributeImportance;
-	}
-
-	public DoubleVector getAccumulated() {
-		DoubleVector accumulated= new DoubleVector();
-		Iterator <Entry<ObservableMOAObject, RuleInformation>> it=this.ruleInformation.entrySet().iterator();
-	    while (it.hasNext()) {
-	        Map.Entry<ObservableMOAObject, RuleInformation> pair = (Map.Entry<ObservableMOAObject, RuleInformation>)it.next();
-	        accumulated.addValues(pair.getValue().getAccumulated());
-	    }
-		return accumulated;
-	}
-	
-	
-	/*
-	 * Rule information class
-	 */
-	public class RuleInformation{
-		private DoubleVector accumulated;
-		private DoubleVector current;
-		//private HashMap<Integer, Integer> literalAttributes;
-		private boolean isFirstAfterExpansion;
-		private int numLiterals;
-		
-		public RuleInformation() {
-			//literalAttributes=new HashMap<Integer, Integer>();
-			isFirstAfterExpansion=false;
-			accumulated=new DoubleVector();
-			current=new DoubleVector();
-			numLiterals=0;
-		}
-
-		public DoubleVector getAccumulated() {
-			return accumulated;
-		}
-		
-		public DoubleVector getCurrent() {
-			return current;
-		}
-
-		public void updateCurrent(DoubleVector merits){
-			DoubleVector newMerits=new DoubleVector(merits);
-			if(!isFirstAfterExpansion){
-				accumulated.subtractValues(current);
-			}
-			newMerits.scaleValues(1.0/(1+numLiterals));
-			accumulated.addValues(newMerits);
-			current=newMerits;
-			isFirstAfterExpansion=false;
-		}
-
-		public void addNumLiterals() {
-			/*boolean contains=false;
-			Iterator<Integer> it=literalAttributes.iterator();
-			while (it.hasNext() && !contains){
-				if(it.next()==attribIndex)
-					contains=true;
-			}
-			if(!contains){
-				literalAttributes.add(attribIndex);
-			}*/
-			this.numLiterals++;
-			isFirstAfterExpansion=true;
-		}
-
-		public boolean isFirstAfterExpansion() {
-			return isFirstAfterExpansion;
-		}
-	
-	}
-
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/featureranking/WeightedMajorityFeatureRanking.java b/moa/src/main/java/moa/classifiers/rules/featureranking/WeightedMajorityFeatureRanking.java
deleted file mode 100644
index 7e0edfb1c..000000000
--- a/moa/src/main/java/moa/classifiers/rules/featureranking/WeightedMajorityFeatureRanking.java
+++ /dev/null
@@ -1,214 +0,0 @@
-/*
- *    WeightedMajorityFeatureRanking.java
- *    Copyright (C) 2017 University of Porto, Portugal
- *    @author J. Duarte, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *
- *
- */
-
-package moa.classifiers.rules.featureranking;
-
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.List;
-
-import com.github.javacliparser.FloatOption;
-
-import moa.classifiers.rules.featureranking.messages.ChangeDetectedMessage;
-import moa.classifiers.rules.featureranking.messages.MeritCheckMessage;
-import moa.classifiers.rules.featureranking.messages.RuleExpandedMessage;
-import moa.classifiers.rules.multilabel.core.ObservableMOAObject;
-import moa.core.DoubleVector;
-
-/**
- * Weighted Majority Feature Ranking method
- * João Duarte, João Gama,Feature ranking in hoeffding algorithms for regression. SAC 2017: 836-841
- */
-
-
-
-
-public class WeightedMajorityFeatureRanking extends AbstractFeatureRanking implements FeatureRanking{
-
-	/**
-	 * 
-	 */
-	private static final long serialVersionUID = 1L;
-	
-	
-
-	protected double [] attributeImportance;
-	protected HashMap<ObservableMOAObject, RuleInformation> ruleInformation;
-	
-	public FloatOption meritThresholdOption = new FloatOption(
-			"meritThreshold",
-			'm',
-			"Merit threshold value. If the merit of an input attribute is below the threshold its importance will decrease",
-			0.01, 0.0, 1.0);
-	
-
-	public WeightedMajorityFeatureRanking() {
-		super();
-		this.ruleInformation =  new HashMap<ObservableMOAObject, RuleInformation>();
-	}
-
-	public void update(ObservableMOAObject o, Object arg) {
-		
-		if (arg instanceof MeritCheckMessage){
-
-			MeritCheckMessage msg = (MeritCheckMessage) arg;
-			//Get Learning attributes
-			boolean [] attributesMask=msg.getLearningAttributes().clone(); //because it will be modified
-			
-			int numAttributes=attributesMask.length;
-			
-			if(this.attributeImportance ==null){
-				this.attributeImportance= new double[numAttributes];
-				for (int i=0; i<attributesMask.length;i++)
-					attributeImportance[i]=1.0;
-			}
-			int numRules=ruleInformation.size();
-			RuleInformation ri=ruleInformation.get(o);
-			//Merit check of a new rule
-			if(ri==null)
-			{
-				ri=new RuleInformation(numAttributes);
-				ruleInformation.put(o, ri);
-				//new
-				for (int i=0; i<numAttributes; i++)
-					attributeImportance[i]=(attributeImportance[i]*numRules+1)/(numRules+1);
-			}
-			//Merit check of an existing rule
-			else{
-				double [] old=ri.getAttributesImportance().clone(); //it may change after update
-				List<Integer> updated=ri.update(msg.getMerits().getArrayRef(), attributesMask, meritThresholdOption.getValue());
-				
-				Iterator<Integer> it = updated.iterator();
-				while(it.hasNext()){
-					int attIndex=it.next();
-
-					this.attributeImportance[attIndex]=(attributeImportance[attIndex]*numRules-
-							old[attIndex]+ri.getAttributeImportance(attIndex))/numRules;
-				}
-			}			
-		}
-		//Rule expanded
-		else if (arg instanceof RuleExpandedMessage){
-			int numRules=ruleInformation.size();
-			RuleInformation ri=ruleInformation.get(o);
-			RuleExpandedMessage msg=((RuleExpandedMessage)arg);
-			int attIndex=msg.getAttributeIndex();
-
-			double oldValue=ri.getAttributeImportance(attIndex);
-			this.attributeImportance[attIndex]=(attributeImportance[attIndex]*numRules-oldValue+1)/numRules;
-			ri.addLiteralAttribute(attIndex);
-			
-		}
-		//Rule will be removed
-		else if (arg instanceof ChangeDetectedMessage) {
-			RuleInformation ri=ruleInformation.get(o);
-			int numRules=ruleInformation.size();
-			double [] attribImportance=ri.getAttributesImportance();
-			for (int i=0; i<this.attributeImportance.length; i++)
-				attributeImportance[i]=(attributeImportance[i]*numRules-attribImportance[i])/(numRules-1);
-			ruleInformation.remove(o);		
-		}
-		
-
-	}
-
-	@Override
-	public DoubleVector getFeatureRankings() {
-		/*DoubleVector normRankings=new DoubleVector();
-		if(attributeImportance!=null){
-			double total=0;
-			for (int i=0; i<attributeImportance.numValues();i++)
-				total+=attributeImportance.getValue(i);
-			
-			//
-			double[] aux= new double[attributeImportance.numValues()];
-			for (int i=0; i<attributeImportance.numValues();i++)
-				aux[i]=attributeImportance.getValue(i)/total;	
-			normRankings.addValues(aux);
-		}
-		return normRankings;*/
-		if(attributeImportance==null)
-			return new DoubleVector();
-		return new DoubleVector(attributeImportance);
-	}
-	
-	
-	/***********************************
-	 * 
-	 * Rule information class
-	 * 
-	 **********************************/
-	public class RuleInformation{
-		private double [] attributeImportance;
-		private double depth;
-		private List<Integer> literalAttributes= new LinkedList<Integer>();
-		
-
-		public RuleInformation(int numAttributes) {
-			attributeImportance=new double [numAttributes];
-			depth=0;
-			for(int i=0; i<numAttributes; i++)
-				attributeImportance[i]=1.0;
-		}
-
-		public void addLiteralAttribute(int attribIndex) {
-			//it means rule expanded. depth always increases. 
-			//However, the number of literals may be inferior
-			depth++;
-			attributeImportance[attribIndex]=1.0;
-			if(!literalAttributes.contains(attribIndex))
-				literalAttributes.add(attribIndex);
-		}
-
-		public double [] getAttributesImportance() {
-			return attributeImportance;
-		}
-		
-		public double getAttributeImportance(int attribIndex) {
-			return attributeImportance[attribIndex];
-		}
-		
-		
-		/*
-		 * Update the attributes importance if the merit is below the giver threshold
-		 * and the attribute is being considered (attributesMask[i]==true)
-		 * Returns the list of attributes whose merit had change
-		 */
-		public List<Integer> update(double [] merits, boolean [] attributesMask, double threshold){
-			boolean [] attributesMaskAux=attributesMask.clone();
-			Iterator<Integer> it=literalAttributes.iterator();
-			while(it.hasNext())
-				attributesMaskAux[it.next()]=false;
-			
-			List<Integer> updated=new LinkedList<Integer>();
-			for (int i=0; i<attributesMaskAux.length;i++){
-				if(merits[i]<threshold && attributesMaskAux[i]){
-					attributeImportance[i]*=(1+depth)/(2+depth);
-					updated.add(i);
-				}
-			}
-			return updated;
-		}
-				
-	
-	}
-
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/functions/AMRulesRegressorFunction.java b/moa/src/main/java/moa/classifiers/rules/functions/AMRulesRegressorFunction.java
deleted file mode 100644
index b2f6bda3a..000000000
--- a/moa/src/main/java/moa/classifiers/rules/functions/AMRulesRegressorFunction.java
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- *    BasicMultiTargetRegressor.java
- *    Copyright (C) 2017 University of Porto, Portugal
- *    @author J. Duarte, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *
- *
- */
-package moa.classifiers.rules.functions;
-
-import moa.learners.Regressor;
-
-public interface AMRulesRegressorFunction extends AMRulesLearner, Regressor{
-
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/meta/RandomAMRulesOld.java b/moa/src/main/java/moa/classifiers/rules/meta/RandomAMRulesOld.java
deleted file mode 100644
index 9629fc3df..000000000
--- a/moa/src/main/java/moa/classifiers/rules/meta/RandomAMRulesOld.java
+++ /dev/null
@@ -1,208 +0,0 @@
-/*
- *    RandomRules.java
- *    Copyright (C) 2014 University of Waikato, Hamilton, New Zealand
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.rules.meta;
-
-import java.util.Arrays;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.predictions.MultiTargetRegressionPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractMultiTargetRegressor;
-import moa.classifiers.rules.AMRulesRegressorOld;
-import moa.classifiers.rules.AbstractAMRules;
-import moa.classifiers.rules.core.voting.ErrorWeightedVote;
-import moa.classifiers.rules.core.voting.Vote;
-import moa.core.Measurement;
-import moa.core.MiscUtils;
-import moa.learners.MultiTargetRegressor;
-import moa.learners.Regressor;
-import moa.options.ClassOption;
-
-
-public class RandomAMRulesOld extends AbstractMultiTargetRegressor implements MultiTargetRegressor {
-
-	public IntOption VerbosityOption = new IntOption(
-			"verbosity",
-			'v',
-			"Output Verbosity Control Level. 1 (Less) to 2 (More)",
-			1, 1, 2);
-	
-	private static final long serialVersionUID = 1L;
-
-	public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l', "Regressor to train.", AbstractAMRules.class, AMRulesRegressorOld.class.getName()); 
-
-	public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's',
-			"The number of models in the bag.", 10, 1, Integer.MAX_VALUE);
-
-	public FloatOption numAttributesPercentageOption = new FloatOption("numAttributesPercentage", 'n',
-			"The number of attributes to use per model.", 63.2, 0, 100); 
-
-	public FlagOption useBaggingOption = new FlagOption("useBagging", 'p',
-			"Use Bagging.");
-	
-	public ClassOption votingFunctionOption = new ClassOption("votingFunction",
-			'V', "Voting Function.", 
-			ErrorWeightedVote.class,
-			"UniformWeightedVote");
-
-	public MultiChoiceOption votingTypeOption = new MultiChoiceOption(
-			"votingTypeOption", 'C', "Select whether the base learner error is computed as the overall error os only the error of the rules that cover the example.", new String[]{
-					"Overall","Only rules covered"}, new String[]{
-					"Overall","Covered"}, 0);
-	
-	public FloatOption fadingErrorFactorOption = new FloatOption(
-			"fadingErrorFactor", 'e', 
-			"Fading error factor for the accumulated error", 0.99, 0, 1);
-	
-	protected AbstractAMRules[] ensemble;
-	protected double[] sumError;
-	protected double[] nError;
-
-	protected boolean isRegression;
-
-	@Override
-	public void resetLearningImpl() {
-		this.classifierRandom.setSeed(this.randomSeedOption.getValue());
-		int n=this.ensembleSizeOption.getValue();
-		this.ensemble= new AbstractAMRules[n];
-		sumError=new double[n];
-		nError=new double[n];
-		
-		//Classifier baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
-		AbstractAMRules baseLearner = (AbstractAMRules) getPreparedClassOption(this.baseLearnerOption);
-		baseLearner.setAttributesPercentage(numAttributesPercentageOption.getValue());
-		baseLearner.resetLearning();
-		for (int i = 0; i < this.ensemble.length; i++) {
-			this.ensemble[i] = (AbstractAMRules) baseLearner.copy();
-			this.ensemble[i].setRandomSeed(this.classifierRandom.nextInt());
-		}
-		this.isRegression = (baseLearner instanceof Regressor);
-	}
-
-	@Override
-	public void trainOnInstanceImpl(Instance instance) {
-		double factor=this.fadingErrorFactorOption.getValue();
-		for (int i = 0; i < this.ensemble.length; i++) {
-			Instance inst=instance.copy();
-			int k = 1;
-			if ( this.useBaggingOption.isSet()) {
-				k = MiscUtils.poisson(1.0, this.classifierRandom);
-			} 
-			if (k > 0) {
-				//Instance weightedInst = transformInstance(inst,i);
-				inst.setWeight(inst.weight() * k);
-				
-				//estimate error
-				double error = Math.abs(inst.classValue()-ensemble[i].getPredictionForInstance(inst).asDoubleArray()[0]);
-				sumError[i]=error*inst.weight()+sumError[i]*factor;
-				nError[i]=inst.weight()+nError[i]*factor;		
-				//train learner
-				this.ensemble[i].trainOnInstance(inst);
-			}
-		}
-	}
-
-	@Override
-	public Prediction getPredictionForInstance(Instance inst) {
-		double [] votes=null;
-		//ErrorWeightedVote combinedVote = (ErrorWeightedVote)((ErrorWeightedVote) votingTypeOption.getPreMaterializedObject()).copy();
-		ErrorWeightedVote combinedVote = (ErrorWeightedVote)((ErrorWeightedVote) getPreparedClassOption(this.votingFunctionOption)).copy();
-		StringBuilder sb = null;
-		if (VerbosityOption.getValue()>1)
-			sb=new StringBuilder();
-		
-		for (int i = 0; i < this.ensemble.length; i++) {
-			// transformInstance method visibility changed from private to protected in RandomRules
-			Vote v = ((AbstractAMRules) this.ensemble[i]).getVotes(inst);
-			if (VerbosityOption.getValue()>1)
-					sb.append(Arrays.toString(v.getVote()) + ", " + " E: " + v.getError() + " ");
-			if (this.isRegression == false && v.sumVoteDistrib() != 0.0){
-				v.normalize();
-			}
-			if(this.votingTypeOption.getChosenIndex()==0){//Overall error estimation
-				combinedVote.addVote(v.getVote(),this.sumError[i]/this.nError[i]);
-			}
-			else //Error estimation over the rules that cover the example
-				combinedVote.addVote(v.getVote(), v.getError());
-		}
-		votes=combinedVote.computeWeightedVote();
-		if (VerbosityOption.getValue()>1){
-			sb.append(Arrays.toString(votes)  + ", ").append(inst.classValue()); 
-			System.out.println(sb.toString());
-		}
-		return new MultiTargetRegressionPrediction(votes); 
-	}
-
-	@Override
-	public boolean isRandomizable() {
-		return true;
-	}
-
-	@Override
-	public void getModelDescription(StringBuilder out, int indent) {
-	}
-
-	@Override
-	protected Measurement[] getModelMeasurementsImpl() {
-		Measurement [] baseLearnerMeasurements=((AbstractAMRules) getPreparedClassOption(this.baseLearnerOption)).getModelMeasurements();
-		int nMeasurements=baseLearnerMeasurements.length;
-		Measurement [] m=new Measurement[nMeasurements+1];
-
-		for(int i=0; i<baseLearnerMeasurements.length; i++)
-			m[i+1]=baseLearnerMeasurements[i];
-		
-		int ensembleSize=0;
-		if(this.ensemble !=null){	
-			ensembleSize=this.ensemble.length;
-			for(int i=0; i<nMeasurements; i++){
-				double value=0;
-				for (int j=0; j<ensembleSize; ++j){
-					value+=ensemble[j].getModelMeasurements()[i].getValue();
-				}
-				m[i+1]= new Measurement("Avg " + baseLearnerMeasurements[i].getName(), value/ensembleSize);
-			}
-		}
-	
-		m[0]=new Measurement("ensemble size", ensembleSize);
-		
-		return m;
-	}
-
-//	public Classifier[] getSubClassifiers() {
-//		return this.ensemble; //.clone();
-//	}
-
-	protected int[][] listAttributes;
-	protected int numAttributes;
-	protected InstancesHeader[] dataset;
-
-
-	
-	public String getPurposeString() {
-		return "WeightedRandomRules";
-	}
-	
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelClassifier.java b/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelClassifier.java
deleted file mode 100644
index f6ac55cc3..000000000
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelClassifier.java
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- *    AMRulesMultiLabelLearnerSemiSuper.java
- *    Copyright (C) 2017 University of Porto, Portugal
- *    @author R. Sousa, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.classifiers.rules.multilabel;
-
-import moa.classifiers.core.driftdetection.ChangeDetector;
-import moa.classifiers.mlc.core.splitcriteria.MultiLabelSplitCriterion;
-import moa.classifiers.rules.multilabel.core.MultiLabelRule;
-import moa.classifiers.rules.multilabel.core.MultiLabelRuleClassification;
-import moa.classifiers.rules.multilabel.core.splitcriteria.MultiTargetVarianceRatio;
-import moa.classifiers.rules.multilabel.core.voting.ErrorWeightedVoteMultiLabel;
-import moa.classifiers.rules.multilabel.core.voting.UniformWeightedVoteMultiLabel;
-import moa.classifiers.rules.multilabel.errormeasurers.MultiLabelErrorMeasurer;
-import moa.classifiers.rules.multilabel.errormeasurers.RelativeMeanAbsoluteDeviationMT;
-import moa.classifiers.rules.multilabel.functions.MultiLabelNaiveBayes;
-import moa.learners.MultiLabelClassifier;
-import moa.options.ClassOption;
-
-
-/**
-* Method for online multi-Label classification.
-* This method consists of the adaptation of the Multi-target Regression method 
-* to Multi-label Classification by problem transformation.
-* This also implied the adaption of AMRules to the output binary variable through the substitution of
-* some heurístics such as variance measures by entropy measures. 
-* 
-* 
-* The algorithm is fully explained in the following publication: 
-* 
-* Sousa R., Gama J. (2016) Online Multi-label Classification with Adaptive Model Rules. In: Luaces
-*  O. et al. (eds) Advances in Artificial Intelligence. CAEPIA 2016. Lecture Notes in Computer Science,
-* vol 9868. Springer.
-* 
-* @author RSousa
-* @version $Revision: 2 $
-*/
-
-
-
-public class AMRulesMultiLabelClassifier extends AMRulesMultiLabelLearner implements MultiLabelClassifier {
-
-	private static final long serialVersionUID = 1L;
-	
-    @Override
-    public String getPurposeString() {
-        return "Method for online multi-Label classification.This method consists of the adaptation of the Multi-target Regression method to Multi-label Classification by problem transformation.This also implied the adaption of AMRules to the output binary variable through the substitution ofsome heurístics such as variance measures by entropy measures.";
-    }
-	
-	public  AMRulesMultiLabelClassifier(){
-		splitCriterionOption = new ClassOption("splitCriterionOption", 'S',
-				"Split criterion used to assess the merit of a split", MultiLabelSplitCriterion.class, MultiTargetVarianceRatio.class.getName()) ;
-
-		 weightedVoteOption = new ClassOption("weightedVoteOption",
-					'w', "Weighted vote type", 
-					ErrorWeightedVoteMultiLabel.class,
-					UniformWeightedVoteMultiLabel.class.getName());
-		 
-		 learnerOption = new ClassOption("learnerOption",
-					'L', "Learner", 
-					MultiLabelClassifier.class,
-					MultiLabelNaiveBayes.class.getName());
-		 
-		 errorMeasurerOption = new ClassOption("errorMeasurer", 'e',
-					"Measure of error for deciding which learner should predict.", MultiLabelErrorMeasurer.class, RelativeMeanAbsoluteDeviationMT.class.getName()) ;
-
-		 changeDetector = new ClassOption("changeDetector",
-					'H', "Change Detector.", 
-					ChangeDetector.class,
-					"DDM");
-	}
-	
-	
-	@Override
-	protected MultiLabelRule newDefaultRule() {
-		return new MultiLabelRuleClassification(1);
-	}
-
-
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java b/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java
deleted file mode 100644
index cba15e5cc..000000000
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearner.java
+++ /dev/null
@@ -1,572 +0,0 @@
-/*
- *    AMRulesMultiLabel.java
- *    Copyright (C) 2014 University of Porto, Portugal
- *    @author J. Duarte, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.classifiers.rules.multilabel;
-
-import java.util.ListIterator;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractInstanceLearner;
-import moa.classifiers.AbstractMultiTargetRegressor;
-import moa.classifiers.core.driftdetection.ChangeDetector;
-import moa.classifiers.mlc.core.attributeclassobservers.NominalStatisticsObserver;
-import moa.classifiers.mlc.core.attributeclassobservers.NumericStatisticsObserver;
-import moa.classifiers.mlc.core.splitcriteria.MultiLabelSplitCriterion;
-import moa.classifiers.rules.core.anomalydetection.AnomalyDetector;
-import moa.classifiers.rules.core.anomalydetection.OddsRatioScore;
-import moa.classifiers.rules.featureranking.FeatureRanking;
-import moa.classifiers.rules.featureranking.NoFeatureRanking;
-import moa.classifiers.rules.featureranking.messages.ChangeDetectedMessage;
-import moa.classifiers.rules.multilabel.core.MultiLabelRule;
-import moa.classifiers.rules.multilabel.core.MultiLabelRuleSet;
-import moa.classifiers.rules.multilabel.core.ObserverMOAObject;
-import moa.classifiers.rules.multilabel.core.voting.ErrorWeightedVoteMultiLabel;
-import moa.classifiers.rules.multilabel.errormeasurers.MultiLabelErrorMeasurer;
-import moa.classifiers.rules.multilabel.functions.MultiLabelPerceptronClassification;
-import moa.classifiers.rules.multilabel.inputselectors.InputAttributesSelector;
-import moa.classifiers.rules.multilabel.inputselectors.SelectAllInputs;
-import moa.classifiers.rules.multilabel.instancetransformers.NoInstanceTransformation;
-import moa.classifiers.rules.multilabel.outputselectors.OutputAttributesSelector;
-import moa.classifiers.rules.multilabel.outputselectors.SelectAllOutputs;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.core.StringUtils;
-import moa.learners.InstanceLearner;
-import moa.learners.MultiLabelClassifier;
-import moa.learners.MultiTargetRegressor;
-import moa.options.ClassOption;
-
-
-/**
- * Adaptive Model Rules for MultiLabel problems (AMRulesML), the streaming rule learning algorithm.
- * 
- * @author  J. Duarte, J. Gama (jgama@fep.up.pt)
- * @version $Revision: 2$* 
- * 
- * This algorithm learns ordered and unordered rule set from data streams. 
- * Each rule detect anomalies and react to changes by pruning the rule set.
- * This algorithm also does the detection of anomalies.
- * 
- **/
-
-public abstract class AMRulesMultiLabelLearner extends AbstractMultiTargetRegressor implements MultiTargetRegressor {
-
-	private static final long serialVersionUID = 1L;
-	protected MultiLabelRuleSet ruleSet;
-	protected MultiLabelRule defaultRule;
-	protected int ruleNumberID=1;
-	protected double[] statistics;
-	protected ObserverMOAObject observer;
-	//public static final double NORMAL_CONSTANT = Math.sqrt(2 * Math.PI);
-	public FloatOption splitConfidenceOption = new FloatOption(
-			"splitConfidence",
-			'c',
-			"Hoeffding Bound Parameter. The allowable error in split decision, values closer to 0 will take longer to decide.",
-			0.0000001, 0.0, 1.0);
-	public FloatOption tieThresholdOption = new FloatOption("tieThreshold",
-			't', "Hoeffding Bound Parameter. Threshold below which a split will be forced to break ties.",
-			0.05, 0.0, 1.0);
-	public IntOption gracePeriodOption = new IntOption("gracePeriod",
-			'g', "Hoeffding Bound Parameter. The number of instances a leaf should observe between split attempts.",
-			200, 1, Integer.MAX_VALUE);
-
-	public ClassOption learnerOption;
-
-	public FlagOption unorderedRulesOption = new FlagOption("setUnorderedRulesOn", 'U',
-			"unorderedRules.");
-
-	public FlagOption dropOldRuleAfterExpansionOption = new FlagOption("dropOldRuleAfterExpansion", 'D',
-			"Drop old rule if it expanded (by default the rule is kept for the set of outputs not selected for expansion.)");
-
-	public ClassOption changeDetector = new ClassOption("changeDetector",
-			'H', "Change Detector.", 
-			ChangeDetector.class,
-			"PageHinkleyDM -d 0.05 -l 35.0");
-
-	public ClassOption anomalyDetector = new ClassOption("anomalyDetector",
-			'A', "Anomaly Detector.", 
-			AnomalyDetector.class,
-			OddsRatioScore.class.getName());
-
-	public ClassOption splitCriterionOption;
-
-	public ClassOption errorMeasurerOption;
-
-	public ClassOption weightedVoteOption;
-
-
-
-	public ClassOption numericObserverOption = new ClassOption("numericObserver",
-			'y', "Numeric observer.", 
-			NumericStatisticsObserver.class,
-			"MultiLabelBSTree");
-	
-	public ClassOption nominalObserverOption = new ClassOption("nominalObserver",
-			'z', "Nominal observer.", 
-			NominalStatisticsObserver.class,
-			"MultiLabelNominalAttributeObserver");
-
-	public IntOption VerbosityOption = new IntOption(
-			"verbosity",
-			'v',
-			"Output Verbosity Control Level. 1 (Less) to 5 (More)",
-			1, 1, 5);
-	
-	
-	// TODO The followint two options are deprecated
-	public ClassOption outputSelectorOption = new ClassOption("outputSelector",
-			'O', "Output attributes selector", 
-			OutputAttributesSelector.class,
-			//"StdDevThreshold");
-			SelectAllOutputs.class.getName());
-
-	public ClassOption inputSelectorOption = new ClassOption("inputSelector",
-			'I', "Input attributes selector", 
-			InputAttributesSelector.class,
-			//"MeritThreshold");
-			SelectAllInputs.class.getName());
-//	public IntOption randomSeedOption = new IntOption("randomSeedOption",
-//			'r', "randomSeedOption", 
-//			1,Integer.MIN_VALUE, Integer.MAX_VALUE);
-	
-	public ClassOption featureRankingOption = new ClassOption("featureRanking",
-			'F', "Feature ranking algorithm.", 
-			FeatureRanking.class,
-			NoFeatureRanking.class.getName());
-
-	private int nAttributes=0;
-
-	protected double attributesPercentage;
-
-	public double getAttributesPercentage() {
-		return attributesPercentage;
-	}
-
-	public void setAttributesPercentage(double attributesPercentage) {
-		this.attributesPercentage = attributesPercentage;
-	}
-
-	public AMRulesMultiLabelLearner() {
-		super();
-		super.randomSeedOption=this.randomSeedOption;
-		attributesPercentage=100;
-	}
-
-	public AMRulesMultiLabelLearner(double attributesPercentage) {
-		this();
-		this.attributesPercentage=attributesPercentage;
-	}
-
-
-	@Override
-	public Prediction getPredictionForInstance(Instance inst) {
-		ErrorWeightedVoteMultiLabel vote=getVotes(inst);
-
-		Prediction pred=vote.getPrediction();
-		if(vote!=null) {
-			if ( getPreparedClassOption(this.learnerOption) instanceof MultiLabelPerceptronClassification ) {
-				for(int i=0; i<pred.size() ; i++){
-					pred.setVote(i,0, pred.getVote(i,0) < 0.5 ? 1:0  );
-				}
-			}
-			return pred;
-		}
-		else
-			return null;
-	}
-
-	/**
-	 * getVotes extension of the instance method getPredictionForInstance 
-	 * in moa.classifier.java
-	 * returns the prediction of the instance.
-	 */
-	public ErrorWeightedVoteMultiLabel getVotes(Instance instance) {
-		ErrorWeightedVoteMultiLabel errorWeightedVote=newErrorWeightedVote();
-		//DoubleVector combinedVote = new DoubleVector();
-
-		VerboseToConsole(instance); // Verbose to console Dataset name.
-		for (MultiLabelRule rule : ruleSet) {
-			if (rule.isCovering(instance) == true){
-				//DoubleVector vote = new DoubleVector(rule.getPrediction(instance));
-				Prediction vote=rule.getPredictionForInstance(instance);
-				if (vote!=null){ //should only happen for first instance
-					double [] errors= rule.getCurrentErrors();
-					if(errors==null) //if errors==null, rule has seen no predictions since expansion: return maximum error, since prediction is not reliable
-						errors=defaultRuleErrors(vote);
-					debug("Rule No"+ rule.getRuleNumberID() + " Vote: " + vote.toString() + " Error: " + errors + " Y: " + instance.classValue(),3); //predictionValueForThisRule);
-					errorWeightedVote.addVote(vote,errors);
-				}
-				if (!this.unorderedRulesOption.isSet()) { // Ordered Rules Option. //TODO: Only break if all outputs have values assigned.Complete Prediction only with the missing values
-					break; // Only one rule cover the instance.
-				}
-			}
-		}
-
-		if(!errorWeightedVote.coversAllOutputs()) {
-			//combinedVote = new DoubleVector(defaultRule.getPrediction(instance));
-			Prediction vote=errorWeightedVote.getPrediction();
-			if (vote==null){  //use default rule
-				vote = new MultiLabelClassificationPrediction(instance.numOutputAttributes());
-			}
-			Prediction defaultVote=defaultRule.getPredictionForInstance(instance);
-			if(defaultVote!=null){
-				double [] defaultErrors= defaultRule.getCurrentErrors();
-				if(defaultErrors==null)
-					defaultErrors=defaultRuleErrors(defaultVote);
-				double [] fixErrors=new double[vote.numOutputAttributes()];
-				Prediction fixVote= new MultiLabelClassificationPrediction(vote.numOutputAttributes());
-				for (int i=0; i<vote.numOutputAttributes(); i++){
-					if(!vote.hasVotesForAttribute(i)){
-						fixVote.setVote(i, defaultVote.getPrediction(i));
-						fixErrors[i]=defaultErrors[i];
-					}
-				}
-				errorWeightedVote.addVote(fixVote,fixErrors);
-				debug("Default Rule Vote " + defaultVote.toString() + "\n Error " + defaultErrors + "  Y: " + instance,3);
-			} 
-		} 	
-		errorWeightedVote.computeWeightedVote();
-		return errorWeightedVote;
-		}
-
-	/*
-	 * Returns the estimate error for each output of a rule
-	 * Should be used when rule.getCurrentErrors() returns null
-	 */
-	protected double[] defaultRuleErrors(Prediction vote) {
-		double [] errors=new double[vote.numOutputAttributes()];
-		for(int i=0; i<vote.numOutputAttributes(); i++){
-			if(vote.hasVotesForAttribute(i))
-				errors[i]=Double.MAX_VALUE;
-		}
-		return errors;
-	}
-
-	@Override
-	public boolean isRandomizable(){
-		return true;
-	}
-
-
-	/**
-	 * AMRules Algorithm.
-	 * Method for updating (training) the AMRules model using a new instance
-	 */
-
-	private double numChangesDetected; //Just for statistics 
-	private double numAnomaliesDetected; //Just for statistics 
-	private double numInstances; //Just for statistics
-	private FeatureRanking featureRanking;
-
-	@Override
-	public void trainOnInstanceImpl(Instance instance) {
-		/**
-		 * AMRules Algorithm
-		 * 
-		 //For each rule in the rule set
-			//If rule covers the instance
-				//if the instance is not an anomaly	
-					//Update Change Detection Tests
-				    	//Compute prediction error
-				    	//Call PHTest
-						//If change is detected then
-							//Remove rule
-						//Else
-							//Update sufficient statistics of rule
-							//If number of examples in rule  > Nmin
-								//Expand rule
-						//If ordered set then
-							//break
-			//If none of the rule covers the instance
-				//Update sufficient statistics of default rule
-				//If number of examples in default rule is multiple of Nmin
-					//Expand default rule and add it to the set of rules
-					//Reset the default rule
-		 */
-		if(nAttributes==0)
-			nAttributes=instance.numInputAttributes();
-		numInstances+=instance.weight();
-		debug("Train",3);
-		debug("Nº instance "+numInstances + " - " + instance.toString(),3);
-		boolean rulesCoveringInstance = false;
-		ListIterator<MultiLabelRule> ruleIterator= this.ruleSet.listIterator();
-		while (ruleIterator.hasNext()) { 
-			MultiLabelRule rule = ruleIterator.next();
-			if (rule.isCovering(instance) == true) {
-				rulesCoveringInstance = true; //TODO: JD use different strategies for this validation (first rule, first complete rule (all out attributes covered), voted complete rule, etc)
-				if (!rule.updateAnomalyDetection(instance)) {
-					if (rule.updateChangeDetection(instance)) {
-						debug("I) Drift Detected. Exa. : " +  this.numInstances + " (" + rule.getWeightSeenSinceExpansion() +") Remove Rule: " +rule.getRuleNumberID(),1);
-						ruleIterator.remove();
-
-						//Rule expansion event
-						rule.notifyAll(new ChangeDetectedMessage());
-						
-						this.numChangesDetected+=instance.weight();  //Just for statistics 
-					} else {
-						rule.trainOnInstance(instance);
-						if (rule.getWeightSeenSinceExpansion()  % this.gracePeriodOption.getValue() == 0.0) {
-							if (rule.tryToExpand(this.splitConfidenceOption.getValue(), this.tieThresholdOption.getValue()) ) 
-							{
-
-								MultiLabelRule otherMultiLabelRule=rule.getNewRuleFromOtherOutputs(); //Need to be outside to make sure other rules are cleaned
-								if(!dropOldRuleAfterExpansionOption.isSet() && rule.hasNewRuleFromOtherOutputs()){
-									rule.clearOtherOutputs();
-									otherMultiLabelRule.setRuleNumberID(++ruleNumberID);
-									setRuleOptions(otherMultiLabelRule);
-									ruleIterator.add(otherMultiLabelRule);
-									if(observer!=null)
-										otherMultiLabelRule.addObserver(observer);
-								}
-								setRuleOptions(rule);
-								debug("Rule Expanded:",2);
-								debug(rule.toString(),2);
-							}	
-						}
-					}
-				}
-				else {
-					debug("Anomaly Detected: " + this.numInstances + " Rule: " +rule.getRuleNumberID() ,1);
-					this.numAnomaliesDetected+=instance.weight();//Just for statistics
-				}
-				if (!this.unorderedRulesOption.isSet()) 
-					break;
-
-			}
-		}	
-
-		if (rulesCoveringInstance == false){ 
-			defaultRule.trainOnInstance(instance);
-			if (defaultRule.getWeightSeenSinceExpansion() % this.gracePeriodOption.getValue() == 0.0) {
-				debug("Nr. examples "+defaultRule.getWeightSeenSinceExpansion(), 4);
-
-				if (defaultRule.tryToExpand(this.splitConfidenceOption.getValue(), this.tieThresholdOption.getValue()) == true) {
-					//create new default rule
-					MultiLabelRule newDefaultRule=defaultRule.getNewRuleFromOtherBranch();
-					newDefaultRule.setRuleNumberID(++ruleNumberID);
-					setRuleOptions(newDefaultRule);
-					
-					//Add expanded rule to ruleset
-					setRuleOptions(defaultRule);
-					ruleSet.add(this.defaultRule);
-					
-
-					debug("Default rule expanded! New Rule:",2);
-					debug(defaultRule.toString(),2);
-					debug("New default rule:", 3);	
-					debug(newDefaultRule.toString(),3);
-					defaultRule=newDefaultRule;
-					if(observer!=null)
-						defaultRule.addObserver(observer);
-				}
-			}
-		}
-	}
-
-
-
-	/**
-	 * print GUI evaluate model	
-	 */
-	@Override
-	protected Measurement[] getModelMeasurementsImpl() {
-		Measurement[] m=null;
-		Measurement[] mNoFeatureRanking=new Measurement[]{
-				new Measurement("anomaly detections", this.numAnomaliesDetected),
-				new Measurement("change detections", this.numChangesDetected), 
-				new Measurement("rules (number)", this.ruleSet.size()+1),
-				new Measurement("Avg #inputs/rule", getAverageInputs()),
-				new Measurement("Avg #outputs/rule", getAverageOutputs())}; 
-		
-		if(featureRanking instanceof NoFeatureRanking){
-			m=mNoFeatureRanking;
-		}
-		else{
-			m=new Measurement[mNoFeatureRanking.length+this.nAttributes];
-			for(int i=0; i<mNoFeatureRanking.length; i++)
-				m[i]=mNoFeatureRanking[i];
-			DoubleVector rankings=this.featureRanking.getFeatureRankings();
-			for(int i=0; i<this.nAttributes; i++)
-				m[i+mNoFeatureRanking.length]=new Measurement("Attribute" + i, rankings.getValue(i));
-		}
-		return m;
-	}
-
-	protected double getAverageInputs() {
-		double avg=0;
-		int ct=0;
-		if(ruleSet.size()>0){
-			for (MultiLabelRule r : ruleSet){
-				int [] aux=r.getInputsCovered();
-				if(aux!=null){
-					avg+=aux.length;
-					ct++;
-				}
-			}
-		}
-		int [] aux=defaultRule.getInputsCovered();
-		if(aux!=null){
-			avg+=aux.length;
-			ct++;
-		}
-		if(ct>0)
-			avg/=ct;
-		return avg;
-	}
-
-	protected double getAverageOutputs() {
-		double avg=0;
-		int ct=0;
-		if(ruleSet.size()>0){
-			for (MultiLabelRule r : ruleSet){
-				int [] aux=r.getOutputsCovered();
-				if(aux!=null){
-					avg+=aux.length;
-					ct++;
-				}
-			}
-		}
-		int [] aux=defaultRule.getOutputsCovered();
-		if(aux!=null){
-			avg+=aux.length;
-			ct++;
-		}
-		if(ct>0)
-			avg/=ct;
-		return avg;
-	}
-
-	/**
-	 * print GUI learn model	
-	 */
-	@Override
-	public void getModelDescription(StringBuilder out, int indent) {
-		if(!this.unorderedRulesOption.isSet()){
-			StringUtils.appendIndented(out, indent, "Method Ordered");
-			StringUtils.appendNewline(out);
-		}else{
-			StringUtils.appendIndented(out, indent, "Method Unordered");
-			StringUtils.appendNewline(out);
-		}
-		StringUtils.appendIndented(out, indent, "Number of Rules: " + (this.ruleSet.size()+1));
-		StringUtils.appendNewline(out);
-		
-		StringUtils.appendIndented(out, indent, "Default rule :");
-		this.defaultRule.getDescription(out, indent);
-		StringUtils.appendNewline(out);
-		
-		StringUtils.appendIndented(out, indent, "Rules in ruleSet:");
-		StringUtils.appendNewline(out);
-		for (MultiLabelRule rule: ruleSet) {
-			rule.getDescription(out, indent);
-			StringUtils.appendNewline(out);
-		}
-	}
-
-	/**
-	 * Print to console
-	 * @param string
-	 */
-	protected void debug(String string, int level) {
-		if (VerbosityOption.getValue()>=level){
-			System.out.println(string); 
-		}
-	}
-
-	protected void VerboseToConsole(Instance inst) {
-		if(VerbosityOption.getValue()>=5){	
-			System.out.println(); 
-			System.out.println("I) Dataset: "+inst.dataset().getRelationName()); 
-
-			if(!this.unorderedRulesOption.isSet()){ 
-				System.out.println("I) Method Ordered");
-			}else{
-				System.out.println("I) Method Unordered");
-			}
-		}    	
-	}
-
-	public void PrintRuleSet() {    
-		debug("Default rule :",2);
-		debug(this.defaultRule.toString(),2);
-		
-		debug("Rules in ruleSet:",2);
-		for (MultiLabelRule rule: ruleSet) {
-			debug(rule.toString(),2);
-		}
-	}
-
-
-	@Override
-	public void resetLearningImpl() {
-		defaultRule=newDefaultRule();
-		this.classifierRandom.setSeed(this.randomSeed);
-		InstanceLearner l = (InstanceLearner) ((InstanceLearner)getPreparedClassOption(learnerOption)).copy();
-		l.setRandomSeed(this.randomSeed);
-		l.resetLearning();
-		defaultRule.setLearner(l);
-		defaultRule.setInstanceTransformer(new NoInstanceTransformation());
-		setRuleOptions(defaultRule);
-		ruleSet = new MultiLabelRuleSet();
-		ruleNumberID=1;
-		statistics=null;
-		this.featureRanking=(FeatureRanking) getPreparedClassOption(this.featureRankingOption);
-		setObserver(featureRanking);
-	}
-	
-
-	protected void setRuleOptions(MultiLabelRule rule){
-		rule.setSplitCriterion((MultiLabelSplitCriterion)((MultiLabelSplitCriterion)getPreparedClassOption(splitCriterionOption)).copy());
-		rule.setChangeDetector((ChangeDetector)((ChangeDetector)getPreparedClassOption(changeDetector)).copy());
-		rule.setAnomalyDetector((AnomalyDetector)((AnomalyDetector)getPreparedClassOption(anomalyDetector)).copy());
-		rule.setNumericObserverOption((NumericStatisticsObserver)((NumericStatisticsObserver)getPreparedClassOption(numericObserverOption)).copy());
-		rule.setNominalObserverOption((NominalStatisticsObserver)((NominalStatisticsObserver)getPreparedClassOption(nominalObserverOption)).copy());
-		rule.setErrorMeasurer((MultiLabelErrorMeasurer)((MultiLabelErrorMeasurer)getPreparedClassOption(errorMeasurerOption)).copy());
-		rule.setOutputAttributesSelector((OutputAttributesSelector)((OutputAttributesSelector)getPreparedClassOption(outputSelectorOption)).copy());
-		rule.setRandomGenerator(this.classifierRandom);
-		rule.setAttributesPercentage(this.attributesPercentage);
-		rule.setInputAttributesSelector((InputAttributesSelector)((InputAttributesSelector)getPreparedClassOption(inputSelectorOption)).copy());
-	}
-
-	abstract protected MultiLabelRule newDefaultRule();
-
-	public ErrorWeightedVoteMultiLabel newErrorWeightedVote(){
-		return (ErrorWeightedVoteMultiLabel)((ErrorWeightedVoteMultiLabel) getPreparedClassOption(weightedVoteOption)).copy();
-	}
-
-
-
-	public void setRandomSeed(int randomSeed){
-		super.setRandomSeed(randomSeed);
-		this.classifierRandom.setSeed(randomSeed);
-	}
-
-	public void setObserver(ObserverMOAObject observer){
-		this.observer=observer;
-		this.defaultRule.addObserver(observer);
-	}
-
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearnerSemiSuper.java b/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearnerSemiSuper.java
deleted file mode 100644
index c53e2c5ee..000000000
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiLabelLearnerSemiSuper.java
+++ /dev/null
@@ -1,613 +0,0 @@
-/*
- *    AMRulesMultiLabelLearnerSemiSuper.java
- *    Copyright (C) 2017 University of Porto, Portugal
- *    @author R. Sousa, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.classifiers.rules.multilabel;
-
-import java.util.ListIterator;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.MultiTargetRegressionPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractMultiLabelClassifier;
-import moa.classifiers.MultiTargetLearnerSemiSupervised;
-import moa.classifiers.core.driftdetection.ChangeDetector;
-import moa.classifiers.mlc.core.attributeclassobservers.NominalStatisticsObserver;
-import moa.classifiers.mlc.core.attributeclassobservers.NumericStatisticsObserver;
-import moa.classifiers.mlc.core.splitcriteria.MultiLabelSplitCriterion;
-import moa.classifiers.rules.core.anomalydetection.AnomalyDetector;
-import moa.classifiers.rules.core.anomalydetection.OddsRatioScore;
-import moa.classifiers.rules.featureranking.FeatureRanking;
-import moa.classifiers.rules.featureranking.NoFeatureRanking;
-import moa.classifiers.rules.featureranking.messages.ChangeDetectedMessage;
-import moa.classifiers.rules.multilabel.core.MultiLabelRule;
-import moa.classifiers.rules.multilabel.core.MultiLabelRuleSet;
-import moa.classifiers.rules.multilabel.core.ObserverMOAObject;
-import moa.classifiers.rules.multilabel.core.voting.ErrorWeightedVoteMultiLabel;
-import moa.classifiers.rules.multilabel.errormeasurers.MultiLabelErrorMeasurer;
-import moa.classifiers.rules.multilabel.inputselectors.InputAttributesSelector;
-import moa.classifiers.rules.multilabel.inputselectors.SelectAllInputs;
-import moa.classifiers.rules.multilabel.instancetransformers.NoInstanceTransformation;
-import moa.classifiers.rules.multilabel.outputselectors.OutputAttributesSelector;
-import moa.classifiers.rules.multilabel.outputselectors.SelectAllOutputs;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.core.StringUtils;
-import moa.learners.InstanceLearner;
-import moa.learners.MultiLabelClassifier;
-import moa.options.ClassOption;
-
-
-/**
- * Semi-supervised method for online multi-target regression.
- * This method uses the AMRules as learner and it based on probabilistic method very similar to 
- * anomaly detection.
- * This method measures predicts the benefit of a unlabeled example to the models(using only the input information) to the 
- * model. If this benefit is higher than <scoreThreshold> then the algorithm predicts an output and 
- * artificially labels the example and use it for training.  
-
-
-The algorithm is fully explained in the following publication: 
-
- *Sousa R., Gama J. (2016) Online Semi-supervised Learning for Multi-target Regression 
- *in Data Streams Using AMRules. In: Boström H., Knobbe A., Soares C., Papapetrou P. (eds)
- *Advances in Intelligent Data Analysis XV. IDA 2016. Lecture Notes in Computer Science, 
- *vol 9897. Springer.
-
- * @author RSousa
- * @version $Revision: 2 $
- */
-
-
-
-
-public abstract class AMRulesMultiLabelLearnerSemiSuper extends AbstractMultiLabelClassifier implements MultiTargetLearnerSemiSupervised { 
-
-	private static final long serialVersionUID = 1L;
-	protected MultiLabelRuleSet ruleSet;
-	protected MultiLabelRule defaultRule;
-	protected int ruleNumberID=1;
-	protected double[] statistics;
-	protected ObserverMOAObject observer;
-
-	//
-	public FloatOption splitConfidenceOption = new FloatOption("splitConfidence",
-			'c',"Hoeffding Bound Parameter. The allowable error in split decision, values closer to 0 will take longer to decide.",0.0000001, 0.0, 1.0);
-	public FloatOption tieThresholdOption = new FloatOption("tieThreshold",
-			't', "Hoeffding Bound Parameter. Threshold below which a split will be forced to break ties.",0.05, 0.0, 1.0);
-	public IntOption gracePeriodOption = new IntOption("gracePeriod",
-			'g', "Hoeffding Bound Parameter. The number of instances a leaf should observe between split attempts.",200, 1, Integer.MAX_VALUE);   
-	public ClassOption learnerOption;
-	public FlagOption unorderedRulesOption = new FlagOption("setUnorderedRulesOn",
-			'U',"unorderedRules.");
-	public FlagOption dropOldRuleAfterExpansionOption = new FlagOption("dropOldRuleAfterExpansion",
-			'D',"Drop old rule if it expanded (by default the rule is kept for the set of outputs not selected for expansion.)");
-	public ClassOption changeDetector;
-
-	public ClassOption anomalyDetector = new ClassOption("anomalyDetector",
-			'A', "Anomaly Detector.", AnomalyDetector.class,OddsRatioScore.class.getName());
-	public ClassOption splitCriterionOption;
-
-	public ClassOption errorMeasurerOption;
-
-	public ClassOption weightedVoteOption;
-
-	public ClassOption numericObserverOption = new ClassOption("numericObserver",
-			'y', "Numeric observer.", NumericStatisticsObserver.class,"MultiLabelBSTree");
-	public ClassOption nominalObserverOption = new ClassOption("nominalObserver",
-			'z', "Nominal observer.", 
-			NominalStatisticsObserver.class,
-			"MultiLabelNominalAttributeObserver");
-	public IntOption VerbosityOption = new IntOption(
-			"verbosity",
-			'v',
-			"Output Verbosity Control Level. 1 (Less) to 5 (More)",
-			1, 1, 5);
-	public ClassOption outputSelectorOption = new ClassOption("outputSelector",
-			'O', "Output attributes selector", 
-			OutputAttributesSelector.class,
-			SelectAllOutputs.class.getName());
-	public ClassOption inputSelectorOption = new ClassOption("inputSelector",
-			'I', "Input attributes selector", 
-			InputAttributesSelector.class,
-			SelectAllInputs.class.getName());
-//	public IntOption randomSeedOption = new IntOption("randomSeedOption",
-//			'r', "randomSeedOption", 
-//			1,Integer.MIN_VALUE, Integer.MAX_VALUE);	
-	public ClassOption featureRankingOption = new ClassOption("featureRanking",
-			'F', "Feature ranking algorithm.", 
-			FeatureRanking.class,
-			NoFeatureRanking.class.getName());
-	public FloatOption scoreThreshold = new FloatOption("scoreThreshold",
-			'h', "Initial dataset (%)", 1);
-	public IntOption  slidingWindowSize= new IntOption("slidingWindowSize",
-			'W', "slidingWindowSize", 1000);
-	public IntOption  slidingWindowStep= new IntOption("slidingWindowStep",
-			'j', "slidingWindowStep", 1);
-
-	private int nAttributes=0;
-
-	protected double attributesPercentage;
-
-	public double getAttributesPercentage() {
-		return attributesPercentage;
-	}
-
-	public void setAttributesPercentage(double attributesPercentage) {
-		this.attributesPercentage = attributesPercentage;
-	}
-
-	public AMRulesMultiLabelLearnerSemiSuper() {
-		super();
-		super.randomSeedOption=this.randomSeedOption;
-		attributesPercentage=100;
-	}
-
-	public AMRulesMultiLabelLearnerSemiSuper(double attributesPercentage) {
-		this();
-		this.attributesPercentage=attributesPercentage;
-	}
-
-
-	@Override
-	public Prediction getPredictionForInstance(Instance inst) {
-		ErrorWeightedVoteMultiLabel vote=getVotes(inst);
-		if(vote!=null)	
-			return vote.getPrediction();
-		else
-			return null;
-	}
-
-	/**
-	 * getVotes extension of the instance method getVotesForInstance 
-	 * in moa.classifier.java
-	 * returns the prediction of the instance.
-	 */
-	public ErrorWeightedVoteMultiLabel getVotes(Instance instance) {
-
-		ErrorWeightedVoteMultiLabel errorWeightedVote=newErrorWeightedVote(); 
-		//int numberOfRulesCovering = 0;
-		VerboseToConsole(instance); // Verbose to console Dataset name.
-
-		for (MultiLabelRule rule : ruleSet) {
-
-			if (rule.isCovering(instance) == true){
-				//numberOfRulesCovering++;
-
-				Prediction vote=rule.getPredictionForInstance(instance);
-
-				if (vote!=null){ //should only happen for first instance
-					double [] errors= rule.getCurrentErrors();
-					if(errors==null) //if errors==null, rule has seen no predictions since expansion: return maximum error, since prediction is not reliable
-						errors=defaultRuleErrors(vote);
-					debug("Rule No"+ rule.getRuleNumberID() + " Vote: " + vote.toString() + " Error: " + errors + " Y: " + instance.classValue(),3); //predictionValueForThisRule);
-					errorWeightedVote.addVote(vote,errors);
-				}
-
-				if (VerbosityOption.getValue()>1){
-					System.out.print("Rule " + rule.getRuleNumberID()+ ": ");
-					for (int i=0; i< instance.numOutputAttributes() ; i++){
-						System.out.print(" " + vote.getVotes(i)[0]);
-					}
-					System.out.print("\n");
-				}
-
-				if (!this.unorderedRulesOption.isSet()) { // Ordered Rules Option.
-					break; // Only one rule cover the instance.
-				}
-			}
-		}
-
-
-
-		if(!errorWeightedVote.coversAllOutputs()) {
-			//Complete Prediction (fill missing outputs with default)
-			Prediction vote=errorWeightedVote.getPrediction();
-
-			if (vote==null){  //use default rule
-				vote = new MultiTargetRegressionPrediction(instance.numOutputAttributes());
-			}
-
-			Prediction defaultVote=defaultRule.getPredictionForInstance(instance);
-			if(defaultVote!=null){
-
-				double [] defaultErrors= defaultRule.getCurrentErrors();
-
-				if(defaultErrors==null)
-					defaultErrors=defaultRuleErrors(defaultVote);
-
-				double [] fixErrors=new double[vote.numOutputAttributes()];
-				Prediction fixVote= new MultiTargetRegressionPrediction(vote.numOutputAttributes());
-				for (int i=0; i<vote.numOutputAttributes(); i++){
-					if(!vote.hasVotesForAttribute(i)){
-						fixVote.setVote(i, defaultVote.getPrediction(i));
-						fixErrors[i]=defaultErrors[i];
-					}
-				}
-				errorWeightedVote.addVote(fixVote,fixErrors);
-				debug("Default Rule Vote " + defaultVote.toString() + "\n Error " + defaultErrors + "  Y: " + instance,3);
-			}
-		} 	
-		errorWeightedVote.computeWeightedVote();
-
-		return errorWeightedVote;
-	}
-
-	/*
-	 * Returns the estimate error for each output of a rule
-	 * Should be used when rule.getCurrentErrors() returns null
-	 */
-	protected double[] defaultRuleErrors(Prediction vote) {
-		double [] errors=new double[vote.numOutputAttributes()];
-		for(int i=0; i<vote.numOutputAttributes(); i++){
-			if(vote.hasVotesForAttribute(i))
-				errors[i]=Double.MAX_VALUE;
-		}
-		return errors;
-	}
-
-	@Override
-	public boolean isRandomizable(){
-		return true;
-	}
-
-
-	/**
-	 * AMRules Algorithm.
-	 * Method for updating (training) the AMRules model using a new instance
-	 */
-
-	private double numChangesDetected;      //Just for statistics 
-	private double numAnomaliesDetected;    //Just for statistics 
-	private double numInstances;            //Just for statistics
-	private FeatureRanking featureRanking;
-	public Prediction prediction;
-	public int numberTotalExamples;
-	public boolean hasModel=false;
-	boolean isUnlabeled;
-	public AnomalyDetector anomalyDetector2;
-
-
-	@Override
-	public void trainOnInstanceImpl(Instance instance) {
-
-		if(nAttributes==0)
-			nAttributes=instance.numInputAttributes();
-
-		numInstances+=instance.weight();
-		debug("Train",3);
-		debug("Nº instance "+numInstances + " - " + instance.toString(),3);
-
-		boolean rulesCoveringInstance = false;
-		ListIterator<MultiLabelRule> ruleIterator= this.ruleSet.listIterator();
-
-		numberTotalExamples++;
-
-		prediction= new MultiLabelClassificationPrediction(instance.numOutputAttributes());
-		boolean isUnlabeledRejected=true; 
-
-		isUnlabeled=false;
-		for(int m=0; m < instance.numOutputAttributes() ; m++){
-			if(instance.valueOutputAttribute(m)==Double.NEGATIVE_INFINITY){ 
-				isUnlabeled=true;
-				break;
-			} 
-		}
-
-		if(numberTotalExamples==1){
-			anomalyDetector2= new OddsRatioScore(); 
-		}
-
-
-		//----------------------------------------------------------------------
-		while (ruleIterator.hasNext()) { 
-			MultiLabelRule rule = ruleIterator.next();
-			if (rule.isCovering(instance) == true) {
-				rulesCoveringInstance = true;
-				if (!rule.updateAnomalyDetection(instance) ) {
-					prediction=rule.getPredictionForInstance(instance);
-					if( isUnlabeled ){
-						if(rule.getAnomalyScore() >= scoreThreshold.getValue() ){
-							for( int a=0 ; a<instance.numOutputAttributes() ; a++)
-								instance.setClassValue(a,prediction.getVote(a,0));
-							isUnlabeledRejected=false; //Unlabeled rejected
-						}
-						else
-							continue;
-					}
-
-					//----------------------------------------------------------
-					if (rule.updateChangeDetection(instance)) {
-						debug("I) Drift Detected. Exa. : " +  numInstances + " (" + rule.getWeightSeenSinceExpansion() +") Remove Rule: " +rule.getRuleNumberID(),1);
-						ruleIterator.remove();                         //Remove a regra 
-						rule.notifyAll(new ChangeDetectedMessage());   //Rule expansion event			
-						this.numChangesDetected += instance.weight();  //Just for statistics 
-					} else {
-
-						rule.trainOnInstance(instance); //<<<<<<<<<<<<
-						if (rule.getWeightSeenSinceExpansion()  % gracePeriodOption.getValue() == 0.0) { 
-							if (rule.tryToExpand(splitConfidenceOption.getValue(), tieThresholdOption.getValue()) ) {
-
-								MultiLabelRule otherMultiLabelRule = rule.getNewRuleFromOtherOutputs(); //Need to be outside to make sure other rules are cleaned
-
-								if(!dropOldRuleAfterExpansionOption.isSet() && rule.hasNewRuleFromOtherOutputs()){
-									rule.clearOtherOutputs();
-									otherMultiLabelRule.setRuleNumberID(++ruleNumberID);
-									setRuleOptions(otherMultiLabelRule);
-									ruleIterator.add(otherMultiLabelRule);
-									if(observer!=null)
-										otherMultiLabelRule.addObserver(observer);
-								}
-								setRuleOptions(rule);
-								debug("Rule Expanded:",2);
-								debug(rule.toString(),2);
-							}	
-						}
-					}
-				}
-				else {
-					debug("Anomaly Detected: " + numInstances + " Rule: " +rule.getRuleNumberID() ,1);
-					numAnomaliesDetected+=instance.weight();//Just for statistics
-				}
-
-				// Testa se  ordered ou unordered
-				if (!unorderedRulesOption.isSet()) 
-					break;
-			}
-
-		}
-
-		//----------------------------------------------------------------------
-
-		if (rulesCoveringInstance == false){
-
-			isUnlabeledRejected=false;
-
-			for(int m=0; m < instance.numOutputAttributes() ; m++){
-				if(instance.valueOutputAttribute(m)==Double.NEGATIVE_INFINITY ){
-
-					prediction=defaultRule.getPredictionForInstance(instance);
-
-					for( int a=0 ; a<instance.numOutputAttributes() ; a++){
-						instance.setClassValue(a,prediction.getVote(a,0)); 
-					}
-					break;
-				}            
-			}
-
-			defaultRule.trainOnInstance(instance);
-
-			if (defaultRule.getWeightSeenSinceExpansion() % this.gracePeriodOption.getValue() == 0.0) {
-				debug("Nr. examples "+defaultRule.getWeightSeenSinceExpansion(), 4);
-				if ( defaultRule.tryToExpand(this.splitConfidenceOption.getValue(), this.tieThresholdOption.getValue()) == true) {
-					MultiLabelRule newDefaultRule=defaultRule.getNewRuleFromOtherBranch();
-					newDefaultRule.setRuleNumberID(++ruleNumberID);
-					setRuleOptions(newDefaultRule);
-					setRuleOptions(defaultRule);
-					ruleSet.add(defaultRule);
-					debug("Default rule expanded! New Rule:",2);
-					debug(defaultRule.toString(),2);
-					debug("New default rule:", 3);	
-					debug(newDefaultRule.toString(),3);
-					defaultRule=newDefaultRule;
-					if(observer!=null)
-						defaultRule.addObserver(observer);
-				}
-			}
-		}
-		//----------------------------------------------------------------------
-	}   
-
-
-
-	/**
-	 * print GUI evaluate model	
-	 */
-	@Override
-	protected Measurement[] getModelMeasurementsImpl() {
-		Measurement[] m=null;
-		Measurement[] mNoFeatureRanking=new Measurement[]{
-				new Measurement("anomaly detections", this.numAnomaliesDetected),
-				new Measurement("change detections", this.numChangesDetected), 
-				new Measurement("rules (number)", this.ruleSet.size()+1),
-				new Measurement("Avg #inputs/rule", getAverageInputs()),
-				new Measurement("Avg #outputs/rule", getAverageOutputs())}; 
-
-		if(featureRanking instanceof NoFeatureRanking){
-			m=mNoFeatureRanking;
-		}
-		else{
-			m=new Measurement[mNoFeatureRanking.length+this.nAttributes];
-			for(int i=0; i<mNoFeatureRanking.length; i++)
-				m[i]=mNoFeatureRanking[i];
-			DoubleVector rankings=this.featureRanking.getFeatureRankings();
-			for(int i=0; i<this.nAttributes; i++)
-				m[i+mNoFeatureRanking.length]=new Measurement("Attribute" + i, rankings.getValue(i));
-		}
-		return m;
-	}
-
-	protected double getAverageInputs() {
-		double avg=0;
-		int ct=0;
-		if(ruleSet.size()>0){
-			for (MultiLabelRule r : ruleSet){
-				int [] aux=r.getInputsCovered();
-				if(aux!=null){
-					avg+=aux.length;
-					ct++;
-				}
-			}
-		}
-		int [] aux=defaultRule.getInputsCovered();
-		if(aux!=null){
-			avg+=aux.length;
-			ct++;
-		}
-		if(ct>0)
-			avg/=ct;
-		return avg;
-	}
-
-	protected double getAverageOutputs() {
-		double avg=0;
-		int ct=0;
-		if(ruleSet.size()>0){
-			for (MultiLabelRule r : ruleSet){
-				int [] aux=r.getOutputsCovered();
-				if(aux!=null){
-					avg+=aux.length;
-					ct++;
-				}
-			}
-		}
-		int [] aux=defaultRule.getOutputsCovered();
-		if(aux!=null){
-			avg+=aux.length;
-			ct++;
-		}
-		if(ct>0)
-			avg/=ct;
-		return avg;
-	}
-
-	/**
-	 * print GUI learn model	
-	 */
-	@Override
-	public void getModelDescription(StringBuilder out, int indent) {
-		if(!this.unorderedRulesOption.isSet()){
-			StringUtils.appendIndented(out, indent, "Method Ordered");
-			StringUtils.appendNewline(out);
-		}else{
-			StringUtils.appendIndented(out, indent, "Method Unordered");
-			StringUtils.appendNewline(out);
-		}
-		StringUtils.appendIndented(out, indent, "Number of Rules: " + (this.ruleSet.size()+1));
-		StringUtils.appendNewline(out);
-
-		StringUtils.appendIndented(out, indent, "Default rule :");
-		this.defaultRule.getDescription(out, indent);
-		StringUtils.appendNewline(out);
-
-		StringUtils.appendIndented(out, indent, "Rules in ruleSet:");
-		StringUtils.appendNewline(out);
-		for (MultiLabelRule rule: ruleSet) {
-			rule.getDescription(out, indent);
-			StringUtils.appendNewline(out);
-		}
-	}
-
-	/**
-	 * Print to console
-	 * @param string
-	 */
-	protected void debug(String string, int level) {
-		if (VerbosityOption.getValue()>=level){
-			System.out.println(string); 
-		}
-	}
-
-	protected void VerboseToConsole(Instance inst) {
-		if(VerbosityOption.getValue()>=5){	
-			System.out.println(); 
-			System.out.println("I) Dataset: "+inst.dataset().getRelationName()); 
-
-			if(!this.unorderedRulesOption.isSet()){ 
-				System.out.println("I) Method Ordered");
-			}else{
-				System.out.println("I) Method Unordered");
-			}
-		}    	
-	}
-
-	public void PrintRuleSet() {    
-		debug("Default rule :",2);
-		debug(this.defaultRule.toString(),2);
-
-		debug("Rules in ruleSet:",2);
-		for (MultiLabelRule rule: ruleSet) {
-			debug(rule.toString(),2);
-		}
-	}
-
-
-	@Override
-	public void resetLearningImpl() {
-
-		defaultRule=newDefaultRule();
-		this.classifierRandom.setSeed(this.randomSeed);
-		InstanceLearner l = (InstanceLearner)((InstanceLearner)getPreparedClassOption(learnerOption)).copy();
-
-		l.setRandomSeed(this.randomSeed);
-
-		l.resetLearning();
-		defaultRule.setLearner(l);
-		defaultRule.setInstanceTransformer(new NoInstanceTransformation());
-		setRuleOptions(defaultRule);
-		ruleSet = new MultiLabelRuleSet();
-		ruleNumberID=1;
-		statistics=null;
-		this.featureRanking=(FeatureRanking) getPreparedClassOption(this.featureRankingOption);
-		setObserver(featureRanking);
-
-	}
-
-
-	protected void setRuleOptions(MultiLabelRule rule){
-		rule.setSplitCriterion((MultiLabelSplitCriterion)((MultiLabelSplitCriterion)getPreparedClassOption(splitCriterionOption)).copy());
-		rule.setChangeDetector((ChangeDetector)((ChangeDetector)getPreparedClassOption(changeDetector)).copy());
-		rule.setAnomalyDetector((AnomalyDetector)((AnomalyDetector)getPreparedClassOption(anomalyDetector)).copy());
-		rule.setNumericObserverOption((NumericStatisticsObserver)((NumericStatisticsObserver)getPreparedClassOption(numericObserverOption)).copy());
-		rule.setNominalObserverOption((NominalStatisticsObserver)((NominalStatisticsObserver)getPreparedClassOption(nominalObserverOption)).copy());
-		rule.setErrorMeasurer((MultiLabelErrorMeasurer)((MultiLabelErrorMeasurer)getPreparedClassOption(errorMeasurerOption)).copy());
-		rule.setOutputAttributesSelector((OutputAttributesSelector)((OutputAttributesSelector)getPreparedClassOption(outputSelectorOption)).copy());
-		rule.setRandomGenerator(this.classifierRandom);
-		rule.setAttributesPercentage(this.attributesPercentage);
-		rule.setInputAttributesSelector((InputAttributesSelector)((InputAttributesSelector)getPreparedClassOption(inputSelectorOption)).copy());
-	}
-
-	abstract protected MultiLabelRule newDefaultRule();
-
-	public ErrorWeightedVoteMultiLabel newErrorWeightedVote(){
-		return (ErrorWeightedVoteMultiLabel)((ErrorWeightedVoteMultiLabel) getPreparedClassOption(weightedVoteOption)).copy();
-	}
-
-
-
-	public void setRandomSeed(int randomSeed){
-		super.setRandomSeed(randomSeed);
-		this.classifierRandom.setSeed(randomSeed);
-	}
-
-	public void setObserver(ObserverMOAObject observer){
-		this.observer=observer;
-		this.defaultRule.addObserver(observer);
-	}
-
-	public Prediction getTrainingPrediction(){
-		return prediction;
-	}
-
-}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressor.java b/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressor.java
deleted file mode 100644
index a4d5091f8..000000000
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressor.java
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- *    AMRulesMultiTargetRegressor.java
- *    Copyright (C) 2017 University of Porto, Portugal
- *    @author J. Duarte, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *
- *
- */
-package moa.classifiers.rules.multilabel;
-
-import moa.classifiers.core.driftdetection.ChangeDetector;
-import moa.classifiers.mlc.core.splitcriteria.MultiLabelSplitCriterion;
-import moa.classifiers.rules.multilabel.core.MultiLabelRule;
-import moa.classifiers.rules.multilabel.core.MultiLabelRuleRegression;
-import moa.classifiers.rules.multilabel.core.splitcriteria.MultiTargetVarianceRatio;
-import moa.classifiers.rules.multilabel.core.voting.ErrorWeightedVoteMultiLabel;
-import moa.classifiers.rules.multilabel.core.voting.InverseErrorWeightedVoteMultiLabel;
-import moa.classifiers.rules.multilabel.errormeasurers.MultiLabelErrorMeasurer;
-import moa.classifiers.rules.multilabel.errormeasurers.RelativeMeanAbsoluteDeviationMT;
-import moa.classifiers.rules.multilabel.functions.AdaptiveMultiTargetRegressor;
-import moa.learners.MultiTargetRegressor;
-import moa.options.ClassOption;
-
-/**
- * AMRules Algorithm  for multitarget
- *
- * splitCriterionOption- Split criterion used to assess the merit of a split
- *
- * weightedVoteOption - Weighted vote type
- *
- * learnerOption - Learner selection
- *
- * errorMeasurerOption -  Measure of error for deciding which learner should predict
- *
- * changeDetector  - Change selection
- *
- * João Duarte, João Gama, Albert Bifet, Adaptive Model Rules From High-Speed Data Streams. TKDD 10(3): 30:1-30:22 (2016)
-
- */
-
-
-
-
-
-public class AMRulesMultiTargetRegressor extends AMRulesMultiLabelLearner implements MultiTargetRegressor {
-
-	/**
-	 * 
-	 */
-	private static final long serialVersionUID = 1L;
-	
-	public  AMRulesMultiTargetRegressor(){
-		splitCriterionOption = new ClassOption("splitCriterionOption", 'S',
-				"Split criterion used to assess the merit of a split", MultiLabelSplitCriterion.class, MultiTargetVarianceRatio.class.getName()) ;
-
-		 weightedVoteOption = new ClassOption("weightedVoteOption",
-					'w', "Weighted vote type", 
-					ErrorWeightedVoteMultiLabel.class,
-					InverseErrorWeightedVoteMultiLabel.class.getName());
-		 
-		 learnerOption = new ClassOption("learnerOption",
-					'L', "Learner", 
-					MultiTargetRegressor.class,
-					AdaptiveMultiTargetRegressor.class.getName());
-		 
-		 errorMeasurerOption = new ClassOption("errorMeasurer", 'e',
-					"Measure of error for deciding which learner should predict.", MultiLabelErrorMeasurer.class, RelativeMeanAbsoluteDeviationMT.class.getName()) ;
-
-	
-		 changeDetector = new ClassOption("changeDetector",
-					'H', "Change Detector.", 
-					ChangeDetector.class,
-					"PageHinkleyDM -d 0.05 -l 35.0");
-	}
-	
-	@Override
-	public ErrorWeightedVoteMultiLabel newErrorWeightedVote(){
-		return (ErrorWeightedVoteMultiLabel)((ErrorWeightedVoteMultiLabel) getPreparedClassOption(weightedVoteOption)).copy();
-		
-	}
-
-	@Override
-	protected MultiLabelRule newDefaultRule() {
-		return new MultiLabelRuleRegression(1);
-	}
-
-	public AMRulesMultiTargetRegressor(double attributesPercentage) {
-		super(attributesPercentage);
-	}
-
-
-	
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressorSemiSuper.java b/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressorSemiSuper.java
deleted file mode 100644
index 2a270dd57..000000000
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressorSemiSuper.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- *    AMRulesMultiTargetRegressorSemiSuper.java
- *    Copyright (C) 2017 University of Porto, Portugal
- *    @author R. Sousa, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.classifiers.rules.multilabel;
-
-import moa.classifiers.MultiTargetLearnerSemiSupervised;
-import moa.classifiers.core.driftdetection.ChangeDetector;
-import moa.classifiers.mlc.core.splitcriteria.MultiLabelSplitCriterion;
-import moa.classifiers.rules.multilabel.core.MultiLabelRule;
-import moa.classifiers.rules.multilabel.core.MultiLabelRuleRegression;
-import moa.classifiers.rules.multilabel.core.splitcriteria.MultiTargetVarianceRatio;
-import moa.classifiers.rules.multilabel.core.voting.ErrorWeightedVoteMultiLabel;
-import moa.classifiers.rules.multilabel.core.voting.InverseErrorWeightedVoteMultiLabel;
-import moa.classifiers.rules.multilabel.errormeasurers.MultiLabelErrorMeasurer;
-import moa.classifiers.rules.multilabel.errormeasurers.RelativeMeanAbsoluteDeviationMT;
-import moa.classifiers.rules.multilabel.functions.AdaptiveMultiTargetRegressor;
-import moa.learners.MultiTargetRegressor;
-import moa.options.ClassOption;
-
-public class AMRulesMultiTargetRegressorSemiSuper extends AMRulesMultiLabelLearnerSemiSuper implements MultiTargetRegressor, MultiTargetLearnerSemiSupervised {  //MultiTargetRegressor,
-
-	private static final long serialVersionUID = 1L;
-	
-	@Override
-	  public String getPurposeString() {
-	        return "Semi-supervised AMRules method for online multi-target regression.This method measures predicts the benefit of a unlabeled example to the models(using only the input information) to the model. If this benefit is higher than <scoreThreshold> then the algorithm predicts an output and artificially labels the example and use it for training.";
-	    }
-	
-	
-	public  AMRulesMultiTargetRegressorSemiSuper(){
-            splitCriterionOption = new ClassOption("splitCriterionOption", 'S',"Split criterion used to assess the merit of a split", MultiLabelSplitCriterion.class, MultiTargetVarianceRatio.class.getName()) ;
-            weightedVoteOption = new ClassOption("weightedVoteOption",'w', "Weighted vote type", ErrorWeightedVoteMultiLabel.class,InverseErrorWeightedVoteMultiLabel.class.getName());
-            learnerOption = new ClassOption("learnerOption",'L', "Learner", MultiTargetRegressor.class,AdaptiveMultiTargetRegressor.class.getName());
-            errorMeasurerOption = new ClassOption("errorMeasurer", 'e',"Measure of error for deciding which learner should predict.", MultiLabelErrorMeasurer.class, RelativeMeanAbsoluteDeviationMT.class.getName()) ;
-            changeDetector = new ClassOption("changeDetector",'H', "Change Detector.", ChangeDetector.class,"PageHinkleyDM -d 0.05 -l 35.0");
-	}
-	
-	@Override
-	protected MultiLabelRule newDefaultRule() {
-		return new MultiLabelRuleRegression(1);
-	}
-
-	public AMRulesMultiTargetRegressorSemiSuper(double attributesPercentage) {
-		super(attributesPercentage);
-	}
-	
-  
-	
-	
-}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/MultiLabelBSTreeFloat.java b/moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/MultiLabelBSTreeFloat.java
deleted file mode 100644
index 5e902d546..000000000
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/MultiLabelBSTreeFloat.java
+++ /dev/null
@@ -1,224 +0,0 @@
-/*
- *    MultiLabelBSTreeFloat.java
- *    Copyright (C) 2017 University of Porto, Portugal
- *    @author J. Duarte, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *
- *
- */
-package moa.classifiers.rules.multilabel.attributeclassobservers;
-
-import java.io.Serializable;
-
-import com.github.javacliparser.IntOption;
-
-import moa.classifiers.mlc.core.attributeclassobservers.NumericStatisticsObserver;
-import moa.classifiers.mlc.core.splitcriteria.MultiLabelSplitCriterion;
-import moa.classifiers.rules.core.AttributeExpansionSuggestion;
-import moa.classifiers.rules.core.NumericRulePredicate;
-import moa.classifiers.rules.core.Utils;
-import moa.core.DoubleVector;
-import moa.core.ObjectRepository;
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
-public class MultiLabelBSTreeFloat extends AbstractOptionHandler implements NumericStatisticsObserver {
-
-	/**
-	 * 
-	 */
-	public IntOption maxNodesOption = new IntOption("maxNodesOption", 'z', "Maximum number of nodes", 50, 0, Integer.MAX_VALUE);
-	protected int maxNodes;
-	protected int numNodes;
-
-	private static final long serialVersionUID = 1L;
-
-	protected Node root = null;
-
-	protected DoubleVector [] leftStatistics;
-	protected DoubleVector [] rightStatistics;
-
-	@Override
-	public void observeAttribute(double inputAttributeValue,
-			DoubleVector[] statistics) {
-		if (!Double.isNaN(inputAttributeValue))
-		{
-			if (this.root == null) {
-				this.root = new Node(inputAttributeValue, statistics);
-				maxNodes=maxNodesOption.getValue();
-			} else {
-				this.root.observeAttribute(inputAttributeValue, statistics);
-			}
-		}
-
-	}
-
-
-	@Override
-	public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(
-			MultiLabelSplitCriterion criterion, DoubleVector[] preSplitStatistics, int inputAttributeIndex) {
-		// Initialize global variables
-		int numOutputs=preSplitStatistics.length;
-		leftStatistics=new DoubleVector[numOutputs];
-		rightStatistics=new DoubleVector[numOutputs];
-		for (int i=0; i< numOutputs; i++)
-		{
-			leftStatistics[i]=new DoubleVector(new double [preSplitStatistics[i].numValues()]); //sets statistics to zeros
-			rightStatistics[i]=new DoubleVector(preSplitStatistics[i]);
-		}
-		AttributeExpansionSuggestion ret=searchForBestSplitOption(this.root, null, criterion, preSplitStatistics, inputAttributeIndex);
-		leftStatistics=null;
-		rightStatistics=null;
-		return ret;
-	}
-
-	protected AttributeExpansionSuggestion searchForBestSplitOption(Node currentNode, AttributeExpansionSuggestion currentBestOption, MultiLabelSplitCriterion criterion, DoubleVector [] preSplitStatistics, int inputAttributeIndex) {
-		// Return null if the current node is null or we have finished looking through all the possible splits
-		if (currentNode == null) { // TODO: JD check || countRightTotal == 0.0
-			return currentBestOption;
-		}
-
-		if (currentNode.left != null) {
-			currentBestOption = searchForBestSplitOption(currentNode.left, currentBestOption, criterion, preSplitStatistics, inputAttributeIndex);
-		}
-		for (int i=0; i<leftStatistics.length; i++)
-		{
-			DoubleVector leftStatsDouble=Utils.floatToDoubleVector(currentNode.leftStatistics[i]);
-			leftStatistics[i].addValues(leftStatsDouble);
-			rightStatistics[i].subtractValues(leftStatsDouble);
-		}
-
-		DoubleVector[][] postSplitDists = new DoubleVector [leftStatistics.length][2];
-		for (int i=0; i<leftStatistics.length; i++)
-		{
-			postSplitDists[i]= new DoubleVector[2];
-			postSplitDists[i][0]=leftStatistics[i];
-			postSplitDists[i][1]=rightStatistics[i];
-		}
-
-		double merit = criterion.getMeritOfSplit(preSplitStatistics, postSplitDists);
-
-		if ((currentBestOption == null) || (merit > currentBestOption.merit)) {
-			currentBestOption= new AttributeExpansionSuggestion(new NumericRulePredicate(inputAttributeIndex, currentNode.cutPoint, true), Utils.copy(postSplitDists), merit);
-		}
-
-		if (currentNode.right != null) {
-			currentBestOption = searchForBestSplitOption(currentNode.right, currentBestOption, criterion, preSplitStatistics, inputAttributeIndex);
-		}
-		for (int i=0; i<leftStatistics.length; i++)
-		{
-			DoubleVector leftStatsDouble=Utils.floatToDoubleVector(currentNode.leftStatistics[i]);
-			leftStatistics[i].subtractValues(leftStatsDouble);
-			rightStatistics[i].addValues(leftStatsDouble);
-		}
-		return currentBestOption;
-	}
-
-
-
-
-	@Override
-	public String getPurposeString() {
-		return "Stores statistics for all output attributes for a giver input attribute.";
-	}
-
-	@Override
-	public void getDescription(StringBuilder sb, int indent) {	
-	}
-
-	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
-
-	}
-
-
-	//Inner classes inspired in FIMTDDNumericalAttributeClassObserver
-
-	protected class Node implements Serializable {
-
-		private static final long serialVersionUID = 1L;
-
-		// The split point to use
-		private float cutPoint;
-
-		// E-BST statistics
-		private SingleVector [] leftStatistics;
-		private SingleVector [] rightStatistics;
-
-		// Child nodes
-		private Node left;
-		private Node right;
-
-		public Node(float inputAttributeValue, SingleVector [] statistics) {
-			cutPoint = inputAttributeValue;
-			int numOutputAttributes=statistics.length;
-			leftStatistics=new SingleVector[numOutputAttributes];
-			for (int i=0; i<numOutputAttributes; i++)
-			{					
-				leftStatistics[i]=statistics[i];;
-			}
-			//this.leftStatistics=statistics.clone();
-
-			this.rightStatistics=new SingleVector[numOutputAttributes];
-			for (int i=0; i<numOutputAttributes; i++)
-				this.rightStatistics[i]= new SingleVector();
-		}
-		
-		public Node(double inputAttributeValue, DoubleVector [] statistics) {
-			this((float)inputAttributeValue, Utils.copyAsFloatVector(statistics));
-		}
-
-		/**
-		 * Updates tree with new observation
-		 */
-		public void observeAttribute(double inputAttributeValue, DoubleVector [] statistics) {
-			this.observeAttribute((float)inputAttributeValue, Utils.copyAsFloatVector(statistics));
-			
-		}
-		public void observeAttribute(float inputAttributeValue, SingleVector [] statistics) {
-			if (inputAttributeValue == this.cutPoint) {
-				for (int i=0; i<statistics.length; i++)
-					this.leftStatistics[i].addValues(statistics[i]);
-			}
-			else if (inputAttributeValue < this.cutPoint) {
-				for (int i=0; i<statistics.length; i++)
-					this.leftStatistics[i].addValues(statistics[i]);
-				
-				if (this.left == null) {
-					if(numNodes<maxNodes){
-						this.left = new Node(inputAttributeValue, statistics);
-						++numNodes;
-					}
-				} else {
-					this.left.observeAttribute(inputAttributeValue, statistics);
-				}
-			}
-			else { 
-				for (int i=0; i<statistics.length; i++)
-					this.rightStatistics[i].addValues(statistics[i]);
-				if (this.right == null) {
-					if(numNodes<maxNodes){
-						this.right = new Node(inputAttributeValue, statistics);
-						++numNodes;
-					}
-				} else {
-					this.right.observeAttribute(inputAttributeValue, statistics);
-				}
-			}
-		}
-	}
-
-
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/SingleVector.java b/moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/SingleVector.java
deleted file mode 100644
index 6cd8cc105..000000000
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/attributeclassobservers/SingleVector.java
+++ /dev/null
@@ -1,204 +0,0 @@
-/*
- *    DoubleVector.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.rules.multilabel.attributeclassobservers;
-
-import com.github.javacliparser.StringUtils;
-
-import moa.AbstractMOAObject;
-
-/**
- * Vector of float numbers with some utilities.
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $
- */
-public class SingleVector extends AbstractMOAObject {
-
-    private static final long serialVersionUID = 1L;
-
-    protected float[] array;
-
-    public SingleVector() {
-        this.array = new float[0];
-    }
-
-    public SingleVector(float[] toCopy) {
-        this.array = new float[toCopy.length];
-        System.arraycopy(toCopy, 0, this.array, 0, toCopy.length);
-    }
-
-    
-    public SingleVector(SingleVector toCopy) {
-        this(toCopy.getArrayRef());
-    }
-
-
-	public SingleVector(double[] arrayRef) {
-		this.array=new float[arrayRef.length];
-		for(int i=0; i<arrayRef.length;i++)
-			this.array[i]=(float)arrayRef[i];
-	}
-
-	public int numValues() {
-        return this.array.length;
-    }
-
-    public void setValue(int i, float v) {
-        if (i >= this.array.length) {
-            setArrayLength(i + 1);
-        }
-        this.array[i] = v;
-    }
-
-    public void addToValue(int i, float v) {
-        if (i >= this.array.length) {
-            setArrayLength(i + 1);
-        }
-        this.array[i] += v;
-    }
-
-    public void addValues(SingleVector toAdd) {
-        addValues(toAdd.getArrayRef());
-    }
-
-    public void addValues(float[] toAdd) {
-        if (toAdd.length > this.array.length) {
-            setArrayLength(toAdd.length);
-        }
-        for (int i = 0; i < toAdd.length; i++) {
-            this.array[i] += toAdd[i];
-        }
-    }
-
-    public void subtractValues(SingleVector toSubtract) {
-        subtractValues(toSubtract.getArrayRef());
-    }
-
-    public void subtractValues(float[] toSubtract) {
-        if (toSubtract.length > this.array.length) {
-            setArrayLength(toSubtract.length);
-        }
-        for (int i = 0; i < toSubtract.length; i++) {
-            this.array[i] -= toSubtract[i];
-        }
-    }
-
-    public void addToValues(float toAdd) {
-        for (int i = 0; i < this.array.length; i++) {
-            this.array[i] = this.array[i] + toAdd;
-        }
-    }
-
-    public void scaleValues(float multiplier) {
-        for (int i = 0; i < this.array.length; i++) {
-            this.array[i] = this.array[i] * multiplier;
-        }
-    }
-
-    // returns 0.0 for values outside of range
-    public float getValue(int i) {
-        return ((i >= 0) && (i < this.array.length)) ? this.array[i] : 0.0f;
-    }
-
-    public float sumOfValues() {
-        float sum = 0.0f;
-        for (float element : this.array) {
-            sum += element;
-        }
-        return sum;
-    }
-
-    public int maxIndex() {
-        int max = -1;
-        for (int i = 0; i < this.array.length; i++) {
-            if ((max < 0) || (this.array[i] > this.array[max])) {
-                max = i;
-            }
-        }
-        return max;
-    }
-
-    public void normalize() {
-        scaleValues(1.0f / sumOfValues());
-    }
-
-    public int numNonZeroEntries() {
-        int count = 0;
-        for (float element : this.array) {
-            if (element != 0.0) {
-                count++;
-            }
-        }
-        return count;
-    }
-
-    public float minWeight() {
-        if (this.array.length > 0) {
-            float min = this.array[0];
-            for (int i = 1; i < this.array.length; i++) {
-                if (this.array[i] < min) {
-                    min = this.array[i];
-                }
-            }
-            return min;
-        }
-        return 0.0f;
-    }
-
-    public float[] getArrayCopy() {
-        float[] aCopy = new float[this.array.length];
-        System.arraycopy(this.array, 0, aCopy, 0, this.array.length);
-        return aCopy;
-    }
-
-    public float[] getArrayRef() {
-        return this.array;
-    }
-
-    protected void setArrayLength(int l) {
-        float[] newArray = new float[l];
-        int numToCopy = this.array.length;
-        if (numToCopy > l) {
-            numToCopy = l;
-        }
-        System.arraycopy(this.array, 0, newArray, 0, numToCopy);
-        this.array = newArray;
-    }
-
-    public void getSingleLineDescription(StringBuilder out) {
-        getSingleLineDescription(out, numValues());
-    }
-
-    public void getSingleLineDescription(StringBuilder out, int numValues) {
-        out.append("{");
-        for (int i = 0; i < numValues; i++) {
-            if (i > 0) {
-                out.append("|");
-            }
-            out.append(StringUtils.doubleToString(getValue(i), 3));
-        }
-        out.append("}");
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        getSingleLineDescription(sb);
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralClassification.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralClassification.java
deleted file mode 100644
index 3883e127c..000000000
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralClassification.java
+++ /dev/null
@@ -1,381 +0,0 @@
-/*
- *    LearningLiteralClassification.java
- *    Copyright (C) 2017 University of Porto, Portugal
- *    @author R. Sousa, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.classifiers.rules.multilabel.core;
-
-import java.util.Arrays;
-import java.util.LinkedList;
-import java.util.List;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.mlc.core.attributeclassobservers.AttributeStatisticsObserver;
-import moa.classifiers.mlc.core.attributeclassobservers.NominalStatisticsObserver;
-import moa.classifiers.mlc.core.attributeclassobservers.NumericStatisticsObserver;
-import moa.classifiers.mlc.core.splitcriteria.MultiLabelSplitCriterion;
-import moa.classifiers.rules.core.AttributeExpansionSuggestion;
-import moa.classifiers.rules.core.NumericRulePredicate;
-import moa.classifiers.rules.core.Utils;
-import moa.classifiers.rules.multilabel.functions.AMRulesFunction;
-import moa.classifiers.rules.multilabel.instancetransformers.InstanceOutputAttributesSelector;
-import moa.classifiers.rules.multilabel.instancetransformers.InstanceTransformer;
-import moa.core.AutoExpandVector;
-import moa.core.DoubleVector;
-import moa.core.ObjectRepository;
-import moa.learners.MultiLabelClassifier;
-import moa.tasks.TaskMonitor;
-
-
-/**
-* This class contains the functions for learning the literals for Multi-label classification 
-* (in same way as Multi-Target regression). 
-* used by  multi-label AMRules.
-* @author RSousa
-* * @version $Revision: 1 $
-*/
-
-
-public class LearningLiteralClassification extends LearningLiteral {
-
-	/**
-	 * 
-	 */
-	private static final long serialVersionUID = 1L;
-
-	double [] EntropyShift; //for proper computation of entropy
-
-	public LearningLiteralClassification() {
-		super();
-	}
-
-	public LearningLiteralClassification(int [] outputsToLearn) {
-		super(outputsToLearn);
-	}
-
-
-
-	protected double [] getNormalizedErrors(Prediction prediction, Instance instance) {
-		double [] errors= new double[outputsToLearn.length];
-
-		for (int i=0; i<outputsToLearn.length;i++){
-			double predY=normalizeOutputValue(i,prediction.getVote(outputsToLearn[i], 0));
-			double trueY=normalizeOutputValue(i,instance.valueOutputAttribute(outputsToLearn[i]));
-			errors[i]=Math.abs(predY-trueY);
-		}
-		return errors;
-	}
-
-	private double normalizeOutputValue(int outputToLearnIndex, double value) {
-		double meanY = this.literalStatistics[outputToLearnIndex].getValue(1)/this.literalStatistics[outputToLearnIndex].getValue(0);
-		double sdY = Utils.computeSD(this.literalStatistics[outputToLearnIndex].getValue(2), this.literalStatistics[outputToLearnIndex].getValue(1), this.literalStatistics[outputToLearnIndex].getValue(0));
-		double normalizedY = 0.0;
-		if (sdY > 0.0000001) {
-			normalizedY = (value - meanY) / (sdY);
-		}
-		return normalizedY;
-	}
-
-
-	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
-
-	}
-
-	@Override
-	public boolean tryToExpand(double splitConfidence, double tieThreshold) {
-
-		boolean shouldSplit=false;
-		
-		//find the best split per attribute and rank the results
-		AttributeExpansionSuggestion[] bestSplitSuggestions = this.getBestSplitSuggestions(splitCriterion);
-
-		double sumMerit=0;
-		meritPerInput= new double[attributesMask.length];
-		for (int i=0; i<bestSplitSuggestions.length;i++){
-			double merit=bestSplitSuggestions[i].getMerit();
-			if(merit>0){
-				meritPerInput[bestSplitSuggestions[i].predicate.getAttributeIndex()]=merit;
-				sumMerit+=merit;
-			}
-		}
-
-		//if merit==0 it means the split have not enough examples in the smallest branch
-		if(sumMerit==0)
-                    meritPerInput=null; //this indicates that no merit should be considered (e.g. for feature ranking)
-
-		Arrays.sort(bestSplitSuggestions);
-                
-		//disable attributes that are not relevant
-		int []oldInputs=inputsToLearn.clone();
-		inputsToLearn=inputSelector.getNextInputIndices(bestSplitSuggestions); //
-		Arrays.sort(this.inputsToLearn);
-		for (int i=0; i<oldInputs.length; i++){
-			if(attributesMask[oldInputs[i]]){
-				if(Arrays.binarySearch(inputsToLearn, oldInputs[i])<0)
-				{
-					this.attributeObservers.set(oldInputs[i], null);
-				}
-			}
-		}
-
-
-		// If only one split was returned, use it
-		if (bestSplitSuggestions.length < 2) {
-			//shouldSplit = ((bestSplitSuggestions.length > 0) && (bestSplitSuggestions[0].merit > 0)); 
-			bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-			shouldSplit = true;
-		} // Otherwise, consider which of the splits proposed may be worth trying
-		else {
-			double hoeffdingBound = computeHoeffdingBound(splitCriterion.getRangeOfMerit(this.literalStatistics), splitConfidence, weightSeen);
-			//debug("Hoeffding bound " + hoeffdingBound, 4);
-			// Determine the top two ranked splitting suggestions
-			bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-			AttributeExpansionSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
-			if ((((bestSuggestion.merit-secondBestSuggestion.merit)) > hoeffdingBound) || (hoeffdingBound < tieThreshold)) {
-				//if ((((secondBestSuggestion.merit/bestSuggestion.merit) + hoeffdingBound) < 1) || (hoeffdingBound < tieThreshold)) {
-				//debug("Expanded ", 5);
-				shouldSplit = true;
-				//System.out.println(bestSuggestion.merit);
-			}
-		}
-                
-
-   
-		if(shouldSplit)
-		{
-			
-            //check which branch is better and update bestSuggestion (in amrules the splits are binary )
-			DoubleVector[][] resultingStatistics=bestSuggestion.getResultingNodeStatistics();
-			
-
-            //if not or higher is better, change predicate (negate condition)
-			double [] branchMerits=splitCriterion.getBranchesSplitMerits(resultingStatistics);
-			DoubleVector[] newLiteralStatistics;
-			if(branchMerits[1]>branchMerits[0]){
-				bestSuggestion.getPredicate().negateCondition();
-				newLiteralStatistics=getBranchStatistics(resultingStatistics,1);
-			}else{
-				newLiteralStatistics=getBranchStatistics(resultingStatistics,0);
-			}
-                        
-			int [] newOutputs=outputSelector.getNextOutputIndices(newLiteralStatistics,literalStatistics, outputsToLearn);
-			Arrays.sort(newOutputs); //Must be ordered for latter correspondence algorithm to work
-    
-			//set other branch (only used if default rule expands)
-			otherBranchLearningLiteral=new LearningLiteralClassification();
-			otherBranchLearningLiteral.instanceHeader=instanceHeader;
-			otherBranchLearningLiteral.learner=(MultiLabelClassifier) learner.copy();
-			otherBranchLearningLiteral.instanceTransformer=(InstanceTransformer)this.instanceTransformer;
-
-			//keep a rule learning to the complement set of newOutputs
-
-
-			//Set expanding branch
-			//if is AMRulesFunction and the  number of output attributes changes, start learning a new predictor
-			//should we do the same for input attributes (attributesMask)?. It would have impact in RandomAMRules
-			if(learner instanceof AMRulesFunction){ //Reset learning
-				if(newOutputs.length != outputsToLearn.length){
-					//other outputs
-					int [] otherOutputs=Utils.complementSet(outputsToLearn,newOutputs);
-					int [] indices;
-					if(otherOutputs.length>0){
-						otherOutputsLearningLiteral=new LearningLiteralClassification(otherOutputs);
-						MultiLabelClassifier otherOutputsLearner=(MultiLabelClassifier) learner.copy();
-						indices=Utils.getIndexCorrespondence(outputsToLearn,otherOutputs);
-						((AMRulesFunction) otherOutputsLearner).selectOutputsToLearn(indices);
-						((AMRulesFunction) otherOutputsLearner).resetWithMemory();
-						otherOutputsLearningLiteral.learner=otherOutputsLearner;
-						otherOutputsLearningLiteral.instanceHeader=instanceHeader;
-						otherOutputsLearningLiteral.instanceTransformer=new InstanceOutputAttributesSelector(instanceHeader,otherOutputs);
-					}
-					//expanded
-					indices=Utils.getIndexCorrespondence(outputsToLearn,newOutputs);
-					((AMRulesFunction) learner).selectOutputsToLearn(indices);
-				}
-
-				((AMRulesFunction) learner).resetWithMemory();
-			}
-			//just reset learning
-			else{
-				//other outputs //TODO JD: Test for general learner (other than AMRules functions
-				if(newOutputs.length != outputsToLearn.length){
-					int [] otherOutputs=Utils.complementSet(outputsToLearn,newOutputs);
-					if(otherOutputs.length>0){
-						otherOutputsLearningLiteral=new LearningLiteralClassification();
-						MultiLabelClassifier otherOutputsLearner=(MultiLabelClassifier)learner.copy();
-						otherOutputsLearner.resetLearning();
-						otherOutputsLearningLiteral.learner=otherOutputsLearner;
-						otherOutputsLearningLiteral.instanceHeader=instanceHeader;
-						otherOutputsLearningLiteral.instanceTransformer=new InstanceOutputAttributesSelector(instanceHeader,otherOutputs);
-					}
-				}
-				//expanded
-				learner.resetLearning();
-			}
-			expandedLearningLiteral=new LearningLiteralClassification(newOutputs);
-			expandedLearningLiteral.learner=(MultiLabelClassifier) this.learner.copy();	
-			expandedLearningLiteral.instanceHeader=instanceHeader;
-			expandedLearningLiteral.instanceTransformer=new InstanceOutputAttributesSelector(instanceHeader,newOutputs);
-         
-		}
-                   
-		return shouldSplit;
-	}
-
-
-	private DoubleVector[] getBranchStatistics(DoubleVector[][] resultingStatistics, int indexBranch) {
-		DoubleVector[] selBranchStats=new DoubleVector[resultingStatistics.length];
-		for(int i=0; i<resultingStatistics.length;i++)
-			selBranchStats[i]=resultingStatistics[i][indexBranch];
-		return selBranchStats;
-	}
-
-	private AttributeExpansionSuggestion[] getBestSplitSuggestions(MultiLabelSplitCriterion criterion) {
-		
-
-                List<AttributeExpansionSuggestion> bestSuggestions = new LinkedList<AttributeExpansionSuggestion>();
-		for (int i = 0; i < this.inputsToLearn.length; i++) {
-			if(attributesMask[inputsToLearn[i]]){ //Should always be true (check trainOnInstance(). Remove?
-				AttributeStatisticsObserver obs = this.attributeObservers.get(inputsToLearn[i]);
-				if (obs != null) {
-					AttributeExpansionSuggestion bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion, literalStatistics, inputsToLearn[i]);
-
-					if (bestSuggestion == null) {
-						//ALL attributes must have a best suggestion. Adding dummy suggestion with minimal merit.
-						bestSuggestion=new  AttributeExpansionSuggestion(new NumericRulePredicate(inputsToLearn[i],0,true),null,-Double.MAX_VALUE);
-					}
-					bestSuggestions.add(bestSuggestion);
-				}
-			}
-		}
-		return bestSuggestions.toArray(new AttributeExpansionSuggestion[bestSuggestions.size()]);
-	}
-
-	@Override
-	public void trainOnInstance(Instance instance)  {
-		int numInputs=0;
-		if (attributesMask==null)
-			numInputs=initializeAttibutesMask(instance);
-
-		//learn for all output attributes if not specified at construction time
-		int numOutputs=instance.numOutputAttributes();
-
-		if(!hasStarted)
-		{
-			if(this.learner.isRandomizable())
-				this.learner.setRandomSeed(this.randomGenerator.nextInt());
-			if(outputsToLearn==null)
-			{
-				outputsToLearn=new int[numOutputs];
-				for (int i=0; i<numOutputs;i++){
-					outputsToLearn[i]=i;
-				}
-			}
-			if(inputsToLearn==null)
-			{
-				inputsToLearn=new int[numInputs];
-				int ct=0;
-				for (int i=0; i<instance.numInputAttributes();i++){//TODO JD: check with mask?
-					if(attributesMask[i]){
-						inputsToLearn[ct]=i;
-						ct++;
-					}
-				}
-			}
-
-			literalStatistics= new DoubleVector[outputsToLearn.length];
-			EntropyShift=new double[outputsToLearn.length];
-			for(int i=0; i<outputsToLearn.length; i++){
-				literalStatistics[i]=new DoubleVector(new double[5]);
-				EntropyShift[i]=instance.valueOutputAttribute(outputsToLearn[i]);
-			}
-			instanceHeader=(InstancesHeader)instance.dataset();
-			hasStarted=true;
-		}
-		double weight=instance.weight();
-		DoubleVector []exampleStatistics=new DoubleVector[outputsToLearn.length];
-		for (int i=0; i<outputsToLearn.length; i++){
-			double target=instance.valueOutputAttribute(outputsToLearn[i]);
-                           
-			double sum=weight*target;                //Needed for expansion
-			double squaredSum=weight*target*target;  //Not needed for now
-			double sumShifted=weight*target-EntropyShift[i];  //Needed for Output Selector
-			double squaredSumShifted=weight*(target-EntropyShift[i])*(target-EntropyShift[i]);//Not needed for now         
-			exampleStatistics[i]= new DoubleVector(new double[]{weight,sum, squaredSum,sumShifted,squaredSumShifted});
-			literalStatistics[i].addValues(exampleStatistics[i].getArrayRef());
-           
-		}
-
-		if(this.attributeObservers==null)
-			this.attributeObservers=new AutoExpandVector<AttributeStatisticsObserver>();
-		for(int i=0; i<inputsToLearn.length; i++){
-			if(attributesMask[inputsToLearn[i]]){ //this is checked above. Remove?
-				AttributeStatisticsObserver obs=this.attributeObservers.get(inputsToLearn[i]);
-				if(obs==null){
-					if(instance.attribute(inputsToLearn[i]).isNumeric()){
-						obs=((NumericStatisticsObserver)numericStatisticsObserver.copy());
-					}else if(instance.attribute(inputsToLearn[i]).isNominal()){  //just to make sure its nominal (in the future there may be ordinal?
-						obs=((NominalStatisticsObserver)nominalStatisticsObserver.copy());
-					}
-					this.attributeObservers.set(inputsToLearn[i], obs);
-				}
-				obs.observeAttribute(instance.valueInputAttribute(inputsToLearn[i]), exampleStatistics);
-			}
-		}
-
-		//Transform instance for learning
-		Instance transformedInstance=instanceTransformer.sourceInstanceToTarget(instance);
-		Prediction prediction=null;
-		Prediction targetPrediction=learner.getPredictionForInstance(transformedInstance);
-		if(targetPrediction!=null)
-			prediction=instanceTransformer.targetPredictionToSource(targetPrediction);
-
-		if(prediction!=null)
-			errorMeasurer.addPrediction(prediction, instance);
-
-		learner.trainOnInstance(transformedInstance);
-
-		weightSeen+=instance.weight();
-	}
-
-	@Override
-	public String getStaticOutput(InstancesHeader instanceInformation) {
-		StringBuffer sb = new StringBuffer();
-		if(this.literalStatistics!=null){
-			for(int i=0; i<this.literalStatistics.length; i++){
-				sb.append( instanceInformation.outputAttribute(outputsToLearn[i]).name() + ": "  + literalStatistics[i].getValue(1)/literalStatistics[i].getValue(0) + " "  ); //  
-			}
-		}
-
-                
-		return sb.toString();
-	}
-
-
-
-	/*@Override
-	public void resetLearning() {
-		weightSeen=0;
-		//hasStarted=false;
-	}*/
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java
deleted file mode 100644
index be833a06a..000000000
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteralRegression.java
+++ /dev/null
@@ -1,335 +0,0 @@
-package moa.classifiers.rules.multilabel.core;
-
-import java.util.Arrays;
-import java.util.LinkedList;
-import java.util.List;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.mlc.core.attributeclassobservers.AttributeStatisticsObserver;
-import moa.classifiers.mlc.core.attributeclassobservers.NominalStatisticsObserver;
-import moa.classifiers.mlc.core.attributeclassobservers.NumericStatisticsObserver;
-import moa.classifiers.mlc.core.splitcriteria.MultiLabelSplitCriterion;
-import moa.classifiers.rules.core.AttributeExpansionSuggestion;
-import moa.classifiers.rules.core.NumericRulePredicate;
-import moa.classifiers.rules.core.Utils;
-import moa.classifiers.rules.multilabel.functions.AMRulesFunction;
-import moa.classifiers.rules.multilabel.instancetransformers.InstanceOutputAttributesSelector;
-import moa.classifiers.rules.multilabel.instancetransformers.InstanceTransformer;
-import moa.core.AutoExpandVector;
-import moa.core.DoubleVector;
-import moa.core.ObjectRepository;
-import moa.learners.MultiLabelClassifier;
-import moa.tasks.TaskMonitor;
-
-public class LearningLiteralRegression extends LearningLiteral {
-
-	/**
-	 * 
-	 */
-	private static final long serialVersionUID = 1L;
-
-	double [] varianceShift; //for proper computation of variance
-
-	public LearningLiteralRegression() {
-		super();
-	}
-
-	public LearningLiteralRegression(int [] outputsToLearn) {
-		super(outputsToLearn);
-	}
-
-	protected double [] getNormalizedErrors(Prediction prediction, Instance instance) {
-		double [] errors= new double[outputsToLearn.length];
-
-		for (int i=0; i<outputsToLearn.length;i++){
-			double predY=normalizeOutputValue(i,prediction.getVote(outputsToLearn[i], 0));
-			double trueY=normalizeOutputValue(i,instance.valueOutputAttribute(outputsToLearn[i]));
-			errors[i]=Math.abs(predY-trueY);
-		}
-		return errors;
-	}
-
-	private double normalizeOutputValue(int outputToLearnIndex, double value) {
-		double meanY = this.literalStatistics[outputToLearnIndex].getValue(1)/this.literalStatistics[outputToLearnIndex].getValue(0);
-		double sdY = Utils.computeSD(this.literalStatistics[outputToLearnIndex].getValue(2), this.literalStatistics[outputToLearnIndex].getValue(1), this.literalStatistics[outputToLearnIndex].getValue(0));
-		double normalizedY = 0.0;
-		if (sdY > 0.0000001) {
-			normalizedY = (value - meanY) / (sdY);
-		}
-		return normalizedY;
-	}
-
-
-	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
-
-	}
-
-	@Override
-	public boolean tryToExpand(double splitConfidence, double tieThreshold) {
-		boolean shouldSplit=false;
-		//find the best split per attribute and rank the results
-		AttributeExpansionSuggestion[] bestSplitSuggestions	= this.getBestSplitSuggestions(splitCriterion);
-
-		double sumMerit=0;
-		meritPerInput= new double[attributesMask.length];
-		for (int i=0; i<bestSplitSuggestions.length;i++){
-			double merit=bestSplitSuggestions[i].getMerit();
-			if(merit>0){
-				meritPerInput[bestSplitSuggestions[i].predicate.getAttributeIndex()]=merit;
-				sumMerit+=merit;
-			}
-		}
-
-		//if merit==0 it means the split have not enough examples in the smallest branch
-		if(sumMerit==0)
-			meritPerInput=null; //this indicates that no merit should be considered (e.g. for feature ranking)
-
-		Arrays.sort(bestSplitSuggestions);
-
-		//disable attributes that are not relevant
-		int []oldInputs=inputsToLearn.clone();
-		inputsToLearn=inputSelector.getNextInputIndices(bestSplitSuggestions); //
-		Arrays.sort(this.inputsToLearn);
-		for (int i=0; i<oldInputs.length; i++){
-			if(attributesMask[oldInputs[i]]){
-				if(Arrays.binarySearch(inputsToLearn, oldInputs[i])<0)
-				{
-					this.attributeObservers.set(oldInputs[i], null);
-				}
-			}
-		}
-
-
-		// If only one split was returned, use it
-		if (bestSplitSuggestions.length < 2) {
-			//shouldSplit = ((bestSplitSuggestions.length > 0) && (bestSplitSuggestions[0].merit > 0)); 
-			bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-			shouldSplit = true;
-		} // Otherwise, consider which of the splits proposed may be worth trying
-		else {
-			double hoeffdingBound = computeHoeffdingBound(splitCriterion.getRangeOfMerit(this.literalStatistics), splitConfidence, weightSeen);
-			//debug("Hoeffding bound " + hoeffdingBound, 4);
-			// Determine the top two ranked splitting suggestions
-			bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-			AttributeExpansionSuggestion secondBestSuggestion
-			= bestSplitSuggestions[bestSplitSuggestions.length - 2];
-			if ((((bestSuggestion.merit-secondBestSuggestion.merit)) > hoeffdingBound) || (hoeffdingBound < tieThreshold)) {
-				//if ((((secondBestSuggestion.merit/bestSuggestion.merit) + hoeffdingBound) < 1) || (hoeffdingBound < tieThreshold)) {
-				//debug("Expanded ", 5);
-				shouldSplit = true;
-				//System.out.println(bestSuggestion.merit);
-			}
-		}
-		if(shouldSplit)
-		{
-			//check which branch is better and update bestSuggestion (in amrules the splits are binary )
-			DoubleVector[][] resultingStatistics=bestSuggestion.getResultingNodeStatistics();
-			//if not or higher is better, change predicate (negate condition)
-			double [] branchMerits=splitCriterion.getBranchesSplitMerits(resultingStatistics);
-			DoubleVector[] newLiteralStatistics;
-			if(branchMerits[1]>branchMerits[0]){
-				bestSuggestion.getPredicate().negateCondition();
-				newLiteralStatistics=getBranchStatistics(resultingStatistics,1);
-			}else{
-				newLiteralStatistics=getBranchStatistics(resultingStatistics,0);
-			}
-			//
-			int [] newOutputs=outputSelector.getNextOutputIndices(newLiteralStatistics,literalStatistics, outputsToLearn);
-			Arrays.sort(newOutputs); //Must be ordered for latter correspondence algorithm to work
-
-
-			//set other branch (only used if default rule expands)
-			otherBranchLearningLiteral=new LearningLiteralRegression();
-			otherBranchLearningLiteral.instanceHeader=instanceHeader;
-			otherBranchLearningLiteral.learner=(MultiLabelClassifier)learner.copy();
-			otherBranchLearningLiteral.instanceTransformer=(InstanceTransformer) this.instanceTransformer;
-
-			//keep a rule learning to the complement set of newOutputs
-
-
-			//Set expanding branch
-			//if is AMRulesFunction and the  number of output attributes changes, start learning a new predictor
-			//should we do the same for input attributes (attributesMask)?. It would have impact in RandomAMRules
-			if(learner instanceof AMRulesFunction){ //Reset learning
-				if(newOutputs.length != outputsToLearn.length){
-					//other outputs
-					int [] otherOutputs=Utils.complementSet(outputsToLearn,newOutputs);
-					int [] indices;
-					if(otherOutputs.length>0){
-						otherOutputsLearningLiteral=new LearningLiteralRegression(otherOutputs);
-						MultiLabelClassifier otherOutputsLearner=(MultiLabelClassifier)learner.copy();
-						indices=Utils.getIndexCorrespondence(outputsToLearn,otherOutputs);
-						((AMRulesFunction) otherOutputsLearner).selectOutputsToLearn(indices);
-						((AMRulesFunction) otherOutputsLearner).resetWithMemory();
-						otherOutputsLearningLiteral.learner=otherOutputsLearner;
-						otherOutputsLearningLiteral.instanceHeader=instanceHeader;
-						otherOutputsLearningLiteral.instanceTransformer=new InstanceOutputAttributesSelector(instanceHeader,otherOutputs);
-					}
-					//expanded
-					indices=Utils.getIndexCorrespondence(outputsToLearn,newOutputs);
-					((AMRulesFunction) learner).selectOutputsToLearn(indices);
-				}
-
-				((AMRulesFunction) learner).resetWithMemory();
-			}
-			//just reset learning
-			else{
-				//other outputs //TODO JD: Test for general learner (other than AMRules functions
-				if(newOutputs.length != outputsToLearn.length){
-					int [] otherOutputs=Utils.complementSet(outputsToLearn,newOutputs);
-					if(otherOutputs.length>0){
-						otherOutputsLearningLiteral=new LearningLiteralRegression();
-						MultiLabelClassifier otherOutputsLearner=(MultiLabelClassifier)learner.copy();
-						otherOutputsLearner.resetLearning();
-						otherOutputsLearningLiteral.learner=otherOutputsLearner;
-						otherOutputsLearningLiteral.instanceHeader=instanceHeader;
-						otherOutputsLearningLiteral.instanceTransformer=new InstanceOutputAttributesSelector(instanceHeader,otherOutputs);
-					}
-				}
-				//expanded
-				learner.resetLearning();
-			}
-			expandedLearningLiteral=new LearningLiteralRegression(newOutputs);
-			expandedLearningLiteral.learner=(MultiLabelClassifier) this.learner.copy();	
-			expandedLearningLiteral.instanceHeader=instanceHeader;
-			expandedLearningLiteral.instanceTransformer=new InstanceOutputAttributesSelector(instanceHeader,newOutputs);
-		}
-		return shouldSplit;
-	}
-
-
-	private DoubleVector[] getBranchStatistics(DoubleVector[][] resultingStatistics, int indexBranch) {
-		DoubleVector[] selBranchStats=new DoubleVector[resultingStatistics.length];
-		for(int i=0; i<resultingStatistics.length;i++)
-			selBranchStats[i]=resultingStatistics[i][indexBranch];
-		return selBranchStats;
-	}
-
-	private AttributeExpansionSuggestion[] getBestSplitSuggestions(MultiLabelSplitCriterion criterion) {
-		List<AttributeExpansionSuggestion> bestSuggestions = new LinkedList<AttributeExpansionSuggestion>();
-		for (int i = 0; i < this.inputsToLearn.length; i++) {
-			if(attributesMask[inputsToLearn[i]]){ //Should always be true (check trainOnInstance(). Remove?
-				AttributeStatisticsObserver obs = this.attributeObservers.get(inputsToLearn[i]);
-				if (obs != null) {
-					AttributeExpansionSuggestion bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion, literalStatistics, inputsToLearn[i]);
-
-					if (bestSuggestion == null) {
-						//ALL attributes must have a best suggestion. Adding dummy suggestion with minimal merit.
-						bestSuggestion=new  AttributeExpansionSuggestion(new NumericRulePredicate(inputsToLearn[i],0,true),null,-Double.MAX_VALUE);
-					}
-					bestSuggestions.add(bestSuggestion);
-				}
-			}
-		}
-		return bestSuggestions.toArray(new AttributeExpansionSuggestion[bestSuggestions.size()]);
-	}
-
-	@Override
-	public void trainOnInstance(Instance instance)  {
-		int numInputs=0;
-		if (attributesMask==null)
-			numInputs=initializeAttibutesMask(instance);
-
-		//learn for all output attributes if not specified at construction time
-		int numOutputs=instance.numOutputAttributes();
-
-		if(!hasStarted)
-		{
-			if(this.learner.isRandomizable())
-				this.learner.setRandomSeed(this.randomGenerator.nextInt());
-			if(outputsToLearn==null)
-			{
-				outputsToLearn=new int[numOutputs];
-				for (int i=0; i<numOutputs;i++){
-					outputsToLearn[i]=i;
-				}
-			}
-			if(inputsToLearn==null)
-			{
-				inputsToLearn=new int[numInputs];
-				int ct=0;
-				for (int i=0; i<instance.numInputAttributes();i++){//TODO JD: check with mask?
-					if(attributesMask[i]){
-						inputsToLearn[ct]=i;
-						ct++;
-					}
-				}
-			}
-
-			literalStatistics= new DoubleVector[outputsToLearn.length];
-			varianceShift=new double[outputsToLearn.length];
-			for(int i=0; i<outputsToLearn.length; i++){
-				literalStatistics[i]=new DoubleVector(new double[5]);
-				varianceShift[i]=instance.valueOutputAttribute(outputsToLearn[i]);
-			}
-			instanceHeader=(InstancesHeader) instance.dataset();
-			hasStarted=true;
-		}
-		double weight=instance.weight();
-		DoubleVector []exampleStatistics=new DoubleVector[outputsToLearn.length];
-		for (int i=0; i<outputsToLearn.length; i++){
-			double target=instance.valueOutputAttribute(outputsToLearn[i]);
-			double sum=weight*target;
-			double squaredSum=weight*target*target;
-			double sumShifted=weight*target-varianceShift[i];
-			double squaredSumShifted=weight*(target-varianceShift[i])*(target-varianceShift[i]);
-			exampleStatistics[i]= new DoubleVector(new double[]{weight,sum, squaredSum,sumShifted,squaredSumShifted});
-			literalStatistics[i].addValues(exampleStatistics[i].getArrayRef());
-		}
-
-		if(this.attributeObservers==null)
-			this.attributeObservers=new AutoExpandVector<AttributeStatisticsObserver>();
-		for(int i=0; i<inputsToLearn.length; i++){
-			if(attributesMask[inputsToLearn[i]]){ //this is checked above. Remove?
-				AttributeStatisticsObserver obs=this.attributeObservers.get(inputsToLearn[i]);
-				if(obs==null){
-					if(instance.attribute(inputsToLearn[i]).isNumeric()){
-						obs=((NumericStatisticsObserver)numericStatisticsObserver.copy());
-					}else if(instance.attribute(inputsToLearn[i]).isNominal()){  //just to make sure its nominal (in the future there may be ordinal?
-						obs=((NominalStatisticsObserver)nominalStatisticsObserver.copy());
-					}
-					this.attributeObservers.set(inputsToLearn[i], obs);
-				}
-				obs.observeAttribute(instance.valueInputAttribute(inputsToLearn[i]), exampleStatistics);
-			}
-		}
-
-		//Transform instance for learning
-		Instance transformedInstance=instanceTransformer.sourceInstanceToTarget(instance);
-		Prediction prediction=null;
-		Prediction targetPrediction=learner.getPredictionForInstance(transformedInstance);
-		if(targetPrediction!=null)
-			prediction=instanceTransformer.targetPredictionToSource(targetPrediction);
-
-		if(prediction!=null)
-			errorMeasurer.addPrediction(prediction, instance);
-
-		learner.trainOnInstance(transformedInstance);
-
-		weightSeen+=instance.weight();
-	}
-
-	@Override
-	public String getStaticOutput(InstancesHeader instanceInformation) {
-		StringBuffer sb = new StringBuffer();
-		if(this.literalStatistics!=null){
-			for(int i=0; i<this.literalStatistics.length; i++){
-				sb.append(instanceInformation.outputAttribute(outputsToLearn[i]).name() +  ": " + literalStatistics[i].getValue(1)/literalStatistics[i].getValue(0) + " ");
-			}
-		}
-		return sb.toString();
-	}
-
-
-
-	/*@Override
-	public void resetLearning() {
-		weightSeen=0;
-		//hasStarted=false;
-	}*/
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/splitcriteria/MultiTargetVarianceRatio.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/splitcriteria/MultiTargetVarianceRatio.java
deleted file mode 100644
index 7e13a9ba0..000000000
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/splitcriteria/MultiTargetVarianceRatio.java
+++ /dev/null
@@ -1,110 +0,0 @@
-package moa.classifiers.rules.multilabel.core.splitcriteria;
-
-import moa.classifiers.mlc.core.splitcriteria.MultiLabelSplitCriterion;
-import moa.classifiers.rules.core.Utils;
-import moa.core.DoubleVector;
-import moa.core.ObjectRepository;
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
-
-
-public class MultiTargetVarianceRatio extends AbstractOptionHandler implements MultiLabelSplitCriterion{
-
-	/**
-	 * 
-	 */
-	private static final long serialVersionUID = 1L;
-
-	@Override
-	public double getMeritOfSplit(DoubleVector[] preSplitDist, DoubleVector[][] postSplitDists) {
-		double error=0;
-		int numOutputs=preSplitDist.length;
-		for (int i=0; i<numOutputs; i++)
-			error+=getMeritOfSplitForOutput(preSplitDist,postSplitDists,i);
-		return error/numOutputs;
-	}
-	
-	public double[] getBranchSplitVarianceOutput(DoubleVector[] postSplitDists) {
-		double[] variances = new double[postSplitDists.length];
-		for(int i = 0; i < postSplitDists.length; i++)
-			variances[i]=Utils.computeVariance(postSplitDists[i]);
-		return variances;
-
-	}
-	
-
-	@Override
-	public double [] getBranchesSplitMerits(DoubleVector[][] postSplitDists){
-		int numOutputs=postSplitDists.length;
-		int numBranches=postSplitDists[0].length;
-		double [] merits=new double[numBranches];
-			for(int j=0; j<numOutputs;j++)
-			{
-				double [] branchMeritsOutput=getBranchSplitVarianceOutput(postSplitDists[j]);
-				/* double weightTotal=0;
-				for (int i=0; i<numBranches;i++){
-					weightTotal+=postSplitDists[j][i].getValue(0)/weightTotal*postSplitDists[j][i].getValue(0);
-				}
-				for (int i=0; i<numBranches;i++){
-					merits[i]+=postSplitDists[j][i].getValue(0)/weightTotal*branchMeritsOutput[i];
-				}*/
-				
-				for (int i=0; i<numBranches;i++){
-					if (postSplitDists[j][i].getValue(0)>0)
-						merits[i]-=branchMeritsOutput[i];
-					else
-						merits[i]=-Double.MAX_VALUE;
-				}
-			}
-		return merits;
-	}
-	
-	protected double getMeritOfSplitForOutput(DoubleVector[] preSplitDist, DoubleVector[][] postSplitDists, int outputAttributeIndex){
-		return getMeritOfSplitForOutput(preSplitDist[outputAttributeIndex],postSplitDists[outputAttributeIndex]);
-	}
-
-	protected double getMeritOfSplitForOutput(DoubleVector preSplitDist, DoubleVector[] postSplitDists) {
-		double merit=0;
-		//count number of branches with weightSeen higher than threshold
-		int count = 0; 
-		for(int i = 0; i < postSplitDists.length; i++)
-			if(postSplitDists[i].getValue(0) >=0.05*preSplitDist.getValue(0))
-				count = count +1;
-		//Consider split if all branches have required weight seen
-		if(count == postSplitDists.length){
-			double varPreSplit=Utils.computeVariance(preSplitDist);
-			double sumVarPostSplit=0;
-			double weightTotal=0;
-			for (int i=0; i<postSplitDists.length;i++){
-				weightTotal+=postSplitDists[i].getValue(0);
-			}
-			double [] variances=getBranchSplitVarianceOutput(postSplitDists);
-			for(int i = 0; i < variances.length; i++)
-				if(postSplitDists[i].getValue(0)>0)
-					sumVarPostSplit+=(postSplitDists[i].getValue(0)/weightTotal*variances[i]);  //weight variance
-			merit=(1-sumVarPostSplit/varPreSplit);
-		}
-		/*if(merit<0 || merit>1)
-			System.out.println("out of range");*/
-		return merit;
-	}
-
-	public double getRangeOfMerit(DoubleVector [] preSplitDist) {
-		return 1;
-	}
-
-
-
-	@Override
-	public void getDescription(StringBuilder sb, int indent) {
-
-	}
-
-	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {		
-	}
-
-
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/splitcriteria/MultilabelInformationGain.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/splitcriteria/MultilabelInformationGain.java
deleted file mode 100644
index 6e2c645f2..000000000
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/splitcriteria/MultilabelInformationGain.java
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- *    MultilabelInformationGain.java
- *    Copyright (C) 2017 University of Porto, Portugal
- *    @author R. Sousa, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-package moa.classifiers.rules.multilabel.core.splitcriteria;
-
-import moa.classifiers.mlc.core.splitcriteria.MultiLabelSplitCriterion;
-import moa.classifiers.rules.core.Utils;
-import moa.core.DoubleVector;
-import moa.core.ObjectRepository;
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
-/**
- * Multi-label Information Gain. 
- * Online Multi-label Classification heuristic for AMRules.
- * 
- * @author RSousa
- */
-public class MultilabelInformationGain  extends AbstractOptionHandler implements MultiLabelSplitCriterion {
-   
-
-    @Override
-    public String getPurposeString() {
-        return "Online Multi-label Classification heuristic for AMRules.";
-    }
-	
-	
-	private static final long serialVersionUID = 1L;
-
-	@Override
-	public double getMeritOfSplit(DoubleVector[] preSplitDist, DoubleVector[][] postSplitDists) {
-		
-            
-                double error=0;
-		int numOutputs=preSplitDist.length;
-		for (int i=0; i<numOutputs; i++)
-			error+=getMeritOfSplitForOutput(preSplitDist,postSplitDists,i);
-		
-                return error/numOutputs;
-	}
-	
-	public double[] getBranchSplitEntropyOutput(DoubleVector[] postSplitDists) {
-		double[] entropies = new double[postSplitDists.length];
-		for(int i = 0; i < postSplitDists.length; i++){
-			entropies[i]=Utils.computeEntropy(postSplitDists[i]);
-        }
-		return entropies;
-	}
-	
-
-	@Override
-	public double [] getBranchesSplitMerits(DoubleVector[][] postSplitDists){
-		
-        int numOutputs=postSplitDists.length;
-		int numBranches=postSplitDists[0].length; 
-		double [] merits=new double[numBranches];
-			for(int j=0; j<numOutputs;j++)
-			{
-				double [] branchMeritsOutput=getBranchSplitEntropyOutput(postSplitDists[j]);
-				
-				for (int i=0; i<numBranches;i++){
-					if (postSplitDists[j][i].getValue(0)>0)
-						merits[i]-=branchMeritsOutput[i];
-					else
-						merits[i]=-Double.MAX_VALUE;
-				}
-			}
-		return merits;
-	}
-	
-	protected double getMeritOfSplitForOutput(DoubleVector[] preSplitDist, DoubleVector[][] postSplitDists, int outputAttributeIndex){
-		return getMeritOfSplitForOutput(preSplitDist[outputAttributeIndex],postSplitDists[outputAttributeIndex]);
-	}
-
-	protected double getMeritOfSplitForOutput(DoubleVector preSplitDist, DoubleVector[] postSplitDists) {
-		double merit=0;
-    
-		//count number of branches with weightSeen higher than threshold
-		int count = 0; 
-		for(int i = 0; i < postSplitDists.length; i++)
-			if(postSplitDists[i].getValue(0) >=0.05*preSplitDist.getValue(0))
-				count = count +1;
-                
-		//Consider split if all branches have required weight seen
-		if(count == postSplitDists.length){
-			
-            double EntPreSplit=Utils.computeEntropy(preSplitDist);
-			double sumEntPostSplit=0;
-			double weightTotal=0;
-			for (int i=0; i<postSplitDists.length;i++){
-				weightTotal+=postSplitDists[i].getValue(0);
-			}
-			double [] Entropies=getBranchSplitEntropyOutput(postSplitDists);
-       
-			for(int i = 0; i < Entropies.length; i++)
-				if(postSplitDists[i].getValue(0)>0)
-					sumEntPostSplit+=(postSplitDists[i].getValue(0)/weightTotal*Entropies[i]);  //weight variance
-                    merit=(EntPreSplit-sumEntPostSplit);
-		}
-		/*if(merit<0 || merit>1)
-			System.out.println("out of range");*/
-		return merit;
-	}
-
-	public double getRangeOfMerit(DoubleVector [] preSplitDist) {
-		return 1;
-	}
-
-
-
-	@Override
-	public void getDescription(StringBuilder sb, int indent) {
-
-	}
-
-	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {		
-	}
-
-
-    
-    
-    
-    
-    
-    
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/MultiLabelVote.java b/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/MultiLabelVote.java
deleted file mode 100644
index 921b6dd81..000000000
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/MultiLabelVote.java
+++ /dev/null
@@ -1,51 +0,0 @@
-package moa.classifiers.rules.multilabel.core.voting;
-
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-public class MultiLabelVote {
-	protected Prediction vote;
-	protected double error;
-	
-	
-	public MultiLabelVote(Prediction vote, double error) {
-		super();
-		this.vote = vote;
-		this.error = error;
-	}
-	
-	public Prediction getVote() {
-		return vote;
-	}
-	
-	public void setVote(Prediction vote) {
-		this.vote = vote;
-	}
-	
-	public double getError() {
-		return error;
-	}
-	
-	public void setError(double error) {
-		this.error = error;
-	}
-	
-	public double [] sumVoteDistrib()
-	{
-		int numOutputs=vote.numOutputAttributes();
-		double [] sum= new double[numOutputs];
-		for (int j=0; j<numOutputs;j++){
-			for (int i=0; i<vote.numClasses(j); ++i)
-				sum[j]+=vote.getVote(j, i);
-		}
-		return sum;		
-	}
-	
-	public void normalize()
-	{
-		double [] sum=sumVoteDistrib();
-		for (int j=0; j<vote.numOutputAttributes();j++)
-			for (int i=0; i<vote.numClasses(j); ++i)
-				if(sum[j]!=0)
-					vote.setVote(j, i, vote.getVote(j, i)/sum[j]);
-	}
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/RelativeMeanAbsoluteDeviationMT.java b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/RelativeMeanAbsoluteDeviationMT.java
deleted file mode 100644
index 36edf0c27..000000000
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/RelativeMeanAbsoluteDeviationMT.java
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- *    RelativeMeanAbsoluteDeviationMT.java
- *    Copyright (C) 2017 University of Porto, Portugal
- *    @author J. Duarte, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *
- *
- */
-
-package moa.classifiers.rules.multilabel.errormeasurers;
-
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-
-/**
- * Relative Mean Absolute Deviation for multitarget and with fading factor
- */
-
-
-public class RelativeMeanAbsoluteDeviationMT extends AbstractMultiTargetErrorMeasurer {
-
-	/**
-	 * 
-	 */
-	protected double weightSeen;
-	protected double [] sumError;
-	
-	protected double [] sumY;
-	protected double [] sumErrorToTargetMean;
-	
-	private static final long serialVersionUID = 1L;
-	protected boolean hasStarted;
-	protected int numLearnedOutputs;
-
-	@Override
-	public void addPrediction(Prediction prediction, Prediction trueClass, double weight) {
-		int numOutputs=prediction.numOutputAttributes();
-		if (!hasStarted){
-			sumError=new double[numOutputs];
-			sumY=new double[numOutputs];
-			sumErrorToTargetMean=new double[numOutputs];
-			hasStarted=true;
-			for(int i=0; i<numOutputs;i++)
-				if(prediction.hasVotesForAttribute(i))
-					++numLearnedOutputs;
-			hasStarted=true;
-		}
-		weightSeen=weight+fadingErrorFactor*weightSeen;
-		for(int i=0; i<numOutputs;i++){
-			if(prediction.hasVotesForAttribute(i)){
-				sumError[i]=Math.abs(prediction.getVote(i, 0)-trueClass.getVote(i, 0))*weight+fadingErrorFactor*sumError[i];
-				sumY[i]=trueClass.getVote(i, 0)*weight+fadingErrorFactor*sumY[i]; 
-				double errorOutputTM=Math.abs(prediction.getVote(i, 0)-sumY[i]/weightSeen); //error to target mean
-				sumErrorToTargetMean[i]=errorOutputTM*weight+fadingErrorFactor*sumErrorToTargetMean[i];
-			}
-		}
-
-	}
-
-	@Override
-	public double getCurrentError() {
-		if(weightSeen==0)
-			return Double.MAX_VALUE;
-		else
-		{
-			double sum=0;
-			int numOutputs=sumError.length;
-			for (int i=0; i<numOutputs; i++)
-				sum+=getCurrentError(i);
-			return sum/numLearnedOutputs;
-		}
-	}
-
-	@Override
-	public double getCurrentError(int index) {
-		return sumError[index]/sumErrorToTargetMean[index];
-	}
-
-	@Override
-	public double[] getCurrentErrors() {
-		double [] errors=null;
-		if(sumError!=null){
-			errors=new double[sumError.length];
-			for (int i=0;i<sumError.length; i++)
-				errors[i]=getCurrentError(i);
-		}
-		return errors;
-	}
-
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/RelativeRootMeanSquaredErrorMT.java b/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/RelativeRootMeanSquaredErrorMT.java
deleted file mode 100644
index 241ca3552..000000000
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/RelativeRootMeanSquaredErrorMT.java
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- *    RelativeRootMeanSquaredErrorMT.java
- *    Copyright (C) 2017 University of Porto, Portugal
- *    @author J. Duarte, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *
- *
- */
-package moa.classifiers.rules.multilabel.errormeasurers;
-
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-/**
- * Relative Root Mean Squared Error for multitarget and with fading factor
- */
-
-
-
-
-public class RelativeRootMeanSquaredErrorMT extends AbstractMultiTargetErrorMeasurer {
-
-	/**
-	 * 
-	 */
-	protected double weightSeen;
-	protected double [] sumY;
-	protected double [] sumSquaredError;
-	protected double [] sumSquaredErrorToTargetMean;
-	protected static final long serialVersionUID = 1L;
-	protected boolean hasStarted;
-	protected int numLearnedOutputs;
-
-	@Override
-	public void addPrediction(Prediction prediction, Prediction trueClass, double weight) {
-		int numOutputs=prediction.numOutputAttributes();
-		if (!hasStarted){
-			sumSquaredError=new double[numOutputs];
-			sumY=new double[numOutputs];
-			sumSquaredErrorToTargetMean=new double[numOutputs];
-			hasStarted=true;
-			for(int i=0; i<numOutputs;i++)
-				if(prediction.hasVotesForAttribute(i))
-					++numLearnedOutputs;
-			hasStarted=true;
-		}
-		weightSeen=weight+fadingErrorFactor*weightSeen;
-		for(int i=0; i<numOutputs;i++){
-			if(prediction.hasVotesForAttribute(i)){
-				sumY[i]=trueClass.getVote(i, 0)*weight+fadingErrorFactor*sumY[i]; //sum target
-				double errorOutput=prediction.getVote(i, 0)-trueClass.getVote(i, 0);
-				double errorOutputTM=prediction.getVote(i, 0)-sumY[i]/weightSeen; //error to target mean
-				sumSquaredError[i]=errorOutput*errorOutput*weight+fadingErrorFactor*sumSquaredError[i];
-				sumSquaredErrorToTargetMean[i]=errorOutputTM*errorOutputTM*weight+fadingErrorFactor*sumSquaredErrorToTargetMean[i];
-			}
-		}
-
-	}
-
-	@Override
-	public double getCurrentError() {
-		if(weightSeen==0)
-			return Double.MAX_VALUE;
-		else
-		{
-			double sum=0;
-			int numOutputs=sumSquaredError.length;
-			for (int i=0; i<numOutputs; i++)
-				sum+=Math.sqrt(sumSquaredError[i]/sumSquaredErrorToTargetMean[i]);
-			return sum/numLearnedOutputs;
-		}
-	}
-
-	@Override
-	public double getCurrentError(int index) {
-		return Math.sqrt(sumSquaredError[index]/sumSquaredErrorToTargetMean[index]);
-	}
-
-	@Override
-	public double[] getCurrentErrors() {
-		double [] errors=null;
-		if(sumSquaredError!=null){
-			errors= new double[sumSquaredError.length];
-			for (int i=0;i<sumSquaredError.length; i++)
-				errors[i]=getCurrentError(i) ;
-		}
-		return errors;
-	}
-
-
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/AdaptiveMultiTargetRegressor.java b/moa/src/main/java/moa/classifiers/rules/multilabel/functions/AdaptiveMultiTargetRegressor.java
deleted file mode 100644
index 7e8dc02a8..000000000
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/AdaptiveMultiTargetRegressor.java
+++ /dev/null
@@ -1,176 +0,0 @@
-/*
- *    AdaptiveMultiTargetRegressor.java
- *    Copyright (C) 2017 University of Porto, Portugal
- *    @author J. Duarte, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *
- *
- */
-package moa.classifiers.rules.multilabel.functions;
-
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractMultiTargetRegressor;
-import moa.classifiers.rules.multilabel.errormeasurers.AbstractMultiTargetErrorMeasurer;
-import moa.classifiers.rules.multilabel.errormeasurers.MeanAbsoluteDeviationMT;
-import moa.classifiers.rules.multilabel.errormeasurers.MultiTargetErrorMeasurer;
-import moa.core.Measurement;
-import moa.learners.MultiTargetRegressor;
-import moa.options.ClassOption;
-
-/**
- * Adaptive MultiTarget Regressor uses two learner
- * The first is used in first stage when high error are produced(e.g. Target mean)
- * The second is used in a second stage when low error are produced(e.g perceptron)
- * 	baseLearnerOption1- Learner one ;
- *  baseLearnerOption2- learner two
- */
-
-
-public class AdaptiveMultiTargetRegressor extends AbstractMultiTargetRegressor implements MultiTargetRegressor, AMRulesFunction {
-
-	/**
-	 * 
-	 */
-	private static final long serialVersionUID = 1L;
-
-	private static final int NUM_LEARNERS=2;
-
-	public ClassOption baseLearnerOption1;
-	public ClassOption baseLearnerOption2;
-
-	public ClassOption errorMeasurerOption;
-	
-//	public IntOption randomSeedOption = new IntOption("randomSeedOption",
-//			'r', "randomSeedOption", 
-//			1,Integer.MIN_VALUE, Integer.MAX_VALUE);
-
-	protected boolean hasStarted;
-
-	protected MultiTargetRegressor baseLearner[] ;
-
-
-	protected MultiTargetErrorMeasurer [] errorMeasurer;
-
-	public AdaptiveMultiTargetRegressor(){
-		super.randomSeedOption=randomSeedOption;
-		 baseLearnerOption1 = new ClassOption("baseLearner1", 'l',
-				"First base learner.", AMRulesFunction.class, MultiTargetMeanRegressor.class.getName()) ;
-		 baseLearnerOption2= new ClassOption("baseLearner2", 'm',
-				"Second base learner.", AMRulesFunction.class, MultiTargetPerceptronRegressor.class.getName()) ;
-		 errorMeasurerOption = new ClassOption("errorMeasurer", 'e',
-				"Measure of error for deciding which learner should predict.", AbstractMultiTargetErrorMeasurer.class, MeanAbsoluteDeviationMT.class.getName()) ;
-
-	}
-	@Override
-	public void trainOnInstanceImpl(Instance instance) {
-		if (!this.hasStarted){	
-			baseLearner=new MultiTargetRegressor[NUM_LEARNERS];
-			errorMeasurer= new MultiTargetErrorMeasurer[NUM_LEARNERS];
-			baseLearner[0]=(MultiTargetRegressor) getPreparedClassOption(this.baseLearnerOption1);
-			baseLearner[1]=(MultiTargetRegressor) getPreparedClassOption(this.baseLearnerOption2);
-			for (int i=0; i<NUM_LEARNERS; i++){
-				if(baseLearner[i].isRandomizable())
-					baseLearner[i].setRandomSeed(this.randomSeed);
-				baseLearner[i].resetLearning();
-				errorMeasurer[i]=(MultiTargetErrorMeasurer)((MultiTargetErrorMeasurer) getPreparedClassOption(this.errorMeasurerOption)).copy();
-			
-			}
-			this.hasStarted = true;
-		}
-		for (int i=0; i<NUM_LEARNERS; i++){
-			//Update online errors
-			Prediction prediction=baseLearner[i].getPredictionForInstance(instance);
-			if(prediction!=null)//should happen only for first instance
-				errorMeasurer[i].addPrediction(prediction, instance);
-			//Train
-			baseLearner[i].trainOnInstanceImpl(instance);
-		}
-
-	}
-
-	@Override
-	public Prediction getPredictionForInstance(Instance inst) {
-		Prediction prediction=null;
-		if(hasStarted){
-			int bestIndex=0;
-			double minError=Double.MAX_VALUE;
-			for (int i=0; i<NUM_LEARNERS; i++){
-				double error=errorMeasurer[i].getCurrentError();
-				if(error<minError)
-				{
-					minError=error;
-					bestIndex=i;
-				}
-			}
-			prediction=baseLearner[bestIndex].getPredictionForInstance(inst);
-		}
-		return prediction;
-	}
-
-	@Override
-	public boolean isRandomizable() {
-		return true;
-	}
-
-	@Override
-	public void resetLearningImpl() {
-		this.hasStarted = false;
-		if(baseLearner!=null){
-			for (int i=0; i<baseLearner.length; i++){
-				classifierRandom.setSeed(randomSeedOption.getValue());
-				baseLearner[i].setRandomSeed(this.randomSeed);
-				baseLearner[i].resetLearning();
-			}
-		}
-	}
-
-	@Override
-	protected Measurement[] getModelMeasurementsImpl() {
-		return null;
-	}
-
-	@Override
-	public void getModelDescription(StringBuilder out, int indent) {
-
-	}
-
-	@Override
-	public String getPurposeString() {
-		return "Learns two regressors and uses the regressor with less error to predict.";
-	}
-
-	@Override
-	public void resetWithMemory() {
-		if(errorMeasurer==null)
-			errorMeasurer=new MultiTargetErrorMeasurer[NUM_LEARNERS];
-		for (int i=0; i<NUM_LEARNERS; i++){
-			errorMeasurer[i]=(MultiTargetErrorMeasurer)((MultiTargetErrorMeasurer) getPreparedClassOption(this.errorMeasurerOption)).copy();
-			if(baseLearner[i] instanceof AMRulesFunction)
-				((AMRulesFunction)baseLearner[i]).resetWithMemory();
-		}
-	}
-	@Override
-	public void selectOutputsToLearn(int[] outtputAtributtes) {
-		for (int i=0; i<NUM_LEARNERS; i++){
-			((AMRulesFunction)baseLearner[i]).selectOutputsToLearn(outtputAtributtes);
-		}
-	}
-	
-
-
-
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/MultiLabelPerceptronClassification.java b/moa/src/main/java/moa/classifiers/rules/multilabel/functions/MultiLabelPerceptronClassification.java
deleted file mode 100644
index 1b09dda86..000000000
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/MultiLabelPerceptronClassification.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- *    MultiLabelPerceptronClassification.java
- *    Copyright (C) 2017 University of Porto, Portugal
- *    @author R. Sousa, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-
-
-
-package moa.classifiers.rules.multilabel.functions;
-
-import moa.learners.MultiLabelClassifier;
-import moa.options.ClassOption;
-
-/**
- * Multi-Label perceptron classifier (by Binary Relevance).
- *This method computes a perceptron classifier per output
- * @author RSousa
- * @version $Revision: 1 $
- */
-public class MultiLabelPerceptronClassification extends AbstractAMRulesFunctionBasicMlLearner implements MultiLabelClassifier, AMRulesFunction {
-    
-    private static final long serialVersionUID = 1L;
-    
-    @Override
-    protected void init(){
-        baseLearnerOption=new ClassOption("baseLearner", 'l',
-            "moa.classifiers.functions.Perceptron", moa.classifiers.functions.Perceptron.class, "moa.classifiers.functions.Perceptron");
-    }
-
-    @Override
-    public String getPurposeString() {
-        return "Uses an ensemble of rules.Perceptron to preform multitarget regression.\n"
-	       + "Extends BasicMultiLabelLearner by allowing only rules.Perceptron";
-    }
-    
-    @Override
-    public void resetWithMemory() {
-		//for (int i = 0; i < this.ensemble.length; i++) {
-		//TODO: JD - reset all statistics? how can we keep some memory?
-		//	
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/StackedPredictor.java b/moa/src/main/java/moa/classifiers/rules/multilabel/functions/StackedPredictor.java
deleted file mode 100644
index 0dd780926..000000000
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/StackedPredictor.java
+++ /dev/null
@@ -1,419 +0,0 @@
-/*
- *    StackedPredictor.java
- *    Copyright (C) 2017 University of Porto, Portugal
- *    @author J. Duarte, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *
- *
- */
-package moa.classifiers.rules.multilabel.functions;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.Random;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractMultiTargetRegressor;
-import moa.classifiers.rules.core.Utils;
-import moa.core.Measurement;
-import moa.learners.MultiTargetRegressor;
-
-
-public class StackedPredictor extends AbstractMultiTargetRegressor implements MultiTargetRegressor, AMRulesFunction {
-
-	/**
-	 * Multi-Target Stacked Predictor for regression
-	 */
-	private static final long serialVersionUID = 1L;
-
-	//THRESHOLD for normalizing attribute and target values
-	private final double SD_THRESHOLD = 0.0000001;
-
-
-	// Parameters and options
-	public FlagOption constantLearningRatioDecayOption = new FlagOption(
-			"learningRatio_Decay_set_constant", 'd',
-			"Learning Ratio Decay in Perceptron set to be constant. (The next parameter).");
-
-	public FloatOption learningRatioOption = new FloatOption(
-			"learningRatio", 'l', 
-			"Learning Ratio to use for training the 1st layer.", 0.025);
-
-	public FloatOption learningRatio2ndLayerOption = new FloatOption(
-			"learningRatio2ndLayer", 'n', 
-			"Learning Ratio to use in the second layer.", 0.001);
-
-	public FloatOption learningRateDecayOption = new FloatOption(
-			"learningRateDecay", 'm', 
-			" Learning Rate decay to use for training the 1st layer.", 0.001);
-
-	public FlagOption skipStackingOption = new FlagOption(
-			"skipStackingOption", 's',
-			"Predicts the outputs of the first layer (no dependence among output is computed)");
-
-//	public IntOption randomSeedOption = new IntOption("randomSeed", 'r',
-//			"Seed for random behaviour of the classifier.", 1);
-
-	public FlagOption printWeightsOption = new FlagOption(
-			"printWeights", 'p',
-			"Outputs the 2nd layer weights as measurements.");
-
-
-	/*
-	 * Other class attributes 
-	 */
-
-	private boolean hasStarted;
-	//Weight seen so far
-	private double count;
-
-	//Input attributes statistics
-	private double [] inAttrSum;
-	private double [] inAttrSquaredSum;
-
-	//Output attributes statistics
-	private double [] outAttrSum;
-	private double [] outAttrSquaredSum;
-
-	//First Layer Weights 
-	private double [][] layer1Weights;
-
-	//Second Layer Weights
-	private double [][] layer2Weights;
-
-	//Algorithm auxiliary variables
-	double currentLearningRate;
-
-	LinkedList<Integer> numericIndices;
-
-
-	/*
-	 * Algorithm's behavior 
-	 */	
-	@Override
-	public boolean isRandomizable() {
-		return true;
-	}
-
-	@Override
-	public void resetWithMemory() {
-		currentLearningRate=this.learningRatioOption.getValue();
-
-	}
-
-	@Override
-	public void trainOnInstanceImpl(Instance instance) {
-		int numOutputs=instance.numOutputAttributes();
-
-		if(!hasStarted){
-			hasStarted=true;
-			numericIndices= new LinkedList<Integer>();
-			//Initialize numericAttributesIndex
-			for (int i = 0; i < instance.numInputAttributes(); i++)
-				if(instance.inputAttribute(i).isNumeric())
-					numericIndices.add(i);
-
-			int numInputs=numericIndices.size();
-			inAttrSum=new double[numInputs];
-			inAttrSquaredSum=new double[numInputs];
-
-			outAttrSum=new double[numOutputs];
-			outAttrSquaredSum=new double[numOutputs];
-
-			layer1Weights=new double[numInputs+1][numOutputs];
-			layer2Weights=new double[numOutputs+1][numOutputs];
-
-			/*
-			 * Initialize first layer randomly uniform between -1 and 1
-			 * Initialize second layer such that the weights between
-			 * correspondent outputs are 1 and the remaining are 0
-			 */
-			for (int j=0; j<numOutputs; j++)
-			{
-				//Iterator<Integer> it=numericIndices.iterator();
-				for (int i=0; i<numInputs+1; i++)
-					//while(it.hasNext())
-					layer1Weights[i][j] = 2 * this.classifierRandom.nextDouble() - 1;
-				layer2Weights[j][j]=1.0;
-			}
-
-			/*	for (int i=0; i<numOutputs+1; i++)
-				for (int j=0; j<numOutputs; j++)
-					layer2Weights[i][j]= 2 * this.classifierRandom.nextDouble() - 1;*/
-
-		}
-
-		/*
-		 * Update statistics
-		 */
-		int numInputs=numericIndices.size();
-		//Update input statistics
-		double w=instance.weight();
-		count+=w;
-		Iterator<Integer> it=numericIndices.iterator();
-		int ct=0;
-		while(it.hasNext()){
-			double value=instance.valueInputAttribute(it.next());
-			inAttrSum[ct]+=value*w;
-			inAttrSquaredSum[ct]+=value*value*w;
-			ct++;
-		}
-
-		//Update  output statistics
-		for(int i=0; i<numOutputs; i++){
-			double value=instance.valueOutputAttribute(i);
-			outAttrSum[i]+=value*w;
-			outAttrSquaredSum[i]+=value*value*w;
-		}
-
-		/*
-		 * Learn new weights
-		 */
-
-		//predict outputs
-		double [] normInputs=getNormalizedInput(instance);
-		//1st Layer
-		double [] firstLayerOutput=predict1stLayer(normInputs);
-		//2nd Layer
-		double [] secondLayerOutput=null;
-		if(!skipStackingOption.isSet()){
-			secondLayerOutput=predict2ndLayer(firstLayerOutput);
-		}
-
-
-		if(!constantLearningRatioDecayOption.isSet()){
-			currentLearningRate = learningRatioOption.getValue() / (1+ count*this.learningRateDecayOption.getValue()); 
-		}
-
-		//update weights
-		//1st Layer
-		double [] normOutputs=getNormalizedOutput(instance);
-		for (int j=0; j<numOutputs; j++){
-			double delta=normOutputs[j] - firstLayerOutput[j];
-			double sumLayer=0;
-			for(int i=0; i<numInputs; i++){
-				layer1Weights[i][j]+=currentLearningRate * delta * normInputs[i]*instance.weight();
-				sumLayer+=Math.abs(layer1Weights[i][j]);
-			}
-
-			layer1Weights[numInputs][j]+=currentLearningRate * delta * instance.weight();
-			sumLayer+=Math.abs(layer1Weights[numInputs][j]);
-			if(sumLayer>(numInputs)){
-				for(int i=0; i<(numInputs+1); i++)
-					layer1Weights[i][j]/=sumLayer;
-			}
-		}
-		if(!skipStackingOption.isSet()){
-			//update weights
-			//2nd Layer
-			double learningRate2ndLayer=learningRatio2ndLayerOption.getValue();
-			for (int j=0; j<numOutputs; j++){
-				double delta=normOutputs[j] - secondLayerOutput[j];
-				double sumLayer=0;
-				for(int i=0; i<numOutputs; i++){
-					layer2Weights[i][j]+=learningRate2ndLayer * delta * firstLayerOutput[i]*instance.weight();
-					sumLayer+=Math.abs(layer2Weights[i][j]);
-				}
-
-				layer2Weights[numOutputs][j]+=learningRate2ndLayer * delta * instance.weight();
-				sumLayer+=Math.abs(layer2Weights[numOutputs][j]);
-				if(sumLayer>(numOutputs)){
-					for(int i=0; i<(numOutputs+1); i++)
-						layer2Weights[i][j]/=sumLayer;
-				}
-			}
-
-		}
-
-	}
-
-
-	@Override
-	public Prediction getPredictionForInstance(Instance inst) {
-		Prediction pred=null;
-		if(hasStarted)
-		{
-			int numOutputs=outAttrSum.length;
-			pred=new MultiLabelClassificationPrediction(numOutputs);
-
-			double [] normInputs=getNormalizedInput(inst);
-			double [] firstLayerOutput=predict1stLayer(normInputs);
-
-			double [] denormalizedOutput=null;
-			if(!skipStackingOption.isSet()){
-				double [] secondLayerOutput=predict2ndLayer(firstLayerOutput);
-				denormalizedOutput=getDenormalizedOutput(secondLayerOutput);
-			}
-			else
-				denormalizedOutput=getDenormalizedOutput(firstLayerOutput);
-
-			for(int i=0; i<numOutputs; i++)
-				pred.setVotes(i, new double[]{denormalizedOutput[i]});	
-		}	
-		return pred;
-	}
-
-	@Override
-	public void resetLearningImpl() {
-
-		hasStarted=false;
-		count=0;
-		inAttrSum=null;
-		inAttrSquaredSum=null;
-
-		outAttrSum=null;
-		outAttrSquaredSum=null;
-
-		layer1Weights=null;
-		layer2Weights=null;
-
-		numericIndices=null;
-
-		currentLearningRate=this.learningRatioOption.getValue();
-
-		//TODO: JD Check if random generator is somehow overridden
-		this.classifierRandom=new Random();
-		this.classifierRandom.setSeed(randomSeedOption.getValue());
-
-	}
-
-	protected double [] getNormalizedInput(Instance instance) {
-		int numInputs=numericIndices.size();
-		double [] normalizedInput=new double[numInputs];
-		Iterator<Integer> it=numericIndices.iterator();
-		int i=0;
-		while(it.hasNext()){
-			double mean=inAttrSum[i]/count;
-			double std=Utils.computeSD(inAttrSquaredSum[i], inAttrSum[i], count);
-			normalizedInput[i]=instance.valueInputAttribute(it.next())-mean;
-			if (std > SD_THRESHOLD)
-				normalizedInput[i]/=std;
-			i++;
-		}
-		return normalizedInput;
-	}
-
-	protected double [] getNormalizedOutput(Instance instance) {
-		int numOutputs=instance.numOutputAttributes();
-		double [] normalizedOutput=new double[numOutputs];
-		for(int i=0; i<numOutputs; i++){
-			double mean=outAttrSum[i]/count;
-			double std=Utils.computeSD(outAttrSquaredSum[i], outAttrSum[i], count);
-			normalizedOutput[i]=instance.valueOutputAttribute(i)-mean;
-			if (std > SD_THRESHOLD)
-				normalizedOutput[i]/=std;
-		}
-		return normalizedOutput;
-	}
-
-	protected double [] getDenormalizedOutput(double [] normOutputs) {
-		int numOutputs=normOutputs.length;
-		double [] denormalizedOutput=new double[numOutputs];
-
-		for(int i=0; i<numOutputs; i++){
-			double mean=outAttrSum[i]/count;
-			double std=Utils.computeSD(outAttrSquaredSum[i], outAttrSum[i], count);
-			if(std > SD_THRESHOLD)
-				denormalizedOutput[i]=normOutputs[i]*std+mean;
-			else
-				denormalizedOutput[i]=normOutputs[i]+mean;
-		}
-		return denormalizedOutput;
-	}
-
-	private double[] predict1stLayer(double [] normInputs) {
-		int numInputs=numericIndices.size();
-		int numOutputs=this.outAttrSum.length;
-
-		double [] firstLayerOutput=new double[numOutputs];
-		for (int j=0; j<numOutputs; j++){
-			for(int i=0; i<numInputs; i++)
-				firstLayerOutput[j]+=normInputs[i]*layer1Weights[i][j];
-			firstLayerOutput[j]+=layer1Weights[numInputs][j]; //bias
-		}
-		return firstLayerOutput;
-	}
-
-	private double[] predict2ndLayer(double[] firstLayerOutput) {
-		int numOutputs=firstLayerOutput.length;
-		double [] secondLayerOutput=new double[numOutputs];
-		for (int j=0; j<numOutputs; j++){
-			for(int i=0; i<numOutputs; i++)
-				secondLayerOutput[j]+=firstLayerOutput[i]*layer2Weights[i][j];
-			secondLayerOutput[j]+=layer2Weights[numOutputs][j]; //bias
-		}
-		return secondLayerOutput;
-	}
-
-
-	@Override
-	protected Measurement[] getModelMeasurementsImpl() {
-		Measurement [] measurements=null;
-		if(printWeightsOption.isSet()){
-			int numWeights=this.layer2Weights.length;
-			measurements= new Measurement[numWeights*(numWeights-1)];
-			int ct=0;
-			for(int j=0; j<numWeights-1; j++){
-				for(int i=0; i<numWeights-1; i++){
-					measurements[ct++]= new Measurement("W Out" + (i+1) + ": Out"+(j+1), layer2Weights[i][j]);
-				}
-
-				measurements[ct++]= new Measurement("W Bias: Out"+(j+1), layer2Weights[numWeights-1][j]);
-			}
-		}
-		return measurements;
-	}
-
-	@Override
-	public void getModelDescription(StringBuilder out, int indent) {
-		// TODO Auto-generated method stub
-
-	}
-
-	@Override
-	public void selectOutputsToLearn(int[] outputAtributtes) {
-
-		//Remove weights for unselected outputs
-		int numOutputs=outputAtributtes.length;
-		double [] newOutAttrSum=new double[numOutputs];
-		double [] newOutAttrSquaredSum=new double[numOutputs];
-		int numInputsPlus1=layer1Weights.length;
-
-		double [][] newLayer1Weights=new double[numInputsPlus1][numOutputs];
-		double [][] newLayer2Weights=new double[numInputsPlus1][numOutputs];
-
-		int oldNumOutputs=layer2Weights.length-1;
-		for (int j=0; j<numOutputs; j++){
-			int out=outputAtributtes[j];
-			newOutAttrSum[j]=outAttrSum[out];
-			newOutAttrSquaredSum[j]=outAttrSquaredSum[out];
-			for(int i=0; i<numInputsPlus1; i++)
-				newLayer1Weights[i][j]=layer1Weights[i][out];
-			for (int i=0; i<numOutputs; i++){
-				int out2=outputAtributtes[i];
-				newLayer2Weights[i][j]=layer2Weights[out2][out];
-			}
-			newLayer2Weights[numOutputs][j]=layer2Weights[oldNumOutputs][out];
-		}
-		outAttrSum=newOutAttrSum;
-		outAttrSquaredSum=newOutAttrSquaredSum;
-		layer1Weights=newLayer1Weights;
-		layer2Weights=newLayer2Weights;
-	}
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/inputselectors/MeritThreshold.java b/moa/src/main/java/moa/classifiers/rules/multilabel/inputselectors/MeritThreshold.java
deleted file mode 100644
index cdbf593a3..000000000
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/inputselectors/MeritThreshold.java
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- *    MeritThreshold.java
- *    Copyright (C) 2017 University of Porto, Portugal
- *    @author J. Duarte, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *
- *
- */
-package moa.classifiers.rules.multilabel.inputselectors;
-
-import com.github.javacliparser.FloatOption;
-
-import moa.classifiers.rules.core.AttributeExpansionSuggestion;
-import moa.core.ObjectRepository;
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
-
-/**
- *  Input selection algorithm based on Merit threshold
- */
-
-public class MeritThreshold extends AbstractOptionHandler implements InputAttributesSelector {
-
-
-	/**
-	 * 
-	 */
-	private static final long serialVersionUID = 1L;
-	
-	public FloatOption percentageThresholdOption = new FloatOption("percentageThreshold",
-			'p', "Allowed merit decrease in percentage of best input attribute.",
-			0.1, 0.0, 1.0);
-
-	@Override
-	public int[] getNextInputIndices(
-			AttributeExpansionSuggestion[] sortedSplitSuggestions) {
-		int [] nextInput=null;
-		if(sortedSplitSuggestions.length>0){
-			int [] temp=new int[sortedSplitSuggestions.length]; //use list instead?
-			double threshold=sortedSplitSuggestions[sortedSplitSuggestions.length-1].merit*(percentageThresholdOption.getValue());
-			temp[0]=sortedSplitSuggestions[sortedSplitSuggestions.length-1].predicate.getAttributeIndex();
-			int c=1;
-			for (int i=sortedSplitSuggestions.length-2; i>=0 && sortedSplitSuggestions[i].merit>=threshold; i--){
-				temp[c]=sortedSplitSuggestions[i].getPredicate().getAttributeIndex();		
-				c++;
-			}
-			if(c==1 && sortedSplitSuggestions.length>1 ){ //if only one is selected, add a second attribute for computing hoeffding bound
-				c=2;
-				temp[1]=sortedSplitSuggestions[sortedSplitSuggestions.length-2].predicate.getAttributeIndex();
-			}
-			nextInput=new int[c];
-			for(int i=0; i<c; i++){
-				nextInput[i]=temp[i];
-			}
-			
-		}
-		//System.out.println("Indices: " + java.util.Arrays.toString(nextInput));
-		return nextInput;
-	}
-
-	@Override
-	public void getDescription(StringBuilder sb, int indent) {
-		// TODO Auto-generated method stub
-
-	}
-
-	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
-	}
-
-
-}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/meta/MultiLabelRandomAMRules.java b/moa/src/main/java/moa/classifiers/rules/multilabel/meta/MultiLabelRandomAMRules.java
deleted file mode 100644
index 671ebb8e4..000000000
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/meta/MultiLabelRandomAMRules.java
+++ /dev/null
@@ -1,243 +0,0 @@
-/*
- *    MultiLabelRandomAMRules.java
- *    Copyright (C) 2017 University of Porto, Portugal
- *    @author J. Duarte, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *
- *
- */
-
-
-package moa.classifiers.rules.multilabel.meta;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractMultiTargetRegressor;
-import moa.classifiers.rules.featureranking.FeatureRanking;
-import moa.classifiers.rules.featureranking.NoFeatureRanking;
-import moa.classifiers.rules.multilabel.AMRulesMultiLabelLearner;
-import moa.classifiers.rules.multilabel.core.voting.ErrorWeightedVoteMultiLabel;
-import moa.classifiers.rules.multilabel.core.voting.UniformWeightedVoteMultiLabel;
-import moa.classifiers.rules.multilabel.errormeasurers.AbstractMultiTargetErrorMeasurer;
-import moa.classifiers.rules.multilabel.errormeasurers.MultiLabelErrorMeasurer;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.core.MiscUtils;
-import moa.learners.MultiTargetRegressor;
-import moa.options.ClassOption;
-
-public class MultiLabelRandomAMRules extends AbstractMultiTargetRegressor implements MultiTargetRegressor {
-
-	/**
-	 * 
-	 */
-	private static final long serialVersionUID = 1L;
-	private 		int nAttributes=0;
-
-	public IntOption VerbosityOption = new IntOption(
-			"verbosity",
-			'v',
-			"Output Verbosity Control Level. 1 (Less) to 2 (More)",
-			1, 1, 2);
-
-
-	public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l', "Classifier to train.", AMRulesMultiLabelLearner.class, "AMRulesMultiTargetRegressor"); 
-
-	public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's',
-			"The number of models in the bag.", 10, 1, Integer.MAX_VALUE);
-
-	public FloatOption numAttributesPercentageOption = new FloatOption("numAttributesPercentage", 'n',
-			"The number of attributes to use per model.", 63.2, 0, 100); 
-
-	public FlagOption useBaggingOption = new FlagOption("useBagging", 'p',
-			"Use Bagging.");
-
-	public ClassOption votingFunctionOption = new ClassOption("votingFunction",
-			'V', "Voting Function.", 
-			ErrorWeightedVoteMultiLabel.class,
-			UniformWeightedVoteMultiLabel.class.getName());
-
-	public MultiChoiceOption votingTypeOption = new MultiChoiceOption(
-			"votingTypeOption", 'C', "Select whether the base learner error is computed as the overall error or only the error of the rules that cover the example.", new String[]{
-					"Overall (Static)","Only rules covered (Dynamic)"}, new String[]{
-					"Overall","Covered"}, 0);
-
-
-//	public IntOption randomSeedOption = new IntOption("randomSeed", 'r',
-//			"Seed for random behaviour of the classifier.", 1);
-	protected AMRulesMultiLabelLearner [] ensemble;
-
-	protected MultiLabelErrorMeasurer [] errorMeasurer;
-
-	public ClassOption errorMeasurerOption = new ClassOption("errorMeasurer", 'e',
-			"Measure of error for deciding which learner should predict.", AbstractMultiTargetErrorMeasurer.class, "MeanAbsoluteDeviationMT") ;
-
-	/*protected double[] sumError;
-	protected double[] nError;*/
-
-	public ClassOption featureRankingOption = new ClassOption("featureRanking",
-			'F', "Feature ranking algorithm.", 
-			FeatureRanking.class,
-			NoFeatureRanking.class.getName());
-
-	protected boolean isRegression;
-	protected FeatureRanking featureRanking;
-	
-
-	@Override
-	public void resetLearningImpl() {
-		this.classifierRandom.setSeed(this.randomSeedOption.getValue());
-		int n=this.ensembleSizeOption.getValue();
-		this.ensemble= new AMRulesMultiLabelLearner[n];
-		this.errorMeasurer= new MultiLabelErrorMeasurer[n];
-
-
-		AMRulesMultiLabelLearner baseLearner = (AMRulesMultiLabelLearner) getPreparedClassOption(this.baseLearnerOption);
-		MultiLabelErrorMeasurer measurer=(MultiLabelErrorMeasurer) getPreparedClassOption(this.errorMeasurerOption);
-		baseLearner.setAttributesPercentage(numAttributesPercentageOption.getValue());
-		baseLearner.resetLearning();
-		for (int i = 0; i < this.ensemble.length; i++) {
-			this.ensemble[i] = (AMRulesMultiLabelLearner) baseLearner.copy();
-			this.ensemble[i].setRandomSeed(this.classifierRandom.nextInt());
-			this.errorMeasurer[i]=(MultiLabelErrorMeasurer)measurer.copy();
-		}
-		this.isRegression = (baseLearner instanceof MultiTargetRegressor);
-                featureRanking=  (FeatureRanking) getPreparedClassOption(this.featureRankingOption);
-	}
-
-	public void trainOnInstanceImpl(Instance instance) {
-		if(featureRanking==null){
-			featureRanking=  (FeatureRanking) getPreparedClassOption(this.featureRankingOption);
-		for (int i = 0; i < this.ensemble.length; i++) {
-				this.ensemble[i].setObserver(featureRanking);
-			}
-			nAttributes=instance.numInputAttributes();
-		}
-		for (int i = 0; i < this.ensemble.length; i++) {
-			Instance inst = instance.copy();
-			int k = 1;
-			if ( this.useBaggingOption.isSet()) {
-				k = MiscUtils.poisson(1.0, this.classifierRandom);
-			} 
-			if (k > 0) {
-				//Instance weightedInst = transformInstance(inst,i);
-				inst.setWeight(inst.weight() * k);
-				//estimate error
-				Prediction p=ensemble[i].getPredictionForInstance(inst);
-				if(p!=null)
-					errorMeasurer[i].addPrediction(p, inst);	
-				//train learner
-				this.ensemble[i].trainOnInstance(inst);
-			}
-		}
-	}
-
-	@Override
-	public Prediction getPredictionForInstance(Instance inst) {
-		Prediction vote=null;
-		//ErrorWeightedVote combinedVote = (ErrorWeightedVote)((ErrorWeightedVote) votingTypeOption.getPreMaterializedObject()).copy();
-		ErrorWeightedVoteMultiLabel combinedVote = (ErrorWeightedVoteMultiLabel)((ErrorWeightedVoteMultiLabel) getPreparedClassOption(this.votingFunctionOption)).copy();
-		StringBuilder sb = null;
-		if (VerbosityOption.getValue()>1)
-			sb=new StringBuilder();
-
-		for (int i = 0; i < this.ensemble.length; i++) {
-			// transformInstance method visibility changed from private to protected in RandomRules
-			ErrorWeightedVoteMultiLabel v = ((AMRulesMultiLabelLearner) this.ensemble[i]).getVotes(inst);
-			if (VerbosityOption.getValue()>1)
-				sb.append(v.getPrediction() + ", " + " E: " + v.getWeightedError() + " ");
-			/*if (!this.isRegression){
-					v.normalize();
-			}*/
-			Prediction p=v.getPrediction();
-			if(p!=null){
-				if(this.votingTypeOption.getChosenIndex()==0){//Overall error estimation
-					combinedVote.addVote(p,errorMeasurer[i].getCurrentErrors());
-				}
-				else //Error estimation over the rules that cover the example
-					combinedVote.addVote(p, v.getOutputAttributesErrors());
-			}
-		}
-		vote=combinedVote.computeWeightedVote();
-		if (VerbosityOption.getValue()>1){
-			sb.append(vote  + ", ").append(inst.classValue()); 
-			System.out.println(sb.toString());
-		}
-		return vote; 
-	}
-
-
-	@Override
-	protected Measurement[] getModelMeasurementsImpl() {
-		//Measurement [] baseLearnerMeasurements=((AMRulesMultiLabelLearner) getPreparedClassOption(this.baseLearnerOption)).getModelMeasurements();
-		Measurement [] baseLearnerMeasurements=ensemble[0].getModelMeasurements();
-		int nMeasurements=baseLearnerMeasurements.length;
-
-		int numMeasurements;
-		if(featureRanking instanceof NoFeatureRanking)
-			numMeasurements=nMeasurements+1;
-		else
-			numMeasurements=nMeasurements+nAttributes+1;
-			
-		
-		Measurement [] m=new Measurement[numMeasurements];
-		
-		int ensembleSize=0;
-		if(this.ensemble !=null){	
-			ensembleSize=this.ensemble.length;
-			for(int i=0; i<nMeasurements; i++){
-				double value=0;
-				for (int j=0; j<ensembleSize; ++j){
-					Measurement [] measurements=ensemble[j].getModelMeasurements();
-					value+=measurements[i].getValue();
-				}
-				m[i+1]= new Measurement("Avg " + baseLearnerMeasurements[i].getName(), value/ensembleSize);
-			}
-		}
-		else{
-			for(int i=0; i<baseLearnerMeasurements.length; i++)
-				m[i+1]=baseLearnerMeasurements[i];
-		}
-	
-		m[0]=new Measurement("ensemble size", ensembleSize);
-		
-		//add feature importance is a method was selected
-		if(!(featureRanking instanceof NoFeatureRanking)){
-			DoubleVector rankings=this.featureRanking.getFeatureRankings();
-			for(int i=0; i<nAttributes;i++){
-				double importance=0;
-				if(rankings!=null)
-					importance=rankings.getValue(i);
-				m[i+nMeasurements+1]=new Measurement("Attribute" + i, importance);
-			}
-		}
-		return m;
-	}
-
-	@Override
-	public void getModelDescription(StringBuilder out, int indent) {
-		// TODO Auto-generated method stub
-
-	}
-
-	@Override
-	public boolean isRandomizable() {
-		return true;
-	}
-	}
diff --git a/moa/src/main/java/moa/classifiers/trees/ARFFIMTDD.java b/moa/src/main/java/moa/classifiers/trees/ARFFIMTDD.java
deleted file mode 100644
index 18d6a4b3d..000000000
--- a/moa/src/main/java/moa/classifiers/trees/ARFFIMTDD.java
+++ /dev/null
@@ -1,1010 +0,0 @@
-/*
- *    ARFFIMTDD.java
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *
- */
-
-package moa.classifiers.trees;
-
-import java.io.Serializable;
-import java.util.Arrays;
-import java.util.LinkedList;
-import java.util.List;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-
-import moa.options.ClassOption;
-import moa.AbstractMOAObject;
-import moa.classifiers.Regressor;
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
-import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.classifiers.AbstractClassifier;
-import moa.core.AutoExpandVector;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.core.SizeOf;
-import moa.core.StringUtils;
-
-/**
- * Implementation of ARFFIMTDD, an extension of ARFFIMTDD to be used by AdaptiveRandomForestRegressor.
- *
- * <p>See details in:<br> Heitor Murilo Gomes, Jean Paul Barddal, Luis Eduardo Boiko Ferreira, Albert Bifet.
- * Adaptive random forests for data stream regression.
- * In European Symposium on Artificial Neural Networks, Computational Intelligence and Machine Learning (ESANN), 2018.
- * https://www.elen.ucl.ac.be/Proceedings/esann/esannpdf/es2018-183.pdf</p>
- */
-public class ARFFIMTDD extends AbstractClassifier implements Regressor {
-
-    private static final long serialVersionUID = 1L;
-
-    protected Node treeRoot;
-
-    protected int leafNodeCount = 0;
-    protected int splitNodeCount = 0;
-
-    protected double examplesSeen = 0.0;
-    protected double sumOfValues = 0.0;
-    protected double sumOfSquares = 0.0;
-
-    protected DoubleVector sumOfAttrValues = new DoubleVector();
-    protected DoubleVector sumOfAttrSquares = new DoubleVector();
-
-    public int maxID = 0;
-
-    public IntOption subspaceSizeOption = new IntOption("subspaceSizeSize", 'k',
-            "Number of features per subset for each node split. Negative values = #features - k",
-            2, Integer.MIN_VALUE, Integer.MAX_VALUE);
-
-    //region ================ OPTIONS ================
-
-    public ClassOption splitCriterionOption = new ClassOption(
-            "splitCriterion", 's', "Split criterion to use.",
-            SplitCriterion.class, "moa.classifiers.core.splitcriteria.VarianceReductionSplitCriterion");
-
-    public IntOption gracePeriodOption = new IntOption(
-            "gracePeriod", 'g', "Number of instances a leaf should observe between split attempts.",
-            200, 0, Integer.MAX_VALUE);
-
-    public FloatOption splitConfidenceOption = new FloatOption(
-            "splitConfidence", 'c', "Allowed error in split decision, values close to 0 will take long to decide.",
-            0.0000001, 0.0, 1.0);
-
-    public FloatOption tieThresholdOption = new FloatOption(
-            "tieThreshold", 't', "Threshold below which a split will be forced to break ties.",
-            0.05, 0.0, 1.0);
-
-    public FloatOption PageHinckleyAlphaOption = new FloatOption(
-            "PageHinckleyAlpha", 'a', "Alpha value to use in the Page Hinckley change detection tests.",
-            0.005, 0.0, 1.0);
-
-    public IntOption PageHinckleyThresholdOption = new IntOption(
-            "PageHinckleyThreshold", 'h', "Threshold value used in the Page Hinckley change detection tests.",
-            50, 0, Integer.MAX_VALUE);
-
-    public FloatOption alternateTreeFadingFactorOption = new FloatOption(
-            "alternateTreeFadingFactor", 'f', "Fading factor used to decide if an alternate tree should replace an original.",
-            0.995, 0.0, 1.0);
-
-    public IntOption alternateTreeTMinOption = new IntOption(
-            "alternateTreeTMin", 'y', "Tmin value used to decide if an alternate tree should replace an original.",
-            150, 0, Integer.MAX_VALUE);
-
-    public IntOption alternateTreeTimeOption = new IntOption(
-            "alternateTreeTime", 'u', "The number of instances used to decide if an alternate tree should be discarded.",
-            1500, 0, Integer.MAX_VALUE);
-
-    public FlagOption regressionTreeOption = new FlagOption(
-            "regressionTree", 'e', "Build a regression tree instead of a model tree.");
-
-    public FloatOption learningRatioOption = new FloatOption(
-            "learningRatio", 'l', "Learning ratio to used for training the Perceptrons in the leaves.",
-            0.02, 0, 1.00);
-
-    public FloatOption learningRateDecayFactorOption = new FloatOption(
-            "learningRatioDecayFactor", 'd', "Learning rate decay factor (not used when learning rate is constant).",
-            0.001, 0, 1.00);
-
-    public FlagOption learningRatioConstOption = new FlagOption(
-            "learningRatioConst", 'p', "Keep learning rate constant instead of decaying.");
-
-    //endregion ================ OPTIONS ================
-
-    //region ================ CLASSES ================
-
-    public abstract static class Node extends AbstractMOAObject {
-
-        private static final long serialVersionUID = 1L;
-
-        public int ID;
-
-        protected ARFFIMTDD tree;
-
-        protected boolean changeDetection = true;
-
-        protected Node parent;
-
-        protected Node alternateTree;
-        protected Node originalNode;
-
-        // The statistics for this node:
-        // Number of instances that have reached it
-        protected double examplesSeen;
-        // Sum of y values
-        protected double sumOfValues;
-        // Sum of squared y values
-        protected double sumOfSquares;
-        // Sum of absolute errors
-        protected double sumOfAbsErrors; // Needed for PH tracking of mean error
-
-        public Node(ARFFIMTDD tree) {
-            this.tree = tree;
-            ID = tree.maxID;
-        }
-
-        public void copyStatistics(Node node) {
-            examplesSeen = node.examplesSeen;
-            sumOfValues = node.sumOfValues;
-            sumOfSquares = node.sumOfSquares;
-            sumOfAbsErrors = node.sumOfAbsErrors;
-        }
-
-        public int calcByteSize() {
-            return (int) SizeOf.fullSizeOf(this);
-        }
-
-        /**
-         * Set the parent node
-         */
-        public void setParent(Node parent) {
-            this.parent = parent;
-        }
-
-        /**
-         * Return the parent node
-         */
-        public Node getParent() {
-            return parent;
-        }
-
-        public void disableChangeDetection() {
-            changeDetection = false;
-        }
-
-        public void restartChangeDetection() {
-            changeDetection = true;
-        }
-
-        public void getDescription(StringBuilder sb, int indent) {
-
-        }
-
-        public double getPrediction(Instance inst) {
-            return 0;
-        }
-
-        public void describeSubtree(StringBuilder out, int indent) {
-            StringUtils.appendIndented(out, indent, "Leaf");
-        }
-
-        public int getLevel() {
-            Node target = this;
-            int level = 0;
-            while (target.getParent() != null) {
-                if (target.skipInLevelCount()) {
-                    target = target.getParent();
-                    continue;
-                }
-                level = level + 1;
-                target = target.getParent();
-            }
-            if (target.originalNode == null) {
-                return level;
-            } else {
-                return level + originalNode.getLevel();
-            }
-        }
-
-        public void setChild(int parentBranch, Node node) {
-        }
-
-        public int getChildIndex(Node child) {
-            return -1;
-        }
-
-        public int getNumSubtrees() {
-            return 1;
-        }
-
-        protected boolean skipInLevelCount() {
-            return false;
-        }
-    }
-
-    public static class LeafNode extends Node {
-
-        private static final long serialVersionUID = 1L;
-
-        // Perceptron model that carries out the actual learning in each node
-        public FIMTDDPerceptron learningModel;
-
-        protected AutoExpandVector<FIMTDDNumericAttributeClassObserver> attributeObservers = new AutoExpandVector<FIMTDDNumericAttributeClassObserver>();
-
-        protected double examplesSeenAtLastSplitEvaluation = 0;
-
-        protected int[] listAttributes;
-
-        protected int numAttributes;
-
-
-        /**
-         * Create a new LeafNode
-         */
-        public LeafNode(ARFFIMTDD tree, int subspaceSize) {
-            super(tree);
-            if (tree.buildingModelTree()) {
-                learningModel = tree.newLeafModel();
-            }
-            examplesSeen = 0;
-            sumOfValues = 0;
-            sumOfSquares = 0;
-            sumOfAbsErrors = 0;
-
-            this.numAttributes = subspaceSize;
-        }
-
-        public void setChild(int parentBranch, Node node) {
-        }
-
-        public int getChildIndex(Node child) {
-            return -1;
-        }
-
-        public int getNumSubtrees() {
-            return 1;
-        }
-
-        protected boolean skipInLevelCount() {
-            return false;
-        }
-
-        /**
-         * Method to learn from an instance that passes the new instance to the perceptron learner,
-         * and also prevents the class value from being truncated to an int when it is passed to the
-         * attribute observer
-         */
-        public void learnFromInstance(Instance inst, boolean growthAllowed, ARFFIMTDD arffimtdd) {
-            //The prediction must be calculated here -- it may be different from the tree's prediction due to alternate trees
-
-            // Update the statistics for this node
-            // number of instances passing through the node
-            examplesSeen += inst.weight();
-
-            // sum of y values
-            sumOfValues += inst.weight() * inst.classValue();
-
-            // sum of squared y values
-            sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
-
-            // sum of absolute errors
-            sumOfAbsErrors += inst.weight() * Math.abs(tree.normalizeTargetValue(Math.abs(inst.classValue() - getPrediction(inst))));
-
-            if (tree.buildingModelTree()) learningModel.updatePerceptron(inst);
-
-            if (this.listAttributes == null) {
-                this.listAttributes = new int[this.numAttributes];
-                for (int j = 0; j < this.numAttributes; j++) {
-                    boolean isUnique = false;
-                    while (isUnique == false) {
-                        this.listAttributes[j] = arffimtdd.classifierRandom.nextInt(inst.numAttributes() - 1);
-                        isUnique = true;
-                        for (int i = 0; i < j; i++) {
-                            if (this.listAttributes[j] == this.listAttributes[i]) {
-                                isUnique = false;
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-
-//                        for (int j = 0; j < this.numAttributes - 1; j++) {
-//                            int i = this.listAttributes[j];
-//                            int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
-//                            AttributeClassObserver obs = this.attributeObservers.get(i);
-//                            if (obs == null) {
-//                                obs = inst.attribute(instAttIndex).isNominal() ? ht.newNominalClassObserver() : ht.newNumericClassObserver();
-//                                this.attributeObservers.set(i, obs);
-//                            }
-//                            obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
-//                        }
-
-            for (int j = 0; j < this.listAttributes.length ; j++) {
-                int i = this.listAttributes[j];
-                int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
-                FIMTDDNumericAttributeClassObserver obs = attributeObservers.get(i);
-                if (obs == null) {
-                    // At this stage all nominal attributes are ignored
-                    if (inst.attribute(instAttIndex).isNumeric()) {
-                        obs = tree.newNumericClassObserver();
-                        this.attributeObservers.set(i, obs);
-                    }
-                }
-                if (obs != null) {
-                    obs.observeAttributeClass(inst.value(instAttIndex), inst.classValue(), inst.weight());
-                }
-            }
-
-            if (growthAllowed) {
-                checkForSplit(tree);
-            }
-        }
-
-        /**
-         * Return the best split suggestions for this node using the given split criteria
-         */
-        public AttributeSplitSuggestion[] getBestSplitSuggestions(SplitCriterion criterion) {
-
-            List<AttributeSplitSuggestion> bestSuggestions = new LinkedList<AttributeSplitSuggestion>();
-
-            // Set the nodeStatistics up as the preSplitDistribution, rather than the observedClassDistribution
-            double[] nodeSplitDist = new double[] {examplesSeen, sumOfValues, sumOfSquares};
-
-            for (int i = 0; i < this.attributeObservers.size(); i++) {
-                FIMTDDNumericAttributeClassObserver obs = this.attributeObservers.get(i);
-                if (obs != null) {
-
-                    // AT THIS STAGE NON-NUMERIC ATTRIBUTES ARE IGNORED
-                    AttributeSplitSuggestion bestSuggestion = null;
-                    if (obs instanceof FIMTDDNumericAttributeClassObserver) {
-                        bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion, nodeSplitDist, i, true);
-                    }
-
-                    if (bestSuggestion != null) {
-                        bestSuggestions.add(bestSuggestion);
-                    }
-                }
-            }
-            return bestSuggestions.toArray(new AttributeSplitSuggestion[bestSuggestions.size()]);
-        }
-
-        /**
-         * Retrieve the class votes using the perceptron learner
-         */
-        public double getPredictionModel(Instance inst) {
-            return learningModel.prediction(inst);
-        }
-
-        public double getPredictionTargetMean(Instance inst) {
-            return (examplesSeen > 0.0) ? sumOfValues / examplesSeen : 0.0;
-        }
-
-        public double getPrediction(Instance inst) {
-            return (tree.buildingModelTree()) ? getPredictionModel(inst) : getPredictionTargetMean(inst);
-        }
-
-        public void checkForSplit(ARFFIMTDD tree) {
-            // If it has seen Nmin examples since it was last tested for splitting, attempt a split of this node
-            if (examplesSeen - examplesSeenAtLastSplitEvaluation >= tree.gracePeriodOption.getValue()) {
-                int index = (parent != null) ? parent.getChildIndex(this) : 0;
-                tree.attemptToSplit(this, parent, index);
-
-                // Take note of how many instances were seen when this split evaluation was made, so we know when to perform the next split evaluation
-                examplesSeenAtLastSplitEvaluation = examplesSeen;
-            }
-        }
-
-        public void describeSubtree(StringBuilder out, int indent) {
-            StringUtils.appendIndented(out, indent, "Leaf ");
-            if (tree.buildingModelTree()) {
-                learningModel.getModelDescription(out, 0);
-            } else {
-                out.append(tree.getClassNameString() + " = " + String.format("%.4f", (sumOfValues / examplesSeen)));
-                StringUtils.appendNewline(out);
-            }
-        }
-    }
-
-    public abstract static class InnerNode extends Node {
-        // The InnerNode and SplitNode design is used for easy extension in ORTO
-        private static final long serialVersionUID = 1L;
-
-        protected AutoExpandVector<Node> children = new AutoExpandVector<Node>();
-
-        // The error values for the Page Hinckley test
-        // PHmT = the cumulative sum of the errors
-        // PHMT = the minimum error value seen so far
-        protected double PHsum = 0;
-        protected double PHmin = Double.MAX_VALUE;
-
-        // Keep track of the statistics for loss error calculations
-        protected double lossExamplesSeen;
-        protected double lossFadedSumOriginal;
-        protected double lossFadedSumAlternate;
-        protected double lossNumQiTests;
-        protected double lossSumQi;
-        protected double previousWeight = 0;
-
-        public InnerNode(ARFFIMTDD tree) {
-            super(tree);
-        }
-
-        public int numChildren() {
-            return children.size();
-        }
-
-        public Node getChild(int index) {
-            return children.get(index);
-        }
-
-        public int getChildIndex(Node child) {
-            return children.indexOf(child);
-        }
-
-        public void setChild(int index, Node child) {
-            children.set(index, child);
-        }
-
-        public void disableChangeDetection() {
-            changeDetection = false;
-            for (Node child : children) {
-                child.disableChangeDetection();
-            }
-        }
-
-        public void restartChangeDetection() {
-            if (alternateTree == null) {
-                changeDetection = true;
-                PHsum = 0;
-                PHmin = Integer.MAX_VALUE;
-                for (Node child : children)
-                    child.restartChangeDetection();
-            }
-        }
-
-        /**
-         * Check to see if the tree needs updating
-         */
-        public boolean PageHinckleyTest(double error, double threshold) {
-            // Update the cumulative mT sum
-            PHsum += error;
-
-            // Update the minimum mT value if the new mT is
-            // smaller than the current minimum
-            if(PHsum < PHmin) {
-                PHmin = PHsum;
-            }
-            // Return true if the cumulative value - the current minimum is
-            // greater than the current threshold (in which case we should adapt)
-            return PHsum - PHmin > threshold;
-        }
-
-        public void initializeAlternateTree() {
-            // Start a new alternate tree, beginning with a learning node
-            alternateTree = tree.newLeafNode();
-            alternateTree.originalNode = this;
-
-            // Set up the blank statistics
-            // Number of instances reaching this node since the alternate tree was started
-            lossExamplesSeen = 0;
-            // Faded squared error (original tree)
-            lossFadedSumOriginal = 0;
-            // Faded squared error (alternate tree)
-            lossFadedSumAlternate = 0;
-            // Number of evaluations of alternate tree
-            lossNumQiTests = 0;
-            // Sum of Qi values
-            lossSumQi = 0;
-            // Number of examples at last test
-            previousWeight = 0;
-
-            // Disable the change detection mechanism bellow this node
-            disableChangeDetection();
-        }
-    }
-
-    public static class SplitNode extends InnerNode {
-
-        private static final long serialVersionUID = 1L;
-
-        protected InstanceConditionalTest splitTest;
-
-        /**
-         * Create a new SplitNode
-         * @param tree
-         */
-        public SplitNode(InstanceConditionalTest splitTest, ARFFIMTDD tree) {
-            super(tree);
-            this.splitTest = splitTest;
-        }
-
-        public int instanceChildIndex(Instance inst) {
-            return splitTest.branchForInstance(inst);
-        }
-
-        public Node descendOneStep(Instance inst) {
-            return children.get(splitTest.branchForInstance(inst));
-        }
-
-        public void describeSubtree(StringBuilder out, int indent) {
-            for (int branch = 0; branch < children.size(); branch++) {
-                Node child = getChild(branch);
-                if (child != null) {
-                    StringUtils.appendIndented(out, indent, "if ");
-                    out.append(this.splitTest.describeConditionForBranch(branch,
-                            tree.getModelContext()));
-                    out.append(": ");
-                    StringUtils.appendNewline(out);
-                    child.describeSubtree(out, indent + 2);
-                }
-            }
-        }
-
-        public double getPrediction(Instance inst) {
-            return children.get(splitTest.branchForInstance(inst)).getPrediction(inst);
-        }
-    }
-
-    public class FIMTDDPerceptron implements Serializable {
-
-        private static final long serialVersionUID = 1L;
-
-        protected ARFFIMTDD tree;
-
-        // The Perception weights
-        protected DoubleVector weightAttribute = new DoubleVector();
-
-        protected double sumOfValues;
-        protected double sumOfSquares;
-
-        // The number of instances contributing to this model
-        protected double instancesSeen = 0;
-
-        // If the model should be reset or not
-        protected boolean reset;
-
-        public String getPurposeString() {
-            return "A perceptron regressor as specified by Ikonomovska et al. used for FIMTDD";
-        }
-
-        public FIMTDDPerceptron(FIMTDDPerceptron original) {
-            this.tree = original.tree;
-            weightAttribute = (DoubleVector) original.weightAttribute.copy();
-            reset = false;
-        }
-
-        public FIMTDDPerceptron(ARFFIMTDD tree) {
-            this.tree = tree;
-            reset = true;
-        }
-
-
-        public DoubleVector getWeights() {
-            return weightAttribute;
-        }
-
-        /**
-         * Update the model using the provided instance
-         */
-        public void updatePerceptron(Instance inst) {
-
-            // Initialize perceptron if necessary
-            if (reset == true) {
-                reset = false;
-                weightAttribute = new DoubleVector();
-                instancesSeen = 0;
-                for (int j = 0; j < inst.numAttributes(); j++) { // The last index corresponds to the constant b
-                    weightAttribute.setValue(j, 2 * tree.classifierRandom.nextDouble() - 1);
-                }
-            }
-
-            // Update attribute statistics
-            instancesSeen += inst.weight();
-
-            // Update weights
-            double learningRatio = 0.0;
-            if (tree.learningRatioConstOption.isSet()) {
-                learningRatio = learningRatioOption.getValue();
-            } else {
-                learningRatio = learningRatioOption.getValue() / (1 + instancesSeen * tree.learningRateDecayFactorOption.getValue());
-            }
-
-            sumOfValues += inst.weight() * inst.classValue();
-            sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
-
-            // Loop for compatibility with bagging methods
-            for (int i = 0; i < (int) inst.weight(); i++) {
-                updateWeights(inst, learningRatio);
-            }
-        }
-
-        public void updateWeights(Instance inst, double learningRatio) {
-            // Compute the normalized instance and the delta
-            DoubleVector normalizedInstance = normalizedInstance(inst);
-            double normalizedPrediction = prediction(normalizedInstance);
-            double normalizedValue = tree.normalizeTargetValue(inst.classValue());
-            double delta = normalizedValue - normalizedPrediction;
-            normalizedInstance.scaleValues(delta * learningRatio);
-
-            weightAttribute.addValues(normalizedInstance);
-        }
-
-        public DoubleVector normalizedInstance(Instance inst) {
-            // Normalize Instance
-            DoubleVector normalizedInstance = new DoubleVector();
-            for (int j = 0; j < inst.numAttributes() - 1; j++) {
-                int instAttIndex = modelAttIndexToInstanceAttIndex(j, inst);
-                double mean = tree.sumOfAttrValues.getValue(j) / tree.examplesSeen;
-                double sd = computeSD(tree.sumOfAttrSquares.getValue(j), tree.sumOfAttrValues.getValue(j), tree.examplesSeen);
-                if (inst.attribute(instAttIndex).isNumeric() && tree.examplesSeen > 1 && sd > 0)
-                    normalizedInstance.setValue(j, (inst.value(instAttIndex) - mean) / (3 * sd));
-                else
-                    normalizedInstance.setValue(j, 0);
-            }
-            if (tree.examplesSeen > 1)
-                normalizedInstance.setValue(inst.numAttributes() - 1, 1.0); // Value to be multiplied with the constant factor
-            else
-                normalizedInstance.setValue(inst.numAttributes() - 1, 0.0);
-            return normalizedInstance;
-        }
-
-        /**
-         * Output the prediction made by this perceptron on the given instance
-         */
-        public double prediction(DoubleVector instanceValues) {
-            return scalarProduct(weightAttribute, instanceValues);
-        }
-
-        protected double prediction(Instance inst) {
-            DoubleVector normalizedInstance = normalizedInstance(inst);
-            double normalizedPrediction = prediction(normalizedInstance);
-            return denormalizePrediction(normalizedPrediction, tree);
-        }
-
-        private double denormalizePrediction(double normalizedPrediction, ARFFIMTDD tree) {
-            double mean = tree.sumOfValues / tree.examplesSeen;
-            double sd = computeSD(tree.sumOfSquares, tree.sumOfValues, tree.examplesSeen);
-            if (examplesSeen > 1)
-                return normalizedPrediction * sd * 3 + mean;
-            else
-                return 0.0;
-        }
-
-        public void getModelDescription(StringBuilder out, int indent) {
-            StringUtils.appendIndented(out, indent, getClassNameString() + " =");
-            if (getModelContext() != null) {
-                for (int j = 0; j < getModelContext().numAttributes() - 1; j++) {
-                    if (getModelContext().attribute(j).isNumeric()) {
-                        out.append((j == 0 || weightAttribute.getValue(j) < 0) ? " " : " + ");
-                        out.append(String.format("%.4f", weightAttribute.getValue(j)));
-                        out.append(" * ");
-                        out.append(getAttributeNameString(j));
-                    }
-                }
-                out.append(" + " + weightAttribute.getValue((getModelContext().numAttributes() - 1)));
-            }
-            StringUtils.appendNewline(out);
-        }
-    }
-
-
-    //endregion ================ CLASSES ================
-
-    //region ================ METHODS ================
-
-    // region --- Regressor methods
-
-    public String getPurposeString() {
-        return "Implementation of the FIMT-DD tree as described by Ikonomovska et al.";
-    }
-
-    public void resetLearningImpl() {
-        this.treeRoot = null;
-        this.leafNodeCount = 0;
-        this.splitNodeCount = 0;
-        this.maxID = 0;
-        this.examplesSeen = 0;
-        this.sumOfValues = 0.0;
-        this.sumOfSquares = 0.0;
-
-        this.sumOfAttrValues = new DoubleVector();
-        this.sumOfAttrSquares = new DoubleVector();
-    }
-
-    public boolean isRandomizable() {
-        return true;
-    }
-
-    public void getModelDescription(StringBuilder out, int indent) {
-        if (treeRoot != null) treeRoot.describeSubtree(out, indent);
-    }
-
-    protected Measurement[] getModelMeasurementsImpl() {
-        return new Measurement[]{
-                new Measurement("tree size (leaves)", this.leafNodeCount)
-        };
-    }
-
-    public int calcByteSize() {
-        return (int) SizeOf.fullSizeOf(this);
-    }
-
-    public double[] getVotesForInstance(Instance inst) {
-        if (treeRoot == null) {
-            return new double[] {0};
-        }
-
-        double prediction = treeRoot.getPrediction(inst);
-
-
-        return new double[] {prediction};
-    }
-
-    public double normalizeTargetValue(double value) {
-        if (examplesSeen > 1) {
-            double sd = Math.sqrt((sumOfSquares - ((sumOfValues * sumOfValues)/examplesSeen))/examplesSeen);
-            double average = sumOfValues / examplesSeen;
-            if (sd > 0 && examplesSeen > 1)
-                return (value - average) / (3 * sd);
-            else
-                return 0.0;
-        }
-        return 0.0;
-    }
-
-    public double getNormalizedError(Instance inst, double prediction) {
-        double normalPrediction = normalizeTargetValue(prediction);
-        double normalValue = normalizeTargetValue(inst.classValue());
-        return Math.abs(normalValue - normalPrediction);
-    }
-
-
-    /**
-     * Method for updating (training) the model using a new instance
-     */
-    public void trainOnInstanceImpl(Instance inst) {
-        checkRoot();
-
-        examplesSeen += inst.weight();
-        sumOfValues += inst.weight() * inst.classValue();
-        sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
-
-        for (int i = 0; i < inst.numAttributes() - 1; i++) {
-            int aIndex = modelAttIndexToInstanceAttIndex(i, inst);
-            sumOfAttrValues.addToValue(i, inst.weight() * inst.value(aIndex));
-            sumOfAttrSquares.addToValue(i, inst.weight() * inst.value(aIndex) * inst.value(aIndex));
-        }
-
-        double prediction = treeRoot.getPrediction(inst);
-        processInstance(inst, treeRoot, prediction, getNormalizedError(inst, prediction), true, false);
-    }
-
-    public void processInstance(Instance inst, Node node, double prediction, double normalError, boolean growthAllowed, boolean inAlternate) {
-        Node currentNode = node;
-        while (true) {
-            if (currentNode instanceof LeafNode) {
-                ((LeafNode) currentNode).learnFromInstance(inst, growthAllowed, this);
-                break;
-            } else {
-                currentNode.examplesSeen += inst.weight();
-                currentNode.sumOfAbsErrors += inst.weight() * normalError;
-                SplitNode iNode = (SplitNode) currentNode;
-                if (!inAlternate && iNode.alternateTree != null) {
-                    boolean altTree = true;
-                    double lossO = Math.pow(inst.classValue() - prediction, 2);
-                    double lossA = Math.pow(inst.classValue() - iNode.alternateTree.getPrediction(inst), 2);
-
-                    // Loop for compatibility with bagging methods
-                    for (int i = 0; i < inst.weight(); i++) {
-                        iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
-                        iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
-                        iNode.lossExamplesSeen++;
-
-                        double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
-                        iNode.lossSumQi += Qi;
-                        iNode.lossNumQiTests += 1;
-                    }
-                    double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
-                    double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
-                    double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
-
-                    if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
-                        iNode.previousWeight = iNode.lossExamplesSeen;
-                        if (Qi > 0) {
-                            // Switch the subtrees
-                            Node parent = currentNode.getParent();
-
-                            if (parent != null) {
-                                Node replacementTree = iNode.alternateTree;
-                                parent.setChild(parent.getChildIndex(currentNode), replacementTree);
-                                if (growthAllowed) replacementTree.restartChangeDetection();
-                            } else {
-                                treeRoot = iNode.alternateTree;
-                                treeRoot.restartChangeDetection();
-                            }
-
-                            currentNode = iNode.alternateTree;
-                            currentNode.originalNode = null;
-                            altTree = false;
-                        } else if (
-                                (QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * this.gracePeriodOption.getValue()))
-                                        || iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()
-                        ) {
-                            // Remove the alternate tree
-                            iNode.alternateTree = null;
-                            if (growthAllowed) iNode.restartChangeDetection();
-                            altTree = false;
-                        }
-                    }
-
-                    if (altTree) {
-                        growthAllowed = false;
-                        processInstance(inst, iNode.alternateTree, prediction, normalError, true, true);
-                    }
-                }
-
-                if (iNode.changeDetection && !inAlternate) {
-                    if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
-                        iNode.initializeAlternateTree();
-                    }
-                }
-                if (currentNode instanceof SplitNode) {
-                    currentNode = ((SplitNode) currentNode).descendOneStep(inst);
-                }
-            }
-        }
-    }
-
-    // endregion --- Regressor methods
-
-    // region --- Object instatiation methods
-
-    protected FIMTDDNumericAttributeClassObserver newNumericClassObserver() {
-        return new FIMTDDNumericAttributeClassObserver();
-    }
-
-    protected SplitNode newSplitNode(InstanceConditionalTest splitTest) {
-        maxID++;
-        return new SplitNode(splitTest, this);
-    }
-
-    protected LeafNode newLeafNode() {
-        maxID++;
-        return new LeafNode(this, this.subspaceSizeOption.getValue());
-    }
-
-    protected FIMTDDPerceptron newLeafModel() {
-        return new FIMTDDPerceptron(this);
-    }
-
-    //endregion --- Object instatiation methods
-
-    // region --- Processing methods
-
-    protected void checkRoot() {
-        if (treeRoot == null) {
-            treeRoot = newLeafNode();
-            leafNodeCount = 1;
-        }
-    }
-
-    public static double computeHoeffdingBound(double range, double confidence, double n) {
-        return Math.sqrt(( (range * range) * Math.log(1 / confidence)) / (2.0 * n));
-    }
-
-    public boolean buildingModelTree() {
-        return !regressionTreeOption.isSet();
-    }
-
-    protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
-        // Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al.
-        SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
-
-        // Using this criterion, find the best split per attribute and rank the results
-        AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion);
-        Arrays.sort(bestSplitSuggestions);
-
-        // Declare a variable to determine if any of the splits should be performed
-        boolean shouldSplit = false;
-
-        // If only one split was returned, use it
-        if (bestSplitSuggestions.length < 2) {
-            shouldSplit = bestSplitSuggestions.length > 0;
-        } else { // Otherwise, consider which of the splits proposed may be worth trying
-
-            // Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
-            // to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
-            double hoeffdingBound = computeHoeffdingBound(1, this.splitConfidenceOption.getValue(), node.examplesSeen);
-            // Determine the top two ranked splitting suggestions
-            AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-            AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
-
-            // If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
-            // as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
-            // particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
-            // splitting should occur.
-            // Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
-            // (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
-            // competing attributes are equally good, and the split will be made on the one with the higher SDR value.
-            if ((secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) || (hoeffdingBound < this.tieThresholdOption.getValue())) {
-                shouldSplit = true;
-            }
-            // If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
-            else {
-                for (int i = 0; i < node.attributeObservers.size(); i++) {
-                    FIMTDDNumericAttributeClassObserver obs = node.attributeObservers.get(i);
-                    if (obs != null) {
-                        obs.removeBadSplits(splitCriterion, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound);
-                    }
-                }
-            }
-        }
-
-        // If the splitting criterion were met, split the current node using the chosen attribute test, and
-        // make two new branches leading to (empty) leaves
-        if (shouldSplit) {
-            AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-
-            SplitNode newSplit = newSplitNode(splitDecision.splitTest);
-            newSplit.copyStatistics(node);
-            newSplit.changeDetection = node.changeDetection;
-            newSplit.ID = node.ID;
-            leafNodeCount--;
-            for (int i = 0; i < splitDecision.numSplits(); i++) {
-                LeafNode newChild = newLeafNode();
-                if (buildingModelTree()) {
-                    // Copy the splitting node's perceptron to it's children
-                    newChild.learningModel = new FIMTDDPerceptron((FIMTDDPerceptron) node.learningModel);
-
-                }
-                newChild.changeDetection = node.changeDetection;
-                newChild.setParent(newSplit);
-                newSplit.setChild(i, newChild);
-                leafNodeCount++;
-            }
-            if (parent == null && node.originalNode == null) {
-                treeRoot = newSplit;
-            } else if (parent == null && node.originalNode != null) {
-                node.originalNode.alternateTree = newSplit;
-            } else {
-                ((SplitNode) parent).setChild(parentIndex, newSplit);
-                newSplit.setParent(parent);
-            }
-
-            splitNodeCount++;
-        }
-    }
-
-    public double computeSD(double squaredVal, double val, double size) {
-        if (size > 1)
-            return Math.sqrt((squaredVal - ((val * val) / size)) / size);
-        else
-            return 0.0;
-    }
-
-    public double scalarProduct(DoubleVector u, DoubleVector v) {
-        double ret = 0.0;
-        for (int i = 0; i < Math.max(u.numValues(), v.numValues()); i++) {
-            ret += u.getValue(i) * v.getValue(i);
-        }
-        return ret;
-    }
-    //endregion --- Processing methods
-
-    //endregion ================ METHODS ================
-}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/trees/ARFHoeffdingTree.java b/moa/src/main/java/moa/classifiers/trees/ARFHoeffdingTree.java
deleted file mode 100644
index 0794ac88a..000000000
--- a/moa/src/main/java/moa/classifiers/trees/ARFHoeffdingTree.java
+++ /dev/null
@@ -1,188 +0,0 @@
-/*
- *    ARFHoeffdingTree.java
- * 
- *    @author Heitor Murilo Gomes (heitor_murilo_gomes at yahoo dot com dot br)
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *
- */
-
-package moa.classifiers.trees;
-
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.classifiers.bayes.NaiveBayes;
-import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
-import moa.core.Utils;
-
-/**
- * Adaptive Random Forest Hoeffding Tree.
- * 
- * <p>Adaptive Random Forest Hoeffding Tree. This is the base model for the 
- * Adaptive Random Forest ensemble learner 
- * (See moa.classifiers.meta.AdaptiveRandomForest.java). This Hoeffding Tree
- * includes a subspace size k parameter, which defines the number of randomly 
- * selected features to be considered at each split. </p>
- * 
- * <p>See details in:<br> Heitor Murilo Gomes, Albert Bifet, Jesse Read, 
- * Jean Paul Barddal, Fabricio Enembreck, Bernhard Pfharinger, Geoff Holmes, 
- * Talel Abdessalem. Adaptive random forests for evolving data stream classification. 
- * In Machine Learning, DOI: 10.1007/s10994-017-5642-8, Springer, 2017.</p>
- *
- * @author Heitor Murilo Gomes (heitor_murilo_gomes at yahoo dot com dot br)
- * @version $Revision: 1 $
- */
-public class ARFHoeffdingTree extends HoeffdingTree {
-
-    private static final long serialVersionUID = 1L;
-    
-    public IntOption subspaceSizeOption = new IntOption("subspaceSizeSize", 'k',
-            "Number of features per subset for each node split. Negative values = #features - k", 
-            2, Integer.MIN_VALUE, Integer.MAX_VALUE);
-    
-    @Override
-    public String getPurposeString() {
-        return "Adaptive Random Forest Hoeffding Tree for data streams. "
-                + "Base learner for AdaptiveRandomForest.";
-    }
-
-    public static class RandomLearningNode extends ActiveLearningNode {
-        
-        private static final long serialVersionUID = 1L;
-
-        protected int[] listAttributes;
-
-        protected int numAttributes;
-        
-        public RandomLearningNode(double[] initialClassObservations, int subspaceSize) {
-            super(initialClassObservations);
-            this.numAttributes = subspaceSize;
-        }
-
-        @Override
-        public void learnFromInstance(Instance inst, HoeffdingTree ht) {            
-            this.observedClassDistribution.addToValue((int) inst.classValue(),
-                    inst.weight());
-            if (this.listAttributes == null) {
-                this.listAttributes = new int[this.numAttributes];
-                for (int j = 0; j < this.numAttributes; j++) {
-                    boolean isUnique = false;
-                    while (isUnique == false) {
-                        this.listAttributes[j] = ht.classifierRandom.nextInt(inst.numAttributes() - 1);
-                        isUnique = true;
-                        for (int i = 0; i < j; i++) {
-                            if (this.listAttributes[j] == this.listAttributes[i]) {
-                                isUnique = false;
-                                break;
-                            }
-                        }
-                    }
-
-                }
-            }
-            for (int j = 0; j < this.numAttributes - 1; j++) {
-                int i = this.listAttributes[j];
-                int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
-                AttributeClassObserver obs = this.attributeObservers.get(i);
-                if (obs == null) {
-                    obs = inst.attribute(instAttIndex).isNominal() ? ht.newNominalClassObserver() : ht.newNumericClassObserver();
-                    this.attributeObservers.set(i, obs);
-                }
-                obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
-            }
-        }
-    }
-
-    public static class LearningNodeNB extends RandomLearningNode {
-
-        private static final long serialVersionUID = 1L;
-
-        public LearningNodeNB(double[] initialClassObservations, int subspaceSize) {
-            super(initialClassObservations, subspaceSize);
-        }
-
-        @Override
-        public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
-            if (getWeightSeen() >= ht.nbThresholdOption.getValue()) {
-                return NaiveBayes.doNaiveBayesPrediction(inst,
-                        this.observedClassDistribution,
-                        this.attributeObservers);
-            }
-            return super.getClassVotes(inst, ht);
-        }
-
-        @Override
-        public void disableAttribute(int attIndex) {
-            // should not disable poor atts - they are used in NB calc
-        }
-    }
-
-    public static class LearningNodeNBAdaptive extends LearningNodeNB {
-
-        private static final long serialVersionUID = 1L;
-
-        protected double mcCorrectWeight = 0.0;
-
-        protected double nbCorrectWeight = 0.0;
-
-        public LearningNodeNBAdaptive(double[] initialClassObservations, int subspaceSize) {
-            super(initialClassObservations, subspaceSize);
-        }
-
-        @Override
-        public void learnFromInstance(Instance inst, HoeffdingTree ht) {
-            int trueClass = (int) inst.classValue();
-            if (this.observedClassDistribution.maxIndex() == trueClass) {
-                this.mcCorrectWeight += inst.weight();
-            }
-            if (Utils.maxIndex(NaiveBayes.doNaiveBayesPrediction(inst,
-                    this.observedClassDistribution, this.attributeObservers)) == trueClass) {
-                this.nbCorrectWeight += inst.weight();
-            }
-            super.learnFromInstance(inst, ht);
-        }
-
-        @Override
-        public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
-            if (this.mcCorrectWeight > this.nbCorrectWeight) {
-                return this.observedClassDistribution.getArrayCopy();
-            }
-            return NaiveBayes.doNaiveBayesPrediction(inst,
-                    this.observedClassDistribution, this.attributeObservers);
-        }
-    }
-
-    public ARFHoeffdingTree() {
-        this.removePoorAttsOption = null;
-    }
-    
-    @Override
-    protected LearningNode newLearningNode(double[] initialClassObservations) {
-        LearningNode ret;
-        int predictionOption = this.leafpredictionOption.getChosenIndex();
-        if (predictionOption == 0) { //MC
-            ret = new RandomLearningNode(initialClassObservations, this.subspaceSizeOption.getValue());
-        } else if (predictionOption == 1) { //NB
-            ret = new LearningNodeNB(initialClassObservations, this.subspaceSizeOption.getValue());
-        } else { //NBAdaptive
-            ret = new LearningNodeNBAdaptive(initialClassObservations, this.subspaceSizeOption.getValue());
-        }
-        return ret;
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return true;
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/trees/ASHoeffdingTree.java b/moa/src/main/java/moa/classifiers/trees/ASHoeffdingTree.java
deleted file mode 100644
index 5faf48aa3..000000000
--- a/moa/src/main/java/moa/classifiers/trees/ASHoeffdingTree.java
+++ /dev/null
@@ -1,183 +0,0 @@
-/*
- *    ASHoeffdingTree.java
- *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.trees;
-
-import com.yahoo.labs.samoa.instances.Instance;
-
-/**
- * Adaptive Size Hoeffding Tree used in Bagging using trees of different size.
- * The Adaptive-Size Hoeffding Tree (ASHT) is derived from the Hoeffding Tree
- * algorithm with the following differences:
- * <ul>
- * <li> it has a maximum number of split nodes, or size
- * <li> after one node splits, if the number of split nodes of the ASHT tree
- * is higher than the maximum value, then it deletes some nodes to reduce its size
- * </ul>
- * The intuition behind this method is as follows: smaller trees adapt
- * more quickly to changes, and larger trees do better during periods with
- * no or little change, simply because they were built on more data. Trees
- * limited to size s will be reset about twice as often as trees with a size
- * limit of 2s. This creates a set of different reset-speeds for an ensemble of such
- * trees, and therefore a subset of trees that are a good approximation for the
- * current rate of change. It is important to note that resets will happen all
- * the time, even for stationary datasets, but this behaviour should not have
- * a negative impact on the ensemble’s predictive performance.
- * When the tree size exceeds the maximun size value, there are two different
- * delete options: <ul>
- * <li> delete the oldest node, the root, and all of its children except the one
- * where the split has been made. After that, the root of the child not
- * deleted becomes the new root
- * <li> delete all the nodes of the tree, i.e., restart from a new root.
- * </ul>
- * The maximum allowed size for the n-th ASHT tree is twice the maximum
- * allowed size for the (n-1)-th tree. Moreover, each tree has a weight
- * proportional to the inverse of the square of its error, and it monitors its
- * error with an exponential weighted moving average (EWMA) with alpha = .01.
- * The size of the first tree is 2.
- * <br/><br/>
- * With this new method, it is attempted to improve bagging performance
- * by increasing tree diversity. It has been observed that boosting tends to
- * produce a more diverse set of classifiers than bagging, and this has been
- * cited as a factor in increased performance.<br/>
- * See more details in:<br/><br/>
- * Albert Bifet, Geoff Holmes, Bernhard Pfahringer, Richard Kirkby,
- * and Ricard Gavaldà. New ensemble methods for evolving data
- * streams. In 15th ACM SIGKDD International Conference on Knowledge
- * Discovery and Data Mining, 2009.<br/><br/>
- * The learner must be ASHoeffdingTree, a Hoeffding Tree with a maximum
- * size value.<br/><br/>
- * Example:<br/><br/>
- * <code>OzaBagASHT -l ASHoeffdingTree -s 10 -u -r </code>
- * Parameters:<ul>
- * <li>Same parameters as <code>OzaBag</code>
- * <li>-f : the size of first classifier in the bag.
- * <li>-u : Enable weight classifiers
- * <li>-r : Reset trees when size is higher than the max
- * </ul>
- *
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @version $Revision: 7 $
- */
-public class ASHoeffdingTree extends HoeffdingTree {
-
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public String getPurposeString() {
-        return "Adaptive Size Hoeffding Tree used in Bagging using trees of different size.";
-    }    
-    
-    protected int maxSize = 10000; //EXTENSION TO ASHT
-
-    protected boolean resetTree = false;
-
-    @Override
-    public void resetLearningImpl() {
-        this.treeRoot = null;
-        this.decisionNodeCount = 0;
-        this.activeLeafNodeCount = 0;
-        this.inactiveLeafNodeCount = 0;
-        this.inactiveLeafByteSizeEstimate = 0.0;
-        this.activeLeafByteSizeEstimate = 0.0;
-        this.byteSizeEstimateOverheadFraction = 1.0;
-        this.growthAllowed = true;
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        if (this.treeRoot == null) {
-            this.treeRoot = newLearningNode();
-            this.activeLeafNodeCount = 1;
-        }
-        FoundNode foundNode = this.treeRoot.filterInstanceToLeaf(inst, null, -1);
-        Node leafNode = foundNode.node;
-        if (leafNode == null) {
-            leafNode = newLearningNode();
-            foundNode.parent.setChild(foundNode.parentBranch, leafNode);
-            this.activeLeafNodeCount++;
-        }
-        if (leafNode instanceof LearningNode) {
-            LearningNode learningNode = (LearningNode) leafNode;
-            learningNode.learnFromInstance(inst, this);
-            if (this.growthAllowed
-                    && (learningNode instanceof ActiveLearningNode)) {
-                ActiveLearningNode activeLearningNode = (ActiveLearningNode) learningNode;
-                double weightSeen = activeLearningNode.getWeightSeen();
-                if (weightSeen
-                        - activeLearningNode.getWeightSeenAtLastSplitEvaluation() >= this.gracePeriodOption.getValue()) {
-                    attemptToSplit(activeLearningNode, foundNode.parent,
-                            foundNode.parentBranch);
-                    //EXTENSION TO ASHT
-                    // if size too big, resize tree ONLY Split Nodes
-                    while (this.decisionNodeCount >= this.maxSize && this.treeRoot instanceof SplitNode) {
-                        if (this.resetTree == false) {
-                            resizeTree(this.treeRoot, ((SplitNode) this.treeRoot).instanceChildIndex(inst));
-                            this.treeRoot = ((SplitNode) this.treeRoot).getChild(((SplitNode) this.treeRoot).instanceChildIndex(inst));
-                        } else {
-                            resetLearningImpl();
-                        }
-                    }
-                    activeLearningNode.setWeightSeenAtLastSplitEvaluation(weightSeen);
-                }
-            }
-        }
-        if (this.trainingWeightSeenByModel
-                % this.memoryEstimatePeriodOption.getValue() == 0) {
-            estimateModelByteSizes();
-        }
-    }
-
-    //EXTENSION TO ASHT
-    public void setMaxSize(int mSize) {
-        this.maxSize = mSize;
-    }
-
-    public void setResetTree() {
-        this.resetTree = true;
-    }
-
-    public void deleteNode(Node node, int childIndex) {
-        Node child = ((SplitNode) node).getChild(childIndex);
-        //if (child != null) {
-        //}
-        if (child instanceof SplitNode) {
-            for (int branch = 0; branch < ((SplitNode) child).numChildren(); branch++) {
-                deleteNode(child, branch);
-            }
-            this.decisionNodeCount--;
-        } else if (child instanceof InactiveLearningNode) {
-            this.inactiveLeafNodeCount--;
-        } else if (child instanceof ActiveLearningNode) {
-            this.activeLeafNodeCount--;
-        }
-        child = null;
-    }
-
-    public void resizeTree(Node node, int childIndex) {
-        //Assume that this is root node
-        if (node instanceof SplitNode) {
-            for (int branch = 0; branch < ((SplitNode) node).numChildren(); branch++) {
-                if (branch != childIndex) {
-                    deleteNode(node, branch);
-                }
-            }
-        }
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/trees/AdaHoeffdingOptionTree.java b/moa/src/main/java/moa/classifiers/trees/AdaHoeffdingOptionTree.java
deleted file mode 100644
index 2cefc4f0e..000000000
--- a/moa/src/main/java/moa/classifiers/trees/AdaHoeffdingOptionTree.java
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- *    AdaHoeffdingOptionTree.java
- *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.trees;
-
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.classifiers.bayes.NaiveBayes;
-import moa.core.Utils;
-
-/**
- * Adaptive decision option tree for streaming data with adaptive Naive
- * Bayes classification at leaves.
- * An Adaptive Hoeffding Option Tree is a Hoeffding Option Tree with the
- * following improvement: each leaf stores an estimation of the current error.
- * It uses an EWMA estimator with alpha = .2. The weight of each node in the
- * voting process is proportional to the square of the inverse of the error.
- * <br/><br/>
- * Example:<br/>
- * <code>AdaHoeffdingOptionTree -o 50 </code>
- * Parameters:<ul>
- * <li>Same parameters as <code>HoeffdingOptionTreeNB<code></ul>
- *
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @version $Revision: 7 $
- */
-public class AdaHoeffdingOptionTree extends HoeffdingOptionTree {
-    
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public String getPurposeString() {
-        return "Adaptive decision option tree for streaming data with adaptive Naive Bayes classification at leaves.";
-    }
-     
-    public static class AdaLearningNode extends LearningNodeNB {
-
-        private static final long serialVersionUID = 1L;
-
-        protected double mcCorrectWeight = 0.0;
-
-        protected double nbCorrectWeight = 0.0;
-
-        protected double CorrectWeight = 0.0;
-
-        protected double alpha = 0.2;
-
-        public AdaLearningNode(double[] initialClassObservations) {
-            super(initialClassObservations);
-        }
-
-        @Override
-        public void learnFromInstance(Instance inst, HoeffdingOptionTree hot) {
-            int trueClass = (int) inst.classValue();
-            boolean blCorrect = false;
-            if (this.observedClassDistribution.maxIndex() == trueClass) {
-                this.mcCorrectWeight += inst.weight();
-                if (this.mcCorrectWeight > this.nbCorrectWeight) {
-                    blCorrect = true;
-                }
-            }
-            if (Utils.maxIndex(NaiveBayes.doNaiveBayesPrediction(inst,
-                    this.observedClassDistribution, this.attributeObservers)) == trueClass) {
-                this.nbCorrectWeight += inst.weight();
-                if (this.mcCorrectWeight <= this.nbCorrectWeight) {
-                    blCorrect = true;
-                }
-            }
-            if (blCorrect == true) {
-                this.CorrectWeight += alpha * (1.0 - this.CorrectWeight); //EWMA
-            } else {
-                this.CorrectWeight -= alpha * this.CorrectWeight; //EWMA
-            }
-            super.learnFromInstance(inst, hot);
-        }
-
-        @Override
-        public double[] getClassVotes(Instance inst, HoeffdingOptionTree ht) {
-            double[] dist;
-            if (this.mcCorrectWeight > this.nbCorrectWeight) {
-                dist = this.observedClassDistribution.getArrayCopy();
-            } else {
-                dist = NaiveBayes.doNaiveBayesPrediction(inst,
-                        this.observedClassDistribution, this.attributeObservers);
-            }
-            double distSum = Utils.sum(dist);
-            if (distSum * (1.0 - this.CorrectWeight) * (1.0 - this.CorrectWeight) > 0.0) {
-                Utils.normalize(dist, distSum * (1.0 - this.CorrectWeight) * (1.0 - this.CorrectWeight)); //Adding weight
-            }
-            return dist;
-        }
-    }
-
-    @Override
-    protected LearningNode newLearningNode(double[] initialClassObservations) {
-        return new AdaLearningNode(initialClassObservations);
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/trees/DecisionStump.java b/moa/src/main/java/moa/classifiers/trees/DecisionStump.java
deleted file mode 100644
index a2655f237..000000000
--- a/moa/src/main/java/moa/classifiers/trees/DecisionStump.java
+++ /dev/null
@@ -1,160 +0,0 @@
-/*
- *    DecisionStump.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.trees;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.GaussianNumericAttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.NominalAttributeClassObserver;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.core.AutoExpandVector;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.learners.Classifier;
-import moa.options.ClassOption;
-
-/**
- * Decision trees of one level.<br />
- *
- * Parameters:</p>
- * <ul>
- * <li>-g : The number of instances to observe between model changes</li>
- * <li>-b : Only allow binary splits</li>
- * <li>-c : Split criterion to use. Example : InfoGainSplitCriterion</li>
- * <li>-r : Seed for random behaviour of the classifier</li>
- * </ul>
- * 
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $
- */
-public class DecisionStump extends AbstractClassifier implements Classifier {
-
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public String getPurposeString() {
-        return "Decision trees of one level.";
-    }
-    
-    public IntOption gracePeriodOption = new IntOption("gracePeriod", 'g',
-            "The number of instances to observe between model changes.", 1000,
-            0, Integer.MAX_VALUE);
-
-    public FlagOption binarySplitsOption = new FlagOption("binarySplits", 'b',
-            "Only allow binary splits.");
-
-    public ClassOption splitCriterionOption = new ClassOption("splitCriterion",
-            'c', "Split criterion to use.", SplitCriterion.class,
-            "InfoGainSplitCriterion");
-
-    protected AttributeSplitSuggestion bestSplit;
-
-    protected DoubleVector observedClassDistribution;
-
-    protected AutoExpandVector<AttributeClassObserver> attributeObservers;
-
-    protected double weightSeenAtLastSplit;
-
-    @Override
-    public void resetLearningImpl() {
-        this.bestSplit = null;
-        this.observedClassDistribution = new DoubleVector();
-        this.attributeObservers = new AutoExpandVector<AttributeClassObserver>();
-        this.weightSeenAtLastSplit = 0.0;
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return null;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight());
-        for (int i = 0; i < inst.numAttributes() - 1; i++) {
-            int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
-            AttributeClassObserver obs = this.attributeObservers.get(i);
-            if (obs == null) {
-                obs = inst.attribute(instAttIndex).isNominal() ? newNominalClassObserver()
-                        : newNumericClassObserver();
-                this.attributeObservers.set(i, obs);
-            }
-            obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
-        }
-        if (this.trainingWeightSeenByModel - this.weightSeenAtLastSplit >= this.gracePeriodOption.getValue()) {
-            this.bestSplit = findBestSplit((SplitCriterion) getPreparedClassOption(this.splitCriterionOption));
-            this.weightSeenAtLastSplit = this.trainingWeightSeenByModel;
-        }
-    }
-
-    @Override
-    public Prediction getPredictionForInstance(Instance inst) {
-        if (this.bestSplit != null) {
-            int branch = this.bestSplit.splitTest.branchForInstance(inst);
-            if (branch >= 0) {
-                return new ClassificationPrediction(this.bestSplit.resultingClassDistributionFromSplit(branch));
-            }
-        }
-        return new ClassificationPrediction(observedClassDistribution.getArrayCopy());
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return false;
-    }
-
-    protected AttributeClassObserver newNominalClassObserver() {
-        return new NominalAttributeClassObserver();
-    }
-
-    protected AttributeClassObserver newNumericClassObserver() {
-        return new GaussianNumericAttributeClassObserver();
-    }
-
-    protected AttributeSplitSuggestion findBestSplit(SplitCriterion criterion) {
-        AttributeSplitSuggestion bestFound = null;
-        double bestMerit = Double.NEGATIVE_INFINITY;
-        double[] preSplitDist = this.observedClassDistribution.getArrayCopy();
-        for (int i = 0; i < this.attributeObservers.size(); i++) {
-            AttributeClassObserver obs = this.attributeObservers.get(i);
-            if (obs != null) {
-                AttributeSplitSuggestion suggestion = obs.getBestEvaluatedSplitSuggestion(criterion,
-                        preSplitDist, i, this.binarySplitsOption.isSet());
-                if (suggestion != null && suggestion.merit > bestMerit) {
-                    bestMerit = suggestion.merit;
-                    bestFound = suggestion;
-                }
-            }
-        }
-        return bestFound;
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/trees/EFDT.java b/moa/src/main/java/moa/classifiers/trees/EFDT.java
deleted file mode 100644
index dda4912ca..000000000
--- a/moa/src/main/java/moa/classifiers/trees/EFDT.java
+++ /dev/null
@@ -1,1615 +0,0 @@
-/*
- *    RandomHoeffdingTree.java
- *    Copyright (C) 2019 University of Waikato, Hamilton, New Zealand
- *    @author Chaitanya Manapragada
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-/*
- * Author: Chaitanya Manapragada.
- * <p>
- * Based on HoeffdingTree.java by Richard Kirkby.
- * <p>
- * There is a lot of code repetition from VFDT.java. This needs to be fixed as per DRY principles.
- * <p>
- * Research code written to test the EFDT idea.
- * <p>
- * Bug-fixed version of Richard Kirkby's  HoeffdingTree.Java written by Chaitanya Manapragada.
- * <p>
- * Bug1 : average delta G's are computed where specified in the Domingos/Hulten paper algorithm listing. This was a bug in the HoeffdingTree.java implementation- fixed here.
- * <p>
- * Bug2: splitting was occurring when the top attribute had no IG, and splitting was occurring on the same attribute. This was also fixed.
- * <p>
- * The correct reference is:
- * Domingos, P., & Hulten, G. (2000, August). Mining high-speed data streams. In Proceedings of the sixth ACM SIGKDD international conference on Knowledge discovery and data mining (pp. 71-80). ACM.
- */
-
-package moa.classifiers.trees;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Set;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.AbstractMOAObject;
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.MultiClassClassifier;
-import moa.classifiers.bayes.NaiveBayes;
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.DiscreteAttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.NullAttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.NumericAttributeClassObserver;
-import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
-import moa.classifiers.core.conditionaltests.NominalAttributeBinaryTest;
-import moa.classifiers.core.conditionaltests.NominalAttributeMultiwayTest;
-import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.core.AutoExpandVector;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.core.SizeOf;
-import moa.core.StringUtils;
-import moa.core.Utils;
-import moa.options.ClassOption;
-
-public class EFDT extends AbstractClassifier implements MultiClassClassifier {
-
-  private static final long serialVersionUID = 2L;
-
-  public IntOption reEvalPeriodOption = new IntOption(
-    "reevaluationPeriod",
-    'R',
-    "The number of instances an internal node should observe between re-evaluation attempts.",
-    2000, 0, Integer.MAX_VALUE);
-
-  public IntOption maxByteSizeOption = new IntOption("maxByteSize", 'm',
-    "Maximum memory consumed by the tree.", 33554432, 0,
-    Integer.MAX_VALUE);
-
-  /*
-   * public MultiChoiceOption numericEstimatorOption = new MultiChoiceOption(
-   * "numericEstimator", 'n', "Numeric estimator to use.", new String[]{
-   * "GAUSS10", "GAUSS100", "GK10", "GK100", "GK1000", "VFML10", "VFML100",
-   * "VFML1000", "BINTREE"}, new String[]{ "Gaussian approximation evaluating
-   * 10 splitpoints", "Gaussian approximation evaluating 100 splitpoints",
-   * "Greenwald-Khanna quantile summary with 10 tuples", "Greenwald-Khanna
-   * quantile summary with 100 tuples", "Greenwald-Khanna quantile summary
-   * with 1000 tuples", "VFML method with 10 bins", "VFML method with 100
-   * bins", "VFML method with 1000 bins", "Exhaustive binary tree"}, 0);
-   */
-  public ClassOption numericEstimatorOption = new ClassOption("numericEstimator",
-    'n', "Numeric estimator to use.", NumericAttributeClassObserver.class,
-    "GaussianNumericAttributeClassObserver");
-
-  public ClassOption nominalEstimatorOption = new ClassOption("nominalEstimator",
-    'd', "Nominal estimator to use.", DiscreteAttributeClassObserver.class,
-    "NominalAttributeClassObserver");
-
-  public IntOption memoryEstimatePeriodOption = new IntOption(
-    "memoryEstimatePeriod", 'e',
-    "How many instances between memory consumption checks.", 1000000,
-    0, Integer.MAX_VALUE);
-
-  public IntOption gracePeriodOption = new IntOption(
-    "gracePeriod",
-    'g',
-    "The number of instances a leaf should observe between split attempts.",
-    200, 0, Integer.MAX_VALUE);
-
-  public ClassOption splitCriterionOption = new ClassOption("splitCriterion",
-    's', "Split criterion to use.", SplitCriterion.class,
-    "InfoGainSplitCriterion");
-
-  public FloatOption splitConfidenceOption = new FloatOption(
-    "splitConfidence",
-    'c',
-    "The allowable error in split decision, values closer to 0 will take longer to decide.",
-    0.0000001, 0.0, 1.0);
-
-  public FloatOption tieThresholdOption = new FloatOption("tieThreshold",
-    't', "Threshold below which a split will be forced to break ties.",
-    0.05, 0.0, 1.0);
-
-  public FlagOption binarySplitsOption = new FlagOption("binarySplits", 'b',
-    "Only allow binary splits.");
-
-  public FlagOption stopMemManagementOption = new FlagOption(
-    "stopMemManagement", 'z',
-    "Stop growing as soon as memory limit is hit.");
-
-  public FlagOption removePoorAttsOption = new FlagOption("removePoorAtts",
-    'r', "Disable poor attributes.");
-
-  public FlagOption noPrePruneOption = new FlagOption("noPrePrune", 'p',
-    "Disable pre-pruning.");
-
-  public MultiChoiceOption leafpredictionOption = new MultiChoiceOption(
-    "leafprediction", 'l', "Leaf prediction to use.", new String[]{
-    "MC", "NB", "NBAdaptive"}, new String[]{
-    "Majority class",
-    "Naive Bayes",
-    "Naive Bayes Adaptive"}, 2);
-
-  public IntOption nbThresholdOption = new IntOption(
-    "nbThreshold",
-    'q',
-    "The number of instances a leaf should observe before permitting Naive Bayes.",
-    0, 0, Integer.MAX_VALUE);
-
-  protected Node treeRoot = null;
-
-  protected int decisionNodeCount;
-
-  protected int activeLeafNodeCount;
-
-  protected int inactiveLeafNodeCount;
-
-  protected double inactiveLeafByteSizeEstimate;
-
-  protected double activeLeafByteSizeEstimate;
-
-  protected double byteSizeEstimateOverheadFraction;
-
-  protected boolean growthAllowed;
-
-  protected int numInstances = 0;
-
-  protected int splitCount = 0;
-
-  @Override
-  public String getPurposeString() {
-    return "Hoeffding Tree or VFDT.";
-  }
-
-  public int calcByteSize() {
-    int size = (int) SizeOf.sizeOf(this);
-    if (this.treeRoot != null) {
-      size += this.treeRoot.calcByteSizeIncludingSubtree();
-    }
-    return size;
-  }
-
-  @Override
-  public int measureByteSize() {
-    return calcByteSize();
-  }
-
-  @Override
-  public void resetLearningImpl() {
-    this.treeRoot = null;
-    this.decisionNodeCount = 0;
-    this.activeLeafNodeCount = 0;
-    this.inactiveLeafNodeCount = 0;
-    this.inactiveLeafByteSizeEstimate = 0.0;
-    this.activeLeafByteSizeEstimate = 0.0;
-    this.byteSizeEstimateOverheadFraction = 1.0;
-    this.growthAllowed = true;
-    if (this.leafpredictionOption.getChosenIndex() > 0) {
-      this.removePoorAttsOption = null;
-    }
-  }
-
-  @Override
-  public double[] getVotesForInstance(Instance inst) {
-    if (this.treeRoot != null) {
-      FoundNode foundNode = this.treeRoot.filterInstanceToLeaf(inst,
-	null, -1);
-      Node leafNode = foundNode.node;
-      if (leafNode == null) {
-	leafNode = foundNode.parent;
-      }
-      return leafNode.getClassVotes(inst, this);
-    }
-    else {
-      int numClasses = inst.dataset().numClasses();
-      return new double[numClasses];
-    }
-  }
-
-  @Override
-  protected Measurement[] getModelMeasurementsImpl() {
-    FoundNode[] learningNodes = findLearningNodes();
-
-    return new Measurement[]{
-
-      new Measurement("tree size (nodes)", this.decisionNodeCount
-	+ this.activeLeafNodeCount + this.inactiveLeafNodeCount),
-      new Measurement("tree size (leaves)", learningNodes.length),
-      new Measurement("active learning leaves",
-	this.activeLeafNodeCount),
-      new Measurement("tree depth", measureTreeDepth()),
-      new Measurement("active leaf byte size estimate",
-	this.activeLeafByteSizeEstimate),
-      new Measurement("inactive leaf byte size estimate",
-	this.inactiveLeafByteSizeEstimate),
-      new Measurement("byte size estimate overhead",
-	this.byteSizeEstimateOverheadFraction),
-      new Measurement("splits",
-	this.splitCount)};
-  }
-
-  public int measureTreeDepth() {
-    if (this.treeRoot != null) {
-      return this.treeRoot.subtreeDepth();
-    }
-    return 0;
-  }
-
-  @Override
-  public void getModelDescription(StringBuilder out, int indent) {
-    this.treeRoot.describeSubtree(this, out, indent);
-  }
-
-  @Override
-  public boolean isRandomizable() {
-    return false;
-  }
-
-  public static double computeHoeffdingBound(double range, double confidence,
-					     double n) {
-    return Math.sqrt(((range * range) * Math.log(1.0 / confidence))
-      / (2.0 * n));
-  }
-
-  protected AttributeClassObserver newNominalClassObserver() {
-    AttributeClassObserver nominalClassObserver = (AttributeClassObserver) getPreparedClassOption(this.nominalEstimatorOption);
-    return (AttributeClassObserver) nominalClassObserver.copy();
-  }
-
-  protected AttributeClassObserver newNumericClassObserver() {
-    AttributeClassObserver numericClassObserver = (AttributeClassObserver) getPreparedClassOption(this.numericEstimatorOption);
-    return (AttributeClassObserver) numericClassObserver.copy();
-  }
-
-  public void enforceTrackerLimit() {
-    if ((this.inactiveLeafNodeCount > 0)
-      || ((this.activeLeafNodeCount * this.activeLeafByteSizeEstimate + this.inactiveLeafNodeCount
-      * this.inactiveLeafByteSizeEstimate)
-      * this.byteSizeEstimateOverheadFraction > this.maxByteSizeOption.getValue())) {
-      if (this.stopMemManagementOption.isSet()) {
-	this.growthAllowed = false;
-	return;
-      }
-      FoundNode[] learningNodes = findLearningNodes();
-      Arrays.sort(learningNodes, new Comparator<FoundNode>() {
-
-	@Override
-	public int compare(FoundNode fn1, FoundNode fn2) {
-	  return Double.compare(fn1.node.calculatePromise(), fn2.node.calculatePromise());
-	}
-      });
-      int maxActive = 0;
-      while (maxActive < learningNodes.length) {
-	maxActive++;
-	if ((maxActive * this.activeLeafByteSizeEstimate + (learningNodes.length - maxActive)
-	  * this.inactiveLeafByteSizeEstimate)
-	  * this.byteSizeEstimateOverheadFraction > this.maxByteSizeOption.getValue()) {
-	  maxActive--;
-	  break;
-	}
-      }
-      int cutoff = learningNodes.length - maxActive;
-      for (int i = 0; i < cutoff; i++) {
-	if (learningNodes[i].node instanceof ActiveLearningNode) {
-	  deactivateLearningNode(
-	    (ActiveLearningNode) learningNodes[i].node,
-	    learningNodes[i].parent,
-	    learningNodes[i].parentBranch);
-	}
-      }
-      for (int i = cutoff; i < learningNodes.length; i++) {
-	if (learningNodes[i].node instanceof InactiveLearningNode) {
-	  activateLearningNode(
-	    (InactiveLearningNode) learningNodes[i].node,
-	    learningNodes[i].parent,
-	    learningNodes[i].parentBranch);
-	}
-      }
-    }
-  }
-
-  public void estimateModelByteSizes() {
-    FoundNode[] learningNodes = findLearningNodes();
-    long totalActiveSize = 0;
-    long totalInactiveSize = 0;
-    for (FoundNode foundNode : learningNodes) {
-      if (foundNode.node instanceof ActiveLearningNode) {
-	totalActiveSize += SizeOf.fullSizeOf(foundNode.node);
-      }
-      else {
-	totalInactiveSize += SizeOf.fullSizeOf(foundNode.node);
-      }
-    }
-    if (totalActiveSize > 0) {
-      this.activeLeafByteSizeEstimate = (double) totalActiveSize
-	/ this.activeLeafNodeCount;
-    }
-    if (totalInactiveSize > 0) {
-      this.inactiveLeafByteSizeEstimate = (double) totalInactiveSize
-	/ this.inactiveLeafNodeCount;
-    }
-    int actualModelSize = this.measureByteSize();
-    double estimatedModelSize = (this.activeLeafNodeCount
-      * this.activeLeafByteSizeEstimate + this.inactiveLeafNodeCount
-      * this.inactiveLeafByteSizeEstimate);
-    this.byteSizeEstimateOverheadFraction = actualModelSize
-      / estimatedModelSize;
-    if (actualModelSize > this.maxByteSizeOption.getValue()) {
-      enforceTrackerLimit();
-    }
-  }
-
-  public void deactivateAllLeaves() {
-    FoundNode[] learningNodes = findLearningNodes();
-    for (FoundNode learningNode : learningNodes) {
-      if (learningNode.node instanceof ActiveLearningNode) {
-	deactivateLearningNode(
-	  (ActiveLearningNode) learningNode.node,
-	  learningNode.parent, learningNode.parentBranch);
-      }
-    }
-  }
-
-  protected void deactivateLearningNode(ActiveLearningNode toDeactivate,
-					SplitNode parent, int parentBranch) {
-    Node newLeaf = new InactiveLearningNode(toDeactivate.getObservedClassDistribution());
-    if (parent == null) {
-      this.treeRoot = newLeaf;
-    }
-    else {
-      parent.setChild(parentBranch, newLeaf);
-    }
-    this.activeLeafNodeCount--;
-    this.inactiveLeafNodeCount++;
-  }
-
-  protected void activateLearningNode(InactiveLearningNode toActivate,
-				      SplitNode parent, int parentBranch) {
-    Node newLeaf = newLearningNode(toActivate.getObservedClassDistribution());
-    if (parent == null) {
-      this.treeRoot = newLeaf;
-    }
-    else {
-      parent.setChild(parentBranch, newLeaf);
-    }
-    this.activeLeafNodeCount++;
-    this.inactiveLeafNodeCount--;
-  }
-
-  protected FoundNode[] findLearningNodes() {
-    List<FoundNode> foundList = new LinkedList<>();
-    findLearningNodes(this.treeRoot, null, -1, foundList);
-    return foundList.toArray(new FoundNode[foundList.size()]);
-  }
-
-  protected void findLearningNodes(Node node, SplitNode parent,
-				   int parentBranch, List<FoundNode> found) {
-    if (node != null) {
-      if (node instanceof LearningNode) {
-	found.add(new FoundNode(node, parent, parentBranch));
-      }
-      if (node instanceof SplitNode) {
-	SplitNode splitNode = (SplitNode) node;
-	for (int i = 0; i < splitNode.numChildren(); i++) {
-	  findLearningNodes(splitNode.getChild(i), splitNode, i,
-	    found);
-	}
-      }
-    }
-  }
-
-  protected void attemptToSplit(ActiveLearningNode node, SplitNode parent,
-				int parentIndex) {
-
-    if (!node.observedClassDistributionIsPure()) {
-      node.addToSplitAttempts(1); // even if we don't actually attempt to split, we've computed infogains
-
-
-      SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
-      AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion, this);
-      Arrays.sort(bestSplitSuggestions);
-      boolean shouldSplit = false;
-
-      for (AttributeSplitSuggestion bestSplitSuggestion : bestSplitSuggestions) {
-
-	if (bestSplitSuggestion.splitTest != null) {
-	  if (!node.getInfogainSum().containsKey((bestSplitSuggestion.splitTest.getAttsTestDependsOn()[0]))) {
-	    node.getInfogainSum().put((bestSplitSuggestion.splitTest.getAttsTestDependsOn()[0]), 0.0);
-	  }
-	  double currentSum = node.getInfogainSum().get((bestSplitSuggestion.splitTest.getAttsTestDependsOn()[0]));
-	  node.getInfogainSum().put((bestSplitSuggestion.splitTest.getAttsTestDependsOn()[0]), currentSum + bestSplitSuggestion.merit);
-	}
-
-	else { // handle the null attribute
-	  double currentSum = node.getInfogainSum().get(-1); // null split
-	  node.getInfogainSum().put(-1, Math.max(0.0, currentSum + bestSplitSuggestion.merit));
-	  assert node.getInfogainSum().get(-1) >= 0.0 : "Negative infogain shouldn't be possible here.";
-	}
-
-      }
-
-      if (bestSplitSuggestions.length < 2) {
-	shouldSplit = bestSplitSuggestions.length > 0;
-      }
-
-      else {
-	double hoeffdingBound = computeHoeffdingBound(splitCriterion.getRangeOfMerit(node.getObservedClassDistribution()),
-	  this.splitConfidenceOption.getValue(), node.getWeightSeen());
-	AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-
-	double bestSuggestionAverageMerit;
-	double currentAverageMerit = node.getInfogainSum().get(-1) / node.getNumSplitAttempts();
-
-	// because this is an unsplit leaf. current average merit should be always zero on the null split.
-
-	if (bestSuggestion.splitTest == null) { // if you have a null split
-	  bestSuggestionAverageMerit = node.getInfogainSum().get(-1) / node.getNumSplitAttempts();
-	}
-	else {
-	  bestSuggestionAverageMerit = node.getInfogainSum().get((bestSuggestion.splitTest.getAttsTestDependsOn()[0])) / node.getNumSplitAttempts();
-	}
-
-	if (bestSuggestion.merit < 1e-10) {
-	  shouldSplit = false; // we don't use average here
-	}
-
-	else if ((bestSuggestionAverageMerit - currentAverageMerit) >
-	  hoeffdingBound
-	  || (hoeffdingBound < this.tieThresholdOption.getValue())) {
-	  if (bestSuggestionAverageMerit - currentAverageMerit < hoeffdingBound) {
-	    // Placeholder to list this possibility
-	  }
-	  shouldSplit = true;
-	}
-
-	if (shouldSplit) {
-	  for (Integer i : node.usedNominalAttributes) {
-	    if (bestSuggestion.splitTest.getAttsTestDependsOn()[0] == i) {
-	      shouldSplit = false;
-	      break;
-	    }
-	  }
-	}
-
-	// }
-	if ((this.removePoorAttsOption != null)
-	  && this.removePoorAttsOption.isSet()) {
-	  Set<Integer> poorAtts = new HashSet<>();
-	  // scan 1 - add any poor to set
-	  for (AttributeSplitSuggestion bestSplitSuggestion : bestSplitSuggestions) {
-	    if (bestSplitSuggestion.splitTest != null) {
-	      int[] splitAtts = bestSplitSuggestion.splitTest.getAttsTestDependsOn();
-	      if (splitAtts.length == 1) {
-		if (bestSuggestion.merit
-		  - bestSplitSuggestion.merit > hoeffdingBound) {
-		  poorAtts.add(splitAtts[0]);
-		}
-	      }
-	    }
-	  }
-	  // scan 2 - remove good ones from set
-	  for (AttributeSplitSuggestion bestSplitSuggestion : bestSplitSuggestions) {
-	    if (bestSplitSuggestion.splitTest != null) {
-	      int[] splitAtts = bestSplitSuggestion.splitTest.getAttsTestDependsOn();
-	      if (splitAtts.length == 1) {
-		if (bestSuggestion.merit
-		  - bestSplitSuggestion.merit < hoeffdingBound) {
-		  poorAtts.remove(splitAtts[0]);
-		}
-	      }
-	    }
-	  }
-	  for (int poorAtt : poorAtts) {
-	    node.disableAttribute(poorAtt);
-	  }
-	}
-      }
-      if (shouldSplit) {
-	splitCount++;
-
-	AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-	if (splitDecision.splitTest == null) {
-	  // preprune - null wins
-	  deactivateLearningNode(node, parent, parentIndex);
-	}
-	else {
-	  Node newSplit = newSplitNode(splitDecision.splitTest,
-	    node.getObservedClassDistribution(), splitDecision.numSplits());
-	  ((EFDTSplitNode) newSplit).attributeObservers = node.attributeObservers; // copy the attribute observers
-	  newSplit.setInfogainSum(node.getInfogainSum());  // transfer infogain history, leaf to split
-
-	  for (int i = 0; i < splitDecision.numSplits(); i++) {
-
-	    double[] j = splitDecision.resultingClassDistributionFromSplit(i);
-
-	    Node newChild = newLearningNode(splitDecision.resultingClassDistributionFromSplit(i));
-
-	    if (splitDecision.splitTest.getClass() == NominalAttributeBinaryTest.class
-	      || splitDecision.splitTest.getClass() == NominalAttributeMultiwayTest.class) {
-	      newChild.usedNominalAttributes = new ArrayList<>(node.usedNominalAttributes); //deep copy
-	      newChild.usedNominalAttributes.add(splitDecision.splitTest.getAttsTestDependsOn()[0]);
-	      // no  nominal attribute should be split on more than once in the path
-	    }
-	    ((EFDTSplitNode) newSplit).setChild(i, newChild);
-	  }
-	  this.activeLeafNodeCount--;
-	  this.decisionNodeCount++;
-	  this.activeLeafNodeCount += splitDecision.numSplits();
-	  if (parent == null) {
-	    this.treeRoot = newSplit;
-	  }
-	  else {
-	    parent.setChild(parentIndex, newSplit);
-	  }
-
-	}
-	// manage memory
-	enforceTrackerLimit();
-      }
-    }
-  }
-
-  @Override
-  public void trainOnInstanceImpl(Instance inst) {
-
-    if (this.treeRoot == null) {
-      this.treeRoot = newLearningNode();
-      ((EFDTNode) this.treeRoot).setRoot(true);
-      this.activeLeafNodeCount = 1;
-    }
-
-    FoundNode foundNode = this.treeRoot.filterInstanceToLeaf(inst, null, -1);
-    Node leafNode = foundNode.node;
-
-    if (leafNode == null) {
-      leafNode = newLearningNode();
-      foundNode.parent.setChild(foundNode.parentBranch, leafNode);
-      this.activeLeafNodeCount++;
-    }
-
-    ((EFDTNode) this.treeRoot).learnFromInstance(inst, this, null, -1);
-
-    numInstances++;
-  }
-
-
-  protected LearningNode newLearningNode() {
-    return new EFDTLearningNode(new double[0]);
-  }
-
-  protected LearningNode newLearningNode(double[] initialClassObservations) {
-    return new EFDTLearningNode(initialClassObservations);
-  }
-
-  protected SplitNode newSplitNode(InstanceConditionalTest splitTest,
-				   double[] classObservations, int size) {
-    return new EFDTSplitNode(splitTest, classObservations, size);
-  }
-
-  protected SplitNode newSplitNode(InstanceConditionalTest splitTest,
-				   double[] classObservations) {
-    return new EFDTSplitNode(splitTest, classObservations);
-  }
-
-  private int argmax(double[] array) {
-
-    double max = array[0];
-    int maxarg = 0;
-
-    for (int i = 1; i < array.length; i++) {
-
-      if (array[i] > max) {
-	max = array[i];
-	maxarg = i;
-      }
-    }
-    return maxarg;
-  }
-
-  public interface EFDTNode {
-
-    boolean isRoot();
-
-    void setRoot(boolean isRoot);
-
-    void learnFromInstance(Instance inst, EFDT ht, EFDTSplitNode parent, int parentBranch);
-
-    void setParent(EFDTSplitNode parent);
-
-    EFDTSplitNode getParent();
-
-  }
-
-  public static class FoundNode {
-
-    public Node node;
-
-    public SplitNode parent;
-
-    public int parentBranch;
-
-    public FoundNode(Node node, SplitNode parent, int parentBranch) {
-      this.node = node;
-      this.parent = parent;
-      this.parentBranch = parentBranch;
-    }
-  }
-
-  public static class Node extends AbstractMOAObject {
-
-    private HashMap<Integer, Double> infogainSum;
-
-    private int numSplitAttempts = 0;
-
-    private static final long serialVersionUID = 1L;
-
-    protected DoubleVector observedClassDistribution;
-
-    protected DoubleVector classDistributionAtTimeOfCreation;
-
-    protected int nodeTime;
-
-    protected List<Integer> usedNominalAttributes = new ArrayList<>();
-
-    public Node(double[] classObservations) {
-      this.observedClassDistribution = new DoubleVector(classObservations);
-      this.classDistributionAtTimeOfCreation = new DoubleVector(classObservations);
-      this.infogainSum = new HashMap<>();
-      this.infogainSum.put(-1, 0.0); // Initialize for null split
-
-    }
-
-    public int getNumSplitAttempts() {
-      return numSplitAttempts;
-    }
-
-    public void addToSplitAttempts(int i) {
-      numSplitAttempts += i;
-    }
-
-    public HashMap<Integer, Double> getInfogainSum() {
-      return infogainSum;
-    }
-
-    public void setInfogainSum(HashMap<Integer, Double> igs) {
-      infogainSum = igs;
-    }
-
-    public int calcByteSize() {
-      return (int) (SizeOf.sizeOf(this) + SizeOf.fullSizeOf(this.observedClassDistribution));
-    }
-
-    public int calcByteSizeIncludingSubtree() {
-      return calcByteSize();
-    }
-
-    public boolean isLeaf() {
-      return true;
-    }
-
-    public FoundNode filterInstanceToLeaf(Instance inst, SplitNode parent,
-					  int parentBranch) {
-      return new FoundNode(this, parent, parentBranch);
-    }
-
-    public double[] getObservedClassDistribution() {
-      return this.observedClassDistribution.getArrayCopy();
-    }
-
-    public double[] getClassVotes(Instance inst, EFDT ht) {
-      return this.observedClassDistribution.getArrayCopy();
-    }
-
-    public double[] getClassDistributionAtTimeOfCreation() {
-      return this.classDistributionAtTimeOfCreation.getArrayCopy();
-    }
-
-    public boolean observedClassDistributionIsPure() {
-      return this.observedClassDistribution.numNonZeroEntries() < 2;
-    }
-
-    public void describeSubtree(EFDT ht, StringBuilder out,
-				int indent) {
-      StringUtils.appendIndented(out, indent, "Leaf ");
-      out.append(ht.getClassNameString());
-      out.append(" = ");
-      out.append(ht.getClassLabelString(this.observedClassDistribution.maxIndex()));
-      out.append(" weights: ");
-      this.observedClassDistribution.getSingleLineDescription(out,
-	ht.treeRoot.observedClassDistribution.numValues());
-      StringUtils.appendNewline(out);
-    }
-
-    public int subtreeDepth() {
-      return 0;
-    }
-
-    public double calculatePromise() {
-      double totalSeen = this.observedClassDistribution.sumOfValues();
-      return totalSeen > 0.0 ? (totalSeen - this.observedClassDistribution.getValue(this.observedClassDistribution.maxIndex()))
-	: 0.0;
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-      describeSubtree(null, sb, indent);
-    }
-  }
-
-  public static class SplitNode extends Node {
-
-    private static final long serialVersionUID = 1L;
-
-    protected InstanceConditionalTest splitTest;
-
-    protected AutoExpandVector<Node> children; // = new AutoExpandVector<Node>();
-
-    @Override
-    public int calcByteSize() {
-      return super.calcByteSize()
-	+ (int) (SizeOf.sizeOf(this.children) + SizeOf.fullSizeOf(this.splitTest));
-    }
-
-    @Override
-    public int calcByteSizeIncludingSubtree() {
-      int byteSize = calcByteSize();
-      for (Node child : this.children) {
-	if (child != null) {
-	  byteSize += child.calcByteSizeIncludingSubtree();
-	}
-      }
-      return byteSize;
-    }
-
-    public SplitNode(InstanceConditionalTest splitTest,
-		     double[] classObservations, int size) {
-      super(classObservations);
-      this.splitTest = splitTest;
-      this.children = new AutoExpandVector<>(size);
-    }
-
-    public SplitNode(InstanceConditionalTest splitTest,
-		     double[] classObservations) {
-      super(classObservations);
-      this.splitTest = splitTest;
-      this.children = new AutoExpandVector<>();
-    }
-
-
-    public int numChildren() {
-      return this.children.size();
-    }
-
-    public void setChild(int index, Node child) {
-      if ((this.splitTest.maxBranches() >= 0)
-	&& (index >= this.splitTest.maxBranches())) {
-	throw new IndexOutOfBoundsException();
-      }
-      this.children.set(index, child);
-    }
-
-    public Node getChild(int index) {
-      return this.children.get(index);
-    }
-
-    public int instanceChildIndex(Instance inst) {
-      return this.splitTest.branchForInstance(inst);
-    }
-
-    @Override
-    public boolean isLeaf() {
-      return false;
-    }
-
-    @Override
-    public FoundNode filterInstanceToLeaf(Instance inst, SplitNode parent,
-					  int parentBranch) {
-
-      //System.err.println("OVERRIDING ");
-
-      int childIndex = instanceChildIndex(inst);
-      if (childIndex >= 0) {
-	Node child = getChild(childIndex);
-	if (child != null) {
-	  return child.filterInstanceToLeaf(inst, this, childIndex);
-	}
-	return new FoundNode(null, this, childIndex);
-      }
-      return new FoundNode(this, parent, parentBranch);
-    }
-
-    @Override
-    public void describeSubtree(EFDT ht, StringBuilder out,
-				int indent) {
-      for (int branch = 0; branch < numChildren(); branch++) {
-	Node child = getChild(branch);
-	if (child != null) {
-	  StringUtils.appendIndented(out, indent, "if ");
-	  out.append(this.splitTest.describeConditionForBranch(branch,
-	    ht.getModelContext()));
-	  out.append(": ");
-	  StringUtils.appendNewline(out);
-	  child.describeSubtree(ht, out, indent + 2);
-	}
-      }
-    }
-
-    @Override
-    public int subtreeDepth() {
-      int maxChildDepth = 0;
-      for (Node child : this.children) {
-	if (child != null) {
-	  int depth = child.subtreeDepth();
-	  if (depth > maxChildDepth) {
-	    maxChildDepth = depth;
-	  }
-	}
-      }
-      return maxChildDepth + 1;
-    }
-  }
-
-
-  public class EFDTSplitNode extends SplitNode implements EFDTNode {
-
-    /**
-     *
-     */
-
-    private boolean isRoot;
-
-    private EFDTSplitNode parent = null;
-
-    private static final long serialVersionUID = 1L;
-
-    protected AutoExpandVector<AttributeClassObserver> attributeObservers;
-
-    public EFDTSplitNode(InstanceConditionalTest splitTest, double[] classObservations, int size) {
-      super(splitTest, classObservations, size);
-    }
-
-    public EFDTSplitNode(InstanceConditionalTest splitTest, double[] classObservations) {
-      super(splitTest, classObservations);
-    }
-
-    @Override
-    public boolean isRoot() {
-      return isRoot;
-    }
-
-    @Override
-    public void setRoot(boolean isRoot) {
-      this.isRoot = isRoot;
-    }
-
-    public void killSubtree(EFDT ht) {
-      for (Node child : this.children) {
-	if (child != null) {
-
-	  //Recursive delete of SplitNodes
-	  if (child instanceof SplitNode) {
-	    ((EFDTSplitNode) child).killSubtree(ht);
-	  }
-	  else if (child instanceof ActiveLearningNode) {
-	    ht.activeLeafNodeCount--;
-	  }
-	  else if (child instanceof InactiveLearningNode) {
-	    ht.inactiveLeafNodeCount--;
-	  }
-	}
-      }
-    }
-
-
-    // DRY Don't Repeat Yourself... code duplicated from ActiveLearningNode in VFDT.java. However, this is the most practical way to share stand-alone.
-    public AttributeSplitSuggestion[] getBestSplitSuggestions(
-      SplitCriterion criterion, EFDT ht) {
-      List<AttributeSplitSuggestion> bestSuggestions = new LinkedList<>();
-      double[] preSplitDist = this.observedClassDistribution.getArrayCopy();
-      if (!ht.noPrePruneOption.isSet()) {
-	// add null split as an option
-	bestSuggestions.add(new AttributeSplitSuggestion(null,
-	  new double[0][], criterion.getMeritOfSplit(
-	  preSplitDist, new double[][]{preSplitDist})));
-      }
-      for (int i = 0; i < this.attributeObservers.size(); i++) {
-	AttributeClassObserver obs = this.attributeObservers.get(i);
-	if (obs != null) {
-	  AttributeSplitSuggestion bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion,
-	    preSplitDist, i, ht.binarySplitsOption.isSet());
-	  if (bestSuggestion != null) {
-	    bestSuggestions.add(bestSuggestion);
-	  }
-	}
-      }
-      return bestSuggestions.toArray(new AttributeSplitSuggestion[bestSuggestions.size()]);
-    }
-
-
-    @Override
-    public void learnFromInstance(Instance inst, EFDT ht, EFDTSplitNode parent, int parentBranch) {
-
-      nodeTime++;
-      //// Update node statistics and class distribution
-
-      this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight()); // update prior (predictor)
-
-      for (int i = 0; i < inst.numAttributes() - 1; i++) { //update likelihood
-	int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
-	AttributeClassObserver obs = this.attributeObservers.get(i);
-	if (obs == null) {
-	  obs = inst.attribute(instAttIndex).isNominal() ? ht.newNominalClassObserver() : ht.newNumericClassObserver();
-	  this.attributeObservers.set(i, obs);
-	}
-	obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
-      }
-
-      // check if a better split is available. if so, chop the tree at this point, copying likelihood. predictors for children are from parent likelihood.
-      if (ht.numInstances % ht.reEvalPeriodOption.getValue() == 0) {
-	this.reEvaluateBestSplit(this, parent, parentBranch);
-      }
-
-      int childBranch = this.instanceChildIndex(inst);
-      Node child = this.getChild(childBranch);
-
-      if (child != null) {
-	((EFDTNode) child).learnFromInstance(inst, ht, this, childBranch);
-      }
-
-    }
-
-    protected void reEvaluateBestSplit(EFDTSplitNode node, EFDTSplitNode parent,
-				       int parentIndex) {
-
-
-      node.addToSplitAttempts(1);
-
-      // EFDT must transfer over gain averages when replacing a node: leaf to split, split to leaf, or split to split
-      // It must replace split nodes with leaves if null wins
-
-
-      // node is a reference to this anyway... why have it at all?
-
-      int currentSplit = -1;
-      // and if we always choose to maintain tree structure
-
-      //lets first find out X_a, the current split
-
-      if (this.splitTest != null) {
-	currentSplit = this.splitTest.getAttsTestDependsOn()[0];
-	// given the current implementations in MOA, we're only ever expecting one int to be returned
-      }
-
-      //compute Hoeffding bound
-      SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(EFDT.this.splitCriterionOption);
-      double hoeffdingBound = computeHoeffdingBound(splitCriterion.getRangeOfMerit(node.getClassDistributionAtTimeOfCreation()),
-	EFDT.this.splitConfidenceOption.getValue(), node.observedClassDistribution.sumOfValues());
-
-      // get best split suggestions
-      AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion, EFDT.this);
-      Arrays.sort(bestSplitSuggestions);
-
-      // get the best suggestion
-      AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-
-
-      for (AttributeSplitSuggestion bestSplitSuggestion : bestSplitSuggestions) {
-
-	if (bestSplitSuggestion.splitTest != null) {
-	  if (!node.getInfogainSum().containsKey((bestSplitSuggestion.splitTest.getAttsTestDependsOn()[0]))) {
-	    node.getInfogainSum().put((bestSplitSuggestion.splitTest.getAttsTestDependsOn()[0]), 0.0);
-	  }
-	  double currentSum = node.getInfogainSum().get((bestSplitSuggestion.splitTest.getAttsTestDependsOn()[0]));
-	  node.getInfogainSum().put((bestSplitSuggestion.splitTest.getAttsTestDependsOn()[0]), currentSum + bestSplitSuggestion.merit);
-	}
-
-	else { // handle the null attribute. this is fine to do- it'll always average zero, and we will use this later to potentially burn bad splits.
-	  double currentSum = node.getInfogainSum().get(-1); // null split
-	  node.getInfogainSum().put(-1, currentSum + bestSplitSuggestion.merit);
-	}
-
-      }
-
-      // get the average merit for best and current splits
-
-      double bestSuggestionAverageMerit;
-      double currentAverageMerit;
-
-      if (bestSuggestion.splitTest == null) { // best is null
-	bestSuggestionAverageMerit = node.getInfogainSum().get(-1) / node.getNumSplitAttempts();
-      }
-      else {
-
-	bestSuggestionAverageMerit = node.getInfogainSum().get(bestSuggestion.splitTest.getAttsTestDependsOn()[0]) / node.getNumSplitAttempts();
-      }
-
-      if (node.splitTest == null) { // current is null- shouldn't happen, check for robustness
-	currentAverageMerit = node.getInfogainSum().get(-1) / node.getNumSplitAttempts();
-      }
-      else {
-	currentAverageMerit = node.getInfogainSum().get(node.splitTest.getAttsTestDependsOn()[0]) / node.getNumSplitAttempts();
-      }
-
-      double tieThreshold = EFDT.this.tieThresholdOption.getValue();
-
-      // compute the average deltaG
-      double deltaG = bestSuggestionAverageMerit - currentAverageMerit;
-
-      if (deltaG > hoeffdingBound
-	|| (hoeffdingBound < tieThreshold && deltaG > tieThreshold / 2)) {
-
-	System.err.println(numInstances);
-
-	AttributeSplitSuggestion splitDecision = bestSuggestion;
-
-	// if null split wins
-	if (splitDecision.splitTest == null) {
-
-	  node.killSubtree(EFDT.this);
-	  EFDTLearningNode replacement = (EFDTLearningNode) newLearningNode();
-	  replacement.setInfogainSum(node.getInfogainSum()); // transfer infogain history, split to replacement leaf
-	  if (node.getParent() != null) {
-	    node.getParent().setChild(parentIndex, replacement);
-	  }
-	  else {
-	    assert (node.isRoot());
-	    node.setRoot(true);
-	  }
-	}
-
-	else {
-
-	  Node newSplit = newSplitNode(splitDecision.splitTest,
-	    node.getObservedClassDistribution(), splitDecision.numSplits());
-
-	  ((EFDTSplitNode) newSplit).attributeObservers = node.attributeObservers; // copy the attribute observers
-	  newSplit.setInfogainSum(node.getInfogainSum());  // transfer infogain history, split to replacement split
-
-	  if (node.splitTest == splitDecision.splitTest
-	    && node.splitTest.getClass() == NumericAttributeBinaryTest.class &&
-	    (argmax(splitDecision.resultingClassDistributions[0]) == argmax(node.getChild(0).getObservedClassDistribution())
-	      || argmax(splitDecision.resultingClassDistributions[1]) == argmax(node.getChild(1).getObservedClassDistribution()))
-	  ) {
-	    // change split but don't destroy the subtrees
-	    for (int i = 0; i < splitDecision.numSplits(); i++) {
-	      ((EFDTSplitNode) newSplit).setChild(i, this.getChild(i));
-	    }
-
-	  }
-	  else {
-
-	    // otherwise, torch the subtree and split on the new best attribute.
-
-	    this.killSubtree(EFDT.this);
-
-	    for (int i = 0; i < splitDecision.numSplits(); i++) {
-
-	      double[] j = splitDecision.resultingClassDistributionFromSplit(i);
-
-	      Node newChild = newLearningNode(splitDecision.resultingClassDistributionFromSplit(i));
-
-	      if (splitDecision.splitTest.getClass() == NominalAttributeBinaryTest.class
-		|| splitDecision.splitTest.getClass() == NominalAttributeMultiwayTest.class) {
-		newChild.usedNominalAttributes = new ArrayList<>(node.usedNominalAttributes); //deep copy
-		newChild.usedNominalAttributes.add(splitDecision.splitTest.getAttsTestDependsOn()[0]);
-		// no  nominal attribute should be split on more than once in the path
-	      }
-	      ((EFDTSplitNode) newSplit).setChild(i, newChild);
-	    }
-
-	    EFDT.this.activeLeafNodeCount--;
-	    EFDT.this.decisionNodeCount++;
-	    EFDT.this.activeLeafNodeCount += splitDecision.numSplits();
-
-	  }
-
-
-	  if (parent == null) {
-	    ((EFDTNode) newSplit).setRoot(true);
-	    ((EFDTNode) newSplit).setParent(null);
-	    EFDT.this.treeRoot = newSplit;
-	  }
-	  else {
-	    ((EFDTNode) newSplit).setRoot(false);
-	    ((EFDTNode) newSplit).setParent(parent);
-	    parent.setChild(parentIndex, newSplit);
-	  }
-	}
-      }
-    }
-
-    @Override
-    public void setParent(EFDTSplitNode parent) {
-      this.parent = parent;
-    }
-
-    @Override
-    public EFDTSplitNode getParent() {
-      return this.parent;
-    }
-  }
-
-  public static abstract class LearningNode extends Node {
-
-    private static final long serialVersionUID = 1L;
-
-    public LearningNode(double[] initialClassObservations) {
-      super(initialClassObservations);
-    }
-
-    public abstract void learnFromInstance(Instance inst, EFDT ht);
-  }
-
-
-  public class EFDTLearningNode extends LearningNodeNBAdaptive implements EFDTNode {
-
-    private boolean isRoot;
-
-    private EFDTSplitNode parent = null;
-
-    public EFDTLearningNode(double[] initialClassObservations) {
-      super(initialClassObservations);
-    }
-
-
-    /**
-     *
-     */
-    private static final long serialVersionUID = -2525042202040084035L;
-
-    @Override
-    public boolean isRoot() {
-      return isRoot;
-    }
-
-    @Override
-    public void setRoot(boolean isRoot) {
-      this.isRoot = isRoot;
-    }
-
-    @Override
-    public void learnFromInstance(Instance inst, EFDT ht) {
-      super.learnFromInstance(inst, ht);
-
-    }
-
-    @Override
-    public void learnFromInstance(Instance inst, EFDT ht, EFDTSplitNode parent, int parentBranch) {
-      learnFromInstance(inst, ht);
-
-      if (ht.growthAllowed) {
-	ActiveLearningNode activeLearningNode = this;
-	double weightSeen = activeLearningNode.getWeightSeen();
-	if (activeLearningNode.nodeTime % ht.gracePeriodOption.getValue() == 0) {
-	  attemptToSplit(activeLearningNode, parent,
-	    parentBranch);
-	  activeLearningNode.setWeightSeenAtLastSplitEvaluation(weightSeen);
-	}
-      }
-    }
-
-    @Override
-    public void setParent(EFDTSplitNode parent) {
-      this.parent = parent;
-    }
-
-    @Override
-    public EFDTSplitNode getParent() {
-      return this.parent;
-    }
-
-  }
-
-  public static class InactiveLearningNode extends LearningNode {
-
-    private static final long serialVersionUID = 1L;
-
-    public InactiveLearningNode(double[] initialClassObservations) {
-      super(initialClassObservations);
-    }
-
-    @Override
-    public void learnFromInstance(Instance inst, EFDT ht) {
-      this.observedClassDistribution.addToValue((int) inst.classValue(),
-	inst.weight());
-    }
-  }
-
-  public static class ActiveLearningNode extends LearningNode {
-
-    private static final long serialVersionUID = 1L;
-
-    protected double weightSeenAtLastSplitEvaluation;
-
-    protected AutoExpandVector<AttributeClassObserver> attributeObservers = new AutoExpandVector<>();
-
-    protected boolean isInitialized;
-
-    public ActiveLearningNode(double[] initialClassObservations) {
-      super(initialClassObservations);
-      this.weightSeenAtLastSplitEvaluation = getWeightSeen();
-      this.isInitialized = false;
-    }
-
-    @Override
-    public int calcByteSize() {
-      return super.calcByteSize()
-	+ (int) (SizeOf.fullSizeOf(this.attributeObservers));
-    }
-
-    @Override
-    public void learnFromInstance(Instance inst, EFDT ht) {
-      nodeTime++;
-
-      if (this.isInitialized) {
-	this.attributeObservers = new AutoExpandVector<>(inst.numAttributes());
-	this.isInitialized = true;
-      }
-      this.observedClassDistribution.addToValue((int) inst.classValue(),
-	inst.weight());
-      for (int i = 0; i < inst.numAttributes() - 1; i++) {
-	int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
-	AttributeClassObserver obs = this.attributeObservers.get(i);
-	if (obs == null) {
-	  obs = inst.attribute(instAttIndex).isNominal() ? ht.newNominalClassObserver() : ht.newNumericClassObserver();
-	  this.attributeObservers.set(i, obs);
-	}
-	obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
-      }
-    }
-
-    public double getWeightSeen() {
-      return this.observedClassDistribution.sumOfValues();
-    }
-
-    public double getWeightSeenAtLastSplitEvaluation() {
-      return this.weightSeenAtLastSplitEvaluation;
-    }
-
-    public void setWeightSeenAtLastSplitEvaluation(double weight) {
-      this.weightSeenAtLastSplitEvaluation = weight;
-    }
-
-    public AttributeSplitSuggestion[] getBestSplitSuggestions(
-      SplitCriterion criterion, EFDT ht) {
-      List<AttributeSplitSuggestion> bestSuggestions = new LinkedList<>();
-      double[] preSplitDist = this.observedClassDistribution.getArrayCopy();
-      if (!ht.noPrePruneOption.isSet()) {
-	// add null split as an option
-	bestSuggestions.add(new AttributeSplitSuggestion(null,
-	  new double[0][], criterion.getMeritOfSplit(
-	  preSplitDist, new double[][]{preSplitDist})));
-      }
-      for (int i = 0; i < this.attributeObservers.size(); i++) {
-	AttributeClassObserver obs = this.attributeObservers.get(i);
-	if (obs != null) {
-	  AttributeSplitSuggestion bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion,
-	    preSplitDist, i, ht.binarySplitsOption.isSet());
-	  if (bestSuggestion != null) {
-	    bestSuggestions.add(bestSuggestion);
-	  }
-	}
-      }
-      return bestSuggestions.toArray(new AttributeSplitSuggestion[bestSuggestions.size()]);
-    }
-
-    public void disableAttribute(int attIndex) {
-      this.attributeObservers.set(attIndex,
-	new NullAttributeClassObserver());
-    }
-  }
-
-  public static class LearningNodeNB extends ActiveLearningNode {
-
-    private static final long serialVersionUID = 1L;
-
-    public LearningNodeNB(double[] initialClassObservations) {
-      super(initialClassObservations);
-    }
-
-    @Override
-    public double[] getClassVotes(Instance inst, EFDT ht) {
-      if (getWeightSeen() >= ht.nbThresholdOption.getValue()) {
-	return NaiveBayes.doNaiveBayesPrediction(inst,
-	  this.observedClassDistribution,
-	  this.attributeObservers);
-      }
-      return super.getClassVotes(inst, ht);
-    }
-
-    @Override
-    public void disableAttribute(int attIndex) {
-      // should not disable poor atts - they are used in NB calc
-    }
-  }
-
-  public static class LearningNodeNBAdaptive extends LearningNodeNB {
-
-    private static final long serialVersionUID = 1L;
-
-    protected double mcCorrectWeight = 0.0;
-
-    protected double nbCorrectWeight = 0.0;
-
-    public LearningNodeNBAdaptive(double[] initialClassObservations) {
-      super(initialClassObservations);
-    }
-
-    @Override
-    public void learnFromInstance(Instance inst, EFDT ht) {
-      int trueClass = (int) inst.classValue();
-      if (this.observedClassDistribution.maxIndex() == trueClass) {
-	this.mcCorrectWeight += inst.weight();
-      }
-      if (Utils.maxIndex(NaiveBayes.doNaiveBayesPrediction(inst,
-	this.observedClassDistribution, this.attributeObservers)) == trueClass) {
-	this.nbCorrectWeight += inst.weight();
-      }
-      super.learnFromInstance(inst, ht);
-    }
-
-    @Override
-    public double[] getClassVotes(Instance inst, EFDT ht) {
-      if (this.mcCorrectWeight > this.nbCorrectWeight) {
-	return this.observedClassDistribution.getArrayCopy();
-      }
-      return NaiveBayes.doNaiveBayesPrediction(inst,
-	this.observedClassDistribution, this.attributeObservers);
-    }
-  }
-
-  static class VFDT extends EFDT {
-
-    @Override
-    protected void attemptToSplit(ActiveLearningNode node, SplitNode parent,
-				  int parentIndex) {
-      if (!node.observedClassDistributionIsPure()) {
-
-
-	SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
-	AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion, this);
-
-	Arrays.sort(bestSplitSuggestions);
-	boolean shouldSplit = false;
-
-	for (int i = 0; i < bestSplitSuggestions.length; i++){
-
-	  node.addToSplitAttempts(1); // even if we don't actually attempt to split, we've computed infogains
-
-
-	  if (bestSplitSuggestions[i].splitTest != null){
-	    if (!node.getInfogainSum().containsKey((bestSplitSuggestions[i].splitTest.getAttsTestDependsOn()[0])))
-	    {
-	      node.getInfogainSum().put((bestSplitSuggestions[i].splitTest.getAttsTestDependsOn()[0]), 0.0);
-	    }
-	    double currentSum = node.getInfogainSum().get((bestSplitSuggestions[i].splitTest.getAttsTestDependsOn()[0]));
-	    node.getInfogainSum().put((bestSplitSuggestions[i].splitTest.getAttsTestDependsOn()[0]), currentSum + bestSplitSuggestions[i].merit);
-	  }
-
-	  else { // handle the null attribute
-	    double currentSum = node.getInfogainSum().get(-1); // null split
-	    node.getInfogainSum().put(-1, currentSum + Math.max(0.0, bestSplitSuggestions[i].merit));
-	    assert node.getInfogainSum().get(-1) >= 0.0 : "Negative infogain shouldn't be possible here.";
-	  }
-
-	}
-
-	if (bestSplitSuggestions.length < 2) {
-	  shouldSplit = bestSplitSuggestions.length > 0;
-	}
-
-	else {
-
-
-	  double hoeffdingBound = computeHoeffdingBound(splitCriterion.getRangeOfMerit(node.getObservedClassDistribution()),
-	    this.splitConfidenceOption.getValue(), node.getWeightSeen());
-
-	  AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-	  AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
-
-
-	  double bestSuggestionAverageMerit = 0.0;
-	  double secondBestSuggestionAverageMerit = 0.0;
-
-	  if(bestSuggestion.splitTest == null){ // if you have a null split
-	    bestSuggestionAverageMerit = node.getInfogainSum().get(-1) / node.getNumSplitAttempts();
-	  } else{
-	    bestSuggestionAverageMerit = node.getInfogainSum().get((bestSuggestion.splitTest.getAttsTestDependsOn()[0])) / node.getNumSplitAttempts();
-	  }
-
-	  if(secondBestSuggestion.splitTest == null){ // if you have a null split
-	    secondBestSuggestionAverageMerit = node.getInfogainSum().get(-1) / node.getNumSplitAttempts();
-	  } else{
-	    secondBestSuggestionAverageMerit = node.getInfogainSum().get((secondBestSuggestion.splitTest.getAttsTestDependsOn()[0])) / node.getNumSplitAttempts();
-	  }
-
-	  //comment this if statement to get VFDT bug
-	  if(bestSuggestion.merit < 1e-10){ // we don't use average here
-	    shouldSplit = false;
-	  }
-
-	  else
-	  if ((bestSuggestionAverageMerit - secondBestSuggestionAverageMerit > hoeffdingBound)
-	    || (hoeffdingBound < this.tieThresholdOption.getValue()))
-	  {
-	    shouldSplit = true;
-	  }
-
-	  if(shouldSplit){
-	    for(Integer i : node.usedNominalAttributes){
-	      if(bestSuggestion.splitTest.getAttsTestDependsOn()[0] == i){
-		shouldSplit = false;
-		break;
-	      }
-	    }
-	  }
-
-	  // }
-	  if ((this.removePoorAttsOption != null)
-	    && this.removePoorAttsOption.isSet()) {
-	    Set<Integer> poorAtts = new HashSet<Integer>();
-	    // scan 1 - add any poor to set
-	    for (int i = 0; i < bestSplitSuggestions.length; i++) {
-	      if (bestSplitSuggestions[i].splitTest != null) {
-		int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
-		if (splitAtts.length == 1) {
-		  if (bestSuggestion.merit
-		    - bestSplitSuggestions[i].merit > hoeffdingBound) {
-		    poorAtts.add(new Integer(splitAtts[0]));
-		  }
-		}
-	      }
-	    }
-	    // scan 2 - remove good ones from set
-	    for (int i = 0; i < bestSplitSuggestions.length; i++) {
-	      if (bestSplitSuggestions[i].splitTest != null) {
-		int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
-		if (splitAtts.length == 1) {
-		  if (bestSuggestion.merit
-		    - bestSplitSuggestions[i].merit < hoeffdingBound) {
-		    poorAtts.remove(new Integer(splitAtts[0]));
-		  }
-		}
-	      }
-	    }
-	    for (int poorAtt : poorAtts) {
-	      node.disableAttribute(poorAtt);
-	    }
-	  }
-	}
-	if (shouldSplit) {
-	  splitCount++;
-
-	  AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-	  if (splitDecision.splitTest == null) {
-	    // preprune - null wins
-	    deactivateLearningNode(node, parent, parentIndex);
-	  } else {
-	    SplitNode newSplit = newSplitNode(splitDecision.splitTest,
-	      node.getObservedClassDistribution(), splitDecision.numSplits());
-	    for (int i = 0; i < splitDecision.numSplits(); i++) {
-
-	      double[] j = splitDecision.resultingClassDistributionFromSplit(i);
-
-	      Node newChild = newLearningNode(splitDecision.resultingClassDistributionFromSplit(i));
-
-	      if(splitDecision.splitTest.getClass() == NominalAttributeBinaryTest.class
-		||splitDecision.splitTest.getClass() == NominalAttributeMultiwayTest.class){
-		newChild.usedNominalAttributes = new ArrayList<Integer>(node.usedNominalAttributes); //deep copy
-		newChild.usedNominalAttributes.add(splitDecision.splitTest.getAttsTestDependsOn()[0]);
-		// no  nominal attribute should be split on more than once in the path
-	      }
-	      newSplit.setChild(i, newChild);
-	    }
-	    this.activeLeafNodeCount--;
-	    this.decisionNodeCount++;
-	    this.activeLeafNodeCount += splitDecision.numSplits();
-	    if (parent == null) {
-	      this.treeRoot = newSplit;
-	    } else {
-	      parent.setChild(parentIndex, newSplit);
-	    }
-
-	  }
-
-	  // manage memory
-	  enforceTrackerLimit();
-	}
-      }
-    }
-
-    @Override
-    protected LearningNode newLearningNode() {
-      return newLearningNode(new double[0]);
-    }
-
-    @Override
-    protected LearningNode newLearningNode(double[] initialClassObservations) {
-      LearningNode ret;
-      int predictionOption = this.leafpredictionOption.getChosenIndex();
-      if (predictionOption == 0) { //MC
-	ret = new ActiveLearningNode(initialClassObservations);
-      } else if (predictionOption == 1) { //NB
-	ret = new LearningNodeNB(initialClassObservations);
-      } else { //NBAdaptive
-	ret = new LearningNodeNBAdaptive(initialClassObservations);
-      }
-      return ret;
-    }
-
-    @Override
-    protected SplitNode newSplitNode(InstanceConditionalTest splitTest,
-				     double[] classObservations, int size) {
-      return new SplitNode(splitTest, classObservations, size);
-    }
-
-    @Override
-    protected SplitNode newSplitNode(InstanceConditionalTest splitTest,
-				     double[] classObservations) {
-      return new SplitNode(splitTest, classObservations);
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-      //System.err.println(i++);
-      if (this.treeRoot == null) {
-	this.treeRoot = newLearningNode();
-	this.activeLeafNodeCount = 1;
-      }
-      FoundNode foundNode = this.treeRoot.filterInstanceToLeaf(inst, null, -1);
-      Node leafNode = foundNode.node;
-
-      if (leafNode == null) {
-	leafNode = newLearningNode();
-	foundNode.parent.setChild(foundNode.parentBranch, leafNode);
-	this.activeLeafNodeCount++;
-      }
-
-      if (leafNode instanceof LearningNode) {
-	LearningNode learningNode = (LearningNode) leafNode;
-	learningNode.learnFromInstance(inst, this);
-	if (this.growthAllowed
-	  && (learningNode instanceof ActiveLearningNode)) {
-	  ActiveLearningNode activeLearningNode = (ActiveLearningNode) learningNode;
-	  double weightSeen = activeLearningNode.getWeightSeen();
-	  if (activeLearningNode.nodeTime % this.gracePeriodOption.getValue() == 0) {
-	    attemptToSplit(activeLearningNode, foundNode.parent,
-	      foundNode.parentBranch);
-	    activeLearningNode.setWeightSeenAtLastSplitEvaluation(weightSeen);
-	  }
-	}
-      }
-
-      if (this.trainingWeightSeenByModel
-	% this.memoryEstimatePeriodOption.getValue() == 0) {
-	estimateModelByteSizes();
-      }
-
-      numInstances++;
-    }
-  }
-}
diff --git a/moa/src/main/java/moa/classifiers/trees/HoeffdingAdaptiveTree.java b/moa/src/main/java/moa/classifiers/trees/HoeffdingAdaptiveTree.java
deleted file mode 100644
index 85231c60f..000000000
--- a/moa/src/main/java/moa/classifiers/trees/HoeffdingAdaptiveTree.java
+++ /dev/null
@@ -1,521 +0,0 @@
-/*
- *    HoeffdingAdaptiveTree.java
- *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.trees;
-
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Random;
-
-import moa.capabilities.Capability;
-import moa.capabilities.ImmutableCapabilities;
-import moa.classifiers.bayes.NaiveBayes;
-import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
-import moa.classifiers.core.driftdetection.ADWIN;
-import moa.core.DoubleVector;
-import moa.core.MiscUtils;
-import moa.core.Utils;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-/**
- * Hoeffding Adaptive Tree for evolving data streams.
- *
- * <p>This adaptive Hoeffding Tree uses ADWIN to monitor performance of
- * branches on the tree and to replace them with new branches when their
- * accuracy decreases if the new branches are more accurate.</p>
- * See details in:</p>
- * <p>Adaptive Learning from Evolving Data Streams. Albert Bifet, Ricard Gavaldà.
- * IDA 2009</p>
- *
- * <ul>
- * <li> Same parameters as <code>HoeffdingTreeNBAdaptive</code></li>
- * <li> -l : Leaf prediction to use: MajorityClass (MC), Naive Bayes (NB) or NaiveBayes
- * adaptive (NBAdaptive).
- * </ul>
- *
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @version $Revision: 7 $
- */
-public class HoeffdingAdaptiveTree extends HoeffdingTree {
-
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public String getPurposeString() {
-        return "Hoeffding Adaptive Tree for evolving data streams that uses ADWIN to replace branches for new ones.";
-    }
-    
- /*   public MultiChoiceOption leafpredictionOption = new MultiChoiceOption(
-            "leafprediction", 'l', "Leaf prediction to use.", new String[]{
-                "MC", "NB", "NBAdaptive"}, new String[]{
-                "Majority class",
-                "Naive Bayes",
-                "Naive Bayes Adaptive"}, 2);*/
-
-    public interface NewNode {
-
-        // Change for adwin
-        //public boolean getErrorChange();
-        public int numberLeaves();
-
-        public double getErrorEstimation();
-
-        public double getErrorWidth();
-
-        public boolean isNullError();
-
-        public void killTreeChilds(HoeffdingAdaptiveTree ht);
-
-        public void learnFromInstance(Instance inst, HoeffdingAdaptiveTree ht, SplitNode parent, int parentBranch);
-
-        public void filterInstanceToLeaves(Instance inst, SplitNode myparent, int parentBranch, List<FoundNode> foundNodes,
-                boolean updateSplitterCounts);
-    }
-
-    public static class AdaSplitNode extends SplitNode implements NewNode {
-
-        private static final long serialVersionUID = 1L;
-
-        protected Node alternateTree;
-
-        protected ADWIN estimationErrorWeight;
-        //public boolean isAlternateTree = false;
-
-        public boolean ErrorChange = false;
-
-        protected int randomSeed = 1;
-
-        protected Random classifierRandom;
-
-        //public boolean getErrorChange() {
-        //		return ErrorChange;
-        //}
-        @Override
-        public int calcByteSizeIncludingSubtree() {
-            int byteSize = calcByteSize();
-            if (alternateTree != null) {
-                byteSize += alternateTree.calcByteSizeIncludingSubtree();
-            }
-            if (estimationErrorWeight != null) {
-                byteSize += estimationErrorWeight.measureByteSize();
-            }
-            for (Node child : this.children) {
-                if (child != null) {
-                    byteSize += child.calcByteSizeIncludingSubtree();
-                }
-            }
-            return byteSize;
-        }
-        
-        public AdaSplitNode(InstanceConditionalTest splitTest,
-                double[] classObservations, int size) {
-            super(splitTest, classObservations, size);
-            this.classifierRandom = new Random(this.randomSeed);
-        }
-        
-        public AdaSplitNode(InstanceConditionalTest splitTest,
-                double[] classObservations) {
-            super(splitTest, classObservations);
-            this.classifierRandom = new Random(this.randomSeed);
-        }
-
-        @Override
-        public int numberLeaves() {
-            int numLeaves = 0;
-            for (Node child : this.children) {
-                if (child != null) {
-                    numLeaves += ((NewNode) child).numberLeaves();
-                }
-            }
-            return numLeaves;
-        }
-
-        @Override
-        public double getErrorEstimation() {
-            return this.estimationErrorWeight.getEstimation();
-        }
-
-        @Override
-        public double getErrorWidth() {
-            double w = 0.0;
-            if (isNullError() == false) {
-                w = this.estimationErrorWeight.getWidth();
-            }
-            return w;
-        }
-
-        @Override
-        public boolean isNullError() {
-            return (this.estimationErrorWeight == null);
-        }
-
-        // SplitNodes can have alternative trees, but LearningNodes can't
-        // LearningNodes can split, but SplitNodes can't
-        // Parent nodes are allways SplitNodes
-        @Override
-        public void learnFromInstance(Instance inst, HoeffdingAdaptiveTree ht, SplitNode parent, int parentBranch) {
-            int trueClass = (int) inst.classValue();
-            //New option vore
-            int k = MiscUtils.poisson(1.0, this.classifierRandom);
-            Instance weightedInst = (Instance) inst.copy();
-            if (k > 0) {
-                //weightedInst.setWeight(inst.weight() * k);
-            }
-            //Compute ClassPrediction using filterInstanceToLeaf
-            //int ClassPrediction = Utils.maxIndex(filterInstanceToLeaf(inst, null, -1).node.getClassVotes(inst, ht));
-            int ClassPrediction = 0;
-            if (filterInstanceToLeaf(inst, parent, parentBranch).node != null) {
-                ClassPrediction = Utils.maxIndex(filterInstanceToLeaf(inst, parent, parentBranch).node.getClassVotes(inst, ht));
-            }
-
-            boolean blCorrect = (trueClass == ClassPrediction);
-
-            if (this.estimationErrorWeight == null) {
-                this.estimationErrorWeight = new ADWIN();
-            }
-            double oldError = this.getErrorEstimation();
-            this.ErrorChange = this.estimationErrorWeight.setInput(blCorrect == true ? 0.0 : 1.0);
-            if (this.ErrorChange == true && oldError > this.getErrorEstimation()) {
-                //if error is decreasing, don't do anything
-                this.ErrorChange = false;
-            }
-
-            // Check condition to build a new alternate tree
-            //if (this.isAlternateTree == false) {
-            if (this.ErrorChange == true) {//&& this.alternateTree == null) {
-                //Start a new alternative tree : learning node
-                this.alternateTree = ht.newLearningNode();
-                //this.alternateTree.isAlternateTree = true;
-                ht.alternateTrees++;
-            } // Check condition to replace tree
-            else if (this.alternateTree != null && ((NewNode) this.alternateTree).isNullError() == false) {
-                if (this.getErrorWidth() > 300 && ((NewNode) this.alternateTree).getErrorWidth() > 300) {
-                    double oldErrorRate = this.getErrorEstimation();
-                    double altErrorRate = ((NewNode) this.alternateTree).getErrorEstimation();
-                    double fDelta = .05;
-                    //if (gNumAlts>0) fDelta=fDelta/gNumAlts;
-                    double fN = 1.0 / ((double) ((NewNode) this.alternateTree).getErrorWidth()) + 1.0 / ((double) this.getErrorWidth());
-                    double Bound = (double) Math.sqrt((double) 2.0 * oldErrorRate * (1.0 - oldErrorRate) * Math.log(2.0 / fDelta) * fN);
-                    if (Bound < oldErrorRate - altErrorRate) {
-                        // Switch alternate tree
-                        ht.activeLeafNodeCount -= this.numberLeaves();
-                        ht.activeLeafNodeCount += ((NewNode) this.alternateTree).numberLeaves();
-                        killTreeChilds(ht);
-                        if (parent != null) {
-                            parent.setChild(parentBranch, this.alternateTree);
-                            //((AdaSplitNode) parent.getChild(parentBranch)).alternateTree = null;
-                        } else {
-                            // Switch root tree
-                            ht.treeRoot = ((AdaSplitNode) ht.treeRoot).alternateTree;
-                        }
-                        ht.switchedAlternateTrees++;
-                    } else if (Bound < altErrorRate - oldErrorRate) {
-                        // Erase alternate tree
-                        if (this.alternateTree instanceof ActiveLearningNode) {
-                            this.alternateTree = null;
-                            //ht.activeLeafNodeCount--;
-                        } else if (this.alternateTree instanceof InactiveLearningNode) {
-                            this.alternateTree = null;
-                            //ht.inactiveLeafNodeCount--;
-                        } else {
-                            ((AdaSplitNode) this.alternateTree).killTreeChilds(ht);
-                        }
-                        ht.prunedAlternateTrees++;
-                    }
-                }
-            }
-            //}
-            //learnFromInstance alternate Tree and Child nodes
-            if (this.alternateTree != null) {
-                ((NewNode) this.alternateTree).learnFromInstance(weightedInst, ht, parent, parentBranch);
-            }
-            int childBranch = this.instanceChildIndex(inst);
-            Node child = this.getChild(childBranch);
-            if (child != null) {
-                ((NewNode) child).learnFromInstance(weightedInst, ht, this, childBranch);
-            }
-        }
-
-        @Override
-        public void killTreeChilds(HoeffdingAdaptiveTree ht) {
-            for (Node child : this.children) {
-                if (child != null) {
-                    //Delete alternate tree if it exists
-                    if (child instanceof AdaSplitNode && ((AdaSplitNode) child).alternateTree != null) {
-                        ((NewNode) ((AdaSplitNode) child).alternateTree).killTreeChilds(ht);
-                        ht.prunedAlternateTrees++;
-                    }
-                    //Recursive delete of SplitNodes
-                    if (child instanceof AdaSplitNode) {
-                        ((NewNode) child).killTreeChilds(ht);
-                    }
-                    if (child instanceof ActiveLearningNode) {
-                        child = null;
-                        ht.activeLeafNodeCount--;
-                    } else if (child instanceof InactiveLearningNode) {
-                        child = null;
-                        ht.inactiveLeafNodeCount--;
-                    }
-                }
-            }
-        }
-
-        //New for option votes
-        //@Override
-        public void filterInstanceToLeaves(Instance inst, SplitNode myparent,
-                int parentBranch, List<FoundNode> foundNodes,
-                boolean updateSplitterCounts) {
-            if (updateSplitterCounts) {
-                this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight());
-            }
-            int childIndex = instanceChildIndex(inst);
-            if (childIndex >= 0) {
-                Node child = getChild(childIndex);
-                if (child != null) {
-                    ((NewNode) child).filterInstanceToLeaves(inst, this, childIndex,
-                            foundNodes, updateSplitterCounts);
-                } else {
-                    foundNodes.add(new FoundNode(null, this, childIndex));
-                }
-            }
-            if (this.alternateTree != null) {
-                ((NewNode) this.alternateTree).filterInstanceToLeaves(inst, this, -999,
-                        foundNodes, updateSplitterCounts);
-            }
-        }
-    }
-
-    public static class AdaLearningNode extends LearningNodeNBAdaptive implements NewNode {
-
-        private static final long serialVersionUID = 1L;
-
-        protected ADWIN estimationErrorWeight;
-
-        public boolean ErrorChange = false;
-
-        protected int randomSeed = 1;
-
-        protected Random classifierRandom;
-
-        @Override
-        public int calcByteSize() {
-            int byteSize = super.calcByteSize();
-            if (estimationErrorWeight != null) {
-                byteSize += estimationErrorWeight.measureByteSize();
-            }
-            return byteSize;
-        }
-
-        public AdaLearningNode(double[] initialClassObservations) {
-            super(initialClassObservations);
-            this.classifierRandom = new Random(this.randomSeed);
-        }
-
-        @Override
-        public int numberLeaves() {
-            return 1;
-        }
-
-        @Override
-        public double getErrorEstimation() {
-            if (this.estimationErrorWeight != null) {
-                return this.estimationErrorWeight.getEstimation();
-            } else {
-                return 0;
-            }
-        }
-
-        @Override
-        public double getErrorWidth() {
-            return this.estimationErrorWeight.getWidth();
-        }
-
-        @Override
-        public boolean isNullError() {
-            return (this.estimationErrorWeight == null);
-        }
-
-        @Override
-        public void killTreeChilds(HoeffdingAdaptiveTree ht) {
-        }
-
-        @Override
-        public void learnFromInstance(Instance inst, HoeffdingAdaptiveTree ht, SplitNode parent, int parentBranch) {
-            int trueClass = (int) inst.classValue();
-            //New option vore
-            int k = MiscUtils.poisson(1.0, this.classifierRandom);
-            Instance weightedInst = (Instance) inst.copy();
-            if (k > 0) {
-                weightedInst.setWeight(inst.weight() * k);
-            }
-            //Compute ClassPrediction using filterInstanceToLeaf
-            int ClassPrediction = Utils.maxIndex(this.getClassVotes(inst, ht));
-
-            boolean blCorrect = (trueClass == ClassPrediction);
-
-            if (this.estimationErrorWeight == null) {
-                this.estimationErrorWeight = new ADWIN();
-            }
-            double oldError = this.getErrorEstimation();
-            this.ErrorChange = this.estimationErrorWeight.setInput(blCorrect == true ? 0.0 : 1.0);
-            if (this.ErrorChange == true && oldError > this.getErrorEstimation()) {
-                this.ErrorChange = false;
-            }
-
-            //Update statistics
-            learnFromInstance(weightedInst, ht);	//inst
-
-            //Check for Split condition
-            double weightSeen = this.getWeightSeen();
-            if (weightSeen
-                    - this.getWeightSeenAtLastSplitEvaluation() >= ht.gracePeriodOption.getValue()) {
-                ht.attemptToSplit(this, parent,
-                        parentBranch);
-                this.setWeightSeenAtLastSplitEvaluation(weightSeen);
-            }
-
-
-            //learnFromInstance alternate Tree and Child nodes
-			/*if (this.alternateTree != null)  {
-            this.alternateTree.learnFromInstance(inst,ht);
-            }
-            for (Node child : this.children) {
-            if (child != null) {
-            child.learnFromInstance(inst,ht);
-            }
-            }*/
-        }
-
-        @Override
-        public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
-            double[] dist;
-            int predictionOption = ((HoeffdingAdaptiveTree) ht).leafpredictionOption.getChosenIndex();
-            if (predictionOption == 0) { //MC
-                dist = this.observedClassDistribution.getArrayCopy();
-            } else if (predictionOption == 1) { //NB
-                dist = NaiveBayes.doNaiveBayesPrediction(inst,
-                        this.observedClassDistribution, this.attributeObservers);
-            } else { //NBAdaptive
-                if (this.mcCorrectWeight > this.nbCorrectWeight) {
-                    dist = this.observedClassDistribution.getArrayCopy();
-                } else {
-                    dist = NaiveBayes.doNaiveBayesPrediction(inst,
-                            this.observedClassDistribution, this.attributeObservers);
-                }
-            }
-            //New for option votes
-            double distSum = Utils.sum(dist);
-            if (distSum * this.getErrorEstimation() * this.getErrorEstimation() > 0.0) {
-                Utils.normalize(dist, distSum * this.getErrorEstimation() * this.getErrorEstimation()); //Adding weight
-            }
-            return dist;
-        }
-
-        //New for option votes
-        @Override
-        public void filterInstanceToLeaves(Instance inst,
-                SplitNode splitparent, int parentBranch,
-                List<FoundNode> foundNodes, boolean updateSplitterCounts) {
-            foundNodes.add(new FoundNode(this, splitparent, parentBranch));
-        }
-    }
-
-    protected int alternateTrees;
-
-    protected int prunedAlternateTrees;
-
-    protected int switchedAlternateTrees;
-
-    @Override
-    protected LearningNode newLearningNode(double[] initialClassObservations) {
-        // IDEA: to choose different learning nodes depending on predictionOption
-        return new AdaLearningNode(initialClassObservations);
-    }
-
-   @Override
-    protected SplitNode newSplitNode(InstanceConditionalTest splitTest,
-            double[] classObservations, int size) {
-        return new AdaSplitNode(splitTest, classObservations, size);
-    }
-   
-    @Override
-    protected SplitNode newSplitNode(InstanceConditionalTest splitTest,
-            double[] classObservations) {
-        return new AdaSplitNode(splitTest, classObservations);
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        if (this.treeRoot == null) {
-            this.treeRoot = newLearningNode();
-            this.activeLeafNodeCount = 1;
-        }
-        ((NewNode) this.treeRoot).learnFromInstance(inst, this, null, -1);
-    }
-
-    //New for options vote
-    public FoundNode[] filterInstanceToLeaves(Instance inst,
-            SplitNode parent, int parentBranch, boolean updateSplitterCounts) {
-        List<FoundNode> nodes = new LinkedList<FoundNode>();
-        ((NewNode) this.treeRoot).filterInstanceToLeaves(inst, parent, parentBranch, nodes,
-                updateSplitterCounts);
-        return nodes.toArray(new FoundNode[nodes.size()]);
-    }
-
-    @Override
-    public Prediction getPredictionForInstance(Instance inst) {
-        if (this.treeRoot != null) {
-            FoundNode[] foundNodes = filterInstanceToLeaves(inst,
-                    null, -1, false);
-            DoubleVector result = new DoubleVector();
-            int predictionPaths = 0;
-            for (FoundNode foundNode : foundNodes) {
-                if (foundNode.parentBranch != -999) {
-                    Node leafNode = foundNode.node;
-                    if (leafNode == null) {
-                        leafNode = foundNode.parent;
-                    }
-                    double[] dist = leafNode.getClassVotes(inst, this);
-                    //Albert: changed for weights
-                    //double distSum = Utils.sum(dist);
-                    //if (distSum > 0.0) {
-                    //	Utils.normalize(dist, distSum);
-                    //}
-                    result.addValues(dist);
-                    //predictionPaths++;
-                }
-            }
-            //if (predictionPaths > this.maxPredictionPaths) {
-            //	this.maxPredictionPaths++;
-            //}
-            return new ClassificationPrediction(result.getArrayRef());
-        }
-        return new ClassificationPrediction();
-    }
-
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == HoeffdingAdaptiveTree.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/trees/HoeffdingAdaptiveTreeClassifLeaves.java b/moa/src/main/java/moa/classifiers/trees/HoeffdingAdaptiveTreeClassifLeaves.java
deleted file mode 100644
index 43888a61f..000000000
--- a/moa/src/main/java/moa/classifiers/trees/HoeffdingAdaptiveTreeClassifLeaves.java
+++ /dev/null
@@ -1,189 +0,0 @@
-/*
- *    HoeffdingAdaptiveTreeClassifLeaves.java
- *    Copyright (C) 2016 Pontifical Catholic University of Paraná, Curitiba, Brazil
- *    @author Jean Paul Barddal (jean.barddal@ppgia.pucpr.br)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.trees;
-
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.Set;
-
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.learners.Classifier;
-import moa.options.ClassOption;
-
-/**
- * Hoeffding Adaptive Tree for evolving data streams that has a classifier at
- * the leaves.
- *
- * @version 1.0
- * @see First used in the data stream configuration in J. P. Barddal, H. M.
- * Gomes, F. Enembreck, B. Pfahringer & A. Bifet. ON DYNAMIC FEATURE WEIGHTING
- * FOR FEATURE DRIFTING DATA STREAMS. In European Conference on Machine Learning
- * and Principles and Practice of Knowledge Discovery (ECML/PKDD'16). 2016.
- */
-public class HoeffdingAdaptiveTreeClassifLeaves extends HoeffdingAdaptiveTree {
-
-    public ClassOption leaveLearnerOption = new ClassOption("leaveLearner", 'a',
-	    "Classifier to train.", Classifier.class, "bayes.NaiveBayes");
-
-    public HoeffdingAdaptiveTreeClassifLeaves() {
-	this.removePoorAttsOption = null;
-    }
-
-    @Override
-    protected LearningNode newLearningNode(double[] initialClassObservations) {
-	return new LearningNodeHATClassifier(initialClassObservations, null, this);
-    }
-
-    //@Override
-    protected LearningNode newLearningNode(double[] initialClassObservations, Classifier cl) {
-	return new LearningNodeHATClassifier(initialClassObservations, cl, this);
-    }
-
-    @Override
-    protected void attemptToSplit(ActiveLearningNode node,
-	    SplitNode parent,
-	    int parentIndex) {
-	if (!node.observedClassDistributionIsPure()) {
-	    SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
-	    AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion, this);
-	    Arrays.sort(bestSplitSuggestions);
-	    boolean shouldSplit = false;
-	    if (bestSplitSuggestions.length < 2) {
-		shouldSplit = bestSplitSuggestions.length > 0;
-	    } else {
-		double hoeffdingBound = computeHoeffdingBound(splitCriterion.getRangeOfMerit(node.getObservedClassDistribution()),
-			this.splitConfidenceOption.getValue(), node.getWeightSeen());
-		AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-		AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
-
-		if ((bestSuggestion.merit - secondBestSuggestion.merit > hoeffdingBound)
-			|| (hoeffdingBound < this.tieThresholdOption.getValue())) {
-		    shouldSplit = true;
-		}
-
-		if ((this.removePoorAttsOption != null)
-			&& this.removePoorAttsOption.isSet()) {
-		    Set<Integer> poorAtts = new HashSet<Integer>();
-		    // scan 1 - add any poor to set
-		    for (int i = 0; i < bestSplitSuggestions.length; i++) {
-			if (bestSplitSuggestions[i].splitTest != null) {
-			    int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
-			    if (splitAtts.length == 1) {
-				if (bestSuggestion.merit
-					- bestSplitSuggestions[i].merit > hoeffdingBound) {
-				    poorAtts.add(new Integer(splitAtts[0]));
-				}
-			    }
-			}
-		    }
-		    // scan 2 - remove good ones from set
-		    for (int i = 0; i < bestSplitSuggestions.length; i++) {
-			if (bestSplitSuggestions[i].splitTest != null) {
-			    int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
-			    if (splitAtts.length == 1) {
-				if (bestSuggestion.merit
-					- bestSplitSuggestions[i].merit < hoeffdingBound) {
-				    poorAtts.remove(new Integer(splitAtts[0]));
-				}
-			    }
-			}
-		    }
-		    for (int poorAtt : poorAtts) {
-			node.disableAttribute(poorAtt);
-		    }
-		}
-	    }
-	    if (shouldSplit) {
-		AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-		if (splitDecision.splitTest == null) {
-		    // preprune - null wins
-		    deactivateLearningNode(node, parent, parentIndex);
-		} else {
-		    SplitNode newSplit = newSplitNode(splitDecision.splitTest,
-			    node.getObservedClassDistribution());
-		    for (int i = 0; i < splitDecision.numSplits(); i++) {
-			//Unique Change of HoeffdingTree
-			Node newChild = newLearningNode(splitDecision.resultingClassDistributionFromSplit(i), ((LearningNodeHATClassifier) node).getClassifier());
-			newSplit.setChild(i, newChild);
-		    }
-		    this.activeLeafNodeCount--;
-		    this.decisionNodeCount++;
-		    this.activeLeafNodeCount += splitDecision.numSplits();
-		    if (parent == null) {
-			this.treeRoot = newSplit;
-		    } else {
-			parent.setChild(parentIndex, newSplit);
-		    }
-		}
-		// manage memory
-		enforceTrackerLimit();
-	    }
-	}
-    }
-
-    public class LearningNodeHATClassifier extends AdaLearningNode  {
-
-	protected Classifier classifier;
-
-	public LearningNodeHATClassifier(double[] initialClassObservations) {
-	    super(initialClassObservations);
-	}
-
-	public LearningNodeHATClassifier(double[] initialClassObservations,
-		Classifier cl,
-		HoeffdingAdaptiveTreeClassifLeaves ht) {
-	    super(initialClassObservations);
-
-	    if (cl == null) {
-		this.classifier = (Classifier) getPreparedClassOption(ht.leaveLearnerOption);
-	    } else {
-		this.classifier = (Classifier) cl.copy();
-	    }
-	}
-
-	@Override
-	public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
-	    if (getWeightSeen() >= ((HoeffdingAdaptiveTreeClassifLeaves) ht).nbThresholdOption.getValue()) {
-		return this.classifier.getPredictionForInstance(inst).asDoubleArray();
-	    }
-	    return super.getClassVotes(inst, ht);
-	}
-
-	@Override
-	public void disableAttribute(int attIndex) {
-	    // should not disable poor atts - they are used in NB calc
-	}
-
-	@Override
-	public void learnFromInstance(Instance inst, HoeffdingTree ht) {
-	    this.classifier.trainOnInstance(inst);
-	    super.learnFromInstance(inst, ht);
-	}
-
-	public Classifier getClassifier() {
-	    return this.classifier;
-	}
-
-    }
-
-}
diff --git a/moa/src/main/java/moa/classifiers/trees/HoeffdingOptionTree.java b/moa/src/main/java/moa/classifiers/trees/HoeffdingOptionTree.java
deleted file mode 100644
index d328e3208..000000000
--- a/moa/src/main/java/moa/classifiers/trees/HoeffdingOptionTree.java
+++ /dev/null
@@ -1,1219 +0,0 @@
-/*
- *    HoeffdingOptionTree.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.trees;
-
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.PrintStream;
-import java.util.Arrays;
-import java.util.Comparator;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Set;
-
-import com.github.javacliparser.FileOption;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.AbstractMOAObject;
-import moa.capabilities.CapabilitiesHandler;
-import moa.capabilities.Capability;
-import moa.capabilities.ImmutableCapabilities;
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.bayes.NaiveBayes;
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.DiscreteAttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.NullAttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.NumericAttributeClassObserver;
-import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
-import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.core.AutoExpandVector;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.core.SizeOf;
-import moa.core.StringUtils;
-import moa.core.Utils;
-import moa.learners.Classifier;
-import moa.options.ClassOption;
-
-/**
- * Hoeffding Option Tree.
- *
- * <p>Hoeffding Option Trees are regular Hoeffding trees containing additional
- * option nodes that allow several tests to be applied, leading to multiple
- * Hoeffding trees as separate paths. They consist of a single structure that
- * efficiently represents multiple trees. A particular example can travel down
- * multiple paths of the tree, contributing, in different ways, to different
- * options.</p>
- *
- * <p>See for details:</p> <p>B. Pfahringer, G. Holmes, and R. Kirkby. New
- * options for hoeffding trees. In AI, pages 90–99, 2007.</p>
- *
- * <p>Parameters:</p> <ul> <li>-o : Maximum number of option paths per node</li>
- * <li>-m : Maximum memory consumed by the tree</li> <li>-n : Numeric estimator
- * to use :</li> <ul> <li> Gaussian approximation evaluating 10 splitpoints</li>
- * <li> Gaussian approximation evaluating 100 splitpoints</li> <li>
- * Greenwald-Khanna quantile summary with 10 tuples</li> <li> Greenwald-Khanna
- * quantile summary with 100 tuples</li> <li> Greenwald-Khanna quantile summary
- * with 1000 tuples</li> <li> VFML method with 10 bins</li> <li> VFML method
- * with 100 bins</li> <li> VFML method with 1000 bins</li> <li> Exhaustive
- * binary tree</li> </ul> <li>-e : How many instances between memory consumption
- * checks</li> <li>-g : The number of instances a leaf should observe between
- * split attempts</li> <li>-s : Split criterion to use. Example :
- * InfoGainSplitCriterion</li> <li>-c : The allowable error in split decision,
- * values closer to 0 will take longer to decide</li> <li>-w : The allowable
- * error in secondary split decisions, values closer to 0 will take longer to
- * decide</li> <li>-t : Threshold below which a split will be forced to break
- * ties</li> <li>-b : Only allow binary splits</li> <li>-z : Memory strategy to
- * use</li> <li>-r : Disable poor attributes</li> <li>-p : Disable
- * pre-pruning</li> <li>-d : File to append option table to.</li> 
- *  <li> -l : Leaf prediction to use: MajorityClass (MC), Naive Bayes (NB) or NaiveBayes
- * adaptive (NBAdaptive).</li>
- *  <li> -q : The number of instances a leaf should observe before
- * permitting Naive Bayes</li>
- * </ul>
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $
- */
-public class HoeffdingOptionTree extends AbstractClassifier implements Classifier, CapabilitiesHandler {
-
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public String getPurposeString() {
-        return "Hoeffding Option Tree: single tree that represents multiple trees.";
-    }
-
-    public IntOption maxOptionPathsOption = new IntOption("maxOptionPaths",
-            'o', "Maximum number of option paths per node.", 5, 1,
-            Integer.MAX_VALUE);
-
-    public IntOption maxByteSizeOption = new IntOption("maxByteSize", 'm',
-            "Maximum memory consumed by the tree.", 33554432, 0,
-            Integer.MAX_VALUE);
-
-    /*
-     * public MultiChoiceOption numericEstimatorOption = new MultiChoiceOption(
-     * "numericEstimator", 'n', "Numeric estimator to use.", new String[]{
-     * "GAUSS10", "GAUSS100", "GK10", "GK100", "GK1000", "VFML10", "VFML100",
-     * "VFML1000", "BINTREE"}, new String[]{ "Gaussian approximation evaluating
-     * 10 splitpoints", "Gaussian approximation evaluating 100 splitpoints",
-     * "Greenwald-Khanna quantile summary with 10 tuples", "Greenwald-Khanna
-     * quantile summary with 100 tuples", "Greenwald-Khanna quantile summary
-     * with 1000 tuples", "VFML method with 10 bins", "VFML method with 100
-     * bins", "VFML method with 1000 bins", "Exhaustive binary tree"}, 0);
-     */
-    public ClassOption numericEstimatorOption = new ClassOption("numericEstimator",
-            'n', "Numeric estimator to use.", NumericAttributeClassObserver.class,
-            "GaussianNumericAttributeClassObserver");
-
-    public ClassOption nominalEstimatorOption = new ClassOption("nominalEstimator",
-            'd', "Nominal estimator to use.", DiscreteAttributeClassObserver.class,
-            "NominalAttributeClassObserver");
-
-    public IntOption memoryEstimatePeriodOption = new IntOption(
-            "memoryEstimatePeriod", 'e',
-            "How many instances between memory consumption checks.", 1000000,
-            0, Integer.MAX_VALUE);
-
-    public IntOption gracePeriodOption = new IntOption(
-            "gracePeriod",
-            'g',
-            "The number of instances a leaf should observe between split attempts.",
-            200, 0, Integer.MAX_VALUE);
-
-    public ClassOption splitCriterionOption = new ClassOption("splitCriterion",
-            's', "Split criterion to use.", SplitCriterion.class,
-            "InfoGainSplitCriterion");
-
-    public FloatOption splitConfidenceOption = new FloatOption(
-            "splitConfidence",
-            'c',
-            "The allowable error in split decision, values closer to 0 will take longer to decide.",
-            0.0000001, 0.0, 1.0);
-
-    public FloatOption secondarySplitConfidenceOption = new FloatOption(
-            "secondarySplitConfidence",
-            'w',
-            "The allowable error in secondary split decisions, values closer to 0 will take longer to decide.",
-            0.1, 0.0, 1.0);
-
-    public FloatOption tieThresholdOption = new FloatOption("tieThreshold",
-            't', "Threshold below which a split will be forced to break ties.",
-            0.05, 0.0, 1.0);
-
-    public FlagOption binarySplitsOption = new FlagOption("binarySplits", 'b',
-            "Only allow binary splits.");
-
-    public FlagOption removePoorAttsOption = new FlagOption("removePoorAtts",
-            'r', "Disable poor attributes.");
-
-    public FlagOption noPrePruneOption = new FlagOption("noPrePrune", 'p',
-            "Disable pre-pruning.");
-
-    public FileOption dumpFileOption = new FileOption("dumpFile", 'f',
-            "File to append option table to.", null, "csv", true);
-
-    public IntOption memoryStrategyOption = new IntOption("memStrategy", 'z',
-            "Memory strategy to use.", 2);
-
-    public static class FoundNode {
-
-        public Node node;
-
-        public SplitNode parent;
-
-        public int parentBranch; // set to -999 for option leaves
-
-        public FoundNode(Node node, SplitNode parent, int parentBranch) {
-            this.node = node;
-            this.parent = parent;
-            this.parentBranch = parentBranch;
-        }
-    }
-
-    public static class Node extends AbstractMOAObject {
-
-        private static final long serialVersionUID = 1L;
-
-        protected DoubleVector observedClassDistribution;
-
-        public Node(double[] classObservations) {
-            this.observedClassDistribution = new DoubleVector(classObservations);
-        }
-
-        public int calcByteSize() {
-            return (int) (SizeOf.sizeOf(this) + SizeOf.fullSizeOf(this.observedClassDistribution));
-        }
-
-        public int calcByteSizeIncludingSubtree() {
-            return calcByteSize();
-        }
-
-        public boolean isLeaf() {
-            return true;
-        }
-
-        public FoundNode[] filterInstanceToLeaves(Instance inst,
-                SplitNode parent, int parentBranch, boolean updateSplitterCounts) {
-            List<FoundNode> nodes = new LinkedList<FoundNode>();
-            filterInstanceToLeaves(inst, parent, parentBranch, nodes,
-                    updateSplitterCounts);
-            return nodes.toArray(new FoundNode[nodes.size()]);
-        }
-
-        public void filterInstanceToLeaves(Instance inst,
-                SplitNode splitparent, int parentBranch,
-                List<FoundNode> foundNodes, boolean updateSplitterCounts) {
-            foundNodes.add(new FoundNode(this, splitparent, parentBranch));
-        }
-
-        public double[] getObservedClassDistribution() {
-            return this.observedClassDistribution.getArrayCopy();
-        }
-
-        public double[] getClassVotes(Instance inst, HoeffdingOptionTree ht) {
-            double[] dist = this.observedClassDistribution.getArrayCopy();
-            double distSum = Utils.sum(dist);
-            if (distSum > 0.0) {
-                Utils.normalize(dist, distSum);
-            }
-            return dist;
-        }
-
-        public boolean observedClassDistributionIsPure() {
-            return this.observedClassDistribution.numNonZeroEntries() < 2;
-        }
-
-        public void describeSubtree(HoeffdingOptionTree ht, StringBuilder out,
-                int indent) {
-            StringUtils.appendIndented(out, indent, "Leaf ");
-            out.append(ht.getClassNameString());
-            out.append(" = ");
-            out.append(ht.getClassLabelString(this.observedClassDistribution.maxIndex()));
-            out.append(" weights: ");
-            this.observedClassDistribution.getSingleLineDescription(out,
-                    ht.treeRoot.observedClassDistribution.numValues());
-            StringUtils.appendNewline(out);
-        }
-
-        public int subtreeDepth() {
-            return 0;
-        }
-
-        public double calculatePromise() {
-            double totalSeen = this.observedClassDistribution.sumOfValues();
-            return totalSeen > 0.0 ? (totalSeen - this.observedClassDistribution.getValue(this.observedClassDistribution.maxIndex()))
-                    : 0.0;
-        }
-
-        public void getDescription(StringBuilder sb, int indent) {
-            describeSubtree(null, sb, indent);
-        }
-    }
-
-    public static class SplitNode extends Node {
-
-        private static final long serialVersionUID = 1L;
-
-        protected InstanceConditionalTest splitTest;
-
-        protected SplitNode parent;
-
-        protected Node nextOption;
-
-        protected int optionCount; // set to -999 for optional splits
-
-        protected AutoExpandVector<Node> children = new AutoExpandVector<Node>();
-
-        @Override
-        public int calcByteSize() {
-            return super.calcByteSize()
-                    + (int) (SizeOf.sizeOf(this.children) + SizeOf.fullSizeOf(this.splitTest));
-        }
-
-        @Override
-        public int calcByteSizeIncludingSubtree() {
-            int byteSize = calcByteSize();
-            for (Node child : this.children) {
-                if (child != null) {
-                    byteSize += child.calcByteSizeIncludingSubtree();
-                }
-            }
-            if (this.nextOption != null) {
-                byteSize += this.nextOption.calcByteSizeIncludingSubtree();
-            }
-            return byteSize;
-        }
-
-        public SplitNode(InstanceConditionalTest splitTest,
-                double[] classObservations) {
-            super(classObservations);
-            this.splitTest = splitTest;
-        }
-
-        public int numChildren() {
-            return this.children.size();
-        }
-
-        public void setChild(int index, Node child) {
-            if ((this.splitTest.maxBranches() >= 0)
-                    && (index >= this.splitTest.maxBranches())) {
-                throw new IndexOutOfBoundsException();
-            }
-            this.children.set(index, child);
-        }
-
-        public Node getChild(int index) {
-            return this.children.get(index);
-        }
-
-        public int instanceChildIndex(Instance inst) {
-            return this.splitTest.branchForInstance(inst);
-        }
-
-        @Override
-        public boolean isLeaf() {
-            return false;
-        }
-
-        @Override
-        public void filterInstanceToLeaves(Instance inst, SplitNode myparent,
-                int parentBranch, List<FoundNode> foundNodes,
-                boolean updateSplitterCounts) {
-            if (updateSplitterCounts) {
-                this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight());
-            }
-            int childIndex = instanceChildIndex(inst);
-            if (childIndex >= 0) {
-                Node child = getChild(childIndex);
-                if (child != null) {
-                    child.filterInstanceToLeaves(inst, this, childIndex,
-                            foundNodes, updateSplitterCounts);
-                } else {
-                    foundNodes.add(new FoundNode(null, this, childIndex));
-                }
-            }
-            if (this.nextOption != null) {
-                this.nextOption.filterInstanceToLeaves(inst, this, -999,
-                        foundNodes, updateSplitterCounts);
-            }
-        }
-
-        @Override
-        public void describeSubtree(HoeffdingOptionTree ht, StringBuilder out,
-                int indent) {
-            for (int branch = 0; branch < numChildren(); branch++) {
-                Node child = getChild(branch);
-                if (child != null) {
-                    StringUtils.appendIndented(out, indent, "if ");
-                    out.append(this.splitTest.describeConditionForBranch(branch,
-                            ht.getModelContext()));
-                    out.append(": ");
-                    out.append("** option count = " + this.optionCount);
-                    StringUtils.appendNewline(out);
-                    child.describeSubtree(ht, out, indent + 2);
-                }
-            }
-        }
-
-        @Override
-        public int subtreeDepth() {
-            int maxChildDepth = 0;
-            for (Node child : this.children) {
-                if (child != null) {
-                    int depth = child.subtreeDepth();
-                    if (depth > maxChildDepth) {
-                        maxChildDepth = depth;
-                    }
-                }
-            }
-            return maxChildDepth + 1;
-        }
-
-        public double computeMeritOfExistingSplit(
-                SplitCriterion splitCriterion, double[] preDist) {
-            double[][] postDists = new double[this.children.size()][];
-            for (int i = 0; i < this.children.size(); i++) {
-                postDists[i] = this.children.get(i).getObservedClassDistribution();
-            }
-            return splitCriterion.getMeritOfSplit(preDist, postDists);
-        }
-
-        public void updateOptionCount(SplitNode source, HoeffdingOptionTree hot) {
-            if (this.optionCount == -999) {
-                this.parent.updateOptionCount(source, hot);
-            } else {
-                int maxChildCount = -999;
-                SplitNode curr = this;
-                while (curr != null) {
-                    for (Node child : curr.children) {
-                        if (child instanceof SplitNode) {
-                            SplitNode splitChild = (SplitNode) child;
-                            if (splitChild.optionCount > maxChildCount) {
-                                maxChildCount = splitChild.optionCount;
-                            }
-                        }
-                    }
-                    if ((curr.nextOption != null)
-                            && (curr.nextOption instanceof SplitNode)) {
-                        curr = (SplitNode) curr.nextOption;
-                    } else {
-                        curr = null;
-                    }
-                }
-                if (maxChildCount > this.optionCount) { // currently only works
-                    // one
-                    // way - adding, not
-                    // removing
-                    int delta = maxChildCount - this.optionCount;
-                    this.optionCount = maxChildCount;
-                    if (this.optionCount >= hot.maxOptionPathsOption.getValue()) {
-                        killOptionLeaf(hot);
-                    }
-                    curr = this;
-                    while (curr != null) {
-                        for (Node child : curr.children) {
-                            if (child instanceof SplitNode) {
-                                SplitNode splitChild = (SplitNode) child;
-                                if (splitChild != source) {
-                                    splitChild.updateOptionCountBelow(delta,
-                                            hot);
-                                }
-                            }
-                        }
-                        if ((curr.nextOption != null)
-                                && (curr.nextOption instanceof SplitNode)) {
-                            curr = (SplitNode) curr.nextOption;
-                        } else {
-                            curr = null;
-                        }
-                    }
-                    if (this.parent != null) {
-                        this.parent.updateOptionCount(this, hot);
-                    }
-                }
-            }
-        }
-
-        public void updateOptionCountBelow(int delta, HoeffdingOptionTree hot) {
-            if (this.optionCount != -999) {
-                this.optionCount += delta;
-                if (this.optionCount >= hot.maxOptionPathsOption.getValue()) {
-                    killOptionLeaf(hot);
-                }
-            }
-            for (Node child : this.children) {
-                if (child instanceof SplitNode) {
-                    SplitNode splitChild = (SplitNode) child;
-                    splitChild.updateOptionCountBelow(delta, hot);
-                }
-            }
-            if (this.nextOption instanceof SplitNode) {
-                ((SplitNode) this.nextOption).updateOptionCountBelow(delta, hot);
-            }
-        }
-
-        private void killOptionLeaf(HoeffdingOptionTree hot) {
-            if (this.nextOption instanceof SplitNode) {
-                ((SplitNode) this.nextOption).killOptionLeaf(hot);
-            } else if (this.nextOption instanceof ActiveLearningNode) {
-                this.nextOption = null;
-                hot.activeLeafNodeCount--;
-            } else if (this.nextOption instanceof InactiveLearningNode) {
-                this.nextOption = null;
-                hot.inactiveLeafNodeCount--;
-            }
-        }
-
-        public int getHeadOptionCount() {
-            SplitNode sn = this;
-            while (sn.optionCount == -999) {
-                sn = sn.parent;
-            }
-            return sn.optionCount;
-        }
-    }
-
-    public static abstract class LearningNode extends Node {
-
-        private static final long serialVersionUID = 1L;
-
-        public LearningNode(double[] initialClassObservations) {
-            super(initialClassObservations);
-        }
-
-        public abstract void learnFromInstance(Instance inst,
-                HoeffdingOptionTree ht);
-    }
-
-    public static class InactiveLearningNode extends LearningNode {
-
-        private static final long serialVersionUID = 1L;
-
-        public InactiveLearningNode(double[] initialClassObservations) {
-            super(initialClassObservations);
-        }
-
-        @Override
-        public void learnFromInstance(Instance inst, HoeffdingOptionTree ht) {
-            this.observedClassDistribution.addToValue((int) inst.classValue(),
-                    inst.weight());
-        }
-    }
-
-    public static class ActiveLearningNode extends LearningNode {
-
-        private static final long serialVersionUID = 1L;
-
-        protected double weightSeenAtLastSplitEvaluation;
-
-        protected AutoExpandVector<AttributeClassObserver> attributeObservers = new AutoExpandVector<AttributeClassObserver>();
-
-        public ActiveLearningNode(double[] initialClassObservations) {
-            super(initialClassObservations);
-            this.weightSeenAtLastSplitEvaluation = getWeightSeen();
-        }
-
-        @Override
-        public int calcByteSize() {
-            return super.calcByteSize()
-                    + (int) (SizeOf.fullSizeOf(this.attributeObservers));
-        }
-
-        @Override
-        public void learnFromInstance(Instance inst, HoeffdingOptionTree ht) {
-            this.observedClassDistribution.addToValue((int) inst.classValue(),
-                    inst.weight());
-            for (int i = 0; i < inst.numAttributes() - 1; i++) {
-                int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
-                AttributeClassObserver obs = this.attributeObservers.get(i);
-                if (obs == null) {
-                    obs = inst.attribute(instAttIndex).isNominal() ? ht.newNominalClassObserver() : ht.newNumericClassObserver();
-                    this.attributeObservers.set(i, obs);
-                }
-                obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
-            }
-        }
-
-        public double getWeightSeen() {
-            return this.observedClassDistribution.sumOfValues();
-        }
-
-        public double getWeightSeenAtLastSplitEvaluation() {
-            return this.weightSeenAtLastSplitEvaluation;
-        }
-
-        public void setWeightSeenAtLastSplitEvaluation(double weight) {
-            this.weightSeenAtLastSplitEvaluation = weight;
-        }
-
-        public AttributeSplitSuggestion[] getBestSplitSuggestions(
-                SplitCriterion criterion, HoeffdingOptionTree ht) {
-            List<AttributeSplitSuggestion> bestSuggestions = new LinkedList<AttributeSplitSuggestion>();
-            double[] preSplitDist = this.observedClassDistribution.getArrayCopy();
-            if (!ht.noPrePruneOption.isSet()) {
-                // add null split as an option
-                bestSuggestions.add(new AttributeSplitSuggestion(null,
-                        new double[0][], criterion.getMeritOfSplit(
-                        preSplitDist,
-                        new double[][]{preSplitDist})));
-            }
-            for (int i = 0; i < this.attributeObservers.size(); i++) {
-                AttributeClassObserver obs = this.attributeObservers.get(i);
-                if (obs != null) {
-                    AttributeSplitSuggestion bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion,
-                            preSplitDist, i, ht.binarySplitsOption.isSet());
-                    if (bestSuggestion != null) {
-                        bestSuggestions.add(bestSuggestion);
-                    }
-                }
-            }
-            return bestSuggestions.toArray(new AttributeSplitSuggestion[bestSuggestions.size()]);
-        }
-
-        public void disableAttribute(int attIndex) {
-            this.attributeObservers.set(attIndex,
-                    new NullAttributeClassObserver());
-        }
-    }
-
-    protected Node treeRoot;
-
-    protected int decisionNodeCount;
-
-    protected int activeLeafNodeCount;
-
-    protected int inactiveLeafNodeCount;
-
-    protected double inactiveLeafByteSizeEstimate;
-
-    protected double activeLeafByteSizeEstimate;
-
-    protected double byteSizeEstimateOverheadFraction;
-
-    protected int maxPredictionPaths;
-
-    public long calcByteSize() {
-        long size = SizeOf.sizeOf(this);
-        if (this.treeRoot != null) {
-            size += this.treeRoot.calcByteSizeIncludingSubtree();
-        }
-        return size;
-    }
-
-    @Override
-    public long measureByteSize() {
-        return calcByteSize();
-    }
-
-    @Override
-    public void resetLearningImpl() {
-        this.treeRoot = null;
-        this.decisionNodeCount = 0;
-        this.activeLeafNodeCount = 0;
-        this.inactiveLeafNodeCount = 0;
-        this.inactiveLeafByteSizeEstimate = 0.0;
-        this.activeLeafByteSizeEstimate = 0.0;
-        this.byteSizeEstimateOverheadFraction = 1.0;
-        this.maxPredictionPaths = 0;
-        if (this.leafpredictionOption.getChosenIndex() > 0) {
-            this.removePoorAttsOption = null;
-        }
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        if (this.treeRoot == null) {
-            this.treeRoot = newLearningNode();
-            this.activeLeafNodeCount = 1;
-        }
-        FoundNode[] foundNodes = this.treeRoot.filterInstanceToLeaves(inst,
-                null, -1, true);
-        for (FoundNode foundNode : foundNodes) {
-            // option leaves will have a parentBranch of -999
-            // option splits will have an option count of -999
-            Node leafNode = foundNode.node;
-            if (leafNode == null) {
-                leafNode = newLearningNode();
-                foundNode.parent.setChild(foundNode.parentBranch, leafNode);
-                this.activeLeafNodeCount++;
-            }
-            if (leafNode instanceof LearningNode) {
-                LearningNode learningNode = (LearningNode) leafNode;
-                learningNode.learnFromInstance(inst, this);
-                if (learningNode instanceof ActiveLearningNode) {
-                    ActiveLearningNode activeLearningNode = (ActiveLearningNode) learningNode;
-                    double weightSeen = activeLearningNode.getWeightSeen();
-                    if (weightSeen
-                            - activeLearningNode.getWeightSeenAtLastSplitEvaluation() >= this.gracePeriodOption.getValue()) {
-                        attemptToSplit(activeLearningNode, foundNode.parent,
-                                foundNode.parentBranch);
-                        activeLearningNode.setWeightSeenAtLastSplitEvaluation(weightSeen);
-                    }
-                }
-            }
-        }
-        if (this.trainingWeightSeenByModel
-                % this.memoryEstimatePeriodOption.getValue() == 0) {
-            estimateModelByteSizes();
-        }
-    }
-
-    @Override
-    public Prediction getPredictionForInstance(Instance inst) {
-        if (this.treeRoot != null) {
-            FoundNode[] foundNodes = this.treeRoot.filterInstanceToLeaves(inst,
-                    null, -1, false);
-            DoubleVector result = new DoubleVector();
-            int predictionPaths = 0;
-            for (FoundNode foundNode : foundNodes) {
-                if (foundNode.parentBranch != -999) {
-                    Node leafNode = foundNode.node;
-                    if (leafNode == null) {
-                        leafNode = foundNode.parent;
-                    }
-                    double[] dist = leafNode.getClassVotes(inst, this);
-                    //Albert: changed for weights
-                    //double distSum = Utils.sum(dist);
-                    //if (distSum > 0.0) {
-                    //	Utils.normalize(dist, distSum);
-                    //}
-                    result.addValues(dist);
-                    predictionPaths++;
-                }
-            }
-            if (predictionPaths > this.maxPredictionPaths) {
-                this.maxPredictionPaths++;
-            }
-            return new ClassificationPrediction(result.getArrayRef());
-        }
-        return new ClassificationPrediction(new double[0]);
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return new Measurement[]{
-                    new Measurement("tree size (nodes)", this.decisionNodeCount
-                    + this.activeLeafNodeCount + this.inactiveLeafNodeCount),
-                    new Measurement("tree size (leaves)", this.activeLeafNodeCount
-                    + this.inactiveLeafNodeCount),
-                    new Measurement("active learning leaves",
-                    this.activeLeafNodeCount),
-                    new Measurement("tree depth", measureTreeDepth()),
-                    new Measurement("active leaf byte size estimate",
-                    this.activeLeafByteSizeEstimate),
-                    new Measurement("inactive leaf byte size estimate",
-                    this.inactiveLeafByteSizeEstimate),
-                    new Measurement("byte size estimate overhead",
-                    this.byteSizeEstimateOverheadFraction),
-                    new Measurement("maximum prediction paths used",
-                    this.maxPredictionPaths)};
-    }
-
-    public int measureTreeDepth() {
-        if (this.treeRoot != null) {
-            return this.treeRoot.subtreeDepth();
-        }
-        return 0;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        this.treeRoot.describeSubtree(this, out, indent);
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return false;
-    }
-
-    public static double computeHoeffdingBound(double range, double confidence,
-            double n) {
-        return Math.sqrt(((range * range) * Math.log(1.0 / confidence))
-                / (2.0 * n));
-    }
-
-    protected AttributeClassObserver newNominalClassObserver() {
-        AttributeClassObserver nominalClassObserver = (AttributeClassObserver) getPreparedClassOption(this.nominalEstimatorOption);
-        return (AttributeClassObserver) nominalClassObserver.copy();
-    }
-
-    protected AttributeClassObserver newNumericClassObserver() {
-        AttributeClassObserver numericClassObserver = (AttributeClassObserver) getPreparedClassOption(this.numericEstimatorOption);
-        return (AttributeClassObserver) numericClassObserver.copy();
-    }
-
-    protected void attemptToSplit(ActiveLearningNode node, SplitNode parent,
-            int parentIndex) {
-        if (!node.observedClassDistributionIsPure()) {
-            SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
-            AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion, this);
-            Arrays.sort(bestSplitSuggestions);
-            boolean shouldSplit = false;
-            if (parentIndex != -999) {
-                if (bestSplitSuggestions.length < 2) {
-                    shouldSplit = bestSplitSuggestions.length > 0;
-                } else {
-                    double hoeffdingBound = computeHoeffdingBound(
-                            splitCriterion.getRangeOfMerit(node.getObservedClassDistribution()),
-                            this.splitConfidenceOption.getValue(), node.getWeightSeen());
-                    AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-                    AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
-                    if ((bestSuggestion.merit - secondBestSuggestion.merit > hoeffdingBound)
-                            || (hoeffdingBound < this.tieThresholdOption.getValue())) {
-                        shouldSplit = true;
-                    }
-                    if ((this.removePoorAttsOption != null)
-                            && this.removePoorAttsOption.isSet()) {
-                        Set<Integer> poorAtts = new HashSet<Integer>();
-                        // scan 1 - add any poor to set
-                        for (int i = 0; i < bestSplitSuggestions.length; i++) {
-                            if (bestSplitSuggestions[i].splitTest != null) {
-                                int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
-                                if (splitAtts.length == 1) {
-                                    if (bestSuggestion.merit
-                                            - bestSplitSuggestions[i].merit > hoeffdingBound) {
-                                        poorAtts.add(new Integer(splitAtts[0]));
-                                    }
-                                }
-                            }
-                        }
-                        // scan 2 - remove good ones from set
-                        for (int i = 0; i < bestSplitSuggestions.length; i++) {
-                            if (bestSplitSuggestions[i].splitTest != null) {
-                                int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
-                                if (splitAtts.length == 1) {
-                                    if (bestSuggestion.merit
-                                            - bestSplitSuggestions[i].merit < hoeffdingBound) {
-                                        poorAtts.remove(new Integer(
-                                                splitAtts[0]));
-                                    }
-                                }
-                            }
-                        }
-                        for (int poorAtt : poorAtts) {
-                            node.disableAttribute(poorAtt);
-                        }
-                    }
-                }
-            } else if (bestSplitSuggestions.length > 0) {
-                double hoeffdingBound = computeHoeffdingBound(splitCriterion.getRangeOfMerit(node.getObservedClassDistribution()),
-                        this.secondarySplitConfidenceOption.getValue(), node.getWeightSeen());
-                AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-                // in option case, scan back through existing options to
-                // find best
-                SplitNode current = parent;
-                double bestPreviousMerit = Double.NEGATIVE_INFINITY;
-                double[] preDist = node.getObservedClassDistribution();
-                while (true) {
-                    double merit = current.computeMeritOfExistingSplit(
-                            splitCriterion, preDist);
-                    if (merit > bestPreviousMerit) {
-                        bestPreviousMerit = merit;
-                    }
-                    if (current.optionCount != -999) {
-                        break;
-                    }
-                    current = current.parent;
-                }
-
-                if (bestSuggestion.merit - bestPreviousMerit > hoeffdingBound) {
-                    shouldSplit = true;
-                }
-            }
-            if (shouldSplit) {
-                AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-                if (splitDecision.splitTest == null) {
-                    // preprune - null wins
-                    if (parentIndex != -999) {
-                        deactivateLearningNode(node, parent, parentIndex);
-                    }
-                } else {
-                    SplitNode newSplit = new SplitNode(splitDecision.splitTest,
-                            node.getObservedClassDistribution());
-                    newSplit.parent = parent;
-                    // add option procedure
-                    SplitNode optionHead = parent;
-                    if (parent != null) {
-                        while (optionHead.optionCount == -999) {
-                            optionHead = optionHead.parent;
-                        }
-                    }
-                    if ((parentIndex == -999) && (parent != null)) {
-                        // adding a new option
-                        newSplit.optionCount = -999;
-                        optionHead.updateOptionCountBelow(1, this);
-                        if (optionHead.parent != null) {
-                            optionHead.parent.updateOptionCount(optionHead,
-                                    this);
-                        }
-                        addToOptionTable(splitDecision, optionHead.parent);
-                    } else {
-                        // adding a regular leaf
-                        if (optionHead == null) {
-                            newSplit.optionCount = 1;
-                        } else {
-                            newSplit.optionCount = optionHead.optionCount;
-                        }
-                    }
-                    int numOptions = 1;
-                    if (optionHead != null) {
-                        numOptions = optionHead.optionCount;
-                    }
-                    if (numOptions < this.maxOptionPathsOption.getValue()) {
-                        newSplit.nextOption = node; // preserve leaf
-                        // disable attribute just used
-                        int[] splitAtts = splitDecision.splitTest.getAttsTestDependsOn();
-                        for (int i : splitAtts) {
-                            node.disableAttribute(i);
-                        }
-                    } else {
-                        this.activeLeafNodeCount--;
-                    }
-                    for (int i = 0; i < splitDecision.numSplits(); i++) {
-                        Node newChild = newLearningNode(splitDecision.resultingClassDistributionFromSplit(i));
-                        newSplit.setChild(i, newChild);
-                    }
-                    this.decisionNodeCount++;
-                    this.activeLeafNodeCount += splitDecision.numSplits();
-                    if (parent == null) {
-                        this.treeRoot = newSplit;
-                    } else {
-                        if (parentIndex != -999) {
-                            parent.setChild(parentIndex, newSplit);
-                        } else {
-                            parent.nextOption = newSplit;
-                        }
-                    }
-                }
-                // manage memory
-                enforceTrackerLimit();
-            }
-        }
-    }
-
-    private void addToOptionTable(AttributeSplitSuggestion bestSuggestion,
-            SplitNode parent) {
-        File dumpFile = this.dumpFileOption.getFile();
-        PrintStream immediateResultStream = null;
-        if (dumpFile != null) {
-            try {
-                if (dumpFile.exists()) {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile, true), true);
-                } else {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile), true);
-                }
-            } catch (Exception ex) {
-                throw new RuntimeException("Unable to open dump file: "
-                        + dumpFile, ex);
-            }
-            int splitAtt = bestSuggestion.splitTest.getAttsTestDependsOn()[0];
-            double splitVal = -1.0;
-            if (bestSuggestion.splitTest instanceof NumericAttributeBinaryTest) {
-                NumericAttributeBinaryTest test = (NumericAttributeBinaryTest) bestSuggestion.splitTest;
-                splitVal = test.getSplitValue();
-            }
-            int treeDepth = 0;
-            while (parent != null) {
-                parent = parent.parent;
-                treeDepth++;
-            }
-            immediateResultStream.println(this.trainingWeightSeenByModel + ","
-                    + treeDepth + "," + splitAtt + "," + splitVal);
-            immediateResultStream.flush();
-            immediateResultStream.close();
-        }
-    }
-
-    public void enforceTrackerLimit() {
-        if ((this.inactiveLeafNodeCount > 0)
-                || ((this.activeLeafNodeCount * this.activeLeafByteSizeEstimate + this.inactiveLeafNodeCount
-                * this.inactiveLeafByteSizeEstimate)
-                * this.byteSizeEstimateOverheadFraction > this.maxByteSizeOption.getValue())) {
-            FoundNode[] learningNodes = findLearningNodes();
-            Arrays.sort(learningNodes, new Comparator<FoundNode>() {
-
-                public int compare(FoundNode fn1, FoundNode fn2) {
-                    if (HoeffdingOptionTree.this.memoryStrategyOption.getValue() == 0) {
-                        // strategy 1 - every leaf treated equal
-                        return Double.compare(fn1.node.calculatePromise(),
-                                fn2.node.calculatePromise());
-                    } else if (HoeffdingOptionTree.this.memoryStrategyOption.getValue() == 1) {
-                        // strategy 2 - internal leaves penalised
-                        double p1 = fn1.node.calculatePromise();
-                        if (fn1.parentBranch == -999) {
-                            p1 /= fn1.parent.getHeadOptionCount();
-                        }
-                        double p2 = fn2.node.calculatePromise();
-                        if (fn2.parentBranch == -999) {
-                            p1 /= fn2.parent.getHeadOptionCount();
-                        }
-                        return Double.compare(p1, p2);
-                    } else {
-                        // strategy 3 - all true leaves beat internal leaves
-                        if (fn1.parentBranch == -999) {
-                            if (fn2.parentBranch == -999) {
-                                return Double.compare(fn1.node.calculatePromise(), fn2.node.calculatePromise());
-                            }
-                            return -1; // fn1 < fn2
-                        }
-                        if (fn2.parentBranch == -999) {
-                            return 1; // fn1 > fn2
-                        }
-                        return Double.compare(fn1.node.calculatePromise(),
-                                fn2.node.calculatePromise());
-                    }
-                }
-            });
-            int maxActive = 0;
-            while (maxActive < learningNodes.length) {
-                maxActive++;
-                if ((maxActive * this.activeLeafByteSizeEstimate + (learningNodes.length - maxActive)
-                        * this.inactiveLeafByteSizeEstimate)
-                        * this.byteSizeEstimateOverheadFraction > this.maxByteSizeOption.getValue()) {
-                    maxActive--;
-                    break;
-                }
-            }
-            int cutoff = learningNodes.length - maxActive;
-            for (int i = 0; i < cutoff; i++) {
-                if (learningNodes[i].node instanceof ActiveLearningNode) {
-                    deactivateLearningNode(
-                            (ActiveLearningNode) learningNodes[i].node,
-                            learningNodes[i].parent,
-                            learningNodes[i].parentBranch);
-                }
-            }
-            for (int i = cutoff; i < learningNodes.length; i++) {
-                if (learningNodes[i].node instanceof InactiveLearningNode) {
-                    activateLearningNode(
-                            (InactiveLearningNode) learningNodes[i].node,
-                            learningNodes[i].parent,
-                            learningNodes[i].parentBranch);
-                }
-            }
-        }
-    }
-
-    public void estimateModelByteSizes() {
-        FoundNode[] learningNodes = findLearningNodes();
-        long totalActiveSize = 0;
-        long totalInactiveSize = 0;
-        for (FoundNode foundNode : learningNodes) {
-            if (foundNode.node instanceof ActiveLearningNode) {
-                totalActiveSize += SizeOf.fullSizeOf(foundNode.node);
-            } else {
-                totalInactiveSize += SizeOf.fullSizeOf(foundNode.node);
-            }
-        }
-        if (totalActiveSize > 0) {
-            this.activeLeafByteSizeEstimate = (double) totalActiveSize
-                    / this.activeLeafNodeCount;
-        }
-        if (totalInactiveSize > 0) {
-            this.inactiveLeafByteSizeEstimate = (double) totalInactiveSize
-                    / this.inactiveLeafNodeCount;
-        }
-        long actualModelSize = this.measureByteSize();
-        double estimatedModelSize = (this.activeLeafNodeCount
-                * this.activeLeafByteSizeEstimate + this.inactiveLeafNodeCount
-                * this.inactiveLeafByteSizeEstimate);
-        this.byteSizeEstimateOverheadFraction = actualModelSize
-                / estimatedModelSize;
-        if (actualModelSize > this.maxByteSizeOption.getValue()) {
-            enforceTrackerLimit();
-        }
-    }
-
-    public void deactivateAllLeaves() {
-        FoundNode[] learningNodes = findLearningNodes();
-        for (int i = 0; i < learningNodes.length; i++) {
-            if (learningNodes[i].node instanceof ActiveLearningNode) {
-                deactivateLearningNode(
-                        (ActiveLearningNode) learningNodes[i].node,
-                        learningNodes[i].parent, learningNodes[i].parentBranch);
-            }
-        }
-    }
-
-    protected void deactivateLearningNode(ActiveLearningNode toDeactivate,
-            SplitNode parent, int parentBranch) {
-        Node newLeaf = new InactiveLearningNode(toDeactivate.getObservedClassDistribution());
-        if (parent == null) {
-            this.treeRoot = newLeaf;
-        } else {
-            if (parentBranch != -999) {
-                parent.setChild(parentBranch, newLeaf);
-            } else {
-                parent.nextOption = newLeaf;
-            }
-        }
-        this.activeLeafNodeCount--;
-        this.inactiveLeafNodeCount++;
-    }
-
-    protected void activateLearningNode(InactiveLearningNode toActivate,
-            SplitNode parent, int parentBranch) {
-        Node newLeaf = newLearningNode(toActivate.getObservedClassDistribution());
-        if (parent == null) {
-            this.treeRoot = newLeaf;
-        } else {
-            if (parentBranch != -999) {
-                parent.setChild(parentBranch, newLeaf);
-            } else {
-                parent.nextOption = newLeaf;
-            }
-        }
-        this.activeLeafNodeCount++;
-        this.inactiveLeafNodeCount--;
-    }
-
-    protected FoundNode[] findLearningNodes() {
-        List<FoundNode> foundList = new LinkedList<FoundNode>();
-        findLearningNodes(this.treeRoot, null, -1, foundList);
-        return foundList.toArray(new FoundNode[foundList.size()]);
-    }
-
-    protected void findLearningNodes(Node node, SplitNode parent,
-            int parentBranch, List<FoundNode> found) {
-        if (node != null) {
-            if (node instanceof LearningNode) {
-                found.add(new FoundNode(node, parent, parentBranch));
-            }
-            if (node instanceof SplitNode) {
-                SplitNode splitNode = (SplitNode) node;
-                for (int i = 0; i < splitNode.numChildren(); i++) {
-                    findLearningNodes(splitNode.getChild(i), splitNode, i,
-                            found);
-                }
-                findLearningNodes(splitNode.nextOption, splitNode, -999, found);
-            }
-        }
-    }
-
-    public MultiChoiceOption leafpredictionOption = new MultiChoiceOption(
-            "leafprediction", 'l', "Leaf prediction to use.", new String[]{
-                "MC", "NB", "NBAdaptive"}, new String[]{
-                "Majority class",
-                "Naive Bayes",
-                "Naive Bayes Adaptive"}, 2);
-
-    public IntOption nbThresholdOption = new IntOption(
-            "nbThreshold",
-            'q',
-            "The number of instances a leaf should observe before permitting Naive Bayes.",
-            0, 0, Integer.MAX_VALUE);
-
-    public static class LearningNodeNB extends ActiveLearningNode {
-
-        private static final long serialVersionUID = 1L;
-
-        public LearningNodeNB(double[] initialClassObservations) {
-            super(initialClassObservations);
-        }
-
-        @Override
-        public double[] getClassVotes(Instance inst, HoeffdingOptionTree hot) {
-            if (getWeightSeen() >=  hot.nbThresholdOption.getValue()) {
-                return NaiveBayes.doNaiveBayesPrediction(inst,
-                        this.observedClassDistribution,
-                        this.attributeObservers);
-            }
-            return super.getClassVotes(inst, hot);
-        }
-
-        @Override
-        public void disableAttribute(int attIndex) {
-            // should not disable poor atts - they are used in NB calc
-        }
-    }
-
-    public static class LearningNodeNBAdaptive extends LearningNodeNB {
-
-        private static final long serialVersionUID = 1L;
-
-        protected double mcCorrectWeight = 0.0;
-
-        protected double nbCorrectWeight = 0.0;
-
-        public LearningNodeNBAdaptive(double[] initialClassObservations) {
-            super(initialClassObservations);
-        }
-
-        @Override
-        public void learnFromInstance(Instance inst, HoeffdingOptionTree hot) {
-            int trueClass = (int) inst.classValue();
-            if (this.observedClassDistribution.maxIndex() == trueClass) {
-                this.mcCorrectWeight += inst.weight();
-            }
-            if (Utils.maxIndex(NaiveBayes.doNaiveBayesPrediction(inst,
-                    this.observedClassDistribution, this.attributeObservers)) == trueClass) {
-                this.nbCorrectWeight += inst.weight();
-            }
-            super.learnFromInstance(inst, hot);
-        }
-
-        @Override
-        public double[] getClassVotes(Instance inst, HoeffdingOptionTree ht) {
-            if (this.mcCorrectWeight > this.nbCorrectWeight) {
-                return this.observedClassDistribution.getArrayCopy();
-            }
-            return NaiveBayes.doNaiveBayesPrediction(inst,
-                    this.observedClassDistribution, this.attributeObservers);
-        }
-    }
-
-    protected LearningNode newLearningNode() {
-        return newLearningNode(new double[0]);
-    }
-
-    protected LearningNode newLearningNode(double[] initialClassObservations) {
-        LearningNode ret;
-        int predictionOption = this.leafpredictionOption.getChosenIndex();
-        if (predictionOption == 0) { //MC
-            ret = new ActiveLearningNode(initialClassObservations);
-        } else if (predictionOption == 1) { //NB
-            ret = new LearningNodeNB(initialClassObservations);
-        } else { //NBAdaptive
-            ret = new LearningNodeNBAdaptive(initialClassObservations);
-        }
-        return ret;
-    }
-
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == HoeffdingOptionTree.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/trees/HoeffdingTree.java b/moa/src/main/java/moa/classifiers/trees/HoeffdingTree.java
deleted file mode 100644
index 4f8ed9e89..000000000
--- a/moa/src/main/java/moa/classifiers/trees/HoeffdingTree.java
+++ /dev/null
@@ -1,938 +0,0 @@
-/*
- *    HoeffdingTree.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.trees;
-
-import java.util.Arrays;
-import java.util.Comparator;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Set;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.AbstractMOAObject;
-import moa.capabilities.CapabilitiesHandler;
-import moa.capabilities.Capability;
-import moa.capabilities.ImmutableCapabilities;
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.bayes.NaiveBayes;
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.DiscreteAttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.NullAttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.NumericAttributeClassObserver;
-import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.core.AutoExpandVector;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.core.SizeOf;
-import moa.core.StringUtils;
-import moa.core.Utils;
-import moa.learners.Classifier;
-import moa.options.ClassOption;
-
-/**
- * Hoeffding Tree or VFDT.
- *
- * A Hoeffding tree is an incremental, anytime decision tree induction algorithm
- * that is capable of learning from massive data streams, assuming that the
- * distribution generating examples does not change over time. Hoeffding trees
- * exploit the fact that a small sample can often be enough to choose an optimal
- * splitting attribute. This idea is supported mathematically by the Hoeffding
- * bound, which quantifies the number of observations (in our case, examples)
- * needed to estimate some statistics within a prescribed precision (in our
- * case, the goodness of an attribute).</p> <p>A theoretically appealing feature
- * of Hoeffding Trees not shared by other incremental decision tree learners is
- * that it has sound guarantees of performance. Using the Hoeffding bound one
- * can show that its output is asymptotically nearly identical to that of a
- * non-incremental learner using infinitely many examples. See for details:</p>
- *
- * <p>G. Hulten, L. Spencer, and P. Domingos. Mining time-changing data streams.
- * In KDD’01, pages 97–106, San Francisco, CA, 2001. ACM Press.</p>
- *
- * <p>Parameters:</p> <ul> <li> -m : Maximum memory consumed by the tree</li>
- * <li> -n : Numeric estimator to use : <ul> <li>Gaussian approximation
- * evaluating 10 splitpoints</li> <li>Gaussian approximation evaluating 100
- * splitpoints</li> <li>Greenwald-Khanna quantile summary with 10 tuples</li>
- * <li>Greenwald-Khanna quantile summary with 100 tuples</li>
- * <li>Greenwald-Khanna quantile summary with 1000 tuples</li> <li>VFML method
- * with 10 bins</li> <li>VFML method with 100 bins</li> <li>VFML method with
- * 1000 bins</li> <li>Exhaustive binary tree</li> </ul> </li> <li> -e : How many
- * instances between memory consumption checks</li> <li> -g : The number of
- * instances a leaf should observe between split attempts</li> <li> -s : Split
- * criterion to use. Example : InfoGainSplitCriterion</li> <li> -c : The
- * allowable error in split decision, values closer to 0 will take longer to
- * decide</li> <li> -t : Threshold below which a split will be forced to break
- * ties</li> <li> -b : Only allow binary splits</li> <li> -z : Stop growing as
- * soon as memory limit is hit</li> <li> -r : Disable poor attributes</li> <li>
- * -p : Disable pre-pruning</li> 
- *  <li> -l : Leaf prediction to use: MajorityClass (MC), Naive Bayes (NB) or NaiveBayes
- * adaptive (NBAdaptive).</li>
- *  <li> -q : The number of instances a leaf should observe before
- * permitting Naive Bayes</li>
- * </ul>
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $
- */
-public class HoeffdingTree extends AbstractClassifier implements Classifier, CapabilitiesHandler {
-
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public String getPurposeString() {
-        return "Hoeffding Tree or VFDT.";
-    }
-
-    public IntOption maxByteSizeOption = new IntOption("maxByteSize", 'm',
-            "Maximum memory consumed by the tree.", 33554432, 0,
-            Integer.MAX_VALUE);
-
-    /*
-     * public MultiChoiceOption numericEstimatorOption = new MultiChoiceOption(
-     * "numericEstimator", 'n', "Numeric estimator to use.", new String[]{
-     * "GAUSS10", "GAUSS100", "GK10", "GK100", "GK1000", "VFML10", "VFML100",
-     * "VFML1000", "BINTREE"}, new String[]{ "Gaussian approximation evaluating
-     * 10 splitpoints", "Gaussian approximation evaluating 100 splitpoints",
-     * "Greenwald-Khanna quantile summary with 10 tuples", "Greenwald-Khanna
-     * quantile summary with 100 tuples", "Greenwald-Khanna quantile summary
-     * with 1000 tuples", "VFML method with 10 bins", "VFML method with 100
-     * bins", "VFML method with 1000 bins", "Exhaustive binary tree"}, 0);
-     */
-    public ClassOption numericEstimatorOption = new ClassOption("numericEstimator",
-            'n', "Numeric estimator to use.", NumericAttributeClassObserver.class,
-            "GaussianNumericAttributeClassObserver");
-
-    public ClassOption nominalEstimatorOption = new ClassOption("nominalEstimator",
-            'd', "Nominal estimator to use.", DiscreteAttributeClassObserver.class,
-            "NominalAttributeClassObserver");
-
-    public IntOption memoryEstimatePeriodOption = new IntOption(
-            "memoryEstimatePeriod", 'e',
-            "How many instances between memory consumption checks.", 1000000,
-            0, Integer.MAX_VALUE);
-
-    public IntOption gracePeriodOption = new IntOption(
-            "gracePeriod",
-            'g',
-            "The number of instances a leaf should observe between split attempts.",
-            200, 0, Integer.MAX_VALUE);
-
-    public ClassOption splitCriterionOption = new ClassOption("splitCriterion",
-            's', "Split criterion to use.", SplitCriterion.class,
-            "InfoGainSplitCriterion");
-
-    public FloatOption splitConfidenceOption = new FloatOption(
-            "splitConfidence",
-            'c',
-            "The allowable error in split decision, values closer to 0 will take longer to decide.",
-            0.0000001, 0.0, 1.0);
-
-    public FloatOption tieThresholdOption = new FloatOption("tieThreshold",
-            't', "Threshold below which a split will be forced to break ties.",
-            0.05, 0.0, 1.0);
-
-public FlagOption binarySplitsOption = new FlagOption("binarySplits", 'b',
-        "Only allow binary splits.");
-
-    public FlagOption stopMemManagementOption = new FlagOption(
-            "stopMemManagement", 'z',
-            "Stop growing as soon as memory limit is hit.");
-
-    public FlagOption removePoorAttsOption = new FlagOption("removePoorAtts",
-            'r', "Disable poor attributes.");
-
-    public FlagOption noPrePruneOption = new FlagOption("noPrePrune", 'p',
-            "Disable pre-pruning.");
-
-    public static class FoundNode {
-
-        public Node node;
-
-        public SplitNode parent;
-
-        public int parentBranch;
-
-        public FoundNode(Node node, SplitNode parent, int parentBranch) {
-            this.node = node;
-            this.parent = parent;
-            this.parentBranch = parentBranch;
-        }
-    }
-
-    public static class Node extends AbstractMOAObject {
-
-        private static final long serialVersionUID = 1L;
-
-        protected DoubleVector observedClassDistribution;
-
-        public Node(double[] classObservations) {
-            this.observedClassDistribution = new DoubleVector(classObservations);
-        }
-
-        public int calcByteSize() {
-            return (int) (SizeOf.sizeOf(this) + SizeOf.fullSizeOf(this.observedClassDistribution));
-        }
-
-        public int calcByteSizeIncludingSubtree() {
-            return calcByteSize();
-        }
-
-        public boolean isLeaf() {
-            return true;
-        }
-
-        public FoundNode filterInstanceToLeaf(Instance inst, SplitNode parent,
-                int parentBranch) {
-            return new FoundNode(this, parent, parentBranch);
-        }
-
-        public double[] getObservedClassDistribution() {
-            return this.observedClassDistribution.getArrayCopy();
-        }
-
-        public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
-            return this.observedClassDistribution.getArrayCopy();
-        }
-
-        public boolean observedClassDistributionIsPure() {
-            return this.observedClassDistribution.numNonZeroEntries() < 2;
-        }
-
-        public void describeSubtree(HoeffdingTree ht, StringBuilder out,
-                int indent) {
-            StringUtils.appendIndented(out, indent, "Leaf ");
-            out.append(ht.getClassNameString());
-            out.append(" = ");
-            out.append(ht.getClassLabelString(this.observedClassDistribution.maxIndex()));
-            out.append(" weights: ");
-            this.observedClassDistribution.getSingleLineDescription(out,
-                    ht.treeRoot.observedClassDistribution.numValues());
-            StringUtils.appendNewline(out);
-        }
-
-        public int subtreeDepth() {
-            return 0;
-        }
-
-        public double calculatePromise() {
-            double totalSeen = this.observedClassDistribution.sumOfValues();
-            return totalSeen > 0.0 ? (totalSeen - this.observedClassDistribution.getValue(this.observedClassDistribution.maxIndex()))
-                    : 0.0;
-        }
-
-        @Override
-        public void getDescription(StringBuilder sb, int indent) {
-            describeSubtree(null, sb, indent);
-        }
-    }
-
-    public static class SplitNode extends Node {
-
-        private static final long serialVersionUID = 1L;
-
-        protected InstanceConditionalTest splitTest;
-
-        protected AutoExpandVector<Node> children; // = new AutoExpandVector<Node>();
-
-        @Override
-        public int calcByteSize() {
-            return super.calcByteSize()
-                    + (int) (SizeOf.sizeOf(this.children) + SizeOf.fullSizeOf(this.splitTest));
-        }
-
-        @Override
-        public int calcByteSizeIncludingSubtree() {
-            int byteSize = calcByteSize();
-            for (Node child : this.children) {
-                if (child != null) {
-                    byteSize += child.calcByteSizeIncludingSubtree();
-                }
-            }
-            return byteSize;
-        }
-
-        public SplitNode(InstanceConditionalTest splitTest,
-                double[] classObservations, int size) {
-            super(classObservations);
-            this.splitTest = splitTest;
-            this.children = new AutoExpandVector<Node>(size);
-        }
-        
-        public SplitNode(InstanceConditionalTest splitTest,
-                double[] classObservations) {
-            super(classObservations);
-            this.splitTest = splitTest;
-            this.children = new AutoExpandVector<Node>();
-        }
-
-
-        public int numChildren() {
-            return this.children.size();
-        }
-
-        public void setChild(int index, Node child) {
-            if ((this.splitTest.maxBranches() >= 0)
-                    && (index >= this.splitTest.maxBranches())) {
-                throw new IndexOutOfBoundsException();
-            }
-            this.children.set(index, child);
-        }
-
-        public Node getChild(int index) {
-            return this.children.get(index);
-        }
-
-        public int instanceChildIndex(Instance inst) {
-            return this.splitTest.branchForInstance(inst);
-        }
-
-        @Override
-        public boolean isLeaf() {
-            return false;
-        }
-
-        @Override
-        public FoundNode filterInstanceToLeaf(Instance inst, SplitNode parent,
-                int parentBranch) {
-            int childIndex = instanceChildIndex(inst);
-            if (childIndex >= 0) {
-                Node child = getChild(childIndex);
-                if (child != null) {
-                    return child.filterInstanceToLeaf(inst, this, childIndex);
-                }
-                return new FoundNode(null, this, childIndex);
-            }
-            return new FoundNode(this, parent, parentBranch);
-        }
-
-        @Override
-        public void describeSubtree(HoeffdingTree ht, StringBuilder out,
-                int indent) {
-            for (int branch = 0; branch < numChildren(); branch++) {
-                Node child = getChild(branch);
-                if (child != null) {
-                    StringUtils.appendIndented(out, indent, "if ");
-                    out.append(this.splitTest.describeConditionForBranch(branch,
-                            ht.getModelContext()));
-                    out.append(": ");
-                    StringUtils.appendNewline(out);
-                    child.describeSubtree(ht, out, indent + 2);
-                }
-            }
-        }
-
-        @Override
-        public int subtreeDepth() {
-            int maxChildDepth = 0;
-            for (Node child : this.children) {
-                if (child != null) {
-                    int depth = child.subtreeDepth();
-                    if (depth > maxChildDepth) {
-                        maxChildDepth = depth;
-                    }
-                }
-            }
-            return maxChildDepth + 1;
-        }
-    }
-
-    public static abstract class LearningNode extends Node {
-
-        private static final long serialVersionUID = 1L;
-
-        public LearningNode(double[] initialClassObservations) {
-            super(initialClassObservations);
-        }
-
-        public abstract void learnFromInstance(Instance inst, HoeffdingTree ht);
-    }
-
-    public static class InactiveLearningNode extends LearningNode {
-
-        private static final long serialVersionUID = 1L;
-
-        public InactiveLearningNode(double[] initialClassObservations) {
-            super(initialClassObservations);
-        }
-
-        @Override
-        public void learnFromInstance(Instance inst, HoeffdingTree ht) {
-            this.observedClassDistribution.addToValue((int) inst.classValue(),
-                    inst.weight());
-        }
-    }
-
-    public static class ActiveLearningNode extends LearningNode {
-
-        private static final long serialVersionUID = 1L;
-
-        protected double weightSeenAtLastSplitEvaluation;
-
-        protected AutoExpandVector<AttributeClassObserver> attributeObservers = new AutoExpandVector<AttributeClassObserver>();
-        
-        protected boolean isInitialized;
-
-        public ActiveLearningNode(double[] initialClassObservations) {
-            super(initialClassObservations);
-            this.weightSeenAtLastSplitEvaluation = getWeightSeen();
-            this.isInitialized = false;
-        }
-
-        @Override
-        public int calcByteSize() {
-            return super.calcByteSize()
-                    + (int) (SizeOf.fullSizeOf(this.attributeObservers));
-        }
-
-        @Override
-        public void learnFromInstance(Instance inst, HoeffdingTree ht) {
-            if (this.isInitialized == false) {
-                this.attributeObservers = new AutoExpandVector<AttributeClassObserver>(inst.numAttributes());
-                this.isInitialized = true;
-            }
-            this.observedClassDistribution.addToValue((int) inst.classValue(),
-                    inst.weight());
-            for (int i = 0; i < inst.numAttributes() - 1; i++) {
-                int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
-                AttributeClassObserver obs = this.attributeObservers.get(i);
-                if (obs == null) {
-                    obs = inst.attribute(instAttIndex).isNominal() ? ht.newNominalClassObserver() : ht.newNumericClassObserver();
-                    this.attributeObservers.set(i, obs);
-                }
-                obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
-            }
-        }
-
-        public double getWeightSeen() {
-            return this.observedClassDistribution.sumOfValues();
-        }
-
-        public double getWeightSeenAtLastSplitEvaluation() {
-            return this.weightSeenAtLastSplitEvaluation;
-        }
-
-        public void setWeightSeenAtLastSplitEvaluation(double weight) {
-            this.weightSeenAtLastSplitEvaluation = weight;
-        }
-
-        public AttributeSplitSuggestion[] getBestSplitSuggestions(
-                SplitCriterion criterion, HoeffdingTree ht) {
-            List<AttributeSplitSuggestion> bestSuggestions = new LinkedList<AttributeSplitSuggestion>();
-            double[] preSplitDist = this.observedClassDistribution.getArrayCopy();
-            if (!ht.noPrePruneOption.isSet()) {
-                // add null split as an option
-                bestSuggestions.add(new AttributeSplitSuggestion(null,
-                        new double[0][], criterion.getMeritOfSplit(
-                        preSplitDist,
-                        new double[][]{preSplitDist})));
-            }
-            for (int i = 0; i < this.attributeObservers.size(); i++) {
-                AttributeClassObserver obs = this.attributeObservers.get(i);
-                if (obs != null) {
-                    AttributeSplitSuggestion bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion,
-                            preSplitDist, i, ht.binarySplitsOption.isSet());
-                    if (bestSuggestion != null) {
-                        bestSuggestions.add(bestSuggestion);
-                    }
-                }
-            }
-            return bestSuggestions.toArray(new AttributeSplitSuggestion[bestSuggestions.size()]);
-        }
-
-        public void disableAttribute(int attIndex) {
-            this.attributeObservers.set(attIndex,
-                    new NullAttributeClassObserver());
-        }
-    }
-
-    protected Node treeRoot;
-
-    protected int decisionNodeCount;
-
-    protected int activeLeafNodeCount;
-
-    protected int inactiveLeafNodeCount;
-
-    protected double inactiveLeafByteSizeEstimate;
-
-    protected double activeLeafByteSizeEstimate;
-
-    protected double byteSizeEstimateOverheadFraction;
-
-    protected boolean growthAllowed;
-
-    public long calcByteSize() {
-        long size = SizeOf.sizeOf(this);
-        if (this.treeRoot != null) {
-            size += this.treeRoot.calcByteSizeIncludingSubtree();
-        }
-        return size;
-    }
-
-    @Override
-    public long measureByteSize() {
-        return calcByteSize();
-    }
-
-    @Override
-    public void resetLearningImpl() {
-        this.treeRoot = null;
-        this.decisionNodeCount = 0;
-        this.activeLeafNodeCount = 0;
-        this.inactiveLeafNodeCount = 0;
-        this.inactiveLeafByteSizeEstimate = 0.0;
-        this.activeLeafByteSizeEstimate = 0.0;
-        this.byteSizeEstimateOverheadFraction = 1.0;
-        this.growthAllowed = true;
-        if (this.leafpredictionOption.getChosenIndex()>0) { 
-            this.removePoorAttsOption = null;
-        }
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        if (this.treeRoot == null) {
-            this.treeRoot = newLearningNode();
-            this.activeLeafNodeCount = 1;
-        }
-        FoundNode foundNode = this.treeRoot.filterInstanceToLeaf(inst, null, -1);
-        Node leafNode = foundNode.node;
-        if (leafNode == null) {
-            leafNode = newLearningNode();
-            foundNode.parent.setChild(foundNode.parentBranch, leafNode);
-            this.activeLeafNodeCount++;
-        }
-        if (leafNode instanceof LearningNode) {
-            LearningNode learningNode = (LearningNode) leafNode;
-            learningNode.learnFromInstance(inst, this);
-            if (this.growthAllowed
-                    && (learningNode instanceof ActiveLearningNode)) {
-                ActiveLearningNode activeLearningNode = (ActiveLearningNode) learningNode;
-                double weightSeen = activeLearningNode.getWeightSeen();
-                if (weightSeen
-                        - activeLearningNode.getWeightSeenAtLastSplitEvaluation() >= this.gracePeriodOption.getValue()) {
-                    attemptToSplit(activeLearningNode, foundNode.parent,
-                            foundNode.parentBranch);
-                    activeLearningNode.setWeightSeenAtLastSplitEvaluation(weightSeen);
-                }
-            }
-        }
-        if (this.trainingWeightSeenByModel
-                % this.memoryEstimatePeriodOption.getValue() == 0) {
-            estimateModelByteSizes();
-        }
-    }
-
-    @Override
-    public Prediction getPredictionForInstance(Instance inst) {
-        if (this.treeRoot != null) {
-            FoundNode foundNode = this.treeRoot.filterInstanceToLeaf(inst,
-                    null, -1);
-            Node leafNode = foundNode.node;
-            if (leafNode == null) {
-                leafNode = foundNode.parent;
-            }
-            return new ClassificationPrediction(leafNode.getClassVotes(inst, this));
-          } else {
-            return new ClassificationPrediction();
-          }
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return new Measurement[]{
-                    new Measurement("tree size (nodes)", this.decisionNodeCount
-                    + this.activeLeafNodeCount + this.inactiveLeafNodeCount),
-                    new Measurement("tree size (leaves)", this.activeLeafNodeCount
-                    + this.inactiveLeafNodeCount),
-                    new Measurement("active learning leaves",
-                    this.activeLeafNodeCount),
-                    new Measurement("tree depth", measureTreeDepth()),
-                    new Measurement("active leaf byte size estimate",
-                    this.activeLeafByteSizeEstimate),
-                    new Measurement("inactive leaf byte size estimate",
-                    this.inactiveLeafByteSizeEstimate),
-                    new Measurement("byte size estimate overhead",
-                    this.byteSizeEstimateOverheadFraction)};
-    }
-
-    public int measureTreeDepth() {
-        if (this.treeRoot != null) {
-            return this.treeRoot.subtreeDepth();
-        }
-        return 0;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        this.treeRoot.describeSubtree(this, out, indent);
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return false;
-    }
-
-    public static double computeHoeffdingBound(double range, double confidence,
-            double n) {
-        return Math.sqrt(((range * range) * Math.log(1.0 / confidence))
-                / (2.0 * n));
-    }
-
-    //Procedure added for Hoeffding Adaptive Trees (ADWIN)
-    protected SplitNode newSplitNode(InstanceConditionalTest splitTest,
-            double[] classObservations, int size) {
-        return new SplitNode(splitTest, classObservations, size);
-    }
-    
-    protected SplitNode newSplitNode(InstanceConditionalTest splitTest,
-            double[] classObservations) {
-        return new SplitNode(splitTest, classObservations);
-    }
-    
-
-    protected AttributeClassObserver newNominalClassObserver() {
-        AttributeClassObserver nominalClassObserver = (AttributeClassObserver) getPreparedClassOption(this.nominalEstimatorOption);
-        return (AttributeClassObserver) nominalClassObserver.copy();
-    }
-
-    protected AttributeClassObserver newNumericClassObserver() {
-        AttributeClassObserver numericClassObserver = (AttributeClassObserver) getPreparedClassOption(this.numericEstimatorOption);
-        return (AttributeClassObserver) numericClassObserver.copy();
-    }
-
-    protected void attemptToSplit(ActiveLearningNode node, SplitNode parent,
-            int parentIndex) {
-        if (!node.observedClassDistributionIsPure()) {
-            SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
-            AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion, this);
-            Arrays.sort(bestSplitSuggestions);
-            boolean shouldSplit = false;
-            if (bestSplitSuggestions.length < 2) {
-                shouldSplit = bestSplitSuggestions.length > 0;
-            } else {
-                double hoeffdingBound = computeHoeffdingBound(splitCriterion.getRangeOfMerit(node.getObservedClassDistribution()),
-                        this.splitConfidenceOption.getValue(), node.getWeightSeen());
-                AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-                AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
-                if ((bestSuggestion.merit - secondBestSuggestion.merit > hoeffdingBound)
-                        || (hoeffdingBound < this.tieThresholdOption.getValue())) {
-                    shouldSplit = true;
-                }
-                // }
-                if ((this.removePoorAttsOption != null)
-                        && this.removePoorAttsOption.isSet()) {
-                    Set<Integer> poorAtts = new HashSet<Integer>();
-                    // scan 1 - add any poor to set
-                    for (int i = 0; i < bestSplitSuggestions.length; i++) {
-                        if (bestSplitSuggestions[i].splitTest != null) {
-                            int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
-                            if (splitAtts.length == 1) {
-                                if (bestSuggestion.merit
-                                        - bestSplitSuggestions[i].merit > hoeffdingBound) {
-                                    poorAtts.add(new Integer(splitAtts[0]));
-                                }
-                            }
-                        }
-                    }
-                    // scan 2 - remove good ones from set
-                    for (int i = 0; i < bestSplitSuggestions.length; i++) {
-                        if (bestSplitSuggestions[i].splitTest != null) {
-                            int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
-                            if (splitAtts.length == 1) {
-                                if (bestSuggestion.merit
-                                        - bestSplitSuggestions[i].merit < hoeffdingBound) {
-                                    poorAtts.remove(new Integer(splitAtts[0]));
-                                }
-                            }
-                        }
-                    }
-                    for (int poorAtt : poorAtts) {
-                        node.disableAttribute(poorAtt);
-                    }
-                }
-            }
-            if (shouldSplit) {
-                AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-                if (splitDecision.splitTest == null) {
-                    // preprune - null wins
-                    deactivateLearningNode(node, parent, parentIndex);
-                } else {
-                    SplitNode newSplit = newSplitNode(splitDecision.splitTest,
-                            node.getObservedClassDistribution(),splitDecision.numSplits() );
-                    for (int i = 0; i < splitDecision.numSplits(); i++) {
-                        Node newChild = newLearningNode(splitDecision.resultingClassDistributionFromSplit(i));
-                        newSplit.setChild(i, newChild);
-                    }
-                    this.activeLeafNodeCount--;
-                    this.decisionNodeCount++;
-                    this.activeLeafNodeCount += splitDecision.numSplits();
-                    if (parent == null) {
-                        this.treeRoot = newSplit;
-                    } else {
-                        parent.setChild(parentIndex, newSplit);
-                    }
-                }
-                // manage memory
-                enforceTrackerLimit();
-            }
-        }
-    }
-
-    public void enforceTrackerLimit() {
-        if ((this.inactiveLeafNodeCount > 0)
-                || ((this.activeLeafNodeCount * this.activeLeafByteSizeEstimate + this.inactiveLeafNodeCount
-                * this.inactiveLeafByteSizeEstimate)
-                * this.byteSizeEstimateOverheadFraction > this.maxByteSizeOption.getValue())) {
-            if (this.stopMemManagementOption.isSet()) {
-                this.growthAllowed = false;
-                return;
-            }
-            FoundNode[] learningNodes = findLearningNodes();
-            Arrays.sort(learningNodes, new Comparator<FoundNode>() {
-
-                @Override
-                public int compare(FoundNode fn1, FoundNode fn2) {
-                    return Double.compare(fn1.node.calculatePromise(), fn2.node.calculatePromise());
-                }
-            });
-            int maxActive = 0;
-            while (maxActive < learningNodes.length) {
-                maxActive++;
-                if ((maxActive * this.activeLeafByteSizeEstimate + (learningNodes.length - maxActive)
-                        * this.inactiveLeafByteSizeEstimate)
-                        * this.byteSizeEstimateOverheadFraction > this.maxByteSizeOption.getValue()) {
-                    maxActive--;
-                    break;
-                }
-            }
-            int cutoff = learningNodes.length - maxActive;
-            for (int i = 0; i < cutoff; i++) {
-                if (learningNodes[i].node instanceof ActiveLearningNode) {
-                    deactivateLearningNode(
-                            (ActiveLearningNode) learningNodes[i].node,
-                            learningNodes[i].parent,
-                            learningNodes[i].parentBranch);
-                }
-            }
-            for (int i = cutoff; i < learningNodes.length; i++) {
-                if (learningNodes[i].node instanceof InactiveLearningNode) {
-                    activateLearningNode(
-                            (InactiveLearningNode) learningNodes[i].node,
-                            learningNodes[i].parent,
-                            learningNodes[i].parentBranch);
-                }
-            }
-        }
-    }
-
-    public void estimateModelByteSizes() {
-        FoundNode[] learningNodes = findLearningNodes();
-        long totalActiveSize = 0;
-        long totalInactiveSize = 0;
-        for (FoundNode foundNode : learningNodes) {
-            if (foundNode.node instanceof ActiveLearningNode) {
-                totalActiveSize += SizeOf.fullSizeOf(foundNode.node);
-            } else {
-                totalInactiveSize += SizeOf.fullSizeOf(foundNode.node);
-            }
-        }
-        if (totalActiveSize > 0) {
-            this.activeLeafByteSizeEstimate = (double) totalActiveSize
-                    / this.activeLeafNodeCount;
-        }
-        if (totalInactiveSize > 0) {
-            this.inactiveLeafByteSizeEstimate = (double) totalInactiveSize
-                    / this.inactiveLeafNodeCount;
-        }
-        long actualModelSize = this.measureByteSize();
-        double estimatedModelSize = (this.activeLeafNodeCount
-                * this.activeLeafByteSizeEstimate + this.inactiveLeafNodeCount
-                * this.inactiveLeafByteSizeEstimate);
-        this.byteSizeEstimateOverheadFraction = actualModelSize
-                / estimatedModelSize;
-        if (actualModelSize > this.maxByteSizeOption.getValue()) {
-            enforceTrackerLimit();
-        }
-    }
-
-    public void deactivateAllLeaves() {
-        FoundNode[] learningNodes = findLearningNodes();
-        for (int i = 0; i < learningNodes.length; i++) {
-            if (learningNodes[i].node instanceof ActiveLearningNode) {
-                deactivateLearningNode(
-                        (ActiveLearningNode) learningNodes[i].node,
-                        learningNodes[i].parent, learningNodes[i].parentBranch);
-            }
-        }
-    }
-
-    protected void deactivateLearningNode(ActiveLearningNode toDeactivate,
-            SplitNode parent, int parentBranch) {
-        Node newLeaf = new InactiveLearningNode(toDeactivate.getObservedClassDistribution());
-        if (parent == null) {
-            this.treeRoot = newLeaf;
-        } else {
-            parent.setChild(parentBranch, newLeaf);
-        }
-        this.activeLeafNodeCount--;
-        this.inactiveLeafNodeCount++;
-    }
-
-    protected void activateLearningNode(InactiveLearningNode toActivate,
-            SplitNode parent, int parentBranch) {
-        Node newLeaf = newLearningNode(toActivate.getObservedClassDistribution());
-        if (parent == null) {
-            this.treeRoot = newLeaf;
-        } else {
-            parent.setChild(parentBranch, newLeaf);
-        }
-        this.activeLeafNodeCount++;
-        this.inactiveLeafNodeCount--;
-    }
-
-    protected FoundNode[] findLearningNodes() {
-        List<FoundNode> foundList = new LinkedList<FoundNode>();
-        findLearningNodes(this.treeRoot, null, -1, foundList);
-        return foundList.toArray(new FoundNode[foundList.size()]);
-    }
-
-    protected void findLearningNodes(Node node, SplitNode parent,
-            int parentBranch, List<FoundNode> found) {
-        if (node != null) {
-            if (node instanceof LearningNode) {
-                found.add(new FoundNode(node, parent, parentBranch));
-            }
-            if (node instanceof SplitNode) {
-                SplitNode splitNode = (SplitNode) node;
-                for (int i = 0; i < splitNode.numChildren(); i++) {
-                    findLearningNodes(splitNode.getChild(i), splitNode, i,
-                            found);
-                }
-            }
-        }
-    }
-
-    public MultiChoiceOption leafpredictionOption = new MultiChoiceOption(
-            "leafprediction", 'l', "Leaf prediction to use.", new String[]{
-                "MC", "NB", "NBAdaptive"}, new String[]{
-                "Majority class",
-                "Naive Bayes",
-                "Naive Bayes Adaptive"}, 2);
-
-    public IntOption nbThresholdOption = new IntOption(
-            "nbThreshold",
-            'q',
-            "The number of instances a leaf should observe before permitting Naive Bayes.",
-            0, 0, Integer.MAX_VALUE);
-
-    public static class LearningNodeNB extends ActiveLearningNode {
-
-        private static final long serialVersionUID = 1L;
-
-        public LearningNodeNB(double[] initialClassObservations) {
-            super(initialClassObservations);
-        }
-
-        @Override
-        public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
-            if (getWeightSeen() >= ht.nbThresholdOption.getValue()) {
-                return NaiveBayes.doNaiveBayesPrediction(inst,
-                        this.observedClassDistribution,
-                        this.attributeObservers);
-            }
-            return super.getClassVotes(inst, ht);
-        }
-
-        @Override
-        public void disableAttribute(int attIndex) {
-            // should not disable poor atts - they are used in NB calc
-        }
-    }
-
-    public static class LearningNodeNBAdaptive extends LearningNodeNB {
-
-        private static final long serialVersionUID = 1L;
-
-        protected double mcCorrectWeight = 0.0;
-
-        protected double nbCorrectWeight = 0.0;
-
-        public LearningNodeNBAdaptive(double[] initialClassObservations) {
-            super(initialClassObservations);
-        }
-
-        @Override
-        public void learnFromInstance(Instance inst, HoeffdingTree ht) {
-            int trueClass = (int) inst.classValue();
-            if (this.observedClassDistribution.maxIndex() == trueClass) {
-                this.mcCorrectWeight += inst.weight();
-            }
-            if (Utils.maxIndex(NaiveBayes.doNaiveBayesPrediction(inst,
-                    this.observedClassDistribution, this.attributeObservers)) == trueClass) {
-                this.nbCorrectWeight += inst.weight();
-            }
-            super.learnFromInstance(inst, ht);
-        }
-
-        @Override
-        public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
-            if (this.mcCorrectWeight > this.nbCorrectWeight) {
-                return this.observedClassDistribution.getArrayCopy();
-            }
-            return NaiveBayes.doNaiveBayesPrediction(inst,
-                    this.observedClassDistribution, this.attributeObservers);
-        }
-    }
-
-    protected LearningNode newLearningNode() {
-        return newLearningNode(new double[0]);
-    }
-
-    protected LearningNode newLearningNode(double[] initialClassObservations) {
-        LearningNode ret;
-        int predictionOption = this.leafpredictionOption.getChosenIndex();
-        if (predictionOption == 0) { //MC
-            ret = new ActiveLearningNode(initialClassObservations);
-        } else if (predictionOption == 1) { //NB
-            ret = new LearningNodeNB(initialClassObservations);
-        } else { //NBAdaptive
-            ret = new LearningNodeNBAdaptive(initialClassObservations);
-        }
-        return ret;
-    }
-
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-      if (this.getClass() == HoeffdingTree.class)
-        return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-      else
-        return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/trees/HoeffdingTreeClassifLeaves.java b/moa/src/main/java/moa/classifiers/trees/HoeffdingTreeClassifLeaves.java
deleted file mode 100644
index 6112eec94..000000000
--- a/moa/src/main/java/moa/classifiers/trees/HoeffdingTreeClassifLeaves.java
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
- *    HoeffdingTreeClassifLeaves.java
- *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
- *    @author Jesse Read (jesse@tsc.uc3m.es)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.trees;
-
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.Set;
-
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.learners.Classifier;
-import moa.options.ClassOption;
-
-/**
- * Hoeffding Tree that have a classifier at the leaves.
- *
- * A Hoeffding tree is an incremental, anytime decision tree induction algorithm
- * that is capable of learning from massive data streams, assuming that the
- * distribution generating examples does not change over time.
- * 
- * 
- */ 
-public class HoeffdingTreeClassifLeaves extends HoeffdingTree {
-
-    private static final long serialVersionUID = 1L;
-
-    public ClassOption learnerOption = new ClassOption("learner", 'a',
-            "Classifier to train.", Classifier.class, "bayes.NaiveBayes");
-
-    public class LearningNodeClassifier extends ActiveLearningNode {
-
-        protected Classifier classifier;
-
-        private static final long serialVersionUID = 1L;
-
-        public LearningNodeClassifier(double[] initialClassObservations) {
-            super(initialClassObservations);
-        }
-
-        public LearningNodeClassifier(double[] initialClassObservations, Classifier cl, HoeffdingTreeClassifLeaves ht) {
-            super(initialClassObservations);
-            //public void LearningNodeClassifier1(double[] initialClassObservations, Classifier cl, HoeffdingTreeClassifLeaves ht ) {
-
-            if (cl == null) {
-                this.classifier = (Classifier) getPreparedClassOption(ht.learnerOption);
-            } else {
-                this.classifier = (Classifier) cl.copy();
-            }
-        }
-	
-        @Override
-        public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
-            if (getWeightSeen() >= ((HoeffdingTreeClassifLeaves) ht).nbThresholdOption.getValue()) {
-                return this.classifier.getPredictionForInstance(inst).asDoubleArray();
-            }
-            return super.getClassVotes(inst, ht);
-        }
-
-        @Override
-        public void disableAttribute(int attIndex) {
-            // should not disable poor atts - they are used in NB calc
-        }
-
-        @Override
-        public void learnFromInstance(Instance inst, HoeffdingTree ht) {
-            this.classifier.trainOnInstance(inst);
-            super.learnFromInstance(inst, ht);
-        }
-
-        public Classifier getClassifier() {
-            return this.classifier;
-        }
-    }
-
-    public HoeffdingTreeClassifLeaves() {
-        this.removePoorAttsOption = null;
-    }
-
-    @Override
-    protected LearningNode newLearningNode(double[] initialClassObservations) {
-        return new LearningNodeClassifier(initialClassObservations, null, this);
-    }
-
-    //@Override
-    protected LearningNode newLearningNode(double[] initialClassObservations, Classifier cl) {
-        return new LearningNodeClassifier(initialClassObservations, cl, this);
-    }
-
-    @Override
-    protected void attemptToSplit(ActiveLearningNode node, SplitNode parent,
-            int parentIndex) {
-        //ßSystem.out.println("Attempt to Split");
-        if (!node.observedClassDistributionIsPure()) {
-            SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
-            AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion, this);
-            Arrays.sort(bestSplitSuggestions);
-            boolean shouldSplit = false;
-            if (bestSplitSuggestions.length < 2) {
-                shouldSplit = bestSplitSuggestions.length > 0;
-            } else {
-                double hoeffdingBound = computeHoeffdingBound(splitCriterion.getRangeOfMerit(node.getObservedClassDistribution()),
-                        this.splitConfidenceOption.getValue(), node.getWeightSeen());
-                AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-                AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
-               // System.out.println(bestSuggestion.merit+" - "+secondBestSuggestion.merit+":"+
-               //         (bestSuggestion.merit - secondBestSuggestion.merit)+" > "+hoeffdingBound+ "<"+this.tieThresholdOption.getValue());
-                if ((bestSuggestion.merit - secondBestSuggestion.merit > hoeffdingBound)
-                        || (hoeffdingBound < this.tieThresholdOption.getValue())) {
-                    shouldSplit = true;
-                }
-                // }
-                if ((this.removePoorAttsOption != null)
-                        && this.removePoorAttsOption.isSet()) {
-                    Set<Integer> poorAtts = new HashSet<Integer>();
-                    // scan 1 - add any poor to set
-                    for (int i = 0; i < bestSplitSuggestions.length; i++) {
-                        if (bestSplitSuggestions[i].splitTest != null) {
-                            int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
-                            if (splitAtts.length == 1) {
-                                if (bestSuggestion.merit
-                                        - bestSplitSuggestions[i].merit > hoeffdingBound) {
-                                    poorAtts.add(new Integer(splitAtts[0]));
-                                }
-                            }
-                        }
-                    }
-                    // scan 2 - remove good ones from set
-                    for (int i = 0; i < bestSplitSuggestions.length; i++) {
-                        if (bestSplitSuggestions[i].splitTest != null) {
-                            int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
-                            if (splitAtts.length == 1) {
-                                if (bestSuggestion.merit
-                                        - bestSplitSuggestions[i].merit < hoeffdingBound) {
-                                    poorAtts.remove(new Integer(splitAtts[0]));
-                                }
-                            }
-                        }
-                    }
-                    for (int poorAtt : poorAtts) {
-                        node.disableAttribute(poorAtt);
-                    }
-                }
-            }
-            if (shouldSplit) {
-                AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-                if (splitDecision.splitTest == null) {
-                    // preprune - null wins
-                    deactivateLearningNode(node, parent, parentIndex);
-                } else {
-                    SplitNode newSplit = newSplitNode(splitDecision.splitTest,
-                            node.getObservedClassDistribution());
-                    for (int i = 0; i < splitDecision.numSplits(); i++) {
-                        //Unique Change of HoeffdingTree
-                        Node newChild = newLearningNode(splitDecision.resultingClassDistributionFromSplit(i), ((LearningNodeClassifier) node).getClassifier());
-                        newSplit.setChild(i, newChild);
-                    }
-                    this.activeLeafNodeCount--;
-                    this.decisionNodeCount++;
-                    this.activeLeafNodeCount += splitDecision.numSplits();
-                    if (parent == null) {
-                        this.treeRoot = newSplit;
-                    } else {
-                        parent.setChild(parentIndex, newSplit);
-                    }
-                }
-                // manage memory
-                enforceTrackerLimit();
-            }
-        }
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/trees/LimAttHoeffdingTree.java b/moa/src/main/java/moa/classifiers/trees/LimAttHoeffdingTree.java
deleted file mode 100644
index 6c0b669a6..000000000
--- a/moa/src/main/java/moa/classifiers/trees/LimAttHoeffdingTree.java
+++ /dev/null
@@ -1,196 +0,0 @@
-/*
- *    LimAttHoeffdingTree.java
- *    Copyright (C) 2010 University of Waikato, Hamilton, New Zealand
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.trees;
-
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.classifiers.bayes.NaiveBayes;
-import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
-import moa.core.Utils;
-
-/**
- * Hoeffding decision trees with a restricted number of attributes for data
- * streams. LimAttClassifier is the stacking method that can be used with these
- * decision trees. For more information see,<br/> <br/> Albert Bifet, Eibe
- * Frank, Geoffrey Holmes, Bernhard Pfahringer: Accurate Ensembles for Data
- * Streams: Combining Restricted Hoeffding Trees using Stacking. Journal of
- * Machine Learning Research - Proceedings Track 13: 225-240 (2010) * <!--
- * technical-bibtex-start --> BibTeX:
- * <pre>
- * &#64;article{BifetFHP10,
- * author    = {Albert Bifet and
- *              Eibe Frank and
- *              Geoffrey Holmes and
- *              Bernhard Pfahringer},
- * title     = {Accurate Ensembles for Data Streams: Combining Restricted
- *              Hoeffding Trees using Stacking},
- * journal   = {Journal of Machine Learning Research - Proceedings Track},
- * volume    = {13},
- * year      = {2010},
- * pages     = {225-240}
- * }
- * </pre>
- * <p/>
- * <!-- technical-bibtex-end -->
- *
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @version $Revision: 7 $
- */
-public class LimAttHoeffdingTree extends HoeffdingTree {
-
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public String getPurposeString() {
-        return "Hoeffding decision trees with a restricted number of attributes for data streams.";
-    }
-
-    protected int[] listAttributes;
-
-    public void setlistAttributes(int[] list) {
-        this.listAttributes = list;
-    }
-
-    public static class LimAttLearningNode extends ActiveLearningNode {
-
-        private static final long serialVersionUID = 1L;
-
-        protected double weightSeenAtLastSplitEvaluation;
-
-        protected int[] listAttributes;
-
-        protected int numAttributes;
-
-        public LimAttLearningNode(double[] initialClassObservations) {
-            super(initialClassObservations);
-        }
-
-        public void setlistAttributes(int[] list) {
-            this.listAttributes = list;
-            this.numAttributes = list.length;
-        }
-
-        @Override
-        public void learnFromInstance(Instance inst, HoeffdingTree ht) {
-            this.observedClassDistribution.addToValue((int) inst.classValue(),
-                    inst.weight());
-            if (this.listAttributes == null) {
-                setlistAttributes(((LimAttHoeffdingTree) ht).listAttributes);
-            }
-
-            for (int j = 0; j < this.numAttributes; j++) {
-                int i = this.listAttributes[j];
-                int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
-                AttributeClassObserver obs = this.attributeObservers.get(i);
-                if (obs == null) {
-                    obs = inst.attribute(instAttIndex).isNominal() ? ht.newNominalClassObserver() : ht.newNumericClassObserver();
-                    this.attributeObservers.set(i, obs);
-                }
-                obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
-            }
-        }
-    }
-
-    public LimAttHoeffdingTree() {
-        this.removePoorAttsOption = null;
-    }
-
-    public static class LearningNodeNB extends LimAttLearningNode {
-
-        private static final long serialVersionUID = 1L;
-
-        public LearningNodeNB(double[] initialClassObservations) {
-            super(initialClassObservations);
-        }
-
-        @Override
-        public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
-            if (getWeightSeen() >= ht.nbThresholdOption.getValue()) {
-                return NaiveBayes.doNaiveBayesPrediction(inst,
-                        this.observedClassDistribution,
-                        this.attributeObservers);
-            }
-            return super.getClassVotes(inst, ht);
-        }
-
-        @Override
-        public void disableAttribute(int attIndex) {
-            // should not disable poor atts - they are used in NB calc
-        }
-    }
-
-    public static class LearningNodeNBAdaptive extends LearningNodeNB {
-
-        private static final long serialVersionUID = 1L;
-
-        protected double mcCorrectWeight = 0.0;
-
-        protected double nbCorrectWeight = 0.0;
-
-        public LearningNodeNBAdaptive(double[] initialClassObservations) {
-            super(initialClassObservations);
-        }
-
-        @Override
-        public void learnFromInstance(Instance inst, HoeffdingTree ht) {
-            int trueClass = (int) inst.classValue();
-            if (this.observedClassDistribution.maxIndex() == trueClass) {
-                this.mcCorrectWeight += inst.weight();
-            }
-            if (Utils.maxIndex(NaiveBayes.doNaiveBayesPrediction(inst,
-                    this.observedClassDistribution, this.attributeObservers)) == trueClass) {
-                this.nbCorrectWeight += inst.weight();
-            }
-            super.learnFromInstance(inst, ht);
-        }
-
-        @Override
-        public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
-            if (this.mcCorrectWeight > this.nbCorrectWeight) {
-                return this.observedClassDistribution.getArrayCopy();
-            }
-            double ret[] = NaiveBayes.doNaiveBayesPrediction(inst,
-                    this.observedClassDistribution, this.attributeObservers);
-            for (int i = 0; i < ret.length; i++) {
-                ret[i] *= this.observedClassDistribution.sumOfValues();
-            }
-            return ret;
-        }
-    }
-
-    @Override
-    protected LearningNode newLearningNode(double[] initialClassObservations) {
-        LearningNode ret;
-        int predictionOption = this.leafpredictionOption.getChosenIndex();
-        if (predictionOption == 0) { //MC
-            ret = new LimAttLearningNode(initialClassObservations);
-        } else if (predictionOption == 1) { //NB
-            ret = new LearningNodeNB(initialClassObservations);
-        } else { //NBAdaptive
-            ret = new LearningNodeNBAdaptive(initialClassObservations);
-        }
-        return ret;
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return true;
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/trees/RandomHoeffdingTree.java b/moa/src/main/java/moa/classifiers/trees/RandomHoeffdingTree.java
deleted file mode 100644
index 884c285b3..000000000
--- a/moa/src/main/java/moa/classifiers/trees/RandomHoeffdingTree.java
+++ /dev/null
@@ -1,171 +0,0 @@
-/*
- *    RandomHoeffdingTree.java
- *    Copyright (C) 2010 University of Waikato, Hamilton, New Zealand
- *    @author Albert Bifet (abifet@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.classifiers.trees;
-
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.classifiers.bayes.NaiveBayes;
-import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
-import moa.core.Utils;
-
-/**
- * Random decision trees for data streams.
- *
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @version $Revision: 7 $
- */
-public class RandomHoeffdingTree extends HoeffdingTree {
-
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public String getPurposeString() {
-        return "Random decision trees for data streams.";
-    }
-
-    public static class RandomLearningNode extends ActiveLearningNode {
-
-        private static final long serialVersionUID = 1L;
-
-        protected int[] listAttributes;
-
-        protected int numAttributes;
-
-        public RandomLearningNode(double[] initialClassObservations) {
-            super(initialClassObservations);
-        }
-
-        @Override
-        public void learnFromInstance(Instance inst, HoeffdingTree ht) {
-            this.observedClassDistribution.addToValue((int) inst.classValue(),
-                    inst.weight());
-            if (this.listAttributes == null) {
-                this.numAttributes = (int) Math.floor(Math.sqrt(inst.numAttributes()));
-                this.listAttributes = new int[this.numAttributes];
-                for (int j = 0; j < this.numAttributes; j++) {
-                    boolean isUnique = false;
-                    while (isUnique == false) {
-                        this.listAttributes[j] = ht.classifierRandom.nextInt(inst.numAttributes() - 1);
-                        isUnique = true;
-                        for (int i = 0; i < j; i++) {
-                            if (this.listAttributes[j] == this.listAttributes[i]) {
-                                isUnique = false;
-                                break;
-                            }
-                        }
-                    }
-
-                }
-            }
-            for (int j = 0; j < this.numAttributes - 1; j++) {
-                int i = this.listAttributes[j];
-                int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
-                AttributeClassObserver obs = this.attributeObservers.get(i);
-                if (obs == null) {
-                    obs = inst.attribute(instAttIndex).isNominal() ? ht.newNominalClassObserver() : ht.newNumericClassObserver();
-                    this.attributeObservers.set(i, obs);
-                }
-                obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
-            }
-        }
-    }
-
-    public static class LearningNodeNB extends RandomLearningNode {
-
-        private static final long serialVersionUID = 1L;
-
-        public LearningNodeNB(double[] initialClassObservations) {
-            super(initialClassObservations);
-        }
-
-        @Override
-        public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
-            if (getWeightSeen() >= ht.nbThresholdOption.getValue()) {
-                return NaiveBayes.doNaiveBayesPrediction(inst,
-                        this.observedClassDistribution,
-                        this.attributeObservers);
-            }
-            return super.getClassVotes(inst, ht);
-        }
-
-        @Override
-        public void disableAttribute(int attIndex) {
-            // should not disable poor atts - they are used in NB calc
-        }
-    }
-
-    public static class LearningNodeNBAdaptive extends LearningNodeNB {
-
-        private static final long serialVersionUID = 1L;
-
-        protected double mcCorrectWeight = 0.0;
-
-        protected double nbCorrectWeight = 0.0;
-
-        public LearningNodeNBAdaptive(double[] initialClassObservations) {
-            super(initialClassObservations);
-        }
-
-        @Override
-        public void learnFromInstance(Instance inst, HoeffdingTree ht) {
-            int trueClass = (int) inst.classValue();
-            if (this.observedClassDistribution.maxIndex() == trueClass) {
-                this.mcCorrectWeight += inst.weight();
-            }
-            if (Utils.maxIndex(NaiveBayes.doNaiveBayesPrediction(inst,
-                    this.observedClassDistribution, this.attributeObservers)) == trueClass) {
-                this.nbCorrectWeight += inst.weight();
-            }
-            super.learnFromInstance(inst, ht);
-        }
-
-        @Override
-        public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
-            if (this.mcCorrectWeight > this.nbCorrectWeight) {
-                return this.observedClassDistribution.getArrayCopy();
-            }
-            return NaiveBayes.doNaiveBayesPrediction(inst,
-                    this.observedClassDistribution, this.attributeObservers);
-        }
-    }
-
-    public RandomHoeffdingTree() {
-        this.removePoorAttsOption = null;
-    }
-
-    @Override
-    protected LearningNode newLearningNode(double[] initialClassObservations) {
-        LearningNode ret;
-        int predictionOption = this.leafpredictionOption.getChosenIndex();
-        if (predictionOption == 0) { //MC
-            ret = new RandomLearningNode(initialClassObservations);
-        } else if (predictionOption == 1) { //NB
-            ret = new LearningNodeNB(initialClassObservations);
-        } else { //NBAdaptive
-            ret = new LearningNodeNBAdaptive(initialClassObservations);
-        }
-        return ret;
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return true;
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/trees/iadem/Iadem2.java b/moa/src/main/java/moa/classifiers/trees/iadem/Iadem2.java
deleted file mode 100644
index 0f39229f4..000000000
--- a/moa/src/main/java/moa/classifiers/trees/iadem/Iadem2.java
+++ /dev/null
@@ -1,2072 +0,0 @@
-/*
- *    IADEM2cTree.java
- *
- *    @author José del Campo-Ávila
- * 
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-package moa.classifiers.trees.iadem;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Iterator;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
-import moa.classifiers.core.conditionaltests.NominalAttributeBinaryTest;
-import moa.classifiers.core.driftdetection.AbstractChangeDetector;
-import moa.core.AutoExpandVector;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import moa.core.Utils;
-import moa.learners.Classifier;
-import moa.options.ClassOption;
-
-public class Iadem2 extends AbstractClassifier implements Classifier {
-
-    private static final long serialVersionUID = 1L;
-    public ClassOption numericEstimatorOption = new ClassOption("numericEstimator",
-            'z', "Numeric estimator to use.", IademNumericAttributeObserver.class,
-            "IademGaussianNumericAttributeClassObserver");
-    public IntOption gracePeriodOption = new IntOption("gracePeriod", 'n',
-            "The number of instances the tree should observe between splitting attempts.",
-            100, 1, Integer.MAX_VALUE);
-    public MultiChoiceOption splitCriterionOption = new MultiChoiceOption("splitCriterion", 's',
-            "Split criterion to use.", new String[]{
-                "entropy", "entropy_logVar", "entropy_logVar+Peso", "entropy_Peso", "beta1", "gamma1", "beta2", "gamma2", "beta4", "gamma4"}, new String[]{
-                "entropy", "entropy_logVar", "entropy_logVar+Peso", "entropy_Peso", "beta1", "gamma1", "beta2", "gamma2", "beta4", "gamma4"}, 0);
-    public FloatOption splitConfidenceOption = new FloatOption("splitConfidence", 'c',
-            "The allowable error in split decision, values closer to 0 will take longer to decide.",
-            0.01, 0.0, 1.0);
-    public MultiChoiceOption splitTestsOption = new MultiChoiceOption("splitChoice", 'i',
-            "Methods for splitting leaf nodes.",
-            new String[]{
-                "onlyBinarySplit", "onlyMultiwaySplit", "bestSplit"}, new String[]{
-                "onlyBinary", "onlyMultiway", "bestSplit"},
-            2);
-
-    public MultiChoiceOption leafPredictionOption = new MultiChoiceOption("leafPrediction", 'b',
-            "Leaf prediction to use.", new String[]{
-                "MC", "NB", "NBKirkby", "WeightedVote"},
-            new String[]{"MC: Majority class.",
-                "NB: Naïve Bayes.",
-                "NBKirkby.",
-                "WeightedVote: Weighted vote between NB and MC."},
-            1);
-    public ClassOption driftDetectionMethodOption = new ClassOption("driftDetectionMethod", 'd',
-            "Drift detection method to use.", AbstractChangeDetector.class, "HDDM_A_Test");
-
-    // fixed option...
-    public FloatOption attributeDiferentiation = new FloatOption("attritubeDiferentiation", 'a',
-            "Attribute differenciation",
-            0.1, 0.0, 1.0);
-
-    public final int naiveBayesLimit = 0;
-    public final double percentInCommon = 0.75;
-    protected int numberOfInstancesProcessed = 0;
-
-    @Override
-    public boolean isRandomizable() {
-        return false;
-    }
-
-    @Override
-    public void resetLearningImpl() {
-        this.numberOfInstancesProcessed = 0;
-        this.treeRoot = null;
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        if (this.treeRoot == null) {
-            IademCommonProcedures.setConfidence(this.splitConfidenceOption.getValue());
-            this.estimator = (AbstractChangeDetector) ((AbstractChangeDetector) getPreparedClassOption(this.driftDetectionMethodOption)).copy();
-            createRoot(inst);
-        }
-        try {
-            learnFromInstance(inst);
-        } catch (IademException ex) {
-            Logger.getLogger(Iadem2.class.getName()).log(Level.SEVERE, null, ex);
-        }
-    }
-
-    protected IademNumericAttributeObserver newNumericClassObserver() {
-        IademNumericAttributeObserver numericClassObserver = (IademNumericAttributeObserver) getPreparedClassOption(this.numericEstimatorOption);
-        return (IademNumericAttributeObserver) numericClassObserver.copy();
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return new Measurement[]{
-            new Measurement("tree size (nodes)", this.getNumberOfNodes()),
-            new Measurement("tree size (leaves)", this.getNumberOfLeaves())
-        };
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-    }
-
-    @Override
-    public Prediction getPredictionForInstance(Instance inst) {
-        if (this.treeRoot == null) {
-            DoubleVector classVotes = new DoubleVector();
-            double estimation = 1.0 / inst.classAttribute().numValues();
-            for (int i = 0; i < inst.classAttribute().numValues(); i++) {
-                classVotes.addToValue(i, estimation);
-            }
-            return new ClassificationPrediction(classVotes.getArrayCopy());
-
-        }
-        DoubleVector predicciones = new DoubleVector(this.treeRoot.getClassVotes(inst));
-        return new ClassificationPrediction(predicciones.getArrayCopy());
-
-    }
-
-    final public static double ERROR_MARGIN = 1.0e-9;
-    protected Node treeRoot;
-    
-    protected AbstractChangeDetector estimator;
-
-    public int numberOfNodes = 1,
-            numberOfLeaves = 1;
-
-    public AbstractChangeDetector newEstimator() {
-        return (AbstractChangeDetector) this.estimator.copy();
-    }
-
-    public void createRoot(Instance instance) {
-        double[] arrayCounter = new double[instance.numClasses()];
-        Arrays.fill(arrayCounter, 0);
-
-        this.treeRoot = newLeafNode(null, 0, 0, arrayCounter, instance);
-    }
-
-    public int getMaxNumberOfBins() {
-        return (int) this.newNumericClassObserver().getMaxOfValues();
-    }
-
-    public IademNumericAttributeObserver getNumericAttObserver() {
-        return newNumericClassObserver();
-    }
-
-    public long getNumberOfInstancesProcessed() {
-        return numberOfInstancesProcessed;
-    }
-
-    public LeafNode newLeafNode(Node parent,
-            long instTreeCountSinceVirtual,
-            long instNodeCountSinceVirtual,
-            double[] classDist,
-            Instance instance) {
-        switch (this.leafPredictionOption.getChosenIndex()) {
-            case 0: {
-                return new LeafNode(this,
-                        parent,
-                        instTreeCountSinceVirtual,
-                        instNodeCountSinceVirtual,
-                        classDist,
-                        newNumericClassObserver(),
-                        this.splitTestsOption.getChosenIndex() == 2,
-                        this.splitTestsOption.getChosenIndex() == 0,
-                        instance);
-            }
-            case 1: {
-                return new LeafNodeNB(this,
-                        parent,
-                        instTreeCountSinceVirtual,
-                        instNodeCountSinceVirtual,
-                        classDist,
-                        newNumericClassObserver(),
-                        this.naiveBayesLimit,
-                        this.splitTestsOption.getChosenIndex() == 2,
-                        this.splitTestsOption.getChosenIndex() == 0,
-                        instance);
-            }
-            case 2: {
-                return new LeafNodeNBKirkby(this,
-                        parent,
-                        instTreeCountSinceVirtual,
-                        instNodeCountSinceVirtual,
-                        classDist,
-                        newNumericClassObserver(),
-                        this.naiveBayesLimit,
-                        this.splitTestsOption.getChosenIndex() == 2,
-                        this.splitTestsOption.getChosenIndex() == 0,
-                        (AbstractChangeDetector) ((AbstractChangeDetector) getPreparedClassOption(this.driftDetectionMethodOption)).copy(),
-                        instance);
-            }
-            default: {
-                return new LeafNodeWeightedVote(this,
-                        parent,
-                        instTreeCountSinceVirtual,
-                        instNodeCountSinceVirtual,
-                        classDist,
-                        newNumericClassObserver(),
-                        this.naiveBayesLimit,
-                        this.splitTestsOption.getChosenIndex() == 2,
-                        this.splitTestsOption.getChosenIndex() == 0,
-                        (AbstractChangeDetector) ((AbstractChangeDetector) getPreparedClassOption(this.driftDetectionMethodOption)).copy(),
-                        instance);
-            }
-        }
-    }
-
-    public double getAttributeDifferentiation() {
-        return this.attributeDiferentiation.getValue();
-    }
-
-    public IademSplitCriterion getMeasure() throws IademException {
-        return new IademSplitCriterion(this.splitCriterionOption.getChosenLabel());
-    }
-
-    public void setTreeRoot(Node newRoot) {
-        this.treeRoot = newRoot;
-    }
-
-    public void learnFromInstance(Instance instance)
-            throws IademException {
-        this.numberOfInstancesProcessed++;
-        this.treeRoot.learnFromInstance(instance);
-    }
-
-    public Node getTreeRoot() {
-        return this.treeRoot;
-    }
-
-    public double[] getClassVotes(Instance instance) {
-        return this.treeRoot.getClassVotes(instance);
-    }
-
-    public double getPercentInCommon() {
-        return this.percentInCommon;
-    }
-
-    public int getValuesOfNominalAttributes(int attIndex, Instance instance) {
-        return instance.attribute(attIndex).numValues();
-    }
-
-    public int getNaiveBayesLimit() {
-        return this.naiveBayesLimit;
-    }
-
-    public boolean isOnlyMultiwayTest() {
-        return this.splitTestsOption.getChosenIndex() == 2;
-    }
-
-    public boolean isOnlyBinaryTest() {
-        return this.splitTestsOption.getChosenIndex() == 0;
-    }
-
-    public void incrNumberOfInstancesProcessed() {
-        this.numberOfInstancesProcessed++;
-    }
-
-    public void getNumberOfNodes(int[] count) {
-        this.treeRoot.getNumberOfNodes(count);
-    }
-
-    public void newSplit(int numOfLeaves) {
-        this.numberOfLeaves += numOfLeaves - 1;
-        this.numberOfNodes += numOfLeaves;
-    }
-
-    public int getNumberOfNodes() {
-        return numberOfNodes;
-    }
-
-    public void setNumberOfNodes(int numberOfNodes) {
-        this.numberOfNodes = numberOfNodes;
-    }
-
-    public int getNumberOfLeaves() {
-        return numberOfLeaves;
-    }
-
-    public void setNumberOfLeaves(int numberOfLeaves) {
-        this.numberOfLeaves = numberOfLeaves;
-    }
-
-    public abstract class Node implements Serializable {
-
-        private static final long serialVersionUID = 1L;
-
-        protected Iadem2 tree;
-
-        protected DoubleVector classValueDist;
-
-        public Node parent;
-
-        public DoubleVector getClassValueDist() {
-            return classValueDist;
-        }
-
-        public void setClassValueDist(DoubleVector classValueDist) {
-            this.classValueDist = classValueDist;
-        }
-
-        public Iadem2 getTree() {
-            return tree;
-        }
-
-        public void setTree(Iadem2 tree) {
-            this.tree = tree;
-        }
-
-        public Node(Iadem2 tree,
-                Node parent,
-                double[] initialClassCount) {
-            this.tree = tree;
-            this.parent = parent;
-            this.classValueDist = new DoubleVector(initialClassCount);
-        }
-
-        public abstract int getSubtreeNodeCount();
-
-        public void setParent(Node parent) {
-            this.parent = parent;
-        }
-
-        public Node getParent() {
-            return parent;
-        }
-
-        public abstract Node learnFromInstance(Instance instance);
-
-        public abstract ArrayList<LeafNode> getLeaves();
-
-        public abstract double[] getClassVotes(Instance instance);
-
-        public int getChildCount() {
-            return 0;
-        }
-
-        public abstract void getNumberOfNodes(int[] count);
-    }
-
-    public class LeafNode extends Node {
-
-        private static final long serialVersionUID = 1L;
-        protected long instNodeCountSinceVirtual;
-        protected long instTreeCountSinceReal;
-        protected long instNodeCountSinceReal;
-        protected AutoExpandVector<VirtualNode> virtualChildren = new AutoExpandVector<>();
-        protected boolean allAttUsed;
-
-        protected double instSeenSinceLastSplitAttempt = 0;
-
-        protected boolean split;
-
-        public LeafNode(Iadem2 tree,
-                Node parent,
-                long instTreeCountSinceVirtual,
-                long instNodeCountSinceVirtual,
-                double[] initialClassCount,
-                IademNumericAttributeObserver numericAttClassObserver,
-                boolean onlyMultiwayTest,
-                boolean onlyBinaryTest,
-                Instance instance) {
-            super(tree, parent, initialClassCount);
-            this.instNodeCountSinceVirtual = instNodeCountSinceVirtual;
-            this.instTreeCountSinceReal = 0;
-            this.instNodeCountSinceReal = 0;
-            this.split = true;
-            createVirtualNodes(numericAttClassObserver,
-                    onlyMultiwayTest,
-                    onlyBinaryTest,
-                    instance);
-        }
-
-        public double getInstSeenSinceLastSplitAttempt() {
-            return instSeenSinceLastSplitAttempt;
-        }
-
-        public void setInstSeenSinceLastSplitAttempt(double instSeenSinceLastSplitAttempt) {
-            this.instSeenSinceLastSplitAttempt = instSeenSinceLastSplitAttempt;
-        }
-
-        public AutoExpandVector<VirtualNode> getVirtualChildren() {
-            return this.virtualChildren;
-        }
-
-        public void setVirtualChildren(AutoExpandVector<VirtualNode> virtualChildren) {
-            this.virtualChildren = virtualChildren;
-        }
-
-        protected void createVirtualNodes(IademNumericAttributeObserver numericObserver,
-                boolean onlyMultiwayTest,
-                boolean onlyBinaryTest,
-                Instance instance) {
-            for (int i = 0; i < instance.numAttributes(); i++) {
-                if (instance.classIndex() != i
-                        && instance.attribute(i).isNominal()) {
-                    this.virtualChildren.set(i, new NominalVirtualNode(this.tree,
-                            this,
-                            i,
-                            onlyMultiwayTest,
-                            onlyBinaryTest));
-                } else if (instance.classIndex() != i
-                        && instance.attribute(i).isNumeric()) {
-                    this.virtualChildren.set(i, new NumericVirtualNode(this.tree,
-                            this,
-                            i,
-                            numericObserver));
-
-                } else { // class attribute
-                    this.virtualChildren.set(i, null);
-                }
-            }
-
-        }
-
-        protected ArrayList<Integer> nominalAttUsed(Instance instance) {
-            SplitNode currentNode = (SplitNode) this.parent;
-            ArrayList<Integer> nomAttUsed = new ArrayList<Integer>();
-            while (currentNode != null) {
-                if (instance.attribute(currentNode.splitTest.getAttsTestDependsOn()[0]).isNominal()) {
-                    nomAttUsed.add(currentNode.splitTest.getAttsTestDependsOn()[0]);
-                }
-                currentNode = (SplitNode) currentNode.parent;
-            }
-            return nomAttUsed;
-        }
-
-        @Override
-        public Iadem2 getTree() {
-            return this.tree;
-        }
-
-        @Override
-        public int getSubtreeNodeCount() {
-            return 1;
-        }
-
-        @Override
-        public ArrayList<LeafNode> getLeaves() {
-            ArrayList<LeafNode> leaf = new ArrayList<LeafNode>();
-            leaf.add(this);
-            return leaf;
-        }
-
-        public boolean isAllAttUsed() {
-            return allAttUsed;
-        }
-
-        public void attemptToSplit(Instance instance) {
-            if (this.classValueDist.numNonZeroEntries() > 1) {
-                if (hasInformationToSplit()) {
-                    try {
-                        this.instSeenSinceLastSplitAttempt = 0;
-                        IademAttributeSplitSuggestion bestSplitSuggestion;
-
-                        bestSplitSuggestion = getBestSplitSuggestion(instance);
-                        if (bestSplitSuggestion != null) {
-                            doSplit(bestSplitSuggestion, instance);
-                        }
-                    } catch (IademException ex) {
-                        Logger.getLogger(LeafNode.class.getName()).log(Level.SEVERE, null, ex);
-                    }
-                }
-            }
-        }
-
-        @Override
-        public Node learnFromInstance(Instance inst) {
-            this.instNodeCountSinceVirtual += inst.weight();
-            this.classValueDist.addToValue((int) inst.value(inst.classIndex()), inst.weight());
-            this.instNodeCountSinceReal += inst.weight();
-            this.instSeenSinceLastSplitAttempt += inst.weight();
-            for (int i = 0; i < inst.numAttributes() - 1; i++) {
-                VirtualNode virtual = this.virtualChildren.get(i);
-                if (virtual != null) {
-                    virtual.learnFromInstance(inst);
-                }
-            }
-            if (this.split) {
-                attemptToSplit(inst);
-            }
-            return this;
-        }
-
-        protected IademAttributeSplitSuggestion getFastSplitSuggestion(Instance instance) throws IademException {
-            int bestAttIndex = -1;
-            double bestAttValue = Double.MAX_VALUE;
-            for (int i = 0; i < virtualChildren.size(); i++) {
-                VirtualNode currentVirtualChild = virtualChildren.get(i);
-                if (currentVirtualChild != null) {
-                    try {
-                        currentVirtualChild.updateHeuristicMeasure(instance);
-                    } catch (IademException e) {
-                        throw new IademException("LeafNode", "getFastSplitSuggestion",
-                                "Problems when updating measures: \n"
-                                + e.getMessage());
-                    }
-                    if (currentVirtualChild.getHeuristicMeasureUpper(instance) >= 0) {
-                        if (currentVirtualChild.getHeuristicMeasureUpper(instance) < bestAttValue) {
-                            bestAttIndex = i;
-                            bestAttValue = currentVirtualChild.getHeuristicMeasureUpper(instance);
-                        }
-                    }
-                }
-            }
-            if (bestAttIndex != -1) {
-                return virtualChildren.get(bestAttIndex).getBestSplitSuggestion();
-            } else {
-                return null;
-            }
-        }
-
-        public IademAttributeSplitSuggestion getBestSplitSuggestion(Instance instance) throws IademException {
-            return getBestSplitSuggestionIADEM(instance);
-        }
-
-        public LeafNode[] doSplit(IademAttributeSplitSuggestion bestSuggestion, Instance instance) {
-            SplitNode splitNode = virtualChildren.get(bestSuggestion.splitTest.getAttsTestDependsOn()[0]).getNewSplitNode(
-                    this.instTreeCountSinceReal,
-                    this.parent,
-                    bestSuggestion,
-                    instance);
-            splitNode.setParent(this.parent);
-
-            if (this.parent == null) {
-                this.tree.setTreeRoot(splitNode);
-            } else {
-                ((SplitNode) this.parent).changeChildren(this, splitNode);
-            }
-
-            this.tree.newSplit(splitNode.getLeaves().size());
-            return null;
-        }
-
-        @Override
-        public double[] getClassVotes(Instance obs) {
-            return getMajorityClassVotes(obs);
-        }
-
-        public double[] getMajorityClassVotes(Instance instance) {
-            double[] votes = new double[instance.attribute(instance.classIndex()).numValues()];
-            Arrays.fill(votes, 0.0);
-            if (instNodeCountSinceVirtual == 0) {
-                if (parent != null) {
-                    ArrayList<LeafNode> siblings = parent.getLeaves();
-                    siblings.remove(this);
-                    ArrayList<LeafNode> siblingWithInfo = new ArrayList<LeafNode>();
-                    long count = 0;
-                    for (LeafNode currentSibling : siblings) {
-                        if (currentSibling.getInstNodeCountSinceVirtual() > 0) {
-                            siblingWithInfo.add(currentSibling);
-                            count += currentSibling.getInstNodeCountSinceVirtual();
-                        }
-                    }
-                    if (count > 0) {
-                        for (LeafNode currentSibling : siblingWithInfo) {
-                            double[] sibVotes = currentSibling.getMajorityClassVotes(instance);
-                            double weight = (double) currentSibling.getInstNodeCountSinceVirtual() / (double) count;
-                            for (int i = 0; i < votes.length; i++) {
-                                votes[i] += weight * sibVotes[i];
-                            }
-                        }
-                    }
-                }
-            } else {
-                for (int i = 0; i < votes.length; i++) {
-                    votes[i] = classValueDist.getValue(i) / (double) instNodeCountSinceVirtual;
-                }
-            }
-            // normalize votes
-            double voteCount = 0.0;
-            for (int i = 0; i < votes.length; i++) {
-                voteCount += votes[i];
-            }
-            if (voteCount == 0.0) {
-                for (int i = 0; i < votes.length; i++) {
-                    votes[i] = 1.0 / (double) votes.length;
-                }
-            } else {
-                for (int i = 0; i < votes.length; i++) {
-                    votes[i] /= voteCount;
-                }
-            }
-            return votes;
-        }
-
-        public long getInstNodeCountSinceVirtual() {
-            return instNodeCountSinceVirtual;
-        }
-
-        private double percentInCommon(double A_upper, double A_lower, double B_upper,
-                double B_lower) {
-            double percent;
-
-            // nothing in common
-            if ((A_lower >= B_upper) || (A_upper <= B_lower)) {
-                percent = 0.0;
-            } else { // something in common
-                double A_out = 0.0;
-                double A_margin = A_upper - A_lower;
-
-                if ((A_upper <= B_upper) && (A_lower >= B_lower)) {
-                    A_out = 0.0;
-                } else if ((A_upper > B_upper) && (A_lower >= B_lower)) {
-                    A_out = A_upper - B_upper;
-                } else if ((A_upper > B_upper) && (A_lower < B_lower)) {
-                    A_out = (A_upper - B_upper) + (B_lower - A_lower);
-                } else if ((A_upper <= B_upper) && (A_lower < B_lower)) {
-                    A_out = B_lower - A_lower;
-                } else {
-                    // TODO remove next line
-                    System.out.println("Something is wrong");
-                }
-                percent = (A_margin - A_out) / A_margin;
-            }
-
-            return percent;
-        }
-
-        public boolean hasInformationToSplit() {
-            return this.instSeenSinceLastSplitAttempt >= this.tree.gracePeriodOption.getValue();
-        }
-
-        public IademAttributeSplitSuggestion getBestSplitSuggestionIADEM(Instance instance) throws IademException {
-            int bestAtt;
-
-            int bestAttIndex = -1;
-            int secondBestAttIndex = -1;
-            double bestAtt_upper = Double.MAX_VALUE;
-            double bestAtt_lower = Double.MAX_VALUE;
-            double secondBestAtt_upper = Double.MAX_VALUE;
-            double secondBestAtt_lower = Double.MAX_VALUE;
-            double worstAtt_upper = Double.MIN_VALUE;
-            double worstAtt_lower = Double.MIN_VALUE;
-
-            for (int i = 0; i < virtualChildren.size(); i++) {
-                VirtualNode currentVirtualChild = virtualChildren.get(i);
-                if (currentVirtualChild != null) {
-                    try {
-                        currentVirtualChild.updateHeuristicMeasure(instance);
-                    } catch (IademException e) {
-                        throw new IademException("LeafNode", "getBestSplitSuggestion7",
-                                "Problems when updating measures: \n"
-                                + e.getMessage());
-                    }
-                    // find the best and second-best attributes
-                    if (currentVirtualChild.getHeuristicMeasureUpper(instance) >= 0) {
-                        if ((currentVirtualChild.getHeuristicMeasureUpper(instance) < bestAtt_upper)
-                                || ((currentVirtualChild.getHeuristicMeasureUpper(instance) == bestAtt_upper)
-                                && (currentVirtualChild.getHeuristicMeasureLower(instance) < bestAtt_lower))) {
-
-                            secondBestAttIndex = bestAttIndex;
-                            secondBestAtt_upper = bestAtt_upper;
-                            secondBestAtt_lower = bestAtt_lower;
-
-                            bestAttIndex = i;
-                            bestAtt_upper = currentVirtualChild.getHeuristicMeasureUpper(instance);
-                            bestAtt_lower = currentVirtualChild.getHeuristicMeasureLower(instance);
-                        } else if ((currentVirtualChild.getHeuristicMeasureUpper(instance) < secondBestAtt_upper)
-                                || ((currentVirtualChild.getHeuristicMeasureUpper(instance) == secondBestAtt_upper)
-                                && (currentVirtualChild.getHeuristicMeasureLower(instance) < secondBestAtt_lower))) {
-                            secondBestAttIndex = i;
-                            secondBestAtt_upper = currentVirtualChild.getHeuristicMeasureUpper(instance);
-                            secondBestAtt_lower = currentVirtualChild.getHeuristicMeasureLower(instance);
-                        }
-                        // find the worst attribute
-                        if ((currentVirtualChild.getHeuristicMeasureUpper(instance) > worstAtt_upper)
-                                || ((currentVirtualChild.getHeuristicMeasureUpper(instance) == worstAtt_upper)
-                                && (currentVirtualChild.getHeuristicMeasureLower(instance) > worstAtt_lower))) {
-                            worstAtt_upper = currentVirtualChild.getHeuristicMeasureUpper(instance);
-                            worstAtt_lower = currentVirtualChild.getHeuristicMeasureLower(instance);
-                        }
-                    }
-                }
-            }
-            bestAtt = bestAttIndex;
-            if (secondBestAttIndex != -1) {
-                // percents in common
-                // best and worst
-                double best_worst = percentInCommon(bestAtt_upper,
-                        bestAtt_lower,
-                        worstAtt_upper,
-                        worstAtt_lower);
-                double worst_best = percentInCommon(worstAtt_upper, worstAtt_lower,
-                        bestAtt_upper,
-                        bestAtt_lower);
-
-                double d = tree.getAttributeDifferentiation();
-
-                boolean similarityBestWorst = (best_worst >= (1.0 - d))
-                        && (worst_best >= (1.0 - d));
-
-                boolean similarityWithConfidenceBestWorst = similarityBestWorst
-                        && ((bestAtt_upper - bestAtt_lower) <= d);
-
-                boolean differenceBestWorst = (best_worst <= d)
-                        || (worst_best <= d);
-                if (!similarityWithConfidenceBestWorst && !differenceBestWorst) {
-                    bestAtt = -1;
-                }
-            }
-
-            if (bestAtt != -1) {
-                VirtualNode bestNode = virtualChildren.get(bestAtt);
-                double percent;
-                if (bestNode instanceof NumericVirtualNode) {
-                    percent = 1.0 - bestNode.getPercent();
-                } else {
-                    percent = bestNode.getPercent();
-                }
-                if (percent > tree.getPercentInCommon()) {
-                    bestAtt = -1;
-                }
-            }
-            if (bestAtt >= 0) {
-                return virtualChildren.get(bestAtt).bestSplitSuggestion;
-            }
-            return null;
-        }
-
-        @Override
-        public void getNumberOfNodes(int[] count) {
-            count[1]++;
-        }
-
-        public void setSplit(boolean split) {
-            this.split = split;
-        }
-    }
-
-    public class LeafNodeNB extends LeafNode {
-
-        private static final long serialVersionUID = 1L;
-        protected int naiveBayesLimit;
-
-        public LeafNodeNB(Iadem2 tree,
-                Node parent,
-                long instTreeCountSinceVirtual,
-                long instNodeCountSinceVirtual,
-                double[] initialClassVotes,
-                IademNumericAttributeObserver numericAttClassObserver,
-                int naiveBayesLimit,
-                boolean onlyMultiwayTest,
-                boolean onlyBinaryTest,
-                Instance instance) {
-            super(tree,
-                    parent,
-                    instTreeCountSinceVirtual,
-                    instNodeCountSinceVirtual,
-                    initialClassVotes,
-                    numericAttClassObserver,
-                    onlyMultiwayTest,
-                    onlyBinaryTest,
-                    instance);
-            this.naiveBayesLimit = naiveBayesLimit;
-        }
-
-        @Override
-        public double[] getClassVotes(Instance inst) {
-            double[] classVotes;
-            if (instNodeCountSinceVirtual == 0 || instNodeCountSinceReal < naiveBayesLimit) {
-                classVotes = getMajorityClassVotes(inst);
-            } else {
-                classVotes = getNaiveBayesPrediction(inst);
-            }
-            return classVotes;
-        }
-
-        protected double[] getNaiveBayesPrediction(Instance obs) {
-            double[] classVotes = getMajorityClassVotes(obs);
-            DoubleVector condProbabilities;
-            for (int i = 0; i < virtualChildren.size(); i++) {
-                VirtualNode currentVirtualNode = virtualChildren.get(i);
-                if (currentVirtualNode != null && currentVirtualNode.hasInformation()) {
-                    double valor = obs.value(i);
-                    condProbabilities = currentVirtualNode.computeConditionalProbability(valor);
-                    if (condProbabilities != null) {
-                        for (int j = 0; j < classVotes.length; j++) {
-                            classVotes[j] *= condProbabilities.getValue(j);
-                        }
-                    }
-                }
-            }
-            // normalize class votes
-            double classVoteCount = 0.0;
-            for (int i = 0; i < classVotes.length; i++) {
-                classVoteCount += classVotes[i];
-            }
-            if (classVoteCount == 0.0) {
-                for (int i = 0; i < classVotes.length; i++) {
-                    classVotes[i] = 1.0 / classVotes.length;
-                }
-            } else {
-                for (int i = 0; i < classVotes.length; i++) {
-                    classVotes[i] /= classVoteCount;
-                }
-            }
-            return classVotes;
-        }
-    }
-
-    public class LeafNodeNBKirkby extends LeafNodeNB {
-
-        private static final long serialVersionUID = 1L;
-        protected int naiveBayesError,
-                majorityClassError;
-
-        public LeafNodeNBKirkby(Iadem2 tree,
-                Node parent,
-                long instancesProcessedByTheTree,
-                long instancesProcessedByThisLeaf,
-                double[] classDist,
-                IademNumericAttributeObserver numericAttClassObserver,
-                int naiveBayesLimit,
-                boolean onlyMultiwayTest,
-                boolean onlyBinaryTest,
-                AbstractChangeDetector estimator,
-                Instance instance) {
-            super(tree,
-                    parent,
-                    instancesProcessedByTheTree,
-                    instancesProcessedByThisLeaf,
-                    classDist,
-                    numericAttClassObserver,
-                    naiveBayesLimit,
-                    onlyMultiwayTest,
-                    onlyBinaryTest,
-                    instance);
-            this.naiveBayesError = 0;
-            this.majorityClassError = 0;
-        }
-
-        @Override
-        public double[] getClassVotes(Instance instance) {
-            if (naiveBayesError > majorityClassError) {
-                return getMajorityClassVotes(instance);
-            } else {
-                return getNaiveBayesPrediction(instance);
-            }
-        }
-
-        @Override
-        public Node learnFromInstance(Instance inst) {
-            // test-then-train
-            double[] prediccion = getMajorityClassVotes(inst);
-            double error = (Utils.maxIndex(prediccion) == (int) inst.classValue()) ? 0.0 : 1.0;
-            this.majorityClassError += error;
-
-            prediccion = getNaiveBayesPrediction(inst);
-            error = (Utils.maxIndex(prediccion) == (int) inst.classValue()) ? 0.0 : 1.0;
-            this.naiveBayesError += error;
-
-            return super.learnFromInstance(inst);
-        }
-    }
-
-    public class LeafNodeWeightedVote extends LeafNodeNB {
-
-        private static final long serialVersionUID = 1L;
-        protected AbstractChangeDetector naiveBayesError,
-                majorityClassError;
-
-        public LeafNodeWeightedVote(Iadem2 tree,
-                Node parent,
-                long instancesProcessedByTheTree,
-                long instancesProcessedByThisLeaf,
-                double[] classDist,
-                IademNumericAttributeObserver observadorContinuos,
-                int naiveBayesLimit,
-                boolean onlyMultiwayTest,
-                boolean onlyBinaryTest,
-                AbstractChangeDetector estimator,
-                Instance instance) {
-            super(tree,
-                    parent,
-                    instancesProcessedByTheTree,
-                    instancesProcessedByThisLeaf,
-                    classDist,
-                    observadorContinuos,
-                    naiveBayesLimit,
-                    onlyMultiwayTest,
-                    onlyBinaryTest,
-                    instance);
-            this.naiveBayesError = (AbstractChangeDetector) estimator.copy();
-            this.majorityClassError = (AbstractChangeDetector) estimator.copy();
-        }
-
-        @Override
-        public double[] getClassVotes(Instance instance) {
-            double NBweight = 1 - this.naiveBayesError.getEstimation(),
-                    MCweight = 1 - this.majorityClassError.getEstimation();
-            double[] MC = getMajorityClassVotes(instance),
-                    NB = getNaiveBayesPrediction(instance),
-                    classVotes = new double[MC.length];
-            for (int i = 0; i < MC.length; i++) {
-                classVotes[i] = MC[i] * MCweight + NB[i] * NBweight;
-            }
-            return classVotes;
-        }
-
-        @Override
-        public Node learnFromInstance(Instance inst) {
-            // test-then-train
-            double[] classVotes = getMajorityClassVotes(inst);
-            double error = (Utils.maxIndex(classVotes) == (int) inst.classValue()) ? 0.0 : 1.0;
-            this.majorityClassError.input(error);
-
-            classVotes = getNaiveBayesPrediction(inst);
-            error = (Utils.maxIndex(classVotes) == (int) inst.classValue()) ? 0.0 : 1.0;
-            this.naiveBayesError.input(error);
-            return super.learnFromInstance(inst);
-        }
-    }
-
-    public abstract class VirtualNode extends Node {
-
-        private static final long serialVersionUID = 1L;
-        protected int attIndex;
-
-        protected boolean heuristicMeasureUpdated;
-
-        protected IademAttributeSplitSuggestion bestSplitSuggestion = null;
-
-        public VirtualNode(Iadem2 tree, Node parent, int attIndex) {
-            super(tree, parent, new double[0]);
-            this.attIndex = attIndex;
-            this.heuristicMeasureUpdated = false;
-        }
-
-        public IademAttributeSplitSuggestion getBestSplitSuggestion() {
-            return bestSplitSuggestion;
-        }
-
-        public int getAttIndex() {
-            return attIndex;
-        }
-
-        @Override
-        public int getSubtreeNodeCount() {
-            return 0;
-        }
-
-        @Override
-        public ArrayList<LeafNode> getLeaves() {
-            return new ArrayList<LeafNode>();
-        }
-
-        public abstract SplitNode getNewSplitNode(long newInstancesSeen,
-                Node parent,
-                IademAttributeSplitSuggestion bestSuggestion,
-                Instance instance);
-
-        public abstract void updateHeuristicMeasure(Instance instance) throws IademException;
-
-        public abstract DoubleVector computeConditionalProbability(double value);
-
-        public abstract double getPercent();
-
-        public abstract boolean hasInformation();
-
-        public double getHeuristicMeasureUpper(Instance instance) throws IademException {
-            if (!this.heuristicMeasureUpdated) {
-                updateHeuristicMeasure(instance);
-            }
-            if (this.bestSplitSuggestion == null) {
-                return -1;
-            }
-            return this.bestSplitSuggestion.merit;
-        }
-
-        public double getHeuristicMeasureLower(Instance instance) throws IademException {
-            if (!this.heuristicMeasureUpdated) {
-                updateHeuristicMeasure(instance);
-            }
-            if (this.bestSplitSuggestion == null) {
-                return -1;
-            }
-            return this.bestSplitSuggestion.getMeritLowerBound();
-        }
-
-        @Override
-        public double[] getClassVotes(Instance inst) {
-            return this.classValueDist.getArrayCopy();
-        }
-    }
-
-    public class NominalVirtualNode extends VirtualNode {
-
-        private static final long serialVersionUID = 1L;
-
-        protected AutoExpandVector<DoubleVector> nominalAttClassObserver = new AutoExpandVector<DoubleVector>();
-
-        protected DoubleVector attValueDist;
-        protected boolean onlyMultiwayTest = false;
-        protected boolean onlyBinaryTest = false;
-
-        public NominalVirtualNode(Iadem2 tree,
-                Node parent,
-                int attIndex,
-                boolean onlyMultiwayTest,
-                boolean onlyBinaryTest) {
-            super(tree, parent, attIndex);
-
-            this.attValueDist = new DoubleVector();
-            this.onlyMultiwayTest = onlyMultiwayTest;
-            this.onlyBinaryTest = onlyBinaryTest;
-        }
-
-        public AutoExpandVector<DoubleVector> getNominalAttClassObserver() {
-            return nominalAttClassObserver;
-        }
-
-        @Override
-        public Node learnFromInstance(Instance inst) {
-            double attValue = inst.value(this.attIndex);
-            if (Utils.isMissingValue(attValue)) {
-            } else {
-                int intAttValue = (int) attValue;
-
-                this.attValueDist.addToValue(intAttValue, inst.weight());
-                this.classValueDist.addToValue((int) inst.value(inst.classIndex()), inst.weight());
-
-                DoubleVector valDist = this.nominalAttClassObserver.get(intAttValue);
-                if (valDist == null) {
-                    valDist = new DoubleVector();
-                    this.nominalAttClassObserver.set(intAttValue, valDist);
-                }
-                int classValue = (int) inst.classValue();
-                valDist.addToValue(classValue, inst.weight());
-
-                this.heuristicMeasureUpdated = false;
-            }
-            return this;
-        }
-
-        @Override
-        public SplitNode getNewSplitNode(long newTotal,
-                Node parent,
-                IademAttributeSplitSuggestion bestSuggestion,
-                Instance instance) {
-            SplitNode splitNode = new SplitNode(this.tree,
-                    parent,
-                    null,
-                    ((LeafNode) this.parent).getMajorityClassVotes(instance),
-                    bestSuggestion.splitTest);
-
-            Node[] children;
-            if (bestSuggestion.splitTest instanceof IademNominalAttributeMultiwayTest) {
-                children = new Node[instance.attribute(this.attIndex).numValues()];
-                for (int i = 0; i < children.length; i++) {
-                    long count = 0;
-                    double[] tmpClassDist = new double[instance.attribute(instance.classIndex()).numValues()];
-                    Arrays.fill(tmpClassDist, 0);
-                    for (int j = 0; j < tmpClassDist.length; j++) {
-
-                        DoubleVector classCount = nominalAttClassObserver.get(i);
-                        double contadorAtributoClase = classCount != null ? classCount.getValue(j) : 0.0;
-                        tmpClassDist[j] = contadorAtributoClase;
-                        count += tmpClassDist[j];
-                    }
-                    children[i] = tree.newLeafNode(splitNode,
-                            newTotal,
-                            count,
-                            tmpClassDist,
-                            instance);
-                }
-            } else { // binary split
-                children = new Node[2];
-                IademNominalAttributeBinaryTest binarySplit = (IademNominalAttributeBinaryTest) bestSuggestion.splitTest;
-                // to the left
-                double[] tmpClassDist = new double[instance.attribute(instance.classIndex()).numValues()];
-                // total de valores
-                double tmpCount = 0;
-                Arrays.fill(tmpClassDist, 0);
-                DoubleVector classDist = nominalAttClassObserver.get(binarySplit.getAttValue());
-                if (classDist != null) {
-                    for (int i = 0; i < tmpClassDist.length; i++) {
-                        tmpClassDist[i] = classDist.getValue(i);
-                        tmpCount += classDist.getValue(i);
-                    }
-                }
-                children[0] = tree.newLeafNode(splitNode,
-                        newTotal,
-                        (int) tmpCount,
-                        tmpClassDist,
-                        instance);
-                // to the right
-                tmpCount = this.classValueDist.sumOfValues() - tmpCount;
-                for (int i = 0; i < tmpClassDist.length; i++) {
-                    tmpClassDist[i] = this.classValueDist.getValue(i) - tmpClassDist[i];
-                }
-                children[1] = tree.newLeafNode(splitNode,
-                        newTotal,
-                        (int) tmpCount,
-                        tmpClassDist,
-                        instance);
-
-            }
-            splitNode.setChildren(children);
-            return splitNode;
-        }
-
-        protected boolean moreThanOneAttValueObserved() {
-            int count = 0;
-            for (DoubleVector tmpClassDist : this.nominalAttClassObserver) {
-                if (tmpClassDist != null) {
-                    count++;
-                }
-                if (count > 1) {
-                    return true;
-                }
-            }
-            return false;
-        }
-
-        @Override
-        public void updateHeuristicMeasure(Instance instance) throws IademException {
-            if (moreThanOneAttValueObserved()/**/) {
-                if (!this.onlyBinaryTest) {
-                    updateHeuristicMeasureMultiwayTest(instance);
-                }
-                if (!this.onlyMultiwayTest) {
-                    updateHeuristicMeasureBinaryTest(instance);
-                }
-            } else {
-                this.bestSplitSuggestion = null;
-            }
-            this.heuristicMeasureUpdated = true;
-        }
-
-        public void updateHeuristicMeasureBinaryTest(Instance instance) throws IademException {
-            if (!this.heuristicMeasureUpdated) {
-                double measureLower, measureUpper;
-                IademSplitCriterion measure = tree.getMeasure();
-                if (this.bestSplitSuggestion != null
-                        && this.bestSplitSuggestion.splitTest instanceof NominalAttributeBinaryTest) {
-                    this.bestSplitSuggestion = null;
-                }
-
-                int numberOfSplits = 2, // binary test
-                        numberOfTests = this.tree.getValuesOfNominalAttributes(this.attIndex, instance);
-                int numberOfClasses = instance.attribute(instance.classIndex()).numValues();
-
-                double[][][] classDistPerTestAndSplit_lower = new double[numberOfTests][numberOfSplits][numberOfClasses];
-                double[][][] classDistPerTestAndSplit_upper = new double[numberOfTests][numberOfSplits][numberOfClasses];
-                computeClassDistBinaryTest(classDistPerTestAndSplit_lower,
-                        classDistPerTestAndSplit_upper);
-
-                for (int k = 0; k < numberOfTests; k++) {
-                    double[] sumPerSplit_lower = new double[numberOfSplits];
-                    double[] availableErrorPerSplit = new double[numberOfSplits];
-                    Arrays.fill(sumPerSplit_lower, 0.0);
-                    for (int i = 0; i < numberOfSplits; i++) {
-                        for (int j = 0; j < numberOfClasses; j++) {
-                            sumPerSplit_lower[i] += classDistPerTestAndSplit_lower[k][i][j];
-                        }
-                        availableErrorPerSplit[i] = 1.0 - sumPerSplit_lower[i];
-
-                        if (availableErrorPerSplit[i] < 0.0) {
-                            if (Math.abs(availableErrorPerSplit[i]) < Iadem2.ERROR_MARGIN) {
-                                availableErrorPerSplit[i] = 0.0;
-                            } else {
-                                throw new IademException("NominalVirtualNode", "updateHeuristicMeasureBinaryTest",
-                                        "Problems when calculating measures");
-                            }
-                        }
-                    }
-
-                    double[] measurePerSplit_upper = new double[numberOfSplits];
-
-                    double[] valueLevels = new double[numberOfSplits];
-                    for (int i = 0; i < numberOfSplits; i++) {
-                        ArrayList<Double> lot = new ArrayList<Double>();
-                        lot.add(0.0);
-                        lot.add(1.0);
-
-                        ArrayList<Integer> hole = new ArrayList<Integer>();
-                        hole.add(0);
-                        for (int j = 0; j < numberOfClasses; j++) {
-                            IademCommonProcedures.insertLotsHoles(lot, hole, classDistPerTestAndSplit_lower[k][i][j],
-                                    classDistPerTestAndSplit_upper[k][i][j]);
-                        }
-                        valueLevels[i] = IademCommonProcedures.computeLevel(lot, hole,
-                                availableErrorPerSplit[i]);
-                    }
-                    for (int i = 0; i < numberOfSplits; i++) {
-                        ArrayList<Double> vectorToMeasure = new ArrayList<Double>();
-                        for (int j = 0; j < numberOfClasses; j++) {
-                            double measureProb_uppper = Math.max(valueLevels[i], classDistPerTestAndSplit_lower[k][i][j]);
-                            measureProb_uppper = Math.min(classDistPerTestAndSplit_upper[k][i][j], measureProb_uppper);
-                            vectorToMeasure.add(measureProb_uppper);
-                        }
-                        measurePerSplit_upper[i] = measure.doMeasure(vectorToMeasure);
-                    }
-
-                    double[] measurePerSplit_lower = new double[numberOfSplits];
-
-                    for (int i = 0; i < numberOfSplits; i++) {
-                        double tmpAvailable = availableErrorPerSplit[i];
-
-                        ArrayList<Integer> decOrderClassDist_upper = new ArrayList<Integer>();
-
-                        ArrayList<Integer> unusedClasses = new ArrayList<Integer>();
-                        for (int j = 0; j < numberOfClasses; j++) {
-                            unusedClasses.add(j);
-                        }
-
-                        double auxAvailable = availableErrorPerSplit[i];
-                        for (int j = 0; j < numberOfClasses; j++) {
-                            if (auxAvailable < 0.0) {
-                                if (Math.abs(auxAvailable) < Iadem2.ERROR_MARGIN) {
-                                    auxAvailable = 0.0;
-                                } else {
-                                    throw new IademException("NominalVirtualNode", "updateHeuristicMeasureBinaryTest",
-                                            "Problems when calculating measures");
-                                }
-                            }
-                            int classIndex = getClassProbabilities(i, unusedClasses,
-                                    classDistPerTestAndSplit_lower[k],
-                                    classDistPerTestAndSplit_upper[k],
-                                    auxAvailable);
-                            double probUp = Math.min(classDistPerTestAndSplit_upper[k][i][classIndex],
-                                    classDistPerTestAndSplit_lower[k][i][classIndex] + auxAvailable);
-
-                            auxAvailable -= (probUp - classDistPerTestAndSplit_lower[k][i][classIndex]);
-
-                            unusedClasses.remove(new Integer(classIndex));
-                            decOrderClassDist_upper.add(new Integer(classIndex));
-                        }
-
-                        ArrayList<Double> vectorToMeasure = new ArrayList<Double>();
-                        for (int j = 0; j < decOrderClassDist_upper.size(); j++) {
-                            int classIndex = decOrderClassDist_upper.get(j);
-
-                            if (tmpAvailable < 0.0) {
-                                if (Math.abs(tmpAvailable) < Iadem2.ERROR_MARGIN) {
-                                    tmpAvailable = 0.0;
-                                } else {
-                                    throw new IademException("NominalVirtualNode", "updateHeuristicMeasureBinaryTest",
-                                            "Problems when calculating measures");
-                                }
-                            }
-                            double probUp = Math.min(classDistPerTestAndSplit_upper[k][i][classIndex],
-                                    classDistPerTestAndSplit_lower[k][i][classIndex] + tmpAvailable);
-                            tmpAvailable -= (probUp - classDistPerTestAndSplit_lower[k][i][classIndex]);
-                            vectorToMeasure.add(probUp);
-                        }
-
-                        measurePerSplit_lower[i] = measure.doMeasure(vectorToMeasure);
-                    }
-
-                    double dividendUpper = 0.0;
-                    double dividendLower = 0.0;
-
-                    double leftDivUpper = measurePerSplit_upper[0] * attValueDist.getValue(k),
-                            leftDivLower = measurePerSplit_lower[0] * attValueDist.getValue(k);
-                    double divisor = classValueDist.sumOfValues(),
-                            rightTotal = divisor - attValueDist.getValue(k);
-                    double rightDivUpper = measurePerSplit_upper[1] * rightTotal,
-                            rightDivLower = measurePerSplit_lower[1] * rightTotal;
-                    dividendUpper = leftDivUpper + rightDivUpper;
-                    dividendLower = leftDivLower + rightDivLower;
-
-                    if (divisor != 0) {
-                        measureLower = dividendLower / divisor;
-                        measureUpper = dividendUpper / divisor;
-                        if (this.bestSplitSuggestion == null) {
-                            DoubleVector tmpClassDist = this.nominalAttClassObserver.get(k);
-                            if (tmpClassDist != null) { // is it a useful split?
-                                NominalAttributeBinaryTest test = new IademNominalAttributeBinaryTest(this.attIndex, k);
-                                this.bestSplitSuggestion = new IademAttributeSplitSuggestion(test,
-                                        new double[0][0],
-                                        measureUpper,
-                                        measureLower);
-                            }
-                        } // compete with multiway test 
-                        else if (!this.onlyBinaryTest) {
-                            if ((measureUpper < this.bestSplitSuggestion.merit)
-                                    || (measureUpper == this.bestSplitSuggestion.merit
-                                    && measureLower < this.bestSplitSuggestion.getMeritLowerBound())) {
-                                DoubleVector tmpClassDist = this.nominalAttClassObserver.get(k);
-                                if (tmpClassDist != null) { // is it a useful split?
-                                    NominalAttributeBinaryTest test = new IademNominalAttributeBinaryTest(this.attIndex, k);
-                                    this.bestSplitSuggestion = new IademAttributeSplitSuggestion(test,
-                                            new double[0][0],
-                                            measureUpper,
-                                            measureLower);
-                                }
-                            }
-                        }
-                    }
-                }
-
-            }
-        }
-
-        protected void computeClassDistBinaryTest(double[][][] classDistPerTestAndSplit_lower,
-                double[][][] classDistPerTestAndSplit_upper) {
-            int numberOfClasses = classDistPerTestAndSplit_lower[0][0].length;
-            double estimator, bound;
-            double leftTotal = this.classValueDist.sumOfValues();
-            for (int currentAttIndex = 0; currentAttIndex < classDistPerTestAndSplit_lower.length; currentAttIndex++) {
-                for (int j = 0; j < numberOfClasses; j++) {
-                    // compute probabilities in the left branch
-                    DoubleVector classCounter = nominalAttClassObserver.get(currentAttIndex);
-                    double attClassCounter = classCounter != null ? classCounter.getValue(j) : 0.0;
-                    if (attValueDist.getValue(currentAttIndex) != 0) {
-                        estimator = attClassCounter / attValueDist.getValue(currentAttIndex);
-                        bound = IademCommonProcedures.getIADEM_HoeffdingBound(estimator, attValueDist.getValue(currentAttIndex));
-                        classDistPerTestAndSplit_lower[currentAttIndex][0][j] = Math.max(0.0, estimator - bound);
-                        classDistPerTestAndSplit_upper[currentAttIndex][0][j] = Math.min(1.0, estimator + bound);
-                    } else {
-                        classDistPerTestAndSplit_lower[currentAttIndex][0][j] = 0.0;
-                        classDistPerTestAndSplit_upper[currentAttIndex][0][j] = 1.0;
-                    }
-                    // compute probabilities in the right branch
-                    attClassCounter = classValueDist.getValue(j) - attClassCounter;
-                    double rightTotal = leftTotal - attValueDist.getValue(currentAttIndex);
-                    if (rightTotal != 0) {
-                        estimator = attClassCounter / rightTotal;
-                        bound = IademCommonProcedures.getIADEM_HoeffdingBound(estimator, rightTotal);
-                        classDistPerTestAndSplit_lower[currentAttIndex][1][j] = Math.max(0.0, estimator - bound);
-                        classDistPerTestAndSplit_upper[currentAttIndex][1][j] = Math.min(1.0, estimator + bound);
-                    } else {
-                        classDistPerTestAndSplit_lower[currentAttIndex][1][j] = 0.0;
-                        classDistPerTestAndSplit_upper[currentAttIndex][1][j] = 1.0;
-                    }
-                }
-            }
-        }
-
-        public void updateHeuristicMeasureMultiwayTest(Instance instance) throws IademException {
-            if (!this.heuristicMeasureUpdated) {
-                this.bestSplitSuggestion = null;
-                double measureLower, measureUpper;
-                IademSplitCriterion measure = tree.getMeasure();
-
-                int numberOfValues = tree.getValuesOfNominalAttributes(attIndex, instance);
-                int numberOfClasses = instance.attribute(instance.classIndex()).numValues();
-                double[][] classDist_lower = new double[numberOfValues][numberOfClasses];
-                double[][] classDist_upper = new double[numberOfValues][numberOfClasses];
-
-                computeClassDistPerValue(classDist_lower, classDist_upper);
-
-                double[] sumPerValue_lower = new double[numberOfValues];
-                double[] availableErrorPerValue = new double[numberOfValues];
-                Arrays.fill(sumPerValue_lower, 0.0);
-                for (int i = 0; i < numberOfValues; i++) {
-                    for (int j = 0; j < numberOfClasses; j++) {
-                        sumPerValue_lower[i] += classDist_lower[i][j];
-                    }
-                    availableErrorPerValue[i] = 1.0 - sumPerValue_lower[i];
-
-                    if (availableErrorPerValue[i] < 0.0) {
-                        if (Math.abs(availableErrorPerValue[i]) < Iadem2.ERROR_MARGIN) {
-                            availableErrorPerValue[i] = 0.0;
-                        } else {
-                            throw new IademException("NominalVirtualNode", "updateHeuristicMeasureMultiwayTest",
-                                    "Problems when calculating measures");
-                        }
-                    }
-                }
-
-                double[] measuerPerValue_upper = new double[numberOfValues];
-
-                double[] valueLevels = new double[numberOfValues];
-                for (int i = 0; i < numberOfValues; i++) {
-                    ArrayList<Double> lot = new ArrayList<Double>();
-                    lot.add(0.0);
-                    lot.add(1.0);
-
-                    ArrayList<Integer> hole = new ArrayList<Integer>();
-                    hole.add(0);
-                    for (int j = 0; j < numberOfClasses; j++) {
-                        IademCommonProcedures.insertLotsHoles(lot, hole, classDist_lower[i][j],
-                                classDist_upper[i][j]);
-                    }
-
-                    valueLevels[i] = IademCommonProcedures.computeLevel(lot, hole,
-                            availableErrorPerValue[i]);
-                }
-
-                for (int i = 0; i < numberOfValues; i++) {
-                    ArrayList<Double> vectorToMeasure = new ArrayList<Double>();
-                    for (int j = 0; j < numberOfClasses; j++) {
-                        double p_sup_medida = Math.max(valueLevels[i], classDist_lower[i][j]);
-                        p_sup_medida = Math.min(classDist_upper[i][j], p_sup_medida);
-                        vectorToMeasure.add(p_sup_medida);
-                    }
-                    measuerPerValue_upper[i] = measure.doMeasure(vectorToMeasure);
-                }
-                // compute measure lower bounds
-                double[] measurePerValue_lower = new double[numberOfValues];
-                for (int i = 0; i < numberOfValues; i++) {
-                    double availableError = availableErrorPerValue[i];
-                    ArrayList<Integer> decOrderClassDist_upper = new ArrayList<Integer>();
-
-                    ArrayList<Integer> unusedClasses = new ArrayList<Integer>();
-                    for (int j = 0; j < numberOfClasses; j++) {
-                        unusedClasses.add(j);
-                    }
-
-                    double auxAvailable = availableErrorPerValue[i];
-                    for (int j = 0; j < numberOfClasses; j++) {
-                        if (auxAvailable < 0.0) {
-                            if (Math.abs(auxAvailable) < Iadem2.ERROR_MARGIN) {
-                                auxAvailable = 0.0;
-                            } else {
-                                throw new IademException("NominalVirtualNode", "updateHeuristicMeasureMultiwayTest",
-                                        "Problems when calculating measures");
-                            }
-                        }
-
-                        int classID = getClassProbabilities(i, unusedClasses, classDist_lower,
-                                classDist_upper, auxAvailable);
-                        double probUp = Math.min(classDist_upper[i][classID],
-                                classDist_lower[i][classID] + auxAvailable);
-
-                        auxAvailable -= (probUp - classDist_lower[i][classID]);
-
-                        unusedClasses.remove(new Integer(classID));
-                        decOrderClassDist_upper.add(new Integer(classID));
-                    }
-
-                    ArrayList<Double> vectorToMeasure = new ArrayList<Double>();
-                    for (int j = 0; j < decOrderClassDist_upper.size(); j++) {
-                        int classID = decOrderClassDist_upper.get(j);
-
-                        if (availableError < 0.0) {
-                            if (Math.abs(availableError) < Iadem2.ERROR_MARGIN) {
-                                availableError = 0.0;
-                            } else {
-                                throw new IademException("NominalVirtualNode", "updateHeuristicMeasureMultiwayTest",
-                                        "Problems when calculating measures");
-                            }
-                        }
-                        double probUp = Math.min(classDist_upper[i][classID],
-                                classDist_lower[i][classID] + availableError);
-                        availableError -= (probUp - classDist_lower[i][classID]);
-                        vectorToMeasure.add(probUp);
-                    }
-
-                    measurePerValue_lower[i] = measure.doMeasure(vectorToMeasure);
-                }
-
-                double dividendUpper = 0.0;
-                double dividendLower = 0.0;
-                double divisor = 0.0;
-
-                for (int i = 0; i < attValueDist.numValues(); i++) {
-                    dividendUpper += (measuerPerValue_upper[i] * attValueDist.getValue(i));
-                    dividendLower += (measurePerValue_lower[i] * attValueDist.getValue(i));
-                    divisor += attValueDist.getValue(i);
-                }
-                measureLower = dividendLower / divisor;
-                measureUpper = dividendUpper / divisor;
-
-                int maxBranches = instance.attribute(attIndex).numValues();
-                IademNominalAttributeMultiwayTest test = new IademNominalAttributeMultiwayTest(this.attIndex, maxBranches);
-                bestSplitSuggestion = new IademAttributeSplitSuggestion(test,
-                        new double[0][0],
-                        measureUpper,
-                        measureLower);
-            }
-        }
-
-        private void computeClassDistPerValue(double[][] classDistLower,
-                double[][] classDistUpper) {
-            double estimator, classDistError;
-
-            int numberOfValues = classDistLower.length;
-            int numberOfClasses = classDistLower[0].length;
-
-            for (int i = 0; i < numberOfValues; i++) {
-                for (int j = 0; j < numberOfClasses; j++) {
-                    if (attValueDist.getValue(i) == 0.0) {
-                        classDistLower[i][j] = 0.0;
-                        classDistUpper[i][j] = 1.0;
-                    } else {
-                        DoubleVector classCounter = nominalAttClassObserver.get(i);
-                        double attValuePerClassCounter = classCounter != null ? classCounter.getValue(j) : 0.0;
-                        estimator = attValuePerClassCounter / attValueDist.getValue(i);
-                        classDistError = IademCommonProcedures.getIADEM_HoeffdingBound(estimator, attValueDist.getValue(i));
-                        classDistLower[i][j] = Math.max(0.0, estimator - classDistError);
-                        classDistUpper[i][j] = Math.min(1.0, estimator + classDistError);
-                    }
-                }
-            }
-        }
-
-        private int getClassProbabilities(int attributeValue, ArrayList<Integer> attValueList,
-                double[][] classDistPerValueLower, double[][] classDistPerValueUpper,
-                double available) {
-            int max, tmp;
-            double maxProbUp, newProbUp;
-            if (attValueList.isEmpty()) {
-                return -1;
-            } else {
-                max = attValueList.get(0);
-                maxProbUp = Math.min(classDistPerValueUpper[attributeValue][max],
-                        classDistPerValueLower[attributeValue][max] + available);
-
-                for (int i = 1; i < attValueList.size(); i++) {
-                    tmp = attValueList.get(i);
-                    newProbUp = Math.min(classDistPerValueUpper[attributeValue][tmp],
-                            classDistPerValueLower[attributeValue][tmp] + available);
-                    if (newProbUp > maxProbUp) {
-                        max = tmp;
-                        maxProbUp = newProbUp;
-                    }
-                }
-                return max;
-            }
-        }
-
-        @Override
-        public DoubleVector computeConditionalProbability(double valor) {
-            int numberOfValues = nominalAttClassObserver.size();
-            DoubleVector conditionalProbability = new DoubleVector();
-
-            DoubleVector sumsPerClass = new DoubleVector();
-            for (int i = 0; i < numberOfValues; i++) {
-                DoubleVector classCounter = nominalAttClassObserver.get(i);
-                int numberOfClasses = classCounter != null ? classCounter.numValues() : 0;
-                for (int j = 0; j < numberOfClasses; j++) {
-                    double attClassCounter = classCounter.getValue(j);
-                    sumsPerClass.addToValue(j, attClassCounter);
-                }
-            }
-
-            for (int i = 0; i < sumsPerClass.numValues(); i++) {
-                if (sumsPerClass.getValue(i) != 0.0) {
-                    DoubleVector contadorClase = nominalAttClassObserver.get((int) valor);
-                    double attClassCounter = contadorClase != null ? contadorClase.getValue(i) : 0.0;
-                    conditionalProbability.setValue(i, attClassCounter / sumsPerClass.getValue(i));
-                }
-            }
-
-            return conditionalProbability;
-        }
-
-        @Override
-        public double getPercent() {
-            double counter = 0;
-            double maxInstances = 0;
-            for (int i = 0; i < attValueDist.numValues(); i++) {
-                counter += attValueDist.getValue(i);
-                if (attValueDist.getValue(i) > maxInstances) {
-                    maxInstances = attValueDist.getValue(i);
-                }
-            }
-            double maxPercent = maxInstances / counter;
-            return maxPercent;
-        }
-
-        @Override
-        public boolean hasInformation() {
-            return true;
-        }
-
-        @Override
-        public void getNumberOfNodes(int[] count) {
-            count[1]++;
-        }
-    }
-
-    public class NumericVirtualNode extends VirtualNode {
-
-        private static final long serialVersionUID = 1L;
-        private static final int MAX_BINS_EQUAL_WIDTH = 10;
-        protected IademNumericAttributeObserver numericAttClassObserver;
-        protected double bestCutPoint;
-
-        public NumericVirtualNode(Iadem2 tree,
-                Node parent,
-                int attIndex,
-                IademNumericAttributeObserver numericAttClassObs) {
-            super(tree, parent, attIndex);
-            int numIntervalos = this.tree.getMaxNumberOfBins();
-            this.numericAttClassObserver = (IademNumericAttributeObserver) numericAttClassObs.copy();
-            this.numericAttClassObserver.setMaxBins(numIntervalos);
-            this.bestCutPoint = 0.0;
-        }
-
-        public IademNumericAttributeObserver getNumericAttClassObserver() {
-            return numericAttClassObserver;
-        }
-
-        @Override
-        public Node learnFromInstance(Instance instance) {
-            this.numericAttClassObserver.addValue(instance.value(this.attIndex),
-                    (int) instance.value(instance.classIndex()),
-                    instance.weight());
-            this.classValueDist.addToValue((int) instance.value(instance.classIndex()), instance.weight());
-            this.heuristicMeasureUpdated = false;
-            return this;
-        }
-
-        long arrSum(long[] arr) {
-            long count = 0;
-            for (int i = 0; i < arr.length; i++) {
-                count += arr[i];
-            }
-            return count;
-        }
-
-        @Override
-        public SplitNode getNewSplitNode(long newTotal,
-                Node parent,
-                IademAttributeSplitSuggestion bestSuggestion,
-                Instance instance) {
-            double[] cut = new double[]{this.bestCutPoint};
-
-            Node[] children = new Node[2]; // a traditional binary split test for numeric attributes
-
-            long[] newClassVotesAndTotal = this.numericAttClassObserver.getLeftClassDist(this.bestCutPoint);
-            long totalLeft = arrSum(newClassVotesAndTotal);
-
-            long total = this.numericAttClassObserver.getValueCount();
-            long[] classVotesTotal = this.numericAttClassObserver.getClassDist();
-            boolean equalsPassesTest = true;
-            if (this.numericAttClassObserver instanceof IademVFMLNumericAttributeClassObserver) {
-                equalsPassesTest = false;
-            }
-            SplitNode splitNode = new SplitNode(this.tree,
-                    parent,
-                    null,
-                    ((LeafNode) this.parent).getMajorityClassVotes(instance),
-                    new IademNumericAttributeBinaryTest(this.attIndex,
-                            cut[0],
-                            equalsPassesTest));
-
-            long newTotalLeft = totalLeft;
-            long newTotalRight = total - newTotalLeft;
-            double[] newClassVotesLeft = new double[instance.attribute(instance.classIndex()).numValues()];
-            double[] newClassVotesRight = new double[instance.attribute(instance.classIndex()).numValues()];
-
-            Arrays.fill(newClassVotesLeft, 0);
-            Arrays.fill(newClassVotesRight, 0);
-
-            for (int i = 0; i < newClassVotesAndTotal.length; i++) {
-                newClassVotesLeft[i] = newClassVotesAndTotal[i];
-                newClassVotesRight[i] = classVotesTotal[i] - newClassVotesLeft[i];
-            }
-
-            splitNode.setChildren((Node[]) null);
-            children[0] = this.tree.newLeafNode(splitNode, newTotal, newTotalLeft, newClassVotesLeft, instance);
-            children[1] = this.tree.newLeafNode(splitNode, newTotal, newTotalRight, newClassVotesRight, instance);
-
-            splitNode.setChildren(children);
-
-            return splitNode;
-        }
-
-        @Override
-        public void updateHeuristicMeasure(Instance instance) throws IademException {
-            if (!this.heuristicMeasureUpdated) {
-                if (this.numericAttClassObserver.getNumberOfCutPoints() < 2) {
-                    this.bestSplitSuggestion = null;
-                } else {
-                    IademSplitCriterion measure = ((LeafNode) this.parent).getTree().getMeasure();
-                    int numberOfClasses = instance.attribute(instance.classIndex()).numValues();
-
-                    int numberOfSplits = 2;
-                    int numberOfCuts = (int) this.numericAttClassObserver.getNumberOfCutPoints();
-
-                    double[] measureLower = new double[numberOfCuts];
-                    double[] measureUpper = new double[numberOfCuts];
-
-                    double[][][] classVotesPerCutAndSplit_lower = new double[numberOfCuts][numberOfSplits][numberOfClasses];
-                    double[][][] classVotesPerCutAndSplit_upper = new double[numberOfCuts][numberOfSplits][numberOfClasses];
-
-                    double[][] totalPerCutAndSplit = new double[numberOfCuts][numberOfSplits];
-
-                    computeClassVoteBounds(classVotesPerCutAndSplit_lower, classVotesPerCutAndSplit_upper,
-                            totalPerCutAndSplit, true);
-
-                    for (int k = 0; k < numberOfCuts; k++) {
-                        double[] countPerSplit_lower = new double[numberOfSplits];
-                        double[] availableErrorPerSplit = new double[numberOfSplits];
-                        Arrays.fill(countPerSplit_lower, 0.0);
-                        for (int i = 0; i < numberOfSplits; i++) {
-                            for (int j = 0; j < numberOfClasses; j++) {
-                                countPerSplit_lower[i] += classVotesPerCutAndSplit_lower[k][i][j];
-                            }
-                            availableErrorPerSplit[i] = 1.0 - countPerSplit_lower[i];
-
-                            if (availableErrorPerSplit[i] < 0.0) {
-                                if (Math.abs(availableErrorPerSplit[i]) < Iadem2.ERROR_MARGIN) {
-                                    availableErrorPerSplit[i] = 0.0;
-                                } else {
-                                    throw new IademException("NumericVirtualNode", "updateHeuristicMeasure",
-                                            "Problems when calculating measures");
-                                }
-                            }
-                        }
-
-                        // compute measure upper bounds
-                        double[] measurePerSplit_upper = new double[numberOfSplits];
-
-                        double[] splitLevels = new double[numberOfSplits];
-                        for (int i = 0; i < numberOfSplits; i++) {
-                            ArrayList<Double> lot = new ArrayList<Double>();
-                            lot.add(0.0);
-                            lot.add(1.0);
-                            ArrayList<Integer> hole = new ArrayList<Integer>();
-                            hole.add(0);
-                            for (int j = 0; j < numberOfClasses; j++) {
-                                IademCommonProcedures.insertLotsHoles(lot, hole,
-                                        classVotesPerCutAndSplit_lower[k][i][j],
-                                        classVotesPerCutAndSplit_upper[k][i][j]);
-                            }
-                            splitLevels[i] = IademCommonProcedures.computeLevel(lot, hole,
-                                    availableErrorPerSplit[i]);
-                        }
-
-                        for (int i = 0; i < numberOfSplits; i++) {
-                            ArrayList<Double> vectorToMeasure = new ArrayList<Double>();
-                            for (int j = 0; j < numberOfClasses; j++) {
-                                double tmpMeasureUpper = Math.max(splitLevels[i],
-                                        classVotesPerCutAndSplit_lower[k][i][j]);
-                                tmpMeasureUpper = Math.min(classVotesPerCutAndSplit_upper[k][i][j],
-                                        tmpMeasureUpper);
-                                vectorToMeasure.add(tmpMeasureUpper);
-                            }
-                            measurePerSplit_upper[i] = measure.doMeasure(vectorToMeasure);
-                        }
-
-                        double[] measurePerSplit_lower = new double[numberOfSplits];
-
-                        for (int i = 0; i < numberOfSplits; i++) {
-                            double availableProb = availableErrorPerSplit[i];
-
-                            ArrayList<Integer> decOrderClassVotes_upper = new ArrayList<Integer>();
-
-                            ArrayList<Integer> unusedClasses = new ArrayList<Integer>();
-                            for (int j = 0; j < numberOfClasses; j++) {
-                                unusedClasses.add(j);
-                            }
-
-                            double auxAvailable = availableErrorPerSplit[i];
-                            for (int j = 0; j < numberOfClasses; j++) {
-                                if (auxAvailable < 0.0) {
-                                    if (Math.abs(auxAvailable) < Iadem2.ERROR_MARGIN) {
-                                        auxAvailable = 0.0;
-                                    } else {
-                                        throw new IademException("NodoVirtualContinuo", "actualizaMedida",
-                                                "Problems calculating measure");
-                                    }
-                                }
-
-                                int classIndex = getClassValueProbabilities(i, unusedClasses,
-                                        classVotesPerCutAndSplit_lower[k],
-                                        classVotesPerCutAndSplit_upper[k], auxAvailable);
-                                double probUpper = Math.min(classVotesPerCutAndSplit_upper[k][i][classIndex],
-                                        classVotesPerCutAndSplit_lower[k][i][classIndex]
-                                        + auxAvailable);
-
-                                auxAvailable -= (probUpper - classVotesPerCutAndSplit_lower[k][i][classIndex]);
-
-                                unusedClasses.remove(new Integer(classIndex));
-                                decOrderClassVotes_upper.add(new Integer(classIndex));
-                            }
-
-                            ArrayList<Double> vectorToMeasure = new ArrayList<Double>();
-                            for (int j = 0; j < decOrderClassVotes_upper.size(); j++) {
-                                int classIndex = decOrderClassVotes_upper.get(j);
-
-                                if (availableProb < 0.0) {
-                                    if (Math.abs(availableProb) < Iadem2.ERROR_MARGIN) {
-                                        availableProb = 0.0;
-                                    } else {
-                                        throw new IademException("NumericVirtualNode", "updateMeasure",
-                                                "Problems when calculating measures");
-                                    }
-                                }
-                                double probUpper = Math.min(classVotesPerCutAndSplit_upper[k][i][classIndex],
-                                        classVotesPerCutAndSplit_lower[k][i][classIndex]
-                                        + availableProb);
-                                availableProb -= (probUpper - classVotesPerCutAndSplit_lower[k][i][classIndex]);
-                                vectorToMeasure.add(probUpper);
-                            }
-
-                            measurePerSplit_lower[i] = measure.doMeasure(vectorToMeasure);
-                        }
-
-                        double dividendUpper = 0.0;
-                        double dividendLower = 0.0;
-                        double divisor = 0.0;
-
-                        for (int i = 0; i < totalPerCutAndSplit[k].length; i++) {
-                            dividendUpper += (measurePerSplit_upper[i] * totalPerCutAndSplit[k][i]);
-                            dividendLower += (measurePerSplit_lower[i] * totalPerCutAndSplit[k][i]);
-                            divisor += totalPerCutAndSplit[k][i];
-                        }
-
-                        measureLower[k] = dividendLower / divisor;
-                        measureUpper[k] = dividendUpper / divisor;
-                    }
-
-                    ArrayList<Integer> indMinSupMedida = new ArrayList<Integer>();
-                    double minSupMedida = measureUpper[0];
-                    indMinSupMedida.add(0);
-
-                    for (int i = 1; i < measureUpper.length; i++) {
-                        if (measureUpper[i] < minSupMedida) {
-                            minSupMedida = measureUpper[i];
-                            indMinSupMedida.clear();
-                            indMinSupMedida.add(i);
-                        } else if (measureUpper[i] == minSupMedida) {
-                            indMinSupMedida.add(i);
-                        }
-                    }
-
-                    Iterator<Integer> iterator = indMinSupMedida.iterator();
-                    Integer element = iterator.next();
-                    int minMeasureLowerIndex = element;
-                    double minMeasureLower = measureLower[element];
-
-                    while (iterator.hasNext()) {
-                        element = iterator.next();
-                        if (measureLower[element] < minMeasureLower) {
-                            minMeasureLower = measureLower[element];
-                            minMeasureLowerIndex = element;
-                        }
-                    }
-
-                    this.bestCutPoint = this.numericAttClassObserver.getCut(minMeasureLowerIndex);
-                    boolean equalsPassesTest = true;
-                    if (this.numericAttClassObserver instanceof IademVFMLNumericAttributeClassObserver) {
-                        equalsPassesTest = false;
-                    }
-                    IademNumericAttributeBinaryTest test = new IademNumericAttributeBinaryTest(this.attIndex,
-                            this.bestCutPoint,
-                            equalsPassesTest);
-                    this.bestSplitSuggestion = new IademAttributeSplitSuggestion(test,
-                            new double[0][0],
-                            minSupMedida,
-                            minMeasureLower);
-                }
-                this.heuristicMeasureUpdated = true;
-            }
-        }
-
-        private void computeClassVoteBounds(double[][][] classVotesPerCutAndSplit_lower,
-                double[][][] classVotesPerCutAndSplit_upper,
-                double[][] totalPerCutAndSplit,
-                boolean withIntervalEstimates) {
-            this.numericAttClassObserver.computeClassDistProbabilities(classVotesPerCutAndSplit_lower,
-                    classVotesPerCutAndSplit_upper,
-                    totalPerCutAndSplit,
-                    withIntervalEstimates);
-        }
-
-        private int getClassValueProbabilities(int value, ArrayList<Integer> valueList,
-                double[][] classValuePerSplitLower, double[][] classValuePerSplitUpper,
-                double availableProb) {
-            int max, newValue;
-            double max_up, newValue_up;
-            if (valueList.isEmpty()) {
-                return -1;
-            } else {
-                max = valueList.get(0);
-                max_up = Math.min(classValuePerSplitUpper[value][max],
-                        classValuePerSplitLower[value][max] + availableProb);
-
-                for (int i = 1; i < valueList.size(); i++) {
-                    newValue = valueList.get(i);
-                    newValue_up = Math.min(classValuePerSplitUpper[value][newValue],
-                            classValuePerSplitLower[value][newValue] + availableProb);
-                    if (newValue_up > max_up) {
-                        max = newValue;
-                        max_up = newValue_up;
-                    }
-                }
-                return max;
-            }
-        }
-
-        @Override
-        public boolean hasInformation() {
-            return (this.numericAttClassObserver.getNumberOfCutPoints() > 1);
-        }
-
-        private ArrayList<Double> getCuts() {
-            return this.numericAttClassObserver.cutPointSuggestion(this.MAX_BINS_EQUAL_WIDTH);
-        }
-
-        @Override
-        public double getPercent() {
-            long[] classVotesLeft = this.numericAttClassObserver.getLeftClassDist(this.bestCutPoint);
-
-            double leftCount = (double) arrSum(classVotesLeft);
-            double total = (double) this.numericAttClassObserver.getValueCount();
-
-            double leftPercent = leftCount / total;
-            double rightPercent = 1.0 - leftPercent;
-
-            if (rightPercent < leftPercent) {
-                return rightPercent;
-            } else {
-                return leftPercent;
-            }
-        }
-
-        @Override
-        public DoubleVector computeConditionalProbability(double value) {
-            ArrayList<Double> cut = getCuts();
-            return new DoubleVector(this.numericAttClassObserver.computeConditionalProb(cut, value));
-        }
-
-        @Override
-        public void getNumberOfNodes(int[] count) {
-            count[1]++;
-        }
-    }
-
-    public class SplitNode extends Node {
-
-        private static final long serialVersionUID = 1L;
-
-        public InstanceConditionalTest splitTest;
-
-        public AutoExpandVector<Node> children = new AutoExpandVector<Node>();
-
-        public SplitNode(Iadem2 tree,
-                Node parent,
-                Node[] children,
-                double[] initialClassCount,
-                InstanceConditionalTest splitTest) {
-            super(tree, parent, initialClassCount);
-            this.splitTest = splitTest;
-            this.setChildren(children);
-        }
-
-        public InstanceConditionalTest getSplitTest() {
-            return splitTest;
-        }
-
-        public void setChild(Node child, int index) {
-            if ((this.splitTest.maxBranches() >= 0)
-                    && (index >= this.splitTest.maxBranches())) {
-                throw new IndexOutOfBoundsException();
-            }
-            this.children.set(index, child);
-        }
-
-        @Override
-        public int getSubtreeNodeCount() {
-            int count = 1;
-            for (Node currentChild : this.children) {
-                count += currentChild.getSubtreeNodeCount();
-            }
-            return count;
-        }
-
-        @Override
-        public ArrayList<LeafNode> getLeaves() {
-            ArrayList<LeafNode> leaves = new ArrayList<LeafNode>();
-            for (Node currentChild : this.children) {
-                leaves.addAll(currentChild.getLeaves());
-            }
-            return leaves;
-        }
-
-        public void changeChildren(Node oldChild,
-                Node newChild) {
-            boolean found = false;
-            int pos = 0;
-            while ((!found) && (pos < this.children.size())) {
-                if (this.children.get(pos).equals(oldChild)) {
-                    found = true;
-                    this.children.set(pos, newChild);
-                }
-                pos++;
-            }
-        }
-
-        public int instanceChildIndex(Instance inst) {
-            return this.splitTest.branchForInstance(inst);
-        }
-
-        public Node getChild(int index) {
-            return this.children.get(index);
-        }
-
-        final public void setChildren(Node[] children) {
-            this.children.clear();
-            if (children != null) {
-                this.children.addAll(Arrays.asList(children));
-            }
-        }
-
-        public void setChild(AutoExpandVector<Node> children) {
-            this.children.clear();
-            this.children.addAll(children);
-        }
-
-        @Override
-        public Node learnFromInstance(Instance inst) {
-            int childIndex = instanceChildIndex(inst);
-            if (childIndex >= 0) {
-                Node child = getChild(childIndex);
-                if (child != null) {
-                    return child.learnFromInstance(inst);
-                }
-            }
-            return null;
-        }
-
-        @Override
-        public double[] getClassVotes(Instance inst) {
-            int childIndex = instanceChildIndex(inst);
-            // there is no missing value
-            if (childIndex >= 0) {
-                Node currentChild = getChild(childIndex);
-                return currentChild.getClassVotes(inst);
-            } else {
-                return this.classValueDist.getArrayCopy();
-            }
-        }
-
-        @Override
-        public int getChildCount() {
-            return this.children.size();
-        }
-
-        public void removeChild(Node child) {
-            this.children.remove(child);
-        }
-
-        public void addChild(Node child) {
-            this.children.add(child);
-        }
-
-        @Override
-        public void getNumberOfNodes(int[] count) {
-            count[0]++;
-            for (Node child : children) {
-                child.getNumberOfNodes(count);
-            }
-        }
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/trees/iadem/Iadem3.java b/moa/src/main/java/moa/classifiers/trees/iadem/Iadem3.java
deleted file mode 100644
index 8c257e3c6..000000000
--- a/moa/src/main/java/moa/classifiers/trees/iadem/Iadem3.java
+++ /dev/null
@@ -1,1323 +0,0 @@
-/*
- *    IADEM3Tree.java
- *
- *    @author Isvani Frías-Blanco
- * 
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-package moa.classifiers.trees.iadem;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.TreeSet;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
-import moa.classifiers.core.conditionaltests.NominalAttributeMultiwayTest;
-import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
-import moa.classifiers.core.driftdetection.AbstractChangeDetector;
-import moa.core.AutoExpandVector;
-import moa.core.DoubleVector;
-import moa.core.Measurement;
-import weka.core.Utils;
-
-/**
- *
- * @author Isvani Frías Blanco (ifriasb at hotmail dot com)
- */
-public class Iadem3 extends Iadem2 {
-
-    private static final long serialVersionUID = 1L;
-
-    public IntOption maxNestingLevelOption = new IntOption("maxNestingLevel", 'p',
-            "Maximum level of nesting for alternative subtrees (-1 => unbounded).",
-            1, -1, Integer.MAX_VALUE);
-
-    public IntOption maxSubtreesPerNodeOption = new IntOption("maxSubtreesPerNode", 'w',
-            "Maximum number of alternative subtrees per split node (-1 => unbounded).",
-            1, -1, Integer.MAX_VALUE);
-
-    protected final boolean restartAtDrift = true;
-
-    protected int interchangedTrees = 0;
-    protected int deletedTrees = 0;
-    protected int numTrees = 0;
-
-    protected int lastPrediction = -1,
-            lastPredictionInLeaf = -1;
-    //
-    protected int treeLevel = 0;
-    protected AutoExpandVector<Iadem3Subtree> subtreeList = new AutoExpandVector<Iadem3Subtree>();
-
-    protected int currentSplitState = -1;
-    protected final int SPLIT_BY_TIE_BREAKING = 0,
-            SPLIT_WITH_CONFIDENCE = 1;
-
-    public int numSplitsByBreakingTies = 0;
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return new Measurement[]{
-            new Measurement("tree size (nodes)", this.getNumberOfNodes()),
-            new Measurement("tree size (leaves)", this.getNumberOfLeaves()),
-            new Measurement("interchanged trees", this.getChangedTrees())
-        };
-    }
-    
-    public AbstractChangeDetector getEstimatorCopy() {
-        return (AbstractChangeDetector) ((AbstractChangeDetector) getPreparedClassOption(this.driftDetectionMethodOption)).copy();
-    }
-
-    @Override
-    public void createRoot(Instance instance) {
-
-        double[] arrayCont = new double[instance.numClasses()];
-        Arrays.fill(arrayCont, 0);
-
-        this.treeRoot = newLeafNode(null, 0, 0, arrayCont, instance);
-    }
-
-    public void addSubtree(Iadem3Subtree subtree) {
-        this.subtreeList.add(subtree);
-    }
-
-    public void removeSubtree(Iadem3Subtree subtree) {
-        this.subtreeList.remove(subtree);
-    }
-
-    public boolean canCreateSubtree() {
-        if (this.maxSubtreesPerNodeOption.getValue() > 0) {
-            int count = getNumberOfSubtrees();
-            if (count >= this.maxSubtreesPerNodeOption.getValue()) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    @Override
-    public LeafNode newLeafNode(Node parent,
-            long instTreeCountSinceVirtual,
-            long instNodeCountSinceVirtual,
-            double[] initialClassCount,
-            Instance instance) {
-        switch (this.leafPredictionOption.getChosenIndex()) {
-            case 0: {
-                return new AdaptiveLeafNode(this,
-                        parent,
-                        instTreeCountSinceVirtual,
-                        instNodeCountSinceVirtual,
-                        initialClassCount,
-                        newNumericClassObserver(),
-                        this.estimator,
-                        this.splitTestsOption.getChosenIndex() == 2,
-                        this.splitTestsOption.getChosenIndex() == 0,
-                        instance);
-            }
-            case 1: {
-                return new AdaptiveLeafNodeNB(this,
-                        parent,
-                        instTreeCountSinceVirtual,
-                        instNodeCountSinceVirtual,
-                        initialClassCount,
-                        newNumericClassObserver(),
-                        this.naiveBayesLimit,
-                        this.estimator,
-                        this.splitTestsOption.getChosenIndex() == 2,
-                        this.splitTestsOption.getChosenIndex() == 0,
-                        instance);
-            }
-            case 2: {
-                return new AdaptiveLeafNodeNBKirkby(this,
-                        parent,
-                        instTreeCountSinceVirtual,
-                        instNodeCountSinceVirtual,
-                        initialClassCount,
-                        newNumericClassObserver(),
-                        this.naiveBayesLimit,
-                        this.splitTestsOption.getChosenIndex() == 2,
-                        this.splitTestsOption.getChosenIndex() == 0,
-                        this.estimator,
-                        instance);
-            }
-            default: {
-                return new AdaptiveLeafNodeWeightedVote(this,
-                        parent,
-                        instTreeCountSinceVirtual,
-                        instNodeCountSinceVirtual,
-                        initialClassCount,
-                        newNumericClassObserver(),
-                        this.naiveBayesLimit,
-                        this.splitTestsOption.getChosenIndex() == 2,
-                        this.splitTestsOption.getChosenIndex() == 0,
-                        this.estimator,
-                        instance);
-            }
-        }
-    }
-
-    public int getTreeLevel() {
-        return treeLevel;
-    }
-
-    public int getMaxAltSubtreesPerNode() {
-        return this.maxSubtreesPerNodeOption.getValue();
-    }
-
-    public int getMaxNestingLevels() {
-        return this.maxNestingLevelOption.getValue();
-    }
-
-    public boolean isRestaurarVectoresPrediccion() {
-        return restartAtDrift;
-    }
-
-    public int numDeletedTrees() {
-        return deletedTrees;
-    }
-
-    public int numTrees() {
-        int subtreeCount;
-        if (this.treeRoot instanceof AdaptiveLeafNode) {
-            subtreeCount = 0;
-        } else {
-            AdaptiveSplitNode nodo = (AdaptiveSplitNode) this.treeRoot;
-            subtreeCount = nodo.getNumTrees();
-        }
-        return subtreeCount;
-    }
-
-    public void newTreeChange() {
-        interchangedTrees++;
-        numTrees--;
-    }
-
-    public void newDeletedTree() {
-        deletedTrees++;
-        numTrees--;
-    }
-
-    public int numSubtrees() {
-        return tmpNumSubtrees(treeRoot);
-    }
-
-    private int tmpNumSubtrees(Node node) {
-        int count = 0;
-        if (node instanceof AdaptiveSplitNode) {
-            count++;
-            AutoExpandVector<Iadem3Subtree> subtree = ((AdaptiveSplitNode) node).alternativeTree;
-            for (Iadem3Subtree currentSubtree : subtree) {
-                count += currentSubtree.numSubtrees();
-            }
-        }
-        if (node instanceof AdaptiveSplitNode) {
-            AdaptiveSplitNode nodoAuxiliar = (AdaptiveSplitNode) node;
-            for (Node child : nodoAuxiliar.children) {
-                count += tmpNumSubtrees(child);
-            }
-        }
-        return count;
-    }
-
-    protected boolean hasTree(Node node) {
-
-        boolean ret = false;
-        if (node instanceof AdaptiveSplitNode) {
-            AdaptiveSplitNode tmp = (AdaptiveSplitNode) node;
-            if (tmp.alternativeTree != null) {
-                ret = true;
-            }
-            for (int i = 0; ret == false && i < tmp.children.size(); i++) {
-                ret = ret || hasTree(tmp.children.get(i));
-            }
-        }
-        return ret;
-    }
-
-    @Override
-    public void learnFromInstance(Instance instance)
-            throws IademException {
-        getClassVotes(instance); // to update lastPrediction in the trees 
-        getClassVotesFromLeaf(instance);
-        super.learnFromInstance(instance);
-    }
-
-    protected void getClassVotesFromLeaf(Instance instance) {
-        double[] votes = null;
-        Node node = this.treeRoot;
-        while (votes == null) {
-            if (node instanceof AdaptiveSplitNode) {
-                AdaptiveSplitNode splitNode = (AdaptiveSplitNode) node;
-                int childIndex = splitNode.instanceChildIndex(instance);
-                if (childIndex >= 0) {
-                    node = splitNode.getChild(childIndex);
-                } else {
-                    votes = splitNode.leaf.getClassVotes(instance);
-                }
-            } else {
-                AdaptiveLeafNode leafNode = (AdaptiveLeafNode) node;
-                votes = leafNode.getClassVotes(instance);
-            }
-        }
-        this.lastPredictionInLeaf = Utils.maxIndex(votes);
-    }
-
-    public void copyTree(Iadem3Subtree arbol) {
-        this.treeRoot = arbol.treeRoot;
-    }
-
-    void setNewTree() {
-        numTrees++;
-    }
-
-    public int getChangedTrees() {
-        return interchangedTrees;
-    }
-
-    @Override
-    public double[] getClassVotes(Instance instance) {
-        double[] votes = super.getClassVotes(instance);
-        this.lastPrediction = Utils.maxIndex(votes);
-        return votes;
-    }
-
-    public int getNumberOfSubtrees() {
-        if (this.treeRoot instanceof AdaptiveSplitNode) {
-            return ((AdaptiveSplitNode) this.treeRoot).getNumberOfSubtrees();
-        }
-        return 0;
-    }
-
-    protected Iadem3 getMainTree() {
-        return this;
-    }
-
-    public void updateNumberOfLeaves(int amount) {
-        this.numberOfLeaves += amount;
-    }
-
-    public void updateNumberOfNodes(int amount) {
-        this.numberOfNodes += amount;
-    }
-
-    public void updateNumberOfNodesSplitByTieBreaking(int amount) {
-        this.numSplitsByBreakingTies += amount;
-    }
-
-    public class AdaptiveLeafNode extends LeafNode implements Serializable {
-
-        private static final long serialVersionUID = 1L;
-        protected AbstractChangeDetector estimator;
-
-        public AdaptiveLeafNode(Iadem3 arbol,
-                Node parent,
-                long instTreeCountSinceVirtual,
-                long instNodeCountSinceVirtual,
-                double[] initialClassCount,
-                IademNumericAttributeObserver numericAttClassObserver,
-                AbstractChangeDetector estimator,
-                boolean onlyMultiwayTest,
-                boolean onlyBinaryTest,
-                Instance instance) {
-            super(arbol,
-                    parent, instTreeCountSinceVirtual, instNodeCountSinceVirtual, initialClassCount, numericAttClassObserver, onlyMultiwayTest, onlyBinaryTest, instance);
-            if (estimator != null) {
-                this.estimator = (AbstractChangeDetector) estimator.copy();
-            } else {
-                this.estimator = null;
-            }
-        }
-
-        @Override
-        protected void createVirtualNodes(IademNumericAttributeObserver numericAttClassObserver,
-                boolean onlyMultiwayTest,
-                boolean onlyBinaryTest,
-                Instance instance) {
-            ArrayList<Integer> nominalUsed = nominalAttUsed(instance);
-            TreeSet<Integer> sort = new TreeSet<>(nominalUsed);
-            for (int i = 0; i < instance.numAttributes(); i++) {
-                if (instance.classIndex() != i
-                        && instance.attribute(i).isNominal()) {
-                    if ((!sort.isEmpty()) && (i == sort.first())) {
-                        sort.remove(new Integer(sort.first()));
-                        virtualChildren.set(i, null);
-                    } else {
-                        virtualChildren.set(i, new AdaptiveNominalVirtualNode((Iadem3) tree,
-                                this,
-                                i,
-                                onlyMultiwayTest,
-                                onlyBinaryTest));
-                    }
-                } else if (instance.classIndex() != i
-                        && instance.attribute(i).isNumeric()) {
-                    virtualChildren.set(i, new AdaptiveNumericVirtualNode((Iadem3) tree,
-                            this,
-                            i,
-                            numericAttClassObserver));
-                } else {
-                    virtualChildren.set(i, null);
-                }
-            }
-        }
-
-        private void updateCounters(Instance experiencia) {
-            double[] classVotes = this.getClassVotes(experiencia);
-            boolean trueClass = (Utils.maxIndex(classVotes) == (int) experiencia.classValue());
-            if (estimator != null && ((Iadem3) this.tree).restartAtDrift) {
-                double error = trueClass == true ? 0.0 : 1.0;
-                this.estimator.input(error);
-                if (this.estimator.getChange()) {
-                    this.restartVariablesAtDrift();
-                }
-            }
-        }
-
-        @Override
-        public void attemptToSplit(Instance instance) {
-            if (this.classValueDist.numNonZeroEntries() > 1) {
-                if (hasInformationToSplit()) {
-                    try {
-                        this.instSeenSinceLastSplitAttempt = 0;
-                        IademAttributeSplitSuggestion bestSplitSuggestion;
-                        if (this.instNodeCountSinceReal > 5000) {
-                            ((Iadem3) this.tree).updateNumberOfNodesSplitByTieBreaking(1);
-                            bestSplitSuggestion = getFastSplitSuggestion(instance);
-                            if (bestSplitSuggestion != null) {
-                                ((Iadem3) this.tree).currentSplitState = ((Iadem3) this.tree).SPLIT_BY_TIE_BREAKING;
-                                doSplit(bestSplitSuggestion, instance);
-                            }
-                        } else {
-                            bestSplitSuggestion = getBestSplitSuggestion(instance);
-                            if (bestSplitSuggestion != null) {
-                                ((Iadem3) this.tree).currentSplitState = ((Iadem3) this.tree).SPLIT_WITH_CONFIDENCE;
-                                doSplit(bestSplitSuggestion, instance);
-                            }
-                        }
-                    } catch (IademException ex) {
-                        Logger.getLogger(LeafNode.class.getName()).log(Level.SEVERE, null, ex);
-                    }
-                }
-            }
-        }
-
-        @Override
-        public Node learnFromInstance(Instance inst) {
-            updateCounters(inst);
-            return super.learnFromInstance(inst);
-        }
-
-        @Override
-        public AdaptiveLeafNode[] doSplit(IademAttributeSplitSuggestion mejorExpansion, Instance instance) {
-            AdaptiveSplitNode splitNode;
-            splitNode = (AdaptiveSplitNode) virtualChildren.get(mejorExpansion.splitTest.getAttsTestDependsOn()[0]).getNewSplitNode(instTreeCountSinceReal,
-                    parent,
-                    mejorExpansion,
-                    instance);
-            splitNode.setParent(this.parent);
-            splitNode.estimator = this.tree.newEstimator();
-
-            if (this.parent == null) {
-                tree.setTreeRoot(splitNode);
-            } else {
-                ((SplitNode) parent).changeChildren(this, splitNode);
-            }
-            this.tree.newSplit(splitNode.getLeaves().size());
-            return null;
-        }
-
-        protected void restartVariablesAtDrift() {
-            instNodeCountSinceVirtual = 0;
-
-            classValueDist = new DoubleVector();
-
-            instTreeCountSinceReal = 0;
-            instNodeCountSinceReal = 0;
-            for (int i = 0; i < virtualChildren.size(); i++) {
-                if (virtualChildren.get(i) != null) {
-                    ((restartsVariablesAtDrift) virtualChildren.get(i)).resetVariablesAtDrift();
-                }
-            }
-        }
-    }
-
-    public class AdaptiveLeafNodeNB extends AdaptiveLeafNode {
-
-        private static final long serialVersionUID = 1L;
-        protected int limitNaiveBayes;
-
-        public AdaptiveLeafNodeNB(Iadem3 tree,
-                Node parent,
-                long instTreeCountSinceVirtual,
-                long instNodeCountSinceVirtual,
-                double[] initialClassCount,
-                IademNumericAttributeObserver numericAttClassObserver,
-                int limitNaiveBayes,
-                AbstractChangeDetector estimator,
-                boolean onlyMultiwayTest,
-                boolean onlyBinaryTest,
-                Instance instance) {
-            super(tree,
-                    parent,
-                    instTreeCountSinceVirtual,
-                    instNodeCountSinceVirtual,
-                    initialClassCount,
-                    numericAttClassObserver,
-                    estimator,
-                    onlyMultiwayTest,
-                    onlyBinaryTest,
-                    instance);
-            this.limitNaiveBayes = limitNaiveBayes;
-        }
-
-        @Override
-        public double[] getClassVotes(Instance inst) {
-            double[] votes;
-            if (instNodeCountSinceVirtual == 0 || instNodeCountSinceReal < limitNaiveBayes) {
-                votes = getMajorityClassVotes(inst);
-            } else {
-                votes = getNaiveBayesPrediction(inst);
-            }
-            return votes;
-        }
-
-        protected double[] getNaiveBayesPrediction(Instance inst) {
-            double[] classDist = getMajorityClassVotes(inst);
-            DoubleVector conditionalProbability = null;
-            for (int i = 0; i < virtualChildren.size(); i++) {
-                VirtualNode virtual = virtualChildren.get(i);
-                if (virtual != null && virtual.hasInformation()) {
-                    double currentValue = inst.value(i);
-                    conditionalProbability = virtual.computeConditionalProbability(currentValue);
-                    if (conditionalProbability != null) {
-                        for (int j = 0; j < classDist.length; j++) {
-                            classDist[j] *= conditionalProbability.getValue(j);
-                        }
-                    }
-                }
-            }
-            double sum = 0.0;
-            for (int i = 0; i < classDist.length; i++) {
-                sum += classDist[i];
-            }
-            if (sum == 0.0) {
-                for (int i = 0; i < classDist.length; i++) {
-                    classDist[i] = 1.0 / classDist.length;
-                }
-            } else {
-                for (int i = 0; i < classDist.length; i++) {
-                    classDist[i] /= sum;
-                }
-            }
-            return classDist;
-        }
-    }
-
-    public class AdaptiveLeafNodeNBAdaptive extends AdaptiveLeafNodeNB {
-
-        private static final long serialVersionUID = 1L;
-        protected AbstractChangeDetector naiveBayesError,
-                majorityClassError;
-
-        public AdaptiveLeafNodeNBAdaptive(Iadem3 tree,
-                Node parent,
-                long instancesProcessedByTheTree,
-                long instancesProcessedByThisLeaf,
-                double[] classDist,
-                IademNumericAttributeObserver observadorContinuos,
-                int naiveBayesLimit,
-                boolean onlyMultiwayTest,
-                boolean onlyBinaryTest,
-                AbstractChangeDetector estimator,
-                Instance instance) {
-            super(tree,
-                    parent,
-                    instancesProcessedByTheTree,
-                    instancesProcessedByThisLeaf,
-                    classDist,
-                    observadorContinuos,
-                    naiveBayesLimit,
-                    estimator,
-                    onlyMultiwayTest,
-                    onlyBinaryTest,
-                    instance);
-            this.naiveBayesError = (AbstractChangeDetector) estimator.copy();
-            this.majorityClassError = (AbstractChangeDetector) estimator.copy();
-        }
-
-        @Override
-        public double[] getClassVotes(Instance instance) {
-            double mean1 = this.naiveBayesError.getEstimation(),
-                    mean2 = this.majorityClassError.getEstimation();
-            if (mean1 > mean2) {
-                return getMajorityClassVotes(instance);
-            } else {
-                return getNaiveBayesPrediction(instance);
-            }
-        }
-
-        @Override
-        public Node learnFromInstance(Instance inst) {
-            double[] classVote = getMajorityClassVotes(inst);
-            double error = (Utils.maxIndex(classVote) == (int) inst.classValue()) ? 0.0 : 1.0;
-            this.majorityClassError.input(error);
-
-            classVote = getNaiveBayesPrediction(inst);
-            error = (Utils.maxIndex(classVote) == (int) inst.classValue()) ? 0.0 : 1.0;
-            this.naiveBayesError.input(error);
-
-            return super.learnFromInstance(inst);
-        }
-
-    }
-
-    public class AdaptiveLeafNodeNBKirkby extends AdaptiveLeafNodeNB {
-
-        private static final long serialVersionUID = 1L;
-        protected int naiveBayesError,
-                majorityClassError;
-
-        public AdaptiveLeafNodeNBKirkby(Iadem3 tree,
-                Node parent,
-                long instancesProcessedByTheTree,
-                long instancesProcessedByThisLeaf,
-                double[] classDist,
-                IademNumericAttributeObserver observadorContinuos,
-                int naiveBayesLimit,
-                boolean onlyMultiwayTest,
-                boolean onlyBinaryTest,
-                AbstractChangeDetector estimator,
-                Instance instance) {
-            super(tree,
-                    parent,
-                    instancesProcessedByTheTree,
-                    instancesProcessedByThisLeaf,
-                    classDist,
-                    observadorContinuos,
-                    naiveBayesLimit,
-                    estimator,
-                    onlyMultiwayTest,
-                    onlyBinaryTest,
-                    instance);
-            this.naiveBayesError = 0;
-            this.majorityClassError = 0;
-        }
-
-        @Override
-        public double[] getClassVotes(Instance instance) {
-            if (naiveBayesError > majorityClassError) {
-                return getMajorityClassVotes(instance);
-            } else {
-                return getNaiveBayesPrediction(instance);
-            }
-        }
-
-        @Override
-        public Node learnFromInstance(Instance inst) {
-            double[] classVotes = getMajorityClassVotes(inst);
-            double error = (Utils.maxIndex(classVotes) == (int) inst.classValue()) ? 0.0 : 1.0;
-            this.majorityClassError += error;
-
-            classVotes = getNaiveBayesPrediction(inst);
-            error = (Utils.maxIndex(classVotes) == (int) inst.classValue()) ? 0.0 : 1.0;
-            this.naiveBayesError += error;
-
-            return super.learnFromInstance(inst);
-        }
-
-    }
-
-    public class AdaptiveLeafNodeWeightedVote extends AdaptiveLeafNodeNBAdaptive {
-
-        private static final long serialVersionUID = 1L;
-
-        public AdaptiveLeafNodeWeightedVote(Iadem3 tree,
-                Node parent,
-                long instTreeCountSinceVirtual,
-                long instNodeCountSinceVirtual,
-                double[] classDist,
-                IademNumericAttributeObserver observadorContinuos,
-                int naiveBayesLimit,
-                boolean onlyMultiwayTest,
-                boolean onlyBinaryTest,
-                AbstractChangeDetector estimator,
-                Instance instance) {
-            super(tree,
-                    parent,
-                    instTreeCountSinceVirtual,
-                    instNodeCountSinceVirtual,
-                    classDist,
-                    observadorContinuos,
-                    naiveBayesLimit,
-                    onlyMultiwayTest,
-                    onlyBinaryTest,
-                    estimator,
-                    instance);
-        }
-
-        @Override
-        public double[] getClassVotes(Instance instance) {
-            double NBweight = 1 - this.naiveBayesError.getEstimation(),
-                    MCweight = 1 - this.majorityClassError.getEstimation();
-            double[] MC = getMajorityClassVotes(instance),
-                    NB = getNaiveBayesPrediction(instance),
-                    votes = new double[MC.length];
-            for (int i = 0; i < MC.length; i++) {
-                votes[i] = MC[i] * MCweight + NB[i] * NBweight;
-            }
-            return votes;
-        }
-
-        protected boolean isSignificantlyGreaterThan(double mean1, double mean2, int n1, int n2) {
-            double m = 1.0 / n1 + 1.0 / n2,
-                    confidence = 0.001,
-                    log = Math.log(1.0 / confidence),
-                    bound = Math.sqrt(m * log / 2);
-            return mean1 - mean2 > bound;
-        }
-    }
-
-    public class AdaptiveNominalVirtualNode extends NominalVirtualNode implements Serializable, restartsVariablesAtDrift {
-
-        private static final long serialVersionUID = 1L;
-
-        protected AbstractChangeDetector estimador;
-
-        public AdaptiveNominalVirtualNode(Iadem3 tree,
-                Node parent,
-                int attID,
-                boolean onlyMultiwayTest,
-                boolean onlyBinaryTest) {
-            super(tree, parent, attID, onlyMultiwayTest, onlyBinaryTest);
-        }
-
-        @Override
-        public Node learnFromInstance(Instance inst) {
-            double attValue = inst.value(attIndex);
-            if (Utils.isMissingValue(attValue)) {
-            } else {
-                updateCountersForChange(inst);
-            }
-            return super.learnFromInstance(inst);
-        }
-
-        private void updateCountersForChange(Instance inst) {
-            double[] classVotes = this.getClassVotes(inst);
-            boolean trueClass = (Utils.maxIndex(classVotes) == (int) inst.classValue());
-            if (estimador != null && ((Iadem3) this.tree).restartAtDrift) {
-                double error = trueClass == true ? 0.0 : 1.0;
-                this.estimador.input(error);
-                if (this.estimador.getChange()) {
-                    this.resetVariablesAtDrift();
-                }
-            }
-        }
-
-        @Override
-        public SplitNode getNewSplitNode(long counter,
-                Node parent,
-                IademAttributeSplitSuggestion bestSplit,
-                Instance instance) {
-            AdaptiveSplitNode splitNode = new AdaptiveSplitNode((Iadem3) this.tree,
-                    parent,
-                    null,
-                    ((LeafNode) this.parent).getMajorityClassVotes(instance),
-                    bestSplit.splitTest,
-                    ((AdaptiveLeafNode) this.parent).estimator,
-                    (AdaptiveLeafNode) this.parent,
-                    ((Iadem3) this.tree).currentSplitState);
-
-            Node[] children;
-            if (bestSplit.splitTest instanceof NominalAttributeMultiwayTest) {
-                children = new Node[instance.attribute(this.attIndex).numValues()];
-                for (int i = 0; i < children.length; i++) {
-                    long tmpConter = 0;
-                    double[] newClassDist = new double[instance.attribute(instance.classIndex()).numValues()];
-                    Arrays.fill(newClassDist, 0);
-                    for (int j = 0; j < newClassDist.length; j++) {
-                        DoubleVector tmpClassDist = nominalAttClassObserver.get(i);
-                        double tmpAttClassCounter = tmpClassDist != null ? tmpClassDist.getValue(j) : 0.0;
-                        newClassDist[j] = tmpAttClassCounter;
-                        tmpConter += newClassDist[j];
-                    }
-                    children[i] = ((Iadem3) tree).newLeafNode(splitNode,
-                            counter,
-                            tmpConter,
-                            newClassDist,
-                            instance);
-                }
-            } else { // binary split
-                children = new Node[2];
-                IademNominalAttributeBinaryTest binarySplit = (IademNominalAttributeBinaryTest) bestSplit.splitTest;
-                double[] newClassDist = new double[instance.attribute(instance.classIndex()).numValues()];
-                double tmpCounter = 0;
-                Arrays.fill(newClassDist, 0);
-                DoubleVector classDist = nominalAttClassObserver.get(binarySplit.getAttValue());
-                for (int i = 0; i < newClassDist.length; i++) {
-                    newClassDist[i] = classDist.getValue(i);
-                    tmpCounter += classDist.getValue(i);
-                }
-                children[0] = ((Iadem3) tree).newLeafNode(splitNode,
-                        counter,
-                        (int) tmpCounter,
-                        newClassDist,
-                        instance);
-                // a la derecha...
-                tmpCounter = this.classValueDist.sumOfValues() - tmpCounter;
-                for (int i = 0; i < newClassDist.length; i++) {
-                    newClassDist[i] = this.classValueDist.getValue(i) - newClassDist[i];
-                }
-                children[1] = ((Iadem3) tree).newLeafNode(splitNode,
-                        counter,
-                        (int) tmpCounter,
-                        newClassDist,
-                        instance);
-            }
-
-            splitNode.setChildren(children);
-
-            return splitNode;
-        }
-
-        @Override
-        public void resetVariablesAtDrift() {
-            attValueDist = new DoubleVector();
-            nominalAttClassObserver = new AutoExpandVector<DoubleVector>();
-            classValueDist = new DoubleVector();
-        }
-    }
-
-    public class AdaptiveNumericVirtualNode extends NumericVirtualNode implements Serializable, restartsVariablesAtDrift {
-
-        private static final long serialVersionUID = 1L;
-        protected IademNumericAttributeObserver altAttClassObserver;
-        protected DoubleVector altClassDist;
-        protected AbstractChangeDetector estimator;
-
-        public AdaptiveNumericVirtualNode(Iadem3 tree,
-                Node parent,
-                int attID,
-                IademNumericAttributeObserver observadorContinuos) {
-            super(tree, parent, attID, observadorContinuos);
-        }
-
-        @Override
-        public Node learnFromInstance(Instance inst) {
-            updateCounters(inst);
-            return super.learnFromInstance(inst);
-        }
-
-        private void updateCounters(Instance inst) {
-            double[] classVotes = this.getClassVotes(inst);
-            boolean correct = (Utils.maxIndex(classVotes) == (int) inst.classValue());
-            if (this.estimator != null && ((Iadem3) this.tree).restartAtDrift) {
-                double error = correct == true ? 0.0 : 1.0;
-                this.estimator.input(error);
-                if (this.estimator.getChange()) {
-                    this.resetVariablesAtDrift();
-                }
-            }
-        }
-
-        private long sum(long[] arr) {
-            long s = 0;
-            for (int i = 0; i < arr.length; i++) {
-                s += arr[i];
-            }
-            return s;
-        }
-
-        @Override
-        public SplitNode getNewSplitNode(long counter,
-                Node parent,
-                IademAttributeSplitSuggestion bestSplit,
-                Instance instance) {
-            double[] cutPoints = new double[]{bestCutPoint};
-            Node[] children = new Node[2]; // a binary split
-            long[] newClassDist = numericAttClassObserver.getLeftClassDist(bestCutPoint);
-            long sumClassDist = numericAttClassObserver.getValueCount();
-            long[] sumAttClassDist = numericAttClassObserver.getClassDist();
-            boolean equalsPassesTest = true;
-            if (this.numericAttClassObserver instanceof IademVFMLNumericAttributeClassObserver) {
-                equalsPassesTest = false;
-            }
-            AdaptiveSplitNode splitNode = new AdaptiveSplitNode((Iadem3) this.tree,
-                    parent,
-                    null,
-                    ((LeafNode) this.parent).getMajorityClassVotes(instance),
-                    new NumericAttributeBinaryTest(this.attIndex, cutPoints[0], equalsPassesTest),
-                    ((AdaptiveLeafNode) this.parent).estimator,
-                    (AdaptiveLeafNode) this.parent,
-                    ((Iadem3) this.tree).currentSplitState);
-            long leftClassDist = sum(newClassDist);
-            long rightClassDist = sumClassDist - leftClassDist;
-            double[] newLeftClassDist = new double[instance.attribute(instance.classIndex()).numValues()];
-            double[] newRightClassDist = new double[instance.attribute(instance.classIndex()).numValues()];
-
-            Arrays.fill(newLeftClassDist, 0);
-            Arrays.fill(newRightClassDist, 0);
-
-            for (int i = 0; i < newClassDist.length; i++) {
-                newLeftClassDist[i] = newClassDist[i];
-                newRightClassDist[i] = sumAttClassDist[i] - newLeftClassDist[i];
-            }
-            splitNode.setChildren(null);
-            children[0] = ((Iadem3) tree).newLeafNode(splitNode,
-                    counter,
-                    leftClassDist,
-                    newLeftClassDist,
-                    instance);
-            children[1] = ((Iadem3) tree).newLeafNode(splitNode,
-                    counter,
-                    rightClassDist,
-                    newRightClassDist,
-                    instance);
-            splitNode.setChildren(children);
-            return splitNode;
-        }
-
-        @Override
-        public void resetVariablesAtDrift() {
-            this.bestSplitSuggestion = null;
-            this.heuristicMeasureUpdated = false;
-            numericAttClassObserver.reset();
-            classValueDist = new DoubleVector();
-        }
-    }
-
-    public class AdaptiveSplitNode extends SplitNode implements Serializable {
-
-        private static final long serialVersionUID = 1L;
-
-        protected AutoExpandVector<Iadem3Subtree> alternativeTree = new AutoExpandVector<Iadem3Subtree>();
-        // Detector de cambio de concepto
-        protected AbstractChangeDetector estimator;
-
-        protected int causeOfSplit;
-
-        protected AdaptiveLeafNode leaf;
-
-        public AdaptiveSplitNode(Iadem3 tree,
-                Node parent,
-                Node[] child,
-                double[] freq,
-                InstanceConditionalTest splitTest,
-                AbstractChangeDetector estimator,
-                AdaptiveLeafNode predictionLeaf,
-                int causeOfSplit) {
-            super(tree, parent, child, freq, splitTest);
-            if (estimator != null) {
-                this.estimator = (AbstractChangeDetector) estimator.copy();
-            } else {
-                this.estimator = null;
-            }
-            this.leaf = predictionLeaf;
-            this.leaf.setSplit(false);
-            this.causeOfSplit = causeOfSplit;
-        }
-
-        @Override
-        public Node learnFromInstance(Instance instance) {
-
-            try {
-                double thisError = this.estimator.getEstimation(),
-                        thisSize = this.estimator.getDelay();
-                double leafError = this.leaf.estimator.getEstimation(),
-                        leafSize = this.leaf.estimator.getDelay();
-                double m = 1.0 / thisSize + 1.0 / leafSize;
-                double delta = 0.0001;
-                double bound = Math.sqrt(m * Math.log(2.0 / delta) / 2.0);
-                double diff = thisError - leafError;
-                if (diff > bound && thisSize > 600 && leafSize > 600/**/) {
-                    prune();
-                    return this.leaf;
-                } else if (-diff > bound) {
-                    this.leaf.restartVariablesAtDrift();
-                    this.leaf.estimator = (AbstractChangeDetector) this.leaf.estimator.copy();
-                }
-                Node node;
-                boolean rightPredicted = ((Iadem3) this.tree).lastPredictionInLeaf == instance.classValue();
-                node = checkAlternativeSubtrees(rightPredicted, instance);
-                if (node == null) {
-                    // no subtree change
-                    for (Iadem3Subtree subtree : this.alternativeTree) {
-                        try {
-                            subtree.learnFromInstance(instance);
-                            subtree.incrNumberOfInstancesProcessed();
-                        } catch (IademException ex) {
-                            Logger.getLogger(AdaptiveSplitNode.class.getName()).log(Level.SEVERE, null, ex);
-                        }
-                    }
-                    this.leaf.learnFromInstance(instance);
-                    return super.learnFromInstance(instance);
-                } else {
-                    // subtree change
-                    return node.learnFromInstance(instance);
-                }
-            } catch (IademException ex) {
-                Logger.getLogger(AdaptiveSplitNode.class.getName()).log(Level.SEVERE, null, ex);
-            }
-            return null;
-        }
-
-        private Node checkAlternativeSubtrees(boolean acierto, Instance instance) throws IademException {
-            if (this.estimator != null) {
-                double loss = (acierto == true ? 0.0 : 1.0);
-                estimator.input(loss);
-                if (estimator.getChange()) {
-                    this.createTree(instance);
-                }
-                for (int i = 0; i < this.alternativeTree.size(); i++) {
-                    Iadem3Subtree subtree = alternativeTree.get(i);
-                    double treeError = subtree.estimacionValorMedio(),
-                            thisError = this.estimator.getEstimation();
-                    double bound = IademCommonProcedures.AverageComparitionByHoeffdingCorollary(this.estimator.getDelay(),
-                            subtree.windowWidth(),
-                            1e-4);
-
-                    if (thisError - treeError > bound/**/) {
-                        ((Iadem3) this.tree).interchangedTrees++;
-                        return changeTrees(i);
-                    } else if (isUseless(i)) {
-                        ((Iadem3) this.tree).updateNumberOfLeaves(-subtree.getNumberOfLeaves());
-                        ((Iadem3) this.tree).updateNumberOfNodes(-subtree.getNumberOfNodes());
-                        ((Iadem3) this.tree).updateNumberOfNodesSplitByTieBreaking(-subtree.numSplitsByBreakingTies);
-                        i--;
-                    } else if (this.estimator.getDelay() > 6000
-                            && subtree.windowWidth() > 6000/**/) {
-                        {
-                            if (treeError - thisError > bound) {
-                                this.alternativeTree.remove(i);
-                                // update number of nodes
-                                ((Iadem3) this.tree).updateNumberOfLeaves(-subtree.getNumberOfLeaves());
-                                ((Iadem3) this.tree).updateNumberOfNodes(-subtree.getNumberOfNodes());
-                                ((Iadem3) this.tree).updateNumberOfNodesSplitByTieBreaking(-subtree.numSplitsByBreakingTies);
-                                i--;
-                            } else /**/ {
-                                int[] countMain = new int[3],
-                                        countAlt = new int[3];
-                                for (Node child : this.children) {
-                                    child.getNumberOfNodes(countMain);
-                                }
-                                subtree.getNumberOfNodes(countAlt);/**/
-
-                                if (countMain[0] + countMain[1] + 1 > countAlt[0] + countAlt[1]) {
-                                    return changeTrees(i);
-                                } else {
-                                    this.alternativeTree.remove(i);
-                                    // update number of nodes
-                                    ((Iadem3) this.tree).updateNumberOfLeaves(-subtree.getNumberOfLeaves());
-                                    ((Iadem3) this.tree).updateNumberOfNodes(-subtree.getNumberOfNodes());
-                                    ((Iadem3) this.tree).updateNumberOfNodesSplitByTieBreaking(-subtree.numSplitsByBreakingTies);
-                                    i--;
-                                }
-                            }
-                        }/**/
-
-                    }
-
-                }
-            }
-            return null;
-        }
-
-        public boolean isUseless(int i) {
-            boolean removed = false;
-            Iadem3Subtree subtree = this.alternativeTree.get(i);
-            if (subtree.getTreeRoot() instanceof AdaptiveSplitNode) /**/ {
-                // change if it already has an alternative subtree 
-                AdaptiveSplitNode splitNode = ((AdaptiveSplitNode) subtree.getTreeRoot());
-
-                int nMain = (int) this.estimator.getDelay(),
-                        nAlt = (int) subtree.getEstimador().getDelay();
-                double errorMain = this.estimator.getEstimation(),
-                        errorAlt = subtree.getEstimador().getEstimation();
-                double errorDifference = errorAlt - errorMain,
-                        absError = Math.abs(errorDifference);
-                if (!removed && nMain > 0 && nAlt > 0) {
-                    double m = 1.0 / nMain + 1.0 / nAlt;
-                    double delta = 1e-4;
-                    double bound = Math.sqrt(m * Math.log(2.0 / delta) / 2.0);
-                    if (errorDifference > bound) {
-                        // alternative tree is too inaccurate
-                        this.alternativeTree.remove(i);
-                        removed = true;
-                    }
-                }
-                if (!removed) {
-                    InstanceConditionalTest condTest = splitNode.splitTest;
-                    if (condTest instanceof IademNominalAttributeBinaryTest
-                            && this.splitTest instanceof IademNominalAttributeBinaryTest) {
-                        IademNominalAttributeBinaryTest altTest = (IademNominalAttributeBinaryTest) condTest,
-                                mainTest = (IademNominalAttributeBinaryTest) this.splitTest;
-                        if (mainTest.getAttValue() == altTest.getAttValue()
-                                && mainTest.getAttsTestDependsOn()[0] == altTest.getAttsTestDependsOn()[0]) {
-                            this.alternativeTree.remove(i);
-                            removed = true;
-                        }
-                    } else if (condTest instanceof NominalAttributeMultiwayTest
-                            && this.splitTest instanceof NominalAttributeMultiwayTest) {
-                        NominalAttributeMultiwayTest altTest = (NominalAttributeMultiwayTest) condTest,
-                                mainTest = (NominalAttributeMultiwayTest) this.splitTest;
-                        if (mainTest.getAttsTestDependsOn()[0] == altTest.getAttsTestDependsOn()[0]) {
-                            this.alternativeTree.remove(i);
-                            removed = true;
-                        }
-                    } else if (condTest instanceof NumericAttributeBinaryTest
-                            && this.splitTest instanceof NumericAttributeBinaryTest) {
-                        NumericAttributeBinaryTest altTest = (NumericAttributeBinaryTest) condTest,
-                                mainTest = (NumericAttributeBinaryTest) this.splitTest;
-                        if (mainTest.getAttsTestDependsOn()[0] == altTest.getAttsTestDependsOn()[0]
-                                && mainTest.getSplitValue() == altTest.getSplitValue()) {
-                            this.alternativeTree.remove(i);
-                            removed = true;
-                        }
-                    }
-                }
-            }
-            return removed;
-        }
-
-        private Node changeTrees(int index) {
-            for (int i = 0; i < this.alternativeTree.size(); i++) {
-                if (i != index) {
-                    Iadem3Subtree subtree = this.alternativeTree.get(i);
-                    ((Iadem3) this.tree).updateNumberOfLeaves(-subtree.getNumberOfLeaves());
-                    ((Iadem3) this.tree).updateNumberOfNodes(-subtree.getNumberOfNodes());
-                    ((Iadem3) this.tree).updateNumberOfNodesSplitByTieBreaking(-subtree.numSplitsByBreakingTies);
-                }
-            }
-            Iadem3Subtree subtree = this.alternativeTree.get(index);
-            // rest nodes of this main tree
-            int count[] = new int[3];
-            super.getNumberOfNodes(count);
-            if (this.causeOfSplit == ((Iadem3) this.tree).SPLIT_BY_TIE_BREAKING) {
-                count[2]++;
-            }
-            ((Iadem3) this.tree).updateNumberOfLeaves(-count[1]);
-            ((Iadem3) this.tree).updateNumberOfNodes(-count[0] - count[1]);
-            ((Iadem3) this.tree).updateNumberOfNodesSplitByTieBreaking(-count[2]);
-            //
-            AdaptiveSplitNode tmpParent = (AdaptiveSplitNode) this.parent;
-            Node newNode = subtree.getTreeRoot();
-            ((Iadem3) tree).newTreeChange();
-            if (tmpParent == null) {
-                ((Iadem3) tree).copyTree(subtree);
-            } else {
-                for (int i = 0; i < tmpParent.children.size(); i++) {
-                    if (tmpParent.children.get(i) == this) {
-                        tmpParent.children.set(i, newNode);
-                        newNode.parent = tmpParent;
-                    }
-                }
-            }
-            updateAttributes(newNode);
-            if (newNode instanceof AdaptiveSplitNode) {
-                AdaptiveSplitNode splitNode = (AdaptiveSplitNode) newNode;
-                for (Iadem3Subtree currentSubtree : splitNode.alternativeTree) {
-                    updateSubtreeLevel(currentSubtree.getTreeRoot());
-                }
-            }
-            return newNode;
-        }
-
-        void updateAttributes(Node newNode) {
-            if (newNode == null) {
-                return;
-            }
-            newNode.setTree(this.tree);
-            if (newNode instanceof AdaptiveSplitNode) {
-                AdaptiveSplitNode splitNode = (AdaptiveSplitNode) newNode;
-                splitNode.leaf.setTree(this.tree);
-                for (Node child : splitNode.children) {
-                    updateAttributes(child);
-                }
-            } else if (newNode instanceof AdaptiveLeafNode) {
-                AdaptiveLeafNode leafNode = (AdaptiveLeafNode) newNode;
-                AutoExpandVector<VirtualNode> virtualChildren = leafNode.getVirtualChildren();
-                for (VirtualNode child : virtualChildren) {
-                    if (child != null) {
-                        child.setTree(this.tree);
-                    }
-                }
-            }
-        }
-
-        protected void updateSubtreeLevel(Node node) {
-            if (node != null) {
-                ((Iadem3) node.getTree()).treeLevel--;
-                if (node instanceof AdaptiveSplitNode) {
-                    AdaptiveSplitNode splitNode = (AdaptiveSplitNode) node;
-                    for (Node child : splitNode.children) {
-                        updateSubtreeLevelAux(child);
-                    }
-                    for (Iadem3Subtree subtree : splitNode.alternativeTree) {
-                        updateSubtreeLevel(subtree.getTreeRoot());
-                    }
-                }
-            }
-        }
-
-        protected void updateSubtreeLevelAux(Node node) {
-            if (node != null) {
-                if (node instanceof AdaptiveSplitNode) {
-                    AdaptiveSplitNode splitNode = (AdaptiveSplitNode) node;
-                    // update level in alternative subtrees
-                    for (Iadem3Subtree subtree : splitNode.alternativeTree) {
-                        updateSubtreeLevel(subtree.getTreeRoot());
-                    }
-                    for (Node child : splitNode.children) {
-                        updateSubtreeLevelAux(child);
-                    }
-                }
-            }
-        }
-
-        void createTree(Instance instance) throws IademException {
-            Iadem3 iadem3Tree = ((Iadem3) this.tree);
-            if (iadem3Tree.canCreateSubtree()) {
-                int maxTreeLevel = iadem3Tree.getMaxNestingLevels();
-                int maxAltSubtrees = iadem3Tree.getMaxAltSubtreesPerNode();
-                if ((maxTreeLevel == -1 || iadem3Tree.getTreeLevel() < maxTreeLevel)
-                        && (maxAltSubtrees == -1 || this.alternativeTree.size() < maxAltSubtrees)) {
-                    if (this.estimator != null) {
-                        Iadem3Subtree subtree = new Iadem3Subtree(this,
-                                iadem3Tree.getTreeLevel() + 1,
-                                (Iadem3) this.tree,
-                                instance);
-                        this.alternativeTree.add(subtree);
-                        ((Iadem3) tree).setNewTree();
-                    }
-                }
-            }
-        }
-
-        public int getNumTrees() {
-            int trees = this.alternativeTree.size() == 0 ? 0 : 1;
-            for (Node child : children) {
-                if (child instanceof AdaptiveSplitNode) {
-                    trees += ((AdaptiveSplitNode) child).getNumTrees();
-                }
-            }
-            for (Iadem3Subtree subtree : this.alternativeTree) {
-                if (subtree.getTreeRoot() instanceof AdaptiveSplitNode) {
-                    AdaptiveSplitNode node = (AdaptiveSplitNode) subtree.getTreeRoot();
-                    trees += node.getNumTrees();
-                }
-            }
-            return trees;
-        }
-
-        @Override
-        public double[] getClassVotes(Instance observacion) {
-            double[] classDist = this.leaf.getClassVotes(observacion);
-
-            double thisError = this.estimator.getEstimation();
-            double leafError = this.leaf.estimator.getEstimation();
-
-            int childIndex = instanceChildIndex(observacion);
-            if (childIndex >= 0 && thisError < leafError) {
-                Node hijo = getChild(childIndex);
-                classDist = hijo.getClassVotes(observacion);
-            }
-
-            for (Iadem3Subtree subtree : this.alternativeTree) {
-                double[] tmp = subtree.getClassVotes(observacion);
-                double altWeight = 1.0 - subtree.estimacionValorMedio();
-                for (int j = 0; j < classDist.length; j++) {
-                    classDist[j] = classDist[j] + tmp[j] * altWeight;
-                }
-            }
-            return classDist;
-        }
-
-        @Override
-        public int getSubtreeNodeCount() {
-            int tmp = super.getSubtreeNodeCount();
-            for (Iadem3Subtree subtree : this.alternativeTree) {
-                tmp += subtree.getTreeRoot().getSubtreeNodeCount();
-            }
-            return tmp;
-        }
-
-        public double getErrorEstimation() {
-            return this.estimator.getEstimation();
-        }
-
-        @Override
-        public void getNumberOfNodes(int[] count) {
-            for (Iadem3Subtree tree : this.alternativeTree) {
-                tree.getNumberOfNodes(count);
-            }
-            if (this.causeOfSplit == ((Iadem3) this.tree).SPLIT_BY_TIE_BREAKING) {
-                count[2]++;
-            }
-            super.getNumberOfNodes(count);
-        }
-
-        public int getNumberOfSubtrees() {
-            int count = this.alternativeTree.size();
-            for (Iadem3Subtree subtree : this.alternativeTree) {
-                count += ((Iadem3) subtree).getNumberOfSubtrees();
-            }
-            for (Node child : children) {
-                if (child instanceof AdaptiveSplitNode) {
-                    count += ((AdaptiveSplitNode) child).getNumberOfSubtrees();
-                }
-            }
-            return count;
-        }
-
-        private void prune() {
-            this.leaf.setSplit(true);
-            for (Node node = this.parent; node != null; node = node.parent) {
-                ((AdaptiveSplitNode) node).leaf.restartVariablesAtDrift();
-                this.leaf.estimator = (AbstractChangeDetector) this.leaf.estimator.copy();
-            }
-            // update tree
-            this.leaf.setTree(this.tree);
-            AutoExpandVector<VirtualNode> nodeList = this.leaf.getVirtualChildren();
-            for (VirtualNode node : nodeList) {
-                if (node != null) {
-                    node.setTree(this.tree);
-                }
-            }
-
-            this.leaf.setParent(this.parent);
-
-            if (this.parent == null) {
-                this.tree.setTreeRoot(this.leaf);
-            } else {
-                ((SplitNode) this.parent).changeChildren(this, this.leaf);
-            }
-
-            int count[] = new int[3];
-            getNumberOfNodes(count);
-
-            ((Iadem3) this.tree).updateNumberOfLeaves(-count[1] + 1);
-            ((Iadem3) this.tree).updateNumberOfNodes(-count[0] - count[1] + 1);
-            ((Iadem3) this.tree).updateNumberOfNodesSplitByTieBreaking(-count[2]);
-        }
-    }
-
-    public interface restartsVariablesAtDrift {
-
-        public void resetVariablesAtDrift();
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/trees/iadem/Iadem3Subtree.java b/moa/src/main/java/moa/classifiers/trees/iadem/Iadem3Subtree.java
deleted file mode 100644
index 84a545fed..000000000
--- a/moa/src/main/java/moa/classifiers/trees/iadem/Iadem3Subtree.java
+++ /dev/null
@@ -1,163 +0,0 @@
-/*
- *    Subtree.java
- *
- *    @author Isvani Frías-Blanco
- * 
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-package moa.classifiers.trees.iadem;
-
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.classifiers.core.driftdetection.AbstractChangeDetector;
-
-
-/**
- *
- * @author Isvani Frías Blanco (ifriasb at hotmail dot com)
- */
-public class Iadem3Subtree extends Iadem3 {
-
-    protected static final long serialVersionUID = 1L;
-    protected AbstractChangeDetector errorEstimator;
-    protected Node nodo;
-
-    protected Iadem3 mainTree;
-
-    public Iadem3Subtree(Node node,
-            int treeLevel,
-            Iadem3 mainTree,
-            Instance instance) {
-        // subtree configuration from main tree
-        this.numericEstimatorOption.setValueViaCLIString(mainTree.numericEstimatorOption.getValueAsCLIString());
-        this.gracePeriodOption.setValue(mainTree.gracePeriodOption.getValue());
-        this.splitCriterionOption.setChosenIndex(mainTree.splitCriterionOption.getChosenIndex());
-        this.splitConfidenceOption.setValue(mainTree.splitConfidenceOption.getValue());
-        this.splitTestsOption.setChosenIndex(mainTree.splitTestsOption.getChosenIndex());
-        this.leafPredictionOption.setChosenIndex(mainTree.leafPredictionOption.getChosenIndex());
-        this.driftDetectionMethodOption.setValueViaCLIString(mainTree.driftDetectionMethodOption.getValueAsCLIString());
-        this.attributeDiferentiation.setValue(mainTree.attributeDiferentiation.getValue());
-        this.maxNestingLevelOption.setValue(mainTree.maxNestingLevelOption.getValue());
-        this.maxSubtreesPerNodeOption.setValue(mainTree.maxSubtreesPerNodeOption.getValue());
-        
-        // subtree inicializations
-        this.estimator = mainTree.getEstimatorCopy();
-        this.errorEstimator = mainTree.getEstimatorCopy();
-        this.nodo = node;
-        this.mainTree = mainTree;
-        this.mainTree.updateNumberOfLeaves(1);
-        this.mainTree.updateNumberOfNodes(1);
-        createRoot(instance);
-    }
-    
-    @Override
-    public AbstractChangeDetector getEstimatorCopy() {
-        return this.mainTree.getEstimatorCopy();
-    }
-    
-    @Override
-    protected IademNumericAttributeObserver newNumericClassObserver() {
-        return this.mainTree.newNumericClassObserver();
-    }
-
-    @Override
-    public void learnFromInstance(Instance instance)
-            throws IademException {
-        getClassVotes(instance);
-        getClassVotesFromLeaf(instance);
-
-        boolean rightPredicted = this.lastPredictionInLeaf == instance.classValue();
-        double lossValue = (rightPredicted == true ? 0.0 : 1.0);
-        this.errorEstimator.input(lossValue);
-
-        treeRoot.learnFromInstance(instance);
-    }
-
-    @Override
-    public boolean canCreateSubtree() {
-        return this.mainTree.canCreateSubtree();
-    }
-
-    public double estimacionValorMedio() {
-        return this.errorEstimator != null ? this.errorEstimator.getEstimation() : -1;
-    }
-    
-    public int windowWidth() {
-        return (int) (this.errorEstimator != null ? this.errorEstimator.getDelay() : 0);
-    }
-    
-    public AbstractChangeDetector getEstimador() {
-        return errorEstimator;
-    }
-    
-    public void setEstimador(AbstractChangeDetector estimador) {
-        this.errorEstimator = estimador;
-    }
-
-    @Override
-    public void setNewTree() {
-        ((Iadem3) this.nodo.getTree()).setNewTree();
-    }
-
-    @Override
-    public void newDeletedTree() {
-        ((Iadem3) this.nodo.getTree()).newDeletedTree();
-    }
-
-    @Override
-    public void newTreeChange() {
-        ((Iadem3) this.nodo.getTree()).newTreeChange();
-    }
-
-    @Override
-    protected Iadem3 getMainTree() {
-        return this.mainTree;
-    }
-
-    @Override
-    public void newSplit(int numOfLeaves) {
-        this.numberOfLeaves += numOfLeaves - 1;
-        this.numberOfNodes += numOfLeaves;
-        this.mainTree.newSplit(numOfLeaves);
-    }
-
-    @Override
-    public void updateNumberOfLeaves(int amount) {
-        this.numberOfLeaves += amount;
-        this.mainTree.updateNumberOfLeaves(amount);
-    }
-
-    @Override
-    public void updateNumberOfNodes(int amount) {
-        this.numberOfNodes += amount;
-        this.mainTree.updateNumberOfNodes(amount);
-    }
-    
-    @Override
-    public void updateNumberOfNodesSplitByTieBreaking(int amount) {
-        this.numSplitsByBreakingTies += amount;
-        this.mainTree.updateNumberOfNodesSplitByTieBreaking(amount);
-    }
-
-    @Override
-    public void addSubtree(Iadem3Subtree subtree) {
-        this.mainTree.addSubtree(subtree);
-    }
-
-    @Override
-    public void removeSubtree(Iadem3Subtree subtree) {
-        this.mainTree.removeSubtree(subtree);
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/trees/iadem/IademCommonProcedures.java b/moa/src/main/java/moa/classifiers/trees/iadem/IademCommonProcedures.java
deleted file mode 100644
index 3785dd8ff..000000000
--- a/moa/src/main/java/moa/classifiers/trees/iadem/IademCommonProcedures.java
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
- *    IademCommonProcedures.java
- *
- *    @author José del Campo-Ávila
- * 
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.classifiers.trees.iadem;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-
-public class IademCommonProcedures implements Serializable {
-
-    private static final long serialVersionUID = 1L;
-    private static double confidence;
-    private static double ln_2_div_confidence;
-    private static double square_ln_2_div_confianza;
-    
-    public IademCommonProcedures(double confidence) {
-        IademCommonProcedures.confidence = confidence;
-        IademCommonProcedures.ln_2_div_confidence = Math.log(2.0 / confidence);
-        IademCommonProcedures.square_ln_2_div_confianza = ln_2_div_confidence
-                * ln_2_div_confidence;
-    }
-
-    public static double AverageComparitionByHoeffdingCorollary(double n, double n1, double alfa) {
-        double m = 1.0 / n + 1.0 / n1;
-        double bound = Math.sqrt(m * Math.log(1.0 / alfa) / 2.0);
-        return bound;
-    }
-    
-    public static double getConfidence() {
-        return confidence;
-    }
-    
-    public static void setConfidence(double confianza) {
-        IademCommonProcedures.confidence = confianza;
-        IademCommonProcedures.ln_2_div_confidence = Math.log(2.0 / confianza);
-        IademCommonProcedures.square_ln_2_div_confianza = ln_2_div_confidence * ln_2_div_confidence;
-    }
-
-    public static double getIADEM_HoeffdingBound(double average, double n) {
-        return computeBound(average, n);
-    }
-    
-    public static double log(double base, double num) {
-        return (Math.log(num) / Math.log(base));
-    }
-    
-    public static void insertLotsHoles(ArrayList<Double> lots,
-            ArrayList<Integer> holes, double inf,
-            double sup) {
-        if (inf != sup) {
-            int currentPos = 1;
-            if (inf == 0.0) {
-                for (int i = 0; i < holes.size(); i++) {
-                    int aux = holes.get(i);
-                    aux++;
-                    holes.set(i, aux);
-                }
-            } else {
-                while (inf > lots.get(currentPos)) {
-                    currentPos++;
-                }
-                if (inf < lots.get(currentPos)) {
-                    lots.add(currentPos, inf);
-                    holes.add(currentPos, (holes.get(currentPos - 1) + 1));
-                } else { 
-                    int aux = holes.get(currentPos);
-                    aux++;
-                    holes.set(currentPos, aux);
-                }
-                for (int i = (currentPos + 1); i < holes.size(); i++) {
-                    int aux = holes.get(i);
-                    aux++;
-                    holes.set(i, aux);
-                }
-            }
-            while (sup > lots.get(currentPos)) {
-                currentPos++;
-            }
-            if (sup < lots.get(currentPos)) {
-                lots.add(currentPos, sup);
-                holes.add(currentPos, (holes.get(currentPos - 1) - 1));
-            } else if (currentPos < holes.size()) { 
-                int aux = holes.get(currentPos);
-                aux--;
-                holes.set(currentPos, aux);
-            }
-            for (int i = (currentPos + 1); i < holes.size(); i++) {
-                int aux = holes.get(i);
-                aux--;
-                holes.set(i, aux);
-            }
-        }
-    }
-    
-    public static double computeLevel(ArrayList<Double> lots, 
-            ArrayList<Integer> holes, double amount) {
-        double level = 0.0;
-        int currentLot = 0;
-        double localAmount = amount;
-        double upperBound, lowerBound, nLot, fullAmount;
-        if (localAmount == 0.0) {
-            if ((holes.size() == 1) && (holes.get(0) == 0)) { 
-                level = 0.0;
-            } else {
-                while ((currentLot < holes.size()) && (holes.get(currentLot) == 0)) {
-                    currentLot++;
-                }
-                level = lots.get(currentLot);
-            }
-        } else {
-            while (localAmount > 0.0) {
-                upperBound = lots.get(currentLot + 1);
-                lowerBound = lots.get(currentLot);
-                nLot = holes.get(currentLot);
-                fullAmount = (upperBound - lowerBound) * nLot;
-                if (localAmount >= fullAmount) {
-                    localAmount -= fullAmount;
-                    level = lots.get(currentLot + 1);
-                } else {
-                    level += (localAmount / (double) holes.get(currentLot));
-                    localAmount = 0.0;
-                }
-                currentLot++;
-            }
-        }
-        return level;
-    }
-
-    public static double computeBound(double average,
-            double n) {
-        double bound;
-        double hoeffdingBound;
-        double chernoffBound;
-        if (n == 0.0) { 
-            bound = 1.0;
-        } else {
-            hoeffdingBound = Math.sqrt((1.0 / (2.0 * n))
-                    * ln_2_div_confidence);
-            if (average >= (1.0 / 6.0)) {
-                bound = hoeffdingBound;
-            } else {
-                chernoffBound = ((3.0 * ln_2_div_confidence) + (Math.sqrt((9.0 * square_ln_2_div_confianza)
-                        + (12.0 * n * average * ln_2_div_confidence)))) / (2.0 * n);
-                bound = Math.min(Math.min(chernoffBound, hoeffdingBound), 1.0);
-            }
-        }
-        return bound;
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/trees/iadem/IademGaussianNumericAttributeClassObserver.java b/moa/src/main/java/moa/classifiers/trees/iadem/IademGaussianNumericAttributeClassObserver.java
deleted file mode 100644
index c2059e3ca..000000000
--- a/moa/src/main/java/moa/classifiers/trees/iadem/IademGaussianNumericAttributeClassObserver.java
+++ /dev/null
@@ -1,223 +0,0 @@
-/*
- *    IademGaussianNumericAttributeClassObserver.java
- *
- *    @author Isvani Frias-Blanco
- * 
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-package moa.classifiers.trees.iadem;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-
-import moa.classifiers.core.attributeclassobservers.GaussianNumericAttributeClassObserver;
-import moa.core.AutoExpandVector;
-import moa.core.DoubleVector;
-import moa.core.GaussianEstimator;
-import weka.core.Utils;
-
-public class IademGaussianNumericAttributeClassObserver
-        extends GaussianNumericAttributeClassObserver
-        implements IademNumericAttributeObserver {
-
-    private static final long serialVersionUID = 1L;
-    private int valueCount = 0;
-    protected DoubleVector classDist = new DoubleVector();
-
-    public IademGaussianNumericAttributeClassObserver() {
-        super();
-    }
-
-    public IademGaussianNumericAttributeClassObserver(int maxTuples) {
-        super();
-        this.numBinsOption.setValue(maxTuples);
-    }
-
-    @Override
-    public void addValue(double attValue, int classValue, double weight) {
-        if (Utils.isMissingValue(attValue)) {
-        } else {
-            this.valueCount += weight;
-            this.classDist.addToValue(classValue, weight);
-            observeAttributeClass(attValue, classValue, weight);
-        }
-    }
-
-    @Override
-    public long getValueCount() {
-        return this.valueCount;
-    }
-
-    @Override
-    public long[] getClassDist() {
-        long[] classDistCopy = new long[this.classDist.numValues()];
-        for (int i = 0; i < this.classDist.numValues(); i++) {
-            classDistCopy[i] = (long) this.classDist.getValue(i);
-        }
-        return classDistCopy;
-    }
-
-    @Override
-    public long getNumberOfCutPoints() {
-        return getSplitPointSuggestions().length;
-    }
-
-    @Override
-    public long[] getLeftClassDist(double cutValue) {
-        long[] lhsDist = new long[this.classDist.numValues()];
-        Arrays.fill(lhsDist, 0);
-        for (int i = 0; i < this.attValDistPerClass.size(); i++) {
-            GaussianEstimator estimator = this.attValDistPerClass.get(i);
-            if (estimator != null) {
-                if (cutValue < this.minValueObservedPerClass.getValue(i)) {
-                } else if (cutValue >= this.maxValueObservedPerClass.getValue(i)) {
-                    lhsDist[i] = (long) estimator.getTotalWeightObserved();
-                } else {
-                    double[] weightDist = estimator.estimatedWeight_LessThan_EqualTo_GreaterThan_Value(cutValue);
-                    lhsDist[i] = (long) (weightDist[0] + weightDist[1]);
-                }
-            }
-        }
-        return lhsDist;
-    }
-
-    @Override
-    public double getCut(int index) {
-        return getSplitPointSuggestions()[index];
-    }
-
-    @Override
-    public void computeClassDistProbabilities(double[][][] cut_value_classDist_lower,
-            double[][][] cut_value_classDist_upper,
-            double[][] counts_cut_value,
-            boolean withIntervalEstimates) {
-        ArrayList<Double> cuts = cutPointSuggestion(-1);
-        long[] totalDist = getClassDist();
-        for (int i = 0; i < cuts.size(); i++) {
-            long[] lDist = getLeftClassDist(cuts.get(i)),
-                    rDist = new long[lDist.length];
-            long leftTotal = sum(lDist);
-            long total = sum(totalDist);
-            counts_cut_value[i][0] = leftTotal;
-            counts_cut_value[i][1] = total - leftTotal;
-            for (int j = 0; j < totalDist.length; j++) {
-                rDist[j] = totalDist[j] - lDist[j];
-                double leftEst = 0.0;
-                if (counts_cut_value[i][0] != 0) {
-                    leftEst = (double) lDist[j] / counts_cut_value[i][0];
-                }
-                double leftError = 0.0;
-                if (withIntervalEstimates) {
-                    leftError = IademCommonProcedures.getIADEM_HoeffdingBound(leftEst, counts_cut_value[i][0]);
-                }
-                cut_value_classDist_lower[i][0][j] = Math.max(0.0, leftEst - leftError);
-                cut_value_classDist_upper[i][0][j] = Math.min(1.0, leftEst + leftError);
-                double rightEst = 0.0;
-                if (counts_cut_value[i][1] != 0) {
-                    rightEst = (double) rDist[j] / counts_cut_value[i][1];
-                }
-                double rightError = 0.0;
-                if (withIntervalEstimates) {
-                    rightError = IademCommonProcedures.getIADEM_HoeffdingBound(rightEst, counts_cut_value[i][1]);
-                }
-                cut_value_classDist_lower[i][1][j] = Math.max(0.0, rightEst - rightError);
-                cut_value_classDist_upper[i][1][j] = Math.min(1.0, rightEst + rightError);
-            }
-        }
-    }
-
-    protected long sum(long[] arr) {
-        long count = 0;
-        for (int i = 0; i < arr.length; i++) {
-            count += arr[i];
-        }
-        return count;
-    }
-
-    @Override
-    public ArrayList<Double> cutPointSuggestion(int total) {
-        ArrayList<Double> cuts = new ArrayList<Double>();
-        double[] arr = getSplitPointSuggestions();
-        for (int i = 0; i < arr.length; i++) {
-            cuts.add(arr[i]);
-        }
-        return cuts;
-    }
-
-    @Override
-    public ArrayList<Double[]> computeConditionalProbPerBin(ArrayList<Double> cuts) {
-        ArrayList<Double[]> probClassDistPerCut = new ArrayList<Double[]>();
-        long total = getValueCount();
-        for (Double currentCut : cuts) {
-            long[] numInstances = getLeftClassDist(currentCut);
-            Double[] prob = new Double[numInstances.length];
-            for (int j = 0; j < prob.length; j++) {
-                prob[j] = (double) numInstances[j] / total;
-            }
-            probClassDistPerCut.add(prob);
-        }
-        return probClassDistPerCut;
-    }
-
-    @Override
-    public double[] computeConditionalProb(ArrayList<Double> cuts, double cutValue) {
-        double[] conditionalProbability = new double[this.attValDistPerClass.size()];
-        for (int i = 0; i < this.attValDistPerClass.size(); i++) {
-            conditionalProbability[i] = probabilityOfAttributeValueGivenClass(cutValue, i);
-        }
-        return conditionalProbability;
-    }
-
-    @Override
-    public void reset() {
-        this.minValueObservedPerClass = new DoubleVector();
-        this.maxValueObservedPerClass = new DoubleVector();
-        this.attValDistPerClass = new AutoExpandVector<GaussianEstimator>();
-        this.valueCount = 0;
-        this.classDist = new DoubleVector();
-    }
-
-    //***********************************************************************
-    // probably deprecated
-    @Override
-    public long getMaxOfValues() {
-        return this.numBinsOption.getValue();
-    }
-
-    @Override
-    public IademNumericAttributeObserver getCopy() {
-        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-    }
-
-    @Override
-    public void setMaxBins(int numberOfBins) {
-        this.numBinsOption.setValue(numberOfBins);
-    }
-
-    @Override
-    public void computeClassDist(double[][][] cutClassDist) {
-        ArrayList<Double> cuts = cutPointSuggestion(-1);
-        long[] totalDist = getClassDist();
-        for (int i = 0; i < cuts.size(); i++) {
-            long[] lDist = getLeftClassDist(cuts.get(i)),
-                    rDist = new long[lDist.length];
-            for (int j = 0; j < totalDist.length; j++) {
-                rDist[j] = totalDist[j] - lDist[j];
-                cutClassDist[i][0][j] = lDist[j];
-                cutClassDist[i][1][j] = rDist[j];
-            }
-        }
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/trees/iadem/IademGreenwaldKhannaNumericAttributeClassObserver.java b/moa/src/main/java/moa/classifiers/trees/iadem/IademGreenwaldKhannaNumericAttributeClassObserver.java
deleted file mode 100644
index f76306222..000000000
--- a/moa/src/main/java/moa/classifiers/trees/iadem/IademGreenwaldKhannaNumericAttributeClassObserver.java
+++ /dev/null
@@ -1,262 +0,0 @@
-/*
- *    IademGreenwaldKhannaNumericAttributeClassObserver.java
- *
- *    @author Isvani Frias-Blanco
- * 
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.classifiers.trees.iadem;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-
-import moa.classifiers.core.attributeclassobservers.GreenwaldKhannaNumericAttributeClassObserver;
-import moa.core.AutoExpandVector;
-import moa.core.GreenwaldKhannaQuantileSummary;
-import weka.core.Utils;
-
-public class IademGreenwaldKhannaNumericAttributeClassObserver extends GreenwaldKhannaNumericAttributeClassObserver implements IademNumericAttributeObserver {
-    private static final long serialVersionUID = 1L;
-
-    public IademGreenwaldKhannaNumericAttributeClassObserver() {
-        super();
-    }
-    
-    public IademGreenwaldKhannaNumericAttributeClassObserver(int maxTuples) {
-        super();
-        this.numTuplesOption.setValue(maxTuples);
-    }
-
-    @Override
-    public void observeAttributeClass(double attVal, int classVal, double weight) {
-        if (Utils.isMissingValue(attVal)) {
-        } else {
-            IademGreenwaldKhannaQuantileSummary valDist = (IademGreenwaldKhannaQuantileSummary) this.attValDistPerClass.get(classVal);
-            if (valDist == null) {
-                valDist = new IademGreenwaldKhannaQuantileSummary(this.numTuplesOption.getValue());
-                this.attValDistPerClass.set(classVal, valDist);
-            }
-            // TODO: not taking weight into account
-            valDist.insert(attVal);
-        }
-    }
-
-    @Override
-    public double probabilityOfAttributeValueGivenClass(double attVal, int classVal) {
-        IademGreenwaldKhannaQuantileSummary obs = (IademGreenwaldKhannaQuantileSummary) this.attValDistPerClass.get(classVal);
-        if (obs == null) {
-            return 0.0;
-        } else {
-            int index = obs.findIndexOfTupleGreaterThan(attVal);
-            double total = obs.getTotalCount();
-            double partial = obs.maxNumberOfObservation(index);
-            return total != 0 ? partial / total : 0.0;
-        }
-    }
-
-    @Override
-    public long getMaxOfValues() {
-        return this.numTuplesOption.getValue();
-    }
-
-    @Override
-    public void addValue(double attValue, int classValue, double weight) {
-        observeAttributeClass(attValue, classValue, weight);
-    }
-
-    @Override
-    public long getValueCount() {
-        int totalCount = 0;
-        for (GreenwaldKhannaQuantileSummary qs : this.attValDistPerClass) {
-            if (qs != null) {
-                totalCount += qs.getTotalCount();
-            }
-        }
-        return totalCount;
-    }
-
-    @Override
-    public long[] getClassDist() {
-        long[] classDist = new long[this.attValDistPerClass.size()];
-        for (int i = 0; i < this.attValDistPerClass.size(); i++) {
-            GreenwaldKhannaQuantileSummary qs = this.attValDistPerClass.get(i);
-            if (qs != null) {
-                classDist[i] = qs.getTotalCount();
-            } else {
-                classDist[i] = 0;
-            }
-        }
-        return classDist;
-    }
-
-    @Override
-    public long getNumberOfCutPoints() {
-        int numberOfCutPoints = 0;
-        for (GreenwaldKhannaQuantileSummary qs : this.attValDistPerClass) {
-            if (qs != null) {
-                numberOfCutPoints += qs.getSuggestedCutpoints().length;
-            }
-        }
-        return numberOfCutPoints;
-    }
-
-    @Override
-    public long[] getLeftClassDist(double cut) {
-        long[] lhsDist = new long[this.attValDistPerClass.size()];
-        Arrays.fill(lhsDist, 0);
-        for (int i = 0; i < this.attValDistPerClass.size(); i++) {
-            GreenwaldKhannaQuantileSummary estimator = this.attValDistPerClass.get(i);
-            if (estimator != null) {
-                long countBelow = estimator.getCountBelow(cut);
-                lhsDist[i] += countBelow;
-            }
-        }
-        return lhsDist;
-    }
-
-    @Override
-    public double getCut(int cutIndex) {
-        int currentCut = cutIndex;
-        for (GreenwaldKhannaQuantileSummary qs : this.attValDistPerClass) {
-            if (qs != null) {
-                double[] cuts = qs.getSuggestedCutpoints();
-                if (currentCut < cuts.length) {
-                    return cuts[currentCut];
-                }
-                currentCut -= cuts.length;
-            }
-        }
-        return Double.NaN;
-    }
-
-    @Override
-    public void computeClassDistProbabilities(double[][][] cut_value_classDist_lower, 
-            double[][][] cut_value_classDist_upper, 
-            double[][] counts_cut_value,
-            boolean withIntervalEstimates) {
-        ArrayList<Double> cuts = cutPointSuggestion(-1);
-        long [] totalDist = getClassDist();
-        for (int i = 0; i < cuts.size(); i++) {
-            long [] lDist = getLeftClassDist(cuts.get(i)),
-                    rDist = new long[lDist.length];
-            long totalIzq = sum(lDist);
-            long total = sum(totalDist);
-            counts_cut_value[i][0] = totalIzq;
-            counts_cut_value[i][1] = total - totalIzq;
-            for (int j = 0; j < totalDist.length; j++) {
-                rDist[j] = totalDist[j] - lDist[j];
-                double lEst = 0.0;
-                if (counts_cut_value[i][0] != 0) {
-                    lEst = (double) lDist[j] / counts_cut_value[i][0];
-                }
-                double lError = 0.0;
-                if (withIntervalEstimates) {
-                    lError = IademCommonProcedures.getIADEM_HoeffdingBound(lEst, counts_cut_value[i][0]);
-                }
-                cut_value_classDist_lower[i][0][j] = Math.max(0.0, lEst - lError);
-                cut_value_classDist_upper[i][0][j] = Math.min(1.0, lEst + lError);
-                
-                double rEst = 0.0;
-                if (counts_cut_value[i][1] != 0) {
-                    rEst = (double) rDist[j] / counts_cut_value[i][1];
-                }
-                double rightError = 0.0;
-                if (withIntervalEstimates) {
-                    rightError = IademCommonProcedures.getIADEM_HoeffdingBound(rEst, counts_cut_value[i][1]);
-                }
-                cut_value_classDist_lower[i][1][j] = Math.max(0.0, rEst - rightError);
-                cut_value_classDist_upper[i][1][j] = Math.min(1.0, rEst + rightError);
-            }
-        }
-    }
-    
-    protected long sum(long []arr) {
-        long counter = 0;
-        for (int i = 0; i < arr.length; i++) {
-            counter += arr[i];
-        }
-        return counter;
-    }
-
-    @Override
-    public ArrayList<Double> cutPointSuggestion(int numCortes) {
-        ArrayList<Double> cuts = new ArrayList<Double>();
-        for (GreenwaldKhannaQuantileSummary qs : this.attValDistPerClass) {
-            if (qs != null) {
-                double[] newCuts = qs.getSuggestedCutpoints();
-                for (double valor : newCuts) {
-                    cuts.add(valor);
-                }
-            }
-        }
-        return cuts;
-    }
-
-    @Override
-    public ArrayList<Double[]> computeConditionalProbPerBin(ArrayList<Double> cuts) {
-        ArrayList<Double []> prob = new ArrayList<Double []>();
-        long total = getValueCount();
-        for (Double currentCut : cuts) {
-            long[] numExp = getLeftClassDist(currentCut);
-            Double [] tmpProb = new Double[numExp.length];
-            for (int j = 0; j < tmpProb.length; j++) {
-                tmpProb[j] = (double) numExp[j] / total;
-            }
-            prob.add(tmpProb);
-        }
-        return prob;
-    }
-
-    @Override
-    public double[] computeConditionalProb(ArrayList<Double> cortes, double valor) {
-        double [] probabilidadCondicional = new double[this.attValDistPerClass.size()];
-        for (int i = 0; i < this.attValDistPerClass.size(); i++) {
-            probabilidadCondicional[i] = probabilityOfAttributeValueGivenClass(valor, i);
-        }
-        return probabilidadCondicional;
-    }
-
-    @Override
-    public IademNumericAttributeObserver getCopy() {
-        throw new UnsupportedOperationException("Not supported yet."); 
-    }
-
-    @Override
-    public void reset() {
-        this.attValDistPerClass = new AutoExpandVector<GreenwaldKhannaQuantileSummary>();
-    }
-    
-    @Override
-    public void setMaxBins(int numTuples) {
-        this.numTuplesOption.setValue(numTuples);
-    }
-
-    @Override
-    public void computeClassDist(double[][][] cutClassDist) {
-        ArrayList<Double> cuts = cutPointSuggestion(-1);
-        long [] totalDist = getClassDist();
-        for (int i = 0; i < cuts.size(); i++) {
-            long [] lDist = getLeftClassDist(cuts.get(i)),
-                    rDist = new long[lDist.length];
-            for (int j = 0; j < totalDist.length; j++) {
-                rDist[j] = totalDist[j] - lDist[j];
-                
-                cutClassDist[i][0][j] = lDist[j];
-                cutClassDist[i][1][j] = rDist[j];
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/trees/iadem/IademNumericAttributeObserver.java b/moa/src/main/java/moa/classifiers/trees/iadem/IademNumericAttributeObserver.java
deleted file mode 100644
index fd5ecbde9..000000000
--- a/moa/src/main/java/moa/classifiers/trees/iadem/IademNumericAttributeObserver.java
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- *    IademNumericAttributeObserver.java
- *
- *    @author Isvani Frias-Blanco
- * 
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.classifiers.trees.iadem;
-
-import java.util.ArrayList;
-
-import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
-
-public interface IademNumericAttributeObserver extends AttributeClassObserver {
-    
-    public long getMaxOfValues();
-    
-    public void addValue(double attValue, int classValue, double weight);
-    
-    public long getValueCount();
-    
-    public long[] getClassDist();
-    
-    public long getNumberOfCutPoints();
-    
-    public long[] getLeftClassDist(double cut);
-    
-    public double getCut(int index);
-    
-    public void computeClassDistProbabilities(double[][][] inf_p_corte_valor_z,
-            double[][][] sup_p_corte_valor_z,
-            double[][] n_corte_valor,
-            boolean withIntervalEstimates);
-    
-    public void computeClassDist(double[][][] cutClassDist);
-    
-    public ArrayList<Double> cutPointSuggestion(int numCortes);
-    
-    public ArrayList<Double[]> computeConditionalProbPerBin(ArrayList<Double> cuts);
-    
-    public double[] computeConditionalProb(ArrayList<Double> cuts, double value);
-
-    public void reset();
-
-    public void setMaxBins(int numIntervalos);
-    
-    @Deprecated
-    public IademNumericAttributeObserver getCopy();
-}
diff --git a/moa/src/main/java/moa/classifiers/trees/iadem/IademSplitCriterion.java b/moa/src/main/java/moa/classifiers/trees/iadem/IademSplitCriterion.java
deleted file mode 100644
index 4c5299ac6..000000000
--- a/moa/src/main/java/moa/classifiers/trees/iadem/IademSplitCriterion.java
+++ /dev/null
@@ -1,367 +0,0 @@
-/*
- *    IademSplitMeasure.java
- *
- *    @author Isvani Frias-Blanco
- * 
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.classifiers.trees.iadem;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-
-public final class IademSplitCriterion implements Serializable {
-
-    private static final long serialVersionUID = 1L;
-    private final static int ENTROPY = 0;
-    private final static int ENTROPY_LOG_VAR = 1;
-    private final static int WEIGHTED_ENTROPY_LOG_VAR = 2;
-    private final static int WEIGHTED_ENTROPY = 9;
-    private final static int BETA_1 = 3;
-    private final static int GAMMA_1 = 4;
-    private final static int BETA_2 = 5;
-    private final static int GAMMA_2 = 6;
-    private final static int BETA_4 = 7;
-    private final static int GAMMA_4 = 8;
-    private final static int ERROR_GAIN = 10;
-    private final static String ENTROPY_TEXT = "entropy";
-    private final static String ENTROPY_LOG_VAR_TEXT = "entropy_logVar";
-    private final static String WEIGHTED_ENTROPY_LOG_VAR_TEXT = "entropy_logVar+Weight";
-    private final static String WEIGHTED_ENTROPY_TEXT = "entropy+Weight";
-    private final static String BETA_1_TEXT = "beta1";
-    private final static String BETA_2_TEXT = "beta2";
-    private final static String BETA_4_TEXT = "beta4";
-    private final static String GAMMA_1_TEXT = "gamma1";
-    private final static String GAMMA_2_TEXT = "gamma2";
-    private final static String GAMMA_4_TEXT = "gamma4";
-    private final static String ERROR_GAIN_TEXT = "error_gain";
-    private int splitMeasure;
-
-    public IademSplitCriterion() {
-        this.splitMeasure = IademSplitCriterion.ENTROPY;
-    }
-
-    public IademSplitCriterion(String splitMeasure) throws IademException {
-        try {
-            setSplitMeasure(splitMeasure);
-        } catch (IademException e) {
-            throw new IademException("MySplitMeasure", "constructor",
-                    "Measure could not be created" + '\n'
-                    + e.getMessage());
-        }
-    }
-
-    public String getSplitMeasureText() {
-        String splitMeasureText = "";
-        switch (this.splitMeasure) {
-            case IademSplitCriterion.ENTROPY:
-                splitMeasureText = IademSplitCriterion.ENTROPY_TEXT;
-                break;
-            case IademSplitCriterion.ENTROPY_LOG_VAR:
-                splitMeasureText = IademSplitCriterion.ENTROPY_LOG_VAR_TEXT;
-                break;
-            case IademSplitCriterion.WEIGHTED_ENTROPY_LOG_VAR:
-                splitMeasureText = IademSplitCriterion.WEIGHTED_ENTROPY_LOG_VAR_TEXT;
-                break;
-            case IademSplitCriterion.WEIGHTED_ENTROPY:
-                splitMeasureText = IademSplitCriterion.WEIGHTED_ENTROPY_TEXT;
-                break;
-            case IademSplitCriterion.BETA_1:
-                splitMeasureText = IademSplitCriterion.BETA_1_TEXT;
-                break;
-            case IademSplitCriterion.GAMMA_1:
-                splitMeasureText = IademSplitCriterion.GAMMA_1_TEXT;
-                break;
-            case IademSplitCriterion.BETA_2:
-                splitMeasureText = IademSplitCriterion.BETA_2_TEXT;
-                break;
-            case IademSplitCriterion.GAMMA_2:
-                splitMeasureText = IademSplitCriterion.GAMMA_2_TEXT;
-                break;
-            case IademSplitCriterion.BETA_4:
-                splitMeasureText = IademSplitCriterion.BETA_4_TEXT;
-                break;
-            case IademSplitCriterion.GAMMA_4:
-                splitMeasureText = IademSplitCriterion.GAMMA_4_TEXT;
-                break;
-            case IademSplitCriterion.ERROR_GAIN:
-                splitMeasureText = IademSplitCriterion.ERROR_GAIN_TEXT;
-                break;
-        }
-        return splitMeasureText;
-    }
-
-    public void setSplitMeasure(String splitMeasureType) throws IademException {
-        if (splitMeasureType.equals(IademSplitCriterion.ENTROPY_TEXT)) {
-            this.splitMeasure = IademSplitCriterion.ENTROPY;
-        } else if (splitMeasureType.equals(IademSplitCriterion.ENTROPY_LOG_VAR_TEXT)) {
-            splitMeasure = IademSplitCriterion.ENTROPY_LOG_VAR;
-        } else if (splitMeasureType.equals(WEIGHTED_ENTROPY_LOG_VAR_TEXT)) {
-            splitMeasure = IademSplitCriterion.WEIGHTED_ENTROPY_LOG_VAR;
-        } else if (splitMeasureType.equals(IademSplitCriterion.WEIGHTED_ENTROPY_TEXT)) {
-            splitMeasure = IademSplitCriterion.WEIGHTED_ENTROPY;
-        } else if (splitMeasureType.equals(IademSplitCriterion.BETA_1_TEXT)) {
-            splitMeasure = IademSplitCriterion.BETA_1;
-        } else if (splitMeasureType.equals(IademSplitCriterion.GAMMA_1_TEXT)) {
-            splitMeasure = IademSplitCriterion.GAMMA_1;
-        } else if (splitMeasureType.equals(IademSplitCriterion.BETA_2_TEXT)) {
-            splitMeasure = IademSplitCriterion.BETA_2;
-        } else if (splitMeasureType.equals(IademSplitCriterion.GAMMA_2_TEXT)) {
-            splitMeasure = IademSplitCriterion.GAMMA_2;
-        } else if (splitMeasureType.equals(IademSplitCriterion.BETA_4_TEXT)) {
-            splitMeasure = IademSplitCriterion.BETA_4;
-        } else if (splitMeasureType.equals(IademSplitCriterion.GAMMA_4_TEXT)) {
-            splitMeasure = IademSplitCriterion.GAMMA_4;
-        } else if (splitMeasureType.equals(IademSplitCriterion.ERROR_GAIN_TEXT)) {
-            splitMeasure = IademSplitCriterion.ERROR_GAIN;
-        } else {
-            throw new IademException("MySplitMeasure", "setSplitMeasure", "Measure does not exist");
-        }
-    }
-
-    public static ArrayList<String> getSplitMeasureOptions() {
-        ArrayList<String> splitMeasureList = new ArrayList<String>();
-        splitMeasureList.add(IademSplitCriterion.ENTROPY_TEXT);
-        splitMeasureList.add(IademSplitCriterion.ENTROPY_LOG_VAR_TEXT);
-        splitMeasureList.add(IademSplitCriterion.WEIGHTED_ENTROPY_LOG_VAR_TEXT);
-        splitMeasureList.add(IademSplitCriterion.WEIGHTED_ENTROPY_TEXT);
-        splitMeasureList.add(IademSplitCriterion.BETA_1_TEXT);
-        splitMeasureList.add(IademSplitCriterion.GAMMA_1_TEXT);
-        splitMeasureList.add(IademSplitCriterion.BETA_2_TEXT);
-        splitMeasureList.add(IademSplitCriterion.GAMMA_2_TEXT);
-        splitMeasureList.add(IademSplitCriterion.BETA_4_TEXT);
-        splitMeasureList.add(IademSplitCriterion.GAMMA_4_TEXT);
-
-        return splitMeasureList;
-    }
-
-    public static String getDefaultSplitMeasure() {
-        return IademSplitCriterion.ENTROPY_TEXT;
-    }
-
-    public double doMeasure(ArrayList<Double> vector) throws IademException {
-        double logBase; // logarithm base for entropy
-        logBase = (double) vector.size();
-
-        double measure = 0.0;
-        switch (this.splitMeasure) {
-            case IademSplitCriterion.ENTROPY: {
-                logBase = vector.size();
-                if (logBase > 1.0) {
-                    double n = 0.0;
-                    for (Double elem : vector) {
-                        double tmpValue = elem;
-                        if (tmpValue > 0.0) {
-                            n += tmpValue;
-                        } else if (tmpValue < 0.0) {
-                            throw new IademException("MySplitMeasure", "doMeasure",
-                                    "All values must be positive");
-                        }
-                    }
-
-                    if (n == 0.0) {
-                        throw new IademException("MySplitMeasure", "doMeasure",
-                                "Vector must be different from 0.0");
-                    } else {
-                        double a_i = 0.0;
-                        double sum = 0.0;
-
-                        for (int i = 0; i < vector.size(); i++) {
-                            a_i = vector.get(i);
-                            if (a_i > 0.0) {
-                                sum += (a_i * IademCommonProcedures.log(logBase, a_i));
-                            }
-                        }
-                        measure = -((1 / n) * (sum - (n * IademCommonProcedures.log(logBase, n))));
-                    }
-                } else if (logBase == 1.0) {
-                    measure = 0.0;
-                }
-            }
-            break;
-            case ENTROPY_LOG_VAR: {
-                if (logBase > 1.0) {
-                    double n = 0.0;
-                    for (Double elem : vector) {
-                        double tmpValue = elem;
-                        if (tmpValue > 0.0) {
-                            n += tmpValue;
-                        } else if (tmpValue < 0.0) {
-                            throw new IademException("MySplitMeasure", "doMeasure",
-                                    "All values must be positive");
-                        }
-                    }
-
-                    if (n == 0.0) {
-                        throw new IademException("MySplitMeasure", "doMeasure",
-                                "Vector must be different from 0.0");
-                    } else {
-                        double a_i = 0.0;
-                        double sum = 0.0;
-
-                        for (Double elem : vector) {
-                            a_i = elem;
-                            if (a_i > 0.0) {
-                                sum += a_i * IademCommonProcedures.log(logBase, a_i);
-                            }
-                        }
-                        measure = -((1 / n) * (sum - (n * IademCommonProcedures.log(logBase, n))));
-                    }
-                } else if (logBase == 1.0) {
-                    measure = 0.0;
-                }
-            }
-            break;
-
-            case WEIGHTED_ENTROPY: {
-                if (logBase > 1.0) {
-                    double n = 0.0;
-                    for (int i = 0; i < vector.size(); i++) {
-                        double tmpValue = vector.get(i);
-                        if (tmpValue > 0.0) {
-                            n += tmpValue;
-                        } else if (tmpValue < 0.0) {
-                            throw new IademException("MySplitMeasure", "doMeasure",
-                                    "All values must be positive");
-                        }
-                    }
-
-                    if (n == 0.0) {
-                        measure = 0.0;
-                    } else {
-                        double a_i = 0.0;
-                        double sum = 0.0;
-
-                        for (int i = 0; i < vector.size(); i++) {
-                            a_i = vector.get(i);
-                            if (a_i > 0.0) {
-                                sum += (a_i * IademCommonProcedures.log(logBase, a_i));
-                            }
-                        }
-                        measure = -((1 / n) * (sum - (n * IademCommonProcedures.log(logBase, n))));
-                    }
-                } else if (logBase == 1.0) {
-                    measure = 0.0;
-                }
-            }
-            break;
-
-            case WEIGHTED_ENTROPY_LOG_VAR: {
-                logBase = vector.size();
-                if (logBase > 1.0) {
-                    double n = 0.0;
-                    for (int i = 0; i < vector.size(); i++) {
-                        double tmpValue = vector.get(i);
-                        if (tmpValue > 0.0) {
-                            n += tmpValue;
-                        } else if (tmpValue < 0.0) {
-                            throw new IademException("MySplitMeasure", "doMeasure",
-                                    "All values must be positive");
-                        }
-                    }
-
-                    if (n == 0.0) {
-                        measure = 0.0;
-                    } else {
-                        double a_i = 0.0;
-                        double sum = 0.0;
-
-                        for (Double elem : vector) {
-                            a_i = elem;
-                            if (a_i > 0.0) {
-                                sum += (a_i * IademCommonProcedures.log(logBase, a_i));
-                            }
-                        }
-                        measure = -((1 / n) * (sum - (n * IademCommonProcedures.log(logBase, n))));
-                    }
-                } else if (logBase == 1.0) {
-                    measure = 0.0;
-                }
-            }
-            break;
-
-            case BETA_1: {
-                double mayor = 0.0;
-                for (Double elem : vector) {
-                    mayor = Math.max(mayor, elem);
-                }
-                measure = 1.0 - mayor;
-            }
-            break;
-
-            case GAMMA_1: {
-                double max = 0.0;
-                for (Double elem : vector) {
-                    max = Math.max(max, elem);
-                }
-                measure = 1.0 - max;
-                measure = Math.sqrt(2.0 * measure);
-            }
-            break;
-
-            case BETA_2: {
-                double mayor = 0.0;
-                double sum = 0.0;
-                for (Double elem : vector) {
-                    double num = elem;
-                    mayor = Math.max(mayor, num);
-                    sum += (num * num);
-                }
-                measure = 1.0 - mayor + (mayor * mayor) - sum;
-            }
-            break;
-
-            case GAMMA_2: {
-                double max = 0.0;
-                double sum = 0.0;
-                for (Double elem : vector) {
-                    double num = elem;
-                    max = Math.max(max, num);
-                    sum += (num * num);
-                }
-                measure = 1.0 - max + (max * max) - sum;
-                measure = Math.sqrt(4.0 * measure);
-            }
-            break;
-
-            case BETA_4: {
-                double sum = 0.0;
-                for (Double elem : vector) {
-                    double num = elem;
-                    sum += (num * num);
-                }
-                measure = 1.0 - sum;
-            }
-            break;
-
-            case GAMMA_4: {
-                double sum = 0.0;
-                for (Double elem : vector) {
-                    double num = elem;
-                    sum += (num * num);
-                }
-                measure = 1.0 - sum;
-                measure = Math.sqrt(2.0 * measure);
-            }
-            break;
-        }
-        if (measure < 0.0) {
-            throw new IademException("MySplitMeasure", "doMeasure",
-                    "Measure could not be calculated");
-        }
-        return measure;
-    }
-}
diff --git a/moa/src/main/java/moa/classifiers/trees/iadem/IademVFMLNumericAttributeClassObserver.java b/moa/src/main/java/moa/classifiers/trees/iadem/IademVFMLNumericAttributeClassObserver.java
deleted file mode 100644
index 37c94c997..000000000
--- a/moa/src/main/java/moa/classifiers/trees/iadem/IademVFMLNumericAttributeClassObserver.java
+++ /dev/null
@@ -1,651 +0,0 @@
-/*
- *    IademVFMLNumericAttributeClassObserver.java
- *
- *    @author Isvani Frias-Blanco
- * 
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-package moa.classifiers.trees.iadem;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.VFMLNumericAttributeClassObserver;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.core.DoubleVector;
-import moa.core.ObjectRepository;
-import moa.tasks.TaskMonitor;
-import weka.core.Utils;
-
-public class IademVFMLNumericAttributeClassObserver extends VFMLNumericAttributeClassObserver
-        implements IademNumericAttributeObserver, AttributeClassObserver {
-
-    private static final long serialVersionUID = 1L;
-
-    public IademVFMLNumericAttributeClassObserver() {
-        super();
-        this.numBinsOption.setValue(500);
-    }
-
-    public IademVFMLNumericAttributeClassObserver(int maxBins) {
-        super();
-        this.numBinsOption.setValue(maxBins);
-    }
-
-    @Override
-    public void setMaxBins(int numBins) {
-        this.numBinsOption.setValue(numBins);
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-    }
-
-    @Override
-    public void computeClassDist(double[][][] cutClassDist) {
-        int classes = this.classDist.numValues();
-        Bin element = binList.get(0);
-
-        double numLeftInst = element.classWeights.sumOfValues();
-        double numRightInst = this.classDist.sumOfValues() - numLeftInst;
-
-        double[] leftClassDist = new double[classes];
-        double[] rightClassDist = new double[classes];
-        for (int i = 0; i < classes; i++) {
-            leftClassDist[i] = element.classWeights.getValue(i);
-            rightClassDist[i] = this.classDist.getValue(i) - leftClassDist[i];
-
-            cutClassDist[0][0][i] = leftClassDist[i];
-            cutClassDist[0][1][i] = rightClassDist[i];
-        }
-
-        for (int i = 1; i < this.binList.size() - 1; i++) {
-            element = this.binList.get(i);
-
-            double numChangingInst = element.classWeights.sumOfValues();
-            numLeftInst += numChangingInst;
-            numRightInst -= numChangingInst;
-
-            for (int j = 0; j < classes; j++) {
-                double changingClassDist = element.classWeights.getValue(j);
-                leftClassDist[j] += changingClassDist;
-                rightClassDist[j] -= changingClassDist;
-
-                cutClassDist[i][0][j] = leftClassDist[j];
-
-                cutClassDist[i][1][j] = rightClassDist[j];
-            }
-        }
-    }
-
-    protected class Bin implements Serializable {
-
-        private static final long serialVersionUID = 1L;
-        public double lowerBound, upperBound;
-        public DoubleVector classWeights = new DoubleVector();
-        public int boundaryClass;
-        public double boundaryWeight;
-    }
-    protected List<Bin> binList = new ArrayList<Bin>();
-    protected DoubleVector classDist = new DoubleVector();
-
-    @Override
-    public void observeAttributeClass(double attVal, int classVal, double weight) {
-        if (Utils.isMissingValue(attVal)) {
-        } else {
-            if (this.binList.size() < 1) {
-                // create the first bin
-                Bin newBin = new Bin();
-                newBin.classWeights.addToValue(classVal, weight);
-                newBin.boundaryClass = classVal;
-                newBin.boundaryWeight = weight;
-                newBin.upperBound = attVal;
-                newBin.lowerBound = attVal;
-                this.binList.add(newBin);
-            } else {
-                // find bin containing new example with binary search
-                int index = -1;
-                boolean found = false;
-                int min = 0;
-                int max = this.binList.size() - 1;
-                index = 0;
-                while ((min <= max) && !found) {
-                    int i = (min + max) / 2;
-                    Bin bin = this.binList.get(i);
-                    if (((attVal >= bin.lowerBound) && (attVal < bin.upperBound))
-                            || ((i == this.binList.size() - 1)
-                            && (attVal >= bin.lowerBound) && (attVal <= bin.upperBound))) {
-                        found = true;
-                        index = i;
-                    } else if (attVal < bin.lowerBound) {
-                        max = i - 1;
-                    } else {
-                        min = i + 1;
-                    }
-                }
-                boolean first = false;
-                boolean last = false;
-                if (!found) {
-                    // determine if it is before or after the existing range
-                    Bin bin = this.binList.get(0);
-                    if (bin.lowerBound > attVal) {
-                        // go before the first bin
-                        index = 0;
-                        first = true;
-                    } else {
-                        // if we haven't found it yet value must be > last bins
-                        // upperBound
-                        index = this.binList.size() - 1;
-                        last = true;
-                    }
-                }
-                Bin bin = this.binList.get(index); // VLIndex(ct->bins, index);
-                if ((bin.lowerBound == attVal)
-                        || (this.binList.size() >= this.numBinsOption.getValue())) {// Option.getValue())
-                    // {//1000)
-                    // {
-                    // if this is the exact same boundary and class as the bin
-                    // boundary or we aren't adding new bins any more then
-                    // increment
-                    // boundary counts
-                    bin.classWeights.addToValue(classVal, weight);
-                    if ((bin.boundaryClass == classVal)
-                            && (bin.lowerBound == attVal)) {
-                        // if it is also the same class then special case it
-                        bin.boundaryWeight += weight;
-                    }
-                } else {
-                    // create a new bin
-                    Bin newBin = new Bin();
-                    newBin.classWeights.addToValue(classVal, weight);
-                    newBin.boundaryWeight = weight;
-                    newBin.boundaryClass = classVal;
-                    newBin.upperBound = bin.upperBound;
-                    newBin.lowerBound = attVal;
-
-                    double percent = 0.0;
-                    // estimate initial counts with a linear interpolation
-                    if (!((bin.upperBound - bin.lowerBound == 0) || last || first)) {
-                        percent = 1.0 - ((attVal - bin.lowerBound) / (bin.upperBound - bin.lowerBound));
-                    }
-
-                    // take out the boundry points, they stay with the old bin
-                    bin.classWeights.addToValue(bin.boundaryClass,
-                            -bin.boundaryWeight);
-                    DoubleVector weightToShift = new DoubleVector(
-                            bin.classWeights);
-
-                    // make this a vector of integers
-                    weightToShift.scaleValues(percent);
-                    for (int i = 0; i < weightToShift.numValues(); i++) {
-                        long tmp = Math.round(weightToShift.getValue(i));
-                        weightToShift.setValue(i, tmp);
-                    }
-
-                    newBin.classWeights.addValues(weightToShift);
-                    bin.classWeights.subtractValues(weightToShift);
-                    // put the boundry examples back in
-                    bin.classWeights.addToValue(bin.boundaryClass,
-                            bin.boundaryWeight);
-
-                    // insert the new bin in the right place
-                    if (last) {
-                        bin.upperBound = attVal;
-                        newBin.upperBound = attVal;
-                        this.binList.add(newBin);
-                    } else if (first) {
-                        newBin.upperBound = bin.lowerBound;
-                        this.binList.add(0, newBin);
-                    } else {
-                        newBin.upperBound = bin.upperBound;
-                        bin.upperBound = attVal;
-                        this.binList.add(index + 1, newBin);
-                    }
-                }
-            }
-        }
-    }
-
-    @Override
-    public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(
-            SplitCriterion criterion, double[] preSplitDist, int attIndex,
-            boolean binaryOnly) {
-        AttributeSplitSuggestion bestSuggestion = null;
-        DoubleVector rightDist = new DoubleVector();
-        for (Bin bin : this.binList) {
-            rightDist.addValues(bin.classWeights);
-        }
-        DoubleVector leftDist = new DoubleVector();
-        for (Bin bin : this.binList) {
-            leftDist.addValues(bin.classWeights);
-            rightDist.subtractValues(bin.classWeights);
-            double[][] postSplitDists = new double[][]{
-                leftDist.getArrayCopy(), rightDist.getArrayCopy()};
-            double merit = criterion.getMeritOfSplit(preSplitDist,
-                    postSplitDists);
-            if ((bestSuggestion == null) || (merit > bestSuggestion.merit)) {
-                bestSuggestion = new AttributeSplitSuggestion(
-                        new IademNumericAttributeBinaryTest(attIndex,
-                                bin.upperBound, false), postSplitDists, merit);
-            }
-        }
-        return bestSuggestion;
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    public double probabilityOfAttributeValueGivenClass(double attVal,
-            int classVal) {
-        // compute the conditional probability
-        double attValClassValCount = 0.0;
-        double totalClassValCount = 0.0;
-        for (int i = 0; i < binList.size(); i++) {
-            if (attVal == this.binList.get(i).lowerBound
-                    && classVal == this.binList.get(i).boundaryClass) {
-                // attribute and class values are in a boundary
-                attValClassValCount = this.binList.get(i).boundaryWeight;
-            } else if (((attVal >= this.binList.get(i).lowerBound) && (attVal < this.binList.get(i).upperBound))
-                    || ((i == this.binList.size() - 1)
-                    && (attVal >= this.binList.get(i).lowerBound) && (attVal <= this.binList.get(i).upperBound))) {
-                // attribute value is inside a bin
-                attValClassValCount = this.binList.get(i).classWeights.getValue(classVal);
-            }
-            totalClassValCount += binList.get(i).classWeights.getValue(classVal);
-        }
-        return totalClassValCount != 0 ? attValClassValCount / totalClassValCount : 0.0;
-    }
-
-    public void forgetAttributeClass(double attVal, int classVal, double weight) {
-        if (Utils.isMissingValue(attVal)) {
-        } else if (this.classDist.sumOfValues() > 0) {
-            this.classDist.addToValue(classVal, -weight);
-
-            int i, index;
-            boolean found = false;
-            int min, max;
-            Bin bin;
-            int numBins = binList.size();
-            // Find the bin holding the example to be forgotten
-            index = 0;
-            min = 0;
-            max = numBins - 1;
-
-            // Binary search
-            while (min <= max && !found) {
-                i = (min + max) / 2;
-                bin = binList.get(i);
-                if ((attVal >= bin.lowerBound && attVal < bin.upperBound)
-                        || ((i == numBins - 1) && (attVal >= bin.lowerBound)
-                        && (attVal <= bin.upperBound))) {
-                    found = true;
-                    index = i;
-                } else if (attVal < bin.lowerBound) {
-                    max = i - 1;
-                } else {
-                    min = i + 1;
-                }
-            }
-
-            // Reduce counts
-            if (!found) {
-                //printf("Value %f not found\n", value );
-                //printBins( ct->bins );
-                // HERE UNREPORTED ERROR
-
-                return;
-            }
-
-            bin = binList.get(index);
-            // decrement counts
-            bin.classWeights.addToValue(classVal, -weight);
-            if (bin.classWeights.getValue(classVal) < 0) {
-                bin.classWeights.setValue(classVal, 0);
-            }
-            if (bin.boundaryClass == classVal) {
-                bin.boundaryWeight -= weight;
-            }
-            if (bin.boundaryWeight < 0) {
-                bin.boundaryWeight = 0;
-            }
-
-            // Remove bin
-            if (bin.boundaryWeight == 0 && binList.size() > 0) {
-                int numClasses = bin.classWeights.numValues();
-                if (index != 0) {
-                    int j;
-                    Bin prevBin = binList.get(index - 1);
-                    prevBin.upperBound = bin.upperBound;
-                    // prevBin->exampleCount += bin->exampleCount;
-                    for (j = 0; j < numClasses; j++) {
-                        prevBin.classWeights.addToValue(j, bin.classWeights.getValue(j));
-                    }
-                    binList.remove(index);
-                    bin = binList.get(index - 1);
-                } // Remove first bin
-                else if (binList.size() > 1) {
-                    int j;
-                    Bin newFirstBin = binList.get(1);
-                    Bin oldFirstBin = binList.get(0);
-                    /*
-                     printf( "removing first bin: %f - %f (%f) bc - %ld\n", oldFirstBin->lowerBound,
-                     oldFirstBin->upperBound, oldFirstBin->exampleCount, oldFirstBin->boundryCount);
-                     */
-                    newFirstBin.lowerBound = oldFirstBin.lowerBound;
-                    for (j = 0; j < numClasses; j++) {
-                        newFirstBin.classWeights.addToValue(j, oldFirstBin.classWeights.getValue(j));
-                    }
-                    /*
-                     printf( "new first bin: %f - %f (%f) bc - %ld\n", newFirstBin->lowerBound,
-                     newFirstBin->upperBound, newFirstBin->exampleCount, newFirstBin->boundryCount);
-                     */
-                    binList.remove(0);
-                }
-            }
-        }
-    }
-
-    @Override
-    public void reset() {
-        this.classDist = new DoubleVector();
-        this.binList = new ArrayList<Bin>();
-    }
-
-    @Override
-    public long getValueCount() {
-        return (long) this.classDist.sumOfValues();
-    }
-
-    @Override
-    public long[] getClassDist() {
-        long[] classDistCopy = new long[this.classDist.numValues()];
-        for (int i = 0; i < this.classDist.numValues(); i++) {
-            classDistCopy[i] = (long) this.classDist.getValue(i);
-        }
-        return classDistCopy;
-    }
-
-    @Override
-    public long getNumberOfCutPoints() {
-        return binList.size() - 1;
-    }
-
-    @Override
-    public long[] getLeftClassDist(double corte) {
-        long[] rightDist = new long[this.classDist.numValues()];
-        Arrays.fill(rightDist, 0);
-        for (int i = 0; i < this.binList.size() && corte > this.binList.get(i).upperBound; i++) {
-            for (int j = 0; j < this.binList.get(i).classWeights.numValues(); j++) {
-                rightDist[j] += this.binList.get(i).classWeights.getValue(j);
-            }
-        }
-        return rightDist;
-    }
-
-    @Override
-    public double getCut(int indice) {
-        return binList.get(indice).upperBound;
-    }
-
-    @Override
-    public void computeClassDistProbabilities(double[][][] cut_value_classDist_lower,
-            double[][][] cut_value_classDist_upper,
-            double[][] counts_cut_value,
-            boolean withIntervalEstimates) {
-        int classes = this.classDist.numValues();
-        Bin element = binList.get(0);
-
-        double numLeftInst = element.classWeights.sumOfValues();
-        double numRightInst = this.classDist.sumOfValues() - numLeftInst;
-        counts_cut_value[0][0] = numLeftInst;
-        counts_cut_value[0][1] = numRightInst;
-
-        double[] leftClassDist = new double[classes];
-        double[] rightClassDist = new double[classes];
-        for (int i = 0; i < classes; i++) {
-            leftClassDist[i] = element.classWeights.getValue(i);
-            rightClassDist[i] = this.classDist.getValue(i) - leftClassDist[i];
-
-            double lEstimates = 0.0;
-            if (numLeftInst != 0) {
-                lEstimates = leftClassDist[i] / numLeftInst;
-            }
-            double lError = 0.0;
-            if (withIntervalEstimates) {
-                lError = IademCommonProcedures.getIADEM_HoeffdingBound(lEstimates, numLeftInst);
-            }
-            cut_value_classDist_lower[0][0][i] = Math.max(0.0, lEstimates - lError);
-            cut_value_classDist_upper[0][0][i] = Math.min(1.0, lEstimates + lError);
-
-            double rEstimates = 0.0;
-            if (numRightInst != 0.0) {
-                rEstimates = rightClassDist[i] / numRightInst;
-            }
-            double rError = 0.0;
-            if (withIntervalEstimates) {
-                rError = IademCommonProcedures.getIADEM_HoeffdingBound(rEstimates, numRightInst);
-            }
-            cut_value_classDist_lower[0][1][i] = Math.max(0.0, rEstimates - rError);
-            cut_value_classDist_upper[0][1][i] = Math.min(1.0, rEstimates + rError);
-        }
-
-        for (int i = 1; i < this.binList.size() - 1; i++) {
-            element = this.binList.get(i);
-
-            double numChangingInst = element.classWeights.sumOfValues();
-            numLeftInst += numChangingInst;
-            numRightInst -= numChangingInst;
-            counts_cut_value[i][0] = numLeftInst; // corte i a la izquierda
-            counts_cut_value[i][1] = numRightInst; // corte i a la derecha
-
-            for (int j = 0; j < classes; j++) {
-                double changingClassDist = element.classWeights.getValue(j);
-                leftClassDist[j] += changingClassDist;
-                rightClassDist[j] -= changingClassDist;
-                double lEstimates = 0.0;
-                if (numLeftInst != 0) {
-                    lEstimates = leftClassDist[j] / numLeftInst;
-                }
-                double lError = 0.0;
-                if (withIntervalEstimates) {
-                    lError = IademCommonProcedures.getIADEM_HoeffdingBound(lEstimates, numLeftInst);
-                }
-                cut_value_classDist_lower[i][0][j] = Math.max(0.0, lEstimates - lError);
-                cut_value_classDist_upper[i][0][j] = Math.min(1.0, lEstimates + lError);
-                double rEstimates = 0.0;
-                if (numRightInst != 0.0) {
-                    rEstimates = rightClassDist[j] / numRightInst;
-                }
-                double rError = 0.0;
-                if (withIntervalEstimates) {
-                    rError = IademCommonProcedures.getIADEM_HoeffdingBound(rEstimates, numRightInst);
-                }
-                cut_value_classDist_lower[i][1][j] = Math.max(0.0, rEstimates - rError);
-                cut_value_classDist_upper[i][1][j] = Math.min(1.0, rEstimates + rError);
-            }
-        }
-    }
-
-    @Override
-    public ArrayList<Double> cutPointSuggestion(int numMaxIntervalos) {
-        ArrayList<Double> cutPoint = new ArrayList<Double>();
-        for (int i = 0; i < this.binList.size() - 1; i++) {
-            cutPoint.add(this.binList.get(i).upperBound);
-        }
-        return cutPoint;
-    }
-
-    @Override
-    public ArrayList<Double[]> computeConditionalProbPerBin(ArrayList<Double> cortes) {
-        ArrayList<Double[]> condProb = new ArrayList<Double[]>();
-        int numClasses = classDist.numValues();
-
-        double[] numClassesPerBin = new double[numClasses];
-        Arrays.fill(numClassesPerBin, 0);
-
-        int currentBin = 0;
-        Bin element;
-        for (int j = 0; j < this.binList.size(); j++) {
-            element = this.binList.get(j);
-            double aux = element.upperBound;
-            if ((currentBin == cortes.size()) // last bin
-                    || (aux <= cortes.get(currentBin))) {// keeps in the same bin
-                for (int i = 0; i < numClasses; i++) {
-                    numClassesPerBin[i] += element.classWeights.getValue(i);
-                }
-            } else {// change of bin
-                // store the previous data
-                Double[] probCond_intervalo = new Double[numClasses];
-                for (int i = 0; i < numClasses; i++) {
-                    if (this.classDist.getValue(i) == 0) {
-                        probCond_intervalo[i] = 0.0;
-                    } else {
-                        probCond_intervalo[i] = numClassesPerBin[i]
-                                / this.classDist.getValue(i);
-                    }
-                }
-                condProb.add(probCond_intervalo);
-
-                currentBin++;
-
-                while ((currentBin < cortes.size())
-                        && (aux > cortes.get(currentBin))) {
-                    currentBin++;
-                    condProb.add(null);
-                }
-
-                Arrays.fill(numClassesPerBin, 0);
-                // store data in the last bin
-                for (int i = 0; i < numClasses; i++) {
-                    numClassesPerBin[i] += element.classWeights.getValue(i);
-                }
-            }
-        }
-        // store data in the last bin
-        Double[] probCond_intervalo = new Double[numClasses];
-        for (int i = 0; i < numClasses; i++) {
-            if (this.classDist.getValue(i) == 0) {
-                probCond_intervalo[i] = 0.0;
-            } else {
-                probCond_intervalo[i] = numClassesPerBin[i]
-                        / this.classDist.getValue(i);
-            }
-        }
-        condProb.add(probCond_intervalo);
-
-        return condProb;
-    }
-
-    @Override
-    public double[] computeConditionalProb(ArrayList<Double> cuts, double cutValue) {
-        int numClasses = this.classDist.numValues();
-        double[] instPerClass = new double[numClasses];
-        Arrays.fill(instPerClass, 0);
-
-        int keyPos;
-        if (cutValue <= cuts.get(0)) {
-            keyPos = 0;
-            while (keyPos < this.binList.size()
-                    && this.binList.get(keyPos).upperBound <= cuts.get(0)) {
-                for (int i = 0; i < numClasses; i++) {
-                    instPerClass[i] += this.binList.get(keyPos).classWeights.getValue(i);
-                }
-                keyPos++;
-            }
-        } else if (cutValue > cuts.get(cuts.size() - 1)) {
-            keyPos = this.binList.size() - 1;
-            while (keyPos < this.binList.size()
-                    && this.binList.get(keyPos).upperBound > cuts.get(cuts.size() - 1)) {
-                for (int i = 0; i < numClasses; i++) {
-                    instPerClass[i] += this.binList.get(keyPos).classWeights.getValue(i);
-                }
-                keyPos--;
-            }
-        } else {
-            int currentBin = 1;
-            double lastBin = cuts.get(currentBin);
-            while (cutValue > lastBin) {
-                currentBin++;
-                lastBin = cuts.get(currentBin);
-            }
-
-            double firstBin = cuts.get(currentBin - 1);
-            keyPos = 0;
-            while (keyPos < this.binList.size()
-                    && this.binList.get(keyPos).upperBound <= firstBin) {
-                keyPos++;
-            }
-            while (keyPos < this.binList.size()
-                    && this.binList.get(keyPos).upperBound <= lastBin) {
-                for (int i = 0; i < numClasses; i++) {
-                    instPerClass[i] += this.binList.get(keyPos).classWeights.getValue(i);
-                }
-                keyPos++;
-            }
-        }
-        // if there is no information in this bin...
-        boolean allZero = true;
-        int pos = 0;
-        while ((allZero) && (pos < numClasses)) {
-            if (instPerClass[pos] > 0.0) {
-                allZero = false;
-            }
-            pos++;
-        }
-
-        double[] classVotes = new double[numClasses];
-        if (allZero) {
-            for (int i = 0; i < numClasses; i++) {
-                classVotes[i] = 1.0 / (double) numClasses;
-            }
-        } else {
-            for (int i = 0; i < numClasses; i++) {
-                if (classDist.getValue(i) == 0) {
-                    classVotes[i] = 0.0;
-                } else {
-                    classVotes[i] = instPerClass[i]
-                            / classDist.getValue(i);
-                }
-            }
-        }
-        return classVotes;
-    }
-
-    @Override
-    public void addValue(double attValue, int classValue, double weight) {
-        if (Utils.isMissingValue(attValue)) {
-        } else {
-            this.classDist.addToValue(classValue, weight);
-            observeAttributeClass(attValue, classValue, weight);
-        }
-    }
-
-    @Override
-    public long getMaxOfValues() {
-        return this.numBinsOption.getValue();
-    }
-
-    @Override
-    public IademNumericAttributeObserver getCopy() {
-        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-    }
-}
diff --git a/moa/src/main/java/moa/cluster/CFCluster.java b/moa/src/main/java/moa/cluster/CFCluster.java
index bd6e83b33..7b983557b 100644
--- a/moa/src/main/java/moa/cluster/CFCluster.java
+++ b/moa/src/main/java/moa/cluster/CFCluster.java
@@ -14,16 +14,17 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.cluster;
+
 import java.util.Arrays;
 
 import com.yahoo.labs.samoa.instances.Instance;
 
-/* micro cluster, as defined by Aggarwal et al, On Clustering Massive Data Streams: A Summarization Praradigm 
+/* micro cluster, as defined by Aggarwal et al, On Clustering Massive Data Streams: A Summarization Praradigm
  * in the book Data streams : models and algorithms, by Charu C Aggarwal
  *  @article{
 	title = {Data Streams: Models and Algorithms},
@@ -74,8 +75,9 @@ public abstract class CFCluster extends SphereCluster {
 
 	/**
 	 * Instantiates an empty kernel with the given dimensionality.
-	 * @param dimensions The number of dimensions of the points that can be in
-	 * this kernel.
+	 * 
+	 * @param dimensions The number of dimensions of the points that can be in this
+	 *                   kernel.
 	 */
 	public CFCluster(Instance instance, int dimensions) {
 		this(instance.toDoubleArray(), dimensions);
@@ -89,12 +91,12 @@ protected CFCluster(int dimensions) {
 		Arrays.fill(this.SS, 0.0);
 	}
 
-	public CFCluster(double [] center, int dimensions) {
+	public CFCluster(double[] center, int dimensions) {
 		this.N = 1;
 		this.LS = center;
 		this.SS = new double[dimensions];
 		for (int i = 0; i < SS.length; i++) {
-			SS[i]=Math.pow(center[i], 2);
+			SS[i] = Math.pow(center[i], 2);
 		}
 	}
 
@@ -104,10 +106,10 @@ public CFCluster(CFCluster cluster) {
 		this.SS = Arrays.copyOf(cluster.SS, cluster.SS.length);
 	}
 
-	public void add(CFCluster cluster ) {
+	public void add(CFCluster cluster) {
 		this.N += cluster.N;
-		addVectors( this.LS, cluster.LS );
-		addVectors( this.SS, cluster.SS );
+		addVectors(this.LS, cluster.LS);
+		addVectors(this.SS, cluster.SS);
 	}
 
 	public abstract CFCluster getCF();
@@ -115,59 +117,60 @@ public void add(CFCluster cluster ) {
 	/**
 	 * @return this kernels' center
 	 */
-	 @Override
-	 public double[] getCenter() {
-		 assert (this.N>0);
-		 double res[] = new double[this.LS.length];
-		 for ( int i = 0; i < res.length; i++ ) {
-			 res[i] = this.LS[i] / N;
-		 }
-		 return res;
-	 }
-
-
-	 @Override
-	 public abstract double getInclusionProbability(Instance instance);
-
-	 /**
-	  * See interface <code>Cluster</code>
-	  * @return The radius of the cluster.
-	  */
-	 @Override
-	 public abstract double getRadius();
-
-	 /**
-	  * See interface <code>Cluster</code>
-	  * @return The weight.
-	  * @see Cluster#getWeight() 
-	  */
-	 @Override
-	 public double getWeight() {
-		 return N;
-	 }
-
-	 public void setN(double N){
-		 this.N = N;
-	 }
-
-	 public double getN() {
-		 return N;
-	 }
-
-	 /**
-	  * Adds the second array to the first array element by element. The arrays
-	  * must have the same length.
-	  * @param a1 Vector to which the second vector is added.
-	  * @param a2 Vector to be added. This vector does not change.
-	  */
-	 public static void addVectors(double[] a1, double[] a2) {
-		 assert (a1 != null);
-		 assert (a2 != null);
-		 assert (a1.length == a2.length) : "Adding two arrays of different "
-			 + "length";
-
-		 for (int i = 0; i < a1.length; i++) {
-			 a1[i] += a2[i];
-		 }
-	 }
+	@Override
+	public double[] getCenter() {
+		assert (this.N > 0);
+		double res[] = new double[this.LS.length];
+		for (int i = 0; i < res.length; i++) {
+			res[i] = this.LS[i] / N;
+		}
+		return res;
+	}
+
+	@Override
+	public abstract double getInclusionProbability(Instance instance);
+
+	/**
+	 * See interface <code>Cluster</code>
+	 * 
+	 * @return The radius of the cluster.
+	 */
+	@Override
+	public abstract double getRadius();
+
+	/**
+	 * See interface <code>Cluster</code>
+	 * 
+	 * @return The weight.
+	 * @see Cluster#getWeight()
+	 */
+	@Override
+	public double getWeight() {
+		return N;
+	}
+
+	public void setN(double N) {
+		this.N = N;
+	}
+
+	public double getN() {
+		return N;
+	}
+
+	/**
+	 * Adds the second array to the first array element by element. The arrays must
+	 * have the same length.
+	 * 
+	 * @param a1 Vector to which the second vector is added.
+	 * @param a2 Vector to be added. This vector does not change.
+	 */
+	public static void addVectors(double[] a1, double[] a2) {
+		assert (a1 != null);
+		assert (a2 != null);
+		assert (a1.length == a2.length) : "Adding two arrays of different " + "length";
+
+		for (int i = 0; i < a1.length; i++) {
+			a1[i] += a2[i];
+		}
+	}
 }
diff --git a/moa/src/main/java/moa/cluster/Cluster.java b/moa/src/main/java/moa/cluster/Cluster.java
index caab641ed..728c52f5d 100644
--- a/moa/src/main/java/moa/cluster/Cluster.java
+++ b/moa/src/main/java/moa/cluster/Cluster.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.cluster;
@@ -35,140 +35,136 @@ public abstract class Cluster extends AbstractMOAObject {
 	private static final long serialVersionUID = 1L;
 
 	private double id = -1;
-    private double gtLabel = -1;
-
-    private HashMap<String, String> measure_values;
-
-
-    public Cluster(){
-        this.measure_values = new HashMap<String, String>();
-    }
-    /**
-     * @return the center of the cluster
-     */
-    public abstract double[] getCenter();
-
-    /**
-     * Returns the weight of this cluster, not neccessarily normalized.
-     * It could, for instance, simply return the number of points contined
-     * in this cluster.
-     * @return the weight
-     */
-    public abstract double getWeight();
-
-    /**
-     * Returns the probability of the given point belonging to
-     * this cluster.
-     *
-     * @param point
-     * @return a value between 0 and 1
-     */
-    public abstract double getInclusionProbability(Instance instance);
-
-
-    //TODO: for non sphere cluster sample points, find out MIN MAX neighbours within cluster
-    //and return the relative distance
-    //public abstract double getRelativeHullDistance(Instance instance);
-    
-    @Override
-    public void getDescription(StringBuilder sb, int i) {
-        sb.append("Cluster Object");
-    }
-
-    public void setId(double id) {
-        this.id = id;
-    }
-
-    public double getId() {
-        return id;
-    }
-
-    public boolean isGroundTruth(){
-        return gtLabel != -1;
-    }
-
-    public void setGroundTruth(double truth){
-        gtLabel = truth;
-    }
-
-    public double getGroundTruth(){
-        return gtLabel;
-    }
-
-
-    /**
-     * Samples this cluster by returning a point from inside it.
-     * @param random a random number source
-     * @return an Instance that lies inside this cluster
-     */
-    public abstract Instance sample(Random random);
-
-
-    public void setMeasureValue(String measureKey, String value){
-        measure_values.put(measureKey, value);
-    }
-
-    public void setMeasureValue(String measureKey, double value){
-        measure_values.put(measureKey, Double.toString(value));
-    }
-
-
-    public String getMeasureValue(String measureKey){
-        if(measure_values.containsKey(measureKey))
-            return measure_values.get(measureKey);
-        else
-            return "";
-    }
-
-
-    protected void getClusterSpecificInfo(ArrayList<String> infoTitle,ArrayList<String> infoValue){
-        infoTitle.add("ClusterID");
-        infoValue.add(Integer.toString((int)getId()));
-
-        infoTitle.add("Type");
-        infoValue.add(getClass().getSimpleName());
-
-        double c[] = getCenter();
-        if(c!=null)
-        for (int i = 0; i < c.length; i++) {
-            infoTitle.add("Dim"+i);
-            infoValue.add(Double.toString(c[i]));
-        }
-
-        infoTitle.add("Weight");
-        infoValue.add(Double.toString(getWeight()));
-        
-    }
-
-    public String getInfo() {
-        ArrayList<String> infoTitle = new ArrayList<String>();
-        ArrayList<String> infoValue = new ArrayList<String>();
-        getClusterSpecificInfo(infoTitle, infoValue);
-
-        StringBuffer sb = new StringBuffer();
-
-        //Cluster properties
-        sb.append("<html>");
-        sb.append("<table>");
-        int i = 0;
-        while(i < infoTitle.size() && i < infoValue.size()){
-            sb.append("<tr><td>"+infoTitle.get(i)+"</td><td>"+infoValue.get(i)+"</td></tr>");
-            i++;
-        }
-        sb.append("</table>");
-
-        //Evaluation info
-        sb.append("<br>");
-        sb.append("<b>Evaluation</b><br>");
-        sb.append("<table>");
-        Iterator miterator = measure_values.entrySet().iterator();
-        while(miterator.hasNext()) {
-             Map.Entry e = (Map.Entry)miterator.next();
-             sb.append("<tr><td>"+e.getKey()+"</td><td>"+e.getValue()+"</td></tr>");
-        }
-        sb.append("</table>");
-        sb.append("</html>");
-        return sb.toString();
-    }
+	private double gtLabel = -1;
+
+	private HashMap<String, String> measure_values;
+
+	public Cluster() {
+		this.measure_values = new HashMap<>();
+	}
+
+	/**
+	 * @return the center of the cluster
+	 */
+	public abstract double[] getCenter();
+
+	/**
+	 * Returns the weight of this cluster, not neccessarily normalized. It could,
+	 * for instance, simply return the number of points contined in this cluster.
+	 * 
+	 * @return the weight
+	 */
+	public abstract double getWeight();
+
+	/**
+	 * Returns the probability of the given point belonging to this cluster.
+	 *
+	 * @param point
+	 * @return a value between 0 and 1
+	 */
+	public abstract double getInclusionProbability(Instance instance);
+
+	// TODO: for non sphere cluster sample points, find out MIN MAX neighbours
+	// within cluster
+	// and return the relative distance
+	// public abstract double getRelativeHullDistance(Instance instance);
+
+	@Override
+	public void getDescription(StringBuilder sb, int i) {
+		sb.append("Cluster Object");
+	}
+
+	public void setId(double id) {
+		this.id = id;
+	}
+
+	public double getId() {
+		return id;
+	}
+
+	public boolean isGroundTruth() {
+		return gtLabel != -1;
+	}
+
+	public void setGroundTruth(double truth) {
+		gtLabel = truth;
+	}
+
+	public double getGroundTruth() {
+		return gtLabel;
+	}
+
+	/**
+	 * Samples this cluster by returning a point from inside it.
+	 * 
+	 * @param random a random number source
+	 * @return an Instance that lies inside this cluster
+	 */
+	public abstract Instance sample(Random random);
+
+	public void setMeasureValue(String measureKey, String value) {
+		measure_values.put(measureKey, value);
+	}
+
+	public void setMeasureValue(String measureKey, double value) {
+		measure_values.put(measureKey, Double.toString(value));
+	}
+
+	public String getMeasureValue(String measureKey) {
+		if (measure_values.containsKey(measureKey))
+			return measure_values.get(measureKey);
+		else
+			return "";
+	}
+
+	protected void getClusterSpecificInfo(ArrayList<String> infoTitle, ArrayList<String> infoValue) {
+		infoTitle.add("ClusterID");
+		infoValue.add(Integer.toString((int) getId()));
+
+		infoTitle.add("Type");
+		infoValue.add(getClass().getSimpleName());
+
+		double c[] = getCenter();
+		if (c != null)
+			for (int i = 0; i < c.length; i++) {
+				infoTitle.add("Dim" + i);
+				infoValue.add(Double.toString(c[i]));
+			}
+
+		infoTitle.add("Weight");
+		infoValue.add(Double.toString(getWeight()));
+
+	}
+
+	public String getInfo() {
+		ArrayList<String> infoTitle = new ArrayList<>();
+		ArrayList<String> infoValue = new ArrayList<>();
+		getClusterSpecificInfo(infoTitle, infoValue);
+
+		StringBuffer sb = new StringBuffer();
+
+		// Cluster properties
+		sb.append("<html>");
+		sb.append("<table>");
+		int i = 0;
+		while (i < infoTitle.size() && i < infoValue.size()) {
+			sb.append("<tr><td>" + infoTitle.get(i) + "</td><td>" + infoValue.get(i) + "</td></tr>");
+			i++;
+		}
+		sb.append("</table>");
+
+		// Evaluation info
+		sb.append("<br>");
+		sb.append("<b>Evaluation</b><br>");
+		sb.append("<table>");
+		Iterator miterator = measure_values.entrySet().iterator();
+		while (miterator.hasNext()) {
+			Map.Entry e = (Map.Entry) miterator.next();
+			sb.append("<tr><td>" + e.getKey() + "</td><td>" + e.getValue() + "</td></tr>");
+		}
+		sb.append("</table>");
+		sb.append("</html>");
+		return sb.toString();
+	}
 
 }
diff --git a/moa/src/main/java/moa/cluster/Clustering.java b/moa/src/main/java/moa/cluster/Clustering.java
index 8f5e17ddd..cef37f81c 100644
--- a/moa/src/main/java/moa/cluster/Clustering.java
+++ b/moa/src/main/java/moa/cluster/Clustering.java
@@ -1,11 +1,11 @@
 /**
  * Clustering.java
- * 
+ *
  * Represents a collection of clusters.
- * 
+ *
  * @author Timm Jansen (moa@cs.rwth-aachen.de)
  * @editor Yunsu Kim
- * 
+ *
  * Last edited: 2013/06/02
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
@@ -19,266 +19,259 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.cluster;
 
-import com.yahoo.labs.samoa.instances.Attribute;
-import com.yahoo.labs.samoa.instances.Instance;
-import moa.AbstractMOAObject;
-import moa.core.AutoExpandVector;
-import moa.gui.visualization.DataPoint;
-
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 
-public class Clustering extends AbstractMOAObject{
-
-    private AutoExpandVector<Cluster> clusters;
-
-    public Clustering() {
-        this.clusters = new AutoExpandVector<Cluster>();
-    }
-
-    public Clustering( Cluster[] clusters ) {
-        this.clusters = new AutoExpandVector<Cluster>();
-        for (int i = 0; i < clusters.length; i++) {
-            this.clusters.add(clusters[i]);
-        }
-    }
-
-    public Clustering(List<? extends Instance> points){
-        HashMap<Integer, Integer> labelMap = classValues(points);
-        int dim = points.get(0).dataset().numAttributes()-1;
-
-        int numClasses = labelMap.size();
-        int noiseLabel;
-        
-        Attribute classLabel = points.get(0).dataset().classAttribute();
-        if (!classLabel.isNominal())
-            throw new IllegalStateException("Class attribute '" + classLabel.name() + "' is not nominal!");
-        int lastLabelIndex = classLabel.numValues() - 1;
-        if (classLabel.value(lastLabelIndex).equals("noise")) {
-        	noiseLabel = lastLabelIndex;
-        } else {
-        	noiseLabel = -1;
-        }
-
-        ArrayList<Instance>[] sorted_points = (ArrayList<Instance>[]) new ArrayList[numClasses];
-        for (int i = 0; i < numClasses; i++) {
-            sorted_points[i] = new ArrayList<Instance>();
-        }
-        for (Instance point : points) {
-            int clusterid = (int)point.classValue();
-            if(clusterid == noiseLabel) continue;
-            sorted_points[labelMap.get(clusterid)].add((Instance)point);
-        }
-        this.clusters = new AutoExpandVector<Cluster>();
-        for (int i = 0; i < numClasses; i++) {
-            if(sorted_points[i].size()>0){
-                SphereCluster s = new SphereCluster(sorted_points[i],dim);
-                s.setId(sorted_points[i].get(0).classValue());
-                s.setGroundTruth(sorted_points[i].get(0).classValue());
-                clusters.add(s);
-            }
-        }
-    }
-
-    public Clustering(ArrayList<DataPoint> points, double overlapThreshold, int initMinPoints){
-        HashMap<Integer, Integer> labelMap = Clustering.classValues(points);
-        int dim = points.get(0).dataset().numAttributes()-1;
-
-        int numClasses = labelMap.size();
-        int num = 0;
-
-        ArrayList<DataPoint>[] sorted_points = (ArrayList<DataPoint>[]) new ArrayList[numClasses];
-        for (int i = 0; i < numClasses; i++) {
-            sorted_points[i] = new ArrayList<DataPoint>();
-        }
-        for (DataPoint point : points) {
-            int clusterid = (int)point.classValue();
-            if(clusterid == -1) continue;
-            sorted_points[labelMap.get(clusterid)].add(point);
-            num++;
-        }
+import com.yahoo.labs.samoa.instances.Attribute;
+import com.yahoo.labs.samoa.instances.Instance;
 
-        clusters = new AutoExpandVector<Cluster>();
-        int microID = 0;
-        for (int i = 0; i < numClasses; i++) {
-            ArrayList<SphereCluster> microByClass = new ArrayList<SphereCluster>();
-            ArrayList<DataPoint> pointInCluster = new ArrayList<DataPoint>();
-            ArrayList<ArrayList<Instance>> pointInMicroClusters = new ArrayList();
+import moa.AbstractMOAObject;
+import moa.core.AutoExpandVector;
+import moa.gui.visualization.DataPoint;
 
-            pointInCluster.addAll(sorted_points[i]);
-            while(pointInCluster.size()>0){
-                ArrayList<Instance> micro_points = new ArrayList<Instance>();
-                for (int j = 0; j < initMinPoints && !pointInCluster.isEmpty(); j++) {
-                    micro_points.add((Instance)pointInCluster.get(0));
-                    pointInCluster.remove(0);
-                }
-                if(micro_points.size() > 0){
-                    SphereCluster s = new SphereCluster(micro_points,dim);
-                    for (int c = 0; c < microByClass.size(); c++) {
-                        if(((SphereCluster)microByClass.get(c)).overlapRadiusDegree(s) > overlapThreshold ){
-                            micro_points.addAll(pointInMicroClusters.get(c));
-                            s = new SphereCluster(micro_points,dim);
-                            pointInMicroClusters.remove(c);
-                            microByClass.remove(c);
-                            //System.out.println("Removing redundant cluster based on radius overlap"+c);
-                        }
-                    }
-                    for (int j = 0; j < pointInCluster.size(); j++) {
-                        Instance instance = pointInCluster.get(j);
-                        if(s.getInclusionProbability(instance) > 0.8){
-                            pointInCluster.remove(j);
-                            micro_points.add(instance);
-                        }
-                    }
-                    s.setWeight(micro_points.size());
-                    microByClass.add(s);
-                    pointInMicroClusters.add(micro_points);
-                    microID++;
-                }
-            }
-            //
-            boolean changed = true;
-            while(changed){
-                changed = false;
-                for(int c = 0; c < microByClass.size(); c++) {
-                    for(int c1 = c+1; c1 < microByClass.size(); c1++) {
-                        double overlap = microByClass.get(c).overlapRadiusDegree(microByClass.get(c1));
+public class Clustering extends AbstractMOAObject {
+
+	private AutoExpandVector<Cluster> clusters;
+
+	public Clustering() {
+		this.clusters = new AutoExpandVector<>();
+	}
+
+	public Clustering(Cluster[] clusters) {
+		this.clusters = new AutoExpandVector<>();
+		for (int i = 0; i < clusters.length; i++) {
+			this.clusters.add(clusters[i]);
+		}
+	}
+
+	public Clustering(List<? extends Instance> points) {
+		HashMap<Integer, Integer> labelMap = classValues(points);
+		int dim = points.get(0).dataset().numAttributes() - 1;
+
+		int numClasses = labelMap.size();
+		int noiseLabel;
+
+		Attribute classLabel = points.get(0).dataset().classAttribute();
+		if (!classLabel.isNominal())
+			throw new IllegalStateException("Class attribute '" + classLabel.name() + "' is not nominal!");
+		int lastLabelIndex = classLabel.numValues() - 1;
+		if (classLabel.value(lastLabelIndex).equals("noise")) {
+			noiseLabel = lastLabelIndex;
+		} else {
+			noiseLabel = -1;
+		}
+
+		ArrayList<Instance>[] sorted_points = new ArrayList[numClasses];
+		for (int i = 0; i < numClasses; i++) {
+			sorted_points[i] = new ArrayList<>();
+		}
+		for (Instance point : points) {
+			int clusterid = (int) point.classValue();
+			if (clusterid == noiseLabel)
+				continue;
+			sorted_points[labelMap.get(clusterid)].add(point);
+		}
+		this.clusters = new AutoExpandVector<>();
+		for (int i = 0; i < numClasses; i++) {
+			if (sorted_points[i].size() > 0) {
+				SphereCluster s = new SphereCluster(sorted_points[i], dim);
+				s.setId(sorted_points[i].get(0).classValue());
+				s.setGroundTruth(sorted_points[i].get(0).classValue());
+				clusters.add(s);
+			}
+		}
+	}
+
+	public Clustering(ArrayList<DataPoint> points, double overlapThreshold, int initMinPoints) {
+		HashMap<Integer, Integer> labelMap = Clustering.classValues(points);
+		int dim = points.get(0).dataset().numAttributes() - 1;
+
+		int numClasses = labelMap.size();
+		int num = 0;
+
+		ArrayList<DataPoint>[] sorted_points = new ArrayList[numClasses];
+		for (int i = 0; i < numClasses; i++) {
+			sorted_points[i] = new ArrayList<>();
+		}
+		for (DataPoint point : points) {
+			int clusterid = (int) point.classValue();
+			if (clusterid == -1)
+				continue;
+			sorted_points[labelMap.get(clusterid)].add(point);
+			num++;
+		}
+
+		clusters = new AutoExpandVector<>();
+		int microID = 0;
+		for (int i = 0; i < numClasses; i++) {
+			ArrayList<SphereCluster> microByClass = new ArrayList<>();
+			ArrayList<DataPoint> pointInCluster = new ArrayList<>();
+			ArrayList<ArrayList<Instance>> pointInMicroClusters = new ArrayList();
+
+			pointInCluster.addAll(sorted_points[i]);
+			while (pointInCluster.size() > 0) {
+				ArrayList<Instance> micro_points = new ArrayList<>();
+				for (int j = 0; j < initMinPoints && !pointInCluster.isEmpty(); j++) {
+					micro_points.add(pointInCluster.get(0));
+					pointInCluster.remove(0);
+				}
+				if (micro_points.size() > 0) {
+					SphereCluster s = new SphereCluster(micro_points, dim);
+					for (int c = 0; c < microByClass.size(); c++) {
+						if (microByClass.get(c).overlapRadiusDegree(s) > overlapThreshold) {
+							micro_points.addAll(pointInMicroClusters.get(c));
+							s = new SphereCluster(micro_points, dim);
+							pointInMicroClusters.remove(c);
+							microByClass.remove(c);
+							// System.out.println("Removing redundant cluster based on radius overlap"+c);
+						}
+					}
+					for (int j = 0; j < pointInCluster.size(); j++) {
+						Instance instance = pointInCluster.get(j);
+						if (s.getInclusionProbability(instance) > 0.8) {
+							pointInCluster.remove(j);
+							micro_points.add(instance);
+						}
+					}
+					s.setWeight(micro_points.size());
+					microByClass.add(s);
+					pointInMicroClusters.add(micro_points);
+					microID++;
+				}
+			}
+			//
+			boolean changed = true;
+			while (changed) {
+				changed = false;
+				for (int c = 0; c < microByClass.size(); c++) {
+					for (int c1 = c + 1; c1 < microByClass.size(); c1++) {
+						double overlap = microByClass.get(c).overlapRadiusDegree(microByClass.get(c1));
 //                        System.out.println("Overlap C"+(clustering.size()+c)+" ->C"+(clustering.size()+c1)+": "+overlap);
-                        if(overlap > overlapThreshold){
-                            pointInMicroClusters.get(c).addAll(pointInMicroClusters.get(c1));
-                            SphereCluster s = new SphereCluster(pointInMicroClusters.get(c),dim);
-                            microByClass.set(c, s);
-                            pointInMicroClusters.remove(c1);
-                            microByClass.remove(c1);
-                            changed = true;
-                            break;
-                        }
-                    }
-                }
-            }
-            for (int j = 0; j < microByClass.size(); j++) {
-                microByClass.get(j).setGroundTruth(sorted_points[i].get(0).classValue());
-                clusters.add(microByClass.get(j));
-            }
-
-        }
-        for (int j = 0; j < clusters.size(); j++) {
-            clusters.get(j).setId(j);
-        }
-
-    }
-
-    /**
-     * @param points 
-     * @return an array with the min and max class label value
-     */
-    public static HashMap<Integer, Integer> classValues(List<? extends Instance> points){
-        HashMap<Integer,Integer> classes = new HashMap<Integer, Integer>();
-        int workcluster = 0;
-        boolean hasnoise = false;
-        for (int i = 0; i < points.size(); i++) {
-            int label = (int) points.get(i).classValue();
-            if(label == -1){
-                hasnoise = true;
-            }
-            else{
-                if(!classes.containsKey(label)){
-                    classes.put(label,workcluster);
-                    workcluster++;
-                }
-            }
-        }
-        if(hasnoise)
-            classes.put(-1,workcluster);
-        return classes;
-    }
-
-    public Clustering(AutoExpandVector<Cluster> clusters) {
-        this.clusters = clusters;
-    }
-
-
-    /**
-     * add a cluster to the clustering
-     */
-    public void add(Cluster cluster){
-        clusters.add(cluster);
-    }
-
-    /**
-     * remove a cluster from the clustering
-     */
-    public void remove(int index){
-        if(index < clusters.size()){
-            clusters.remove(index);
-        }
-    }
-
-    /**
-     * get a cluster from the clustering
-     */
-    public Cluster get(int index){
-        if(index < clusters.size()){
-            return clusters.get(index);
-        }
-        return null;
-    }
-
-    /**
-     * @return the <code>Clustering</code> as an AutoExpandVector
-     */
-    public AutoExpandVector<Cluster> getClustering() {
-        return clusters;
-    }
-
-    /**
-     * @return A deepcopy of the <code>Clustering</code> as an AutoExpandVector
-     */
-    public AutoExpandVector<Cluster> getClusteringCopy() {
-        return (AutoExpandVector<Cluster>)clusters.copy();
-    }
-
-
-    /**
-     * @return the number of clusters
-     */
-    public int size() {
-	return clusters.size();
-    }
-
-    /**
-     * @return the number of dimensions of this clustering
-     */
-    public int dimension() {
-	assert (clusters.size() != 0);
-	return clusters.get(0).getCenter().length;
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int i) {
-        sb.append("Clustering Object");
-    }
-
-
-
-    public double getMaxInclusionProbability(Instance point) {
-        double maxInclusion = 0.0;
-        for (int i = 0; i < clusters.size(); i++) {
-            maxInclusion = Math.max(clusters.get(i).getInclusionProbability(point),
-                    maxInclusion);
-        }
-        return maxInclusion;
-    }
-
-
-
-
+						if (overlap > overlapThreshold) {
+							pointInMicroClusters.get(c).addAll(pointInMicroClusters.get(c1));
+							SphereCluster s = new SphereCluster(pointInMicroClusters.get(c), dim);
+							microByClass.set(c, s);
+							pointInMicroClusters.remove(c1);
+							microByClass.remove(c1);
+							changed = true;
+							break;
+						}
+					}
+				}
+			}
+			for (int j = 0; j < microByClass.size(); j++) {
+				microByClass.get(j).setGroundTruth(sorted_points[i].get(0).classValue());
+				clusters.add(microByClass.get(j));
+			}
+
+		}
+		for (int j = 0; j < clusters.size(); j++) {
+			clusters.get(j).setId(j);
+		}
+
+	}
+
+	/**
+	 * @param points
+	 * @return an array with the min and max class label value
+	 */
+	public static HashMap<Integer, Integer> classValues(List<? extends Instance> points) {
+		HashMap<Integer, Integer> classes = new HashMap<>();
+		int workcluster = 0;
+		boolean hasnoise = false;
+		for (int i = 0; i < points.size(); i++) {
+			int label = (int) points.get(i).classValue();
+			if (label == -1) {
+				hasnoise = true;
+			} else {
+				if (!classes.containsKey(label)) {
+					classes.put(label, workcluster);
+					workcluster++;
+				}
+			}
+		}
+		if (hasnoise)
+			classes.put(-1, workcluster);
+		return classes;
+	}
+
+	public Clustering(AutoExpandVector<Cluster> clusters) {
+		this.clusters = clusters;
+	}
+
+	/**
+	 * add a cluster to the clustering
+	 */
+	public void add(Cluster cluster) {
+		clusters.add(cluster);
+	}
+
+	/**
+	 * remove a cluster from the clustering
+	 */
+	public void remove(int index) {
+		if (index < clusters.size()) {
+			clusters.remove(index);
+		}
+	}
+
+	/**
+	 * get a cluster from the clustering
+	 */
+	public Cluster get(int index) {
+		if (index < clusters.size()) {
+			return clusters.get(index);
+		}
+		return null;
+	}
+
+	/**
+	 * @return the <code>Clustering</code> as an AutoExpandVector
+	 */
+	public AutoExpandVector<Cluster> getClustering() {
+		return clusters;
+	}
+
+	/**
+	 * @return A deepcopy of the <code>Clustering</code> as an AutoExpandVector
+	 */
+	public AutoExpandVector<Cluster> getClusteringCopy() {
+		return (AutoExpandVector<Cluster>) clusters.copy();
+	}
+
+	/**
+	 * @return the number of clusters
+	 */
+	public int size() {
+		return clusters.size();
+	}
+
+	/**
+	 * @return the number of dimensions of this clustering
+	 */
+	public int dimension() {
+		assert (clusters.size() != 0);
+		return clusters.get(0).getCenter().length;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int i) {
+		sb.append("Clustering Object");
+	}
+
+	public double getMaxInclusionProbability(Instance point) {
+		double maxInclusion = 0.0;
+		for (int i = 0; i < clusters.size(); i++) {
+			maxInclusion = Math.max(clusters.get(i).getInclusionProbability(point), maxInclusion);
+		}
+		return maxInclusion;
+	}
 
 }
diff --git a/moa/src/main/java/moa/cluster/Miniball.java b/moa/src/main/java/moa/cluster/Miniball.java
index 1c37d33c8..cc92aca9d 100644
--- a/moa/src/main/java/moa/cluster/Miniball.java
+++ b/moa/src/main/java/moa/cluster/Miniball.java
@@ -3,423 +3,431 @@
 import java.util.ArrayList;
 
 /**
-* Java Porting of the Miniball.h code of <B>Bernd Gaertner</B>.
-* Look at http://www.inf.ethz.ch/personal/gaertner/miniball.html<br>
-* and related work at
-* http://www.inf.ethz.ch/personal/gaertner/texts/own_work/esa99_final.pdf<br>
-* for reading about the algorithm and the implementation of it.<p>
-* <p>
-* If interested in Bounding Sphere algorithms read also published work of 
-* <B>Emo Welzl</B> "Smallest enclosing disks (balls and Ellipsoid)" and
-* the work of <B>Jack Ritter</B> on "Efficient Bounding Spheres"  at<br>
-* http://tog.acm.org/GraphicsGems/gems/BoundSphere.c?searchterm=calc<p>
-* <p><p>
-* For Licencing Info report to Bernd Gaertner's one reported below:<p>
-*
-* Copright (C) 1999-2006, Bernd Gaertner<br>
-*   $Revision: 1.3 $<br>
-*   $Date: 2006/11/16 08:01:52 $<br>
-*<br>
-*This program is free software; you can redistribute it and/or modify<br>
-*it under the terms of the GNU General Public License as published by<br>
-*the Free Software Foundation; either version 3 of the License, or<br>
-*(at your option) any later version.<br>
-*<br>
-*This program is distributed in the hope that it will be useful,<br>
-*but WITHOUT ANY WARRANTY; without even the implied warranty of<br>
-*MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the<br>
-*GNU General Public License for more details.<br>
-*<br>
-*You should have received a copy of the GNU General Public License<br>
-*along with this program. If not, see <http://www.gnu.org/licenses/>.<br>
-*Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA,<br>
-*or download the License terms from prep.ai.mit.edu/pub/gnu/COPYING-2.0.<br>
-*<br>
-*Contact:<br>
-*--------<br>
-*Bernd Gaertner<br>
-*Institute of Theoretical Computer Science<br>
-*ETH Zuerich<br>
-*CAB G32.2<br>
-*CH-8092 Zuerich, Switzerland<br>
-*http://www.inf.ethz.ch/personal/gaertner<br>
-
-* Original Java port from Paolo Perissinotto for Jpatch Project by Sascha Ledinsky
-* found at http://forum.jpatch.com/viewtopic.php?f=3&t=919
-*
-* @author Paolo Perissinotto for Jpatch Project by <B>Sascha Ledinsky</B>
-*
-* @version 1.0
-* {@literal Date: 2007/11/18 21:57}
-*
-* used for moa for calculating most compact sphere cluster
-* modified by Timm Jansen (moa@cs.rwth-aachen.de) to be used with high 
-* dimensional points
-*
-*/
+ * Java Porting of the Miniball.h code of <B>Bernd Gaertner</B>. Look at
+ * http://www.inf.ethz.ch/personal/gaertner/miniball.html<br>
+ * and related work at
+ * http://www.inf.ethz.ch/personal/gaertner/texts/own_work/esa99_final.pdf<br>
+ * for reading about the algorithm and the implementation of it.
+ * <p>
+ * <p>
+ * If interested in Bounding Sphere algorithms read also published work of
+ * <B>Emo Welzl</B> "Smallest enclosing disks (balls and Ellipsoid)" and the
+ * work of <B>Jack Ritter</B> on "Efficient Bounding Spheres" at<br>
+ * http://tog.acm.org/GraphicsGems/gems/BoundSphere.c?searchterm=calc
+ * <p>
+ * <p>
+ * <p>
+ * For Licencing Info report to Bernd Gaertner's one reported below:
+ * <p>
+ *
+ * Copright (C) 1999-2006, Bernd Gaertner<br>
+ * $Revision: 1.3 $<br>
+ * $Date: 2006/11/16 08:01:52 $<br>
+ * <br>
+ * This program is free software; you can redistribute it and/or modify<br>
+ * it under the terms of the GNU General Public License as published by<br>
+ * the Free Software Foundation; either version 3 of the License, or<br>
+ * (at your option) any later version.<br>
+ * <br>
+ * This program is distributed in the hope that it will be useful,<br>
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of<br>
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the<br>
+ * GNU General Public License for more details.<br>
+ * <br>
+ * You should have received a copy of the GNU General Public License<br>
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.<br>
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA,<br>
+ * or download the License terms from prep.ai.mit.edu/pub/gnu/COPYING-2.0.<br>
+ * <br>
+ * Contact:<br>
+ * --------<br>
+ * Bernd Gaertner<br>
+ * Institute of Theoretical Computer Science<br>
+ * ETH Zuerich<br>
+ * CAB G32.2<br>
+ * CH-8092 Zuerich, Switzerland<br>
+ * http://www.inf.ethz.ch/personal/gaertner<br>
+ * 
+ * Original Java port from Paolo Perissinotto for Jpatch Project by Sascha
+ * Ledinsky found at http://forum.jpatch.com/viewtopic.php?f=3&t=919
+ *
+ * @author Paolo Perissinotto for Jpatch Project by <B>Sascha Ledinsky</B>
+ *
+ * @version 1.0 {@literal Date: 2007/11/18 21:57}
+ *
+ *          used for moa for calculating most compact sphere cluster modified by
+ *          Timm Jansen (moa@cs.rwth-aachen.de) to be used with high dimensional
+ *          points
+ *
+ */
 
 public class Miniball {
 
-    int d;
-    ArrayList L;
-    Miniball_b B;
-    int support_end = 0;
-
-    public Miniball(int dim) {
-        d = dim;
-        L = new ArrayList();
-        B = new Miniball_b();
-    }
-
-    class pvt {
-        int val;
-
-        pvt() {
-            val = 0;
-        }
-
-        void setVal(int i) {
-            val = i;
-        }
-
-        int getVal() {
-            return (val);
-        }
-    }
-
-    class Miniball_b {
-
-        int m, s;   // size and number of support points
-        double[] q0 = new double[d];
-        double[] z = new double[d + 1];
-        double[] f = new double[d + 1];
-        double[][] v = new double[d + 1][d];
-        double[][] a = new double[d + 1][d];
-        double[][] c = new double[d + 1][d];
-        double[] sqr_r = new double[d + 1];
-        double[] current_c = new double[d]; // refers to some c[j]
-        double current_sqr_r;
-
-
-        double[] getCenter() {
-            return (current_c);
-        }
-
-        double squared_radius() {
-            return current_sqr_r;
-        }
-
-        int size() {
-            return m;
-        }
-
-        int support_size() {
-            return s;
-        }
-
-        double excess(double[] p) {
-            double e = -current_sqr_r;
-            for (int k = 0; k < d; ++k) {
-                e += mb_sqr(p[k] - current_c[k]);
-            }
-            return e;
-        }
-
-        void reset() {
-            m = 0;
-            s = 0;
-            // we misuse c[0] for the center of the empty sphere
-            for (int j = 0; j < d; j++) {
-                c[0][j] = 0;
-            }
-            current_c = c[0];
-            current_sqr_r = -1;
-        }
-
-        void pop() {
-            --m;
-        }
-
-        boolean push(double[] p) {
-            //System.out.println("Miniball_b:push");
-            int i, j;
-            double eps = 1e-32;
-
-            if (m == 0) {
-                for (i = 0; i < d; ++i) {
-                    q0[i] = p[i];
-                }
-                for (i = 0; i < d; ++i) {
-                    c[0][i] = q0[i];
-                }
-                sqr_r[0] = 0;
-            } else {
-                // set v_m to Q_m
-                for (i = 0; i < d; ++i) {
-                    v[m][i] = p[i] - q0[i];
-                }
-
-                // compute the a_{m,i}, i< m
-                for (i = 1; i < m; ++i) {
-                    a[m][i] = 0;
-                    for (j = 0; j < d; ++j) {
-                        a[m][i] += v[i][j] * v[m][j];
-                    }
-                    a[m][i] *= (2 / z[i]);
-                }
-
-                // update v_m to Q_m-\bar{Q}_m
-                for (i = 1; i < m; ++i) {
-                    for (j = 0; j < d; ++j) {
-                        v[m][j] -= a[m][i] * v[i][j];
-                    }
-                }
-
-                // compute z_m
-                z[m] = 0;
-                for (j = 0; j < d; ++j) {
-                    z[m] += mb_sqr(v[m][j]);
-                }
-                z[m] *= 2;
-
-                // reject push if z_m too small
-                if (z[m] < eps * current_sqr_r) {
-                    return false;
-                }
-
-                // update c, sqr_r
-                double e = -sqr_r[m - 1];
-                for (i = 0; i < d; ++i) {
-                    e += mb_sqr(p[i] - c[m - 1][i]);
-                }
-                f[m] = e / z[m];
-
-                for (i = 0; i < d; ++i) {
-                    c[m][i] = c[m - 1][i] + f[m] * v[m][i];
-                }
-                sqr_r[m] = sqr_r[m - 1] + e * f[m] / 2;
-            }
-            current_c = c[m];
-            current_sqr_r = sqr_r[m];
-            s = ++m;
-            return true;
-        }
-
-        double slack() {
-            double min_l = 0;
-            double[] l = new double[d + 1];
-            l[0] = 1;
-            for (int i = s - 1; i > 0; --i) {
-                l[i] = f[i];
-                for (int k = s - 1; k > i; --k) {
-                    l[i] -= a[k][i] * l[k];
-                }
-                if (l[i] < min_l) {
-                    min_l = l[i];
-                }
-                l[0] -= l[i];
-            }
-            if (l[0] < min_l) {
-                min_l = l[0];
-            }
-            return ((min_l < 0) ? -min_l : 0);
-        }
-    }
-
-    /**
-     *   Method clear: clears the ArrayList of the selection points.<br>
-     *   Use it for starting a new selection list to calculate Bounding Sphere on<br>
-     *   or to clear memory references to the list of objects.<br>
-     *   Always use at the end of a Miniball use if you want to reuse later the Miniball object
-     *
-     */
-    public void clear() {
-        L.clear();
-    }
-
-    /**
-     * Adds a point to the list.<br>
-     * Skip action on null parameter.<br>
-     * @param p The object to be added to the list
-     */
-    public void check_in(double[] p) {
-        if (p != null) {
-            L.add(p);
-        } else {
-            System.out.println("Miniball.check_in WARNING: Skipping null point");
-        }
-    }
-
-
-    /**
-     * Recalculate Miniball parameter Center and Radius
-     *
-     */
-    public void build() {
-        B.reset();
-        support_end = 0;
-        pivot_mb(points_end());
-    }
-
-    void mtf_mb(int i) {
-        int pj = 0;
-        support_end = points_begin();
-        if ((B.size()) == d + 1) {
-            return;
-        }
-        for (int k = points_begin(); k != i;) {
-            pj = pj + 1;
-            int j = k++;
-            double[] sp = (double[]) L.get(j);
-            if (B.excess(sp) > 0) {
-                if (B.push(sp)) {
-                    mtf_mb(j);
-                    B.pop();
-                    move_to_front(j);
-                }
-            }
-        }
-    }
-
-    void move_to_front(int j) {
-
-        if (support_end <= j) {
-            support_end++;
-        }
-        //   L.splice (L.begin(), L, j);
-        double[] sp = (double[]) L.get(j);
-        L.remove(j);
-        L.add(0, sp);
-    }
-
-    void pivot_mb(int i) {
-        int t = 1;
-        mtf_mb(t);
-        double max_e = 0.0, old_sqr_r = -1;
-        pvt pivot = new pvt();
-        do {
-            max_e = max_excess(t, i, pivot);
-            if (max_e > 0) {
-                t = support_end;
-                if (t == pivot.getVal()) {
-                    ++t;
-                }
-                old_sqr_r = B.squared_radius();
-                double[] sp = (double[]) L.get(pivot.getVal());
-                B.push(sp);
-                mtf_mb(support_end);
-                B.pop();
-                move_to_front(pivot.getVal());
-            }
-        } while ((max_e > 0) && (B.squared_radius() > old_sqr_r));
-    }
-
-    double max_excess(int t, int i, pvt pivot) {
-        double[] c = B.getCenter();
-        double sqr_r = B.squared_radius();
-        double e, max_e = 0;
-        for (int k = t; k != i; ++k) {
-            double[] p = (double[]) L.get(k);
-
-            e = -sqr_r;
-            for (int j = 0; j < d; ++j) {
-                e += mb_sqr(p[j] - c[j]);
-            }
-            if (e > max_e) {
-                max_e = e;
-                pivot.setVal(k);
-            }
-        }
-        return max_e;
-    }
-
-    /**
-     * Return the center of the Miniball
-     * @return The center (double[])
-     */
-    public double[] center() {
-        return B.getCenter();
-    }
-
-    /**
-     * Return the sqaured Radius of the miniball
-     * @return The square radius
-     */
-    public double squared_radius() {
-        return B.squared_radius();
-    }
-
-    /**
-     * Return the Radius of the miniball
-     * @return The radius
-     */
-    public double radius() {
-        return ((1 + 0.00001) * Math.sqrt(B.squared_radius()));
-    }
-
-    /**
-     * Return the actual number of points in the list
-     * @return the actual number of points
-     */
-    public int nr_points() {
-        return L.size();
-    }
-
-    int points_begin() {
-        return (0);
-    }
-
-    int points_end() {
-        return (L.size());
-    }
-
-    /**
-     * Return the number of support points (used to calculate the miniball).<br>
-     * It's and internal info
-     * @return the number of support points
-     */
-    public int nr_support_points() {
-        return B.support_size();
-    }
-
-    int support_points_begin() {
-        return (0);
-    }
-
-    int support_points_end() {
-        return support_end;
-    }
-
-    double accuracy(double slack) {
-        double e, max_e = 0;
-        int n_supp = 0;
-
-        int i;
-        for (i = points_begin(); i != support_end; ++i, ++n_supp) {
-            double[] sp = (double[]) L.get(i);
-            if ((e = Math.abs(B.excess(sp))) > max_e) {
-                max_e = e;
-            }
-        }
-        if (n_supp == nr_support_points()) {
-            System.out.println("Miniball.accuracy WARNING: STRANGE PROBLEM HERE!");
-        }
-        for (i = support_end; i != points_end(); ++i) {
-            double[] sp = (double[]) L.get(i);
-            if ((e = B.excess(sp)) > max_e) {
-                max_e = e;
-            }
-        }
-        slack = B.slack();
-        return (max_e / squared_radius());
-    }
-
-    boolean is_valid(double tolerance) {
-        double slack = 0.0;
-        return ((accuracy(slack) < tolerance) && (slack == 0));
-    }
-
-    double mb_sqr(double r) {
-        return r * r;
-    }
+	int d;
+	ArrayList L;
+	Miniball_b B;
+	int support_end = 0;
+
+	public Miniball(int dim) {
+		d = dim;
+		L = new ArrayList();
+		B = new Miniball_b();
+	}
+
+	class pvt {
+		int val;
+
+		pvt() {
+			val = 0;
+		}
+
+		void setVal(int i) {
+			val = i;
+		}
+
+		int getVal() {
+			return (val);
+		}
+	}
+
+	class Miniball_b {
+
+		int m, s; // size and number of support points
+		double[] q0 = new double[d];
+		double[] z = new double[d + 1];
+		double[] f = new double[d + 1];
+		double[][] v = new double[d + 1][d];
+		double[][] a = new double[d + 1][d];
+		double[][] c = new double[d + 1][d];
+		double[] sqr_r = new double[d + 1];
+		double[] current_c = new double[d]; // refers to some c[j]
+		double current_sqr_r;
+
+		double[] getCenter() {
+			return (current_c);
+		}
+
+		double squared_radius() {
+			return current_sqr_r;
+		}
+
+		int size() {
+			return m;
+		}
+
+		int support_size() {
+			return s;
+		}
+
+		double excess(double[] p) {
+			double e = -current_sqr_r;
+			for (int k = 0; k < d; ++k) {
+				e += mb_sqr(p[k] - current_c[k]);
+			}
+			return e;
+		}
+
+		void reset() {
+			m = 0;
+			s = 0;
+			// we misuse c[0] for the center of the empty sphere
+			for (int j = 0; j < d; j++) {
+				c[0][j] = 0;
+			}
+			current_c = c[0];
+			current_sqr_r = -1;
+		}
+
+		void pop() {
+			--m;
+		}
+
+		boolean push(double[] p) {
+			// System.out.println("Miniball_b:push");
+			int i, j;
+			double eps = 1e-32;
+
+			if (m == 0) {
+				for (i = 0; i < d; ++i) {
+					q0[i] = p[i];
+				}
+				for (i = 0; i < d; ++i) {
+					c[0][i] = q0[i];
+				}
+				sqr_r[0] = 0;
+			} else {
+				// set v_m to Q_m
+				for (i = 0; i < d; ++i) {
+					v[m][i] = p[i] - q0[i];
+				}
+
+				// compute the a_{m,i}, i< m
+				for (i = 1; i < m; ++i) {
+					a[m][i] = 0;
+					for (j = 0; j < d; ++j) {
+						a[m][i] += v[i][j] * v[m][j];
+					}
+					a[m][i] *= (2 / z[i]);
+				}
+
+				// update v_m to Q_m-\bar{Q}_m
+				for (i = 1; i < m; ++i) {
+					for (j = 0; j < d; ++j) {
+						v[m][j] -= a[m][i] * v[i][j];
+					}
+				}
+
+				// compute z_m
+				z[m] = 0;
+				for (j = 0; j < d; ++j) {
+					z[m] += mb_sqr(v[m][j]);
+				}
+				z[m] *= 2;
+
+				// reject push if z_m too small
+				if (z[m] < eps * current_sqr_r) {
+					return false;
+				}
+
+				// update c, sqr_r
+				double e = -sqr_r[m - 1];
+				for (i = 0; i < d; ++i) {
+					e += mb_sqr(p[i] - c[m - 1][i]);
+				}
+				f[m] = e / z[m];
+
+				for (i = 0; i < d; ++i) {
+					c[m][i] = c[m - 1][i] + f[m] * v[m][i];
+				}
+				sqr_r[m] = sqr_r[m - 1] + e * f[m] / 2;
+			}
+			current_c = c[m];
+			current_sqr_r = sqr_r[m];
+			s = ++m;
+			return true;
+		}
+
+		double slack() {
+			double min_l = 0;
+			double[] l = new double[d + 1];
+			l[0] = 1;
+			for (int i = s - 1; i > 0; --i) {
+				l[i] = f[i];
+				for (int k = s - 1; k > i; --k) {
+					l[i] -= a[k][i] * l[k];
+				}
+				if (l[i] < min_l) {
+					min_l = l[i];
+				}
+				l[0] -= l[i];
+			}
+			if (l[0] < min_l) {
+				min_l = l[0];
+			}
+			return ((min_l < 0) ? -min_l : 0);
+		}
+	}
+
+	/**
+	 * Method clear: clears the ArrayList of the selection points.<br>
+	 * Use it for starting a new selection list to calculate Bounding Sphere on<br>
+	 * or to clear memory references to the list of objects.<br>
+	 * Always use at the end of a Miniball use if you want to reuse later the
+	 * Miniball object
+	 *
+	 */
+	public void clear() {
+		L.clear();
+	}
+
+	/**
+	 * Adds a point to the list.<br>
+	 * Skip action on null parameter.<br>
+	 * 
+	 * @param p The object to be added to the list
+	 */
+	public void check_in(double[] p) {
+		if (p != null) {
+			L.add(p);
+		} else {
+			System.out.println("Miniball.check_in WARNING: Skipping null point");
+		}
+	}
+
+	/**
+	 * Recalculate Miniball parameter Center and Radius
+	 *
+	 */
+	public void build() {
+		B.reset();
+		support_end = 0;
+		pivot_mb(points_end());
+	}
+
+	void mtf_mb(int i) {
+		int pj = 0;
+		support_end = points_begin();
+		if ((B.size()) == d + 1) {
+			return;
+		}
+		for (int k = points_begin(); k != i;) {
+			pj = pj + 1;
+			int j = k++;
+			double[] sp = (double[]) L.get(j);
+			if (B.excess(sp) > 0) {
+				if (B.push(sp)) {
+					mtf_mb(j);
+					B.pop();
+					move_to_front(j);
+				}
+			}
+		}
+	}
+
+	void move_to_front(int j) {
+
+		if (support_end <= j) {
+			support_end++;
+		}
+		// L.splice (L.begin(), L, j);
+		double[] sp = (double[]) L.get(j);
+		L.remove(j);
+		L.add(0, sp);
+	}
+
+	void pivot_mb(int i) {
+		int t = 1;
+		mtf_mb(t);
+		double max_e = 0.0, old_sqr_r = -1;
+		pvt pivot = new pvt();
+		do {
+			max_e = max_excess(t, i, pivot);
+			if (max_e > 0) {
+				t = support_end;
+				if (t == pivot.getVal()) {
+					++t;
+				}
+				old_sqr_r = B.squared_radius();
+				double[] sp = (double[]) L.get(pivot.getVal());
+				B.push(sp);
+				mtf_mb(support_end);
+				B.pop();
+				move_to_front(pivot.getVal());
+			}
+		} while ((max_e > 0) && (B.squared_radius() > old_sqr_r));
+	}
+
+	double max_excess(int t, int i, pvt pivot) {
+		double[] c = B.getCenter();
+		double sqr_r = B.squared_radius();
+		double e, max_e = 0;
+		for (int k = t; k != i; ++k) {
+			double[] p = (double[]) L.get(k);
+
+			e = -sqr_r;
+			for (int j = 0; j < d; ++j) {
+				e += mb_sqr(p[j] - c[j]);
+			}
+			if (e > max_e) {
+				max_e = e;
+				pivot.setVal(k);
+			}
+		}
+		return max_e;
+	}
+
+	/**
+	 * Return the center of the Miniball
+	 * 
+	 * @return The center (double[])
+	 */
+	public double[] center() {
+		return B.getCenter();
+	}
+
+	/**
+	 * Return the sqaured Radius of the miniball
+	 * 
+	 * @return The square radius
+	 */
+	public double squared_radius() {
+		return B.squared_radius();
+	}
+
+	/**
+	 * Return the Radius of the miniball
+	 * 
+	 * @return The radius
+	 */
+	public double radius() {
+		return ((1 + 0.00001) * Math.sqrt(B.squared_radius()));
+	}
+
+	/**
+	 * Return the actual number of points in the list
+	 * 
+	 * @return the actual number of points
+	 */
+	public int nr_points() {
+		return L.size();
+	}
+
+	int points_begin() {
+		return (0);
+	}
+
+	int points_end() {
+		return (L.size());
+	}
+
+	/**
+	 * Return the number of support points (used to calculate the miniball).<br>
+	 * It's and internal info
+	 * 
+	 * @return the number of support points
+	 */
+	public int nr_support_points() {
+		return B.support_size();
+	}
+
+	int support_points_begin() {
+		return (0);
+	}
+
+	int support_points_end() {
+		return support_end;
+	}
+
+	double accuracy(double slack) {
+		double e, max_e = 0;
+		int n_supp = 0;
+
+		int i;
+		for (i = points_begin(); i != support_end; ++i, ++n_supp) {
+			double[] sp = (double[]) L.get(i);
+			if ((e = Math.abs(B.excess(sp))) > max_e) {
+				max_e = e;
+			}
+		}
+		if (n_supp == nr_support_points()) {
+			System.out.println("Miniball.accuracy WARNING: STRANGE PROBLEM HERE!");
+		}
+		for (i = support_end; i != points_end(); ++i) {
+			double[] sp = (double[]) L.get(i);
+			if ((e = B.excess(sp)) > max_e) {
+				max_e = e;
+			}
+		}
+		slack = B.slack();
+		return (max_e / squared_radius());
+	}
+
+	boolean is_valid(double tolerance) {
+		double slack = 0.0;
+		return ((accuracy(slack) < tolerance) && (slack == 0));
+	}
+
+	double mb_sqr(double r) {
+		return r * r;
+	}
 }
diff --git a/moa/src/main/java/moa/cluster/SphereCluster.java b/moa/src/main/java/moa/cluster/SphereCluster.java
index 533ba108e..a3e50acb1 100644
--- a/moa/src/main/java/moa/cluster/SphereCluster.java
+++ b/moa/src/main/java/moa/cluster/SphereCluster.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.cluster;
@@ -29,8 +29,8 @@
 
 /**
  * A simple implementation of the <code>Cluster</code> interface representing
- * spherical clusters. The inclusion probability is one inside the sphere and zero
- * everywhere else.
+ * spherical clusters. The inclusion probability is one inside the sphere and
+ * zero everywhere else.
  *
  */
 public class SphereCluster extends Cluster {
@@ -41,15 +41,14 @@ public class SphereCluster extends Cluster {
 	private double radius;
 	private double weight;
 
-
 	public SphereCluster(double[] center, double radius) {
-		this( center, radius, 1.0 );
+		this(center, radius, 1.0);
 	}
 
 	public SphereCluster() {
 	}
 
-	public SphereCluster( double[] center, double radius, double weightedSize) {
+	public SphereCluster(double[] center, double radius, double weightedSize) {
 		this();
 		this.center = center;
 		this.radius = radius;
@@ -69,10 +68,9 @@ public SphereCluster(int dimensions, double radius, Random random) {
 		this.weight = 0.0;
 	}
 
-
-	public SphereCluster(List<?extends Instance> instances, int dimension){
+	public SphereCluster(List<? extends Instance> instances, int dimension) {
 		this();
-		if(instances == null || instances.size() <= 0)
+		if (instances == null || instances.size() <= 0)
 			return;
 
 		weight = instances.size();
@@ -90,11 +88,10 @@ public SphereCluster(List<?extends Instance> instances, int dimension){
 		mb.clear();
 	}
 
-
 	/**
-	 * Checks whether two <code>SphereCluster</code> overlap based on radius
-	 * NOTE: overlapRadiusDegree only calculates the overlap based
-	 * on the centers and the radi, so not the real overlap
+	 * Checks whether two <code>SphereCluster</code> overlap based on radius NOTE:
+	 * overlapRadiusDegree only calculates the overlap based on the centers and the
+	 * radi, so not the real overlap
 	 *
 	 * TODO: should we do this by MC to get the real overlap???
 	 *
@@ -104,7 +101,6 @@ public SphereCluster(List<?extends Instance> instances, int dimension){
 
 	public double overlapRadiusDegree(SphereCluster other) {
 
-
 		double[] center0 = getCenter();
 		double radius0 = getRadius();
 
@@ -113,11 +109,10 @@ public double overlapRadiusDegree(SphereCluster other) {
 
 		double radiusBig;
 		double radiusSmall;
-		if(radius0 < radius1){
+		if (radius0 < radius1) {
 			radiusBig = radius1;
 			radiusSmall = radius0;
-		}
-		else{
+		} else {
 			radiusBig = radius0;
 			radiusSmall = radius1;
 		}
@@ -129,14 +124,13 @@ public double overlapRadiusDegree(SphereCluster other) {
 		}
 		dist = Math.sqrt(dist);
 
-		if(dist > radiusSmall + radiusBig)
+		if (dist > radiusSmall + radiusBig)
 			return 0;
-		if(dist + radiusSmall <= radiusBig){
-			//one lies within the other
+		if (dist + radiusSmall <= radiusBig) {
+			// one lies within the other
 			return 1;
-		}
-		else{
-			return (radiusSmall+radiusBig-dist)/(2*radiusSmall);
+		} else {
+			return (radiusSmall + radiusBig - dist) / (2 * radiusSmall);
 		}
 	}
 
@@ -148,14 +142,14 @@ public void combine(SphereCluster cluster) {
 		double other_radius = cluster.getRadius();
 
 		for (int i = 0; i < center.length; i++) {
-			newcenter[i] = (center[i]*getWeight()+other_center[i]*other_weight)/(getWeight()+other_weight);
+			newcenter[i] = (center[i] * getWeight() + other_center[i] * other_weight) / (getWeight() + other_weight);
 		}
 
 		center = newcenter;
 		double r_0 = getRadius() + Math.abs(distance(center, newcenter));
 		double r_1 = other_radius + Math.abs(distance(other_center, newcenter));
 		radius = Math.max(r_0, r_1);
-		weight+= other_weight;
+		weight += other_weight;
 	}
 
 	public void merge(SphereCluster cluster) {
@@ -167,9 +161,9 @@ public void merge(SphereCluster cluster) {
 		double w1 = cluster.getWeight();
 		double r1 = cluster.getRadius();
 
-		//vector
+		// vector
 		double[] v = new double[c0.length];
-		//center distance
+		// center distance
 		double d = 0;
 
 		for (int i = 0; i < c0.length; i++) {
@@ -178,32 +172,28 @@ public void merge(SphereCluster cluster) {
 		}
 		d = Math.sqrt(d);
 
-
-
 		double r = 0;
 		double[] c = new double[c0.length];
 
-		//one lays within the others
-		if(d + r0 <= r1  || d + r1 <= r0){
-			if(d + r0 <= r1){
+		// one lays within the others
+		if (d + r0 <= r1 || d + r1 <= r0) {
+			if (d + r0 <= r1) {
 				r = r1;
 				c = c1;
-			}
-			else{
+			} else {
 				r = r0;
 				c = c0;
 			}
-		}
-		else{
-			r = (r0 + r1 + d)/2.0;
+		} else {
+			r = (r0 + r1 + d) / 2.0;
 			for (int i = 0; i < c.length; i++) {
-				c[i] = c1[i] - v[i]/d * (r1-r);
+				c[i] = c1[i] - v[i] / d * (r1 - r);
 			}
 		}
 
 		setCenter(c);
 		setRadius(r);
-		setWeight(w0+w1);
+		setWeight(w0 + w1);
 
 	}
 
@@ -222,7 +212,7 @@ public double getRadius() {
 		return radius;
 	}
 
-	public void setRadius( double radius ) {
+	public void setRadius(double radius) {
 		this.radius = radius;
 	}
 
@@ -231,7 +221,7 @@ public double getWeight() {
 		return weight;
 	}
 
-	public void setWeight( double weight ) {
+	public void setWeight(double weight) {
 		this.weight = weight;
 	}
 
@@ -245,7 +235,7 @@ public double getInclusionProbability(Instance instance) {
 
 	public double getCenterDistance(Instance instance) {
 		double distance = 0.0;
-		//get the center through getCenter so subclass have a chance
+		// get the center through getCenter so subclass have a chance
 		double[] center = getCenter();
 		for (int i = 0; i < center.length; i++) {
 			double d = center[i] - instance.value(i);
@@ -259,12 +249,12 @@ public double getCenterDistance(SphereCluster other) {
 	}
 
 	/*
-	 * the minimal distance between the surface of two clusters.
-	 * is negative if the two clusters overlap
+	 * the minimal distance between the surface of two clusters. is negative if the
+	 * two clusters overlap
 	 */
 	public double getHullDistance(SphereCluster other) {
 		double distance = 0.0;
-		//get the center through getCenter so subclass have a chance
+		// get the center through getCenter so subclass have a chance
 		double[] center0 = getCenter();
 		double[] center1 = other.getCenter();
 		distance = distance(center0, center1);
@@ -276,29 +266,28 @@ public double getHullDistance(SphereCluster other) {
 	/*
 	 */
 	/**
-	 * When a clusters looses points the new minimal bounding sphere can be
-	 * partly outside of the originating cluster. If a another cluster is
-	 * right next to the original cluster (without overlapping), the new
-	 * cluster can be overlapping with this second cluster. OverlapSave
-	 * will tell you if the current cluster can degenerate so much that it
-	 * overlaps with cluster 'other'
-	 * 
+	 * When a clusters looses points the new minimal bounding sphere can be partly
+	 * outside of the originating cluster. If a another cluster is right next to the
+	 * original cluster (without overlapping), the new cluster can be overlapping
+	 * with this second cluster. OverlapSave will tell you if the current cluster
+	 * can degenerate so much that it overlaps with cluster 'other'
+	 *
 	 * @param other the potentially overlapping cluster
 	 * @return true if cluster can potentially overlap
 	 */
-	public boolean overlapSave(SphereCluster other){
-		//use basic geometry to figure out the maximal degenerated cluster
-		//comes down to Max(radius *(sin alpha + cos alpha)) which is
-		double minDist = Math.sqrt(2)*(getRadius() + other.getRadius());
+	public boolean overlapSave(SphereCluster other) {
+		// use basic geometry to figure out the maximal degenerated cluster
+		// comes down to Max(radius *(sin alpha + cos alpha)) which is
+		double minDist = Math.sqrt(2) * (getRadius() + other.getRadius());
 		double diff = getCenterDistance(other) - minDist;
 
-		if(diff > 0)
+		if (diff > 0)
 			return true;
 		else
 			return false;
 	}
 
-	private double distance(double[] v1, double[] v2){
+	private double distance(double[] v1, double[] v2) {
 		double distance = 0.0;
 		double[] center = getCenter();
 		for (int i = 0; i < center.length; i++) {
@@ -308,15 +297,15 @@ private double distance(double[] v1, double[] v2){
 		return Math.sqrt(distance);
 	}
 
-	public double[] getDistanceVector(Instance instance){
+	public double[] getDistanceVector(Instance instance) {
 		return distanceVector(getCenter(), instance.toDoubleArray());
 	}
 
-	public double[] getDistanceVector(SphereCluster other){
+	public double[] getDistanceVector(SphereCluster other) {
 		return distanceVector(getCenter(), other.getCenter());
 	}
 
-	private double[] distanceVector(double[] v1, double[] v2){
+	private double[] distanceVector(double[] v1, double[] v2) {
 		double[] v = new double[v1.length];
 		for (int i = 0; i < v1.length; i++) {
 			v[i] = v2[i] - v1[i];
@@ -324,15 +313,16 @@ private double[] distanceVector(double[] v1, double[] v2){
 		return v;
 	}
 
- 
 	/**
 	 * Samples this cluster by returning a point from inside it.
+	 * 
 	 * @param random a random number source
 	 * @return a point that lies inside this cluster
 	 */
+	@Override
 	public Instance sample(Random random) {
 		// Create sample in hypersphere coordinates
-		//get the center through getCenter so subclass have a chance
+		// get the center through getCenter so subclass have a chance
 		double[] center = getCenter();
 
 		final int dimensions = center.length;
@@ -342,10 +332,10 @@ public Instance sample(Random random) {
 		final double length = random.nextDouble() * getRadius();
 
 		double lastValue = 1.0;
-		for (int i = 0; i < dimensions-1; i++) {
+		for (int i = 0; i < dimensions - 1; i++) {
 			double angle = random.nextDouble() * 2 * Math.PI;
-			sin[i] = lastValue * Math.sin( angle ); // Store cumulative values
-			cos[i] = Math.cos( angle );
+			sin[i] = lastValue * Math.sin(angle); // Store cumulative values
+			cos[i] = Math.cos(angle);
 			lastValue = sin[i];
 		}
 
@@ -353,15 +343,15 @@ public Instance sample(Random random) {
 		double res[] = new double[dimensions];
 
 		// First value uses only cosines
-		res[0] = center[0] + length*cos[0];
+		res[0] = center[0] + length * cos[0];
 
 		// Loop through 'middle' coordinates which use cosines and sines
-		for (int i = 1; i < dimensions-1; i++) {
-			res[i] = center[i] + length*sin[i-1]*cos[i];
+		for (int i = 1; i < dimensions - 1; i++) {
+			res[i] = center[i] + length * sin[i - 1] * cos[i];
 		}
 
 		// Last value uses only sines
-		res[dimensions-1] = center[dimensions-1] + length*sin[dimensions-2];
+		res[dimensions - 1] = center[dimensions - 1] + length * sin[dimensions - 2];
 
 		return new DenseInstance(1.0, res);
 	}
@@ -373,5 +363,4 @@ protected void getClusterSpecificInfo(ArrayList<String> infoTitle, ArrayList<Str
 		infoValue.add(Double.toString(getRadius()));
 	}
 
-
 }
diff --git a/moa/src/main/java/moa/clusterers/ClusterGenerator.java b/moa/src/main/java/moa/clusterers/ClusterGenerator.java
deleted file mode 100644
index b52225979..000000000
--- a/moa/src/main/java/moa/clusterers/ClusterGenerator.java
+++ /dev/null
@@ -1,370 +0,0 @@
-/*
- *    ClusterGenerator.java
- *    Copyright (C) 2010 RWTH Aachen University, Germany
- *    @author Jansen (moa@cs.rwth-aachen.de)
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Random;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.cluster.Clustering;
-import moa.cluster.SphereCluster;
-import moa.core.Measurement;
-import moa.gui.visualization.DataPoint;
-
-public class ClusterGenerator extends AbstractClusterer{
-
-	private static final long serialVersionUID = 1L;
-
-	public IntOption timeWindowOption = new IntOption("timeWindow",
-			't', "Rang of the window.", 1000);
-
-    public FloatOption radiusDecreaseOption = new FloatOption("radiusDecrease", 'r',
-                "The average radii of the centroids in the model.", 0, 0, 1);
-
-    public FloatOption radiusIncreaseOption = new FloatOption("radiusIncrease", 'R',
-                "The average radii of the centroids in the model.", 0, 0, 1);
-
-    public FloatOption positionOffsetOption = new FloatOption("positionOffset", 'p',
-                "The average radii of the centroids in the model.", 0, 0, 1);
-
-    public FloatOption clusterRemoveOption = new FloatOption("clusterRemove", 'D',
-                "Deletes complete clusters from the clustering.", 0, 0, 1);
-
-    public FloatOption joinClustersOption = new FloatOption("joinClusters", 'j',
-            "Join two clusters if their hull distance is less minRadius times this factor.", 0, 0, 1);
-
-    public FloatOption clusterAddOption = new FloatOption("clusterAdd", 'A',
-                "Adds additional clusters.", 0, 0, 1);
-
-    private static double err_intervall_width = 0.0;
-    private ArrayList<DataPoint> points;
-    private int instanceCounter;
-    private int windowCounter;
-    private Random random;
-    private Clustering sourceClustering = null;
-
-    @Override
-    public void resetLearningImpl() {
-        points = new ArrayList<DataPoint>();
-        instanceCounter = 0;
-        windowCounter = 0;
-        random = new Random(227);
-
-        //joinClustersOption.set();
-        //evaluateMicroClusteringOption.set();
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        if(windowCounter >= timeWindowOption.getValue()){
-            points.clear();
-            windowCounter = 0;
-        }
-        windowCounter++;
-        instanceCounter++;
-        points.add( new DataPoint(inst,instanceCounter));
-    }
-
-    @Override
-    public boolean implementsMicroClusterer() {
-        return true;
-    }
-
-
-    public void setSourceClustering(Clustering source){
-        sourceClustering = source;
-    }
-    
-    @Override
-    public Clustering getMicroClusteringResult() {
-        //System.out.println("Numcluster:"+clustering.size()+" / "+num);
-        //Clustering source_clustering = new Clustering(points, overlapThreshold, microInitMinPoints);
-        if(sourceClustering == null){
-
-            System.out.println("You need to set a source clustering for the ClusterGenerator to work");
-            return null;
-        }
-        return alterClustering(sourceClustering);
-    }
-
-
-
-    public Clustering getClusteringResult(){
-        sourceClustering = new Clustering(points);
-//        if(sourceClustering == null){
-//            System.out.println("You need to set a source clustering for the ClusterGenerator to work");
-//            return null;
-//        }
-        return alterClustering(sourceClustering);
-    }
-
-
-    private Clustering alterClustering(Clustering scclustering){
-        //percentage of the radius that will be cut off
-        //0: no changes to radius
-        //1: radius of 0
-        double errLevelRadiusDecrease = radiusDecreaseOption.getValue();
-
-        //0: no changes to radius
-        //1: radius 100% bigger
-        double errLevelRadiusIncrease = radiusIncreaseOption.getValue();
-
-        //0: no changes
-        //1: distance between centers is 2 * original radius
-        double errLevelPosition = positionOffsetOption.getValue();
-
-
-        int numRemoveCluster = (int)(clusterRemoveOption.getValue()*scclustering.size());
-
-        int numAddCluster = (int)(clusterAddOption.getValue()*scclustering.size());
-
-        for (int c = 0; c < numRemoveCluster; c++) {
-            int delId = random.nextInt(scclustering.size());
-            scclustering.remove(delId);
-        }
-
-        int numCluster = scclustering.size();
-        double[] err_seeds = new double[numCluster];
-        double err_seed_sum = 0.0;
-        double tmp_seed;
-        for (int i = 0; i < numCluster; i++) {
-            tmp_seed = random.nextDouble();
-            err_seeds[i] = err_seed_sum + tmp_seed;
-            err_seed_sum+= tmp_seed;
-        }
-
-        double sumWeight = 0;
-        for (int i = 0; i <numCluster; i++) {
-            sumWeight+= scclustering.get(i).getWeight();
-        }
-
-        Clustering clustering = new Clustering();
-
-        for (int i = 0; i <numCluster; i++) {
-            if(!(scclustering.get(i) instanceof SphereCluster)){
-                System.out.println("Not a Sphere Cluster");
-                continue;
-            }
-            SphereCluster sourceCluster = (SphereCluster)scclustering.get(i);
-            double[] center = Arrays.copyOf(sourceCluster.getCenter(),sourceCluster.getCenter().length);
-            double weight = sourceCluster.getWeight();
-            double radius = sourceCluster.getRadius();
-
-            //move cluster center
-            if(errLevelPosition >0){
-                double errOffset = random.nextDouble()*err_intervall_width/2.0;
-                double errOffsetDirection = ((random.nextBoolean())? 1 : -1);
-                double level = errLevelPosition + errOffsetDirection * errOffset;
-                double[] vector = new double[center.length];
-                double vectorLength = 0;
-                for (int d = 0; d < center.length; d++) {
-                    vector[d] = (random.nextBoolean()?1:-1)*random.nextDouble();
-                    vectorLength += Math.pow(vector[d],2);
-                }
-                vectorLength = Math.sqrt(vectorLength);
-
-                
-                //max is when clusters are next to each other
-                double length = 2 * radius * level;
-
-                for (int d = 0; d < center.length; d++) {
-                    //normalize length and then strecht to reach error position
-                    vector[d]=vector[d]/vectorLength*length;
-                }
-//                System.out.println("Center "+Arrays.toString(center));
-//                System.out.println("Vector "+Arrays.toString(vector));
-                //check if error position is within bounds
-                double [] newCenter = new double[center.length];
-                for (int d = 0; d < center.length; d++) {
-                    //check bounds, otherwise flip vector
-                    if(center[d] + vector[d] >= 0 && center[d] + vector[d] <= 1){
-                        newCenter[d] = center[d] + vector[d];
-                    }
-                    else{
-                        newCenter[d] = center[d] + (-1)*vector[d];
-                    }
-                }
-                center = newCenter;
-                for (int d = 0; d < center.length; d++) {
-                    if(newCenter[d] >= 0 && newCenter[d] <= 1){
-                    }
-                    else{
-                        System.out.println("This shouldnt have happend, Cluster center out of bounds:"+Arrays.toString(newCenter));
-                    }
-                }
-                //System.out.println("new Center "+Arrays.toString(newCenter));
-
-            }
-            
-            //alter radius
-            if(errLevelRadiusDecrease > 0 || errLevelRadiusIncrease > 0){
-                double errOffset = random.nextDouble()*err_intervall_width/2.0;
-                int errOffsetDirection = ((random.nextBoolean())? 1 : -1);
-
-                if(errLevelRadiusDecrease > 0 && (errLevelRadiusIncrease == 0 || random.nextBoolean())){
-                    double level = (errLevelRadiusDecrease + errOffsetDirection * errOffset);//*sourceCluster.getWeight()/sumWeight;
-                    level = (level<0)?0:level;
-                    level = (level>1)?1:level;
-                    radius*=(1-level);
-                }
-                else{
-                    double level = errLevelRadiusIncrease + errOffsetDirection * errOffset;
-                    level = (level<0)?0:level;
-                    level = (level>1)?1:level;
-                    radius+=radius*level;
-                }
-            }
-
-            SphereCluster newCluster = new SphereCluster(center, radius, weight);
-            newCluster.setMeasureValue("Source Cluster", "C"+sourceCluster.getId());
-
-            clustering.add(newCluster);
-        }
-
-        if(joinClustersOption.getValue() > 0){
-            clustering = joinClusters(clustering);
-        }
-
-        //add new clusters by copying clusters and set a random center
-        for (int c = 0; c < numAddCluster; c++) {
-            int copyId = random.nextInt(clustering.size());
-            SphereCluster scorg = (SphereCluster)clustering.get(copyId);
-            int dim = scorg.getCenter().length;
-            double[] center = new double [dim];
-            double radius = scorg.getRadius();
-
-            boolean outofbounds = true;
-            int tryCounter = 0;
-            while(outofbounds && tryCounter < 20){
-                tryCounter++;
-                outofbounds = false;
-                for (int j = 0; j < center.length; j++) {
-                     center[j] = random.nextDouble();
-                     if(center[j]- radius < 0 || center[j] + radius > 1){
-                        outofbounds = true;
-                        break;
-                     }
-                }
-            }
-            if(outofbounds){
-                System.out.println("Coludn't place additional cluster");
-            }
-            else{
-                SphereCluster scnew = new SphereCluster(center, radius, scorg.getWeight()/2);
-                scorg.setWeight(scorg.getWeight()-scnew.getWeight());
-                clustering.add(scnew);
-            }
-        }
-
-        return clustering;
-
-    }
-
-
-
-    private Clustering joinClusters(Clustering clustering){
-
-        double radiusFactor = joinClustersOption.getValue();
-        boolean[] merged = new boolean[clustering.size()];
-
-        Clustering mclustering = new Clustering();
-
-        if(radiusFactor >0){
-            for (int c1 = 0; c1 < clustering.size(); c1++) {
-                SphereCluster sc1 = (SphereCluster) clustering.get(c1);
-                double minDist = Double.MAX_VALUE;
-                double minOver = 1;
-                int maxindexCon = -1;
-                int maxindexOver = -1;
-                for (int c2 = 0; c2 < clustering.size(); c2++) {
-                    SphereCluster sc2 = (SphereCluster) clustering.get(c2);
-//                    double over = sc1.overlapRadiusDegree(sc2);
-//                    if(over > 0 && over < minOver){
-//                       minOver = over;
-//                       maxindexOver = c2;
-//                    }
-                    double dist = sc1.getHullDistance(sc2);
-                    double threshold = Math.min(sc1.getRadius(), sc2.getRadius())*radiusFactor;
-                    if(dist > 0 && dist < minDist && dist < threshold){
-                            minDist = dist;
-                            maxindexCon = c2;
-                    }
-                }
-                int maxindex = -1;
-                if(maxindexOver!=-1)
-                    maxindex = maxindexOver;
-                else
-                    maxindex = maxindexCon;
-
-                if(maxindex!=-1 && !merged[c1]){
-                    merged[c1]=true;
-                    merged[maxindex]=true;
-                    SphereCluster scnew = new SphereCluster(sc1.getCenter(),sc1.getRadius(),sc1.getWeight());
-                    SphereCluster sc2 = (SphereCluster) clustering.get(maxindex);
-                    scnew.merge(sc2);
-                    mclustering.add(scnew);
-                }
-            }
-        }
-
-        for (int i = 0; i < merged.length; i++) {
-            if(!merged[i])
-                 mclustering.add(clustering.get(i));
-        }
-
-
-        return mclustering;
-
-    }
-
-
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        throw new UnsupportedOperationException("Not supported yet.");
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        throw new UnsupportedOperationException("Not supported yet.");
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return false;
-    }
-
-    @Override
-    public boolean  keepClassLabel(){
-        return true;
-    }
-
-    public Prediction getPredictionForInstance(Instance inst) {
-        return null;
-    }
-}
-
-
diff --git a/moa/src/main/java/moa/clusterers/CobWeb.java b/moa/src/main/java/moa/clusterers/CobWeb.java
deleted file mode 100644
index ac3dc5673..000000000
--- a/moa/src/main/java/moa/clusterers/CobWeb.java
+++ /dev/null
@@ -1,997 +0,0 @@
-/*
- *    CobWeb.java
- *    Copyright (C) 2009 University of Waikato, Hamilton, New Zealand
- *    @author Mark Hall (mhall@cs.waikato.ac.nz)
- * 
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.clusterers;
-
-import java.io.Serializable;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.cluster.Clustering;
-import moa.cluster.SphereCluster;
-import moa.core.FastVector;
-import moa.core.Measurement;
-import moa.core.StringUtils;
-import weka.core.AttributeStats;
-import weka.experiment.Stats;
-import weka.filters.unsupervised.attribute.Add;
-
-/**
- * Class implementing the Cobweb and Classit clustering algorithms.
- * See: http://en.wikipedia.org/wiki/Cobweb_%28clustering%29
- * 
- * Citation: D. Fisher (1987). 
- * Knowledge acquisition via incremental conceptual clustering. 
- * Machine Learning. 2(2):139-172.
- **/
-public class CobWeb extends AbstractClusterer {
-
-    private static final long serialVersionUID = 1L;
-    public FloatOption acuityOption = new FloatOption("acuity",
-            'a', "Acuity (minimum standard deviation)", 1.0, 0.0, 90.0);
-    public FloatOption cutoffOption = new FloatOption("cutoff",
-            'c', "Cutoff (minimum category utility)", 0.002, 0.0, 90.0); //0.01 * Cobweb.m_normal
-//    public IntOption randomSeedOption = new IntOption("randomSeed", 'r',
-//            "Seed for random noise.", 1);	//42
-
-    /**
-     * Inner class handling node operations for Cobweb.
-     *
-     * @see Serializable
-     */
-    private class CNode implements Serializable {
-
-        /** for serialization */
-        static final long serialVersionUID = 3452097436933325631L;
-        /**
-         * Within cluster attribute statistics
-         */
-        private AttributeStats[] m_attStats;
-        /**
-         * Number of attributes
-         */
-        private int m_numAttributes;
-        /**
-         * Instances at this node
-         */
-        protected InstancesHeader m_clusterInstances = null;
-        /**
-         * Children of this node
-         */
-        private FastVector m_children = null;
-        /**
-         * Total instances at this node
-         */
-        private double m_totalInstances = 0.0;
-        /**
-         * Cluster number of this node
-         */
-        private int m_clusterNum = -1;
-
-        /**
-         * Creates an empty <code>CNode</code> instance.
-         *
-         * @param numAttributes the number of attributes in the data
-         */
-        public CNode(int numAttributes) {
-            m_numAttributes = numAttributes;
-        }
-
-        /**
-         * Creates a new leaf <code>CNode</code> instance.
-         *
-         * @param numAttributes the number of attributes in the data
-         * @param leafInstance the instance to store at this leaf
-         */
-        public CNode(int numAttributes, Instance leafInstance) {
-            this(numAttributes);
-            if (m_clusterInstances == null) {
-		//System.out.println(leafInstance.numAttributes()+"-"+leafInstance.value(0)+"-"+leafInstance.value(1)+"-"+leafInstance.value(2));
-		//System.out.println(leafInstance.numAttributes()+"-"+leafInstance.attribute(0).type()+"-"+leafInstance.attribute(1).type()+"-"+leafInstance.attribute(2).type());
-                m_clusterInstances = new InstancesHeader(leafInstance.dataset(), 1);
-            }
-            m_clusterInstances.add(leafInstance);
-            updateStats(leafInstance, false);
-        }
-
-        /**
-         * Adds an instance to this cluster.
-         *
-         * @param newInstance the instance to add
-         */
-        protected void addInstance(Instance newInstance) {
-            // Add the instance to this cluster
-
-            if (m_clusterInstances == null) {
-                m_clusterInstances = new InstancesHeader(newInstance.dataset(), 1);
-                m_clusterInstances.add(newInstance);
-                updateStats(newInstance, false);
-                return;
-            } else if (m_children == null) {
-                /* we are a leaf, so make our existing instance(s) into a child
-                and then add the new instance as a child */
-                m_children = new FastVector();
-                CNode tempSubCluster = new CNode(m_numAttributes,
-                        m_clusterInstances.instance(0));
-
-                //	System.out.println("Dumping "+m_clusterInstances.numInstances());
-                for (int i = 1; i < m_clusterInstances.numInstances(); i++) {
-                    tempSubCluster.m_clusterInstances.add(m_clusterInstances.instance(i));
-                    tempSubCluster.updateStats(m_clusterInstances.instance(i), false);
-                }
-                m_children = new FastVector();
-                m_children.addElement(tempSubCluster);
-                m_children.addElement(new CNode(m_numAttributes, newInstance));
-
-                m_clusterInstances.add(newInstance);
-                updateStats(newInstance, false);
-
-                // here is where we check against cutoff (also check cutoff
-                // in findHost)
-                if (categoryUtility() < m_cutoff) {
-                    //	  System.out.println("Cutting (leaf add) ");
-                    m_children = null;
-                }
-                return;
-            }
-
-            // otherwise, find the best host for this instance
-            CNode bestHost = findHost(newInstance, false);
-            if (bestHost != null) {
-                // now add to the best host
-                bestHost.addInstance(newInstance);
-            }
-        }
-
-        /**
-         * Temporarily adds a new instance to each of this nodes children
-         * in turn and computes the category utility.
-         *
-         * @param newInstance the new instance to evaluate
-         * @return an array of category utility values---the result of considering
-         * each child in turn as a host for the new instance
-         * @throws Exception if an error occurs
-         */
-        private double[] cuScoresForChildren(Instance newInstance) {
-            //throws Exception {
-            // look for a host in existing children
-            double[] categoryUtils = new double[m_children.size()];
-
-            // look for a home for this instance in the existing children
-            for (int i = 0; i < m_children.size(); i++) {
-                CNode temp = (CNode) m_children.elementAt(i);
-                // tentitively add the new instance to this child
-                temp.updateStats(newInstance, false);
-                categoryUtils[i] = categoryUtility();
-
-                // remove the new instance from this child
-                temp.updateStats(newInstance, true);
-            }
-            return categoryUtils;
-        }
-
-        private double cuScoreForBestTwoMerged(CNode merged,
-                CNode a, CNode b,
-                Instance newInstance) {//throws Exception {
-
-            double mergedCU = -Double.MAX_VALUE;
-            // consider merging the best and second
-            // best.
-            merged.m_clusterInstances = new InstancesHeader(m_clusterInstances, 1);
-
-            merged.addChildNode(a);
-            merged.addChildNode(b);
-            merged.updateStats(newInstance, false); // add new instance to stats
-            // remove the best and second best nodes
-            m_children.removeElementAt(m_children.indexOf(a));
-            m_children.removeElementAt(m_children.indexOf(b));
-            m_children.addElement(merged);
-            mergedCU = categoryUtility();
-            // restore the status quo
-            merged.updateStats(newInstance, true);
-            m_children.removeElementAt(m_children.indexOf(merged));
-            m_children.addElement(a);
-            m_children.addElement(b);
-            return mergedCU;
-        }
-
-        /**
-         * Finds a host for the new instance in this nodes children. Also
-         * considers merging the two best hosts and splitting the best host.
-         *
-         * @param newInstance the instance to find a host for
-         * @param structureFrozen true if the instance is not to be added to
-         * the tree and instead the best potential host is to be returned
-         * @return the best host
-         * @throws Exception if an error occurs
-         */
-        private CNode findHost(Instance newInstance,
-                boolean structureFrozen) {//throws Exception {
-
-            if (!structureFrozen) {
-                updateStats(newInstance, false);
-            }
-
-            // look for a host in existing children and also consider as a new leaf
-            double[] categoryUtils = cuScoresForChildren(newInstance);
-
-            // make a temporary new leaf for this instance and get CU
-            CNode newLeaf = new CNode(m_numAttributes, newInstance);
-            m_children.addElement(newLeaf);
-            double bestHostCU = categoryUtility();
-            CNode finalBestHost = newLeaf;
-
-            // remove new leaf when seaching for best and second best nodes to
-            // consider for merging and splitting
-            m_children.removeElementAt(m_children.size() - 1);
-
-            // now determine the best host (and the second best)
-            int best = 0;
-            int secondBest = 0;
-            for (int i = 0; i < categoryUtils.length; i++) {
-                if (categoryUtils[i] > categoryUtils[secondBest]) {
-                    if (categoryUtils[i] > categoryUtils[best]) {
-                        secondBest = best;
-                        best = i;
-                    } else {
-                        secondBest = i;
-                    }
-                }
-            }
-
-            CNode a = (CNode) m_children.elementAt(best);
-            CNode b = (CNode) m_children.elementAt(secondBest);
-            if (categoryUtils[best] > bestHostCU) {
-                bestHostCU = categoryUtils[best];
-                finalBestHost = a;
-                //	System.out.println("Node is best");
-            }
-
-            if (structureFrozen) {
-                if (finalBestHost == newLeaf) {
-                    return null; // *this* node is the best host
-                } else {
-                    return finalBestHost;
-                }
-            }
-
-            double mergedCU = -Double.MAX_VALUE;
-            CNode merged = new CNode(m_numAttributes);
-            if (a != b) {
-                mergedCU = cuScoreForBestTwoMerged(merged, a, b, newInstance);
-
-                if (mergedCU > bestHostCU) {
-                    bestHostCU = mergedCU;
-                    finalBestHost = merged;
-                }
-            }
-
-            // Consider splitting the best
-            double splitCU = -Double.MAX_VALUE;
-            double splitBestChildCU = -Double.MAX_VALUE;
-            double splitPlusNewLeafCU = -Double.MAX_VALUE;
-            double splitPlusMergeBestTwoCU = -Double.MAX_VALUE;
-            if (a.m_children != null) {
-                FastVector tempChildren = new FastVector();
-
-                for (int i = 0; i < m_children.size(); i++) {
-                    CNode existingChild = (CNode) m_children.elementAt(i);
-                    if (existingChild != a) {
-                        tempChildren.addElement(existingChild);
-                    }
-                }
-                for (int i = 0; i < a.m_children.size(); i++) {
-                    CNode promotedChild = (CNode) a.m_children.elementAt(i);
-                    tempChildren.addElement(promotedChild);
-                }
-                // also add the new leaf
-                tempChildren.addElement(newLeaf);
-
-                FastVector saveStatusQuo = m_children;
-                m_children = tempChildren;
-                splitPlusNewLeafCU = categoryUtility(); // split + new leaf
-                // remove the new leaf
-                tempChildren.removeElementAt(tempChildren.size() - 1);
-                // now look for best and second best
-                categoryUtils = cuScoresForChildren(newInstance);
-
-                // now determine the best host (and the second best)
-                best = 0;
-                secondBest = 0;
-                for (int i = 0; i < categoryUtils.length; i++) {
-                    if (categoryUtils[i] > categoryUtils[secondBest]) {
-                        if (categoryUtils[i] > categoryUtils[best]) {
-                            secondBest = best;
-                            best = i;
-                        } else {
-                            secondBest = i;
-                        }
-                    }
-                }
-                CNode sa = (CNode) m_children.elementAt(best);
-                CNode sb = (CNode) m_children.elementAt(secondBest);
-                splitBestChildCU = categoryUtils[best];
-
-                // now merge best and second best
-                CNode mergedSplitChildren = new CNode(m_numAttributes);
-                if (sa != sb) {
-                    splitPlusMergeBestTwoCU =
-                            cuScoreForBestTwoMerged(mergedSplitChildren, sa, sb, newInstance);
-                }
-                splitCU = (splitBestChildCU > splitPlusNewLeafCU)
-                        ? splitBestChildCU : splitPlusNewLeafCU;
-                splitCU = (splitCU > splitPlusMergeBestTwoCU)
-                        ? splitCU : splitPlusMergeBestTwoCU;
-
-                if (splitCU > bestHostCU) {
-                    bestHostCU = splitCU;
-                    finalBestHost = this;
-                    //	  tempChildren.removeElementAt(tempChildren.size()-1);
-                } else {
-                    // restore the status quo
-                    m_children = saveStatusQuo;
-                }
-            }
-
-            if (finalBestHost != this) {
-                // can commit the instance to the set of instances at this node
-                m_clusterInstances.add(newInstance);
-            } else {
-                m_numberSplits++;
-            }
-
-            if (finalBestHost == merged) {
-                m_numberMerges++;
-                m_children.removeElementAt(m_children.indexOf(a));
-                m_children.removeElementAt(m_children.indexOf(b));
-                m_children.addElement(merged);
-            }
-
-            if (finalBestHost == newLeaf) {
-                finalBestHost = new CNode(m_numAttributes);
-                m_children.addElement(finalBestHost);
-            }
-
-            if (bestHostCU < m_cutoff) {
-                if (finalBestHost == this) {
-                    // splitting was the best, but since we are cutting all children
-                    // recursion is aborted and we still need to add the instance
-                    // to the set of instances at this node
-                    m_clusterInstances.add(newInstance);
-                }
-                m_children = null;
-                finalBestHost = null;
-            }
-
-            if (finalBestHost == this) {
-                // splitting is still the best, so downdate the stats as
-                // we'll be recursively calling on this node
-                updateStats(newInstance, true);
-            }
-
-            return finalBestHost;
-        }
-
-        /**
-         * Adds the supplied node as a child of this node. All of the child's
-         * instances are added to this nodes instances
-         *
-         * @param child the child to add
-         */
-        protected void addChildNode(CNode child) {
-            for (int i = 0; i < child.m_clusterInstances.numInstances(); i++) {
-                Instance temp = child.m_clusterInstances.instance(i);
-                m_clusterInstances.add(temp);
-                updateStats(temp, false);
-            }
-
-            if (m_children == null) {
-                m_children = new FastVector();
-            }
-            m_children.addElement(child);
-        }
-
-        /**
-         * Computes the utility of all children with respect to this node
-         *
-         * @return the category utility of the children with respect to this node.
-         * @throws Exception if there are no children
-         */
-        protected double categoryUtility() {// {throws Exception {
-
-            // if (m_children == null) {
-            //throw new Exception("categoryUtility: No children!");
-            // }
-
-            double totalCU = 0;
-
-            for (int i = 0; i < m_children.size(); i++) {
-                CNode child = (CNode) m_children.elementAt(i);
-                totalCU += categoryUtilityChild(child);
-            }
-
-            totalCU /= (double) m_children.size();
-            return totalCU;
-        }
-
-        /**
-         * Computes the utility of a single child with respect to this node
-         *
-         * @param child the child for which to compute the utility
-         * @return the utility of the child with respect to this node
-         * @throws Exception if something goes wrong
-         */
-        protected double categoryUtilityChild(CNode child) {//throws Exception {
-
-            double sum = 0;
-            for (int i = 0; i < m_numAttributes; i++) {
-                if (m_clusterInstances.attribute(i).isNominal()) {
-                    for (int j = 0;
-                            j < m_clusterInstances.attribute(i).numValues(); j++) {
-                        double x = child.getProbability(i, j);
-                        double y = getProbability(i, j);
-                        sum += (x * x) - (y * y);
-                    }
-                } else {
-                    // numeric attribute
-                    sum += ((m_normal / child.getStandardDev(i))
-                            - (m_normal / getStandardDev(i)));
-
-                }
-            }
-            return (child.m_totalInstances / m_totalInstances) * sum;
-        }
-
-        /**
-         * Returns the probability of a value of a nominal attribute in this node
-         *
-         * @param attIndex the index of the attribute
-         * @param valueIndex the index of the value of the attribute
-         * @return the probability
-         * @throws Exception if the requested attribute is not nominal
-         */
-        protected double getProbability(int attIndex, int valueIndex) {
-            //throws Exception {
-
-            //  if (!m_clusterInstances.attribute(attIndex).isNominal()) {
-            //throw new Exception("getProbability: attribute is not nominal");
-            //  }
-
-            if (m_attStats[attIndex].totalCount <= 0) {
-                return 0;
-            }
-
-            return (double) m_attStats[attIndex].nominalCounts[valueIndex]
-                    / (double) m_attStats[attIndex].totalCount;
-        }
-
-        /**
-         * Returns the standard deviation of a numeric attribute
-         *
-         * @param attIndex the index of the attribute
-         * @return the standard deviation
-         * @throws Exception if an error occurs
-         */
-        protected double getStandardDev(int attIndex) { //throws Exception {
-            //  if (!m_clusterInstances.attribute(attIndex).isNumeric()) {
-            //throw new Exception("getStandardDev: attribute is not numeric");
-            // }
-
-            m_attStats[attIndex].numericStats.calculateDerived();
-            double stdDev = m_attStats[attIndex].numericStats.stdDev;
-            if (Double.isNaN(stdDev) || Double.isInfinite(stdDev)) {
-                return m_acuity;
-            }
-
-            return Math.max(m_acuity, stdDev);
-        }
-
-        /**
-         * Update attribute stats using the supplied instance.
-         *
-         * @param updateInstance the instance for updating
-         * @param delete true if the values of the supplied instance are
-         * to be removed from the statistics
-         */
-        protected void updateStats(Instance updateInstance,
-                boolean delete) {
-
-            if (m_attStats == null) {
-                m_attStats = new AttributeStats[m_numAttributes];
-                for (int i = 0; i < m_numAttributes; i++) {
-                    m_attStats[i] = new AttributeStats();
-                    if (m_clusterInstances.attribute(i).isNominal()) {
-                        m_attStats[i].nominalCounts =
-                                new int[m_clusterInstances.attribute(i).numValues()];
-                    } else {
-                        m_attStats[i].numericStats = new Stats();
-                    }
-                }
-            }
-            for (int i = 0; i < m_numAttributes; i++) {
-                if (!updateInstance.isMissing(i)) {
-                    double value = updateInstance.value(i);
-                    if (m_clusterInstances.attribute(i).isNominal()) {
-                        m_attStats[i].nominalCounts[(int) value] += (delete)
-                                ? (-1.0 * updateInstance.weight())
-                                : updateInstance.weight();
-                        m_attStats[i].totalCount += (delete)
-                                ? (-1.0 * updateInstance.weight())
-                                : updateInstance.weight();
-                    } else {
-                        if (delete) {
-                            m_attStats[i].numericStats.subtract(value,
-                                    updateInstance.weight());
-                        } else {
-                            m_attStats[i].numericStats.add(value, updateInstance.weight());
-                        }
-                    }
-                }
-            }
-            m_totalInstances += (delete)
-                    ? (-1.0 * updateInstance.weight())
-                    : (updateInstance.weight());
-        }
-
-        /**
-         * Recursively assigns numbers to the nodes in the tree.
-         *
-         * @param cl_num an <code>int[]</code> value
-         * @throws Exception if an error occurs
-         */
-        private void assignClusterNums(int[] cl_num) { //throws Exception {
-            // if (m_children != null && m_children.size() < 2) {
-            //throw new Exception("assignClusterNums: tree not built correctly!");
-            // }
-
-            m_clusterNum = cl_num[0];
-            cl_num[0]++;
-            if (m_children != null) {
-                for (int i = 0; i < m_children.size(); i++) {
-                    CNode child = (CNode) m_children.elementAt(i);
-                    child.assignClusterNums(cl_num);
-                }
-            }
-        }
-
-        /**
-         * Recursively build a string representation of the Cobweb tree
-         *
-         * @param depth depth of this node in the tree
-         * @param text holds the string representation
-         */
-        protected void dumpTree(int depth, StringBuffer text) {
-
-            if (depth == 0) {
-                determineNumberOfClusters();
-            }
-
-            if (m_children == null) {
-                text.append("\n");
-                for (int j = 0; j < depth; j++) {
-                    text.append("|   ");
-                }
-                text.append("leaf " + m_clusterNum + " ["
-                        + m_clusterInstances.numInstances() + "]");
-            } else {
-                for (int i = 0; i < m_children.size(); i++) {
-                    text.append("\n");
-                    for (int j = 0; j < depth; j++) {
-                        text.append("|   ");
-                    }
-                    text.append("node " + m_clusterNum + " ["
-                            + m_clusterInstances.numInstances()
-                            + "]");
-                    ((CNode) m_children.elementAt(i)).dumpTree(depth + 1, text);
-                }
-            }
-        }
-
-        /**
-         * Returns the instances at this node as a string. Appends the cluster
-         * number of the child that each instance belongs to.
-         *
-         * @return a <code>String</code> value
-         * @throws Exception if an error occurs
-         */
-        protected String dumpData() { //throws Exception {
-            if (m_children == null) {
-                return m_clusterInstances.toString();
-            }
-
-            // construct instances string with cluster numbers attached
-            CNode tempNode = new CNode(m_numAttributes);
-            tempNode.m_clusterInstances = new InstancesHeader(m_clusterInstances, 1);
-            for (int i = 0; i < m_children.size(); i++) {
-                tempNode.addChildNode((CNode) m_children.elementAt(i));
-            }
-            InstancesHeader tempInst = tempNode.m_clusterInstances;
-            tempNode = null;
-
-            Add af = new Add();
-            af.setAttributeName("Cluster");
-            String labels = "";
-            for (int i = 0; i < m_children.size(); i++) {
-                CNode temp = (CNode) m_children.elementAt(i);
-                labels += ("C" + temp.m_clusterNum);
-                if (i < m_children.size() - 1) {
-                    labels += ",";
-                }
-            }
-            af.setNominalLabels(labels);
-            //af.setInputFormat(tempInst);
-            //tempInst = Filter.useFilter(tempInst, af);
-            tempInst.setRelationName("Cluster " + m_clusterNum);
-
-            int z = 0;
-            for (int i = 0; i < m_children.size(); i++) {
-                CNode temp = (CNode) m_children.elementAt(i);
-                for (int j = 0; j < temp.m_clusterInstances.numInstances(); j++) {
-                    tempInst.instance(z).setValue(m_numAttributes, (double) i);
-                    z++;
-                }
-            }
-            return tempInst.toString();
-        }
-
-        /**
-         * Recursively generate the graph string for the Cobweb tree.
-         *
-         * @param text holds the graph string
-         * @throws Exception if generation fails
-         */
-        protected void graphTree(StringBuffer text) { //throws Exception {
-
-            text.append("N" + m_clusterNum
-                    + " [label=\"" + ((m_children == null)
-                    ? "leaf " : "node ")
-                    + m_clusterNum + " "
-                    + " (" + m_clusterInstances.numInstances()
-                    + ")\" "
-                    + ((m_children == null)
-                    ? "shape=box style=filled " : "")
-                    + (m_saveInstances
-                    ? "data =\n" + dumpData() + "\n,\n"
-                    : "")
-                    + "]\n");
-            if (m_children != null) {
-                for (int i = 0; i < m_children.size(); i++) {
-                    CNode temp = (CNode) m_children.elementAt(i);
-                    text.append("N" + m_clusterNum
-                            + "->"
-                            + "N" + temp.m_clusterNum
-                            + "\n");
-                }
-
-                for (int i = 0; i < m_children.size(); i++) {
-                    CNode temp = (CNode) m_children.elementAt(i);
-                    temp.graphTree(text);
-                }
-            }
-        }
-
-	/**
-         * Recursively build a clustering representation of the Cobweb tree
-         *
-         * @param depth depth of this node in the tree
-         * @param clustering holds the Clustering representation
-         */
-        protected void computeTreeClustering(int depth, Clustering clustering) {
-
-            if (depth == 0) {
-                determineNumberOfClusters();
-            }
-
-            if (m_children == null) {
-		//Append Cluster
-                /*text.append("\n");
-                for (int j = 0; j < depth; j++) {
-                    text.append("|   ");
-                }
-                text.append("leaf " + m_clusterNum + " ["
-                        + m_clusterInstances.numInstances() + "]");
-		clustering.add(SphereCluster(this.coordinates, .05, m_clusterInstances.numInstances()));*/
-	            if (depth == 0) {
-	    		    double [] centroidCoordinates = new double[m_clusterInstances.numAttributes()];
-			    for (int j = 0; j < m_clusterInstances.numAttributes()-1; j++) {						
-				centroidCoordinates[j] = m_clusterInstances.meanOrMode(j);	
-			    }
-			    clustering.add(new SphereCluster(centroidCoordinates, .05, m_clusterInstances.numInstances()));
-	            }
-            } else {
-                for (int i = 0; i < m_children.size(); i++) {
-                    /*text.append("\n");
-                    for (int j = 0; j < depth; j++) {
-                        text.append("|   ");
-                    }
-                    text.append("node " + m_clusterNum + " ["
-                            + m_clusterInstances.numInstances()
-                            + "]");*/
-    		    double [] centroidCoordinates = new double[m_clusterInstances.numAttributes()];
-		    for (int j = 0; j < m_clusterInstances.numAttributes()-1; j++) {						
-			centroidCoordinates[j] = m_clusterInstances.meanOrMode(j);	
-		    }
-		    clustering.add(new SphereCluster(centroidCoordinates, .05, m_clusterInstances.numInstances()));
-                    ((CNode) m_children.elementAt(i)).computeTreeClustering(depth + 1, clustering);
-                }
-            }
-        }
-    }
-    /**
-     * Normal constant.
-     */
-    protected static final double m_normal = 1.0 / (2 * Math.sqrt(Math.PI));
-    /**
-     * Acuity (minimum standard deviation).
-     */
-    protected double m_acuity = 1.0;
-    /**
-     * Cutoff (minimum category utility).
-     */
-    protected double m_cutoff = 0.002;//0.01 * Cobweb.m_normal;
-    /**
-     * Holds the root of the Cobweb tree.
-     */
-    protected CNode m_cobwebTree = null;
-    /**
-     * Number of clusters (nodes in the tree). Must never be queried directly,
-     * only via the method numberOfClusters(). Otherwise it's not guaranteed that
-     * it contains the correct value.
-     *
-     * @see #numberOfClusters()
-     * @see #m_numberOfClustersDetermined
-     */
-    protected int m_numberOfClusters = -1;
-    /** whether the number of clusters was already determined */
-    protected boolean m_numberOfClustersDetermined = false;
-    /** the number of splits that happened */
-    protected int m_numberSplits;
-    /** the number of merges that happened */
-    protected int m_numberMerges;
-    /**
-     * Output instances in graph representation of Cobweb tree (Allows
-     * instances at nodes in the tree to be visualized in the Explorer).
-     */
-    protected boolean m_saveInstances = false;
-    @SuppressWarnings("hiding")
-    public static final String classifierPurposeString = "Cobweb and Classit clustering algorithms: it always compares the best host, adding a new leaf, merging the two best hosts, and splitting the best host when considering where to place a new instance..";
-
-    @Override
-    public void resetLearningImpl() {
-        setAcuity(this.acuityOption.getValue());
-        setCutoff(this.cutoffOption.getValue());
-        m_numberOfClusters = -1;
-        m_cobwebTree = null;
-        m_numberSplits = 0;
-        m_numberMerges = 0;
-    }
-
-    /**
-     * Adds an instance to the clusterer.
-     *
-     * @param newInstance the instance to be added
-     * @throws Exception 	if something goes wrong
-     */
-    // public void updateClusterer(Instance newInstance) throws Exception {
-    @Override
-    public void trainOnInstanceImpl(Instance newInstance) { //throws Exception {
-        m_numberOfClustersDetermined = false;
-
-        if (m_cobwebTree == null) {
-            m_cobwebTree = new CNode(newInstance.numAttributes(), newInstance);
-        } else {
-            m_cobwebTree.addInstance(newInstance);
-        }
-    }
-
-    /**
-     * Classifies a given instance.
-     *
-     * @param instance the instance to be assigned to a cluster
-     * @return the number of the assigned cluster as an interger
-     * if the class is enumerated, otherwise the predicted value
-     * @throws Exception if instance could not be classified
-     * successfully
-     */
-    public Prediction getPredictionForInstance(Instance instance) {
-        //public int clusterInstance(Instance instance) {//throws Exception {
-        CNode host = m_cobwebTree;
-        CNode temp = null;
-
-        determineNumberOfClusters();
-
-        if (this.m_numberOfClusters < 1) {
-            return new ClassificationPrediction();
-        }
-        double[] ret = new double[this.m_numberOfClusters];
-
-        do {
-            if (host.m_children == null) {
-                temp = null;
-                break;
-            }
-
-            host.updateStats(instance, false);
-            temp = host.findHost(instance, true);
-            host.updateStats(instance, true);
-
-            if (temp != null) {
-                host = temp;
-            }
-        } while (temp != null);
-
-        ret[host.m_clusterNum] = 1.0;
-        return new ClassificationPrediction(ret);
-    }
-
-    /**
-     * determines the number of clusters if necessary
-     *
-     * @see #m_numberOfClusters
-     * @see #m_numberOfClustersDetermined
-     */
-    protected void determineNumberOfClusters() {
-        if (!m_numberOfClustersDetermined
-                && (m_cobwebTree != null)) {
-            int[] numClusts = new int[1];
-            numClusts[0] = 0;
-            //  try {
-            m_cobwebTree.assignClusterNums(numClusts);
-            // }
-            // catch (Exception e) {
-//	e.printStackTrace();
-//	numClusts[0] = 0;
-            // }
-            m_numberOfClusters = numClusts[0];
-
-            m_numberOfClustersDetermined = true;
-        }
-    }
-
-    /**
-     * Returns the number of clusters.
-     *
-     * @return the number of clusters
-     */
-    public int numberOfClusters() {
-        determineNumberOfClusters();
-        return m_numberOfClusters;
-    }
-
-    {
-//		return this.observedClassDistribution.getArrayCopy();
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return null;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        StringBuffer text = new StringBuffer();
-        if (m_cobwebTree == null) {
-            StringUtils.appendIndented(out, indent, "Cobweb hasn't been built yet!");
-            StringUtils.appendNewline(out);
-        } else {
-            m_cobwebTree.dumpTree(0, text);
-            StringUtils.appendIndented(out, indent, "CobWeb - ");
-            out.append("Number of merges: "
-                    + m_numberMerges + "\nNumber of splits: "
-                    + m_numberSplits + "\nNumber of clusters: "
-                    + numberOfClusters() + "\n" + text.toString());
-            StringUtils.appendNewline(out);
-        }
-    }
-
-    public boolean isRandomizable() {
-        return false;
-    }
-
-    /**
-     * Generates the graph string of the Cobweb tree
-     *
-     * @return a <code>String</code> value
-     * @throws Exception if an error occurs
-     */
-    public String graph() {// throws Exception {
-        StringBuffer text = new StringBuffer();
-
-        text.append("digraph CobwebTree {\n");
-        m_cobwebTree.graphTree(text);
-        text.append("}\n");
-        return text.toString();
-    }
-
-    /**
-     * set the acuity.
-     * @param a the acuity value
-     */
-    public void setAcuity(double a) {
-        m_acuity = a;
-    }
-
-    /**
-     * get the acuity value
-     * @return the acuity
-     */
-    public double getAcuity() {
-        return m_acuity;
-    }
-
-    /**
-     * set the cutoff
-     * @param c the cutof
-     */
-    public void setCutoff(double c) {
-        m_cutoff = c;
-    }
-
-    /**
-     * get the cutoff
-     * @return the cutoff
-     */
-    public double getCutoff() {
-        return m_cutoff;
-    }
-
-    /**
-     * Get the value of saveInstances.
-     *
-     * @return Value of saveInstances.
-     */
-    public boolean getSaveInstanceData() {
-
-        return m_saveInstances;
-    }
-
-    /**
-     * Set the value of saveInstances.
-     *
-     * @param newsaveInstances Value to assign to saveInstances.
-     */
-    public void setSaveInstanceData(boolean newsaveInstances) {
-
-        m_saveInstances = newsaveInstances;
-    }
-
-    public Clustering getClusteringResult() {
-        //throw new UnsupportedOperationException("Not supported yet.");
-	Clustering result = new Clustering();
-        if (m_cobwebTree == null) {
-            //StringUtils.appendIndented(out, indent, "Cobweb hasn't been built yet!");
-            //StringUtils.appendNewline(out);
-        } else {
-            m_cobwebTree.computeTreeClustering(0,result);
-	    System.out.println("After Number of clusters: "+numberOfClusters() );    
-	}
-	System.out.println("Number of clusters: "+result.size());
-	return result; 
-    }
-
-
-}
-     
-
-
diff --git a/moa/src/main/java/moa/clusterers/KMeans.java b/moa/src/main/java/moa/clusterers/KMeans.java
deleted file mode 100644
index d509f26a7..000000000
--- a/moa/src/main/java/moa/clusterers/KMeans.java
+++ /dev/null
@@ -1,202 +0,0 @@
-/*
- *    KMeans.java
- *    Copyright (C) 2010 RWTH Aachen University, Germany
- *    @author Jansen (moa@cs.rwth-aachen.de)
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import moa.cluster.CFCluster;
-import moa.cluster.Cluster;
-import moa.cluster.Clustering;
-import moa.cluster.SphereCluster;
-
-/**
- * A kMeans implementation for microclusterings. For now it only uses the real centers of the 
- * groundtruthclustering for implementation. There should also be an option to use random 
- * centers. 
- * TODO: random centers
- * TODO: Create a macro clustering interface to make different macro clustering algorithms available 
- * to micro clustering algorithms like clustream, denstream and clustree   
- *
- */
-public class KMeans {
-
-    /**
-     * This kMeans implementation clusters a big number of microclusters 
-     * into a smaller amount of macro clusters. To make it comparable to other 
-     * algorithms it uses the real centers of the ground truth macro clustering
-     * to have the best possible initialization. The quality of resulting 
-     * macro clustering yields an upper bound for kMeans on the underlying 
-     * microclustering.        
-     * 
-     * @param centers of the ground truth clustering 
-     * @param data list of microclusters
-     * @return
-     */
-    public static Clustering kMeans(Cluster[] centers, List<? extends Cluster> data ) {
-        int k = centers.length;
-
-	int dimensions = centers[0].getCenter().length;
-
-	ArrayList<ArrayList<Cluster>> clustering =
-		new ArrayList<ArrayList<Cluster>>();
-	for ( int i = 0; i < k; i++ ) {
-	    clustering.add( new ArrayList<Cluster>() );
-	}
-
-	int repetitions = 100;
-	while ( repetitions-- >= 0 ) {
-	    // Assign points to clusters
-	    for ( Cluster point : data ) {
-		double minDistance = distance( point.getCenter(), centers[0].getCenter() );
-		int closestCluster = 0;
-		for ( int i = 1; i < k; i++ ) {
-		    double distance = distance( point.getCenter(), centers[i].getCenter() );
-		    if ( distance < minDistance ) {
-			closestCluster = i;
-			minDistance = distance;
-		    }
-		}
-
-		clustering.get( closestCluster ).add( point );
-	    }
-
-	    // Calculate new centers and clear clustering lists
-	    SphereCluster[] newCenters = new SphereCluster[centers.length];
-	    for ( int i = 0; i < k; i++ ) {
-		newCenters[i] = calculateCenter( clustering.get( i ), dimensions );
-		clustering.get( i ).clear();
-	    }
-	    centers = newCenters;
-	}
-
-	return new Clustering( centers );
-    }
-
-    private static double distance(double[] pointA, double [] pointB){
-        double distance = 0.0;
-        for (int i = 0; i < pointA.length; i++) {
-            double d = pointA[i] - pointB[i];
-            distance += d * d;
-        }
-        return Math.sqrt(distance);
-    }
-
-
-    private static SphereCluster calculateCenter( ArrayList<Cluster> cluster, int dimensions ) {
-	double[] res = new double[dimensions];
-	for ( int i = 0; i < res.length; i++ ) {
-	    res[i] = 0.0;
-	}
-
-	if ( cluster.size() == 0 ) {
-	    return new SphereCluster( res, 0.0 );
-	}
-
-	for ( Cluster point : cluster ) {
-            double [] center = point.getCenter();
-            for (int i = 0; i < res.length; i++) {
-               res[i] += center[i];
-            }
-	}
-
-	// Normalize
-	for ( int i = 0; i < res.length; i++ ) {
-	    res[i] /= cluster.size();
-	}
-
-	// Calculate radius
-	double radius = 0.0;
-	for ( Cluster point : cluster ) {
-	    double dist = distance( res, point.getCenter() );
-	    if ( dist > radius ) {
-		radius = dist;
-	    }
-	}
-
-	return new SphereCluster( res, radius );
-    }
-
-    public static Clustering gaussianMeans(Clustering gtClustering, Clustering clustering) {
-        ArrayList<CFCluster> microclusters = new ArrayList<CFCluster>();
-        for (int i = 0; i < clustering.size(); i++) {
-            if (clustering.get(i) instanceof CFCluster) {
-                microclusters.add((CFCluster)clustering.get(i));
-            }
-            else{
-                System.out.println("Unsupported Cluster Type:"+clustering.get(i).getClass()
-                        +". Cluster needs to extend moa.cluster.CFCluster");
-            }
-        }
-        Cluster[] centers = new Cluster[gtClustering.size()];
-        for (int i = 0; i < centers.length; i++) {
-            centers[i] = gtClustering.get(i);
-
-        }
-
-        int k = centers.length;
-	if ( microclusters.size() < k ) {
-	    return new Clustering( new Cluster[0]);
-	}
-
-	Clustering kMeansResult = kMeans( centers, microclusters );
-
-	k = kMeansResult.size();
-	CFCluster[] res = new CFCluster[ k ];
-
-	for ( CFCluster microcluster : microclusters) {
-	    // Find closest kMeans cluster
-	    double minDistance = Double.MAX_VALUE;
-	    int closestCluster = 0;
-	    for ( int i = 0; i < k; i++ ) {
-		double distance = distance( kMeansResult.get(i).getCenter(), microcluster.getCenter() );
-		if ( distance < minDistance ) {
-		    closestCluster = i;
-		    minDistance = distance;
-		}
-	    }
-
-	    // Add to cluster
-	    if ( res[closestCluster] == null ) {
-		res[closestCluster] = (CFCluster)microcluster.copy();
-	    } else {
-		res[closestCluster].add(microcluster);
-	    }
-	}
-
-	// Clean up res
-	int count = 0;
-	for ( int i = 0; i < res.length; i++ ) {
-	    if ( res[i] != null )
-		++count;
-	}
-
-	CFCluster[] cleaned = new CFCluster[count];
-	count = 0;
-	for ( int i = 0; i < res.length; i++ ) {
-	    if ( res[i] != null )
-		cleaned[count++] = res[i];
-	}
-
-	return new Clustering( cleaned );
-    }
-
-}
diff --git a/moa/src/main/java/moa/clusterers/WekaClusteringAlgorithm.java b/moa/src/main/java/moa/clusterers/WekaClusteringAlgorithm.java
deleted file mode 100644
index 402a82243..000000000
--- a/moa/src/main/java/moa/clusterers/WekaClusteringAlgorithm.java
+++ /dev/null
@@ -1,227 +0,0 @@
-/*
- *    WekaClusteringAlgorithm.java
- *    Copyright (C) 2010 RWTH Aachen University, Germany
- *    @author Jansen (moa@cs.rwth-aachen.de)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.clusterers;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import com.github.javacliparser.IntOption;
-import com.github.javacliparser.MultiChoiceOption;
-import com.github.javacliparser.StringOption;
-import com.yahoo.labs.samoa.instances.Attribute;
-import com.yahoo.labs.samoa.instances.DenseInstance;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.cluster.Clustering;
-import moa.core.AutoClassDiscovery;
-import moa.core.AutoExpandVector;
-import moa.core.FastVector;
-import moa.core.Measurement;
-import moa.options.ClassOption;
-import weka.core.Utils;
-
-public class WekaClusteringAlgorithm extends AbstractClusterer {
-
-    private static final long serialVersionUID = 1L;
-    
-    public IntOption horizonOption = new IntOption("horizon",
-            'h', "Range of the window.", 1000);
-    
-    public MultiChoiceOption wekaAlgorithmOption;
-    
-    public StringOption parameterOption = new StringOption("parameter", 'p',
-            "Parameters that will be passed to the weka algorithm. (e.g. '-N 5' for using SimpleKmeans with 5 clusters)", "-N 5 -S 8");
-    
-    private Class<?>[] clustererClasses;
-    
-    private InstancesHeader instances;
-    
-    private weka.clusterers.AbstractClusterer clusterer;
-    
-    protected SamoaToWekaInstanceConverter instanceConverter;
-    
-
-    public WekaClusteringAlgorithm() {
-        clustererClasses = findWekaClustererClasses();
-        String[] optionLabels = new String[clustererClasses.length];
-        String[] optionDescriptions = new String[clustererClasses.length];
-
-        for (int i = 0; i < clustererClasses.length; i++) {
-            optionLabels[i] = clustererClasses[i].getSimpleName();
-            optionDescriptions[i] = clustererClasses[i].getName();
-//			We do have the parameter option info, but not really a place to show it somewhere
-/*
-             //System.out.println(clustererClasses[i].getSimpleName());
-             for (Class c : clustererClasses[i].getInterfaces()) {
-             if (c.equals(weka.core.OptionHandler.class)) {
-             try {
-             Enumeration options = ((weka.core.OptionHandler)clustererClasses[i].newInstance()).listOptions();
-             while(options.hasMoreElements()){
-             weka.core.Option o = (weka.core.Option)options.nextElement(); 
-             System.out.print(o.synopsis()+" ");	
-             } 
-							
-             } catch (InstantiationException e) {
-             e.printStackTrace();
-             } catch (IllegalAccessException e) {
-             e.printStackTrace();
-             }
-			        	
-             }
-             }
-             */
-        }
-
-        if (clustererClasses != null && clustererClasses.length > 0) {
-            wekaAlgorithmOption = new MultiChoiceOption("clusterer", 'w',
-                    "Weka cluster algorithm to use.",
-                    optionLabels, optionDescriptions, 6);
-        } else {
-            horizonOption = null;
-            parameterOption = null;
-
-        }
-
-    }
-
-    @Override
-    public void resetLearningImpl() {
-        try {
-            instances = null;
-            String clistring = clustererClasses[wekaAlgorithmOption.getChosenIndex()].getName();
-            clusterer = (weka.clusterers.AbstractClusterer) ClassOption.cliStringToObject(clistring, weka.clusterers.Clusterer.class, null);
-
-            String rawOptions = parameterOption.getValue();
-            String[] options = rawOptions.split(" ");
-            if (clusterer instanceof weka.core.OptionHandler) {
-                ((weka.core.OptionHandler) clusterer).setOptions(options);
-                Utils.checkForRemainingOptions(options);
-            }
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-        this.instanceConverter = new SamoaToWekaInstanceConverter();
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        if (instances == null) {
-            instances = getDataset(inst.numAttributes(), 0);
-        }
-        instances.add(inst);
-    }
-
-    public Clustering getClusteringResult() {
-        Clustering clustering = null;
-        weka.core.Instances wekaInstances= this.instanceConverter.wekaInstances(instances);
-        try {
-            
-            clusterer.buildClusterer(wekaInstances);
-            int numClusters = clusterer.numberOfClusters();
-            InstancesHeader dataset = getDataset(instances.numAttributes(), numClusters);
-            List<Instance> newInstances = new ArrayList<Instance>() ; //Instances(dataset);
-
-            for (int i = 0; i < wekaInstances.numInstances(); i++) {
-                weka.core.Instance inst = wekaInstances.get(i);
-                int cnum = clusterer.clusterInstance(inst);
-
-                Instance newInst = new DenseInstance(instances.instance(cnum));
-                newInst.insertAttributeAt(inst.numAttributes());
-                newInst.setDataset(dataset);
-                newInst.setClassValue(cnum);
-                newInstances.add(newInst);
-            }
-            clustering = new Clustering(newInstances);
-
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-        instances = null;
-
-        return clustering;
-    }
-
-    public InstancesHeader getDataset(int numdim, int numclass) {
-        FastVector attributes = new FastVector();
-        for (int i = 0; i < numdim; i++) {
-            attributes.addElement(new Attribute("att" + (i + 1)));
-        }
-
-        if (numclass > 0) {
-            FastVector classLabels = new FastVector();
-            for (int i = 0; i < numclass; i++) {
-                classLabels.addElement("class" + (i + 1));
-            }
-            attributes.addElement(new Attribute("class", classLabels));
-        }
-
-        InstancesHeader myDataset = new InstancesHeader("horizion", attributes, 0);
-        if (numclass > 0) {
-            myDataset.setClassIndex(myDataset.numAttributes() - 1);
-        }
-
-        return myDataset;
-    }
-
-    private Class<?>[] findWekaClustererClasses() {
-        AutoExpandVector<Class<?>> finalClasses = new AutoExpandVector<Class<?>>();
-        Class<?>[] classesFound = AutoClassDiscovery.findClassesOfType("weka.clusterers",
-                weka.clusterers.AbstractClusterer.class);
-        for (Class<?> foundClass : classesFound) {
-            finalClasses.add(foundClass);
-        }
-        return finalClasses.toArray(new Class<?>[finalClasses.size()]);
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        throw new UnsupportedOperationException("Not supported yet.");
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-    }
-
-    public boolean isRandomizable() {
-        return false;
-    }
-
-    public Prediction getPredictionForInstance(Instance inst) {
-        return null;
-    }
-
-    @Override
-    public boolean keepClassLabel() {
-        return false;
-    }
-
-    @Override
-    public String getPurposeString() {
-        String purpose = "MOA Clusterer: " + getClass().getCanonicalName();
-        if (clustererClasses == null || clustererClasses.length == 0) {
-            purpose += "\nPlease add weka.jar to the classpath to use Weka clustering algorithms.";
-        }
-        return purpose;
-
-    }
-}
diff --git a/moa/src/main/java/moa/clusterers/clustream/ClustreamKernel.java b/moa/src/main/java/moa/clusterers/clustream/ClustreamKernel.java
deleted file mode 100644
index 73ef8a6a7..000000000
--- a/moa/src/main/java/moa/clusterers/clustream/ClustreamKernel.java
+++ /dev/null
@@ -1,274 +0,0 @@
-/*
- *    ClustreamKernel.java
- *    Copyright (C) 2010 RWTH Aachen University, Germany
- *    @author Jansen (moa@cs.rwth-aachen.de)
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-package moa.clusterers.clustream;
-
-import java.util.ArrayList;
-
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.cluster.CFCluster;
-
-public class ClustreamKernel extends CFCluster {
-	private static final long serialVersionUID = 1L;
-
-	private final static double EPSILON = 0.00005;
-    public static final double MIN_VARIANCE = 1e-50;
-
-    protected double LST;
-    protected double SST;
-
-    int m;
-    double t;
-
-
-    public ClustreamKernel( Instance instance, int dimensions, long timestamp , double t, int m) {
-        super(instance, dimensions);
-        this.t = t;
-        this.m = m;
-        this.LST = timestamp;
-		this.SST = timestamp*timestamp;
-    }
-
-    public ClustreamKernel( ClustreamKernel cluster, double t, int m ) {
-        super(cluster);
-        this.t = t;
-        this.m = m;
-        this.LST = cluster.LST;
-        this.SST = cluster.SST;
-    }
-
-    public void insert( Instance instance, long timestamp ) {
-		N++;
-		LST += timestamp;
-		SST += timestamp*timestamp;
-	
-		for ( int i = 0; i < instance.numValues(); i++ ) {
-		    LS[i] += instance.value(i);
-		    SS[i] += instance.value(i)*instance.value(i);
-		}
-    }
-
-    @Override
-    public void add( CFCluster other2 ) {
-        ClustreamKernel other = (ClustreamKernel) other2;
-		assert( other.LS.length == this.LS.length );
-		this.N += other.N;
-		this.LST += other.LST;
-		this.SST += other.SST;
-	
-		for ( int i = 0; i < LS.length; i++ ) {
-		    this.LS[i] += other.LS[i];
-		    this.SS[i] += other.SS[i];
-		}
-    }
-
-    public double getRelevanceStamp() {
-		if ( N < 2*m )
-		    return getMuTime();
-	
-		return getMuTime() + getSigmaTime() * getQuantile( ((double)m)/(2*N) );
-    }
-
-    private double getMuTime() {
-    	return LST / N;
-    }
-
-    private double getSigmaTime() {
-    	return Math.sqrt(SST/N - (LST/N)*(LST/N));
-    }
-
-    private double getQuantile( double z ) {
-		assert( z >= 0 && z <= 1 );
-		return Math.sqrt( 2 ) * inverseError( 2*z - 1 );
-    }
-
-    @Override
-    public double getRadius() {
-        //trivial cluster
-        if(N == 1) return 0;
-        if(t==1)
-            t=1;
-
-        return getDeviation()*radiusFactor;
-    }
-
-    @Override
-    public CFCluster getCF(){
-        return this;
-    }
-
-
-    private double getDeviation(){
-        double[] variance = getVarianceVector();
-        double sumOfDeviation = 0.0;
-        for (int i = 0; i < variance.length; i++) {
-            double d = Math.sqrt(variance[i]);
-            sumOfDeviation += d;
-        }
-        return sumOfDeviation / variance.length;
-    }
-
-    /**
-     * @return this kernels' center
-     */
-    @Override
-    public double[] getCenter() {
-        assert (!this.isEmpty());
-        double res[] = new double[this.LS.length];
-        for (int i = 0; i < res.length; i++) {
-            res[i] = this.LS[i] / N;
-        }
-        return res;
-    }
-
-    /**
-     * See interface <code>Cluster</code>
-     * @param point
-     * @return
-     */
-    @Override
-    public double getInclusionProbability(Instance instance) {
-        //trivial cluster
-        if(N == 1){
-            double distance = 0.0;
-            for (int i = 0; i < LS.length; i++) {
-                double d = LS[i] - instance.value(i);
-                distance += d * d;
-            }
-            distance = Math.sqrt(distance);
-            if( distance < EPSILON )
-                return 1.0;
-            return 0.0;
-        }
-        else{
-            double dist = calcNormalizedDistance(instance.toDoubleArray());
-            if(dist <= getRadius()){
-                return 1;
-            }
-            else{
-                return 0;
-            }
-//            double res = AuxiliaryFunctions.distanceProbabilty(dist, LS.length);
-//            return res;
-        }
-    }
-
-    private double[] getVarianceVector() {
-        double[] res = new double[this.LS.length];
-        for (int i = 0; i < this.LS.length; i++) {
-            double ls = this.LS[i];
-            double ss = this.SS[i];
-
-            double lsDivN = ls / this.getWeight();
-            double lsDivNSquared = lsDivN * lsDivN;
-            double ssDivN = ss / this.getWeight();
-            res[i] = ssDivN - lsDivNSquared;
-
-            // Due to numerical errors, small negative values can occur.
-            // We correct this by settings them to almost zero.
-            if (res[i] <= 0.0) {
-                if (res[i] > -EPSILON) {
-                    res[i] = MIN_VARIANCE;
-                }
-            }
-            else{
-                
-            }
-        }
-        return res;
-    }
-
-    /**
-     * Check if this cluster is empty or not.
-     * @return <code>true</code> if the cluster has no data points,
-     * <code>false</code> otherwise.
-     */
-    public boolean isEmpty() {
-        return this.N == 0;
-    }
-
-    /**
-     * Calculate the normalized euclidean distance (Mahalanobis distance for
-     * distribution w/o covariances) to a point.
-     * @param other The point to which the distance is calculated.
-     * @return The normalized distance to the cluster center.
-     *
-     * TODO: check whether WEIGHTING is correctly applied to variances
-     */
-    //???????
-    private double calcNormalizedDistance(double[] point) {
-        double[] variance = getVarianceVector();
-        double[] center = getCenter();
-        double res = 0.0;
-
-        for (int i = 0; i < center.length; i++) {
-            double diff = center[i] - point[i];
-            res += (diff * diff);// variance[i];
-        }
-        return Math.sqrt(res);
-    }
-
-        /**
-     * Approximates the inverse error function. Clustream needs this.
-     * @param z
-     */
-    public static double inverseError(double x) {
-        double z = Math.sqrt(Math.PI) * x;
-        double res = (z) / 2;
-
-        double z2 = z * z;
-        double zProd = z * z2; // z^3
-        res += (1.0 / 24) * zProd;
-
-        zProd *= z2;  // z^5
-        res += (7.0 / 960) * zProd;
-
-        zProd *= z2;  // z^7
-        res += (127 * zProd) / 80640;
-
-        zProd *= z2;  // z^9
-        res += (4369 * zProd) / 11612160;
-
-        zProd *= z2;  // z^11
-        res += (34807 * zProd) / 364953600;
-
-        zProd *= z2;  // z^13
-        res += (20036983 * zProd) / 797058662400d;
-
-        return res;
-    }
-
-    @Override
-    protected void getClusterSpecificInfo(ArrayList<String> infoTitle, ArrayList<String> infoValue) {
-        super.getClusterSpecificInfo(infoTitle, infoValue);
-        infoTitle.add("Deviation");
-
-        double[] variance = getVarianceVector();
-        double sumOfDeviation = 0.0;
-        for (int i = 0; i < variance.length; i++) {
-            double d = Math.sqrt(variance[i]);
-            sumOfDeviation += d;
-        }
-
-        sumOfDeviation/= variance.length;
-        
-        infoValue.add(Double.toString(sumOfDeviation));
-    }
-}
diff --git a/moa/src/main/java/moa/clusterers/clustree/ClusKernel.java b/moa/src/main/java/moa/clusterers/clustree/ClusKernel.java
deleted file mode 100644
index fdddc6f31..000000000
--- a/moa/src/main/java/moa/clusterers/clustree/ClusKernel.java
+++ /dev/null
@@ -1,338 +0,0 @@
-/*
- *    ClusKernel.java
- *    Copyright (C) 2010 RWTH Aachen University, Germany
- *    @author Sanchez Villaamil (moa@cs.rwth-aachen.de)
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.clustree;
-
-import java.util.Arrays;
-
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.cluster.CFCluster;
-import moa.cluster.Cluster;
-
-/**
- * Representation of an Entry in the tree
- */
-public class ClusKernel extends CFCluster{
-    /**
-     * Numeric epsilon.
-     */
-    public static final double EPSILON = 0.00000001;
-    public static final double MIN_VARIANCE = 1e-50; // 1e-100; // 0.0000001;
-
-
-    /**
-     * Counting of the number of N as normal N is weighted by how much time passes between
-     * updates. If weighted N is under a threshhold, we may consider
-     * the cluster irrelevant and we can delete it.
-     */
-
-    private double totalN;
-
-    /**
-     * A constructor that makes a Kernel which just represents the given point.
-     * @param point The point to be converted into a corresponding Kernel.
-     * @param numberClasses The number of classes possible for points in this
-     * experiment(<code>Tree</code>).
-     */
-    public ClusKernel(double[] point, int dim) {
-        super(point, dim);
-        this.totalN = 1;
-    }
-
-    /**
-     * Constructor of the Cluster.
-     * @param numberDimensions Dimensionality of the points added that can be
-     * added to this cluster
-     * @param numberClasses The number of classes possible for points in this
-     * experiment(<code>Tree</code>).
-     */
-    protected ClusKernel(int numberDimensions) {
-        super(numberDimensions);
-        this.totalN = 0;
-    }
-
-    /**
-     * Instantiates a copy of the given cluster.
-     * @param other The <code>Cluster</code> of which we make a copy.
-     */
-    protected ClusKernel(ClusKernel other) {
-        super(other);
-        this.totalN = other.getTotalN();
-    }
-
-    /**
-     * Adds the given cluster to this cluster, without making this cluster
-     * older.
-     * @param other
-     */
-    public void add(ClusKernel other) {
-        super.add(other);
-        this.totalN += other.totalN;
-    }
-
-    /**
-     * Make this cluster older bei weighting it and add to this cluster the
-     * given cluster. If we want to add somethin to the cluster, but don't
-     * want to weight it, we should use the function <code>add(Cluster)</code>.
-     * @param other The other cluster to be added to this one.
-     * @param timeDifference The time elapsed between the last update of the
-     * <code>Entry</code> to which this cluster belongs and the update that
-     * caused the call to this function.
-     * @param negLambda A parameter needed to weight the cluster.
-     * @see #add(tree.Kernel)
-     */
-    protected void aggregate(ClusKernel other, long timeDifference, double negLambda) {
-        makeOlder(timeDifference, negLambda);
-        add(other);
-    }
-
-    /**
-     * Make this cluster older. This means multiplying weighted N, LS and SS
-     * with a weight factor given by the time difference and the parameter
-     * negLambda.
-     * @param timeDifference The time elapsed between this current update and
-     * the last one.
-     * @param negLambda
-     */
-    protected void makeOlder(long timeDifference, double negLambda) {
-        if (timeDifference == 0) {
-            return;
-        }
-
-        //double weightFactor = AuxiliaryFunctions.weight(negLambda, timeDifference);
-        assert (negLambda < 0);
-        assert (timeDifference > 0);
-        double weightFactor = Math.pow(2.0, negLambda * timeDifference);
-
-        this.N *= weightFactor;
-        for (int i = 0; i < LS.length; i++) {
-            LS[i] *= weightFactor;
-            SS[i] *= weightFactor;
-        }
-    }
-
-    /**
-     * Calculate the distance to this other cluster. The other cluster is
-     * normaly just a single data point(i.e. N = 1).
-     * @param other The other cluster to which the distance is calculated.
-     * @return The distance between this cluster and the other.
-     */
-    public double calcDistance(ClusKernel other) {
-        // TODO: (Fernando, Felix) Adapt the distance function to the new algorithmn.
-
-        double N1 = this.getWeight();
-        double N2 = other.getWeight();
-
-        double[] thisLS = this.LS;
-        double[] otherLS = other.LS;
-
-        double res = 0.0;
-        for (int i = 0; i < thisLS.length; i++) {
-            double substracted = (thisLS[i] / N1) - (otherLS[i] / N2);
-            res += substracted * substracted;
-        }
-
-        // TODO INFO: added sqrt to the computation [PK 10.09.10] 
-        return Math.sqrt(res);
-    }
-
-    /**
-     * Returns the weighted number of points in the cluster.
-     * @return The weighted number of points in the cluster.
-     */
-    private double getTotalN() {
-        return totalN;
-    }
-
-    /**
-     * Check if this cluster is empty or not.
-     * @return <code>true</code> if the cluster has no data points,
-     * <code>false</code> otherwise.
-     */
-    protected boolean isEmpty() {
-        return this.totalN == 0;
-    }
-
-    /**
-     * Remove all points from this cluster.
-     */
-    protected void clear() {
-        this.totalN = 0;
-        this.N = 0.0;
-        Arrays.fill(this.LS, 0.0);
-        Arrays.fill(this.SS, 0.0);
-    }
-
-    /**
-     * Overwrites the LS, SS and weightedN in this cluster to the values of the
-     * given cluster but adds N and classCount of the given cluster to this one.
-     * This function is useful when the weight of an entry becomes to small, and
-     * we want to forget the information of the old points.
-     * @param other The cluster that should overwrite the information.
-     */
-    protected void overwriteOldCluster(ClusKernel other) {
-        this.totalN = other.totalN;
-        this.N = other.N;
-        //AuxiliaryFunctions.overwriteDoubleArray(this.LS, other.LS);
-        //AuxiliaryFunctions.overwriteDoubleArray(this.SS, other.SS);
-        assert (LS.length == other.LS.length);
-        System.arraycopy(other.LS, 0, LS, 0, LS.length);
-        assert (SS.length == other.SS.length);
-        System.arraycopy(other.SS, 0, SS, 0, SS.length);
-    }
-
-    @Override
-    public double getWeight() {
-        return this.N;
-    }
-
-
-    @Override
-    public CFCluster getCF(){
-        return this;
-    }
-
-
-    /**
-     * @return this kernels' center
-     */
-    public double[] getCenter() {
-        assert (!this.isEmpty());
-        double res[] = new double[this.LS.length];
-        double weightedSize = this.getWeight();
-        for (int i = 0; i < res.length; i++) {
-            res[i] = this.LS[i] / weightedSize;
-        }
-        return res;
-    }
-
-//    @Override
-//    public double getInclusionProbability(Instance instance) {
-//
-//        double dist = calcNormalizedDistance(instance.toDoubleArray());
-//        double res = AuxiliaryFunctions.distanceProbabilty(dist, LS.length);
-//        assert (res >= 0.0 && res <= 1.0) : "Bad confidence " + res + " for"
-//                + " distance " + dist;
-//
-//        return res;
-//    }
-
-    @Override
-    public double getInclusionProbability(Instance instance) {
-        //trivial cluster
-        if(N == 1){
-            double distance = 0.0;
-            for (int i = 0; i < LS.length; i++) {
-                double d = LS[i] - instance.value(i);
-                distance += d * d;
-            }
-            distance = Math.sqrt(distance);
-            if( distance < EPSILON )
-                return 1.0;
-            return 0.0;
-        }
-        else{
-            double dist = calcNormalizedDistance(instance.toDoubleArray());
-            if(dist <= getRadius()){
-                return 1;
-            }
-            else{
-                return 0;
-            }
-//            double res = AuxiliaryFunctions.distanceProbabilty(dist, LS.length);
-//            return res;
-        }
-    }
-
-    /**
-     * See interface <code>Cluster</code>
-     * @return The radius of the cluster.
-     * @see Cluster#getRadius()
-     */
-    @Override
-    public double getRadius() {
-        //trivial cluster
-        if(N == 1) return 0;
-
-        return getDeviation()*radiusFactor;
-    }
-
-
-    private double getDeviation(){
-        double[] variance = getVarianceVector();
-        double sumOfDeviation = 0.0;
-        for (int i = 0; i < variance.length; i++) {
-            double d = Math.sqrt(variance[i]);
-            sumOfDeviation += d;
-        }
-        return sumOfDeviation / variance.length;
-    }
-
-
-    public double[] getVarianceVector() {
-        double[] res = new double[this.LS.length];
-        for (int i = 0; i < this.LS.length; i++) {
-            double ls = this.LS[i];
-            double ss = this.SS[i];
-
-            double lsDivN = ls / this.getWeight();
-            double lsDivNSquared = lsDivN * lsDivN;
-            double ssDivN = ss / this.getWeight();
-            res[i] = ssDivN - lsDivNSquared;
-
-            // Due to numerical errors, small negative values can occur.
-            // We correct this by settings them to almost zero.
-            if (res[i] <= 0.0) {
-                if (res[i] > -EPSILON) {
-                    res[i] = MIN_VARIANCE;
-                }
-            }
-            else{
-
-            }
-        }
-        return res;
-    }
-
-
-    /**
-     * Calculate the normalized euclidean distance (Mahalanobis distance for
-     * distribution w/o covariances) to a point.
-     * @param other The point to which the distance is calculated.
-     * @return The normalized distance to the cluster center.
-     *
-     * TODO: check whether WEIGHTING is correctly applied to variances
-     */
-    //???????
-    private double calcNormalizedDistance(double[] point) {
-        double[] variance = getVarianceVector();
-        double[] center = getCenter();
-        double res = 0.0;
-
-        for (int i = 0; i < center.length; i++) {
-            double diff = center[i] - point[i];
-            res += (diff * diff);// variance[i];
-        }
-        return Math.sqrt(res);
-    }
-
-
-}
diff --git a/moa/src/main/java/moa/clusterers/clustree/ClusTree.java b/moa/src/main/java/moa/clusterers/clustree/ClusTree.java
deleted file mode 100644
index dbccaf2c5..000000000
--- a/moa/src/main/java/moa/clusterers/clustree/ClusTree.java
+++ /dev/null
@@ -1,879 +0,0 @@
-/*
- *    ClusTree.java
- *    Copyright (C) 2010 RWTH Aachen University, Germany
- *    @author Sanchez Villaamil (moa@cs.rwth-aachen.de)
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.clustree;
-
-import java.util.ArrayList;
-import java.util.LinkedList;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.cluster.Clustering;
-import moa.clusterers.AbstractClusterer;
-import moa.clusterers.clustree.util.Budget;
-import moa.clusterers.clustree.util.SimpleBudget;
-import moa.core.Measurement;
-
-/**
- * Citation: ClusTree: Philipp Kranen, Ira Assent, Corinna Baldauf, Thomas Seidl:
- * The ClusTree: indexing micro-clusters for anytime stream mining.
- * Knowl. Inf. Syst. 29(2): 249-272 (2011) 
-*/
-public class ClusTree extends AbstractClusterer{
-	private static final long serialVersionUID = 1L;
-	
-	public IntOption horizonOption = new IntOption("horizon",
-			'h', "Range of the window.", 1000);
-
-    public IntOption maxHeightOption = new IntOption(
-			"maxHeight", 'H',
-			"The maximal height of the tree", getDefaultHeight());
-    
-    public FlagOption breadthFirstStrategyOption = new FlagOption(
-			"breadthFirstStrategy", 'B',
-			"Use breadth first strategy");
-    
-    protected int getDefaultHeight() {
-    	return 8;
-    }
-    
-    private static int INSERTIONS_BETWEEN_CLEANUPS = 10000;
-    /**
-     * The root node of the tree.
-     */
-    protected Node root;
-    // Information about the data represented in this tree.
-    /**
-     * Dimensionality of the data points managed by this tree.
-     */
-    private int numberDimensions;
-    /**
-     * Parameter for the weighting function use to weight the entries.
-     */
-    protected double negLambda;
-    /**
-     * The current height of the tree. Should always be smaller than maxHeight.
-     */
-    private int height;
-    /**
-     * The maximal height of the tree.
-     */
-    protected int maxHeight;
-    /**
-     * This variable is used to keep the inverse height that is stored in every
-     * node correct.
-     */
-    private int numRootSplits;
-    /**
-     * The threshold for the weighting of an Entry. An Entry is irrelevant, if
-     * it is in a leaf and the weightedN of the data Cluster is smaller than
-     * this threshold.
-     * @see Entry#data
-     */
-    private double weightThreshold = 0.05;
-    /**
-     * Number of points inserted into the tree.
-     */
-    private int numberInsertions;
-    private long timestamp;
-
-    /**
-     * Parameter to determine wich strategy to use
-     */
-    //TODO: Add Option for that
-    protected boolean breadthFirstStrat = false;
-    
-    //TODO: cleanup
-    private Entry alsoUpdate;
-    
-    @Override
-    public void resetLearningImpl() {
-        breadthFirstStrat = breadthFirstStrategyOption.isSet();
-        negLambda = (1.0 / (double) horizonOption.getValue())
-                * (Math.log(weightThreshold) / Math.log(2));
-        maxHeight = maxHeightOption.getValue();
-        numberDimensions = -1;
-        root = null;
-        timestamp = 0;
-        height = 0;
-        numRootSplits = 0;
-        numberInsertions = 0;
-    }
-
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return null;
-    }
-
-    public boolean isRandomizable() {
-        return false;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-    }
-
-    public Prediction getPredictionForInstance(Instance inst) {
-        return null;
-    }
-
-    @Override
-    public boolean implementsMicroClusterer() {
-        return true;
-    }
-
-
-
-    @Override
-    public void trainOnInstanceImpl(Instance instance) {
-        timestamp++;
-        
-        //TODO check if instance contains label
-        if(root == null){
-            numberDimensions = instance.numAttributes();
-            root = new Node(numberDimensions, 0);
-        }
-        else{
-            if(numberDimensions!=instance.numAttributes())
-                System.out.println("Wrong dimensionality, expected:"+numberDimensions+ "found:"+instance.numAttributes());
-        }
-
-        ClusKernel newPointAsKernel = new ClusKernel(instance.toDoubleArray(), numberDimensions);
-        insert(newPointAsKernel, new SimpleBudget(1000),timestamp);
-    }
-
-
-    /**
-     * Insert a new point in the <code>Tree</code>. The point should be 
-     * represented as a cluster with a single data point(i.e. N = 1). A
-     * <code>Budget</code> class is also given, which is informed of the number
-     * of operation the tree does, and informs the tree when it does not have
-     * time left and should stop the insertion.
-     * @param newPoint The point to be inserted.
-     * @param budget The budget and statistics recollector for the insertion.
-     * @param timestamp The moment at which this point is inserted.
-     * @see Kernel
-     * @see Budget
-     */
-    public void insert(ClusKernel newPoint, Budget budget, long timestamp) {
-        if (breadthFirstStrat){
-          	insertBreadthFirst(newPoint, budget, timestamp);
-       }
-        else{
-	    	Entry rootEntry = new Entry(this.numberDimensions,
-	                root, timestamp, null, null);
-	        ClusKernel carriedBuffer = new ClusKernel(this.numberDimensions);
-	        Entry toInsertHere = insert(newPoint, carriedBuffer, root, rootEntry,
-	                budget, timestamp);
-	
-	        if (toInsertHere != null) {
-	            this.numRootSplits++;
-	            this.height += this.height < this.maxHeight ? 1 : 0;
-	            
-	            Node newRoot = new Node(this.numberDimensions,
-	                    toInsertHere.getChild().getRawLevel() + 1);
-	            newRoot.addEntry(rootEntry, timestamp);
-	            newRoot.addEntry(toInsertHere, timestamp);
-	            rootEntry.setNode(newRoot);
-	            toInsertHere.setNode(newRoot);
-	            this.root = newRoot;
-	        }
-        }
-
-        this.numberInsertions++;
-        if (this.numberInsertions % INSERTIONS_BETWEEN_CLEANUPS == 0) {
-            cleanUp(this.root, 0);
-        }
-    }
-
-    /**
-     * insert newPoint into the tree using the BreadthFirst strategy, i.e.: insert into
-     * the closest entry in a leaf node.
-     * @param newPoint
-     * @param budget
-     * @param timestamp
-     * @return
-     */
-	private Entry insertBreadthFirst(ClusKernel newPoint, Budget budget, long timestamp) {
-    	//check all leaf nodes and get the one with the closest entry to newPoint
-		Node bestFit = findBestLeafNode(newPoint);
-    	bestFit.makeOlder(timestamp, negLambda);
-    	Entry parent = bestFit.getEntries()[0].getParentEntry(); 	
-    	// Search for an Entry with a weight under the threshold.
-   	    Entry irrelevantEntry = bestFit.getIrrelevantEntry(this.weightThreshold);
-        int numFreeEntries = bestFit.numFreeEntries();
-        Entry newEntry = new Entry(newPoint.getCenter().length,
-    			newPoint, timestamp, parent, bestFit);
-        //if there is space, add it to the node ( doesn't ever occur, since nodes are created with 3 entries) 
-        if (numFreeEntries>0){
-        	bestFit.addEntry(newEntry, timestamp);
-        }
-        //if outdated cluster in this best fitting node, replace it
-         else if (irrelevantEntry != null) {
-	        irrelevantEntry.overwriteOldEntry(newEntry);
-        }
-        //if there is space/outdated cluster on path to top, split. Else merge without split
-        else {
-        	if (existsOutdatedEntryOnPath(bestFit)||!this.hasMaximalSize()){
-	            // We have to split.
-	        	insertHereWithSplit(newEntry, bestFit, timestamp);
-	        }
-        	else {
-	            mergeEntryWithoutSplit(bestFit, newEntry,
-	                    timestamp);
-	        }
-        }
-        //update all nodes on path to top.
-        if (bestFit.getEntries()[0].getParentEntry()!=null)
-        	updateToTop(bestFit.getEntries()[0].getParentEntry().getNode());
-        return null;
-    }
- /**
-  * This method checks if there is an outdated (or empty) entry on the path from node to root.
-  * It updates the weights of nodes on path and then checks if it is outdated.
-  * @param node
-  * @return true if an outdated/empty entry exists on the path
-  */
-	private boolean existsOutdatedEntryOnPath(Node node) {
-    	if (node == root){
-    		node.makeOlder(timestamp, negLambda);
-    		return node.getIrrelevantEntry(this.weightThreshold)!=null;
-    	}
-    	do{
-    		node = node.getEntries()[0].getParentEntry().getNode();
-    		node.makeOlder(timestamp, negLambda);
-    		for (Entry e : node.getEntries()){
-    			e.recalculateData();
-    		}
-    		if (node.numFreeEntries()>0)
-    			return true;
-    		if (node.getIrrelevantEntry(this.weightThreshold)!=null)
-    			return true;
-    	}while(node.getEntries()[0].getParentEntry()!=null);
-		return false;
-	}
-    
-    /**
-     * recalculates data for all entries, that lie on the path from the root to the 
-     * Entry toUpdate.
-     */
-	private void updateToTop(Node toUpdate) {
-    	while(toUpdate!=null){
-    		for (Entry e: toUpdate.getEntries())
-    			e.recalculateData();
-    		if (toUpdate.getEntries()[0].getParentEntry()==null)
-    			break;
-    		toUpdate=toUpdate.getEntries()[0].getParentEntry().getNode();
-    	}
-	}
-
-	/**
-	 * Method called by insertBreadthFirst.
-	 * @param toInsert
-	 * @param insertNode
-	 * @param timestamp
-	 * @return
-	 */
-	private Entry insertHereWithSplit(Entry toInsert, Node insertNode,
-			long timestamp) {
-		//Handle root split
-   	    if (insertNode.getEntries()[0].getParentEntry()==null){
-   	    	root.makeOlder(timestamp, negLambda);
-   	    	Entry irrelevantEntry = insertNode.getIrrelevantEntry(this.weightThreshold);
-   	        int numFreeEntries = insertNode.numFreeEntries();
-   	        if (irrelevantEntry != null) {
-   		        irrelevantEntry.overwriteOldEntry(toInsert);
-   	        }
-   	        else if (numFreeEntries>0){
-   	        	insertNode.addEntry(toInsert, timestamp);
-   	        }
-   	        else{
-	            this.numRootSplits++;
-	            this.height += this.height < this.maxHeight ? 1 : 0;
-	            Entry oldRootEntry = new Entry(this.numberDimensions,
-	                    root, timestamp, null, null);
-	            Node newRoot = new Node(this.numberDimensions,
-	                    this.height);
-	            Entry newRootEntry = split(toInsert, root, oldRootEntry, timestamp);
-	            newRoot.addEntry(oldRootEntry, timestamp);
-	            newRoot.addEntry(newRootEntry, timestamp);
-	            this.root = newRoot;
-	            for (Entry c : oldRootEntry.getChild().getEntries())
-	            	c.setParentEntry(root.getEntries()[0]);
-	            for (Entry c : newRootEntry.getChild().getEntries())
-	            	c.setParentEntry(root.getEntries()[1]);
-   	        }
-            return null;
-   	    }
-   	    insertNode.makeOlder(timestamp, negLambda);
-    	Entry irrelevantEntry = insertNode.getIrrelevantEntry(this.weightThreshold);
-        int numFreeEntries = insertNode.numFreeEntries();
-        if (irrelevantEntry != null) {
-	        irrelevantEntry.overwriteOldEntry(toInsert);
-        }
-        else if (numFreeEntries>0){
-        	insertNode.addEntry(toInsert, timestamp);
-        }
-        else {
-	            // We have to split.
-	        	Entry parentEntry = insertNode.getEntries()[0].getParentEntry();
-	        	Entry residualEntry = split(toInsert, insertNode, parentEntry, timestamp);
-	        	if (alsoUpdate!=null){
-	        		alsoUpdate = residualEntry;
-	        	}
-	        	Node nodeForResidualEntry = insertNode.getEntries()[0].getParentEntry().getNode();
-	        	//recursive call
-	        	return insertHereWithSplit(residualEntry, nodeForResidualEntry, timestamp);
-	    }
-        
-        //no Split
-        return null;
-	}
-
-
-	// XXX: Document the insertion when the final implementation is done.
-	private Entry insertHere(Entry newEntry, Node currentNode,
-	        Entry parentEntry, ClusKernel carriedBuffer, Budget budget,
-	        long timestamp) {
-	
-	    int numFreeEntries = currentNode.numFreeEntries();
-	
-	    // Insert the buffer that we carry.
-	    if (!carriedBuffer.isEmpty()) {
-	        Entry bufferEntry = new Entry(this.numberDimensions,
-	                carriedBuffer, timestamp, parentEntry, currentNode);
-	
-	        if (numFreeEntries <= 1) {
-	            // Distance from buffer to entries.
-	            Entry nearestEntryToCarriedBuffer =
-	                    currentNode.nearestEntry(newEntry);
-	            double distanceNearestEntryToBuffer =
-	                    nearestEntryToCarriedBuffer.calcDistance(newEntry);
-	
-	            // Distance between buffer and point to insert.
-	            double distanceBufferNewEntry =
-	                    newEntry.calcDistance(carriedBuffer);
-	
-	            // Best distance between Entrys in the Node.
-	            BestMergeInNode bestMergeInNode =
-	                    calculateBestMergeInNode(currentNode);
-	
-	            // See what the minimal distance is and do the correspoding
-	            // action.
-	            if (distanceNearestEntryToBuffer <= distanceBufferNewEntry
-	                    && distanceNearestEntryToBuffer <= bestMergeInNode.distance) {
-	                // Aggregate buffer entry to nearest entry in node.
-	                nearestEntryToCarriedBuffer.aggregateEntry(bufferEntry,
-	                        timestamp, this.negLambda);
-	            } else if (distanceBufferNewEntry <= distanceNearestEntryToBuffer
-	                    && distanceBufferNewEntry <= bestMergeInNode.distance) {
-	                newEntry.mergeWith(bufferEntry);
-	            } else {
-	                currentNode.mergeEntries(bestMergeInNode.entryPos1,
-	                        bestMergeInNode.entryPos2);
-	                currentNode.addEntry(bufferEntry, timestamp);
-	            }
-	
-	        } else {
-	            assert (currentNode.isLeaf());
-	            currentNode.addEntry(bufferEntry, timestamp);
-	        }
-	    }
-	
-	    // Normally the insertion of the carries buffer does not change the
-	    // number of free entries, but in case of future changes we calculate
-	    // the number again.
-	    numFreeEntries = currentNode.numFreeEntries();
-	
-	    // Search for an Entry with a weight under the threshold.
-	    Entry irrelevantEntry = currentNode.getIrrelevantEntry(this.weightThreshold);
-	    if (currentNode.isLeaf() && irrelevantEntry != null) {
-	        irrelevantEntry.overwriteOldEntry(newEntry);
-	    } else if (numFreeEntries >= 1) {
-	        currentNode.addEntry(newEntry, timestamp);
-	    } else {
-	        if (currentNode.isLeaf() && (this.hasMaximalSize()
-	                || !budget.hasMoreTime())) {
-	            mergeEntryWithoutSplit(currentNode, newEntry,
-	                    timestamp);
-	        } else {
-	            // We have to split.
-	            return split(newEntry, currentNode, parentEntry, timestamp);
-	        }
-	    }
-	
-	    return null;
-	}
-
-	/**
-	 * This method calculates the distances between the new point and each Entry in a leaf node.
-	 * It returns the node that contains the entry with the smallest distance
-	 * to the new point.
-	 * @param newPoint
-	 * @return best fitting node
-	 */
-	private Node findBestLeafNode(ClusKernel newPoint) {
-    	double minDist = Double.MAX_VALUE;
-    	Node bestFit = null;
-    	for (Node e: collectLeafNodes(root)){
-    		if (newPoint.calcDistance(e.nearestEntry(newPoint).getData())<minDist){
-    			bestFit = e;
-    			minDist = newPoint.calcDistance(e.nearestEntry(newPoint).getData());
-    		}
-    	}
-    	if (bestFit!=null)
-    		return bestFit;
-    	else
-    		return root;
-	}
-    
-    private ArrayList<Node> collectLeafNodes(Node curr){
-    	ArrayList<Node> toReturn = new ArrayList<Node>();
-    	if (curr==null)
-    		return toReturn;
-    	if	(curr.isLeaf()){
-    		toReturn.add(curr);
-    		return toReturn;
-    	}
-    	else{
-    		for (Entry e : curr.getEntries())
-    			toReturn.addAll(collectLeafNodes(e.getChild()));
-    		return toReturn;
-    	}
-    }
-
-	// TODO: Expand all function that work on entries to work with the Budget.
-    private Entry insert(ClusKernel pointToInsert, ClusKernel carriedBuffer,
-            Node currentNode, Entry parentEntry, Budget budget, long timestamp) {
-        assert (currentNode != null);
-        assert (currentNode.isLeaf()
-                || currentNode.getEntries()[0].getChild() != null);
-
-        currentNode.makeOlder(timestamp, this.negLambda);
-
-        // This variable will be changed from to null to an actual reference
-        // in the following if-else block if we have to insert something here,
-        // either because this is a leaf, or because of split propagation.
-        Entry toInsertHere = null;
-
-        if (currentNode.isLeaf()) {
-            // At the end of the function the entry will be inserted.
-            toInsertHere = new Entry(this.numberDimensions,
-                    pointToInsert, timestamp, parentEntry, currentNode);
-        } else {
-
-            Entry bestEntry = currentNode.nearestEntry(pointToInsert);
-            bestEntry.aggregateCluster(pointToInsert, timestamp,
-                    this.negLambda);
-
-            boolean isCarriedBufferEmpty = carriedBuffer.isEmpty();
-
-            Entry bestBufferEntry = null;
-            if (!isCarriedBufferEmpty) {
-                bestBufferEntry = currentNode.nearestEntry(carriedBuffer);
-                bestBufferEntry.aggregateCluster(carriedBuffer, timestamp,
-                        this.negLambda);
-            }
-
-            if (!budget.hasMoreTime()) {
-                bestEntry.aggregateToBuffer(pointToInsert, timestamp,
-                        this.negLambda);
-                if (!isCarriedBufferEmpty) {
-                    bestBufferEntry.aggregateToBuffer(carriedBuffer,
-                            timestamp, this.negLambda);
-                }
-                return null;
-            }
-
-            // If the way of the buffer differs from the way of the point to
-            // be inserted, leave the buffer here.
-            if (!isCarriedBufferEmpty && (bestEntry != bestBufferEntry)) {
-                bestBufferEntry.aggregateToBuffer(carriedBuffer, timestamp,
-                        this.negLambda);
-                carriedBuffer.clear();
-            }
-            // Take the buffer of the best entry for the point to be inserted
-            // along.
-            ClusKernel takeAlongBuffer = bestEntry.emptyBuffer(timestamp,
-                    this.negLambda);
-            carriedBuffer.add(takeAlongBuffer);
-
-            // Recursive call.
-            toInsertHere = insert(pointToInsert, carriedBuffer,
-                    bestEntry.getChild(), bestEntry, budget, timestamp);
-        }
-
-        // If the above block has a new Entry for this place insert it.
-        if (toInsertHere != null) {
-            return this.insertHere(toInsertHere, currentNode, parentEntry,
-                    carriedBuffer, budget, timestamp);
-        }
-
-        // If nothing else needs to be done in all the above levels
-        // return null to signalize it.
-        return null;
-    }
-
-    /**
-     * Inserts an <code>Entry</code> into a <code>Node</code> without inducing
-     * a split.
-     * @param node The node at which the entry is to be inserted.
-     * @param newEntry The entry to be inserted.
-     * @param timestamp The moment at which this occurs.
-     */
-    private void mergeEntryWithoutSplit(Node node,
-            Entry newEntry, long timestamp) {
-
-        Entry nearestEntryToCarriedBuffer =
-                node.nearestEntry(newEntry);
-        double distanceNearestEntryToBuffer =
-                nearestEntryToCarriedBuffer.calcDistance(newEntry);
-
-        BestMergeInNode bestMergeInNode =
-                calculateBestMergeInNode(node);
-
-        if (distanceNearestEntryToBuffer < bestMergeInNode.distance) {
-            nearestEntryToCarriedBuffer.aggregateEntry(newEntry, timestamp,
-                    this.negLambda);
-        } else {
-            node.mergeEntries(bestMergeInNode.entryPos1,
-                    bestMergeInNode.entryPos2);
-            node.addEntry(newEntry, timestamp);
-        }
-    }
-
-    /**
-     * Calculates the best merge possible between two nodes in a node. This
-     * means that the pair with the smallest distance is found.
-     * @param node The node in which these two entries have to be found.
-     * @return An object which encodes the two position of the entries with the
-     * smallest distance in the node and the distance between them.
-     * @see BestMergeInNode
-     * @see Entry#calcDistance(tree.Entry) 
-     */
-    private BestMergeInNode calculateBestMergeInNode(Node node) {
-        assert (node.numFreeEntries() == 0);
-
-        Entry[] entries = node.getEntries();
-
-        int toMerge1 = -1;
-        int toMerge2 = -1;
-        double distanceBetweenMergeEntries = Double.NaN;
-
-        double minDistance = Double.MAX_VALUE;
-        for (int i = 0; i < entries.length; i++) {
-            Entry e1 = entries[i];
-            for (int j = i + 1; j < entries.length; j++) {
-                Entry e2 = entries[j];
-                double distance = e1.calcDistance(e2);
-                if (distance < minDistance) {
-                    toMerge1 = i;
-                    toMerge2 = j;
-                    distanceBetweenMergeEntries = distance;
-                }
-            }
-        }
-
-        assert (toMerge1 != -1 && toMerge2 != -1);
-        if (Double.isNaN(distanceBetweenMergeEntries)) {
-            throw new RuntimeException("The minimal distance between two "
-                    + "Entrys in a Node was Double.MAX_VAUE. That can hardly "
-                    + "be right.");
-        }
-
-        return new BestMergeInNode(toMerge1, toMerge2,
-                distanceBetweenMergeEntries);
-    }
-
-    private boolean hasMaximalSize() {
-        // TODO: Improve hasMaximalSize(). For now it just works somehow for testing.
-        return this.height == this.maxHeight;
-    }
-
-    /**
-     * Performs a (2,2) split on the given node with the given entry. This
-     * implementation only works if the nodes have three entries each. The split
-     * will generate two new nodes. One of them will be put where the old node
-     * was, and for the other a new <code>Entry</code> will be generated and
-     * returned.
-     * @param newEntry The entry to be added to the node.
-     * @param node The node that is going to be splitted.
-     * @param parentEntry The entry in the tree that points at the node that
-     * is going to be splitted.
-     * @param timestamp The moment at which this split occurs.
-     * @return An entry which points at the second node created in the split.
-     * This entry has to be introduced later in the tree.
-     */
-    private Entry split(Entry newEntry, Node node, Entry parentEntry,
-            long timestamp) {
-        // The implemented split function only works in trees where node
-        // have three entries.
-        // Splitting only makes sense on full nodes.
-        assert (node.numFreeEntries() == 0);
-        assert (parentEntry.getChild() == node);
-
-        // All the entries we have to separate in two nodes.
-        Entry[] allEntries = new Entry[4];
-        Entry[] nodeEntries = node.getEntries();
-        for (int i = 0; i < nodeEntries.length; i++) {
-            allEntries[i] = new Entry(nodeEntries[i]);
-        }
-        allEntries[3] = newEntry;
-
-        // Clear the given node, since we are going to refill it later.
-        node = new Node(this.numberDimensions, node.getRawLevel());
-
-        // Calculate the distance of all the possible pairings, since we want
-        // to do a (2,2) split.
-        double select01 = allEntries[0].calcDistance(allEntries[1])
-                + allEntries[2].calcDistance(allEntries[3]);
-
-        double select02 = allEntries[0].calcDistance(allEntries[2])
-                + allEntries[1].calcDistance(allEntries[3]);
-
-        double select03 = allEntries[0].calcDistance(allEntries[3])
-                + allEntries[1].calcDistance(allEntries[2]);
-
-        // See which of the pairings is minimal and distribute the entries
-        // accordingly.
-        Node residualNode = new Node(this.numberDimensions,
-                node.getRawLevel());
-        if (select01 < select02) {
-            if (select01 < select03) {//select01 smallest
-                node.addEntry(allEntries[0], timestamp);
-                node.addEntry(allEntries[1], timestamp);
-                residualNode.addEntry(allEntries[2], timestamp);
-                residualNode.addEntry(allEntries[3], timestamp);
-            } else {//select03 smallest
-                node.addEntry(allEntries[0], timestamp);
-                node.addEntry(allEntries[3], timestamp);
-                residualNode.addEntry(allEntries[1], timestamp);
-                residualNode.addEntry(allEntries[2], timestamp);
-            }
-        } else {
-            if (select02 < select03) {//select02 smallest
-                node.addEntry(allEntries[0], timestamp);
-                node.addEntry(allEntries[2], timestamp);
-                residualNode.addEntry(allEntries[1], timestamp);
-                residualNode.addEntry(allEntries[3], timestamp);
-            } else {//select03 smallest
-                node.addEntry(allEntries[0], timestamp);
-                node.addEntry(allEntries[3], timestamp);
-                residualNode.addEntry(allEntries[1], timestamp);
-                residualNode.addEntry(allEntries[2], timestamp);
-            }
-        }
-
-        // Set the other node into the tree.
-        parentEntry.setChild(node);
-        parentEntry.recalculateData();
-        int count = 0;
-        for (Entry e : node.getEntries()){
-        	e.setParentEntry(parentEntry);
-        	if (e.getData().getN() != 0)
-        		count++;
-        }
-        //System.out.println(count);
-        // Generate a new entry for the residual node.
-        Entry residualEntry = new Entry(this.numberDimensions,
-                residualNode, timestamp, parentEntry, node);
-        count=0;
-        for (Entry e: residualNode.getEntries()){
-        	e.setParentEntry(residualEntry);
-        	if (e.getData().getN() != 0)
-        		count++;
-        }
-        //System.out.println(count);
-        return residualEntry;
-    }
-
-    /**
-     * Return the number of time the tree has grown in size. If the tree grows
-     * and is then cutted from a certain depth, it also counts.
-     * @return The number of times the root node was splitted.
-     */
-    public int getNumRootSplits() {
-        return numRootSplits;
-    }
-
-    /**
-     * Return the current height of the tree. This should never be greater than
-     * <code>maxHeight</code>.
-     * @return The height of the tree.
-     * @see #maxHeight
-     */
-    public int getHeight() {
-        assert (height <= maxHeight);
-        return height;
-    }
-
-    private void cleanUp(Node currentNode, int level) {
-        if (currentNode == null) {
-            return;
-        }
-
-        Entry[] entries = currentNode.getEntries();
-        if (level == this.maxHeight) {
-            for (int i = 0; i < entries.length; i++) {
-                Entry e = entries[i];
-                e.setChild(null);
-            }
-        } else {
-            for (int i = 0; i < entries.length; i++) {
-                Entry e = entries[i];
-                cleanUp(e.getChild(), level + 1);
-            }
-        }
-    }
-
-    /**
-     * @param currentTime The current time
-     * @return The kernels at the leaf level as a clustering
-     */
-    //TODO: Microcluster unter dem Threshhold nich zur�ckgeben (WIe bei outdated entries)
-    @Override
-    public Clustering getMicroClusteringResult() {
-        return getClustering(timestamp, -1);
-    }
-
-    @Override
-    public Clustering getClusteringResult() {
-        return null;
-    }
-
-
-    /**
-     * @param currentTime The current time
-     * @return The kernels at the given level as a clustering.
-     */
-    public Clustering getClustering(long currentTime, int targetLevel) {
-        if (root == null) {
-            return null;
-        }
-
-        Clustering clusters = new Clustering();
-        LinkedList<Node> queue = new LinkedList<Node>();
-        queue.add(root);
-
-        while (!queue.isEmpty()) {
-            Node current = queue.remove();
-           // if (current == null)
-           // 	continue;
-            int currentLevel = current.getLevel(this);
-            boolean isLeaf = (current.isLeaf() && currentLevel <= maxHeight)
-                    || currentLevel == maxHeight;
-
-            if (currentLevel == targetLevel
-                    || (targetLevel == - 1 && isLeaf)) {
-                assert (currentLevel <= maxHeight);
-
-                Entry[] entries = current.getEntries();
-                for (int i = 0; i < entries.length; i++) {
-                    Entry entry = entries[i];
-                    if (entry == null || entry.isEmpty()) {
-                        continue;
-                    }
-                    // XXX
-                    entry.makeOlder(currentTime, this.negLambda);
-                    if (entry.isIrrelevant(this.weightThreshold))
-                    	continue;
-
-                    ClusKernel gaussKernel = new ClusKernel(entry.getData());
-
-//                  long diff = currentTime - entry.getTimestamp();
-//                    if (diff > 0) {
-//                        gaussKernel.makeOlder(diff, negLambda);
-//                    }
-
-                    clusters.add(gaussKernel);
-                }
-            } else if (!current.isLeaf()) {
-                Entry[] entries = current.getEntries();
-                for (int i = 0; i < entries.length; i++) {
-                    Entry entry = entries[i];
-
-                    if (entry.isEmpty()) {
-                        continue;
-                    }
-
-                    if (entry.isIrrelevant(weightThreshold)) {
-                        continue;
-                    }
-
-                    queue.add(entry.getChild());
-                }
-            }
-        }
-
-        return clusters;
-    }
-
-
-
-    /**************************************************************************
-     * LOCAL CLASSES
-     **************************************************************************/
-    /**
-     * A class to code the return value of searching the smallest merge in a
-     * node.
-     */
-    class BestMergeInNode {
-
-        /**
-         * The position of the first entry in the array of the node.
-         */
-        public int entryPos1;
-        /**
-         * The position of the second entry in the array of the node.
-         */
-        public int entryPos2;
-        /**
-         * The distance between the two entries.
-         */
-        public double distance;
-
-        /**
-         * The constructor of this return value. It will automatically make
-         * sure that the first position is the smaller one of the two.
-         * @param pos1 One of the position.
-         * @param pos2 One of the position.
-         * @param distance The distance between the entries at these positions.
-         */
-        public BestMergeInNode(int pos1, int pos2,
-                double distance) {
-            assert (pos1 != pos2);
-
-            this.distance = distance;
-
-            if (pos1 < pos2) {
-                this.entryPos1 = pos1;
-                this.entryPos2 = pos2;
-            } else {
-                this.entryPos1 = pos2;
-                this.entryPos2 = pos1;
-            }
-        }
-    }
-
-}
diff --git a/moa/src/main/java/moa/clusterers/clustree/Entry.java b/moa/src/main/java/moa/clusterers/clustree/Entry.java
deleted file mode 100644
index c24814887..000000000
--- a/moa/src/main/java/moa/clusterers/clustree/Entry.java
+++ /dev/null
@@ -1,464 +0,0 @@
-/*
- *    Entry.java
- *    Copyright (C) 2010 RWTH Aachen University, Germany
- *    @author Sanchez Villaamil (moa@cs.rwth-aachen.de)
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-package moa.clusterers.clustree;
-
-import java.io.Serializable;
-
-public class Entry implements Serializable {
-
-    /**
-     * The actual entry data.
-     */
-    public ClusKernel data;
-    /**
-     * The buffer of this entry. It can also be seen as the buffer of the child
-     * node, it is here just to simplify the insertion recuersion.
-     */
-    private ClusKernel buffer;
-    /**
-     * A reference to the next node in the tree. <code>null</code> if we are
-     * at a leaf, or this is an entry is part of a lying <code>Node</code>.
-     */
-    private Node child;
-    /**
-     *	A reference to the Entry's parent Entry
-     */
-    private Entry parentEntry;
-    /**
-     *	A reference to the Node, that contains this Entry
-     */
-    private Node node;
-	/**
-     * Last time this entry was changed.
-     */
-    private long timestamp;
-    /**
-     * The timestamp to be used when no operation has yet been done on this
-     * entry.
-     * @see #timestamp
-     */
-    private static final long defaultTimestamp = 0;
-
-    /**
-     * Constructor for the entry. To be used when we want to create an empty
-     * entry. Notice that the timestamp will be set to zero, since there is no
-     * reason to know when an empty entry was generated.
-     * @param numberDimensions The dimensionality of the data point in tree
-     * where this entry is used.
-     */
-    public Entry(int numberDimensions) {
-        this.data = new ClusKernel(numberDimensions);
-        this.buffer = new ClusKernel(numberDimensions);
-        this.child = null;
-        this.timestamp = Entry.defaultTimestamp;
-    }
-
-    /**
-     * Constructor that creates an <code>Entry</code> that points to the given
-     * node. The values of <code>data</code> will be calculated for this.
-     * @param numberDimensions The dimensionality of the node.
-     * @param node The node to which the new <code>Entry</code> should point.
-     * @param currentTime The timestamp for the moment where this Entry was
-     * was generated.
-     * @see Node
-     * @see #data
-     */
-    protected Entry(int numberDimensions,
-            Node node, long currentTime, Entry parentEntry, Node containerNode) {
-        this(numberDimensions);
-        this.child = node;
-        this.parentEntry = parentEntry;
-        this.node = containerNode;
-        Entry[] entries = node.getEntries();
-        for (int i = 0; i < entries.length; i++) {
-            Entry entry = entries[i];
-            entry.setParentEntry(this);
-            if (entry.isEmpty()) {
-                break;
-            }
-
-            this.add(entry);
-        }
-
-        this.timestamp = currentTime;
-    }
-
-
-
-    /**
-     * Constructuctor that creates an <code>Entry</code> with an empty buffer
-     * and the <code>data</code> given by the <code>Kernel</code>.
-     * @param numberDimensions The dimensionality of the information in the
-     * cluster.
-     * @param cluster The cluster from which the information is to be extracted.
-     * @param currentTime The timestamp for the moment where this Entry was
-     * was generated.
-     * @see Kernel
-     * @see #data
-     */
-    public Entry(int numberDimensions, ClusKernel cluster, long currentTime) {
-        this(numberDimensions);
-        this.data.add(cluster);
-        this.timestamp = currentTime;
-    }
-    /**
-     * extended constructor with containerNode and parentEntry
-     * @param numberDimensions
-     * @param cluster
-     * @param currentTime
-     * @param parentEntry
-     * @param containerNode
-     */
-    protected Entry(int numberDimensions, ClusKernel cluster, long currentTime, Entry parentEntry, Node containerNode) {
-        this(numberDimensions);
-        this.parentEntry = parentEntry;
-        this.data.add(cluster);
-        this.node = containerNode;
-        this.timestamp = currentTime;
-    }
-    /**
-     * Copy constructor. Everythin is copied, including the child.
-     * @param other
-     */
-    protected Entry(Entry other) {
-    	this.parentEntry = other.parentEntry;
-    	this.node = other.node;
-        this.buffer = new ClusKernel(other.buffer);
-        this.data = new ClusKernel(other.data);
-        this.timestamp = other.timestamp;
-        this.child = other.child;
-    	if (other.getChild()!=null)
-	    	for (Entry e : other.getChild().getEntries()){
-	    		e.setParentEntry(this);
-	    	}
-    }
-
-    public Node getNode() {
-		return node;
-	}
-
-	public void setNode(Node node) {
-		this.node = node;
-	}
-
-	/**
-     * Clear the Entry. All points in the buffer and in the data cluster are
-     * lost, the connection to the child is lost and the timestamp is set to
-     * the default value.
-     */
-    protected void clear() {
-        this.data.clear();
-        this.buffer.clear();
-        this.child = null;
-        this.timestamp = Entry.defaultTimestamp;
-    }
-
-    /**
-     * Clear the <code>data</code> and the <code>buffer Custer</code> in this
-     * entry. This function does not clear the child of this <code>Entry</code>.
-     * @see #data
-     * @see #buffer
-     * @see Kernel
-     */
-    protected void shallowClear() {
-        this.buffer.clear();
-        this.data.clear();
-    }
-
-    /**
-     * Calculates the distance to the data in this entry.
-     * @param cluster The Kernel cluster to which the distance is to be
-     * calculated.
-     * @return The distance to the data <code>Kernel</code> in this
-     * <code>Entry</code>
-     * @see Kernel
-     * @see #data
-     */
-    protected double calcDistance(ClusKernel cluster) {
-        return data.calcDistance(cluster);
-    }
-
-    /**
-     * Calculates the distance to the data in this entry of the data in the
-     * given entry.
-     * @param other The <code>Entry</code> to which the distance is to be
-     * calculated.
-     * @return The distance to the data <code>Kernel</code> in this
-     * <code>Entry</code> of the data <code>Kernel</code> in the other
-     * <code>Entry</code>.
-     * @see Kernel
-     * @see #data
-     */
-    public double calcDistance(Entry other) {
-        return this.getData().calcDistance(other.getData());
-    }
-
-    /**
-     * When this entry is empty, give it it's first values. It makes sense to
-     * have this operation separated from the aggregation, because the
-     * aggregation first weights the values in <code>data</code> and
-     * <code>Kernel</code>, which makes no sense in an empty entry.
-     * @param other The entry with the information to be used to initialize
-     * this entry.
-     * @param currentTime The time at which this is happening.
-     */
-    protected void initializeEntry(Entry other, long currentTime) {
-        assert (this.isEmpty());
-        assert (other.getBuffer().isEmpty());
-        this.data.add(other.data);
-        this.timestamp = currentTime;
-        this.child = other.child;
-        if (child!=null){
-        	for (Entry e : child.getEntries()){
-        		e.setParentEntry(this);
-        	}
-        }
-    }
-
-    /**
-     * Add the data cluster of another entry to the data cluster of this entry.
-     * By using this function the timestamp does not get updated, nor does this
-     * entry get older.
-     * @param other The entry of which the data cluster should be added to
-     * the local data cluster.
-     * @see #data
-     * @see Kernel#add(tree.Kernel) 
-     */
-    public void add(Entry other) {
-        this.data.add(other.data);
-    }
-
-    /**
-     * Aggregate the <code>data</code> in the <code>Kernel</code> of the other
-     * <code>Entry</code>.
-     * @param other The <code>Entry</code> to be aggregated.
-     * @see #data
-     * @see Kernel
-     */
-    protected void aggregateEntry(Entry other, long currentTime,
-            double negLambda) {
-        this.data.aggregate(other.data, currentTime - this.timestamp,
-                negLambda);
-        this.timestamp = currentTime;
-    }
-
-    /**
-     * Aggregate the given <code>Kernel</code> to the <code>data</code> cluster
-     * of this entry.
-     * @param otherData The <code>Entry</code> to be aggregated.
-     * @see #data
-     * @see Kernel
-     */
-    protected void aggregateCluster(ClusKernel otherData, long currentTime,
-            double negLambda) {
-        this.getData().aggregate(otherData, currentTime - this.timestamp,
-                negLambda);
-        this.timestamp = currentTime;
-    }
-
-    /**
-     * Aggregate the given <code>Kernel</code> to the <code>buffer</code>
-     * cluster of this entry.
-     * @param pointToInsert The cluster to aggregate to the buffer.
-     * @param currentTime The time at which the aggregation occurs.
-     * @param negLambda A parameter needed to weight the current state of the
-     * buffer.
-     */
-    protected void aggregateToBuffer(ClusKernel pointToInsert, long currentTime,
-            double negLambda) {
-        ClusKernel currentBuffer = this.getBuffer();
-        currentBuffer.aggregate(pointToInsert, currentTime - this.timestamp,
-                negLambda);
-        this.timestamp = currentTime;
-    }
-
-    /**
-     * Merge this entry witht the given <code>Entry</code>. This adds the data 
-     * cluster of the given Entry to the data cluster of this entry and sets the 
-     * timestamp to the newest one of the the two entries.
-     * @param other The entry from which the data cluster is added.
-     * @see Kernel#add(tree.Kernel) 
-     */
-    protected void mergeWith(Entry other) {
-        // We should only merge entries in leafs, and leafes should have empty
-        // buffers.
-        assert (this.child == null);
-        assert (other.child == null);
-        assert (other.buffer.isEmpty());
-
-        this.data.add(other.data);
-        if (this.timestamp < other.timestamp) {
-            this.timestamp = other.timestamp;
-        }
-    }
-
-    /**
-     * Getter for the buffer. It is the real object, that means side effects are
-     * possible!
-     * @return A reference to the buffer in this entry.
-     */
-    protected ClusKernel getBuffer() {
-        return buffer;
-    }
-
-    /**
-     * Return the reference to the child of this <code>Entry</code> to navigate
-     * in the tree.
-     * @return A reference to the child of this <code>Entry</code>
-     */
-    public Node getChild() {
-        return child;
-    }
-
-    /**
-     * Getter for the data. It is the real object, that means side effects are
-     * possible!
-     * @return A reference to the data <code>Kernel</code> in this entry.
-     * @see Kernel
-     */
-    protected ClusKernel getData() {
-        return data;
-    }
-    public Entry getParentEntry() {
-		return parentEntry;
-	}
-
-	public void setParentEntry(Entry parent) {
-		this.parentEntry = parent;
-	}
-
-    /**
-     * Setter for the child in this entry. Use to build the tree.
-     * @param child The <code>Node</code> that should be a child of this
-     * <code>Entry</code>
-     * @see Node
-     */
-    public void setChild(Node child) {
-        this.child = child;
-    }
-
-    /**
-     * Return the current timestamp.
-     * @return The current timestamp.
-     */
-    public long getTimestamp() {
-        return timestamp;
-    }
-
-    /**
-     * Clear the buffer in this entry and return a copy. No side effects are
-     * possible (given that the copy constructor of <code>Kernel</code> makes
-     * a deep copy).
-     * @return A copy of the buffer.
-     */
-    protected ClusKernel emptyBuffer(long currentTime, double negLambda) {
-        this.buffer.makeOlder(currentTime - this.timestamp, negLambda);
-        ClusKernel bufferCopy = new ClusKernel(this.buffer);
-        this.buffer.clear();
-        return bufferCopy;
-    }
-
-    /**
-     * Check if this <code>Entry</code> is empty or not. An <code>Entry</code>
-     * is empty if the <code>data Kernel</code> is empty, since then the buffer
-     * has to be empty.
-     * @return <code>true</code> if the data cluster has no data points,
-     * <code>false</code> otherwise.
-     */
-    protected boolean isEmpty() {
-        // Assert that if the data cluster is empty, the buffer cluster is
-        // empty too.
-        assert ((this.data.isEmpty() && this.buffer.isEmpty())
-                || !this.data.isEmpty());
-
-        return this.data.isEmpty();
-    }
-
-    /**
-     * Overwrites the LS, SS and weightedN in the data cluster of this
-     * <code>Entry</code> to the values of the data cluster in the given
-     * <code>Entry</code>, but adds N and classCount of the cluster in the given
-     * Entry to the data cluster in this one. This function is useful when the
-     * weight of an entry becomes to small, and we want to forget the
-     * information of the old points.
-     * @param newEntry The cluster that should overwrite the information.
-     */
-    protected void overwriteOldEntry(Entry newEntry) {
-        assert (this.getBuffer().isEmpty());
-        assert (newEntry.getBuffer().isEmpty());
-        this.data.overwriteOldCluster(newEntry.data);
-        newEntry.setParentEntry(this.parentEntry);
-        if (newEntry.getChild()!=null)
-        for (Entry e : newEntry.getChild().getEntries())
-        	e.setParentEntry(this);
-        //this.setParentEntry(newEntry.getParentEntry());
-        this.child=newEntry.child;
-    }
-
-    /**
-     * This functions reads every entry in the child node and calculates the
-     * corresponding <code>data Kernel</code>. Timestamps are not changed.
-     * @see #data
-     * @see Kerne
-     */
-    protected void recalculateData() {
-        Node currentChild = this.getChild();
-        if (currentChild != null) {
-            ClusKernel currentData = this.getData();
-            currentData.clear();
-            Entry[] entries = currentChild.getEntries();
-            for (int i = 0; i < entries.length; i++) {
-                currentData.add(entries[i].getData());
-            }
-        } else {
-            this.clear();
-        }
-    }
-
-    /**
-     * Returns true if this entry is irrelevant with respecto the given
-     * threshold. This is done by comparing the weighted N of this Entry to
-     * the threshold, if it is smaller, than the entry is deemed to be
-     * irrelevant.
-     * @param threshold The threshold under which entries at leafs can be
-     * erased.
-     * @return True if this entry is deemed irrelevant, false otherwise.
-     */
-    protected boolean isIrrelevant(double threshold) {
-        return this.getData().getWeight() < threshold;
-    }
-
-    /**
-     * Ages this entrie's data AND buffer according to the given
-     * time and aging constant.
-     * @param currentTime   the current time
-     * @param negLambda	    the aging constant
-     */
-    protected void makeOlder(long currentTime, double negLambda) {
-//        assert (currentTime > this.timestamp) : "currentTime : "
-//                + currentTime + ", this.timestamp: " + this.timestamp;
-
-        long diff = currentTime - this.timestamp;
-        this.buffer.makeOlder(diff, negLambda);
-        this.data.makeOlder(diff, negLambda);
-        this.timestamp = currentTime;
-    }
-
-}
diff --git a/moa/src/main/java/moa/clusterers/clustree/Node.java b/moa/src/main/java/moa/clusterers/clustree/Node.java
deleted file mode 100644
index 5ab9b66a2..000000000
--- a/moa/src/main/java/moa/clusterers/clustree/Node.java
+++ /dev/null
@@ -1,332 +0,0 @@
-/*
- *    Node.java
- *    Copyright (C) 2010 RWTH Aachen University, Germany
- *    @author Sanchez Villaamil (moa@cs.rwth-aachen.de)
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.clustree;
-
-import java.io.Serializable;
-
-public class Node implements Serializable {
-
-	final int NUMBER_ENTRIES = 3;
-    static int INSERTIONS_BETWEEN_CLEANUPS = 10000;
-    
-    /**
-     * The children of this node.
-     */
-    private Entry[] entries;
-    // Information about the state in the tree.
-    /**
-     * The depth at which this <code>Node</code> is in the tree.
-     */
-    private int level;
-
-    /**
-     * Initialze a normal node, which is not fake.
-     * @param numberDimensions The dimensionality of the data points it
-     * manipulates.
-     * @param level The INVERSE level at which this node hangs.
-     */
-    public Node(int numberDimensions, int level) {
-        this.level = level;
-
-        this.entries = new Entry[NUMBER_ENTRIES];
-        // Generate all entries when we generate a Node.
-        // That no entry can be null makes it much easier to handle.
-        for (int i = 0; i < NUMBER_ENTRIES; i++) {
-            entries[i] = new Entry(numberDimensions);
-            entries[i].setNode(this);
-        }
-    }
-
-    /**
-     * Initialiazes a node which is a fake root depending on the given
-     * <code>boolean</code>.
-     * @param numberDimensions The dimensionality of the data points it
-     * manipulates.
-     * @param level The level at which this node hangs.
-     * @param fakeRoot A parameter the says if the node is to be fake or not.
-     */
-    protected Node(int numberDimensions, int numberClasses, int level,
-            boolean fakeRoot) {
-
-        this.level = level;
-
-        this.entries = new Entry[NUMBER_ENTRIES];
-        // Generate all entries when we generate a Node.
-        // That no entry can be null makes it much easier to handle.
-        for (int i = 0; i < NUMBER_ENTRIES; i++) {
-            entries[i] = new Entry(numberDimensions);
-        }
-    }
-    
-    /**
-     * USED FOR EM_TOP_DOWN BULK LOADING
-     * @param numberDimensions
-     * @param level
-     * @param argEntries
-     */
-    public Node(int numberDimensions, int level, Entry[] argEntries) {
-        this.level = level;
-
-        this.entries = new Entry[NUMBER_ENTRIES];
-        // Generate all entries when we generate a Node.
-        // That no entry can be null makes it much easier to handle.
-        for (int i = 0; i < NUMBER_ENTRIES; i++) {
-            entries[i] = argEntries[i];
-        }
-    }
-
-
-    /**
-     * Checks if this node is a leaf. A node is a leaf when none of the entries
-     * in the node have children.
-     * @return <code>true</code> if the node is leaf, <code>false</code>
-     * otherwise.
-     */
-    protected boolean isLeaf() {
-
-        for (int i = 0; i < entries.length; i++) {
-            Entry entry = entries[i];
-            if (entry.getChild() != null) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    /**
-     * Returns the neareast <code>Entry</code> to the given <code>Cluster</code>.
-     * The distance is minimized over <code>Entry.calcDistance(Cluster)</code>.
-     * @param buffer The cluster to which the distance has to be compared.
-     * @return The <code>Entry</code> with minimal distance to the given
-     * cluster.
-     * @throws EmptyNodeException This Exception is thrown when this function is
-     * called on an empty node.
-     * @see Kernel
-     * @see Entry#calcDistance(moa.clusterers.tree.Kernel)
-     */
-    public Entry nearestEntry(ClusKernel buffer) {
-
-        // TODO: (Fernando) Adapt the nearestEntry(...) function to the new algorithmn.
-
-        Entry res = entries[0];
-        double min = res.calcDistance(buffer);
-        for (int i = 1; i < entries.length; i++) {
-            Entry entry = entries[i];
-
-            if (entry.isEmpty()) {
-                break;
-            }
-
-            double distance = entry.calcDistance(buffer);
-            if (distance < min) {
-                min = distance;
-                res = entry;
-            }
-        }
-
-        return res;
-    }
-
-    /**
-     * Return the nearest entry to the given one. The
-     * <code>calcDistance(Entry)</code> function is find the one with the
-     * shortest distance in this node to the given one.
-     * @param newEntry The entry to which the entry with the minimal distance
-     * to it is calculated.
-     * @return The entry with the minimal distance to the given one.
-     */
-    protected Entry nearestEntry(Entry newEntry) {
-        assert (!this.entries[0].isEmpty());
-
-        Entry res = entries[0];
-        double min = res.calcDistance(newEntry);
-        for (int i = 1; i < entries.length; i++) {
-
-            if (this.entries[i].isEmpty()) {
-                break;
-            }
-
-            Entry entry = entries[i];
-            double distance = entry.calcDistance(newEntry);
-            if (distance < min) {
-                min = distance;
-                res = entry;
-            }
-        }
-
-        return res;
-    }
-
-    /**
-     * Return the number of free <code>Entry</code>s in this node.
-     * @return The number of free <code>Entry</code>s in this node.
-     * @see Entry
-     */
-    protected int numFreeEntries() {
-        int res = 0;
-        for (int i = 0; i < entries.length; i++) {
-            Entry entry = entries[i];
-            if (entry.isEmpty()) {
-                res++;
-            }
-        }
-
-        assert (NUMBER_ENTRIES == entries.length);
-        return res;
-    }
-
-    /**
-     * Add a new <code>Entry</code> to this node. If there is no space left a
-     * <code>NoFreeEntryException</code> is thrown.
-     * @param newEntry The <code>Entry</code> to be added.
-     * @throws NoFreeEntryException Is thrown when there is no space left in
-     * the node for the new entry.
-     */
-    public void addEntry(Entry newEntry, long currentTime){
-    	newEntry.setNode(this);
-        int freePosition = getNextEmptyPosition();
-        entries[freePosition].initializeEntry(newEntry, currentTime);
-    }
-
-    /**
-     * Returns the position of the next free Entry.
-     * @return The position of the next free Entry.
-     * @throws NoFreeEntryException Is thrown when there is no free entry left in
-     * the node.
-     */
-    private int getNextEmptyPosition(){
-        int counter;
-        for (counter = 0; counter < entries.length; counter++) {
-            Entry e = entries[counter];
-            if (e.isEmpty()) {
-                break;
-            }
-        }
-
-        if (counter == entries.length) {
-            throw new RuntimeException("Entry added to a node which is already full.");
-        }
-
-        return counter;
-    }
-
-    /**
-     * If there exists an entry, whose relevance is under the threshold given
-     * as a parameter to the tree, this entry is returned. Otherwise
-     * <code>null</code> is returned.
-     * @return An irrelevant <code>Entry</code> if there exists one,
-     * <code>null</code> otherwise.
-     * @see Entry
-     * @see Entry#isIrrelevant(double) 
-     */
-    protected Entry getIrrelevantEntry(double threshold) {
-        for (int i = 0; i < this.entries.length; i++) {
-            Entry entry = this.entries[i];
-            if (entry.isIrrelevant(threshold)) {
-                return entry;
-            }
-        }
-
-        return null;
-    }
-
-    /**
-     * Return an array with references to the children of this node. These are
-     * not copies, that means side effects are possible!
-     * @return An array with references to the children of this node.
-     * @see Entry
-     */
-    public Entry[] getEntries() {
-        return entries;
-    }
-
-    /**
-     * Return the level number in the node. This is not the real level. For the
-     * real level one has to call <code>getLevel(Tree tree)</code>.
-     * @return The raw level of the node.
-     * @see #getLevel(moa.clusterers.LiarTree.Tree)
-     */
-    protected int getRawLevel() {
-        return level;
-    }
-
-    /**
-     * Returns the level at which this node is in the tree. If a tree is passed
-     * to which the node does not belonged a value is returned, but it is
-     * gibberish.
-     * @param tree The tree to which this node belongs.
-     * @return The level at which this node hangs.
-     */
-    protected int getLevel(ClusTree tree) {
-        int numRootSplits = tree.getNumRootSplits();
-        return numRootSplits - this.getRawLevel();
-    }
-
-    /**
-     * Clear this Node, which means that the noiseBuffer is cleared, that
-     * <code>shallowClear</code> is called upon all the entries of the node,
-     * that the split counter is set to zero and the node is set to not be a
-     * fake root. Notice that the level stays the same after calling this
-     * function.
-     * @see Kernel#clear()
-     * @see Entry#shallowClear()
-     */
-    // Level stays the same.
-    protected void clear() {
-        for (int i = 0; i < NUMBER_ENTRIES; i++) {
-            entries[i].shallowClear();
-        }
-    }
-
-    /**
-     * Merge the two entries at the given position. The entries are reordered in
-     * the <code>entries</code> array so that the non-empty entries are still
-     * at the beginning.
-     * @param pos1 The position of the first entry to be merged. This position
-     * has to be smaller than the the second position.
-     * @param pos2 The position of the second entry to be merged. This position
-     * has to be greater than the the first position.
-     */
-    protected void mergeEntries(int pos1, int pos2) {
-        assert (this.numFreeEntries() == 0);
-        assert (pos1 < pos2);
-
-        this.entries[pos1].mergeWith(this.entries[pos2]);
-
-        for (int i = pos2; i < entries.length - 1; i++) {
-            entries[i] = entries[i + 1];
-        }
-        entries[entries.length - 1].clear();
-    }
-
-    protected void makeOlder(long currentTime, double negLambda) {
-        for (int i = 0; i < this.entries.length; i++) {
-            Entry entry = this.entries[i];
-
-            if (entry.isEmpty()) {
-                break;
-            }
-
-            entry.makeOlder(currentTime, negLambda);
-        }
-    }
-}
diff --git a/moa/src/main/java/moa/clusterers/clustree/util/Budget.java b/moa/src/main/java/moa/clusterers/clustree/util/Budget.java
deleted file mode 100644
index 6ffa1f513..000000000
--- a/moa/src/main/java/moa/clusterers/clustree/util/Budget.java
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- *    Budget.java
- *    Copyright (C) 2010 RWTH Aachen University, Germany
- *    @author Sanchez Villaamil (moa@cs.rwth-aachen.de)
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.clustree.util;
-
-/**
- * This is an interface for classes that are to be given along with every data 
- * point inserted in the tree. The tree has to inform the implementation of 
- * this <code>Budget</code> interface of every operation it does, and ask at the
- * places where it can stop prematurely if it should. This models the arrival of
- * a new data point in the stream, before there was enough time to insert the
- * current one.
- */
-public interface Budget {
-
-    /**
-     * A function for the tree to ask if there is budget(time) left.
-     * @return A <code>boolean</code> that is <code>true</code> if the tree
-     * should go on, <code>false</code> otherwise.
-     */
-    public boolean hasMoreTime();
-
-    /**
-     * Inform the <code>Budget</code> class that an integer addition has been
-     * performed by the tree.
-     */
-    public void integerAddition();
-
-    /**
-     * Inform the <code>Budget</code> that a certain number of integer additions
-     * have been done.
-     * @param number the number of additions done.
-     */
-    public void integerAddition(int number);
-
-    /**
-     * Inform the <code>Budget</code> class that a double addition has been 
-     * performed by the tree.
-     */
-    public void doubleAddition();
-
-    /**
-     * Inform the <code>Budget</code> that a certain number of double additions
-     * have been performed.
-     * @param number the number of additions done.
-     */
-    public void doubleAddition(int number);
-
-    /**
-     * Inform the <code>Budget</code> class that a integer multiplicaton has 
-     * been performed by the tree.
-     */
-    public void integerMultiplication();
-
-    /**
-     * Inform the <code>Budget</code> that a certain number of integer
-     * multiplications have been performed.
-     * @param number the number of multiplication done.
-     */
-    public void integerMultiplication(int number);
-
-    /**
-     * Inform the <code>Budget</code> class that a double multiplicaton has
-     * been performed by the tree.
-     */
-    public void doubleMultiplication();
-
-    /**
-     * Inform the <code>Budget</code> that a certain number of double 
-     * multiplications have been performed.
-     * @param number the number of multiplications done.
-     */
-    public void doubleMultiplication(int number);
-
-    /**
-     * Inform the <code>Budget</code> class that a integer division has
-     * been performed by the tree.
-     */
-    public void integerDivision();
-
-    /**
-     * Inform the <code>Budget</code> that a certain number of integer divisions
-     * have been performed.
-     * @param number the number of division done.
-     */
-    public void integerDivision(int number);
-
-    /**
-     * Inform the <code>Budget</code> class that a double division has
-     * been performed by the tree.
-     */
-    public void doubleDivision();
-
-    /**
-     * Inform the <code>Budget</code> that a certain number of double divisions
-     * have been performed.
-     * @param number the number of divisions done.
-     */
-    public void doubleDivision(int number);
-}
diff --git a/moa/src/main/java/moa/clusterers/clustree/util/SimpleBudget.java b/moa/src/main/java/moa/clusterers/clustree/util/SimpleBudget.java
deleted file mode 100644
index ee05c4062..000000000
--- a/moa/src/main/java/moa/clusterers/clustree/util/SimpleBudget.java
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- *    SimpleBudget.java
- *    Copyright (C) 2010 RWTH Aachen University, Germany
- *    @author Reidl (moa@cs.rwth-aachen.de)
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.clustree.util;
-
-public class SimpleBudget implements Budget {
-
-    public static final int INT_ADD = 1;
-    public static final int INT_MULT = 1;
-    public static final int INT_DIV = 1;
-    public static final int DOUBLE_ADD = 1;
-    public static final int DOUBLE_MULT = 1;
-    public static final int DOUBLE_DIV = 10;
-    private int time;
-
-    public SimpleBudget(int time) {
-        assert (time >= 0);
-        this.time = time;
-    }
-
-    @Override
-    public boolean hasMoreTime() {
-        return time > 0;
-    }
-
-    @Override
-    public void integerAddition() {
-        time -= INT_ADD;
-    }
-
-    @Override
-    public void integerAddition(int number) {
-        time -= INT_ADD * number;
-    }
-
-    @Override
-    public void doubleAddition() {
-        time -= DOUBLE_ADD;
-    }
-
-    @Override
-    public void doubleAddition(int number) {
-        time -= DOUBLE_ADD * number;
-    }
-
-    @Override
-    public void integerMultiplication() {
-        time -= INT_MULT;
-    }
-
-    @Override
-    public void integerMultiplication(int number) {
-        time -= INT_MULT * number;
-    }
-
-    @Override
-    public void doubleMultiplication() {
-        time -= DOUBLE_MULT;
-    }
-
-    @Override
-    public void doubleMultiplication(int number) {
-        time -= DOUBLE_MULT * number;
-    }
-
-    @Override
-    public void integerDivision() {
-        time -= INT_DIV;
-    }
-
-    @Override
-    public void integerDivision(int number) {
-        time -= INT_DIV * number;
-    }
-
-    @Override
-    public void doubleDivision() {
-        time -= DOUBLE_DIV;
-    }
-
-    @Override
-    public void doubleDivision(int number) {
-        time -= DOUBLE_DIV * number;
-    }
-}
diff --git a/moa/src/main/java/moa/clusterers/denstream/MicroCluster.java b/moa/src/main/java/moa/clusterers/denstream/MicroCluster.java
deleted file mode 100644
index cf6c25dba..000000000
--- a/moa/src/main/java/moa/clusterers/denstream/MicroCluster.java
+++ /dev/null
@@ -1,157 +0,0 @@
-/*
- *    MicroCluster.java
- *    Copyright (C) 2010 RWTH Aachen University, Germany
- *    @author Wels (moa@cs.rwth-aachen.de)
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-package moa.clusterers.denstream;
-
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.cluster.CFCluster;
-
-public class MicroCluster extends CFCluster {
-
-    private long lastEditT = -1;
-    private long creationTimestamp = -1;
-    private double lambda;
-    private Timestamp currentTimestamp;
-
-    public MicroCluster(double[] center, int dimensions, long creationTimestamp, double lambda, Timestamp currentTimestamp) {
-        super(center, dimensions);
-        this.creationTimestamp = creationTimestamp;
-        this.lastEditT = creationTimestamp;
-        this.lambda = lambda;
-        this.currentTimestamp = currentTimestamp;
-    }
-
-    public MicroCluster(Instance instance, int dimensions, long timestamp, double lambda, Timestamp currentTimestamp) {
-        this(instance.toDoubleArray(), dimensions, timestamp, lambda, currentTimestamp);
-    }
-
-    public void insert(Instance instance, long timestamp) {
-        N++;
-        super.setWeight(super.getWeight() + 1);
-        this.lastEditT = timestamp;
-
-        for (int i = 0; i < instance.numValues(); i++) {
-            LS[i] += instance.value(i);
-            SS[i] += instance.value(i) * instance.value(i);
-        }
-    }
-
-    public long getLastEditTimestamp() {
-        return lastEditT;
-    }
-
-    private double[] calcCF2(long dt) {
-        double[] cf2 = new double[SS.length];
-        for (int i = 0; i < SS.length; i++) {
-            cf2[i] = Math.pow(2, -lambda * dt) * SS[i];
-        }
-        return cf2;
-    }
-
-    private double[] calcCF1(long dt) {
-        double[] cf1 = new double[LS.length];
-        for (int i = 0; i < LS.length; i++) {
-            cf1[i] = Math.pow(2, -lambda * dt) * LS[i];
-        }
-        return cf1;
-    }
-
-    @Override
-    public double getWeight() {
-        return getWeight(currentTimestamp.getTimestamp());
-    }
-
-    private double getWeight(long timestamp) {
-        long dt = timestamp - lastEditT;
-        return (N * Math.pow(2, -lambda * dt));
-    }
-
-    public long getCreationTime() {
-        return creationTimestamp;
-    }
-
-    @Override
-    public double[] getCenter() {
-        return getCenter(currentTimestamp.getTimestamp());
-    }
-
-    private double[] getCenter(long timestamp) {
-        long dt = timestamp - lastEditT;
-        double w = getWeight(timestamp);
-        double[] res = new double[LS.length];
-        for (int i = 0; i < LS.length; i++) {
-            res[i] = LS[i];
-            res[i] *= Math.pow(2, -lambda * dt);
-            res[i] /= w;
-        }
-        return res;
-    }
-
-    @Override
-    public double getRadius() {
-        return getRadius(currentTimestamp.getTimestamp())*radiusFactor;
-    }
-
-    public double getRadius(long timestamp) {
-        long dt = timestamp - lastEditT;
-        double[] cf1 = calcCF1(dt);
-        double[] cf2 = calcCF2(dt);
-        double w = getWeight(timestamp);
-        double max = 0;
-        double sum = 0;
-        for (int i = 0; i < SS.length; i++) {
-            double x1 = cf2[i] / w;
-            double x2 = Math.pow(cf1[i] / w, 2);
-            //sum += Math.pow(x1 - x2,2);
-            sum += (x1 - x2);
-            if (Math.sqrt(x1 - x2) > max) {
-                max = Math.sqrt(x1 - x2);
-            }
-        }
-        return max;
-    }
-
-    @Override
-    public MicroCluster copy() {
-        MicroCluster copy = new MicroCluster(this.LS.clone(), this.LS.length, this.getCreationTime(), this.lambda, this.currentTimestamp);
-        copy.setWeight(this.N + 1);
-        copy.N = this.N;
-        copy.SS = this.SS.clone();
-        copy.LS = this.LS.clone();
-        copy.lastEditT = this.lastEditT;
-        return copy;
-    }
-
-    @Override
-    public double getInclusionProbability(Instance instance) {
-        if (getCenterDistance(instance) <= getRadius()) {
-            return 1.0;
-        }
-        return 0.0;
-    }
-
-    @Override
-    public CFCluster getCF(){
-        CFCluster cf = copy();
-        double w = getWeight();
-        cf.setN(w);
-        return cf;
-    }
-}
diff --git a/moa/src/main/java/moa/clusterers/macro/ColorArray.java b/moa/src/main/java/moa/clusterers/macro/ColorArray.java
deleted file mode 100644
index 6c5e0c31b..000000000
--- a/moa/src/main/java/moa/clusterers/macro/ColorArray.java
+++ /dev/null
@@ -1,148 +0,0 @@
-/**
- * [ColorArray.java] for Subspace MOA
- * 
- * @author Stephen Wels
- * Data Management and Data Exploration Group, RWTH Aachen University
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-package moa.clusterers.macro;
-
-import java.awt.Color;
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.nio.charset.StandardCharsets;
-import java.util.ArrayList;
-
-public class ColorArray {
-
-	private static final ColorObject[] ORIGINAL_COLOURS = {
-	  new ColorObject("blue", new Color(0x0000ff)),
-	  new ColorObject("blueviolet", new Color(0x8a2be2)),
-	  new ColorObject("brown", new Color(0xa52a2a)),
-	  new ColorObject("burlywood", new Color(0xdeb887)),
-	  new ColorObject("cadetblue", new Color(0x5f9ea0)),
-	  //new ColorObject("chartreuse", new Color(0x7fff00)),
-	  new ColorObject("chocolate", new Color(0xd2691e)),
-	  new ColorObject("coral", new Color(0xff7f50)),
-	  new ColorObject("cornflowerblue", new Color(0x6495ed)),
-	  new ColorObject("crimson", new Color(0xdc143c)),
-	  new ColorObject("cyan", new Color(0x00ffff)),
-	  new ColorObject("darkblue", new Color(0x00008b)),
-	  new ColorObject("darkcyan", new Color(0x008b8b)),
-	  new ColorObject("darkgoldenrod", new Color(0xb8860b)),
-	  new ColorObject("darkgreen", new Color(0x006400)),
-	  new ColorObject("darkkhaki", new Color(0xbdb76b)),
-	  new ColorObject("darkmagenta", new Color(0x8b008b)),
-	  new ColorObject("darkolivegreen", new Color(0x556b2f)),
-	  new ColorObject("darkorange", new Color(0xff8c00)),
-	  // new ColorObject("darkorchid", new Color(0x9932cc)),
-	  new ColorObject("darkred", new Color(0x8b0000)),
-	  new ColorObject("darksalmon", new Color(0xe9967a)),
-	  new ColorObject("darkseagreen", new Color(0x8fbc8f)),
-	  new ColorObject("darkslateblue", new Color(0x483d8b)),
-	  new ColorObject("darkslategray", new Color(0x2f4f4f)),
-	  // new ColorObject("darkturquoise", new Color(0x00ced1)),
-	  new ColorObject("darkviolet", new Color(0x9400d3)),
-	  new ColorObject("deeppink", new Color(0xff1493)),
-	  new ColorObject("deepskyblue", new Color(0x00bfff)),
-	  // new ColorObject("dodgerblue", new Color(0x1e90ff)),
-	  new ColorObject("firebrick", new Color(0xb22222)),
-	  new ColorObject("forestgreen", new Color(0x228b22)),
-	  new ColorObject("fuchsia", new Color(0xff00ff)),
-	  new ColorObject("gold", new Color(0xffd700)),
-	  new ColorObject("goldenrod", new Color(0xdaa520)),
-	  //new ColorObject("green", new Color(0x008000)),
-	  new ColorObject("greenyellow", new Color(0xadff2f)),
-	  new ColorObject("hotpink", new Color(0xff69b4)),
-	  new ColorObject("indianred", new Color(0xcd5c5c)),
-	  new ColorObject("indigo", new Color(0x4b0082)),
-	  //new ColorObject("lawngreen", new Color(0x7cfc00)),
-	  // new ColorObject("lime", new Color(0x00ff00)),
-	  // new ColorObject("limegreen", new Color(0x32cd32)),
-	  new ColorObject("magenta", new Color(0xff00ff)),
-	  new ColorObject("maroon", new Color(0x800000)),
-	  new ColorObject("olive", new Color(0x808000)),
-	  new ColorObject("orange", new Color(0xffa500)),
-	  new ColorObject("orangered", new Color(0xff4500)),
-	  new ColorObject("pink", new Color(0xffc0cb)),
-	  new ColorObject("powderblue", new Color(0xb0e0e6)),
-	  new ColorObject("purple", new Color(0x800080)),
-	  new ColorObject("red", new Color(0xff0000)),
-	  new ColorObject("royalblue", new Color(0x4169e1)),
-	  new ColorObject("saddlebrown", new Color(0x8b4513)),
-	  new ColorObject("salmon", new Color(0xfa8072)),
-	  new ColorObject("seagreen", new Color(0x2e8b57)),
-	  new ColorObject("skyblue", new Color(0x87ceeb)),
-	  new ColorObject("slateblue", new Color(0x6a5acd)),
-	  new ColorObject("tomato", new Color(0xff6347)),
-	  new ColorObject("violet", new Color(0xee82ee)) };
-
-	private static final String COMMA_DELIMITER   = ",";
-	public static ColorObject[] mVisibleColors;
-
-	static {
-		try {
-		  	ArrayList<ColorObject> colours = new ArrayList<>();
-		  	for (ColorObject obj : ORIGINAL_COLOURS)
-		  	  colours.add(obj);
-		  	colours.addAll(getColors());
-			mVisibleColors = colours.toArray(new ColorObject[0]);
-		} catch (IOException e) {
-			e.printStackTrace();
-		}
-	}
-
-	private static ArrayList<ColorObject> getColors() throws IOException {
-
-		ArrayList<ColorObject> colorObjects = new ArrayList<>();
-		ClassLoader classLoader = ColorArray.class.getClassLoader();
-		InputStream inputStream = classLoader.getResourceAsStream("colors.csv");
-		InputStreamReader streamReader = new InputStreamReader(inputStream, StandardCharsets.UTF_8);
-		BufferedReader reader = new BufferedReader(streamReader);
-		for (String line; (line = reader.readLine()) != null;) {
-			String[] values = line.split(COMMA_DELIMITER);
-			colorObjects.add(new ColorObject(values[0], Color.decode(values[1])));
-		}
-
-		return colorObjects;
-	}
-
-	public static Color getColor(int i) {
-		Color res;
-		try {
-			res = mVisibleColors[i].getColor();
-		} catch (ArrayIndexOutOfBoundsException e) {
-			return Color.BLACK;
-		}
-		return res;
-	}
-
-	public static String getName(int i) {
-		String res;
-		try {
-			res = mVisibleColors[i].getName();
-		} catch (ArrayIndexOutOfBoundsException e) {
-			throw e;
-		}
-		return res;
-	}
-
-	public static double getNumColors() {
-		return mVisibleColors.length;
-	}
-}
diff --git a/moa/src/main/java/moa/clusterers/outliers/AbstractC/AbstractC.java b/moa/src/main/java/moa/clusterers/outliers/AbstractC/AbstractC.java
deleted file mode 100644
index 9ac25bf0a..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/AbstractC/AbstractC.java
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
- *    AbstractC.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- * 
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers.AbstractC;
-
-import java.util.Vector;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.clusterers.outliers.AbstractC.ISBIndex.ISBNode;
-import moa.clusterers.outliers.AbstractC.ISBIndex.ISBSearchResult;
-
-//The algorithm is presented in:
-//D. Yang, E. Rundensteiner, and M. Ward.
-//Neighbor-based pattern detection for windows over streaming data. 
-//In EDBT, pages 529–540, 2009
-
-
-public class AbstractC extends AbstractCBase {    
-    public FloatOption radiusOption = new FloatOption("radius", 'r', "Search radius.", 0.1);
-    //public FloatOption fractionOption = new FloatOption("fraction", 'f', "Parameter fraction.", 0.05);
-    public IntOption kOption = new IntOption("k", 't', "Parameter k.", 50);
-    public FlagOption waitWinFullOption = new FlagOption("waitWinFull", 'a', "Output outliers when windows is full.");
-    
-    public AbstractC()
-    {
-        // System.out.println("AbstractC: created");
-    }
-    
-    @Override
-    public void Init() {   
-        super.Init();
-        
-        m_WindowSize = windowSizeOption.getValue();
-        m_radius = radiusOption.getValue();
-        //m_Fraction = fractionOption.getValue();
-        m_Fraction = (double)kOption.getValue() / (double)m_WindowSize;
-                
-        Println("Init AbstractC:");
-        Println("   window_size: " + m_WindowSize);
-        Println("   radius: " + m_radius);
-        Println("   Fraction: " + m_Fraction);
-        Println("   (Fraction * window_size: " + String.format("%.2f", m_Fraction * m_WindowSize) + ")");
-        
-        //bTrace = true;
-        bWarning = true;
-        
-        objId = FIRST_OBJ_ID; // init object identifier
-        // create fifo
-        windowNodes = new Vector<ISBNode>();
-        // create ISB
-        ISB = new ISBIndex(m_radius, m_Fraction);
-        
-        // init statistics
-        m_nBothInlierOutlier = 0;
-        m_nOnlyInlier = 0;
-        m_nOnlyOutlier = 0;
-    }
-    
-    void UpdateNeighbors(ISBNode n, ISBNode q) {
-        if (n == q) return;
-        if (bTrace) Println("UpdateNeighbors: n.id: " + n.id + ", q.id: " + q.id);
-        
-        int len = q.lt_cnt.size();
-        for (int i = 0; i < len; i++) {
-            // n.lt_cnt++
-            n.lt_cnt.set(i, n.lt_cnt.get(i) + 1);
-            // q.lt_cnt++
-            q.lt_cnt.set(i, q.lt_cnt.get(i) + 1);
-        }
-    }
-    
-    void OutputPatterns() {
-        if (bTrace) Println("OutputPatterns");
-        
-        double thr = m_Fraction * m_WindowSize;
-        
-        for (ISBNode node : windowNodes) {
-            if (node.lt_cnt.size() > 0) {
-                if (IsWinFull() || !waitWinFullOption.isSet()) {
-                    if (node.lt_cnt.get(0) < thr) {
-                        SaveOutlier(node);
-                    } else {
-                        RemoveOutlier(node);
-                    }
-                }
-                node.lt_cnt.remove(0);
-            } else {
-                if (bWarning) Println("OutputPatterns: " + node.id + ".lt_cnt is empty!");
-            }
-        }
-    }
-    
-    @Override
-    protected void ProcessNewStreamObj(Instance inst)
-    {        
-        if (bShowProgress) ShowProgress("Processed " + (objId - 1) + " stream objects.");       
-        // PrintInstance(inst);
-        
-        double[] values = getInstanceValues(inst);
-        StreamObj obj = new StreamObj(values);
-        
-        // process new data stream object
-        if (bTrace) Println("\n- - - - - - - - - - - -\n");
-        
-        // create new ISB node
-        ISBNode nodeNew = new ISBNode(inst, obj, objId);
-        if (bTrace) { Print("New node: "); PrintNode(nodeNew); }
-        
-        objId++; // update object identifier (slide window)
-        
-        // purge expired node
-        ISBNode nodeExpired = GetExpiredNode();
-        if (nodeExpired != null) {
-            // purge nodeExpired
-            if (bTrace) { Print("nodeExpired: "); PrintNode(nodeExpired); }
-            RemoveNode(nodeExpired);
-        }
-        
-        // initialize nodeNew.lt_cnt
-        if (bTrace) Println("initialize nodeNew");
-        for (int i = 0; i < m_WindowSize; i++) {
-            nodeNew.lt_cnt.add(1);
-        }        
-        AddNode(nodeNew); // add nodeNew to window and index
-        if (bTrace) PrintWindow();
-        
-        // perform range query search
-        if (bTrace) Println("Perform range query seach");
-        nRangeQueriesExecuted++;
-        Vector<ISBIndex.ISBSearchResult> neighbors = ISB.RangeSearch(nodeNew, m_radius);
-
-        // process each returned node
-        for (ISBSearchResult res : neighbors) {
-            ISBNode node = res.node;
-            UpdateNeighbors(nodeNew, node);
-        }
-        
-        OutputPatterns();
-        
-        if (bTrace) {            
-            PrintOutliers();
-            for (ISBNode node : windowNodes) {
-                Print(node.id + ".lt_count: "); Print_lt_cnt(node.lt_cnt);
-            }
-        }
-    }
-}
diff --git a/moa/src/main/java/moa/clusterers/outliers/AbstractC/AbstractCBase.java b/moa/src/main/java/moa/clusterers/outliers/AbstractC/AbstractCBase.java
deleted file mode 100644
index 67150fa8b..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/AbstractC/AbstractCBase.java
+++ /dev/null
@@ -1,213 +0,0 @@
-/*
- *    AbstractCBase.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- *
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers.AbstractC;
-
-import java.util.ArrayList;
-import java.util.Vector;
-
-import moa.clusterers.outliers.MyBaseOutlierDetector;
-import moa.clusterers.outliers.AbstractC.ISBIndex.ISBNode;
-
-public abstract class AbstractCBase extends MyBaseOutlierDetector {    
-    protected static final Long FIRST_OBJ_ID = 1L;
-    
-    // object identifier increments with each new data stream object
-    protected Long objId;
-    // list used to find expired nodes
-    protected Vector<ISBNode> windowNodes; 
-    protected ISBIndex ISB;
-    protected int m_WindowSize;
-    protected double m_radius;
-    protected double m_Fraction;
-    protected boolean bWarning = false;
-    
-    // statistics
-    public int m_nBothInlierOutlier;
-    public int m_nOnlyInlier;
-    public int m_nOnlyOutlier;
-    
-    @Override
-    public String getObjectInfo(Object obj) {
-        if (obj == null) return null;
-        
-        ISBNode node = (ISBNode) obj;
-        
-        ArrayList<String> infoTitle = new ArrayList<String>();
-        ArrayList<String> infoValue = new ArrayList<String>();
-        StringBuilder sb = new StringBuilder();
-
-        // show node position
-        for (int i = 0; i < node.obj.dimensions(); i++) {
-            infoTitle.add("Dim" + (i+1));
-            infoValue.add(String.format("%.3f", node.obj.get(i)));
-        }
-        
-        // show node properties
-        infoTitle.add("id");
-        infoValue.add(String.format("%d", node.id));
-        
-        sb.append("<html>");
-        sb.append("<table>");
-        int i = 0;
-        while(i < infoTitle.size() && i < infoValue.size()){
-            sb.append("<tr><td><b>"+infoTitle.get(i)+":</b></td><td>"+infoValue.get(i)+"</td></tr>");
-            i++;
-        }
-        sb.append("</table>");
-
-        
-        sb.append("</html>");
-        return sb.toString();
-    }
-    
-    @Override
-    public String getStatistics() {
-        StringBuilder sb = new StringBuilder();
-        
-        sb.append("Statistics:\n\n");
-        
-        // get counters of expired nodes
-        int nBothInlierOutlier = m_nBothInlierOutlier;
-        int nOnlyInlier = m_nOnlyInlier;
-        int nOnlyOutlier = m_nOnlyOutlier;
-        
-        // add counters of non expired nodes
-        for (ISBNode node : windowNodes) {
-            if ((node.nInlier > 0) && (node.nOutlier > 0))
-                nBothInlierOutlier++;
-            else if (node.nInlier > 0)
-                nOnlyInlier++;
-            else
-                nOnlyOutlier++;
-        }
-        
-        int sum = nBothInlierOutlier + nOnlyInlier + nOnlyOutlier;
-        if (sum > 0) {
-            sb.append(String.format("  Nodes always inlier: %d (%.1f%%)\n", nOnlyInlier, (100 * nOnlyInlier) / (double)sum));
-            sb.append(String.format("  Nodes always outlier: %d (%.1f%%)\n", nOnlyOutlier, (100 * nOnlyOutlier) / (double)sum));
-            sb.append(String.format("  Nodes both inlier and outlier: %d (%.1f%%)\n", nBothInlierOutlier, (100 * nBothInlierOutlier) / (double)sum));
-            
-            sb.append("  (Sum: " + sum + ")\n");
-        }
-        
-        sb.append("\n  Total range queries: " + nRangeQueriesExecuted + "\n");
-        sb.append("  Max memory usage: " + iMaxMemUsage + " MB\n");
-        sb.append("  Total process time: " + String.format("%.2f ms", nTotalRunTime / 1000.0) + "\n");
-        
-        return sb.toString();
-    }
-    
-    Long GetWindowEnd() {
-        return objId - 1;
-    }
-    
-    Long GetWindowStart() {
-        Long x = GetWindowEnd() - m_WindowSize + 1;
-        if (x < FIRST_OBJ_ID) 
-            x = FIRST_OBJ_ID;
-        return x;
-    }
-    
-    boolean IsWinFull() {
-        return (GetWindowEnd() >= FIRST_OBJ_ID + m_WindowSize - 1);
-    }
-    
-    Long GetExpirationTime(ISBNode node) {
-        return node.id + m_WindowSize;
-    }
-    
-    void AddNode(ISBNode node) {
-        windowNodes.add(node);
-        ISB.Insert(node);
-    }
-    
-    void RemoveNode(ISBNode node) {
-        windowNodes.remove(node);
-        ISB.Remove(node);
-        RemoveExpiredOutlier(new Outlier(node.inst, node.id, node)); // ### remove when expired?
-        // update statistics
-        if ((node.nInlier > 0) && (node.nOutlier > 0))
-            m_nBothInlierOutlier++;
-        else if (node.nInlier > 0)
-            m_nOnlyInlier++;
-        else
-            m_nOnlyOutlier++;
-    }
-    
-    ISBNode GetExpiredNode() {
-        if (windowNodes.size() <= 0)
-            return null;       
-        // get oldest node
-        ISBNode node = windowNodes.get(0);
-        // check if node has expired
-        if (node.id < GetWindowStart()) {
-            return node;
-        }        
-        return null;
-    }
-    
-    void SaveOutlier(ISBNode node) {
-        AddOutlier(new Outlier(node.inst, node.id, node));
-        node.nOutlier++; // update statistics
-    }
-    
-    void RemoveOutlier(ISBNode node) {
-        RemoveOutlier(new Outlier(node.inst, node.id, node));
-        node.nInlier++; // update statistics
-    }
-    
-    @Override
-    protected boolean IsNodeIdInWin(long id) {
-        if ((GetWindowStart() <= id) && (id <= GetWindowEnd()) )
-            return true;
-        else
-            return false;
-    }
-    
-    void PrintWindow() {
-        Println("Window [" + GetWindowStart() + "-" + GetWindowEnd() + "]: ");
-        ISBNode node;
-        for (int i = 0; i < windowNodes.size(); i++) {
-            node = windowNodes.get(i);
-            Print("   Node: ");
-            PrintNode(node);
-        }
-    }
-    
-    void PrintNode(ISBNode n) {
-        Print("id=" + n.id + " (");
-        int dim = n.obj.dimensions();
-        for (int d = 0; d < dim; d++) {
-            Print(Double.toString(n.obj.get(d)));
-            if (d < dim - 1)
-                Print(", ");
-        }
-        Println(")");
-    }
-    
-    public void Print_lt_cnt(ArrayList<Integer> lt_cnt) {
-        for (int i = 0; i < lt_cnt.size(); i++) {
-            Print("(" + i + ": " + lt_cnt.get(i) + ") ");
-        }
-        Println("");
-    }
-}
diff --git a/moa/src/main/java/moa/clusterers/outliers/AbstractC/ISBIndex.java b/moa/src/main/java/moa/clusterers/outliers/AbstractC/ISBIndex.java
deleted file mode 100644
index 26c4292ad..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/AbstractC/ISBIndex.java
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
- *    ISBIndex.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- *
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers.AbstractC;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Set;
-import java.util.Vector;
-
-import com.yahoo.labs.samoa.instances.Instance;
-
-
-
-public class ISBIndex {    
-    public static class ISBNode {
-        public Instance inst;
-        public StreamObj obj;
-        public Long id;
-        public ArrayList<Integer> lt_cnt;
-        
-        // statistics
-        public int nOutlier;
-        public int nInlier;
-
-        public ISBNode(Instance inst, StreamObj obj, Long id) {
-            this.inst = inst;
-            this.obj = obj;
-            this.id = id;
-            lt_cnt = new ArrayList<Integer>();
-            
-            // init statistics
-            nOutlier = 0;
-            nInlier  = 0;
-        }
-    }
-    
-    MyMTree mtree;
-    Map<Integer, Set<ISBNode>> mapNodes;
-    double m_radius;
-    double m_Fraction;
-    
-    public ISBIndex(double radius, double fra) {
-        mtree = new MyMTree();
-        mapNodes = new HashMap<Integer, Set<ISBNode>>();
-        m_radius = radius;
-        m_Fraction = fra;
-    }
-    
-    public static class ISBSearchResult {
-        public ISBNode node;
-        public double distance;
-        
-        public ISBSearchResult(ISBNode n, double distance) {
-            this.node = n;
-            this.distance = distance;
-        }
-    }
-    
-    public Vector<ISBSearchResult> RangeSearch(ISBNode node, double radius) {
-        Vector<ISBSearchResult> results = new Vector<ISBSearchResult>();
-        // execute range search at mtree
-        StreamObj obj;
-        double d;
-        MyMTree.Query query = mtree.getNearestByRange(node.obj, radius);
-        for (MyMTree.ResultItem q : query) {
-            // get next obj found within range
-            obj = q.data;
-            // get distance of obj from query
-            d = q.distance;
-            // get all nodes referencing obj
-            Vector<ISBNode> nodes = MapGetNodes(obj);
-            for (int i = 0; i < nodes.size(); i++)
-                results.add(new ISBSearchResult(nodes.get(i), d));
-        }        
-        return results;
-    }
-    
-    public void Insert(ISBNode node) {
-        // insert object of node at mtree
-        mtree.add(node.obj);
-        // insert node at map
-        MapInsert(node);    
-    }
-    
-    public void Remove(ISBNode node) {
-        // remove from map
-        MapDelete(node);
-        // check if stream object at mtree is still being referenced
-        if (MapCountObjRefs(node.obj) <= 0) {
-            // delete stream object from mtree
-            mtree.remove(node.obj);
-        }
-    }
-    
-    Vector<ISBNode> MapGetNodes(StreamObj obj) {
-        int h = obj.hashCode();
-        Vector<ISBNode> v = new Vector<ISBNode>();
-        if (mapNodes.containsKey(h)) {
-            Set<ISBNode> s = mapNodes.get(h);
-            ISBNode node;
-            Iterator<ISBNode> i = s.iterator();
-            while (i.hasNext()) {
-                node = i.next();
-                if (node.obj.equals(obj))
-                    v.add(node);
-            }
-        }
-        return v;
-    }
-    
-    int MapCountObjRefs(StreamObj obj) {
-        int h = obj.hashCode();
-        int iCount = 0;
-        if (mapNodes.containsKey(h)) {
-            Set<ISBNode> s = mapNodes.get(h);
-            ISBNode n;
-            Iterator<ISBNode> i = s.iterator();
-            while (i.hasNext()) {
-                n = i.next();
-                if (n.obj.equals(obj))
-                    iCount++;
-            }
-        }
-        return iCount;
-    }
-    
-    void MapInsert(ISBNode node) {
-        int h = node.obj.hashCode();
-        Set<ISBNode> s;
-        if (mapNodes.containsKey(h)) {
-            s = mapNodes.get(h);
-            s.add(node);
-        }
-        else {
-            s = new HashSet<ISBNode>();
-            s.add(node);
-            mapNodes.put(h, s);
-        }
-    }
-    
-    void MapDelete(ISBNode node) {
-        int h = node.obj.hashCode();
-        if (mapNodes.containsKey(h)) {
-            Set<ISBNode> s = mapNodes.get(h);
-            s.remove(node);
-            if (s.isEmpty()) { // ### added
-                mapNodes.remove(h);
-            }
-        }
-    }    
-}
diff --git a/moa/src/main/java/moa/clusterers/outliers/AbstractC/MyMTree.java b/moa/src/main/java/moa/clusterers/outliers/AbstractC/MyMTree.java
deleted file mode 100644
index 5a2f5d531..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/AbstractC/MyMTree.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- *    MyMTree.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- *
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers.AbstractC;
-
-import java.util.Set;
-
-import moa.clusterers.outliers.utils.mtree.ComposedSplitFunction;
-import moa.clusterers.outliers.utils.mtree.DistanceFunction;
-import moa.clusterers.outliers.utils.mtree.DistanceFunctions;
-import moa.clusterers.outliers.utils.mtree.MTree;
-import moa.clusterers.outliers.utils.mtree.PartitionFunctions;
-import moa.clusterers.outliers.utils.mtree.PromotionFunction;
-import moa.clusterers.outliers.utils.mtree.utils.Pair;
-import moa.clusterers.outliers.utils.mtree.utils.Utils;
-
-
-class MyMTree extends MTree<StreamObj> {
-
-    private static final PromotionFunction<StreamObj> nonRandomPromotion = new PromotionFunction<StreamObj>() {
-
-        @Override
-        public Pair<StreamObj> process(Set<StreamObj> dataSet, DistanceFunction<? super StreamObj> distanceFunction) {
-            return Utils.minMax(dataSet);
-        }
-    };
-
-    MyMTree() {
-        super(2, DistanceFunctions.EUCLIDEAN,
-                new ComposedSplitFunction<StreamObj>(
-                nonRandomPromotion,
-                new PartitionFunctions.BalancedPartition<StreamObj>()));
-    }
-
-    public void add(StreamObj data) {
-        super.add(data);
-        _check();
-    }
-
-    public boolean remove(StreamObj data) {
-        boolean result = super.remove(data);
-        _check();
-        return result;
-    }
-
-    DistanceFunction<? super StreamObj> getDistanceFunction() {
-        return distanceFunction;
-    }
-};
diff --git a/moa/src/main/java/moa/clusterers/outliers/AbstractC/StreamObj.java b/moa/src/main/java/moa/clusterers/outliers/AbstractC/StreamObj.java
deleted file mode 100644
index d7a04a625..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/AbstractC/StreamObj.java
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- *    StreamObj.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers.AbstractC;
-
-import moa.clusterers.outliers.utils.mtree.DistanceFunctions.EuclideanCoordinate;
-
-public class StreamObj implements EuclideanCoordinate, Comparable<StreamObj> {
-    private final double[] values;
-    private final int hashCode;
-
-    public StreamObj(double... values) {
-        this.values = values;
-
-        int h = 1;
-        for (double value : values) {
-            h = 31 * (int) h + (int) value;
-        }
-        this.hashCode = h;
-    }
-
-    @Override
-    public int dimensions() {
-        return values.length;
-    }
-
-    @Override
-    public double get(int index) {
-        return values[index];
-    }
-
-    @Override
-    public int hashCode() {
-        return hashCode;
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (obj instanceof StreamObj) {
-            StreamObj that = (StreamObj) obj;
-            if (this.dimensions() != that.dimensions()) {
-                return false;
-            }
-            for (int i = 0; i < this.dimensions(); i++) {
-                if (this.values[i] != that.values[i]) {
-                    return false;
-                }
-            }
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    @Override
-    public int compareTo(StreamObj that) {
-        int dimensions = Math.min(this.dimensions(), that.dimensions());
-        for (int i = 0; i < dimensions; i++) {
-            double v1 = this.values[i];
-            double v2 = that.values[i];
-            if (v1 > v2) {
-                return +1;
-            }
-            if (v1 < v2) {
-                return -1;
-            }
-        }
-
-        if (this.dimensions() > dimensions) {
-            return +1;
-        }
-
-        if (that.dimensions() > dimensions) {
-            return -1;
-        }
-
-        return 0;
-    }
-}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/clusterers/outliers/AbstractC/Test.java b/moa/src/main/java/moa/clusterers/outliers/AbstractC/Test.java
deleted file mode 100644
index 46cc09f59..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/AbstractC/Test.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- *    Test.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- *
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers.AbstractC;
-
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.streams.clustering.RandomRBFGeneratorEvents;
-
-public class Test {    
-    public static void main(String[] args) throws Exception 
-    {
-        //if (true) return;
-        
-        int numInstances = 10000;        
-        //moa.streams.ArffFileStream stream = new ArffFileStream("./datasets/debug_1.txt", -1);
-        RandomRBFGeneratorEvents stream = new RandomRBFGeneratorEvents();
-        stream.prepareForUse();
-        
-        AbstractC myOutlierDetector= new AbstractC();
-        /*myOutlierDetector.fractionOption.setValue(0.2);
-        myOutlierDetector.radiusOption.setValue(3);
-        myOutlierDetector.windowSizeOption.setValue(12);*/
-        myOutlierDetector.setModelContext(stream.getHeader());
-        myOutlierDetector.prepareForUse();  
-        
-        Long tmStart = System.currentTimeMillis();
-        
-        int numberSamples = 0;  
-        int w = myOutlierDetector.windowSizeOption.getValue();      
-        while (stream.hasMoreInstances() && (numberSamples < numInstances)) {
-            Instance newInst = stream.nextInstance().getData();
-            myOutlierDetector.processNewInstanceImpl(newInst);            
-            numberSamples++;
-            if (numberSamples % 100 == 0) {
-                //System.out.println("Processed " + numberSamples + " stream objects.");  
-            }
-            if ((numberSamples % (w / 2)) == 0) {
-                //myOutlierDetector.PrintOutliers();
-            }
-        }        
-        // myOutlierDetector.PrintOutliers();
-        System.out.println("Total time = " + (System.currentTimeMillis() - tmStart) + " ms");
-    }
-}
diff --git a/moa/src/main/java/moa/clusterers/outliers/Angiulli/ApproxSTORM.java b/moa/src/main/java/moa/clusterers/outliers/Angiulli/ApproxSTORM.java
deleted file mode 100644
index 7b965ee9c..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/Angiulli/ApproxSTORM.java
+++ /dev/null
@@ -1,354 +0,0 @@
-/*
- *    ApproxSTORM.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers.Angiulli;
-
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.Random;
-import java.util.Set;
-import java.util.Vector;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.clusterers.outliers.Angiulli.ISBIndex.ISBNode;
-import moa.clusterers.outliers.Angiulli.ISBIndex.ISBSearchResult;
-
-
-public class ApproxSTORM extends STORMBase {
-    public class ISBNodeAppr extends ISBNode {
-        public Long count_after, count_before;
-        public double fract_before;
-        
-        public ISBNodeAppr(Instance inst, StreamObj obj, Long id, int k) {
-            super(inst, obj, id);
-            m_k = k;
-            count_after = 0L;
-            count_before = 0L;
-            fract_before = 0;
-        }
-    }
-    
-    public FloatOption radiusOption = new FloatOption("radius", 'r', "Search radius.", 0.1);
-    public IntOption kOption = new IntOption("k", 't', "Parameter k.", 50);
-    public IntOption queryFreqOption = new IntOption("queryFreq", 'q', "Query frequency.", 1);
-    public FloatOption pOption = new FloatOption("p", 'p', "Parameter p.", 0.1);
-    
-    Set<ISBNode> safe_inliers; // list of safe inliers
-    int m_FractWindowSize;  
-    Random m_Random;
-    
-    @Override
-    public String getObjectInfo(Object obj) {
-        if (obj == null) return null;
-        
-        ISBNodeAppr node = (ISBNodeAppr) obj;
-        
-        ArrayList<String> infoTitle = new ArrayList<String>();
-        ArrayList<String> infoValue = new ArrayList<String>();
-        StringBuilder sb = new StringBuilder();
-
-        // show node position
-        for (int i = 0; i < node.obj.dimensions(); i++) {
-            infoTitle.add("Dim" + (i+1));
-            infoValue.add(String.format("%.3f", node.obj.get(i)));
-        }
-        
-        // show node properties
-        infoTitle.add("id");
-        infoValue.add(String.format("%d", node.id));
-        infoTitle.add("count_after");
-        infoValue.add(String.format("%d", node.count_after));
-        infoTitle.add("count_before");
-        infoValue.add(String.format("%d", node.count_before));
-        
-        sb.append("<html>");
-        sb.append("<table>");
-        int i = 0;
-        while(i < infoTitle.size() && i < infoValue.size()){
-            sb.append("<tr><td><b>"+infoTitle.get(i)+":</b></td><td>"+infoValue.get(i)+"</td></tr>");
-            i++;
-        }
-        sb.append("</table>");
-
-        
-        sb.append("</html>");
-        return sb.toString();
-    }
-    
-    public ApproxSTORM()
-    {
-        // System.out.println("DistanceOutliersAppr: created");
-    }
-    
-    @Override
-    public void Init() {    
-        super.Init();
-              
-        m_WindowSize = windowSizeOption.getValue();
-        m_radius = radiusOption.getValue();
-        m_k = kOption.getValue();
-        m_QueryFreq = queryFreqOption.getValue();
-        m_FractWindowSize = (int) (pOption.getValue() * m_WindowSize);
-                
-        Println("Init DistanceOutliersAppr:");
-        Println("   window_size: " + m_WindowSize);
-        Println("   radius: " + m_radius);
-        Println("   k: " + m_k);
-        Println("   query_freq: " + m_QueryFreq);
-        
-        m_Random = new Random();
-        
-        objId = FIRST_OBJ_ID; // init object identifier
-        // create fifo
-        windowNodes = new Vector<ISBNode>();
-        // create ISB
-        ISB = new ISBIndex(m_radius, m_k);
-        // create safe_inliers list
-        safe_inliers = new HashSet<ISBNode>();
-        
-        // init statistics
-        m_nBothInlierOutlier = 0;
-        m_nOnlyInlier = 0;
-        m_nOnlyOutlier = 0;
-    }
-    
-    void AddSafeInlier(ISBNode node) {
-        safe_inliers.add(node);
-    }
-    
-    ISBNode GetSafeInlier(int idx) {
-        ISBNode node = null;
-        Iterator it = safe_inliers.iterator();
-        while (idx >= 0) {
-            node = (ISBNodeAppr)it.next();
-            idx--;
-        }
-        return node;
-    }
-    
-    boolean IsSafeInlier(ISBNodeAppr node) {
-        return node.count_after >= m_k;
-    }
-    
-    void PrintSafeInliers() {
-        Print("Safe inliers: ");
-        ISBNode node;
-        Iterator it = safe_inliers.iterator();
-        while (it.hasNext()) {
-            node = (ISBNode) it.next();
-            Print(node.id + " ");
-        }
-        Println(" ");
-    }
-    
-    void RemoveNode(ISBNode node) {
-        // remove node from ISB
-        ISB.Remove(node);   
-        // remove from fifo
-        windowNodes.remove(node);
-        // remove node from safe_inliers
-        safe_inliers.remove(node);
-        // remove from outliers
-        RemoveExpiredOutlier(new Outlier(node.inst, node.id, node));
-        // update statistics
-        UpdateStatistics(node);
-    }
-    
-    void RemoveSafeInlier(ISBNode node) {
-        // remove node from ISB
-        ISB.Remove(node);   
-        // remove node from safe_inliers
-        safe_inliers.remove(node);
-    }
-    
-    void DeleteExpiredNode() {
-        if (windowNodes.size() <= 0)
-            return;        
-       
-        // get oldest node
-        ISBNode node = windowNodes.get(0);
-        // check if node has expired
-        if (node.id < GetWindowStart()) {
-            if (bTrace) {
-                Print("Delete expired node: ");
-                PrintNode(node);
-            }
-            // remove node
-            RemoveNode(node);
-        }
-    }
-    
-    @Override
-    protected void ProcessNewStreamObj(Instance inst)
-    {
-        if (bShowProgress) ShowProgress("Processed " + objId + " stream objects.");       
-        // PrintInstance(inst);
-        
-        double[] values = getInstanceValues(inst);
-        StreamObj obj = new StreamObj(values);
-        
-        if (bTrace) Println("\n- - - - - - - - - - - -\n");
-
-        // delete a node if it has expired
-        DeleteExpiredNode();
-
-        // create new ISB node
-        ISBNodeAppr nodeNew = new ISBNodeAppr(inst, obj, objId, m_k);
-        if (bTrace) {
-            Print("New obj: ");
-            PrintNode(nodeNew);
-        }
-        
-        // update object identifier
-        objId++;
-        
-        // init nodeNew
-        nodeNew.count_after = 1L;
-        nodeNew.count_before = 0L;
-
-        // perform range query search
-        if (bTrace) Println("Perform range query seach:");
-        nRangeQueriesExecuted++;
-        Vector<ISBIndex.ISBSearchResult> nodes = ISB.RangeSearch(nodeNew, m_radius);
-
-        // process each returned node
-        int nSafeInliers;
-        Long count_si_before = 0L;
-        for (ISBSearchResult res : nodes) {
-            ISBNodeAppr n = (ISBNodeAppr) res.node;
-            if (bTrace) {
-                Printf("   Found at d=%.2f: ", res.distance);
-                PrintNode(res.node);
-            }
-
-            n.count_after++;
-
-            if (IsSafeInlier(n)) {
-                if (bTrace) Println("   Safe inlier: id=" + n.id);
-                AddSafeInlier(n);
-                count_si_before++;
-            }
-
-            nSafeInliers = safe_inliers.size();
-            if (nSafeInliers > m_FractWindowSize) {
-                // get a random safe inlier: 0 <= idx < nSafeInliers
-                int idx = m_Random.nextInt(nSafeInliers);
-                ISBNode si = GetSafeInlier(idx);
-                if (bTrace) Println("   Remove random safe inlier: id=" + si.id);
-                // remove node from ISB and safe-inliers-list
-                RemoveSafeInlier(si);
-            }
-
-            nodeNew.count_before++;
-        }
-
-        // Set fract_before of curr_node which is determined as the ratio 
-        // between the number of preceding neighbors of curr_node in ISB 
-        // which are safe inliers and the total number of safe inliers in 
-        // ISB, at the arrival time of curr_node.
-
-        nSafeInliers = safe_inliers.size();
-        if (nSafeInliers > 0) {
-            nodeNew.fract_before = (double)count_si_before / (double)nSafeInliers;
-        }
-        else {
-            if (bTrace) Println("Set fract before: no safe inliers yet, set 0.");
-            nodeNew.fract_before = 0;
-        }
-
-        if (bTrace) {
-            Println("Node: ");
-            Println("   count_after=" + nodeNew.count_after);
-            Println("   count_before=" + nodeNew.count_before);
-            Printf("   fract_before=%.3f\n", nodeNew.fract_before);
-            Println("Insert new node to ISB.");
-        }
-        
-        // insert node to ISB
-        ISB.Insert(nodeNew);
-        
-        // insert node at window
-        windowNodes.add(nodeNew);
-
-        if (bTrace) {
-            PrintWindow();
-            PrintSafeInliers();
-        }
-        
-        if (CanSearch()) {
-            // invoke query function to detect outliers
-            SearchOutliers();
-        } else {
-            // update statistics outlierness of new node
-            UpdateNodeStatistics(nodeNew);
-        }
-    }
-    
-    void SearchOutliers() {
-        if (bTrace) Println("Invoke query: ");
-        ISBNodeAppr node;
-        // process each node in the ISB (also in window)
-        for (int i = 0; i < windowNodes.size(); i++) {
-            node = (ISBNodeAppr) windowNodes.get(i);
-            if (bTrace) {
-                Print("   Process node: ");
-                PrintNode(node);
-            }
-            UpdateNodeType(node);            
-        }
-    }
-    
-    void UpdateNodeType(ISBNodeAppr node) {
-        double succ_neighs, prec_neighs;
-        
-        // get number of succeeding neighbors
-        succ_neighs = node.count_after;
-        if (bTrace) Println("      succ_neighs: " + succ_neighs);
-
-        // get number of preceding neighbors
-        prec_neighs = node.fract_before * (double)Math.abs((node.id + m_WindowSize) - GetWindowEnd());
-        if (bTrace) Println("      prec_neighs: " + prec_neighs);
-
-        // check if node is an outlier
-        if (succ_neighs + prec_neighs < m_k) {
-            SaveOutlier(node);
-            if (bTrace) {
-                Print("*** Outlier: ");
-                PrintNode(node);
-            }
-        } else {
-            RemoveOutlier(node);
-        }
-    }
-    
-    void UpdateNodeStatistics(ISBNodeAppr node) {
-        double succ_neighs = node.count_after;
-        double prec_neighs = node.fract_before * (double)Math.abs((node.id + m_WindowSize) - GetWindowEnd());
-        if (succ_neighs + prec_neighs < m_k) {
-            node.nOutlier++; // update statistics
-        } else {
-            node.nInlier++; // update statistics
-        }
-    }
-}
diff --git a/moa/src/main/java/moa/clusterers/outliers/Angiulli/ExactSTORM.java b/moa/src/main/java/moa/clusterers/outliers/Angiulli/ExactSTORM.java
deleted file mode 100644
index 652632ae1..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/Angiulli/ExactSTORM.java
+++ /dev/null
@@ -1,305 +0,0 @@
-/*
- *    ExactSTORM.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- *
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-package moa.clusterers.outliers.Angiulli;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.Vector;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.clusterers.outliers.Angiulli.ISBIndex.ISBNode;
-import moa.clusterers.outliers.Angiulli.ISBIndex.ISBSearchResult;
-
-
-// The algorithm is presented in "Distance-based outlier queries in data streams: the novel task and algorithms.
-//Data Mining and Knowledge Discovery, 20(2):290–324,2010.
-
-
-public class ExactSTORM extends STORMBase {    
-    public class ISBNodeExact extends ISBNode {
-        public int count_after;
-        // nn_before:
-        //   A list that needs O(logn) time for ordered insertion and search.
-        //   It must be able to perform a search in the list using e.g. <=.
-        private ArrayList<Long> nn_before;
-        
-        public ISBNodeExact(Instance inst, StreamObj obj, Long id, int k) {
-            super(inst, obj, id);
-            m_k = k;
-            count_after = 0;
-            nn_before = new ArrayList<Long>();
-        }
-        
-        public void AddPrecNeigh(Long id) {
-            int pos = Collections.binarySearch(nn_before, id);
-            if (pos < 0) {
-                // item does not exist, so add it to the right position
-                nn_before.add(-(pos + 1), id);
-            }
-        }
-        
-        public int CountPrecNeighs(Long sinceId) {
-            if (nn_before.size() > 0) {
-                // get number of neighs with id >= sinceId
-                int startPos;
-                int pos = Collections.binarySearch(nn_before, sinceId);
-                if (pos < 0) {
-                    // item does not exist, should insert at position startPos
-                    startPos = -(pos + 1);
-                } else {
-                    // item exists at startPos
-                    startPos = pos;
-                }
-                
-                if (startPos < nn_before.size()) {
-                    return nn_before.size() - startPos;
-                }
-            }
-            return 0;
-        }
-        
-        public void PrintPrecNeighs() {
-            Print("      nn_before: ");
-            Iterator it = nn_before.iterator();
-            while (it.hasNext()) {
-                Print((Long)it.next() + " ");
-            }
-            Println(" ");
-        }
-    }
-    
-    public FloatOption radiusOption = new FloatOption("radius", 'r', "Search radius.", 0.1);
-    public IntOption kOption = new IntOption("k", 't', "Parameter k.", 50);
-    public IntOption queryFreqOption = new IntOption("queryFreq", 'q', "Query frequency.", 1);
-    
-    public ExactSTORM()
-    {
-        // System.out.println("DistanceOutliersExact: created");
-    }
-    
-    @Override
-    public String getObjectInfo(Object obj) {
-        if (obj == null) return null;
-        
-        ISBNodeExact node = (ISBNodeExact) obj;
-        
-        ArrayList<String> infoTitle = new ArrayList<String>();
-        ArrayList<String> infoValue = new ArrayList<String>();
-        StringBuilder sb = new StringBuilder();
-
-        // show node position
-        for (int i = 0; i < node.obj.dimensions(); i++) {
-            infoTitle.add("Dim" + (i+1));
-            infoValue.add(String.format("%.3f", node.obj.get(i)));
-        }
-        
-        // show node properties
-        infoTitle.add("id");
-        infoValue.add(String.format("%d", node.id));
-        infoTitle.add("count_after");
-        infoValue.add(String.format("%d", node.count_after));
-        infoTitle.add("|nn_before|");
-        infoValue.add(String.format("%d", node.CountPrecNeighs(GetWindowStart())));
-        
-        sb.append("<html>");
-        sb.append("<table>");
-        int i = 0;
-        while(i < infoTitle.size() && i < infoValue.size()){
-            sb.append("<tr><td><b>"+infoTitle.get(i)+":</b></td><td>"+infoValue.get(i)+"</td></tr>");
-            i++;
-        }
-        sb.append("</table>");
-
-        
-        sb.append("</html>");
-        return sb.toString();
-    }
-    
-    @Override
-    public void Init() {   
-        super.Init();
-        
-        m_WindowSize = windowSizeOption.getValue();
-        m_radius = radiusOption.getValue();
-        m_k = kOption.getValue();
-        m_QueryFreq = queryFreqOption.getValue();
-                
-        Println("Init DistanceOutliersExact:");
-        Println("   window_size: " + m_WindowSize);
-        Println("   radius: " + m_radius);
-        Println("   k: " + m_k);
-        Println("   query_freq: " + m_QueryFreq);
-        
-        objId = FIRST_OBJ_ID; // init object identifier
-        // create fifo
-        windowNodes = new Vector<ISBNode>();
-        // create ISB
-        ISB = new ISBIndex(m_radius, m_k);
-        
-        // init statistics
-        m_nBothInlierOutlier = 0;
-        m_nOnlyInlier = 0;
-        m_nOnlyOutlier = 0;
-    }
-    
-    void RemoveNode(ISBNode node) {
-        // remove node from ISB
-        ISB.Remove(node);   
-        // remove from fifo
-        windowNodes.remove(node);
-        // remove from outliers
-        RemoveExpiredOutlier(new Outlier(node.inst, node.id, node));
-        // update statistics
-        UpdateStatistics(node);
-    }
-    
-    void DeleteExpiredNode() {
-        if (windowNodes.size() <= 0)
-            return;        
-       
-        // get oldest node
-        ISBNode node = windowNodes.get(0);
-        // check if node has expired
-        if (node.id < GetWindowStart()) {
-            if (bTrace) {
-                Print("Delete expired node: ");
-                PrintNode(node);
-            }
-            // remove node
-            RemoveNode(node);
-        }
-    }
-    
-    @Override
-    protected void ProcessNewStreamObj(Instance inst)
-    {        
-        if (bShowProgress) ShowProgress("Processed " + objId + " stream objects.");       
-        // PrintInstance(inst);
-        
-        double[] values = getInstanceValues(inst);
-        StreamObj obj = new StreamObj(values);
-        
-        if (bTrace) Println("\n- - - - - - - - - - - -\n");
-
-        // create new ISB node
-        ISBNodeExact nodeNew = new ISBNodeExact(inst, obj, objId, m_k);
-        if (bTrace) {
-            Print("New obj: ");
-            PrintNode(nodeNew);
-        }
-        // update object identifier
-        objId++;
-        
-        // delete a node if it has expired
-        DeleteExpiredNode();
-        
-        // init nodeNew
-        nodeNew.count_after = 1;
-
-        // perform range query search
-        if (bTrace) Println("Perform range query seach:");
-        nRangeQueriesExecuted++;
-        Vector<ISBIndex.ISBSearchResult> nodes = ISB.RangeSearch(nodeNew, m_radius);
-
-        // process each returned node
-        for (ISBSearchResult res : nodes) {
-            ISBNodeExact n = (ISBNodeExact) res.node;
-            if (bTrace)  {
-                Printf("   Found at d=%.2f: ", res.distance);
-                PrintNode(res.node);
-            }
-            
-            n.count_after++;            
-            nodeNew.AddPrecNeigh(res.node.id);
-        }
-
-        if (bTrace) Println("Insert new node to ISB.");
-        ISB.Insert(nodeNew);
-        
-        // insert node at window
-        windowNodes.add(nodeNew);
-        if (bTrace) PrintWindow();
-        
-        if (CanSearch()) {
-            // invoke query function to detect outliers
-            SearchOutliers();
-        } else {
-            // update statistics outlierness of new node
-            UpdateNodeStatistics(nodeNew);
-        }
-    }
-    
-    void SearchOutliers() {
-        if (bTrace) Println("Invoke query: ");
-        ISBNodeExact node;
-        // process each node in the ISB (also in window)
-        for (int i = 0; i < windowNodes.size(); i++) {
-            node = (ISBNodeExact) windowNodes.get(i);
-            if (bTrace) {
-                Print("   Process node: ");
-                PrintNode(node);
-            }
-            UpdateNodeType(node);        
-        }
-    }
-    
-    void UpdateNodeType(ISBNodeExact node) {
-        int succ_neighs, prec_neighs;
-        
-        // get number of succeeding neighbors
-        succ_neighs = node.count_after;
-        if (bTrace) Println("      succ_neighs: " + succ_neighs);
-
-        // get number of preceding neighbors with
-        // non-expired objects determined
-        prec_neighs = node.CountPrecNeighs(GetWindowStart());
-        if (bTrace) {
-            Println("      GetWindowStart(): " + GetWindowStart());
-            node.PrintPrecNeighs();
-            Println("      prec_neighs: " + prec_neighs);
-        }
-
-        // check if node is an outlier
-        if (succ_neighs + prec_neighs < m_k) {
-            SaveOutlier(node);
-            if (bTrace) {
-                Print("*** Outlier: ");
-                PrintNode(node);
-            }
-        } else {
-            RemoveOutlier(node);
-        }
-    }
-    
-    void UpdateNodeStatistics(ISBNodeExact node) {
-        int succ_neighs = node.count_after;
-        int prec_neighs = node.CountPrecNeighs(GetWindowStart());
-        if (succ_neighs + prec_neighs < m_k) {
-            node.nOutlier++; // update statistics
-        } else {
-            node.nInlier++; // update statistics
-        }
-    }
-}
diff --git a/moa/src/main/java/moa/clusterers/outliers/Angiulli/ISBIndex.java b/moa/src/main/java/moa/clusterers/outliers/Angiulli/ISBIndex.java
deleted file mode 100644
index 47bb87b5c..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/Angiulli/ISBIndex.java
+++ /dev/null
@@ -1,167 +0,0 @@
-/*
- *    ISBIndex.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-package moa.clusterers.outliers.Angiulli;
-
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Set;
-import java.util.Vector;
-
-import com.yahoo.labs.samoa.instances.Instance;
-
-
-public class ISBIndex {    
-    public abstract static class ISBNode {
-        public Instance inst;
-        public StreamObj obj;
-        public Long id;
-        
-        // statistics
-        public int nOutlier;
-        public int nInlier;
-
-        public ISBNode(Instance inst, StreamObj obj, Long id) {
-            this.inst = inst;
-            this.obj = obj;
-            this.id = id;
-            
-            // init statistics
-            nOutlier = 0;
-            nInlier  = 0;
-        }
-    }
-    
-    MyMTree mtree;
-    Map<Integer, Set<ISBNode>> mapNodes;
-    double m_radius;
-    int m_k; // k nearest neighbors
-    
-    public ISBIndex(double radius, int k) {
-        mtree = new MyMTree();
-        mapNodes = new HashMap<Integer, Set<ISBNode>>();
-        m_radius = radius;
-        m_k = k;
-    }
-    
-    public static class ISBSearchResult {
-        public ISBNode node;
-        public double distance;
-        
-        public ISBSearchResult(ISBNode n, double distance) {
-            this.node = n;
-            this.distance = distance;
-        }
-    }
-    
-    public Vector<ISBSearchResult> RangeSearch(ISBNode node, double radius) {
-        Vector<ISBSearchResult> results = new Vector<ISBSearchResult>();
-        // execute range search at mtree
-        StreamObj obj;
-        double d;
-        MyMTree.Query query = mtree.getNearestByRange(node.obj, radius);
-        for (MyMTree.ResultItem q : query) {
-            // get next obj found within range
-            obj = q.data;
-            // get distance of obj from query
-            d = q.distance;
-            // get all nodes referencing obj
-            Vector<ISBNode> nodes = MapGetNodes(obj);
-            for (int i = 0; i < nodes.size(); i++)
-                results.add(new ISBSearchResult(nodes.get(i), d));
-        }        
-        return results;
-    }
-    
-    public void Insert(ISBNode node) {
-        // insert object of node at mtree
-        mtree.add(node.obj);
-        // insert node at map
-        MapInsert(node);    
-    }
-    
-    public void Remove(ISBNode node) {
-        // remove from map
-        MapDelete(node);
-        // check if stream object at mtree is still being referenced
-        if (MapCountObjRefs(node.obj) <= 0) {
-            // delete stream object from mtree
-            mtree.remove(node.obj);
-        }
-    }
-    
-    Vector<ISBNode> MapGetNodes(StreamObj obj) {
-        int h = obj.hashCode();
-        Vector<ISBNode> v = new Vector<ISBNode>();
-        if (mapNodes.containsKey(h)) {
-            Set<ISBNode> s = mapNodes.get(h);
-            ISBNode node;
-            Iterator<ISBNode> i = s.iterator();
-            while (i.hasNext()) {
-                node = i.next();
-                if (node.obj.equals(obj))
-                    v.add(node);
-            }
-        }
-        return v;
-    }
-    
-    int MapCountObjRefs(StreamObj obj) {
-        int h = obj.hashCode();
-        int iCount = 0;
-        if (mapNodes.containsKey(h)) {
-            Set<ISBNode> s = mapNodes.get(h);
-            ISBNode n;
-            Iterator<ISBNode> i = s.iterator();
-            while (i.hasNext()) {
-                n = i.next();
-                if (n.obj.equals(obj))
-                    iCount++;
-            }
-        }
-        return iCount;
-    }
-    
-    void MapInsert(ISBNode node) {
-        int h = node.obj.hashCode();
-        Set<ISBNode> s;
-        if (mapNodes.containsKey(h)) {
-            s = mapNodes.get(h);
-            s.add(node);
-        }
-        else {
-            s = new HashSet<ISBNode>();
-            s.add(node);
-            mapNodes.put(h, s);
-        }
-    }
-    
-    void MapDelete(ISBNode node) {
-        int h = node.obj.hashCode();
-        if (mapNodes.containsKey(h)) {
-            Set<ISBNode> s = mapNodes.get(h);
-            s.remove(node);
-            if (s.isEmpty()) { // ### added
-                mapNodes.remove(h);
-            }
-        }
-    }    
-}
diff --git a/moa/src/main/java/moa/clusterers/outliers/Angiulli/MyMTree.java b/moa/src/main/java/moa/clusterers/outliers/Angiulli/MyMTree.java
deleted file mode 100644
index 96ba2625c..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/Angiulli/MyMTree.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- *    MyMTree.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers.Angiulli;
-
-import java.util.Set;
-
-import moa.clusterers.outliers.utils.mtree.ComposedSplitFunction;
-import moa.clusterers.outliers.utils.mtree.DistanceFunction;
-import moa.clusterers.outliers.utils.mtree.DistanceFunctions;
-import moa.clusterers.outliers.utils.mtree.MTree;
-import moa.clusterers.outliers.utils.mtree.PartitionFunctions;
-import moa.clusterers.outliers.utils.mtree.PromotionFunction;
-import moa.clusterers.outliers.utils.mtree.utils.Pair;
-import moa.clusterers.outliers.utils.mtree.utils.Utils;
-
-class MyMTree extends MTree<StreamObj> {
-
-    private static final PromotionFunction<StreamObj> nonRandomPromotion = new PromotionFunction<StreamObj>() {
-
-        @Override
-        public Pair<StreamObj> process(Set<StreamObj> dataSet, DistanceFunction<? super StreamObj> distanceFunction) {
-            return Utils.minMax(dataSet);
-        }
-    };
-
-    MyMTree() {
-        super(2, DistanceFunctions.EUCLIDEAN,
-                new ComposedSplitFunction<StreamObj>(
-                nonRandomPromotion,
-                new PartitionFunctions.BalancedPartition<StreamObj>()));
-    }
-
-    public void add(StreamObj data) {
-        super.add(data);
-        _check();
-    }
-
-    public boolean remove(StreamObj data) {
-        boolean result = super.remove(data);
-        _check();
-        return result;
-    }
-
-    DistanceFunction<? super StreamObj> getDistanceFunction() {
-        return distanceFunction;
-    }
-};
diff --git a/moa/src/main/java/moa/clusterers/outliers/Angiulli/STORMBase.java b/moa/src/main/java/moa/clusterers/outliers/Angiulli/STORMBase.java
deleted file mode 100644
index d1e2cbf28..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/Angiulli/STORMBase.java
+++ /dev/null
@@ -1,160 +0,0 @@
-/*
- *    STORMBase.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers.Angiulli;
-
-import java.util.Vector;
-
-import com.github.javacliparser.FlagOption;
-
-import moa.clusterers.outliers.MyBaseOutlierDetector;
-import moa.clusterers.outliers.Angiulli.ISBIndex.ISBNode;
-
-public abstract class STORMBase extends MyBaseOutlierDetector {   
-    public FlagOption waitWinFullOption = new FlagOption("waitWinFull", 'a', "Output outliers when windows is full.");
-     
-    protected static final Long FIRST_OBJ_ID = 1L;
-    
-    // object identifier increments with each new data stream object
-    protected Long objId;
-    // list used to find expired nodes
-    protected Vector<ISBNode> windowNodes; 
-    protected ISBIndex ISB;
-    protected int m_WindowSize;
-    protected double m_radius;
-    protected int m_k;
-    // perform a query every m_QueryFreq objects
-    protected int m_QueryFreq; 
-    
-    // statistics
-    public int m_nBothInlierOutlier;
-    public int m_nOnlyInlier;
-    public int m_nOnlyOutlier;
-    
-    @Override
-    public String getStatistics() {
-        StringBuilder sb = new StringBuilder();
-        
-        sb.append("Statistics:\n\n");
-        
-        // get counters of expired nodes
-        int nBothInlierOutlier = m_nBothInlierOutlier;
-        int nOnlyInlier = m_nOnlyInlier;
-        int nOnlyOutlier = m_nOnlyOutlier;
-        
-        // add counters of non expired nodes
-        for (ISBNode node : windowNodes) {
-            if ((node.nInlier > 0) && (node.nOutlier > 0))
-                nBothInlierOutlier++;
-            else if (node.nInlier > 0)
-                nOnlyInlier++;
-            else
-                nOnlyOutlier++;
-        }
-        
-        int sum = nBothInlierOutlier + nOnlyInlier + nOnlyOutlier;
-        if (sum > 0) {
-            sb.append(String.format("  Nodes always inlier: %d (%.1f%%)\n", nOnlyInlier, (100 * nOnlyInlier) / (double)sum));
-            sb.append(String.format("  Nodes always outlier: %d (%.1f%%)\n", nOnlyOutlier, (100 * nOnlyOutlier) / (double)sum));
-            sb.append(String.format("  Nodes both inlier and outlier: %d (%.1f%%)\n", nBothInlierOutlier, (100 * nBothInlierOutlier) / (double)sum));
-            
-            sb.append("  (Sum: " + sum + ")\n");
-        }
-        
-        sb.append("\n  Total range queries: " + nRangeQueriesExecuted + "\n");
-        sb.append("  Max memory usage: " + iMaxMemUsage + " MB\n");
-        sb.append("  Total process time: " + String.format("%.2f ms", nTotalRunTime / 1000.0) + "\n");
-        
-        return sb.toString();
-    }
-    
-    Long GetWindowEnd() {
-        return objId - 1;
-    }
-    
-    Long GetWindowStart() {
-        Long x = GetWindowEnd() - m_WindowSize + 1;
-        if (x < FIRST_OBJ_ID) 
-            x = FIRST_OBJ_ID;
-        return x;
-    }
-    
-    boolean IsWinFull() {
-        return (GetWindowEnd() >= FIRST_OBJ_ID + m_WindowSize - 1);
-    }
-    
-    boolean CanSearch() {
-        if (IsWinFull()  || !waitWinFullOption.isSet()) {
-            if ((GetWindowEnd() - FIRST_OBJ_ID + 1) % m_QueryFreq == 0) {
-                // perform query every m_QueryFreq objects
-                return true;
-            }
-        }
-        return false;
-    }
-    
-    void SaveOutlier(ISBNode node) {
-        AddOutlier(new Outlier(node.inst, node.id, node));
-        node.nOutlier++; // update statistics
-    }
-    
-    void RemoveOutlier(ISBNode node) {
-        RemoveOutlier(new Outlier(node.inst, node.id, node));
-        node.nInlier++; // update statistics
-    }
-    
-    protected void UpdateStatistics(ISBNode node) {
-        if ((node.nInlier > 0) && (node.nOutlier > 0))
-            m_nBothInlierOutlier++;
-        else if (node.nInlier > 0)
-            m_nOnlyInlier++;
-        else
-            m_nOnlyOutlier++;
-    }
-    
-    @Override
-    protected boolean IsNodeIdInWin(long id) {
-        if ((GetWindowStart() <= id) && (id <= GetWindowEnd()) )
-            return true;
-        else
-            return false;
-    }
-    
-    void PrintWindow() {
-        Println("Window [" + GetWindowStart() + "-" + GetWindowEnd() + "]: ");
-        ISBNode node;
-        for (int i = 0; i < windowNodes.size(); i++) {
-            node = windowNodes.get(i);
-            Print("   Node: ");
-            PrintNode(node);
-        }
-    }
-    
-    void PrintNode(ISBNode n) {
-        Print("id=" + n.id + " (");
-        int dim = n.obj.dimensions();
-        for (int d = 0; d < dim; d++) {
-            Print(Double.toString(n.obj.get(d)));
-            if (d < dim - 1)
-                Print(", ");
-        }
-        Println(")");
-    }
-}
diff --git a/moa/src/main/java/moa/clusterers/outliers/Angiulli/StreamObj.java b/moa/src/main/java/moa/clusterers/outliers/Angiulli/StreamObj.java
deleted file mode 100644
index eb38037a6..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/Angiulli/StreamObj.java
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- *    StreamObj.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers.Angiulli;
-
-import moa.clusterers.outliers.utils.mtree.DistanceFunctions.EuclideanCoordinate;
-
-public class StreamObj implements EuclideanCoordinate, Comparable<StreamObj> {
-    private final double[] values;
-    private final int hashCode;
-
-    public StreamObj(double... values) {
-        this.values = values;
-
-        int h = 1;
-        for (double value : values) {
-            h = 31 * (int) h + (int) value;
-        }
-        this.hashCode = h;
-    }
-
-    @Override
-    public int dimensions() {
-        return values.length;
-    }
-
-    @Override
-    public double get(int index) {
-        return values[index];
-    }
-
-    @Override
-    public int hashCode() {
-        return hashCode;
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (obj instanceof StreamObj) {
-            StreamObj that = (StreamObj) obj;
-            if (this.dimensions() != that.dimensions()) {
-                return false;
-            }
-            for (int i = 0; i < this.dimensions(); i++) {
-                if (this.values[i] != that.values[i]) {
-                    return false;
-                }
-            }
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    @Override
-    public int compareTo(StreamObj that) {
-        int dimensions = Math.min(this.dimensions(), that.dimensions());
-        for (int i = 0; i < dimensions; i++) {
-            double v1 = this.values[i];
-            double v2 = that.values[i];
-            if (v1 > v2) {
-                return +1;
-            }
-            if (v1 < v2) {
-                return -1;
-            }
-        }
-
-        if (this.dimensions() > dimensions) {
-            return +1;
-        }
-
-        if (that.dimensions() > dimensions) {
-            return -1;
-        }
-
-        return 0;
-    }
-}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/clusterers/outliers/Angiulli/Test.java b/moa/src/main/java/moa/clusterers/outliers/Angiulli/Test.java
deleted file mode 100644
index dc6de05d5..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/Angiulli/Test.java
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- *    Test.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers.Angiulli;
-
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.streams.clustering.RandomRBFGeneratorEvents;
-
-
-public class Test {    
-    public static void main(String[] args) throws Exception 
-    {
-        //if (true) return;
-        
-        int numInstances = 10000;
-        
-        RandomRBFGeneratorEvents stream = new RandomRBFGeneratorEvents();
-        stream.prepareForUse();
-        
-        //DistanceOutliersAppr myOutlierDetector= new DistanceOutliersAppr();
-        ExactSTORM myOutlierDetector= new ExactSTORM();
-        myOutlierDetector.queryFreqOption.setValue(1);
-        myOutlierDetector.setModelContext(stream.getHeader());
-        myOutlierDetector.prepareForUse();  
-        
-        Long tmStart = System.currentTimeMillis();
-        
-        int numberSamples = 0;  
-        int w = myOutlierDetector.windowSizeOption.getValue();      
-        while (stream.hasMoreInstances() && (numberSamples < numInstances)) {
-            Instance newInst = stream.nextInstance().getData();
-            myOutlierDetector.processNewInstanceImpl(newInst);            
-            numberSamples++;
-            if (numberSamples % 100 == 0) {
-                //System.out.println("Processed " + numberSamples + " stream objects.");  
-            }
-            if ((numberSamples % (w / 2)) == 0) {
-                //myOutlierDetector.PrintOutliers();
-            }
-        }        
-        // myOutlierDetector.PrintOutliers();
-        System.out.println("Total time = " + (System.currentTimeMillis() - tmStart) + " ms");
-    }
-}
diff --git a/moa/src/main/java/moa/clusterers/outliers/AnyOut/util/DataObject.java b/moa/src/main/java/moa/clusterers/outliers/AnyOut/util/DataObject.java
deleted file mode 100644
index 12679afcb..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/AnyOut/util/DataObject.java
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
- *    DataObject.java
- *
- *    @author F. Sanchez, I. Assent, P. Kranen, C. Baldauf, T. Seidl
- *    @author G. Piskas, A. Gounaris
- * 
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers.AnyOut.util;
-
-import com.yahoo.labs.samoa.instances.Instance;
-
-
-
-/**
- * This object encapsulates a data point.
- * @author Fernando Sanchez Villaamil
- */
-
-public class DataObject {
-    
-    private int id;
-    private Instance inst;
-    private double[] features;
-    private int classLabel;
-    private boolean isOutiler;
-
-    /**
-     * Returns the features (label attribute excluded).
-     * @return An array <code>double[]</code> with the features.
-     */
-    public double[] getFeatures() {
-    	double[] filteredFeatures = new double[features.length-1];
-    	for (int i = 0; i<filteredFeatures.length; i++)
-    		filteredFeatures[i]=features[i];
-        return filteredFeatures;
-    }
-
-    /**
-     * Returns the id for the <code>DataObject</code>.
-     * @return An <code>int</code> with the id of the <code>DataObject</code>.
-     */
-    public int getId() {
-        return id;
-    }
-    public void setId(int id){
-    	this.id=id;
-    }
-    
-    /**
-     * Return the label for the <code>DataObject</code>.
-     * @return An <code>int</code> which codes the label.
-     */
-    public int getClassLabel() {
-        return classLabel;
-    }
-    
-    /**
-     * Return the <code>Instance</code> of the <code>DataObject</code>.
-     * @return An <code>Instance</code>.
-     */
-    public Instance getInstance() {
-        return inst;
-    }
-    /**
-     * Standard constructor for <code>DataObject</code>.
-     * @param idCounter The id for the <code>DataObject</code>.
-     * @param features The feature as a <code>double[]</code>
-     * @param classLabel The label id for the <code>DataObject</code>.
-     */
-    public DataObject(int idCounter, Instance inst){
-        this.id = idCounter;
-        this.inst = inst;
-        this.features = inst.toDoubleArray();
-        this.classLabel = (int)inst.classValue();
-        this.isOutiler = false;
-    }
-    
-    /**
-     * Returns the number of features (label attribute excluded).
-     * @return The number of features in the point.
-     */
-    public int getNrOfDimensions(){
-        return this.features.length-1;
-    }
-    
-    /**
-     * Returns a <code>String</code> representation of the point. The features are written comma
-     * separated between parenthesis and the label id is written after the closing parenthesis
-     * surrounded by squared brackets.
-     * @return A <code>String</code> representation of the point.
-     */
-    @Override
-    public String toString(){
-        
-        String res = "(";
-        for (int i = 0; i < features.length; i++) {
-            double d = features[i];
-            res += d;
-            if (i != features.length - 1)
-                res += ",";
-        }
-        res += ")";
-        
-        res += "[" + this.classLabel + "]";
-        
-        return res;
-        
-    }
-
-    
-    public void setOutiler(boolean val) {
-		isOutiler = val;
-	}
-    
-    public boolean isOutiler() {
-		return isOutiler;
-	}
-    
-}
diff --git a/moa/src/main/java/moa/clusterers/outliers/AnyOut/util/DataSet.java b/moa/src/main/java/moa/clusterers/outliers/AnyOut/util/DataSet.java
deleted file mode 100644
index 9cbc4df44..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/AnyOut/util/DataSet.java
+++ /dev/null
@@ -1,273 +0,0 @@
-/*
- *    DataSet.java
- *
- *    @author F. Sanchez, I. Assent, P. Kranen, C. Baldauf, T. Seidl
- *    @author G. Piskas, A. Gounaris
- * 
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers.AnyOut.util;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Iterator;
-
-
-/**
- * A set of <code>DataObject</code>s. Internally it uses an <code>ArrayList&lt;DataObject&gt;</code>
- * so it is recommended to use  with care. For speedy operations
- * after the data is collected use {@link #getFeaturesAsArray()}. When access speed is not a factor
- * the iterator can be used to go through the data with a <code>foreach</code> loop.
- * @author Fernando Sanchez Villaamil
- * @see #getFeaturesAsArray()
- */
-
-public class DataSet implements Iterable<DataObject>{
-
-    private int nrOfDimensions;
-    private ArrayList<DataObject> dataList;
-
-    /**
-     * Creates an empty set.
-     * @param nrOfDimensions The dimension the <code>DataObject</code>s should have.
-     * @see DataObject
-     * @throws praktikum.framework.data.InconsistentDimensionException
-     */
-    public DataSet(int nrOfDimensions){
-        if (nrOfDimensions <= 0) {
-            System.err.println("Negative dimension given: " + nrOfDimensions);
-        } else {
-            this.nrOfDimensions = nrOfDimensions;
-            dataList = new ArrayList<DataObject>();
-        }
-    }
-
-    /**
-     * Creates a Set with only the given object. The dimension for the <code>DataSet</code> is
-     * given by the given <code>DataObject</code>.
-     * @param newData The first <code>DataObject</code> added to the set.
-     * @see DataObject
-     * @throws praktikum.framework.data.InconsistentDimensionException
-     */
-    public DataSet(DataObject newData) {
-        this.nrOfDimensions = newData.getNrOfDimensions();
-
-        dataList = new ArrayList<DataObject>();
-        dataList.add(newData);
-    }
-
-    /**
-     * Adds a <code>DataObject</code> to the set.
-     * @param newData The <code>DataObject</code> to be added.
-     * @throws praktikum.framework.data.InconsistentDimensionException This <code>Exception</code> is thrown
-     * when the dimension of the object to be added does not fit the rest.
-     * @see DataObject
-     * @throws praktikum.framework.data.InconsistentDimensionException
-     */
-    public void addObject(DataObject newData) {
-
-        if (newData.getNrOfDimensions() != nrOfDimensions) {
-        	System.err.println("Inconsistent number of dimensions!"); //(this.nrOfDimensions, newData.getNrOfDimensions());
-        } else {
-        	this.dataList.add(newData);
-        }
-    }
-
-    /**
-     * Adds all objects in the given data set
-     * @see addObject(DataObject newData)
-     * @param dataSet
-     * @throws InconsistentDimensionException
-     */
-    public void addObject(DataSet dataSet) throws Exception {
-    	DataObject[] dataObjects = dataSet.getDataObjectArray();
-    	for (int i = 0; i < dataObjects.length; i++) {
-			this.addObject(dataObjects[i]);
-		}
-    }
-    
-    /**
-     * Returns the <code>DataObject</code> at the given position. Use with care.
-     * For speedy operations after the data is collected use {@link #getFeaturesAsArray()}.
-     * @param index The index position that is to be returned.
-     * @return The <code>DataObeject</code> at the given position.
-     * @see DataObject
-     */
-    public DataObject getObject(int index) {
-        return dataList.get(index);
-    }
-
-    /**
-     * Returns the size of the set.
-     * @return The size of the set.
-     */
-    public int size() {
-        return this.dataList.size();
-    }
-
-    /**
-     * Return the dimension of the objects in the <code>DataSet</code>. The <code>DataSet</code>
-     * makes sure all objects have the same dimension.
-     * @return The dimension of the <code>DataObjects</code> in the <code>DataSet</code>.
-     * @see DataObject
-     */
-    public int getNrOfDimensions() {
-        return nrOfDimensions;
-    }
-
-    /**
-     * Counts the number of classes that are present in the data set.
-     * !!! It does not check whether all classes are contained !!!  
-     * @return the number of distinct class labels
-     */
-    public int getNrOfClasses() {
-		HashMap<Integer, Integer> classes = new HashMap<Integer, Integer>();
-
-		for (DataObject currentObject : dataList) {
-			if (!classes.containsKey(currentObject.getClassLabel()))
-				classes.put(currentObject.getClassLabel(), 1);
-		}
-    	
-		return classes.size();
-    }
-    
-    /**
-     * Returns an array with all the features of all the objects in the set. Be aware that it does not copy the features
-     * so that any changes to the values of the features in this array will result in changes in
-     * the initial <code>DataObject</code>s.
-     * @return A <code>double[][]</code> with the features. The first dimension is the feature
-     * number, the second the values in the feature.
-     * @see DataObject
-     */
-    public double[][] getFeaturesAsArray() {
-
-        double[][] data = new double[this.size()][this.nrOfDimensions];
-
-        int c = 0;
-        for (DataObject d : dataList) {
-            data[c] = d.getFeatures();
-            c++;
-        }
-
-        return data;
-    }
-    
-    /**
-     * Returns an array of all the <code>DataObject</code>s in the set. Use for speedy access when the labels
-     * and/or the ids are also needed.
-     * @return An array with all the <code>DataObject</code>s in the set.
-     * @see DataObject
-     */
-    public DataObject[] getDataObjectArray(){
-        DataObject[] res = new DataObject[this.dataList.size()];
-        return this.dataList.toArray(res);
-    }
-    
-    /**
-     * Separates the objects in this data set according to their class label
-     * @return an array of DataSets, one for each class
-     */
-    public DataSet[] getDataSetsPerClass() throws Exception {
-    	DataSet[] dataSetsPerClass = new DataSet[this.getNrOfClasses()];
-    	// create a new data set for each class
-    	for (int i = 0; i < dataSetsPerClass.length; i++) {
-			dataSetsPerClass[i] = new DataSet(this.nrOfDimensions);
-		}
-    	
-    	// fill the data sets
-    	for(DataObject currentObject : dataList) {
-    		dataSetsPerClass[currentObject.getClassLabel()].addObject(currentObject);
-    	}
-    	
-    	return dataSetsPerClass;
-    }
-    
-    /**
-     * Calculates the variance of this data set for each dimension
-     * @return double array containing the variance per dimension 
-     */
-    public double[] getVariances() {
-		double N = this.size();
-    	double[] LS = new double[this.getNrOfDimensions()];
-    	double[] SS = new double[this.getNrOfDimensions()];
-		double[] tmpFeatures;
-		double[] variances = new double[this.getNrOfDimensions()];
-
-		for (DataObject dataObject : dataList) {
-			tmpFeatures = dataObject.getFeatures();
-			for (int j = 0; j < tmpFeatures.length; j++) {
-				LS[j] += tmpFeatures[j];
-				SS[j] += tmpFeatures[j] * tmpFeatures[j];
-			}
-		}
-		
-		// sigmaSquared[i] = (SS[i] / N) - ((LS[i] * LS [i]) / (N * N));
-		for (int i = 0; i < LS.length; i++) {
-			variances[i] = (SS[i] / N - ((LS[i] / N)*(LS[i] / N)));
-		}
-		
-		return variances;
-    }
-    
-    /**
-     * An iterator for the set. This allows to use a <code>foreach</code> loop over the <code>DataObject</code>s.
-     * This is a nice way of going through the data, but when the access speed is relevant its use
-     * is not recommended.
-     * @return An iterator for the set.
-     * @see DataObject
-     */
-    public Iterator<DataObject> iterator() {
-        return this.dataList.iterator();
-    }
-    
-    /**
-     * Returns a <code>String</code> representation of all the <code>DataObject</code>s in the code as a list of
-     * the representation implemented for these.
-     * @return A <code>String</code> representation of all the elements in the set.
-     * @see DataObject
-     */
-    @Override
-    public String toString(){
-        String res = "";
-        
-        for (DataObject dataObject : dataList) {
-            res += dataObject.toString() + "\n";
-        }
-        
-        return res;
-    }
-
-	/**
-	 * resets the ids, so that the set contains ids from 0 to noOfObjects-1
-	 */
-	public void manipulateIds() {
-		int id = 0;
-		for (DataObject o : dataList){
-			o.setId(id);
-			id++;
-		}
-		
-	}
-
-	public void clear() {
-		dataList.clear();
-	}
-}
-
-
-
-
-
diff --git a/moa/src/main/java/moa/clusterers/outliers/MCOD/ISBIndex.java b/moa/src/main/java/moa/clusterers/outliers/MCOD/ISBIndex.java
deleted file mode 100644
index 047c964ff..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/MCOD/ISBIndex.java
+++ /dev/null
@@ -1,275 +0,0 @@
-/*
- *    ISBIndex.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers.MCOD;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeSet;
-import java.util.Vector;
-
-import com.yahoo.labs.samoa.instances.Instance;
-
-
-
-public class ISBIndex {    
-    public static class ISBNode implements Comparable<ISBNode> {
-        public static enum NodeType { OUTLIER, INLIER_MC, INLIER_PD }
-        
-        public Instance inst;
-        public StreamObj obj;
-        public Long id;
-        public MicroCluster mc;
-        public Set<MicroCluster> Rmc;
-        public int count_after;
-        public NodeType nodeType;
-        private ArrayList<ISBNode> nn_before;
-        
-        // statistics
-        public int nOutlier;
-        public int nInlier;
-        
-
-        public ISBNode(Instance inst, StreamObj obj, Long id) {
-            this.inst = inst;
-            this.obj  = obj;
-            this.id   = id;
-            
-            // init statistics
-            nOutlier = 0;
-            nInlier  = 0;
-            
-            // init other fields
-            InitNode();
-        }  
-        
-        public void InitNode() {
-            this.mc          = null;
-            this.Rmc         = new TreeSet<MicroCluster>();
-            this.count_after = 1;
-            this.nodeType    = NodeType.INLIER_PD;
-            this.nn_before   = new ArrayList<ISBNode>();
-        }
-        
-        @Override
-        public int compareTo(ISBNode t) {
-            if (this.id > t.id)
-                return +1;
-            else if (this.id < t.id)
-                return -1;
-            return 0;
-        }
-        
-        public void AddPrecNeigh(ISBNode node) {
-            int pos = Collections.binarySearch(nn_before, node);
-            if (pos < 0) {
-                // item does not exist, so add it to the right position
-                nn_before.add(-(pos + 1), node);
-            }
-        }
-        
-        public void RemovePrecNeigh(ISBNode node) {
-            int pos = Collections.binarySearch(nn_before, node);
-            if (pos >= 0) {
-                // item exists
-                nn_before.remove(pos);
-            }
-        }
-        
-        public ISBNode GetMinPrecNeigh(Long sinceId) {
-            if (nn_before.size() > 0) {                
-                int startPos;
-                ISBNode dummy = new ISBNode(null, null, sinceId);
-                
-                int pos = Collections.binarySearch(nn_before, dummy);
-                if (pos < 0) {
-                    // item does not exist, should insert at position startPos
-                    startPos = -(pos + 1);
-                } else {
-                    // item exists at startPos
-                    startPos = pos;
-                }
-                
-                if (startPos < nn_before.size()) {
-                    return nn_before.get(startPos);
-                }
-            }
-            return null;
-        }
-        
-        public int CountPrecNeighs(Long sinceId) {
-            if (nn_before.size() > 0) {
-                // get number of neighs with id >= sinceId
-                int startPos;
-                ISBNode dummy = new ISBNode(null, null, sinceId);
-                int pos = Collections.binarySearch(nn_before, dummy);
-                if (pos < 0) {
-                    // item does not exist, should insert at position startPos
-                    startPos = -(pos + 1);
-                } else {
-                    // item exists at startPos
-                    startPos = pos;
-                }
-                
-                if (startPos < nn_before.size()) {
-                    return nn_before.size() - startPos;
-                }
-            }
-            return 0;
-        }
-        
-        public List<ISBNode> Get_nn_before() {
-            return nn_before;
-        }
-    }
-    
-    MTreeStreamObjects mtree;
-    Map<Integer, Set<ISBNode>> mapNodes;
-    double m_radius;
-    int m_k; // k nearest neighbors
-    
-    public ISBIndex(double radius, int k) {
-        mtree = new MTreeStreamObjects();
-        mapNodes = new HashMap<Integer, Set<ISBNode>>();
-        m_radius = radius;
-        m_k = k;
-    }
-    
-    Vector<ISBNode> GetAllNodes() {
-        Vector<ISBNode> v = new Vector<ISBNode>(); 
-        Iterator it = mapNodes.entrySet().iterator();
-        while (it.hasNext()) {
-            Map.Entry pairs = (Map.Entry) it.next();
-            Set<ISBNode> setNodes = (Set<ISBNode>) pairs.getValue();
-            for (ISBNode n : setNodes) {
-                v.add(n);
-            }
-        }  
-        return v;
-    }
-    
-    public static class ISBSearchResult {
-        public ISBNode node;
-        public double distance;
-        
-        public ISBSearchResult(ISBNode n, double distance) {
-            this.node = n;
-            this.distance = distance;
-        }
-    }
-    
-    public Vector<ISBSearchResult> RangeSearch(ISBNode node, double radius) {
-        Vector<ISBSearchResult> results = new Vector<ISBSearchResult>();
-        StreamObj obj;
-        double d;
-        MTreeStreamObjects.Query query = mtree.getNearestByRange(node.obj, radius);
-        for (MTreeStreamObjects.ResultItem q : query) {
-            // get next obj found within range
-            obj = q.data;
-            // get distance of obj from query
-            d = q.distance;
-            // get all nodes referencing obj
-            Vector<ISBNode> nodes = MapGetNodes(obj);
-            for (int i = 0; i < nodes.size(); i++)
-                results.add(new ISBSearchResult(nodes.get(i), d));
-        }        
-        return results;
-    }
-    
-    public void Insert(ISBNode node) {
-        // insert object of node at mtree
-        mtree.add(node.obj);
-        // insert node at map
-        MapInsert(node);    
-    }
-    
-    public void Remove(ISBNode node) {
-        // remove from map
-        MapDelete(node);
-        // check if stream object at mtree is still being referenced
-        if (MapCountObjRefs(node.obj) <= 0) {
-            // delete stream object from mtree
-            mtree.remove(node.obj);
-        }
-    }
-    
-    Vector<ISBNode> MapGetNodes(StreamObj obj) {
-        int h = obj.hashCode();
-        Vector<ISBNode> v = new Vector<ISBNode>();
-        if (mapNodes.containsKey(h)) {
-            Set<ISBNode> s = mapNodes.get(h);
-            ISBNode node;
-            Iterator<ISBNode> i = s.iterator();
-            while (i.hasNext()) {
-                node = i.next();
-                if (node.obj.equals(obj))
-                    v.add(node);
-            }
-        }
-        return v;
-    }
-    
-    int MapCountObjRefs(StreamObj obj) {
-        int h = obj.hashCode();
-        int iCount = 0;
-        if (mapNodes.containsKey(h)) {
-            Set<ISBNode> s = mapNodes.get(h);
-            ISBNode n;
-            Iterator<ISBNode> i = s.iterator();
-            while (i.hasNext()) {
-                n = i.next();
-                if (n.obj.equals(obj))
-                    iCount++;
-            }
-        }
-        return iCount;
-    }  
-    
-    void MapInsert(ISBNode node) {
-        int h = node.obj.hashCode();
-        Set<ISBNode> s;
-        if (mapNodes.containsKey(h)) {
-            s = mapNodes.get(h);
-            s.add(node);
-        }
-        else {
-            s = new HashSet<ISBNode>();
-            s.add(node);
-            mapNodes.put(h, s);
-        }
-    }
-    
-    void MapDelete(ISBNode node) {
-        int h = node.obj.hashCode();
-        if (mapNodes.containsKey(h)) {
-            Set<ISBNode> s = mapNodes.get(h);
-            s.remove(node);
-            if (s.isEmpty()) { // ### added
-                mapNodes.remove(h);
-            }
-        }
-    }  
-}
diff --git a/moa/src/main/java/moa/clusterers/outliers/MCOD/MCOD.java b/moa/src/main/java/moa/clusterers/outliers/MCOD/MCOD.java
deleted file mode 100644
index 0d58e7b02..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/MCOD/MCOD.java
+++ /dev/null
@@ -1,408 +0,0 @@
-/*
- *    MCOD.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers.MCOD;
-
-import java.util.ArrayList;
-import java.util.TreeSet;
-import java.util.Vector;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.clusterers.outliers.MCOD.ISBIndex.ISBNode;
-import moa.clusterers.outliers.MCOD.ISBIndex.ISBNode.NodeType;
-import moa.clusterers.outliers.MCOD.ISBIndex.ISBSearchResult;
-
-
-//The algorithm is described in 
-// M. Kontaki, A. Gounaris, A. N. Papadopoulos, K. Tsichlas, and Y. Manolopoulos. 
-//Continuous monitoring of distance-based outliers over data streams.
-//In ICDE, pages 135–146, 2011.
-
-
-public class MCOD extends MCODBase {
-    public FloatOption radiusOption = new FloatOption("radius", 'r', "Search radius.", 0.1);
-    public IntOption kOption = new IntOption("k", 't', "Parameter k.", 50);
-    
-    public MCOD()
-    {
-        // System.out.println("MCOD: created");
-    }
-    
-    @Override
-    public void Init() {   
-        super.Init();
-        
-        m_WindowSize = windowSizeOption.getValue();
-        m_radius = radiusOption.getValue();
-        m_k = kOption.getValue();
-                
-        Println("Init MCOD:");
-        Println("   window_size: " + m_WindowSize);
-        Println("   radius: " + m_radius);
-        Println("   k: " + m_k);
-        
-        //bTrace = true;
-        //bWarning = true;
-        
-        objId = FIRST_OBJ_ID; // init object identifier
-        // create nodes list of window
-        windowNodes = new Vector<ISBNode>();
-        // create ISB
-        ISB_PD = new ISBIndex(m_radius, m_k);
-        // create helper sets for micro-cluster management
-        setMC = new TreeSet<MicroCluster>();
-        // micro-cluster index
-        mtreeMC = new MTreeMicroClusters();
-        // create event queue
-        eventQueue = new EventQueue();
-        
-        // init statistics
-        m_nBothInlierOutlier = 0;
-        m_nOnlyInlier = 0;
-        m_nOnlyOutlier = 0;
-    }
-    
-    void SetNodeType(ISBNode node, NodeType type) {
-        node.nodeType = type;
-        // update statistics
-        if (type == NodeType.OUTLIER)
-            node.nOutlier++;
-        else
-            node.nInlier++;
-    }
-    
-    void AddNeighbor(ISBNode node, ISBNode q, boolean bUpdateState) {
-        if (bTrace) Println("AddNeighbor: node.id: " + node.id + ", q.id: " + q.id);
-        
-        // check if q still in window
-        if (IsNodeIdInWin(q.id) == false) {
-            if (bWarning) Println("AddNeighbor: node.id: " + node.id + ", q.id: " + q.id + " (expired)"); 
-            return;
-        }
-        
-        if (q.id < node.id) {
-            node.AddPrecNeigh(q);
-        } else {
-            node.count_after++;
-        }        
-        
-        if (bUpdateState) {
-            // check if node inlier or outlier
-            int count = node.count_after + node.CountPrecNeighs(GetWindowStart());
-            if ((node.nodeType == NodeType.OUTLIER) && (count >= m_k)) {
-                // remove node from outliers
-                if (bTrace) Println("Remove node from outliers"); 
-                RemoveOutlier(node);
-                // add node to inlier set PD
-                SetNodeType(node, NodeType.INLIER_PD);
-                // insert node to event queue
-                ISBNode nodeMinExp = node.GetMinPrecNeigh(GetWindowStart());
-                AddToEventQueue(node, nodeMinExp);
-            }
-        }
-    }
-    
-    void ProcessNewNode(ISBNode nodeNew, boolean bNewNode) {
-        if (bTrace) { Print("ProcessNewNode: "); PrintNode(nodeNew); }
-        
-        if (bTrace) Println("Perform 3R/2 range query to cluster centers w.r.t new node"); 
-        Vector<SearchResultMC> resultsMC;
-        // results are sorted ascenting by distance
-        resultsMC = RangeSearchMC(nodeNew, 1.5 * m_radius); 
-        if (bTrace) {
-            Println("MC query found: "); 
-            for (SearchResultMC sr : resultsMC) {
-                Printf("  (%.1f) mcc: ", sr.distance); PrintNode(sr.mc.mcc);
-            }
-        }
-        
-        if (bTrace) Println("Get closest micro-cluster"); 
-        MicroCluster mcClosest = null;
-        if (resultsMC.size() > 0) { 
-            mcClosest = resultsMC.get(0).mc;
-            if (bTrace) Println("Closest mcc: " + mcClosest.mcc.id);
-        }
-        
-        // check if nodeNew can be insterted to closest micro-cluster
-        boolean bFoundMC = false;
-        if (mcClosest != null) {
-            double d = GetEuclideanDist(nodeNew, mcClosest.mcc);
-            if (d <= m_radius / 2) {
-                bFoundMC = true;
-            } else {
-                if (bTrace) Println("Not close enough to closest mcc"); 
-            }
-        }
-        
-        if (bFoundMC) {
-            if (bTrace) Println("Add new node to micro-cluster"); 
-            nodeNew.mc = mcClosest;
-            SetNodeType(nodeNew, NodeType.INLIER_MC);
-            mcClosest.AddNode(nodeNew);
-            if (bTrace) { Print("mcClosest.nodes: "); PrintNodeList(mcClosest.nodes); } 
-            
-            if (bTrace) Println("Update neighbors of set PD"); 
-            Vector<ISBNode> nodes;
-            nodes = ISB_PD.GetAllNodes();
-            for (ISBNode q : nodes) {
-                if (q.Rmc.contains(mcClosest)) {
-                    if (GetEuclideanDist(q, nodeNew) <= m_radius) {
-                        if (bNewNode) {
-                            // update q.count_after and its' outlierness
-                            AddNeighbor(q, nodeNew, true);
-                        } else {
-                            if (nodesReinsert.contains(q)) {
-                                // update q.count_after or q.nn_before and its' outlierness
-                                AddNeighbor(q, nodeNew, true);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        else {
-            // No close enough micro-cluster found.
-            // Perform 3R/2 range query to nodes in set PD.
-
-            if (bTrace) Println("Perform 3R/2 range query to nodes in set PD");     
-            nRangeQueriesExecuted++;
-            // create helper sets for micro-cluster management
-            ArrayList<ISBNode> setNC = new ArrayList<ISBNode>();
-            ArrayList<ISBNode> setNNC = new ArrayList<ISBNode>();
-            Vector<ISBSearchResult> resultNodes;
-            resultNodes = ISB_PD.RangeSearch(nodeNew, 1.5 * m_radius); // 1.5 ###
-            for (ISBSearchResult sr : resultNodes) {
-                ISBNode q = sr.node;
-                if (sr.distance <= m_radius) {                    
-                    // add q to neighs of nodeNew
-                    AddNeighbor(nodeNew, q, false);                
-                    if (bNewNode) {
-                        // update q.count_after and its' outlierness
-                        AddNeighbor(q, nodeNew, true); 
-                    } else {
-                        if (nodesReinsert.contains(q)) {
-                            // update q.count_after or q.nn_before and its' outlierness
-                            AddNeighbor(q, nodeNew, true);
-                        }
-                    }
-                }
-                
-                if (sr.distance <= m_radius / 2.0) {
-                    setNC.add(q);
-                } else {
-                    setNNC.add(q);
-                }
-            }
-            if (bTrace) {
-                Print("Prec neighs of new node: "); PrintNodeList(nodeNew.Get_nn_before());
-                Print("NC: "); PrintNodeList(setNC); 
-                Print("NNC: "); PrintNodeList(setNNC); 
-            }
-            
-            // check if size of set NC big enough to create cluster
-            if (bTrace) Println("Check size of set NC"); 
-            if (setNC.size() >= m_theta * m_k) {
-                // create new micro-cluster with center nodeNew
-                if (bTrace) Println("Create new micro-cluster"); 
-                MicroCluster mcNew = new MicroCluster(nodeNew);
-                AddMicroCluster(mcNew);
-                nodeNew.mc = mcNew;
-                SetNodeType(nodeNew, NodeType.INLIER_MC);
-                
-                if (bTrace) Println("Add to new mc nodes within range R/2"); 
-                for (ISBNode q : setNC) {
-                    q.mc = mcNew;
-                    mcNew.AddNode(q);
-                    // move q from set PD to set inlier-mc
-                    SetNodeType(q, NodeType.INLIER_MC);
-                    ISB_PD.Remove(q);
-                    RemoveOutlier(q); // needed? ###
-                }
-                if (bTrace) { 
-                    Print("mcNew.nodes: "); PrintNodeList(mcNew.nodes); 
-                    PrintPD();
-                } 
-                
-                if (bTrace) Println("Update Rmc lists of nodes of PD in range 3R/2 from mcNew"); 
-                for (ISBNode q : setNNC) {
-                    q.Rmc.add(mcNew);
-                    if (bTrace) { Print(q.id + ".Rmc: "); PrintMCSet(q.Rmc); }
-                }
-            } else {
-                if (bTrace) Println("Add to nodeNew neighs nodes of near micro-clusters"); 
-                for (SearchResultMC sr : resultsMC) {
-                    for (ISBNode q : sr.mc.nodes) {
-                        if (GetEuclideanDist(q, nodeNew) <= m_radius) {
-                            // add q to neighs of nodeNew
-                            AddNeighbor(nodeNew, q, false);
-                        }
-                    }
-                }
-                if (bTrace) { 
-                    Println("nodeNew.count_after = " + nodeNew.count_after); 
-                    Print("nodeNew.nn_before: "); PrintNodeList(nodeNew.Get_nn_before()); 
-                }
-                
-                if (bTrace) Println("Insert nodeNew to index of nodes of PD"); 
-                ISB_PD.Insert(nodeNew); 
-                if (bTrace) PrintPD();
-                
-                // check if nodeNew is an inlier or outlier
-                // use both nn_before and count_after for case bNewNode=false
-                int count = nodeNew.CountPrecNeighs(GetWindowStart()) + nodeNew.count_after;
-                if (count >= m_k) {
-                    if (bTrace) Println("nodeNew is an inlier"); 
-                    SetNodeType(nodeNew, NodeType.INLIER_PD);                    
-                    // insert nodeNew to event queue
-                    ISBNode nodeMinExp = nodeNew.GetMinPrecNeigh(GetWindowStart());
-                    AddToEventQueue(nodeNew, nodeMinExp);
-                } else {
-                    if (bTrace) Println("nodeNew is an outlier");
-                    SetNodeType(nodeNew, NodeType.OUTLIER);
-                    SaveOutlier(nodeNew);
-                }
-                
-                if (bTrace) Println("Update nodeNew.Rmc"); 
-                for (SearchResultMC sr : resultsMC) {
-                    nodeNew.Rmc.add(sr.mc);
-                }                
-                if (bTrace) { Print("nodeNew.Rmc: "); PrintMCSet(nodeNew.Rmc); } 
-            }
-        }
-    }
-
-    void AddToEventQueue(ISBNode x, ISBNode nodeMinExp) {
-        if (bTrace) Println("AddToEventQueue x.id: " + x.id); 
-        if (nodeMinExp != null) {
-            Long expTime = GetExpirationTime(nodeMinExp);
-            eventQueue.Insert(x, expTime);
-            if (bTrace) {
-                Print("x.nn_before: "); PrintNodeList(x.Get_nn_before());
-                Println("nodeMinExp: " + nodeMinExp.id + ", expTime = " + expTime);
-                PrintEventQueue();
-            }
-        } else {
-            if (bWarning) Println("AddToEventQueue: Cannot add x.id: " + x.id + " to event queue (nn_before is empty, count_after=" + x.count_after + ")"); 
-        }
-    }
-    
-    void ProcessEventQueue(ISBNode nodeExpired) {
-        EventItem e = eventQueue.FindMin();
-        while ((e != null) && (e.timeStamp <= GetWindowEnd())) {
-            e = eventQueue.ExtractMin();
-            ISBNode x = e.node;
-            if (bTrace) Println("Process event queue: check node x: " + x.id);
-            // node x must be in window and not in any micro-cluster
-            boolean bValid = ( IsNodeIdInWin(x.id) && (x.mc == null) );
-            if (bValid) {
-                // remove nodeExpired from x.nn_before
-                x.RemovePrecNeigh(nodeExpired);
-                // get amount of neighbors of x
-                int count = x.count_after + x.CountPrecNeighs(GetWindowStart());
-                if (count < m_k) {
-                    if (bTrace) Println("x is an outlier");
-                    SetNodeType(x, NodeType.OUTLIER);
-                    SaveOutlier(x);
-                } else {
-                    if (bTrace) Println("x is an inlier, add to event queue");
-                    // get oldest preceding neighbor of x
-                    ISBNode nodeMinExp = x.GetMinPrecNeigh(GetWindowStart());
-                    // add x to event queue
-                    AddToEventQueue(x, nodeMinExp);
-                }
-            } else {
-                if (bWarning) Println("Process event queue: node x.id: " + x.id + " is not valid!");
-            }
-            e = eventQueue.FindMin();
-        }
-    }
-    
-    void ProcessExpiredNode(ISBNode nodeExpired) { 
-        if (nodeExpired != null) {
-            if (bTrace) Println("\nnodeExpired: " + nodeExpired.id);
-            MicroCluster mc = nodeExpired.mc;
-            if (mc != null) {
-                if (bTrace) Println("nodeExpired belongs to mc: " + mc.mcc.id);
-                mc.RemoveNode(nodeExpired);
-                if (bTrace) { Print("mc.nodes: "); PrintNodeList(mc.nodes); }
-                
-                if (bTrace) Println("Check if mc has enough objects");
-                if (mc.GetNodesCount() < m_k) {
-                    // remove micro-cluster mc
-                    if (bTrace) Println("Remove mc");
-                    RemoveMicroCluster(mc);
-                    
-                    // insert nodes of mc to set nodesReinsert
-                    nodesReinsert = new TreeSet<ISBNode>();
-                    for (ISBNode q : mc.nodes) {
-                        nodesReinsert.add(q);
-                    }
-                    
-                    // treat each node of mc as new node
-                    for (ISBNode q : mc.nodes) {
-                        if (bTrace) Println("\nTreat as new node q: " + q.id);
-                        q.InitNode();
-                        ProcessNewNode(q, false);
-                    }
-                }
-            } else {
-                // nodeExpired belongs to set PD
-                // remove nodeExpired from PD index
-                ISB_PD.Remove(nodeExpired);
-            }
-            
-            RemoveNode(nodeExpired);
-            ProcessEventQueue(nodeExpired);
-        }
-    }
-    
-    @Override
-    protected void ProcessNewStreamObj(Instance inst)
-    {                
-        if (bShowProgress) ShowProgress("Processed " + (objId-1) + " stream objects.");       
-        // PrintInstance(inst);
-        
-        double[] values = getInstanceValues(inst);
-        StreamObj obj = new StreamObj(values);
-        
-        if (bTrace) Println("\n- - - - - - - - - - - -\n");
-
-        // create new ISB node
-        ISBNode nodeNew = new ISBNode(inst, obj, objId);
-        if (bTrace) { Print("New node: "); PrintNode(nodeNew); }
-        
-        objId++; // update object identifier (slide window)
-        
-        AddNode(nodeNew); // add nodeNew to window
-        if (bTrace) PrintWindow();
-        
-        ProcessNewNode(nodeNew, true);
-        ProcessExpiredNode(GetExpiredNode());
-        
-        if (bTrace) {
-            Print("Micro-clusters: "); PrintMCSet(setMC);
-            PrintOutliers();
-            PrintPD();
-        }
-    }
-}
diff --git a/moa/src/main/java/moa/clusterers/outliers/MCOD/MCODBase.java b/moa/src/main/java/moa/clusterers/outliers/MCOD/MCODBase.java
deleted file mode 100644
index 94f7ba167..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/MCOD/MCODBase.java
+++ /dev/null
@@ -1,372 +0,0 @@
-/*
- *    MCODBase.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers.MCOD;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Set;
-import java.util.TreeSet;
-import java.util.Vector;
-
-import moa.clusterers.outliers.MyBaseOutlierDetector;
-import moa.clusterers.outliers.MCOD.ISBIndex.ISBNode;
-import moa.clusterers.outliers.MCOD.ISBIndex.ISBNode.NodeType;
-
-public abstract class MCODBase extends MyBaseOutlierDetector {    
-    protected static class EventItem implements Comparable<EventItem> {
-        public ISBNode node;
-        public Long timeStamp;
-
-        public EventItem(ISBNode node, Long timeStamp) {
-            this.node = node;
-            this.timeStamp = timeStamp;
-        }
-
-        @Override
-        public int compareTo(EventItem t) {
-            if (this.timeStamp > t.timeStamp) {
-                return +1;
-            } else if (this.timeStamp < t.timeStamp) {
-                return -1;
-            } else {
-                if (this.node.id > t.node.id)
-                    return +1;
-                else if (this.node.id < t.node.id)
-                    return -1;
-            }
-            return 0;
-        }
-    }
-    
-    protected static class EventQueue {
-        public TreeSet<EventItem> setEvents;
-
-        public EventQueue() {
-            setEvents = new TreeSet<EventItem>();
-        }
-        
-        public void Insert(ISBNode node, Long expTime) {
-            setEvents.add(new EventItem(node, expTime));
-        }
-        
-        public EventItem FindMin() {
-            if (setEvents.size() > 0) {
-                // events are sorted ascenting by expiration time
-                return setEvents.first();
-            }
-            return null;
-        }
-        
-        public EventItem ExtractMin() {
-            EventItem e = FindMin();
-            if (e != null) {
-                setEvents.remove(e);
-                return e;
-            }
-            return null;
-        }
-    }
-    
-    protected static final Long FIRST_OBJ_ID = 1L;
-    
-    // object identifier increments with each new data stream object
-    protected Long objId;
-    // list used to find expired nodes
-    protected Vector<ISBNode> windowNodes; 
-    protected EventQueue eventQueue;
-    // MTree index of micro-clusters
-    protected MTreeMicroClusters mtreeMC;
-    // set of micro-clusters (for trace)
-    protected TreeSet<MicroCluster> setMC;
-    // nodes treated as new nodes when a mc removed
-    protected TreeSet<ISBNode> nodesReinsert;
-    // index of objects not in any micro-cluster
-    protected ISBIndex ISB_PD;
-    protected int m_WindowSize;
-    protected double m_radius;
-    protected int m_k;
-    protected double m_theta = 1.0;
-            
-    public boolean bWarning = false;
-    
-    // statistics
-    public int m_nBothInlierOutlier;
-    public int m_nOnlyInlier;
-    public int m_nOnlyOutlier;
-    
-    @Override
-    public String getObjectInfo(Object obj) {
-        if (obj == null) return null;
-        
-        ISBNode node = (ISBNode) obj;
-        
-        ArrayList<String> infoTitle = new ArrayList<String>();
-        ArrayList<String> infoValue = new ArrayList<String>();
-        StringBuilder sb = new StringBuilder();
-        
-        // show node type
-        infoTitle.add("Node type");
-        infoValue.add((node.nodeType == NodeType.OUTLIER) ? "Outlier" : "Inlier");
-
-        // show node position
-        for (int i = 0; i < node.obj.dimensions(); i++) {
-            infoTitle.add("Dim" + (i+1));
-            infoValue.add(String.format("%.3f", node.obj.get(i)));
-        }
-        
-        // show node properties
-        infoTitle.add("id");
-        infoValue.add(String.format("%d", node.id));
-        infoTitle.add("count_after");
-        infoValue.add(String.format("%d", node.count_after));
-        infoTitle.add("|nn_before|");
-        infoValue.add(String.format("%d", node.CountPrecNeighs(GetWindowStart())));
-        
-        sb.append("<html>");
-        sb.append("<table>");
-        int i = 0;
-        while(i < infoTitle.size() && i < infoValue.size()){
-            sb.append("<tr><td><b>"+infoTitle.get(i)+":</b></td><td>"+infoValue.get(i)+"</td></tr>");
-            i++;
-        }
-        sb.append("</table>");
-
-        
-        sb.append("</html>");
-        return sb.toString();
-    }
-    
-    @Override
-    public String getStatistics() {
-        StringBuilder sb = new StringBuilder();
-        
-        sb.append("Statistics:\n\n");
-        
-        // get counters of expired nodes
-        int nBothInlierOutlier = m_nBothInlierOutlier;
-        int nOnlyInlier = m_nOnlyInlier;
-        int nOnlyOutlier = m_nOnlyOutlier;
-        
-        // add counters of non expired nodes
-        for (ISBNode node : windowNodes) {
-            if ((node.nInlier > 0) && (node.nOutlier > 0))
-                nBothInlierOutlier++;
-            else if (node.nInlier > 0)
-                nOnlyInlier++;
-            else
-                nOnlyOutlier++;
-        }
-        
-        int sum = nBothInlierOutlier + nOnlyInlier + nOnlyOutlier;
-        if (sum > 0) {
-            sb.append(String.format("  Nodes always inlier: %d (%.1f%%)\n", nOnlyInlier, (100 * nOnlyInlier) / (double)sum));
-            sb.append(String.format("  Nodes always outlier: %d (%.1f%%)\n", nOnlyOutlier, (100 * nOnlyOutlier) / (double)sum));
-            sb.append(String.format("  Nodes both inlier and outlier: %d (%.1f%%)\n", nBothInlierOutlier, (100 * nBothInlierOutlier) / (double)sum));
-            
-            sb.append("  (Sum: " + sum + ")\n");
-        }
-        
-        sb.append("\n  Total range queries: " + nRangeQueriesExecuted + "\n");
-        sb.append("  Max memory usage: " + iMaxMemUsage + " MB\n");
-        sb.append("  Total process time: " + String.format("%.2f ms", nTotalRunTime / 1000.0) + "\n");
-        
-        return sb.toString();
-    }
-    
-    Long GetWindowEnd() {
-        return objId - 1;
-    }
-    
-    Long GetWindowStart() {
-        Long x = GetWindowEnd() - m_WindowSize + 1;
-        if (x < FIRST_OBJ_ID) 
-            x = FIRST_OBJ_ID;
-        return x;
-    }
-    
-    boolean IsWinFull() {
-        return (GetWindowEnd() >= FIRST_OBJ_ID + m_WindowSize - 1);
-    }
-    
-    Long GetExpirationTime(ISBNode node) {
-        return node.id + m_WindowSize;
-    }
-    
-    void SaveOutlier(ISBNode node) {
-        AddOutlier(new Outlier(node.inst, node.id, node));
-        node.nOutlier++; // update statistics
-    }
-    
-    void RemoveOutlier(ISBNode node) {
-        RemoveOutlier(new Outlier(node.inst, node.id, node));
-        node.nInlier++; // update statistics
-    }
-    
-    @Override
-    protected boolean IsNodeIdInWin(long id) {
-        int toleranceStart = 1;
-        Long start = GetWindowStart() - toleranceStart;
-        if ( (start <= id) && (id <= GetWindowEnd()) )
-            return true;
-        else
-            return false;
-    }
-    
-    void AddNode(ISBNode node) {
-        windowNodes.add(node);
-    }
-    
-    void RemoveNode(ISBNode node) {
-        windowNodes.remove(node);
-        RemoveExpiredOutlier(new Outlier(node.inst, node.id, node)); // ### remove when expired?
-        // update statistics
-        UpdateStatistics(node);
-    }
-    
-    void UpdateStatistics(ISBNode node) {
-        if ((node.nInlier > 0) && (node.nOutlier > 0))
-            m_nBothInlierOutlier++;
-        else if (node.nInlier > 0)
-            m_nOnlyInlier++;
-        else
-            m_nOnlyOutlier++;
-    }
-    
-    ISBNode GetExpiredNode() {
-        if (windowNodes.size() <= 0)
-            return null;       
-        // get oldest node
-        ISBNode node = windowNodes.get(0);
-        // check if node has expired
-        if (node.id < GetWindowStart()) {
-            return node;
-        }        
-        return null;
-    }
-    
-    void AddMicroCluster(MicroCluster mc) {
-        mtreeMC.add(mc);
-        setMC.add(mc);
-    }
-    
-    void RemoveMicroCluster(MicroCluster mc) {
-        mtreeMC.remove(mc);
-        setMC.remove(mc);
-    }
-    
-    class SearchResultMC {
-        MicroCluster mc;
-        double distance;
-
-        public SearchResultMC(MicroCluster mc, double distance) {
-            this.mc = mc;
-            this.distance = distance;
-        }
-    }
-    
-    Vector<SearchResultMC> RangeSearchMC(ISBNode nodeNew, double radius) {
-        Vector<SearchResultMC> results = new Vector<SearchResultMC>();
-        // create a dummy mc in order to search w.r.t. nodeNew
-        MicroCluster dummy = new MicroCluster(nodeNew);
-        // query results are returned ascenting by distance
-        MTreeMicroClusters.Query query = mtreeMC.getNearestByRange(dummy, radius);
-        for (MTreeMicroClusters.ResultItem q : query) {            
-            results.add(new SearchResultMC(q.data, q.distance));
-        }        
-        return results;
-    }
-    
-    double GetEuclideanDist(ISBNode n1, ISBNode n2)
-    {
-        double diff;
-        double sum = 0;
-        int d = n1.obj.dimensions();
-        for (int i = 0; i < d; i++) {
-            diff = n1.obj.get(i) - n2.obj.get(i);
-            sum += Math.pow(diff, 2);
-        }
-        return Math.sqrt(sum);
-    }
-    
-    void PrintWindow() {
-        Println("Window [" + GetWindowStart() + "-" + GetWindowEnd() + "]: ");
-        ISBNode node;
-        for (int i = 0; i < windowNodes.size(); i++) {
-            node = windowNodes.get(i);
-            Print("   Node: ");
-            PrintNode(node);
-        }
-    }
-    
-    void PrintNode(ISBNode n) {
-        Print("id=" + n.id + " (");
-        int dim = n.obj.dimensions();
-        for (int d = 0; d < dim; d++) {
-            Print(Double.toString(n.obj.get(d)));
-            if (d < dim - 1)
-                Print(", ");
-        }
-        Println(")");
-    }
-    
-    public void PrintNodeSet(Set<ISBNode> set) {
-        for (ISBNode n : set) {
-            Print(n.id + " ");
-        }
-        Println("");
-    }
-    
-    public void PrintMCSet(Set<MicroCluster> set) {
-        for (MicroCluster n : set) {
-            Print(n.mcc.id + " ");
-        }
-        Println("");
-    }
-    
-    public void PrintNodeVector(Vector<ISBNode> vector) {
-        for (ISBNode n : vector) {
-            Print(n.id + " ");
-        }
-        Println("");
-    }
-    
-    public void PrintNodeList(List<ISBNode> list) {
-        for (ISBNode n : list) {
-            Print(n.id + " ");
-        }
-        Println("");
-    }
-    
-    public void PrintEventQueue() {
-        Println("event queue: ");
-        for (EventItem n : eventQueue.setEvents) {
-            Printf("  id=%d, exp=%d\n", n.node.id, n.timeStamp);
-        }
-    }
-    
-    public void PrintPD() {
-        Print("PD: ");
-        for (ISBNode n : ISB_PD.GetAllNodes()) {
-            Print(n.id + " ");
-        }
-        Println("");
-    }
-}
diff --git a/moa/src/main/java/moa/clusterers/outliers/MCOD/MTreeMicroClusters.java b/moa/src/main/java/moa/clusterers/outliers/MCOD/MTreeMicroClusters.java
deleted file mode 100644
index 42be983f2..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/MCOD/MTreeMicroClusters.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- *    MTreeMicroClusters.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers.MCOD;
-
-import java.util.Set;
-
-import moa.clusterers.outliers.utils.mtree.ComposedSplitFunction;
-import moa.clusterers.outliers.utils.mtree.DistanceFunction;
-import moa.clusterers.outliers.utils.mtree.DistanceFunctions;
-import moa.clusterers.outliers.utils.mtree.MTree;
-import moa.clusterers.outliers.utils.mtree.PartitionFunctions;
-import moa.clusterers.outliers.utils.mtree.PromotionFunction;
-import moa.clusterers.outliers.utils.mtree.utils.Pair;
-import moa.clusterers.outliers.utils.mtree.utils.Utils;
-
-class MTreeMicroClusters extends MTree<MicroCluster> {
-
-    private static final PromotionFunction<MicroCluster> nonRandomPromotion = new PromotionFunction<MicroCluster>() {
-
-        @Override
-        public Pair<MicroCluster> process(Set<MicroCluster> dataSet, DistanceFunction<? super MicroCluster> distanceFunction) {
-            return Utils.minMax(dataSet);
-        }
-    };
-
-    MTreeMicroClusters() {
-        super(2, DistanceFunctions.EUCLIDEAN,
-                new ComposedSplitFunction<MicroCluster>(
-                nonRandomPromotion,
-                new PartitionFunctions.BalancedPartition<MicroCluster>()));
-    }
-
-    public void add(MicroCluster data) {
-        super.add(data);
-        _check();
-    }
-
-    public boolean remove(MicroCluster data) {
-        boolean result = super.remove(data);
-        _check();
-        return result;
-    }
-
-    DistanceFunction<? super MicroCluster> getDistanceFunction() {
-        return distanceFunction;
-    }
-};
diff --git a/moa/src/main/java/moa/clusterers/outliers/MCOD/MTreeStreamObjects.java b/moa/src/main/java/moa/clusterers/outliers/MCOD/MTreeStreamObjects.java
deleted file mode 100644
index 20f44c653..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/MCOD/MTreeStreamObjects.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- *    MTreeStreamObjects.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers.MCOD;
-
-import java.util.Set;
-
-import moa.clusterers.outliers.utils.mtree.ComposedSplitFunction;
-import moa.clusterers.outliers.utils.mtree.DistanceFunction;
-import moa.clusterers.outliers.utils.mtree.DistanceFunctions;
-import moa.clusterers.outliers.utils.mtree.MTree;
-import moa.clusterers.outliers.utils.mtree.PartitionFunctions;
-import moa.clusterers.outliers.utils.mtree.PromotionFunction;
-import moa.clusterers.outliers.utils.mtree.utils.Pair;
-import moa.clusterers.outliers.utils.mtree.utils.Utils;
-
-class MTreeStreamObjects extends MTree<StreamObj> {
-
-    private static final PromotionFunction<StreamObj> nonRandomPromotion = new PromotionFunction<StreamObj>() {
-
-        @Override
-        public Pair<StreamObj> process(Set<StreamObj> dataSet, DistanceFunction<? super StreamObj> distanceFunction) {
-            return Utils.minMax(dataSet);
-        }
-    };
-
-    MTreeStreamObjects() {
-        super(2, DistanceFunctions.EUCLIDEAN,
-                new ComposedSplitFunction<StreamObj>(
-                nonRandomPromotion,
-                new PartitionFunctions.BalancedPartition<StreamObj>()));
-    }
-
-    public void add(StreamObj data) {
-        super.add(data);
-        _check();
-    }
-
-    public boolean remove(StreamObj data) {
-        boolean result = super.remove(data);
-        _check();
-        return result;
-    }
-
-    DistanceFunction<? super StreamObj> getDistanceFunction() {
-        return distanceFunction;
-    }
-};
diff --git a/moa/src/main/java/moa/clusterers/outliers/MCOD/MicroCluster.java b/moa/src/main/java/moa/clusterers/outliers/MCOD/MicroCluster.java
deleted file mode 100644
index 40741a868..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/MCOD/MicroCluster.java
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- *    MicroCluster.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers.MCOD;
-
-import java.util.ArrayList;
-
-import moa.clusterers.outliers.MCOD.ISBIndex.ISBNode;
-import moa.clusterers.outliers.utils.mtree.DistanceFunctions.EuclideanCoordinate;
-
-public class MicroCluster implements EuclideanCoordinate, Comparable<MicroCluster> {
-    public ISBNode mcc;
-    public ArrayList<ISBNode> nodes;
-
-    public MicroCluster(ISBNode mcc) {
-        this.mcc = mcc;
-        nodes = new ArrayList<ISBNode>();
-        AddNode(mcc);
-    }
-    
-    public void AddNode(ISBNode node) {
-        if (node != null)
-            nodes.add(node);
-    }
-    
-    public void RemoveNode(ISBNode node) {
-        if (node != null)
-            nodes.remove(node);
-    }
-    
-    public int GetNodesCount() {
-        return nodes.size();
-    }
-
-    @Override
-    public int dimensions() {
-        return mcc.obj.dimensions();
-    }
-
-    @Override
-    public double get(int index) {
-        return mcc.obj.get(index);
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (obj instanceof MicroCluster) {
-            MicroCluster that = (MicroCluster) obj;
-            if (this.dimensions() != that.dimensions()) {
-                return false;
-            }
-            for (int i = 0; i < this.dimensions(); i++) {
-                if (this.mcc.obj.get(i) != that.mcc.obj.get(i)) {
-                    return false;
-                }
-            }
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    @Override
-    public int compareTo(MicroCluster that) {
-        int dimensions = Math.min(this.dimensions(), that.dimensions());
-        for (int i = 0; i < dimensions; i++) {
-            double v1 = this.mcc.obj.get(i);
-            double v2 = that.mcc.obj.get(i);
-            if (v1 > v2) {
-                return +1;
-            }
-            if (v1 < v2) {
-                return -1;
-            }
-        }
-
-        if (this.dimensions() > dimensions) {
-            return +1;
-        }
-
-        if (that.dimensions() > dimensions) {
-            return -1;
-        }
-
-        return 0;
-    }
-}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/clusterers/outliers/MCOD/StreamObj.java b/moa/src/main/java/moa/clusterers/outliers/MCOD/StreamObj.java
deleted file mode 100644
index d514c3d4c..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/MCOD/StreamObj.java
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- *    StreamObj.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers.MCOD;
-
-import moa.clusterers.outliers.utils.mtree.DistanceFunctions.EuclideanCoordinate;
-
-public class StreamObj implements EuclideanCoordinate, Comparable<StreamObj> {
-    private final double[] values;
-    private final int hashCode;
-
-    public StreamObj(double... values) {
-        this.values = values;
-
-        int h = 1;
-        for (double value : values) {
-            h = 31 * (int) h + (int) value;
-        }
-        this.hashCode = h;
-    }
-
-    @Override
-    public int dimensions() {
-        return values.length;
-    }
-
-    @Override
-    public double get(int index) {
-        return values[index];
-    }
-
-    @Override
-    public int hashCode() {
-        return hashCode;
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (obj instanceof StreamObj) {
-            StreamObj that = (StreamObj) obj;
-            if (this.dimensions() != that.dimensions()) {
-                return false;
-            }
-            for (int i = 0; i < this.dimensions(); i++) {
-                if (this.values[i] != that.values[i]) {
-                    return false;
-                }
-            }
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    @Override
-    public int compareTo(StreamObj that) {
-        int dimensions = Math.min(this.dimensions(), that.dimensions());
-        for (int i = 0; i < dimensions; i++) {
-            double v1 = this.values[i];
-            double v2 = that.values[i];
-            if (v1 > v2) {
-                return +1;
-            }
-            if (v1 < v2) {
-                return -1;
-            }
-        }
-
-        if (this.dimensions() > dimensions) {
-            return +1;
-        }
-
-        if (that.dimensions() > dimensions) {
-            return -1;
-        }
-
-        return 0;
-    }
-}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/clusterers/outliers/MCOD/Test.java b/moa/src/main/java/moa/clusterers/outliers/MCOD/Test.java
deleted file mode 100644
index 5b8474cab..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/MCOD/Test.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- *    Test.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers.MCOD;
-
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.streams.clustering.RandomRBFGeneratorEvents;
-
-
-public class Test {    
-    public static void main(String[] args) throws Exception 
-    {
-        //if (true) return;
-        
-        int numInstances = 50000;
-        //moa.streams.ArffFileStream stream = new ArffFileStream("./datasets/debug_2.txt", -1);
-        RandomRBFGeneratorEvents stream = new RandomRBFGeneratorEvents();
-        stream.prepareForUse();
-        
-        MCOD myOutlierDetector= new MCOD();
-        /*myOutlierDetector.kOption.setValue(3);
-        myOutlierDetector.radiusOption.setValue(5);
-        myOutlierDetector.windowSizeOption.setValue(6);*/
-        myOutlierDetector.setModelContext(stream.getHeader());
-        myOutlierDetector.prepareForUse(); 
-        
-        Long tmStart = System.currentTimeMillis();
-        
-        int numberSamples = 0;   
-        int w = myOutlierDetector.windowSizeOption.getValue();
-        while (stream.hasMoreInstances() && (numberSamples < numInstances)) {
-            Instance newInst = stream.nextInstance().getData();
-            myOutlierDetector.processNewInstanceImpl(newInst);            
-            numberSamples++;
-            if (numberSamples % 100 == 0) {
-                //System.out.println("Processed " + numberSamples + " stream objects.");  
-            }
-            if ((numberSamples % (w / 2)) == 0) {
-                //myOutlierDetector.PrintOutliers();
-            }
-        }        
-        //myOutlierDetector.PrintOutliers();
-        System.out.println("Total time = " + (System.currentTimeMillis() - tmStart) + " ms");
-    }
-}
diff --git a/moa/src/main/java/moa/clusterers/outliers/MyBaseOutlierDetector.java b/moa/src/main/java/moa/clusterers/outliers/MyBaseOutlierDetector.java
deleted file mode 100644
index 1d3d64ac9..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/MyBaseOutlierDetector.java
+++ /dev/null
@@ -1,476 +0,0 @@
-/*
- *    MyBaseOutlierDetector.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- * 
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers;
-
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.PrintStream;
-import java.util.Random;
-import java.util.Set;
-import java.util.TreeSet;
-import java.util.Vector;
-
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.cluster.Cluster;
-import moa.cluster.Clustering;
-import moa.cluster.SphereCluster;
-import moa.clusterers.AbstractClusterer;
-import moa.core.Measurement;
-
-public abstract class MyBaseOutlierDetector extends AbstractClusterer { 
-    public static class Outlier implements Comparable<Outlier> {
-        public long id;
-        public Instance inst;
-        public Object obj;
-        
-        public Outlier(Instance inst, long id, Object obj) {
-            this.id = id;
-            this.inst = inst;
-            this.obj = obj;
-        }
-        
-        @Override
-        public int compareTo(Outlier o) { 
-            if (this.id > o.id)
-                return 1;
-            else if (this.id < o.id)
-                return -1;
-            else 
-                return 0;
-        }
-
-        @Override
-        public boolean equals(Object o) {
-            return (this.id == ((Outlier) o).id);
-        }
-    }
-    
-    public static abstract class OutlierNotifier {
-        public void OnOutlier(Outlier outlier) {
-            throw new UnsupportedOperationException("Not yet implemented");
-        }
-        
-        public void OnInlier(Outlier outlier) {
-            throw new UnsupportedOperationException("Not yet implemented");
-        }
-    }
-    
-    public IntOption windowSizeOption = new IntOption("windowSize", 'w', "Size of the window.", 1000);
-    
-    public OutlierNotifier outlierNotifier = null;   
-    
-    protected Random random;
-    protected int iMaxMemUsage = 0;
-    protected int nRangeQueriesExecuted = 0;
-    protected Long nTotalRunTime = 0L;
-    protected double nTimePerObj;    
-    
-    private Clustering myClusters = null;
-    private TreeSet<Outlier> outliersFound;
-    private Long m_timePreObjSum;
-    private int nProcessed;
-    private static final int m_timePreObjInterval = 100;
-    
-    protected void UpdateMaxMemUsage() {
-        int x = GetMemoryUsage();
-        if (iMaxMemUsage < x) iMaxMemUsage = x;
-    }
-    
-    public double getTimePerObj() {
-        return nTimePerObj;
-    }
-    
-    public String getObjectInfo(Object obj) {
-        throw new UnsupportedOperationException("Not yet implemented");
-    }
-    
-    public String getStatistics() {
-        throw new UnsupportedOperationException("Not yet implemented");
-    }
-    
-    public double[] getInstanceValues(Instance inst) {
-        int length = inst.numValues()-1; 
-        double[] values = new double[length]; // last attribute is the class
-        for (int i = 0; i < length; i++) {
-            values[i] = inst.value(i);
-        }
-        return values;
-    }
-    
-    public void PrintInstance(Instance inst) {
-        Print("instance: [ ");
-        for (int i = 0; i < inst.numValues()-1; i++) { // -1 last value is the class
-            Printf("%.2f ", inst.value(i));
-        }
-        Print("] ");
-        Println("");
-    }
-    
-    @Override
-    public void resetLearningImpl() {        
-        Init();
-    }
-    
-    protected void Init() {        
-        random = new Random(System.currentTimeMillis());
-        outliersFound = new TreeSet<Outlier>();
-        
-        m_timePreObjSum = 0L;
-        nProcessed = 0;
-        nTimePerObj = 0L;
-        
-        StdPrintMsg printer = new StdPrintMsg();
-        printer.RedirectToDisplay();
-        
-        //timePerObjInfo = new MyTimePerObjInfo();
-        //timePerObjInfo.Init();
-        
-        SetUserInfo(true, false, printer, 1000);
-    }
-    
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        processNewInstanceImpl(inst);
-    }
-    
-    public void processNewInstanceImpl(Instance inst) {        
-        Long nsNow = System.nanoTime(); 
-        
-        ProcessNewStreamObj(inst);
-        
-        UpdateMaxMemUsage();
-        nTotalRunTime += (System.nanoTime() - nsNow) / (1024 * 1024);
-        
-        // update process time per object   
-        nProcessed++;
-        m_timePreObjSum += System.nanoTime() - nsNow;
-        if (nProcessed % m_timePreObjInterval == 0) {           
-            nTimePerObj = ((double) m_timePreObjSum) / ((double) m_timePreObjInterval);
-            if (bShowProgress) ShowTimePerObj();
-            // init
-            m_timePreObjSum = 0L;
-        }
-    }
-    
-    private void ShowTimePerObj() {
-        double ms = nTimePerObj / (1000.0 * 1000.0);
-        Println("Process time per object (ms): " + String.format("%.3f", ms));
-    }
-    
-    protected void ProcessNewStreamObj(Instance inst) {
-        throw new UnsupportedOperationException("Not yet implemented");
-    }
-    
-    public void PrintOutliers() {        
-        Print("Outliers: ");        
-        for (Outlier o : outliersFound) {
-            Printf("[%d] ", o.id);
-        }
-        Println("");
-    }
-    
-    public Set<Outlier> GetOutliersFound() {
-        return outliersFound;
-    }
-    
-    protected boolean IsNodeIdInWin(long id) {
-        throw new UnsupportedOperationException("Not yet implemented");
-    }
-        
-    @Override
-    public Clustering getClusteringResult(){
-        myClusters = new Clustering();
-        for (Outlier o : outliersFound) {
-            if (IsNodeIdInWin(o.id)) {
-                double[] center = new double[o.inst.numValues() - 1];
-                for (int i = 0; i < o.inst.numValues() - 1; i++) {
-                    center[i] = o.inst.value(i);                
-                }            
-                Cluster c = new SphereCluster(center, 0);
-                myClusters.add(c);
-            }
-        }
-        return myClusters;
-    }
-    
-    public Vector<Outlier> getOutliersResult(){
-        Vector<Outlier> outliers = new Vector<Outlier>();
-        for (Outlier o : outliersFound) {
-            if (IsNodeIdInWin(o.id)) {                
-                outliers.add(o);
-            }
-        }
-        return outliers;
-    }
-    
-    protected void AddOutlier(Outlier newOutlier) {
-        boolean bNewAdd = outliersFound.add(newOutlier);
-        if ((outlierNotifier != null) && bNewAdd) {
-            outlierNotifier.OnOutlier(newOutlier);
-        }
-    }
-    
-    protected boolean RemoveExpiredOutlier(Outlier outlier) {
-        boolean bFound = outliersFound.remove(outlier);
-        return bFound;
-    }  
-    
-    protected boolean RemoveOutlier(Outlier outlier) {
-        boolean bFound = outliersFound.remove(outlier);
-        if ((outlierNotifier != null) && bFound) {
-            outlierNotifier.OnInlier(outlier);
-        }
-        return bFound;
-    }            
-
-    @Override
-    public boolean implementsMicroClusterer() {
-        return false;
-    }
-    
-    @Override
-    public Clustering getMicroClusteringResult() {
-        return null;
-    }
-    
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        throw new UnsupportedOperationException("Not supported yet.");
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        throw new UnsupportedOperationException("Not supported yet.");
-    }
-
-    @Override
-    public boolean isRandomizable() {
-        return false;
-    }
-
-    @Override
-    public boolean keepClassLabel(){
-        return true;
-    }
-
-    @Override
-    public Prediction getPredictionForInstance(Instance inst) {
-        return null;
-    }
-    
-    // show progress through object
-    protected ProgressInfo myProgressInfo;
-    protected PrintMsg myOut;
-    protected boolean bTrace = false;
-    protected boolean bShowProgress = false;
-    public boolean bStopAlgorithm = false;
-    // time measurement for progress
-    private Long _msPrev = 0L, _msNow = 0L;
-    
-    public void SetShowProgress(boolean b) {
-        bShowProgress = b;
-    }
-    
-    public void SetTrace(boolean b) {
-        bTrace = b;
-    }
-    
-    public void SetProgressInterval(int iProgressInterval) {
-        myProgressInfo = new MyProgressInfo(iProgressInterval);
-    }
-    
-    public void SetMessagePrinter(PrintMsg logPrinter) {
-        myOut = logPrinter;
-    }
-    
-    public void SetUserInfo(
-            boolean bShowProgress,
-            boolean bTrace,
-            PrintMsg logPrinter,
-            int iProgressInterval) 
-    {
-        this.bShowProgress = bShowProgress;
-        this.bTrace = bTrace;
-        
-        myProgressInfo = new MyProgressInfo(iProgressInterval);
-        myOut = logPrinter;
-    }
-    
-    public interface PrintMsg {
-        public void print(String s);
-        public void println(String s);
-        public void printf(String fmt, Object... args);
-    }
-    
-    public interface ProgressInfo {
-        public int GetInterval();
-        public void ShowProgress(String sMsg);
-    }
-    
-    public class StdPrintMsg implements PrintMsg {
-        private PrintStream printStream, fileStream;            
-        
-        public StdPrintMsg() {
-            RedirectToDisplay();
-        }
-        
-        public StdPrintMsg(String sFilename) {
-            RedirectToFile(sFilename);
-        }
-        
-        public void RedirectToDisplay() {
-            printStream = System.out;
-        }
-        
-        public void RedirectToFile(String sFilename) {
-            File file = new File(sFilename);
-            try {
-                fileStream = new PrintStream(new FileOutputStream(file));
-                printStream = fileStream;
-            } catch (Exception ex) {}
-        }
-        
-        public void RedirectToFile() {
-            printStream = fileStream;
-        }
-        
-        @Override
-        public void println(String s) {
-            printStream.println(s);
-        }
-        
-        @Override
-        public void print(String s) {
-            printStream.print(s);
-        }    
-        
-        @Override
-        public void printf(String fmt, Object... args) {
-            printStream.printf(fmt, args);
-        }  
-    }
-    
-    class MyProgressInfo implements ProgressInfo {
-        int progressInterval;
-        
-        public MyProgressInfo(int interval) {
-            progressInterval = interval;
-        }
-
-        public void setProgressInterval(int progressInterval) {
-            this.progressInterval = progressInterval;
-        }
-        
-        @Override
-        public int GetInterval() {
-            return progressInterval;
-        }
-        
-        @Override
-        public void ShowProgress(String sMsg) {
-            myOut.println(sMsg);
-        }
-    }
-    
-    protected void ShowProgress(String sMsg) 
-    {
-        ShowProgress(sMsg, false);
-    }
-    
-    protected void ShowProgress(String sMsg, boolean bShowAlways) {
-        if (bShowAlways || (_msNow - _msPrev >= myProgressInfo.GetInterval())) {
-            // call user progress function
-            myProgressInfo.ShowProgress(sMsg);
-            
-            _msNow = System.currentTimeMillis();
-            _msPrev = _msNow;
-        } else {
-            _msNow = System.currentTimeMillis();
-        }
-    }
-    
-    /*public class MyTimePerObjInfo {
-        Long nPrevObj, nsPrevObj;
-        Long _msTimerPrev = 0L, _msTimerNow = 0L;
-        
-        public MyTimePerObjInfo() {
-            Init();
-        }
-        
-        public void Init()
-        {
-            nPrevObj = 0L;
-            nsPrevObj = 0L;            
-        }
-        
-        private void _ShowTimePerObj(Long nObj) {
-            Double timePerObj = 0.0;
-            Long nsNow = System.nanoTime(); 
-            Long d = nObj - nPrevObj + 1;
-            if ((d > 0) && (nsPrevObj > 0)) {           
-                timePerObj = (double)(nsNow - nsPrevObj) / (double)d;
-            }
-            nsPrevObj = nsNow;
-            nPrevObj = nObj;
-            
-            // call user progress function
-            myProgressInfo.ShowProgress("Processing time per object (ms): " + String.format("%.3f", timePerObj / (1000.0 * 1000.0)));
-        }
-        
-        public void ShowTimePerObj(Long nObj, boolean bShowAlways) {
-            if (bShowAlways || (_msTimerNow - _msTimerPrev >= myProgressInfo.GetInterval())) {                
-                _ShowTimePerObj(nObj);
-                _msTimerNow = System.currentTimeMillis();
-                _msTimerPrev = _msTimerNow;
-            } else {
-                _msTimerNow = System.currentTimeMillis();
-            }
-        }
-        
-        public void ShowTimePerObj(Long nObj) 
-        {
-            ShowTimePerObj(nObj, false);
-        }
-    }*/
-    
-    protected void Println(String s) {
-        if (myOut != null)
-            myOut.println(s);
-    }
-    
-    protected void Print(String s) {
-        if (myOut != null)
-            myOut.print(s);
-    }
-    
-    protected void Printf(String fmt, Object... args) {
-        if (myOut != null)
-            myOut.printf(fmt, args);
-    }
-    
-    protected int GetMemoryUsage() {
-        int iMemory = (int) ((Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()) / (1024 * 1024));
-        return iMemory;
-    }
-}
diff --git a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/ISBIndex.java b/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/ISBIndex.java
deleted file mode 100644
index 4a12a6459..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/ISBIndex.java
+++ /dev/null
@@ -1,262 +0,0 @@
-/*
- *    ISBIndex.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers.SimpleCOD;
-
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.Vector;
-
-import com.yahoo.labs.samoa.instances.Instance;
-
-public class ISBIndex {    
-    public static class ISBNode implements Comparable<ISBNode> {        
-        public Instance inst;
-        public StreamObj obj;
-        public Long id;
-        public boolean bOutlier;
-        public int count_after;
-        private ArrayList<ISBNode> nn_before;
-        
-        // statistics
-        public int nOutlier;
-        public int nInlier;
-        
-
-        public ISBNode(Instance inst, StreamObj obj, Long id) {
-            this.inst = inst;
-            this.obj  = obj;
-            this.id   = id;
-            
-            this.bOutlier    = false;
-            this.count_after = 1;
-            this.nn_before   = new ArrayList<ISBNode>();
-            
-            // init statistics
-            nOutlier = 0;
-            nInlier  = 0;
-        }  
-        
-        @Override
-        public int compareTo(ISBNode t) {
-            if (this.id > t.id)
-                return +1;
-            else if (this.id < t.id)
-                return -1;
-            return 0;
-        }
-        
-        public void AddPrecNeigh(ISBNode node) {
-            int pos = Collections.binarySearch(nn_before, node);
-            if (pos < 0) {
-                // item does not exist, so add it to the right position
-                nn_before.add(-(pos + 1), node);
-            }
-        }
-        
-        public void RemovePrecNeigh(ISBNode node) {
-            int pos = Collections.binarySearch(nn_before, node);
-            if (pos >= 0) {
-                // item exists
-                nn_before.remove(pos);
-            }
-        }
-        
-        public ISBNode GetMinPrecNeigh(Long sinceId) {
-            if (nn_before.size() > 0) {                
-                int startPos;
-                ISBNode dummy = new ISBNode(null, null, sinceId);
-                
-                int pos = Collections.binarySearch(nn_before, dummy);
-                if (pos < 0) {
-                    // item does not exist, should insert at position startPos
-                    startPos = -(pos + 1);
-                } else {
-                    // item exists at startPos
-                    startPos = pos;
-                }
-                
-                if (startPos < nn_before.size()) {
-                    return nn_before.get(startPos);
-                }
-            }
-            return null;
-        }
-        
-        public int CountPrecNeighs(Long sinceId) {
-            if (nn_before.size() > 0) {
-                // get number of neighs with id >= sinceId
-                int startPos;
-                ISBNode dummy = new ISBNode(null, null, sinceId);
-                int pos = Collections.binarySearch(nn_before, dummy);
-                if (pos < 0) {
-                    // item does not exist, should insert at position startPos
-                    startPos = -(pos + 1);
-                } else {
-                    // item exists at startPos
-                    startPos = pos;
-                }
-                
-                if (startPos < nn_before.size()) {
-                    return nn_before.size() - startPos;
-                }
-            }
-            return 0;
-        }
-        
-        public List<ISBNode> Get_nn_before() {
-            return nn_before;
-        }
-    }
-    
-    MyMTree mtree;
-    Map<Integer, Set<ISBNode>> mapNodes;
-    double m_radius;
-    int m_k; // k nearest neighbors
-    
-    public ISBIndex(double radius, int k) {
-        mtree = new MyMTree();
-        mapNodes = new HashMap<Integer, Set<ISBNode>>();
-        m_radius = radius;
-        m_k = k;
-    }
-    
-    Vector<ISBNode> GetAllNodes() {
-        Vector<ISBNode> v = new Vector<ISBNode>(); 
-        Iterator it = mapNodes.entrySet().iterator();
-        while (it.hasNext()) {
-            Map.Entry pairs = (Map.Entry) it.next();
-            Set<ISBNode> setNodes = (Set<ISBNode>) pairs.getValue();
-            for (ISBNode n : setNodes) {
-                v.add(n);
-            }
-        }  
-        return v;
-    }
-    
-    public static class ISBSearchResult {
-        public ISBNode node;
-        public double distance;
-        
-        public ISBSearchResult(ISBNode n, double distance) {
-            this.node = n;
-            this.distance = distance;
-        }
-    }
-    
-    public Vector<ISBSearchResult> RangeSearch(ISBNode node, double radius) {
-        Vector<ISBSearchResult> results = new Vector<ISBSearchResult>();
-        StreamObj obj;
-        double d;
-        MyMTree.Query query = mtree.getNearestByRange(node.obj, radius);
-        for (MyMTree.ResultItem q : query) {
-            // get next obj found within range
-            obj = q.data;
-            // get distance of obj from query
-            d = q.distance;
-            // get all nodes referencing obj
-            Vector<ISBNode> nodes = MapGetNodes(obj);
-            for (int i = 0; i < nodes.size(); i++)
-                results.add(new ISBSearchResult(nodes.get(i), d));
-        }        
-        return results;
-    }
-    
-    public void Insert(ISBNode node) {
-        // insert object of node at mtree
-        mtree.add(node.obj);
-        // insert node at map
-        MapInsert(node);    
-    }
-    
-    public void Remove(ISBNode node) {
-        // remove from map
-        MapDelete(node);
-        // check if stream object at mtree is still being referenced
-        if (MapCountObjRefs(node.obj) <= 0) {
-            // delete stream object from mtree
-            mtree.remove(node.obj);
-        }
-    }
-    
-    Vector<ISBNode> MapGetNodes(StreamObj obj) {
-        int h = obj.hashCode();
-        Vector<ISBNode> v = new Vector<ISBNode>();
-        if (mapNodes.containsKey(h)) {
-            Set<ISBNode> s = mapNodes.get(h);
-            ISBNode node;
-            Iterator<ISBNode> i = s.iterator();
-            while (i.hasNext()) {
-                node = i.next();
-                if (node.obj.equals(obj))
-                    v.add(node);
-            }
-        }
-        return v;
-    }
-    
-    int MapCountObjRefs(StreamObj obj) {
-        int h = obj.hashCode();
-        int iCount = 0;
-        if (mapNodes.containsKey(h)) {
-            Set<ISBNode> s = mapNodes.get(h);
-            ISBNode n;
-            Iterator<ISBNode> i = s.iterator();
-            while (i.hasNext()) {
-                n = i.next();
-                if (n.obj.equals(obj))
-                    iCount++;
-            }
-        }
-        return iCount;
-    }  
-    
-    void MapInsert(ISBNode node) {
-        int h = node.obj.hashCode();
-        Set<ISBNode> s;
-        if (mapNodes.containsKey(h)) {
-            s = mapNodes.get(h);
-            s.add(node);
-        }
-        else {
-            s = new HashSet<ISBNode>();
-            s.add(node);
-            mapNodes.put(h, s);
-        }
-    }
-    
-    void MapDelete(ISBNode node) {
-        int h = node.obj.hashCode();
-        if (mapNodes.containsKey(h)) {
-            Set<ISBNode> s = mapNodes.get(h);
-            s.remove(node);
-            if (s.isEmpty()) { // ### added
-                mapNodes.remove(h);
-            }
-        }
-    }  
-}
diff --git a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/MyMTree.java b/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/MyMTree.java
deleted file mode 100644
index 722ee5687..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/MyMTree.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- *    MyMTree.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers.SimpleCOD;
-
-import java.util.Set;
-
-import moa.clusterers.outliers.utils.mtree.ComposedSplitFunction;
-import moa.clusterers.outliers.utils.mtree.DistanceFunction;
-import moa.clusterers.outliers.utils.mtree.DistanceFunctions;
-import moa.clusterers.outliers.utils.mtree.MTree;
-import moa.clusterers.outliers.utils.mtree.PartitionFunctions;
-import moa.clusterers.outliers.utils.mtree.PromotionFunction;
-import moa.clusterers.outliers.utils.mtree.utils.Pair;
-import moa.clusterers.outliers.utils.mtree.utils.Utils;
-
-class MyMTree extends MTree<StreamObj> {
-
-    private static final PromotionFunction<StreamObj> nonRandomPromotion = new PromotionFunction<StreamObj>() {
-
-        @Override
-        public Pair<StreamObj> process(Set<StreamObj> dataSet, DistanceFunction<? super StreamObj> distanceFunction) {
-            return Utils.minMax(dataSet);
-        }
-    };
-
-    MyMTree() {
-        super(2, DistanceFunctions.EUCLIDEAN,
-                new ComposedSplitFunction<StreamObj>(
-                nonRandomPromotion,
-                new PartitionFunctions.BalancedPartition<StreamObj>()));
-    }
-
-    public void add(StreamObj data) {
-        super.add(data);
-        _check();
-    }
-
-    public boolean remove(StreamObj data) {
-        boolean result = super.remove(data);
-        _check();
-        return result;
-    }
-
-    DistanceFunction<? super StreamObj> getDistanceFunction() {
-        return distanceFunction;
-    }
-};
diff --git a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/SimpleCOD.java b/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/SimpleCOD.java
deleted file mode 100644
index 2e8a1fb80..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/SimpleCOD.java
+++ /dev/null
@@ -1,208 +0,0 @@
-/*
- *    SimpleCOD.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers.SimpleCOD;
-
-import java.util.Vector;
-
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.clusterers.outliers.SimpleCOD.ISBIndex.ISBNode;
-import moa.clusterers.outliers.SimpleCOD.ISBIndex.ISBSearchResult;
-
-
-////The algorithm is described in 
-// M. Kontaki, A. Gounaris, A. N. Papadopoulos, K. Tsichlas, and Y. Manolopoulos. 
-//Continuous monitoring of distance-based outliers over data streams.
-//In ICDE, pages 135–146, 2011.
-
-public class SimpleCOD extends SimpleCODBase {
-    public FloatOption radiusOption = new FloatOption("radius", 'r', "Search radius.", 0.1);
-    public IntOption kOption = new IntOption("k", 't', "Parameter k.", 50);
-    
-    public SimpleCOD()
-    {
-        // System.out.println("SimpleCOD: created");
-    }
-    
-    @Override
-    public void Init() {   
-        super.Init();
-        
-        m_WindowSize = windowSizeOption.getValue();
-        m_radius = radiusOption.getValue();
-        m_k = kOption.getValue();
-                
-        Println("Init SimpleCOD:");
-        Println("   window_size: " + m_WindowSize);
-        Println("   radius: " + m_radius);
-        Println("   k: " + m_k);
-        
-        //bTrace = true;
-        //bWarning = true;
-        
-        objId = FIRST_OBJ_ID; // init object identifier
-        // create nodes list of window
-        windowNodes = new Vector<ISBNode>();
-        // create ISB
-        ISB = new ISBIndex(m_radius, m_k);
-        // create event queue
-        eventQueue = new EventQueue();
-        
-        // init statistics
-        m_nBothInlierOutlier = 0;
-        m_nOnlyInlier = 0;
-        m_nOnlyOutlier = 0;
-    }
-    
-    void ProcessNewNode(ISBNode nodeNew, boolean bNewNode) {
-        if (bTrace) { Print("ProcessNewNode: "); PrintNode(nodeNew); }        
-        
-        if (bTrace) Println("Perform R range query");    
-        nRangeQueriesExecuted++;
-        Vector<ISBSearchResult> resultNodes;
-        resultNodes = ISB.RangeSearch(nodeNew, m_radius);
-        for (ISBSearchResult sr : resultNodes) {
-            double distance = sr.distance;
-            ISBNode q = sr.node;
-            if ( (nodeNew != q) && (distance <= m_radius) ) {  
-                if (bTrace) Println("nodeNew has neighbor q.id " + q.id);  
-                nodeNew.AddPrecNeigh(q);
-                q.count_after++;
-                
-                if (q.bOutlier) {
-                    int count = q.CountPrecNeighs(GetWindowStart()) + q.count_after; 
-                    if (count >= m_k) {
-                        if (bTrace) Println("q.id " + q.id + " is now an inlier");  
-                        q.bOutlier = false;
-                        RemoveOutlier(q);
-                        // insert q to event queue
-                        ISBNode nodeMinExp = q.GetMinPrecNeigh(GetWindowStart());
-                        AddToEventQueue(q, nodeMinExp);
-                    }
-                }
-            }
-        }
-        
-        if (bTrace) Println("Check if nodeNew is an inlier or outlier"); 
-        int count = nodeNew.CountPrecNeighs(GetWindowStart()) + nodeNew.count_after;
-        if (count >= m_k) {
-            if (bTrace) Println("nodeNew is an inlier");   
-            nodeNew.bOutlier = false;
-            RemoveOutlier(nodeNew); // updates statistics
-            // insert nodeNew to event queue
-            ISBNode nodeMinExp = nodeNew.GetMinPrecNeigh(GetWindowStart());
-            AddToEventQueue(nodeNew, nodeMinExp);
-        } else {
-            if (bTrace) Println("nodeNew is an outlier");
-            nodeNew.bOutlier = true;
-            SaveOutlier(nodeNew);
-        }
-    }
-
-    void AddToEventQueue(ISBNode x, ISBNode nodeMinExp) {
-        if (bTrace) Println("AddToEventQueue x.id: " + x.id); 
-        if (nodeMinExp != null) {
-            Long expTime = GetExpirationTime(nodeMinExp);
-            eventQueue.Insert(x, expTime);
-            if (bTrace) {
-                Print("x.nn_before: "); PrintNodeList(x.Get_nn_before());
-                Println("nodeMinExp: " + nodeMinExp.id + ", expTime = " + expTime);
-                PrintEventQueue();
-            }
-        } else {
-            if (bWarning) Println("AddToEventQueue: Cannot add x.id: " + x.id + " to event queue (nn_before is empty, count_after=" + x.count_after + ")"); 
-        }
-    }
-    
-    void ProcessEventQueue(ISBNode nodeExpired) {
-        EventItem e = eventQueue.FindMin();
-        while ((e != null) && (e.timeStamp <= GetWindowEnd())) {
-            e = eventQueue.ExtractMin();
-            ISBNode x = e.node;
-            if (bTrace) Println("Process event queue: check node x: " + x.id);
-            // node x must be in window
-            if (IsNodeIdInWin(x.id)) {
-                // remove nodeExpired from x.nn_before
-                x.RemovePrecNeigh(nodeExpired);
-                // get amount of neighbors of x
-                int count = x.count_after + x.CountPrecNeighs(GetWindowStart());
-                if (count < m_k) {
-                    if (bTrace) Println("x is an outlier");
-                    x.bOutlier = true;
-                    SaveOutlier(x);
-                } else {
-                    if (bTrace) Println("x is an inlier, add to event queue");
-                    x.bOutlier = false;
-                    // get oldest preceding neighbor of x
-                    ISBNode nodeMinExp = x.GetMinPrecNeigh(GetWindowStart());
-                    // add x to event queue
-                    AddToEventQueue(x, nodeMinExp);
-                }
-            } else {
-                if (bWarning) Println("Process event queue: node x.id: " + x.id + " has expired!");
-            }
-            e = eventQueue.FindMin();
-        }
-    }
-    
-    void ProcessExpiredNode(ISBNode nodeExpired) { 
-        if (nodeExpired != null) {
-            if (bTrace) Println("\nnodeExpired: " + nodeExpired.id);
-            ISB.Remove(nodeExpired); // remove nodeExpired from index
-            RemoveNode(nodeExpired);
-            ProcessEventQueue(nodeExpired);
-        }
-    }
-    
-    @Override
-    protected void ProcessNewStreamObj(Instance inst)
-    {                
-        if (bShowProgress) ShowProgress("Processed " + (objId-1) + " stream objects.");       
-        // PrintInstance(inst);
-        
-        double[] values = getInstanceValues(inst);
-        StreamObj obj = new StreamObj(values);
-        
-        if (bTrace) Println("\n- - - - - - - - - - - -\n");
-
-        // create new ISB node
-        ISBNode nodeNew = new ISBNode(inst, obj, objId);
-        if (bTrace) { Print("New node: "); PrintNode(nodeNew); }
-        
-        objId++; // update object identifier (slide window)
-        
-        AddNode(nodeNew); // add nodeNew to window
-        if (bTrace) PrintWindow();
-        
-        // insert new node to ISB index
-        ISB.Insert(nodeNew);
-        
-        ProcessNewNode(nodeNew, true);
-        ProcessExpiredNode(GetExpiredNode());
-        
-        if (bTrace) {
-            PrintOutliers();
-            PrintISB();
-        }
-    }
-}
diff --git a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/SimpleCODBase.java b/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/SimpleCODBase.java
deleted file mode 100644
index cd8ac90d3..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/SimpleCODBase.java
+++ /dev/null
@@ -1,319 +0,0 @@
-/*
- *    SimpleCODBase.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-package moa.clusterers.outliers.SimpleCOD;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Set;
-import java.util.TreeSet;
-import java.util.Vector;
-
-import moa.clusterers.outliers.MyBaseOutlierDetector;
-import moa.clusterers.outliers.SimpleCOD.ISBIndex.ISBNode;
-
-public abstract class SimpleCODBase extends MyBaseOutlierDetector {    
-    protected static class EventItem implements Comparable<EventItem> {
-        public ISBNode node;
-        public Long timeStamp;
-
-        public EventItem(ISBNode node, Long timeStamp) {
-            this.node = node;
-            this.timeStamp = timeStamp;
-        }
-
-        @Override
-        public int compareTo(EventItem t) {
-            if (this.timeStamp > t.timeStamp) {
-                return +1;
-            } else if (this.timeStamp < t.timeStamp) {
-                return -1;
-            } else {
-                if (this.node.id > t.node.id)
-                    return +1;
-                else if (this.node.id < t.node.id)
-                    return -1;
-            }
-            return 0;
-        }
-    }
-    
-    protected static class EventQueue {
-        public TreeSet<EventItem> setEvents;
-
-        public EventQueue() {
-            setEvents = new TreeSet<EventItem>();
-        }
-        
-        public void Insert(ISBNode node, Long expTime) {
-            setEvents.add(new EventItem(node, expTime));
-        }
-        
-        public EventItem FindMin() {
-            if (setEvents.size() > 0) {
-                // events are sorted ascenting by expiration time
-                return setEvents.first();
-            }
-            return null;
-        }
-        
-        public EventItem ExtractMin() {
-            EventItem e = FindMin();
-            if (e != null) {
-                setEvents.remove(e);
-                return e;
-            }
-            return null;
-        }
-    }
-    
-    protected static final Long FIRST_OBJ_ID = 1L;
-    
-    // object identifier increments with each new data stream object
-    protected Long objId;
-    // list used to find expired nodes
-    protected Vector<ISBNode> windowNodes; 
-    protected EventQueue eventQueue;
-    // index of objects
-    protected ISBIndex ISB;
-    protected int m_WindowSize;
-    protected double m_radius;
-    protected int m_k;
-    public boolean bWarning = false;
-    
-    // statistics
-    public int m_nBothInlierOutlier;
-    public int m_nOnlyInlier;
-    public int m_nOnlyOutlier;
-    
-    @Override
-    public String getObjectInfo(Object obj) {
-        if (obj == null) return null;
-        
-        ISBNode node = (ISBNode) obj;
-        
-        ArrayList<String> infoTitle = new ArrayList<String>();
-        ArrayList<String> infoValue = new ArrayList<String>();
-        StringBuilder sb = new StringBuilder();
-
-        // show node position
-        for (int i = 0; i < node.obj.dimensions(); i++) {
-            infoTitle.add("Dim" + (i+1));
-            infoValue.add(String.format("%.3f", node.obj.get(i)));
-        }
-        
-        // show node properties
-        infoTitle.add("id");
-        infoValue.add(String.format("%d", node.id));
-        infoTitle.add("count_after");
-        infoValue.add(String.format("%d", node.count_after));
-        infoTitle.add("|nn_before|");
-        infoValue.add(String.format("%d", node.CountPrecNeighs(GetWindowStart())));
-        
-        sb.append("<html>");
-        sb.append("<table>");
-        int i = 0;
-        while(i < infoTitle.size() && i < infoValue.size()){
-            sb.append("<tr><td><b>"+infoTitle.get(i)+":</b></td><td>"+infoValue.get(i)+"</td></tr>");
-            i++;
-        }
-        sb.append("</table>");
-
-        
-        sb.append("</html>");
-        return sb.toString();
-    }
-    
-    @Override
-    public String getStatistics() {
-        StringBuilder sb = new StringBuilder();
-        
-        sb.append("Statistics:\n\n");
-        
-        // get counters of expired nodes
-        int nBothInlierOutlier = m_nBothInlierOutlier;
-        int nOnlyInlier = m_nOnlyInlier;
-        int nOnlyOutlier = m_nOnlyOutlier;
-        
-        // add counters of non expired nodes
-        for (ISBNode node : windowNodes) {
-            if ((node.nInlier > 0) && (node.nOutlier > 0))
-                nBothInlierOutlier++;
-            else if (node.nInlier > 0)
-                nOnlyInlier++;
-            else
-                nOnlyOutlier++;
-        }
-        
-        int sum = nBothInlierOutlier + nOnlyInlier + nOnlyOutlier;
-        if (sum > 0) {
-            sb.append(String.format("  Nodes always inlier: %d (%.1f%%)\n", nOnlyInlier, (100 * nOnlyInlier) / (double)sum));
-            sb.append(String.format("  Nodes always outlier: %d (%.1f%%)\n", nOnlyOutlier, (100 * nOnlyOutlier) / (double)sum));
-            sb.append(String.format("  Nodes both inlier and outlier: %d (%.1f%%)\n", nBothInlierOutlier, (100 * nBothInlierOutlier) / (double)sum));
-            
-            sb.append("  (Sum: " + sum + ")\n");
-        }
-        
-        sb.append("\n  Total range queries: " + nRangeQueriesExecuted + "\n");
-        sb.append("  Max memory usage: " + iMaxMemUsage + " MB\n");
-        sb.append("  Total process time: " + String.format("%.2f ms", nTotalRunTime / 1000.0) + "\n");
-        
-        return sb.toString();
-    }
-    
-    Long GetWindowEnd() {
-        return objId - 1;
-    }
-    
-    Long GetWindowStart() {
-        Long x = GetWindowEnd() - m_WindowSize + 1;
-        if (x < FIRST_OBJ_ID) 
-            x = FIRST_OBJ_ID;
-        return x;
-    }
-    
-    boolean IsWinFull() {
-        return (GetWindowEnd() >= FIRST_OBJ_ID + m_WindowSize - 1);
-    }
-    
-    Long GetExpirationTime(ISBNode node) {
-        return node.id + m_WindowSize;
-    }
-    
-    void SaveOutlier(ISBNode node) {
-        AddOutlier(new Outlier(node.inst, node.id, node));
-        node.nOutlier++; // update statistics
-    }
-    
-    void RemoveOutlier(ISBNode node) {
-        RemoveOutlier(new Outlier(node.inst, node.id, node));
-        node.nInlier++; // update statistics
-    }
-    
-    @Override
-    protected boolean IsNodeIdInWin(long id) {
-        int toleranceStart = 1;
-        Long start = GetWindowStart() - toleranceStart;
-        if ( (start <= id) && (id <= GetWindowEnd()) )
-            return true;
-        else
-            return false;
-    }
-    
-    void AddNode(ISBNode node) {
-        windowNodes.add(node);
-    }
-    
-    void RemoveNode(ISBNode node) {
-        windowNodes.remove(node);
-        RemoveExpiredOutlier(new Outlier(node.inst, node.id, node)); // ### remove when expired?
-        // update statistics
-        UpdateStatistics(node);
-    }
-    
-    void UpdateStatistics(ISBNode node) {
-        if ((node.nInlier > 0) && (node.nOutlier > 0))
-            m_nBothInlierOutlier++;
-        else if (node.nInlier > 0)
-            m_nOnlyInlier++;
-        else
-            m_nOnlyOutlier++;
-    }
-    
-    ISBNode GetExpiredNode() {
-        if (windowNodes.size() <= 0)
-            return null;       
-        // get oldest node
-        ISBNode node = windowNodes.get(0);
-        // check if node has expired
-        if (node.id < GetWindowStart()) {
-            return node;
-        }        
-        return null;
-    }
-    
-    double GetEuclideanDist(ISBNode n1, ISBNode n2)
-    {
-        double diff;
-        double sum = 0;
-        int d = n1.obj.dimensions();
-        for (int i = 0; i < d; i++) {
-            diff = n1.obj.get(i) - n2.obj.get(i);
-            sum += Math.pow(diff, 2);
-        }
-        return Math.sqrt(sum);
-    }
-    
-    void PrintWindow() {
-        Println("Window [" + GetWindowStart() + "-" + GetWindowEnd() + "]: ");
-        ISBNode node;
-        for (int i = 0; i < windowNodes.size(); i++) {
-            node = windowNodes.get(i);
-            Print("   Node: ");
-            PrintNode(node);
-        }
-    }
-    
-    void PrintNode(ISBNode n) {
-        Print("id=" + n.id + " (");
-        int dim = n.obj.dimensions();
-        for (int d = 0; d < dim; d++) {
-            Print(Double.toString(n.obj.get(d)));
-            if (d < dim - 1)
-                Print(", ");
-        }
-        Println(")");
-    }
-    
-    public void PrintNodeSet(Set<ISBNode> set) {
-        for (ISBNode n : set) {
-            Print(n.id + " ");
-        }
-        Println("");
-    }
-    
-    public void PrintNodeVector(Vector<ISBNode> vector) {
-        for (ISBNode n : vector) {
-            Print(n.id + " ");
-        }
-        Println("");
-    }
-    
-    public void PrintNodeList(List<ISBNode> list) {
-        for (ISBNode n : list) {
-            Print(n.id + " ");
-        }
-        Println("");
-    }
-    
-    public void PrintEventQueue() {
-        Println("event queue: ");
-        for (EventItem n : eventQueue.setEvents) {
-            Printf("  id=%d, exp=%d\n", n.node.id, n.timeStamp);
-        }
-    }
-    
-    public void PrintISB() {
-        Print("PD: ");
-        for (ISBNode n : ISB.GetAllNodes()) {
-            Print(n.id + " ");
-        }
-        Println("");
-    }
-}
diff --git a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/StreamObj.java b/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/StreamObj.java
deleted file mode 100644
index f37b8228c..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/StreamObj.java
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- *    StreamObj.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers.SimpleCOD;
-
-import moa.clusterers.outliers.utils.mtree.DistanceFunctions.EuclideanCoordinate;
-
-public class StreamObj implements EuclideanCoordinate, Comparable<StreamObj> {
-    private final double[] values;
-    private final int hashCode;
-
-    public StreamObj(double... values) {
-        this.values = values;
-
-        int h = 1;
-        for (double value : values) {
-            h = 31 * (int) h + (int) value;
-        }
-        this.hashCode = h;
-    }
-
-    @Override
-    public int dimensions() {
-        return values.length;
-    }
-
-    @Override
-    public double get(int index) {
-        return values[index];
-    }
-
-    @Override
-    public int hashCode() {
-        return hashCode;
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (obj instanceof StreamObj) {
-            StreamObj that = (StreamObj) obj;
-            if (this.dimensions() != that.dimensions()) {
-                return false;
-            }
-            for (int i = 0; i < this.dimensions(); i++) {
-                if (this.values[i] != that.values[i]) {
-                    return false;
-                }
-            }
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    @Override
-    public int compareTo(StreamObj that) {
-        int dimensions = Math.min(this.dimensions(), that.dimensions());
-        for (int i = 0; i < dimensions; i++) {
-            double v1 = this.values[i];
-            double v2 = that.values[i];
-            if (v1 > v2) {
-                return +1;
-            }
-            if (v1 < v2) {
-                return -1;
-            }
-        }
-
-        if (this.dimensions() > dimensions) {
-            return +1;
-        }
-
-        if (that.dimensions() > dimensions) {
-            return -1;
-        }
-
-        return 0;
-    }
-}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/Test.java b/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/Test.java
deleted file mode 100644
index a8ed48e79..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/SimpleCOD/Test.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- *    Test.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers.SimpleCOD;
-
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.streams.ArffFileStream;
-
-
-public class Test {    
-    public static void main(String[] args) throws Exception 
-    {
-        //if (true) return;
-        
-        int numInstances = 30;
-        moa.streams.ArffFileStream stream = new ArffFileStream("./datasets/debug_1.txt", -1);
-        //RandomRBFGeneratorEvents stream = new RandomRBFGeneratorEvents();
-        stream.prepareForUse();
-        
-        SimpleCOD myOutlierDetector= new SimpleCOD();
-        myOutlierDetector.kOption.setValue(3);
-        myOutlierDetector.radiusOption.setValue(5);
-        myOutlierDetector.windowSizeOption.setValue(6);
-        myOutlierDetector.setModelContext(stream.getHeader());
-        myOutlierDetector.prepareForUse(); 
-        
-        Long tmStart = System.currentTimeMillis();
-        
-        int numberSamples = 0;   
-        int w = myOutlierDetector.windowSizeOption.getValue();
-        while (stream.hasMoreInstances() && (numberSamples < numInstances)) {
-            Instance newInst = stream.nextInstance().getData();
-            myOutlierDetector.processNewInstanceImpl(newInst);            
-            numberSamples++;
-        }        
-        //myOutlierDetector.PrintOutliers();
-        System.out.println("Total time = " + (System.currentTimeMillis() - tmStart) + " ms");
-    }
-}
diff --git a/moa/src/main/java/moa/clusterers/outliers/TestSpeed.java b/moa/src/main/java/moa/clusterers/outliers/TestSpeed.java
deleted file mode 100644
index 31e903388..000000000
--- a/moa/src/main/java/moa/clusterers/outliers/TestSpeed.java
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- *    TestSpeed.java
- *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
- *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
- * 
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-
-package moa.clusterers.outliers;
-
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.clusterers.outliers.AbstractC.AbstractC;
-import moa.clusterers.outliers.Angiulli.ExactSTORM;
-import moa.clusterers.outliers.MCOD.MCOD;
-import moa.clusterers.outliers.SimpleCOD.SimpleCOD;
-import moa.streams.clustering.RandomRBFGeneratorEvents;
-
-public class TestSpeed {    
-    public static void main(String[] args) throws Exception 
-    {        
-        int numInstances = 2000;        
-        RandomRBFGeneratorEvents stream = new RandomRBFGeneratorEvents();
-        stream.prepareForUse();
-        
-        SimpleCOD scod = new SimpleCOD();   
-        MCOD mcod = new MCOD();        
-        ExactSTORM angiulli = new ExactSTORM();   
-        //DistanceOutliersAppr angiulli = new DistanceOutliersAppr(); 
-        AbstractC abstractC = new AbstractC();        
-        
-        angiulli.queryFreqOption.setValue(1);
-        
-        scod.setModelContext(stream.getHeader());
-        scod.prepareForUse(); 
-        
-        mcod.setModelContext(stream.getHeader());
-        mcod.prepareForUse(); 
-        
-        angiulli.setModelContext(stream.getHeader());
-        angiulli.prepareForUse(); 
-        
-        abstractC.setModelContext(stream.getHeader());
-        abstractC.prepareForUse();
-        
-        Long tmStart = System.currentTimeMillis();
-        
-        int numberSamples = 0;     
-        while (stream.hasMoreInstances() && (numberSamples < numInstances)) {               
-            Instance newInst = stream.nextInstance().getData();
-            
-            //scod.processNewInstanceImpl(newInst);  
-            mcod.processNewInstanceImpl(newInst);  
-            //angiulli.processNewInstanceImpl(newInst);  
-            //abstractC.processNewInstanceImpl(newInst); 
-            
-            numberSamples++;
-        }      
-        
-        System.out.println("Total time = " + (System.currentTimeMillis() - tmStart) + " ms");
-    }
-}
diff --git a/moa/src/main/java/moa/clusterers/streamkm/BucketManager.java b/moa/src/main/java/moa/clusterers/streamkm/BucketManager.java
deleted file mode 100644
index 3f96d2fd7..000000000
--- a/moa/src/main/java/moa/clusterers/streamkm/BucketManager.java
+++ /dev/null
@@ -1,159 +0,0 @@
-package moa.clusterers.streamkm;
-
-
-/**
- *
- * @author Marcel R. Ackermann, Christiane Lammersen, Marcus Maertens, Christoph Raupach, 
-Christian Sohler, Kamil Swierkot
-
-Modified by Richard Hugh Moulton (24 Jul 2017)
- */
-public class BucketManager  {
-
-	protected class Bucket {
-		int cursize;
-		Point[] points;
-		Point[] spillover;
-		
-		public Bucket(int d, int maxsize){
-			this.cursize = 0;
-			this.points = new Point[maxsize];
-			this.spillover = new Point[maxsize];
-			for(int i=0; i<maxsize; i++){
-				this.points[i] = new Point(d);
-				this.spillover[i] = new Point(d);
-			}
-		}
-		
-	};
-
-	protected int numberOfBuckets;
-	protected int maxBucketsize;
-	protected Bucket[] buckets;
-	protected MTRandom clustererRandom;
-	protected TreeCoreset treeCoreset;
-	
-	
-	/**
-	initializes a bucketmanager for n points with bucketsize maxsize and dimension d
-	**/
-	public BucketManager(int n,int d,int maxsize, MTRandom random){
-		this.clustererRandom = random;
-		this.numberOfBuckets = (int) Math.ceil(Math.log((double)n/(double)maxsize) / Math.log(2) )+2;
-		this.maxBucketsize = maxsize;
-		this.buckets = new Bucket[this.numberOfBuckets];
-		for(int i=0; i<this.numberOfBuckets; i++){
-			this.buckets[i] = new Bucket(d,maxsize);
-		}
-		this.treeCoreset = new TreeCoreset();
-		//printf("Created manager with %d buckets of dimension %d \n",this.numberOfBuckets,d);
-	}
-
-	/**
-	inserts a single point into the bucketmanager
-	**/
-	void insertPoint(Point p){
-		
-		//check if there is enough space in the first bucket
-		int cursize = this.buckets[0].cursize;	
-		if(cursize >= this.maxBucketsize) {
-			//printf("Bucket 0 full \n");
-			//start spillover process
-			int curbucket  = 0;
-			int nextbucket = 1;
-
-			//check if the next bucket is empty
-			if(this.buckets[nextbucket].cursize == 0){
-				//copy the bucket	
-				int i;
-				for(i=0; i<this.maxBucketsize; i++){
-					this.buckets[nextbucket].points[i] = this.buckets[curbucket].points[i].clone();
-					//copyPointWithoutInit: we should not copy coordinates? 
-				}
-				//bucket is now full
-				this.buckets[nextbucket].cursize = this.maxBucketsize;
-				//first bucket is now empty
-				this.buckets[curbucket].cursize = 0;
-				cursize = 0;
-			} else {
-				//printf("Bucket %d full \n",nextbucket);
-				//copy bucket to spillover and continue
-				int i;
-				for(i=0;i<this.maxBucketsize;i++){
-					this.buckets[nextbucket].spillover[i] = this.buckets[curbucket].points[i].clone();
-					//copyPointWithoutInit: we should not copy coordinates? 
-				}
-				this.buckets[0].cursize=0;
-				cursize = 0;
-				curbucket++;
-				nextbucket++;
-				/*
-				as long as the next bucket is full output the coreset to the spillover of the next bucket
-				*/
-				while(this.buckets[nextbucket].cursize == this.maxBucketsize){
-					//printf("Bucket %d full \n",nextbucket);
-					this.treeCoreset.unionTreeCoreset(this.maxBucketsize,this.maxBucketsize,
-						this.maxBucketsize,p.dimension, 
-						this.buckets[curbucket].points,this.buckets[curbucket].spillover,
-						this.buckets[nextbucket].spillover, this.clustererRandom);
-					//bucket now empty
-					this.buckets[curbucket].cursize = 0;
-					curbucket++;
-					nextbucket++;
-				}
-				this.treeCoreset.unionTreeCoreset(this.maxBucketsize,this.maxBucketsize,
-						this.maxBucketsize,p.dimension, 
-						this.buckets[curbucket].points,this.buckets[curbucket].spillover,
-						this.buckets[nextbucket].points, this.clustererRandom);
-				this.buckets[curbucket].cursize = 0;
-				this.buckets[nextbucket].cursize = this.maxBucketsize;
-			}
-		}
-		//insert point into the first bucket
-		this.buckets[0].points[cursize] = p.clone();
-		//copyPointWithoutInit: we should not copy coordinates? 
-		this.buckets[0].cursize++;
-	}
-
-	/**
-	It may happen that the manager is not full (since n is not always a power of 2). In this case we extract the coreset
-	from the manager by computing a coreset of all nonempty buckets
-
-	Case 1: the last bucket is full
-	=> n is a power of 2 and we return the contents of the last bucket
-
-	Case2: the last bucket is not full
-	=> we compute a coreset of all nonempty buckets 
-
-	this operation should only be called after the streaming process is finished
-	**/
-	Point[] getCoresetFromManager(int d){
-		Point[] coreset = new Point[d];
-		int i = 0;
-		//if(this.buckets[this.numberOfBuckets-1].cursize == this.maxBucketsize){
-			//coreset = this.buckets[this.numberOfBuckets-1].points;
-
-		//} else {
-			//find the first nonempty bucket
-			for(i=0; i < this.numberOfBuckets; i++){
-				if(this.buckets[i].cursize != 0){
-					coreset = this.buckets[i].points;
-					break;
-				}
-			}		
-			//as long as there is a nonempty bucket compute a coreset
-			int j;
-			for(j=i+1; j < this.numberOfBuckets; j++){
-				if(this.buckets[j].cursize != 0){
-					//output the coreset into the spillover of bucket j
-					this.treeCoreset.unionTreeCoreset(this.maxBucketsize,this.maxBucketsize,
-						this.maxBucketsize,d, 
-						this.buckets[j].points,coreset,
-						this.buckets[j].spillover, this.clustererRandom); 
-					coreset = this.buckets[j].spillover;			
-				}
-			}
-		//}
-		return coreset;
-	}
-}
diff --git a/moa/src/main/java/moa/clusterers/streamkm/MTRandom.java b/moa/src/main/java/moa/clusterers/streamkm/MTRandom.java
deleted file mode 100644
index 004bbab8c..000000000
--- a/moa/src/main/java/moa/clusterers/streamkm/MTRandom.java
+++ /dev/null
@@ -1,390 +0,0 @@
-/*
- * MTRandom : A Java implementation of the MT19937 (Mersenne Twister)
- *            pseudo random number generator algorithm based upon the
- *            original C code by Makoto Matsumoto and Takuji Nishimura.
- * Author   : David Beaumont
- * Email    : mersenne-at-www.goui.net
- * 
- * For the original C code, see:
- *     http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
- *
- * This version, Copyright (C) 2005, David Beaumont.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- */
-
-package moa.clusterers.streamkm;
-
-import java.util.Random;
-
-/**
- * @version 1.0
- * @author David Beaumont, Copyright 2005
- * <p>
- * A Java implementation of the MT19937 (Mersenne Twister) pseudo
- * random number generator algorithm based upon the original C code
- * by Makoto Matsumoto and Takuji Nishimura (see
- * <a href="http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html">
- * http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html</a> for
- * more information.
- * <p>
- * As a subclass of java.util.Random this class provides a single
- * canonical method next() for generating bits in the pseudo random
- * number sequence.  Anyone using this class should invoke the public
- * inherited methods (nextInt(), nextFloat etc.) to obtain values as
- * normal.  This class should provide a drop-in replacement for the
- * standard implementation of java.util.Random with the additional
- * advantage of having a far longer period and the ability to use a
- * far larger seed value.
- * <p>
- * This is <b>not</b> a cryptographically strong source of randomness
- * and should <b>not</b> be used for cryptographic systems or in any
- * other situation where true random numbers are required.
- * <p>
- * <!-- Creative Commons License -->
- * <a href="http://creativecommons.org/licenses/LGPL/2.1/"><img alt="CC-GNU LGPL" border="0" src="http://creativecommons.org/images/public/cc-LGPL-a.png" /></a><br />
- * This software is licensed under the <a href="http://creativecommons.org/licenses/LGPL/2.1/">CC-GNU LGPL</a>.
- * <!-- /Creative Commons License -->
- * 
- * <!--
- * <rdf:RDF xmlns="http://web.resource.org/cc/"
- *     xmlns:dc="http://purl.org/dc/elements/1.1/"
- *     xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
- *     
- * <Work rdf:about="">
- *    <license rdf:resource="http://creativecommons.org/licenses/LGPL/2.1/" />
- *    <dc:type rdf:resource="http://purl.org/dc/dcmitype/Software" />
- * </Work>
- * 
- * <License rdf:about="http://creativecommons.org/licenses/LGPL/2.1/">
- *    <permits rdf:resource="http://web.resource.org/cc/Reproduction" />
- *    <permits rdf:resource="http://web.resource.org/cc/Distribution" />
- *    <requires rdf:resource="http://web.resource.org/cc/Notice" />
- *    <permits rdf:resource="http://web.resource.org/cc/DerivativeWorks" />
- *    <requires rdf:resource="http://web.resource.org/cc/ShareAlike" />
- *    <requires rdf:resource="http://web.resource.org/cc/SourceCode" />
- * </License>
- * 
- * </rdf:RDF>
- * -->
- * 
- */
-public class MTRandom extends Random {
-
-	/**
-	 * Auto-generated serial version UID.  Note that MTRandom does NOT
-	 * support serialisation of its internal state and it may even be
-	 * necessary to implement read/write methods to re-seed it properly.
-	 * This is only here to make Eclipse shut up about it being missing.
-	 */
-	private static final long serialVersionUID = -515082678588212038L;
-
-	// Constants used in the original C implementation
-	private final static int UPPER_MASK = 0x80000000;
-	private final static int LOWER_MASK = 0x7fffffff;
-
-	private final static int N = 624;
-	private final static int M = 397;
-	private final static int MAGIC[] = { 0x0, 0x9908b0df };
-	private final static int MAGIC_FACTOR1 = 1812433253;
-	private final static int MAGIC_FACTOR2 = 1664525;
-	private final static int MAGIC_FACTOR3 = 1566083941;
-	private final static int MAGIC_MASK1   = 0x9d2c5680;
-	private final static int MAGIC_MASK2   = 0xefc60000;
-	private final static int MAGIC_SEED    = 19650218;
-	private final static long DEFAULT_SEED = 5489L;
-
-	// Internal state
-	private transient int[] mt;
-	private transient int mti;
-	private transient boolean compat = false;
-
-	// Temporary buffer used during setSeed(long)
-	private transient int[] ibuf;
-
-	/**
-	 * The default constructor for an instance of MTRandom.  This invokes
-	 * the no-argument constructor for java.util.Random which will result
-	 * in the class being initialised with a seed value obtained by calling
-	 * System.currentTimeMillis().
-	 */	
-	public MTRandom() { }
-
-	/**
-	 * This version of the constructor can be used to implement identical
-	 * behaviour to the original C code version of this algorithm including
-	 * exactly replicating the case where the seed value had not been set
-	 * prior to calling genrand_int32.
-	 * <p>
-	 * If the compatibility flag is set to true, then the algorithm will be
-	 * seeded with the same default value as was used in the original C
-	 * code.  Furthermore the setSeed() method, which must take a 64 bit
-	 * long value, will be limited to using only the lower 32 bits of the
-	 * seed to facilitate seamless migration of existing C code into Java
-	 * where identical behaviour is required.
-	 * <p>
-	 * Whilst useful for ensuring backwards compatibility, it is advised
-	 * that this feature not be used unless specifically required, due to
-	 * the reduction in strength of the seed value.
-	 * 
-	 * @param compatible Compatibility flag for replicating original
-	 * behaviour.
-	 */
-	public MTRandom(boolean compatible) {
-		super(0L);
-		compat = compatible;
-		setSeed(compat?DEFAULT_SEED:System.currentTimeMillis());
-	}
-
-	/**
-	 * This version of the constructor simply initialises the class with
-	 * the given 64 bit seed value.  For a better random number sequence
-	 * this seed value should contain as much entropy as possible.
-	 * 
-	 * @param seed The seed value with which to initialise this class.
-	 */
-	public MTRandom(long seed) {
-		super(seed);
-	}
-
-	/**
-	 * This version of the constructor initialises the class with the
-	 * given byte array.  All the data will be used to initialise this
-	 * instance.
-	 * 
-	 * @param buf The non-empty byte array of seed information.
-	 * @throws NullPointerException if the buffer is null.
-	 * @throws IllegalArgumentException if the buffer has zero length.
-	 */
-	public MTRandom(byte[] buf) {
-		super(0L);
-		setSeed(buf);
-	}
-
-	/**
-	 * This version of the constructor initialises the class with the
-	 * given integer array.  All the data will be used to initialise
-	 * this instance.
-	 * 
-	 * @param buf The non-empty integer array of seed information.
-	 * @throws NullPointerException if the buffer is null.
-	 * @throws IllegalArgumentException if the buffer has zero length.
-	 */
-	public MTRandom(int[] buf) {
-		super(0L);
-		setSeed(buf);
-	}
-
-	// Initializes mt[N] with a simple integer seed. This method is
-	// required as part of the Mersenne Twister algorithm but need
-	// not be made public.
-	private final void setSeed(int seed) {
-
-		// Annoying runtime check for initialisation of internal data
-		// caused by java.util.Random invoking setSeed() during init.
-		// This is unavoidable because no fields in our instance will
-		// have been initialised at this point, not even if the code
-		// were placed at the declaration of the member variable.
-		if (mt == null) mt = new int[N];
-
-		// ---- Begin Mersenne Twister Algorithm ----
-		mt[0] = seed;
-		for (mti = 1; mti < N; mti++) {
-			mt[mti] = (MAGIC_FACTOR1 * (mt[mti-1] ^ (mt[mti-1] >>> 30)) + mti);
-		}
-		// ---- End Mersenne Twister Algorithm ----
-	}
-
-	/**
-	 * This method resets the state of this instance using the 64
-	 * bits of seed data provided.  Note that if the same seed data
-	 * is passed to two different instances of MTRandom (both of
-	 * which share the same compatibility state) then the sequence
-	 * of numbers generated by both instances will be identical.
-	 * <p>
-	 * If this instance was initialised in 'compatibility' mode then
-	 * this method will only use the lower 32 bits of any seed value
-	 * passed in and will match the behaviour of the original C code
-	 * exactly with respect to state initialisation.
-	 * 
-	 * @param seed The 64 bit value used to initialise the random
-	 * number generator state. 
-	 */
-	public final synchronized void setSeed(long seed) {
-		if (compat) {
-			setSeed((int)seed);
-		} else {
-
-			// Annoying runtime check for initialisation of internal data
-			// caused by java.util.Random invoking setSeed() during init.
-			// This is unavoidable because no fields in our instance will
-			// have been initialised at this point, not even if the code
-			// were placed at the declaration of the member variable.
-			if (ibuf == null) ibuf = new int[2];
-
-			ibuf[0] = (int)seed;
-			ibuf[1] = (int)(seed >>> 32);
-			setSeed(ibuf);
-		}
-	}
-
-	/**
-	 * This method resets the state of this instance using the byte
-	 * array of seed data provided.  Note that calling this method
-	 * is equivalent to calling "setSeed(pack(buf))" and in particular
-	 * will result in a new integer array being generated during the
-	 * call.  If you wish to retain this seed data to allow the pseudo
-	 * random sequence to be restarted then it would be more efficient
-	 * to use the "pack()" method to convert it into an integer array
-	 * first and then use that to re-seed the instance.  The behaviour
-	 * of the class will be the same in both cases but it will be more
-	 * efficient.
-	 *
-	 * @param buf The non-empty byte array of seed information.
-	 * @throws NullPointerException if the buffer is null.
-	 * @throws IllegalArgumentException if the buffer has zero length.
-	 */
-	public final void setSeed(byte[] buf) {
-		setSeed(pack(buf));
-	}
-
-	/**
-	 * This method resets the state of this instance using the integer
-	 * array of seed data provided.  This is the canonical way of
-	 * resetting the pseudo random number sequence.
-	 * 
-	 * @param buf The non-empty integer array of seed information.
-	 * @throws NullPointerException if the buffer is null.
-	 * @throws IllegalArgumentException if the buffer has zero length.
-	 */
-	public final synchronized void setSeed(int[] buf) {
-		int length = buf.length;
-		if (length == 0) throw new IllegalArgumentException("Seed buffer may not be empty");
-		// ---- Begin Mersenne Twister Algorithm ----
-		int i = 1, j = 0, k = (N > length ? N : length);
-		setSeed(MAGIC_SEED);
-		for (; k > 0; k--) {
-			mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >>> 30)) * MAGIC_FACTOR2)) + buf[j] + j;
-			i++; j++;
-			if (i >= N) { mt[0] = mt[N-1]; i = 1; }
-			if (j >= length) j = 0;
-		}
-		for (k = N-1; k > 0; k--) {
-			mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >>> 30)) * MAGIC_FACTOR3)) - i;
-			i++;
-			if (i >= N) { mt[0] = mt[N-1]; i = 1; }
-		}
-		mt[0] = UPPER_MASK; // MSB is 1; assuring non-zero initial array
-		// ---- End Mersenne Twister Algorithm ----
-	}
-
-	/**
-	 * This method forms the basis for generating a pseudo random number
-	 * sequence from this class.  If given a value of 32, this method
-	 * behaves identically to the genrand_int32 function in the original
-	 * C code and ensures that using the standard nextInt() function
-	 * (inherited from Random) we are able to replicate behaviour exactly.
-	 * <p>
-	 * Note that where the number of bits requested is not equal to 32
-	 * then bits will simply be masked out from the top of the returned
-	 * integer value.  That is to say that:
-	 * <pre>
-	 * mt.setSeed(12345);
-	 * int foo = mt.nextInt(16) + (mt.nextInt(16) << 16);</pre>
-	 * will not give the same result as
-	 * <pre>
-	 * mt.setSeed(12345);
-	 * int foo = mt.nextInt(32);</pre>
-	 * 
-	 * @param bits The number of significant bits desired in the output.
-	 * @return The next value in the pseudo random sequence with the
-	 * specified number of bits in the lower part of the integer.
-	 */
-	protected final synchronized int next(int bits) {
-		// ---- Begin Mersenne Twister Algorithm ----
-		int y, kk;
-		if (mti >= N) {             // generate N words at one time
-
-			// In the original C implementation, mti is checked here
-			// to determine if initialisation has occurred; if not
-			// it initialises this instance with DEFAULT_SEED (5489).
-			// This is no longer necessary as initialisation of the
-			// Java instance must result in initialisation occurring
-			// Use the constructor MTRandom(true) to enable backwards
-			// compatible behaviour.
-			
-			for (kk = 0; kk < N-M; kk++) {
-				y = (mt[kk] & UPPER_MASK) | (mt[kk+1] & LOWER_MASK);
-				mt[kk] = mt[kk+M] ^ (y >>> 1) ^ MAGIC[y & 0x1];
-			}
-			for (;kk < N-1; kk++) {
-				y = (mt[kk] & UPPER_MASK) | (mt[kk+1] & LOWER_MASK);
-				mt[kk] = mt[kk+(M-N)] ^ (y >>> 1) ^ MAGIC[y & 0x1];
-			}
-			y = (mt[N-1] & UPPER_MASK) | (mt[0] & LOWER_MASK);
-			mt[N-1] = mt[M-1] ^ (y >>> 1) ^ MAGIC[y & 0x1];
-
-			mti = 0;
-		}
-  
-		y = mt[mti++];
-
-		// Tempering
-		y ^= (y >>> 11);
-		y ^= (y << 7) & MAGIC_MASK1;
-		y ^= (y << 15) & MAGIC_MASK2;
-		y ^= (y >>> 18);
-		// ---- End Mersenne Twister Algorithm ----
-		return (y >>> (32-bits));
-	}
-
-	// This is a fairly obscure little code section to pack a
-	// byte[] into an int[] in little endian ordering.  
-
-	/**
-	 * This simply utility method can be used in cases where a byte
-	 * array of seed data is to be used to repeatedly re-seed the
-	 * random number sequence.  By packing the byte array into an
-	 * integer array first, using this method, and then invoking
-	 * setSeed() with that; it removes the need to re-pack the byte
-	 * array each time setSeed() is called.
-	 * <p>
-	 * If the length of the byte array is not a multiple of 4 then
-	 * it is implicitly padded with zeros as necessary.  For example:
-	 * <pre>    byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 }</pre>
-	 * becomes
-	 * <pre>    int[]  { 0x04030201, 0x00000605 }</pre>
-	 * <p>
-	 * Note that this method will not complain if the given byte array
-	 * is empty and will produce an empty integer array, but the
-	 * setSeed() method will throw an exception if the empty integer
-	 * array is passed to it.
-	 * 
-	 * @param buf The non-null byte array to be packed.
-	 * @return A non-null integer array of the packed bytes.
-	 * @throws NullPointerException if the given byte array is null.
-	 */
-	public static int[] pack(byte[] buf) {
-		int k, blen = buf.length, ilen = ((buf.length+3) >>> 2);
-		int[] ibuf = new int[ilen];
-		for (int n = 0; n < ilen; n++) {
-			int m = (n+1) << 2;
-			if (m > blen) m = blen;
-			for (k = buf[--m]&0xff; (m & 0x3) != 0; k = (k << 8) | buf[--m]&0xff);
-			ibuf[n] = k;
-		}
-		return ibuf;
-	}
-}
diff --git a/moa/src/main/java/moa/clusterers/streamkm/StreamKM.java b/moa/src/main/java/moa/clusterers/streamkm/StreamKM.java
deleted file mode 100644
index 45e3d35e8..000000000
--- a/moa/src/main/java/moa/clusterers/streamkm/StreamKM.java
+++ /dev/null
@@ -1,386 +0,0 @@
-package moa.clusterers.streamkm;
-
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.cluster.Clustering;
-import moa.clusterers.AbstractClusterer;
-import moa.core.Measurement;
-
-/**
- *
- * @author Marcel R. Ackermann, Christiane Lammersen, Marcus Maertens, Christoph Raupach, 
-Christian Sohler, Kamil Swierkot
-
-Modified by Richard Hugh Moulton (24 Jul 2017)
-
-Citation: Marcel R. Ackermann, Christiane Lammersen, Marcus Märtens,
-Christoph Raupach, Christian Sohler, Kamil Swierkot: StreamKM++: A
-Clustering Algorithms for Data Streams. ALENEX 2010: 173-187
- */
-
-public class StreamKM extends AbstractClusterer {
-
-    public IntOption sizeCoresetOption = new IntOption("sizeCoreset",
-			's', "Size of the coreset (m).", 10000);
-
-    public IntOption numClustersOption = new IntOption(
-			"numClusters", 'k',
-			"Number of clusters to compute.", 5);
-			
-	public IntOption lengthOption = new IntOption("length",
-			'l', "Length of the data stream (n).", 100000, 0, Integer.MAX_VALUE);
-
-	public FlagOption evaluateOption = new FlagOption("evaluateFinalOnly",
-			'e', "If true, only the final clustering is evaluated.");
-			
-	public IntOption randomSeedOption = new IntOption("randomSeed", 'r',
-					"Seed for random behaviour of the classifier.", 1);	
-							
-	protected MTRandom clustererRandom;
-	protected Point[] centresStreamingCoreset;
-			
-	protected int numberInstances;
-	
-	protected int dimension;	
-	protected int length;
-	protected int numberOfCentres;
-	protected int coresetsize;	
-	
-	protected BucketManager manager;
-	
-	protected boolean initialized = false;	
-	
-	private final static double THRESHOLD = 1.000;
-
-    @Override
-    public void resetLearningImpl() {
-		this.initialized = false;
-		this.coresetsize = sizeCoresetOption.getValue();
-		this.numberOfCentres = numClustersOption.getValue();
-		this.length = lengthOption.getValue();
-		this.centresStreamingCoreset = new Point[this.numberOfCentres];
-
-		//initalize random generator with seed
-		this.clustererRandom = new MTRandom(this.randomSeedOption.getValue());
-	}
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-		
-		if (this.initialized == false) {
-			this.dimension =  inst.numAttributes();
-			manager = new BucketManager(this.length, this.dimension, this.coresetsize, this.clustererRandom);
-			this.initialized = true;
-		}
-		
-		manager.insertPoint(new Point(inst, this.numberInstances));     
-        
-        this.numberInstances++;
-		if (this.numberInstances % lengthOption.getValue() == 0) {
-			
-			Point[] streamingCoreset = manager.getCoresetFromManager(dimension);
-			
-			//compute 5 clusterings of the coreset with kMeans++ and take the best
-			CoresetCostTriple triple;
-			double minCost = 0.0;
-			double curCost = 0.0;
-			
-			triple = lloydPlusPlus(numberOfCentres, coresetsize, dimension, streamingCoreset);
-			minCost = triple.getCoresetCost();
-			for (int j = 0 ; j < this.numberOfCentres ; j++)
-			{
-				centresStreamingCoreset[j] = triple.getCoresetCentres()[j].clone();
-			}
-			curCost = minCost;
-
-			for(int i = 1; i < 5; i++){
-				triple = lloydPlusPlus(numberOfCentres, coresetsize, dimension, streamingCoreset);
-				curCost = triple.getCoresetCost();
-
-				if(curCost < minCost) {
-					minCost = curCost;
-					for (int j = 0 ; j < this.numberOfCentres ; j++)
-					{
-						centresStreamingCoreset[j] = triple.getCoresetCentres()[j].clone();
-					}
-				}
-		    }
-		}
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        throw new UnsupportedOperationException("Not supported yet.");
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        throw new UnsupportedOperationException("Not supported yet.");
-    }
-
-    public boolean isRandomizable() {
-        return true;
-    }
-
-    public Prediction getPredictionForInstance(Instance inst) {
-        throw new UnsupportedOperationException("Not supported yet.");
-    }
-
-
-    @Override
-    public Clustering getClusteringResult() {
-		if ( !this.initialized ) {
-			return new Clustering();
-		}
-		
-		Clustering clustering = new Clustering();
-
-		if (!evaluateOption.isSet())
-		{
-			Point[] streamingCoreset = manager.getCoresetFromManager(dimension);
-
-			//compute 5 clusterings of the coreset with kMeans++ and take the best
-			CoresetCostTriple triple;
-			double minCost = 0.0;
-			double curCost = 0.0;
-
-			triple = lloydPlusPlus(numberOfCentres, coresetsize, dimension, streamingCoreset);
-			minCost = triple.getCoresetCost();
-			for (int j = 0 ; j < this.numberOfCentres ; j++)
-			{
-				centresStreamingCoreset[j] = triple.getCoresetCentres()[j].clone();
-			}
-			curCost = minCost;
-
-			for(int i = 1; i < 5; i++){
-				triple = lloydPlusPlus(numberOfCentres, coresetsize, dimension, streamingCoreset);
-				curCost = triple.getCoresetCost();
-
-				if(curCost < minCost) {
-					minCost = curCost;
-					for (int j = 0 ; j < this.numberOfCentres ; j++)
-					{
-						centresStreamingCoreset[j] = triple.getCoresetCentres()[j].clone();
-					}
-				}
-			}
-
-		for ( int i = 0; i < centresStreamingCoreset.length; i++ ) {
-			if(centresStreamingCoreset[i] != null){
-					clustering.add(centresStreamingCoreset[i].toCluster(triple.getRadii()[i]));
-				}
-			}
-		}
-		
-		return clustering;
-    }
-
-    
-	public CoresetCostTriple lloydPlusPlus(int k, int n, int d, Point points[]){
-		//printf("starting kMeans++\n");
-		CoresetCostTriple triple;
-		double[] radii = new double[k];
-		//choose random centres
-		//choose random centres
-		Point[] centres = chooseRandomCentres(k, n, d, points);
-		double cost = targetFunctionValue(k, n, centres, points);
-		double newCost = cost;
-		
-
-		Point[] massCentres = new Point[k];
-		double[] numberOfPoints = new double[k];
-
-		do{
-			cost = newCost;
-			//reset centres of mass
-			int i = 0;
-			for(i = 0; i < k; i++){	
-				massCentres[i] = new Point(d);
-				numberOfPoints[i] = 0.0;
-			}
-			//compute centres of mass
-			for(i = 0; i < n; i++){
-				int centre = points[i].determineClusterCentreKMeans(k,centres);
-				for(int l = 0; l < massCentres[centre].dimension; l++){
-					if(points[i].weight != 0.0)
-						massCentres[centre].coordinates[l] += points[i].coordinates[l];
-				}
-				numberOfPoints[centre] += points[i].weight;
-			
-			}
-			
-			//move centres
-			for(i=0; i<k; i++){
-				for(int l=0; l<centres[i].dimension; l++){
-					centres[i].coordinates[l] = massCentres[i].coordinates[l];
-				}
-					centres[i].weight = numberOfPoints[i];
-				}
-			
-			//calculate costs
-			newCost = targetFunctionValue(k, n, centres, points);
-			//printf("old cost:%f, new cost:%f \n",cost,newCost);
-		} while (newCost < THRESHOLD * cost);
-
-		//compute radii
-		for (int i = 0 ; i < n ; i++)
-		{
-			int centre = points[i].determineClusterCentreKMeans(k,centres);
-			double radius = 0.0;
-			double distance;
-
-			for(int j = 0 ; j < points[i].dimension ; j++)
-			{
-				distance = Math.abs((centres[centre].coordinates[j]/centres[centre].weight) - (points[i].coordinates[j]/points[i].weight));
-				radius += Math.pow(distance, 2.0);
-			}
-
-			radii[centre] += radius*points[i].weight;	
-		}
-		for (int i = 0 ; i < k ; i++)
-		{
-			radii[i] = 2.0 * Math.sqrt(radii[i]/centres[i].weight);
-		}
-
-
-		/*printf("Centres: \n");
-		int i=0;
-		for(i=0;i<k;i++){
-			printf("(");
-			int l = 0;
-			for(l=0;l<centres[i].dimension;l++){
-				printf("%f,",centres[i].coordinates[l] / centres[i].weight);
-			}
-			printf(")\n");
-		}
-		printf("kMeans++ finished\n");
-		*/ 
-		triple = new CoresetCostTriple(centres, radii, newCost);
-
-		return triple; 
-	}
-	
-	private Point[] chooseRandomCentres(int k, int n, int d, Point points[]){
-
-		//array to store the choosen centres
-		Point[] centres = new Point[k]; 
-
-		//choose the first centre (each point has the same probability of being choosen)
-		int i = 0;
-		
-		int next = 0;
-		int j = 0;
-		do{ //only choose from the n-i points not already choosen
-			next = this.clustererRandom.nextInt(n-1); 
-			
-			//check if the choosen point is not a dummy
-		} while( points[next].weight < 1);
-		
-		//set j to next unchoosen point
-		j = next;
-		//copy the choosen point to the array
-		centres[i] = points[j].clone();
-			
-		//set the current centre for all points to the choosen centre
-		for(i = 0; i < n; i++){
-			points[i].centreIndex = 0;
-			points[i].curCost = points[i].costOfPointToCenter(centres[0]);
-		
-		}
-		//choose centre 1 to k-1 with the kMeans++ distribution
-		for(i = 1; i < k; i++){
-
-			double cost = 0.0;
-			for(j = 0; j < n; j++){
-				cost += points[j].curCost;
-			}
-			
-			double random = 0;
-			double sum = 0.0;
-			int pos = -1;
-			
-			do{
-					random = this.clustererRandom.nextDouble();//genrand_real3();
-					sum = 0.0;
-					pos = -1;
-
-				for(j = 0; j < n; j++){
-					sum = sum + points[j].curCost;
-					if(random <= sum/cost){
-						pos = j;
-						break;
-					}	
-				}	
-			} while (points[pos].weight < 1);
-				
-			//copy the choosen centre
-			centres[i] = points[pos].clone();
-			//check which points are closest to the new centre
-			for(j = 0; j < n; j++){
-				double newCost = points[j].costOfPointToCenter(centres[i]);
-				if(points[j].curCost > newCost){
-					points[j].curCost = newCost;
-					points[j].centreIndex = i;
-				}
-			}
-			
-		}
-		
-		/*printf("random centres: \n");
-		for(i = 0; i < k; i++){
-			//printf("%d: (",i);
-			int l = 0;
-			for(l = 0; l < centres[i].dimension; l++){
-				printf("%f,",centres[i].coordinates[l] / centres[i].weight);
-			}
-			printf(")\n");
-		}*/
-
-		return centres;
-	}
-
-	/**
-	computes the target function for the given pointarray points[] (of size n) with the given array of
-	centres centres[] (of size k)
-	**/
-	public double targetFunctionValue(int k, int n, Point[] centres, Point[] points){
-		int i=0;
-		double sum = 0.0;
-		for(i=0;i<n;i++){
-			double nearestCost = -1.0;
-			int j=0;
-			for(j=0;j<k;j++){
-				double distance = 0.0;
-				int l = 0;
-				for(l=0;l<points[i].dimension;l++){
-					//Centroid coordinate of the point
-					double centroidCoordinatePoint;
-					if(points[i].weight != 0.0){
-						centroidCoordinatePoint = points[i].coordinates[l] / points[i].weight;
-					} else {
-						centroidCoordinatePoint = points[i].coordinates[l];
-					}
-					//Centroid coordinate of the centre
-					double centroidCoordinateCentre;
-					if(centres[j].weight != 0.0){
-						centroidCoordinateCentre = centres[j].coordinates[l] / centres[j].weight;
-					} else {
-						centroidCoordinateCentre = centres[j].coordinates[l];
-					}
-					distance += (centroidCoordinatePoint-centroidCoordinateCentre) * 
-							(centroidCoordinatePoint-centroidCoordinateCentre) ;
-					
-				}
-				if(nearestCost <0 || distance < nearestCost) {
-					nearestCost = distance;
-				} 
-			}
-			sum += nearestCost * points[i].weight;
-		}
-		return sum;
-	}
-
-}
diff --git a/moa/src/main/java/moa/clusterers/streamkm/TreeCoreset.java b/moa/src/main/java/moa/clusterers/streamkm/TreeCoreset.java
deleted file mode 100644
index 74b325d30..000000000
--- a/moa/src/main/java/moa/clusterers/streamkm/TreeCoreset.java
+++ /dev/null
@@ -1,614 +0,0 @@
-package moa.clusterers.streamkm;
-
-/**
- *
- * @author Marcel R. Ackermann, Christiane Lammersen, Marcus Maertens, Christoph Raupach, 
-Christian Sohler, Kamil Swierkot
- */
-public class TreeCoreset {
-
-	/**
-	datastructure representing a node within a tree
-	**/
-	protected class treeNode {
-		//number of points in this node
-		int n;
-		
-		//array with pointers on points
-		Point[] points;
-
-		//pointer on the centre of the treenode
-		Point centre;
-
-		//pointer on the left childnode
-		treeNode lc;
-		
-		//pointer on the right childnode
-		treeNode rc;
-
-		//pointer on the parent node
-		treeNode parent;
-
-		//cost of the treenode
-		double cost;
-		
-		void free(){
-			this.parent 	= null;
-			this.lc     	= null;
-			this.rc     	= null;
-			this.points		= null; 
-			this.centre     = null;  
-		}
-		
-		public treeNode(int n, Point[] points, Point centre, treeNode parent) {
-			this.n = n;
-			this.points = points; 
-			this.centre = centre; 
-			this.lc = null;
-			this.rc = null;
-			this.parent = parent;
-			this.cost = treeNodeTargetFunctionValue();;
-		}
-		
-		/**
-		initalizes root as a treenode with the union of setA and setB as pointset and centre as centre
-		**/
-	    public treeNode(Point[] setA, Point[] setB, int n_1, int n_2, Point centre, int centreIndex){
-			//loop counter variable
-			int i;	
-
-			//the root has no parent and no child nodes in the beginning
-			this.parent 	= null;
-			this.lc     	= null;
-			this.rc     	= null; 
-
-			//array with points to the points
-			this.points = new Point[n_1+n_2];
-			this.n = n_1 + n_2;
-			
-			for(i=0;i<this.n;i++){
-				if(i < n_1){
-					this.points[i] = setA[i];
-					this.points[i].centreIndex = centreIndex;
-				} else {
-					this.points[i] = setB[i-n_1];
-					this.points[i].centreIndex = centreIndex;
-				}
-			}
-
-			//set the centre
-			this.centre = centre;
-
-			//calculate costs
-			this.cost = treeNodeTargetFunctionValue();
-		}
-		
-		/**
-		Computes the target function value of the n points of the treenode. Differs from the function "targetFunctionValue" in three things:
-
-		1. only the centre of the treenode is used as a centre
-
-		2. works on arrays of pointers instead on arrays of points 
-
-		3. stores the cost in the treenode
-		**/
-		double treeNodeTargetFunctionValue(){
-			//loop counter variable
-			int i;
-			
-			//stores the cost
-			double sum = 0.0;
-
-			for(i=0; i<this.n; i++){
-				//stores the distance
-				double distance = 0.0;
-
-				//loop counter variable
-				int l;
-
-				for(l=0;l<this.points[i].dimension;l++){
-					//centroid coordinate of the point
-					double centroidCoordinatePoint;
-					if(this.points[i].weight != 0.0){
-						centroidCoordinatePoint = this.points[i].coordinates[l] / this.points[i].weight;
-					} else {
-						centroidCoordinatePoint = this.points[i].coordinates[l];
-					}
-					//centroid coordinate of the centre
-					double centroidCoordinateCentre;
-					if(this.centre.weight != 0.0){
-						centroidCoordinateCentre = this.centre.coordinates[l] / this.centre.weight;
-					} else {
-						centroidCoordinateCentre = this.centre.coordinates[l];
-					}
-					distance += (centroidCoordinatePoint-centroidCoordinateCentre) * 
-							(centroidCoordinatePoint-centroidCoordinateCentre) ;
-						
-				}
-
-				sum += distance*this.points[i].weight;	
-			}
-			return sum;
-		}
-	};
-
-	/**
-	computes the hypothetical cost if the node would be split with new centers centreA, centreB
-	**/
-	double treeNodeSplitCost(treeNode node, Point centreA, Point centreB){
-		//loop counter variable
-		int i;
-		
-		//stores the cost
-		double sum = 0.0;
-		
-		for(i=0; i<node.n; i++){
-			//loop counter variable
-			int l;	
-
-			//stores the distance between p and centreA
-			double distanceA = 0.0;
-
-			for(l=0;l<node.points[i].dimension;l++){
-				//centroid coordinate of the point
-				double centroidCoordinatePoint;
-				if(node.points[i].weight != 0.0){
-					centroidCoordinatePoint = node.points[i].coordinates[l] / node.points[i].weight;
-				} else {
-					centroidCoordinatePoint = node.points[i].coordinates[l];
-				}
-				//centroid coordinate of the centre
-				double centroidCoordinateCentre;
-				if(centreA.weight != 0.0){
-					centroidCoordinateCentre = centreA.coordinates[l] / centreA.weight;
-				} else {
-					centroidCoordinateCentre = centreA.coordinates[l];
-				}
-
-				distanceA += (centroidCoordinatePoint-centroidCoordinateCentre) * 
-						(centroidCoordinatePoint-centroidCoordinateCentre) ;
-			}
-
-			//stores the distance between p and centreB
-			double distanceB = 0.0;
-
-			for(l=0;l<node.points[i].dimension;l++){
-				//centroid coordinate of the point
-				double centroidCoordinatePoint;
-				if(node.points[i].weight != 0.0){
-					centroidCoordinatePoint = node.points[i].coordinates[l] / node.points[i].weight;
-				} else {
-					centroidCoordinatePoint = node.points[i].coordinates[l];
-				}
-				//centroid coordinate of the centre
-				double centroidCoordinateCentre;
-				if(centreB.weight != 0.0){
-					centroidCoordinateCentre = centreB.coordinates[l] / centreB.weight;
-				} else {
-					centroidCoordinateCentre = centreB.coordinates[l];
-				}
-
-				distanceB += (centroidCoordinatePoint-centroidCoordinateCentre) * 
-						(centroidCoordinatePoint-centroidCoordinateCentre) ;
-			}
-
-			//add the cost of the closest centre to the sum
-			if(distanceA < distanceB){
-				sum += distanceA*node.points[i].weight;
-			} else {
-				sum += distanceB*node.points[i].weight;
-			}
-
-		}
-		
-		//return the total cost
-		return sum;
-
-	}
-
-
-	/**
-	computes the cost of point p with the centre of treenode node
-	**/
-	double treeNodeCostOfPoint(treeNode node, Point p){
-		if(p.weight == 0.0){
-			return 0.0;
-		}
-
-		//stores the distance between centre and p
-		double distance = 0.0;
-		
-		//loop counter variable
-		int l;
-
-		for(l=0;l<p.dimension;l++){
-			//centroid coordinate of the point
-			double centroidCoordinatePoint;
-			if(p.weight != 0.0){
-				centroidCoordinatePoint = p.coordinates[l] / p.weight;
-			} else {
-				centroidCoordinatePoint = p.coordinates[l];
-			}
-			//centroid coordinate of the centre
-			double centroidCoordinateCentre;
-			if(node.centre.weight != 0.0){
-				centroidCoordinateCentre = node.centre.coordinates[l] / node.centre.weight;
-			} else {
-				centroidCoordinateCentre = node.centre.coordinates[l];
-			}
-			distance += (centroidCoordinatePoint-centroidCoordinateCentre) * 
-					(centroidCoordinatePoint-centroidCoordinateCentre) ;
-					
-		}
-		return distance * p.weight;
-	}
-
-	/**
-	tests if a node is a leaf
-	**/
-	boolean isLeaf(treeNode node){
-
-		if(node.lc == null && node.rc == null){
-			return true;
-		} else {
-			return false;
-		}
-
-	}
-
-	/**
-	selects a leaf node (using the kMeans++ distribution)
-	**/
-   treeNode selectNode(treeNode root, MTRandom clustererRandom){
-		
-		//random number between 0 and 1
-		double random = clustererRandom.nextDouble();
-		
-		while(!isLeaf(root)){
-			if(root.lc.cost == 0 && root.rc.cost == 0){
-				if(root.lc.n == 0){
-					root = root.rc;
-				} else if(root.rc.n == 0){
-					root = root.lc;
-				}else if(random < 0.5){
-					random = clustererRandom.nextDouble();
-					root = root.lc;
-				} else {		
-					random = clustererRandom.nextDouble();		
-					root = root.rc;
-				}
-			} else {
-
-				if(random < root.lc.cost/root.cost){
-			
-					root = root.lc;
-				} else {		
-
-					root = root.rc;
-				}
-			}
-		}
-
-		return root;
-	}
-
-	/**
-	selects a new centre from the treenode (using the kMeans++ distribution)
-	**/
-	Point chooseCentre(treeNode node, MTRandom clustererRandom){
-
-		//How many times should we try to choose a centre ??
-		int times = 3;
-			
-		//stores the nodecost if node is split with the best centre
-		double minCost = node.cost;
-		Point bestCentre = null;
-		
-		//loop counter variable
-		int i;
-		int j;
-		
-		for(j=0;j<times;j++){
-			//sum of the relativ cost of the points
-			double sum = 0.0;
-			//random number between 0 and 1
-			double random = clustererRandom.nextDouble();
-			
-			for(i=0;i<node.n;i++){
-			
-				sum += treeNodeCostOfPoint(node,node.points[i]) / node.cost;
-				if(sum >= random){
-					if(node.points[i].weight == 0.0){
-						//printf("ERROR: CHOOSEN DUMMY NODE THOUGH OTHER AVAILABLE \n");
-						return null;
-					}
-					double curCost = treeNodeSplitCost(node,node.centre,node.points[i]);
-					if(curCost < minCost){
-						bestCentre = node.points[i];
-						minCost = curCost;
-					}
-					break;
-				}
-			}
-		}
-		if(bestCentre == null){
-			return node.points[0];
-		} else {
-			return bestCentre;
-		}
-	}
-
-	/**
-	returns the next centre
-	**/
-	Point determineClosestCentre(Point p, Point centreA, Point centreB){
-		
-		//loop counter variable
-		int l;	
-
-		//stores the distance between p and centreA
-		double distanceA = 0.0;
-
-		for(l=0;l<p.dimension;l++){
-			//centroid coordinate of the point
-			double centroidCoordinatePoint;
-			if(p.weight != 0.0){
-				centroidCoordinatePoint = p.coordinates[l] / p.weight;
-			} else {
-				centroidCoordinatePoint = p.coordinates[l];
-			}
-			//centroid coordinate of the centre
-			double centroidCoordinateCentre;
-			if(centreA.weight != 0.0){
-				centroidCoordinateCentre = centreA.coordinates[l] / centreA.weight;
-			} else {
-				centroidCoordinateCentre = centreA.coordinates[l];
-			}
-
-			distanceA += (centroidCoordinatePoint-centroidCoordinateCentre) * 
-					(centroidCoordinatePoint-centroidCoordinateCentre) ;
-		}
-
-		//stores the distance between p and centreB
-		double distanceB = 0.0;
-
-		for(l=0;l<p.dimension;l++){
-			//centroid coordinate of the point
-			double centroidCoordinatePoint;
-			if(p.weight != 0.0){
-				centroidCoordinatePoint = p.coordinates[l] / p.weight;
-			} else {
-				centroidCoordinatePoint = p.coordinates[l];
-			}
-			//centroid coordinate of the centre
-			double centroidCoordinateCentre;
-			if(centreB.weight != 0.0){
-				centroidCoordinateCentre = centreB.coordinates[l] / centreB.weight;
-			} else {
-				centroidCoordinateCentre = centreB.coordinates[l];
-			}
-
-			distanceB += (centroidCoordinatePoint-centroidCoordinateCentre) * 
-					(centroidCoordinatePoint-centroidCoordinateCentre) ;
-		}
-
-		//return the nearest centre
-		if(distanceA < distanceB){
-			return centreA;
-		} else {
-			return centreB;
-		}
-	}
-
-	/**
-	splits the parent node and creates two child nodes (one with the old centre and one with the new one)
-	**/
-	void split(treeNode parent, Point newCentre, int newCentreIndex){
-		
-		//loop counter variable
-		int i;
-
-		//1. Counts how many points belong to the new and how many points belong to the old centre
-		int nOld = 0;
-		int nNew = 0;
-		for(i=0;i<parent.n;i++){
-			Point centre = determineClosestCentre(parent.points[i], parent.centre, newCentre);
-			if(centre == newCentre){
-				nNew++;
-			} else {
-				nOld++;
-			} 
-		}
-
-		//2. initalizes the arrays for the pointer
-		
-		//array for pointer on the points belonging to the old centre
-		Point[] oldPoints = new Point[nOld];
-
-		//array for pointer on the points belonging to the new centre
-		Point[] newPoints = new Point[nNew];
-
-		int indexOld = 0;
-		int indexNew = 0;
-
-		for(i=0;i<parent.n;i++){
-			Point centre = determineClosestCentre(parent.points[i],parent.centre,newCentre);
-			if(centre == newCentre){
-				newPoints[indexNew] = parent.points[i];
-				newPoints[indexNew].centreIndex = newCentreIndex;
-				indexNew++;
-			} else if(centre == parent.centre){
-				oldPoints[indexOld] = parent.points[i];
-				indexOld++;
-			} else {
-				//printf("ERROR !!! NO CENTER NEAREST !! \n");
-			}
-		}
-
-		//left child: old centre
-		treeNode lc = new treeNode(nOld, oldPoints, 
-						parent.centre, parent);
-		/*lc.centre = parent.centre;
-		lc.points = oldPoints;
-		lc.n = nOld;
-
-		lc.lc = null;
-		lc.rc = null;
-		lc.parent = parent;
-
-		treeNodeTargetFunctionValue(lc);*/
-		
-		//right child: new centre
-		treeNode rc = new treeNode(nNew, newPoints, newCentre, 
-							 parent);
-		/*rc.centre = newCentre;
-		rc.points = newPoints;
-		rc.n = nNew;
-
-		rc.lc = null;
-		rc.rc = null;
-		rc.parent = parent;
-
-		treeNodeTargetFunctionValue(rc);*/
-
-		//set childs of the parent node
-		parent.lc = lc;
-		parent.rc = rc;
-
-		//propagate the cost changes to the parent nodes
-		while(parent != null){
-			parent.cost = parent.lc.cost + parent.rc.cost;
-			parent = parent.parent;
-		}
-
-	}
-
-	/**
-	Checks if the storage is completly freed
-	**/
-	boolean treeFinished(treeNode root){
-		return (root.parent == null && root.lc == null && root.rc == null);
-	}
-
-	/**
-	frees a tree of its storage
-	**/
-	void freeTree(treeNode root){
-
-		while(!treeFinished(root)){
-			if(root.lc == null && root.rc == null){
-				root = root.parent;
-			} else if(root.lc == null && root.rc != null){
-				//Schau ob rc ein Blatt ist
-				if(isLeaf(root.rc)){
-					//Gebe rechtes Kind frei
-					root.rc.free();
-					root.rc = null;
-				} else {
-					//Fahre mit rechtem Kind fort
-					root = root.rc;
-				}
-			} else if(root.lc != null) {
-				if(isLeaf(root.lc)){
-					root.lc.free();
-					root.lc = null;
-				} else {
-					root = root.lc;
-				}
-			}
-		}
-		root.free();
-
-	}
-
-	/**
-	Constructs a coreset of size k from the union of setA and setB
-	**/
-	void unionTreeCoreset(int k,int n_1,int n_2,int d, Point[] setA,Point[] setB, Point[] centres, MTRandom clustererRandom) {
-		//printf("Computing coreset...\n");
-		//total number of points
-		int n = n_1+n_2;
-
-		//choose the first centre (each point has the same probability of being choosen)
-		
-		//stores, how many centres have been choosen yet
-		int choosenPoints = 0; 
-		
-		//only choose from the n-i points not already choosen
-		int j = clustererRandom.nextInt(n-choosenPoints); 
-
-		//copy the choosen point
-		if(j < n_1){
-			//copyPointWithoutInit(&setA[j],&centres[choosenPoints]);
-			centres[choosenPoints] = setA[j].clone();
-		} else {
-			j = j - n_1;
-			//copyPointWithoutInit(&setB[j],&centres[choosenPoints]);
-			centres[choosenPoints] = setB[j].clone();
-		}
-		treeNode root = new treeNode(setA,setB,n_1,n_2, centres[choosenPoints],choosenPoints); //??
-		choosenPoints = 1;
-		
-		//choose the remaining points
-		while(choosenPoints < k){
-			if(root.cost > 0.0){
-				treeNode leaf = selectNode(root, clustererRandom);
-				Point centre = chooseCentre(leaf, clustererRandom);
-				split(leaf,centre,choosenPoints);
-				//copyPointWithoutInit(centre,&centres[choosenPoints]);
-				centres[choosenPoints] = centre;
-			} else {
-				//create a dummy point
-				//copyPointWithoutInit(root.centre,&centres[choosenPoints]);
-				centres[choosenPoints] = root.centre;
-				int l;
-				for(l=0;l<root.centre.dimension;l++){
-					centres[choosenPoints].coordinates[l] = -1 * 1000000;
-				}
-				centres[choosenPoints].id = -1;
-				centres[choosenPoints].weight = 0.0;
-				centres[choosenPoints].squareSum = 0.0;
-			}
-			
-			choosenPoints++;
-		}
-
-		//free the tree
-		freeTree(root);
-
-		//recalculate clustering features
-		int i;
-		for(i=0;i<n;i++){
-				
-			if(i < n_1) {
-				
-				int index = setA[i].centreIndex;
-				if(centres[index].id != setA[i].id){
-					centres[index].weight += setA[i].weight;
-					centres[index].squareSum += setA[i].squareSum;
-					int l;
-					for(l=0;l<centres[index].dimension;l++){
-						if(setA[i].weight != 0.0){
-							centres[index].coordinates[l] += setA[i].coordinates[l];
-						}
-					}
-				}
-			} else {
-				
-				int index = setB[i-n_1].centreIndex;
-				if(centres[index].id != setB[i-n_1].id){
-					centres[index].weight += setB[i-n_1].weight;
-					centres[index].squareSum += setB[i-n_1].squareSum;
-					int l;
-					for(l=0;l<centres[index].dimension;l++){
-						if(setB[i-n_1].weight != 0.0){
-							centres[index].coordinates[l] += setB[i-n_1].coordinates[l];
-						}
-					}
-				}
-			}
-		}
-	}
-
-
-}
diff --git a/moa/src/main/java/moa/core/AutoClassDiscovery.java b/moa/src/main/java/moa/core/AutoClassDiscovery.java
index f750c52eb..be0987a51 100644
--- a/moa/src/main/java/moa/core/AutoClassDiscovery.java
+++ b/moa/src/main/java/moa/core/AutoClassDiscovery.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.core;
 
@@ -36,146 +36,142 @@
 import nz.ac.waikato.cms.locator.FixedClassListTraversal;
 
 /**
- * Class for discovering classes via reflection in the java class path.
- * <br>
- * If analyzing of classpath fails, it falls back on reading class names
- * from file list {@link #CLASS_LIST} as resource stream.
+ * Class for discovering classes via reflection in the java class path. <br>
+ * If analyzing of classpath fails, it falls back on reading class names from
+ * file list {@link #CLASS_LIST} as resource stream.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  */
 public class AutoClassDiscovery {
 
-    protected static final Map<String, String[]> cachedClassNames = new HashMap<String, String[]>();
-
-    protected static ClassCache m_Cache;
-
-    public final static String CLASS_LIST = "moa.classes";
-
-    /**
-     * Initializes the class cache
-     */
-    protected static synchronized void initCache() {
-        if (m_Cache == null) {
-            m_Cache = new ClassCache();
-
-            // try loading fixed list of classes
-            if (m_Cache.isEmpty()) {
-                InputStream inputStream = null;
-                    try {
-                    inputStream = m_Cache.getClass().getResourceAsStream(CLASS_LIST);
-                    m_Cache = new ClassCache(new FixedClassListTraversal(inputStream));
-                }
-                catch (Exception e) {
-                    System.err.println("Failed to initialize class cache from fixed list (" + CLASS_LIST + ")!");
-                        e.printStackTrace();
-                    }
-                finally {
-                    if (inputStream != null) {
-                        try {
-                            inputStream.close();
-                }
-                        catch (Exception e) {
-
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-
-    /**
-     * Returns all class names stored in the cache.
-     * @return the class names
-     */
-    public static List<String> getAllClassNames() {
-        List<String> result = new ArrayList<>();
-        Iterator<String> pkgs = m_Cache.packages();
-        while (pkgs.hasNext()) {
-            String pkg = pkgs.next();
-            if (pkg.startsWith("moa")) {
-                Set<String> classnames = m_Cache.getClassnames(pkg);
-                result.addAll(classnames);
-            }
-            }
-        return result;
-            }
-            // ignore unreadable files
-    public static synchronized String[] findClassNames(String packageNameToSearch) {
-        String[] cached = cachedClassNames.get(packageNameToSearch);
-        if (cached == null) {
-            HashSet<String> classNames = new HashSet<String>();
-
-            initCache();
-            Iterator<String> iter = m_Cache.packages();
-            while (iter.hasNext()) {
-                String pkg = iter.next();
-                if (pkg.equals(packageNameToSearch) || pkg.startsWith(packageNameToSearch + "."))
-                    classNames.addAll(m_Cache.getClassnames(pkg));
-            }
-            cached = classNames.toArray(new String[classNames.size()]);
-            Arrays.sort(cached);
-            cachedClassNames.put(packageNameToSearch, cached);
-        }
-        return cached;
-    }
-
-    public static Class[] findClassesOfType(String packageNameToSearch,
-            Class<?> typeDesired) {
-        ArrayList<Class<?>> classesFound = new ArrayList<>();
-        String[] classNames = findClassNames(packageNameToSearch);
-        for (String className : classNames) {
-            if (isPublicConcreteClassOfType(className, typeDesired)) {
-                try {
-                    classesFound.add(Class.forName(className));
-                } catch (Exception ignored) {
-                    // ignore classes that we cannot instantiate
-                }
-            }
-        }
-        return classesFound.toArray(new Class[classesFound.size()]);
-    }
-
-    public static boolean isPublicConcreteClassOfType(String className,
-            Class<?> typeDesired) {
-        Class<?> testClass = null;
-        try {
-            testClass = Class.forName(className);
-        } catch (Exception e) {
-            return false;
-        }
-        int classModifiers = testClass.getModifiers();
-        return (java.lang.reflect.Modifier.isPublic(classModifiers)
-                && !java.lang.reflect.Modifier.isAbstract(classModifiers)
-                && typeDesired.isAssignableFrom(testClass) && hasEmptyConstructor(testClass));
-    }
-
-    public static boolean hasEmptyConstructor(Class<?> type) {
-        try {
-            type.getConstructor();
-            return true;
-        } catch (Exception ignored) {
-            return false;
-        }
-    }
-
-    /**
-     * Outputs all class names below "moa" either to stdout or to the
-     * file provided as first argument.
-     *
-     * @param args optional file for storing the classnames
-     * @throws Exception if writing to file fails
-     */
-    public static void main(String[] args) throws Exception {
-        initCache();
-        List<String> allClassnames = getAllClassNames();
-        PrintStream out = System.out;
-        if (args.length > 0)
-            out = new PrintStream(new File(args[0]));
-        Collections.sort(allClassnames);
-        for (String clsname: allClassnames)
-            out.println(clsname);
-        out.flush();
-        if (args.length > 0)
-            out.close();
-    }
+	protected static final Map<String, String[]> cachedClassNames = new HashMap<>();
+
+	protected static ClassCache m_Cache;
+
+	public final static String CLASS_LIST = "moa.classes";
+
+	/**
+	 * Initializes the class cache
+	 */
+	protected static synchronized void initCache() {
+		if (m_Cache == null) {
+			m_Cache = new ClassCache();
+
+			// try loading fixed list of classes
+			if (m_Cache.isEmpty()) {
+				InputStream inputStream = null;
+				try {
+					inputStream = m_Cache.getClass().getResourceAsStream(CLASS_LIST);
+					m_Cache = new ClassCache(new FixedClassListTraversal(inputStream));
+				} catch (Exception e) {
+					System.err.println("Failed to initialize class cache from fixed list (" + CLASS_LIST + ")!");
+					e.printStackTrace();
+				} finally {
+					if (inputStream != null) {
+						try {
+							inputStream.close();
+						} catch (Exception e) {
+
+						}
+					}
+				}
+			}
+		}
+	}
+
+	/**
+	 * Returns all class names stored in the cache.
+	 * 
+	 * @return the class names
+	 */
+	public static List<String> getAllClassNames() {
+		List<String> result = new ArrayList<>();
+		Iterator<String> pkgs = m_Cache.packages();
+		while (pkgs.hasNext()) {
+			String pkg = pkgs.next();
+			if (pkg.startsWith("moa")) {
+				Set<String> classnames = m_Cache.getClassnames(pkg);
+				result.addAll(classnames);
+			}
+		}
+		return result;
+	}
+
+	// ignore unreadable files
+	public static synchronized String[] findClassNames(String packageNameToSearch) {
+		String[] cached = cachedClassNames.get(packageNameToSearch);
+		if (cached == null) {
+			HashSet<String> classNames = new HashSet<>();
+
+			initCache();
+			Iterator<String> iter = m_Cache.packages();
+			while (iter.hasNext()) {
+				String pkg = iter.next();
+				if (pkg.equals(packageNameToSearch) || pkg.startsWith(packageNameToSearch + "."))
+					classNames.addAll(m_Cache.getClassnames(pkg));
+			}
+			cached = classNames.toArray(new String[classNames.size()]);
+			Arrays.sort(cached);
+			cachedClassNames.put(packageNameToSearch, cached);
+		}
+		return cached;
+	}
+
+	public static Class[] findClassesOfType(String packageNameToSearch, Class<?> typeDesired) {
+		ArrayList<Class<?>> classesFound = new ArrayList<>();
+		String[] classNames = findClassNames(packageNameToSearch);
+		for (String className : classNames) {
+			if (isPublicConcreteClassOfType(className, typeDesired)) {
+				try {
+					classesFound.add(Class.forName(className));
+				} catch (Exception ignored) {
+					// ignore classes that we cannot instantiate
+				}
+			}
+		}
+		return classesFound.toArray(new Class[classesFound.size()]);
+	}
+
+	public static boolean isPublicConcreteClassOfType(String className, Class<?> typeDesired) {
+		Class<?> testClass = null;
+		try {
+			testClass = Class.forName(className);
+		} catch (Exception e) {
+			return false;
+		}
+		int classModifiers = testClass.getModifiers();
+		return (java.lang.reflect.Modifier.isPublic(classModifiers)
+				&& !java.lang.reflect.Modifier.isAbstract(classModifiers) && typeDesired.isAssignableFrom(testClass)
+				&& hasEmptyConstructor(testClass));
+	}
+
+	public static boolean hasEmptyConstructor(Class<?> type) {
+		try {
+			type.getConstructor();
+			return true;
+		} catch (Exception ignored) {
+			return false;
+		}
+	}
+
+	/**
+	 * Outputs all class names below "moa" either to stdout or to the file provided
+	 * as first argument.
+	 *
+	 * @param args optional file for storing the classnames
+	 * @throws Exception if writing to file fails
+	 */
+	public static void main(String[] args) throws Exception {
+		initCache();
+		List<String> allClassnames = getAllClassNames();
+		PrintStream out = System.out;
+		if (args.length > 0)
+			out = new PrintStream(new File(args[0]));
+		Collections.sort(allClassnames);
+		for (String clsname : allClassnames)
+			out.println(clsname);
+		out.flush();
+		if (args.length > 0)
+			out.close();
+	}
 }
diff --git a/moa/src/main/java/moa/core/AutoExpandVector.java b/moa/src/main/java/moa/core/AutoExpandVector.java
index 938f70a78..c352fbf53 100644
--- a/moa/src/main/java/moa/core/AutoExpandVector.java
+++ b/moa/src/main/java/moa/core/AutoExpandVector.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.core;
 
@@ -33,100 +33,100 @@
  */
 public class AutoExpandVector<T> extends ArrayList<T> implements MOAObject {
 
-    private static final long serialVersionUID = 1L;
-
-    public AutoExpandVector() {
-        super(0);
-    }
-    
-    public AutoExpandVector(int size) {
-        super(size);
-    }
-
-    @Override
-    public void add(int pos, T obj) {
-        if (pos > size()) {
-            while (pos > size()) {
-                add(null);
-            }
-            trimToSize();
-        }
-        super.add(pos, obj);
-    }
-
-    @Override
-    public T get(int pos) {
-        return ((pos >= 0) && (pos < size())) ? super.get(pos) : null;
-    }
-
-    @Override
-    public T set(int pos, T obj) {
-        if (pos >= size()) {
-            add(pos, obj);
-            return null;
-        }
-        return super.set(pos, obj);
-    }
-
-    @Override
-    public boolean add(T arg0) {
-        boolean result = super.add(arg0);
-        trimToSize();
-        return result;
-    }
-
-    @Override
-    public boolean addAll(Collection<? extends T> arg0) {
-        boolean result = super.addAll(arg0);
-        trimToSize();
-        return result;
-    }
-
-    @Override
-    public boolean addAll(int arg0, Collection<? extends T> arg1) {
-        boolean result = super.addAll(arg0, arg1);
-        trimToSize();
-        return result;
-    }
-
-    @Override
-    public void clear() {
-        super.clear();
-        trimToSize();
-    }
-
-    @Override
-    public T remove(int arg0) {
-        T result = super.remove(arg0);
-        trimToSize();
-        return result;
-    }
-
-    @Override
-    public boolean remove(Object arg0) {
-        boolean result = super.remove(arg0);
-        trimToSize();
-        return result;
-    }
-
-    @Override
-    protected void removeRange(int arg0, int arg1) {
-        super.removeRange(arg0, arg1);
-        trimToSize();
-    }
-
-    @Override
-    public MOAObject copy() {
-        return AbstractMOAObject.copy(this);
-    }
-
-    @Override
-    public long measureByteSize() {
-        return AbstractMOAObject.measureByteSize(this);
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
+	private static final long serialVersionUID = 1L;
+
+	public AutoExpandVector() {
+		super(0);
+	}
+
+	public AutoExpandVector(int size) {
+		super(size);
+	}
+
+	@Override
+	public void add(int pos, T obj) {
+		if (pos > size()) {
+			while (pos > size()) {
+				add(null);
+			}
+			trimToSize();
+		}
+		super.add(pos, obj);
+	}
+
+	@Override
+	public T get(int pos) {
+		return ((pos >= 0) && (pos < size())) ? super.get(pos) : null;
+	}
+
+	@Override
+	public T set(int pos, T obj) {
+		if (pos >= size()) {
+			add(pos, obj);
+			return null;
+		}
+		return super.set(pos, obj);
+	}
+
+	@Override
+	public boolean add(T arg0) {
+		boolean result = super.add(arg0);
+		trimToSize();
+		return result;
+	}
+
+	@Override
+	public boolean addAll(Collection<? extends T> arg0) {
+		boolean result = super.addAll(arg0);
+		trimToSize();
+		return result;
+	}
+
+	@Override
+	public boolean addAll(int arg0, Collection<? extends T> arg1) {
+		boolean result = super.addAll(arg0, arg1);
+		trimToSize();
+		return result;
+	}
+
+	@Override
+	public void clear() {
+		super.clear();
+		trimToSize();
+	}
+
+	@Override
+	public T remove(int arg0) {
+		T result = super.remove(arg0);
+		trimToSize();
+		return result;
+	}
+
+	@Override
+	public boolean remove(Object arg0) {
+		boolean result = super.remove(arg0);
+		trimToSize();
+		return result;
+	}
+
+	@Override
+	protected void removeRange(int arg0, int arg1) {
+		super.removeRange(arg0, arg1);
+		trimToSize();
+	}
+
+	@Override
+	public MOAObject copy() {
+		return AbstractMOAObject.copy(this);
+	}
+
+	@Override
+	public long measureByteSize() {
+		return AbstractMOAObject.measureByteSize(this);
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
 }
diff --git a/moa/src/main/java/moa/core/DoubleVector.java b/moa/src/main/java/moa/core/DoubleVector.java
index 51d27a2a5..770f1c768 100644
--- a/moa/src/main/java/moa/core/DoubleVector.java
+++ b/moa/src/main/java/moa/core/DoubleVector.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.core;
 
@@ -29,178 +29,178 @@
  */
 public class DoubleVector extends AbstractMOAObject {
 
-    private static final long serialVersionUID = 1L;
-
-    protected double[] array;
-
-    public DoubleVector() {
-        this.array = new double[0];
-    }
-
-    public DoubleVector(double[] toCopy) {
-    	if (toCopy != null) {
-    		this.array = new double[toCopy.length];
-    		System.arraycopy(toCopy, 0, this.array, 0, toCopy.length);
-    	} else {
-    		this.array = new double[0];
-    	}
-    }
-
-    public DoubleVector(DoubleVector toCopy) {
-        this(toCopy.getArrayCopy());
-    }
-
-    public int numValues() {
-        return this.array.length;
-    }
-
-    public void setValue(int i, double v) {
-        if (i >= this.array.length) {
-            setArrayLength(i + 1);
-        }
-        this.array[i] = v;
-    }
-
-    public void addToValue(int i, double v) {
-        if (i >= this.array.length) {
-            setArrayLength(i + 1);
-        }
-        this.array[i] += v;
-    }
-
-    public void addValues(DoubleVector toAdd) {
-        addValues(toAdd.getArrayRef());
-    }
-
-    public void addValues(double[] toAdd) {
-        if (toAdd.length > this.array.length) {
-            setArrayLength(toAdd.length);
-        }
-        for (int i = 0; i < toAdd.length; i++) {
-            this.array[i] += toAdd[i];
-        }
-    }
-
-    public void subtractValues(DoubleVector toSubtract) {
-        subtractValues(toSubtract.getArrayRef());
-    }
-
-    public void subtractValues(double[] toSubtract) {
-        if (toSubtract.length > this.array.length) {
-            setArrayLength(toSubtract.length);
-        }
-        for (int i = 0; i < toSubtract.length; i++) {
-            this.array[i] -= toSubtract[i];
-        }
-    }
-
-    public void addToValues(double toAdd) {
-        for (int i = 0; i < this.array.length; i++) {
-            this.array[i] = this.array[i] + toAdd;
-        }
-    }
-
-    public void scaleValues(double multiplier) {
-        for (int i = 0; i < this.array.length; i++) {
-            this.array[i] = this.array[i] * multiplier;
-        }
-    }
-
-    // returns 0.0 for values outside of range
-    public double getValue(int i) {
-        return ((i >= 0) && (i < this.array.length)) ? this.array[i] : 0.0;
-    }
-
-    public double sumOfValues() {
-        double sum = 0.0;
-        for (double element : this.array) {
-            sum += element;
-        }
-        return sum;
-    }
-    
-    public double sumOfAbsoluteValues() {
-        double sum = 0.0;
-        for (double element : this.array) {
-            sum += (element > 0.0) ? element : -element;
-        }
-        return sum;
-    }
-
-    public int maxIndex() {
-        int max = -1;
-        for (int i = 0; i < this.array.length; i++) {
-            if ((max < 0) || (this.array[i] > this.array[max])) {
-                max = i;
-            }
-        }
-        return max;
-    }
-
-    public void normalize() {
-        scaleValues(1.0 / sumOfAbsoluteValues());
-    }
-
-    public int numNonZeroEntries() {
-        int count = 0;
-        for (double element : this.array) {
-            if (element != 0.0) {
-                count++;
-            }
-        }
-        return count;
-    }
-
-    public double minWeight() {
-        if (this.array.length > 0) {
-            double min = this.array[0];
-            for (int i = 1; i < this.array.length; i++) {
-                if (this.array[i] < min) {
-                    min = this.array[i];
-                }
-            }
-            return min;
-        }
-        return 0.0;
-    }
-
-    public double[] getArrayCopy() {
-        double[] aCopy = new double[this.array.length];
-        System.arraycopy(this.array, 0, aCopy, 0, this.array.length);
-        return aCopy;
-    }
-
-    public double[] getArrayRef() {
-        return this.array;
-    }
-
-    protected void setArrayLength(int l) {
-        double[] newArray = new double[l];
-        int numToCopy = this.array.length;
-        if (numToCopy > l) {
-            numToCopy = l;
-        }
-        System.arraycopy(this.array, 0, newArray, 0, numToCopy);
-        this.array = newArray;
-    }
-
-    public void getSingleLineDescription(StringBuilder out) {
-        getSingleLineDescription(out, numValues());
-    }
-
-    public void getSingleLineDescription(StringBuilder out, int numValues) {
-        out.append("{");
-        for (int i = 0; i < numValues; i++) {
-            if (i > 0) {
-                out.append("|");
-            }
-            out.append(String.valueOf(this.array[i]));
-        }
-        out.append("}");
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        getSingleLineDescription(sb);
-    }
+	private static final long serialVersionUID = 1L;
+
+	protected double[] array;
+
+	public DoubleVector() {
+		this.array = new double[0];
+	}
+
+	public DoubleVector(double[] toCopy) {
+		if (toCopy != null) {
+			this.array = new double[toCopy.length];
+			System.arraycopy(toCopy, 0, this.array, 0, toCopy.length);
+		} else {
+			this.array = new double[0];
+		}
+	}
+
+	public DoubleVector(DoubleVector toCopy) {
+		this(toCopy.getArrayCopy());
+	}
+
+	public int numValues() {
+		return this.array.length;
+	}
+
+	public void setValue(int i, double v) {
+		if (i >= this.array.length) {
+			setArrayLength(i + 1);
+		}
+		this.array[i] = v;
+	}
+
+	public void addToValue(int i, double v) {
+		if (i >= this.array.length) {
+			setArrayLength(i + 1);
+		}
+		this.array[i] += v;
+	}
+
+	public void addValues(DoubleVector toAdd) {
+		addValues(toAdd.getArrayRef());
+	}
+
+	public void addValues(double[] toAdd) {
+		if (toAdd.length > this.array.length) {
+			setArrayLength(toAdd.length);
+		}
+		for (int i = 0; i < toAdd.length; i++) {
+			this.array[i] += toAdd[i];
+		}
+	}
+
+	public void subtractValues(DoubleVector toSubtract) {
+		subtractValues(toSubtract.getArrayRef());
+	}
+
+	public void subtractValues(double[] toSubtract) {
+		if (toSubtract.length > this.array.length) {
+			setArrayLength(toSubtract.length);
+		}
+		for (int i = 0; i < toSubtract.length; i++) {
+			this.array[i] -= toSubtract[i];
+		}
+	}
+
+	public void addToValues(double toAdd) {
+		for (int i = 0; i < this.array.length; i++) {
+			this.array[i] = this.array[i] + toAdd;
+		}
+	}
+
+	public void scaleValues(double multiplier) {
+		for (int i = 0; i < this.array.length; i++) {
+			this.array[i] = this.array[i] * multiplier;
+		}
+	}
+
+	// returns 0.0 for values outside of range
+	public double getValue(int i) {
+		return ((i >= 0) && (i < this.array.length)) ? this.array[i] : 0.0;
+	}
+
+	public double sumOfValues() {
+		double sum = 0.0;
+		for (double element : this.array) {
+			sum += element;
+		}
+		return sum;
+	}
+
+	public double sumOfAbsoluteValues() {
+		double sum = 0.0;
+		for (double element : this.array) {
+			sum += (element > 0.0) ? element : -element;
+		}
+		return sum;
+	}
+
+	public int maxIndex() {
+		int max = -1;
+		for (int i = 0; i < this.array.length; i++) {
+			if ((max < 0) || (this.array[i] > this.array[max])) {
+				max = i;
+			}
+		}
+		return max;
+	}
+
+	public void normalize() {
+		scaleValues(1.0 / sumOfAbsoluteValues());
+	}
+
+	public int numNonZeroEntries() {
+		int count = 0;
+		for (double element : this.array) {
+			if (element != 0.0) {
+				count++;
+			}
+		}
+		return count;
+	}
+
+	public double minWeight() {
+		if (this.array.length > 0) {
+			double min = this.array[0];
+			for (int i = 1; i < this.array.length; i++) {
+				if (this.array[i] < min) {
+					min = this.array[i];
+				}
+			}
+			return min;
+		}
+		return 0.0;
+	}
+
+	public double[] getArrayCopy() {
+		double[] aCopy = new double[this.array.length];
+		System.arraycopy(this.array, 0, aCopy, 0, this.array.length);
+		return aCopy;
+	}
+
+	public double[] getArrayRef() {
+		return this.array;
+	}
+
+	protected void setArrayLength(int l) {
+		double[] newArray = new double[l];
+		int numToCopy = this.array.length;
+		if (numToCopy > l) {
+			numToCopy = l;
+		}
+		System.arraycopy(this.array, 0, newArray, 0, numToCopy);
+		this.array = newArray;
+	}
+
+	public void getSingleLineDescription(StringBuilder out) {
+		getSingleLineDescription(out, numValues());
+	}
+
+	public void getSingleLineDescription(StringBuilder out, int numValues) {
+		out.append("{");
+		for (int i = 0; i < numValues; i++) {
+			if (i > 0) {
+				out.append("|");
+			}
+			out.append(String.valueOf(this.array[i]));
+		}
+		out.append("}");
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		getSingleLineDescription(sb);
+	}
 }
diff --git a/moa/src/main/java/moa/core/Example.java b/moa/src/main/java/moa/core/Example.java
index 47e5f57ea..404fbce82 100644
--- a/moa/src/main/java/moa/core/Example.java
+++ b/moa/src/main/java/moa/core/Example.java
@@ -1,12 +1,12 @@
 package moa.core;
 
-public interface Example< T extends Object> {
+public interface Example<T extends Object> {
 
-	public T getData();
+	T getData();
 
-	public double weight();
-	
-	public void setWeight(double weight);
+	double weight();
 
-	public Example copy();
-} 
+	void setWeight(double weight);
+
+	Example copy();
+}
diff --git a/moa/src/main/java/moa/core/FastVector.java b/moa/src/main/java/moa/core/FastVector.java
index ba3b77fe3..df1722c14 100644
--- a/moa/src/main/java/moa/core/FastVector.java
+++ b/moa/src/main/java/moa/core/FastVector.java
@@ -30,32 +30,32 @@
  */
 public class FastVector<E> extends ArrayList<E> {
 
-    /**
-     * Adds an element to this vector. Increases its capacity if its not large
-     * enough.
-     *
-     * @param element the element to add
-     */
-    public final void addElement(E element) {
-        add(element);
-    }
+	/**
+	 * Adds an element to this vector. Increases its capacity if its not large
+	 * enough.
+	 *
+	 * @param element the element to add
+	 */
+	public final void addElement(E element) {
+		add(element);
+	}
 
-    /**
-     * Returns the element at the given position.
-     *
-     * @param index the element's index
-     * @return the element with the given index
-     */
-    public final E elementAt(int index) {
-        return get(index);
-    }
+	/**
+	 * Returns the element at the given position.
+	 *
+	 * @param index the element's index
+	 * @return the element with the given index
+	 */
+	public final E elementAt(int index) {
+		return get(index);
+	}
 
-    /**
-     * Deletes an element from this vector.
-     *
-     * @param index the index of the element to be deleted
-     */
-    public final void removeElementAt(int index) {
-        remove(index);
-    }
+	/**
+	 * Deletes an element from this vector.
+	 *
+	 * @param index the index of the element to be deleted
+	 */
+	public final void removeElementAt(int index) {
+		remove(index);
+	}
 }
diff --git a/moa/src/main/java/moa/core/FixedLengthList.java b/moa/src/main/java/moa/core/FixedLengthList.java
index 4bb55ef64..17392a868 100644
--- a/moa/src/main/java/moa/core/FixedLengthList.java
+++ b/moa/src/main/java/moa/core/FixedLengthList.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
 package moa.core;
@@ -25,87 +25,82 @@
 import java.util.Iterator;
 
 /**
- * FixedLengthList is an extension of an ArrayList with a fixed maximum size. If an element is added that would
- * put the list over its maximum size then the oldest element in the list is removed.
- * 
+ * FixedLengthList is an extension of an ArrayList with a fixed maximum size. If
+ * an element is added that would put the list over its maximum size then the
+ * oldest element in the list is removed.
+ *
  * @author Richard Hugh Moulton
  *
  * @param <E> the type of object found in the FixedLengthList
  */
-public class FixedLengthList<E> extends ArrayList<E>
-{
+public class FixedLengthList<E> extends ArrayList<E> {
 	private static final long serialVersionUID = 5763493643390042080L;
-	
+
 	/**
 	 * The fixed length of the FixedLengthList
 	 */
 	private int maxSize;
-	
+
 	/**
 	 * Constructor
-	 * 
+	 *
 	 * @param m the length of the list
 	 */
-	public FixedLengthList(int m)
-	{
+	public FixedLengthList(int m) {
 		maxSize = m;
 	}
-	
+
 	/**
-	 * Calls super.add(entry) to append the entry to the end of the FixedLengthList. Removes the oldest entry if required.
-	 * Returns true at completion.
-	 * 
+	 * Calls super.add(entry) to append the entry to the end of the FixedLengthList.
+	 * Removes the oldest entry if required. Returns true at completion.
+	 *
 	 * @param entry the entry to add to the list
 	 */
-	public boolean add(E entry)
-	{
+	@Override
+	public boolean add(E entry) {
 		super.add(entry);
-		
-		if(this.size() > this.maxSize)
-		{
+
+		if (this.size() > this.maxSize) {
 			super.removeRange(0, this.size() - maxSize);
 		}
-		
+
 		return true;
 	}
-	
+
 	/**
-	 * Appends all of the elements in the argument collection in the order that they are returned by the collection's iterator.
-	 * Does so by calling FixedLengthList.add(E entry).
+	 * Appends all of the elements in the argument collection in the order that they
+	 * are returned by the collection's iterator. Does so by calling
+	 * FixedLengthList.add(E entry).
 	 */
-	public boolean addAll(Collection<? extends E> c)
-	{
+	@Override
+	public boolean addAll(Collection<? extends E> c) {
 		Iterator<? extends E> cIterator = c.iterator();
-		
-		while(cIterator.hasNext())
-		{
+
+		while (cIterator.hasNext()) {
 			this.add(cIterator.next());
 		}
-		
+
 		return true;
 	}
-	
+
 	/**
 	 * @return the least recently added object in the list.
 	 */
-	public E getOldestEntry()
-	{
+	public E getOldestEntry() {
 		return super.get(0);
 	}
-	
+
 	/**
 	 * @return the most recently added object in the list.
 	 */
-	public E getYoungestEntry()
-	{
-		return super.get(this.size()-1);
+	public E getYoungestEntry() {
+		return super.get(this.size() - 1);
 	}
 
 	/**
 	 * @return the size limit of the FixedLengthList.
 	 */
-	public int getMaxSize()
-	{
+	public int getMaxSize() {
 		return this.maxSize;
 	}
 }
diff --git a/moa/src/main/java/moa/core/GaussianEstimator.java b/moa/src/main/java/moa/core/GaussianEstimator.java
index eafbe0b74..69aa91b36 100644
--- a/moa/src/main/java/moa/core/GaussianEstimator.java
+++ b/moa/src/main/java/moa/core/GaussianEstimator.java
@@ -15,108 +15,107 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.core;
 
 import moa.AbstractMOAObject;
 
 /**
- * Gaussian incremental estimator that uses incremental method that is more resistant to floating point imprecision.
- * for more info see Donald Knuth's "The Art of Computer Programming, Volume 2: Seminumerical Algorithms", section 4.2.2.
+ * Gaussian incremental estimator that uses incremental method that is more
+ * resistant to floating point imprecision. for more info see Donald Knuth's
+ * "The Art of Computer Programming, Volume 2: Seminumerical Algorithms",
+ * section 4.2.2.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
 public class GaussianEstimator extends AbstractMOAObject {
 
-    private static final long serialVersionUID = 1L;
-
-    protected double weightSum;
-
-    protected double mean;
-
-    protected double varianceSum;
-
-    public static final double NORMAL_CONSTANT = Math.sqrt(2 * Math.PI);
-
-    public void addObservation(double value, double weight) {
-        if (Double.isInfinite(value) || Double.isNaN(value)) {
-            return;
-        }
-        if (this.weightSum > 0.0) {
-            this.weightSum += weight;
-            double lastMean = this.mean;
-            this.mean += weight * (value - lastMean) / this.weightSum; 
-            this.varianceSum += weight * (value - lastMean) * (value - this.mean);
-        } else {
-            this.mean = value;
-            this.weightSum = weight;
-        }
-    }
-
-    public void addObservations(GaussianEstimator obs) {
-        // Follows Variance Combination Rule in Section 2 of
-        // Brian Babcock, Mayur Datar, Rajeev Motwani, Liadan O'Callaghan:
-        // Maintaining variance and k-medians over data stream windows. PODS 2003: 234-243
-        //
-        if ((this.weightSum > 0.0) && (obs.weightSum > 0.0)) {
-            double oldMean = this.mean;
-            this.mean = (this.mean * (this.weightSum / (this.weightSum + obs.weightSum)))
-                    + (obs.mean * (obs.weightSum / (this.weightSum + obs.weightSum)));
-            this.varianceSum += obs.varianceSum + (this.weightSum * obs.weightSum / (this.weightSum + obs.weightSum) *
-                                 Math.pow(obs.mean-oldMean, 2));
-            this.weightSum += obs.weightSum;
-        }
-    }
-
-    public double getTotalWeightObserved() {
-        return this.weightSum;
-    }
-
-    public double getMean() {
-        return this.mean;
-    }
-
-    public double getStdDev() {
-        return Math.sqrt(getVariance());
-    }
-
-    public double getVariance() {
-        return this.weightSum > 1.0 ? this.varianceSum / (this.weightSum - 1.0)
-                : 0.0;
-    }
-
-    public double probabilityDensity(double value) {
-        if (this.weightSum > 0.0) {
-            double stdDev = getStdDev();
-            if (stdDev > 0.0) {
-                double diff = value - getMean();
-                return (1.0 / (NORMAL_CONSTANT * stdDev))
-                        * Math.exp(-(diff * diff / (2.0 * stdDev * stdDev)));
-            }
-            return value == getMean() ? 1.0 : 0.0;
-        }
-        return 0.0;
-    }
-
-    public double[] estimatedWeight_LessThan_EqualTo_GreaterThan_Value(
-            double value) {
-        double equalToWeight = probabilityDensity(value) * this.weightSum;
-        double stdDev = getStdDev();
-        double lessThanWeight = stdDev > 0.0 ? moa.core.Statistics.normalProbability((value - getMean()) / stdDev)
-                * this.weightSum - equalToWeight
-                : (value < getMean() ? this.weightSum - equalToWeight : 0.0);
-        double greaterThanWeight = this.weightSum - equalToWeight
-                - lessThanWeight;
-        if (greaterThanWeight < 0.0) {
-            greaterThanWeight = 0.0;
-        }
-        return new double[]{lessThanWeight, equalToWeight, greaterThanWeight};
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
+	private static final long serialVersionUID = 1L;
+
+	protected double weightSum;
+
+	protected double mean;
+
+	protected double varianceSum;
+
+	public static final double NORMAL_CONSTANT = Math.sqrt(2 * Math.PI);
+
+	public void addObservation(double value, double weight) {
+		if (Double.isInfinite(value) || Double.isNaN(value)) {
+			return;
+		}
+		if (this.weightSum > 0.0) {
+			this.weightSum += weight;
+			double lastMean = this.mean;
+			this.mean += weight * (value - lastMean) / this.weightSum;
+			this.varianceSum += weight * (value - lastMean) * (value - this.mean);
+		} else {
+			this.mean = value;
+			this.weightSum = weight;
+		}
+	}
+
+	public void addObservations(GaussianEstimator obs) {
+		// Follows Variance Combination Rule in Section 2 of
+		// Brian Babcock, Mayur Datar, Rajeev Motwani, Liadan O'Callaghan:
+		// Maintaining variance and k-medians over data stream windows. PODS 2003:
+		// 234-243
+		//
+		if ((this.weightSum > 0.0) && (obs.weightSum > 0.0)) {
+			double oldMean = this.mean;
+			this.mean = (this.mean * (this.weightSum / (this.weightSum + obs.weightSum)))
+					+ (obs.mean * (obs.weightSum / (this.weightSum + obs.weightSum)));
+			this.varianceSum += obs.varianceSum + (this.weightSum * obs.weightSum / (this.weightSum + obs.weightSum)
+					* Math.pow(obs.mean - oldMean, 2));
+			this.weightSum += obs.weightSum;
+		}
+	}
+
+	public double getTotalWeightObserved() {
+		return this.weightSum;
+	}
+
+	public double getMean() {
+		return this.mean;
+	}
+
+	public double getStdDev() {
+		return Math.sqrt(getVariance());
+	}
+
+	public double getVariance() {
+		return this.weightSum > 1.0 ? this.varianceSum / (this.weightSum - 1.0) : 0.0;
+	}
+
+	public double probabilityDensity(double value) {
+		if (this.weightSum > 0.0) {
+			double stdDev = getStdDev();
+			if (stdDev > 0.0) {
+				double diff = value - getMean();
+				return (1.0 / (NORMAL_CONSTANT * stdDev)) * Math.exp(-(diff * diff / (2.0 * stdDev * stdDev)));
+			}
+			return value == getMean() ? 1.0 : 0.0;
+		}
+		return 0.0;
+	}
+
+	public double[] estimatedWeight_LessThan_EqualTo_GreaterThan_Value(double value) {
+		double equalToWeight = probabilityDensity(value) * this.weightSum;
+		double stdDev = getStdDev();
+		double lessThanWeight = stdDev > 0.0
+				? moa.core.Statistics.normalProbability((value - getMean()) / stdDev) * this.weightSum - equalToWeight
+				: (value < getMean() ? this.weightSum - equalToWeight : 0.0);
+		double greaterThanWeight = this.weightSum - equalToWeight - lessThanWeight;
+		if (greaterThanWeight < 0.0) {
+			greaterThanWeight = 0.0;
+		}
+		return new double[] { lessThanWeight, equalToWeight, greaterThanWeight };
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
 }
diff --git a/moa/src/main/java/moa/core/Globals.java b/moa/src/main/java/moa/core/Globals.java
index aab19a22f..44eae5850 100644
--- a/moa/src/main/java/moa/core/Globals.java
+++ b/moa/src/main/java/moa/core/Globals.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.core;
 
@@ -27,26 +27,26 @@
  */
 public class Globals {
 
-    public static final String workbenchTitle = "{M}assive {O}nline {A}nalysis";
+	public static final String workbenchTitle = "{M}assive {O}nline {A}nalysis";
 
-    public static final String versionString = " 19.05 May 2019";
+	public static final String versionString = " 19.05 May 2019";
 
-    public static final String copyrightNotice = "(C) 2007-2019 University of Waikato, Hamilton, New Zealand";
+	public static final String copyrightNotice = "(C) 2007-2019 University of Waikato, Hamilton, New Zealand";
 
-    public static final String webAddress = "http://moa.cms.waikato.ac.nz/";
+	public static final String webAddress = "http://moa.cms.waikato.ac.nz/";
 
-    public static String getWorkbenchInfoString() {
-        StringBuilder result = new StringBuilder();
-        result.append(workbenchTitle);
-        StringUtils.appendNewline(result);
-        result.append("Version: ");
-        result.append(versionString);
-        StringUtils.appendNewline(result);
-        result.append("Copyright: ");
-        result.append(copyrightNotice);
-        StringUtils.appendNewline(result);
-        result.append("Web: ");
-        result.append(webAddress);
-        return result.toString();
-    }
+	public static String getWorkbenchInfoString() {
+		StringBuilder result = new StringBuilder();
+		result.append(workbenchTitle);
+		StringUtils.appendNewline(result);
+		result.append("Version: ");
+		result.append(versionString);
+		StringUtils.appendNewline(result);
+		result.append("Copyright: ");
+		result.append(copyrightNotice);
+		StringUtils.appendNewline(result);
+		result.append("Web: ");
+		result.append(webAddress);
+		return result.toString();
+	}
 }
diff --git a/moa/src/main/java/moa/core/GreenwaldKhannaQuantileSummary.java b/moa/src/main/java/moa/core/GreenwaldKhannaQuantileSummary.java
index 4ba82a7ea..ffb2b0729 100644
--- a/moa/src/main/java/moa/core/GreenwaldKhannaQuantileSummary.java
+++ b/moa/src/main/java/moa/core/GreenwaldKhannaQuantileSummary.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.core;
 
@@ -32,249 +32,241 @@
  */
 public class GreenwaldKhannaQuantileSummary extends AbstractMOAObject {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    protected static class Tuple implements Serializable {
+	protected static class Tuple implements Serializable {
 
-        private static final long serialVersionUID = 1L;
+		private static final long serialVersionUID = 1L;
 
-        public double v;
+		public double v;
 
-        public long g;
+		public long g;
 
-        public long delta;
+		public long delta;
 
-        public Tuple(double v, long g, long delta) {
-            this.v = v;
-            this.g = g;
-            this.delta = delta;
-        }
+		public Tuple(double v, long g, long delta) {
+			this.v = v;
+			this.g = g;
+			this.delta = delta;
+		}
 
-        public Tuple(double v) {
-            this(v, 1, 0);
-        }
-    }
+		public Tuple(double v) {
+			this(v, 1, 0);
+		}
+	}
 
-    protected Tuple[] summary;
+	protected Tuple[] summary;
 
-    protected int numTuples = 0;
+	protected int numTuples = 0;
 
-    protected long numObservations = 0;
+	protected long numObservations = 0;
 
-    public GreenwaldKhannaQuantileSummary(int maxTuples) {
-        this.summary = new Tuple[maxTuples];
-    }
+	public GreenwaldKhannaQuantileSummary(int maxTuples) {
+		this.summary = new Tuple[maxTuples];
+	}
 
-    public void insert(double val) {
-        int i = findIndexOfTupleGreaterThan(val);
-        Tuple nextT = this.summary[i];
-        if (nextT == null) {
-            insertTuple(new Tuple(val, 1, 0), i);
-        } else {
-            insertTuple(new Tuple(val, 1, nextT.g + nextT.delta - 1), i);
-        }
-        if (this.numTuples == this.summary.length) {
-            // use method 1
-            deleteMergeableTupleMostFull();
-            // if (mergeMethod == 1) {
-            // deleteMergeableTupleMostFull();
-            // } else if (mergeMethod == 2) {
-            // deleteTupleMostFull();
-            // } else {
-            // long maxDelta = findMaxDelta();
-            // compress(maxDelta);
-            // while (numTuples == summary.length) {
-            // maxDelta++;
-            // compress(maxDelta);
-            // }
-            // }
-        }
-        this.numObservations++;
-    }
+	public void insert(double val) {
+		int i = findIndexOfTupleGreaterThan(val);
+		Tuple nextT = this.summary[i];
+		if (nextT == null) {
+			insertTuple(new Tuple(val, 1, 0), i);
+		} else {
+			insertTuple(new Tuple(val, 1, nextT.g + nextT.delta - 1), i);
+		}
+		if (this.numTuples == this.summary.length) {
+			// use method 1
+			deleteMergeableTupleMostFull();
+			// if (mergeMethod == 1) {
+			// deleteMergeableTupleMostFull();
+			// } else if (mergeMethod == 2) {
+			// deleteTupleMostFull();
+			// } else {
+			// long maxDelta = findMaxDelta();
+			// compress(maxDelta);
+			// while (numTuples == summary.length) {
+			// maxDelta++;
+			// compress(maxDelta);
+			// }
+			// }
+		}
+		this.numObservations++;
+	}
 
-    protected void insertTuple(Tuple t, int index) {
-        System.arraycopy(this.summary, index, this.summary, index + 1,
-                this.numTuples - index);
-        this.summary[index] = t;
-        this.numTuples++;
-    }
+	protected void insertTuple(Tuple t, int index) {
+		System.arraycopy(this.summary, index, this.summary, index + 1, this.numTuples - index);
+		this.summary[index] = t;
+		this.numTuples++;
+	}
 
-    protected void deleteTuple(int index) {
-        this.summary[index] = new Tuple(this.summary[index + 1].v,
-                this.summary[index].g + this.summary[index + 1].g,
-                this.summary[index + 1].delta);
-        System.arraycopy(this.summary, index + 2, this.summary, index + 1,
-                this.numTuples - index - 2);
-        this.summary[this.numTuples - 1] = null;
-        this.numTuples--;
-    }
+	protected void deleteTuple(int index) {
+		this.summary[index] = new Tuple(this.summary[index + 1].v, this.summary[index].g + this.summary[index + 1].g,
+				this.summary[index + 1].delta);
+		System.arraycopy(this.summary, index + 2, this.summary, index + 1, this.numTuples - index - 2);
+		this.summary[this.numTuples - 1] = null;
+		this.numTuples--;
+	}
 
-    protected void deleteTupleMostFull() {
-        long leastFullness = Long.MAX_VALUE;
-        int leastFullIndex = 0;
-        for (int i = 1; i < this.numTuples - 1; i++) {
-            long fullness = this.summary[i].g + this.summary[i + 1].g
-                    + this.summary[i + 1].delta;
-            if (fullness < leastFullness) {
-                leastFullness = fullness;
-                leastFullIndex = i;
-            }
-        }
-        if (leastFullIndex > 0) {
-            deleteTuple(leastFullIndex);
-        }
-    }
+	protected void deleteTupleMostFull() {
+		long leastFullness = Long.MAX_VALUE;
+		int leastFullIndex = 0;
+		for (int i = 1; i < this.numTuples - 1; i++) {
+			long fullness = this.summary[i].g + this.summary[i + 1].g + this.summary[i + 1].delta;
+			if (fullness < leastFullness) {
+				leastFullness = fullness;
+				leastFullIndex = i;
+			}
+		}
+		if (leastFullIndex > 0) {
+			deleteTuple(leastFullIndex);
+		}
+	}
 
-    protected void deleteMergeableTupleMostFull() {
-        long leastFullness = Long.MAX_VALUE;
-        int leastFullIndex = 0;
-        for (int i = 1; i < this.numTuples - 1; i++) {
-            long fullness = this.summary[i].g + this.summary[i + 1].g
-                    + this.summary[i + 1].delta;
-            if ((this.summary[i].delta >= this.summary[i + 1].delta)
-                    && (fullness < leastFullness)) {
-                leastFullness = fullness;
-                leastFullIndex = i;
-            }
-        }
-        if (leastFullIndex > 0) {
-            deleteTuple(leastFullIndex);
-        }
-    }
+	protected void deleteMergeableTupleMostFull() {
+		long leastFullness = Long.MAX_VALUE;
+		int leastFullIndex = 0;
+		for (int i = 1; i < this.numTuples - 1; i++) {
+			long fullness = this.summary[i].g + this.summary[i + 1].g + this.summary[i + 1].delta;
+			if ((this.summary[i].delta >= this.summary[i + 1].delta) && (fullness < leastFullness)) {
+				leastFullness = fullness;
+				leastFullIndex = i;
+			}
+		}
+		if (leastFullIndex > 0) {
+			deleteTuple(leastFullIndex);
+		}
+	}
 
-    public long getWorstError() {
-        long mostFullness = 0;
-        for (int i = 1; i < this.numTuples - 1; i++) {
-            long fullness = this.summary[i].g + this.summary[i].delta;
-            if (fullness > mostFullness) {
-                mostFullness = fullness;
-            }
-        }
-        return mostFullness;
-    }
+	public long getWorstError() {
+		long mostFullness = 0;
+		for (int i = 1; i < this.numTuples - 1; i++) {
+			long fullness = this.summary[i].g + this.summary[i].delta;
+			if (fullness > mostFullness) {
+				mostFullness = fullness;
+			}
+		}
+		return mostFullness;
+	}
 
-    public long findMaxDelta() {
-        long maxDelta = 0;
-        for (int i = 0; i < this.numTuples; i++) {
-            if (this.summary[i].delta > maxDelta) {
-                maxDelta = this.summary[i].delta;
-            }
-        }
-        return maxDelta;
-    }
+	public long findMaxDelta() {
+		long maxDelta = 0;
+		for (int i = 0; i < this.numTuples; i++) {
+			if (this.summary[i].delta > maxDelta) {
+				maxDelta = this.summary[i].delta;
+			}
+		}
+		return maxDelta;
+	}
 
-    public void compress(long maxDelta) {
-        long[] bandBoundaries = computeBandBoundaries(maxDelta);
-        for (int i = this.numTuples - 2; i >= 0; i--) {
-            if (this.summary[i].delta >= this.summary[i + 1].delta) {
-                int band = 0;
-                while (this.summary[i].delta < bandBoundaries[band]) {
-                    band++;
-                }
-                long belowBandThreshold = Long.MAX_VALUE;
-                if (band > 0) {
-                    belowBandThreshold = bandBoundaries[band - 1];
-                }
-                long mergeG = this.summary[i + 1].g + this.summary[i].g;
-                int childI = i - 1;
-                while (((mergeG + this.summary[i + 1].delta) < maxDelta)
-                        && (childI >= 0)
-                        && (this.summary[childI].delta >= belowBandThreshold)) {
-                    mergeG += this.summary[childI].g;
-                    childI--;
-                }
-                if (mergeG + this.summary[i + 1].delta < maxDelta) {
-                    // merge
-                    int numDeleted = i - childI;
-                    this.summary[childI + 1] = new Tuple(this.summary[i + 1].v,
-                            mergeG, this.summary[i + 1].delta);
-                    // todo complete & test this multiple delete
-                    System.arraycopy(this.summary, i + 2, this.summary,
-                            childI + 2, this.numTuples - (i + 2));
-                    for (int j = this.numTuples - numDeleted; j < this.numTuples; j++) {
-                        this.summary[j] = null;
-                    }
-                    this.numTuples -= numDeleted;
-                    i = childI + 1;
-                }
-            }
-        }
-    }
+	public void compress(long maxDelta) {
+		long[] bandBoundaries = computeBandBoundaries(maxDelta);
+		for (int i = this.numTuples - 2; i >= 0; i--) {
+			if (this.summary[i].delta >= this.summary[i + 1].delta) {
+				int band = 0;
+				while (this.summary[i].delta < bandBoundaries[band]) {
+					band++;
+				}
+				long belowBandThreshold = Long.MAX_VALUE;
+				if (band > 0) {
+					belowBandThreshold = bandBoundaries[band - 1];
+				}
+				long mergeG = this.summary[i + 1].g + this.summary[i].g;
+				int childI = i - 1;
+				while (((mergeG + this.summary[i + 1].delta) < maxDelta) && (childI >= 0)
+						&& (this.summary[childI].delta >= belowBandThreshold)) {
+					mergeG += this.summary[childI].g;
+					childI--;
+				}
+				if (mergeG + this.summary[i + 1].delta < maxDelta) {
+					// merge
+					int numDeleted = i - childI;
+					this.summary[childI + 1] = new Tuple(this.summary[i + 1].v, mergeG, this.summary[i + 1].delta);
+					// todo complete & test this multiple delete
+					System.arraycopy(this.summary, i + 2, this.summary, childI + 2, this.numTuples - (i + 2));
+					for (int j = this.numTuples - numDeleted; j < this.numTuples; j++) {
+						this.summary[j] = null;
+					}
+					this.numTuples -= numDeleted;
+					i = childI + 1;
+				}
+			}
+		}
+	}
 
-    public double getQuantile(double quant) {
-        long r = (long) Math.ceil(quant * this.numObservations);
-        long currRank = 0;
-        for (int i = 0; i < this.numTuples - 1; i++) {
-            currRank += this.summary[i].g;
-            if (currRank + this.summary[i + 1].g > r) {
-                return this.summary[i].v;
-            }
-        }
-        return this.summary[this.numTuples - 1].v;
-    }
+	public double getQuantile(double quant) {
+		long r = (long) Math.ceil(quant * this.numObservations);
+		long currRank = 0;
+		for (int i = 0; i < this.numTuples - 1; i++) {
+			currRank += this.summary[i].g;
+			if (currRank + this.summary[i + 1].g > r) {
+				return this.summary[i].v;
+			}
+		}
+		return this.summary[this.numTuples - 1].v;
+	}
 
-    public long getTotalCount() {
-        return this.numObservations;
-    }
+	public long getTotalCount() {
+		return this.numObservations;
+	}
 
-    public double getPropotionBelow(double cutpoint) {
-        return (double) getCountBelow(cutpoint) / (double) this.numObservations;
-    }
+	public double getPropotionBelow(double cutpoint) {
+		return (double) getCountBelow(cutpoint) / (double) this.numObservations;
+	}
 
-    public long getCountBelow(double cutpoint) {
-        long rank = 0;
-        for (int i = 0; i < this.numTuples; i++) {
-            if (this.summary[i].v > cutpoint) {
-                break;
-            }
-            rank += this.summary[i].g;
-        }
-        return rank;
-    }
+	public long getCountBelow(double cutpoint) {
+		long rank = 0;
+		for (int i = 0; i < this.numTuples; i++) {
+			if (this.summary[i].v > cutpoint) {
+				break;
+			}
+			rank += this.summary[i].g;
+		}
+		return rank;
+	}
 
-    public double[] getSuggestedCutpoints() {
-        double[] cutpoints = new double[this.numTuples];
-        for (int i = 0; i < this.numTuples; i++) {
-            cutpoints[i] = this.summary[i].v;
-        }
-        return cutpoints;
-    }
+	public double[] getSuggestedCutpoints() {
+		double[] cutpoints = new double[this.numTuples];
+		for (int i = 0; i < this.numTuples; i++) {
+			cutpoints[i] = this.summary[i].v;
+		}
+		return cutpoints;
+	}
 
-    protected int findIndexOfTupleGreaterThan(double val) {
-        int high = this.numTuples, low = -1, probe;
-        while (high - low > 1) {
-            probe = (high + low) / 2;
-            if (this.summary[probe].v > val) {
-                high = probe;
-            } else {
-                low = probe;
-            }
-        }
-        return high;
-    }
+	protected int findIndexOfTupleGreaterThan(double val) {
+		int high = this.numTuples, low = -1, probe;
+		while (high - low > 1) {
+			probe = (high + low) / 2;
+			if (this.summary[probe].v > val) {
+				high = probe;
+			} else {
+				low = probe;
+			}
+		}
+		return high;
+	}
 
-    public static long[] computeBandBoundaries(long maxDelta) {
-        ArrayList<Long> boundaryList = new ArrayList<Long>();
-        boundaryList.add(new Long(maxDelta));
-        int alpha = 1;
-        while (true) {
-            long boundary = (maxDelta - (2 << (alpha - 1)) - (maxDelta % (2 << (alpha - 1))));
-            if (boundary >= 0) {
-                boundaryList.add(new Long(boundary + 1));
-            } else {
-                break;
-            }
-            alpha++;
-        }
-        boundaryList.add(new Long(0));
-        long[] boundaries = new long[boundaryList.size()];
-        for (int i = 0; i < boundaries.length; i++) {
-            boundaries[i] = boundaryList.get(i).longValue();
-        }
-        return boundaries;
-    }
+	public static long[] computeBandBoundaries(long maxDelta) {
+		ArrayList<Long> boundaryList = new ArrayList<>();
+		boundaryList.add(new Long(maxDelta));
+		int alpha = 1;
+		while (true) {
+			long boundary = (maxDelta - (2 << (alpha - 1)) - (maxDelta % (2 << (alpha - 1))));
+			if (boundary >= 0) {
+				boundaryList.add(new Long(boundary + 1));
+			} else {
+				break;
+			}
+			alpha++;
+		}
+		boundaryList.add(new Long(0));
+		long[] boundaries = new long[boundaryList.size()];
+		for (int i = 0; i < boundaries.length; i++) {
+			boundaries[i] = boundaryList.get(i);
+		}
+		return boundaries;
+	}
 
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
 }
diff --git a/moa/src/main/java/moa/core/InputStreamProgressMonitor.java b/moa/src/main/java/moa/core/InputStreamProgressMonitor.java
index d308948b2..632f639ff 100644
--- a/moa/src/main/java/moa/core/InputStreamProgressMonitor.java
+++ b/moa/src/main/java/moa/core/InputStreamProgressMonitor.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.core;
 
@@ -61,7 +61,7 @@ public double getProgressFraction() {
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see java.io.InputStream#read()
 	 */
 	@Override
@@ -75,7 +75,7 @@ public int read() throws IOException {
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see java.io.InputStream#read(byte[])
 	 */
 	@Override
@@ -89,7 +89,7 @@ public int read(byte[] b) throws IOException {
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see java.io.InputStream#read(byte[], int, int)
 	 */
 	@Override
@@ -103,7 +103,7 @@ public int read(byte[] b, int off, int len) throws IOException {
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see java.io.InputStream#skip(long)
 	 */
 	@Override
@@ -117,7 +117,7 @@ public long skip(long n) throws IOException {
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see java.io.FilterInputStream#reset()
 	 */
 	@Override
diff --git a/moa/src/main/java/moa/core/InstanceExample.java b/moa/src/main/java/moa/core/InstanceExample.java
index 86cc0b18b..ed6203813 100644
--- a/moa/src/main/java/moa/core/InstanceExample.java
+++ b/moa/src/main/java/moa/core/InstanceExample.java
@@ -6,16 +6,15 @@ public class InstanceExample implements Example<Instance> {
 
 	public Instance instance;
 
-  	public InstanceExample(Instance inst)
-   	{                             
-		this.instance = inst;    
-  	}  
+	public InstanceExample(Instance inst) {
+		this.instance = inst;
+	}
 
 	@Override
 	public Instance getData() {
 		return this.instance;
 	}
-	
+
 	@Override
 	public double weight() {
 		return this.instance.weight();
@@ -33,8 +32,8 @@ public Example copy() {
 	}
 
 	@Override
-  	public String toString() {
-  	  return this.instance.toString();
+	public String toString() {
+		return this.instance.toString();
 	}
 
-} 
+}
diff --git a/moa/src/main/java/moa/core/Measurement.java b/moa/src/main/java/moa/core/Measurement.java
index a2ea72d66..cf1389899 100644
--- a/moa/src/main/java/moa/core/Measurement.java
+++ b/moa/src/main/java/moa/core/Measurement.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.core;
 
@@ -32,88 +32,85 @@
  */
 public class Measurement extends AbstractMOAObject {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    protected String name;
+	protected String name;
 
-    protected double value;
+	protected double value;
 
-    public Measurement(String name, double value) {
-        this.name = name;
-        this.value = value;
-    }
+	public Measurement(String name, double value) {
+		this.name = name;
+		this.value = value;
+	}
 
-    public String getName() {
-        return this.name;
-    }
+	public String getName() {
+		return this.name;
+	}
 
-    public double getValue() {
-        return this.value;
-    }
+	public double getValue() {
+		return this.value;
+	}
 
-    public static Measurement getMeasurementNamed(String name,
-            Measurement[] measurements) {
-        for (Measurement measurement : measurements) {
-            if (name.equals(measurement.getName())) {
-                return measurement;
-            }
-        }
-        return null;
-    }
+	public static Measurement getMeasurementNamed(String name, Measurement[] measurements) {
+		for (Measurement measurement : measurements) {
+			if (name.equals(measurement.getName())) {
+				return measurement;
+			}
+		}
+		return null;
+	}
 
-    public static void getMeasurementsDescription(Measurement[] measurements,
-            StringBuilder out, int indent) {
-        if (measurements.length > 0) {
-            StringUtils.appendIndented(out, indent, measurements[0].toString());
-            for (int i = 1; i < measurements.length; i++) {
-                StringUtils.appendNewlineIndented(out, indent, measurements[i].toString());
-            }
+	public static void getMeasurementsDescription(Measurement[] measurements, StringBuilder out, int indent) {
+		if (measurements.length > 0) {
+			StringUtils.appendIndented(out, indent, measurements[0].toString());
+			for (int i = 1; i < measurements.length; i++) {
+				StringUtils.appendNewlineIndented(out, indent, measurements[i].toString());
+			}
 
-        }
-    }
+		}
+	}
 
-    public static Measurement[] averageMeasurements(Measurement[][] toAverage) {
-        List<String> measurementNames = new ArrayList<String>();
-        for (Measurement[] measurements : toAverage) {
-            for (Measurement measurement : measurements) {
-                if (measurementNames.indexOf(measurement.getName()) < 0) {
-                    measurementNames.add(measurement.getName());
-                }
-            }
-        }
-        GaussianEstimator[] estimators = new GaussianEstimator[measurementNames.size()];
-        for (int i = 0; i < estimators.length; i++) {
-            estimators[i] = new GaussianEstimator();
-        }
-        for (Measurement[] measurements : toAverage) {
-            for (Measurement measurement : measurements) {
-                estimators[measurementNames.indexOf(measurement.getName())].addObservation(measurement.getValue(), 1.0);
-            }
-        }
-        List<Measurement> averagedMeasurements = new ArrayList<Measurement>();
-        for (int i = 0; i < measurementNames.size(); i++) {
-            String mName = measurementNames.get(i);
-            GaussianEstimator mEstimator = estimators[i];
-            if (mEstimator.getTotalWeightObserved() > 1.0) {
-                averagedMeasurements.add(new Measurement("[avg] " + mName, mEstimator.getMean()));
-                averagedMeasurements.add(new Measurement("[err] " + mName, mEstimator.getStdDev()));
-            }
-            else {
-                averagedMeasurements.add(new Measurement("[avg] " + mName, 0.0));
-                averagedMeasurements.add(new Measurement("[err] " + mName, 0.0));
-            }
-        }
-        return averagedMeasurements.toArray(new Measurement[averagedMeasurements.size()]);
-    }
+	public static Measurement[] averageMeasurements(Measurement[][] toAverage) {
+		List<String> measurementNames = new ArrayList<>();
+		for (Measurement[] measurements : toAverage) {
+			for (Measurement measurement : measurements) {
+				if (measurementNames.indexOf(measurement.getName()) < 0) {
+					measurementNames.add(measurement.getName());
+				}
+			}
+		}
+		GaussianEstimator[] estimators = new GaussianEstimator[measurementNames.size()];
+		for (int i = 0; i < estimators.length; i++) {
+			estimators[i] = new GaussianEstimator();
+		}
+		for (Measurement[] measurements : toAverage) {
+			for (Measurement measurement : measurements) {
+				estimators[measurementNames.indexOf(measurement.getName())].addObservation(measurement.getValue(), 1.0);
+			}
+		}
+		List<Measurement> averagedMeasurements = new ArrayList<>();
+		for (int i = 0; i < measurementNames.size(); i++) {
+			String mName = measurementNames.get(i);
+			GaussianEstimator mEstimator = estimators[i];
+			if (mEstimator.getTotalWeightObserved() > 1.0) {
+				averagedMeasurements.add(new Measurement("[avg] " + mName, mEstimator.getMean()));
+				averagedMeasurements.add(new Measurement("[err] " + mName, mEstimator.getStdDev()));
+			} else {
+				averagedMeasurements.add(new Measurement("[avg] " + mName, 0.0));
+				averagedMeasurements.add(new Measurement("[err] " + mName, 0.0));
+			}
+		}
+		return averagedMeasurements.toArray(new Measurement[averagedMeasurements.size()]);
+	}
 
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        sb.append(getName());
-        sb.append(" = ");
-        if (getValue()>.001) {
-                sb.append(StringUtils.doubleToString(getValue(),3));
-        } else {
-                sb.append(getValue());
-        }
-    }
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		sb.append(getName());
+		sb.append(" = ");
+		if (getValue() > .001) {
+			sb.append(StringUtils.doubleToString(getValue(), 3));
+		} else {
+			sb.append(getValue());
+		}
+	}
 }
diff --git a/moa/src/main/java/moa/core/MiscUtils.java b/moa/src/main/java/moa/core/MiscUtils.java
index a2d1cd75a..96360efd6 100644
--- a/moa/src/main/java/moa/core/MiscUtils.java
+++ b/moa/src/main/java/moa/core/MiscUtils.java
@@ -16,7 +16,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.core;
 
@@ -24,7 +24,6 @@
 import java.io.StringWriter;
 import java.util.Random;
 
-
 /**
  * Class implementing some utility methods.
  *
@@ -34,43 +33,41 @@
  */
 public class MiscUtils {
 
-    public static int chooseRandomIndexBasedOnWeights(double[] weights,
-            Random random) {
-        double probSum = Utils.sum(weights);
-        double val = random.nextDouble() * probSum;
-        int index = 0;
-        double sum = 0.0;
-        while ((sum <= val) && (index < weights.length)) {
-            sum += weights[index++];
-        }
-        return index - 1;
-    }
+	public static int chooseRandomIndexBasedOnWeights(double[] weights, Random random) {
+		double probSum = Utils.sum(weights);
+		double val = random.nextDouble() * probSum;
+		int index = 0;
+		double sum = 0.0;
+		while ((sum <= val) && (index < weights.length)) {
+			sum += weights[index++];
+		}
+		return index - 1;
+	}
 
-    public static int poisson(double lambda, Random r) {
-        if (lambda < 100.0) {
-            double product = 1.0;
-            double sum = 1.0;
-            double threshold = r.nextDouble() * Math.exp(lambda);
-            int i = 1;
-            int max = Math.max(100, 10 * (int) Math.ceil(lambda));
-            while ((i < max) && (sum <= threshold)) {
-                product *= (lambda / i);
-                sum += product;
-                i++;
-            }
-            return i - 1;
-        }
-        double x = lambda + Math.sqrt(lambda) * r.nextGaussian();
-        if (x < 0.0) {
-            return 0;
-        }
-        return (int) Math.floor(x);
-    }
+	public static int poisson(double lambda, Random r) {
+		if (lambda < 100.0) {
+			double product = 1.0;
+			double sum = 1.0;
+			double threshold = r.nextDouble() * Math.exp(lambda);
+			int i = 1;
+			int max = Math.max(100, 10 * (int) Math.ceil(lambda));
+			while ((i < max) && (sum <= threshold)) {
+				product *= (lambda / i);
+				sum += product;
+				i++;
+			}
+			return i - 1;
+		}
+		double x = lambda + Math.sqrt(lambda) * r.nextGaussian();
+		if (x < 0.0) {
+			return 0;
+		}
+		return (int) Math.floor(x);
+	}
 
-    public static String getStackTraceString(Exception ex) {
-        StringWriter stackTraceWriter = new StringWriter();
-        ex.printStackTrace(new PrintWriter(stackTraceWriter));
-        return "*** STACK TRACE ***\n" + stackTraceWriter.toString();
-    }
+	public static String getStackTraceString(Exception ex) {
+		StringWriter stackTraceWriter = new StringWriter();
+		ex.printStackTrace(new PrintWriter(stackTraceWriter));
+		return "*** STACK TRACE ***\n" + stackTraceWriter.toString();
+	}
 }
-
diff --git a/moa/src/main/java/moa/core/ObjectRepository.java b/moa/src/main/java/moa/core/ObjectRepository.java
index 44dd0e692..6babeb82c 100644
--- a/moa/src/main/java/moa/core/ObjectRepository.java
+++ b/moa/src/main/java/moa/core/ObjectRepository.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.core;
 
@@ -27,5 +27,5 @@
  */
 public interface ObjectRepository {
 
-    Object getObjectNamed(String string);
+	Object getObjectNamed(String string);
 }
diff --git a/moa/src/main/java/moa/core/PropertiesReader.java b/moa/src/main/java/moa/core/PropertiesReader.java
index 3d595aad5..2bc1c8342 100644
--- a/moa/src/main/java/moa/core/PropertiesReader.java
+++ b/moa/src/main/java/moa/core/PropertiesReader.java
@@ -11,7 +11,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
 /*
@@ -28,79 +28,76 @@
 /**
  * Class implementing some properties reader utility methods.
  *
- * @author Eibe Frank 
- * @author Yong Wang 
- * @author Len Trigg 
+ * @author Eibe Frank
+ * @author Yong Wang
+ * @author Len Trigg
  * @author Julien Prados
  * @version $Revision: 6681 $
  */
 public final class PropertiesReader {
 
-    /**
-     * Reads properties that inherit from three locations. Properties
-     * are first defined in the system resource location (i.e. in the
-     * CLASSPATH).  These default properties must exist. Properties
-     * defined in the users home directory (optional) override default
-     * settings. Properties defined in the current directory (optional)
-     * override all these settings.
-     *
-     * @param resourceName the location of the resource that should be
-     * loaded.  e.g.: "weka/core/Utils.props". (The use of hardcoded
-     * forward slashes here is OK - see
-     * jdk1.1/docs/guide/misc/resources.html) This routine will also
-     * look for the file (in this case) "Utils.props" in the users home
-     * directory and the current directory.
-     * @return the Properties
-     * @exception Exception if no default properties are defined, or if
-     * an error occurs reading the properties files.
-     */
-    public static Properties readProperties(String resourceName)
-            throws Exception {
+	/**
+	 * Reads properties that inherit from three locations. Properties are first
+	 * defined in the system resource location (i.e. in the CLASSPATH). These
+	 * default properties must exist. Properties defined in the users home directory
+	 * (optional) override default settings. Properties defined in the current
+	 * directory (optional) override all these settings.
+	 *
+	 * @param resourceName the location of the resource that should be loaded. e.g.:
+	 *                     "weka/core/Utils.props". (The use of hardcoded forward
+	 *                     slashes here is OK - see
+	 *                     jdk1.1/docs/guide/misc/resources.html) This routine will
+	 *                     also look for the file (in this case) "Utils.props" in
+	 *                     the users home directory and the current directory.
+	 * @return the Properties
+	 * @exception Exception if no default properties are defined, or if an error
+	 *                      occurs reading the properties files.
+	 */
+	public static Properties readProperties(String resourceName) throws Exception {
 
-        Properties defaultProps = new Properties();
-        try {
-            // Apparently hardcoded slashes are OK here
-            // jdk1.1/docs/guide/misc/resources.html
-            //      defaultProps.load(ClassLoader.getSystemResourceAsStream(resourceName));
-            defaultProps.load((new Utils()).getClass().getClassLoader().getResourceAsStream(resourceName));
-        } catch (Exception ex) {
-            /*      throw new Exception("Problem reading default properties: "
-            + ex.getMessage()); */
-            System.err.println("Warning, unable to load properties file from "
-                    + "system resource (Utils.java)");
-        }
+		Properties defaultProps = new Properties();
+		try {
+			// Apparently hardcoded slashes are OK here
+			// jdk1.1/docs/guide/misc/resources.html
+			// defaultProps.load(ClassLoader.getSystemResourceAsStream(resourceName));
+			defaultProps.load((new Utils()).getClass().getClassLoader().getResourceAsStream(resourceName));
+		} catch (Exception ex) {
+			/*
+			 * throw new Exception("Problem reading default properties: " +
+			 * ex.getMessage());
+			 */
+			System.err.println("Warning, unable to load properties file from " + "system resource (Utils.java)");
+		}
 
-        // Hardcoded slash is OK here
-        // eg: see jdk1.1/docs/guide/misc/resources.html
-        int slInd = resourceName.lastIndexOf('/');
-        if (slInd != -1) {
-            resourceName = resourceName.substring(slInd + 1);
-        }
+		// Hardcoded slash is OK here
+		// eg: see jdk1.1/docs/guide/misc/resources.html
+		int slInd = resourceName.lastIndexOf('/');
+		if (slInd != -1) {
+			resourceName = resourceName.substring(slInd + 1);
+		}
 
-        // Allow a properties file in the home directory to override
-        Properties userProps = new Properties(defaultProps);
-        File propFile = new File(System.getProperties().getProperty("user.home")
-                + File.separatorChar
-                + resourceName);
-        if (propFile.exists()) {
-            try {
-                userProps.load(new FileInputStream(propFile));
-            } catch (Exception ex) {
-                throw new Exception("Problem reading user properties: " + propFile);
-            }
-        }
+		// Allow a properties file in the home directory to override
+		Properties userProps = new Properties(defaultProps);
+		File propFile = new File(System.getProperties().getProperty("user.home") + File.separatorChar + resourceName);
+		if (propFile.exists()) {
+			try {
+				userProps.load(new FileInputStream(propFile));
+			} catch (Exception ex) {
+				throw new Exception("Problem reading user properties: " + propFile);
+			}
+		}
 
-        // Allow a properties file in the current directory to override
-        Properties localProps = new Properties(userProps);
-        propFile = new File(resourceName);
-        if (propFile.exists()) {
-            try {
-                localProps.load(new FileInputStream(propFile));
-            } catch (Exception ex) {
-                throw new Exception("Problem reading local properties: " + propFile);
-            }
-        }
+		// Allow a properties file in the current directory to override
+		Properties localProps = new Properties(userProps);
+		propFile = new File(resourceName);
+		if (propFile.exists()) {
+			try {
+				localProps.load(new FileInputStream(propFile));
+			} catch (Exception ex) {
+				throw new Exception("Problem reading local properties: " + propFile);
+			}
+		}
 
-        return localProps;
-    }
+		return localProps;
+	}
 }
diff --git a/moa/src/main/java/moa/core/SerializeUtils.java b/moa/src/main/java/moa/core/SerializeUtils.java
index 070a02062..fef5e0a48 100644
--- a/moa/src/main/java/moa/core/SerializeUtils.java
+++ b/moa/src/main/java/moa/core/SerializeUtils.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.core;
 
@@ -42,70 +42,65 @@
  */
 public class SerializeUtils {
 
-    public static class ByteCountingOutputStream extends OutputStream {
+	public static class ByteCountingOutputStream extends OutputStream {
 
-        protected int numBytesWritten = 0;
+		protected int numBytesWritten = 0;
 
-        public int getNumBytesWritten() {
-            return this.numBytesWritten;
-        }
+		public int getNumBytesWritten() {
+			return this.numBytesWritten;
+		}
 
-        @Override
-        public void write(int b) throws IOException {
-            this.numBytesWritten++;
-        }
+		@Override
+		public void write(int b) throws IOException {
+			this.numBytesWritten++;
+		}
 
-        @Override
-        public void write(byte[] b, int off, int len) throws IOException {
-            this.numBytesWritten += len;
-        }
+		@Override
+		public void write(byte[] b, int off, int len) throws IOException {
+			this.numBytesWritten += len;
+		}
 
-        @Override
-        public void write(byte[] b) throws IOException {
-            this.numBytesWritten += b.length;
-        }
-    }
+		@Override
+		public void write(byte[] b) throws IOException {
+			this.numBytesWritten += b.length;
+		}
+	}
 
-    public static void writeToFile(File file, Serializable obj)
-            throws IOException {
-        ObjectOutputStream out = new ObjectOutputStream(new GZIPOutputStream(
-                new BufferedOutputStream(new FileOutputStream(file))));
-        out.writeObject(obj);
-        out.flush();
-        out.close();
-    }
+	public static void writeToFile(File file, Serializable obj) throws IOException {
+		ObjectOutputStream out = new ObjectOutputStream(
+				new GZIPOutputStream(new BufferedOutputStream(new FileOutputStream(file))));
+		out.writeObject(obj);
+		out.flush();
+		out.close();
+	}
 
-    public static Object readFromFile(File file) throws IOException,
-            ClassNotFoundException {
-        ObjectInputStream in = new ObjectInputStream(new GZIPInputStream(
-                new BufferedInputStream(new FileInputStream(file))));
-        Object obj = in.readObject();
-        in.close();
-        return obj;
-    }
+	public static Object readFromFile(File file) throws IOException, ClassNotFoundException {
+		ObjectInputStream in = new ObjectInputStream(
+				new GZIPInputStream(new BufferedInputStream(new FileInputStream(file))));
+		Object obj = in.readObject();
+		in.close();
+		return obj;
+	}
 
-    public static Object copyObject(Serializable obj) throws Exception {
-        ByteArrayOutputStream baoStream = new ByteArrayOutputStream();
-        ObjectOutputStream out = new ObjectOutputStream(
-                new BufferedOutputStream(baoStream));
-        out.writeObject(obj);
-        out.flush();
-        out.close();
-        byte[] byteArray = baoStream.toByteArray();
-        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(
-                new ByteArrayInputStream(byteArray)));
-        Object copy = in.readObject();
-        in.close();
-        return copy;
-    }
+	public static Object copyObject(Serializable obj) throws Exception {
+		ByteArrayOutputStream baoStream = new ByteArrayOutputStream();
+		ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(baoStream));
+		out.writeObject(obj);
+		out.flush();
+		out.close();
+		byte[] byteArray = baoStream.toByteArray();
+		ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(new ByteArrayInputStream(byteArray)));
+		Object copy = in.readObject();
+		in.close();
+		return copy;
+	}
 
-    public static int measureObjectByteSize(Serializable obj) throws Exception {
-        ByteCountingOutputStream bcoStream = new ByteCountingOutputStream();
-        ObjectOutputStream out = new ObjectOutputStream(
-                new BufferedOutputStream(bcoStream));
-        out.writeObject(obj);
-        out.flush();
-        out.close();
-        return bcoStream.getNumBytesWritten();
-    }
+	public static int measureObjectByteSize(Serializable obj) throws Exception {
+		ByteCountingOutputStream bcoStream = new ByteCountingOutputStream();
+		ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bcoStream));
+		out.writeObject(obj);
+		out.flush();
+		out.close();
+		return bcoStream.getNumBytesWritten();
+	}
 }
diff --git a/moa/src/main/java/moa/core/SizeOf.java b/moa/src/main/java/moa/core/SizeOf.java
index ff3def4c8..88234bf10 100644
--- a/moa/src/main/java/moa/core/SizeOf.java
+++ b/moa/src/main/java/moa/core/SizeOf.java
@@ -11,7 +11,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
 /*
@@ -23,59 +23,61 @@
 import sizeof.agent.SizeOfAgent;
 
 /**
- * Helper class for <a href="http://www.jroller.com/maxim/entry/again_about_determining_size_of" target="_blank">Maxim Zakharenkov's SizeOf agent</a>.
+ * Helper class for
+ * <a href="http://www.jroller.com/maxim/entry/again_about_determining_size_of"
+ * target="_blank">Maxim Zakharenkov's SizeOf agent</a>.
  *
- * @author  fracpete (fracpete at waikato dot ac dot nz)
+ * @author fracpete (fracpete at waikato dot ac dot nz)
  * @version $Revision$
  */
 public class SizeOf {
 
-    /** whether the agent is present. */
-    protected static Boolean m_Present;
+	/** whether the agent is present. */
+	protected static Boolean m_Present;
 
-    /**
-     * Checks whether the agent is present.
-     *
-     * @return true if the agent is present, false otherwise
-     */
-    protected static synchronized boolean isPresent() {
-        if (m_Present == null) {
-            try {
-                SizeOfAgent.fullSizeOf(new Integer(1));
-                m_Present = true;
-            } catch (Throwable t) {
-                m_Present = false;
-            }
-        }
+	/**
+	 * Checks whether the agent is present.
+	 *
+	 * @return true if the agent is present, false otherwise
+	 */
+	protected static synchronized boolean isPresent() {
+		if (m_Present == null) {
+			try {
+				SizeOfAgent.fullSizeOf(new Integer(1));
+				m_Present = true;
+			} catch (Throwable t) {
+				m_Present = false;
+			}
+		}
 
-        return m_Present;
-    }
+		return m_Present;
+	}
 
-    /**
-     * Returns the size of the object.
-     *
-     * @param o	the object to get the size for
-     * @return the size of the object, or if the agent isn't present -1
-     */
-    public static long sizeOf(Object o) {
-        if (isPresent()) {
-            return SizeOfAgent.sizeOf(o);
-        } else {
-            return -1;
-        }
-    }
+	/**
+	 * Returns the size of the object.
+	 *
+	 * @param o the object to get the size for
+	 * @return the size of the object, or if the agent isn't present -1
+	 */
+	public static long sizeOf(Object o) {
+		if (isPresent()) {
+			return SizeOfAgent.sizeOf(o);
+		} else {
+			return -1;
+		}
+	}
 
-    /**
-     * Returns the full size of the object.
-     *
-     * @param o	the object to get the size for
-     * @return the size of the object, or if the agent isn't present -1
-     */
-    public static long fullSizeOf(Object o) {
-        if (isPresent()) {
-            return SizeOfAgent.fullSizeOf(o);
-        } else {
-            return -1;
-        }
-    }
+	/**
+	 * Returns the full size of the object.
+	 *
+	 * @param o the object to get the size for
+	 * @return the size of the object, or if the agent isn't present -1
+	 */
+	public static long fullSizeOf(Object o) {
+		if (isPresent()) {
+			return SizeOfAgent.fullSizeOf(o);
+		} else {
+			return -1;
+		}
+	}
 }
diff --git a/moa/src/main/java/moa/core/Statistics.java b/moa/src/main/java/moa/core/Statistics.java
index 4d15e91ce..c52e2703f 100644
--- a/moa/src/main/java/moa/core/Statistics.java
+++ b/moa/src/main/java/moa/core/Statistics.java
@@ -1,17 +1,17 @@
 package moa.core;
 
 /**
- * Class implementing some distributions, tests, etc. The code is mostly adapted from the CERN
- * Jet Java libraries:
- * 
- * Copyright 2001 University of Waikato
- * Copyright 1999 CERN - European Organization for Nuclear Research.
- * Permission to use, copy, modify, distribute and sell this software and its documentation for
- * any purpose is hereby granted without fee, provided that the above copyright notice appear
- * in all copies and that both that copyright notice and this permission notice appear in
- * supporting documentation. 
- * CERN and the University of Waikato make no representations about the suitability of this 
- * software for any purpose. It is provided "as is" without expressed or implied warranty.
+ * Class implementing some distributions, tests, etc. The code is mostly adapted
+ * from the CERN Jet Java libraries:
+ *
+ * Copyright 2001 University of Waikato Copyright 1999 CERN - European
+ * Organization for Nuclear Research. Permission to use, copy, modify,
+ * distribute and sell this software and its documentation for any purpose is
+ * hereby granted without fee, provided that the above copyright notice appear
+ * in all copies and that both that copyright notice and this permission notice
+ * appear in supporting documentation. CERN and the University of Waikato make
+ * no representations about the suitability of this software for any purpose. It
+ * is provided "as is" without expressed or implied warranty.
  *
  * @author peter.gedeck@pharma.Novartis.com
  * @author wolfgang.hoschek@cern.ch
@@ -21,1025 +21,962 @@
  */
 public class Statistics {
 
-  /** Some constants */
-  protected static final double MACHEP =  1.11022302462515654042E-16;
-  protected static final double MAXLOG =  7.09782712893383996732E2;
-  protected static final double MINLOG = -7.451332191019412076235E2;
-  protected static final double MAXGAM = 171.624376956302725;
-  protected static final double SQTPI  =  2.50662827463100050242E0;
-  protected static final double SQRTH  =  7.07106781186547524401E-1;
-  protected static final double LOGPI  =  1.14472988584940017414;
-  
-  protected static final double big    =  4.503599627370496e15;
-  protected static final double biginv =  2.22044604925031308085e-16;
-
-  /*************************************************
-   *    COEFFICIENTS FOR METHOD  normalInverse()   *
-   *************************************************/
-  /* approximation for 0 <= |y - 0.5| <= 3/8 */
-  protected static final double P0[] = {
-    -5.99633501014107895267E1,
-    9.80010754185999661536E1,
-    -5.66762857469070293439E1,
-    1.39312609387279679503E1,
-    -1.23916583867381258016E0,
-  };
-  protected static final double Q0[] = {
-    /* 1.00000000000000000000E0,*/
-    1.95448858338141759834E0,
-    4.67627912898881538453E0,
-    8.63602421390890590575E1,
-    -2.25462687854119370527E2,
-    2.00260212380060660359E2,
-    -8.20372256168333339912E1,
-    1.59056225126211695515E1,
-    -1.18331621121330003142E0,
-  };
-  
-  /* Approximation for interval z = sqrt(-2 log y ) between 2 and 8
-   * i.e., y between exp(-2) = .135 and exp(-32) = 1.27e-14.
-   */
-  protected static final double P1[] = {
-    4.05544892305962419923E0,
-    3.15251094599893866154E1,
-    5.71628192246421288162E1,
-    4.40805073893200834700E1,
-    1.46849561928858024014E1,
-    2.18663306850790267539E0,
-    -1.40256079171354495875E-1,
-    -3.50424626827848203418E-2,
-    -8.57456785154685413611E-4,
-  };
-  protected static final double Q1[] = {
-    /*  1.00000000000000000000E0,*/
-    1.57799883256466749731E1,
-    4.53907635128879210584E1,
-    4.13172038254672030440E1,
-    1.50425385692907503408E1,
-    2.50464946208309415979E0,
-    -1.42182922854787788574E-1,
-    -3.80806407691578277194E-2,
-    -9.33259480895457427372E-4,
-  };
-  
-  /* Approximation for interval z = sqrt(-2 log y ) between 8 and 64
-   * i.e., y between exp(-32) = 1.27e-14 and exp(-2048) = 3.67e-890.
-   */
-  protected static final double  P2[] = {
-    3.23774891776946035970E0,
-    6.91522889068984211695E0,
-    3.93881025292474443415E0,
-    1.33303460815807542389E0,
-    2.01485389549179081538E-1,
-    1.23716634817820021358E-2,
-    3.01581553508235416007E-4,
-    2.65806974686737550832E-6,
-    6.23974539184983293730E-9,
-  };
-  protected static final double  Q2[] = {
-    /*  1.00000000000000000000E0,*/
-    6.02427039364742014255E0,
-    3.67983563856160859403E0,
-    1.37702099489081330271E0,
-    2.16236993594496635890E-1,
-    1.34204006088543189037E-2,
-    3.28014464682127739104E-4,
-    2.89247864745380683936E-6,
-    6.79019408009981274425E-9,
-  };
-  
-  /**
-   * Computes standard error for observed values of a binomial
-   * random variable.
-   *
-   * @param p the probability of success
-   * @param n the size of the sample
-   * @return the standard error
-   */
-  public static double binomialStandardError(double p, int n) {
-    
-    if (n == 0) {
-      return 0; 
-    }
-    return Math.sqrt((p*(1-p))/(double) n);
-  }
-  
-  /**
-   * Returns chi-squared probability for given value and degrees
-   * of freedom. (The probability that the chi-squared variate
-   * will be greater than x for the given degrees of freedom.)
-   *
-   * @param x the value
-   * @param v the number of degrees of freedom
-   * @return the chi-squared probability
-   */
-  public static double chiSquaredProbability(double x, double v) { 
-
-    if( x < 0.0 || v < 1.0 ) return 0.0;
-    return incompleteGammaComplement( v/2.0, x/2.0 );
-  }
-
-  /**
-   * Computes probability of F-ratio.
-   *
-   * @param F the F-ratio
-   * @param df1 the first number of degrees of freedom
-   * @param df2 the second number of degrees of freedom
-   * @return the probability of the F-ratio.
-   */
-  public static double FProbability(double F, int df1, int df2) {
-    
-    return incompleteBeta( df2/2.0, df1/2.0, df2/(df2+df1*F) );
-  }
-
-  /**
-   * Returns the area under the Normal (Gaussian) probability density
-   * function, integrated from minus infinity to <tt>x</tt>
-   * (assumes mean is zero, variance is one).
-   * <pre>
-   *                            x
-   *                             -
-   *                   1        | |          2
-   *  normal(x)  = ---------    |    exp( - t /2 ) dt
-   *               sqrt(2pi)  | |
-   *                           -
-   *                          -inf.
-   *
-   *             =  ( 1 + erf(z) ) / 2
-   *             =  erfc(z) / 2
-   * </pre>
-   * where <tt>z = x/sqrt(2)</tt>.
-   * Computation is via the functions <tt>errorFunction</tt> and <tt>errorFunctionComplement</tt>.
-   *
-   * @param a the z-value
-   * @return the probability of the z value according to the normal pdf
-   */
-  public static double normalProbability(double a) { 
-
-    double x, y, z;
- 
-    x = a * SQRTH;
-    z = Math.abs(x);
- 
-    if( z < SQRTH ) y = 0.5 + 0.5 * errorFunction(x);
-    else {
-      y = 0.5 * errorFunctionComplemented(z);
-      if( x > 0 )  y = 1.0 - y;
-    } 
-    return y;
-  }
-
-  /**
-   * Returns the value, <tt>x</tt>, for which the area under the
-   * Normal (Gaussian) probability density function (integrated from
-   * minus infinity to <tt>x</tt>) is equal to the argument <tt>y</tt>
-   * (assumes mean is zero, variance is one).
-   * <p>
-   * For small arguments <tt>0 < y < exp(-2)</tt>, the program computes
-   * <tt>z = sqrt( -2.0 * log(y) )</tt>;  then the approximation is
-   * <tt>x = z - log(z)/z  - (1/z) P(1/z) / Q(1/z)</tt>.
-   * There are two rational functions P/Q, one for <tt>0 < y < exp(-32)</tt>
-   * and the other for <tt>y</tt> up to <tt>exp(-2)</tt>. 
-   * For larger arguments,
-   * <tt>w = y - 0.5</tt>, and  <tt>x/sqrt(2pi) = w + w**3 R(w**2)/S(w**2))</tt>.
-   *
-   * @param y0 the area under the normal pdf
-   * @return the z-value
-   */
-  public static double normalInverse(double y0) { 
-
-    double x, y, z, y2, x0, x1;
-    int code;
-
-    final double s2pi = Math.sqrt(2.0*Math.PI);
-
-    if( y0 <= 0.0 ) throw new IllegalArgumentException();
-    if( y0 >= 1.0 ) throw new IllegalArgumentException();
-    code = 1;
-    y = y0;
-    if( y > (1.0 - 0.13533528323661269189) ) { /* 0.135... = exp(-2) */
-      y = 1.0 - y;
-      code = 0;
-    }
-
-    if( y > 0.13533528323661269189 ) {
-      y = y - 0.5;
-      y2 = y * y;
-      x = y + y * (y2 * polevl( y2, P0, 4)/p1evl( y2, Q0, 8 ));
-      x = x * s2pi; 
-      return(x);
-    }
-
-    x = Math.sqrt( -2.0 * Math.log(y) );
-    x0 = x - Math.log(x)/x;
-
-    z = 1.0/x;
-    if( x < 8.0 ) /* y > exp(-32) = 1.2664165549e-14 */
-      x1 = z * polevl( z, P1, 8 )/p1evl( z, Q1, 8 );
-    else
-      x1 = z * polevl( z, P2, 8 )/p1evl( z, Q2, 8 );
-    x = x0 - x1;
-    if( code != 0 )
-      x = -x;
-    return( x );
-  }
-
-  /**
-   * Returns natural logarithm of gamma function.
-   *
-   * @param x the value
-   * @return natural logarithm of gamma function
-   */
-  public static double lnGamma(double x) {
-
-    double p, q, w, z;
- 
-    double A[] = {
-      8.11614167470508450300E-4,
-      -5.95061904284301438324E-4,
-      7.93650340457716943945E-4,
-      -2.77777777730099687205E-3,
-      8.33333333333331927722E-2
-    };
-    double B[] = {
-      -1.37825152569120859100E3,
-      -3.88016315134637840924E4,
-      -3.31612992738871184744E5,
-      -1.16237097492762307383E6,
-      -1.72173700820839662146E6,
-      -8.53555664245765465627E5
-    };
-    double C[] = {
-      /* 1.00000000000000000000E0, */
-      -3.51815701436523470549E2,
-      -1.70642106651881159223E4,
-      -2.20528590553854454839E5,
-      -1.13933444367982507207E6,
-      -2.53252307177582951285E6,
-      -2.01889141433532773231E6
-    };
- 
-    if( x < -34.0 ) {
-      q = -x;
-      w = lnGamma(q);
-      p = Math.floor(q);
-      if( p == q ) throw new ArithmeticException("lnGamma: Overflow");
-      z = q - p;
-      if( z > 0.5 ) {
-	p += 1.0;
-	z = p - q;
-      }
-      z = q * Math.sin( Math.PI * z );
-      if( z == 0.0 ) throw new 
-	ArithmeticException("lnGamma: Overflow");
-      z = LOGPI - Math.log( z ) - w;
-      return z;
-    }
- 
-    if( x < 13.0 ) {
-      z = 1.0;
-      while( x >= 3.0 ) {
-	x -= 1.0;
-	z *= x;
-      }
-      while( x < 2.0 ) {
-	if( x == 0.0 ) throw new 
-	  ArithmeticException("lnGamma: Overflow");
-	z /= x;
-	x += 1.0;
-      }
-      if( z < 0.0 ) z = -z;
-      if( x == 2.0 ) return Math.log(z);
-      x -= 2.0;
-      p = x * polevl( x, B, 5 ) / p1evl( x, C, 6);
-      return( Math.log(z) + p );
-    }
- 
-    if( x > 2.556348e305 ) throw new ArithmeticException("lnGamma: Overflow");
- 
-    q = ( x - 0.5 ) * Math.log(x) - x + 0.91893853320467274178;
-  
-    if( x > 1.0e8 ) return( q );
- 
-    p = 1.0/(x*x);
-    if( x >= 1000.0 )
-      q += ((   7.9365079365079365079365e-4 * p
-		- 2.7777777777777777777778e-3) *p
-	    + 0.0833333333333333333333) / x;
-    else
-      q += polevl( p, A, 4 ) / x;
-    return q;
-  }
-
-  /**
-   * Returns the error function of the normal distribution.
-   * The integral is
-   * <pre>
-   *                           x 
-   *                            -
-   *                 2         | |          2
-   *   erf(x)  =  --------     |    exp( - t  ) dt.
-   *              sqrt(pi)   | |
-   *                          -
-   *                           0
-   * </pre>
-   * <b>Implementation:</b>
-   * For <tt>0 <= |x| < 1, erf(x) = x * P4(x**2)/Q5(x**2)</tt>; otherwise
-   * <tt>erf(x) = 1 - erfc(x)</tt>.
-   * <p>
-   * Code adapted from the <A HREF="http://www.sci.usq.edu.au/staff/leighb/graph/Top.html">
-   * Java 2D Graph Package 2.4</A>,
-   * which in turn is a port from the
-   * <A HREF="http://people.ne.mediaone.net/moshier/index.html#Cephes">Cephes 2.2</A>
-   * Math Library (C).
-   *
-   * @param a the argument to the function.
-   */
-  public static double errorFunction(double x) { 
-    double y, z;
-    final double T[] = {
-      9.60497373987051638749E0,
-      9.00260197203842689217E1,
-      2.23200534594684319226E3,
-      7.00332514112805075473E3,
-      5.55923013010394962768E4
-    };
-    final double U[] = {
-      //1.00000000000000000000E0,
-      3.35617141647503099647E1,
-      5.21357949780152679795E2,
-      4.59432382970980127987E3,
-      2.26290000613890934246E4,
-      4.92673942608635921086E4
-    };
-  
-    if( Math.abs(x) > 1.0 ) return( 1.0 - errorFunctionComplemented(x) );
-    z = x * x;
-    y = x * polevl( z, T, 4 ) / p1evl( z, U, 5 );
-    return y;
-  }
-
-  /**
-   * Returns the complementary Error function of the normal distribution.
-   * <pre>
-   *  1 - erf(x) =
-   *
-   *                           inf. 
-   *                             -
-   *                  2         | |          2
-   *   erfc(x)  =  --------     |    exp( - t  ) dt
-   *               sqrt(pi)   | |
-   *                           -
-   *                            x
-   * </pre>
-   * <b>Implementation:</b>
-   * For small x, <tt>erfc(x) = 1 - erf(x)</tt>; otherwise rational
-   * approximations are computed.
-   * <p>
-   * Code adapted from the <A HREF="http://www.sci.usq.edu.au/staff/leighb/graph/Top.html">
-   * Java 2D Graph Package 2.4</A>,
-   * which in turn is a port from the
-   * <A HREF="http://people.ne.mediaone.net/moshier/index.html#Cephes">Cephes 2.2</A>
-   * Math Library (C).
-   *
-   * @param a the argument to the function.
-   */
-  public static double errorFunctionComplemented(double a) { 
-    double x,y,z,p,q;
-  
-    double P[] = {
-      2.46196981473530512524E-10,
-      5.64189564831068821977E-1,
-      7.46321056442269912687E0,
-      4.86371970985681366614E1,
-      1.96520832956077098242E2,
-      5.26445194995477358631E2,
-      9.34528527171957607540E2,
-      1.02755188689515710272E3,
-      5.57535335369399327526E2
-    };
-    double Q[] = {
-      //1.0
-      1.32281951154744992508E1,
-      8.67072140885989742329E1,
-      3.54937778887819891062E2,
-      9.75708501743205489753E2,
-      1.82390916687909736289E3,
-      2.24633760818710981792E3,
-      1.65666309194161350182E3,
-      5.57535340817727675546E2
-    };
-  
-    double R[] = {
-      5.64189583547755073984E-1,
-      1.27536670759978104416E0,
-      5.01905042251180477414E0,
-      6.16021097993053585195E0,
-      7.40974269950448939160E0,
-      2.97886665372100240670E0
-    };
-    double S[] = {
-      //1.00000000000000000000E0, 
-      2.26052863220117276590E0,
-      9.39603524938001434673E0,
-      1.20489539808096656605E1,
-      1.70814450747565897222E1,
-      9.60896809063285878198E0,
-      3.36907645100081516050E0
-    };
-  
-    if( a < 0.0 )   x = -a;
-    else            x = a;
-  
-    if( x < 1.0 )   return 1.0 - errorFunction(a);
-  
-    z = -a * a;
-  
-    if( z < -MAXLOG ) {
-      if( a < 0 )  return( 2.0 );
-      else         return( 0.0 );
-    }
-  
-    z = Math.exp(z);
-  
-    if( x < 8.0 ) {
-      p = polevl( x, P, 8 );
-      q = p1evl( x, Q, 8 );
-    } else {
-      p = polevl( x, R, 5 );
-      q = p1evl( x, S, 6 );
-    }
-  
-    y = (z * p)/q;
-  
-    if( a < 0 ) y = 2.0 - y;
-  
-    if( y == 0.0 ) {
-      if( a < 0 ) return 2.0;
-      else        return( 0.0 );
-    }
-    return y;
-  }
-  
-  /**
-   * Evaluates the given polynomial of degree <tt>N</tt> at <tt>x</tt>.
-   * Evaluates polynomial when coefficient of N is 1.0.
-   * Otherwise same as <tt>polevl()</tt>.
-   * <pre>
-   *                     2          N
-   * y  =  C  + C x + C x  +...+ C x
-   *        0    1     2          N
-   *
-   * Coefficients are stored in reverse order:
-   *
-   * coef[0] = C  , ..., coef[N] = C  .
-   *            N                   0
-   * </pre>
-   * The function <tt>p1evl()</tt> assumes that <tt>coef[N] = 1.0</tt> and is
-   * omitted from the array.  Its calling arguments are
-   * otherwise the same as <tt>polevl()</tt>.
-   * <p>
-   * In the interest of speed, there are no checks for out of bounds arithmetic.
-   *
-   * @param x argument to the polynomial.
-   * @param coef the coefficients of the polynomial.
-   * @param N the degree of the polynomial.
-   */
-  public static double p1evl( double x, double coef[], int N ) {
-  
-    double ans;
-    ans = x + coef[0];
-  
-    for(int i=1; i<N; i++) ans = ans*x+coef[i];
-  
-    return ans;
-  }
-
-  /**
-   * Evaluates the given polynomial of degree <tt>N</tt> at <tt>x</tt>.
-   * <pre>
-   *                     2          N
-   * y  =  C  + C x + C x  +...+ C x
-   *        0    1     2          N
-   *
-   * Coefficients are stored in reverse order:
-   *
-   * coef[0] = C  , ..., coef[N] = C  .
-   *            N                   0
-   * </pre>
-   * In the interest of speed, there are no checks for out of bounds arithmetic.
-   *
-   * @param x argument to the polynomial.
-   * @param coef the coefficients of the polynomial.
-   * @param N the degree of the polynomial.
-   */
-  public static double polevl( double x, double coef[], int N ) {
-
-    double ans;
-    ans = coef[0];
-  
-    for(int i=1; i<=N; i++) ans = ans*x+coef[i];
-  
-    return ans;
-  }
-
-  /**
-   * Returns the Incomplete Gamma function.
-   * @param a the parameter of the gamma distribution.
-   * @param x the integration end point.
-   */
-  public static double incompleteGamma(double a, double x) 
-    { 
- 
-    double ans, ax, c, r;
- 
-    if( x <= 0 || a <= 0 ) return 0.0;
- 
-    if( x > 1.0 && x > a ) return 1.0 - incompleteGammaComplement(a,x);
-
-    /* Compute  x**a * exp(-x) / gamma(a)  */
-    ax = a * Math.log(x) - x - lnGamma(a);
-    if( ax < -MAXLOG ) return( 0.0 );
-
-    ax = Math.exp(ax);
-
-    /* power series */
-    r = a;
-    c = 1.0;
-    ans = 1.0;
-
-    do {
-      r += 1.0;
-      c *= x/r;
-      ans += c;
-    }
-    while( c/ans > MACHEP );
- 
-    return( ans * ax/a );
-  }
-
-  /**
-   * Returns the Complemented Incomplete Gamma function.
-   * @param a the parameter of the gamma distribution.
-   * @param x the integration start point.
-   */
-  public static double incompleteGammaComplement( double a, double x ) {
-
-    double ans, ax, c, yc, r, t, y, z;
-    double pk, pkm1, pkm2, qk, qkm1, qkm2;
-
-    if( x <= 0 || a <= 0 ) return 1.0;
- 
-    if( x < 1.0 || x < a ) return 1.0 - incompleteGamma(a,x);
- 
-    ax = a * Math.log(x) - x - lnGamma(a);
-    if( ax < -MAXLOG ) return 0.0;
- 
-    ax = Math.exp(ax);
- 
-    /* continued fraction */
-    y = 1.0 - a;
-    z = x + y + 1.0;
-    c = 0.0;
-    pkm2 = 1.0;
-    qkm2 = x;
-    pkm1 = x + 1.0;
-    qkm1 = z * x;
-    ans = pkm1/qkm1;
- 
-    do {
-      c += 1.0;
-      y += 1.0;
-      z += 2.0;
-      yc = y * c;
-      pk = pkm1 * z  -  pkm2 * yc;
-      qk = qkm1 * z  -  qkm2 * yc;
-      if( qk != 0 ) {
-	r = pk/qk;
-        t = Math.abs( (ans - r)/r );
-	ans = r;
-      } else
-	t = 1.0;
-
-      pkm2 = pkm1;
-      pkm1 = pk;
-      qkm2 = qkm1;
-      qkm1 = qk;
-      if( Math.abs(pk) > big ) {
-	pkm2 *= biginv;
-        pkm1 *= biginv;
-	qkm2 *= biginv;
-	qkm1 *= biginv;
-      }
-    } while( t > MACHEP );
- 
-    return ans * ax;
-  }
-
-  /**
-   * Returns the Gamma function of the argument.
-   */
-  public static double gamma(double x) {
-
-    double P[] = {
-      1.60119522476751861407E-4,
-      1.19135147006586384913E-3,
-      1.04213797561761569935E-2,
-      4.76367800457137231464E-2,
-      2.07448227648435975150E-1,
-      4.94214826801497100753E-1,
-      9.99999999999999996796E-1
-    };
-    double Q[] = {
-      -2.31581873324120129819E-5,
-      5.39605580493303397842E-4,
-      -4.45641913851797240494E-3,
-      1.18139785222060435552E-2,
-      3.58236398605498653373E-2,
-      -2.34591795718243348568E-1,
-      7.14304917030273074085E-2,
-      1.00000000000000000320E0
-    };
-
-    double p, z;
-    int i;
-
-    double q = Math.abs(x);
-
-    if( q > 33.0 ) {
-      if( x < 0.0 ) {
-	p = Math.floor(q);
-	if( p == q ) throw new ArithmeticException("gamma: overflow");
-	i = (int)p;
-	z = q - p;
-	if( z > 0.5 ) {
-	  p += 1.0;
-	  z = q - p;
+	/** Some constants */
+	protected static final double MACHEP = 1.11022302462515654042E-16;
+	protected static final double MAXLOG = 7.09782712893383996732E2;
+	protected static final double MINLOG = -7.451332191019412076235E2;
+	protected static final double MAXGAM = 171.624376956302725;
+	protected static final double SQTPI = 2.50662827463100050242E0;
+	protected static final double SQRTH = 7.07106781186547524401E-1;
+	protected static final double LOGPI = 1.14472988584940017414;
+
+	protected static final double big = 4.503599627370496e15;
+	protected static final double biginv = 2.22044604925031308085e-16;
+
+	/*************************************************
+	 * COEFFICIENTS FOR METHOD normalInverse() *
+	 *************************************************/
+	/* approximation for 0 <= |y - 0.5| <= 3/8 */
+	protected static final double P0[] = { -5.99633501014107895267E1, 9.80010754185999661536E1,
+			-5.66762857469070293439E1, 1.39312609387279679503E1, -1.23916583867381258016E0, };
+	protected static final double Q0[] = {
+			/* 1.00000000000000000000E0, */
+			1.95448858338141759834E0, 4.67627912898881538453E0, 8.63602421390890590575E1, -2.25462687854119370527E2,
+			2.00260212380060660359E2, -8.20372256168333339912E1, 1.59056225126211695515E1, -1.18331621121330003142E0, };
+
+	/*
+	 * Approximation for interval z = sqrt(-2 log y ) between 2 and 8 i.e., y
+	 * between exp(-2) = .135 and exp(-32) = 1.27e-14.
+	 */
+	protected static final double P1[] = { 4.05544892305962419923E0, 3.15251094599893866154E1, 5.71628192246421288162E1,
+			4.40805073893200834700E1, 1.46849561928858024014E1, 2.18663306850790267539E0, -1.40256079171354495875E-1,
+			-3.50424626827848203418E-2, -8.57456785154685413611E-4, };
+	protected static final double Q1[] = {
+			/* 1.00000000000000000000E0, */
+			1.57799883256466749731E1, 4.53907635128879210584E1, 4.13172038254672030440E1, 1.50425385692907503408E1,
+			2.50464946208309415979E0, -1.42182922854787788574E-1, -3.80806407691578277194E-2,
+			-9.33259480895457427372E-4, };
+
+	/*
+	 * Approximation for interval z = sqrt(-2 log y ) between 8 and 64 i.e., y
+	 * between exp(-32) = 1.27e-14 and exp(-2048) = 3.67e-890.
+	 */
+	protected static final double P2[] = { 3.23774891776946035970E0, 6.91522889068984211695E0, 3.93881025292474443415E0,
+			1.33303460815807542389E0, 2.01485389549179081538E-1, 1.23716634817820021358E-2, 3.01581553508235416007E-4,
+			2.65806974686737550832E-6, 6.23974539184983293730E-9, };
+	protected static final double Q2[] = {
+			/* 1.00000000000000000000E0, */
+			6.02427039364742014255E0, 3.67983563856160859403E0, 1.37702099489081330271E0, 2.16236993594496635890E-1,
+			1.34204006088543189037E-2, 3.28014464682127739104E-4, 2.89247864745380683936E-6,
+			6.79019408009981274425E-9, };
+
+	/**
+	 * Computes standard error for observed values of a binomial random variable.
+	 *
+	 * @param p the probability of success
+	 * @param n the size of the sample
+	 * @return the standard error
+	 */
+	public static double binomialStandardError(double p, int n) {
+
+		if (n == 0) {
+			return 0;
+		}
+		return Math.sqrt((p * (1 - p)) / n);
+	}
+
+	/**
+	 * Returns chi-squared probability for given value and degrees of freedom. (The
+	 * probability that the chi-squared variate will be greater than x for the given
+	 * degrees of freedom.)
+	 *
+	 * @param x the value
+	 * @param v the number of degrees of freedom
+	 * @return the chi-squared probability
+	 */
+	public static double chiSquaredProbability(double x, double v) {
+
+		if (x < 0.0 || v < 1.0)
+			return 0.0;
+		return incompleteGammaComplement(v / 2.0, x / 2.0);
 	}
-	z = q * Math.sin( Math.PI * z );
-	if( z == 0.0 ) throw new ArithmeticException("gamma: overflow");
-	z = Math.abs(z);
-	z = Math.PI/(z * stirlingFormula(q) );
-
-	return -z;
-      } else {
-	return stirlingFormula(x);
-      }
-    }
-
-    z = 1.0;
-    while( x >= 3.0 ) {
-      x -= 1.0;
-      z *= x;
-    }
-
-    while( x < 0.0 ) {
-      if( x == 0.0 ) {
-	throw new ArithmeticException("gamma: singular");
-      } else
-	if( x > -1.E-9 ) {
-	  return( z/((1.0 + 0.5772156649015329 * x) * x) );
+
+	/**
+	 * Computes probability of F-ratio.
+	 *
+	 * @param F   the F-ratio
+	 * @param df1 the first number of degrees of freedom
+	 * @param df2 the second number of degrees of freedom
+	 * @return the probability of the F-ratio.
+	 */
+	public static double FProbability(double F, int df1, int df2) {
+
+		return incompleteBeta(df2 / 2.0, df1 / 2.0, df2 / (df2 + df1 * F));
+	}
+
+	/**
+	 * Returns the area under the Normal (Gaussian) probability density function,
+	 * integrated from minus infinity to <tt>x</tt> (assumes mean is zero, variance
+	 * is one).
+	 * 
+	 * <pre>
+	 *                            x
+	 *                             -
+	 *                   1        | |          2
+	 *  normal(x)  = ---------    |    exp( - t /2 ) dt
+	 *               sqrt(2pi)  | |
+	 *                           -
+	 *                          -inf.
+	 *
+	 *             =  ( 1 + erf(z) ) / 2
+	 *             =  erfc(z) / 2
+	 * </pre>
+	 * 
+	 * where <tt>z = x/sqrt(2)</tt>. Computation is via the functions
+	 * <tt>errorFunction</tt> and <tt>errorFunctionComplement</tt>.
+	 *
+	 * @param a the z-value
+	 * @return the probability of the z value according to the normal pdf
+	 */
+	public static double normalProbability(double a) {
+
+		double x, y, z;
+
+		x = a * SQRTH;
+		z = Math.abs(x);
+
+		if (z < SQRTH)
+			y = 0.5 + 0.5 * errorFunction(x);
+		else {
+			y = 0.5 * errorFunctionComplemented(z);
+			if (x > 0)
+				y = 1.0 - y;
+		}
+		return y;
 	}
-      z /= x;
-      x += 1.0;
-    }
-
-    while( x < 2.0 ) {
-      if( x == 0.0 ) {
-	throw new ArithmeticException("gamma: singular");
-      } else
-	if( x < 1.e-9 ) {
-	  return( z/((1.0 + 0.5772156649015329 * x) * x) );
+
+	/**
+	 * Returns the value, <tt>x</tt>, for which the area under the Normal (Gaussian)
+	 * probability density function (integrated from minus infinity to <tt>x</tt>)
+	 * is equal to the argument <tt>y</tt> (assumes mean is zero, variance is one).
+	 * <p>
+	 * For small arguments <tt>0 < y < exp(-2)</tt>, the program computes
+	 * <tt>z = sqrt( -2.0 * log(y) )</tt>; then the approximation is
+	 * <tt>x = z - log(z)/z  - (1/z) P(1/z) / Q(1/z)</tt>. There are two rational
+	 * functions P/Q, one for <tt>0 < y < exp(-32)</tt> and the other for <tt>y</tt>
+	 * up to <tt>exp(-2)</tt>. For larger arguments, <tt>w = y - 0.5</tt>, and
+	 * <tt>x/sqrt(2pi) = w + w**3 R(w**2)/S(w**2))</tt>.
+	 *
+	 * @param y0 the area under the normal pdf
+	 * @return the z-value
+	 */
+	public static double normalInverse(double y0) {
+
+		double x, y, z, y2, x0, x1;
+		int code;
+
+		final double s2pi = Math.sqrt(2.0 * Math.PI);
+
+		if (y0 <= 0.0)
+			throw new IllegalArgumentException();
+		if (y0 >= 1.0)
+			throw new IllegalArgumentException();
+		code = 1;
+		y = y0;
+		if (y > (1.0 - 0.13533528323661269189)) { /* 0.135... = exp(-2) */
+			y = 1.0 - y;
+			code = 0;
+		}
+
+		if (y > 0.13533528323661269189) {
+			y = y - 0.5;
+			y2 = y * y;
+			x = y + y * (y2 * polevl(y2, P0, 4) / p1evl(y2, Q0, 8));
+			x = x * s2pi;
+			return (x);
+		}
+
+		x = Math.sqrt(-2.0 * Math.log(y));
+		x0 = x - Math.log(x) / x;
+
+		z = 1.0 / x;
+		if (x < 8.0) /* y > exp(-32) = 1.2664165549e-14 */
+			x1 = z * polevl(z, P1, 8) / p1evl(z, Q1, 8);
+		else
+			x1 = z * polevl(z, P2, 8) / p1evl(z, Q2, 8);
+		x = x0 - x1;
+		if (code != 0)
+			x = -x;
+		return (x);
+	}
+
+	/**
+	 * Returns natural logarithm of gamma function.
+	 *
+	 * @param x the value
+	 * @return natural logarithm of gamma function
+	 */
+	public static double lnGamma(double x) {
+
+		double p, q, w, z;
+
+		double A[] = { 8.11614167470508450300E-4, -5.95061904284301438324E-4, 7.93650340457716943945E-4,
+				-2.77777777730099687205E-3, 8.33333333333331927722E-2 };
+		double B[] = { -1.37825152569120859100E3, -3.88016315134637840924E4, -3.31612992738871184744E5,
+				-1.16237097492762307383E6, -1.72173700820839662146E6, -8.53555664245765465627E5 };
+		double C[] = {
+				/* 1.00000000000000000000E0, */
+				-3.51815701436523470549E2, -1.70642106651881159223E4, -2.20528590553854454839E5,
+				-1.13933444367982507207E6, -2.53252307177582951285E6, -2.01889141433532773231E6 };
+
+		if (x < -34.0) {
+			q = -x;
+			w = lnGamma(q);
+			p = Math.floor(q);
+			if (p == q)
+				throw new ArithmeticException("lnGamma: Overflow");
+			z = q - p;
+			if (z > 0.5) {
+				p += 1.0;
+				z = p - q;
+			}
+			z = q * Math.sin(Math.PI * z);
+			if (z == 0.0)
+				throw new ArithmeticException("lnGamma: Overflow");
+			z = LOGPI - Math.log(z) - w;
+			return z;
+		}
+
+		if (x < 13.0) {
+			z = 1.0;
+			while (x >= 3.0) {
+				x -= 1.0;
+				z *= x;
+			}
+			while (x < 2.0) {
+				if (x == 0.0)
+					throw new ArithmeticException("lnGamma: Overflow");
+				z /= x;
+				x += 1.0;
+			}
+			if (z < 0.0)
+				z = -z;
+			if (x == 2.0)
+				return Math.log(z);
+			x -= 2.0;
+			p = x * polevl(x, B, 5) / p1evl(x, C, 6);
+			return (Math.log(z) + p);
+		}
+
+		if (x > 2.556348e305)
+			throw new ArithmeticException("lnGamma: Overflow");
+
+		q = (x - 0.5) * Math.log(x) - x + 0.91893853320467274178;
+
+		if (x > 1.0e8)
+			return (q);
+
+		p = 1.0 / (x * x);
+		if (x >= 1000.0)
+			q += ((7.9365079365079365079365e-4 * p - 2.7777777777777777777778e-3) * p + 0.0833333333333333333333) / x;
+		else
+			q += polevl(p, A, 4) / x;
+		return q;
+	}
+
+	/**
+	 * Returns the error function of the normal distribution. The integral is
+	 * 
+	 * <pre>
+	 *                           x 
+	 *                            -
+	 *                 2         | |          2
+	 *   erf(x)  =  --------     |    exp( - t  ) dt.
+	 *              sqrt(pi)   | |
+	 *                          -
+	 *                           0
+	 * </pre>
+	 * 
+	 * <b>Implementation:</b> For
+	 * <tt>0 <= |x| < 1, erf(x) = x * P4(x**2)/Q5(x**2)</tt>; otherwise
+	 * <tt>erf(x) = 1 - erfc(x)</tt>.
+	 * <p>
+	 * Code adapted from the
+	 * <A HREF="http://www.sci.usq.edu.au/staff/leighb/graph/Top.html"> Java 2D
+	 * Graph Package 2.4</A>, which in turn is a port from the
+	 * <A HREF="http://people.ne.mediaone.net/moshier/index.html#Cephes">Cephes
+	 * 2.2</A> Math Library (C).
+	 *
+	 * @param a the argument to the function.
+	 */
+	public static double errorFunction(double x) {
+		double y, z;
+		final double T[] = { 9.60497373987051638749E0, 9.00260197203842689217E1, 2.23200534594684319226E3,
+				7.00332514112805075473E3, 5.55923013010394962768E4 };
+		final double U[] = {
+				// 1.00000000000000000000E0,
+				3.35617141647503099647E1, 5.21357949780152679795E2, 4.59432382970980127987E3, 2.26290000613890934246E4,
+				4.92673942608635921086E4 };
+
+		if (Math.abs(x) > 1.0)
+			return (1.0 - errorFunctionComplemented(x));
+		z = x * x;
+		y = x * polevl(z, T, 4) / p1evl(z, U, 5);
+		return y;
+	}
+
+	/**
+	 * Returns the complementary Error function of the normal distribution.
+	 * 
+	 * <pre>
+	 *  1 - erf(x) =
+	 *
+	 *                           inf. 
+	 *                             -
+	 *                  2         | |          2
+	 *   erfc(x)  =  --------     |    exp( - t  ) dt
+	 *               sqrt(pi)   | |
+	 *                           -
+	 *                            x
+	 * </pre>
+	 * 
+	 * <b>Implementation:</b> For small x, <tt>erfc(x) = 1 - erf(x)</tt>; otherwise
+	 * rational approximations are computed.
+	 * <p>
+	 * Code adapted from the
+	 * <A HREF="http://www.sci.usq.edu.au/staff/leighb/graph/Top.html"> Java 2D
+	 * Graph Package 2.4</A>, which in turn is a port from the
+	 * <A HREF="http://people.ne.mediaone.net/moshier/index.html#Cephes">Cephes
+	 * 2.2</A> Math Library (C).
+	 *
+	 * @param a the argument to the function.
+	 */
+	public static double errorFunctionComplemented(double a) {
+		double x, y, z, p, q;
+
+		double P[] = { 2.46196981473530512524E-10, 5.64189564831068821977E-1, 7.46321056442269912687E0,
+				4.86371970985681366614E1, 1.96520832956077098242E2, 5.26445194995477358631E2, 9.34528527171957607540E2,
+				1.02755188689515710272E3, 5.57535335369399327526E2 };
+		double Q[] = {
+				// 1.0
+				1.32281951154744992508E1, 8.67072140885989742329E1, 3.54937778887819891062E2, 9.75708501743205489753E2,
+				1.82390916687909736289E3, 2.24633760818710981792E3, 1.65666309194161350182E3,
+				5.57535340817727675546E2 };
+
+		double R[] = { 5.64189583547755073984E-1, 1.27536670759978104416E0, 5.01905042251180477414E0,
+				6.16021097993053585195E0, 7.40974269950448939160E0, 2.97886665372100240670E0 };
+		double S[] = {
+				// 1.00000000000000000000E0,
+				2.26052863220117276590E0, 9.39603524938001434673E0, 1.20489539808096656605E1, 1.70814450747565897222E1,
+				9.60896809063285878198E0, 3.36907645100081516050E0 };
+
+		if (a < 0.0)
+			x = -a;
+		else
+			x = a;
+
+		if (x < 1.0)
+			return 1.0 - errorFunction(a);
+
+		z = -a * a;
+
+		if (z < -MAXLOG) {
+			if (a < 0)
+				return (2.0);
+			else
+				return (0.0);
+		}
+
+		z = Math.exp(z);
+
+		if (x < 8.0) {
+			p = polevl(x, P, 8);
+			q = p1evl(x, Q, 8);
+		} else {
+			p = polevl(x, R, 5);
+			q = p1evl(x, S, 6);
+		}
+
+		y = (z * p) / q;
+
+		if (a < 0)
+			y = 2.0 - y;
+
+		if (y == 0.0) {
+			if (a < 0)
+				return 2.0;
+			else
+				return (0.0);
+		}
+		return y;
+	}
+
+	/**
+	 * Evaluates the given polynomial of degree <tt>N</tt> at <tt>x</tt>. Evaluates
+	 * polynomial when coefficient of N is 1.0. Otherwise same as <tt>polevl()</tt>.
+	 * 
+	 * <pre>
+	 *                     2          N
+	 * y  =  C  + C x + C x  +...+ C x
+	 *        0    1     2          N
+	 *
+	 * Coefficients are stored in reverse order:
+	 *
+	 * coef[0] = C  , ..., coef[N] = C  .
+	 *            N                   0
+	 * </pre>
+	 * 
+	 * The function <tt>p1evl()</tt> assumes that <tt>coef[N] = 1.0</tt> and is
+	 * omitted from the array. Its calling arguments are otherwise the same as
+	 * <tt>polevl()</tt>.
+	 * <p>
+	 * In the interest of speed, there are no checks for out of bounds arithmetic.
+	 *
+	 * @param x    argument to the polynomial.
+	 * @param coef the coefficients of the polynomial.
+	 * @param N    the degree of the polynomial.
+	 */
+	public static double p1evl(double x, double coef[], int N) {
+
+		double ans;
+		ans = x + coef[0];
+
+		for (int i = 1; i < N; i++)
+			ans = ans * x + coef[i];
+
+		return ans;
+	}
+
+	/**
+	 * Evaluates the given polynomial of degree <tt>N</tt> at <tt>x</tt>.
+	 * 
+	 * <pre>
+	 *                     2          N
+	 * y  =  C  + C x + C x  +...+ C x
+	 *        0    1     2          N
+	 *
+	 * Coefficients are stored in reverse order:
+	 *
+	 * coef[0] = C  , ..., coef[N] = C  .
+	 *            N                   0
+	 * </pre>
+	 * 
+	 * In the interest of speed, there are no checks for out of bounds arithmetic.
+	 *
+	 * @param x    argument to the polynomial.
+	 * @param coef the coefficients of the polynomial.
+	 * @param N    the degree of the polynomial.
+	 */
+	public static double polevl(double x, double coef[], int N) {
+
+		double ans;
+		ans = coef[0];
+
+		for (int i = 1; i <= N; i++)
+			ans = ans * x + coef[i];
+
+		return ans;
+	}
+
+	/**
+	 * Returns the Incomplete Gamma function.
+	 * 
+	 * @param a the parameter of the gamma distribution.
+	 * @param x the integration end point.
+	 */
+	public static double incompleteGamma(double a, double x) {
+
+		double ans, ax, c, r;
+
+		if (x <= 0 || a <= 0)
+			return 0.0;
+
+		if (x > 1.0 && x > a)
+			return 1.0 - incompleteGammaComplement(a, x);
+
+		/* Compute x**a * exp(-x) / gamma(a) */
+		ax = a * Math.log(x) - x - lnGamma(a);
+		if (ax < -MAXLOG)
+			return (0.0);
+
+		ax = Math.exp(ax);
+
+		/* power series */
+		r = a;
+		c = 1.0;
+		ans = 1.0;
+
+		do {
+			r += 1.0;
+			c *= x / r;
+			ans += c;
+		} while (c / ans > MACHEP);
+
+		return (ans * ax / a);
+	}
+
+	/**
+	 * Returns the Complemented Incomplete Gamma function.
+	 * 
+	 * @param a the parameter of the gamma distribution.
+	 * @param x the integration start point.
+	 */
+	public static double incompleteGammaComplement(double a, double x) {
+
+		double ans, ax, c, yc, r, t, y, z;
+		double pk, pkm1, pkm2, qk, qkm1, qkm2;
+
+		if (x <= 0 || a <= 0)
+			return 1.0;
+
+		if (x < 1.0 || x < a)
+			return 1.0 - incompleteGamma(a, x);
+
+		ax = a * Math.log(x) - x - lnGamma(a);
+		if (ax < -MAXLOG)
+			return 0.0;
+
+		ax = Math.exp(ax);
+
+		/* continued fraction */
+		y = 1.0 - a;
+		z = x + y + 1.0;
+		c = 0.0;
+		pkm2 = 1.0;
+		qkm2 = x;
+		pkm1 = x + 1.0;
+		qkm1 = z * x;
+		ans = pkm1 / qkm1;
+
+		do {
+			c += 1.0;
+			y += 1.0;
+			z += 2.0;
+			yc = y * c;
+			pk = pkm1 * z - pkm2 * yc;
+			qk = qkm1 * z - qkm2 * yc;
+			if (qk != 0) {
+				r = pk / qk;
+				t = Math.abs((ans - r) / r);
+				ans = r;
+			} else
+				t = 1.0;
+
+			pkm2 = pkm1;
+			pkm1 = pk;
+			qkm2 = qkm1;
+			qkm1 = qk;
+			if (Math.abs(pk) > big) {
+				pkm2 *= biginv;
+				pkm1 *= biginv;
+				qkm2 *= biginv;
+				qkm1 *= biginv;
+			}
+		} while (t > MACHEP);
+
+		return ans * ax;
+	}
+
+	/**
+	 * Returns the Gamma function of the argument.
+	 */
+	public static double gamma(double x) {
+
+		double P[] = { 1.60119522476751861407E-4, 1.19135147006586384913E-3, 1.04213797561761569935E-2,
+				4.76367800457137231464E-2, 2.07448227648435975150E-1, 4.94214826801497100753E-1,
+				9.99999999999999996796E-1 };
+		double Q[] = { -2.31581873324120129819E-5, 5.39605580493303397842E-4, -4.45641913851797240494E-3,
+				1.18139785222060435552E-2, 3.58236398605498653373E-2, -2.34591795718243348568E-1,
+				7.14304917030273074085E-2, 1.00000000000000000320E0 };
+
+		double p, z;
+		int i;
+
+		double q = Math.abs(x);
+
+		if (q > 33.0) {
+			if (x < 0.0) {
+				p = Math.floor(q);
+				if (p == q)
+					throw new ArithmeticException("gamma: overflow");
+				i = (int) p;
+				z = q - p;
+				if (z > 0.5) {
+					p += 1.0;
+					z = q - p;
+				}
+				z = q * Math.sin(Math.PI * z);
+				if (z == 0.0)
+					throw new ArithmeticException("gamma: overflow");
+				z = Math.abs(z);
+				z = Math.PI / (z * stirlingFormula(q));
+
+				return -z;
+			} else {
+				return stirlingFormula(x);
+			}
+		}
+
+		z = 1.0;
+		while (x >= 3.0) {
+			x -= 1.0;
+			z *= x;
+		}
+
+		while (x < 0.0) {
+			if (x == 0.0) {
+				throw new ArithmeticException("gamma: singular");
+			} else if (x > -1.E-9) {
+				return (z / ((1.0 + 0.5772156649015329 * x) * x));
+			}
+			z /= x;
+			x += 1.0;
+		}
+
+		while (x < 2.0) {
+			if (x == 0.0) {
+				throw new ArithmeticException("gamma: singular");
+			} else if (x < 1.e-9) {
+				return (z / ((1.0 + 0.5772156649015329 * x) * x));
+			}
+			z /= x;
+			x += 1.0;
+		}
+
+		if ((x == 2.0) || (x == 3.0))
+			return z;
+
+		x -= 2.0;
+		p = polevl(x, P, 6);
+		q = polevl(x, Q, 7);
+		return z * p / q;
+	}
+
+	/**
+	 * Returns the Gamma function computed by Stirling's formula. The polynomial
+	 * STIR is valid for 33 <= x <= 172.
+	 */
+	public static double stirlingFormula(double x) {
+
+		double STIR[] = { 7.87311395793093628397E-4, -2.29549961613378126380E-4, -2.68132617805781232825E-3,
+				3.47222221605458667310E-3, 8.33333333333482257126E-2, };
+		double MAXSTIR = 143.01608;
+
+		double w = 1.0 / x;
+		double y = Math.exp(x);
+
+		w = 1.0 + w * polevl(w, STIR, 4);
+
+		if (x > MAXSTIR) {
+			/* Avoid overflow in Math.pow() */
+			double v = Math.pow(x, 0.5 * x - 0.25);
+			y = v * (v / y);
+		} else {
+			y = Math.pow(x, x - 0.5) / y;
+		}
+		y = SQTPI * y * w;
+		return y;
+	}
+
+	/**
+	 * Returns the Incomplete Beta Function evaluated from zero to <tt>xx</tt>.
+	 *
+	 * @param aa the alpha parameter of the beta distribution.
+	 * @param bb the beta parameter of the beta distribution.
+	 * @param xx the integration end point.
+	 */
+	public static double incompleteBeta(double aa, double bb, double xx) {
+
+		double a, b, t, x, xc, w, y;
+		boolean flag;
+
+		if (aa <= 0.0 || bb <= 0.0)
+			throw new ArithmeticException("ibeta: Domain error!");
+
+		if ((xx <= 0.0) || (xx >= 1.0)) {
+			if (xx == 0.0)
+				return 0.0;
+			if (xx == 1.0)
+				return 1.0;
+			throw new ArithmeticException("ibeta: Domain error!");
+		}
+
+		flag = false;
+		if ((bb * xx) <= 1.0 && xx <= 0.95) {
+			t = powerSeries(aa, bb, xx);
+			return t;
+		}
+
+		w = 1.0 - xx;
+
+		/* Reverse a and b if x is greater than the mean. */
+		if (xx > (aa / (aa + bb))) {
+			flag = true;
+			a = bb;
+			b = aa;
+			xc = xx;
+			x = w;
+		} else {
+			a = aa;
+			b = bb;
+			xc = w;
+			x = xx;
+		}
+
+		if (flag && (b * x) <= 1.0 && x <= 0.95) {
+			t = powerSeries(a, b, x);
+			if (t <= MACHEP)
+				t = 1.0 - MACHEP;
+			else
+				t = 1.0 - t;
+			return t;
+		}
+
+		/* Choose expansion for better convergence. */
+		y = x * (a + b - 2.0) - (a - 1.0);
+		if (y < 0.0)
+			w = incompleteBetaFraction1(a, b, x);
+		else
+			w = incompleteBetaFraction2(a, b, x) / xc;
+
+		/*
+		 * Multiply w by the factor a b _ _ _ x (1-x) | (a+b) / ( a | (a) | (b) ) .
+		 */
+
+		y = a * Math.log(x);
+		t = b * Math.log(xc);
+		if ((a + b) < MAXGAM && Math.abs(y) < MAXLOG && Math.abs(t) < MAXLOG) {
+			t = Math.pow(xc, b);
+			t *= Math.pow(x, a);
+			t /= a;
+			t *= w;
+			t *= gamma(a + b) / (gamma(a) * gamma(b));
+			if (flag) {
+				if (t <= MACHEP)
+					t = 1.0 - MACHEP;
+				else
+					t = 1.0 - t;
+			}
+			return t;
+		}
+		/* Resort to logarithms. */
+		y += t + lnGamma(a + b) - lnGamma(a) - lnGamma(b);
+		y += Math.log(w / a);
+		if (y < MINLOG)
+			t = 0.0;
+		else
+			t = Math.exp(y);
+
+		if (flag) {
+			if (t <= MACHEP)
+				t = 1.0 - MACHEP;
+			else
+				t = 1.0 - t;
+		}
+		return t;
+	}
+
+	/**
+	 * Continued fraction expansion #1 for incomplete beta integral.
+	 */
+	public static double incompleteBetaFraction1(double a, double b, double x) {
+
+		double xk, pk, pkm1, pkm2, qk, qkm1, qkm2;
+		double k1, k2, k3, k4, k5, k6, k7, k8;
+		double r, t, ans, thresh;
+		int n;
+
+		k1 = a;
+		k2 = a + b;
+		k3 = a;
+		k4 = a + 1.0;
+		k5 = 1.0;
+		k6 = b - 1.0;
+		k7 = k4;
+		k8 = a + 2.0;
+
+		pkm2 = 0.0;
+		qkm2 = 1.0;
+		pkm1 = 1.0;
+		qkm1 = 1.0;
+		ans = 1.0;
+		r = 1.0;
+		n = 0;
+		thresh = 3.0 * MACHEP;
+		do {
+			xk = -(x * k1 * k2) / (k3 * k4);
+			pk = pkm1 + pkm2 * xk;
+			qk = qkm1 + qkm2 * xk;
+			pkm2 = pkm1;
+			pkm1 = pk;
+			qkm2 = qkm1;
+			qkm1 = qk;
+
+			xk = (x * k5 * k6) / (k7 * k8);
+			pk = pkm1 + pkm2 * xk;
+			qk = qkm1 + qkm2 * xk;
+			pkm2 = pkm1;
+			pkm1 = pk;
+			qkm2 = qkm1;
+			qkm1 = qk;
+
+			if (qk != 0)
+				r = pk / qk;
+			if (r != 0) {
+				t = Math.abs((ans - r) / r);
+				ans = r;
+			} else
+				t = 1.0;
+
+			if (t < thresh)
+				return ans;
+
+			k1 += 1.0;
+			k2 += 1.0;
+			k3 += 2.0;
+			k4 += 2.0;
+			k5 += 1.0;
+			k6 -= 1.0;
+			k7 += 2.0;
+			k8 += 2.0;
+
+			if ((Math.abs(qk) + Math.abs(pk)) > big) {
+				pkm2 *= biginv;
+				pkm1 *= biginv;
+				qkm2 *= biginv;
+				qkm1 *= biginv;
+			}
+			if ((Math.abs(qk) < biginv) || (Math.abs(pk) < biginv)) {
+				pkm2 *= big;
+				pkm1 *= big;
+				qkm2 *= big;
+				qkm1 *= big;
+			}
+		} while (++n < 300);
+
+		return ans;
+	}
+
+	/**
+	 * Continued fraction expansion #2 for incomplete beta integral.
+	 */
+	public static double incompleteBetaFraction2(double a, double b, double x) {
+
+		double xk, pk, pkm1, pkm2, qk, qkm1, qkm2;
+		double k1, k2, k3, k4, k5, k6, k7, k8;
+		double r, t, ans, z, thresh;
+		int n;
+
+		k1 = a;
+		k2 = b - 1.0;
+		k3 = a;
+		k4 = a + 1.0;
+		k5 = 1.0;
+		k6 = a + b;
+		k7 = a + 1.0;
+		k8 = a + 2.0;
+
+		pkm2 = 0.0;
+		qkm2 = 1.0;
+		pkm1 = 1.0;
+		qkm1 = 1.0;
+		z = x / (1.0 - x);
+		ans = 1.0;
+		r = 1.0;
+		n = 0;
+		thresh = 3.0 * MACHEP;
+		do {
+			xk = -(z * k1 * k2) / (k3 * k4);
+			pk = pkm1 + pkm2 * xk;
+			qk = qkm1 + qkm2 * xk;
+			pkm2 = pkm1;
+			pkm1 = pk;
+			qkm2 = qkm1;
+			qkm1 = qk;
+
+			xk = (z * k5 * k6) / (k7 * k8);
+			pk = pkm1 + pkm2 * xk;
+			qk = qkm1 + qkm2 * xk;
+			pkm2 = pkm1;
+			pkm1 = pk;
+			qkm2 = qkm1;
+			qkm1 = qk;
+
+			if (qk != 0)
+				r = pk / qk;
+			if (r != 0) {
+				t = Math.abs((ans - r) / r);
+				ans = r;
+			} else
+				t = 1.0;
+
+			if (t < thresh)
+				return ans;
+
+			k1 += 1.0;
+			k2 -= 1.0;
+			k3 += 2.0;
+			k4 += 2.0;
+			k5 += 1.0;
+			k6 += 1.0;
+			k7 += 2.0;
+			k8 += 2.0;
+
+			if ((Math.abs(qk) + Math.abs(pk)) > big) {
+				pkm2 *= biginv;
+				pkm1 *= biginv;
+				qkm2 *= biginv;
+				qkm1 *= biginv;
+			}
+			if ((Math.abs(qk) < biginv) || (Math.abs(pk) < biginv)) {
+				pkm2 *= big;
+				pkm1 *= big;
+				qkm2 *= big;
+				qkm1 *= big;
+			}
+		} while (++n < 300);
+
+		return ans;
+	}
+
+	/**
+	 * Power series for incomplete beta integral. Use when b*x is small and x not
+	 * too close to 1.
+	 */
+	public static double powerSeries(double a, double b, double x) {
+
+		double s, t, u, v, n, t1, z, ai;
+
+		ai = 1.0 / a;
+		u = (1.0 - b) * x;
+		v = u / (a + 1.0);
+		t1 = v;
+		t = u;
+		n = 2.0;
+		s = 0.0;
+		z = MACHEP * ai;
+		while (Math.abs(v) > z) {
+			u = (n - b) * x / n;
+			t *= u;
+			v = t / (a + n);
+			s += v;
+			n += 1.0;
+		}
+		s += t1;
+		s += ai;
+
+		u = a * Math.log(x);
+		if ((a + b) < MAXGAM && Math.abs(u) < MAXLOG) {
+			t = gamma(a + b) / (gamma(a) * gamma(b));
+			s = s * t * Math.pow(x, a);
+		} else {
+			t = lnGamma(a + b) - lnGamma(a) - lnGamma(b) + u + Math.log(s);
+			if (t < MINLOG)
+				s = 0.0;
+			else
+				s = Math.exp(t);
+		}
+		return s;
 	}
-      z /= x;
-      x += 1.0;
-    }
-
-    if( (x == 2.0) || (x == 3.0) ) 	return z;
-
-    x -= 2.0;
-    p = polevl( x, P, 6 );
-    q = polevl( x, Q, 7 );
-    return  z * p / q;
-  }
-
-  /**
-   * Returns the Gamma function computed by Stirling's formula.
-   * The polynomial STIR is valid for 33 <= x <= 172.
-   */
-  public static double stirlingFormula(double x) {
-
-    double STIR[] = {
-      7.87311395793093628397E-4,
-      -2.29549961613378126380E-4,
-      -2.68132617805781232825E-3,
-      3.47222221605458667310E-3,
-      8.33333333333482257126E-2,
-    };
-    double MAXSTIR = 143.01608;
-
-    double w = 1.0/x;
-    double  y = Math.exp(x);
-
-    w = 1.0 + w * polevl( w, STIR, 4 );
-
-    if( x > MAXSTIR ) {
-      /* Avoid overflow in Math.pow() */
-      double v = Math.pow( x, 0.5 * x - 0.25 );
-      y = v * (v / y);
-    } else {
-      y = Math.pow( x, x - 0.5 ) / y;
-    }
-    y = SQTPI * y * w;
-    return y;
-  }
-
-  /**
-   * Returns the Incomplete Beta Function evaluated from zero to <tt>xx</tt>.
-   *
-   * @param aa the alpha parameter of the beta distribution.
-   * @param bb the beta parameter of the beta distribution.
-   * @param xx the integration end point.
-   */
-  public static double incompleteBeta( double aa, double bb, double xx ) {
-
-    double a, b, t, x, xc, w, y;
-    boolean flag;
-
-    if( aa <= 0.0 || bb <= 0.0 ) throw new 
-      ArithmeticException("ibeta: Domain error!");
-
-    if( (xx <= 0.0) || ( xx >= 1.0) ) {
-      if( xx == 0.0 ) return 0.0;
-      if( xx == 1.0 ) return 1.0;
-      throw new ArithmeticException("ibeta: Domain error!");
-    }
-
-    flag = false;
-    if( (bb * xx) <= 1.0 && xx <= 0.95) {
-      t = powerSeries(aa, bb, xx);
-      return t;
-    }
-
-    w = 1.0 - xx;
-
-    /* Reverse a and b if x is greater than the mean. */
-    if( xx > (aa/(aa+bb)) ) {
-      flag = true;
-      a = bb;
-      b = aa;
-      xc = xx;
-      x = w;
-    } else {
-      a = aa;
-      b = bb;
-      xc = w;
-      x = xx;
-    }
-
-    if( flag  && (b * x) <= 1.0 && x <= 0.95) {
-      t = powerSeries(a, b, x);
-      if( t <= MACHEP ) 	t = 1.0 - MACHEP;
-      else  		        t = 1.0 - t;
-      return t;
-    }
-
-    /* Choose expansion for better convergence. */
-    y = x * (a+b-2.0) - (a-1.0);
-    if( y < 0.0 )
-      w = incompleteBetaFraction1( a, b, x );
-    else
-      w = incompleteBetaFraction2( a, b, x ) / xc;
-
-    /* Multiply w by the factor
-       a      b   _             _     _
-       x  (1-x)   | (a+b) / ( a | (a) | (b) ) .   */
-
-    y = a * Math.log(x);
-    t = b * Math.log(xc);
-    if( (a+b) < MAXGAM && Math.abs(y) < MAXLOG && Math.abs(t) < MAXLOG ) {
-      t = Math.pow(xc,b);
-      t *= Math.pow(x,a);
-      t /= a;
-      t *= w;
-      t *= gamma(a+b) / (gamma(a) * gamma(b));
-      if( flag ) {
-	if( t <= MACHEP ) 	t = 1.0 - MACHEP;
-	else  		        t = 1.0 - t;
-      }
-      return t;
-    }
-    /* Resort to logarithms.  */
-    y += t + lnGamma(a+b) - lnGamma(a) - lnGamma(b);
-    y += Math.log(w/a);
-    if( y < MINLOG )
-      t = 0.0;
-    else
-      t = Math.exp(y);
-
-    if( flag ) {
-      if( t <= MACHEP ) 	t = 1.0 - MACHEP;
-      else  		        t = 1.0 - t;
-    }
-    return t;
-  }   
-
-  /**
-   * Continued fraction expansion #1 for incomplete beta integral.
-   */
-  public static double incompleteBetaFraction1( double a, double b, double x ) {
-
-    double xk, pk, pkm1, pkm2, qk, qkm1, qkm2;
-    double k1, k2, k3, k4, k5, k6, k7, k8;
-    double r, t, ans, thresh;
-    int n;
-
-    k1 = a;
-    k2 = a + b;
-    k3 = a;
-    k4 = a + 1.0;
-    k5 = 1.0;
-    k6 = b - 1.0;
-    k7 = k4;
-    k8 = a + 2.0;
-
-    pkm2 = 0.0;
-    qkm2 = 1.0;
-    pkm1 = 1.0;
-    qkm1 = 1.0;
-    ans = 1.0;
-    r = 1.0;
-    n = 0;
-    thresh = 3.0 * MACHEP;
-    do {
-      xk = -( x * k1 * k2 )/( k3 * k4 );
-      pk = pkm1 +  pkm2 * xk;
-      qk = qkm1 +  qkm2 * xk;
-      pkm2 = pkm1;
-      pkm1 = pk;
-      qkm2 = qkm1;
-      qkm1 = qk;
-
-      xk = ( x * k5 * k6 )/( k7 * k8 );
-      pk = pkm1 +  pkm2 * xk;
-      qk = qkm1 +  qkm2 * xk;
-      pkm2 = pkm1;
-      pkm1 = pk;
-      qkm2 = qkm1;
-      qkm1 = qk;
-
-      if( qk != 0 )		r = pk/qk;
-      if( r != 0 ) {
-	t = Math.abs( (ans - r)/r );
-	ans = r;
-      }	else
-	t = 1.0;
-
-      if( t < thresh ) return ans;
-
-      k1 += 1.0;
-      k2 += 1.0;
-      k3 += 2.0;
-      k4 += 2.0;
-      k5 += 1.0;
-      k6 -= 1.0;
-      k7 += 2.0;
-      k8 += 2.0;
-
-      if( (Math.abs(qk) + Math.abs(pk)) > big ) {
-	pkm2 *= biginv;
-	pkm1 *= biginv;
-	qkm2 *= biginv;
-	qkm1 *= biginv;
-      }
-      if( (Math.abs(qk) < biginv) || (Math.abs(pk) < biginv) ) {
-	pkm2 *= big;
-	pkm1 *= big;
-	qkm2 *= big;
-	qkm1 *= big;
-      }
-    } while( ++n < 300 );
-
-    return ans;
-  }   
-
-  /**
-   * Continued fraction expansion #2 for incomplete beta integral.
-   */
-  public static double incompleteBetaFraction2( double a, double b, double x ) {
-
-    double xk, pk, pkm1, pkm2, qk, qkm1, qkm2;
-    double k1, k2, k3, k4, k5, k6, k7, k8;
-    double r, t, ans, z, thresh;
-    int n;
-
-    k1 = a;
-    k2 = b - 1.0;
-    k3 = a;
-    k4 = a + 1.0;
-    k5 = 1.0;
-    k6 = a + b;
-    k7 = a + 1.0;;
-    k8 = a + 2.0;
-
-    pkm2 = 0.0;
-    qkm2 = 1.0;
-    pkm1 = 1.0;
-    qkm1 = 1.0;
-    z = x / (1.0-x);
-    ans = 1.0;
-    r = 1.0;
-    n = 0;
-    thresh = 3.0 * MACHEP;
-    do {
-      xk = -( z * k1 * k2 )/( k3 * k4 );
-      pk = pkm1 +  pkm2 * xk;
-      qk = qkm1 +  qkm2 * xk;
-      pkm2 = pkm1;
-      pkm1 = pk;
-      qkm2 = qkm1;
-      qkm1 = qk;
-
-      xk = ( z * k5 * k6 )/( k7 * k8 );
-      pk = pkm1 +  pkm2 * xk;
-      qk = qkm1 +  qkm2 * xk;
-      pkm2 = pkm1;
-      pkm1 = pk;
-      qkm2 = qkm1;
-      qkm1 = qk;
-
-      if( qk != 0 )  r = pk/qk;
-      if( r != 0 ) {
-	t = Math.abs( (ans - r)/r );
-	ans = r;
-      } else
-	t = 1.0;
-
-      if( t < thresh ) return ans;
-
-      k1 += 1.0;
-      k2 -= 1.0;
-      k3 += 2.0;
-      k4 += 2.0;
-      k5 += 1.0;
-      k6 += 1.0;
-      k7 += 2.0;
-      k8 += 2.0;
-
-      if( (Math.abs(qk) + Math.abs(pk)) > big ) {
-	pkm2 *= biginv;
-	pkm1 *= biginv;
-	qkm2 *= biginv;
-	qkm1 *= biginv;
-      }
-      if( (Math.abs(qk) < biginv) || (Math.abs(pk) < biginv) ) {
-	pkm2 *= big;
-	pkm1 *= big;
-	qkm2 *= big;
-	qkm1 *= big;
-      }
-    } while( ++n < 300 );
-
-    return ans;
-  }
-
-  /**
-   * Power series for incomplete beta integral.
-   * Use when b*x is small and x not too close to 1.  
-   */
-  public static double powerSeries( double a, double b, double x ) {
-
-    double s, t, u, v, n, t1, z, ai;
-    
-    ai = 1.0 / a;
-    u = (1.0 - b) * x;
-    v = u / (a + 1.0);
-    t1 = v;
-    t = u;
-    n = 2.0;
-    s = 0.0;
-    z = MACHEP * ai;
-    while( Math.abs(v) > z ) {
-      u = (n - b) * x / n;
-      t *= u;
-      v = t / (a + n);
-      s += v; 
-      n += 1.0;
-    }
-    s += t1;
-    s += ai;
-
-    u = a * Math.log(x);
-    if( (a+b) < MAXGAM && Math.abs(u) < MAXLOG ) {
-      t = gamma(a+b)/(gamma(a)*gamma(b));
-      s = s * t * Math.pow(x,a);
-    } else {
-      t = lnGamma(a+b) - lnGamma(a) - lnGamma(b) + u + Math.log(s);
-      if( t < MINLOG ) 	s = 0.0;
-      else  	            s = Math.exp(t);
-    }
-    return s;
-  }
-  
 
 }
diff --git a/moa/src/main/java/moa/core/StringUtils.java b/moa/src/main/java/moa/core/StringUtils.java
index b6c9e4325..fd8040a7b 100644
--- a/moa/src/main/java/moa/core/StringUtils.java
+++ b/moa/src/main/java/moa/core/StringUtils.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.core;
 
@@ -29,67 +29,65 @@
  */
 public class StringUtils {
 
-    public static final String newline = System.getProperty("line.separator");
+	public static final String newline = System.getProperty("line.separator");
 
-    public static String doubleToString(double value, int fractionDigits) {
-        return doubleToString(value, 0, fractionDigits);
-    }
+	public static String doubleToString(double value, int fractionDigits) {
+		return doubleToString(value, 0, fractionDigits);
+	}
 
-    public static String doubleToString(double value, int minFractionDigits,
-            int maxFractionDigits) {
-        DecimalFormat numberFormat = new DecimalFormat();
-        numberFormat.setMinimumFractionDigits(minFractionDigits);
-        numberFormat.setMaximumFractionDigits(maxFractionDigits);
-        return numberFormat.format(value);
-    }
+	public static String doubleToString(double value, int minFractionDigits, int maxFractionDigits) {
+		DecimalFormat numberFormat = new DecimalFormat();
+		numberFormat.setMinimumFractionDigits(minFractionDigits);
+		numberFormat.setMaximumFractionDigits(maxFractionDigits);
+		return numberFormat.format(value);
+	}
 
-    public static void appendNewline(StringBuilder out) {
-        out.append(newline);
-    }
+	public static void appendNewline(StringBuilder out) {
+		out.append(newline);
+	}
 
-    public static void appendIndent(StringBuilder out, int indent) {
-        for (int i = 0; i < indent; i++) {
-            out.append(' ');
-        }
-    }
+	public static void appendIndent(StringBuilder out, int indent) {
+		for (int i = 0; i < indent; i++) {
+			out.append(' ');
+		}
+	}
 
-    public static void appendIndented(StringBuilder out, int indent, String s) {
-        appendIndent(out, indent);
-        out.append(s);
-    }
+	public static void appendIndented(StringBuilder out, int indent, String s) {
+		appendIndent(out, indent);
+		out.append(s);
+	}
 
-    public static void appendNewlineIndented(StringBuilder out, int indent,
-            String s) {
-        appendNewline(out);
-        appendIndented(out, indent, s);
-    }
+	public static void appendNewlineIndented(StringBuilder out, int indent, String s) {
+		appendNewline(out);
+		appendIndented(out, indent, s);
+	}
 
-    public static String secondsToDHMSString(double seconds) {
-        if (seconds < 60) {
-            return doubleToString(seconds, 2, 2) + 's';
-        }
-        long secs = (int) (seconds);
-        long mins = secs / 60;
-        long hours = mins / 60;
-        long days = hours / 24;
-        secs %= 60;
-        mins %= 60;
-        hours %= 24;
-        StringBuilder result = new StringBuilder();
-        if (days > 0) {
-            result.append(days);
-            result.append('d');
-        }
-        if ((hours > 0) || (days > 0)) {
-            result.append(hours);
-            result.append('h');
-        }
-        if ((hours > 0) || (days > 0) || (mins > 0)) {
-            result.append(mins);
-            result.append('m');
-        }
-        result.append(secs);
-        result.append('s');
-        return result.toString();
-    }
+	public static String secondsToDHMSString(double seconds) {
+		if (seconds < 60) {
+			return doubleToString(seconds, 2, 2) + 's';
+		}
+		long secs = (int) (seconds);
+		long mins = secs / 60;
+		long hours = mins / 60;
+		long days = hours / 24;
+		secs %= 60;
+		mins %= 60;
+		hours %= 24;
+		StringBuilder result = new StringBuilder();
+		if (days > 0) {
+			result.append(days);
+			result.append('d');
+		}
+		if ((hours > 0) || (days > 0)) {
+			result.append(hours);
+			result.append('h');
+		}
+		if ((hours > 0) || (days > 0) || (mins > 0)) {
+			result.append(mins);
+			result.append('m');
+		}
+		result.append(secs);
+		result.append('s');
+		return result.toString();
+	}
 }
diff --git a/moa/src/main/java/moa/core/TimingUtils.java b/moa/src/main/java/moa/core/TimingUtils.java
index f373f002c..38008888d 100644
--- a/moa/src/main/java/moa/core/TimingUtils.java
+++ b/moa/src/main/java/moa/core/TimingUtils.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.core;
 
@@ -27,38 +27,38 @@
  */
 public class TimingUtils {
 
-    protected static boolean preciseThreadTimesAvailable = false;
+	protected static boolean preciseThreadTimesAvailable = false;
 
-    public static boolean enablePreciseTiming() {
-        if (!preciseThreadTimesAvailable) {
-            try {
-                java.lang.management.ThreadMXBean tmxb = java.lang.management.ManagementFactory.getThreadMXBean();
-                if (tmxb.isCurrentThreadCpuTimeSupported()) {
-                    tmxb.setThreadCpuTimeEnabled(true);
-                    preciseThreadTimesAvailable = true;
-                }
-            } catch (Throwable e) {
-                // ignore problems, just resort to inaccurate timing
-            }
-        }
-        return preciseThreadTimesAvailable;
-    }
+	public static boolean enablePreciseTiming() {
+		if (!preciseThreadTimesAvailable) {
+			try {
+				java.lang.management.ThreadMXBean tmxb = java.lang.management.ManagementFactory.getThreadMXBean();
+				if (tmxb.isCurrentThreadCpuTimeSupported()) {
+					tmxb.setThreadCpuTimeEnabled(true);
+					preciseThreadTimesAvailable = true;
+				}
+			} catch (Throwable e) {
+				// ignore problems, just resort to inaccurate timing
+			}
+		}
+		return preciseThreadTimesAvailable;
+	}
 
-    public static long getNanoCPUTimeOfCurrentThread() {
-        return getNanoCPUTimeOfThread(Thread.currentThread().getId());
-    }
+	public static long getNanoCPUTimeOfCurrentThread() {
+		return getNanoCPUTimeOfThread(Thread.currentThread().getId());
+	}
 
-    public static long getNanoCPUTimeOfThread(long threadID) {
-        if (preciseThreadTimesAvailable) {
-            long time = java.lang.management.ManagementFactory.getThreadMXBean().getThreadCpuTime(threadID);
-            if (time != -1) {
-                return time;
-            }
-        }
-        return System.nanoTime();
-    }
+	public static long getNanoCPUTimeOfThread(long threadID) {
+		if (preciseThreadTimesAvailable) {
+			long time = java.lang.management.ManagementFactory.getThreadMXBean().getThreadCpuTime(threadID);
+			if (time != -1) {
+				return time;
+			}
+		}
+		return System.nanoTime();
+	}
 
-    public static double nanoTimeToSeconds(long nanoTime) {
-        return nanoTime / 1000000000.0;
-    }
+	public static double nanoTimeToSeconds(long nanoTime) {
+		return nanoTime / 1000000000.0;
+	}
 }
diff --git a/moa/src/main/java/moa/core/Utils.java b/moa/src/main/java/moa/core/Utils.java
index 66dc03972..1712d634e 100644
--- a/moa/src/main/java/moa/core/Utils.java
+++ b/moa/src/main/java/moa/core/Utils.java
@@ -32,1881 +32,1818 @@
 /**
  * Class implementing some simple utility methods.
  *
- * @author Eibe Frank 
- * @author Yong Wang 
- * @author Len Trigg 
+ * @author Eibe Frank
+ * @author Yong Wang
+ * @author Len Trigg
  * @author Julien Prados
  * @version $Revision: 8080 $
  */
 public final class Utils {
 
-  /** The natural logarithm of 2. */
-  public static double log2 = Math.log(2);
-
-  /** The small deviation allowed in double comparisons. */
-  public static double SMALL = 1e-6;
-  
-  /**
-   * Tests if the given value codes "missing".
-   *
-   * @param val the value to be tested
-   * @return true if val codes "missing"
-   */
-  public static boolean isMissingValue(double val) {
-
-    return Double.isNaN(val);
-  }
-
-  /**
-   * Returns the value used to code a missing value.  Note that
-   * equality tests on this value will always return false, so use
-   * isMissingValue(double val) for testing..
-   *
-   * @return the value used as missing value.
-   */
-  public static double missingValue() {
-    
-    return Double.NaN;
-  }
-
-  /**
-   * Casting an object without "unchecked" compile-time warnings.
-   * Use only when absolutely necessary (e.g. when using clone()).
-   */
-  @SuppressWarnings("unchecked")
-    public static <T> T cast(Object x) {
-    return (T) x;
-  }
-  
-  
-
-  /**
-   * Returns the correlation coefficient of two double vectors.
-   *
-   * @param y1 double vector 1
-   * @param y2 double vector 2
-   * @param n the length of two double vectors
-   * @return the correlation coefficient
-   */
-  public static final double correlation(double y1[],double y2[],int n) {
-
-    int i;
-    double av1 = 0.0, av2 = 0.0, y11 = 0.0, y22 = 0.0, y12 = 0.0, c;
-    
-    if (n <= 1) {
-      return 1.0;
-    }
-    for (i = 0; i < n; i++) {
-      av1 += y1[i];
-      av2 += y2[i];
-    }
-    av1 /= (double) n;
-    av2 /= (double) n;
-    for (i = 0; i < n; i++) {
-      y11 += (y1[i] - av1) * (y1[i] - av1);
-      y22 += (y2[i] - av2) * (y2[i] - av2);
-      y12 += (y1[i] - av1) * (y2[i] - av2);
-    }
-    if (y11 * y22 == 0.0) {
-      c=1.0;
-    } else {
-      c = y12 / Math.sqrt(Math.abs(y11 * y22));
-    }
-    
-    return c;
-  }
-
-  /**
-   * Removes all occurrences of a string from another string.
-   *
-   * @param inString the string to remove substrings from.
-   * @param substring the substring to remove.
-   * @return the input string with occurrences of substring removed.
-   */
-  public static String removeSubstring(String inString, String substring) {
-
-    StringBuffer result = new StringBuffer();
-    int oldLoc = 0, loc = 0;
-    while ((loc = inString.indexOf(substring, oldLoc))!= -1) {
-      result.append(inString.substring(oldLoc, loc));
-      oldLoc = loc + substring.length();
-    }
-    result.append(inString.substring(oldLoc));
-    return result.toString();
-  }
-
-  /**
-   * Replaces with a new string, all occurrences of a string from 
-   * another string.
-   *
-   * @param inString the string to replace substrings in.
-   * @param subString the substring to replace.
-   * @param replaceString the replacement substring
-   * @return the input string with occurrences of substring replaced.
-   */
-  public static String replaceSubstring(String inString, String subString,
-					String replaceString) {
-
-    StringBuffer result = new StringBuffer();
-    int oldLoc = 0, loc = 0;
-    while ((loc = inString.indexOf(subString, oldLoc))!= -1) {
-      result.append(inString.substring(oldLoc, loc));
-      result.append(replaceString);
-      oldLoc = loc + subString.length();
-    }
-    result.append(inString.substring(oldLoc));
-    return result.toString();
-  }
-
-
-  /**
-   * Pads a string to a specified length, inserting spaces on the left
-   * as required. If the string is too long, characters are removed (from
-   * the right).
-   *
-   * @param inString the input string
-   * @param length the desired length of the output string
-   * @return the output string
-   */
-  public static String padLeft(String inString, int length) {
-
-    return fixStringLength(inString, length, false);
-  }
-  
-  /**
-   * Pads a string to a specified length, inserting spaces on the right
-   * as required. If the string is too long, characters are removed (from
-   * the right).
-   *
-   * @param inString the input string
-   * @param length the desired length of the output string
-   * @return the output string
-   */
-  public static String padRight(String inString, int length) {
-
-    return fixStringLength(inString, length, true);
-  }
-  
-  /**
-   * Pads a string to a specified length, inserting spaces as
-   * required. If the string is too long, characters are removed (from
-   * the right).
-   *
-   * @param inString the input string
-   * @param length the desired length of the output string
-   * @param right true if inserted spaces should be added to the right
-   * @return the output string
-   */
-  private static /*@pure@*/ String fixStringLength(String inString, int length,
-					boolean right) {
-
-    if (inString.length() < length) {
-      while (inString.length() < length) {
-	inString = (right ? inString.concat(" ") : " ".concat(inString));
-      }
-    } else if (inString.length() > length) {
-      inString = inString.substring(0, length);
-    }
-    return inString;
-  }
- 
-  /**
-   * Rounds a double and converts it into String.
-   *
-   * @param value the double value
-   * @param afterDecimalPoint the (maximum) number of digits permitted
-   * after the decimal point
-   * @return the double as a formatted string
-   */
-  public static /*@pure@*/ String doubleToString(double value, int afterDecimalPoint) {
-    
-    StringBuffer stringBuffer;
-    double temp;
-    int dotPosition;
-    long precisionValue;
-    
-    temp = value * Math.pow(10.0, afterDecimalPoint);
-    if (Math.abs(temp) < Long.MAX_VALUE) {
-      precisionValue = 	(temp > 0) ? (long)(temp + 0.5) 
-                                   : -(long)(Math.abs(temp) + 0.5);
-      if (precisionValue == 0) {
-	stringBuffer = new StringBuffer(String.valueOf(0));
-      } else {
-	stringBuffer = new StringBuffer(String.valueOf(precisionValue));
-      }
-      if (afterDecimalPoint == 0) {
-	return stringBuffer.toString();
-      }
-      dotPosition = stringBuffer.length() - afterDecimalPoint;
-      while (((precisionValue < 0) && (dotPosition < 1)) ||
-	     (dotPosition < 0)) {
-	if (precisionValue < 0) {
-	  stringBuffer.insert(1, '0');
-	} else {
-	  stringBuffer.insert(0, '0');
-	}
-	dotPosition++;
-      }
-      stringBuffer.insert(dotPosition, '.');
-      if ((precisionValue < 0) && (stringBuffer.charAt(1) == '.')) {
-	stringBuffer.insert(1, '0');
-      } else if (stringBuffer.charAt(0) == '.') {
-	stringBuffer.insert(0, '0');
-      }
-      int currentPos = stringBuffer.length() - 1;
-      while ((currentPos > dotPosition) &&
-	     (stringBuffer.charAt(currentPos) == '0')) {
-	stringBuffer.setCharAt(currentPos--, ' ');
-      }
-      if (stringBuffer.charAt(currentPos) == '.') {
-	stringBuffer.setCharAt(currentPos, ' ');
-      }
-      
-      return stringBuffer.toString().trim();
-    }
-    return new String("" + value);
-  }
-
-  /**
-   * Rounds a double and converts it into a formatted decimal-justified String.
-   * Trailing 0's are replaced with spaces.
-   *
-   * @param value the double value
-   * @param width the width of the string
-   * @param afterDecimalPoint the number of digits after the decimal point
-   * @return the double as a formatted string
-   */
-  public static /*@pure@*/ String doubleToString(double value, int width,
-				      int afterDecimalPoint) {
-    
-    String tempString = doubleToString(value, afterDecimalPoint);
-    char[] result;
-    int dotPosition;
-
-    if ((afterDecimalPoint >= width) 
-        || (tempString.indexOf('E') != -1)) { // Protects sci notation
-      return tempString;
-    }
-
-    // Initialize result
-    result = new char[width];
-    for (int i = 0; i < result.length; i++) {
-      result[i] = ' ';
-    }
-
-    if (afterDecimalPoint > 0) {
-      // Get position of decimal point and insert decimal point
-      dotPosition = tempString.indexOf('.');
-      if (dotPosition == -1) {
-	dotPosition = tempString.length();
-      } else {
-	result[width - afterDecimalPoint - 1] = '.';
-      }
-    } else {
-      dotPosition = tempString.length();
-    }
-    
-
-    int offset = width - afterDecimalPoint - dotPosition;
-    if (afterDecimalPoint > 0) {
-      offset--;
-    }
-
-    // Not enough room to decimal align within the supplied width
-    if (offset < 0) {
-      return tempString;
-    }
-
-    // Copy characters before decimal point
-    for (int i = 0; i < dotPosition; i++) {
-      result[offset + i] = tempString.charAt(i);
-    }
-
-    // Copy characters after decimal point
-    for (int i = dotPosition + 1; i < tempString.length(); i++) {
-      result[offset + i] = tempString.charAt(i);
-    }
-
-    return new String(result);
-  }
-
-  /**
-   * Returns the basic class of an array class (handles multi-dimensional
-   * arrays).
-   * @param c        the array to inspect
-   * @return         the class of the innermost elements
-   */
-  public static Class getArrayClass(Class c) {
-     if (c.getComponentType().isArray())
-        return getArrayClass(c.getComponentType());
-     else
-        return c.getComponentType();
-  }
-
-  /**
-   * Returns the dimensions of the given array. Even though the
-   * parameter is of type "Object" one can hand over primitve arrays, e.g.
-   * int[3] or double[2][4].
-   *
-   * @param array       the array to determine the dimensions for
-   * @return            the dimensions of the array
-   */
-  public static int getArrayDimensions(Class array) {
-    if (array.getComponentType().isArray())
-      return 1 + getArrayDimensions(array.getComponentType());
-    else
-      return 1;
-  }
-
-  /**
-   * Returns the dimensions of the given array. Even though the
-   * parameter is of type "Object" one can hand over primitve arrays, e.g.
-   * int[3] or double[2][4].
-   *
-   * @param array       the array to determine the dimensions for
-   * @return            the dimensions of the array
-   */
-  public static int getArrayDimensions(Object array) {
-    return getArrayDimensions(array.getClass());
-  }
-
-  /**
-   * Returns the given Array in a string representation. Even though the
-   * parameter is of type "Object" one can hand over primitve arrays, e.g.
-   * int[3] or double[2][4].
-   * 
-   * @param array       the array to return in a string representation
-   * @return            the array as string
-   */
-  public static String arrayToString(Object array) {
-    String        result;
-    int           dimensions;
-    int           i;       
-
-    result     = "";
-    dimensions = getArrayDimensions(array);
-    
-    if (dimensions == 0) {
-      result = "null";
-    }
-    else if (dimensions == 1) {
-      for (i = 0; i < Array.getLength(array); i++) {
-        if (i > 0)
-          result += ",";
-        if (Array.get(array, i) == null)
-          result += "null";
-        else
-          result += Array.get(array, i).toString();
-      }
-    }
-    else {
-      for (i = 0; i < Array.getLength(array); i++) {
-        if (i > 0)
-          result += ",";
-        result += "[" + arrayToString(Array.get(array, i)) + "]";
-      }
-    }
-    
-    return result;
-  }
-
-  /**
-   * Tests if a is equal to b.
-   *
-   * @param a a double
-   * @param b a double
-   */
-  public static /*@pure@*/ boolean eq(double a, double b){
-    
-    return (a - b < SMALL) && (b - a < SMALL); 
-  }
-
-  /**
-   * Checks if the given array contains any non-empty options.
-   *
-   * @param options an array of strings
-   * @exception Exception if there are any non-empty options
-   */
-  public static void checkForRemainingOptions(String[] options) 
-    throws Exception {
-    
-    int illegalOptionsFound = 0;
-    StringBuffer text = new StringBuffer();
-
-    if (options == null) {
-      return;
-    }
-    for (int i = 0; i < options.length; i++) {
-      if (options[i].length() > 0) {
-	illegalOptionsFound++;
-	text.append(options[i] + ' ');
-      }
-    }
-    if (illegalOptionsFound > 0) {
-      throw new Exception("Illegal options: " + text);
-    }
-  }
-  
-  /**
-   * Checks if the given array contains the flag "-Char". Stops
-   * searching at the first marker "--". If the flag is found,
-   * it is replaced with the empty string.
-   *
-   * @param flag the character indicating the flag.
-   * @param options the array of strings containing all the options.
-   * @return true if the flag was found
-   * @exception Exception if an illegal option was found
-   */
-  public static boolean getFlag(char flag, String[] options) 
-    throws Exception {
-    
-    return getFlag("" + flag, options);
-  }
-  
-  /**
-   * Checks if the given array contains the flag "-String". Stops
-   * searching at the first marker "--". If the flag is found,
-   * it is replaced with the empty string.
-   *
-   * @param flag the String indicating the flag.
-   * @param options the array of strings containing all the options.
-   * @return true if the flag was found
-   * @exception Exception if an illegal option was found
-   */
-  public static boolean getFlag(String flag, String[] options) 
-    throws Exception {
-    
-    int pos = getOptionPos(flag, options);
-
-    if (pos > -1)
-      options[pos] = "";
-    
-    return (pos > -1);
-  }
-
-  /**
-   * Gets an option indicated by a flag "-Char" from the given array
-   * of strings. Stops searching at the first marker "--". Replaces 
-   * flag and option with empty strings.
-   *
-   * @param flag the character indicating the option.
-   * @param options the array of strings containing all the options.
-   * @return the indicated option or an empty string
-   * @exception Exception if the option indicated by the flag can't be found
-   */
-  public static /*@non_null@*/ String getOption(char flag, String[] options) 
-    throws Exception {
-    
-    return getOption("" + flag, options);
-  }
-
-  /**
-   * Gets an option indicated by a flag "-String" from the given array
-   * of strings. Stops searching at the first marker "--". Replaces 
-   * flag and option with empty strings.
-   *
-   * @param flag the String indicating the option.
-   * @param options the array of strings containing all the options.
-   * @return the indicated option or an empty string
-   * @exception Exception if the option indicated by the flag can't be found
-   */
-  public static /*@non_null@*/ String getOption(String flag, String[] options) 
-    throws Exception {
-
-    String newString;
-    int i = getOptionPos(flag, options);
-
-    if (i > -1) {
-      if (options[i].equals("-" + flag)) {
-	if (i + 1 == options.length) {
-	  throw new Exception("No value given for -" + flag + " option.");
-	}
-	options[i] = "";
-	newString = new String(options[i + 1]);
-	options[i + 1] = "";
-	return newString;
-      }
-      if (options[i].charAt(1) == '-') {
-	return "";
-      }
-    }
-    
-    return "";
-  }
-
-  /**
-   * Gets the index of an option or flag indicated by a flag "-Char" from 
-   * the given array of strings. Stops searching at the first marker "--".
-   *
-   * @param flag 	the character indicating the option.
-   * @param options 	the array of strings containing all the options.
-   * @return 		the position if found, or -1 otherwise
-   */
-  public static int getOptionPos(char flag, String[] options) {
-     return getOptionPos("" + flag, options);
-  }
-
-  /**
-   * Gets the index of an option or flag indicated by a flag "-String" from 
-   * the given array of strings. Stops searching at the first marker "--".
-   *
-   * @param flag 	the String indicating the option.
-   * @param options 	the array of strings containing all the options.
-   * @return 		the position if found, or -1 otherwise
-   */
-  public static int getOptionPos(String flag, String[] options) {
-    if (options == null)
-      return -1;
-    
-    for (int i = 0; i < options.length; i++) {
-      if ((options[i].length() > 0) && (options[i].charAt(0) == '-')) {
-	// Check if it is a negative number
-	try {
-	  Double.valueOf(options[i]);
-	} 
-	catch (NumberFormatException e) {
-	  // found?
-	  if (options[i].equals("-" + flag))
-	    return i;
-	  // did we reach "--"?
-	  if (options[i].charAt(1) == '-')
-	    return -1;
-	}
-      }
-    }
-    
-    return -1;
-  }
-
-  /**
-   * Quotes a string if it contains special characters.
-   * 
-   * The following rules are applied:
-   *
-   * A character is backquoted version of it is one 
-   * of <tt>" ' % \ \n \r \t</tt>.
-   *
-   * A string is enclosed within single quotes if a character has been
-   * backquoted using the previous rule above or contains 
-   * <tt>{ }</tt> or is exactly equal to the strings 
-   * <tt>, ? space or ""</tt> (empty string).
-   *
-   * A quoted question mark distinguishes it from the missing value which
-   * is represented as an unquoted question mark in arff files.
-   *
-   * @param string 	the string to be quoted
-   * @return 		the string (possibly quoted)
-   * @see		#unquote(String)
-   */
-  public static /*@pure@*/ String quote(String string) {
-      boolean quote = false;
-
-      // backquote the following characters 
-      if ((string.indexOf('\n') != -1) || (string.indexOf('\r') != -1) || 
-	  (string.indexOf('\'') != -1) || (string.indexOf('"') != -1) || 
-	  (string.indexOf('\\') != -1) || 
-	  (string.indexOf('\t') != -1) || (string.indexOf('%') != -1) ||
-	  (string.indexOf('\u001E') != -1)) {
-	  string = backQuoteChars(string);
-	  quote = true;
-      }
-
-      // Enclose the string in 's if the string contains a recently added
-      // backquote or contains one of the following characters.
-      if((quote == true) || 
-	 (string.indexOf('{') != -1) || (string.indexOf('}') != -1) ||
-	 (string.indexOf(',') != -1) || (string.equals("?")) ||
-	 (string.indexOf(' ') != -1) || (string.equals(""))) {
-	  string = ("'".concat(string)).concat("'");
-      }
-
-      return string;
-  }
-
-  /**
-   * unquotes are previously quoted string (but only if necessary), i.e., it
-   * removes the single quotes around it. Inverse to quote(String).
-   * 
-   * @param string	the string to process
-   * @return		the unquoted string
-   * @see		#quote(String)
-   */
-  public static String unquote(String string) {
-    if (string.startsWith("'") && string.endsWith("'")) {
-      string = string.substring(1, string.length() - 1);
-      
-      if ((string.indexOf("\\n") != -1) || (string.indexOf("\\r") != -1) || 
-	  (string.indexOf("\\'") != -1) || (string.indexOf("\\\"") != -1) || 
-	  (string.indexOf("\\\\") != -1) || 
-	  (string.indexOf("\\t") != -1) || (string.indexOf("\\%") != -1) ||
-	  (string.indexOf("\\u001E") != -1)) {
-	string = unbackQuoteChars(string);
-      }
-    }
-
-    return string;
-  }
-
-  /**
-   * Converts carriage returns and new lines in a string into \r and \n.
-   * Backquotes the following characters: ` " \ \t and %
-   * 
-   * @param string 	the string
-   * @return 		the converted string
-   * @see		#unbackQuoteChars(String)
-   */
-  public static /*@pure@*/ String backQuoteChars(String string) {
-
-    int index;
-    StringBuffer newStringBuffer;
-
-    // replace each of the following characters with the backquoted version
-    char   charsFind[] =    {'\\',   '\'',  '\t',  '\n',  '\r',  '"',    '%', 
-        '\u001E'};
-    String charsReplace[] = {"\\\\", "\\'", "\\t", "\\n", "\\r", "\\\"", "\\%",
-        "\\u001E"};
-    for (int i = 0; i < charsFind.length; i++) {
-      if (string.indexOf(charsFind[i]) != -1 ) {
-	newStringBuffer = new StringBuffer();
-	while ((index = string.indexOf(charsFind[i])) != -1) {
-	  if (index > 0) {
-	    newStringBuffer.append(string.substring(0, index));
-	  }
-	  newStringBuffer.append(charsReplace[i]);
-	  if ((index + 1) < string.length()) {
-	    string = string.substring(index + 1);
-	  } else {
-	    string = "";
-	  }
-	}
-	newStringBuffer.append(string);
-	string = newStringBuffer.toString();
-      }
-    }
-
-    return string;
-  }
-
-  /**
-   * Converts carriage returns and new lines in a string into \r and \n.
-   *
-   * @param string the string
-   * @return the converted string
-   */
-  public static String convertNewLines(String string) {
-    int index;
-
-    // Replace with \n
-    StringBuffer newStringBuffer = new StringBuffer();
-    while ((index = string.indexOf('\n')) != -1) {
-      if (index > 0) {
-	newStringBuffer.append(string.substring(0, index));
-      }
-      newStringBuffer.append('\\');
-      newStringBuffer.append('n');
-      if ((index + 1) < string.length()) {
-	string = string.substring(index + 1);
-      } else {
-	string = "";
-      }
-    }
-    newStringBuffer.append(string);
-    string = newStringBuffer.toString();
-
-    // Replace with \r
-    newStringBuffer = new StringBuffer();
-    while ((index = string.indexOf('\r')) != -1) {
-      if (index > 0) {
-	newStringBuffer.append(string.substring(0, index));
-      }
-      newStringBuffer.append('\\');
-      newStringBuffer.append('r');
-      if ((index + 1) < string.length()){
-	string = string.substring(index + 1);
-      } else {
-	string = "";
-      }
-    }
-    newStringBuffer.append(string);
-    return newStringBuffer.toString();
-  }
-
-  /**
-   * Reverts \r and \n in a string into carriage returns and new lines.
-   * 
-   * @param string the string
-   * @return the converted string
-   */
-  public static String revertNewLines(String string) {
-    int index;
-
-    // Replace with \n
-    StringBuffer newStringBuffer = new StringBuffer();
-    while ((index = string.indexOf("\\n")) != -1) {
-      if (index > 0) {
-	newStringBuffer.append(string.substring(0, index));
-      }
-      newStringBuffer.append('\n');
-      if ((index + 2) < string.length()) {
-	string = string.substring(index + 2);
-      } else {
-	string = "";
-      }
-    }
-    newStringBuffer.append(string);
-    string = newStringBuffer.toString();
-
-    // Replace with \r
-    newStringBuffer = new StringBuffer();
-    while ((index = string.indexOf("\\r")) != -1) {
-      if (index > 0) {
-	newStringBuffer.append(string.substring(0, index));
-      }
-      newStringBuffer.append('\r');
-      if ((index + 2) < string.length()){
-	string = string.substring(index + 2);
-      } else {
-	string = "";
-      }
-    }
-    newStringBuffer.append(string);
-    
-    return newStringBuffer.toString();
-  }
-
-  /**
-   * Returns the secondary set of options (if any) contained in
-   * the supplied options array. The secondary set is defined to
-   * be any options after the first "--". These options are removed from
-   * the original options array.
-   *
-   * @param options the input array of options
-   * @return the array of secondary options
-   */
-  public static String[] partitionOptions(String[] options) {
-
-    for (int i = 0; i < options.length; i++) {
-      if (options[i].equals("--")) {
-	options[i++] = "";
-	String[] result = new String [options.length - i];
-	for (int j = i; j < options.length; j++) {
-	  result[j - i] = options[j];
-	  options[j] = "";
-	}
-	return result;
-      }
-    }
-    return new String [0];
-  }
-    
-  /**
-   * The inverse operation of backQuoteChars().
-   * Converts back-quoted carriage returns and new lines in a string 
-   * to the corresponding character ('\r' and '\n').
-   * Also "un"-back-quotes the following characters: ` " \ \t and %
-   *
-   * @param string 	the string
-   * @return 		the converted string
-   * @see		#backQuoteChars(String)
-   */
-  public static String unbackQuoteChars(String string) {
-
-    int index;
-    StringBuffer newStringBuffer;
-    
-    // replace each of the following characters with the backquoted version
-    String charsFind[]    = {"\\\\", "\\'", "\\t", "\\n", "\\r", "\\\"", "\\%",
-        "\\u001E"};
-    char   charsReplace[] = {'\\',   '\'',  '\t',  '\n',  '\r',  '"',    '%',
-        '\u001E'};
-    int pos[] = new int[charsFind.length];
-    int	curPos;
-    
-    String str = new String(string);
-    newStringBuffer = new StringBuffer();
-    while (str.length() > 0) {
-      // get positions and closest character to replace
-      curPos = str.length();
-      index  = -1;
-      for (int i = 0; i < pos.length; i++) {
-	pos[i] = str.indexOf(charsFind[i]);
-	if ( (pos[i] > -1) && (pos[i] < curPos) ) {
-	  index  = i;
-	  curPos = pos[i];
-	}
-      }
-      
-      // replace character if found, otherwise finished
-      if (index == -1) {
-	newStringBuffer.append(str);
-	str = "";
-      }
-      else {
-	newStringBuffer.append(str.substring(0, pos[index]));
-	newStringBuffer.append(charsReplace[index]);
-	str = str.substring(pos[index] + charsFind[index].length());
-      }
-    }
-
-    return newStringBuffer.toString();
-  }    
-  
-  /**
-   * Split up a string containing options into an array of strings,
-   * one for each option.
-   *
-   * @param 		quotedOptionString the string containing the options
-   * @return 		the array of options
-   * @throws Exception 	in case of an unterminated string, unknown character or
-   * 			a parse error
-   */
-  public static String[] splitOptions(String quotedOptionString) throws Exception{
-
-    Vector<String> optionsVec = new Vector<String>();
-    String str = new String(quotedOptionString);
-    int i;
-    
-    while (true){
-
-      //trimLeft 
-      i = 0;
-      while ((i < str.length()) && (Character.isWhitespace(str.charAt(i)))) i++;
-      str = str.substring(i);
-      
-      //stop when str is empty
-      if (str.length() == 0) break;
-      
-      //if str start with a double quote
-      if (str.charAt(0) == '"'){
-	
-	//find the first not anti-slached double quote
-	i = 1;
-	while(i < str.length()){
-	  if (str.charAt(i) == str.charAt(0)) break;
-	  if (str.charAt(i) == '\\'){
-	    i += 1;
-	    if (i >= str.length()) 
-	      throw new Exception("String should not finish with \\");
-	  }
-	  i += 1;
-	}
-	if (i >= str.length()) throw new Exception("Quote parse error.");
-	
-	//add the founded string to the option vector (without quotes)
-	String optStr = str.substring(1,i);
-	optStr = unbackQuoteChars(optStr);
-	optionsVec.addElement(optStr);
-	str = str.substring(i+1);
-      } else {
-	//find first whiteSpace
-	i=0;
-	while((i < str.length()) && (!Character.isWhitespace(str.charAt(i)))) i++;
-	
-	//add the founded string to the option vector
-	String optStr = str.substring(0,i);
-	optionsVec.addElement(optStr);
-	str = str.substring(i);
-      }
-    }
-    
-    //convert optionsVec to an array of String
-    String[] options = new String[optionsVec.size()];
-    for (i = 0; i < optionsVec.size(); i++) {
-      options[i] = (String)optionsVec.elementAt(i);
-    }
-    return options;
-  }    
-
-  /**
-   * Joins all the options in an option array into a single string,
-   * as might be used on the command line.
-   *
-   * @param optionArray the array of options
-   * @return the string containing all options.
-   */
-  public static String joinOptions(String[] optionArray) {
-
-    String optionString = "";
-    for (int i = 0; i < optionArray.length; i++) {
-      if (optionArray[i].equals("")) {
-	continue;
-      }
-      boolean escape = false;
-      for (int n = 0; n < optionArray[i].length(); n++) {
-	if (Character.isWhitespace(optionArray[i].charAt(n))) {
-	  escape = true;
-	  break;
-	}
-      }
-      if (escape) {
-	optionString += '"' + backQuoteChars(optionArray[i]) + '"';
-      } else {
-	optionString += optionArray[i];
-      }
-      optionString += " ";
-    }
-    return optionString.trim();
-  }
-  
-  
-  /**
-   * Computes entropy for an array of integers.
-   *
-   * @param counts array of counts
-   * @return - a log2 a - b log2 b - c log2 c + (a+b+c) log2 (a+b+c)
-   * when given array [a b c]
-   */
-  public static /*@pure@*/ double info(int counts[]) {
-    
-    int total = 0;
-    double x = 0;
-    for (int j = 0; j < counts.length; j++) {
-      x -= xlogx(counts[j]);
-      total += counts[j];
-    }
-    return x + xlogx(total);
-  }
-
-  /**
-   * Tests if a is smaller or equal to b.
-   *
-   * @param a a double
-   * @param b a double
-   */
-  public static /*@pure@*/ boolean smOrEq(double a,double b) {
-    
-    return (a-b < SMALL);
-  }
-
-  /**
-   * Tests if a is greater or equal to b.
-   *
-   * @param a a double
-   * @param b a double
-   */
-  public static /*@pure@*/ boolean grOrEq(double a,double b) {
-    
-    return (b-a < SMALL);
-  }
-  
-  /**
-   * Tests if a is smaller than b.
-   *
-   * @param a a double
-   * @param b a double
-   */
-  public static /*@pure@*/ boolean sm(double a,double b) {
-    
-    return (b-a > SMALL);
-  }
-
-  /**
-   * Tests if a is greater than b.
-   *
-   * @param a a double
-   * @param b a double 
-   */
-  public static /*@pure@*/ boolean gr(double a,double b) {
-    
-    return (a-b > SMALL);
-  }
-
-  /**
-   * Returns the kth-smallest value in the array.
-   *
-   * @param array the array of integers
-   * @param k the value of k
-   * @return the kth-smallest value
-   */
-  public static double kthSmallestValue(int[] array, int k) {
-
-    int[] index = new int[array.length];
-    
-    for (int i = 0; i < index.length; i++) {
-      index[i] = i;
-    }
-
-    return array[index[select(array, index, 0, array.length - 1, k)]];
-  }
-
-  /**
-   * Returns the kth-smallest value in the array
-   *
-   * @param array the array of double
-   * @param k the value of k
-   * @return the kth-smallest value
-   */
-  public static double kthSmallestValue(double[] array, int k) {
-
-    int[] index = new int[array.length];
-    
-    for (int i = 0; i < index.length; i++) {
-      index[i] = i;
-    }
-
-    return array[index[select(array, index, 0, array.length - 1, k)]];
-  }
-
-  /**
-   * Returns the logarithm of a for base 2.
-   *
-   * @param a 	a double
-   * @return	the logarithm for base 2
-   */
-  public static /*@pure@*/ double log2(double a) {
-    
-    return Math.log(a) / log2;
-  }
-
-  /**
-   * Returns index of maximum element in a given
-   * array of doubles. First maximum is returned.
-   *
-   * @param doubles the array of doubles
-   * @return the index of the maximum element
-   */
-  public static /*@pure@*/ int maxIndex(double[] doubles) {
-
-    double maximum = 0;
-    int maxIndex = 0;
-
-    for (int i = 0; i < doubles.length; i++) {
-      if ((i == 0) || (doubles[i] > maximum)) {
-	maxIndex = i;
-	maximum = doubles[i];
-      }
-    }
-
-    return maxIndex;
-  }
-
-  /**
-   * Returns index of maximum element in a given
-   * array of doubles. First maximum is returned.
-   *
-   * @param doubles the array of doubles
-   * @return the index of the maximum element
-   */
-  public static /*@pure@*/ int maxIndex(Prediction prediction) {
-
-    return maxIndex(prediction.asDoubleArray());
-  }
-
-  
-  /**
-   * Returns index of maximum element in a given
-   * array of integers. First maximum is returned.
-   *
-   * @param ints the array of integers
-   * @return the index of the maximum element
-   */
-  public static /*@pure@*/ int maxIndex(int[] ints) {
-
-    int maximum = 0;
-    int maxIndex = 0;
-
-    for (int i = 0; i < ints.length; i++) {
-      if ((i == 0) || (ints[i] > maximum)) {
-	maxIndex = i;
-	maximum = ints[i];
-      }
-    }
-
-    return maxIndex;
-  }
-
-  /**
-   * Computes the mean for an array of doubles.
-   *
-   * @param vector the array
-   * @return the mean
-   */
-  public static /*@pure@*/ double mean(double[] vector) {
-  
-    double sum = 0;
-
-    if (vector.length == 0) {
-      return 0;
-    }
-    for (int i = 0; i < vector.length; i++) {
-      sum += vector[i];
-    }
-    return sum / (double) vector.length;
-  }
-
-  /**
-   * Returns index of minimum element in a given
-   * array of integers. First minimum is returned.
-   *
-   * @param ints the array of integers
-   * @return the index of the minimum element
-   */
-  public static /*@pure@*/ int minIndex(int[] ints) {
-
-    int minimum = 0;
-    int minIndex = 0;
-
-    for (int i = 0; i < ints.length; i++) {
-      if ((i == 0) || (ints[i] < minimum)) {
-	minIndex = i;
-	minimum = ints[i];
-      }
-    }
-
-    return minIndex;
-  }
-
-  /**
-   * Returns index of minimum element in a given
-   * array of doubles. First minimum is returned.
-   *
-   * @param doubles the array of doubles
-   * @return the index of the minimum element
-   */
-  public static /*@pure@*/ int minIndex(double[] doubles) {
-
-    double minimum = 0;
-    int minIndex = 0;
-
-    for (int i = 0; i < doubles.length; i++) {
-      if ((i == 0) || (doubles[i] < minimum)) {
-	minIndex = i;
-	minimum = doubles[i];
-      }
-    }
-
-    return minIndex;
-  }
-
-  /**
-   * Normalizes the doubles in the array by their sum.
-   *
-   * @param doubles the array of double
-   * @exception IllegalArgumentException if sum is Zero or NaN
-   */
-  public static void normalize(double[] doubles) {
-
-    double sum = 0;
-    for (int i = 0; i < doubles.length; i++) {
-      sum += doubles[i];
-    }
-    normalize(doubles, sum);
-  }
-
-  /**
-   * Normalizes the doubles in the array using the given value.
-   *
-   * @param doubles the array of double
-   * @param sum the value by which the doubles are to be normalized
-   * @exception IllegalArgumentException if sum is zero or NaN
-   */
-  public static void normalize(double[] doubles, double sum) {
-
-    if (Double.isNaN(sum)) {
-      throw new IllegalArgumentException("Can't normalize array. Sum is NaN.");
-    }
-    if (sum == 0) {
-      // Maybe this should just be a return.
-      throw new IllegalArgumentException("Can't normalize array. Sum is zero.");
-    }
-    for (int i = 0; i < doubles.length; i++) {
-      doubles[i] /= sum;
-    }
-  }
-
-  /**
-   * Converts an array containing the natural logarithms of
-   * probabilities stored in a vector back into probabilities.
-   * The probabilities are assumed to sum to one.
-   *
-   * @param a an array holding the natural logarithms of the probabilities
-   * @return the converted array 
-   */
-  public static double[] logs2probs(double[] a) {
-
-    double max = a[maxIndex(a)];
-    double sum = 0.0;
-
-    double[] result = new double[a.length];
-    for(int i = 0; i < a.length; i++) {
-      result[i] = Math.exp(a[i] - max);
-      sum += result[i];
-    }
-
-    normalize(result, sum);
-
-    return result;
-  } 
-
-  /**
-   * Returns the log-odds for a given probabilitiy.
-   *
-   * @param prob the probabilitiy
-   *
-   * @return the log-odds after the probability has been mapped to
-   * [Utils.SMALL, 1-Utils.SMALL]
-   */
-  public static /*@pure@*/ double probToLogOdds(double prob) {
-
-    if (gr(prob, 1) || (sm(prob, 0))) {
-      throw new IllegalArgumentException("probToLogOdds: probability must " +
-				     "be in [0,1] "+prob);
-    }
-    double p = SMALL + (1.0 - 2 * SMALL) * prob;
-    return Math.log(p / (1 - p));
-  }
-
-  /**
-   * Rounds a double to the next nearest integer value. The JDK version
-   * of it doesn't work properly.
-   *
-   * @param value the double value
-   * @return the resulting integer value
-   */
-  public static /*@pure@*/ int round(double value) {
-
-    int roundedValue = value > 0
-      ? (int)(value + 0.5)
-      : -(int)(Math.abs(value) + 0.5);
-    
-    return roundedValue;
-  }
-
-  /**
-   * Rounds a double to the next nearest integer value in a probabilistic
-   * fashion (e.g. 0.8 has a 20% chance of being rounded down to 0 and a
-   * 80% chance of being rounded up to 1). In the limit, the average of
-   * the rounded numbers generated by this procedure should converge to
-   * the original double.
-   *
-   * @param value the double value
-   * @param rand the random number generator
-   * @return the resulting integer value
-   */
-  public static int probRound(double value, Random rand) {
-
-    if (value >= 0) {
-      double lower = Math.floor(value);
-      double prob = value - lower;
-      if (rand.nextDouble() < prob) {
-	return (int)lower + 1;
-      } else {
-	return (int)lower;
-      }
-    } else {
-      double lower = Math.floor(Math.abs(value));
-      double prob = Math.abs(value) - lower;
-      if (rand.nextDouble() < prob) {
-	return -((int)lower + 1);
-      } else {
-	return -(int)lower;
-      }
-    }
-  }
-
-  /**
-   * Rounds a double to the given number of decimal places.
-   *
-   * @param value the double value
-   * @param afterDecimalPoint the number of digits after the decimal point
-   * @return the double rounded to the given precision
-   */
-  public static /*@pure@*/ double roundDouble(double value,int afterDecimalPoint) {
-
-    double mask = Math.pow(10.0, (double)afterDecimalPoint);
-
-    return (double)(Math.round(value * mask)) / mask;
-  }
-
-  /**
-   * Sorts a given array of integers in ascending order and returns an 
-   * array of integers with the positions of the elements of the original 
-   * array in the sorted array. The sort is stable. (Equal elements remain
-   * in their original order.)
-   *
-   * @param array this array is not changed by the method!
-   * @return an array of integers with the positions in the sorted
-   * array.
-   */
-  public static /*@pure@*/ int[] sort(int[] array) {
-
-    int[] index = new int[array.length];
-    int[] newIndex = new int[array.length];
-    int[] helpIndex;
-    int numEqual;
-    
-    for (int i = 0; i < index.length; i++) {
-      index[i] = i;
-    }
-    quickSort(array, index, 0, array.length - 1);
-
-    // Make sort stable
-    int i = 0;
-    while (i < index.length) {
-      numEqual = 1;
-      for (int j = i + 1; ((j < index.length)
-			   && (array[index[i]] == array[index[j]]));
-	   j++) {
-	numEqual++;
-      }
-      if (numEqual > 1) {
-	helpIndex = new int[numEqual];
-	for (int j = 0; j < numEqual; j++) {
-	  helpIndex[j] = i + j;
-	}
-	quickSort(index, helpIndex, 0, numEqual - 1);
-	for (int j = 0; j < numEqual; j++) {
-	  newIndex[i + j] = index[helpIndex[j]];
-	}
-	i += numEqual;
-      } else {
-	newIndex[i] = index[i];
-	i++;
-      }
-    }
-    return newIndex;
-  }
-
-  /**
-   * Sorts a given array of doubles in ascending order and returns an
-   * array of integers with the positions of the elements of the
-   * original array in the sorted array. NOTE THESE CHANGES: the sort
-   * is no longer stable and it doesn't use safe floating-point
-   * comparisons anymore. Occurrences of Double.NaN are treated as 
-   * Double.MAX_VALUE
-   *
-   * @param array this array is not changed by the method!
-   * @return an array of integers with the positions in the sorted
-   * array.  
-   */
-  public static /*@pure@*/ int[] sort(/*@non_null@*/ double[] array) {
-
-    int[] index = new int[array.length];
-    array = (double[])array.clone();
-    for (int i = 0; i < index.length; i++) {
-      index[i] = i;
-      if (Double.isNaN(array[i])) {
-        array[i] = Double.MAX_VALUE;
-      }
-    }
-    quickSort(array, index, 0, array.length - 1);
-    return index;
-  }
-
-  /**
-   * Sorts a given array of doubles in ascending order and returns an 
-   * array of integers with the positions of the elements of the original 
-   * array in the sorted array. The sort is stable (Equal elements remain
-   * in their original order.) Occurrences of Double.NaN are treated as 
-   * Double.MAX_VALUE
-   *
-   * @param array this array is not changed by the method!
-   * @return an array of integers with the positions in the sorted
-   * array.
-   */
-  public static /*@pure@*/ int[] stableSort(double[] array){
-
-    int[] index = new int[array.length];
-    int[] newIndex = new int[array.length];
-    int[] helpIndex;
-    int numEqual;
-    
-    array = (double[])array.clone();
-    for (int i = 0; i < index.length; i++) {
-      index[i] = i;
-      if (Double.isNaN(array[i])) {
-        array[i] = Double.MAX_VALUE;
-      }
-    }
-    quickSort(array,index,0,array.length-1);
-
-    // Make sort stable
-
-    int i = 0;
-    while (i < index.length) {
-      numEqual = 1;
-      for (int j = i+1; ((j < index.length) && Utils.eq(array[index[i]],
-							array[index[j]])); j++)
-	numEqual++;
-      if (numEqual > 1) {
-	helpIndex = new int[numEqual];
-	for (int j = 0; j < numEqual; j++)
-	  helpIndex[j] = i+j;
-	quickSort(index, helpIndex, 0, numEqual-1);
-	for (int j = 0; j < numEqual; j++) 
-	  newIndex[i+j] = index[helpIndex[j]];
-	i += numEqual;
-      } else {
-	newIndex[i] = index[i];
-	i++;
-      }
-    }
-
-    return newIndex;
-  }
-
-  /**
-   * Computes the variance for an array of doubles.
-   *
-   * @param vector the array
-   * @return the variance
-   */
-  public static /*@pure@*/ double variance(double[] vector) {
-  
-    double sum = 0, sumSquared = 0;
-
-    if (vector.length <= 1) {
-      return 0;
-    }
-    for (int i = 0; i < vector.length; i++) {
-      sum += vector[i];
-      sumSquared += (vector[i] * vector[i]);
-    }
-    double result = (sumSquared - (sum * sum / (double) vector.length)) / 
-      (double) (vector.length - 1);
-
-    // We don't like negative variance
-    if (result < 0) {
-      return 0;
-    } else {
-      return result;
-    }
-  }
-
-  /**
-   * Computes the sum of the elements of an array of doubles.
-   *
-   * @param doubles the array of double
-   * @return the sum of the elements
-   */
-  public static /*@pure@*/ double sum(double[] doubles) {
-
-    double sum = 0;
-
-    for (int i = 0; i < doubles.length; i++) {
-      sum += doubles[i];
-    }
-    return sum;
-  }
-
-  /**
-   * Computes the sum of the elements of an array of integers.
-   *
-   * @param ints the array of integers
-   * @return the sum of the elements
-   */
-  public static /*@pure@*/ int sum(int[] ints) {
-
-    int sum = 0;
-
-    for (int i = 0; i < ints.length; i++) {
-      sum += ints[i];
-    }
-    return sum;
-  }
-
-  /**
-   * Returns c*log2(c) for a given integer value c.
-   *
-   * @param c an integer value
-   * @return c*log2(c) (but is careful to return 0 if c is 0)
-   */
-  public static /*@pure@*/ double xlogx(int c) {
-    
-    if (c == 0) {
-      return 0.0;
-    }
-    return c * Utils.log2((double) c);
-  }
-
-  /**
-   * Partitions the instances around a pivot. Used by quicksort and
-   * kthSmallestValue.
-   *
-   * @param array the array of doubles to be sorted
-   * @param index the index into the array of doubles
-   * @param l the first index of the subset 
-   * @param r the last index of the subset 
-   *
-   * @return the index of the middle element
-   */
-  private static int partition(double[] array, int[] index, int l, int r) {
-    
-    double pivot = array[index[(l + r) / 2]];
-    int help;
-
-    while (l < r) {
-      while ((array[index[l]] < pivot) && (l < r)) {
-        l++;
-      }
-      while ((array[index[r]] > pivot) && (l < r)) {
-        r--;
-      }
-      if (l < r) {
-        help = index[l];
-        index[l] = index[r];
-        index[r] = help;
-        l++;
-        r--;
-      }
-    }
-    if ((l == r) && (array[index[r]] > pivot)) {
-      r--;
-    } 
-
-    return r;
-  }
-
-  /**
-   * Partitions the instances around a pivot. Used by quicksort and
-   * kthSmallestValue.
-   *
-   * @param array the array of integers to be sorted
-   * @param index the index into the array of integers
-   * @param l the first index of the subset 
-   * @param r the last index of the subset 
-   *
-   * @return the index of the middle element
-   */
-  private static int partition(int[] array, int[] index, int l, int r) {
-    
-    double pivot = array[index[(l + r) / 2]];
-    int help;
-
-    while (l < r) {
-      while ((array[index[l]] < pivot) && (l < r)) {
-        l++;
-      }
-      while ((array[index[r]] > pivot) && (l < r)) {
-        r--;
-      }
-      if (l < r) {
-        help = index[l];
-        index[l] = index[r];
-        index[r] = help;
-        l++;
-        r--;
-      }
-    }
-    if ((l == r) && (array[index[r]] > pivot)) {
-      r--;
-    } 
-
-    return r;
-  }
-  
-  /**
-   * Implements quicksort according to Manber's "Introduction to
-   * Algorithms".
-   *
-   * @param array the array of doubles to be sorted
-   * @param index the index into the array of doubles
-   * @param left the first index of the subset to be sorted
-   * @param right the last index of the subset to be sorted
-   */
-  //@ requires 0 <= first && first <= right && right < array.length;
-  //@ requires (\forall int i; 0 <= i && i < index.length; 0 <= index[i] && index[i] < array.length);
-  //@ requires array != index;
-  //  assignable index;
-  private static void quickSort(/*@non_null@*/ double[] array, /*@non_null@*/ int[] index, 
-                                int left, int right) {
-
-    if (left < right) {
-      int middle = partition(array, index, left, right);
-      quickSort(array, index, left, middle);
-      quickSort(array, index, middle + 1, right);
-    }
-  }
-  
-  /**
-   * Implements quicksort according to Manber's "Introduction to
-   * Algorithms".
-   *
-   * @param array the array of integers to be sorted
-   * @param index the index into the array of integers
-   * @param left the first index of the subset to be sorted
-   * @param right the last index of the subset to be sorted
-   */
-  //@ requires 0 <= first && first <= right && right < array.length;
-  //@ requires (\forall int i; 0 <= i && i < index.length; 0 <= index[i] && index[i] < array.length);
-  //@ requires array != index;
-  //  assignable index;
-  private static void quickSort(/*@non_null@*/ int[] array, /*@non_null@*/  int[] index, 
-                                int left, int right) {
-
-    if (left < right) {
-      int middle = partition(array, index, left, right);
-      quickSort(array, index, left, middle);
-      quickSort(array, index, middle + 1, right);
-    }
-  }
-  
-  /**
-   * Implements computation of the kth-smallest element according
-   * to Manber's "Introduction to Algorithms".
-   *
-   * @param array the array of double
-   * @param index the index into the array of doubles
-   * @param left the first index of the subset 
-   * @param right the last index of the subset 
-   * @param k the value of k
-   *
-   * @return the index of the kth-smallest element
-   */
-  //@ requires 0 <= first && first <= right && right < array.length;
-  private static int select(/*@non_null@*/ double[] array, /*@non_null@*/ int[] index, 
-                            int left, int right, int k) {
-    
-    if (left == right) {
-      return left;
-    } else {
-      int middle = partition(array, index, left, right);
-      if ((middle - left + 1) >= k) {
-        return select(array, index, left, middle, k);
-      } else {
-        return select(array, index, middle + 1, right, k - (middle - left + 1));
-      }
-    }
-  }
-
-  /**
-   * Converts a File's absolute path to a path relative to the user
-   * (ie start) directory. Includes an additional workaround for Cygwin, which
-   * doesn't like upper case drive letters.
-   * @param absolute the File to convert to relative path
-   * @return a File with a path that is relative to the user's directory
-   * @exception Exception if the path cannot be constructed
-   */
-  public static File convertToRelativePath(File absolute) throws Exception {
-    File        result;
-    String      fileStr;
-    
-    result = null;
-    
-    // if we're running windows, it could be Cygwin
-    if (File.separator.equals("\\")) {
-      // Cygwin doesn't like upper case drives -> try lower case drive
-      try {
-        fileStr = absolute.getPath();
-        fileStr =   fileStr.substring(0, 1).toLowerCase() 
-                  + fileStr.substring(1);
-        result = createRelativePath(new File(fileStr));
-      }
-      catch (Exception e) {
-        // no luck with Cygwin workaround, convert it like it is
-        result = createRelativePath(absolute);
-      }
-    }
-    else {
-      result = createRelativePath(absolute);
-    }
-
-    return result;
-  }
-
-  /**
-   * Converts a File's absolute path to a path relative to the user
-   * (ie start) directory.
-   * 
-   * @param absolute the File to convert to relative path
-   * @return a File with a path that is relative to the user's directory
-   * @exception Exception if the path cannot be constructed
-   */
-  protected static File createRelativePath(File absolute) throws Exception {
-    File userDir = new File(System.getProperty("user.dir"));
-    String userPath = userDir.getAbsolutePath() + File.separator;
-    String targetPath = (new File(absolute.getParent())).getPath() 
-      + File.separator;
-    String fileName = absolute.getName();
-    StringBuffer relativePath = new StringBuffer();
-    //    relativePath.append("."+File.separator);
-    //    System.err.println("User dir "+userPath);
-    //    System.err.println("Target path "+targetPath);
-    
-    // file is in user dir (or subdir)
-    int subdir = targetPath.indexOf(userPath);
-    if (subdir == 0) {
-      if (userPath.length() == targetPath.length()) {
-	relativePath.append(fileName);
-      } else {
-	int ll = userPath.length();
-	relativePath.append(targetPath.substring(ll));
-	relativePath.append(fileName);
-      }
-    } else {
-      int sepCount = 0;
-      String temp = new String(userPath);
-      while (temp.indexOf(File.separator) != -1) {
-	int ind = temp.indexOf(File.separator);
-	sepCount++;
-	temp = temp.substring(ind+1, temp.length());
-      }
-      
-      String targetTemp = new String(targetPath);
-      String userTemp = new String(userPath);
-      int tcount = 0;
-      while (targetTemp.indexOf(File.separator) != -1) {
-	int ind = targetTemp.indexOf(File.separator);
-	int ind2 = userTemp.indexOf(File.separator);
-	String tpart = targetTemp.substring(0,ind+1);
-	String upart = userTemp.substring(0,ind2+1);
-	if (tpart.compareTo(upart) != 0) {
-	  if (tcount == 0) {
-	    tcount = -1;
-	  }
-	  break;
-	}
-	tcount++;
-	targetTemp = targetTemp.substring(ind+1, targetTemp.length());
-	userTemp = userTemp.substring(ind2+1, userTemp.length());
-      }
-      if (tcount == -1) {
-	// then target file is probably on another drive (under windows)
-	throw new Exception("Can't construct a path to file relative to user "
-			    +"dir.");
-      }
-      if (targetTemp.indexOf(File.separator) == -1) {
-	targetTemp = "";
-      }
-      for (int i = 0; i < sepCount - tcount; i++) {
-	relativePath.append(".."+File.separator);
-      }
-      relativePath.append(targetTemp + fileName);
-    }
-    //    System.err.println("new path : "+relativePath.toString());
-    return new File(relativePath.toString());
-  }
-  
-  /**
-   * Implements computation of the kth-smallest element according
-   * to Manber's "Introduction to Algorithms".
-   *
-   * @param array the array of integers
-   * @param index the index into the array of integers
-   * @param left the first index of the subset 
-   * @param right the last index of the subset 
-   * @param k the value of k
-   *
-   * @return the index of the kth-smallest element
-   */
-  //@ requires 0 <= first && first <= right && right < array.length;
-  private static int select(/*@non_null@*/ int[] array, /*@non_null@*/ int[] index, 
-                            int left, int right, int k) {
-    
-    if (left == right) {
-      return left;
-    } else {
-      int middle = partition(array, index, left, right);
-      if ((middle - left + 1) >= k) {
-        return select(array, index, left, middle, k);
-      } else {
-        return select(array, index, middle + 1, right, k - (middle - left + 1));
-      }
-    }
-  }
-  
-  
- 
-  /**
-   * Breaks up the string, if wider than "columns" characters.
-   *
-   * @param s		the string to process
-   * @param columns	the width in columns
-   * @return		the processed string
-   */
-  public static String[] breakUp(String s, int columns) {
-    Vector<String>	result;
-    String		line;
-    BreakIterator	boundary;
-    int			boundaryStart;
-    int			boundaryEnd;
-    String		word;
-    String		punctuation;
-    int			i;
-    String[]		lines;
-
-    result      = new Vector<String>();
-    punctuation = " .,;:!?'\"";
-    lines       = s.split("\n");
-
-    for (i = 0; i < lines.length; i++) {
-      boundary      = BreakIterator.getWordInstance();
-      boundary.setText(lines[i]);
-      boundaryStart = boundary.first();
-      boundaryEnd   = boundary.next();
-      line          = "";
-
-      while (boundaryEnd != BreakIterator.DONE) {
-	word = lines[i].substring(boundaryStart, boundaryEnd);
-	if (line.length() >= columns) {
-	  if (word.length() == 1) {
-	    if (punctuation.indexOf(word.charAt(0)) > -1) {
-	      line += word;
-	      word = "";
-	    }
-	  }
-	  result.add(line);
-	  line = "";
-	}
-	line          += word;
-	boundaryStart  = boundaryEnd;
-	boundaryEnd    = boundary.next();
-      }
-      if (line.length() > 0)
-	result.add(line);
-    }
-
-    return result.toArray(new String[result.size()]);
-  }
-
-  /**
-   * Creates a new instance of an object given it's class name and
-   * (optional) arguments to pass to it's setOptions method. If the
-   * object implements OptionHandler and the options parameter is
-   * non-null, the object will have it's options set. Example use:<p>
-   *
-   * <code> <pre>
-   * String classifierName = Utils.getOption('W', options);
-   * Classifier c = (Classifier)Utils.forName(Classifier.class,
-   *                                          classifierName,
-   *                                          options);
-   * setClassifier(c);
-   * </pre></code>
-   *
-   * @param classType the class that the instantiated object should
-   * be assignable to -- an exception is thrown if this is not the case
-   * @param className the fully qualified class name of the object
-   * @param options an array of options suitable for passing to setOptions. May
-   * be null. Any options accepted by the object will be removed from the
-   * array.
-   * @return the newly created object, ready for use.
-   * @exception Exception if the class name is invalid, or if the
-   * class is not assignable to the desired class type, or the options
-   * supplied are not acceptable to the object
-   */
-  public static Object forName(Class<?> classType,
-			       String className,
-			       String[] options) throws Exception {
-
-    Class<?> c = null;
-    try {
-      c = Class.forName(className);
-    } catch (Exception ex) {
-      throw new Exception("Can't find class called: " + className);
-    }
-    if (!classType.isAssignableFrom(c)) {
-      throw new Exception(classType.getName() + " is not assignable from "
-			  + className);
-    }
-    Object o = c.newInstance();
-    /*if ((o instanceof OptionHandler)
-	&& (options != null)) {
-      ((OptionHandler)o).setOptions(options);
-      Utils.checkForRemainingOptions(options);
-    }*/
-    return o;
-  }
+	/** The natural logarithm of 2. */
+	public static double log2 = Math.log(2);
 
-}
-  
+	/** The small deviation allowed in double comparisons. */
+	public static double SMALL = 1e-6;
+
+	/**
+	 * Tests if the given value codes "missing".
+	 *
+	 * @param val the value to be tested
+	 * @return true if val codes "missing"
+	 */
+	public static boolean isMissingValue(double val) {
+
+		return Double.isNaN(val);
+	}
+
+	/**
+	 * Returns the value used to code a missing value. Note that equality tests on
+	 * this value will always return false, so use isMissingValue(double val) for
+	 * testing..
+	 *
+	 * @return the value used as missing value.
+	 */
+	public static double missingValue() {
+
+		return Double.NaN;
+	}
+
+	/**
+	 * Casting an object without "unchecked" compile-time warnings. Use only when
+	 * absolutely necessary (e.g. when using clone()).
+	 */
+	@SuppressWarnings("unchecked")
+	public static <T> T cast(Object x) {
+		return (T) x;
+	}
+
+	/**
+	 * Returns the correlation coefficient of two double vectors.
+	 *
+	 * @param y1 double vector 1
+	 * @param y2 double vector 2
+	 * @param n  the length of two double vectors
+	 * @return the correlation coefficient
+	 */
+	public static double correlation(double y1[], double y2[], int n) {
+
+		int i;
+		double av1 = 0.0, av2 = 0.0, y11 = 0.0, y22 = 0.0, y12 = 0.0, c;
+
+		if (n <= 1) {
+			return 1.0;
+		}
+		for (i = 0; i < n; i++) {
+			av1 += y1[i];
+			av2 += y2[i];
+		}
+		av1 /= n;
+		av2 /= n;
+		for (i = 0; i < n; i++) {
+			y11 += (y1[i] - av1) * (y1[i] - av1);
+			y22 += (y2[i] - av2) * (y2[i] - av2);
+			y12 += (y1[i] - av1) * (y2[i] - av2);
+		}
+		if (y11 * y22 == 0.0) {
+			c = 1.0;
+		} else {
+			c = y12 / Math.sqrt(Math.abs(y11 * y22));
+		}
+
+		return c;
+	}
+
+	/**
+	 * Removes all occurrences of a string from another string.
+	 *
+	 * @param inString  the string to remove substrings from.
+	 * @param substring the substring to remove.
+	 * @return the input string with occurrences of substring removed.
+	 */
+	public static String removeSubstring(String inString, String substring) {
+
+		StringBuffer result = new StringBuffer();
+		int oldLoc = 0, loc = 0;
+		while ((loc = inString.indexOf(substring, oldLoc)) != -1) {
+			result.append(inString.substring(oldLoc, loc));
+			oldLoc = loc + substring.length();
+		}
+		result.append(inString.substring(oldLoc));
+		return result.toString();
+	}
+
+	/**
+	 * Replaces with a new string, all occurrences of a string from another string.
+	 *
+	 * @param inString      the string to replace substrings in.
+	 * @param subString     the substring to replace.
+	 * @param replaceString the replacement substring
+	 * @return the input string with occurrences of substring replaced.
+	 */
+	public static String replaceSubstring(String inString, String subString, String replaceString) {
+
+		StringBuffer result = new StringBuffer();
+		int oldLoc = 0, loc = 0;
+		while ((loc = inString.indexOf(subString, oldLoc)) != -1) {
+			result.append(inString.substring(oldLoc, loc));
+			result.append(replaceString);
+			oldLoc = loc + subString.length();
+		}
+		result.append(inString.substring(oldLoc));
+		return result.toString();
+	}
+
+	/**
+	 * Pads a string to a specified length, inserting spaces on the left as
+	 * required. If the string is too long, characters are removed (from the right).
+	 *
+	 * @param inString the input string
+	 * @param length   the desired length of the output string
+	 * @return the output string
+	 */
+	public static String padLeft(String inString, int length) {
+
+		return fixStringLength(inString, length, false);
+	}
+
+	/**
+	 * Pads a string to a specified length, inserting spaces on the right as
+	 * required. If the string is too long, characters are removed (from the right).
+	 *
+	 * @param inString the input string
+	 * @param length   the desired length of the output string
+	 * @return the output string
+	 */
+	public static String padRight(String inString, int length) {
+
+		return fixStringLength(inString, length, true);
+	}
+
+	/**
+	 * Pads a string to a specified length, inserting spaces as required. If the
+	 * string is too long, characters are removed (from the right).
+	 *
+	 * @param inString the input string
+	 * @param length   the desired length of the output string
+	 * @param right    true if inserted spaces should be added to the right
+	 * @return the output string
+	 */
+	private static /* @pure@ */ String fixStringLength(String inString, int length, boolean right) {
+
+		if (inString.length() < length) {
+			while (inString.length() < length) {
+				inString = (right ? inString.concat(" ") : " ".concat(inString));
+			}
+		} else if (inString.length() > length) {
+			inString = inString.substring(0, length);
+		}
+		return inString;
+	}
+
+	/**
+	 * Rounds a double and converts it into String.
+	 *
+	 * @param value             the double value
+	 * @param afterDecimalPoint the (maximum) number of digits permitted after the
+	 *                          decimal point
+	 * @return the double as a formatted string
+	 */
+	public static /* @pure@ */ String doubleToString(double value, int afterDecimalPoint) {
+
+		StringBuffer stringBuffer;
+		double temp;
+		int dotPosition;
+		long precisionValue;
+
+		temp = value * Math.pow(10.0, afterDecimalPoint);
+		if (Math.abs(temp) < Long.MAX_VALUE) {
+			precisionValue = (temp > 0) ? (long) (temp + 0.5) : -(long) (Math.abs(temp) + 0.5);
+			if (precisionValue == 0) {
+				stringBuffer = new StringBuffer(String.valueOf(0));
+			} else {
+				stringBuffer = new StringBuffer(String.valueOf(precisionValue));
+			}
+			if (afterDecimalPoint == 0) {
+				return stringBuffer.toString();
+			}
+			dotPosition = stringBuffer.length() - afterDecimalPoint;
+			while (((precisionValue < 0) && (dotPosition < 1)) || (dotPosition < 0)) {
+				if (precisionValue < 0) {
+					stringBuffer.insert(1, '0');
+				} else {
+					stringBuffer.insert(0, '0');
+				}
+				dotPosition++;
+			}
+			stringBuffer.insert(dotPosition, '.');
+			if ((precisionValue < 0) && (stringBuffer.charAt(1) == '.')) {
+				stringBuffer.insert(1, '0');
+			} else if (stringBuffer.charAt(0) == '.') {
+				stringBuffer.insert(0, '0');
+			}
+			int currentPos = stringBuffer.length() - 1;
+			while ((currentPos > dotPosition) && (stringBuffer.charAt(currentPos) == '0')) {
+				stringBuffer.setCharAt(currentPos--, ' ');
+			}
+			if (stringBuffer.charAt(currentPos) == '.') {
+				stringBuffer.setCharAt(currentPos, ' ');
+			}
+
+			return stringBuffer.toString().trim();
+		}
+		return new String("" + value);
+	}
+
+	/**
+	 * Rounds a double and converts it into a formatted decimal-justified String.
+	 * Trailing 0's are replaced with spaces.
+	 *
+	 * @param value             the double value
+	 * @param width             the width of the string
+	 * @param afterDecimalPoint the number of digits after the decimal point
+	 * @return the double as a formatted string
+	 */
+	public static /* @pure@ */ String doubleToString(double value, int width, int afterDecimalPoint) {
+
+		String tempString = doubleToString(value, afterDecimalPoint);
+		char[] result;
+		int dotPosition;
+
+		if ((afterDecimalPoint >= width) || (tempString.indexOf('E') != -1)) { // Protects sci notation
+			return tempString;
+		}
+
+		// Initialize result
+		result = new char[width];
+		for (int i = 0; i < result.length; i++) {
+			result[i] = ' ';
+		}
+
+		if (afterDecimalPoint > 0) {
+			// Get position of decimal point and insert decimal point
+			dotPosition = tempString.indexOf('.');
+			if (dotPosition == -1) {
+				dotPosition = tempString.length();
+			} else {
+				result[width - afterDecimalPoint - 1] = '.';
+			}
+		} else {
+			dotPosition = tempString.length();
+		}
+
+		int offset = width - afterDecimalPoint - dotPosition;
+		if (afterDecimalPoint > 0) {
+			offset--;
+		}
+
+		// Not enough room to decimal align within the supplied width
+		if (offset < 0) {
+			return tempString;
+		}
+
+		// Copy characters before decimal point
+		for (int i = 0; i < dotPosition; i++) {
+			result[offset + i] = tempString.charAt(i);
+		}
+
+		// Copy characters after decimal point
+		for (int i = dotPosition + 1; i < tempString.length(); i++) {
+			result[offset + i] = tempString.charAt(i);
+		}
+
+		return new String(result);
+	}
+
+	/**
+	 * Returns the basic class of an array class (handles multi-dimensional arrays).
+	 * 
+	 * @param c the array to inspect
+	 * @return the class of the innermost elements
+	 */
+	public static Class getArrayClass(Class c) {
+		if (c.getComponentType().isArray())
+			return getArrayClass(c.getComponentType());
+		else
+			return c.getComponentType();
+	}
+
+	/**
+	 * Returns the dimensions of the given array. Even though the parameter is of
+	 * type "Object" one can hand over primitve arrays, e.g. int[3] or double[2][4].
+	 *
+	 * @param array the array to determine the dimensions for
+	 * @return the dimensions of the array
+	 */
+	public static int getArrayDimensions(Class array) {
+		if (array.getComponentType().isArray())
+			return 1 + getArrayDimensions(array.getComponentType());
+		else
+			return 1;
+	}
+
+	/**
+	 * Returns the dimensions of the given array. Even though the parameter is of
+	 * type "Object" one can hand over primitve arrays, e.g. int[3] or double[2][4].
+	 *
+	 * @param array the array to determine the dimensions for
+	 * @return the dimensions of the array
+	 */
+	public static int getArrayDimensions(Object array) {
+		return getArrayDimensions(array.getClass());
+	}
+
+	/**
+	 * Returns the given Array in a string representation. Even though the parameter
+	 * is of type "Object" one can hand over primitve arrays, e.g. int[3] or
+	 * double[2][4].
+	 * 
+	 * @param array the array to return in a string representation
+	 * @return the array as string
+	 */
+	public static String arrayToString(Object array) {
+		String result;
+		int dimensions;
+		int i;
+
+		result = "";
+		dimensions = getArrayDimensions(array);
+
+		if (dimensions == 0) {
+			result = "null";
+		} else if (dimensions == 1) {
+			for (i = 0; i < Array.getLength(array); i++) {
+				if (i > 0)
+					result += ",";
+				if (Array.get(array, i) == null)
+					result += "null";
+				else
+					result += Array.get(array, i).toString();
+			}
+		} else {
+			for (i = 0; i < Array.getLength(array); i++) {
+				if (i > 0)
+					result += ",";
+				result += "[" + arrayToString(Array.get(array, i)) + "]";
+			}
+		}
+
+		return result;
+	}
+
+	/**
+	 * Tests if a is equal to b.
+	 *
+	 * @param a a double
+	 * @param b a double
+	 */
+	public static /* @pure@ */ boolean eq(double a, double b) {
+
+		return (a - b < SMALL) && (b - a < SMALL);
+	}
+
+	/**
+	 * Checks if the given array contains any non-empty options.
+	 *
+	 * @param options an array of strings
+	 * @exception Exception if there are any non-empty options
+	 */
+	public static void checkForRemainingOptions(String[] options) throws Exception {
+
+		int illegalOptionsFound = 0;
+		StringBuffer text = new StringBuffer();
+
+		if (options == null) {
+			return;
+		}
+		for (int i = 0; i < options.length; i++) {
+			if (options[i].length() > 0) {
+				illegalOptionsFound++;
+				text.append(options[i] + ' ');
+			}
+		}
+		if (illegalOptionsFound > 0) {
+			throw new Exception("Illegal options: " + text);
+		}
+	}
+
+	/**
+	 * Checks if the given array contains the flag "-Char". Stops searching at the
+	 * first marker "--". If the flag is found, it is replaced with the empty
+	 * string.
+	 *
+	 * @param flag    the character indicating the flag.
+	 * @param options the array of strings containing all the options.
+	 * @return true if the flag was found
+	 * @exception Exception if an illegal option was found
+	 */
+	public static boolean getFlag(char flag, String[] options) throws Exception {
+
+		return getFlag("" + flag, options);
+	}
+
+	/**
+	 * Checks if the given array contains the flag "-String". Stops searching at the
+	 * first marker "--". If the flag is found, it is replaced with the empty
+	 * string.
+	 *
+	 * @param flag    the String indicating the flag.
+	 * @param options the array of strings containing all the options.
+	 * @return true if the flag was found
+	 * @exception Exception if an illegal option was found
+	 */
+	public static boolean getFlag(String flag, String[] options) throws Exception {
+
+		int pos = getOptionPos(flag, options);
+
+		if (pos > -1)
+			options[pos] = "";
+
+		return (pos > -1);
+	}
+
+	/**
+	 * Gets an option indicated by a flag "-Char" from the given array of strings.
+	 * Stops searching at the first marker "--". Replaces flag and option with empty
+	 * strings.
+	 *
+	 * @param flag    the character indicating the option.
+	 * @param options the array of strings containing all the options.
+	 * @return the indicated option or an empty string
+	 * @exception Exception if the option indicated by the flag can't be found
+	 */
+	public static /* @non_null@ */ String getOption(char flag, String[] options) throws Exception {
+
+		return getOption("" + flag, options);
+	}
+
+	/**
+	 * Gets an option indicated by a flag "-String" from the given array of strings.
+	 * Stops searching at the first marker "--". Replaces flag and option with empty
+	 * strings.
+	 *
+	 * @param flag    the String indicating the option.
+	 * @param options the array of strings containing all the options.
+	 * @return the indicated option or an empty string
+	 * @exception Exception if the option indicated by the flag can't be found
+	 */
+	public static /* @non_null@ */ String getOption(String flag, String[] options) throws Exception {
+
+		String newString;
+		int i = getOptionPos(flag, options);
+
+		if (i > -1) {
+			if (options[i].equals("-" + flag)) {
+				if (i + 1 == options.length) {
+					throw new Exception("No value given for -" + flag + " option.");
+				}
+				options[i] = "";
+				newString = new String(options[i + 1]);
+				options[i + 1] = "";
+				return newString;
+			}
+			if (options[i].charAt(1) == '-') {
+				return "";
+			}
+		}
+
+		return "";
+	}
+
+	/**
+	 * Gets the index of an option or flag indicated by a flag "-Char" from the
+	 * given array of strings. Stops searching at the first marker "--".
+	 *
+	 * @param flag    the character indicating the option.
+	 * @param options the array of strings containing all the options.
+	 * @return the position if found, or -1 otherwise
+	 */
+	public static int getOptionPos(char flag, String[] options) {
+		return getOptionPos("" + flag, options);
+	}
+
+	/**
+	 * Gets the index of an option or flag indicated by a flag "-String" from the
+	 * given array of strings. Stops searching at the first marker "--".
+	 *
+	 * @param flag    the String indicating the option.
+	 * @param options the array of strings containing all the options.
+	 * @return the position if found, or -1 otherwise
+	 */
+	public static int getOptionPos(String flag, String[] options) {
+		if (options == null)
+			return -1;
+
+		for (int i = 0; i < options.length; i++) {
+			if ((options[i].length() > 0) && (options[i].charAt(0) == '-')) {
+				// Check if it is a negative number
+				try {
+					Double.valueOf(options[i]);
+				} catch (NumberFormatException e) {
+					// found?
+					if (options[i].equals("-" + flag))
+						return i;
+					// did we reach "--"?
+					if (options[i].charAt(1) == '-')
+						return -1;
+				}
+			}
+		}
+
+		return -1;
+	}
+
+	/**
+	 * Quotes a string if it contains special characters.
+	 * 
+	 * The following rules are applied:
+	 *
+	 * A character is backquoted version of it is one of <tt>" ' % \ \n \r \t</tt>.
+	 *
+	 * A string is enclosed within single quotes if a character has been backquoted
+	 * using the previous rule above or contains <tt>{ }</tt> or is exactly equal to
+	 * the strings <tt>, ? space or ""</tt> (empty string).
+	 *
+	 * A quoted question mark distinguishes it from the missing value which is
+	 * represented as an unquoted question mark in arff files.
+	 *
+	 * @param string the string to be quoted
+	 * @return the string (possibly quoted)
+	 * @see #unquote(String)
+	 */
+	public static /* @pure@ */ String quote(String string) {
+		boolean quote = false;
+
+		// backquote the following characters
+		if ((string.indexOf('\n') != -1) || (string.indexOf('\r') != -1) || (string.indexOf('\'') != -1)
+				|| (string.indexOf('"') != -1) || (string.indexOf('\\') != -1) || (string.indexOf('\t') != -1)
+				|| (string.indexOf('%') != -1) || (string.indexOf('\u001E') != -1)) {
+			string = backQuoteChars(string);
+			quote = true;
+		}
+
+		// Enclose the string in 's if the string contains a recently added
+		// backquote or contains one of the following characters.
+		if ((quote == true) || (string.indexOf('{') != -1) || (string.indexOf('}') != -1) || (string.indexOf(',') != -1)
+				|| (string.equals("?")) || (string.indexOf(' ') != -1) || (string.equals(""))) {
+			string = ("'".concat(string)).concat("'");
+		}
+
+		return string;
+	}
+
+	/**
+	 * unquotes are previously quoted string (but only if necessary), i.e., it
+	 * removes the single quotes around it. Inverse to quote(String).
+	 * 
+	 * @param string the string to process
+	 * @return the unquoted string
+	 * @see #quote(String)
+	 */
+	public static String unquote(String string) {
+		if (string.startsWith("'") && string.endsWith("'")) {
+			string = string.substring(1, string.length() - 1);
+
+			if ((string.indexOf("\\n") != -1) || (string.indexOf("\\r") != -1) || (string.indexOf("\\'") != -1)
+					|| (string.indexOf("\\\"") != -1) || (string.indexOf("\\\\") != -1) || (string.indexOf("\\t") != -1)
+					|| (string.indexOf("\\%") != -1) || (string.indexOf("\\u001E") != -1)) {
+				string = unbackQuoteChars(string);
+			}
+		}
+
+		return string;
+	}
+
+	/**
+	 * Converts carriage returns and new lines in a string into \r and \n.
+	 * Backquotes the following characters: ` " \ \t and %
+	 * 
+	 * @param string the string
+	 * @return the converted string
+	 * @see #unbackQuoteChars(String)
+	 */
+	public static /* @pure@ */ String backQuoteChars(String string) {
+
+		int index;
+		StringBuffer newStringBuffer;
+
+		// replace each of the following characters with the backquoted version
+		char charsFind[] = { '\\', '\'', '\t', '\n', '\r', '"', '%', '\u001E' };
+		String charsReplace[] = { "\\\\", "\\'", "\\t", "\\n", "\\r", "\\\"", "\\%", "\\u001E" };
+		for (int i = 0; i < charsFind.length; i++) {
+			if (string.indexOf(charsFind[i]) != -1) {
+				newStringBuffer = new StringBuffer();
+				while ((index = string.indexOf(charsFind[i])) != -1) {
+					if (index > 0) {
+						newStringBuffer.append(string.substring(0, index));
+					}
+					newStringBuffer.append(charsReplace[i]);
+					if ((index + 1) < string.length()) {
+						string = string.substring(index + 1);
+					} else {
+						string = "";
+					}
+				}
+				newStringBuffer.append(string);
+				string = newStringBuffer.toString();
+			}
+		}
+
+		return string;
+	}
+
+	/**
+	 * Converts carriage returns and new lines in a string into \r and \n.
+	 *
+	 * @param string the string
+	 * @return the converted string
+	 */
+	public static String convertNewLines(String string) {
+		int index;
+
+		// Replace with \n
+		StringBuffer newStringBuffer = new StringBuffer();
+		while ((index = string.indexOf('\n')) != -1) {
+			if (index > 0) {
+				newStringBuffer.append(string.substring(0, index));
+			}
+			newStringBuffer.append('\\');
+			newStringBuffer.append('n');
+			if ((index + 1) < string.length()) {
+				string = string.substring(index + 1);
+			} else {
+				string = "";
+			}
+		}
+		newStringBuffer.append(string);
+		string = newStringBuffer.toString();
+
+		// Replace with \r
+		newStringBuffer = new StringBuffer();
+		while ((index = string.indexOf('\r')) != -1) {
+			if (index > 0) {
+				newStringBuffer.append(string.substring(0, index));
+			}
+			newStringBuffer.append('\\');
+			newStringBuffer.append('r');
+			if ((index + 1) < string.length()) {
+				string = string.substring(index + 1);
+			} else {
+				string = "";
+			}
+		}
+		newStringBuffer.append(string);
+		return newStringBuffer.toString();
+	}
+
+	/**
+	 * Reverts \r and \n in a string into carriage returns and new lines.
+	 * 
+	 * @param string the string
+	 * @return the converted string
+	 */
+	public static String revertNewLines(String string) {
+		int index;
+
+		// Replace with \n
+		StringBuffer newStringBuffer = new StringBuffer();
+		while ((index = string.indexOf("\\n")) != -1) {
+			if (index > 0) {
+				newStringBuffer.append(string.substring(0, index));
+			}
+			newStringBuffer.append('\n');
+			if ((index + 2) < string.length()) {
+				string = string.substring(index + 2);
+			} else {
+				string = "";
+			}
+		}
+		newStringBuffer.append(string);
+		string = newStringBuffer.toString();
+
+		// Replace with \r
+		newStringBuffer = new StringBuffer();
+		while ((index = string.indexOf("\\r")) != -1) {
+			if (index > 0) {
+				newStringBuffer.append(string.substring(0, index));
+			}
+			newStringBuffer.append('\r');
+			if ((index + 2) < string.length()) {
+				string = string.substring(index + 2);
+			} else {
+				string = "";
+			}
+		}
+		newStringBuffer.append(string);
+
+		return newStringBuffer.toString();
+	}
+
+	/**
+	 * Returns the secondary set of options (if any) contained in the supplied
+	 * options array. The secondary set is defined to be any options after the first
+	 * "--". These options are removed from the original options array.
+	 *
+	 * @param options the input array of options
+	 * @return the array of secondary options
+	 */
+	public static String[] partitionOptions(String[] options) {
+
+		for (int i = 0; i < options.length; i++) {
+			if (options[i].equals("--")) {
+				options[i++] = "";
+				String[] result = new String[options.length - i];
+				for (int j = i; j < options.length; j++) {
+					result[j - i] = options[j];
+					options[j] = "";
+				}
+				return result;
+			}
+		}
+		return new String[0];
+	}
+
+	/**
+	 * The inverse operation of backQuoteChars(). Converts back-quoted carriage
+	 * returns and new lines in a string to the corresponding character ('\r' and
+	 * '\n'). Also "un"-back-quotes the following characters: ` " \ \t and %
+	 *
+	 * @param string the string
+	 * @return the converted string
+	 * @see #backQuoteChars(String)
+	 */
+	public static String unbackQuoteChars(String string) {
+
+		int index;
+		StringBuffer newStringBuffer;
+
+		// replace each of the following characters with the backquoted version
+		String charsFind[] = { "\\\\", "\\'", "\\t", "\\n", "\\r", "\\\"", "\\%", "\\u001E" };
+		char charsReplace[] = { '\\', '\'', '\t', '\n', '\r', '"', '%', '\u001E' };
+		int pos[] = new int[charsFind.length];
+		int curPos;
+
+		String str = new String(string);
+		newStringBuffer = new StringBuffer();
+		while (str.length() > 0) {
+			// get positions and closest character to replace
+			curPos = str.length();
+			index = -1;
+			for (int i = 0; i < pos.length; i++) {
+				pos[i] = str.indexOf(charsFind[i]);
+				if ((pos[i] > -1) && (pos[i] < curPos)) {
+					index = i;
+					curPos = pos[i];
+				}
+			}
+
+			// replace character if found, otherwise finished
+			if (index == -1) {
+				newStringBuffer.append(str);
+				str = "";
+			} else {
+				newStringBuffer.append(str.substring(0, pos[index]));
+				newStringBuffer.append(charsReplace[index]);
+				str = str.substring(pos[index] + charsFind[index].length());
+			}
+		}
+
+		return newStringBuffer.toString();
+	}
+
+	/**
+	 * Split up a string containing options into an array of strings, one for each
+	 * option.
+	 *
+	 * @param quotedOptionString the string containing the options
+	 * @return the array of options
+	 * @throws Exception in case of an unterminated string, unknown character or a
+	 *                   parse error
+	 */
+	public static String[] splitOptions(String quotedOptionString) throws Exception {
+
+		Vector<String> optionsVec = new Vector<>();
+		String str = new String(quotedOptionString);
+		int i;
+
+		while (true) {
+
+			// trimLeft
+			i = 0;
+			while ((i < str.length()) && (Character.isWhitespace(str.charAt(i))))
+				i++;
+			str = str.substring(i);
+
+			// stop when str is empty
+			if (str.length() == 0)
+				break;
+
+			// if str start with a double quote
+			if (str.charAt(0) == '"') {
+
+				// find the first not anti-slached double quote
+				i = 1;
+				while (i < str.length()) {
+					if (str.charAt(i) == str.charAt(0))
+						break;
+					if (str.charAt(i) == '\\') {
+						i += 1;
+						if (i >= str.length())
+							throw new Exception("String should not finish with \\");
+					}
+					i += 1;
+				}
+				if (i >= str.length())
+					throw new Exception("Quote parse error.");
+
+				// add the founded string to the option vector (without quotes)
+				String optStr = str.substring(1, i);
+				optStr = unbackQuoteChars(optStr);
+				optionsVec.addElement(optStr);
+				str = str.substring(i + 1);
+			} else {
+				// find first whiteSpace
+				i = 0;
+				while ((i < str.length()) && (!Character.isWhitespace(str.charAt(i))))
+					i++;
+
+				// add the founded string to the option vector
+				String optStr = str.substring(0, i);
+				optionsVec.addElement(optStr);
+				str = str.substring(i);
+			}
+		}
+
+		// convert optionsVec to an array of String
+		String[] options = new String[optionsVec.size()];
+		for (i = 0; i < optionsVec.size(); i++) {
+			options[i] = optionsVec.elementAt(i);
+		}
+		return options;
+	}
+
+	/**
+	 * Joins all the options in an option array into a single string, as might be
+	 * used on the command line.
+	 *
+	 * @param optionArray the array of options
+	 * @return the string containing all options.
+	 */
+	public static String joinOptions(String[] optionArray) {
+
+		String optionString = "";
+		for (int i = 0; i < optionArray.length; i++) {
+			if (optionArray[i].equals("")) {
+				continue;
+			}
+			boolean escape = false;
+			for (int n = 0; n < optionArray[i].length(); n++) {
+				if (Character.isWhitespace(optionArray[i].charAt(n))) {
+					escape = true;
+					break;
+				}
+			}
+			if (escape) {
+				optionString += '"' + backQuoteChars(optionArray[i]) + '"';
+			} else {
+				optionString += optionArray[i];
+			}
+			optionString += " ";
+		}
+		return optionString.trim();
+	}
+
+	/**
+	 * Computes entropy for an array of integers.
+	 *
+	 * @param counts array of counts
+	 * @return - a log2 a - b log2 b - c log2 c + (a+b+c) log2 (a+b+c) when given
+	 *         array [a b c]
+	 */
+	public static /* @pure@ */ double info(int counts[]) {
+
+		int total = 0;
+		double x = 0;
+		for (int j = 0; j < counts.length; j++) {
+			x -= xlogx(counts[j]);
+			total += counts[j];
+		}
+		return x + xlogx(total);
+	}
+
+	/**
+	 * Tests if a is smaller or equal to b.
+	 *
+	 * @param a a double
+	 * @param b a double
+	 */
+	public static /* @pure@ */ boolean smOrEq(double a, double b) {
+
+		return (a - b < SMALL);
+	}
+
+	/**
+	 * Tests if a is greater or equal to b.
+	 *
+	 * @param a a double
+	 * @param b a double
+	 */
+	public static /* @pure@ */ boolean grOrEq(double a, double b) {
+
+		return (b - a < SMALL);
+	}
+
+	/**
+	 * Tests if a is smaller than b.
+	 *
+	 * @param a a double
+	 * @param b a double
+	 */
+	public static /* @pure@ */ boolean sm(double a, double b) {
+
+		return (b - a > SMALL);
+	}
+
+	/**
+	 * Tests if a is greater than b.
+	 *
+	 * @param a a double
+	 * @param b a double
+	 */
+	public static /* @pure@ */ boolean gr(double a, double b) {
+
+		return (a - b > SMALL);
+	}
+
+	/**
+	 * Returns the kth-smallest value in the array.
+	 *
+	 * @param array the array of integers
+	 * @param k     the value of k
+	 * @return the kth-smallest value
+	 */
+	public static double kthSmallestValue(int[] array, int k) {
 
+		int[] index = new int[array.length];
+
+		for (int i = 0; i < index.length; i++) {
+			index[i] = i;
+		}
+
+		return array[index[select(array, index, 0, array.length - 1, k)]];
+	}
+
+	/**
+	 * Returns the kth-smallest value in the array
+	 *
+	 * @param array the array of double
+	 * @param k     the value of k
+	 * @return the kth-smallest value
+	 */
+	public static double kthSmallestValue(double[] array, int k) {
+
+		int[] index = new int[array.length];
+
+		for (int i = 0; i < index.length; i++) {
+			index[i] = i;
+		}
+
+		return array[index[select(array, index, 0, array.length - 1, k)]];
+	}
+
+	/**
+	 * Returns the logarithm of a for base 2.
+	 *
+	 * @param a a double
+	 * @return the logarithm for base 2
+	 */
+	public static /* @pure@ */ double log2(double a) {
+
+		return Math.log(a) / log2;
+	}
+
+	/**
+	 * Returns index of maximum element in a given array of doubles. First maximum
+	 * is returned.
+	 *
+	 * @param doubles the array of doubles
+	 * @return the index of the maximum element
+	 */
+	public static /* @pure@ */ int maxIndex(double[] doubles) {
+
+		double maximum = 0;
+		int maxIndex = 0;
+
+		for (int i = 0; i < doubles.length; i++) {
+			if ((i == 0) || (doubles[i] > maximum)) {
+				maxIndex = i;
+				maximum = doubles[i];
+			}
+		}
+
+		return maxIndex;
+	}
+
+	/**
+	 * Returns index of maximum element in a given array of doubles. First maximum
+	 * is returned.
+	 *
+	 * @param doubles the array of doubles
+	 * @return the index of the maximum element
+	 */
+	public static /* @pure@ */ int maxIndex(Prediction prediction) {
+
+		return maxIndex(prediction.asDoubleArray());
+	}
+
+	/**
+	 * Returns index of maximum element in a given array of integers. First maximum
+	 * is returned.
+	 *
+	 * @param ints the array of integers
+	 * @return the index of the maximum element
+	 */
+	public static /* @pure@ */ int maxIndex(int[] ints) {
+
+		int maximum = 0;
+		int maxIndex = 0;
+
+		for (int i = 0; i < ints.length; i++) {
+			if ((i == 0) || (ints[i] > maximum)) {
+				maxIndex = i;
+				maximum = ints[i];
+			}
+		}
+
+		return maxIndex;
+	}
+
+	/**
+	 * Computes the mean for an array of doubles.
+	 *
+	 * @param vector the array
+	 * @return the mean
+	 */
+	public static /* @pure@ */ double mean(double[] vector) {
+
+		double sum = 0;
+
+		if (vector.length == 0) {
+			return 0;
+		}
+		for (int i = 0; i < vector.length; i++) {
+			sum += vector[i];
+		}
+		return sum / vector.length;
+	}
+
+	/**
+	 * Returns index of minimum element in a given array of integers. First minimum
+	 * is returned.
+	 *
+	 * @param ints the array of integers
+	 * @return the index of the minimum element
+	 */
+	public static /* @pure@ */ int minIndex(int[] ints) {
+
+		int minimum = 0;
+		int minIndex = 0;
+
+		for (int i = 0; i < ints.length; i++) {
+			if ((i == 0) || (ints[i] < minimum)) {
+				minIndex = i;
+				minimum = ints[i];
+			}
+		}
+
+		return minIndex;
+	}
+
+	/**
+	 * Returns index of minimum element in a given array of doubles. First minimum
+	 * is returned.
+	 *
+	 * @param doubles the array of doubles
+	 * @return the index of the minimum element
+	 */
+	public static /* @pure@ */ int minIndex(double[] doubles) {
+
+		double minimum = 0;
+		int minIndex = 0;
+
+		for (int i = 0; i < doubles.length; i++) {
+			if ((i == 0) || (doubles[i] < minimum)) {
+				minIndex = i;
+				minimum = doubles[i];
+			}
+		}
+
+		return minIndex;
+	}
+
+	/**
+	 * Normalizes the doubles in the array by their sum.
+	 *
+	 * @param doubles the array of double
+	 * @exception IllegalArgumentException if sum is Zero or NaN
+	 */
+	public static void normalize(double[] doubles) {
+
+		double sum = 0;
+		for (int i = 0; i < doubles.length; i++) {
+			sum += doubles[i];
+		}
+		normalize(doubles, sum);
+	}
+
+	/**
+	 * Normalizes the doubles in the array using the given value.
+	 *
+	 * @param doubles the array of double
+	 * @param sum     the value by which the doubles are to be normalized
+	 * @exception IllegalArgumentException if sum is zero or NaN
+	 */
+	public static void normalize(double[] doubles, double sum) {
+
+		if (Double.isNaN(sum)) {
+			throw new IllegalArgumentException("Can't normalize array. Sum is NaN.");
+		}
+		if (sum == 0) {
+			// Maybe this should just be a return.
+			throw new IllegalArgumentException("Can't normalize array. Sum is zero.");
+		}
+		for (int i = 0; i < doubles.length; i++) {
+			doubles[i] /= sum;
+		}
+	}
+
+	/**
+	 * Converts an array containing the natural logarithms of probabilities stored
+	 * in a vector back into probabilities. The probabilities are assumed to sum to
+	 * one.
+	 *
+	 * @param a an array holding the natural logarithms of the probabilities
+	 * @return the converted array
+	 */
+	public static double[] logs2probs(double[] a) {
+
+		double max = a[maxIndex(a)];
+		double sum = 0.0;
+
+		double[] result = new double[a.length];
+		for (int i = 0; i < a.length; i++) {
+			result[i] = Math.exp(a[i] - max);
+			sum += result[i];
+		}
+
+		normalize(result, sum);
+
+		return result;
+	}
+
+	/**
+	 * Returns the log-odds for a given probabilitiy.
+	 *
+	 * @param prob the probabilitiy
+	 *
+	 * @return the log-odds after the probability has been mapped to [Utils.SMALL,
+	 *         1-Utils.SMALL]
+	 */
+	public static /* @pure@ */ double probToLogOdds(double prob) {
+
+		if (gr(prob, 1) || (sm(prob, 0))) {
+			throw new IllegalArgumentException("probToLogOdds: probability must " + "be in [0,1] " + prob);
+		}
+		double p = SMALL + (1.0 - 2 * SMALL) * prob;
+		return Math.log(p / (1 - p));
+	}
+
+	/**
+	 * Rounds a double to the next nearest integer value. The JDK version of it
+	 * doesn't work properly.
+	 *
+	 * @param value the double value
+	 * @return the resulting integer value
+	 */
+	public static /* @pure@ */ int round(double value) {
+
+		int roundedValue = value > 0 ? (int) (value + 0.5) : -(int) (Math.abs(value) + 0.5);
+
+		return roundedValue;
+	}
+
+	/**
+	 * Rounds a double to the next nearest integer value in a probabilistic fashion
+	 * (e.g. 0.8 has a 20% chance of being rounded down to 0 and a 80% chance of
+	 * being rounded up to 1). In the limit, the average of the rounded numbers
+	 * generated by this procedure should converge to the original double.
+	 *
+	 * @param value the double value
+	 * @param rand  the random number generator
+	 * @return the resulting integer value
+	 */
+	public static int probRound(double value, Random rand) {
+
+		if (value >= 0) {
+			double lower = Math.floor(value);
+			double prob = value - lower;
+			if (rand.nextDouble() < prob) {
+				return (int) lower + 1;
+			} else {
+				return (int) lower;
+			}
+		} else {
+			double lower = Math.floor(Math.abs(value));
+			double prob = Math.abs(value) - lower;
+			if (rand.nextDouble() < prob) {
+				return -((int) lower + 1);
+			} else {
+				return -(int) lower;
+			}
+		}
+	}
+
+	/**
+	 * Rounds a double to the given number of decimal places.
+	 *
+	 * @param value             the double value
+	 * @param afterDecimalPoint the number of digits after the decimal point
+	 * @return the double rounded to the given precision
+	 */
+	public static /* @pure@ */ double roundDouble(double value, int afterDecimalPoint) {
+
+		double mask = Math.pow(10.0, afterDecimalPoint);
+
+		return (Math.round(value * mask)) / mask;
+	}
+
+	/**
+	 * Sorts a given array of integers in ascending order and returns an array of
+	 * integers with the positions of the elements of the original array in the
+	 * sorted array. The sort is stable. (Equal elements remain in their original
+	 * order.)
+	 *
+	 * @param array this array is not changed by the method!
+	 * @return an array of integers with the positions in the sorted array.
+	 */
+	public static /* @pure@ */ int[] sort(int[] array) {
+
+		int[] index = new int[array.length];
+		int[] newIndex = new int[array.length];
+		int[] helpIndex;
+		int numEqual;
+
+		for (int i = 0; i < index.length; i++) {
+			index[i] = i;
+		}
+		quickSort(array, index, 0, array.length - 1);
+
+		// Make sort stable
+		int i = 0;
+		while (i < index.length) {
+			numEqual = 1;
+			for (int j = i + 1; ((j < index.length) && (array[index[i]] == array[index[j]])); j++) {
+				numEqual++;
+			}
+			if (numEqual > 1) {
+				helpIndex = new int[numEqual];
+				for (int j = 0; j < numEqual; j++) {
+					helpIndex[j] = i + j;
+				}
+				quickSort(index, helpIndex, 0, numEqual - 1);
+				for (int j = 0; j < numEqual; j++) {
+					newIndex[i + j] = index[helpIndex[j]];
+				}
+				i += numEqual;
+			} else {
+				newIndex[i] = index[i];
+				i++;
+			}
+		}
+		return newIndex;
+	}
+
+	/**
+	 * Sorts a given array of doubles in ascending order and returns an array of
+	 * integers with the positions of the elements of the original array in the
+	 * sorted array. NOTE THESE CHANGES: the sort is no longer stable and it doesn't
+	 * use safe floating-point comparisons anymore. Occurrences of Double.NaN are
+	 * treated as Double.MAX_VALUE
+	 *
+	 * @param array this array is not changed by the method!
+	 * @return an array of integers with the positions in the sorted array.
+	 */
+	public static /* @pure@ */ int[] sort(/* @non_null@ */ double[] array) {
+
+		int[] index = new int[array.length];
+		array = array.clone();
+		for (int i = 0; i < index.length; i++) {
+			index[i] = i;
+			if (Double.isNaN(array[i])) {
+				array[i] = Double.MAX_VALUE;
+			}
+		}
+		quickSort(array, index, 0, array.length - 1);
+		return index;
+	}
+
+	/**
+	 * Sorts a given array of doubles in ascending order and returns an array of
+	 * integers with the positions of the elements of the original array in the
+	 * sorted array. The sort is stable (Equal elements remain in their original
+	 * order.) Occurrences of Double.NaN are treated as Double.MAX_VALUE
+	 *
+	 * @param array this array is not changed by the method!
+	 * @return an array of integers with the positions in the sorted array.
+	 */
+	public static /* @pure@ */ int[] stableSort(double[] array) {
+
+		int[] index = new int[array.length];
+		int[] newIndex = new int[array.length];
+		int[] helpIndex;
+		int numEqual;
+
+		array = array.clone();
+		for (int i = 0; i < index.length; i++) {
+			index[i] = i;
+			if (Double.isNaN(array[i])) {
+				array[i] = Double.MAX_VALUE;
+			}
+		}
+		quickSort(array, index, 0, array.length - 1);
+
+		// Make sort stable
+
+		int i = 0;
+		while (i < index.length) {
+			numEqual = 1;
+			for (int j = i + 1; ((j < index.length) && Utils.eq(array[index[i]], array[index[j]])); j++)
+				numEqual++;
+			if (numEqual > 1) {
+				helpIndex = new int[numEqual];
+				for (int j = 0; j < numEqual; j++)
+					helpIndex[j] = i + j;
+				quickSort(index, helpIndex, 0, numEqual - 1);
+				for (int j = 0; j < numEqual; j++)
+					newIndex[i + j] = index[helpIndex[j]];
+				i += numEqual;
+			} else {
+				newIndex[i] = index[i];
+				i++;
+			}
+		}
+
+		return newIndex;
+	}
+
+	/**
+	 * Computes the variance for an array of doubles.
+	 *
+	 * @param vector the array
+	 * @return the variance
+	 */
+	public static /* @pure@ */ double variance(double[] vector) {
+
+		double sum = 0, sumSquared = 0;
+
+		if (vector.length <= 1) {
+			return 0;
+		}
+		for (int i = 0; i < vector.length; i++) {
+			sum += vector[i];
+			sumSquared += (vector[i] * vector[i]);
+		}
+		double result = (sumSquared - (sum * sum / vector.length)) / (vector.length - 1);
+
+		// We don't like negative variance
+		if (result < 0) {
+			return 0;
+		} else {
+			return result;
+		}
+	}
+
+	/**
+	 * Computes the sum of the elements of an array of doubles.
+	 *
+	 * @param doubles the array of double
+	 * @return the sum of the elements
+	 */
+	public static /* @pure@ */ double sum(double[] doubles) {
+
+		double sum = 0;
+
+		for (int i = 0; i < doubles.length; i++) {
+			sum += doubles[i];
+		}
+		return sum;
+	}
+
+	/**
+	 * Computes the sum of the elements of an array of integers.
+	 *
+	 * @param ints the array of integers
+	 * @return the sum of the elements
+	 */
+	public static /* @pure@ */ int sum(int[] ints) {
+
+		int sum = 0;
+
+		for (int i = 0; i < ints.length; i++) {
+			sum += ints[i];
+		}
+		return sum;
+	}
+
+	/**
+	 * Returns c*log2(c) for a given integer value c.
+	 *
+	 * @param c an integer value
+	 * @return c*log2(c) (but is careful to return 0 if c is 0)
+	 */
+	public static /* @pure@ */ double xlogx(int c) {
+
+		if (c == 0) {
+			return 0.0;
+		}
+		return c * Utils.log2(c);
+	}
+
+	/**
+	 * Partitions the instances around a pivot. Used by quicksort and
+	 * kthSmallestValue.
+	 *
+	 * @param array the array of doubles to be sorted
+	 * @param index the index into the array of doubles
+	 * @param l     the first index of the subset
+	 * @param r     the last index of the subset
+	 *
+	 * @return the index of the middle element
+	 */
+	private static int partition(double[] array, int[] index, int l, int r) {
+
+		double pivot = array[index[(l + r) / 2]];
+		int help;
+
+		while (l < r) {
+			while ((array[index[l]] < pivot) && (l < r)) {
+				l++;
+			}
+			while ((array[index[r]] > pivot) && (l < r)) {
+				r--;
+			}
+			if (l < r) {
+				help = index[l];
+				index[l] = index[r];
+				index[r] = help;
+				l++;
+				r--;
+			}
+		}
+		if ((l == r) && (array[index[r]] > pivot)) {
+			r--;
+		}
+
+		return r;
+	}
+
+	/**
+	 * Partitions the instances around a pivot. Used by quicksort and
+	 * kthSmallestValue.
+	 *
+	 * @param array the array of integers to be sorted
+	 * @param index the index into the array of integers
+	 * @param l     the first index of the subset
+	 * @param r     the last index of the subset
+	 *
+	 * @return the index of the middle element
+	 */
+	private static int partition(int[] array, int[] index, int l, int r) {
+
+		double pivot = array[index[(l + r) / 2]];
+		int help;
+
+		while (l < r) {
+			while ((array[index[l]] < pivot) && (l < r)) {
+				l++;
+			}
+			while ((array[index[r]] > pivot) && (l < r)) {
+				r--;
+			}
+			if (l < r) {
+				help = index[l];
+				index[l] = index[r];
+				index[r] = help;
+				l++;
+				r--;
+			}
+		}
+		if ((l == r) && (array[index[r]] > pivot)) {
+			r--;
+		}
+
+		return r;
+	}
+
+	/**
+	 * Implements quicksort according to Manber's "Introduction to Algorithms".
+	 *
+	 * @param array the array of doubles to be sorted
+	 * @param index the index into the array of doubles
+	 * @param left  the first index of the subset to be sorted
+	 * @param right the last index of the subset to be sorted
+	 */
+	// @ requires 0 <= first && first <= right && right < array.length;
+	// @ requires (\forall int i; 0 <= i && i < index.length; 0 <= index[i] &&
+	// index[i] < array.length);
+	// @ requires array != index;
+	// assignable index;
+	private static void quickSort(/* @non_null@ */ double[] array, /* @non_null@ */ int[] index, int left, int right) {
+
+		if (left < right) {
+			int middle = partition(array, index, left, right);
+			quickSort(array, index, left, middle);
+			quickSort(array, index, middle + 1, right);
+		}
+	}
+
+	/**
+	 * Implements quicksort according to Manber's "Introduction to Algorithms".
+	 *
+	 * @param array the array of integers to be sorted
+	 * @param index the index into the array of integers
+	 * @param left  the first index of the subset to be sorted
+	 * @param right the last index of the subset to be sorted
+	 */
+	// @ requires 0 <= first && first <= right && right < array.length;
+	// @ requires (\forall int i; 0 <= i && i < index.length; 0 <= index[i] &&
+	// index[i] < array.length);
+	// @ requires array != index;
+	// assignable index;
+	private static void quickSort(/* @non_null@ */ int[] array, /* @non_null@ */ int[] index, int left, int right) {
+
+		if (left < right) {
+			int middle = partition(array, index, left, right);
+			quickSort(array, index, left, middle);
+			quickSort(array, index, middle + 1, right);
+		}
+	}
+
+	/**
+	 * Implements computation of the kth-smallest element according to Manber's
+	 * "Introduction to Algorithms".
+	 *
+	 * @param array the array of double
+	 * @param index the index into the array of doubles
+	 * @param left  the first index of the subset
+	 * @param right the last index of the subset
+	 * @param k     the value of k
+	 *
+	 * @return the index of the kth-smallest element
+	 */
+	// @ requires 0 <= first && first <= right && right < array.length;
+	private static int select(/* @non_null@ */ double[] array, /* @non_null@ */ int[] index, int left, int right,
+			int k) {
+
+		if (left == right) {
+			return left;
+		} else {
+			int middle = partition(array, index, left, right);
+			if ((middle - left + 1) >= k) {
+				return select(array, index, left, middle, k);
+			} else {
+				return select(array, index, middle + 1, right, k - (middle - left + 1));
+			}
+		}
+	}
+
+	/**
+	 * Converts a File's absolute path to a path relative to the user (ie start)
+	 * directory. Includes an additional workaround for Cygwin, which doesn't like
+	 * upper case drive letters.
+	 * 
+	 * @param absolute the File to convert to relative path
+	 * @return a File with a path that is relative to the user's directory
+	 * @exception Exception if the path cannot be constructed
+	 */
+	public static File convertToRelativePath(File absolute) throws Exception {
+		File result;
+		String fileStr;
+
+		result = null;
+
+		// if we're running windows, it could be Cygwin
+		if (File.separator.equals("\\")) {
+			// Cygwin doesn't like upper case drives -> try lower case drive
+			try {
+				fileStr = absolute.getPath();
+				fileStr = fileStr.substring(0, 1).toLowerCase() + fileStr.substring(1);
+				result = createRelativePath(new File(fileStr));
+			} catch (Exception e) {
+				// no luck with Cygwin workaround, convert it like it is
+				result = createRelativePath(absolute);
+			}
+		} else {
+			result = createRelativePath(absolute);
+		}
+
+		return result;
+	}
+
+	/**
+	 * Converts a File's absolute path to a path relative to the user (ie start)
+	 * directory.
+	 * 
+	 * @param absolute the File to convert to relative path
+	 * @return a File with a path that is relative to the user's directory
+	 * @exception Exception if the path cannot be constructed
+	 */
+	protected static File createRelativePath(File absolute) throws Exception {
+		File userDir = new File(System.getProperty("user.dir"));
+		String userPath = userDir.getAbsolutePath() + File.separator;
+		String targetPath = (new File(absolute.getParent())).getPath() + File.separator;
+		String fileName = absolute.getName();
+		StringBuffer relativePath = new StringBuffer();
+		// relativePath.append("."+File.separator);
+		// System.err.println("User dir "+userPath);
+		// System.err.println("Target path "+targetPath);
+
+		// file is in user dir (or subdir)
+		int subdir = targetPath.indexOf(userPath);
+		if (subdir == 0) {
+			if (userPath.length() == targetPath.length()) {
+				relativePath.append(fileName);
+			} else {
+				int ll = userPath.length();
+				relativePath.append(targetPath.substring(ll));
+				relativePath.append(fileName);
+			}
+		} else {
+			int sepCount = 0;
+			String temp = new String(userPath);
+			while (temp.indexOf(File.separator) != -1) {
+				int ind = temp.indexOf(File.separator);
+				sepCount++;
+				temp = temp.substring(ind + 1, temp.length());
+			}
+
+			String targetTemp = new String(targetPath);
+			String userTemp = new String(userPath);
+			int tcount = 0;
+			while (targetTemp.indexOf(File.separator) != -1) {
+				int ind = targetTemp.indexOf(File.separator);
+				int ind2 = userTemp.indexOf(File.separator);
+				String tpart = targetTemp.substring(0, ind + 1);
+				String upart = userTemp.substring(0, ind2 + 1);
+				if (tpart.compareTo(upart) != 0) {
+					if (tcount == 0) {
+						tcount = -1;
+					}
+					break;
+				}
+				tcount++;
+				targetTemp = targetTemp.substring(ind + 1, targetTemp.length());
+				userTemp = userTemp.substring(ind2 + 1, userTemp.length());
+			}
+			if (tcount == -1) {
+				// then target file is probably on another drive (under windows)
+				throw new Exception("Can't construct a path to file relative to user " + "dir.");
+			}
+			if (targetTemp.indexOf(File.separator) == -1) {
+				targetTemp = "";
+			}
+			for (int i = 0; i < sepCount - tcount; i++) {
+				relativePath.append(".." + File.separator);
+			}
+			relativePath.append(targetTemp + fileName);
+		}
+		// System.err.println("new path : "+relativePath.toString());
+		return new File(relativePath.toString());
+	}
+
+	/**
+	 * Implements computation of the kth-smallest element according to Manber's
+	 * "Introduction to Algorithms".
+	 *
+	 * @param array the array of integers
+	 * @param index the index into the array of integers
+	 * @param left  the first index of the subset
+	 * @param right the last index of the subset
+	 * @param k     the value of k
+	 *
+	 * @return the index of the kth-smallest element
+	 */
+	// @ requires 0 <= first && first <= right && right < array.length;
+	private static int select(/* @non_null@ */ int[] array, /* @non_null@ */ int[] index, int left, int right, int k) {
+
+		if (left == right) {
+			return left;
+		} else {
+			int middle = partition(array, index, left, right);
+			if ((middle - left + 1) >= k) {
+				return select(array, index, left, middle, k);
+			} else {
+				return select(array, index, middle + 1, right, k - (middle - left + 1));
+			}
+		}
+	}
+
+	/**
+	 * Breaks up the string, if wider than "columns" characters.
+	 *
+	 * @param s       the string to process
+	 * @param columns the width in columns
+	 * @return the processed string
+	 */
+	public static String[] breakUp(String s, int columns) {
+		Vector<String> result;
+		String line;
+		BreakIterator boundary;
+		int boundaryStart;
+		int boundaryEnd;
+		String word;
+		String punctuation;
+		int i;
+		String[] lines;
+
+		result = new Vector<>();
+		punctuation = " .,;:!?'\"";
+		lines = s.split("\n");
+
+		for (i = 0; i < lines.length; i++) {
+			boundary = BreakIterator.getWordInstance();
+			boundary.setText(lines[i]);
+			boundaryStart = boundary.first();
+			boundaryEnd = boundary.next();
+			line = "";
+
+			while (boundaryEnd != BreakIterator.DONE) {
+				word = lines[i].substring(boundaryStart, boundaryEnd);
+				if (line.length() >= columns) {
+					if (word.length() == 1) {
+						if (punctuation.indexOf(word.charAt(0)) > -1) {
+							line += word;
+							word = "";
+						}
+					}
+					result.add(line);
+					line = "";
+				}
+				line += word;
+				boundaryStart = boundaryEnd;
+				boundaryEnd = boundary.next();
+			}
+			if (line.length() > 0)
+				result.add(line);
+		}
+
+		return result.toArray(new String[result.size()]);
+	}
+
+	/**
+	 * Creates a new instance of an object given it's class name and (optional)
+	 * arguments to pass to it's setOptions method. If the object implements
+	 * OptionHandler and the options parameter is non-null, the object will have
+	 * it's options set. Example use:
+	 * <p>
+	 *
+	 * <code> <pre>
+	 * String classifierName = Utils.getOption('W', options);
+	 * Classifier c = (Classifier)Utils.forName(Classifier.class,
+	 *                                          classifierName,
+	 *                                          options);
+	 * setClassifier(c);
+	 * </pre></code>
+	 *
+	 * @param classType the class that the instantiated object should be assignable
+	 *                  to -- an exception is thrown if this is not the case
+	 * @param className the fully qualified class name of the object
+	 * @param options   an array of options suitable for passing to setOptions. May
+	 *                  be null. Any options accepted by the object will be removed
+	 *                  from the array.
+	 * @return the newly created object, ready for use.
+	 * @exception Exception if the class name is invalid, or if the class is not
+	 *                      assignable to the desired class type, or the options
+	 *                      supplied are not acceptable to the object
+	 */
+	public static Object forName(Class<?> classType, String className, String[] options) throws Exception {
+
+		Class<?> c = null;
+		try {
+			c = Class.forName(className);
+		} catch (Exception ex) {
+			throw new Exception("Can't find class called: " + className);
+		}
+		if (!classType.isAssignableFrom(c)) {
+			throw new Exception(classType.getName() + " is not assignable from " + className);
+		}
+		Object o = c.newInstance();
+		/*
+		 * if ((o instanceof OptionHandler) && (options != null)) {
+		 * ((OptionHandler)o).setOptions(options);
+		 * Utils.checkForRemainingOptions(options); }
+		 */
+		return o;
+	}
+
+}
diff --git a/moa/src/main/java/moa/core/WekaUtils.java b/moa/src/main/java/moa/core/WekaUtils.java
index c1176198d..8c100858a 100644
--- a/moa/src/main/java/moa/core/WekaUtils.java
+++ b/moa/src/main/java/moa/core/WekaUtils.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.core;
 
@@ -29,32 +29,30 @@
  */
 public class WekaUtils {
 
- /**
-     * Checks if the Weka version is recent enough to run MOA.
-     * For example, if the Weka version is not recent, there may be problems
-     * due to the fact that <code>Instance</code> was a class before 3.7.1 and
-     * now is an interface.
-     *
-     * @return true if the Weka version is recent.
-     */
-    public static boolean isWekaVersionOK() {
-        try {
-            Class.forName("weka.core.Version");
-            Version version = new Version();
-            if (version.isOlder("3.7.1")) {
-                System.err.println();
-                System.err.println(Globals.getWorkbenchInfoString());
-                System.err.println();
-                System.err.print("Weka 3.7.1 or higher is required to run MOA. ");
-                System.err.println("Weka version " + Version.VERSION + " found");
-                return false;
-            } else {
-                return true;
-            }
-        } catch (ClassNotFoundException exception) {
-            // It is not available
-            return true;
-        }
-    }
+	/**
+	 * Checks if the Weka version is recent enough to run MOA. For example, if the
+	 * Weka version is not recent, there may be problems due to the fact that
+	 * <code>Instance</code> was a class before 3.7.1 and now is an interface.
+	 *
+	 * @return true if the Weka version is recent.
+	 */
+	public static boolean isWekaVersionOK() {
+		try {
+			Class.forName("weka.core.Version");
+			Version version = new Version();
+			if (version.isOlder("3.7.1")) {
+				System.err.println();
+				System.err.println(Globals.getWorkbenchInfoString());
+				System.err.println();
+				System.err.print("Weka 3.7.1 or higher is required to run MOA. ");
+				System.err.println("Weka version " + Version.VERSION + " found");
+				return false;
+			} else {
+				return true;
+			}
+		} catch (ClassNotFoundException exception) {
+			// It is not available
+			return true;
+		}
+	}
 }
-
diff --git a/moa/src/main/java/moa/core/utils/AttributeDefinitionUtil.java b/moa/src/main/java/moa/core/utils/AttributeDefinitionUtil.java
index d43968462..f6c50e318 100644
--- a/moa/src/main/java/moa/core/utils/AttributeDefinitionUtil.java
+++ b/moa/src/main/java/moa/core/utils/AttributeDefinitionUtil.java
@@ -1,135 +1,206 @@
+/**
+ * 
+ * The attribute definition follows the following syntax:
+ * 
+ * attributeDefinition ::= definition | definition ',' attributeDefinition
+ * 
+ * definition ::= '!'? index | '!'? range
+ * index ::= -?[0-9]+
+ * range ::= positiveRange | arbitraryRange
+ * positiveRange ::= [0-9]+-[0-9]+
+ * arbitraryRange ::= index '~' index
+ * 
+ * An attribute definition is composed of atomic definitions. These are interpreted as:
+ * 
+ * 0 - add all non-ignored attributes (used for loading all non-output attributes as input attributes)
+ * 
+ * i - if i > 0, add the i-th attribute, if i < 0, add the |i|-th to last attribute
+ * 
+ * i-j - add all attributes between i and j (inclusive) (i, j > 0, i <= j)
+ * 
+ * i~j - add all attributes between i and j (inclusive), i and j can be negative and are mapped to the appropriate attribute offset from the number of total attributes
+ * 
+ * !<definition> - remove the attributes defined by the <definition>
+ * 
+ * When loading the input attributes, the output attributes are (generally) ignored.
+ * 
+ * The atomic definitions are applied in order.
+ * 
+ * Examples:
+ * 
+ * 0 - add all non-ignored attributes
+ * 
+ * 0,!1 - add all non-ignored attributes, except for the first attribute
+ * 
+ * 0,!-1 - add all non-ignored attributes, except for the last attribte
+ * 
+ * 1-5 - add the first 5 attributes
+ * 
+ * 1-5,!3 - add the 1st, 2nd, 4th and 5th attribute
+ * 
+ * 1~-2 - add all attributes, except for the last attribute
+ * 
+ * -5~-2 - add all attributes from the 5th to last one to the 2nd to last one
+ * 
+ * 
+ * @author Aljaž Osojnik <aljaz.osojnik@ijs.si>
+ *
+ */
+
 package moa.core.utils;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.regex.Pattern;
 
+
 public class AttributeDefinitionUtil {
-	//public static String definitionTotal = "(!?-?[0-9]+?)|(!?[0-9]+?-[0-9]+?)|(!?-?[0-9]+?~-?[0-9]+?)";
-	
+	// public static String definitionTotal =
+	// "(!?-?[0-9]+?)|(!?[0-9]+?-[0-9]+?)|(!?-?[0-9]+?~-?[0-9]+?)";
+
 	public static String nonIgnoredDefinition = "0";
-	
+
 	public static String definitionSingle = "-?[0-9]+?";
 	public static String definitionPositiveRange = "[0-9]+?-[0-9]+?";
 	public static String definitionArbitraryRange = "-?[0-9]+?~-?[0-9]+?";
-	
+
 	public static String getDefinitionTotal() {
-		return "(!?" + definitionSingle + ")|" + "(!?" + definitionPositiveRange + ")|" + "(!?" + definitionArbitraryRange + ")";
+		return "(!?" + definitionSingle + ")|" + "(!?" + definitionPositiveRange + ")|" + "(!?"
+				+ definitionArbitraryRange + ")";
 	}
-	
+
 	public static List<Integer> parseDefinition(String definition, int numAttributes, List<Integer> ignoredAttributes) {
-		List<Integer> ret = new ArrayList<Integer>();
+		List<Integer> ret = new ArrayList<>();
 		if (Pattern.matches(definitionArbitraryRange, definition)) {
 			String[] split = definition.split("~");
 			int start = Integer.valueOf(split[0]);
 			int end = Integer.valueOf(split[1]);
 			if (start < 0) {
-				start = numAttributes + start + 1; // + 1 for so that -1 maps to last attribute 
+				start = numAttributes + start + 1; // + 1 for so that -1 maps to last attribute
 			}
 			if (end < 0) {
-				end = numAttributes + end + 1; // + 1 for so that -1 maps to last attribute 
+				end = numAttributes + end + 1; // + 1 for so that -1 maps to last attribute
 			}
 			start = Math.max(0, start);
 			end = Math.max(0, end);
 			if (start == end) {
-				System.err.println("[Warning] Strage attribute range definition '" + definition + "', start equals end");
+				System.err
+						.println("[Warning] Strage attribute range definition '" + definition + "', start equals end");
 			}
 			if (start <= end) {
 				Integer i = start;
-				while(i <= end) {
-					if (!ignoredAttributes.contains(i - 1)) ret.add(i - 1);
+				while (i <= end) {
+					if (!ignoredAttributes.contains(i - 1))
+						ret.add(i - 1);
 					i++;
 				}
-			}
-			else 
-				System.err.println("[Warning] Strage attribute range definition '" + definition + "', end smaller than start, ignoring...");
+			} else
+				System.err.println("[Warning] Strage attribute range definition '" + definition
+						+ "', end smaller than start, ignoring...");
 		} else if (Pattern.matches(definitionPositiveRange, definition)) {
 			String[] split = definition.split("-");
 			int start = Integer.valueOf(split[0]);
 			int end = Integer.valueOf(split[1]);
 			if (start == 0 || end == 0) {
-				throw new UnsupportedOperationException("Attribute definition range error - start or end equals 0: " + definition);
+				throw new UnsupportedOperationException(
+						"Attribute definition range error - start or end equals 0: " + definition);
 			}
 			if (start == end) {
-				System.err.println("[Warning] Strage attribute range definition '" + definition + "', start equals end");
+				System.err
+						.println("[Warning] Strage attribute range definition '" + definition + "', start equals end");
 			}
 			Integer i = start;
 			if (start <= end)
-				while(i <= end) {
-					if (!ignoredAttributes.contains(i - 1)) ret.add(i - 1);
+				while (i <= end) {
+					if (!ignoredAttributes.contains(i - 1))
+						ret.add(i - 1);
 					i++;
 				}
-			else 
-				System.err.println("[Warning] Strage attribute range definition '" + definition + "', end smaller of start, ignoring...");
+			else
+				System.err.println("[Warning] Strage attribute range definition '" + definition
+						+ "', end smaller of start, ignoring...");
 		} else if (Pattern.matches(definitionSingle, definition)) {
 			int index = Integer.valueOf(definition);
 			if (index == 0) {
-	    		// Add all non-ignored attributes
+				// Add all non-ignored attributes
 				for (Integer i = 0; i < numAttributes; i++)
-	   				if (!ignoredAttributes.contains(i)) ret.add(i);
+					if (!ignoredAttributes.contains(i))
+						ret.add(i);
 			} else {
-				if (index < 0){
+				if (index < 0) {
 					index = numAttributes + index + 1;
 					if (index <= 0) {
-						throw new UnsupportedOperationException("Attribute definition range error - negative index overflows the number of attributes: " + definition);
+						throw new UnsupportedOperationException(
+								"Attribute definition range error - negative index overflows the number of attributes: "
+										+ definition);
 					}
 				}
-				if (!ignoredAttributes.contains(index - 1)) ret.add(index - 1);
+				if (!ignoredAttributes.contains(index - 1))
+					ret.add(index - 1);
 			}
 		}
 		return ret;
 	}
-	
-    public static List<Integer> parseAttributeDefinition(String attributeDefinition, int numAttributes, List<Integer> ignoredAttributes) {
-    	List<Integer> ret = new ArrayList<Integer>();
-    	if (ignoredAttributes == null) ignoredAttributes = new ArrayList<Integer>();
-    	if (!attributeDefinition.isEmpty()) {
-	    	String[] definitions = attributeDefinition.split("[,;]");
-	    	Pattern definitionsPattern = Pattern.compile(getDefinitionTotal());
-	    	for (int i = 0; i < definitions.length; i++) {
-	    		String definition = definitions[i];
-	    		boolean negative = false;
-	    		if (definition.isEmpty()) {
-	    			continue;
-	    		}
-	    		if (!definitionsPattern.matcher(definition).matches()) throw new UnsupportedOperationException("The attribute definition '" + definition + "' is not recognised.");
-	
-	    		if (definition.startsWith("!")) {
-	    			definition = definition.substring(1);
-	    			negative = true;
-	    		}
-	
-	    		List<Integer> candidates = parseDefinition(definition, numAttributes, ignoredAttributes);
-	    		if (negative) {
-	    			for (Integer j : candidates) {
-	    				if (ret.contains(j)) ret.remove(j);
-	    			}
-	    		} else {
-	    			for (Integer j : candidates) {
-	    				if (!ret.contains(j)) ret.add(j);
-	    			}
-	    		}
-	    	}
-    	} else {
-    		// Add all non-ignored attributes (this is the default behavior for input attributes)
- 			for (Integer i = 0; i < numAttributes; i++)
-   				if (!ignoredAttributes.contains(i)) ret.add(i);
-    	}
-    	return ret;
-    }
-	
-    public static List<Integer> remapAttributeDefitinion(List<Integer> attributeList, List<Integer> indexMap) {
-    	// Remaps the attribute list to only the included attributes, i.e., skip unincluded attributes
-    	
-    	// Example:
-    	// If input attributes = 1 - 11, output attributes = 14, 14 get remapped to 12
-
-    	List<Integer> ret = new ArrayList<Integer>();
-    	for (int i = 0; i < attributeList.size(); i++) {
-    		ret.add(indexMap.indexOf(attributeList.get(i)));
-    	}
-    	return ret;
-    		
-    }
-	
+
+	public static List<Integer> parseAttributeDefinition(String attributeDefinition, int numAttributes,
+			List<Integer> ignoredAttributes) {
+		List<Integer> ret = new ArrayList<>();
+		if (ignoredAttributes == null)
+			ignoredAttributes = new ArrayList<>();
+		if (!attributeDefinition.isEmpty()) {
+			String[] definitions = attributeDefinition.split("[,;]");
+			Pattern definitionsPattern = Pattern.compile(getDefinitionTotal());
+			for (int i = 0; i < definitions.length; i++) {
+				String definition = definitions[i];
+				boolean negative = false;
+				if (definition.isEmpty()) {
+					continue;
+				}
+				if (!definitionsPattern.matcher(definition).matches())
+					throw new UnsupportedOperationException(
+							"The attribute definition '" + definition + "' is not recognised.");
+
+				if (definition.startsWith("!")) {
+					definition = definition.substring(1);
+					negative = true;
+				}
+
+				List<Integer> candidates = parseDefinition(definition, numAttributes, ignoredAttributes);
+				if (negative) {
+					for (Integer j : candidates) {
+						if (ret.contains(j))
+							ret.remove(j);
+					}
+				} else {
+					for (Integer j : candidates) {
+						if (!ret.contains(j))
+							ret.add(j);
+					}
+				}
+			}
+		} else {
+			// Add all non-ignored attributes (this is the default behavior for input
+			// attributes)
+			for (Integer i = 0; i < numAttributes; i++)
+				if (!ignoredAttributes.contains(i))
+					ret.add(i);
+		}
+		return ret;
+	}
+
+	public static List<Integer> remapAttributeDefitinion(List<Integer> attributeList, List<Integer> indexMap) {
+		// Remaps the attribute list to only the included attributes, i.e., skip
+		// unincluded attributes
+
+		// Example:
+		// If input attributes = 1 - 11, output attributes = 14, 14 get remapped to 12
+
+		List<Integer> ret = new ArrayList<>();
+		for (int i = 0; i < attributeList.size(); i++) {
+			ret.add(indexMap.indexOf(attributeList.get(i)));
+		}
+		return ret;
+
+	}
+
 }
diff --git a/moa/src/main/java/moa/core/utils/Converter.java b/moa/src/main/java/moa/core/utils/Converter.java
index 5a06a8490..92a34eae5 100644
--- a/moa/src/main/java/moa/core/utils/Converter.java
+++ b/moa/src/main/java/moa/core/utils/Converter.java
@@ -2,7 +2,7 @@
  *    Converter.java
  *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
  *    @author Jesse Read (jesse@tsc.uc3m.es)
- * 
+ *
  *    This program is free software; you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
  *    the Free Software Foundation; either version 3 of the License, or
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.core.utils;
 
@@ -30,65 +30,66 @@
 /**
  * Converter. This class can be used to convert a multi-label instance into a
  * single-label instance.
- * 
+ *
  * @author Jesse Read (jesse@tsc.uc3m.es)
  * @version $Revision: 1 $
  */
 public class Converter extends AbstractMOAObject {
 
-    protected InstancesHeader m_InstancesTemplate = null;
+	protected InstancesHeader m_InstancesTemplate = null;
 
-    protected int m_L = -1;
+	protected int m_L = -1;
 
-    public int getL() {
-        return this.m_L;
-    }
+	public int getL() {
+		return this.m_L;
+	}
 
-    public Converter() {
-    }
+	public Converter() {
+	}
 
-    public Converter(int n) {
-        m_L = n;
-    }
+	public Converter(int n) {
+		m_L = n;
+	}
 
-    public InstancesHeader createTemplate(InstancesHeader i) {
-        this.m_InstancesTemplate = new InstancesHeader(i, 0, 0);
-        return this.m_InstancesTemplate;
-    }
+	public InstancesHeader createTemplate(InstancesHeader i) {
+		this.m_InstancesTemplate = new InstancesHeader(i, 0, 0);
+		return this.m_InstancesTemplate;
+	}
 
-    public Instance formatInstance(Instance original) {
+	public Instance formatInstance(Instance original) {
 
-        //Copy the original instance
-        Instance converted = (Instance) original.copy();
-        converted.setDataset(null);
+		// Copy the original instance
+		Instance converted = original.copy();
+		converted.setDataset(null);
 
-        //Delete all class attributes
-        for (int j = 0; j < m_L; j++) {
-            converted.deleteAttributeAt(0);
-        }
+		// Delete all class attributes
+		for (int j = 0; j < m_L; j++) {
+			converted.deleteAttributeAt(0);
+		}
 
-        //Add one of those class attributes at the begginning
-        converted.insertAttributeAt(0);
+		// Add one of those class attributes at the begginning
+		converted.insertAttributeAt(0);
 
-        //Hopefully setting the dataset will configure that attribute properly
-        converted.setDataset(m_InstancesTemplate);
+		// Hopefully setting the dataset will configure that attribute properly
+		converted.setDataset(m_InstancesTemplate);
 
-        return converted;
+		return converted;
 
-    }
+	}
 
-    public List<Integer> getRelevantLabels(Instance x) {
-        List<Integer> classValues = new LinkedList<Integer>();
-        //get all class attributes
-        for (int j = 0; j < m_L; j++) {
-            if (x.value(j) > 0.0) {
-                classValues.add(j);
-            }
-        }
-        return classValues;
-    }
+	public List<Integer> getRelevantLabels(Instance x) {
+		List<Integer> classValues = new LinkedList<>();
+		// get all class attributes
+		for (int j = 0; j < m_L; j++) {
+			if (x.value(j) > 0.0) {
+				classValues.add(j);
+			}
+		}
+		return classValues;
+	}
 
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
 }
diff --git a/moa/src/main/java/moa/evaluation/ALMeasureCollection.java b/moa/src/main/java/moa/evaluation/ALMeasureCollection.java
index f0e54ded3..d926f2eb2 100644
--- a/moa/src/main/java/moa/evaluation/ALMeasureCollection.java
+++ b/moa/src/main/java/moa/evaluation/ALMeasureCollection.java
@@ -35,15 +35,14 @@ public class ALMeasureCollection extends MeasureCollection implements Classifica
 
 	private static final long serialVersionUID = 1L;
 
-    @Override
-    protected String[] getNames() {
-        return new String[]{"Accuracy", "Kappa", "Kappa Temp", "Ram-Hours",
-                    "Time", "Memory", "Label Acq. Rate"};
-    }
+	@Override
+	protected String[] getNames() {
+		return new String[] { "Accuracy", "Kappa", "Kappa Temp", "Ram-Hours", "Time", "Memory", "Label Acq. Rate" };
+	}
 
-    @Override
-    public void evaluateClustering(Clustering clustering, Clustering trueClsutering, ArrayList<DataPoint> points) {
+	@Override
+	public void evaluateClustering(Clustering clustering, Clustering trueClsutering, ArrayList<DataPoint> points) {
 
-    }
+	}
 
 }
\ No newline at end of file
diff --git a/moa/src/main/java/moa/evaluation/Accuracy.java b/moa/src/main/java/moa/evaluation/Accuracy.java
index 049ef9913..1384d5547 100644
--- a/moa/src/main/java/moa/evaluation/Accuracy.java
+++ b/moa/src/main/java/moa/evaluation/Accuracy.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.evaluation;
 
@@ -26,26 +26,27 @@
 
 public class Accuracy extends MeasureCollection implements ClassificationMeasureCollection {
 
-    private boolean debug = false;
+	private boolean debug = false;
 
-    public Accuracy() {
-        super();
-    }
+	public Accuracy() {
+		super();
+	}
 
-    @Override
-    public String[] getNames() {
-        String[] names = {"Accuracy", "Kappa", "Kappa Temp", "Ram-Hours", "Time", "Memory"};
-        return names;
-    }
+	@Override
+	public String[] getNames() {
+		String[] names = { "Accuracy", "Kappa", "Kappa Temp", "Ram-Hours", "Time", "Memory" };
+		return names;
+	}
 
-    @Override
-    protected boolean[] getDefaultEnabled() {
-        boolean[] defaults = {true, true, true, true, true, true};
-        return defaults;
-    }
+	@Override
+	protected boolean[] getDefaultEnabled() {
+		boolean[] defaults = { true, true, true, true, true, true };
+		return defaults;
+	}
 
-    public void evaluateClustering(Clustering clustering, Clustering trueClsutering, ArrayList<DataPoint> points) {
+	@Override
+	public void evaluateClustering(Clustering clustering, Clustering trueClsutering, ArrayList<DataPoint> points) {
 
-    }
+	}
 
 }
diff --git a/moa/src/main/java/moa/evaluation/BasicClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/BasicClassificationPerformanceEvaluator.java
deleted file mode 100644
index 5fef6029d..000000000
--- a/moa/src/main/java/moa/evaluation/BasicClassificationPerformanceEvaluator.java
+++ /dev/null
@@ -1,339 +0,0 @@
-/*
- *    BasicClassificationPerformanceEvaluator.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.evaluation;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-
-import com.github.javacliparser.FlagOption;
-import moa.capabilities.Capability;
-import moa.capabilities.ImmutableCapabilities;
-import moa.core.Example;
-import moa.core.Measurement;
-import moa.core.ObjectRepository;
-import moa.core.Utils;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
-/**
- * Classification evaluator that performs basic incremental evaluation.
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * 
- * Updates in September 15th 2017 to include precision, recall and F1 scores.
- * @author Jean Karax (karaxjr@gmail.com)
- * @author Jean Paul Barddal (jean.barddal@ppgia.pucpr.br)
- * @author Wilson Sasaki Jr (sasaki.wilson.jr@gmail.com)
- * @version $Revision: 8 $
- */
-public class BasicClassificationPerformanceEvaluator extends AbstractOptionHandler implements ClassificationPerformanceEvaluator {
-
-    private static final long serialVersionUID = 1L;
-
-    protected Estimator weightCorrect;
-
-    protected Estimator[] columnKappa;
-
-    protected Estimator[] rowKappa;
-
-    protected Estimator[] precision;
-
-    protected Estimator[] recall;
-
-    protected int numClasses;
-
-    private Estimator weightCorrectNoChangeClassifier;
-
-    private Estimator weightMajorityClassifier;
-
-    private int lastSeenClass;
-
-    private double totalWeightObserved;
-
-    public FlagOption precisionRecallOutputOption = new FlagOption("precisionRecallOutput",
-            'o',
-            "Outputs average precision, recall and F1 scores.");
-    
-    public FlagOption precisionPerClassOption = new FlagOption("precisionPerClass",
-            'p',
-            "Report precision per class.");
-
-    public FlagOption recallPerClassOption = new FlagOption("recallPerClass",
-            'r',
-            "Report recall per class.");
-
-    public FlagOption f1PerClassOption = new FlagOption("f1PerClass", 'f',
-            "Report F1 per class.");
-
-    @Override
-    public void reset() {
-        reset(this.numClasses);
-    }
-
-    public void reset(int numClasses) {
-        this.numClasses = numClasses;
-        this.rowKappa = new  Estimator[numClasses];
-        this.columnKappa = new  Estimator[numClasses];
-        this.precision = new Estimator[numClasses];
-        this.recall = new Estimator[numClasses];
-        for (int i = 0; i < this.numClasses; i++) {
-            this.rowKappa[i] = newEstimator();
-            this.columnKappa[i] = newEstimator();
-            this.precision[i] = newEstimator();
-            this.recall[i] = newEstimator();
-        }
-        this.weightCorrect = newEstimator();
-        this.weightCorrectNoChangeClassifier = newEstimator();
-        this.weightMajorityClassifier = newEstimator();
-        this.lastSeenClass = 0;
-        this.totalWeightObserved = 0;
-    }
-
-    @Override
-    public void addResult(Example<Instance> example, double[] classVotes) {
-        Instance inst = example.getData();
-        double weight = inst.weight();
-        if (inst.classIsMissing() == false){
-            int trueClass = (int) inst.classValue();
-            int predictedClass = Utils.maxIndex(classVotes);
-            if (weight > 0.0) {
-                if (this.totalWeightObserved == 0) {
-                    reset(inst.dataset().numClasses());
-                }
-                this.totalWeightObserved += weight;
-                this.weightCorrect.add(predictedClass == trueClass ? weight : 0);
-                for (int i = 0; i < this.numClasses; i++) {
-                    this.rowKappa[i].add(predictedClass == i ? weight: 0);
-                    this.columnKappa[i].add(trueClass == i ? weight: 0);
-                    // for both precision and recall, NaN values are used to 'balance' the number
-                    // of instances seen across classes
-                    if (predictedClass == i) {
-                        precision[i].add(predictedClass == trueClass ? weight : 0.0);
-                    } else precision[i].add(Double.NaN);
-                    if (trueClass == i) {
-                        recall[i].add(predictedClass == trueClass ? weight : 0.0);
-                    } else recall[i].add(Double.NaN);
-                }
-            }
-            this.weightCorrectNoChangeClassifier.add(this.lastSeenClass == trueClass ? weight: 0);
-            this.weightMajorityClassifier.add(getMajorityClass() == trueClass ? weight: 0);
-            this.lastSeenClass = trueClass;
-        }
-    }
-
-    private int getMajorityClass() {
-        int majorityClass = 0;
-        double maxProbClass = 0.0;
-        for (int i = 0; i < this.numClasses; i++) {
-            if (this.columnKappa[i].estimation() > maxProbClass) {
-                majorityClass = i;
-                maxProbClass = this.columnKappa[i].estimation();
-            }
-        }
-        return majorityClass;
-    }
-
-    @Override
-    public Measurement[] getPerformanceMeasurements() {
-        ArrayList<Measurement> measurements = new ArrayList<Measurement>();
-        measurements.add(new Measurement("classified instances", this.getTotalWeightObserved()));
-        measurements.add(new Measurement("classifications correct (percent)", this.getFractionCorrectlyClassified() * 100.0));
-        measurements.add(new Measurement("Kappa Statistic (percent)", this.getKappaStatistic() * 100.0));
-        measurements.add(new Measurement("Kappa Temporal Statistic (percent)", this.getKappaTemporalStatistic() * 100.0));
-        measurements.add(new Measurement("Kappa M Statistic (percent)", this.getKappaMStatistic() * 100.0));
-        if (precisionRecallOutputOption.isSet()) 
-            measurements.add(new Measurement("F1 Score (percent)", 
-                    this.getF1Statistic() * 100.0));
-        if (f1PerClassOption.isSet()) {
-            for (int i = 0; i < this.numClasses; i++) {
-                measurements.add(new Measurement("F1 Score for class " + i + 
-                        " (percent)", 100.0 * this.getF1Statistic(i)));
-            }
-        }
-        if (precisionRecallOutputOption.isSet())
-            measurements.add(new Measurement("Precision (percent)", 
-                this.getPrecisionStatistic() * 100.0));               
-        if (precisionPerClassOption.isSet()) {
-            for (int i = 0; i < this.numClasses; i++) {
-                measurements.add(new Measurement("Precision for class " + i + 
-                        " (percent)", 100.0 * this.getPrecisionStatistic(i)));
-            }
-        }
-        if (precisionRecallOutputOption.isSet())
-            measurements.add(new Measurement("Recall (percent)", 
-                this.getRecallStatistic() * 100.0));
-        if (recallPerClassOption.isSet()) {
-            for (int i = 0; i < this.numClasses; i++) {
-                measurements.add(new Measurement("Recall for class " + i + 
-                        " (percent)", 100.0 * this.getRecallStatistic(i)));
-            }
-        }
-
-        Measurement[] result = new Measurement[measurements.size()];
-
-        return measurements.toArray(result);
-
-    }
-
-    public double getTotalWeightObserved() {
-        return this.totalWeightObserved;
-    }
-
-    public double getFractionCorrectlyClassified() {
-        return this.weightCorrect.estimation();
-    }
-
-    public double getFractionIncorrectlyClassified() {
-        return 1.0 - getFractionCorrectlyClassified();
-    }
-
-    public double getKappaStatistic() {
-        if (this.getTotalWeightObserved() > 0.0) {
-            double p0 = getFractionCorrectlyClassified();
-            double pc = 0.0;
-            for (int i = 0; i < this.numClasses; i++) {
-                pc += this.rowKappa[i].estimation()
-                        * this.columnKappa[i].estimation();
-            }
-            return (p0 - pc) / (1.0 - pc);
-        } else {
-            return 0;
-        }
-    }
-
-    public double getKappaTemporalStatistic() {
-        if (this.getTotalWeightObserved() > 0.0) {
-            double p0 = getFractionCorrectlyClassified();
-            double pc = this.weightCorrectNoChangeClassifier.estimation();
-
-            return (p0 - pc) / (1.0 - pc);
-        } else {
-            return 0;
-        }
-    }
-
-    private double getKappaMStatistic() {
-        if (this.getTotalWeightObserved() > 0.0) {
-            double p0 = getFractionCorrectlyClassified();
-            double pc = this.weightMajorityClassifier.estimation();
-
-            return (p0 - pc) / (1.0 - pc);
-        } else {
-            return 0;
-        }
-    }
-
-    public double getPrecisionStatistic() {
-        double total = 0;
-        for (Estimator ck : this.precision) {
-            total += ck.estimation();
-        }
-        return total / this.precision.length;
-    }
-
-    public double getPrecisionStatistic(int numClass) {
-        return this.precision[numClass].estimation();
-    }
-
-    public double getRecallStatistic() {
-        double total = 0;
-        for (Estimator ck : this.recall) {
-            total += ck.estimation();
-        }
-        return total / this.recall.length;
-    }
-
-    public double getRecallStatistic(int numClass) {
-        return this.recall[numClass].estimation();
-    }
-
-    public double getF1Statistic() {
-        return 2 * ((this.getPrecisionStatistic() * this.getRecallStatistic())
-                / (this.getPrecisionStatistic() + this.getRecallStatistic()));
-    }
-
-    public double getF1Statistic(int numClass) {
-        return 2 * ((this.getPrecisionStatistic(numClass) * this.getRecallStatistic(numClass))
-                / (this.getPrecisionStatistic(numClass) + this.getRecallStatistic(numClass)));
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        Measurement.getMeasurementsDescription(getPerformanceMeasurements(),
-                sb, indent);
-    }
-
-	@Override
-	public void addResult(Example<Instance> testInst, Prediction prediction) {
-		this.addResult(testInst, prediction.asDoubleArray());		
-	}
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-
-    }
-
-    public interface Estimator extends Serializable {
-
-        void add(double value);
-
-        double estimation();
-    }
-
-    public class BasicEstimator implements Estimator {
-
-        protected double len;
-
-        protected double sum;
-
-        @Override
-        public void add(double value) {
-            if(!Double.isNaN(value)) {
-            sum += value;
-            len++;
-            }
-        }
-
-        @Override
-        public double estimation(){
-            return sum/len;
-        }
-
-    }
-
-    protected Estimator newEstimator() {
-        return new BasicEstimator();
-    }
-
-
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == BasicClassificationPerformanceEvaluator.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
-}
diff --git a/moa/src/main/java/moa/evaluation/BasicConceptDriftPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/BasicConceptDriftPerformanceEvaluator.java
deleted file mode 100644
index a6b14931f..000000000
--- a/moa/src/main/java/moa/evaluation/BasicConceptDriftPerformanceEvaluator.java
+++ /dev/null
@@ -1,210 +0,0 @@
-/*
- *    BasicConceptDriftPerformanceEvaluator.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Albert Bifet (abifet@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 2 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program; if not, write to the Free Software
- *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-package moa.evaluation;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.AbstractMOAObject;
-import moa.core.Example;
-import moa.core.Measurement;
-
-public class BasicConceptDriftPerformanceEvaluator extends AbstractMOAObject
-        implements LearningPerformanceEvaluator<Example<Instance>> {
-
-    private static final long serialVersionUID = 1L;
-
-    protected double weightObserved;
-
-    protected double numberDetections;
-    
-    protected double numberDetectionsOccurred;
-
-    protected double numberChanges;
-
-    protected double numberWarnings;
-
-    protected double delay;
-
-    protected double errorPrediction;
-
-    protected double totalDelay;
-    
-    protected boolean isWarningZone;
-    
-    protected double inputValues;
-
-    @Override
-    public void reset() {
-        this.weightObserved = 0.0;
-        this.numberDetections = 0.0;
-        this.numberDetectionsOccurred = 0.0;
-        this.errorPrediction = 0.0;
-        this.numberChanges = 0.0;
-        this.numberWarnings = 0.0;
-        this.delay = 0.0;
-        this.totalDelay = 0.0;
-        this.isWarningZone = false;
-        this.inputValues = 0.0;
-        this.hasChangeOccurred = false;
-    }
-
-    private boolean hasChangeOccurred = false;
-    
-    @Override
-    public void addResult(Example<Instance> example, double[] classVotes) {
-        Instance inst = example.getData();
-        //classVotes[0] -> is Change
-        //classVotes[1] -> is in Warning Zone
-        //classVotes[2] -> delay
-        //classVotes[3] -> estimation
-
-        this.inputValues = inst.value(2);
-        if (inst.weight() > 0.0 && classVotes.length == 4) {
-            if (inst.numAttributes() > 1) {
-                //if there is ground truth we monitor delay
-                this.delay++;
-            }
-            this.weightObserved += inst.weight();
-            if ( classVotes[0] == 1.0) {
-                //Change detected
-                //System.out.println("Change detected with delay "+ this.delay );
-                this.numberDetections += inst.weight();
-                if (this.hasChangeOccurred == true) { 
-                    this.totalDelay += this.delay - classVotes[2];
-                    this.numberDetectionsOccurred += inst.weight();
-                    this.hasChangeOccurred = false;
-                }
-            }
-            if (this.hasChangeOccurred && classVotes[1] == 1.0) {
-                //Warning detected
-                //System.out.println("Warning detected at "+getTotalWeightObserved());
-                if (this.isWarningZone == false) {
-                    this.numberWarnings += inst.weight();
-                    this.isWarningZone = true;
-                } 
-            } else {
-                this.isWarningZone = false;
-            }
-            if (inst.numAttributes() > 1) {
-                if (inst.value(inst.numAttributes() - 2) == 1.0) {//Attribute 1
-                    //Ground truth Change
-                    this.numberChanges += inst.weight();
-                    this.delay = 0;
-                    this.hasChangeOccurred = true;
-                }
-            }
-            //Compute error prediction
-            if (classVotes.length > 1) {
-                this.errorPrediction += Math.abs(classVotes[3] - inst.value(0));
-            }
-        }
-    }
-
-    @Override
-    public Measurement[] getPerformanceMeasurements() {
-        Measurement[] measurement;
-        //if (totalDelay == 0.0) { //No Ground Truth
-            measurement = new Measurement[]{
-                new Measurement("learned instances",
-                getTotalWeightObserved()),
-                new Measurement("detected changes",
-                getNumberDetections()),
-                new Measurement("detected warnings",
-                getNumberWarnings()),
-                new Measurement("prediction error (average)",
-                getPredictionError() / getTotalWeightObserved()),
-                new Measurement("true changes",
-                getNumberChanges()),
-                new Measurement("delay detection (average)",
-                getTotalDelay() / getNumberChanges()),
-                new Measurement("true changes detected",
-                getNumberChangesOccurred()),
-                new Measurement("input values",
-                getInputValues())
-            };
-       /* } else {
-            measurement = new Measurement[]{
-                new Measurement("learned instances",
-                getTotalWeightObserved()),
-                new Measurement("detected changes",
-                getNumberDetections()),
-                new Measurement("detected warnings",
-                getNumberWarnings()),
-                new Measurement("prediction error (average)",
-                getPredictionError() / getTotalWeightObserved()),
-                new Measurement("true changes",
-                getNumberChanges()),
-                new Measurement("delay detection (average)",
-                getTotalDelay() / getNumberChanges()),
-                new Measurement("true changes detected",
-                getNumberChangesOccurred()),
-                new Measurement("input values",
-                getInputValues())
-            };
-        }*/
-        return measurement;
-    }
-
-    public double getTotalWeightObserved() {
-        return this.weightObserved > 0 ? this.weightObserved : 1.0;
-    }
-
-    public double getNumberDetections() {
-        return this.numberDetections;
-    }
-    
-    public double getInputValues() {
-        return this.inputValues;
-    }
-
-    public double getPredictionError() {
-        return this.errorPrediction;
-    }
-
-    public double getNumberChanges() {
-        return this.numberChanges;
-    }
-    
-    public double getNumberChangesOccurred() {
-        return  this.numberDetectionsOccurred;
-    }
-
-    public double getNumberWarnings() {
-        return this.numberWarnings;
-    }
-
-    public double getTotalDelay() {
-        return this.totalDelay;
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        Measurement.getMeasurementsDescription(getPerformanceMeasurements(),
-                sb, indent);
-    }
-
-	@Override
-	public void addResult(Example<Instance> testInst, Prediction prediction) {
-		// TODO Auto-generated method stub
-		
-	}
-    
-}
diff --git a/moa/src/main/java/moa/evaluation/BasicMultiLabelPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/BasicMultiLabelPerformanceEvaluator.java
deleted file mode 100644
index b3f9e3d11..000000000
--- a/moa/src/main/java/moa/evaluation/BasicMultiLabelPerformanceEvaluator.java
+++ /dev/null
@@ -1,187 +0,0 @@
-/*
- *    BasicMultiLabelPerformanceEvaluator.java
- *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
- *    @author Jesse Read (jesse@tsc.uc3m.es)
- * 
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package moa.evaluation;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.AbstractMOAObject;
-import moa.core.Example;
-import moa.core.Measurement;
-
-/**
- * Multilabel Window Classification Performance Evaluator.
- * 
- * @author Jesse Read (jesse@tsc.uc3m.es)
- * @version $Revision: 1 $
- *
- * Added instance based F-Measure, Recall, Precision and Accuracy
- * @author R. Sousa, J.Gama
- * @version $Revision: 2 $
- *
- */
-public class BasicMultiLabelPerformanceEvaluator extends AbstractMOAObject implements MultiLabelClassificationPerformanceEvaluator {
-
-	protected int L;
-
-	/** running sum of accuracy */
-    double sumAccuracy = 0.0;
-	double sumHamming = 0.0;
-    double sumAccuracy2 = 0.0;
-    double sumPrecision=0.0;
-    double sumRecall=0.0;
-    double sumFmeasure=0.0;
-
-
-	/** running number of examples */
-    int sumExamples = 0;
-
-	/** preset threshold */
-    private double t = 0.5;
-
-    @Override
-    public void reset() {
-		sumAccuracy = 0.0;
-		sumHamming = 0.0;
-		sumExamples = 0;
-        sumAccuracy2 = 0.0;
-        sumPrecision=0.0;
-        sumRecall=0.0;
-        sumFmeasure=0.0;
-    }
-
-    @Override
-	public void addResult(Example<Instance> example, Prediction y) {
-
-        int sumReunion= 0;
-        int sumInterse= 0;
-        int sumOnesTrue=0;
-        int sumOnesPred=0;
-
-		Instance x = (Instance) example.getData();
-
-        for (int j = 0; j < y.numOutputAttributes(); j++) {
-            System.out.print( (int)x.classValue(j));
-        }
-        System.out.print(" ");
-
-
-        for (int j = 0; j < y.numOutputAttributes(); j++) {
-            System.out.print( (y.getVote(j,0) > t) ? 1 : 0);
-        }
-        System.out.print("\n");
-
-
-
-		if (L == 0) {
-			L = x.numOutputAttributes();
-		}
-
-		if (y == null) {
-			System.err.print("[WARNING] Prediction is null! (Ignoring this prediction)");
-		}
-		else if (y.numOutputAttributes() < x.numOutputAttributes()) {
-			System.err.println("[WARNING] Only "+y.numOutputAttributes()+" labels found! (Expecting "+x.numOutputAttributes()+")\n (Ignoring this prediction)");
-		}
-		else {
-			sumExamples++;
-			int correct = 0;
-			for (int j = 0; j < y.numOutputAttributes(); j++) {
-                int yp = (y.getVote(j,0) > t) ? 1 : 0;
-				correct += ((int)x.classValue(j) == yp) ? 1 : 0;
-
-                int y_true = (int)x.valueOutputAttribute(j);
-                if (y_true == yp)
-                    correct++;
-
-                if(y_true==1 || yp==1)
-                    sumReunion++;
-
-                if(y_true==1 &&  yp==1)
-                    sumInterse++;
-
-                if(y_true==1)
-                    sumOnesTrue++;
-
-                if(yp==1)
-                    sumOnesPred++;
-
-			}
-
-            //Accuracy by instance(Jaccard Index)
-            if(sumReunion>0){
-                sumAccuracy2 += (double)sumInterse/sumReunion;
-            }
-            else{
-                sumAccuracy2+=0.0;
-            }
-
-            //Precision by instance
-            if(sumOnesTrue>0){
-                sumPrecision+= (double) sumInterse/sumOnesTrue;
-            }
-
-            //Recall by instance
-            if(sumOnesPred>0){
-                sumRecall+= (double)(sumInterse/sumOnesPred);
-            }
-
-            //F-Measure by instance
-            if((sumOnesPred+sumOnesTrue)>0){
-                sumFmeasure+= (double) 2*sumInterse/(sumOnesPred+sumOnesTrue);
-            }
-            else{
-                sumFmeasure+=0.0;
-            }
-
-			sumHamming+=(correct/(double)L); 			// Hamming Score
-			sumAccuracy += (correct == L) ? 1 : 0; 		// Exact Match
-		}
-    }
-
-    @Override
-    public Measurement[] getPerformanceMeasurements() {
-
-        // gather measurements
-        Measurement m[] = new Measurement[]{
-                new Measurement("Exact Match", sumAccuracy/sumExamples),
-                new Measurement("Accuracy", (double) sumAccuracy2/sumExamples),
-                new Measurement("Hamming Score", sumHamming/sumExamples),
-                new Measurement("Precision",((double) sumPrecision)/sumExamples),
-                new Measurement("Recall",(double) sumRecall/sumExamples),
-                new Measurement("F-Measure", (double) sumFmeasure/sumExamples),
-        };
-
-        // reset
-        // reset();
-
-        return m;
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        sb.append("Basic Multi-label Performance Evaluator");
-    }
-
-	@Override
-	public void addResult(Example<Instance> example, double[] classVotes) {
-		// TODO Auto-generated method stub
-		
-	}
-}
diff --git a/moa/src/main/java/moa/evaluation/BasicMultiTargetPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/BasicMultiTargetPerformanceEvaluator.java
deleted file mode 100644
index 74f554006..000000000
--- a/moa/src/main/java/moa/evaluation/BasicMultiTargetPerformanceEvaluator.java
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
- *    BasicRegressionPerformanceEvaluator.java
- *    Copyright (C) 2011 University of Waikato, Hamilton, New Zealand
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.evaluation;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.AbstractMOAObject;
-import moa.core.Example;
-import moa.core.Measurement;
-
-/**
- * Regression evaluator that performs basic incremental evaluation.
- *
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @version $Revision: 7 $
- */
-public class BasicMultiTargetPerformanceEvaluator extends AbstractMOAObject
-        implements MultiTargetRegressionPerformanceEvaluator{
-
-    private static final long serialVersionUID = 1L;
-
-    protected double weightObserved;
-
-    protected double squareError;
-
-    protected double averageError;
-    
-    protected int numberOutputs;
-
-    @Override
-    public void reset() {
-        this.weightObserved = 0.0;
-        this.squareError = 0.0;
-        this.averageError = 0.0;
-    }
-
-    @Override
-    public void addResult(Example<Instance> example, Prediction prediction) {
-
-    StructuredInstance inst = (StructuredInstance) example.getData();
-    if (numberOutputs == 0) {
-    	numberOutputs = inst.numOutputAttributes();
-    }
-        if (inst.weight() > 0.0) {
-            this.weightObserved += inst.weight();
-            if (prediction != null ) {
-            	for (int i = 0; i< numberOutputs;i++){
-            		double err = inst.classValue(i) - ((prediction.numOutputAttributes()==0) ? 0.0 : prediction.getVote(i,0));
-	                this.squareError += (err) * (err);
-	                this.averageError += Math.abs(err);
-            	}
-            }
-            //System.out.println(inst.classValue()+", "+prediction);
-        }
-    }
-
-    @Override
-    public Measurement[] getPerformanceMeasurements() {
-        return new Measurement[]{
-                    new Measurement("classified instances",
-                    getTotalWeightObserved()),
-                    new Measurement("mean absolute error",
-                    getMeanError()),
-                    new Measurement("root mean squared error",
-                    getSquareError())};
-    }
-
-    public double getTotalWeightObserved() {
-        return this.weightObserved;
-    }
-
-    public double getMeanError() {
-        return this.weightObserved > 0.0 ? this.averageError
-                / (this.weightObserved * this.numberOutputs) : 0.0;
-    }
-
-    public double getSquareError() {
-        return Math.sqrt(this.weightObserved > 0.0 ? this.squareError
-                / (this.weightObserved * this.numberOutputs): 0.0);
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        Measurement.getMeasurementsDescription(getPerformanceMeasurements(),
-                sb, indent);
-    }
-
-	@Override
-	public void addResult(Example<Instance> example, double[] classVotes) {
-		// TODO Auto-generated method stub
-		
-	}
-
-}
diff --git a/moa/src/main/java/moa/evaluation/BasicRegressionPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/BasicRegressionPerformanceEvaluator.java
deleted file mode 100644
index 650ccbede..000000000
--- a/moa/src/main/java/moa/evaluation/BasicRegressionPerformanceEvaluator.java
+++ /dev/null
@@ -1,146 +0,0 @@
-/*
- *    BasicRegressionPerformanceEvaluator.java
- *    Copyright (C) 2011 University of Waikato, Hamilton, New Zealand
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.evaluation;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.AbstractMOAObject;
-import moa.core.Example;
-import moa.core.Measurement;
-
-/**
- * Regression evaluator that performs basic incremental evaluation.
- *
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @version $Revision: 7 $
- */
-public class BasicRegressionPerformanceEvaluator extends AbstractMOAObject
-        implements RegressionPerformanceEvaluator {
-
-    private static final long serialVersionUID = 1L;
-
-    protected double weightObserved;
-
-    protected double squareError;
-
-    protected double averageError;
-
-    protected double sumTarget;
-    
-    protected double squareTargetError;
-    
-    protected double averageTargetError;
-
-    @Override
-    public void reset() {
-        this.weightObserved = 0.0;
-        this.squareError = 0.0;
-        this.averageError = 0.0;
-        this.sumTarget = 0.0;
-        this.averageTargetError = 0.0;
-        this.squareTargetError = 0.0;
-        
-    }
-
-    @Override
-    public void addResult(Example<Instance> example, double[] prediction) {
-	Instance inst = example.getData();
-        if (inst.weight() > 0.0) {
-            if (prediction.length > 0) {
-                double meanTarget = this.weightObserved != 0 ? 
-                            this.sumTarget / this.weightObserved : 0.0;
-                this.squareError += (inst.classValue() - prediction[0]) * (inst.classValue() - prediction[0]);
-                this.averageError += Math.abs(inst.classValue() - prediction[0]);
-                this.squareTargetError += (inst.classValue() - meanTarget) * (inst.classValue() - meanTarget);
-                this.averageTargetError += Math.abs(inst.classValue() - meanTarget);
-                this.sumTarget += inst.classValue();
-                this.weightObserved += inst.weight();
-            }
-           //System.out.println(inst.classValue()+", "+prediction[0]);
-        }
-    }
-
-    @Override
-    public Measurement[] getPerformanceMeasurements() {
-        return new Measurement[]{
-                    new Measurement("classified instances",
-                    getTotalWeightObserved()),
-                    new Measurement("mean absolute error",
-                    getMeanError()),
-                    new Measurement("root mean squared error",
-                    getSquareError()),
-                    new Measurement("relative mean absolute error",
-                    getRelativeMeanError()),
-                    new Measurement("relative root mean squared error",
-                    getRelativeSquareError())
-        };
-    }
-
-    public double getTotalWeightObserved() {
-        return this.weightObserved;
-    }
-
-    public double getMeanError() {
-        return this.weightObserved > 0.0 ? this.averageError
-                / this.weightObserved : 0.0;
-    }
-
-    public double getSquareError() {
-        return Math.sqrt(this.weightObserved > 0.0 ? this.squareError
-                / this.weightObserved : 0.0);
-    }
-
-    public double getTargetMeanError() {
-        return this.weightObserved > 0.0 ? this.averageTargetError
-                / this.weightObserved : 0.0;
-    }
-
-    public double getTargetSquareError() {
-        return Math.sqrt(this.weightObserved > 0.0 ? this.squareTargetError
-                / this.weightObserved : 0.0);
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        Measurement.getMeasurementsDescription(getPerformanceMeasurements(),
-                sb, indent);
-    }
-
-    private double getRelativeMeanError() {
-        //double targetMeanError = getTargetMeanError();
-        //return targetMeanError > 0 ? getMeanError()/targetMeanError : 0.0;
-        return this.averageTargetError> 0 ?
-                this.averageError/this.averageTargetError : 0.0;
-}
-
-    private double getRelativeSquareError() {
-        //double targetSquareError = getTargetSquareError();
-        //return targetSquareError > 0 ? getSquareError()/targetSquareError : 0.0;
-    return Math.sqrt(this.squareTargetError> 0 ?
-                this.squareError/this.squareTargetError : 0.0);
-    }
-    
-    @Override
-    public void addResult(Example<Instance> example, Prediction prediction) {
-    	if(prediction!=null)
-    		addResult(example,prediction.asDoubleArray());
-    }
-}
diff --git a/moa/src/main/java/moa/evaluation/CMM.java b/moa/src/main/java/moa/evaluation/CMM.java
index 4005c65b6..50c000d53 100644
--- a/moa/src/main/java/moa/evaluation/CMM.java
+++ b/moa/src/main/java/moa/evaluation/CMM.java
@@ -1,10 +1,10 @@
 /**
  * [CMM.java]
- * 
+ *
  * CMM: Main class
- * 
+ *
  * Reference: Kremer et al., "An Effective Evaluation Measure for Clustering on Evolving Data Streams", KDD, 2011
- * 
+ *
  * @author Timm jansen
  * Data Management and Data Exploration Group, RWTH Aachen University
  *
@@ -19,8 +19,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.evaluation;
@@ -33,473 +33,467 @@
 import moa.evaluation.CMM_GTAnalysis.CMMPoint;
 import moa.gui.visualization.DataPoint;
 
+public class CMM extends MeasureCollection {
 
-public class CMM extends MeasureCollection{
-    
-	
 	private static final long serialVersionUID = 1L;
 
 	/**
-     * found clustering
-     */
+	 * found clustering
+	 */
 	private Clustering clustering;
 
 	/**
 	 * the ground truth analysis
 	 */
-    private CMM_GTAnalysis gtAnalysis;
-
-    /**
-     * number of points within the horizon
-     */
-    private int numPoints;
-    
-    /**
-     * number of clusters in the found clustering
-     */
-    private int numFClusters;
-    
-    /**
-     * number of cluster in the adjusted groundtruth clustering that 
-     * was calculated through the groundtruth analysis 
-     */
-    private int numGT0Classes;
-
-    /**
-     * match found clusters to GT clusters
-     */
-    private int matchMap[]; 
-    
-    /**
-     * pointInclusionProbFC[p][C] contains the probability of point p 
-     * being included in cluster C 
-     */
-    private double[][] pointInclusionProbFC;
-    
-    /**
-     * threshold that defines when a point is being considered belonging to a cluster
-     */
-    private double pointInclusionProbThreshold = 0.5;
-    
-    /**
-     * parameterize the error weight of missed points (default 1)
-     */
-    private double lamdaMissed = 1;
-
-    
-    /**
-     * enable/disable debug mode
-     */
-    public boolean debug = false;
-
-    
-    /**
-     * enable/disable class merge (main feature of ground truth analysis)
-     */
-    public boolean enableClassMerge = true;
-    
-    /**
-     * enable/disable model error
-     * when enabled errors that are caused by the underling cluster model will not be counted
-     */
-    public boolean enableModelError = true;
-    
-
-    @Override
-    protected String[] getNames() {
-        String[] names = {"CMM","CMM Basic","CMM Missed","CMM Misplaced","CMM Noise",
-                            "CA Seperability", "CA Noise", "CA Model"};
-        return names;
-    }
-
-    @Override
-    protected boolean[] getDefaultEnabled() {
-        boolean [] defaults = {false, false, false, false, false, false, false, false};
-        return defaults;
-    }
-
-    
-    @Override
-    public void evaluateClustering(Clustering clustering, Clustering trueClustering, ArrayList<DataPoint> points) throws Exception{
-        this.clustering = clustering;
-
-        numPoints = points.size();
-        numFClusters = clustering.size();
-
-        gtAnalysis = new CMM_GTAnalysis(trueClustering, points, enableClassMerge);
-
-        numGT0Classes = gtAnalysis.getNumberOfGT0Classes();
-
-        addValue("CA Seperability",gtAnalysis.getClassSeparability());
-        addValue("CA Noise",gtAnalysis.getNoiseSeparability());
-        addValue("CA Model",gtAnalysis.getModelQuality());
-
-        /* init the matching and point distances */
-        calculateMatching();
-
-        /* calculate the actual error */
-        calculateError();
-    }
-
-    
-    /**
-     * calculates the CMM specific matching between found clusters and ground truth clusters 
-     */
-    private void calculateMatching(){
-
-    	/**
-    	 * found cluster frequencies  
-    	 */
-        int[][] mapFC = new int[numFClusters][numGT0Classes];
-
-        /**
-    	 * ground truth cluster frequencies
-    	 */
-        int[][] mapGT = new int[numGT0Classes][numGT0Classes];
-        int [] sumsFC = new int[numFClusters];
-
-        //calculate fuzzy mapping from
-        pointInclusionProbFC = new double[numPoints][numFClusters];
-        for (int p = 0; p < numPoints; p++) {
-            CMMPoint cmdp = gtAnalysis.getPoint(p);
-            //found cluster frequencies
-            for (int fc = 0; fc < numFClusters; fc++) {
-                Cluster cl = clustering.get(fc);
-                pointInclusionProbFC[p][fc] = cl.getInclusionProbability(cmdp);
-                if (pointInclusionProbFC[p][fc] >= pointInclusionProbThreshold) {
-                    //make sure we don't count points twice that are contained in two merged clusters
-                    if(cmdp.isNoise()) continue;
-                    mapFC[fc][cmdp.workclass()]++;
-                    sumsFC[fc]++;
-                }
-            }
-
-            //ground truth cluster frequencies
-            if(!cmdp.isNoise()){
-                for(int hc = 0; hc < numGT0Classes;hc++){
-                    if(hc == cmdp.workclass()){
-                        mapGT[hc][hc]++;
-                    }
-                    else{
-                        if(gtAnalysis.getGT0Cluster(hc).getInclusionProbability(cmdp) >= 1){
-                            mapGT[hc][cmdp.workclass()]++;
-                        }
-                    }
-                }
-            }
-        }
-
-        //assign each found cluster to a hidden cluster
-        matchMap = new int[numFClusters];
-        for (int fc = 0; fc < numFClusters; fc++) {
-            int matchIndex = -1;
-            //check if we only have one entry anyway
-            for (int hc0 = 0; hc0 < numGT0Classes; hc0++) {
-                if(mapFC[fc][hc0]!=0){
-                    if(matchIndex == -1)
-                        matchIndex = hc0;
-                    else{
-                        matchIndex = -1;
-                        break;
-                    }
-                }
-            }
-
-            //more then one entry, so look for most similar frequency profile
-            int minDiff = Integer.MAX_VALUE;
-            if(sumsFC[fc]!=0 && matchIndex == -1){
-                ArrayList<Integer> fitCandidates = new ArrayList<Integer>();
-                for (int hc0 = 0; hc0 < numGT0Classes; hc0++) {
-                    int errDiff = 0;
-                    for (int hc1 = 0; hc1 < numGT0Classes; hc1++) {
-                        //fc profile doesn't fit into current hc profile
-                        double freq_diff = mapFC[fc][hc1] - mapGT[hc0][hc1];
-                        if(freq_diff > 0){
-                            errDiff+= freq_diff;
-                        }
-                    }
-                    if(errDiff == 0){
-                        fitCandidates.add(hc0);
-                    }
-                    if(errDiff < minDiff){
-                        minDiff = errDiff;
-                        matchIndex = hc0;
-                    }
-                    if(debug){
-                        //System.out.println("FC"+fc+"("+Arrays.toString(mapFC[fc])+") - HC0_"+hc0+"("+Arrays.toString(mapGT[hc0])+"):"+errDiff);
-                    }
-                }
-                //if we have a fitting profile overwrite the min error choice
-                //if we have multiple fit candidates, use majority vote of corresponding classes
-                if(fitCandidates.size()!=0){
-                    int bestGTfit = fitCandidates.get(0);
-                    for(int i = 1; i < fitCandidates.size(); i++){
-                        int GTfit = fitCandidates.get(i);
-                        if(mapFC[fc][GTfit] > mapFC[fc][bestGTfit])
-                            bestGTfit=fitCandidates.get(i);
-                    }
-                    matchIndex = bestGTfit;
-                }
-            }
-            
-            matchMap[fc] = matchIndex;
-            int realMatch = -1;
-            if(matchIndex==-1){
-                if(debug)
-                    System.out.println("No cluster match: needs to be implemented?");
-            }
-            else{
-                realMatch = gtAnalysis.getGT0Cluster(matchMap[fc]).getLabel();
-            }
-            clustering.get(fc).setMeasureValue("CMM Match", "C"+realMatch);
-            clustering.get(fc).setMeasureValue("CMM Workclass", "C"+matchMap[fc]);
-        }
-
-        //print matching table
-        if(debug){
-            for (int i = 0; i < numFClusters; i++) {
-                    System.out.print("C"+((int)clustering.get(i).getId()) + " N:"+((int)clustering.get(i).getWeight())+"  |  ");
-                    for (int j = 0; j < numGT0Classes; j++) {
-                          System.out.print(mapFC[i][j] + " ");
-                    }
-                    System.out.print(" = "+sumsFC[i] + " | ");
-                    String match = "-";
-                    if (matchMap[i]!=-1) {
-                        match = Integer.toString(gtAnalysis.getGT0Cluster(matchMap[i]).getLabel());
-                    }
-                    System.out.println(" --> " + match + "(work:"+matchMap[i]+")");
-             }
-        }
-    }
-    
-    
-    /**
-     * Calculate the actual error values
-     */
-    private void calculateError(){
-        int totalErrorCount = 0;
-        int totalRedundancy = 0;
-        int trueCoverage = 0;
-        int totalCoverage = 0;
-
-        int numNoise = 0;
-        double errorNoise = 0;
-        double errorNoiseMax = 0;
-
-        double errorMissed = 0;
-        double errorMissedMax = 0;
-
-        double errorMisplaced = 0;
-        double errorMisplacedMax = 0;
-
-        double totalError = 0.0;
-        double totalErrorMax = 0.0;
-
-        /** mainly iterate over all points and find the right error value for the point.
-         *  within the same run calculate various other stuff like coverage etc...
-         */
-        for (int p = 0; p < numPoints; p++) {
-            CMMPoint cmdp = gtAnalysis.getPoint(p);
-            double weight = cmdp.weight();
-            //noise counter
-            if(cmdp.isNoise()){
-                numNoise++;
-                //this is always 1
-                errorNoiseMax+=cmdp.connectivity*weight;
-            }
-            else{
-                errorMissedMax+=cmdp.connectivity*weight;
-                errorMisplacedMax+=cmdp.connectivity*weight;
-            }
-            //sum up maxError as the individual errors are the quality weighted between 0-1
-            totalErrorMax+=cmdp.connectivity*weight;
-
-
-            double err = 0;
-            int coverage = 0;
-
-            //check every FCluster
-            for (int c = 0; c < numFClusters; c++) {
-                //contained in cluster c?
-                if(pointInclusionProbFC[p][c] >= pointInclusionProbThreshold){
-                    coverage++;
-
-                    if(!cmdp.isNoise()){
-                        //PLACED CORRECTLY
-                        if(matchMap[c] == cmdp.workclass()){
-                        }
-                        //MISPLACED
-                        else{
-                            double errvalue = misplacedError(cmdp, c);
-                            if(errvalue > err)
-                                err = errvalue;
-                        }
-                    }
-                    else{
-                        //NOISE
-                        double errvalue = noiseError(cmdp, c);
-                        if(errvalue > err) err = errvalue;
-                    }
-                }
-            }
-            //not in any cluster
-            if(coverage == 0){
-                //MISSED
-                if(!cmdp.isNoise()){
-                    err = missedError(cmdp,true);
-                    errorMissed+= weight*err;
-                }
-                //NOISE
-                else{
-                }
-            }
-            else{
-                if(!cmdp.isNoise()){
-                    errorMisplaced+= err*weight;
-                }
-                else{
-                    errorNoise+= err*weight;
-                }
-            }
-
-            /* processing of other evaluation values */
-            totalError+= err*weight;
-            if(err!=0)totalErrorCount++;
-            if(coverage>0) totalCoverage++;  //points covered by clustering (incl. noise)
-            if(coverage>0 && !cmdp.isNoise()) trueCoverage++; //points covered by clustering, don't count noise
-            if(coverage>1) totalRedundancy++; //include noise
-
-            cmdp.p.setMeasureValue("CMM",err);
-            cmdp.p.setMeasureValue("Redundancy", coverage);
-        }
-
-        addValue("CMM", (totalErrorMax!=0)?1-totalError/totalErrorMax:1);
-        addValue("CMM Missed", (errorMissedMax!=0)?1-errorMissed/errorMissedMax:1);
-        addValue("CMM Misplaced", (errorMisplacedMax!=0)?1-errorMisplaced/errorMisplacedMax:1);
-        addValue("CMM Noise", (errorNoiseMax!=0)?1-errorNoise/errorNoiseMax:1);
-        addValue("CMM Basic", 1-((double)totalErrorCount/(double)numPoints));
-
-        if(debug){
-            System.out.println("-------------");
-        }
-    }
-
-
-    private double noiseError(CMMPoint cmdp, int assignedClusterID){
-        int gtAssignedID = matchMap[assignedClusterID];
-        double error;
-        
-        //Cluster wasn't matched, so just contains noise
-        //TODO: Noiscluster?
-        //also happens when we decrease the radius and there is only a noise point in the center
-        if(gtAssignedID==-1){
-            error = 1;
-            cmdp.p.setMeasureValue("CMM Type","noise - cluster");
-        }
-        else{
-            if(enableModelError && gtAnalysis.getGT0Cluster(gtAssignedID).getInclusionProbability(cmdp) >= pointInclusionProbThreshold){
-                //set to MIN_ERROR so we can still track the error
-            	error = 0.00001;
-                cmdp.p.setMeasureValue("CMM Type","noise - byModel");
-            }
-            else{
-                error = 1 - gtAnalysis.getConnectionValue(cmdp, gtAssignedID);
-                cmdp.p.setMeasureValue("CMM Type","noise");
-            }
-        }
-
-        return error;
-    }
-
-    private double missedError(CMMPoint cmdp, boolean useHullDistance){
-        cmdp.p.setMeasureValue("CMM Type","missed");
-        if(!useHullDistance){
-            return cmdp.connectivity;
-        }
-        else{
-            //main idea: look at relative distance of missed point to cluster
-            double minHullDist = 1;
-            for (int fc = 0; fc < numFClusters; fc++){
-                //if fc is mappend onto the class of the point, check it for its hulldist
-                if(matchMap[fc]!=-1 && matchMap[fc] == cmdp.workclass()){
-                    if(clustering.get(fc) instanceof SphereCluster){
-                        SphereCluster sc = (SphereCluster)clustering.get(fc);
-                        double distanceFC = sc.getCenterDistance(cmdp);
-                        double radius = sc.getRadius();
-                        double hullDist = (distanceFC-radius)/(distanceFC+radius);
-                        if(hullDist < minHullDist)
-                            minHullDist = hullDist;
-                    }
-                    else{
-                        double min = 1;
-                        double max = 1;
-
-                        //TODO: distance for random shape
-                        //generate X points from the cluster with clustering.get(fc).sample(null)
-                        //and find Min and Max values
-
-                        double hullDist = min/max;
-                        if(hullDist < minHullDist)
-                            minHullDist = hullDist;
-                    }
-                }
-            }
-
-            //use distance as weight
-            if(minHullDist>1) minHullDist = 1;
-
-            double weight = (1-Math.exp(-lamdaMissed*minHullDist));
-            cmdp.p.setMeasureValue("HullDistWeight",weight);
-
-            return weight*cmdp.connectivity;
-        }
-    }
-
-
-    private double misplacedError(CMMPoint cmdp, int assignedClusterID){
-        double weight = 0;
-
-        int gtAssignedID = matchMap[assignedClusterID];
-        //TODO take care of noise cluster?
-        if(gtAssignedID ==-1){
-            System.out.println("Point "+cmdp.getTimestamp()+" from gtcluster "+cmdp.trueClass+" assigned to noise cluster "+assignedClusterID);
-            return 1;
-        }
-
-        if(gtAssignedID == cmdp.workclass())
-            return 0;
-        else{
-            //assigned and real GT0 cluster are not connected, but does the model have the
-            //chance of separating this point after all?
-            if(enableModelError && gtAnalysis.getGT0Cluster(gtAssignedID).getInclusionProbability(cmdp) >= pointInclusionProbThreshold){
-                weight = 0;
-                cmdp.p.setMeasureValue("CMM Type","missplaced - byModel");
-            }
-            else{
-                //point was mapped onto wrong cluster (assigned), so check how far away
-                //the nearest point is within the wrongly assigned cluster
-                weight = 1 - gtAnalysis.getConnectionValue(cmdp, gtAssignedID);
-            }
-        }
-        double err_value;
-        //set to MIN_ERROR so we can still track the error
-        if(weight == 0){
-            err_value= 0.00001;
-        }
-        else{
-            err_value = weight*cmdp.connectivity;
-            cmdp.p.setMeasureValue("CMM Type","missplaced");
-        }
-
-        return err_value;
-    }
-
-    public String getParameterString(){
-        String para = gtAnalysis.getParameterString();
-        para+="lambdaMissed="+lamdaMissed+";";
-        return para;
-    }
+	private CMM_GTAnalysis gtAnalysis;
 
-}
+	/**
+	 * number of points within the horizon
+	 */
+	private int numPoints;
+
+	/**
+	 * number of clusters in the found clustering
+	 */
+	private int numFClusters;
+
+	/**
+	 * number of cluster in the adjusted groundtruth clustering that was calculated
+	 * through the groundtruth analysis
+	 */
+	private int numGT0Classes;
 
+	/**
+	 * match found clusters to GT clusters
+	 */
+	private int matchMap[];
+
+	/**
+	 * pointInclusionProbFC[p][C] contains the probability of point p being included
+	 * in cluster C
+	 */
+	private double[][] pointInclusionProbFC;
+
+	/**
+	 * threshold that defines when a point is being considered belonging to a
+	 * cluster
+	 */
+	private double pointInclusionProbThreshold = 0.5;
+
+	/**
+	 * parameterize the error weight of missed points (default 1)
+	 */
+	private double lamdaMissed = 1;
 
+	/**
+	 * enable/disable debug mode
+	 */
+	public boolean debug = false;
+
+	/**
+	 * enable/disable class merge (main feature of ground truth analysis)
+	 */
+	public boolean enableClassMerge = true;
+
+	/**
+	 * enable/disable model error when enabled errors that are caused by the
+	 * underling cluster model will not be counted
+	 */
+	public boolean enableModelError = true;
+
+	@Override
+	protected String[] getNames() {
+		String[] names = { "CMM", "CMM Basic", "CMM Missed", "CMM Misplaced", "CMM Noise", "CA Seperability",
+				"CA Noise", "CA Model" };
+		return names;
+	}
+
+	@Override
+	protected boolean[] getDefaultEnabled() {
+		boolean[] defaults = { false, false, false, false, false, false, false, false };
+		return defaults;
+	}
+
+	@Override
+	public void evaluateClustering(Clustering clustering, Clustering trueClustering, ArrayList<DataPoint> points)
+			throws Exception {
+		this.clustering = clustering;
+
+		numPoints = points.size();
+		numFClusters = clustering.size();
+
+		gtAnalysis = new CMM_GTAnalysis(trueClustering, points, enableClassMerge);
+
+		numGT0Classes = gtAnalysis.getNumberOfGT0Classes();
+
+		addValue("CA Seperability", gtAnalysis.getClassSeparability());
+		addValue("CA Noise", gtAnalysis.getNoiseSeparability());
+		addValue("CA Model", gtAnalysis.getModelQuality());
+
+		/* init the matching and point distances */
+		calculateMatching();
+
+		/* calculate the actual error */
+		calculateError();
+	}
+
+	/**
+	 * calculates the CMM specific matching between found clusters and ground truth
+	 * clusters
+	 */
+	private void calculateMatching() {
+
+		/**
+		 * found cluster frequencies
+		 */
+		int[][] mapFC = new int[numFClusters][numGT0Classes];
+
+		/**
+		 * ground truth cluster frequencies
+		 */
+		int[][] mapGT = new int[numGT0Classes][numGT0Classes];
+		int[] sumsFC = new int[numFClusters];
+
+		// calculate fuzzy mapping from
+		pointInclusionProbFC = new double[numPoints][numFClusters];
+		for (int p = 0; p < numPoints; p++) {
+			CMMPoint cmdp = gtAnalysis.getPoint(p);
+			// found cluster frequencies
+			for (int fc = 0; fc < numFClusters; fc++) {
+				Cluster cl = clustering.get(fc);
+				pointInclusionProbFC[p][fc] = cl.getInclusionProbability(cmdp);
+				if (pointInclusionProbFC[p][fc] >= pointInclusionProbThreshold) {
+					// make sure we don't count points twice that are contained in two merged
+					// clusters
+					if (cmdp.isNoise())
+						continue;
+					mapFC[fc][cmdp.workclass()]++;
+					sumsFC[fc]++;
+				}
+			}
+
+			// ground truth cluster frequencies
+			if (!cmdp.isNoise()) {
+				for (int hc = 0; hc < numGT0Classes; hc++) {
+					if (hc == cmdp.workclass()) {
+						mapGT[hc][hc]++;
+					} else {
+						if (gtAnalysis.getGT0Cluster(hc).getInclusionProbability(cmdp) >= 1) {
+							mapGT[hc][cmdp.workclass()]++;
+						}
+					}
+				}
+			}
+		}
+
+		// assign each found cluster to a hidden cluster
+		matchMap = new int[numFClusters];
+		for (int fc = 0; fc < numFClusters; fc++) {
+			int matchIndex = -1;
+			// check if we only have one entry anyway
+			for (int hc0 = 0; hc0 < numGT0Classes; hc0++) {
+				if (mapFC[fc][hc0] != 0) {
+					if (matchIndex == -1)
+						matchIndex = hc0;
+					else {
+						matchIndex = -1;
+						break;
+					}
+				}
+			}
+
+			// more then one entry, so look for most similar frequency profile
+			int minDiff = Integer.MAX_VALUE;
+			if (sumsFC[fc] != 0 && matchIndex == -1) {
+				ArrayList<Integer> fitCandidates = new ArrayList<>();
+				for (int hc0 = 0; hc0 < numGT0Classes; hc0++) {
+					int errDiff = 0;
+					for (int hc1 = 0; hc1 < numGT0Classes; hc1++) {
+						// fc profile doesn't fit into current hc profile
+						double freq_diff = mapFC[fc][hc1] - mapGT[hc0][hc1];
+						if (freq_diff > 0) {
+							errDiff += freq_diff;
+						}
+					}
+					if (errDiff == 0) {
+						fitCandidates.add(hc0);
+					}
+					if (errDiff < minDiff) {
+						minDiff = errDiff;
+						matchIndex = hc0;
+					}
+					if (debug) {
+						// System.out.println("FC"+fc+"("+Arrays.toString(mapFC[fc])+") -
+						// HC0_"+hc0+"("+Arrays.toString(mapGT[hc0])+"):"+errDiff);
+					}
+				}
+				// if we have a fitting profile overwrite the min error choice
+				// if we have multiple fit candidates, use majority vote of corresponding
+				// classes
+				if (fitCandidates.size() != 0) {
+					int bestGTfit = fitCandidates.get(0);
+					for (int i = 1; i < fitCandidates.size(); i++) {
+						int GTfit = fitCandidates.get(i);
+						if (mapFC[fc][GTfit] > mapFC[fc][bestGTfit])
+							bestGTfit = fitCandidates.get(i);
+					}
+					matchIndex = bestGTfit;
+				}
+			}
+
+			matchMap[fc] = matchIndex;
+			int realMatch = -1;
+			if (matchIndex == -1) {
+				if (debug)
+					System.out.println("No cluster match: needs to be implemented?");
+			} else {
+				realMatch = gtAnalysis.getGT0Cluster(matchMap[fc]).getLabel();
+			}
+			clustering.get(fc).setMeasureValue("CMM Match", "C" + realMatch);
+			clustering.get(fc).setMeasureValue("CMM Workclass", "C" + matchMap[fc]);
+		}
+
+		// print matching table
+		if (debug) {
+			for (int i = 0; i < numFClusters; i++) {
+				System.out.print("C" + ((int) clustering.get(i).getId()) + " N:" + ((int) clustering.get(i).getWeight())
+						+ "  |  ");
+				for (int j = 0; j < numGT0Classes; j++) {
+					System.out.print(mapFC[i][j] + " ");
+				}
+				System.out.print(" = " + sumsFC[i] + " | ");
+				String match = "-";
+				if (matchMap[i] != -1) {
+					match = Integer.toString(gtAnalysis.getGT0Cluster(matchMap[i]).getLabel());
+				}
+				System.out.println(" --> " + match + "(work:" + matchMap[i] + ")");
+			}
+		}
+	}
+
+	/**
+	 * Calculate the actual error values
+	 */
+	private void calculateError() {
+		int totalErrorCount = 0;
+		int totalRedundancy = 0;
+		int trueCoverage = 0;
+		int totalCoverage = 0;
+
+		int numNoise = 0;
+		double errorNoise = 0;
+		double errorNoiseMax = 0;
+
+		double errorMissed = 0;
+		double errorMissedMax = 0;
+
+		double errorMisplaced = 0;
+		double errorMisplacedMax = 0;
+
+		double totalError = 0.0;
+		double totalErrorMax = 0.0;
+
+		/**
+		 * mainly iterate over all points and find the right error value for the point.
+		 * within the same run calculate various other stuff like coverage etc...
+		 */
+		for (int p = 0; p < numPoints; p++) {
+			CMMPoint cmdp = gtAnalysis.getPoint(p);
+			double weight = cmdp.weight();
+			// noise counter
+			if (cmdp.isNoise()) {
+				numNoise++;
+				// this is always 1
+				errorNoiseMax += cmdp.connectivity * weight;
+			} else {
+				errorMissedMax += cmdp.connectivity * weight;
+				errorMisplacedMax += cmdp.connectivity * weight;
+			}
+			// sum up maxError as the individual errors are the quality weighted between 0-1
+			totalErrorMax += cmdp.connectivity * weight;
+
+			double err = 0;
+			int coverage = 0;
+
+			// check every FCluster
+			for (int c = 0; c < numFClusters; c++) {
+				// contained in cluster c?
+				if (pointInclusionProbFC[p][c] >= pointInclusionProbThreshold) {
+					coverage++;
+
+					if (!cmdp.isNoise()) {
+						// PLACED CORRECTLY
+						if (matchMap[c] == cmdp.workclass()) {
+						}
+						// MISPLACED
+						else {
+							double errvalue = misplacedError(cmdp, c);
+							if (errvalue > err)
+								err = errvalue;
+						}
+					} else {
+						// NOISE
+						double errvalue = noiseError(cmdp, c);
+						if (errvalue > err)
+							err = errvalue;
+					}
+				}
+			}
+			// not in any cluster
+			if (coverage == 0) {
+				// MISSED
+				if (!cmdp.isNoise()) {
+					err = missedError(cmdp, true);
+					errorMissed += weight * err;
+				}
+				// NOISE
+				else {
+				}
+			} else {
+				if (!cmdp.isNoise()) {
+					errorMisplaced += err * weight;
+				} else {
+					errorNoise += err * weight;
+				}
+			}
+
+			/* processing of other evaluation values */
+			totalError += err * weight;
+			if (err != 0)
+				totalErrorCount++;
+			if (coverage > 0)
+				totalCoverage++; // points covered by clustering (incl. noise)
+			if (coverage > 0 && !cmdp.isNoise())
+				trueCoverage++; // points covered by clustering, don't count noise
+			if (coverage > 1)
+				totalRedundancy++; // include noise
+
+			cmdp.p.setMeasureValue("CMM", err);
+			cmdp.p.setMeasureValue("Redundancy", coverage);
+		}
+
+		addValue("CMM", (totalErrorMax != 0) ? 1 - totalError / totalErrorMax : 1);
+		addValue("CMM Missed", (errorMissedMax != 0) ? 1 - errorMissed / errorMissedMax : 1);
+		addValue("CMM Misplaced", (errorMisplacedMax != 0) ? 1 - errorMisplaced / errorMisplacedMax : 1);
+		addValue("CMM Noise", (errorNoiseMax != 0) ? 1 - errorNoise / errorNoiseMax : 1);
+		addValue("CMM Basic", 1 - ((double) totalErrorCount / (double) numPoints));
+
+		if (debug) {
+			System.out.println("-------------");
+		}
+	}
+
+	private double noiseError(CMMPoint cmdp, int assignedClusterID) {
+		int gtAssignedID = matchMap[assignedClusterID];
+		double error;
+
+		// Cluster wasn't matched, so just contains noise
+		// TODO: Noiscluster?
+		// also happens when we decrease the radius and there is only a noise point in
+		// the center
+		if (gtAssignedID == -1) {
+			error = 1;
+			cmdp.p.setMeasureValue("CMM Type", "noise - cluster");
+		} else {
+			if (enableModelError && gtAnalysis.getGT0Cluster(gtAssignedID)
+					.getInclusionProbability(cmdp) >= pointInclusionProbThreshold) {
+				// set to MIN_ERROR so we can still track the error
+				error = 0.00001;
+				cmdp.p.setMeasureValue("CMM Type", "noise - byModel");
+			} else {
+				error = 1 - gtAnalysis.getConnectionValue(cmdp, gtAssignedID);
+				cmdp.p.setMeasureValue("CMM Type", "noise");
+			}
+		}
+
+		return error;
+	}
+
+	private double missedError(CMMPoint cmdp, boolean useHullDistance) {
+		cmdp.p.setMeasureValue("CMM Type", "missed");
+		if (!useHullDistance) {
+			return cmdp.connectivity;
+		} else {
+			// main idea: look at relative distance of missed point to cluster
+			double minHullDist = 1;
+			for (int fc = 0; fc < numFClusters; fc++) {
+				// if fc is mappend onto the class of the point, check it for its hulldist
+				if (matchMap[fc] != -1 && matchMap[fc] == cmdp.workclass()) {
+					if (clustering.get(fc) instanceof SphereCluster) {
+						SphereCluster sc = (SphereCluster) clustering.get(fc);
+						double distanceFC = sc.getCenterDistance(cmdp);
+						double radius = sc.getRadius();
+						double hullDist = (distanceFC - radius) / (distanceFC + radius);
+						if (hullDist < minHullDist)
+							minHullDist = hullDist;
+					} else {
+						double min = 1;
+						double max = 1;
+
+						// TODO: distance for random shape
+						// generate X points from the cluster with clustering.get(fc).sample(null)
+						// and find Min and Max values
+
+						double hullDist = min / max;
+						if (hullDist < minHullDist)
+							minHullDist = hullDist;
+					}
+				}
+			}
+
+			// use distance as weight
+			if (minHullDist > 1)
+				minHullDist = 1;
+
+			double weight = (1 - Math.exp(-lamdaMissed * minHullDist));
+			cmdp.p.setMeasureValue("HullDistWeight", weight);
+
+			return weight * cmdp.connectivity;
+		}
+	}
+
+	private double misplacedError(CMMPoint cmdp, int assignedClusterID) {
+		double weight = 0;
+
+		int gtAssignedID = matchMap[assignedClusterID];
+		// TODO take care of noise cluster?
+		if (gtAssignedID == -1) {
+			System.out.println("Point " + cmdp.getTimestamp() + " from gtcluster " + cmdp.trueClass
+					+ " assigned to noise cluster " + assignedClusterID);
+			return 1;
+		}
+
+		if (gtAssignedID == cmdp.workclass())
+			return 0;
+		else {
+			// assigned and real GT0 cluster are not connected, but does the model have the
+			// chance of separating this point after all?
+			if (enableModelError && gtAnalysis.getGT0Cluster(gtAssignedID)
+					.getInclusionProbability(cmdp) >= pointInclusionProbThreshold) {
+				weight = 0;
+				cmdp.p.setMeasureValue("CMM Type", "missplaced - byModel");
+			} else {
+				// point was mapped onto wrong cluster (assigned), so check how far away
+				// the nearest point is within the wrongly assigned cluster
+				weight = 1 - gtAnalysis.getConnectionValue(cmdp, gtAssignedID);
+			}
+		}
+		double err_value;
+		// set to MIN_ERROR so we can still track the error
+		if (weight == 0) {
+			err_value = 0.00001;
+		} else {
+			err_value = weight * cmdp.connectivity;
+			cmdp.p.setMeasureValue("CMM Type", "missplaced");
+		}
+
+		return err_value;
+	}
+
+	public String getParameterString() {
+		String para = gtAnalysis.getParameterString();
+		para += "lambdaMissed=" + lamdaMissed + ";";
+		return para;
+	}
+
+}
diff --git a/moa/src/main/java/moa/evaluation/CMM_GTAnalysis.java b/moa/src/main/java/moa/evaluation/CMM_GTAnalysis.java
index db4f8273b..a4dd61824 100644
--- a/moa/src/main/java/moa/evaluation/CMM_GTAnalysis.java
+++ b/moa/src/main/java/moa/evaluation/CMM_GTAnalysis.java
@@ -1,10 +1,10 @@
 /**
  * [CMM_GTAnalysis.java]
- * 
+ *
  * CMM: Ground truth analysis
- * 
+ *
  * Reference: Kremer et al., "An Effective Evaluation Measure for Clustering on Evolving Data Streams", KDD, 2011
- * 
+ *
  * @author Timm jansen
  * Data Management and Data Exploration Group, RWTH Aachen University
  *
@@ -19,8 +19,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 /*
@@ -43,658 +43,646 @@
 import moa.core.AutoExpandVector;
 import moa.gui.visualization.DataPoint;
 
-public class CMM_GTAnalysis{
-	
-    /**
-     * the given ground truth clustering
-     */
-    private Clustering gtClustering;
-    
-    /**
-     * list of given points within the horizon  
-     */
-    private ArrayList<CMMPoint> cmmpoints;
-    
-    /**
-     * the newly calculate ground truth clustering
-     */
-    private ArrayList<GTCluster> gt0Clusters;
-
-    /**
-     * IDs of noise points
-     */
-    private ArrayList<Integer> noise;
-    
-    /**
-     * total number of points
-     */
-    private int numPoints;
-
-    /**
-     * number of clusters of the original ground truth 
-     */
-    private int numGTClusters;
-
-    /**
-     *    number of classes of the original ground truth, in case of a 
-     *    micro clustering ground truth this differs from numGTClusters
-     */
-    private int numGTClasses;
-
-    /**
-     * number of classes after we are done with the analysis 
-     */
-    private int numGT0Classes;
-
-    /**
-     * number of dimensions
-     */
-    private int numDims;
-
-    /**
-     * mapping between true cluster ID/class label of the original ground truth 
-     * and the internal cluster ID/working class label. 
-     * 
-     * different original cluster IDs might map to the same new cluster ID due to merging of two clusters 
-     */
-    private HashMap<Integer, Integer> mapTrueLabelToWorkLabel;
-
-    /**
-     * log of how clusters have been merged (for debugging)
-     */
-    private int[] mergeMap;
-
-    /**
-     * number of non-noise points that will create an error due to the underlying clustering model
-     * (e.g. point being covered by two clusters representing different classes)
-     */
-    private int noiseErrorByModel;
-
-    /**
-     * number of noise points that will create an error due to the underlying clustering model
-     * (e.g. noise point being covered by a cluster)
-     */
-    private int pointErrorByModel;    
-    
-    /**
-     * CMM debug mode
-     */
-    private boolean debug = false;
-
-    
-    /******* CMM parameter ***********/
-
-    /**
-     * defines how many nearest neighbors will be used
-     */
-    private int knnNeighbourhood = 2;
-
-    /**
-     * the threshold which defines when ground truth clusters will be merged.
-     * set to 1 to disable merging 
-     */
-    private double tauConnection = 0.5;
-    
-    /**
-     *  experimental (default: disabled)
-     *  separate k for points to cluster and cluster to cluster 
-     */
-    private double clusterConnectionMaxPoints = knnNeighbourhood;
-    
-    /** 
-     * experimental (default: disabled)
-     * use exponential connectivity function to model different behavior: 
-     * closer points will have a stronger connection compared to the linear function.
-     * Use ConnRefXValue and ConnX to better parameterize lambda, which controls 
-     * the decay of the connectivity
-     */
-    private boolean useExpConnectivity = false;
-    private double lambdaConnRefXValue = 0.01;
-    private double lambdaConnX = 4;
-    private double lamdaConn;
-    
-    
-    /******************************************/
-    
-    
-    /**
-     * Wrapper class for data points to store CMM relevant attributes
-     *
-     */
-    protected class CMMPoint extends DataPoint{
-        /**
-         * Reference to original point
-         */
-        protected DataPoint p = null;
-        
-        /**
-         * point ID
-         */
-        protected int pID = 0;
-        
-        
-        /**
-         * true class label
-         */
-        protected int trueClass = -1;
-
-        
-        /**
-         * the connectivity of the point to its cluster
-         */
-        protected double connectivity = 1.0;
-        
-        
-        /**
-         * knn distnace within own cluster
-         */
-        protected double knnInCluster = 0.0; 
-        
-        
-        /**
-         * knn indices (for debugging only)
-         */
-        protected ArrayList<Integer> knnIndices;
-
-        public CMMPoint(DataPoint point, int id) {
-            //make a copy, but keep reference
-            super(point,point.getTimestamp());
-            p = point;
-            pID = id;
-            trueClass = (int)point.classValue();
-        }
-
-        
-        /**
-         * Retruns the current working label of the cluster the point belongs to. 
-         * The label can change due to merging of clusters.  
-         * 
-         * @return the current working class label
-         */
-        protected int workclass(){
-            if(trueClass == -1 )
-                return -1;
-            else
-                return mapTrueLabelToWorkLabel.get(trueClass);
-        }
-    }
-
-    
-    
-    /**
-     * Main class to model the new clusters that will be the output of the cluster analysis
-     *
-     */
-    protected class GTCluster{
-    	/** points that are per definition in the cluster */
-        private ArrayList<Integer> points = new ArrayList<Integer>();
-        
-        /** a new GT cluster consists of one or more "old" GT clusters. 
-         * Connected/overlapping clusters cannot be merged directly because of the 
-         * underlying cluster model. E.g. for merging two spherical clusters the new 
-         * cluster sphere can cover a lot more space then two separate smaller spheres. 
-         * To keep the original coverage we need to keep the orignal clusters and merge
-         * them on an abstract level. */
-        private ArrayList<Integer> clusterRepresentations = new ArrayList<Integer>();
-     
-        /** current work class (changes when merging) */
-        private int workclass;
-        
-        /** original work class */
-        private final int orgWorkClass;
-        
-        /** original class label*/
-        private final int label;
-        
-        /** clusters that have been merged into this cluster (debugging)*/
-        private ArrayList<Integer> mergedWorkLabels = null;
-        
-        /** average knn distance of all points in the cluster*/
-        private double knnMeanAvg = 0;
-        
-        /** average deviation of knn distance of all points*/
-        private double knnDevAvg = 0;
-        
-        /** connectivity of the cluster to all other clusters */
-        private ArrayList<Double> connections = new ArrayList<Double>();
-        
-
-        private GTCluster(int workclass, int label, int gtClusteringID) {
-           this.orgWorkClass = workclass;
-           this.workclass = workclass;
-           this.label = label;
-           this.clusterRepresentations.add(gtClusteringID);
-        }
-
-        
-        /**
-         * The original class label the cluster represents
-         * @return original class label
-         */
-        protected int getLabel(){
-            return label;
-        }
-
-        /**
-         * Calculate the probability of the point being covered through the cluster
-         * @param point to calculate the probability for
-         * @return probability of the point being covered through the cluster
-         */
-        protected double getInclusionProbability(CMMPoint point){
-            double prob = Double.MIN_VALUE;
-            //check all cluster representatives for coverage
-            for (int c = 0; c < clusterRepresentations.size(); c++) {
-               double tmp_prob = gtClustering.get(clusterRepresentations.get(c)).getInclusionProbability(point);
-               if(tmp_prob > prob) prob = tmp_prob;
-            }
-            return prob;
-        }
-
-        
-        /**
-         * calculate knn distances of points within own cluster 
-         * + average knn distance and average knn distance deviation of all points 
-         */
-        private void calculateKnn(){
-            for (int p0 : points) {
-                CMMPoint cmdp = cmmpoints.get(p0);
-                if(!cmdp.isNoise()){
-                    AutoExpandVector<Double> knnDist = new AutoExpandVector<Double>();
-                    AutoExpandVector<Integer> knnPointIndex = new AutoExpandVector<Integer>();
-                    
-                    //calculate nearest neighbours 
-                    getKnnInCluster(cmdp, knnNeighbourhood, points, knnDist,knnPointIndex);
-
-                    //TODO: What to do if we have less then k neighbours?
-                    double avgKnn = 0;
-                    for (int i = 0; i < knnDist.size(); i++) {
-                        avgKnn+= knnDist.get(i);
-                    }
-                    if(knnDist.size()!=0)
-                        avgKnn/=knnDist.size();
-                    cmdp.knnInCluster = avgKnn;
-                    cmdp.knnIndices = knnPointIndex;
-                    cmdp.p.setMeasureValue("knnAvg", cmdp.knnInCluster);
-
-                    knnMeanAvg+=avgKnn;
-                    knnDevAvg+=Math.pow(avgKnn,2);
-                }
-            }
-            knnMeanAvg=knnMeanAvg/(double)points.size();
-            knnDevAvg=knnDevAvg/(double)points.size();
-
-            double variance = knnDevAvg-Math.pow(knnMeanAvg,2.0);
-            // Due to numerical errors, small negative values can occur.
-            if (variance <= 0.0) variance = 1e-50;
-            knnDevAvg = Math.sqrt(variance);
-
-        }
-
-        
-        /**
-         * Calculate the connection of a cluster to this cluster
-         * @param otherCid cluster id of the other cluster
-         * @param initial flag for initial run
-         */
-        private void calculateClusterConnection(int otherCid, boolean initial){
-            double avgConnection = 0;
-            if(workclass==otherCid){
-                avgConnection = 1;
-            }
-            else{
-                AutoExpandVector<Double> kmax = new AutoExpandVector<Double>();
-                AutoExpandVector<Integer> kmaxIndexes = new AutoExpandVector<Integer>();
-
-                for(int p : points){
-                    CMMPoint cmdp = cmmpoints.get(p);
-                    double con_p_Cj = getConnectionValue(cmmpoints.get(p), otherCid);
-                    double connection = cmdp.connectivity * con_p_Cj;
-                    if(initial){
-                        cmdp.p.setMeasureValue("Connection to C"+otherCid, con_p_Cj);
-                    }
-
-                    //connection
-                    if(kmax.size() < clusterConnectionMaxPoints || connection > kmax.get(kmax.size()-1)){
-                        int index = 0;
-                        while(index < kmax.size() && connection < kmax.get(index)) {
-                            index++;
-                        }
-                        kmax.add(index, connection);
-                        kmaxIndexes.add(index, p);
-                        if(kmax.size() > clusterConnectionMaxPoints){
-                            kmax.remove(kmax.size()-1);
-                            kmaxIndexes.add(kmaxIndexes.size()-1);
-                        }
-                    }
-                }
-                //connection
-                for (int k = 0; k < kmax.size(); k++) {
-                    avgConnection+= kmax.get(k);
-                }
-                avgConnection/=kmax.size();
-            }
-
-            if(otherCid<connections.size()){
-                connections.set(otherCid, avgConnection);
-            }
-            else
-                if(connections.size() == otherCid){
-                    connections.add(avgConnection);
-                }
-                else
-                    System.out.println("Something is going really wrong with the connection listing!"+knnNeighbourhood+" "+tauConnection);
-        }
-
-        
-        /**
-         * Merge a cluster into this cluster
-         * @param mergeID the ID of the cluster to be merged
-         */
-        private void mergeCluster(int mergeID){
-            if(mergeID < gt0Clusters.size()){
-                //track merging (debugging)
-            	for (int i = 0; i < numGTClasses; i++) {
-                    if(mergeMap[i]==mergeID)
-                        mergeMap[i]=workclass;
-                    if(mergeMap[i]>mergeID)
-                        mergeMap[i]--;
-                }
-                GTCluster gtcMerge  = gt0Clusters.get(mergeID);
-                if(debug)
-                    System.out.println("Merging C"+gtcMerge.workclass+" into C"+workclass+
-                            " with Con "+connections.get(mergeID)+" / "+gtcMerge.connections.get(workclass));
-
-
-                //update mapTrueLabelToWorkLabel
-                mapTrueLabelToWorkLabel.put(gtcMerge.label, workclass);
-                Iterator iterator = mapTrueLabelToWorkLabel.keySet().iterator();
-                while (iterator.hasNext()) {
-                    Integer key = (Integer)iterator.next();
-                    //update pointer of already merged cluster
-                    int value = mapTrueLabelToWorkLabel.get(key);
-                    if(value == mergeID)
-                        mapTrueLabelToWorkLabel.put(key, workclass);
-                    if(value > mergeID)
-                        mapTrueLabelToWorkLabel.put(key, value-1);
-                }
-
-                //merge points from B into A
-                points.addAll(gtcMerge.points);
-                clusterRepresentations.addAll(gtcMerge.clusterRepresentations);
-                if(mergedWorkLabels==null){
-                    mergedWorkLabels = new ArrayList<Integer>();
-                }
-                mergedWorkLabels.add(gtcMerge.orgWorkClass);
-                if(gtcMerge.mergedWorkLabels!=null)
-                    mergedWorkLabels.addAll(gtcMerge.mergedWorkLabels);
-
-                gt0Clusters.remove(mergeID);
-
-                //update workclass labels
-                for(int c=mergeID; c < gt0Clusters.size(); c++){
-                    gt0Clusters.get(c).workclass = c;
-                }
-
-                //update knn distances
-                calculateKnn();
-                for(int c=0; c < gt0Clusters.size(); c++){
-                    gt0Clusters.get(c).connections.remove(mergeID);
-                    
-                    //recalculate connection from other clusters to the new merged one
-                    gt0Clusters.get(c).calculateClusterConnection(workclass,false);
-                    //and from new merged one to other clusters
-                    gt0Clusters.get(workclass).calculateClusterConnection(c,false);
-                }
-            }
-            else{
-                System.out.println("Merge indices are not valid");
-            }
-        }
-    }
-
-    
-    /**
-     * @param trueClustering the ground truth clustering
-     * @param points data points
-     * @param enableClassMerge allow class merging (should be set to true on default)
-     */
-    public CMM_GTAnalysis(Clustering trueClustering, ArrayList<DataPoint> points, boolean enableClassMerge){
-        if(debug)
-            System.out.println("GT Analysis Debug Output");
-
-        noiseErrorByModel = 0;
-        pointErrorByModel = 0;
-        if(!enableClassMerge){
-        	tauConnection = 1.0;
-        }
-
-        lamdaConn = -Math.log(lambdaConnRefXValue)/Math.log(2)/lambdaConnX;
-        
-        this.gtClustering = trueClustering;
-
-        numPoints = points.size();
-        numDims = points.get(0).numAttributes()-1;
-        numGTClusters = gtClustering.size();
-
-        //init mappings between work and true labels
-        mapTrueLabelToWorkLabel = new HashMap<Integer, Integer>();
-        
-        //set up base of new clustering
-        gt0Clusters = new ArrayList<GTCluster>();
-        int numWorkClasses = 0;
-        //create label to worklabel mapping as real labels can be just a set of unordered integers
-        for (int i = 0; i < numGTClusters; i++) {
-            int label = (int)gtClustering.get(i).getGroundTruth();
-            if(!mapTrueLabelToWorkLabel.containsKey(label)){
-                gt0Clusters.add(new GTCluster(numWorkClasses,label,i));
-                mapTrueLabelToWorkLabel.put(label,numWorkClasses);
-                numWorkClasses++;
-            }
-            else{
-                gt0Clusters.get(mapTrueLabelToWorkLabel.get(label)).clusterRepresentations.add(i);
-            }
-        }
-        numGTClasses = numWorkClasses;
-
-        mergeMap = new int[numGTClasses];
-        for (int i = 0; i < numGTClasses; i++) {
-            mergeMap[i]=i;
-        }
-
-        //create cmd point wrapper instances
-        cmmpoints = new ArrayList<CMMPoint>();
-        for (int p = 0; p < points.size(); p++) {
-            CMMPoint cmdp = new CMMPoint(points.get(p), p);
-            cmmpoints.add(cmdp);
-        }
-
-
-        //split points up into their GTClusters and Noise (according to class labels)
-        noise = new ArrayList<Integer>();
-        for (int p = 0; p < numPoints; p++) {
-            if(cmmpoints.get(p).isNoise()){
-                noise.add(p);
-            }
-            else{
-                gt0Clusters.get(cmmpoints.get(p).workclass()).points.add(p);
-            }
-        }
-
-        //calculate initial knnMean and knnDev
-        for (GTCluster gtc : gt0Clusters) {
-            gtc.calculateKnn();
-        }
-
-        //calculate cluster connections
-        calculateGTClusterConnections();
-
-        //calculate point connections with own clusters
-        calculateGTPointQualities();
-
-        if(debug)
-            System.out.println("GT Analysis Debug End");
-
-   }
-
-    /**
-     * Calculate the connection of a point to a cluster
-     *  
-     * @param cmmp the point to calculate the connection for
-     * @param clusterID the corresponding cluster
-     * @return the connection value
-     */
-    //TODO: Cache the connection value for a point to the different clusters???
-    protected double getConnectionValue(CMMPoint cmmp, int clusterID){
-        AutoExpandVector<Double> knnDist = new AutoExpandVector<Double>();
-        AutoExpandVector<Integer> knnPointIndex = new AutoExpandVector<Integer>();
-        
-        //calculate the knn distance of the point to the cluster
-        getKnnInCluster(cmmp, knnNeighbourhood, gt0Clusters.get(clusterID).points, knnDist, knnPointIndex);
-
-        //TODO: What to do if we have less then k neighbors?
-        double avgDist = 0;
-        for (int i = 0; i < knnDist.size(); i++) {
-            avgDist+= knnDist.get(i);
-        }
-        //what to do if we only have a single point???
-        if(knnDist.size()!=0)
-            avgDist/=knnDist.size();
-        else
-            return 0;
-
-        //get the upper knn distance of the cluster
-        double upperKnn = gt0Clusters.get(clusterID).knnMeanAvg + gt0Clusters.get(clusterID).knnDevAvg;
-        
-        /* calculate the connectivity based on knn distance of the point within the cluster
-           and the upper knn distance of the cluster*/ 
-        if(avgDist < upperKnn){
-            return 1;
-        }
-        else{
-            //value that should be reached at upperKnn distance
-            //Choose connection formula
-            double conn;
-            if(useExpConnectivity)
-                conn = Math.pow(2,-lamdaConn*(avgDist-upperKnn)/upperKnn);
-            else
-                conn = upperKnn/avgDist;
-
-            if(Double.isNaN(conn))
-                System.out.println("Connectivity NaN at "+cmmp.p.getTimestamp());
-
-            return conn;
-        }
-    }
-
-    
-    /**
-     * @param cmmp point to calculate knn distance for
-     * @param k number of nearest neighbors to look for
-     * @param pointIDs list of point IDs to check
-     * @param knnDist sorted list of smallest knn distances (can already be filled to make updates possible)  
-     * @param knnPointIndex list of corresponding knn indices
-     */
-    private void getKnnInCluster(CMMPoint cmmp, int k,
-                                 ArrayList<Integer> pointIDs,
-                                 AutoExpandVector<Double> knnDist,
-                                 AutoExpandVector<Integer> knnPointIndex) {
-
-        //iterate over every point in the choosen cluster, cal distance and insert into list
-        for (int p1 = 0; p1 < pointIDs.size(); p1++) {
-            int pid = pointIDs.get(p1);
-            if(cmmp.pID == pid) continue;
-            double dist = distance(cmmp,cmmpoints.get(pid));
-            if(knnDist.size() < k || dist < knnDist.get(knnDist.size()-1)){
-                int index = 0;
-                while(index < knnDist.size() && dist > knnDist.get(index)) {
-                    index++;
-                }
-                knnDist.add(index, dist);
-                knnPointIndex.add(index,pid);
-                if(knnDist.size() > k){
-                    knnDist.remove(knnDist.size()-1);
-                    knnPointIndex.remove(knnPointIndex.size()-1);
-                }
-            }
-        }
-    }
-
-
-    
-    /**
-     * calculate initial connectivities
-     */
-    private void calculateGTPointQualities(){
-        for (int p = 0; p < numPoints; p++) {
-            CMMPoint cmdp = cmmpoints.get(p);
-            if(!cmdp.isNoise()){
-                cmdp.connectivity = getConnectionValue(cmdp, cmdp.workclass());
-                cmdp.p.setMeasureValue("Connectivity", cmdp.connectivity);
-            }
-        }
-    }
-
-    
-    
-    /**
-     * Calculate connections between clusters and merge clusters accordingly as 
-     * long as connections exceed threshold 
-     */
-    private void calculateGTClusterConnections(){
-        for (int c0 = 0; c0 < gt0Clusters.size(); c0++) {
-            for (int c1 = 0; c1 < gt0Clusters.size(); c1++) {
-                    gt0Clusters.get(c0).calculateClusterConnection(c1, true);
-            }
-        }
-
-        boolean changedConnection = true;
-        while(changedConnection){
-            if(debug){
-                System.out.println("Cluster Connection");
-                for (int c = 0; c < gt0Clusters.size(); c++) {
-                    System.out.print("C"+gt0Clusters.get(c).label+" --> ");
-                    for (int c1 = 0; c1 < gt0Clusters.get(c).connections.size(); c1++) {
-                        System.out.print(" C"+gt0Clusters.get(c1).label+": "+gt0Clusters.get(c).connections.get(c1));
-                    }
-                    System.out.println("");
-                }
-                System.out.println("");
-            }
-
-            double max = 0;
-            int maxIndexI = -1;
-            int maxIndexJ = -1;
-
-            changedConnection = false;
-            for (int c0 = 0; c0 < gt0Clusters.size(); c0++) {
-                for (int c1 = c0+1; c1 < gt0Clusters.size(); c1++) {
-                    if(c0==c1) continue;
-                        double min =Math.min(gt0Clusters.get(c0).connections.get(c1), gt0Clusters.get(c1).connections.get(c0));
-                        if(min > max){
-                            max = min;
-                            maxIndexI = c0;
-                            maxIndexJ = c1;
-                        }
-                }
-            }
-            if(maxIndexI!=-1 && max > tauConnection){
-                gt0Clusters.get(maxIndexI).mergeCluster(maxIndexJ);
-                if(debug)
-                    System.out.println("Merging "+maxIndexI+" and "+maxIndexJ+" because of connection "+max);
-
-                changedConnection = true;
-            }
-        }
-        numGT0Classes = gt0Clusters.size();
-    }
-
-    
-    /** 
-     * Calculates how well the original clusters are separable. 
-     * Small values indicate bad separability, values close to 1 indicate good separability 
-     * @return index of seperability 
-     */
-    public double getClassSeparability(){
+public class CMM_GTAnalysis {
+
+	/**
+	 * the given ground truth clustering
+	 */
+	private Clustering gtClustering;
+
+	/**
+	 * list of given points within the horizon
+	 */
+	private ArrayList<CMMPoint> cmmpoints;
+
+	/**
+	 * the newly calculate ground truth clustering
+	 */
+	private ArrayList<GTCluster> gt0Clusters;
+
+	/**
+	 * IDs of noise points
+	 */
+	private ArrayList<Integer> noise;
+
+	/**
+	 * total number of points
+	 */
+	private int numPoints;
+
+	/**
+	 * number of clusters of the original ground truth
+	 */
+	private int numGTClusters;
+
+	/**
+	 * number of classes of the original ground truth, in case of a micro clustering
+	 * ground truth this differs from numGTClusters
+	 */
+	private int numGTClasses;
+
+	/**
+	 * number of classes after we are done with the analysis
+	 */
+	private int numGT0Classes;
+
+	/**
+	 * number of dimensions
+	 */
+	private int numDims;
+
+	/**
+	 * mapping between true cluster ID/class label of the original ground truth and
+	 * the internal cluster ID/working class label.
+	 * 
+	 * different original cluster IDs might map to the same new cluster ID due to
+	 * merging of two clusters
+	 */
+	private HashMap<Integer, Integer> mapTrueLabelToWorkLabel;
+
+	/**
+	 * log of how clusters have been merged (for debugging)
+	 */
+	private int[] mergeMap;
+
+	/**
+	 * number of non-noise points that will create an error due to the underlying
+	 * clustering model (e.g. point being covered by two clusters representing
+	 * different classes)
+	 */
+	private int noiseErrorByModel;
+
+	/**
+	 * number of noise points that will create an error due to the underlying
+	 * clustering model (e.g. noise point being covered by a cluster)
+	 */
+	private int pointErrorByModel;
+
+	/**
+	 * CMM debug mode
+	 */
+	private boolean debug = false;
+
+	/******* CMM parameter ***********/
+
+	/**
+	 * defines how many nearest neighbors will be used
+	 */
+	private int knnNeighbourhood = 2;
+
+	/**
+	 * the threshold which defines when ground truth clusters will be merged. set to
+	 * 1 to disable merging
+	 */
+	private double tauConnection = 0.5;
+
+	/**
+	 * experimental (default: disabled) separate k for points to cluster and cluster
+	 * to cluster
+	 */
+	private double clusterConnectionMaxPoints = knnNeighbourhood;
+
+	/**
+	 * experimental (default: disabled) use exponential connectivity function to
+	 * model different behavior: closer points will have a stronger connection
+	 * compared to the linear function. Use ConnRefXValue and ConnX to better
+	 * parameterize lambda, which controls the decay of the connectivity
+	 */
+	private boolean useExpConnectivity = false;
+	private double lambdaConnRefXValue = 0.01;
+	private double lambdaConnX = 4;
+	private double lamdaConn;
+
+	/******************************************/
+
+	/**
+	 * Wrapper class for data points to store CMM relevant attributes
+	 *
+	 */
+	protected class CMMPoint extends DataPoint {
+		/**
+		 * Reference to original point
+		 */
+		protected DataPoint p = null;
+
+		/**
+		 * point ID
+		 */
+		protected int pID = 0;
+
+		/**
+		 * true class label
+		 */
+		protected int trueClass = -1;
+
+		/**
+		 * the connectivity of the point to its cluster
+		 */
+		protected double connectivity = 1.0;
+
+		/**
+		 * knn distnace within own cluster
+		 */
+		protected double knnInCluster = 0.0;
+
+		/**
+		 * knn indices (for debugging only)
+		 */
+		protected ArrayList<Integer> knnIndices;
+
+		public CMMPoint(DataPoint point, int id) {
+			// make a copy, but keep reference
+			super(point, point.getTimestamp());
+			p = point;
+			pID = id;
+			trueClass = (int) point.classValue();
+		}
+
+		/**
+		 * Retruns the current working label of the cluster the point belongs to. The
+		 * label can change due to merging of clusters.
+		 * 
+		 * @return the current working class label
+		 */
+		protected int workclass() {
+			if (trueClass == -1)
+				return -1;
+			else
+				return mapTrueLabelToWorkLabel.get(trueClass);
+		}
+	}
+
+	/**
+	 * Main class to model the new clusters that will be the output of the cluster
+	 * analysis
+	 *
+	 */
+	protected class GTCluster {
+		/** points that are per definition in the cluster */
+		private ArrayList<Integer> points = new ArrayList<>();
+
+		/**
+		 * a new GT cluster consists of one or more "old" GT clusters.
+		 * Connected/overlapping clusters cannot be merged directly because of the
+		 * underlying cluster model. E.g. for merging two spherical clusters the new
+		 * cluster sphere can cover a lot more space then two separate smaller spheres.
+		 * To keep the original coverage we need to keep the orignal clusters and merge
+		 * them on an abstract level.
+		 */
+		private ArrayList<Integer> clusterRepresentations = new ArrayList<>();
+
+		/** current work class (changes when merging) */
+		private int workclass;
+
+		/** original work class */
+		private final int orgWorkClass;
+
+		/** original class label */
+		private final int label;
+
+		/** clusters that have been merged into this cluster (debugging) */
+		private ArrayList<Integer> mergedWorkLabels = null;
+
+		/** average knn distance of all points in the cluster */
+		private double knnMeanAvg = 0;
+
+		/** average deviation of knn distance of all points */
+		private double knnDevAvg = 0;
+
+		/** connectivity of the cluster to all other clusters */
+		private ArrayList<Double> connections = new ArrayList<>();
+
+		private GTCluster(int workclass, int label, int gtClusteringID) {
+			this.orgWorkClass = workclass;
+			this.workclass = workclass;
+			this.label = label;
+			this.clusterRepresentations.add(gtClusteringID);
+		}
+
+		/**
+		 * The original class label the cluster represents
+		 * 
+		 * @return original class label
+		 */
+		protected int getLabel() {
+			return label;
+		}
+
+		/**
+		 * Calculate the probability of the point being covered through the cluster
+		 * 
+		 * @param point to calculate the probability for
+		 * @return probability of the point being covered through the cluster
+		 */
+		protected double getInclusionProbability(CMMPoint point) {
+			double prob = Double.MIN_VALUE;
+			// check all cluster representatives for coverage
+			for (int c = 0; c < clusterRepresentations.size(); c++) {
+				double tmp_prob = gtClustering.get(clusterRepresentations.get(c)).getInclusionProbability(point);
+				if (tmp_prob > prob)
+					prob = tmp_prob;
+			}
+			return prob;
+		}
+
+		/**
+		 * calculate knn distances of points within own cluster + average knn distance
+		 * and average knn distance deviation of all points
+		 */
+		private void calculateKnn() {
+			for (int p0 : points) {
+				CMMPoint cmdp = cmmpoints.get(p0);
+				if (!cmdp.isNoise()) {
+					AutoExpandVector<Double> knnDist = new AutoExpandVector<>();
+					AutoExpandVector<Integer> knnPointIndex = new AutoExpandVector<>();
+
+					// calculate nearest neighbours
+					getKnnInCluster(cmdp, knnNeighbourhood, points, knnDist, knnPointIndex);
+
+					// TODO: What to do if we have less then k neighbours?
+					double avgKnn = 0;
+					for (int i = 0; i < knnDist.size(); i++) {
+						avgKnn += knnDist.get(i);
+					}
+					if (knnDist.size() != 0)
+						avgKnn /= knnDist.size();
+					cmdp.knnInCluster = avgKnn;
+					cmdp.knnIndices = knnPointIndex;
+					cmdp.p.setMeasureValue("knnAvg", cmdp.knnInCluster);
+
+					knnMeanAvg += avgKnn;
+					knnDevAvg += Math.pow(avgKnn, 2);
+				}
+			}
+			knnMeanAvg = knnMeanAvg / points.size();
+			knnDevAvg = knnDevAvg / points.size();
+
+			double variance = knnDevAvg - Math.pow(knnMeanAvg, 2.0);
+			// Due to numerical errors, small negative values can occur.
+			if (variance <= 0.0)
+				variance = 1e-50;
+			knnDevAvg = Math.sqrt(variance);
+
+		}
+
+		/**
+		 * Calculate the connection of a cluster to this cluster
+		 * 
+		 * @param otherCid cluster id of the other cluster
+		 * @param initial  flag for initial run
+		 */
+		private void calculateClusterConnection(int otherCid, boolean initial) {
+			double avgConnection = 0;
+			if (workclass == otherCid) {
+				avgConnection = 1;
+			} else {
+				AutoExpandVector<Double> kmax = new AutoExpandVector<>();
+				AutoExpandVector<Integer> kmaxIndexes = new AutoExpandVector<>();
+
+				for (int p : points) {
+					CMMPoint cmdp = cmmpoints.get(p);
+					double con_p_Cj = getConnectionValue(cmmpoints.get(p), otherCid);
+					double connection = cmdp.connectivity * con_p_Cj;
+					if (initial) {
+						cmdp.p.setMeasureValue("Connection to C" + otherCid, con_p_Cj);
+					}
+
+					// connection
+					if (kmax.size() < clusterConnectionMaxPoints || connection > kmax.get(kmax.size() - 1)) {
+						int index = 0;
+						while (index < kmax.size() && connection < kmax.get(index)) {
+							index++;
+						}
+						kmax.add(index, connection);
+						kmaxIndexes.add(index, p);
+						if (kmax.size() > clusterConnectionMaxPoints) {
+							kmax.remove(kmax.size() - 1);
+							kmaxIndexes.add(kmaxIndexes.size() - 1);
+						}
+					}
+				}
+				// connection
+				for (int k = 0; k < kmax.size(); k++) {
+					avgConnection += kmax.get(k);
+				}
+				avgConnection /= kmax.size();
+			}
+
+			if (otherCid < connections.size()) {
+				connections.set(otherCid, avgConnection);
+			} else if (connections.size() == otherCid) {
+				connections.add(avgConnection);
+			} else
+				System.out.println("Something is going really wrong with the connection listing!" + knnNeighbourhood
+						+ " " + tauConnection);
+		}
+
+		/**
+		 * Merge a cluster into this cluster
+		 * 
+		 * @param mergeID the ID of the cluster to be merged
+		 */
+		private void mergeCluster(int mergeID) {
+			if (mergeID < gt0Clusters.size()) {
+				// track merging (debugging)
+				for (int i = 0; i < numGTClasses; i++) {
+					if (mergeMap[i] == mergeID)
+						mergeMap[i] = workclass;
+					if (mergeMap[i] > mergeID)
+						mergeMap[i]--;
+				}
+				GTCluster gtcMerge = gt0Clusters.get(mergeID);
+				if (debug)
+					System.out.println("Merging C" + gtcMerge.workclass + " into C" + workclass + " with Con "
+							+ connections.get(mergeID) + " / " + gtcMerge.connections.get(workclass));
+
+				// update mapTrueLabelToWorkLabel
+				mapTrueLabelToWorkLabel.put(gtcMerge.label, workclass);
+				Iterator iterator = mapTrueLabelToWorkLabel.keySet().iterator();
+				while (iterator.hasNext()) {
+					Integer key = (Integer) iterator.next();
+					// update pointer of already merged cluster
+					int value = mapTrueLabelToWorkLabel.get(key);
+					if (value == mergeID)
+						mapTrueLabelToWorkLabel.put(key, workclass);
+					if (value > mergeID)
+						mapTrueLabelToWorkLabel.put(key, value - 1);
+				}
+
+				// merge points from B into A
+				points.addAll(gtcMerge.points);
+				clusterRepresentations.addAll(gtcMerge.clusterRepresentations);
+				if (mergedWorkLabels == null) {
+					mergedWorkLabels = new ArrayList<>();
+				}
+				mergedWorkLabels.add(gtcMerge.orgWorkClass);
+				if (gtcMerge.mergedWorkLabels != null)
+					mergedWorkLabels.addAll(gtcMerge.mergedWorkLabels);
+
+				gt0Clusters.remove(mergeID);
+
+				// update workclass labels
+				for (int c = mergeID; c < gt0Clusters.size(); c++) {
+					gt0Clusters.get(c).workclass = c;
+				}
+
+				// update knn distances
+				calculateKnn();
+				for (int c = 0; c < gt0Clusters.size(); c++) {
+					gt0Clusters.get(c).connections.remove(mergeID);
+
+					// recalculate connection from other clusters to the new merged one
+					gt0Clusters.get(c).calculateClusterConnection(workclass, false);
+					// and from new merged one to other clusters
+					gt0Clusters.get(workclass).calculateClusterConnection(c, false);
+				}
+			} else {
+				System.out.println("Merge indices are not valid");
+			}
+		}
+	}
+
+	/**
+	 * @param trueClustering   the ground truth clustering
+	 * @param points           data points
+	 * @param enableClassMerge allow class merging (should be set to true on
+	 *                         default)
+	 */
+	public CMM_GTAnalysis(Clustering trueClustering, ArrayList<DataPoint> points, boolean enableClassMerge) {
+		if (debug)
+			System.out.println("GT Analysis Debug Output");
+
+		noiseErrorByModel = 0;
+		pointErrorByModel = 0;
+		if (!enableClassMerge) {
+			tauConnection = 1.0;
+		}
+
+		lamdaConn = -Math.log(lambdaConnRefXValue) / Math.log(2) / lambdaConnX;
+
+		this.gtClustering = trueClustering;
+
+		numPoints = points.size();
+		numDims = points.get(0).numAttributes() - 1;
+		numGTClusters = gtClustering.size();
+
+		// init mappings between work and true labels
+		mapTrueLabelToWorkLabel = new HashMap<>();
+
+		// set up base of new clustering
+		gt0Clusters = new ArrayList<>();
+		int numWorkClasses = 0;
+		// create label to worklabel mapping as real labels can be just a set of
+		// unordered integers
+		for (int i = 0; i < numGTClusters; i++) {
+			int label = (int) gtClustering.get(i).getGroundTruth();
+			if (!mapTrueLabelToWorkLabel.containsKey(label)) {
+				gt0Clusters.add(new GTCluster(numWorkClasses, label, i));
+				mapTrueLabelToWorkLabel.put(label, numWorkClasses);
+				numWorkClasses++;
+			} else {
+				gt0Clusters.get(mapTrueLabelToWorkLabel.get(label)).clusterRepresentations.add(i);
+			}
+		}
+		numGTClasses = numWorkClasses;
+
+		mergeMap = new int[numGTClasses];
+		for (int i = 0; i < numGTClasses; i++) {
+			mergeMap[i] = i;
+		}
+
+		// create cmd point wrapper instances
+		cmmpoints = new ArrayList<>();
+		for (int p = 0; p < points.size(); p++) {
+			CMMPoint cmdp = new CMMPoint(points.get(p), p);
+			cmmpoints.add(cmdp);
+		}
+
+		// split points up into their GTClusters and Noise (according to class labels)
+		noise = new ArrayList<>();
+		for (int p = 0; p < numPoints; p++) {
+			if (cmmpoints.get(p).isNoise()) {
+				noise.add(p);
+			} else {
+				gt0Clusters.get(cmmpoints.get(p).workclass()).points.add(p);
+			}
+		}
+
+		// calculate initial knnMean and knnDev
+		for (GTCluster gtc : gt0Clusters) {
+			gtc.calculateKnn();
+		}
+
+		// calculate cluster connections
+		calculateGTClusterConnections();
+
+		// calculate point connections with own clusters
+		calculateGTPointQualities();
+
+		if (debug)
+			System.out.println("GT Analysis Debug End");
+
+	}
+
+	/**
+	 * Calculate the connection of a point to a cluster
+	 * 
+	 * @param cmmp      the point to calculate the connection for
+	 * @param clusterID the corresponding cluster
+	 * @return the connection value
+	 */
+	// TODO: Cache the connection value for a point to the different clusters???
+	protected double getConnectionValue(CMMPoint cmmp, int clusterID) {
+		AutoExpandVector<Double> knnDist = new AutoExpandVector<>();
+		AutoExpandVector<Integer> knnPointIndex = new AutoExpandVector<>();
+
+		// calculate the knn distance of the point to the cluster
+		getKnnInCluster(cmmp, knnNeighbourhood, gt0Clusters.get(clusterID).points, knnDist, knnPointIndex);
+
+		// TODO: What to do if we have less then k neighbors?
+		double avgDist = 0;
+		for (int i = 0; i < knnDist.size(); i++) {
+			avgDist += knnDist.get(i);
+		}
+		// what to do if we only have a single point???
+		if (knnDist.size() != 0)
+			avgDist /= knnDist.size();
+		else
+			return 0;
+
+		// get the upper knn distance of the cluster
+		double upperKnn = gt0Clusters.get(clusterID).knnMeanAvg + gt0Clusters.get(clusterID).knnDevAvg;
+
+		/*
+		 * calculate the connectivity based on knn distance of the point within the
+		 * cluster and the upper knn distance of the cluster
+		 */
+		if (avgDist < upperKnn) {
+			return 1;
+		} else {
+			// value that should be reached at upperKnn distance
+			// Choose connection formula
+			double conn;
+			if (useExpConnectivity)
+				conn = Math.pow(2, -lamdaConn * (avgDist - upperKnn) / upperKnn);
+			else
+				conn = upperKnn / avgDist;
+
+			if (Double.isNaN(conn))
+				System.out.println("Connectivity NaN at " + cmmp.p.getTimestamp());
+
+			return conn;
+		}
+	}
+
+	/**
+	 * @param cmmp          point to calculate knn distance for
+	 * @param k             number of nearest neighbors to look for
+	 * @param pointIDs      list of point IDs to check
+	 * @param knnDist       sorted list of smallest knn distances (can already be
+	 *                      filled to make updates possible)
+	 * @param knnPointIndex list of corresponding knn indices
+	 */
+	private void getKnnInCluster(CMMPoint cmmp, int k, ArrayList<Integer> pointIDs, AutoExpandVector<Double> knnDist,
+			AutoExpandVector<Integer> knnPointIndex) {
+
+		// iterate over every point in the choosen cluster, cal distance and insert into
+		// list
+		for (int p1 = 0; p1 < pointIDs.size(); p1++) {
+			int pid = pointIDs.get(p1);
+			if (cmmp.pID == pid)
+				continue;
+			double dist = distance(cmmp, cmmpoints.get(pid));
+			if (knnDist.size() < k || dist < knnDist.get(knnDist.size() - 1)) {
+				int index = 0;
+				while (index < knnDist.size() && dist > knnDist.get(index)) {
+					index++;
+				}
+				knnDist.add(index, dist);
+				knnPointIndex.add(index, pid);
+				if (knnDist.size() > k) {
+					knnDist.remove(knnDist.size() - 1);
+					knnPointIndex.remove(knnPointIndex.size() - 1);
+				}
+			}
+		}
+	}
+
+	/**
+	 * calculate initial connectivities
+	 */
+	private void calculateGTPointQualities() {
+		for (int p = 0; p < numPoints; p++) {
+			CMMPoint cmdp = cmmpoints.get(p);
+			if (!cmdp.isNoise()) {
+				cmdp.connectivity = getConnectionValue(cmdp, cmdp.workclass());
+				cmdp.p.setMeasureValue("Connectivity", cmdp.connectivity);
+			}
+		}
+	}
+
+	/**
+	 * Calculate connections between clusters and merge clusters accordingly as long
+	 * as connections exceed threshold
+	 */
+	private void calculateGTClusterConnections() {
+		for (int c0 = 0; c0 < gt0Clusters.size(); c0++) {
+			for (int c1 = 0; c1 < gt0Clusters.size(); c1++) {
+				gt0Clusters.get(c0).calculateClusterConnection(c1, true);
+			}
+		}
+
+		boolean changedConnection = true;
+		while (changedConnection) {
+			if (debug) {
+				System.out.println("Cluster Connection");
+				for (int c = 0; c < gt0Clusters.size(); c++) {
+					System.out.print("C" + gt0Clusters.get(c).label + " --> ");
+					for (int c1 = 0; c1 < gt0Clusters.get(c).connections.size(); c1++) {
+						System.out.print(
+								" C" + gt0Clusters.get(c1).label + ": " + gt0Clusters.get(c).connections.get(c1));
+					}
+					System.out.println("");
+				}
+				System.out.println("");
+			}
+
+			double max = 0;
+			int maxIndexI = -1;
+			int maxIndexJ = -1;
+
+			changedConnection = false;
+			for (int c0 = 0; c0 < gt0Clusters.size(); c0++) {
+				for (int c1 = c0 + 1; c1 < gt0Clusters.size(); c1++) {
+					if (c0 == c1)
+						continue;
+					double min = Math.min(gt0Clusters.get(c0).connections.get(c1),
+							gt0Clusters.get(c1).connections.get(c0));
+					if (min > max) {
+						max = min;
+						maxIndexI = c0;
+						maxIndexJ = c1;
+					}
+				}
+			}
+			if (maxIndexI != -1 && max > tauConnection) {
+				gt0Clusters.get(maxIndexI).mergeCluster(maxIndexJ);
+				if (debug)
+					System.out.println("Merging " + maxIndexI + " and " + maxIndexJ + " because of connection " + max);
+
+				changedConnection = true;
+			}
+		}
+		numGT0Classes = gt0Clusters.size();
+	}
+
+	/**
+	 * Calculates how well the original clusters are separable. Small values
+	 * indicate bad separability, values close to 1 indicate good separability
+	 * 
+	 * @return index of seperability
+	 */
+	public double getClassSeparability() {
 //        int totalConn = numGTClasses*(numGTClasses-1)/2;
 //        int mergedConn = 0;
 //        for(GTCluster gt : gt0Clusters){
@@ -706,135 +694,138 @@ public double getClassSeparability(){
 //            return 0;
 //        else
 //            return 1-mergedConn/(double)totalConn;
-        return numGT0Classes/(double)numGTClasses;
-
-    }
-
-    
-    /**
-     * Calculates how well noise is separable from the given clusters
-     * Small values indicate bad separability, values close to 1 indicate good separability
-     * @return index of noise separability
-     */
-    public double getNoiseSeparability(){
-        if(noise.isEmpty()) 
-            return 1;
-
-        double connectivity = 0;
-        for(int p : noise){
-            CMMPoint npoint = cmmpoints.get(p);
-            double maxConnection = 0;
-
-            //TODO: some kind of pruning possible. what about weighting?
-            for (int c = 0; c < gt0Clusters.size(); c++) {
-                double connection = getConnectionValue(npoint, c);
-                if(connection > maxConnection)
-                    maxConnection = connection;
-            }
-            connectivity+=maxConnection;
-            npoint.p.setMeasureValue("MaxConnection", maxConnection);
-        }
-
-        return 1-(connectivity / noise.size());
-    }
-
-    
-    /** 
-     * Calculates the relative number of errors being caused by the underlying cluster model
-     *  @return quality of the model 
-     */
-    public double getModelQuality(){
-        for(int p = 0; p < numPoints; p++){
-            CMMPoint cmdp = cmmpoints.get(p);
-            for(int hc = 0; hc < numGTClusters;hc++){
-                if(gtClustering.get(hc).getGroundTruth() != cmdp.trueClass){
-                    if(gtClustering.get(hc).getInclusionProbability(cmdp) >= 1){
-                        if(!cmdp.isNoise())
-                            pointErrorByModel++;
-                        else
-                            noiseErrorByModel++;
-                        break;
-                    }
-                }
-            }
-        }
-        if(debug)
-            System.out.println("Error by model: noise "+noiseErrorByModel+" point "+pointErrorByModel);
-
-        return 1-((pointErrorByModel + noiseErrorByModel)/(double) numPoints);
-    }
-
-    
-    /**
-     * Get CMM internal point
-     * @param index of the point
-     * @return cmm point
-     */
-    protected CMMPoint getPoint(int index){
-        return cmmpoints.get(index);
-    }
-
-    
-    /**
-     * Return cluster
-     * @param index of the cluster to return
-     * @return cluster
-     */
-    protected GTCluster getGT0Cluster(int index){
-        return gt0Clusters.get(index);
-    }
-
-    /**
-     * Number of classes/clusters of the new clustering
-     * @return number of new clusters
-     */
-    protected int getNumberOfGT0Classes() {
-        return numGT0Classes;
-    }
-    
-    /**
-     * Calculates Euclidian distance 
-     * @param inst1 point as double array
-     * @param inst2 point as double array
-     * @return euclidian distance
-     */
-    private double distance(Instance inst1, Instance inst2){
-          return distance(inst1, inst2.toDoubleArray());
-
-    }
-    
-    /**
-     * Calculates Euclidian distance 
-     * @param inst1 point as an instance
-     * @param inst2 point as double array
-     * @return euclidian distance
-     */
-    private double distance(Instance inst1, double[] inst2){
-        double distance = 0.0;
-        for (int i = 0; i < numDims; i++) {
-            double d = inst1.value(i) - inst2[i];
-            distance += d * d;
-        }
-        return Math.sqrt(distance);
-    }
-    
-    /**
-     * String with main CMM parameters
-     * @return main CMM parameter
-     */
-    public String getParameterString(){
-        String para = "";
-        para+="k="+knnNeighbourhood+";";
-        if(useExpConnectivity){
-	        para+="lambdaConnX="+lambdaConnX+";";
-	        para+="lambdaConn="+lamdaConn+";";
-	        para+="lambdaConnRef="+lambdaConnRefXValue+";";
-        }
-        para+="m="+clusterConnectionMaxPoints+";";
-        para+="tauConn="+tauConnection+";";
-
-        return para;
-    }    
+		return numGT0Classes / (double) numGTClasses;
+
+	}
+
+	/**
+	 * Calculates how well noise is separable from the given clusters Small values
+	 * indicate bad separability, values close to 1 indicate good separability
+	 * 
+	 * @return index of noise separability
+	 */
+	public double getNoiseSeparability() {
+		if (noise.isEmpty())
+			return 1;
+
+		double connectivity = 0;
+		for (int p : noise) {
+			CMMPoint npoint = cmmpoints.get(p);
+			double maxConnection = 0;
+
+			// TODO: some kind of pruning possible. what about weighting?
+			for (int c = 0; c < gt0Clusters.size(); c++) {
+				double connection = getConnectionValue(npoint, c);
+				if (connection > maxConnection)
+					maxConnection = connection;
+			}
+			connectivity += maxConnection;
+			npoint.p.setMeasureValue("MaxConnection", maxConnection);
+		}
+
+		return 1 - (connectivity / noise.size());
+	}
+
+	/**
+	 * Calculates the relative number of errors being caused by the underlying
+	 * cluster model
+	 * 
+	 * @return quality of the model
+	 */
+	public double getModelQuality() {
+		for (int p = 0; p < numPoints; p++) {
+			CMMPoint cmdp = cmmpoints.get(p);
+			for (int hc = 0; hc < numGTClusters; hc++) {
+				if (gtClustering.get(hc).getGroundTruth() != cmdp.trueClass) {
+					if (gtClustering.get(hc).getInclusionProbability(cmdp) >= 1) {
+						if (!cmdp.isNoise())
+							pointErrorByModel++;
+						else
+							noiseErrorByModel++;
+						break;
+					}
+				}
+			}
+		}
+		if (debug)
+			System.out.println("Error by model: noise " + noiseErrorByModel + " point " + pointErrorByModel);
+
+		return 1 - ((pointErrorByModel + noiseErrorByModel) / (double) numPoints);
+	}
+
+	/**
+	 * Get CMM internal point
+	 * 
+	 * @param index of the point
+	 * @return cmm point
+	 */
+	protected CMMPoint getPoint(int index) {
+		return cmmpoints.get(index);
+	}
+
+	/**
+	 * Return cluster
+	 * 
+	 * @param index of the cluster to return
+	 * @return cluster
+	 */
+	protected GTCluster getGT0Cluster(int index) {
+		return gt0Clusters.get(index);
+	}
+
+	/**
+	 * Number of classes/clusters of the new clustering
+	 * 
+	 * @return number of new clusters
+	 */
+	protected int getNumberOfGT0Classes() {
+		return numGT0Classes;
+	}
+
+	/**
+	 * Calculates Euclidian distance
+	 * 
+	 * @param inst1 point as double array
+	 * @param inst2 point as double array
+	 * @return euclidian distance
+	 */
+	private double distance(Instance inst1, Instance inst2) {
+		return distance(inst1, inst2.toDoubleArray());
+
+	}
+
+	/**
+	 * Calculates Euclidian distance
+	 * 
+	 * @param inst1 point as an instance
+	 * @param inst2 point as double array
+	 * @return euclidian distance
+	 */
+	private double distance(Instance inst1, double[] inst2) {
+		double distance = 0.0;
+		for (int i = 0; i < numDims; i++) {
+			double d = inst1.value(i) - inst2[i];
+			distance += d * d;
+		}
+		return Math.sqrt(distance);
+	}
+
+	/**
+	 * String with main CMM parameters
+	 * 
+	 * @return main CMM parameter
+	 */
+	public String getParameterString() {
+		String para = "";
+		para += "k=" + knnNeighbourhood + ";";
+		if (useExpConnectivity) {
+			para += "lambdaConnX=" + lambdaConnX + ";";
+			para += "lambdaConn=" + lamdaConn + ";";
+			para += "lambdaConnRef=" + lambdaConnRefXValue + ";";
+		}
+		para += "m=" + clusterConnectionMaxPoints + ";";
+		para += "tauConn=" + tauConnection + ";";
+
+		return para;
+	}
 }
-
-
diff --git a/moa/src/main/java/moa/evaluation/ChangeDetectionMeasures.java b/moa/src/main/java/moa/evaluation/ChangeDetectionMeasures.java
index faccffcc6..26a4abd90 100644
--- a/moa/src/main/java/moa/evaluation/ChangeDetectionMeasures.java
+++ b/moa/src/main/java/moa/evaluation/ChangeDetectionMeasures.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
 package moa.evaluation;
@@ -25,31 +25,28 @@
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
 
-public class ChangeDetectionMeasures extends MeasureCollection implements ClassificationMeasureCollection{
-    private boolean debug = false;
-
-    public ChangeDetectionMeasures() {
-        super();
-    }
-
-    @Override
-    public String[] getNames() {
-        String[] names = {"Input","","","Ram-Hours","Time","Memory"};
-        return names;
-    }
-    
-  @Override
-  protected boolean[] getDefaultEnabled() {
-      boolean [] defaults = {true,false,false,true,true,true};
-      return defaults;
-  }
-    
-    public void evaluateClustering(Clustering clustering, Clustering trueClustering, ArrayList<DataPoint> points) {
+public class ChangeDetectionMeasures extends MeasureCollection implements ClassificationMeasureCollection {
+	private boolean debug = false;
 
-    }
+	public ChangeDetectionMeasures() {
+		super();
+	}
 
+	@Override
+	public String[] getNames() {
+		String[] names = { "Input", "", "", "Ram-Hours", "Time", "Memory" };
+		return names;
+	}
 
+	@Override
+	protected boolean[] getDefaultEnabled() {
+		boolean[] defaults = { true, false, false, true, true, true };
+		return defaults;
+	}
 
+	@Override
+	public void evaluateClustering(Clustering clustering, Clustering trueClustering, ArrayList<DataPoint> points) {
 
+	}
 
 }
diff --git a/moa/src/main/java/moa/evaluation/ClassificationMeasureCollection.java b/moa/src/main/java/moa/evaluation/ClassificationMeasureCollection.java
index 1abdabc76..2bf458521 100644
--- a/moa/src/main/java/moa/evaluation/ClassificationMeasureCollection.java
+++ b/moa/src/main/java/moa/evaluation/ClassificationMeasureCollection.java
@@ -15,13 +15,14 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
 package moa.evaluation;
 
 /**
- * Classification Measure Collection interface that it is used to not appear in clustering 
+ * Classification Measure Collection interface that it is used to not appear in
+ * clustering
  */
 public interface ClassificationMeasureCollection {
 
diff --git a/moa/src/main/java/moa/evaluation/EntropyCollection.java b/moa/src/main/java/moa/evaluation/EntropyCollection.java
index dcf04e018..c5fb00e12 100644
--- a/moa/src/main/java/moa/evaluation/EntropyCollection.java
+++ b/moa/src/main/java/moa/evaluation/EntropyCollection.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.evaluation;
@@ -25,158 +25,155 @@
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
 
-
-public class EntropyCollection extends MeasureCollection{
-    private boolean debug = false;
-    private final double beta = 1;
-
-
-    @Override
-    protected String[] getNames() {
-        String[] names = {"GT cross entropy","FC cross entropy","Homogeneity","Completeness","V-Measure","VarInformation"};
-        return names;
-    }
-
-    @Override
-    protected boolean[] getDefaultEnabled() {
-        boolean [] defaults = {false, false, false, false, false, false};
-        return defaults;
-    }
-
-    @Override
-    public void evaluateClustering(Clustering fclustering, Clustering hClustering, ArrayList<DataPoint> points) throws Exception {
-
-        MembershipMatrix mm = new MembershipMatrix(fclustering, points);
-        int numClasses = mm.getNumClasses();
-        int numCluster = fclustering.size()+1;
-        int n = mm.getTotalEntries();
-
-
-        double FCentropy = 0;
-        if(numCluster > 1){
-            for (int fc = 0; fc < numCluster; fc++){
-                double weight = mm.getClusterSum(fc)/(double)n;
-                if(weight > 0)
-                    FCentropy+= weight * Math.log10(weight);
-            }
-            FCentropy/=(-1*Math.log10(numCluster));
-        }
-        if(debug){
-            System.out.println("FC entropy "+FCentropy);
-        }
-
-        double GTentropy = 0;
-        if(numClasses > 1){
-            for (int hc = 0; hc < numClasses; hc++){
-                double weight = mm.getClassSum(hc)/(double)n;
-                if(weight > 0)
-                    GTentropy+= weight * Math.log10(weight);
-            }
-            GTentropy/=(-1*Math.log10(numClasses));
-        }
-        if(debug){
-            System.out.println("GT entropy "+GTentropy);
-        }
-
-
-        //cluster based entropy
-        double FCcrossEntropy = 0;
-        
-        for (int fc = 0; fc < numCluster; fc++){
-            double e = 0;
-            int clusterWeight = mm.getClusterSum(fc);
-            if(clusterWeight>0){
-                for (int hc = 0; hc < numClasses; hc++) {
-                    double p = mm.getClusterClassWeight(fc, hc)/(double)clusterWeight;
-                    if(p!=0){
-                        e+=p * Math.log10(p);
-                    }
-                }
-                FCcrossEntropy+=((clusterWeight/(double)n) * e);
-            }
-        }
-        if(numCluster > 1){
-            FCcrossEntropy/=-1*Math.log10(numCluster);
-        }
-
-        addValue("FC cross entropy", 1-FCcrossEntropy);
-        if(debug){
-            System.out.println("FC cross entropy "+(1-FCcrossEntropy));
-        }
-
-
-        //class based entropy
-        double GTcrossEntropy = 0;
-        for (int hc = 0; hc < numClasses; hc++){
-            double e = 0;
-            int classWeight = mm.getClassSum(hc);
-            if(classWeight>0){
-                for (int fc = 0; fc < numCluster; fc++) {
-                    double p = mm.getClusterClassWeight(fc, hc)/(double)classWeight;
-                    if(p!=0){
-                        e+=p * Math.log10(p);
-                    }
-                }
-            }
-            GTcrossEntropy+=((classWeight/(double)n) * e);
-        }
-        if(numClasses > 1)
-            GTcrossEntropy/=-1*Math.log10(numClasses);
-        addValue("GT cross entropy", 1-GTcrossEntropy);
-        if(debug){
-            System.out.println("GT cross entropy "+(1-GTcrossEntropy));
-        }
-
-        double homogeneity;
-        if(FCentropy == 0)
-            homogeneity = 1;
-        else
-            homogeneity = 1 - FCcrossEntropy/FCentropy;
-
-        //TODO set err values for now, needs to be debugged
-        if(homogeneity > 1 || homogeneity < 0)
-            addValue("Homogeneity",-1);
-        else
-            addValue("Homogeneity",homogeneity);
-
-        double completeness;
-        if(GTentropy == 0)
-            completeness = 1;
-        else
-            completeness = 1 - GTcrossEntropy/GTentropy;
-        addValue("Completeness",completeness);
-
-        double vmeasure = (1+beta)*homogeneity*completeness/(beta*homogeneity+completeness);
-
-        if(vmeasure > 1 || homogeneity < 0)
-            addValue("V-Measure",-1);
-        else
-            addValue("V-Measure",vmeasure);
-
-
-
-        double mutual = 0;
-        for (int i = 0; i < numCluster; i++){
-                for (int j = 0; j < numClasses; j++) {
-                   if(mm.getClusterClassWeight(i, j)==0) continue;
-                   double m = Math.log10(mm.getClusterClassWeight(i, j)/(double)mm.getClusterSum(i)/(double)mm.getClassSum(j)*(double)n);
-                   m*= mm.getClusterClassWeight(i, j)/(double)n;
-                   if(debug)
-                        System.out.println("("+j+"/"+ j + "): "+m);
-                   mutual+=m;
-                }
-        }
-        if(numClasses > 1)
-            mutual/=Math.log10(numClasses);
-
-        double varInfo = 1;
-        if(FCentropy + GTentropy > 0)
-            varInfo = 2*mutual/(FCentropy + GTentropy);
-        
-        if(debug)
-            System.out.println("mutual "+mutual+ " / VI "+varInfo);
-        addValue("VarInformation", varInfo);
-
-    }
+public class EntropyCollection extends MeasureCollection {
+	private boolean debug = false;
+	private final double beta = 1;
+
+	@Override
+	protected String[] getNames() {
+		String[] names = { "GT cross entropy", "FC cross entropy", "Homogeneity", "Completeness", "V-Measure",
+				"VarInformation" };
+		return names;
+	}
+
+	@Override
+	protected boolean[] getDefaultEnabled() {
+		boolean[] defaults = { false, false, false, false, false, false };
+		return defaults;
+	}
+
+	@Override
+	public void evaluateClustering(Clustering fclustering, Clustering hClustering, ArrayList<DataPoint> points)
+			throws Exception {
+
+		MembershipMatrix mm = new MembershipMatrix(fclustering, points);
+		int numClasses = mm.getNumClasses();
+		int numCluster = fclustering.size() + 1;
+		int n = mm.getTotalEntries();
+
+		double FCentropy = 0;
+		if (numCluster > 1) {
+			for (int fc = 0; fc < numCluster; fc++) {
+				double weight = mm.getClusterSum(fc) / (double) n;
+				if (weight > 0)
+					FCentropy += weight * Math.log10(weight);
+			}
+			FCentropy /= (-1 * Math.log10(numCluster));
+		}
+		if (debug) {
+			System.out.println("FC entropy " + FCentropy);
+		}
+
+		double GTentropy = 0;
+		if (numClasses > 1) {
+			for (int hc = 0; hc < numClasses; hc++) {
+				double weight = mm.getClassSum(hc) / (double) n;
+				if (weight > 0)
+					GTentropy += weight * Math.log10(weight);
+			}
+			GTentropy /= (-1 * Math.log10(numClasses));
+		}
+		if (debug) {
+			System.out.println("GT entropy " + GTentropy);
+		}
+
+		// cluster based entropy
+		double FCcrossEntropy = 0;
+
+		for (int fc = 0; fc < numCluster; fc++) {
+			double e = 0;
+			int clusterWeight = mm.getClusterSum(fc);
+			if (clusterWeight > 0) {
+				for (int hc = 0; hc < numClasses; hc++) {
+					double p = mm.getClusterClassWeight(fc, hc) / (double) clusterWeight;
+					if (p != 0) {
+						e += p * Math.log10(p);
+					}
+				}
+				FCcrossEntropy += ((clusterWeight / (double) n) * e);
+			}
+		}
+		if (numCluster > 1) {
+			FCcrossEntropy /= -1 * Math.log10(numCluster);
+		}
+
+		addValue("FC cross entropy", 1 - FCcrossEntropy);
+		if (debug) {
+			System.out.println("FC cross entropy " + (1 - FCcrossEntropy));
+		}
+
+		// class based entropy
+		double GTcrossEntropy = 0;
+		for (int hc = 0; hc < numClasses; hc++) {
+			double e = 0;
+			int classWeight = mm.getClassSum(hc);
+			if (classWeight > 0) {
+				for (int fc = 0; fc < numCluster; fc++) {
+					double p = mm.getClusterClassWeight(fc, hc) / (double) classWeight;
+					if (p != 0) {
+						e += p * Math.log10(p);
+					}
+				}
+			}
+			GTcrossEntropy += ((classWeight / (double) n) * e);
+		}
+		if (numClasses > 1)
+			GTcrossEntropy /= -1 * Math.log10(numClasses);
+		addValue("GT cross entropy", 1 - GTcrossEntropy);
+		if (debug) {
+			System.out.println("GT cross entropy " + (1 - GTcrossEntropy));
+		}
+
+		double homogeneity;
+		if (FCentropy == 0)
+			homogeneity = 1;
+		else
+			homogeneity = 1 - FCcrossEntropy / FCentropy;
+
+		// TODO set err values for now, needs to be debugged
+		if (homogeneity > 1 || homogeneity < 0)
+			addValue("Homogeneity", -1);
+		else
+			addValue("Homogeneity", homogeneity);
+
+		double completeness;
+		if (GTentropy == 0)
+			completeness = 1;
+		else
+			completeness = 1 - GTcrossEntropy / GTentropy;
+		addValue("Completeness", completeness);
+
+		double vmeasure = (1 + beta) * homogeneity * completeness / (beta * homogeneity + completeness);
+
+		if (vmeasure > 1 || homogeneity < 0)
+			addValue("V-Measure", -1);
+		else
+			addValue("V-Measure", vmeasure);
+
+		double mutual = 0;
+		for (int i = 0; i < numCluster; i++) {
+			for (int j = 0; j < numClasses; j++) {
+				if (mm.getClusterClassWeight(i, j) == 0)
+					continue;
+				double m = Math
+						.log10(mm.getClusterClassWeight(i, j) / (double) mm.getClusterSum(i) / mm.getClassSum(j) * n);
+				m *= mm.getClusterClassWeight(i, j) / (double) n;
+				if (debug)
+					System.out.println("(" + j + "/" + j + "): " + m);
+				mutual += m;
+			}
+		}
+		if (numClasses > 1)
+			mutual /= Math.log10(numClasses);
+
+		double varInfo = 1;
+		if (FCentropy + GTentropy > 0)
+			varInfo = 2 * mutual / (FCentropy + GTentropy);
+
+		if (debug)
+			System.out.println("mutual " + mutual + " / VI " + varInfo);
+		addValue("VarInformation", varInfo);
+
+	}
 
 }
diff --git a/moa/src/main/java/moa/evaluation/F1.java b/moa/src/main/java/moa/evaluation/F1.java
index de214877c..ef63648a3 100644
--- a/moa/src/main/java/moa/evaluation/F1.java
+++ b/moa/src/main/java/moa/evaluation/F1.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 package moa.evaluation;
 
@@ -24,96 +24,94 @@
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
 
-public class F1 extends MeasureCollection{
+public class F1 extends MeasureCollection {
 
-    @Override
-    protected String[] getNames() {
-        String[] names = {"F1-P","F1-R","Purity"};
-        return names;
-    }
+	@Override
+	protected String[] getNames() {
+		String[] names = { "F1-P", "F1-R", "Purity" };
+		return names;
+	}
 
 //    @Override
 //    protected boolean[] getDefaultEnabled() {
 //        boolean [] defaults = {false, false, false};
 //        return defaults;
 //    }
-    
-    public void evaluateClustering(Clustering clustering, Clustering trueClustering, ArrayList<DataPoint> points) {
-
-        if (clustering.size()<0){
-            addValue(0,0);
-            addValue(1,0);
-            return;
-        }
-
-        MembershipMatrix mm = new MembershipMatrix(clustering, points);
-        //System.out.println(mm.toString());
-
-        int numClasses = mm.getNumClasses();
-        if(mm.hasNoiseClass())
-            numClasses--;
-
-
-
-        //F1 as defined in P3C, try using F1 optimization
-        double F1_P = 0.0;
-        double purity = 0;
-        int realClusters = 0;
-        for (int i = 0; i < clustering.size(); i++) {
-            int max_weight = 0;
-            int max_weight_index = -1;
-
-            //find max index
-            for (int j = 0; j < numClasses; j++) {
-                if(mm.getClusterClassWeight(i, j) > max_weight){
-                    max_weight = mm.getClusterClassWeight(i, j);
-                    max_weight_index = j;
-                }
-            }
-            if(max_weight_index!=-1){
-                realClusters++;
-                double precision = mm.getClusterClassWeight(i, max_weight_index)/(double)mm.getClusterSum(i);
-                double recall = mm.getClusterClassWeight(i, max_weight_index)/(double) mm.getClassSum(max_weight_index);
-                double f1 = 0;
-                if(precision > 0 || recall > 0){
-                    f1 = 2*precision*recall/(precision+recall);
-                }
-                F1_P += f1;
-                purity += precision;
-
-                //TODO should we move setMeasure stuff into the Cluster interface?
-                clustering.get(i).setMeasureValue("F1-P", Double.toString(f1));
-            }
-        }
-        if(realClusters > 0){
-            F1_P/=realClusters;
-            purity/=realClusters;
-        }
-        addValue("F1-P",F1_P);
-        addValue("Purity",purity);
-
-
-
-        //F1 as defined in .... mainly maximizes F1 for each class
-        double F1_R = 0.0;
-        for (int j = 0; j < numClasses; j++) {
-            double max_f1 = 0;
-            for (int i = 0; i < clustering.size(); i++) {
-                double precision = mm.getClusterClassWeight(i, j)/(double)mm.getClusterSum(i);
-                double recall = mm.getClusterClassWeight(i, j)/(double)mm.getClassSum(j);
-                double f1 = 0;
-                if(precision > 0 || recall > 0){
-                    f1 = 2*precision*recall/(precision+recall);
-                }
-                if(max_f1 < f1){
-                    max_f1 = f1;
-                }
-            }
-            F1_R+= max_f1;
-        }
-        F1_R/=numClasses;
 
-        addValue("F1-R",F1_R);
-    }
+	@Override
+	public void evaluateClustering(Clustering clustering, Clustering trueClustering, ArrayList<DataPoint> points) {
+
+		if (clustering.size() < 0) {
+			addValue(0, 0);
+			addValue(1, 0);
+			return;
+		}
+
+		MembershipMatrix mm = new MembershipMatrix(clustering, points);
+		// System.out.println(mm.toString());
+
+		int numClasses = mm.getNumClasses();
+		if (mm.hasNoiseClass())
+			numClasses--;
+
+		// F1 as defined in P3C, try using F1 optimization
+		double F1_P = 0.0;
+		double purity = 0;
+		int realClusters = 0;
+		for (int i = 0; i < clustering.size(); i++) {
+			int max_weight = 0;
+			int max_weight_index = -1;
+
+			// find max index
+			for (int j = 0; j < numClasses; j++) {
+				if (mm.getClusterClassWeight(i, j) > max_weight) {
+					max_weight = mm.getClusterClassWeight(i, j);
+					max_weight_index = j;
+				}
+			}
+			if (max_weight_index != -1) {
+				realClusters++;
+				double precision = mm.getClusterClassWeight(i, max_weight_index) / (double) mm.getClusterSum(i);
+				double recall = mm.getClusterClassWeight(i, max_weight_index)
+						/ (double) mm.getClassSum(max_weight_index);
+				double f1 = 0;
+				if (precision > 0 || recall > 0) {
+					f1 = 2 * precision * recall / (precision + recall);
+				}
+				F1_P += f1;
+				purity += precision;
+
+				// TODO should we move setMeasure stuff into the Cluster interface?
+				clustering.get(i).setMeasureValue("F1-P", Double.toString(f1));
+			}
+		}
+		if (realClusters > 0) {
+			F1_P /= realClusters;
+			purity /= realClusters;
+		}
+		addValue("F1-P", F1_P);
+		addValue("Purity", purity);
+
+		// F1 as defined in .... mainly maximizes F1 for each class
+		double F1_R = 0.0;
+		for (int j = 0; j < numClasses; j++) {
+			double max_f1 = 0;
+			for (int i = 0; i < clustering.size(); i++) {
+				double precision = mm.getClusterClassWeight(i, j) / (double) mm.getClusterSum(i);
+				double recall = mm.getClusterClassWeight(i, j) / (double) mm.getClassSum(j);
+				double f1 = 0;
+				if (precision > 0 || recall > 0) {
+					f1 = 2 * precision * recall / (precision + recall);
+				}
+				if (max_f1 < f1) {
+					max_f1 = f1;
+				}
+			}
+			F1_R += max_f1;
+		}
+		F1_R /= numClasses;
+
+		addValue("F1-R", F1_R);
+	}
 
 }
diff --git a/moa/src/main/java/moa/evaluation/General.java b/moa/src/main/java/moa/evaluation/General.java
index 90682d18b..8922c6582 100644
--- a/moa/src/main/java/moa/evaluation/General.java
+++ b/moa/src/main/java/moa/evaluation/General.java
@@ -15,12 +15,11 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
 package moa.evaluation;
 
-
 import java.util.ArrayList;
 
 import com.yahoo.labs.samoa.instances.Instance;
@@ -29,26 +28,25 @@
 import moa.cluster.SphereCluster;
 import moa.gui.visualization.DataPoint;
 
-public class General extends MeasureCollection{
-    private int numPoints;
-    private int numFClusters;
-    private int numDims;
-    private double pointInclusionProbThreshold = 0.8;
-    private Clustering clustering;
-    private ArrayList<DataPoint> points;
-
-
-    public General() {
-        super();
-    }
-
-
-    @Override
-    protected String[] getNames() {
-        String[] names = {"GPrecision","GRecall","Redundancy","numCluster","numClasses"};
-        //String[] names = {"GPrecision","GRecall","Redundancy","Overlap","numCluster","numClasses","Compactness"};
-        return names;
-    }
+public class General extends MeasureCollection {
+	private int numPoints;
+	private int numFClusters;
+	private int numDims;
+	private double pointInclusionProbThreshold = 0.8;
+	private Clustering clustering;
+	private ArrayList<DataPoint> points;
+
+	public General() {
+		super();
+	}
+
+	@Override
+	protected String[] getNames() {
+		String[] names = { "GPrecision", "GRecall", "Redundancy", "numCluster", "numClasses" };
+		// String[] names =
+		// {"GPrecision","GRecall","Redundancy","Overlap","numCluster","numClasses","Compactness"};
+		return names;
+	}
 
 //    @Override
 //    protected boolean[] getDefaultEnabled() {
@@ -56,137 +54,138 @@ protected String[] getNames() {
 //        return defaults;
 //    }
 
-    @Override
-    public void evaluateClustering(Clustering clustering, Clustering trueClustering, ArrayList<DataPoint> points) throws Exception{
-
-        this.points = points;
-        this.clustering = clustering;
-        numPoints = points.size();
-        numFClusters = clustering.size();
-        numDims = points.get(0).numAttributes()-1;
-
-
-        int totalRedundancy = 0;
-        int trueCoverage = 0;
-        int totalCoverage = 0;
-
-        int numNoise = 0;
-        for (int p = 0; p < numPoints; p++) {
-            int coverage = 0;
-            for (int c = 0; c < numFClusters; c++) {
-                //contained in cluster c?
-                if(clustering.get(c).getInclusionProbability(points.get(p)) >= pointInclusionProbThreshold){
-                    coverage++;
-                }
-            }
-
-            if(points.get(p).classValue()==-1){
-                numNoise++;
-            }
-            else{
-                if(coverage>0) trueCoverage++;
-            }
-
-            if(coverage>0) totalCoverage++;  //points covered by clustering (incl. noise)
-            if(coverage>1) totalRedundancy++; //include noise
-        }
-
-        addValue("numCluster", clustering.size());
-        addValue("numClasses", trueClustering.size());
-        addValue("Redundancy", ((double)totalRedundancy/(double)numPoints));
-        addValue("GPrecision", (totalCoverage==0?0:((double)trueCoverage/(double)(totalCoverage))));
-        addValue("GRecall", ((double)trueCoverage/(double)(numPoints-numNoise)));
+	@Override
+	public void evaluateClustering(Clustering clustering, Clustering trueClustering, ArrayList<DataPoint> points)
+			throws Exception {
+
+		this.points = points;
+		this.clustering = clustering;
+		numPoints = points.size();
+		numFClusters = clustering.size();
+		numDims = points.get(0).numAttributes() - 1;
+
+		int totalRedundancy = 0;
+		int trueCoverage = 0;
+		int totalCoverage = 0;
+
+		int numNoise = 0;
+		for (int p = 0; p < numPoints; p++) {
+			int coverage = 0;
+			for (int c = 0; c < numFClusters; c++) {
+				// contained in cluster c?
+				if (clustering.get(c).getInclusionProbability(points.get(p)) >= pointInclusionProbThreshold) {
+					coverage++;
+				}
+			}
+
+			if (points.get(p).classValue() == -1) {
+				numNoise++;
+			} else {
+				if (coverage > 0)
+					trueCoverage++;
+			}
+
+			if (coverage > 0)
+				totalCoverage++; // points covered by clustering (incl. noise)
+			if (coverage > 1)
+				totalRedundancy++; // include noise
+		}
+
+		addValue("numCluster", clustering.size());
+		addValue("numClasses", trueClustering.size());
+		addValue("Redundancy", ((double) totalRedundancy / (double) numPoints));
+		addValue("GPrecision", (totalCoverage == 0 ? 0 : ((double) trueCoverage / (double) (totalCoverage))));
+		addValue("GRecall", ((double) trueCoverage / (double) (numPoints - numNoise)));
 //        if(isEnabled(3)){
 //            addValue("Compactness", computeCompactness());
 //        }
 //        if(isEnabled(3)){
 //            addValue("Overlap", computeOverlap());
 //        }
-    }
-
-    private double computeOverlap(){
-        for (int c = 0; c < numFClusters; c++) {
-            if(!(clustering.get(c) instanceof SphereCluster)){
-                System.out.println("Overlap only supports Sphere Cluster. Found: "+clustering.get(c).getClass());
-                return Double.NaN;
-            }
-        }
-
-        boolean[] overlap = new boolean[numFClusters];
-
-        for (int c0 = 0; c0 < numFClusters; c0++) {
-            if(overlap[c0]) continue;
-            SphereCluster s0 = (SphereCluster)clustering.get(c0);
-            for (int c1 = c0; c1 < clustering.size(); c1++) {
-                if(c1 == c0) continue;
-                SphereCluster s1 = (SphereCluster)clustering.get(c1);
-                if(s0.overlapRadiusDegree(s1) > 0){
-                    overlap[c0] = overlap[c1] = true;
-                }
-            }
-        }
-
-        double totalOverlap = 0;
-        for (int c0 = 0; c0 < numFClusters; c0++) {
-            if(overlap[c0])
-                totalOverlap++;
-        }
+	}
+
+	private double computeOverlap() {
+		for (int c = 0; c < numFClusters; c++) {
+			if (!(clustering.get(c) instanceof SphereCluster)) {
+				System.out.println("Overlap only supports Sphere Cluster. Found: " + clustering.get(c).getClass());
+				return Double.NaN;
+			}
+		}
+
+		boolean[] overlap = new boolean[numFClusters];
+
+		for (int c0 = 0; c0 < numFClusters; c0++) {
+			if (overlap[c0])
+				continue;
+			SphereCluster s0 = (SphereCluster) clustering.get(c0);
+			for (int c1 = c0; c1 < clustering.size(); c1++) {
+				if (c1 == c0)
+					continue;
+				SphereCluster s1 = (SphereCluster) clustering.get(c1);
+				if (s0.overlapRadiusDegree(s1) > 0) {
+					overlap[c0] = overlap[c1] = true;
+				}
+			}
+		}
+
+		double totalOverlap = 0;
+		for (int c0 = 0; c0 < numFClusters; c0++) {
+			if (overlap[c0])
+				totalOverlap++;
+		}
 
 //        if(totalOverlap/(double)numFClusters > .8) RunVisualizer.pause();
-        if(numFClusters>0) totalOverlap/=(double)numFClusters;
-        return totalOverlap;
-    }
-
-
-    private double computeCompactness(){
-        if(numFClusters == 0) return 0;
-        for (int c = 0; c < numFClusters; c++) {
-            if(!(clustering.get(c) instanceof SphereCluster)){
-                System.out.println("Compactness only supports Sphere Cluster. Found: "+clustering.get(c).getClass());
-                return Double.NaN;
-            }
-        }
-
-        //TODO weight radius by number of dimensions
-        double totalCompactness = 0;
-        for (int c = 0; c < numFClusters; c++) {
-            ArrayList<Instance> containedPoints = new ArrayList<Instance>();
-            for (int p = 0; p < numPoints; p++) {
-                //p in c
-                if(clustering.get(c).getInclusionProbability(points.get(p)) >= pointInclusionProbThreshold){
-                    containedPoints.add(points.get(p));
-                }
-            }
-            double compactness = 0;
-            if(containedPoints.size()>1){
-                //cluster not empty
-                SphereCluster minEnclosingCluster = new SphereCluster(containedPoints, numDims);
-                double minRadius = minEnclosingCluster.getRadius();
-                double cfRadius = ((SphereCluster)clustering.get(c)).getRadius();
-                if(Math.abs(minRadius-cfRadius) < 0.1e-10){
-                    compactness = 1;
-                }
-                else
-                    if(minRadius < cfRadius)
-                        compactness = minRadius/cfRadius;
-                    else{
-                        System.out.println("Optimal radius bigger then real one ("+(cfRadius-minRadius)+"), this is really wrong");
-                        compactness = 1;
-                    }
-            }
-            else{
-                double cfRadius = ((SphereCluster)clustering.get(c)).getRadius();
-                if(cfRadius==0) compactness = 1;
-            }
-
-            //weight by weight of cluster???
-            totalCompactness+=compactness;
-            clustering.get(c).setMeasureValue("Compactness", Double.toString(compactness));
-        }
-        return (totalCompactness/numFClusters);
-    }
-
+		if (numFClusters > 0)
+			totalOverlap /= numFClusters;
+		return totalOverlap;
+	}
+
+	private double computeCompactness() {
+		if (numFClusters == 0)
+			return 0;
+		for (int c = 0; c < numFClusters; c++) {
+			if (!(clustering.get(c) instanceof SphereCluster)) {
+				System.out.println("Compactness only supports Sphere Cluster. Found: " + clustering.get(c).getClass());
+				return Double.NaN;
+			}
+		}
+
+		// TODO weight radius by number of dimensions
+		double totalCompactness = 0;
+		for (int c = 0; c < numFClusters; c++) {
+			ArrayList<Instance> containedPoints = new ArrayList<>();
+			for (int p = 0; p < numPoints; p++) {
+				// p in c
+				if (clustering.get(c).getInclusionProbability(points.get(p)) >= pointInclusionProbThreshold) {
+					containedPoints.add(points.get(p));
+				}
+			}
+			double compactness = 0;
+			if (containedPoints.size() > 1) {
+				// cluster not empty
+				SphereCluster minEnclosingCluster = new SphereCluster(containedPoints, numDims);
+				double minRadius = minEnclosingCluster.getRadius();
+				double cfRadius = ((SphereCluster) clustering.get(c)).getRadius();
+				if (Math.abs(minRadius - cfRadius) < 0.1e-10) {
+					compactness = 1;
+				} else if (minRadius < cfRadius)
+					compactness = minRadius / cfRadius;
+				else {
+					System.out.println("Optimal radius bigger then real one (" + (cfRadius - minRadius)
+							+ "), this is really wrong");
+					compactness = 1;
+				}
+			} else {
+				double cfRadius = ((SphereCluster) clustering.get(c)).getRadius();
+				if (cfRadius == 0)
+					compactness = 1;
+			}
+
+			// weight by weight of cluster???
+			totalCompactness += compactness;
+			clustering.get(c).setMeasureValue("Compactness", Double.toString(compactness));
+		}
+		return (totalCompactness / numFClusters);
+	}
 
 }
-
-
diff --git a/moa/src/main/java/moa/evaluation/LearningEvaluation.java b/moa/src/main/java/moa/evaluation/LearningEvaluation.java
index 6aaa07c59..f5511a83f 100644
--- a/moa/src/main/java/moa/evaluation/LearningEvaluation.java
+++ b/moa/src/main/java/moa/evaluation/LearningEvaluation.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.evaluation;
 
@@ -25,6 +25,7 @@
 
 import moa.AbstractMOAObject;
 import moa.core.Measurement;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
 import moa.learners.MLTask;
 
 /**
@@ -35,37 +36,34 @@
  */
 public class LearningEvaluation extends AbstractMOAObject {
 
-    private static final long serialVersionUID = 1L;
-
-    protected Measurement[] measurements;
+	private static final long serialVersionUID = 1L;
 
-    public LearningEvaluation(Measurement[] measurements) {
-        this.measurements = measurements.clone();
-    }
+	protected Measurement[] measurements;
 
-    public LearningEvaluation(Measurement[] evaluationMeasurements,
-            LearningPerformanceEvaluator cpe, MLTask model) {
-        List<Measurement> measurementList = new LinkedList<Measurement>();
-        if (evaluationMeasurements != null){
-        measurementList.addAll(Arrays.asList(evaluationMeasurements));
-        }
-        measurementList.addAll(Arrays.asList(cpe.getPerformanceMeasurements()));
-        measurementList.addAll(Arrays.asList(model.getModelMeasurements()));
-        this.measurements = measurementList.toArray(new Measurement[measurementList.size()]);
-    }
+	public LearningEvaluation(Measurement[] measurements) {
+		this.measurements = measurements.clone();
+	}
 
-    public LearningEvaluation(
-            LearningPerformanceEvaluator cpe, MLTask model) {
-        this(null,cpe,model);
-    }
+	public LearningEvaluation(Measurement[] evaluationMeasurements, LearningPerformanceEvaluator cpe, MLTask model) {
+		List<Measurement> measurementList = new LinkedList<>();
+		if (evaluationMeasurements != null) {
+			measurementList.addAll(Arrays.asList(evaluationMeasurements));
+		}
+		measurementList.addAll(Arrays.asList(cpe.getPerformanceMeasurements()));
+		measurementList.addAll(Arrays.asList(model.getModelMeasurements()));
+		this.measurements = measurementList.toArray(new Measurement[measurementList.size()]);
+	}
 
+	public LearningEvaluation(LearningPerformanceEvaluator cpe, MLTask model) {
+		this(null, cpe, model);
+	}
 
-    public Measurement[] getMeasurements() {
-        return this.measurements.clone();
-    }
+	public Measurement[] getMeasurements() {
+		return this.measurements.clone();
+	}
 
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        Measurement.getMeasurementsDescription(this.measurements, sb, indent);
-    }
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		Measurement.getMeasurementsDescription(this.measurements, sb, indent);
+	}
 }
diff --git a/moa/src/main/java/moa/evaluation/MeasureCollection.java b/moa/src/main/java/moa/evaluation/MeasureCollection.java
index 0016239e7..b01d3141a 100644
--- a/moa/src/main/java/moa/evaluation/MeasureCollection.java
+++ b/moa/src/main/java/moa/evaluation/MeasureCollection.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.evaluation;
@@ -27,233 +27,236 @@
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
 
-public abstract class MeasureCollection extends AbstractMOAObject{
-    private String[] names;
-    private ArrayList<Double>[] values;
-    private ArrayList<Double>[] sortedValues;
-    private ArrayList<String> events;
-    
-    private double[] minValue;
-    private double[] maxValue;
-    private double[] sumValues;
-    private boolean[] enabled;
-    private boolean[] corrupted;
-    private double time;
-    private boolean debug = true;
-    private MembershipMatrix mm = null;
-
-    private HashMap<String, Integer> map;
-
-    private int numMeasures = 0;
-    
-    
-
-
-     public MeasureCollection() {
-        names = getNames();
-        numMeasures = names.length;
-        map = new HashMap<String, Integer>(numMeasures);        
-        for (int i = 0; i < names.length; i++) {
-             map.put(names[i],i);
-        }
-        values = (ArrayList<Double>[]) new ArrayList[numMeasures];
-        sortedValues = (ArrayList<Double>[]) new ArrayList[numMeasures];
-        maxValue = new double[numMeasures];
-        minValue = new double[numMeasures];
-        sumValues = new double[numMeasures];
-        corrupted = new boolean[numMeasures];
-        enabled = getDefaultEnabled();
-        time = 0;
-        events = new ArrayList<String>();
-
-        for (int i = 0; i < numMeasures; i++) {
-                values[i] = new ArrayList<Double>();
-                sortedValues[i] = new ArrayList<Double>();
-                maxValue[i] = Double.MIN_VALUE;
-                minValue[i] = Double.MAX_VALUE;
-                corrupted[i] = false;
-                sumValues[i] = 0.0;
-        }
-
-    }
-
-    protected abstract String[] getNames();
-
-     public void addValue(int index, double value){
-         if(Double.isNaN(value)){
-        	 if(debug)
-        		 System.out.println("NaN for "+names[index]);
-             corrupted[index] = true;
-         }
-         //if(value < 0){
-        //	 if(debug)
-        //		 System.out.println("Negative value for "+names[index]);
-        // }
-
-         values[index].add(value);
-         sumValues[index]+=value;
-         if(value < minValue[index]) minValue[index] = value;
-         if(value > maxValue[index]) maxValue[index] = value;
-     }
-
-     protected void addValue(String name, double value){
-        if(map.containsKey(name)){
-            addValue(map.get(name),value);
-        }
-        else{
-            System.out.println(name+" is not a valid measure key, no value added");
-        }
-     }
-     
-     //add an empty entry e.g. if evaluation crashed internally
-     public void addEmptyValue(int index){
-         values[index].add(Double.NaN);
-         corrupted[index] = true;
-     }
-
-     public int getNumMeasures(){
-         return numMeasures;
-     }
-
-     public String getName(int index){
-        return names[index];
-     }
-
-     public double getMaxValue(int index){
-         return maxValue[index];
-     }
-
-     public double getMinValue(int index){
-         return minValue[index];
-     }
-
-     public double getLastValue(int index){
-         if(values[index].size()<1) return Double.NaN;
-         return values[index].get(values[index].size()-1);
-     }
-
-     public double getMean(int index){
-         if(corrupted[index] || values[index].size()<1)
-             return Double.NaN;
-
-         return sumValues[index]/values[index].size();
-     }
-
-     private void updateSortedValues(int index){
-         //naive implementation of insertion sort
-         for (int i = sortedValues[index].size(); i < values[index].size(); i++) {
-             double v = values[index].get(i);
-             int insertIndex = 0;
-             while(!sortedValues[index].isEmpty() && insertIndex < sortedValues[index].size() && v > sortedValues[index].get(insertIndex))
-                 insertIndex++;
-             sortedValues[index].add(insertIndex,v);
-         }
+public abstract class MeasureCollection extends AbstractMOAObject {
+	private String[] names;
+	private ArrayList<Double>[] values;
+	private ArrayList<Double>[] sortedValues;
+	private ArrayList<String> events;
+
+	private double[] minValue;
+	private double[] maxValue;
+	private double[] sumValues;
+	private boolean[] enabled;
+	private boolean[] corrupted;
+	private double time;
+	private boolean debug = true;
+	private MembershipMatrix mm = null;
+
+	private HashMap<String, Integer> map;
+
+	private int numMeasures = 0;
+
+	public MeasureCollection() {
+		names = getNames();
+		numMeasures = names.length;
+		map = new HashMap<>(numMeasures);
+		for (int i = 0; i < names.length; i++) {
+			map.put(names[i], i);
+		}
+		values = new ArrayList[numMeasures];
+		sortedValues = new ArrayList[numMeasures];
+		maxValue = new double[numMeasures];
+		minValue = new double[numMeasures];
+		sumValues = new double[numMeasures];
+		corrupted = new boolean[numMeasures];
+		enabled = getDefaultEnabled();
+		time = 0;
+		events = new ArrayList<>();
+
+		for (int i = 0; i < numMeasures; i++) {
+			values[i] = new ArrayList<>();
+			sortedValues[i] = new ArrayList<>();
+			maxValue[i] = Double.MIN_VALUE;
+			minValue[i] = Double.MAX_VALUE;
+			corrupted[i] = false;
+			sumValues[i] = 0.0;
+		}
+
+	}
+
+	protected abstract String[] getNames();
+
+	public void addValue(int index, double value) {
+		if (Double.isNaN(value)) {
+			if (debug)
+				System.out.println("NaN for " + names[index]);
+			corrupted[index] = true;
+		}
+		// if(value < 0){
+		// if(debug)
+		// System.out.println("Negative value for "+names[index]);
+		// }
+
+		values[index].add(value);
+		sumValues[index] += value;
+		if (value < minValue[index])
+			minValue[index] = value;
+		if (value > maxValue[index])
+			maxValue[index] = value;
+	}
+
+	protected void addValue(String name, double value) {
+		if (map.containsKey(name)) {
+			addValue(map.get(name), value);
+		} else {
+			System.out.println(name + " is not a valid measure key, no value added");
+		}
+	}
+
+	// add an empty entry e.g. if evaluation crashed internally
+	public void addEmptyValue(int index) {
+		values[index].add(Double.NaN);
+		corrupted[index] = true;
+	}
+
+	public int getNumMeasures() {
+		return numMeasures;
+	}
+
+	public String getName(int index) {
+		return names[index];
+	}
+
+	public double getMaxValue(int index) {
+		return maxValue[index];
+	}
+
+	public double getMinValue(int index) {
+		return minValue[index];
+	}
+
+	public double getLastValue(int index) {
+		if (values[index].size() < 1)
+			return Double.NaN;
+		return values[index].get(values[index].size() - 1);
+	}
+
+	public double getMean(int index) {
+		if (corrupted[index] || values[index].size() < 1)
+			return Double.NaN;
+
+		return sumValues[index] / values[index].size();
+	}
+
+	private void updateSortedValues(int index) {
+		// naive implementation of insertion sort
+		for (int i = sortedValues[index].size(); i < values[index].size(); i++) {
+			double v = values[index].get(i);
+			int insertIndex = 0;
+			while (!sortedValues[index].isEmpty() && insertIndex < sortedValues[index].size()
+					&& v > sortedValues[index].get(insertIndex))
+				insertIndex++;
+			sortedValues[index].add(insertIndex, v);
+		}
 //         for (int i = 0; i < sortedValues[index].size(); i++) {
 //             System.out.print(sortedValues[index].get(i)+" ");
 //         }
 //         System.out.println();
-     }
-
-     public void clean(int index){
-         sortedValues[index].clear();
-     }
-
-     public double getMedian(int index){
-         updateSortedValues(index);
-         int size = sortedValues[index].size();
-
-         if(size > 0){
-             if(size%2 == 1)
-                 return sortedValues[index].get((int)(size/2));
-             else
-                 return (sortedValues[index].get((size-1)/2)+sortedValues[index].get((size-1)/2+1))/2.0;
-         }
-         return Double.NaN;
-    }
-
-     public double getLowerQuartile(int index){
-         updateSortedValues(index);
-         int size = sortedValues[index].size();
-         if(size > 11){
-             return sortedValues[index].get(Math.round(size*0.25f));
-         }
-         return Double.NaN;
-     }
-
-     public double getUpperQuartile(int index){
-         updateSortedValues(index);
-         int size = sortedValues[index].size();
-         if(size > 11){
-             return sortedValues[index].get(Math.round(size*0.75f-1));
-         }
-         return Double.NaN;
-     }
-
-
-     public int getNumberOfValues(int index){
-         return values[index].size();
-     }
-
-     public double getValue(int index, int i){
-         if(i>=values[index].size()) return Double.NaN;
-         return values[index].get(i);
-     }
-
-     public ArrayList<Double> getAllValues(int index){
-         return values[index];
-     }
-
-     public void setEnabled(int index, boolean value){
-         enabled[index] = value;
-     }
-
-     public boolean isEnabled(int index){
-         return enabled[index];
-     }
-
-     public double getMeanRunningTime(){
-         if(values[0].size()!=0)
-            return (time/10e5/values[0].size());
-         else
-             return 0;
-     }
-
-     protected boolean[] getDefaultEnabled(){
-         boolean[] defaults = new boolean[numMeasures];
-         for (int i = 0; i < defaults.length; i++) {
-             defaults[i] = true;
-         }
-         return defaults;
-     }
-
-     protected abstract void evaluateClustering(Clustering clustering, Clustering trueClustering, ArrayList<DataPoint> points) throws Exception;
-
-     /*
-      * Evaluate Clustering
-      *
-      * return Time in milliseconds
-      */
-     public double evaluateClusteringPerformance(Clustering clustering, Clustering trueClustering, ArrayList<DataPoint> points) throws Exception{
-        long start = System.nanoTime();
-        evaluateClustering(clustering, trueClustering, points);
-        long duration = System.nanoTime()-start;
-        time+=duration;
-        duration/=10e5;
-        return duration;
-     }
-
-     public void getDescription(StringBuilder sb, int indent) {
-
-    }
-
-     public void addEventType(String type){
-    	 events.add(type);
-     }
-     public String getEventType(int index){
-    	 if(index < events.size())
-    		 return events.get(index);
-    	 else
-    		 return null;
-     }
+	}
+
+	public void clean(int index) {
+		sortedValues[index].clear();
+	}
+
+	public double getMedian(int index) {
+		updateSortedValues(index);
+		int size = sortedValues[index].size();
+
+		if (size > 0) {
+			if (size % 2 == 1)
+				return sortedValues[index].get(size / 2);
+			else
+				return (sortedValues[index].get((size - 1) / 2) + sortedValues[index].get((size - 1) / 2 + 1)) / 2.0;
+		}
+		return Double.NaN;
+	}
+
+	public double getLowerQuartile(int index) {
+		updateSortedValues(index);
+		int size = sortedValues[index].size();
+		if (size > 11) {
+			return sortedValues[index].get(Math.round(size * 0.25f));
+		}
+		return Double.NaN;
+	}
+
+	public double getUpperQuartile(int index) {
+		updateSortedValues(index);
+		int size = sortedValues[index].size();
+		if (size > 11) {
+			return sortedValues[index].get(Math.round(size * 0.75f - 1));
+		}
+		return Double.NaN;
+	}
+
+	public int getNumberOfValues(int index) {
+		return values[index].size();
+	}
+
+	public double getValue(int index, int i) {
+		if (i >= values[index].size())
+			return Double.NaN;
+		return values[index].get(i);
+	}
+
+	public ArrayList<Double> getAllValues(int index) {
+		return values[index];
+	}
+
+	public void setEnabled(int index, boolean value) {
+		enabled[index] = value;
+	}
+
+	public boolean isEnabled(int index) {
+		return enabled[index];
+	}
+
+	public double getMeanRunningTime() {
+		if (values[0].size() != 0)
+			return (time / 10e5 / values[0].size());
+		else
+			return 0;
+	}
+
+	protected boolean[] getDefaultEnabled() {
+		boolean[] defaults = new boolean[numMeasures];
+		for (int i = 0; i < defaults.length; i++) {
+			defaults[i] = true;
+		}
+		return defaults;
+	}
+
+	protected abstract void evaluateClustering(Clustering clustering, Clustering trueClustering,
+			ArrayList<DataPoint> points) throws Exception;
+
+	/*
+	 * Evaluate Clustering
+	 *
+	 * return Time in milliseconds
+	 */
+	public double evaluateClusteringPerformance(Clustering clustering, Clustering trueClustering,
+			ArrayList<DataPoint> points) throws Exception {
+		long start = System.nanoTime();
+		evaluateClustering(clustering, trueClustering, points);
+		long duration = System.nanoTime() - start;
+		time += duration;
+		duration /= 10e5;
+		return duration;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+
+	}
+
+	public void addEventType(String type) {
+		events.add(type);
+	}
+
+	public String getEventType(int index) {
+		if (index < events.size())
+			return events.get(index);
+		else
+			return null;
+	}
 }
-
diff --git a/moa/src/main/java/moa/evaluation/MembershipMatrix.java b/moa/src/main/java/moa/evaluation/MembershipMatrix.java
index d29777667..faa3dac1d 100644
--- a/moa/src/main/java/moa/evaluation/MembershipMatrix.java
+++ b/moa/src/main/java/moa/evaluation/MembershipMatrix.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.evaluation;
@@ -26,128 +26,124 @@
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
 
-
 public class MembershipMatrix {
 
-    HashMap<Integer, Integer>  classmap;
-    int cluster_class_weights[][];
-    int cluster_sums[];
-    int class_sums[];
-    int total_entries;
-    int class_distribution[];
-    int total_class_entries;
-    int initalBuildTimestamp = -1;
-
-    public MembershipMatrix(Clustering foundClustering, ArrayList<DataPoint> points) {
-        classmap = Clustering.classValues(points);
+	HashMap<Integer, Integer> classmap;
+	int cluster_class_weights[][];
+	int cluster_sums[];
+	int class_sums[];
+	int total_entries;
+	int class_distribution[];
+	int total_class_entries;
+	int initalBuildTimestamp = -1;
+
+	public MembershipMatrix(Clustering foundClustering, ArrayList<DataPoint> points) {
+		classmap = Clustering.classValues(points);
 //        int lastID  = classmap.size()-1;
 //        classmap.put(-1, lastID);
-        int numClasses = classmap.size();
-        int numCluster = foundClustering.size()+1;
-
-        cluster_class_weights = new int[numCluster][numClasses];
-        class_distribution = new int[numClasses];
-        cluster_sums = new int[numCluster];
-        class_sums = new int[numClasses];
-        total_entries = 0;
-        total_class_entries = points.size();
-        for (int p = 0; p < points.size(); p++) {
-            int worklabel = classmap.get((int)points.get(p).classValue());
-            //real class distribution
-            class_distribution[worklabel]++;
-            boolean covered = false;
-            for (int c = 0; c < numCluster-1; c++) {
-                double prob = foundClustering.get(c).getInclusionProbability(points.get(p));
-                if(prob >= 1){
-                    cluster_class_weights[c][worklabel]++;
-                    class_sums[worklabel]++;
-                    cluster_sums[c]++;
-                    total_entries++;
-                    covered = true;
-                }
-            }
-            if(!covered){
-                cluster_class_weights[numCluster-1][worklabel]++;
-                class_sums[worklabel]++;
-                cluster_sums[numCluster-1]++;
-                total_entries++;
-            }
-
-        }
-        
-        initalBuildTimestamp = points.get(0).getTimestamp();
-    }
-
-    public int getClusterClassWeight(int i, int j){
-        return cluster_class_weights[i][j];
-    }
-
-    public int getClusterSum(int i){
-        return cluster_sums[i];
-    }
-
-    public int getClassSum(int j){
-        return class_sums[j];
-    }
-
-    public int getClassDistribution(int j){
-        return class_distribution[j];
-    }
-
-    public int getClusterClassWeightByLabel(int cluster, int classLabel){
-        return cluster_class_weights[cluster][classmap.get(classLabel)];
-    }
-
-    public int getClassSumByLabel(int classLabel){
-        return class_sums[classmap.get(classLabel)];
-    }
-
-    public int getClassDistributionByLabel(int classLabel){
-        return class_distribution[classmap.get(classLabel)];
-    }
-
-    public int getTotalEntries(){
-        return total_entries;
-    }
-
-    public int getNumClasses(){
-        return classmap.size();
-    }
-
-    public boolean hasNoiseClass(){
-        return classmap.containsKey(-1);
-    }
-
-    @Override
-    public String toString() {
-        StringBuffer sb = new StringBuffer();
-        sb.append("Membership Matrix\n");
-        for (int i = 0; i < cluster_class_weights.length; i++) {
-            for (int j = 0; j < cluster_class_weights[i].length; j++) {
-                sb.append(cluster_class_weights[i][j]+"\t ");
-            }
-            sb.append("| "+cluster_sums[i]+"\n");
-        }
-        //sb.append("-----------\n");
-        for (int i = 0; i < class_sums.length; i++) {
-            sb.append(class_sums[i]+"\t ");
-        }
-        sb.append("| "+total_entries+"\n");
-
-
-        sb.append("Real class distribution \n");
-        for (int i = 0; i < class_distribution.length; i++) {
-            sb.append(class_distribution[i]+"\t ");
-        }
-        sb.append("| "+total_class_entries+"\n");
-
-        return sb.toString();
-    }
-
-
-    public int getInitalBuildTimestamp(){
-    	return initalBuildTimestamp;
-    }
-    
+		int numClasses = classmap.size();
+		int numCluster = foundClustering.size() + 1;
+
+		cluster_class_weights = new int[numCluster][numClasses];
+		class_distribution = new int[numClasses];
+		cluster_sums = new int[numCluster];
+		class_sums = new int[numClasses];
+		total_entries = 0;
+		total_class_entries = points.size();
+		for (int p = 0; p < points.size(); p++) {
+			int worklabel = classmap.get((int) points.get(p).classValue());
+			// real class distribution
+			class_distribution[worklabel]++;
+			boolean covered = false;
+			for (int c = 0; c < numCluster - 1; c++) {
+				double prob = foundClustering.get(c).getInclusionProbability(points.get(p));
+				if (prob >= 1) {
+					cluster_class_weights[c][worklabel]++;
+					class_sums[worklabel]++;
+					cluster_sums[c]++;
+					total_entries++;
+					covered = true;
+				}
+			}
+			if (!covered) {
+				cluster_class_weights[numCluster - 1][worklabel]++;
+				class_sums[worklabel]++;
+				cluster_sums[numCluster - 1]++;
+				total_entries++;
+			}
+
+		}
+
+		initalBuildTimestamp = points.get(0).getTimestamp();
+	}
+
+	public int getClusterClassWeight(int i, int j) {
+		return cluster_class_weights[i][j];
+	}
+
+	public int getClusterSum(int i) {
+		return cluster_sums[i];
+	}
+
+	public int getClassSum(int j) {
+		return class_sums[j];
+	}
+
+	public int getClassDistribution(int j) {
+		return class_distribution[j];
+	}
+
+	public int getClusterClassWeightByLabel(int cluster, int classLabel) {
+		return cluster_class_weights[cluster][classmap.get(classLabel)];
+	}
+
+	public int getClassSumByLabel(int classLabel) {
+		return class_sums[classmap.get(classLabel)];
+	}
+
+	public int getClassDistributionByLabel(int classLabel) {
+		return class_distribution[classmap.get(classLabel)];
+	}
+
+	public int getTotalEntries() {
+		return total_entries;
+	}
+
+	public int getNumClasses() {
+		return classmap.size();
+	}
+
+	public boolean hasNoiseClass() {
+		return classmap.containsKey(-1);
+	}
+
+	@Override
+	public String toString() {
+		StringBuffer sb = new StringBuffer();
+		sb.append("Membership Matrix\n");
+		for (int i = 0; i < cluster_class_weights.length; i++) {
+			for (int j = 0; j < cluster_class_weights[i].length; j++) {
+				sb.append(cluster_class_weights[i][j] + "\t ");
+			}
+			sb.append("| " + cluster_sums[i] + "\n");
+		}
+		// sb.append("-----------\n");
+		for (int i = 0; i < class_sums.length; i++) {
+			sb.append(class_sums[i] + "\t ");
+		}
+		sb.append("| " + total_entries + "\n");
+
+		sb.append("Real class distribution \n");
+		for (int i = 0; i < class_distribution.length; i++) {
+			sb.append(class_distribution[i] + "\t ");
+		}
+		sb.append("| " + total_class_entries + "\n");
+
+		return sb.toString();
+	}
+
+	public int getInitalBuildTimestamp() {
+		return initalBuildTimestamp;
+	}
 
 }
diff --git a/moa/src/main/java/moa/evaluation/MultiLabelWindowClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/MultiLabelWindowClassificationPerformanceEvaluator.java
deleted file mode 100644
index 0f141b6f4..000000000
--- a/moa/src/main/java/moa/evaluation/MultiLabelWindowClassificationPerformanceEvaluator.java
+++ /dev/null
@@ -1,150 +0,0 @@
-/*
- *    ClassificationPerformanceEvaluator.java
- *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
- *    @author Jesse Read (jesse@tsc.uc3m.es)
- * 
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.evaluation;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.core.Example;
-import moa.core.Measurement;
-
-/**
- * Multilabel Window Classification Performance Evaluator.
- * 
- * @author Jesse Read (jesse@tsc.uc3m.es)
- * @version $Revision: 1 $
- */
-public class MultiLabelWindowClassificationPerformanceEvaluator extends WindowClassificationPerformanceEvaluator implements MultiLabelClassificationPerformanceEvaluator {
-
-	/** running sum of accuracy */
-    double sumAccuracy = 0.0;
-	double sumHamming = 0.0;
-
-	/** running number of examples */
-    int sumExamples = 0;
-
-	/** preset threshold */
-    private double t = 0.5;
-
-    @Override
-    public void reset() {
-		sumAccuracy = 0.0;
-		sumHamming = 0.0;
-		sumExamples = 0;
-    }
-
-    @Override
-    public void reset(int L) {
-        numClasses = L;
-		reset();
-    }
-
-    /**
-     * Add a Result. NOTE: In theory, the size of y[] could change, although we
-     * do not take into account this possibility *yet*. (for this, we would have
-     * to use y[] differently, another format for y[] e.g. HashMap, or store
-     * more info in x)
-     */
-    @Override
-    public void addResult(Example<Instance> example, double[] p_y) {
-
-		//int L = example.numOutputAttributes();      // <-- doesn't work!
-		int L = p_y.length;
-
-        Instance x = example.getData();
-        if (p_y.length < 2) {
-            System.err.println("FATAL ERROR: Not enough labels, we've lost track of the number of labels.");
-            System.exit(1);
-        }
-
-		//System.out.println("------- new result -------------");
-		//System.out.println("x = "+x);
-		//System.out.println("p(y) = "+Arrays.toString(p_y));
-
-		// Threshold to binary output (optional)
-		int y[] = new int[L];
-		for(int j = 0; j < L; j++) {
-			y[j] = (p_y[j] > t) ? 1 : 0;
-		}
-		//System.out.println("y =    "+Arrays.toString(y));
-		
-		sumExamples++;
-		int correct = 0;
-		for(int j = 0; j < y.length; j++) {
-			//int y_true = //]example.valueOutputAttribute(j);  // <-- doesn't work!
-			int y_true = (int)x.value(j); 
-			//int y_pred = (p_y[j] > t) ? 1 : 0;
-			if (y_true == y[j])
-				correct++;
-		}
-
-		// Hamming Score
-		sumHamming+=(correct/(double)L);
-
-		// Exact Match
-		if (correct == L)
-			sumAccuracy++;
-    }
-
-    
-    @Override
-    public void addResult(Example<Instance> example, Prediction prediction) {
-
-        StructuredInstance inst = (StructuredInstance) example.getData();
-        if (inst.weight() > 0.0) {
-            int numberOutputs = inst.numOutputAttributes();
-			if (numberOutputs <= 1) {
-				System.err.println("FATAL ERROR: This is not a multi-label dataset!");
-				System.exit(1);
-			}
-			if (prediction.numOutputAttributes()==0) {
-				System.err.println("FATAL ERROR: This is not a multi-label prediction!");
-				System.exit(1);
-			}
-            double[] result = new double[numberOutputs];
-            for (int i = 0; i< prediction.size();i++){
-				result[i] = prediction.getVote(i,1); 
-            }
-            addResult(example, result);
-        }
-            //System.out.println(inst.classValue()+", "+prediction);
-    }
-
-    @Override
-    public Measurement[] getPerformanceMeasurements() {
-
-        // gather measurements
-        Measurement m[] = new Measurement[]{
-            new Measurement("Exact Match", sumAccuracy/sumExamples),
-			new Measurement("Hamming Score", sumHamming/sumExamples),
-        };
-
-        // reset
-        reset();
-
-        return m;
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        sb.append("Multi-label Window Classification Performance Evaluator");
-    }
-}
diff --git a/moa/src/main/java/moa/evaluation/OutlierPerformance.java b/moa/src/main/java/moa/evaluation/OutlierPerformance.java
index 298472f54..2b16101ef 100644
--- a/moa/src/main/java/moa/evaluation/OutlierPerformance.java
+++ b/moa/src/main/java/moa/evaluation/OutlierPerformance.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.evaluation;
@@ -25,26 +25,26 @@
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
 
+public class OutlierPerformance extends MeasureCollection {
+	@Override
+	protected String[] getNames() {
+		String[] names = { "time per object", "needed?###" };
+		return names;
+	}
 
-public class OutlierPerformance extends MeasureCollection{
-    @Override
-    protected String[] getNames() {
-        String[] names = {"time per object","needed?###"};
-        return names;
-    }
+	@Override
+	protected boolean[] getDefaultEnabled() {
+		boolean[] defaults = { false, false };
+		return defaults;
+	}
 
-    @Override
-    protected boolean[] getDefaultEnabled() {
-        boolean [] defaults = {false, false};
-        return defaults;
-    }
+	@Override
+	public void evaluateClustering(Clustering clustering, Clustering trueClustering, ArrayList<DataPoint> points)
+			throws Exception {
+		// nothing to do
+	}
 
-    @Override
-    public void evaluateClustering(Clustering clustering, Clustering trueClustering, ArrayList<DataPoint> points) throws Exception {
-        // nothing to do
-    }
-    
-    public void addTimePerObject(double time) {
-        addValue("time per object", time);
-    }
+	public void addTimePerObject(double time) {
+		addValue("time per object", time);
+	}
 }
diff --git a/moa/src/main/java/moa/evaluation/RegressionAccuracy.java b/moa/src/main/java/moa/evaluation/RegressionAccuracy.java
index ebdce7bf7..155ed61c0 100644
--- a/moa/src/main/java/moa/evaluation/RegressionAccuracy.java
+++ b/moa/src/main/java/moa/evaluation/RegressionAccuracy.java
@@ -15,22 +15,22 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.evaluation;
 
 public class RegressionAccuracy extends Accuracy {
 
-    @Override
-    public String[] getNames() {
-        String[] names = {"mean abs. error", "root mean sq. er.", "", "Ram-Hours", "Time", "Memory"};
-        return names;
-    }
+	@Override
+	public String[] getNames() {
+		String[] names = { "mean abs. error", "root mean sq. er.", "", "Ram-Hours", "Time", "Memory" };
+		return names;
+	}
 
-    @Override
-    protected boolean[] getDefaultEnabled() {
-        boolean[] defaults = {true, true, false, true, true, true};
-        return defaults;
-    }
+	@Override
+	protected boolean[] getDefaultEnabled() {
+		boolean[] defaults = { true, true, false, true, true, true };
+		return defaults;
+	}
 
 }
diff --git a/moa/src/main/java/moa/evaluation/SSQ.java b/moa/src/main/java/moa/evaluation/SSQ.java
index 37fab259e..4f1dad8c2 100644
--- a/moa/src/main/java/moa/evaluation/SSQ.java
+++ b/moa/src/main/java/moa/evaluation/SSQ.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.evaluation;
@@ -25,49 +25,47 @@
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
 
-public class SSQ extends MeasureCollection{
+public class SSQ extends MeasureCollection {
 
-    public SSQ() {
-        super();
-    }
+	public SSQ() {
+		super();
+	}
 
-    @Override
-    public String[] getNames() {
-        String[] names = {"SSQ"};
-        return names;
-    }
-    
-  @Override
-  protected boolean[] getDefaultEnabled() {
-      boolean [] defaults = {false};
-      return defaults;
-  }
-    
-    public void evaluateClustering(Clustering clustering, Clustering trueClsutering, ArrayList<DataPoint> points) {
-        double sum = 0.0;
-        for (int p = 0; p < points.size(); p++) {
-            //don't include noise
-            if(points.get(p).classValue()==-1) continue;
+	@Override
+	public String[] getNames() {
+		String[] names = { "SSQ" };
+		return names;
+	}
 
-            double minDistance = Double.MAX_VALUE;
-            for (int c = 0; c < clustering.size(); c++) {
-                double distance = 0.0;
-                double[] center = clustering.get(c).getCenter();
-                for (int i = 0; i < center.length; i++) {
-                    double d = points.get(p).value(i) - center[i];
-                    distance += d * d;
-                }
-                minDistance = Math.min(distance, minDistance);
-            }
-            
-            sum+=minDistance;
-        }
-        
-        addValue(0,sum);
-    }
+	@Override
+	protected boolean[] getDefaultEnabled() {
+		boolean[] defaults = { false };
+		return defaults;
+	}
 
+	@Override
+	public void evaluateClustering(Clustering clustering, Clustering trueClsutering, ArrayList<DataPoint> points) {
+		double sum = 0.0;
+		for (int p = 0; p < points.size(); p++) {
+			// don't include noise
+			if (points.get(p).classValue() == -1)
+				continue;
 
+			double minDistance = Double.MAX_VALUE;
+			for (int c = 0; c < clustering.size(); c++) {
+				double distance = 0.0;
+				double[] center = clustering.get(c).getCenter();
+				for (int i = 0; i < center.length; i++) {
+					double d = points.get(p).value(i) - center[i];
+					distance += d * d;
+				}
+				minDistance = Math.min(distance, minDistance);
+			}
 
+			sum += minDistance;
+		}
 
+		addValue(0, sum);
+	}
 
 }
diff --git a/moa/src/main/java/moa/evaluation/Separation.java b/moa/src/main/java/moa/evaluation/Separation.java
index fd5c9fbf8..38e4ae5dc 100644
--- a/moa/src/main/java/moa/evaluation/Separation.java
+++ b/moa/src/main/java/moa/evaluation/Separation.java
@@ -12,9 +12,9 @@
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -33,57 +33,56 @@
 
 public class Separation extends MeasureCollection {
 
-  public Separation() {
-    super();
-  }
+	public Separation() {
+		super();
+	}
 
-  @Override
-  protected String[] getNames() {
-    return new String[] { "BSS", "BSS-GT", "BSS-Ratio" };
-  }
+	@Override
+	protected String[] getNames() {
+		return new String[] { "BSS", "BSS-GT", "BSS-Ratio" };
+	}
 
-  private double getBSS(Clustering clustering, double[] mean) {
-    double bss = 0.0;
-    for (int i = 0; i < clustering.size(); i++) {
-      double weight = clustering.get(i).getWeight();
-      double sum = 0.0;
-      for (int j = 0; j < mean.length; j++) {
-        sum += Math.pow((mean[j] - clustering.get(i).getCenter()[j]), 2);
-      }
-      bss += weight * sum;
-    }
+	private double getBSS(Clustering clustering, double[] mean) {
+		double bss = 0.0;
+		for (int i = 0; i < clustering.size(); i++) {
+			double weight = clustering.get(i).getWeight();
+			double sum = 0.0;
+			for (int j = 0; j < mean.length; j++) {
+				sum += Math.pow((mean[j] - clustering.get(i).getCenter()[j]), 2);
+			}
+			bss += weight * sum;
+		}
 
-    return bss;
-  }
+		return bss;
+	}
 
-  @Override
-  protected void evaluateClustering(Clustering clustering,
-      Clustering trueClustering, ArrayList<DataPoint> points)
-      throws Exception {
-    double BSS_GT = 1.0;
-    double BSS;
-    int dimension = points.get(0).numAttributes() - 1;
-    SphereCluster sc = new SphereCluster(points, dimension);
+	@Override
+	protected void evaluateClustering(Clustering clustering, Clustering trueClustering, ArrayList<DataPoint> points)
+			throws Exception {
+		double BSS_GT = 1.0;
+		double BSS;
+		int dimension = points.get(0).numAttributes() - 1;
+		SphereCluster sc = new SphereCluster(points, dimension);
 
-    // DO INTERNAL EVALUATION
-    // clustering.getClustering().get(0).getCenter();
+		// DO INTERNAL EVALUATION
+		// clustering.getClustering().get(0).getCenter();
 
-    BSS = getBSS(clustering, sc.getCenter());
+		BSS = getBSS(clustering, sc.getCenter());
 
-    if (trueClustering != null) {
-      String s = "";
-      List<Instance> listInstances = new ArrayList<Instance>();
-      for (Cluster c : trueClustering.getClustering()) {
-        DenseInstance inst = new DenseInstance(c.getWeight(), c.getCenter());
-        listInstances.add(inst);
-        s += " " + c.getWeight();
-      }
-      SphereCluster gt = new SphereCluster(listInstances, dimension);
-      BSS_GT = getBSS(trueClustering, gt.getCenter());
-    }
+		if (trueClustering != null) {
+			String s = "";
+			List<Instance> listInstances = new ArrayList<>();
+			for (Cluster c : trueClustering.getClustering()) {
+				DenseInstance inst = new DenseInstance(c.getWeight(), c.getCenter());
+				listInstances.add(inst);
+				s += " " + c.getWeight();
+			}
+			SphereCluster gt = new SphereCluster(listInstances, dimension);
+			BSS_GT = getBSS(trueClustering, gt.getCenter());
+		}
 
-    addValue("BSS", BSS);
-    addValue("BSS-GT", BSS_GT);
-    addValue("BSS-Ratio", BSS / BSS_GT);
-  }
+		addValue("BSS", BSS);
+		addValue("BSS-GT", BSS_GT);
+		addValue("BSS-Ratio", BSS / BSS_GT);
+	}
 }
diff --git a/moa/src/main/java/moa/evaluation/SilhouetteCoefficient.java b/moa/src/main/java/moa/evaluation/SilhouetteCoefficient.java
index c58a7a8da..7fe14abcb 100644
--- a/moa/src/main/java/moa/evaluation/SilhouetteCoefficient.java
+++ b/moa/src/main/java/moa/evaluation/SilhouetteCoefficient.java
@@ -14,11 +14,11 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.evaluation; 
+package moa.evaluation;
 
 import java.util.ArrayList;
 
@@ -26,112 +26,114 @@
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
 
-public class SilhouetteCoefficient extends MeasureCollection{
-    private double pointInclusionProbThreshold = 0.8;
-
-    public SilhouetteCoefficient() {
-        super();
-    }
-
-    @Override
-    protected boolean[] getDefaultEnabled() {
-        boolean [] defaults = {false};
-        return defaults;
-    }
-
-    @Override
-    public String[] getNames() {
-        String[] names = {"SilhCoeff"};
-        return names;
-    }
-
-    public void evaluateClustering(Clustering clustering, Clustering trueClustering, ArrayList<DataPoint> points) {
-        int numFCluster = clustering.size();
-
-        double [][] pointInclusionProbFC = new double[points.size()][numFCluster];
-        for (int p = 0; p < points.size(); p++) {
-            DataPoint point = points.get(p);
-            for (int fc = 0; fc < numFCluster; fc++) {
-                Cluster cl = clustering.get(fc);
-                pointInclusionProbFC[p][fc] = cl.getInclusionProbability(point);
-            }
-        }
-
-        double silhCoeff = 0.0;
-        int totalCount = 0;
-        for (int p = 0; p < points.size(); p++) {
-            DataPoint point = points.get(p);
-            ArrayList<Integer> ownClusters = new ArrayList<Integer>();
-            for (int fc = 0; fc < numFCluster; fc++) {
-                if(pointInclusionProbFC[p][fc] > pointInclusionProbThreshold){
-                    ownClusters.add(fc);
-                }
-            }
-
-            if(ownClusters.size() > 0){
-                double[] distanceByClusters = new double[numFCluster];
-                int[] countsByClusters = new int[numFCluster];
-                    //calculate averageDistance of p to all cluster
-                for (int p1 = 0; p1 < points.size(); p1++) {
-                    DataPoint point1 = points.get(p1);
-                    if(p1!= p && point1.classValue() != -1){
-                        for (int fc = 0; fc < numFCluster; fc++) {
-                            if(pointInclusionProbFC[p1][fc] > pointInclusionProbThreshold){
-                                double distance = distance(point, point1);
-                                distanceByClusters[fc]+=distance;
-                                countsByClusters[fc]++;
-                            }
-                        }
-                    }
-                }
-
-                //find closest OWN cluster as clusters might overlap
-                double minAvgDistanceOwn = Double.MAX_VALUE;
-                int minOwnIndex = -1;
-                for (int fc : ownClusters) {
-                        double normDist = distanceByClusters[fc]/(double)countsByClusters[fc];
-                        if(normDist < minAvgDistanceOwn){// && pointInclusionProbFC[p][fc] > pointInclusionProbThreshold){
-                            minAvgDistanceOwn = normDist;
-                            minOwnIndex = fc;
-                        }
-                }
-
-
-                //find closest other (or other own) cluster
-                double minAvgDistanceOther = Double.MAX_VALUE;
-                for (int fc = 0; fc < numFCluster; fc++) {
-                    if(fc != minOwnIndex){
-                        double normDist = distanceByClusters[fc]/(double)countsByClusters[fc];
-                        if(normDist < minAvgDistanceOther){
-                            minAvgDistanceOther = normDist;
-                        }
-                    }
-                }
-
-                double silhP = (minAvgDistanceOther-minAvgDistanceOwn)/Math.max(minAvgDistanceOther, minAvgDistanceOwn);
-                point.setMeasureValue("SC - own", minAvgDistanceOwn);
-                point.setMeasureValue("SC - other", minAvgDistanceOther);
-                point.setMeasureValue("SC", silhP);
-
-                silhCoeff+=silhP;
-                totalCount++;
-                //System.out.println(point.getTimestamp()+" Silh "+silhP+" / "+avgDistanceOwn+" "+minAvgDistanceOther+" (C"+minIndex+")");
-            }
-        }
-        if(totalCount>0)
-            silhCoeff/=(double)totalCount;
-        //normalize from -1, 1 to 0,1
-        silhCoeff = (silhCoeff+1)/2.0;
-        addValue(0,silhCoeff);
-    }
-
-    private double distance(DataPoint inst1, DataPoint inst2){
-        double distance = 0.0;
-        int numDims = inst1.numAttributes();
-        for (int i = 0; i < numDims; i++) {
-            double d = inst1.value(i) - inst2.value(i);
-            distance += d * d;
-        }
-        return Math.sqrt(distance);
-    }
+public class SilhouetteCoefficient extends MeasureCollection {
+	private double pointInclusionProbThreshold = 0.8;
+
+	public SilhouetteCoefficient() {
+		super();
+	}
+
+	@Override
+	protected boolean[] getDefaultEnabled() {
+		boolean[] defaults = { false };
+		return defaults;
+	}
+
+	@Override
+	public String[] getNames() {
+		String[] names = { "SilhCoeff" };
+		return names;
+	}
+
+	@Override
+	public void evaluateClustering(Clustering clustering, Clustering trueClustering, ArrayList<DataPoint> points) {
+		int numFCluster = clustering.size();
+
+		double[][] pointInclusionProbFC = new double[points.size()][numFCluster];
+		for (int p = 0; p < points.size(); p++) {
+			DataPoint point = points.get(p);
+			for (int fc = 0; fc < numFCluster; fc++) {
+				Cluster cl = clustering.get(fc);
+				pointInclusionProbFC[p][fc] = cl.getInclusionProbability(point);
+			}
+		}
+
+		double silhCoeff = 0.0;
+		int totalCount = 0;
+		for (int p = 0; p < points.size(); p++) {
+			DataPoint point = points.get(p);
+			ArrayList<Integer> ownClusters = new ArrayList<>();
+			for (int fc = 0; fc < numFCluster; fc++) {
+				if (pointInclusionProbFC[p][fc] > pointInclusionProbThreshold) {
+					ownClusters.add(fc);
+				}
+			}
+
+			if (ownClusters.size() > 0) {
+				double[] distanceByClusters = new double[numFCluster];
+				int[] countsByClusters = new int[numFCluster];
+				// calculate averageDistance of p to all cluster
+				for (int p1 = 0; p1 < points.size(); p1++) {
+					DataPoint point1 = points.get(p1);
+					if (p1 != p && point1.classValue() != -1) {
+						for (int fc = 0; fc < numFCluster; fc++) {
+							if (pointInclusionProbFC[p1][fc] > pointInclusionProbThreshold) {
+								double distance = distance(point, point1);
+								distanceByClusters[fc] += distance;
+								countsByClusters[fc]++;
+							}
+						}
+					}
+				}
+
+				// find closest OWN cluster as clusters might overlap
+				double minAvgDistanceOwn = Double.MAX_VALUE;
+				int minOwnIndex = -1;
+				for (int fc : ownClusters) {
+					double normDist = distanceByClusters[fc] / countsByClusters[fc];
+					if (normDist < minAvgDistanceOwn) {// && pointInclusionProbFC[p][fc] > pointInclusionProbThreshold){
+						minAvgDistanceOwn = normDist;
+						minOwnIndex = fc;
+					}
+				}
+
+				// find closest other (or other own) cluster
+				double minAvgDistanceOther = Double.MAX_VALUE;
+				for (int fc = 0; fc < numFCluster; fc++) {
+					if (fc != minOwnIndex) {
+						double normDist = distanceByClusters[fc] / countsByClusters[fc];
+						if (normDist < minAvgDistanceOther) {
+							minAvgDistanceOther = normDist;
+						}
+					}
+				}
+
+				double silhP = (minAvgDistanceOther - minAvgDistanceOwn)
+						/ Math.max(minAvgDistanceOther, minAvgDistanceOwn);
+				point.setMeasureValue("SC - own", minAvgDistanceOwn);
+				point.setMeasureValue("SC - other", minAvgDistanceOther);
+				point.setMeasureValue("SC", silhP);
+
+				silhCoeff += silhP;
+				totalCount++;
+				// System.out.println(point.getTimestamp()+" Silh "+silhP+" / "+avgDistanceOwn+"
+				// "+minAvgDistanceOther+" (C"+minIndex+")");
+			}
+		}
+		if (totalCount > 0)
+			silhCoeff /= totalCount;
+		// normalize from -1, 1 to 0,1
+		silhCoeff = (silhCoeff + 1) / 2.0;
+		addValue(0, silhCoeff);
+	}
+
+	private double distance(DataPoint inst1, DataPoint inst2) {
+		double distance = 0.0;
+		int numDims = inst1.numAttributes();
+		for (int i = 0; i < numDims; i++) {
+			double d = inst1.value(i) - inst2.value(i);
+			distance += d * d;
+		}
+		return Math.sqrt(distance);
+	}
 }
diff --git a/moa/src/main/java/moa/evaluation/StatisticalCollection.java b/moa/src/main/java/moa/evaluation/StatisticalCollection.java
index 74f9576d1..77aabf266 100644
--- a/moa/src/main/java/moa/evaluation/StatisticalCollection.java
+++ b/moa/src/main/java/moa/evaluation/StatisticalCollection.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.evaluation;
@@ -26,162 +26,162 @@
 import moa.cluster.Clustering;
 import moa.gui.visualization.DataPoint;
 
-
-public class StatisticalCollection extends MeasureCollection{
-    private boolean debug = false;
-
-    @Override
-    protected String[] getNames() {
-        //String[] names = {"van Dongen","Rand statistic", "C Index"};
-        String[] names = {"van Dongen","Rand statistic"};
-        return names;
-    }
-
-    @Override
-    protected boolean[] getDefaultEnabled() {
-        boolean [] defaults = {false, false};
-        return defaults;
-    }
-
-    @Override
-    public void evaluateClustering(Clustering clustering, Clustering trueClustering, ArrayList<DataPoint> points) throws Exception {
-
-
-    	MembershipMatrix mm = new MembershipMatrix(clustering, points);
-        int numClasses = mm.getNumClasses();
-        int numCluster = clustering.size()+1;
-        int n = mm.getTotalEntries();
-
-        double dongenMaxFC = 0;
-        double dongenMaxSumFC = 0;
-        for (int i = 0; i < numCluster; i++){
-                double max = 0;
-                for (int j = 0; j < numClasses; j++) {
-                    if(mm.getClusterClassWeight(i, j)>max) max = mm.getClusterClassWeight(i, j);
-                }
-                dongenMaxFC+=max;
-                if(mm.getClusterSum(i)>dongenMaxSumFC) dongenMaxSumFC = mm.getClusterSum(i);
-        }
-
-        double dongenMaxHC = 0;
-        double dongenMaxSumHC = 0;
-        for (int j = 0; j < numClasses; j++) {
-                double max = 0;
-                for (int i = 0; i < numCluster; i++){
-                    if(mm.getClusterClassWeight(i, j)>max) max = mm.getClusterClassWeight(i, j);
-                }
-                dongenMaxHC+=max;
-                if(mm.getClassSum(j)>dongenMaxSumHC) dongenMaxSumHC = mm.getClassSum(j);
-        }
-
-        double dongen = (dongenMaxFC + dongenMaxHC)/(2*n);
-        //normalized dongen
-        //double dongen = 1-(2*n - dongenMaxFC - dongenMaxHC)/(2*n - dongenMaxSumFC - dongenMaxSumHC);
-        if(debug)
-            System.out.println("Dongen HC:"+dongenMaxHC+" FC:"+dongenMaxFC+" Total:"+dongen+" n "+n);
-
-        addValue("van Dongen", dongen);
-
-
-        //Rand index
-        //http://www.cais.ntu.edu.sg/~qihe/menu4.html
-        double m1 = 0;
-        for (int j = 0; j < numClasses; j++) {
-            double v = mm.getClassSum(j);
-            m1+= v*(v-1)/2.0;
-        }
-        double m2 = 0;
-        for (int i = 0; i < numCluster; i++){
-            double v = mm.getClusterSum(i);
-            m2+= v*(v-1)/2.0;
-        }
-
-        double m = 0;
-        for (int i = 0; i < numCluster; i++){
-            for (int j = 0; j < numClasses; j++) {
-                    double v = mm.getClusterClassWeight(i, j);
-                    m+= v*(v-1)/2.0;
-                }
-        }
-        double M = n*(n-1)/2.0;
-        double rand = (M - m1 - m2 +2*m)/M;
-        //normalized rand
-        //double rand = (m - m1*m2/M)/(m1/2.0 + m2/2.0 - m1*m2/M);
-
-        addValue("Rand statistic", rand);
-
-
-        //addValue("C Index",cindex(clustering, points));
-    }
-
-
-
-    public double cindex(Clustering clustering,  ArrayList<DataPoint> points){
-        int numClusters = clustering.size();
-        double withinClustersDistance = 0;
-        int numDistancesWithin = 0;
-        double numDistances = 0;
-
-        //double[] withinClusters = new double[numClusters];
-        double[] minWithinClusters = new double[numClusters];
-        double[] maxWithinClusters = new double[numClusters];
-        ArrayList<Integer>[] pointsInClusters = new ArrayList[numClusters];
-        for (int c = 0; c < numClusters; c++) {
-            pointsInClusters[c] = new ArrayList<Integer>();
-            minWithinClusters[c] = Double.MAX_VALUE;
-            maxWithinClusters[c] = Double.MIN_VALUE;
-        }
-
-        for (int p = 0; p < points.size(); p++) {
-            for (int c = 0; c < clustering.size(); c++) {
-                if(clustering.get(c).getInclusionProbability(points.get(p)) > 0.8){
-                    pointsInClusters[c].add(p);
-                    numDistances++;
-                }
-            }
-        }
-
-        //calc within cluster distances + min and max values
-        for (int c = 0; c < numClusters; c++) {
-            int numDistancesInC = 0;
-            ArrayList<Integer> pointsInC = pointsInClusters[c];
-            for (int p = 0; p < pointsInC.size(); p++) {
-                DataPoint point = points.get(pointsInC.get(p));
-                for (int p1 = p+1; p1 < pointsInC.size(); p1++) {
-                    numDistancesWithin++;
-                    numDistancesInC++;
-                    DataPoint point1 = points.get(pointsInC.get(p1));
-                    double dist = point.getDistance(point1);
-                    withinClustersDistance+=dist;
-                    if(minWithinClusters[c] > dist) minWithinClusters[c] = dist;
-                    if(maxWithinClusters[c] < dist) maxWithinClusters[c] = dist;
-                }
-            }
-        }
-
-        double minWithin = Double.MAX_VALUE;
-        double maxWithin = Double.MIN_VALUE;
-        for (int c = 0; c < numClusters; c++) {
-            if(minWithinClusters[c] < minWithin)
-               minWithin = minWithinClusters[c];
-            if(maxWithinClusters[c] > maxWithin)
-               maxWithin = maxWithinClusters[c];
-        }
-
-        double cindex = 0;
-        if(numDistancesWithin != 0){
-            double meanWithinClustersDistance = withinClustersDistance/numDistancesWithin;
-            cindex = (meanWithinClustersDistance - minWithin)/(maxWithin-minWithin);
-        }
-
-
-        if(debug){
-            System.out.println("Min:"+Arrays.toString(minWithinClusters));
-            System.out.println("Max:"+Arrays.toString(maxWithinClusters));
-            System.out.println("totalWithin:"+numDistancesWithin);
-        }
-        return cindex;
-    }
-
+public class StatisticalCollection extends MeasureCollection {
+	private boolean debug = false;
+
+	@Override
+	protected String[] getNames() {
+		// String[] names = {"van Dongen","Rand statistic", "C Index"};
+		String[] names = { "van Dongen", "Rand statistic" };
+		return names;
+	}
+
+	@Override
+	protected boolean[] getDefaultEnabled() {
+		boolean[] defaults = { false, false };
+		return defaults;
+	}
+
+	@Override
+	public void evaluateClustering(Clustering clustering, Clustering trueClustering, ArrayList<DataPoint> points)
+			throws Exception {
+
+		MembershipMatrix mm = new MembershipMatrix(clustering, points);
+		int numClasses = mm.getNumClasses();
+		int numCluster = clustering.size() + 1;
+		int n = mm.getTotalEntries();
+
+		double dongenMaxFC = 0;
+		double dongenMaxSumFC = 0;
+		for (int i = 0; i < numCluster; i++) {
+			double max = 0;
+			for (int j = 0; j < numClasses; j++) {
+				if (mm.getClusterClassWeight(i, j) > max)
+					max = mm.getClusterClassWeight(i, j);
+			}
+			dongenMaxFC += max;
+			if (mm.getClusterSum(i) > dongenMaxSumFC)
+				dongenMaxSumFC = mm.getClusterSum(i);
+		}
+
+		double dongenMaxHC = 0;
+		double dongenMaxSumHC = 0;
+		for (int j = 0; j < numClasses; j++) {
+			double max = 0;
+			for (int i = 0; i < numCluster; i++) {
+				if (mm.getClusterClassWeight(i, j) > max)
+					max = mm.getClusterClassWeight(i, j);
+			}
+			dongenMaxHC += max;
+			if (mm.getClassSum(j) > dongenMaxSumHC)
+				dongenMaxSumHC = mm.getClassSum(j);
+		}
+
+		double dongen = (dongenMaxFC + dongenMaxHC) / (2 * n);
+		// normalized dongen
+		// double dongen = 1-(2*n - dongenMaxFC - dongenMaxHC)/(2*n - dongenMaxSumFC -
+		// dongenMaxSumHC);
+		if (debug)
+			System.out.println("Dongen HC:" + dongenMaxHC + " FC:" + dongenMaxFC + " Total:" + dongen + " n " + n);
+
+		addValue("van Dongen", dongen);
+
+		// Rand index
+		// http://www.cais.ntu.edu.sg/~qihe/menu4.html
+		double m1 = 0;
+		for (int j = 0; j < numClasses; j++) {
+			double v = mm.getClassSum(j);
+			m1 += v * (v - 1) / 2.0;
+		}
+		double m2 = 0;
+		for (int i = 0; i < numCluster; i++) {
+			double v = mm.getClusterSum(i);
+			m2 += v * (v - 1) / 2.0;
+		}
+
+		double m = 0;
+		for (int i = 0; i < numCluster; i++) {
+			for (int j = 0; j < numClasses; j++) {
+				double v = mm.getClusterClassWeight(i, j);
+				m += v * (v - 1) / 2.0;
+			}
+		}
+		double M = n * (n - 1) / 2.0;
+		double rand = (M - m1 - m2 + 2 * m) / M;
+		// normalized rand
+		// double rand = (m - m1*m2/M)/(m1/2.0 + m2/2.0 - m1*m2/M);
+
+		addValue("Rand statistic", rand);
+
+		// addValue("C Index",cindex(clustering, points));
+	}
+
+	public double cindex(Clustering clustering, ArrayList<DataPoint> points) {
+		int numClusters = clustering.size();
+		double withinClustersDistance = 0;
+		int numDistancesWithin = 0;
+		double numDistances = 0;
+
+		// double[] withinClusters = new double[numClusters];
+		double[] minWithinClusters = new double[numClusters];
+		double[] maxWithinClusters = new double[numClusters];
+		ArrayList<Integer>[] pointsInClusters = new ArrayList[numClusters];
+		for (int c = 0; c < numClusters; c++) {
+			pointsInClusters[c] = new ArrayList<>();
+			minWithinClusters[c] = Double.MAX_VALUE;
+			maxWithinClusters[c] = Double.MIN_VALUE;
+		}
+
+		for (int p = 0; p < points.size(); p++) {
+			for (int c = 0; c < clustering.size(); c++) {
+				if (clustering.get(c).getInclusionProbability(points.get(p)) > 0.8) {
+					pointsInClusters[c].add(p);
+					numDistances++;
+				}
+			}
+		}
+
+		// calc within cluster distances + min and max values
+		for (int c = 0; c < numClusters; c++) {
+			int numDistancesInC = 0;
+			ArrayList<Integer> pointsInC = pointsInClusters[c];
+			for (int p = 0; p < pointsInC.size(); p++) {
+				DataPoint point = points.get(pointsInC.get(p));
+				for (int p1 = p + 1; p1 < pointsInC.size(); p1++) {
+					numDistancesWithin++;
+					numDistancesInC++;
+					DataPoint point1 = points.get(pointsInC.get(p1));
+					double dist = point.getDistance(point1);
+					withinClustersDistance += dist;
+					if (minWithinClusters[c] > dist)
+						minWithinClusters[c] = dist;
+					if (maxWithinClusters[c] < dist)
+						maxWithinClusters[c] = dist;
+				}
+			}
+		}
+
+		double minWithin = Double.MAX_VALUE;
+		double maxWithin = Double.MIN_VALUE;
+		for (int c = 0; c < numClusters; c++) {
+			if (minWithinClusters[c] < minWithin)
+				minWithin = minWithinClusters[c];
+			if (maxWithinClusters[c] > maxWithin)
+				maxWithin = maxWithinClusters[c];
+		}
+
+		double cindex = 0;
+		if (numDistancesWithin != 0) {
+			double meanWithinClustersDistance = withinClustersDistance / numDistancesWithin;
+			cindex = (meanWithinClustersDistance - minWithin) / (maxWithin - minWithin);
+		}
+
+		if (debug) {
+			System.out.println("Min:" + Arrays.toString(minWithinClusters));
+			System.out.println("Max:" + Arrays.toString(maxWithinClusters));
+			System.out.println("totalWithin:" + numDistancesWithin);
+		}
+		return cindex;
+	}
 
 }
diff --git a/moa/src/main/java/moa/evaluation/WindowClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/WindowClassificationPerformanceEvaluator.java
deleted file mode 100644
index f73d59677..000000000
--- a/moa/src/main/java/moa/evaluation/WindowClassificationPerformanceEvaluator.java
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- *    WindowClassificationPerformanceEvaluator.java
- *    Copyright (C) 2009 University of Waikato, Hamilton, New Zealand
- *    @author Albert Bifet (abifet@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.evaluation;
-
-import moa.capabilities.Capability;
-import moa.capabilities.ImmutableCapabilities;
-
-import com.github.javacliparser.IntOption;
-
-/**
- * Classification evaluator that updates evaluation results using a sliding
- * window.
- *
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @author Jean Paul Barddal (jpbarddal@gmail.com)
- * @version $Revision: 8 $
- *
- *
- */
-public class WindowClassificationPerformanceEvaluator extends BasicClassificationPerformanceEvaluator {
-
-    private static final long serialVersionUID = 1L;
-
-    public IntOption widthOption = new IntOption("width",
-            'w', "Size of Window", 1000);
-
-    @Override
-    protected Estimator newEstimator() {
-        return new WindowEstimator(this.widthOption.getValue());
-    }
-
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == WindowClassificationPerformanceEvaluator.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
-
-    public class WindowEstimator implements Estimator {
-
-        protected double[] window;
-
-        protected int posWindow;
-
-        protected int lenWindow;
-
-        protected int SizeWindow;
-
-        protected double sum;
-
-        protected double qtyNaNs;
-
-        public WindowEstimator(int sizeWindow) {
-            window = new double[sizeWindow];
-            SizeWindow = sizeWindow;
-            posWindow = 0;
-            lenWindow = 0;
-        }
-
-        public void add(double value) {
-            double forget = window[posWindow];
-            if(!Double.isNaN(forget)){
-                sum -= forget;
-            }else qtyNaNs--;
-            if(!Double.isNaN(value)) {
-            sum += value;
-            }else qtyNaNs++;
-            window[posWindow] = value;
-            posWindow++;
-            if (posWindow == SizeWindow) {
-                posWindow = 0;
-            }
-            if (lenWindow < SizeWindow) {
-                lenWindow++;
-            }
-        }
-
-        public double estimation(){
-            return sum / (lenWindow - qtyNaNs);
-        }
-
-    }
-
-}
diff --git a/moa/src/main/java/moa/evaluation/WindowMultiTargetRegressionPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/WindowMultiTargetRegressionPerformanceEvaluator.java
deleted file mode 100644
index 823cb41da..000000000
--- a/moa/src/main/java/moa/evaluation/WindowMultiTargetRegressionPerformanceEvaluator.java
+++ /dev/null
@@ -1,175 +0,0 @@
-/*
- *    WindowRegressionPerformanceEvaluator.java
- *    Copyright (C) 2011 University of Waikato, Hamilton, New Zealand
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.evaluation;
-
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.core.Example;
-import moa.core.Measurement;
-import moa.core.ObjectRepository;
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
-/**
- * Multi-target regression evaluator that updates evaluation results using a sliding window.
- *
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @version $Revision: 7 $
- */
-public class WindowMultiTargetRegressionPerformanceEvaluator extends AbstractOptionHandler
-implements MultiTargetRegressionPerformanceEvaluator {
-
-    private static final long serialVersionUID = 1L;
-
-    public IntOption widthOption = new IntOption("width",
-            'w', "Size of Window", 1000);
-
-    protected double TotalweightObserved = 0;
-
-    protected Estimator weightObserved;
-
-    protected Estimator squareError;
-
-    protected Estimator averageError;
-
-    protected int numClasses;
-    
-    protected int numberOutputs;
-
-    public class Estimator {
-
-        protected double[] window;
-
-        protected int posWindow;
-
-        protected int lenWindow;
-
-        protected int SizeWindow;
-
-        protected double sum;
-
-        public Estimator(int sizeWindow) {
-            window = new double[sizeWindow];
-            SizeWindow = sizeWindow;
-            posWindow = 0;
-        }
-
-        public void add(double value) {
-            sum -= window[posWindow];
-            sum += value;
-            window[posWindow] = value;
-            posWindow++;
-            if (posWindow == SizeWindow) {
-                posWindow = 0;
-            }
-        }
-
-        public double total() {
-            return sum;
-        }
-    }
-
-    /*   public void setWindowWidth(int w) {
-    this.width = w;
-    reset();
-    }*/
-    @Override
-    public void reset() {
-        reset(this.numClasses);
-    }
-
-    public void reset(int numClasses) {
-        this.numClasses = numClasses;
-        this.weightObserved = new Estimator(this.widthOption.getValue());
-        this.squareError = new Estimator(this.widthOption.getValue());
-        this.averageError = new Estimator(this.widthOption.getValue());
-        this.TotalweightObserved = 0;
-    }
-
-    @Override
-    public void addResult(Example<Instance> example, double[] prediction) {
-    }
-
-    @Override
-    public Measurement[] getPerformanceMeasurements() {
-        return new Measurement[]{
-                    new Measurement("classified instances",
-                    getTotalWeightObserved()),
-                    new Measurement("mean absolute error",
-                    getMeanError()),
-                    new Measurement("root mean squared error",
-                    getSquareError())};
-    }
-
-    public double getTotalWeightObserved() {
-        return this.weightObserved.total();
-    }
-
-    public double getMeanError() {
-        return this.weightObserved.total() > 0.0 ? this.averageError.total()
-                / (this.weightObserved.total()*this.numberOutputs) : 0.0;
-    }
-
-    public double getSquareError() {
-        return Math.sqrt(this.weightObserved.total() > 0.0 ? this.squareError.total()
-                / (this.weightObserved.total()*this.numberOutputs) : 0.0);
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        Measurement.getMeasurementsDescription(getPerformanceMeasurements(),
-                sb, indent);
-    }
-
-    @Override
-    public void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-    }
-    
-
-	@Override
-	public void addResult(Example<Instance> testInst, Prediction prediction) {
-		StructuredInstance inst=(StructuredInstance) testInst.getData();
-       double weight = inst.weight();
-        if (numberOutputs == 0) {
-        	numberOutputs = inst.numOutputAttributes();
-        }
-        if (weight > 0.0) {
-            if (TotalweightObserved == 0) {
-                reset(inst.dataset().numClasses());
-            }
-            this.TotalweightObserved += weight;
-            this.weightObserved.add(weight);
-
-            if (prediction!=null) {
-            	for (int i = 0; i< numberOutputs;i++){
-	            	double error=(inst.valueOutputAttribute(i) - prediction.getVote(i, 0));
-	                this.squareError.add( error*error);
-	                this.averageError.add(Math.abs(error));
-            	}
-            }
-            //System.out.println(inst.classValue()+", "+prediction[0]);
-        }
-		
-	}
-}
diff --git a/moa/src/main/java/moa/evaluation/WindowMultiTargetRegressionPerformanceRelativeMeasuresEvaluator.java b/moa/src/main/java/moa/evaluation/WindowMultiTargetRegressionPerformanceRelativeMeasuresEvaluator.java
deleted file mode 100644
index 4f7f4a56d..000000000
--- a/moa/src/main/java/moa/evaluation/WindowMultiTargetRegressionPerformanceRelativeMeasuresEvaluator.java
+++ /dev/null
@@ -1,213 +0,0 @@
-/*
- *    WindowRegressionPerformanceEvaluator.java
- *    Copyright (C) 2011 University of Waikato, Hamilton, New Zealand
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.evaluation;
-
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.core.Example;
-import moa.core.Measurement;
-import moa.core.ObjectRepository;
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
-/**
- * Multi-target regression evaluator that updates evaluation results using a sliding window.
- *
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @version $Revision: 7 $
- */
-public class WindowMultiTargetRegressionPerformanceRelativeMeasuresEvaluator extends AbstractOptionHandler
-implements MultiTargetRegressionPerformanceEvaluator{
-
-	private static final long serialVersionUID = 1L;
-
-	public IntOption widthOption = new IntOption("width",
-			'w', "Size of Window", 1000);
-
-	protected double TotalweightObserved = 0;
-
-	protected Estimator weightObserved;
-
-	protected Estimator [] squareError;
-
-	protected Estimator [] averageError;
-
-	protected Estimator [] averageErrorToTargetMean;
-
-	protected Estimator [] squareErrorToTargetMean;
-
-	protected Estimator [] sumY;
-
-	protected int numClasses;
-
-	protected int numberOutputs;
-
-	public class Estimator {
-
-		protected double[] window;
-
-		protected int posWindow;
-
-		protected int lenWindow;
-
-		protected int SizeWindow;
-
-		protected double sum;
-
-		public Estimator(int sizeWindow) {
-			window = new double[sizeWindow];
-			SizeWindow = sizeWindow;
-			posWindow = 0;
-		}
-
-		public void add(double value) {
-			sum -= window[posWindow];
-			sum += value;
-			window[posWindow] = value;
-			posWindow++;
-			if (posWindow == SizeWindow) {
-				posWindow = 0;
-			}
-		}
-
-		public double total() {
-			return sum;
-		}
-	}
-
-	/*   public void setWindowWidth(int w) {
-    this.width = w;
-    reset();
-    }*/
-    @Override
-    public void reset() {
-    	reset(this.numClasses);
-    }
-
-    public void reset(int numClasses) {
-    	this.numClasses = numClasses;
-    	this.weightObserved = new Estimator(this.widthOption.getValue());
-    	this.TotalweightObserved = 0;
-    }
-
-    @Override
-    public void addResult(Example<Instance> example, double[] prediction) {
-    }
-
-    @Override
-    public Measurement[] getPerformanceMeasurements() {
-    	return new Measurement[]{
-    			new Measurement("classified instances",
-    					getTotalWeightObserved()),
-    					new Measurement("relative mean absolute error",
-    							getMeanError()),
-    							new Measurement("relative root mean squared error",
-    									getSquareError())};
-    }
-
-    public double getTotalWeightObserved() {
-    	return this.weightObserved.total();
-    }
-
-    public double getMeanError() {
-    	double error=0;
-    	if(this.weightObserved.total() > 0.0 ){
-    		for(int i=0; i<this.averageError.length;i++){
-    			error+=this.averageError[i].total()/this.averageErrorToTargetMean[i].total();
-    		}
-    		error/=this.averageError.length;
-    	}
-    	return error;
-    }
-
-    public double getSquareError() {
-    	double error=0;
-    	if(this.weightObserved.total() > 0.0 ){
-    		for(int i=0; i<this.squareError.length;i++){
-    			error+=Math.sqrt(this.squareError[i].total()/this.squareErrorToTargetMean[i].total());
-    		}
-    		error/=this.squareError.length;
-    	}
-    	return error;
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-    	Measurement.getMeasurementsDescription(getPerformanceMeasurements(),
-    			sb, indent);
-    }
-
-    @Override
-    public void prepareForUseImpl(TaskMonitor monitor,
-    		ObjectRepository repository) {
-    }
-
-
-    @Override
-    public void addResult(Example<Instance> testInst, Prediction prediction) {
-    	Instance inst=(Instance) testInst.getData();
-    	if(this.squareError==null){
-    		this.squareError=new Estimator[inst.numOutputAttributes()];
-    		this.averageError=new Estimator[inst.numOutputAttributes()];
-    		this.averageErrorToTargetMean=new Estimator[inst.numOutputAttributes()];
-    		this.squareErrorToTargetMean=new Estimator[inst.numOutputAttributes()];
-    		this.sumY=new Estimator[inst.numOutputAttributes()];
-
-    		for (int i=0; i<inst.numOutputAttributes();i++){
-    			this.averageError[i] = new Estimator(this.widthOption.getValue());
-    			this.averageErrorToTargetMean[i]=new Estimator(this.widthOption.getValue());
-    			this.squareError[i] = new Estimator(this.widthOption.getValue());
-    			this.squareErrorToTargetMean[i]=new Estimator(this.widthOption.getValue());
-    			this.sumY[i]=new Estimator(this.widthOption.getValue());
-    		}
-    	}
-
-
-    	double weight = inst.weight();
-    	if (numberOutputs == 0) {
-    		numberOutputs = inst.numOutputAttributes();
-    	}
-    	if (weight > 0.0) {
-    		if (TotalweightObserved == 0) {
-    			reset(inst.dataset().numClasses());
-    		}
-    		this.TotalweightObserved += weight;
-    		this.weightObserved.add(weight);
-
-    		if (prediction!=null) {
-    			for (int i = 0; i< numberOutputs;i++){
-    				double error=(inst.valueOutputAttribute(i) - prediction.getVote(i, 0));
-    				this.sumY[i].add(inst.valueOutputAttribute(i));
-    				double errorTM=(inst.valueOutputAttribute(i) - this.sumY[i].total()/this.weightObserved.total());
-    				
-    				this.averageErrorToTargetMean[i].add(Math.abs(errorTM));;
-        			this.squareErrorToTargetMean[i].add(errorTM*errorTM);;
-        			
-    				this.averageError[i].add(Math.abs(error));
-    				this.squareError[i].add( error*error);
-    			}
-    		}
-    		//System.out.println(inst.classValue()+", "+prediction[0]);
-    	}
-
-    }
-}
diff --git a/moa/src/main/java/moa/evaluation/WindowRegressionPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/WindowRegressionPerformanceEvaluator.java
deleted file mode 100644
index 3f91677ea..000000000
--- a/moa/src/main/java/moa/evaluation/WindowRegressionPerformanceEvaluator.java
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
- *    WindowRegressionPerformanceEvaluator.java
- *    Copyright (C) 2011 University of Waikato, Hamilton, New Zealand
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.evaluation;
-
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.core.Example;
-import moa.core.Measurement;
-import moa.core.ObjectRepository;
-import moa.options.AbstractOptionHandler;
-import moa.tasks.TaskMonitor;
-
-/**
- * Regression evaluator that updates evaluation results using a sliding window.
- *
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @version $Revision: 7 $
- */
-public class WindowRegressionPerformanceEvaluator extends AbstractOptionHandler
-        implements RegressionPerformanceEvaluator {
-
-    private static final long serialVersionUID = 1L;
-
-    public IntOption widthOption = new IntOption("width",
-            'w', "Size of Window", 1000);
-
-    protected double TotalweightObserved = 0;
-
-    protected Estimator weightObserved;
-
-    protected Estimator squareError;
-
-    protected Estimator averageError;
-
-    protected int numClasses;
-
-    public class Estimator {
-
-        protected double[] window;
-
-        protected int posWindow;
-
-        protected int lenWindow;
-
-        protected int SizeWindow;
-
-        protected double sum;
-
-        public Estimator(int sizeWindow) {
-            window = new double[sizeWindow];
-            SizeWindow = sizeWindow;
-            posWindow = 0;
-        }
-
-        public void add(double value) {
-            sum -= window[posWindow];
-            sum += value;
-            window[posWindow] = value;
-            posWindow++;
-            if (posWindow == SizeWindow) {
-                posWindow = 0;
-            }
-        }
-
-        public double total() {
-            return sum;
-        }
-    }
-
-    /*   public void setWindowWidth(int w) {
-    this.width = w;
-    reset();
-    }*/
-    @Override
-    public void reset() {
-        reset(this.numClasses);
-    }
-
-    public void reset(int numClasses) {
-        this.numClasses = numClasses;
-        this.weightObserved = new Estimator(this.widthOption.getValue());
-        this.squareError = new Estimator(this.widthOption.getValue());
-        this.averageError = new Estimator(this.widthOption.getValue());
-        this.TotalweightObserved = 0;
-    }
-
-    @Override
-    public void addResult(Example<Instance> example, double[] prediction) {
-        Instance inst = example.getData();
-        double weight = inst.weight();
-        if (weight > 0.0) {
-            if (TotalweightObserved == 0) {
-                reset(inst.dataset().numClasses());
-            }
-            this.TotalweightObserved += weight;
-            this.weightObserved.add(weight);
-
-            if (prediction.length > 0) {
-                this.squareError.add((inst.classValue() - prediction[0]) * (inst.classValue() - prediction[0]));
-                this.averageError.add(Math.abs(inst.classValue() - prediction[0]));
-            }
-            //System.out.println(inst.classValue()+", "+prediction[0]);
-        }
-    }
-
-    @Override
-    public Measurement[] getPerformanceMeasurements() {
-        return new Measurement[]{
-                    new Measurement("classified instances",
-                    getTotalWeightObserved()),
-                    new Measurement("mean absolute error",
-                    getMeanError()),
-                    new Measurement("root mean squared error",
-                    getSquareError())};
-    }
-
-    public double getTotalWeightObserved() {
-        return this.weightObserved.total();
-    }
-
-    public double getMeanError() {
-        return this.weightObserved.total() > 0.0 ? this.averageError.total()
-                / this.weightObserved.total() : 0.0;
-    }
-
-    public double getSquareError() {
-        return Math.sqrt(this.weightObserved.total() > 0.0 ? this.squareError.total()
-                / this.weightObserved.total() : 0.0);
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        Measurement.getMeasurementsDescription(getPerformanceMeasurements(),
-                sb, indent);
-    }
-
-    @Override
-    public void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-    }
-    
-
-	@Override
-	public void addResult(Example<Instance> testInst, Prediction prediction) {
-		double votes[];
-		if(prediction==null)
-			votes = new double[0];
-		else
-			votes= new double[] {prediction.asDouble()};
-		addResult(testInst, votes);
-		
-	}
-}
diff --git a/moa/src/main/java/moa/evaluation/ALClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/evaluators/ALClassificationPerformanceEvaluator.java
similarity index 74%
rename from moa/src/main/java/moa/evaluation/ALClassificationPerformanceEvaluator.java
rename to moa/src/main/java/moa/evaluation/evaluators/ALClassificationPerformanceEvaluator.java
index 19e6ef2e5..0896ece1f 100644
--- a/moa/src/main/java/moa/evaluation/ALClassificationPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/evaluators/ALClassificationPerformanceEvaluator.java
@@ -15,29 +15,30 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.evaluation;
+package moa.evaluation.evaluators;
 
 import com.yahoo.labs.samoa.instances.Instance;
 
 import moa.core.Example;
 
 /**
- * Active Learning Evaluator Interface to make AL Evaluators selectable in AL tasks.
+ * Active Learning Evaluator Interface to make AL Evaluators selectable in AL
+ * tasks.
  *
  * @author Daniel Kottke (daniel.kottke@ovgu.de)
  * @version $Revision: 1 $
  */
 public interface ALClassificationPerformanceEvaluator extends ClassificationPerformanceEvaluator {
-	
-	   /**
-	     * Reports if a label of an instance was acquired.
-	     *
-	     * @param trainInst the instance that was previously considered
-	     * @param labelAcquired bool type which indicates if trainInst 
-	     *        was acquired by the active learner
-	     */
-		public void doLabelAcqReport(Example<Instance> trainInst, int labelAcquired);
+
+	/**
+	 * Reports if a label of an instance was acquired.
+	 *
+	 * @param trainInst     the instance that was previously considered
+	 * @param labelAcquired bool type which indicates if trainInst was acquired by
+	 *                      the active learner
+	 */
+	void doLabelAcqReport(Example<Instance> trainInst, int labelAcquired);
 
 }
diff --git a/moa/src/main/java/moa/evaluation/ALWindowClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/evaluators/ALWindowClassificationPerformanceEvaluator.java
similarity index 62%
rename from moa/src/main/java/moa/evaluation/ALWindowClassificationPerformanceEvaluator.java
rename to moa/src/main/java/moa/evaluation/evaluators/ALWindowClassificationPerformanceEvaluator.java
index a96603273..1f97b1252 100644
--- a/moa/src/main/java/moa/evaluation/ALWindowClassificationPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/evaluators/ALWindowClassificationPerformanceEvaluator.java
@@ -15,9 +15,9 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.evaluation;
+package moa.evaluation.evaluators;
 
 import java.util.Arrays;
 
@@ -25,6 +25,7 @@
 
 import moa.core.Example;
 import moa.core.Measurement;
+import moa.evaluation.evaluators.WindowClassificationPerformanceEvaluator.WindowEstimator;
 
 /**
  * Active Learning Wrapper for BasicClassificationPerformanceEvaluator.
@@ -32,60 +33,62 @@
  * @author Daniel Kottke (daniel.kottke@ovgu.de)
  * @version $Revision: 1 $
  */
-public class ALWindowClassificationPerformanceEvaluator extends WindowClassificationPerformanceEvaluator implements ALClassificationPerformanceEvaluator{
+public class ALWindowClassificationPerformanceEvaluator extends WindowClassificationPerformanceEvaluator
+		implements ALClassificationPerformanceEvaluator {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 
-    private Estimator acquisitionRateEstimator;
+	private Estimator acquisitionRateEstimator;
 
-    private int acquiredInstances;
+	private int acquiredInstances;
 
-   /**
-     * Receives the information if a label has been acquired and increases counters.
-     *
-     * @param trainInst the instance that was previously considered
-     * @param labelAcquired bool type which indicates if trainInst 
-     *        was acquired by the active learner
-     */
+	/**
+	 * Receives the information if a label has been acquired and increases counters.
+	 *
+	 * @param trainInst     the instance that was previously considered
+	 * @param labelAcquired bool type which indicates if trainInst was acquired by
+	 *                      the active learner
+	 */
 	@Override
 	public void doLabelAcqReport(Example<Instance> trainInst, int labelAcquired) {
 		this.acquisitionRateEstimator.add(labelAcquired);
 		this.acquiredInstances += labelAcquired;
 	}
 
-   /**
-     * Returns absolute number of acquired labels so far.
-     */
-	public int getAbsNumOfAcqInst(){
+	/**
+	 * Returns absolute number of acquired labels so far.
+	 */
+	public int getAbsNumOfAcqInst() {
 		return acquiredInstances;
 	}
 
-   /**
-     * Returns relative number of acquired labels so far.
-     */
-	public double getRelNumOfAcqInst(){
-		return acquisitionRateEstimator.estimation();//((float) acquiredInstances) / (float) seenInstances;
+	/**
+	 * Returns relative number of acquired labels so far.
+	 */
+	public double getRelNumOfAcqInst() {
+		return acquisitionRateEstimator.estimation();// ((float) acquiredInstances) / (float) seenInstances;
 	}
 
-	
 	@Override
-    public Measurement[] getPerformanceMeasurements() {
-		Measurement[] measurements = super.getPerformanceMeasurements(); 
-		measurements  = Arrays.copyOf(measurements, measurements.length + 2);
-		measurements[measurements.length - 2] = new Measurement("Abs Number of Label Acquisitions", getAbsNumOfAcqInst());
-		measurements[measurements.length - 1] = new Measurement("Rel Number of Label Acquisitions", getRelNumOfAcqInst());
+	public Measurement[] getPerformanceMeasurements() {
+		Measurement[] measurements = super.getPerformanceMeasurements();
+		measurements = Arrays.copyOf(measurements, measurements.length + 2);
+		measurements[measurements.length - 2] = new Measurement("Abs Number of Label Acquisitions",
+				getAbsNumOfAcqInst());
+		measurements[measurements.length - 1] = new Measurement("Rel Number of Label Acquisitions",
+				getRelNumOfAcqInst());
 		return measurements;
-    }
-	
+	}
+
 	@Override
 	public void reset(int numClasses) {
 		super.reset(numClasses);
 		acquisitionRateEstimator = new WindowEstimator(widthOption.getValue());
 		acquiredInstances = 0;
-		
+
 	}
 
 }
diff --git a/moa/src/main/java/moa/evaluation/AdwinClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/evaluators/AdwinClassificationPerformanceEvaluator.java
similarity index 63%
rename from moa/src/main/java/moa/evaluation/AdwinClassificationPerformanceEvaluator.java
rename to moa/src/main/java/moa/evaluation/evaluators/AdwinClassificationPerformanceEvaluator.java
index aea7cf19e..5b954f037 100644
--- a/moa/src/main/java/moa/evaluation/AdwinClassificationPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/evaluators/AdwinClassificationPerformanceEvaluator.java
@@ -15,46 +15,46 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.evaluation;
+package moa.evaluation.evaluators;
 
-import moa.classifiers.core.driftdetection.ADWIN;
+import moa.learners.predictors.core.driftdetection.ADWIN;
 
 /**
- * Classification evaluator that updates evaluation results using an adaptive sliding
- * window.
+ * Classification evaluator that updates evaluation results using an adaptive
+ * sliding window.
  *
  * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
  * @version $Revision: 7 $
  */
 public class AdwinClassificationPerformanceEvaluator extends BasicClassificationPerformanceEvaluator {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    @Override
-    protected Estimator newEstimator() {
-        return new AdwinEstimator();
-    }
+	@Override
+	protected Estimator newEstimator() {
+		return new AdwinEstimator();
+	}
 
-    public class AdwinEstimator implements Estimator {
+	public class AdwinEstimator implements Estimator {
 
-        protected ADWIN adwin;
+		protected ADWIN adwin;
 
-        public AdwinEstimator() {
-            this.adwin = new ADWIN();
-        }
+		public AdwinEstimator() {
+			this.adwin = new ADWIN();
+		}
 
-        @Override
-        public void add(double value) {
-            this.adwin.setInput(value);
-        }
+		@Override
+		public void add(double value) {
+			this.adwin.setInput(value);
+		}
 
-        @Override
-        public double estimation() {
-            return this.adwin.getEstimation();
-        }
+		@Override
+		public double estimation() {
+			return this.adwin.getEstimation();
+		}
 
-    }
+	}
 
 }
diff --git a/moa/src/main/java/moa/evaluation/BasicAUCImbalancedPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/evaluators/BasicAUCImbalancedPerformanceEvaluator.java
similarity index 95%
rename from moa/src/main/java/moa/evaluation/BasicAUCImbalancedPerformanceEvaluator.java
rename to moa/src/main/java/moa/evaluation/evaluators/BasicAUCImbalancedPerformanceEvaluator.java
index a439cab40..fcb75b62e 100644
--- a/moa/src/main/java/moa/evaluation/BasicAUCImbalancedPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/evaluators/BasicAUCImbalancedPerformanceEvaluator.java
@@ -16,7 +16,7 @@
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
-package moa.evaluation;
+package moa.evaluation.evaluators;
 
 import java.util.TreeSet;
 
@@ -39,7 +39,7 @@
  * calculation as described in (but without windowing): D. Brzezinski, J.
  * Stefanowski, "Prequential AUC: Properties of the Area Under the ROC Curve for
  * Data Streams with Concept Drift", Knowledge and Information Systems, 2017.
- * 
+ *
  * @author Dariusz Brzezinski (dbrzezinski at cs.put.poznan.pl)
  */
 public class BasicAUCImbalancedPerformanceEvaluator extends AbstractOptionHandler
@@ -50,8 +50,7 @@ public class BasicAUCImbalancedPerformanceEvaluator extends AbstractOptionHandle
 	public FlagOption calculateAUC = new FlagOption("calculateAUC", 'a',
 			"Determines whether AUC should be calculated. To calculate AUC, "
 					+ "predictions need to be remembered, therefore setting "
-					+ "this option for large streams can cause substantial "
-					+ "memory usage.");
+					+ "this option for large streams can cause substantial " + "memory usage.");
 
 	protected double totalObservedInstances = 0;
 	private Estimator aucEstimator;
@@ -82,8 +81,7 @@ public class Score implements Comparable<Score> {
 			protected double value;
 
 			/**
-			 * Age of example - position in the stream where the example was
-			 * added
+			 * Age of example - position in the stream where the example was added
 			 */
 			protected int position;
 
@@ -94,12 +92,10 @@ public class Score implements Comparable<Score> {
 
 			/**
 			 * Constructor.
-			 * 
-			 * @param value
-			 *            score value
-			 * 
-			 * @param isPositive
-			 *            true if the example's true label is positive
+			 *
+			 * @param value      score value
+			 *
+			 * @param isPositive true if the example's true label is positive
 			 */
 			public Score(double value, int position, boolean isPositive) {
 				this.value = value;
@@ -159,7 +155,7 @@ public boolean equals(Object o) {
 
 		public Estimator(boolean calculateAuc) {
 			this.calculateAuc = calculateAuc;
-			this.sortedScores = new TreeSet<Score>();
+			this.sortedScores = new TreeSet<>();
 
 			this.rowKappa = new double[numClasses];
 			this.columnKappa = new double[numClasses];
@@ -225,7 +221,7 @@ public double getAUC() {
 				} else {
 					if (s.value == lastPosScore) {
 						// tie
-						AUC += ((double) (c + prevc)) / 2.0;
+						AUC += (c + prevc) / 2.0;
 					} else {
 						AUC += c;
 					}
@@ -265,7 +261,7 @@ public double getScoredAUC() {
 
 					if (s.value == lastNegScore) {
 						// tie
-						AOC += ((double) (r + prevr)) / 2.0;
+						AOC += (r + prevr) / 2.0;
 					} else {
 						AOC += r;
 					}
@@ -279,7 +275,7 @@ public double getScoredAUC() {
 
 					if (s.value == lastPosScore) {
 						// tie
-						AUC += ((double) (c + prevc)) / 2.0;
+						AUC += (c + prevc) / 2.0;
 					} else {
 						AUC += c;
 					}
diff --git a/moa/src/main/java/moa/evaluation/evaluators/BasicClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/evaluators/BasicClassificationPerformanceEvaluator.java
new file mode 100644
index 000000000..6b66aed50
--- /dev/null
+++ b/moa/src/main/java/moa/evaluation/evaluators/BasicClassificationPerformanceEvaluator.java
@@ -0,0 +1,332 @@
+/*
+ *    BasicClassificationPerformanceEvaluator.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.evaluation.evaluators;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+
+import com.github.javacliparser.FlagOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
+import moa.core.Example;
+import moa.core.Measurement;
+import moa.core.ObjectRepository;
+import moa.core.Utils;
+import moa.options.AbstractOptionHandler;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Classification evaluator that performs basic incremental evaluation.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *         Updates in September 15th 2017 to include precision, recall and F1
+ *         scores.
+ * @author Jean Karax (karaxjr@gmail.com)
+ * @author Jean Paul Barddal (jean.barddal@ppgia.pucpr.br)
+ * @author Wilson Sasaki Jr (sasaki.wilson.jr@gmail.com)
+ * @version $Revision: 8 $
+ */
+public class BasicClassificationPerformanceEvaluator extends AbstractOptionHandler
+		implements ClassificationPerformanceEvaluator {
+
+	private static final long serialVersionUID = 1L;
+
+	protected Estimator weightCorrect;
+
+	protected Estimator[] columnKappa;
+
+	protected Estimator[] rowKappa;
+
+	protected Estimator[] precision;
+
+	protected Estimator[] recall;
+
+	protected int numClasses;
+
+	private Estimator weightCorrectNoChangeClassifier;
+
+	private Estimator weightMajorityClassifier;
+
+	private int lastSeenClass;
+
+	private double totalWeightObserved;
+
+	public FlagOption precisionRecallOutputOption = new FlagOption("precisionRecallOutput", 'o',
+			"Outputs average precision, recall and F1 scores.");
+
+	public FlagOption precisionPerClassOption = new FlagOption("precisionPerClass", 'p', "Report precision per class.");
+
+	public FlagOption recallPerClassOption = new FlagOption("recallPerClass", 'r', "Report recall per class.");
+
+	public FlagOption f1PerClassOption = new FlagOption("f1PerClass", 'f', "Report F1 per class.");
+
+	@Override
+	public void reset() {
+		reset(this.numClasses);
+	}
+
+	public void reset(int numClasses) {
+		this.numClasses = numClasses;
+		this.rowKappa = new Estimator[numClasses];
+		this.columnKappa = new Estimator[numClasses];
+		this.precision = new Estimator[numClasses];
+		this.recall = new Estimator[numClasses];
+		for (int i = 0; i < this.numClasses; i++) {
+			this.rowKappa[i] = newEstimator();
+			this.columnKappa[i] = newEstimator();
+			this.precision[i] = newEstimator();
+			this.recall[i] = newEstimator();
+		}
+		this.weightCorrect = newEstimator();
+		this.weightCorrectNoChangeClassifier = newEstimator();
+		this.weightMajorityClassifier = newEstimator();
+		this.lastSeenClass = 0;
+		this.totalWeightObserved = 0;
+	}
+
+	@Override
+	public void addResult(Example<Instance> example, double[] classVotes) {
+		Instance inst = example.getData();
+		double weight = inst.weight();
+		if (inst.classIsMissing() == false) {
+			int trueClass = (int) inst.classValue();
+			int predictedClass = Utils.maxIndex(classVotes);
+			if (weight > 0.0) {
+				if (this.totalWeightObserved == 0) {
+					reset(inst.dataset().numClasses());
+				}
+				this.totalWeightObserved += weight;
+				this.weightCorrect.add(predictedClass == trueClass ? weight : 0);
+				for (int i = 0; i < this.numClasses; i++) {
+					this.rowKappa[i].add(predictedClass == i ? weight : 0);
+					this.columnKappa[i].add(trueClass == i ? weight : 0);
+					// for both precision and recall, NaN values are used to 'balance' the number
+					// of instances seen across classes
+					if (predictedClass == i) {
+						precision[i].add(predictedClass == trueClass ? weight : 0.0);
+					} else
+						precision[i].add(Double.NaN);
+					if (trueClass == i) {
+						recall[i].add(predictedClass == trueClass ? weight : 0.0);
+					} else
+						recall[i].add(Double.NaN);
+				}
+			}
+			this.weightCorrectNoChangeClassifier.add(this.lastSeenClass == trueClass ? weight : 0);
+			this.weightMajorityClassifier.add(getMajorityClass() == trueClass ? weight : 0);
+			this.lastSeenClass = trueClass;
+		}
+	}
+
+	private int getMajorityClass() {
+		int majorityClass = 0;
+		double maxProbClass = 0.0;
+		for (int i = 0; i < this.numClasses; i++) {
+			if (this.columnKappa[i].estimation() > maxProbClass) {
+				majorityClass = i;
+				maxProbClass = this.columnKappa[i].estimation();
+			}
+		}
+		return majorityClass;
+	}
+
+	@Override
+	public Measurement[] getPerformanceMeasurements() {
+		ArrayList<Measurement> measurements = new ArrayList<>();
+		measurements.add(new Measurement("classified instances", this.getTotalWeightObserved()));
+		measurements.add(
+				new Measurement("classifications correct (percent)", this.getFractionCorrectlyClassified() * 100.0));
+		measurements.add(new Measurement("Kappa Statistic (percent)", this.getKappaStatistic() * 100.0));
+		measurements
+				.add(new Measurement("Kappa Temporal Statistic (percent)", this.getKappaTemporalStatistic() * 100.0));
+		measurements.add(new Measurement("Kappa M Statistic (percent)", this.getKappaMStatistic() * 100.0));
+		if (precisionRecallOutputOption.isSet())
+			measurements.add(new Measurement("F1 Score (percent)", this.getF1Statistic() * 100.0));
+		if (f1PerClassOption.isSet()) {
+			for (int i = 0; i < this.numClasses; i++) {
+				measurements
+						.add(new Measurement("F1 Score for class " + i + " (percent)", 100.0 * this.getF1Statistic(i)));
+			}
+		}
+		if (precisionRecallOutputOption.isSet())
+			measurements.add(new Measurement("Precision (percent)", this.getPrecisionStatistic() * 100.0));
+		if (precisionPerClassOption.isSet()) {
+			for (int i = 0; i < this.numClasses; i++) {
+				measurements.add(new Measurement("Precision for class " + i + " (percent)",
+						100.0 * this.getPrecisionStatistic(i)));
+			}
+		}
+		if (precisionRecallOutputOption.isSet())
+			measurements.add(new Measurement("Recall (percent)", this.getRecallStatistic() * 100.0));
+		if (recallPerClassOption.isSet()) {
+			for (int i = 0; i < this.numClasses; i++) {
+				measurements.add(
+						new Measurement("Recall for class " + i + " (percent)", 100.0 * this.getRecallStatistic(i)));
+			}
+		}
+
+		Measurement[] result = new Measurement[measurements.size()];
+
+		return measurements.toArray(result);
+
+	}
+
+	public double getTotalWeightObserved() {
+		return this.totalWeightObserved;
+	}
+
+	public double getFractionCorrectlyClassified() {
+		return this.weightCorrect.estimation();
+	}
+
+	public double getFractionIncorrectlyClassified() {
+		return 1.0 - getFractionCorrectlyClassified();
+	}
+
+	public double getKappaStatistic() {
+		if (this.getTotalWeightObserved() > 0.0) {
+			double p0 = getFractionCorrectlyClassified();
+			double pc = 0.0;
+			for (int i = 0; i < this.numClasses; i++) {
+				pc += this.rowKappa[i].estimation() * this.columnKappa[i].estimation();
+			}
+			return (p0 - pc) / (1.0 - pc);
+		} else {
+			return 0;
+		}
+	}
+
+	public double getKappaTemporalStatistic() {
+		if (this.getTotalWeightObserved() > 0.0) {
+			double p0 = getFractionCorrectlyClassified();
+			double pc = this.weightCorrectNoChangeClassifier.estimation();
+
+			return (p0 - pc) / (1.0 - pc);
+		} else {
+			return 0;
+		}
+	}
+
+	private double getKappaMStatistic() {
+		if (this.getTotalWeightObserved() > 0.0) {
+			double p0 = getFractionCorrectlyClassified();
+			double pc = this.weightMajorityClassifier.estimation();
+
+			return (p0 - pc) / (1.0 - pc);
+		} else {
+			return 0;
+		}
+	}
+
+	public double getPrecisionStatistic() {
+		double total = 0;
+		for (Estimator ck : this.precision) {
+			total += ck.estimation();
+		}
+		return total / this.precision.length;
+	}
+
+	public double getPrecisionStatistic(int numClass) {
+		return this.precision[numClass].estimation();
+	}
+
+	public double getRecallStatistic() {
+		double total = 0;
+		for (Estimator ck : this.recall) {
+			total += ck.estimation();
+		}
+		return total / this.recall.length;
+	}
+
+	public double getRecallStatistic(int numClass) {
+		return this.recall[numClass].estimation();
+	}
+
+	public double getF1Statistic() {
+		return 2 * ((this.getPrecisionStatistic() * this.getRecallStatistic())
+				/ (this.getPrecisionStatistic() + this.getRecallStatistic()));
+	}
+
+	public double getF1Statistic(int numClass) {
+		return 2 * ((this.getPrecisionStatistic(numClass) * this.getRecallStatistic(numClass))
+				/ (this.getPrecisionStatistic(numClass) + this.getRecallStatistic(numClass)));
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		Measurement.getMeasurementsDescription(getPerformanceMeasurements(), sb, indent);
+	}
+
+	@Override
+	public void addResult(Example<Instance> testInst, Prediction prediction) {
+		this.addResult(testInst, prediction.asDoubleArray());
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+
+	}
+
+	public interface Estimator extends Serializable {
+
+		void add(double value);
+
+		double estimation();
+	}
+
+	public class BasicEstimator implements Estimator {
+
+		protected double len;
+
+		protected double sum;
+
+		@Override
+		public void add(double value) {
+			if (!Double.isNaN(value)) {
+				sum += value;
+				len++;
+			}
+		}
+
+		@Override
+		public double estimation() {
+			return sum / len;
+		}
+
+	}
+
+	protected Estimator newEstimator() {
+		return new BasicEstimator();
+	}
+
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == BasicClassificationPerformanceEvaluator.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
+}
diff --git a/moa/src/main/java/moa/evaluation/evaluators/BasicConceptDriftPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/evaluators/BasicConceptDriftPerformanceEvaluator.java
new file mode 100644
index 000000000..8eb82aeb6
--- /dev/null
+++ b/moa/src/main/java/moa/evaluation/evaluators/BasicConceptDriftPerformanceEvaluator.java
@@ -0,0 +1,191 @@
+/*
+ *    BasicConceptDriftPerformanceEvaluator.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Albert Bifet (abifet@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 2 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program; if not, write to the Free Software
+ *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+package moa.evaluation.evaluators;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.AbstractMOAObject;
+import moa.core.Example;
+import moa.core.Measurement;
+
+public class BasicConceptDriftPerformanceEvaluator extends AbstractMOAObject
+		implements LearningPerformanceEvaluator<Example<Instance>> {
+
+	private static final long serialVersionUID = 1L;
+
+	protected double weightObserved;
+
+	protected double numberDetections;
+
+	protected double numberDetectionsOccurred;
+
+	protected double numberChanges;
+
+	protected double numberWarnings;
+
+	protected double delay;
+
+	protected double errorPrediction;
+
+	protected double totalDelay;
+
+	protected boolean isWarningZone;
+
+	protected double inputValues;
+
+	@Override
+	public void reset() {
+		this.weightObserved = 0.0;
+		this.numberDetections = 0.0;
+		this.numberDetectionsOccurred = 0.0;
+		this.errorPrediction = 0.0;
+		this.numberChanges = 0.0;
+		this.numberWarnings = 0.0;
+		this.delay = 0.0;
+		this.totalDelay = 0.0;
+		this.isWarningZone = false;
+		this.inputValues = 0.0;
+		this.hasChangeOccurred = false;
+	}
+
+	private boolean hasChangeOccurred = false;
+
+	@Override
+	public void addResult(Example<Instance> example, double[] classVotes) {
+		Instance inst = example.getData();
+		// classVotes[0] -> is Change
+		// classVotes[1] -> is in Warning Zone
+		// classVotes[2] -> delay
+		// classVotes[3] -> estimation
+
+		this.inputValues = inst.value(2);
+		if (inst.weight() > 0.0 && classVotes.length == 4) {
+			if (inst.numAttributes() > 1) {
+				// if there is ground truth we monitor delay
+				this.delay++;
+			}
+			this.weightObserved += inst.weight();
+			if (classVotes[0] == 1.0) {
+				// Change detected
+				// System.out.println("Change detected with delay "+ this.delay );
+				this.numberDetections += inst.weight();
+				if (this.hasChangeOccurred == true) {
+					this.totalDelay += this.delay - classVotes[2];
+					this.numberDetectionsOccurred += inst.weight();
+					this.hasChangeOccurred = false;
+				}
+			}
+			if (this.hasChangeOccurred && classVotes[1] == 1.0) {
+				// Warning detected
+				// System.out.println("Warning detected at "+getTotalWeightObserved());
+				if (this.isWarningZone == false) {
+					this.numberWarnings += inst.weight();
+					this.isWarningZone = true;
+				}
+			} else {
+				this.isWarningZone = false;
+			}
+			if (inst.numAttributes() > 1) {
+				if (inst.value(inst.numAttributes() - 2) == 1.0) {// Attribute 1
+					// Ground truth Change
+					this.numberChanges += inst.weight();
+					this.delay = 0;
+					this.hasChangeOccurred = true;
+				}
+			}
+			// Compute error prediction
+			if (classVotes.length > 1) {
+				this.errorPrediction += Math.abs(classVotes[3] - inst.value(0));
+			}
+		}
+	}
+
+	@Override
+	public Measurement[] getPerformanceMeasurements() {
+		Measurement[] measurement;
+		// if (totalDelay == 0.0) { //No Ground Truth
+		measurement = new Measurement[] { new Measurement("learned instances", getTotalWeightObserved()),
+				new Measurement("detected changes", getNumberDetections()),
+				new Measurement("detected warnings", getNumberWarnings()),
+				new Measurement("prediction error (average)", getPredictionError() / getTotalWeightObserved()),
+				new Measurement("true changes", getNumberChanges()),
+				new Measurement("delay detection (average)", getTotalDelay() / getNumberChanges()),
+				new Measurement("true changes detected", getNumberChangesOccurred()),
+				new Measurement("input values", getInputValues()) };
+		/*
+		 * } else { measurement = new Measurement[]{ new
+		 * Measurement("learned instances", getTotalWeightObserved()), new
+		 * Measurement("detected changes", getNumberDetections()), new
+		 * Measurement("detected warnings", getNumberWarnings()), new
+		 * Measurement("prediction error (average)", getPredictionError() /
+		 * getTotalWeightObserved()), new Measurement("true changes",
+		 * getNumberChanges()), new Measurement("delay detection (average)",
+		 * getTotalDelay() / getNumberChanges()), new
+		 * Measurement("true changes detected", getNumberChangesOccurred()), new
+		 * Measurement("input values", getInputValues()) }; }
+		 */
+		return measurement;
+	}
+
+	public double getTotalWeightObserved() {
+		return this.weightObserved > 0 ? this.weightObserved : 1.0;
+	}
+
+	public double getNumberDetections() {
+		return this.numberDetections;
+	}
+
+	public double getInputValues() {
+		return this.inputValues;
+	}
+
+	public double getPredictionError() {
+		return this.errorPrediction;
+	}
+
+	public double getNumberChanges() {
+		return this.numberChanges;
+	}
+
+	public double getNumberChangesOccurred() {
+		return this.numberDetectionsOccurred;
+	}
+
+	public double getNumberWarnings() {
+		return this.numberWarnings;
+	}
+
+	public double getTotalDelay() {
+		return this.totalDelay;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		Measurement.getMeasurementsDescription(getPerformanceMeasurements(), sb, indent);
+	}
+
+	@Override
+	public void addResult(Example<Instance> testInst, Prediction prediction) {
+		// TODO Auto-generated method stub
+
+	}
+
+}
diff --git a/moa/src/main/java/moa/evaluation/evaluators/BasicMultiLabelPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/evaluators/BasicMultiLabelPerformanceEvaluator.java
new file mode 100644
index 000000000..db8c317c5
--- /dev/null
+++ b/moa/src/main/java/moa/evaluation/evaluators/BasicMultiLabelPerformanceEvaluator.java
@@ -0,0 +1,179 @@
+/*
+ *    BasicMultiLabelPerformanceEvaluator.java
+ *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
+ *    @author Jesse Read (jesse@tsc.uc3m.es)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package moa.evaluation.evaluators;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.AbstractMOAObject;
+import moa.core.Example;
+import moa.core.Measurement;
+
+/**
+ * Multilabel Window Classification Performance Evaluator.
+ *
+ * @author Jesse Read (jesse@tsc.uc3m.es)
+ * @version $Revision: 1 $
+ *
+ *          Added instance based F-Measure, Recall, Precision and Accuracy
+ * @author R. Sousa, J.Gama
+ * @version $Revision: 2 $
+ *
+ */
+public class BasicMultiLabelPerformanceEvaluator extends AbstractMOAObject
+		implements MultiLabelClassificationPerformanceEvaluator {
+
+	protected int L;
+
+	/** running sum of accuracy */
+	double sumAccuracy = 0.0;
+	double sumHamming = 0.0;
+	double sumAccuracy2 = 0.0;
+	double sumPrecision = 0.0;
+	double sumRecall = 0.0;
+	double sumFmeasure = 0.0;
+
+	/** running number of examples */
+	int sumExamples = 0;
+
+	/** preset threshold */
+	private double t = 0.5;
+
+	@Override
+	public void reset() {
+		sumAccuracy = 0.0;
+		sumHamming = 0.0;
+		sumExamples = 0;
+		sumAccuracy2 = 0.0;
+		sumPrecision = 0.0;
+		sumRecall = 0.0;
+		sumFmeasure = 0.0;
+	}
+
+	@Override
+	public void addResult(Example<Instance> example, Prediction y) {
+
+		int sumReunion = 0;
+		int sumInterse = 0;
+		int sumOnesTrue = 0;
+		int sumOnesPred = 0;
+
+		Instance x = example.getData();
+
+		for (int j = 0; j < y.numOutputAttributes(); j++) {
+			System.out.print((int) x.classValue(j));
+		}
+		System.out.print(" ");
+
+		for (int j = 0; j < y.numOutputAttributes(); j++) {
+			System.out.print((y.getVote(j, 0) > t) ? 1 : 0);
+		}
+		System.out.print("\n");
+
+		if (L == 0) {
+			L = x.numOutputAttributes();
+		}
+
+		if (y == null) {
+			System.err.print("[WARNING] Prediction is null! (Ignoring this prediction)");
+		} else if (y.numOutputAttributes() < x.numOutputAttributes()) {
+			System.err.println("[WARNING] Only " + y.numOutputAttributes() + " labels found! (Expecting "
+					+ x.numOutputAttributes() + ")\n (Ignoring this prediction)");
+		} else {
+			sumExamples++;
+			int correct = 0;
+			for (int j = 0; j < y.numOutputAttributes(); j++) {
+				int yp = (y.getVote(j, 0) > t) ? 1 : 0;
+				correct += ((int) x.classValue(j) == yp) ? 1 : 0;
+
+				int y_true = (int) x.valueOutputAttribute(j);
+				if (y_true == yp)
+					correct++;
+
+				if (y_true == 1 || yp == 1)
+					sumReunion++;
+
+				if (y_true == 1 && yp == 1)
+					sumInterse++;
+
+				if (y_true == 1)
+					sumOnesTrue++;
+
+				if (yp == 1)
+					sumOnesPred++;
+
+			}
+
+			// Accuracy by instance(Jaccard Index)
+			if (sumReunion > 0) {
+				sumAccuracy2 += (double) sumInterse / sumReunion;
+			} else {
+				sumAccuracy2 += 0.0;
+			}
+
+			// Precision by instance
+			if (sumOnesTrue > 0) {
+				sumPrecision += (double) sumInterse / sumOnesTrue;
+			}
+
+			// Recall by instance
+			if (sumOnesPred > 0) {
+				sumRecall += sumInterse / sumOnesPred;
+			}
+
+			// F-Measure by instance
+			if ((sumOnesPred + sumOnesTrue) > 0) {
+				sumFmeasure += (double) 2 * sumInterse / (sumOnesPred + sumOnesTrue);
+			} else {
+				sumFmeasure += 0.0;
+			}
+
+			sumHamming += (correct / (double) L); // Hamming Score
+			sumAccuracy += (correct == L) ? 1 : 0; // Exact Match
+		}
+	}
+
+	@Override
+	public Measurement[] getPerformanceMeasurements() {
+
+		// gather measurements
+		Measurement m[] = new Measurement[] { new Measurement("Exact Match", sumAccuracy / sumExamples),
+				new Measurement("Accuracy", sumAccuracy2 / sumExamples),
+				new Measurement("Hamming Score", sumHamming / sumExamples),
+				new Measurement("Precision", (sumPrecision) / sumExamples),
+				new Measurement("Recall", sumRecall / sumExamples),
+				new Measurement("F-Measure", sumFmeasure / sumExamples), };
+
+		// reset
+		// reset();
+
+		return m;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		sb.append("Basic Multi-label Performance Evaluator");
+	}
+
+	@Override
+	public void addResult(Example<Instance> example, double[] classVotes) {
+		// TODO Auto-generated method stub
+
+	}
+}
diff --git a/moa/src/main/java/moa/evaluation/evaluators/BasicMultiTargetPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/evaluators/BasicMultiTargetPerformanceEvaluator.java
new file mode 100644
index 000000000..82d6b6ffe
--- /dev/null
+++ b/moa/src/main/java/moa/evaluation/evaluators/BasicMultiTargetPerformanceEvaluator.java
@@ -0,0 +1,107 @@
+/*
+ *    BasicRegressionPerformanceEvaluator.java
+ *    Copyright (C) 2011 University of Waikato, Hamilton, New Zealand
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.evaluation.evaluators;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.AbstractMOAObject;
+import moa.core.Example;
+import moa.core.Measurement;
+
+/**
+ * Regression evaluator that performs basic incremental evaluation.
+ *
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @version $Revision: 7 $
+ */
+public class BasicMultiTargetPerformanceEvaluator extends AbstractMOAObject
+		implements MultiTargetRegressionPerformanceEvaluator {
+
+	private static final long serialVersionUID = 1L;
+
+	protected double weightObserved;
+
+	protected double squareError;
+
+	protected double averageError;
+
+	protected int numberOutputs;
+
+	@Override
+	public void reset() {
+		this.weightObserved = 0.0;
+		this.squareError = 0.0;
+		this.averageError = 0.0;
+	}
+
+	@Override
+	public void addResult(Example<Instance> example, Prediction prediction) {
+
+		Instance inst = (Instance) example.getData();
+		if (numberOutputs == 0) {
+			numberOutputs = inst.numOutputAttributes();
+		}
+		if (inst.weight() > 0.0) {
+			this.weightObserved += inst.weight();
+			if (prediction != null) {
+				for (int i = 0; i < numberOutputs; i++) {
+					double err = inst.classValue(i)
+							- ((prediction.numOutputAttributes() == 0) ? 0.0 : prediction.getPrediction(i));
+					this.squareError += (err) * (err);
+					this.averageError += Math.abs(err);
+				}
+			}
+			// System.out.println(inst.classValue()+", "+prediction);
+		}
+	}
+
+	@Override
+	public Measurement[] getPerformanceMeasurements() {
+		return new Measurement[] { new Measurement("classified instances", getTotalWeightObserved()),
+				new Measurement("mean absolute error", getMeanError()),
+				new Measurement("root mean squared error", getSquareError()) };
+	}
+
+	public double getTotalWeightObserved() {
+		return this.weightObserved;
+	}
+
+	public double getMeanError() {
+		return this.weightObserved > 0.0 ? this.averageError / (this.weightObserved * this.numberOutputs) : 0.0;
+	}
+
+	public double getSquareError() {
+		return Math
+				.sqrt(this.weightObserved > 0.0 ? this.squareError / (this.weightObserved * this.numberOutputs) : 0.0);
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		Measurement.getMeasurementsDescription(getPerformanceMeasurements(), sb, indent);
+	}
+
+	@Override
+	public void addResult(Example<Instance> example, double[] classVotes) {
+		// TODO Auto-generated method stub
+
+	}
+
+}
diff --git a/moa/src/main/java/moa/evaluation/BasicMultiTargetPerformanceRelativeMeasuresEvaluator.java b/moa/src/main/java/moa/evaluation/evaluators/BasicMultiTargetPerformanceRelativeMeasuresEvaluator.java
similarity index 58%
rename from moa/src/main/java/moa/evaluation/BasicMultiTargetPerformanceRelativeMeasuresEvaluator.java
rename to moa/src/main/java/moa/evaluation/evaluators/BasicMultiTargetPerformanceRelativeMeasuresEvaluator.java
index a72d8cc45..ede4dd2d9 100644
--- a/moa/src/main/java/moa/evaluation/BasicMultiTargetPerformanceRelativeMeasuresEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/evaluators/BasicMultiTargetPerformanceRelativeMeasuresEvaluator.java
@@ -15,9 +15,9 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.evaluation;
+package moa.evaluation.evaluators;
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.MultiLabelInstance;
@@ -35,22 +35,21 @@
  * @version $Revision: 7 $
  */
 public class BasicMultiTargetPerformanceRelativeMeasuresEvaluator extends AbstractMOAObject
-implements MultiTargetRegressionPerformanceEvaluator{
+		implements MultiTargetRegressionPerformanceEvaluator {
 
 	private static final long serialVersionUID = 1L;
 
 	protected double weightObserved;
 
-	protected double [] squareError;
-
-	protected double [] averageError;
+	protected double[] squareError;
 
-	protected double [] averageErrorToTargetMean;
+	protected double[] averageError;
 
-	protected double [] squareErrorToTargetMean;
+	protected double[] averageErrorToTargetMean;
 
-	protected double [] sumY;
+	protected double[] squareErrorToTargetMean;
 
+	protected double[] sumY;
 
 	protected int numberOutputs;
 
@@ -59,9 +58,9 @@ public void reset() {
 		this.weightObserved = 0.0;
 		this.squareError = null;
 		this.averageError = null;
-		this.averageErrorToTargetMean=null;
-		this.squareErrorToTargetMean=null;
-		this.sumY=null;
+		this.averageErrorToTargetMean = null;
+		this.squareErrorToTargetMean = null;
+		this.sumY = null;
 	}
 
 	@Override
@@ -70,46 +69,40 @@ public void addResult(Example<Instance> example, Prediction prediction) {
 		if (numberOutputs == 0) {
 			numberOutputs = inst.numOutputAttributes();
 		}
-		if(this.squareError==null){
+		if (this.squareError == null) {
 			this.squareError = new double[numberOutputs];
 			this.averageError = new double[numberOutputs];
-			this.averageErrorToTargetMean=new double[numberOutputs];
-			this.squareErrorToTargetMean=new double[numberOutputs];
-			this.sumY=new double[numberOutputs];
+			this.averageErrorToTargetMean = new double[numberOutputs];
+			this.squareErrorToTargetMean = new double[numberOutputs];
+			this.sumY = new double[numberOutputs];
 		}
 
-
-
 		if (inst.weight() > 0.0) {
 			this.weightObserved += inst.weight();
-			if (prediction != null && prediction.numOutputAttributes()>0) {
-				for (int i = 0; i< numberOutputs;i++){
-					double error=(inst.valueOutputAttribute(i) - prediction.getVote(i, 0));
-					
-					this.sumY[i]+=inst.valueOutputAttribute(i);
-					double errorTM=(inst.valueOutputAttribute(i) - this.sumY[i]/this.weightObserved);
+			if (prediction != null && prediction.numOutputAttributes() > 0) {
+				for (int i = 0; i < numberOutputs; i++) {
+					double error = (inst.valueOutputAttribute(i) - prediction.getPrediction(i));
+
+					this.sumY[i] += inst.valueOutputAttribute(i);
+					double errorTM = (inst.valueOutputAttribute(i) - this.sumY[i] / this.weightObserved);
 
-					this.averageErrorToTargetMean[i]+=Math.abs(errorTM);
-					this.squareErrorToTargetMean[i]+=errorTM*errorTM;
+					this.averageErrorToTargetMean[i] += Math.abs(errorTM);
+					this.squareErrorToTargetMean[i] += errorTM * errorTM;
 
-					this.averageError[i]+=Math.abs(error);
-					this.squareError[i]+=error*error;
+					this.averageError[i] += Math.abs(error);
+					this.squareError[i] += error * error;
 
 				}
 			}
-			//System.out.println(inst.classValue()+", "+prediction);
+			// System.out.println(inst.classValue()+", "+prediction);
 		}
 	}
 
 	@Override
 	public Measurement[] getPerformanceMeasurements() {
-		return new Measurement[]{
-				new Measurement("classified instances",
-						getTotalWeightObserved()),
-						new Measurement("relative mean absolute error",
-								getMeanError()),
-								new Measurement("relative root mean squared error",
-										getSquareError())};
+		return new Measurement[] { new Measurement("classified instances", getTotalWeightObserved()),
+				new Measurement("relative mean absolute error", getMeanError()),
+				new Measurement("relative root mean squared error", getSquareError()) };
 	}
 
 	public double getTotalWeightObserved() {
@@ -117,38 +110,37 @@ public double getTotalWeightObserved() {
 	}
 
 	public double getMeanError() {
-		double error=0;
-		if(this.weightObserved > 0.0 ){
-			for(int i=0; i<this.averageError.length;i++){
-				error+=this.averageError[i]/this.averageErrorToTargetMean[i];
+		double error = 0;
+		if (this.weightObserved > 0.0) {
+			for (int i = 0; i < this.averageError.length; i++) {
+				error += this.averageError[i] / this.averageErrorToTargetMean[i];
 			}
-			error/=this.numberOutputs;
+			error /= this.numberOutputs;
 		}
 		return error;
 	}
 
 	public double getSquareError() {
-		double error=0;
-		if(this.weightObserved > 0.0 ){
-			for(int i=0; i<this.squareError.length;i++){
-				error+=Math.sqrt(this.squareError[i]/this.squareErrorToTargetMean[i]);
+		double error = 0;
+		if (this.weightObserved > 0.0) {
+			for (int i = 0; i < this.squareError.length; i++) {
+				error += Math.sqrt(this.squareError[i] / this.squareErrorToTargetMean[i]);
 			}
-			error/=this.numberOutputs;
+			error /= this.numberOutputs;
 		}
 		return error;
 	}
 
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
-		Measurement.getMeasurementsDescription(getPerformanceMeasurements(),
-				sb, indent);
+		Measurement.getMeasurementsDescription(getPerformanceMeasurements(), sb, indent);
 	}
 
-	//only for one output
+	// only for one output
 	@Override
 	public void addResult(Example<Instance> example, double[] classVotes) {
 		// TODO This probably fails
-		Prediction p=new MultiTargetRegressionPrediction(1);
+		Prediction p = new MultiTargetRegressionPrediction(1);
 		p.setVotes(classVotes);
 		addResult(example, p);
 	}
diff --git a/moa/src/main/java/moa/evaluation/evaluators/BasicRegressionPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/evaluators/BasicRegressionPerformanceEvaluator.java
new file mode 100644
index 000000000..a6a383c16
--- /dev/null
+++ b/moa/src/main/java/moa/evaluation/evaluators/BasicRegressionPerformanceEvaluator.java
@@ -0,0 +1,130 @@
+/*
+ *    BasicRegressionPerformanceEvaluator.java
+ *    Copyright (C) 2011 University of Waikato, Hamilton, New Zealand
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.evaluation.evaluators;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.AbstractMOAObject;
+import moa.core.Example;
+import moa.core.Measurement;
+
+/**
+ * Regression evaluator that performs basic incremental evaluation.
+ *
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @version $Revision: 7 $
+ */
+public class BasicRegressionPerformanceEvaluator extends AbstractMOAObject implements RegressionPerformanceEvaluator {
+
+	private static final long serialVersionUID = 1L;
+
+	protected double weightObserved;
+
+	protected double squareError;
+
+	protected double averageError;
+
+	protected double sumTarget;
+
+	protected double squareTargetError;
+
+	protected double averageTargetError;
+
+	@Override
+	public void reset() {
+		this.weightObserved = 0.0;
+		this.squareError = 0.0;
+		this.averageError = 0.0;
+		this.sumTarget = 0.0;
+		this.averageTargetError = 0.0;
+		this.squareTargetError = 0.0;
+
+	}
+
+	@Override
+	public void addResult(Example<Instance> example, double[] prediction) {
+		Instance inst = example.getData();
+		if (inst.weight() > 0.0) {
+			if (prediction.length > 0) {
+				double meanTarget = this.weightObserved != 0 ? this.sumTarget / this.weightObserved : 0.0;
+				this.squareError += (inst.classValue() - prediction[0]) * (inst.classValue() - prediction[0]);
+				this.averageError += Math.abs(inst.classValue() - prediction[0]);
+				this.squareTargetError += (inst.classValue() - meanTarget) * (inst.classValue() - meanTarget);
+				this.averageTargetError += Math.abs(inst.classValue() - meanTarget);
+				this.sumTarget += inst.classValue();
+				this.weightObserved += inst.weight();
+			}
+			// System.out.println(inst.classValue()+", "+prediction[0]);
+		}
+	}
+
+	@Override
+	public Measurement[] getPerformanceMeasurements() {
+		return new Measurement[] { new Measurement("classified instances", getTotalWeightObserved()),
+				new Measurement("mean absolute error", getMeanError()),
+				new Measurement("root mean squared error", getSquareError()),
+				new Measurement("relative mean absolute error", getRelativeMeanError()),
+				new Measurement("relative root mean squared error", getRelativeSquareError()) };
+	}
+
+	public double getTotalWeightObserved() {
+		return this.weightObserved;
+	}
+
+	public double getMeanError() {
+		return this.weightObserved > 0.0 ? this.averageError / this.weightObserved : 0.0;
+	}
+
+	public double getSquareError() {
+		return Math.sqrt(this.weightObserved > 0.0 ? this.squareError / this.weightObserved : 0.0);
+	}
+
+	public double getTargetMeanError() {
+		return this.weightObserved > 0.0 ? this.averageTargetError / this.weightObserved : 0.0;
+	}
+
+	public double getTargetSquareError() {
+		return Math.sqrt(this.weightObserved > 0.0 ? this.squareTargetError / this.weightObserved : 0.0);
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		Measurement.getMeasurementsDescription(getPerformanceMeasurements(), sb, indent);
+	}
+
+	private double getRelativeMeanError() {
+		// double targetMeanError = getTargetMeanError();
+		// return targetMeanError > 0 ? getMeanError()/targetMeanError : 0.0;
+		return this.averageTargetError > 0 ? this.averageError / this.averageTargetError : 0.0;
+	}
+
+	private double getRelativeSquareError() {
+		// double targetSquareError = getTargetSquareError();
+		// return targetSquareError > 0 ? getSquareError()/targetSquareError : 0.0;
+		return Math.sqrt(this.squareTargetError > 0 ? this.squareError / this.squareTargetError : 0.0);
+	}
+
+	@Override
+	public void addResult(Example<Instance> example, Prediction prediction) {
+		if (prediction != null)
+			addResult(example, prediction.asDoubleArray());
+	}
+}
diff --git a/moa/src/main/java/moa/evaluation/ClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/evaluators/ClassificationPerformanceEvaluator.java
similarity index 96%
rename from moa/src/main/java/moa/evaluation/ClassificationPerformanceEvaluator.java
rename to moa/src/main/java/moa/evaluation/evaluators/ClassificationPerformanceEvaluator.java
index d1a6ba878..5fa5c3d85 100644
--- a/moa/src/main/java/moa/evaluation/ClassificationPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/evaluators/ClassificationPerformanceEvaluator.java
@@ -15,9 +15,9 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.evaluation;
+package moa.evaluation.evaluators;
 
 import com.yahoo.labs.samoa.instances.Instance;
 
diff --git a/moa/src/main/java/moa/evaluation/EWMAClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/evaluators/EWMAClassificationPerformanceEvaluator.java
similarity index 57%
rename from moa/src/main/java/moa/evaluation/EWMAClassificationPerformanceEvaluator.java
rename to moa/src/main/java/moa/evaluation/evaluators/EWMAClassificationPerformanceEvaluator.java
index 04a33adf2..100f63fd5 100644
--- a/moa/src/main/java/moa/evaluation/EWMAClassificationPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/evaluators/EWMAClassificationPerformanceEvaluator.java
@@ -15,52 +15,53 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.evaluation;
+package moa.evaluation.evaluators;
 
 import com.github.javacliparser.FloatOption;
 
 /**
- * Classification evaluator that updates evaluation results using an Exponential Weighted Moving Average.
+ * Classification evaluator that updates evaluation results using an Exponential
+ * Weighted Moving Average.
  *
  * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
  * @version $Revision: 7 $
  */
 public class EWMAClassificationPerformanceEvaluator extends BasicClassificationPerformanceEvaluator {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public FloatOption alphaOption = new FloatOption("alpha",
-            'a', "Fading factor or exponential smoothing factor", .01);
+	public FloatOption alphaOption = new FloatOption("alpha", 'a', "Fading factor or exponential smoothing factor",
+			.01);
 
-    @Override
-    protected Estimator newEstimator() {
-        return new EWMAEstimator(this.alphaOption.getValue());
-    }
+	@Override
+	protected Estimator newEstimator() {
+		return new EWMAEstimator(this.alphaOption.getValue());
+	}
 
-    protected Estimator weightCorrect;
+	protected Estimator weightCorrect;
 
-    public class EWMAEstimator implements Estimator {
+	public class EWMAEstimator implements Estimator {
 
-        protected double alpha;
+		protected double alpha;
 
-        protected double estimation;
+		protected double estimation;
 
-        public EWMAEstimator(double a) {
-            alpha = a;
-            estimation = 0;
-        }
+		public EWMAEstimator(double a) {
+			alpha = a;
+			estimation = 0;
+		}
 
-        @Override
-        public void add(double value) {
-            estimation += alpha * (value - estimation);
-        }
+		@Override
+		public void add(double value) {
+			estimation += alpha * (value - estimation);
+		}
 
-        @Override
-        public double estimation() {
-            return estimation;
-        }
+		@Override
+		public double estimation() {
+			return estimation;
+		}
 
-    }
+	}
 }
diff --git a/moa/src/main/java/moa/evaluation/FadingFactorClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/evaluators/FadingFactorClassificationPerformanceEvaluator.java
similarity index 50%
rename from moa/src/main/java/moa/evaluation/FadingFactorClassificationPerformanceEvaluator.java
rename to moa/src/main/java/moa/evaluation/evaluators/FadingFactorClassificationPerformanceEvaluator.java
index aa628456a..2c3e8450f 100644
--- a/moa/src/main/java/moa/evaluation/FadingFactorClassificationPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/evaluators/FadingFactorClassificationPerformanceEvaluator.java
@@ -15,66 +15,67 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.evaluation;
+package moa.evaluation.evaluators;
+
+import com.github.javacliparser.FloatOption;
 
 import moa.capabilities.Capability;
 import moa.capabilities.ImmutableCapabilities;
 
-import com.github.javacliparser.FloatOption;
-
 /**
- * Classification evaluator that updates evaluation results using a fading factor.
+ * Classification evaluator that updates evaluation results using a fading
+ * factor.
  *
  * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
  * @version $Revision: 7 $
  */
 public class FadingFactorClassificationPerformanceEvaluator extends BasicClassificationPerformanceEvaluator {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public FloatOption alphaOption = new FloatOption("alpha",
-            'a', "Fading factor or exponential smoothing factor", .999);
+	public FloatOption alphaOption = new FloatOption("alpha", 'a', "Fading factor or exponential smoothing factor",
+			.999);
 
-    @Override
-    protected Estimator newEstimator() {
-        return new FadingFactorEstimator(this.alphaOption.getValue());
-    }
+	@Override
+	protected Estimator newEstimator() {
+		return new FadingFactorEstimator(this.alphaOption.getValue());
+	}
 
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == FadingFactorClassificationPerformanceEvaluator.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == FadingFactorClassificationPerformanceEvaluator.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
 
-    public class FadingFactorEstimator implements Estimator {
+	public class FadingFactorEstimator implements Estimator {
 
-        protected double alpha;
+		protected double alpha;
 
-        protected double estimation;
+		protected double estimation;
 
-        protected double b;
+		protected double b;
 
-        public FadingFactorEstimator(double a) {
-            alpha = a;
-            estimation = 0.0;
-            b = 0.0;
-        }
+		public FadingFactorEstimator(double a) {
+			alpha = a;
+			estimation = 0.0;
+			b = 0.0;
+		}
 
-        @Override
-        public void add(double value) {
-            estimation = alpha * estimation + value;
-            b = alpha * b + 1.0;
-        }
+		@Override
+		public void add(double value) {
+			estimation = alpha * estimation + value;
+			b = alpha * b + 1.0;
+		}
 
-        @Override
-        public double estimation() {
-            return b > 0.0 ? estimation / b : 0;
-        }
+		@Override
+		public double estimation() {
+			return b > 0.0 ? estimation / b : 0;
+		}
 
-    }
+	}
 
 }
diff --git a/moa/src/main/java/moa/evaluation/LearningPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/evaluators/LearningPerformanceEvaluator.java
similarity index 58%
rename from moa/src/main/java/moa/evaluation/LearningPerformanceEvaluator.java
rename to moa/src/main/java/moa/evaluation/evaluators/LearningPerformanceEvaluator.java
index 306d25a50..88e09beec 100644
--- a/moa/src/main/java/moa/evaluation/LearningPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/evaluators/LearningPerformanceEvaluator.java
@@ -15,9 +15,9 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.evaluation;
+package moa.evaluation.evaluators;
 
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
@@ -29,42 +29,43 @@
 import moa.core.Measurement;
 
 /**
- * Interface implemented by learner evaluators to monitor
- * the results of the learning process.
+ * Interface implemented by learner evaluators to monitor the results of the
+ * learning process.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
 public interface LearningPerformanceEvaluator<E extends Example> extends MOAObject, CapabilitiesHandler {
 
-    /**
-     * Resets this evaluator. It must be similar to
-     * starting a new evaluator from scratch.
-     *
-     */
-	public void reset();
+	/**
+	 * Resets this evaluator. It must be similar to starting a new evaluator from
+	 * scratch.
+	 *
+	 */
+	void reset();
+
+	/**
+	 * Adds a learning result to this evaluator.
+	 *
+	 * @param example    the example to be classified
+	 * @param classVotes an array containing the estimated membership probabilities
+	 *                   of the test instance in each class
+	 * @return an array of measurements monitored in this evaluator
+	 */
+	void addResult(E example, double[] classVotes);
 
-   /**
-     * Adds a learning result to this evaluator.
-     *
-     * @param example the example to be classified
-     * @param classVotes an array containing the estimated membership
-     * probabilities of the test instance in each class
-     * @return an array of measurements monitored in this evaluator
-     */
-    public void addResult(E example, double[] classVotes);
-    public void addResult(E testInst, Prediction prediction);
+	void addResult(E testInst, Prediction prediction);
 
-    /**
-     * Gets the current measurements monitored by this evaluator.
-     *
-     * @return an array of measurements monitored by this evaluator
-     */
-	public Measurement[] getPerformanceMeasurements();
+	/**
+	 * Gets the current measurements monitored by this evaluator.
+	 *
+	 * @return an array of measurements monitored by this evaluator
+	 */
+	Measurement[] getPerformanceMeasurements();
 
 	@Override
 	default ImmutableCapabilities defineImmutableCapabilities() {
-	  return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+		return new ImmutableCapabilities(Capability.VIEW_STANDARD);
 	}
 
 }
diff --git a/moa/src/main/java/moa/evaluation/MultiLabelClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/evaluators/MultiLabelClassificationPerformanceEvaluator.java
similarity index 88%
rename from moa/src/main/java/moa/evaluation/MultiLabelClassificationPerformanceEvaluator.java
rename to moa/src/main/java/moa/evaluation/evaluators/MultiLabelClassificationPerformanceEvaluator.java
index f7eba97c4..a6b55ccd1 100644
--- a/moa/src/main/java/moa/evaluation/MultiLabelClassificationPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/evaluators/MultiLabelClassificationPerformanceEvaluator.java
@@ -15,23 +15,21 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.evaluation;
+package moa.evaluation.evaluators;
 
 import com.yahoo.labs.samoa.instances.Instance;
 
 import moa.core.Example;
 
-
 /**
- * Interface implemented by learner evaluators to monitor
- * the results of the regression learning process.
+ * Interface implemented by learner evaluators to monitor the results of the
+ * regression learning process.
  *
  * @author João Duarte (joaomaiaduarte@gmail.com)
  * @version $Revision: 7 $
  */
 public interface MultiLabelClassificationPerformanceEvaluator extends LearningPerformanceEvaluator<Example<Instance>> {
 
-    
 }
diff --git a/moa/src/main/java/moa/evaluation/evaluators/MultiLabelWindowClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/evaluators/MultiLabelWindowClassificationPerformanceEvaluator.java
new file mode 100644
index 000000000..c6f8d63a3
--- /dev/null
+++ b/moa/src/main/java/moa/evaluation/evaluators/MultiLabelWindowClassificationPerformanceEvaluator.java
@@ -0,0 +1,147 @@
+/*
+ *    ClassificationPerformanceEvaluator.java
+ *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
+ *    @author Jesse Read (jesse@tsc.uc3m.es)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.evaluation.evaluators;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Example;
+import moa.core.Measurement;
+
+/**
+ * Multilabel Window Classification Performance Evaluator.
+ *
+ * @author Jesse Read (jesse@tsc.uc3m.es)
+ * @version $Revision: 1 $
+ */
+public class MultiLabelWindowClassificationPerformanceEvaluator extends WindowClassificationPerformanceEvaluator
+		implements MultiLabelClassificationPerformanceEvaluator {
+
+	/** running sum of accuracy */
+	double sumAccuracy = 0.0;
+	double sumHamming = 0.0;
+
+	/** running number of examples */
+	int sumExamples = 0;
+
+	/** preset threshold */
+	private double t = 0.5;
+
+	@Override
+	public void reset() {
+		sumAccuracy = 0.0;
+		sumHamming = 0.0;
+		sumExamples = 0;
+	}
+
+	@Override
+	public void reset(int L) {
+		numClasses = L;
+		reset();
+	}
+
+	/**
+	 * Add a Result. NOTE: In theory, the size of y[] could change, although we do
+	 * not take into account this possibility *yet*. (for this, we would have to use
+	 * y[] differently, another format for y[] e.g. HashMap, or store more info in
+	 * x)
+	 */
+	@Override
+	public void addResult(Example<Instance> example, double[] p_y) {
+
+		// int L = example.numOutputAttributes(); // <-- doesn't work!
+		int L = p_y.length;
+
+		Instance x = example.getData();
+		if (p_y.length < 2) {
+			System.err.println("FATAL ERROR: Not enough labels, we've lost track of the number of labels.");
+			System.exit(1);
+		}
+
+		// System.out.println("------- new result -------------");
+		// System.out.println("x = "+x);
+		// System.out.println("p(y) = "+Arrays.toString(p_y));
+
+		// Threshold to binary output (optional)
+		int y[] = new int[L];
+		for (int j = 0; j < L; j++) {
+			y[j] = (p_y[j] > t) ? 1 : 0;
+		}
+		// System.out.println("y = "+Arrays.toString(y));
+
+		sumExamples++;
+		int correct = 0;
+		for (int j = 0; j < y.length; j++) {
+			// int y_true = //]example.valueOutputAttribute(j); // <-- doesn't work!
+			int y_true = (int) x.value(j);
+			// int y_pred = (p_y[j] > t) ? 1 : 0;
+			if (y_true == y[j])
+				correct++;
+		}
+
+		// Hamming Score
+		sumHamming += (correct / (double) L);
+
+		// Exact Match
+		if (correct == L)
+			sumAccuracy++;
+	}
+
+	@Override
+	public void addResult(Example<Instance> example, Prediction prediction) {
+
+		Instance inst = (Instance) example.getData();
+		if (inst.weight() > 0.0) {
+			int numberOutputs = inst.numOutputAttributes();
+			if (numberOutputs <= 1) {
+				System.err.println("FATAL ERROR: This is not a multi-label dataset!");
+				System.exit(1);
+			}
+			if (prediction.numOutputAttributes() == 0) {
+				System.err.println("FATAL ERROR: This is not a multi-label prediction!");
+				System.exit(1);
+			}
+			double[] result = new double[numberOutputs];
+			for (int i = 0; i < prediction.size(); i++) {
+				result[i] = prediction.getVote(i, 1);
+			}
+			addResult(example, result);
+		}
+		// System.out.println(inst.classValue()+", "+prediction);
+	}
+
+	@Override
+	public Measurement[] getPerformanceMeasurements() {
+
+		// gather measurements
+		Measurement m[] = new Measurement[] { new Measurement("Exact Match", sumAccuracy / sumExamples),
+				new Measurement("Hamming Score", sumHamming / sumExamples), };
+
+		// reset
+		reset();
+
+		return m;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		sb.append("Multi-label Window Classification Performance Evaluator");
+	}
+}
diff --git a/moa/src/main/java/moa/evaluation/MultiTargetRegressionPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/evaluators/MultiTargetRegressionPerformanceEvaluator.java
similarity index 88%
rename from moa/src/main/java/moa/evaluation/MultiTargetRegressionPerformanceEvaluator.java
rename to moa/src/main/java/moa/evaluation/evaluators/MultiTargetRegressionPerformanceEvaluator.java
index 1841dc827..eb0919f57 100644
--- a/moa/src/main/java/moa/evaluation/MultiTargetRegressionPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/evaluators/MultiTargetRegressionPerformanceEvaluator.java
@@ -15,23 +15,21 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.evaluation;
+package moa.evaluation.evaluators;
 
 import com.yahoo.labs.samoa.instances.Instance;
 
 import moa.core.Example;
 
-
 /**
- * Interface implemented by learner evaluators to monitor
- * the results of the regression learning process.
+ * Interface implemented by learner evaluators to monitor the results of the
+ * regression learning process.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
 public interface MultiTargetRegressionPerformanceEvaluator extends LearningPerformanceEvaluator<Example<Instance>> {
 
-    
 }
diff --git a/moa/src/main/java/moa/evaluation/RegressionPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/evaluators/RegressionPerformanceEvaluator.java
similarity index 88%
rename from moa/src/main/java/moa/evaluation/RegressionPerformanceEvaluator.java
rename to moa/src/main/java/moa/evaluation/evaluators/RegressionPerformanceEvaluator.java
index 78513adb7..6e1437dad 100644
--- a/moa/src/main/java/moa/evaluation/RegressionPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/evaluators/RegressionPerformanceEvaluator.java
@@ -15,23 +15,21 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.evaluation;
+package moa.evaluation.evaluators;
 
 import com.yahoo.labs.samoa.instances.Instance;
 
 import moa.core.Example;
 
-
 /**
- * Interface implemented by learner evaluators to monitor
- * the results of the regression learning process.
+ * Interface implemented by learner evaluators to monitor the results of the
+ * regression learning process.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
 public interface RegressionPerformanceEvaluator extends LearningPerformanceEvaluator<Example<Instance>> {
 
-    
 }
diff --git a/moa/src/main/java/moa/evaluation/WindowAUCImbalancedPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/evaluators/WindowAUCImbalancedPerformanceEvaluator.java
similarity index 66%
rename from moa/src/main/java/moa/evaluation/WindowAUCImbalancedPerformanceEvaluator.java
rename to moa/src/main/java/moa/evaluation/evaluators/WindowAUCImbalancedPerformanceEvaluator.java
index 82102f725..85d1fea6d 100644
--- a/moa/src/main/java/moa/evaluation/WindowAUCImbalancedPerformanceEvaluator.java
+++ b/moa/src/main/java/moa/evaluation/evaluators/WindowAUCImbalancedPerformanceEvaluator.java
@@ -14,9 +14,9 @@
  *    distributed under the License is distributed on an "AS IS" BASIS,
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
- *    limitations under the License.  
+ *    limitations under the License.
  */
-package moa.evaluation;
+package moa.evaluation.evaluators;
 
 import java.util.TreeSet;
 
@@ -34,45 +34,43 @@
 
 /**
  * Classification evaluator that updates evaluation results using a sliding
- * window. Performance measures designed for class imbalance problems.
- * Only to be used for binary classification problems with unweighted instances.
- * Class 0 - majority/negative examples, class 1 - minority, positive examples.
- * Prequential AUC calculation as described and analyzed in: D. Brzezinski,
- * J. Stefanowski, "Prequential AUC: Properties of the Area Under the ROC
- * Curve for Data Streams with Concept Drift", Knowledge and Information
- * Systems, 2017.
- * 
+ * window. Performance measures designed for class imbalance problems. Only to
+ * be used for binary classification problems with unweighted instances. Class 0
+ * - majority/negative examples, class 1 - minority, positive examples.
+ * Prequential AUC calculation as described and analyzed in: D. Brzezinski, J.
+ * Stefanowski, "Prequential AUC: Properties of the Area Under the ROC Curve for
+ * Data Streams with Concept Drift", Knowledge and Information Systems, 2017.
+ *
  * @author Dariusz Brzezinski (dbrzezinski at cs.put.poznan.pl)
  * @author Tomasz Pewinski
  */
-public class WindowAUCImbalancedPerformanceEvaluator extends
-		AbstractOptionHandler implements ClassificationPerformanceEvaluator {
+public class WindowAUCImbalancedPerformanceEvaluator extends AbstractOptionHandler
+		implements ClassificationPerformanceEvaluator {
 
 	private static final long serialVersionUID = 1L;
 
-	public IntOption widthOption = new IntOption("width", 'w',
-			"Size of Window", 500);
+	public IntOption widthOption = new IntOption("width", 'w', "Size of Window", 500);
 
 	protected double totalObservedInstances = 0;
 	private Estimator aucEstimator;
 	private SimpleEstimator weightMajorityClassifier;
 	protected int numClasses;
 
-    public class SimpleEstimator {
-        protected double len;
+	public class SimpleEstimator {
+		protected double len;
+
+		protected double sum;
 
-        protected double sum;
+		public void add(double value) {
+			sum += value;
+			len++;
+		}
 
-        public void add(double value) {
-            sum += value;
-            len++;
-        }
+		public double estimation() {
+			return sum / len;
+		}
+	}
 
-        public double estimation(){
-            return sum/len;
-        }
-    }
-	
 	public class Estimator {
 
 		public class Score implements Comparable<Score> {
@@ -82,8 +80,7 @@ public class Score implements Comparable<Score> {
 			protected double value;
 
 			/**
-			 * Age of example - position in the window where the example was
-			 * added
+			 * Age of example - position in the window where the example was added
 			 */
 			protected int posWindow;
 
@@ -94,13 +91,10 @@ public class Score implements Comparable<Score> {
 
 			/**
 			 * Constructor.
-			 * 
-			 * @param value
-			 *            score value
-			 * @param position
-			 *            score position in window (defines its age)
-			 * @param isPositive
-			 *            true if the example's true label is positive
+			 *
+			 * @param value      score value
+			 * @param position   score position in window (defines its age)
+			 * @param isPositive true if the example's true label is positive
 			 */
 			public Score(double value, int position, boolean isPositive) {
 				this.value = value;
@@ -115,17 +109,17 @@ public Score(double value, int position, boolean isPositive) {
 			public int compareTo(Score o) {
 				if (o.value < this.value) {
 					return -1;
-				} else if (o.value > this.value){
+				} else if (o.value > this.value) {
 					return 1;
 				} else {
 					if (!o.isPositive && this.isPositive) {
 						return -1;
-					} else if (o.isPositive && !this.isPositive){
+					} else if (o.isPositive && !this.isPositive) {
 						return 1;
 					} else {
 						if (o.posWindow > this.posWindow) {
 							return -1;
-						} else if (o.posWindow < this.posWindow){
+						} else if (o.posWindow < this.posWindow) {
 							return 1;
 						} else {
 							return 0;
@@ -133,19 +127,19 @@ public int compareTo(Score o) {
 					}
 				}
 			}
-			
+
 			@Override
 			public boolean equals(Object o) {
-				return (o instanceof Score) && ((Score)o).posWindow == this.posWindow;
+				return (o instanceof Score) && ((Score) o).posWindow == this.posWindow;
 			}
 		}
 
 		protected TreeSet<Score> sortedScores;
-		
+
 		protected TreeSet<Score> holdoutSortedScores;
 
 		protected Score[] window;
-		
+
 		protected double[] predictions;
 
 		protected int posWindow;
@@ -155,33 +149,33 @@ public boolean equals(Object o) {
 		protected double numPos;
 
 		protected double numNeg;
-		
+
 		protected double holdoutNumPos;
 
 		protected double holdoutNumNeg;
-		
+
 		protected double correctPredictions;
-		
+
 		protected double correctPositivePredictions;
-		
-	    protected double[] columnKappa;
 
-	    protected double[] rowKappa;
+		protected double[] columnKappa;
+
+		protected double[] rowKappa;
 
 		public Estimator(int sizeWindow) {
-			this.sortedScores = new TreeSet<Score>();
-			this.holdoutSortedScores = new TreeSet<Score>();
+			this.sortedScores = new TreeSet<>();
+			this.holdoutSortedScores = new TreeSet<>();
 			this.size = sizeWindow;
 			this.window = new Score[sizeWindow];
 			this.predictions = new double[sizeWindow];
-			
-	        this.rowKappa = new double[numClasses];
-	        this.columnKappa = new double[numClasses];
-	        for (int i = 0; i < numClasses; i++) {
-	            this.rowKappa[i] = 0.0;
-	            this.columnKappa[i] = 0.0;
-	        }
-			
+
+			this.rowKappa = new double[numClasses];
+			this.columnKappa = new double[numClasses];
+			for (int i = 0; i < numClasses; i++) {
+				this.rowKappa[i] = 0.0;
+				this.columnKappa[i] = 0.0;
+			}
+
 			this.posWindow = 0;
 			this.numPos = 0;
 			this.numNeg = 0;
@@ -192,49 +186,50 @@ public Estimator(int sizeWindow) {
 		}
 
 		public void add(double score, boolean isPositive, boolean correctPrediction) {
-            // // periodically update holdout evaluation
+			// // periodically update holdout evaluation
 			if (size > 0 && posWindow % this.size == 0) {
-				this.holdoutSortedScores = new TreeSet<Score>();
-				
+				this.holdoutSortedScores = new TreeSet<>();
+
 				for (Score s : this.sortedScores) {
 					this.holdoutSortedScores.add(s);
 				}
-				
+
 				this.holdoutNumPos = this.numPos;
 				this.holdoutNumNeg = this.numNeg;
 			}
-			
-			// // if the window is used and it's full			
+
+			// // if the window is used and it's full
 			if (size > 0 && posWindow >= this.size) {
 				// // remove the oldest example
 				sortedScores.remove(window[posWindow % size]);
 				correctPredictions -= predictions[posWindow % size];
 				correctPositivePredictions -= window[posWindow % size].isPositive ? predictions[posWindow % size] : 0;
-				
+
 				if (window[posWindow % size].isPositive) {
 					numPos--;
 				} else {
 					numNeg--;
 				}
-				
+
 				int oldestExampleTrueClass = window[posWindow % size].isPositive ? 1 : 0;
-	            int oldestExamplePredictedClass = predictions[posWindow % size] == 1.0 ? oldestExampleTrueClass : Math.abs(oldestExampleTrueClass - 1);  
-	            
+				int oldestExamplePredictedClass = predictions[posWindow % size] == 1.0 ? oldestExampleTrueClass
+						: Math.abs(oldestExampleTrueClass - 1);
+
 				this.rowKappa[oldestExamplePredictedClass] -= 1;
-	            this.columnKappa[oldestExampleTrueClass] -= 1;
+				this.columnKappa[oldestExampleTrueClass] -= 1;
 			}
-			
+
 			// // add new example
 			Score newScore = new Score(score, posWindow, isPositive);
 			sortedScores.add(newScore);
 			correctPredictions += correctPrediction ? 1 : 0;
 			correctPositivePredictions += correctPrediction && isPositive ? 1 : 0;
-			
-            int trueClass = isPositive ? 1 : 0;
-            int predictedClass = correctPrediction ? trueClass : Math.abs(trueClass - 1);    
-            this.rowKappa[predictedClass] += 1;
-            this.columnKappa[trueClass] += 1;
-			
+
+			int trueClass = isPositive ? 1 : 0;
+			int predictedClass = correctPrediction ? trueClass : Math.abs(trueClass - 1);
+			this.rowKappa[predictedClass] += 1;
+			this.columnKappa[trueClass] += 1;
+
 			if (newScore.isPositive) {
 				numPos++;
 			} else {
@@ -245,8 +240,9 @@ public void add(double score, boolean isPositive, boolean correctPrediction) {
 				window[posWindow % size] = newScore;
 				predictions[posWindow % size] = correctPrediction ? 1 : 0;
 			}
-			
-			//// posWindow needs to be always incremented to differentiate between examples in the red-black tree
+
+			//// posWindow needs to be always incremented to differentiate between examples
+			//// in the red-black tree
 			posWindow++;
 		}
 
@@ -255,32 +251,32 @@ public double getAUC() {
 			double c = 0;
 			double prevc = 0;
 			double lastPosScore = Double.MAX_VALUE;
-					
+
 			if (numPos == 0 || numNeg == 0) {
 				return 1;
 			}
-			
-			for (Score s : sortedScores){
-				if(s.isPositive) {			
+
+			for (Score s : sortedScores) {
+				if (s.isPositive) {
 					if (s.value != lastPosScore) {
 						prevc = c;
 						lastPosScore = s.value;
 					}
-					
+
 					c += 1;
 				} else {
 					if (s.value == lastPosScore) {
 						// tie
-						AUC += ((double)(c + prevc))/2.0;
+						AUC += (c + prevc) / 2.0;
 					} else {
 						AUC += c;
 					}
 				}
 			}
-			
+
 			return AUC / (numPos * numNeg);
 		}
-		
+
 		public double getHoldoutAUC() {
 			double AUC = 0;
 			double c = 0;
@@ -290,29 +286,29 @@ public double getHoldoutAUC() {
 			if (holdoutSortedScores.isEmpty()) {
 				return 0;
 			}
-			
+
 			if (holdoutNumPos == 0 || holdoutNumNeg == 0) {
 				return 1;
 			}
 
-			for (Score s : holdoutSortedScores){
-				if(s.isPositive) {
+			for (Score s : holdoutSortedScores) {
+				if (s.isPositive) {
 					if (s.value != lastPosScore) {
 						prevc = c;
 						lastPosScore = s.value;
 					}
-					
+
 					c += 1;
 				} else {
 					if (s.value == lastPosScore) {
 						// tie
-						AUC += ((double)(c + prevc))/2.0;
+						AUC += (c + prevc) / 2.0;
 					} else {
 						AUC += c;
 					}
 				}
 			}
-			
+
 			return AUC / (holdoutNumPos * holdoutNumNeg);
 		}
 
@@ -326,23 +322,23 @@ public double getScoredAUC() {
 			double R_plus, R_minus;
 			double lastPosScore = Double.MAX_VALUE;
 			double lastNegScore = Double.MAX_VALUE;
-			
+
 			if (numPos == 0 || numNeg == 0) {
 				return 1;
 			}
-			
-			for (Score s : sortedScores){
-				if(s.isPositive) {
+
+			for (Score s : sortedScores) {
+				if (s.isPositive) {
 					if (s.value != lastPosScore) {
 						prevc = c;
 						lastPosScore = s.value;
 					}
-					
+
 					c += s.value;
-					
+
 					if (s.value == lastNegScore) {
 						// tie
-						AOC += ((double)(r + prevr))/2.0;
+						AOC += (r + prevr) / 2.0;
 					} else {
 						AOC += r;
 					}
@@ -351,31 +347,31 @@ public double getScoredAUC() {
 						prevr = r;
 						lastNegScore = s.value;
 					}
-					
+
 					r += s.value;
-					
+
 					if (s.value == lastPosScore) {
 						// tie
-						AUC += ((double)(c + prevc))/2.0;
+						AUC += (c + prevc) / 2.0;
 					} else {
 						AUC += c;
 					}
 				}
 			}
-			
-			R_minus = (numPos*r - AOC)/(numPos * numNeg);
-			R_plus = (AUC)/(numPos * numNeg);		
+
+			R_minus = (numPos * r - AOC) / (numPos * numNeg);
+			R_plus = (AUC) / (numPos * numNeg);
 			return R_plus - R_minus;
 		}
-		
+
 		public double getRatio() {
-			if(numNeg == 0) {
+			if (numNeg == 0) {
 				return Double.MAX_VALUE;
 			} else {
-				return numPos/numNeg;
+				return numPos / numNeg;
 			}
 		}
-		
+
 		public double getAccuracy() {
 			if (size > 0) {
 				return totalObservedInstances > 0.0 ? correctPredictions / Math.min(size, totalObservedInstances) : 0.0;
@@ -383,36 +379,37 @@ public double getAccuracy() {
 				return totalObservedInstances > 0.0 ? correctPredictions / totalObservedInstances : 0.0;
 			}
 		}
-		
+
 		public double getKappa() {
-            double p0 = getAccuracy();
-            double pc = 0.0;
-            
-            if (size > 0) {
-	            for (int i = 0; i < numClasses; i++) {
-	                pc += (this.rowKappa[i]/Math.min(size, totalObservedInstances)) * (this.columnKappa[i]/Math.min(size, totalObservedInstances));
-	            }
-            } else {
-            	for (int i = 0; i < numClasses; i++) {
-	                pc += (this.rowKappa[i]/totalObservedInstances) * (this.columnKappa[i]/totalObservedInstances);
-	            }
-            }
-            return (p0 - pc) / (1.0 - pc);
-	    }
-		
-	    private double getKappaM() {
-            double p0 = getAccuracy();
-            double pc = weightMajorityClassifier.estimation();
-
-            return (p0 - pc) / (1.0 - pc);
-	    }
-		
+			double p0 = getAccuracy();
+			double pc = 0.0;
+
+			if (size > 0) {
+				for (int i = 0; i < numClasses; i++) {
+					pc += (this.rowKappa[i] / Math.min(size, totalObservedInstances))
+							* (this.columnKappa[i] / Math.min(size, totalObservedInstances));
+				}
+			} else {
+				for (int i = 0; i < numClasses; i++) {
+					pc += (this.rowKappa[i] / totalObservedInstances) * (this.columnKappa[i] / totalObservedInstances);
+				}
+			}
+			return (p0 - pc) / (1.0 - pc);
+		}
+
+		private double getKappaM() {
+			double p0 = getAccuracy();
+			double pc = weightMajorityClassifier.estimation();
+
+			return (p0 - pc) / (1.0 - pc);
+		}
+
 		public double getGMean() {
 			double positiveAccuracy = correctPositivePredictions / numPos;
 			double negativeAccuracy = (correctPredictions - correctPositivePredictions) / numNeg;
 			return Math.sqrt(positiveAccuracy * negativeAccuracy);
 		}
-		
+
 		public double getRecall() {
 			return correctPositivePredictions / numPos;
 		}
@@ -425,14 +422,12 @@ public void reset() {
 
 	public void reset(int numClasses) {
 		if (numClasses != 2) {
-			throw new RuntimeException(
-					"Too many classes ("
-							+ numClasses
-							+ "). AUC evaluation can be performed only for two-class problems!");
+			throw new RuntimeException("Too many classes (" + numClasses
+					+ "). AUC evaluation can be performed only for two-class problems!");
 		}
 
 		this.numClasses = numClasses;
-		
+
 		this.aucEstimator = new Estimator(this.widthOption.getValue());
 		this.weightMajorityClassifier = new SimpleEstimator();
 		this.totalObservedInstances = 0;
@@ -440,42 +435,42 @@ public void reset(int numClasses) {
 
 	@Override
 	public void addResult(Example<Instance> exampleInstance, double[] classVotes) {
-		InstanceImpl inst = (InstanceImpl)exampleInstance.getData();
+		InstanceImpl inst = (InstanceImpl) exampleInstance.getData();
 		double weight = inst.weight();
-		
-		if (inst.classIsMissing() == false){
+
+		if (inst.classIsMissing() == false) {
 			int trueClass = (int) inst.classValue();
-	
+
 			if (weight > 0.0) {
 				// // initialize evaluator
 				if (totalObservedInstances == 0) {
 					reset(inst.dataset().numClasses());
 				}
 				this.totalObservedInstances += 1;
-				
-				//// if classVotes has length == 1, then the negative (0) class got all the votes
+
+				//// if classVotes has length == 1, then the negative (0) class got all the
+				//// votes
 				Double normalizedVote = 0.0;
-				
+
 				//// normalize and add score
-				if(classVotes.length == 2) {
-					normalizedVote = classVotes[1]/(classVotes[0] + classVotes[1]);
+				if (classVotes.length == 2) {
+					normalizedVote = classVotes[1] / (classVotes[0] + classVotes[1]);
 				}
-				
-				if(normalizedVote.isNaN()){
+
+				if (normalizedVote.isNaN()) {
 					normalizedVote = 0.0;
 				}
-				
+
 				this.aucEstimator.add(normalizedVote, trueClass == 1, Utils.maxIndex(classVotes) == trueClass);
-				this.weightMajorityClassifier.add((this.aucEstimator.getRatio() <= 1 ? 0 : 1) == trueClass ? weight: 0);
+				this.weightMajorityClassifier
+						.add((this.aucEstimator.getRatio() <= 1 ? 0 : 1) == trueClass ? weight : 0);
 			}
 		}
 	}
 
 	@Override
 	public Measurement[] getPerformanceMeasurements() {
-		return new Measurement[] {
-				new Measurement("classified instances",
-						this.totalObservedInstances),			
+		return new Measurement[] { new Measurement("classified instances", this.totalObservedInstances),
 				new Measurement("AUC", this.aucEstimator.getAUC()),
 				new Measurement("sAUC", this.aucEstimator.getScoredAUC()),
 				new Measurement("Accuracy", this.aucEstimator.getAccuracy()),
@@ -484,19 +479,17 @@ public Measurement[] getPerformanceMeasurements() {
 				new Measurement("Pos/Neg ratio", this.aucEstimator.getRatio()),
 				new Measurement("G-Mean", this.aucEstimator.getGMean()),
 				new Measurement("Recall", this.aucEstimator.getRecall()),
-				new Measurement("KappaM", this.aucEstimator.getKappaM())};
+				new Measurement("KappaM", this.aucEstimator.getKappaM()) };
 
 	}
 
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
-		Measurement.getMeasurementsDescription(getPerformanceMeasurements(),
-				sb, indent);
+		Measurement.getMeasurementsDescription(getPerformanceMeasurements(), sb, indent);
 	}
 
 	@Override
-	public void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
+	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
 	}
 
 	public Estimator getAucEstimator() {
diff --git a/moa/src/main/java/moa/evaluation/evaluators/WindowClassificationPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/evaluators/WindowClassificationPerformanceEvaluator.java
new file mode 100644
index 000000000..32f5f9803
--- /dev/null
+++ b/moa/src/main/java/moa/evaluation/evaluators/WindowClassificationPerformanceEvaluator.java
@@ -0,0 +1,105 @@
+/*
+ *    WindowClassificationPerformanceEvaluator.java
+ *    Copyright (C) 2009 University of Waikato, Hamilton, New Zealand
+ *    @author Albert Bifet (abifet@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.evaluation.evaluators;
+
+import com.github.javacliparser.IntOption;
+
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
+
+/**
+ * Classification evaluator that updates evaluation results using a sliding
+ * window.
+ *
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @author Jean Paul Barddal (jpbarddal@gmail.com)
+ * @version $Revision: 8 $
+ *
+ *
+ */
+public class WindowClassificationPerformanceEvaluator extends BasicClassificationPerformanceEvaluator {
+
+	private static final long serialVersionUID = 1L;
+
+	public IntOption widthOption = new IntOption("width", 'w', "Size of Window", 1000);
+
+	@Override
+	protected Estimator newEstimator() {
+		return new WindowEstimator(this.widthOption.getValue());
+	}
+
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == WindowClassificationPerformanceEvaluator.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
+
+	public class WindowEstimator implements Estimator {
+
+		protected double[] window;
+
+		protected int posWindow;
+
+		protected int lenWindow;
+
+		protected int SizeWindow;
+
+		protected double sum;
+
+		protected double qtyNaNs;
+
+		public WindowEstimator(int sizeWindow) {
+			window = new double[sizeWindow];
+			SizeWindow = sizeWindow;
+			posWindow = 0;
+			lenWindow = 0;
+		}
+
+		@Override
+		public void add(double value) {
+			double forget = window[posWindow];
+			if (!Double.isNaN(forget)) {
+				sum -= forget;
+			} else
+				qtyNaNs--;
+			if (!Double.isNaN(value)) {
+				sum += value;
+			} else
+				qtyNaNs++;
+			window[posWindow] = value;
+			posWindow++;
+			if (posWindow == SizeWindow) {
+				posWindow = 0;
+			}
+			if (lenWindow < SizeWindow) {
+				lenWindow++;
+			}
+		}
+
+		@Override
+		public double estimation() {
+			return sum / (lenWindow - qtyNaNs);
+		}
+
+	}
+
+}
diff --git a/moa/src/main/java/moa/evaluation/evaluators/WindowMultiTargetRegressionPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/evaluators/WindowMultiTargetRegressionPerformanceEvaluator.java
new file mode 100644
index 000000000..ff05cc9a2
--- /dev/null
+++ b/moa/src/main/java/moa/evaluation/evaluators/WindowMultiTargetRegressionPerformanceEvaluator.java
@@ -0,0 +1,168 @@
+/*
+ *    WindowRegressionPerformanceEvaluator.java
+ *    Copyright (C) 2011 University of Waikato, Hamilton, New Zealand
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.evaluation.evaluators;
+
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Example;
+import moa.core.Measurement;
+import moa.core.ObjectRepository;
+import moa.options.AbstractOptionHandler;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Multi-target regression evaluator that updates evaluation results using a
+ * sliding window.
+ *
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @version $Revision: 7 $
+ */
+public class WindowMultiTargetRegressionPerformanceEvaluator extends AbstractOptionHandler
+		implements MultiTargetRegressionPerformanceEvaluator {
+
+	private static final long serialVersionUID = 1L;
+
+	public IntOption widthOption = new IntOption("width", 'w', "Size of Window", 1000);
+
+	protected double TotalweightObserved = 0;
+
+	protected Estimator weightObserved;
+
+	protected Estimator squareError;
+
+	protected Estimator averageError;
+
+	protected int numClasses;
+
+	protected int numberOutputs;
+
+	public class Estimator {
+
+		protected double[] window;
+
+		protected int posWindow;
+
+		protected int lenWindow;
+
+		protected int SizeWindow;
+
+		protected double sum;
+
+		public Estimator(int sizeWindow) {
+			window = new double[sizeWindow];
+			SizeWindow = sizeWindow;
+			posWindow = 0;
+		}
+
+		public void add(double value) {
+			sum -= window[posWindow];
+			sum += value;
+			window[posWindow] = value;
+			posWindow++;
+			if (posWindow == SizeWindow) {
+				posWindow = 0;
+			}
+		}
+
+		public double total() {
+			return sum;
+		}
+	}
+
+	/*
+	 * public void setWindowWidth(int w) { this.width = w; reset(); }
+	 */
+	@Override
+	public void reset() {
+		reset(this.numClasses);
+	}
+
+	public void reset(int numClasses) {
+		this.numClasses = numClasses;
+		this.weightObserved = new Estimator(this.widthOption.getValue());
+		this.squareError = new Estimator(this.widthOption.getValue());
+		this.averageError = new Estimator(this.widthOption.getValue());
+		this.TotalweightObserved = 0;
+	}
+
+	@Override
+	public void addResult(Example<Instance> example, double[] prediction) {
+	}
+
+	@Override
+	public Measurement[] getPerformanceMeasurements() {
+		return new Measurement[] { new Measurement("classified instances", getTotalWeightObserved()),
+				new Measurement("mean absolute error", getMeanError()),
+				new Measurement("root mean squared error", getSquareError()) };
+	}
+
+	public double getTotalWeightObserved() {
+		return this.weightObserved.total();
+	}
+
+	public double getMeanError() {
+		return this.weightObserved.total() > 0.0
+				? this.averageError.total() / (this.weightObserved.total() * this.numberOutputs)
+				: 0.0;
+	}
+
+	public double getSquareError() {
+		return Math.sqrt(this.weightObserved.total() > 0.0
+				? this.squareError.total() / (this.weightObserved.total() * this.numberOutputs)
+				: 0.0);
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		Measurement.getMeasurementsDescription(getPerformanceMeasurements(), sb, indent);
+	}
+
+	@Override
+	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+	}
+
+	@Override
+	public void addResult(Example<Instance> testInst, Prediction prediction) {
+		Instance inst = (Instance) testInst.getData();
+		double weight = inst.weight();
+		if (numberOutputs == 0) {
+			numberOutputs = inst.numOutputAttributes();
+		}
+		if (weight > 0.0) {
+			if (TotalweightObserved == 0) {
+				reset(inst.dataset().numClasses());
+			}
+			this.TotalweightObserved += weight;
+			this.weightObserved.add(weight);
+
+			if (prediction != null) {
+				for (int i = 0; i < numberOutputs; i++) {
+					double error = (inst.valueOutputAttribute(i) - prediction.getPrediction(i));
+					this.squareError.add(error * error);
+					this.averageError.add(Math.abs(error));
+				}
+			}
+			// System.out.println(inst.classValue()+", "+prediction[0]);
+		}
+
+	}
+}
diff --git a/moa/src/main/java/moa/evaluation/evaluators/WindowMultiTargetRegressionPerformanceRelativeMeasuresEvaluator.java b/moa/src/main/java/moa/evaluation/evaluators/WindowMultiTargetRegressionPerformanceRelativeMeasuresEvaluator.java
new file mode 100644
index 000000000..c38af14e5
--- /dev/null
+++ b/moa/src/main/java/moa/evaluation/evaluators/WindowMultiTargetRegressionPerformanceRelativeMeasuresEvaluator.java
@@ -0,0 +1,205 @@
+/*
+ *    WindowRegressionPerformanceEvaluator.java
+ *    Copyright (C) 2011 University of Waikato, Hamilton, New Zealand
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.evaluation.evaluators;
+
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Example;
+import moa.core.Measurement;
+import moa.core.ObjectRepository;
+import moa.options.AbstractOptionHandler;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Multi-target regression evaluator that updates evaluation results using a
+ * sliding window.
+ *
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @version $Revision: 7 $
+ */
+public class WindowMultiTargetRegressionPerformanceRelativeMeasuresEvaluator extends AbstractOptionHandler
+		implements MultiTargetRegressionPerformanceEvaluator {
+
+	private static final long serialVersionUID = 1L;
+
+	public IntOption widthOption = new IntOption("width", 'w', "Size of Window", 1000);
+
+	protected double TotalweightObserved = 0;
+
+	protected Estimator weightObserved;
+
+	protected Estimator[] squareError;
+
+	protected Estimator[] averageError;
+
+	protected Estimator[] averageErrorToTargetMean;
+
+	protected Estimator[] squareErrorToTargetMean;
+
+	protected Estimator[] sumY;
+
+	protected int numClasses;
+
+	protected int numberOutputs;
+
+	public class Estimator {
+
+		protected double[] window;
+
+		protected int posWindow;
+
+		protected int lenWindow;
+
+		protected int SizeWindow;
+
+		protected double sum;
+
+		public Estimator(int sizeWindow) {
+			window = new double[sizeWindow];
+			SizeWindow = sizeWindow;
+			posWindow = 0;
+		}
+
+		public void add(double value) {
+			sum -= window[posWindow];
+			sum += value;
+			window[posWindow] = value;
+			posWindow++;
+			if (posWindow == SizeWindow) {
+				posWindow = 0;
+			}
+		}
+
+		public double total() {
+			return sum;
+		}
+	}
+
+	/*
+	 * public void setWindowWidth(int w) { this.width = w; reset(); }
+	 */
+	@Override
+	public void reset() {
+		reset(this.numClasses);
+	}
+
+	public void reset(int numClasses) {
+		this.numClasses = numClasses;
+		this.weightObserved = new Estimator(this.widthOption.getValue());
+		this.TotalweightObserved = 0;
+	}
+
+	@Override
+	public void addResult(Example<Instance> example, double[] prediction) {
+	}
+
+	@Override
+	public Measurement[] getPerformanceMeasurements() {
+		return new Measurement[] { new Measurement("classified instances", getTotalWeightObserved()),
+				new Measurement("relative mean absolute error", getMeanError()),
+				new Measurement("relative root mean squared error", getSquareError()) };
+	}
+
+	public double getTotalWeightObserved() {
+		return this.weightObserved.total();
+	}
+
+	public double getMeanError() {
+		double error = 0;
+		if (this.weightObserved.total() > 0.0) {
+			for (int i = 0; i < this.averageError.length; i++) {
+				error += this.averageError[i].total() / this.averageErrorToTargetMean[i].total();
+			}
+			error /= this.averageError.length;
+		}
+		return error;
+	}
+
+	public double getSquareError() {
+		double error = 0;
+		if (this.weightObserved.total() > 0.0) {
+			for (int i = 0; i < this.squareError.length; i++) {
+				error += Math.sqrt(this.squareError[i].total() / this.squareErrorToTargetMean[i].total());
+			}
+			error /= this.squareError.length;
+		}
+		return error;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		Measurement.getMeasurementsDescription(getPerformanceMeasurements(), sb, indent);
+	}
+
+	@Override
+	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+	}
+
+	@Override
+	public void addResult(Example<Instance> testInst, Prediction prediction) {
+		Instance inst = testInst.getData();
+		if (this.squareError == null) {
+			this.squareError = new Estimator[inst.numOutputAttributes()];
+			this.averageError = new Estimator[inst.numOutputAttributes()];
+			this.averageErrorToTargetMean = new Estimator[inst.numOutputAttributes()];
+			this.squareErrorToTargetMean = new Estimator[inst.numOutputAttributes()];
+			this.sumY = new Estimator[inst.numOutputAttributes()];
+
+			for (int i = 0; i < inst.numOutputAttributes(); i++) {
+				this.averageError[i] = new Estimator(this.widthOption.getValue());
+				this.averageErrorToTargetMean[i] = new Estimator(this.widthOption.getValue());
+				this.squareError[i] = new Estimator(this.widthOption.getValue());
+				this.squareErrorToTargetMean[i] = new Estimator(this.widthOption.getValue());
+				this.sumY[i] = new Estimator(this.widthOption.getValue());
+			}
+		}
+
+		double weight = inst.weight();
+		if (numberOutputs == 0) {
+			numberOutputs = inst.numOutputAttributes();
+		}
+		if (weight > 0.0) {
+			if (TotalweightObserved == 0) {
+				reset(inst.dataset().numClasses());
+			}
+			this.TotalweightObserved += weight;
+			this.weightObserved.add(weight);
+
+			if (prediction != null) {
+				for (int i = 0; i < numberOutputs; i++) {
+					double error = (inst.valueOutputAttribute(i) - prediction.getPrediction(i));
+					this.sumY[i].add(inst.valueOutputAttribute(i));
+					double errorTM = (inst.valueOutputAttribute(i)
+							- this.sumY[i].total() / this.weightObserved.total());
+
+					this.averageErrorToTargetMean[i].add(Math.abs(errorTM));
+					this.squareErrorToTargetMean[i].add(errorTM * errorTM);
+
+					this.averageError[i].add(Math.abs(error));
+					this.squareError[i].add(error * error);
+				}
+			}
+			// System.out.println(inst.classValue()+", "+prediction[0]);
+		}
+
+	}
+}
diff --git a/moa/src/main/java/moa/evaluation/evaluators/WindowRegressionPerformanceEvaluator.java b/moa/src/main/java/moa/evaluation/evaluators/WindowRegressionPerformanceEvaluator.java
new file mode 100644
index 000000000..801b24e6d
--- /dev/null
+++ b/moa/src/main/java/moa/evaluation/evaluators/WindowRegressionPerformanceEvaluator.java
@@ -0,0 +1,162 @@
+/*
+ *    WindowRegressionPerformanceEvaluator.java
+ *    Copyright (C) 2011 University of Waikato, Hamilton, New Zealand
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.evaluation.evaluators;
+
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Example;
+import moa.core.Measurement;
+import moa.core.ObjectRepository;
+import moa.options.AbstractOptionHandler;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Regression evaluator that updates evaluation results using a sliding window.
+ *
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @version $Revision: 7 $
+ */
+public class WindowRegressionPerformanceEvaluator extends AbstractOptionHandler
+		implements RegressionPerformanceEvaluator {
+
+	private static final long serialVersionUID = 1L;
+
+	public IntOption widthOption = new IntOption("width", 'w', "Size of Window", 1000);
+
+	protected double TotalweightObserved = 0;
+
+	protected Estimator weightObserved;
+
+	protected Estimator squareError;
+
+	protected Estimator averageError;
+
+	protected int numClasses;
+
+	public class Estimator {
+
+		protected double[] window;
+
+		protected int posWindow;
+
+		protected int lenWindow;
+
+		protected int SizeWindow;
+
+		protected double sum;
+
+		public Estimator(int sizeWindow) {
+			window = new double[sizeWindow];
+			SizeWindow = sizeWindow;
+			posWindow = 0;
+		}
+
+		public void add(double value) {
+			sum -= window[posWindow];
+			sum += value;
+			window[posWindow] = value;
+			posWindow++;
+			if (posWindow == SizeWindow) {
+				posWindow = 0;
+			}
+		}
+
+		public double total() {
+			return sum;
+		}
+	}
+
+	/*
+	 * public void setWindowWidth(int w) { this.width = w; reset(); }
+	 */
+	@Override
+	public void reset() {
+		reset(this.numClasses);
+	}
+
+	public void reset(int numClasses) {
+		this.numClasses = numClasses;
+		this.weightObserved = new Estimator(this.widthOption.getValue());
+		this.squareError = new Estimator(this.widthOption.getValue());
+		this.averageError = new Estimator(this.widthOption.getValue());
+		this.TotalweightObserved = 0;
+	}
+
+	@Override
+	public void addResult(Example<Instance> example, double[] prediction) {
+		Instance inst = example.getData();
+		double weight = inst.weight();
+		if (weight > 0.0) {
+			if (TotalweightObserved == 0) {
+				reset(inst.dataset().numClasses());
+			}
+			this.TotalweightObserved += weight;
+			this.weightObserved.add(weight);
+
+			if (prediction.length > 0) {
+				this.squareError.add((inst.classValue() - prediction[0]) * (inst.classValue() - prediction[0]));
+				this.averageError.add(Math.abs(inst.classValue() - prediction[0]));
+			}
+			// System.out.println(inst.classValue()+", "+prediction[0]);
+		}
+	}
+
+	@Override
+	public Measurement[] getPerformanceMeasurements() {
+		return new Measurement[] { new Measurement("classified instances", getTotalWeightObserved()),
+				new Measurement("mean absolute error", getMeanError()),
+				new Measurement("root mean squared error", getSquareError()) };
+	}
+
+	public double getTotalWeightObserved() {
+		return this.weightObserved.total();
+	}
+
+	public double getMeanError() {
+		return this.weightObserved.total() > 0.0 ? this.averageError.total() / this.weightObserved.total() : 0.0;
+	}
+
+	public double getSquareError() {
+		return Math
+				.sqrt(this.weightObserved.total() > 0.0 ? this.squareError.total() / this.weightObserved.total() : 0.0);
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		Measurement.getMeasurementsDescription(getPerformanceMeasurements(), sb, indent);
+	}
+
+	@Override
+	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+	}
+
+	@Override
+	public void addResult(Example<Instance> testInst, Prediction prediction) {
+		double votes[];
+		if (prediction == null)
+			votes = new double[0];
+		else
+			votes = new double[] { prediction.asDouble() };
+		addResult(testInst, votes);
+
+	}
+}
diff --git a/moa/src/main/java/moa/evaluation/preview/LearningCurve.java b/moa/src/main/java/moa/evaluation/preview/LearningCurve.java
index 53703e148..7a99052fd 100644
--- a/moa/src/main/java/moa/evaluation/preview/LearningCurve.java
+++ b/moa/src/main/java/moa/evaluation/preview/LearningCurve.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.evaluation.preview;
 
@@ -35,125 +35,123 @@
  */
 public class LearningCurve extends Preview {
 
-    private static final long serialVersionUID = 1L;
-
-    protected List<String> measurementNames = new ArrayList<String>();
-
-    protected List<double[]> measurementValues = new ArrayList<double[]>();
-
-    Class<?> taskClass = null;
-    
-    public LearningCurve(String orderingMeasurementName) {
-        this.measurementNames.add(orderingMeasurementName);
-    }
-    
-    public LearningCurve(String orderingMeasurementName, Class<?> taskClass) {
-        this.measurementNames.add(orderingMeasurementName);
-        this.taskClass = taskClass;
-    }
-
-    public String getOrderingMeasurementName() {
-        return this.measurementNames.get(0);
-    }
-    
-    public void setData(
-    		List<String> measurementNames, 
-    		List<double[]> measurementValues) 
-    {
-    	this.measurementNames.clear();
-    	this.measurementValues.clear();
-    	
-    	this.measurementNames.addAll(measurementNames);
-    	this.measurementValues.addAll(measurementValues);
-    }
-
-    public void insertEntry(LearningEvaluation learningEvaluation) {
-        Measurement[] measurements = learningEvaluation.getMeasurements();
-        Measurement orderMeasurement = Measurement.getMeasurementNamed(
-                getOrderingMeasurementName(), measurements);
-        if (orderMeasurement == null) {
-            throw new IllegalArgumentException();
-        }
-        DoubleVector entryVals = new DoubleVector();
-        for (Measurement measurement : measurements) {
-            entryVals.setValue(addMeasurementName(measurement.getName()),
-                    measurement.getValue());
-        }
-        double orderVal = orderMeasurement.getValue();
-        int index = 0;
-        while ((index < this.measurementValues.size())
-                && (orderVal > this.measurementValues.get(index)[0])) {
-            index++;
-        }
-        this.measurementValues.add(index, entryVals.getArrayRef());
-    }
-
-    public int numEntries() {
-        return this.measurementValues.size();
-    }
-
-    protected int addMeasurementName(String name) {
-        int index = this.measurementNames.indexOf(name);
-        if (index < 0) {
-            index = this.measurementNames.size();
-            this.measurementNames.add(name);
-        }
-        return index;
-    }
-
-    public String headerToString() {
-        StringBuilder sb = new StringBuilder();
-        boolean first = true;
-        for (String name : this.measurementNames) {
-            if (!first) {
-                sb.append(',');
-            } else {
-                first = false;
-            }
-            sb.append(name);
-        }
-        return sb.toString();
-    }
-
-    public String entryToString(int entryIndex) {
-        StringBuilder sb = new StringBuilder();
-        double[] vals = this.measurementValues.get(entryIndex);
-        for (int i = 0; i < this.measurementNames.size(); i++) {
-            if (i > 0) {
-                sb.append(',');
-            }
-            if ((i >= vals.length) || Double.isNaN(vals[i])) {
-                sb.append('?');
-            } else {
-                sb.append(Double.toString(vals[i]));
-            }
-        }
-        return sb.toString();
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        sb.append(headerToString());
-        for (int i = 0; i < numEntries(); i++) {
-            StringUtils.appendNewlineIndented(sb, indent, entryToString(i));
-        }
-    }
-
-    public double getMeasurement(int entryIndex, int measurementIndex) {
-        return this.measurementValues.get(entryIndex)[measurementIndex];
-    }
-
-    public String getMeasurementName(int measurementIndex) {
-        return this.measurementNames.get(measurementIndex);
-    }
-
-    public int getMeasurementNameCount() {
-        return this.measurementNames.size();
-    }
-
-    public int getEntryMeasurementCount(int entryIdx) {
-        return this.measurementValues.get(entryIdx).length;
-    }
+	private static final long serialVersionUID = 1L;
+
+	protected List<String> measurementNames = new ArrayList<>();
+
+	protected List<double[]> measurementValues = new ArrayList<>();
+
+	Class<?> taskClass = null;
+
+	public LearningCurve(String orderingMeasurementName) {
+		this.measurementNames.add(orderingMeasurementName);
+	}
+
+	public LearningCurve(String orderingMeasurementName, Class<?> taskClass) {
+		this.measurementNames.add(orderingMeasurementName);
+		this.taskClass = taskClass;
+	}
+
+	public String getOrderingMeasurementName() {
+		return this.measurementNames.get(0);
+	}
+
+	public void setData(List<String> measurementNames, List<double[]> measurementValues) {
+		this.measurementNames.clear();
+		this.measurementValues.clear();
+
+		this.measurementNames.addAll(measurementNames);
+		this.measurementValues.addAll(measurementValues);
+	}
+
+	public void insertEntry(LearningEvaluation learningEvaluation) {
+		Measurement[] measurements = learningEvaluation.getMeasurements();
+		Measurement orderMeasurement = Measurement.getMeasurementNamed(getOrderingMeasurementName(), measurements);
+		if (orderMeasurement == null) {
+			throw new IllegalArgumentException();
+		}
+		DoubleVector entryVals = new DoubleVector();
+		for (Measurement measurement : measurements) {
+			entryVals.setValue(addMeasurementName(measurement.getName()), measurement.getValue());
+		}
+		double orderVal = orderMeasurement.getValue();
+		int index = 0;
+		while ((index < this.measurementValues.size()) && (orderVal > this.measurementValues.get(index)[0])) {
+			index++;
+		}
+		this.measurementValues.add(index, entryVals.getArrayRef());
+	}
+
+	@Override
+	public int numEntries() {
+		return this.measurementValues.size();
+	}
+
+	protected int addMeasurementName(String name) {
+		int index = this.measurementNames.indexOf(name);
+		if (index < 0) {
+			index = this.measurementNames.size();
+			this.measurementNames.add(name);
+		}
+		return index;
+	}
+
+	public String headerToString() {
+		StringBuilder sb = new StringBuilder();
+		boolean first = true;
+		for (String name : this.measurementNames) {
+			if (!first) {
+				sb.append(',');
+			} else {
+				first = false;
+			}
+			sb.append(name);
+		}
+		return sb.toString();
+	}
+
+	@Override
+	public String entryToString(int entryIndex) {
+		StringBuilder sb = new StringBuilder();
+		double[] vals = this.measurementValues.get(entryIndex);
+		for (int i = 0; i < this.measurementNames.size(); i++) {
+			if (i > 0) {
+				sb.append(',');
+			}
+			if ((i >= vals.length) || Double.isNaN(vals[i])) {
+				sb.append('?');
+			} else {
+				sb.append(Double.toString(vals[i]));
+			}
+		}
+		return sb.toString();
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		sb.append(headerToString());
+		for (int i = 0; i < numEntries(); i++) {
+			StringUtils.appendNewlineIndented(sb, indent, entryToString(i));
+		}
+	}
+
+	public double getMeasurement(int entryIndex, int measurementIndex) {
+		return this.measurementValues.get(entryIndex)[measurementIndex];
+	}
+
+	@Override
+	public String getMeasurementName(int measurementIndex) {
+		return this.measurementNames.get(measurementIndex);
+	}
+
+	@Override
+	public int getMeasurementNameCount() {
+		return this.measurementNames.size();
+	}
+
+	public int getEntryMeasurementCount(int entryIdx) {
+		return this.measurementValues.get(entryIdx).length;
+	}
 
 	@Override
 	public Class<?> getTaskClass() {
@@ -169,14 +167,10 @@ public double[] getEntryData(int entryIndex) {
 		// preallocate the array to store all measurements
 		double[] data = new double[numMeasurements];
 		// get measuements from the learning curve
-		for(int measurementIdx = 0; measurementIdx < numMeasurements; ++measurementIdx)
-		{
-			if(measurementIdx < numEntryMeasurements)
-			{
-				data[measurementIdx] = getMeasurement(entryIndex, measurementIdx);	
-			}
-			else
-			{
+		for (int measurementIdx = 0; measurementIdx < numMeasurements; ++measurementIdx) {
+			if (measurementIdx < numEntryMeasurements) {
+				data[measurementIdx] = getMeasurement(entryIndex, measurementIdx);
+			} else {
 				data[measurementIdx] = Double.NaN;
 			}
 		}
diff --git a/moa/src/main/java/moa/evaluation/preview/MeanPreviewCollection.java b/moa/src/main/java/moa/evaluation/preview/MeanPreviewCollection.java
index 539093c70..9241af85b 100644
--- a/moa/src/main/java/moa/evaluation/preview/MeanPreviewCollection.java
+++ b/moa/src/main/java/moa/evaluation/preview/MeanPreviewCollection.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.evaluation.preview;
 
@@ -24,7 +24,7 @@
 import java.util.List;
 
 /**
- * Class that holds separate {@link PreviewCollection}s for mean and standard 
+ * Class that holds separate {@link PreviewCollection}s for mean and standard
  * deviation values. The values can be calculated from a PreviewCollection that
  * contains the results of multiple runs for the same parameter configurations.
  *
@@ -32,341 +32,276 @@
  * @version $Revision: 1 $
  */
 public class MeanPreviewCollection {
-    
-    PreviewCollection<PreviewCollection<Preview>> origMultiRunPreviews;
-    PreviewCollection<Preview>                    meanPreviews;
-    PreviewCollection<Preview>                    stdPreviews;
-    
-    /**
-     * On creation of a MeanPreviewCollection, the mean Previews and 
-     * standard deviation Previews are calculated from the given 
-     * PreviewCollection by averaging the measurements for all entries over 
-     * the different runs that have been performed. 
-     * This results in a collection of mean Previews and a separate collection 
-     * of standard deviation Previews, both containing Previews for each 
-     * parameter configuration.
-     */
-    public MeanPreviewCollection(
-            PreviewCollection<PreviewCollection<Preview>> multiRunPreviews) 
-    {
-        this.origMultiRunPreviews = multiRunPreviews;
-        
-        // create new preview collections for mean and standard deviation
-        this.meanPreviews = new PreviewCollection<Preview>(
-                "mean preview entry id",
-                "parameter value id",
-                multiRunPreviews.taskClass,
-                multiRunPreviews.variedParamName,
-                multiRunPreviews.variedParamValues);
-        this.stdPreviews = new PreviewCollection<Preview>(
-                "mean preview entry id",
-                "parameter value id",
-                multiRunPreviews.taskClass,
-                multiRunPreviews.variedParamName,
-                multiRunPreviews.variedParamValues);
-        
-        // calculate maximum number of entries that each Preview can provide
-        int numFolds             = multiRunPreviews.subPreviews.size();
-        int numParamValues       = multiRunPreviews.variedParamValues.length;
-        int numEntriesPerPreview = 
-                multiRunPreviews.numEntries() / numFolds / numParamValues;
-                
-        for (int paramValue = 0; paramValue < numParamValues; paramValue++)
-        {
-            // construct mean and standard deviation Previews for this 
-            // parameter value
-            this.constructMeanStdPreviewsForParam(
-                    numEntriesPerPreview, numParamValues, paramValue);
-        }
-    }
-    
-    /**
-     * @return the PreviewCollection of mean values
-     */
-    public PreviewCollection<Preview> getMeanPreviews() {
-        return this.meanPreviews;
-    }
-    
-    /**
-     * @return the PreviewCollection of standard deviation values
-     */
-    public PreviewCollection<Preview> getStdPreviews() {
-        return this.stdPreviews;
-    }
-    
-    /**
-     * Construct the mean and standard deviation Previews for one specific 
-     * parameter value.
-     * 
-     * @param numEntriesPerPreview
-     * @param numParamValues
-     * @param paramValue
-     */
-    private void constructMeanStdPreviewsForParam(
-            int numEntriesPerPreview, 
-            int numParamValues, 
-            int paramValue) 
-    {
-        // calculate mean
-        List<double[]> meanParamMeasurements = calculateMeanMeasurementsForParam(
-                numEntriesPerPreview, numParamValues, paramValue);
-        
-        // calculate standard deviation
-        List<double[]> stdParamMeasurements = calculateStdMeasurementsForParam(
-                numEntriesPerPreview, 
-                numParamValues, 
-                paramValue,
-                meanParamMeasurements);
-        
-        // get actual measurement names (first four are only additional IDs)
-        String[] meanMeasurementNames = 
-                this.origMultiRunPreviews.getMeasurementNames();
-        meanMeasurementNames = Arrays.copyOfRange(
-                meanMeasurementNames, 4, meanMeasurementNames.length);
-        
-        // Create names for standard deviations.
-        // First name is used for indexing and remains unchanged. For the 
-        // remaining names, [std] is prepended to the original name.
-        String[] stdMeasurementNames = new String[meanMeasurementNames.length];
-        stdMeasurementNames[0] = meanMeasurementNames[0];
-        for (int m = 1; m < meanMeasurementNames.length; m++) {
-            stdMeasurementNames[m] = "[std] " + meanMeasurementNames[m];
-        }
-        
-        // wrap into LearningCurves
-        LearningCurve meanLearningCurve = 
-                new LearningCurve(meanMeasurementNames[0]);
-        meanLearningCurve.setData(
-                Arrays.asList(meanMeasurementNames), meanParamMeasurements);
-        LearningCurve stdLearningCurve = 
-                new LearningCurve(stdMeasurementNames[0]);
-        stdLearningCurve.setData(
-                Arrays.asList(stdMeasurementNames), stdParamMeasurements);
-        
-        // wrap into PreviewCollectionLearningCurveWrapper
-        Preview meanParamValuePreview = 
-                new PreviewCollectionLearningCurveWrapper(
-                        meanLearningCurve, 
-                        this.origMultiRunPreviews.taskClass);
-        Preview stdParamValuePreview = 
-                new PreviewCollectionLearningCurveWrapper(
-                        stdLearningCurve, 
-                        this.origMultiRunPreviews.taskClass);
-        
-        // store Previews in corresponding PreviewCollections
-        this.meanPreviews.setPreview(paramValue, meanParamValuePreview);
-        this.stdPreviews.setPreview(paramValue, stdParamValuePreview);
-    }
-    
-    /**
-     * Calculate the mean measurements for the given parameter value.
-     * 
-     * @param numEntriesPerPreview
-     * @param numParamValues
-     * @param paramValue
-     * @return List of mean measurement arrays
-     */
-    private List<double[]> calculateMeanMeasurementsForParam(
-            int numEntriesPerPreview,
-            int numParamValues,
-            int paramValue) 
-    {
-        List<double[]> paramMeasurementsSum  = 
-                new ArrayList<double[]>(numEntriesPerPreview);
-        List<double[]> meanParamMeasurements = 
-                new ArrayList<double[]>(numEntriesPerPreview);
-        
-        int numCompleteFolds = 0;
-        
-        // sum up measurement values
-        for (PreviewCollection<Preview> foldPreview : 
-             this.origMultiRunPreviews.subPreviews) 
-        {
-            // check if there is a preview for each parameter value
-            if (foldPreview.getPreviews().size() == numParamValues) {
-                numCompleteFolds++;
-                
-                Preview foldParamPreview = 
-                        foldPreview.getPreviews().get(paramValue);
-                
-                // add this Preview's measurements to the overall sum
-                this.addPreviewMeasurementsToSum(
-                        paramMeasurementsSum, 
-                        foldParamPreview, 
-                        numEntriesPerPreview);
-            }
-        }
-        
-        // divide sum by number of folds
-        for (int entryIdx = 0; entryIdx < numEntriesPerPreview; entryIdx++) {
-            double[] sumEntry  = paramMeasurementsSum.get(entryIdx);
-            double[] meanEntry = new double[sumEntry.length];
-            
-            // first measurement is used for indexing -> simply copy
-            meanEntry[0] = sumEntry[0];
-            
-            // calculate mean for remaining measurements
-            for (int m = 1; m < sumEntry.length; m++) {
-                meanEntry[m] = sumEntry[m] / numCompleteFolds;
-            }
-            
-            meanParamMeasurements.add(meanEntry);
-        }
-        
-        return meanParamMeasurements;
-    }
-    
-    /**
-     * Calculate the standard deviation measurements for the given parameter 
-     * value.
-     * 
-     * @param numEntriesPerPreview
-     * @param numParamValues
-     * @param paramValue
-     * @return List of standard deviation measurement arrays
-     */
-    private List<double[]> calculateStdMeasurementsForParam(
-            int            numEntriesPerPreview,
-            int            numParamValues,
-            int            paramValue,
-            List<double[]> meanParamMeasurements)
-    {
-        List<double[]> paramMeasurementsSquaredDiffSum = 
-                new ArrayList<double[]>(numEntriesPerPreview);
-        List<double[]> paramMeasurementsStd            = 
-                new ArrayList<double[]>(numEntriesPerPreview);
-        
-        int numCompleteFolds = 0;
-        
-        // sum up squared differences between measurements and mean values
-        for (PreviewCollection<Preview> foldPreview : 
-             this.origMultiRunPreviews.subPreviews) 
-        {
-            // check if there is a preview for each parameter value
-            if (foldPreview.getPreviews().size() == numParamValues) {
-                numCompleteFolds++;
-                
-                Preview foldParamPreview = 
-                        foldPreview.getPreviews().get(paramValue);
-                
-                // add this Preview's standardDeviations to the overall sum
-                this.addPreviewMeasurementSquaredDiffsToSum(
-                        meanParamMeasurements, 
-                        paramMeasurementsSquaredDiffSum,
-                        foldParamPreview, 
-                        numEntriesPerPreview);
-            }
-        }
-        
-        // divide sum by number of folds and take square root 
-        for (int entryIdx = 0; entryIdx < numEntriesPerPreview; entryIdx++) {
-            double[] sumEntry = paramMeasurementsSquaredDiffSum.get(entryIdx);
-            double[] stdEntry = new double[sumEntry.length];
-            
-            // first measurement is used for indexing -> simply copy
-            stdEntry[0] = sumEntry[0];
-            
-            // calculate standard deviation for remaining measurements
-            for (int m = 1; m < sumEntry.length; m++) {
-                if (numCompleteFolds > 1) {
-                    stdEntry[m] = Math.sqrt(sumEntry[m]/(numCompleteFolds-1));
-                }
-                else {
-                    stdEntry[m] = Math.sqrt(sumEntry[m]);
-                }
-            }
-            
-            paramMeasurementsStd.add(stdEntry);
-        }
-        
-        return paramMeasurementsStd;
-    }
-    
-    /**
-     * Add measurements from the given Preview to the overall sum.
-     * 
-     * @param measurementsSum
-     * @param preview
-     * @param numEntriesPerPreview
-     */
-    private void addPreviewMeasurementsToSum(
-            List<double[]> measurementsSum, 
-            Preview        preview, 
-            int            numEntriesPerPreview) 
-    {
-        List<double[]> previewMeasurements = preview.getData();
-        
-        // add values for each measurement in each entry
-        for (int entryIdx = 0; entryIdx < numEntriesPerPreview; entryIdx++) {
-            double[] previewEntry = previewMeasurements.get(entryIdx);
-            double[] sumEntry;
-            
-            if (measurementsSum.size() > entryIdx) {
-                sumEntry = measurementsSum.get(entryIdx);
-            }
-            else {
-                // initialize sum entry
-                sumEntry = new double[previewEntry.length];
-                measurementsSum.add(sumEntry);
-            }
-            
-            // first measurement is used for indexing
-            // -> simply copy from first preview
-            if (sumEntry[0] == 0.0) {
-                sumEntry[0] = previewEntry[0];
-            }
-            
-            // add measurements of current entry
-            for (int measure = 1; measure < sumEntry.length; measure++) {
-                sumEntry[measure] += previewEntry[measure];
-            }
-        }
-    }
-    
-    /**
-     * Add squared deviations from the mean value from the given Preview to the
-     * overall sum.
-     * 
-     * @param meanMeasurements
-     * @param measurementsSquaredDiffSum
-     * @param preview
-     * @param numEntriesPerPreview
-     */
-    private void addPreviewMeasurementSquaredDiffsToSum(
-            List<double[]> meanMeasurements, 
-            List<double[]> measurementsSquaredDiffSum, 
-            Preview        preview, 
-            int            numEntriesPerPreview)
-    {
-        List<double[]> previewMeasurements = preview.getData();
-        
-        // add standard deviation for each measurement in each entry
-        for (int entryIdx = 0; entryIdx < numEntriesPerPreview; entryIdx++) {
-            double[] meanEntry    = meanMeasurements.get(entryIdx);
-            double[] previewEntry = previewMeasurements.get(entryIdx);
-            double[] squaredDiffSumEntry;
-            
-            if (measurementsSquaredDiffSum.size() > entryIdx) {
-                squaredDiffSumEntry = measurementsSquaredDiffSum.get(entryIdx);
-            }
-            else {
-                // initialize sum entry
-                squaredDiffSumEntry = new double[previewEntry.length];
-                measurementsSquaredDiffSum.add(squaredDiffSumEntry);
-            }
-            
-            // first measurement is used for indexing
-            // -> simply copy from first preview
-            if (squaredDiffSumEntry[0] == 0.0) {
-                squaredDiffSumEntry[0] = previewEntry[0];
-            }
-            
-            // add squared differences for current entry
-            for (int m = 1; m < previewEntry.length; m++) {
-                double diff        = (meanEntry[m] - previewEntry[m]);
-                double squaredDiff = diff * diff;
-                squaredDiffSumEntry[m] += squaredDiff;
-            }
-        }
-    }
+
+	PreviewCollection<PreviewCollection<Preview>> origMultiRunPreviews;
+	PreviewCollection<Preview> meanPreviews;
+	PreviewCollection<Preview> stdPreviews;
+
+	/**
+	 * On creation of a MeanPreviewCollection, the mean Previews and standard
+	 * deviation Previews are calculated from the given PreviewCollection by
+	 * averaging the measurements for all entries over the different runs that have
+	 * been performed. This results in a collection of mean Previews and a separate
+	 * collection of standard deviation Previews, both containing Previews for each
+	 * parameter configuration.
+	 */
+	public MeanPreviewCollection(PreviewCollection<PreviewCollection<Preview>> multiRunPreviews) {
+		this.origMultiRunPreviews = multiRunPreviews;
+
+		// create new preview collections for mean and standard deviation
+		this.meanPreviews = new PreviewCollection<>("mean preview entry id", "parameter value id",
+				multiRunPreviews.taskClass, multiRunPreviews.variedParamName, multiRunPreviews.variedParamValues);
+		this.stdPreviews = new PreviewCollection<>("mean preview entry id", "parameter value id",
+				multiRunPreviews.taskClass, multiRunPreviews.variedParamName, multiRunPreviews.variedParamValues);
+
+		// calculate maximum number of entries that each Preview can provide
+		int numFolds = multiRunPreviews.subPreviews.size();
+		int numParamValues = multiRunPreviews.variedParamValues.length;
+		int numEntriesPerPreview = multiRunPreviews.numEntries() / numFolds / numParamValues;
+
+		for (int paramValue = 0; paramValue < numParamValues; paramValue++) {
+			// construct mean and standard deviation Previews for this
+			// parameter value
+			this.constructMeanStdPreviewsForParam(numEntriesPerPreview, numParamValues, paramValue);
+		}
+	}
+
+	/**
+	 * @return the PreviewCollection of mean values
+	 */
+	public PreviewCollection<Preview> getMeanPreviews() {
+		return this.meanPreviews;
+	}
+
+	/**
+	 * @return the PreviewCollection of standard deviation values
+	 */
+	public PreviewCollection<Preview> getStdPreviews() {
+		return this.stdPreviews;
+	}
+
+	/**
+	 * Construct the mean and standard deviation Previews for one specific parameter
+	 * value.
+	 * 
+	 * @param numEntriesPerPreview
+	 * @param numParamValues
+	 * @param paramValue
+	 */
+	private void constructMeanStdPreviewsForParam(int numEntriesPerPreview, int numParamValues, int paramValue) {
+		// calculate mean
+		List<double[]> meanParamMeasurements = calculateMeanMeasurementsForParam(numEntriesPerPreview, numParamValues,
+				paramValue);
+
+		// calculate standard deviation
+		List<double[]> stdParamMeasurements = calculateStdMeasurementsForParam(numEntriesPerPreview, numParamValues,
+				paramValue, meanParamMeasurements);
+
+		// get actual measurement names (first four are only additional IDs)
+		String[] meanMeasurementNames = this.origMultiRunPreviews.getMeasurementNames();
+		meanMeasurementNames = Arrays.copyOfRange(meanMeasurementNames, 4, meanMeasurementNames.length);
+
+		// Create names for standard deviations.
+		// First name is used for indexing and remains unchanged. For the
+		// remaining names, [std] is prepended to the original name.
+		String[] stdMeasurementNames = new String[meanMeasurementNames.length];
+		stdMeasurementNames[0] = meanMeasurementNames[0];
+		for (int m = 1; m < meanMeasurementNames.length; m++) {
+			stdMeasurementNames[m] = "[std] " + meanMeasurementNames[m];
+		}
+
+		// wrap into LearningCurves
+		LearningCurve meanLearningCurve = new LearningCurve(meanMeasurementNames[0]);
+		meanLearningCurve.setData(Arrays.asList(meanMeasurementNames), meanParamMeasurements);
+		LearningCurve stdLearningCurve = new LearningCurve(stdMeasurementNames[0]);
+		stdLearningCurve.setData(Arrays.asList(stdMeasurementNames), stdParamMeasurements);
+
+		// wrap into PreviewCollectionLearningCurveWrapper
+		Preview meanParamValuePreview = new PreviewCollectionLearningCurveWrapper(meanLearningCurve,
+				this.origMultiRunPreviews.taskClass);
+		Preview stdParamValuePreview = new PreviewCollectionLearningCurveWrapper(stdLearningCurve,
+				this.origMultiRunPreviews.taskClass);
+
+		// store Previews in corresponding PreviewCollections
+		this.meanPreviews.setPreview(paramValue, meanParamValuePreview);
+		this.stdPreviews.setPreview(paramValue, stdParamValuePreview);
+	}
+
+	/**
+	 * Calculate the mean measurements for the given parameter value.
+	 * 
+	 * @param numEntriesPerPreview
+	 * @param numParamValues
+	 * @param paramValue
+	 * @return List of mean measurement arrays
+	 */
+	private List<double[]> calculateMeanMeasurementsForParam(int numEntriesPerPreview, int numParamValues,
+			int paramValue) {
+		List<double[]> paramMeasurementsSum = new ArrayList<>(numEntriesPerPreview);
+		List<double[]> meanParamMeasurements = new ArrayList<>(numEntriesPerPreview);
+
+		int numCompleteFolds = 0;
+
+		// sum up measurement values
+		for (PreviewCollection<Preview> foldPreview : this.origMultiRunPreviews.subPreviews) {
+			// check if there is a preview for each parameter value
+			if (foldPreview.getPreviews().size() == numParamValues) {
+				numCompleteFolds++;
+
+				Preview foldParamPreview = foldPreview.getPreviews().get(paramValue);
+
+				// add this Preview's measurements to the overall sum
+				this.addPreviewMeasurementsToSum(paramMeasurementsSum, foldParamPreview, numEntriesPerPreview);
+			}
+		}
+
+		// divide sum by number of folds
+		for (int entryIdx = 0; entryIdx < numEntriesPerPreview; entryIdx++) {
+			double[] sumEntry = paramMeasurementsSum.get(entryIdx);
+			double[] meanEntry = new double[sumEntry.length];
+
+			// first measurement is used for indexing -> simply copy
+			meanEntry[0] = sumEntry[0];
+
+			// calculate mean for remaining measurements
+			for (int m = 1; m < sumEntry.length; m++) {
+				meanEntry[m] = sumEntry[m] / numCompleteFolds;
+			}
+
+			meanParamMeasurements.add(meanEntry);
+		}
+
+		return meanParamMeasurements;
+	}
+
+	/**
+	 * Calculate the standard deviation measurements for the given parameter value.
+	 * 
+	 * @param numEntriesPerPreview
+	 * @param numParamValues
+	 * @param paramValue
+	 * @return List of standard deviation measurement arrays
+	 */
+	private List<double[]> calculateStdMeasurementsForParam(int numEntriesPerPreview, int numParamValues,
+			int paramValue, List<double[]> meanParamMeasurements) {
+		List<double[]> paramMeasurementsSquaredDiffSum = new ArrayList<>(numEntriesPerPreview);
+		List<double[]> paramMeasurementsStd = new ArrayList<>(numEntriesPerPreview);
+
+		int numCompleteFolds = 0;
+
+		// sum up squared differences between measurements and mean values
+		for (PreviewCollection<Preview> foldPreview : this.origMultiRunPreviews.subPreviews) {
+			// check if there is a preview for each parameter value
+			if (foldPreview.getPreviews().size() == numParamValues) {
+				numCompleteFolds++;
+
+				Preview foldParamPreview = foldPreview.getPreviews().get(paramValue);
+
+				// add this Preview's standardDeviations to the overall sum
+				this.addPreviewMeasurementSquaredDiffsToSum(meanParamMeasurements, paramMeasurementsSquaredDiffSum,
+						foldParamPreview, numEntriesPerPreview);
+			}
+		}
+
+		// divide sum by number of folds and take square root
+		for (int entryIdx = 0; entryIdx < numEntriesPerPreview; entryIdx++) {
+			double[] sumEntry = paramMeasurementsSquaredDiffSum.get(entryIdx);
+			double[] stdEntry = new double[sumEntry.length];
+
+			// first measurement is used for indexing -> simply copy
+			stdEntry[0] = sumEntry[0];
+
+			// calculate standard deviation for remaining measurements
+			for (int m = 1; m < sumEntry.length; m++) {
+				if (numCompleteFolds > 1) {
+					stdEntry[m] = Math.sqrt(sumEntry[m] / (numCompleteFolds - 1));
+				} else {
+					stdEntry[m] = Math.sqrt(sumEntry[m]);
+				}
+			}
+
+			paramMeasurementsStd.add(stdEntry);
+		}
+
+		return paramMeasurementsStd;
+	}
+
+	/**
+	 * Add measurements from the given Preview to the overall sum.
+	 * 
+	 * @param measurementsSum
+	 * @param preview
+	 * @param numEntriesPerPreview
+	 */
+	private void addPreviewMeasurementsToSum(List<double[]> measurementsSum, Preview preview,
+			int numEntriesPerPreview) {
+		List<double[]> previewMeasurements = preview.getData();
+
+		// add values for each measurement in each entry
+		for (int entryIdx = 0; entryIdx < numEntriesPerPreview; entryIdx++) {
+			double[] previewEntry = previewMeasurements.get(entryIdx);
+			double[] sumEntry;
+
+			if (measurementsSum.size() > entryIdx) {
+				sumEntry = measurementsSum.get(entryIdx);
+			} else {
+				// initialize sum entry
+				sumEntry = new double[previewEntry.length];
+				measurementsSum.add(sumEntry);
+			}
+
+			// first measurement is used for indexing
+			// -> simply copy from first preview
+			if (sumEntry[0] == 0.0) {
+				sumEntry[0] = previewEntry[0];
+			}
+
+			// add measurements of current entry
+			for (int measure = 1; measure < sumEntry.length; measure++) {
+				sumEntry[measure] += previewEntry[measure];
+			}
+		}
+	}
+
+	/**
+	 * Add squared deviations from the mean value from the given Preview to the
+	 * overall sum.
+	 * 
+	 * @param meanMeasurements
+	 * @param measurementsSquaredDiffSum
+	 * @param preview
+	 * @param numEntriesPerPreview
+	 */
+	private void addPreviewMeasurementSquaredDiffsToSum(List<double[]> meanMeasurements,
+			List<double[]> measurementsSquaredDiffSum, Preview preview, int numEntriesPerPreview) {
+		List<double[]> previewMeasurements = preview.getData();
+
+		// add standard deviation for each measurement in each entry
+		for (int entryIdx = 0; entryIdx < numEntriesPerPreview; entryIdx++) {
+			double[] meanEntry = meanMeasurements.get(entryIdx);
+			double[] previewEntry = previewMeasurements.get(entryIdx);
+			double[] squaredDiffSumEntry;
+
+			if (measurementsSquaredDiffSum.size() > entryIdx) {
+				squaredDiffSumEntry = measurementsSquaredDiffSum.get(entryIdx);
+			} else {
+				// initialize sum entry
+				squaredDiffSumEntry = new double[previewEntry.length];
+				measurementsSquaredDiffSum.add(squaredDiffSumEntry);
+			}
+
+			// first measurement is used for indexing
+			// -> simply copy from first preview
+			if (squaredDiffSumEntry[0] == 0.0) {
+				squaredDiffSumEntry[0] = previewEntry[0];
+			}
+
+			// add squared differences for current entry
+			for (int m = 1; m < previewEntry.length; m++) {
+				double diff = (meanEntry[m] - previewEntry[m]);
+				double squaredDiff = diff * diff;
+				squaredDiffSumEntry[m] += squaredDiff;
+			}
+		}
+	}
 }
diff --git a/moa/src/main/java/moa/evaluation/preview/Preview.java b/moa/src/main/java/moa/evaluation/preview/Preview.java
index 49a15ce95..4b2bd1440 100644
--- a/moa/src/main/java/moa/evaluation/preview/Preview.java
+++ b/moa/src/main/java/moa/evaluation/preview/Preview.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.evaluation.preview;
 
@@ -30,7 +30,7 @@
  * @author Tuan Pham Minh (tuan.pham@ovgu.de)
  * @version $Revision: 1 $
  */
-public abstract class Preview extends AbstractMOAObject{
+public abstract class Preview extends AbstractMOAObject {
 	private static final long serialVersionUID = 1L;
 
 	// TODO add methods to return a 2D double array
@@ -45,7 +45,7 @@ public abstract class Preview extends AbstractMOAObject{
 	public abstract Class<?> getTaskClass();
 
 	public abstract double[] getEntryData(int entryIndex);
-	
+
 	public String[] getMeasurementNames() {
 		int numNames = getMeasurementNameCount();
 		String[] names = new String[numNames];
@@ -55,15 +55,14 @@ public String[] getMeasurementNames() {
 		return names;
 	}
 
-	public List<double[]> getData()
-	{
+	public List<double[]> getData() {
 		// create list to store all entries
 		List<double[]> data = new ArrayList<>();
 		// add all entries in the list above
-        for (int entryIdx = 0; entryIdx < numEntries(); entryIdx++) {
-            data.add(getEntryData(entryIdx));
-        }
-		
+		for (int entryIdx = 0; entryIdx < numEntries(); entryIdx++) {
+			data.add(getEntryData(entryIdx));
+		}
+
 		return data;
 	}
 }
diff --git a/moa/src/main/java/moa/evaluation/preview/PreviewCollection.java b/moa/src/main/java/moa/evaluation/preview/PreviewCollection.java
index 3cc31f6ed..fea43a701 100644
--- a/moa/src/main/java/moa/evaluation/preview/PreviewCollection.java
+++ b/moa/src/main/java/moa/evaluation/preview/PreviewCollection.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.evaluation.preview;
 
@@ -53,10 +53,9 @@ public class PreviewCollection<CollectionElementType extends Preview> extends Pr
 	String variedParamName;
 	// values for the varied parameter (can be null)
 	double[] variedParamValues;
-	
-	public PreviewCollection(String orderingName, String indexName, Class<?> taskClass, 
-			String variedParamName, double[] variedParamValues) 
-	{
+
+	public PreviewCollection(String orderingName, String indexName, Class<?> taskClass, String variedParamName,
+			double[] variedParamValues) {
 		this.orderingName = orderingName;
 		this.indexName = indexName;
 		requiredMeasurementNames = new ArrayList<>();
@@ -68,7 +67,7 @@ public PreviewCollection(String orderingName, String indexName, Class<?> taskCla
 		this.variedParamName = variedParamName;
 		this.variedParamValues = variedParamValues;
 	}
-	
+
 	public PreviewCollection(String orderingName, String indexName, Class<?> taskClass) {
 		this(orderingName, indexName, taskClass, null, null);
 	}
@@ -82,7 +81,7 @@ public void setPreview(int previewIndex, CollectionElementType preview) throws I
 			measurementNames = new ArrayList<>();
 			measurementNames.add(orderingName);
 			measurementNames.add(indexName);
-			
+
 			for (int i = 0; i < preview.getMeasurementNameCount(); ++i) {
 				String name = preview.getMeasurementName(i);
 				measurementNames.add(name);
@@ -100,10 +99,8 @@ public void setPreview(int previewIndex, CollectionElementType preview) throws I
 			}
 
 			// check if the new preview has more entries than the last one
-			if (subPreviews.get(previewIndex) == null ||
-				(subPreviews.get(previewIndex) != null && 
-				 preview.numEntries() > subPreviews.get(previewIndex).numEntries())) 
-			{
+			if (subPreviews.get(previewIndex) == null || (subPreviews.get(previewIndex) != null
+					&& preview.numEntries() > subPreviews.get(previewIndex).numEntries())) {
 				// set the smallest number of entries
 				minEntryNum = preview.numEntries();
 				for (int i = 0; i < subPreviews.size(); ++i) {
@@ -118,6 +115,7 @@ public void setPreview(int previewIndex, CollectionElementType preview) throws I
 		}
 	}
 
+	@Override
 	public int numEntries() {
 		// use the minimal number of entries to guarantee that all previews have
 		// enough values
@@ -163,6 +161,7 @@ public String entryToString(int subPreviewIndex, int interlacedEntryIndex) {
 		return sb.toString();
 	}
 
+	@Override
 	public void getDescription(StringBuilder sb, int indent) {
 		sb.append(headerToString());
 
@@ -222,19 +221,19 @@ public double[] getEntryData(int entryIndex) {
 
 		return entry;
 	}
-	
+
 	public String getOrderingName() {
 		return this.orderingName;
 	}
-	
+
 	public String getIndexName() {
 		return this.indexName;
 	}
-	
+
 	public String getVariedParamName() {
 		return this.variedParamName;
 	}
-	
+
 	public double[] getVariedParamValues() {
 		return this.variedParamValues;
 	}
diff --git a/moa/src/main/java/moa/evaluation/preview/PreviewCollectionLearningCurveWrapper.java b/moa/src/main/java/moa/evaluation/preview/PreviewCollectionLearningCurveWrapper.java
index d25a2176a..dcf1ab784 100644
--- a/moa/src/main/java/moa/evaluation/preview/PreviewCollectionLearningCurveWrapper.java
+++ b/moa/src/main/java/moa/evaluation/preview/PreviewCollectionLearningCurveWrapper.java
@@ -15,13 +15,13 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.evaluation.preview;
 
 /**
- * Class used to wrap LearningCurve so that it can be used in 
- * conjunction with a PreviewCollection
+ * Class used to wrap LearningCurve so that it can be used in conjunction with a
+ * PreviewCollection
  *
  * @author Tuan Pham Minh (tuan.pham@ovgu.de)
  * @version $Revision: 1 $
@@ -29,17 +29,16 @@
 public class PreviewCollectionLearningCurveWrapper extends Preview {
 
 	private static final long serialVersionUID = 1L;
-	
+
 	// the learning curve which should be wrapped
 	LearningCurve learningCurveToBeWrapped;
 	Class<?> taskClass;
-	
-	public PreviewCollectionLearningCurveWrapper(LearningCurve learningCurveToBeWrapped, Class<?> taskClass)
-	{
-		this.learningCurveToBeWrapped = learningCurveToBeWrapped;	
+
+	public PreviewCollectionLearningCurveWrapper(LearningCurve learningCurveToBeWrapped, Class<?> taskClass) {
+		this.learningCurveToBeWrapped = learningCurveToBeWrapped;
 		this.taskClass = taskClass;
 	}
-	
+
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
 		learningCurveToBeWrapped.getDescription(sb, indent);
@@ -65,7 +64,7 @@ public String entryToString(int entryIndex) {
 		return learningCurveToBeWrapped.entryToString(entryIndex);
 	}
 
-	public LearningCurve getLearningCurve( ) {
+	public LearningCurve getLearningCurve() {
 		return learningCurveToBeWrapped;
 	}
 
@@ -83,14 +82,10 @@ public double[] getEntryData(int entryIndex) {
 		// preallocate the array to store all measurements
 		double[] data = new double[numMeasurements];
 		// get measuements from the learning curve
-		for(int measurementIdx = 0; measurementIdx < numMeasurements; ++measurementIdx)
-		{
-			if(measurementIdx < numEntryMeasurements)
-			{
-				data[measurementIdx] = learningCurveToBeWrapped.getMeasurement(entryIndex, measurementIdx);	
-			}
-			else
-			{
+		for (int measurementIdx = 0; measurementIdx < numMeasurements; ++measurementIdx) {
+			if (measurementIdx < numEntryMeasurements) {
+				data[measurementIdx] = learningCurveToBeWrapped.getMeasurement(entryIndex, measurementIdx);
+			} else {
 				data[measurementIdx] = Double.NaN;
 			}
 		}
diff --git a/moa/src/main/java/moa/gui/ALTabPanel.java b/moa/src/main/java/moa/gui/ALTabPanel.java
index 215d25e66..47f12ffd0 100644
--- a/moa/src/main/java/moa/gui/ALTabPanel.java
+++ b/moa/src/main/java/moa/gui/ALTabPanel.java
@@ -17,7 +17,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
@@ -49,19 +49,17 @@ public ALTabPanel() {
 		add(this.previewPanel, BorderLayout.CENTER);
 	}
 
-	//returns the string to display as title of the tab
-    @Override
+	// returns the string to display as title of the tab
+	@Override
 	public String getTabTitle() {
 		return "Active Learning";
 	}
 
-	//a short description (can be used as tool tip) of the tab, or contributor, etc.
-    @Override
-	public String getDescription(){
+	// a short description (can be used as tool tip) of the tab, or contributor,
+	// etc.
+	@Override
+	public String getDescription() {
 		return "MOA Active Learning";
 	}
 
 }
-
-
-
diff --git a/moa/src/main/java/moa/gui/AWTInteractiveRenderer.java b/moa/src/main/java/moa/gui/AWTInteractiveRenderer.java
index aaf6fa427..6a4ff964a 100644
--- a/moa/src/main/java/moa/gui/AWTInteractiveRenderer.java
+++ b/moa/src/main/java/moa/gui/AWTInteractiveRenderer.java
@@ -15,12 +15,12 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
 // not used?
 public interface AWTInteractiveRenderer extends AWTRenderer {
 
-    public void mouseClicked(int pixelX, int pixelY);
+	void mouseClicked(int pixelX, int pixelY);
 }
diff --git a/moa/src/main/java/moa/gui/AWTRenderable.java b/moa/src/main/java/moa/gui/AWTRenderable.java
index a723a4b42..709cec4b3 100644
--- a/moa/src/main/java/moa/gui/AWTRenderable.java
+++ b/moa/src/main/java/moa/gui/AWTRenderable.java
@@ -15,17 +15,17 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
 /**
- * Interface representing a component that is renderable 
+ * Interface representing a component that is renderable
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $ 
+ * @version $Revision: 7 $
  */
 public interface AWTRenderable {
 
-    public AWTRenderer getAWTRenderer();
+	AWTRenderer getAWTRenderer();
 }
diff --git a/moa/src/main/java/moa/gui/AWTRenderer.java b/moa/src/main/java/moa/gui/AWTRenderer.java
index af947f22a..1d15c1bab 100644
--- a/moa/src/main/java/moa/gui/AWTRenderer.java
+++ b/moa/src/main/java/moa/gui/AWTRenderer.java
@@ -15,20 +15,19 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
 import java.awt.Graphics;
 
 /**
- * Interface representing a component to edit an option. 
+ * Interface representing a component to edit an option.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $ 
+ * @version $Revision: 7 $
  */
 public interface AWTRenderer {
 
-    public void renderAWTBox(Graphics g, int minPixelX, int minPixelY,
-            int maxPixelX, int maxPixelY);
+	void renderAWTBox(Graphics g, int minPixelX, int minPixelY, int maxPixelX, int maxPixelY);
 }
diff --git a/moa/src/main/java/moa/gui/AbstractTabPanel.java b/moa/src/main/java/moa/gui/AbstractTabPanel.java
index ecead4360..655e4721a 100644
--- a/moa/src/main/java/moa/gui/AbstractTabPanel.java
+++ b/moa/src/main/java/moa/gui/AbstractTabPanel.java
@@ -1,6 +1,6 @@
 /*
  *    AbstractTabPanel.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand 
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
  *    @author FracPete (fracpete at waikato dot ac dot nz)
  *
  *    This program is free software; you can redistribute it and/or modify
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
@@ -27,17 +27,18 @@
  */
 public abstract class AbstractTabPanel extends javax.swing.JPanel {
 
-    /**
-     * Returns the string to display as title of the tab.
-     * 
-     * @return the string to display as title of the tab
-     */
-    public abstract String getTabTitle();
+	/**
+	 * Returns the string to display as title of the tab.
+	 * 
+	 * @return the string to display as title of the tab
+	 */
+	public abstract String getTabTitle();
 
-    /**
-     * Returns a short description (can be used as tool tip) of the tab, or contributor, etc.
-     *
-     * @return a short description of this tab panel.
-     */
-    public abstract String getDescription();
+	/**
+	 * Returns a short description (can be used as tool tip) of the tab, or
+	 * contributor, etc.
+	 *
+	 * @return a short description of this tab panel.
+	 */
+	public abstract String getDescription();
 }
diff --git a/moa/src/main/java/moa/gui/AuxiliarTabPanel.java b/moa/src/main/java/moa/gui/AuxiliarTabPanel.java
index 5ab203004..62d5ba437 100644
--- a/moa/src/main/java/moa/gui/AuxiliarTabPanel.java
+++ b/moa/src/main/java/moa/gui/AuxiliarTabPanel.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
@@ -46,19 +46,17 @@ public AuxiliarTabPanel() {
 		add(this.previewPanel, BorderLayout.CENTER);
 	}
 
-	//returns the string to display as title of the tab
-    @Override
+	// returns the string to display as title of the tab
+	@Override
 	public String getTabTitle() {
 		return "Other Tasks";
 	}
 
-	//a short description (can be used as tool tip) of the tab, or contributor, etc.
-    @Override
-	public String getDescription(){
+	// a short description (can be used as tool tip) of the tab, or contributor,
+	// etc.
+	@Override
+	public String getDescription() {
 		return "MOA Auxiliars";
 	}
 
 }
-
-
-
diff --git a/moa/src/main/java/moa/gui/AuxiliarTaskManagerPanel.java b/moa/src/main/java/moa/gui/AuxiliarTaskManagerPanel.java
index e8c4a13f1..276d7124d 100644
--- a/moa/src/main/java/moa/gui/AuxiliarTaskManagerPanel.java
+++ b/moa/src/main/java/moa/gui/AuxiliarTaskManagerPanel.java
@@ -16,34 +16,10 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
-import moa.core.StringUtils;
-import moa.options.ClassOption;
-import moa.options.OptionHandler;
-import moa.tasks.MainTask;
-import moa.tasks.Task;
-import moa.tasks.TaskThread;
-import nz.ac.waikato.cms.gui.core.BaseFileChooser;
-
-import javax.swing.JButton;
-import javax.swing.JFrame;
-import javax.swing.JMenuItem;
-import javax.swing.JOptionPane;
-import javax.swing.JPanel;
-import javax.swing.JPopupMenu;
-import javax.swing.JProgressBar;
-import javax.swing.JScrollPane;
-import javax.swing.JTable;
-import javax.swing.JTextField;
-import javax.swing.SwingConstants;
-import javax.swing.event.ListSelectionEvent;
-import javax.swing.event.ListSelectionListener;
-import javax.swing.table.AbstractTableModel;
-import javax.swing.table.DefaultTableCellRenderer;
-import javax.swing.table.TableCellRenderer;
 import java.awt.BorderLayout;
 import java.awt.Component;
 import java.awt.Dimension;
@@ -63,9 +39,33 @@
 import java.util.List;
 import java.util.prefs.Preferences;
 
-import javax.swing.UIManager;
+import javax.swing.JButton;
+import javax.swing.JFileChooser;
+import javax.swing.JFrame;
+import javax.swing.JMenuItem;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JPopupMenu;
+import javax.swing.JProgressBar;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
+import javax.swing.JTextField;
+import javax.swing.SwingConstants;
+import javax.swing.event.ListSelectionEvent;
+import javax.swing.event.ListSelectionListener;
+import javax.swing.table.AbstractTableModel;
+import javax.swing.table.DefaultTableCellRenderer;
+import javax.swing.table.TableCellRenderer;
+
+import moa.core.StringUtils;
+import moa.options.ClassOption;
+import moa.options.OptionHandler;
+import moa.tasks.MainTask;
+import moa.tasks.Task;
+import moa.tasks.TaskThread;
 import moa.tasks.auxiliar.AuxiliarMainTask;
 import moa.tasks.auxiliar.WriteStreamToARFFFile;
+import nz.ac.waikato.cms.gui.core.BaseFileChooser;
 
 /**
  * This panel displays the running tasks.
@@ -74,449 +74,430 @@
  */
 public class AuxiliarTaskManagerPanel extends JPanel {
 
-    private static final long serialVersionUID = 1L;
-
-    public static final int MILLISECS_BETWEEN_REFRESH = 600;
-
-    public static String exportFileExtension = "log";
-
-    public class ProgressCellRenderer extends JProgressBar implements
-            TableCellRenderer {
-
-        private static final long serialVersionUID = 1L;
-
-        public ProgressCellRenderer() {
-            super(SwingConstants.HORIZONTAL, 0, 10000);
-            setBorderPainted(false);
-            setStringPainted(true);
-        }
-
-         @Override
-        public Component getTableCellRendererComponent(JTable table,
-                Object value, boolean isSelected, boolean hasFocus, int row,
-                int column) {
-            double frac = -1.0;
-            if (value instanceof Double) {
-                frac = ((Double) value).doubleValue();
-            }
-            if (frac >= 0.0) {
-                setIndeterminate(false);
-                setValue((int) (frac * 10000.0));
-                setString(StringUtils.doubleToString(frac * 100.0, 2, 2));
-            } else {
-                setValue(0);
-                //setIndeterminate(true);
-                //setString("?");
-            }
-            return this;
-        }
-
-        @Override
-        public void validate() {
-        }
-
-        @Override
-        public void revalidate() {
-        }
-
-        @Override
-        protected void firePropertyChange(String propertyName, Object oldValue,
-                Object newValue) {
-        }
-
-        @Override
-        public void firePropertyChange(String propertyName, boolean oldValue,
-                boolean newValue) {
-        }
-    }
-
-    protected class TaskTableModel extends AbstractTableModel {
-
-        private static final long serialVersionUID = 1L;
-
-        @Override
-        public String getColumnName(int col) {
-            switch (col) {
-                case 0:
-                    return "command";
-                case 1:
-                    return "status";
-                case 2:
-                    return "time elapsed";
-                case 3:
-                    return "current activity";
-                case 4:
-                    return "% complete";
-            }
-            return null;
-        }
-
-        @Override
-        public int getColumnCount() {
-            return 5;
-        }
-
-        @Override
-        public int getRowCount() {
-            return AuxiliarTaskManagerPanel.this.taskList.size();
-        }
-
-        @Override
-        public Object getValueAt(int row, int col) {
-            TaskThread thread = AuxiliarTaskManagerPanel.this.taskList.get(row);
-            switch (col) {
-                case 0:
-                    return ((OptionHandler) thread.getTask()).getCLICreationString(MainTask.class);
-                case 1:
-                    return thread.getCurrentStatusString();
-                case 2:
-                    return StringUtils.secondsToDHMSString(thread.getCPUSecondsElapsed());
-                case 3:
-                    return thread.getCurrentActivityString();
-                case 4:
-                    return new Double(thread.getCurrentActivityFracComplete());
-            }
-            return null;
-        }
-
-        @Override
-        public boolean isCellEditable(int row, int col) {
-            return false;
-        }
-    }
-
-    protected MainTask currentTask = new WriteStreamToARFFFile();//LearnModel();
-
-    protected List<TaskThread> taskList = new ArrayList<TaskThread>();
-
-    protected JButton configureTaskButton = new JButton("Configure");
-
-    protected JTextField taskDescField = new JTextField();
-
-    protected JButton runTaskButton = new JButton("Run");
-
-    protected TaskTableModel taskTableModel;
-
-    protected JTable taskTable;
-
-    protected JButton pauseTaskButton = new JButton("Pause");
-
-    protected JButton resumeTaskButton = new JButton("Resume");
-
-    protected JButton cancelTaskButton = new JButton("Cancel");
-
-    protected JButton deleteTaskButton = new JButton("Delete");
-
-    protected PreviewPanel previewPanel;
-
-    private Preferences prefs;
-
-    private final String PREF_NAME = "currentTask";
-
-    public AuxiliarTaskManagerPanel() {
-        // Read current task preference
-        prefs = Preferences.userRoot().node(this.getClass().getName());
-        currentTask = new WriteStreamToARFFFile();
-        String taskText = this.currentTask.getCLICreationString(MainTask.class);
-        String propertyValue = prefs.get(PREF_NAME, taskText);
-        //this.taskDescField.setText(propertyValue);
-        setTaskString(propertyValue, false); //Not store preference
-        this.taskDescField.setEditable(false);
-        
-        final Component comp = this.taskDescField;
-        this.taskDescField.addMouseListener(new MouseAdapter() {
-
-            @Override
-            public void mouseClicked(MouseEvent evt) {
-                if (evt.getClickCount() == 1) {
-                    if ((evt.getButton() == MouseEvent.BUTTON3)
-                            || ((evt.getButton() == MouseEvent.BUTTON1) && evt.isAltDown() && evt.isShiftDown())) {
-                        JPopupMenu menu = new JPopupMenu();
-                        JMenuItem item;
-
-                        item = new JMenuItem("Copy configuration to clipboard");
-                        item.addActionListener(new ActionListener() {
-
-                            @Override
-                            public void actionPerformed(ActionEvent e) {
-                                copyClipBoardConfiguration();
-                            }
-                        });
-                        menu.add(item);
-
-
-
-                        item = new JMenuItem("Save selected tasks to file");
-                        item.addActionListener(new ActionListener() {
-
-                            @Override
-                            public void actionPerformed(ActionEvent arg0) {
-                                saveLogSelectedTasks();
-                            }
-                        });
-                        menu.add(item);
-
-
-                        item = new JMenuItem("Enter configuration...");
-                        item.addActionListener(new ActionListener() {
-
-                            @Override
-                            public void actionPerformed(ActionEvent arg0) {
-                                String newTaskString = JOptionPane.showInputDialog("Insert command line");
-                                if (newTaskString != null) {
-                                    setTaskString(newTaskString);
-                                }
-                            }
-                        });
-                        menu.add(item);
-
-                        menu.show(comp, evt.getX(), evt.getY());
-                    }
-                }
-            }
-        });
-
-        JPanel configPanel = new JPanel();
-        configPanel.setLayout(new BorderLayout());
-        configPanel.add(this.configureTaskButton, BorderLayout.WEST);
-        configPanel.add(this.taskDescField, BorderLayout.CENTER);
-        configPanel.add(this.runTaskButton, BorderLayout.EAST);
-        this.taskTableModel = new TaskTableModel();
-        this.taskTable = new JTable(this.taskTableModel);
-        DefaultTableCellRenderer centerRenderer = new DefaultTableCellRenderer();
-        centerRenderer.setHorizontalAlignment(SwingConstants.CENTER);
-        this.taskTable.getColumnModel().getColumn(1).setCellRenderer(
-                centerRenderer);
-        this.taskTable.getColumnModel().getColumn(2).setCellRenderer(
-                centerRenderer);
-        this.taskTable.getColumnModel().getColumn(4).setCellRenderer(
-                new ProgressCellRenderer());
-        JPanel controlPanel = new JPanel();
-        controlPanel.add(this.pauseTaskButton);
-        controlPanel.add(this.resumeTaskButton);
-        controlPanel.add(this.cancelTaskButton);
-        controlPanel.add(this.deleteTaskButton);
-        setLayout(new BorderLayout());
-        add(configPanel, BorderLayout.NORTH);
-        add(new JScrollPane(this.taskTable), BorderLayout.CENTER);
-        add(controlPanel, BorderLayout.SOUTH);
-        this.taskTable.getSelectionModel().addListSelectionListener(
-                new ListSelectionListener() {
-
-                    @Override
-                    public void valueChanged(ListSelectionEvent arg0) {
-                        taskSelectionChanged();
-                    }
-                });
-        this.configureTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                String newTaskString = ClassOptionSelectionPanel.showSelectClassDialog(AuxiliarTaskManagerPanel.this,
-                        "Configure task", AuxiliarMainTask.class,
-                        AuxiliarTaskManagerPanel.this.currentTask.getCLICreationString(AuxiliarMainTask.class),
-                        null);
-                setTaskString(newTaskString);
-            }
-        });
-        this.runTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                runTask((Task) AuxiliarTaskManagerPanel.this.currentTask.copy());
-            }
-        });
-        this.pauseTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                pauseSelectedTasks();
-            }
-        });
-        this.resumeTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                resumeSelectedTasks();
-            }
-        });
-        this.cancelTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                cancelSelectedTasks();
-            }
-        });
-        this.deleteTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                deleteSelectedTasks();
-            }
-        });
-
-        javax.swing.Timer updateListTimer = new javax.swing.Timer(
-                MILLISECS_BETWEEN_REFRESH, new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                AuxiliarTaskManagerPanel.this.taskTable.repaint();
-            }
-        });
-        updateListTimer.start();
-        setPreferredSize(new Dimension(0, 200));
-    }
-
-    public void setPreviewPanel(PreviewPanel previewPanel) {
-        this.previewPanel = previewPanel;
-    }
-
-    public void setTaskString(String cliString) {
-        setTaskString(cliString, true);
-    }
-    
-    public void setTaskString(String cliString, boolean storePreference) {    
-        try {
-            this.currentTask = (MainTask) ClassOption.cliStringToObject(
-                    cliString, MainTask.class, null);
-            String taskText = this.currentTask.getCLICreationString(MainTask.class);
-            this.taskDescField.setText(taskText);
-            if (storePreference == true){
-            //Save task text as a preference
-            prefs.put(PREF_NAME, taskText);
-            }
-        } catch (Exception ex) {
-            GUIUtils.showExceptionDialog(this, "Problem with task", ex);
-        }
-    }
-
-    public void runTask(Task task) {
-        TaskThread thread = new TaskThread(task);
-        this.taskList.add(0, thread);
-        this.taskTableModel.fireTableDataChanged();
-        this.taskTable.setRowSelectionInterval(0, 0);
-        thread.start();
-    }
-
-    public void taskSelectionChanged() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        if (selectedTasks.length == 1) {
-            setTaskString(((OptionHandler) selectedTasks[0].getTask()).getCLICreationString(MainTask.class));
-            if (this.previewPanel != null) {
-                this.previewPanel.setTaskThreadToPreview(selectedTasks[0]);
-            }
-        } else {
-            this.previewPanel.setTaskThreadToPreview(null);
-        }
-    }
-
-    public TaskThread[] getSelectedTasks() {
-        int[] selectedRows = this.taskTable.getSelectedRows();
-        TaskThread[] selectedTasks = new TaskThread[selectedRows.length];
-        for (int i = 0; i < selectedRows.length; i++) {
-            selectedTasks[i] = this.taskList.get(selectedRows[i]);
-        }
-        return selectedTasks;
-    }
-
-    public void pauseSelectedTasks() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            thread.pauseTask();
-        }
-    }
-
-    public void resumeSelectedTasks() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            thread.resumeTask();
-        }
-    }
-
-    public void cancelSelectedTasks() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            thread.cancelTask();
-        }
-    }
-
-    public void deleteSelectedTasks() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            thread.cancelTask();
-            this.taskList.remove(thread);
-        }
-        this.taskTableModel.fireTableDataChanged();
-    }
-
-    public void copyClipBoardConfiguration() {
-
-        StringSelection selection = new StringSelection(this.taskDescField.getText().trim());
-        Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
-        clipboard.setContents(selection, selection);
-
-    }
-
-    public void saveLogSelectedTasks() {
-        String tasksLog = "";
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            tasksLog += ((OptionHandler) thread.getTask()).getCLICreationString(MainTask.class) + "\n";
-        }
-
-        BaseFileChooser fileChooser = new BaseFileChooser();
-        fileChooser.setAcceptAllFileFilterUsed(true);
-        fileChooser.addChoosableFileFilter(new FileExtensionFilter(
-                exportFileExtension));
-        if (fileChooser.showSaveDialog(this) == BaseFileChooser.APPROVE_OPTION) {
-            File chosenFile = fileChooser.getSelectedFile();
-            String fileName = chosenFile.getPath();
-            if (!chosenFile.exists()
-                    && !fileName.endsWith(exportFileExtension)) {
-                fileName = fileName + "." + exportFileExtension;
-            }
-            try {
-                PrintWriter out = new PrintWriter(new BufferedWriter(
-                        new FileWriter(fileName)));
-                out.write(tasksLog);
-                out.close();
-            } catch (IOException ioe) {
-                GUIUtils.showExceptionDialog(
-                        this,
-                        "Problem saving file " + fileName, ioe);
-            }
-        }
-    }
-
-    private static void createAndShowGUI() {
-
-        // Create and set up the window.
-        JFrame frame = new JFrame("Test");
-        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-
-        // Create and set up the content pane.
-        JPanel panel = new AuxiliarTaskManagerPanel();
-        panel.setOpaque(true); // content panes must be opaque
-        frame.setContentPane(panel);
-
-        // Display the window.
-        frame.pack();
-        // frame.setSize(400, 400);
-        frame.setVisible(true);
-    }
-
-    public static void main(String[] args) {
-        try {
-            LookAndFeel.install();
-            javax.swing.SwingUtilities.invokeLater(new Runnable() {
-
-                @Override
-                public void run() {
-                    createAndShowGUI();
-                }
-            });
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
+	private static final long serialVersionUID = 1L;
+
+	public static final int MILLISECS_BETWEEN_REFRESH = 600;
+
+	public static String exportFileExtension = "log";
+
+	public class ProgressCellRenderer extends JProgressBar implements TableCellRenderer {
+
+		private static final long serialVersionUID = 1L;
+
+		public ProgressCellRenderer() {
+			super(SwingConstants.HORIZONTAL, 0, 10000);
+			setBorderPainted(false);
+			setStringPainted(true);
+		}
+
+		@Override
+		public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
+				int row, int column) {
+			double frac = -1.0;
+			if (value instanceof Double) {
+				frac = ((Double) value);
+			}
+			if (frac >= 0.0) {
+				setIndeterminate(false);
+				setValue((int) (frac * 10000.0));
+				setString(StringUtils.doubleToString(frac * 100.0, 2, 2));
+			} else {
+				setValue(0);
+				// setIndeterminate(true);
+				// setString("?");
+			}
+			return this;
+		}
+
+		@Override
+		public void validate() {
+		}
+
+		@Override
+		public void revalidate() {
+		}
+
+		@Override
+		protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
+		}
+
+		@Override
+		public void firePropertyChange(String propertyName, boolean oldValue, boolean newValue) {
+		}
+	}
+
+	protected class TaskTableModel extends AbstractTableModel {
+
+		private static final long serialVersionUID = 1L;
+
+		@Override
+		public String getColumnName(int col) {
+			switch (col) {
+			case 0:
+				return "command";
+			case 1:
+				return "status";
+			case 2:
+				return "time elapsed";
+			case 3:
+				return "current activity";
+			case 4:
+				return "% complete";
+			}
+			return null;
+		}
+
+		@Override
+		public int getColumnCount() {
+			return 5;
+		}
+
+		@Override
+		public int getRowCount() {
+			return AuxiliarTaskManagerPanel.this.taskList.size();
+		}
+
+		@Override
+		public Object getValueAt(int row, int col) {
+			TaskThread thread = AuxiliarTaskManagerPanel.this.taskList.get(row);
+			switch (col) {
+			case 0:
+				return ((OptionHandler) thread.getTask()).getCLICreationString(MainTask.class);
+			case 1:
+				return thread.getCurrentStatusString();
+			case 2:
+				return StringUtils.secondsToDHMSString(thread.getCPUSecondsElapsed());
+			case 3:
+				return thread.getCurrentActivityString();
+			case 4:
+				return new Double(thread.getCurrentActivityFracComplete());
+			}
+			return null;
+		}
+
+		@Override
+		public boolean isCellEditable(int row, int col) {
+			return false;
+		}
+	}
+
+	protected MainTask currentTask = new WriteStreamToARFFFile();// LearnModel();
+
+	protected List<TaskThread> taskList = new ArrayList<>();
+
+	protected JButton configureTaskButton = new JButton("Configure");
+
+	protected JTextField taskDescField = new JTextField();
+
+	protected JButton runTaskButton = new JButton("Run");
+
+	protected TaskTableModel taskTableModel;
+
+	protected JTable taskTable;
+
+	protected JButton pauseTaskButton = new JButton("Pause");
+
+	protected JButton resumeTaskButton = new JButton("Resume");
+
+	protected JButton cancelTaskButton = new JButton("Cancel");
+
+	protected JButton deleteTaskButton = new JButton("Delete");
+
+	protected PreviewPanel previewPanel;
+
+	private Preferences prefs;
+
+	private final String PREF_NAME = "currentTask";
+
+	public AuxiliarTaskManagerPanel() {
+		// Read current task preference
+		prefs = Preferences.userRoot().node(this.getClass().getName());
+		currentTask = new WriteStreamToARFFFile();
+		String taskText = this.currentTask.getCLICreationString(MainTask.class);
+		String propertyValue = prefs.get(PREF_NAME, taskText);
+		// this.taskDescField.setText(propertyValue);
+		setTaskString(propertyValue, false); // Not store preference
+		this.taskDescField.setEditable(false);
+
+		final Component comp = this.taskDescField;
+		this.taskDescField.addMouseListener(new MouseAdapter() {
+
+			@Override
+			public void mouseClicked(MouseEvent evt) {
+				if (evt.getClickCount() == 1) {
+					if ((evt.getButton() == MouseEvent.BUTTON3)
+							|| ((evt.getButton() == MouseEvent.BUTTON1) && evt.isAltDown() && evt.isShiftDown())) {
+						JPopupMenu menu = new JPopupMenu();
+						JMenuItem item;
+
+						item = new JMenuItem("Copy configuration to clipboard");
+						item.addActionListener(new ActionListener() {
+
+							@Override
+							public void actionPerformed(ActionEvent e) {
+								copyClipBoardConfiguration();
+							}
+						});
+						menu.add(item);
+
+						item = new JMenuItem("Save selected tasks to file");
+						item.addActionListener(new ActionListener() {
+
+							@Override
+							public void actionPerformed(ActionEvent arg0) {
+								saveLogSelectedTasks();
+							}
+						});
+						menu.add(item);
+
+						item = new JMenuItem("Enter configuration...");
+						item.addActionListener(new ActionListener() {
+
+							@Override
+							public void actionPerformed(ActionEvent arg0) {
+								String newTaskString = JOptionPane.showInputDialog("Insert command line");
+								if (newTaskString != null) {
+									setTaskString(newTaskString);
+								}
+							}
+						});
+						menu.add(item);
+
+						menu.show(comp, evt.getX(), evt.getY());
+					}
+				}
+			}
+		});
+
+		JPanel configPanel = new JPanel();
+		configPanel.setLayout(new BorderLayout());
+		configPanel.add(this.configureTaskButton, BorderLayout.WEST);
+		configPanel.add(this.taskDescField, BorderLayout.CENTER);
+		configPanel.add(this.runTaskButton, BorderLayout.EAST);
+		this.taskTableModel = new TaskTableModel();
+		this.taskTable = new JTable(this.taskTableModel);
+		DefaultTableCellRenderer centerRenderer = new DefaultTableCellRenderer();
+		centerRenderer.setHorizontalAlignment(SwingConstants.CENTER);
+		this.taskTable.getColumnModel().getColumn(1).setCellRenderer(centerRenderer);
+		this.taskTable.getColumnModel().getColumn(2).setCellRenderer(centerRenderer);
+		this.taskTable.getColumnModel().getColumn(4).setCellRenderer(new ProgressCellRenderer());
+		JPanel controlPanel = new JPanel();
+		controlPanel.add(this.pauseTaskButton);
+		controlPanel.add(this.resumeTaskButton);
+		controlPanel.add(this.cancelTaskButton);
+		controlPanel.add(this.deleteTaskButton);
+		setLayout(new BorderLayout());
+		add(configPanel, BorderLayout.NORTH);
+		add(new JScrollPane(this.taskTable), BorderLayout.CENTER);
+		add(controlPanel, BorderLayout.SOUTH);
+		this.taskTable.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
+
+			@Override
+			public void valueChanged(ListSelectionEvent arg0) {
+				taskSelectionChanged();
+			}
+		});
+		this.configureTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				String newTaskString = ClassOptionSelectionPanel.showSelectClassDialog(AuxiliarTaskManagerPanel.this,
+						"Configure task", AuxiliarMainTask.class,
+						AuxiliarTaskManagerPanel.this.currentTask.getCLICreationString(AuxiliarMainTask.class), null);
+				setTaskString(newTaskString);
+			}
+		});
+		this.runTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				runTask((Task) AuxiliarTaskManagerPanel.this.currentTask.copy());
+			}
+		});
+		this.pauseTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				pauseSelectedTasks();
+			}
+		});
+		this.resumeTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				resumeSelectedTasks();
+			}
+		});
+		this.cancelTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				cancelSelectedTasks();
+			}
+		});
+		this.deleteTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				deleteSelectedTasks();
+			}
+		});
+
+		javax.swing.Timer updateListTimer = new javax.swing.Timer(MILLISECS_BETWEEN_REFRESH, new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				AuxiliarTaskManagerPanel.this.taskTable.repaint();
+			}
+		});
+		updateListTimer.start();
+		setPreferredSize(new Dimension(0, 200));
+	}
+
+	public void setPreviewPanel(PreviewPanel previewPanel) {
+		this.previewPanel = previewPanel;
+	}
+
+	public void setTaskString(String cliString) {
+		setTaskString(cliString, true);
+	}
+
+	public void setTaskString(String cliString, boolean storePreference) {
+		try {
+			this.currentTask = (MainTask) ClassOption.cliStringToObject(cliString, MainTask.class, null);
+			String taskText = this.currentTask.getCLICreationString(MainTask.class);
+			this.taskDescField.setText(taskText);
+			if (storePreference == true) {
+				// Save task text as a preference
+				prefs.put(PREF_NAME, taskText);
+			}
+		} catch (Exception ex) {
+			GUIUtils.showExceptionDialog(this, "Problem with task", ex);
+		}
+	}
+
+	public void runTask(Task task) {
+		TaskThread thread = new TaskThread(task);
+		this.taskList.add(0, thread);
+		this.taskTableModel.fireTableDataChanged();
+		this.taskTable.setRowSelectionInterval(0, 0);
+		thread.start();
+	}
+
+	public void taskSelectionChanged() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		if (selectedTasks.length == 1) {
+			setTaskString(((OptionHandler) selectedTasks[0].getTask()).getCLICreationString(MainTask.class));
+			if (this.previewPanel != null) {
+				this.previewPanel.setTaskThreadToPreview(selectedTasks[0]);
+			}
+		} else {
+			this.previewPanel.setTaskThreadToPreview(null);
+		}
+	}
+
+	public TaskThread[] getSelectedTasks() {
+		int[] selectedRows = this.taskTable.getSelectedRows();
+		TaskThread[] selectedTasks = new TaskThread[selectedRows.length];
+		for (int i = 0; i < selectedRows.length; i++) {
+			selectedTasks[i] = this.taskList.get(selectedRows[i]);
+		}
+		return selectedTasks;
+	}
+
+	public void pauseSelectedTasks() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			thread.pauseTask();
+		}
+	}
+
+	public void resumeSelectedTasks() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			thread.resumeTask();
+		}
+	}
+
+	public void cancelSelectedTasks() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			thread.cancelTask();
+		}
+	}
+
+	public void deleteSelectedTasks() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			thread.cancelTask();
+			this.taskList.remove(thread);
+		}
+		this.taskTableModel.fireTableDataChanged();
+	}
+
+	public void copyClipBoardConfiguration() {
+
+		StringSelection selection = new StringSelection(this.taskDescField.getText().trim());
+		Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
+		clipboard.setContents(selection, selection);
+
+	}
+
+	public void saveLogSelectedTasks() {
+		String tasksLog = "";
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			tasksLog += ((OptionHandler) thread.getTask()).getCLICreationString(MainTask.class) + "\n";
+		}
+
+		BaseFileChooser fileChooser = new BaseFileChooser();
+		fileChooser.setAcceptAllFileFilterUsed(true);
+		fileChooser.addChoosableFileFilter(new FileExtensionFilter(exportFileExtension));
+		if (fileChooser.showSaveDialog(this) == JFileChooser.APPROVE_OPTION) {
+			File chosenFile = fileChooser.getSelectedFile();
+			String fileName = chosenFile.getPath();
+			if (!chosenFile.exists() && !fileName.endsWith(exportFileExtension)) {
+				fileName = fileName + "." + exportFileExtension;
+			}
+			try {
+				PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(fileName)));
+				out.write(tasksLog);
+				out.close();
+			} catch (IOException ioe) {
+				GUIUtils.showExceptionDialog(this, "Problem saving file " + fileName, ioe);
+			}
+		}
+	}
+
+	private static void createAndShowGUI() {
+
+		// Create and set up the window.
+		JFrame frame = new JFrame("Test");
+		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+
+		// Create and set up the content pane.
+		JPanel panel = new AuxiliarTaskManagerPanel();
+		panel.setOpaque(true); // content panes must be opaque
+		frame.setContentPane(panel);
+
+		// Display the window.
+		frame.pack();
+		// frame.setSize(400, 400);
+		frame.setVisible(true);
+	}
+
+	public static void main(String[] args) {
+		try {
+			LookAndFeel.install();
+			javax.swing.SwingUtilities.invokeLater(new Runnable() {
+
+				@Override
+				public void run() {
+					createAndShowGUI();
+				}
+			});
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
 }
diff --git a/moa/src/main/java/moa/gui/BatchCmd.java b/moa/src/main/java/moa/gui/BatchCmd.java
index e8566dc12..77c7dcfea 100644
--- a/moa/src/main/java/moa/gui/BatchCmd.java
+++ b/moa/src/main/java/moa/gui/BatchCmd.java
@@ -1,9 +1,9 @@
 /**
  * BatchCmd.java
- * 
+ *
  * @author Timm Jansen (moa@cs.rwth-aachen.de)
  * @editor Yunsu Kim
- * 
+ *
  * Last edited: 2013/06/02
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,8 +17,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.gui;
@@ -36,9 +36,6 @@
 import com.yahoo.labs.samoa.instances.Instance;
 
 import moa.cluster.Clustering;
-import moa.clusterers.AbstractClusterer;
-import moa.clusterers.ClusterGenerator;
-import moa.clusterers.clustream.WithKmeans;
 import moa.evaluation.CMM;
 import moa.evaluation.EntropyCollection;
 import moa.evaluation.F1;
@@ -50,12 +47,15 @@
 import moa.evaluation.StatisticalCollection;
 import moa.gui.visualization.DataPoint;
 import moa.gui.visualization.RunVisualizer;
+import moa.learners.clusterers.AbstractClusterer;
+import moa.learners.clusterers.ClusterGenerator;
+import moa.learners.clusterers.clustream.WithKmeans;
 import moa.streams.clustering.ClusterEvent;
 import moa.streams.clustering.ClusterEventListener;
 import moa.streams.clustering.ClusteringStream;
 import moa.streams.clustering.RandomRBFGeneratorEvents;
 
-public class BatchCmd implements ClusterEventListener{
+public class BatchCmd implements ClusterEventListener {
 
 	private ArrayList<ClusterEvent> clusterEvents;
 	private AbstractClusterer clusterer;
@@ -65,73 +65,70 @@ public class BatchCmd implements ClusterEventListener{
 	private int totalInstances;
 	public boolean useMicroGT = false;
 
-
-	public BatchCmd(AbstractClusterer clusterer, ClusteringStream stream, MeasureCollection[] measures, int totalInstances){
+	public BatchCmd(AbstractClusterer clusterer, ClusteringStream stream, MeasureCollection[] measures,
+			int totalInstances) {
 		this.clusterer = clusterer;
 		this.stream = stream;
-		if(totalInstances == -1)
+		if (totalInstances == -1)
 			this.totalInstances = Integer.MAX_VALUE;
 		else
 			this.totalInstances = totalInstances;
 		this.measures = measures;
 
-		if(stream instanceof RandomRBFGeneratorEvents){
-			((RandomRBFGeneratorEvents)stream).addClusterChangeListener(this);
-			clusterEvents = new ArrayList<ClusterEvent>();
-		}
-		else{
+		if (stream instanceof RandomRBFGeneratorEvents) {
+			((RandomRBFGeneratorEvents) stream).addClusterChangeListener(this);
+			clusterEvents = new ArrayList<>();
+		} else {
 			clusterEvents = null;
 		}
 		stream.prepareForUse();
 		clusterer.prepareForUse();
 	}
 
-	private ArrayList<ClusterEvent> getEventList(){
+	private ArrayList<ClusterEvent> getEventList() {
 		return clusterEvents;
 	}
 
 	@SuppressWarnings("unchecked")
-	private static ArrayList<Class> getMeasureSelection(boolean[] selection){
-		ArrayList<Class>mclasses = new ArrayList<Class>();
-		
-		if(selection[0])
+	private static ArrayList<Class> getMeasureSelection(boolean[] selection) {
+		ArrayList<Class> mclasses = new ArrayList<>();
+
+		if (selection[0])
 			mclasses.add(General.class);
-		if(selection[1])
+		if (selection[1])
 			mclasses.add(F1.class);
-		if(selection[2])
+		if (selection[2])
 			mclasses.add(EntropyCollection.class);
-		if(selection[3])
+		if (selection[3])
 			mclasses.add(CMM.class);
-		if(selection[4])
+		if (selection[4])
 			mclasses.add(SSQ.class);
-		if(selection[5])
+		if (selection[5])
 			mclasses.add(Separation.class);
-		if(selection[6])
+		if (selection[6])
 			mclasses.add(SilhouetteCoefficient.class);
-		if(selection[7])
+		if (selection[7])
 			mclasses.add(StatisticalCollection.class);
 
 		return mclasses;
 	}
 
-
 	/* TODO read args from command line */
-	public static void main(String[] args){
+	public static void main(String[] args) {
 		RandomRBFGeneratorEvents stream = new RandomRBFGeneratorEvents();
 		AbstractClusterer clusterer = new WithKmeans();
-		boolean[] measureCollection = {true,true,true,true,true,true,true,true};
+		boolean[] measureCollection = { true, true, true, true, true, true, true, true };
 		int amountInstances = 20000;
 		String testfile = "d:\\data\\test.csv";
 
 		runBatch(stream, clusterer, measureCollection, amountInstances, testfile);
 	}
 
-
-	public static void runBatch(ClusteringStream stream, AbstractClusterer clusterer,
-			boolean[] measureCollection, int amountInstances, String outputFile){
-		// create the measure collection 
+	public static void runBatch(ClusteringStream stream, AbstractClusterer clusterer, boolean[] measureCollection,
+			int amountInstances, String outputFile) {
+		// create the measure collection
 		MeasureCollection[] measures = getMeasures(getMeasureSelection(measureCollection));
-		
+
 		// run the batch job
 		BatchCmd batch = new BatchCmd(clusterer, stream, measures, amountInstances);
 		batch.run();
@@ -139,74 +136,76 @@ public static void runBatch(ClusteringStream stream, AbstractClusterer clusterer
 		// read events and horizon
 		ArrayList<ClusterEvent> clusterEvents = batch.getEventList();
 		int horizon = stream.decayHorizonOption.getValue();
-		
+
 		// write results to file
 		exportCSV(outputFile, clusterEvents, measures, horizon);
 	}
 
-
-	public void run(){
-		ArrayList<DataPoint> pointBuffer0 = new ArrayList<DataPoint>();
+	public void run() {
+		ArrayList<DataPoint> pointBuffer0 = new ArrayList<>();
 		int m_timestamp = 0;
 		int decayHorizon = stream.getDecayHorizon();
 
 		double decay_threshold = stream.getDecayThreshold();
-		double decay_rate = (-1*Math.log(decay_threshold)/decayHorizon);
+		double decay_rate = (-1 * Math.log(decay_threshold) / decayHorizon);
 
 		int counter = decayHorizon;
 
-		while(m_timestamp < totalInstances && stream.hasMoreInstances()){
+		while (m_timestamp < totalInstances && stream.hasMoreInstances()) {
 			m_timestamp++;
 			counter--;
 			Instance next = stream.nextInstance().getData();
-			DataPoint point0 = new DataPoint(next,m_timestamp);
+			DataPoint point0 = new DataPoint(next, m_timestamp);
 			pointBuffer0.add(point0);
 
 			Instance traininst0 = new DenseInstance(point0);
-			if(clusterer instanceof ClusterGenerator)
+			if (clusterer instanceof ClusterGenerator)
 				traininst0.setDataset(point0.dataset());
 			else
 				traininst0.deleteAttributeAt(point0.classIndex());
 
 			clusterer.trainOnInstanceImpl(traininst0);
 
-			if(counter <= 0){
-				//                if(m_timestamp%(totalInstances/10) == 0)
-					//                    System.out.println("Thread"+threadID+":"+(m_timestamp*100/totalInstances)+"% ");
-				for(DataPoint p:pointBuffer0)
+			if (counter <= 0) {
+				// if(m_timestamp%(totalInstances/10) == 0)
+				// System.out.println("Thread"+threadID+":"+(m_timestamp*100/totalInstances)+"%
+				// ");
+				for (DataPoint p : pointBuffer0)
 					p.updateWeight(m_timestamp, decay_rate);
 
 				Clustering gtClustering0;
 				Clustering clustering0 = null;
 
 				gtClustering0 = new Clustering(pointBuffer0);
-				if(useMicroGT && stream instanceof RandomRBFGeneratorEvents){
-					gtClustering0 = ((RandomRBFGeneratorEvents)stream).getMicroClustering();
+				if (useMicroGT && stream instanceof RandomRBFGeneratorEvents) {
+					gtClustering0 = ((RandomRBFGeneratorEvents) stream).getMicroClustering();
 				}
 
 				clustering0 = clusterer.getClusteringResult();
-				if(clusterer.implementsMicroClusterer()){
-					if(clusterer instanceof ClusterGenerator
-							&& stream instanceof RandomRBFGeneratorEvents){
-						((ClusterGenerator)clusterer).setSourceClustering(((RandomRBFGeneratorEvents)stream).getMicroClustering());
+				if (clusterer.implementsMicroClusterer()) {
+					if (clusterer instanceof ClusterGenerator && stream instanceof RandomRBFGeneratorEvents) {
+						((ClusterGenerator) clusterer)
+								.setSourceClustering(((RandomRBFGeneratorEvents) stream).getMicroClustering());
 					}
 					Clustering microC = clusterer.getMicroClusteringResult();
-					if(clusterer.evaluateMicroClusteringOption.isSet()){
+					if (clusterer.evaluateMicroClusteringOption.isSet()) {
 						clustering0 = microC;
-					}
-					else{
-						if(clustering0 == null && microC != null)
-							clustering0 = moa.clusterers.KMeans.gaussianMeans(gtClustering0, microC);
+					} else {
+						if (clustering0 == null && microC != null)
+							clustering0 = moa.learners.clusterers.KMeans.gaussianMeans(gtClustering0, microC);
 					}
 				}
 
-
-				//evaluate
+				// evaluate
 				for (int i = 0; i < measures.length; i++) {
 					try {
-						/*double sec =*/ measures[i].evaluateClusteringPerformance(clustering0, gtClustering0, pointBuffer0);
-						//System.out.println("Eval of "+measures[i].getClass().getSimpleName()+" at "+m_timestamp+" took "+sec);
-					} catch (Exception ex) { ex.printStackTrace(); }
+						/* double sec = */ measures[i].evaluateClusteringPerformance(clustering0, gtClustering0,
+								pointBuffer0);
+						// System.out.println("Eval of "+measures[i].getClass().getSimpleName()+" at
+						// "+m_timestamp+" took "+sec);
+					} catch (Exception ex) {
+						ex.printStackTrace();
+					}
 				}
 
 				pointBuffer0.clear();
@@ -216,47 +215,47 @@ public void run(){
 	}
 
 	@SuppressWarnings("unchecked")
-	private static MeasureCollection[] getMeasures(ArrayList<Class> measure_classes){
+	private static MeasureCollection[] getMeasures(ArrayList<Class> measure_classes) {
 		MeasureCollection[] measures = new MeasureCollection[measure_classes.size()];
 		for (int i = 0; i < measure_classes.size(); i++) {
 			try {
-				MeasureCollection m = (MeasureCollection)measure_classes.get(i).newInstance();
-				for(int j = 0 ; j < m.getNumMeasures() ; j++)
-				{
+				MeasureCollection m = (MeasureCollection) measure_classes.get(i).newInstance();
+				for (int j = 0; j < m.getNumMeasures(); j++) {
 					m.setEnabled(j, true);
 				}
 				measures[i] = m;
 
 			} catch (Exception ex) {
-				Logger.getLogger("Couldn't create Instance for "+measure_classes.get(i).getName());
+				Logger.getLogger("Couldn't create Instance for " + measure_classes.get(i).getName());
 				ex.printStackTrace();
 			}
 		}
 		return measures;
 	}
 
+	@Override
 	public void changeCluster(ClusterEvent e) {
-		if(clusterEvents!=null) clusterEvents.add(e);
+		if (clusterEvents != null)
+			clusterEvents.add(e);
 	}
 
-
-	public static void exportCSV(String filepath, ArrayList<ClusterEvent> clusterEvents, MeasureCollection[] measures, int horizon) {
+	public static void exportCSV(String filepath, ArrayList<ClusterEvent> clusterEvents, MeasureCollection[] measures,
+			int horizon) {
 		PrintWriter out = null;
 		try {
-			// Prepare an output file			
+			// Prepare an output file
 			if (!filepath.endsWith(".csv")) {
 				filepath += ".csv";
 			}
 			out = new PrintWriter(new BufferedWriter(new FileWriter(filepath)));
-			
-			
+
 			String delimiter = ";";
 
 			// Header
 			int numValues = 0;
 			out.write("Nr" + delimiter);
 			out.write("Event" + delimiter);
-			for (int m = 0; m < 1; m++) {	// TODO: Multiple group of measures
+			for (int m = 0; m < 1; m++) { // TODO: Multiple group of measures
 				for (int i = 0; i < measures.length; i++) {
 					for (int j = 0; j < measures[i].getNumMeasures(); j++) {
 						if (measures[i].isEnabled(j)) {
@@ -277,11 +276,11 @@ public static void exportCSV(String filepath, ArrayList<ClusterEvent> clusterEve
 					event = eventIt.next();
 				}
 			}
-			for (int v = 0; v < numValues; v++){
+			for (int v = 0; v < numValues; v++) {
 				// Nr
 				out.write(v + delimiter);
 				// Events
-				if (event != null && event.getTimestamp() <= ((v+1) * horizon)) {
+				if (event != null && event.getTimestamp() <= ((v + 1) * horizon)) {
 					out.write(event.getType() + delimiter);
 					if (eventIt != null && eventIt.hasNext()) {
 						event = eventIt.next();
@@ -293,7 +292,7 @@ public static void exportCSV(String filepath, ArrayList<ClusterEvent> clusterEve
 				}
 
 				// Values
-				for (int m = 0; m < 1; m++) {	// TODO: Multiple group of measures
+				for (int m = 0; m < 1; m++) { // TODO: Multiple group of measures
 					for (int i = 0; i < measures.length; i++) {
 						for (int j = 0; j < measures[i].getNumMeasures(); j++) {
 							if (measures[i].isEnabled(j)) {
@@ -304,9 +303,9 @@ public static void exportCSV(String filepath, ArrayList<ClusterEvent> clusterEve
 				}
 				out.write("\n");
 			}
-			
+
 			out.close();
-			
+
 		} catch (IOException ex) {
 			Logger.getLogger(RunVisualizer.class.getName()).log(Level.SEVERE, null, ex);
 		} finally {
@@ -314,4 +313,3 @@ public static void exportCSV(String filepath, ArrayList<ClusterEvent> clusterEve
 		}
 	}
 }
-
diff --git a/moa/src/main/java/moa/gui/ClassOptionSelectionPanel.java b/moa/src/main/java/moa/gui/ClassOptionSelectionPanel.java
index 1bf16d8ec..b9693c29a 100644
--- a/moa/src/main/java/moa/gui/ClassOptionSelectionPanel.java
+++ b/moa/src/main/java/moa/gui/ClassOptionSelectionPanel.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
@@ -50,143 +50,137 @@
  */
 public class ClassOptionSelectionPanel extends JPanel {
 
-    // TODO: idea - why not retain matching options between classes when the
-    // class type is changed
-    // e.g. if user switches from LearnModel to EvaluateLearner, retain whatever
-    // the 'stream' option was set to
-    private static final long serialVersionUID = 1L;
-
-    /** The requirements that classes must meet in order to be listed. */
-    private static CapabilityRequirement requiredCapabilities = null;
-
-    /**
-     * Sets the capability requirement of listed classes.
-     *
-     * @param requirements	The capability requirements.
-     */
-    public static void setRequiredCapabilities(CapabilityRequirement requirements) {
-        requiredCapabilities = requirements;
-    }
-
-    protected JComboBox classChoiceBox;
-
-    protected JComponent chosenObjectEditor;
-
-    protected Object chosenObject;
-
-    public ClassOptionSelectionPanel(Class<?> requiredType,
-            String initialCLIString, String nullString) {
-        // Class<?>[] classesFound = AutoClassDiscovery.findClassesOfType("moa",
-        // requiredType);
-        Class<?>[] classesFound = findSuitableClasses(requiredType);
-        this.classChoiceBox = new JComboBox(classesFound);
-        setLayout(new BorderLayout());
-        add(this.classChoiceBox, BorderLayout.NORTH);
-        Object initialObject = null;
-        try {
-            initialObject = ClassOption.cliStringToObject(initialCLIString,
-                    requiredType, null);
-        } catch (Exception ignored) {
-            // ignore exception
-        }
-        if (initialObject != null) {
-            this.classChoiceBox.setSelectedItem(initialObject.getClass());
-            classChoiceChanged(initialObject);
-        } else {
-            try {
-                Object chosen = ((Class<?>) ClassOptionSelectionPanel.this.classChoiceBox.getSelectedItem()).newInstance();
-                classChoiceChanged(chosen);
-            } catch (Exception ex) {
-                GUIUtils.showExceptionDialog(ClassOptionSelectionPanel.this,
-                        "Problem", ex);
-            }
-        }
-        this.classChoiceBox.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                try {
-                    Object chosen = ((Class<?>) ClassOptionSelectionPanel.this.classChoiceBox.getSelectedItem()).newInstance();
-                    classChoiceChanged(chosen);
-                } catch (Exception ex) {
-                    GUIUtils.showExceptionDialog(
-                            ClassOptionSelectionPanel.this, "Problem", ex);
-                }
-            }
-        });
-    }
-
-    public Class<?>[] findSuitableClasses(Class<?> requiredType) {
-        AutoExpandVector<Class<?>> finalClasses = new AutoExpandVector<Class<?>>();
-        Class<?>[] classesFound = AutoClassDiscovery.findClassesOfType("moa",
-                requiredType);
-        for (Class<?> foundClass : classesFound) {
-            // Skip this class if it doesn't meet the capabilities requirement
-            if (requiredCapabilities != null && !requiredCapabilities.isMetBy(foundClass))
-                continue;
-
-            finalClasses.add(foundClass);
-        }
-        Class<?>[] tasksFound = AutoClassDiscovery.findClassesOfType("moa",
-                Task.class);
-        for (Class<?> foundTask : tasksFound) {
-            try {
-                Task task = (Task) foundTask.newInstance();
-                if (requiredType.isAssignableFrom(task.getTaskResultType())) {
-		    // Skip this task if its result type doesn't meet the capabilities requirement
-                    if (requiredCapabilities != null && !requiredCapabilities.isMetBy(task.getTaskResultType()))
-                        continue;
-
-                    finalClasses.add(foundTask);
-                }
-            } catch (Exception e) {
-                // ignore
-            }
-        }
-        return finalClasses.toArray(new Class<?>[finalClasses.size()]);
-    }
-
-    public static String showSelectClassDialog(Component parent, String title,
-            Class<?> requiredType, String initialCLIString, String nullString) {
-        ClassOptionSelectionPanel panel = new ClassOptionSelectionPanel(
-                requiredType, initialCLIString, nullString);
-        if (JOptionPane.showOptionDialog(parent, panel, title,
-                JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE, null,
-                null, null) == JOptionPane.OK_OPTION) {
-            return panel.getChosenObjectCLIString(requiredType);
-        }
-        return initialCLIString;
-    }
-
-    public String getChosenObjectCLIString(Class<?> requiredType) {
-        if (this.chosenObjectEditor instanceof OptionsConfigurationPanel) {
-            ((OptionsConfigurationPanel) this.chosenObjectEditor).applyChanges();
-        }
-        return ClassOption.objectToCLIString(this.chosenObject, requiredType);
-    }
-
-    public void classChoiceChanged(Object chosen) {
-        this.chosenObject = chosen;
-        JComponent newChosenObjectEditor = null;
-        if (this.chosenObject instanceof OptionHandler) {
-            OptionHandler chosenOptionHandler = (OptionHandler) this.chosenObject;
-            newChosenObjectEditor = new OptionsConfigurationPanel(
-                    chosenOptionHandler.getPurposeString(), chosenOptionHandler.getOptions());
-        }
-        if (this.chosenObjectEditor != null) {
-            remove(this.chosenObjectEditor);
-        }
-        this.chosenObjectEditor = newChosenObjectEditor;
-        if (this.chosenObjectEditor != null) {
-            add(this.chosenObjectEditor, BorderLayout.CENTER);
-        }
-        Component component = this;
-        while ((component != null) && !(component instanceof JDialog)) {
-            component = component.getParent();
-        }
-        if (component != null) {
-            Window window = (Window) component;
-            window.pack();
-        }
-    }
+	// TODO: idea - why not retain matching options between classes when the
+	// class type is changed
+	// e.g. if user switches from LearnModel to EvaluateLearner, retain whatever
+	// the 'stream' option was set to
+	private static final long serialVersionUID = 1L;
+
+	/** The requirements that classes must meet in order to be listed. */
+	private static CapabilityRequirement requiredCapabilities = null;
+
+	/**
+	 * Sets the capability requirement of listed classes.
+	 *
+	 * @param requirements The capability requirements.
+	 */
+	public static void setRequiredCapabilities(CapabilityRequirement requirements) {
+		requiredCapabilities = requirements;
+	}
+
+	protected JComboBox classChoiceBox;
+
+	protected JComponent chosenObjectEditor;
+
+	protected Object chosenObject;
+
+	public ClassOptionSelectionPanel(Class<?> requiredType, String initialCLIString, String nullString) {
+		// Class<?>[] classesFound = AutoClassDiscovery.findClassesOfType("moa",
+		// requiredType);
+		Class<?>[] classesFound = findSuitableClasses(requiredType);
+		this.classChoiceBox = new JComboBox(classesFound);
+		setLayout(new BorderLayout());
+		add(this.classChoiceBox, BorderLayout.NORTH);
+		Object initialObject = null;
+		try {
+			initialObject = ClassOption.cliStringToObject(initialCLIString, requiredType, null);
+		} catch (Exception ignored) {
+			// ignore exception
+		}
+		if (initialObject != null) {
+			this.classChoiceBox.setSelectedItem(initialObject.getClass());
+			classChoiceChanged(initialObject);
+		} else {
+			try {
+				Object chosen = ((Class<?>) ClassOptionSelectionPanel.this.classChoiceBox.getSelectedItem())
+						.newInstance();
+				classChoiceChanged(chosen);
+			} catch (Exception ex) {
+				GUIUtils.showExceptionDialog(ClassOptionSelectionPanel.this, "Problem", ex);
+			}
+		}
+		this.classChoiceBox.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				try {
+					Object chosen = ((Class<?>) ClassOptionSelectionPanel.this.classChoiceBox.getSelectedItem())
+							.newInstance();
+					classChoiceChanged(chosen);
+				} catch (Exception ex) {
+					GUIUtils.showExceptionDialog(ClassOptionSelectionPanel.this, "Problem", ex);
+				}
+			}
+		});
+	}
+
+	public Class<?>[] findSuitableClasses(Class<?> requiredType) {
+		AutoExpandVector<Class<?>> finalClasses = new AutoExpandVector<>();
+		Class<?>[] classesFound = AutoClassDiscovery.findClassesOfType("moa", requiredType);
+		for (Class<?> foundClass : classesFound) {
+			// Skip this class if it doesn't meet the capabilities requirement
+			if (requiredCapabilities != null && !requiredCapabilities.isMetBy(foundClass))
+				continue;
+
+			finalClasses.add(foundClass);
+		}
+		Class<?>[] tasksFound = AutoClassDiscovery.findClassesOfType("moa", Task.class);
+		for (Class<?> foundTask : tasksFound) {
+			try {
+				Task task = (Task) foundTask.newInstance();
+				if (requiredType.isAssignableFrom(task.getTaskResultType())) {
+					// Skip this task if its result type doesn't meet the capabilities requirement
+					if (requiredCapabilities != null && !requiredCapabilities.isMetBy(task.getTaskResultType()))
+						continue;
+
+					finalClasses.add(foundTask);
+				}
+			} catch (Exception e) {
+				// ignore
+			}
+		}
+		return finalClasses.toArray(new Class<?>[finalClasses.size()]);
+	}
+
+	public static String showSelectClassDialog(Component parent, String title, Class<?> requiredType,
+			String initialCLIString, String nullString) {
+		ClassOptionSelectionPanel panel = new ClassOptionSelectionPanel(requiredType, initialCLIString, nullString);
+		if (JOptionPane.showOptionDialog(parent, panel, title, JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE,
+				null, null, null) == JOptionPane.OK_OPTION) {
+			return panel.getChosenObjectCLIString(requiredType);
+		}
+		return initialCLIString;
+	}
+
+	public String getChosenObjectCLIString(Class<?> requiredType) {
+		if (this.chosenObjectEditor instanceof OptionsConfigurationPanel) {
+			((OptionsConfigurationPanel) this.chosenObjectEditor).applyChanges();
+		}
+		return ClassOption.objectToCLIString(this.chosenObject, requiredType);
+	}
+
+	public void classChoiceChanged(Object chosen) {
+		this.chosenObject = chosen;
+		JComponent newChosenObjectEditor = null;
+		if (this.chosenObject instanceof OptionHandler) {
+			OptionHandler chosenOptionHandler = (OptionHandler) this.chosenObject;
+			newChosenObjectEditor = new OptionsConfigurationPanel(chosenOptionHandler.getPurposeString(),
+					chosenOptionHandler.getOptions());
+		}
+		if (this.chosenObjectEditor != null) {
+			remove(this.chosenObjectEditor);
+		}
+		this.chosenObjectEditor = newChosenObjectEditor;
+		if (this.chosenObjectEditor != null) {
+			add(this.chosenObjectEditor, BorderLayout.CENTER);
+		}
+		Component component = this;
+		while ((component != null) && !(component instanceof JDialog)) {
+			component = component.getParent();
+		}
+		if (component != null) {
+			Window window = (Window) component;
+			window.pack();
+		}
+	}
 }
diff --git a/moa/src/main/java/moa/gui/ClassOptionWithListenerOptionEditComponent.java b/moa/src/main/java/moa/gui/ClassOptionWithListenerOptionEditComponent.java
index eaec092be..fd04046b8 100644
--- a/moa/src/main/java/moa/gui/ClassOptionWithListenerOptionEditComponent.java
+++ b/moa/src/main/java/moa/gui/ClassOptionWithListenerOptionEditComponent.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
@@ -31,30 +31,28 @@
  * EditComponent for the {@link ClassOptionWithListenerOption}. When its state
  * is changed, the changes are directly applied to the corresponding Option so
  * that potential listeners can be notified and updates can be processed.
- * 
+ *
  * @author Cornelius Styp von Rekowski (cornelius.styp@ovgu.de)
  * @version $Revision: 1 $
  */
 public class ClassOptionWithListenerOptionEditComponent extends ClassOptionEditComponent {
-	
+
 	private static final long serialVersionUID = 1L;
 
 	public ClassOptionWithListenerOptionEditComponent(Option opt) {
 		super(opt);
-		
+
 		this.addChangeListener(new ChangeListener() {
-			
+
 			@Override
 			public void stateChanged(ChangeEvent e) {
-				if (!ClassOptionWithListenerOptionEditComponent.this.textField
-						.getText().isEmpty()) 
-				{
+				if (!ClassOptionWithListenerOptionEditComponent.this.textField.getText().isEmpty()) {
 					// apply state to set the selected value in the ClassOption
 					// so that it can be picked up by dependent options
 					ClassOptionWithListenerOptionEditComponent.this.applyState();
 				}
 			}
-			
+
 		});
 	}
 
diff --git a/moa/src/main/java/moa/gui/ClassOptionWithNamesSelectionPanel.java b/moa/src/main/java/moa/gui/ClassOptionWithNamesSelectionPanel.java
index 524199618..96cec7541 100644
--- a/moa/src/main/java/moa/gui/ClassOptionWithNamesSelectionPanel.java
+++ b/moa/src/main/java/moa/gui/ClassOptionWithNamesSelectionPanel.java
@@ -1,8 +1,8 @@
 /**
  * [ClassOptionWithNamesSelectionPanel.java]
- * 
+ *
  * ClassOptionWithNames: Selection panel
- * 
+ *
  * @author Yunsu Kim
  * 		   based on the implementation of Richard Kirkby
  * Data Management and Data Exploration Group, RWTH Aachen University
@@ -31,141 +31,138 @@
 import moa.tasks.Task;
 
 public class ClassOptionWithNamesSelectionPanel extends JPanel {
-	
-    private static final long serialVersionUID = 1L;
-    
-    private boolean debug = false;
-
-    protected JComboBox classChoiceBox;
-    protected JComponent chosenObjectEditor;
-    protected Object chosenObject;
-
-    public ClassOptionWithNamesSelectionPanel(Class<?> requiredType,
-            String initialCLIString, String nullString, String[] classNames) {
-        Class<?>[] classesFound = findSuitableClasses(requiredType, classNames);
-        if (debug) {
-        	System.out.print("[ClassOptionWithNamesSelectionPanel] classNames = ");
-        	for (String s : classNames) {
-        		System.out.print(s + ", ");
-        	}
-        	System.out.println();
-        	
-        	System.out.print("[ClassOptionWithNamesSelectionPanel] classesFound = ");
-        	for (Class<?> cl : classesFound) {
-        		System.out.print(cl.getSimpleName() + ", ");
-        	}
-        	System.out.println();
-        }
-        this.classChoiceBox = new JComboBox(classesFound);
-        
-        setLayout(new BorderLayout());
-        add(this.classChoiceBox, BorderLayout.NORTH);
-        Object initialObject = null;
-        try {
-            initialObject = ClassOption.cliStringToObject(initialCLIString,
-                    requiredType, null);
-        } catch (Exception ignored) {
-            // ignore exception
-        }
-        if (initialObject != null) {
-            this.classChoiceBox.setSelectedItem(initialObject.getClass());
-            classChoiceChanged(initialObject);
-        } else {
-            try {
-                Object chosen = ((Class<?>) ClassOptionWithNamesSelectionPanel.this.classChoiceBox.getSelectedItem()).newInstance();
-                classChoiceChanged(chosen);
-            } catch (Exception ex) {
-                GUIUtils.showExceptionDialog(ClassOptionWithNamesSelectionPanel.this,
-                        "Problem", ex);
-            }
-        }
-        this.classChoiceBox.addActionListener(new ActionListener() {
-
-            public void actionPerformed(ActionEvent arg0) {
-                try {
-                    Object chosen = ((Class<?>) ClassOptionWithNamesSelectionPanel.this.classChoiceBox.getSelectedItem()).newInstance();
-                    classChoiceChanged(chosen);
-                } catch (Exception ex) {
-                    GUIUtils.showExceptionDialog(
-                            ClassOptionWithNamesSelectionPanel.this, "Problem", ex);
-                }
-            }
-        });
-    }
-
-    public Class<?>[] findSuitableClasses(Class<?> requiredType, String[] classNames) {
-        AutoExpandVector<Class<?>> finalClasses = new AutoExpandVector<Class<?>>();
-        Class<?>[] classesFound = AutoClassDiscovery.findClassesOfType("moa",
-                requiredType);
-        for (Class<?> cl : classesFound) {
-        	for (int i = 0; i < classNames.length; i++) {
-        		if (cl.getSimpleName().contains(classNames[i])) {
-        			finalClasses.add(cl);
-        			break;
-        		}
-        	}
-        }
-        Class<?>[] tasksFound = AutoClassDiscovery.findClassesOfType("moa",
-                Task.class);
-        for (Class<?> foundTask : tasksFound) {
-            try {
-                Task task = (Task) foundTask.newInstance();
-                if (requiredType.isAssignableFrom(task.getTaskResultType())) {
-                	for (int i = 0; i < classNames.length; i++) {
-                		if (foundTask.getSimpleName().contains(classNames[i])) {
-                			finalClasses.add(foundTask);
-                			break;
-                		}
-                	}
-                }
-            } catch (Exception e) {
-                // ignore
-            }
-        }
-        return finalClasses.toArray(new Class<?>[finalClasses.size()]);
-    }
-
-    public static String showSelectClassDialog(Component parent, String title,
-            Class<?> requiredType, String initialCLIString, String nullString, String[] classNames) {
-        ClassOptionWithNamesSelectionPanel panel = new ClassOptionWithNamesSelectionPanel(
-                requiredType, initialCLIString, nullString, classNames);
-        if (JOptionPane.showOptionDialog(parent, panel, title,
-                JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE, null,
-                null, null) == JOptionPane.OK_OPTION) {
-            return panel.getChosenObjectCLIString(requiredType);
-        }
-        return initialCLIString;
-    }
-
-    public String getChosenObjectCLIString(Class<?> requiredType) {
-        if (this.chosenObjectEditor instanceof OptionsConfigurationPanel) {
-            ((OptionsConfigurationPanel) this.chosenObjectEditor).applyChanges();
-        }
-        return ClassOption.objectToCLIString(this.chosenObject, requiredType);
-    }
-
-    public void classChoiceChanged(Object chosen) {
-        this.chosenObject = chosen;
-        JComponent newChosenObjectEditor = null;
-        if (this.chosenObject instanceof OptionHandler) {
-            OptionHandler chosenOptionHandler = (OptionHandler) this.chosenObject;
-            newChosenObjectEditor = new OptionsConfigurationPanel(
-                    chosenOptionHandler.getPurposeString(), chosenOptionHandler.getOptions());
-        }
-        if (this.chosenObjectEditor != null) {
-            remove(this.chosenObjectEditor);
-        }
-        this.chosenObjectEditor = newChosenObjectEditor;
-        if (this.chosenObjectEditor != null) {
-            add(this.chosenObjectEditor, BorderLayout.CENTER);
-        }
-        Component component = this;
-        while ((component != null) && !(component instanceof JDialog)) {
-            component = component.getParent();
-        }
-        if (component != null) {
-            Window window = (Window) component;
-            window.pack();
-        }
-    }
+
+	private static final long serialVersionUID = 1L;
+
+	private boolean debug = false;
+
+	protected JComboBox classChoiceBox;
+	protected JComponent chosenObjectEditor;
+	protected Object chosenObject;
+
+	public ClassOptionWithNamesSelectionPanel(Class<?> requiredType, String initialCLIString, String nullString,
+			String[] classNames) {
+		Class<?>[] classesFound = findSuitableClasses(requiredType, classNames);
+		if (debug) {
+			System.out.print("[ClassOptionWithNamesSelectionPanel] classNames = ");
+			for (String s : classNames) {
+				System.out.print(s + ", ");
+			}
+			System.out.println();
+
+			System.out.print("[ClassOptionWithNamesSelectionPanel] classesFound = ");
+			for (Class<?> cl : classesFound) {
+				System.out.print(cl.getSimpleName() + ", ");
+			}
+			System.out.println();
+		}
+		this.classChoiceBox = new JComboBox(classesFound);
+
+		setLayout(new BorderLayout());
+		add(this.classChoiceBox, BorderLayout.NORTH);
+		Object initialObject = null;
+		try {
+			initialObject = ClassOption.cliStringToObject(initialCLIString, requiredType, null);
+		} catch (Exception ignored) {
+			// ignore exception
+		}
+		if (initialObject != null) {
+			this.classChoiceBox.setSelectedItem(initialObject.getClass());
+			classChoiceChanged(initialObject);
+		} else {
+			try {
+				Object chosen = ((Class<?>) ClassOptionWithNamesSelectionPanel.this.classChoiceBox.getSelectedItem())
+						.newInstance();
+				classChoiceChanged(chosen);
+			} catch (Exception ex) {
+				GUIUtils.showExceptionDialog(ClassOptionWithNamesSelectionPanel.this, "Problem", ex);
+			}
+		}
+		this.classChoiceBox.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				try {
+					Object chosen = ((Class<?>) ClassOptionWithNamesSelectionPanel.this.classChoiceBox
+							.getSelectedItem()).newInstance();
+					classChoiceChanged(chosen);
+				} catch (Exception ex) {
+					GUIUtils.showExceptionDialog(ClassOptionWithNamesSelectionPanel.this, "Problem", ex);
+				}
+			}
+		});
+	}
+
+	public Class<?>[] findSuitableClasses(Class<?> requiredType, String[] classNames) {
+		AutoExpandVector<Class<?>> finalClasses = new AutoExpandVector<>();
+		Class<?>[] classesFound = AutoClassDiscovery.findClassesOfType("moa", requiredType);
+		for (Class<?> cl : classesFound) {
+			for (int i = 0; i < classNames.length; i++) {
+				if (cl.getSimpleName().contains(classNames[i])) {
+					finalClasses.add(cl);
+					break;
+				}
+			}
+		}
+		Class<?>[] tasksFound = AutoClassDiscovery.findClassesOfType("moa", Task.class);
+		for (Class<?> foundTask : tasksFound) {
+			try {
+				Task task = (Task) foundTask.newInstance();
+				if (requiredType.isAssignableFrom(task.getTaskResultType())) {
+					for (int i = 0; i < classNames.length; i++) {
+						if (foundTask.getSimpleName().contains(classNames[i])) {
+							finalClasses.add(foundTask);
+							break;
+						}
+					}
+				}
+			} catch (Exception e) {
+				// ignore
+			}
+		}
+		return finalClasses.toArray(new Class<?>[finalClasses.size()]);
+	}
+
+	public static String showSelectClassDialog(Component parent, String title, Class<?> requiredType,
+			String initialCLIString, String nullString, String[] classNames) {
+		ClassOptionWithNamesSelectionPanel panel = new ClassOptionWithNamesSelectionPanel(requiredType,
+				initialCLIString, nullString, classNames);
+		if (JOptionPane.showOptionDialog(parent, panel, title, JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE,
+				null, null, null) == JOptionPane.OK_OPTION) {
+			return panel.getChosenObjectCLIString(requiredType);
+		}
+		return initialCLIString;
+	}
+
+	public String getChosenObjectCLIString(Class<?> requiredType) {
+		if (this.chosenObjectEditor instanceof OptionsConfigurationPanel) {
+			((OptionsConfigurationPanel) this.chosenObjectEditor).applyChanges();
+		}
+		return ClassOption.objectToCLIString(this.chosenObject, requiredType);
+	}
+
+	public void classChoiceChanged(Object chosen) {
+		this.chosenObject = chosen;
+		JComponent newChosenObjectEditor = null;
+		if (this.chosenObject instanceof OptionHandler) {
+			OptionHandler chosenOptionHandler = (OptionHandler) this.chosenObject;
+			newChosenObjectEditor = new OptionsConfigurationPanel(chosenOptionHandler.getPurposeString(),
+					chosenOptionHandler.getOptions());
+		}
+		if (this.chosenObjectEditor != null) {
+			remove(this.chosenObjectEditor);
+		}
+		this.chosenObjectEditor = newChosenObjectEditor;
+		if (this.chosenObjectEditor != null) {
+			add(this.chosenObjectEditor, BorderLayout.CENTER);
+		}
+		Component component = this;
+		while ((component != null) && !(component instanceof JDialog)) {
+			component = component.getParent();
+		}
+		if (component != null) {
+			Window window = (Window) component;
+			window.pack();
+		}
+	}
 }
diff --git a/moa/src/main/java/moa/gui/ClassificationTabPanel.java b/moa/src/main/java/moa/gui/ClassificationTabPanel.java
index ecfbc4cda..54a915aae 100644
--- a/moa/src/main/java/moa/gui/ClassificationTabPanel.java
+++ b/moa/src/main/java/moa/gui/ClassificationTabPanel.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
@@ -44,19 +44,17 @@ public ClassificationTabPanel() {
 		add(this.previewPanel, BorderLayout.CENTER);
 	}
 
-	//returns the string to display as title of the tab
-    @Override
+	// returns the string to display as title of the tab
+	@Override
 	public String getTabTitle() {
 		return "Classification";
 	}
 
-	//a short description (can be used as tool tip) of the tab, or contributor, etc.
-    @Override
-	public String getDescription(){
+	// a short description (can be used as tool tip) of the tab, or contributor,
+	// etc.
+	@Override
+	public String getDescription() {
 		return "MOA Classification";
 	}
 
 }
-
-
-
diff --git a/moa/src/main/java/moa/gui/ConceptDriftTabPanel.java b/moa/src/main/java/moa/gui/ConceptDriftTabPanel.java
index de248e6de..0269167e6 100644
--- a/moa/src/main/java/moa/gui/ConceptDriftTabPanel.java
+++ b/moa/src/main/java/moa/gui/ConceptDriftTabPanel.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
@@ -47,19 +47,17 @@ public ConceptDriftTabPanel() {
 		add(this.previewPanel, BorderLayout.CENTER);
 	}
 
-	//returns the string to display as title of the tab
-    @Override
+	// returns the string to display as title of the tab
+	@Override
 	public String getTabTitle() {
 		return "Concept Drift";
 	}
 
-	//a short description (can be used as tool tip) of the tab, or contributor, etc.
-    @Override
-	public String getDescription(){
+	// a short description (can be used as tool tip) of the tab, or contributor,
+	// etc.
+	@Override
+	public String getDescription() {
 		return "MOA Concept Drift";
 	}
 
 }
-
-
-
diff --git a/moa/src/main/java/moa/gui/EditableMultiChoiceOptionEditComponent.java b/moa/src/main/java/moa/gui/EditableMultiChoiceOptionEditComponent.java
index b68db1a72..9fca714c7 100644
--- a/moa/src/main/java/moa/gui/EditableMultiChoiceOptionEditComponent.java
+++ b/moa/src/main/java/moa/gui/EditableMultiChoiceOptionEditComponent.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
@@ -27,31 +27,30 @@
 import moa.options.EditableMultiChoiceOption;
 
 /**
- * EditComponent for the {@link EditableMultiChoiceOption} which allows for 
+ * EditComponent for the {@link EditableMultiChoiceOption} which allows for
  * refreshing the shown contents.
- * 
+ *
  * @author Cornelius Styp von Rekowski (cornelius.styp@ovgu.de)
  * @version $Revision: 1 $
  */
 public class EditableMultiChoiceOptionEditComponent extends MultiChoiceOptionEditComponent {
 
 	private static final long serialVersionUID = 1L;
-	
+
 	public EditableMultiChoiceOptionEditComponent(Option option) {
 		super(option);
-		
-		// register the EditComponent with the corresponding 
+
+		// register the EditComponent with the corresponding
 		// EditableMultiChoiceOption, so that updates can be received
 		((EditableMultiChoiceOption) option).registerEditComponent(this);
 	}
-	
+
 	/**
 	 * Refresh the shown contents.
 	 */
 	public void refresh() {
-		setModel(new DefaultComboBoxModel<String>(
-				this.editedOption.getOptionLabels()));
-        setSelectedIndex(this.editedOption.getChosenIndex());
+		setModel(new DefaultComboBoxModel<>(this.editedOption.getOptionLabels()));
+		setSelectedIndex(this.editedOption.getChosenIndex());
 	}
-	
+
 }
diff --git a/moa/src/main/java/moa/gui/FileExtensionFilter.java b/moa/src/main/java/moa/gui/FileExtensionFilter.java
index 3c7a44a75..3a0d679d7 100644
--- a/moa/src/main/java/moa/gui/FileExtensionFilter.java
+++ b/moa/src/main/java/moa/gui/FileExtensionFilter.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
@@ -26,31 +26,31 @@
 /**
  * A filter that is used to restrict the files that are shown.
  *
- *  
+ * 
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $ 
+ * @version $Revision: 7 $
  */
 public class FileExtensionFilter extends FileFilter {
 
-    protected String fileExtension;
+	protected String fileExtension;
 
-    public FileExtensionFilter(String extension) {
-        this.fileExtension = extension.toLowerCase();
-    }
+	public FileExtensionFilter(String extension) {
+		this.fileExtension = extension.toLowerCase();
+	}
 
-    @Override
-    public boolean accept(File f) {
-        if (f != null) {
-            if (f.isDirectory()) {
-                return true;
-            }
-            return (f.getName().toLowerCase().endsWith("." + this.fileExtension));
-        }
-        return false;
-    }
+	@Override
+	public boolean accept(File f) {
+		if (f != null) {
+			if (f.isDirectory()) {
+				return true;
+			}
+			return (f.getName().toLowerCase().endsWith("." + this.fileExtension));
+		}
+		return false;
+	}
 
-    @Override
-    public String getDescription() {
-        return ("*." + this.fileExtension);
-    }
+	@Override
+	public String getDescription() {
+		return ("*." + this.fileExtension);
+	}
 }
diff --git a/moa/src/main/java/moa/gui/GUI.java b/moa/src/main/java/moa/gui/GUI.java
index 691fd5158..1c7a4e1ed 100644
--- a/moa/src/main/java/moa/gui/GUI.java
+++ b/moa/src/main/java/moa/gui/GUI.java
@@ -16,20 +16,10 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
-import com.jidesoft.swing.JideButton;
-import com.jidesoft.swing.JideSplitButton;
-import moa.DoTask;
-import moa.core.WekaUtils;
-import nz.ac.waikato.cms.gui.core.GUIHelper;
-import nz.ac.waikato.cms.gui.core.MultiPagePane;
-
-import javax.swing.JFrame;
-import javax.swing.JMenuItem;
-import javax.swing.JPanel;
 import java.awt.BorderLayout;
 import java.awt.Font;
 import java.awt.event.ActionEvent;
@@ -37,99 +27,110 @@
 import java.util.HashSet;
 import java.util.Set;
 
+import javax.swing.JFrame;
+import javax.swing.JMenuItem;
+import javax.swing.JPanel;
+
+import com.jidesoft.swing.ButtonStyle;
+import com.jidesoft.swing.JideSplitButton;
+
+import moa.DoTask;
+import moa.core.WekaUtils;
+import nz.ac.waikato.cms.gui.core.GUIHelper;
+import nz.ac.waikato.cms.gui.core.MultiPagePane;
+
 /**
- * The main class for the MOA gui. Lets the user configure
- * tasks, learners, streams, and perform data stream analysis.
+ * The main class for the MOA gui. Lets the user configure tasks, learners,
+ * streams, and perform data stream analysis.
  *
  * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
  * @author FracPete (fracpete at waikato dot ac dot nz)
  */
 public class GUI extends JPanel {
 
-    private static final long serialVersionUID = 1L;
-
-    private MultiPagePane pagePane;
-
-    public GUI() {
-        initGUI();
-    }
-
-    private void initGUI() {
-        setLayout(new BorderLayout());
-
-        // Create and set up tabs
-        pagePane = new MultiPagePane();
-        pagePane.setMaxPageCloseUndo(GUIDefaults.getMaxTabUndo());
-        add(pagePane, BorderLayout.CENTER);
-
-        // sub-menu for adding tabs via action button
-        JideSplitButton buttonAdd = new JideSplitButton(GUIHelper.getIcon("add.gif"));
-        buttonAdd.setButtonStyle(JideButton.TOOLBOX_STYLE);
-        buttonAdd.setFont(getFont().deriveFont(Font.PLAIN));
-        buttonAdd.setAlwaysDropdown(false);
-        pagePane.getButtonPanel().add(buttonAdd);
-
-        // the default tabs
-        Set<String> defaultTabs = new HashSet<>(Arrays.asList(GUIDefaults.getDefaultTabs()));
-
-        // initialize additional panels
-        String[] tabs = GUIDefaults.getTabs();
-        for (int i = 0; i < tabs.length; i++) {
-            try {
-                // determine classname
-                String[] optionsStr = tabs[i].split(":");
-                final String classname = optionsStr[0];
-                // setup panel
-                AbstractTabPanel tabPanel = (AbstractTabPanel) Class.forName(classname).newInstance();
-                if ((defaultTabs.size() == 0) || defaultTabs.contains(classname))
-                    pagePane.addPage(tabPanel.getTabTitle(), tabPanel);
-
-                // add tab
-                JMenuItem menuitem = new JMenuItem(tabPanel.getTabTitle());
-                menuitem.addActionListener((ActionEvent e) -> {
-                    try {
-                        AbstractTabPanel tab = (AbstractTabPanel) Class.forName(classname).newInstance();
-                        pagePane.addPage(tab.getTabTitle(), tab);
-                    }
-                    catch (Exception ex) {
-                        // ignored
-                    }
-                });
-                buttonAdd.add(menuitem);
-            } catch (Exception e) {
-                e.printStackTrace();
-            }
-        }
-        pagePane.setSelectedIndex(0);
-    }
-
-    public static void main(String[] args) {
-        try {
-            if (!DoTask.isJavaVersionOK() || !WekaUtils.isWekaVersionOK()) {
-                return;
-            }
-            javax.swing.SwingUtilities.invokeLater(new Runnable() {
-
-                @Override
-                public void run() {
-
-                    // Create and set up the window.
-                    JFrame frame = new JFrame("MOA Graphical User Interface");
-                    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-                    LookAndFeel.install();
-
-                    GUI gui = new GUI();
-                    frame.getContentPane().setLayout(new BorderLayout());
-                    frame.getContentPane().add(gui);
-
-                    // Display the window.
-                    frame.setSize(GUIDefaults.getFrameWidth(), GUIDefaults.getFrameHeight());
-                    frame.setLocationRelativeTo(null);
-                    frame.setVisible(true);
-                }
-            });
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
+	private static final long serialVersionUID = 1L;
+
+	private MultiPagePane pagePane;
+
+	public GUI() {
+		initGUI();
+	}
+
+	private void initGUI() {
+		setLayout(new BorderLayout());
+
+		// Create and set up tabs
+		pagePane = new MultiPagePane();
+		pagePane.setMaxPageCloseUndo(GUIDefaults.getMaxTabUndo());
+		add(pagePane, BorderLayout.CENTER);
+
+		// sub-menu for adding tabs via action button
+		JideSplitButton buttonAdd = new JideSplitButton(GUIHelper.getIcon("add.gif"));
+		buttonAdd.setButtonStyle(ButtonStyle.TOOLBOX_STYLE);
+		buttonAdd.setFont(getFont().deriveFont(Font.PLAIN));
+		buttonAdd.setAlwaysDropdown(false);
+		pagePane.getButtonPanel().add(buttonAdd);
+
+		// the default tabs
+		Set<String> defaultTabs = new HashSet<>(Arrays.asList(GUIDefaults.getDefaultTabs()));
+
+		// initialize additional panels
+		String[] tabs = GUIDefaults.getTabs();
+		for (int i = 0; i < tabs.length; i++) {
+			try {
+				// determine classname
+				String[] optionsStr = tabs[i].split(":");
+				final String classname = optionsStr[0];
+				// setup panel
+				AbstractTabPanel tabPanel = (AbstractTabPanel) Class.forName(classname).newInstance();
+				if ((defaultTabs.size() == 0) || defaultTabs.contains(classname))
+					pagePane.addPage(tabPanel.getTabTitle(), tabPanel);
+
+				// add tab
+				JMenuItem menuitem = new JMenuItem(tabPanel.getTabTitle());
+				menuitem.addActionListener((ActionEvent e) -> {
+					try {
+						AbstractTabPanel tab = (AbstractTabPanel) Class.forName(classname).newInstance();
+						pagePane.addPage(tab.getTabTitle(), tab);
+					} catch (Exception ex) {
+						// ignored
+					}
+				});
+				buttonAdd.add(menuitem);
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+		}
+		pagePane.setSelectedIndex(0);
+	}
+
+	public static void main(String[] args) {
+		try {
+			if (!DoTask.isJavaVersionOK() || !WekaUtils.isWekaVersionOK()) {
+				return;
+			}
+			javax.swing.SwingUtilities.invokeLater(new Runnable() {
+
+				@Override
+				public void run() {
+
+					// Create and set up the window.
+					JFrame frame = new JFrame("MOA Graphical User Interface");
+					frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+					LookAndFeel.install();
+
+					GUI gui = new GUI();
+					frame.getContentPane().setLayout(new BorderLayout());
+					frame.getContentPane().add(gui);
+
+					// Display the window.
+					frame.setSize(GUIDefaults.getFrameWidth(), GUIDefaults.getFrameHeight());
+					frame.setLocationRelativeTo(null);
+					frame.setVisible(true);
+				}
+			});
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
 }
diff --git a/moa/src/main/java/moa/gui/GUIDefaults.java b/moa/src/main/java/moa/gui/GUIDefaults.java
index a6d0864a6..819b79f69 100644
--- a/moa/src/main/java/moa/gui/GUIDefaults.java
+++ b/moa/src/main/java/moa/gui/GUIDefaults.java
@@ -11,7 +11,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
 /*
@@ -30,277 +30,271 @@
 import moa.core.Utils;
 
 /**
- * This class offers get methods for the default GUI settings in 
- * the props file <code>moa/gui/GUI.props</code>.
+ * This class offers get methods for the default GUI settings in the props file
+ * <code>moa/gui/GUI.props</code>.
  *
- * @author  FracPete (fracpete at waikato dot ac dot nz)
+ * @author FracPete (fracpete at waikato dot ac dot nz)
  */
 public class GUIDefaults implements Serializable {
 
-    /** for serialization. */
-    private static final long serialVersionUID = 4954795757927524225L;
-
-    /** The name of the properties file. */
-    public final static String PROPERTY_FILE = "moa/gui/GUI.props";
-
-    /** Properties associated with the GUI options. */
-    protected static Properties PROPERTIES;
-
-    static {
-        try {
-            PROPERTIES = PropertiesReader.readProperties(PROPERTY_FILE);
-        } catch (Exception e) {
-            System.err.println("Problem reading properties. Fix before continuing.");
-            e.printStackTrace();
-            PROPERTIES = new Properties();
-        }
-    }
-
-    /**
-     * returns the value for the specified property, if non-existent then the
-     * default value.
-     *
-     * @param property      the property to retrieve the value for
-     * @param defaultValue  the default value for the property
-     * @return              the value of the specified property
-     */
-    public static String get(String property, String defaultValue) {
-        return PROPERTIES.getProperty(property, defaultValue);
-    }
-
-    /**
-     * returns the associated properties file.
-     *
-     * @return              the props file
-     */
-    public final static Properties getProperties() {
-        return PROPERTIES;
-    }
-
-    /**
-     * Tries to instantiate the class stored for this property, optional
-     * options will be set as well. Returns null if unsuccessful.
-     *
-     * @param property      the property to get the object for
-     * @param defaultValue  the default object spec string
-     * @return              if successful the fully configured object, null
-     *                      otherwise
-     */
-    protected static Object getObject(String property, String defaultValue) {
-        return getObject(property, defaultValue, Object.class);
-    }
-
-    /**
-     * Tries to instantiate the class stored for this property, optional
-     * options will be set as well. Returns null if unsuccessful.
-     *
-     * @param property      the property to get the object for
-     * @param defaultValue  the default object spec string
-     * @param cls           the class the object must be derived from
-     * @return              if successful the fully configured object, null
-     *                      otherwise
-     */
-    protected static Object getObject(String property, String defaultValue, Class cls) {
-        Object result;
-        String tmpStr;
-        String[] tmpOptions;
-
-        result = null;
-
-        try {
-            tmpStr = get(property, defaultValue);
-            tmpOptions = Utils.splitOptions(tmpStr);
-            if (tmpOptions.length != 0) {
-                tmpStr = tmpOptions[0];
-                tmpOptions[0] = "";
-                result = Utils.forName(cls, tmpStr, tmpOptions);
-            }
-        } catch (Exception e) {
-            e.printStackTrace();
-            result = null;
-        }
-
-        return result;
-    }
-
-    /**
-     * returns an array with the classnames of all the additional panels to
-     * display as tabs in the GUI.
-     *
-     * @return		the classnames
-     */
-    public static String[] getTabs() {
-        String[] result;
-        String tabs;
-
-        // read and split on comma
-        tabs = get("Tabs", "moa.gui.ClassificationTabPanel,moa.gui.RegressionTabPanel,moa.gui.MultiLabelClassificationTabPanel,moa.gui.MultiRegressionTargetTabPanel,moa.gui.clustertab.ClusteringTabPanel,moa.gui.outliertab.OutlierTabPanel,moa.gui.ConceptDriftTabPanel,moa.gui.ALTabPanel,moa.gui.AuxiliarTabPanel,moa.gui.experimentertab.ExperimenterTabPanel");
-        result = tabs.split(",");
-
-        return result;
-    }
-
-    /**
-     * returns an array with the classnames of all default tabs to
-     * display as tabs in the GUI.
-     *
-     * @return		the classnames
-     */
-    public static String[] getDefaultTabs() {
-        String[] result;
-        String tabs;
-
-        // read and split on comma
-        tabs = get("DefaultTabs", "").trim();
-        if (tabs.isEmpty())
-            result = new String[0];
-        else
-            result = tabs.split(",");
-
-        return result;
-    }
-
-    /**
-     * Returns the maximum of undos for closing pages/tabs.
-     *
-     * @return      the maximum
-     */
-    public static int getMaxTabUndo() {
-        int defMaxUndo = 10;
-        String maxUndo = get("MaxTabUndo", "" + defMaxUndo);
-        try {
-            return Math.max(Integer.parseInt(maxUndo), 0);
-        }
-        catch (Exception e) {
-            System.err.println("Failed to parse 'MaxTabUndo': " + maxUndo);
-            return defMaxUndo;
-        }
-    }
-
-    /**
-     * Returns the initial directory for the file chooser used for opening
-     * datasets.
-     * <p/>
-     * The following placeholders are recognized:
-     * <pre>
-     *   %t - the temp directory
-     *   %h - the user's home directory
-     *   %c - the current directory
-     *   %% - gets replaced by a single percentage sign
-     * </pre>
-     *
-     * @return		the default directory
-     */
-    public static String getInitialDirectory() {
-        String result;
-
-        result = get("InitialDirectory", "%c");
-        result = result.replaceAll("%t", System.getProperty("java.io.tmpdir"));
-        result = result.replaceAll("%h", System.getProperty("user.home"));
-        result = result.replaceAll("%c", System.getProperty("user.dir"));
-        result = result.replaceAll("%%", System.getProperty("%"));
-
-        return result;
-    }
-
-    /**
-     * Returns the width for the frame.
-     *
-     * @return the width in pixel
-     */
-    public static int getFrameWidth() {
-        int result;
-        String str;
-        str = get("FrameWidth", "1200");
-        try {
-            result = Integer.parseInt(str);
-        }
-        catch (Exception e) {
-            result = 1200;
-        }
-        return result;
-    }
-
-    /**
-     * Returns the height for the frame.
-     *
-     * @return the height in pixel
-     */
-    public static int getFrameHeight() {
-        int result;
-        String str;
-        str = get("FrameHeight", "900");
-        try {
-            result = Integer.parseInt(str);
-        }
-        catch (Exception e) {
-            result = 900;
-        }
-        return result;
-    }
-
-    /**
-     * Returns the width for the file chooser.
-     *
-     * @return the width in pixel
-     */
-    public static int getFileChooserWidth() {
-        int result;
-        String str;
-        str = get("FileChooserWidth", "1200");
-        try {
-            result = Integer.parseInt(str);
-        }
-        catch (Exception e) {
-            result = 1200;
-        }
-        return result;
-    }
-
-    /**
-     * Returns the height for the file chooser.
-     *
-     * @return the height in pixel
-     */
-    public static int getFileChooserHeight() {
-        int result;
-        String str;
-        str = get("FileChooserHeight", "900");
-        try {
-            result = Integer.parseInt(str);
-        }
-        catch (Exception e) {
-            result = 900;
-        }
-        return result;
-    }
-
-    /**
-     * only for testing - prints the content of the props file.
-     *
-     * @param args	commandline parameters - ignored
-     */
-    public static void main(String[] args) {
-        Enumeration names;
-        String name;
-        Vector sorted;
-
-        System.out.println("\nMOA defaults:");
-        names = PROPERTIES.propertyNames();
-
-        // sort names
-        sorted = new Vector();
-        while (names.hasMoreElements()) {
-            sorted.add(names.nextElement());
-        }
-        Collections.sort(sorted);
-        names = sorted.elements();
-
-        // output
-        while (names.hasMoreElements()) {
-            name = names.nextElement().toString();
-            System.out.println("- " + name + ": " + PROPERTIES.getProperty(name, ""));
-        }
-        System.out.println();
-    }
+	/** for serialization. */
+	private static final long serialVersionUID = 4954795757927524225L;
+
+	/** The name of the properties file. */
+	public final static String PROPERTY_FILE = "moa/gui/GUI.props";
+
+	/** Properties associated with the GUI options. */
+	protected static Properties PROPERTIES;
+
+	static {
+		try {
+			PROPERTIES = PropertiesReader.readProperties(PROPERTY_FILE);
+		} catch (Exception e) {
+			System.err.println("Problem reading properties. Fix before continuing.");
+			e.printStackTrace();
+			PROPERTIES = new Properties();
+		}
+	}
+
+	/**
+	 * returns the value for the specified property, if non-existent then the
+	 * default value.
+	 *
+	 * @param property     the property to retrieve the value for
+	 * @param defaultValue the default value for the property
+	 * @return the value of the specified property
+	 */
+	public static String get(String property, String defaultValue) {
+		return PROPERTIES.getProperty(property, defaultValue);
+	}
+
+	/**
+	 * returns the associated properties file.
+	 *
+	 * @return the props file
+	 */
+	public final static Properties getProperties() {
+		return PROPERTIES;
+	}
+
+	/**
+	 * Tries to instantiate the class stored for this property, optional options
+	 * will be set as well. Returns null if unsuccessful.
+	 *
+	 * @param property     the property to get the object for
+	 * @param defaultValue the default object spec string
+	 * @return if successful the fully configured object, null otherwise
+	 */
+	protected static Object getObject(String property, String defaultValue) {
+		return getObject(property, defaultValue, Object.class);
+	}
+
+	/**
+	 * Tries to instantiate the class stored for this property, optional options
+	 * will be set as well. Returns null if unsuccessful.
+	 *
+	 * @param property     the property to get the object for
+	 * @param defaultValue the default object spec string
+	 * @param cls          the class the object must be derived from
+	 * @return if successful the fully configured object, null otherwise
+	 */
+	protected static Object getObject(String property, String defaultValue, Class cls) {
+		Object result;
+		String tmpStr;
+		String[] tmpOptions;
+
+		result = null;
+
+		try {
+			tmpStr = get(property, defaultValue);
+			tmpOptions = Utils.splitOptions(tmpStr);
+			if (tmpOptions.length != 0) {
+				tmpStr = tmpOptions[0];
+				tmpOptions[0] = "";
+				result = Utils.forName(cls, tmpStr, tmpOptions);
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+			result = null;
+		}
+
+		return result;
+	}
+
+	/**
+	 * returns an array with the classnames of all the additional panels to display
+	 * as tabs in the GUI.
+	 *
+	 * @return the classnames
+	 */
+	public static String[] getTabs() {
+		String[] result;
+		String tabs;
+
+		// read and split on comma
+		tabs = get("Tabs",
+				"moa.gui.ClassificationTabPanel,moa.gui.RegressionTabPanel,moa.gui.MultiLabelClassificationTabPanel,moa.gui.MultiRegressionTargetTabPanel,moa.gui.clustertab.ClusteringTabPanel,moa.gui.outliertab.OutlierTabPanel,moa.gui.ConceptDriftTabPanel,moa.gui.ALTabPanel,moa.gui.AuxiliarTabPanel,moa.gui.experimentertab.ExperimenterTabPanel");
+		result = tabs.split(",");
+
+		return result;
+	}
+
+	/**
+	 * returns an array with the classnames of all default tabs to display as tabs
+	 * in the GUI.
+	 *
+	 * @return the classnames
+	 */
+	public static String[] getDefaultTabs() {
+		String[] result;
+		String tabs;
+
+		// read and split on comma
+		tabs = get("DefaultTabs", "").trim();
+		if (tabs.isEmpty())
+			result = new String[0];
+		else
+			result = tabs.split(",");
+
+		return result;
+	}
+
+	/**
+	 * Returns the maximum of undos for closing pages/tabs.
+	 *
+	 * @return the maximum
+	 */
+	public static int getMaxTabUndo() {
+		int defMaxUndo = 10;
+		String maxUndo = get("MaxTabUndo", "" + defMaxUndo);
+		try {
+			return Math.max(Integer.parseInt(maxUndo), 0);
+		} catch (Exception e) {
+			System.err.println("Failed to parse 'MaxTabUndo': " + maxUndo);
+			return defMaxUndo;
+		}
+	}
+
+	/**
+	 * Returns the initial directory for the file chooser used for opening datasets.
+	 * <p/>
+	 * The following placeholders are recognized:
+	 * 
+	 * <pre>
+	 *   %t - the temp directory
+	 *   %h - the user's home directory
+	 *   %c - the current directory
+	 *   %% - gets replaced by a single percentage sign
+	 * </pre>
+	 *
+	 * @return the default directory
+	 */
+	public static String getInitialDirectory() {
+		String result;
+
+		result = get("InitialDirectory", "%c");
+		result = result.replaceAll("%t", System.getProperty("java.io.tmpdir"));
+		result = result.replaceAll("%h", System.getProperty("user.home"));
+		result = result.replaceAll("%c", System.getProperty("user.dir"));
+		result = result.replaceAll("%%", System.getProperty("%"));
+
+		return result;
+	}
+
+	/**
+	 * Returns the width for the frame.
+	 *
+	 * @return the width in pixel
+	 */
+	public static int getFrameWidth() {
+		int result;
+		String str;
+		str = get("FrameWidth", "1200");
+		try {
+			result = Integer.parseInt(str);
+		} catch (Exception e) {
+			result = 1200;
+		}
+		return result;
+	}
+
+	/**
+	 * Returns the height for the frame.
+	 *
+	 * @return the height in pixel
+	 */
+	public static int getFrameHeight() {
+		int result;
+		String str;
+		str = get("FrameHeight", "900");
+		try {
+			result = Integer.parseInt(str);
+		} catch (Exception e) {
+			result = 900;
+		}
+		return result;
+	}
+
+	/**
+	 * Returns the width for the file chooser.
+	 *
+	 * @return the width in pixel
+	 */
+	public static int getFileChooserWidth() {
+		int result;
+		String str;
+		str = get("FileChooserWidth", "1200");
+		try {
+			result = Integer.parseInt(str);
+		} catch (Exception e) {
+			result = 1200;
+		}
+		return result;
+	}
+
+	/**
+	 * Returns the height for the file chooser.
+	 *
+	 * @return the height in pixel
+	 */
+	public static int getFileChooserHeight() {
+		int result;
+		String str;
+		str = get("FileChooserHeight", "900");
+		try {
+			result = Integer.parseInt(str);
+		} catch (Exception e) {
+			result = 900;
+		}
+		return result;
+	}
+
+	/**
+	 * only for testing - prints the content of the props file.
+	 *
+	 * @param args commandline parameters - ignored
+	 */
+	public static void main(String[] args) {
+		Enumeration names;
+		String name;
+		Vector sorted;
+
+		System.out.println("\nMOA defaults:");
+		names = PROPERTIES.propertyNames();
+
+		// sort names
+		sorted = new Vector();
+		while (names.hasMoreElements()) {
+			sorted.add(names.nextElement());
+		}
+		Collections.sort(sorted);
+		names = sorted.elements();
+
+		// output
+		while (names.hasMoreElements()) {
+			name = names.nextElement().toString();
+			System.out.println("- " + name + ": " + PROPERTIES.getProperty(name, ""));
+		}
+		System.out.println();
+	}
 }
diff --git a/moa/src/main/java/moa/gui/GUIUtils.java b/moa/src/main/java/moa/gui/GUIUtils.java
index d58eaa728..a651561cf 100644
--- a/moa/src/main/java/moa/gui/GUIUtils.java
+++ b/moa/src/main/java/moa/gui/GUIUtils.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
@@ -29,25 +29,22 @@
 import moa.core.MiscUtils;
 
 /**
- * This class offers util methods for displaying dialogs showing errors or exceptions.
+ * This class offers util methods for displaying dialogs showing errors or
+ * exceptions.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
 public class GUIUtils {
 
-    public static void showErrorDialog(Component parent, String title,
-            String message) {
-        JTextArea messagePanel = new JTextArea(message);
-        JScrollPane messageScroll = new JScrollPane(messagePanel);
-        messageScroll.setPreferredSize(new Dimension(400, 100));
-        JOptionPane.showMessageDialog(parent, messageScroll, title,
-                JOptionPane.ERROR_MESSAGE);
-    }
+	public static void showErrorDialog(Component parent, String title, String message) {
+		JTextArea messagePanel = new JTextArea(message);
+		JScrollPane messageScroll = new JScrollPane(messagePanel);
+		messageScroll.setPreferredSize(new Dimension(400, 100));
+		JOptionPane.showMessageDialog(parent, messageScroll, title, JOptionPane.ERROR_MESSAGE);
+	}
 
-    public static void showExceptionDialog(Component parent, String title,
-            Exception ex) {
-        showErrorDialog(parent, title, ex.getMessage() + "\n\n"
-                + MiscUtils.getStackTraceString(ex));
-    }
+	public static void showExceptionDialog(Component parent, String title, Exception ex) {
+		showErrorDialog(parent, title, ex.getMessage() + "\n\n" + MiscUtils.getStackTraceString(ex));
+	}
 }
diff --git a/moa/src/main/java/moa/gui/LineGraphViewPanel.java b/moa/src/main/java/moa/gui/LineGraphViewPanel.java
index a72a6ee56..662c6c28e 100644
--- a/moa/src/main/java/moa/gui/LineGraphViewPanel.java
+++ b/moa/src/main/java/moa/gui/LineGraphViewPanel.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
@@ -41,135 +41,134 @@
  */
 public class LineGraphViewPanel extends JPanel {
 
-    private static final long serialVersionUID = 1L;
-
-    static final BasicStroke lineStroke = new BasicStroke(3.0f);
-
-    protected class PlotLine {
-
-        public LearningCurve curve;
-
-        public Color colour;
-
-        public int xAxisIndex;
-
-        public int yAxisIndex;
-
-        public double xMin;
-
-        public double xMax;
-
-        public double yMin;
-
-        public double yMax;
-
-        public float convertX(double x) {
-            return (float) ((x - this.xMin) / (this.xMax - this.xMin));
-        }
-
-        public float convertY(double y) {
-            return (float) ((y - this.yMin) / (this.yMax - this.yMin));
-        }
-
-        public Shape getShapeToPlot() {
-            GeneralPath path = new GeneralPath();
-            if (this.curve.numEntries() > 0) {
-                path.moveTo(convertX(this.curve.getMeasurement(0,
-                        this.xAxisIndex)), convertY(this.curve.getMeasurement(
-                        0, this.yAxisIndex)));
-                for (int i = 1; i < this.curve.numEntries(); i++) {
-                    path.lineTo(convertX(this.curve.getMeasurement(i,
-                            this.xAxisIndex)), convertY(this.curve.getMeasurement(i, this.yAxisIndex)));
-                }
-            }
-            return path;
-        }
-    }
-
-    protected class PlotPanel extends JPanel {
-
-        private static final long serialVersionUID = 1L;
-
-        @Override
-        public void paint(Graphics g) {
-            g.setColor(getBackground());
-            g.fillRect(0, 0, getWidth(), getHeight());
-            Graphics2D g2 = (Graphics2D) g;
-            g2.scale(getWidth(), getHeight());
-            g2.setStroke(lineStroke);
-            for (PlotLine plotLine : LineGraphViewPanel.this.plotLines) {
-                g2.setPaint(plotLine.colour);
-                g2.draw(plotLine.getShapeToPlot());
-            }
-        }
-    }
-
-    protected class PlotTableModel extends AbstractTableModel {
-
-        private static final long serialVersionUID = 1L;
-
-        @Override
-        public String getColumnName(int col) {
-            switch (col) {
-                case 0:
-                    return "source";
-                case 1:
-                    return "colour";
-                case 2:
-                    return "x-axis";
-                case 3:
-                    return "y-axis";
-                case 4:
-                    return "x-min";
-                case 5:
-                    return "x-max";
-                case 6:
-                    return "y-min";
-                case 7:
-                    return "y-max";
-            }
-            return null;
-        }
-
-        @Override
-        public int getColumnCount() {
-            return 8;
-        }
-
-        @Override
-        public int getRowCount() {
-            return LineGraphViewPanel.this.plotLines.size();
-        }
-
-        @Override
-        public Object getValueAt(int row, int col) {
-            PlotLine plotLine = LineGraphViewPanel.this.plotLines.get(row);
-            switch (col) {
-                case 0:
-                    return plotLine.curve;
-                case 1:
-                    return plotLine.colour;
-                case 2:
-                    return plotLine.curve.getMeasurementName(plotLine.xAxisIndex);
-                case 3:
-                    return plotLine.curve.getMeasurementName(plotLine.yAxisIndex);
-                case 4:
-                    return plotLine.xMin;
-                case 5:
-                    return plotLine.xMax;
-                case 6:
-                    return plotLine.yMin;
-                case 7:
-                    return plotLine.yMax;
-            }
-            return null;
-        }
-
-        @Override
-        public boolean isCellEditable(int row, int col) {
-            return false;
-        }
-    }
-
-    protected List<PlotLine> plotLines = new ArrayList<PlotLine>();
+	private static final long serialVersionUID = 1L;
+
+	static final BasicStroke lineStroke = new BasicStroke(3.0f);
+
+	protected class PlotLine {
+
+		public LearningCurve curve;
+
+		public Color colour;
+
+		public int xAxisIndex;
+
+		public int yAxisIndex;
+
+		public double xMin;
+
+		public double xMax;
+
+		public double yMin;
+
+		public double yMax;
+
+		public float convertX(double x) {
+			return (float) ((x - this.xMin) / (this.xMax - this.xMin));
+		}
+
+		public float convertY(double y) {
+			return (float) ((y - this.yMin) / (this.yMax - this.yMin));
+		}
+
+		public Shape getShapeToPlot() {
+			GeneralPath path = new GeneralPath();
+			if (this.curve.numEntries() > 0) {
+				path.moveTo(convertX(this.curve.getMeasurement(0, this.xAxisIndex)),
+						convertY(this.curve.getMeasurement(0, this.yAxisIndex)));
+				for (int i = 1; i < this.curve.numEntries(); i++) {
+					path.lineTo(convertX(this.curve.getMeasurement(i, this.xAxisIndex)),
+							convertY(this.curve.getMeasurement(i, this.yAxisIndex)));
+				}
+			}
+			return path;
+		}
+	}
+
+	protected class PlotPanel extends JPanel {
+
+		private static final long serialVersionUID = 1L;
+
+		@Override
+		public void paint(Graphics g) {
+			g.setColor(getBackground());
+			g.fillRect(0, 0, getWidth(), getHeight());
+			Graphics2D g2 = (Graphics2D) g;
+			g2.scale(getWidth(), getHeight());
+			g2.setStroke(lineStroke);
+			for (PlotLine plotLine : LineGraphViewPanel.this.plotLines) {
+				g2.setPaint(plotLine.colour);
+				g2.draw(plotLine.getShapeToPlot());
+			}
+		}
+	}
+
+	protected class PlotTableModel extends AbstractTableModel {
+
+		private static final long serialVersionUID = 1L;
+
+		@Override
+		public String getColumnName(int col) {
+			switch (col) {
+			case 0:
+				return "source";
+			case 1:
+				return "colour";
+			case 2:
+				return "x-axis";
+			case 3:
+				return "y-axis";
+			case 4:
+				return "x-min";
+			case 5:
+				return "x-max";
+			case 6:
+				return "y-min";
+			case 7:
+				return "y-max";
+			}
+			return null;
+		}
+
+		@Override
+		public int getColumnCount() {
+			return 8;
+		}
+
+		@Override
+		public int getRowCount() {
+			return LineGraphViewPanel.this.plotLines.size();
+		}
+
+		@Override
+		public Object getValueAt(int row, int col) {
+			PlotLine plotLine = LineGraphViewPanel.this.plotLines.get(row);
+			switch (col) {
+			case 0:
+				return plotLine.curve;
+			case 1:
+				return plotLine.colour;
+			case 2:
+				return plotLine.curve.getMeasurementName(plotLine.xAxisIndex);
+			case 3:
+				return plotLine.curve.getMeasurementName(plotLine.yAxisIndex);
+			case 4:
+				return plotLine.xMin;
+			case 5:
+				return plotLine.xMax;
+			case 6:
+				return plotLine.yMin;
+			case 7:
+				return plotLine.yMax;
+			}
+			return null;
+		}
+
+		@Override
+		public boolean isCellEditable(int row, int col) {
+			return false;
+		}
+	}
+
+	protected List<PlotLine> plotLines = new ArrayList<>();
 }
diff --git a/moa/src/main/java/moa/gui/LookAndFeel.java b/moa/src/main/java/moa/gui/LookAndFeel.java
index 8fab9ca54..fd9be6108 100644
--- a/moa/src/main/java/moa/gui/LookAndFeel.java
+++ b/moa/src/main/java/moa/gui/LookAndFeel.java
@@ -20,207 +20,200 @@
 
 package moa.gui;
 
-import com.jidesoft.plaf.LookAndFeelFactory;
-
-import javax.swing.UIManager;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
+import javax.swing.UIManager;
+
+import com.jidesoft.plaf.LookAndFeelFactory;
+
 /**
- * Manages setting the look and feel.
- * Uses the {@link #KEY_LOOKANDFEEL} property from {@link GUIDefaults} to
- * determine what Look'n'Feel to use. See examples in the GUI.props file
- * for more details.
+ * Manages setting the look and feel. Uses the {@link #KEY_LOOKANDFEEL} property
+ * from {@link GUIDefaults} to determine what Look'n'Feel to use. See examples
+ * in the GUI.props file for more details.
  *
  * @author FracPete (fracpete at waikato dot ac dot nz)
  */
 public class LookAndFeel {
 
-    /** the LnF property in the GUI defaults. */
-    public static final String KEY_LOOKANDFEEL = "LookAndFeel";
-
-    /** the LnF for JIDE property in the GUI defaults. */
-    public static final String KEY_JIDELOOKANDFEEL = "JideLookAndFeel";
-
-    /** the Windows LnF classname. */
-    public static final String WINDOWS_LNF = LookAndFeelFactory.WINDOWS_LNF;
-
-    /** the cross-platform LnF classname. */
-    public static final String CROSSPLATFORM_LNF = LookAndFeelFactory.METAL_LNF;
-
-    /** for using the system's default LnF. */
-    public static final String VALUE_SYSTEM = "system";
-
-    /** for using the cross-platform LnF (= metal). */
-    public static final String VALUE_CROSSPLATFORM = "crossplatform";
-
-    /** for logging output. */
-    protected static Logger LOGGER;
-    static {
-        LOGGER = Logger.getLogger(LookAndFeel.class.getName());
-        LOGGER.setLevel(Level.INFO);
-    }
-
-
-    /**
-     * Attempts to install the specified Java Look'n'Feel.
-     *
-     * @param lnf the look'n'feel classname
-     * @return true if successfully installed
-     */
-    protected static boolean installJavaLookAndFeel(String lnf) {
-        boolean result = true;
-        switch (lnf) {
-            case "":
-                LOGGER.info("Using built-in strategy for setting Look'n'Feel...");
-                try {
-                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
-                }
-                catch (Throwable t) {
-                    try {
-                        UIManager.setLookAndFeel(WINDOWS_LNF);
-                    }
-                    catch (Throwable th) {
-                        result = false;
-                    }
-                }
-                break;
-
-            case VALUE_SYSTEM:
-                LOGGER.info("Using system Look'n'Feel...");
-                try {
-                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
-                }
-                catch (Throwable t) {
-                    result = false;
-                }
-                break;
-
-            case VALUE_CROSSPLATFORM:
-                LOGGER.info("Using cross-platform Look'n'Feel...");
-                try {
-                    UIManager.setLookAndFeel(CROSSPLATFORM_LNF);
-                }
-                catch (Throwable t) {
-                    result = false;
-                }
-                break;
-
-            default:
-                LOGGER.info("Using Look'n'Feel class: " + lnf);
-                try {
-                    UIManager.setLookAndFeel(lnf);
-                }
-                catch (Throwable t) {
-                    LOGGER.severe("Failed to instantiate Look'n'Feel class: " + lnf);
-                    result = false;
-                }
-                break;
-        }
-        return result;
-    }
-
-    /**
-     * Attempts to install the specified Look'n'Feel, but falls back on
-     * cross-platform look if it fails.
-     *
-     * @param lnf the look'n'feel classname
-     * @return true if successful
-     */
-    protected static boolean attemptInstallJavaLookAndFeel(String lnf) {
-        boolean result;
-        result = installJavaLookAndFeel(lnf);
-        if (!result) {
-            LOGGER.info("Falling back on cross-platform Look'n'Feel...");
-            result = installJavaLookAndFeel(CROSSPLATFORM_LNF);
-            if (!result)
-                LOGGER.severe("Failed to set cross-platform Look'n'Feel (" + CROSSPLATFORM_LNF + "), which should always succeed!");
-        }
-        return result;
-    }
-
-    /**
-     * Attempts to install the specified JIDE style.
-     *
-     * @param style the style to install, uses default strategy if -1
-     * @return true if successful
-     * @see LookAndFeelFactory
-     */
-    protected static boolean installJideLookAndFeel(int style) {
-        boolean result = true;
-
-        try {
-            if (style == -1) {
-                LOGGER.info("Using built-in strategy for setting JIDE Look'n'Feel...");
-                LookAndFeelFactory.installJideExtension();
-            }
-            else {
-                LOGGER.info("Using JIDE Look'n'Feel style: " + style);
-                LookAndFeelFactory.installJideExtension(style);
-            }
-        }
-        catch (Throwable t) {
-            result = false;
-            if (style == -1)
-                LOGGER.severe("Failed to install JIDE Look'n'Feel based on built-in strategy: " + t);
-            else
-                LOGGER.severe("Failed to install JIDE Look'n'Feel based on built-in strategy: " + t);
-        }
-
-        return result;
-    }
-
-    /**
-     * Attempts to install the specifoed JIDE style, but falls back on
-     * cross-platform Java Look'n'Feel and JIDE style {@link LookAndFeelFactory#VSNET_STYLE_WITHOUT_MENU}
-     * if it fails.
-     *
-     * @param style the style to install, uses default strategy if -1
-     * @return true if successful
-     * @see LookAndFeelFactory
-     */
-    protected static boolean attemptInstallJideLookAndFeel(int style) {
-        boolean result;
-        result = installJideLookAndFeel(style);
-        if (!result) {
-            LOGGER.info("Falling back on cross-platform Look'n'Feel and JIDE style " + LookAndFeelFactory.VSNET_STYLE_WITHOUT_MENU + "...");
-            result = installJavaLookAndFeel(CROSSPLATFORM_LNF)
-                && installJideLookAndFeel(LookAndFeelFactory.VSNET_STYLE_WITHOUT_MENU);
-            if (!result)
-                LOGGER.severe("Failed to set cross-platform Look'n'Feel (" + CROSSPLATFORM_LNF + ") and JIDE style " + LookAndFeelFactory.VSNET_STYLE_WITHOUT_MENU + ", which should always succeed!");
-        }
-        return result;
-    }
-
-    /**
-     * Installs the look and feel.
-     */
-    public static void install() {
-        String lnf;
-        int style;
-        boolean success;
-
-        // Java
-        lnf     = GUIDefaults.get(KEY_LOOKANDFEEL, "").trim();
-        success = attemptInstallJavaLookAndFeel(lnf);
-        LOGGER.info("Setting Java Look'n'Feel: " + success);
-
-        // JIDE
-        lnf = GUIDefaults.get(KEY_JIDELOOKANDFEEL, "").trim();
-        if (lnf.isEmpty()) {
-            success = attemptInstallJideLookAndFeel(-1);
-        }
-        else {
-            try {
-                style   = Integer.parseInt(lnf);
-                success = attemptInstallJideLookAndFeel(style);
-            }
-            catch (Throwable t) {
-                LOGGER.severe("JIDE Look'n'Feel must be an integer, found: " + lnf);
-                LOGGER.info("Falling back on JIDE Look'n'Feel style: " + LookAndFeelFactory.VSNET_STYLE_WITHOUT_MENU);
-                success = attemptInstallJideLookAndFeel(LookAndFeelFactory.VSNET_STYLE_WITHOUT_MENU);
-            }
-        }
-        LOGGER.info("Setting JIDE style: " + success);
-    }
+	/** the LnF property in the GUI defaults. */
+	public static final String KEY_LOOKANDFEEL = "LookAndFeel";
+
+	/** the LnF for JIDE property in the GUI defaults. */
+	public static final String KEY_JIDELOOKANDFEEL = "JideLookAndFeel";
+
+	/** the Windows LnF classname. */
+	public static final String WINDOWS_LNF = LookAndFeelFactory.WINDOWS_LNF;
+
+	/** the cross-platform LnF classname. */
+	public static final String CROSSPLATFORM_LNF = LookAndFeelFactory.METAL_LNF;
+
+	/** for using the system's default LnF. */
+	public static final String VALUE_SYSTEM = "system";
+
+	/** for using the cross-platform LnF (= metal). */
+	public static final String VALUE_CROSSPLATFORM = "crossplatform";
+
+	/** for logging output. */
+	protected static Logger LOGGER;
+	static {
+		LOGGER = Logger.getLogger(LookAndFeel.class.getName());
+		LOGGER.setLevel(Level.INFO);
+	}
+
+	/**
+	 * Attempts to install the specified Java Look'n'Feel.
+	 *
+	 * @param lnf the look'n'feel classname
+	 * @return true if successfully installed
+	 */
+	protected static boolean installJavaLookAndFeel(String lnf) {
+		boolean result = true;
+		switch (lnf) {
+		case "":
+			LOGGER.info("Using built-in strategy for setting Look'n'Feel...");
+			try {
+				UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
+			} catch (Throwable t) {
+				try {
+					UIManager.setLookAndFeel(WINDOWS_LNF);
+				} catch (Throwable th) {
+					result = false;
+				}
+			}
+			break;
+
+		case VALUE_SYSTEM:
+			LOGGER.info("Using system Look'n'Feel...");
+			try {
+				UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
+			} catch (Throwable t) {
+				result = false;
+			}
+			break;
+
+		case VALUE_CROSSPLATFORM:
+			LOGGER.info("Using cross-platform Look'n'Feel...");
+			try {
+				UIManager.setLookAndFeel(CROSSPLATFORM_LNF);
+			} catch (Throwable t) {
+				result = false;
+			}
+			break;
+
+		default:
+			LOGGER.info("Using Look'n'Feel class: " + lnf);
+			try {
+				UIManager.setLookAndFeel(lnf);
+			} catch (Throwable t) {
+				LOGGER.severe("Failed to instantiate Look'n'Feel class: " + lnf);
+				result = false;
+			}
+			break;
+		}
+		return result;
+	}
+
+	/**
+	 * Attempts to install the specified Look'n'Feel, but falls back on
+	 * cross-platform look if it fails.
+	 *
+	 * @param lnf the look'n'feel classname
+	 * @return true if successful
+	 */
+	protected static boolean attemptInstallJavaLookAndFeel(String lnf) {
+		boolean result;
+		result = installJavaLookAndFeel(lnf);
+		if (!result) {
+			LOGGER.info("Falling back on cross-platform Look'n'Feel...");
+			result = installJavaLookAndFeel(CROSSPLATFORM_LNF);
+			if (!result)
+				LOGGER.severe("Failed to set cross-platform Look'n'Feel (" + CROSSPLATFORM_LNF
+						+ "), which should always succeed!");
+		}
+		return result;
+	}
+
+	/**
+	 * Attempts to install the specified JIDE style.
+	 *
+	 * @param style the style to install, uses default strategy if -1
+	 * @return true if successful
+	 * @see LookAndFeelFactory
+	 */
+	protected static boolean installJideLookAndFeel(int style) {
+		boolean result = true;
+
+		try {
+			if (style == -1) {
+				LOGGER.info("Using built-in strategy for setting JIDE Look'n'Feel...");
+				LookAndFeelFactory.installJideExtension();
+			} else {
+				LOGGER.info("Using JIDE Look'n'Feel style: " + style);
+				LookAndFeelFactory.installJideExtension(style);
+			}
+		} catch (Throwable t) {
+			result = false;
+			if (style == -1)
+				LOGGER.severe("Failed to install JIDE Look'n'Feel based on built-in strategy: " + t);
+			else
+				LOGGER.severe("Failed to install JIDE Look'n'Feel based on built-in strategy: " + t);
+		}
+
+		return result;
+	}
+
+	/**
+	 * Attempts to install the specifoed JIDE style, but falls back on
+	 * cross-platform Java Look'n'Feel and JIDE style
+	 * {@link LookAndFeelFactory#VSNET_STYLE_WITHOUT_MENU} if it fails.
+	 *
+	 * @param style the style to install, uses default strategy if -1
+	 * @return true if successful
+	 * @see LookAndFeelFactory
+	 */
+	protected static boolean attemptInstallJideLookAndFeel(int style) {
+		boolean result;
+		result = installJideLookAndFeel(style);
+		if (!result) {
+			LOGGER.info("Falling back on cross-platform Look'n'Feel and JIDE style "
+					+ LookAndFeelFactory.VSNET_STYLE_WITHOUT_MENU + "...");
+			result = installJavaLookAndFeel(CROSSPLATFORM_LNF)
+					&& installJideLookAndFeel(LookAndFeelFactory.VSNET_STYLE_WITHOUT_MENU);
+			if (!result)
+				LOGGER.severe("Failed to set cross-platform Look'n'Feel (" + CROSSPLATFORM_LNF + ") and JIDE style "
+						+ LookAndFeelFactory.VSNET_STYLE_WITHOUT_MENU + ", which should always succeed!");
+		}
+		return result;
+	}
+
+	/**
+	 * Installs the look and feel.
+	 */
+	public static void install() {
+		String lnf;
+		int style;
+		boolean success;
+
+		// Java
+		lnf = GUIDefaults.get(KEY_LOOKANDFEEL, "").trim();
+		success = attemptInstallJavaLookAndFeel(lnf);
+		LOGGER.info("Setting Java Look'n'Feel: " + success);
+
+		// JIDE
+		lnf = GUIDefaults.get(KEY_JIDELOOKANDFEEL, "").trim();
+		if (lnf.isEmpty()) {
+			success = attemptInstallJideLookAndFeel(-1);
+		} else {
+			try {
+				style = Integer.parseInt(lnf);
+				success = attemptInstallJideLookAndFeel(style);
+			} catch (Throwable t) {
+				LOGGER.severe("JIDE Look'n'Feel must be an integer, found: " + lnf);
+				LOGGER.info("Falling back on JIDE Look'n'Feel style: " + LookAndFeelFactory.VSNET_STYLE_WITHOUT_MENU);
+				success = attemptInstallJideLookAndFeel(LookAndFeelFactory.VSNET_STYLE_WITHOUT_MENU);
+			}
+		}
+		LOGGER.info("Setting JIDE style: " + success);
+	}
 }
diff --git a/moa/src/main/java/moa/gui/MultiLabelClassificationTabPanel.java b/moa/src/main/java/moa/gui/MultiLabelClassificationTabPanel.java
index 84109aed2..8c84935e4 100644
--- a/moa/src/main/java/moa/gui/MultiLabelClassificationTabPanel.java
+++ b/moa/src/main/java/moa/gui/MultiLabelClassificationTabPanel.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
@@ -46,19 +46,17 @@ public MultiLabelClassificationTabPanel() {
 		add(this.previewPanel, BorderLayout.CENTER);
 	}
 
-	//returns the string to display as title of the tab
-    @Override
+	// returns the string to display as title of the tab
+	@Override
 	public String getTabTitle() {
 		return "Multi-label classification"; // "Learning";
 	}
 
-	//a short description (can be used as tool tip) of the tab, or contributor, etc.
-    @Override
-	public String getDescription(){
+	// a short description (can be used as tool tip) of the tab, or contributor,
+	// etc.
+	@Override
+	public String getDescription() {
 		return "MOA MultiLabel Learning";
 	}
 
 }
-
-
-
diff --git a/moa/src/main/java/moa/gui/MultiLabelClassificationTaskManagerPanel.java b/moa/src/main/java/moa/gui/MultiLabelClassificationTaskManagerPanel.java
index 45b243d0b..38965de0d 100644
--- a/moa/src/main/java/moa/gui/MultiLabelClassificationTaskManagerPanel.java
+++ b/moa/src/main/java/moa/gui/MultiLabelClassificationTaskManagerPanel.java
@@ -16,33 +16,10 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
-import moa.core.StringUtils;
-import moa.options.ClassOption;
-import moa.options.OptionHandler;
-import moa.tasks.Task;
-import moa.tasks.TaskThread;
-import nz.ac.waikato.cms.gui.core.BaseFileChooser;
-
-import javax.swing.JButton;
-import javax.swing.JFrame;
-import javax.swing.JMenuItem;
-import javax.swing.JOptionPane;
-import javax.swing.JPanel;
-import javax.swing.JPopupMenu;
-import javax.swing.JProgressBar;
-import javax.swing.JScrollPane;
-import javax.swing.JTable;
-import javax.swing.JTextField;
-import javax.swing.SwingConstants;
-import javax.swing.event.ListSelectionEvent;
-import javax.swing.event.ListSelectionListener;
-import javax.swing.table.AbstractTableModel;
-import javax.swing.table.DefaultTableCellRenderer;
-import javax.swing.table.TableCellRenderer;
 import java.awt.BorderLayout;
 import java.awt.Component;
 import java.awt.Dimension;
@@ -62,11 +39,32 @@
 import java.util.List;
 import java.util.prefs.Preferences;
 
-import javax.swing.UIManager;
-
+import javax.swing.JButton;
+import javax.swing.JFileChooser;
+import javax.swing.JFrame;
+import javax.swing.JMenuItem;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JPopupMenu;
+import javax.swing.JProgressBar;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
+import javax.swing.JTextField;
+import javax.swing.SwingConstants;
+import javax.swing.event.ListSelectionEvent;
+import javax.swing.event.ListSelectionListener;
+import javax.swing.table.AbstractTableModel;
+import javax.swing.table.DefaultTableCellRenderer;
+import javax.swing.table.TableCellRenderer;
 
+import moa.core.StringUtils;
+import moa.options.ClassOption;
+import moa.options.OptionHandler;
+import moa.tasks.Task;
+import moa.tasks.TaskThread;
 import moa.tasks.structuredoutput.multilabelclassification.EvaluatePrequential;
 import moa.tasks.structuredoutput.multilabelclassification.MultiLabelClassificatioMainTask;
+import nz.ac.waikato.cms.gui.core.BaseFileChooser;
 
 /**
  * This panel displays the running tasks.
@@ -75,449 +73,435 @@
  */
 public class MultiLabelClassificationTaskManagerPanel extends JPanel {
 
-    private static final long serialVersionUID = 1L;
-
-    public static final int MILLISECS_BETWEEN_REFRESH = 600;
-
-    public static String exportFileExtension = "log";
-
-    public class ProgressCellRenderer extends JProgressBar implements
-            TableCellRenderer {
-
-        private static final long serialVersionUID = 1L;
-
-        public ProgressCellRenderer() {
-            super(SwingConstants.HORIZONTAL, 0, 10000);
-            setBorderPainted(false);
-            setStringPainted(true);
-        }
-
-         @Override
-        public Component getTableCellRendererComponent(JTable table,
-                Object value, boolean isSelected, boolean hasFocus, int row,
-                int column) {
-            double frac = -1.0;
-            if (value instanceof Double) {
-                frac = ((Double) value).doubleValue();
-            }
-            if (frac >= 0.0) {
-                setIndeterminate(false);
-                setValue((int) (frac * 10000.0));
-                setString(StringUtils.doubleToString(frac * 100.0, 2, 2));
-            } else {
-                setValue(0);
-                //setIndeterminate(true);
-                //setString("?");
-            }
-            return this;
-        }
-
-        @Override
-        public void validate() {
-        }
-
-        @Override
-        public void revalidate() {
-        }
-
-        @Override
-        protected void firePropertyChange(String propertyName, Object oldValue,
-                Object newValue) {
-        }
-
-        @Override
-        public void firePropertyChange(String propertyName, boolean oldValue,
-                boolean newValue) {
-        }
-    }
-
-    protected class TaskTableModel extends AbstractTableModel {
-
-        private static final long serialVersionUID = 1L;
-
-        @Override
-        public String getColumnName(int col) {
-            switch (col) {
-                case 0:
-                    return "command";
-                case 1:
-                    return "status";
-                case 2:
-                    return "time elapsed";
-                case 3:
-                    return "current activity";
-                case 4:
-                    return "% complete";
-            }
-            return null;
-        }
-
-        @Override
-        public int getColumnCount() {
-            return 5;
-        }
-
-        @Override
-        public int getRowCount() {
-            return MultiLabelClassificationTaskManagerPanel.this.taskList.size();
-        }
-
-        @Override
-        public Object getValueAt(int row, int col) {
-            TaskThread thread = MultiLabelClassificationTaskManagerPanel.this.taskList.get(row);
-            switch (col) {
-                case 0:
-                    return ((OptionHandler) thread.getTask()).getCLICreationString(MultiLabelClassificatioMainTask.class);
-                case 1:
-                    return thread.getCurrentStatusString();
-                case 2:
-                    return StringUtils.secondsToDHMSString(thread.getCPUSecondsElapsed());
-                case 3:
-                    return thread.getCurrentActivityString();
-                case 4:
-                    return new Double(thread.getCurrentActivityFracComplete());
-            }
-            return null;
-        }
-
-        @Override
-        public boolean isCellEditable(int row, int col) {
-            return false;
-        }
-    }
-
-    protected MultiLabelClassificatioMainTask currentTask = new EvaluatePrequential();//LearnModel();
-
-    protected List<TaskThread> taskList = new ArrayList<TaskThread>();
-
-    protected JButton configureTaskButton = new JButton("Configure");
-
-    protected JTextField taskDescField = new JTextField();
-
-    protected JButton runTaskButton = new JButton("Run");
-
-    protected TaskTableModel taskTableModel;
-
-    protected JTable taskTable;
-
-    protected JButton pauseTaskButton = new JButton("Pause");
-
-    protected JButton resumeTaskButton = new JButton("Resume");
-
-    protected JButton cancelTaskButton = new JButton("Cancel");
-
-    protected JButton deleteTaskButton = new JButton("Delete");
-
-    protected PreviewPanel previewPanel;
-
-    private Preferences prefs;
-
-    private final String PREF_NAME = "currentTask";
-
-    public MultiLabelClassificationTaskManagerPanel() {
-        // Read current task preference
-        prefs = Preferences.userRoot().node(this.getClass().getName());
-        currentTask = new EvaluatePrequential();
-        String taskText = this.currentTask.getCLICreationString(MultiLabelClassificatioMainTask.class);
-        String propertyValue = prefs.get(PREF_NAME, taskText);
-        //this.taskDescField.setText(propertyValue);
-        setTaskString(propertyValue, false); //Not store preference
-        this.taskDescField.setEditable(false);
-        
-        final Component comp = this.taskDescField;
-        this.taskDescField.addMouseListener(new MouseAdapter() {
-
-            @Override
-            public void mouseClicked(MouseEvent evt) {
-                if (evt.getClickCount() == 1) {
-                    if ((evt.getButton() == MouseEvent.BUTTON3)
-                            || ((evt.getButton() == MouseEvent.BUTTON1) && evt.isAltDown() && evt.isShiftDown())) {
-                        JPopupMenu menu = new JPopupMenu();
-                        JMenuItem item;
-
-                        item = new JMenuItem("Copy configuration to clipboard");
-                        item.addActionListener(new ActionListener() {
-
-                            @Override
-                            public void actionPerformed(ActionEvent e) {
-                                copyClipBoardConfiguration();
-                            }
-                        });
-                        menu.add(item);
-
-
-
-                        item = new JMenuItem("Save selected tasks to file");
-                        item.addActionListener(new ActionListener() {
-
-                            @Override
-                            public void actionPerformed(ActionEvent arg0) {
-                                saveLogSelectedTasks();
-                            }
-                        });
-                        menu.add(item);
-
-
-                        item = new JMenuItem("Enter configuration...");
-                        item.addActionListener(new ActionListener() {
-
-                            @Override
-                            public void actionPerformed(ActionEvent arg0) {
-                                String newTaskString = JOptionPane.showInputDialog("Insert command line");
-                                if (newTaskString != null) {
-                                    setTaskString(newTaskString);
-                                }
-                            }
-                        });
-                        menu.add(item);
-
-                        menu.show(comp, evt.getX(), evt.getY());
-                    }
-                }
-            }
-        });
-
-        JPanel configPanel = new JPanel();
-        configPanel.setLayout(new BorderLayout());
-        configPanel.add(this.configureTaskButton, BorderLayout.WEST);
-        configPanel.add(this.taskDescField, BorderLayout.CENTER);
-        configPanel.add(this.runTaskButton, BorderLayout.EAST);
-        this.taskTableModel = new TaskTableModel();
-        this.taskTable = new JTable(this.taskTableModel);
-        DefaultTableCellRenderer centerRenderer = new DefaultTableCellRenderer();
-        centerRenderer.setHorizontalAlignment(SwingConstants.CENTER);
-        this.taskTable.getColumnModel().getColumn(1).setCellRenderer(
-                centerRenderer);
-        this.taskTable.getColumnModel().getColumn(2).setCellRenderer(
-                centerRenderer);
-        this.taskTable.getColumnModel().getColumn(4).setCellRenderer(
-                new ProgressCellRenderer());
-        JPanel controlPanel = new JPanel();
-        controlPanel.add(this.pauseTaskButton);
-        controlPanel.add(this.resumeTaskButton);
-        controlPanel.add(this.cancelTaskButton);
-        controlPanel.add(this.deleteTaskButton);
-        setLayout(new BorderLayout());
-        add(configPanel, BorderLayout.NORTH);
-        add(new JScrollPane(this.taskTable), BorderLayout.CENTER);
-        add(controlPanel, BorderLayout.SOUTH);
-        this.taskTable.getSelectionModel().addListSelectionListener(
-                new ListSelectionListener() {
-
-                    @Override
-                    public void valueChanged(ListSelectionEvent arg0) {
-                        taskSelectionChanged();
-                    }
-                });
-        this.configureTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                String newTaskString = ClassOptionSelectionPanel.showSelectClassDialog(MultiLabelClassificationTaskManagerPanel.this,
-                        "Configure task", MultiLabelClassificatioMainTask.class,
-                        MultiLabelClassificationTaskManagerPanel.this.currentTask.getCLICreationString(MultiLabelClassificatioMainTask.class),
-                        null);
-                setTaskString(newTaskString);
-            }
-        });
-        this.runTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                runTask((Task) MultiLabelClassificationTaskManagerPanel.this.currentTask.copy());
-            }
-        });
-        this.pauseTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                pauseSelectedTasks();
-            }
-        });
-        this.resumeTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                resumeSelectedTasks();
-            }
-        });
-        this.cancelTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                cancelSelectedTasks();
-            }
-        });
-        this.deleteTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                deleteSelectedTasks();
-            }
-        });
-
-        javax.swing.Timer updateListTimer = new javax.swing.Timer(
-                MILLISECS_BETWEEN_REFRESH, new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                MultiLabelClassificationTaskManagerPanel.this.taskTable.repaint();
-            }
-        });
-        updateListTimer.start();
-        setPreferredSize(new Dimension(0, 200));
-    }
-
-    public void setPreviewPanel(PreviewPanel previewPanel) {
-        this.previewPanel = previewPanel;
-    }
-
-    public void setTaskString(String cliString) {
-        setTaskString(cliString, true);
-    }
-    
-    public void setTaskString(String cliString, boolean storePreference) {    
-        try {
-            this.currentTask = (MultiLabelClassificatioMainTask) ClassOption.cliStringToObject(
-                    cliString, MultiLabelClassificatioMainTask.class, null);
-            String taskText = this.currentTask.getCLICreationString(MultiLabelClassificatioMainTask.class);
-            this.taskDescField.setText(taskText);
-            if (storePreference == true){
-            //Save task text as a preference
-            prefs.put(PREF_NAME, taskText);
-            }
-        } catch (Exception ex) {
-            GUIUtils.showExceptionDialog(this, "Problem with task", ex);
-        }
-    }
-
-    public void runTask(Task task) {
-        TaskThread thread = new TaskThread(task);
-        this.taskList.add(0, thread);
-        this.taskTableModel.fireTableDataChanged();
-        this.taskTable.setRowSelectionInterval(0, 0);
-        thread.start();
-    }
-
-    public void taskSelectionChanged() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        if (selectedTasks.length == 1) {
-            setTaskString(((OptionHandler) selectedTasks[0].getTask()).getCLICreationString(MultiLabelClassificatioMainTask.class));
-            if (this.previewPanel != null) {
-                this.previewPanel.setTaskThreadToPreview(selectedTasks[0]);
-            }
-        } else {
-            this.previewPanel.setTaskThreadToPreview(null);
-        }
-    }
-
-    public TaskThread[] getSelectedTasks() {
-        int[] selectedRows = this.taskTable.getSelectedRows();
-        TaskThread[] selectedTasks = new TaskThread[selectedRows.length];
-        for (int i = 0; i < selectedRows.length; i++) {
-            selectedTasks[i] = this.taskList.get(selectedRows[i]);
-        }
-        return selectedTasks;
-    }
-
-    public void pauseSelectedTasks() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            thread.pauseTask();
-        }
-    }
-
-    public void resumeSelectedTasks() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            thread.resumeTask();
-        }
-    }
-
-    public void cancelSelectedTasks() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            thread.cancelTask();
-        }
-    }
-
-    public void deleteSelectedTasks() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            thread.cancelTask();
-            this.taskList.remove(thread);
-        }
-        this.taskTableModel.fireTableDataChanged();
-    }
-
-    public void copyClipBoardConfiguration() {
-
-        StringSelection selection = new StringSelection(this.taskDescField.getText().trim());
-        Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
-        clipboard.setContents(selection, selection);
-
-    }
-
-    public void saveLogSelectedTasks() {
-        String tasksLog = "";
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            tasksLog += ((OptionHandler) thread.getTask()).getCLICreationString(MultiLabelClassificatioMainTask.class) + "\n";
-        }
-
-        BaseFileChooser fileChooser = new BaseFileChooser();
-        fileChooser.setAcceptAllFileFilterUsed(true);
-        fileChooser.addChoosableFileFilter(new FileExtensionFilter(
-                exportFileExtension));
-        if (fileChooser.showSaveDialog(this) == BaseFileChooser.APPROVE_OPTION) {
-            File chosenFile = fileChooser.getSelectedFile();
-            String fileName = chosenFile.getPath();
-            if (!chosenFile.exists()
-                    && !fileName.endsWith(exportFileExtension)) {
-                fileName = fileName + "." + exportFileExtension;
-            }
-            try {
-                PrintWriter out = new PrintWriter(new BufferedWriter(
-                        new FileWriter(fileName)));
-                out.write(tasksLog);
-                out.close();
-            } catch (IOException ioe) {
-                GUIUtils.showExceptionDialog(
-                        this,
-                        "Problem saving file " + fileName, ioe);
-            }
-        }
-    }
-
-    private static void createAndShowGUI() {
-
-        // Create and set up the window.
-        JFrame frame = new JFrame("Test");
-        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-
-        // Create and set up the content pane.
-        JPanel panel = new MultiLabelClassificationTaskManagerPanel();
-        panel.setOpaque(true); // content panes must be opaque
-        frame.setContentPane(panel);
-
-        // Display the window.
-        frame.pack();
-        // frame.setSize(400, 400);
-        frame.setVisible(true);
-    }
-
-    public static void main(String[] args) {
-        try {
-            LookAndFeel.install();
-            javax.swing.SwingUtilities.invokeLater(new Runnable() {
-
-                @Override
-                public void run() {
-                    createAndShowGUI();
-                }
-            });
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
+	private static final long serialVersionUID = 1L;
+
+	public static final int MILLISECS_BETWEEN_REFRESH = 600;
+
+	public static String exportFileExtension = "log";
+
+	public class ProgressCellRenderer extends JProgressBar implements TableCellRenderer {
+
+		private static final long serialVersionUID = 1L;
+
+		public ProgressCellRenderer() {
+			super(SwingConstants.HORIZONTAL, 0, 10000);
+			setBorderPainted(false);
+			setStringPainted(true);
+		}
+
+		@Override
+		public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
+				int row, int column) {
+			double frac = -1.0;
+			if (value instanceof Double) {
+				frac = ((Double) value);
+			}
+			if (frac >= 0.0) {
+				setIndeterminate(false);
+				setValue((int) (frac * 10000.0));
+				setString(StringUtils.doubleToString(frac * 100.0, 2, 2));
+			} else {
+				setValue(0);
+				// setIndeterminate(true);
+				// setString("?");
+			}
+			return this;
+		}
+
+		@Override
+		public void validate() {
+		}
+
+		@Override
+		public void revalidate() {
+		}
+
+		@Override
+		protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
+		}
+
+		@Override
+		public void firePropertyChange(String propertyName, boolean oldValue, boolean newValue) {
+		}
+	}
+
+	protected class TaskTableModel extends AbstractTableModel {
+
+		private static final long serialVersionUID = 1L;
+
+		@Override
+		public String getColumnName(int col) {
+			switch (col) {
+			case 0:
+				return "command";
+			case 1:
+				return "status";
+			case 2:
+				return "time elapsed";
+			case 3:
+				return "current activity";
+			case 4:
+				return "% complete";
+			}
+			return null;
+		}
+
+		@Override
+		public int getColumnCount() {
+			return 5;
+		}
+
+		@Override
+		public int getRowCount() {
+			return MultiLabelClassificationTaskManagerPanel.this.taskList.size();
+		}
+
+		@Override
+		public Object getValueAt(int row, int col) {
+			TaskThread thread = MultiLabelClassificationTaskManagerPanel.this.taskList.get(row);
+			switch (col) {
+			case 0:
+				return ((OptionHandler) thread.getTask()).getCLICreationString(MultiLabelClassificatioMainTask.class);
+			case 1:
+				return thread.getCurrentStatusString();
+			case 2:
+				return StringUtils.secondsToDHMSString(thread.getCPUSecondsElapsed());
+			case 3:
+				return thread.getCurrentActivityString();
+			case 4:
+				return new Double(thread.getCurrentActivityFracComplete());
+			}
+			return null;
+		}
+
+		@Override
+		public boolean isCellEditable(int row, int col) {
+			return false;
+		}
+	}
+
+	protected MultiLabelClassificatioMainTask currentTask = new EvaluatePrequential();// LearnModel();
+
+	protected List<TaskThread> taskList = new ArrayList<>();
+
+	protected JButton configureTaskButton = new JButton("Configure");
+
+	protected JTextField taskDescField = new JTextField();
+
+	protected JButton runTaskButton = new JButton("Run");
+
+	protected TaskTableModel taskTableModel;
+
+	protected JTable taskTable;
+
+	protected JButton pauseTaskButton = new JButton("Pause");
+
+	protected JButton resumeTaskButton = new JButton("Resume");
+
+	protected JButton cancelTaskButton = new JButton("Cancel");
+
+	protected JButton deleteTaskButton = new JButton("Delete");
+
+	protected PreviewPanel previewPanel;
+
+	private Preferences prefs;
+
+	private final String PREF_NAME = "currentTask";
+
+	public MultiLabelClassificationTaskManagerPanel() {
+		// Read current task preference
+		prefs = Preferences.userRoot().node(this.getClass().getName());
+		currentTask = new EvaluatePrequential();
+		String taskText = this.currentTask.getCLICreationString(MultiLabelClassificatioMainTask.class);
+		String propertyValue = prefs.get(PREF_NAME, taskText);
+		// this.taskDescField.setText(propertyValue);
+		setTaskString(propertyValue, false); // Not store preference
+		this.taskDescField.setEditable(false);
+
+		final Component comp = this.taskDescField;
+		this.taskDescField.addMouseListener(new MouseAdapter() {
+
+			@Override
+			public void mouseClicked(MouseEvent evt) {
+				if (evt.getClickCount() == 1) {
+					if ((evt.getButton() == MouseEvent.BUTTON3)
+							|| ((evt.getButton() == MouseEvent.BUTTON1) && evt.isAltDown() && evt.isShiftDown())) {
+						JPopupMenu menu = new JPopupMenu();
+						JMenuItem item;
+
+						item = new JMenuItem("Copy configuration to clipboard");
+						item.addActionListener(new ActionListener() {
+
+							@Override
+							public void actionPerformed(ActionEvent e) {
+								copyClipBoardConfiguration();
+							}
+						});
+						menu.add(item);
+
+						item = new JMenuItem("Save selected tasks to file");
+						item.addActionListener(new ActionListener() {
+
+							@Override
+							public void actionPerformed(ActionEvent arg0) {
+								saveLogSelectedTasks();
+							}
+						});
+						menu.add(item);
+
+						item = new JMenuItem("Enter configuration...");
+						item.addActionListener(new ActionListener() {
+
+							@Override
+							public void actionPerformed(ActionEvent arg0) {
+								String newTaskString = JOptionPane.showInputDialog("Insert command line");
+								if (newTaskString != null) {
+									setTaskString(newTaskString);
+								}
+							}
+						});
+						menu.add(item);
+
+						menu.show(comp, evt.getX(), evt.getY());
+					}
+				}
+			}
+		});
+
+		JPanel configPanel = new JPanel();
+		configPanel.setLayout(new BorderLayout());
+		configPanel.add(this.configureTaskButton, BorderLayout.WEST);
+		configPanel.add(this.taskDescField, BorderLayout.CENTER);
+		configPanel.add(this.runTaskButton, BorderLayout.EAST);
+		this.taskTableModel = new TaskTableModel();
+		this.taskTable = new JTable(this.taskTableModel);
+		DefaultTableCellRenderer centerRenderer = new DefaultTableCellRenderer();
+		centerRenderer.setHorizontalAlignment(SwingConstants.CENTER);
+		this.taskTable.getColumnModel().getColumn(1).setCellRenderer(centerRenderer);
+		this.taskTable.getColumnModel().getColumn(2).setCellRenderer(centerRenderer);
+		this.taskTable.getColumnModel().getColumn(4).setCellRenderer(new ProgressCellRenderer());
+		JPanel controlPanel = new JPanel();
+		controlPanel.add(this.pauseTaskButton);
+		controlPanel.add(this.resumeTaskButton);
+		controlPanel.add(this.cancelTaskButton);
+		controlPanel.add(this.deleteTaskButton);
+		setLayout(new BorderLayout());
+		add(configPanel, BorderLayout.NORTH);
+		add(new JScrollPane(this.taskTable), BorderLayout.CENTER);
+		add(controlPanel, BorderLayout.SOUTH);
+		this.taskTable.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
+
+			@Override
+			public void valueChanged(ListSelectionEvent arg0) {
+				taskSelectionChanged();
+			}
+		});
+		this.configureTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				String newTaskString = ClassOptionSelectionPanel.showSelectClassDialog(
+						MultiLabelClassificationTaskManagerPanel.this, "Configure task",
+						MultiLabelClassificatioMainTask.class, MultiLabelClassificationTaskManagerPanel.this.currentTask
+								.getCLICreationString(MultiLabelClassificatioMainTask.class),
+						null);
+				setTaskString(newTaskString);
+			}
+		});
+		this.runTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				runTask((Task) MultiLabelClassificationTaskManagerPanel.this.currentTask.copy());
+			}
+		});
+		this.pauseTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				pauseSelectedTasks();
+			}
+		});
+		this.resumeTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				resumeSelectedTasks();
+			}
+		});
+		this.cancelTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				cancelSelectedTasks();
+			}
+		});
+		this.deleteTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				deleteSelectedTasks();
+			}
+		});
+
+		javax.swing.Timer updateListTimer = new javax.swing.Timer(MILLISECS_BETWEEN_REFRESH, new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				MultiLabelClassificationTaskManagerPanel.this.taskTable.repaint();
+			}
+		});
+		updateListTimer.start();
+		setPreferredSize(new Dimension(0, 200));
+	}
+
+	public void setPreviewPanel(PreviewPanel previewPanel) {
+		this.previewPanel = previewPanel;
+	}
+
+	public void setTaskString(String cliString) {
+		setTaskString(cliString, true);
+	}
+
+	public void setTaskString(String cliString, boolean storePreference) {
+		try {
+			this.currentTask = (MultiLabelClassificatioMainTask) ClassOption.cliStringToObject(cliString,
+					MultiLabelClassificatioMainTask.class, null);
+			String taskText = this.currentTask.getCLICreationString(MultiLabelClassificatioMainTask.class);
+			this.taskDescField.setText(taskText);
+			if (storePreference == true) {
+				// Save task text as a preference
+				prefs.put(PREF_NAME, taskText);
+			}
+		} catch (Exception ex) {
+			GUIUtils.showExceptionDialog(this, "Problem with task", ex);
+		}
+	}
+
+	public void runTask(Task task) {
+		TaskThread thread = new TaskThread(task);
+		this.taskList.add(0, thread);
+		this.taskTableModel.fireTableDataChanged();
+		this.taskTable.setRowSelectionInterval(0, 0);
+		thread.start();
+	}
+
+	public void taskSelectionChanged() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		if (selectedTasks.length == 1) {
+			setTaskString(((OptionHandler) selectedTasks[0].getTask())
+					.getCLICreationString(MultiLabelClassificatioMainTask.class));
+			if (this.previewPanel != null) {
+				this.previewPanel.setTaskThreadToPreview(selectedTasks[0]);
+			}
+		} else {
+			this.previewPanel.setTaskThreadToPreview(null);
+		}
+	}
+
+	public TaskThread[] getSelectedTasks() {
+		int[] selectedRows = this.taskTable.getSelectedRows();
+		TaskThread[] selectedTasks = new TaskThread[selectedRows.length];
+		for (int i = 0; i < selectedRows.length; i++) {
+			selectedTasks[i] = this.taskList.get(selectedRows[i]);
+		}
+		return selectedTasks;
+	}
+
+	public void pauseSelectedTasks() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			thread.pauseTask();
+		}
+	}
+
+	public void resumeSelectedTasks() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			thread.resumeTask();
+		}
+	}
+
+	public void cancelSelectedTasks() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			thread.cancelTask();
+		}
+	}
+
+	public void deleteSelectedTasks() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			thread.cancelTask();
+			this.taskList.remove(thread);
+		}
+		this.taskTableModel.fireTableDataChanged();
+	}
+
+	public void copyClipBoardConfiguration() {
+
+		StringSelection selection = new StringSelection(this.taskDescField.getText().trim());
+		Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
+		clipboard.setContents(selection, selection);
+
+	}
+
+	public void saveLogSelectedTasks() {
+		String tasksLog = "";
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			tasksLog += ((OptionHandler) thread.getTask()).getCLICreationString(MultiLabelClassificatioMainTask.class)
+					+ "\n";
+		}
+
+		BaseFileChooser fileChooser = new BaseFileChooser();
+		fileChooser.setAcceptAllFileFilterUsed(true);
+		fileChooser.addChoosableFileFilter(new FileExtensionFilter(exportFileExtension));
+		if (fileChooser.showSaveDialog(this) == JFileChooser.APPROVE_OPTION) {
+			File chosenFile = fileChooser.getSelectedFile();
+			String fileName = chosenFile.getPath();
+			if (!chosenFile.exists() && !fileName.endsWith(exportFileExtension)) {
+				fileName = fileName + "." + exportFileExtension;
+			}
+			try {
+				PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(fileName)));
+				out.write(tasksLog);
+				out.close();
+			} catch (IOException ioe) {
+				GUIUtils.showExceptionDialog(this, "Problem saving file " + fileName, ioe);
+			}
+		}
+	}
+
+	private static void createAndShowGUI() {
+
+		// Create and set up the window.
+		JFrame frame = new JFrame("Test");
+		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+
+		// Create and set up the content pane.
+		JPanel panel = new MultiLabelClassificationTaskManagerPanel();
+		panel.setOpaque(true); // content panes must be opaque
+		frame.setContentPane(panel);
+
+		// Display the window.
+		frame.pack();
+		// frame.setSize(400, 400);
+		frame.setVisible(true);
+	}
+
+	public static void main(String[] args) {
+		try {
+			LookAndFeel.install();
+			javax.swing.SwingUtilities.invokeLater(new Runnable() {
+
+				@Override
+				public void run() {
+					createAndShowGUI();
+				}
+			});
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
 }
diff --git a/moa/src/main/java/moa/gui/MultiTargetRegressionTabPanel.java b/moa/src/main/java/moa/gui/MultiTargetRegressionTabPanel.java
index 170092f2e..f50550040 100644
--- a/moa/src/main/java/moa/gui/MultiTargetRegressionTabPanel.java
+++ b/moa/src/main/java/moa/gui/MultiTargetRegressionTabPanel.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
@@ -46,19 +46,17 @@ public MultiTargetRegressionTabPanel() {
 		add(this.previewPanel, BorderLayout.CENTER);
 	}
 
-	//returns the string to display as title of the tab
-    @Override
+	// returns the string to display as title of the tab
+	@Override
 	public String getTabTitle() {
 		return "Multi-target regression"; // "Learning";
 	}
 
-	//a short description (can be used as tool tip) of the tab, or contributor, etc.
-    @Override
-	public String getDescription(){
+	// a short description (can be used as tool tip) of the tab, or contributor,
+	// etc.
+	@Override
+	public String getDescription() {
 		return "MOA MultiTarget Learning";
 	}
 
 }
-
-
-
diff --git a/moa/src/main/java/moa/gui/MultiTargetRegressionTaskManagerPanel.java b/moa/src/main/java/moa/gui/MultiTargetRegressionTaskManagerPanel.java
index c86f17cdc..087551799 100644
--- a/moa/src/main/java/moa/gui/MultiTargetRegressionTaskManagerPanel.java
+++ b/moa/src/main/java/moa/gui/MultiTargetRegressionTaskManagerPanel.java
@@ -16,33 +16,10 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
-import moa.core.StringUtils;
-import moa.options.ClassOption;
-import moa.options.OptionHandler;
-import moa.tasks.Task;
-import moa.tasks.TaskThread;
-import nz.ac.waikato.cms.gui.core.BaseFileChooser;
-
-import javax.swing.JButton;
-import javax.swing.JFrame;
-import javax.swing.JMenuItem;
-import javax.swing.JOptionPane;
-import javax.swing.JPanel;
-import javax.swing.JPopupMenu;
-import javax.swing.JProgressBar;
-import javax.swing.JScrollPane;
-import javax.swing.JTable;
-import javax.swing.JTextField;
-import javax.swing.SwingConstants;
-import javax.swing.event.ListSelectionEvent;
-import javax.swing.event.ListSelectionListener;
-import javax.swing.table.AbstractTableModel;
-import javax.swing.table.DefaultTableCellRenderer;
-import javax.swing.table.TableCellRenderer;
 import java.awt.BorderLayout;
 import java.awt.Component;
 import java.awt.Dimension;
@@ -63,6 +40,7 @@
 import java.util.prefs.Preferences;
 
 import javax.swing.JButton;
+import javax.swing.JFileChooser;
 import javax.swing.JFrame;
 import javax.swing.JMenuItem;
 import javax.swing.JOptionPane;
@@ -73,7 +51,6 @@
 import javax.swing.JTable;
 import javax.swing.JTextField;
 import javax.swing.SwingConstants;
-import javax.swing.UIManager;
 import javax.swing.event.ListSelectionEvent;
 import javax.swing.event.ListSelectionListener;
 import javax.swing.table.AbstractTableModel;
@@ -96,449 +73,435 @@
  */
 public class MultiTargetRegressionTaskManagerPanel extends JPanel {
 
-    private static final long serialVersionUID = 1L;
-
-    public static final int MILLISECS_BETWEEN_REFRESH = 600;
-
-    public static String exportFileExtension = "log";
-
-    public class ProgressCellRenderer extends JProgressBar implements
-            TableCellRenderer {
-
-        private static final long serialVersionUID = 1L;
-
-        public ProgressCellRenderer() {
-            super(SwingConstants.HORIZONTAL, 0, 10000);
-            setBorderPainted(false);
-            setStringPainted(true);
-        }
-
-         @Override
-        public Component getTableCellRendererComponent(JTable table,
-                Object value, boolean isSelected, boolean hasFocus, int row,
-                int column) {
-            double frac = -1.0;
-            if (value instanceof Double) {
-                frac = ((Double) value).doubleValue();
-            }
-            if (frac >= 0.0) {
-                setIndeterminate(false);
-                setValue((int) (frac * 10000.0));
-                setString(StringUtils.doubleToString(frac * 100.0, 2, 2));
-            } else {
-                setValue(0);
-                //setIndeterminate(true);
-                //setString("?");
-            }
-            return this;
-        }
-
-        @Override
-        public void validate() {
-        }
-
-        @Override
-        public void revalidate() {
-        }
-
-        @Override
-        protected void firePropertyChange(String propertyName, Object oldValue,
-                Object newValue) {
-        }
-
-        @Override
-        public void firePropertyChange(String propertyName, boolean oldValue,
-                boolean newValue) {
-        }
-    }
-
-    protected class TaskTableModel extends AbstractTableModel {
-
-        private static final long serialVersionUID = 1L;
-
-        @Override
-        public String getColumnName(int col) {
-            switch (col) {
-                case 0:
-                    return "command";
-                case 1:
-                    return "status";
-                case 2:
-                    return "time elapsed";
-                case 3:
-                    return "current activity";
-                case 4:
-                    return "% complete";
-            }
-            return null;
-        }
-
-        @Override
-        public int getColumnCount() {
-            return 5;
-        }
-
-        @Override
-        public int getRowCount() {
-            return MultiTargetRegressionTaskManagerPanel.this.taskList.size();
-        }
-
-        @Override
-        public Object getValueAt(int row, int col) {
-            TaskThread thread = MultiTargetRegressionTaskManagerPanel.this.taskList.get(row);
-            switch (col) {
-                case 0:
-                    return ((OptionHandler) thread.getTask()).getCLICreationString(MultiTargetRegressionMainTask.class);
-                case 1:
-                    return thread.getCurrentStatusString();
-                case 2:
-                    return StringUtils.secondsToDHMSString(thread.getCPUSecondsElapsed());
-                case 3:
-                    return thread.getCurrentActivityString();
-                case 4:
-                    return new Double(thread.getCurrentActivityFracComplete());
-            }
-            return null;
-        }
-
-        @Override
-        public boolean isCellEditable(int row, int col) {
-            return false;
-        }
-    }
-
-    protected MultiTargetRegressionMainTask currentTask = new EvaluatePrequential();
-
-    protected List<TaskThread> taskList = new ArrayList<TaskThread>();
-
-    protected JButton configureTaskButton = new JButton("Configure");
-
-    protected JTextField taskDescField = new JTextField();
-
-    protected JButton runTaskButton = new JButton("Run");
-
-    protected TaskTableModel taskTableModel;
-
-    protected JTable taskTable;
-
-    protected JButton pauseTaskButton = new JButton("Pause");
-
-    protected JButton resumeTaskButton = new JButton("Resume");
-
-    protected JButton cancelTaskButton = new JButton("Cancel");
-
-    protected JButton deleteTaskButton = new JButton("Delete");
-
-    protected PreviewPanel previewPanel;
-
-    private Preferences prefs;
-    
-    private final String PREF_NAME = "currentTask";
-    
-    public MultiTargetRegressionTaskManagerPanel() {
-        // Read current task preference
-        prefs = Preferences.userRoot().node(this.getClass().getName());
-        currentTask = new EvaluatePrequential();
-        String taskText = this.currentTask.getCLICreationString(MultiTargetRegressionMainTask.class);
-        String propertyValue = prefs.get(PREF_NAME, taskText);
-        //this.taskDescField.setText(propertyValue);
-        setTaskString(propertyValue, false); //Not store preference
-        this.taskDescField.setEditable(false);
-        
-        final Component comp = this.taskDescField;
-        this.taskDescField.addMouseListener(new MouseAdapter() {
-
-            @Override
-            public void mouseClicked(MouseEvent evt) {
-                if (evt.getClickCount() == 1) {
-                    if ((evt.getButton() == MouseEvent.BUTTON3)
-                            || ((evt.getButton() == MouseEvent.BUTTON1) && evt.isAltDown() && evt.isShiftDown())) {
-                        JPopupMenu menu = new JPopupMenu();
-                        JMenuItem item;
-
-                        item = new JMenuItem("Copy configuration to clipboard");
-                        item.addActionListener(new ActionListener() {
-
-                            @Override
-                            public void actionPerformed(ActionEvent e) {
-                                copyClipBoardConfiguration();
-                            }
-                        });
-                        menu.add(item);
-
-
-
-                        item = new JMenuItem("Save selected tasks to file");
-                        item.addActionListener(new ActionListener() {
-
-                            @Override
-                            public void actionPerformed(ActionEvent arg0) {
-                                saveLogSelectedTasks();
-                            }
-                        });
-                        menu.add(item);
-
-
-                        item = new JMenuItem("Enter configuration...");
-                        item.addActionListener(new ActionListener() {
-
-                            @Override
-                            public void actionPerformed(ActionEvent arg0) {
-                                String newTaskString = JOptionPane.showInputDialog("Insert command line");
-                                if (newTaskString != null) {
-                                    setTaskString(newTaskString);
-                                }
-                            }
-                        });
-                        menu.add(item);
-
-                        menu.show(comp, evt.getX(), evt.getY());
-                    }
-                }
-            }
-        });
-
-        JPanel configPanel = new JPanel();
-        configPanel.setLayout(new BorderLayout());
-        configPanel.add(this.configureTaskButton, BorderLayout.WEST);
-        configPanel.add(this.taskDescField, BorderLayout.CENTER);
-        configPanel.add(this.runTaskButton, BorderLayout.EAST);
-        this.taskTableModel = new TaskTableModel();
-        this.taskTable = new JTable(this.taskTableModel);
-        DefaultTableCellRenderer centerRenderer = new DefaultTableCellRenderer();
-        centerRenderer.setHorizontalAlignment(SwingConstants.CENTER);
-        this.taskTable.getColumnModel().getColumn(1).setCellRenderer(
-                centerRenderer);
-        this.taskTable.getColumnModel().getColumn(2).setCellRenderer(
-                centerRenderer);
-        this.taskTable.getColumnModel().getColumn(4).setCellRenderer(
-                new ProgressCellRenderer());
-        JPanel controlPanel = new JPanel();
-        controlPanel.add(this.pauseTaskButton);
-        controlPanel.add(this.resumeTaskButton);
-        controlPanel.add(this.cancelTaskButton);
-        controlPanel.add(this.deleteTaskButton);
-        setLayout(new BorderLayout());
-        add(configPanel, BorderLayout.NORTH);
-        add(new JScrollPane(this.taskTable), BorderLayout.CENTER);
-        add(controlPanel, BorderLayout.SOUTH);
-        this.taskTable.getSelectionModel().addListSelectionListener(
-                new ListSelectionListener() {
-
-                    @Override
-                    public void valueChanged(ListSelectionEvent arg0) {
-                        taskSelectionChanged();
-                    }
-                });
-        this.configureTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                String newTaskString = ClassOptionSelectionPanel.showSelectClassDialog(MultiTargetRegressionTaskManagerPanel.this,
-                        "Configure task", MultiTargetRegressionMainTask.class,
-                        MultiTargetRegressionTaskManagerPanel.this.currentTask.getCLICreationString(MultiTargetRegressionMainTask.class),
-                        null);
-                setTaskString(newTaskString);
-            }
-        });
-        this.runTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                runTask((Task) MultiTargetRegressionTaskManagerPanel.this.currentTask.copy());
-            }
-        });
-        this.pauseTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                pauseSelectedTasks();
-            }
-        });
-        this.resumeTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                resumeSelectedTasks();
-            }
-        });
-        this.cancelTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                cancelSelectedTasks();
-            }
-        });
-        this.deleteTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                deleteSelectedTasks();
-            }
-        });
-
-        javax.swing.Timer updateListTimer = new javax.swing.Timer(
-                MILLISECS_BETWEEN_REFRESH, new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                MultiTargetRegressionTaskManagerPanel.this.taskTable.repaint();
-            }
-        });
-        updateListTimer.start();
-        setPreferredSize(new Dimension(0, 200));
-    }
-
-    public void setPreviewPanel(PreviewPanel previewPanel) {
-        this.previewPanel = previewPanel;
-    }
-
-    public void setTaskString(String cliString) {
-        setTaskString(cliString, true);
-    }
-    
-    public void setTaskString(String cliString, boolean storePreference) {    
-        try {
-            this.currentTask = (MultiTargetRegressionMainTask) ClassOption.cliStringToObject(
-                    cliString, MultiTargetRegressionMainTask.class, null);
-            String taskText = this.currentTask.getCLICreationString(MultiTargetRegressionMainTask.class);
-            this.taskDescField.setText(taskText);
-            if (storePreference == true){
-            //Save task text as a preference
-            prefs.put(PREF_NAME, taskText);
-            }
-        } catch (Exception ex) {
-            GUIUtils.showExceptionDialog(this, "Problem with task", ex);
-        }
-    }
-
-    public void runTask(Task task) {
-        TaskThread thread = new TaskThread(task);
-        this.taskList.add(0, thread);
-        this.taskTableModel.fireTableDataChanged();
-        this.taskTable.setRowSelectionInterval(0, 0);
-        thread.start();
-    }
-
-    public void taskSelectionChanged() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        if (selectedTasks.length == 1) {
-            setTaskString(((OptionHandler) selectedTasks[0].getTask()).getCLICreationString(MultiTargetRegressionMainTask.class));
-            if (this.previewPanel != null) {
-                this.previewPanel.setTaskThreadToPreview(selectedTasks[0]);
-            }
-        } else {
-            this.previewPanel.setTaskThreadToPreview(null);
-        }
-    }
-
-    public TaskThread[] getSelectedTasks() {
-        int[] selectedRows = this.taskTable.getSelectedRows();
-        TaskThread[] selectedTasks = new TaskThread[selectedRows.length];
-        for (int i = 0; i < selectedRows.length; i++) {
-            selectedTasks[i] = this.taskList.get(selectedRows[i]);
-        }
-        return selectedTasks;
-    }
-
-    public void pauseSelectedTasks() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            thread.pauseTask();
-        }
-    }
-
-    public void resumeSelectedTasks() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            thread.resumeTask();
-        }
-    }
-
-    public void cancelSelectedTasks() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            thread.cancelTask();
-        }
-    }
-
-    public void deleteSelectedTasks() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            thread.cancelTask();
-            this.taskList.remove(thread);
-        }
-        this.taskTableModel.fireTableDataChanged();
-    }
-
-    public void copyClipBoardConfiguration() {
-
-        StringSelection selection = new StringSelection(this.taskDescField.getText().trim());
-        Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
-        clipboard.setContents(selection, selection);
-
-    }
-
-    public void saveLogSelectedTasks() {
-        String tasksLog = "";
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            tasksLog += ((OptionHandler) thread.getTask()).getCLICreationString(MultiTargetRegressionMainTask.class) + "\n";
-        }
-
-        BaseFileChooser fileChooser = new BaseFileChooser();
-        fileChooser.setAcceptAllFileFilterUsed(true);
-        fileChooser.addChoosableFileFilter(new FileExtensionFilter(
-                exportFileExtension));
-        if (fileChooser.showSaveDialog(this) == BaseFileChooser.APPROVE_OPTION) {
-            File chosenFile = fileChooser.getSelectedFile();
-            String fileName = chosenFile.getPath();
-            if (!chosenFile.exists()
-                    && !fileName.endsWith(exportFileExtension)) {
-                fileName = fileName + "." + exportFileExtension;
-            }
-            try {
-                PrintWriter out = new PrintWriter(new BufferedWriter(
-                        new FileWriter(fileName)));
-                out.write(tasksLog);
-                out.close();
-            } catch (IOException ioe) {
-                GUIUtils.showExceptionDialog(
-                        this,
-                        "Problem saving file " + fileName, ioe);
-            }
-        }
-    }
-
-    private static void createAndShowGUI() {
-
-        // Create and set up the window.
-        JFrame frame = new JFrame("Test");
-        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-
-        // Create and set up the content pane.
-        JPanel panel = new MultiTargetRegressionTaskManagerPanel();
-        panel.setOpaque(true); // content panes must be opaque
-        frame.setContentPane(panel);
-
-        // Display the window.
-        frame.pack();
-        // frame.setSize(400, 400);
-        frame.setVisible(true);
-    }
-
-    public static void main(String[] args) {
-        try {
-            LookAndFeel.install();
-            javax.swing.SwingUtilities.invokeLater(new Runnable() {
-
-                @Override
-                public void run() {
-                    createAndShowGUI();
-                }
-            });
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
+	private static final long serialVersionUID = 1L;
+
+	public static final int MILLISECS_BETWEEN_REFRESH = 600;
+
+	public static String exportFileExtension = "log";
+
+	public class ProgressCellRenderer extends JProgressBar implements TableCellRenderer {
+
+		private static final long serialVersionUID = 1L;
+
+		public ProgressCellRenderer() {
+			super(SwingConstants.HORIZONTAL, 0, 10000);
+			setBorderPainted(false);
+			setStringPainted(true);
+		}
+
+		@Override
+		public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
+				int row, int column) {
+			double frac = -1.0;
+			if (value instanceof Double) {
+				frac = ((Double) value);
+			}
+			if (frac >= 0.0) {
+				setIndeterminate(false);
+				setValue((int) (frac * 10000.0));
+				setString(StringUtils.doubleToString(frac * 100.0, 2, 2));
+			} else {
+				setValue(0);
+				// setIndeterminate(true);
+				// setString("?");
+			}
+			return this;
+		}
+
+		@Override
+		public void validate() {
+		}
+
+		@Override
+		public void revalidate() {
+		}
+
+		@Override
+		protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
+		}
+
+		@Override
+		public void firePropertyChange(String propertyName, boolean oldValue, boolean newValue) {
+		}
+	}
+
+	protected class TaskTableModel extends AbstractTableModel {
+
+		private static final long serialVersionUID = 1L;
+
+		@Override
+		public String getColumnName(int col) {
+			switch (col) {
+			case 0:
+				return "command";
+			case 1:
+				return "status";
+			case 2:
+				return "time elapsed";
+			case 3:
+				return "current activity";
+			case 4:
+				return "% complete";
+			}
+			return null;
+		}
+
+		@Override
+		public int getColumnCount() {
+			return 5;
+		}
+
+		@Override
+		public int getRowCount() {
+			return MultiTargetRegressionTaskManagerPanel.this.taskList.size();
+		}
+
+		@Override
+		public Object getValueAt(int row, int col) {
+			TaskThread thread = MultiTargetRegressionTaskManagerPanel.this.taskList.get(row);
+			switch (col) {
+			case 0:
+				return ((OptionHandler) thread.getTask()).getCLICreationString(MultiTargetRegressionMainTask.class);
+			case 1:
+				return thread.getCurrentStatusString();
+			case 2:
+				return StringUtils.secondsToDHMSString(thread.getCPUSecondsElapsed());
+			case 3:
+				return thread.getCurrentActivityString();
+			case 4:
+				return new Double(thread.getCurrentActivityFracComplete());
+			}
+			return null;
+		}
+
+		@Override
+		public boolean isCellEditable(int row, int col) {
+			return false;
+		}
+	}
+
+	protected MultiTargetRegressionMainTask currentTask = new EvaluatePrequential();
+
+	protected List<TaskThread> taskList = new ArrayList<>();
+
+	protected JButton configureTaskButton = new JButton("Configure");
+
+	protected JTextField taskDescField = new JTextField();
+
+	protected JButton runTaskButton = new JButton("Run");
+
+	protected TaskTableModel taskTableModel;
+
+	protected JTable taskTable;
+
+	protected JButton pauseTaskButton = new JButton("Pause");
+
+	protected JButton resumeTaskButton = new JButton("Resume");
+
+	protected JButton cancelTaskButton = new JButton("Cancel");
+
+	protected JButton deleteTaskButton = new JButton("Delete");
+
+	protected PreviewPanel previewPanel;
+
+	private Preferences prefs;
+
+	private final String PREF_NAME = "currentTask";
+
+	public MultiTargetRegressionTaskManagerPanel() {
+		// Read current task preference
+		prefs = Preferences.userRoot().node(this.getClass().getName());
+		currentTask = new EvaluatePrequential();
+		String taskText = this.currentTask.getCLICreationString(MultiTargetRegressionMainTask.class);
+		String propertyValue = prefs.get(PREF_NAME, taskText);
+		// this.taskDescField.setText(propertyValue);
+		setTaskString(propertyValue, false); // Not store preference
+		this.taskDescField.setEditable(false);
+
+		final Component comp = this.taskDescField;
+		this.taskDescField.addMouseListener(new MouseAdapter() {
+
+			@Override
+			public void mouseClicked(MouseEvent evt) {
+				if (evt.getClickCount() == 1) {
+					if ((evt.getButton() == MouseEvent.BUTTON3)
+							|| ((evt.getButton() == MouseEvent.BUTTON1) && evt.isAltDown() && evt.isShiftDown())) {
+						JPopupMenu menu = new JPopupMenu();
+						JMenuItem item;
+
+						item = new JMenuItem("Copy configuration to clipboard");
+						item.addActionListener(new ActionListener() {
+
+							@Override
+							public void actionPerformed(ActionEvent e) {
+								copyClipBoardConfiguration();
+							}
+						});
+						menu.add(item);
+
+						item = new JMenuItem("Save selected tasks to file");
+						item.addActionListener(new ActionListener() {
+
+							@Override
+							public void actionPerformed(ActionEvent arg0) {
+								saveLogSelectedTasks();
+							}
+						});
+						menu.add(item);
+
+						item = new JMenuItem("Enter configuration...");
+						item.addActionListener(new ActionListener() {
+
+							@Override
+							public void actionPerformed(ActionEvent arg0) {
+								String newTaskString = JOptionPane.showInputDialog("Insert command line");
+								if (newTaskString != null) {
+									setTaskString(newTaskString);
+								}
+							}
+						});
+						menu.add(item);
+
+						menu.show(comp, evt.getX(), evt.getY());
+					}
+				}
+			}
+		});
+
+		JPanel configPanel = new JPanel();
+		configPanel.setLayout(new BorderLayout());
+		configPanel.add(this.configureTaskButton, BorderLayout.WEST);
+		configPanel.add(this.taskDescField, BorderLayout.CENTER);
+		configPanel.add(this.runTaskButton, BorderLayout.EAST);
+		this.taskTableModel = new TaskTableModel();
+		this.taskTable = new JTable(this.taskTableModel);
+		DefaultTableCellRenderer centerRenderer = new DefaultTableCellRenderer();
+		centerRenderer.setHorizontalAlignment(SwingConstants.CENTER);
+		this.taskTable.getColumnModel().getColumn(1).setCellRenderer(centerRenderer);
+		this.taskTable.getColumnModel().getColumn(2).setCellRenderer(centerRenderer);
+		this.taskTable.getColumnModel().getColumn(4).setCellRenderer(new ProgressCellRenderer());
+		JPanel controlPanel = new JPanel();
+		controlPanel.add(this.pauseTaskButton);
+		controlPanel.add(this.resumeTaskButton);
+		controlPanel.add(this.cancelTaskButton);
+		controlPanel.add(this.deleteTaskButton);
+		setLayout(new BorderLayout());
+		add(configPanel, BorderLayout.NORTH);
+		add(new JScrollPane(this.taskTable), BorderLayout.CENTER);
+		add(controlPanel, BorderLayout.SOUTH);
+		this.taskTable.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
+
+			@Override
+			public void valueChanged(ListSelectionEvent arg0) {
+				taskSelectionChanged();
+			}
+		});
+		this.configureTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				String newTaskString = ClassOptionSelectionPanel.showSelectClassDialog(
+						MultiTargetRegressionTaskManagerPanel.this, "Configure task",
+						MultiTargetRegressionMainTask.class, MultiTargetRegressionTaskManagerPanel.this.currentTask
+								.getCLICreationString(MultiTargetRegressionMainTask.class),
+						null);
+				setTaskString(newTaskString);
+			}
+		});
+		this.runTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				runTask((Task) MultiTargetRegressionTaskManagerPanel.this.currentTask.copy());
+			}
+		});
+		this.pauseTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				pauseSelectedTasks();
+			}
+		});
+		this.resumeTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				resumeSelectedTasks();
+			}
+		});
+		this.cancelTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				cancelSelectedTasks();
+			}
+		});
+		this.deleteTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				deleteSelectedTasks();
+			}
+		});
+
+		javax.swing.Timer updateListTimer = new javax.swing.Timer(MILLISECS_BETWEEN_REFRESH, new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				MultiTargetRegressionTaskManagerPanel.this.taskTable.repaint();
+			}
+		});
+		updateListTimer.start();
+		setPreferredSize(new Dimension(0, 200));
+	}
+
+	public void setPreviewPanel(PreviewPanel previewPanel) {
+		this.previewPanel = previewPanel;
+	}
+
+	public void setTaskString(String cliString) {
+		setTaskString(cliString, true);
+	}
+
+	public void setTaskString(String cliString, boolean storePreference) {
+		try {
+			this.currentTask = (MultiTargetRegressionMainTask) ClassOption.cliStringToObject(cliString,
+					MultiTargetRegressionMainTask.class, null);
+			String taskText = this.currentTask.getCLICreationString(MultiTargetRegressionMainTask.class);
+			this.taskDescField.setText(taskText);
+			if (storePreference == true) {
+				// Save task text as a preference
+				prefs.put(PREF_NAME, taskText);
+			}
+		} catch (Exception ex) {
+			GUIUtils.showExceptionDialog(this, "Problem with task", ex);
+		}
+	}
+
+	public void runTask(Task task) {
+		TaskThread thread = new TaskThread(task);
+		this.taskList.add(0, thread);
+		this.taskTableModel.fireTableDataChanged();
+		this.taskTable.setRowSelectionInterval(0, 0);
+		thread.start();
+	}
+
+	public void taskSelectionChanged() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		if (selectedTasks.length == 1) {
+			setTaskString(((OptionHandler) selectedTasks[0].getTask())
+					.getCLICreationString(MultiTargetRegressionMainTask.class));
+			if (this.previewPanel != null) {
+				this.previewPanel.setTaskThreadToPreview(selectedTasks[0]);
+			}
+		} else {
+			this.previewPanel.setTaskThreadToPreview(null);
+		}
+	}
+
+	public TaskThread[] getSelectedTasks() {
+		int[] selectedRows = this.taskTable.getSelectedRows();
+		TaskThread[] selectedTasks = new TaskThread[selectedRows.length];
+		for (int i = 0; i < selectedRows.length; i++) {
+			selectedTasks[i] = this.taskList.get(selectedRows[i]);
+		}
+		return selectedTasks;
+	}
+
+	public void pauseSelectedTasks() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			thread.pauseTask();
+		}
+	}
+
+	public void resumeSelectedTasks() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			thread.resumeTask();
+		}
+	}
+
+	public void cancelSelectedTasks() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			thread.cancelTask();
+		}
+	}
+
+	public void deleteSelectedTasks() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			thread.cancelTask();
+			this.taskList.remove(thread);
+		}
+		this.taskTableModel.fireTableDataChanged();
+	}
+
+	public void copyClipBoardConfiguration() {
+
+		StringSelection selection = new StringSelection(this.taskDescField.getText().trim());
+		Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
+		clipboard.setContents(selection, selection);
+
+	}
+
+	public void saveLogSelectedTasks() {
+		String tasksLog = "";
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			tasksLog += ((OptionHandler) thread.getTask()).getCLICreationString(MultiTargetRegressionMainTask.class)
+					+ "\n";
+		}
+
+		BaseFileChooser fileChooser = new BaseFileChooser();
+		fileChooser.setAcceptAllFileFilterUsed(true);
+		fileChooser.addChoosableFileFilter(new FileExtensionFilter(exportFileExtension));
+		if (fileChooser.showSaveDialog(this) == JFileChooser.APPROVE_OPTION) {
+			File chosenFile = fileChooser.getSelectedFile();
+			String fileName = chosenFile.getPath();
+			if (!chosenFile.exists() && !fileName.endsWith(exportFileExtension)) {
+				fileName = fileName + "." + exportFileExtension;
+			}
+			try {
+				PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(fileName)));
+				out.write(tasksLog);
+				out.close();
+			} catch (IOException ioe) {
+				GUIUtils.showExceptionDialog(this, "Problem saving file " + fileName, ioe);
+			}
+		}
+	}
+
+	private static void createAndShowGUI() {
+
+		// Create and set up the window.
+		JFrame frame = new JFrame("Test");
+		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+
+		// Create and set up the content pane.
+		JPanel panel = new MultiTargetRegressionTaskManagerPanel();
+		panel.setOpaque(true); // content panes must be opaque
+		frame.setContentPane(panel);
+
+		// Display the window.
+		frame.pack();
+		// frame.setSize(400, 400);
+		frame.setVisible(true);
+	}
+
+	public static void main(String[] args) {
+		try {
+			LookAndFeel.install();
+			javax.swing.SwingUtilities.invokeLater(new Runnable() {
+
+				@Override
+				public void run() {
+					createAndShowGUI();
+				}
+			});
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
 }
diff --git a/moa/src/main/java/moa/gui/PreviewPanel.java b/moa/src/main/java/moa/gui/PreviewPanel.java
index 02fc94758..70520e19d 100644
--- a/moa/src/main/java/moa/gui/PreviewPanel.java
+++ b/moa/src/main/java/moa/gui/PreviewPanel.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
@@ -32,10 +32,9 @@
 import moa.evaluation.Accuracy;
 import moa.evaluation.ChangeDetectionMeasures;
 import moa.evaluation.MeasureCollection;
-import moa.evaluation.preview.Preview;
 import moa.evaluation.RegressionAccuracy;
+import moa.evaluation.preview.Preview;
 import moa.gui.conceptdrift.CDTaskManagerPanel;
-import moa.tasks.FailedTaskReport;
 import moa.tasks.ResultPreviewListener;
 import moa.tasks.TaskThread;
 
@@ -47,176 +46,173 @@
  */
 public class PreviewPanel extends JPanel implements ResultPreviewListener {
 
-    private static final long serialVersionUID = 1L;
-
-    public static final String[] autoFreqStrings = {"never", "every second",
-        "every 5 seconds", "every 10 seconds", "every 30 seconds",
-        "every minute"};
-
-    public static final int[] autoFreqTimeSecs = {0, 1, 5, 10, 30, 60};
-
-    protected TaskThread previewedThread;
-
-    protected JLabel previewLabel = new JLabel("No preview available");
-
-    protected JButton refreshButton = new JButton("Refresh");
-
-    protected JLabel autoRefreshLabel = new JLabel("Auto refresh: ");
-
-    protected JComboBox<String> autoRefreshComboBox = new JComboBox<String>(autoFreqStrings);
-
-    protected TaskTextViewerPanel textViewerPanel; // = new TaskTextViewerPanel();
-
-    protected javax.swing.Timer autoRefreshTimer;
-    
-    public enum TypePanel {
-        CLASSIFICATION(new Accuracy()),
-        REGRESSION(new RegressionAccuracy()),
-        CONCEPT_DRIFT(new ChangeDetectionMeasures());
-        private final MeasureCollection measureCollection;
-        //Constructor
-        TypePanel(MeasureCollection measureCollection){
-            this.measureCollection = measureCollection;
-        }
-        
-        public MeasureCollection getMeasureCollection(){
-            return (MeasureCollection) this.measureCollection.copy();
-        }
-    }
-
-    public PreviewPanel() {
-        this(TypePanel.CLASSIFICATION, null);
-    }
-    
-    public PreviewPanel(TypePanel typePanel) {
-        this(typePanel, null);
-    }
-    
-    public PreviewPanel(TypePanel typePanel, CDTaskManagerPanel taskManagerPanel) {
-        this.textViewerPanel = new TaskTextViewerPanel(typePanel,taskManagerPanel); 
-        this.autoRefreshComboBox.setSelectedIndex(1); // default to 1 sec
-        JPanel controlPanel = new JPanel();
-        controlPanel.add(this.previewLabel);
-        controlPanel.add(this.refreshButton);
-        controlPanel.add(this.autoRefreshLabel);
-        controlPanel.add(this.autoRefreshComboBox);
-        setLayout(new BorderLayout());
-        add(controlPanel, BorderLayout.NORTH);
-        add(this.textViewerPanel, BorderLayout.CENTER);
-        this.refreshButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                refresh();
-            }
-        });
-        this.autoRefreshTimer = new javax.swing.Timer(1000,
-                new ActionListener() {
-
-                    @Override
-                    public void actionPerformed(ActionEvent e) {
-                        refresh();
-                    }
-                });
-        this.autoRefreshComboBox.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                updateAutoRefreshTimer();
-            }
-        });
-        setTaskThreadToPreview(null);
-    }
-
-    public void refresh() {
-        if (this.previewedThread != null) {
-            if (this.previewedThread.isComplete()) {
-                setLatestPreview();
-                disableRefresh();
-            } else {
-                this.previewedThread.getPreview(PreviewPanel.this);
-            }
-        }
-    }
-
-    public void setTaskThreadToPreview(TaskThread thread) {
-        this.previewedThread = thread;
-        setLatestPreview();
-        if (thread == null) {
-            disableRefresh();
-        } else if (!thread.isComplete()) {
-            enableRefresh();
-        }
-    }
-
-    /**
-     * Requests the latest preview and sends it to the TextViewerPanel to
-     * display it.
-     */
-    private void setLatestPreview() {
-    	Object previewObject = null;
-    	if (this.previewedThread != null) {
-    	    if (this.previewedThread.isFailed()) {
-                previewObject = this.previewedThread.getFinalResult();
-                this.previewLabel.setText("Error");
-                disableRefresh();
-            }
-            else if (this.previewedThread.isComplete()) {
-                // cancelled or completed task
-                previewObject = this.previewedThread.getFinalResult();
-                this.previewLabel.setText("Final result");
-                disableRefresh();
-            }
-            else {
-                // running task
-                previewObject = this.previewedThread.getLatestResultPreview();
-                double grabTime = this.previewedThread.getLatestPreviewGrabTimeSeconds();
-                String grabString = " (" + StringUtils.secondsToDHMSString(grabTime) + ")";
-                this.previewLabel.setText("Preview" + grabString);
-            }
+	private static final long serialVersionUID = 1L;
+
+	public static final String[] autoFreqStrings = { "never", "every second", "every 5 seconds", "every 10 seconds",
+			"every 30 seconds", "every minute" };
+
+	public static final int[] autoFreqTimeSecs = { 0, 1, 5, 10, 30, 60 };
+
+	protected TaskThread previewedThread;
+
+	protected JLabel previewLabel = new JLabel("No preview available");
+
+	protected JButton refreshButton = new JButton("Refresh");
+
+	protected JLabel autoRefreshLabel = new JLabel("Auto refresh: ");
+
+	protected JComboBox<String> autoRefreshComboBox = new JComboBox<>(autoFreqStrings);
+
+	protected TaskTextViewerPanel textViewerPanel; // = new TaskTextViewerPanel();
+
+	protected javax.swing.Timer autoRefreshTimer;
+
+	public enum TypePanel {
+		CLASSIFICATION(new Accuracy()), REGRESSION(new RegressionAccuracy()),
+		CONCEPT_DRIFT(new ChangeDetectionMeasures());
+
+		private final MeasureCollection measureCollection;
+
+		// Constructor
+		TypePanel(MeasureCollection measureCollection) {
+			this.measureCollection = measureCollection;
+		}
+
+		public MeasureCollection getMeasureCollection() {
+			return (MeasureCollection) this.measureCollection.copy();
+		}
 	}
 
-	if (previewObject == null){
-            // no thread
-            this.previewLabel.setText("No preview available");
+	public PreviewPanel() {
+		this(TypePanel.CLASSIFICATION, null);
 	}
 
-	this.textViewerPanel.setText(previewObject);
-	if (previewObject instanceof Preview)
-	    this.textViewerPanel.setGraph(previewObject.toString());
-	else
-	    this.textViewerPanel.setGraph(null);
-    }
-    
-    public void updateAutoRefreshTimer() {
-        int autoDelay = autoFreqTimeSecs[this.autoRefreshComboBox.getSelectedIndex()];
-        if (autoDelay > 0) {
-            if (this.autoRefreshTimer.isRunning()) {
-                this.autoRefreshTimer.stop();
-            }
-            this.autoRefreshTimer.setDelay(autoDelay * 1000);
-            this.autoRefreshTimer.start();
-        } else {
-            this.autoRefreshTimer.stop();
-        }
-    }
-
-    public void disableRefresh() {
-        this.refreshButton.setEnabled(false);
-        this.autoRefreshLabel.setEnabled(false);
-        this.autoRefreshComboBox.setEnabled(false);
-        this.autoRefreshTimer.stop();
-    }
-
-    public void enableRefresh() {
-        this.refreshButton.setEnabled(true);
-        this.autoRefreshLabel.setEnabled(true);
-        this.autoRefreshComboBox.setEnabled(true);
-        updateAutoRefreshTimer();
-    }
-
-    @Override
-    public void latestPreviewChanged() {
-        setTaskThreadToPreview(this.previewedThread);
-    }
+	public PreviewPanel(TypePanel typePanel) {
+		this(typePanel, null);
+	}
+
+	public PreviewPanel(TypePanel typePanel, CDTaskManagerPanel taskManagerPanel) {
+		this.textViewerPanel = new TaskTextViewerPanel(typePanel, taskManagerPanel);
+		this.autoRefreshComboBox.setSelectedIndex(1); // default to 1 sec
+		JPanel controlPanel = new JPanel();
+		controlPanel.add(this.previewLabel);
+		controlPanel.add(this.refreshButton);
+		controlPanel.add(this.autoRefreshLabel);
+		controlPanel.add(this.autoRefreshComboBox);
+		setLayout(new BorderLayout());
+		add(controlPanel, BorderLayout.NORTH);
+		add(this.textViewerPanel, BorderLayout.CENTER);
+		this.refreshButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				refresh();
+			}
+		});
+		this.autoRefreshTimer = new javax.swing.Timer(1000, new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				refresh();
+			}
+		});
+		this.autoRefreshComboBox.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				updateAutoRefreshTimer();
+			}
+		});
+		setTaskThreadToPreview(null);
+	}
+
+	public void refresh() {
+		if (this.previewedThread != null) {
+			if (this.previewedThread.isComplete()) {
+				setLatestPreview();
+				disableRefresh();
+			} else {
+				this.previewedThread.getPreview(PreviewPanel.this);
+			}
+		}
+	}
+
+	public void setTaskThreadToPreview(TaskThread thread) {
+		this.previewedThread = thread;
+		setLatestPreview();
+		if (thread == null) {
+			disableRefresh();
+		} else if (!thread.isComplete()) {
+			enableRefresh();
+		}
+	}
+
+	/**
+	 * Requests the latest preview and sends it to the TextViewerPanel to display
+	 * it.
+	 */
+	private void setLatestPreview() {
+		Object previewObject = null;
+		if (this.previewedThread != null) {
+			if (this.previewedThread.isFailed()) {
+				previewObject = this.previewedThread.getFinalResult();
+				this.previewLabel.setText("Error");
+				disableRefresh();
+			} else if (this.previewedThread.isComplete()) {
+				// cancelled or completed task
+				previewObject = this.previewedThread.getFinalResult();
+				this.previewLabel.setText("Final result");
+				disableRefresh();
+			} else {
+				// running task
+				previewObject = this.previewedThread.getLatestResultPreview();
+				double grabTime = this.previewedThread.getLatestPreviewGrabTimeSeconds();
+				String grabString = " (" + StringUtils.secondsToDHMSString(grabTime) + ")";
+				this.previewLabel.setText("Preview" + grabString);
+			}
+		}
+
+		if (previewObject == null) {
+			// no thread
+			this.previewLabel.setText("No preview available");
+		}
+
+		this.textViewerPanel.setText(previewObject);
+		if (previewObject instanceof Preview)
+			this.textViewerPanel.setGraph(previewObject.toString());
+		else
+			this.textViewerPanel.setGraph(null);
+	}
+
+	public void updateAutoRefreshTimer() {
+		int autoDelay = autoFreqTimeSecs[this.autoRefreshComboBox.getSelectedIndex()];
+		if (autoDelay > 0) {
+			if (this.autoRefreshTimer.isRunning()) {
+				this.autoRefreshTimer.stop();
+			}
+			this.autoRefreshTimer.setDelay(autoDelay * 1000);
+			this.autoRefreshTimer.start();
+		} else {
+			this.autoRefreshTimer.stop();
+		}
+	}
+
+	public void disableRefresh() {
+		this.refreshButton.setEnabled(false);
+		this.autoRefreshLabel.setEnabled(false);
+		this.autoRefreshComboBox.setEnabled(false);
+		this.autoRefreshTimer.stop();
+	}
+
+	public void enableRefresh() {
+		this.refreshButton.setEnabled(true);
+		this.autoRefreshLabel.setEnabled(true);
+		this.autoRefreshComboBox.setEnabled(true);
+		updateAutoRefreshTimer();
+	}
+
+	@Override
+	public void latestPreviewChanged() {
+		setTaskThreadToPreview(this.previewedThread);
+	}
 }
diff --git a/moa/src/main/java/moa/gui/PreviewTableModel.java b/moa/src/main/java/moa/gui/PreviewTableModel.java
index 5f31b29f8..44a7838ed 100644
--- a/moa/src/main/java/moa/gui/PreviewTableModel.java
+++ b/moa/src/main/java/moa/gui/PreviewTableModel.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
@@ -35,25 +35,24 @@
 public class PreviewTableModel extends AbstractTableModel {
 	// TODO add implementation
 	private static final long serialVersionUID = 1L;
-	
+
 	List<String> names;
 	List<double[]> data;
 	Preview latestPreview;
 	boolean structureChangeFlag;
-	
-	public PreviewTableModel()
-	{
+
+	public PreviewTableModel() {
 		names = new ArrayList<>();
 		data = new ArrayList<>();
 		latestPreview = null;
 		structureChangeFlag = false;
 	}
-	
+
 	@Override
 	public String getColumnName(int column) {
 		return names.get(column);
 	}
-	
+
 	@Override
 	public int getColumnCount() {
 		return names.size();
@@ -66,60 +65,49 @@ public int getRowCount() {
 
 	@Override
 	public Object getValueAt(int row, int column) {
-		if(row >= data.size() || column >= data.get(row).length)
-		{
+		if (row >= data.size() || column >= data.get(row).length) {
 			return 0.0;
 		}
 		return data.get(row)[column];
 	}
-	
-	public void setPreview(Preview preview)
-	{
+
+	public void setPreview(Preview preview) {
 		structureChangeFlag = false;
-		
-		if(preview == null)
-		{
-			if(latestPreview != null)
-			{
+
+		if (preview == null) {
+			if (latestPreview != null) {
 				names = new ArrayList<>();
 				data = new ArrayList<>();
 				structureChangeFlag = true;
 			}
-		}
-		else
-		{
+		} else {
 			structureChangeFlag |= latestPreview == null;
 			structureChangeFlag |= latestPreview != null && latestPreview.numEntries() == 0 && preview.numEntries() > 0;
 			structureChangeFlag |= latestPreview != null && latestPreview.getTaskClass() != preview.getTaskClass();
 		}
 		latestPreview = preview;
-		if(preview != null)
-		{
+		if (preview != null) {
 			data = preview.getData();
-			
-			if(structureChangeFlag)
-			{
+
+			if (structureChangeFlag) {
 				copyMeasurementNames(preview);
 			}
 		}
 	}
-	
+
 	@Override
 	public String toString() {
-		return latestPreview == null? "" : latestPreview.toString();
+		return latestPreview == null ? "" : latestPreview.toString();
 	}
-	
-	public boolean structureChanged()
-	{
+
+	public boolean structureChanged() {
 		return structureChangeFlag;
 	}
-	
-	private void copyMeasurementNames(Preview preview)
-	{
+
+	private void copyMeasurementNames(Preview preview) {
 		names = new ArrayList<>();
 		int newMeasurementNameCount = preview.getMeasurementNameCount();
-		for(int measurementNameIdx = 0; measurementNameIdx < newMeasurementNameCount; ++measurementNameIdx)
-		{
+		for (int measurementNameIdx = 0; measurementNameIdx < newMeasurementNameCount; ++measurementNameIdx) {
 			names.add(preview.getMeasurementName(measurementNameIdx));
 		}
 	}
diff --git a/moa/src/main/java/moa/gui/RegressionTabPanel.java b/moa/src/main/java/moa/gui/RegressionTabPanel.java
index ae99d364c..1e49e28c3 100644
--- a/moa/src/main/java/moa/gui/RegressionTabPanel.java
+++ b/moa/src/main/java/moa/gui/RegressionTabPanel.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
@@ -46,19 +46,17 @@ public RegressionTabPanel() {
 		add(this.previewPanel, BorderLayout.CENTER);
 	}
 
-	//returns the string to display as title of the tab
-    @Override
+	// returns the string to display as title of the tab
+	@Override
 	public String getTabTitle() {
 		return "Regression";
 	}
 
-	//a short description (can be used as tool tip) of the tab, or contributor, etc.
-    @Override
-	public String getDescription(){
+	// a short description (can be used as tool tip) of the tab, or contributor,
+	// etc.
+	@Override
+	public String getDescription() {
 		return "MOA Regression";
 	}
 
 }
-
-
-
diff --git a/moa/src/main/java/moa/gui/RegressionTaskManagerPanel.java b/moa/src/main/java/moa/gui/RegressionTaskManagerPanel.java
index 3c3aaa843..d1cf0ef8b 100644
--- a/moa/src/main/java/moa/gui/RegressionTaskManagerPanel.java
+++ b/moa/src/main/java/moa/gui/RegressionTaskManagerPanel.java
@@ -16,33 +16,10 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
-import moa.core.StringUtils;
-import moa.options.ClassOption;
-import moa.options.OptionHandler;
-import moa.tasks.Task;
-import moa.tasks.TaskThread;
-import nz.ac.waikato.cms.gui.core.BaseFileChooser;
-
-import javax.swing.JButton;
-import javax.swing.JFrame;
-import javax.swing.JMenuItem;
-import javax.swing.JOptionPane;
-import javax.swing.JPanel;
-import javax.swing.JPopupMenu;
-import javax.swing.JProgressBar;
-import javax.swing.JScrollPane;
-import javax.swing.JTable;
-import javax.swing.JTextField;
-import javax.swing.SwingConstants;
-import javax.swing.event.ListSelectionEvent;
-import javax.swing.event.ListSelectionListener;
-import javax.swing.table.AbstractTableModel;
-import javax.swing.table.DefaultTableCellRenderer;
-import javax.swing.table.TableCellRenderer;
 import java.awt.BorderLayout;
 import java.awt.Component;
 import java.awt.Dimension;
@@ -63,6 +40,7 @@
 import java.util.prefs.Preferences;
 
 import javax.swing.JButton;
+import javax.swing.JFileChooser;
 import javax.swing.JFrame;
 import javax.swing.JMenuItem;
 import javax.swing.JOptionPane;
@@ -73,7 +51,6 @@
 import javax.swing.JTable;
 import javax.swing.JTextField;
 import javax.swing.SwingConstants;
-import javax.swing.UIManager;
 import javax.swing.event.ListSelectionEvent;
 import javax.swing.event.ListSelectionListener;
 import javax.swing.table.AbstractTableModel;
@@ -96,449 +73,432 @@
  */
 public class RegressionTaskManagerPanel extends JPanel {
 
-    private static final long serialVersionUID = 1L;
-
-    public static final int MILLISECS_BETWEEN_REFRESH = 600;
-
-    public static String exportFileExtension = "log";
-
-    public class ProgressCellRenderer extends JProgressBar implements
-            TableCellRenderer {
-
-        private static final long serialVersionUID = 1L;
-
-        public ProgressCellRenderer() {
-            super(SwingConstants.HORIZONTAL, 0, 10000);
-            setBorderPainted(false);
-            setStringPainted(true);
-        }
-
-         @Override
-        public Component getTableCellRendererComponent(JTable table,
-                Object value, boolean isSelected, boolean hasFocus, int row,
-                int column) {
-            double frac = -1.0;
-            if (value instanceof Double) {
-                frac = ((Double) value).doubleValue();
-            }
-            if (frac >= 0.0) {
-                setIndeterminate(false);
-                setValue((int) (frac * 10000.0));
-                setString(StringUtils.doubleToString(frac * 100.0, 2, 2));
-            } else {
-                setValue(0);
-                //setIndeterminate(true);
-                //setString("?");
-            }
-            return this;
-        }
-
-        @Override
-        public void validate() {
-        }
-
-        @Override
-        public void revalidate() {
-        }
-
-        @Override
-        protected void firePropertyChange(String propertyName, Object oldValue,
-                Object newValue) {
-        }
-
-        @Override
-        public void firePropertyChange(String propertyName, boolean oldValue,
-                boolean newValue) {
-        }
-    }
-
-    protected class TaskTableModel extends AbstractTableModel {
-
-        private static final long serialVersionUID = 1L;
-
-        @Override
-        public String getColumnName(int col) {
-            switch (col) {
-                case 0:
-                    return "command";
-                case 1:
-                    return "status";
-                case 2:
-                    return "time elapsed";
-                case 3:
-                    return "current activity";
-                case 4:
-                    return "% complete";
-            }
-            return null;
-        }
-
-        @Override
-        public int getColumnCount() {
-            return 5;
-        }
-
-        @Override
-        public int getRowCount() {
-            return RegressionTaskManagerPanel.this.taskList.size();
-        }
-
-        @Override
-        public Object getValueAt(int row, int col) {
-            TaskThread thread = RegressionTaskManagerPanel.this.taskList.get(row);
-            switch (col) {
-                case 0:
-                    return ((OptionHandler) thread.getTask()).getCLICreationString(RegressionMainTask.class);
-                case 1:
-                    return thread.getCurrentStatusString();
-                case 2:
-                    return StringUtils.secondsToDHMSString(thread.getCPUSecondsElapsed());
-                case 3:
-                    return thread.getCurrentActivityString();
-                case 4:
-                    return new Double(thread.getCurrentActivityFracComplete());
-            }
-            return null;
-        }
-
-        @Override
-        public boolean isCellEditable(int row, int col) {
-            return false;
-        }
-    }
-
-    protected RegressionMainTask currentTask = new EvaluatePrequential();//LearnModel();
-
-    protected List<TaskThread> taskList = new ArrayList<TaskThread>();
-
-    protected JButton configureTaskButton = new JButton("Configure");
-
-    protected JTextField taskDescField = new JTextField();
-
-    protected JButton runTaskButton = new JButton("Run");
-
-    protected TaskTableModel taskTableModel;
-
-    protected JTable taskTable;
-
-    protected JButton pauseTaskButton = new JButton("Pause");
-
-    protected JButton resumeTaskButton = new JButton("Resume");
-
-    protected JButton cancelTaskButton = new JButton("Cancel");
-
-    protected JButton deleteTaskButton = new JButton("Delete");
-
-    protected PreviewPanel previewPanel;
-
-    private Preferences prefs;
-    
-    private final String PREF_NAME = "currentTask";
-    
-    public RegressionTaskManagerPanel() {
-        // Read current task preference
-        prefs = Preferences.userRoot().node(this.getClass().getName());
-        currentTask = new EvaluatePrequential();
-        String taskText = this.currentTask.getCLICreationString(RegressionMainTask.class);
-        String propertyValue = prefs.get(PREF_NAME, taskText);
-        //this.taskDescField.setText(propertyValue);
-        setTaskString(propertyValue, false); //Not store preference
-        this.taskDescField.setEditable(false);
-        
-        final Component comp = this.taskDescField;
-        this.taskDescField.addMouseListener(new MouseAdapter() {
-
-            @Override
-            public void mouseClicked(MouseEvent evt) {
-                if (evt.getClickCount() == 1) {
-                    if ((evt.getButton() == MouseEvent.BUTTON3)
-                            || ((evt.getButton() == MouseEvent.BUTTON1) && evt.isAltDown() && evt.isShiftDown())) {
-                        JPopupMenu menu = new JPopupMenu();
-                        JMenuItem item;
-
-                        item = new JMenuItem("Copy configuration to clipboard");
-                        item.addActionListener(new ActionListener() {
-
-                            @Override
-                            public void actionPerformed(ActionEvent e) {
-                                copyClipBoardConfiguration();
-                            }
-                        });
-                        menu.add(item);
-
-
-
-                        item = new JMenuItem("Save selected tasks to file");
-                        item.addActionListener(new ActionListener() {
-
-                            @Override
-                            public void actionPerformed(ActionEvent arg0) {
-                                saveLogSelectedTasks();
-                            }
-                        });
-                        menu.add(item);
-
-
-                        item = new JMenuItem("Enter configuration...");
-                        item.addActionListener(new ActionListener() {
-
-                            @Override
-                            public void actionPerformed(ActionEvent arg0) {
-                                String newTaskString = JOptionPane.showInputDialog("Insert command line");
-                                if (newTaskString != null) {
-                                    setTaskString(newTaskString);
-                                }
-                            }
-                        });
-                        menu.add(item);
-
-                        menu.show(comp, evt.getX(), evt.getY());
-                    }
-                }
-            }
-        });
-
-        JPanel configPanel = new JPanel();
-        configPanel.setLayout(new BorderLayout());
-        configPanel.add(this.configureTaskButton, BorderLayout.WEST);
-        configPanel.add(this.taskDescField, BorderLayout.CENTER);
-        configPanel.add(this.runTaskButton, BorderLayout.EAST);
-        this.taskTableModel = new TaskTableModel();
-        this.taskTable = new JTable(this.taskTableModel);
-        DefaultTableCellRenderer centerRenderer = new DefaultTableCellRenderer();
-        centerRenderer.setHorizontalAlignment(SwingConstants.CENTER);
-        this.taskTable.getColumnModel().getColumn(1).setCellRenderer(
-                centerRenderer);
-        this.taskTable.getColumnModel().getColumn(2).setCellRenderer(
-                centerRenderer);
-        this.taskTable.getColumnModel().getColumn(4).setCellRenderer(
-                new ProgressCellRenderer());
-        JPanel controlPanel = new JPanel();
-        controlPanel.add(this.pauseTaskButton);
-        controlPanel.add(this.resumeTaskButton);
-        controlPanel.add(this.cancelTaskButton);
-        controlPanel.add(this.deleteTaskButton);
-        setLayout(new BorderLayout());
-        add(configPanel, BorderLayout.NORTH);
-        add(new JScrollPane(this.taskTable), BorderLayout.CENTER);
-        add(controlPanel, BorderLayout.SOUTH);
-        this.taskTable.getSelectionModel().addListSelectionListener(
-                new ListSelectionListener() {
-
-                    @Override
-                    public void valueChanged(ListSelectionEvent arg0) {
-                        taskSelectionChanged();
-                    }
-                });
-        this.configureTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                String newTaskString = ClassOptionSelectionPanel.showSelectClassDialog(RegressionTaskManagerPanel.this,
-                        "Configure task", RegressionMainTask.class,
-                        RegressionTaskManagerPanel.this.currentTask.getCLICreationString(RegressionMainTask.class),
-                        null);
-                setTaskString(newTaskString);
-            }
-        });
-        this.runTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                runTask((Task) RegressionTaskManagerPanel.this.currentTask.copy());
-            }
-        });
-        this.pauseTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                pauseSelectedTasks();
-            }
-        });
-        this.resumeTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                resumeSelectedTasks();
-            }
-        });
-        this.cancelTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                cancelSelectedTasks();
-            }
-        });
-        this.deleteTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                deleteSelectedTasks();
-            }
-        });
-
-        javax.swing.Timer updateListTimer = new javax.swing.Timer(
-                MILLISECS_BETWEEN_REFRESH, new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                RegressionTaskManagerPanel.this.taskTable.repaint();
-            }
-        });
-        updateListTimer.start();
-        setPreferredSize(new Dimension(0, 200));
-    }
-
-    public void setPreviewPanel(PreviewPanel previewPanel) {
-        this.previewPanel = previewPanel;
-    }
-
-    public void setTaskString(String cliString) {
-        setTaskString(cliString, true);
-    }
-    
-    public void setTaskString(String cliString, boolean storePreference) {    
-        try {
-            this.currentTask = (RegressionMainTask) ClassOption.cliStringToObject(
-                    cliString, RegressionMainTask.class, null);
-            String taskText = this.currentTask.getCLICreationString(RegressionMainTask.class);
-            this.taskDescField.setText(taskText);
-            if (storePreference == true){
-            //Save task text as a preference
-            prefs.put(PREF_NAME, taskText);
-            }
-        } catch (Exception ex) {
-            GUIUtils.showExceptionDialog(this, "Problem with task", ex);
-        }
-    }
-
-    public void runTask(Task task) {
-        TaskThread thread = new TaskThread(task);
-        this.taskList.add(0, thread);
-        this.taskTableModel.fireTableDataChanged();
-        this.taskTable.setRowSelectionInterval(0, 0);
-        thread.start();
-    }
-
-    public void taskSelectionChanged() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        if (selectedTasks.length == 1) {
-            setTaskString(((OptionHandler) selectedTasks[0].getTask()).getCLICreationString(RegressionMainTask.class));
-            if (this.previewPanel != null) {
-                this.previewPanel.setTaskThreadToPreview(selectedTasks[0]);
-            }
-        } else {
-            this.previewPanel.setTaskThreadToPreview(null);
-        }
-    }
-
-    public TaskThread[] getSelectedTasks() {
-        int[] selectedRows = this.taskTable.getSelectedRows();
-        TaskThread[] selectedTasks = new TaskThread[selectedRows.length];
-        for (int i = 0; i < selectedRows.length; i++) {
-            selectedTasks[i] = this.taskList.get(selectedRows[i]);
-        }
-        return selectedTasks;
-    }
-
-    public void pauseSelectedTasks() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            thread.pauseTask();
-        }
-    }
-
-    public void resumeSelectedTasks() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            thread.resumeTask();
-        }
-    }
-
-    public void cancelSelectedTasks() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            thread.cancelTask();
-        }
-    }
-
-    public void deleteSelectedTasks() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            thread.cancelTask();
-            this.taskList.remove(thread);
-        }
-        this.taskTableModel.fireTableDataChanged();
-    }
-
-    public void copyClipBoardConfiguration() {
-
-        StringSelection selection = new StringSelection(this.taskDescField.getText().trim());
-        Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
-        clipboard.setContents(selection, selection);
-
-    }
-
-    public void saveLogSelectedTasks() {
-        String tasksLog = "";
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            tasksLog += ((OptionHandler) thread.getTask()).getCLICreationString(RegressionMainTask.class) + "\n";
-        }
-
-        BaseFileChooser fileChooser = new BaseFileChooser();
-        fileChooser.setAcceptAllFileFilterUsed(true);
-        fileChooser.addChoosableFileFilter(new FileExtensionFilter(
-                exportFileExtension));
-        if (fileChooser.showSaveDialog(this) == BaseFileChooser.APPROVE_OPTION) {
-            File chosenFile = fileChooser.getSelectedFile();
-            String fileName = chosenFile.getPath();
-            if (!chosenFile.exists()
-                    && !fileName.endsWith(exportFileExtension)) {
-                fileName = fileName + "." + exportFileExtension;
-            }
-            try {
-                PrintWriter out = new PrintWriter(new BufferedWriter(
-                        new FileWriter(fileName)));
-                out.write(tasksLog);
-                out.close();
-            } catch (IOException ioe) {
-                GUIUtils.showExceptionDialog(
-                        this,
-                        "Problem saving file " + fileName, ioe);
-            }
-        }
-    }
-
-    private static void createAndShowGUI() {
-
-        // Create and set up the window.
-        JFrame frame = new JFrame("Test");
-        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-
-        // Create and set up the content pane.
-        JPanel panel = new RegressionTaskManagerPanel();
-        panel.setOpaque(true); // content panes must be opaque
-        frame.setContentPane(panel);
-
-        // Display the window.
-        frame.pack();
-        // frame.setSize(400, 400);
-        frame.setVisible(true);
-    }
-
-    public static void main(String[] args) {
-        try {
-            LookAndFeel.install();
-            javax.swing.SwingUtilities.invokeLater(new Runnable() {
-
-                @Override
-                public void run() {
-                    createAndShowGUI();
-                }
-            });
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
+	private static final long serialVersionUID = 1L;
+
+	public static final int MILLISECS_BETWEEN_REFRESH = 600;
+
+	public static String exportFileExtension = "log";
+
+	public class ProgressCellRenderer extends JProgressBar implements TableCellRenderer {
+
+		private static final long serialVersionUID = 1L;
+
+		public ProgressCellRenderer() {
+			super(SwingConstants.HORIZONTAL, 0, 10000);
+			setBorderPainted(false);
+			setStringPainted(true);
+		}
+
+		@Override
+		public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
+				int row, int column) {
+			double frac = -1.0;
+			if (value instanceof Double) {
+				frac = ((Double) value);
+			}
+			if (frac >= 0.0) {
+				setIndeterminate(false);
+				setValue((int) (frac * 10000.0));
+				setString(StringUtils.doubleToString(frac * 100.0, 2, 2));
+			} else {
+				setValue(0);
+				// setIndeterminate(true);
+				// setString("?");
+			}
+			return this;
+		}
+
+		@Override
+		public void validate() {
+		}
+
+		@Override
+		public void revalidate() {
+		}
+
+		@Override
+		protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
+		}
+
+		@Override
+		public void firePropertyChange(String propertyName, boolean oldValue, boolean newValue) {
+		}
+	}
+
+	protected class TaskTableModel extends AbstractTableModel {
+
+		private static final long serialVersionUID = 1L;
+
+		@Override
+		public String getColumnName(int col) {
+			switch (col) {
+			case 0:
+				return "command";
+			case 1:
+				return "status";
+			case 2:
+				return "time elapsed";
+			case 3:
+				return "current activity";
+			case 4:
+				return "% complete";
+			}
+			return null;
+		}
+
+		@Override
+		public int getColumnCount() {
+			return 5;
+		}
+
+		@Override
+		public int getRowCount() {
+			return RegressionTaskManagerPanel.this.taskList.size();
+		}
+
+		@Override
+		public Object getValueAt(int row, int col) {
+			TaskThread thread = RegressionTaskManagerPanel.this.taskList.get(row);
+			switch (col) {
+			case 0:
+				return ((OptionHandler) thread.getTask()).getCLICreationString(RegressionMainTask.class);
+			case 1:
+				return thread.getCurrentStatusString();
+			case 2:
+				return StringUtils.secondsToDHMSString(thread.getCPUSecondsElapsed());
+			case 3:
+				return thread.getCurrentActivityString();
+			case 4:
+				return new Double(thread.getCurrentActivityFracComplete());
+			}
+			return null;
+		}
+
+		@Override
+		public boolean isCellEditable(int row, int col) {
+			return false;
+		}
+	}
+
+	protected RegressionMainTask currentTask = new EvaluatePrequential();
+
+	protected List<TaskThread> taskList = new ArrayList<>();
+
+	protected JButton configureTaskButton = new JButton("Configure");
+
+	protected JTextField taskDescField = new JTextField();
+
+	protected JButton runTaskButton = new JButton("Run");
+
+	protected TaskTableModel taskTableModel;
+
+	protected JTable taskTable;
+
+	protected JButton pauseTaskButton = new JButton("Pause");
+
+	protected JButton resumeTaskButton = new JButton("Resume");
+
+	protected JButton cancelTaskButton = new JButton("Cancel");
+
+	protected JButton deleteTaskButton = new JButton("Delete");
+
+	protected PreviewPanel previewPanel;
+
+	private Preferences prefs;
+
+	private final String PREF_NAME = "currentTask";
+
+	public RegressionTaskManagerPanel() {
+		// Read current task preference
+		prefs = Preferences.userRoot().node(this.getClass().getName());
+		currentTask = new EvaluatePrequential();
+		String taskText = this.currentTask.getCLICreationString(RegressionMainTask.class);
+		String propertyValue = prefs.get(PREF_NAME, taskText);
+		// this.taskDescField.setText(propertyValue);
+		setTaskString(propertyValue, false); // Not store preference
+		this.taskDescField.setEditable(false);
+
+		final Component comp = this.taskDescField;
+		this.taskDescField.addMouseListener(new MouseAdapter() {
+
+			@Override
+			public void mouseClicked(MouseEvent evt) {
+				if (evt.getClickCount() == 1) {
+					if ((evt.getButton() == MouseEvent.BUTTON3)
+							|| ((evt.getButton() == MouseEvent.BUTTON1) && evt.isAltDown() && evt.isShiftDown())) {
+						JPopupMenu menu = new JPopupMenu();
+						JMenuItem item;
+
+						item = new JMenuItem("Copy configuration to clipboard");
+						item.addActionListener(new ActionListener() {
+
+							@Override
+							public void actionPerformed(ActionEvent e) {
+								copyClipBoardConfiguration();
+							}
+						});
+						menu.add(item);
+
+						item = new JMenuItem("Save selected tasks to file");
+						item.addActionListener(new ActionListener() {
+
+							@Override
+							public void actionPerformed(ActionEvent arg0) {
+								saveLogSelectedTasks();
+							}
+						});
+						menu.add(item);
+
+						item = new JMenuItem("Enter configuration...");
+						item.addActionListener(new ActionListener() {
+
+							@Override
+							public void actionPerformed(ActionEvent arg0) {
+								String newTaskString = JOptionPane.showInputDialog("Insert command line");
+								if (newTaskString != null) {
+									setTaskString(newTaskString);
+								}
+							}
+						});
+						menu.add(item);
+
+						menu.show(comp, evt.getX(), evt.getY());
+					}
+				}
+			}
+		});
+
+		JPanel configPanel = new JPanel();
+		configPanel.setLayout(new BorderLayout());
+		configPanel.add(this.configureTaskButton, BorderLayout.WEST);
+		configPanel.add(this.taskDescField, BorderLayout.CENTER);
+		configPanel.add(this.runTaskButton, BorderLayout.EAST);
+		this.taskTableModel = new TaskTableModel();
+		this.taskTable = new JTable(this.taskTableModel);
+		DefaultTableCellRenderer centerRenderer = new DefaultTableCellRenderer();
+		centerRenderer.setHorizontalAlignment(SwingConstants.CENTER);
+		this.taskTable.getColumnModel().getColumn(1).setCellRenderer(centerRenderer);
+		this.taskTable.getColumnModel().getColumn(2).setCellRenderer(centerRenderer);
+		this.taskTable.getColumnModel().getColumn(4).setCellRenderer(new ProgressCellRenderer());
+		JPanel controlPanel = new JPanel();
+		controlPanel.add(this.pauseTaskButton);
+		controlPanel.add(this.resumeTaskButton);
+		controlPanel.add(this.cancelTaskButton);
+		controlPanel.add(this.deleteTaskButton);
+		setLayout(new BorderLayout());
+		add(configPanel, BorderLayout.NORTH);
+		add(new JScrollPane(this.taskTable), BorderLayout.CENTER);
+		add(controlPanel, BorderLayout.SOUTH);
+		this.taskTable.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
+
+			@Override
+			public void valueChanged(ListSelectionEvent arg0) {
+				taskSelectionChanged();
+			}
+		});
+		this.configureTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				String newTaskString = ClassOptionSelectionPanel.showSelectClassDialog(RegressionTaskManagerPanel.this,
+						"Configure task", RegressionMainTask.class,
+						RegressionTaskManagerPanel.this.currentTask.getCLICreationString(RegressionMainTask.class),
+						null);
+				setTaskString(newTaskString);
+			}
+		});
+		this.runTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				runTask((Task) RegressionTaskManagerPanel.this.currentTask.copy());
+			}
+		});
+		this.pauseTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				pauseSelectedTasks();
+			}
+		});
+		this.resumeTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				resumeSelectedTasks();
+			}
+		});
+		this.cancelTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				cancelSelectedTasks();
+			}
+		});
+		this.deleteTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				deleteSelectedTasks();
+			}
+		});
+
+		javax.swing.Timer updateListTimer = new javax.swing.Timer(MILLISECS_BETWEEN_REFRESH, new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				RegressionTaskManagerPanel.this.taskTable.repaint();
+			}
+		});
+		updateListTimer.start();
+		setPreferredSize(new Dimension(0, 200));
+	}
+
+	public void setPreviewPanel(PreviewPanel previewPanel) {
+		this.previewPanel = previewPanel;
+	}
+
+	public void setTaskString(String cliString) {
+		setTaskString(cliString, true);
+	}
+
+	public void setTaskString(String cliString, boolean storePreference) {
+		try {
+			this.currentTask = (RegressionMainTask) ClassOption.cliStringToObject(cliString, RegressionMainTask.class,
+					null);
+			String taskText = this.currentTask.getCLICreationString(RegressionMainTask.class);
+			this.taskDescField.setText(taskText);
+			if (storePreference == true) {
+				// Save task text as a preference
+				prefs.put(PREF_NAME, taskText);
+			}
+		} catch (Exception ex) {
+			GUIUtils.showExceptionDialog(this, "Problem with task", ex);
+		}
+	}
+
+	public void runTask(Task task) {
+		TaskThread thread = new TaskThread(task);
+		this.taskList.add(0, thread);
+		this.taskTableModel.fireTableDataChanged();
+		this.taskTable.setRowSelectionInterval(0, 0);
+		thread.start();
+	}
+
+	public void taskSelectionChanged() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		if (selectedTasks.length == 1) {
+			setTaskString(((OptionHandler) selectedTasks[0].getTask()).getCLICreationString(RegressionMainTask.class));
+			if (this.previewPanel != null) {
+				this.previewPanel.setTaskThreadToPreview(selectedTasks[0]);
+			}
+		} else {
+			this.previewPanel.setTaskThreadToPreview(null);
+		}
+	}
+
+	public TaskThread[] getSelectedTasks() {
+		int[] selectedRows = this.taskTable.getSelectedRows();
+		TaskThread[] selectedTasks = new TaskThread[selectedRows.length];
+		for (int i = 0; i < selectedRows.length; i++) {
+			selectedTasks[i] = this.taskList.get(selectedRows[i]);
+		}
+		return selectedTasks;
+	}
+
+	public void pauseSelectedTasks() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			thread.pauseTask();
+		}
+	}
+
+	public void resumeSelectedTasks() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			thread.resumeTask();
+		}
+	}
+
+	public void cancelSelectedTasks() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			thread.cancelTask();
+		}
+	}
+
+	public void deleteSelectedTasks() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			thread.cancelTask();
+			this.taskList.remove(thread);
+		}
+		this.taskTableModel.fireTableDataChanged();
+	}
+
+	public void copyClipBoardConfiguration() {
+
+		StringSelection selection = new StringSelection(this.taskDescField.getText().trim());
+		Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
+		clipboard.setContents(selection, selection);
+
+	}
+
+	public void saveLogSelectedTasks() {
+		String tasksLog = "";
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			tasksLog += ((OptionHandler) thread.getTask()).getCLICreationString(RegressionMainTask.class) + "\n";
+		}
+
+		BaseFileChooser fileChooser = new BaseFileChooser();
+		fileChooser.setAcceptAllFileFilterUsed(true);
+		fileChooser.addChoosableFileFilter(new FileExtensionFilter(exportFileExtension));
+		if (fileChooser.showSaveDialog(this) == JFileChooser.APPROVE_OPTION) {
+			File chosenFile = fileChooser.getSelectedFile();
+			String fileName = chosenFile.getPath();
+			if (!chosenFile.exists() && !fileName.endsWith(exportFileExtension)) {
+				fileName = fileName + "." + exportFileExtension;
+			}
+			try {
+				PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(fileName)));
+				out.write(tasksLog);
+				out.close();
+			} catch (IOException ioe) {
+				GUIUtils.showExceptionDialog(this, "Problem saving file " + fileName, ioe);
+			}
+		}
+	}
+
+	private static void createAndShowGUI() {
+
+		// Create and set up the window.
+		JFrame frame = new JFrame("Test");
+		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+
+		// Create and set up the content pane.
+		JPanel panel = new RegressionTaskManagerPanel();
+		panel.setOpaque(true); // content panes must be opaque
+		frame.setContentPane(panel);
+
+		// Display the window.
+		frame.pack();
+		// frame.setSize(400, 400);
+		frame.setVisible(true);
+	}
+
+	public static void main(String[] args) {
+		try {
+			LookAndFeel.install();
+			javax.swing.SwingUtilities.invokeLater(new Runnable() {
+
+				@Override
+				public void run() {
+					createAndShowGUI();
+				}
+			});
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
 }
diff --git a/moa/src/main/java/moa/gui/ScriptingTabPanel.java b/moa/src/main/java/moa/gui/ScriptingTabPanel.java
index d4cff7895..2cd7eba8d 100644
--- a/moa/src/main/java/moa/gui/ScriptingTabPanel.java
+++ b/moa/src/main/java/moa/gui/ScriptingTabPanel.java
@@ -34,61 +34,62 @@
  */
 public class ScriptingTabPanel extends AbstractTabPanel {
 
-    /** the panel to use. */
-    protected JShellPanel m_PanelJShell;
+	/** the panel to use. */
+	protected JShellPanel m_PanelJShell;
 
-    /**
-     * Initializes the tab.
-     */
-    public ScriptingTabPanel() {
-        super();
-        setLayout(new BorderLayout());
+	/**
+	 * Initializes the tab.
+	 */
+	public ScriptingTabPanel() {
+		super();
+		setLayout(new BorderLayout());
 
-        m_PanelJShell = new JShellPanel();
-        String sizeOfAg = locateSizeOfAg();
-        if (sizeOfAg != null)
-            m_PanelJShell.setRemoteRuntimeFlags(Arrays.asList("-javaagent:" + sizeOfAg));
-        add(m_PanelJShell, BorderLayout.CENTER);
-    }
+		m_PanelJShell = new JShellPanel();
+		String sizeOfAg = locateSizeOfAg();
+		if (sizeOfAg != null)
+			m_PanelJShell.setRemoteRuntimeFlags(Arrays.asList("-javaagent:" + sizeOfAg));
+		add(m_PanelJShell, BorderLayout.CENTER);
+	}
 
-    /**
-     * Locates the sizeofag jar in the classpath.
-     *
-     * @return the jar, null if not found
-     */
-    protected String locateSizeOfAg() {
-        String      result;
-        String[]      cp;
+	/**
+	 * Locates the sizeofag jar in the classpath.
+	 *
+	 * @return the jar, null if not found
+	 */
+	protected String locateSizeOfAg() {
+		String result;
+		String[] cp;
 
-        result = null;
-        cp     = System.getProperty("java.class.path").split(System.getProperty("path.separator"));
-        for (String part: cp) {
-            if (part.toLowerCase().contains("sizeofag")) {
-                result = part;
-                break;
-            }
-        }
+		result = null;
+		cp = System.getProperty("java.class.path").split(System.getProperty("path.separator"));
+		for (String part : cp) {
+			if (part.toLowerCase().contains("sizeofag")) {
+				result = part;
+				break;
+			}
+		}
 
-        return result;
-    }
+		return result;
+	}
 
-    /**
-     * Returns the string to display as title of the tab.
-     *
-     * @return the string to display as title of the tab
-     */
-    @Override
-    public String getTabTitle() {
-        return "Scripting";
-    }
+	/**
+	 * Returns the string to display as title of the tab.
+	 *
+	 * @return the string to display as title of the tab
+	 */
+	@Override
+	public String getTabTitle() {
+		return "Scripting";
+	}
 
-    /**
-     * Returns a short description (can be used as tool tip) of the tab, or contributor, etc.
-     *
-     * @return a short description of this tab panel.
-     */
-    @Override
-    public String getDescription() {
-        return "Offers scripting via jshell (Java 9+)";
-    }
+	/**
+	 * Returns a short description (can be used as tool tip) of the tab, or
+	 * contributor, etc.
+	 *
+	 * @return a short description of this tab panel.
+	 */
+	@Override
+	public String getDescription() {
+		return "Offers scripting via jshell (Java 9+)";
+	}
 }
diff --git a/moa/src/main/java/moa/gui/TaskLauncher.java b/moa/src/main/java/moa/gui/TaskLauncher.java
index 53b12709c..60bd2c50a 100644
--- a/moa/src/main/java/moa/gui/TaskLauncher.java
+++ b/moa/src/main/java/moa/gui/TaskLauncher.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
@@ -26,8 +26,8 @@
 
 /**
  * The old main class for the MOA gui, now the main class is <code>GUI</code>.
- * Lets the user configure
- * tasks, learners, streams, and perform data stream analysis.
+ * Lets the user configure tasks, learners, streams, and perform data stream
+ * analysis.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
@@ -69,6 +69,7 @@ private static void createAndShowGUI() {
 	public static void main(String[] args) {
 		try {
 			javax.swing.SwingUtilities.invokeLater(new Runnable() {
+				@Override
 				public void run() {
 					createAndShowGUI();
 				}
diff --git a/moa/src/main/java/moa/gui/TaskManagerPanel.java b/moa/src/main/java/moa/gui/TaskManagerPanel.java
index 220694fae..cad89ab5b 100644
--- a/moa/src/main/java/moa/gui/TaskManagerPanel.java
+++ b/moa/src/main/java/moa/gui/TaskManagerPanel.java
@@ -16,37 +16,10 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
-import moa.capabilities.Capability;
-import moa.capabilities.CapabilityRequirement;
-import moa.core.StringUtils;
-import moa.options.ClassOption;
-import moa.options.OptionHandler;
-import moa.tasks.MainTask;
-import moa.tasks.Task;
-import moa.tasks.TaskThread;
-import nz.ac.waikato.cms.gui.core.BaseFileChooser;
-
-import javax.swing.JButton;
-import javax.swing.JComboBox;
-import javax.swing.JFrame;
-import javax.swing.JMenuItem;
-import javax.swing.JOptionPane;
-import javax.swing.JPanel;
-import javax.swing.JPopupMenu;
-import javax.swing.JProgressBar;
-import javax.swing.JScrollPane;
-import javax.swing.JTable;
-import javax.swing.JTextField;
-import javax.swing.SwingConstants;
-import javax.swing.event.ListSelectionEvent;
-import javax.swing.event.ListSelectionListener;
-import javax.swing.table.AbstractTableModel;
-import javax.swing.table.DefaultTableCellRenderer;
-import javax.swing.table.TableCellRenderer;
 import java.awt.BorderLayout;
 import java.awt.Component;
 import java.awt.Dimension;
@@ -66,8 +39,36 @@
 import java.util.List;
 import java.util.prefs.Preferences;
 
+import javax.swing.JButton;
+import javax.swing.JComboBox;
+import javax.swing.JFileChooser;
+import javax.swing.JFrame;
+import javax.swing.JMenuItem;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JPopupMenu;
+import javax.swing.JProgressBar;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
+import javax.swing.JTextField;
+import javax.swing.SwingConstants;
+import javax.swing.event.ListSelectionEvent;
+import javax.swing.event.ListSelectionListener;
+import javax.swing.table.AbstractTableModel;
+import javax.swing.table.DefaultTableCellRenderer;
+import javax.swing.table.TableCellRenderer;
+
+import moa.capabilities.Capability;
+import moa.capabilities.CapabilityRequirement;
+import moa.core.StringUtils;
+import moa.options.ClassOption;
+import moa.options.OptionHandler;
+import moa.tasks.MainTask;
+import moa.tasks.Task;
+import moa.tasks.TaskThread;
 import moa.tasks.classification.ClassificationMainTask;
 import moa.tasks.classification.EvaluatePrequential;
+import nz.ac.waikato.cms.gui.core.BaseFileChooser;
 
 /**
  * This panel displays the running tasks.
@@ -76,468 +77,455 @@
  */
 public class TaskManagerPanel extends JPanel {
 
-    private static final long serialVersionUID = 1L;
-
-    public static final int MILLISECS_BETWEEN_REFRESH = 600;
-
-    public static String exportFileExtension = "log";
-
-    public class ProgressCellRenderer extends JProgressBar implements
-            TableCellRenderer {
-
-        private static final long serialVersionUID = 1L;
-
-        public ProgressCellRenderer() {
-            super(SwingConstants.HORIZONTAL, 0, 10000);
-            setBorderPainted(false);
-            setStringPainted(true);
-        }
-
-         @Override
-        public Component getTableCellRendererComponent(JTable table,
-                Object value, boolean isSelected, boolean hasFocus, int row,
-                int column) {
-            double frac = -1.0;
-            if (value instanceof Double) {
-                frac = ((Double) value).doubleValue();
-            }
-            if (frac >= 0.0) {
-                setIndeterminate(false);
-                setValue((int) (frac * 10000.0));
-                setString(StringUtils.doubleToString(frac * 100.0, 2, 2));
-            } else {
-                setValue(0);
-                //setIndeterminate(true);
-                //setString("?");
-            }
-            return this;
-        }
-
-        @Override
-        public void validate() {
-        }
-
-        @Override
-        public void revalidate() {
-        }
-
-        @Override
-        protected void firePropertyChange(String propertyName, Object oldValue,
-                Object newValue) {
-        }
-
-        @Override
-        public void firePropertyChange(String propertyName, boolean oldValue,
-                boolean newValue) {
-        }
-    }
-
-    protected class TaskTableModel extends AbstractTableModel {
-
-        private static final long serialVersionUID = 1L;
-
-        @Override
-        public String getColumnName(int col) {
-            switch (col) {
-                case 0:
-                    return "command";
-                case 1:
-                    return "status";
-                case 2:
-                    return "time elapsed";
-                case 3:
-                    return "current activity";
-                case 4:
-                    return "% complete";
-            }
-            return null;
-        }
-
-        @Override
-        public int getColumnCount() {
-            return 5;
-        }
-
-        @Override
-        public int getRowCount() {
-            return TaskManagerPanel.this.taskList.size();
-        }
-
-        @Override
-        public Object getValueAt(int row, int col) {
-            TaskThread thread = TaskManagerPanel.this.taskList.get(row);
-            switch (col) {
-                case 0:
-                    return ((OptionHandler) thread.getTask()).getCLICreationString(MainTask.class);
-                case 1:
-                    return thread.getCurrentStatusString();
-                case 2:
-                    return StringUtils.secondsToDHMSString(thread.getCPUSecondsElapsed());
-                case 3:
-                    return thread.getCurrentActivityString();
-                case 4:
-                    return new Double(thread.getCurrentActivityFracComplete());
-            }
-            return null;
-        }
-
-        @Override
-        public boolean isCellEditable(int row, int col) {
-            return false;
-        }
-    }
-
-    protected MainTask currentTask;//LearnModel();
-
-    protected List<TaskThread> taskList = new ArrayList<TaskThread>();
-
-    protected JButton configureTaskButton = new JButton("Configure");
-
-    protected JTextField taskDescField = new JTextField();
-
-    protected JButton runTaskButton = new JButton("Run");
-
-    protected JComboBox<String> viewModeList = new JComboBox<>(new String[]{Capability.VIEW_LITE.toString(), Capability.VIEW_STANDARD.toString()});
-
-    protected TaskTableModel taskTableModel;
-
-    protected JTable taskTable;
-
-    protected JButton pauseTaskButton = new JButton("Pause");
-
-    protected JButton resumeTaskButton = new JButton("Resume");
-
-    protected JButton cancelTaskButton = new JButton("Cancel");
-
-    protected JButton deleteTaskButton = new JButton("Delete");
-
-    protected PreviewPanel previewPanel;
-
-    private Preferences prefs;
-    
-    private final String PREF_NAME = "currentTask";
-
-    public TaskManagerPanel() {
-        // Read current task preference
-        prefs = Preferences.userRoot().node(this.getClass().getName());
-        currentTask = new EvaluatePrequential();
-        String taskText = this.currentTask.getCLICreationString(MainTask.class);
-        String propertyValue = prefs.get(PREF_NAME, taskText);
-        //this.taskDescField.setText(propertyValue);
-        setTaskString(propertyValue, false); //Not store preference
-        this.taskDescField.setEditable(false);
-        
-        final Component comp = this.taskDescField;
-        this.taskDescField.addMouseListener(new MouseAdapter() {
-
-            @Override
-            public void mouseClicked(MouseEvent evt) {
-                if (evt.getClickCount() == 1) {
-                    if ((evt.getButton() == MouseEvent.BUTTON3)
-                            || ((evt.getButton() == MouseEvent.BUTTON1) && evt.isAltDown() && evt.isShiftDown())) {
-                        JPopupMenu menu = new JPopupMenu();
-                        JMenuItem item;
-
-                        item = new JMenuItem("Copy configuration to clipboard");
-                        item.addActionListener(new ActionListener() {
-
-                            @Override
-                            public void actionPerformed(ActionEvent e) {
-                                copyClipBoardConfiguration();
-                            }
-                        });
-                        menu.add(item);
-
-
-
-                        item = new JMenuItem("Save selected tasks to file");
-                        item.addActionListener(new ActionListener() {
-
-                            @Override
-                            public void actionPerformed(ActionEvent arg0) {
-                                saveLogSelectedTasks();
-                            }
-                        });
-                        menu.add(item);
-
-
-                        item = new JMenuItem("Enter configuration...");
-                        item.addActionListener(new ActionListener() {
-
-                            @Override
-                            public void actionPerformed(ActionEvent arg0) {
-                                String newTaskString = JOptionPane.showInputDialog("Insert command line");
-                                if (newTaskString != null) {
-                                    setTaskString(newTaskString);
-                                }
-                            }
-                        });
-                        menu.add(item);
-
-                        menu.show(comp, evt.getX(), evt.getY());
-                    }
-                }
-            }
-        });
-
-        JPanel configPanel = new JPanel();
-        configPanel.setLayout(new BorderLayout());
-        configPanel.add(this.configureTaskButton, BorderLayout.WEST);
-        configPanel.add(this.taskDescField, BorderLayout.CENTER);
-        JPanel runViewPanel = new JPanel();
-        runViewPanel.setLayout(new BorderLayout());
-        runViewPanel.add(this.runTaskButton, BorderLayout.WEST);
-        this.viewModeList.setPrototypeDisplayValue(Capability.VIEW_EXPERIMENTAL.toString() + "        "); // Require extra spacing to force enough width
-        runViewPanel.add(this.viewModeList, BorderLayout.EAST);
-        configPanel.add(runViewPanel, BorderLayout.EAST);
-        this.taskTableModel = new TaskTableModel();
-        this.taskTable = new JTable(this.taskTableModel);
-        DefaultTableCellRenderer centerRenderer = new DefaultTableCellRenderer();
-        centerRenderer.setHorizontalAlignment(SwingConstants.CENTER);
-        this.taskTable.getColumnModel().getColumn(1).setCellRenderer(
-                centerRenderer);
-        this.taskTable.getColumnModel().getColumn(2).setCellRenderer(
-                centerRenderer);
-        this.taskTable.getColumnModel().getColumn(4).setCellRenderer(
-                new ProgressCellRenderer());
-        JPanel controlPanel = new JPanel();
-        controlPanel.add(this.pauseTaskButton);
-        controlPanel.add(this.resumeTaskButton);
-        controlPanel.add(this.cancelTaskButton);
-        controlPanel.add(this.deleteTaskButton);
-        setLayout(new BorderLayout());
-        add(configPanel, BorderLayout.NORTH);
-        add(new JScrollPane(this.taskTable), BorderLayout.CENTER);
-        add(controlPanel, BorderLayout.SOUTH);
-        this.taskTable.getSelectionModel().addListSelectionListener(
-                new ListSelectionListener() {
-
-                    @Override
-                    public void valueChanged(ListSelectionEvent arg0) {
-                        taskSelectionChanged();
-                    }
-                });
-        this.configureTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                CapabilityRequirement capReq = forViewSelection();
-                ClassOptionSelectionPanel.setRequiredCapabilities(capReq);
-                String newTaskString = ClassOptionSelectionPanel.showSelectClassDialog(TaskManagerPanel.this,
-                        "Configure task", ClassificationMainTask.class,
-                        TaskManagerPanel.this.currentTask.getCLICreationString(ClassificationMainTask.class),
-                        null);
-                setTaskString(newTaskString);
-                ClassOptionSelectionPanel.setRequiredCapabilities(null);
-            }
-        });
-        this.runTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                runTask((Task) TaskManagerPanel.this.currentTask.copy());
-            }
-        });
-        this.pauseTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                pauseSelectedTasks();
-            }
-        });
-        this.resumeTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                resumeSelectedTasks();
-            }
-        });
-        this.cancelTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                cancelSelectedTasks();
-            }
-        });
-        this.deleteTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                deleteSelectedTasks();
-            }
-        });
-
-        javax.swing.Timer updateListTimer = new javax.swing.Timer(
-                MILLISECS_BETWEEN_REFRESH, new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                TaskManagerPanel.this.taskTable.repaint();
-            }
-        });
-        updateListTimer.start();
-        setPreferredSize(new Dimension(0, 200));
-    }
-
-    public void setPreviewPanel(PreviewPanel previewPanel) {
-        this.previewPanel = previewPanel;
-    }
-
-    public void setTaskString(String cliString) {
-        setTaskString(cliString, true);
-    }
-        
-    public void setTaskString(String cliString, boolean storePreference) {    
-        try {
-            this.currentTask = (MainTask) ClassOption.cliStringToObject(
-                    cliString, ClassificationMainTask.class, null);
-            String taskText = this.currentTask.getCLICreationString(ClassificationMainTask.class);
-            this.taskDescField.setText(taskText);
-            if (storePreference == true){
-            //Save task text as a preference
-            prefs.put(PREF_NAME, taskText);
-            }
-        } catch (Exception ex) {
-            GUIUtils.showExceptionDialog(this, "Problem with task", ex);
-        }
-    }
-
-    public void runTask(Task task) {
-        TaskThread thread = new TaskThread(task);
-        this.taskList.add(0, thread);
-        this.taskTableModel.fireTableDataChanged();
-        this.taskTable.setRowSelectionInterval(0, 0);
-        thread.start();
-    }
-
-    public void taskSelectionChanged() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        if (selectedTasks.length == 1) {
-            setTaskString(((OptionHandler) selectedTasks[0].getTask()).getCLICreationString(MainTask.class));
-            if (this.previewPanel != null) {
-                this.previewPanel.setTaskThreadToPreview(selectedTasks[0]);
-            }
-        } else {
-            this.previewPanel.setTaskThreadToPreview(null);
-        }
-    }
-
-    public TaskThread[] getSelectedTasks() {
-        int[] selectedRows = this.taskTable.getSelectedRows();
-        TaskThread[] selectedTasks = new TaskThread[selectedRows.length];
-        for (int i = 0; i < selectedRows.length; i++) {
-            selectedTasks[i] = this.taskList.get(selectedRows[i]);
-        }
-        return selectedTasks;
-    }
-
-    public void pauseSelectedTasks() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            thread.pauseTask();
-        }
-    }
-
-    public void resumeSelectedTasks() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            thread.resumeTask();
-        }
-    }
-
-    public void cancelSelectedTasks() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            thread.cancelTask();
-        }
-    }
-
-    public void deleteSelectedTasks() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            thread.cancelTask();
-            this.taskList.remove(thread);
-        }
-        this.taskTableModel.fireTableDataChanged();
-    }
-
-    public void copyClipBoardConfiguration() {
-
-        StringSelection selection = new StringSelection(this.taskDescField.getText().trim());
-        Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
-        clipboard.setContents(selection, selection);
-
-    }
-
-    public void saveLogSelectedTasks() {
-        String tasksLog = "";
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            tasksLog += ((OptionHandler) thread.getTask()).getCLICreationString(MainTask.class) + "\n";
-        }
-
-        BaseFileChooser fileChooser = new BaseFileChooser();
-        fileChooser.setAcceptAllFileFilterUsed(true);
-        fileChooser.addChoosableFileFilter(new FileExtensionFilter(
-                exportFileExtension));
-        if (fileChooser.showSaveDialog(this) == BaseFileChooser.APPROVE_OPTION) {
-            File chosenFile = fileChooser.getSelectedFile();
-            String fileName = chosenFile.getPath();
-            if (!chosenFile.exists()
-                    && !fileName.endsWith(exportFileExtension)) {
-                fileName = fileName + "." + exportFileExtension;
-            }
-            try {
-                PrintWriter out = new PrintWriter(new BufferedWriter(
-                        new FileWriter(fileName)));
-                out.write(tasksLog);
-                out.close();
-            } catch (IOException ioe) {
-                GUIUtils.showExceptionDialog(
-                        this,
-                        "Problem saving file " + fileName, ioe);
-            }
-        }
-    }
-
-    /**
-     * Gets the requirement that a capabilities object must have the selected view.
-     *
-     * @return  The requirement.
-     */
-    private CapabilityRequirement forViewSelection() {
-        return CapabilityRequirement.has(Capability.forShortName((String) this.viewModeList.getSelectedItem()));
-    }
-
-    private static void createAndShowGUI() {
-
-        // Create and set up the window.
-        JFrame frame = new JFrame("Test");
-        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-
-        // Create and set up the content pane.
-        JPanel panel = new TaskManagerPanel();
-        panel.setOpaque(true); // content panes must be opaque
-        frame.setContentPane(panel);
-
-        // Display the window.
-        frame.pack();
-        // frame.setSize(400, 400);
-        frame.setVisible(true);
-    }
-
-    public static void main(String[] args) {
-        try {
-            LookAndFeel.install();
-            javax.swing.SwingUtilities.invokeLater(new Runnable() {
-
-                @Override
-                public void run() {
-                    createAndShowGUI();
-                }
-            });
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
+	private static final long serialVersionUID = 1L;
+
+	public static final int MILLISECS_BETWEEN_REFRESH = 600;
+
+	public static String exportFileExtension = "log";
+
+	public class ProgressCellRenderer extends JProgressBar implements TableCellRenderer {
+
+		private static final long serialVersionUID = 1L;
+
+		public ProgressCellRenderer() {
+			super(SwingConstants.HORIZONTAL, 0, 10000);
+			setBorderPainted(false);
+			setStringPainted(true);
+		}
+
+		@Override
+		public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
+				int row, int column) {
+			double frac = -1.0;
+			if (value instanceof Double) {
+				frac = ((Double) value);
+			}
+			if (frac >= 0.0) {
+				setIndeterminate(false);
+				setValue((int) (frac * 10000.0));
+				setString(StringUtils.doubleToString(frac * 100.0, 2, 2));
+			} else {
+				setValue(0);
+				// setIndeterminate(true);
+				// setString("?");
+			}
+			return this;
+		}
+
+		@Override
+		public void validate() {
+		}
+
+		@Override
+		public void revalidate() {
+		}
+
+		@Override
+		protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
+		}
+
+		@Override
+		public void firePropertyChange(String propertyName, boolean oldValue, boolean newValue) {
+		}
+	}
+
+	protected class TaskTableModel extends AbstractTableModel {
+
+		private static final long serialVersionUID = 1L;
+
+		@Override
+		public String getColumnName(int col) {
+			switch (col) {
+			case 0:
+				return "command";
+			case 1:
+				return "status";
+			case 2:
+				return "time elapsed";
+			case 3:
+				return "current activity";
+			case 4:
+				return "% complete";
+			}
+			return null;
+		}
+
+		@Override
+		public int getColumnCount() {
+			return 5;
+		}
+
+		@Override
+		public int getRowCount() {
+			return TaskManagerPanel.this.taskList.size();
+		}
+
+		@Override
+		public Object getValueAt(int row, int col) {
+			TaskThread thread = TaskManagerPanel.this.taskList.get(row);
+			switch (col) {
+			case 0:
+				return ((OptionHandler) thread.getTask()).getCLICreationString(MainTask.class);
+			case 1:
+				return thread.getCurrentStatusString();
+			case 2:
+				return StringUtils.secondsToDHMSString(thread.getCPUSecondsElapsed());
+			case 3:
+				return thread.getCurrentActivityString();
+			case 4:
+				return new Double(thread.getCurrentActivityFracComplete());
+			}
+			return null;
+		}
+
+		@Override
+		public boolean isCellEditable(int row, int col) {
+			return false;
+		}
+	}
+
+	protected MainTask currentTask;// LearnModel();
+
+	protected List<TaskThread> taskList = new ArrayList<>();
+
+	protected JButton configureTaskButton = new JButton("Configure");
+
+	protected JTextField taskDescField = new JTextField();
+
+	protected JButton runTaskButton = new JButton("Run");
+
+	protected JComboBox<String> viewModeList = new JComboBox<>(
+			new String[] { Capability.VIEW_LITE.toString(), Capability.VIEW_STANDARD.toString() });
+
+	protected TaskTableModel taskTableModel;
+
+	protected JTable taskTable;
+
+	protected JButton pauseTaskButton = new JButton("Pause");
+
+	protected JButton resumeTaskButton = new JButton("Resume");
+
+	protected JButton cancelTaskButton = new JButton("Cancel");
+
+	protected JButton deleteTaskButton = new JButton("Delete");
+
+	protected PreviewPanel previewPanel;
+
+	private Preferences prefs;
+
+	private final String PREF_NAME = "currentTask";
+
+	public TaskManagerPanel() {
+		// Read current task preference
+		prefs = Preferences.userRoot().node(this.getClass().getName());
+		currentTask = new EvaluatePrequential();
+		String taskText = this.currentTask.getCLICreationString(MainTask.class);
+		String propertyValue = prefs.get(PREF_NAME, taskText);
+		// this.taskDescField.setText(propertyValue);
+		setTaskString(propertyValue, false); // Not store preference
+		this.taskDescField.setEditable(false);
+
+		final Component comp = this.taskDescField;
+		this.taskDescField.addMouseListener(new MouseAdapter() {
+
+			@Override
+			public void mouseClicked(MouseEvent evt) {
+				if (evt.getClickCount() == 1) {
+					if ((evt.getButton() == MouseEvent.BUTTON3)
+							|| ((evt.getButton() == MouseEvent.BUTTON1) && evt.isAltDown() && evt.isShiftDown())) {
+						JPopupMenu menu = new JPopupMenu();
+						JMenuItem item;
+
+						item = new JMenuItem("Copy configuration to clipboard");
+						item.addActionListener(new ActionListener() {
+
+							@Override
+							public void actionPerformed(ActionEvent e) {
+								copyClipBoardConfiguration();
+							}
+						});
+						menu.add(item);
+
+						item = new JMenuItem("Save selected tasks to file");
+						item.addActionListener(new ActionListener() {
+
+							@Override
+							public void actionPerformed(ActionEvent arg0) {
+								saveLogSelectedTasks();
+							}
+						});
+						menu.add(item);
+
+						item = new JMenuItem("Enter configuration...");
+						item.addActionListener(new ActionListener() {
+
+							@Override
+							public void actionPerformed(ActionEvent arg0) {
+								String newTaskString = JOptionPane.showInputDialog("Insert command line");
+								if (newTaskString != null) {
+									setTaskString(newTaskString);
+								}
+							}
+						});
+						menu.add(item);
+
+						menu.show(comp, evt.getX(), evt.getY());
+					}
+				}
+			}
+		});
+
+		JPanel configPanel = new JPanel();
+		configPanel.setLayout(new BorderLayout());
+		configPanel.add(this.configureTaskButton, BorderLayout.WEST);
+		configPanel.add(this.taskDescField, BorderLayout.CENTER);
+		JPanel runViewPanel = new JPanel();
+		runViewPanel.setLayout(new BorderLayout());
+		runViewPanel.add(this.runTaskButton, BorderLayout.WEST);
+		this.viewModeList.setPrototypeDisplayValue(Capability.VIEW_EXPERIMENTAL.toString() + "        "); // Require
+																											// extra
+																											// spacing
+																											// to force
+																											// enough
+																											// width
+		runViewPanel.add(this.viewModeList, BorderLayout.EAST);
+		configPanel.add(runViewPanel, BorderLayout.EAST);
+		this.taskTableModel = new TaskTableModel();
+		this.taskTable = new JTable(this.taskTableModel);
+		DefaultTableCellRenderer centerRenderer = new DefaultTableCellRenderer();
+		centerRenderer.setHorizontalAlignment(SwingConstants.CENTER);
+		this.taskTable.getColumnModel().getColumn(1).setCellRenderer(centerRenderer);
+		this.taskTable.getColumnModel().getColumn(2).setCellRenderer(centerRenderer);
+		this.taskTable.getColumnModel().getColumn(4).setCellRenderer(new ProgressCellRenderer());
+		JPanel controlPanel = new JPanel();
+		controlPanel.add(this.pauseTaskButton);
+		controlPanel.add(this.resumeTaskButton);
+		controlPanel.add(this.cancelTaskButton);
+		controlPanel.add(this.deleteTaskButton);
+		setLayout(new BorderLayout());
+		add(configPanel, BorderLayout.NORTH);
+		add(new JScrollPane(this.taskTable), BorderLayout.CENTER);
+		add(controlPanel, BorderLayout.SOUTH);
+		this.taskTable.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
+
+			@Override
+			public void valueChanged(ListSelectionEvent arg0) {
+				taskSelectionChanged();
+			}
+		});
+		this.configureTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				CapabilityRequirement capReq = forViewSelection();
+				ClassOptionSelectionPanel.setRequiredCapabilities(capReq);
+				String newTaskString = ClassOptionSelectionPanel.showSelectClassDialog(TaskManagerPanel.this,
+						"Configure task", ClassificationMainTask.class,
+						TaskManagerPanel.this.currentTask.getCLICreationString(ClassificationMainTask.class), null);
+				setTaskString(newTaskString);
+				ClassOptionSelectionPanel.setRequiredCapabilities(null);
+			}
+		});
+		this.runTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				runTask((Task) TaskManagerPanel.this.currentTask.copy());
+			}
+		});
+		this.pauseTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				pauseSelectedTasks();
+			}
+		});
+		this.resumeTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				resumeSelectedTasks();
+			}
+		});
+		this.cancelTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				cancelSelectedTasks();
+			}
+		});
+		this.deleteTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				deleteSelectedTasks();
+			}
+		});
+
+		javax.swing.Timer updateListTimer = new javax.swing.Timer(MILLISECS_BETWEEN_REFRESH, new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				TaskManagerPanel.this.taskTable.repaint();
+			}
+		});
+		updateListTimer.start();
+		setPreferredSize(new Dimension(0, 200));
+	}
+
+	public void setPreviewPanel(PreviewPanel previewPanel) {
+		this.previewPanel = previewPanel;
+	}
+
+	public void setTaskString(String cliString) {
+		setTaskString(cliString, true);
+	}
+
+	public void setTaskString(String cliString, boolean storePreference) {
+		try {
+			this.currentTask = (MainTask) ClassOption.cliStringToObject(cliString, ClassificationMainTask.class, null);
+			String taskText = this.currentTask.getCLICreationString(ClassificationMainTask.class);
+			this.taskDescField.setText(taskText);
+			if (storePreference == true) {
+				// Save task text as a preference
+				prefs.put(PREF_NAME, taskText);
+			}
+		} catch (Exception ex) {
+			GUIUtils.showExceptionDialog(this, "Problem with task", ex);
+		}
+	}
+
+	public void runTask(Task task) {
+		TaskThread thread = new TaskThread(task);
+		this.taskList.add(0, thread);
+		this.taskTableModel.fireTableDataChanged();
+		this.taskTable.setRowSelectionInterval(0, 0);
+		thread.start();
+	}
+
+	public void taskSelectionChanged() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		if (selectedTasks.length == 1) {
+			setTaskString(((OptionHandler) selectedTasks[0].getTask()).getCLICreationString(MainTask.class));
+			if (this.previewPanel != null) {
+				this.previewPanel.setTaskThreadToPreview(selectedTasks[0]);
+			}
+		} else {
+			this.previewPanel.setTaskThreadToPreview(null);
+		}
+	}
+
+	public TaskThread[] getSelectedTasks() {
+		int[] selectedRows = this.taskTable.getSelectedRows();
+		TaskThread[] selectedTasks = new TaskThread[selectedRows.length];
+		for (int i = 0; i < selectedRows.length; i++) {
+			selectedTasks[i] = this.taskList.get(selectedRows[i]);
+		}
+		return selectedTasks;
+	}
+
+	public void pauseSelectedTasks() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			thread.pauseTask();
+		}
+	}
+
+	public void resumeSelectedTasks() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			thread.resumeTask();
+		}
+	}
+
+	public void cancelSelectedTasks() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			thread.cancelTask();
+		}
+	}
+
+	public void deleteSelectedTasks() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			thread.cancelTask();
+			this.taskList.remove(thread);
+		}
+		this.taskTableModel.fireTableDataChanged();
+	}
+
+	public void copyClipBoardConfiguration() {
+
+		StringSelection selection = new StringSelection(this.taskDescField.getText().trim());
+		Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
+		clipboard.setContents(selection, selection);
+
+	}
+
+	public void saveLogSelectedTasks() {
+		String tasksLog = "";
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			tasksLog += ((OptionHandler) thread.getTask()).getCLICreationString(MainTask.class) + "\n";
+		}
+
+		BaseFileChooser fileChooser = new BaseFileChooser();
+		fileChooser.setAcceptAllFileFilterUsed(true);
+		fileChooser.addChoosableFileFilter(new FileExtensionFilter(exportFileExtension));
+		if (fileChooser.showSaveDialog(this) == JFileChooser.APPROVE_OPTION) {
+			File chosenFile = fileChooser.getSelectedFile();
+			String fileName = chosenFile.getPath();
+			if (!chosenFile.exists() && !fileName.endsWith(exportFileExtension)) {
+				fileName = fileName + "." + exportFileExtension;
+			}
+			try {
+				PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(fileName)));
+				out.write(tasksLog);
+				out.close();
+			} catch (IOException ioe) {
+				GUIUtils.showExceptionDialog(this, "Problem saving file " + fileName, ioe);
+			}
+		}
+	}
+
+	/**
+	 * Gets the requirement that a capabilities object must have the selected view.
+	 *
+	 * @return The requirement.
+	 */
+	private CapabilityRequirement forViewSelection() {
+		return CapabilityRequirement.has(Capability.forShortName((String) this.viewModeList.getSelectedItem()));
+	}
+
+	private static void createAndShowGUI() {
+
+		// Create and set up the window.
+		JFrame frame = new JFrame("Test");
+		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+
+		// Create and set up the content pane.
+		JPanel panel = new TaskManagerPanel();
+		panel.setOpaque(true); // content panes must be opaque
+		frame.setContentPane(panel);
+
+		// Display the window.
+		frame.pack();
+		// frame.setSize(400, 400);
+		frame.setVisible(true);
+	}
+
+	public static void main(String[] args) {
+		try {
+			LookAndFeel.install();
+			javax.swing.SwingUtilities.invokeLater(new Runnable() {
+
+				@Override
+				public void run() {
+					createAndShowGUI();
+				}
+			});
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
 }
diff --git a/moa/src/main/java/moa/gui/TaskTextViewerPanel.java b/moa/src/main/java/moa/gui/TaskTextViewerPanel.java
index b8733f9da..2f46a4063 100644
--- a/moa/src/main/java/moa/gui/TaskTextViewerPanel.java
+++ b/moa/src/main/java/moa/gui/TaskTextViewerPanel.java
@@ -16,32 +16,10 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
-import moa.evaluation.MeasureCollection;
-import moa.evaluation.preview.Preview;
-import moa.gui.PreviewPanel.TypePanel;
-import moa.gui.conceptdrift.CDTaskManagerPanel;
-import moa.streams.clustering.ClusterEvent;
-import moa.tasks.FailedTaskReport;
-import nz.ac.waikato.cms.gui.core.BaseFileChooser;
-import nz.ac.waikato.cms.gui.core.DetachablePanel;
-import nz.ac.waikato.cms.gui.core.ExtensionFileFilter;
-import nz.ac.waikato.cms.gui.core.GUIHelper;
-import weka.gui.visualize.PNGWriter;
-
-import javax.swing.JButton;
-import javax.swing.JPanel;
-import javax.swing.JScrollPane;
-import javax.swing.JSplitPane;
-import javax.swing.JTable;
-import javax.swing.JTextArea;
-import javax.swing.SwingUtilities;
-import javax.swing.table.TableCellRenderer;
-import javax.swing.table.TableColumn;
-import javax.swing.table.TableColumnModel;
 import java.awt.BorderLayout;
 import java.awt.Component;
 import java.awt.Dimension;
@@ -60,16 +38,30 @@
 import java.util.Scanner;
 
 import javax.swing.JButton;
+import javax.swing.JFileChooser;
 import javax.swing.JPanel;
 import javax.swing.JScrollPane;
+import javax.swing.JSplitPane;
+import javax.swing.JTable;
 import javax.swing.JTextArea;
+import javax.swing.ScrollPaneConstants;
+import javax.swing.SwingUtilities;
+import javax.swing.table.TableCellRenderer;
+import javax.swing.table.TableColumn;
+import javax.swing.table.TableColumnModel;
 
 import moa.evaluation.MeasureCollection;
+import moa.evaluation.preview.Preview;
 import moa.gui.PreviewPanel.TypePanel;
 import moa.gui.conceptdrift.CDTaskManagerPanel;
 import moa.streams.clustering.ClusterEvent;
+import moa.tasks.FailedTaskReport;
 import moa.tasks.conceptdrift.ConceptDriftMainTask;
 import nz.ac.waikato.cms.gui.core.BaseFileChooser;
+import nz.ac.waikato.cms.gui.core.DetachablePanel;
+import nz.ac.waikato.cms.gui.core.ExtensionFileFilter;
+import nz.ac.waikato.cms.gui.core.GUIHelper;
+import weka.gui.visualize.PNGWriter;
 
 /**
  * This panel displays text. Used to output the results of tasks.
@@ -79,705 +71,705 @@
  */
 public class TaskTextViewerPanel extends JPanel implements ActionListener {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
+
+	public static String exportFileExtension = "txt";
+
+	private PreviewTableModel previewTableModel;
+
+	private JTable previewTable;
 
-    public static String exportFileExtension = "txt";
-
-    private PreviewTableModel previewTableModel;
-
-    private JTable previewTable;
-
-    private JTextArea previewText;
+	private JTextArea previewText;
 
-    private JScrollPane scrollPaneTable;
-
-    private JScrollPane scrollPaneText;
-
-    protected JButton exportButton;
-
-    private javax.swing.JPanel topWrapper;
-
-    private javax.swing.JSplitPane jSplitPane1;
-
-   //Added for stream events
-    protected CDTaskManagerPanel taskManagerPanel;
-
-    protected TypePanel typePanel;
-
-    public void initVisualEvalPanel() {
-        acc1[0] = getNewMeasureCollection();
-        acc2[0] = getNewMeasureCollection();
-        if (clusteringVisualEvalPanel1 != null) {
-            panelEvalOutput.remove(clusteringVisualEvalPanel1);
-        }
-        clusteringVisualEvalPanel1 = new moa.gui.clustertab.ClusteringVisualEvalPanel();
-        clusteringVisualEvalPanel1.setMeasures(acc1, acc2, this);
-        this.graphCanvas.setGraph(acc1[0], acc2[0], 0, 1000);
-        this.graphCanvas.forceAddEvents();
-        clusteringVisualEvalPanel1.setMinimumSize(new java.awt.Dimension(280, 118));
-        clusteringVisualEvalPanel1.setPreferredSize(new java.awt.Dimension(290, 115));
-         panelEvalOutput.add(clusteringVisualEvalPanel1, gridBagConstraints);
-    }
-
-    public TaskTextViewerPanel() {
-       this(TypePanel.CLASSIFICATION, null);
-    }
-
-    public java.awt.GridBagConstraints gridBagConstraints;
-
-    public TaskTextViewerPanel(PreviewPanel.TypePanel typePanel, CDTaskManagerPanel taskManagerPanel) {
-        this.typePanel = typePanel;
-        this.taskManagerPanel = taskManagerPanel;
-        topWrapper = new javax.swing.JPanel();
-
-        setLayout(new GridBagLayout());
-
-        // mainPane contains the two main components of the text viewer panel:
-        // top component: preview table panel
-        // bottom component: interactive graph panel
-        this.jSplitPane1 = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
-        this.jSplitPane1.setDividerLocation(200);
-
-        // topWrapper is the wrapper of the top component of mainPane
-        this.topWrapper = new JPanel();
-        this.topWrapper.setLayout(new BorderLayout());
-
-        // previewTable displays live results in table form
-        // (or in text form, if an error occurs)
-        this.previewTableModel = new PreviewTableModel();
-        this.previewTable = new JTable(this.previewTableModel);
-        this.previewTable.setFont(new Font("Monospaced", Font.PLAIN, 12));
-        this.previewTable.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
-
-        this.previewText = new JTextArea();
-        this.previewText.setEditable(false);
-        this.previewText.setFont(new Font("Monospaced", Font.PLAIN, 12));
-
-        // scrollPane enables scroll support for previewTable
-        this.scrollPaneTable = new JScrollPane(this.previewTable, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
-                JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
-        this.scrollPaneText = new JScrollPane(this.previewText, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
-                JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
-        this.scrollPaneText.setVisible(false);
-
-        this.topWrapper.add(this.scrollPaneTable, BorderLayout.CENTER);
-
-        this.exportButton = new JButton("Export as .txt file...");
-        this.exportButton.setEnabled(false);
-        JPanel buttonPanel = new JPanel();
-        buttonPanel.setLayout(new GridLayout(1, 2));
-        buttonPanel.add(this.exportButton);
-        topWrapper.add(buttonPanel, BorderLayout.SOUTH);
-        this.exportButton.addActionListener(new ActionListener() {
-
-            public void actionPerformed(ActionEvent e) {
-                BaseFileChooser fileChooser = new BaseFileChooser();
-                fileChooser.setAcceptAllFileFilterUsed(true);
-                fileChooser.addChoosableFileFilter(new FileExtensionFilter(
-                        exportFileExtension));
-                if (fileChooser.showSaveDialog(TaskTextViewerPanel.this) == BaseFileChooser.APPROVE_OPTION) {
-                    File chosenFile = fileChooser.getSelectedFile();
-                    String fileName = chosenFile.getPath();
-                    if (!chosenFile.exists()
-                            && !fileName.endsWith(exportFileExtension)) {
-                        fileName = fileName + "." + exportFileExtension;
-                    }
-                    try {
-                        PrintWriter out = new PrintWriter(new BufferedWriter(
-                                new FileWriter(fileName)));
-
-                        String text = "";
-
-                        if (scrollPaneTable.isVisible()) {
-                            text = previewTableModel.toString();
-                        } else {
-                            text = previewText.getText();
-                        }
-
-                        out.write(text);
-                        out.close();
-                    } catch (IOException ioe) {
-                        GUIUtils.showExceptionDialog(
-                                TaskTextViewerPanel.this.exportButton,
-                                "Problem saving file " + fileName, ioe);
-                    }
-                }
-            }
-        });
-        //topWrapper.add(this.scrollPane);
-        //topWrapper.add(buttonPanel);
-
-        panelEvalOutput = new javax.swing.JPanel();
-        //clusteringVisualEvalPanel1 = new moa.gui.clustertab.ClusteringVisualEvalPanel();
-        graphPanel = new javax.swing.JPanel();
-        graphPanelControlTop = new javax.swing.JPanel();
-        buttonZoomInY = new javax.swing.JButton();
-        buttonZoomOutY = new javax.swing.JButton();
-        buttonDetach = new javax.swing.JButton();
-        buttonSaveAs = new javax.swing.JButton();
-        labelEvents = new javax.swing.JLabel();
-        graphScrollPanel = new javax.swing.JScrollPane();
-        graphCanvas = new moa.gui.visualization.GraphCanvas();
-        // New EventClusters
-        //clusterEvents = new  ArrayList<ClusterEvent>();
-        //clusterEvents.add(new ClusterEvent(this,100,"Change", "Drift"));
-        //graphCanvas.setClusterEventsList(clusterEvents);
-
-        graphPanelControlBottom = new javax.swing.JPanel();
-        buttonZoomInX = new javax.swing.JButton();
-        buttonZoomOutX = new javax.swing.JButton();
-
-        setLayout(new java.awt.GridBagLayout());
-
-        jSplitPane1.setDividerLocation(200);
-        jSplitPane1.setOrientation(javax.swing.JSplitPane.VERTICAL_SPLIT);
-
-        //topWrapper.setPreferredSize(new java.awt.Dimension(688, 500));
-        //topWrapper.setLayout(new java.awt.GridBagLayout());
-
-        jSplitPane1.setLeftComponent(topWrapper);
-
-        panelEvalOutput.setBorder(javax.swing.BorderFactory.createTitledBorder("Evaluation"));
-        panelEvalOutput.setLayout(new java.awt.GridBagLayout());
-
-        //clusteringVisualEvalPanel1.setMinimumSize(new java.awt.Dimension(280, 118));
-        //clusteringVisualEvalPanel1.setPreferredSize(new java.awt.Dimension(290, 115));
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
-        gridBagConstraints.weighty = 1.0;
-        //panelEvalOutput.add(clusteringVisualEvalPanel1, gridBagConstraints);
-        initVisualEvalPanel();
-
-
-        graphPanel.setBorder(javax.swing.BorderFactory.createTitledBorder("Plot"));
-        graphPanel.setPreferredSize(new java.awt.Dimension(530, 115));
-        graphPanel.setLayout(new java.awt.GridBagLayout());
-
-        detachablePanel = new DetachablePanel();
-        detachablePanel.setFrameTitle("Plot");
-        detachablePanel.getContentPanel().add(graphPanel);
-
-        graphPanelControlTop.setLayout(new java.awt.GridBagLayout());
-
-        buttonZoomInY.setIcon(GUIHelper.getIcon("zoom_in.png"));
-        buttonZoomInY.setText("Y");
-        buttonZoomInY.addActionListener(new java.awt.event.ActionListener() {
-
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonZoomInYActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
-        graphPanelControlTop.add(buttonZoomInY, gridBagConstraints);
-
-        buttonZoomOutY.setIcon(GUIHelper.getIcon("zoom_out.png"));
-        buttonZoomOutY.setText("Y");
-        buttonZoomOutY.addActionListener(new java.awt.event.ActionListener() {
-
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonZoomOutYActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
-        graphPanelControlTop.add(buttonZoomOutY, gridBagConstraints);
-
-        labelEvents.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
-        gridBagConstraints.weightx = 1.0;
-        gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
-        graphPanelControlTop.add(labelEvents, gridBagConstraints);
-
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
-        gridBagConstraints.weightx = 1.0;
-        graphPanel.add(graphPanelControlTop, gridBagConstraints);
-
-        javax.swing.GroupLayout graphCanvasLayout = new javax.swing.GroupLayout(graphCanvas);
-        graphCanvas.setLayout(graphCanvasLayout);
-        graphCanvasLayout.setHorizontalGroup(
-                graphCanvasLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 515, Short.MAX_VALUE));
-        graphCanvasLayout.setVerticalGroup(
-                graphCanvasLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 128, Short.MAX_VALUE));
-
-        graphScrollPanel.setViewportView(graphCanvas);
-
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 1;
-        gridBagConstraints.gridwidth = 2;
-        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
-        gridBagConstraints.weightx = 1.0;
-        gridBagConstraints.weighty = 1.0;
-        gridBagConstraints.insets = new java.awt.Insets(2, 2, 2, 2);
-        graphPanel.add(graphScrollPanel, gridBagConstraints);
-
-        buttonZoomInX.setIcon(GUIHelper.getIcon("zoom_in.png"));
-        buttonZoomInX.setText("X");
-        buttonZoomInX.addActionListener(new java.awt.event.ActionListener() {
-
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonZoomInXActionPerformed(evt);
-            }
-        });
-        graphPanelControlBottom.add(buttonZoomInX);
-
-        buttonZoomOutX.setIcon(GUIHelper.getIcon("zoom_out.png"));
-        buttonZoomOutX.setText("X");
-        buttonZoomOutX.addActionListener(new java.awt.event.ActionListener() {
-
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonZoomOutXActionPerformed(evt);
-            }
-        });
-        graphPanelControlBottom.add(buttonZoomOutX);
-
-        buttonDetach.setIcon(GUIHelper.getIcon("maximize.png"));
-        buttonDetach.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                if (detachablePanel.isDetached()) {
-                    detachablePanel.reattach();
-                    buttonDetach.setIcon(GUIHelper.getIcon("maximize.png"));
-                }
-                else {
-                    detachablePanel.detach();
-                    buttonDetach.setIcon(GUIHelper.getIcon("minimize.png"));
-                }
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
-        graphPanelControlBottom.add(buttonDetach, gridBagConstraints);
-
-        buttonSaveAs.setIcon(GUIHelper.getIcon("save.gif"));
-        buttonSaveAs.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                if (fileChooserGraph == null) {
-                    fileChooserGraph = new BaseFileChooser();
-                    fileChooserGraph.setAcceptAllFileFilterUsed(false);
-                    ExtensionFileFilter filter = new ExtensionFileFilter("PNG image", "png");
-                    fileChooserGraph.addChoosableFileFilter(filter);
-                }
-                int retVal = fileChooserGraph.showSaveDialog(getParent());
-                if (retVal != BaseFileChooser.APPROVE_OPTION)
-                    return;
-                File png = fileChooserGraph.getSelectedFile();
-                PNGWriter writer = new PNGWriter(graphCanvas);
-                writer.setFile(png);
-                try {
-                    writer.toOutput();
-                }
-                catch (Exception e) {
-                    GUIHelper.showErrorMessage(getParent(), "Failed to save graph to: " + png, e);
-                }
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
-        graphPanelControlBottom.add(buttonSaveAs, gridBagConstraints);
-
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 1;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
-        graphPanel.add(graphPanelControlBottom, gridBagConstraints);
-
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
-        gridBagConstraints.weightx = 2.0;
-        gridBagConstraints.weighty = 1.0;
-        panelEvalOutput.add(detachablePanel, gridBagConstraints);
-
-        jSplitPane1.setRightComponent(panelEvalOutput);
-
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
-        gridBagConstraints.weightx = 1.0;
-        gridBagConstraints.weighty = 1.0;
-        add(jSplitPane1, gridBagConstraints);
-
-       // acc1[0] = getNewMeasureCollection();
-
-        //acc2[0] = getNewMeasureCollection();
-        //clusteringVisualEvalPanel1.setMeasures(acc1, acc2, this);
-        //this.graphCanvas.setGraph(acc1[0], acc2[0], 0, 1000);
-
-    }
-
-    /**
-     * Updates the preview table based on the information given by preview.
-     *
-     * @param preview
-     *            the new information used to update the table
-     */
-     public void setText(Preview preview) {
-         Point p = this.scrollPaneTable.getViewport().getViewPosition();
-
-         previewTableModel.setPreview(preview);
-         SwingUtilities.invokeLater(new Runnable() {
-             boolean structureChanged = previewTableModel.structureChanged();
-
-             public void run() {
-                 if (!scrollPaneTable.isVisible()) {
-                     topWrapper.remove(scrollPaneText);
-                     scrollPaneText.setVisible(false);
-                     topWrapper.add(scrollPaneTable, BorderLayout.CENTER);
-                     scrollPaneTable.setVisible(true);
-                     topWrapper.validate();
-                 }
-
-                 if (structureChanged) {
-                     previewTableModel.fireTableStructureChanged();
-                     rescaleTableColumns();
-                 } else {
-                     previewTableModel.fireTableDataChanged();
-                 }
-                 previewTable.repaint();
-             }
-         });
-
-         this.scrollPaneTable.getViewport().setViewPosition(p);
-         this.exportButton.setEnabled(preview != null);
-     }
-
-    public void setText(Object object) {
-        // Dynamic dispatch
-        if (object instanceof Preview) {
-            setText((Preview) object);
-            return;
-        } else if (object instanceof FailedTaskReport) {
-            setText((FailedTaskReport) object);
-            return;
-        }
-
-        Point p = this.scrollPaneText.getViewport().getViewPosition();
-
-        final String string = object == null ? null : object.toString();
-
-        SwingUtilities.invokeLater(
-            new Runnable(){
-                public void run(){
-                    if(!scrollPaneText.isVisible())
-                    {
-                        topWrapper.remove(scrollPaneTable);
-                        scrollPaneTable.setVisible(false);
-                        topWrapper.add(scrollPaneText, BorderLayout.CENTER);
-                        scrollPaneText.setVisible(true);
-                        topWrapper.validate();
-                    }
-                    previewText.setText(string);
-                    previewText.repaint();
-                }
-            }
-        );
-
-        this.scrollPaneText.getViewport().setViewPosition(p);
-        this.exportButton.setEnabled(object != null);
-    }
-
-    /**
-     * Displays the error message.
-     * @param failedTaskReport error message
-     */
-    public void setText(FailedTaskReport failedTaskReport) {
-        final String failedTaskReportString = failedTaskReport == null ?
-                "Failed Task Report is null" : failedTaskReport.toString();
-
-        setText(failedTaskReportString);
-    }
-
-    private void rescaleTableColumns() {
-        // iterate over all columns to resize them individually
-        TableColumnModel columnModel = previewTable.getColumnModel();
-        for (int columnIdx = 0; columnIdx < columnModel.getColumnCount(); ++columnIdx) {
-            // get the current column
-            TableColumn column = columnModel.getColumn(columnIdx);
-            // get the renderer for the column header to calculate the preferred
-            // with for the header
-            TableCellRenderer renderer = column.getHeaderRenderer();
-            // check if the renderer is null
-            if (renderer == null) {
-                // if it is null use the default renderer for header
-                renderer = previewTable.getTableHeader().getDefaultRenderer();
-            }
-            // create a cell to calculate its preferred size
-            Component comp = renderer.getTableCellRendererComponent(previewTable, column.getHeaderValue(), false, false,
-                    0, columnIdx);
-            int width = comp.getPreferredSize().width;
-            // set the maximum width which was calculated
-            column.setPreferredWidth(width);
-        }
-    }
-
-    protected MeasureCollection[] acc1 = new MeasureCollection[1];
-
-    protected MeasureCollection[] acc2 = new MeasureCollection[1];
-
-    protected String secondLine = "";
-
-    protected double round(double d) {
-        return (Math.rint(d * 100) / 100);
-    }
-
-    protected MeasureCollection getNewMeasureCollection() {
-        /*if (this.taskManagerPanel != null) {
-            return new ChangeDetectionMeasures();
-        } else {
-            return new Accuracy();
-        }*/
-        return this.typePanel.getMeasureCollection();
-    }
-
-    public void setGraph(String preview) {
-        //Change the graph when there is change in the text
-        double processFrequency = 1000;
-        if (preview != null && !preview.equals("")) {
-            MeasureCollection oldAccuracy = acc1[0];
-            acc1[0] = getNewMeasureCollection();
-            Scanner scanner = new Scanner(preview);
-            String firstLine = scanner.nextLine();
-            boolean isSecondLine = true;
-
-            boolean isPrequential = firstLine.startsWith("learning evaluation instances,evaluation time");
-            boolean isHoldOut = firstLine.startsWith("evaluation instances,to");
-            int accuracyColumn = 6;
-            int kappaColumn = 4;
-            int RamColumn = 2;
-            int timeColumn = 1;
-            int memoryColumn = 9;
-            int kappaTempColumn = 5;
-            if (this.taskManagerPanel instanceof CDTaskManagerPanel) {
-                accuracyColumn = 6;
-                kappaColumn = 4;
-                RamColumn = 2;
-                timeColumn = 1;
-                memoryColumn = 9;
-            } else if (isPrequential || isHoldOut) {
-                accuracyColumn = 4;
-                kappaColumn = 5;
-                RamColumn = 2;
-                timeColumn = 1;
-                memoryColumn = 7;
-                kappaTempColumn = 5;
-                String[] tokensFirstLine = firstLine.split(",");
-                int i = 0;
-                for (String s : tokensFirstLine) {
-                    if (s.equals("classifications correct (percent)") ||  s.equals("[avg] classifications correct (percent)")) {
-                        accuracyColumn = i;
-                    } else if (s.equals("Kappa Statistic (percent)") || s.equals("[avg] Kappa Statistic (percent)")) {
-                        kappaColumn = i;
-                    } else if (s.equals("Kappa Temporal Statistic (percent)") || s.equals("[avg] Kappa Temporal Statistic (percent)")) {
-                        kappaTempColumn = i;
-                    } else if (s.equals("model cost (RAM-Hours)")) {
-                        RamColumn = i;
-                    } else if (s.equals("evaluation time (cpu seconds)")
-                            || s.equals("total train time")) {
-                        timeColumn = i;
-                    } else if (s.equals("model serialized size (bytes)")) {
-                        memoryColumn = i;
-                    }
-                    i++;
-                }
-            }
-            if (isPrequential || isHoldOut || this.taskManagerPanel instanceof CDTaskManagerPanel) {
-                while (scanner.hasNextLine()) {
-                    String line = scanner.nextLine();
-                    String[] tokens = line.split(",");
-                    this.acc1[0].addValue(0, round(parseDouble(tokens[accuracyColumn])));
-                    this.acc1[0].addValue(1, round(parseDouble(tokens[kappaColumn])));
-                    this.acc1[0].addValue(2, round(parseDouble(tokens[kappaTempColumn])));
-                    if (!isHoldOut) {
-                        this.acc1[0].addValue(3, Math.abs(parseDouble(tokens[RamColumn])));
-                    }
-                    this.acc1[0].addValue(4, round(parseDouble(tokens[timeColumn])));
-                    this.acc1[0].addValue(5, round(parseDouble(tokens[memoryColumn]) / (1024 * 1024)));
-
-                    if (isSecondLine == true) {
-                        processFrequency = Math.abs(parseDouble(tokens[0]));
-                        isSecondLine = false;
-                        if (acc1[0].getValue(0, 0) != oldAccuracy.getValue(0, 0)) { //(!line.equals(secondLine)) {
-                            //If we are in a new task, compare with the previous
-                            secondLine = line;
-                            if (processFrequency == this.graphCanvas.getProcessFrequency()) {
-                                acc2[0] = oldAccuracy;
-                            }
-                        }
-                    }
-                }
-            } else {
-                this.acc2[0] = getNewMeasureCollection();
-            }
-            scanner.close();
-        } else {
-            this.acc1[0] = getNewMeasureCollection();
-            this.acc2[0] = getNewMeasureCollection();
-        }
-
-
-        if (this.taskManagerPanel instanceof CDTaskManagerPanel) {
-            ConceptDriftMainTask cdTask = this.taskManagerPanel.getSelectedCurrenTask();
-            ArrayList<ClusterEvent> clusterEvents = cdTask.getEventsList();
-            this.graphCanvas.setClusterEventsList(clusterEvents);
-        }
-        this.graphCanvas.setGraph(acc1[0], acc2[0], this.graphCanvas.getMeasureSelected(), (int) processFrequency);
-        this.graphCanvas.updateCanvas(true);
-        this.graphCanvas.forceAddEvents();
-        this.clusteringVisualEvalPanel1.update();
-
-    }
-
-    private double parseDouble(String s) {
-        double ret = 0;
-        if (s.equals("?") == false) {
-            ret = Double.parseDouble(s);
-        }
-        return ret;
-    }
-
-    private void scrollPane0MouseWheelMoved(java.awt.event.MouseWheelEvent evt) {//GEN-FIRST:event_scrollPane0MouseWheelMoved
-        streamPanel0.setZoom(evt.getX(), evt.getY(), (-1) * evt.getWheelRotation(), scrollPane0);
-    }//GEN-LAST:event_scrollPane0MouseWheelMoved
+	private JScrollPane scrollPaneTable;
+
+	private JScrollPane scrollPaneText;
 
-    private void buttonZoomInXActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonZoomInXActionPerformed
-        graphCanvas.scaleXResolution(false);
-    }//GEN-LAST:event_buttonZoomInXActionPerformed
+	protected JButton exportButton;
+
+	private javax.swing.JPanel topWrapper;
+
+	private javax.swing.JSplitPane jSplitPane1;
+
+	// Added for stream events
+	protected CDTaskManagerPanel taskManagerPanel;
+
+	protected TypePanel typePanel;
+
+	public void initVisualEvalPanel() {
+		acc1[0] = getNewMeasureCollection();
+		acc2[0] = getNewMeasureCollection();
+		if (clusteringVisualEvalPanel1 != null) {
+			panelEvalOutput.remove(clusteringVisualEvalPanel1);
+		}
+		clusteringVisualEvalPanel1 = new moa.gui.clustertab.ClusteringVisualEvalPanel();
+		clusteringVisualEvalPanel1.setMeasures(acc1, acc2, this);
+		this.graphCanvas.setGraph(acc1[0], acc2[0], 0, 1000);
+		this.graphCanvas.forceAddEvents();
+		clusteringVisualEvalPanel1.setMinimumSize(new java.awt.Dimension(280, 118));
+		clusteringVisualEvalPanel1.setPreferredSize(new java.awt.Dimension(290, 115));
+		panelEvalOutput.add(clusteringVisualEvalPanel1, gridBagConstraints);
+	}
+
+	public TaskTextViewerPanel() {
+		this(TypePanel.CLASSIFICATION, null);
+	}
+
+	public java.awt.GridBagConstraints gridBagConstraints;
+
+	public TaskTextViewerPanel(PreviewPanel.TypePanel typePanel, CDTaskManagerPanel taskManagerPanel) {
+		this.typePanel = typePanel;
+		this.taskManagerPanel = taskManagerPanel;
+		topWrapper = new javax.swing.JPanel();
+
+		setLayout(new GridBagLayout());
+
+		// mainPane contains the two main components of the text viewer panel:
+		// top component: preview table panel
+		// bottom component: interactive graph panel
+		this.jSplitPane1 = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
+		this.jSplitPane1.setDividerLocation(200);
+
+		// topWrapper is the wrapper of the top component of mainPane
+		this.topWrapper = new JPanel();
+		this.topWrapper.setLayout(new BorderLayout());
+
+		// previewTable displays live results in table form
+		// (or in text form, if an error occurs)
+		this.previewTableModel = new PreviewTableModel();
+		this.previewTable = new JTable(this.previewTableModel);
+		this.previewTable.setFont(new Font("Monospaced", Font.PLAIN, 12));
+		this.previewTable.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
+
+		this.previewText = new JTextArea();
+		this.previewText.setEditable(false);
+		this.previewText.setFont(new Font("Monospaced", Font.PLAIN, 12));
+
+		// scrollPane enables scroll support for previewTable
+		this.scrollPaneTable = new JScrollPane(this.previewTable, ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED,
+				ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED);
+		this.scrollPaneText = new JScrollPane(this.previewText, ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED,
+				ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED);
+		this.scrollPaneText.setVisible(false);
+
+		this.topWrapper.add(this.scrollPaneTable, BorderLayout.CENTER);
+
+		this.exportButton = new JButton("Export as .txt file...");
+		this.exportButton.setEnabled(false);
+		JPanel buttonPanel = new JPanel();
+		buttonPanel.setLayout(new GridLayout(1, 2));
+		buttonPanel.add(this.exportButton);
+		topWrapper.add(buttonPanel, BorderLayout.SOUTH);
+		this.exportButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				BaseFileChooser fileChooser = new BaseFileChooser();
+				fileChooser.setAcceptAllFileFilterUsed(true);
+				fileChooser.addChoosableFileFilter(new FileExtensionFilter(exportFileExtension));
+				if (fileChooser.showSaveDialog(TaskTextViewerPanel.this) == JFileChooser.APPROVE_OPTION) {
+					File chosenFile = fileChooser.getSelectedFile();
+					String fileName = chosenFile.getPath();
+					if (!chosenFile.exists() && !fileName.endsWith(exportFileExtension)) {
+						fileName = fileName + "." + exportFileExtension;
+					}
+					try {
+						PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(fileName)));
+
+						String text = "";
+
+						if (scrollPaneTable.isVisible()) {
+							text = previewTableModel.toString();
+						} else {
+							text = previewText.getText();
+						}
+
+						out.write(text);
+						out.close();
+					} catch (IOException ioe) {
+						GUIUtils.showExceptionDialog(TaskTextViewerPanel.this.exportButton,
+								"Problem saving file " + fileName, ioe);
+					}
+				}
+			}
+		});
+		// topWrapper.add(this.scrollPane);
+		// topWrapper.add(buttonPanel);
+
+		panelEvalOutput = new javax.swing.JPanel();
+		// clusteringVisualEvalPanel1 = new
+		// moa.gui.clustertab.ClusteringVisualEvalPanel();
+		graphPanel = new javax.swing.JPanel();
+		graphPanelControlTop = new javax.swing.JPanel();
+		buttonZoomInY = new javax.swing.JButton();
+		buttonZoomOutY = new javax.swing.JButton();
+		buttonDetach = new javax.swing.JButton();
+		buttonSaveAs = new javax.swing.JButton();
+		labelEvents = new javax.swing.JLabel();
+		graphScrollPanel = new javax.swing.JScrollPane();
+		graphCanvas = new moa.gui.visualization.GraphCanvas();
+		// New EventClusters
+		// clusterEvents = new ArrayList<ClusterEvent>();
+		// clusterEvents.add(new ClusterEvent(this,100,"Change", "Drift"));
+		// graphCanvas.setClusterEventsList(clusterEvents);
+
+		graphPanelControlBottom = new javax.swing.JPanel();
+		buttonZoomInX = new javax.swing.JButton();
+		buttonZoomOutX = new javax.swing.JButton();
+
+		setLayout(new java.awt.GridBagLayout());
+
+		jSplitPane1.setDividerLocation(200);
+		jSplitPane1.setOrientation(javax.swing.JSplitPane.VERTICAL_SPLIT);
+
+		// topWrapper.setPreferredSize(new java.awt.Dimension(688, 500));
+		// topWrapper.setLayout(new java.awt.GridBagLayout());
+
+		jSplitPane1.setLeftComponent(topWrapper);
+
+		panelEvalOutput.setBorder(javax.swing.BorderFactory.createTitledBorder("Evaluation"));
+		panelEvalOutput.setLayout(new java.awt.GridBagLayout());
+
+		// clusteringVisualEvalPanel1.setMinimumSize(new java.awt.Dimension(280, 118));
+		// clusteringVisualEvalPanel1.setPreferredSize(new java.awt.Dimension(290,
+		// 115));
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
+		gridBagConstraints.weighty = 1.0;
+		// panelEvalOutput.add(clusteringVisualEvalPanel1, gridBagConstraints);
+		initVisualEvalPanel();
+
+		graphPanel.setBorder(javax.swing.BorderFactory.createTitledBorder("Plot"));
+		graphPanel.setPreferredSize(new java.awt.Dimension(530, 115));
+		graphPanel.setLayout(new java.awt.GridBagLayout());
+
+		detachablePanel = new DetachablePanel();
+		detachablePanel.setFrameTitle("Plot");
+		detachablePanel.getContentPanel().add(graphPanel);
+
+		graphPanelControlTop.setLayout(new java.awt.GridBagLayout());
+
+		buttonZoomInY.setIcon(GUIHelper.getIcon("zoom_in.png"));
+		buttonZoomInY.setText("Y");
+		buttonZoomInY.addActionListener(new java.awt.event.ActionListener() {
+
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonZoomInYActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
+		graphPanelControlTop.add(buttonZoomInY, gridBagConstraints);
+
+		buttonZoomOutY.setIcon(GUIHelper.getIcon("zoom_out.png"));
+		buttonZoomOutY.setText("Y");
+		buttonZoomOutY.addActionListener(new java.awt.event.ActionListener() {
+
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonZoomOutYActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
+		graphPanelControlTop.add(buttonZoomOutY, gridBagConstraints);
+
+		labelEvents.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
+		gridBagConstraints.weightx = 1.0;
+		gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
+		graphPanelControlTop.add(labelEvents, gridBagConstraints);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
+		gridBagConstraints.weightx = 1.0;
+		graphPanel.add(graphPanelControlTop, gridBagConstraints);
+
+		javax.swing.GroupLayout graphCanvasLayout = new javax.swing.GroupLayout(graphCanvas);
+		graphCanvas.setLayout(graphCanvasLayout);
+		graphCanvasLayout.setHorizontalGroup(graphCanvasLayout
+				.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 515, Short.MAX_VALUE));
+		graphCanvasLayout.setVerticalGroup(graphCanvasLayout
+				.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 128, Short.MAX_VALUE));
+
+		graphScrollPanel.setViewportView(graphCanvas);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 1;
+		gridBagConstraints.gridwidth = 2;
+		gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
+		gridBagConstraints.weightx = 1.0;
+		gridBagConstraints.weighty = 1.0;
+		gridBagConstraints.insets = new java.awt.Insets(2, 2, 2, 2);
+		graphPanel.add(graphScrollPanel, gridBagConstraints);
+
+		buttonZoomInX.setIcon(GUIHelper.getIcon("zoom_in.png"));
+		buttonZoomInX.setText("X");
+		buttonZoomInX.addActionListener(new java.awt.event.ActionListener() {
+
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonZoomInXActionPerformed(evt);
+			}
+		});
+		graphPanelControlBottom.add(buttonZoomInX);
+
+		buttonZoomOutX.setIcon(GUIHelper.getIcon("zoom_out.png"));
+		buttonZoomOutX.setText("X");
+		buttonZoomOutX.addActionListener(new java.awt.event.ActionListener() {
+
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonZoomOutXActionPerformed(evt);
+			}
+		});
+		graphPanelControlBottom.add(buttonZoomOutX);
+
+		buttonDetach.setIcon(GUIHelper.getIcon("maximize.png"));
+		buttonDetach.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				if (detachablePanel.isDetached()) {
+					detachablePanel.reattach();
+					buttonDetach.setIcon(GUIHelper.getIcon("maximize.png"));
+				} else {
+					detachablePanel.detach();
+					buttonDetach.setIcon(GUIHelper.getIcon("minimize.png"));
+				}
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
+		graphPanelControlBottom.add(buttonDetach, gridBagConstraints);
+
+		buttonSaveAs.setIcon(GUIHelper.getIcon("save.gif"));
+		buttonSaveAs.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				if (fileChooserGraph == null) {
+					fileChooserGraph = new BaseFileChooser();
+					fileChooserGraph.setAcceptAllFileFilterUsed(false);
+					ExtensionFileFilter filter = new ExtensionFileFilter("PNG image", "png");
+					fileChooserGraph.addChoosableFileFilter(filter);
+				}
+				int retVal = fileChooserGraph.showSaveDialog(getParent());
+				if (retVal != JFileChooser.APPROVE_OPTION)
+					return;
+				File png = fileChooserGraph.getSelectedFile();
+				PNGWriter writer = new PNGWriter(graphCanvas);
+				writer.setFile(png);
+				try {
+					writer.toOutput();
+				} catch (Exception e) {
+					GUIHelper.showErrorMessage(getParent(), "Failed to save graph to: " + png, e);
+				}
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
+		graphPanelControlBottom.add(buttonSaveAs, gridBagConstraints);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 1;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
+		graphPanel.add(graphPanelControlBottom, gridBagConstraints);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
+		gridBagConstraints.weightx = 2.0;
+		gridBagConstraints.weighty = 1.0;
+		panelEvalOutput.add(detachablePanel, gridBagConstraints);
+
+		jSplitPane1.setRightComponent(panelEvalOutput);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
+		gridBagConstraints.weightx = 1.0;
+		gridBagConstraints.weighty = 1.0;
+		add(jSplitPane1, gridBagConstraints);
+
+		// acc1[0] = getNewMeasureCollection();
+
+		// acc2[0] = getNewMeasureCollection();
+		// clusteringVisualEvalPanel1.setMeasures(acc1, acc2, this);
+		// this.graphCanvas.setGraph(acc1[0], acc2[0], 0, 1000);
+
+	}
+
+	/**
+	 * Updates the preview table based on the information given by preview.
+	 *
+	 * @param preview the new information used to update the table
+	 */
+	public void setText(Preview preview) {
+		Point p = this.scrollPaneTable.getViewport().getViewPosition();
+
+		previewTableModel.setPreview(preview);
+		SwingUtilities.invokeLater(new Runnable() {
+			boolean structureChanged = previewTableModel.structureChanged();
+
+			@Override
+			public void run() {
+				if (!scrollPaneTable.isVisible()) {
+					topWrapper.remove(scrollPaneText);
+					scrollPaneText.setVisible(false);
+					topWrapper.add(scrollPaneTable, BorderLayout.CENTER);
+					scrollPaneTable.setVisible(true);
+					topWrapper.validate();
+				}
+
+				if (structureChanged) {
+					previewTableModel.fireTableStructureChanged();
+					rescaleTableColumns();
+				} else {
+					previewTableModel.fireTableDataChanged();
+				}
+				previewTable.repaint();
+			}
+		});
+
+		this.scrollPaneTable.getViewport().setViewPosition(p);
+		this.exportButton.setEnabled(preview != null);
+	}
+
+	public void setText(Object object) {
+		// Dynamic dispatch
+		if (object instanceof Preview) {
+			setText((Preview) object);
+			return;
+		} else if (object instanceof FailedTaskReport) {
+			setText((FailedTaskReport) object);
+			return;
+		}
+
+		Point p = this.scrollPaneText.getViewport().getViewPosition();
+
+		final String string = object == null ? null : object.toString();
+
+		SwingUtilities.invokeLater(new Runnable() {
+			@Override
+			public void run() {
+				if (!scrollPaneText.isVisible()) {
+					topWrapper.remove(scrollPaneTable);
+					scrollPaneTable.setVisible(false);
+					topWrapper.add(scrollPaneText, BorderLayout.CENTER);
+					scrollPaneText.setVisible(true);
+					topWrapper.validate();
+				}
+				previewText.setText(string);
+				previewText.repaint();
+			}
+		});
+
+		this.scrollPaneText.getViewport().setViewPosition(p);
+		this.exportButton.setEnabled(object != null);
+	}
+
+	/**
+	 * Displays the error message.
+	 * 
+	 * @param failedTaskReport error message
+	 */
+	public void setText(FailedTaskReport failedTaskReport) {
+		final String failedTaskReportString = failedTaskReport == null ? "Failed Task Report is null"
+				: failedTaskReport.toString();
+
+		setText(failedTaskReportString);
+	}
+
+	private void rescaleTableColumns() {
+		// iterate over all columns to resize them individually
+		TableColumnModel columnModel = previewTable.getColumnModel();
+		for (int columnIdx = 0; columnIdx < columnModel.getColumnCount(); ++columnIdx) {
+			// get the current column
+			TableColumn column = columnModel.getColumn(columnIdx);
+			// get the renderer for the column header to calculate the preferred
+			// with for the header
+			TableCellRenderer renderer = column.getHeaderRenderer();
+			// check if the renderer is null
+			if (renderer == null) {
+				// if it is null use the default renderer for header
+				renderer = previewTable.getTableHeader().getDefaultRenderer();
+			}
+			// create a cell to calculate its preferred size
+			Component comp = renderer.getTableCellRendererComponent(previewTable, column.getHeaderValue(), false, false,
+					0, columnIdx);
+			int width = comp.getPreferredSize().width;
+			// set the maximum width which was calculated
+			column.setPreferredWidth(width);
+		}
+	}
+
+	protected MeasureCollection[] acc1 = new MeasureCollection[1];
+
+	protected MeasureCollection[] acc2 = new MeasureCollection[1];
+
+	protected String secondLine = "";
+
+	protected double round(double d) {
+		return (Math.rint(d * 100) / 100);
+	}
+
+	protected MeasureCollection getNewMeasureCollection() {
+		/*
+		 * if (this.taskManagerPanel != null) { return new ChangeDetectionMeasures(); }
+		 * else { return new Accuracy(); }
+		 */
+		return this.typePanel.getMeasureCollection();
+	}
+
+	public void setGraph(String preview) {
+		// Change the graph when there is change in the text
+		double processFrequency = 1000;
+		if (preview != null && !preview.equals("")) {
+			MeasureCollection oldAccuracy = acc1[0];
+			acc1[0] = getNewMeasureCollection();
+			Scanner scanner = new Scanner(preview);
+			String firstLine = scanner.nextLine();
+			boolean isSecondLine = true;
+
+			boolean isPrequential = firstLine.startsWith("learning evaluation instances,evaluation time");
+			boolean isHoldOut = firstLine.startsWith("evaluation instances,to");
+			int accuracyColumn = 6;
+			int kappaColumn = 4;
+			int RamColumn = 2;
+			int timeColumn = 1;
+			int memoryColumn = 9;
+			int kappaTempColumn = 5;
+			if (this.taskManagerPanel instanceof CDTaskManagerPanel) {
+				accuracyColumn = 6;
+				kappaColumn = 4;
+				RamColumn = 2;
+				timeColumn = 1;
+				memoryColumn = 9;
+			} else if (isPrequential || isHoldOut) {
+				accuracyColumn = 4;
+				kappaColumn = 5;
+				RamColumn = 2;
+				timeColumn = 1;
+				memoryColumn = 7;
+				kappaTempColumn = 5;
+				String[] tokensFirstLine = firstLine.split(",");
+				int i = 0;
+				for (String s : tokensFirstLine) {
+					if (s.equals("classifications correct (percent)")
+							|| s.equals("[avg] classifications correct (percent)")) {
+						accuracyColumn = i;
+					} else if (s.equals("Kappa Statistic (percent)") || s.equals("[avg] Kappa Statistic (percent)")) {
+						kappaColumn = i;
+					} else if (s.equals("Kappa Temporal Statistic (percent)")
+							|| s.equals("[avg] Kappa Temporal Statistic (percent)")) {
+						kappaTempColumn = i;
+					} else if (s.equals("model cost (RAM-Hours)")) {
+						RamColumn = i;
+					} else if (s.equals("evaluation time (cpu seconds)") || s.equals("total train time")) {
+						timeColumn = i;
+					} else if (s.equals("model serialized size (bytes)")) {
+						memoryColumn = i;
+					}
+					i++;
+				}
+			}
+			if (isPrequential || isHoldOut || this.taskManagerPanel instanceof CDTaskManagerPanel) {
+				while (scanner.hasNextLine()) {
+					String line = scanner.nextLine();
+					String[] tokens = line.split(",");
+					this.acc1[0].addValue(0, round(parseDouble(tokens[accuracyColumn])));
+					this.acc1[0].addValue(1, round(parseDouble(tokens[kappaColumn])));
+					this.acc1[0].addValue(2, round(parseDouble(tokens[kappaTempColumn])));
+					if (!isHoldOut) {
+						this.acc1[0].addValue(3, Math.abs(parseDouble(tokens[RamColumn])));
+					}
+					this.acc1[0].addValue(4, round(parseDouble(tokens[timeColumn])));
+					this.acc1[0].addValue(5, round(parseDouble(tokens[memoryColumn]) / (1024 * 1024)));
+
+					if (isSecondLine == true) {
+						processFrequency = Math.abs(parseDouble(tokens[0]));
+						isSecondLine = false;
+						if (acc1[0].getValue(0, 0) != oldAccuracy.getValue(0, 0)) { // (!line.equals(secondLine)) {
+							// If we are in a new task, compare with the previous
+							secondLine = line;
+							if (processFrequency == this.graphCanvas.getProcessFrequency()) {
+								acc2[0] = oldAccuracy;
+							}
+						}
+					}
+				}
+			} else {
+				this.acc2[0] = getNewMeasureCollection();
+			}
+			scanner.close();
+		} else {
+			this.acc1[0] = getNewMeasureCollection();
+			this.acc2[0] = getNewMeasureCollection();
+		}
+
+		if (this.taskManagerPanel instanceof CDTaskManagerPanel) {
+			ConceptDriftMainTask cdTask = this.taskManagerPanel.getSelectedCurrenTask();
+			ArrayList<ClusterEvent> clusterEvents = cdTask.getEventsList();
+			this.graphCanvas.setClusterEventsList(clusterEvents);
+		}
+		this.graphCanvas.setGraph(acc1[0], acc2[0], this.graphCanvas.getMeasureSelected(), (int) processFrequency);
+		this.graphCanvas.updateCanvas(true);
+		this.graphCanvas.forceAddEvents();
+		this.clusteringVisualEvalPanel1.update();
+
+	}
+
+	private double parseDouble(String s) {
+		double ret = 0;
+		if (s.equals("?") == false) {
+			ret = Double.parseDouble(s);
+		}
+		return ret;
+	}
+
+	private void scrollPane0MouseWheelMoved(java.awt.event.MouseWheelEvent evt) {// GEN-FIRST:event_scrollPane0MouseWheelMoved
+		streamPanel0.setZoom(evt.getX(), evt.getY(), (-1) * evt.getWheelRotation(), scrollPane0);
+	}// GEN-LAST:event_scrollPane0MouseWheelMoved
+
+	private void buttonZoomInXActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonZoomInXActionPerformed
+		graphCanvas.scaleXResolution(false);
+	}// GEN-LAST:event_buttonZoomInXActionPerformed
 
-    private void buttonZoomOutYActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonZoomOutYActionPerformed
-        graphCanvas.setSize(new Dimension(graphCanvas.getWidth(), (int) (graphCanvas.getHeight() * 0.8)));
-        graphCanvas.setPreferredSize(new Dimension(graphCanvas.getWidth(), (int) (graphCanvas.getHeight() * 0.8)));
-        this.graphCanvas.updateCanvas(true);
-    }//GEN-LAST:event_buttonZoomOutYActionPerformed
+	private void buttonZoomOutYActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonZoomOutYActionPerformed
+		graphCanvas.setSize(new Dimension(graphCanvas.getWidth(), (int) (graphCanvas.getHeight() * 0.8)));
+		graphCanvas.setPreferredSize(new Dimension(graphCanvas.getWidth(), (int) (graphCanvas.getHeight() * 0.8)));
+		this.graphCanvas.updateCanvas(true);
+	}// GEN-LAST:event_buttonZoomOutYActionPerformed
 
-    private void buttonZoomOutXActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonZoomOutXActionPerformed
-        graphCanvas.scaleXResolution(true);
-    }//GEN-LAST:event_buttonZoomOutXActionPerformed
+	private void buttonZoomOutXActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonZoomOutXActionPerformed
+		graphCanvas.scaleXResolution(true);
+	}// GEN-LAST:event_buttonZoomOutXActionPerformed
 
-    private void buttonZoomInYActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonZoomInYActionPerformed
-        graphCanvas.setSize(new Dimension(graphCanvas.getWidth(), (int) (graphCanvas.getHeight() * 1.2)));
-        graphCanvas.setPreferredSize(new Dimension(graphCanvas.getWidth(), (int) (graphCanvas.getHeight() * 1.2)));
-        this.graphCanvas.updateCanvas(true);
-    }//GEN-LAST:event_buttonZoomInYActionPerformed
+	private void buttonZoomInYActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonZoomInYActionPerformed
+		graphCanvas.setSize(new Dimension(graphCanvas.getWidth(), (int) (graphCanvas.getHeight() * 1.2)));
+		graphCanvas.setPreferredSize(new Dimension(graphCanvas.getWidth(), (int) (graphCanvas.getHeight() * 1.2)));
+		this.graphCanvas.updateCanvas(true);
+	}// GEN-LAST:event_buttonZoomInYActionPerformed
 
-    private void buttonRunActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonRunActionPerformed
-        // TODO add your handling code here:
-    }//GEN-LAST:event_buttonRunActionPerformed
+	private void buttonRunActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonRunActionPerformed
+		// TODO add your handling code here:
+	}// GEN-LAST:event_buttonRunActionPerformed
 
-    // Variables declaration - do not modify//GEN-BEGIN:variables
-    private javax.swing.JButton buttonRun;
+	// Variables declaration - do not modify//GEN-BEGIN:variables
+	private javax.swing.JButton buttonRun;
 
-    private javax.swing.JButton buttonScreenshot;
+	private javax.swing.JButton buttonScreenshot;
 
-    private javax.swing.JButton buttonStop;
+	private javax.swing.JButton buttonStop;
 
-    private javax.swing.JButton buttonZoomInX;
+	private javax.swing.JButton buttonZoomInX;
 
-    private javax.swing.JButton buttonZoomInY;
+	private javax.swing.JButton buttonZoomInY;
 
-    private javax.swing.JButton buttonZoomOutX;
+	private javax.swing.JButton buttonZoomOutX;
 
-    private javax.swing.JButton buttonZoomOutY;
+	private javax.swing.JButton buttonZoomOutY;
 
-    private javax.swing.JButton buttonDetach;
+	private javax.swing.JButton buttonDetach;
 
-    private javax.swing.JButton buttonSaveAs;
+	private javax.swing.JButton buttonSaveAs;
 
-    private DetachablePanel detachablePanel;
+	private DetachablePanel detachablePanel;
 
-    private javax.swing.JCheckBox checkboxDrawClustering;
+	private javax.swing.JCheckBox checkboxDrawClustering;
 
-    private javax.swing.JCheckBox checkboxDrawGT;
+	private javax.swing.JCheckBox checkboxDrawGT;
 
-    private javax.swing.JCheckBox checkboxDrawMicro;
+	private javax.swing.JCheckBox checkboxDrawMicro;
 
-    private javax.swing.JCheckBox checkboxDrawPoints;
+	private javax.swing.JCheckBox checkboxDrawPoints;
 
-    private moa.gui.clustertab.ClusteringVisualEvalPanel clusteringVisualEvalPanel1;
+	private moa.gui.clustertab.ClusteringVisualEvalPanel clusteringVisualEvalPanel1;
 
-    private javax.swing.JComboBox comboX;
+	private javax.swing.JComboBox comboX;
 
-    private javax.swing.JComboBox comboY;
+	private javax.swing.JComboBox comboY;
 
-    private moa.gui.visualization.GraphCanvas graphCanvas;
+	private moa.gui.visualization.GraphCanvas graphCanvas;
 
-    private BaseFileChooser fileChooserGraph;
+	private BaseFileChooser fileChooserGraph;
 
-    private javax.swing.JPanel graphPanel;
+	private javax.swing.JPanel graphPanel;
 
-    private javax.swing.JPanel graphPanelControlBottom;
+	private javax.swing.JPanel graphPanelControlBottom;
 
-    private javax.swing.JPanel graphPanelControlTop;
+	private javax.swing.JPanel graphPanelControlTop;
 
-    private javax.swing.JScrollPane graphScrollPanel;
+	private javax.swing.JScrollPane graphScrollPanel;
 
-    private javax.swing.JLabel jLabel1;
+	private javax.swing.JLabel jLabel1;
 
-    private javax.swing.JLabel labelEvents;
+	private javax.swing.JLabel labelEvents;
 
-    private javax.swing.JLabel labelNumPause;
+	private javax.swing.JLabel labelNumPause;
 
-    private javax.swing.JLabel labelX;
+	private javax.swing.JLabel labelX;
 
-    private javax.swing.JLabel labelY;
+	private javax.swing.JLabel labelY;
 
-    private javax.swing.JLabel label_processed_points;
+	private javax.swing.JLabel label_processed_points;
 
-    private javax.swing.JLabel label_processed_points_value;
+	private javax.swing.JLabel label_processed_points_value;
 
-    private javax.swing.JTextField numPauseAfterPoints;
+	private javax.swing.JTextField numPauseAfterPoints;
 
-    private javax.swing.JPanel panelControl;
+	private javax.swing.JPanel panelControl;
 
-    private javax.swing.JPanel panelEvalOutput;
+	private javax.swing.JPanel panelEvalOutput;
 
-    private javax.swing.JPanel panelVisualWrapper;
+	private javax.swing.JPanel panelVisualWrapper;
 
-    private javax.swing.JScrollPane scrollPane0;
+	private javax.swing.JScrollPane scrollPane0;
 
-    private javax.swing.JScrollPane scrollPane1;
+	private javax.swing.JScrollPane scrollPane1;
 
-    private javax.swing.JSlider speedSlider;
+	private javax.swing.JSlider speedSlider;
 
-    private javax.swing.JSplitPane splitVisual;
+	private javax.swing.JSplitPane splitVisual;
 
-    private moa.gui.visualization.StreamPanel streamPanel0;
+	private moa.gui.visualization.StreamPanel streamPanel0;
 
-    private moa.gui.visualization.StreamPanel streamPanel1;
+	private moa.gui.visualization.StreamPanel streamPanel1;
 
-    @Override
-    public void actionPerformed(ActionEvent e) {
-        // reacte on graph selection and find out which measure was selected
-        int selected = Integer.parseInt(e.getActionCommand());
-        int counter = selected;
-        int m_select = 0;
-        int m_select_offset = 0;
-        boolean found = false;
-        for (int i = 0; i < acc1.length; i++) {
-            for (int j = 0; j < acc1[i].getNumMeasures(); j++) {
-                if (acc1[i].isEnabled(j)) {
-                    counter--;
-                    if (counter < 0) {
-                        m_select = i;
-                        m_select_offset = j;
-                        found = true;
-                        break;
-                    }
-                }
-            }
-            if (found) {
-                break;
-            }
-        }
-        this.graphCanvas.setGraph(acc1[m_select], acc2[m_select], m_select_offset,
-                this.graphCanvas.getProcessFrequency());
-        this.graphCanvas.forceAddEvents();
-    }
+	@Override
+	public void actionPerformed(ActionEvent e) {
+		// reacte on graph selection and find out which measure was selected
+		int selected = Integer.parseInt(e.getActionCommand());
+		int counter = selected;
+		int m_select = 0;
+		int m_select_offset = 0;
+		boolean found = false;
+		for (int i = 0; i < acc1.length; i++) {
+			for (int j = 0; j < acc1[i].getNumMeasures(); j++) {
+				if (acc1[i].isEnabled(j)) {
+					counter--;
+					if (counter < 0) {
+						m_select = i;
+						m_select_offset = j;
+						found = true;
+						break;
+					}
+				}
+			}
+			if (found) {
+				break;
+			}
+		}
+		this.graphCanvas.setGraph(acc1[m_select], acc2[m_select], m_select_offset,
+				this.graphCanvas.getProcessFrequency());
+		this.graphCanvas.forceAddEvents();
+	}
 }
diff --git a/moa/src/main/java/moa/gui/TextViewerPanel.java b/moa/src/main/java/moa/gui/TextViewerPanel.java
index 732e01b91..943a53289 100644
--- a/moa/src/main/java/moa/gui/TextViewerPanel.java
+++ b/moa/src/main/java/moa/gui/TextViewerPanel.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
@@ -32,6 +32,7 @@
 import java.io.PrintWriter;
 
 import javax.swing.JButton;
+import javax.swing.JFileChooser;
 import javax.swing.JPanel;
 import javax.swing.JScrollPane;
 import javax.swing.JTextArea;
@@ -46,69 +47,66 @@
  */
 public class TextViewerPanel extends JPanel {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public static String exportFileExtension = "txt";
+	public static String exportFileExtension = "txt";
 
-    protected JTextArea textArea;
+	protected JTextArea textArea;
 
-    protected JScrollPane scrollPane;
+	protected JScrollPane scrollPane;
 
-    protected JButton exportButton;
+	protected JButton exportButton;
 
-    public TextViewerPanel() {
-        this.textArea = new JTextArea();
-        this.textArea.setEditable(false);
-        this.textArea.setFont(new Font("Monospaced", Font.PLAIN, 12));
-        this.exportButton = new JButton("Export as .txt file...");
-        this.exportButton.setEnabled(false);
-        JPanel buttonPanel = new JPanel();
-        buttonPanel.setLayout(new GridLayout(1, 2));
-        buttonPanel.add(this.exportButton);
-        setLayout(new BorderLayout());
-        this.scrollPane = new JScrollPane(this.textArea);
-        add(this.scrollPane, BorderLayout.CENTER);
-        add(buttonPanel, BorderLayout.SOUTH);
-        this.exportButton.addActionListener(new ActionListener() {
+	public TextViewerPanel() {
+		this.textArea = new JTextArea();
+		this.textArea.setEditable(false);
+		this.textArea.setFont(new Font("Monospaced", Font.PLAIN, 12));
+		this.exportButton = new JButton("Export as .txt file...");
+		this.exportButton.setEnabled(false);
+		JPanel buttonPanel = new JPanel();
+		buttonPanel.setLayout(new GridLayout(1, 2));
+		buttonPanel.add(this.exportButton);
+		setLayout(new BorderLayout());
+		this.scrollPane = new JScrollPane(this.textArea);
+		add(this.scrollPane, BorderLayout.CENTER);
+		add(buttonPanel, BorderLayout.SOUTH);
+		this.exportButton.addActionListener(new ActionListener() {
 
-            public void actionPerformed(ActionEvent e) {
-                BaseFileChooser fileChooser = new BaseFileChooser();
-                fileChooser.setAcceptAllFileFilterUsed(true);
-                fileChooser.addChoosableFileFilter(new FileExtensionFilter(
-                        exportFileExtension));
-                if (fileChooser.showSaveDialog(TextViewerPanel.this) == BaseFileChooser.APPROVE_OPTION) {
-                    File chosenFile = fileChooser.getSelectedFile();
-                    String fileName = chosenFile.getPath();
-                    if (!chosenFile.exists()
-                            && !fileName.endsWith(exportFileExtension)) {
-                        fileName = fileName + "." + exportFileExtension;
-                    }
-                    try {
-                        PrintWriter out = new PrintWriter(new BufferedWriter(
-                                new FileWriter(fileName)));
-                        out.write(TextViewerPanel.this.textArea.getText());
-                        out.close();
-                    } catch (IOException ioe) {
-                        GUIUtils.showExceptionDialog(
-                                TextViewerPanel.this.exportButton,
-                                "Problem saving file " + fileName, ioe);
-                    }
-                }
-            }
-        });
-    }
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				BaseFileChooser fileChooser = new BaseFileChooser();
+				fileChooser.setAcceptAllFileFilterUsed(true);
+				fileChooser.addChoosableFileFilter(new FileExtensionFilter(exportFileExtension));
+				if (fileChooser.showSaveDialog(TextViewerPanel.this) == JFileChooser.APPROVE_OPTION) {
+					File chosenFile = fileChooser.getSelectedFile();
+					String fileName = chosenFile.getPath();
+					if (!chosenFile.exists() && !fileName.endsWith(exportFileExtension)) {
+						fileName = fileName + "." + exportFileExtension;
+					}
+					try {
+						PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(fileName)));
+						out.write(TextViewerPanel.this.textArea.getText());
+						out.close();
+					} catch (IOException ioe) {
+						GUIUtils.showExceptionDialog(TextViewerPanel.this.exportButton,
+								"Problem saving file " + fileName, ioe);
+					}
+				}
+			}
+		});
+	}
 
-    public void setText(String newText) {
-        Point p = this.scrollPane.getViewport().getViewPosition();
-        this.textArea.setText(newText);
-        this.scrollPane.getViewport().setViewPosition(p);
-        this.exportButton.setEnabled(newText != null);
-    }
+	public void setText(String newText) {
+		Point p = this.scrollPane.getViewport().getViewPosition();
+		this.textArea.setText(newText);
+		this.scrollPane.getViewport().setViewPosition(p);
+		this.exportButton.setEnabled(newText != null);
+	}
 
-    public void addText(String newText) {
-        String text = textArea.getText();
-        text += (!text.isEmpty()) ? "\n" : "";
-        text += newText;
-        setText(text);
-    }
+	public void addText(String newText) {
+		String text = textArea.getText();
+		text += (!text.isEmpty()) ? "\n" : "";
+		text += newText;
+		setText(text);
+	}
 }
diff --git a/moa/src/main/java/moa/gui/WEKAClassOptionEditComponent.java b/moa/src/main/java/moa/gui/WEKAClassOptionEditComponent.java
index 755326f70..27c2181e6 100644
--- a/moa/src/main/java/moa/gui/WEKAClassOptionEditComponent.java
+++ b/moa/src/main/java/moa/gui/WEKAClassOptionEditComponent.java
@@ -16,7 +16,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui;
 
@@ -44,84 +44,82 @@
  * @author FracPete (fracpete at waikato dot ac dot nz)
  * @version $Revision$
  */
-public class WEKAClassOptionEditComponent
-        extends JPanel
-        implements OptionEditComponent {
-
-    private static final long serialVersionUID = 1L;
-
-    protected WEKAClassOption editedOption;
-
-    protected JTextField textField = new JTextField();
-
-    protected JButton editButton = new JButton("Edit");
-
-    public WEKAClassOptionEditComponent(Option opt) {
-        WEKAClassOption option = (WEKAClassOption) opt;
-        this.editedOption = option;
-        this.textField.setEditable(false);
-        setLayout(new BorderLayout());
-        add(this.textField, BorderLayout.CENTER);
-        add(this.editButton, BorderLayout.EAST);
-        this.editButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                editObject();
-            }
-        });
-        setEditState(this.editedOption.getValueAsCLIString());
-    }
-
-    @Override
-    public void applyState() {
-        this.editedOption.setValueViaCLIString(this.textField.getText());
-    }
-
-    @Override
-    public Option getEditedOption() {
-        return this.editedOption;
-    }
-
-    @Override
-    public void setEditState(String cliString) {
-        this.textField.setText(cliString);
-    }
-
-    public void editObject() {
-        final GenericObjectEditor goe = new GenericObjectEditor(true);
-        goe.setClassType(editedOption.getRequiredType());
-        try {
-            String[] options = Utils.splitOptions(editedOption.getValueAsCLIString());
-            String classname = options[0];
-            options[0] = "";
-            Object obj = Class.forName(classname).newInstance();
-            if (obj instanceof weka.core.OptionHandler) {
-                ((weka.core.OptionHandler) obj).setOptions(options);
-            }
-            goe.setValue(obj);
-            ((GOEPanel) goe.getCustomEditor()).addOkListener(new ActionListener() {
-
-                @Override
-                public void actionPerformed(ActionEvent e) {
-                    Object obj = goe.getValue();
-                    String s = obj.getClass().getName();
-                    if (obj instanceof weka.core.OptionHandler) {
-                        s += " " + Utils.joinOptions(((weka.core.OptionHandler) obj).getOptions());
-                    }
-                    setEditState(s.trim());
-                }
-            });
-            PropertyDialog dialog;
-            if (PropertyDialog.getParentDialog(this) != null) {
-                dialog = new PropertyDialog(PropertyDialog.getParentDialog(this), goe);
-            } else {
-                dialog = new PropertyDialog(PropertyDialog.getParentFrame(this), goe);
-            }
-            dialog.setModal(true);
-            dialog.setVisible(true);
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
+public class WEKAClassOptionEditComponent extends JPanel implements OptionEditComponent {
+
+	private static final long serialVersionUID = 1L;
+
+	protected WEKAClassOption editedOption;
+
+	protected JTextField textField = new JTextField();
+
+	protected JButton editButton = new JButton("Edit");
+
+	public WEKAClassOptionEditComponent(Option opt) {
+		WEKAClassOption option = (WEKAClassOption) opt;
+		this.editedOption = option;
+		this.textField.setEditable(false);
+		setLayout(new BorderLayout());
+		add(this.textField, BorderLayout.CENTER);
+		add(this.editButton, BorderLayout.EAST);
+		this.editButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				editObject();
+			}
+		});
+		setEditState(this.editedOption.getValueAsCLIString());
+	}
+
+	@Override
+	public void applyState() {
+		this.editedOption.setValueViaCLIString(this.textField.getText());
+	}
+
+	@Override
+	public Option getEditedOption() {
+		return this.editedOption;
+	}
+
+	@Override
+	public void setEditState(String cliString) {
+		this.textField.setText(cliString);
+	}
+
+	public void editObject() {
+		final GenericObjectEditor goe = new GenericObjectEditor(true);
+		goe.setClassType(editedOption.getRequiredType());
+		try {
+			String[] options = Utils.splitOptions(editedOption.getValueAsCLIString());
+			String classname = options[0];
+			options[0] = "";
+			Object obj = Class.forName(classname).newInstance();
+			if (obj instanceof weka.core.OptionHandler) {
+				((weka.core.OptionHandler) obj).setOptions(options);
+			}
+			goe.setValue(obj);
+			((GOEPanel) goe.getCustomEditor()).addOkListener(new ActionListener() {
+
+				@Override
+				public void actionPerformed(ActionEvent e) {
+					Object obj = goe.getValue();
+					String s = obj.getClass().getName();
+					if (obj instanceof weka.core.OptionHandler) {
+						s += " " + Utils.joinOptions(((weka.core.OptionHandler) obj).getOptions());
+					}
+					setEditState(s.trim());
+				}
+			});
+			PropertyDialog dialog;
+			if (PropertyDialog.getParentDialog(this) != null) {
+				dialog = new PropertyDialog(PropertyDialog.getParentDialog(this), goe);
+			} else {
+				dialog = new PropertyDialog(PropertyDialog.getParentFrame(this), goe);
+			}
+			dialog.setModal(true);
+			dialog.setVisible(true);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
 }
diff --git a/moa/src/main/java/moa/gui/active/ALPreviewPanel.java b/moa/src/main/java/moa/gui/active/ALPreviewPanel.java
index 358f6a2ae..c44a6820c 100644
--- a/moa/src/main/java/moa/gui/active/ALPreviewPanel.java
+++ b/moa/src/main/java/moa/gui/active/ALPreviewPanel.java
@@ -17,7 +17,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.active;
 
@@ -51,207 +51,204 @@
  */
 public class ALPreviewPanel extends JPanel implements ResultPreviewListener {
 
-    private static final long serialVersionUID = 1L;
-
-    protected ALTaskThread previewedThread;
-
-    protected JLabel previewLabel;
-
-    protected JButton refreshButton;
-
-    protected JLabel autoRefreshLabel;
-    
-    protected JComboBox<String> autoRefreshComboBox;
-
-    protected ALTaskTextViewerPanel textViewerPanel;
-
-    protected javax.swing.Timer autoRefreshTimer;
-
-    /**
-     * Initialises the underlying ALTaskTextViewerPanel and the refresh components.
-     */
-    public ALPreviewPanel() {
-    	this.textViewerPanel = new ALTaskTextViewerPanel(); 
-    	this.previewLabel = new JLabel("No preview available");
-    	this.refreshButton = new JButton("Refresh");
-    	this.autoRefreshLabel = new JLabel("Auto refresh: ");
-    	this.autoRefreshComboBox = new JComboBox<String>(PreviewPanel.autoFreqStrings);
-        this.autoRefreshComboBox.setSelectedIndex(1); // default to 1 sec
-        JPanel controlPanel = new JPanel();
-        controlPanel.add(this.previewLabel);
-        controlPanel.add(this.refreshButton);
-        controlPanel.add(this.autoRefreshLabel);
-        controlPanel.add(this.autoRefreshComboBox);
-        setLayout(new BorderLayout());
-        add(controlPanel, BorderLayout.NORTH);
-        add(this.textViewerPanel, BorderLayout.CENTER);
-        this.refreshButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                refresh();
-            }
-        });
-        this.autoRefreshTimer = new javax.swing.Timer(1000,
-                new ActionListener() {
-
-                    @Override
-                    public void actionPerformed(ActionEvent e) {
-                        refresh();
-                    }
-                });
-        this.autoRefreshComboBox.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                updateAutoRefreshTimer();
-            }
-        });
-        setTaskThreadToPreview(null);
-    }
-
-    /**
-     * Refreshes the preview.
-     */
-    private void refresh() {
-        if (this.previewedThread != null) {
-            if (this.previewedThread.isComplete()) {
-                setLatestPreview();
-                disableRefresh();
-            } else {
-                this.previewedThread.getPreview(ALPreviewPanel.this);
-            }
-        }
-    }
-
-    /**
-     * Sets the TaskThread that will be previewed.
-     * @param thread TaskThread to be previewed
-     */
+	private static final long serialVersionUID = 1L;
+
+	protected ALTaskThread previewedThread;
+
+	protected JLabel previewLabel;
+
+	protected JButton refreshButton;
+
+	protected JLabel autoRefreshLabel;
+
+	protected JComboBox<String> autoRefreshComboBox;
+
+	protected ALTaskTextViewerPanel textViewerPanel;
+
+	protected javax.swing.Timer autoRefreshTimer;
+
+	/**
+	 * Initialises the underlying ALTaskTextViewerPanel and the refresh components.
+	 */
+	public ALPreviewPanel() {
+		this.textViewerPanel = new ALTaskTextViewerPanel();
+		this.previewLabel = new JLabel("No preview available");
+		this.refreshButton = new JButton("Refresh");
+		this.autoRefreshLabel = new JLabel("Auto refresh: ");
+		this.autoRefreshComboBox = new JComboBox<>(PreviewPanel.autoFreqStrings);
+		this.autoRefreshComboBox.setSelectedIndex(1); // default to 1 sec
+		JPanel controlPanel = new JPanel();
+		controlPanel.add(this.previewLabel);
+		controlPanel.add(this.refreshButton);
+		controlPanel.add(this.autoRefreshLabel);
+		controlPanel.add(this.autoRefreshComboBox);
+		setLayout(new BorderLayout());
+		add(controlPanel, BorderLayout.NORTH);
+		add(this.textViewerPanel, BorderLayout.CENTER);
+		this.refreshButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				refresh();
+			}
+		});
+		this.autoRefreshTimer = new javax.swing.Timer(1000, new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				refresh();
+			}
+		});
+		this.autoRefreshComboBox.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				updateAutoRefreshTimer();
+			}
+		});
+		setTaskThreadToPreview(null);
+	}
+
+	/**
+	 * Refreshes the preview.
+	 */
+	private void refresh() {
+		if (this.previewedThread != null) {
+			if (this.previewedThread.isComplete()) {
+				setLatestPreview();
+				disableRefresh();
+			} else {
+				this.previewedThread.getPreview(ALPreviewPanel.this);
+			}
+		}
+	}
+
+	/**
+	 * Sets the TaskThread that will be previewed.
+	 * 
+	 * @param thread TaskThread to be previewed
+	 */
 	public void setTaskThreadToPreview(ALTaskThread thread) {
-        this.previewedThread = thread;
-        setLatestPreview();
-        if (thread == null) {
-            disableRefresh();
-        } else if (!thread.isComplete()) {
-            enableRefresh();
-        }
-    }
-
-    /**
-     * Requests the latest preview and sends it to the TextViewerPanel to
-     * display it.
-     */
-    private void setLatestPreview() {
-
-    	if(this.previewedThread != null && this.previewedThread.isFailed())
-    	{
-    		// failed task
-    		FailedTaskReport failedTaskReport = (FailedTaskReport) this.previewedThread.getFinalResult();
-    		this.textViewerPanel.setErrorText(failedTaskReport);
-    		this.textViewerPanel.setGraph(null, null);
-    	}
-    	else
-    	{
-        	Preview preview = null;
-    		if ((this.previewedThread != null) && this.previewedThread.isComplete()) {
-    			// cancelled or completed task
-    			preview = (Preview) this.previewedThread.getFinalResult();
-    			this.previewLabel.setText("Final result");
-    			disableRefresh();
-    		} else if (this.previewedThread != null){
-    			// running task
-    			preview = (Preview) this.previewedThread.getLatestResultPreview();
-    			double grabTime = this.previewedThread.getLatestPreviewGrabTimeSeconds();
-    			String grabString = " (" + StringUtils.secondsToDHMSString(grabTime) + ")";
-    			if (preview == null) {
-    				this.previewLabel.setText("No preview available" + grabString);
-    			} else {
-    				this.previewLabel.setText("Preview" + grabString);
-    			}
-    		} else {
-    			// no thread
-    			this.previewLabel.setText("No preview available");
-    			preview = null;
-    		}
-        	
-    		this.textViewerPanel.setText(preview);
-    		this.textViewerPanel.setGraph(preview, getColorCodings(this.previewedThread));
-    	}
-    }
-    
-    /**
-     * Reads the color codings of the subtasks.
-     * @return array of color codings, one for each subtask
-     */
-    private Color[] getColorCodings(ALTaskThread thread) {
-    	if (thread == null) {
-    		return null;
-    	}
-    	
-    	ALMainTask task = (ALMainTask) thread.getTask();
-    	
-    	List<ALTaskThread> subtaskThreads = task.getSubtaskThreads();
-    	
-    	if (subtaskThreads.size() == 0) {
-    		// no hierarchical thread, e.g. ALPrequentialEvaluationTask
-    		return new Color[]{task.getColorCoding()};
-    	}
-    	
-    	
-    	if (task.getClass() == ALPartitionEvaluationTask.class) {
-    		// if the task is a cross validation task, it displays the mean
-    		// over the underlying params. The color coding therefore 
-    		// corresponds to the color coding of each of its subtasks.
-    		return getColorCodings(subtaskThreads.get(0));
-    	}
-    	
-    	Color[] colors = new Color[subtaskThreads.size()];
-    	for (int i = 0; i < subtaskThreads.size(); i++) {
-    		ALMainTask subtask = (ALMainTask) subtaskThreads.get(i).getTask();
-    		colors[i] = subtask.getColorCoding();
-    	}
-    	return colors;
-    }
-
-    /**
-     * Updates the refresh timer by the setting of the "Auto refresh" box.
-     */
-    private void updateAutoRefreshTimer() {
-        int autoDelay = PreviewPanel.autoFreqTimeSecs[this.autoRefreshComboBox.getSelectedIndex()];
-        if (autoDelay > 0) {
-            if (this.autoRefreshTimer.isRunning()) {
-                this.autoRefreshTimer.stop();
-            }
-            this.autoRefreshTimer.setDelay(autoDelay * 1000);
-            this.autoRefreshTimer.start();
-        } else {
-            this.autoRefreshTimer.stop();
-        }
-    }
-
-    /**
-     * Disables refreshing.
-     */
-    private void disableRefresh() {
-        this.refreshButton.setEnabled(false);
-        this.autoRefreshLabel.setEnabled(false);
-        this.autoRefreshComboBox.setEnabled(false);
-        this.autoRefreshTimer.stop();
-    }
-
-    /**
-     * Enables refreshing.
-     */
-    private void enableRefresh() {
-        this.refreshButton.setEnabled(true);
-        this.autoRefreshLabel.setEnabled(true);
-        this.autoRefreshComboBox.setEnabled(true);
-        updateAutoRefreshTimer();
-    }
-
-    @Override
-    public void latestPreviewChanged() {
-        setTaskThreadToPreview(this.previewedThread);
-    }
+		this.previewedThread = thread;
+		setLatestPreview();
+		if (thread == null) {
+			disableRefresh();
+		} else if (!thread.isComplete()) {
+			enableRefresh();
+		}
+	}
+
+	/**
+	 * Requests the latest preview and sends it to the TextViewerPanel to display
+	 * it.
+	 */
+	private void setLatestPreview() {
+
+		if (this.previewedThread != null && this.previewedThread.isFailed()) {
+			// failed task
+			FailedTaskReport failedTaskReport = (FailedTaskReport) this.previewedThread.getFinalResult();
+			this.textViewerPanel.setErrorText(failedTaskReport);
+			this.textViewerPanel.setGraph(null, null);
+		} else {
+			Preview preview = null;
+			if ((this.previewedThread != null) && this.previewedThread.isComplete()) {
+				// cancelled or completed task
+				preview = (Preview) this.previewedThread.getFinalResult();
+				this.previewLabel.setText("Final result");
+				disableRefresh();
+			} else if (this.previewedThread != null) {
+				// running task
+				preview = (Preview) this.previewedThread.getLatestResultPreview();
+				double grabTime = this.previewedThread.getLatestPreviewGrabTimeSeconds();
+				String grabString = " (" + StringUtils.secondsToDHMSString(grabTime) + ")";
+				if (preview == null) {
+					this.previewLabel.setText("No preview available" + grabString);
+				} else {
+					this.previewLabel.setText("Preview" + grabString);
+				}
+			} else {
+				// no thread
+				this.previewLabel.setText("No preview available");
+				preview = null;
+			}
+
+			this.textViewerPanel.setText(preview);
+			this.textViewerPanel.setGraph(preview, getColorCodings(this.previewedThread));
+		}
+	}
+
+	/**
+	 * Reads the color codings of the subtasks.
+	 * 
+	 * @return array of color codings, one for each subtask
+	 */
+	private Color[] getColorCodings(ALTaskThread thread) {
+		if (thread == null) {
+			return null;
+		}
+
+		ALMainTask task = (ALMainTask) thread.getTask();
+
+		List<ALTaskThread> subtaskThreads = task.getSubtaskThreads();
+
+		if (subtaskThreads.size() == 0) {
+			// no hierarchical thread, e.g. ALPrequentialEvaluationTask
+			return new Color[] { task.getColorCoding() };
+		}
+
+		if (task.getClass() == ALPartitionEvaluationTask.class) {
+			// if the task is a cross validation task, it displays the mean
+			// over the underlying params. The color coding therefore
+			// corresponds to the color coding of each of its subtasks.
+			return getColorCodings(subtaskThreads.get(0));
+		}
+
+		Color[] colors = new Color[subtaskThreads.size()];
+		for (int i = 0; i < subtaskThreads.size(); i++) {
+			ALMainTask subtask = (ALMainTask) subtaskThreads.get(i).getTask();
+			colors[i] = subtask.getColorCoding();
+		}
+		return colors;
+	}
+
+	/**
+	 * Updates the refresh timer by the setting of the "Auto refresh" box.
+	 */
+	private void updateAutoRefreshTimer() {
+		int autoDelay = PreviewPanel.autoFreqTimeSecs[this.autoRefreshComboBox.getSelectedIndex()];
+		if (autoDelay > 0) {
+			if (this.autoRefreshTimer.isRunning()) {
+				this.autoRefreshTimer.stop();
+			}
+			this.autoRefreshTimer.setDelay(autoDelay * 1000);
+			this.autoRefreshTimer.start();
+		} else {
+			this.autoRefreshTimer.stop();
+		}
+	}
+
+	/**
+	 * Disables refreshing.
+	 */
+	private void disableRefresh() {
+		this.refreshButton.setEnabled(false);
+		this.autoRefreshLabel.setEnabled(false);
+		this.autoRefreshComboBox.setEnabled(false);
+		this.autoRefreshTimer.stop();
+	}
+
+	/**
+	 * Enables refreshing.
+	 */
+	private void enableRefresh() {
+		this.refreshButton.setEnabled(true);
+		this.autoRefreshLabel.setEnabled(true);
+		this.autoRefreshComboBox.setEnabled(true);
+		updateAutoRefreshTimer();
+	}
+
+	@Override
+	public void latestPreviewChanged() {
+		setTaskThreadToPreview(this.previewedThread);
+	}
 }
diff --git a/moa/src/main/java/moa/gui/active/ALTaskManagerPanel.java b/moa/src/main/java/moa/gui/active/ALTaskManagerPanel.java
index f4535fb89..12e303c50 100644
--- a/moa/src/main/java/moa/gui/active/ALTaskManagerPanel.java
+++ b/moa/src/main/java/moa/gui/active/ALTaskManagerPanel.java
@@ -18,7 +18,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.active;
 
@@ -43,6 +43,7 @@
 import java.util.prefs.Preferences;
 
 import javax.swing.JButton;
+import javax.swing.JFileChooser;
 import javax.swing.JMenuItem;
 import javax.swing.JOptionPane;
 import javax.swing.JPanel;
@@ -70,489 +71,464 @@
 import moa.tasks.meta.ALTaskThread;
 import nz.ac.waikato.cms.gui.core.BaseFileChooser;
 
-
 /**
  * This panel displays the running tasks for active learning experiments.
  *
  * @author Tuan Pham Minh (tuan.pham@ovgu.de)
  * @version $Revision: 1 $
  */
-public class ALTaskManagerPanel extends JPanel{
-	
+public class ALTaskManagerPanel extends JPanel {
+
 	private static final long serialVersionUID = 1L;
 
-    public static final int MILLISECS_BETWEEN_REFRESH = 600;
-
-    public static String exportFileExtension = "log";
-
-    public class ProgressCellRenderer extends JProgressBar implements
-            TableCellRenderer {
-
-        private static final long serialVersionUID = 1L;
-
-        public ProgressCellRenderer() {
-            super(SwingConstants.HORIZONTAL, 0, 10000);
-            setBorderPainted(false);
-            setStringPainted(true);
-        }
-
-         @Override
-        public Component getTableCellRendererComponent(JTable table,
-                Object value, boolean isSelected, boolean hasFocus, int row,
-                int column) {
-            double frac = -1.0;
-            if (value instanceof Double) {
-                frac = ((Double) value).doubleValue();
-            }
-            if (frac >= 0.0) {
-                setIndeterminate(false);
-                setValue((int) (frac * 10000.0));
-                setString(StringUtils.doubleToString(frac * 100.0, 2, 2));
-            } else {
-                setValue(0);
-                //setIndeterminate(true);
-                //setString("?");
-            }
-            return this;
-        }
-
-        @Override
-        public void validate() {
-        }
-
-        @Override
-        public void revalidate() {
-        }
-
-        @Override
-        protected void firePropertyChange(String propertyName, Object oldValue,
-                Object newValue) {
-        }
-
-        @Override
-        public void firePropertyChange(String propertyName, boolean oldValue,
-                boolean newValue) {
-        }
-    }
-    
-    protected class TaskColorCodingCellRenderer extends DefaultTableCellRenderer implements TableCellRenderer
-    {
+	public static final int MILLISECS_BETWEEN_REFRESH = 600;
+
+	public static String exportFileExtension = "log";
+
+	public class ProgressCellRenderer extends JProgressBar implements TableCellRenderer {
+
 		private static final long serialVersionUID = 1L;
 
+		public ProgressCellRenderer() {
+			super(SwingConstants.HORIZONTAL, 0, 10000);
+			setBorderPainted(false);
+			setStringPainted(true);
+		}
+
+		@Override
+		public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
+				int row, int column) {
+			double frac = -1.0;
+			if (value instanceof Double) {
+				frac = ((Double) value);
+			}
+			if (frac >= 0.0) {
+				setIndeterminate(false);
+				setValue((int) (frac * 10000.0));
+				setString(StringUtils.doubleToString(frac * 100.0, 2, 2));
+			} else {
+				setValue(0);
+				// setIndeterminate(true);
+				// setString("?");
+			}
+			return this;
+		}
+
 		@Override
-		public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
+		public void validate() {
+		}
+
+		@Override
+		public void revalidate() {
+		}
+
+		@Override
+		protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
+		}
+
+		@Override
+		public void firePropertyChange(String propertyName, boolean oldValue, boolean newValue) {
+		}
+	}
+
+	protected class TaskColorCodingCellRenderer extends DefaultTableCellRenderer implements TableCellRenderer {
+		private static final long serialVersionUID = 1L;
+
+		@Override
+		public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
+				int row, int column) {
 			setBackground((Color) value);
 			return this;
 		}
-    	
-    }
-    
-    protected class TaskTableModel extends AbstractTableModel {
-
-        private static final long serialVersionUID = 1L;
-
-        @Override
-        public String getColumnName(int col) {
-            switch (col) {
-	        	case 0:
-	        		return "";
-	            case 1:
-	                return "command";
-	            case 2:
-	                return "status";
-	            case 3:
-	                return "time elapsed";
-	            case 4:
-	                return "current activity";
-	            case 5:
-	                return "% complete";
-            }
-            return null;
-        }
-
-        @Override
-        public int getColumnCount() {
-            return 6;
-        }
-
-        @Override
-        public int getRowCount() {
-            return ALTaskManagerPanel.this.taskList.size();
-        }
-
-        @Override
-        public Object getValueAt(int row, int col) {
-        	ALTaskThread thread = ALTaskManagerPanel.this.taskList.get(row);
-            switch (col) {
-            	case 0:
-            		return ((ALMainTask) thread.getTask()).getColorCoding();
-                case 1:
-                	// display the name specified by the task
-                    return ((ALMainTask) thread.getTask()).getDisplayName();
-                case 2:
-                    return thread.getCurrentStatusString();
-                case 3:
-                    return StringUtils.secondsToDHMSString(thread.getCPUSecondsElapsed());
-                case 4:
-                    return thread.getCurrentActivityString();
-                case 5:
-                    return new Double(thread.getCurrentActivityFracComplete());
-            }
-            return null;
-        }
-
-        @Override
-        public boolean isCellEditable(int row, int col) {
-            return false;
-        }
-    }
-    
-    
-    protected ALMainTask currentTask = new ALPartitionEvaluationTask();
-    
-    protected List<ALTaskThread> taskList = new ArrayList<ALTaskThread>();
-	
-    protected JButton configureTaskButton = new JButton("Configure");
-
-    protected JTextField taskDescField = new JTextField();
-
-    protected JButton runTaskButton = new JButton("Run");
-
-    protected TaskTableModel taskTableModel;
-
-    protected JTable taskTable;
-
-    protected JButton pauseTaskButton = new JButton("Pause");
-
-    protected JButton resumeTaskButton = new JButton("Resume");
-
-    protected JButton cancelTaskButton = new JButton("Cancel");
-
-    protected JButton deleteTaskButton = new JButton("Delete");
-    
+
+	}
+
+	protected class TaskTableModel extends AbstractTableModel {
+
+		private static final long serialVersionUID = 1L;
+
+		@Override
+		public String getColumnName(int col) {
+			switch (col) {
+			case 0:
+				return "";
+			case 1:
+				return "command";
+			case 2:
+				return "status";
+			case 3:
+				return "time elapsed";
+			case 4:
+				return "current activity";
+			case 5:
+				return "% complete";
+			}
+			return null;
+		}
+
+		@Override
+		public int getColumnCount() {
+			return 6;
+		}
+
+		@Override
+		public int getRowCount() {
+			return ALTaskManagerPanel.this.taskList.size();
+		}
+
+		@Override
+		public Object getValueAt(int row, int col) {
+			ALTaskThread thread = ALTaskManagerPanel.this.taskList.get(row);
+			switch (col) {
+			case 0:
+				return ((ALMainTask) thread.getTask()).getColorCoding();
+			case 1:
+				// display the name specified by the task
+				return ((ALMainTask) thread.getTask()).getDisplayName();
+			case 2:
+				return thread.getCurrentStatusString();
+			case 3:
+				return StringUtils.secondsToDHMSString(thread.getCPUSecondsElapsed());
+			case 4:
+				return thread.getCurrentActivityString();
+			case 5:
+				return new Double(thread.getCurrentActivityFracComplete());
+			}
+			return null;
+		}
+
+		@Override
+		public boolean isCellEditable(int row, int col) {
+			return false;
+		}
+	}
+
+	protected ALMainTask currentTask = new ALPartitionEvaluationTask();
+
+	protected List<ALTaskThread> taskList = new ArrayList<>();
+
+	protected JButton configureTaskButton = new JButton("Configure");
+
+	protected JTextField taskDescField = new JTextField();
+
+	protected JButton runTaskButton = new JButton("Run");
+
+	protected TaskTableModel taskTableModel;
+
+	protected JTable taskTable;
+
+	protected JButton pauseTaskButton = new JButton("Pause");
+
+	protected JButton resumeTaskButton = new JButton("Resume");
+
+	protected JButton cancelTaskButton = new JButton("Cancel");
+
+	protected JButton deleteTaskButton = new JButton("Delete");
+
 	protected ALPreviewPanel previewPanel;
 
-    private Preferences prefs;
-    
-    private final String PREF_NAME = "currentTask";
-
-    public ALTaskManagerPanel() {
-        // Read current task preference
-        prefs = Preferences.userRoot().node(this.getClass().getName());
-        String taskText = this.currentTask.getCLICreationString(ALMainTask.class);
-        String propertyValue = prefs.get(PREF_NAME, taskText);
-        //this.taskDescField.setText(propertyValue);
-        
-        setTaskString(propertyValue, false); //Not store preference
-        this.taskDescField.setEditable(false);
-        
-        final Component comp = this.taskDescField;
-        this.taskDescField.addMouseListener(new MouseAdapter() {
-
-            @Override
-            public void mouseClicked(MouseEvent evt) {
-                if (evt.getClickCount() == 1) {
-                    if ((evt.getButton() == MouseEvent.BUTTON3)
-                            || ((evt.getButton() == MouseEvent.BUTTON1) && evt.isAltDown() && evt.isShiftDown())) {
-                        JPopupMenu menu = new JPopupMenu();
-                        JMenuItem item;
-
-                        item = new JMenuItem("Copy configuration to clipboard");
-                        item.addActionListener(new ActionListener() {
-
-                            @Override
-                            public void actionPerformed(ActionEvent e) {
-                                copyClipBoardConfiguration();
-                            }
-                        });
-                        menu.add(item);
-
-
-
-                        item = new JMenuItem("Save selected tasks to file");
-                        item.addActionListener(new ActionListener() {
-
-                            @Override
-                            public void actionPerformed(ActionEvent arg0) {
-                                saveLogSelectedTasks();
-                            }
-                        });
-                        menu.add(item);
-
-
-                        item = new JMenuItem("Enter configuration...");
-                        item.addActionListener(new ActionListener() {
-
-                            @Override
-                            public void actionPerformed(ActionEvent arg0) {
-                                String newTaskString = JOptionPane.showInputDialog("Insert command line");
-                                if (newTaskString != null) {
-                                    setTaskString(newTaskString);
-                                }
-                            }
-                        });
-                        menu.add(item);
-
-                        menu.show(comp, evt.getX(), evt.getY());
-                    }
-                }
-            }
-        });
-
-        JPanel configPanel = new JPanel();
-        configPanel.setLayout(new BorderLayout());
-        configPanel.add(this.configureTaskButton, BorderLayout.WEST);
-        configPanel.add(this.taskDescField, BorderLayout.CENTER);
-        configPanel.add(this.runTaskButton, BorderLayout.EAST);
-        this.taskTableModel = new TaskTableModel();
-        this.taskTable = new JTable(this.taskTableModel);
-        this.taskTable.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
-        DefaultTableCellRenderer centerRenderer = new DefaultTableCellRenderer();
-        centerRenderer.setHorizontalAlignment(SwingConstants.CENTER);
-        TaskColorCodingCellRenderer taskColorCodingRenderer = new TaskColorCodingCellRenderer();
-        this.taskTable.getColumnModel().getColumn(0).setCellRenderer(
-        		taskColorCodingRenderer);
-        this.taskTable.getColumnModel().getColumn(2).setCellRenderer(
-                centerRenderer);
-        this.taskTable.getColumnModel().getColumn(3).setCellRenderer(
-                centerRenderer);
-        this.taskTable.getColumnModel().getColumn(5).setCellRenderer(
-                new ProgressCellRenderer());
-        
-        // set the color column to the smallest size possible
-        TableColumnModel tableColumnModel = taskTable.getColumnModel();
-        tableColumnModel.getColumn(0).setMaxWidth(tableColumnModel.getColumn(0).getMinWidth());
-        tableColumnModel.getColumn(0).setPreferredWidth(0);
-        
-        JPanel controlPanel = new JPanel();
-        controlPanel.add(this.pauseTaskButton);
-        controlPanel.add(this.resumeTaskButton);
-        controlPanel.add(this.cancelTaskButton);
-        controlPanel.add(this.deleteTaskButton);
-        setLayout(new BorderLayout());
-        add(configPanel, BorderLayout.NORTH);
-        add(new JScrollPane(this.taskTable), BorderLayout.CENTER);
-        add(controlPanel, BorderLayout.SOUTH);
-        this.taskTable.getSelectionModel().addListSelectionListener(
-                new ListSelectionListener() {
-
-                    @Override
-                    public void valueChanged(ListSelectionEvent arg0) {
-                    	taskSelectionChanged();
-                    }
-                });
-        this.configureTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                String newTaskString = ClassOptionSelectionPanel.showSelectClassDialog(ALTaskManagerPanel.this,
-                        "Configure task", ALMainTask.class,
-                        ALTaskManagerPanel.this.currentTask.getCLICreationString(ALMainTask.class),
-                        null);
-
-                setTaskString(newTaskString);
-            }
-        });
-        this.runTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-            	runTask((ALMainTask) ALTaskManagerPanel.this.currentTask.copy());
-            }
-        });
-        this.pauseTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-            	pauseSelectedTasks();
-            }
-        });
-        this.resumeTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-            	resumeSelectedTasks();
-            }
-        });
-        this.cancelTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-            	cancelSelectedTasks();
-            }
-        });
-        this.deleteTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-            	deleteSelectedTasks();
-            }
-        });
-
-        javax.swing.Timer updateListTimer = new javax.swing.Timer(
-                MILLISECS_BETWEEN_REFRESH, new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent e) {
-            	ALTaskManagerPanel.this.taskTable.repaint();
-            }
-        });
-        updateListTimer.start();
-        setPreferredSize(new Dimension(0, 200));
-    }
-    
+	private Preferences prefs;
+
+	private final String PREF_NAME = "currentTask";
+
+	public ALTaskManagerPanel() {
+		// Read current task preference
+		prefs = Preferences.userRoot().node(this.getClass().getName());
+		String taskText = this.currentTask.getCLICreationString(ALMainTask.class);
+		String propertyValue = prefs.get(PREF_NAME, taskText);
+		// this.taskDescField.setText(propertyValue);
+
+		setTaskString(propertyValue, false); // Not store preference
+		this.taskDescField.setEditable(false);
+
+		final Component comp = this.taskDescField;
+		this.taskDescField.addMouseListener(new MouseAdapter() {
+
+			@Override
+			public void mouseClicked(MouseEvent evt) {
+				if (evt.getClickCount() == 1) {
+					if ((evt.getButton() == MouseEvent.BUTTON3)
+							|| ((evt.getButton() == MouseEvent.BUTTON1) && evt.isAltDown() && evt.isShiftDown())) {
+						JPopupMenu menu = new JPopupMenu();
+						JMenuItem item;
+
+						item = new JMenuItem("Copy configuration to clipboard");
+						item.addActionListener(new ActionListener() {
+
+							@Override
+							public void actionPerformed(ActionEvent e) {
+								copyClipBoardConfiguration();
+							}
+						});
+						menu.add(item);
+
+						item = new JMenuItem("Save selected tasks to file");
+						item.addActionListener(new ActionListener() {
+
+							@Override
+							public void actionPerformed(ActionEvent arg0) {
+								saveLogSelectedTasks();
+							}
+						});
+						menu.add(item);
+
+						item = new JMenuItem("Enter configuration...");
+						item.addActionListener(new ActionListener() {
+
+							@Override
+							public void actionPerformed(ActionEvent arg0) {
+								String newTaskString = JOptionPane.showInputDialog("Insert command line");
+								if (newTaskString != null) {
+									setTaskString(newTaskString);
+								}
+							}
+						});
+						menu.add(item);
+
+						menu.show(comp, evt.getX(), evt.getY());
+					}
+				}
+			}
+		});
+
+		JPanel configPanel = new JPanel();
+		configPanel.setLayout(new BorderLayout());
+		configPanel.add(this.configureTaskButton, BorderLayout.WEST);
+		configPanel.add(this.taskDescField, BorderLayout.CENTER);
+		configPanel.add(this.runTaskButton, BorderLayout.EAST);
+		this.taskTableModel = new TaskTableModel();
+		this.taskTable = new JTable(this.taskTableModel);
+		this.taskTable.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
+		DefaultTableCellRenderer centerRenderer = new DefaultTableCellRenderer();
+		centerRenderer.setHorizontalAlignment(SwingConstants.CENTER);
+		TaskColorCodingCellRenderer taskColorCodingRenderer = new TaskColorCodingCellRenderer();
+		this.taskTable.getColumnModel().getColumn(0).setCellRenderer(taskColorCodingRenderer);
+		this.taskTable.getColumnModel().getColumn(2).setCellRenderer(centerRenderer);
+		this.taskTable.getColumnModel().getColumn(3).setCellRenderer(centerRenderer);
+		this.taskTable.getColumnModel().getColumn(5).setCellRenderer(new ProgressCellRenderer());
+
+		// set the color column to the smallest size possible
+		TableColumnModel tableColumnModel = taskTable.getColumnModel();
+		tableColumnModel.getColumn(0).setMaxWidth(tableColumnModel.getColumn(0).getMinWidth());
+		tableColumnModel.getColumn(0).setPreferredWidth(0);
+
+		JPanel controlPanel = new JPanel();
+		controlPanel.add(this.pauseTaskButton);
+		controlPanel.add(this.resumeTaskButton);
+		controlPanel.add(this.cancelTaskButton);
+		controlPanel.add(this.deleteTaskButton);
+		setLayout(new BorderLayout());
+		add(configPanel, BorderLayout.NORTH);
+		add(new JScrollPane(this.taskTable), BorderLayout.CENTER);
+		add(controlPanel, BorderLayout.SOUTH);
+		this.taskTable.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
+
+			@Override
+			public void valueChanged(ListSelectionEvent arg0) {
+				taskSelectionChanged();
+			}
+		});
+		this.configureTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				String newTaskString = ClassOptionSelectionPanel.showSelectClassDialog(ALTaskManagerPanel.this,
+						"Configure task", ALMainTask.class,
+						ALTaskManagerPanel.this.currentTask.getCLICreationString(ALMainTask.class), null);
+
+				setTaskString(newTaskString);
+			}
+		});
+		this.runTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				runTask((ALMainTask) ALTaskManagerPanel.this.currentTask.copy());
+			}
+		});
+		this.pauseTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				pauseSelectedTasks();
+			}
+		});
+		this.resumeTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				resumeSelectedTasks();
+			}
+		});
+		this.cancelTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				cancelSelectedTasks();
+			}
+		});
+		this.deleteTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				deleteSelectedTasks();
+			}
+		});
+
+		javax.swing.Timer updateListTimer = new javax.swing.Timer(MILLISECS_BETWEEN_REFRESH, new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				ALTaskManagerPanel.this.taskTable.repaint();
+			}
+		});
+		updateListTimer.start();
+		setPreferredSize(new Dimension(0, 200));
+	}
+
 	public void setPreviewPanel(ALPreviewPanel previewPanel) {
-        this.previewPanel = previewPanel;
-    }
-
-    public void setTaskString(String cliString) {
-        setTaskString(cliString, true);
-    }
-    
-    public void setTaskString(String cliString, boolean storePreference) {    
-        try {
-            this.currentTask = (ALMainTask) ClassOption.cliStringToObject(
-                    cliString, ALMainTask.class, null);
-            String taskText = this.currentTask.getCLICreationString(ALMainTask.class);
-            
-            this.taskDescField.setText(taskText);
-            if (storePreference == true){
-	            //Save task text as a preference
-	            prefs.put(PREF_NAME, taskText);
-            }
-        } catch (Exception ex) {
-            GUIUtils.showExceptionDialog(this, "Problem with task", ex);
-        }
-    }
-
-    public void runTask(ALMainTask task) {
-
-        task.prepareForUse();
-    	ALTaskThread thread = new ALTaskThread(task);
-        this.taskTableModel.fireTableDataChanged();
-        thread.start();
-        
-        // get the threads for all subtasks
-        List<ALTaskThread> subThreads = ((ALMainTask) thread.getTask()).getSubtaskThreads();
-        // add the subtask threads to the list of available tasks
-
-        this.taskList.add(0, thread);
-        this.taskTable.setRowSelectionInterval(0, 0);
-        
-        for(int i = 0; i < subThreads.size(); ++i)
-        {
-        	this.taskList.add(i+1,subThreads.get(i));
-        }
-
-    }
-
-    public void taskSelectionChanged() {
-        ALTaskThread[] selectedTasks = getSelectedTasks();
-        if (selectedTasks.length == 1) {
-            setTaskString(((OptionHandler) selectedTasks[0].getTask()).getCLICreationString(ALMainTask.class));
-            if (this.previewPanel != null) {
-                this.previewPanel.setTaskThreadToPreview(selectedTasks[0]);
-            }
-        } else {
-            this.previewPanel.setTaskThreadToPreview(null);
-        }
-        
-        if(selectedTasks.length > 0)
-        {
-        	boolean onlyRootTasks = true;
-        	for(int i = 0; i < selectedTasks.length; ++i)
-        	{
-        		onlyRootTasks &= !((ALMainTask)selectedTasks[i].getTask()).isSubtask();
-        	}
-
-        	cancelTaskButton.setEnabled(onlyRootTasks);
-        	deleteTaskButton.setEnabled(onlyRootTasks);
-        }
-    }
-
-    public ALTaskThread[] getSelectedTasks() {
-        int[] selectedRows = this.taskTable.getSelectedRows();
-        ALTaskThread[] selectedTasks = new ALTaskThread[selectedRows.length];
-        for (int i = 0; i < selectedRows.length; i++) {
-            selectedTasks[i] = this.taskList.get(selectedRows[i]);
-        }
-        return selectedTasks;
-    }
-
-    public void pauseSelectedTasks() {
-        ALTaskThread[] selectedTasks = getSelectedTasks();
-        for (ALTaskThread thread : selectedTasks) {
-            thread.pauseTask();
-        }
-    }
-
-    public void resumeSelectedTasks() {
-        ALTaskThread[] selectedTasks = getSelectedTasks();
-        for (ALTaskThread thread : selectedTasks) {
-            thread.resumeTask();
-        }
-    }
-
-    public void cancelSelectedTasks() {
-        ALTaskThread[] selectedTasks = getSelectedTasks();
-        for (ALTaskThread thread : selectedTasks) {
-            thread.cancelTask();
-        }
-    }
-
-    public void deleteSelectedTasks() {
-    	ALTaskThread[] selectedTasks = getSelectedTasks();
-    	
-        for (ALTaskThread thread : selectedTasks) {
-            thread.cancelTask();
-            this.taskList.remove(thread);
-            
-            ALMainTask task =  (ALMainTask)thread.getTask();
-            List<ALTaskThread> subtaskThreads = task.getSubtaskThreads();
-            for (ALTaskThread subthread : subtaskThreads) {
-                this.taskList.remove(subthread);
-            }
-            
-        }
-        this.taskTableModel.fireTableDataChanged();
-    }
-
-    public void copyClipBoardConfiguration() {
-
-        StringSelection selection = new StringSelection(this.taskDescField.getText().trim());
-        Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
-        clipboard.setContents(selection, selection);
-
-    }
-
-    public void saveLogSelectedTasks() {
-        String tasksLog = "";
-        ALTaskThread[] selectedTasks = getSelectedTasks();
-        for (ALTaskThread thread : selectedTasks) {
-        	tasksLog += ((OptionHandler) thread.getTask()).getCLICreationString(ALMainTask.class) + "\n";
-        }
-
-        BaseFileChooser fileChooser = new BaseFileChooser();
-        fileChooser.setAcceptAllFileFilterUsed(true);
-        fileChooser.addChoosableFileFilter(new FileExtensionFilter(
-                exportFileExtension));
-        if (fileChooser.showSaveDialog(this) == BaseFileChooser.APPROVE_OPTION) {
-            File chosenFile = fileChooser.getSelectedFile();
-            String fileName = chosenFile.getPath();
-            if (!chosenFile.exists()
-                    && !fileName.endsWith(exportFileExtension)) {
-                fileName = fileName + "." + exportFileExtension;
-            }
-            try {
-                PrintWriter out = new PrintWriter(new BufferedWriter(
-                        new FileWriter(fileName)));
-                out.write(tasksLog);
-                out.close();
-            } catch (IOException ioe) {
-                GUIUtils.showExceptionDialog(
-                        this,
-                        "Problem saving file " + fileName, ioe);
-            }
-        }
-    }
+		this.previewPanel = previewPanel;
+	}
+
+	public void setTaskString(String cliString) {
+		setTaskString(cliString, true);
+	}
+
+	public void setTaskString(String cliString, boolean storePreference) {
+		try {
+			this.currentTask = (ALMainTask) ClassOption.cliStringToObject(cliString, ALMainTask.class, null);
+			String taskText = this.currentTask.getCLICreationString(ALMainTask.class);
+
+			this.taskDescField.setText(taskText);
+			if (storePreference == true) {
+				// Save task text as a preference
+				prefs.put(PREF_NAME, taskText);
+			}
+		} catch (Exception ex) {
+			GUIUtils.showExceptionDialog(this, "Problem with task", ex);
+		}
+	}
+
+	public void runTask(ALMainTask task) {
+
+		task.prepareForUse();
+		ALTaskThread thread = new ALTaskThread(task);
+		this.taskTableModel.fireTableDataChanged();
+		thread.start();
+
+		// get the threads for all subtasks
+		List<ALTaskThread> subThreads = ((ALMainTask) thread.getTask()).getSubtaskThreads();
+		// add the subtask threads to the list of available tasks
+
+		this.taskList.add(0, thread);
+		this.taskTable.setRowSelectionInterval(0, 0);
+
+		for (int i = 0; i < subThreads.size(); ++i) {
+			this.taskList.add(i + 1, subThreads.get(i));
+		}
+
+	}
+
+	public void taskSelectionChanged() {
+		ALTaskThread[] selectedTasks = getSelectedTasks();
+		if (selectedTasks.length == 1) {
+			setTaskString(((OptionHandler) selectedTasks[0].getTask()).getCLICreationString(ALMainTask.class));
+			if (this.previewPanel != null) {
+				this.previewPanel.setTaskThreadToPreview(selectedTasks[0]);
+			}
+		} else {
+			this.previewPanel.setTaskThreadToPreview(null);
+		}
+
+		if (selectedTasks.length > 0) {
+			boolean onlyRootTasks = true;
+			for (int i = 0; i < selectedTasks.length; ++i) {
+				onlyRootTasks &= !((ALMainTask) selectedTasks[i].getTask()).isSubtask();
+			}
+
+			cancelTaskButton.setEnabled(onlyRootTasks);
+			deleteTaskButton.setEnabled(onlyRootTasks);
+		}
+	}
+
+	public ALTaskThread[] getSelectedTasks() {
+		int[] selectedRows = this.taskTable.getSelectedRows();
+		ALTaskThread[] selectedTasks = new ALTaskThread[selectedRows.length];
+		for (int i = 0; i < selectedRows.length; i++) {
+			selectedTasks[i] = this.taskList.get(selectedRows[i]);
+		}
+		return selectedTasks;
+	}
+
+	public void pauseSelectedTasks() {
+		ALTaskThread[] selectedTasks = getSelectedTasks();
+		for (ALTaskThread thread : selectedTasks) {
+			thread.pauseTask();
+		}
+	}
+
+	public void resumeSelectedTasks() {
+		ALTaskThread[] selectedTasks = getSelectedTasks();
+		for (ALTaskThread thread : selectedTasks) {
+			thread.resumeTask();
+		}
+	}
+
+	public void cancelSelectedTasks() {
+		ALTaskThread[] selectedTasks = getSelectedTasks();
+		for (ALTaskThread thread : selectedTasks) {
+			thread.cancelTask();
+		}
+	}
+
+	public void deleteSelectedTasks() {
+		ALTaskThread[] selectedTasks = getSelectedTasks();
+
+		for (ALTaskThread thread : selectedTasks) {
+			thread.cancelTask();
+			this.taskList.remove(thread);
+
+			ALMainTask task = (ALMainTask) thread.getTask();
+			List<ALTaskThread> subtaskThreads = task.getSubtaskThreads();
+			for (ALTaskThread subthread : subtaskThreads) {
+				this.taskList.remove(subthread);
+			}
+
+		}
+		this.taskTableModel.fireTableDataChanged();
+	}
+
+	public void copyClipBoardConfiguration() {
+
+		StringSelection selection = new StringSelection(this.taskDescField.getText().trim());
+		Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
+		clipboard.setContents(selection, selection);
+
+	}
+
+	public void saveLogSelectedTasks() {
+		String tasksLog = "";
+		ALTaskThread[] selectedTasks = getSelectedTasks();
+		for (ALTaskThread thread : selectedTasks) {
+			tasksLog += ((OptionHandler) thread.getTask()).getCLICreationString(ALMainTask.class) + "\n";
+		}
+
+		BaseFileChooser fileChooser = new BaseFileChooser();
+		fileChooser.setAcceptAllFileFilterUsed(true);
+		fileChooser.addChoosableFileFilter(new FileExtensionFilter(exportFileExtension));
+		if (fileChooser.showSaveDialog(this) == JFileChooser.APPROVE_OPTION) {
+			File chosenFile = fileChooser.getSelectedFile();
+			String fileName = chosenFile.getPath();
+			if (!chosenFile.exists() && !fileName.endsWith(exportFileExtension)) {
+				fileName = fileName + "." + exportFileExtension;
+			}
+			try {
+				PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(fileName)));
+				out.write(tasksLog);
+				out.close();
+			} catch (IOException ioe) {
+				GUIUtils.showExceptionDialog(this, "Problem saving file " + fileName, ioe);
+			}
+		}
+	}
 }
diff --git a/moa/src/main/java/moa/gui/active/ALTaskTextViewerPanel.java b/moa/src/main/java/moa/gui/active/ALTaskTextViewerPanel.java
index 9e0d117ff..5cccc91a9 100644
--- a/moa/src/main/java/moa/gui/active/ALTaskTextViewerPanel.java
+++ b/moa/src/main/java/moa/gui/active/ALTaskTextViewerPanel.java
@@ -18,7 +18,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.active;
 
@@ -45,6 +45,7 @@
 import javax.swing.BorderFactory;
 import javax.swing.GroupLayout;
 import javax.swing.JButton;
+import javax.swing.JFileChooser;
 import javax.swing.JLabel;
 import javax.swing.JPanel;
 import javax.swing.JScrollPane;
@@ -52,6 +53,7 @@
 import javax.swing.JTabbedPane;
 import javax.swing.JTable;
 import javax.swing.JTextArea;
+import javax.swing.ScrollPaneConstants;
 import javax.swing.SwingConstants;
 import javax.swing.SwingUtilities;
 import javax.swing.table.TableCellRenderer;
@@ -161,27 +163,23 @@ public ALTaskTextViewerPanel() {
 		this.topWrapper = new JPanel();
 		this.topWrapper.setLayout(new BorderLayout());
 
-		// previewTable displays live results in table form 
+		// previewTable displays live results in table form
 		// (or in text form, if an error occurs)
 		this.previewTableModel = new PreviewTableModel();
 		this.previewTable = new JTable(this.previewTableModel);
 		this.previewTable.setFont(new Font("Monospaced", Font.PLAIN, 12));
 		this.previewTable.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
 
-        this.errorTextField = new JTextArea();
-        this.errorTextField.setEditable(false);
-        this.errorTextField.setFont(new Font("Monospaced", Font.PLAIN, 12));
+		this.errorTextField = new JTextArea();
+		this.errorTextField.setEditable(false);
+		this.errorTextField.setFont(new Font("Monospaced", Font.PLAIN, 12));
 
 		// scrollPane enables scroll support for previewTable
-		this.scrollPaneTable = new JScrollPane(this.previewTable, 
-				JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
-				JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED
-		);
-		this.scrollPaneText = new JScrollPane(this.errorTextField, 
-				JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
-				JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED
-		);
-        this.scrollPaneText.setVisible(false);
+		this.scrollPaneTable = new JScrollPane(this.previewTable, ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED,
+				ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED);
+		this.scrollPaneText = new JScrollPane(this.errorTextField, ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED,
+				ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED);
+		this.scrollPaneText.setVisible(false);
 
 		this.topWrapper.add(this.scrollPaneTable, BorderLayout.CENTER);
 
@@ -195,11 +193,12 @@ public ALTaskTextViewerPanel() {
 
 		this.exportButton.addActionListener(new ActionListener() {
 
+			@Override
 			public void actionPerformed(ActionEvent e) {
 				BaseFileChooser fileChooser = new BaseFileChooser();
 				fileChooser.setAcceptAllFileFilterUsed(true);
 				fileChooser.addChoosableFileFilter(new FileExtensionFilter(EXPORT_FILE_EXTENSION));
-				if (fileChooser.showSaveDialog(ALTaskTextViewerPanel.this) == BaseFileChooser.APPROVE_OPTION) {
+				if (fileChooser.showSaveDialog(ALTaskTextViewerPanel.this) == JFileChooser.APPROVE_OPTION) {
 					File chosenFile = fileChooser.getSelectedFile();
 					String fileName = chosenFile.getPath();
 					if (!chosenFile.exists() && !fileName.endsWith(EXPORT_FILE_EXTENSION)) {
@@ -210,12 +209,9 @@ public void actionPerformed(ActionEvent e) {
 
 						String text = "";
 
-						if(scrollPaneTable.isVisible())
-						{
+						if (scrollPaneTable.isVisible()) {
 							text = previewTableModel.toString();
-						}
-						else
-						{
+						} else {
 							text = errorTextField.getText();
 						}
 
@@ -235,30 +231,33 @@ public void actionPerformed(ActionEvent e) {
 
 		this.mainPane.setTopComponent(this.topWrapper);
 
-		// panelEvalOutput contains the bottom component of the mainPane. It consists of a left
-		// area showing several performance measures and an area on the right side with a live
+		// panelEvalOutput contains the bottom component of the mainPane. It consists of
+		// a left
+		// area showing several performance measures and an area on the right side with
+		// a live
 		// performance graph
 		this.panelEvalOutput = new JPanel();
 		this.panelEvalOutput.setLayout(new GridBagLayout());
 		this.panelEvalOutput.setBorder(BorderFactory.createTitledBorder("Evaluation"));
 
-		// init the measure overview. the dummy ALMeasureCollection[] is needed to properly init the measure names
-		this.measureOverview = new MeasureOverview(new ALMeasureCollection[]{new ALMeasureCollection()}, "", null);
-        this.measureOverview.setMinimumSize(new Dimension(280, 118));
-        this.measureOverview.setPreferredSize(new Dimension(290, 115));
-        this.measureOverview.setActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                int selected = Integer.parseInt(e.getActionCommand());
-                graphCanvas.setMeasureSelected(selected);
-                graphCanvas.updateCanvas(true);
-                paramGraphCanvas.setMeasureSelected(selected);
-                paramGraphCanvas.updateCanvas(true);
-                budgetGraphCanvas.setMeasureSelected(selected);
-                budgetGraphCanvas.updateCanvas(true);
-            }
-        });
+		// init the measure overview. the dummy ALMeasureCollection[] is needed to
+		// properly init the measure names
+		this.measureOverview = new MeasureOverview(new ALMeasureCollection[] { new ALMeasureCollection() }, "", null);
+		this.measureOverview.setMinimumSize(new Dimension(280, 118));
+		this.measureOverview.setPreferredSize(new Dimension(290, 115));
+		this.measureOverview.setActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				int selected = Integer.parseInt(e.getActionCommand());
+				graphCanvas.setMeasureSelected(selected);
+				graphCanvas.updateCanvas(true);
+				paramGraphCanvas.setMeasureSelected(selected);
+				paramGraphCanvas.updateCanvas(true);
+				budgetGraphCanvas.setMeasureSelected(selected);
+				budgetGraphCanvas.updateCanvas(true);
+			}
+		});
 
 		gridBagConstraints = new GridBagConstraints();
 		gridBagConstraints.gridx = 0;
@@ -269,31 +268,37 @@ public void actionPerformed(ActionEvent e) {
 
 		panelEvalOutput.add(measureOverview, gridBagConstraints);
 
-		// graphPanel is the right area of panelEvalOutput, showing a live preview of the
+		// graphPanel is the right area of panelEvalOutput, showing a live preview of
+		// the
 		// performance
 		graphPanel = new JPanel();
 		graphPanel.setLayout(new GridBagLayout());
 		graphPanel.setBorder(BorderFactory.createTitledBorder("Plot"));
 		graphPanel.setPreferredSize(new Dimension(530, 115));
 
-		// graphPanelControlLeft contains two buttons allowing to zoom the y-axis in and out
+		// graphPanelControlLeft contains two buttons allowing to zoom the y-axis in and
+		// out
 		graphPanelControlLeft = new JPanel();
 		graphPanelControlLeft.setLayout(new GridBagLayout());
 
 		buttonZoomInY = new JButton();
 		buttonZoomInY.setText("Zoom in Y");
 		buttonZoomInY.addActionListener(new ActionListener() {
+			@Override
 			public void actionPerformed(ActionEvent evt) {
 				// update the currently open graph
-                int currentTab = graphPanelTabbedPane.getSelectedIndex();
-                switch (currentTab){
-                    case 0: graphCanvas.scaleYResolution(2); 
-                            break;
-                    case 1: paramGraphCanvas.scaleYResolution(2); 
-                            break;
-                    case 2: budgetGraphCanvas.scaleYResolution(2);
-                            break;
-                }
+				int currentTab = graphPanelTabbedPane.getSelectedIndex();
+				switch (currentTab) {
+				case 0:
+					graphCanvas.scaleYResolution(2);
+					break;
+				case 1:
+					paramGraphCanvas.scaleYResolution(2);
+					break;
+				case 2:
+					budgetGraphCanvas.scaleYResolution(2);
+					break;
+				}
 			}
 		});
 
@@ -304,17 +309,21 @@ public void actionPerformed(ActionEvent evt) {
 		buttonZoomOutY = new JButton();
 		buttonZoomOutY.setText("Zoom out Y");
 		buttonZoomOutY.addActionListener(new ActionListener() {
+			@Override
 			public void actionPerformed(ActionEvent evt) {
 				// update the currently open graph
 				int currentTab = graphPanelTabbedPane.getSelectedIndex();
-                switch (currentTab){
-                    case 0: graphCanvas.scaleYResolution(0.5); 
-                            break;
-                    case 1: paramGraphCanvas.scaleYResolution(0.5); 
-                            break;
-                    case 2: budgetGraphCanvas.scaleYResolution(0.5);
-                            break;
-                }
+				switch (currentTab) {
+				case 0:
+					graphCanvas.scaleYResolution(0.5);
+					break;
+				case 1:
+					paramGraphCanvas.scaleYResolution(0.5);
+					break;
+				case 2:
+					budgetGraphCanvas.scaleYResolution(0.5);
+					break;
+				}
 			}
 		});
 
@@ -352,10 +361,10 @@ public void actionPerformed(ActionEvent evt) {
 
 		GroupLayout graphCanvasLayout = new GroupLayout(graphCanvas);
 		graphCanvas.setLayout(graphCanvasLayout);
-		graphCanvasLayout.setHorizontalGroup(graphCanvasLayout
-				.createParallelGroup(GroupLayout.Alignment.LEADING).addGap(0, 515, Short.MAX_VALUE));
-		graphCanvasLayout.setVerticalGroup(graphCanvasLayout
-				.createParallelGroup(GroupLayout.Alignment.LEADING).addGap(0, 128, Short.MAX_VALUE));
+		graphCanvasLayout.setHorizontalGroup(
+				graphCanvasLayout.createParallelGroup(GroupLayout.Alignment.LEADING).addGap(0, 515, Short.MAX_VALUE));
+		graphCanvasLayout.setVerticalGroup(
+				graphCanvasLayout.createParallelGroup(GroupLayout.Alignment.LEADING).addGap(0, 128, Short.MAX_VALUE));
 
 		graphScrollPanel.setViewportView(graphCanvas);
 		graphPanelTabbedPane.addTab("Processed Instances", graphScrollPanel);
@@ -379,22 +388,22 @@ public void actionPerformed(ActionEvent evt) {
 		graphPanelTabbedPane.addTab("Varied Parameter", paramGraphScrollPanel);
 
 		// budgetGraphScrollPanel is a scroll wrapper for the live budget graph
-        budgetGraphScrollPanel = new JScrollPane();
+		budgetGraphScrollPanel = new JScrollPane();
 
 		// budgetGraphCanvas displays the live actually used budget graph
 		budgetGraphCanvas = new ParamGraphCanvas();
 		budgetGraphCanvas.setPreferredSize(new Dimension(500, 111));
-        budgetGraphCanvas.setGraph(null, null, null, null);
+		budgetGraphCanvas.setGraph(null, null, null, null);
 
-        GroupLayout budgetGraphCanvasLayout = new GroupLayout(budgetGraphCanvas);
-        budgetGraphCanvas.setLayout(budgetGraphCanvasLayout);
-        budgetGraphCanvasLayout.setHorizontalGroup(budgetGraphCanvasLayout
-                .createParallelGroup(GroupLayout.Alignment.LEADING).addGap(0, 515, Short.MAX_VALUE));
-        budgetGraphCanvasLayout.setVerticalGroup(budgetGraphCanvasLayout
-                .createParallelGroup(GroupLayout.Alignment.LEADING).addGap(0, 128, Short.MAX_VALUE));
+		GroupLayout budgetGraphCanvasLayout = new GroupLayout(budgetGraphCanvas);
+		budgetGraphCanvas.setLayout(budgetGraphCanvasLayout);
+		budgetGraphCanvasLayout.setHorizontalGroup(budgetGraphCanvasLayout
+				.createParallelGroup(GroupLayout.Alignment.LEADING).addGap(0, 515, Short.MAX_VALUE));
+		budgetGraphCanvasLayout.setVerticalGroup(budgetGraphCanvasLayout
+				.createParallelGroup(GroupLayout.Alignment.LEADING).addGap(0, 128, Short.MAX_VALUE));
 
-        budgetGraphScrollPanel.setViewportView(budgetGraphCanvas);
-        graphPanelTabbedPane.addTab("Label Acq. Rate", budgetGraphScrollPanel);
+		budgetGraphScrollPanel.setViewportView(budgetGraphCanvas);
+		graphPanelTabbedPane.addTab("Label Acq. Rate", budgetGraphScrollPanel);
 
 		gridBagConstraints = new GridBagConstraints();
 		gridBagConstraints.gridx = 0;
@@ -406,24 +415,28 @@ public void actionPerformed(ActionEvent evt) {
 		gridBagConstraints.insets = new Insets(2, 2, 2, 2);
 		graphPanel.add(graphPanelTabbedPane, gridBagConstraints);
 
-
-		// graphPanelControlRight contains two buttons allowing to zoom the x-axis in and out
+		// graphPanelControlRight contains two buttons allowing to zoom the x-axis in
+		// and out
 		graphPanelControlRight = new JPanel();
 
 		buttonZoomInX = new JButton();
 		buttonZoomInX.setText("Zoom in X");
 		buttonZoomInX.addActionListener(new ActionListener() {
+			@Override
 			public void actionPerformed(ActionEvent evt) {
 				// update the currently open graph
 				int currentTab = graphPanelTabbedPane.getSelectedIndex();
-                switch (currentTab){
-                    case 0: graphCanvas.scaleXResolution(2); 
-                            break;
-                    case 1: paramGraphCanvas.scaleXResolution(2); 
-                            break;
-                    case 2: budgetGraphCanvas.scaleXResolution(2);
-                            break;
-                }
+				switch (currentTab) {
+				case 0:
+					graphCanvas.scaleXResolution(2);
+					break;
+				case 1:
+					paramGraphCanvas.scaleXResolution(2);
+					break;
+				case 2:
+					budgetGraphCanvas.scaleXResolution(2);
+					break;
+				}
 			}
 		});
 		graphPanelControlRight.add(buttonZoomInX);
@@ -431,17 +444,21 @@ public void actionPerformed(ActionEvent evt) {
 		buttonZoomOutX = new JButton();
 		buttonZoomOutX.setText("Zoom out X");
 		buttonZoomOutX.addActionListener(new ActionListener() {
+			@Override
 			public void actionPerformed(ActionEvent evt) {
 				// update the currently open graph
 				int currentTab = graphPanelTabbedPane.getSelectedIndex();
-                switch (currentTab){
-                    case 0: graphCanvas.scaleXResolution(0.5); 
-                            break;
-                    case 1: paramGraphCanvas.scaleXResolution(0.5); 
-                            break;
-                    case 2: budgetGraphCanvas.scaleXResolution(0.5);
-                            break;
-                }
+				switch (currentTab) {
+				case 0:
+					graphCanvas.scaleXResolution(0.5);
+					break;
+				case 1:
+					paramGraphCanvas.scaleXResolution(0.5);
+					break;
+				case 2:
+					budgetGraphCanvas.scaleXResolution(0.5);
+					break;
+				}
 			}
 		});
 		graphPanelControlRight.add(buttonZoomOutX);
@@ -471,38 +488,35 @@ public void actionPerformed(ActionEvent evt) {
 
 	/**
 	 * Updates the preview table based on the information given by preview.
+	 * 
 	 * @param preview the new information used to update the table
 	 */
 	public void setText(Preview preview) {
 		Point p = this.scrollPaneTable.getViewport().getViewPosition();
 
 		previewTableModel.setPreview(preview);
-		SwingUtilities.invokeLater(
-			new Runnable(){
-				boolean structureChanged = previewTableModel.structureChanged();
-				public void run(){
-					if(!scrollPaneTable.isVisible())
-					{
-						topWrapper.remove(scrollPaneText);
-						scrollPaneText.setVisible(false);
-						topWrapper.add(scrollPaneTable, BorderLayout.CENTER);
-						scrollPaneTable.setVisible(true);
-						topWrapper.validate();
-					}
+		SwingUtilities.invokeLater(new Runnable() {
+			boolean structureChanged = previewTableModel.structureChanged();
+
+			@Override
+			public void run() {
+				if (!scrollPaneTable.isVisible()) {
+					topWrapper.remove(scrollPaneText);
+					scrollPaneText.setVisible(false);
+					topWrapper.add(scrollPaneTable, BorderLayout.CENTER);
+					scrollPaneTable.setVisible(true);
+					topWrapper.validate();
+				}
 
-					if(structureChanged)
-					{
-						previewTableModel.fireTableStructureChanged();
-						rescaleTableColumns();
-					}
-					else
-					{
-						previewTableModel.fireTableDataChanged();
-					}
-					previewTable.repaint();
+				if (structureChanged) {
+					previewTableModel.fireTableStructureChanged();
+					rescaleTableColumns();
+				} else {
+					previewTableModel.fireTableDataChanged();
 				}
+				previewTable.repaint();
 			}
-		);
+		});
 
 		this.scrollPaneTable.getViewport().setViewPosition(p);
 		this.exportButton.setEnabled(preview != null);
@@ -510,53 +524,51 @@ public void run(){
 
 	/**
 	 * Displays the error message.
+	 * 
 	 * @param failedTaskReport error message
 	 */
 	public void setErrorText(FailedTaskReport failedTaskReport) {
 		Point p = this.scrollPaneText.getViewport().getViewPosition();
-		
-		final String failedTaskReportString = failedTaskReport == null ? 
-				"Failed Task Report is null" : failedTaskReport.toString();
-
-		SwingUtilities.invokeLater(
-			new Runnable(){
-				public void run(){
-					if(!scrollPaneText.isVisible())
-					{
-						topWrapper.remove(scrollPaneTable);
-						scrollPaneTable.setVisible(false);
-						topWrapper.add(scrollPaneText, BorderLayout.CENTER);
-						scrollPaneText.setVisible(true);
-						topWrapper.validate();
-					}
-					errorTextField.setText(failedTaskReportString);
-					errorTextField.repaint();
+
+		final String failedTaskReportString = failedTaskReport == null ? "Failed Task Report is null"
+				: failedTaskReport.toString();
+
+		SwingUtilities.invokeLater(new Runnable() {
+			@Override
+			public void run() {
+				if (!scrollPaneText.isVisible()) {
+					topWrapper.remove(scrollPaneTable);
+					scrollPaneTable.setVisible(false);
+					topWrapper.add(scrollPaneText, BorderLayout.CENTER);
+					scrollPaneText.setVisible(true);
+					topWrapper.validate();
 				}
+				errorTextField.setText(failedTaskReportString);
+				errorTextField.repaint();
 			}
-		);
+		});
 
 		this.scrollPaneText.getViewport().setViewPosition(p);
 		this.exportButton.setEnabled(failedTaskReport != null);
 	}
 
-	private void rescaleTableColumns()
-	{
+	private void rescaleTableColumns() {
 		// iterate over all columns to resize them individually
 		TableColumnModel columnModel = previewTable.getColumnModel();
-		for(int columnIdx = 0; columnIdx < columnModel.getColumnCount(); ++columnIdx)
-		{
+		for (int columnIdx = 0; columnIdx < columnModel.getColumnCount(); ++columnIdx) {
 			// get the current column
 			TableColumn column = columnModel.getColumn(columnIdx);
-			// get the renderer for the column header to calculate the preferred with for the header
+			// get the renderer for the column header to calculate the preferred with for
+			// the header
 			TableCellRenderer renderer = column.getHeaderRenderer();
 			// check if the renderer is null
-			if(renderer == null)
-			{
+			if (renderer == null) {
 				// if it is null use the default renderer for header
 				renderer = previewTable.getTableHeader().getDefaultRenderer();
 			}
 			// create a cell to calculate its preferred size
-			Component comp = renderer.getTableCellRendererComponent(previewTable, column.getHeaderValue(), false, false, 0, columnIdx);
+			Component comp = renderer.getTableCellRendererComponent(previewTable, column.getHeaderValue(), false, false,
+					0, columnIdx);
 			int width = comp.getPreferredSize().width;
 			// set the maximum width which was calculated
 			column.setPreferredWidth(width);
@@ -565,14 +577,15 @@ private void rescaleTableColumns()
 
 	/**
 	 * Updates the graph based on the information given by the preview.
+	 * 
 	 * @param preview information used to update the graph
-	 * @param colors color coding used to connect the tasks with the graphs
+	 * @param colors  color coding used to connect the tasks with the graphs
 	 */
 	@SuppressWarnings("unchecked")
 	public void setGraph(Preview preview, Color[] colors) {
 		if (preview == null) {
 			// no preview received
-		    this.measureOverview.update(null, "", null);
+			this.measureOverview.update(null, "", null);
 			this.graphCanvas.setGraph(null, null, null, 1000, null);
 			this.paramGraphCanvas.setGraph(null, null, null, null);
 			this.budgetGraphCanvas.setGraph(null, null, null, null);
@@ -588,9 +601,9 @@ public void setGraph(Preview preview, Color[] colors) {
 			// PreviewCollection
 			PreviewCollection<Preview> pc = (PreviewCollection<Preview>) preview;
 
-	         // get varied parameter name and values
+			// get varied parameter name and values
 			this.variedParamName = pc.getVariedParamName();
-            this.variedParamValues = pc.getVariedParamValues();
+			this.variedParamValues = pc.getVariedParamValues();
 
 			if (c == ALPartitionEvaluationTask.class) {
 				// calculate mean preview collection for each parameter value
@@ -604,42 +617,42 @@ public void setGraph(Preview preview, Color[] colors) {
 			} else {
 				pp = readCollection(pc);
 				ppStd = null;
-			    this.graphCanvas.setStandardDeviationPainted(false);
-			    this.paramGraphCanvas.setStandardDeviationPainted(false);
+				this.graphCanvas.setStandardDeviationPainted(false);
+				this.paramGraphCanvas.setStandardDeviationPainted(false);
 			}
 
 			// enable param and budget graph
 			this.graphPanelTabbedPane.setEnabledAt(1, true);
-            this.graphPanelTabbedPane.setEnabledAt(2, true);
+			this.graphPanelTabbedPane.setEnabledAt(2, true);
 
-    	} else if (c == ALPrequentialEvaluationTask.class) {
-    		// read Preview (in this case, no special preview is required)
-    		pp = read(preview);
-    		ppStd = null;
+		} else if (c == ALPrequentialEvaluationTask.class) {
+			// read Preview (in this case, no special preview is required)
+			pp = read(preview);
+			ppStd = null;
 
-    		// reset varied param name and values
-    		this.variedParamName = "";
-    		this.variedParamValues = null;
+			// reset varied param name and values
+			this.variedParamName = "";
+			this.variedParamValues = null;
 
-   			// switch to Processed Instances tab
-    		this.graphPanelTabbedPane.setSelectedIndex(0);
+			// switch to Processed Instances tab
+			this.graphPanelTabbedPane.setSelectedIndex(0);
 
 			// disable param and budget view
 			this.graphPanelTabbedPane.setEnabledAt(1, false);
-            this.graphPanelTabbedPane.setEnabledAt(2, false);
-
-            // disable painting standard deviation
-    		this.graphCanvas.setStandardDeviationPainted(false);
-            this.paramGraphCanvas.setStandardDeviationPainted(false);
-
-    	} else {
-    		// sth went wrong
-    	    this.measureOverview.update(null, "", null);
-    		this.graphCanvas.setGraph(null, null, null, 1000, null);
-    		this.paramGraphCanvas.setGraph(null, null, null, null);
-    		this.budgetGraphCanvas.setGraph(null, null, null, null);
+			this.graphPanelTabbedPane.setEnabledAt(2, false);
+
+			// disable painting standard deviation
+			this.graphCanvas.setStandardDeviationPainted(false);
+			this.paramGraphCanvas.setStandardDeviationPainted(false);
+
+		} else {
+			// sth went wrong
+			this.measureOverview.update(null, "", null);
+			this.graphCanvas.setGraph(null, null, null, 1000, null);
+			this.paramGraphCanvas.setGraph(null, null, null, null);
+			this.budgetGraphCanvas.setGraph(null, null, null, null);
 			return;
-    	}
+		}
 
 		MeasureCollection[] measures = pp.getMeasureCollectionsArray();
 		MeasureCollection[] measuresStd = null;
@@ -678,28 +691,29 @@ private static int min(int[] l) {
 	}
 
 	/**
-	 * Parses a PreviewCollection and return the resulting 
-	 * ParsedPreview object. If the PreviewCollection contains
-	 * PreviewCollections again, it recursively adds their results. If it
-	 * contains simple Previews, it adds their properties to the result.
+	 * Parses a PreviewCollection and return the resulting ParsedPreview object. If
+	 * the PreviewCollection contains PreviewCollections again, it recursively adds
+	 * their results. If it contains simple Previews, it adds their properties to
+	 * the result.
+	 * 
 	 * @param pc PreviewCollection
 	 * @return relevant information contained in the PreviewCollection
 	 */
-	public ParsedPreview readCollection(PreviewCollection<Preview> pc) {	
+	public ParsedPreview readCollection(PreviewCollection<Preview> pc) {
 		ParsedPreview pp = new ParsedPreview();
 		List<Preview> sps = pc.getPreviews();
 
 		if (sps.size() > 0 && sps.get(0) instanceof PreviewCollection) {
 			// members are PreviewCollections again
 			// NOTE: this assumes that all elements in sps are of the same type
-			for (Preview sp: sps) {
+			for (Preview sp : sps) {
 				@SuppressWarnings("unchecked")
 				ParsedPreview tmp = readCollection((PreviewCollection<Preview>) sp);
 				pp.add(tmp);
 			}
 		} else {
 			// members are simple previews
-			for (Preview sp: sps) {
+			for (Preview sp : sps) {
 				ParsedPreview tmp = read(sp);
 				pp.add(tmp);
 			}
@@ -709,8 +723,9 @@ public ParsedPreview readCollection(PreviewCollection<Preview> pc) {
 	}
 
 	/**
-	 * ParsedPreview represents the parsing results of a preview,
-	 * namely the process frequencies and the measure collections.
+	 * ParsedPreview represents the parsing results of a preview, namely the process
+	 * frequencies and the measure collections.
+	 * 
 	 * @author Tim Sabsch (tim.sabsch@ovgu.de)
 	 * @version $Revision: 1 $
 	 */
@@ -719,8 +734,8 @@ private class ParsedPreview {
 		private List<MeasureCollection> measureCollections;
 
 		public ParsedPreview() {
-			this.processFrequencies = new ArrayList<Integer>();
-			this.measureCollections = new ArrayList<MeasureCollection>();
+			this.processFrequencies = new ArrayList<>();
+			this.measureCollections = new ArrayList<>();
 		}
 
 		public void add(ParsedPreview other) {
@@ -749,11 +764,12 @@ public int[] getProcessFrequenciesArray() {
 			int[] processFrequenciesArray = new int[this.processFrequencies.size()];
 			int i = 0;
 			for (Integer freq : this.processFrequencies) {
-				processFrequenciesArray[i] = freq.intValue();
+				processFrequenciesArray[i] = freq;
 				++i;
 			}
 			return processFrequenciesArray;
 		}
+
 		public MeasureCollection[] getMeasureCollectionsArray() {
 			return this.measureCollections.toArray(new MeasureCollection[this.measureCollections.size()]);
 		}
@@ -762,6 +778,7 @@ public MeasureCollection[] getMeasureCollectionsArray() {
 	/**
 	 * Parses a preview with respect to the process frequency and several
 	 * measurements.
+	 * 
 	 * @param preview
 	 */
 	private ParsedPreview read(Preview p) {
@@ -787,7 +804,7 @@ private ParsedPreview read(Preview p) {
 			case "classifications correct (percent)":
 			case "[avg] classifications correct (percent)":
 			case "[std] classifications correct (percent)":
-				accuracyColumn = i; 
+				accuracyColumn = i;
 				break;
 			case "Kappa Statistic (percent)":
 			case "[avg] Kappa Statistic (percent)":
@@ -827,7 +844,7 @@ private ParsedPreview read(Preview p) {
 
 		// set entries
 		// TODO: obviously this should be changed into a dict
-		for (double[] entry: data) {
+		for (double[] entry : data) {
 			m.addValue(0, entry[accuracyColumn]);
 			m.addValue(1, entry[kappaColumn]);
 			m.addValue(2, entry[kappaTempColumn]);
@@ -835,7 +852,7 @@ private ParsedPreview read(Preview p) {
 			m.addValue(4, entry[timeColumn]);
 			m.addValue(5, entry[memoryColumn] / (1024 * 1024));
 			m.addValue(6, entry[budgetColumn]);
-    	}
+		}
 
 		// determine process frequency
 		int processFrequency = (int) data.get(0)[processFrequencyColumn];
diff --git a/moa/src/main/java/moa/gui/active/MeasureOverview.java b/moa/src/main/java/moa/gui/active/MeasureOverview.java
index 7289a800b..24fc3d045 100644
--- a/moa/src/main/java/moa/gui/active/MeasureOverview.java
+++ b/moa/src/main/java/moa/gui/active/MeasureOverview.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.active;
 
@@ -42,248 +42,250 @@
 import moa.gui.clustertab.ClusteringVisualEvalPanel;
 
 /**
- * MeasureOverview provides a graphical overview of the current and mean
- * measure values during the runtime of a task.
+ * MeasureOverview provides a graphical overview of the current and mean measure
+ * values during the runtime of a task.
+ *
+ * This class is partially based on
+ * moa.gui.clustertab.ClusteringVisualEvalPanel.
  * 
- * This class is partially based on moa.gui.clustertab.ClusteringVisualEvalPanel.
  * @author Tim Sabsch (tim.sabsch@ovgu.de)
  * @version $Revision: 1 $
  * @see ClusteringVisualEvalPanel
  */
 public class MeasureOverview extends JPanel {
 
-    private static final long serialVersionUID = 1L;
-    
-    private MeasureCollection[] measures;
-    private int measureCollectionSelected;
-    
-    private String variedParamName;
-    private double[] variedParamValues;
-    
-    private JPanel contentPanel;
-    private JScrollPane scrollPane;
-    
-    private ButtonGroup radioGroup;
-    private JRadioButton[] radioButtons;
-    private JLabel[] currentValues;
-    private JLabel[] meanValues;
-    
-    private JLabel labelMeasure;
-    private JLabel labelCurrent;
-    private JLabel labelMean;
-    
-    private JComboBox<String> paramBox;
-
-    /**
-     * Creates a new MeasureOverview.
-     * @param measures MeasureCollection array
-     * @param variedParamName name of the varied parameter
-     * @param variedParamValues values of the varied parameter
-     */
-    public MeasureOverview(MeasureCollection[] measures, String variedParamName, double[] variedParamValues) {
-        // set basic parameters
-        setBorder(BorderFactory.createTitledBorder("Values"));
-        setPreferredSize(new Dimension(250, 115));
-        setLayout(new BoxLayout(this, BoxLayout.PAGE_AXIS));
-        
-        // init scroll pane
-        scrollPane = new JScrollPane();
-        scrollPane.setViewportBorder(BorderFactory.createEmptyBorder());
-        scrollPane.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
-        scrollPane.setPreferredSize(new Dimension(270, 180));
-        
-        // init content of the scroll pane
-        contentPanel = new JPanel();
-        contentPanel.setPreferredSize(new Dimension(100, 105));
-        contentPanel.setLayout(new GridBagLayout());
-        scrollPane.setViewportView(contentPanel);
-        
-        // init param combo box
-        paramBox = new JComboBox<String>();
-        // prevent height rescaling
-        paramBox.setMaximumSize(new Dimension(paramBox.getMaximumSize().width, paramBox.getPreferredSize().height));
-        paramBox.setEnabled(false);
-        paramBox.addActionListener(new ActionListener() {
-            
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                @SuppressWarnings("unchecked")
-                JComboBox<String> cb = (JComboBox<String>) e.getSource();
-                measureCollectionSelected = cb.getSelectedIndex();
-                // if the cb got disabled, set idx to 0
-                if (measureCollectionSelected == -1) {
-                    measureCollectionSelected = 0;
-                }
-                update();
-            }
-        });
-
-        add(scrollPane);
-        add(paramBox);
-        
-        // add labels
-        labelMeasure = new JLabel("Measure");
-        labelCurrent = new JLabel("Current");
-        labelMean    = new JLabel("Mean");
-
-        GridBagConstraints gb = new GridBagConstraints();
-        gb.gridx = 0;
-        gb.gridy = 0;
-        contentPanel.add(labelMeasure, gb);
-
-        gb.gridx = 1;
-        contentPanel.add(labelCurrent, gb);
-        
-        gb.gridx = 2;
-        contentPanel.add(labelMean, gb);
-        
-        this.measures = measures;
-        this.measureCollectionSelected = 0;
-        this.variedParamName = variedParamName;
-        this.variedParamValues = variedParamValues;
-        
-        if (measures == null || measures.length == 0) {
-            // no measures to display
-            return;
-        }
-        int numMeasures = measures[0].getNumMeasures(); 
-        
-        // init radio buttons
-        this.radioGroup = new ButtonGroup();
-        this.radioButtons = new JRadioButton[numMeasures];
-        gb = new GridBagConstraints();
-        gb.gridx = 0;
-        gb.anchor = GridBagConstraints.WEST;
-        for (int i = 0; i < numMeasures; i++) {
-            JRadioButton rb = new JRadioButton(measures[0].getName(i));
-            rb.setBorder(BorderFactory.createLineBorder(Color.RED));
-            rb.setActionCommand(Integer.toString(i));
-            this.radioButtons[i] = rb;
-
-            gb.gridy = 1 + i;
-            this.contentPanel.add(rb, gb);
-            this.radioGroup.add(rb);
-        }
-        this.radioButtons[0].setSelected(true);
-        
-        // init values
-        this.currentValues = new JLabel[numMeasures];
-        this.meanValues = new JLabel[numMeasures];
-        
-        gb = new GridBagConstraints();
-        gb.weightx = 1.0;
-        
-        for (int i = 0; i < numMeasures; i++) {
-            gb.gridy = 1 + i;
-            // current values
-            this.currentValues[i] = new JLabel("-");
-            this.currentValues[i].setHorizontalAlignment(SwingConstants.CENTER);
-            gb.gridx = 1;
-            this.contentPanel.add(this.currentValues[i], gb);
-            
-            // mean values
-            this.meanValues[i] = new JLabel("-");
-            this.meanValues[i].setHorizontalAlignment(SwingConstants.CENTER);
-            gb.gridx = 2;
-            this.contentPanel.add(this.meanValues[i], gb);
-        }
-
-        // I have no idea where these numbers come from. its taken from 
-        // ClusteringVisualEvalPanel
-        contentPanel.setPreferredSize(new Dimension(250, this.currentValues.length*(14+8)+20));
-        
-        // update parameter box
-        updateParamBox();
-
-    }
-    
-    /**
-     * Sets the ActionListener for the radio buttons.
-     * @param listener ActionListener assigned to the radio buttons
-     */
-    public void setActionListener(ActionListener listener) {
-        for (int i = 0; i < this.radioButtons.length; i++) {
-            this.radioButtons[i].addActionListener(listener);
-        }
-    }
-    
-    /**
-     * Updates the measure overview by assigning new measure collections and
-     * varied parameter properties. If no measures are currently to display,
-     * reset the display to hyphens. Otherwise display the last measured and
-     * mean values.
-     * Updates the parameter combo box if needed.
-     * @param measures new MeasureCollection[]
-     * @param variedParamName new varied parameter name
-     * @param variedParamValues new varied parameter values
-     */
-    public void update(MeasureCollection[] measures, String variedParamName, double[] variedParamValues) {
-        this.measures = measures;
-        this.variedParamName = variedParamName;
-        this.variedParamValues = variedParamValues;
-        update();
-        updateParamBox();
-    }
-    
-    /**
-     * Updates the measure overview. If no measures are currently to display,
-     * reset the display to hyphens. Otherwise display the last measured and
-     * mean values.
-     */
-    public void update() {
-        if (this.measures == null || this.measures.length == 0) {
-            // no measures to show -> empty entries
-            for (int i = 0; i < this.currentValues.length; i++) {
-                this.currentValues[i].setText("-");
-                this.meanValues[i].setText("-");
-            }
-            return;
-        }
-        
-        DecimalFormat d = new DecimalFormat("0.00");
-        
-        MeasureCollection mc;
-        if (this.measures.length > this.measureCollectionSelected) {
-        	mc = this.measures[this.measureCollectionSelected];
-        }
-        else {
-        	mc = this.measures[0];
-        }
-        
-        for (int i = 0; i < this.currentValues.length; i++) {
-            // set current value
-            if(Double.isNaN(mc.getLastValue(i))) {
-                this.currentValues[i].setText("-");
-            } else {
-                this.currentValues[i].setText(d.format(mc.getLastValue(i)));
-            }
-            
-            // set mean value
-            if(Double.isNaN(mc.getMean(i))) {
-                this.meanValues[i].setText("-");
-            } else {
-                this.meanValues[i].setText(d.format(mc.getMean(i)));
-            }
-        } 
-    }
-    
-    /**
-     * Updates the parameter combo box. If there is no varied parameter, empty
-     * and disable the box. Otherwise display the available parameters.
-     */
-    private void updateParamBox() {
-        if (this.variedParamValues == null || this.variedParamValues.length == 0) {
-            // no varied parameter -> set to empty box
-            this.paramBox.removeAllItems();
-            this.paramBox.setEnabled(false);
-        } else if (this.paramBox.getItemCount() != this.variedParamValues.length) {
-            // varied parameter changed -> set the paramBox new
-            this.paramBox.removeAllItems();
-            for (int i = 0; i < variedParamValues.length; i++) {
-                this.paramBox.addItem(String.format("%s: %s", this.variedParamName, this.variedParamValues[i]));
-            }
-            this.paramBox.setEnabled(true);
-        }
-    }
+	private static final long serialVersionUID = 1L;
+
+	private MeasureCollection[] measures;
+	private int measureCollectionSelected;
+
+	private String variedParamName;
+	private double[] variedParamValues;
+
+	private JPanel contentPanel;
+	private JScrollPane scrollPane;
+
+	private ButtonGroup radioGroup;
+	private JRadioButton[] radioButtons;
+	private JLabel[] currentValues;
+	private JLabel[] meanValues;
+
+	private JLabel labelMeasure;
+	private JLabel labelCurrent;
+	private JLabel labelMean;
+
+	private JComboBox<String> paramBox;
+
+	/**
+	 * Creates a new MeasureOverview.
+	 * 
+	 * @param measures          MeasureCollection array
+	 * @param variedParamName   name of the varied parameter
+	 * @param variedParamValues values of the varied parameter
+	 */
+	public MeasureOverview(MeasureCollection[] measures, String variedParamName, double[] variedParamValues) {
+		// set basic parameters
+		setBorder(BorderFactory.createTitledBorder("Values"));
+		setPreferredSize(new Dimension(250, 115));
+		setLayout(new BoxLayout(this, BoxLayout.PAGE_AXIS));
+
+		// init scroll pane
+		scrollPane = new JScrollPane();
+		scrollPane.setViewportBorder(BorderFactory.createEmptyBorder());
+		scrollPane.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
+		scrollPane.setPreferredSize(new Dimension(270, 180));
+
+		// init content of the scroll pane
+		contentPanel = new JPanel();
+		contentPanel.setPreferredSize(new Dimension(100, 105));
+		contentPanel.setLayout(new GridBagLayout());
+		scrollPane.setViewportView(contentPanel);
+
+		// init param combo box
+		paramBox = new JComboBox<>();
+		// prevent height rescaling
+		paramBox.setMaximumSize(new Dimension(paramBox.getMaximumSize().width, paramBox.getPreferredSize().height));
+		paramBox.setEnabled(false);
+		paramBox.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				@SuppressWarnings("unchecked")
+				JComboBox<String> cb = (JComboBox<String>) e.getSource();
+				measureCollectionSelected = cb.getSelectedIndex();
+				// if the cb got disabled, set idx to 0
+				if (measureCollectionSelected == -1) {
+					measureCollectionSelected = 0;
+				}
+				update();
+			}
+		});
+
+		add(scrollPane);
+		add(paramBox);
+
+		// add labels
+		labelMeasure = new JLabel("Measure");
+		labelCurrent = new JLabel("Current");
+		labelMean = new JLabel("Mean");
+
+		GridBagConstraints gb = new GridBagConstraints();
+		gb.gridx = 0;
+		gb.gridy = 0;
+		contentPanel.add(labelMeasure, gb);
+
+		gb.gridx = 1;
+		contentPanel.add(labelCurrent, gb);
+
+		gb.gridx = 2;
+		contentPanel.add(labelMean, gb);
+
+		this.measures = measures;
+		this.measureCollectionSelected = 0;
+		this.variedParamName = variedParamName;
+		this.variedParamValues = variedParamValues;
+
+		if (measures == null || measures.length == 0) {
+			// no measures to display
+			return;
+		}
+		int numMeasures = measures[0].getNumMeasures();
+
+		// init radio buttons
+		this.radioGroup = new ButtonGroup();
+		this.radioButtons = new JRadioButton[numMeasures];
+		gb = new GridBagConstraints();
+		gb.gridx = 0;
+		gb.anchor = GridBagConstraints.WEST;
+		for (int i = 0; i < numMeasures; i++) {
+			JRadioButton rb = new JRadioButton(measures[0].getName(i));
+			rb.setBorder(BorderFactory.createLineBorder(Color.RED));
+			rb.setActionCommand(Integer.toString(i));
+			this.radioButtons[i] = rb;
+
+			gb.gridy = 1 + i;
+			this.contentPanel.add(rb, gb);
+			this.radioGroup.add(rb);
+		}
+		this.radioButtons[0].setSelected(true);
+
+		// init values
+		this.currentValues = new JLabel[numMeasures];
+		this.meanValues = new JLabel[numMeasures];
+
+		gb = new GridBagConstraints();
+		gb.weightx = 1.0;
+
+		for (int i = 0; i < numMeasures; i++) {
+			gb.gridy = 1 + i;
+			// current values
+			this.currentValues[i] = new JLabel("-");
+			this.currentValues[i].setHorizontalAlignment(SwingConstants.CENTER);
+			gb.gridx = 1;
+			this.contentPanel.add(this.currentValues[i], gb);
+
+			// mean values
+			this.meanValues[i] = new JLabel("-");
+			this.meanValues[i].setHorizontalAlignment(SwingConstants.CENTER);
+			gb.gridx = 2;
+			this.contentPanel.add(this.meanValues[i], gb);
+		}
+
+		// I have no idea where these numbers come from. its taken from
+		// ClusteringVisualEvalPanel
+		contentPanel.setPreferredSize(new Dimension(250, this.currentValues.length * (14 + 8) + 20));
+
+		// update parameter box
+		updateParamBox();
+
+	}
+
+	/**
+	 * Sets the ActionListener for the radio buttons.
+	 * 
+	 * @param listener ActionListener assigned to the radio buttons
+	 */
+	public void setActionListener(ActionListener listener) {
+		for (int i = 0; i < this.radioButtons.length; i++) {
+			this.radioButtons[i].addActionListener(listener);
+		}
+	}
+
+	/**
+	 * Updates the measure overview by assigning new measure collections and varied
+	 * parameter properties. If no measures are currently to display, reset the
+	 * display to hyphens. Otherwise display the last measured and mean values.
+	 * Updates the parameter combo box if needed.
+	 * 
+	 * @param measures          new MeasureCollection[]
+	 * @param variedParamName   new varied parameter name
+	 * @param variedParamValues new varied parameter values
+	 */
+	public void update(MeasureCollection[] measures, String variedParamName, double[] variedParamValues) {
+		this.measures = measures;
+		this.variedParamName = variedParamName;
+		this.variedParamValues = variedParamValues;
+		update();
+		updateParamBox();
+	}
+
+	/**
+	 * Updates the measure overview. If no measures are currently to display, reset
+	 * the display to hyphens. Otherwise display the last measured and mean values.
+	 */
+	public void update() {
+		if (this.measures == null || this.measures.length == 0) {
+			// no measures to show -> empty entries
+			for (int i = 0; i < this.currentValues.length; i++) {
+				this.currentValues[i].setText("-");
+				this.meanValues[i].setText("-");
+			}
+			return;
+		}
+
+		DecimalFormat d = new DecimalFormat("0.00");
+
+		MeasureCollection mc;
+		if (this.measures.length > this.measureCollectionSelected) {
+			mc = this.measures[this.measureCollectionSelected];
+		} else {
+			mc = this.measures[0];
+		}
+
+		for (int i = 0; i < this.currentValues.length; i++) {
+			// set current value
+			if (Double.isNaN(mc.getLastValue(i))) {
+				this.currentValues[i].setText("-");
+			} else {
+				this.currentValues[i].setText(d.format(mc.getLastValue(i)));
+			}
+
+			// set mean value
+			if (Double.isNaN(mc.getMean(i))) {
+				this.meanValues[i].setText("-");
+			} else {
+				this.meanValues[i].setText(d.format(mc.getMean(i)));
+			}
+		}
+	}
+
+	/**
+	 * Updates the parameter combo box. If there is no varied parameter, empty and
+	 * disable the box. Otherwise display the available parameters.
+	 */
+	private void updateParamBox() {
+		if (this.variedParamValues == null || this.variedParamValues.length == 0) {
+			// no varied parameter -> set to empty box
+			this.paramBox.removeAllItems();
+			this.paramBox.setEnabled(false);
+		} else if (this.paramBox.getItemCount() != this.variedParamValues.length) {
+			// varied parameter changed -> set the paramBox new
+			this.paramBox.removeAllItems();
+			for (int i = 0; i < variedParamValues.length; i++) {
+				this.paramBox.addItem(String.format("%s: %s", this.variedParamName, this.variedParamValues[i]));
+			}
+			this.paramBox.setEnabled(true);
+		}
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/clustertab/ClusteringAlgoPanel.java b/moa/src/main/java/moa/gui/clustertab/ClusteringAlgoPanel.java
index 61385baf7..83052b4c9 100644
--- a/moa/src/main/java/moa/gui/clustertab/ClusteringAlgoPanel.java
+++ b/moa/src/main/java/moa/gui/clustertab/ClusteringAlgoPanel.java
@@ -41,211 +41,218 @@
 import com.github.javacliparser.gui.OptionEditComponent;
 import com.github.javacliparser.gui.OptionsConfigurationPanel;
 
-import moa.clusterers.AbstractClusterer;
-import moa.clusterers.Clusterer;
 import moa.gui.GUIUtils;
+import moa.learners.clusterers.AbstractClusterer;
+import moa.learners.clusterers.Clusterer;
 import moa.options.ClassOption;
 import moa.streams.clustering.ClusteringStream;
 
-public class ClusteringAlgoPanel extends javax.swing.JPanel implements ActionListener{
-
-    protected List<OptionEditComponent> editComponents = new LinkedList<OptionEditComponent>();
-
-    private ClassOption streamOption = new ClassOption("Stream", 's',
-                "", ClusteringStream.class,
-                "RandomRBFGeneratorEvents");
-
-   private ClassOption algorithmOption0 = new ClassOption("Algorithm0", 'a',
-               "Algorithm to use.", Clusterer.class, "ClusterGenerator");
-
-   private ClassOption algorithmOption1 = new ClassOption("Algorithm1", 'c',
-               "Comparison algorithm", Clusterer.class, "clustream.WithKmeans", "None");
-
-
-    public ClusteringAlgoPanel() {
-        initComponents();
-    }
-
-    public void renderAlgoPanel(){
-
-        setLayout(new BorderLayout());
-
-        ArrayList<Option> options = new ArrayList<Option>();
-        options.add(streamOption);
-        options.add(algorithmOption0);
-        options.add(algorithmOption1);
-
-        JPanel optionsPanel = new JPanel();
-        GridBagLayout gbLayout = new GridBagLayout();
-        optionsPanel.setLayout(gbLayout);
-
-        //Create generic label constraints
-        GridBagConstraints gbcLabel = new GridBagConstraints();
-        gbcLabel.gridx = 0;
-        gbcLabel.fill = GridBagConstraints.NONE;
-        gbcLabel.anchor = GridBagConstraints.EAST;
-        gbcLabel.weightx = 0;
-        gbcLabel.insets = new Insets(5, 5, 5, 5);
-
-        //Create generic editor constraints
-        GridBagConstraints gbcOption = new GridBagConstraints();
-        gbcOption.gridx = 1;
-        gbcOption.fill = GridBagConstraints.HORIZONTAL;
-        gbcOption.anchor = GridBagConstraints.CENTER;
-        gbcOption.weightx = 1;
-        gbcOption.insets = new Insets(5, 5, 5, 0);
-
-        //Stream Option
-        JLabel labelStream = new JLabel("Stream");
-        labelStream.setToolTipText("Stream to use.");
-        optionsPanel.add(labelStream, gbcLabel);
-        JComponent editorStream = getEditComponent(streamOption);
-        labelStream.setLabelFor(editorStream);
-        editComponents.add((OptionEditComponent) editorStream);
-        optionsPanel.add(editorStream, gbcOption);
-
-        //Algorithm0 Option
-        JLabel labelAlgo0 = new JLabel("Algorithm1");
-        labelAlgo0.setToolTipText("Algorithm to use.");
-        optionsPanel.add(labelAlgo0, gbcLabel);
-        JComponent editorAlgo0 = getEditComponent(algorithmOption0);
-        labelAlgo0.setLabelFor(editorAlgo0);
-        editComponents.add((OptionEditComponent) editorAlgo0);
-        optionsPanel.add(editorAlgo0, gbcOption);
-
-        //Algorithm1 Option
-        JLabel labelAlgo1 = new JLabel("Algorithm2");
-        labelAlgo1.setToolTipText("Comparison algorithm to use.");
-        optionsPanel.add(labelAlgo1, gbcLabel);
-        JComponent editorAlgo1 = getEditComponent(algorithmOption1);
-        labelAlgo1.setLabelFor(editorAlgo1);
-        editComponents.add((OptionEditComponent) editorAlgo1);
-        optionsPanel.add(editorAlgo1, gbcOption);
-
-        //use comparison Algorithm Option
-        GridBagConstraints gbcClearButton = new GridBagConstraints();
-        gbcClearButton.gridx = 2;
-        gbcClearButton.gridy = 2;
-        gbcClearButton.fill = GridBagConstraints.NONE;
-        gbcClearButton.anchor = GridBagConstraints.CENTER;
-        gbcClearButton.insets = new Insets(5, 0, 5, 5);
-
-        JButton clearButton = new JButton("Clear");
-        clearButton.addActionListener(this);
-        clearButton.setActionCommand("clear");
-        optionsPanel.add(clearButton, gbcClearButton);
-
-
-        add(optionsPanel);
-    }
-
-    public JComponent getEditComponent(Option option){
-        return OptionsConfigurationPanel.getEditComponent(option);
-    }
-
-    public void actionPerformed(ActionEvent e) {
-        if(e.getActionCommand().equals("clear")){
-            algorithmOption1.setValueViaCLIString("None");
-            editComponents.get(2).setEditState("None");
-        }
-    }
-
-    public AbstractClusterer getClusterer0(){
-        AbstractClusterer c = null;
-        applyChanges();
-        try {
-            c = (AbstractClusterer) ClassOption.cliStringToObject(algorithmOption0.getValueAsCLIString(), Clusterer.class, null);
-        } catch (Exception ex) {
-            Logger.getLogger(ClusteringAlgoPanel.class.getName()).log(Level.SEVERE, null, ex);
-        }
-        return c;
-    }
-
-    public AbstractClusterer getClusterer1(){
-        AbstractClusterer c = null;
-        applyChanges();
-        if(!algorithmOption1.getValueAsCLIString().equals("None")){
-            try {
-                c = (AbstractClusterer) ClassOption.cliStringToObject(algorithmOption1.getValueAsCLIString(), Clusterer.class, null);
-            } catch (Exception ex) {
-                Logger.getLogger(ClusteringAlgoPanel.class.getName()).log(Level.SEVERE, null, ex);
-            }
-        }
-        return c;
-    }
-
-    public ClusteringStream getStream(){
-        ClusteringStream s = null;
-        applyChanges();
-        try {
-            s = (ClusteringStream) ClassOption.cliStringToObject(streamOption.getValueAsCLIString(), ClusteringStream.class, null);
-        } catch (Exception ex) {
-            Logger.getLogger(ClusteringAlgoPanel.class.getName()).log(Level.SEVERE, null, ex);
-        }
-        return s;
-    }
-
-    public String getStreamValueAsCLIString(){
-        applyChanges();
-        return streamOption.getValueAsCLIString();
-    }
-
-    public String getAlgorithm0ValueAsCLIString(){
-        applyChanges();
-        return algorithmOption0.getValueAsCLIString();
-    }
-
-    public String getAlgorithm1ValueAsCLIString(){
-        applyChanges();
-        return algorithmOption1.getValueAsCLIString();
-    }
-
-    /* We need to fetch the right item from editComponents list, index needs to match GUI order */
-    public void setStreamValueAsCLIString(String s){
-        streamOption.setValueViaCLIString(s);
-        editComponents.get(0).setEditState(streamOption.getValueAsCLIString());
-    }
-
-    public void setAlgorithm0ValueAsCLIString(String s){
-        algorithmOption0.setValueViaCLIString(s);
-        editComponents.get(1).setEditState(algorithmOption0.getValueAsCLIString());
-    }
-
-    public void setAlgorithm1ValueAsCLIString(String s){
-        algorithmOption1.setValueViaCLIString(s);
-        editComponents.get(2).setEditState(algorithmOption1.getValueAsCLIString());
-    }
-
-    public void applyChanges() {
-            for (OptionEditComponent editor : this.editComponents) {
-                    try {
-                            editor.applyState();
-                    } catch (Exception ex) {
-                            GUIUtils.showExceptionDialog(this, "Problem with option "
-                                            + editor.getEditedOption().getName(), ex);
-                    }
-            }
-    }
-
-    public void setPanelTitle(String title){
-        setBorder(javax.swing.BorderFactory.createTitledBorder(null,title, javax.swing.border.TitledBorder.DEFAULT_JUSTIFICATION, javax.swing.border.TitledBorder.DEFAULT_POSITION, new java.awt.Font("Tahoma", 1, 11)));
-    }
-
-    /** This method is called from within the constructor to
-     * initialize the form.
-     * WARNING: Do NOT modify this code. The content of this method is
-     * always regenerated by the Form Editor.
-     */
-    @SuppressWarnings("unchecked")
-    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
-    private void initComponents() {
-
-        setBorder(javax.swing.BorderFactory.createTitledBorder(null, "Cluster Algorithm Setup", javax.swing.border.TitledBorder.DEFAULT_JUSTIFICATION, javax.swing.border.TitledBorder.DEFAULT_POSITION, new java.awt.Font("Tahoma", 1, 11))); // NOI18N
-        setLayout(new java.awt.GridBagLayout());
-    }// </editor-fold>//GEN-END:initComponents
-
-
-    // Variables declaration - do not modify//GEN-BEGIN:variables
-    // End of variables declaration//GEN-END:variables
+public class ClusteringAlgoPanel extends javax.swing.JPanel implements ActionListener {
+
+	protected List<OptionEditComponent> editComponents = new LinkedList<>();
+
+	private ClassOption streamOption = new ClassOption("Stream", 's', "", ClusteringStream.class,
+			"RandomRBFGeneratorEvents");
+
+	private ClassOption algorithmOption0 = new ClassOption("Algorithm0", 'a', "Algorithm to use.", Clusterer.class,
+			"ClusterGenerator");
+
+	private ClassOption algorithmOption1 = new ClassOption("Algorithm1", 'c', "Comparison algorithm", Clusterer.class,
+			"clustream.WithKmeans", "None");
+
+	public ClusteringAlgoPanel() {
+		initComponents();
+	}
+
+	public void renderAlgoPanel() {
+
+		setLayout(new BorderLayout());
+
+		ArrayList<Option> options = new ArrayList<>();
+		options.add(streamOption);
+		options.add(algorithmOption0);
+		options.add(algorithmOption1);
+
+		JPanel optionsPanel = new JPanel();
+		GridBagLayout gbLayout = new GridBagLayout();
+		optionsPanel.setLayout(gbLayout);
+
+		// Create generic label constraints
+		GridBagConstraints gbcLabel = new GridBagConstraints();
+		gbcLabel.gridx = 0;
+		gbcLabel.fill = GridBagConstraints.NONE;
+		gbcLabel.anchor = GridBagConstraints.EAST;
+		gbcLabel.weightx = 0;
+		gbcLabel.insets = new Insets(5, 5, 5, 5);
+
+		// Create generic editor constraints
+		GridBagConstraints gbcOption = new GridBagConstraints();
+		gbcOption.gridx = 1;
+		gbcOption.fill = GridBagConstraints.HORIZONTAL;
+		gbcOption.anchor = GridBagConstraints.CENTER;
+		gbcOption.weightx = 1;
+		gbcOption.insets = new Insets(5, 5, 5, 0);
+
+		// Stream Option
+		JLabel labelStream = new JLabel("Stream");
+		labelStream.setToolTipText("Stream to use.");
+		optionsPanel.add(labelStream, gbcLabel);
+		JComponent editorStream = getEditComponent(streamOption);
+		labelStream.setLabelFor(editorStream);
+		editComponents.add((OptionEditComponent) editorStream);
+		optionsPanel.add(editorStream, gbcOption);
+
+		// Algorithm0 Option
+		JLabel labelAlgo0 = new JLabel("Algorithm1");
+		labelAlgo0.setToolTipText("Algorithm to use.");
+		optionsPanel.add(labelAlgo0, gbcLabel);
+		JComponent editorAlgo0 = getEditComponent(algorithmOption0);
+		labelAlgo0.setLabelFor(editorAlgo0);
+		editComponents.add((OptionEditComponent) editorAlgo0);
+		optionsPanel.add(editorAlgo0, gbcOption);
+
+		// Algorithm1 Option
+		JLabel labelAlgo1 = new JLabel("Algorithm2");
+		labelAlgo1.setToolTipText("Comparison algorithm to use.");
+		optionsPanel.add(labelAlgo1, gbcLabel);
+		JComponent editorAlgo1 = getEditComponent(algorithmOption1);
+		labelAlgo1.setLabelFor(editorAlgo1);
+		editComponents.add((OptionEditComponent) editorAlgo1);
+		optionsPanel.add(editorAlgo1, gbcOption);
+
+		// use comparison Algorithm Option
+		GridBagConstraints gbcClearButton = new GridBagConstraints();
+		gbcClearButton.gridx = 2;
+		gbcClearButton.gridy = 2;
+		gbcClearButton.fill = GridBagConstraints.NONE;
+		gbcClearButton.anchor = GridBagConstraints.CENTER;
+		gbcClearButton.insets = new Insets(5, 0, 5, 5);
+
+		JButton clearButton = new JButton("Clear");
+		clearButton.addActionListener(this);
+		clearButton.setActionCommand("clear");
+		optionsPanel.add(clearButton, gbcClearButton);
+
+		add(optionsPanel);
+	}
+
+	public JComponent getEditComponent(Option option) {
+		return OptionsConfigurationPanel.getEditComponent(option);
+	}
+
+	@Override
+	public void actionPerformed(ActionEvent e) {
+		if (e.getActionCommand().equals("clear")) {
+			algorithmOption1.setValueViaCLIString("None");
+			editComponents.get(2).setEditState("None");
+		}
+	}
+
+	public AbstractClusterer getClusterer0() {
+		AbstractClusterer c = null;
+		applyChanges();
+		try {
+			c = (AbstractClusterer) ClassOption.cliStringToObject(algorithmOption0.getValueAsCLIString(),
+					Clusterer.class, null);
+		} catch (Exception ex) {
+			Logger.getLogger(ClusteringAlgoPanel.class.getName()).log(Level.SEVERE, null, ex);
+		}
+		return c;
+	}
+
+	public AbstractClusterer getClusterer1() {
+		AbstractClusterer c = null;
+		applyChanges();
+		if (!algorithmOption1.getValueAsCLIString().equals("None")) {
+			try {
+				c = (AbstractClusterer) ClassOption.cliStringToObject(algorithmOption1.getValueAsCLIString(),
+						Clusterer.class, null);
+			} catch (Exception ex) {
+				Logger.getLogger(ClusteringAlgoPanel.class.getName()).log(Level.SEVERE, null, ex);
+			}
+		}
+		return c;
+	}
+
+	public ClusteringStream getStream() {
+		ClusteringStream s = null;
+		applyChanges();
+		try {
+			s = (ClusteringStream) ClassOption.cliStringToObject(streamOption.getValueAsCLIString(),
+					ClusteringStream.class, null);
+		} catch (Exception ex) {
+			Logger.getLogger(ClusteringAlgoPanel.class.getName()).log(Level.SEVERE, null, ex);
+		}
+		return s;
+	}
+
+	public String getStreamValueAsCLIString() {
+		applyChanges();
+		return streamOption.getValueAsCLIString();
+	}
+
+	public String getAlgorithm0ValueAsCLIString() {
+		applyChanges();
+		return algorithmOption0.getValueAsCLIString();
+	}
+
+	public String getAlgorithm1ValueAsCLIString() {
+		applyChanges();
+		return algorithmOption1.getValueAsCLIString();
+	}
+
+	/*
+	 * We need to fetch the right item from editComponents list, index needs to
+	 * match GUI order
+	 */
+	public void setStreamValueAsCLIString(String s) {
+		streamOption.setValueViaCLIString(s);
+		editComponents.get(0).setEditState(streamOption.getValueAsCLIString());
+	}
+
+	public void setAlgorithm0ValueAsCLIString(String s) {
+		algorithmOption0.setValueViaCLIString(s);
+		editComponents.get(1).setEditState(algorithmOption0.getValueAsCLIString());
+	}
+
+	public void setAlgorithm1ValueAsCLIString(String s) {
+		algorithmOption1.setValueViaCLIString(s);
+		editComponents.get(2).setEditState(algorithmOption1.getValueAsCLIString());
+	}
+
+	public void applyChanges() {
+		for (OptionEditComponent editor : this.editComponents) {
+			try {
+				editor.applyState();
+			} catch (Exception ex) {
+				GUIUtils.showExceptionDialog(this, "Problem with option " + editor.getEditedOption().getName(), ex);
+			}
+		}
+	}
+
+	public void setPanelTitle(String title) {
+		setBorder(javax.swing.BorderFactory.createTitledBorder(null, title,
+				javax.swing.border.TitledBorder.DEFAULT_JUSTIFICATION, javax.swing.border.TitledBorder.DEFAULT_POSITION,
+				new java.awt.Font("Tahoma", 1, 11)));
+	}
+
+	/**
+	 * This method is called from within the constructor to initialize the form.
+	 * WARNING: Do NOT modify this code. The content of this method is always
+	 * regenerated by the Form Editor.
+	 */
+	@SuppressWarnings("unchecked")
+	// <editor-fold defaultstate="collapsed" desc="Generated
+	// Code">//GEN-BEGIN:initComponents
+	private void initComponents() {
+
+		setBorder(javax.swing.BorderFactory.createTitledBorder(null, "Cluster Algorithm Setup",
+				javax.swing.border.TitledBorder.DEFAULT_JUSTIFICATION, javax.swing.border.TitledBorder.DEFAULT_POSITION,
+				new java.awt.Font("Tahoma", 1, 11))); // NOI18N
+		setLayout(new java.awt.GridBagLayout());
+	}// </editor-fold>//GEN-END:initComponents
+
+	// Variables declaration - do not modify//GEN-BEGIN:variables
+	// End of variables declaration//GEN-END:variables
 
 }
diff --git a/moa/src/main/java/moa/gui/clustertab/ClusteringEvalPanel.java b/moa/src/main/java/moa/gui/clustertab/ClusteringEvalPanel.java
index 9d94481db..6b5e76308 100644
--- a/moa/src/main/java/moa/gui/clustertab/ClusteringEvalPanel.java
+++ b/moa/src/main/java/moa/gui/clustertab/ClusteringEvalPanel.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 package moa.gui.clustertab;
 
@@ -32,159 +32,158 @@
 
 public class ClusteringEvalPanel extends javax.swing.JPanel {
 
-    Class<?>[] measure_classes = null;
-
-    ArrayList<JLabel> labels = null;
-
-    ArrayList<JCheckBox> checkboxes = null;
-
-    /** Creates new form ClusteringEvalPanel */
-    public ClusteringEvalPanel() {
-        initComponents();
-        measure_classes = findMeasureClasses();
-        labels = new ArrayList<JLabel>();
-        checkboxes = new ArrayList<JCheckBox>();
-        addComponents();
-    }
-
-    private void addComponents() {
-        GridBagConstraints gb = new GridBagConstraints();
-        gb.insets = new java.awt.Insets(4, 7, 4, 7);
-        int counter = 0;
-        for (int i = 0; i < measure_classes.length; i++) {
-            try {
-                MeasureCollection m = (MeasureCollection) measure_classes[i].newInstance();
-                for (int j = 0; j < m.getNumMeasures(); j++) {
-                    String t = m.getName(j);
-                    JLabel l = new JLabel(m.getName(j));
-                    l.setPreferredSize(new java.awt.Dimension(100, 14));
-                    //labels[i].setToolTipText("");
-                    gb.gridx = 0;
-                    gb.gridy = counter;
-                    labels.add(l);
-                    contentPanel.add(l, gb);
-
-                    JCheckBox cb = new JCheckBox();
-
-                    if (m.isEnabled(j)) {
-                        cb.setSelected(true);
-                    } else {
-                        cb.setSelected(false);
-                    }
-
-                    gb.gridx = 1;
-                    checkboxes.add(cb);
-                    contentPanel.add(cb, gb);
-                    counter++;
-                }
-            } catch (Exception ex) {
-                Logger.getLogger("Couldn't create Instance for " + measure_classes[i].getName());
-                ex.printStackTrace();
-            }
-
-        }
-        JLabel dummy = new JLabel();
-        gb.gridx = 0;
-        gb.gridy++;
-        gb.gridwidth = 3;
-        gb.weightx = 1;
-        gb.weighty = 1;
-        add(dummy, gb);
-
-    }
-
-    private Class<?>[] findMeasureClasses() {
-        AutoExpandVector<Class<?>> finalClasses = new AutoExpandVector<Class<?>>();
-        Class<?>[] classesFound = AutoClassDiscovery.findClassesOfType("moa.evaluation",
-                MeasureCollection.class);
-        for (Class<?> foundClass : classesFound) {
-            //Not add ClassificationMeasureCollection
-            boolean noClassificationMeasures = true;
-            for (Class cl: foundClass.getInterfaces()) {
-                if (cl.toString().contains("moa.evaluation.ClassificationMeasureCollection")){
-                    noClassificationMeasures = false;
-                }
-            }
-            if (noClassificationMeasures ) { 
-                finalClasses.add(foundClass);
-            }
-        }
-        return finalClasses.toArray(new Class<?>[finalClasses.size()]);
-    }
-
-    public MeasureCollection[] getSelectedMeasures() {
-        ArrayList<MeasureCollection> measuresSelect = new ArrayList<MeasureCollection>();
-
-        int counter = 0;
-        for (int i = 0; i < measure_classes.length; i++) {
-            try {
-                MeasureCollection m = (MeasureCollection) measure_classes[i].newInstance();
-                boolean addMeasure = false;
-                for (int j = 0; j < m.getNumMeasures(); j++) {
-                    boolean selected = checkboxes.get(counter).isSelected();
-                    m.setEnabled(j, selected);
-                    if (selected) {
-                        addMeasure = true;
-                    }
-                    counter++;
-                }
-                if (addMeasure) {
-                    measuresSelect.add(m);
-                }
-
-
-
-            } catch (Exception ex) {
-                Logger.getLogger("Couldn't create Instance for " + measure_classes[i].getName());
-                ex.printStackTrace();
-            }
-        }
-
-
-        MeasureCollection[] measures = new MeasureCollection[measuresSelect.size()];
-        for (int i = 0; i < measures.length; i++) {
-            measures[i] = measuresSelect.get(i);
-        }
-        return measures;
-    }
-
-    /** This method is called from within the constructor to
-     * initialize the form.
-     * WARNING: Do NOT modify this code. The content of this method is
-     * always regenerated by the Form Editor.
-     */
-    @SuppressWarnings("unchecked")
-    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
-    private void initComponents() {
-        java.awt.GridBagConstraints gridBagConstraints;
-
-        scrollPane = new javax.swing.JScrollPane();
-        contentPanel = new javax.swing.JPanel();
-
-        setBorder(javax.swing.BorderFactory.createTitledBorder(null, "Evaluation Measures", javax.swing.border.TitledBorder.DEFAULT_JUSTIFICATION, javax.swing.border.TitledBorder.DEFAULT_POSITION, new java.awt.Font("Tahoma", 1, 11))); // NOI18N
-        setLayout(new java.awt.GridBagLayout());
-
-        scrollPane.setBorder(null);
-        scrollPane.setHorizontalScrollBarPolicy(javax.swing.ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);       
-        scrollPane.setVerticalScrollBarPolicy(javax.swing.ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED);
-        if(java.awt.Toolkit.getDefaultToolkit().getScreenSize().getHeight() > 650) {
-            scrollPane.setPreferredSize(new java.awt.Dimension(100, 225));
-        } else {
-            scrollPane.setPreferredSize(new java.awt.Dimension(100, 115));
-        }        
- 
-        contentPanel.setLayout(new java.awt.GridBagLayout());
-        scrollPane.setViewportView(contentPanel);
-
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
-        gridBagConstraints.weightx = 1.0;
-        gridBagConstraints.weighty = 1.0;
-        add(scrollPane, gridBagConstraints);
-    }// </editor-fold>//GEN-END:initComponents
-
-    // Variables declaration - do not modify//GEN-BEGIN:variables
-    private javax.swing.JPanel contentPanel;
-    private javax.swing.JScrollPane scrollPane;
-    // End of variables declaration//GEN-END:variables
+	Class<?>[] measure_classes = null;
+
+	ArrayList<JLabel> labels = null;
+
+	ArrayList<JCheckBox> checkboxes = null;
+
+	/** Creates new form ClusteringEvalPanel */
+	public ClusteringEvalPanel() {
+		initComponents();
+		measure_classes = findMeasureClasses();
+		labels = new ArrayList<>();
+		checkboxes = new ArrayList<>();
+		addComponents();
+	}
+
+	private void addComponents() {
+		GridBagConstraints gb = new GridBagConstraints();
+		gb.insets = new java.awt.Insets(4, 7, 4, 7);
+		int counter = 0;
+		for (int i = 0; i < measure_classes.length; i++) {
+			try {
+				MeasureCollection m = (MeasureCollection) measure_classes[i].newInstance();
+				for (int j = 0; j < m.getNumMeasures(); j++) {
+					String t = m.getName(j);
+					JLabel l = new JLabel(m.getName(j));
+					l.setPreferredSize(new java.awt.Dimension(100, 14));
+					// labels[i].setToolTipText("");
+					gb.gridx = 0;
+					gb.gridy = counter;
+					labels.add(l);
+					contentPanel.add(l, gb);
+
+					JCheckBox cb = new JCheckBox();
+
+					if (m.isEnabled(j)) {
+						cb.setSelected(true);
+					} else {
+						cb.setSelected(false);
+					}
+
+					gb.gridx = 1;
+					checkboxes.add(cb);
+					contentPanel.add(cb, gb);
+					counter++;
+				}
+			} catch (Exception ex) {
+				Logger.getLogger("Couldn't create Instance for " + measure_classes[i].getName());
+				ex.printStackTrace();
+			}
+
+		}
+		JLabel dummy = new JLabel();
+		gb.gridx = 0;
+		gb.gridy++;
+		gb.gridwidth = 3;
+		gb.weightx = 1;
+		gb.weighty = 1;
+		add(dummy, gb);
+
+	}
+
+	private Class<?>[] findMeasureClasses() {
+		AutoExpandVector<Class<?>> finalClasses = new AutoExpandVector<>();
+		Class<?>[] classesFound = AutoClassDiscovery.findClassesOfType("moa.evaluation", MeasureCollection.class);
+		for (Class<?> foundClass : classesFound) {
+			// Not add ClassificationMeasureCollection
+			boolean noClassificationMeasures = true;
+			for (Class cl : foundClass.getInterfaces()) {
+				if (cl.toString().contains("moa.evaluation.ClassificationMeasureCollection")) {
+					noClassificationMeasures = false;
+				}
+			}
+			if (noClassificationMeasures) {
+				finalClasses.add(foundClass);
+			}
+		}
+		return finalClasses.toArray(new Class<?>[finalClasses.size()]);
+	}
+
+	public MeasureCollection[] getSelectedMeasures() {
+		ArrayList<MeasureCollection> measuresSelect = new ArrayList<>();
+
+		int counter = 0;
+		for (int i = 0; i < measure_classes.length; i++) {
+			try {
+				MeasureCollection m = (MeasureCollection) measure_classes[i].newInstance();
+				boolean addMeasure = false;
+				for (int j = 0; j < m.getNumMeasures(); j++) {
+					boolean selected = checkboxes.get(counter).isSelected();
+					m.setEnabled(j, selected);
+					if (selected) {
+						addMeasure = true;
+					}
+					counter++;
+				}
+				if (addMeasure) {
+					measuresSelect.add(m);
+				}
+
+			} catch (Exception ex) {
+				Logger.getLogger("Couldn't create Instance for " + measure_classes[i].getName());
+				ex.printStackTrace();
+			}
+		}
+
+		MeasureCollection[] measures = new MeasureCollection[measuresSelect.size()];
+		for (int i = 0; i < measures.length; i++) {
+			measures[i] = measuresSelect.get(i);
+		}
+		return measures;
+	}
+
+	/**
+	 * This method is called from within the constructor to initialize the form.
+	 * WARNING: Do NOT modify this code. The content of this method is always
+	 * regenerated by the Form Editor.
+	 */
+	@SuppressWarnings("unchecked")
+	// <editor-fold defaultstate="collapsed" desc="Generated
+	// Code">//GEN-BEGIN:initComponents
+	private void initComponents() {
+		java.awt.GridBagConstraints gridBagConstraints;
+
+		scrollPane = new javax.swing.JScrollPane();
+		contentPanel = new javax.swing.JPanel();
+
+		setBorder(javax.swing.BorderFactory.createTitledBorder(null, "Evaluation Measures",
+				javax.swing.border.TitledBorder.DEFAULT_JUSTIFICATION, javax.swing.border.TitledBorder.DEFAULT_POSITION,
+				new java.awt.Font("Tahoma", 1, 11))); // NOI18N
+		setLayout(new java.awt.GridBagLayout());
+
+		scrollPane.setBorder(null);
+		scrollPane.setHorizontalScrollBarPolicy(javax.swing.ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
+		scrollPane.setVerticalScrollBarPolicy(javax.swing.ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED);
+		if (java.awt.Toolkit.getDefaultToolkit().getScreenSize().getHeight() > 650) {
+			scrollPane.setPreferredSize(new java.awt.Dimension(100, 225));
+		} else {
+			scrollPane.setPreferredSize(new java.awt.Dimension(100, 115));
+		}
+
+		contentPanel.setLayout(new java.awt.GridBagLayout());
+		scrollPane.setViewportView(contentPanel);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
+		gridBagConstraints.weightx = 1.0;
+		gridBagConstraints.weighty = 1.0;
+		add(scrollPane, gridBagConstraints);
+	}// </editor-fold>//GEN-END:initComponents
+
+	// Variables declaration - do not modify//GEN-BEGIN:variables
+	private javax.swing.JPanel contentPanel;
+	private javax.swing.JScrollPane scrollPane;
+	// End of variables declaration//GEN-END:variables
 }
diff --git a/moa/src/main/java/moa/gui/clustertab/ClusteringSetupTab.java b/moa/src/main/java/moa/gui/clustertab/ClusteringSetupTab.java
index 0e1039299..9fc05cb2c 100644
--- a/moa/src/main/java/moa/gui/clustertab/ClusteringSetupTab.java
+++ b/moa/src/main/java/moa/gui/clustertab/ClusteringSetupTab.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.gui.clustertab;
@@ -25,290 +25,293 @@
 import java.io.File;
 import java.io.FileReader;
 
-import moa.clusterers.AbstractClusterer;
+import javax.swing.JFileChooser;
+
 import moa.evaluation.MeasureCollection;
 import moa.gui.FileExtensionFilter;
 import moa.gui.TextViewerPanel;
+import moa.learners.clusterers.AbstractClusterer;
 import moa.streams.clustering.ClusteringStream;
 import nz.ac.waikato.cms.gui.core.BaseFileChooser;
 
 public class ClusteringSetupTab extends javax.swing.JPanel {
-    private ClusteringTabPanel clusteringTab;
-    private String lastfile;
-
-    /** Creates new form ClusteringSetupTab */
-    public ClusteringSetupTab() {
-        initComponents();
-        clusteringAlgoPanel0.renderAlgoPanel();
-    }
-
-    public AbstractClusterer getClusterer0(){
-        return clusteringAlgoPanel0.getClusterer0();
-    }
-
-    public AbstractClusterer getClusterer1(){
-        return clusteringAlgoPanel0.getClusterer1();
-    }
-
-    public ClusteringStream getStream0(){
-        return clusteringAlgoPanel0.getStream();
-    }
-
-    public MeasureCollection[] getMeasures(){
-        return clusteringEvalPanel1.getSelectedMeasures();
-    }
-
-    public TextViewerPanel getLogPanel(){
-        return logPanel;
-    }
-
-    public void addButtonActionListener(ActionListener l){
-        buttonWeka.addActionListener(l);
-        buttonWeka.setActionCommand("weka export");
-        buttonExport.addActionListener(l);
-        buttonExport.setActionCommand("csv export");
-    }
-    /** This method is called from within the constructor to
-     * initialize the form.
-     * WARNING: Do NOT modify this code. The content of this method is
-     * always regenerated by the Form Editor.
-     */
-    @SuppressWarnings("unchecked")
-    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
-    private void initComponents() {
-        java.awt.GridBagConstraints gridBagConstraints;
-
-        clusteringAlgoPanel0 = new moa.gui.clustertab.ClusteringAlgoPanel();
-        clusteringEvalPanel1 = new moa.gui.clustertab.ClusteringEvalPanel();
-        buttonStart = new javax.swing.JButton();
-        buttonStop = new javax.swing.JButton();
-        buttonExport = new javax.swing.JButton();
-        buttonWeka = new javax.swing.JButton();
-        buttonImportSettings = new javax.swing.JButton();
-        buttonExportSettings = new javax.swing.JButton();
-        logPanel = new moa.gui.TextViewerPanel();
-
-        setLayout(new java.awt.GridBagLayout());
-
-        clusteringAlgoPanel0.setMinimumSize(new java.awt.Dimension(335, 150));
-        clusteringAlgoPanel0.setPanelTitle("Cluster Algorithm Setup");
-        clusteringAlgoPanel0.setPreferredSize(new java.awt.Dimension(335, 150));
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.gridwidth = 4;
-        gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
-        gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
-        add(clusteringAlgoPanel0, gridBagConstraints);
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 4;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.gridwidth = 2;
-        gridBagConstraints.gridheight = 4;
-        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
-        gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
-        add(clusteringEvalPanel1, gridBagConstraints);
-
-        buttonStart.setText("Start");
-        buttonStart.setPreferredSize(new java.awt.Dimension(80, 23));
-        buttonStart.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonStartActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 4;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
-        gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
-        add(buttonStart, gridBagConstraints);
-
-        buttonStop.setText("Stop");
-        buttonStop.setEnabled(false);
-        buttonStop.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonStopActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 1;
-        gridBagConstraints.gridy = 4;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
-        gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
-        add(buttonStop, gridBagConstraints);
-
-        buttonExport.setText("Export CSV");
-        buttonExport.setEnabled(false);
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 5;
-        gridBagConstraints.gridy = 4;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
-        gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
-        add(buttonExport, gridBagConstraints);
-
-        buttonWeka.setText("Weka Explorer");
-        buttonWeka.setEnabled(false);
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 4;
-        gridBagConstraints.gridy = 4;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
-        gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
-        add(buttonWeka, gridBagConstraints);
-
-        buttonImportSettings.setText("Import");
-        buttonImportSettings.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonImportSettingsActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 2;
-        gridBagConstraints.gridy = 4;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
-        gridBagConstraints.insets = new java.awt.Insets(4, 75, 4, 4);
-        add(buttonImportSettings, gridBagConstraints);
-
-        buttonExportSettings.setText("Export");
-        buttonExportSettings.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonExportSettingsActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 3;
-        gridBagConstraints.gridy = 4;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
-        gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
-        add(buttonExportSettings, gridBagConstraints);
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 5;
-        gridBagConstraints.gridwidth = 7;
-        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
-        gridBagConstraints.weightx = 1.0;
-        gridBagConstraints.weighty = 1.0;
-        gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
-        add(logPanel, gridBagConstraints);
-    }// </editor-fold>//GEN-END:initComponents
-
-    private void buttonImportSettingsActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonImportSettingsActionPerformed
-
-        BaseFileChooser fileChooser = new BaseFileChooser();
-        fileChooser.setAcceptAllFileFilterUsed(true);
-        fileChooser.addChoosableFileFilter(new FileExtensionFilter("txt"));
-        if(lastfile!=null)
-            fileChooser.setSelectedFile(new File(lastfile));
-        if (fileChooser.showOpenDialog(this.buttonImportSettings) == BaseFileChooser.APPROVE_OPTION) {
-            lastfile = fileChooser.getSelectedFile().getPath();
-            loadOptionsFromFile(fileChooser.getSelectedFile().getPath());
-        }
-    }//GEN-LAST:event_buttonImportSettingsActionPerformed
-
-    private void buttonExportSettingsActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonExportSettingsActionPerformed
-        StringBuffer sb = new StringBuffer();
-        sb.append(clusteringAlgoPanel0.getStreamValueAsCLIString()+"\n");
-        sb.append(clusteringAlgoPanel0.getAlgorithm0ValueAsCLIString()+"\n");
-        sb.append(clusteringAlgoPanel0.getAlgorithm1ValueAsCLIString()+"\n");
-        
-        System.out.println(sb);
-        logPanel.addText(sb.toString());
-        
-    }//GEN-LAST:event_buttonExportSettingsActionPerformed
-
-    private void buttonStartActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonStartActionPerformed
-        toggle(true);
-    }//GEN-LAST:event_buttonStartActionPerformed
-
-    private void buttonStopActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonStopActionPerformed
-        stop(true);
-    }//GEN-LAST:event_buttonStopActionPerformed
-
-
-    private void loadOptionsFromFile(String filepath){
-        try {
-            BufferedReader in = new BufferedReader(new FileReader(filepath));
-
-            String stream0 = in.readLine();
-            clusteringAlgoPanel0.setStreamValueAsCLIString(stream0);
-
-            String algo0 = in.readLine();
-            clusteringAlgoPanel0.setAlgorithm0ValueAsCLIString(algo0);
-
-            String algo1 = in.readLine();
-            clusteringAlgoPanel0.setAlgorithm1ValueAsCLIString(algo1);
-
-
-            System.out.println("Loading settings from "+filepath);
-            logPanel.addText("Loading settings from "+filepath);
-
-        } catch (Exception e) {
-            System.out.println("Bad option file:"+e.getMessage());
-        }
-    }
-
-    // Variables declaration - do not modify//GEN-BEGIN:variables
-    private javax.swing.JButton buttonExport;
-    private javax.swing.JButton buttonExportSettings;
-    private javax.swing.JButton buttonImportSettings;
-    private javax.swing.JButton buttonStart;
-    private javax.swing.JButton buttonStop;
-    private javax.swing.JButton buttonWeka;
-    private moa.gui.clustertab.ClusteringAlgoPanel clusteringAlgoPanel0;
-    private moa.gui.clustertab.ClusteringEvalPanel clusteringEvalPanel1;
-    private moa.gui.TextViewerPanel logPanel;
-    // End of variables declaration//GEN-END:variables
-
-    void setClusteringTab(ClusteringTabPanel clusteringTab) {
-        this.clusteringTab = clusteringTab;
-    }
-
-    public void toggleRunMode(){
-        toggle(false);
-    }
-
-    public void stopRun(){
-        stop(false);
-    }
-
-    private void toggle(boolean internal) {
-        setStateConfigButtons(false);
-        if(buttonStart.getText().equals("Pause")){
-            buttonStart.setText("Resume");
-            buttonWeka.setEnabled(true);
-            buttonExport.setEnabled(true);
-        }
-        else{
-            buttonStart.setText("Pause");
-            buttonWeka.setEnabled(false);
-            buttonExport.setEnabled(false);
-        }
-
-        //push event forward to the cluster tab
-        if(internal)
-            clusteringTab.toggle();
-    }
-
-
-    private void stop(boolean internal) {
-        buttonStart.setEnabled(true);
-        buttonStart.setText("Start");
-        buttonStop.setEnabled(false);
-        buttonWeka.setEnabled(false);
-        buttonExport.setEnabled(false);
-        setStateConfigButtons(true);
-
-        //push event forward to the cluster tab
-        if(internal)
-            clusteringTab.stop();
-    }
-
-    private void setStateConfigButtons(boolean state){
-        buttonStop.setEnabled(!state);
-        buttonExportSettings.setEnabled(state);
-        buttonImportSettings.setEnabled(state);
-    }
-
+	private ClusteringTabPanel clusteringTab;
+	private String lastfile;
+
+	/** Creates new form ClusteringSetupTab */
+	public ClusteringSetupTab() {
+		initComponents();
+		clusteringAlgoPanel0.renderAlgoPanel();
+	}
+
+	public AbstractClusterer getClusterer0() {
+		return clusteringAlgoPanel0.getClusterer0();
+	}
+
+	public AbstractClusterer getClusterer1() {
+		return clusteringAlgoPanel0.getClusterer1();
+	}
+
+	public ClusteringStream getStream0() {
+		return clusteringAlgoPanel0.getStream();
+	}
+
+	public MeasureCollection[] getMeasures() {
+		return clusteringEvalPanel1.getSelectedMeasures();
+	}
+
+	public TextViewerPanel getLogPanel() {
+		return logPanel;
+	}
+
+	public void addButtonActionListener(ActionListener l) {
+		buttonWeka.addActionListener(l);
+		buttonWeka.setActionCommand("weka export");
+		buttonExport.addActionListener(l);
+		buttonExport.setActionCommand("csv export");
+	}
+
+	/**
+	 * This method is called from within the constructor to initialize the form.
+	 * WARNING: Do NOT modify this code. The content of this method is always
+	 * regenerated by the Form Editor.
+	 */
+	@SuppressWarnings("unchecked")
+	// <editor-fold defaultstate="collapsed" desc="Generated
+	// Code">//GEN-BEGIN:initComponents
+	private void initComponents() {
+		java.awt.GridBagConstraints gridBagConstraints;
+
+		clusteringAlgoPanel0 = new moa.gui.clustertab.ClusteringAlgoPanel();
+		clusteringEvalPanel1 = new moa.gui.clustertab.ClusteringEvalPanel();
+		buttonStart = new javax.swing.JButton();
+		buttonStop = new javax.swing.JButton();
+		buttonExport = new javax.swing.JButton();
+		buttonWeka = new javax.swing.JButton();
+		buttonImportSettings = new javax.swing.JButton();
+		buttonExportSettings = new javax.swing.JButton();
+		logPanel = new moa.gui.TextViewerPanel();
+
+		setLayout(new java.awt.GridBagLayout());
+
+		clusteringAlgoPanel0.setMinimumSize(new java.awt.Dimension(335, 150));
+		clusteringAlgoPanel0.setPanelTitle("Cluster Algorithm Setup");
+		clusteringAlgoPanel0.setPreferredSize(new java.awt.Dimension(335, 150));
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.gridwidth = 4;
+		gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
+		gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
+		add(clusteringAlgoPanel0, gridBagConstraints);
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 4;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.gridwidth = 2;
+		gridBagConstraints.gridheight = 4;
+		gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
+		gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
+		add(clusteringEvalPanel1, gridBagConstraints);
+
+		buttonStart.setText("Start");
+		buttonStart.setPreferredSize(new java.awt.Dimension(80, 23));
+		buttonStart.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonStartActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 4;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
+		gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
+		add(buttonStart, gridBagConstraints);
+
+		buttonStop.setText("Stop");
+		buttonStop.setEnabled(false);
+		buttonStop.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonStopActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 1;
+		gridBagConstraints.gridy = 4;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
+		gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
+		add(buttonStop, gridBagConstraints);
+
+		buttonExport.setText("Export CSV");
+		buttonExport.setEnabled(false);
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 5;
+		gridBagConstraints.gridy = 4;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
+		gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
+		add(buttonExport, gridBagConstraints);
+
+		buttonWeka.setText("Weka Explorer");
+		buttonWeka.setEnabled(false);
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 4;
+		gridBagConstraints.gridy = 4;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
+		gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
+		add(buttonWeka, gridBagConstraints);
+
+		buttonImportSettings.setText("Import");
+		buttonImportSettings.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonImportSettingsActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 2;
+		gridBagConstraints.gridy = 4;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
+		gridBagConstraints.insets = new java.awt.Insets(4, 75, 4, 4);
+		add(buttonImportSettings, gridBagConstraints);
+
+		buttonExportSettings.setText("Export");
+		buttonExportSettings.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonExportSettingsActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 3;
+		gridBagConstraints.gridy = 4;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
+		gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
+		add(buttonExportSettings, gridBagConstraints);
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 5;
+		gridBagConstraints.gridwidth = 7;
+		gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
+		gridBagConstraints.weightx = 1.0;
+		gridBagConstraints.weighty = 1.0;
+		gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
+		add(logPanel, gridBagConstraints);
+	}// </editor-fold>//GEN-END:initComponents
+
+	private void buttonImportSettingsActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonImportSettingsActionPerformed
+
+		BaseFileChooser fileChooser = new BaseFileChooser();
+		fileChooser.setAcceptAllFileFilterUsed(true);
+		fileChooser.addChoosableFileFilter(new FileExtensionFilter("txt"));
+		if (lastfile != null)
+			fileChooser.setSelectedFile(new File(lastfile));
+		if (fileChooser.showOpenDialog(this.buttonImportSettings) == JFileChooser.APPROVE_OPTION) {
+			lastfile = fileChooser.getSelectedFile().getPath();
+			loadOptionsFromFile(fileChooser.getSelectedFile().getPath());
+		}
+	}// GEN-LAST:event_buttonImportSettingsActionPerformed
+
+	private void buttonExportSettingsActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonExportSettingsActionPerformed
+		StringBuffer sb = new StringBuffer();
+		sb.append(clusteringAlgoPanel0.getStreamValueAsCLIString() + "\n");
+		sb.append(clusteringAlgoPanel0.getAlgorithm0ValueAsCLIString() + "\n");
+		sb.append(clusteringAlgoPanel0.getAlgorithm1ValueAsCLIString() + "\n");
+
+		System.out.println(sb);
+		logPanel.addText(sb.toString());
+
+	}// GEN-LAST:event_buttonExportSettingsActionPerformed
+
+	private void buttonStartActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonStartActionPerformed
+		toggle(true);
+	}// GEN-LAST:event_buttonStartActionPerformed
+
+	private void buttonStopActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonStopActionPerformed
+		stop(true);
+	}// GEN-LAST:event_buttonStopActionPerformed
+
+	private void loadOptionsFromFile(String filepath) {
+		try {
+			BufferedReader in = new BufferedReader(new FileReader(filepath));
+
+			String stream0 = in.readLine();
+			clusteringAlgoPanel0.setStreamValueAsCLIString(stream0);
+
+			String algo0 = in.readLine();
+			clusteringAlgoPanel0.setAlgorithm0ValueAsCLIString(algo0);
+
+			String algo1 = in.readLine();
+			clusteringAlgoPanel0.setAlgorithm1ValueAsCLIString(algo1);
+
+			System.out.println("Loading settings from " + filepath);
+			logPanel.addText("Loading settings from " + filepath);
+
+		} catch (Exception e) {
+			System.out.println("Bad option file:" + e.getMessage());
+		}
+	}
+
+	// Variables declaration - do not modify//GEN-BEGIN:variables
+	private javax.swing.JButton buttonExport;
+	private javax.swing.JButton buttonExportSettings;
+	private javax.swing.JButton buttonImportSettings;
+	private javax.swing.JButton buttonStart;
+	private javax.swing.JButton buttonStop;
+	private javax.swing.JButton buttonWeka;
+	private moa.gui.clustertab.ClusteringAlgoPanel clusteringAlgoPanel0;
+	private moa.gui.clustertab.ClusteringEvalPanel clusteringEvalPanel1;
+	private moa.gui.TextViewerPanel logPanel;
+	// End of variables declaration//GEN-END:variables
+
+	void setClusteringTab(ClusteringTabPanel clusteringTab) {
+		this.clusteringTab = clusteringTab;
+	}
+
+	public void toggleRunMode() {
+		toggle(false);
+	}
+
+	public void stopRun() {
+		stop(false);
+	}
+
+	private void toggle(boolean internal) {
+		setStateConfigButtons(false);
+		if (buttonStart.getText().equals("Pause")) {
+			buttonStart.setText("Resume");
+			buttonWeka.setEnabled(true);
+			buttonExport.setEnabled(true);
+		} else {
+			buttonStart.setText("Pause");
+			buttonWeka.setEnabled(false);
+			buttonExport.setEnabled(false);
+		}
+
+		// push event forward to the cluster tab
+		if (internal)
+			clusteringTab.toggle();
+	}
+
+	private void stop(boolean internal) {
+		buttonStart.setEnabled(true);
+		buttonStart.setText("Start");
+		buttonStop.setEnabled(false);
+		buttonWeka.setEnabled(false);
+		buttonExport.setEnabled(false);
+		setStateConfigButtons(true);
+
+		// push event forward to the cluster tab
+		if (internal)
+			clusteringTab.stop();
+	}
+
+	private void setStateConfigButtons(boolean state) {
+		buttonStop.setEnabled(!state);
+		buttonExportSettings.setEnabled(state);
+		buttonImportSettings.setEnabled(state);
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/clustertab/ClusteringTabPanel.java b/moa/src/main/java/moa/gui/clustertab/ClusteringTabPanel.java
index ff456bd6a..6c356dfe1 100644
--- a/moa/src/main/java/moa/gui/clustertab/ClusteringTabPanel.java
+++ b/moa/src/main/java/moa/gui/clustertab/ClusteringTabPanel.java
@@ -14,89 +14,91 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.gui.clustertab;
 
 import moa.gui.AbstractTabPanel;
 
-public class ClusteringTabPanel extends AbstractTabPanel{
-
-    /** Creates new form ClusterTab */
-    public ClusteringTabPanel() {
-        initComponents();
-        clusteringVisualTab.setClusteringSetupTab(clusteringSetupTab);
-        clusteringSetupTab.addButtonActionListener(clusteringVisualTab);
-        clusteringSetupTab.setClusteringTab(this);
-    }
-
-    void toggle() {
-        clusteringVisualTab.toggleVisualizer(false);
-    }
-
-    void stop() {
-        clusteringVisualTab.stopVisualizer();
-    }
-
-    
-    /** This method is called from within the constructor to
-     * initialize the form.
-     * WARNING: Do NOT modify this code. The content of this method is
-     * always regenerated by the Form Editor.
-     */
-    @SuppressWarnings("unchecked")
-    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
-    private void initComponents() {
-
-        jTabbedPane1 = new javax.swing.JTabbedPane();
-        clusteringSetupTab = new moa.gui.clustertab.ClusteringSetupTab();
-        clusteringVisualTab = new moa.gui.clustertab.ClusteringVisualTab();
-
-        setLayout(new java.awt.BorderLayout());
-
-        jTabbedPane1.addMouseListener(new java.awt.event.MouseAdapter() {
-            public void mouseClicked(java.awt.event.MouseEvent evt) {
-                jTabbedPane1MouseClicked(evt);
-            }
-        });
-        jTabbedPane1.addFocusListener(new java.awt.event.FocusAdapter() {
-            public void focusGained(java.awt.event.FocusEvent evt) {
-                jTabbedPane1FocusGained(evt);
-            }
-        });
-        jTabbedPane1.addTab("Setup", clusteringSetupTab);
-        jTabbedPane1.addTab("Visualization", clusteringVisualTab);
-
-        add(jTabbedPane1, java.awt.BorderLayout.CENTER);
-    }// </editor-fold>//GEN-END:initComponents
-
-    private void jTabbedPane1FocusGained(java.awt.event.FocusEvent evt) {//GEN-FIRST:event_jTabbedPane1FocusGained
-        
-    }//GEN-LAST:event_jTabbedPane1FocusGained
-
-    private void jTabbedPane1MouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_jTabbedPane1MouseClicked
-        
-    }//GEN-LAST:event_jTabbedPane1MouseClicked
-
-
-
-    // Variables declaration - do not modify//GEN-BEGIN:variables
-    private moa.gui.clustertab.ClusteringSetupTab clusteringSetupTab;
-    private moa.gui.clustertab.ClusteringVisualTab clusteringVisualTab;
-    private javax.swing.JTabbedPane jTabbedPane1;
-    // End of variables declaration//GEN-END:variables
-
-    //returns the string to display as title of the tab
-    public String getTabTitle() {
-            return "Clustering";
-    }
-
-    //a short description (can be used as tool tip) of the tab, or contributor, etc.
-    public String getDescription(){
-            return "MOA Clustering";
-    }
-
+public class ClusteringTabPanel extends AbstractTabPanel {
+
+	/** Creates new form ClusterTab */
+	public ClusteringTabPanel() {
+		initComponents();
+		clusteringVisualTab.setClusteringSetupTab(clusteringSetupTab);
+		clusteringSetupTab.addButtonActionListener(clusteringVisualTab);
+		clusteringSetupTab.setClusteringTab(this);
+	}
+
+	void toggle() {
+		clusteringVisualTab.toggleVisualizer(false);
+	}
+
+	void stop() {
+		clusteringVisualTab.stopVisualizer();
+	}
+
+	/**
+	 * This method is called from within the constructor to initialize the form.
+	 * WARNING: Do NOT modify this code. The content of this method is always
+	 * regenerated by the Form Editor.
+	 */
+	@SuppressWarnings("unchecked")
+	// <editor-fold defaultstate="collapsed" desc="Generated
+	// Code">//GEN-BEGIN:initComponents
+	private void initComponents() {
+
+		jTabbedPane1 = new javax.swing.JTabbedPane();
+		clusteringSetupTab = new moa.gui.clustertab.ClusteringSetupTab();
+		clusteringVisualTab = new moa.gui.clustertab.ClusteringVisualTab();
+
+		setLayout(new java.awt.BorderLayout());
+
+		jTabbedPane1.addMouseListener(new java.awt.event.MouseAdapter() {
+			@Override
+			public void mouseClicked(java.awt.event.MouseEvent evt) {
+				jTabbedPane1MouseClicked(evt);
+			}
+		});
+		jTabbedPane1.addFocusListener(new java.awt.event.FocusAdapter() {
+			@Override
+			public void focusGained(java.awt.event.FocusEvent evt) {
+				jTabbedPane1FocusGained(evt);
+			}
+		});
+		jTabbedPane1.addTab("Setup", clusteringSetupTab);
+		jTabbedPane1.addTab("Visualization", clusteringVisualTab);
+
+		add(jTabbedPane1, java.awt.BorderLayout.CENTER);
+	}// </editor-fold>//GEN-END:initComponents
+
+	private void jTabbedPane1FocusGained(java.awt.event.FocusEvent evt) {// GEN-FIRST:event_jTabbedPane1FocusGained
+
+	}// GEN-LAST:event_jTabbedPane1FocusGained
+
+	private void jTabbedPane1MouseClicked(java.awt.event.MouseEvent evt) {// GEN-FIRST:event_jTabbedPane1MouseClicked
+
+	}// GEN-LAST:event_jTabbedPane1MouseClicked
+
+	// Variables declaration - do not modify//GEN-BEGIN:variables
+	private moa.gui.clustertab.ClusteringSetupTab clusteringSetupTab;
+	private moa.gui.clustertab.ClusteringVisualTab clusteringVisualTab;
+	private javax.swing.JTabbedPane jTabbedPane1;
+	// End of variables declaration//GEN-END:variables
+
+	// returns the string to display as title of the tab
+	@Override
+	public String getTabTitle() {
+		return "Clustering";
+	}
+
+	// a short description (can be used as tool tip) of the tab, or contributor,
+	// etc.
+	@Override
+	public String getDescription() {
+		return "MOA Clustering";
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/clustertab/ClusteringVisualEvalPanel.java b/moa/src/main/java/moa/gui/clustertab/ClusteringVisualEvalPanel.java
index 574a78b96..43b657301 100644
--- a/moa/src/main/java/moa/gui/clustertab/ClusteringVisualEvalPanel.java
+++ b/moa/src/main/java/moa/gui/clustertab/ClusteringVisualEvalPanel.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.gui.clustertab;
@@ -34,246 +34,244 @@
 
 import moa.evaluation.MeasureCollection;
 
-public class ClusteringVisualEvalPanel extends javax.swing.JPanel{
-    private ArrayList<JLabel> names;
-    private ArrayList<JLabel> values;
-    private ArrayList<JRadioButton> radiobuttons;
-    private MeasureCollection[] measures0;
-    private MeasureCollection[] measures1;
-    private ButtonGroup radioGroup;
-
-    private JLabel labelDummy;
-    private JLabel labelMeasure;
-    private JLabel labelCurrent0;
-    private JLabel labelMean0;
-
-    /** Creates new form ClusteringEvalPanel */
-    public ClusteringVisualEvalPanel() {
-        initComponents();
-        radioGroup = new ButtonGroup();
-    }
-
-
-    public void setMeasures(MeasureCollection[] measures0, MeasureCollection[] measures1, ActionListener listener){
-        this.measures0 = measures0;
-        this.measures1 = measures1;
-
-        names = new ArrayList<JLabel>();
-        values = new ArrayList<JLabel>();
-        radiobuttons = new ArrayList<JRadioButton>();
-
-        for (int i = 0; i < measures0.length; i++) {
-            for (int j = 0; j < measures0[i].getNumMeasures(); j++) {
-                if(measures0[i].isEnabled(j)){
-                    names.add(new JLabel(measures0[i].getName(j)));
-
-                }
-            }
-        }
-        
-        setLayout(new java.awt.GridBagLayout());
-        GridBagConstraints gb;
-
-        //Radiobuttons
-        radioGroup = new ButtonGroup();
-        gb = new GridBagConstraints();
-        gb.gridx=0;
-        for (int i = 0; i < names.size(); i++) {
-            JRadioButton rb = new JRadioButton();
-            rb.setActionCommand(Integer.toString(i));
-            rb.addActionListener(listener);
-            radiobuttons.add(rb);
-
-            gb.gridy = i+1;
-            contentPanel.add(rb, gb);
-            radioGroup.add(rb);
-        }
-        radiobuttons.get(0).setSelected(true);
-
-        //name labels
-        gb = new GridBagConstraints();
-        gb.gridx=1;
-        for (int i = 0; i < names.size(); i++) {
-            names.get(i).setPreferredSize(new Dimension(40, 14));
-            gb.anchor = GridBagConstraints.WEST;
-            gb.insets = new java.awt.Insets(4, 7, 4, 7);
-            gb.gridy = i+1;
-            contentPanel.add(names.get(i), gb);
-        }
-
-        
-
-        int counter = 0;
-        for (int i = 0; i < measures0.length; i++) {
-            for (int j = 0; j < measures0[i].getNumMeasures(); j++) {
-                if(!measures0[i].isEnabled(j)) continue;
-                for (int k = 0; k < 4; k++) {
-                    String tooltip ="";
-                    Color color = Color.black;
-                    switch(k){
-                        case 0:
-                            tooltip = "current value";
-                            color = Color.red;
-                        break;
-                        case 1:
-                            tooltip = "current value";
-                            color = Color.blue;
-                        break;
-                        case 2:
-                            tooltip = "mean";
-                            color = Color.black;
-                        break;
-                        case 3:
-                            tooltip = "mean";
-                            color = Color.black;
-                        break;
-                    }
-                    JLabel l = new JLabel("-");
-                    l.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
-                    l.setPreferredSize(new java.awt.Dimension(50, 14));
-                    l.setToolTipText(measures0[i].getName(j)+" "+tooltip);
-                    l.setForeground(color);
-                    values.add(l);
-                    gb = new GridBagConstraints();
-                    gb.gridy = 1 + counter;
-                    gb.gridx = 2 + k;
-                    gb.weightx = 1.0;
-                    contentPanel.add(l, gb);
-                }
-                counter++;
-            }
-        }
-
-        //dummy label to align the labels at the top
-        gb = new GridBagConstraints();
-        gb.gridx = 0;
-        gb.gridy = names.size()+2;
-        gb.gridwidth = 6;
-        gb.weighty = 1.0;
-        JLabel fill = new JLabel();
-        contentPanel.add(fill, gb);
-
-        addLabels();
-
-        contentPanel.setPreferredSize(new Dimension(250, names.size()*(14+8)+20));
-    }
-
-    private void addLabels(){
-        labelMeasure = new javax.swing.JLabel("Measure");
-        labelCurrent0 = new JLabel("Current");
-        labelMean0 = new javax.swing.JLabel("Mean");
-        labelDummy = new javax.swing.JLabel();
-        GridBagConstraints gb = new GridBagConstraints();
-        gb.gridy = 0;
-
-        gb.gridx = 0;
-        contentPanel.add(labelDummy, gb);
-
-        gb.gridx = 1;
-        contentPanel.add(labelMeasure, gb);
-
-        gb = new GridBagConstraints();
-        gb.gridy = 0;
-        gb.gridx = 2;
-        gb.gridwidth = 2;
-        contentPanel.add(labelCurrent0, gb);
-
-
-        gb = new GridBagConstraints();
-        gb.gridy = 0;
-        gb.gridx=4;
-        gb.gridwidth = 2;
-        contentPanel.add(labelMean0, gb);
-
-    }
-
-    public void update(){
-        DecimalFormat d = new DecimalFormat("0.00");
-
-        if(measures0!=null){
-            int counter = 0;
-            for (MeasureCollection m : measures0) {
-                for (int i = 0; i < m.getNumMeasures(); i++) {
-                    if(!m.isEnabled(i)) continue;
-                    if(Double.isNaN(m.getLastValue(i)))
-                        values.get(counter*4).setText("-");
-                    else
-                        values.get(counter*4).setText(d.format(m.getLastValue(i)));
-
-                    if(Double.isNaN(m.getMean(i)))
-                        values.get(counter*4+2).setText("-");
-                    else
-                        values.get(counter*4+2).setText(d.format(m.getMean(i)));
-                    counter++;
-                }
-            }
-        }
-        if(measures1!=null){
-            int counter = 0;
-            for (MeasureCollection m : measures1) {
-                for (int i = 0; i < m.getNumMeasures(); i++) {
-                    if(!m.isEnabled(i)) continue;
-                    if(Double.isNaN(m.getLastValue(i)))
-                        values.get(counter*4+1).setText("-");
-                    else
-                        values.get(counter*4+1).setText(d.format(m.getLastValue(i)));
-
-
-                    if(Double.isNaN(m.getMean(i)))
-                        values.get(counter*4+3).setText("-");
-                    else
-                        values.get(counter*4+3).setText(d.format(m.getMean(i)));
-                    counter++;
-                }
-            }
-        }
-    }
-
-    @Override
-    //this is soooooo bad, but freaking gridbag somehow doesnt kick in...???
-    protected void paintComponent(Graphics g) {
-        scrollPane.setPreferredSize(new Dimension(getWidth()-20, getHeight()-30));
-        super.paintComponent(g);
-    }
-
-    /** This method is called from within the constructor to
-     * initialize the form.
-     * WARNING: Do NOT modify this code. The content of this method is
-     * always regenerated by the Form Editor.
-     */
-    @SuppressWarnings("unchecked")
-    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
-    private void initComponents() {
-        java.awt.GridBagConstraints gridBagConstraints;
-
-        scrollPane = new javax.swing.JScrollPane();
-        contentPanel = new javax.swing.JPanel();
-
-        setBorder(javax.swing.BorderFactory.createTitledBorder("Values"));
-        setPreferredSize(new java.awt.Dimension(250, 115));
-        setLayout(new java.awt.GridBagLayout());
-
-        scrollPane.setBorder(null);
-        scrollPane.setHorizontalScrollBarPolicy(javax.swing.ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
-        scrollPane.setPreferredSize(new java.awt.Dimension(270, 180));
-
-        contentPanel.setPreferredSize(new java.awt.Dimension(100, 105));
-        contentPanel.setLayout(new java.awt.GridBagLayout());
-        scrollPane.setViewportView(contentPanel);
-
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
-        gridBagConstraints.weightx = 1.0;
-        gridBagConstraints.weighty = 1.0;
-        add(scrollPane, gridBagConstraints);
-    }// </editor-fold>//GEN-END:initComponents
-
-
-    // Variables declaration - do not modify//GEN-BEGIN:variables
-    private javax.swing.JPanel contentPanel;
-    private javax.swing.JScrollPane scrollPane;
-    // End of variables declaration//GEN-END:variables
+public class ClusteringVisualEvalPanel extends javax.swing.JPanel {
+	private ArrayList<JLabel> names;
+	private ArrayList<JLabel> values;
+	private ArrayList<JRadioButton> radiobuttons;
+	private MeasureCollection[] measures0;
+	private MeasureCollection[] measures1;
+	private ButtonGroup radioGroup;
+
+	private JLabel labelDummy;
+	private JLabel labelMeasure;
+	private JLabel labelCurrent0;
+	private JLabel labelMean0;
+
+	/** Creates new form ClusteringEvalPanel */
+	public ClusteringVisualEvalPanel() {
+		initComponents();
+		radioGroup = new ButtonGroup();
+	}
+
+	public void setMeasures(MeasureCollection[] measures0, MeasureCollection[] measures1, ActionListener listener) {
+		this.measures0 = measures0;
+		this.measures1 = measures1;
+
+		names = new ArrayList<>();
+		values = new ArrayList<>();
+		radiobuttons = new ArrayList<>();
+
+		for (int i = 0; i < measures0.length; i++) {
+			for (int j = 0; j < measures0[i].getNumMeasures(); j++) {
+				if (measures0[i].isEnabled(j)) {
+					names.add(new JLabel(measures0[i].getName(j)));
+
+				}
+			}
+		}
+
+		setLayout(new java.awt.GridBagLayout());
+		GridBagConstraints gb;
+
+		// Radiobuttons
+		radioGroup = new ButtonGroup();
+		gb = new GridBagConstraints();
+		gb.gridx = 0;
+		for (int i = 0; i < names.size(); i++) {
+			JRadioButton rb = new JRadioButton();
+			rb.setActionCommand(Integer.toString(i));
+			rb.addActionListener(listener);
+			radiobuttons.add(rb);
+
+			gb.gridy = i + 1;
+			contentPanel.add(rb, gb);
+			radioGroup.add(rb);
+		}
+		radiobuttons.get(0).setSelected(true);
+
+		// name labels
+		gb = new GridBagConstraints();
+		gb.gridx = 1;
+		for (int i = 0; i < names.size(); i++) {
+			names.get(i).setPreferredSize(new Dimension(40, 14));
+			gb.anchor = GridBagConstraints.WEST;
+			gb.insets = new java.awt.Insets(4, 7, 4, 7);
+			gb.gridy = i + 1;
+			contentPanel.add(names.get(i), gb);
+		}
+
+		int counter = 0;
+		for (int i = 0; i < measures0.length; i++) {
+			for (int j = 0; j < measures0[i].getNumMeasures(); j++) {
+				if (!measures0[i].isEnabled(j))
+					continue;
+				for (int k = 0; k < 4; k++) {
+					String tooltip = "";
+					Color color = Color.black;
+					switch (k) {
+					case 0:
+						tooltip = "current value";
+						color = Color.red;
+						break;
+					case 1:
+						tooltip = "current value";
+						color = Color.blue;
+						break;
+					case 2:
+						tooltip = "mean";
+						color = Color.black;
+						break;
+					case 3:
+						tooltip = "mean";
+						color = Color.black;
+						break;
+					}
+					JLabel l = new JLabel("-");
+					l.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
+					l.setPreferredSize(new java.awt.Dimension(50, 14));
+					l.setToolTipText(measures0[i].getName(j) + " " + tooltip);
+					l.setForeground(color);
+					values.add(l);
+					gb = new GridBagConstraints();
+					gb.gridy = 1 + counter;
+					gb.gridx = 2 + k;
+					gb.weightx = 1.0;
+					contentPanel.add(l, gb);
+				}
+				counter++;
+			}
+		}
+
+		// dummy label to align the labels at the top
+		gb = new GridBagConstraints();
+		gb.gridx = 0;
+		gb.gridy = names.size() + 2;
+		gb.gridwidth = 6;
+		gb.weighty = 1.0;
+		JLabel fill = new JLabel();
+		contentPanel.add(fill, gb);
+
+		addLabels();
+
+		contentPanel.setPreferredSize(new Dimension(250, names.size() * (14 + 8) + 20));
+	}
+
+	private void addLabels() {
+		labelMeasure = new javax.swing.JLabel("Measure");
+		labelCurrent0 = new JLabel("Current");
+		labelMean0 = new javax.swing.JLabel("Mean");
+		labelDummy = new javax.swing.JLabel();
+		GridBagConstraints gb = new GridBagConstraints();
+		gb.gridy = 0;
+
+		gb.gridx = 0;
+		contentPanel.add(labelDummy, gb);
+
+		gb.gridx = 1;
+		contentPanel.add(labelMeasure, gb);
+
+		gb = new GridBagConstraints();
+		gb.gridy = 0;
+		gb.gridx = 2;
+		gb.gridwidth = 2;
+		contentPanel.add(labelCurrent0, gb);
+
+		gb = new GridBagConstraints();
+		gb.gridy = 0;
+		gb.gridx = 4;
+		gb.gridwidth = 2;
+		contentPanel.add(labelMean0, gb);
+
+	}
+
+	public void update() {
+		DecimalFormat d = new DecimalFormat("0.00");
+
+		if (measures0 != null) {
+			int counter = 0;
+			for (MeasureCollection m : measures0) {
+				for (int i = 0; i < m.getNumMeasures(); i++) {
+					if (!m.isEnabled(i))
+						continue;
+					if (Double.isNaN(m.getLastValue(i)))
+						values.get(counter * 4).setText("-");
+					else
+						values.get(counter * 4).setText(d.format(m.getLastValue(i)));
+
+					if (Double.isNaN(m.getMean(i)))
+						values.get(counter * 4 + 2).setText("-");
+					else
+						values.get(counter * 4 + 2).setText(d.format(m.getMean(i)));
+					counter++;
+				}
+			}
+		}
+		if (measures1 != null) {
+			int counter = 0;
+			for (MeasureCollection m : measures1) {
+				for (int i = 0; i < m.getNumMeasures(); i++) {
+					if (!m.isEnabled(i))
+						continue;
+					if (Double.isNaN(m.getLastValue(i)))
+						values.get(counter * 4 + 1).setText("-");
+					else
+						values.get(counter * 4 + 1).setText(d.format(m.getLastValue(i)));
+
+					if (Double.isNaN(m.getMean(i)))
+						values.get(counter * 4 + 3).setText("-");
+					else
+						values.get(counter * 4 + 3).setText(d.format(m.getMean(i)));
+					counter++;
+				}
+			}
+		}
+	}
+
+	@Override
+	// this is soooooo bad, but freaking gridbag somehow doesnt kick in...???
+	protected void paintComponent(Graphics g) {
+		scrollPane.setPreferredSize(new Dimension(getWidth() - 20, getHeight() - 30));
+		super.paintComponent(g);
+	}
+
+	/**
+	 * This method is called from within the constructor to initialize the form.
+	 * WARNING: Do NOT modify this code. The content of this method is always
+	 * regenerated by the Form Editor.
+	 */
+	@SuppressWarnings("unchecked")
+	// <editor-fold defaultstate="collapsed" desc="Generated
+	// Code">//GEN-BEGIN:initComponents
+	private void initComponents() {
+		java.awt.GridBagConstraints gridBagConstraints;
+
+		scrollPane = new javax.swing.JScrollPane();
+		contentPanel = new javax.swing.JPanel();
+
+		setBorder(javax.swing.BorderFactory.createTitledBorder("Values"));
+		setPreferredSize(new java.awt.Dimension(250, 115));
+		setLayout(new java.awt.GridBagLayout());
+
+		scrollPane.setBorder(null);
+		scrollPane.setHorizontalScrollBarPolicy(javax.swing.ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
+		scrollPane.setPreferredSize(new java.awt.Dimension(270, 180));
+
+		contentPanel.setPreferredSize(new java.awt.Dimension(100, 105));
+		contentPanel.setLayout(new java.awt.GridBagLayout());
+		scrollPane.setViewportView(contentPanel);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
+		gridBagConstraints.weightx = 1.0;
+		gridBagConstraints.weighty = 1.0;
+		add(scrollPane, gridBagConstraints);
+	}// </editor-fold>//GEN-END:initComponents
+
+	// Variables declaration - do not modify//GEN-BEGIN:variables
+	private javax.swing.JPanel contentPanel;
+	private javax.swing.JScrollPane scrollPane;
+	// End of variables declaration//GEN-END:variables
 
 }
diff --git a/moa/src/main/java/moa/gui/clustertab/ClusteringVisualTab.java b/moa/src/main/java/moa/gui/clustertab/ClusteringVisualTab.java
index 0389700c9..fbbb712bd 100644
--- a/moa/src/main/java/moa/gui/clustertab/ClusteringVisualTab.java
+++ b/moa/src/main/java/moa/gui/clustertab/ClusteringVisualTab.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.gui.clustertab;
@@ -28,6 +28,7 @@
 import javax.swing.JButton;
 import javax.swing.JComboBox;
 import javax.swing.JFileChooser;
+import javax.swing.SwingConstants;
 import javax.swing.ToolTipManager;
 
 import moa.gui.FileExtensionFilter;
@@ -36,729 +37,735 @@
 import moa.gui.visualization.StreamPanel;
 import nz.ac.waikato.cms.gui.core.BaseFileChooser;
 
-public class ClusteringVisualTab extends javax.swing.JPanel implements ActionListener{
+public class ClusteringVisualTab extends javax.swing.JPanel implements ActionListener {
 	private RunVisualizer visualizer = null;
-    private Thread visualizerThread = null;
-    private Boolean running = false;
-    private ClusteringSetupTab clusteringSetupTab = null;
-    private String exportFile;
-    private String screenshotFilebase;
-
-    /** Creates new form ClusteringVisualTab */
-    public ClusteringVisualTab() {
-        resetComponents();
-    }
-
-    private void resetComponents(){
-        initComponents();
-        comboY.setSelectedIndex(1);
-        graphCanvas.setViewport(graphScrollPanel.getViewport());
-
-        //TODO this needs to only affect the visual Panel
-        ToolTipManager.sharedInstance().setDismissDelay(20000);
-        ToolTipManager.sharedInstance().setInitialDelay(100);
-    }
-
-    public void setClusteringSetupTab(ClusteringSetupTab clusteringSetupTab){
-        this.clusteringSetupTab = clusteringSetupTab;
-    }
-
-
-    private void createVisualiterThread(){
-        visualizer = new RunVisualizer(this, clusteringSetupTab);
-        visualizerThread = new Thread(visualizer);
-    }
-
-    public void setDimensionComobBoxes(int numDimensions){
-        String[] dimensions = new String[numDimensions];
-        for (int i = 0; i < dimensions.length; i++) {
-            dimensions[i] = "Dim "+(i+1);
-
-        }
-        comboX.setModel(new javax.swing.DefaultComboBoxModel(dimensions));
-        comboY.setModel(new javax.swing.DefaultComboBoxModel(dimensions));
-        comboY.setSelectedIndex(1);
-    }
-
-    public StreamPanel getLeftStreamPanel(){
-        return streamPanel0;
-    }
-
-    public StreamPanel getRightStreamPanel(){
-        return streamPanel1;
-    }
-
-    public GraphCanvas getGraphCanvas(){
-        return graphCanvas;
-    }
-
-    public ClusteringVisualEvalPanel getEvalPanel(){
-        return clusteringVisualEvalPanel1;
-    }
-
-    public boolean isEnabledDrawPoints(){
-        return checkboxDrawPoints.isSelected();
-    }
-
-    public boolean isEnabledDrawGroundTruth(){
-        return checkboxDrawGT.isSelected();
-    }
-
-    public boolean isEnabledDrawMicroclustering(){
-        return checkboxDrawMicro.isSelected();
-    }
-    public boolean isEnabledDrawClustering(){
-        return checkboxDrawClustering.isSelected();
-    }
-
-    public void setProcessedPointsCounter(int value){
-        label_processed_points_value.setText(Integer.toString(value));
-    }
-
-    public int getPauseInterval(){
-        return Integer.parseInt(numPauseAfterPoints.getText());
-    }
-
-    public void setPauseInterval(int pause){
-        numPauseAfterPoints.setText(Integer.toString(pause));
-    }
-
-    @Override
-    public void repaint() {
-        if(splitVisual!=null)
-            splitVisual.setDividerLocation(splitVisual.getWidth()/2);
-        super.repaint();
-    }
-
-    public void toggleVisualizer(boolean internal){
-        if(visualizer == null)
-            createVisualiterThread();
-
-        if(!visualizerThread.isAlive()){
-            visualizerThread.start();
-
-        }
-        //pause
-        if(running){
-            running = false;
-            visualizer.pause();
-            buttonRun.setText("Resume");
-        }
-        else{
-            running = true;
-            visualizer.resume();
-            buttonRun.setText("Pause");
-        }
-        if(internal)
-            clusteringSetupTab.toggleRunMode();
-    }
-
-    public void stopVisualizer(){
-        visualizer.stop();
-        running = false;
-        visualizer = null;
-        visualizerThread = null;
-        removeAll();
-        resetComponents();
-    }
-
-
-    /** This method is called from within the constructor to
-     * initialize the form.
-     * WARNING: Do NOT modify this code. The content of this method is
-     * always regenerated by the Form Editor.
-     */
-    @SuppressWarnings("unchecked")
-    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
-    private void initComponents() {
-        java.awt.GridBagConstraints gridBagConstraints;
-
-        jSplitPane1 = new javax.swing.JSplitPane();
-        topWrapper = new javax.swing.JPanel();
-        panelVisualWrapper = new javax.swing.JPanel();
-        splitVisual = new javax.swing.JSplitPane();
-        scrollPane1 = new javax.swing.JScrollPane();
-        streamPanel1 = new moa.gui.visualization.StreamPanel();
-        scrollPane0 = new javax.swing.JScrollPane();
-        streamPanel0 = new moa.gui.visualization.StreamPanel();
-        panelControl = new javax.swing.JPanel();
-        buttonRun = new javax.swing.JButton();
-        buttonStop = new javax.swing.JButton();
-        buttonScreenshot = new javax.swing.JButton();
-        speedSlider = new javax.swing.JSlider();
-        jLabel1 = new javax.swing.JLabel();
-        comboX = new javax.swing.JComboBox();
-        labelX = new javax.swing.JLabel();
-        comboY = new javax.swing.JComboBox();
-        labelY = new javax.swing.JLabel();
-        checkboxDrawPoints = new javax.swing.JCheckBox();
-        checkboxDrawGT = new javax.swing.JCheckBox();
-        checkboxDrawMicro = new javax.swing.JCheckBox();
-        checkboxDrawClustering = new javax.swing.JCheckBox();
-        label_processed_points = new javax.swing.JLabel();
-        label_processed_points_value = new javax.swing.JLabel();
-        labelNumPause = new javax.swing.JLabel();
-        numPauseAfterPoints = new javax.swing.JTextField();
-        panelEvalOutput = new javax.swing.JPanel();
-        clusteringVisualEvalPanel1 = new moa.gui.clustertab.ClusteringVisualEvalPanel();
-        graphPanel = new javax.swing.JPanel();
-        graphPanelControlTop = new javax.swing.JPanel();
-        buttonZoomInY = new javax.swing.JButton();
-        buttonZoomOutY = new javax.swing.JButton();
-        labelEvents = new javax.swing.JLabel();
-        graphScrollPanel = new javax.swing.JScrollPane();
-        graphCanvas = new moa.gui.visualization.GraphCanvas();
-        graphPanelControlBottom = new javax.swing.JPanel();
-        buttonZoomInX = new javax.swing.JButton();
-        buttonZoomOutX = new javax.swing.JButton();
-
-        setLayout(new java.awt.GridBagLayout());
-
-        jSplitPane1.setDividerLocation(400);
-        jSplitPane1.setOrientation(javax.swing.JSplitPane.VERTICAL_SPLIT);
-
-        topWrapper.setPreferredSize(new java.awt.Dimension(688, 500));
-        topWrapper.setLayout(new java.awt.GridBagLayout());
-
-        panelVisualWrapper.setBorder(javax.swing.BorderFactory.createBevelBorder(javax.swing.border.BevelBorder.RAISED));
-        panelVisualWrapper.setLayout(new java.awt.BorderLayout());
-
-        splitVisual.setDividerLocation(403);
-        splitVisual.setResizeWeight(1.0);
-
-        streamPanel1.setPreferredSize(new java.awt.Dimension(400, 250));
-
-        javax.swing.GroupLayout streamPanel1Layout = new javax.swing.GroupLayout(streamPanel1);
-        streamPanel1.setLayout(streamPanel1Layout);
-        streamPanel1Layout.setHorizontalGroup(
-            streamPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 428, Short.MAX_VALUE)
-        );
-        streamPanel1Layout.setVerticalGroup(
-            streamPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 339, Short.MAX_VALUE)
-        );
-
-        scrollPane1.setViewportView(streamPanel1);
-
-        splitVisual.setRightComponent(scrollPane1);
-
-        scrollPane0.addMouseWheelListener(new java.awt.event.MouseWheelListener() {
-            public void mouseWheelMoved(java.awt.event.MouseWheelEvent evt) {
-                scrollPane0MouseWheelMoved(evt);
-            }
-        });
-
-        streamPanel0.setPreferredSize(new java.awt.Dimension(400, 250));
-
-        javax.swing.GroupLayout streamPanel0Layout = new javax.swing.GroupLayout(streamPanel0);
-        streamPanel0.setLayout(streamPanel0Layout);
-        streamPanel0Layout.setHorizontalGroup(
-            streamPanel0Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 400, Short.MAX_VALUE)
-        );
-        streamPanel0Layout.setVerticalGroup(
-            streamPanel0Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 339, Short.MAX_VALUE)
-        );
-
-        scrollPane0.setViewportView(streamPanel0);
-
-        splitVisual.setLeftComponent(scrollPane0);
-
-        panelVisualWrapper.add(splitVisual, java.awt.BorderLayout.CENTER);
-
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 1;
-        gridBagConstraints.gridheight = java.awt.GridBagConstraints.RELATIVE;
-        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
-        gridBagConstraints.ipadx = 400;
-        gridBagConstraints.ipady = 200;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
-        gridBagConstraints.weightx = 1.0;
-        gridBagConstraints.weighty = 1.0;
-        topWrapper.add(panelVisualWrapper, gridBagConstraints);
-
-        panelControl.setMinimumSize(new java.awt.Dimension(600, 76));
-        panelControl.setPreferredSize(new java.awt.Dimension(2000, 76));
-        panelControl.setLayout(new java.awt.GridBagLayout());
-
-        buttonRun.setText("Start");
-        buttonRun.setPreferredSize(new java.awt.Dimension(70, 33));
-        buttonRun.addMouseListener(new java.awt.event.MouseAdapter() {
-            public void mouseClicked(java.awt.event.MouseEvent evt) {
-                buttonRunMouseClicked(evt);
-            }
-        });
-        buttonRun.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonRunActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.insets = new java.awt.Insets(3, 5, 1, 5);
-        panelControl.add(buttonRun, gridBagConstraints);
-
-        buttonStop.setText("Stop");
-        buttonStop.setPreferredSize(new java.awt.Dimension(70, 33));
-        buttonStop.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonStopActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 1;
-        gridBagConstraints.insets = new java.awt.Insets(1, 5, 1, 5);
-        panelControl.add(buttonStop, gridBagConstraints);
-
-        buttonScreenshot.setText("Screenshot");
-        buttonScreenshot.setPreferredSize(new java.awt.Dimension(90, 23));
-        buttonScreenshot.addMouseListener(new java.awt.event.MouseAdapter() {
-            public void mouseClicked(java.awt.event.MouseEvent evt) {
-                buttonScreenshotMouseClicked(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 1;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.insets = new java.awt.Insets(3, 5, 1, 5);
-        // ### panelControl.add(buttonScreenshot, gridBagConstraints);
-
-        speedSlider.setValue(100);
-        speedSlider.setBorder(javax.swing.BorderFactory.createTitledBorder("Visualisation Speed"));
-        speedSlider.setMinimumSize(new java.awt.Dimension(150, 68));
-        speedSlider.setPreferredSize(new java.awt.Dimension(160, 68));
-        speedSlider.addMouseMotionListener(new java.awt.event.MouseMotionAdapter() {
-            public void mouseDragged(java.awt.event.MouseEvent evt) {
-                speedSliderMouseDragged(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 6;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.gridheight = 2;
-        gridBagConstraints.insets = new java.awt.Insets(0, 16, 1, 5);
-        panelControl.add(speedSlider, gridBagConstraints);
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 9;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.gridheight = 2;
-        gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
-        gridBagConstraints.weightx = 1.0;
-        panelControl.add(jLabel1, gridBagConstraints);        
-
-        comboX.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "Dim 1", "Dim 2", "Dim 3", "Dim 4" }));
-        comboX.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                comboXActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 3;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.insets = new java.awt.Insets(0, 4, 0, 4);
-        panelControl.add(comboX, gridBagConstraints);
-
-        labelX.setText("X");
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 2;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.insets = new java.awt.Insets(0, 14, 0, 5);
-        panelControl.add(labelX, gridBagConstraints);
-
-        comboY.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "Dim 1", "Dim 2", "Dim 3", "Dim 4" }));
-        comboY.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                comboYActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 3;
-        gridBagConstraints.gridy = 1;
-        gridBagConstraints.insets = new java.awt.Insets(0, 4, 0, 4);
-        panelControl.add(comboY, gridBagConstraints);
-
-        labelY.setText("Y");
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 2;
-        gridBagConstraints.gridy = 1;
-        gridBagConstraints.insets = new java.awt.Insets(0, 14, 0, 5);
-        panelControl.add(labelY, gridBagConstraints);
-
-        checkboxDrawPoints.setSelected(true);
-        checkboxDrawPoints.setText("Points");
-        checkboxDrawPoints.setMargin(new java.awt.Insets(0, 0, 0, 0));
-        checkboxDrawPoints.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                checkboxDrawPointsActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 4;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.SOUTHWEST;
-        gridBagConstraints.insets = new java.awt.Insets(0, 20, 0, 4);
-        panelControl.add(checkboxDrawPoints, gridBagConstraints);
-
-        checkboxDrawGT.setSelected(true);
-        checkboxDrawGT.setText("Ground truth");
-        checkboxDrawGT.setMargin(new java.awt.Insets(0, 0, 0, 0));
-        checkboxDrawGT.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                checkboxDrawGTActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 5;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.SOUTHWEST;
-        gridBagConstraints.insets = new java.awt.Insets(0, 4, 0, 4);
-        panelControl.add(checkboxDrawGT, gridBagConstraints);
-
-        checkboxDrawMicro.setSelected(true);
-        checkboxDrawMicro.setText("Microclustering");
-        checkboxDrawMicro.setMargin(new java.awt.Insets(0, 0, 0, 0));
-        checkboxDrawMicro.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                checkboxDrawMicroActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 4;
-        gridBagConstraints.gridy = 1;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
-        gridBagConstraints.insets = new java.awt.Insets(0, 20, 0, 4);
-        panelControl.add(checkboxDrawMicro, gridBagConstraints);
-
-        checkboxDrawClustering.setSelected(true);
-        checkboxDrawClustering.setText("Clustering");
-        checkboxDrawClustering.setMargin(new java.awt.Insets(0, 0, 0, 0));
-        checkboxDrawClustering.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                checkboxDrawClusteringActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 5;
-        gridBagConstraints.gridy = 1;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
-        gridBagConstraints.insets = new java.awt.Insets(0, 4, 0, 4);
-        panelControl.add(checkboxDrawClustering, gridBagConstraints);
-
-        label_processed_points.setText("Processed:");
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 7;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
-        gridBagConstraints.insets = new java.awt.Insets(0, 6, 0, 0);
-        panelControl.add(label_processed_points, gridBagConstraints);
-
-        label_processed_points_value.setText("0");
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 8;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
-        gridBagConstraints.weightx = 1.0;
-        panelControl.add(label_processed_points_value, gridBagConstraints);
-
-        labelNumPause.setText("Pause in:");
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 7;
-        gridBagConstraints.gridy = 1;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
-        gridBagConstraints.insets = new java.awt.Insets(0, 6, 0, 0);
-        panelControl.add(labelNumPause, gridBagConstraints);
-
-        numPauseAfterPoints.setHorizontalAlignment(javax.swing.JTextField.RIGHT);
-        numPauseAfterPoints.setText(Integer.toString(RunVisualizer.initialPauseInterval));
-        numPauseAfterPoints.setMinimumSize(new java.awt.Dimension(70, 25));
-        numPauseAfterPoints.setPreferredSize(new java.awt.Dimension(70, 25));
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 8;
-        gridBagConstraints.gridy = 1;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
-        panelControl.add(numPauseAfterPoints, gridBagConstraints);
-        
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
-        gridBagConstraints.weightx = 1.0;
-        topWrapper.add(panelControl, gridBagConstraints);
-
-        jSplitPane1.setLeftComponent(topWrapper);
-
-        panelEvalOutput.setBorder(javax.swing.BorderFactory.createTitledBorder("Evaluation"));
-        panelEvalOutput.setLayout(new java.awt.GridBagLayout());
-
-        clusteringVisualEvalPanel1.setMinimumSize(new java.awt.Dimension(280, 118));
-        clusteringVisualEvalPanel1.setPreferredSize(new java.awt.Dimension(290, 115));
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
-        gridBagConstraints.weighty = 1.0;
-        panelEvalOutput.add(clusteringVisualEvalPanel1, gridBagConstraints);
-
-        graphPanel.setBorder(javax.swing.BorderFactory.createTitledBorder("Plot"));
-        graphPanel.setPreferredSize(new java.awt.Dimension(530, 115));
-        graphPanel.setLayout(new java.awt.GridBagLayout());
-
-        graphPanelControlTop.setLayout(new java.awt.GridBagLayout());
-
-        buttonZoomInY.setText("Zoom in Y");
-        buttonZoomInY.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonZoomInYActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
-        graphPanelControlTop.add(buttonZoomInY, gridBagConstraints);
-
-        buttonZoomOutY.setText("Zoom out Y");
-        buttonZoomOutY.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonZoomOutYActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
-        graphPanelControlTop.add(buttonZoomOutY, gridBagConstraints);
-
-        labelEvents.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
-        gridBagConstraints.weightx = 1.0;
-        gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
-        graphPanelControlTop.add(labelEvents, gridBagConstraints);
-
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
-        gridBagConstraints.weightx = 1.0;
-        graphPanel.add(graphPanelControlTop, gridBagConstraints);
-
-        graphCanvas.setPreferredSize(new java.awt.Dimension(500, 111));
-
-        javax.swing.GroupLayout graphCanvasLayout = new javax.swing.GroupLayout(graphCanvas);
-        graphCanvas.setLayout(graphCanvasLayout);
-        graphCanvasLayout.setHorizontalGroup(
-            graphCanvasLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 515, Short.MAX_VALUE)
-        );
-        graphCanvasLayout.setVerticalGroup(
-            graphCanvasLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 128, Short.MAX_VALUE)
-        );
-
-        graphScrollPanel.setViewportView(graphCanvas);
-
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 1;
-        gridBagConstraints.gridwidth = 2;
-        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
-        gridBagConstraints.weightx = 1.0;
-        gridBagConstraints.weighty = 1.0;
-        gridBagConstraints.insets = new java.awt.Insets(2, 2, 2, 2);
-        graphPanel.add(graphScrollPanel, gridBagConstraints);
-
-        buttonZoomInX.setText("Zoom in X");
-        buttonZoomInX.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonZoomInXActionPerformed(evt);
-            }
-        });
-        graphPanelControlBottom.add(buttonZoomInX);
-
-        buttonZoomOutX.setText("Zoom out X");
-        buttonZoomOutX.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonZoomOutXActionPerformed(evt);
-            }
-        });
-        graphPanelControlBottom.add(buttonZoomOutX);
-
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 1;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
-        graphPanel.add(graphPanelControlBottom, gridBagConstraints);
-
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
-        gridBagConstraints.weightx = 2.0;
-        gridBagConstraints.weighty = 1.0;
-        panelEvalOutput.add(graphPanel, gridBagConstraints);
-
-        jSplitPane1.setRightComponent(panelEvalOutput);
-
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
-        gridBagConstraints.weightx = 1.0;
-        gridBagConstraints.weighty = 1.0;
-        add(jSplitPane1, gridBagConstraints);
-    }// </editor-fold>//GEN-END:initComponents
-
-    private void buttonScreenshotMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_buttonScreenshotMouseClicked
-        BaseFileChooser fileChooser = new BaseFileChooser();
-        fileChooser.setAcceptAllFileFilterUsed(true);
-        if(screenshotFilebase!=null)
-            fileChooser.setSelectedFile(new File(screenshotFilebase));
-        if (fileChooser.showSaveDialog(this) == BaseFileChooser.APPROVE_OPTION) {
-        	screenshotFilebase = fileChooser.getSelectedFile().getPath();
-        	streamPanel0.screenshot(screenshotFilebase+"_"+label_processed_points_value.getText()+"_0", true, true);
-            streamPanel1.screenshot(screenshotFilebase+"_"+label_processed_points_value.getText()+"_1", true, true);
-        }
-
-    }//GEN-LAST:event_buttonScreenshotMouseClicked
-
-    private void buttonRunMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_buttonRunMouseClicked
-        toggleVisualizer(true);
-    }//GEN-LAST:event_buttonRunMouseClicked
-
-    private void speedSliderMouseDragged(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_speedSliderMouseDragged
-        visualizer.setSpeed((int)(speedSlider.getValue()/(100.0/15.0)));
-
-    }//GEN-LAST:event_speedSliderMouseDragged
-
-    private void scrollPane0MouseWheelMoved(java.awt.event.MouseWheelEvent evt) {//GEN-FIRST:event_scrollPane0MouseWheelMoved
-        streamPanel0.setZoom(evt.getX(),evt.getY(),(-1)*evt.getWheelRotation(),scrollPane0);
-    }//GEN-LAST:event_scrollPane0MouseWheelMoved
-
-    private void buttonZoomInXActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonZoomInXActionPerformed
-        graphCanvas.scaleXResolution(false);
-    }//GEN-LAST:event_buttonZoomInXActionPerformed
-
-    private void buttonZoomOutYActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonZoomOutYActionPerformed
-        graphCanvas.setSize(new Dimension(graphCanvas.getWidth(), (int)(graphCanvas.getHeight()*0.8)));
-        graphCanvas.setPreferredSize(new Dimension(graphCanvas.getWidth(), (int)(graphCanvas.getHeight()*0.8)));
-    }//GEN-LAST:event_buttonZoomOutYActionPerformed
-
-    private void buttonZoomOutXActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonZoomOutXActionPerformed
-        graphCanvas.scaleXResolution(true);
-    }//GEN-LAST:event_buttonZoomOutXActionPerformed
-
-    private void buttonZoomInYActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonZoomInYActionPerformed
-        graphCanvas.setSize(new Dimension(graphCanvas.getWidth(), (int)(graphCanvas.getHeight()*1.2)));
-        graphCanvas.setPreferredSize(new Dimension(graphCanvas.getWidth(), (int)(graphCanvas.getHeight()*1.2)));
-    }//GEN-LAST:event_buttonZoomInYActionPerformed
-
-    private void checkboxDrawPointsActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_checkboxDrawPointsActionPerformed
-        visualizer.setPointLayerVisibility(checkboxDrawPoints.isSelected());
-    }//GEN-LAST:event_checkboxDrawPointsActionPerformed
-
-    private void checkboxDrawMicroActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_checkboxDrawMicroActionPerformed
-        //visualizer.redrawClusterings();
-        visualizer.setMicroLayerVisibility(checkboxDrawMicro.isSelected());
-    }//GEN-LAST:event_checkboxDrawMicroActionPerformed
-
-    private void checkboxDrawGTActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_checkboxDrawGTActionPerformed
-        //visualizer.redrawClusterings();
-        visualizer.setGroundTruthVisibility(checkboxDrawGT.isSelected());
-    }//GEN-LAST:event_checkboxDrawGTActionPerformed
-
-    private void checkboxDrawClusteringActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_checkboxDrawClusteringActionPerformed
-        //visualizer.redrawClusterings();
-        visualizer.setMacroVisibility(checkboxDrawClustering.isSelected());
-    }//GEN-LAST:event_checkboxDrawClusteringActionPerformed
-
-    private void comboXActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_comboXActionPerformed
-        JComboBox cb = (JComboBox)evt.getSource();
-        int dim = cb.getSelectedIndex();
-        streamPanel0.setActiveXDim(dim);
-        streamPanel1.setActiveXDim(dim);
-        if(visualizer!=null)
-            visualizer.redraw();
-    }//GEN-LAST:event_comboXActionPerformed
-
-    private void comboYActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_comboYActionPerformed
-        JComboBox cb = (JComboBox)evt.getSource();
-        int dim = cb.getSelectedIndex();
-        streamPanel0.setActiveYDim(dim);
-        streamPanel1.setActiveYDim(dim);
-        if(visualizer!=null)
-            visualizer.redraw();
-    }//GEN-LAST:event_comboYActionPerformed
-
-    private void buttonStopActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonStopActionPerformed
-        stopVisualizer();
-        clusteringSetupTab.stopRun();
-    }//GEN-LAST:event_buttonStopActionPerformed
-
-    private void buttonRunActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonRunActionPerformed
-        // TODO add your handling code here:
-    }//GEN-LAST:event_buttonRunActionPerformed
-
-
-    // Variables declaration - do not modify//GEN-BEGIN:variables
-    private javax.swing.JButton buttonRun;
-    private javax.swing.JButton buttonScreenshot;
-    private javax.swing.JButton buttonStop;
-    private javax.swing.JButton buttonZoomInX;
-    private javax.swing.JButton buttonZoomInY;
-    private javax.swing.JButton buttonZoomOutX;
-    private javax.swing.JButton buttonZoomOutY;
-    private javax.swing.JCheckBox checkboxDrawClustering;
-    private javax.swing.JCheckBox checkboxDrawGT;
-    private javax.swing.JCheckBox checkboxDrawMicro;
-    private javax.swing.JCheckBox checkboxDrawPoints;
-    private moa.gui.clustertab.ClusteringVisualEvalPanel clusteringVisualEvalPanel1;
-    private javax.swing.JComboBox comboX;
-    private javax.swing.JComboBox comboY;
-    private moa.gui.visualization.GraphCanvas graphCanvas;
-    private javax.swing.JPanel graphPanel;
-    private javax.swing.JPanel graphPanelControlBottom;
-    private javax.swing.JPanel graphPanelControlTop;
-    private javax.swing.JScrollPane graphScrollPanel;
-    private javax.swing.JLabel jLabel1;
-    private javax.swing.JSplitPane jSplitPane1;
-    private javax.swing.JLabel labelEvents;
-    private javax.swing.JLabel labelNumPause;
-    private javax.swing.JLabel labelX;
-    private javax.swing.JLabel labelY;
-    private javax.swing.JLabel label_processed_points;
-    private javax.swing.JLabel label_processed_points_value;
-    private javax.swing.JTextField numPauseAfterPoints;
-    private javax.swing.JPanel panelControl;
-    private javax.swing.JPanel panelEvalOutput;
-    private javax.swing.JPanel panelVisualWrapper;
-    private javax.swing.JScrollPane scrollPane0;
-    private javax.swing.JScrollPane scrollPane1;
-    private javax.swing.JSlider speedSlider;
-    private javax.swing.JSplitPane splitVisual;
-    private moa.gui.visualization.StreamPanel streamPanel0;
-    private moa.gui.visualization.StreamPanel streamPanel1;
-    private javax.swing.JPanel topWrapper;
-    // End of variables declaration//GEN-END:variables
-
-    public void actionPerformed(ActionEvent e) {
-        if(e.getSource() instanceof JButton){
-            if(e.getActionCommand().equals("csv export")){
-                JFileChooser fileChooser = new JFileChooser();
-                fileChooser.setAcceptAllFileFilterUsed(true);
-                fileChooser.addChoosableFileFilter(new FileExtensionFilter("csv"));
-                if(exportFile!=null)
-                    fileChooser.setSelectedFile(new File(exportFile));
-                if (fileChooser.showSaveDialog(this) == JFileChooser.APPROVE_OPTION) {
-                    exportFile = fileChooser.getSelectedFile().getPath();
-                    visualizer.exportCSV(exportFile);
-                }
-            }
-            if(e.getActionCommand().equals("weka export")){
-                visualizer.weka();
-            }
-        }
-    }
+	private Thread visualizerThread = null;
+	private Boolean running = false;
+	private ClusteringSetupTab clusteringSetupTab = null;
+	private String exportFile;
+	private String screenshotFilebase;
+
+	/** Creates new form ClusteringVisualTab */
+	public ClusteringVisualTab() {
+		resetComponents();
+	}
+
+	private void resetComponents() {
+		initComponents();
+		comboY.setSelectedIndex(1);
+		graphCanvas.setViewport(graphScrollPanel.getViewport());
+
+		// TODO this needs to only affect the visual Panel
+		ToolTipManager.sharedInstance().setDismissDelay(20000);
+		ToolTipManager.sharedInstance().setInitialDelay(100);
+	}
+
+	public void setClusteringSetupTab(ClusteringSetupTab clusteringSetupTab) {
+		this.clusteringSetupTab = clusteringSetupTab;
+	}
+
+	private void createVisualiterThread() {
+		visualizer = new RunVisualizer(this, clusteringSetupTab);
+		visualizerThread = new Thread(visualizer);
+	}
+
+	public void setDimensionComobBoxes(int numDimensions) {
+		String[] dimensions = new String[numDimensions];
+		for (int i = 0; i < dimensions.length; i++) {
+			dimensions[i] = "Dim " + (i + 1);
+
+		}
+		comboX.setModel(new javax.swing.DefaultComboBoxModel(dimensions));
+		comboY.setModel(new javax.swing.DefaultComboBoxModel(dimensions));
+		comboY.setSelectedIndex(1);
+	}
+
+	public StreamPanel getLeftStreamPanel() {
+		return streamPanel0;
+	}
+
+	public StreamPanel getRightStreamPanel() {
+		return streamPanel1;
+	}
+
+	public GraphCanvas getGraphCanvas() {
+		return graphCanvas;
+	}
+
+	public ClusteringVisualEvalPanel getEvalPanel() {
+		return clusteringVisualEvalPanel1;
+	}
+
+	public boolean isEnabledDrawPoints() {
+		return checkboxDrawPoints.isSelected();
+	}
+
+	public boolean isEnabledDrawGroundTruth() {
+		return checkboxDrawGT.isSelected();
+	}
+
+	public boolean isEnabledDrawMicroclustering() {
+		return checkboxDrawMicro.isSelected();
+	}
+
+	public boolean isEnabledDrawClustering() {
+		return checkboxDrawClustering.isSelected();
+	}
+
+	public void setProcessedPointsCounter(int value) {
+		label_processed_points_value.setText(Integer.toString(value));
+	}
+
+	public int getPauseInterval() {
+		return Integer.parseInt(numPauseAfterPoints.getText());
+	}
+
+	public void setPauseInterval(int pause) {
+		numPauseAfterPoints.setText(Integer.toString(pause));
+	}
+
+	@Override
+	public void repaint() {
+		if (splitVisual != null)
+			splitVisual.setDividerLocation(splitVisual.getWidth() / 2);
+		super.repaint();
+	}
+
+	public void toggleVisualizer(boolean internal) {
+		if (visualizer == null)
+			createVisualiterThread();
+
+		if (!visualizerThread.isAlive()) {
+			visualizerThread.start();
+
+		}
+		// pause
+		if (running) {
+			running = false;
+			RunVisualizer.pause();
+			buttonRun.setText("Resume");
+		} else {
+			running = true;
+			RunVisualizer.resume();
+			buttonRun.setText("Pause");
+		}
+		if (internal)
+			clusteringSetupTab.toggleRunMode();
+	}
+
+	public void stopVisualizer() {
+		visualizer.stop();
+		running = false;
+		visualizer = null;
+		visualizerThread = null;
+		removeAll();
+		resetComponents();
+	}
+
+	/**
+	 * This method is called from within the constructor to initialize the form.
+	 * WARNING: Do NOT modify this code. The content of this method is always
+	 * regenerated by the Form Editor.
+	 */
+	@SuppressWarnings("unchecked")
+	// <editor-fold defaultstate="collapsed" desc="Generated
+	// Code">//GEN-BEGIN:initComponents
+	private void initComponents() {
+		java.awt.GridBagConstraints gridBagConstraints;
+
+		jSplitPane1 = new javax.swing.JSplitPane();
+		topWrapper = new javax.swing.JPanel();
+		panelVisualWrapper = new javax.swing.JPanel();
+		splitVisual = new javax.swing.JSplitPane();
+		scrollPane1 = new javax.swing.JScrollPane();
+		streamPanel1 = new moa.gui.visualization.StreamPanel();
+		scrollPane0 = new javax.swing.JScrollPane();
+		streamPanel0 = new moa.gui.visualization.StreamPanel();
+		panelControl = new javax.swing.JPanel();
+		buttonRun = new javax.swing.JButton();
+		buttonStop = new javax.swing.JButton();
+		buttonScreenshot = new javax.swing.JButton();
+		speedSlider = new javax.swing.JSlider();
+		jLabel1 = new javax.swing.JLabel();
+		comboX = new javax.swing.JComboBox();
+		labelX = new javax.swing.JLabel();
+		comboY = new javax.swing.JComboBox();
+		labelY = new javax.swing.JLabel();
+		checkboxDrawPoints = new javax.swing.JCheckBox();
+		checkboxDrawGT = new javax.swing.JCheckBox();
+		checkboxDrawMicro = new javax.swing.JCheckBox();
+		checkboxDrawClustering = new javax.swing.JCheckBox();
+		label_processed_points = new javax.swing.JLabel();
+		label_processed_points_value = new javax.swing.JLabel();
+		labelNumPause = new javax.swing.JLabel();
+		numPauseAfterPoints = new javax.swing.JTextField();
+		panelEvalOutput = new javax.swing.JPanel();
+		clusteringVisualEvalPanel1 = new moa.gui.clustertab.ClusteringVisualEvalPanel();
+		graphPanel = new javax.swing.JPanel();
+		graphPanelControlTop = new javax.swing.JPanel();
+		buttonZoomInY = new javax.swing.JButton();
+		buttonZoomOutY = new javax.swing.JButton();
+		labelEvents = new javax.swing.JLabel();
+		graphScrollPanel = new javax.swing.JScrollPane();
+		graphCanvas = new moa.gui.visualization.GraphCanvas();
+		graphPanelControlBottom = new javax.swing.JPanel();
+		buttonZoomInX = new javax.swing.JButton();
+		buttonZoomOutX = new javax.swing.JButton();
+
+		setLayout(new java.awt.GridBagLayout());
+
+		jSplitPane1.setDividerLocation(400);
+		jSplitPane1.setOrientation(javax.swing.JSplitPane.VERTICAL_SPLIT);
+
+		topWrapper.setPreferredSize(new java.awt.Dimension(688, 500));
+		topWrapper.setLayout(new java.awt.GridBagLayout());
+
+		panelVisualWrapper
+				.setBorder(javax.swing.BorderFactory.createBevelBorder(javax.swing.border.BevelBorder.RAISED));
+		panelVisualWrapper.setLayout(new java.awt.BorderLayout());
+
+		splitVisual.setDividerLocation(403);
+		splitVisual.setResizeWeight(1.0);
+
+		streamPanel1.setPreferredSize(new java.awt.Dimension(400, 250));
+
+		javax.swing.GroupLayout streamPanel1Layout = new javax.swing.GroupLayout(streamPanel1);
+		streamPanel1.setLayout(streamPanel1Layout);
+		streamPanel1Layout.setHorizontalGroup(streamPanel1Layout
+				.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 428, Short.MAX_VALUE));
+		streamPanel1Layout.setVerticalGroup(streamPanel1Layout
+				.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 339, Short.MAX_VALUE));
+
+		scrollPane1.setViewportView(streamPanel1);
+
+		splitVisual.setRightComponent(scrollPane1);
+
+		scrollPane0.addMouseWheelListener(new java.awt.event.MouseWheelListener() {
+			@Override
+			public void mouseWheelMoved(java.awt.event.MouseWheelEvent evt) {
+				scrollPane0MouseWheelMoved(evt);
+			}
+		});
+
+		streamPanel0.setPreferredSize(new java.awt.Dimension(400, 250));
+
+		javax.swing.GroupLayout streamPanel0Layout = new javax.swing.GroupLayout(streamPanel0);
+		streamPanel0.setLayout(streamPanel0Layout);
+		streamPanel0Layout.setHorizontalGroup(streamPanel0Layout
+				.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 400, Short.MAX_VALUE));
+		streamPanel0Layout.setVerticalGroup(streamPanel0Layout
+				.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 339, Short.MAX_VALUE));
+
+		scrollPane0.setViewportView(streamPanel0);
+
+		splitVisual.setLeftComponent(scrollPane0);
+
+		panelVisualWrapper.add(splitVisual, java.awt.BorderLayout.CENTER);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 1;
+		gridBagConstraints.gridheight = java.awt.GridBagConstraints.RELATIVE;
+		gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
+		gridBagConstraints.ipadx = 400;
+		gridBagConstraints.ipady = 200;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
+		gridBagConstraints.weightx = 1.0;
+		gridBagConstraints.weighty = 1.0;
+		topWrapper.add(panelVisualWrapper, gridBagConstraints);
+
+		panelControl.setMinimumSize(new java.awt.Dimension(600, 76));
+		panelControl.setPreferredSize(new java.awt.Dimension(2000, 76));
+		panelControl.setLayout(new java.awt.GridBagLayout());
+
+		buttonRun.setText("Start");
+		buttonRun.setPreferredSize(new java.awt.Dimension(70, 33));
+		buttonRun.addMouseListener(new java.awt.event.MouseAdapter() {
+			@Override
+			public void mouseClicked(java.awt.event.MouseEvent evt) {
+				buttonRunMouseClicked(evt);
+			}
+		});
+		buttonRun.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonRunActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.insets = new java.awt.Insets(3, 5, 1, 5);
+		panelControl.add(buttonRun, gridBagConstraints);
+
+		buttonStop.setText("Stop");
+		buttonStop.setPreferredSize(new java.awt.Dimension(70, 33));
+		buttonStop.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonStopActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 1;
+		gridBagConstraints.insets = new java.awt.Insets(1, 5, 1, 5);
+		panelControl.add(buttonStop, gridBagConstraints);
+
+		buttonScreenshot.setText("Screenshot");
+		buttonScreenshot.setPreferredSize(new java.awt.Dimension(90, 23));
+		buttonScreenshot.addMouseListener(new java.awt.event.MouseAdapter() {
+			@Override
+			public void mouseClicked(java.awt.event.MouseEvent evt) {
+				buttonScreenshotMouseClicked(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 1;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.insets = new java.awt.Insets(3, 5, 1, 5);
+		// ### panelControl.add(buttonScreenshot, gridBagConstraints);
+
+		speedSlider.setValue(100);
+		speedSlider.setBorder(javax.swing.BorderFactory.createTitledBorder("Visualisation Speed"));
+		speedSlider.setMinimumSize(new java.awt.Dimension(150, 68));
+		speedSlider.setPreferredSize(new java.awt.Dimension(160, 68));
+		speedSlider.addMouseMotionListener(new java.awt.event.MouseMotionAdapter() {
+			@Override
+			public void mouseDragged(java.awt.event.MouseEvent evt) {
+				speedSliderMouseDragged(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 6;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.gridheight = 2;
+		gridBagConstraints.insets = new java.awt.Insets(0, 16, 1, 5);
+		panelControl.add(speedSlider, gridBagConstraints);
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 9;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.gridheight = 2;
+		gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
+		gridBagConstraints.weightx = 1.0;
+		panelControl.add(jLabel1, gridBagConstraints);
+
+		comboX.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "Dim 1", "Dim 2", "Dim 3", "Dim 4" }));
+		comboX.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				comboXActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 3;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.insets = new java.awt.Insets(0, 4, 0, 4);
+		panelControl.add(comboX, gridBagConstraints);
+
+		labelX.setText("X");
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 2;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.insets = new java.awt.Insets(0, 14, 0, 5);
+		panelControl.add(labelX, gridBagConstraints);
+
+		comboY.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "Dim 1", "Dim 2", "Dim 3", "Dim 4" }));
+		comboY.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				comboYActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 3;
+		gridBagConstraints.gridy = 1;
+		gridBagConstraints.insets = new java.awt.Insets(0, 4, 0, 4);
+		panelControl.add(comboY, gridBagConstraints);
+
+		labelY.setText("Y");
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 2;
+		gridBagConstraints.gridy = 1;
+		gridBagConstraints.insets = new java.awt.Insets(0, 14, 0, 5);
+		panelControl.add(labelY, gridBagConstraints);
+
+		checkboxDrawPoints.setSelected(true);
+		checkboxDrawPoints.setText("Points");
+		checkboxDrawPoints.setMargin(new java.awt.Insets(0, 0, 0, 0));
+		checkboxDrawPoints.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				checkboxDrawPointsActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 4;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.SOUTHWEST;
+		gridBagConstraints.insets = new java.awt.Insets(0, 20, 0, 4);
+		panelControl.add(checkboxDrawPoints, gridBagConstraints);
+
+		checkboxDrawGT.setSelected(true);
+		checkboxDrawGT.setText("Ground truth");
+		checkboxDrawGT.setMargin(new java.awt.Insets(0, 0, 0, 0));
+		checkboxDrawGT.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				checkboxDrawGTActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 5;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.SOUTHWEST;
+		gridBagConstraints.insets = new java.awt.Insets(0, 4, 0, 4);
+		panelControl.add(checkboxDrawGT, gridBagConstraints);
+
+		checkboxDrawMicro.setSelected(true);
+		checkboxDrawMicro.setText("Microclustering");
+		checkboxDrawMicro.setMargin(new java.awt.Insets(0, 0, 0, 0));
+		checkboxDrawMicro.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				checkboxDrawMicroActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 4;
+		gridBagConstraints.gridy = 1;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
+		gridBagConstraints.insets = new java.awt.Insets(0, 20, 0, 4);
+		panelControl.add(checkboxDrawMicro, gridBagConstraints);
+
+		checkboxDrawClustering.setSelected(true);
+		checkboxDrawClustering.setText("Clustering");
+		checkboxDrawClustering.setMargin(new java.awt.Insets(0, 0, 0, 0));
+		checkboxDrawClustering.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				checkboxDrawClusteringActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 5;
+		gridBagConstraints.gridy = 1;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
+		gridBagConstraints.insets = new java.awt.Insets(0, 4, 0, 4);
+		panelControl.add(checkboxDrawClustering, gridBagConstraints);
+
+		label_processed_points.setText("Processed:");
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 7;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
+		gridBagConstraints.insets = new java.awt.Insets(0, 6, 0, 0);
+		panelControl.add(label_processed_points, gridBagConstraints);
+
+		label_processed_points_value.setText("0");
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 8;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
+		gridBagConstraints.weightx = 1.0;
+		panelControl.add(label_processed_points_value, gridBagConstraints);
+
+		labelNumPause.setText("Pause in:");
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 7;
+		gridBagConstraints.gridy = 1;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
+		gridBagConstraints.insets = new java.awt.Insets(0, 6, 0, 0);
+		panelControl.add(labelNumPause, gridBagConstraints);
+
+		numPauseAfterPoints.setHorizontalAlignment(SwingConstants.RIGHT);
+		numPauseAfterPoints.setText(Integer.toString(RunVisualizer.initialPauseInterval));
+		numPauseAfterPoints.setMinimumSize(new java.awt.Dimension(70, 25));
+		numPauseAfterPoints.setPreferredSize(new java.awt.Dimension(70, 25));
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 8;
+		gridBagConstraints.gridy = 1;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
+		panelControl.add(numPauseAfterPoints, gridBagConstraints);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
+		gridBagConstraints.weightx = 1.0;
+		topWrapper.add(panelControl, gridBagConstraints);
+
+		jSplitPane1.setLeftComponent(topWrapper);
+
+		panelEvalOutput.setBorder(javax.swing.BorderFactory.createTitledBorder("Evaluation"));
+		panelEvalOutput.setLayout(new java.awt.GridBagLayout());
+
+		clusteringVisualEvalPanel1.setMinimumSize(new java.awt.Dimension(280, 118));
+		clusteringVisualEvalPanel1.setPreferredSize(new java.awt.Dimension(290, 115));
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
+		gridBagConstraints.weighty = 1.0;
+		panelEvalOutput.add(clusteringVisualEvalPanel1, gridBagConstraints);
+
+		graphPanel.setBorder(javax.swing.BorderFactory.createTitledBorder("Plot"));
+		graphPanel.setPreferredSize(new java.awt.Dimension(530, 115));
+		graphPanel.setLayout(new java.awt.GridBagLayout());
+
+		graphPanelControlTop.setLayout(new java.awt.GridBagLayout());
+
+		buttonZoomInY.setText("Zoom in Y");
+		buttonZoomInY.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonZoomInYActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
+		graphPanelControlTop.add(buttonZoomInY, gridBagConstraints);
+
+		buttonZoomOutY.setText("Zoom out Y");
+		buttonZoomOutY.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonZoomOutYActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
+		graphPanelControlTop.add(buttonZoomOutY, gridBagConstraints);
+
+		labelEvents.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
+		gridBagConstraints.weightx = 1.0;
+		gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
+		graphPanelControlTop.add(labelEvents, gridBagConstraints);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
+		gridBagConstraints.weightx = 1.0;
+		graphPanel.add(graphPanelControlTop, gridBagConstraints);
+
+		graphCanvas.setPreferredSize(new java.awt.Dimension(500, 111));
+
+		javax.swing.GroupLayout graphCanvasLayout = new javax.swing.GroupLayout(graphCanvas);
+		graphCanvas.setLayout(graphCanvasLayout);
+		graphCanvasLayout.setHorizontalGroup(graphCanvasLayout
+				.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 515, Short.MAX_VALUE));
+		graphCanvasLayout.setVerticalGroup(graphCanvasLayout
+				.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 128, Short.MAX_VALUE));
+
+		graphScrollPanel.setViewportView(graphCanvas);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 1;
+		gridBagConstraints.gridwidth = 2;
+		gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
+		gridBagConstraints.weightx = 1.0;
+		gridBagConstraints.weighty = 1.0;
+		gridBagConstraints.insets = new java.awt.Insets(2, 2, 2, 2);
+		graphPanel.add(graphScrollPanel, gridBagConstraints);
+
+		buttonZoomInX.setText("Zoom in X");
+		buttonZoomInX.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonZoomInXActionPerformed(evt);
+			}
+		});
+		graphPanelControlBottom.add(buttonZoomInX);
+
+		buttonZoomOutX.setText("Zoom out X");
+		buttonZoomOutX.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonZoomOutXActionPerformed(evt);
+			}
+		});
+		graphPanelControlBottom.add(buttonZoomOutX);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 1;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
+		graphPanel.add(graphPanelControlBottom, gridBagConstraints);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
+		gridBagConstraints.weightx = 2.0;
+		gridBagConstraints.weighty = 1.0;
+		panelEvalOutput.add(graphPanel, gridBagConstraints);
+
+		jSplitPane1.setRightComponent(panelEvalOutput);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
+		gridBagConstraints.weightx = 1.0;
+		gridBagConstraints.weighty = 1.0;
+		add(jSplitPane1, gridBagConstraints);
+	}// </editor-fold>//GEN-END:initComponents
+
+	private void buttonScreenshotMouseClicked(java.awt.event.MouseEvent evt) {// GEN-FIRST:event_buttonScreenshotMouseClicked
+		BaseFileChooser fileChooser = new BaseFileChooser();
+		fileChooser.setAcceptAllFileFilterUsed(true);
+		if (screenshotFilebase != null)
+			fileChooser.setSelectedFile(new File(screenshotFilebase));
+		if (fileChooser.showSaveDialog(this) == JFileChooser.APPROVE_OPTION) {
+			screenshotFilebase = fileChooser.getSelectedFile().getPath();
+			streamPanel0.screenshot(screenshotFilebase + "_" + label_processed_points_value.getText() + "_0", true,
+					true);
+			streamPanel1.screenshot(screenshotFilebase + "_" + label_processed_points_value.getText() + "_1", true,
+					true);
+		}
+
+	}// GEN-LAST:event_buttonScreenshotMouseClicked
+
+	private void buttonRunMouseClicked(java.awt.event.MouseEvent evt) {// GEN-FIRST:event_buttonRunMouseClicked
+		toggleVisualizer(true);
+	}// GEN-LAST:event_buttonRunMouseClicked
+
+	private void speedSliderMouseDragged(java.awt.event.MouseEvent evt) {// GEN-FIRST:event_speedSliderMouseDragged
+		visualizer.setSpeed((int) (speedSlider.getValue() / (100.0 / 15.0)));
+
+	}// GEN-LAST:event_speedSliderMouseDragged
+
+	private void scrollPane0MouseWheelMoved(java.awt.event.MouseWheelEvent evt) {// GEN-FIRST:event_scrollPane0MouseWheelMoved
+		streamPanel0.setZoom(evt.getX(), evt.getY(), (-1) * evt.getWheelRotation(), scrollPane0);
+	}// GEN-LAST:event_scrollPane0MouseWheelMoved
+
+	private void buttonZoomInXActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonZoomInXActionPerformed
+		graphCanvas.scaleXResolution(false);
+	}// GEN-LAST:event_buttonZoomInXActionPerformed
+
+	private void buttonZoomOutYActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonZoomOutYActionPerformed
+		graphCanvas.setSize(new Dimension(graphCanvas.getWidth(), (int) (graphCanvas.getHeight() * 0.8)));
+		graphCanvas.setPreferredSize(new Dimension(graphCanvas.getWidth(), (int) (graphCanvas.getHeight() * 0.8)));
+	}// GEN-LAST:event_buttonZoomOutYActionPerformed
+
+	private void buttonZoomOutXActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonZoomOutXActionPerformed
+		graphCanvas.scaleXResolution(true);
+	}// GEN-LAST:event_buttonZoomOutXActionPerformed
+
+	private void buttonZoomInYActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonZoomInYActionPerformed
+		graphCanvas.setSize(new Dimension(graphCanvas.getWidth(), (int) (graphCanvas.getHeight() * 1.2)));
+		graphCanvas.setPreferredSize(new Dimension(graphCanvas.getWidth(), (int) (graphCanvas.getHeight() * 1.2)));
+	}// GEN-LAST:event_buttonZoomInYActionPerformed
+
+	private void checkboxDrawPointsActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_checkboxDrawPointsActionPerformed
+		visualizer.setPointLayerVisibility(checkboxDrawPoints.isSelected());
+	}// GEN-LAST:event_checkboxDrawPointsActionPerformed
+
+	private void checkboxDrawMicroActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_checkboxDrawMicroActionPerformed
+		// visualizer.redrawClusterings();
+		visualizer.setMicroLayerVisibility(checkboxDrawMicro.isSelected());
+	}// GEN-LAST:event_checkboxDrawMicroActionPerformed
+
+	private void checkboxDrawGTActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_checkboxDrawGTActionPerformed
+		// visualizer.redrawClusterings();
+		visualizer.setGroundTruthVisibility(checkboxDrawGT.isSelected());
+	}// GEN-LAST:event_checkboxDrawGTActionPerformed
+
+	private void checkboxDrawClusteringActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_checkboxDrawClusteringActionPerformed
+		// visualizer.redrawClusterings();
+		visualizer.setMacroVisibility(checkboxDrawClustering.isSelected());
+	}// GEN-LAST:event_checkboxDrawClusteringActionPerformed
+
+	private void comboXActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_comboXActionPerformed
+		JComboBox cb = (JComboBox) evt.getSource();
+		int dim = cb.getSelectedIndex();
+		streamPanel0.setActiveXDim(dim);
+		streamPanel1.setActiveXDim(dim);
+		if (visualizer != null)
+			visualizer.redraw();
+	}// GEN-LAST:event_comboXActionPerformed
+
+	private void comboYActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_comboYActionPerformed
+		JComboBox cb = (JComboBox) evt.getSource();
+		int dim = cb.getSelectedIndex();
+		streamPanel0.setActiveYDim(dim);
+		streamPanel1.setActiveYDim(dim);
+		if (visualizer != null)
+			visualizer.redraw();
+	}// GEN-LAST:event_comboYActionPerformed
+
+	private void buttonStopActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonStopActionPerformed
+		stopVisualizer();
+		clusteringSetupTab.stopRun();
+	}// GEN-LAST:event_buttonStopActionPerformed
+
+	private void buttonRunActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonRunActionPerformed
+		// TODO add your handling code here:
+	}// GEN-LAST:event_buttonRunActionPerformed
+
+	// Variables declaration - do not modify//GEN-BEGIN:variables
+	private javax.swing.JButton buttonRun;
+	private javax.swing.JButton buttonScreenshot;
+	private javax.swing.JButton buttonStop;
+	private javax.swing.JButton buttonZoomInX;
+	private javax.swing.JButton buttonZoomInY;
+	private javax.swing.JButton buttonZoomOutX;
+	private javax.swing.JButton buttonZoomOutY;
+	private javax.swing.JCheckBox checkboxDrawClustering;
+	private javax.swing.JCheckBox checkboxDrawGT;
+	private javax.swing.JCheckBox checkboxDrawMicro;
+	private javax.swing.JCheckBox checkboxDrawPoints;
+	private moa.gui.clustertab.ClusteringVisualEvalPanel clusteringVisualEvalPanel1;
+	private javax.swing.JComboBox comboX;
+	private javax.swing.JComboBox comboY;
+	private moa.gui.visualization.GraphCanvas graphCanvas;
+	private javax.swing.JPanel graphPanel;
+	private javax.swing.JPanel graphPanelControlBottom;
+	private javax.swing.JPanel graphPanelControlTop;
+	private javax.swing.JScrollPane graphScrollPanel;
+	private javax.swing.JLabel jLabel1;
+	private javax.swing.JSplitPane jSplitPane1;
+	private javax.swing.JLabel labelEvents;
+	private javax.swing.JLabel labelNumPause;
+	private javax.swing.JLabel labelX;
+	private javax.swing.JLabel labelY;
+	private javax.swing.JLabel label_processed_points;
+	private javax.swing.JLabel label_processed_points_value;
+	private javax.swing.JTextField numPauseAfterPoints;
+	private javax.swing.JPanel panelControl;
+	private javax.swing.JPanel panelEvalOutput;
+	private javax.swing.JPanel panelVisualWrapper;
+	private javax.swing.JScrollPane scrollPane0;
+	private javax.swing.JScrollPane scrollPane1;
+	private javax.swing.JSlider speedSlider;
+	private javax.swing.JSplitPane splitVisual;
+	private moa.gui.visualization.StreamPanel streamPanel0;
+	private moa.gui.visualization.StreamPanel streamPanel1;
+	private javax.swing.JPanel topWrapper;
+	// End of variables declaration//GEN-END:variables
+
+	@Override
+	public void actionPerformed(ActionEvent e) {
+		if (e.getSource() instanceof JButton) {
+			if (e.getActionCommand().equals("csv export")) {
+				JFileChooser fileChooser = new JFileChooser();
+				fileChooser.setAcceptAllFileFilterUsed(true);
+				fileChooser.addChoosableFileFilter(new FileExtensionFilter("csv"));
+				if (exportFile != null)
+					fileChooser.setSelectedFile(new File(exportFile));
+				if (fileChooser.showSaveDialog(this) == JFileChooser.APPROVE_OPTION) {
+					exportFile = fileChooser.getSelectedFile().getPath();
+					visualizer.exportCSV(exportFile);
+				}
+			}
+			if (e.getActionCommand().equals("weka export")) {
+				visualizer.weka();
+			}
+		}
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/colorGenerator/ColorGenerator.java b/moa/src/main/java/moa/gui/colorGenerator/ColorGenerator.java
index 730d536d2..5e77ff496 100644
--- a/moa/src/main/java/moa/gui/colorGenerator/ColorGenerator.java
+++ b/moa/src/main/java/moa/gui/colorGenerator/ColorGenerator.java
@@ -3,19 +3,19 @@
 import java.awt.Color;
 
 /**
- * This interface specifies the generateColors method for classes
- * which generate colors according different strategies such that
- * those colors can be distinguished easily.
- * 
+ * This interface specifies the generateColors method for classes which generate
+ * colors according different strategies such that those colors can be
+ * distinguished easily.
+ *
  * @author Tuan Pham Minh (tuan.pham@ovgu.de)
  * @version $Revision: 1 $
  */
 public interface ColorGenerator {
 	/**
 	 * Generate numColors unique colors which should be easily distinguishable.
-	 * 
+	 *
 	 * @param numColors the number of colors to generate
 	 * @return an array of unique colors
 	 */
-	public Color[] generateColors(int numColors);
+	Color[] generateColors(int numColors);
 }
diff --git a/moa/src/main/java/moa/gui/colorGenerator/HSVColorGenerator.java b/moa/src/main/java/moa/gui/colorGenerator/HSVColorGenerator.java
index 5da81d3c6..af8c28f78 100644
--- a/moa/src/main/java/moa/gui/colorGenerator/HSVColorGenerator.java
+++ b/moa/src/main/java/moa/gui/colorGenerator/HSVColorGenerator.java
@@ -4,15 +4,14 @@
 import java.util.Random;
 
 /**
- * This class generates colors in the HSV space.
- * The space where the colors are sampled from
- * can be configured by specifying the range of 
- * hue, saturation and brightness.
- * 
+ * This class generates colors in the HSV space. The space where the colors are
+ * sampled from can be configured by specifying the range of hue, saturation and
+ * brightness.
+ *
  * @author Tuan Pham Minh (tuan.pham@ovgu.de)
  * @version $Revision: 1 $
  */
-public class HSVColorGenerator implements ColorGenerator{
+public class HSVColorGenerator implements ColorGenerator {
 
 	// range of the hue
 	private float hueMin;
@@ -23,32 +22,29 @@ public class HSVColorGenerator implements ColorGenerator{
 	// range of the brightness
 	private float brightnessMin;
 	private float brightnessMax;
-	
+
 	/**
-	 * constructor which sets the range to:
-	 * 		hue - [0.0, 1.0) 
-	 * 		saturation - [1.0, 1.0] 
-	 * 		brightness - [1.0, 1.0] 
+	 * constructor which sets the range to: hue - [0.0, 1.0) saturation - [1.0, 1.0]
+	 * brightness - [1.0, 1.0]
 	 */
-	public HSVColorGenerator()
-	{
-		this(1.0f,1.0f,1.0f,1.0f);
+	public HSVColorGenerator() {
+		this(1.0f, 1.0f, 1.0f, 1.0f);
 	}
-	
+
 	/**
-	 * constructor which sets the range of the hue to [0,1) and sets the 
-	 * ranges for saturation and brightness to the parameter
+	 * constructor which sets the range of the hue to [0,1) and sets the ranges for
+	 * saturation and brightness to the parameter
 	 */
-	public HSVColorGenerator(float saturationMin, float saturationMax, float brightnessMin, float brightnessMax)
-	{
-		this(0.0f, 1.0f, saturationMin,saturationMax,brightnessMin,brightnessMax);
+	public HSVColorGenerator(float saturationMin, float saturationMax, float brightnessMin, float brightnessMax) {
+		this(0.0f, 1.0f, saturationMin, saturationMax, brightnessMin, brightnessMax);
 	}
-	
+
 	/**
-	 * constructor which sets the ranges for saturation and brightness to the parameter
+	 * constructor which sets the ranges for saturation and brightness to the
+	 * parameter
 	 */
-	public HSVColorGenerator(float hueMin, float hueMax, float saturationMin, float saturationMax, float brightnessMin, float brightnessMax)
-	{
+	public HSVColorGenerator(float hueMin, float hueMax, float saturationMin, float saturationMax, float brightnessMin,
+			float brightnessMax) {
 		// set the ranges according to the given parameter
 		this.hueMin = hueMin;
 		this.hueMax = hueMax;
@@ -60,18 +56,18 @@ public HSVColorGenerator(float hueMin, float hueMax, float saturationMin, float
 
 	/**
 	 * Generate numColors unique colors which should be easily distinguishable.
-	 * 
+	 *
 	 * @param numColors the number of colors to generate
 	 * @return an array of unique colors
 	 */
 	@Override
 	public Color[] generateColors(int numColors) {
 		Color[] colors = new Color[numColors];
-		// fix the seed to always get the same colors for the same numColors parameter and ranges for hue, saturation and brightness
+		// fix the seed to always get the same colors for the same numColors parameter
+		// and ranges for hue, saturation and brightness
 		Random rand = new Random(0);
-		for(int i = 0; i < numColors; ++i)
-		{
-			float hueRatio = i/(float)numColors;
+		for (int i = 0; i < numColors; ++i) {
+			float hueRatio = i / (float) numColors;
 			float saturationRatio = rand.nextFloat();
 			float brightnessRatio = rand.nextFloat();
 			float hue = lerp(hueMin, hueMax, hueRatio);
@@ -79,20 +75,22 @@ public Color[] generateColors(int numColors) {
 			float brightness = lerp(brightnessMin, brightnessMax, brightnessRatio);
 			colors[i] = Color.getHSBColor(hue, saturation, brightness);
 		}
-		
+
 		return colors;
 	}
-	
+
 	/**
 	 * linear interpoplate between a minimal and maximal value given a ratio
-	 * 
-	 * @param min the minimal value which can be reached by setting the factor to 0.0
-	 * @param max the maximal value which can be reached by setting the factor to 1.0
-	 * @param ratio a float between 0.0 and 1.0 which describes the ratio between min and max to incorporate
+	 *
+	 * @param min   the minimal value which can be reached by setting the factor to
+	 *              0.0
+	 * @param max   the maximal value which can be reached by setting the factor to
+	 *              1.0
+	 * @param ratio a float between 0.0 and 1.0 which describes the ratio between
+	 *              min and max to incorporate
 	 * @return return the interpolated value
 	 */
-	private float lerp(float min, float max, float ratio)
-	{
-		return min + (max-min) * ratio;
+	private float lerp(float min, float max, float ratio) {
+		return min + (max - min) * ratio;
 	}
 }
diff --git a/moa/src/main/java/moa/gui/conceptdrift/CDTaskManagerPanel.java b/moa/src/main/java/moa/gui/conceptdrift/CDTaskManagerPanel.java
index 00d62e556..fa56c6121 100644
--- a/moa/src/main/java/moa/gui/conceptdrift/CDTaskManagerPanel.java
+++ b/moa/src/main/java/moa/gui/conceptdrift/CDTaskManagerPanel.java
@@ -16,38 +16,10 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.conceptdrift;
 
-import moa.core.StringUtils;
-import moa.gui.ClassOptionSelectionPanel;
-import moa.gui.FileExtensionFilter;
-import moa.gui.GUIUtils;
-import moa.gui.LookAndFeel;
-import moa.gui.PreviewPanel;
-import moa.options.ClassOption;
-import moa.options.OptionHandler;
-import moa.tasks.Task;
-import moa.tasks.TaskThread;
-import nz.ac.waikato.cms.gui.core.BaseFileChooser;
-
-import javax.swing.JButton;
-import javax.swing.JFrame;
-import javax.swing.JMenuItem;
-import javax.swing.JOptionPane;
-import javax.swing.JPanel;
-import javax.swing.JPopupMenu;
-import javax.swing.JProgressBar;
-import javax.swing.JScrollPane;
-import javax.swing.JTable;
-import javax.swing.JTextField;
-import javax.swing.SwingConstants;
-import javax.swing.event.ListSelectionEvent;
-import javax.swing.event.ListSelectionListener;
-import javax.swing.table.AbstractTableModel;
-import javax.swing.table.DefaultTableCellRenderer;
-import javax.swing.table.TableCellRenderer;
 import java.awt.BorderLayout;
 import java.awt.Component;
 import java.awt.Dimension;
@@ -68,6 +40,7 @@
 import java.util.prefs.Preferences;
 
 import javax.swing.JButton;
+import javax.swing.JFileChooser;
 import javax.swing.JFrame;
 import javax.swing.JMenuItem;
 import javax.swing.JOptionPane;
@@ -78,7 +51,6 @@
 import javax.swing.JTable;
 import javax.swing.JTextField;
 import javax.swing.SwingConstants;
-import javax.swing.UIManager;
 import javax.swing.event.ListSelectionEvent;
 import javax.swing.event.ListSelectionListener;
 import javax.swing.table.AbstractTableModel;
@@ -89,6 +61,7 @@
 import moa.gui.ClassOptionSelectionPanel;
 import moa.gui.FileExtensionFilter;
 import moa.gui.GUIUtils;
+import moa.gui.LookAndFeel;
 import moa.gui.PreviewPanel;
 import moa.options.ClassOption;
 import moa.options.OptionHandler;
@@ -98,7 +71,6 @@
 import moa.tasks.conceptdrift.EvaluateConceptDrift;
 import nz.ac.waikato.cms.gui.core.BaseFileChooser;
 
-
 /**
  * This panel displays the running tasks.
  *
@@ -106,464 +78,446 @@
  */
 public class CDTaskManagerPanel extends JPanel {
 
-    private static final long serialVersionUID = 1L;
-
-    public static final int MILLISECS_BETWEEN_REFRESH = 600;
-
-    public static String exportFileExtension = "log";
-
-    public class ProgressCellRenderer extends JProgressBar implements
-            TableCellRenderer {
-
-        private static final long serialVersionUID = 1L;
-
-        public ProgressCellRenderer() {
-            super(SwingConstants.HORIZONTAL, 0, 10000);
-            setBorderPainted(false);
-            setStringPainted(true);
-        }
-
-        @Override
-        public Component getTableCellRendererComponent(JTable table,
-                Object value, boolean isSelected, boolean hasFocus, int row,
-                int column) {
-            double frac = -1.0;
-            if (value instanceof Double) {
-                frac = ((Double) value).doubleValue();
-            }
-                if (frac >= 0.0) {
-                    setIndeterminate(false);
-                    setValue((int) (frac * 10000.0));
-                    setString(StringUtils.doubleToString(frac * 100.0, 2, 2));
-                } else {
-                    setValue(0);
-                    //setIndeterminate(true);
-                    //setString("?");
-                }
-            return this;
-        }
-
-        @Override
-        public void validate() {
-        }
-
-        @Override
-        public void revalidate() {
-        }
-
-        @Override
-        protected void firePropertyChange(String propertyName, Object oldValue,
-                Object newValue) {
-        }
-
-        @Override
-        public void firePropertyChange(String propertyName, boolean oldValue,
-                boolean newValue) {
-        }
-    }
-
-    public class TaskTableModel extends AbstractTableModel {
-
-        private static final long serialVersionUID = 1L;
-
-        @Override
-        public String getColumnName(int col) {
-            switch (col) {
-                case 0:
-                    return "command";
-                case 1:
-                    return "status";
-                case 2:
-                    return "time elapsed";
-                case 3:
-                    return "current activity";
-                case 4:
-                    return "% complete";
-            }
-            return null;
-        }
-
-        @Override
-        public int getColumnCount() {
-            return 5;
-        }
-
-        @Override
-        public int getRowCount() {
-            return CDTaskManagerPanel.this.taskList.size();
-        }
-
-        @Override
-        public Object getValueAt(int row, int col) {
-            TaskThread thread = CDTaskManagerPanel.this.taskList.get(row);
-            switch (col) {
-                case 0:
-                    return ((OptionHandler) thread.getTask()).getCLICreationString(ConceptDriftMainTask.class);
-                case 1:
-                    return thread.getCurrentStatusString();
-                case 2:
-                    return StringUtils.secondsToDHMSString(thread.getCPUSecondsElapsed());
-                case 3:
-                    return thread.getCurrentActivityString();
-                case 4:
-                    return new Double(thread.getCurrentActivityFracComplete());
-            }
-            return null;
-        }
-
-        @Override
-        public boolean isCellEditable(int row, int col) {
-            return false;
-        }
-    }
-
-    protected ConceptDriftMainTask currentTask = new EvaluateConceptDrift();//LearnModel();
-
-    protected List<TaskThread> taskList = new ArrayList<TaskThread>();
-
-    protected JButton configureTaskButton = new JButton("Configure");
-
-    protected JTextField taskDescField = new JTextField();
-
-    protected JButton runTaskButton = new JButton("Run");
-
-    protected TaskTableModel taskTableModel;
-
-    protected JTable taskTable;
-
-    protected JButton pauseTaskButton = new JButton("Pause");
-
-    protected JButton resumeTaskButton = new JButton("Resume");
-
-    protected JButton cancelTaskButton = new JButton("Cancel");
-
-    protected JButton deleteTaskButton = new JButton("Delete");
-
-    protected PreviewPanel previewPanel;
-
-    private Preferences prefs;
-    
-    private final String PREF_NAME = "currentTask";
-    
-    public CDTaskManagerPanel() {
-        // Read current task preference
-        prefs = Preferences.userRoot().node(this.getClass().getName());
-        currentTask = new EvaluateConceptDrift();
-        String taskText = this.currentTask.getCLICreationString(ConceptDriftMainTask.class);
-        String propertyValue = prefs.get(PREF_NAME, taskText);
-        //this.taskDescField.setText(propertyValue);
-        setTaskString(propertyValue, false); //Not store preference
-        this.taskDescField.setEditable(false);
-        
-        final Component comp = this.taskDescField;
-        this.taskDescField.addMouseListener(new MouseAdapter() {
-
-            @Override
-            public void mouseClicked(MouseEvent evt) {
-                if (evt.getClickCount() == 1) {
-                    if ((evt.getButton() == MouseEvent.BUTTON3)
-                            || ((evt.getButton() == MouseEvent.BUTTON1) && evt.isAltDown() && evt.isShiftDown())) {
-                        JPopupMenu menu = new JPopupMenu();
-                        JMenuItem item;
-
-                        item = new JMenuItem("Copy configuration to clipboard");
-                        item.addActionListener(new ActionListener() {
-
-                            @Override
-                            public void actionPerformed(ActionEvent e) {
-                                copyClipBoardConfiguration();
-                            }
-                        });
-                        menu.add(item);
-
-
-
-                        item = new JMenuItem("Save selected tasks to file");
-                        item.addActionListener(new ActionListener() {
-
-                            @Override
-                            public void actionPerformed(ActionEvent arg0) {
-                                saveLogSelectedTasks();
-                            }
-                        });
-                        menu.add(item);
-
-
-                        item = new JMenuItem("Enter configuration...");
-                        item.addActionListener(new ActionListener() {
-
-                            @Override
-                            public void actionPerformed(ActionEvent arg0) {
-                                String newTaskString = JOptionPane.showInputDialog("Insert command line");
-                                if (newTaskString != null) {
-                                    setTaskString(newTaskString);
-                                }
-                            }
-                        });
-                        menu.add(item);
-
-                        menu.show(comp, evt.getX(), evt.getY());
-                    }
-                }
-            }
-        });
-
-        JPanel configPanel = new JPanel();
-        configPanel.setLayout(new BorderLayout());
-        configPanel.add(this.configureTaskButton, BorderLayout.WEST);
-        configPanel.add(this.taskDescField, BorderLayout.CENTER);
-        configPanel.add(this.runTaskButton, BorderLayout.EAST);
-        this.taskTableModel = new TaskTableModel();
-        this.taskTable = new JTable(this.taskTableModel);
-        DefaultTableCellRenderer centerRenderer = new DefaultTableCellRenderer();
-        centerRenderer.setHorizontalAlignment(SwingConstants.CENTER);
-        this.taskTable.getColumnModel().getColumn(1).setCellRenderer(
-                centerRenderer);
-        this.taskTable.getColumnModel().getColumn(2).setCellRenderer(
-                centerRenderer);
-        this.taskTable.getColumnModel().getColumn(4).setCellRenderer(
-                new ProgressCellRenderer());
-        JPanel controlPanel = new JPanel();
-        controlPanel.add(this.pauseTaskButton);
-        controlPanel.add(this.resumeTaskButton);
-        controlPanel.add(this.cancelTaskButton);
-        controlPanel.add(this.deleteTaskButton);
-        setLayout(new BorderLayout());
-        add(configPanel, BorderLayout.NORTH);
-        add(new JScrollPane(this.taskTable), BorderLayout.CENTER);
-        add(controlPanel, BorderLayout.SOUTH);
-        this.taskTable.getSelectionModel().addListSelectionListener(
-                new ListSelectionListener() {
-
-                    @Override
-                    public void valueChanged(ListSelectionEvent arg0) {
-                        taskSelectionChanged();
-                    }
-                });
-        this.configureTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                String newTaskString = ClassOptionSelectionPanel.showSelectClassDialog(CDTaskManagerPanel.this,
-                        "Configure task", ConceptDriftMainTask.class,
-                        CDTaskManagerPanel.this.currentTask.getCLICreationString(ConceptDriftMainTask.class),
-                        null);
-                setTaskString(newTaskString);
-            }
-        });
-        this.runTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                runTask((Task) CDTaskManagerPanel.this.currentTask.copy());
-            }
-        });
-        this.pauseTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                pauseSelectedTasks();
-            }
-        });
-        this.resumeTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                resumeSelectedTasks();
-            }
-        });
-        this.cancelTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                cancelSelectedTasks();
-            }
-        });
-        this.deleteTaskButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                deleteSelectedTasks();
-            }
-        });
-
-        javax.swing.Timer updateListTimer = new javax.swing.Timer(
-                MILLISECS_BETWEEN_REFRESH, new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                CDTaskManagerPanel.this.taskTable.repaint();
-            }
-        });
-        updateListTimer.start();
-        setPreferredSize(new Dimension(0, 200));
-    }
-
-    public void setPreviewPanel(PreviewPanel previewPanel) {
-        this.previewPanel = previewPanel;
-    }
-
-    public void setTaskString(String cliString) {
-        setTaskString(cliString, true);
-    }
-    
-    public void setTaskString(String cliString, boolean storePreference) {    
-        try {
-            this.currentTask = (ConceptDriftMainTask) ClassOption.cliStringToObject(
-                    cliString, ConceptDriftMainTask.class, null);
-            String taskText = this.currentTask.getCLICreationString(ConceptDriftMainTask.class);
-            this.taskDescField.setText(taskText);
-            if (storePreference == true){
-            //Save task text as a preference
-            prefs.put(PREF_NAME, taskText);
-            }
-        } catch (Exception ex) {
-            GUIUtils.showExceptionDialog(this, "Problem with task", ex);
-        }
-    }
-
-    public void runTask(Task task) {
-        TaskThread thread = new TaskThread(task);
-        this.taskList.add(0, thread);
-        this.taskTableModel.fireTableDataChanged();
-        this.taskTable.setRowSelectionInterval(0, 0);
-        thread.start();
-    }
-
-    public void taskSelectionChanged() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        if (selectedTasks.length == 1) {
-            setTaskString(((OptionHandler) selectedTasks[0].getTask()).getCLICreationString(ConceptDriftMainTask.class));
-            if (this.previewPanel != null) {
-                this.previewPanel.setTaskThreadToPreview(selectedTasks[0]);
-            }
-        } else {
-            this.previewPanel.setTaskThreadToPreview(null);
-        }
-    }
-
-    public TaskThread[] getSelectedTasks() {
-        int[] selectedRows = this.taskTable.getSelectedRows();
-        TaskThread[] selectedTasks = new TaskThread[selectedRows.length];
-        for (int i = 0; i < selectedRows.length; i++) {
-            selectedTasks[i] = this.taskList.get(selectedRows[i]);
-        }
-        return selectedTasks;
-    }
-
-    public void pauseSelectedTasks() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            thread.pauseTask();
-        }
-    }
-
-    public void resumeSelectedTasks() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            thread.resumeTask();
-        }
-    }
-
-    public void cancelSelectedTasks() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            thread.cancelTask();
-        }
-    }
-
-    public void deleteSelectedTasks() {
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            thread.cancelTask();
-            this.taskList.remove(thread);
-        }
-        this.taskTableModel.fireTableDataChanged();
-    }
-
-    public void copyClipBoardConfiguration() {
-
-        StringSelection selection = new StringSelection(this.taskDescField.getText().trim());
-        Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
-        clipboard.setContents(selection, selection);
-
-    }
-
-    public void saveLogSelectedTasks() {
-        String tasksLog = "";
-        TaskThread[] selectedTasks = getSelectedTasks();
-        for (TaskThread thread : selectedTasks) {
-            tasksLog += ((OptionHandler) thread.getTask()).getCLICreationString(ConceptDriftMainTask.class) + "\n";
-        }
-
-        BaseFileChooser fileChooser = new BaseFileChooser();
-        fileChooser.setAcceptAllFileFilterUsed(true);
-        fileChooser.addChoosableFileFilter(new FileExtensionFilter(
-                exportFileExtension));
-        if (fileChooser.showSaveDialog(this) == BaseFileChooser.APPROVE_OPTION) {
-            File chosenFile = fileChooser.getSelectedFile();
-            String fileName = chosenFile.getPath();
-            if (!chosenFile.exists()
-                    && !fileName.endsWith(exportFileExtension)) {
-                fileName = fileName + "." + exportFileExtension;
-            }
-            try {
-                PrintWriter out = new PrintWriter(new BufferedWriter(
-                        new FileWriter(fileName)));
-                out.write(tasksLog);
-                out.close();
-            } catch (IOException ioe) {
-                GUIUtils.showExceptionDialog(
-                        this,
-                        "Problem saving file " + fileName, ioe);
-            }
-        }
-    }
-
-    private static void createAndShowGUI() {
-
-        // Create and set up the window.
-        JFrame frame = new JFrame("Test");
-        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-
-        // Create and set up the content pane.
-        JPanel panel = new CDTaskManagerPanel();
-        panel.setOpaque(true); // content panes must be opaque
-        frame.setContentPane(panel);
-
-        // Display the window.
-        frame.pack();
-        // frame.setSize(400, 400);
-        frame.setVisible(true);
-    }
-
-    public static void main(String[] args) {
-        try {
-            LookAndFeel.install();
-            javax.swing.SwingUtilities.invokeLater(new Runnable() {
-
-                @Override
-                public void run() {
-                    createAndShowGUI();
-                }
-            });
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-    
-    //Added for stream events
-    public ConceptDriftMainTask getCurrenTask() {
-        return  (ConceptDriftMainTask) this.currentTask; //this.getSelectedTasks()[0].getTask();//this.currentTask;
-    }
-    
-        //Added for stream events
-    public ConceptDriftMainTask getSelectedCurrenTask() {
-        if (this.getSelectedTasks().length > 0) {
-            return  (ConceptDriftMainTask) this.getSelectedTasks()[0].getTask();//this.currentTask;
-        }
-        else {
-            return getCurrenTask();
-        }
-    }
+	private static final long serialVersionUID = 1L;
+
+	public static final int MILLISECS_BETWEEN_REFRESH = 600;
+
+	public static String exportFileExtension = "log";
+
+	public class ProgressCellRenderer extends JProgressBar implements TableCellRenderer {
+
+		private static final long serialVersionUID = 1L;
+
+		public ProgressCellRenderer() {
+			super(SwingConstants.HORIZONTAL, 0, 10000);
+			setBorderPainted(false);
+			setStringPainted(true);
+		}
+
+		@Override
+		public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
+				int row, int column) {
+			double frac = -1.0;
+			if (value instanceof Double) {
+				frac = ((Double) value);
+			}
+			if (frac >= 0.0) {
+				setIndeterminate(false);
+				setValue((int) (frac * 10000.0));
+				setString(StringUtils.doubleToString(frac * 100.0, 2, 2));
+			} else {
+				setValue(0);
+				// setIndeterminate(true);
+				// setString("?");
+			}
+			return this;
+		}
+
+		@Override
+		public void validate() {
+		}
+
+		@Override
+		public void revalidate() {
+		}
+
+		@Override
+		protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
+		}
+
+		@Override
+		public void firePropertyChange(String propertyName, boolean oldValue, boolean newValue) {
+		}
+	}
+
+	public class TaskTableModel extends AbstractTableModel {
+
+		private static final long serialVersionUID = 1L;
+
+		@Override
+		public String getColumnName(int col) {
+			switch (col) {
+			case 0:
+				return "command";
+			case 1:
+				return "status";
+			case 2:
+				return "time elapsed";
+			case 3:
+				return "current activity";
+			case 4:
+				return "% complete";
+			}
+			return null;
+		}
+
+		@Override
+		public int getColumnCount() {
+			return 5;
+		}
+
+		@Override
+		public int getRowCount() {
+			return CDTaskManagerPanel.this.taskList.size();
+		}
+
+		@Override
+		public Object getValueAt(int row, int col) {
+			TaskThread thread = CDTaskManagerPanel.this.taskList.get(row);
+			switch (col) {
+			case 0:
+				return ((OptionHandler) thread.getTask()).getCLICreationString(ConceptDriftMainTask.class);
+			case 1:
+				return thread.getCurrentStatusString();
+			case 2:
+				return StringUtils.secondsToDHMSString(thread.getCPUSecondsElapsed());
+			case 3:
+				return thread.getCurrentActivityString();
+			case 4:
+				return new Double(thread.getCurrentActivityFracComplete());
+			}
+			return null;
+		}
+
+		@Override
+		public boolean isCellEditable(int row, int col) {
+			return false;
+		}
+	}
+
+	protected ConceptDriftMainTask currentTask = new EvaluateConceptDrift();// LearnModel();
+
+	protected List<TaskThread> taskList = new ArrayList<>();
+
+	protected JButton configureTaskButton = new JButton("Configure");
+
+	protected JTextField taskDescField = new JTextField();
+
+	protected JButton runTaskButton = new JButton("Run");
+
+	protected TaskTableModel taskTableModel;
+
+	protected JTable taskTable;
+
+	protected JButton pauseTaskButton = new JButton("Pause");
+
+	protected JButton resumeTaskButton = new JButton("Resume");
+
+	protected JButton cancelTaskButton = new JButton("Cancel");
+
+	protected JButton deleteTaskButton = new JButton("Delete");
+
+	protected PreviewPanel previewPanel;
+
+	private Preferences prefs;
+
+	private final String PREF_NAME = "currentTask";
+
+	public CDTaskManagerPanel() {
+		// Read current task preference
+		prefs = Preferences.userRoot().node(this.getClass().getName());
+		currentTask = new EvaluateConceptDrift();
+		String taskText = this.currentTask.getCLICreationString(ConceptDriftMainTask.class);
+		String propertyValue = prefs.get(PREF_NAME, taskText);
+		// this.taskDescField.setText(propertyValue);
+		setTaskString(propertyValue, false); // Not store preference
+		this.taskDescField.setEditable(false);
+
+		final Component comp = this.taskDescField;
+		this.taskDescField.addMouseListener(new MouseAdapter() {
+
+			@Override
+			public void mouseClicked(MouseEvent evt) {
+				if (evt.getClickCount() == 1) {
+					if ((evt.getButton() == MouseEvent.BUTTON3)
+							|| ((evt.getButton() == MouseEvent.BUTTON1) && evt.isAltDown() && evt.isShiftDown())) {
+						JPopupMenu menu = new JPopupMenu();
+						JMenuItem item;
+
+						item = new JMenuItem("Copy configuration to clipboard");
+						item.addActionListener(new ActionListener() {
+
+							@Override
+							public void actionPerformed(ActionEvent e) {
+								copyClipBoardConfiguration();
+							}
+						});
+						menu.add(item);
+
+						item = new JMenuItem("Save selected tasks to file");
+						item.addActionListener(new ActionListener() {
+
+							@Override
+							public void actionPerformed(ActionEvent arg0) {
+								saveLogSelectedTasks();
+							}
+						});
+						menu.add(item);
+
+						item = new JMenuItem("Enter configuration...");
+						item.addActionListener(new ActionListener() {
+
+							@Override
+							public void actionPerformed(ActionEvent arg0) {
+								String newTaskString = JOptionPane.showInputDialog("Insert command line");
+								if (newTaskString != null) {
+									setTaskString(newTaskString);
+								}
+							}
+						});
+						menu.add(item);
+
+						menu.show(comp, evt.getX(), evt.getY());
+					}
+				}
+			}
+		});
+
+		JPanel configPanel = new JPanel();
+		configPanel.setLayout(new BorderLayout());
+		configPanel.add(this.configureTaskButton, BorderLayout.WEST);
+		configPanel.add(this.taskDescField, BorderLayout.CENTER);
+		configPanel.add(this.runTaskButton, BorderLayout.EAST);
+		this.taskTableModel = new TaskTableModel();
+		this.taskTable = new JTable(this.taskTableModel);
+		DefaultTableCellRenderer centerRenderer = new DefaultTableCellRenderer();
+		centerRenderer.setHorizontalAlignment(SwingConstants.CENTER);
+		this.taskTable.getColumnModel().getColumn(1).setCellRenderer(centerRenderer);
+		this.taskTable.getColumnModel().getColumn(2).setCellRenderer(centerRenderer);
+		this.taskTable.getColumnModel().getColumn(4).setCellRenderer(new ProgressCellRenderer());
+		JPanel controlPanel = new JPanel();
+		controlPanel.add(this.pauseTaskButton);
+		controlPanel.add(this.resumeTaskButton);
+		controlPanel.add(this.cancelTaskButton);
+		controlPanel.add(this.deleteTaskButton);
+		setLayout(new BorderLayout());
+		add(configPanel, BorderLayout.NORTH);
+		add(new JScrollPane(this.taskTable), BorderLayout.CENTER);
+		add(controlPanel, BorderLayout.SOUTH);
+		this.taskTable.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
+
+			@Override
+			public void valueChanged(ListSelectionEvent arg0) {
+				taskSelectionChanged();
+			}
+		});
+		this.configureTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				String newTaskString = ClassOptionSelectionPanel.showSelectClassDialog(CDTaskManagerPanel.this,
+						"Configure task", ConceptDriftMainTask.class,
+						CDTaskManagerPanel.this.currentTask.getCLICreationString(ConceptDriftMainTask.class), null);
+				setTaskString(newTaskString);
+			}
+		});
+		this.runTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				runTask((Task) CDTaskManagerPanel.this.currentTask.copy());
+			}
+		});
+		this.pauseTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				pauseSelectedTasks();
+			}
+		});
+		this.resumeTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				resumeSelectedTasks();
+			}
+		});
+		this.cancelTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				cancelSelectedTasks();
+			}
+		});
+		this.deleteTaskButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				deleteSelectedTasks();
+			}
+		});
+
+		javax.swing.Timer updateListTimer = new javax.swing.Timer(MILLISECS_BETWEEN_REFRESH, new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				CDTaskManagerPanel.this.taskTable.repaint();
+			}
+		});
+		updateListTimer.start();
+		setPreferredSize(new Dimension(0, 200));
+	}
+
+	public void setPreviewPanel(PreviewPanel previewPanel) {
+		this.previewPanel = previewPanel;
+	}
+
+	public void setTaskString(String cliString) {
+		setTaskString(cliString, true);
+	}
+
+	public void setTaskString(String cliString, boolean storePreference) {
+		try {
+			this.currentTask = (ConceptDriftMainTask) ClassOption.cliStringToObject(cliString,
+					ConceptDriftMainTask.class, null);
+			String taskText = this.currentTask.getCLICreationString(ConceptDriftMainTask.class);
+			this.taskDescField.setText(taskText);
+			if (storePreference == true) {
+				// Save task text as a preference
+				prefs.put(PREF_NAME, taskText);
+			}
+		} catch (Exception ex) {
+			GUIUtils.showExceptionDialog(this, "Problem with task", ex);
+		}
+	}
+
+	public void runTask(Task task) {
+		TaskThread thread = new TaskThread(task);
+		this.taskList.add(0, thread);
+		this.taskTableModel.fireTableDataChanged();
+		this.taskTable.setRowSelectionInterval(0, 0);
+		thread.start();
+	}
+
+	public void taskSelectionChanged() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		if (selectedTasks.length == 1) {
+			setTaskString(
+					((OptionHandler) selectedTasks[0].getTask()).getCLICreationString(ConceptDriftMainTask.class));
+			if (this.previewPanel != null) {
+				this.previewPanel.setTaskThreadToPreview(selectedTasks[0]);
+			}
+		} else {
+			this.previewPanel.setTaskThreadToPreview(null);
+		}
+	}
+
+	public TaskThread[] getSelectedTasks() {
+		int[] selectedRows = this.taskTable.getSelectedRows();
+		TaskThread[] selectedTasks = new TaskThread[selectedRows.length];
+		for (int i = 0; i < selectedRows.length; i++) {
+			selectedTasks[i] = this.taskList.get(selectedRows[i]);
+		}
+		return selectedTasks;
+	}
+
+	public void pauseSelectedTasks() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			thread.pauseTask();
+		}
+	}
+
+	public void resumeSelectedTasks() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			thread.resumeTask();
+		}
+	}
+
+	public void cancelSelectedTasks() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			thread.cancelTask();
+		}
+	}
+
+	public void deleteSelectedTasks() {
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			thread.cancelTask();
+			this.taskList.remove(thread);
+		}
+		this.taskTableModel.fireTableDataChanged();
+	}
+
+	public void copyClipBoardConfiguration() {
+
+		StringSelection selection = new StringSelection(this.taskDescField.getText().trim());
+		Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
+		clipboard.setContents(selection, selection);
+
+	}
+
+	public void saveLogSelectedTasks() {
+		String tasksLog = "";
+		TaskThread[] selectedTasks = getSelectedTasks();
+		for (TaskThread thread : selectedTasks) {
+			tasksLog += ((OptionHandler) thread.getTask()).getCLICreationString(ConceptDriftMainTask.class) + "\n";
+		}
+
+		BaseFileChooser fileChooser = new BaseFileChooser();
+		fileChooser.setAcceptAllFileFilterUsed(true);
+		fileChooser.addChoosableFileFilter(new FileExtensionFilter(exportFileExtension));
+		if (fileChooser.showSaveDialog(this) == JFileChooser.APPROVE_OPTION) {
+			File chosenFile = fileChooser.getSelectedFile();
+			String fileName = chosenFile.getPath();
+			if (!chosenFile.exists() && !fileName.endsWith(exportFileExtension)) {
+				fileName = fileName + "." + exportFileExtension;
+			}
+			try {
+				PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(fileName)));
+				out.write(tasksLog);
+				out.close();
+			} catch (IOException ioe) {
+				GUIUtils.showExceptionDialog(this, "Problem saving file " + fileName, ioe);
+			}
+		}
+	}
+
+	private static void createAndShowGUI() {
+
+		// Create and set up the window.
+		JFrame frame = new JFrame("Test");
+		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+
+		// Create and set up the content pane.
+		JPanel panel = new CDTaskManagerPanel();
+		panel.setOpaque(true); // content panes must be opaque
+		frame.setContentPane(panel);
+
+		// Display the window.
+		frame.pack();
+		// frame.setSize(400, 400);
+		frame.setVisible(true);
+	}
+
+	public static void main(String[] args) {
+		try {
+			LookAndFeel.install();
+			javax.swing.SwingUtilities.invokeLater(new Runnable() {
+
+				@Override
+				public void run() {
+					createAndShowGUI();
+				}
+			});
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	// Added for stream events
+	public ConceptDriftMainTask getCurrenTask() {
+		return this.currentTask; // this.getSelectedTasks()[0].getTask();//this.currentTask;
+	}
+
+	// Added for stream events
+	public ConceptDriftMainTask getSelectedCurrenTask() {
+		if (this.getSelectedTasks().length > 0) {
+			return (ConceptDriftMainTask) this.getSelectedTasks()[0].getTask();// this.currentTask;
+		} else {
+			return getCurrenTask();
+		}
+	}
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/Algorithm.java b/moa/src/main/java/moa/gui/experimentertab/Algorithm.java
index 0eb043fc2..9f4b3e256 100644
--- a/moa/src/main/java/moa/gui/experimentertab/Algorithm.java
+++ b/moa/src/main/java/moa/gui/experimentertab/Algorithm.java
@@ -1,6 +1,6 @@
 /*
  *    Algorithm.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand 
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
  *    @author Alberto Verdecia Cabrera (averdeciac@gmail.com)
  *
  *    This program is free software; you can redistribute it and/or modify
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab;
 
@@ -25,6 +25,7 @@
 import java.util.List;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+
 import moa.core.DoubleVector;
 
 /**
@@ -34,144 +35,144 @@
  */
 public class Algorithm {
 
-    /**
-     * The name of the algorithms
-     */
-    public String name;
-    
-    public String path;
-    /**
-     * The list of measures per algorithm
-     */
-    public List<Measure> measures = new ArrayList<>();
-
-    /**
-     * The results file for the algorithm
-     */
-    public BufferedReader buffer;
-
-    /**
-     * The same size that the measure list
-     */
-    public int measureStdSize = 0;
-
-    /**
-     * Algorithm constructor
-     *
-     * @param name
-     * @param measures
-     * @param buffer
-     * @param path
-     */
-    public Algorithm(String name, List<Measure> measures, BufferedReader buffer,String path) {
-
-        this.name = name;
-        this.path = path;
-        this.measureStdSize = measures.size();
-        measures.stream().map((measure) -> {
-            int index = ReadFile.getMeasureIndex(path,measure.getFileName());
-            this.measures.add(new Measure(measure.getName(),measure.getFileName(), measure.isType(), index));
-            return measure;
-        }).filter((measure) -> (measure.isType())).forEach((_item) -> {
-            this.measureStdSize++;
-        });
-
-        this.buffer = buffer;
-        try {
-            calculateMeasures();
-        } catch (IOException ex) {
-            Logger.getLogger(Algorithm.class.getName()).log(Level.SEVERE, null, ex);
-        }
-
-    }
-
-    /**
-     * calculates the different measures for each algorithm.
-     *
-     */
-    private void calculateMeasures() throws IOException {
-        int cont = 0;
-        DoubleVector values[] = new DoubleVector[this.measures.size()];
-        for (int i = 0; i < this.measures.size(); i++) {
-            values[i] = new DoubleVector();
-        }
-        String lines;
-        lines = this.buffer.readLine();
-        while ((lines = this.buffer.readLine()) != null) {
-
-            String line[] = lines.split(",");
-            for (int i = 0; i < this.measures.size(); i++) {
-                if (this.measures.get(i).isType()) {
-
-                   try{
-                       values[i].setValue(cont, Double.parseDouble(line[this.measures.get(i).getIndex()]));
-                   }catch(NumberFormatException exp){
-                       values[i].setValue(cont,0);
-                   }
-
-                } else {
-                    try{
-                        this.measures.get(i).setValue(Double.parseDouble(line[this.measures.get(i).getIndex()]));
-                    }catch(NumberFormatException exp){
-                       this.measures.get(i).setValue(0.0);
-                   }
-                }
-            }
-            cont++;
-        }
-        //compute values
-        for (int i = 0; i < this.measures.size(); i++) {
-            this.measures.get(i).computeValue(values[i]);
-        }
-
-    }
-
-    /**
-     * Returns a list of measures per dataset.
-     *
-     * @param stream
-     * @return a list of measures per dataset
-     */
-    public List<Measure>[] getMeasuresPerData(List<Stream> stream) {
-        List<Measure> measures[] = new ArrayList[stream.size()];
-        for (int i = 0; i < stream.size(); i++) {
-            measures[i] = new ArrayList<>();
-            for (int j = 0; j < stream.get(i).algorithm.size(); j++) {
-                if (stream.get(i).algorithm.get(j).name.equals(name)) {
-                    measures[i] = stream.get(i).algorithm.get(j).measures;
-                }
-            }
-        }
-        return measures;
-    }
-
-    /**
-     * Rounds to two decimal places and returns the rounded value as a string.
-     *
-     * @return a formated value.
-     */
-    static String format(double value) {
-        return String.format("%.2f", value);
-    }
-
-    /**
-     * Returns the closest long to the argument, with ties rounding to positive
-     * infinity.
-     *
-     * @return the value of the argument rounded to the nearest long value.
-     */
-    static String format1(double x) {
-        String s = "" + Math.round(x);
-        return s;
-    }
-
-    /**
-     * Rounds to two decimal places and returns the rounded value as a double.
-     *
-     * @return a formated value.
-     */
-    static double Round(double x) {
-        return (Math.floor((x + 0.005) * 100)) / 100;
-    }
+	/**
+	 * The name of the algorithms
+	 */
+	public String name;
+
+	public String path;
+	/**
+	 * The list of measures per algorithm
+	 */
+	public List<Measure> measures = new ArrayList<>();
+
+	/**
+	 * The results file for the algorithm
+	 */
+	public BufferedReader buffer;
+
+	/**
+	 * The same size that the measure list
+	 */
+	public int measureStdSize = 0;
+
+	/**
+	 * Algorithm constructor
+	 *
+	 * @param name
+	 * @param measures
+	 * @param buffer
+	 * @param path
+	 */
+	public Algorithm(String name, List<Measure> measures, BufferedReader buffer, String path) {
+
+		this.name = name;
+		this.path = path;
+		this.measureStdSize = measures.size();
+		measures.stream().map((measure) -> {
+			int index = ReadFile.getMeasureIndex(path, measure.getFileName());
+			this.measures.add(new Measure(measure.getName(), measure.getFileName(), measure.isType(), index));
+			return measure;
+		}).filter((measure) -> (measure.isType())).forEach((_item) -> {
+			this.measureStdSize++;
+		});
+
+		this.buffer = buffer;
+		try {
+			calculateMeasures();
+		} catch (IOException ex) {
+			Logger.getLogger(Algorithm.class.getName()).log(Level.SEVERE, null, ex);
+		}
+
+	}
+
+	/**
+	 * calculates the different measures for each algorithm.
+	 *
+	 */
+	private void calculateMeasures() throws IOException {
+		int cont = 0;
+		DoubleVector values[] = new DoubleVector[this.measures.size()];
+		for (int i = 0; i < this.measures.size(); i++) {
+			values[i] = new DoubleVector();
+		}
+		String lines;
+		lines = this.buffer.readLine();
+		while ((lines = this.buffer.readLine()) != null) {
+
+			String line[] = lines.split(",");
+			for (int i = 0; i < this.measures.size(); i++) {
+				if (this.measures.get(i).isType()) {
+
+					try {
+						values[i].setValue(cont, Double.parseDouble(line[this.measures.get(i).getIndex()]));
+					} catch (NumberFormatException exp) {
+						values[i].setValue(cont, 0);
+					}
+
+				} else {
+					try {
+						this.measures.get(i).setValue(Double.parseDouble(line[this.measures.get(i).getIndex()]));
+					} catch (NumberFormatException exp) {
+						this.measures.get(i).setValue(0.0);
+					}
+				}
+			}
+			cont++;
+		}
+		// compute values
+		for (int i = 0; i < this.measures.size(); i++) {
+			this.measures.get(i).computeValue(values[i]);
+		}
+
+	}
+
+	/**
+	 * Returns a list of measures per dataset.
+	 *
+	 * @param stream
+	 * @return a list of measures per dataset
+	 */
+	public List<Measure>[] getMeasuresPerData(List<Stream> stream) {
+		List<Measure> measures[] = new ArrayList[stream.size()];
+		for (int i = 0; i < stream.size(); i++) {
+			measures[i] = new ArrayList<>();
+			for (int j = 0; j < stream.get(i).algorithm.size(); j++) {
+				if (stream.get(i).algorithm.get(j).name.equals(name)) {
+					measures[i] = stream.get(i).algorithm.get(j).measures;
+				}
+			}
+		}
+		return measures;
+	}
+
+	/**
+	 * Rounds to two decimal places and returns the rounded value as a string.
+	 *
+	 * @return a formated value.
+	 */
+	static String format(double value) {
+		return String.format("%.2f", value);
+	}
+
+	/**
+	 * Returns the closest long to the argument, with ties rounding to positive
+	 * infinity.
+	 *
+	 * @return the value of the argument rounded to the nearest long value.
+	 */
+	static String format1(double x) {
+		String s = "" + Math.round(x);
+		return s;
+	}
+
+	/**
+	 * Rounds to two decimal places and returns the rounded value as a double.
+	 *
+	 * @return a formated value.
+	 */
+	static double Round(double x) {
+		return (Math.floor((x + 0.005) * 100)) / 100;
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/AnalyzeTab.java b/moa/src/main/java/moa/gui/experimentertab/AnalyzeTab.java
index e4a3e9349..0ddf3f078 100644
--- a/moa/src/main/java/moa/gui/experimentertab/AnalyzeTab.java
+++ b/moa/src/main/java/moa/gui/experimentertab/AnalyzeTab.java
@@ -1,6 +1,6 @@
 /*
  *    AnalyzeTab.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand 
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
  *    @author Alberto Verdecia Cabrera (averdeciac@gmail.com)
  *
  *    This program is free software; you can redistribute it and/or modify
@@ -15,24 +15,10 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab;
 
-import moa.gui.LookAndFeel;
-import moa.gui.experimentertab.statisticaltests.PValuePerTwoAlgorithm;
-import moa.gui.experimentertab.statisticaltests.RankPerAlgorithm;
-import moa.gui.experimentertab.statisticaltests.StatisticalTest;
-import nz.ac.waikato.cms.gui.core.BaseDirectoryChooser;
-import org.apache.commons.io.FilenameUtils;
-
-import javax.swing.JFileChooser;
-import javax.swing.JFrame;
-import javax.swing.JMenuItem;
-import javax.swing.JOptionPane;
-import javax.swing.JPanel;
-import javax.swing.JPopupMenu;
-import javax.swing.table.DefaultTableModel;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.awt.event.MouseAdapter;
@@ -42,6 +28,22 @@
 import java.util.LinkedList;
 import java.util.List;
 
+import javax.swing.JFileChooser;
+import javax.swing.JFrame;
+import javax.swing.JMenuItem;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JPopupMenu;
+import javax.swing.table.DefaultTableModel;
+
+import org.apache.commons.io.FilenameUtils;
+
+import moa.gui.LookAndFeel;
+import moa.gui.experimentertab.statisticaltests.PValuePerTwoAlgorithm;
+import moa.gui.experimentertab.statisticaltests.RankPerAlgorithm;
+import moa.gui.experimentertab.statisticaltests.StatisticalTest;
+import nz.ac.waikato.cms.gui.core.BaseDirectoryChooser;
+
 /**
  * In this class are compared online learning algorithms on multiple datasets by
  * performing appropriate statistical tests.
@@ -50,621 +52,601 @@
  */
 public class AnalyzeTab extends javax.swing.JPanel {
 
-    private String algorithms[];
-    ArrayList<RankPerAlgorithm> rank = null;
-    ArrayList<PValuePerTwoAlgorithm> pvalues = null;
-    private DefaultTableModel algoritmModel;
-    private DefaultTableModel streamModel;
-    private String path = "";
-    private LinkedList<String> measures = new LinkedList();
-    ReadFile rf;
-    /**
-     * Creates new form Analize
-     */
-    public AnalyzeTab() {
-        initComponents();
-        this.algoritmModel = (DefaultTableModel) jTableAlgoritms.getModel();
-        this.streamModel = (DefaultTableModel) jTableStreams.getModel();
-        jTextAreaOut.addMouseListener(new PopClickListener());
-    }
-
-    private static void createAndShowGUI() {
-
-        // Create and set up the window.
-        JFrame frame = new JFrame("Test");
-        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-
-        // Create and set up the content pane.
-        JPanel panel = new AnalyzeTab();
-        panel.setOpaque(true); // content panes must be opaque
-        frame.setContentPane(panel);
-
-        // Display the window.
-        frame.pack();
-        frame.setVisible(true);
-    }
-
-    @SuppressWarnings("unchecked")
-    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
-    private void initComponents() {
-
-        jPanel1 = new javax.swing.JPanel();
-        jScrollPaneAlgorithms = new javax.swing.JScrollPane();
-        jTableAlgoritms = new javax.swing.JTable();
-        jScrollPaneStreams = new javax.swing.JScrollPane();
-        jTableStreams = new javax.swing.JTable();
-        jTextFieldResultsPath = new javax.swing.JTextField();
-        jButtonResults = new javax.swing.JButton();
-        jLabelDirectory = new javax.swing.JLabel();
-        jButtonDelAlgoritm = new javax.swing.JButton();
-        jButtonDelStream = new javax.swing.JButton();
-        jPanel2 = new javax.swing.JPanel();
-        jLabel2 = new javax.swing.JLabel();
-        jComboBoxTest = new javax.swing.JComboBox();
-        jButtonTest = new javax.swing.JButton();
-        jButtonImage = new javax.swing.JButton();
-        jLabel3 = new javax.swing.JLabel();
-        jSpinnerPvalue = new javax.swing.JSpinner();
-        jButtonReset = new javax.swing.JButton();
-        jComboBoxMeasure = new javax.swing.JComboBox();
-        jLabel4 = new javax.swing.JLabel();
-        jComboBoxType = new javax.swing.JComboBox();
-        jLabel1 = new javax.swing.JLabel();
-        jScrollPane1 = new javax.swing.JScrollPane();
-        jTextAreaOut = new javax.swing.JTextArea();
-
-        jPanel1.setBorder(javax.swing.BorderFactory.createTitledBorder("Configuration"));
-
-        jScrollPaneAlgorithms.setBorder(javax.swing.BorderFactory.createTitledBorder("Algorithm"));
-
-        jTableAlgoritms.setBorder(javax.swing.BorderFactory.createTitledBorder(""));
-        jTableAlgoritms.setModel(new javax.swing.table.DefaultTableModel(
-            new Object [][] {
-
-            },
-            new String [] {
-                "Algorithm", "Algorithm ID"
-            }
-        ));
-        jScrollPaneAlgorithms.setViewportView(jTableAlgoritms);
-
-        jScrollPaneStreams.setBorder(javax.swing.BorderFactory.createTitledBorder("Stram"));
-
-        jTableStreams.setBorder(javax.swing.BorderFactory.createTitledBorder(""));
-        jTableStreams.setModel(new javax.swing.table.DefaultTableModel(
-            new Object [][] {
-
-            },
-            new String [] {
-                "Stream", "Stream ID"
-            }
-        ));
-        jScrollPaneStreams.setViewportView(jTableStreams);
-
-        jButtonResults.setText("Browse");
-        jButtonResults.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                jButtonResultsActionPerformed(evt);
-            }
-        });
-
-        jLabelDirectory.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
-        jLabelDirectory.setText("Result  folder");
-
-        jButtonDelAlgoritm.setText("Delete Algorithm");
-        jButtonDelAlgoritm.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                jButtonDelAlgoritmActionPerformed(evt);
-            }
-        });
-
-        jButtonDelStream.setText("Delete Stream");
-        jButtonDelStream.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                jButtonDelStreamActionPerformed(evt);
-            }
-        });
-
-        javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1);
-        jPanel1.setLayout(jPanel1Layout);
-        jPanel1Layout.setHorizontalGroup(
-            jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGroup(jPanel1Layout.createSequentialGroup()
-                .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                    .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanel1Layout.createSequentialGroup()
-                        .addGap(14, 14, 14)
-                        .addComponent(jLabelDirectory)
-                        .addGap(18, 18, 18)
-                        .addComponent(jTextFieldResultsPath)
-                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
-                        .addComponent(jButtonResults))
-                    .addGroup(jPanel1Layout.createSequentialGroup()
-                        .addContainerGap()
-                        .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                            .addComponent(jButtonDelAlgoritm)
-                            .addComponent(jScrollPaneAlgorithms, javax.swing.GroupLayout.DEFAULT_SIZE, 327, Short.MAX_VALUE))
-                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
-                        .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                            .addComponent(jScrollPaneStreams, javax.swing.GroupLayout.PREFERRED_SIZE, 0, Short.MAX_VALUE)
-                            .addGroup(jPanel1Layout.createSequentialGroup()
-                                .addComponent(jButtonDelStream)
-                                .addGap(0, 216, Short.MAX_VALUE)))))
-                .addGap(16, 16, 16))
-        );
-        jPanel1Layout.setVerticalGroup(
-            jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanel1Layout.createSequentialGroup()
-                .addGap(23, 23, 23)
-                .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jTextFieldResultsPath, javax.swing.GroupLayout.PREFERRED_SIZE, 23, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jButtonResults)
-                    .addComponent(jLabelDirectory))
-                .addGap(18, 18, 18)
-                .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                    .addComponent(jScrollPaneAlgorithms, javax.swing.GroupLayout.DEFAULT_SIZE, 164, Short.MAX_VALUE)
-                    .addComponent(jScrollPaneStreams, javax.swing.GroupLayout.PREFERRED_SIZE, 0, Short.MAX_VALUE))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jButtonDelStream)
-                    .addComponent(jButtonDelAlgoritm)))
-        );
-
-        jPanel2.setBorder(javax.swing.BorderFactory.createTitledBorder("Statistical Test"));
-
-        jLabel2.setText("Test");
-
-        jComboBoxTest.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "Holm", "Shaffer", "Nemenyi" }));
-
-        jButtonTest.setText("Run Test");
-        jButtonTest.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                jButtonTestActionPerformed(evt);
-            }
-        });
-
-        jButtonImage.setText("Image");
-        jButtonImage.setEnabled(false);
-        jButtonImage.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                jButtonImageActionPerformed(evt);
-            }
-        });
-
-        jLabel3.setText("pValue");
-
-        jSpinnerPvalue.setModel(new javax.swing.SpinnerNumberModel(Double.valueOf(0.05d), null, null, Double.valueOf(0.001d)));
-
-        jButtonReset.setText("Reset to Default");
-        jButtonReset.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                jButtonResetActionPerformed(evt);
-            }
-        });
-
-        jLabel4.setText("measure");
-
-        jComboBoxType.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "Mean", "Last" }));
-
-        jLabel1.setText("type");
-
-        javax.swing.GroupLayout jPanel2Layout = new javax.swing.GroupLayout(jPanel2);
-        jPanel2.setLayout(jPanel2Layout);
-        jPanel2Layout.setHorizontalGroup(
-            jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGroup(jPanel2Layout.createSequentialGroup()
-                .addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                    .addGroup(jPanel2Layout.createSequentialGroup()
-                        .addContainerGap()
-                        .addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
-                            .addComponent(jLabel2)
-                            .addComponent(jLabel3)
-                            .addComponent(jLabel4))
-                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
-                        .addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                            .addComponent(jComboBoxTest, 0, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
-                            .addComponent(jSpinnerPvalue)
-                            .addComponent(jComboBoxMeasure, 0, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)))
-                    .addGroup(jPanel2Layout.createSequentialGroup()
-                        .addGap(49, 49, 49)
-                        .addComponent(jButtonTest)
-                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                        .addComponent(jButtonImage)
-                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                        .addComponent(jButtonReset)
-                        .addGap(0, 0, Short.MAX_VALUE))
-                    .addGroup(jPanel2Layout.createSequentialGroup()
-                        .addGap(29, 29, 29)
-                        .addComponent(jLabel1)
-                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
-                        .addComponent(jComboBoxType, 0, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)))
-                .addContainerGap())
-        );
-        jPanel2Layout.setVerticalGroup(
-            jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGroup(jPanel2Layout.createSequentialGroup()
-                .addContainerGap()
-                .addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jComboBoxTest, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jLabel2))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jSpinnerPvalue, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jLabel3))
-                .addGap(6, 6, 6)
-                .addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jComboBoxMeasure, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jLabel4))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
-                .addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jComboBoxType, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jLabel1))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jButtonTest)
-                    .addComponent(jButtonImage)
-                    .addComponent(jButtonReset)))
-        );
-
-        jScrollPane1.setBorder(javax.swing.BorderFactory.createTitledBorder("Output"));
-
-        jTextAreaOut.setColumns(20);
-        jTextAreaOut.setRows(5);
-        jScrollPane1.setViewportView(jTextAreaOut);
-
-        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
-        this.setLayout(layout);
-        layout.setHorizontalGroup(
-            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGroup(layout.createSequentialGroup()
-                .addContainerGap()
-                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                    .addComponent(jScrollPane1, javax.swing.GroupLayout.DEFAULT_SIZE, 682, Short.MAX_VALUE)
-                    .addComponent(jPanel2, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)))
-            .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                .addComponent(jPanel1, javax.swing.GroupLayout.Alignment.TRAILING, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
-        );
-        layout.setVerticalGroup(
-            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
-                .addGap(289, 289, 289)
-                .addComponent(jPanel2, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addComponent(jScrollPane1, javax.swing.GroupLayout.DEFAULT_SIZE, 113, Short.MAX_VALUE)
-                .addContainerGap())
-            .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                .addGroup(layout.createSequentialGroup()
-                    .addComponent(jPanel1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addContainerGap(300, Short.MAX_VALUE)))
-        );
-    }// </editor-fold>//GEN-END:initComponents
-
-    private void jButtonResultsActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonResultsActionPerformed
-        BaseDirectoryChooser resultsFile = new BaseDirectoryChooser();
-        //resultsFile.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
-        int selection = resultsFile.showOpenDialog(this);
-        if (selection == JFileChooser.APPROVE_OPTION) {
-            path = resultsFile.getSelectedFile().getAbsolutePath();
-        }
-
-        if (!path.equals("")) {
-            reset();
-            this.jTextFieldResultsPath.setText(path);
-            rf = new ReadFile(path);
-            String str = rf.processFiles();
-            if (str.equals("")) {
-
-                int algSize = rf.getAlgShortNames().size();
-                int streamSize = rf.getStream().size();
-                this.measures = rf.getMeasures();
-                for (int i = 0; i < algSize; i++) {
-                    this.algoritmModel.addRow(new Object[]{rf.getAlgNames().get(i), rf.getAlgShortNames().get(i)});
-                }
-                for (int i = 0; i < streamSize; i++) {
-                    this.streamModel.addRow(new Object[]{rf.getStream().get(i), rf.getStream().get(i)});
-                }
-
-                String measuresNames[] = measures.getFirst().split(",");
-                for (String measuresName : measuresNames) {
-                    jComboBoxMeasure.addItem(measuresName);
-                    if (measuresName.equals("classifications correct (percent)") == true
-                            || measuresName.equals("[avg] classifications correct (percent)") == true) {
-                        jComboBoxMeasure.setSelectedItem(measuresName);
-                    }
-
-                }
-            } else {
-
-                JOptionPane.showMessageDialog(this, str,
-                        "Error", JOptionPane.ERROR_MESSAGE);
-            }
-        }
-    }//GEN-LAST:event_jButtonResultsActionPerformed
-
-    private void jButtonDelAlgoritmActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonDelAlgoritmActionPerformed
-        if (this.jTableAlgoritms.getSelectedRow() != -1) {
-            
-            this.algoritmModel.removeRow(this.jTableAlgoritms.getSelectedRow());
-            String algorithms[] = new String[algoritmModel.getRowCount()];
-            for (int i = 0; i < algoritmModel.getRowCount(); i++) {
-                algorithms[i] = algoritmModel.getValueAt(i, 0).toString();
-            }
-            
-            if (streamModel.getValueAt(0, 0).toString() != null) {
-                rf.updateMeasures(algorithms, streamModel.getValueAt(0, 0).toString());
-                this.measures = rf.getMeasures();
-                String measuresNames[] = measures.getFirst().split(",");
-                jComboBoxMeasure.removeAllItems();
-                for (String measuresName : measuresNames) {
-                    jComboBoxMeasure.addItem(measuresName);
-                    if (measuresName.equals("classifications correct (percent)") == true
-                            || measuresName.equals("[avg] classifications correct (percent)") == true) {
-                        jComboBoxMeasure.setSelectedItem(measuresName);
-                    }
-
-                }
-            }
-        }
-    }//GEN-LAST:event_jButtonDelAlgoritmActionPerformed
-
-    private void jButtonDelStreamActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonDelStreamActionPerformed
-        this.streamModel.removeRow(this.jTableStreams.getSelectedRow());
-    }//GEN-LAST:event_jButtonDelStreamActionPerformed
-
-    private void jButtonTestActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonTestActionPerformed
-        if (this.jTextFieldResultsPath.getText().equals("")) {
-            JOptionPane.showMessageDialog(this, "Directory not found",
-                    "Error", JOptionPane.ERROR_MESSAGE);
-            return;
-        }
-         List<Measure> algmeasures = new ArrayList<>();
-        List<Stream> streams = new ArrayList<>();
-        List<String> algPath = new ArrayList<>();
-        List<String> algShortNames = new ArrayList<>();
-        int count = 0;
-        boolean type = true;
-        type = this.jComboBoxType.getSelectedItem().toString().equals("Mean");
-        Measure m = new Measure(this.jComboBoxMeasure.getSelectedItem().toString(),
-                this.jComboBoxMeasure.getSelectedItem().toString(),type, 0);
-        algmeasures.add(m);
-        String path = this.jTextFieldResultsPath.getText();
-        for (int i = 0; i < streamModel.getRowCount(); i++) {
-           
-            algPath.clear();
-            for (int j = 0; j < algoritmModel.getRowCount(); j++) {
-                File inputFile = new File(FilenameUtils.separatorsToSystem(
-                        path + "\\" + streamModel.getValueAt(i, 0) + "\\" + algoritmModel.getValueAt(j, 0)));
-                File streamFile = new File(FilenameUtils.separatorsToSystem(
-                        path + "\\" + streamModel.getValueAt(i, 0)));
-                if (!inputFile.exists()) {
-                    JOptionPane.showMessageDialog(this, "File not found: "
-                            + inputFile.getAbsolutePath(),
-                            "Error", JOptionPane.ERROR_MESSAGE);
-                    return;
-                } else {
-                    String algorithmPath = FilenameUtils.separatorsToSystem(
-                            path + "\\" + streamModel.getValueAt(i, 0).toString() + "\\"
-                            + algoritmModel.getValueAt(j, 0).toString());
-                    algPath.add(algorithmPath);
-                    if (i == 0) {
-                        algShortNames.add(algoritmModel.getValueAt(j, 1).toString());
-                    }
-                   
-                }
-            }
-            Stream s = new Stream(streamModel.getValueAt(i, 1).toString(), algPath, algShortNames, algmeasures);
-            streams.add(s);
-        }
-
-        //Statistical Test 
-        StatisticalTest test = new StatisticalTest(streams);
-        try {
-            // test.readCSV(this.jTextFieldCSV.getText());
-            test.readData();
-        } catch (Exception exp) {
-            JOptionPane.showMessageDialog(this, "Problem with csv file",
-                    "Error", JOptionPane.ERROR_MESSAGE);
-            return;
-        }
-
-        test.avgPerformance();
-        this.jTextAreaOut.append("P-values involving all algorithms\n");
-        this.jTextAreaOut.append(System.getProperty("line.separator"));
-        this.jTextAreaOut.append("P-value computed by Friedman Test: " + test.getFriedmanPValue() + "\n");
-        this.jTextAreaOut.append("P-value computed by Iman and Daveport Test: " + test.getImanPValue() + "\n");
-
-        rank = test.getRankAlg();
-        this.jTextAreaOut.append(System.getProperty("line.separator"));
-        this.jTextAreaOut.append("Ranking of the algorithms\n");
-        this.jTextAreaOut.append(System.getProperty("line.separator"));
-        rank.stream().forEach((RankPerAlgorithm rank1) -> {
-            this.jTextAreaOut.append(rank1.algName + ": " + rank1.rank + "\n");
-        });
-
-        switch (jComboBoxTest.getSelectedItem().toString()) {
-            case "Holm":
-                pvalues = test.holmTest();
-                break;
-            case "Shaffer":
-                pvalues = test.shafferTest();
-                break;
-            case "Nemenyi":
-                pvalues = test.nemenyiTest();
-        }
-        this.jTextAreaOut.append(System.getProperty("line.separator"));
-        this.jTextAreaOut.append("P-values of classifiers against each other\n");
-        this.jTextAreaOut.append(System.getProperty("line.separator"));
-        pvalues.stream().forEach((pvalue) -> {
-            this.jTextAreaOut.append(pvalue.algName1 + " vs " + pvalue.algName2 + ": " + pvalue.PValue + "\n");
-        });
-        jButtonImage.setEnabled(true);
-        //
-    }//GEN-LAST:event_jButtonTestActionPerformed
-
-    private void jButtonImageActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonImageActionPerformed
-        RankingGraph graf = new RankingGraph(rank, pvalues, jTextFieldResultsPath.getText(), Double.parseDouble(this.jSpinnerPvalue.getValue().toString()));
-    }//GEN-LAST:event_jButtonImageActionPerformed
-
-    private void jButtonResetActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonResetActionPerformed
-        reset();
-    }//GEN-LAST:event_jButtonResetActionPerformed
-
-    /**
-     * Tables of algorithms and datasets are cleaned.
-     */
-    public void cleanTables() {
-        try {
-            DefaultTableModel algModel = (DefaultTableModel) jTableAlgoritms.getModel();
-            DefaultTableModel strModel = (DefaultTableModel) jTableStreams.getModel();
-            int rows = jTableAlgoritms.getRowCount();
-            int srow = jTableStreams.getRowCount();
-            for (int i = 0; i < rows; i++) {
-                algModel.removeRow(0);
-            }
-            for (int i = 0; i < srow; i++) {
-                strModel.removeRow(0);
-            }
-
-        } catch (Exception e) {
-            JOptionPane.showMessageDialog(null, "Error cleaning the table.");
-        }
-    }
-
-    private void reset() {
-        cleanTables();
-        this.jTextFieldResultsPath.setText("");
-
-        //Combobox
-        this.jComboBoxMeasure.removeAllItems();
-        this.jComboBoxTest.setSelectedItem("Holm");
-        //spinner
-        this.jSpinnerPvalue.setValue(0.05);
-
-        this.jButtonTest.setSelected(false);
-        this.jButtonImage.setSelected(false);
-
-    }
-
-    /**
-     * Allows you to read the results file and update the corresponding fields.
-     *
-     * @param path
-     */
-    public void readData(String path) {
-        reset();
-        this.jTextFieldResultsPath.setText(path);
-        this.path = path;
-        rf = new ReadFile(path);
-        String str = rf.processFiles();
-        if (str.equals("")) {
-
-            int algSize = rf.getAlgShortNames().size();
-            int streamSize = rf.getStream().size();
-            this.measures = rf.getMeasures();
-            for (int i = 0; i < algSize; i++) {
-                this.algoritmModel.addRow(new Object[]{rf.getAlgNames().get(i), rf.getAlgShortNames().get(i)});
-            }
-            for (int i = 0; i < streamSize; i++) {
-                this.streamModel.addRow(new Object[]{rf.getStream().get(i), rf.getStream().get(i)});
-            }
-            String measuresNames[] = measures.getFirst().split(",");
-            for (String measuresName : measuresNames) {
-                jComboBoxMeasure.addItem(measuresName);
-                if (measuresName.equals("classifications correct (percent)") == true
-                        || measuresName.equals("[avg] classifications correct (percent)") == true) {
-                    jComboBoxMeasure.setSelectedItem(measuresName);
-                }
-
-            }
-        } else {
-
-            JOptionPane.showMessageDialog(this, str,
-                    "Error", JOptionPane.ERROR_MESSAGE);
-        }
-
-    }
-
-    /**
-     * Main class method.
-     *
-     * @param args
-     */
-    public static void main(String[] args) {
-        try {
-            LookAndFeel.install();
-            javax.swing.SwingUtilities.invokeLater(new Runnable() {
-
-                @Override
-                public void run() {
-                    createAndShowGUI();
-                }
-            });
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-
-    }
-
-    class PopupMenu extends JPopupMenu {
-
-        JMenuItem anItem;
-
-        public PopupMenu() {
-            anItem = new JMenuItem("Clear");
-            add(anItem);
-            ActionListener listener = (ActionEvent event) -> {
-                jTextAreaOut.setText("");
-            };
-            anItem.addActionListener(listener);
-        }
-
-    }
-
-    class PopClickListener extends MouseAdapter {
-
-        @Override
-        public void mousePressed(MouseEvent e) {
-            if (e.isPopupTrigger()) {
-                doPop(e);
-            }
-        }
-
-        @Override
-        public void mouseReleased(MouseEvent e) {
-            if (e.isPopupTrigger()) {
-                doPop(e);
-            }
-        }
-
-        private void doPop(MouseEvent e) {
-            PopupMenu menu = new PopupMenu();
-            menu.show(e.getComponent(), e.getX(), e.getY());
-
-        }
-    }
-    // Variables declaration - do not modify//GEN-BEGIN:variables
-    private javax.swing.JButton jButtonDelAlgoritm;
-    private javax.swing.JButton jButtonDelStream;
-    private javax.swing.JButton jButtonImage;
-    private javax.swing.JButton jButtonReset;
-    private javax.swing.JButton jButtonResults;
-    private javax.swing.JButton jButtonTest;
-    private javax.swing.JComboBox jComboBoxMeasure;
-    private javax.swing.JComboBox jComboBoxTest;
-    private javax.swing.JComboBox jComboBoxType;
-    private javax.swing.JLabel jLabel1;
-    private javax.swing.JLabel jLabel2;
-    private javax.swing.JLabel jLabel3;
-    private javax.swing.JLabel jLabel4;
-    private javax.swing.JLabel jLabelDirectory;
-    private javax.swing.JPanel jPanel1;
-    private javax.swing.JPanel jPanel2;
-    private javax.swing.JScrollPane jScrollPane1;
-    private javax.swing.JScrollPane jScrollPaneAlgorithms;
-    private javax.swing.JScrollPane jScrollPaneStreams;
-    private javax.swing.JSpinner jSpinnerPvalue;
-    private javax.swing.JTable jTableAlgoritms;
-    private javax.swing.JTable jTableStreams;
-    private javax.swing.JTextArea jTextAreaOut;
-    private javax.swing.JTextField jTextFieldResultsPath;
-    // End of variables declaration//GEN-END:variables
+	private String algorithms[];
+	ArrayList<RankPerAlgorithm> rank = null;
+	ArrayList<PValuePerTwoAlgorithm> pvalues = null;
+	private DefaultTableModel algoritmModel;
+	private DefaultTableModel streamModel;
+	private String path = "";
+	private LinkedList<String> measures = new LinkedList();
+	ReadFile rf;
+
+	/**
+	 * Creates new form Analize
+	 */
+	public AnalyzeTab() {
+		initComponents();
+		this.algoritmModel = (DefaultTableModel) jTableAlgoritms.getModel();
+		this.streamModel = (DefaultTableModel) jTableStreams.getModel();
+		jTextAreaOut.addMouseListener(new PopClickListener());
+	}
+
+	private static void createAndShowGUI() {
+
+		// Create and set up the window.
+		JFrame frame = new JFrame("Test");
+		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+
+		// Create and set up the content pane.
+		JPanel panel = new AnalyzeTab();
+		panel.setOpaque(true); // content panes must be opaque
+		frame.setContentPane(panel);
+
+		// Display the window.
+		frame.pack();
+		frame.setVisible(true);
+	}
+
+	@SuppressWarnings("unchecked")
+	// <editor-fold defaultstate="collapsed" desc="Generated
+	// Code">//GEN-BEGIN:initComponents
+	private void initComponents() {
+
+		jPanel1 = new javax.swing.JPanel();
+		jScrollPaneAlgorithms = new javax.swing.JScrollPane();
+		jTableAlgoritms = new javax.swing.JTable();
+		jScrollPaneStreams = new javax.swing.JScrollPane();
+		jTableStreams = new javax.swing.JTable();
+		jTextFieldResultsPath = new javax.swing.JTextField();
+		jButtonResults = new javax.swing.JButton();
+		jLabelDirectory = new javax.swing.JLabel();
+		jButtonDelAlgoritm = new javax.swing.JButton();
+		jButtonDelStream = new javax.swing.JButton();
+		jPanel2 = new javax.swing.JPanel();
+		jLabel2 = new javax.swing.JLabel();
+		jComboBoxTest = new javax.swing.JComboBox();
+		jButtonTest = new javax.swing.JButton();
+		jButtonImage = new javax.swing.JButton();
+		jLabel3 = new javax.swing.JLabel();
+		jSpinnerPvalue = new javax.swing.JSpinner();
+		jButtonReset = new javax.swing.JButton();
+		jComboBoxMeasure = new javax.swing.JComboBox();
+		jLabel4 = new javax.swing.JLabel();
+		jComboBoxType = new javax.swing.JComboBox();
+		jLabel1 = new javax.swing.JLabel();
+		jScrollPane1 = new javax.swing.JScrollPane();
+		jTextAreaOut = new javax.swing.JTextArea();
+
+		jPanel1.setBorder(javax.swing.BorderFactory.createTitledBorder("Configuration"));
+
+		jScrollPaneAlgorithms.setBorder(javax.swing.BorderFactory.createTitledBorder("Algorithm"));
+
+		jTableAlgoritms.setBorder(javax.swing.BorderFactory.createTitledBorder(""));
+		jTableAlgoritms.setModel(new javax.swing.table.DefaultTableModel(new Object[][] {
+
+		}, new String[] { "Algorithm", "Algorithm ID" }));
+		jScrollPaneAlgorithms.setViewportView(jTableAlgoritms);
+
+		jScrollPaneStreams.setBorder(javax.swing.BorderFactory.createTitledBorder("Stram"));
+
+		jTableStreams.setBorder(javax.swing.BorderFactory.createTitledBorder(""));
+		jTableStreams.setModel(new javax.swing.table.DefaultTableModel(new Object[][] {
+
+		}, new String[] { "Stream", "Stream ID" }));
+		jScrollPaneStreams.setViewportView(jTableStreams);
+
+		jButtonResults.setText("Browse");
+		jButtonResults.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				jButtonResultsActionPerformed(evt);
+			}
+		});
+
+		jLabelDirectory.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
+		jLabelDirectory.setText("Result  folder");
+
+		jButtonDelAlgoritm.setText("Delete Algorithm");
+		jButtonDelAlgoritm.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				jButtonDelAlgoritmActionPerformed(evt);
+			}
+		});
+
+		jButtonDelStream.setText("Delete Stream");
+		jButtonDelStream.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				jButtonDelStreamActionPerformed(evt);
+			}
+		});
+
+		javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1);
+		jPanel1.setLayout(jPanel1Layout);
+		jPanel1Layout.setHorizontalGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+				.addGroup(jPanel1Layout.createSequentialGroup().addGroup(jPanel1Layout
+						.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+						.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
+								jPanel1Layout.createSequentialGroup().addGap(14, 14, 14).addComponent(jLabelDirectory)
+										.addGap(18, 18, 18).addComponent(jTextFieldResultsPath)
+										.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
+										.addComponent(jButtonResults))
+						.addGroup(jPanel1Layout.createSequentialGroup().addContainerGap()
+								.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+										.addComponent(jButtonDelAlgoritm).addComponent(jScrollPaneAlgorithms,
+												javax.swing.GroupLayout.DEFAULT_SIZE, 327, Short.MAX_VALUE))
+								.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
+								.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+										.addComponent(jScrollPaneStreams, javax.swing.GroupLayout.PREFERRED_SIZE, 0,
+												Short.MAX_VALUE)
+										.addGroup(jPanel1Layout.createSequentialGroup().addComponent(jButtonDelStream)
+												.addGap(0, 216, Short.MAX_VALUE)))))
+						.addGap(16, 16, 16)));
+		jPanel1Layout.setVerticalGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+				.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
+						jPanel1Layout.createSequentialGroup().addGap(23, 23, 23)
+								.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+										.addComponent(jTextFieldResultsPath, javax.swing.GroupLayout.PREFERRED_SIZE, 23,
+												javax.swing.GroupLayout.PREFERRED_SIZE)
+										.addComponent(jButtonResults).addComponent(jLabelDirectory))
+								.addGap(18, 18, 18)
+								.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+										.addComponent(jScrollPaneAlgorithms, javax.swing.GroupLayout.DEFAULT_SIZE, 164,
+												Short.MAX_VALUE)
+										.addComponent(jScrollPaneStreams, javax.swing.GroupLayout.PREFERRED_SIZE, 0,
+												Short.MAX_VALUE))
+								.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+								.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+										.addComponent(jButtonDelStream).addComponent(jButtonDelAlgoritm))));
+
+		jPanel2.setBorder(javax.swing.BorderFactory.createTitledBorder("Statistical Test"));
+
+		jLabel2.setText("Test");
+
+		jComboBoxTest.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "Holm", "Shaffer", "Nemenyi" }));
+
+		jButtonTest.setText("Run Test");
+		jButtonTest.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				jButtonTestActionPerformed(evt);
+			}
+		});
+
+		jButtonImage.setText("Image");
+		jButtonImage.setEnabled(false);
+		jButtonImage.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				jButtonImageActionPerformed(evt);
+			}
+		});
+
+		jLabel3.setText("pValue");
+
+		jSpinnerPvalue.setModel(
+				new javax.swing.SpinnerNumberModel(Double.valueOf(0.05d), null, null, Double.valueOf(0.001d)));
+
+		jButtonReset.setText("Reset to Default");
+		jButtonReset.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				jButtonResetActionPerformed(evt);
+			}
+		});
+
+		jLabel4.setText("measure");
+
+		jComboBoxType.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "Mean", "Last" }));
+
+		jLabel1.setText("type");
+
+		javax.swing.GroupLayout jPanel2Layout = new javax.swing.GroupLayout(jPanel2);
+		jPanel2.setLayout(jPanel2Layout);
+		jPanel2Layout.setHorizontalGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+				.addGroup(jPanel2Layout.createSequentialGroup().addGroup(jPanel2Layout
+						.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+						.addGroup(jPanel2Layout.createSequentialGroup().addContainerGap()
+								.addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
+										.addComponent(jLabel2).addComponent(jLabel3).addComponent(jLabel4))
+								.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
+								.addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+										.addComponent(jComboBoxTest, 0, javax.swing.GroupLayout.DEFAULT_SIZE,
+												Short.MAX_VALUE)
+										.addComponent(jSpinnerPvalue).addComponent(jComboBoxMeasure, 0,
+												javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)))
+						.addGroup(jPanel2Layout.createSequentialGroup().addGap(49, 49, 49).addComponent(jButtonTest)
+								.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+								.addComponent(jButtonImage)
+								.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+								.addComponent(jButtonReset).addGap(0, 0, Short.MAX_VALUE))
+						.addGroup(jPanel2Layout.createSequentialGroup().addGap(29, 29, 29).addComponent(jLabel1)
+								.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
+								.addComponent(jComboBoxType, 0, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)))
+						.addContainerGap()));
+		jPanel2Layout.setVerticalGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+				.addGroup(jPanel2Layout.createSequentialGroup().addContainerGap()
+						.addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+								.addComponent(jComboBoxTest, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addComponent(jLabel2))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+						.addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+								.addComponent(jSpinnerPvalue, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addComponent(jLabel3))
+						.addGap(6, 6, 6)
+						.addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+								.addComponent(jComboBoxMeasure, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addComponent(jLabel4))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED,
+								javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
+						.addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+								.addComponent(jComboBoxType, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addComponent(jLabel1))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+						.addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+								.addComponent(jButtonTest).addComponent(jButtonImage).addComponent(jButtonReset))));
+
+		jScrollPane1.setBorder(javax.swing.BorderFactory.createTitledBorder("Output"));
+
+		jTextAreaOut.setColumns(20);
+		jTextAreaOut.setRows(5);
+		jScrollPane1.setViewportView(jTextAreaOut);
+
+		javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
+		this.setLayout(layout);
+		layout.setHorizontalGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+				.addGroup(layout.createSequentialGroup().addContainerGap()
+						.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+								.addComponent(jScrollPane1, javax.swing.GroupLayout.DEFAULT_SIZE, 682, Short.MAX_VALUE)
+								.addComponent(jPanel2, javax.swing.GroupLayout.DEFAULT_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)))
+				.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addComponent(jPanel1,
+						javax.swing.GroupLayout.Alignment.TRAILING, javax.swing.GroupLayout.DEFAULT_SIZE,
+						javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)));
+		layout.setVerticalGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+				.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
+						layout.createSequentialGroup().addGap(289, 289, 289)
+								.addComponent(jPanel2, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+								.addComponent(jScrollPane1, javax.swing.GroupLayout.DEFAULT_SIZE, 113, Short.MAX_VALUE)
+								.addContainerGap())
+				.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+						.addGroup(layout.createSequentialGroup()
+								.addComponent(jPanel1, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addContainerGap(300, Short.MAX_VALUE))));
+	}// </editor-fold>//GEN-END:initComponents
+
+	private void jButtonResultsActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_jButtonResultsActionPerformed
+		BaseDirectoryChooser resultsFile = new BaseDirectoryChooser();
+		// resultsFile.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
+		int selection = resultsFile.showOpenDialog(this);
+		if (selection == JFileChooser.APPROVE_OPTION) {
+			path = resultsFile.getSelectedFile().getAbsolutePath();
+		}
+
+		if (!path.equals("")) {
+			reset();
+			this.jTextFieldResultsPath.setText(path);
+			rf = new ReadFile(path);
+			String str = rf.processFiles();
+			if (str.equals("")) {
+
+				int algSize = rf.getAlgShortNames().size();
+				int streamSize = rf.getStream().size();
+				this.measures = rf.getMeasures();
+				for (int i = 0; i < algSize; i++) {
+					this.algoritmModel.addRow(new Object[] { rf.getAlgNames().get(i), rf.getAlgShortNames().get(i) });
+				}
+				for (int i = 0; i < streamSize; i++) {
+					this.streamModel.addRow(new Object[] { rf.getStream().get(i), rf.getStream().get(i) });
+				}
+
+				String measuresNames[] = measures.getFirst().split(",");
+				for (String measuresName : measuresNames) {
+					jComboBoxMeasure.addItem(measuresName);
+					if (measuresName.equals("classifications correct (percent)") == true
+							|| measuresName.equals("[avg] classifications correct (percent)") == true) {
+						jComboBoxMeasure.setSelectedItem(measuresName);
+					}
+
+				}
+			} else {
+
+				JOptionPane.showMessageDialog(this, str, "Error", JOptionPane.ERROR_MESSAGE);
+			}
+		}
+	}// GEN-LAST:event_jButtonResultsActionPerformed
+
+	private void jButtonDelAlgoritmActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_jButtonDelAlgoritmActionPerformed
+		if (this.jTableAlgoritms.getSelectedRow() != -1) {
+
+			this.algoritmModel.removeRow(this.jTableAlgoritms.getSelectedRow());
+			String algorithms[] = new String[algoritmModel.getRowCount()];
+			for (int i = 0; i < algoritmModel.getRowCount(); i++) {
+				algorithms[i] = algoritmModel.getValueAt(i, 0).toString();
+			}
+
+			if (streamModel.getValueAt(0, 0).toString() != null) {
+				rf.updateMeasures(algorithms, streamModel.getValueAt(0, 0).toString());
+				this.measures = rf.getMeasures();
+				String measuresNames[] = measures.getFirst().split(",");
+				jComboBoxMeasure.removeAllItems();
+				for (String measuresName : measuresNames) {
+					jComboBoxMeasure.addItem(measuresName);
+					if (measuresName.equals("classifications correct (percent)") == true
+							|| measuresName.equals("[avg] classifications correct (percent)") == true) {
+						jComboBoxMeasure.setSelectedItem(measuresName);
+					}
+
+				}
+			}
+		}
+	}// GEN-LAST:event_jButtonDelAlgoritmActionPerformed
+
+	private void jButtonDelStreamActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_jButtonDelStreamActionPerformed
+		this.streamModel.removeRow(this.jTableStreams.getSelectedRow());
+	}// GEN-LAST:event_jButtonDelStreamActionPerformed
+
+	private void jButtonTestActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_jButtonTestActionPerformed
+		if (this.jTextFieldResultsPath.getText().equals("")) {
+			JOptionPane.showMessageDialog(this, "Directory not found", "Error", JOptionPane.ERROR_MESSAGE);
+			return;
+		}
+		List<Measure> algmeasures = new ArrayList<>();
+		List<Stream> streams = new ArrayList<>();
+		List<String> algPath = new ArrayList<>();
+		List<String> algShortNames = new ArrayList<>();
+		int count = 0;
+		boolean type = true;
+		type = this.jComboBoxType.getSelectedItem().toString().equals("Mean");
+		Measure m = new Measure(this.jComboBoxMeasure.getSelectedItem().toString(),
+				this.jComboBoxMeasure.getSelectedItem().toString(), type, 0);
+		algmeasures.add(m);
+		String path = this.jTextFieldResultsPath.getText();
+		for (int i = 0; i < streamModel.getRowCount(); i++) {
+
+			algPath.clear();
+			for (int j = 0; j < algoritmModel.getRowCount(); j++) {
+				File inputFile = new File(FilenameUtils.separatorsToSystem(
+						path + "\\" + streamModel.getValueAt(i, 0) + "\\" + algoritmModel.getValueAt(j, 0)));
+				File streamFile = new File(
+						FilenameUtils.separatorsToSystem(path + "\\" + streamModel.getValueAt(i, 0)));
+				if (!inputFile.exists()) {
+					JOptionPane.showMessageDialog(this, "File not found: " + inputFile.getAbsolutePath(), "Error",
+							JOptionPane.ERROR_MESSAGE);
+					return;
+				} else {
+					String algorithmPath = FilenameUtils
+							.separatorsToSystem(path + "\\" + streamModel.getValueAt(i, 0).toString() + "\\"
+									+ algoritmModel.getValueAt(j, 0).toString());
+					algPath.add(algorithmPath);
+					if (i == 0) {
+						algShortNames.add(algoritmModel.getValueAt(j, 1).toString());
+					}
+
+				}
+			}
+			Stream s = new Stream(streamModel.getValueAt(i, 1).toString(), algPath, algShortNames, algmeasures);
+			streams.add(s);
+		}
+
+		// Statistical Test
+		StatisticalTest test = new StatisticalTest(streams);
+		try {
+			// test.readCSV(this.jTextFieldCSV.getText());
+			test.readData();
+		} catch (Exception exp) {
+			JOptionPane.showMessageDialog(this, "Problem with csv file", "Error", JOptionPane.ERROR_MESSAGE);
+			return;
+		}
+
+		test.avgPerformance();
+		this.jTextAreaOut.append("P-values involving all algorithms\n");
+		this.jTextAreaOut.append(System.getProperty("line.separator"));
+		this.jTextAreaOut.append("P-value computed by Friedman Test: " + test.getFriedmanPValue() + "\n");
+		this.jTextAreaOut.append("P-value computed by Iman and Daveport Test: " + test.getImanPValue() + "\n");
+
+		rank = test.getRankAlg();
+		this.jTextAreaOut.append(System.getProperty("line.separator"));
+		this.jTextAreaOut.append("Ranking of the algorithms\n");
+		this.jTextAreaOut.append(System.getProperty("line.separator"));
+		rank.stream().forEach((RankPerAlgorithm rank1) -> {
+			this.jTextAreaOut.append(rank1.algName + ": " + rank1.rank + "\n");
+		});
+
+		switch (jComboBoxTest.getSelectedItem().toString()) {
+		case "Holm":
+			pvalues = test.holmTest();
+			break;
+		case "Shaffer":
+			pvalues = test.shafferTest();
+			break;
+		case "Nemenyi":
+			pvalues = test.nemenyiTest();
+		}
+		this.jTextAreaOut.append(System.getProperty("line.separator"));
+		this.jTextAreaOut.append("P-values of classifiers against each other\n");
+		this.jTextAreaOut.append(System.getProperty("line.separator"));
+		pvalues.stream().forEach((pvalue) -> {
+			this.jTextAreaOut.append(pvalue.algName1 + " vs " + pvalue.algName2 + ": " + pvalue.PValue + "\n");
+		});
+		jButtonImage.setEnabled(true);
+		//
+	}// GEN-LAST:event_jButtonTestActionPerformed
+
+	private void jButtonImageActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_jButtonImageActionPerformed
+		RankingGraph graf = new RankingGraph(rank, pvalues, jTextFieldResultsPath.getText(),
+				Double.parseDouble(this.jSpinnerPvalue.getValue().toString()));
+	}// GEN-LAST:event_jButtonImageActionPerformed
+
+	private void jButtonResetActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_jButtonResetActionPerformed
+		reset();
+	}// GEN-LAST:event_jButtonResetActionPerformed
+
+	/**
+	 * Tables of algorithms and datasets are cleaned.
+	 */
+	public void cleanTables() {
+		try {
+			DefaultTableModel algModel = (DefaultTableModel) jTableAlgoritms.getModel();
+			DefaultTableModel strModel = (DefaultTableModel) jTableStreams.getModel();
+			int rows = jTableAlgoritms.getRowCount();
+			int srow = jTableStreams.getRowCount();
+			for (int i = 0; i < rows; i++) {
+				algModel.removeRow(0);
+			}
+			for (int i = 0; i < srow; i++) {
+				strModel.removeRow(0);
+			}
+
+		} catch (Exception e) {
+			JOptionPane.showMessageDialog(null, "Error cleaning the table.");
+		}
+	}
+
+	private void reset() {
+		cleanTables();
+		this.jTextFieldResultsPath.setText("");
+
+		// Combobox
+		this.jComboBoxMeasure.removeAllItems();
+		this.jComboBoxTest.setSelectedItem("Holm");
+		// spinner
+		this.jSpinnerPvalue.setValue(0.05);
+
+		this.jButtonTest.setSelected(false);
+		this.jButtonImage.setSelected(false);
+
+	}
+
+	/**
+	 * Allows you to read the results file and update the corresponding fields.
+	 *
+	 * @param path
+	 */
+	public void readData(String path) {
+		reset();
+		this.jTextFieldResultsPath.setText(path);
+		this.path = path;
+		rf = new ReadFile(path);
+		String str = rf.processFiles();
+		if (str.equals("")) {
+
+			int algSize = rf.getAlgShortNames().size();
+			int streamSize = rf.getStream().size();
+			this.measures = rf.getMeasures();
+			for (int i = 0; i < algSize; i++) {
+				this.algoritmModel.addRow(new Object[] { rf.getAlgNames().get(i), rf.getAlgShortNames().get(i) });
+			}
+			for (int i = 0; i < streamSize; i++) {
+				this.streamModel.addRow(new Object[] { rf.getStream().get(i), rf.getStream().get(i) });
+			}
+			String measuresNames[] = measures.getFirst().split(",");
+			for (String measuresName : measuresNames) {
+				jComboBoxMeasure.addItem(measuresName);
+				if (measuresName.equals("classifications correct (percent)") == true
+						|| measuresName.equals("[avg] classifications correct (percent)") == true) {
+					jComboBoxMeasure.setSelectedItem(measuresName);
+				}
+
+			}
+		} else {
+
+			JOptionPane.showMessageDialog(this, str, "Error", JOptionPane.ERROR_MESSAGE);
+		}
+
+	}
+
+	/**
+	 * Main class method.
+	 *
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		try {
+			LookAndFeel.install();
+			javax.swing.SwingUtilities.invokeLater(new Runnable() {
+
+				@Override
+				public void run() {
+					createAndShowGUI();
+				}
+			});
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+
+	}
+
+	class PopupMenu extends JPopupMenu {
+
+		JMenuItem anItem;
+
+		public PopupMenu() {
+			anItem = new JMenuItem("Clear");
+			add(anItem);
+			ActionListener listener = (ActionEvent event) -> {
+				jTextAreaOut.setText("");
+			};
+			anItem.addActionListener(listener);
+		}
+
+	}
+
+	class PopClickListener extends MouseAdapter {
+
+		@Override
+		public void mousePressed(MouseEvent e) {
+			if (e.isPopupTrigger()) {
+				doPop(e);
+			}
+		}
+
+		@Override
+		public void mouseReleased(MouseEvent e) {
+			if (e.isPopupTrigger()) {
+				doPop(e);
+			}
+		}
+
+		private void doPop(MouseEvent e) {
+			PopupMenu menu = new PopupMenu();
+			menu.show(e.getComponent(), e.getX(), e.getY());
+
+		}
+	}
+
+	// Variables declaration - do not modify//GEN-BEGIN:variables
+	private javax.swing.JButton jButtonDelAlgoritm;
+	private javax.swing.JButton jButtonDelStream;
+	private javax.swing.JButton jButtonImage;
+	private javax.swing.JButton jButtonReset;
+	private javax.swing.JButton jButtonResults;
+	private javax.swing.JButton jButtonTest;
+	private javax.swing.JComboBox jComboBoxMeasure;
+	private javax.swing.JComboBox jComboBoxTest;
+	private javax.swing.JComboBox jComboBoxType;
+	private javax.swing.JLabel jLabel1;
+	private javax.swing.JLabel jLabel2;
+	private javax.swing.JLabel jLabel3;
+	private javax.swing.JLabel jLabel4;
+	private javax.swing.JLabel jLabelDirectory;
+	private javax.swing.JPanel jPanel1;
+	private javax.swing.JPanel jPanel2;
+	private javax.swing.JScrollPane jScrollPane1;
+	private javax.swing.JScrollPane jScrollPaneAlgorithms;
+	private javax.swing.JScrollPane jScrollPaneStreams;
+	private javax.swing.JSpinner jSpinnerPvalue;
+	private javax.swing.JTable jTableAlgoritms;
+	private javax.swing.JTable jTableStreams;
+	private javax.swing.JTextArea jTextAreaOut;
+	private javax.swing.JTextField jTextFieldResultsPath;
+	// End of variables declaration//GEN-END:variables
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/Buffer.java b/moa/src/main/java/moa/gui/experimentertab/Buffer.java
index 17be314d8..2df3dc3db 100644
--- a/moa/src/main/java/moa/gui/experimentertab/Buffer.java
+++ b/moa/src/main/java/moa/gui/experimentertab/Buffer.java
@@ -1,6 +1,6 @@
 /*
  *    Buffer.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand 
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
  *    @author Alberto Verdecia Cabrera (averdeciac@gmail.com)
  *
  *    This program is free software; you can redistribute it and/or modify
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab;
 
@@ -28,45 +28,46 @@
  */
 public class Buffer {
 
-    MainTask tasks[];
-    int cantTask = 0;
+	MainTask tasks[];
+	int cantTask = 0;
 
-    /**
-     * Buffer Constructor 
-     * @param tasks
-     */
-    public Buffer(MainTask tasks[]) {
-        this.tasks = tasks;
-    }
+	/**
+	 * Buffer Constructor
+	 * 
+	 * @param tasks
+	 */
+	public Buffer(MainTask tasks[]) {
+		this.tasks = tasks;
+	}
 
-    /**
-     * Returns the next task to be executed.
-     *
-     * @return the next task to be executed.
-     */
-    synchronized MainTask getTask() {
-        if (this.tasks.length != this.cantTask) {
-            return this.tasks[this.cantTask++];
-        }
-        return null;
-    }
+	/**
+	 * Returns the next task to be executed.
+	 *
+	 * @return the next task to be executed.
+	 */
+	synchronized MainTask getTask() {
+		if (this.tasks.length != this.cantTask) {
+			return this.tasks[this.cantTask++];
+		}
+		return null;
+	}
 
-    /**
-     * Returns the number of executed tasks.
-     *
-     * @return the number of executed tasks.
-     */
-    synchronized int getCantTask() {
-        return this.cantTask;
-    }
+	/**
+	 * Returns the number of executed tasks.
+	 *
+	 * @return the number of executed tasks.
+	 */
+	synchronized int getCantTask() {
+		return this.cantTask;
+	}
 
-    /**
-     * Returns the number of tasks.
-     *
-     * @return the number of tasks.
-     */
-    synchronized int getSize() {
-        return this.tasks.length;
-    }
+	/**
+	 * Returns the number of tasks.
+	 *
+	 * @return the number of tasks.
+	 */
+	synchronized int getSize() {
+		return this.tasks.length;
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/ExpPreviewPanel.java b/moa/src/main/java/moa/gui/experimentertab/ExpPreviewPanel.java
index 7786e0553..9c1cdb0a6 100644
--- a/moa/src/main/java/moa/gui/experimentertab/ExpPreviewPanel.java
+++ b/moa/src/main/java/moa/gui/experimentertab/ExpPreviewPanel.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab;
 
@@ -44,159 +44,155 @@
  */
 public class ExpPreviewPanel extends JPanel implements ResultPreviewListener {
 
-    private static final long serialVersionUID = 1L;
-
-    public static final String[] autoFreqStrings = {"never", "every second",
-        "every 5 seconds", "every 10 seconds", "every 30 seconds",
-        "every minute"};
-
-    public static final int[] autoFreqTimeSecs = {0, 1, 5, 10, 30, 60};
-
-    protected ExpTaskThread previewedThread;
-
-    protected JLabel previewLabel = new JLabel("No preview available");
-
-    protected JButton refreshButton = new JButton("Refresh");
-
-    protected JLabel autoRefreshLabel = new JLabel("Auto refresh: ");
-
-    protected JComboBox autoRefreshComboBox = new JComboBox(autoFreqStrings);
-
-    protected TaskTextViewerPanel textViewerPanel; // = new TaskTextViewerPanel();
-
-    protected javax.swing.Timer autoRefreshTimer;
-    
-    public enum TypePanel {
-        CLASSIFICATION(new Accuracy()),
-        REGRESSION(new RegressionAccuracy()),
-        CONCEPT_DRIFT(new ChangeDetectionMeasures());
-        private final MeasureCollection measureCollection;
-        //Constructor
-        TypePanel(MeasureCollection measureCollection){
-            this.measureCollection = measureCollection;
-        }
-        
-        public MeasureCollection getMeasureCollection(){
-            return (MeasureCollection) this.measureCollection.copy();
-        }
-    }
-
-    public ExpPreviewPanel() {
-        this(TypePanel.CLASSIFICATION, null);
-    }
-    
-    public ExpPreviewPanel(TypePanel typePanel) {
-        this(typePanel, null);
-    }
-    
-    public ExpPreviewPanel(TypePanel typePanel, CDTaskManagerPanel taskManagerPanel) {
-        this.textViewerPanel = new TaskTextViewerPanel(typePanel,taskManagerPanel); 
-        this.autoRefreshComboBox.setSelectedIndex(1); // default to 1 sec
-        JPanel controlPanel = new JPanel();
-        controlPanel.add(this.previewLabel);
-        controlPanel.add(this.refreshButton);
-        controlPanel.add(this.autoRefreshLabel);
-        controlPanel.add(this.autoRefreshComboBox);
-        setLayout(new BorderLayout());
-        add(controlPanel, BorderLayout.NORTH);
-        add(this.textViewerPanel, BorderLayout.CENTER);
-        this.refreshButton.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                refresh();
-            }
-        });
-        this.autoRefreshTimer = new javax.swing.Timer(1000,
-                new ActionListener() {
-
-                    @Override
-                    public void actionPerformed(ActionEvent e) {
-                        refresh();
-                    }
-                });
-        this.autoRefreshComboBox.addActionListener(new ActionListener() {
-
-            @Override
-            public void actionPerformed(ActionEvent arg0) {
-                updateAutoRefreshTimer();
-            }
-        });
-        setTaskThreadToPreview(null);
-    }
-
-    public void refresh() {
-        if (this.previewedThread != null) {
-            if (this.previewedThread.isComplete()) {
-                setLatestPreview(null);
-                disableRefresh();
-            } else {
-                this.previewedThread.getPreview(ExpPreviewPanel.this);
-            }
-        }
-    }
-
-    public void setTaskThreadToPreview(ExpTaskThread thread) {
-        this.previewedThread = thread;
-        setLatestPreview(thread != null ? thread.getLatestResultPreview()
-                : null);
-        if (thread == null) {
-            disableRefresh();
-        } else if (!thread.isComplete()) {
-            enableRefresh();
-        }
-    }
-
-    public void setLatestPreview(Object preview) {
-        if ((this.previewedThread != null) && this.previewedThread.isComplete()) {
-            this.previewLabel.setText("Final result");
-            Object finalResult = this.previewedThread.getFinalResult();
-            this.textViewerPanel.setText(finalResult != null ? finalResult.toString() : null);
-            disableRefresh();
-        } else {
-            double grabTime = this.previewedThread != null ? this.previewedThread.getLatestPreviewGrabTimeSeconds()
-                    : 0.0;
-            String grabString = grabTime > 0.0 ? (" ("
-                    + StringUtils.secondsToDHMSString(grabTime) + ")") : "";
-            this.textViewerPanel.setText(preview != null ? preview.toString()
-                    : null);
-            if (preview == null) {
-                this.previewLabel.setText("No preview available" + grabString);
-            } else {
-                this.previewLabel.setText("Preview" + grabString);
-            }
-        }
-    }
-
-    public void updateAutoRefreshTimer() {
-        int autoDelay = autoFreqTimeSecs[this.autoRefreshComboBox.getSelectedIndex()];
-        if (autoDelay > 0) {
-            if (this.autoRefreshTimer.isRunning()) {
-                this.autoRefreshTimer.stop();
-            }
-            this.autoRefreshTimer.setDelay(autoDelay * 1000);
-            this.autoRefreshTimer.start();
-        } else {
-            this.autoRefreshTimer.stop();
-        }
-    }
-
-    public void disableRefresh() {
-        this.refreshButton.setEnabled(false);
-        this.autoRefreshLabel.setEnabled(false);
-        this.autoRefreshComboBox.setEnabled(false);
-        this.autoRefreshTimer.stop();
-    }
-
-    public void enableRefresh() {
-        this.refreshButton.setEnabled(true);
-        this.autoRefreshLabel.setEnabled(true);
-        this.autoRefreshComboBox.setEnabled(true);
-        updateAutoRefreshTimer();
-    }
-
-    @Override
-    public void latestPreviewChanged() {
-        setTaskThreadToPreview(this.previewedThread);
-    }
+	private static final long serialVersionUID = 1L;
+
+	public static final String[] autoFreqStrings = { "never", "every second", "every 5 seconds", "every 10 seconds",
+			"every 30 seconds", "every minute" };
+
+	public static final int[] autoFreqTimeSecs = { 0, 1, 5, 10, 30, 60 };
+
+	protected ExpTaskThread previewedThread;
+
+	protected JLabel previewLabel = new JLabel("No preview available");
+
+	protected JButton refreshButton = new JButton("Refresh");
+
+	protected JLabel autoRefreshLabel = new JLabel("Auto refresh: ");
+
+	protected JComboBox autoRefreshComboBox = new JComboBox(autoFreqStrings);
+
+	protected TaskTextViewerPanel textViewerPanel; // = new TaskTextViewerPanel();
+
+	protected javax.swing.Timer autoRefreshTimer;
+
+	public enum TypePanel {
+		CLASSIFICATION(new Accuracy()), REGRESSION(new RegressionAccuracy()),
+		CONCEPT_DRIFT(new ChangeDetectionMeasures());
+
+		private final MeasureCollection measureCollection;
+
+		// Constructor
+		TypePanel(MeasureCollection measureCollection) {
+			this.measureCollection = measureCollection;
+		}
+
+		public MeasureCollection getMeasureCollection() {
+			return (MeasureCollection) this.measureCollection.copy();
+		}
+	}
+
+	public ExpPreviewPanel() {
+		this(TypePanel.CLASSIFICATION, null);
+	}
+
+	public ExpPreviewPanel(TypePanel typePanel) {
+		this(typePanel, null);
+	}
+
+	public ExpPreviewPanel(TypePanel typePanel, CDTaskManagerPanel taskManagerPanel) {
+		this.textViewerPanel = new TaskTextViewerPanel(typePanel, taskManagerPanel);
+		this.autoRefreshComboBox.setSelectedIndex(1); // default to 1 sec
+		JPanel controlPanel = new JPanel();
+		controlPanel.add(this.previewLabel);
+		controlPanel.add(this.refreshButton);
+		controlPanel.add(this.autoRefreshLabel);
+		controlPanel.add(this.autoRefreshComboBox);
+		setLayout(new BorderLayout());
+		add(controlPanel, BorderLayout.NORTH);
+		add(this.textViewerPanel, BorderLayout.CENTER);
+		this.refreshButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				refresh();
+			}
+		});
+		this.autoRefreshTimer = new javax.swing.Timer(1000, new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				refresh();
+			}
+		});
+		this.autoRefreshComboBox.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent arg0) {
+				updateAutoRefreshTimer();
+			}
+		});
+		setTaskThreadToPreview(null);
+	}
+
+	public void refresh() {
+		if (this.previewedThread != null) {
+			if (this.previewedThread.isComplete()) {
+				setLatestPreview(null);
+				disableRefresh();
+			} else {
+				this.previewedThread.getPreview(ExpPreviewPanel.this);
+			}
+		}
+	}
+
+	public void setTaskThreadToPreview(ExpTaskThread thread) {
+		this.previewedThread = thread;
+		setLatestPreview(thread != null ? thread.getLatestResultPreview() : null);
+		if (thread == null) {
+			disableRefresh();
+		} else if (!thread.isComplete()) {
+			enableRefresh();
+		}
+	}
+
+	public void setLatestPreview(Object preview) {
+		if ((this.previewedThread != null) && this.previewedThread.isComplete()) {
+			this.previewLabel.setText("Final result");
+			Object finalResult = this.previewedThread.getFinalResult();
+			this.textViewerPanel.setText(finalResult != null ? finalResult.toString() : null);
+			disableRefresh();
+		} else {
+			double grabTime = this.previewedThread != null ? this.previewedThread.getLatestPreviewGrabTimeSeconds()
+					: 0.0;
+			String grabString = grabTime > 0.0 ? (" (" + StringUtils.secondsToDHMSString(grabTime) + ")") : "";
+			this.textViewerPanel.setText(preview != null ? preview.toString() : null);
+			if (preview == null) {
+				this.previewLabel.setText("No preview available" + grabString);
+			} else {
+				this.previewLabel.setText("Preview" + grabString);
+			}
+		}
+	}
+
+	public void updateAutoRefreshTimer() {
+		int autoDelay = autoFreqTimeSecs[this.autoRefreshComboBox.getSelectedIndex()];
+		if (autoDelay > 0) {
+			if (this.autoRefreshTimer.isRunning()) {
+				this.autoRefreshTimer.stop();
+			}
+			this.autoRefreshTimer.setDelay(autoDelay * 1000);
+			this.autoRefreshTimer.start();
+		} else {
+			this.autoRefreshTimer.stop();
+		}
+	}
+
+	public void disableRefresh() {
+		this.refreshButton.setEnabled(false);
+		this.autoRefreshLabel.setEnabled(false);
+		this.autoRefreshComboBox.setEnabled(false);
+		this.autoRefreshTimer.stop();
+	}
+
+	public void enableRefresh() {
+		this.refreshButton.setEnabled(true);
+		this.autoRefreshLabel.setEnabled(true);
+		this.autoRefreshComboBox.setEnabled(true);
+		updateAutoRefreshTimer();
+	}
+
+	@Override
+	public void latestPreviewChanged() {
+		setTaskThreadToPreview(this.previewedThread);
+	}
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/ExpTaskThread.java b/moa/src/main/java/moa/gui/experimentertab/ExpTaskThread.java
index afc42ad4d..9ba0316c9 100644
--- a/moa/src/main/java/moa/gui/experimentertab/ExpTaskThread.java
+++ b/moa/src/main/java/moa/gui/experimentertab/ExpTaskThread.java
@@ -15,11 +15,12 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab;
 
 import java.util.concurrent.CopyOnWriteArraySet;
+
 import moa.core.ObjectRepository;
 import moa.core.TimingUtils;
 import moa.tasks.MainTask;
@@ -33,163 +34,169 @@
  * Task Thread.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @modified Alberto Verdecia (averdeciac@gmail.com)  
+ * @modified Alberto Verdecia (averdeciac@gmail.com)
  */
 public class ExpTaskThread extends Thread {
 
-    Buffer tasks;
-
-    public static enum Status {
-
-        NOT_STARTED, RUNNING, PAUSED, CANCELLING, CANCELLED, COMPLETED, FAILED
-    }
-
-    protected MainTask runningTask;
-    
-    protected volatile Status currentStatus;
-
-    protected TaskMonitor taskMonitor;
-
-    protected ObjectRepository repository;
-
-    protected Object finalResult;
-
-    protected long taskStartTime;
-
-    protected long taskEndTime;
-
-    protected double latestPreviewGrabTime = 0.0;
-    
-    public boolean isCompleted = false;
-
-    CopyOnWriteArraySet<TaskCompletionListener> completionListeners = new CopyOnWriteArraySet<TaskCompletionListener>();
-
-    public ExpTaskThread(Buffer buf) {
-        this.tasks = buf;
-        this.currentStatus = ExpTaskThread.Status.NOT_STARTED;
-        this.taskMonitor = new StandardTaskMonitor();
-        this.repository =null;
-       
-    }
-
-    @Override
-    public void run() {
-        TimingUtils.enablePreciseTiming();
-        this.taskStartTime = TimingUtils.getNanoCPUTimeOfThread(getId());
-        while (this.tasks.getCantTask() != this.tasks.getSize()) {
-            this.runningTask = this.tasks.getTask();
-            this.currentStatus = ExpTaskThread.Status.RUNNING;
-            this.taskMonitor.setCurrentActivityDescription("Running task " + this.runningTask);
-            this.finalResult = this.runningTask.doTask(this.taskMonitor, this.repository);
-            this.currentStatus = this.taskMonitor.isCancelled() ? ExpTaskThread.Status.CANCELLED
-                    : ExpTaskThread.Status.COMPLETED;
-            //System.out.println(this.taskMonitor.getCurrentActivityFractionComplete()*100); 
-        }
-        this.isCompleted = true;
-    }
-   public String getCurrentActivityString() {
-        return (isComplete() || (this.currentStatus == ExpTaskThread.Status.NOT_STARTED)) ? ""
-                : this.taskMonitor.getCurrentActivityDescription();
-    }
-       
-    public boolean isComplete() {
-        return ((this.currentStatus == ExpTaskThread.Status.CANCELLED)
-                || (this.currentStatus == ExpTaskThread.Status.COMPLETED) || (this.currentStatus == ExpTaskThread.Status.FAILED));
-    }
-    public double getCPUSecondsElapsed() {
-        double secondsElapsed = 0.0;
-        if (this.currentStatus == ExpTaskThread.Status.NOT_STARTED) {
-            secondsElapsed = 0.0;
-        } else if (isComplete()) {
-            secondsElapsed = TimingUtils.nanoTimeToSeconds(this.taskEndTime
-                    - this.taskStartTime);
-        } else {
-            secondsElapsed = TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfThread(getId())
-                    - this.taskStartTime);
-        }
-        return secondsElapsed > 0.0 ? secondsElapsed : 0.0;
-    }
-    public Task getTask() {
-        return this.runningTask;
-    }
-     public String getCurrentStatusString() {
-        switch (this.currentStatus) {
-            case NOT_STARTED:
-                return "not started";
-            case RUNNING:
-                return "running";
-            case PAUSED:
-                return "paused";
-            case CANCELLING:
-                return "cancelling";
-            case CANCELLED:
-                return "cancelled";
-            case COMPLETED:
-                return "completed";
-            case FAILED:
-                return "failed";
-        }
-        return "unknown";
-    }
-     public double getCurrentActivityFracComplete() {
-        switch (this.currentStatus) {
-            case NOT_STARTED:
-                return 0.0;
-            case RUNNING:
-            case PAUSED:
-            case CANCELLING:
-                return this.taskMonitor.getCurrentActivityFractionComplete();
-            case CANCELLED:
-            case COMPLETED:
-            case FAILED:
-                return 1.0;
-        }
-        return 0.0;
-    }
-      public Object getFinalResult() {
-        return this.finalResult;
-    }
-
-    public void addTaskCompletionListener(TaskCompletionListener tcl) {
-        this.completionListeners.add(tcl);
-    }
-
-    public void removeTaskCompletionListener(TaskCompletionListener tcl) {
-        this.completionListeners.remove(tcl);
-    }
-   
-    public void getPreview(ResultPreviewListener previewer) {
-        this.taskMonitor.requestResultPreview(previewer);
-        this.latestPreviewGrabTime = getCPUSecondsElapsed();
-    }
-
-    public Object getLatestResultPreview() {
-        return this.taskMonitor.getLatestResultPreview();
-    }
-
-    public double getLatestPreviewGrabTimeSeconds() {
-        return this.latestPreviewGrabTime;
-    }
-     public synchronized void pauseTask() {
-        if (this.currentStatus == Status.RUNNING) {
-            this.taskMonitor.requestPause();
-            this.currentStatus = Status.PAUSED;
-        }
-    }
-
-    public synchronized void resumeTask() {
-        if (this.currentStatus == Status.PAUSED) {
-            this.taskMonitor.requestResume();
-            this.currentStatus = Status.RUNNING;
-        }
-    }
-
-    public synchronized void cancelTask() {
-        if ((this.currentStatus == Status.RUNNING)
-                || (this.currentStatus == Status.PAUSED)) {
-            this.taskMonitor.requestCancel();
-            this.currentStatus = Status.CANCELLING;
-        }
-    }
-   
+	Buffer tasks;
+
+	public enum Status {
+
+		NOT_STARTED, RUNNING, PAUSED, CANCELLING, CANCELLED, COMPLETED, FAILED
+	}
+
+	protected MainTask runningTask;
+
+	protected volatile Status currentStatus;
+
+	protected TaskMonitor taskMonitor;
+
+	protected ObjectRepository repository;
+
+	protected Object finalResult;
+
+	protected long taskStartTime;
+
+	protected long taskEndTime;
+
+	protected double latestPreviewGrabTime = 0.0;
+
+	public boolean isCompleted = false;
+
+	CopyOnWriteArraySet<TaskCompletionListener> completionListeners = new CopyOnWriteArraySet<>();
+
+	public ExpTaskThread(Buffer buf) {
+		this.tasks = buf;
+		this.currentStatus = ExpTaskThread.Status.NOT_STARTED;
+		this.taskMonitor = new StandardTaskMonitor();
+		this.repository = null;
+
+	}
+
+	@Override
+	public void run() {
+		TimingUtils.enablePreciseTiming();
+		this.taskStartTime = TimingUtils.getNanoCPUTimeOfThread(getId());
+		while (this.tasks.getCantTask() != this.tasks.getSize()) {
+			this.runningTask = this.tasks.getTask();
+			this.currentStatus = ExpTaskThread.Status.RUNNING;
+			this.taskMonitor.setCurrentActivityDescription("Running task " + this.runningTask);
+			this.finalResult = this.runningTask.doTask(this.taskMonitor, this.repository);
+			this.currentStatus = this.taskMonitor.isCancelled() ? ExpTaskThread.Status.CANCELLED
+					: ExpTaskThread.Status.COMPLETED;
+			// System.out.println(this.taskMonitor.getCurrentActivityFractionComplete()*100);
+		}
+		this.isCompleted = true;
+	}
+
+	public String getCurrentActivityString() {
+		return (isComplete() || (this.currentStatus == ExpTaskThread.Status.NOT_STARTED)) ? ""
+				: this.taskMonitor.getCurrentActivityDescription();
+	}
+
+	public boolean isComplete() {
+		return ((this.currentStatus == ExpTaskThread.Status.CANCELLED)
+				|| (this.currentStatus == ExpTaskThread.Status.COMPLETED)
+				|| (this.currentStatus == ExpTaskThread.Status.FAILED));
+	}
+
+	public double getCPUSecondsElapsed() {
+		double secondsElapsed = 0.0;
+		if (this.currentStatus == ExpTaskThread.Status.NOT_STARTED) {
+			secondsElapsed = 0.0;
+		} else if (isComplete()) {
+			secondsElapsed = TimingUtils.nanoTimeToSeconds(this.taskEndTime - this.taskStartTime);
+		} else {
+			secondsElapsed = TimingUtils
+					.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfThread(getId()) - this.taskStartTime);
+		}
+		return secondsElapsed > 0.0 ? secondsElapsed : 0.0;
+	}
+
+	public Task getTask() {
+		return this.runningTask;
+	}
+
+	public String getCurrentStatusString() {
+		switch (this.currentStatus) {
+		case NOT_STARTED:
+			return "not started";
+		case RUNNING:
+			return "running";
+		case PAUSED:
+			return "paused";
+		case CANCELLING:
+			return "cancelling";
+		case CANCELLED:
+			return "cancelled";
+		case COMPLETED:
+			return "completed";
+		case FAILED:
+			return "failed";
+		}
+		return "unknown";
+	}
+
+	public double getCurrentActivityFracComplete() {
+		switch (this.currentStatus) {
+		case NOT_STARTED:
+			return 0.0;
+		case RUNNING:
+		case PAUSED:
+		case CANCELLING:
+			return this.taskMonitor.getCurrentActivityFractionComplete();
+		case CANCELLED:
+		case COMPLETED:
+		case FAILED:
+			return 1.0;
+		}
+		return 0.0;
+	}
+
+	public Object getFinalResult() {
+		return this.finalResult;
+	}
+
+	public void addTaskCompletionListener(TaskCompletionListener tcl) {
+		this.completionListeners.add(tcl);
+	}
+
+	public void removeTaskCompletionListener(TaskCompletionListener tcl) {
+		this.completionListeners.remove(tcl);
+	}
+
+	public void getPreview(ResultPreviewListener previewer) {
+		this.taskMonitor.requestResultPreview(previewer);
+		this.latestPreviewGrabTime = getCPUSecondsElapsed();
+	}
+
+	public Object getLatestResultPreview() {
+		return this.taskMonitor.getLatestResultPreview();
+	}
+
+	public double getLatestPreviewGrabTimeSeconds() {
+		return this.latestPreviewGrabTime;
+	}
+
+	public synchronized void pauseTask() {
+		if (this.currentStatus == Status.RUNNING) {
+			this.taskMonitor.requestPause();
+			this.currentStatus = Status.PAUSED;
+		}
+	}
+
+	public synchronized void resumeTask() {
+		if (this.currentStatus == Status.PAUSED) {
+			this.taskMonitor.requestResume();
+			this.currentStatus = Status.RUNNING;
+		}
+	}
+
+	public synchronized void cancelTask() {
+		if ((this.currentStatus == Status.RUNNING) || (this.currentStatus == Status.PAUSED)) {
+			this.taskMonitor.requestCancel();
+			this.currentStatus = Status.CANCELLING;
+		}
+	}
+
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/ExperimenterTabPanel.java b/moa/src/main/java/moa/gui/experimentertab/ExperimenterTabPanel.java
index 580eb9214..8fb66527e 100644
--- a/moa/src/main/java/moa/gui/experimentertab/ExperimenterTabPanel.java
+++ b/moa/src/main/java/moa/gui/experimentertab/ExperimenterTabPanel.java
@@ -6,7 +6,9 @@
 package moa.gui.experimentertab;
 
 import java.awt.BorderLayout;
+
 import javax.swing.JTabbedPane;
+
 import moa.gui.AbstractTabPanel;
 
 /**
@@ -15,42 +17,43 @@
  */
 public class ExperimenterTabPanel extends AbstractTabPanel {
 
-    private static final long serialVersionUID = 1L;
-    
-    protected TaskManagerTabPanel taskTabManagerPanel;
-
-    protected ExpPreviewPanel previewPanel;
-
-    protected JTabbedPane tabs = new JTabbedPane();
-
-    /**
-     *Initializes the different tabs of the application
-     */
-    public ExperimenterTabPanel() {
-        //this.taskManagerPanel = new TaskManagerPanel();
-        this.taskTabManagerPanel = new TaskManagerTabPanel();
-        tabs.addTab("Experiments", this.taskTabManagerPanel);
-        tabs.addTab("Summary", this.taskTabManagerPanel.summary);
-        tabs.addTab("Plot", this.taskTabManagerPanel.plot);
-        tabs.addTab("Analyze", this.taskTabManagerPanel.analizeTab);
-        this.previewPanel = new ExpPreviewPanel();
-        //this.taskTabManagerPanel.setPreviewPanel(this.previewPanel);
-        //this.taskManagerPanel.setPreviewPanel(this.previewPanel);
-       // tabs.addTab("Analyze", this.previewPanel);
-        setLayout(new BorderLayout());
-        add(this.tabs);
-        //add(this.previewPanel, BorderLayout.CENTER);
-    }
-
-    //returns the string to display as title of the tab
-    @Override
-    public String getTabTitle() {
-        return "Experimenter";
-    }
-
-    //a short description (can be used as tool tip) of the tab, or contributor, etc.
-    @Override
-    public String getDescription() {
-        return "MOA Classification";
-    }
+	private static final long serialVersionUID = 1L;
+
+	protected TaskManagerTabPanel taskTabManagerPanel;
+
+	protected ExpPreviewPanel previewPanel;
+
+	protected JTabbedPane tabs = new JTabbedPane();
+
+	/**
+	 * Initializes the different tabs of the application
+	 */
+	public ExperimenterTabPanel() {
+		// this.taskManagerPanel = new TaskManagerPanel();
+		this.taskTabManagerPanel = new TaskManagerTabPanel();
+		tabs.addTab("Experiments", this.taskTabManagerPanel);
+		tabs.addTab("Summary", this.taskTabManagerPanel.summary);
+		tabs.addTab("Plot", this.taskTabManagerPanel.plot);
+		tabs.addTab("Analyze", this.taskTabManagerPanel.analizeTab);
+		this.previewPanel = new ExpPreviewPanel();
+		// this.taskTabManagerPanel.setPreviewPanel(this.previewPanel);
+		// this.taskManagerPanel.setPreviewPanel(this.previewPanel);
+		// tabs.addTab("Analyze", this.previewPanel);
+		setLayout(new BorderLayout());
+		add(this.tabs);
+		// add(this.previewPanel, BorderLayout.CENTER);
+	}
+
+	// returns the string to display as title of the tab
+	@Override
+	public String getTabTitle() {
+		return "Experimenter";
+	}
+
+	// a short description (can be used as tool tip) of the tab, or contributor,
+	// etc.
+	@Override
+	public String getDescription() {
+		return "MOA Classification";
+	}
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/ExperimeterCLI.java b/moa/src/main/java/moa/gui/experimentertab/ExperimeterCLI.java
index cca8dffc2..812495a9b 100644
--- a/moa/src/main/java/moa/gui/experimentertab/ExperimeterCLI.java
+++ b/moa/src/main/java/moa/gui/experimentertab/ExperimeterCLI.java
@@ -9,6 +9,7 @@
 import java.io.IOException;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+
 import org.apache.commons.cli.BasicParser;
 import org.apache.commons.cli.CommandLine;
 import org.apache.commons.cli.CommandLineParser;
@@ -21,312 +22,317 @@
  * @author Alberto
  */
 public class ExperimeterCLI {
-    
-    private String algorithms[];
-    private String algorithmsID[];
-    private String streams[];
-    private String streamsID[];
-    private String task;
-    private String resultsFolder;
-    private String saveExperimentsPath;
-    private String args[];
-    private int threads = 1;
-    
-    public int[] measures = null;
-    public String[] types = null;
-    Options options = new Options();
-    Options optionsm = new Options();
-    
-    public ExperimeterCLI(String[] args) {
-        this.args = args;
-        //Config the options
-
-        options.addOption("ls", true, "The names of the algorithms separated by commas");
-        options.addOption("lss", true, "ID of the algorithms separated by commas");
-        options.addOption("ds", true, "The names of the streams separated by commas");
-        options.addOption("dss", true, "ID of the streams separated by commas");
-        options.addOption("rf", true, "Results folder");
-        options.addOption("th", true, "Number of threads");
-        options.addOption("ts", true, "Task");
-        options.addOption("h", "help", false, "Prints the help message");
-        
-        optionsm.addOption("h", "help", false, "Prints the help message");
-        optionsm.addOption("m", true, "The number of measures separated by commas");
-        optionsm.addOption("tm", true, "The types of measures separated by commas, the types are Mean and Last");
-    }
-    
-    public boolean summary1CMD(String[] args) {
-        
-        CommandLineParser parser = null;
-        CommandLine cmdLine = null;
-        
-        try {
-            parser = new BasicParser();
-            cmdLine = parser.parse(optionsm, args);
-            if (cmdLine.hasOption("h")) {
-                new HelpFormatter().printHelp(ExperimeterCLI.class.getCanonicalName(), optionsm);
-                return false;
-            }
-            String measure = cmdLine.getOptionValue("m");
-            if (measure == null) {
-                System.out.println("The measures are required");
-                return false;
-            }
-            if (measure.contains(",")) {
-                String[] m = measure.split(",");
-                measures = new int[m.length];
-                for (int i = 0; i < m.length; i++) {
-                    measures[i] = Integer.parseInt(m[i]);
-                }
-            } else {
-                measures = new int[1];
-                measures[0] = Integer.parseInt(measure);
-            }
-            
-            if (cmdLine.hasOption("tm")) {
-                String type = cmdLine.getOptionValue("tm");
-                if (type.contains(",")) {
-                    types = type.split(",");
-                } else {
-                    types = new String[1];
-                    types[0] = type;
-                }
-            } else {
-                types = new String[measures.length];
-                for (int i = 0; i < types.length; i++) {
-                    types[i] = "Mean";
-                }
-            }
-        } catch (org.apache.commons.cli.ParseException ex) {
-            System.out.println(ex.getMessage());
-            
-            new HelpFormatter().printHelp(ExperimeterCLI.class.getCanonicalName(), optionsm);    // Error, imprimimos la ayuda  
-        } catch (java.lang.NumberFormatException ex) {
-            new HelpFormatter().printHelp(ExperimeterCLI.class.getCanonicalName(), optionsm);    // Error, imprimimos la ayuda  
-        }
-        return true;
-    }
-    
-    public boolean proccesCMD(){
-        int threads = 1;
-        String algNames = null;
-        String algShortNames = null;
-        String streamNames = null;
-        String streamShortNames = null;
-        String task = null;
-        String resultsFolder = null;
-        
-        CommandLineParser parser = null;
-        CommandLine cmdLine = null;
-        
-        try {
-            //Parse the input with the set configuration
-            parser = new BasicParser();
-            cmdLine = parser.parse(options, args);
-            if (cmdLine.hasOption("h")) {
-                new HelpFormatter().printHelp(ExperimeterCLI.class.getCanonicalName(), options);
-                return false;
-            }
-            
-            if (cmdLine.hasOption("th")) {
-                threads = Integer.parseInt(cmdLine.getOptionValue("th"));
-                this.setThreads(threads);
-            }
-            
-            task = cmdLine.getOptionValue("ts");
-            if (task == null) {
-                throw new org.apache.commons.cli.ParseException("The task is required");
-            }
-            this.setTask(task);
-            //Algorithms names
-            algNames = cmdLine.getOptionValue("ls");
-            
-            if (algNames == null) {
-                throw new org.apache.commons.cli.ParseException("The name of the algorithms are required");
-            }
-            
-            try {
-                if (algNames.contains(",")) {
-                    this.setAlgorithms(algNames.split(","));
-                } else {
-                    String alg[] = new String[1];
-                    alg[0] = algNames;
-                    this.setAlgorithms(alg);
-                }
-                
-            } catch (Exception e) {
-                System.out.println("Problems with algortihms ls options");
-                new HelpFormatter().printHelp(ExperimeterCLI.class.getCanonicalName(), options);
-            }
-
-            //Agorithms ID 
-            if (cmdLine.hasOption("lss")) {
-                
-                algShortNames = cmdLine.getOptionValue("lss");
-                if (algShortNames.contains(",")) {
-                    this.setAlgorithmsID(algShortNames.split(","));
-                } else {
-                    String ash[] = new String[1];
-                    ash[0] = algShortNames;
-                    this.setAlgorithmsID(ash);
-                }
-                
-            } else {
-                this.setAlgorithmsID(this.getAlgorithms());
-            }
-            //Streams names
-            streamNames = cmdLine.getOptionValue("ds");
-            
-            if (streamNames == null) {
-                throw new org.apache.commons.cli.ParseException("The name of the streams are required");
-            }
-            
-            if (streamNames.contains(",")) {
-                this.setStreams(streamNames.split(","));
-                for (int i = 0; i < this.getStreams().length; i++) {
-                    String ds = this.getStreams()[i];
-                    if (ds.contains(":")) {
-                        String dir = ds.split(":")[0];
-                        if (dir.contains(File.separator)) {
-                            dir = dir.split(File.separator + File.separator)[0];
-                            ds = dir + ":" + ds.split(":")[1];
-                            this.setStreamIndex(i, ds);
-                        }
-                        
-                    }
-                }
-            } else {
-                String str[] = new String[1];
-                str[0] = FilenameUtils.separatorsToSystem(streamNames);
-                this.setStreams(str);
-                
-            }
-
-            //stream ID 
-            if (cmdLine.hasOption("dss")) {
-                streamShortNames = cmdLine.getOptionValue("dss");
-                if (streamShortNames.contains(",")) {
-                    this.setStreamsID(streamShortNames.split(","));
-                } else {
-                    String strh[] = new String[1];
-                    strh[0] = streamShortNames;
-                    this.setStreamsID(strh);
-                }
-                
-            } else {
-                this.setStreamsID(this.getStreams());
-            }
-            //Results folder
-            resultsFolder = cmdLine.getOptionValue("rf");
-            
-            if (resultsFolder == null) {
-                //throw new org.apache.commons.cli.ParseException("The resuts folder are required");
-                File excPath = new File(".");
-                try {
-                    resultsFolder = excPath.getCanonicalPath();
-                } catch (IOException ex) {
-                    Logger.getLogger(ExperimeterCLI.class.getName()).log(Level.SEVERE, null, ex);
-                }
-            }
-            if (resultsFolder.contains(":")) {
-                String dir = resultsFolder.split(":")[0];
-                if (dir.contains(File.separator)) {
-                    dir = dir.split(File.separator + File.separator)[0];
-                    resultsFolder = dir + ":" + resultsFolder.split(":")[1];
-                }
-            }
-            this.setResultsFolder(FilenameUtils.separatorsToSystem(resultsFolder));
-            // System.out.println("OK");  
-            // System.out.println(task);
-            // System.out.println(algNames);
-            // System.out.println(streamNames);
-
-        } catch (org.apache.commons.cli.ParseException ex) {
-            System.out.println(ex.getMessage());
-            new HelpFormatter().printHelp(ExperimeterCLI.class.getCanonicalName(), options);    // Error, print help
-            return false;
-        } catch (java.lang.NumberFormatException ex) {
-            new HelpFormatter().printHelp(ExperimeterCLI.class.getCanonicalName(), options);    // Error, print help 
-            return false;
-        }
-        return true;
-    }
-    
-    public String[] getAlgorithms() {
-        return algorithms;
-    }
-    
-    public String[] getAlgorithmsID() {
-        return algorithmsID;
-    }
-    
-    public String[] getArgs() {
-        return args;
-    }
-    
-    public String getResultsFolder() {
-        return resultsFolder;
-    }
-    
-    public String getSaveExperimentsPath() {
-        return saveExperimentsPath;
-    }
-    
-    public String[] getStreams() {
-        return streams;
-    }
-    
-    public String[] getStreamsID() {
-        return streamsID;
-    }
-    
-    public String getTask() {
-        return task;
-    }
-    
-    public int getThreads() {
-        return threads;
-    }
-    
-    public void setAlgorithms(String[] algorithms) {
-        this.algorithms = algorithms;
-    }
-    
-    public void setAlgorithmsID(String[] algorithmsID) {
-        this.algorithmsID = algorithmsID;
-    }
-    
-    public void setArgs(String[] args) {
-        this.args = args;
-    }
-    
-    public void setResultsFolder(String resultsFolder) {
-        this.resultsFolder = resultsFolder;
-    }
-    
-    public void setSaveExperimentsPath(String saveExperimentsPath) {
-        this.saveExperimentsPath = saveExperimentsPath;
-    }
-    
-    public void setStreams(String[] streams) {
-        for(int i = 0; i < streams.length; i++){
-            streams[i] =  FilenameUtils.separatorsToSystem(streams[i]);
-        }
-        this.streams = streams;
-    }
-    
-    public void setStreamsID(String[] streamsID) {
-        this.streamsID = streamsID;
-    }
-     public void setStreamIndex(int index, String streamID) {
-        this.streams[index] = streamID;
-    }
-    public void setTask(String task) {
-        this.task = task;
-    }
-    
-    public void setThreads(int threads) {
-        this.threads = threads;
-    }
-    
+
+	private String algorithms[];
+	private String algorithmsID[];
+	private String streams[];
+	private String streamsID[];
+	private String task;
+	private String resultsFolder;
+	private String saveExperimentsPath;
+	private String args[];
+	private int threads = 1;
+
+	public int[] measures = null;
+	public String[] types = null;
+	Options options = new Options();
+	Options optionsm = new Options();
+
+	public ExperimeterCLI(String[] args) {
+		this.args = args;
+		// Config the options
+
+		options.addOption("ls", true, "The names of the algorithms separated by commas");
+		options.addOption("lss", true, "ID of the algorithms separated by commas");
+		options.addOption("ds", true, "The names of the streams separated by commas");
+		options.addOption("dss", true, "ID of the streams separated by commas");
+		options.addOption("rf", true, "Results folder");
+		options.addOption("th", true, "Number of threads");
+		options.addOption("ts", true, "Task");
+		options.addOption("h", "help", false, "Prints the help message");
+
+		optionsm.addOption("h", "help", false, "Prints the help message");
+		optionsm.addOption("m", true, "The number of measures separated by commas");
+		optionsm.addOption("tm", true, "The types of measures separated by commas, the types are Mean and Last");
+	}
+
+	public boolean summary1CMD(String[] args) {
+
+		CommandLineParser parser = null;
+		CommandLine cmdLine = null;
+
+		try {
+			parser = new BasicParser();
+			cmdLine = parser.parse(optionsm, args);
+			if (cmdLine.hasOption("h")) {
+				new HelpFormatter().printHelp(ExperimeterCLI.class.getCanonicalName(), optionsm);
+				return false;
+			}
+			String measure = cmdLine.getOptionValue("m");
+			if (measure == null) {
+				System.out.println("The measures are required");
+				return false;
+			}
+			if (measure.contains(",")) {
+				String[] m = measure.split(",");
+				measures = new int[m.length];
+				for (int i = 0; i < m.length; i++) {
+					measures[i] = Integer.parseInt(m[i]);
+				}
+			} else {
+				measures = new int[1];
+				measures[0] = Integer.parseInt(measure);
+			}
+
+			if (cmdLine.hasOption("tm")) {
+				String type = cmdLine.getOptionValue("tm");
+				if (type.contains(",")) {
+					types = type.split(",");
+				} else {
+					types = new String[1];
+					types[0] = type;
+				}
+			} else {
+				types = new String[measures.length];
+				for (int i = 0; i < types.length; i++) {
+					types[i] = "Mean";
+				}
+			}
+		} catch (org.apache.commons.cli.ParseException ex) {
+			System.out.println(ex.getMessage());
+
+			new HelpFormatter().printHelp(ExperimeterCLI.class.getCanonicalName(), optionsm); // Error, imprimimos la
+																								// ayuda
+		} catch (java.lang.NumberFormatException ex) {
+			new HelpFormatter().printHelp(ExperimeterCLI.class.getCanonicalName(), optionsm); // Error, imprimimos la
+																								// ayuda
+		}
+		return true;
+	}
+
+	public boolean proccesCMD() {
+		int threads = 1;
+		String algNames = null;
+		String algShortNames = null;
+		String streamNames = null;
+		String streamShortNames = null;
+		String task = null;
+		String resultsFolder = null;
+
+		CommandLineParser parser = null;
+		CommandLine cmdLine = null;
+
+		try {
+			// Parse the input with the set configuration
+			parser = new BasicParser();
+			cmdLine = parser.parse(options, args);
+			if (cmdLine.hasOption("h")) {
+				new HelpFormatter().printHelp(ExperimeterCLI.class.getCanonicalName(), options);
+				return false;
+			}
+
+			if (cmdLine.hasOption("th")) {
+				threads = Integer.parseInt(cmdLine.getOptionValue("th"));
+				this.setThreads(threads);
+			}
+
+			task = cmdLine.getOptionValue("ts");
+			if (task == null) {
+				throw new org.apache.commons.cli.ParseException("The task is required");
+			}
+			this.setTask(task);
+			// Algorithms names
+			algNames = cmdLine.getOptionValue("ls");
+
+			if (algNames == null) {
+				throw new org.apache.commons.cli.ParseException("The name of the algorithms are required");
+			}
+
+			try {
+				if (algNames.contains(",")) {
+					this.setAlgorithms(algNames.split(","));
+				} else {
+					String alg[] = new String[1];
+					alg[0] = algNames;
+					this.setAlgorithms(alg);
+				}
+
+			} catch (Exception e) {
+				System.out.println("Problems with algortihms ls options");
+				new HelpFormatter().printHelp(ExperimeterCLI.class.getCanonicalName(), options);
+			}
+
+			// Agorithms ID
+			if (cmdLine.hasOption("lss")) {
+
+				algShortNames = cmdLine.getOptionValue("lss");
+				if (algShortNames.contains(",")) {
+					this.setAlgorithmsID(algShortNames.split(","));
+				} else {
+					String ash[] = new String[1];
+					ash[0] = algShortNames;
+					this.setAlgorithmsID(ash);
+				}
+
+			} else {
+				this.setAlgorithmsID(this.getAlgorithms());
+			}
+			// Streams names
+			streamNames = cmdLine.getOptionValue("ds");
+
+			if (streamNames == null) {
+				throw new org.apache.commons.cli.ParseException("The name of the streams are required");
+			}
+
+			if (streamNames.contains(",")) {
+				this.setStreams(streamNames.split(","));
+				for (int i = 0; i < this.getStreams().length; i++) {
+					String ds = this.getStreams()[i];
+					if (ds.contains(":")) {
+						String dir = ds.split(":")[0];
+						if (dir.contains(File.separator)) {
+							dir = dir.split(File.separator + File.separator)[0];
+							ds = dir + ":" + ds.split(":")[1];
+							this.setStreamIndex(i, ds);
+						}
+
+					}
+				}
+			} else {
+				String str[] = new String[1];
+				str[0] = FilenameUtils.separatorsToSystem(streamNames);
+				this.setStreams(str);
+
+			}
+
+			// stream ID
+			if (cmdLine.hasOption("dss")) {
+				streamShortNames = cmdLine.getOptionValue("dss");
+				if (streamShortNames.contains(",")) {
+					this.setStreamsID(streamShortNames.split(","));
+				} else {
+					String strh[] = new String[1];
+					strh[0] = streamShortNames;
+					this.setStreamsID(strh);
+				}
+
+			} else {
+				this.setStreamsID(this.getStreams());
+			}
+			// Results folder
+			resultsFolder = cmdLine.getOptionValue("rf");
+
+			if (resultsFolder == null) {
+				// throw new org.apache.commons.cli.ParseException("The resuts folder are
+				// required");
+				File excPath = new File(".");
+				try {
+					resultsFolder = excPath.getCanonicalPath();
+				} catch (IOException ex) {
+					Logger.getLogger(ExperimeterCLI.class.getName()).log(Level.SEVERE, null, ex);
+				}
+			}
+			if (resultsFolder.contains(":")) {
+				String dir = resultsFolder.split(":")[0];
+				if (dir.contains(File.separator)) {
+					dir = dir.split(File.separator + File.separator)[0];
+					resultsFolder = dir + ":" + resultsFolder.split(":")[1];
+				}
+			}
+			this.setResultsFolder(FilenameUtils.separatorsToSystem(resultsFolder));
+			// System.out.println("OK");
+			// System.out.println(task);
+			// System.out.println(algNames);
+			// System.out.println(streamNames);
+
+		} catch (org.apache.commons.cli.ParseException ex) {
+			System.out.println(ex.getMessage());
+			new HelpFormatter().printHelp(ExperimeterCLI.class.getCanonicalName(), options); // Error, print help
+			return false;
+		} catch (java.lang.NumberFormatException ex) {
+			new HelpFormatter().printHelp(ExperimeterCLI.class.getCanonicalName(), options); // Error, print help
+			return false;
+		}
+		return true;
+	}
+
+	public String[] getAlgorithms() {
+		return algorithms;
+	}
+
+	public String[] getAlgorithmsID() {
+		return algorithmsID;
+	}
+
+	public String[] getArgs() {
+		return args;
+	}
+
+	public String getResultsFolder() {
+		return resultsFolder;
+	}
+
+	public String getSaveExperimentsPath() {
+		return saveExperimentsPath;
+	}
+
+	public String[] getStreams() {
+		return streams;
+	}
+
+	public String[] getStreamsID() {
+		return streamsID;
+	}
+
+	public String getTask() {
+		return task;
+	}
+
+	public int getThreads() {
+		return threads;
+	}
+
+	public void setAlgorithms(String[] algorithms) {
+		this.algorithms = algorithms;
+	}
+
+	public void setAlgorithmsID(String[] algorithmsID) {
+		this.algorithmsID = algorithmsID;
+	}
+
+	public void setArgs(String[] args) {
+		this.args = args;
+	}
+
+	public void setResultsFolder(String resultsFolder) {
+		this.resultsFolder = resultsFolder;
+	}
+
+	public void setSaveExperimentsPath(String saveExperimentsPath) {
+		this.saveExperimentsPath = saveExperimentsPath;
+	}
+
+	public void setStreams(String[] streams) {
+		for (int i = 0; i < streams.length; i++) {
+			streams[i] = FilenameUtils.separatorsToSystem(streams[i]);
+		}
+		this.streams = streams;
+	}
+
+	public void setStreamsID(String[] streamsID) {
+		this.streamsID = streamsID;
+	}
+
+	public void setStreamIndex(int index, String streamID) {
+		this.streams[index] = streamID;
+	}
+
+	public void setTask(String task) {
+		this.task = task;
+	}
+
+	public void setThreads(int threads) {
+		this.threads = threads;
+	}
+
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/ImageChart.java b/moa/src/main/java/moa/gui/experimentertab/ImageChart.java
index 8acbc00a6..57cb7e9f7 100644
--- a/moa/src/main/java/moa/gui/experimentertab/ImageChart.java
+++ b/moa/src/main/java/moa/gui/experimentertab/ImageChart.java
@@ -1,6 +1,6 @@
 /*
  *    ImageChart.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand 
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
  *    @author Alberto Verdecia Cabrera (averdeciac@gmail.com)
  *
  *    This program is free software; you can redistribute it and/or modify
@@ -15,22 +15,20 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab;
 
-import java.awt.Color;
 import java.awt.Graphics2D;
-import java.awt.Rectangle;
 import java.awt.geom.Rectangle2D;
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileWriter;
 import java.io.IOException;
-import java.io.Writer;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+
 import org.jfree.chart.ChartUtilities;
 import org.jfree.chart.JFreeChart;
 
@@ -42,198 +40,201 @@
  */
 public class ImageChart {
 
-    private String name;
-
-    private JFreeChart chart;
-
-    private int width;
-
-    private int height;
-
-    /**
-     * Default constructor.
-     */
-    public ImageChart() {
-    }
-
-    /**
-     * Constructor.
-     *
-     * @param name
-     * @param chart
-     * @param width
-     * @param height
-     */
-    public ImageChart(String name, JFreeChart chart, int width, int height) {
-        this.name = name;
-        this.chart = chart;
-        this.width = width;
-        this.height = height;
-    }
-
-    /**
-     * Constructor.
-     *
-     * @param name
-     * @param chart
-     */
-    public ImageChart(String name, JFreeChart chart) {
-        this.name = name;
-        this.chart = chart;
-    }
-
-    /**
-     * Set the image name.
-     *
-     * @param name
-     */
-    public void setName(String name) {
-        this.name = name;
-    }
-
-    /**
-     * Set chart.
-     *
-     * @param chart
-     */
-    public void setChart(JFreeChart chart) {
-        this.chart = chart;
-    }
-
-    /**
-     * Set chart height.
-     *
-     * @param height
-     */
-    public void setHeight(int height) {
-        this.height = height;
-    }
-
-    /**
-     * Set chart width.
-     *
-     * @param width
-     */
-    public void setWidth(int width) {
-        this.width = width;
-    }
-
-    /**
-     * Return the chart.
-     *
-     * @return chart
-     */
-    public JFreeChart getChart() {
-        return chart;
-    }
-
-    /**
-     * Return the name.
-     *
-     * @return name
-     */
-    public String getName() {
-        return name;
-    }
-
-    /**
-     * Return the height.
-     *
-     * @return height
-     */
-    public int getHeight() {
-        return height;
-    }
-
-    /**
-     * Return the width.
-     *
-     * @return width
-     */
-    public int getWidth() {
-        return width;
-    }
-
-    @Override
-    public String toString() {
-        return name; //To change body of generated methods, choose Tools | Templates.
-    }
-
-    /**
-     * Export the image to formats JPG, PNG, SVG and EPS.
-     *
-     * @param path
-     * @param type
-     * @throws IOException
-     */
-    public void exportIMG(String path, String type) throws IOException {
-
-        switch (type) {
-            case "JPG":
-                try {
-                    ChartUtilities.saveChartAsJPEG(new File(path + File.separator + name + ".jpg"), chart, width, height);
-                } catch (IOException e) {
-
-                }
-                break;
-            case "PNG":
-                try {
-                    ChartUtilities.saveChartAsPNG(new File(path + File.separator + name + ".png"), chart, width, height);
-                } catch (IOException e) {
-
-                }
-                break;
-            case "SVG":
-                String svg = generateSVG(width, height);
-                BufferedWriter writer = null;
-                try {
-                    writer = new BufferedWriter(new FileWriter(new File(path + File.separator + name + ".svg")));
-                    writer.write("<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n");
-                    writer.write(svg + "\n");
-                    writer.flush();
-                } finally {
-                    try {
-                        if (writer != null) {
-                            writer.close();
-                        }
-                    } catch (IOException ex) {
-                        throw new RuntimeException(ex);
-                    }
-                }
-                break;
-
-        }
-
-    }
-
-    private String generateSVG(int width, int height) {
-        Graphics2D g2 = createSVGGraphics2D(width, height);
-        if (g2 == null) {
-            throw new IllegalStateException("JFreeSVG library is not present.");
-        }
-        // we suppress shadow generation, because SVG is a vector format and
-        // the shadow effect is applied via bitmap effects...
-        g2.setRenderingHint(JFreeChart.KEY_SUPPRESS_SHADOW_GENERATION, true);
-        String svg = null;
-        Rectangle2D drawArea = new Rectangle2D.Double(0, 0, width, height);
-        this.chart.draw(g2, drawArea);
-        try {
-            Method m = g2.getClass().getMethod("getSVGElement");
-            svg = (String) m.invoke(g2);
-        } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
-            // null will be returned
-        }
-        return svg;
-    }
-
-    private Graphics2D createSVGGraphics2D(int w, int h) {
-        try {
-            Class svgGraphics2d = Class.forName("org.jfree.graphics2d.svg.SVGGraphics2D");
-            Constructor ctor = svgGraphics2d.getConstructor(int.class, int.class);
-            return (Graphics2D) ctor.newInstance(w, h);
-        } catch (ClassNotFoundException | NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) {
-            return null;
-        }
-    }
+	private String name;
+
+	private JFreeChart chart;
+
+	private int width;
+
+	private int height;
+
+	/**
+	 * Default constructor.
+	 */
+	public ImageChart() {
+	}
+
+	/**
+	 * Constructor.
+	 *
+	 * @param name
+	 * @param chart
+	 * @param width
+	 * @param height
+	 */
+	public ImageChart(String name, JFreeChart chart, int width, int height) {
+		this.name = name;
+		this.chart = chart;
+		this.width = width;
+		this.height = height;
+	}
+
+	/**
+	 * Constructor.
+	 *
+	 * @param name
+	 * @param chart
+	 */
+	public ImageChart(String name, JFreeChart chart) {
+		this.name = name;
+		this.chart = chart;
+	}
+
+	/**
+	 * Set the image name.
+	 *
+	 * @param name
+	 */
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	/**
+	 * Set chart.
+	 *
+	 * @param chart
+	 */
+	public void setChart(JFreeChart chart) {
+		this.chart = chart;
+	}
+
+	/**
+	 * Set chart height.
+	 *
+	 * @param height
+	 */
+	public void setHeight(int height) {
+		this.height = height;
+	}
+
+	/**
+	 * Set chart width.
+	 *
+	 * @param width
+	 */
+	public void setWidth(int width) {
+		this.width = width;
+	}
+
+	/**
+	 * Return the chart.
+	 *
+	 * @return chart
+	 */
+	public JFreeChart getChart() {
+		return chart;
+	}
+
+	/**
+	 * Return the name.
+	 *
+	 * @return name
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * Return the height.
+	 *
+	 * @return height
+	 */
+	public int getHeight() {
+		return height;
+	}
+
+	/**
+	 * Return the width.
+	 *
+	 * @return width
+	 */
+	public int getWidth() {
+		return width;
+	}
+
+	@Override
+	public String toString() {
+		return name; // To change body of generated methods, choose Tools | Templates.
+	}
+
+	/**
+	 * Export the image to formats JPG, PNG, SVG and EPS.
+	 *
+	 * @param path
+	 * @param type
+	 * @throws IOException
+	 */
+	public void exportIMG(String path, String type) throws IOException {
+
+		switch (type) {
+		case "JPG":
+			try {
+				ChartUtilities.saveChartAsJPEG(new File(path + File.separator + name + ".jpg"), chart, width, height);
+			} catch (IOException e) {
+
+			}
+			break;
+		case "PNG":
+			try {
+				ChartUtilities.saveChartAsPNG(new File(path + File.separator + name + ".png"), chart, width, height);
+			} catch (IOException e) {
+
+			}
+			break;
+		case "SVG":
+			String svg = generateSVG(width, height);
+			BufferedWriter writer = null;
+			try {
+				writer = new BufferedWriter(new FileWriter(new File(path + File.separator + name + ".svg")));
+				writer.write(
+						"<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n");
+				writer.write(svg + "\n");
+				writer.flush();
+			} finally {
+				try {
+					if (writer != null) {
+						writer.close();
+					}
+				} catch (IOException ex) {
+					throw new RuntimeException(ex);
+				}
+			}
+			break;
+
+		}
+
+	}
+
+	private String generateSVG(int width, int height) {
+		Graphics2D g2 = createSVGGraphics2D(width, height);
+		if (g2 == null) {
+			throw new IllegalStateException("JFreeSVG library is not present.");
+		}
+		// we suppress shadow generation, because SVG is a vector format and
+		// the shadow effect is applied via bitmap effects...
+		g2.setRenderingHint(JFreeChart.KEY_SUPPRESS_SHADOW_GENERATION, true);
+		String svg = null;
+		Rectangle2D drawArea = new Rectangle2D.Double(0, 0, width, height);
+		this.chart.draw(g2, drawArea);
+		try {
+			Method m = g2.getClass().getMethod("getSVGElement");
+			svg = (String) m.invoke(g2);
+		} catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException
+				| InvocationTargetException e) {
+			// null will be returned
+		}
+		return svg;
+	}
+
+	private Graphics2D createSVGGraphics2D(int w, int h) {
+		try {
+			Class svgGraphics2d = Class.forName("org.jfree.graphics2d.svg.SVGGraphics2D");
+			Constructor ctor = svgGraphics2d.getConstructor(int.class, int.class);
+			return (Graphics2D) ctor.newInstance(w, h);
+		} catch (ClassNotFoundException | NoSuchMethodException | SecurityException | InstantiationException
+				| IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) {
+			return null;
+		}
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/ImagePanel.java b/moa/src/main/java/moa/gui/experimentertab/ImagePanel.java
index ca6185daa..edb24d0d1 100644
--- a/moa/src/main/java/moa/gui/experimentertab/ImagePanel.java
+++ b/moa/src/main/java/moa/gui/experimentertab/ImagePanel.java
@@ -1,6 +1,6 @@
 /*
  *    ImagePanel.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand 
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
  *    @author Alberto Verdecia Cabrera (averdeciac@gmail.com)
  *
  *    This program is free software; you can redistribute it and/or modify
@@ -15,19 +15,22 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab;
 
 import java.io.File;
 import java.io.IOException;
+
 import javax.swing.JFileChooser;
 import javax.swing.JMenu;
 import javax.swing.JMenuItem;
 import javax.swing.JPopupMenu;
+
 import org.jfree.chart.ChartPanel;
 import org.jfree.chart.ChartUtilities;
 import org.jfree.chart.JFreeChart;
+
 import weka.gui.ExtensionFileFilter;
 
 /**
@@ -37,120 +40,118 @@
  */
 public class ImagePanel extends ChartPanel {
 
-    JFreeChart chart;
-
-    /**
-     * Class Constructor.
-     *
-     * @param chart
-     */
-    public ImagePanel(JFreeChart chart) {
-        super(chart);
-        this.chart = chart;
-    }
-
-    /**
-     * Method for save the images.
-     *
-     * @throws IOException
-     */
-    @Override
-    public void doSaveAs() throws IOException {
-
-        JFileChooser fileChooser = new JFileChooser();
-        ExtensionFileFilter filterPNG = new ExtensionFileFilter("PNG Image Files", ".png");
-        fileChooser.addChoosableFileFilter(filterPNG);
-
-        ExtensionFileFilter filterJPG = new ExtensionFileFilter("JPG Image Files", ".jpg");
-        fileChooser.addChoosableFileFilter(filterJPG);
-
-        ExtensionFileFilter filterEPS = new ExtensionFileFilter("EPS Image Files", ".eps");
-        fileChooser.addChoosableFileFilter(filterEPS);
-
-        ExtensionFileFilter filterSVG = new ExtensionFileFilter("SVG Image Files", ".svg");
-        fileChooser.addChoosableFileFilter(filterSVG);
-        fileChooser.setCurrentDirectory(null);
-        int option = fileChooser.showSaveDialog(this);
-        if (option == JFileChooser.APPROVE_OPTION) {
-            String fileDesc = fileChooser.getFileFilter().getDescription();
-            if (fileDesc.startsWith("PNG")) {
-                if (!fileChooser.getSelectedFile().getName().toUpperCase().endsWith("PNG")) {
-                    ChartUtilities.saveChartAsPNG(new File(fileChooser.getSelectedFile().getAbsolutePath() + ".png"), this.chart, this.getWidth(), this.getHeight());
-                } else {
-                    ChartUtilities.saveChartAsPNG(fileChooser.getSelectedFile(), this.chart, this.getWidth(), this.getHeight());
-                }
-            } else if (fileDesc.startsWith("JPG")) {
-                if (!fileChooser.getSelectedFile().getName().toUpperCase().endsWith("JPG")) {
-                    ChartUtilities.saveChartAsJPEG(new File(fileChooser.getSelectedFile().getAbsolutePath() + ".jpg"), this.chart, this.getWidth(), this.getHeight());
-                } else {
-                    ChartUtilities.saveChartAsJPEG(fileChooser.getSelectedFile(), this.chart, this.getWidth(), this.getHeight());
-                }
-            }
-
-        }//else
-    }
-
-    /**
-     *
-     * @param properties
-     * @param copy
-     * @param save
-     * @param print
-     * @param zoom
-     * @return JPopupMenu
-     */
-    @Override
-    protected JPopupMenu createPopupMenu(boolean properties,
-            boolean copy, boolean save, boolean print, boolean zoom) {
-        JPopupMenu result = new JPopupMenu(localizationResources.getString("Chart") + ":");
-        boolean separator = false;
-
-        if (properties) {
-            JMenuItem propertiesItem = new JMenuItem(
-                    localizationResources.getString("Properties..."));
-            propertiesItem.setActionCommand(PROPERTIES_COMMAND);
-            propertiesItem.addActionListener(this);
-            result.add(propertiesItem);
-            separator = true;
-        }
-
-        if (copy) {
-            if (separator) {
-                result.addSeparator();
-            }
-            JMenuItem copyItem = new JMenuItem(
-                    localizationResources.getString("Copy"));
-            copyItem.setActionCommand(COPY_COMMAND);
-            copyItem.addActionListener(this);
-            result.add(copyItem);
-            separator = !save;
-        }
-
-        if (save) {
-            if (separator) {
-                result.addSeparator();
-            }
-            JMenu saveSubMenu = new JMenu(localizationResources.getString(
-                    "Save_as"));
-            JMenuItem pngItem = new JMenuItem(localizationResources.getString(
-                    "PNG..."));
-
-            separator = true;
-        }
-
-        if (print) {
-            if (separator) {
-                result.addSeparator();
-            }
-            JMenuItem printItem = new JMenuItem(
-                    localizationResources.getString("Print..."));
-            printItem.setActionCommand(PRINT_COMMAND);
-            printItem.addActionListener(this);
-            result.add(printItem);
-            separator = true;
-        }
-
-        return result;
-    }
+	JFreeChart chart;
+
+	/**
+	 * Class Constructor.
+	 *
+	 * @param chart
+	 */
+	public ImagePanel(JFreeChart chart) {
+		super(chart);
+		this.chart = chart;
+	}
+
+	/**
+	 * Method for save the images.
+	 *
+	 * @throws IOException
+	 */
+	@Override
+	public void doSaveAs() throws IOException {
+
+		JFileChooser fileChooser = new JFileChooser();
+		ExtensionFileFilter filterPNG = new ExtensionFileFilter("PNG Image Files", ".png");
+		fileChooser.addChoosableFileFilter(filterPNG);
+
+		ExtensionFileFilter filterJPG = new ExtensionFileFilter("JPG Image Files", ".jpg");
+		fileChooser.addChoosableFileFilter(filterJPG);
+
+		ExtensionFileFilter filterEPS = new ExtensionFileFilter("EPS Image Files", ".eps");
+		fileChooser.addChoosableFileFilter(filterEPS);
+
+		ExtensionFileFilter filterSVG = new ExtensionFileFilter("SVG Image Files", ".svg");
+		fileChooser.addChoosableFileFilter(filterSVG);
+		fileChooser.setCurrentDirectory(null);
+		int option = fileChooser.showSaveDialog(this);
+		if (option == JFileChooser.APPROVE_OPTION) {
+			String fileDesc = fileChooser.getFileFilter().getDescription();
+			if (fileDesc.startsWith("PNG")) {
+				if (!fileChooser.getSelectedFile().getName().toUpperCase().endsWith("PNG")) {
+					ChartUtilities.saveChartAsPNG(new File(fileChooser.getSelectedFile().getAbsolutePath() + ".png"),
+							this.chart, this.getWidth(), this.getHeight());
+				} else {
+					ChartUtilities.saveChartAsPNG(fileChooser.getSelectedFile(), this.chart, this.getWidth(),
+							this.getHeight());
+				}
+			} else if (fileDesc.startsWith("JPG")) {
+				if (!fileChooser.getSelectedFile().getName().toUpperCase().endsWith("JPG")) {
+					ChartUtilities.saveChartAsJPEG(new File(fileChooser.getSelectedFile().getAbsolutePath() + ".jpg"),
+							this.chart, this.getWidth(), this.getHeight());
+				} else {
+					ChartUtilities.saveChartAsJPEG(fileChooser.getSelectedFile(), this.chart, this.getWidth(),
+							this.getHeight());
+				}
+			}
+
+		} // else
+	}
+
+	/**
+	 *
+	 * @param properties
+	 * @param copy
+	 * @param save
+	 * @param print
+	 * @param zoom
+	 * @return JPopupMenu
+	 */
+	@Override
+	protected JPopupMenu createPopupMenu(boolean properties, boolean copy, boolean save, boolean print, boolean zoom) {
+		JPopupMenu result = new JPopupMenu(localizationResources.getString("Chart") + ":");
+		boolean separator = false;
+
+		if (properties) {
+			JMenuItem propertiesItem = new JMenuItem(localizationResources.getString("Properties..."));
+			propertiesItem.setActionCommand(PROPERTIES_COMMAND);
+			propertiesItem.addActionListener(this);
+			result.add(propertiesItem);
+			separator = true;
+		}
+
+		if (copy) {
+			if (separator) {
+				result.addSeparator();
+			}
+			JMenuItem copyItem = new JMenuItem(localizationResources.getString("Copy"));
+			copyItem.setActionCommand(COPY_COMMAND);
+			copyItem.addActionListener(this);
+			result.add(copyItem);
+			separator = !save;
+		}
+
+		if (save) {
+			if (separator) {
+				result.addSeparator();
+			}
+			JMenu saveSubMenu = new JMenu(localizationResources.getString("Save_as"));
+			JMenuItem pngItem = new JMenuItem(localizationResources.getString("PNG..."));
+
+			separator = true;
+		}
+
+		if (print) {
+			if (separator) {
+				result.addSeparator();
+			}
+			JMenuItem printItem = new JMenuItem(localizationResources.getString("Print..."));
+			printItem.setActionCommand(PRINT_COMMAND);
+			printItem.addActionListener(this);
+			result.add(printItem);
+			separator = true;
+		}
+
+		return result;
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/ImageTreePanel.java b/moa/src/main/java/moa/gui/experimentertab/ImageTreePanel.java
index 670eb951b..e1281fbb5 100644
--- a/moa/src/main/java/moa/gui/experimentertab/ImageTreePanel.java
+++ b/moa/src/main/java/moa/gui/experimentertab/ImageTreePanel.java
@@ -1,6 +1,6 @@
 /*
  *    ImageTreePanel.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand 
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
  *    @author Alberto Verdecia Cabrera (averdeciac@gmail.com)
  *
  *    This program is free software; you can redistribute it and/or modify
@@ -15,23 +15,24 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab;
 
+import java.awt.Dimension;
+import java.awt.GridLayout;
+
+import javax.swing.ImageIcon;
 import javax.swing.JPanel;
 import javax.swing.JScrollPane;
 import javax.swing.JSplitPane;
 import javax.swing.JTree;
-import javax.swing.tree.DefaultMutableTreeNode;
-import javax.swing.tree.TreeSelectionModel;
 import javax.swing.event.TreeSelectionEvent;
 import javax.swing.event.TreeSelectionListener;
-import java.awt.Dimension;
-import java.awt.GridLayout;
-import javax.swing.ImageIcon;
+import javax.swing.tree.DefaultMutableTreeNode;
 import javax.swing.tree.DefaultTreeCellRenderer;
 import javax.swing.tree.DefaultTreeModel;
+import javax.swing.tree.TreeSelectionModel;
 
 /**
  * This class creates a JTree panel to show the images generated with
@@ -39,106 +40,104 @@
  *
  * @author Alberto
  */
-public class ImageTreePanel extends JPanel
-        implements TreeSelectionListener {
-
-    private JPanel imgPanel;
-    private JTree tree;
-    private ImageChart chart[];
-    private ImagePanel chartPanel[];
-
-    /**
-     * Constructor.
-     * @param chart
-     */
-    public ImageTreePanel(ImageChart chart[]) {
-        super(new GridLayout(1, 0));
-        this.chart = chart;
-        //Create the nodes.
-        DefaultMutableTreeNode top
-                = new DefaultMutableTreeNode("Images");
-        imgPanel = new JPanel();
-        imgPanel.setLayout(new GridLayout(1, 0));
-        createNodes(top);
-        tree = new JTree(top);
-        tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
-        DefaultTreeModel model = (DefaultTreeModel) tree.getModel();
-        tree.setSelectionRow(1);
-
-        tree.addTreeSelectionListener(this);
-        ImageIcon leafIcon = new ImageIcon("icon/img.png");
-        if (leafIcon != null) {
-            DefaultTreeCellRenderer renderer
-                    = new DefaultTreeCellRenderer();
-            renderer.setLeafIcon(leafIcon);
-            tree.setCellRenderer(renderer);
-        }
-        imgPanel.updateUI();
-        JScrollPane treeView = new JScrollPane(tree);
-        treeView.setMinimumSize(new Dimension(100, 50));
-
-        JSplitPane splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
-        splitPane.setTopComponent(treeView);
-        splitPane.setBottomComponent(imgPanel);
-        splitPane.setDividerLocation(100);
-        splitPane.setPreferredSize(new Dimension(500, 300));
-        add(splitPane);
-
-    }
-
-    private void createNodes(DefaultMutableTreeNode top) {
-
-        DefaultMutableTreeNode child = null;
-
-        for (ImageChart chart1 : chart) {
-            child = new DefaultMutableTreeNode(chart1);
-            ImagePanel chPanel = new ImagePanel(chart1.getChart());
-            chPanel.setMouseWheelEnabled(true);
-            chPanel.setMouseZoomable(true);
-            chPanel.repaint();
-            this.imgPanel.removeAll();
-            this.imgPanel.add(chPanel);
-            this.imgPanel.updateUI();
-            top.add(child);
-        }
-
-    }
-
-    /**
-     * @param args the command line arguments
-     */
-    public static void main(String[] args) {
-        // TODO code application logic here
-    }
-
-    @Override
-    public void valueChanged(TreeSelectionEvent e) {
-        DefaultMutableTreeNode node = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
-
-        if (node == null) {
-            return;
-        }
-
-        Object nodeInfo = node.getUserObject();
-        if (node.isLeaf()) {
-            ImageChart chart = (ImageChart) nodeInfo;
-            ImagePanel chPanel = new ImagePanel(chart.getChart());
-            chPanel.setMouseWheelEnabled(true);
-            chPanel.setMouseZoomable(true);
-            chPanel.repaint();
-            this.imgPanel.removeAll();
-            this.imgPanel.add(chPanel);
-            this.imgPanel.updateUI();
-        }
-    }
-
-    /**
-     * Return the ImageChart array.
-     *
-     * @return chart
-     */
-    public ImageChart[] getChart() {
-        return chart;
-    }
+public class ImageTreePanel extends JPanel implements TreeSelectionListener {
+
+	private JPanel imgPanel;
+	private JTree tree;
+	private ImageChart chart[];
+	private ImagePanel chartPanel[];
+
+	/**
+	 * Constructor.
+	 * 
+	 * @param chart
+	 */
+	public ImageTreePanel(ImageChart chart[]) {
+		super(new GridLayout(1, 0));
+		this.chart = chart;
+		// Create the nodes.
+		DefaultMutableTreeNode top = new DefaultMutableTreeNode("Images");
+		imgPanel = new JPanel();
+		imgPanel.setLayout(new GridLayout(1, 0));
+		createNodes(top);
+		tree = new JTree(top);
+		tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
+		DefaultTreeModel model = (DefaultTreeModel) tree.getModel();
+		tree.setSelectionRow(1);
+
+		tree.addTreeSelectionListener(this);
+		ImageIcon leafIcon = new ImageIcon("icon/img.png");
+		if (leafIcon != null) {
+			DefaultTreeCellRenderer renderer = new DefaultTreeCellRenderer();
+			renderer.setLeafIcon(leafIcon);
+			tree.setCellRenderer(renderer);
+		}
+		imgPanel.updateUI();
+		JScrollPane treeView = new JScrollPane(tree);
+		treeView.setMinimumSize(new Dimension(100, 50));
+
+		JSplitPane splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
+		splitPane.setTopComponent(treeView);
+		splitPane.setBottomComponent(imgPanel);
+		splitPane.setDividerLocation(100);
+		splitPane.setPreferredSize(new Dimension(500, 300));
+		add(splitPane);
+
+	}
+
+	private void createNodes(DefaultMutableTreeNode top) {
+
+		DefaultMutableTreeNode child = null;
+
+		for (ImageChart chart1 : chart) {
+			child = new DefaultMutableTreeNode(chart1);
+			ImagePanel chPanel = new ImagePanel(chart1.getChart());
+			chPanel.setMouseWheelEnabled(true);
+			chPanel.setMouseZoomable(true);
+			chPanel.repaint();
+			this.imgPanel.removeAll();
+			this.imgPanel.add(chPanel);
+			this.imgPanel.updateUI();
+			top.add(child);
+		}
+
+	}
+
+	/**
+	 * @param args the command line arguments
+	 */
+	public static void main(String[] args) {
+		// TODO code application logic here
+	}
+
+	@Override
+	public void valueChanged(TreeSelectionEvent e) {
+		DefaultMutableTreeNode node = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
+
+		if (node == null) {
+			return;
+		}
+
+		Object nodeInfo = node.getUserObject();
+		if (node.isLeaf()) {
+			ImageChart chart = (ImageChart) nodeInfo;
+			ImagePanel chPanel = new ImagePanel(chart.getChart());
+			chPanel.setMouseWheelEnabled(true);
+			chPanel.setMouseZoomable(true);
+			chPanel.repaint();
+			this.imgPanel.removeAll();
+			this.imgPanel.add(chPanel);
+			this.imgPanel.updateUI();
+		}
+	}
+
+	/**
+	 * Return the ImageChart array.
+	 *
+	 * @return chart
+	 */
+	public ImageChart[] getChart() {
+		return chart;
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/ImageViewer.java b/moa/src/main/java/moa/gui/experimentertab/ImageViewer.java
index cdf1009b5..d4ca9aa04 100644
--- a/moa/src/main/java/moa/gui/experimentertab/ImageViewer.java
+++ b/moa/src/main/java/moa/gui/experimentertab/ImageViewer.java
@@ -1,6 +1,6 @@
 /*
  *    ImageViewer.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand 
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
  *    @author Alberto Verdecia Cabrera (averdeciac@gmail.com)
  *
  *    This program is free software; you can redistribute it and/or modify
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab;
 
@@ -23,6 +23,7 @@
 import java.awt.HeadlessException;
 import java.io.File;
 import java.io.IOException;
+
 import javax.swing.JButton;
 import javax.swing.JComboBox;
 import javax.swing.JFileChooser;
@@ -30,6 +31,8 @@
 import javax.swing.JLabel;
 import javax.swing.JOptionPane;
 import javax.swing.JPanel;
+import javax.swing.WindowConstants;
+
 import nz.ac.waikato.cms.gui.core.BaseDirectoryChooser;
 
 /**
@@ -40,76 +43,76 @@
  */
 public class ImageViewer extends JFrame {
 
-    private ImageTreePanel imgPanel;
-
-    private String resultsPath;
-
-    private JButton btn;
-
-    private JComboBox imgType;
-
-    /**
-     * Class constructor.
-     *
-     * @param imgPanel
-     * @param resultsPath
-     * @throws HeadlessException
-     */
-    public ImageViewer(ImageTreePanel imgPanel, String resultsPath) throws HeadlessException {
-        super("Preview");
-        this.imgPanel = imgPanel;
-        this.resultsPath = resultsPath;
-        setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
-
-        // Create and set up the content pane.
-        JPanel panel = new JPanel();
-        JPanel main = new JPanel();
-        JLabel label = new JLabel("Output format");
-        String op[] = {"PNG", "JPG", "SVG"};
-        imgType = new JComboBox(op);
-        imgType.setSelectedIndex(0);
-        btn = new JButton("Save all images as...");
-        btn.addActionListener(this::btnMenuActionPerformed);
-        panel.add(label);
-        panel.add(imgType);
-        panel.add(btn);
-
-        main.setLayout(new BorderLayout());
-        main.add(this.imgPanel, BorderLayout.CENTER);
-        main.add(panel, BorderLayout.SOUTH);
-
-        setContentPane(main);
-
-        // Display the window.
-        pack();
-        setSize(700, 500);
-
-        setVisible(true);
-    }
-
-    private void btnMenuActionPerformed(java.awt.event.ActionEvent evt) {
-
-        String path = "";
-        BaseDirectoryChooser propDir = new BaseDirectoryChooser();
-        propDir.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
-        propDir.setCurrentDirectory(new File(resultsPath));
-        int selection = propDir.showSaveDialog(this);
-        if (selection == JFileChooser.APPROVE_OPTION) {
-            path = propDir.getSelectedFile().getAbsolutePath();
-            if (!path.equals("")) {
-                for (ImageChart chart : this.imgPanel.getChart()) {
-                    try {
-                        chart.exportIMG(path, this.imgType.getSelectedItem().toString());
-
-                    } catch (IOException ex) {
-                        JOptionPane.showMessageDialog(this, "Error creating image " + chart.getName());
-                        return;
-                    }
-
-                }
-                JOptionPane.showMessageDialog(this, "Images saved at: " + path);
-            }
-        }
-
-    }
+	private ImageTreePanel imgPanel;
+
+	private String resultsPath;
+
+	private JButton btn;
+
+	private JComboBox imgType;
+
+	/**
+	 * Class constructor.
+	 *
+	 * @param imgPanel
+	 * @param resultsPath
+	 * @throws HeadlessException
+	 */
+	public ImageViewer(ImageTreePanel imgPanel, String resultsPath) throws HeadlessException {
+		super("Preview");
+		this.imgPanel = imgPanel;
+		this.resultsPath = resultsPath;
+		setDefaultCloseOperation(WindowConstants.HIDE_ON_CLOSE);
+
+		// Create and set up the content pane.
+		JPanel panel = new JPanel();
+		JPanel main = new JPanel();
+		JLabel label = new JLabel("Output format");
+		String op[] = { "PNG", "JPG", "SVG" };
+		imgType = new JComboBox(op);
+		imgType.setSelectedIndex(0);
+		btn = new JButton("Save all images as...");
+		btn.addActionListener(this::btnMenuActionPerformed);
+		panel.add(label);
+		panel.add(imgType);
+		panel.add(btn);
+
+		main.setLayout(new BorderLayout());
+		main.add(this.imgPanel, BorderLayout.CENTER);
+		main.add(panel, BorderLayout.SOUTH);
+
+		setContentPane(main);
+
+		// Display the window.
+		pack();
+		setSize(700, 500);
+
+		setVisible(true);
+	}
+
+	private void btnMenuActionPerformed(java.awt.event.ActionEvent evt) {
+
+		String path = "";
+		BaseDirectoryChooser propDir = new BaseDirectoryChooser();
+		propDir.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
+		propDir.setCurrentDirectory(new File(resultsPath));
+		int selection = propDir.showSaveDialog(this);
+		if (selection == JFileChooser.APPROVE_OPTION) {
+			path = propDir.getSelectedFile().getAbsolutePath();
+			if (!path.equals("")) {
+				for (ImageChart chart : this.imgPanel.getChart()) {
+					try {
+						chart.exportIMG(path, this.imgType.getSelectedItem().toString());
+
+					} catch (IOException ex) {
+						JOptionPane.showMessageDialog(this, "Error creating image " + chart.getName());
+						return;
+					}
+
+				}
+				JOptionPane.showMessageDialog(this, "Images saved at: " + path);
+			}
+		}
+
+	}
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/Measure.java b/moa/src/main/java/moa/gui/experimentertab/Measure.java
index b1e7edd84..e27ec4101 100644
--- a/moa/src/main/java/moa/gui/experimentertab/Measure.java
+++ b/moa/src/main/java/moa/gui/experimentertab/Measure.java
@@ -1,6 +1,6 @@
 /*
  *    Measure.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand 
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
  *    @author Alberto Verdecia Cabrera (averdeciac@gmail.com)
  *
  *    This program is free software; you can redistribute it and/or modify
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab;
 
@@ -28,161 +28,171 @@
  */
 public class Measure {
 
-    private String name;
-    
-    private String fileName;
-
-    private Double value;
-
-    private DoubleVector values = new DoubleVector();
-
-    private Double std;
-
-    private boolean type;
-
-    private int index;
-
-    /**
-     * Measure Constructor
-     * @param name
-     * @param type
-     * @param index
-     */
-    public Measure(String name,String filename, boolean type, int index) {
-        this.name = name;
-        this.fileName = filename;
-        this.type = type;
-        this.index = index;
-        this.value = 0.0;
-        this.std = 0.0;
-    }
-   
-    /**
-     *
-     * @return the name of measure
-     */
-    public String getName() {
-        return name;
-    }
-
-    public String getFileName() {
-        return fileName;
-    }
-    
-    public void setFileName(String fileName) {
-        this.fileName = fileName;
-    }
-    
-    /**
-     * Sets the name of measure
-     * @param name
-     */
-    public void setName(String name) {
-        this.name = name;
-    }
-
-    /**
-     *
-     * @return the value of measure
-     */
-    public Double getValue() {
-        return value;
-    }
-
-    /**
-     * Sets the value of measure
-     * @param value
-     */
-    public void setValue(Double value) {
-        this.value = value;
-    }
-
-    /**
-     * Returns the standard deviation
-     * @return the standard deviation
-     */
-    public Double getStd() {
-        return std;
-    }
-
-    /**
-     * Sets the standard deviation
-     * @param std
-     */
-    public void setStd(Double std) {
-        this.std = std;
-    }
-
-    /**
-     * Returns the type of measure
-     * @return the type of measure
-     */
-    public boolean isType() {
-        return type;
-    }
-
-    /**
-     * Sets the type of measure
-     * @param type
-     */
-    public void setType(boolean type) {
-        this.type = type;
-    }
-
-    /**
-     * Returns the index of measure
-     * @return the index of measure
-     */
-    public int getIndex() {
-        return index;
-    }
-
-    /**
-     * Sets the index of measure
-     * @param index
-     */
-    public void setIndex(int index) {
-        this.index = index;
-    }
-
-    /**
-     *
-     * @return values
-     */
-    public DoubleVector getValues() {
-        return values;
-    }
-
-    /**
-     *
-     * @param values
-     */
-    public void setValues(DoubleVector values) {
-        this.values = (DoubleVector) values.copy();
-    }
-
-    /**
-     * Calculates the value of measure
-     * @param values
-     */
-    public void computeValue(DoubleVector values) {
-        if (this.isType()) {
-            setValues(values);
-            double sumDif = 0.0;
-            this.value = this.values.sumOfValues() / (double) values.numValues();
-            for (int i = 0; i < this.values.numValues(); i++) {
-                double dif = this.values.getValue(i) - this.value;
-                sumDif += Math.pow(dif, 2);
-            }
-            sumDif = sumDif / this.values.numValues();
-            this.std = Math.sqrt(sumDif);
-        }
-
-    }
-
-    @Override
-    protected Object clone() throws CloneNotSupportedException {
-        return super.clone(); 
-    }
+	private String name;
+
+	private String fileName;
+
+	private Double value;
+
+	private DoubleVector values = new DoubleVector();
+
+	private Double std;
+
+	private boolean type;
+
+	private int index;
+
+	/**
+	 * Measure Constructor
+	 * 
+	 * @param name
+	 * @param type
+	 * @param index
+	 */
+	public Measure(String name, String filename, boolean type, int index) {
+		this.name = name;
+		this.fileName = filename;
+		this.type = type;
+		this.index = index;
+		this.value = 0.0;
+		this.std = 0.0;
+	}
+
+	/**
+	 *
+	 * @return the name of measure
+	 */
+	public String getName() {
+		return name;
+	}
+
+	public String getFileName() {
+		return fileName;
+	}
+
+	public void setFileName(String fileName) {
+		this.fileName = fileName;
+	}
+
+	/**
+	 * Sets the name of measure
+	 * 
+	 * @param name
+	 */
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	/**
+	 *
+	 * @return the value of measure
+	 */
+	public Double getValue() {
+		return value;
+	}
+
+	/**
+	 * Sets the value of measure
+	 * 
+	 * @param value
+	 */
+	public void setValue(Double value) {
+		this.value = value;
+	}
+
+	/**
+	 * Returns the standard deviation
+	 * 
+	 * @return the standard deviation
+	 */
+	public Double getStd() {
+		return std;
+	}
+
+	/**
+	 * Sets the standard deviation
+	 * 
+	 * @param std
+	 */
+	public void setStd(Double std) {
+		this.std = std;
+	}
+
+	/**
+	 * Returns the type of measure
+	 * 
+	 * @return the type of measure
+	 */
+	public boolean isType() {
+		return type;
+	}
+
+	/**
+	 * Sets the type of measure
+	 * 
+	 * @param type
+	 */
+	public void setType(boolean type) {
+		this.type = type;
+	}
+
+	/**
+	 * Returns the index of measure
+	 * 
+	 * @return the index of measure
+	 */
+	public int getIndex() {
+		return index;
+	}
+
+	/**
+	 * Sets the index of measure
+	 * 
+	 * @param index
+	 */
+	public void setIndex(int index) {
+		this.index = index;
+	}
+
+	/**
+	 *
+	 * @return values
+	 */
+	public DoubleVector getValues() {
+		return values;
+	}
+
+	/**
+	 *
+	 * @param values
+	 */
+	public void setValues(DoubleVector values) {
+		this.values = (DoubleVector) values.copy();
+	}
+
+	/**
+	 * Calculates the value of measure
+	 * 
+	 * @param values
+	 */
+	public void computeValue(DoubleVector values) {
+		if (this.isType()) {
+			setValues(values);
+			double sumDif = 0.0;
+			this.value = this.values.sumOfValues() / values.numValues();
+			for (int i = 0; i < this.values.numValues(); i++) {
+				double dif = this.values.getValue(i) - this.value;
+				sumDif += Math.pow(dif, 2);
+			}
+			sumDif = sumDif / this.values.numValues();
+			this.std = Math.sqrt(sumDif);
+		}
+
+	}
+
+	@Override
+	protected Object clone() throws CloneNotSupportedException {
+		return super.clone();
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/PlotTab.java b/moa/src/main/java/moa/gui/experimentertab/PlotTab.java
index 2b6369d47..20a7ebba8 100644
--- a/moa/src/main/java/moa/gui/experimentertab/PlotTab.java
+++ b/moa/src/main/java/moa/gui/experimentertab/PlotTab.java
@@ -1,6 +1,6 @@
 /*
  *    PlotTab.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand 
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
  *    @author Alberto Verdecia Cabrera (averdeciac@gmail.com)
  *
  *    This program is free software; you can redistribute it and/or modify
@@ -15,26 +15,12 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab;
 
-import moa.gui.LookAndFeel;
-import nz.ac.waikato.cms.gui.core.BaseDirectoryChooser;
-import org.apache.commons.io.FilenameUtils;
-import org.jfree.chart.ChartFactory;
-import org.jfree.chart.JFreeChart;
-import org.jfree.chart.plot.PlotOrientation;
-import org.jfree.chart.plot.XYPlot;
-import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;
-import org.jfree.data.xy.XYSeries;
-import org.jfree.data.xy.XYSeriesCollection;
+import static moa.gui.experimentertab.ReadFile.readCSV;
 
-import javax.swing.JFileChooser;
-import javax.swing.JFrame;
-import javax.swing.JOptionPane;
-import javax.swing.JPanel;
-import javax.swing.table.DefaultTableModel;
 import java.awt.Color;
 import java.io.BufferedReader;
 import java.io.BufferedWriter;
@@ -48,7 +34,23 @@
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
-import static moa.gui.experimentertab.ReadFile.readCSV;
+import javax.swing.JFileChooser;
+import javax.swing.JFrame;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.table.DefaultTableModel;
+
+import org.apache.commons.io.FilenameUtils;
+import org.jfree.chart.ChartFactory;
+import org.jfree.chart.JFreeChart;
+import org.jfree.chart.plot.PlotOrientation;
+import org.jfree.chart.plot.XYPlot;
+import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;
+import org.jfree.data.xy.XYSeries;
+import org.jfree.data.xy.XYSeriesCollection;
+
+import moa.gui.LookAndFeel;
+import nz.ac.waikato.cms.gui.core.BaseDirectoryChooser;
 
 /**
  * Generate figures plotting the performance measurements of various learning
@@ -58,1278 +60,1273 @@
  */
 public class PlotTab extends javax.swing.JPanel {
 
-    private String path = "";
-
-    private LinkedList<String> measures = new LinkedList();
-
-    private DefaultTableModel algoritmModel;
-
-    private DefaultTableModel streamModel;
-
-    ImageTreePanel imgPanel;
-
-    ImageChart chart[];
-    
-    ReadFile rf;
-
-    public PlotTab() {
-        initComponents();
-        initComponents();
-        this.algoritmModel = (DefaultTableModel) jTableAlgoritms.getModel();
-        this.streamModel = (DefaultTableModel) jTableStreams.getModel();
-    }
-
-    /**
-     * This method is called from within the constructor to initialize the form.
-     * WARNING: Do NOT modify this code. The content of this method is always
-     * regenerated by the Form Editor.
-     */
-    @SuppressWarnings("unchecked")
-    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
-    private void initComponents() {
-
-        jPanel1 = new javax.swing.JPanel();
-        jScrollPaneAlgorithms = new javax.swing.JScrollPane();
-        jTableAlgoritms = new javax.swing.JTable();
-        jScrollPane3 = new javax.swing.JScrollPane();
-        jTableStreams = new javax.swing.JTable();
-        jTextFieldResultPath = new javax.swing.JTextField();
-        jButtonInPath = new javax.swing.JButton();
-        jLabel3 = new javax.swing.JLabel();
-        jButtonDeletAlgorithm = new javax.swing.JButton();
-        jButtonDeleteStream = new javax.swing.JButton();
-        jTabbedPane1 = new javax.swing.JTabbedPane();
-        jPanel2 = new javax.swing.JPanel();
-        jButtonAcept = new javax.swing.JButton();
-        jButtonReset = new javax.swing.JButton();
-        jScrollPane1 = new javax.swing.JScrollPane();
-        jPanel4 = new javax.swing.JPanel();
-        jLabel17 = new javax.swing.JLabel();
-        jTextFieldxTitle = new javax.swing.JTextField();
-        jLabel18 = new javax.swing.JLabel();
-        jLabel19 = new javax.swing.JLabel();
-        jTextFieldyTitle = new javax.swing.JTextField();
-        jLabel20 = new javax.swing.JLabel();
-        jComboBoxXColumn = new javax.swing.JComboBox();
-        jComboBoxYColumn = new javax.swing.JComboBox();
-        jTextFieldTitle = new javax.swing.JTextField();
-        jLabel21 = new javax.swing.JLabel();
-        jSpinnerWidth = new javax.swing.JSpinner();
-        jSpinnerHeight = new javax.swing.JSpinner();
-        jLabel22 = new javax.swing.JLabel();
-        jLabel23 = new javax.swing.JLabel();
-        jComboBoxGrid = new javax.swing.JComboBox();
-        jCheckBoxShape = new javax.swing.JCheckBox();
-        jLabel2 = new javax.swing.JLabel();
-        jPanel3 = new javax.swing.JPanel();
-        jButtonAceptGnuP = new javax.swing.JButton();
-        jButtonResetGnuP = new javax.swing.JButton();
-        jScrollPaneGnuP = new javax.swing.JScrollPane();
-        jPanelGnuP = new javax.swing.JPanel();
-        jTextFieldGNUPath = new javax.swing.JTextField();
-        jLabel1 = new javax.swing.JLabel();
-        jButtonGnuoPath = new javax.swing.JButton();
-        jComboBoxOutPTypeGnuP = new javax.swing.JComboBox();
-        jLabel5 = new javax.swing.JLabel();
-        jComboBoxLineStyle = new javax.swing.JComboBox();
-        jLabel6 = new javax.swing.JLabel();
-        jLabel7 = new javax.swing.JLabel();
-        jTextFieldxTitleGnuP = new javax.swing.JTextField();
-        jLabel8 = new javax.swing.JLabel();
-        jLabel10 = new javax.swing.JLabel();
-        jTextFieldyTitleGnuP = new javax.swing.JTextField();
-        jLabel11 = new javax.swing.JLabel();
-        jSpinnerLineWidth = new javax.swing.JSpinner();
-        jSpinnerPlotInterval = new javax.swing.JSpinner();
-        jLabel13 = new javax.swing.JLabel();
-        jLabel14 = new javax.swing.JLabel();
-        jCheckBoxSmooth = new javax.swing.JCheckBox();
-        jLabel15 = new javax.swing.JLabel();
-        jCheckBoxDeleteScript = new javax.swing.JCheckBox();
-        jLabel16 = new javax.swing.JLabel();
-        jComboBoxLegendLocation = new javax.swing.JComboBox();
-        jLabel24 = new javax.swing.JLabel();
-        jComboBoxLegendType = new javax.swing.JComboBox();
-        jLabel25 = new javax.swing.JLabel();
-        jTextFieldAdcComand = new javax.swing.JTextField();
-        jLabel26 = new javax.swing.JLabel();
-        jTextFieldAPOptions = new javax.swing.JTextField();
-        jLabel27 = new javax.swing.JLabel();
-        jComboBoxXColumnGnuP = new javax.swing.JComboBox();
-        jComboBoxYColumnGnuP = new javax.swing.JComboBox();
-
-        jPanel1.setBorder(javax.swing.BorderFactory.createTitledBorder("Configuration"));
-
-        jScrollPaneAlgorithms.setBorder(javax.swing.BorderFactory.createTitledBorder("Algorithm"));
-
-        jTableAlgoritms.setBorder(javax.swing.BorderFactory.createTitledBorder(""));
-        jTableAlgoritms.setModel(new javax.swing.table.DefaultTableModel(
-            new Object [][] {
-
-            },
-            new String [] {
-                "Algorithm", "Algorithm ID"
-            }
-        ));
-        jScrollPaneAlgorithms.setViewportView(jTableAlgoritms);
-
-        jScrollPane3.setBorder(javax.swing.BorderFactory.createTitledBorder("Stream"));
-
-        jTableStreams.setBorder(javax.swing.BorderFactory.createTitledBorder(""));
-        jTableStreams.setModel(new javax.swing.table.DefaultTableModel(
-            new Object [][] {
-
-            },
-            new String [] {
-                "Stream", "Stream ID"
-            }
-        ));
-        jScrollPane3.setViewportView(jTableStreams);
-
-        jButtonInPath.setText("Browse");
-        jButtonInPath.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                jButtonInPathActionPerformed(evt);
-            }
-        });
-
-        jLabel3.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
-        jLabel3.setText("Result  folder");
-
-        jButtonDeletAlgorithm.setText("Delete Algorithm");
-        jButtonDeletAlgorithm.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                jButtonDeletAlgorithmActionPerformed(evt);
-            }
-        });
-
-        jButtonDeleteStream.setText("Delete Stream");
-        jButtonDeleteStream.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                jButtonDeleteStreamActionPerformed(evt);
-            }
-        });
-
-        javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1);
-        jPanel1.setLayout(jPanel1Layout);
-        jPanel1Layout.setHorizontalGroup(
-            jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGroup(jPanel1Layout.createSequentialGroup()
-                .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                    .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanel1Layout.createSequentialGroup()
-                        .addGap(14, 14, 14)
-                        .addComponent(jLabel3)
-                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                        .addComponent(jTextFieldResultPath)
-                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
-                        .addComponent(jButtonInPath))
-                    .addGroup(jPanel1Layout.createSequentialGroup()
-                        .addContainerGap()
-                        .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                            .addComponent(jButtonDeletAlgorithm)
-                            .addComponent(jScrollPaneAlgorithms, javax.swing.GroupLayout.PREFERRED_SIZE, 0, Short.MAX_VALUE))
-                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
-                        .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                            .addComponent(jScrollPane3, javax.swing.GroupLayout.PREFERRED_SIZE, 0, Short.MAX_VALUE)
-                            .addGroup(jPanel1Layout.createSequentialGroup()
-                                .addComponent(jButtonDeleteStream)
-                                .addGap(0, 0, Short.MAX_VALUE)))))
-                .addGap(16, 16, 16))
-        );
-        jPanel1Layout.setVerticalGroup(
-            jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanel1Layout.createSequentialGroup()
-                .addGap(23, 23, 23)
-                .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jTextFieldResultPath, javax.swing.GroupLayout.PREFERRED_SIZE, 23, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jButtonInPath)
-                    .addComponent(jLabel3))
-                .addGap(18, 18, 18)
-                .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                    .addComponent(jScrollPaneAlgorithms, javax.swing.GroupLayout.DEFAULT_SIZE, 89, Short.MAX_VALUE)
-                    .addComponent(jScrollPane3, javax.swing.GroupLayout.PREFERRED_SIZE, 0, Short.MAX_VALUE))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jButtonDeleteStream)
-                    .addComponent(jButtonDeletAlgorithm)))
-        );
-
-        jButtonAcept.setText("Generate Images");
-        jButtonAcept.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                jButtonAceptActionPerformed(evt);
-            }
-        });
-
-        jButtonReset.setText(" Reset to Default");
-        jButtonReset.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                jButtonResetActionPerformed(evt);
-            }
-        });
-
-        jScrollPane1.setBorder(javax.swing.BorderFactory.createTitledBorder(""));
-        jScrollPane1.setHorizontalScrollBarPolicy(javax.swing.ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
-
-        jPanel4.setBorder(javax.swing.BorderFactory.createTitledBorder(""));
-
-        jLabel17.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
-        jLabel17.setText("xColumn");
-
-        jTextFieldxTitle.setText("Instances processed");
-
-        jLabel18.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
-        jLabel18.setText("xTitle");
-
-        jLabel19.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
-        jLabel19.setText("yColumn");
-
-        jTextFieldyTitle.setText("% of correctly classified");
-
-        jLabel20.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
-        jLabel20.setText("yTitle");
-
-        jLabel21.setText("title");
-
-        jSpinnerWidth.setValue(500);
-
-        jSpinnerHeight.setValue(300);
-
-        jLabel22.setText("width");
-
-        jLabel23.setText("height");
-
-        jComboBoxGrid.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "White", "Default" }));
-
-        jCheckBoxShape.setText("shapes");
-
-        jLabel2.setText("gridColor");
-
-        javax.swing.GroupLayout jPanel4Layout = new javax.swing.GroupLayout(jPanel4);
-        jPanel4.setLayout(jPanel4Layout);
-        jPanel4Layout.setHorizontalGroup(
-            jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGroup(jPanel4Layout.createSequentialGroup()
-                .addGap(67, 67, 67)
-                .addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
-                    .addGroup(jPanel4Layout.createSequentialGroup()
-                        .addGap(3, 3, 3)
-                        .addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                            .addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
-                                .addComponent(jLabel17)
-                                .addComponent(jLabel21)
-                                .addComponent(jLabel18))
-                            .addComponent(jLabel19)
-                            .addComponent(jLabel20, javax.swing.GroupLayout.Alignment.TRAILING)
-                            .addComponent(jLabel22, javax.swing.GroupLayout.Alignment.TRAILING))
-                        .addGap(18, 18, 18)
-                        .addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                            .addComponent(jTextFieldxTitle)
-                            .addComponent(jComboBoxXColumn, javax.swing.GroupLayout.Alignment.TRAILING, 0, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
-                            .addComponent(jTextFieldTitle, javax.swing.GroupLayout.Alignment.TRAILING)
-                            .addComponent(jComboBoxYColumn, 0, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
-                            .addComponent(jTextFieldyTitle, javax.swing.GroupLayout.DEFAULT_SIZE, 542, Short.MAX_VALUE)
-                            .addComponent(jSpinnerWidth)))
-                    .addGroup(javax.swing.GroupLayout.Alignment.LEADING, jPanel4Layout.createSequentialGroup()
-                        .addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
-                            .addComponent(jLabel23)
-                            .addComponent(jLabel2))
-                        .addGap(18, 18, 18)
-                        .addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                            .addGroup(jPanel4Layout.createSequentialGroup()
-                                .addComponent(jCheckBoxShape, javax.swing.GroupLayout.PREFERRED_SIZE, 91, javax.swing.GroupLayout.PREFERRED_SIZE)
-                                .addGap(0, 0, Short.MAX_VALUE))
-                            .addComponent(jComboBoxGrid, 0, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
-                            .addComponent(jSpinnerHeight))))
-                .addGap(30, 30, 30))
-        );
-        jPanel4Layout.setVerticalGroup(
-            jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGroup(jPanel4Layout.createSequentialGroup()
-                .addContainerGap()
-                .addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jTextFieldTitle, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jLabel21))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jComboBoxXColumn, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jLabel17))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jTextFieldxTitle, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jLabel18))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jComboBoxYColumn, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jLabel19))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
-                .addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jTextFieldyTitle, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jLabel20))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                    .addComponent(jSpinnerWidth, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jLabel22))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jLabel23)
-                    .addComponent(jSpinnerHeight, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jComboBoxGrid, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jLabel2))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addComponent(jCheckBoxShape)
-                .addContainerGap(11, Short.MAX_VALUE))
-        );
-
-        jScrollPane1.setViewportView(jPanel4);
-
-        javax.swing.GroupLayout jPanel2Layout = new javax.swing.GroupLayout(jPanel2);
-        jPanel2.setLayout(jPanel2Layout);
-        jPanel2Layout.setHorizontalGroup(
-            jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGroup(jPanel2Layout.createSequentialGroup()
-                .addGap(135, 135, 135)
-                .addComponent(jButtonAcept)
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addComponent(jButtonReset)
-                .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
-            .addComponent(jScrollPane1, javax.swing.GroupLayout.Alignment.TRAILING, javax.swing.GroupLayout.DEFAULT_SIZE, 700, Short.MAX_VALUE)
-        );
-        jPanel2Layout.setVerticalGroup(
-            jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanel2Layout.createSequentialGroup()
-                .addContainerGap()
-                .addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 247, javax.swing.GroupLayout.PREFERRED_SIZE)
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jButtonAcept)
-                    .addComponent(jButtonReset)))
-        );
-
-        jTabbedPane1.addTab("Charts", jPanel2);
-
-        jButtonAceptGnuP.setText("Generate GnuPlot Commands");
-        jButtonAceptGnuP.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                jButtonAceptGnuPActionPerformed(evt);
-            }
-        });
-
-        jButtonResetGnuP.setText(" Reset to Default");
-        jButtonResetGnuP.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                jButtonResetGnuPActionPerformed(evt);
-            }
-        });
-
-        jScrollPaneGnuP.setBorder(javax.swing.BorderFactory.createTitledBorder(""));
-        jScrollPaneGnuP.setHorizontalScrollBarPolicy(javax.swing.ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
-
-        jPanelGnuP.setBorder(javax.swing.BorderFactory.createTitledBorder(""));
-        jPanelGnuP.setPreferredSize(new java.awt.Dimension(400, 449));
-
-        jTextFieldGNUPath.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                jTextFieldGNUPathActionPerformed(evt);
-            }
-        });
-
-        jLabel1.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
-        jLabel1.setText("gnuplotBinaryPath ");
-
-        jButtonGnuoPath.setText("Browse");
-        jButtonGnuoPath.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                jButtonGnuoPathActionPerformed(evt);
-            }
-        });
-
-        jComboBoxOutPTypeGnuP.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "POSTSCRIPT_COLOR", "EPSLATEX", "GIF", "JPEG", "LATEX", "PDFCAIRO", "PNG", "POSTSCRIPT", "CANVAS", "PSLATEX", "PSTEX", "PSTRICKS", "SVG" }));
-
-        jLabel5.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
-        jLabel5.setText("outputType");
-
-        jComboBoxLineStyle.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "LINES", "POINTS", "LINESPOINTS", "IMPULSES", "STEPS", "FSTEPS", "HISTEPS", "DOTS;" }));
-
-        jLabel6.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
-        jLabel6.setText("plotStyle");
-
-        jLabel7.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
-        jLabel7.setText("xColumn");
-
-        jTextFieldxTitleGnuP.setText("Processed instances");
-
-        jLabel8.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
-        jLabel8.setText("xTitle");
-
-        jLabel10.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
-        jLabel10.setText("yColumn");
-
-        jTextFieldyTitleGnuP.setText("Accuracy");
-
-        jLabel11.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
-        jLabel11.setText("yTitle");
-
-        jSpinnerLineWidth.setValue(2);
-
-        jLabel13.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
-        jLabel13.setText("lineWidth");
-
-        jLabel14.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
-        jLabel14.setText("plotInterval");
-
-        jLabel15.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
-        jLabel15.setText("smooth");
-
-        jLabel16.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
-        jLabel16.setText("deleteScripts");
-
-        jComboBoxLegendLocation.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "BOTTOM_CENTER_OUTSIDE", "TOP_LEFT_INSIDE", "TOP_CENTER_INSIDE", "TOP_RIGHT_INSIDE", "LEFT_INSIDE", "CENTER_INSIDE", "RIGHT_INSIDE", "BOTTOM_LEFT_INSIDE", "BOTTOM_CENTER_INSIDE", "BOTTOM_RIGHT_INSIDE", "TOP_LEFT_OUTSIDE", "TOP_CENTER_OUTSIDE", "TOP_RIGHT_OUTSIDE", "LEFT_OUTSIDE", "CENTER_OUTSIDE", "RIGHT_OUTSIDE", "BOTTOM_LEFT_OUTSIDE", "BOTTOM_RIGHT_OUTSIDE" }));
-        jComboBoxLegendLocation.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                jComboBoxLegendLocationActionPerformed(evt);
-            }
-        });
-
-        jLabel24.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
-        jLabel24.setText("legendLocation");
-
-        jComboBoxLegendType.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "NOBOX_HORIZONTAL", "BOX_VERTICAL", "BOX_HORIZONTAL", "NOBOX_VERTICAL", " " }));
-
-        jLabel25.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
-        jLabel25.setText("legendType");
-
-        jLabel26.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
-        jLabel26.setText("additionalCommands");
-
-        jLabel27.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
-        jLabel27.setText("additionalPlotOptions");
-
-        javax.swing.GroupLayout jPanelGnuPLayout = new javax.swing.GroupLayout(jPanelGnuP);
-        jPanelGnuP.setLayout(jPanelGnuPLayout);
-        jPanelGnuPLayout.setHorizontalGroup(
-            jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGroup(jPanelGnuPLayout.createSequentialGroup()
-                .addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                    .addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                        .addGroup(jPanelGnuPLayout.createSequentialGroup()
-                            .addGap(22, 22, 22)
-                            .addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                                .addComponent(jLabel5, javax.swing.GroupLayout.Alignment.TRAILING)
-                                .addComponent(jLabel6, javax.swing.GroupLayout.Alignment.TRAILING)
-                                .addComponent(jLabel7, javax.swing.GroupLayout.Alignment.TRAILING)
-                                .addComponent(jLabel8, javax.swing.GroupLayout.Alignment.TRAILING)
-                                .addComponent(jLabel10, javax.swing.GroupLayout.Alignment.TRAILING)
-                                .addComponent(jLabel11, javax.swing.GroupLayout.Alignment.TRAILING)
-                                .addComponent(jLabel1, javax.swing.GroupLayout.Alignment.TRAILING)))
-                        .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanelGnuPLayout.createSequentialGroup()
-                            .addContainerGap()
-                            .addComponent(jLabel27)))
-                    .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanelGnuPLayout.createSequentialGroup()
-                        .addContainerGap()
-                        .addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                            .addComponent(jLabel15, javax.swing.GroupLayout.Alignment.TRAILING)
-                            .addComponent(jLabel13, javax.swing.GroupLayout.Alignment.TRAILING)
-                            .addComponent(jLabel14, javax.swing.GroupLayout.Alignment.TRAILING)
-                            .addComponent(jLabel16, javax.swing.GroupLayout.Alignment.TRAILING)
-                            .addComponent(jLabel24, javax.swing.GroupLayout.Alignment.TRAILING)
-                            .addComponent(jLabel25, javax.swing.GroupLayout.Alignment.TRAILING)
-                            .addComponent(jLabel26, javax.swing.GroupLayout.Alignment.TRAILING))))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
-                .addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                    .addComponent(jTextFieldAPOptions, javax.swing.GroupLayout.Alignment.TRAILING)
-                    .addComponent(jTextFieldAdcComand, javax.swing.GroupLayout.Alignment.TRAILING)
-                    .addComponent(jComboBoxLegendType, javax.swing.GroupLayout.Alignment.TRAILING, 0, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
-                    .addComponent(jSpinnerPlotInterval, javax.swing.GroupLayout.Alignment.TRAILING)
-                    .addComponent(jSpinnerLineWidth, javax.swing.GroupLayout.Alignment.TRAILING)
-                    .addComponent(jTextFieldyTitleGnuP, javax.swing.GroupLayout.Alignment.TRAILING)
-                    .addComponent(jTextFieldxTitleGnuP, javax.swing.GroupLayout.Alignment.TRAILING)
-                    .addComponent(jComboBoxLineStyle, javax.swing.GroupLayout.Alignment.TRAILING, 0, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
-                    .addComponent(jComboBoxXColumnGnuP, 0, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
-                    .addComponent(jComboBoxYColumnGnuP, 0, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
-                    .addComponent(jComboBoxLegendLocation, 0, 542, Short.MAX_VALUE)
-                    .addGroup(jPanelGnuPLayout.createSequentialGroup()
-                        .addComponent(jTextFieldGNUPath)
-                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                        .addComponent(jButtonGnuoPath))
-                    .addGroup(jPanelGnuPLayout.createSequentialGroup()
-                        .addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                            .addComponent(jCheckBoxDeleteScript)
-                            .addComponent(jCheckBoxSmooth))
-                        .addGap(0, 0, Short.MAX_VALUE))
-                    .addComponent(jComboBoxOutPTypeGnuP, javax.swing.GroupLayout.Alignment.TRAILING, 0, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
-                .addContainerGap())
-        );
-        jPanelGnuPLayout.setVerticalGroup(
-            jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGroup(jPanelGnuPLayout.createSequentialGroup()
-                .addContainerGap()
-                .addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jTextFieldGNUPath, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jButtonGnuoPath)
-                    .addComponent(jLabel1))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jComboBoxOutPTypeGnuP, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jLabel5))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                    .addComponent(jComboBoxLineStyle, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jLabel6))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jComboBoxXColumnGnuP, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jLabel7))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jTextFieldxTitleGnuP, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jLabel8))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jComboBoxYColumnGnuP, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jLabel10))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jTextFieldyTitleGnuP, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jLabel11))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jSpinnerLineWidth, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jLabel13))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jSpinnerPlotInterval, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jLabel14))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                    .addComponent(jCheckBoxSmooth)
-                    .addComponent(jLabel15))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                    .addComponent(jCheckBoxDeleteScript)
-                    .addComponent(jLabel16))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jComboBoxLegendLocation, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jLabel24))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jComboBoxLegendType, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jLabel25))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jTextFieldAdcComand, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jLabel26))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jTextFieldAPOptions, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jLabel27))
-                .addGap(186, 186, 186))
-        );
-
-        jScrollPaneGnuP.setViewportView(jPanelGnuP);
-
-        javax.swing.GroupLayout jPanel3Layout = new javax.swing.GroupLayout(jPanel3);
-        jPanel3.setLayout(jPanel3Layout);
-        jPanel3Layout.setHorizontalGroup(
-            jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGroup(jPanel3Layout.createSequentialGroup()
-                .addGap(128, 128, 128)
-                .addComponent(jButtonAceptGnuP)
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addComponent(jButtonResetGnuP)
-                .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
-            .addComponent(jScrollPaneGnuP, javax.swing.GroupLayout.DEFAULT_SIZE, 700, Short.MAX_VALUE)
-        );
-        jPanel3Layout.setVerticalGroup(
-            jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanel3Layout.createSequentialGroup()
-                .addContainerGap()
-                .addComponent(jScrollPaneGnuP, javax.swing.GroupLayout.PREFERRED_SIZE, 247, javax.swing.GroupLayout.PREFERRED_SIZE)
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jButtonAceptGnuP)
-                    .addComponent(jButtonResetGnuP)))
-        );
-
-        jTabbedPane1.addTab("GnuPlot", jPanel3);
-
-        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
-        this.setLayout(layout);
-        layout.setHorizontalGroup(
-            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGroup(layout.createSequentialGroup()
-                .addContainerGap()
-                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                    .addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
-                    .addComponent(jTabbedPane1, javax.swing.GroupLayout.Alignment.TRAILING))
-                .addContainerGap())
-        );
-        layout.setVerticalGroup(
-            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
-                .addContainerGap()
-                .addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
-                .addComponent(jTabbedPane1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                .addGap(7, 7, 7))
-        );
-    }// </editor-fold>//GEN-END:initComponents
-
-    private void jButtonInPathActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonInPathActionPerformed
-        path = getDirectory("open", JFileChooser.DIRECTORIES_ONLY);
-        if (!path.equals("")) {
-            reset();
-            resetP();
-            this.jTextFieldResultPath.setText(path);
-             rf = new ReadFile(path);
-            String str = rf.processFiles();
-            if (str.equals("")) {
-
-                int algSize = rf.getAlgShortNames().size();
-                int streamSize = rf.getStream().size();
-                this.measures = rf.getMeasures();
-                for (int i = 0; i < algSize; i++) {
-                    this.algoritmModel.addRow(new Object[]{rf.getAlgNames().get(i), rf.getAlgShortNames().get(i)});
-                }
-                for (int i = 0; i < streamSize; i++) {
-                    this.streamModel.addRow(new Object[]{rf.getStream().get(i), rf.getStream().get(i)});
-                }
-
-                String measuresNames[] = measures.getFirst().split(",");
-                for (String measuresName : measuresNames) {
-                    jComboBoxXColumn.addItem(measuresName);
-                    jComboBoxYColumn.addItem(measuresName);
-                    jComboBoxXColumnGnuP.addItem(measuresName);
-                    jComboBoxYColumnGnuP.addItem(measuresName);
-                    if (measuresName.equals("learning evaluation instances") == true) {
-                        jComboBoxXColumn.setSelectedItem(measuresName);
-                        jComboBoxXColumnGnuP.setSelectedItem(measuresName);
-                    }
-                    if (measuresName.equals("classifications correct (percent)") == true
-                            || measuresName.equals("[avg] classifications correct (percent)") == true) {
-                        jComboBoxYColumn.setSelectedItem(measuresName);
-                        jComboBoxYColumnGnuP.setSelectedItem(measuresName);
-                    }
-
-                }
-            } else {
-
-                JOptionPane.showMessageDialog(this, str,
-                        "Error", JOptionPane.ERROR_MESSAGE);
-            }
-        }
-    }//GEN-LAST:event_jButtonInPathActionPerformed
-
-    private void jButtonDeletAlgorithmActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonDeletAlgorithmActionPerformed
-         if (this.jTableAlgoritms.getSelectedRow() != -1) {
-           
-            this.algoritmModel.removeRow(this.jTableAlgoritms.getSelectedRow());
-             String algorithms[] = new String[algoritmModel.getRowCount()];
-            for (int i = 0; i < algoritmModel.getRowCount(); i++) {
-                algorithms[i] = algoritmModel.getValueAt(i, 0).toString();
-            }
-           if (streamModel.getValueAt(0, 0).toString() != null) {
-               String s = streamModel.getValueAt(0, 0).toString();
-               rf.updateMeasures(algorithms, s);
-            this.measures = rf.getMeasures();
-            String measuresNames[] = measures.getFirst().split(",");
-            jComboBoxXColumn.removeAllItems();
-            jComboBoxYColumn.removeAllItems();
-            jComboBoxXColumnGnuP.removeAllItems();
-            jComboBoxYColumnGnuP.removeAllItems();
-            for (String measuresName : measuresNames) {
-                jComboBoxXColumn.addItem(measuresName);
-                jComboBoxYColumn.addItem(measuresName);
-                jComboBoxXColumnGnuP.addItem(measuresName);
-                jComboBoxYColumnGnuP.addItem(measuresName);
-                if (measuresName.equals("learning evaluation instances") == true) {
-                    jComboBoxXColumn.setSelectedItem(measuresName);
-                    jComboBoxXColumnGnuP.setSelectedItem(measuresName);
-                }
-                if (measuresName.equals("classifications correct (percent)") == true || measuresName.equals("[avg] classifications correct (percent)")) {
-                    jComboBoxYColumn.setSelectedItem(measuresName);
-                    jComboBoxYColumnGnuP.setSelectedItem(measuresName);
-                }
-
-            }
-           }
-        }
-    }//GEN-LAST:event_jButtonDeletAlgorithmActionPerformed
-
-    private void jButtonDeleteStreamActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonDeleteStreamActionPerformed
-        this.streamModel.removeRow(this.jTableStreams.getSelectedRow());
-    }//GEN-LAST:event_jButtonDeleteStreamActionPerformed
-
-    private void jButtonAceptActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonAceptActionPerformed
-
-        int algCount = this.jTableAlgoritms.getRowCount();
-        int streamCount = this.jTableStreams.getRowCount();
-        chart = new ImageChart[streamCount];
-
-        for (int i = 0; i < streamCount; i++) {
-            String streamName = this.jTableStreams.getModel().getValueAt(i, 0).toString();
-            String streamID = this.jTableStreams.getModel().getValueAt(i, 1).toString();
-            XYSeriesCollection dataset = new XYSeriesCollection();
-            for (int j = 0; j < algCount; j++) {
-                try {
-                    String algName = this.jTableAlgoritms.getModel().getValueAt(j, 0).toString();
-                    String algID = this.jTableAlgoritms.getModel().getValueAt(j, 1).toString();
-                    String algPath = FilenameUtils.separatorsToSystem(
-                            this.path + "\\" + streamName + "\\" + algName);
-                    File inputFile = new File(algPath);
-                    if (!inputFile.exists()) {
-                        JOptionPane.showMessageDialog(this, "File not found: "
-                                + inputFile.getAbsolutePath(),
-                                "Error", JOptionPane.ERROR_MESSAGE);
-                        return;
-                    }
-                    /*Preparing the graph*/
-                    ArrayList<String[]> data = readCSV(algPath);
-                    XYSeries series = new XYSeries(algID);
-                    int x = ReadFile.getMeasureIndex(algPath,this.jComboBoxXColumn.getSelectedItem().toString());
-                    int y = ReadFile.getMeasureIndex(algPath,this.jComboBoxYColumn.getSelectedItem().toString());
-                    
-                    for (String[] s : data) {
-                        series.add(Double.parseDouble(s[x]), Double.parseDouble(s[y]));
-                    }
-
-                    dataset.addSeries(series);
-
-                } catch (FileNotFoundException ex) {
-                    Logger.getLogger(PlotTab.class.getName()).log(Level.SEVERE, null, ex);
-                } catch (IOException ex) {
-                    Logger.getLogger(PlotTab.class.getName()).log(Level.SEVERE, null, ex);
-                }
-            }//end for 
-            /*Create chart*/
-            JFreeChart imgChart = ChartFactory.createXYLineChart(
-                    this.jTextFieldTitle.getText(), // Title
-                    this.jTextFieldxTitle.getText(), // x-axis Label
-                    this.jTextFieldyTitle.getText(), // y-axis Label
-                    dataset, // Dataset
-                    PlotOrientation.VERTICAL, // Plot Orientation
-                    true, // Show Legend
-                    true, // Use tooltips
-                    false // Configure chart to generate URLs?
-            );
-            final XYPlot plot = imgChart.getXYPlot();
-            switch (this.jComboBoxGrid.getSelectedItem().toString()) {
-                case "White":
-                    plot.setBackgroundPaint(Color.white);
-                    break;
-                case "Default":
-                    plot.setBackgroundPaint(Color.lightGray);
-            }
-            if (this.jCheckBoxShape.isSelected()) {
-                final XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer();
-                renderer.setSeriesLinesVisible(0, true);
-                renderer.setSeriesShapesVisible(1, false);
-                for (int k = 0; k < algCount; k++) {
-                    renderer.setSeriesPaint(k, Color.black);
-                }
-                plot.setRenderer(renderer);
-            }
-
-            this.chart[i] = new ImageChart(streamID, imgChart,
-                    (int) this.jSpinnerWidth.getValue(), (int) this.jSpinnerHeight.getValue());
-
-        }
-        this.imgPanel = new ImageTreePanel(chart);
-        new ImageViewer(imgPanel, path);
-
-    }//GEN-LAST:event_jButtonAceptActionPerformed
-
-    private void jButtonResetActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonResetActionPerformed
-        reset();
-    }//GEN-LAST:event_jButtonResetActionPerformed
-
-    private void jButtonAceptGnuPActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonAceptGnuPActionPerformed
-
-        if (!this.jTextFieldResultPath.getText().equals("")) {
-            String outPath = getDirectory("open", JFileChooser.DIRECTORIES_ONLY);
-            if(!outPath.equals("")){
-                
-            File resultFile = new File(this.jTextFieldResultPath.getText());
-            String resultDirectory = resultFile.getAbsolutePath();
-            String gnuPlotPath = this.jTextFieldGNUPath.getText();
-            String gnuplotScriptPath = null;
-            File gnuplotDir = new File(gnuPlotPath);
-            if (!gnuplotDir.exists()) {
-                JOptionPane.showMessageDialog(this, "Gnuplot directory not found: " + gnuPlotPath, "Error", JOptionPane.ERROR_MESSAGE);
-                return;
-            }
-            String algShortName[] = new String[this.jTableAlgoritms.getRowCount()];
-            String algName[] = new String[this.jTableAlgoritms.getRowCount()];
-            for (int i = 0; i < this.jTableStreams.getRowCount(); i++) {
-                String streamName = this.jTableStreams.getModel().getValueAt(i, 0).toString();
-                String streamShortName = this.jTableStreams.getModel().getValueAt(i, 1).toString();
-                for (int j = 0; j < this.jTableAlgoritms.getRowCount(); j++) {
-                    algName[j] = this.jTableAlgoritms.getModel().getValueAt(j, 0).toString();
-                    algShortName[j] = this.jTableAlgoritms.getModel().getValueAt(j, 1).toString();
-                    File inputFile = new File(FilenameUtils.separatorsToSystem(
-                            this.path + "\\" + streamName + "\\" + algName[j]));
-
-                    if (!inputFile.exists()) {
-                        JOptionPane.showMessageDialog(this, "File not found: "
-                                + inputFile.getAbsolutePath(),
-                                "Error", JOptionPane.ERROR_MESSAGE);
-                        return;
-                    }
-
-                }
-
-                gnuplotScriptPath = resultDirectory + File.separator
-                        + resultFile.getName() + ".plt";
-                String script = createScript(streamName, algName, algShortName, outPath);
-                File scriptFile = writeScriptToFile(gnuplotScriptPath, script);
-                String gnuplotCommand = gnuPlotPath + File.separator + "gnuplot \""
-                        + gnuplotScriptPath + "\"";
-                String line, gnuplotOutput = "";
-                try {
-                    Process p = Runtime.getRuntime().exec(gnuplotCommand);
-
-                    BufferedReader err = new BufferedReader(new InputStreamReader(p
-                            .getErrorStream()));
-                    while ((line = err.readLine()) != null) {
-                        gnuplotOutput += line + System.getProperty("line.separator");
-                    }
-                    err.close();
-                } catch (IOException ex) {
-                    JOptionPane.showMessageDialog(this, "Error while executing gnuplot script",
-                            "Error", JOptionPane.ERROR_MESSAGE);
-                    throw new RuntimeException("Error while executing gnuplot script:"
-                            + scriptFile, ex);
-
-                }
-                if (this.jCheckBoxDeleteScript.isSelected()) {
-                    scriptFile.delete();
-                }
-            }
-
-            //Completed
-            JOptionPane.showMessageDialog(this, "Figures created at " + (new File(resultFile.getAbsolutePath())).getParent(),
-                    "", JOptionPane.INFORMATION_MESSAGE);
-        }
-        } else {
-            JOptionPane.showMessageDialog(this, "Plot output file option not set!",
-                    "Error", JOptionPane.ERROR_MESSAGE);
-        }
-
-    }//GEN-LAST:event_jButtonAceptGnuPActionPerformed
-
-    private void jButtonResetGnuPActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonResetGnuPActionPerformed
-        resetP();
-    }//GEN-LAST:event_jButtonResetGnuPActionPerformed
-
-    private void jButtonGnuoPathActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonGnuoPathActionPerformed
-        this.jTextFieldGNUPath.setText(getDirectory("open", JFileChooser.DIRECTORIES_ONLY));
-    }//GEN-LAST:event_jButtonGnuoPathActionPerformed
-
-    private void jComboBoxLegendLocationActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jComboBoxLegendLocationActionPerformed
-        // TODO add your handling code here:
-    }//GEN-LAST:event_jComboBoxLegendLocationActionPerformed
-
-    private void jTextFieldGNUPathActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jTextFieldGNUPathActionPerformed
-        // TODO add your handling code here:
-    }//GEN-LAST:event_jTextFieldGNUPathActionPerformed
-
-    /**
-     * Allows to read the results file and update the corresponding fields.
-     *
-     * @param path
-     */
-    public void readData(String path) {
-        reset();
-        resetP();
-        this.jTextFieldResultPath.setText(path);
-        this.path = path;
-        rf = new ReadFile(path);
-        String str = rf.processFiles();
-        if (str.equals("")) {
-
-            int algSize = rf.getAlgShortNames().size();
-            int streamSize = rf.getStream().size();
-            this.measures = rf.getMeasures();
-            for (int i = 0; i < algSize; i++) {
-                this.algoritmModel.addRow(new Object[]{rf.getAlgNames().get(i), rf.getAlgShortNames().get(i)});
-            }
-            for (int i = 0; i < streamSize; i++) {
-                this.streamModel.addRow(new Object[]{rf.getStream().get(i), rf.getStream().get(i)});
-            }
-            String measuresNames[] = measures.getFirst().split(",");
-            for (String measuresName : measuresNames) {
-                jComboBoxXColumn.addItem(measuresName);
-                jComboBoxYColumn.addItem(measuresName);
-                jComboBoxXColumnGnuP.addItem(measuresName);
-                jComboBoxYColumnGnuP.addItem(measuresName);
-                if (measuresName.equals("learning evaluation instances") == true) {
-                    jComboBoxXColumn.setSelectedItem(measuresName);
-                    jComboBoxXColumnGnuP.setSelectedItem(measuresName);
-                }
-                if (measuresName.equals("classifications correct (percent)") == true || measuresName.equals("[avg] classifications correct (percent)")) {
-                    jComboBoxYColumn.setSelectedItem(measuresName);
-                    jComboBoxYColumnGnuP.setSelectedItem(measuresName);
-                }
-
-            }
-        } else {
-
-            JOptionPane.showMessageDialog(this, str,
-                    "Error", JOptionPane.ERROR_MESSAGE);
-        }
-
-    }
-
-    private String getDirectory(String type, int filter) {
-        BaseDirectoryChooser gnuPlotDir = new BaseDirectoryChooser();
-        gnuPlotDir.setFileSelectionMode(filter);
-        int selection = -1;
-        if (type.equals("open")) 
-            selection = gnuPlotDir.showOpenDialog(this);
-        if (selection == JFileChooser.APPROVE_OPTION) {
-
-            try {
-                return gnuPlotDir.getSelectedFile().getAbsolutePath();
-
-            } catch (Exception exp) {
-            }
-
-        }
-        return "";
-    }
-
-    /**
-     * Clean the tables
-     */
-    public void cleanTables() {
-        try {
-            DefaultTableModel algModel = (DefaultTableModel) jTableAlgoritms.getModel();
-            DefaultTableModel strModel = (DefaultTableModel) jTableStreams.getModel();
-            int rows = jTableAlgoritms.getRowCount();
-            int srow = jTableStreams.getRowCount();
-            for (int i = 0; i < rows; i++) {
-                algModel.removeRow(0);
-            }
-            for (int i = 0; i < srow; i++) {
-                strModel.removeRow(0);
-            }
-
-        } catch (Exception e) {
-            JOptionPane.showMessageDialog(null, "Error cleaning the table.");
-        }
-    }
-
-    private void reset() {
-        cleanTables();
-        this.jTextFieldResultPath.setText("");
-
-        this.jTextFieldxTitle.setText("Instances processed");
-
-        this.jTextFieldyTitle.setText("% of correctly classified");
-
-        //Combobox
-        this.jComboBoxXColumn.removeAllItems();
-        this.jComboBoxYColumn.removeAllItems();
-        //spinner
-        this.jSpinnerWidth.setValue(500);
-        this.jSpinnerHeight.setValue(300);
-
-        this.jCheckBoxShape.setSelected(false);
-        this.jComboBoxGrid.setSelectedItem("White");
-
-    }
-
-    private void resetP() {
-        cleanTables();
-        this.jTextFieldGNUPath.setText("");
-        this.jTextFieldResultPath.setText("");
-        this.jTextFieldAPOptions.setText("");
-        this.jTextFieldAdcComand.setText("");
-        this.jTextFieldxTitleGnuP.setText("Instances processed");
-        this.jTextFieldyTitleGnuP.setText("% of correctly classified");
-        //Combobox
-        this.jComboBoxLegendLocation.setSelectedIndex(0);
-
-        this.jComboBoxLegendType.setSelectedIndex(0);
-        this.jComboBoxLineStyle.setSelectedIndex(0);
-        this.jComboBoxOutPTypeGnuP.setSelectedIndex(0);
-        this.jComboBoxXColumnGnuP.removeAllItems();
-        this.jComboBoxYColumnGnuP.removeAllItems();
-        //spinner
-        this.jSpinnerLineWidth.setValue(2);
-        this.jSpinnerPlotInterval.setValue(0);
-
-    }
-
-    private String createScript(String streamName, String algName[], String algShortName[], String outPath) {
-        String newLine = System.getProperty("line.separator");
-        int sourceFileIdx = 0;
-
-        String imgName;
-        boolean eps = false;
-        switch (this.jComboBoxOutPTypeGnuP.getSelectedItem().toString()) {
-            case "GIF":
-                imgName = outPath + File.separator + streamName + "GP" + ".gif";
-                break;
-            case "JPEG":
-                imgName = outPath + File.separator + streamName + "GP" + ".JPEG";
-                break;
-            case "LATEX":
-                imgName = outPath + File.separator + streamName + "GP" + ".tex";
-                break;
-            case "PDFCAIRO":
-                imgName = outPath + File.separator + streamName + "GP" + ".pdf";
-                break;
-            case "PNG":
-                imgName = outPath + File.separator + streamName + "GP" + ".PNG";
-                break;
-            case "PSTEX":
-                imgName = outPath + File.separator + streamName + "GP" + ".tex";
-                break;
-            case "PSTRICKS":
-                imgName = outPath + File.separator + streamName + "GP" + ".tex";
-                break;
-            case "PSLATEX":
-                imgName = outPath + File.separator + streamName + "GP" + ".tex";
-                break;
-            case "SVG":
-                imgName = outPath + File.separator + streamName + "GP" + ".SVG";
-                break;
-            default:
-                imgName = outPath + File.separator + streamName + "GP" + ".eps";
-                eps = true;
-
-        }
-        // terminal options;
-        String script;
-        if (eps) {
-            script = "set term "
-                    + terminalOptions(Terminal.valueOf(this.jComboBoxOutPTypeGnuP.getSelectedItem().toString())) + " eps " + newLine;
-        } else {
-            script = "set term "
-                    + terminalOptions(Terminal.valueOf(this.jComboBoxOutPTypeGnuP.getSelectedItem().toString())) + newLine;
-        }
-        script += "set loadpath '" + FilenameUtils.separatorsToSystem(path + File.separator + streamName) + "'" + newLine;
-        script += "set output '" + imgName + "'" + newLine;
-        script += "set datafile separator ','" + newLine;
-        //script += "set grid" + newLine;
-        script += "set style line 1 pt 8" + newLine;
-        script += "set style line 2 lt rgb '#00C000'" + newLine;
-        script += "set style line 5 lt rgb '#FFD800'" + newLine;
-        script += "set style line 6 lt rgb '#4E0000'" + newLine;
+	private String path = "";
+
+	private LinkedList<String> measures = new LinkedList();
+
+	private DefaultTableModel algoritmModel;
+
+	private DefaultTableModel streamModel;
+
+	ImageTreePanel imgPanel;
+
+	ImageChart chart[];
+
+	ReadFile rf;
+
+	public PlotTab() {
+		initComponents();
+		initComponents();
+		this.algoritmModel = (DefaultTableModel) jTableAlgoritms.getModel();
+		this.streamModel = (DefaultTableModel) jTableStreams.getModel();
+	}
+
+	/**
+	 * This method is called from within the constructor to initialize the form.
+	 * WARNING: Do NOT modify this code. The content of this method is always
+	 * regenerated by the Form Editor.
+	 */
+	@SuppressWarnings("unchecked")
+	// <editor-fold defaultstate="collapsed" desc="Generated
+	// Code">//GEN-BEGIN:initComponents
+	private void initComponents() {
+
+		jPanel1 = new javax.swing.JPanel();
+		jScrollPaneAlgorithms = new javax.swing.JScrollPane();
+		jTableAlgoritms = new javax.swing.JTable();
+		jScrollPane3 = new javax.swing.JScrollPane();
+		jTableStreams = new javax.swing.JTable();
+		jTextFieldResultPath = new javax.swing.JTextField();
+		jButtonInPath = new javax.swing.JButton();
+		jLabel3 = new javax.swing.JLabel();
+		jButtonDeletAlgorithm = new javax.swing.JButton();
+		jButtonDeleteStream = new javax.swing.JButton();
+		jTabbedPane1 = new javax.swing.JTabbedPane();
+		jPanel2 = new javax.swing.JPanel();
+		jButtonAcept = new javax.swing.JButton();
+		jButtonReset = new javax.swing.JButton();
+		jScrollPane1 = new javax.swing.JScrollPane();
+		jPanel4 = new javax.swing.JPanel();
+		jLabel17 = new javax.swing.JLabel();
+		jTextFieldxTitle = new javax.swing.JTextField();
+		jLabel18 = new javax.swing.JLabel();
+		jLabel19 = new javax.swing.JLabel();
+		jTextFieldyTitle = new javax.swing.JTextField();
+		jLabel20 = new javax.swing.JLabel();
+		jComboBoxXColumn = new javax.swing.JComboBox();
+		jComboBoxYColumn = new javax.swing.JComboBox();
+		jTextFieldTitle = new javax.swing.JTextField();
+		jLabel21 = new javax.swing.JLabel();
+		jSpinnerWidth = new javax.swing.JSpinner();
+		jSpinnerHeight = new javax.swing.JSpinner();
+		jLabel22 = new javax.swing.JLabel();
+		jLabel23 = new javax.swing.JLabel();
+		jComboBoxGrid = new javax.swing.JComboBox();
+		jCheckBoxShape = new javax.swing.JCheckBox();
+		jLabel2 = new javax.swing.JLabel();
+		jPanel3 = new javax.swing.JPanel();
+		jButtonAceptGnuP = new javax.swing.JButton();
+		jButtonResetGnuP = new javax.swing.JButton();
+		jScrollPaneGnuP = new javax.swing.JScrollPane();
+		jPanelGnuP = new javax.swing.JPanel();
+		jTextFieldGNUPath = new javax.swing.JTextField();
+		jLabel1 = new javax.swing.JLabel();
+		jButtonGnuoPath = new javax.swing.JButton();
+		jComboBoxOutPTypeGnuP = new javax.swing.JComboBox();
+		jLabel5 = new javax.swing.JLabel();
+		jComboBoxLineStyle = new javax.swing.JComboBox();
+		jLabel6 = new javax.swing.JLabel();
+		jLabel7 = new javax.swing.JLabel();
+		jTextFieldxTitleGnuP = new javax.swing.JTextField();
+		jLabel8 = new javax.swing.JLabel();
+		jLabel10 = new javax.swing.JLabel();
+		jTextFieldyTitleGnuP = new javax.swing.JTextField();
+		jLabel11 = new javax.swing.JLabel();
+		jSpinnerLineWidth = new javax.swing.JSpinner();
+		jSpinnerPlotInterval = new javax.swing.JSpinner();
+		jLabel13 = new javax.swing.JLabel();
+		jLabel14 = new javax.swing.JLabel();
+		jCheckBoxSmooth = new javax.swing.JCheckBox();
+		jLabel15 = new javax.swing.JLabel();
+		jCheckBoxDeleteScript = new javax.swing.JCheckBox();
+		jLabel16 = new javax.swing.JLabel();
+		jComboBoxLegendLocation = new javax.swing.JComboBox();
+		jLabel24 = new javax.swing.JLabel();
+		jComboBoxLegendType = new javax.swing.JComboBox();
+		jLabel25 = new javax.swing.JLabel();
+		jTextFieldAdcComand = new javax.swing.JTextField();
+		jLabel26 = new javax.swing.JLabel();
+		jTextFieldAPOptions = new javax.swing.JTextField();
+		jLabel27 = new javax.swing.JLabel();
+		jComboBoxXColumnGnuP = new javax.swing.JComboBox();
+		jComboBoxYColumnGnuP = new javax.swing.JComboBox();
+
+		jPanel1.setBorder(javax.swing.BorderFactory.createTitledBorder("Configuration"));
+
+		jScrollPaneAlgorithms.setBorder(javax.swing.BorderFactory.createTitledBorder("Algorithm"));
+
+		jTableAlgoritms.setBorder(javax.swing.BorderFactory.createTitledBorder(""));
+		jTableAlgoritms.setModel(new javax.swing.table.DefaultTableModel(new Object[][] {
+
+		}, new String[] { "Algorithm", "Algorithm ID" }));
+		jScrollPaneAlgorithms.setViewportView(jTableAlgoritms);
+
+		jScrollPane3.setBorder(javax.swing.BorderFactory.createTitledBorder("Stream"));
+
+		jTableStreams.setBorder(javax.swing.BorderFactory.createTitledBorder(""));
+		jTableStreams.setModel(new javax.swing.table.DefaultTableModel(new Object[][] {
+
+		}, new String[] { "Stream", "Stream ID" }));
+		jScrollPane3.setViewportView(jTableStreams);
+
+		jButtonInPath.setText("Browse");
+		jButtonInPath.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				jButtonInPathActionPerformed(evt);
+			}
+		});
+
+		jLabel3.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
+		jLabel3.setText("Result  folder");
+
+		jButtonDeletAlgorithm.setText("Delete Algorithm");
+		jButtonDeletAlgorithm.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				jButtonDeletAlgorithmActionPerformed(evt);
+			}
+		});
+
+		jButtonDeleteStream.setText("Delete Stream");
+		jButtonDeleteStream.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				jButtonDeleteStreamActionPerformed(evt);
+			}
+		});
+
+		javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1);
+		jPanel1.setLayout(jPanel1Layout);
+		jPanel1Layout.setHorizontalGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+				.addGroup(jPanel1Layout.createSequentialGroup()
+						.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+								.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
+										jPanel1Layout.createSequentialGroup().addGap(14, 14, 14).addComponent(jLabel3)
+												.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+												.addComponent(jTextFieldResultPath)
+												.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
+												.addComponent(jButtonInPath))
+								.addGroup(jPanel1Layout.createSequentialGroup().addContainerGap()
+										.addGroup(jPanel1Layout
+												.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+												.addComponent(jButtonDeletAlgorithm).addComponent(jScrollPaneAlgorithms,
+														javax.swing.GroupLayout.PREFERRED_SIZE, 0, Short.MAX_VALUE))
+										.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
+										.addGroup(jPanel1Layout
+												.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+												.addComponent(jScrollPane3, javax.swing.GroupLayout.PREFERRED_SIZE, 0,
+														Short.MAX_VALUE)
+												.addGroup(jPanel1Layout.createSequentialGroup()
+														.addComponent(jButtonDeleteStream)
+														.addGap(0, 0, Short.MAX_VALUE)))))
+						.addGap(16, 16, 16)));
+		jPanel1Layout.setVerticalGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+				.addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanel1Layout.createSequentialGroup()
+						.addGap(23, 23, 23)
+						.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+								.addComponent(jTextFieldResultPath, javax.swing.GroupLayout.PREFERRED_SIZE, 23,
+										javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addComponent(jButtonInPath).addComponent(jLabel3))
+						.addGap(18, 18, 18)
+						.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+								.addComponent(jScrollPaneAlgorithms, javax.swing.GroupLayout.DEFAULT_SIZE, 89,
+										Short.MAX_VALUE)
+								.addComponent(jScrollPane3, javax.swing.GroupLayout.PREFERRED_SIZE, 0, Short.MAX_VALUE))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+						.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+								.addComponent(jButtonDeleteStream).addComponent(jButtonDeletAlgorithm))));
+
+		jButtonAcept.setText("Generate Images");
+		jButtonAcept.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				jButtonAceptActionPerformed(evt);
+			}
+		});
+
+		jButtonReset.setText(" Reset to Default");
+		jButtonReset.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				jButtonResetActionPerformed(evt);
+			}
+		});
+
+		jScrollPane1.setBorder(javax.swing.BorderFactory.createTitledBorder(""));
+		jScrollPane1.setHorizontalScrollBarPolicy(javax.swing.ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
+
+		jPanel4.setBorder(javax.swing.BorderFactory.createTitledBorder(""));
+
+		jLabel17.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
+		jLabel17.setText("xColumn");
+
+		jTextFieldxTitle.setText("Instances processed");
+
+		jLabel18.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
+		jLabel18.setText("xTitle");
+
+		jLabel19.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
+		jLabel19.setText("yColumn");
+
+		jTextFieldyTitle.setText("% of correctly classified");
+
+		jLabel20.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
+		jLabel20.setText("yTitle");
+
+		jLabel21.setText("title");
+
+		jSpinnerWidth.setValue(500);
+
+		jSpinnerHeight.setValue(300);
+
+		jLabel22.setText("width");
+
+		jLabel23.setText("height");
+
+		jComboBoxGrid.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "White", "Default" }));
+
+		jCheckBoxShape.setText("shapes");
+
+		jLabel2.setText("gridColor");
+
+		javax.swing.GroupLayout jPanel4Layout = new javax.swing.GroupLayout(jPanel4);
+		jPanel4.setLayout(jPanel4Layout);
+		jPanel4Layout.setHorizontalGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+				.addGroup(jPanel4Layout.createSequentialGroup().addGap(67, 67, 67).addGroup(jPanel4Layout
+						.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
+						.addGroup(jPanel4Layout.createSequentialGroup().addGap(3, 3, 3).addGroup(jPanel4Layout
+								.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+								.addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
+										.addComponent(jLabel17).addComponent(jLabel21).addComponent(jLabel18))
+								.addComponent(jLabel19)
+								.addComponent(jLabel20, javax.swing.GroupLayout.Alignment.TRAILING)
+								.addComponent(jLabel22, javax.swing.GroupLayout.Alignment.TRAILING)).addGap(18, 18, 18)
+								.addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+										.addComponent(jTextFieldxTitle)
+										.addComponent(jComboBoxXColumn, javax.swing.GroupLayout.Alignment.TRAILING, 0,
+												javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
+										.addComponent(jTextFieldTitle, javax.swing.GroupLayout.Alignment.TRAILING)
+										.addComponent(jComboBoxYColumn, 0, javax.swing.GroupLayout.DEFAULT_SIZE,
+												Short.MAX_VALUE)
+										.addComponent(jTextFieldyTitle, javax.swing.GroupLayout.DEFAULT_SIZE, 542,
+												Short.MAX_VALUE)
+										.addComponent(jSpinnerWidth)))
+						.addGroup(javax.swing.GroupLayout.Alignment.LEADING, jPanel4Layout.createSequentialGroup()
+								.addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
+										.addComponent(jLabel23).addComponent(jLabel2))
+								.addGap(18, 18, 18)
+								.addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+										.addGroup(jPanel4Layout.createSequentialGroup()
+												.addComponent(jCheckBoxShape, javax.swing.GroupLayout.PREFERRED_SIZE,
+														91, javax.swing.GroupLayout.PREFERRED_SIZE)
+												.addGap(0, 0, Short.MAX_VALUE))
+										.addComponent(jComboBoxGrid, 0, javax.swing.GroupLayout.DEFAULT_SIZE,
+												Short.MAX_VALUE)
+										.addComponent(jSpinnerHeight))))
+						.addGap(30, 30, 30)));
+		jPanel4Layout.setVerticalGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+				.addGroup(jPanel4Layout.createSequentialGroup().addContainerGap()
+						.addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+								.addComponent(jTextFieldTitle, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addComponent(jLabel21))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+						.addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+								.addComponent(jComboBoxXColumn, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addComponent(jLabel17))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+						.addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+								.addComponent(jTextFieldxTitle, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addComponent(jLabel18))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+						.addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+								.addComponent(jComboBoxYColumn, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addComponent(jLabel19))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED,
+								javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
+						.addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+								.addComponent(jTextFieldyTitle, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addComponent(jLabel20))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+						.addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+								.addComponent(jSpinnerWidth, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addComponent(jLabel22))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+						.addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+								.addComponent(jLabel23).addComponent(jSpinnerHeight,
+										javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE,
+										javax.swing.GroupLayout.PREFERRED_SIZE))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+						.addGroup(jPanel4Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+								.addComponent(jComboBoxGrid, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addComponent(jLabel2))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+						.addComponent(jCheckBoxShape).addContainerGap(11, Short.MAX_VALUE)));
+
+		jScrollPane1.setViewportView(jPanel4);
+
+		javax.swing.GroupLayout jPanel2Layout = new javax.swing.GroupLayout(jPanel2);
+		jPanel2.setLayout(jPanel2Layout);
+		jPanel2Layout.setHorizontalGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+				.addGroup(jPanel2Layout.createSequentialGroup().addGap(135, 135, 135).addComponent(jButtonAcept)
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED).addComponent(jButtonReset)
+						.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
+				.addComponent(jScrollPane1, javax.swing.GroupLayout.Alignment.TRAILING,
+						javax.swing.GroupLayout.DEFAULT_SIZE, 700, Short.MAX_VALUE));
+		jPanel2Layout.setVerticalGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+				.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
+						jPanel2Layout.createSequentialGroup().addContainerGap()
+								.addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 247,
+										javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+								.addGroup(jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+										.addComponent(jButtonAcept).addComponent(jButtonReset))));
+
+		jTabbedPane1.addTab("Charts", jPanel2);
+
+		jButtonAceptGnuP.setText("Generate GnuPlot Commands");
+		jButtonAceptGnuP.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				jButtonAceptGnuPActionPerformed(evt);
+			}
+		});
+
+		jButtonResetGnuP.setText(" Reset to Default");
+		jButtonResetGnuP.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				jButtonResetGnuPActionPerformed(evt);
+			}
+		});
+
+		jScrollPaneGnuP.setBorder(javax.swing.BorderFactory.createTitledBorder(""));
+		jScrollPaneGnuP.setHorizontalScrollBarPolicy(javax.swing.ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
+
+		jPanelGnuP.setBorder(javax.swing.BorderFactory.createTitledBorder(""));
+		jPanelGnuP.setPreferredSize(new java.awt.Dimension(400, 449));
+
+		jTextFieldGNUPath.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				jTextFieldGNUPathActionPerformed(evt);
+			}
+		});
+
+		jLabel1.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
+		jLabel1.setText("gnuplotBinaryPath ");
+
+		jButtonGnuoPath.setText("Browse");
+		jButtonGnuoPath.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				jButtonGnuoPathActionPerformed(evt);
+			}
+		});
+
+		jComboBoxOutPTypeGnuP.setModel(
+				new javax.swing.DefaultComboBoxModel(new String[] { "POSTSCRIPT_COLOR", "EPSLATEX", "GIF", "JPEG",
+						"LATEX", "PDFCAIRO", "PNG", "POSTSCRIPT", "CANVAS", "PSLATEX", "PSTEX", "PSTRICKS", "SVG" }));
+
+		jLabel5.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
+		jLabel5.setText("outputType");
+
+		jComboBoxLineStyle.setModel(new javax.swing.DefaultComboBoxModel(
+				new String[] { "LINES", "POINTS", "LINESPOINTS", "IMPULSES", "STEPS", "FSTEPS", "HISTEPS", "DOTS;" }));
+
+		jLabel6.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
+		jLabel6.setText("plotStyle");
+
+		jLabel7.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
+		jLabel7.setText("xColumn");
+
+		jTextFieldxTitleGnuP.setText("Processed instances");
+
+		jLabel8.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
+		jLabel8.setText("xTitle");
+
+		jLabel10.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
+		jLabel10.setText("yColumn");
+
+		jTextFieldyTitleGnuP.setText("Accuracy");
+
+		jLabel11.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
+		jLabel11.setText("yTitle");
+
+		jSpinnerLineWidth.setValue(2);
+
+		jLabel13.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
+		jLabel13.setText("lineWidth");
+
+		jLabel14.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
+		jLabel14.setText("plotInterval");
+
+		jLabel15.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
+		jLabel15.setText("smooth");
+
+		jLabel16.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
+		jLabel16.setText("deleteScripts");
+
+		jComboBoxLegendLocation.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "BOTTOM_CENTER_OUTSIDE",
+				"TOP_LEFT_INSIDE", "TOP_CENTER_INSIDE", "TOP_RIGHT_INSIDE", "LEFT_INSIDE", "CENTER_INSIDE",
+				"RIGHT_INSIDE", "BOTTOM_LEFT_INSIDE", "BOTTOM_CENTER_INSIDE", "BOTTOM_RIGHT_INSIDE", "TOP_LEFT_OUTSIDE",
+				"TOP_CENTER_OUTSIDE", "TOP_RIGHT_OUTSIDE", "LEFT_OUTSIDE", "CENTER_OUTSIDE", "RIGHT_OUTSIDE",
+				"BOTTOM_LEFT_OUTSIDE", "BOTTOM_RIGHT_OUTSIDE" }));
+		jComboBoxLegendLocation.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				jComboBoxLegendLocationActionPerformed(evt);
+			}
+		});
+
+		jLabel24.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
+		jLabel24.setText("legendLocation");
+
+		jComboBoxLegendType.setModel(new javax.swing.DefaultComboBoxModel(
+				new String[] { "NOBOX_HORIZONTAL", "BOX_VERTICAL", "BOX_HORIZONTAL", "NOBOX_VERTICAL", " " }));
+
+		jLabel25.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
+		jLabel25.setText("legendType");
+
+		jLabel26.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
+		jLabel26.setText("additionalCommands");
+
+		jLabel27.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
+		jLabel27.setText("additionalPlotOptions");
+
+		javax.swing.GroupLayout jPanelGnuPLayout = new javax.swing.GroupLayout(jPanelGnuP);
+		jPanelGnuP.setLayout(jPanelGnuPLayout);
+		jPanelGnuPLayout.setHorizontalGroup(jPanelGnuPLayout
+				.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+				.addGroup(jPanelGnuPLayout.createSequentialGroup().addGroup(jPanelGnuPLayout
+						.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+						.addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+								.addGroup(jPanelGnuPLayout.createSequentialGroup().addGap(22, 22, 22)
+										.addGroup(jPanelGnuPLayout
+												.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+												.addComponent(jLabel5, javax.swing.GroupLayout.Alignment.TRAILING)
+												.addComponent(jLabel6, javax.swing.GroupLayout.Alignment.TRAILING)
+												.addComponent(jLabel7, javax.swing.GroupLayout.Alignment.TRAILING)
+												.addComponent(jLabel8, javax.swing.GroupLayout.Alignment.TRAILING)
+												.addComponent(jLabel10, javax.swing.GroupLayout.Alignment.TRAILING)
+												.addComponent(jLabel11, javax.swing.GroupLayout.Alignment.TRAILING)
+												.addComponent(jLabel1, javax.swing.GroupLayout.Alignment.TRAILING)))
+								.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
+										jPanelGnuPLayout.createSequentialGroup().addContainerGap()
+												.addComponent(jLabel27)))
+						.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
+								jPanelGnuPLayout.createSequentialGroup().addContainerGap().addGroup(
+										jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+												.addComponent(jLabel15, javax.swing.GroupLayout.Alignment.TRAILING)
+												.addComponent(jLabel13, javax.swing.GroupLayout.Alignment.TRAILING)
+												.addComponent(jLabel14, javax.swing.GroupLayout.Alignment.TRAILING)
+												.addComponent(jLabel16, javax.swing.GroupLayout.Alignment.TRAILING)
+												.addComponent(jLabel24, javax.swing.GroupLayout.Alignment.TRAILING)
+												.addComponent(jLabel25, javax.swing.GroupLayout.Alignment.TRAILING)
+												.addComponent(jLabel26, javax.swing.GroupLayout.Alignment.TRAILING))))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
+						.addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+								.addComponent(jTextFieldAPOptions, javax.swing.GroupLayout.Alignment.TRAILING)
+								.addComponent(jTextFieldAdcComand, javax.swing.GroupLayout.Alignment.TRAILING)
+								.addComponent(jComboBoxLegendType, javax.swing.GroupLayout.Alignment.TRAILING, 0,
+										javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
+								.addComponent(jSpinnerPlotInterval, javax.swing.GroupLayout.Alignment.TRAILING)
+								.addComponent(jSpinnerLineWidth, javax.swing.GroupLayout.Alignment.TRAILING)
+								.addComponent(jTextFieldyTitleGnuP, javax.swing.GroupLayout.Alignment.TRAILING)
+								.addComponent(jTextFieldxTitleGnuP, javax.swing.GroupLayout.Alignment.TRAILING)
+								.addComponent(jComboBoxLineStyle, javax.swing.GroupLayout.Alignment.TRAILING, 0,
+										javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
+								.addComponent(jComboBoxXColumnGnuP, 0, javax.swing.GroupLayout.DEFAULT_SIZE,
+										Short.MAX_VALUE)
+								.addComponent(
+										jComboBoxYColumnGnuP, 0, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
+								.addComponent(jComboBoxLegendLocation, 0, 542, Short.MAX_VALUE)
+								.addGroup(jPanelGnuPLayout.createSequentialGroup().addComponent(jTextFieldGNUPath)
+										.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+										.addComponent(jButtonGnuoPath))
+								.addGroup(jPanelGnuPLayout.createSequentialGroup()
+										.addGroup(jPanelGnuPLayout
+												.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+												.addComponent(jCheckBoxDeleteScript).addComponent(jCheckBoxSmooth))
+										.addGap(0, 0, Short.MAX_VALUE))
+								.addComponent(jComboBoxOutPTypeGnuP, javax.swing.GroupLayout.Alignment.TRAILING, 0,
+										javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
+						.addContainerGap()));
+		jPanelGnuPLayout.setVerticalGroup(jPanelGnuPLayout
+				.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+				.addGroup(jPanelGnuPLayout.createSequentialGroup().addContainerGap()
+						.addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+								.addComponent(jTextFieldGNUPath, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addComponent(jButtonGnuoPath).addComponent(jLabel1))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+						.addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+								.addComponent(jComboBoxOutPTypeGnuP, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addComponent(jLabel5))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+						.addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+								.addComponent(jComboBoxLineStyle, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addComponent(jLabel6))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+						.addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+								.addComponent(jComboBoxXColumnGnuP, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addComponent(jLabel7))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+						.addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+								.addComponent(jTextFieldxTitleGnuP, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addComponent(jLabel8))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+						.addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+								.addComponent(jComboBoxYColumnGnuP, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addComponent(jLabel10))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+						.addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+								.addComponent(jTextFieldyTitleGnuP, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addComponent(jLabel11))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+						.addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+								.addComponent(jSpinnerLineWidth, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addComponent(jLabel13))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+						.addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+								.addComponent(jSpinnerPlotInterval, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addComponent(jLabel14))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+						.addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+								.addComponent(jCheckBoxSmooth).addComponent(jLabel15))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+						.addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+								.addComponent(jCheckBoxDeleteScript).addComponent(jLabel16))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+						.addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+								.addComponent(jComboBoxLegendLocation, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addComponent(jLabel24))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+						.addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+								.addComponent(jComboBoxLegendType, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addComponent(jLabel25))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+						.addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+								.addComponent(jTextFieldAdcComand, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addComponent(jLabel26))
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+						.addGroup(jPanelGnuPLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+								.addComponent(jTextFieldAPOptions, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addComponent(jLabel27))
+						.addGap(186, 186, 186)));
+
+		jScrollPaneGnuP.setViewportView(jPanelGnuP);
+
+		javax.swing.GroupLayout jPanel3Layout = new javax.swing.GroupLayout(jPanel3);
+		jPanel3.setLayout(jPanel3Layout);
+		jPanel3Layout.setHorizontalGroup(jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+				.addGroup(jPanel3Layout.createSequentialGroup().addGap(128, 128, 128).addComponent(jButtonAceptGnuP)
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+						.addComponent(jButtonResetGnuP)
+						.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
+				.addComponent(jScrollPaneGnuP, javax.swing.GroupLayout.DEFAULT_SIZE, 700, Short.MAX_VALUE));
+		jPanel3Layout.setVerticalGroup(jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+				.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
+						jPanel3Layout.createSequentialGroup().addContainerGap()
+								.addComponent(jScrollPaneGnuP, javax.swing.GroupLayout.PREFERRED_SIZE, 247,
+										javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+								.addGroup(jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+										.addComponent(jButtonAceptGnuP).addComponent(jButtonResetGnuP))));
+
+		jTabbedPane1.addTab("GnuPlot", jPanel3);
+
+		javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
+		this.setLayout(layout);
+		layout.setHorizontalGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+				.addGroup(layout.createSequentialGroup().addContainerGap()
+						.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+								.addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
+								.addComponent(jTabbedPane1, javax.swing.GroupLayout.Alignment.TRAILING))
+						.addContainerGap()));
+		layout.setVerticalGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGroup(
+				javax.swing.GroupLayout.Alignment.TRAILING,
+				layout.createSequentialGroup().addContainerGap()
+						.addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE,
+								javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
+						.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
+						.addComponent(jTabbedPane1, javax.swing.GroupLayout.PREFERRED_SIZE,
+								javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+						.addGap(7, 7, 7)));
+	}// </editor-fold>//GEN-END:initComponents
+
+	private void jButtonInPathActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_jButtonInPathActionPerformed
+		path = getDirectory("open", JFileChooser.DIRECTORIES_ONLY);
+		if (!path.equals("")) {
+			reset();
+			resetP();
+			this.jTextFieldResultPath.setText(path);
+			rf = new ReadFile(path);
+			String str = rf.processFiles();
+			if (str.equals("")) {
+
+				int algSize = rf.getAlgShortNames().size();
+				int streamSize = rf.getStream().size();
+				this.measures = rf.getMeasures();
+				for (int i = 0; i < algSize; i++) {
+					this.algoritmModel.addRow(new Object[] { rf.getAlgNames().get(i), rf.getAlgShortNames().get(i) });
+				}
+				for (int i = 0; i < streamSize; i++) {
+					this.streamModel.addRow(new Object[] { rf.getStream().get(i), rf.getStream().get(i) });
+				}
+
+				String measuresNames[] = measures.getFirst().split(",");
+				for (String measuresName : measuresNames) {
+					jComboBoxXColumn.addItem(measuresName);
+					jComboBoxYColumn.addItem(measuresName);
+					jComboBoxXColumnGnuP.addItem(measuresName);
+					jComboBoxYColumnGnuP.addItem(measuresName);
+					if (measuresName.equals("learning evaluation instances") == true) {
+						jComboBoxXColumn.setSelectedItem(measuresName);
+						jComboBoxXColumnGnuP.setSelectedItem(measuresName);
+					}
+					if (measuresName.equals("classifications correct (percent)") == true
+							|| measuresName.equals("[avg] classifications correct (percent)") == true) {
+						jComboBoxYColumn.setSelectedItem(measuresName);
+						jComboBoxYColumnGnuP.setSelectedItem(measuresName);
+					}
+
+				}
+			} else {
+
+				JOptionPane.showMessageDialog(this, str, "Error", JOptionPane.ERROR_MESSAGE);
+			}
+		}
+	}// GEN-LAST:event_jButtonInPathActionPerformed
+
+	private void jButtonDeletAlgorithmActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_jButtonDeletAlgorithmActionPerformed
+		if (this.jTableAlgoritms.getSelectedRow() != -1) {
+
+			this.algoritmModel.removeRow(this.jTableAlgoritms.getSelectedRow());
+			String algorithms[] = new String[algoritmModel.getRowCount()];
+			for (int i = 0; i < algoritmModel.getRowCount(); i++) {
+				algorithms[i] = algoritmModel.getValueAt(i, 0).toString();
+			}
+			if (streamModel.getValueAt(0, 0).toString() != null) {
+				String s = streamModel.getValueAt(0, 0).toString();
+				rf.updateMeasures(algorithms, s);
+				this.measures = rf.getMeasures();
+				String measuresNames[] = measures.getFirst().split(",");
+				jComboBoxXColumn.removeAllItems();
+				jComboBoxYColumn.removeAllItems();
+				jComboBoxXColumnGnuP.removeAllItems();
+				jComboBoxYColumnGnuP.removeAllItems();
+				for (String measuresName : measuresNames) {
+					jComboBoxXColumn.addItem(measuresName);
+					jComboBoxYColumn.addItem(measuresName);
+					jComboBoxXColumnGnuP.addItem(measuresName);
+					jComboBoxYColumnGnuP.addItem(measuresName);
+					if (measuresName.equals("learning evaluation instances") == true) {
+						jComboBoxXColumn.setSelectedItem(measuresName);
+						jComboBoxXColumnGnuP.setSelectedItem(measuresName);
+					}
+					if (measuresName.equals("classifications correct (percent)") == true
+							|| measuresName.equals("[avg] classifications correct (percent)")) {
+						jComboBoxYColumn.setSelectedItem(measuresName);
+						jComboBoxYColumnGnuP.setSelectedItem(measuresName);
+					}
+
+				}
+			}
+		}
+	}// GEN-LAST:event_jButtonDeletAlgorithmActionPerformed
+
+	private void jButtonDeleteStreamActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_jButtonDeleteStreamActionPerformed
+		this.streamModel.removeRow(this.jTableStreams.getSelectedRow());
+	}// GEN-LAST:event_jButtonDeleteStreamActionPerformed
+
+	private void jButtonAceptActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_jButtonAceptActionPerformed
+
+		int algCount = this.jTableAlgoritms.getRowCount();
+		int streamCount = this.jTableStreams.getRowCount();
+		chart = new ImageChart[streamCount];
+
+		for (int i = 0; i < streamCount; i++) {
+			String streamName = this.jTableStreams.getModel().getValueAt(i, 0).toString();
+			String streamID = this.jTableStreams.getModel().getValueAt(i, 1).toString();
+			XYSeriesCollection dataset = new XYSeriesCollection();
+			for (int j = 0; j < algCount; j++) {
+				try {
+					String algName = this.jTableAlgoritms.getModel().getValueAt(j, 0).toString();
+					String algID = this.jTableAlgoritms.getModel().getValueAt(j, 1).toString();
+					String algPath = FilenameUtils.separatorsToSystem(this.path + "\\" + streamName + "\\" + algName);
+					File inputFile = new File(algPath);
+					if (!inputFile.exists()) {
+						JOptionPane.showMessageDialog(this, "File not found: " + inputFile.getAbsolutePath(), "Error",
+								JOptionPane.ERROR_MESSAGE);
+						return;
+					}
+					/* Preparing the graph */
+					ArrayList<String[]> data = readCSV(algPath);
+					XYSeries series = new XYSeries(algID);
+					int x = ReadFile.getMeasureIndex(algPath, this.jComboBoxXColumn.getSelectedItem().toString());
+					int y = ReadFile.getMeasureIndex(algPath, this.jComboBoxYColumn.getSelectedItem().toString());
+
+					for (String[] s : data) {
+						series.add(Double.parseDouble(s[x]), Double.parseDouble(s[y]));
+					}
+
+					dataset.addSeries(series);
+
+				} catch (FileNotFoundException ex) {
+					Logger.getLogger(PlotTab.class.getName()).log(Level.SEVERE, null, ex);
+				} catch (IOException ex) {
+					Logger.getLogger(PlotTab.class.getName()).log(Level.SEVERE, null, ex);
+				}
+			} // end for
+			/* Create chart */
+			JFreeChart imgChart = ChartFactory.createXYLineChart(this.jTextFieldTitle.getText(), // Title
+					this.jTextFieldxTitle.getText(), // x-axis Label
+					this.jTextFieldyTitle.getText(), // y-axis Label
+					dataset, // Dataset
+					PlotOrientation.VERTICAL, // Plot Orientation
+					true, // Show Legend
+					true, // Use tooltips
+					false // Configure chart to generate URLs?
+			);
+			final XYPlot plot = imgChart.getXYPlot();
+			switch (this.jComboBoxGrid.getSelectedItem().toString()) {
+			case "White":
+				plot.setBackgroundPaint(Color.white);
+				break;
+			case "Default":
+				plot.setBackgroundPaint(Color.lightGray);
+			}
+			if (this.jCheckBoxShape.isSelected()) {
+				final XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer();
+				renderer.setSeriesLinesVisible(0, true);
+				renderer.setSeriesShapesVisible(1, false);
+				for (int k = 0; k < algCount; k++) {
+					renderer.setSeriesPaint(k, Color.black);
+				}
+				plot.setRenderer(renderer);
+			}
+
+			this.chart[i] = new ImageChart(streamID, imgChart, (int) this.jSpinnerWidth.getValue(),
+					(int) this.jSpinnerHeight.getValue());
+
+		}
+		this.imgPanel = new ImageTreePanel(chart);
+		new ImageViewer(imgPanel, path);
+
+	}// GEN-LAST:event_jButtonAceptActionPerformed
+
+	private void jButtonResetActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_jButtonResetActionPerformed
+		reset();
+	}// GEN-LAST:event_jButtonResetActionPerformed
+
+	private void jButtonAceptGnuPActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_jButtonAceptGnuPActionPerformed
+
+		if (!this.jTextFieldResultPath.getText().equals("")) {
+			String outPath = getDirectory("open", JFileChooser.DIRECTORIES_ONLY);
+			if (!outPath.equals("")) {
+
+				File resultFile = new File(this.jTextFieldResultPath.getText());
+				String resultDirectory = resultFile.getAbsolutePath();
+				String gnuPlotPath = this.jTextFieldGNUPath.getText();
+				String gnuplotScriptPath = null;
+				File gnuplotDir = new File(gnuPlotPath);
+				if (!gnuplotDir.exists()) {
+					JOptionPane.showMessageDialog(this, "Gnuplot directory not found: " + gnuPlotPath, "Error",
+							JOptionPane.ERROR_MESSAGE);
+					return;
+				}
+				String algShortName[] = new String[this.jTableAlgoritms.getRowCount()];
+				String algName[] = new String[this.jTableAlgoritms.getRowCount()];
+				for (int i = 0; i < this.jTableStreams.getRowCount(); i++) {
+					String streamName = this.jTableStreams.getModel().getValueAt(i, 0).toString();
+					String streamShortName = this.jTableStreams.getModel().getValueAt(i, 1).toString();
+					for (int j = 0; j < this.jTableAlgoritms.getRowCount(); j++) {
+						algName[j] = this.jTableAlgoritms.getModel().getValueAt(j, 0).toString();
+						algShortName[j] = this.jTableAlgoritms.getModel().getValueAt(j, 1).toString();
+						File inputFile = new File(
+								FilenameUtils.separatorsToSystem(this.path + "\\" + streamName + "\\" + algName[j]));
+
+						if (!inputFile.exists()) {
+							JOptionPane.showMessageDialog(this, "File not found: " + inputFile.getAbsolutePath(),
+									"Error", JOptionPane.ERROR_MESSAGE);
+							return;
+						}
+
+					}
+
+					gnuplotScriptPath = resultDirectory + File.separator + resultFile.getName() + ".plt";
+					String script = createScript(streamName, algName, algShortName, outPath);
+					File scriptFile = writeScriptToFile(gnuplotScriptPath, script);
+					String gnuplotCommand = gnuPlotPath + File.separator + "gnuplot \"" + gnuplotScriptPath + "\"";
+					String line, gnuplotOutput = "";
+					try {
+						Process p = Runtime.getRuntime().exec(gnuplotCommand);
+
+						BufferedReader err = new BufferedReader(new InputStreamReader(p.getErrorStream()));
+						while ((line = err.readLine()) != null) {
+							gnuplotOutput += line + System.getProperty("line.separator");
+						}
+						err.close();
+					} catch (IOException ex) {
+						JOptionPane.showMessageDialog(this, "Error while executing gnuplot script", "Error",
+								JOptionPane.ERROR_MESSAGE);
+						throw new RuntimeException("Error while executing gnuplot script:" + scriptFile, ex);
+
+					}
+					if (this.jCheckBoxDeleteScript.isSelected()) {
+						scriptFile.delete();
+					}
+				}
+
+				// Completed
+				JOptionPane.showMessageDialog(this,
+						"Figures created at " + (new File(resultFile.getAbsolutePath())).getParent(), "",
+						JOptionPane.INFORMATION_MESSAGE);
+			}
+		} else {
+			JOptionPane.showMessageDialog(this, "Plot output file option not set!", "Error", JOptionPane.ERROR_MESSAGE);
+		}
+
+	}// GEN-LAST:event_jButtonAceptGnuPActionPerformed
+
+	private void jButtonResetGnuPActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_jButtonResetGnuPActionPerformed
+		resetP();
+	}// GEN-LAST:event_jButtonResetGnuPActionPerformed
+
+	private void jButtonGnuoPathActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_jButtonGnuoPathActionPerformed
+		this.jTextFieldGNUPath.setText(getDirectory("open", JFileChooser.DIRECTORIES_ONLY));
+	}// GEN-LAST:event_jButtonGnuoPathActionPerformed
+
+	private void jComboBoxLegendLocationActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_jComboBoxLegendLocationActionPerformed
+		// TODO add your handling code here:
+	}// GEN-LAST:event_jComboBoxLegendLocationActionPerformed
+
+	private void jTextFieldGNUPathActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_jTextFieldGNUPathActionPerformed
+		// TODO add your handling code here:
+	}// GEN-LAST:event_jTextFieldGNUPathActionPerformed
+
+	/**
+	 * Allows to read the results file and update the corresponding fields.
+	 *
+	 * @param path
+	 */
+	public void readData(String path) {
+		reset();
+		resetP();
+		this.jTextFieldResultPath.setText(path);
+		this.path = path;
+		rf = new ReadFile(path);
+		String str = rf.processFiles();
+		if (str.equals("")) {
+
+			int algSize = rf.getAlgShortNames().size();
+			int streamSize = rf.getStream().size();
+			this.measures = rf.getMeasures();
+			for (int i = 0; i < algSize; i++) {
+				this.algoritmModel.addRow(new Object[] { rf.getAlgNames().get(i), rf.getAlgShortNames().get(i) });
+			}
+			for (int i = 0; i < streamSize; i++) {
+				this.streamModel.addRow(new Object[] { rf.getStream().get(i), rf.getStream().get(i) });
+			}
+			String measuresNames[] = measures.getFirst().split(",");
+			for (String measuresName : measuresNames) {
+				jComboBoxXColumn.addItem(measuresName);
+				jComboBoxYColumn.addItem(measuresName);
+				jComboBoxXColumnGnuP.addItem(measuresName);
+				jComboBoxYColumnGnuP.addItem(measuresName);
+				if (measuresName.equals("learning evaluation instances") == true) {
+					jComboBoxXColumn.setSelectedItem(measuresName);
+					jComboBoxXColumnGnuP.setSelectedItem(measuresName);
+				}
+				if (measuresName.equals("classifications correct (percent)") == true
+						|| measuresName.equals("[avg] classifications correct (percent)")) {
+					jComboBoxYColumn.setSelectedItem(measuresName);
+					jComboBoxYColumnGnuP.setSelectedItem(measuresName);
+				}
+
+			}
+		} else {
+
+			JOptionPane.showMessageDialog(this, str, "Error", JOptionPane.ERROR_MESSAGE);
+		}
+
+	}
+
+	private String getDirectory(String type, int filter) {
+		BaseDirectoryChooser gnuPlotDir = new BaseDirectoryChooser();
+		gnuPlotDir.setFileSelectionMode(filter);
+		int selection = -1;
+		if (type.equals("open"))
+			selection = gnuPlotDir.showOpenDialog(this);
+		if (selection == JFileChooser.APPROVE_OPTION) {
+
+			try {
+				return gnuPlotDir.getSelectedFile().getAbsolutePath();
+
+			} catch (Exception exp) {
+			}
+
+		}
+		return "";
+	}
+
+	/**
+	 * Clean the tables
+	 */
+	public void cleanTables() {
+		try {
+			DefaultTableModel algModel = (DefaultTableModel) jTableAlgoritms.getModel();
+			DefaultTableModel strModel = (DefaultTableModel) jTableStreams.getModel();
+			int rows = jTableAlgoritms.getRowCount();
+			int srow = jTableStreams.getRowCount();
+			for (int i = 0; i < rows; i++) {
+				algModel.removeRow(0);
+			}
+			for (int i = 0; i < srow; i++) {
+				strModel.removeRow(0);
+			}
+
+		} catch (Exception e) {
+			JOptionPane.showMessageDialog(null, "Error cleaning the table.");
+		}
+	}
+
+	private void reset() {
+		cleanTables();
+		this.jTextFieldResultPath.setText("");
+
+		this.jTextFieldxTitle.setText("Instances processed");
+
+		this.jTextFieldyTitle.setText("% of correctly classified");
+
+		// Combobox
+		this.jComboBoxXColumn.removeAllItems();
+		this.jComboBoxYColumn.removeAllItems();
+		// spinner
+		this.jSpinnerWidth.setValue(500);
+		this.jSpinnerHeight.setValue(300);
+
+		this.jCheckBoxShape.setSelected(false);
+		this.jComboBoxGrid.setSelectedItem("White");
+
+	}
+
+	private void resetP() {
+		cleanTables();
+		this.jTextFieldGNUPath.setText("");
+		this.jTextFieldResultPath.setText("");
+		this.jTextFieldAPOptions.setText("");
+		this.jTextFieldAdcComand.setText("");
+		this.jTextFieldxTitleGnuP.setText("Instances processed");
+		this.jTextFieldyTitleGnuP.setText("% of correctly classified");
+		// Combobox
+		this.jComboBoxLegendLocation.setSelectedIndex(0);
+
+		this.jComboBoxLegendType.setSelectedIndex(0);
+		this.jComboBoxLineStyle.setSelectedIndex(0);
+		this.jComboBoxOutPTypeGnuP.setSelectedIndex(0);
+		this.jComboBoxXColumnGnuP.removeAllItems();
+		this.jComboBoxYColumnGnuP.removeAllItems();
+		// spinner
+		this.jSpinnerLineWidth.setValue(2);
+		this.jSpinnerPlotInterval.setValue(0);
+
+	}
+
+	private String createScript(String streamName, String algName[], String algShortName[], String outPath) {
+		String newLine = System.getProperty("line.separator");
+		int sourceFileIdx = 0;
+
+		String imgName;
+		boolean eps = false;
+		switch (this.jComboBoxOutPTypeGnuP.getSelectedItem().toString()) {
+		case "GIF":
+			imgName = outPath + File.separator + streamName + "GP" + ".gif";
+			break;
+		case "JPEG":
+			imgName = outPath + File.separator + streamName + "GP" + ".JPEG";
+			break;
+		case "LATEX":
+			imgName = outPath + File.separator + streamName + "GP" + ".tex";
+			break;
+		case "PDFCAIRO":
+			imgName = outPath + File.separator + streamName + "GP" + ".pdf";
+			break;
+		case "PNG":
+			imgName = outPath + File.separator + streamName + "GP" + ".PNG";
+			break;
+		case "PSTEX":
+			imgName = outPath + File.separator + streamName + "GP" + ".tex";
+			break;
+		case "PSTRICKS":
+			imgName = outPath + File.separator + streamName + "GP" + ".tex";
+			break;
+		case "PSLATEX":
+			imgName = outPath + File.separator + streamName + "GP" + ".tex";
+			break;
+		case "SVG":
+			imgName = outPath + File.separator + streamName + "GP" + ".SVG";
+			break;
+		default:
+			imgName = outPath + File.separator + streamName + "GP" + ".eps";
+			eps = true;
+
+		}
+		// terminal options;
+		String script;
+		if (eps) {
+			script = "set term "
+					+ terminalOptions(Terminal.valueOf(this.jComboBoxOutPTypeGnuP.getSelectedItem().toString()))
+					+ " eps " + newLine;
+		} else {
+			script = "set term "
+					+ terminalOptions(Terminal.valueOf(this.jComboBoxOutPTypeGnuP.getSelectedItem().toString()))
+					+ newLine;
+		}
+		script += "set loadpath '" + FilenameUtils.separatorsToSystem(path + File.separator + streamName) + "'"
+				+ newLine;
+		script += "set output '" + imgName + "'" + newLine;
+		script += "set datafile separator ','" + newLine;
+		// script += "set grid" + newLine;
+		script += "set style line 1 pt 8" + newLine;
+		script += "set style line 2 lt rgb '#00C000'" + newLine;
+		script += "set style line 5 lt rgb '#FFD800'" + newLine;
+		script += "set style line 6 lt rgb '#4E0000'" + newLine;
 //        script += "set format x '%.0s %c" + getAxisUnit(this.jTextFieldxUnit.getText())
 //                + "'" + newLine;
 //        script += "set format y '%.1f" + getAxisUnit(this.jTextFieldyUnit.getText())
 //                + "'" + newLine;
-        script += "set ylabel '" + this.jTextFieldyTitleGnuP.getText() + "'" + newLine;
-        script += "set xlabel '" + this.jTextFieldxTitleGnuP.getText() + "'" + newLine;
-        if (!this.jComboBoxLegendType.getSelectedItem().toString().equals(LegendType.NONE)) {
-            script += "set key "
-                    + this.jComboBoxLegendType.getSelectedItem().toString().toLowerCase().replace(
-                            '_', ' ')
-                    + " "
-                    + this.jComboBoxLegendLocation.getSelectedItem().toString().toLowerCase()
-                    .replace('_', ' ') + newLine;
-        }
-
-        // additional commands
-        script += this.jTextFieldAdcComand.getText();
-
-        // plot command
-        script += "plot " + this.jTextFieldAPOptions.getText() + " ";
-
-        // plot for each input file
-        for (int i = 0; i < algName.length; i++) {
-
-            if (sourceFileIdx > 0) {
-                script += ", ";
-            }
-            sourceFileIdx++;
-            script += "'" + algName[i] + "' using "
-                    + (this.jComboBoxXColumnGnuP.getSelectedIndex() + 1) + ":" + (this.jComboBoxYColumnGnuP.getSelectedIndex() + 1);
-
-            if (this.jCheckBoxSmooth.isSelected()) {
-                script += ":(1.0) smooth bezier";
-            }
-
-            script += " with " + this.jComboBoxLineStyle.getSelectedItem().toString().toLowerCase()
-                    + " ls " + sourceFileIdx + " lw "
-                    + this.jSpinnerLineWidth.getValue().toString();
-            if (this.jComboBoxLineStyle.getSelectedItem().toString().equals(
-                    PlotStyle.LINESPOINTS.toString())
-                    && Integer.parseInt(this.jSpinnerPlotInterval.getValue().toString()) > 0) {
-                script += " pointinterval " + this.jSpinnerPlotInterval.getValue().toString();
-            }
-            script += " title '" + algShortName[i] + "'";
-        }
-        script += newLine;
-        return script;
-    }
-
-    private File writeScriptToFile(String gnuplotScriptPath, String script) {
-        File scriptFile = new File(gnuplotScriptPath);
-        BufferedWriter writer;
-        try {
-            writer = new BufferedWriter(new FileWriter(scriptFile));
-            writer.write(script);
-            writer.close();
-        } catch (IOException ex) {
-            throw new RuntimeException(
-                    "Unable to create or write to script file: " + scriptFile,
-                    ex);
-        }
-        return scriptFile;
-    }
-
-    private String terminalOptions(Terminal term) {
-        String options;
-
-        switch (term) {
-            case POSTSCRIPT:
-                options = "postscript enhanced";
-                break;
-            case POSTSCRIPT_COLOR:
-                options = "postscript color enhanced";
-                break;
-            default:
-                options = term.toString().toLowerCase();
-                break;
-        }
-        return options;
-    }
-
-    /**
-     * Lgend type
-     */
-    public enum LegendType {
-
-        NONE, BOX_VERTICAL, BOX_HORIZONTAL, NOBOX_VERTICAL, NOBOX_HORIZONTAL;
-    }
-
-    /**
-     * Plot style
-     */
-    public enum PlotStyle {
-
-        LINES, POINTS, LINESPOINTS, IMPULSES, STEPS, FSTEPS, HISTEPS, DOTS;
-
-    }
-
-    /**
-     * Terminal
-     */
-    public enum Terminal {
-
-        CANVAS, EPSLATEX, GIF, JPEG, LATEX, PDFCAIRO, PNG, POSTSCRIPT, POSTSCRIPT_COLOR, PSLATEX, PSTEX, PSTRICKS, SVG;
-
-    }
-
-    private static void createAndShowGUI() {
-
-        // Create and set up the window.
-        JFrame frame = new JFrame("Test");
-        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-
-        // Create and set up the content pane.
-        JPanel panel = new PlotTab();
-        panel.setOpaque(true); // content panes must be opaque
-        frame.setContentPane(panel);
-
-        // Display the window.
-        frame.pack();
-        //frame.setSize(400, 400);
-        frame.setVisible(true);
-    }
-
-    /**
-     * @param args the command line arguments
-     */
-    public static void main(String[] args) {
-        try {
-            LookAndFeel.install();
-            javax.swing.SwingUtilities.invokeLater(new Runnable() {
-
-                @Override
-                public void run() {
-                    createAndShowGUI();
-                }
-            });
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-    // Variables declaration - do not modify//GEN-BEGIN:variables
-    private javax.swing.JButton jButtonAcept;
-    private javax.swing.JButton jButtonAceptGnuP;
-    private javax.swing.JButton jButtonDeletAlgorithm;
-    private javax.swing.JButton jButtonDeleteStream;
-    private javax.swing.JButton jButtonGnuoPath;
-    private javax.swing.JButton jButtonInPath;
-    private javax.swing.JButton jButtonReset;
-    private javax.swing.JButton jButtonResetGnuP;
-    private javax.swing.JCheckBox jCheckBoxDeleteScript;
-    private javax.swing.JCheckBox jCheckBoxShape;
-    private javax.swing.JCheckBox jCheckBoxSmooth;
-    private javax.swing.JComboBox jComboBoxGrid;
-    private javax.swing.JComboBox jComboBoxLegendLocation;
-    private javax.swing.JComboBox jComboBoxLegendType;
-    private javax.swing.JComboBox jComboBoxLineStyle;
-    private javax.swing.JComboBox jComboBoxOutPTypeGnuP;
-    private javax.swing.JComboBox jComboBoxXColumn;
-    private javax.swing.JComboBox jComboBoxXColumnGnuP;
-    private javax.swing.JComboBox jComboBoxYColumn;
-    private javax.swing.JComboBox jComboBoxYColumnGnuP;
-    private javax.swing.JLabel jLabel1;
-    private javax.swing.JLabel jLabel10;
-    private javax.swing.JLabel jLabel11;
-    private javax.swing.JLabel jLabel13;
-    private javax.swing.JLabel jLabel14;
-    private javax.swing.JLabel jLabel15;
-    private javax.swing.JLabel jLabel16;
-    private javax.swing.JLabel jLabel17;
-    private javax.swing.JLabel jLabel18;
-    private javax.swing.JLabel jLabel19;
-    private javax.swing.JLabel jLabel2;
-    private javax.swing.JLabel jLabel20;
-    private javax.swing.JLabel jLabel21;
-    private javax.swing.JLabel jLabel22;
-    private javax.swing.JLabel jLabel23;
-    private javax.swing.JLabel jLabel24;
-    private javax.swing.JLabel jLabel25;
-    private javax.swing.JLabel jLabel26;
-    private javax.swing.JLabel jLabel27;
-    private javax.swing.JLabel jLabel3;
-    private javax.swing.JLabel jLabel5;
-    private javax.swing.JLabel jLabel6;
-    private javax.swing.JLabel jLabel7;
-    private javax.swing.JLabel jLabel8;
-    private javax.swing.JPanel jPanel1;
-    private javax.swing.JPanel jPanel2;
-    private javax.swing.JPanel jPanel3;
-    private javax.swing.JPanel jPanel4;
-    private javax.swing.JPanel jPanelGnuP;
-    private javax.swing.JScrollPane jScrollPane1;
-    private javax.swing.JScrollPane jScrollPane3;
-    private javax.swing.JScrollPane jScrollPaneAlgorithms;
-    private javax.swing.JScrollPane jScrollPaneGnuP;
-    private javax.swing.JSpinner jSpinnerHeight;
-    private javax.swing.JSpinner jSpinnerLineWidth;
-    private javax.swing.JSpinner jSpinnerPlotInterval;
-    private javax.swing.JSpinner jSpinnerWidth;
-    private javax.swing.JTabbedPane jTabbedPane1;
-    private javax.swing.JTable jTableAlgoritms;
-    private javax.swing.JTable jTableStreams;
-    private javax.swing.JTextField jTextFieldAPOptions;
-    private javax.swing.JTextField jTextFieldAdcComand;
-    private javax.swing.JTextField jTextFieldGNUPath;
-    private javax.swing.JTextField jTextFieldResultPath;
-    private javax.swing.JTextField jTextFieldTitle;
-    private javax.swing.JTextField jTextFieldxTitle;
-    private javax.swing.JTextField jTextFieldxTitleGnuP;
-    private javax.swing.JTextField jTextFieldyTitle;
-    private javax.swing.JTextField jTextFieldyTitleGnuP;
-    // End of variables declaration//GEN-END:variables
+		script += "set ylabel '" + this.jTextFieldyTitleGnuP.getText() + "'" + newLine;
+		script += "set xlabel '" + this.jTextFieldxTitleGnuP.getText() + "'" + newLine;
+		if (!this.jComboBoxLegendType.getSelectedItem().toString().equals(LegendType.NONE)) {
+			script += "set key " + this.jComboBoxLegendType.getSelectedItem().toString().toLowerCase().replace('_', ' ')
+					+ " " + this.jComboBoxLegendLocation.getSelectedItem().toString().toLowerCase().replace('_', ' ')
+					+ newLine;
+		}
+
+		// additional commands
+		script += this.jTextFieldAdcComand.getText();
+
+		// plot command
+		script += "plot " + this.jTextFieldAPOptions.getText() + " ";
+
+		// plot for each input file
+		for (int i = 0; i < algName.length; i++) {
+
+			if (sourceFileIdx > 0) {
+				script += ", ";
+			}
+			sourceFileIdx++;
+			script += "'" + algName[i] + "' using " + (this.jComboBoxXColumnGnuP.getSelectedIndex() + 1) + ":"
+					+ (this.jComboBoxYColumnGnuP.getSelectedIndex() + 1);
+
+			if (this.jCheckBoxSmooth.isSelected()) {
+				script += ":(1.0) smooth bezier";
+			}
+
+			script += " with " + this.jComboBoxLineStyle.getSelectedItem().toString().toLowerCase() + " ls "
+					+ sourceFileIdx + " lw " + this.jSpinnerLineWidth.getValue().toString();
+			if (this.jComboBoxLineStyle.getSelectedItem().toString().equals(PlotStyle.LINESPOINTS.toString())
+					&& Integer.parseInt(this.jSpinnerPlotInterval.getValue().toString()) > 0) {
+				script += " pointinterval " + this.jSpinnerPlotInterval.getValue().toString();
+			}
+			script += " title '" + algShortName[i] + "'";
+		}
+		script += newLine;
+		return script;
+	}
+
+	private File writeScriptToFile(String gnuplotScriptPath, String script) {
+		File scriptFile = new File(gnuplotScriptPath);
+		BufferedWriter writer;
+		try {
+			writer = new BufferedWriter(new FileWriter(scriptFile));
+			writer.write(script);
+			writer.close();
+		} catch (IOException ex) {
+			throw new RuntimeException("Unable to create or write to script file: " + scriptFile, ex);
+		}
+		return scriptFile;
+	}
+
+	private String terminalOptions(Terminal term) {
+		String options;
+
+		switch (term) {
+		case POSTSCRIPT:
+			options = "postscript enhanced";
+			break;
+		case POSTSCRIPT_COLOR:
+			options = "postscript color enhanced";
+			break;
+		default:
+			options = term.toString().toLowerCase();
+			break;
+		}
+		return options;
+	}
+
+	/**
+	 * Lgend type
+	 */
+	public enum LegendType {
+
+		NONE, BOX_VERTICAL, BOX_HORIZONTAL, NOBOX_VERTICAL, NOBOX_HORIZONTAL;
+	}
+
+	/**
+	 * Plot style
+	 */
+	public enum PlotStyle {
+
+		LINES, POINTS, LINESPOINTS, IMPULSES, STEPS, FSTEPS, HISTEPS, DOTS;
+
+	}
+
+	/**
+	 * Terminal
+	 */
+	public enum Terminal {
+
+		CANVAS, EPSLATEX, GIF, JPEG, LATEX, PDFCAIRO, PNG, POSTSCRIPT, POSTSCRIPT_COLOR, PSLATEX, PSTEX, PSTRICKS, SVG;
+
+	}
+
+	private static void createAndShowGUI() {
+
+		// Create and set up the window.
+		JFrame frame = new JFrame("Test");
+		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+
+		// Create and set up the content pane.
+		JPanel panel = new PlotTab();
+		panel.setOpaque(true); // content panes must be opaque
+		frame.setContentPane(panel);
+
+		// Display the window.
+		frame.pack();
+		// frame.setSize(400, 400);
+		frame.setVisible(true);
+	}
+
+	/**
+	 * @param args the command line arguments
+	 */
+	public static void main(String[] args) {
+		try {
+			LookAndFeel.install();
+			javax.swing.SwingUtilities.invokeLater(new Runnable() {
+
+				@Override
+				public void run() {
+					createAndShowGUI();
+				}
+			});
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	// Variables declaration - do not modify//GEN-BEGIN:variables
+	private javax.swing.JButton jButtonAcept;
+	private javax.swing.JButton jButtonAceptGnuP;
+	private javax.swing.JButton jButtonDeletAlgorithm;
+	private javax.swing.JButton jButtonDeleteStream;
+	private javax.swing.JButton jButtonGnuoPath;
+	private javax.swing.JButton jButtonInPath;
+	private javax.swing.JButton jButtonReset;
+	private javax.swing.JButton jButtonResetGnuP;
+	private javax.swing.JCheckBox jCheckBoxDeleteScript;
+	private javax.swing.JCheckBox jCheckBoxShape;
+	private javax.swing.JCheckBox jCheckBoxSmooth;
+	private javax.swing.JComboBox jComboBoxGrid;
+	private javax.swing.JComboBox jComboBoxLegendLocation;
+	private javax.swing.JComboBox jComboBoxLegendType;
+	private javax.swing.JComboBox jComboBoxLineStyle;
+	private javax.swing.JComboBox jComboBoxOutPTypeGnuP;
+	private javax.swing.JComboBox jComboBoxXColumn;
+	private javax.swing.JComboBox jComboBoxXColumnGnuP;
+	private javax.swing.JComboBox jComboBoxYColumn;
+	private javax.swing.JComboBox jComboBoxYColumnGnuP;
+	private javax.swing.JLabel jLabel1;
+	private javax.swing.JLabel jLabel10;
+	private javax.swing.JLabel jLabel11;
+	private javax.swing.JLabel jLabel13;
+	private javax.swing.JLabel jLabel14;
+	private javax.swing.JLabel jLabel15;
+	private javax.swing.JLabel jLabel16;
+	private javax.swing.JLabel jLabel17;
+	private javax.swing.JLabel jLabel18;
+	private javax.swing.JLabel jLabel19;
+	private javax.swing.JLabel jLabel2;
+	private javax.swing.JLabel jLabel20;
+	private javax.swing.JLabel jLabel21;
+	private javax.swing.JLabel jLabel22;
+	private javax.swing.JLabel jLabel23;
+	private javax.swing.JLabel jLabel24;
+	private javax.swing.JLabel jLabel25;
+	private javax.swing.JLabel jLabel26;
+	private javax.swing.JLabel jLabel27;
+	private javax.swing.JLabel jLabel3;
+	private javax.swing.JLabel jLabel5;
+	private javax.swing.JLabel jLabel6;
+	private javax.swing.JLabel jLabel7;
+	private javax.swing.JLabel jLabel8;
+	private javax.swing.JPanel jPanel1;
+	private javax.swing.JPanel jPanel2;
+	private javax.swing.JPanel jPanel3;
+	private javax.swing.JPanel jPanel4;
+	private javax.swing.JPanel jPanelGnuP;
+	private javax.swing.JScrollPane jScrollPane1;
+	private javax.swing.JScrollPane jScrollPane3;
+	private javax.swing.JScrollPane jScrollPaneAlgorithms;
+	private javax.swing.JScrollPane jScrollPaneGnuP;
+	private javax.swing.JSpinner jSpinnerHeight;
+	private javax.swing.JSpinner jSpinnerLineWidth;
+	private javax.swing.JSpinner jSpinnerPlotInterval;
+	private javax.swing.JSpinner jSpinnerWidth;
+	private javax.swing.JTabbedPane jTabbedPane1;
+	private javax.swing.JTable jTableAlgoritms;
+	private javax.swing.JTable jTableStreams;
+	private javax.swing.JTextField jTextFieldAPOptions;
+	private javax.swing.JTextField jTextFieldAdcComand;
+	private javax.swing.JTextField jTextFieldGNUPath;
+	private javax.swing.JTextField jTextFieldResultPath;
+	private javax.swing.JTextField jTextFieldTitle;
+	private javax.swing.JTextField jTextFieldxTitle;
+	private javax.swing.JTextField jTextFieldxTitleGnuP;
+	private javax.swing.JTextField jTextFieldyTitle;
+	private javax.swing.JTextField jTextFieldyTitleGnuP;
+	// End of variables declaration//GEN-END:variables
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/PreviewExperiments.java b/moa/src/main/java/moa/gui/experimentertab/PreviewExperiments.java
index cfde286bb..bbcae711f 100644
--- a/moa/src/main/java/moa/gui/experimentertab/PreviewExperiments.java
+++ b/moa/src/main/java/moa/gui/experimentertab/PreviewExperiments.java
@@ -6,35 +6,33 @@
 package moa.gui.experimentertab;
 
 import javax.swing.JFrame;
+import javax.swing.WindowConstants;
 
 /**
  *
  * @author Alberto
  */
-public class PreviewExperiments extends JFrame{
-
-    private ExpPreviewPanel previewPanel;
-
-    public PreviewExperiments(ExpPreviewPanel previewPanel) {
-        this.previewPanel = previewPanel;
-        
-        setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
-        
-        setContentPane(this.previewPanel);
-
-        // Display the window.
-        pack();
-        setSize(700, 500);
-       
-    }
-
-    @Override
-    public void setVisible(boolean b) {
-        super.setVisible(b); //To change body of generated methods, choose Tools | Templates.
-        this.repaint();
-    }
-    
-    
-    
-       
+public class PreviewExperiments extends JFrame {
+
+	private ExpPreviewPanel previewPanel;
+
+	public PreviewExperiments(ExpPreviewPanel previewPanel) {
+		this.previewPanel = previewPanel;
+
+		setDefaultCloseOperation(WindowConstants.HIDE_ON_CLOSE);
+
+		setContentPane(this.previewPanel);
+
+		// Display the window.
+		pack();
+		setSize(700, 500);
+
+	}
+
+	@Override
+	public void setVisible(boolean b) {
+		super.setVisible(b); // To change body of generated methods, choose Tools | Templates.
+		this.repaint();
+	}
+
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/RankingGraph.java b/moa/src/main/java/moa/gui/experimentertab/RankingGraph.java
index 780acacba..75151bc61 100644
--- a/moa/src/main/java/moa/gui/experimentertab/RankingGraph.java
+++ b/moa/src/main/java/moa/gui/experimentertab/RankingGraph.java
@@ -1,6 +1,6 @@
 /*
  *    RankingGraph.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand 
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
  *    @author Alberto Verdecia Cabrera (averdeciac@gmail.com)
  *
  *    This program is free software; you can redistribute it and/or modify
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab;
 
@@ -41,12 +41,9 @@
 import java.awt.geom.Line2D;
 import java.awt.image.BufferedImage;
 import java.io.File;
-import java.io.FileWriter;
 import java.io.IOException;
-import java.io.Writer;
 import java.util.ArrayList;
-import java.util.logging.Level;
-import java.util.logging.Logger;
+
 import javax.imageio.ImageIO;
 import javax.swing.BorderFactory;
 import javax.swing.JButton;
@@ -55,14 +52,17 @@
 import javax.swing.JOptionPane;
 import javax.swing.JPanel;
 import javax.swing.JSlider;
+import javax.swing.SwingConstants;
 import javax.swing.border.TitledBorder;
 import javax.swing.event.ChangeEvent;
-import moa.gui.experimentertab.statisticaltests.PValuePerTwoAlgorithm;
-import moa.gui.experimentertab.statisticaltests.RankPerAlgorithm;
-import nz.ac.waikato.cms.gui.core.BaseFileChooser;
+
 import org.jfree.ui.FontChooserPanel;
 import org.jfree.ui.StrokeChooserPanel;
 import org.jfree.ui.StrokeSample;
+
+import moa.gui.experimentertab.statisticaltests.PValuePerTwoAlgorithm;
+import moa.gui.experimentertab.statisticaltests.RankPerAlgorithm;
+import nz.ac.waikato.cms.gui.core.BaseFileChooser;
 import weka.gui.ExtensionFileFilter;
 
 /**
@@ -72,203 +72,190 @@
  * @author Alberto Verdecia Cabrera (averdeciac@gmail.com)
  */
 public class RankingGraph extends JFrame {
-    
-    JPanel zoomPanel;
-    JPanel graphPanel;
-    JPanel graphPanelDisplay = new JPanel();
-    JPanel controlPanelDisplay = new JPanel();
-    JPanel controlPanel;
-    JPanel imgOptionsPanel;
-    JPanel exportPanel;
-    JButton btnSave, btnLineStroke, btnFont, btnLineDifStronke, btnDir;
-    //JComboBox imgType;
-    //JTextField JtextFieldimgName;
-    JSlider xSlider, ySlider;
-    int height, width;
-    int x0, y0;
-    int xScale, yScale;
-    double pvalue;
-    
-    Font textFont = new Font("Arial", Font.PLAIN, 14);
-    ArrayList<RankPerAlgorithm> algRank;
-    ArrayList<PValuePerTwoAlgorithm> PValues;
-    final static BasicStroke currentStroke = new BasicStroke(1.0f);
-    final static float dash1[] = {1.5f};
-    final static BasicStroke dashed = new BasicStroke(1.5f,
-            BasicStroke.CAP_BUTT,
-            BasicStroke.JOIN_MITER,
-            10.0f, dash1, 0.0f);
-    private StrokeSample[] availableStrokeSamples;
-    private StrokeSample stroke = new StrokeSample(currentStroke);
-    private StrokeSample difStroke = new StrokeSample(new BasicStroke(3.0f));
-
-    public BufferedImage image;
-    public Graphics2D gb;
-    public String imgPath;
-
-    /**
-     * Class constructor.
-     *
-     * @param algRank
-     * @param PValues
-     * @param imgPath
-     * @param pvalue
-     */
-    public RankingGraph(ArrayList<RankPerAlgorithm> algRank, ArrayList<PValuePerTwoAlgorithm> PValues, String imgPath, double pvalue) {
-        super("Ranking Viewer");
-        this.algRank = algRank;
-        this.PValues = PValues;
-        this.imgPath = imgPath;
-        this.pvalue = pvalue;
-        setSize(800, 640);
-        initComponents();
-        setDefaultCloseOperation(HIDE_ON_CLOSE);
-        setVisible(true);
-    }
-    
-    private void initComponents() {
-        Container container = getContentPane();
-        width = getSize().width - 10;
-        height = 70 * getSize().height / 100;
-        graphPanel = new Graph();
-        zoomPanel = new SliderPanel();
-        controlPanel = new JPanel();
-        imgOptionsPanel = new JPanel();
-        exportPanel = new JPanel();
-        btnSave = new JButton("Save");
-        btnLineStroke = new JButton("Line 1 Stroke");
-        btnFont = new JButton("Text Font");
-        btnLineDifStronke = new JButton("Line 2 Stroke");
-        btnDir = new JButton("Save as");
-      
-        graphPanelDisplay.setLayout(new BorderLayout());
-        graphPanelDisplay.add(graphPanel, BorderLayout.CENTER);
-        TitledBorder titleborder;
-        titleborder = BorderFactory.createTitledBorder(" Zoom");
-        zoomPanel.setBorder(titleborder);
-        //titleborder = BorderFactory.createTitledBorder("Options");
-        //controlPanel.setBorder(titleborder);
-        
-        titleborder = BorderFactory.createTitledBorder("Properties");
-        imgOptionsPanel.setBorder(titleborder);
-        
-        titleborder = BorderFactory.createTitledBorder("Export");
-        exportPanel.setBorder(titleborder);
-        
-        graphPanelDisplay.setPreferredSize(new Dimension(width, height));
-        controlPanel.setPreferredSize(new Dimension(60 * width / 100,
-                20 * getSize().height / 100));
-        zoomPanel.setPreferredSize(new Dimension(30 * width / 100,
-                20 * getSize().height / 100));
-        
-        EventControl evt = new EventControl();
-        btnFont.addActionListener(evt);
-        btnLineDifStronke.addActionListener(evt);
-        btnLineStroke.addActionListener(evt);
-        btnSave.addActionListener(evt);
-        btnDir.addActionListener(evt);
-        imgOptionsPanel.add(btnFont);
-        imgOptionsPanel.add(btnLineStroke);
-        imgOptionsPanel.add(btnLineDifStronke);
-        
-        exportPanel.setLayout(new BorderLayout());
-        JPanel panel = new JPanel();
-        //panel.add(new JLabel("Export as "));
-       // panel.add(imgType);
-       // panel.add(btnSave);
-        
-        JPanel panelName = new JPanel();
-        //panelName.add(new JLabel("File name "));
-       // panelName.add(JtextFieldimgName);
-        panelName.add(btnDir);
-        exportPanel.add(panelName, BorderLayout.CENTER);
-        exportPanel.add(panel, BorderLayout.SOUTH);
-        
-        controlPanel.setLayout(new BorderLayout());
-        controlPanel.add(imgOptionsPanel, BorderLayout.CENTER);
-        controlPanel.add(exportPanel, BorderLayout.EAST);
-        controlPanelDisplay.setLayout(new BorderLayout(1, 1));
-        controlPanelDisplay.add(controlPanel, BorderLayout.CENTER);
-        controlPanelDisplay.add(zoomPanel, BorderLayout.EAST);
-        container.setLayout(new BorderLayout(1, 1));
-        container.add("Center", graphPanelDisplay);
-        container.add("South", controlPanelDisplay);
-        xScale = 20;
-        yScale = 20;
-        x0 = width / 2;
-        y0 = height / 5;
-        this.availableStrokeSamples = new StrokeSample[4];
-        this.availableStrokeSamples[0] = new StrokeSample(new BasicStroke(1.5f,
-                BasicStroke.CAP_BUTT,
-                BasicStroke.JOIN_MITER,
-                10.0f, dash1, 0.0f));
-        this.availableStrokeSamples[1] = new StrokeSample(
-                new BasicStroke(1.0f));
-        this.availableStrokeSamples[2] = new StrokeSample(
-                new BasicStroke(2.0f));
-        this.availableStrokeSamples[3] = new StrokeSample(
-                new BasicStroke(3.0f));
-        
-        addWindowStateListener((WindowEvent arg0) -> {
-            width = getSize().width - 10;
-            height = 70 * getSize().height / 100;
-            x0 = width / 2;
-            y0 = height / 5;
-            xScale = 20;
-            yScale = 20;
-            xSlider.setValue(50);
-            ySlider.setValue(20);
-        });
-        
-    }
-    
-    private void strokeSelection(StrokeSample str) {
-        StrokeChooserPanel panel = new StrokeChooserPanel(
-                str, availableStrokeSamples);
-        int result = JOptionPane.showConfirmDialog(this, panel,
-                "Stroke Selection",
-                JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE);
-        
-        if (result == JOptionPane.OK_OPTION) {
-            str.setStroke(panel.getSelectedStroke());
-            
-        }
-        
-    }
-
-    /**
-     * Allow to select the text font.
-     */
-    public void fontSelection() {
-        
-        FontChooserPanel panel = new FontChooserPanel(textFont);
-        int result
-                = JOptionPane.showConfirmDialog(
-                        this, panel, "Font Selection",
-                        JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE
-                );
-        
-        if (result == JOptionPane.OK_OPTION) {
-            textFont = panel.getSelectedFont();
-            
-        }
-    }
-    
-    private class EventControl implements ActionListener {
-        
-        @Override
-        public void actionPerformed(ActionEvent evt) {
-            Object source = evt.getSource();
-            
-            if (source == btnSave) {
-                
-            } else if (source == btnFont) {
-                fontSelection();
-            } else if (source == btnLineStroke) {
-                strokeSelection(stroke);
-            } else if (source == btnLineDifStronke) {
-                strokeSelection(difStroke);
-            } else if (source == btnDir) {
+
+	JPanel zoomPanel;
+	JPanel graphPanel;
+	JPanel graphPanelDisplay = new JPanel();
+	JPanel controlPanelDisplay = new JPanel();
+	JPanel controlPanel;
+	JPanel imgOptionsPanel;
+	JPanel exportPanel;
+	JButton btnSave, btnLineStroke, btnFont, btnLineDifStronke, btnDir;
+	// JComboBox imgType;
+	// JTextField JtextFieldimgName;
+	JSlider xSlider, ySlider;
+	int height, width;
+	int x0, y0;
+	int xScale, yScale;
+	double pvalue;
+
+	Font textFont = new Font("Arial", Font.PLAIN, 14);
+	ArrayList<RankPerAlgorithm> algRank;
+	ArrayList<PValuePerTwoAlgorithm> PValues;
+	final static BasicStroke currentStroke = new BasicStroke(1.0f);
+	final static float dash1[] = { 1.5f };
+	final static BasicStroke dashed = new BasicStroke(1.5f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 10.0f, dash1,
+			0.0f);
+	private StrokeSample[] availableStrokeSamples;
+	private StrokeSample stroke = new StrokeSample(currentStroke);
+	private StrokeSample difStroke = new StrokeSample(new BasicStroke(3.0f));
+
+	public BufferedImage image;
+	public Graphics2D gb;
+	public String imgPath;
+
+	/**
+	 * Class constructor.
+	 *
+	 * @param algRank
+	 * @param PValues
+	 * @param imgPath
+	 * @param pvalue
+	 */
+	public RankingGraph(ArrayList<RankPerAlgorithm> algRank, ArrayList<PValuePerTwoAlgorithm> PValues, String imgPath,
+			double pvalue) {
+		super("Ranking Viewer");
+		this.algRank = algRank;
+		this.PValues = PValues;
+		this.imgPath = imgPath;
+		this.pvalue = pvalue;
+		setSize(800, 640);
+		initComponents();
+		setDefaultCloseOperation(HIDE_ON_CLOSE);
+		setVisible(true);
+	}
+
+	private void initComponents() {
+		Container container = getContentPane();
+		width = getSize().width - 10;
+		height = 70 * getSize().height / 100;
+		graphPanel = new Graph();
+		zoomPanel = new SliderPanel();
+		controlPanel = new JPanel();
+		imgOptionsPanel = new JPanel();
+		exportPanel = new JPanel();
+		btnSave = new JButton("Save");
+		btnLineStroke = new JButton("Line 1 Stroke");
+		btnFont = new JButton("Text Font");
+		btnLineDifStronke = new JButton("Line 2 Stroke");
+		btnDir = new JButton("Save as");
+
+		graphPanelDisplay.setLayout(new BorderLayout());
+		graphPanelDisplay.add(graphPanel, BorderLayout.CENTER);
+		TitledBorder titleborder;
+		titleborder = BorderFactory.createTitledBorder(" Zoom");
+		zoomPanel.setBorder(titleborder);
+		// titleborder = BorderFactory.createTitledBorder("Options");
+		// controlPanel.setBorder(titleborder);
+
+		titleborder = BorderFactory.createTitledBorder("Properties");
+		imgOptionsPanel.setBorder(titleborder);
+
+		titleborder = BorderFactory.createTitledBorder("Export");
+		exportPanel.setBorder(titleborder);
+
+		graphPanelDisplay.setPreferredSize(new Dimension(width, height));
+		controlPanel.setPreferredSize(new Dimension(60 * width / 100, 20 * getSize().height / 100));
+		zoomPanel.setPreferredSize(new Dimension(30 * width / 100, 20 * getSize().height / 100));
+
+		EventControl evt = new EventControl();
+		btnFont.addActionListener(evt);
+		btnLineDifStronke.addActionListener(evt);
+		btnLineStroke.addActionListener(evt);
+		btnSave.addActionListener(evt);
+		btnDir.addActionListener(evt);
+		imgOptionsPanel.add(btnFont);
+		imgOptionsPanel.add(btnLineStroke);
+		imgOptionsPanel.add(btnLineDifStronke);
+
+		exportPanel.setLayout(new BorderLayout());
+		JPanel panel = new JPanel();
+		// panel.add(new JLabel("Export as "));
+		// panel.add(imgType);
+		// panel.add(btnSave);
+
+		JPanel panelName = new JPanel();
+		// panelName.add(new JLabel("File name "));
+		// panelName.add(JtextFieldimgName);
+		panelName.add(btnDir);
+		exportPanel.add(panelName, BorderLayout.CENTER);
+		exportPanel.add(panel, BorderLayout.SOUTH);
+
+		controlPanel.setLayout(new BorderLayout());
+		controlPanel.add(imgOptionsPanel, BorderLayout.CENTER);
+		controlPanel.add(exportPanel, BorderLayout.EAST);
+		controlPanelDisplay.setLayout(new BorderLayout(1, 1));
+		controlPanelDisplay.add(controlPanel, BorderLayout.CENTER);
+		controlPanelDisplay.add(zoomPanel, BorderLayout.EAST);
+		container.setLayout(new BorderLayout(1, 1));
+		container.add("Center", graphPanelDisplay);
+		container.add("South", controlPanelDisplay);
+		xScale = 20;
+		yScale = 20;
+		x0 = width / 2;
+		y0 = height / 5;
+		this.availableStrokeSamples = new StrokeSample[4];
+		this.availableStrokeSamples[0] = new StrokeSample(
+				new BasicStroke(1.5f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 10.0f, dash1, 0.0f));
+		this.availableStrokeSamples[1] = new StrokeSample(new BasicStroke(1.0f));
+		this.availableStrokeSamples[2] = new StrokeSample(new BasicStroke(2.0f));
+		this.availableStrokeSamples[3] = new StrokeSample(new BasicStroke(3.0f));
+
+		addWindowStateListener((WindowEvent arg0) -> {
+			width = getSize().width - 10;
+			height = 70 * getSize().height / 100;
+			x0 = width / 2;
+			y0 = height / 5;
+			xScale = 20;
+			yScale = 20;
+			xSlider.setValue(50);
+			ySlider.setValue(20);
+		});
+
+	}
+
+	private void strokeSelection(StrokeSample str) {
+		StrokeChooserPanel panel = new StrokeChooserPanel(str, availableStrokeSamples);
+		int result = JOptionPane.showConfirmDialog(this, panel, "Stroke Selection", JOptionPane.OK_CANCEL_OPTION,
+				JOptionPane.PLAIN_MESSAGE);
+
+		if (result == JOptionPane.OK_OPTION) {
+			str.setStroke(panel.getSelectedStroke());
+
+		}
+
+	}
+
+	/**
+	 * Allow to select the text font.
+	 */
+	public void fontSelection() {
+
+		FontChooserPanel panel = new FontChooserPanel(textFont);
+		int result = JOptionPane.showConfirmDialog(this, panel, "Font Selection", JOptionPane.OK_CANCEL_OPTION,
+				JOptionPane.PLAIN_MESSAGE);
+
+		if (result == JOptionPane.OK_OPTION) {
+			textFont = panel.getSelectedFont();
+
+		}
+	}
+
+	private class EventControl implements ActionListener {
+
+		@Override
+		public void actionPerformed(ActionEvent evt) {
+			Object source = evt.getSource();
+
+			if (source == btnSave) {
+
+			} else if (source == btnFont) {
+				fontSelection();
+			} else if (source == btnLineStroke) {
+				strokeSelection(stroke);
+			} else if (source == btnLineDifStronke) {
+				strokeSelection(difStroke);
+			} else if (source == btnDir) {
 //                String path = "";
 //                JFileChooser propDir = new JFileChooser();
 //                int selection = propDir.showSaveDialog(JtextFieldimgName);
@@ -277,292 +264,295 @@ public void actionPerformed(ActionEvent evt) {
 //                }
 //                if (!path.equals("")) {
 //                    JtextFieldimgName.setText(path);
-//                    
+//
 //                }
-              
-                BaseFileChooser fileChooser = new BaseFileChooser();
-                ExtensionFileFilter filterPNG = new ExtensionFileFilter(".png","PNG Image Files");
-                fileChooser.addChoosableFileFilter(filterPNG);
-
-                ExtensionFileFilter filterJPG = new ExtensionFileFilter(".jpg","JPG Image Files");
-                fileChooser.addChoosableFileFilter(filterJPG);
-
-                ExtensionFileFilter filterEPS = new ExtensionFileFilter(".eps","EPS Image Files");
-                fileChooser.addChoosableFileFilter(filterEPS);
-                
-	
-                fileChooser. setAcceptAllFileFilterUsed(false); 
-                fileChooser.setCurrentDirectory(new File(imgPath));
-                int option = fileChooser.showSaveDialog(null);
-                if (option == JFileChooser.APPROVE_OPTION) { 
-                 String fileDesc = fileChooser.getFileFilter().getDescription();
-           
-                if (fileDesc.startsWith("PNG")) {
-                    
-                    if (fileChooser.getSelectedFile().getName().toUpperCase().endsWith("PNG")==true) {
-                        try {
-                                ImageIO.write(image, "png",fileChooser.getSelectedFile());
-                            } catch (IOException e) {
-                                e.printStackTrace();
-                            }
-                    } else {
-                       try {
-                                ImageIO.write(image, "png", new File(fileChooser.getSelectedFile().getAbsolutePath()+".png"));
-                            } catch (IOException e) {
-                                e.printStackTrace();
-                            }
-                    }
-                } else if (fileDesc.startsWith("JPG")) {
-                    if (fileChooser.getSelectedFile().getName().toUpperCase().endsWith("JPG")==true) {
-                       try {
-                                ImageIO.write(image, "jpg", fileChooser.getSelectedFile());
-                            } catch (IOException e) {
-                                e.printStackTrace();
-                            }
-                    } else {
-                        try {
-                                ImageIO.write(image, "jpg", new File(fileChooser.getSelectedFile().getAbsolutePath()+".jpg"));
-                            } catch (IOException e) {
-                                e.printStackTrace();
-                            }
-                    }
-                }
-            
-        }//else
-            }
-            graphPanel.repaint();
-            
-        }
-    }
-    
-    class Graph extends JPanel implements MouseListener,
-            MouseMotionListener, MouseWheelListener {
-        
-        int offsetX, offsetY;
-        boolean dragging;
-        
-        Graph() {
-            setBackground(Color.white);
-            offsetX = x0;
-            offsetY = y0;
-            addMouseListener(this);
-            addMouseMotionListener(this);
-            addMouseWheelListener(this);
-        }
-        
-        @Override
-        public void mousePressed(MouseEvent evt) {
-            
-            if (dragging) {
-                return;
-            }
-            int x = evt.getX();
-            int y = evt.getY();
-            offsetX = x - x0;
-            offsetY = y - y0;
-            dragging = true;
-        }
-        
-        @Override
-        public void mouseReleased(MouseEvent evt) {
-            dragging = false;
-            repaint();
-        }
-        
-        @Override
-        public void mouseDragged(MouseEvent evt) {
-            if (dragging == false) {
-                return;
-            }
-            
-            int x = evt.getX();
-            int y = evt.getY();
-            x0 = x - offsetX;
-            y0 = y - offsetY;
-            
-            repaint();
-        }
-        
-        @Override
-        public void mouseWheelMoved(MouseWheelEvent e) {
-            double value = 0.05f * e.getPreciseWheelRotation();
-            int xleft = x0 - width / 3;
-            int xrigth = x0 + width / 3;
-          
-            if(value > 0 && (xrigth + xScale) - (xleft - xScale) <= 50){
-                return;
-            }
-            else{
-               xScale -= value * 100; 
-            }
-            repaint();
-        }
-        
-        @Override
-        public void mouseMoved(MouseEvent evt) {
-        }
-        
-        @Override
-        public void mouseClicked(MouseEvent evt) {
-        }
-        
-        @Override
-        public void mouseEntered(MouseEvent evt) {
-        }
-        
-        @Override
-        public void mouseExited(MouseEvent evt) {
-        }
-        
-        @Override
-        public void paintComponent(Graphics g) {
-            super.paintComponent(g);
-            Graficar(g, x0, y0);
-            
-        }
-        
-        void Graficar(Graphics ap, int xg, int yg) {
-
-            Graphics2D g = (Graphics2D) ap;
-            image = new BufferedImage(width, height, BufferedImage.TYPE_INT_BGR);
-            gb = image.createGraphics();
-            g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
-                    RenderingHints.VALUE_ANTIALIAS_ON);
-            gb.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
-                    RenderingHints.VALUE_ANTIALIAS_ON);
-            g.setFont(textFont);
-            gb.setFont(textFont);
-            // X axis
-            g.setPaint(Color.BLACK);
-            
-            gb.setBackground(Color.WHITE);
-            gb.clearRect(0, 0, image.getWidth(), image.getHeight());
-            gb.setColor(Color.BLACK);
-            
-            int xleft = xg - width / 3;
-            int xrigth = xg + width / 3;
-            g.setStroke(stroke.getStroke());
-            gb.setStroke(stroke.getStroke());
-            //Values
-            int xin = xleft - xScale;
-            int xfin = xrigth + xScale;
-            int rank1 = (int)Math.floor(algRank.get(0).rank);
-            //ticks number
-            int ticks = (int) (Math.ceil(algRank.get(algRank.size() - 1).rank));
-            int xdiv = (xfin - xin) / ticks; //number of divisions in the axis
-            int xinr = rank1*xdiv + xin;
-            //axis
-              g.draw(new Line2D.Double(xinr, yg, xrigth + xScale, yg));
-              gb.draw(new Line2D.Double(xinr, yg, xrigth + xScale, yg));
-
-            int j = rank1;
-            //put the ticks
-            g.setStroke(currentStroke);
-            gb.setStroke(currentStroke);
-            for (int i = /*xin*/xinr; i <= xfin; i += xdiv) {
-                g.draw(new Line2D.Double(i, yg - 4, i, yg));
-                g.drawString("" + j, i, yg - 6);
-                gb.draw(new Line2D.Double(i, yg - 4, i, yg));
-                gb.drawString("" + j, i, yg - 6);
-                j++;
-            }
-            int ydiv = (height / 2) / 4 - (height / 10);
-            
-            int ya = ydiv + yScale;
-            FontMetrics fm = g.getFontMetrics();
-            g.setStroke(stroke.getStroke());
-            gb.setStroke(stroke.getStroke());
-            boolean visited[][] = new boolean[algRank.size()][algRank.size()];
-            for (int i = 0; i < algRank.size(); i++) {
-                for (int k = 0; k < algRank.size(); k++) {
-                    visited[i][k] = false;
-                }
-            }
-           
-            //Draw algorithms Lines
-            for (int i = 0; i < algRank.size(); i++) {
-                g.draw(new Line2D.Double((double) (xdiv * algRank.get(i).rank + xin), yg + ya, (double) (xdiv * algRank.get(i).rank + xin), yg));
-                gb.draw(new Line2D.Double((double) (xdiv * algRank.get(i).rank + xin), yg + ya, (double) (xdiv * algRank.get(i).rank + xin), yg));
-                int k;
-                for (k = i + 1; k <= algRank.size() - 1; k++) {
-                    int index = PValuePerTwoAlgorithm.getIndex(PValues,
-                            algRank.get(i).algName, algRank.get(k).algName);
-                    boolean v = PValues.get(index).isSignicativeBetterThan(pvalue);
-                    if (v == true) {
-                        visited[i][k] = true;
-                    } else {
-                        break;
-                    }
-                }
-                g.setStroke(difStroke.getStroke());
-                gb.setStroke(difStroke.getStroke());
-                if (i == 0 && k - 1 != 0) {
-                    g.draw(new Line2D.Double((double) (xdiv * algRank.get(i).rank + xin), (yg + ya + yg) / 2, (double) (xdiv * algRank.get(k - 1).rank + xin), (yg + ya + yg) / 2));
-                    gb.draw(new Line2D.Double((double) (xdiv * algRank.get(i).rank + xin), (yg + ya + yg) / 2, (double) (xdiv * algRank.get(k - 1).rank + xin), (yg + ya + yg) / 2));
-                } else if (i != 0) {
-                    //If the last visited by the current algorithm is not in the visited of the previous one then draw a line
-                    if (visited[i - 1][k - 1] == false && (i != k - 1)) {
-                        g.draw(new Line2D.Double((double) (xdiv * algRank.get(i).rank + xin), (yg + ya + yg) / 2, (double) (xdiv * algRank.get(k - 1).rank + xin), (yg + ya + yg) / 2));
-                        gb.draw(new Line2D.Double((double) (xdiv * algRank.get(i).rank + xin), (yg + ya + yg) / 2, (double) (xdiv * algRank.get(k - 1).rank + xin), (yg + ya + yg) / 2));
-                    }
-                }
-                g.setStroke(stroke.getStroke());
-                gb.setStroke(stroke.getStroke());
-                if (i < algRank.size() / 2) {
-                    int lenght = fm.stringWidth(algRank.get(i).algName);
-                    g.draw(new Line2D.Double((double) (xdiv * algRank.get(i).rank + xin), yg + ya, xinr-3, yg + ya));
-                    g.drawString(algRank.get(i).algName, xinr-3 - lenght - 10, yg + ya);
-                    gb.draw(new Line2D.Double((double) (xdiv * algRank.get(i).rank + xin), yg + ya, xinr-3, yg + ya));
-                    gb.drawString(algRank.get(i).algName, xinr-3 - lenght - 10, yg + ya);
-                } else {                    
-                    g.draw(new Line2D.Double((double) (xdiv * algRank.get(i).rank + xin), yg + ya, xfin+3, yg + ya));
-                    g.drawString(algRank.get(i).algName, xfin+3 + 10, yg + ya);
-                    gb.draw(new Line2D.Double((double) (xdiv * algRank.get(i).rank + xin), yg + ya, xfin+3, yg + ya));
-                    gb.drawString(algRank.get(i).algName, xfin+3 + 10, yg + ya);
-                }
-                ya += 20;
-                
-            }
-            
-        }
-        
-    }
-
-    /**
-     * Allows you to increase or decrease the scale of the graph.
-     */
-    public class SliderPanel extends JPanel {
-
-        /**
-         * Constructor.
-         */
-        public SliderPanel() {
-            setLayout(new GridLayout(1, 2));
-            
-            xSlider = new JSlider(JSlider.VERTICAL, -400, 400, 50);
-            xSlider.addChangeListener((ChangeEvent e) -> {
-                xScale = (int) xSlider.getValue();
-                graphPanel.repaint();
-            });
-            
-            add(xSlider);
-            
-            ySlider = new JSlider(JSlider.VERTICAL, 1, 400, 20);
-            ySlider.addChangeListener((ChangeEvent e) -> {
-                yScale = (int) ySlider.getValue();
-                graphPanel.repaint();
-            });
-            add(ySlider);
-            
-            xSlider.setMinorTickSpacing(20);
-            xSlider.setPaintTicks(true);
-            xSlider.setPaintLabels(true);
-            ySlider.setMinorTickSpacing(20);
-            ySlider.setPaintTicks(true);
-            ySlider.setPaintLabels(true);
-            
-        }
-        
-    }
-    
+
+				BaseFileChooser fileChooser = new BaseFileChooser();
+				ExtensionFileFilter filterPNG = new ExtensionFileFilter(".png", "PNG Image Files");
+				fileChooser.addChoosableFileFilter(filterPNG);
+
+				ExtensionFileFilter filterJPG = new ExtensionFileFilter(".jpg", "JPG Image Files");
+				fileChooser.addChoosableFileFilter(filterJPG);
+
+				ExtensionFileFilter filterEPS = new ExtensionFileFilter(".eps", "EPS Image Files");
+				fileChooser.addChoosableFileFilter(filterEPS);
+
+				fileChooser.setAcceptAllFileFilterUsed(false);
+				fileChooser.setCurrentDirectory(new File(imgPath));
+				int option = fileChooser.showSaveDialog(null);
+				if (option == JFileChooser.APPROVE_OPTION) {
+					String fileDesc = fileChooser.getFileFilter().getDescription();
+
+					if (fileDesc.startsWith("PNG")) {
+
+						if (fileChooser.getSelectedFile().getName().toUpperCase().endsWith("PNG") == true) {
+							try {
+								ImageIO.write(image, "png", fileChooser.getSelectedFile());
+							} catch (IOException e) {
+								e.printStackTrace();
+							}
+						} else {
+							try {
+								ImageIO.write(image, "png",
+										new File(fileChooser.getSelectedFile().getAbsolutePath() + ".png"));
+							} catch (IOException e) {
+								e.printStackTrace();
+							}
+						}
+					} else if (fileDesc.startsWith("JPG")) {
+						if (fileChooser.getSelectedFile().getName().toUpperCase().endsWith("JPG") == true) {
+							try {
+								ImageIO.write(image, "jpg", fileChooser.getSelectedFile());
+							} catch (IOException e) {
+								e.printStackTrace();
+							}
+						} else {
+							try {
+								ImageIO.write(image, "jpg",
+										new File(fileChooser.getSelectedFile().getAbsolutePath() + ".jpg"));
+							} catch (IOException e) {
+								e.printStackTrace();
+							}
+						}
+					}
+
+				} // else
+			}
+			graphPanel.repaint();
+
+		}
+	}
+
+	class Graph extends JPanel implements MouseListener, MouseMotionListener, MouseWheelListener {
+
+		int offsetX, offsetY;
+		boolean dragging;
+
+		Graph() {
+			setBackground(Color.white);
+			offsetX = x0;
+			offsetY = y0;
+			addMouseListener(this);
+			addMouseMotionListener(this);
+			addMouseWheelListener(this);
+		}
+
+		@Override
+		public void mousePressed(MouseEvent evt) {
+
+			if (dragging) {
+				return;
+			}
+			int x = evt.getX();
+			int y = evt.getY();
+			offsetX = x - x0;
+			offsetY = y - y0;
+			dragging = true;
+		}
+
+		@Override
+		public void mouseReleased(MouseEvent evt) {
+			dragging = false;
+			repaint();
+		}
+
+		@Override
+		public void mouseDragged(MouseEvent evt) {
+			if (dragging == false) {
+				return;
+			}
+
+			int x = evt.getX();
+			int y = evt.getY();
+			x0 = x - offsetX;
+			y0 = y - offsetY;
+
+			repaint();
+		}
+
+		@Override
+		public void mouseWheelMoved(MouseWheelEvent e) {
+			double value = 0.05f * e.getPreciseWheelRotation();
+			int xleft = x0 - width / 3;
+			int xrigth = x0 + width / 3;
+
+			if (value > 0 && (xrigth + xScale) - (xleft - xScale) <= 50) {
+				return;
+			} else {
+				xScale -= value * 100;
+			}
+			repaint();
+		}
+
+		@Override
+		public void mouseMoved(MouseEvent evt) {
+		}
+
+		@Override
+		public void mouseClicked(MouseEvent evt) {
+		}
+
+		@Override
+		public void mouseEntered(MouseEvent evt) {
+		}
+
+		@Override
+		public void mouseExited(MouseEvent evt) {
+		}
+
+		@Override
+		public void paintComponent(Graphics g) {
+			super.paintComponent(g);
+			Graficar(g, x0, y0);
+
+		}
+
+		void Graficar(Graphics ap, int xg, int yg) {
+
+			Graphics2D g = (Graphics2D) ap;
+			image = new BufferedImage(width, height, BufferedImage.TYPE_INT_BGR);
+			gb = image.createGraphics();
+			g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+			gb.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+			g.setFont(textFont);
+			gb.setFont(textFont);
+			// X axis
+			g.setPaint(Color.BLACK);
+
+			gb.setBackground(Color.WHITE);
+			gb.clearRect(0, 0, image.getWidth(), image.getHeight());
+			gb.setColor(Color.BLACK);
+
+			int xleft = xg - width / 3;
+			int xrigth = xg + width / 3;
+			g.setStroke(stroke.getStroke());
+			gb.setStroke(stroke.getStroke());
+			// Values
+			int xin = xleft - xScale;
+			int xfin = xrigth + xScale;
+			int rank1 = (int) Math.floor(algRank.get(0).rank);
+			// ticks number
+			int ticks = (int) (Math.ceil(algRank.get(algRank.size() - 1).rank));
+			int xdiv = (xfin - xin) / ticks; // number of divisions in the axis
+			int xinr = rank1 * xdiv + xin;
+			// axis
+			g.draw(new Line2D.Double(xinr, yg, xrigth + xScale, yg));
+			gb.draw(new Line2D.Double(xinr, yg, xrigth + xScale, yg));
+
+			int j = rank1;
+			// put the ticks
+			g.setStroke(currentStroke);
+			gb.setStroke(currentStroke);
+			for (int i = /* xin */xinr; i <= xfin; i += xdiv) {
+				g.draw(new Line2D.Double(i, yg - 4, i, yg));
+				g.drawString("" + j, i, yg - 6);
+				gb.draw(new Line2D.Double(i, yg - 4, i, yg));
+				gb.drawString("" + j, i, yg - 6);
+				j++;
+			}
+			int ydiv = (height / 2) / 4 - (height / 10);
+
+			int ya = ydiv + yScale;
+			FontMetrics fm = g.getFontMetrics();
+			g.setStroke(stroke.getStroke());
+			gb.setStroke(stroke.getStroke());
+			boolean visited[][] = new boolean[algRank.size()][algRank.size()];
+			for (int i = 0; i < algRank.size(); i++) {
+				for (int k = 0; k < algRank.size(); k++) {
+					visited[i][k] = false;
+				}
+			}
+
+			// Draw algorithms Lines
+			for (int i = 0; i < algRank.size(); i++) {
+				g.draw(new Line2D.Double(xdiv * algRank.get(i).rank + xin, yg + ya, xdiv * algRank.get(i).rank + xin,
+						yg));
+				gb.draw(new Line2D.Double(xdiv * algRank.get(i).rank + xin, yg + ya, xdiv * algRank.get(i).rank + xin,
+						yg));
+				int k;
+				for (k = i + 1; k <= algRank.size() - 1; k++) {
+					int index = PValuePerTwoAlgorithm.getIndex(PValues, algRank.get(i).algName, algRank.get(k).algName);
+					boolean v = PValues.get(index).isSignicativeBetterThan(pvalue);
+					if (v == true) {
+						visited[i][k] = true;
+					} else {
+						break;
+					}
+				}
+				g.setStroke(difStroke.getStroke());
+				gb.setStroke(difStroke.getStroke());
+				if (i == 0 && k - 1 != 0) {
+					g.draw(new Line2D.Double(xdiv * algRank.get(i).rank + xin, (yg + ya + yg) / 2,
+							xdiv * algRank.get(k - 1).rank + xin, (yg + ya + yg) / 2));
+					gb.draw(new Line2D.Double(xdiv * algRank.get(i).rank + xin, (yg + ya + yg) / 2,
+							xdiv * algRank.get(k - 1).rank + xin, (yg + ya + yg) / 2));
+				} else if (i != 0) {
+					// If the last visited by the current algorithm is not in the visited of the
+					// previous one then draw a line
+					if (visited[i - 1][k - 1] == false && (i != k - 1)) {
+						g.draw(new Line2D.Double(xdiv * algRank.get(i).rank + xin, (yg + ya + yg) / 2,
+								xdiv * algRank.get(k - 1).rank + xin, (yg + ya + yg) / 2));
+						gb.draw(new Line2D.Double(xdiv * algRank.get(i).rank + xin, (yg + ya + yg) / 2,
+								xdiv * algRank.get(k - 1).rank + xin, (yg + ya + yg) / 2));
+					}
+				}
+				g.setStroke(stroke.getStroke());
+				gb.setStroke(stroke.getStroke());
+				if (i < algRank.size() / 2) {
+					int lenght = fm.stringWidth(algRank.get(i).algName);
+					g.draw(new Line2D.Double(xdiv * algRank.get(i).rank + xin, yg + ya, xinr - 3, yg + ya));
+					g.drawString(algRank.get(i).algName, xinr - 3 - lenght - 10, yg + ya);
+					gb.draw(new Line2D.Double(xdiv * algRank.get(i).rank + xin, yg + ya, xinr - 3, yg + ya));
+					gb.drawString(algRank.get(i).algName, xinr - 3 - lenght - 10, yg + ya);
+				} else {
+					g.draw(new Line2D.Double(xdiv * algRank.get(i).rank + xin, yg + ya, xfin + 3, yg + ya));
+					g.drawString(algRank.get(i).algName, xfin + 3 + 10, yg + ya);
+					gb.draw(new Line2D.Double(xdiv * algRank.get(i).rank + xin, yg + ya, xfin + 3, yg + ya));
+					gb.drawString(algRank.get(i).algName, xfin + 3 + 10, yg + ya);
+				}
+				ya += 20;
+
+			}
+
+		}
+
+	}
+
+	/**
+	 * Allows you to increase or decrease the scale of the graph.
+	 */
+	public class SliderPanel extends JPanel {
+
+		/**
+		 * Constructor.
+		 */
+		public SliderPanel() {
+			setLayout(new GridLayout(1, 2));
+
+			xSlider = new JSlider(SwingConstants.VERTICAL, -400, 400, 50);
+			xSlider.addChangeListener((ChangeEvent e) -> {
+				xScale = xSlider.getValue();
+				graphPanel.repaint();
+			});
+
+			add(xSlider);
+
+			ySlider = new JSlider(SwingConstants.VERTICAL, 1, 400, 20);
+			ySlider.addChangeListener((ChangeEvent e) -> {
+				yScale = ySlider.getValue();
+				graphPanel.repaint();
+			});
+			add(ySlider);
+
+			xSlider.setMinorTickSpacing(20);
+			xSlider.setPaintTicks(true);
+			xSlider.setPaintLabels(true);
+			ySlider.setMinorTickSpacing(20);
+			ySlider.setPaintTicks(true);
+			ySlider.setPaintLabels(true);
+
+		}
+
+	}
+
 } // class
diff --git a/moa/src/main/java/moa/gui/experimentertab/ReadFile.java b/moa/src/main/java/moa/gui/experimentertab/ReadFile.java
index e3b9a855e..fc10007d7 100644
--- a/moa/src/main/java/moa/gui/experimentertab/ReadFile.java
+++ b/moa/src/main/java/moa/gui/experimentertab/ReadFile.java
@@ -1,6 +1,6 @@
 /*
  *    ReadFile.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand 
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
  *    @author Alberto Verdecia Cabrera (averdeciac@gmail.com)
  *
  *    This program is free software; you can redistribute it and/or modify
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab;
 
@@ -32,6 +32,7 @@
 import java.util.List;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+
 import org.apache.commons.io.FilenameUtils;
 
 /**
@@ -41,309 +42,303 @@
  */
 public class ReadFile {
 
-    private String path;
-    private LinkedList<String> stream;
-    private LinkedList<String> algNames;
-    private LinkedList<String> measures;
-    private ArrayList<String> algShortNames;
-    private List<Algorithm> algorithm = new ArrayList<>();
-    /**
-     * File Constructor
-     *
-     * @param path
-     */
-    public ReadFile(String path) {
-        this.path = path;
-        this.stream = new LinkedList<>();
-        this.algNames = new LinkedList<>();
-        this.measures = new LinkedList<>();
-        this.algShortNames = new ArrayList<>();
-    }
-
-    /**
-     * Processes the results files of the algorithms in each directory.
-     *
-     * @return If all the files were processed correctly it returns an empty
-     * string, else return the problem file.
-     */
-    public String processFiles() {
-
-        //read files
-        File file = new File(path);
-        File listFiles[] = file.listFiles();
-        boolean addFirst = true;
-        for (int i = 0; i < listFiles.length; i++) {
-
-            if (listFiles[i].isDirectory()) {
-                stream.add(listFiles[i].getName());
-                File files = new File(listFiles[i].getAbsolutePath());
-                File algorithm[] = files.listFiles();
-                for (int j = 0; j < algorithm.length; j++) {
-                    if (algorithm[j].isFile()) {
-                        if (algNames.remove(algorithm[j].getName())) {
-                            algNames.add(algorithm[j].getName());
-                        } else {
-                            algNames.add(algorithm[j].getName());
-                        }
-                        FileReader fr = null;
-                        try {
-                            fr = new FileReader(algorithm[j].getAbsolutePath());
-                        } catch (FileNotFoundException ex) {
-                            return "Problem with file: " + listFiles[j].getAbsolutePath();
-
-                        }
-                        BufferedReader br = new BufferedReader(fr);
-                        try {
-                            String line = br.readLine();
-                            if (addFirst) {
-                                measures.add(line);
-                                addFirst = false;
-                            } else if (measures.remove(line)) {
-                                measures.add(line);
-                            } else {
-                                String lineArray[] = line.split(",");
-                                String measureArray[] = measures.getFirst().split(",");
-                                String newMeasure = "";
-                                for (int l = 0; l < lineArray.length; l++) {
-                                    for (int m = 0; m < measureArray.length; m++) {
-                                        if (lineArray[l].equals(measureArray[m])) {
-                                            newMeasure += lineArray[l] + ",";
-                                        }
-
-                                    }
-                                }
-                                String s[];
-                                if (newMeasure.endsWith(",")) {
-                                    s = newMeasure.split(",");
-                                    newMeasure = "";
-                                    for (int k = 0; k < s.length; k++) {
-                                        newMeasure += s[k];
-                                        if (k != s.length - 1) {
-                                            newMeasure += ",";
-                                        }
-                                    }
-                                }
-
-                                measures.removeFirst();
-                                measures.add(newMeasure);
-                            }
-
-                        } catch (IOException ex) {
-                            return "Problem with file: " + listFiles[j].getAbsolutePath();
-
-                        }
-                    }
-
-                }
-            }
-        }//end files
-        algNames.stream().forEach((algName) -> {
-            this.algShortNames.add(FilenameUtils.getBaseName(algName));
-        });
-        return "";
-    }
-
-    public String updateMeasures(String algNames[], String stream) {
-        this.measures = new LinkedList<>();
-        //read files
-        boolean addFirst = true;
-        for (int i = 0; i < algNames.length; i++) {
-            File algorithm = new File(path + File.separator + stream + File.separator + algNames[i]);
-            FileReader fr = null;
-            try {
-                fr = new FileReader(algorithm.getAbsolutePath());
-            } catch (FileNotFoundException ex) {
-                return "Problem with file: " + algorithm.getAbsolutePath();
-            }
-            BufferedReader br = new BufferedReader(fr);
-            try {
-                String line = br.readLine();
-                if (addFirst) {
-                    measures.add(line);
-                    addFirst = false;
-                } else if (measures.remove(line)) {
-                    measures.add(line);
-                } else {
-                    String lineArray[] = line.split(",");
-                    String measureArray[] = measures.getFirst().split(",");
-                    String newMeasure = "";
-                    for (int l = 0; l < lineArray.length; l++) {
-                        for (int m = 0; m < measureArray.length; m++) {
-                            if (lineArray[l].equals(measureArray[m])) {
-                                newMeasure += lineArray[l] + ",";
-                            }
-
-                        }
-                    }
-                    String s[];
-                    if (newMeasure.endsWith(",")) {
-                        s = newMeasure.split(",");
-                        newMeasure = "";
-                        for (int k = 0; k < s.length; k++) {
-                            newMeasure += s[k];
-                            if (k != s.length - 1) {
-                                newMeasure += ",";
-                            }
-                        }
-                    }
-
-                    measures.removeFirst();
-                    measures.add(newMeasure);
-                }
-
-            } catch (IOException ex) {
-                return "Problem with file: " + algorithm.getAbsolutePath();
-
-            }
-        }
-        return null;
-    }
-    
-    static int getMeasureIndex(String algPath, String mesasure){
-          
-             FileReader fr = null;
-        try {
-            fr = new FileReader(new File(algPath));
-            BufferedReader br = new BufferedReader(fr);
-             String line = br.readLine();
-                 String measures[] = line.split(",");
-                 for(int i = 0; i < measures.length; i++){
-                      if(measures[i].equals(mesasure)==true)
-                          return i;
-                 }
-            
-        } catch (FileNotFoundException ex) {
-            Logger.getLogger(ReadFile.class.getName()).log(Level.SEVERE, null, ex);
-        } catch (IOException ex) {
-            Logger.getLogger(ReadFile.class.getName()).log(Level.SEVERE, null, ex);
-        }
-        
-        return 0;
-    }
-    
-  /*  public ArrayList<Algorithm> getAlgorithms(List<String> algPath,List<String> algNames, List<Measure> measures){
-        
-         for(int i = 0; i < algPath.size(); i++){
-             FileReader fr = null;
-             try {
-                 fr = new FileReader(new File(algPath.get(i)));
-             } catch (FileNotFoundException ex) {
-                 Logger.getLogger(ReadFile.class.getName()).log(Level.SEVERE, null, ex);
-             }
-             BufferedReader br = new BufferedReader(fr); 
-            
-             try {
-                 String line = br.readLine();
-                 String measures1[] = line.split(",");
-                 for(int j = 0; j < measures1.length; j++){
-                     
-                 }
-             } catch (IOException ex) {
-                 Logger.getLogger(ReadFile.class.getName()).log(Level.SEVERE, null, ex);
-             }
-             Algorithm algorithm = new Algorithm(algNames.get(i), measures, br);
-             this.algorithm.add(algorithm);
-         }
-    }*/
-    /**
-     * Returns the name of the algorithms.
-     *
-     * @return a LinkedList with the name of the algorithms.
-     */
-    public LinkedList<String> getAlgNames() {
-        return algNames;
-    }
-
-    /**
-     * Returns the common measures to all algorithms.
-     *
-     * @return a LinkedList with the measures.
-     */
-    public LinkedList<String> getMeasures() {
-        return measures;
-    }
-
-    /**
-     * Returns the name of the streams.
-     *
-     * @return a LinkedList with the streams.
-     */
-    public LinkedList<String> getStream() {
-        return stream;
-    }
-
-    /**
-     * Returns the short name of the algorithms.
-     *
-     * @return an ArrayList with the short name of the algorithms.
-     */
-    public ArrayList<String> getAlgShortNames() {
-        return algShortNames;
-    }
-
-    /**
-     * Returns the path of the results.
-     *
-     * @return the path of the results.
-     */
-    public String getPath() {
-        return path;
-    }
-
-    /**
-     * Sets the directory of the results file.
-     *
-     * @param path
-     */
-    public void setPath(String path) {
-        this.path = path;
-    }
-
-    /**
-     * Delete the selected directory.
-     *
-     * @param directory
-     */
-    public static void deleteDrectory(File directory) {
-        File[] files = directory.listFiles();
-        for (File file : files) {
-            if (file.isDirectory()) {
-                deleteDrectory(file);
-            }
-            file.delete();
-        }
-    }
-
-    /**
-     * Allow to read a csv file.
-     *
-     * @param path
-     * @return
-     * @throws UnsupportedEncodingException
-     * @throws FileNotFoundException
-     * @throws IOException
-     */
-    public static ArrayList<String[]> readCSV(String path)
-            throws UnsupportedEncodingException, FileNotFoundException, IOException {
-
-        ArrayList<String[]> data = new ArrayList<>();
-
-        try (FileInputStream csv = new FileInputStream(path);
-                InputStreamReader reader = new InputStreamReader(csv);
-                BufferedReader br = new BufferedReader(reader)) {
-
-            String linea = br.readLine();
-
-            while ((linea = br.readLine()) != null) {
-
-                data.add(linea.split(","));
-
-            }
-
-        }
-
-        return data;
-
-    }
+	private String path;
+	private LinkedList<String> stream;
+	private LinkedList<String> algNames;
+	private LinkedList<String> measures;
+	private ArrayList<String> algShortNames;
+	private List<Algorithm> algorithm = new ArrayList<>();
+
+	/**
+	 * File Constructor
+	 *
+	 * @param path
+	 */
+	public ReadFile(String path) {
+		this.path = path;
+		this.stream = new LinkedList<>();
+		this.algNames = new LinkedList<>();
+		this.measures = new LinkedList<>();
+		this.algShortNames = new ArrayList<>();
+	}
+
+	/**
+	 * Processes the results files of the algorithms in each directory.
+	 *
+	 * @return If all the files were processed correctly it returns an empty string,
+	 *         else return the problem file.
+	 */
+	public String processFiles() {
+
+		// read files
+		File file = new File(path);
+		File listFiles[] = file.listFiles();
+		boolean addFirst = true;
+		for (int i = 0; i < listFiles.length; i++) {
+
+			if (listFiles[i].isDirectory()) {
+				stream.add(listFiles[i].getName());
+				File files = new File(listFiles[i].getAbsolutePath());
+				File algorithm[] = files.listFiles();
+				for (int j = 0; j < algorithm.length; j++) {
+					if (algorithm[j].isFile()) {
+						if (algNames.remove(algorithm[j].getName())) {
+							algNames.add(algorithm[j].getName());
+						} else {
+							algNames.add(algorithm[j].getName());
+						}
+						FileReader fr = null;
+						try {
+							fr = new FileReader(algorithm[j].getAbsolutePath());
+						} catch (FileNotFoundException ex) {
+							return "Problem with file: " + listFiles[j].getAbsolutePath();
+
+						}
+						BufferedReader br = new BufferedReader(fr);
+						try {
+							String line = br.readLine();
+							if (addFirst) {
+								measures.add(line);
+								addFirst = false;
+							} else if (measures.remove(line)) {
+								measures.add(line);
+							} else {
+								String lineArray[] = line.split(",");
+								String measureArray[] = measures.getFirst().split(",");
+								String newMeasure = "";
+								for (int l = 0; l < lineArray.length; l++) {
+									for (int m = 0; m < measureArray.length; m++) {
+										if (lineArray[l].equals(measureArray[m])) {
+											newMeasure += lineArray[l] + ",";
+										}
+
+									}
+								}
+								String s[];
+								if (newMeasure.endsWith(",")) {
+									s = newMeasure.split(",");
+									newMeasure = "";
+									for (int k = 0; k < s.length; k++) {
+										newMeasure += s[k];
+										if (k != s.length - 1) {
+											newMeasure += ",";
+										}
+									}
+								}
+
+								measures.removeFirst();
+								measures.add(newMeasure);
+							}
+
+						} catch (IOException ex) {
+							return "Problem with file: " + listFiles[j].getAbsolutePath();
+
+						}
+					}
+
+				}
+			}
+		} // end files
+		algNames.stream().forEach((algName) -> {
+			this.algShortNames.add(FilenameUtils.getBaseName(algName));
+		});
+		return "";
+	}
+
+	public String updateMeasures(String algNames[], String stream) {
+		this.measures = new LinkedList<>();
+		// read files
+		boolean addFirst = true;
+		for (int i = 0; i < algNames.length; i++) {
+			File algorithm = new File(path + File.separator + stream + File.separator + algNames[i]);
+			FileReader fr = null;
+			try {
+				fr = new FileReader(algorithm.getAbsolutePath());
+			} catch (FileNotFoundException ex) {
+				return "Problem with file: " + algorithm.getAbsolutePath();
+			}
+			BufferedReader br = new BufferedReader(fr);
+			try {
+				String line = br.readLine();
+				if (addFirst) {
+					measures.add(line);
+					addFirst = false;
+				} else if (measures.remove(line)) {
+					measures.add(line);
+				} else {
+					String lineArray[] = line.split(",");
+					String measureArray[] = measures.getFirst().split(",");
+					String newMeasure = "";
+					for (int l = 0; l < lineArray.length; l++) {
+						for (int m = 0; m < measureArray.length; m++) {
+							if (lineArray[l].equals(measureArray[m])) {
+								newMeasure += lineArray[l] + ",";
+							}
+
+						}
+					}
+					String s[];
+					if (newMeasure.endsWith(",")) {
+						s = newMeasure.split(",");
+						newMeasure = "";
+						for (int k = 0; k < s.length; k++) {
+							newMeasure += s[k];
+							if (k != s.length - 1) {
+								newMeasure += ",";
+							}
+						}
+					}
+
+					measures.removeFirst();
+					measures.add(newMeasure);
+				}
+
+			} catch (IOException ex) {
+				return "Problem with file: " + algorithm.getAbsolutePath();
+
+			}
+		}
+		return null;
+	}
+
+	static int getMeasureIndex(String algPath, String mesasure) {
+
+		FileReader fr = null;
+		try {
+			fr = new FileReader(new File(algPath));
+			BufferedReader br = new BufferedReader(fr);
+			String line = br.readLine();
+			String measures[] = line.split(",");
+			for (int i = 0; i < measures.length; i++) {
+				if (measures[i].equals(mesasure) == true)
+					return i;
+			}
+
+		} catch (FileNotFoundException ex) {
+			Logger.getLogger(ReadFile.class.getName()).log(Level.SEVERE, null, ex);
+		} catch (IOException ex) {
+			Logger.getLogger(ReadFile.class.getName()).log(Level.SEVERE, null, ex);
+		}
+
+		return 0;
+	}
+
+	/*
+	 * public ArrayList<Algorithm> getAlgorithms(List<String> algPath,List<String>
+	 * algNames, List<Measure> measures){
+	 * 
+	 * for(int i = 0; i < algPath.size(); i++){ FileReader fr = null; try { fr = new
+	 * FileReader(new File(algPath.get(i))); } catch (FileNotFoundException ex) {
+	 * Logger.getLogger(ReadFile.class.getName()).log(Level.SEVERE, null, ex); }
+	 * BufferedReader br = new BufferedReader(fr);
+	 * 
+	 * try { String line = br.readLine(); String measures1[] = line.split(",");
+	 * for(int j = 0; j < measures1.length; j++){
+	 * 
+	 * } } catch (IOException ex) {
+	 * Logger.getLogger(ReadFile.class.getName()).log(Level.SEVERE, null, ex); }
+	 * Algorithm algorithm = new Algorithm(algNames.get(i), measures, br);
+	 * this.algorithm.add(algorithm); } }
+	 */
+	/**
+	 * Returns the name of the algorithms.
+	 *
+	 * @return a LinkedList with the name of the algorithms.
+	 */
+	public LinkedList<String> getAlgNames() {
+		return algNames;
+	}
+
+	/**
+	 * Returns the common measures to all algorithms.
+	 *
+	 * @return a LinkedList with the measures.
+	 */
+	public LinkedList<String> getMeasures() {
+		return measures;
+	}
+
+	/**
+	 * Returns the name of the streams.
+	 *
+	 * @return a LinkedList with the streams.
+	 */
+	public LinkedList<String> getStream() {
+		return stream;
+	}
+
+	/**
+	 * Returns the short name of the algorithms.
+	 *
+	 * @return an ArrayList with the short name of the algorithms.
+	 */
+	public ArrayList<String> getAlgShortNames() {
+		return algShortNames;
+	}
+
+	/**
+	 * Returns the path of the results.
+	 *
+	 * @return the path of the results.
+	 */
+	public String getPath() {
+		return path;
+	}
+
+	/**
+	 * Sets the directory of the results file.
+	 *
+	 * @param path
+	 */
+	public void setPath(String path) {
+		this.path = path;
+	}
+
+	/**
+	 * Delete the selected directory.
+	 *
+	 * @param directory
+	 */
+	public static void deleteDrectory(File directory) {
+		File[] files = directory.listFiles();
+		for (File file : files) {
+			if (file.isDirectory()) {
+				deleteDrectory(file);
+			}
+			file.delete();
+		}
+	}
+
+	/**
+	 * Allow to read a csv file.
+	 *
+	 * @param path
+	 * @return
+	 * @throws UnsupportedEncodingException
+	 * @throws FileNotFoundException
+	 * @throws IOException
+	 */
+	public static ArrayList<String[]> readCSV(String path)
+			throws UnsupportedEncodingException, FileNotFoundException, IOException {
+
+		ArrayList<String[]> data = new ArrayList<>();
+
+		try (FileInputStream csv = new FileInputStream(path);
+				InputStreamReader reader = new InputStreamReader(csv);
+				BufferedReader br = new BufferedReader(reader)) {
+
+			String linea = br.readLine();
+
+			while ((linea = br.readLine()) != null) {
+
+				data.add(linea.split(","));
+
+			}
+
+		}
+
+		return data;
+
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/Stream.java b/moa/src/main/java/moa/gui/experimentertab/Stream.java
index 863d4dbf4..ca944092c 100644
--- a/moa/src/main/java/moa/gui/experimentertab/Stream.java
+++ b/moa/src/main/java/moa/gui/experimentertab/Stream.java
@@ -1,6 +1,6 @@
 /*
  *    Stream.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand 
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
  *    @author Alberto Verdecia Cabrera (averdeciac@gmail.com)
  *
  *    This program is free software; you can redistribute it and/or modify
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab;
 
@@ -34,70 +34,75 @@
  */
 public class Stream {
 
-    /**
-     * The name of the stream
-     */
-    public String name;
+	/**
+	 * The name of the stream
+	 */
+	public String name;
 
-    /**
-     * The list of algorithms within of the stream
-     */
-    public List<Algorithm> algorithm = new ArrayList<>();
+	/**
+	 * The list of algorithms within of the stream
+	 */
+	public List<Algorithm> algorithm = new ArrayList<>();
 
-    /**
-     * Stream Constructor
-     * @param name
-     * @param algPath
-     * @param algNames
-     * @param measures
-     */
-    public Stream(String name, List<String> algPath, List<String> algNames, List<Measure> measures) {
-        this.name = name;
-        readBuffer(algPath, algNames, measures);
-    }
+	/**
+	 * Stream Constructor
+	 * 
+	 * @param name
+	 * @param algPath
+	 * @param algNames
+	 * @param measures
+	 */
+	public Stream(String name, List<String> algPath, List<String> algNames, List<Measure> measures) {
+		this.name = name;
+		readBuffer(algPath, algNames, measures);
+	}
 
-    /**
-     * Read each algorithm file.
-     * @param algPath
-     * @param algNames
-     * @param measures
-     */
-    public void readBuffer(List<String> algPath, List<String> algNames, List<Measure> measures) {
-        BufferedReader buffer = null;
-        for (int i = 0; i < algPath.size(); i++) {
-            try {
-                buffer = new BufferedReader(new FileReader(algPath.get(i)));
-            } catch (FileNotFoundException ex) {
-                Logger.getLogger(Stream.class.getName()).log(Level.SEVERE, null, ex);
-            }
-            Algorithm algorithm = new Algorithm(algNames.get(i), measures, buffer,algPath.get(i));
-            this.algorithm.add(algorithm);
-        }
+	/**
+	 * Read each algorithm file.
+	 * 
+	 * @param algPath
+	 * @param algNames
+	 * @param measures
+	 */
+	public void readBuffer(List<String> algPath, List<String> algNames, List<Measure> measures) {
+		BufferedReader buffer = null;
+		for (int i = 0; i < algPath.size(); i++) {
+			try {
+				buffer = new BufferedReader(new FileReader(algPath.get(i)));
+			} catch (FileNotFoundException ex) {
+				Logger.getLogger(Stream.class.getName()).log(Level.SEVERE, null, ex);
+			}
+			Algorithm algorithm = new Algorithm(algNames.get(i), measures, buffer, algPath.get(i));
+			this.algorithm.add(algorithm);
+		}
 
-    }
+	}
 
-    /**
-     * Sets the name of stream
-     * @param name
-     */
-    public void setName(String name) {
-        this.name = name;
-    }
+	/**
+	 * Sets the name of stream
+	 * 
+	 * @param name
+	 */
+	public void setName(String name) {
+		this.name = name;
+	}
 
-    /**
-     * Returns the name of the stream
-     * @return the name of the stream
-     */
-    public String getName() {
-        return name;
-    }
+	/**
+	 * Returns the name of the stream
+	 * 
+	 * @return the name of the stream
+	 */
+	public String getName() {
+		return name;
+	}
 
-    /**
-     * Returns the list of the algorithms
-     * @return the list of  the algorithms
-     */
-    public List<Algorithm> getAlgorithm() {
-        return algorithm;
-    }
+	/**
+	 * Returns the list of the algorithms
+	 * 
+	 * @return the list of the algorithms
+	 */
+	public List<Algorithm> getAlgorithm() {
+		return algorithm;
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/Summary.java b/moa/src/main/java/moa/gui/experimentertab/Summary.java
index 7217d4e4f..b3cd2236b 100644
--- a/moa/src/main/java/moa/gui/experimentertab/Summary.java
+++ b/moa/src/main/java/moa/gui/experimentertab/Summary.java
@@ -1,6 +1,6 @@
 /*
  *    Summary.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand 
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
  *    @author Alberto Verdecia Cabrera (averdeciac@gmail.com)
  *
  *    This program is free software; you can redistribute it and/or modify
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab;
 
@@ -32,102 +32,102 @@
  */
 public class Summary {
 
-    /**
-     * The list of the streams
-     */
-    public List<Stream> streams = new ArrayList<>();
-
-    /**
-     * The path of the results
-     */
-    public  String path = "";
-    public  SummaryTable []summary;    
-
-    /**
-     * Summary Constructor
-     *
-     * @param streams
-     * @param path
-     */
-    public Summary(List<Stream> streams, String path) {
-        this.streams = streams;
-        this.path = path;
+	/**
+	 * The list of the streams
+	 */
+	public List<Stream> streams = new ArrayList<>();
+
+	/**
+	 * The path of the results
+	 */
+	public String path = "";
+	public SummaryTable[] summary;
+
+	/**
+	 * Summary Constructor
+	 *
+	 * @param streams
+	 * @param path
+	 */
+	public Summary(List<Stream> streams, String path) {
+		this.streams = streams;
+		this.path = path;
 //        generateHTML();
 //        generateCSV();
 //        generateLatex();
 //        computeWinsTiesLossesLatex();
 //        invertedSumariesPerMeasure();
 //        computeWinsTiesLossesHTML();
-    }
-
-    /**
-     * Generates a latex summary, in which the rows are the algorithms and the
-     * columns the datasets.
-     */
-    public void generateLatex(String path) {
-        String output = "";
-        output += "\\documentclass{article}\n";
-        output += "\\usepackage{multirow}\n\\usepackage{booktabs}\n\\begin{document}\n\\begin{table}[htbp]\n\\caption{Add caption}";
-        output += "\\begin{tabular}";
-        output += "{";
-        for (int i = 0; i < this.streams.size() + 4; i++) {
-            output += "r";
-        }
-        output += "}\n\\toprule\nAlgorithm & \\multicolumn{2}{r}{Measure}";
-        for (int i = 0; i < this.streams.size(); i++) {
-            output += "& " + this.streams.get(i).getName();
-        }
-        output += "& AVG\\\\\n\\midrule\n";
-        int algorithmSize = this.streams.get(0).algorithm.size();
-        String name = "";
-        for (int i = 0; i < algorithmSize; i++) {
-            List<Algorithm> alg = this.streams.get(0).algorithm;
-            output += "\\multirow{" + alg.get(i).measureStdSize + "}[" + 6 + "]{*}{" + alg.get(i).name + "}";
-            List<Measure> measures[] = alg.get(i).getMeasuresPerData(streams);
-            int cont = 0;
-            double sum = 0.0;
-            boolean isType = true;
-            while (cont != this.streams.get(0).algorithm.get(i).measures.size()) {
-                sum = 0;
-                name = measures[0].get(cont).getName();
-                if (measures[0].get(cont).isType()) {
-                    output += "&\\multirow{" + 2 + "}[4]{*}{" + name + "} & mean";
-
-                } else {
-                    output += " & " + name;
-                    output += "& Last value";
-                }
-                for (int j = 0; j < measures.length; j++) {
-                    //sum =0;
-                    if (measures[j].get(cont).isType()) {
-                        output += " & " + Algorithm.format(measures[j].get(cont).getValue());
-
-                        sum += measures[j].get(cont).getValue();
-                        isType = true;
-                    } else {
-                        output += " & " + Algorithm.format1(measures[j].get(cont).getValue());
-                        isType = false;
-                    }
-
-                }
-                if (isType) {
-                    double size = (double) this.streams.size();
-                    output += "& " + Algorithm.format(sum / size);
-                    output += "\\\\\n";
-                    output += " & & std";
-                    for (int j = 0; j < measures.length; j++) {
-                        output += " & " + Algorithm.format(measures[j].get(cont).getStd());
-                    }
-                    output += " & -";
-                } else {
-                    output += " & -";
-
-                }
-                output += "\\\\\n";
-                cont++;
-            }
-        }
-        output += "\\bottomrule\n\\end{tabular}%\n\\label{tab:addlabel}%\n\\end{table}%\n\\end{document}";
+	}
+
+	/**
+	 * Generates a latex summary, in which the rows are the algorithms and the
+	 * columns the datasets.
+	 */
+	public void generateLatex(String path) {
+		String output = "";
+		output += "\\documentclass{article}\n";
+		output += "\\usepackage{multirow}\n\\usepackage{booktabs}\n\\begin{document}\n\\begin{table}[htbp]\n\\caption{Add caption}";
+		output += "\\begin{tabular}";
+		output += "{";
+		for (int i = 0; i < this.streams.size() + 4; i++) {
+			output += "r";
+		}
+		output += "}\n\\toprule\nAlgorithm & \\multicolumn{2}{r}{Measure}";
+		for (int i = 0; i < this.streams.size(); i++) {
+			output += "& " + this.streams.get(i).getName();
+		}
+		output += "& AVG\\\\\n\\midrule\n";
+		int algorithmSize = this.streams.get(0).algorithm.size();
+		String name = "";
+		for (int i = 0; i < algorithmSize; i++) {
+			List<Algorithm> alg = this.streams.get(0).algorithm;
+			output += "\\multirow{" + alg.get(i).measureStdSize + "}[" + 6 + "]{*}{" + alg.get(i).name + "}";
+			List<Measure> measures[] = alg.get(i).getMeasuresPerData(streams);
+			int cont = 0;
+			double sum = 0.0;
+			boolean isType = true;
+			while (cont != this.streams.get(0).algorithm.get(i).measures.size()) {
+				sum = 0;
+				name = measures[0].get(cont).getName();
+				if (measures[0].get(cont).isType()) {
+					output += "&\\multirow{" + 2 + "}[4]{*}{" + name + "} & mean";
+
+				} else {
+					output += " & " + name;
+					output += "& Last value";
+				}
+				for (int j = 0; j < measures.length; j++) {
+					// sum =0;
+					if (measures[j].get(cont).isType()) {
+						output += " & " + Algorithm.format(measures[j].get(cont).getValue());
+
+						sum += measures[j].get(cont).getValue();
+						isType = true;
+					} else {
+						output += " & " + Algorithm.format1(measures[j].get(cont).getValue());
+						isType = false;
+					}
+
+				}
+				if (isType) {
+					double size = this.streams.size();
+					output += "& " + Algorithm.format(sum / size);
+					output += "\\\\\n";
+					output += " & & std";
+					for (int j = 0; j < measures.length; j++) {
+						output += " & " + Algorithm.format(measures[j].get(cont).getStd());
+					}
+					output += " & -";
+				} else {
+					output += " & -";
+
+				}
+				output += "\\\\\n";
+				cont++;
+			}
+		}
+		output += "\\bottomrule\n\\end{tabular}%\n\\label{tab:addlabel}%\n\\end{table}%\n\\end{document}";
 //        PrintStream out = null;
 //        try {
 //            out = new PrintStream(new BufferedOutputStream(new FileOutputStream(path + "summary.tex")));
@@ -137,60 +137,60 @@ public void generateLatex(String path) {
 //        System.setOut(out);
 //        System.out.println(output);
 //        out.close();
-        try {
-            BufferedWriter out = new BufferedWriter(new FileWriter(path + "summary.tex"));
-            out.write(output);  //Replace with the string 
-            //you are trying to write  
-            out.close();
-        } catch (IOException e) {
-            System.out.println(" Error saving summary.tex");
-
-        }
-    }
-
-    /**
-     * Generates a latex summary, in which the rows are the datasets and the
-     * columns the algorithms.
-     */
-    public void invertedSumariesPerMeasure( String path) {
-
-        int cont = 0;
-        int algorithmSize = this.streams.get(0).algorithm.size();
-        int streamSize = this.streams.size();
-        int measureSize = this.streams.get(0).algorithm.get(0).measures.size();
-        while (cont != measureSize) {
-            String output = "";
-            output += "\\documentclass{article}\n";
-            output += "\\usepackage{multirow}\n\\usepackage{booktabs}\n\\begin{document}\n\\begin{table}[htbp]\n\\caption{Add caption}";
-            output += "\\begin{tabular}";
-            output += "{";
-            for (int i = 0; i < algorithmSize + 1; i++) {
-                output += "r";
-            }
-           
-            output += "}\n\\toprule\nAlgorithm";
-            for (int i = 0; i < algorithmSize; i++) {
-                output += "& " + this.streams.get(0).algorithm.get(i).name;
-            }
-            output += "\\\\";
-            output += "\n\\midrule\n";
-
-            for (int i = 0; i < streamSize; i++) {
-                List<Algorithm> alg = this.streams.get(i).algorithm;
-                output += this.streams.get(i).name;
-                for (int j = 0; j < algorithmSize; j++) {
-                    if (alg.get(j).measures.get(cont).isType()) {
-                        output += "&" + Algorithm.format(alg.get(j).measures.get(cont).getValue()) + "$\\,\\pm$"
-                                + Algorithm.format(alg.get(j).measures.get(cont).getStd());
-                    } else {      
-                        output += "&" + Algorithm.format1(alg.get(j).measures.get(cont).getValue());
-                    }
-                }
-                output += "\\\\\n";
-            }
-            output += "\\bottomrule\n\\end{tabular}%\n\\label{tab:addlabel}%\n\\end{table}%\n\\end{document}";
-            //PrintStream out = null;
-            String name = this.streams.get(0).algorithm.get(0).measures.get(cont).getName();
+		try {
+			BufferedWriter out = new BufferedWriter(new FileWriter(path + "summary.tex"));
+			out.write(output); // Replace with the string
+			// you are trying to write
+			out.close();
+		} catch (IOException e) {
+			System.out.println(" Error saving summary.tex");
+
+		}
+	}
+
+	/**
+	 * Generates a latex summary, in which the rows are the datasets and the columns
+	 * the algorithms.
+	 */
+	public void invertedSumariesPerMeasure(String path) {
+
+		int cont = 0;
+		int algorithmSize = this.streams.get(0).algorithm.size();
+		int streamSize = this.streams.size();
+		int measureSize = this.streams.get(0).algorithm.get(0).measures.size();
+		while (cont != measureSize) {
+			String output = "";
+			output += "\\documentclass{article}\n";
+			output += "\\usepackage{multirow}\n\\usepackage{booktabs}\n\\begin{document}\n\\begin{table}[htbp]\n\\caption{Add caption}";
+			output += "\\begin{tabular}";
+			output += "{";
+			for (int i = 0; i < algorithmSize + 1; i++) {
+				output += "r";
+			}
+
+			output += "}\n\\toprule\nAlgorithm";
+			for (int i = 0; i < algorithmSize; i++) {
+				output += "& " + this.streams.get(0).algorithm.get(i).name;
+			}
+			output += "\\\\";
+			output += "\n\\midrule\n";
+
+			for (int i = 0; i < streamSize; i++) {
+				List<Algorithm> alg = this.streams.get(i).algorithm;
+				output += this.streams.get(i).name;
+				for (int j = 0; j < algorithmSize; j++) {
+					if (alg.get(j).measures.get(cont).isType()) {
+						output += "&" + Algorithm.format(alg.get(j).measures.get(cont).getValue()) + "$\\,\\pm$"
+								+ Algorithm.format(alg.get(j).measures.get(cont).getStd());
+					} else {
+						output += "&" + Algorithm.format1(alg.get(j).measures.get(cont).getValue());
+					}
+				}
+				output += "\\\\\n";
+			}
+			output += "\\bottomrule\n\\end{tabular}%\n\\label{tab:addlabel}%\n\\end{table}%\n\\end{document}";
+			// PrintStream out = null;
+			String name = this.streams.get(0).algorithm.get(0).measures.get(cont).getName();
 //            try {
 //                out = new PrintStream(new BufferedOutputStream(new FileOutputStream(path + name + ".tex")));
 //            } catch (FileNotFoundException ex) {
@@ -199,131 +199,133 @@ public void invertedSumariesPerMeasure( String path) {
 //            System.setOut(out);
 //            System.out.println(output);
 //            out.close();
-             try {
-            BufferedWriter out = new BufferedWriter(new FileWriter(path + name + ".tex"));
-            out.write(output);  //Replace with the string 
-            //you are trying to write  
-            out.close();
-        } catch (IOException e) {
-            System.out.println("Error saving "+name + ".tex");
-
-        }
-            cont++;
-        }
-
-    }
-    /**
-     * The summaries are performed for each measure to be displayed in the user interface
-     * 
-     * @return SummaryTable
-     */
-    public SummaryTable[] showSummary(){
-        int cont = 0;
-        int algorithmSize = this.streams.get(0).algorithm.size();
-        int streamSize = this.streams.size();
-        int measureSize = this.streams.get(0).algorithm.get(0).measures.size();
-        summary = new SummaryTable[measureSize];
-        while (cont != measureSize) {
-           
-            summary[cont] = new SummaryTable();
-            summary[cont].measureName = this.streams.get(0).algorithm.get(0).measures.get(cont).getName();
-            summary[cont].algNames = new String[algorithmSize+1];
-            summary[cont].algNames[0] ="Algorithm";
-            summary[cont].value = new Object[streamSize][algorithmSize+1];
-           
-            for (int i = 0; i < algorithmSize; i++) {
-              
-                summary[cont].algNames[i+1] = this.streams.get(0).algorithm.get(i).name;
-            }
-            for (int i = 0; i < streamSize; i++) {
-                List<Algorithm> alg = this.streams.get(i).algorithm;
-                 summary[cont].value[i][0] = this.streams.get(i).name;  
-                for (int j = 0; j < algorithmSize; j++) {
-                    if (alg.get(j).measures.get(cont).isType()) {
-                        summary[cont].value[i][j+1] = Algorithm.format(alg.get(j).measures.get(cont).getValue())+"±"+
-                                    Algorithm.format(alg.get(j).measures.get(cont).getStd());
-                    } else {
-                        summary[cont].value[i][j+1] = Algorithm.format1(alg.get(j).measures.get(cont).getValue());
-                       
-                    }
-                }
-               
-            }
-                   
-            cont++;
-        }
-        return summary;
-    }
-
-    /**
-     * Generates an HTML summary, in which the rows are the datasets and the
-     * columns the algorithms.
-     */
-    public void generateHTML(String path) {
-      
-        String output = "";
-        output += "<TABLE BORDER=1 WIDTH=\"100%\" ALIGN=CENTER>\n";
-        output += "<CAPTION> Experiment";
-        output += "<TR> <TD>Algorithm <TD COLSPAN = 2>Measure";
-
-        //set algorithms names
-       
-        for (int i = 0; i < this.streams.size(); i++) {
-            output += "<TD>" + this.streams.get(i).getName();
-        }
-        output += "<TD>AVG";
-        int algorithmSize = this.streams.get(0).algorithm.size();
-        String name = "";
-        for (int i = 0; i < algorithmSize; i++) {
-            List<Algorithm> alg = this.streams.get(0).algorithm;
-            output += "<TR><TD ROWSPAN = " + /*alg.get(i).measures.size()*/ alg.get(i).measureStdSize + ">"
-                    + alg.get(i).name;
-            List<Measure> measures[] = alg.get(i).getMeasuresPerData(streams);
-            int cont = 0;
-            double sum = 0.0;
-            boolean isType = true;
-            while (cont != this.streams.get(0).algorithm.get(i).measures.size()) {
-                sum = 0;
-                name = measures[0].get(cont).getName();
-                if (measures[0].get(cont).isType()) {
-                    output += "<TD ROWSPAN = 2>" + name;
-                    output += "<TD>mean";
-                } else {
-                    output += "<TD>" + name;
-                    output += "<TD>Last value";
-                }
-                for (int j = 0; j < measures.length; j++) {
-                    //sum =0;
-                    if (measures[j].get(cont).isType()) {
-                        output += "<TD>" + Algorithm.format(measures[j].get(cont).getValue());
-
-                        sum += measures[j].get(cont).getValue();
-                        isType = true;
-                    } else {
-                        output += "<TD>" + Algorithm.format1(measures[j].get(cont).getValue());
-                        isType = false;
-                    }
-
-                }
-                if (isType) {
-                    double size = (double) this.streams.size();
-                    output += "<TD>" + Algorithm.format(sum / size);
-                    output += "<TR>";
-                    output += "<TD>std";
-                    for (int j = 0; j < measures.length; j++) {
-                        output += "<TD>" + Algorithm.format(measures[j].get(cont).getStd());
-                    }
-                    output += "<TD>" + "-";
-                } else {
-                    output += "<TD>" + "-";
-
-                }
-                output += "<TR>";
-                cont++;
-            }
-        }
-
-        output += "</TABLE>";
+			try {
+				BufferedWriter out = new BufferedWriter(new FileWriter(path + name + ".tex"));
+				out.write(output); // Replace with the string
+				// you are trying to write
+				out.close();
+			} catch (IOException e) {
+				System.out.println("Error saving " + name + ".tex");
+
+			}
+			cont++;
+		}
+
+	}
+
+	/**
+	 * The summaries are performed for each measure to be displayed in the user
+	 * interface
+	 * 
+	 * @return SummaryTable
+	 */
+	public SummaryTable[] showSummary() {
+		int cont = 0;
+		int algorithmSize = this.streams.get(0).algorithm.size();
+		int streamSize = this.streams.size();
+		int measureSize = this.streams.get(0).algorithm.get(0).measures.size();
+		summary = new SummaryTable[measureSize];
+		while (cont != measureSize) {
+
+			summary[cont] = new SummaryTable();
+			summary[cont].measureName = this.streams.get(0).algorithm.get(0).measures.get(cont).getName();
+			summary[cont].algNames = new String[algorithmSize + 1];
+			summary[cont].algNames[0] = "Algorithm";
+			summary[cont].value = new Object[streamSize][algorithmSize + 1];
+
+			for (int i = 0; i < algorithmSize; i++) {
+
+				summary[cont].algNames[i + 1] = this.streams.get(0).algorithm.get(i).name;
+			}
+			for (int i = 0; i < streamSize; i++) {
+				List<Algorithm> alg = this.streams.get(i).algorithm;
+				summary[cont].value[i][0] = this.streams.get(i).name;
+				for (int j = 0; j < algorithmSize; j++) {
+					if (alg.get(j).measures.get(cont).isType()) {
+						summary[cont].value[i][j + 1] = Algorithm.format(alg.get(j).measures.get(cont).getValue()) + "±"
+								+ Algorithm.format(alg.get(j).measures.get(cont).getStd());
+					} else {
+						summary[cont].value[i][j + 1] = Algorithm.format1(alg.get(j).measures.get(cont).getValue());
+
+					}
+				}
+
+			}
+
+			cont++;
+		}
+		return summary;
+	}
+
+	/**
+	 * Generates an HTML summary, in which the rows are the datasets and the columns
+	 * the algorithms.
+	 */
+	public void generateHTML(String path) {
+
+		String output = "";
+		output += "<TABLE BORDER=1 WIDTH=\"100%\" ALIGN=CENTER>\n";
+		output += "<CAPTION> Experiment";
+		output += "<TR> <TD>Algorithm <TD COLSPAN = 2>Measure";
+
+		// set algorithms names
+
+		for (int i = 0; i < this.streams.size(); i++) {
+			output += "<TD>" + this.streams.get(i).getName();
+		}
+		output += "<TD>AVG";
+		int algorithmSize = this.streams.get(0).algorithm.size();
+		String name = "";
+		for (int i = 0; i < algorithmSize; i++) {
+			List<Algorithm> alg = this.streams.get(0).algorithm;
+			output += "<TR><TD ROWSPAN = " + /* alg.get(i).measures.size() */ alg.get(i).measureStdSize + ">"
+					+ alg.get(i).name;
+			List<Measure> measures[] = alg.get(i).getMeasuresPerData(streams);
+			int cont = 0;
+			double sum = 0.0;
+			boolean isType = true;
+			while (cont != this.streams.get(0).algorithm.get(i).measures.size()) {
+				sum = 0;
+				name = measures[0].get(cont).getName();
+				if (measures[0].get(cont).isType()) {
+					output += "<TD ROWSPAN = 2>" + name;
+					output += "<TD>mean";
+				} else {
+					output += "<TD>" + name;
+					output += "<TD>Last value";
+				}
+				for (int j = 0; j < measures.length; j++) {
+					// sum =0;
+					if (measures[j].get(cont).isType()) {
+						output += "<TD>" + Algorithm.format(measures[j].get(cont).getValue());
+
+						sum += measures[j].get(cont).getValue();
+						isType = true;
+					} else {
+						output += "<TD>" + Algorithm.format1(measures[j].get(cont).getValue());
+						isType = false;
+					}
+
+				}
+				if (isType) {
+					double size = this.streams.size();
+					output += "<TD>" + Algorithm.format(sum / size);
+					output += "<TR>";
+					output += "<TD>std";
+					for (int j = 0; j < measures.length; j++) {
+						output += "<TD>" + Algorithm.format(measures[j].get(cont).getStd());
+					}
+					output += "<TD>" + "-";
+				} else {
+					output += "<TD>" + "-";
+
+				}
+				output += "<TR>";
+				cont++;
+			}
+		}
+
+		output += "</TABLE>";
 //        PrintStream out = null;
 //        try {
 //            out = new PrintStream(new BufferedOutputStream(new FileOutputStream(path + "summary.html")));
@@ -333,154 +335,143 @@ public void generateHTML(String path) {
 //        System.setOut(out);
 //        System.out.println(output);
 //        out.close();
-         try {
-            BufferedWriter out = new BufferedWriter(new FileWriter(path + "summary.html"));
-            out.write(output);  //Replace with the string 
-            //you are trying to write  
-            out.close();
-        } catch (IOException e) {
-            System.out.println("Error saving summary.html");
-
-        }
-
-    }
-
-    /**
-     * Generates a latex summary that shows the gains, loses or ties of each
-     * algorithm against each other, in a specific measure..
-     */
-    public void computeWinsTiesLossesLatex(String path) {
-
-        List<Algorithm> alg = this.streams.get(0).algorithm;
-        int algorithmSize = this.streams.get(0).algorithm.size();
-        String output = "";
-        output += "\\documentclass{article}\n";
-        output += "\\usepackage[latin9]{inputenc}\n"
-                + "\\usepackage{array}\n"
-                + "\\usepackage{rotfloat}\n"
-                + "\\usepackage{multirow}\n"
-                + "\n"
-                + "\\makeatletter\n"
-                + "\\providecommand{\\tabularnewline}{\\\\}\n"
-                + "\\usepackage{multirow}\n"
-                + "\\usepackage{booktabs}\n"
-                + "\\makeatother\n"
-                + "\n"
-                + "\\begin{document}\n"
-                + "\\begin{sidewaystable}\n"
-                + "\\centering \\caption{Add caption}\n\\begin{tabular}";
-        output += "{|r|r|";
-
-        for (int i = 2; i <= algorithmSize * 3; i++) {
-            if (i <= algorithmSize) {
-                output += "r";
-            } else {
-                if (i == algorithmSize * 3) {
-                    output += "|";
-                } else {
-                    output += "|r";
-                }
-            }
-        }
-        output += "}\n\\hline\n";
-        output += "\\multirow{2}{*}{Algorithm } & \\multirow{2}{*}{PM} &";
-        output += "\\multicolumn{3}{r|}{" + alg.get(1).name + "}";
-        for (int i = 2; i < algorithmSize; i++) {
-            output += " & \\multicolumn{3}{r|}{" + alg.get(i).name + "}";
-        }
-        output += "& \\multirow{2}{*}{AVG}\\tabularnewline\n";
-        output += "\\cline{3-" + (algorithmSize * 3 - 1) + "}\n";
-        output += " & & ";
-        output += "\\multicolumn{1}{r|}{W} & \\multicolumn{1}{r|}{L} & \\multicolumn{1}{r|}{T} & ";
-        for (int i = 2; i < algorithmSize; i++) {
-            output += "\\multicolumn{1}{r|}{W} & \\multicolumn{1}{r|}{L} & \\multicolumn{1}{r|}{T} & ";
-        }
-        output += "\\tabularnewline\n\\hline\n";
-        int range = 3;
-        int measuresSize = this.streams.get(0).algorithm.get(0).measures.size();
-        for (int i = 0; i < algorithmSize; i++) {
-            output += "\\multirow{" + alg.get(i).measures.size() + "}{*}" + "{" + alg.get(i).name + "}";
-            List<Measure> measureRow[] = alg.get(i).getMeasuresPerData(streams);
-            int cont = 0;
-
-            while (cont != measuresSize) {
-
-                //String name = measureRow[i].get(cont).getName();
-                String name = alg.get(i).measures.get(cont).getName();
-                output += " & " + name;
-                double sum = 0.0;
-
-                for (int j = 1; j < algorithmSize; j++) {
-                    List<Measure> measureCol[] = alg.get(j).getMeasuresPerData(streams);
-                    int win = 0, losses = 0, ties = 0;
-                    for (int k = 0; k < measureCol.length; k++) {
-                        double alg1 = measureRow[k].get(cont).getValue();
-                        double alg2 = measureCol[k].get(cont).getValue();
-                        if (j == 1) {
-                            sum += measureRow[k].get(cont).getValue();
-                        }
-                        if (measureRow[k].get(cont).isType()) {
-
-                            if (Algorithm.Round(alg1) > Algorithm.Round(alg2)) {
-                                win++;
-                            } else if (Algorithm.Round(alg1) < Algorithm.Round(alg2)) {
-                                losses++;
-                            } else {
-                                ties++;
-                            }
-                        } else {
-                            if (alg1 < alg2) {
-                                win++;
-                            } else if (alg1 > alg2) {
-                                losses++;
-                            } else {
-                                ties++;
-                            }
-                        }
-
-                    }
-                    if (i < j) {
-
-                        output += " & \\multicolumn{1}{r|}{" + win + "}";
-                        output += " & \\multicolumn{1}{r|}{" + losses + "}";
-                        output += " & \\multicolumn{1}{r|}{" + ties + "}";
-
-                    } else if (i == j) {
-                        output += " & \\multicolumn{1}{r}{}";
-                        output += " & \\multicolumn{1}{r}{}";
-                        output += " & \\multicolumn{1}{r|}{}";
-                    } else {
-                        output += " & \\multicolumn{1}{r}{}";
-                        output += " & \\multicolumn{1}{r}{}";
-                        output += " & \\multicolumn{1}{r}{}";
-
-                    }
-
-                }
-
-                sum = (double) sum / measureRow.length;
-                output += " & " + Algorithm.format(sum);
-
-                if (cont < measuresSize - 1) {
-                    output += "\\tabularnewline\n \\cline{2-2} \\cline{" + range + "-" + (algorithmSize * 3) + "}\n";
-                } else {
-                    if (i != algorithmSize - 1) {
-                        output += "\\tabularnewline\n \\cline{1-2} \\cline{" + range + "-" + (algorithmSize * 3) + "}\n";
-                    } else {
-                        output += "\\tabularnewline\n \\cline{1-" + (algorithmSize * 3) + "}\n";
-                    }
-                }
-
-                cont++;
-
-            }
-
-            range += 3;
-        }
-        output += "\\end{tabular}\\label{tab:addlabel}\n"
-                + "\\end{sidewaystable}\n"
-                + "\n"
-                + "\\end{document}";
+		try {
+			BufferedWriter out = new BufferedWriter(new FileWriter(path + "summary.html"));
+			out.write(output); // Replace with the string
+			// you are trying to write
+			out.close();
+		} catch (IOException e) {
+			System.out.println("Error saving summary.html");
+
+		}
+
+	}
+
+	/**
+	 * Generates a latex summary that shows the gains, loses or ties of each
+	 * algorithm against each other, in a specific measure..
+	 */
+	public void computeWinsTiesLossesLatex(String path) {
+
+		List<Algorithm> alg = this.streams.get(0).algorithm;
+		int algorithmSize = this.streams.get(0).algorithm.size();
+		String output = "";
+		output += "\\documentclass{article}\n";
+		output += "\\usepackage[latin9]{inputenc}\n" + "\\usepackage{array}\n" + "\\usepackage{rotfloat}\n"
+				+ "\\usepackage{multirow}\n" + "\n" + "\\makeatletter\n" + "\\providecommand{\\tabularnewline}{\\\\}\n"
+				+ "\\usepackage{multirow}\n" + "\\usepackage{booktabs}\n" + "\\makeatother\n" + "\n"
+				+ "\\begin{document}\n" + "\\begin{sidewaystable}\n"
+				+ "\\centering \\caption{Add caption}\n\\begin{tabular}";
+		output += "{|r|r|";
+
+		for (int i = 2; i <= algorithmSize * 3; i++) {
+			if (i <= algorithmSize) {
+				output += "r";
+			} else {
+				if (i == algorithmSize * 3) {
+					output += "|";
+				} else {
+					output += "|r";
+				}
+			}
+		}
+		output += "}\n\\hline\n";
+		output += "\\multirow{2}{*}{Algorithm } & \\multirow{2}{*}{PM} &";
+		output += "\\multicolumn{3}{r|}{" + alg.get(1).name + "}";
+		for (int i = 2; i < algorithmSize; i++) {
+			output += " & \\multicolumn{3}{r|}{" + alg.get(i).name + "}";
+		}
+		output += "& \\multirow{2}{*}{AVG}\\tabularnewline\n";
+		output += "\\cline{3-" + (algorithmSize * 3 - 1) + "}\n";
+		output += " & & ";
+		output += "\\multicolumn{1}{r|}{W} & \\multicolumn{1}{r|}{L} & \\multicolumn{1}{r|}{T} & ";
+		for (int i = 2; i < algorithmSize; i++) {
+			output += "\\multicolumn{1}{r|}{W} & \\multicolumn{1}{r|}{L} & \\multicolumn{1}{r|}{T} & ";
+		}
+		output += "\\tabularnewline\n\\hline\n";
+		int range = 3;
+		int measuresSize = this.streams.get(0).algorithm.get(0).measures.size();
+		for (int i = 0; i < algorithmSize; i++) {
+			output += "\\multirow{" + alg.get(i).measures.size() + "}{*}" + "{" + alg.get(i).name + "}";
+			List<Measure> measureRow[] = alg.get(i).getMeasuresPerData(streams);
+			int cont = 0;
+
+			while (cont != measuresSize) {
+
+				// String name = measureRow[i].get(cont).getName();
+				String name = alg.get(i).measures.get(cont).getName();
+				output += " & " + name;
+				double sum = 0.0;
+
+				for (int j = 1; j < algorithmSize; j++) {
+					List<Measure> measureCol[] = alg.get(j).getMeasuresPerData(streams);
+					int win = 0, losses = 0, ties = 0;
+					for (int k = 0; k < measureCol.length; k++) {
+						double alg1 = measureRow[k].get(cont).getValue();
+						double alg2 = measureCol[k].get(cont).getValue();
+						if (j == 1) {
+							sum += measureRow[k].get(cont).getValue();
+						}
+						if (measureRow[k].get(cont).isType()) {
+
+							if (Algorithm.Round(alg1) > Algorithm.Round(alg2)) {
+								win++;
+							} else if (Algorithm.Round(alg1) < Algorithm.Round(alg2)) {
+								losses++;
+							} else {
+								ties++;
+							}
+						} else {
+							if (alg1 < alg2) {
+								win++;
+							} else if (alg1 > alg2) {
+								losses++;
+							} else {
+								ties++;
+							}
+						}
+
+					}
+					if (i < j) {
+
+						output += " & \\multicolumn{1}{r|}{" + win + "}";
+						output += " & \\multicolumn{1}{r|}{" + losses + "}";
+						output += " & \\multicolumn{1}{r|}{" + ties + "}";
+
+					} else if (i == j) {
+						output += " & \\multicolumn{1}{r}{}";
+						output += " & \\multicolumn{1}{r}{}";
+						output += " & \\multicolumn{1}{r|}{}";
+					} else {
+						output += " & \\multicolumn{1}{r}{}";
+						output += " & \\multicolumn{1}{r}{}";
+						output += " & \\multicolumn{1}{r}{}";
+
+					}
+
+				}
+
+				sum = sum / measureRow.length;
+				output += " & " + Algorithm.format(sum);
+
+				if (cont < measuresSize - 1) {
+					output += "\\tabularnewline\n \\cline{2-2} \\cline{" + range + "-" + (algorithmSize * 3) + "}\n";
+				} else {
+					if (i != algorithmSize - 1) {
+						output += "\\tabularnewline\n \\cline{1-2} \\cline{" + range + "-" + (algorithmSize * 3)
+								+ "}\n";
+					} else {
+						output += "\\tabularnewline\n \\cline{1-" + (algorithmSize * 3) + "}\n";
+					}
+				}
+
+				cont++;
+
+			}
+
+			range += 3;
+		}
+		output += "\\end{tabular}\\label{tab:addlabel}\n" + "\\end{sidewaystable}\n" + "\n" + "\\end{document}";
 //        PrintStream out = null;
 //        try {
 //            out = new PrintStream(new BufferedOutputStream(new FileOutputStream(path + "summary.win.ties.losses.tex")));
@@ -490,51 +481,51 @@ public void computeWinsTiesLossesLatex(String path) {
 //        System.setOut(out);
 //        System.out.println(output);
 //        out.close();
-        try {
-            BufferedWriter out = new BufferedWriter(new FileWriter(path + "summary.win.ties.losses.tex"));
-            out.write(output);  //Replace with the string 
-            //you are trying to write  
-            out.close();
-        } catch (IOException e) {
-            System.out.println("Error saving summary.win.ties.losses.tex");
-
-        }
-
-    }
-
-    /**
-     * Generate a csv file for the statistical analysis.
-     */
-    public void generateCSV() {
-        
-        int cont = 0;
-        int algorithmSize = this.streams.get(0).algorithm.size();
-        int streamSize = this.streams.size();
-        int measureSize = this.streams.get(0).algorithm.get(0).measures.size();
-        
-        while (cont != measureSize) {
-            String output = "";
-            output += "Algorithm,";
-            output += this.streams.get(0).algorithm.get(0).name;
-            //Inicialize summary table
-            
-            for (int i = 1; i < algorithmSize; i++) {
-                output += "," + this.streams.get(0).algorithm.get(i).name;
-               
-            }
-            output += "\n";
-
-            for (int i = 0; i < streamSize; i++) {
-                List<Algorithm> alg = this.streams.get(i).algorithm;
-                output += this.streams.get(i).name;
-                for (int j = 0; j < algorithmSize; j++) {
-                    output += "," + alg.get(j).measures.get(cont).getValue();
-                    
-                }
-                output += "\n";
-            }
-            //PrintStream out = null;
-            String name = this.streams.get(0).algorithm.get(0).measures.get(cont).getName();
+		try {
+			BufferedWriter out = new BufferedWriter(new FileWriter(path + "summary.win.ties.losses.tex"));
+			out.write(output); // Replace with the string
+			// you are trying to write
+			out.close();
+		} catch (IOException e) {
+			System.out.println("Error saving summary.win.ties.losses.tex");
+
+		}
+
+	}
+
+	/**
+	 * Generate a csv file for the statistical analysis.
+	 */
+	public void generateCSV() {
+
+		int cont = 0;
+		int algorithmSize = this.streams.get(0).algorithm.size();
+		int streamSize = this.streams.size();
+		int measureSize = this.streams.get(0).algorithm.get(0).measures.size();
+
+		while (cont != measureSize) {
+			String output = "";
+			output += "Algorithm,";
+			output += this.streams.get(0).algorithm.get(0).name;
+			// Inicialize summary table
+
+			for (int i = 1; i < algorithmSize; i++) {
+				output += "," + this.streams.get(0).algorithm.get(i).name;
+
+			}
+			output += "\n";
+
+			for (int i = 0; i < streamSize; i++) {
+				List<Algorithm> alg = this.streams.get(i).algorithm;
+				output += this.streams.get(i).name;
+				for (int j = 0; j < algorithmSize; j++) {
+					output += "," + alg.get(j).measures.get(cont).getValue();
+
+				}
+				output += "\n";
+			}
+			// PrintStream out = null;
+			String name = this.streams.get(0).algorithm.get(0).measures.get(cont).getName();
 //            try {
 //                out = new PrintStream(new BufferedOutputStream(new FileOutputStream(path + name + ".csv")));
 //            } catch (FileNotFoundException ex) {
@@ -543,101 +534,101 @@ public void generateCSV() {
 //            System.setOut(out);
 //            System.out.println(output);
 //            out.close();
-            try {
-            BufferedWriter out = new BufferedWriter(new FileWriter(path + name + ".csv"));
-            out.write(output);  //Replace with the string 
-            //you are trying to write  
-            out.close();
-        } catch (IOException e) {
-            System.out.println(name + ".csv");
-
-        }
-            cont++;
-        }
-
-    }
-
-    /**
-     * Generates a HTML summary that shows the gains, loses or ties of each
-     * algorithm against each other, in a specific measure..
-     */
-    public void computeWinsTiesLossesHTML(String path) {
-
-        List<Algorithm> alg = this.streams.get(0).algorithm;
-        int algorithmSize = this.streams.get(0).algorithm.size();
-        String tablaSalida = "";
-        tablaSalida += "<TABLE BORDER=1 WIDTH=\"100%\" ALIGN=CENTER>\n";
-        tablaSalida += "<CAPTION> Experiment";
-        tablaSalida += "<TR> <TD ROWSPAN = 2>Algorithm <TD TD ROWSPAN = 2>PM";
-
-        for (int i = 1; i < algorithmSize; i++) {
-            tablaSalida += "<TD COLSPAN = 3>" + alg.get(i).name;
-        }
-        tablaSalida += "<TD>AVG";
-        tablaSalida += "<TR>";
-        for (int i = 1; i < algorithmSize; i++) {
-            tablaSalida += "<TD>" + "Wins" + "<TD>" + "Losses" + "<TD>" + "Ties";
-        }
-        for (int i = 0; i < algorithmSize; i++) {
-            tablaSalida += "<TR><TD ROWSPAN = " + alg.get(i).measures.size() + ">" + alg.get(i).name;
-            List<Measure> measureRow[] = alg.get(i).getMeasuresPerData(streams);
-            int cont = 0;
-            while (cont != this.streams.get(0).algorithm.get(i).measures.size()) {
-
-                //String name = measureRow[i].get(cont).getName();
-                String name = alg.get(i).measures.get(cont).getName();
-                tablaSalida += "<TD>" + name;
-                double sum = 0.0;
-
-                for (int j = 1; j < algorithmSize; j++) {
-                    List<Measure> measureCol[] = alg.get(j).getMeasuresPerData(streams);
-                    int win = 0, losses = 0, ties = 0;
-                    for (int k = 0; k < measureCol.length; k++) {
-                        double alg1 = measureRow[k].get(cont).getValue();
-                        double alg2 = measureCol[k].get(cont).getValue();
-                        if (j == 1) {
-                            sum += measureRow[k].get(cont).getValue();
-                        }
-                        if (measureRow[k].get(cont).isType()) {
-                            if (Algorithm.Round(alg1) > Algorithm.Round(alg2)) {
-                                win++;
-                            } else if (Algorithm.Round(alg1) < Algorithm.Round(alg2)) {
-                                losses++;
-                            } else {
-                                ties++;
-                            }
-                        } else {
-                            if (alg1 < alg2) {
-                                win++;
-                            } else if (alg1 > alg2) {
-                                losses++;
-                            } else {
-                                ties++;
-                            }
-                        }
-
-                    }
-
-                    if (i < j) {
-                        tablaSalida += "<TD>" + win;
-                        tablaSalida += "<TD>" + losses;
-                        tablaSalida += "<TD>" + ties;
-                    } else {
-                        tablaSalida += "<TD> ";
-                        tablaSalida += "<TD> ";
-                        tablaSalida += "<TD> ";
-                    }
-
-                }
-
-                sum = (double) sum / measureRow.length;
-                tablaSalida += "<TD>" + Algorithm.format(sum);
-                tablaSalida += "<TR>";
-                cont++;
-            }
-
-        }
-        tablaSalida += "</TABLE>";
+			try {
+				BufferedWriter out = new BufferedWriter(new FileWriter(path + name + ".csv"));
+				out.write(output); // Replace with the string
+				// you are trying to write
+				out.close();
+			} catch (IOException e) {
+				System.out.println(name + ".csv");
+
+			}
+			cont++;
+		}
+
+	}
+
+	/**
+	 * Generates a HTML summary that shows the gains, loses or ties of each
+	 * algorithm against each other, in a specific measure..
+	 */
+	public void computeWinsTiesLossesHTML(String path) {
+
+		List<Algorithm> alg = this.streams.get(0).algorithm;
+		int algorithmSize = this.streams.get(0).algorithm.size();
+		String tablaSalida = "";
+		tablaSalida += "<TABLE BORDER=1 WIDTH=\"100%\" ALIGN=CENTER>\n";
+		tablaSalida += "<CAPTION> Experiment";
+		tablaSalida += "<TR> <TD ROWSPAN = 2>Algorithm <TD TD ROWSPAN = 2>PM";
+
+		for (int i = 1; i < algorithmSize; i++) {
+			tablaSalida += "<TD COLSPAN = 3>" + alg.get(i).name;
+		}
+		tablaSalida += "<TD>AVG";
+		tablaSalida += "<TR>";
+		for (int i = 1; i < algorithmSize; i++) {
+			tablaSalida += "<TD>" + "Wins" + "<TD>" + "Losses" + "<TD>" + "Ties";
+		}
+		for (int i = 0; i < algorithmSize; i++) {
+			tablaSalida += "<TR><TD ROWSPAN = " + alg.get(i).measures.size() + ">" + alg.get(i).name;
+			List<Measure> measureRow[] = alg.get(i).getMeasuresPerData(streams);
+			int cont = 0;
+			while (cont != this.streams.get(0).algorithm.get(i).measures.size()) {
+
+				// String name = measureRow[i].get(cont).getName();
+				String name = alg.get(i).measures.get(cont).getName();
+				tablaSalida += "<TD>" + name;
+				double sum = 0.0;
+
+				for (int j = 1; j < algorithmSize; j++) {
+					List<Measure> measureCol[] = alg.get(j).getMeasuresPerData(streams);
+					int win = 0, losses = 0, ties = 0;
+					for (int k = 0; k < measureCol.length; k++) {
+						double alg1 = measureRow[k].get(cont).getValue();
+						double alg2 = measureCol[k].get(cont).getValue();
+						if (j == 1) {
+							sum += measureRow[k].get(cont).getValue();
+						}
+						if (measureRow[k].get(cont).isType()) {
+							if (Algorithm.Round(alg1) > Algorithm.Round(alg2)) {
+								win++;
+							} else if (Algorithm.Round(alg1) < Algorithm.Round(alg2)) {
+								losses++;
+							} else {
+								ties++;
+							}
+						} else {
+							if (alg1 < alg2) {
+								win++;
+							} else if (alg1 > alg2) {
+								losses++;
+							} else {
+								ties++;
+							}
+						}
+
+					}
+
+					if (i < j) {
+						tablaSalida += "<TD>" + win;
+						tablaSalida += "<TD>" + losses;
+						tablaSalida += "<TD>" + ties;
+					} else {
+						tablaSalida += "<TD> ";
+						tablaSalida += "<TD> ";
+						tablaSalida += "<TD> ";
+					}
+
+				}
+
+				sum = sum / measureRow.length;
+				tablaSalida += "<TD>" + Algorithm.format(sum);
+				tablaSalida += "<TR>";
+				cont++;
+			}
+
+		}
+		tablaSalida += "</TABLE>";
 //        PrintStream salida = null;
 //        try {
 //            salida = new PrintStream(new BufferedOutputStream(new FileOutputStream(path + "summary.win.ties.losses.html")));
@@ -647,17 +638,16 @@ public void computeWinsTiesLossesHTML(String path) {
 //        System.setOut(salida);
 //        System.out.println(tablaSalida);
 //        salida.close();
-          try {
-            BufferedWriter out = new BufferedWriter(new FileWriter(path + "summary.win.ties.losses.html"));
-            out.write(tablaSalida);  //Replace with the string 
-            //you are trying to write  
-            out.close();
-        } catch (IOException e) {
-            System.out.println("Error saving summary.win.ties.losses.html");
-
-        }
-        
-
-    }
+		try {
+			BufferedWriter out = new BufferedWriter(new FileWriter(path + "summary.win.ties.losses.html"));
+			out.write(tablaSalida); // Replace with the string
+			// you are trying to write
+			out.close();
+		} catch (IOException e) {
+			System.out.println("Error saving summary.win.ties.losses.html");
+
+		}
+
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/SummaryTab.java b/moa/src/main/java/moa/gui/experimentertab/SummaryTab.java
index 2bb62cde0..ad24b973a 100644
--- a/moa/src/main/java/moa/gui/experimentertab/SummaryTab.java
+++ b/moa/src/main/java/moa/gui/experimentertab/SummaryTab.java
@@ -1,6 +1,6 @@
 /*
  *    SummaryTab.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand 
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
  *    @author Alberto Verdecia Cabrera (averdeciac@gmail.com)
  *
  *    This program is free software; you can redistribute it and/or modify
@@ -15,13 +15,15 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab;
 
-import moa.gui.LookAndFeel;
-import nz.ac.waikato.cms.gui.core.BaseDirectoryChooser;
-import org.apache.commons.io.FilenameUtils;
+import java.awt.BorderLayout;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
 
 import javax.swing.DefaultCellEditor;
 import javax.swing.JComboBox;
@@ -32,11 +34,11 @@
 import javax.swing.JPanel;
 import javax.swing.table.DefaultTableModel;
 import javax.swing.table.TableColumn;
-import java.awt.BorderLayout;
-import java.io.File;
-import java.util.ArrayList;
-import java.util.LinkedList;
-import java.util.List;
+
+import org.apache.commons.io.FilenameUtils;
+
+import moa.gui.LookAndFeel;
+import nz.ac.waikato.cms.gui.core.BaseDirectoryChooser;
 
 /**
  * Summarize the performance measurements of different learning algorithms over
@@ -46,553 +48,525 @@
  */
 public class SummaryTab extends JPanel {
 
-    private javax.swing.JButton jButtonResults;
-    private javax.swing.JButton jButtonDelAlgoritm;
-    private javax.swing.JButton jButtonDelStream;
-    private javax.swing.JButton jButtonDelMeasure;
-    private javax.swing.JButton jButtonDleteRow;
-    private javax.swing.JButton jButtonSummarize;
-    private javax.swing.JButton jButtonAddMeasure;
-    private javax.swing.JButton jButtonShowSummary;
-    private javax.swing.JPanel jPanelConfig;
-    private javax.swing.JScrollPane jScrollPaneAlgorithms;
-    private javax.swing.JScrollPane jScrollPaneStreams;
-    private javax.swing.JScrollPane jScrollPaneMeasure;
-    private javax.swing.JTable jTableAlgoritms;
-    private javax.swing.JTable jTableStreams;
-    private javax.swing.JTable jTableMeasures;
-    private javax.swing.JTextField jTextFieldResultsPath;
-    private javax.swing.JComboBox jComboBoxMeasure;
-    private javax.swing.JComboBox option;
-    private javax.swing.JLabel jLabelResults;
-    private javax.swing.JLabel jLabelMeasure;
-    private DefaultTableModel algoritmModel;
-    private DefaultTableModel streamModel;
-    private DefaultTableModel measureModel;
-    public LinkedList<String> measures;
-    private ArrayList<String> algotithmID;
-    private LinkedList<String> algorithmNames;
-    private LinkedList<String> streamNames;
-    Summary summary;
-    ReadFile rf;
-
-    /**
-     * SummaryTab Constructor
-     */
-    public SummaryTab() {
-        initComponents();
-        measures = new LinkedList<>();
-        algotithmID = new ArrayList<>();
-        algorithmNames = new LinkedList<>();
-        streamNames    = new LinkedList<>();    
-        this.algoritmModel = (DefaultTableModel) jTableAlgoritms.getModel();
-        this.streamModel = (DefaultTableModel) jTableStreams.getModel();
-        this.measureModel = (DefaultTableModel) jTableMeasures.getModel();
-        TableColumn col = jTableMeasures.getColumnModel().getColumn(2);
-        String op[] = {"Mean", "Last Value"};
-        option = new JComboBox(op);
-        option.setSelectedIndex(0);
-        col.setCellEditor(new DefaultCellEditor(option));
-        TableColumn col1 = jTableMeasures.getColumnModel().getColumn(0);
-    }
-
-    private void initComponents() {
-        jPanelConfig = new javax.swing.JPanel();
-        jScrollPaneAlgorithms = new javax.swing.JScrollPane();
-        jTableAlgoritms = new javax.swing.JTable();
-        jScrollPaneStreams = new javax.swing.JScrollPane();
-        jTableStreams = new javax.swing.JTable();
-        jTextFieldResultsPath = new javax.swing.JTextField();
-        jButtonResults = new javax.swing.JButton();
-        jButtonAddMeasure = new javax.swing.JButton();
-        jButtonShowSummary = new javax.swing.JButton();
-        jScrollPaneMeasure = new javax.swing.JScrollPane();
-        jTableMeasures = new javax.swing.JTable();
-        jButtonDelAlgoritm = new javax.swing.JButton();
-        jButtonDelStream = new javax.swing.JButton();
-        jButtonDleteRow = new javax.swing.JButton();
-        jButtonSummarize = new javax.swing.JButton();
-        jButtonDelMeasure = new javax.swing.JButton();
-        jLabelResults = new javax.swing.JLabel();
-        jLabelMeasure = new javax.swing.JLabel();
-        jComboBoxMeasure = new javax.swing.JComboBox();
-
-        jPanelConfig.setBorder(javax.swing.BorderFactory.createTitledBorder(null, "Configure", javax.swing.border.TitledBorder.DEFAULT_JUSTIFICATION, javax.swing.border.TitledBorder.DEFAULT_POSITION, new java.awt.Font("Tahoma", 0, 12))); // NOI18N
-
-        jScrollPaneAlgorithms.setBorder(javax.swing.BorderFactory.createTitledBorder("Algorithms"));
-
-        jTableAlgoritms.setModel(new javax.swing.table.DefaultTableModel(
-                new Object[][]{},
-                new String[]{
-                    "Algorithm", "Algorithm ID"
-                }
-        ));
-        jTableAlgoritms.setEditingColumn(1);
-        jScrollPaneAlgorithms.setViewportView(jTableAlgoritms);
-
-        jScrollPaneStreams.setBorder(javax.swing.BorderFactory.createTitledBorder("Streams"));
-
-        jTableStreams.setModel(new javax.swing.table.DefaultTableModel(
-                new Object[][]{},
-                new String[]{
-                    "Stream", "Stream ID"
-                }
-        ));
-        jScrollPaneStreams.setViewportView(jTableStreams);
-
-        jTextFieldResultsPath.setEditable(true);
-        jLabelResults.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
-        jLabelResults.setLabelFor(jTextFieldResultsPath);
-        jLabelResults.setText("Result folder");
-        jButtonResults.setText("Browse");
-        jButtonResults.addActionListener(this::jButtonResultsActionPerformed);
-
-        jButtonAddMeasure.setText("Add Measure");
-        jButtonAddMeasure.setToolTipText("Add Measure");
-        jButtonAddMeasure.addActionListener((java.awt.event.ActionEvent evt) -> {
-            // jButtonRunActionPerformed(evt);
-        });
-
-        jTableMeasures.setModel(new javax.swing.table.DefaultTableModel(
-                new Object[][]{},
-                new String[]{
-                    "Measure", "Measure ID", "Option"
-                }
-        ));
-       
-        jScrollPaneMeasure.setBorder(javax.swing.BorderFactory.createTitledBorder("Performance measures"));
-        jScrollPaneMeasure.setViewportView(jTableMeasures);
-
-        jButtonDelAlgoritm.setText("Delete Algorithm");
-        jButtonDelAlgoritm.addActionListener(this::jButtonDelAlgoritmActionPerformed);
-
-        jButtonDelStream.setText("Delete Stream");
-        jButtonDelStream.addActionListener(this::jButtonDelStreamActionPerformed);
-
-        jButtonDelMeasure.setText("Delete Measure");
-        jButtonDelMeasure.addActionListener(this::jButtonDelMeasureActionPerformed);
-
-        jButtonSummarize.setText("Export Summary");
-        jButtonSummarize.setEnabled(false);
-        jButtonSummarize.addActionListener(this::jButtonSummaryActionPerformed);
-
-        jButtonShowSummary.setText("Show Summary");
-        jButtonShowSummary.setEnabled(true);
-        jButtonShowSummary.addActionListener(this::jButtonShowSummaryActionPerformed);
-
-        jLabelMeasure.setText("Measures");
-        jComboBoxMeasure.setModel(new javax.swing.DefaultComboBoxModel(new String[]{"--Slect--"}));
-        jButtonAddMeasure.addActionListener(this::jButtonAddMeasureActionPerformed);
-        /*prueba*/
-        JPanel jPanel1 = new JPanel();
-        jPanel1.setBorder(javax.swing.BorderFactory.createTitledBorder("Configuration"));
-        JLabel jLabelDirectory = new JLabel("Result folder");
-
-        javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1);
-        jPanel1.setLayout(jPanel1Layout);
-        jPanel1Layout.setHorizontalGroup(
-                jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                .addGroup(jPanel1Layout.createSequentialGroup()
-                        .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                                .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanel1Layout.createSequentialGroup()
-                                        .addGap(14, 14, 14)
-                                        .addComponent(jLabelDirectory)
-                                        .addGap(18, 18, 18)
-                                        .addComponent(jTextFieldResultsPath)
-                                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
-                                        .addComponent(jButtonResults))
-                                .addGroup(jPanel1Layout.createSequentialGroup()
-                                        .addContainerGap()
-                                        .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                                                .addComponent(jButtonDelAlgoritm)
-                                                .addComponent(jScrollPaneAlgorithms, javax.swing.GroupLayout.DEFAULT_SIZE, 341, Short.MAX_VALUE))
-                                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
-                                        .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                                                .addComponent(jScrollPaneStreams, javax.swing.GroupLayout.DEFAULT_SIZE, 332, Short.MAX_VALUE)
-                                                .addGroup(jPanel1Layout.createSequentialGroup()
-                                                        .addComponent(jButtonDelStream)
-                                                        .addGap(0, 0, Short.MAX_VALUE)))))
-                        .addGap(16, 16, 16))
-        );
-        jPanel1Layout.setVerticalGroup(
-                jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanel1Layout.createSequentialGroup()
-                        .addGap(23, 23, 23)
-                        .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                                .addComponent(jTextFieldResultsPath, javax.swing.GroupLayout.PREFERRED_SIZE, 23, javax.swing.GroupLayout.PREFERRED_SIZE)
-                                .addComponent(jButtonResults)
-                                .addComponent(jLabelDirectory))
-                        .addGap(18, 18, 18)
-                        .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                                .addComponent(jScrollPaneAlgorithms, javax.swing.GroupLayout.DEFAULT_SIZE, 305, Short.MAX_VALUE)
-                                .addComponent(jScrollPaneStreams, javax.swing.GroupLayout.PREFERRED_SIZE, 0, Short.MAX_VALUE))
-                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                        .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                                .addComponent(jButtonDelStream)
-                                .addComponent(jButtonDelAlgoritm)))
-        );
-
-        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
-        this.setLayout(layout);
-        layout.setHorizontalGroup(
-                layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                .addGap(0, 741, Short.MAX_VALUE)
-                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                        .addGroup(layout.createSequentialGroup()
-                                .addContainerGap()
-                                .addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
-                                .addContainerGap()))
-        );
-        layout.setVerticalGroup(
-                layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                .addGap(0, 443, Short.MAX_VALUE)
-                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                        .addGroup(layout.createSequentialGroup()
-                                .addContainerGap()
-                                .addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
-                                .addContainerGap()))
-        );
-        /*fin prueba*/
-        JPanel panelMeasure = new JPanel();
-        // JSplitPane splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
-
-        panelMeasure.setLayout(new BorderLayout());
-        panelMeasure.add(jLabelMeasure, BorderLayout.WEST);
-        panelMeasure.add(jComboBoxMeasure, BorderLayout.CENTER);
-        panelMeasure.add(jButtonAddMeasure, BorderLayout.EAST);
-        //Configure task table panel
-        JPanel panelMeasuresTable = new JPanel();
-        JPanel panelTaskTableBtn = new JPanel();
-        panelTaskTableBtn.add(jButtonShowSummary);
-        //panelTaskTableBtn.add(jButtonSummarize);
-        panelTaskTableBtn.add(jButtonDelMeasure);
-        panelMeasuresTable.setLayout(new BorderLayout());
-        panelMeasuresTable.add(panelMeasure, BorderLayout.NORTH);
-        panelMeasuresTable.add(jScrollPaneMeasure, BorderLayout.CENTER);
-        panelMeasuresTable.add(panelTaskTableBtn, BorderLayout.SOUTH);
-        // panelMeasuresTable.setPreferredSize(new Dimension(200,200));
-        //splitPane.setTopComponent(jPanel1);
-        //  splitPane.setBottomComponent(panelMeasuresTable);
-        //splitPane.setDividerLocation(100);
-        this.setLayout(new BorderLayout());
-        this.add(jPanel1, BorderLayout.NORTH);
-        this.add(panelMeasuresTable, BorderLayout.CENTER);
-        // this.add(splitPane);
-    }
-
-    private void jButtonDelAlgoritmActionPerformed(java.awt.event.ActionEvent evt) {
-        if (this.jTableAlgoritms.getSelectedRow() != -1) {
-            
-            this.algoritmModel.removeRow(this.jTableAlgoritms.getSelectedRow());
-            String algorithms[] = new String[algoritmModel.getRowCount()];
-            for (int i = 0; i < algoritmModel.getRowCount(); i++) {
-                algorithms[i] = algoritmModel.getValueAt(i, 0).toString();
-            }
-            
-            if (streamModel.getValueAt(0, 0).toString() != null) {
-                rf.updateMeasures(algorithms, streamModel.getValueAt(0, 0).toString());
-                this.measures = rf.getMeasures();
-                String measuresNames[] = measures.getFirst().split(",");
-                jComboBoxMeasure.removeAllItems();
-                for (String measuresName : measuresNames) {
-                    jComboBoxMeasure.addItem(measuresName);
-                }
-            }
-        }
-
-    }
-
-    private void jButtonDelStreamActionPerformed(java.awt.event.ActionEvent evt) {
-        this.streamModel.removeRow(this.jTableStreams.getSelectedRow());
-    }
-
-    private void jButtonDelMeasureActionPerformed(java.awt.event.ActionEvent evt) {
-        this.measureModel.removeRow(this.jTableMeasures.getSelectedRow());
-    }
-
-    private void jButtonAddMeasureActionPerformed(java.awt.event.ActionEvent evt) {
-        for (int i = 0; i < this.measureModel.getRowCount(); i++) {
-            if (jComboBoxMeasure.getSelectedItem().equals(this.measureModel.getValueAt(i, 0))) {
-                JOptionPane.showMessageDialog(this, "The value exist",
-                        "Error", JOptionPane.ERROR_MESSAGE);
-                return;
-            } else if (jComboBoxMeasure.getSelectedItem().equals("--Slect--")) {
-                JOptionPane.showMessageDialog(this, "There are not values",
-                        "Error", JOptionPane.ERROR_MESSAGE);
-                return;
-            }
-        }
-
-        this.measureModel.addRow(new Object[]{jComboBoxMeasure.getSelectedItem(),
-            jComboBoxMeasure.getSelectedItem(), "Mean"});
-
-    }
-
-    private void jButtonShowSummaryActionPerformed(java.awt.event.ActionEvent evt) {
-
-        if (this.jTextFieldResultsPath.getText().equals("")) {
-            JOptionPane.showMessageDialog(this, "Directory not found",
-                    "Error", JOptionPane.ERROR_MESSAGE);
-            return;
-        }
-        List<Measure> algmeasures = new ArrayList<>();
-        List<Stream> streams = new ArrayList<>();
-        List<String> algPath = new ArrayList<>();
-        List<String> algShortNames = new ArrayList<>();
-        int count = 0;
-        for (int i = 0; i < this.measureModel.getRowCount(); i++) {
-            for (int j = 0; j < this.jComboBoxMeasure.getItemCount(); j++) {
-                if (this.measureModel.getValueAt(i, 0).equals(this.jComboBoxMeasure.getItemAt(j))) {
-                    count++;
-                }
-                if (this.measureModel.getValueAt(i, 0).equals("") || this.measureModel.getValueAt(i, 1).equals("")
-                        || this.measureModel.getValueAt(i, 2) == null) {
-                    JOptionPane.showMessageDialog(this, "There are fields incompleted in Table",
-                            "Error", JOptionPane.ERROR_MESSAGE);
-                    return;
-                }
-
-            }
-        }
-        boolean type = true;
-        for (int k = 0; k < this.measureModel.getRowCount(); k++) {
-            type = this.measureModel.getValueAt(k, 2).equals("Mean");
-            Measure m = new Measure(this.measureModel.getValueAt(k, 1).toString(),this.measureModel.getValueAt(k, 0).toString(), type,0);
-            algmeasures.add(m);
-
-        }
-        String path = this.jTextFieldResultsPath.getText();
-        for (int i = 0; i < streamModel.getRowCount(); i++) {
-           
-            algPath.clear();
-            for (int j = 0; j < algoritmModel.getRowCount(); j++) {
-                File inputFile = new File(FilenameUtils.separatorsToSystem(
-                        path + "\\" + streamModel.getValueAt(i, 0) + "\\" + algoritmModel.getValueAt(j, 0)));
-                File streamFile = new File(FilenameUtils.separatorsToSystem(
-                        path + "\\" + streamModel.getValueAt(i, 0)));
-                if (!inputFile.exists()) {
-                    JOptionPane.showMessageDialog(this, "File not found: "
-                            + inputFile.getAbsolutePath(),
-                            "Error", JOptionPane.ERROR_MESSAGE);
-                    return;
-                } else {
-                    String algorithmPath = FilenameUtils.separatorsToSystem(
-                            path + "\\" + streamModel.getValueAt(i, 0).toString() + "\\"
-                            + algoritmModel.getValueAt(j, 0).toString());
-                    algPath.add(algorithmPath);
-                    if (i == 0) {
-                        algShortNames.add(algoritmModel.getValueAt(j, 1).toString());
-                    }
-                   
-                }
-            }
-            Stream s = new Stream(streamModel.getValueAt(i, 1).toString(), algPath, algShortNames, algmeasures);
-            streams.add(s);
-        }
-
-        //create summary
-        try {
-            summary = new Summary(streams, FilenameUtils.separatorsToSystem(path + "\\"));
-            jButtonSummarize.setEnabled(true);
-            SummaryTable[] table = summary.showSummary();
-            SummaryViewer summaryViewer = new SummaryViewer(table, summary,jTextFieldResultsPath.getText());
-
-        } catch (Exception exc) {
-            JOptionPane.showMessageDialog(this, "Problems generating summaries",
-                    "Error", JOptionPane.ERROR_MESSAGE);
-
-        }
-
-    }
-
-    private void jButtonSummaryActionPerformed(java.awt.event.ActionEvent evt) {
-
-    }
-
-    private void jButtonResultsActionPerformed(java.awt.event.ActionEvent evt) {
-        BaseDirectoryChooser resultsDir = new BaseDirectoryChooser();
-        resultsDir.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
-        int selection = -1;
-        String path = "";
-        selection = resultsDir.showOpenDialog(this);
-
-        if (selection == JFileChooser.APPROVE_OPTION) {
-
-            try {
-                path = resultsDir.getSelectedFile().getAbsolutePath();
-                readData(path);
-
-            } catch (Exception exp) {
-                JOptionPane.showMessageDialog(this, "Problem with path",
-                        "Error", JOptionPane.ERROR_MESSAGE);
-
-            }
-
-        }
-
-    }
-    
-    public void summaryCMD(String[] measures, String[] types){
-         List<Measure> algmeasures = new ArrayList<>();
-        List<Stream> streams = new ArrayList<>();
-        List<String> algPath = new ArrayList<>();
-        List<String> algShortNames = new ArrayList<>();
-       
-     
-        boolean type = true;
-        for (int k = 0; k < measures.length; k++) {
-            type = types[k].equals("Mean");
-            Measure m = new Measure(measures[k],measures[k], type,0);
-            algmeasures.add(m);
-
-        }
-        String path = this.jTextFieldResultsPath.getText();
-        for (int i = 0; i < streamModel.getRowCount(); i++) {
-           
-            algPath.clear();
-            for (int j = 0; j < algoritmModel.getRowCount(); j++) {
-                File inputFile = new File(FilenameUtils.separatorsToSystem(
-                        path + "\\" + streamModel.getValueAt(i, 0) + "\\" + algoritmModel.getValueAt(j, 0)));
-                File streamFile = new File(FilenameUtils.separatorsToSystem(
-                        path + "\\" + streamModel.getValueAt(i, 0)));
-                if (!inputFile.exists()) {
-                    System.out.println("File not found: "+ inputFile.getAbsolutePath());
-                            
-                    return;
-                } else {
-                    String algorithmPath = FilenameUtils.separatorsToSystem(
-                            path + "\\" + streamModel.getValueAt(i, 0).toString() + "\\"
-                            + algoritmModel.getValueAt(j, 0).toString());
-                    algPath.add(algorithmPath);
-                    if (i == 0) {
-                        algShortNames.add(algoritmModel.getValueAt(j, 1).toString());
-                    }
-                   
-                }
-            }
-            Stream s = new Stream(streamModel.getValueAt(i, 1).toString(), algPath, algShortNames, algmeasures);
-            streams.add(s);
-        }
-
-        //create summary
-        try {
-            summary = new Summary(streams, FilenameUtils.separatorsToSystem(path + File.separator));
-            jButtonSummarize.setEnabled(true);
-            String summaryPath = this.jTextFieldResultsPath.getText()+File.separator;
-            
-                    summary.invertedSumariesPerMeasure(summaryPath);
-                    summary.computeWinsTiesLossesHTML(summaryPath);
-                    summary.computeWinsTiesLossesLatex(summaryPath);
-                    summary.generateHTML(summaryPath);
-                    summary.generateLatex(summaryPath);
-                   System.out.println("Summaries created at: " + summaryPath);
-
-        } catch (Exception exc) {
-           //  System.err.println("Problems generating summaries");
-                    
-
-        }
-
-    }
-    
-    /**
-     * Allows to read the results file and update the corresponding fields.
-     *
-     * @param path
-     */
-    public void readData(String path) {
-        jTextFieldResultsPath.setText(path);
-        cleanTables();
-        rf = new ReadFile(path);
-        String str = rf.processFiles();
-        if (str.equals("")) {
-             algotithmID = rf.getAlgShortNames();
-             algorithmNames = rf.getAlgNames();
-             streamNames = rf.getStream();
-            this.measures = rf.getMeasures();
-            //Set algorithms an streams
-            for (int i = 0; i < algotithmID.size(); i++) {
-                this.algoritmModel.addRow(new Object[]{algorithmNames.get(i), algotithmID.get(i)});
-            }
-            streamNames.stream().forEach((streamName) -> {
-                this.streamModel.addRow(new Object[]{streamName, streamName});
-            });
-
-            // set the measures into the combobox
-            String measuresNames[] = measures.getFirst().split(",");
-            jComboBoxMeasure.removeAllItems();
-            for (String measuresName : measuresNames) {
-                jComboBoxMeasure.addItem(measuresName);
-            }
-
-        } else {
-
-            JOptionPane.showMessageDialog(this, str,
-                    "Error", JOptionPane.ERROR_MESSAGE);
-        }
-
-    }
-
-    /**
-     * Clean the tables
-     */
-    public void cleanTables() {
-        try {
-            DefaultTableModel algModel = (DefaultTableModel) jTableAlgoritms.getModel();
-            DefaultTableModel strModel = (DefaultTableModel) jTableStreams.getModel();
-            DefaultTableModel measureModel = (DefaultTableModel) jTableMeasures.getModel();
-            int rows = jTableAlgoritms.getRowCount();
-            int srow = jTableStreams.getRowCount();
-            int trow = this.jTableMeasures.getRowCount();
-            for (int i = 0; i < rows; i++) {
-                algModel.removeRow(0);
-            }
-            for (int i = 0; i < srow; i++) {
-                strModel.removeRow(0);
-            }
-            for (int i = 0; i < trow; i++) {
-                this.measureModel.removeRow(0);
-            }
-        } catch (Exception e) {
-            JOptionPane.showMessageDialog(null, "Error cleaning the table.");
-        }
-        jButtonSummarize.setEnabled(false);
-    }
-
-    private static void createAndShowGUI() {
-
-        // Create and set up the window.
-        JFrame frame = new JFrame("Test");
-        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-
-        // Create and set up the content pane.
-        JPanel panel = new SummaryTab();
-        panel.setOpaque(true); // content panes must be opaque
-        frame.setContentPane(panel);
-
-        // Display the window.
-        frame.pack();
-        frame.setVisible(true);
-    }
-
-    /**
-     * The main method
-     *
-     * @param args
-     */
-    public static void main(String[] args) {
-        try {
-            LookAndFeel.install();
-            javax.swing.SwingUtilities.invokeLater(new Runnable() {
-
-                @Override
-                public void run() {
-                    createAndShowGUI();
-                }
-            });
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
+	private javax.swing.JButton jButtonResults;
+	private javax.swing.JButton jButtonDelAlgoritm;
+	private javax.swing.JButton jButtonDelStream;
+	private javax.swing.JButton jButtonDelMeasure;
+	private javax.swing.JButton jButtonDleteRow;
+	private javax.swing.JButton jButtonSummarize;
+	private javax.swing.JButton jButtonAddMeasure;
+	private javax.swing.JButton jButtonShowSummary;
+	private javax.swing.JPanel jPanelConfig;
+	private javax.swing.JScrollPane jScrollPaneAlgorithms;
+	private javax.swing.JScrollPane jScrollPaneStreams;
+	private javax.swing.JScrollPane jScrollPaneMeasure;
+	private javax.swing.JTable jTableAlgoritms;
+	private javax.swing.JTable jTableStreams;
+	private javax.swing.JTable jTableMeasures;
+	private javax.swing.JTextField jTextFieldResultsPath;
+	private javax.swing.JComboBox jComboBoxMeasure;
+	private javax.swing.JComboBox option;
+	private javax.swing.JLabel jLabelResults;
+	private javax.swing.JLabel jLabelMeasure;
+	private DefaultTableModel algoritmModel;
+	private DefaultTableModel streamModel;
+	private DefaultTableModel measureModel;
+	public LinkedList<String> measures;
+	private ArrayList<String> algotithmID;
+	private LinkedList<String> algorithmNames;
+	private LinkedList<String> streamNames;
+	Summary summary;
+	ReadFile rf;
+
+	/**
+	 * SummaryTab Constructor
+	 */
+	public SummaryTab() {
+		initComponents();
+		measures = new LinkedList<>();
+		algotithmID = new ArrayList<>();
+		algorithmNames = new LinkedList<>();
+		streamNames = new LinkedList<>();
+		this.algoritmModel = (DefaultTableModel) jTableAlgoritms.getModel();
+		this.streamModel = (DefaultTableModel) jTableStreams.getModel();
+		this.measureModel = (DefaultTableModel) jTableMeasures.getModel();
+		TableColumn col = jTableMeasures.getColumnModel().getColumn(2);
+		String op[] = { "Mean", "Last Value" };
+		option = new JComboBox(op);
+		option.setSelectedIndex(0);
+		col.setCellEditor(new DefaultCellEditor(option));
+		TableColumn col1 = jTableMeasures.getColumnModel().getColumn(0);
+	}
+
+	private void initComponents() {
+		jPanelConfig = new javax.swing.JPanel();
+		jScrollPaneAlgorithms = new javax.swing.JScrollPane();
+		jTableAlgoritms = new javax.swing.JTable();
+		jScrollPaneStreams = new javax.swing.JScrollPane();
+		jTableStreams = new javax.swing.JTable();
+		jTextFieldResultsPath = new javax.swing.JTextField();
+		jButtonResults = new javax.swing.JButton();
+		jButtonAddMeasure = new javax.swing.JButton();
+		jButtonShowSummary = new javax.swing.JButton();
+		jScrollPaneMeasure = new javax.swing.JScrollPane();
+		jTableMeasures = new javax.swing.JTable();
+		jButtonDelAlgoritm = new javax.swing.JButton();
+		jButtonDelStream = new javax.swing.JButton();
+		jButtonDleteRow = new javax.swing.JButton();
+		jButtonSummarize = new javax.swing.JButton();
+		jButtonDelMeasure = new javax.swing.JButton();
+		jLabelResults = new javax.swing.JLabel();
+		jLabelMeasure = new javax.swing.JLabel();
+		jComboBoxMeasure = new javax.swing.JComboBox();
+
+		jPanelConfig.setBorder(javax.swing.BorderFactory.createTitledBorder(null, "Configure",
+				javax.swing.border.TitledBorder.DEFAULT_JUSTIFICATION, javax.swing.border.TitledBorder.DEFAULT_POSITION,
+				new java.awt.Font("Tahoma", 0, 12))); // NOI18N
+
+		jScrollPaneAlgorithms.setBorder(javax.swing.BorderFactory.createTitledBorder("Algorithms"));
+
+		jTableAlgoritms.setModel(new javax.swing.table.DefaultTableModel(new Object[][] {},
+				new String[] { "Algorithm", "Algorithm ID" }));
+		jTableAlgoritms.setEditingColumn(1);
+		jScrollPaneAlgorithms.setViewportView(jTableAlgoritms);
+
+		jScrollPaneStreams.setBorder(javax.swing.BorderFactory.createTitledBorder("Streams"));
+
+		jTableStreams.setModel(
+				new javax.swing.table.DefaultTableModel(new Object[][] {}, new String[] { "Stream", "Stream ID" }));
+		jScrollPaneStreams.setViewportView(jTableStreams);
+
+		jTextFieldResultsPath.setEditable(true);
+		jLabelResults.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
+		jLabelResults.setLabelFor(jTextFieldResultsPath);
+		jLabelResults.setText("Result folder");
+		jButtonResults.setText("Browse");
+		jButtonResults.addActionListener(this::jButtonResultsActionPerformed);
+
+		jButtonAddMeasure.setText("Add Measure");
+		jButtonAddMeasure.setToolTipText("Add Measure");
+		jButtonAddMeasure.addActionListener((java.awt.event.ActionEvent evt) -> {
+			// jButtonRunActionPerformed(evt);
+		});
+
+		jTableMeasures.setModel(new javax.swing.table.DefaultTableModel(new Object[][] {},
+				new String[] { "Measure", "Measure ID", "Option" }));
+
+		jScrollPaneMeasure.setBorder(javax.swing.BorderFactory.createTitledBorder("Performance measures"));
+		jScrollPaneMeasure.setViewportView(jTableMeasures);
+
+		jButtonDelAlgoritm.setText("Delete Algorithm");
+		jButtonDelAlgoritm.addActionListener(this::jButtonDelAlgoritmActionPerformed);
+
+		jButtonDelStream.setText("Delete Stream");
+		jButtonDelStream.addActionListener(this::jButtonDelStreamActionPerformed);
+
+		jButtonDelMeasure.setText("Delete Measure");
+		jButtonDelMeasure.addActionListener(this::jButtonDelMeasureActionPerformed);
+
+		jButtonSummarize.setText("Export Summary");
+		jButtonSummarize.setEnabled(false);
+		jButtonSummarize.addActionListener(this::jButtonSummaryActionPerformed);
+
+		jButtonShowSummary.setText("Show Summary");
+		jButtonShowSummary.setEnabled(true);
+		jButtonShowSummary.addActionListener(this::jButtonShowSummaryActionPerformed);
+
+		jLabelMeasure.setText("Measures");
+		jComboBoxMeasure.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "--Slect--" }));
+		jButtonAddMeasure.addActionListener(this::jButtonAddMeasureActionPerformed);
+		/* prueba */
+		JPanel jPanel1 = new JPanel();
+		jPanel1.setBorder(javax.swing.BorderFactory.createTitledBorder("Configuration"));
+		JLabel jLabelDirectory = new JLabel("Result folder");
+
+		javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1);
+		jPanel1.setLayout(jPanel1Layout);
+		jPanel1Layout.setHorizontalGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+				.addGroup(jPanel1Layout.createSequentialGroup().addGroup(jPanel1Layout
+						.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+						.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
+								jPanel1Layout.createSequentialGroup().addGap(14, 14, 14).addComponent(jLabelDirectory)
+										.addGap(18, 18, 18).addComponent(jTextFieldResultsPath)
+										.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
+										.addComponent(jButtonResults))
+						.addGroup(jPanel1Layout.createSequentialGroup().addContainerGap()
+								.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+										.addComponent(jButtonDelAlgoritm).addComponent(jScrollPaneAlgorithms,
+												javax.swing.GroupLayout.DEFAULT_SIZE, 341, Short.MAX_VALUE))
+								.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
+								.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+										.addComponent(jScrollPaneStreams, javax.swing.GroupLayout.DEFAULT_SIZE, 332,
+												Short.MAX_VALUE)
+										.addGroup(jPanel1Layout.createSequentialGroup().addComponent(jButtonDelStream)
+												.addGap(0, 0, Short.MAX_VALUE)))))
+						.addGap(16, 16, 16)));
+		jPanel1Layout.setVerticalGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+				.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
+						jPanel1Layout.createSequentialGroup().addGap(23, 23, 23)
+								.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+										.addComponent(jTextFieldResultsPath, javax.swing.GroupLayout.PREFERRED_SIZE, 23,
+												javax.swing.GroupLayout.PREFERRED_SIZE)
+										.addComponent(jButtonResults).addComponent(jLabelDirectory))
+								.addGap(18, 18, 18)
+								.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+										.addComponent(jScrollPaneAlgorithms, javax.swing.GroupLayout.DEFAULT_SIZE, 305,
+												Short.MAX_VALUE)
+										.addComponent(jScrollPaneStreams, javax.swing.GroupLayout.PREFERRED_SIZE, 0,
+												Short.MAX_VALUE))
+								.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+								.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+										.addComponent(jButtonDelStream).addComponent(jButtonDelAlgoritm))));
+
+		javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
+		this.setLayout(layout);
+		layout.setHorizontalGroup(
+				layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 741, Short.MAX_VALUE)
+						.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+								.addGroup(layout.createSequentialGroup().addContainerGap()
+										.addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE,
+												javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
+										.addContainerGap())));
+		layout.setVerticalGroup(
+				layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 443, Short.MAX_VALUE)
+						.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+								.addGroup(layout.createSequentialGroup().addContainerGap()
+										.addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE,
+												javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
+										.addContainerGap())));
+		/* fin prueba */
+		JPanel panelMeasure = new JPanel();
+		// JSplitPane splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
+
+		panelMeasure.setLayout(new BorderLayout());
+		panelMeasure.add(jLabelMeasure, BorderLayout.WEST);
+		panelMeasure.add(jComboBoxMeasure, BorderLayout.CENTER);
+		panelMeasure.add(jButtonAddMeasure, BorderLayout.EAST);
+		// Configure task table panel
+		JPanel panelMeasuresTable = new JPanel();
+		JPanel panelTaskTableBtn = new JPanel();
+		panelTaskTableBtn.add(jButtonShowSummary);
+		// panelTaskTableBtn.add(jButtonSummarize);
+		panelTaskTableBtn.add(jButtonDelMeasure);
+		panelMeasuresTable.setLayout(new BorderLayout());
+		panelMeasuresTable.add(panelMeasure, BorderLayout.NORTH);
+		panelMeasuresTable.add(jScrollPaneMeasure, BorderLayout.CENTER);
+		panelMeasuresTable.add(panelTaskTableBtn, BorderLayout.SOUTH);
+		// panelMeasuresTable.setPreferredSize(new Dimension(200,200));
+		// splitPane.setTopComponent(jPanel1);
+		// splitPane.setBottomComponent(panelMeasuresTable);
+		// splitPane.setDividerLocation(100);
+		this.setLayout(new BorderLayout());
+		this.add(jPanel1, BorderLayout.NORTH);
+		this.add(panelMeasuresTable, BorderLayout.CENTER);
+		// this.add(splitPane);
+	}
+
+	private void jButtonDelAlgoritmActionPerformed(java.awt.event.ActionEvent evt) {
+		if (this.jTableAlgoritms.getSelectedRow() != -1) {
+
+			this.algoritmModel.removeRow(this.jTableAlgoritms.getSelectedRow());
+			String algorithms[] = new String[algoritmModel.getRowCount()];
+			for (int i = 0; i < algoritmModel.getRowCount(); i++) {
+				algorithms[i] = algoritmModel.getValueAt(i, 0).toString();
+			}
+
+			if (streamModel.getValueAt(0, 0).toString() != null) {
+				rf.updateMeasures(algorithms, streamModel.getValueAt(0, 0).toString());
+				this.measures = rf.getMeasures();
+				String measuresNames[] = measures.getFirst().split(",");
+				jComboBoxMeasure.removeAllItems();
+				for (String measuresName : measuresNames) {
+					jComboBoxMeasure.addItem(measuresName);
+				}
+			}
+		}
+
+	}
+
+	private void jButtonDelStreamActionPerformed(java.awt.event.ActionEvent evt) {
+		this.streamModel.removeRow(this.jTableStreams.getSelectedRow());
+	}
+
+	private void jButtonDelMeasureActionPerformed(java.awt.event.ActionEvent evt) {
+		this.measureModel.removeRow(this.jTableMeasures.getSelectedRow());
+	}
+
+	private void jButtonAddMeasureActionPerformed(java.awt.event.ActionEvent evt) {
+		for (int i = 0; i < this.measureModel.getRowCount(); i++) {
+			if (jComboBoxMeasure.getSelectedItem().equals(this.measureModel.getValueAt(i, 0))) {
+				JOptionPane.showMessageDialog(this, "The value exist", "Error", JOptionPane.ERROR_MESSAGE);
+				return;
+			} else if (jComboBoxMeasure.getSelectedItem().equals("--Slect--")) {
+				JOptionPane.showMessageDialog(this, "There are not values", "Error", JOptionPane.ERROR_MESSAGE);
+				return;
+			}
+		}
+
+		this.measureModel.addRow(
+				new Object[] { jComboBoxMeasure.getSelectedItem(), jComboBoxMeasure.getSelectedItem(), "Mean" });
+
+	}
+
+	private void jButtonShowSummaryActionPerformed(java.awt.event.ActionEvent evt) {
+
+		if (this.jTextFieldResultsPath.getText().equals("")) {
+			JOptionPane.showMessageDialog(this, "Directory not found", "Error", JOptionPane.ERROR_MESSAGE);
+			return;
+		}
+		List<Measure> algmeasures = new ArrayList<>();
+		List<Stream> streams = new ArrayList<>();
+		List<String> algPath = new ArrayList<>();
+		List<String> algShortNames = new ArrayList<>();
+		int count = 0;
+		for (int i = 0; i < this.measureModel.getRowCount(); i++) {
+			for (int j = 0; j < this.jComboBoxMeasure.getItemCount(); j++) {
+				if (this.measureModel.getValueAt(i, 0).equals(this.jComboBoxMeasure.getItemAt(j))) {
+					count++;
+				}
+				if (this.measureModel.getValueAt(i, 0).equals("") || this.measureModel.getValueAt(i, 1).equals("")
+						|| this.measureModel.getValueAt(i, 2) == null) {
+					JOptionPane.showMessageDialog(this, "There are fields incompleted in Table", "Error",
+							JOptionPane.ERROR_MESSAGE);
+					return;
+				}
+
+			}
+		}
+		boolean type = true;
+		for (int k = 0; k < this.measureModel.getRowCount(); k++) {
+			type = this.measureModel.getValueAt(k, 2).equals("Mean");
+			Measure m = new Measure(this.measureModel.getValueAt(k, 1).toString(),
+					this.measureModel.getValueAt(k, 0).toString(), type, 0);
+			algmeasures.add(m);
+
+		}
+		String path = this.jTextFieldResultsPath.getText();
+		for (int i = 0; i < streamModel.getRowCount(); i++) {
+
+			algPath.clear();
+			for (int j = 0; j < algoritmModel.getRowCount(); j++) {
+				File inputFile = new File(FilenameUtils.separatorsToSystem(
+						path + "\\" + streamModel.getValueAt(i, 0) + "\\" + algoritmModel.getValueAt(j, 0)));
+				File streamFile = new File(
+						FilenameUtils.separatorsToSystem(path + "\\" + streamModel.getValueAt(i, 0)));
+				if (!inputFile.exists()) {
+					JOptionPane.showMessageDialog(this, "File not found: " + inputFile.getAbsolutePath(), "Error",
+							JOptionPane.ERROR_MESSAGE);
+					return;
+				} else {
+					String algorithmPath = FilenameUtils
+							.separatorsToSystem(path + "\\" + streamModel.getValueAt(i, 0).toString() + "\\"
+									+ algoritmModel.getValueAt(j, 0).toString());
+					algPath.add(algorithmPath);
+					if (i == 0) {
+						algShortNames.add(algoritmModel.getValueAt(j, 1).toString());
+					}
+
+				}
+			}
+			Stream s = new Stream(streamModel.getValueAt(i, 1).toString(), algPath, algShortNames, algmeasures);
+			streams.add(s);
+		}
+
+		// create summary
+		try {
+			summary = new Summary(streams, FilenameUtils.separatorsToSystem(path + "\\"));
+			jButtonSummarize.setEnabled(true);
+			SummaryTable[] table = summary.showSummary();
+			SummaryViewer summaryViewer = new SummaryViewer(table, summary, jTextFieldResultsPath.getText());
+
+		} catch (Exception exc) {
+			JOptionPane.showMessageDialog(this, "Problems generating summaries", "Error", JOptionPane.ERROR_MESSAGE);
+
+		}
+
+	}
+
+	private void jButtonSummaryActionPerformed(java.awt.event.ActionEvent evt) {
+
+	}
+
+	private void jButtonResultsActionPerformed(java.awt.event.ActionEvent evt) {
+		BaseDirectoryChooser resultsDir = new BaseDirectoryChooser();
+		resultsDir.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
+		int selection = -1;
+		String path = "";
+		selection = resultsDir.showOpenDialog(this);
+
+		if (selection == JFileChooser.APPROVE_OPTION) {
+
+			try {
+				path = resultsDir.getSelectedFile().getAbsolutePath();
+				readData(path);
+
+			} catch (Exception exp) {
+				JOptionPane.showMessageDialog(this, "Problem with path", "Error", JOptionPane.ERROR_MESSAGE);
+
+			}
+
+		}
+
+	}
+
+	public void summaryCMD(String[] measures, String[] types) {
+		List<Measure> algmeasures = new ArrayList<>();
+		List<Stream> streams = new ArrayList<>();
+		List<String> algPath = new ArrayList<>();
+		List<String> algShortNames = new ArrayList<>();
+
+		boolean type = true;
+		for (int k = 0; k < measures.length; k++) {
+			type = types[k].equals("Mean");
+			Measure m = new Measure(measures[k], measures[k], type, 0);
+			algmeasures.add(m);
+
+		}
+		String path = this.jTextFieldResultsPath.getText();
+		for (int i = 0; i < streamModel.getRowCount(); i++) {
+
+			algPath.clear();
+			for (int j = 0; j < algoritmModel.getRowCount(); j++) {
+				File inputFile = new File(FilenameUtils.separatorsToSystem(
+						path + "\\" + streamModel.getValueAt(i, 0) + "\\" + algoritmModel.getValueAt(j, 0)));
+				File streamFile = new File(
+						FilenameUtils.separatorsToSystem(path + "\\" + streamModel.getValueAt(i, 0)));
+				if (!inputFile.exists()) {
+					System.out.println("File not found: " + inputFile.getAbsolutePath());
+
+					return;
+				} else {
+					String algorithmPath = FilenameUtils
+							.separatorsToSystem(path + "\\" + streamModel.getValueAt(i, 0).toString() + "\\"
+									+ algoritmModel.getValueAt(j, 0).toString());
+					algPath.add(algorithmPath);
+					if (i == 0) {
+						algShortNames.add(algoritmModel.getValueAt(j, 1).toString());
+					}
+
+				}
+			}
+			Stream s = new Stream(streamModel.getValueAt(i, 1).toString(), algPath, algShortNames, algmeasures);
+			streams.add(s);
+		}
+
+		// create summary
+		try {
+			summary = new Summary(streams, FilenameUtils.separatorsToSystem(path + File.separator));
+			jButtonSummarize.setEnabled(true);
+			String summaryPath = this.jTextFieldResultsPath.getText() + File.separator;
+
+			summary.invertedSumariesPerMeasure(summaryPath);
+			summary.computeWinsTiesLossesHTML(summaryPath);
+			summary.computeWinsTiesLossesLatex(summaryPath);
+			summary.generateHTML(summaryPath);
+			summary.generateLatex(summaryPath);
+			System.out.println("Summaries created at: " + summaryPath);
+
+		} catch (Exception exc) {
+			// System.err.println("Problems generating summaries");
+
+		}
+
+	}
+
+	/**
+	 * Allows to read the results file and update the corresponding fields.
+	 *
+	 * @param path
+	 */
+	public void readData(String path) {
+		jTextFieldResultsPath.setText(path);
+		cleanTables();
+		rf = new ReadFile(path);
+		String str = rf.processFiles();
+		if (str.equals("")) {
+			algotithmID = rf.getAlgShortNames();
+			algorithmNames = rf.getAlgNames();
+			streamNames = rf.getStream();
+			this.measures = rf.getMeasures();
+			// Set algorithms an streams
+			for (int i = 0; i < algotithmID.size(); i++) {
+				this.algoritmModel.addRow(new Object[] { algorithmNames.get(i), algotithmID.get(i) });
+			}
+			streamNames.stream().forEach((streamName) -> {
+				this.streamModel.addRow(new Object[] { streamName, streamName });
+			});
+
+			// set the measures into the combobox
+			String measuresNames[] = measures.getFirst().split(",");
+			jComboBoxMeasure.removeAllItems();
+			for (String measuresName : measuresNames) {
+				jComboBoxMeasure.addItem(measuresName);
+			}
+
+		} else {
+
+			JOptionPane.showMessageDialog(this, str, "Error", JOptionPane.ERROR_MESSAGE);
+		}
+
+	}
+
+	/**
+	 * Clean the tables
+	 */
+	public void cleanTables() {
+		try {
+			DefaultTableModel algModel = (DefaultTableModel) jTableAlgoritms.getModel();
+			DefaultTableModel strModel = (DefaultTableModel) jTableStreams.getModel();
+			DefaultTableModel measureModel = (DefaultTableModel) jTableMeasures.getModel();
+			int rows = jTableAlgoritms.getRowCount();
+			int srow = jTableStreams.getRowCount();
+			int trow = this.jTableMeasures.getRowCount();
+			for (int i = 0; i < rows; i++) {
+				algModel.removeRow(0);
+			}
+			for (int i = 0; i < srow; i++) {
+				strModel.removeRow(0);
+			}
+			for (int i = 0; i < trow; i++) {
+				this.measureModel.removeRow(0);
+			}
+		} catch (Exception e) {
+			JOptionPane.showMessageDialog(null, "Error cleaning the table.");
+		}
+		jButtonSummarize.setEnabled(false);
+	}
+
+	private static void createAndShowGUI() {
+
+		// Create and set up the window.
+		JFrame frame = new JFrame("Test");
+		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+
+		// Create and set up the content pane.
+		JPanel panel = new SummaryTab();
+		panel.setOpaque(true); // content panes must be opaque
+		frame.setContentPane(panel);
+
+		// Display the window.
+		frame.pack();
+		frame.setVisible(true);
+	}
+
+	/**
+	 * The main method
+	 *
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		try {
+			LookAndFeel.install();
+			javax.swing.SwingUtilities.invokeLater(new Runnable() {
+
+				@Override
+				public void run() {
+					createAndShowGUI();
+				}
+			});
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/SummaryTable.java b/moa/src/main/java/moa/gui/experimentertab/SummaryTable.java
index 32961d5e1..5838bc57d 100644
--- a/moa/src/main/java/moa/gui/experimentertab/SummaryTable.java
+++ b/moa/src/main/java/moa/gui/experimentertab/SummaryTable.java
@@ -1,6 +1,6 @@
 /*
  *    SummaryTable.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand 
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
  *    @author Alberto Verdecia Cabrera (averdeciac@gmail.com)
  *
  *    This program is free software; you can redistribute it and/or modify
@@ -15,17 +15,18 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab;
 
 /**
  * Class to create the fields needed to display the summaries in the gui.
+ * 
  * @author Alberto Verdecia Cabrera (averdeciac@gmail.com)
  */
 public class SummaryTable {
-    public String algNames[];
-    public String measureName;
-    public Object value[][];
-    
+	public String algNames[];
+	public String measureName;
+	public Object value[][];
+
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/SummaryViewer.java b/moa/src/main/java/moa/gui/experimentertab/SummaryViewer.java
index e09723f2d..3d850588f 100644
--- a/moa/src/main/java/moa/gui/experimentertab/SummaryViewer.java
+++ b/moa/src/main/java/moa/gui/experimentertab/SummaryViewer.java
@@ -1,6 +1,6 @@
 /*
  *    SummaryViewer.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand 
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
  *    @author Alberto Verdecia Cabrera (averdeciac@gmail.com)
  *
  *    This program is free software; you can redistribute it and/or modify
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab;
 
@@ -23,6 +23,7 @@
 import java.awt.GridLayout;
 import java.awt.HeadlessException;
 import java.io.File;
+
 import javax.swing.JButton;
 import javax.swing.JComboBox;
 import javax.swing.JFileChooser;
@@ -32,107 +33,107 @@
 import javax.swing.JPanel;
 import javax.swing.JScrollPane;
 import javax.swing.JTable;
+import javax.swing.WindowConstants;
+
 import nz.ac.waikato.cms.gui.core.BaseDirectoryChooser;
 
 /**
  * Class to display summaries in the gui.
+ * 
  * @author Alberto Verdecia Cabrera (averdeciac@gmail.com)
  */
 public class SummaryViewer extends JFrame {
 
-    public JTable tableSummary;
-    public JScrollPane scroll;
-    public JPanel jTablePanel;
-    public JComboBox summaryType;
-    public JButton bntExport;
-    public SummaryTable[] summaryTable;
-    public Summary summary;
-    public String resultsPath;
-
-    /**
-     * Constructor.
-     * @param summaryTable
-     * @param summary
-     * @throws HeadlessException
-     */
-    public SummaryViewer(SummaryTable[] summaryTable, Summary summary, String resultsPath) throws HeadlessException {
-        super("Summary Viewer");
-
-        setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
-        this.summaryTable = summaryTable;
-        this.summary = summary;
-        this.resultsPath = resultsPath;
-        JLabel label = new JLabel("Summary");
-        tableSummary = new JTable();
-        String op[] = new String[this.summaryTable.length];
-        for (int i = 0; i < this.summaryTable.length; i++) {
-            op[i] = this.summaryTable[i].measureName;
-        }
-        tableSummary.setModel(new javax.swing.table.DefaultTableModel(
-                this.summaryTable[0].value,
-                this.summaryTable[0].algNames
-        ));
-        scroll = new JScrollPane();
-        scroll.setViewportView(tableSummary);
-        JPanel panel = new JPanel();
-        JPanel main = new JPanel();
-        jTablePanel = new JPanel();
-        jTablePanel.setLayout(new GridLayout(1, 0));
-        jTablePanel.add(scroll);
-        summaryType = new JComboBox(op);
-        summaryType.setSelectedIndex(0);
-        bntExport = new JButton("Export Summaries");
-      
-        summaryType.addItemListener(this::summaryTypeItemStateChanged);
-        bntExport.addActionListener(this::btnExportActionPerformed);
-        panel.add(label);
-        panel.add(summaryType);
-        panel.add(bntExport);
-
-        main.setLayout(new BorderLayout());
-        main.add(this.jTablePanel, BorderLayout.CENTER);
-        main.add(panel, BorderLayout.SOUTH);
-
-        setContentPane(main);
-
-        // Display the window.
-        pack();
-        setSize(700, 500);
-
-        setVisible(true);
-    }
-
-   
-    private void summaryTypeItemStateChanged(java.awt.event.ItemEvent evt) {                                                       
-        for (SummaryTable summary1 : this.summaryTable) {
-            if (summaryType.getSelectedItem().equals(summary1.measureName) == true) {
-                tableSummary.setModel(new javax.swing.table.DefaultTableModel(summary1.value, summary1.algNames));
-                break;
-            }
-        }
-    }
-     private void btnExportActionPerformed(java.awt.event.ActionEvent evt) {
-        
-           String path = "";
-                BaseDirectoryChooser propDir = new BaseDirectoryChooser();
-                propDir.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
-                propDir.setCurrentDirectory(new File(resultsPath));
-                int selection = propDir.showSaveDialog(this);
-                if (selection == JFileChooser.APPROVE_OPTION) {
-                    path = propDir.getSelectedFile().getAbsolutePath();
-                }
-                if (!path.equals("")) {
-                    path += File.separator;
-                    summary.invertedSumariesPerMeasure(path);
-                    summary.computeWinsTiesLossesHTML(path);
-                    summary.computeWinsTiesLossesLatex(path);
-                    summary.generateHTML(path);
-                    summary.generateLatex(path);
-                     JOptionPane.showMessageDialog(this, "Summaries created at: " + path,
-                    "", JOptionPane.INFORMATION_MESSAGE);
-                }
-         
-        
-     }
+	public JTable tableSummary;
+	public JScrollPane scroll;
+	public JPanel jTablePanel;
+	public JComboBox summaryType;
+	public JButton bntExport;
+	public SummaryTable[] summaryTable;
+	public Summary summary;
+	public String resultsPath;
+
+	/**
+	 * Constructor.
+	 * 
+	 * @param summaryTable
+	 * @param summary
+	 * @throws HeadlessException
+	 */
+	public SummaryViewer(SummaryTable[] summaryTable, Summary summary, String resultsPath) throws HeadlessException {
+		super("Summary Viewer");
+
+		setDefaultCloseOperation(WindowConstants.HIDE_ON_CLOSE);
+		this.summaryTable = summaryTable;
+		this.summary = summary;
+		this.resultsPath = resultsPath;
+		JLabel label = new JLabel("Summary");
+		tableSummary = new JTable();
+		String op[] = new String[this.summaryTable.length];
+		for (int i = 0; i < this.summaryTable.length; i++) {
+			op[i] = this.summaryTable[i].measureName;
+		}
+		tableSummary.setModel(
+				new javax.swing.table.DefaultTableModel(this.summaryTable[0].value, this.summaryTable[0].algNames));
+		scroll = new JScrollPane();
+		scroll.setViewportView(tableSummary);
+		JPanel panel = new JPanel();
+		JPanel main = new JPanel();
+		jTablePanel = new JPanel();
+		jTablePanel.setLayout(new GridLayout(1, 0));
+		jTablePanel.add(scroll);
+		summaryType = new JComboBox(op);
+		summaryType.setSelectedIndex(0);
+		bntExport = new JButton("Export Summaries");
+
+		summaryType.addItemListener(this::summaryTypeItemStateChanged);
+		bntExport.addActionListener(this::btnExportActionPerformed);
+		panel.add(label);
+		panel.add(summaryType);
+		panel.add(bntExport);
+
+		main.setLayout(new BorderLayout());
+		main.add(this.jTablePanel, BorderLayout.CENTER);
+		main.add(panel, BorderLayout.SOUTH);
+
+		setContentPane(main);
+
+		// Display the window.
+		pack();
+		setSize(700, 500);
+
+		setVisible(true);
+	}
+
+	private void summaryTypeItemStateChanged(java.awt.event.ItemEvent evt) {
+		for (SummaryTable summary1 : this.summaryTable) {
+			if (summaryType.getSelectedItem().equals(summary1.measureName) == true) {
+				tableSummary.setModel(new javax.swing.table.DefaultTableModel(summary1.value, summary1.algNames));
+				break;
+			}
+		}
+	}
+
+	private void btnExportActionPerformed(java.awt.event.ActionEvent evt) {
+
+		String path = "";
+		BaseDirectoryChooser propDir = new BaseDirectoryChooser();
+		propDir.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
+		propDir.setCurrentDirectory(new File(resultsPath));
+		int selection = propDir.showSaveDialog(this);
+		if (selection == JFileChooser.APPROVE_OPTION) {
+			path = propDir.getSelectedFile().getAbsolutePath();
+		}
+		if (!path.equals("")) {
+			path += File.separator;
+			summary.invertedSumariesPerMeasure(path);
+			summary.computeWinsTiesLossesHTML(path);
+			summary.computeWinsTiesLossesLatex(path);
+			summary.generateHTML(path);
+			summary.generateLatex(path);
+			JOptionPane.showMessageDialog(this, "Summaries created at: " + path, "", JOptionPane.INFORMATION_MESSAGE);
+		}
+
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/TaskManagerForm.java b/moa/src/main/java/moa/gui/experimentertab/TaskManagerForm.java
index aff09d3cc..dcc350713 100644
--- a/moa/src/main/java/moa/gui/experimentertab/TaskManagerForm.java
+++ b/moa/src/main/java/moa/gui/experimentertab/TaskManagerForm.java
@@ -5,280 +5,257 @@
  */
 package moa.gui.experimentertab;
 
-import moa.gui.LookAndFeel;
-
 import javax.swing.JFrame;
 import javax.swing.JPanel;
 
+import moa.gui.LookAndFeel;
+
 /**
  *
  * @author Alberto
  */
 public class TaskManagerForm extends javax.swing.JPanel {
 
-    /**
-     * Creates new form TaskManagerForm
-     */
-    public TaskManagerForm() {
-        initComponents();
-    }
-private static void createAndShowGUI() {
-
-        // Create and set up the window.
-        JFrame frame = new JFrame("Test");
-        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-
-        // Create and set up the content pane.
-        JPanel panel = new TaskManagerForm();
-        panel.setOpaque(true); // content panes must be opaque
-        frame.setContentPane(panel);
-
-        // Display the window.
-        frame.pack();
-        //frame.setSize(400, 400);
-        frame.setVisible(true);
-    }
-
-    /**
-     * @param args the command line arguments
-     */
-    public static void main(String[] args) {
-        try {
-            LookAndFeel.install();
-            javax.swing.SwingUtilities.invokeLater(new Runnable() {
-
-                @Override
-                public void run() {
-                    createAndShowGUI();
-                }
-            });
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-    /**
-     * This method is called from within the constructor to initialize the form.
-     * WARNING: Do NOT modify this code. The content of this method is always
-     * regenerated by the Form Editor.
-     */
-    @SuppressWarnings("unchecked")
-    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
-    private void initComponents() {
-
-        jPanel1 = new javax.swing.JPanel();
-        jScrollPaneAlgorithms = new javax.swing.JScrollPane();
-        jTableAlgorithms = new javax.swing.JTable();
-        jScrollPaneStreams = new javax.swing.JScrollPane();
-        jTableStreams = new javax.swing.JTable();
-        jTextFieldTask = new javax.swing.JTextField();
-        jButtonDir = new javax.swing.JButton();
-        jLabelDirectory = new javax.swing.JLabel();
-        jButtonDelAlgoritm = new javax.swing.JButton();
-        jButtonDelStream = new javax.swing.JButton();
-        jButtonAlgorithm = new javax.swing.JButton();
-        jButtonStream = new javax.swing.JButton();
-        jTextFieldDir = new javax.swing.JTextField();
-        jButtonTask = new javax.swing.JButton();
-        jLabel1 = new javax.swing.JLabel();
-        jButtonOpenConfig = new javax.swing.JButton();
-        jButtonSaveConfig = new javax.swing.JButton();
-
-        jPanel1.setBorder(javax.swing.BorderFactory.createTitledBorder("Config Algorithms/Data"));
-
-        jScrollPaneAlgorithms.setBorder(javax.swing.BorderFactory.createTitledBorder("Algorithm"));
-
-        jTableAlgorithms.setBorder(javax.swing.BorderFactory.createTitledBorder(""));
-        jTableAlgorithms.setModel(new javax.swing.table.DefaultTableModel(
-            new Object [][] {
-
-            },
-            new String [] {
-                "Algorithm", "Algorithm ID"
-            }
-        ));
-        jScrollPaneAlgorithms.setViewportView(jTableAlgorithms);
-
-        jScrollPaneStreams.setBorder(javax.swing.BorderFactory.createTitledBorder("Stram"));
-
-        jTableStreams.setBorder(javax.swing.BorderFactory.createTitledBorder(""));
-        jTableStreams.setModel(new javax.swing.table.DefaultTableModel(
-            new Object [][] {
-
-            },
-            new String [] {
-                "Stream", "Stream ID"
-            }
-        ));
-        jScrollPaneStreams.setViewportView(jTableStreams);
-
-        jTextFieldTask.setEditable(false);
-
-        jButtonDir.setText("Browse");
-        jButtonDir.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                jButtonDirActionPerformed(evt);
-            }
-        });
-
-        jLabelDirectory.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
-        jLabelDirectory.setText("Result  folder");
-
-        jButtonDelAlgoritm.setText("Delete Algorithm");
-        jButtonDelAlgoritm.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                jButtonDelAlgoritmActionPerformed(evt);
-            }
-        });
-
-        jButtonDelStream.setText("Delete Stream");
-        jButtonDelStream.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                jButtonDelStreamActionPerformed(evt);
-            }
-        });
-
-        jButtonAlgorithm.setText("Add Algorithm");
-
-        jButtonStream.setText("Add Stream");
-
-        jTextFieldDir.setEditable(false);
-
-        jButtonTask.setText("Add Task");
-
-        jLabel1.setText("Task");
-
-        jButtonOpenConfig.setText("Open Experiment");
-
-        jButtonSaveConfig.setText("Save Experiment");
-
-        javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1);
-        jPanel1.setLayout(jPanel1Layout);
-        jPanel1Layout.setHorizontalGroup(
-            jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGroup(jPanel1Layout.createSequentialGroup()
-                .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                    .addGroup(jPanel1Layout.createSequentialGroup()
-                        .addContainerGap()
-                        .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                            .addComponent(jScrollPaneAlgorithms, javax.swing.GroupLayout.PREFERRED_SIZE, 0, Short.MAX_VALUE)
-                            .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanel1Layout.createSequentialGroup()
-                                .addComponent(jButtonAlgorithm)
-                                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                                .addComponent(jButtonDelAlgoritm)
-                                .addGap(0, 111, Short.MAX_VALUE)))
-                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
-                        .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                            .addComponent(jScrollPaneStreams, javax.swing.GroupLayout.DEFAULT_SIZE, 311, Short.MAX_VALUE)
-                            .addGroup(jPanel1Layout.createSequentialGroup()
-                                .addComponent(jButtonStream)
-                                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
-                                .addComponent(jButtonDelStream))))
-                    .addGroup(jPanel1Layout.createSequentialGroup()
-                        .addGap(14, 14, 14)
-                        .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
-                            .addComponent(jLabel1)
-                            .addComponent(jLabelDirectory))
-                        .addGap(14, 14, 14)
-                        .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                            .addComponent(jTextFieldDir)
-                            .addComponent(jTextFieldTask))
-                        .addGap(14, 14, 14)
-                        .addComponent(jButtonDir)))
-                .addGap(16, 16, 16))
-            .addGroup(jPanel1Layout.createSequentialGroup()
-                .addGap(113, 113, 113)
-                .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                    .addGroup(jPanel1Layout.createSequentialGroup()
-                        .addComponent(jButtonOpenConfig)
-                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                        .addComponent(jButtonSaveConfig)
-                        .addGap(0, 0, Short.MAX_VALUE))
-                    .addGroup(jPanel1Layout.createSequentialGroup()
-                        .addGap(0, 0, Short.MAX_VALUE)
-                        .addComponent(jButtonTask)))
-                .addGap(14, 14, 14))
-        );
-        jPanel1Layout.setVerticalGroup(
-            jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanel1Layout.createSequentialGroup()
-                .addContainerGap()
-                .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jButtonOpenConfig)
-                    .addComponent(jButtonSaveConfig))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jTextFieldTask, javax.swing.GroupLayout.PREFERRED_SIZE, 23, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jButtonTask)
-                    .addComponent(jLabel1))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jTextFieldDir, javax.swing.GroupLayout.PREFERRED_SIZE, 23, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addComponent(jLabelDirectory)
-                    .addComponent(jButtonDir))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                    .addComponent(jScrollPaneAlgorithms, javax.swing.GroupLayout.DEFAULT_SIZE, 288, Short.MAX_VALUE)
-                    .addComponent(jScrollPaneStreams, javax.swing.GroupLayout.PREFERRED_SIZE, 0, Short.MAX_VALUE))
-                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                    .addComponent(jButtonDelStream)
-                    .addComponent(jButtonDelAlgoritm)
-                    .addComponent(jButtonAlgorithm)
-                    .addComponent(jButtonStream)))
-        );
-
-        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
-        this.setLayout(layout);
-        layout.setHorizontalGroup(
-            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 400, Short.MAX_VALUE)
-            .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                .addGroup(layout.createSequentialGroup()
-                    .addContainerGap()
-                    .addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
-                    .addContainerGap()))
-        );
-        layout.setVerticalGroup(
-            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 393, Short.MAX_VALUE)
-            .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                .addGroup(layout.createSequentialGroup()
-                    .addContainerGap()
-                    .addComponent(jPanel1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                    .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)))
-        );
-    }// </editor-fold>//GEN-END:initComponents
-
-    private void jButtonDirActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonDirActionPerformed
-
-    }//GEN-LAST:event_jButtonDirActionPerformed
-
-    private void jButtonDelAlgoritmActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonDelAlgoritmActionPerformed
-
-    }//GEN-LAST:event_jButtonDelAlgoritmActionPerformed
-
-    private void jButtonDelStreamActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonDelStreamActionPerformed
-
-    }//GEN-LAST:event_jButtonDelStreamActionPerformed
-
-
-    // Variables declaration - do not modify//GEN-BEGIN:variables
-    private javax.swing.JButton jButtonAlgorithm;
-    private javax.swing.JButton jButtonDelAlgoritm;
-    private javax.swing.JButton jButtonDelStream;
-    private javax.swing.JButton jButtonDir;
-    private javax.swing.JButton jButtonOpenConfig;
-    private javax.swing.JButton jButtonSaveConfig;
-    private javax.swing.JButton jButtonStream;
-    private javax.swing.JButton jButtonTask;
-    private javax.swing.JLabel jLabel1;
-    private javax.swing.JLabel jLabelDirectory;
-    private javax.swing.JPanel jPanel1;
-    private javax.swing.JScrollPane jScrollPaneAlgorithms;
-    private javax.swing.JScrollPane jScrollPaneStreams;
-    private javax.swing.JTable jTableAlgorithms;
-    private javax.swing.JTable jTableStreams;
-    private javax.swing.JTextField jTextFieldDir;
-    private javax.swing.JTextField jTextFieldTask;
-    // End of variables declaration//GEN-END:variables
+	/**
+	 * Creates new form TaskManagerForm
+	 */
+	public TaskManagerForm() {
+		initComponents();
+	}
+
+	private static void createAndShowGUI() {
+
+		// Create and set up the window.
+		JFrame frame = new JFrame("Test");
+		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+
+		// Create and set up the content pane.
+		JPanel panel = new TaskManagerForm();
+		panel.setOpaque(true); // content panes must be opaque
+		frame.setContentPane(panel);
+
+		// Display the window.
+		frame.pack();
+		// frame.setSize(400, 400);
+		frame.setVisible(true);
+	}
+
+	/**
+	 * @param args the command line arguments
+	 */
+	public static void main(String[] args) {
+		try {
+			LookAndFeel.install();
+			javax.swing.SwingUtilities.invokeLater(new Runnable() {
+
+				@Override
+				public void run() {
+					createAndShowGUI();
+				}
+			});
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	/**
+	 * This method is called from within the constructor to initialize the form.
+	 * WARNING: Do NOT modify this code. The content of this method is always
+	 * regenerated by the Form Editor.
+	 */
+	@SuppressWarnings("unchecked")
+	// <editor-fold defaultstate="collapsed" desc="Generated
+	// Code">//GEN-BEGIN:initComponents
+	private void initComponents() {
+
+		jPanel1 = new javax.swing.JPanel();
+		jScrollPaneAlgorithms = new javax.swing.JScrollPane();
+		jTableAlgorithms = new javax.swing.JTable();
+		jScrollPaneStreams = new javax.swing.JScrollPane();
+		jTableStreams = new javax.swing.JTable();
+		jTextFieldTask = new javax.swing.JTextField();
+		jButtonDir = new javax.swing.JButton();
+		jLabelDirectory = new javax.swing.JLabel();
+		jButtonDelAlgoritm = new javax.swing.JButton();
+		jButtonDelStream = new javax.swing.JButton();
+		jButtonAlgorithm = new javax.swing.JButton();
+		jButtonStream = new javax.swing.JButton();
+		jTextFieldDir = new javax.swing.JTextField();
+		jButtonTask = new javax.swing.JButton();
+		jLabel1 = new javax.swing.JLabel();
+		jButtonOpenConfig = new javax.swing.JButton();
+		jButtonSaveConfig = new javax.swing.JButton();
+
+		jPanel1.setBorder(javax.swing.BorderFactory.createTitledBorder("Config Algorithms/Data"));
+
+		jScrollPaneAlgorithms.setBorder(javax.swing.BorderFactory.createTitledBorder("Algorithm"));
+
+		jTableAlgorithms.setBorder(javax.swing.BorderFactory.createTitledBorder(""));
+		jTableAlgorithms.setModel(new javax.swing.table.DefaultTableModel(new Object[][] {
+
+		}, new String[] { "Algorithm", "Algorithm ID" }));
+		jScrollPaneAlgorithms.setViewportView(jTableAlgorithms);
+
+		jScrollPaneStreams.setBorder(javax.swing.BorderFactory.createTitledBorder("Stram"));
+
+		jTableStreams.setBorder(javax.swing.BorderFactory.createTitledBorder(""));
+		jTableStreams.setModel(new javax.swing.table.DefaultTableModel(new Object[][] {
+
+		}, new String[] { "Stream", "Stream ID" }));
+		jScrollPaneStreams.setViewportView(jTableStreams);
+
+		jTextFieldTask.setEditable(false);
+
+		jButtonDir.setText("Browse");
+		jButtonDir.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				jButtonDirActionPerformed(evt);
+			}
+		});
+
+		jLabelDirectory.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
+		jLabelDirectory.setText("Result  folder");
+
+		jButtonDelAlgoritm.setText("Delete Algorithm");
+		jButtonDelAlgoritm.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				jButtonDelAlgoritmActionPerformed(evt);
+			}
+		});
+
+		jButtonDelStream.setText("Delete Stream");
+		jButtonDelStream.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				jButtonDelStreamActionPerformed(evt);
+			}
+		});
+
+		jButtonAlgorithm.setText("Add Algorithm");
+
+		jButtonStream.setText("Add Stream");
+
+		jTextFieldDir.setEditable(false);
+
+		jButtonTask.setText("Add Task");
+
+		jLabel1.setText("Task");
+
+		jButtonOpenConfig.setText("Open Experiment");
+
+		jButtonSaveConfig.setText("Save Experiment");
+
+		javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1);
+		jPanel1.setLayout(jPanel1Layout);
+		jPanel1Layout.setHorizontalGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+				.addGroup(jPanel1Layout.createSequentialGroup().addGroup(jPanel1Layout
+						.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+						.addGroup(jPanel1Layout.createSequentialGroup().addContainerGap().addGroup(jPanel1Layout
+								.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+								.addComponent(jScrollPaneAlgorithms, javax.swing.GroupLayout.PREFERRED_SIZE, 0,
+										Short.MAX_VALUE)
+								.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
+										jPanel1Layout.createSequentialGroup().addComponent(jButtonAlgorithm)
+												.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+												.addComponent(jButtonDelAlgoritm).addGap(0, 111, Short.MAX_VALUE)))
+								.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
+								.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+										.addComponent(jScrollPaneStreams, javax.swing.GroupLayout.DEFAULT_SIZE, 311,
+												Short.MAX_VALUE)
+										.addGroup(jPanel1Layout.createSequentialGroup().addComponent(jButtonStream)
+												.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
+												.addComponent(jButtonDelStream))))
+						.addGroup(jPanel1Layout.createSequentialGroup().addGap(14, 14, 14)
+								.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
+										.addComponent(jLabel1).addComponent(jLabelDirectory))
+								.addGap(14, 14, 14)
+								.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+										.addComponent(jTextFieldDir).addComponent(jTextFieldTask))
+								.addGap(14, 14, 14).addComponent(jButtonDir)))
+						.addGap(16, 16, 16))
+				.addGroup(jPanel1Layout.createSequentialGroup().addGap(113, 113, 113)
+						.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+								.addGroup(jPanel1Layout.createSequentialGroup().addComponent(jButtonOpenConfig)
+										.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+										.addComponent(jButtonSaveConfig).addGap(0, 0, Short.MAX_VALUE))
+								.addGroup(jPanel1Layout.createSequentialGroup().addGap(0, 0, Short.MAX_VALUE)
+										.addComponent(jButtonTask)))
+						.addGap(14, 14, 14)));
+		jPanel1Layout.setVerticalGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+				.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
+						jPanel1Layout.createSequentialGroup().addContainerGap()
+								.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+										.addComponent(jButtonOpenConfig).addComponent(jButtonSaveConfig))
+								.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+								.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+										.addComponent(jTextFieldTask, javax.swing.GroupLayout.PREFERRED_SIZE, 23,
+												javax.swing.GroupLayout.PREFERRED_SIZE)
+										.addComponent(jButtonTask).addComponent(jLabel1))
+								.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+								.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+										.addComponent(jTextFieldDir, javax.swing.GroupLayout.PREFERRED_SIZE, 23,
+												javax.swing.GroupLayout.PREFERRED_SIZE)
+										.addComponent(jLabelDirectory).addComponent(jButtonDir))
+								.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+								.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+										.addComponent(jScrollPaneAlgorithms, javax.swing.GroupLayout.DEFAULT_SIZE, 288,
+												Short.MAX_VALUE)
+										.addComponent(jScrollPaneStreams, javax.swing.GroupLayout.PREFERRED_SIZE, 0,
+												Short.MAX_VALUE))
+								.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+								.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+										.addComponent(jButtonDelStream).addComponent(jButtonDelAlgoritm)
+										.addComponent(jButtonAlgorithm).addComponent(jButtonStream))));
+
+		javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
+		this.setLayout(layout);
+		layout.setHorizontalGroup(
+				layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 400, Short.MAX_VALUE)
+						.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+								.addGroup(layout.createSequentialGroup().addContainerGap()
+										.addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE,
+												javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
+										.addContainerGap())));
+		layout.setVerticalGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+				.addGap(0, 393, Short.MAX_VALUE)
+				.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+						.addGroup(layout.createSequentialGroup().addContainerGap()
+								.addComponent(jPanel1, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))));
+	}// </editor-fold>//GEN-END:initComponents
+
+	private void jButtonDirActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_jButtonDirActionPerformed
+
+	}// GEN-LAST:event_jButtonDirActionPerformed
+
+	private void jButtonDelAlgoritmActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_jButtonDelAlgoritmActionPerformed
+
+	}// GEN-LAST:event_jButtonDelAlgoritmActionPerformed
+
+	private void jButtonDelStreamActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_jButtonDelStreamActionPerformed
+
+	}// GEN-LAST:event_jButtonDelStreamActionPerformed
+
+	// Variables declaration - do not modify//GEN-BEGIN:variables
+	private javax.swing.JButton jButtonAlgorithm;
+	private javax.swing.JButton jButtonDelAlgoritm;
+	private javax.swing.JButton jButtonDelStream;
+	private javax.swing.JButton jButtonDir;
+	private javax.swing.JButton jButtonOpenConfig;
+	private javax.swing.JButton jButtonSaveConfig;
+	private javax.swing.JButton jButtonStream;
+	private javax.swing.JButton jButtonTask;
+	private javax.swing.JLabel jLabel1;
+	private javax.swing.JLabel jLabelDirectory;
+	private javax.swing.JPanel jPanel1;
+	private javax.swing.JScrollPane jScrollPaneAlgorithms;
+	private javax.swing.JScrollPane jScrollPaneStreams;
+	private javax.swing.JTable jTableAlgorithms;
+	private javax.swing.JTable jTableStreams;
+	private javax.swing.JTextField jTextFieldDir;
+	private javax.swing.JTextField jTextFieldTask;
+	// End of variables declaration//GEN-END:variables
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/TaskManagerTabPanel.java b/moa/src/main/java/moa/gui/experimentertab/TaskManagerTabPanel.java
index 5ab8d100e..cbed48146 100644
--- a/moa/src/main/java/moa/gui/experimentertab/TaskManagerTabPanel.java
+++ b/moa/src/main/java/moa/gui/experimentertab/TaskManagerTabPanel.java
@@ -17,30 +17,25 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab;
 
-import moa.classifiers.Classifier;
-import moa.core.Globals;
-import moa.core.StringUtils;
-import moa.gui.ClassOptionSelectionPanel;
-import moa.gui.LookAndFeel;
-import moa.gui.experimentertab.tasks.ExperimenterTask;
-import moa.learners.ChangeDetectorLearner;
-import moa.learners.Learner;
-import moa.options.AbstractOptionHandler;
-import moa.options.ClassOption;
-import moa.options.OptionHandler;
-import moa.streams.ArffFileStream;
-import moa.streams.InstanceStream;
-import moa.streams.generators.AgrawalGenerator;
-import moa.streams.generators.cd.ConceptDriftGenerator;
-import moa.streams.generators.cd.GradualChangeGenerator;
-import moa.tasks.MainTask;
-import nz.ac.waikato.cms.gui.core.BaseDirectoryChooser;
-import nz.ac.waikato.cms.gui.core.BaseFileChooser;
-import org.apache.commons.io.FilenameUtils;
+import java.awt.BorderLayout;
+import java.awt.Component;
+import java.awt.Dimension;
+import java.awt.event.ActionEvent;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Properties;
+import java.util.Scanner;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 
 import javax.swing.DefaultListModel;
 import javax.swing.JFileChooser;
@@ -57,21 +52,28 @@
 import javax.swing.table.DefaultTableCellRenderer;
 import javax.swing.table.DefaultTableModel;
 import javax.swing.table.TableCellRenderer;
-import java.awt.BorderLayout;
-import java.awt.Component;
-import java.awt.Dimension;
-import java.awt.event.ActionEvent;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Properties;
-import java.util.Scanner;
-import java.util.logging.Level;
-import java.util.logging.Logger;
+
+import org.apache.commons.io.FilenameUtils;
+
+import moa.core.Globals;
+import moa.core.StringUtils;
+import moa.gui.ClassOptionSelectionPanel;
+import moa.gui.LookAndFeel;
+import moa.gui.experimentertab.tasks.ExperimenterTask;
+import moa.learners.predictors.ChangeDetectorLearner;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.InstanceLearner;
+import moa.options.AbstractOptionHandler;
+import moa.options.ClassOption;
+import moa.options.OptionHandler;
+import moa.streams.ArffFileStream;
+import moa.streams.InstanceStream;
+import moa.streams.generators.AgrawalGenerator;
+import moa.streams.generators.cd.ConceptDriftGenerator;
+import moa.streams.generators.cd.GradualChangeGenerator;
+import moa.tasks.MainTask;
+import nz.ac.waikato.cms.gui.core.BaseDirectoryChooser;
+import nz.ac.waikato.cms.gui.core.BaseFileChooser;
 
 /**
  * Run online learning algorithms over multiple datasets and save the
@@ -83,486 +85,447 @@
  */
 public class TaskManagerTabPanel extends JPanel {
 
-    protected MainTask currentTask = new moa.tasks.EvaluatePrequential();//LearnModel();
-
-    protected Classifier learner = new moa.classifiers.bayes.NaiveBayes();//LearnModel();
-
-    protected AbstractOptionHandler stream = new AgrawalGenerator();
-
-    protected DefaultTableModel algoritmModel;
-
-    protected DefaultTableModel streamModel;
-
-    protected List<ExpTaskThread> taskList = new ArrayList<>();
-
-    protected TaskManagerTabPanel.TaskTableModel taskTableModel;
-
-    protected JTable taskTable = new JTable();
-
-    protected String initialString = "initial";
-
-    protected ChangeDetectorLearner detector = new ChangeDetectorLearner();
-
-    protected ConceptDriftGenerator detectorStream = new GradualChangeGenerator();
-    
-    protected ExpPreviewPanel previewPanel  = new ExpPreviewPanel();
-    
-    private PreviewExperiments preview = new PreviewExperiments(previewPanel);
-
-    DefaultListModel listModelMonitor = new DefaultListModel();
-
-    public static final int MILLISECS_BETWEEN_REFRESH = 600;
-
-    /**
-     * Array of characters to use to animate the progress of tasks running.
-     */
-    public static final char[] progressAnimSequence = new char[]{'-', '\\',
-        '|', '/'};
-    /**
-     * Maximum length of the status string that shows the progress of tasks
-     * running.
-     */
-    public static final int MAX_STATUS_STRING_LENGTH = 79;
-
-    public SummaryTab summary = new SummaryTab();
-
-    public PlotTab plot = new PlotTab();
-
-    public AnalyzeTab analizeTab = new AnalyzeTab();
-    
-    protected String resultsPath = "";
-    private javax.swing.JButton jButtonTask;
-    private javax.swing.JButton jButtonAlgorithm;
-    private javax.swing.JButton jButtonCancel;
-    private javax.swing.JButton jButtonDelAlgoritm;
-    private javax.swing.JButton jButtonDelStream;
-    private javax.swing.JButton jButtonDelete;
-    private javax.swing.JButton jButtonPause;
-    private javax.swing.JButton jButtonResume;
-    private javax.swing.JButton jButtonRun;
-    private javax.swing.JButton jButtonStream;
-    private javax.swing.JButton jButtonSaveConfig;
-    private javax.swing.JButton jButtonOpenConfig;
-    private javax.swing.JButton jButtonReset;
-    private javax.swing.JButton jButtonDir;
-    private javax.swing.JButton jButtonPreview;
-    private javax.swing.JPanel jPanelConfig;
-    private javax.swing.JScrollPane jScrollPaneAlgorithms;
-    private javax.swing.JScrollPane jScrollPaneStreams;
-    private javax.swing.JScrollPane jScrollPaneTaskTable;
-    private javax.swing.JTable jTableAlgorithms;
-    private javax.swing.JTable jTableStreams;
-    private javax.swing.JTextField jTextFieldProcess;
-    private javax.swing.JTextField jTextFieldTask;
-    private javax.swing.JTextField jTextFieldDir;
-
-    /**
-     * Class ProgressCellRenderer
-     */
-    public class ProgressCellRenderer extends JProgressBar implements
-            TableCellRenderer {
-
-        private static final long serialVersionUID = 1L;
-
-        /**
-         * ProgressCellRenderer Constructor
-         */
-        public ProgressCellRenderer() {
-            super(SwingConstants.HORIZONTAL, 0, 10000);
-            setBorderPainted(false);
-            setStringPainted(true);
-        }
-
-        @Override
-        public Component getTableCellRendererComponent(JTable table,
-                Object value, boolean isSelected, boolean hasFocus, int row,
-                int column) {
-            double frac = -1.0;
-            if (value instanceof Double) {
-                frac = ((Double) value).doubleValue();
-            }
-            if (frac >= 0.0) {
-                setIndeterminate(false);
-                setValue((int) (frac * 10000.0));
-                setString(StringUtils.doubleToString(frac * 100.0, 2, 2));
-            } else {
-                setValue(0);
-
-            }
-            return this;
-        }
-
-        @Override
-        public void validate() {
-        }
-
-        @Override
-        public void revalidate() {
-        }
-
-        @Override
-        protected void firePropertyChange(String propertyName, Object oldValue,
-                Object newValue) {
-        }
-
-        @Override
-        public void firePropertyChange(String propertyName, boolean oldValue,
-                boolean newValue) {
-        }
-    }
-
-    /**
-     * Class TaskTableModel
-     */
-    protected class TaskTableModel extends AbstractTableModel {
-
-        private static final long serialVersionUID = 1L;
-
-        @Override
-        public String getColumnName(int col) {
-            switch (col) {
-                case 0:
-                    return "command";
-                case 1:
-                    return "status";
-                case 2:
-                    return "time elapsed";
-                case 3:
-                    return "current activity";
-                case 4:
-                    return "% complete";
-            }
-            return null;
-        }
-
-        @Override
-        public int getColumnCount() {
-            return 5;
-        }
-
-        @Override
-        public int getRowCount() {
-            return TaskManagerTabPanel.this.taskList.size();
-        }
-
-        @Override
-        public Object getValueAt(int row, int col) {
-            ExpTaskThread thread = TaskManagerTabPanel.this.taskList.get(row);
-            switch (col) {
-                case 0:
-                    try {
-                        return ((OptionHandler) thread.getTask()).getCLICreationString(MainTask.class);
-                    } catch (Exception e) {
-                    }
-                case 1:
-                    return thread.getCurrentStatusString();
-                case 2:
-                    return StringUtils.secondsToDHMSString(thread.getCPUSecondsElapsed());
-                case 3:
-                    return thread.getCurrentActivityString();
-                case 4:
-                    return thread.getCurrentActivityFracComplete();
-            }
-            return null;
-        }
-
-        @Override
-        public boolean isCellEditable(int row, int col) {
-            return false;
-        }
-    }
-
-    /**
-     * TaskManagerTabPanel Constructor
-     */
-    public TaskManagerTabPanel() {
-        initComponents();
-        this.algoritmModel = (DefaultTableModel) jTableAlgorithms.getModel();
-        this.streamModel = (DefaultTableModel) jTableStreams.getModel();
-        this.taskTableModel = new TaskManagerTabPanel.TaskTableModel();
-        this.taskTable.setModel(this.taskTableModel);
-        DefaultTableCellRenderer centerRenderer = new DefaultTableCellRenderer();
-        centerRenderer.setHorizontalAlignment(SwingConstants.CENTER);
-        this.taskTable.getColumnModel().getColumn(1).setCellRenderer(
-                centerRenderer);
-        this.taskTable.getColumnModel().getColumn(2).setCellRenderer(
-                centerRenderer);
-        this.taskTable.getColumnModel().getColumn(4).setCellRenderer(new TaskManagerTabPanel.ProgressCellRenderer());
-           this.taskTable.getSelectionModel().addListSelectionListener(
-                new ListSelectionListener() {
-
-                    @Override
-                    public void valueChanged(ListSelectionEvent arg0) {
-                        taskSelectionChanged();
-                    }
-                });
-        javax.swing.Timer updateListTimer = new javax.swing.Timer(
-                MILLISECS_BETWEEN_REFRESH, (ActionEvent e) -> {
-                    TaskManagerTabPanel.this.taskTable.repaint();
-                });
-        updateListTimer.start();
-
-    }
-
-    private static void createAndShowGUI() {
-
-        // Create and set up the window.
-        JFrame frame = new JFrame("Test");
-        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-
-        // Create and set up the content pane.
-        JPanel panel = new TaskManagerTabPanel();
-        panel.setOpaque(true); // content panes must be opaque
-        frame.setContentPane(panel);
-
-        // Display the window.
-        frame.pack();
-        frame.setVisible(true);
-    }
-
-    private void initComponents() {
-
-        jPanelConfig = new javax.swing.JPanel();
-        jScrollPaneAlgorithms = new javax.swing.JScrollPane();
-        jTableAlgorithms = new javax.swing.JTable();
-        jScrollPaneStreams = new javax.swing.JScrollPane();
-        jTableStreams = new javax.swing.JTable();
-        jTextFieldTask = new javax.swing.JTextField();
-        jButtonTask = new javax.swing.JButton();
-        jButtonAlgorithm = new javax.swing.JButton();
-        jButtonStream = new javax.swing.JButton();
-        jButtonRun = new javax.swing.JButton();
-        jScrollPaneTaskTable = new javax.swing.JScrollPane();
-        taskTable = new javax.swing.JTable();
-        jTextFieldProcess = new javax.swing.JTextField();
-        jTextFieldDir = new javax.swing.JTextField();
-        jButtonDelAlgoritm = new javax.swing.JButton();
-        jButtonDelStream = new javax.swing.JButton();
-        jButtonPause = new javax.swing.JButton();
-        jButtonResume = new javax.swing.JButton();
-        jButtonCancel = new javax.swing.JButton();
-        jButtonDelete = new javax.swing.JButton();
-        jButtonSaveConfig = new javax.swing.JButton();
-        jButtonOpenConfig = new javax.swing.JButton();
-        jButtonReset = new javax.swing.JButton();
-        jButtonDir = new javax.swing.JButton();
-        jButtonPreview = new javax.swing.JButton();
-
-        jPanelConfig.setBorder(javax.swing.BorderFactory.createTitledBorder(null,
-                "Configure", javax.swing.border.TitledBorder.DEFAULT_JUSTIFICATION,
-                javax.swing.border.TitledBorder.DEFAULT_POSITION,
-                new java.awt.Font("Tahoma", 0, 12))); // NOI18N
-
-        jScrollPaneAlgorithms.setBorder(javax.swing.BorderFactory.createTitledBorder("Algorithms"));
-
-        jTableAlgorithms.setModel(new javax.swing.table.DefaultTableModel(
-                new Object[][]{},
-                new String[]{
-                    "Algorithm", "Algorithm ID"
-                }
-        ));
-        jTableAlgorithms.setEditingColumn(1);
-        jScrollPaneAlgorithms.setViewportView(jTableAlgorithms);
-
-        jScrollPaneStreams.setBorder(javax.swing.BorderFactory.createTitledBorder("Streams"));
-
-        jTableStreams.setModel(new javax.swing.table.DefaultTableModel(
-                new Object[][]{},
-                new String[]{
-                    "Stream", "Stream ID"
-                }
-        ));
-        jScrollPaneStreams.setViewportView(jTableStreams);
-
-        jTextFieldTask.setEditable(false);
-        //jTextFieldTask.setBorder(javax.swing.BorderFactory.createTitledBorder("Task"));
-
-        jButtonTask.setText("Add Task");
-        jButtonTask.addActionListener(this::jButtonTaskActionPerformed);
-        jButtonDir.setText("Browse");
-        jButtonDir.addActionListener(this::jButtonDirActionPerformed);
-        
-        jButtonPreview.setText("Preview");
-        jButtonPreview.addActionListener(this::jButtonPreviewActionPerformed);
-
-        jButtonAlgorithm.setText("Add Algorithm");
-        jButtonAlgorithm.addActionListener(this::jButtonAlgorithmActionPerformed);
-
-        jButtonStream.setText("Add Stream");
-        jButtonStream.addActionListener(this::jButtonStreamActionPerformed);
-
-        jButtonRun.setText("Run Experiment");
-        jButtonRun.setToolTipText("Run task");
-        jButtonRun.addActionListener(this::jButtonRunActionPerformed);
-
-        jButtonOpenConfig.setText("Open Experiment");
-        jButtonOpenConfig.setToolTipText("Open saved configuration file");
-        jButtonOpenConfig.addActionListener(this::jButtonOpenConfigActionPerformed);
-
-        jButtonSaveConfig.setText("Save Experiment");
-        jButtonSaveConfig.setToolTipText("Save Configuration to file");
-        jButtonSaveConfig.addActionListener(this::jButtonSaveConfigActionPerformed);
-
-        jButtonReset.setText("Reset to Default");
-        jButtonReset.setToolTipText("Reset all");
-        jButtonReset.addActionListener(this::jButtonResetActionPerformed);
-
-        taskTable.setModel(new javax.swing.table.DefaultTableModel(
-                new Object[][]{},
-                new String[]{}
-        ));
-        jScrollPaneTaskTable.setViewportView(taskTable);
-
-        jTextFieldProcess.setText("1");
-        jTextFieldProcess.setBorder(javax.swing.BorderFactory.createTitledBorder("Threads"));
-
-        jTextFieldDir.setText("");
-        //jTextFieldDir.setBorder(javax.swing.BorderFactory.createTitledBorder("Results directory"));
-
-        jButtonDelAlgoritm.setText("Delete Algorithm");
-        jButtonDelAlgoritm.addActionListener(this::jButtonDelAlgoritmActionPerformed);
-
-        jButtonDelStream.setText("Delete Stream");
-        jButtonDelStream.addActionListener(this::jButtonDelStreamActionPerformed);
-
-        jButtonPause.setText("Pause");
-        jButtonPause.addActionListener(this::jButtonPauseActionPerformed);
-
-        jButtonResume.setText("Resume");
-        jButtonResume.addActionListener(this::jButtonResumeActionPerformed);
-
-        jButtonCancel.setText("Cancel");
-        jButtonCancel.addActionListener(this::jButtonCancelActionPerformed);
-
-        jButtonDelete.setText("Delete");
-        jButtonDelete.addActionListener(this::jButtonDeleteActionPerformed);
-
-        /*prueba*/
-        JPanel jPanel1 = new JPanel();
-        jPanel1.setBorder(javax.swing.BorderFactory.createTitledBorder("Configuration"));
-        JLabel jLabelDirectory = new JLabel("Result folder");
-        JLabel jLabel1 = new JLabel("Task");
-
-        javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1);
-        jPanel1.setLayout(jPanel1Layout);
-        jPanel1Layout.setHorizontalGroup(
-                jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                .addGroup(jPanel1Layout.createSequentialGroup()
-                        .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                                .addGroup(jPanel1Layout.createSequentialGroup()
-                                        .addContainerGap()
-                                        .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                                                .addComponent(jScrollPaneAlgorithms, javax.swing.GroupLayout.PREFERRED_SIZE, 0, Short.MAX_VALUE)
-                                                .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanel1Layout.createSequentialGroup()
-                                                        .addComponent(jButtonAlgorithm)
-                                                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                                                        .addComponent(jButtonDelAlgoritm)
-                                                        .addGap(0, 111, Short.MAX_VALUE)))
-                                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
-                                        .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                                                .addComponent(jScrollPaneStreams, javax.swing.GroupLayout.DEFAULT_SIZE, 311, Short.MAX_VALUE)
-                                                .addGroup(jPanel1Layout.createSequentialGroup()
-                                                        .addComponent(jButtonStream)
-                                                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
-                                                        .addComponent(jButtonDelStream))))
-                                .addGroup(jPanel1Layout.createSequentialGroup()
-                                        .addGap(14, 14, 14)
-                                        .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
-                                                .addComponent(jLabel1)
-                                                .addComponent(jLabelDirectory))
-                                        .addGap(14, 14, 14)
-                                        .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                                                .addComponent(jTextFieldDir)
-                                                .addComponent(jTextFieldTask))
-                                        .addGap(14, 14, 14)
-                                        .addComponent(jButtonDir)))
-                        .addGap(16, 16, 16))
-                .addGroup(jPanel1Layout.createSequentialGroup()
-                        .addGap(113, 113, 113)
-                        .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                                .addGroup(jPanel1Layout.createSequentialGroup()
-                                        .addComponent(jButtonOpenConfig)
-                                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                                        .addComponent(jButtonSaveConfig)
-                                        .addGap(0, 0, Short.MAX_VALUE))
-                                .addGroup(jPanel1Layout.createSequentialGroup()
-                                        .addGap(0, 0, Short.MAX_VALUE)
-                                        .addComponent(jButtonTask)))
-                        .addGap(14, 14, 14))
-        );
-        jPanel1Layout.setVerticalGroup(
-                jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanel1Layout.createSequentialGroup()
-                        .addContainerGap()
-                        .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                                .addComponent(jButtonOpenConfig)
-                                .addComponent(jButtonSaveConfig))
-                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                        .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                                .addComponent(jTextFieldTask, javax.swing.GroupLayout.PREFERRED_SIZE, 23, javax.swing.GroupLayout.PREFERRED_SIZE)
-                                .addComponent(jButtonTask)
-                                .addComponent(jLabel1))
-                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                        .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                                .addComponent(jTextFieldDir, javax.swing.GroupLayout.PREFERRED_SIZE, 23, javax.swing.GroupLayout.PREFERRED_SIZE)
-                                .addComponent(jLabelDirectory)
-                                .addComponent(jButtonDir))
-                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                        .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                                .addComponent(jScrollPaneAlgorithms, javax.swing.GroupLayout.DEFAULT_SIZE, 288, Short.MAX_VALUE)
-                                .addComponent(jScrollPaneStreams, javax.swing.GroupLayout.PREFERRED_SIZE, 0, Short.MAX_VALUE))
-                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
-                        .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
-                                .addComponent(jButtonDelStream)
-                                .addComponent(jButtonDelAlgoritm)
-                                .addComponent(jButtonAlgorithm)
-                                .addComponent(jButtonStream)))
-        );
-
-        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
-        this.setLayout(layout);
-        layout.setHorizontalGroup(
-                layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                .addGap(0, 400, Short.MAX_VALUE)
-                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                        .addGroup(layout.createSequentialGroup()
-                                .addContainerGap()
-                                .addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
-                                .addContainerGap()))
-        );
-        layout.setVerticalGroup(
-                layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                .addGap(0, 393, Short.MAX_VALUE)
-                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                        .addGroup(layout.createSequentialGroup()
-                                .addContainerGap()
-                                .addComponent(jPanel1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
-                                .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)))
-        );
-
-        JPanel panelSRB = new JPanel();
-        jTextFieldProcess.setPreferredSize(new Dimension(80, 40));
-        panelSRB.add(jTextFieldProcess);
-        panelSRB.add(jButtonRun);
-        //Configure task table panel
-        jScrollPaneAlgorithms.setPreferredSize(new Dimension(461, 260));
-       jScrollPaneStreams.setPreferredSize(new Dimension(461, 260));
-       jScrollPaneTaskTable.setPreferredSize(new Dimension(350, 180));
-        JPanel panelTaskTable = new JPanel();
-        JPanel panelTaskTableBtn = new JPanel();
-        panelTaskTableBtn.add(jButtonPreview);
-        panelTaskTableBtn.add(jButtonPause);
-        panelTaskTableBtn.add(jButtonResume);
-        panelTaskTableBtn.add(jButtonCancel);
-        panelTaskTableBtn.add(jButtonDelete);
-        panelTaskTableBtn.add(jButtonReset);
-        panelTaskTable.setLayout(new BorderLayout());
-        panelTaskTable.add(panelSRB, BorderLayout.NORTH);
-        panelTaskTable.add(jScrollPaneTaskTable, BorderLayout.CENTER);
-        panelTaskTable.add(panelTaskTableBtn, BorderLayout.SOUTH);
-        setLayout(new BorderLayout());
-        this.add(jPanel1, BorderLayout.CENTER);
-        this.add(panelTaskTable, BorderLayout.SOUTH);
+	protected MainTask currentTask = new moa.tasks.classification.EvaluatePrequential();// LearnModel();
+
+	protected Classifier learner = new moa.learners.predictors.bayes.NaiveBayes();// LearnModel();
+
+	protected AbstractOptionHandler stream = new AgrawalGenerator();
+
+	protected DefaultTableModel algoritmModel;
+
+	protected DefaultTableModel streamModel;
+
+	protected List<ExpTaskThread> taskList = new ArrayList<>();
+
+	protected TaskManagerTabPanel.TaskTableModel taskTableModel;
+
+	protected JTable taskTable = new JTable();
+
+	protected String initialString = "initial";
+
+	protected ChangeDetectorLearner detector = new ChangeDetectorLearner();
+
+	protected ConceptDriftGenerator detectorStream = new GradualChangeGenerator();
+
+	protected ExpPreviewPanel previewPanel = new ExpPreviewPanel();
+
+	private PreviewExperiments preview = new PreviewExperiments(previewPanel);
+
+	DefaultListModel listModelMonitor = new DefaultListModel();
+
+	public static final int MILLISECS_BETWEEN_REFRESH = 600;
+
+	/**
+	 * Array of characters to use to animate the progress of tasks running.
+	 */
+	public static final char[] progressAnimSequence = new char[] { '-', '\\', '|', '/' };
+	/**
+	 * Maximum length of the status string that shows the progress of tasks running.
+	 */
+	public static final int MAX_STATUS_STRING_LENGTH = 79;
+
+	public SummaryTab summary = new SummaryTab();
+
+	public PlotTab plot = new PlotTab();
+
+	public AnalyzeTab analizeTab = new AnalyzeTab();
+
+	protected String resultsPath = "";
+	private javax.swing.JButton jButtonTask;
+	private javax.swing.JButton jButtonAlgorithm;
+	private javax.swing.JButton jButtonCancel;
+	private javax.swing.JButton jButtonDelAlgoritm;
+	private javax.swing.JButton jButtonDelStream;
+	private javax.swing.JButton jButtonDelete;
+	private javax.swing.JButton jButtonPause;
+	private javax.swing.JButton jButtonResume;
+	private javax.swing.JButton jButtonRun;
+	private javax.swing.JButton jButtonStream;
+	private javax.swing.JButton jButtonSaveConfig;
+	private javax.swing.JButton jButtonOpenConfig;
+	private javax.swing.JButton jButtonReset;
+	private javax.swing.JButton jButtonDir;
+	private javax.swing.JButton jButtonPreview;
+	private javax.swing.JPanel jPanelConfig;
+	private javax.swing.JScrollPane jScrollPaneAlgorithms;
+	private javax.swing.JScrollPane jScrollPaneStreams;
+	private javax.swing.JScrollPane jScrollPaneTaskTable;
+	private javax.swing.JTable jTableAlgorithms;
+	private javax.swing.JTable jTableStreams;
+	private javax.swing.JTextField jTextFieldProcess;
+	private javax.swing.JTextField jTextFieldTask;
+	private javax.swing.JTextField jTextFieldDir;
+
+	/**
+	 * Class ProgressCellRenderer
+	 */
+	public class ProgressCellRenderer extends JProgressBar implements TableCellRenderer {
+
+		private static final long serialVersionUID = 1L;
+
+		/**
+		 * ProgressCellRenderer Constructor
+		 */
+		public ProgressCellRenderer() {
+			super(SwingConstants.HORIZONTAL, 0, 10000);
+			setBorderPainted(false);
+			setStringPainted(true);
+		}
+
+		@Override
+		public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
+				int row, int column) {
+			double frac = -1.0;
+			if (value instanceof Double) {
+				frac = ((Double) value);
+			}
+			if (frac >= 0.0) {
+				setIndeterminate(false);
+				setValue((int) (frac * 10000.0));
+				setString(StringUtils.doubleToString(frac * 100.0, 2, 2));
+			} else {
+				setValue(0);
+
+			}
+			return this;
+		}
+
+		@Override
+		public void validate() {
+		}
+
+		@Override
+		public void revalidate() {
+		}
+
+		@Override
+		protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
+		}
+
+		@Override
+		public void firePropertyChange(String propertyName, boolean oldValue, boolean newValue) {
+		}
+	}
+
+	/**
+	 * Class TaskTableModel
+	 */
+	protected class TaskTableModel extends AbstractTableModel {
+
+		private static final long serialVersionUID = 1L;
+
+		@Override
+		public String getColumnName(int col) {
+			switch (col) {
+			case 0:
+				return "command";
+			case 1:
+				return "status";
+			case 2:
+				return "time elapsed";
+			case 3:
+				return "current activity";
+			case 4:
+				return "% complete";
+			}
+			return null;
+		}
+
+		@Override
+		public int getColumnCount() {
+			return 5;
+		}
+
+		@Override
+		public int getRowCount() {
+			return TaskManagerTabPanel.this.taskList.size();
+		}
+
+		@Override
+		public Object getValueAt(int row, int col) {
+			ExpTaskThread thread = TaskManagerTabPanel.this.taskList.get(row);
+			switch (col) {
+			case 0:
+				try {
+					return ((OptionHandler) thread.getTask()).getCLICreationString(MainTask.class);
+				} catch (Exception e) {
+				}
+			case 1:
+				return thread.getCurrentStatusString();
+			case 2:
+				return StringUtils.secondsToDHMSString(thread.getCPUSecondsElapsed());
+			case 3:
+				return thread.getCurrentActivityString();
+			case 4:
+				return thread.getCurrentActivityFracComplete();
+			}
+			return null;
+		}
+
+		@Override
+		public boolean isCellEditable(int row, int col) {
+			return false;
+		}
+	}
+
+	/**
+	 * TaskManagerTabPanel Constructor
+	 */
+	public TaskManagerTabPanel() {
+		initComponents();
+		this.algoritmModel = (DefaultTableModel) jTableAlgorithms.getModel();
+		this.streamModel = (DefaultTableModel) jTableStreams.getModel();
+		this.taskTableModel = new TaskManagerTabPanel.TaskTableModel();
+		this.taskTable.setModel(this.taskTableModel);
+		DefaultTableCellRenderer centerRenderer = new DefaultTableCellRenderer();
+		centerRenderer.setHorizontalAlignment(SwingConstants.CENTER);
+		this.taskTable.getColumnModel().getColumn(1).setCellRenderer(centerRenderer);
+		this.taskTable.getColumnModel().getColumn(2).setCellRenderer(centerRenderer);
+		this.taskTable.getColumnModel().getColumn(4).setCellRenderer(new TaskManagerTabPanel.ProgressCellRenderer());
+		this.taskTable.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
+
+			@Override
+			public void valueChanged(ListSelectionEvent arg0) {
+				taskSelectionChanged();
+			}
+		});
+		javax.swing.Timer updateListTimer = new javax.swing.Timer(MILLISECS_BETWEEN_REFRESH, (ActionEvent e) -> {
+			TaskManagerTabPanel.this.taskTable.repaint();
+		});
+		updateListTimer.start();
+
+	}
+
+	private static void createAndShowGUI() {
+
+		// Create and set up the window.
+		JFrame frame = new JFrame("Test");
+		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+
+		// Create and set up the content pane.
+		JPanel panel = new TaskManagerTabPanel();
+		panel.setOpaque(true); // content panes must be opaque
+		frame.setContentPane(panel);
+
+		// Display the window.
+		frame.pack();
+		frame.setVisible(true);
+	}
+
+	private void initComponents() {
+
+		jPanelConfig = new javax.swing.JPanel();
+		jScrollPaneAlgorithms = new javax.swing.JScrollPane();
+		jTableAlgorithms = new javax.swing.JTable();
+		jScrollPaneStreams = new javax.swing.JScrollPane();
+		jTableStreams = new javax.swing.JTable();
+		jTextFieldTask = new javax.swing.JTextField();
+		jButtonTask = new javax.swing.JButton();
+		jButtonAlgorithm = new javax.swing.JButton();
+		jButtonStream = new javax.swing.JButton();
+		jButtonRun = new javax.swing.JButton();
+		jScrollPaneTaskTable = new javax.swing.JScrollPane();
+		taskTable = new javax.swing.JTable();
+		jTextFieldProcess = new javax.swing.JTextField();
+		jTextFieldDir = new javax.swing.JTextField();
+		jButtonDelAlgoritm = new javax.swing.JButton();
+		jButtonDelStream = new javax.swing.JButton();
+		jButtonPause = new javax.swing.JButton();
+		jButtonResume = new javax.swing.JButton();
+		jButtonCancel = new javax.swing.JButton();
+		jButtonDelete = new javax.swing.JButton();
+		jButtonSaveConfig = new javax.swing.JButton();
+		jButtonOpenConfig = new javax.swing.JButton();
+		jButtonReset = new javax.swing.JButton();
+		jButtonDir = new javax.swing.JButton();
+		jButtonPreview = new javax.swing.JButton();
+
+		jPanelConfig.setBorder(javax.swing.BorderFactory.createTitledBorder(null, "Configure",
+				javax.swing.border.TitledBorder.DEFAULT_JUSTIFICATION, javax.swing.border.TitledBorder.DEFAULT_POSITION,
+				new java.awt.Font("Tahoma", 0, 12))); // NOI18N
+
+		jScrollPaneAlgorithms.setBorder(javax.swing.BorderFactory.createTitledBorder("Algorithms"));
+
+		jTableAlgorithms.setModel(new javax.swing.table.DefaultTableModel(new Object[][] {},
+				new String[] { "Algorithm", "Algorithm ID" }));
+		jTableAlgorithms.setEditingColumn(1);
+		jScrollPaneAlgorithms.setViewportView(jTableAlgorithms);
+
+		jScrollPaneStreams.setBorder(javax.swing.BorderFactory.createTitledBorder("Streams"));
+
+		jTableStreams.setModel(
+				new javax.swing.table.DefaultTableModel(new Object[][] {}, new String[] { "Stream", "Stream ID" }));
+		jScrollPaneStreams.setViewportView(jTableStreams);
+
+		jTextFieldTask.setEditable(false);
+		// jTextFieldTask.setBorder(javax.swing.BorderFactory.createTitledBorder("Task"));
+
+		jButtonTask.setText("Add Task");
+		jButtonTask.addActionListener(this::jButtonTaskActionPerformed);
+		jButtonDir.setText("Browse");
+		jButtonDir.addActionListener(this::jButtonDirActionPerformed);
+
+		jButtonPreview.setText("Preview");
+		jButtonPreview.addActionListener(this::jButtonPreviewActionPerformed);
+
+		jButtonAlgorithm.setText("Add Algorithm");
+		jButtonAlgorithm.addActionListener(this::jButtonAlgorithmActionPerformed);
+
+		jButtonStream.setText("Add Stream");
+		jButtonStream.addActionListener(this::jButtonStreamActionPerformed);
+
+		jButtonRun.setText("Run Experiment");
+		jButtonRun.setToolTipText("Run task");
+		jButtonRun.addActionListener(this::jButtonRunActionPerformed);
+
+		jButtonOpenConfig.setText("Open Experiment");
+		jButtonOpenConfig.setToolTipText("Open saved configuration file");
+		jButtonOpenConfig.addActionListener(this::jButtonOpenConfigActionPerformed);
+
+		jButtonSaveConfig.setText("Save Experiment");
+		jButtonSaveConfig.setToolTipText("Save Configuration to file");
+		jButtonSaveConfig.addActionListener(this::jButtonSaveConfigActionPerformed);
+
+		jButtonReset.setText("Reset to Default");
+		jButtonReset.setToolTipText("Reset all");
+		jButtonReset.addActionListener(this::jButtonResetActionPerformed);
+
+		taskTable.setModel(new javax.swing.table.DefaultTableModel(new Object[][] {}, new String[] {}));
+		jScrollPaneTaskTable.setViewportView(taskTable);
+
+		jTextFieldProcess.setText("1");
+		jTextFieldProcess.setBorder(javax.swing.BorderFactory.createTitledBorder("Threads"));
+
+		jTextFieldDir.setText("");
+		// jTextFieldDir.setBorder(javax.swing.BorderFactory.createTitledBorder("Results
+		// directory"));
+
+		jButtonDelAlgoritm.setText("Delete Algorithm");
+		jButtonDelAlgoritm.addActionListener(this::jButtonDelAlgoritmActionPerformed);
+
+		jButtonDelStream.setText("Delete Stream");
+		jButtonDelStream.addActionListener(this::jButtonDelStreamActionPerformed);
+
+		jButtonPause.setText("Pause");
+		jButtonPause.addActionListener(this::jButtonPauseActionPerformed);
+
+		jButtonResume.setText("Resume");
+		jButtonResume.addActionListener(this::jButtonResumeActionPerformed);
+
+		jButtonCancel.setText("Cancel");
+		jButtonCancel.addActionListener(this::jButtonCancelActionPerformed);
+
+		jButtonDelete.setText("Delete");
+		jButtonDelete.addActionListener(this::jButtonDeleteActionPerformed);
+
+		/* prueba */
+		JPanel jPanel1 = new JPanel();
+		jPanel1.setBorder(javax.swing.BorderFactory.createTitledBorder("Configuration"));
+		JLabel jLabelDirectory = new JLabel("Result folder");
+		JLabel jLabel1 = new JLabel("Task");
+
+		javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1);
+		jPanel1.setLayout(jPanel1Layout);
+		jPanel1Layout.setHorizontalGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+				.addGroup(jPanel1Layout.createSequentialGroup().addGroup(jPanel1Layout
+						.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+						.addGroup(jPanel1Layout.createSequentialGroup().addContainerGap().addGroup(jPanel1Layout
+								.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+								.addComponent(jScrollPaneAlgorithms, javax.swing.GroupLayout.PREFERRED_SIZE, 0,
+										Short.MAX_VALUE)
+								.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
+										jPanel1Layout.createSequentialGroup().addComponent(jButtonAlgorithm)
+												.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+												.addComponent(jButtonDelAlgoritm).addGap(0, 111, Short.MAX_VALUE)))
+								.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
+								.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+										.addComponent(jScrollPaneStreams, javax.swing.GroupLayout.DEFAULT_SIZE, 311,
+												Short.MAX_VALUE)
+										.addGroup(jPanel1Layout.createSequentialGroup().addComponent(jButtonStream)
+												.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
+												.addComponent(jButtonDelStream))))
+						.addGroup(jPanel1Layout.createSequentialGroup().addGap(14, 14, 14)
+								.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
+										.addComponent(jLabel1).addComponent(jLabelDirectory))
+								.addGap(14, 14, 14)
+								.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+										.addComponent(jTextFieldDir).addComponent(jTextFieldTask))
+								.addGap(14, 14, 14).addComponent(jButtonDir)))
+						.addGap(16, 16, 16))
+				.addGroup(jPanel1Layout.createSequentialGroup().addGap(113, 113, 113)
+						.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+								.addGroup(jPanel1Layout.createSequentialGroup().addComponent(jButtonOpenConfig)
+										.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+										.addComponent(jButtonSaveConfig).addGap(0, 0, Short.MAX_VALUE))
+								.addGroup(jPanel1Layout.createSequentialGroup().addGap(0, 0, Short.MAX_VALUE)
+										.addComponent(jButtonTask)))
+						.addGap(14, 14, 14)));
+		jPanel1Layout.setVerticalGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+				.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
+						jPanel1Layout.createSequentialGroup().addContainerGap()
+								.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+										.addComponent(jButtonOpenConfig).addComponent(jButtonSaveConfig))
+								.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+								.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+										.addComponent(jTextFieldTask, javax.swing.GroupLayout.PREFERRED_SIZE, 23,
+												javax.swing.GroupLayout.PREFERRED_SIZE)
+										.addComponent(jButtonTask).addComponent(jLabel1))
+								.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+								.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+										.addComponent(jTextFieldDir, javax.swing.GroupLayout.PREFERRED_SIZE, 23,
+												javax.swing.GroupLayout.PREFERRED_SIZE)
+										.addComponent(jLabelDirectory).addComponent(jButtonDir))
+								.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+								.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+										.addComponent(jScrollPaneAlgorithms, javax.swing.GroupLayout.DEFAULT_SIZE, 288,
+												Short.MAX_VALUE)
+										.addComponent(jScrollPaneStreams, javax.swing.GroupLayout.PREFERRED_SIZE, 0,
+												Short.MAX_VALUE))
+								.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
+								.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+										.addComponent(jButtonDelStream).addComponent(jButtonDelAlgoritm)
+										.addComponent(jButtonAlgorithm).addComponent(jButtonStream))));
+
+		javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
+		this.setLayout(layout);
+		layout.setHorizontalGroup(
+				layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 400, Short.MAX_VALUE)
+						.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+								.addGroup(layout.createSequentialGroup().addContainerGap()
+										.addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE,
+												javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
+										.addContainerGap())));
+		layout.setVerticalGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+				.addGap(0, 393, Short.MAX_VALUE)
+				.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+						.addGroup(layout.createSequentialGroup().addContainerGap()
+								.addComponent(jPanel1, javax.swing.GroupLayout.PREFERRED_SIZE,
+										javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+								.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))));
+
+		JPanel panelSRB = new JPanel();
+		jTextFieldProcess.setPreferredSize(new Dimension(80, 40));
+		panelSRB.add(jTextFieldProcess);
+		panelSRB.add(jButtonRun);
+		// Configure task table panel
+		jScrollPaneAlgorithms.setPreferredSize(new Dimension(461, 260));
+		jScrollPaneStreams.setPreferredSize(new Dimension(461, 260));
+		jScrollPaneTaskTable.setPreferredSize(new Dimension(350, 180));
+		JPanel panelTaskTable = new JPanel();
+		JPanel panelTaskTableBtn = new JPanel();
+		panelTaskTableBtn.add(jButtonPreview);
+		panelTaskTableBtn.add(jButtonPause);
+		panelTaskTableBtn.add(jButtonResume);
+		panelTaskTableBtn.add(jButtonCancel);
+		panelTaskTableBtn.add(jButtonDelete);
+		panelTaskTableBtn.add(jButtonReset);
+		panelTaskTable.setLayout(new BorderLayout());
+		panelTaskTable.add(panelSRB, BorderLayout.NORTH);
+		panelTaskTable.add(jScrollPaneTaskTable, BorderLayout.CENTER);
+		panelTaskTable.add(panelTaskTableBtn, BorderLayout.SOUTH);
+		setLayout(new BorderLayout());
+		this.add(jPanel1, BorderLayout.CENTER);
+		this.add(panelTaskTable, BorderLayout.SOUTH);
 
 //        JPanel panel = new JPanel(new BorderLayout());
 //        panel.add(panelTaskTable,BorderLayout.NORTH);
@@ -576,793 +539,793 @@ private void initComponents() {
 //       splitPane.setPreferredSize(new Dimension(500, 700));
 //        this.add(splitPane, BorderLayout.SOUTH);
 
-    }// </editor-fold>   
-
-    private void jButtonSaveConfigActionPerformed(java.awt.event.ActionEvent evt) {
-        String path = "";
-        BaseFileChooser propDir = new BaseFileChooser();
-        int selection = propDir.showSaveDialog(this);
-        if (selection == JFileChooser.APPROVE_OPTION) {
-            path = propDir.getSelectedFile().getAbsolutePath();
-            SaveConfig(path);
-        }
-
-
-    }
-
-    private void jButtonOpenConfigActionPerformed(java.awt.event.ActionEvent evt) {
-        String path = "";
-        
-        BaseFileChooser fileChooser = new BaseFileChooser();
-        int option = fileChooser.showOpenDialog(null);
-                if (option == JFileChooser.APPROVE_OPTION) { 
-                    path = fileChooser.getSelectedFile().getAbsolutePath();
-                     openConfig(path);
-                }
-    }
-
-    private String openDirectory() {
-        String path = "";
-        BaseDirectoryChooser propDir = new BaseDirectoryChooser();
-        int selection = propDir.showOpenDialog(this);
-        if (selection == JFileChooser.APPROVE_OPTION) {
-            path = propDir.getSelectedFile().getAbsolutePath();
-            return path;
-        }
-        return "";
-    }
-
-    private void jButtonResetActionPerformed(java.awt.event.ActionEvent evt) {
-        this.jTextFieldTask.setText("");
-        this.jTextFieldDir.setText("");
-        this.jTextFieldProcess.setText("1");
-        this.jButtonRun.setEnabled(true);
-        cleanTables();
-    }
-
-    private void jButtonDirActionPerformed(ActionEvent evt) {
-
-        String path = openDirectory();
-
-        if (!path.equals("")) {
-            this.jTextFieldDir.setText(path);
-            this.resultsPath = jTextFieldDir.getText() + File.separator + "Results";
+	}// </editor-fold>
+
+	private void jButtonSaveConfigActionPerformed(java.awt.event.ActionEvent evt) {
+		String path = "";
+		BaseFileChooser propDir = new BaseFileChooser();
+		int selection = propDir.showSaveDialog(this);
+		if (selection == JFileChooser.APPROVE_OPTION) {
+			path = propDir.getSelectedFile().getAbsolutePath();
+			SaveConfig(path);
+		}
+
+	}
+
+	private void jButtonOpenConfigActionPerformed(java.awt.event.ActionEvent evt) {
+		String path = "";
+
+		BaseFileChooser fileChooser = new BaseFileChooser();
+		int option = fileChooser.showOpenDialog(null);
+		if (option == JFileChooser.APPROVE_OPTION) {
+			path = fileChooser.getSelectedFile().getAbsolutePath();
+			openConfig(path);
+		}
+	}
+
+	private String openDirectory() {
+		String path = "";
+		BaseDirectoryChooser propDir = new BaseDirectoryChooser();
+		int selection = propDir.showOpenDialog(this);
+		if (selection == JFileChooser.APPROVE_OPTION) {
+			path = propDir.getSelectedFile().getAbsolutePath();
+			return path;
+		}
+		return "";
+	}
+
+	private void jButtonResetActionPerformed(java.awt.event.ActionEvent evt) {
+		this.jTextFieldTask.setText("");
+		this.jTextFieldDir.setText("");
+		this.jTextFieldProcess.setText("1");
+		this.jButtonRun.setEnabled(true);
+		cleanTables();
+	}
+
+	private void jButtonDirActionPerformed(ActionEvent evt) {
+
+		String path = openDirectory();
+
+		if (!path.equals("")) {
+			this.jTextFieldDir.setText(path);
+			this.resultsPath = jTextFieldDir.getText() + File.separator + "Results";
 //            File  file= new File(this.resultsPath);
 //            file.mkdir();
 
-        }
-    }
-   private void jButtonPreviewActionPerformed(ActionEvent evt) {
-
-         preview.setVisible(true);
-    }
-    private void jButtonTaskActionPerformed(java.awt.event.ActionEvent evt) {
-
-        String initial = TaskManagerTabPanel.this.currentTask.getCLICreationString(MainTask.class);
-        if (initial.split(" ") != null) {
-            String split[] = initial.split(" ");
-            String temp = initial.split(" ")[0];
-            if (split.length >= 3 && split[1].equals("-l") == true) {
-                for (int i = 3; i < split.length; i++) {
-                    temp += " " + split[i];
-                }
-                initial = temp;
-            }
-
-        }
-        String newTaskString = ClassOptionSelectionPanel.showSelectClassDialog(TaskManagerTabPanel.this,
-                "Configure task", ExperimenterTask.class,
-                initial, null);
-
-        try {
-            this.currentTask = (MainTask) ClassOption.cliStringToObject(
-                    newTaskString, MainTask.class, null);
-        } catch (Exception ex) {
-            Logger.getLogger(TaskManagerTabPanel.class.getName()).log(Level.SEVERE, null, ex);
-        }
-        this.jTextFieldTask.setText(newTaskString);
-    }
-
-    private void jButtonAlgorithmActionPerformed(java.awt.event.ActionEvent evt) {
-        String newTaskString;
-        if (this.currentTask instanceof moa.tasks.EvaluateConceptDrift) {
-            newTaskString = ClassOptionSelectionPanel.showSelectClassDialog(TaskManagerTabPanel.this,
-                    "Configure learner", ChangeDetectorLearner.class, this.initialString, null);
-
-            if (newTaskString.equals(this.initialString) == true) {
-                return;
-            }
-            this.initialString = newTaskString;
-            try {
-                this.detector = (ChangeDetectorLearner) ClassOption.cliStringToObject(
-                        newTaskString, ChangeDetectorLearner.class, null);
-            } catch (Exception ex) {
-                Logger.getLogger(TaskManagerTabPanel.class.getName()).log(Level.SEVERE, null, ex);
-            }
-        } else {
-            newTaskString = ClassOptionSelectionPanel.showSelectClassDialog(TaskManagerTabPanel.this,
-                    "Configure learner", Learner.class, this.initialString, null);
-            if (newTaskString.equals(this.initialString) == true) {
-                return;
-            }
-            this.initialString = newTaskString;
-            try {
-                this.learner = (Classifier) ClassOption.cliStringToObject(
-                        newTaskString, Learner.class, null);
-            } catch (Exception ex) {
-                Logger.getLogger(TaskManagerTabPanel.class.getName()).log(Level.SEVERE, null, ex);
-            }
-        }
-
-        for (int i = 0; i < this.algoritmModel.getRowCount(); i++) {
-            if (this.algoritmModel.getValueAt(i, 0).equals(newTaskString)) {
-                JOptionPane.showMessageDialog(this, "The value exist",
-                        "Error", JOptionPane.ERROR_MESSAGE);
-                return;
-            }
-        }
-        this.algoritmModel.addRow(new Object[]{newTaskString, newTaskString});
-
-    }
-
-    private void jButtonStreamActionPerformed(java.awt.event.ActionEvent evt) {
-
-        boolean arff = false;
-        String newTaskString = "";
-        String streamOption = "";
-        if (this.currentTask instanceof moa.tasks.EvaluateConceptDrift) {
-            newTaskString = ClassOptionSelectionPanel.showSelectClassDialog(TaskManagerTabPanel.this,
-                    "Configure stream", ConceptDriftGenerator.class, this.initialString, null);
-
-            if (newTaskString.equals(this.initialString) == true) {
-                return;
-            }
-            this.initialString = newTaskString;
-            try {
-                this.detectorStream = (ConceptDriftGenerator) ClassOption.cliStringToObject(
-                        newTaskString, ConceptDriftGenerator.class, null);
-            } catch (Exception ex) {
-                Logger.getLogger(TaskManagerTabPanel.class.getName()).log(Level.SEVERE, null, ex);
-            }
-
-        } else {
-            newTaskString = ClassOptionSelectionPanel.showSelectClassDialog(TaskManagerTabPanel.this,
-                    "Configure stream", InstanceStream.class, this.initialString, null);
-
-            if (newTaskString.equals(this.initialString) == true) {
-                return;
-            }
-            this.initialString = newTaskString;
-            try {
-                this.stream = (AbstractOptionHandler) ClassOption.cliStringToObject(
-                        newTaskString, InstanceStream.class, null);
-            } catch (Exception ex) {
-                Logger.getLogger(TaskManagerTabPanel.class.getName()).log(Level.SEVERE, null, ex);
-            }
-
-            if (this.stream instanceof ArffFileStream) {
-                streamOption = FilenameUtils.getBaseName(((ArffFileStream) this.stream).arffFileOption.getFile().getName());
-                arff = true;
-            }
-        }
-        for (int i = 0; i < this.streamModel.getRowCount(); i++) {
-            if (this.streamModel.getValueAt(i, 0).equals(newTaskString)) {
-                JOptionPane.showMessageDialog(this, "The value exist",
-                        "Error", JOptionPane.ERROR_MESSAGE);
-                return;
-            }
-        }
-        if (arff == true) {
-            this.streamModel.addRow(new Object[]{newTaskString, streamOption});
-        } else {
-            this.streamModel.addRow(new Object[]{newTaskString, newTaskString});
-        }
-
-    }
-
-    private void jButtonRunActionPerformed(java.awt.event.ActionEvent evt) {
-
-        //Validations 
-        if (this.jTextFieldTask.getText().equals("")) {
-
-            JOptionPane.showMessageDialog(this, "The task is not specified",
-                    "Error", JOptionPane.ERROR_MESSAGE);
-        } else if (this.jTextFieldDir.getText().equals("")) {
-            JOptionPane.showMessageDialog(this, "The result directory is not specified",
-                    "Error", JOptionPane.ERROR_MESSAGE);
-        } else {
-            if (this.jTableAlgorithms.getRowCount() != 0) {
-                if (this.jTableStreams.getRowCount() != 0) {
-                    List<String> stream = new ArrayList<>();
-                    for (int i = 0; i < this.streamModel.getRowCount(); i++) {
-                        if (this.streamModel.getValueAt(i, 0).equals("")
-                                || this.streamModel.getValueAt(i, 1).equals("")) {
-                            JOptionPane.showMessageDialog(this, "Fields incompleted in Table Stream",
-                                    "Error", JOptionPane.ERROR_MESSAGE);
-                            return;
-                        }
-                        if (i == 0) {
-                            stream.add(this.streamModel.getValueAt(i, 1).toString());
-                        } else {
-                            if (stream.remove(this.streamModel.getValueAt(i, 1).toString())) {
-                                stream.add(this.streamModel.getValueAt(i, 1).toString());
-                                JOptionPane.showMessageDialog(this, "There are reapeted values in Table Stream",
-                                        "Error", JOptionPane.ERROR_MESSAGE);
-                                return;
-                            } else {
-                                stream.add(this.streamModel.getValueAt(i, 1).toString());
-                            }
-                        }
-
-                    }
-                    List<String> algorithm = new ArrayList<>();
-                    for (int i = 0; i < this.algoritmModel.getRowCount(); i++) {
-                        if (this.algoritmModel.getValueAt(i, 0).equals("")
-                                || this.algoritmModel.getValueAt(i, 1).equals("")) {
-                            JOptionPane.showMessageDialog(this, "Fields incompleted in Table Algorithm",
-                                    "Error", JOptionPane.ERROR_MESSAGE);
-                            return;
-                        }
-                        if (i == 0) {
-                            algorithm.add(this.algoritmModel.getValueAt(i, 1).toString());
-                        } else {
-                            if (algorithm.remove(this.algoritmModel.getValueAt(i, 1).toString())) {
-                                algorithm.add(this.algoritmModel.getValueAt(i, 1).toString());
-                                JOptionPane.showMessageDialog(this, "There are reapeted values in Table Algorithm",
-                                        "Error", JOptionPane.ERROR_MESSAGE);
-                                return;
-                            } else {
-                                algorithm.add(this.algoritmModel.getValueAt(i, 1).toString());
-                            }
-                        }
-
-                    }//End Validations
-                    runTask();
-                } else {
-                    JOptionPane.showMessageDialog(this, "You must select at least one dataset",
-                            "Error", JOptionPane.ERROR_MESSAGE);
-                }
-            } else {
-                JOptionPane.showMessageDialog(this, "You must select at least one algorithm",
-                        "Error", JOptionPane.ERROR_MESSAGE);
-            }
-
-        }
-
-    }
-
-    private void jButtonDelAlgoritmActionPerformed(java.awt.event.ActionEvent evt) {
-        this.algoritmModel.removeRow(this.jTableAlgorithms.getSelectedRow());
-    }
-
-    private void jButtonDelStreamActionPerformed(java.awt.event.ActionEvent evt) {
-        this.streamModel.removeRow(this.jTableStreams.getSelectedRow());
-    }
-
-    private void jButtonPauseActionPerformed(java.awt.event.ActionEvent evt) {
-        pauseSelectedTasks();
-    }
-
-    private void jButtonResumeActionPerformed(java.awt.event.ActionEvent evt) {
-        resumeSelectedTasks();
-    }
-
-    private void jButtonCancelActionPerformed(java.awt.event.ActionEvent evt) {
-        cancelSelectedTasks();
-    }
-
-    private void jButtonDeleteActionPerformed(java.awt.event.ActionEvent evt) {
-        deleteSelectedTasks();
-    }
-
-    /**
-     * Executes the Task
-     */
-    public void runTask() {
-        MainTask tasks[] = new MainTask[jTableAlgorithms.getModel().getRowCount() * jTableStreams.getModel().getRowCount()];
-        int taskCount = 0;
-
-        String dir = "";
-
-        try {
-            this.currentTask = (MainTask) ClassOption.cliStringToObject(
-                    this.jTextFieldTask.getText(), MainTask.class, null);
-        } catch (Exception ex) {
-            Logger.getLogger(TaskManagerTabPanel.class.getName()).log(Level.SEVERE, null, ex);
-        }
-        MainTask auxTask = (MainTask) this.currentTask.copy();
-
-        dir += this.resultsPath;
-
-        File f = new File(dir);
-        if (f.exists()) {
-            Object[] options = {"Yes", "No"};
-            String cancel = "NO";
-            int resp = JOptionPane.showOptionDialog(this,
-                    "The selected folder is not empty. This action may overwrite "
-                    + "previous experiment results. Do you want to continue?", "Warning",
-                    JOptionPane.OK_CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE, null, options, cancel);
-            if (resp == JOptionPane.OK_OPTION) {
-                ReadFile.deleteDrectory(f);
-
-            } else {
-                JOptionPane.showMessageDialog(this, "Please specify another directory", "Message",
-                        JOptionPane.INFORMATION_MESSAGE);
-                return;
-            }
-        }
-        f.mkdir();
-
-        String algNames = "";
-        String streamNames = "";
-        for (int i = 0; i < jTableAlgorithms.getModel().getRowCount(); i++) {
-            String alg = jTableAlgorithms.getModel().getValueAt(i, 0).toString();
-            String algFile = jTableAlgorithms.getModel().getValueAt(i, 1).toString();
-            algNames += algFile;
-            if (i != jTableAlgorithms.getModel().getRowCount() - 1) {
-                algNames += ",";
-            }
-            for (int j = 0; j < jTableStreams.getModel().getRowCount(); j++) {
-                String stream = jTableStreams.getModel().getValueAt(j, 0).toString();
-                String streamFile = jTableStreams.getModel().getValueAt(j, 1).toString();
-                streamNames += streamFile.split(" ")[0];
-                if (j != jTableStreams.getModel().getRowCount() - 1) {
-                    streamNames += ",";
-                }
-                if (i == 0) {
-                    String sfile = FilenameUtils.separatorsToSystem(dir + "\\\\" + streamFile);
-                    f = new File(sfile);
-                    f.mkdir();
-                }
-                String task = " -l ";
-                if (alg.split(" ") != null) {
-                    task += "(" + alg + ") -s (" + stream + ")" + " -d (" + dir + File.separator
-                            + streamFile.split(" ")[0] + File.separator + algFile + ".txt" + ")";
-                } else {
-                    task += alg + " -s (" + stream + ")" + " -d (" + dir + File.separator
-                            + streamFile.split(" ")[0] + File.separator + algFile + ".txt" + ")";
-                }
+		}
+	}
+
+	private void jButtonPreviewActionPerformed(ActionEvent evt) {
+
+		preview.setVisible(true);
+	}
+
+	private void jButtonTaskActionPerformed(java.awt.event.ActionEvent evt) {
+
+		String initial = TaskManagerTabPanel.this.currentTask.getCLICreationString(MainTask.class);
+		if (initial.split(" ") != null) {
+			String split[] = initial.split(" ");
+			String temp = initial.split(" ")[0];
+			if (split.length >= 3 && split[1].equals("-l") == true) {
+				for (int i = 3; i < split.length; i++) {
+					temp += " " + split[i];
+				}
+				initial = temp;
+			}
+
+		}
+		String newTaskString = ClassOptionSelectionPanel.showSelectClassDialog(TaskManagerTabPanel.this,
+				"Configure task", ExperimenterTask.class, initial, null);
+
+		try {
+			this.currentTask = (MainTask) ClassOption.cliStringToObject(newTaskString, MainTask.class, null);
+		} catch (Exception ex) {
+			Logger.getLogger(TaskManagerTabPanel.class.getName()).log(Level.SEVERE, null, ex);
+		}
+		this.jTextFieldTask.setText(newTaskString);
+	}
+
+	private void jButtonAlgorithmActionPerformed(java.awt.event.ActionEvent evt) {
+		String newTaskString;
+		if (this.currentTask instanceof moa.tasks.conceptdrift.EvaluateConceptDrift) {
+			newTaskString = ClassOptionSelectionPanel.showSelectClassDialog(TaskManagerTabPanel.this,
+					"Configure learner", ChangeDetectorLearner.class, this.initialString, null);
+
+			if (newTaskString.equals(this.initialString) == true) {
+				return;
+			}
+			this.initialString = newTaskString;
+			try {
+				this.detector = (ChangeDetectorLearner) ClassOption.cliStringToObject(newTaskString,
+						ChangeDetectorLearner.class, null);
+			} catch (Exception ex) {
+				Logger.getLogger(TaskManagerTabPanel.class.getName()).log(Level.SEVERE, null, ex);
+			}
+		} else {
+			newTaskString = ClassOptionSelectionPanel.showSelectClassDialog(TaskManagerTabPanel.this,
+					"Configure learner", InstanceLearner.class, this.initialString, null);
+			if (newTaskString.equals(this.initialString) == true) {
+				return;
+			}
+			this.initialString = newTaskString;
+			try {
+				this.learner = (Classifier) ClassOption.cliStringToObject(newTaskString, InstanceLearner.class, null);
+			} catch (Exception ex) {
+				Logger.getLogger(TaskManagerTabPanel.class.getName()).log(Level.SEVERE, null, ex);
+			}
+		}
+
+		for (int i = 0; i < this.algoritmModel.getRowCount(); i++) {
+			if (this.algoritmModel.getValueAt(i, 0).equals(newTaskString)) {
+				JOptionPane.showMessageDialog(this, "The value exist", "Error", JOptionPane.ERROR_MESSAGE);
+				return;
+			}
+		}
+		this.algoritmModel.addRow(new Object[] { newTaskString, newTaskString });
+
+	}
+
+	private void jButtonStreamActionPerformed(java.awt.event.ActionEvent evt) {
+
+		boolean arff = false;
+		String newTaskString = "";
+		String streamOption = "";
+		if (this.currentTask instanceof moa.tasks.conceptdrift.EvaluateConceptDrift) {
+			newTaskString = ClassOptionSelectionPanel.showSelectClassDialog(TaskManagerTabPanel.this,
+					"Configure stream", ConceptDriftGenerator.class, this.initialString, null);
+
+			if (newTaskString.equals(this.initialString) == true) {
+				return;
+			}
+			this.initialString = newTaskString;
+			try {
+				this.detectorStream = (ConceptDriftGenerator) ClassOption.cliStringToObject(newTaskString,
+						ConceptDriftGenerator.class, null);
+			} catch (Exception ex) {
+				Logger.getLogger(TaskManagerTabPanel.class.getName()).log(Level.SEVERE, null, ex);
+			}
+
+		} else {
+			newTaskString = ClassOptionSelectionPanel.showSelectClassDialog(TaskManagerTabPanel.this,
+					"Configure stream", InstanceStream.class, this.initialString, null);
+
+			if (newTaskString.equals(this.initialString) == true) {
+				return;
+			}
+			this.initialString = newTaskString;
+			try {
+				this.stream = (AbstractOptionHandler) ClassOption.cliStringToObject(newTaskString, InstanceStream.class,
+						null);
+			} catch (Exception ex) {
+				Logger.getLogger(TaskManagerTabPanel.class.getName()).log(Level.SEVERE, null, ex);
+			}
+
+			if (this.stream instanceof ArffFileStream) {
+				streamOption = FilenameUtils
+						.getBaseName(((ArffFileStream) this.stream).arffFileOption.getFile().getName());
+				arff = true;
+			}
+		}
+		for (int i = 0; i < this.streamModel.getRowCount(); i++) {
+			if (this.streamModel.getValueAt(i, 0).equals(newTaskString)) {
+				JOptionPane.showMessageDialog(this, "The value exist", "Error", JOptionPane.ERROR_MESSAGE);
+				return;
+			}
+		}
+		if (arff == true) {
+			this.streamModel.addRow(new Object[] { newTaskString, streamOption });
+		} else {
+			this.streamModel.addRow(new Object[] { newTaskString, newTaskString });
+		}
+
+	}
+
+	private void jButtonRunActionPerformed(java.awt.event.ActionEvent evt) {
+
+		// Validations
+		if (this.jTextFieldTask.getText().equals("")) {
+
+			JOptionPane.showMessageDialog(this, "The task is not specified", "Error", JOptionPane.ERROR_MESSAGE);
+		} else if (this.jTextFieldDir.getText().equals("")) {
+			JOptionPane.showMessageDialog(this, "The result directory is not specified", "Error",
+					JOptionPane.ERROR_MESSAGE);
+		} else {
+			if (this.jTableAlgorithms.getRowCount() != 0) {
+				if (this.jTableStreams.getRowCount() != 0) {
+					List<String> stream = new ArrayList<>();
+					for (int i = 0; i < this.streamModel.getRowCount(); i++) {
+						if (this.streamModel.getValueAt(i, 0).equals("")
+								|| this.streamModel.getValueAt(i, 1).equals("")) {
+							JOptionPane.showMessageDialog(this, "Fields incompleted in Table Stream", "Error",
+									JOptionPane.ERROR_MESSAGE);
+							return;
+						}
+						if (i == 0) {
+							stream.add(this.streamModel.getValueAt(i, 1).toString());
+						} else {
+							if (stream.remove(this.streamModel.getValueAt(i, 1).toString())) {
+								stream.add(this.streamModel.getValueAt(i, 1).toString());
+								JOptionPane.showMessageDialog(this, "There are reapeted values in Table Stream",
+										"Error", JOptionPane.ERROR_MESSAGE);
+								return;
+							} else {
+								stream.add(this.streamModel.getValueAt(i, 1).toString());
+							}
+						}
+
+					}
+					List<String> algorithm = new ArrayList<>();
+					for (int i = 0; i < this.algoritmModel.getRowCount(); i++) {
+						if (this.algoritmModel.getValueAt(i, 0).equals("")
+								|| this.algoritmModel.getValueAt(i, 1).equals("")) {
+							JOptionPane.showMessageDialog(this, "Fields incompleted in Table Algorithm", "Error",
+									JOptionPane.ERROR_MESSAGE);
+							return;
+						}
+						if (i == 0) {
+							algorithm.add(this.algoritmModel.getValueAt(i, 1).toString());
+						} else {
+							if (algorithm.remove(this.algoritmModel.getValueAt(i, 1).toString())) {
+								algorithm.add(this.algoritmModel.getValueAt(i, 1).toString());
+								JOptionPane.showMessageDialog(this, "There are reapeted values in Table Algorithm",
+										"Error", JOptionPane.ERROR_MESSAGE);
+								return;
+							} else {
+								algorithm.add(this.algoritmModel.getValueAt(i, 1).toString());
+							}
+						}
+
+					} // End Validations
+					runTask();
+				} else {
+					JOptionPane.showMessageDialog(this, "You must select at least one dataset", "Error",
+							JOptionPane.ERROR_MESSAGE);
+				}
+			} else {
+				JOptionPane.showMessageDialog(this, "You must select at least one algorithm", "Error",
+						JOptionPane.ERROR_MESSAGE);
+			}
+
+		}
+
+	}
+
+	private void jButtonDelAlgoritmActionPerformed(java.awt.event.ActionEvent evt) {
+		this.algoritmModel.removeRow(this.jTableAlgorithms.getSelectedRow());
+	}
+
+	private void jButtonDelStreamActionPerformed(java.awt.event.ActionEvent evt) {
+		this.streamModel.removeRow(this.jTableStreams.getSelectedRow());
+	}
+
+	private void jButtonPauseActionPerformed(java.awt.event.ActionEvent evt) {
+		pauseSelectedTasks();
+	}
+
+	private void jButtonResumeActionPerformed(java.awt.event.ActionEvent evt) {
+		resumeSelectedTasks();
+	}
+
+	private void jButtonCancelActionPerformed(java.awt.event.ActionEvent evt) {
+		cancelSelectedTasks();
+	}
+
+	private void jButtonDeleteActionPerformed(java.awt.event.ActionEvent evt) {
+		deleteSelectedTasks();
+	}
+
+	/**
+	 * Executes the Task
+	 */
+	public void runTask() {
+		MainTask tasks[] = new MainTask[jTableAlgorithms.getModel().getRowCount()
+				* jTableStreams.getModel().getRowCount()];
+		int taskCount = 0;
+
+		String dir = "";
+
+		try {
+			this.currentTask = (MainTask) ClassOption.cliStringToObject(this.jTextFieldTask.getText(), MainTask.class,
+					null);
+		} catch (Exception ex) {
+			Logger.getLogger(TaskManagerTabPanel.class.getName()).log(Level.SEVERE, null, ex);
+		}
+		MainTask auxTask = (MainTask) this.currentTask.copy();
+
+		dir += this.resultsPath;
+
+		File f = new File(dir);
+		if (f.exists()) {
+			Object[] options = { "Yes", "No" };
+			String cancel = "NO";
+			int resp = JOptionPane.showOptionDialog(this,
+					"The selected folder is not empty. This action may overwrite "
+							+ "previous experiment results. Do you want to continue?",
+					"Warning", JOptionPane.OK_CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE, null, options, cancel);
+			if (resp == JOptionPane.OK_OPTION) {
+				ReadFile.deleteDrectory(f);
+
+			} else {
+				JOptionPane.showMessageDialog(this, "Please specify another directory", "Message",
+						JOptionPane.INFORMATION_MESSAGE);
+				return;
+			}
+		}
+		f.mkdir();
+
+		String algNames = "";
+		String streamNames = "";
+		for (int i = 0; i < jTableAlgorithms.getModel().getRowCount(); i++) {
+			String alg = jTableAlgorithms.getModel().getValueAt(i, 0).toString();
+			String algFile = jTableAlgorithms.getModel().getValueAt(i, 1).toString();
+			algNames += algFile;
+			if (i != jTableAlgorithms.getModel().getRowCount() - 1) {
+				algNames += ",";
+			}
+			for (int j = 0; j < jTableStreams.getModel().getRowCount(); j++) {
+				String stream = jTableStreams.getModel().getValueAt(j, 0).toString();
+				String streamFile = jTableStreams.getModel().getValueAt(j, 1).toString();
+				streamNames += streamFile.split(" ")[0];
+				if (j != jTableStreams.getModel().getRowCount() - 1) {
+					streamNames += ",";
+				}
+				if (i == 0) {
+					String sfile = FilenameUtils.separatorsToSystem(dir + "\\\\" + streamFile);
+					f = new File(sfile);
+					f.mkdir();
+				}
+				String task = " -l ";
+				if (alg.split(" ") != null) {
+					task += "(" + alg + ") -s (" + stream + ")" + " -d (" + dir + File.separator
+							+ streamFile.split(" ")[0] + File.separator + algFile + ".txt" + ")";
+				} else {
+					task += alg + " -s (" + stream + ")" + " -d (" + dir + File.separator + streamFile.split(" ")[0]
+							+ File.separator + algFile + ".txt" + ")";
+				}
 //                String task = FilenameUtils.separatorsToSystem(" -l (" + alg + ") -s (" + stream + ") " + " -d " + "(" + dir + "\\\\"
 //                        + streamFile.split(" ")[0] + "\\\\" + algFile + ".txt" + ")");
-                auxTask.getOptions().setViaCLIString(task);
-
-                try {
-                    tasks[taskCount] = (MainTask) auxTask.copy();
-                } catch (Exception ex) {
-                    Logger.getLogger(TaskManagerTabPanel.class.getName()).log(Level.SEVERE, null, ex);
-                }
-
-                taskCount++;
-            }
-        }
-        this.jButtonRun.setEnabled(false);
-        Buffer buffer = new Buffer(tasks);
-        int proc = 1;
-        if (!this.jTextFieldProcess.getText().equals("")) {
-            proc = Integer.parseInt(this.jTextFieldProcess.getText());
-        }
-        if (proc > tasks.length) {
-            proc = tasks.length;
-        }
-        for (int i = 0; i < proc; i++) {
-            ExpTaskThread thread = new ExpTaskThread(buffer);
-            thread.start();
-            this.taskList.add(0, thread);
-            this.taskTableModel.fireTableDataChanged();
-            this.taskTable.setRowSelectionInterval(0, 0);
-
-        }
-        Thread obs = new Thread() {
-            public void run() {
-                while (true) {
-                    int count = 0;
-                    for (ExpTaskThread thread : TaskManagerTabPanel.this.taskList) {
-                        if (thread.isCompleted == true) {
-                            count++;
-                            //System.out.println(count);
-                        }
-                    }
-                    if (count == TaskManagerTabPanel.this.taskList.size()) {
-                        TaskManagerTabPanel.this.summary.readData(resultsPath);
-                        TaskManagerTabPanel.this.plot.readData(resultsPath);
-                        TaskManagerTabPanel.this.analizeTab.readData(resultsPath);
-                        TaskManagerTabPanel.this.jButtonRun.setEnabled(true);
-                        break;
-                    }
-                }
-            }
-        };
-        obs.start();
-    }
-
-    public void runTaskCLI(String[] args) {
-        ExperimeterCLI expCLI = new ExperimeterCLI(args);
-        boolean Ok = expCLI.proccesCMD();
-        if (Ok == true) {
-            MainTask tasks[] = new MainTask[expCLI.getAlgorithms().length * expCLI.getStreams().length];
-            int taskCount = 0;
-
-            String dir = "";
-
-            try {
-                this.currentTask = (MainTask) ClassOption.cliStringToObject(
-                        expCLI.getTask(), MainTask.class, null);
-            } catch (Exception ex) {
-                Logger.getLogger(TaskManagerTabPanel.class.getName()).log(Level.SEVERE, null, ex);
-            }
-            MainTask auxTask = (MainTask) this.currentTask.copy();
-
-            resultsPath = expCLI.getResultsFolder() + File.separator + "Results";
-            dir += resultsPath;
-
-            File f = new File(dir);
-            if (f.exists()) {
-                ReadFile.deleteDrectory(f);
-            }
-            f.mkdir();
-
-            String algNames = "";
-            String streamNames = "";
-            for (int i = 0; i < expCLI.getAlgorithms().length; i++) {
-                String alg = expCLI.getAlgorithms()[i];
-                String algFile = expCLI.getAlgorithmsID()[i];
-                algNames += algFile;
-                if (i != expCLI.getAlgorithms().length - 1) {
-                    algNames += ",";
-                }
-                for (int j = 0; j < expCLI.getStreams().length; j++) {
-                    String stream = expCLI.getStreams()[j];
-                    String streamFile = expCLI.getStreamsID()[j];
-                    streamNames += streamFile.split(" ")[0];
-                    if (j != expCLI.getStreams().length - 1) {
-                        streamNames += ",";
-                    }
-                    if (i == 0) {
-                        String sfile = FilenameUtils.separatorsToSystem(dir + "\\\\" + streamFile);
-                        f = new File(sfile);
-                        f.mkdir();
-                    }
-                    String task = " -l ";
-                    if (alg.split(" ") != null) {
-                        task += "(" + alg + ") -s (" + stream + ")" + " -d (" + dir + File.separator
-                                + streamFile.split(" ")[0] + File.separator + algFile + ".txt" + ")";
-                    } else {
-                        task += alg + " -s (" + stream + ")" + " -d (" + dir + File.separator
-                                + streamFile.split(" ")[0] + File.separator + algFile + ".txt" + ")";
-                    }
+				auxTask.getOptions().setViaCLIString(task);
+
+				try {
+					tasks[taskCount] = (MainTask) auxTask.copy();
+				} catch (Exception ex) {
+					Logger.getLogger(TaskManagerTabPanel.class.getName()).log(Level.SEVERE, null, ex);
+				}
+
+				taskCount++;
+			}
+		}
+		this.jButtonRun.setEnabled(false);
+		Buffer buffer = new Buffer(tasks);
+		int proc = 1;
+		if (!this.jTextFieldProcess.getText().equals("")) {
+			proc = Integer.parseInt(this.jTextFieldProcess.getText());
+		}
+		if (proc > tasks.length) {
+			proc = tasks.length;
+		}
+		for (int i = 0; i < proc; i++) {
+			ExpTaskThread thread = new ExpTaskThread(buffer);
+			thread.start();
+			this.taskList.add(0, thread);
+			this.taskTableModel.fireTableDataChanged();
+			this.taskTable.setRowSelectionInterval(0, 0);
+
+		}
+		Thread obs = new Thread() {
+			@Override
+			public void run() {
+				while (true) {
+					int count = 0;
+					for (ExpTaskThread thread : TaskManagerTabPanel.this.taskList) {
+						if (thread.isCompleted == true) {
+							count++;
+							// System.out.println(count);
+						}
+					}
+					if (count == TaskManagerTabPanel.this.taskList.size()) {
+						TaskManagerTabPanel.this.summary.readData(resultsPath);
+						TaskManagerTabPanel.this.plot.readData(resultsPath);
+						TaskManagerTabPanel.this.analizeTab.readData(resultsPath);
+						TaskManagerTabPanel.this.jButtonRun.setEnabled(true);
+						break;
+					}
+				}
+			}
+		};
+		obs.start();
+	}
+
+	public void runTaskCLI(String[] args) {
+		ExperimeterCLI expCLI = new ExperimeterCLI(args);
+		boolean Ok = expCLI.proccesCMD();
+		if (Ok == true) {
+			MainTask tasks[] = new MainTask[expCLI.getAlgorithms().length * expCLI.getStreams().length];
+			int taskCount = 0;
+
+			String dir = "";
+
+			try {
+				this.currentTask = (MainTask) ClassOption.cliStringToObject(expCLI.getTask(), MainTask.class, null);
+			} catch (Exception ex) {
+				Logger.getLogger(TaskManagerTabPanel.class.getName()).log(Level.SEVERE, null, ex);
+			}
+			MainTask auxTask = (MainTask) this.currentTask.copy();
+
+			resultsPath = expCLI.getResultsFolder() + File.separator + "Results";
+			dir += resultsPath;
+
+			File f = new File(dir);
+			if (f.exists()) {
+				ReadFile.deleteDrectory(f);
+			}
+			f.mkdir();
+
+			String algNames = "";
+			String streamNames = "";
+			for (int i = 0; i < expCLI.getAlgorithms().length; i++) {
+				String alg = expCLI.getAlgorithms()[i];
+				String algFile = expCLI.getAlgorithmsID()[i];
+				algNames += algFile;
+				if (i != expCLI.getAlgorithms().length - 1) {
+					algNames += ",";
+				}
+				for (int j = 0; j < expCLI.getStreams().length; j++) {
+					String stream = expCLI.getStreams()[j];
+					String streamFile = expCLI.getStreamsID()[j];
+					streamNames += streamFile.split(" ")[0];
+					if (j != expCLI.getStreams().length - 1) {
+						streamNames += ",";
+					}
+					if (i == 0) {
+						String sfile = FilenameUtils.separatorsToSystem(dir + "\\\\" + streamFile);
+						f = new File(sfile);
+						f.mkdir();
+					}
+					String task = " -l ";
+					if (alg.split(" ") != null) {
+						task += "(" + alg + ") -s (" + stream + ")" + " -d (" + dir + File.separator
+								+ streamFile.split(" ")[0] + File.separator + algFile + ".txt" + ")";
+					} else {
+						task += alg + " -s (" + stream + ")" + " -d (" + dir + File.separator + streamFile.split(" ")[0]
+								+ File.separator + algFile + ".txt" + ")";
+					}
 //                String task = FilenameUtils.separatorsToSystem(" -l (" + alg + ") -s (" + stream + ") " + " -d " + "(" + dir + "\\\\"
 //                        + streamFile.split(" ")[0] + "\\\\" + algFile + ".txt" + ")");
-                    auxTask.getOptions().setViaCLIString(task);
-
-                    try {
-                        tasks[taskCount] = (MainTask) auxTask.copy();
-                    } catch (Exception ex) {
-                        Logger.getLogger(TaskManagerTabPanel.class.getName()).log(Level.SEVERE, null, ex);
-                    }
-
-                    taskCount++;
-                }
-            }
-
-            Buffer buffer = new Buffer(tasks);
-            int proc = expCLI.getThreads();
-
-            if (proc > tasks.length) {
-                proc = tasks.length;
-            }
-            for (int i = 0; i < proc; i++) {
-                ExpTaskThread thread = new ExpTaskThread(buffer);
-                thread.start();
-                this.taskList.add(0, thread);
-                this.taskTableModel.fireTableDataChanged();
-                this.taskTable.setRowSelectionInterval(0, 0);
-
-            }
-
-            System.err.println(Globals.getWorkbenchInfoString());
-            while (true) {
-                int count = 0;
-                int progressAnimIndex = 0;
-                StringBuilder progressLine = new StringBuilder();
-                progressLine.append('\r');
-
-                for (ExpTaskThread thread : this.taskList) {
-                    //System.out.println(thread.getCurrentActivityFracComplete()*100);
-
-                    if (thread.isCompleted == true) {
-                        count++;
-                        //System.out.println(count);
-                    }
-                    progressLine.append(StringUtils.secondsToDHMSString(thread.getCPUSecondsElapsed()));
-                    progressLine.append(" [");
-                    progressLine.append(thread.getCurrentStatusString());
-                    progressLine.append("] ");
-                    double fracComplete = thread.getCurrentActivityFracComplete();
-                    if (fracComplete >= 0.0) {
-                        progressLine.append(StringUtils.doubleToString(
-                                fracComplete * 100.0, 2, 2));
-                        progressLine.append("% ");
-
-                    }
-                    //progressLine.append(thread.getCurrentActivityString());
-
-                }
-                System.out.print(progressLine);
-                System.out.print('\r');
-                System.out.flush();
-                try {
-                    Thread.sleep(1000);
-
-                } catch (InterruptedException ignored) {
-                    // wake up
-                }
-                if (count == this.taskList.size()) {
-                    TaskManagerTabPanel.this.summary.readData(resultsPath);
-                    // TaskManagerTabPanel.this.plot.readData(resultsPath);
-                    //  TaskManagerTabPanel.this.analizeTab.readData(resultsPath);
-                    System.out.println();
-                    System.out.println("To perform summaries type summary or exit to finish");
-                    Scanner sc = new Scanner(System.in);
-                    String option = sc.nextLine();
-                    while (!option.equals("exit")) {
-                        switch (option) {
-                            case "summary":
-                                System.out.println("Measures:");
-                                for (int i = 0; i < TaskManagerTabPanel.this.summary.measures.get(0).split(",").length; i++) {
-                                    System.out.println("[" + i + "] " + TaskManagerTabPanel.this.summary.measures.get(0).split(",")[i]);
-                                }
-                                System.out.println("Select Measeures: type -h for help");
-                                while (true) {
-                                    String arg[] = sc.nextLine().split(" ");
-                                    boolean out = expCLI.summary1CMD(arg);
-                                    if (out == true) {
-                                        if (expCLI.measures != null) {
-                                            String[] measures = new String[expCLI.measures.length];
-                                            if (measures.length == expCLI.types.length) {
-                                                for (int i = 0; i < measures.length; i++) {
-                                                    measures[i] = TaskManagerTabPanel.this.summary.measures.get(0).split(",")[expCLI.measures[i]];
-                                                }
-                                                TaskManagerTabPanel.this.summary.summaryCMD(measures, expCLI.types);
-
-                                                break;
-                                            } else {
-                                                System.out.println("There must be the same number of measures and types, please enter the commands again");
-                                            }
-                                        }
-                                    }
-
-                                }
-                                break;
-                        }
-                        System.out.println("To perform summaries type summary or exit to finish");
-                        option = sc.nextLine();
-                    }
+					auxTask.getOptions().setViaCLIString(task);
+
+					try {
+						tasks[taskCount] = (MainTask) auxTask.copy();
+					} catch (Exception ex) {
+						Logger.getLogger(TaskManagerTabPanel.class.getName()).log(Level.SEVERE, null, ex);
+					}
+
+					taskCount++;
+				}
+			}
+
+			Buffer buffer = new Buffer(tasks);
+			int proc = expCLI.getThreads();
+
+			if (proc > tasks.length) {
+				proc = tasks.length;
+			}
+			for (int i = 0; i < proc; i++) {
+				ExpTaskThread thread = new ExpTaskThread(buffer);
+				thread.start();
+				this.taskList.add(0, thread);
+				this.taskTableModel.fireTableDataChanged();
+				this.taskTable.setRowSelectionInterval(0, 0);
+
+			}
+
+			System.err.println(Globals.getWorkbenchInfoString());
+			while (true) {
+				int count = 0;
+				int progressAnimIndex = 0;
+				StringBuilder progressLine = new StringBuilder();
+				progressLine.append('\r');
+
+				for (ExpTaskThread thread : this.taskList) {
+					// System.out.println(thread.getCurrentActivityFracComplete()*100);
+
+					if (thread.isCompleted == true) {
+						count++;
+						// System.out.println(count);
+					}
+					progressLine.append(StringUtils.secondsToDHMSString(thread.getCPUSecondsElapsed()));
+					progressLine.append(" [");
+					progressLine.append(thread.getCurrentStatusString());
+					progressLine.append("] ");
+					double fracComplete = thread.getCurrentActivityFracComplete();
+					if (fracComplete >= 0.0) {
+						progressLine.append(StringUtils.doubleToString(fracComplete * 100.0, 2, 2));
+						progressLine.append("% ");
+
+					}
+					// progressLine.append(thread.getCurrentActivityString());
+
+				}
+				System.out.print(progressLine);
+				System.out.print('\r');
+				System.out.flush();
+				try {
+					Thread.sleep(1000);
+
+				} catch (InterruptedException ignored) {
+					// wake up
+				}
+				if (count == this.taskList.size()) {
+					TaskManagerTabPanel.this.summary.readData(resultsPath);
+					// TaskManagerTabPanel.this.plot.readData(resultsPath);
+					// TaskManagerTabPanel.this.analizeTab.readData(resultsPath);
+					System.out.println();
+					System.out.println("To perform summaries type summary or exit to finish");
+					Scanner sc = new Scanner(System.in);
+					String option = sc.nextLine();
+					while (!option.equals("exit")) {
+						switch (option) {
+						case "summary":
+							System.out.println("Measures:");
+							for (int i = 0; i < TaskManagerTabPanel.this.summary.measures.get(0)
+									.split(",").length; i++) {
+								System.out.println("[" + i + "] "
+										+ TaskManagerTabPanel.this.summary.measures.get(0).split(",")[i]);
+							}
+							System.out.println("Select Measeures: type -h for help");
+							while (true) {
+								String arg[] = sc.nextLine().split(" ");
+								boolean out = expCLI.summary1CMD(arg);
+								if (out == true) {
+									if (expCLI.measures != null) {
+										String[] measures = new String[expCLI.measures.length];
+										if (measures.length == expCLI.types.length) {
+											for (int i = 0; i < measures.length; i++) {
+												measures[i] = TaskManagerTabPanel.this.summary.measures.get(0)
+														.split(",")[expCLI.measures[i]];
+											}
+											TaskManagerTabPanel.this.summary.summaryCMD(measures, expCLI.types);
+
+											break;
+										} else {
+											System.out.println(
+													"There must be the same number of measures and types, please enter the commands again");
+										}
+									}
+								}
+
+							}
+							break;
+						}
+						System.out.println("To perform summaries type summary or exit to finish");
+						option = sc.nextLine();
+					}
 //                       String arg = sc.nextLine();
 //                       System.out.println(arg);
-                    break;
-                }
-            }
-        }
-    }
-
-    /**
-     *
-     * @return a task thread
-     */
-    
-     public void taskSelectionChanged() {
-        ExpTaskThread[] selectedTasks = getSelectedTasks();
-        if (selectedTasks.length == 1) {
-           if (this.previewPanel != null) {
-                this.previewPanel.setTaskThreadToPreview(selectedTasks[0]);
-            }
-        } else {
-            this.previewPanel.setTaskThreadToPreview(null);
-        }
-    }
-    public ExpTaskThread[] getSelectedTasks() {
-        int[] selectedRows = this.taskTable.getSelectedRows();
-        ExpTaskThread[] selectedTasks = new ExpTaskThread[selectedRows.length];
-        for (int i = 0; i < selectedRows.length; i++) {
-            selectedTasks[i] = this.taskList.get(selectedRows[i]);
-        }
-        return selectedTasks;
-    }
-
-    /**
-     * Pause tasks
-     */
-    public void pauseSelectedTasks() {
-        ExpTaskThread[] selectedTasks = getSelectedTasks();
-        for (ExpTaskThread thread : selectedTasks) {
-            thread.pauseTask();
-        }
-    }
-
-    /**
-     * Reseme task
-     */
-    public void resumeSelectedTasks() {
-        ExpTaskThread[] selectedTasks = getSelectedTasks();
-        for (ExpTaskThread thread : selectedTasks) {
-            thread.resumeTask();
-        }
-    }
-
-    /**
-     * Cancel task
-     */
-    public void cancelSelectedTasks() {
-        ExpTaskThread[] selectedTasks = getSelectedTasks();
-        for (ExpTaskThread thread : selectedTasks) {
-            thread.cancelTask();
-        }
-    }
-
-    /**
-     * Deletes selected tasks
-     */
-    public void deleteSelectedTasks() {
-        ExpTaskThread[] selectedTasks = getSelectedTasks();
-        for (ExpTaskThread thread : selectedTasks) {
-            thread.cancelTask();
-            this.taskList.remove(thread);
-        }
-        this.taskTableModel.fireTableDataChanged();
-    }
-
-    private void SaveConfig(String path) {
-        Properties prop = new Properties();
-        String algShortNames = "", algCommand = "";
-        String streamShortNames = "", streamCommand = "";
-        String expCLI = "";
-        if (jTableAlgorithms.getRowCount() != 0) {
-            algCommand += jTableAlgorithms.getModel().getValueAt(0, 0);
-            algShortNames += jTableAlgorithms.getModel().getValueAt(0, 1);
-        }
-        if (jTableStreams.getRowCount() != 0) {
-            streamCommand += jTableStreams.getModel().getValueAt(0, 0);
-            streamShortNames += jTableStreams.getModel().getValueAt(0, 1);
-        }
-        for (int i = 1; i < jTableAlgorithms.getRowCount(); i++) {
-            algCommand += "," + jTableAlgorithms.getModel().getValueAt(i, 0);
-            algShortNames += "," + jTableAlgorithms.getModel().getValueAt(i, 1);
-        }
-        for (int j = 1; j < jTableStreams.getRowCount(); j++) {
-            streamCommand += "," + jTableStreams.getModel().getValueAt(j, 0);
-            streamShortNames += "," + jTableStreams.getModel().getValueAt(j, 1);
-        }
-        expCLI += "-ts \""+jTextFieldTask.getText()+"\" ";
-        expCLI += "-ls \""+algCommand+"\" ";
-        expCLI += "-lss \""+algShortNames+"\" ";
-        expCLI += "-ds \""+streamCommand+"\" ";
-        expCLI += "-dss \""+streamShortNames+"\" ";
-        expCLI += "-th "+jTextFieldProcess.getText()+" ";
-        expCLI += "-rf \""+FilenameUtils.separatorsToSystem(this.jTextFieldDir.getText())+"\" ";
-        prop.setProperty("expCLI", expCLI);
-       
-        prop.setProperty("task", jTextFieldTask.getText());
-
-        prop.setProperty("processors", jTextFieldProcess.getText());
-
-        prop.setProperty("algorithmCommand", algCommand);
-        prop.setProperty("algorithmShortNames", algShortNames);
-
-        prop.setProperty("streamCommand", streamCommand);
-        prop.setProperty("streamShortNames", streamShortNames);
-        prop.setProperty("ResultsDir", this.resultsPath);
-        path += ".properties";
-        FileOutputStream propertiesFile = null;
-        File f = new File(path);
-        if (!f.exists()) {
-            f.delete();
-        }
-        try {
-            propertiesFile = new FileOutputStream(path);
-        } catch (FileNotFoundException ex) {
-            JOptionPane.showMessageDialog(this, "Problems creating properties file",
-                    "Error", JOptionPane.ERROR_MESSAGE);
-        }
-        try {
-            prop.store(propertiesFile, "file");
-            JOptionPane.showMessageDialog(this, "Experiments saved at " + path,
-                    "", JOptionPane.INFORMATION_MESSAGE);
-        } catch (IOException ex) {
-            JOptionPane.showMessageDialog(this, "Problems creating properties file",
-                    "Error", JOptionPane.ERROR_MESSAGE);
-        }
-
-    }
-
-    /**
-     * Opens a previously saved configuration
-     *
-     * @param path
-     */
-    public void openConfig(String path) {
-
-        Properties properties = new Properties();
-        try {
-            properties.load(new FileInputStream(path));
-        } catch (IOException ex) {
-            JOptionPane.showMessageDialog(this, "Problems reading the properties file",
-                    "Error", JOptionPane.ERROR_MESSAGE);
-        }
-        // read datasets
-        this.jTextFieldProcess.setText(properties.getProperty("processors"));
-        this.jTextFieldTask.setText(properties.getProperty("task"));
-        try {
-            this.currentTask = (MainTask) ClassOption.cliStringToObject(
-                    this.jTextFieldTask.getText(), MainTask.class, null);
-        } catch (Exception ex) {
-            Logger.getLogger(TaskManagerTabPanel.class.getName()).log(Level.SEVERE, null, ex);
-        }
-        this.jTextFieldDir.setText(properties.getProperty("ResultsDir"));
-        this.resultsPath = this.jTextFieldDir.getText();
-        String[] streamShortNames = properties.getProperty("streamShortNames").split(",");
-        String[] streamCommand = properties.getProperty("streamCommand").split(",");
-        String[] algShortNames = properties.getProperty("algorithmShortNames").split(",");
-        String[] algorithmCommand = properties.getProperty("algorithmCommand").split(",");
-        cleanTables();
-        for (int i = 0; i < streamShortNames.length; i++) {
-            this.streamModel.addRow(new Object[]{streamCommand[i], streamShortNames[i]});
-        }
-        for (int i = 0; i < algShortNames.length; i++) {
-            this.algoritmModel.addRow(new Object[]{algorithmCommand[i], algShortNames[i]});
-        }
-
-    }
-
-    /**
-     * Clean the tables
-     */
-    public void cleanTables() {
-        try {
-            DefaultTableModel algModel = (DefaultTableModel) jTableAlgorithms.getModel();
-            DefaultTableModel strModel = (DefaultTableModel) jTableStreams.getModel();
-            int rows = jTableAlgorithms.getRowCount();
-            int srow = jTableStreams.getRowCount();
-            int trow = this.taskList.size();
-            for (int i = 0; i < rows; i++) {
-                algModel.removeRow(0);
-            }
-            for (int i = 0; i < srow; i++) {
-                strModel.removeRow(0);
-            }
-            for (int i = 0; i < trow; i++) {
-                this.taskList.remove(0);
-            }
-            this.taskTableModel.fireTableDataChanged();
-        } catch (Exception e) {
-            JOptionPane.showMessageDialog(null, "Error al limpiar la tabla.");
-        }
-    }
-
-    /**
-     * Main method
-     *
-     * @param args
-     */
-    public static void main(String[] args) {
-        try {
-            LookAndFeel.install();
-            javax.swing.SwingUtilities.invokeLater(new Runnable() {
-
-                @Override
-                public void run() {
-                    if (args.length != 0) {
-                        //System.out.println("OK");
-                        TaskManagerTabPanel panel = new TaskManagerTabPanel();
-                        panel.runTaskCLI(args);
-                        System.exit(0);
-
-                    } else {
-                        createAndShowGUI();
-                    }
-                }
-            });
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
+					break;
+				}
+			}
+		}
+	}
+
+	/**
+	 *
+	 * @return a task thread
+	 */
+
+	public void taskSelectionChanged() {
+		ExpTaskThread[] selectedTasks = getSelectedTasks();
+		if (selectedTasks.length == 1) {
+			if (this.previewPanel != null) {
+				this.previewPanel.setTaskThreadToPreview(selectedTasks[0]);
+			}
+		} else {
+			this.previewPanel.setTaskThreadToPreview(null);
+		}
+	}
+
+	public ExpTaskThread[] getSelectedTasks() {
+		int[] selectedRows = this.taskTable.getSelectedRows();
+		ExpTaskThread[] selectedTasks = new ExpTaskThread[selectedRows.length];
+		for (int i = 0; i < selectedRows.length; i++) {
+			selectedTasks[i] = this.taskList.get(selectedRows[i]);
+		}
+		return selectedTasks;
+	}
+
+	/**
+	 * Pause tasks
+	 */
+	public void pauseSelectedTasks() {
+		ExpTaskThread[] selectedTasks = getSelectedTasks();
+		for (ExpTaskThread thread : selectedTasks) {
+			thread.pauseTask();
+		}
+	}
+
+	/**
+	 * Reseme task
+	 */
+	public void resumeSelectedTasks() {
+		ExpTaskThread[] selectedTasks = getSelectedTasks();
+		for (ExpTaskThread thread : selectedTasks) {
+			thread.resumeTask();
+		}
+	}
+
+	/**
+	 * Cancel task
+	 */
+	public void cancelSelectedTasks() {
+		ExpTaskThread[] selectedTasks = getSelectedTasks();
+		for (ExpTaskThread thread : selectedTasks) {
+			thread.cancelTask();
+		}
+	}
+
+	/**
+	 * Deletes selected tasks
+	 */
+	public void deleteSelectedTasks() {
+		ExpTaskThread[] selectedTasks = getSelectedTasks();
+		for (ExpTaskThread thread : selectedTasks) {
+			thread.cancelTask();
+			this.taskList.remove(thread);
+		}
+		this.taskTableModel.fireTableDataChanged();
+	}
+
+	private void SaveConfig(String path) {
+		Properties prop = new Properties();
+		String algShortNames = "", algCommand = "";
+		String streamShortNames = "", streamCommand = "";
+		String expCLI = "";
+		if (jTableAlgorithms.getRowCount() != 0) {
+			algCommand += jTableAlgorithms.getModel().getValueAt(0, 0);
+			algShortNames += jTableAlgorithms.getModel().getValueAt(0, 1);
+		}
+		if (jTableStreams.getRowCount() != 0) {
+			streamCommand += jTableStreams.getModel().getValueAt(0, 0);
+			streamShortNames += jTableStreams.getModel().getValueAt(0, 1);
+		}
+		for (int i = 1; i < jTableAlgorithms.getRowCount(); i++) {
+			algCommand += "," + jTableAlgorithms.getModel().getValueAt(i, 0);
+			algShortNames += "," + jTableAlgorithms.getModel().getValueAt(i, 1);
+		}
+		for (int j = 1; j < jTableStreams.getRowCount(); j++) {
+			streamCommand += "," + jTableStreams.getModel().getValueAt(j, 0);
+			streamShortNames += "," + jTableStreams.getModel().getValueAt(j, 1);
+		}
+		expCLI += "-ts \"" + jTextFieldTask.getText() + "\" ";
+		expCLI += "-ls \"" + algCommand + "\" ";
+		expCLI += "-lss \"" + algShortNames + "\" ";
+		expCLI += "-ds \"" + streamCommand + "\" ";
+		expCLI += "-dss \"" + streamShortNames + "\" ";
+		expCLI += "-th " + jTextFieldProcess.getText() + " ";
+		expCLI += "-rf \"" + FilenameUtils.separatorsToSystem(this.jTextFieldDir.getText()) + "\" ";
+		prop.setProperty("expCLI", expCLI);
+
+		prop.setProperty("task", jTextFieldTask.getText());
+
+		prop.setProperty("processors", jTextFieldProcess.getText());
+
+		prop.setProperty("algorithmCommand", algCommand);
+		prop.setProperty("algorithmShortNames", algShortNames);
+
+		prop.setProperty("streamCommand", streamCommand);
+		prop.setProperty("streamShortNames", streamShortNames);
+		prop.setProperty("ResultsDir", this.resultsPath);
+		path += ".properties";
+		FileOutputStream propertiesFile = null;
+		File f = new File(path);
+		if (!f.exists()) {
+			f.delete();
+		}
+		try {
+			propertiesFile = new FileOutputStream(path);
+		} catch (FileNotFoundException ex) {
+			JOptionPane.showMessageDialog(this, "Problems creating properties file", "Error",
+					JOptionPane.ERROR_MESSAGE);
+		}
+		try {
+			prop.store(propertiesFile, "file");
+			JOptionPane.showMessageDialog(this, "Experiments saved at " + path, "", JOptionPane.INFORMATION_MESSAGE);
+		} catch (IOException ex) {
+			JOptionPane.showMessageDialog(this, "Problems creating properties file", "Error",
+					JOptionPane.ERROR_MESSAGE);
+		}
+
+	}
+
+	/**
+	 * Opens a previously saved configuration
+	 *
+	 * @param path
+	 */
+	public void openConfig(String path) {
+
+		Properties properties = new Properties();
+		try {
+			properties.load(new FileInputStream(path));
+		} catch (IOException ex) {
+			JOptionPane.showMessageDialog(this, "Problems reading the properties file", "Error",
+					JOptionPane.ERROR_MESSAGE);
+		}
+		// read datasets
+		this.jTextFieldProcess.setText(properties.getProperty("processors"));
+		this.jTextFieldTask.setText(properties.getProperty("task"));
+		try {
+			this.currentTask = (MainTask) ClassOption.cliStringToObject(this.jTextFieldTask.getText(), MainTask.class,
+					null);
+		} catch (Exception ex) {
+			Logger.getLogger(TaskManagerTabPanel.class.getName()).log(Level.SEVERE, null, ex);
+		}
+		this.jTextFieldDir.setText(properties.getProperty("ResultsDir"));
+		this.resultsPath = this.jTextFieldDir.getText();
+		String[] streamShortNames = properties.getProperty("streamShortNames").split(",");
+		String[] streamCommand = properties.getProperty("streamCommand").split(",");
+		String[] algShortNames = properties.getProperty("algorithmShortNames").split(",");
+		String[] algorithmCommand = properties.getProperty("algorithmCommand").split(",");
+		cleanTables();
+		for (int i = 0; i < streamShortNames.length; i++) {
+			this.streamModel.addRow(new Object[] { streamCommand[i], streamShortNames[i] });
+		}
+		for (int i = 0; i < algShortNames.length; i++) {
+			this.algoritmModel.addRow(new Object[] { algorithmCommand[i], algShortNames[i] });
+		}
+
+	}
+
+	/**
+	 * Clean the tables
+	 */
+	public void cleanTables() {
+		try {
+			DefaultTableModel algModel = (DefaultTableModel) jTableAlgorithms.getModel();
+			DefaultTableModel strModel = (DefaultTableModel) jTableStreams.getModel();
+			int rows = jTableAlgorithms.getRowCount();
+			int srow = jTableStreams.getRowCount();
+			int trow = this.taskList.size();
+			for (int i = 0; i < rows; i++) {
+				algModel.removeRow(0);
+			}
+			for (int i = 0; i < srow; i++) {
+				strModel.removeRow(0);
+			}
+			for (int i = 0; i < trow; i++) {
+				this.taskList.remove(0);
+			}
+			this.taskTableModel.fireTableDataChanged();
+		} catch (Exception e) {
+			JOptionPane.showMessageDialog(null, "Error al limpiar la tabla.");
+		}
+	}
+
+	/**
+	 * Main method
+	 *
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		try {
+			LookAndFeel.install();
+			javax.swing.SwingUtilities.invokeLater(new Runnable() {
+
+				@Override
+				public void run() {
+					if (args.length != 0) {
+						// System.out.println("OK");
+						TaskManagerTabPanel panel = new TaskManagerTabPanel();
+						panel.runTaskCLI(args);
+						System.exit(0);
+
+					} else {
+						createAndShowGUI();
+					}
+				}
+			});
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/TaskTextViewerPanel.java b/moa/src/main/java/moa/gui/experimentertab/TaskTextViewerPanel.java
index e87c2c03c..f82bf4537 100644
--- a/moa/src/main/java/moa/gui/experimentertab/TaskTextViewerPanel.java
+++ b/moa/src/main/java/moa/gui/experimentertab/TaskTextViewerPanel.java
@@ -16,7 +16,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab;
 
@@ -40,13 +40,14 @@
 import javax.swing.JPanel;
 import javax.swing.JScrollPane;
 import javax.swing.JTextArea;
+
 import moa.evaluation.MeasureCollection;
 import moa.gui.FileExtensionFilter;
 import moa.gui.GUIUtils;
 import moa.gui.conceptdrift.CDTaskManagerPanel;
 import moa.gui.experimentertab.ExpPreviewPanel.TypePanel;
 import moa.streams.clustering.ClusterEvent;
-import moa.tasks.ConceptDriftMainTask;
+import moa.tasks.conceptdrift.ConceptDriftMainTask;
 
 /**
  * This panel displays text. Used to output the results of tasks.
@@ -56,506 +57,509 @@
  */
 public class TaskTextViewerPanel extends JPanel implements ActionListener {
 
-    private static final long serialVersionUID = 1L;
-
-    public static String exportFileExtension = "txt";
-
-    protected JTextArea textArea;
-
-    protected JScrollPane scrollPane;
-
-    protected JButton exportButton;
-
-    private javax.swing.JPanel topWrapper;
-
-    private javax.swing.JSplitPane jSplitPane1;
-
-   //Added for stream events
-    protected CDTaskManagerPanel taskManagerPanel;
-    
-    protected TypePanel typePanel;
-    
-    public void initVisualEvalPanel() {
-        acc1[0] = getNewMeasureCollection();
-        acc2[0] = getNewMeasureCollection();
-        if (clusteringVisualEvalPanel1 != null) {
-            panelEvalOutput.remove(clusteringVisualEvalPanel1);
-        }
-        clusteringVisualEvalPanel1 = new moa.gui.clustertab.ClusteringVisualEvalPanel();
-        clusteringVisualEvalPanel1.setMeasures(acc1, acc2, this);
-        this.graphCanvas.setGraph(acc1[0], acc2[0], 0, 1000); 
-        this.graphCanvas.forceAddEvents();
-        clusteringVisualEvalPanel1.setMinimumSize(new java.awt.Dimension(280, 118));
-        clusteringVisualEvalPanel1.setPreferredSize(new java.awt.Dimension(290, 115));
-         panelEvalOutput.add(clusteringVisualEvalPanel1, gridBagConstraints);
-    }
-        public TaskTextViewerPanel() {
-           this(TypePanel.CLASSIFICATION, null);
-        }
-        
-        public java.awt.GridBagConstraints gridBagConstraints;
-        
-        public TaskTextViewerPanel(ExpPreviewPanel.TypePanel typePanel, CDTaskManagerPanel taskManagerPanel) { 
-        this.typePanel = typePanel;
-        this.taskManagerPanel = taskManagerPanel;
-        jSplitPane1 = new javax.swing.JSplitPane();
-        topWrapper = new javax.swing.JPanel();
-
-        this.textArea = new JTextArea();
-        this.textArea.setEditable(false);
-        this.textArea.setFont(new Font("Monospaced", Font.PLAIN, 12));
-        this.exportButton = new JButton("Export as .txt file...");
-        this.exportButton.setEnabled(false);
-        JPanel buttonPanel = new JPanel();
-        buttonPanel.setLayout(new GridLayout(1, 2));
-        buttonPanel.add(this.exportButton);
-        topWrapper.setLayout(new BorderLayout());
-        this.scrollPane = new JScrollPane(this.textArea);
-        topWrapper.add(this.scrollPane, BorderLayout.CENTER);
-        topWrapper.add(buttonPanel, BorderLayout.SOUTH);
-        this.exportButton.addActionListener(new ActionListener() {
-
-            public void actionPerformed(ActionEvent e) {
-                JFileChooser fileChooser = new JFileChooser();
-                fileChooser.setAcceptAllFileFilterUsed(true);
-                fileChooser.addChoosableFileFilter(new FileExtensionFilter(
-                        exportFileExtension));
-                if (fileChooser.showSaveDialog(TaskTextViewerPanel.this) == JFileChooser.APPROVE_OPTION) {
-                    File chosenFile = fileChooser.getSelectedFile();
-                    String fileName = chosenFile.getPath();
-                    if (!chosenFile.exists()
-                            && !fileName.endsWith(exportFileExtension)) {
-                        fileName = fileName + "." + exportFileExtension;
-                    }
-                    try {
-                        PrintWriter out = new PrintWriter(new BufferedWriter(
-                                new FileWriter(fileName)));
-                        out.write(TaskTextViewerPanel.this.textArea.getText());
-                        out.close();
-                    } catch (IOException ioe) {
-                        GUIUtils.showExceptionDialog(
-                                TaskTextViewerPanel.this.exportButton,
-                                "Problem saving file " + fileName, ioe);
-                    }
-                }
-            }
-        });
-        //topWrapper.add(this.scrollPane);
-        //topWrapper.add(buttonPanel);
-
-        panelEvalOutput = new javax.swing.JPanel();
-        //clusteringVisualEvalPanel1 = new moa.gui.clustertab.ClusteringVisualEvalPanel();
-        graphPanel = new javax.swing.JPanel();
-        graphPanelControlTop = new javax.swing.JPanel();
-        buttonZoomInY = new javax.swing.JButton();
-        buttonZoomOutY = new javax.swing.JButton();
-        labelEvents = new javax.swing.JLabel();
-        graphScrollPanel = new javax.swing.JScrollPane();
-        graphCanvas = new moa.gui.visualization.GraphCanvas();
-        // New EventClusters
-        //clusterEvents = new  ArrayList<ClusterEvent>();
-        //clusterEvents.add(new ClusterEvent(this,100,"Change", "Drift"));
-        //graphCanvas.setClusterEventsList(clusterEvents);
-
-        graphPanelControlBottom = new javax.swing.JPanel();
-        buttonZoomInX = new javax.swing.JButton();
-        buttonZoomOutX = new javax.swing.JButton();
-
-        setLayout(new java.awt.GridBagLayout());
-
-        jSplitPane1.setDividerLocation(200);
-        jSplitPane1.setOrientation(javax.swing.JSplitPane.VERTICAL_SPLIT);
-
-        //topWrapper.setPreferredSize(new java.awt.Dimension(688, 500));
-        //topWrapper.setLayout(new java.awt.GridBagLayout());
-
-        jSplitPane1.setLeftComponent(topWrapper);
-
-        panelEvalOutput.setBorder(javax.swing.BorderFactory.createTitledBorder("Evaluation"));
-        panelEvalOutput.setLayout(new java.awt.GridBagLayout());
-
-        //clusteringVisualEvalPanel1.setMinimumSize(new java.awt.Dimension(280, 118));
-        //clusteringVisualEvalPanel1.setPreferredSize(new java.awt.Dimension(290, 115));
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
-        gridBagConstraints.weighty = 1.0;
-        //panelEvalOutput.add(clusteringVisualEvalPanel1, gridBagConstraints);
-        initVisualEvalPanel();
-
-
-        graphPanel.setBorder(javax.swing.BorderFactory.createTitledBorder("Plot"));
-        graphPanel.setPreferredSize(new java.awt.Dimension(530, 115));
-        graphPanel.setLayout(new java.awt.GridBagLayout());
-
-        graphPanelControlTop.setLayout(new java.awt.GridBagLayout());
-
-        buttonZoomInY.setText("Zoom in Y");
-        buttonZoomInY.addActionListener(new java.awt.event.ActionListener() {
-
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonZoomInYActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
-        graphPanelControlTop.add(buttonZoomInY, gridBagConstraints);
-
-        buttonZoomOutY.setText("Zoom out Y");
-        buttonZoomOutY.addActionListener(new java.awt.event.ActionListener() {
-
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonZoomOutYActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
-        graphPanelControlTop.add(buttonZoomOutY, gridBagConstraints);
-
-        labelEvents.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
-        gridBagConstraints.weightx = 1.0;
-        gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
-        graphPanelControlTop.add(labelEvents, gridBagConstraints);
-
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
-        gridBagConstraints.weightx = 1.0;
-        graphPanel.add(graphPanelControlTop, gridBagConstraints);
-
-        graphCanvas.setPreferredSize(new java.awt.Dimension(500, 111));
-
-        javax.swing.GroupLayout graphCanvasLayout = new javax.swing.GroupLayout(graphCanvas);
-        graphCanvas.setLayout(graphCanvasLayout);
-        graphCanvasLayout.setHorizontalGroup(
-                graphCanvasLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 515, Short.MAX_VALUE));
-        graphCanvasLayout.setVerticalGroup(
-                graphCanvasLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 128, Short.MAX_VALUE));
-
-        graphScrollPanel.setViewportView(graphCanvas);
-
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 1;
-        gridBagConstraints.gridwidth = 2;
-        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
-        gridBagConstraints.weightx = 1.0;
-        gridBagConstraints.weighty = 1.0;
-        gridBagConstraints.insets = new java.awt.Insets(2, 2, 2, 2);
-        graphPanel.add(graphScrollPanel, gridBagConstraints);
-
-        buttonZoomInX.setText("Zoom in X");
-        buttonZoomInX.addActionListener(new java.awt.event.ActionListener() {
-
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonZoomInXActionPerformed(evt);
-            }
-        });
-        graphPanelControlBottom.add(buttonZoomInX);
-
-        buttonZoomOutX.setText("Zoom out X");
-        buttonZoomOutX.addActionListener(new java.awt.event.ActionListener() {
-
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonZoomOutXActionPerformed(evt);
-            }
-        });
-        graphPanelControlBottom.add(buttonZoomOutX);
-
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 1;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
-        graphPanel.add(graphPanelControlBottom, gridBagConstraints);
-
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
-        gridBagConstraints.weightx = 2.0;
-        gridBagConstraints.weighty = 1.0;
-        panelEvalOutput.add(graphPanel, gridBagConstraints);
-
-        jSplitPane1.setRightComponent(panelEvalOutput);
-
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
-        gridBagConstraints.weightx = 1.0;
-        gridBagConstraints.weighty = 1.0;
-        add(jSplitPane1, gridBagConstraints);
-
-       // acc1[0] = getNewMeasureCollection();
-
-        //acc2[0] = getNewMeasureCollection();
-        //clusteringVisualEvalPanel1.setMeasures(acc1, acc2, this);
-        //this.graphCanvas.setGraph(acc1[0], acc2[0], 0, 1000);
-
-    }
-
-    public void setText(String newText) {
-        Point p = this.scrollPane.getViewport().getViewPosition();
-        this.textArea.setText(newText);
-        this.scrollPane.getViewport().setViewPosition(p);
-        this.exportButton.setEnabled(newText != null);
-        setGraph(newText);
-    }
-
-    protected MeasureCollection[] acc1 = new MeasureCollection[1];
-
-    protected MeasureCollection[] acc2 = new MeasureCollection[1];
-
-    protected String secondLine = "";
-
-    protected double round(double d) {
-        return (Math.rint(d * 100) / 100);
-    }
-
-    protected MeasureCollection getNewMeasureCollection() {
-        /*if (this.taskManagerPanel != null) {
-            return new ChangeDetectionMeasures();
-        } else {
-            return new Accuracy();
-        }*/
-        return this.typePanel.getMeasureCollection();
-    }
-
-    public void setGraph(String preview) {
-        //Change the graph when there is change in the text
-        double processFrequency = 1000;
-        if (preview != null && !preview.equals("")) {
-            MeasureCollection oldAccuracy = acc1[0];
-            acc1[0] = getNewMeasureCollection();
-            Scanner scanner = new Scanner(preview);
-            String firstLine = scanner.nextLine();
-            boolean isSecondLine = true;
-
-            boolean isPrequential = firstLine.startsWith("learning evaluation instances,evaluation time");
-            boolean isHoldOut = firstLine.startsWith("evaluation instances,to");
-            int accuracyColumn = 6;
-            int kappaColumn = 4;
-            int RamColumn = 2;
-            int timeColumn = 1;
-            int memoryColumn = 9;
-            int kappaTempColumn = 5;
-            if (this.taskManagerPanel instanceof CDTaskManagerPanel) {
-                accuracyColumn = 6;
-                kappaColumn = 4;
-                RamColumn = 2;
-                timeColumn = 1;
-                memoryColumn = 9;
-            } else if (isPrequential || isHoldOut) {
-                accuracyColumn = 4;
-                kappaColumn = 5;
-                RamColumn = 2;
-                timeColumn = 1;
-                memoryColumn = 7;
-                kappaTempColumn = 5;
-                String[] tokensFirstLine = firstLine.split(",");
-                int i = 0;
-                for (String s : tokensFirstLine) {
-                    if (s.equals("classifications correct (percent)") ||  s.equals("[avg] classifications correct (percent)")) {
-                        accuracyColumn = i;
-                    } else if (s.equals("Kappa Statistic (percent)") || s.equals("[avg] Kappa Statistic (percent)")) {
-                        kappaColumn = i;
-                    } else if (s.equals("Kappa Temporal Statistic (percent)") || s.equals("[avg] Kappa Temporal Statistic (percent)")) {
-                        kappaTempColumn = i;
-                    } else if (s.equals("model cost (RAM-Hours)")) {
-                        RamColumn = i;
-                    } else if (s.equals("evaluation time (cpu seconds)")
-                            || s.equals("total train time")) {
-                        timeColumn = i;
-                    } else if (s.equals("model serialized size (bytes)")) {
-                        memoryColumn = i;
-                    }
-                    i++;
-                }
-            }
-            if (isPrequential || isHoldOut || this.taskManagerPanel instanceof CDTaskManagerPanel) {
-                while (scanner.hasNextLine()) {
-                    String line = scanner.nextLine();
-                    String[] tokens = line.split(",");
-                    this.acc1[0].addValue(0, round(parseDouble(tokens[accuracyColumn])));
-                    this.acc1[0].addValue(1, round(parseDouble(tokens[kappaColumn])));
-                    this.acc1[0].addValue(2, round(parseDouble(tokens[kappaTempColumn])));
-                    if (!isHoldOut) {
-                        this.acc1[0].addValue(3, Math.abs(parseDouble(tokens[RamColumn])));
-                    }
-                    this.acc1[0].addValue(4, round(parseDouble(tokens[timeColumn])));
-                    this.acc1[0].addValue(5, round(parseDouble(tokens[memoryColumn]) / (1024 * 1024)));
-
-                    if (isSecondLine == true) {
-                        processFrequency = Math.abs(parseDouble(tokens[0]));
-                        isSecondLine = false;
-                        if (acc1[0].getValue(0, 0) != oldAccuracy.getValue(0, 0)) { //(!line.equals(secondLine)) {
-                            //If we are in a new task, compare with the previous
-                            secondLine = line;
-                            if (processFrequency == this.graphCanvas.getProcessFrequency()) {
-                                acc2[0] = oldAccuracy;
-                            }
-                        }
-                    }
-                }
-            } else {
-                this.acc2[0] = getNewMeasureCollection();
-            }
-
-        } else {
-            this.acc1[0] = getNewMeasureCollection();
-            this.acc2[0] = getNewMeasureCollection();
-        }
-
-
-        if (this.taskManagerPanel instanceof CDTaskManagerPanel) {
-            ConceptDriftMainTask cdTask = this.taskManagerPanel.getSelectedCurrenTask();
-            ArrayList<ClusterEvent> clusterEvents = cdTask.getEventsList();
-            this.graphCanvas.setClusterEventsList(clusterEvents);
-        }
-        this.graphCanvas.setGraph(acc1[0], acc2[0], this.graphCanvas.getMeasureSelected(), (int) processFrequency);
-        this.graphCanvas.updateCanvas(true);
-        this.graphCanvas.forceAddEvents();
-        this.clusteringVisualEvalPanel1.update();
-
-    }
-
-    private double parseDouble(String s) {
-        double ret = 0;
-        if (s.equals("?") == false) {
-            ret = Double.parseDouble(s);
-        }
-        return ret;
-    }
-
-    private void scrollPane0MouseWheelMoved(java.awt.event.MouseWheelEvent evt) {//GEN-FIRST:event_scrollPane0MouseWheelMoved
-        streamPanel0.setZoom(evt.getX(), evt.getY(), (-1) * evt.getWheelRotation(), scrollPane0);
-    }//GEN-LAST:event_scrollPane0MouseWheelMoved
-
-    private void buttonZoomInXActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonZoomInXActionPerformed
-        graphCanvas.scaleXResolution(false);
-    }//GEN-LAST:event_buttonZoomInXActionPerformed
-
-    private void buttonZoomOutYActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonZoomOutYActionPerformed
-        graphCanvas.setSize(new Dimension(graphCanvas.getWidth(), (int) (graphCanvas.getHeight() * 0.8)));
-        graphCanvas.setPreferredSize(new Dimension(graphCanvas.getWidth(), (int) (graphCanvas.getHeight() * 0.8)));
-        this.graphCanvas.updateCanvas(true);
-    }//GEN-LAST:event_buttonZoomOutYActionPerformed
-
-    private void buttonZoomOutXActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonZoomOutXActionPerformed
-        graphCanvas.scaleXResolution(true);
-    }//GEN-LAST:event_buttonZoomOutXActionPerformed
-
-    private void buttonZoomInYActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonZoomInYActionPerformed
-        graphCanvas.setSize(new Dimension(graphCanvas.getWidth(), (int) (graphCanvas.getHeight() * 1.2)));
-        graphCanvas.setPreferredSize(new Dimension(graphCanvas.getWidth(), (int) (graphCanvas.getHeight() * 1.2)));
-        this.graphCanvas.updateCanvas(true);
-    }//GEN-LAST:event_buttonZoomInYActionPerformed
-
-    private void buttonRunActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonRunActionPerformed
-        // TODO add your handling code here:
-    }//GEN-LAST:event_buttonRunActionPerformed
-
-    // Variables declaration - do not modify//GEN-BEGIN:variables
-    private javax.swing.JButton buttonRun;
-
-    private javax.swing.JButton buttonScreenshot;
-
-    private javax.swing.JButton buttonStop;
+	private static final long serialVersionUID = 1L;
+
+	public static String exportFileExtension = "txt";
+
+	protected JTextArea textArea;
+
+	protected JScrollPane scrollPane;
+
+	protected JButton exportButton;
+
+	private javax.swing.JPanel topWrapper;
+
+	private javax.swing.JSplitPane jSplitPane1;
+
+	// Added for stream events
+	protected CDTaskManagerPanel taskManagerPanel;
+
+	protected TypePanel typePanel;
+
+	public void initVisualEvalPanel() {
+		acc1[0] = getNewMeasureCollection();
+		acc2[0] = getNewMeasureCollection();
+		if (clusteringVisualEvalPanel1 != null) {
+			panelEvalOutput.remove(clusteringVisualEvalPanel1);
+		}
+		clusteringVisualEvalPanel1 = new moa.gui.clustertab.ClusteringVisualEvalPanel();
+		clusteringVisualEvalPanel1.setMeasures(acc1, acc2, this);
+		this.graphCanvas.setGraph(acc1[0], acc2[0], 0, 1000);
+		this.graphCanvas.forceAddEvents();
+		clusteringVisualEvalPanel1.setMinimumSize(new java.awt.Dimension(280, 118));
+		clusteringVisualEvalPanel1.setPreferredSize(new java.awt.Dimension(290, 115));
+		panelEvalOutput.add(clusteringVisualEvalPanel1, gridBagConstraints);
+	}
+
+	public TaskTextViewerPanel() {
+		this(TypePanel.CLASSIFICATION, null);
+	}
+
+	public java.awt.GridBagConstraints gridBagConstraints;
+
+	public TaskTextViewerPanel(ExpPreviewPanel.TypePanel typePanel, CDTaskManagerPanel taskManagerPanel) {
+		this.typePanel = typePanel;
+		this.taskManagerPanel = taskManagerPanel;
+		jSplitPane1 = new javax.swing.JSplitPane();
+		topWrapper = new javax.swing.JPanel();
+
+		this.textArea = new JTextArea();
+		this.textArea.setEditable(false);
+		this.textArea.setFont(new Font("Monospaced", Font.PLAIN, 12));
+		this.exportButton = new JButton("Export as .txt file...");
+		this.exportButton.setEnabled(false);
+		JPanel buttonPanel = new JPanel();
+		buttonPanel.setLayout(new GridLayout(1, 2));
+		buttonPanel.add(this.exportButton);
+		topWrapper.setLayout(new BorderLayout());
+		this.scrollPane = new JScrollPane(this.textArea);
+		topWrapper.add(this.scrollPane, BorderLayout.CENTER);
+		topWrapper.add(buttonPanel, BorderLayout.SOUTH);
+		this.exportButton.addActionListener(new ActionListener() {
+
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				JFileChooser fileChooser = new JFileChooser();
+				fileChooser.setAcceptAllFileFilterUsed(true);
+				fileChooser.addChoosableFileFilter(new FileExtensionFilter(exportFileExtension));
+				if (fileChooser.showSaveDialog(TaskTextViewerPanel.this) == JFileChooser.APPROVE_OPTION) {
+					File chosenFile = fileChooser.getSelectedFile();
+					String fileName = chosenFile.getPath();
+					if (!chosenFile.exists() && !fileName.endsWith(exportFileExtension)) {
+						fileName = fileName + "." + exportFileExtension;
+					}
+					try {
+						PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(fileName)));
+						out.write(TaskTextViewerPanel.this.textArea.getText());
+						out.close();
+					} catch (IOException ioe) {
+						GUIUtils.showExceptionDialog(TaskTextViewerPanel.this.exportButton,
+								"Problem saving file " + fileName, ioe);
+					}
+				}
+			}
+		});
+		// topWrapper.add(this.scrollPane);
+		// topWrapper.add(buttonPanel);
+
+		panelEvalOutput = new javax.swing.JPanel();
+		// clusteringVisualEvalPanel1 = new
+		// moa.gui.clustertab.ClusteringVisualEvalPanel();
+		graphPanel = new javax.swing.JPanel();
+		graphPanelControlTop = new javax.swing.JPanel();
+		buttonZoomInY = new javax.swing.JButton();
+		buttonZoomOutY = new javax.swing.JButton();
+		labelEvents = new javax.swing.JLabel();
+		graphScrollPanel = new javax.swing.JScrollPane();
+		graphCanvas = new moa.gui.visualization.GraphCanvas();
+		// New EventClusters
+		// clusterEvents = new ArrayList<ClusterEvent>();
+		// clusterEvents.add(new ClusterEvent(this,100,"Change", "Drift"));
+		// graphCanvas.setClusterEventsList(clusterEvents);
+
+		graphPanelControlBottom = new javax.swing.JPanel();
+		buttonZoomInX = new javax.swing.JButton();
+		buttonZoomOutX = new javax.swing.JButton();
+
+		setLayout(new java.awt.GridBagLayout());
+
+		jSplitPane1.setDividerLocation(200);
+		jSplitPane1.setOrientation(javax.swing.JSplitPane.VERTICAL_SPLIT);
+
+		// topWrapper.setPreferredSize(new java.awt.Dimension(688, 500));
+		// topWrapper.setLayout(new java.awt.GridBagLayout());
+
+		jSplitPane1.setLeftComponent(topWrapper);
+
+		panelEvalOutput.setBorder(javax.swing.BorderFactory.createTitledBorder("Evaluation"));
+		panelEvalOutput.setLayout(new java.awt.GridBagLayout());
+
+		// clusteringVisualEvalPanel1.setMinimumSize(new java.awt.Dimension(280, 118));
+		// clusteringVisualEvalPanel1.setPreferredSize(new java.awt.Dimension(290,
+		// 115));
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
+		gridBagConstraints.weighty = 1.0;
+		// panelEvalOutput.add(clusteringVisualEvalPanel1, gridBagConstraints);
+		initVisualEvalPanel();
+
+		graphPanel.setBorder(javax.swing.BorderFactory.createTitledBorder("Plot"));
+		graphPanel.setPreferredSize(new java.awt.Dimension(530, 115));
+		graphPanel.setLayout(new java.awt.GridBagLayout());
+
+		graphPanelControlTop.setLayout(new java.awt.GridBagLayout());
+
+		buttonZoomInY.setText("Zoom in Y");
+		buttonZoomInY.addActionListener(new java.awt.event.ActionListener() {
+
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonZoomInYActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
+		graphPanelControlTop.add(buttonZoomInY, gridBagConstraints);
+
+		buttonZoomOutY.setText("Zoom out Y");
+		buttonZoomOutY.addActionListener(new java.awt.event.ActionListener() {
+
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonZoomOutYActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
+		graphPanelControlTop.add(buttonZoomOutY, gridBagConstraints);
+
+		labelEvents.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
+		gridBagConstraints.weightx = 1.0;
+		gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
+		graphPanelControlTop.add(labelEvents, gridBagConstraints);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
+		gridBagConstraints.weightx = 1.0;
+		graphPanel.add(graphPanelControlTop, gridBagConstraints);
+
+		graphCanvas.setPreferredSize(new java.awt.Dimension(500, 111));
+
+		javax.swing.GroupLayout graphCanvasLayout = new javax.swing.GroupLayout(graphCanvas);
+		graphCanvas.setLayout(graphCanvasLayout);
+		graphCanvasLayout.setHorizontalGroup(graphCanvasLayout
+				.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 515, Short.MAX_VALUE));
+		graphCanvasLayout.setVerticalGroup(graphCanvasLayout
+				.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 128, Short.MAX_VALUE));
+
+		graphScrollPanel.setViewportView(graphCanvas);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 1;
+		gridBagConstraints.gridwidth = 2;
+		gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
+		gridBagConstraints.weightx = 1.0;
+		gridBagConstraints.weighty = 1.0;
+		gridBagConstraints.insets = new java.awt.Insets(2, 2, 2, 2);
+		graphPanel.add(graphScrollPanel, gridBagConstraints);
+
+		buttonZoomInX.setText("Zoom in X");
+		buttonZoomInX.addActionListener(new java.awt.event.ActionListener() {
+
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonZoomInXActionPerformed(evt);
+			}
+		});
+		graphPanelControlBottom.add(buttonZoomInX);
+
+		buttonZoomOutX.setText("Zoom out X");
+		buttonZoomOutX.addActionListener(new java.awt.event.ActionListener() {
+
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonZoomOutXActionPerformed(evt);
+			}
+		});
+		graphPanelControlBottom.add(buttonZoomOutX);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 1;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
+		graphPanel.add(graphPanelControlBottom, gridBagConstraints);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
+		gridBagConstraints.weightx = 2.0;
+		gridBagConstraints.weighty = 1.0;
+		panelEvalOutput.add(graphPanel, gridBagConstraints);
+
+		jSplitPane1.setRightComponent(panelEvalOutput);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
+		gridBagConstraints.weightx = 1.0;
+		gridBagConstraints.weighty = 1.0;
+		add(jSplitPane1, gridBagConstraints);
+
+		// acc1[0] = getNewMeasureCollection();
+
+		// acc2[0] = getNewMeasureCollection();
+		// clusteringVisualEvalPanel1.setMeasures(acc1, acc2, this);
+		// this.graphCanvas.setGraph(acc1[0], acc2[0], 0, 1000);
+
+	}
+
+	public void setText(String newText) {
+		Point p = this.scrollPane.getViewport().getViewPosition();
+		this.textArea.setText(newText);
+		this.scrollPane.getViewport().setViewPosition(p);
+		this.exportButton.setEnabled(newText != null);
+		setGraph(newText);
+	}
+
+	protected MeasureCollection[] acc1 = new MeasureCollection[1];
+
+	protected MeasureCollection[] acc2 = new MeasureCollection[1];
+
+	protected String secondLine = "";
+
+	protected double round(double d) {
+		return (Math.rint(d * 100) / 100);
+	}
+
+	protected MeasureCollection getNewMeasureCollection() {
+		/*
+		 * if (this.taskManagerPanel != null) { return new ChangeDetectionMeasures(); }
+		 * else { return new Accuracy(); }
+		 */
+		return this.typePanel.getMeasureCollection();
+	}
+
+	public void setGraph(String preview) {
+		// Change the graph when there is change in the text
+		double processFrequency = 1000;
+		if (preview != null && !preview.equals("")) {
+			MeasureCollection oldAccuracy = acc1[0];
+			acc1[0] = getNewMeasureCollection();
+			Scanner scanner = new Scanner(preview);
+			String firstLine = scanner.nextLine();
+			boolean isSecondLine = true;
+
+			boolean isPrequential = firstLine.startsWith("learning evaluation instances,evaluation time");
+			boolean isHoldOut = firstLine.startsWith("evaluation instances,to");
+			int accuracyColumn = 6;
+			int kappaColumn = 4;
+			int RamColumn = 2;
+			int timeColumn = 1;
+			int memoryColumn = 9;
+			int kappaTempColumn = 5;
+			if (this.taskManagerPanel instanceof CDTaskManagerPanel) {
+				accuracyColumn = 6;
+				kappaColumn = 4;
+				RamColumn = 2;
+				timeColumn = 1;
+				memoryColumn = 9;
+			} else if (isPrequential || isHoldOut) {
+				accuracyColumn = 4;
+				kappaColumn = 5;
+				RamColumn = 2;
+				timeColumn = 1;
+				memoryColumn = 7;
+				kappaTempColumn = 5;
+				String[] tokensFirstLine = firstLine.split(",");
+				int i = 0;
+				for (String s : tokensFirstLine) {
+					if (s.equals("classifications correct (percent)")
+							|| s.equals("[avg] classifications correct (percent)")) {
+						accuracyColumn = i;
+					} else if (s.equals("Kappa Statistic (percent)") || s.equals("[avg] Kappa Statistic (percent)")) {
+						kappaColumn = i;
+					} else if (s.equals("Kappa Temporal Statistic (percent)")
+							|| s.equals("[avg] Kappa Temporal Statistic (percent)")) {
+						kappaTempColumn = i;
+					} else if (s.equals("model cost (RAM-Hours)")) {
+						RamColumn = i;
+					} else if (s.equals("evaluation time (cpu seconds)") || s.equals("total train time")) {
+						timeColumn = i;
+					} else if (s.equals("model serialized size (bytes)")) {
+						memoryColumn = i;
+					}
+					i++;
+				}
+			}
+			if (isPrequential || isHoldOut || this.taskManagerPanel instanceof CDTaskManagerPanel) {
+				while (scanner.hasNextLine()) {
+					String line = scanner.nextLine();
+					String[] tokens = line.split(",");
+					this.acc1[0].addValue(0, round(parseDouble(tokens[accuracyColumn])));
+					this.acc1[0].addValue(1, round(parseDouble(tokens[kappaColumn])));
+					this.acc1[0].addValue(2, round(parseDouble(tokens[kappaTempColumn])));
+					if (!isHoldOut) {
+						this.acc1[0].addValue(3, Math.abs(parseDouble(tokens[RamColumn])));
+					}
+					this.acc1[0].addValue(4, round(parseDouble(tokens[timeColumn])));
+					this.acc1[0].addValue(5, round(parseDouble(tokens[memoryColumn]) / (1024 * 1024)));
+
+					if (isSecondLine == true) {
+						processFrequency = Math.abs(parseDouble(tokens[0]));
+						isSecondLine = false;
+						if (acc1[0].getValue(0, 0) != oldAccuracy.getValue(0, 0)) { // (!line.equals(secondLine)) {
+							// If we are in a new task, compare with the previous
+							secondLine = line;
+							if (processFrequency == this.graphCanvas.getProcessFrequency()) {
+								acc2[0] = oldAccuracy;
+							}
+						}
+					}
+				}
+			} else {
+				this.acc2[0] = getNewMeasureCollection();
+			}
+
+		} else {
+			this.acc1[0] = getNewMeasureCollection();
+			this.acc2[0] = getNewMeasureCollection();
+		}
+
+		if (this.taskManagerPanel instanceof CDTaskManagerPanel) {
+			ConceptDriftMainTask cdTask = this.taskManagerPanel.getSelectedCurrenTask();
+			ArrayList<ClusterEvent> clusterEvents = cdTask.getEventsList();
+			this.graphCanvas.setClusterEventsList(clusterEvents);
+		}
+		this.graphCanvas.setGraph(acc1[0], acc2[0], this.graphCanvas.getMeasureSelected(), (int) processFrequency);
+		this.graphCanvas.updateCanvas(true);
+		this.graphCanvas.forceAddEvents();
+		this.clusteringVisualEvalPanel1.update();
+
+	}
+
+	private double parseDouble(String s) {
+		double ret = 0;
+		if (s.equals("?") == false) {
+			ret = Double.parseDouble(s);
+		}
+		return ret;
+	}
+
+	private void scrollPane0MouseWheelMoved(java.awt.event.MouseWheelEvent evt) {// GEN-FIRST:event_scrollPane0MouseWheelMoved
+		streamPanel0.setZoom(evt.getX(), evt.getY(), (-1) * evt.getWheelRotation(), scrollPane0);
+	}// GEN-LAST:event_scrollPane0MouseWheelMoved
+
+	private void buttonZoomInXActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonZoomInXActionPerformed
+		graphCanvas.scaleXResolution(false);
+	}// GEN-LAST:event_buttonZoomInXActionPerformed
+
+	private void buttonZoomOutYActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonZoomOutYActionPerformed
+		graphCanvas.setSize(new Dimension(graphCanvas.getWidth(), (int) (graphCanvas.getHeight() * 0.8)));
+		graphCanvas.setPreferredSize(new Dimension(graphCanvas.getWidth(), (int) (graphCanvas.getHeight() * 0.8)));
+		this.graphCanvas.updateCanvas(true);
+	}// GEN-LAST:event_buttonZoomOutYActionPerformed
+
+	private void buttonZoomOutXActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonZoomOutXActionPerformed
+		graphCanvas.scaleXResolution(true);
+	}// GEN-LAST:event_buttonZoomOutXActionPerformed
+
+	private void buttonZoomInYActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonZoomInYActionPerformed
+		graphCanvas.setSize(new Dimension(graphCanvas.getWidth(), (int) (graphCanvas.getHeight() * 1.2)));
+		graphCanvas.setPreferredSize(new Dimension(graphCanvas.getWidth(), (int) (graphCanvas.getHeight() * 1.2)));
+		this.graphCanvas.updateCanvas(true);
+	}// GEN-LAST:event_buttonZoomInYActionPerformed
+
+	private void buttonRunActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonRunActionPerformed
+		// TODO add your handling code here:
+	}// GEN-LAST:event_buttonRunActionPerformed
+
+	// Variables declaration - do not modify//GEN-BEGIN:variables
+	private javax.swing.JButton buttonRun;
+
+	private javax.swing.JButton buttonScreenshot;
+
+	private javax.swing.JButton buttonStop;
 
-    private javax.swing.JButton buttonZoomInX;
+	private javax.swing.JButton buttonZoomInX;
 
-    private javax.swing.JButton buttonZoomInY;
+	private javax.swing.JButton buttonZoomInY;
 
-    private javax.swing.JButton buttonZoomOutX;
+	private javax.swing.JButton buttonZoomOutX;
 
-    private javax.swing.JButton buttonZoomOutY;
+	private javax.swing.JButton buttonZoomOutY;
 
-    private javax.swing.JCheckBox checkboxDrawClustering;
+	private javax.swing.JCheckBox checkboxDrawClustering;
 
-    private javax.swing.JCheckBox checkboxDrawGT;
+	private javax.swing.JCheckBox checkboxDrawGT;
 
-    private javax.swing.JCheckBox checkboxDrawMicro;
+	private javax.swing.JCheckBox checkboxDrawMicro;
 
-    private javax.swing.JCheckBox checkboxDrawPoints;
+	private javax.swing.JCheckBox checkboxDrawPoints;
 
-    private moa.gui.clustertab.ClusteringVisualEvalPanel clusteringVisualEvalPanel1;
+	private moa.gui.clustertab.ClusteringVisualEvalPanel clusteringVisualEvalPanel1;
 
-    private javax.swing.JComboBox comboX;
+	private javax.swing.JComboBox comboX;
 
-    private javax.swing.JComboBox comboY;
+	private javax.swing.JComboBox comboY;
 
-    private moa.gui.visualization.GraphCanvas graphCanvas;
+	private moa.gui.visualization.GraphCanvas graphCanvas;
 
-    private javax.swing.JPanel graphPanel;
+	private javax.swing.JPanel graphPanel;
 
-    private javax.swing.JPanel graphPanelControlBottom;
+	private javax.swing.JPanel graphPanelControlBottom;
 
-    private javax.swing.JPanel graphPanelControlTop;
+	private javax.swing.JPanel graphPanelControlTop;
 
-    private javax.swing.JScrollPane graphScrollPanel;
+	private javax.swing.JScrollPane graphScrollPanel;
 
-    private javax.swing.JLabel jLabel1;
+	private javax.swing.JLabel jLabel1;
 
-    private javax.swing.JLabel labelEvents;
+	private javax.swing.JLabel labelEvents;
 
-    private javax.swing.JLabel labelNumPause;
+	private javax.swing.JLabel labelNumPause;
 
-    private javax.swing.JLabel labelX;
+	private javax.swing.JLabel labelX;
 
-    private javax.swing.JLabel labelY;
+	private javax.swing.JLabel labelY;
 
-    private javax.swing.JLabel label_processed_points;
+	private javax.swing.JLabel label_processed_points;
 
-    private javax.swing.JLabel label_processed_points_value;
+	private javax.swing.JLabel label_processed_points_value;
 
-    private javax.swing.JTextField numPauseAfterPoints;
+	private javax.swing.JTextField numPauseAfterPoints;
 
-    private javax.swing.JPanel panelControl;
+	private javax.swing.JPanel panelControl;
 
-    private javax.swing.JPanel panelEvalOutput;
+	private javax.swing.JPanel panelEvalOutput;
 
-    private javax.swing.JPanel panelVisualWrapper;
+	private javax.swing.JPanel panelVisualWrapper;
 
-    private javax.swing.JScrollPane scrollPane0;
+	private javax.swing.JScrollPane scrollPane0;
 
-    private javax.swing.JScrollPane scrollPane1;
+	private javax.swing.JScrollPane scrollPane1;
 
-    private javax.swing.JSlider speedSlider;
+	private javax.swing.JSlider speedSlider;
 
-    private javax.swing.JSplitPane splitVisual;
+	private javax.swing.JSplitPane splitVisual;
 
-    private moa.gui.visualization.StreamPanel streamPanel0;
+	private moa.gui.visualization.StreamPanel streamPanel0;
 
-    private moa.gui.visualization.StreamPanel streamPanel1;
+	private moa.gui.visualization.StreamPanel streamPanel1;
 
-    @Override
-    public void actionPerformed(ActionEvent e) {
-        //reacte on graph selection and find out which measure was selected
-        int selected = Integer.parseInt(e.getActionCommand());
-        int counter = selected;
-        int m_select = 0;
-        int m_select_offset = 0;
-        boolean found = false;
-        for (int i = 0; i < acc1.length; i++) {
-            for (int j = 0; j < acc1[i].getNumMeasures(); j++) {
-                if (acc1[i].isEnabled(j)) {
-                    counter--;
-                    if (counter < 0) {
-                        m_select = i;
-                        m_select_offset = j;
-                        found = true;
-                        break;
-                    }
-                }
-            }
-            if (found) {
-                break;
-            }
-        }
-        this.graphCanvas.setGraph(acc1[m_select], acc2[m_select], m_select_offset, this.graphCanvas.getProcessFrequency());
-        this.graphCanvas.forceAddEvents();
-    }
+	@Override
+	public void actionPerformed(ActionEvent e) {
+		// reacte on graph selection and find out which measure was selected
+		int selected = Integer.parseInt(e.getActionCommand());
+		int counter = selected;
+		int m_select = 0;
+		int m_select_offset = 0;
+		boolean found = false;
+		for (int i = 0; i < acc1.length; i++) {
+			for (int j = 0; j < acc1[i].getNumMeasures(); j++) {
+				if (acc1[i].isEnabled(j)) {
+					counter--;
+					if (counter < 0) {
+						m_select = i;
+						m_select_offset = j;
+						found = true;
+						break;
+					}
+				}
+			}
+			if (found) {
+				break;
+			}
+		}
+		this.graphCanvas.setGraph(acc1[m_select], acc2[m_select], m_select_offset,
+				this.graphCanvas.getProcessFrequency());
+		this.graphCanvas.forceAddEvents();
+	}
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/statisticaltests/CDF_Normal.java b/moa/src/main/java/moa/gui/experimentertab/statisticaltests/CDF_Normal.java
index eb2a61250..587377ae1 100644
--- a/moa/src/main/java/moa/gui/experimentertab/statisticaltests/CDF_Normal.java
+++ b/moa/src/main/java/moa/gui/experimentertab/statisticaltests/CDF_Normal.java
@@ -1,215 +1,197 @@
 package moa.gui.experimentertab.statisticaltests;
 
 /**
-*
-*This class contains routines to calculate the
-*normal cumulative distribution function (CDF) and
-*its inverse.
-*
-*@version .5 --- June 7, 1996
-*@version .6 --- January 10, 2001 (normcdf added)
-*
-*/
+ *
+ * This class contains routines to calculate the normal cumulative distribution
+ * function (CDF) and its inverse.
+ *
+ * @version .5 --- June 7, 1996
+ * @version .6 --- January 10, 2001 (normcdf added)
+ *
+ */
 
 public class CDF_Normal extends Object {
 
-/**
-*
-*This method calculates the normal cdf inverse function.
-*<p>
-*Let PHI(x) be the normal cdf.  Suppose that Q calculates
-*1.0 - PHI(x), and that QINV calculates QINV(p) for p in (0.0,.5].
-*Then for p .le. .5, x = PHIINV(p) = -QINV(p).
-*For p .gt. .5, x = PHIINV(p) = QINV(1.0 - p).
-*The formula for approximating QINV is taken from Abramowitz and Stegun,
-*Handbook of Mathematical Functions, Dover, 9th printing,
-*formula 26.2.3, page 933.  The error in x is claimed to
-*be less than 4.5e-4 in absolute value.
-*
-*@param   p    p must lie between 0 and 1.  xnormi returns
-*              the normal cdf inverse evaluated at p.
-*
-*@author Steve Verrill
-*@version .5 --- June 7, 1996
-     * @return 
-*
-*/
+	/**
+	 *
+	 * This method calculates the normal cdf inverse function.
+	 * <p>
+	 * Let PHI(x) be the normal cdf. Suppose that Q calculates 1.0 - PHI(x), and
+	 * that QINV calculates QINV(p) for p in (0.0,.5]. Then for p .le. .5, x =
+	 * PHIINV(p) = -QINV(p). For p .gt. .5, x = PHIINV(p) = QINV(1.0 - p). The
+	 * formula for approximating QINV is taken from Abramowitz and Stegun, Handbook
+	 * of Mathematical Functions, Dover, 9th printing, formula 26.2.3, page 933. The
+	 * error in x is claimed to be less than 4.5e-4 in absolute value.
+	 *
+	 * @param p p must lie between 0 and 1. xnormi returns the normal cdf inverse
+	 *          evaluated at p.
+	 *
+	 * @author Steve Verrill
+	 * @version .5 --- June 7, 1996
+	 * @return
+	 *
+	 */
 
 //  FIX: Eventually I should build in a check that p lies in (0,1)
 
-   public static double xnormi(double p) {
-
-      double arg,t,t2,t3,xnum,xden,qinvp,x,pc;
-
-      final double c[] = {2.515517,
-      .802853,
-      .010328};
-
-      final double d[] = {1.432788,
-      .189269,
-      .001308};
-
-      if (p <= .5) {
-
-         arg = -2.0*Math.log(p);
-         t = Math.sqrt(arg);
-         t2 = t*t;
-         t3 = t2*t;
-
-         xnum = c[0] + c[1]*t + c[2]*t2;
-         xden = 1.0 + d[0]*t + d[1]*t2 + d[2]*t3;
-         qinvp = t - xnum/xden;
-         x = -qinvp;
-
-         return x;
-
-      }
-
-      else {
-
-         pc = 1.0 - p;
-         arg = -2.0*Math.log(pc);
-         t = Math.sqrt(arg);
-         t2 = t*t;
-         t3 = t2*t;
-
-         xnum = c[0] + c[1]*t + c[2]*t2;
-         xden = 1.0 + d[0]*t + d[1]*t2 + d[2]*t3;
-         x = t - xnum/xden;
-
-         return x;
-
-      }
-
-   }
-
-
-/**
-*
-*This method calculates the normal cumulative distribution function.
-*<p>
-*It is based upon algorithm 5666 for the error function, from:<p>
-*<pre>
-*       Hart, J.F. et al, 'Computer Approximations', Wiley 1968
-*</pre>
-*<p>
-*The FORTRAN programmer was Alan Miller.  The documentation
-*in the FORTRAN code claims that the function is "accurate
-*to 1.e-15."<p>
-*Steve Verrill
-*translated the FORTRAN code (the March 30, 1986 version)
-*into Java.  This translation was performed on January 10, 2001.
-*
-*@param   z   The method returns the value of the normal
-*             cumulative distribution function at z.
-*
-*@version .5 --- January 10, 2001
-     * @return 
-*
-*/
-
-
-/*
-
-Here is a copy of the documentation in the FORTRAN code:
-
-	SUBROUTINE NORMP(Z, P, Q, PDF)
-C
-C	Normal distribution probabilities accurate to 1.e-15.
-C	Z = no. of standard deviations from the mean.
-C	P, Q = probabilities to the left & right of Z.   P + Q = 1.
-C       PDF = the probability density.
-C
-C       Based upon algorithm 5666 for the error function, from:
-C       Hart, J.F. et al, 'Computer Approximations', Wiley 1968
-C
-C       Programmer: Alan Miller
-C
-C	Latest revision - 30 March 1986
-C
-
-*/
-
-   public static double normp(double z) {
-
-      double zabs;
-      double p;
-      double expntl,pdf;
-
-      final double p0 = 220.2068679123761;
-      final double p1 = 221.2135961699311;
-      final double p2 = 112.0792914978709;
-      final double p3 = 33.91286607838300;
-      final double p4 = 6.373962203531650;
-      final double p5 = .7003830644436881;
-      final double p6 = .3526249659989109E-01;
-
-      final double q0 = 440.4137358247522;
-      final double q1 = 793.8265125199484;
-      final double q2 = 637.3336333788311;
-      final double q3 = 296.5642487796737;
-      final double q4 = 86.78073220294608;
-      final double q5 = 16.06417757920695;
-      final double q6 = 1.755667163182642;
-      final double q7 = .8838834764831844E-1;
-
-      final double cutoff = 7.071;
-      final double root2pi = 2.506628274631001;
-
-      zabs = Math.abs(z);
+	public static double xnormi(double p) {
+
+		double arg, t, t2, t3, xnum, xden, qinvp, x, pc;
+
+		final double c[] = { 2.515517, .802853, .010328 };
+
+		final double d[] = { 1.432788, .189269, .001308 };
+
+		if (p <= .5) {
+
+			arg = -2.0 * Math.log(p);
+			t = Math.sqrt(arg);
+			t2 = t * t;
+			t3 = t2 * t;
+
+			xnum = c[0] + c[1] * t + c[2] * t2;
+			xden = 1.0 + d[0] * t + d[1] * t2 + d[2] * t3;
+			qinvp = t - xnum / xden;
+			x = -qinvp;
+
+			return x;
+
+		}
+
+		else {
+
+			pc = 1.0 - p;
+			arg = -2.0 * Math.log(pc);
+			t = Math.sqrt(arg);
+			t2 = t * t;
+			t3 = t2 * t;
+
+			xnum = c[0] + c[1] * t + c[2] * t2;
+			xden = 1.0 + d[0] * t + d[1] * t2 + d[2] * t3;
+			x = t - xnum / xden;
+
+			return x;
+
+		}
+
+	}
+
+	/**
+	 *
+	 * This method calculates the normal cumulative distribution function.
+	 * <p>
+	 * It is based upon algorithm 5666 for the error function, from:
+	 * <p>
+	 * 
+	 * <pre>
+	*       Hart, J.F. et al, 'Computer Approximations', Wiley 1968
+	 * </pre>
+	 * <p>
+	 * The FORTRAN programmer was Alan Miller. The documentation in the FORTRAN code
+	 * claims that the function is "accurate to 1.e-15."
+	 * <p>
+	 * Steve Verrill translated the FORTRAN code (the March 30, 1986 version) into
+	 * Java. This translation was performed on January 10, 2001.
+	 *
+	 * @param z The method returns the value of the normal cumulative distribution
+	 *          function at z.
+	 *
+	 * @version .5 --- January 10, 2001
+	 * @return
+	 *
+	 */
+
+	/*
+	 * 
+	 * Here is a copy of the documentation in the FORTRAN code:
+	 * 
+	 * SUBROUTINE NORMP(Z, P, Q, PDF) C C Normal distribution probabilities accurate
+	 * to 1.e-15. C Z = no. of standard deviations from the mean. C P, Q =
+	 * probabilities to the left & right of Z. P + Q = 1. C PDF = the probability
+	 * density. C C Based upon algorithm 5666 for the error function, from: C Hart,
+	 * J.F. et al, 'Computer Approximations', Wiley 1968 C C Programmer: Alan Miller
+	 * C C Latest revision - 30 March 1986 C
+	 * 
+	 */
+
+	public static double normp(double z) {
+
+		double zabs;
+		double p;
+		double expntl, pdf;
+
+		final double p0 = 220.2068679123761;
+		final double p1 = 221.2135961699311;
+		final double p2 = 112.0792914978709;
+		final double p3 = 33.91286607838300;
+		final double p4 = 6.373962203531650;
+		final double p5 = .7003830644436881;
+		final double p6 = .3526249659989109E-01;
+
+		final double q0 = 440.4137358247522;
+		final double q1 = 793.8265125199484;
+		final double q2 = 637.3336333788311;
+		final double q3 = 296.5642487796737;
+		final double q4 = 86.78073220294608;
+		final double q5 = 16.06417757920695;
+		final double q6 = 1.755667163182642;
+		final double q7 = .8838834764831844E-1;
+
+		final double cutoff = 7.071;
+		final double root2pi = 2.506628274631001;
+
+		zabs = Math.abs(z);
 
 //  |z| > 37
 
-      if (z > 37.0) {
+		if (z > 37.0) {
 
-         p = 1.0;
+			p = 1.0;
 
-         return p;
+			return p;
 
-      }
+		}
 
-      if (z < -37.0) {
+		if (z < -37.0) {
 
-         p = 0.0;
+			p = 0.0;
 
-         return p;
+			return p;
 
-      }
+		}
 
 //  |z| <= 37.
 
-      expntl = Math.exp(-.5*zabs*zabs);
+		expntl = Math.exp(-.5 * zabs * zabs);
 
-      pdf = expntl/root2pi;
+		pdf = expntl / root2pi;
 
 //  |z| < cutoff = 10/sqrt(2).
 
-      if (zabs < cutoff) {
+		if (zabs < cutoff) {
 
-         p = expntl*((((((p6*zabs + p5)*zabs + p4)*zabs + p3)*zabs +
-             p2)*zabs + p1)*zabs + p0)/(((((((q7*zabs + q6)*zabs +
-             q5)*zabs + q4)*zabs + q3)*zabs + q2)*zabs + q1)*zabs +
-             q0);
+			p = expntl * ((((((p6 * zabs + p5) * zabs + p4) * zabs + p3) * zabs + p2) * zabs + p1) * zabs + p0)
+					/ (((((((q7 * zabs + q6) * zabs + q5) * zabs + q4) * zabs + q3) * zabs + q2) * zabs + q1) * zabs
+							+ q0);
 
-      } else {
+		} else {
 
-         p = pdf/(zabs + 1.0/(zabs + 2.0/(zabs + 3.0/(zabs + 4.0/
-             (zabs + 0.65)))));
+			p = pdf / (zabs + 1.0 / (zabs + 2.0 / (zabs + 3.0 / (zabs + 4.0 / (zabs + 0.65)))));
 
-      }
+		}
 
-      if (z < 0.0) {
+		if (z < 0.0) {
 
-         return p;
+			return p;
 
-      } else {
+		} else {
 
-         p = 1.0 - p;
+			p = 1.0 - p;
 
-         return p;
+			return p;
 
-      }
+		}
 
-   }
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/statisticaltests/Fichero.java b/moa/src/main/java/moa/gui/experimentertab/statisticaltests/Fichero.java
index 8608e824e..8731132a6 100644
--- a/moa/src/main/java/moa/gui/experimentertab/statisticaltests/Fichero.java
+++ b/moa/src/main/java/moa/gui/experimentertab/statisticaltests/Fichero.java
@@ -1,6 +1,5 @@
 package moa.gui.experimentertab.statisticaltests;
 
-
 /*
  * Created on 16-Jun-2004
  *
@@ -12,7 +11,11 @@
  *
  *
  */
-import java.io.*;
+import java.io.DataOutputStream;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.RandomAccessFile;
 
 /**
  *
@@ -20,73 +23,73 @@
  */
 public class Fichero {
 
-    /**
-     *
-     * @param nombreFichero
-     * @return
-     */
-    public static String leeFichero(String nombreFichero) {
-        String cadena = "";
-
-        try {
-            FileInputStream fis = new FileInputStream(nombreFichero);
-
-            byte[] leido = new byte[4096];
-            int bytesLeidos = 0;
-
-            while (bytesLeidos != -1) {
-                bytesLeidos = fis.read(leido);
-
-                if (bytesLeidos != -1) {
-                    cadena += new String(leido, 0, bytesLeidos);
-                }
-            }
-
-            fis.close();
-        } catch (IOException e) {
-            e.printStackTrace();
-            System.exit(-1);
-        }
-
-        return cadena;
-    }
-
-    /**
-     *
-     * @param nombreFichero
-     * @param cadena
-     */
-    public static void escribeFichero(String nombreFichero, String cadena) {
-        try {
-            FileOutputStream f = new FileOutputStream(nombreFichero);
-            DataOutputStream fis = new DataOutputStream((OutputStream) f);
-
-            fis.writeBytes(cadena);
-
-            fis.close();
-        } catch (IOException e) {
-            e.printStackTrace();
-            System.exit(-1);
-        }
-    }
-
-    /**
-     *
-     * @param nombreFichero
-     * @param cadena
-     */
-    public static void AnadirtoFichero(String nombreFichero, String cadena) {
-        try {
-            RandomAccessFile fis = new RandomAccessFile(nombreFichero, "rw");
-            fis.seek(fis.length());
-
-            fis.writeBytes(cadena);
-
-            fis.close();
-        } catch (IOException e) {
-            e.printStackTrace();
-            System.exit(-1);
-        }
-    }
+	/**
+	 *
+	 * @param nombreFichero
+	 * @return
+	 */
+	public static String leeFichero(String nombreFichero) {
+		String cadena = "";
+
+		try {
+			FileInputStream fis = new FileInputStream(nombreFichero);
+
+			byte[] leido = new byte[4096];
+			int bytesLeidos = 0;
+
+			while (bytesLeidos != -1) {
+				bytesLeidos = fis.read(leido);
+
+				if (bytesLeidos != -1) {
+					cadena += new String(leido, 0, bytesLeidos);
+				}
+			}
+
+			fis.close();
+		} catch (IOException e) {
+			e.printStackTrace();
+			System.exit(-1);
+		}
+
+		return cadena;
+	}
+
+	/**
+	 *
+	 * @param nombreFichero
+	 * @param cadena
+	 */
+	public static void escribeFichero(String nombreFichero, String cadena) {
+		try {
+			FileOutputStream f = new FileOutputStream(nombreFichero);
+			DataOutputStream fis = new DataOutputStream(f);
+
+			fis.writeBytes(cadena);
+
+			fis.close();
+		} catch (IOException e) {
+			e.printStackTrace();
+			System.exit(-1);
+		}
+	}
+
+	/**
+	 *
+	 * @param nombreFichero
+	 * @param cadena
+	 */
+	public static void AnadirtoFichero(String nombreFichero, String cadena) {
+		try {
+			RandomAccessFile fis = new RandomAccessFile(nombreFichero, "rw");
+			fis.seek(fis.length());
+
+			fis.writeBytes(cadena);
+
+			fis.close();
+		} catch (IOException e) {
+			e.printStackTrace();
+			System.exit(-1);
+		}
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/statisticaltests/PValuePerTwoAlgorithm.java b/moa/src/main/java/moa/gui/experimentertab/statisticaltests/PValuePerTwoAlgorithm.java
index 9863770fe..11b12b878 100644
--- a/moa/src/main/java/moa/gui/experimentertab/statisticaltests/PValuePerTwoAlgorithm.java
+++ b/moa/src/main/java/moa/gui/experimentertab/statisticaltests/PValuePerTwoAlgorithm.java
@@ -1,6 +1,6 @@
 /*
  *    PValuePerTwoAlgorithm.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand 
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
  *    @author Alberto Verdecia Cabrera (averdeciac@gmail.com)
  *
  *    This program is free software; you can redistribute it and/or modify
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab.statisticaltests;
 
@@ -27,47 +27,48 @@
  */
 public class PValuePerTwoAlgorithm {
 
-    public String algName1;
+	public String algName1;
+
+	public String algName2;
 
-    public String algName2;
+	public double PValue;
 
-    public double PValue;
+	/**
+	 * Costructor.
+	 * 
+	 * @param algName1
+	 * @param algName2
+	 * @param PValue
+	 */
+	public PValuePerTwoAlgorithm(String algName1, String algName2, double PValue) {
+		this.algName1 = algName1;
+		this.algName2 = algName2;
+		this.PValue = PValue;
+	}
 
-    /**
-     * Costructor.
-     * @param algName1
-     * @param algName2
-     * @param PValue
-     */
-    public PValuePerTwoAlgorithm(String algName1, String algName2, double PValue) {
-        this.algName1 = algName1;
-        this.algName2 = algName2;
-        this.PValue = PValue;
-    }
+	/**
+	 *
+	 * @param PValue
+	 * @return
+	 */
+	public boolean isSignicativeBetterThan(double PValue) {
+		return this.PValue >= PValue;
+	}
 
-    /**
-     *
-     * @param PValue
-     * @return
-     */
-    public  boolean isSignicativeBetterThan(double PValue){
-        return this.PValue >= PValue;
-    }
+	/**
+	 *
+	 * @param pvalues
+	 * @param name1
+	 * @param name2
+	 * @return
+	 */
+	public static int getIndex(ArrayList<PValuePerTwoAlgorithm> pvalues, String name1, String name2) {
+		for (int i = 0; i < pvalues.size(); i++) {
+			if (pvalues.get(i).algName1.equals(name1) == true && pvalues.get(i).algName2.equals(name2) == true
+					|| pvalues.get(i).algName1.equals(name2) == true && pvalues.get(i).algName2.equals(name1) == true)
+				return i;
 
-    /**
-     *
-     * @param pvalues
-     * @param name1
-     * @param name2
-     * @return
-     */
-    public static int getIndex(ArrayList<PValuePerTwoAlgorithm> pvalues, String name1, String name2){
-           for(int i = 0; i < pvalues.size(); i++){
-               if(pvalues.get(i).algName1.equals(name1)==true && pvalues.get(i).algName2.equals(name2)==true
-                       || pvalues.get(i).algName1.equals(name2)==true && pvalues.get(i).algName2.equals(name1)==true)
-                   return i;
-                   
-           }
-        return -1;   
-    }
+		}
+		return -1;
+	}
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/statisticaltests/Pareja.java b/moa/src/main/java/moa/gui/experimentertab/statisticaltests/Pareja.java
index fea80a37f..f48173d52 100644
--- a/moa/src/main/java/moa/gui/experimentertab/statisticaltests/Pareja.java
+++ b/moa/src/main/java/moa/gui/experimentertab/statisticaltests/Pareja.java
@@ -2,40 +2,45 @@
 
 /**
  * <p>
- * T�tulo: </p>
+ * T�tulo:
+ * </p>
  * <p>
- * Descripci�n: </p>
+ * Descripci�n:
+ * </p>
  * <p>
- * Copyright: Copyright (c) 2005</p>
+ * Copyright: Copyright (c) 2005
+ * </p>
  * <p>
- * Empresa: </p>
+ * Empresa:
+ * </p>
  *
  * @author sin atribuir
  * @version 1.0
  */
 public class Pareja implements Comparable {
 
-    public double indice;
-    public double valor;
+	public double indice;
+	public double valor;
 
-    public Pareja() {
+	public Pareja() {
 
-    }
+	}
 
-    public Pareja(double i, double v) {
-        indice = i;
-        valor = v;
-    }
+	public Pareja(double i, double v) {
+		indice = i;
+		valor = v;
+	}
 
-    public int compareTo(Object o1) { //ordena por valor absoluto
+	@Override
+	public int compareTo(Object o1) { // ordena por valor absoluto
 
-        if (Math.abs(this.valor) > Math.abs(((Pareja) o1).valor)) {
-            return -1;
-        } else if (Math.abs(this.valor) < Math.abs(((Pareja) o1).valor)) {
-            return 1;
-        } else {
-            return 0;
-        }
-    }
+		if (Math.abs(this.valor) > Math.abs(((Pareja) o1).valor)) {
+			return -1;
+		} else if (Math.abs(this.valor) < Math.abs(((Pareja) o1).valor)) {
+			return 1;
+		} else {
+			return 0;
+		}
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/statisticaltests/RankPerAlgorithm.java b/moa/src/main/java/moa/gui/experimentertab/statisticaltests/RankPerAlgorithm.java
index 960e570ed..8f82c73fd 100644
--- a/moa/src/main/java/moa/gui/experimentertab/statisticaltests/RankPerAlgorithm.java
+++ b/moa/src/main/java/moa/gui/experimentertab/statisticaltests/RankPerAlgorithm.java
@@ -1,6 +1,6 @@
 /*
  *    RankPerAlgorithm.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand 
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
  *    @author Alberto Verdecia Cabrera (averdeciac@gmail.com)
  *
  *    This program is free software; you can redistribute it and/or modify
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab.statisticaltests;
 
@@ -26,29 +26,29 @@
  */
 public class RankPerAlgorithm implements Comparable<RankPerAlgorithm> {
 
-    public String algName;
-    public double rank;
+	public String algName;
+	public double rank;
 
-    /**
-     * Constructor.
-     *
-     * @param algName
-     * @param rank
-     */
-    public RankPerAlgorithm(String algName, double rank) {
-        this.algName = algName;
-        this.rank = rank;
-    }
+	/**
+	 * Constructor.
+	 *
+	 * @param algName
+	 * @param rank
+	 */
+	public RankPerAlgorithm(String algName, double rank) {
+		this.algName = algName;
+		this.rank = rank;
+	}
 
-    @Override
-    public int compareTo(RankPerAlgorithm r) {
-        if (rank < r.rank) {
-            return -1;
-        }
-        if (rank > r.rank) {
-            return 1;
-        }
-        return 0;
-    }
+	@Override
+	public int compareTo(RankPerAlgorithm r) {
+		if (rank < r.rank) {
+			return -1;
+		}
+		if (rank > r.rank) {
+			return 1;
+		}
+		return 0;
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/statisticaltests/Relation.java b/moa/src/main/java/moa/gui/experimentertab/statisticaltests/Relation.java
index 6867af01e..120790aa7 100644
--- a/moa/src/main/java/moa/gui/experimentertab/statisticaltests/Relation.java
+++ b/moa/src/main/java/moa/gui/experimentertab/statisticaltests/Relation.java
@@ -4,32 +4,35 @@
  * <p>
  * T�tulo:
  * <p>
- * Descripci�n: </p>
+ * Descripci�n:
+ * </p>
  * <p>
- * Copyright: Copyright (c) 2005</p>
+ * Copyright: Copyright (c) 2005
+ * </p>
  * <p>
- * Empresa: </p>
+ * Empresa:
+ * </p>
  *
  * @author sin atribuir
  * @version 1.0
  */
 public class Relation {
 
-    public int i;
-    public int j;
+	public int i;
+	public int j;
 
-    public Relation() {
+	public Relation() {
 
-    }
+	}
 
-    public Relation(int x, int y) {
-        i = x;
-        j = y;
-    }
+	public Relation(int x, int y) {
+		i = x;
+		j = y;
+	}
 
-    @Override
-    public String toString() {
-        return "(" + i + "," + j + ")";
-    }
+	@Override
+	public String toString() {
+		return "(" + i + "," + j + ")";
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/statisticaltests/StatisticalTest.java b/moa/src/main/java/moa/gui/experimentertab/statisticaltests/StatisticalTest.java
index 6588e0a71..41f5430ee 100644
--- a/moa/src/main/java/moa/gui/experimentertab/statisticaltests/StatisticalTest.java
+++ b/moa/src/main/java/moa/gui/experimentertab/statisticaltests/StatisticalTest.java
@@ -1,8 +1,8 @@
 /*
  *    StatisticalTest.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand 
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
  *    @author Alberto Verdecia Cabrera (averdeciac@gmail.com)
- * 
+ *
  *    This program is free software; you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
  *    the Free Software Foundation; either version 3 of the License, or
@@ -15,19 +15,19 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    The statistical tests programmed in this class were taken from 
- *    KEEL(Knowledge Extraction based on Evolutionary Learning) software. 
- *    KEEL is an open source (GPLv3) Java software tool that can be used for 
+ *    The statistical tests programmed in this class were taken from
+ *    KEEL(Knowledge Extraction based on Evolutionary Learning) software.
+ *    KEEL is an open source (GPLv3) Java software tool that can be used for
  *    a large number of different knowledge data discovery tasks.
- *    J. Alcalá-Fdez, L. Sánchez, S. García, M.J. del Jesus, S. Ventura, 
- *    J.M. Garrell, J. Otero, C. Romero, J. Bacardit, V.M. Rivas, J.C. Fernández, 
- *    F. Herrera. KEEL: A Software Tool to Assess Evolutionary Algorithms to 
- *    Data Mining Problems. Soft Computing 13:3 (2009) 307-318, 
+ *    J. Alcalá-Fdez, L. Sánchez, S. García, M.J. del Jesus, S. Ventura,
+ *    J.M. Garrell, J. Otero, C. Romero, J. Bacardit, V.M. Rivas, J.C. Fernández,
+ *    F. Herrera. KEEL: A Software Tool to Assess Evolutionary Algorithms to
+ *    Data Mining Problems. Soft Computing 13:3 (2009) 307-318,
  *    doi: 10.1007/s00500-008-0323-y.
- *    J. Alcalá-Fdez, A. Fernandez, J. Luengo, J. Derrac, S. García, L. Sánchez, 
- *    F. Herrera. KEEL Data-Mining Software Tool: Data Set Repository, 
- *    Integration of Algorithms and Experimental Analysis Framework. Journal of 
- *    Multiple-Valued Logic and Soft Computing 17:2-3 (2011) 255-287. 
+ *    J. Alcalá-Fdez, A. Fernandez, J. Luengo, J. Derrac, S. García, L. Sánchez,
+ *    F. Herrera. KEEL Data-Mining Software Tool: Data Set Repository,
+ *    Integration of Algorithms and Experimental Analysis Framework. Journal of
+ *    Multiple-Valued Logic and Soft Computing 17:2-3 (2011) 255-287.
  */
 package moa.gui.experimentertab.statisticaltests;
 
@@ -37,6 +37,7 @@
 import java.util.Comparator;
 import java.util.List;
 import java.util.StringTokenizer;
+
 import moa.gui.experimentertab.Algorithm;
 import moa.gui.experimentertab.Stream;
 
@@ -46,628 +47,626 @@
  */
 public class StatisticalTest {
 
-    ArrayList algoritmos;
-    ArrayList datasets;
-    ArrayList datos;
-    //String linea, token;
-    int i, j, k, m;
-    int posicion;
-    double mean[][];
-    Pareja orden[][];
-    Pareja rank[][];
-    boolean encontrado;
-    int ig;
-    double sum;
-    boolean visto[];
-    ArrayList porVisitar;
-    double Rj[];
-    double friedman;
-    double sumatoria = 0;
-    double termino1, termino2, termino3;
-    double iman;
-    boolean vistos[];
-    int pos, tmp;
-    double min;
-    double maxVal;
-    double rankingRef;
-    double Pi[];
-    double ALPHAiHolm[];
-    double ALPHAiShaffer[];
-    String ordenAlgoritmos[];
-    double ordenRankings[];
-    int order[];
-    double adjustedP[][];
-    double Ci[];
-    double SE;
-    boolean parar, otro;
-    ArrayList indices = new ArrayList();
-    ArrayList exhaustiveI = new ArrayList();
-    boolean[][] cuadro;
-    double minPi, tmpPi, maxAPi, tmpAPi;
-    Relation[] parejitas;
-    int lineaN = 0;
-    int columnaN = 0;
-    ArrayList T;
-    int Tarray[];
-    ArrayList<RankPerAlgorithm> rankAlg;
-    double pFriedman, pIman;
-    public List<Stream> streams = new ArrayList<>();
-
-    /**
-     * Constructor.
-     *
-     * @param streams
-     */
-    public StatisticalTest(List<Stream> streams) {
-        this.streams = streams;
-        algoritmos = new ArrayList();
-        datasets = new ArrayList();
-        datos = new ArrayList();
-        rankAlg = new ArrayList<>();
-
-    }
-
-    /**
-     * Read a csv file from an path.
-     *
-     * @param path
-     */
-    public void readCSV(String path) {
-        String cadena, linea, token;
-        StringTokenizer lineas, tokens;
-        cadena = Fichero.leeFichero(path);
-        lineas = new StringTokenizer(cadena, "\n\r");
-        while (lineas.hasMoreTokens()) {
-            linea = lineas.nextToken();
-            tokens = new StringTokenizer(linea, ",\t");
-            columnaN = 0;
-            while (tokens.hasMoreTokens()) {
-                if (lineaN == 0) {
-                    if (columnaN == 0) {
-                        token = tokens.nextToken();
-                    } else {
-                        token = tokens.nextToken();
-                        algoritmos.add(token);
-                        datos.add(new ArrayList());
-                    }
-                } else {
-                    if (columnaN == 0) {
-                        token = tokens.nextToken();
-                        datasets.add(token);
-                    } else {
-                        token = tokens.nextToken();
-                        ((ArrayList) datos.get(columnaN - 1)).add(new Double(token));
-                    }
-                }
-                columnaN++;
-            }
-            lineaN++;
-        }
-    }
-
-    /**
-     * Read data from experiments sumaries.
-     */
-    public void readData() {
-
-        int cont = 0;
-        int algorithmSize = this.streams.get(0).algorithm.size();
-        int streamSize = this.streams.size();
-        int measureSize = this.streams.get(0).algorithm.get(0).measures.size();
-
-        for (int i = 0; i < algorithmSize; i++) {
-            algoritmos.add(this.streams.get(0).algorithm.get(i).name);
-            datos.add(new ArrayList());
-        }
-        for (int i = 0; i < streamSize; i++) {
-            List<Algorithm> alg = this.streams.get(i).algorithm;
-            datasets.add(this.streams.get(i).name);
-            for (int j = 0; j < algorithmSize; j++) {
-                ((ArrayList) datos.get(j)).add(alg.get(j).measures.get(cont).getValue());
-            }
-
-        }
-
-    }
-
-    /**
-     * Compute the average ranking of the algorithms.
-     */
-    public void avgPerformance() {
-        mean = new double[datasets.size()][algoritmos.size()];
-
-        /*Compute the average performance per algorithm for each data set*/
-        for (i = 0; i < datasets.size(); i++) {
-            for (j = 0; j < algoritmos.size(); j++) {
-                mean[i][j] = ((Double) ((ArrayList) datos.get(j)).get(i));
-            }
-        }
-
-        /*We use the pareja structure to compute and order rankings*/
-        orden = new Pareja[datasets.size()][algoritmos.size()];
-        for (i = 0; i < datasets.size(); i++) {
-            for (j = 0; j < algoritmos.size(); j++) {
-                orden[i][j] = new Pareja(j, mean[i][j]);
-            }
-            Arrays.sort(orden[i]);
-        }
-
-        /*building of the rankings table per algorithms and data sets*/
-        rank = new Pareja[datasets.size()][algoritmos.size()];
-        posicion = 0;
-        for (i = 0; i < datasets.size(); i++) {
-            for (j = 0; j < algoritmos.size(); j++) {
-                encontrado = false;
-                for (k = 0; k < algoritmos.size() && !encontrado; k++) {
-                    if (orden[i][k].indice == j) {
-                        encontrado = true;
-                        posicion = k + 1;
-                    }
-                }
-                rank[i][j] = new Pareja(posicion, orden[i][posicion - 1].valor);
-            }
-        }
-
-        /*In the case of having the same performance, the rankings are equal*/
-        for (i = 0; i < datasets.size(); i++) {
-            visto = new boolean[algoritmos.size()];
-            porVisitar = new ArrayList();
-
-            Arrays.fill(visto, false);
-            for (j = 0; j < algoritmos.size(); j++) {
-                porVisitar.clear();
-                sum = rank[i][j].indice;
-                visto[j] = true;
-                ig = 1;
-                for (k = j + 1; k < algoritmos.size(); k++) {
-                    if (rank[i][j].valor == rank[i][k].valor && !visto[k]) {
-                        sum += rank[i][k].indice;
-                        ig++;
-                        porVisitar.add(new Integer(k));
-                        visto[k] = true;
-                    }
-                }
-                sum /= (double) ig;
-                rank[i][j].indice = sum;
-                for (k = 0; k < porVisitar.size(); k++) {
-                    rank[i][((Integer) porVisitar.get(k))].indice = sum;
-                }
-            }
-        }
-        avgRankingPerAlgorithm();
-    }
-
-    private void avgRankingPerAlgorithm() {
-
-        Rj = new double[algoritmos.size()];
-        for (i = 0; i < algoritmos.size(); i++) {
-            Rj[i] = 0;
-            for (j = 0; j < datasets.size(); j++) {
-                Rj[i] += rank[j][i].indice / ((double) datasets.size());
-            }
-        }
-        /*Print the average ranking per algorithm*/
-        for (i = 0; i < algoritmos.size(); i++) {
-            rankAlg.add(new RankPerAlgorithm((String) algoritmos.get(i), Rj[i]));
-        }
-        //Order de Algorithms with rank
-        Collections.sort(rankAlg, new ComparatorImpl());
-
-        /*Compute the Friedman statistic*/
-        termino1 = (12 * (double) datasets.size()) / ((double) algoritmos.size()
-                * ((double) algoritmos.size() + 1));
-        termino2 = (double) algoritmos.size() * ((double) algoritmos.size() + 1)
-                * ((double) algoritmos.size() + 1) / (4.0);
-        for (i = 0; i < algoritmos.size(); i++) {
-            sumatoria += Rj[i] * Rj[i];
-        }
-        friedman = (sumatoria - termino2) * termino1;
-
-        pFriedman = ChiSq(friedman, (algoritmos.size() - 1));
-
-        /*Compute the Iman-Davenport statistic*/
-        iman = ((datasets.size() - 1) * friedman) / (datasets.size() * (algoritmos.size() - 1) - friedman);
-        pIman = FishF(iman, (algoritmos.size() - 1), (algoritmos.size() - 1) * (datasets.size() - 1));
-        //System.out.print("P-value computed by Iman and Daveport Test: " + pIman + ".\\newline\n\n");
-
-        termino3 = Math.sqrt((double) algoritmos.size() * ((double) algoritmos.size() + 1)
-                / (6.0 * (double) datasets.size()));
-        //Inicialize values
-        inicialize();
-
-    }
-
-    /**
-     * Return the p-value computed by Friedman test.
-     *
-     * @return pFriedman
-     */
-    public double getFriedmanPValue() {
-        return pFriedman;
-    }
-
-    /**
-     * Return the p-value Iman and Daveport test.
-     *
-     * @return pIman
-     */
-    public double getImanPValue() {
-        return pIman;
-    }
-
-    /**
-     * Return the ranking of the algorithms.
-     *
-     * @return rankAlg
-     */
-    public ArrayList<RankPerAlgorithm> getRankAlg() {
-        return rankAlg;
-    }
-
-    private void inicialize() {
-        /*Compute the unadjusted p_i value for each comparison alpha=0.10*/
-        Pi = new double[(int) combinatoria(2, algoritmos.size())];
-        ordenAlgoritmos = new String[(int) combinatoria(2, algoritmos.size())];
-        ordenRankings = new double[(int) combinatoria(2, algoritmos.size())];
-        order = new int[(int) combinatoria(2, algoritmos.size())];
-        parejitas = new Relation[(int) combinatoria(2, algoritmos.size())];
-        T = new ArrayList();
-        T = trueHShaffer(algoritmos.size());
-        Tarray = new int[T.size()];
-        for (i = 0; i < T.size(); i++) {
-            Tarray[i] = ((Integer) T.get(i));
-        }
-        Arrays.sort(Tarray);
-        SE = termino3;
-        vistos = new boolean[(int) combinatoria(2, algoritmos.size())];
-        for (i = 0, k = 0; i < algoritmos.size(); i++) {
-            for (j = i + 1; j < algoritmos.size(); j++, k++) {
-                ordenRankings[k] = Math.abs(Rj[i] - Rj[j]);
-                ordenAlgoritmos[k] = (String) algoritmos.get(i) + " vs. " + (String) algoritmos.get(j);
-                parejitas[k] = new Relation(i, j);
-            }
-        }
-
-        Arrays.fill(vistos, false);
-        for (i = 0; i < ordenRankings.length; i++) {
-            for (j = 0; vistos[j] == true; j++);
-            pos = j;
-            maxVal = ordenRankings[j];
-            for (j = j + 1; j < ordenRankings.length; j++) {
-                if (vistos[j] == false && ordenRankings[j] > maxVal) {
-                    pos = j;
-                    maxVal = ordenRankings[j];
-                }
-            }
-            vistos[pos] = true;
-            order[i] = pos;
-        }
-
-        /*Computing the logically related hypotheses tests (Shaffer and Bergmann-Hommel)*/
-        pos = 0;
-        tmp = Tarray.length - 1;
-        for (i = 0; i < order.length; i++) {
-            Pi[i] = 2 * CDF_Normal.normp((-1) * Math.abs((ordenRankings[order[i]]) / SE));
-
-        }
-
-    }
-
-    /**
-     * Return the p-values computed by the Holm test.
-     *
-     * @return algPValues
-     */
-    public ArrayList<PValuePerTwoAlgorithm> holmTest() {
-        ArrayList<PValuePerTwoAlgorithm> algPValues = new ArrayList<>();
-        double[] holmPValues;
-        holmPValues = new double[Pi.length];
-
-        for (i = 0; i < holmPValues.length; i++) {
-            holmPValues[i] = Pi[i] * (double) (holmPValues.length - i);
-        }
-        for (i = 1; i < holmPValues.length; i++) {
-            if (holmPValues[i] < holmPValues[i - 1]) {
-                holmPValues[i] = holmPValues[i - 1];
-            }
-        }
-        for (i = 0; i < Pi.length; i++) {
-            algPValues.add(new PValuePerTwoAlgorithm(algoritmos.get(parejitas[order[i]].i).toString(),
-                    algoritmos.get(parejitas[order[i]].j).toString(), holmPValues[i]));
-        }
-
-        return algPValues;
-    }
-
-    /**
-     * Return the p-values computed by the Shaffer test.
-     *
-     * @return algPValues
-     */
-    public ArrayList<PValuePerTwoAlgorithm> shafferTest() {
-        ArrayList<PValuePerTwoAlgorithm> algPValues = new ArrayList<>();
-        double[] shafferPValues;
-        shafferPValues = new double[Pi.length];
-        pos = 0;
-        tmp = Tarray.length - 1;
-        for (i = 0; i < shafferPValues.length; i++) {
-            shafferPValues[i] = Pi[i] * ((double) shafferPValues.length - (double) Math.max(pos, i));
-            if (i == pos) {
-                tmp--;
-                pos = (int) combinatoria(2, algoritmos.size()) - Tarray[tmp];
-            }
-        }
-        for (i = 1; i < shafferPValues.length; i++) {
-            if (shafferPValues[i] < shafferPValues[i - 1]) {
-                shafferPValues[i] = shafferPValues[i - 1];
-            }
-            if (shafferPValues[i] < shafferPValues[i - 1]) {
-                shafferPValues[i] = shafferPValues[i - 1];
-            }
-        }
-
-        for (i = 0; i < Pi.length; i++) {
-            algPValues.add(new PValuePerTwoAlgorithm(algoritmos.get(parejitas[order[i]].i).toString(),
-                    algoritmos.get(parejitas[order[i]].j).toString(), shafferPValues[i]));
-        }
-
-        return algPValues;
-    }
-
-    /**
-     * Return the p-values computed by the Nemenyi test.
-     *
-     * @return algPValues
-     */
-    public ArrayList<PValuePerTwoAlgorithm> nemenyiTest() {
-        ArrayList<PValuePerTwoAlgorithm> algPValues = new ArrayList<>();
-        double[] nemenyiPValues;
-        nemenyiPValues = new double[Pi.length];
-        pos = 0;
-        tmp = Tarray.length - 1;
-        for (i = 0; i < nemenyiPValues.length; i++) {
-            nemenyiPValues[i] = Pi[i] * (double) (nemenyiPValues.length);
-        }
-
-        for (i = 0; i < Pi.length; i++) {
-            algPValues.add(new PValuePerTwoAlgorithm(algoritmos.get(parejitas[order[i]].i).toString(),
-                    algoritmos.get(parejitas[order[i]].j).toString(), nemenyiPValues[i]));
-        }
-        return algPValues;
-    }
-
-    private static double combinatoria(int m, int n) {
-
-        double result = 1;
-        int i;
-
-        if (n >= m) {
-            for (i = 1; i <= m; i++) {
-                result *= (double) (n - m + i) / (double) i;
-            }
-        } else {
-            result = 0;
-        }
-        return result;
-    }
-
-    private static ArrayList obtainExhaustive(ArrayList indices) {
-
-        ArrayList result = new ArrayList();
-        int i, j, k;
-        String binario;
-        boolean[] number = new boolean[indices.size()];
-        ArrayList ind1, ind2;
-        ArrayList set = new ArrayList();
-        ArrayList res1, res2;
-        ArrayList temp;
-        ArrayList temp2;
-        ArrayList temp3;
-
-        ind1 = new ArrayList();
-        ind2 = new ArrayList();
-        temp = new ArrayList();
-        temp2 = new ArrayList();
-        temp3 = new ArrayList();
-
-        for (i = 0; i < indices.size(); i++) {
-            for (j = i + 1; j < indices.size(); j++) {
-                set.add(new Relation(((Integer) indices.get(i)), ((Integer) indices.get(j))));
-            }
-        }
-        if (set.size() > 0) {
-            result.add(set);
-        }
-
-        for (i = 1; i < (int) (Math.pow(2, indices.size() - 1)); i++) {
-            Arrays.fill(number, false);
-            ind1.clear();
-            ind2.clear();
-            temp.clear();
-            temp2.clear();
-            temp3.clear();
-            binario = Integer.toString(i, 2);
-            for (k = 0; k < number.length - binario.length(); k++) {
-                number[k] = false;
-            }
-            for (j = 0; j < binario.length(); j++, k++) {
-                if (binario.charAt(j) == '1') {
-                    number[k] = true;
-                }
-            }
-            for (j = 0; j < number.length; j++) {
-                if (number[j] == true) {
-                    ind1.add(((Integer) indices.get(j)));
-                } else {
-                    ind2.add(((Integer) indices.get(j)));
-                }
-            }
-            res1 = obtainExhaustive(ind1);
-            res2 = obtainExhaustive(ind2);
-            for (j = 0; j < res1.size(); j++) {
-                result.add(new ArrayList((ArrayList) res1.get(j)));
-            }
-            for (j = 0; j < res2.size(); j++) {
-                result.add(new ArrayList((ArrayList) res2.get(j)));
-            }
-            for (j = 0; j < res1.size(); j++) {
-                temp = (ArrayList) ((ArrayList) res1.get(j)).clone();
-                for (k = 0; k < res2.size(); k++) {
-                    temp2 = (ArrayList) temp.clone();
-                    temp3 = (ArrayList) ((ArrayList) res2.get(k)).clone();
-                    if (((Relation) temp2.get(0)).i < ((Relation) temp3.get(0)).i) {
-                        temp2.addAll((ArrayList) temp3);
-                        result.add(new ArrayList(temp2));
-                    } else {
-                        temp3.addAll((ArrayList) temp2);
-                        result.add(new ArrayList(temp3));
-
-                    }
-                }
-            }
-        }
-        for (i = 0; i < result.size(); i++) {
-            if (((ArrayList) result.get(i)).toString().equalsIgnoreCase("[]")) {
-                result.remove(i);
-                i--;
-            }
-        }
-        for (i = 0; i < result.size(); i++) {
-            for (j = i + 1; j < result.size(); j++) {
-                if (((ArrayList) result.get(i)).toString().equalsIgnoreCase(((ArrayList) result.get(j)).toString())) {
-                    result.remove(j);
-                    j--;
-                }
-            }
-        }
-        return result;
-    }
-
-    private static ArrayList trueHShaffer(int k) {
-
-        ArrayList number;
-        int j;
-        ArrayList tmp, tmp2;
-        int p;
-
-        number = new ArrayList();
-        tmp = new ArrayList();
-        if (k <= 1) {
-            number.add(0);
-        } else {
-            for (j = 1; j <= k; j++) {
-                tmp = trueHShaffer(k - j);
-                tmp2 = new ArrayList();
-                for (p = 0; p < tmp.size(); p++) {
-                    tmp2.add(((Integer) (tmp.get(p))) + (int) combinatoria(2, j));
-                }
-                number = unionVectores(number, tmp2);
-            }
-        }
-
-        return number;
-    }
-
-    private static ArrayList unionVectores(ArrayList a, ArrayList b) {
-
-        int i;
-
-        for (i = 0; i < b.size(); i++) {
-            if (a.contains(new Integer((Integer) (b.get(i)))) == false) {
-                a.add(b.get(i));
-            }
-        }
-
-        return a;
-    }
-
-    private static double ChiSq(double x, int n) {
-        if (n == 1 & x > 1000) {
-            return 0;
-        }
-        if (x > 1000 | n > 1000) {
-            double q = ChiSq((x - n) * (x - n) / (2 * n), 1) / 2;
-            if (x > n) {
-                return q;
-            }
-            {
-                return 1 - q;
-            }
-        }
-        double p = Math.exp(-0.5 * x);
-        if ((n % 2) == 1) {
-            p = p * Math.sqrt(2 * x / Math.PI);
-        }
-        double k = n;
-        while (k >= 2) {
-            p = p * x / k;
-            k = k - 2;
-        }
-        double t = p;
-        double a = n;
-        while (t > 0.0000000001 * p) {
-            a = a + 2;
-            t = t * x / a;
-            p = p + t;
-        }
-        return 1 - p;
-    }
-
-    private static double FishF(double f, int n1, int n2) {
-        double x = n2 / (n1 * f + n2);
-        if ((n1 % 2) == 0) {
-            return StatCom(1 - x, n2, n1 + n2 - 4, n2 - 2) * Math.pow(x, n2 / 2.0);
-        }
-        if ((n2 % 2) == 0) {
-            return 1
-                    - StatCom(x, n1, n1 + n2 - 4, n1 - 2)
-                    * Math.pow(1 - x, n1 / 2.0);
-        }
-        double th = Math.atan(Math.sqrt(n1 * f / (1.0 * n2)));
-        double a = th / (Math.PI / 2.0);
-        double sth = Math.sin(th);
-        double cth = Math.cos(th);
-        if (n2 > 1) {
-            a = a
-                    + sth * cth * StatCom(cth * cth, 2, n2 - 3, -1) / (Math.PI / 2.0);
-        }
-        if (n1 == 1) {
-            return 1 - a;
-        }
-        double c = 4 * StatCom(sth * sth, n2 + 1, n1 + n2 - 4, n2 - 2) * sth
-                * Math.pow(cth, n2) / Math.PI;
-        if (n2 == 1) {
-            return 1 - a + c / 2.0;
-        }
-        int k = 2;
-        while (k <= (n2 - 1) / 2.0) {
-            c = c * k / (k - .5);
-            k = k + 1;
-        }
-        return 1 - a + c;
-    }
-
-    private static double StatCom(double q, int i, int j, int b) {
-        double zz = 1;
-        double z = zz;
-        int k = i;
-        while (k <= j) {
-            zz = zz * q * k / (k - b);
-            z = z + zz;
-            k = k + 2;
-        }
-        return z;
-    }
-
-    private static class ComparatorImpl implements Comparator<RankPerAlgorithm> {
-
-        public ComparatorImpl() {
-        }
-
-        @Override
-        public int compare(RankPerAlgorithm r1, RankPerAlgorithm r2) {
-            return r1.compareTo(r2);
-        }
-    }
+	ArrayList algoritmos;
+	ArrayList datasets;
+	ArrayList datos;
+	// String linea, token;
+	int i, j, k, m;
+	int posicion;
+	double mean[][];
+	Pareja orden[][];
+	Pareja rank[][];
+	boolean encontrado;
+	int ig;
+	double sum;
+	boolean visto[];
+	ArrayList porVisitar;
+	double Rj[];
+	double friedman;
+	double sumatoria = 0;
+	double termino1, termino2, termino3;
+	double iman;
+	boolean vistos[];
+	int pos, tmp;
+	double min;
+	double maxVal;
+	double rankingRef;
+	double Pi[];
+	double ALPHAiHolm[];
+	double ALPHAiShaffer[];
+	String ordenAlgoritmos[];
+	double ordenRankings[];
+	int order[];
+	double adjustedP[][];
+	double Ci[];
+	double SE;
+	boolean parar, otro;
+	ArrayList indices = new ArrayList();
+	ArrayList exhaustiveI = new ArrayList();
+	boolean[][] cuadro;
+	double minPi, tmpPi, maxAPi, tmpAPi;
+	Relation[] parejitas;
+	int lineaN = 0;
+	int columnaN = 0;
+	ArrayList T;
+	int Tarray[];
+	ArrayList<RankPerAlgorithm> rankAlg;
+	double pFriedman, pIman;
+	public List<Stream> streams = new ArrayList<>();
+
+	/**
+	 * Constructor.
+	 *
+	 * @param streams
+	 */
+	public StatisticalTest(List<Stream> streams) {
+		this.streams = streams;
+		algoritmos = new ArrayList();
+		datasets = new ArrayList();
+		datos = new ArrayList();
+		rankAlg = new ArrayList<>();
+
+	}
+
+	/**
+	 * Read a csv file from an path.
+	 *
+	 * @param path
+	 */
+	public void readCSV(String path) {
+		String cadena, linea, token;
+		StringTokenizer lineas, tokens;
+		cadena = Fichero.leeFichero(path);
+		lineas = new StringTokenizer(cadena, "\n\r");
+		while (lineas.hasMoreTokens()) {
+			linea = lineas.nextToken();
+			tokens = new StringTokenizer(linea, ",\t");
+			columnaN = 0;
+			while (tokens.hasMoreTokens()) {
+				if (lineaN == 0) {
+					if (columnaN == 0) {
+						token = tokens.nextToken();
+					} else {
+						token = tokens.nextToken();
+						algoritmos.add(token);
+						datos.add(new ArrayList());
+					}
+				} else {
+					if (columnaN == 0) {
+						token = tokens.nextToken();
+						datasets.add(token);
+					} else {
+						token = tokens.nextToken();
+						((ArrayList) datos.get(columnaN - 1)).add(new Double(token));
+					}
+				}
+				columnaN++;
+			}
+			lineaN++;
+		}
+	}
+
+	/**
+	 * Read data from experiments sumaries.
+	 */
+	public void readData() {
+
+		int cont = 0;
+		int algorithmSize = this.streams.get(0).algorithm.size();
+		int streamSize = this.streams.size();
+		int measureSize = this.streams.get(0).algorithm.get(0).measures.size();
+
+		for (int i = 0; i < algorithmSize; i++) {
+			algoritmos.add(this.streams.get(0).algorithm.get(i).name);
+			datos.add(new ArrayList());
+		}
+		for (int i = 0; i < streamSize; i++) {
+			List<Algorithm> alg = this.streams.get(i).algorithm;
+			datasets.add(this.streams.get(i).name);
+			for (int j = 0; j < algorithmSize; j++) {
+				((ArrayList) datos.get(j)).add(alg.get(j).measures.get(cont).getValue());
+			}
+
+		}
+
+	}
+
+	/**
+	 * Compute the average ranking of the algorithms.
+	 */
+	public void avgPerformance() {
+		mean = new double[datasets.size()][algoritmos.size()];
+
+		/* Compute the average performance per algorithm for each data set */
+		for (i = 0; i < datasets.size(); i++) {
+			for (j = 0; j < algoritmos.size(); j++) {
+				mean[i][j] = ((Double) ((ArrayList) datos.get(j)).get(i));
+			}
+		}
+
+		/* We use the pareja structure to compute and order rankings */
+		orden = new Pareja[datasets.size()][algoritmos.size()];
+		for (i = 0; i < datasets.size(); i++) {
+			for (j = 0; j < algoritmos.size(); j++) {
+				orden[i][j] = new Pareja(j, mean[i][j]);
+			}
+			Arrays.sort(orden[i]);
+		}
+
+		/* building of the rankings table per algorithms and data sets */
+		rank = new Pareja[datasets.size()][algoritmos.size()];
+		posicion = 0;
+		for (i = 0; i < datasets.size(); i++) {
+			for (j = 0; j < algoritmos.size(); j++) {
+				encontrado = false;
+				for (k = 0; k < algoritmos.size() && !encontrado; k++) {
+					if (orden[i][k].indice == j) {
+						encontrado = true;
+						posicion = k + 1;
+					}
+				}
+				rank[i][j] = new Pareja(posicion, orden[i][posicion - 1].valor);
+			}
+		}
+
+		/* In the case of having the same performance, the rankings are equal */
+		for (i = 0; i < datasets.size(); i++) {
+			visto = new boolean[algoritmos.size()];
+			porVisitar = new ArrayList();
+
+			Arrays.fill(visto, false);
+			for (j = 0; j < algoritmos.size(); j++) {
+				porVisitar.clear();
+				sum = rank[i][j].indice;
+				visto[j] = true;
+				ig = 1;
+				for (k = j + 1; k < algoritmos.size(); k++) {
+					if (rank[i][j].valor == rank[i][k].valor && !visto[k]) {
+						sum += rank[i][k].indice;
+						ig++;
+						porVisitar.add(new Integer(k));
+						visto[k] = true;
+					}
+				}
+				sum /= ig;
+				rank[i][j].indice = sum;
+				for (k = 0; k < porVisitar.size(); k++) {
+					rank[i][((Integer) porVisitar.get(k))].indice = sum;
+				}
+			}
+		}
+		avgRankingPerAlgorithm();
+	}
+
+	private void avgRankingPerAlgorithm() {
+
+		Rj = new double[algoritmos.size()];
+		for (i = 0; i < algoritmos.size(); i++) {
+			Rj[i] = 0;
+			for (j = 0; j < datasets.size(); j++) {
+				Rj[i] += rank[j][i].indice / (datasets.size());
+			}
+		}
+		/* Print the average ranking per algorithm */
+		for (i = 0; i < algoritmos.size(); i++) {
+			rankAlg.add(new RankPerAlgorithm((String) algoritmos.get(i), Rj[i]));
+		}
+		// Order de Algorithms with rank
+		Collections.sort(rankAlg, new ComparatorImpl());
+
+		/* Compute the Friedman statistic */
+		termino1 = (12 * (double) datasets.size()) / (algoritmos.size() * ((double) algoritmos.size() + 1));
+		termino2 = algoritmos.size() * ((double) algoritmos.size() + 1) * ((double) algoritmos.size() + 1) / (4.0);
+		for (i = 0; i < algoritmos.size(); i++) {
+			sumatoria += Rj[i] * Rj[i];
+		}
+		friedman = (sumatoria - termino2) * termino1;
+
+		pFriedman = ChiSq(friedman, (algoritmos.size() - 1));
+
+		/* Compute the Iman-Davenport statistic */
+		iman = ((datasets.size() - 1) * friedman) / (datasets.size() * (algoritmos.size() - 1) - friedman);
+		pIman = FishF(iman, (algoritmos.size() - 1), (algoritmos.size() - 1) * (datasets.size() - 1));
+		// System.out.print("P-value computed by Iman and Daveport Test: " + pIman +
+		// ".\\newline\n\n");
+
+		termino3 = Math.sqrt(algoritmos.size() * ((double) algoritmos.size() + 1) / (6.0 * datasets.size()));
+		// Inicialize values
+		inicialize();
+
+	}
+
+	/**
+	 * Return the p-value computed by Friedman test.
+	 *
+	 * @return pFriedman
+	 */
+	public double getFriedmanPValue() {
+		return pFriedman;
+	}
+
+	/**
+	 * Return the p-value Iman and Daveport test.
+	 *
+	 * @return pIman
+	 */
+	public double getImanPValue() {
+		return pIman;
+	}
+
+	/**
+	 * Return the ranking of the algorithms.
+	 *
+	 * @return rankAlg
+	 */
+	public ArrayList<RankPerAlgorithm> getRankAlg() {
+		return rankAlg;
+	}
+
+	private void inicialize() {
+		/* Compute the unadjusted p_i value for each comparison alpha=0.10 */
+		Pi = new double[(int) combinatoria(2, algoritmos.size())];
+		ordenAlgoritmos = new String[(int) combinatoria(2, algoritmos.size())];
+		ordenRankings = new double[(int) combinatoria(2, algoritmos.size())];
+		order = new int[(int) combinatoria(2, algoritmos.size())];
+		parejitas = new Relation[(int) combinatoria(2, algoritmos.size())];
+		T = new ArrayList();
+		T = trueHShaffer(algoritmos.size());
+		Tarray = new int[T.size()];
+		for (i = 0; i < T.size(); i++) {
+			Tarray[i] = ((Integer) T.get(i));
+		}
+		Arrays.sort(Tarray);
+		SE = termino3;
+		vistos = new boolean[(int) combinatoria(2, algoritmos.size())];
+		for (i = 0, k = 0; i < algoritmos.size(); i++) {
+			for (j = i + 1; j < algoritmos.size(); j++, k++) {
+				ordenRankings[k] = Math.abs(Rj[i] - Rj[j]);
+				ordenAlgoritmos[k] = (String) algoritmos.get(i) + " vs. " + (String) algoritmos.get(j);
+				parejitas[k] = new Relation(i, j);
+			}
+		}
+
+		Arrays.fill(vistos, false);
+		for (i = 0; i < ordenRankings.length; i++) {
+			for (j = 0; vistos[j] == true; j++)
+				;
+			pos = j;
+			maxVal = ordenRankings[j];
+			for (j = j + 1; j < ordenRankings.length; j++) {
+				if (vistos[j] == false && ordenRankings[j] > maxVal) {
+					pos = j;
+					maxVal = ordenRankings[j];
+				}
+			}
+			vistos[pos] = true;
+			order[i] = pos;
+		}
+
+		/*
+		 * Computing the logically related hypotheses tests (Shaffer and
+		 * Bergmann-Hommel)
+		 */
+		pos = 0;
+		tmp = Tarray.length - 1;
+		for (i = 0; i < order.length; i++) {
+			Pi[i] = 2 * CDF_Normal.normp((-1) * Math.abs((ordenRankings[order[i]]) / SE));
+
+		}
+
+	}
+
+	/**
+	 * Return the p-values computed by the Holm test.
+	 *
+	 * @return algPValues
+	 */
+	public ArrayList<PValuePerTwoAlgorithm> holmTest() {
+		ArrayList<PValuePerTwoAlgorithm> algPValues = new ArrayList<>();
+		double[] holmPValues;
+		holmPValues = new double[Pi.length];
+
+		for (i = 0; i < holmPValues.length; i++) {
+			holmPValues[i] = Pi[i] * (holmPValues.length - i);
+		}
+		for (i = 1; i < holmPValues.length; i++) {
+			if (holmPValues[i] < holmPValues[i - 1]) {
+				holmPValues[i] = holmPValues[i - 1];
+			}
+		}
+		for (i = 0; i < Pi.length; i++) {
+			algPValues.add(new PValuePerTwoAlgorithm(algoritmos.get(parejitas[order[i]].i).toString(),
+					algoritmos.get(parejitas[order[i]].j).toString(), holmPValues[i]));
+		}
+
+		return algPValues;
+	}
+
+	/**
+	 * Return the p-values computed by the Shaffer test.
+	 *
+	 * @return algPValues
+	 */
+	public ArrayList<PValuePerTwoAlgorithm> shafferTest() {
+		ArrayList<PValuePerTwoAlgorithm> algPValues = new ArrayList<>();
+		double[] shafferPValues;
+		shafferPValues = new double[Pi.length];
+		pos = 0;
+		tmp = Tarray.length - 1;
+		for (i = 0; i < shafferPValues.length; i++) {
+			shafferPValues[i] = Pi[i] * ((double) shafferPValues.length - (double) Math.max(pos, i));
+			if (i == pos) {
+				tmp--;
+				pos = (int) combinatoria(2, algoritmos.size()) - Tarray[tmp];
+			}
+		}
+		for (i = 1; i < shafferPValues.length; i++) {
+			if (shafferPValues[i] < shafferPValues[i - 1]) {
+				shafferPValues[i] = shafferPValues[i - 1];
+			}
+			if (shafferPValues[i] < shafferPValues[i - 1]) {
+				shafferPValues[i] = shafferPValues[i - 1];
+			}
+		}
+
+		for (i = 0; i < Pi.length; i++) {
+			algPValues.add(new PValuePerTwoAlgorithm(algoritmos.get(parejitas[order[i]].i).toString(),
+					algoritmos.get(parejitas[order[i]].j).toString(), shafferPValues[i]));
+		}
+
+		return algPValues;
+	}
+
+	/**
+	 * Return the p-values computed by the Nemenyi test.
+	 *
+	 * @return algPValues
+	 */
+	public ArrayList<PValuePerTwoAlgorithm> nemenyiTest() {
+		ArrayList<PValuePerTwoAlgorithm> algPValues = new ArrayList<>();
+		double[] nemenyiPValues;
+		nemenyiPValues = new double[Pi.length];
+		pos = 0;
+		tmp = Tarray.length - 1;
+		for (i = 0; i < nemenyiPValues.length; i++) {
+			nemenyiPValues[i] = Pi[i] * (nemenyiPValues.length);
+		}
+
+		for (i = 0; i < Pi.length; i++) {
+			algPValues.add(new PValuePerTwoAlgorithm(algoritmos.get(parejitas[order[i]].i).toString(),
+					algoritmos.get(parejitas[order[i]].j).toString(), nemenyiPValues[i]));
+		}
+		return algPValues;
+	}
+
+	private static double combinatoria(int m, int n) {
+
+		double result = 1;
+		int i;
+
+		if (n >= m) {
+			for (i = 1; i <= m; i++) {
+				result *= (double) (n - m + i) / (double) i;
+			}
+		} else {
+			result = 0;
+		}
+		return result;
+	}
+
+	private static ArrayList obtainExhaustive(ArrayList indices) {
+
+		ArrayList result = new ArrayList();
+		int i, j, k;
+		String binario;
+		boolean[] number = new boolean[indices.size()];
+		ArrayList ind1, ind2;
+		ArrayList set = new ArrayList();
+		ArrayList res1, res2;
+		ArrayList temp;
+		ArrayList temp2;
+		ArrayList temp3;
+
+		ind1 = new ArrayList();
+		ind2 = new ArrayList();
+		temp = new ArrayList();
+		temp2 = new ArrayList();
+		temp3 = new ArrayList();
+
+		for (i = 0; i < indices.size(); i++) {
+			for (j = i + 1; j < indices.size(); j++) {
+				set.add(new Relation(((Integer) indices.get(i)), ((Integer) indices.get(j))));
+			}
+		}
+		if (set.size() > 0) {
+			result.add(set);
+		}
+
+		for (i = 1; i < (int) (Math.pow(2, indices.size() - 1)); i++) {
+			Arrays.fill(number, false);
+			ind1.clear();
+			ind2.clear();
+			temp.clear();
+			temp2.clear();
+			temp3.clear();
+			binario = Integer.toString(i, 2);
+			for (k = 0; k < number.length - binario.length(); k++) {
+				number[k] = false;
+			}
+			for (j = 0; j < binario.length(); j++, k++) {
+				if (binario.charAt(j) == '1') {
+					number[k] = true;
+				}
+			}
+			for (j = 0; j < number.length; j++) {
+				if (number[j] == true) {
+					ind1.add((indices.get(j)));
+				} else {
+					ind2.add((indices.get(j)));
+				}
+			}
+			res1 = obtainExhaustive(ind1);
+			res2 = obtainExhaustive(ind2);
+			for (j = 0; j < res1.size(); j++) {
+				result.add(new ArrayList((ArrayList) res1.get(j)));
+			}
+			for (j = 0; j < res2.size(); j++) {
+				result.add(new ArrayList((ArrayList) res2.get(j)));
+			}
+			for (j = 0; j < res1.size(); j++) {
+				temp = (ArrayList) ((ArrayList) res1.get(j)).clone();
+				for (k = 0; k < res2.size(); k++) {
+					temp2 = (ArrayList) temp.clone();
+					temp3 = (ArrayList) ((ArrayList) res2.get(k)).clone();
+					if (((Relation) temp2.get(0)).i < ((Relation) temp3.get(0)).i) {
+						temp2.addAll(temp3);
+						result.add(new ArrayList(temp2));
+					} else {
+						temp3.addAll(temp2);
+						result.add(new ArrayList(temp3));
+
+					}
+				}
+			}
+		}
+		for (i = 0; i < result.size(); i++) {
+			if (((ArrayList) result.get(i)).toString().equalsIgnoreCase("[]")) {
+				result.remove(i);
+				i--;
+			}
+		}
+		for (i = 0; i < result.size(); i++) {
+			for (j = i + 1; j < result.size(); j++) {
+				if (((ArrayList) result.get(i)).toString().equalsIgnoreCase(((ArrayList) result.get(j)).toString())) {
+					result.remove(j);
+					j--;
+				}
+			}
+		}
+		return result;
+	}
+
+	private static ArrayList trueHShaffer(int k) {
+
+		ArrayList number;
+		int j;
+		ArrayList tmp, tmp2;
+		int p;
+
+		number = new ArrayList();
+		tmp = new ArrayList();
+		if (k <= 1) {
+			number.add(0);
+		} else {
+			for (j = 1; j <= k; j++) {
+				tmp = trueHShaffer(k - j);
+				tmp2 = new ArrayList();
+				for (p = 0; p < tmp.size(); p++) {
+					tmp2.add(((Integer) (tmp.get(p))) + (int) combinatoria(2, j));
+				}
+				number = unionVectores(number, tmp2);
+			}
+		}
+
+		return number;
+	}
+
+	private static ArrayList unionVectores(ArrayList a, ArrayList b) {
+
+		int i;
+
+		for (i = 0; i < b.size(); i++) {
+			if (a.contains(new Integer((Integer) (b.get(i)))) == false) {
+				a.add(b.get(i));
+			}
+		}
+
+		return a;
+	}
+
+	private static double ChiSq(double x, int n) {
+		if (n == 1 & x > 1000) {
+			return 0;
+		}
+		if (x > 1000 | n > 1000) {
+			double q = ChiSq((x - n) * (x - n) / (2 * n), 1) / 2;
+			if (x > n) {
+				return q;
+			}
+			{
+				return 1 - q;
+			}
+		}
+		double p = Math.exp(-0.5 * x);
+		if ((n % 2) == 1) {
+			p = p * Math.sqrt(2 * x / Math.PI);
+		}
+		double k = n;
+		while (k >= 2) {
+			p = p * x / k;
+			k = k - 2;
+		}
+		double t = p;
+		double a = n;
+		while (t > 0.0000000001 * p) {
+			a = a + 2;
+			t = t * x / a;
+			p = p + t;
+		}
+		return 1 - p;
+	}
+
+	private static double FishF(double f, int n1, int n2) {
+		double x = n2 / (n1 * f + n2);
+		if ((n1 % 2) == 0) {
+			return StatCom(1 - x, n2, n1 + n2 - 4, n2 - 2) * Math.pow(x, n2 / 2.0);
+		}
+		if ((n2 % 2) == 0) {
+			return 1 - StatCom(x, n1, n1 + n2 - 4, n1 - 2) * Math.pow(1 - x, n1 / 2.0);
+		}
+		double th = Math.atan(Math.sqrt(n1 * f / (1.0 * n2)));
+		double a = th / (Math.PI / 2.0);
+		double sth = Math.sin(th);
+		double cth = Math.cos(th);
+		if (n2 > 1) {
+			a = a + sth * cth * StatCom(cth * cth, 2, n2 - 3, -1) / (Math.PI / 2.0);
+		}
+		if (n1 == 1) {
+			return 1 - a;
+		}
+		double c = 4 * StatCom(sth * sth, n2 + 1, n1 + n2 - 4, n2 - 2) * sth * Math.pow(cth, n2) / Math.PI;
+		if (n2 == 1) {
+			return 1 - a + c / 2.0;
+		}
+		int k = 2;
+		while (k <= (n2 - 1) / 2.0) {
+			c = c * k / (k - .5);
+			k = k + 1;
+		}
+		return 1 - a + c;
+	}
+
+	private static double StatCom(double q, int i, int j, int b) {
+		double zz = 1;
+		double z = zz;
+		int k = i;
+		while (k <= j) {
+			zz = zz * q * k / (k - b);
+			z = z + zz;
+			k = k + 2;
+		}
+		return z;
+	}
+
+	private static class ComparatorImpl implements Comparator<RankPerAlgorithm> {
+
+		public ComparatorImpl() {
+		}
+
+		@Override
+		public int compare(RankPerAlgorithm r1, RankPerAlgorithm r2) {
+			return r1.compareTo(r2);
+		}
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/tasks/ConceptDriftMainTask.java b/moa/src/main/java/moa/gui/experimentertab/tasks/ConceptDriftMainTask.java
index 3a9ad4eef..d8cac02a8 100644
--- a/moa/src/main/java/moa/gui/experimentertab/tasks/ConceptDriftMainTask.java
+++ b/moa/src/main/java/moa/gui/experimentertab/tasks/ConceptDriftMainTask.java
@@ -5,6 +5,7 @@
 package moa.gui.experimentertab.tasks;
 
 import java.util.ArrayList;
+
 import moa.streams.clustering.ClusterEvent;
 
 /**
@@ -13,14 +14,14 @@
  */
 public abstract class ConceptDriftMainTask extends ExperimenterTask {
 
-    protected ArrayList<ClusterEvent> events;
+	protected ArrayList<ClusterEvent> events;
+
+	protected void setEventsList(ArrayList<ClusterEvent> events) {
+		this.events = events;
+	}
+
+	public ArrayList<ClusterEvent> getEventsList() {
+		return this.events;
+	}
 
-    protected void setEventsList(ArrayList<ClusterEvent> events) {
-        this.events = events;
-    }
-    
-    public ArrayList<ClusterEvent> getEventsList() {
-        return this.events;
-    }
-    
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/tasks/EvaluateConceptDrift.java b/moa/src/main/java/moa/gui/experimentertab/tasks/EvaluateConceptDrift.java
index 438acc8e9..3d5f7f2b4 100644
--- a/moa/src/main/java/moa/gui/experimentertab/tasks/EvaluateConceptDrift.java
+++ b/moa/src/main/java/moa/gui/experimentertab/tasks/EvaluateConceptDrift.java
@@ -16,61 +16,56 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab.tasks;
 
+import com.github.javacliparser.IntOption;
+
 import moa.core.ObjectRepository;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
 import moa.evaluation.preview.LearningCurve;
 import moa.options.ClassOption;
-import com.github.javacliparser.IntOption;
-import moa.evaluation.LearningPerformanceEvaluator;
 import moa.tasks.TaskMonitor;
 
 /**
- * Task for evaluating a classifier on a stream by testing then training with each example in sequence.
+ * Task for evaluating a classifier on a stream by testing then training with
+ * each example in sequence.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
  * @version $Revision: 7 $
  */
-public class EvaluateConceptDrift extends ConceptDriftMainTask{
+public class EvaluateConceptDrift extends ConceptDriftMainTask {
+
+	@Override
+	public String getPurposeString() {
+		return "Evaluates a classifier on a stream by testing then training with each example in sequence.";
+	}
 
-   
-    @Override
-    public String getPurposeString() {
-        return "Evaluates a classifier on a stream by testing then training with each example in sequence.";
-    }
+	private static final long serialVersionUID = 1L;
 
-    private static final long serialVersionUID = 1L;
+	public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
+			"Classification performance evaluation method.", LearningPerformanceEvaluator.class,
+			"BasicConceptDriftPerformanceEvaluator");
 
-    public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
-            "Classification performance evaluation method.",
-            LearningPerformanceEvaluator.class,
-            "BasicConceptDriftPerformanceEvaluator");
+	public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
+			"Maximum number of instances to test/train on  (-1 = no limit).", 1000, -1, Integer.MAX_VALUE);
 
-    public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
-            "Maximum number of instances to test/train on  (-1 = no limit).",
-            1000, -1, Integer.MAX_VALUE);
+	public IntOption timeLimitOption = new IntOption("timeLimit", 't',
+			"Maximum number of seconds to test/train for (-1 = no limit).", -1, -1, Integer.MAX_VALUE);
 
-    public IntOption timeLimitOption = new IntOption("timeLimit", 't',
-            "Maximum number of seconds to test/train for (-1 = no limit).", -1,
-            -1, Integer.MAX_VALUE);
+	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency", 'f',
+			"How many instances between samples of the learning performance.", 10, 0, Integer.MAX_VALUE);
 
-    public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
-            'f',
-            "How many instances between samples of the learning performance.",
-            10, 0, Integer.MAX_VALUE);
+	@Override
+	public Class<?> getTaskResultType() {
+		return LearningCurve.class;
+	}
 
-   
-    @Override
-    public Class<?> getTaskResultType() {
-        return LearningCurve.class;
-    }
-   
-    
-    @Override
-    protected Object doTaskImpl(TaskMonitor monitor, ObjectRepository repository) {
-        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-    }
+	@Override
+	protected Object doTaskImpl(TaskMonitor monitor, ObjectRepository repository) {
+		throw new UnsupportedOperationException("Not supported yet."); // To change body of generated methods, choose
+																		// Tools | Templates.
+	}
 }
\ No newline at end of file
diff --git a/moa/src/main/java/moa/gui/experimentertab/tasks/EvaluateInterleavedChunks.java b/moa/src/main/java/moa/gui/experimentertab/tasks/EvaluateInterleavedChunks.java
index 105f4dbd8..feec24ee2 100644
--- a/moa/src/main/java/moa/gui/experimentertab/tasks/EvaluateInterleavedChunks.java
+++ b/moa/src/main/java/moa/gui/experimentertab/tasks/EvaluateInterleavedChunks.java
@@ -15,18 +15,17 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab.tasks;
 
-import moa.core.ObjectRepository;
-import moa.tasks.*;
+import com.github.javacliparser.IntOption;
 
+import moa.core.ObjectRepository;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
 import moa.evaluation.preview.LearningCurve;
 import moa.options.ClassOption;
-import com.github.javacliparser.IntOption;
-import moa.evaluation.LearningPerformanceEvaluator;
-
+import moa.tasks.TaskMonitor;
 
 public class EvaluateInterleavedChunks extends ExperimenterTask {
 
@@ -34,60 +33,52 @@ public class EvaluateInterleavedChunks extends ExperimenterTask {
 	public String getPurposeString() {
 		return "Evaluates a classifier on a stream by testing then training with chunks of data in sequence.";
 	}
-	
+
 	private static final long serialVersionUID = 1L;
 
 	/**
 	 * Allows to select the classifier performance evaluation method.
 	 */
-	public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
-            "Learning performance evaluation method.",
-            LearningPerformanceEvaluator.class,
-			"BasicClassificationPerformanceEvaluator");
+	public ClassOption evaluatorOption = new ClassOption("evaluator", 'e', "Learning performance evaluation method.",
+			LearningPerformanceEvaluator.class, "BasicClassificationPerformanceEvaluator");
 
 	/**
-	 * Allows to define the maximum number of instances to test/train on  (-1 = no limit).
+	 * Allows to define the maximum number of instances to test/train on (-1 = no
+	 * limit).
 	 */
 	public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
-			"Maximum number of instances to test/train on  (-1 = no limit).",
-			100000000, -1, Integer.MAX_VALUE);
+			"Maximum number of instances to test/train on  (-1 = no limit).", 100000000, -1, Integer.MAX_VALUE);
 
 	/**
 	 * Allow to define the training/testing chunk size.
 	 */
-	public IntOption chunkSizeOption = new IntOption("chunkSize", 'c',
-			"Number of instances in a data chunk.",
-			1000, 1, Integer.MAX_VALUE);
-	
+	public IntOption chunkSizeOption = new IntOption("chunkSize", 'c', "Number of instances in a data chunk.", 1000, 1,
+			Integer.MAX_VALUE);
+
 	/**
-	 * Allows to define the maximum number of seconds to test/train for (-1 = no limit).
+	 * Allows to define the maximum number of seconds to test/train for (-1 = no
+	 * limit).
 	 */
 	public IntOption timeLimitOption = new IntOption("timeLimit", 't',
-			"Maximum number of seconds to test/train for (-1 = no limit).", -1,
-			-1, Integer.MAX_VALUE);
+			"Maximum number of seconds to test/train for (-1 = no limit).", -1, -1, Integer.MAX_VALUE);
 
 	/**
 	 * Defines how often classifier parameters will be calculated.
 	 */
-	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
-			'f',
-			"How many instances between samples of the learning performance.",
-			100000, 0, Integer.MAX_VALUE);
+	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency", 'f',
+			"How many instances between samples of the learning performance.", 100000, 0, Integer.MAX_VALUE);
 
 	/**
 	 * Allows to define the memory limit for the created model.
 	 */
 	public IntOption maxMemoryOption = new IntOption("maxMemory", 'b',
-			"Maximum size of model (in bytes). -1 = no limit.", -1, -1,
-			Integer.MAX_VALUE);
+			"Maximum size of model (in bytes). -1 = no limit.", -1, -1, Integer.MAX_VALUE);
 
 	/**
 	 * Allows to define the frequency of memory checks.
 	 */
-	public IntOption memCheckFrequencyOption = new IntOption(
-			"memCheckFrequency", 'q',
-			"How many instances between memory bound checks.", 100000, 0,
-			Integer.MAX_VALUE);
+	public IntOption memCheckFrequencyOption = new IntOption("memCheckFrequency", 'q',
+			"How many instances between memory bound checks.", 100000, 0, Integer.MAX_VALUE);
 
 	/**
 	 * Allows to define the output file name and location.
@@ -98,15 +89,15 @@ public String getPurposeString() {
 	/**
 	 * Defines the task's result type.
 	 */
+	@Override
 	public Class<?> getTaskResultType() {
 		return LearningCurve.class;
 	}
 
-    @Override
-    protected Object doTaskImpl(TaskMonitor monitor, ObjectRepository repository) {
-        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-    }
+	@Override
+	protected Object doTaskImpl(TaskMonitor monitor, ObjectRepository repository) {
+		throw new UnsupportedOperationException("Not supported yet."); // To change body of generated methods, choose
+																		// Tools | Templates.
+	}
 
-    
-	
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/tasks/EvaluateInterleavedTestThenTrain.java b/moa/src/main/java/moa/gui/experimentertab/tasks/EvaluateInterleavedTestThenTrain.java
index eace8f9fd..9495cf1b7 100644
--- a/moa/src/main/java/moa/gui/experimentertab/tasks/EvaluateInterleavedTestThenTrain.java
+++ b/moa/src/main/java/moa/gui/experimentertab/tasks/EvaluateInterleavedTestThenTrain.java
@@ -15,17 +15,17 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab.tasks;
 
-import moa.core.ObjectRepository;
-import moa.tasks.*;
+import com.github.javacliparser.IntOption;
 
+import moa.core.ObjectRepository;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
 import moa.evaluation.preview.LearningCurve;
 import moa.options.ClassOption;
-import com.github.javacliparser.IntOption;
-import moa.evaluation.LearningPerformanceEvaluator;
+import moa.tasks.TaskMonitor;
 
 /**
  * Task for evaluating a classifier on a stream by testing then training with
@@ -36,51 +36,43 @@
  */
 public class EvaluateInterleavedTestThenTrain extends ExperimenterTask {
 
-    @Override
-    public String getPurposeString() {
-        return "Evaluates a classifier on a stream by testing then training with each example in sequence.";
-    }
+	@Override
+	public String getPurposeString() {
+		return "Evaluates a classifier on a stream by testing then training with each example in sequence.";
+	}
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public IntOption randomSeedOption = new IntOption(
-            "instanceRandomSeed", 'r',
-            "Seed for random generation of instances.", 1);
+	public IntOption randomSeedOption = new IntOption("instanceRandomSeed", 'r',
+			"Seed for random generation of instances.", 1);
 
-     public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
-            "Classification performance evaluation method.",
-            LearningPerformanceEvaluator.class,
-            "BasicClassificationPerformanceEvaluator");
+	public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
+			"Classification performance evaluation method.", LearningPerformanceEvaluator.class,
+			"BasicClassificationPerformanceEvaluator");
 
-    public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
-            "Maximum number of instances to test/train on  (-1 = no limit).",
-            100000000, -1, Integer.MAX_VALUE);
+	public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
+			"Maximum number of instances to test/train on  (-1 = no limit).", 100000000, -1, Integer.MAX_VALUE);
 
-    public IntOption timeLimitOption = new IntOption("timeLimit", 't',
-            "Maximum number of seconds to test/train for (-1 = no limit).", -1,
-            -1, Integer.MAX_VALUE);
+	public IntOption timeLimitOption = new IntOption("timeLimit", 't',
+			"Maximum number of seconds to test/train for (-1 = no limit).", -1, -1, Integer.MAX_VALUE);
 
-    public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
-            'f',
-            "How many instances between samples of the learning performance.",
-            100000, 0, Integer.MAX_VALUE);
+	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency", 'f',
+			"How many instances between samples of the learning performance.", 100000, 0, Integer.MAX_VALUE);
 
-    public IntOption memCheckFrequencyOption = new IntOption(
-            "memCheckFrequency", 'q',
-            "How many instances between memory bound checks.", 100000, 0,
-            Integer.MAX_VALUE);
+	public IntOption memCheckFrequencyOption = new IntOption("memCheckFrequency", 'q',
+			"How many instances between memory bound checks.", 100000, 0, Integer.MAX_VALUE);
 
 //    public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
 //            "File to append intermediate csv reslts to.", null,"", true);
 
-    @Override
-    public Class<?> getTaskResultType() {
-        return LearningCurve.class;
-    }
+	@Override
+	public Class<?> getTaskResultType() {
+		return LearningCurve.class;
+	}
 
-   
-    @Override
-    protected Object doTaskImpl(TaskMonitor monitor, ObjectRepository repository) {
-        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-    }
+	@Override
+	protected Object doTaskImpl(TaskMonitor monitor, ObjectRepository repository) {
+		throw new UnsupportedOperationException("Not supported yet."); // To change body of generated methods, choose
+																		// Tools | Templates.
+	}
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/tasks/EvaluatePeriodicHeldOutTest.java b/moa/src/main/java/moa/gui/experimentertab/tasks/EvaluatePeriodicHeldOutTest.java
index 42564027f..59eee31a8 100644
--- a/moa/src/main/java/moa/gui/experimentertab/tasks/EvaluatePeriodicHeldOutTest.java
+++ b/moa/src/main/java/moa/gui/experimentertab/tasks/EvaluatePeriodicHeldOutTest.java
@@ -16,17 +16,18 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab.tasks;
 
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
+
 import moa.core.ObjectRepository;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
 import moa.evaluation.preview.LearningCurve;
-import moa.tasks.*;
 import moa.options.ClassOption;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.IntOption;
-import moa.evaluation.LearningPerformanceEvaluator;
+import moa.tasks.TaskMonitor;
 
 /**
  * Task for evaluating a classifier on a stream by periodically testing on a
@@ -37,48 +38,43 @@
  */
 public class EvaluatePeriodicHeldOutTest extends ExperimenterTask {
 
-    @Override
-    public String getPurposeString() {
-        return "Evaluates a classifier on a stream by periodically testing on a heldout set.";
-    }
+	@Override
+	public String getPurposeString() {
+		return "Evaluates a classifier on a stream by periodically testing on a heldout set.";
+	}
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
-            "Classification performance evaluation method.",
-            LearningPerformanceEvaluator.class,
-            "BasicClassificationPerformanceEvaluator");
+	public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
+			"Classification performance evaluation method.", LearningPerformanceEvaluator.class,
+			"BasicClassificationPerformanceEvaluator");
 
-    public IntOption testSizeOption = new IntOption("testSize", 'n',
-            "Number of testing examples.", 1000000, 0, Integer.MAX_VALUE);
+	public IntOption testSizeOption = new IntOption("testSize", 'n', "Number of testing examples.", 1000000, 0,
+			Integer.MAX_VALUE);
 
-    public IntOption trainSizeOption = new IntOption("trainSize", 'i',
-            "Number of training examples, <1 = unlimited.", 0, 0,
-            Integer.MAX_VALUE);
+	public IntOption trainSizeOption = new IntOption("trainSize", 'i', "Number of training examples, <1 = unlimited.",
+			0, 0, Integer.MAX_VALUE);
 
-    public IntOption trainTimeOption = new IntOption("trainTime", 't',
-            "Number of training seconds.", 10 * 60 * 60, 0, Integer.MAX_VALUE);
+	public IntOption trainTimeOption = new IntOption("trainTime", 't', "Number of training seconds.", 10 * 60 * 60, 0,
+			Integer.MAX_VALUE);
 
-    public IntOption sampleFrequencyOption = new IntOption(
-            "sampleFrequency",
-            'f',
-            "Number of training examples between samples of learning performance.",
-            100000, 0, Integer.MAX_VALUE);
+	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency", 'f',
+			"Number of training examples between samples of learning performance.", 100000, 0, Integer.MAX_VALUE);
 
 //    public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
 //            "File to append intermediate csv results to.", null, "csv", true);
 
-    public FlagOption cacheTestOption = new FlagOption("cacheTest", 'c',
-            "Cache test instances in memory.");
+	public FlagOption cacheTestOption = new FlagOption("cacheTest", 'c', "Cache test instances in memory.");
 
-    @Override
-    public Class<?> getTaskResultType() {
-        return LearningCurve.class;
-    }
+	@Override
+	public Class<?> getTaskResultType() {
+		return LearningCurve.class;
+	}
 
-    @Override
-    protected Object doTaskImpl(TaskMonitor monitor, ObjectRepository repository) {
-        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-    }
+	@Override
+	protected Object doTaskImpl(TaskMonitor monitor, ObjectRepository repository) {
+		throw new UnsupportedOperationException("Not supported yet."); // To change body of generated methods, choose
+																		// Tools | Templates.
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/tasks/EvaluatePrequential.java b/moa/src/main/java/moa/gui/experimentertab/tasks/EvaluatePrequential.java
index 723d92286..43f7e10c1 100644
--- a/moa/src/main/java/moa/gui/experimentertab/tasks/EvaluatePrequential.java
+++ b/moa/src/main/java/moa/gui/experimentertab/tasks/EvaluatePrequential.java
@@ -5,13 +5,12 @@
  */
 package moa.gui.experimentertab.tasks;
 
-
-import moa.core.ObjectRepository;
-import moa.options.ClassOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
-import moa.evaluation.LearningPerformanceEvaluator;
 
+import moa.core.ObjectRepository;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
+import moa.options.ClassOption;
 import moa.tasks.TaskMonitor;
 
 /**
@@ -19,52 +18,45 @@
  * @author Alberto
  */
 public class EvaluatePrequential extends ExperimenterTask {
-     @Override
-    public String getPurposeString() {
-        return "Evaluates a classifier on a stream by testing then training with each example in sequence.";
-    }
+	@Override
+	public String getPurposeString() {
+		return "Evaluates a classifier on a stream by testing then training with each example in sequence.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
+			"Classification performance evaluation method.", LearningPerformanceEvaluator.class,
+			"WindowClassificationPerformanceEvaluator");
 
-    private static final long serialVersionUID = 1L;
+	public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
+			"Maximum number of instances to test/train on  (-1 = no limit).", 100000000, -1, Integer.MAX_VALUE);
 
-     public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
-            "Classification performance evaluation method.",
-            LearningPerformanceEvaluator.class,
-            "WindowClassificationPerformanceEvaluator");
+	public IntOption timeLimitOption = new IntOption("timeLimit", 't',
+			"Maximum number of seconds to test/train for (-1 = no limit).", -1, -1, Integer.MAX_VALUE);
 
-    public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
-            "Maximum number of instances to test/train on  (-1 = no limit).",
-            100000000, -1, Integer.MAX_VALUE);
+	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency", 'f',
+			"How many instances between samples of the learning performance.", 100000, 0, Integer.MAX_VALUE);
 
-    public IntOption timeLimitOption = new IntOption("timeLimit", 't',
-            "Maximum number of seconds to test/train for (-1 = no limit).", -1,
-            -1, Integer.MAX_VALUE);
+	public IntOption memCheckFrequencyOption = new IntOption("memCheckFrequency", 'q',
+			"How many instances between memory bound checks.", 100000, 0, Integer.MAX_VALUE);
 
-    public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
-            'f',
-            "How many instances between samples of the learning performance.",
-            100000, 0, Integer.MAX_VALUE);
+	// New for prequential method DEPRECATED
+	public IntOption widthOption = new IntOption("width", 'w', "Size of Window", 1000);
 
-    public IntOption memCheckFrequencyOption = new IntOption(
-            "memCheckFrequency", 'q',
-            "How many instances between memory bound checks.", 100000, 0,
-            Integer.MAX_VALUE);
-    
-    //New for prequential method DEPRECATED
-    public IntOption widthOption = new IntOption("width",
-            'w', "Size of Window", 1000);
+	public FloatOption alphaOption = new FloatOption("alpha", 'a', "Fading factor or exponential smoothing factor",
+			.01);
 
-    public FloatOption alphaOption = new FloatOption("alpha",
-            'a', "Fading factor or exponential smoothing factor", .01);
+	@Override
+	protected Object doTaskImpl(TaskMonitor monitor, ObjectRepository repository) {
+		throw new UnsupportedOperationException("Not supported yet."); // To change body of generated methods, choose
+																		// Tools | Templates.
+	}
 
-    @Override
-    protected Object doTaskImpl(TaskMonitor monitor, ObjectRepository repository) {
-        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-    }
+	@Override
+	public Class<?> getTaskResultType() {
+		throw new UnsupportedOperationException("Not supported yet."); // To change body of generated methods, choose
+																		// Tools | Templates.
+	}
 
-    @Override
-    public Class<?> getTaskResultType() {
-        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-    }
-    
-    
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/tasks/EvaluatePrequentialCV.java b/moa/src/main/java/moa/gui/experimentertab/tasks/EvaluatePrequentialCV.java
index 757088ae1..60c983345 100644
--- a/moa/src/main/java/moa/gui/experimentertab/tasks/EvaluatePrequentialCV.java
+++ b/moa/src/main/java/moa/gui/experimentertab/tasks/EvaluatePrequentialCV.java
@@ -16,23 +16,28 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.gui.experimentertab.tasks;
 
-import moa.tasks.*;
 import com.github.javacliparser.IntOption;
 import com.github.javacliparser.MultiChoiceOption;
-import moa.core.*;
-import moa.evaluation.*;
+
+import moa.core.ObjectRepository;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
 import moa.options.ClassOption;
+import moa.tasks.TaskMonitor;
 
 /**
- * Task for prequential cross-validation evaluation of a classifier on a stream by testing then training with each
- * example in sequence and doing cross-validation at the same time.
+ * Task for prequential cross-validation evaluation of a classifier on a stream
+ * by testing then training with each example in sequence and doing
+ * cross-validation at the same time.
  *
- * <p>Albert Bifet, Gianmarco De Francisci Morales, Jesse Read, Geoff Holmes, Bernhard Pfahringer: Efficient Online
- * Evaluation of Big Data Stream Classifiers. KDD 2015: 59-68</p>
+ * <p>
+ * Albert Bifet, Gianmarco De Francisci Morales, Jesse Read, Geoff Holmes,
+ * Bernhard Pfahringer: Efficient Online Evaluation of Big Data Stream
+ * Classifiers. KDD 2015: 59-68
+ * </p>
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
@@ -40,60 +45,51 @@
  */
 public class EvaluatePrequentialCV extends ExperimenterTask {
 
-    @Override
-    public String getPurposeString() {
-        return "Evaluates a classifier on a stream by doing prequential evaluation (testing then training with each" +
-                " example in sequence) and doing cross-validation.";
-    }
-
-    private static final long serialVersionUID = 1L;
-
-       public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
-            "Classification performance evaluation method.",
-            LearningPerformanceEvaluator.class,
-            "WindowClassificationPerformanceEvaluator");
-
-    public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
-            "Maximum number of instances to test/train on  (-1 = no limit).",
-            100000000, -1, Integer.MAX_VALUE);
-
-    public IntOption timeLimitOption = new IntOption("timeLimit", 't',
-            "Maximum number of seconds to test/train for (-1 = no limit).", -1,
-            -1, Integer.MAX_VALUE);
-
-    public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
-            'f',
-            "How many instances between samples of the learning performance.",
-            100000, 0, Integer.MAX_VALUE);
-
-    public IntOption memCheckFrequencyOption = new IntOption(
-            "memCheckFrequency", 'q',
-            "How many instances between memory bound checks.", 100000, 0,
-            Integer.MAX_VALUE);
-
-    public IntOption ensembleSizeOption = new IntOption("ensembleSize", 'w',
-            "The number of distributed models.", 10, 1, Integer.MAX_VALUE);
-
-    public MultiChoiceOption validationMethodologyOption = new MultiChoiceOption(
-            "validationMethodology", 'a', "Validation methodology to use.", new String[]{
-            "Cross-Validation", "Bootstrap-Validation", "Split-Validation"},
-            new String[]{"k-fold distributed Cross Validation",
-                    "k-fold distributed Bootstrap Validation",
-                    "k-fold distributed Split Validation"
-            }, 0);
-
-    public IntOption randomSeedOption = new IntOption("randomSeed", 'r',
-            "Seed for random behaviour of the task.", 1);
-
-
-    @Override
-    public Class<?> getTaskResultType() {
-        throw new UnsupportedOperationException("Not supported yet."); 
-    }
-
-    @Override
-    protected Object doTaskImpl(TaskMonitor monitor, ObjectRepository repository) {
-        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-    }
-   
+	@Override
+	public String getPurposeString() {
+		return "Evaluates a classifier on a stream by doing prequential evaluation (testing then training with each"
+				+ " example in sequence) and doing cross-validation.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
+			"Classification performance evaluation method.", LearningPerformanceEvaluator.class,
+			"WindowClassificationPerformanceEvaluator");
+
+	public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
+			"Maximum number of instances to test/train on  (-1 = no limit).", 100000000, -1, Integer.MAX_VALUE);
+
+	public IntOption timeLimitOption = new IntOption("timeLimit", 't',
+			"Maximum number of seconds to test/train for (-1 = no limit).", -1, -1, Integer.MAX_VALUE);
+
+	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency", 'f',
+			"How many instances between samples of the learning performance.", 100000, 0, Integer.MAX_VALUE);
+
+	public IntOption memCheckFrequencyOption = new IntOption("memCheckFrequency", 'q',
+			"How many instances between memory bound checks.", 100000, 0, Integer.MAX_VALUE);
+
+	public IntOption ensembleSizeOption = new IntOption("ensembleSize", 'w', "The number of distributed models.", 10, 1,
+			Integer.MAX_VALUE);
+
+	public MultiChoiceOption validationMethodologyOption = new MultiChoiceOption("validationMethodology", 'a',
+			"Validation methodology to use.",
+			new String[] { "Cross-Validation", "Bootstrap-Validation", "Split-Validation" },
+			new String[] { "k-fold distributed Cross Validation", "k-fold distributed Bootstrap Validation",
+					"k-fold distributed Split Validation" },
+			0);
+
+	public IntOption randomSeedOption = new IntOption("randomSeed", 'r', "Seed for random behaviour of the task.", 1);
+
+	@Override
+	public Class<?> getTaskResultType() {
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	protected Object doTaskImpl(TaskMonitor monitor, ObjectRepository repository) {
+		throw new UnsupportedOperationException("Not supported yet."); // To change body of generated methods, choose
+																		// Tools | Templates.
+	}
+
 }
diff --git a/moa/src/main/java/moa/gui/experimentertab/tasks/ExperimenterTask.java b/moa/src/main/java/moa/gui/experimentertab/tasks/ExperimenterTask.java
index e494fbe6d..978a49d04 100644
--- a/moa/src/main/java/moa/gui/experimentertab/tasks/ExperimenterTask.java
+++ b/moa/src/main/java/moa/gui/experimentertab/tasks/ExperimenterTask.java
@@ -5,10 +5,7 @@
  */
 package moa.gui.experimentertab.tasks;
 
-
-import moa.core.ObjectRepository;
 import moa.tasks.AbstractTask;
-import moa.tasks.TaskMonitor;
 
 /**
  *
@@ -16,6 +13,6 @@
  */
 public abstract class ExperimenterTask extends AbstractTask {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
 }
diff --git a/moa/src/main/java/moa/gui/outliertab/OutlierAlgoPanel.java b/moa/src/main/java/moa/gui/outliertab/OutlierAlgoPanel.java
index 80d155308..022f3a8b3 100644
--- a/moa/src/main/java/moa/gui/outliertab/OutlierAlgoPanel.java
+++ b/moa/src/main/java/moa/gui/outliertab/OutlierAlgoPanel.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.gui.outliertab;
@@ -42,211 +42,219 @@
 import com.github.javacliparser.gui.OptionEditComponent;
 import com.github.javacliparser.gui.OptionsConfigurationPanel;
 
-import moa.clusterers.outliers.MyBaseOutlierDetector;
 import moa.gui.GUIUtils;
+import moa.learners.clusterers.outliers.MyBaseOutlierDetector;
 import moa.options.ClassOption;
 import moa.streams.clustering.ClusteringStream;
 
-public class OutlierAlgoPanel extends javax.swing.JPanel implements ActionListener{
-
-    protected List<OptionEditComponent> editComponents = new LinkedList<OptionEditComponent>();
-
-    private ClassOption streamOption = new ClassOption("Stream", 's',
-                "", ClusteringStream.class,
-                "RandomRBFGeneratorEvents"); 
-
-    private ClassOption algorithmOption0 = new ClassOption("Algorithm0", 'a',
-               "Algorithm to use.", MyBaseOutlierDetector.class, "MCOD.MCOD");
-    
-    private ClassOption algorithmOption1 = new ClassOption("Algorithm1", 'a',
-               "Algorithm to use.", MyBaseOutlierDetector.class, "Angiulli.ExactSTORM","None");
-   
-    public OutlierAlgoPanel() {
-        initComponents();
-    }
-
-    public void renderAlgoPanel(){
-
-        setLayout(new BorderLayout());
-
-        ArrayList<Option> options = new ArrayList<Option>();
-        options.add(streamOption);
-        options.add(algorithmOption0);
-        options.add(algorithmOption1);
-
-        JPanel optionsPanel = new JPanel();
-        GridBagLayout gbLayout = new GridBagLayout();
-        optionsPanel.setLayout(gbLayout);
-        
-        //Create generic label constraints
-        GridBagConstraints gbcLabel = new GridBagConstraints();
-        gbcLabel.gridx = 0;
-        gbcLabel.fill = GridBagConstraints.NONE;
-        gbcLabel.anchor = GridBagConstraints.EAST;
-        gbcLabel.weightx = 0;
-        gbcLabel.insets = new Insets(5, 5, 5, 5);
-        
-        //Create generic editor constraints
-        GridBagConstraints gbcOption = new GridBagConstraints();
-        gbcOption.gridx = 1;
-        gbcOption.fill = GridBagConstraints.HORIZONTAL;
-        gbcOption.anchor = GridBagConstraints.CENTER;
-        gbcOption.weightx = 1;
-        gbcOption.insets = new Insets(5, 5, 5, 0);
-
-        //Stream Option
-        JLabel labelStream = new JLabel("Stream");
-        labelStream.setToolTipText("Stream to use.");
-        optionsPanel.add(labelStream, gbcLabel);
-        JComponent editorStream = getEditComponent(streamOption);
-        labelStream.setLabelFor(editorStream);
-        editComponents.add((OptionEditComponent) editorStream);
-        optionsPanel.add(editorStream, gbcOption);
-
-        //Algorithm0 Option
-        JLabel labelAlgo0 = new JLabel("Algorithm1");
-        labelAlgo0.setForeground(Color.RED);
-        labelAlgo0.setToolTipText("Algorithm to use.");
-        optionsPanel.add(labelAlgo0, gbcLabel);
-        JComponent editorAlgo0 = getEditComponent(algorithmOption0);
-        labelAlgo0.setLabelFor(editorAlgo0);
-        editComponents.add((OptionEditComponent) editorAlgo0);
-        optionsPanel.add(editorAlgo0, gbcOption);    
-        
-        //Algorithm1 Option
-        JLabel labelAlgo1 = new JLabel("Algorithm2");
-        labelAlgo1.setForeground(Color.BLUE);
-        labelAlgo1.setToolTipText("Algorithm to use.");
-        optionsPanel.add(labelAlgo1, gbcLabel);
-        JComponent editorAlgo1 = getEditComponent(algorithmOption1);
-        labelAlgo1.setLabelFor(editorAlgo1);
-        editComponents.add((OptionEditComponent) editorAlgo1);
-        optionsPanel.add(editorAlgo1, gbcOption);  
-        
-        //use comparison Algorithm Option
-        GridBagConstraints gbcClearButton = new GridBagConstraints();
-        gbcClearButton.gridx = 2;
-        gbcClearButton.gridy = 2;
-        gbcClearButton.fill = GridBagConstraints.NONE;
-        gbcClearButton.anchor = GridBagConstraints.CENTER;
-        gbcClearButton.insets = new Insets(5, 0, 5, 5);
-        
-        JButton clearButton = new JButton("Clear");
-        clearButton.addActionListener(this);
-        clearButton.setActionCommand("clear");
-        optionsPanel.add(clearButton, gbcClearButton);  
-            
-        add(optionsPanel);
-    }
-    
-    public JComponent getEditComponent(Option option){
-        return OptionsConfigurationPanel.getEditComponent(option);
-    }
-
-    @Override
-    public void actionPerformed(ActionEvent e) {
-        if (e.getActionCommand().equals("clear")){
-            algorithmOption1.setValueViaCLIString("None");
-            editComponents.get(2).setEditState("None");
-        }
-    }    
-    
-    public MyBaseOutlierDetector getClusterer0(){
-        MyBaseOutlierDetector c = null;
-        applyChanges();
-        try {
-            c = (MyBaseOutlierDetector) ClassOption.cliStringToObject(algorithmOption0.getValueAsCLIString(), MyBaseOutlierDetector.class, null);
-        } catch (Exception ex) {
-            Logger.getLogger(OutlierAlgoPanel.class.getName()).log(Level.SEVERE, null, ex);
-        }
-        return c;
-    }
-    
-    public MyBaseOutlierDetector getClusterer1(){
-        MyBaseOutlierDetector c = null;
-        if (algorithmOption1.getValueAsCLIString().equalsIgnoreCase("None") == false) {
-            applyChanges();
-            try {
-                c = (MyBaseOutlierDetector) ClassOption.cliStringToObject(algorithmOption1.getValueAsCLIString(), MyBaseOutlierDetector.class, null);
-            } catch (Exception ex) {
-                Logger.getLogger(OutlierAlgoPanel.class.getName()).log(Level.SEVERE, null, ex);
-            }
-        }
-        return c;
-    }
-    
-    public ClusteringStream getStream(){
-        ClusteringStream s = null;
-        applyChanges();
-        try {
-            s = (ClusteringStream) ClassOption.cliStringToObject(streamOption.getValueAsCLIString(), ClusteringStream.class, null);
-        } catch (Exception ex) {
-            Logger.getLogger(OutlierAlgoPanel.class.getName()).log(Level.SEVERE, null, ex);
-        }
-        return s;
-    }
-
-    public String getStreamValueAsCLIString(){
-        applyChanges();
-        return streamOption.getValueAsCLIString();
-    }
-
-    public String getAlgorithm0ValueAsCLIString(){
-        applyChanges();
-        return algorithmOption0.getValueAsCLIString();
-    }
-    
-    public String getAlgorithm1ValueAsCLIString(){
-        applyChanges();
-        return algorithmOption1.getValueAsCLIString();
-    }
-    
-    /* We need to fetch the right item from editComponents list, index needs to match GUI order */
-    public void setStreamValueAsCLIString(String s){
-        streamOption.setValueViaCLIString(s);
-        editComponents.get(0).setEditState(streamOption.getValueAsCLIString());
-    }
-
-    public void setAlgorithm0ValueAsCLIString(String s){
-        algorithmOption0.setValueViaCLIString(s);
-        editComponents.get(1).setEditState(algorithmOption0.getValueAsCLIString());
-    }
-    
-    public void setAlgorithm1ValueAsCLIString(String s){
-        algorithmOption1.setValueViaCLIString(s);
-        editComponents.get(2).setEditState(algorithmOption1.getValueAsCLIString());
-    }
-
-    public void applyChanges() {
-            for (OptionEditComponent editor : this.editComponents) {
-                    try {
-                            editor.applyState();
-                    } catch (Exception ex) {
-                            GUIUtils.showExceptionDialog(this, "Problem with option "
-                                            + editor.getEditedOption().getName(), ex);
-                    }
-            }
-    }
-
-    public void setPanelTitle(String title){
-        setBorder(javax.swing.BorderFactory.createTitledBorder(null,title, javax.swing.border.TitledBorder.DEFAULT_JUSTIFICATION, javax.swing.border.TitledBorder.DEFAULT_POSITION, new java.awt.Font("Tahoma", 1, 11)));
-    }
-
-    /** This method is called from within the constructor to
-     * initialize the form.
-     * WARNING: Do NOT modify this code. The content of this method is
-     * always regenerated by the Form Editor.
-     */
-    @SuppressWarnings("unchecked")
-    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
-    private void initComponents() {
-
-        setBorder(javax.swing.BorderFactory.createTitledBorder(null, "Cluster Algorithm Setup", javax.swing.border.TitledBorder.DEFAULT_JUSTIFICATION, javax.swing.border.TitledBorder.DEFAULT_POSITION, new java.awt.Font("Tahoma", 1, 11))); // NOI18N
-        setLayout(new java.awt.GridBagLayout());
-    }// </editor-fold>//GEN-END:initComponents
-
-
-    // Variables declaration - do not modify//GEN-BEGIN:variables
-    // End of variables declaration//GEN-END:variables
+public class OutlierAlgoPanel extends javax.swing.JPanel implements ActionListener {
+
+	protected List<OptionEditComponent> editComponents = new LinkedList<>();
+
+	private ClassOption streamOption = new ClassOption("Stream", 's', "", ClusteringStream.class,
+			"RandomRBFGeneratorEvents");
+
+	private ClassOption algorithmOption0 = new ClassOption("Algorithm0", 'a', "Algorithm to use.",
+			MyBaseOutlierDetector.class, "MCOD.MCOD");
+
+	private ClassOption algorithmOption1 = new ClassOption("Algorithm1", 'a', "Algorithm to use.",
+			MyBaseOutlierDetector.class, "Angiulli.ExactSTORM", "None");
+
+	public OutlierAlgoPanel() {
+		initComponents();
+	}
+
+	public void renderAlgoPanel() {
+
+		setLayout(new BorderLayout());
+
+		ArrayList<Option> options = new ArrayList<>();
+		options.add(streamOption);
+		options.add(algorithmOption0);
+		options.add(algorithmOption1);
+
+		JPanel optionsPanel = new JPanel();
+		GridBagLayout gbLayout = new GridBagLayout();
+		optionsPanel.setLayout(gbLayout);
+
+		// Create generic label constraints
+		GridBagConstraints gbcLabel = new GridBagConstraints();
+		gbcLabel.gridx = 0;
+		gbcLabel.fill = GridBagConstraints.NONE;
+		gbcLabel.anchor = GridBagConstraints.EAST;
+		gbcLabel.weightx = 0;
+		gbcLabel.insets = new Insets(5, 5, 5, 5);
+
+		// Create generic editor constraints
+		GridBagConstraints gbcOption = new GridBagConstraints();
+		gbcOption.gridx = 1;
+		gbcOption.fill = GridBagConstraints.HORIZONTAL;
+		gbcOption.anchor = GridBagConstraints.CENTER;
+		gbcOption.weightx = 1;
+		gbcOption.insets = new Insets(5, 5, 5, 0);
+
+		// Stream Option
+		JLabel labelStream = new JLabel("Stream");
+		labelStream.setToolTipText("Stream to use.");
+		optionsPanel.add(labelStream, gbcLabel);
+		JComponent editorStream = getEditComponent(streamOption);
+		labelStream.setLabelFor(editorStream);
+		editComponents.add((OptionEditComponent) editorStream);
+		optionsPanel.add(editorStream, gbcOption);
+
+		// Algorithm0 Option
+		JLabel labelAlgo0 = new JLabel("Algorithm1");
+		labelAlgo0.setForeground(Color.RED);
+		labelAlgo0.setToolTipText("Algorithm to use.");
+		optionsPanel.add(labelAlgo0, gbcLabel);
+		JComponent editorAlgo0 = getEditComponent(algorithmOption0);
+		labelAlgo0.setLabelFor(editorAlgo0);
+		editComponents.add((OptionEditComponent) editorAlgo0);
+		optionsPanel.add(editorAlgo0, gbcOption);
+
+		// Algorithm1 Option
+		JLabel labelAlgo1 = new JLabel("Algorithm2");
+		labelAlgo1.setForeground(Color.BLUE);
+		labelAlgo1.setToolTipText("Algorithm to use.");
+		optionsPanel.add(labelAlgo1, gbcLabel);
+		JComponent editorAlgo1 = getEditComponent(algorithmOption1);
+		labelAlgo1.setLabelFor(editorAlgo1);
+		editComponents.add((OptionEditComponent) editorAlgo1);
+		optionsPanel.add(editorAlgo1, gbcOption);
+
+		// use comparison Algorithm Option
+		GridBagConstraints gbcClearButton = new GridBagConstraints();
+		gbcClearButton.gridx = 2;
+		gbcClearButton.gridy = 2;
+		gbcClearButton.fill = GridBagConstraints.NONE;
+		gbcClearButton.anchor = GridBagConstraints.CENTER;
+		gbcClearButton.insets = new Insets(5, 0, 5, 5);
+
+		JButton clearButton = new JButton("Clear");
+		clearButton.addActionListener(this);
+		clearButton.setActionCommand("clear");
+		optionsPanel.add(clearButton, gbcClearButton);
+
+		add(optionsPanel);
+	}
+
+	public JComponent getEditComponent(Option option) {
+		return OptionsConfigurationPanel.getEditComponent(option);
+	}
+
+	@Override
+	public void actionPerformed(ActionEvent e) {
+		if (e.getActionCommand().equals("clear")) {
+			algorithmOption1.setValueViaCLIString("None");
+			editComponents.get(2).setEditState("None");
+		}
+	}
+
+	public MyBaseOutlierDetector getClusterer0() {
+		MyBaseOutlierDetector c = null;
+		applyChanges();
+		try {
+			c = (MyBaseOutlierDetector) ClassOption.cliStringToObject(algorithmOption0.getValueAsCLIString(),
+					MyBaseOutlierDetector.class, null);
+		} catch (Exception ex) {
+			Logger.getLogger(OutlierAlgoPanel.class.getName()).log(Level.SEVERE, null, ex);
+		}
+		return c;
+	}
+
+	public MyBaseOutlierDetector getClusterer1() {
+		MyBaseOutlierDetector c = null;
+		if (algorithmOption1.getValueAsCLIString().equalsIgnoreCase("None") == false) {
+			applyChanges();
+			try {
+				c = (MyBaseOutlierDetector) ClassOption.cliStringToObject(algorithmOption1.getValueAsCLIString(),
+						MyBaseOutlierDetector.class, null);
+			} catch (Exception ex) {
+				Logger.getLogger(OutlierAlgoPanel.class.getName()).log(Level.SEVERE, null, ex);
+			}
+		}
+		return c;
+	}
+
+	public ClusteringStream getStream() {
+		ClusteringStream s = null;
+		applyChanges();
+		try {
+			s = (ClusteringStream) ClassOption.cliStringToObject(streamOption.getValueAsCLIString(),
+					ClusteringStream.class, null);
+		} catch (Exception ex) {
+			Logger.getLogger(OutlierAlgoPanel.class.getName()).log(Level.SEVERE, null, ex);
+		}
+		return s;
+	}
+
+	public String getStreamValueAsCLIString() {
+		applyChanges();
+		return streamOption.getValueAsCLIString();
+	}
+
+	public String getAlgorithm0ValueAsCLIString() {
+		applyChanges();
+		return algorithmOption0.getValueAsCLIString();
+	}
+
+	public String getAlgorithm1ValueAsCLIString() {
+		applyChanges();
+		return algorithmOption1.getValueAsCLIString();
+	}
+
+	/*
+	 * We need to fetch the right item from editComponents list, index needs to
+	 * match GUI order
+	 */
+	public void setStreamValueAsCLIString(String s) {
+		streamOption.setValueViaCLIString(s);
+		editComponents.get(0).setEditState(streamOption.getValueAsCLIString());
+	}
+
+	public void setAlgorithm0ValueAsCLIString(String s) {
+		algorithmOption0.setValueViaCLIString(s);
+		editComponents.get(1).setEditState(algorithmOption0.getValueAsCLIString());
+	}
+
+	public void setAlgorithm1ValueAsCLIString(String s) {
+		algorithmOption1.setValueViaCLIString(s);
+		editComponents.get(2).setEditState(algorithmOption1.getValueAsCLIString());
+	}
+
+	public void applyChanges() {
+		for (OptionEditComponent editor : this.editComponents) {
+			try {
+				editor.applyState();
+			} catch (Exception ex) {
+				GUIUtils.showExceptionDialog(this, "Problem with option " + editor.getEditedOption().getName(), ex);
+			}
+		}
+	}
+
+	public void setPanelTitle(String title) {
+		setBorder(javax.swing.BorderFactory.createTitledBorder(null, title,
+				javax.swing.border.TitledBorder.DEFAULT_JUSTIFICATION, javax.swing.border.TitledBorder.DEFAULT_POSITION,
+				new java.awt.Font("Tahoma", 1, 11)));
+	}
+
+	/**
+	 * This method is called from within the constructor to initialize the form.
+	 * WARNING: Do NOT modify this code. The content of this method is always
+	 * regenerated by the Form Editor.
+	 */
+	@SuppressWarnings("unchecked")
+	// <editor-fold defaultstate="collapsed" desc="Generated
+	// Code">//GEN-BEGIN:initComponents
+	private void initComponents() {
+
+		setBorder(javax.swing.BorderFactory.createTitledBorder(null, "Cluster Algorithm Setup",
+				javax.swing.border.TitledBorder.DEFAULT_JUSTIFICATION, javax.swing.border.TitledBorder.DEFAULT_POSITION,
+				new java.awt.Font("Tahoma", 1, 11))); // NOI18N
+		setLayout(new java.awt.GridBagLayout());
+	}// </editor-fold>//GEN-END:initComponents
+
+	// Variables declaration - do not modify//GEN-BEGIN:variables
+	// End of variables declaration//GEN-END:variables
 
 }
diff --git a/moa/src/main/java/moa/gui/outliertab/OutlierEvalPanel.java b/moa/src/main/java/moa/gui/outliertab/OutlierEvalPanel.java
index 0883b9034..753885f2f 100644
--- a/moa/src/main/java/moa/gui/outliertab/OutlierEvalPanel.java
+++ b/moa/src/main/java/moa/gui/outliertab/OutlierEvalPanel.java
@@ -14,10 +14,10 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
- 
+
 package moa.gui.outliertab;
 
 import java.awt.GridBagConstraints;
@@ -33,127 +33,129 @@
 
 public class OutlierEvalPanel extends javax.swing.JPanel {
 
-    Class<?>[] measure_classes = null;
-
-    ArrayList<JLabel> labels = null;
-
-    ArrayList<JCheckBox> checkboxes = null;
-
-    /** Creates new form ClusteringEvalPanel */
-    public OutlierEvalPanel() {
-        initComponents();
-        measure_classes = findMeasureClasses();
-        labels = new ArrayList<JLabel>();
-        checkboxes = new ArrayList<JCheckBox>();
-        addComponents();
-    }
-
-    private void addComponents() {
-        GridBagConstraints gb = new GridBagConstraints();
-        gb.insets = new java.awt.Insets(4, 7, 4, 7);
-        int counter = 0;
-        for (int i = 0; i < measure_classes.length; i++) {
-            try {
-                MeasureCollection m = (MeasureCollection) measure_classes[i].newInstance();
-                for (int j = 0; j < m.getNumMeasures(); j++) {
-                    String t = m.getName(j);
-                    JLabel l = new JLabel(m.getName(j));
-                    l.setPreferredSize(new java.awt.Dimension(100, 14));
-                    //labels[i].setToolTipText("");
-                    gb.gridx = 0;
-                    gb.gridy = counter;
-                    labels.add(l);
-                    contentPanel.add(l, gb);
-
-                    JCheckBox cb = new JCheckBox();
-
-                    if (m.isEnabled(j)) {
-                        cb.setSelected(true);
-                    } else {
-                        cb.setSelected(false);
-                    }
-
-                    gb.gridx = 1;
-                    checkboxes.add(cb);
-                    contentPanel.add(cb, gb);
-                    counter++;
-                }
-            } catch (Exception ex) {
-                System.out.println("Couldn't create Instance for " + measure_classes[i].getName());
-            }
-
-        }
-        JLabel dummy = new JLabel();
-        gb.gridx = 0;
-        gb.gridy++;
-        gb.gridwidth = 3;
-        gb.weightx = 1;
-        gb.weighty = 1;
-        add(dummy, gb);
-
-    }
-
-    private Class<?>[] findMeasureClasses() {
-        AutoExpandVector<Class<?>> finalClasses = new AutoExpandVector<Class<?>>();
-        Class<?>[] classesFound = AutoClassDiscovery.findClassesOfType("moa.evaluation",
-                OutlierPerformance.class);
-        for (Class<?> foundClass : classesFound) {
-            finalClasses.add(foundClass);
-        }
-        return finalClasses.toArray(new Class<?>[finalClasses.size()]);
-    }
-
-    public MeasureCollection[] getSelectedMeasures() {
-        ArrayList<MeasureCollection> measuresSelect = new ArrayList<MeasureCollection>();
-        for (int i = 0; i < measure_classes.length; i++) {
-            try {
-                MeasureCollection m = (MeasureCollection) measure_classes[i].newInstance();
-                measuresSelect.add(m);
-            } catch (Exception ex) {
-                System.out.println("Couldn't create Instance for " + measure_classes[i].getName());
-            }
-        }
-
-        MeasureCollection[] measures = new MeasureCollection[measuresSelect.size()];
-        for (int i = 0; i < measures.length; i++) {
-            measures[i] = measuresSelect.get(i);
-        }
-        return measures;
-    }
-
-    /** This method is called from within the constructor to
-     * initialize the form.
-     * WARNING: Do NOT modify this code. The content of this method is
-     * always regenerated by the Form Editor.
-     */
-    @SuppressWarnings("unchecked")
-    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
-    private void initComponents() {
-        java.awt.GridBagConstraints gridBagConstraints;
-
-        scrollPane = new javax.swing.JScrollPane();
-        contentPanel = new javax.swing.JPanel();
-
-        setBorder(javax.swing.BorderFactory.createTitledBorder(null, "Evaluation Measures", javax.swing.border.TitledBorder.DEFAULT_JUSTIFICATION, javax.swing.border.TitledBorder.DEFAULT_POSITION, new java.awt.Font("Tahoma", 1, 11))); // NOI18N
-        setLayout(new java.awt.GridBagLayout());
-
-        scrollPane.setBorder(null);
-        scrollPane.setHorizontalScrollBarPolicy(javax.swing.ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
-        scrollPane.setVerticalScrollBarPolicy(javax.swing.ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);
-        scrollPane.setPreferredSize(new java.awt.Dimension(100, 225));
-
-        contentPanel.setLayout(new java.awt.GridBagLayout());
-        scrollPane.setViewportView(contentPanel);
-
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
-        gridBagConstraints.weightx = 1.0;
-        gridBagConstraints.weighty = 1.0;
-        add(scrollPane, gridBagConstraints);
-    }// </editor-fold>//GEN-END:initComponents
-
-    // Variables declaration - do not modify//GEN-BEGIN:variables
-    private javax.swing.JPanel contentPanel;
-    private javax.swing.JScrollPane scrollPane;
-    // End of variables declaration//GEN-END:variables
+	Class<?>[] measure_classes = null;
+
+	ArrayList<JLabel> labels = null;
+
+	ArrayList<JCheckBox> checkboxes = null;
+
+	/** Creates new form ClusteringEvalPanel */
+	public OutlierEvalPanel() {
+		initComponents();
+		measure_classes = findMeasureClasses();
+		labels = new ArrayList<>();
+		checkboxes = new ArrayList<>();
+		addComponents();
+	}
+
+	private void addComponents() {
+		GridBagConstraints gb = new GridBagConstraints();
+		gb.insets = new java.awt.Insets(4, 7, 4, 7);
+		int counter = 0;
+		for (int i = 0; i < measure_classes.length; i++) {
+			try {
+				MeasureCollection m = (MeasureCollection) measure_classes[i].newInstance();
+				for (int j = 0; j < m.getNumMeasures(); j++) {
+					String t = m.getName(j);
+					JLabel l = new JLabel(m.getName(j));
+					l.setPreferredSize(new java.awt.Dimension(100, 14));
+					// labels[i].setToolTipText("");
+					gb.gridx = 0;
+					gb.gridy = counter;
+					labels.add(l);
+					contentPanel.add(l, gb);
+
+					JCheckBox cb = new JCheckBox();
+
+					if (m.isEnabled(j)) {
+						cb.setSelected(true);
+					} else {
+						cb.setSelected(false);
+					}
+
+					gb.gridx = 1;
+					checkboxes.add(cb);
+					contentPanel.add(cb, gb);
+					counter++;
+				}
+			} catch (Exception ex) {
+				System.out.println("Couldn't create Instance for " + measure_classes[i].getName());
+			}
+
+		}
+		JLabel dummy = new JLabel();
+		gb.gridx = 0;
+		gb.gridy++;
+		gb.gridwidth = 3;
+		gb.weightx = 1;
+		gb.weighty = 1;
+		add(dummy, gb);
+
+	}
+
+	private Class<?>[] findMeasureClasses() {
+		AutoExpandVector<Class<?>> finalClasses = new AutoExpandVector<>();
+		Class<?>[] classesFound = AutoClassDiscovery.findClassesOfType("moa.evaluation", OutlierPerformance.class);
+		for (Class<?> foundClass : classesFound) {
+			finalClasses.add(foundClass);
+		}
+		return finalClasses.toArray(new Class<?>[finalClasses.size()]);
+	}
+
+	public MeasureCollection[] getSelectedMeasures() {
+		ArrayList<MeasureCollection> measuresSelect = new ArrayList<>();
+		for (int i = 0; i < measure_classes.length; i++) {
+			try {
+				MeasureCollection m = (MeasureCollection) measure_classes[i].newInstance();
+				measuresSelect.add(m);
+			} catch (Exception ex) {
+				System.out.println("Couldn't create Instance for " + measure_classes[i].getName());
+			}
+		}
+
+		MeasureCollection[] measures = new MeasureCollection[measuresSelect.size()];
+		for (int i = 0; i < measures.length; i++) {
+			measures[i] = measuresSelect.get(i);
+		}
+		return measures;
+	}
+
+	/**
+	 * This method is called from within the constructor to initialize the form.
+	 * WARNING: Do NOT modify this code. The content of this method is always
+	 * regenerated by the Form Editor.
+	 */
+	@SuppressWarnings("unchecked")
+	// <editor-fold defaultstate="collapsed" desc="Generated
+	// Code">//GEN-BEGIN:initComponents
+	private void initComponents() {
+		java.awt.GridBagConstraints gridBagConstraints;
+
+		scrollPane = new javax.swing.JScrollPane();
+		contentPanel = new javax.swing.JPanel();
+
+		setBorder(javax.swing.BorderFactory.createTitledBorder(null, "Evaluation Measures",
+				javax.swing.border.TitledBorder.DEFAULT_JUSTIFICATION, javax.swing.border.TitledBorder.DEFAULT_POSITION,
+				new java.awt.Font("Tahoma", 1, 11))); // NOI18N
+		setLayout(new java.awt.GridBagLayout());
+
+		scrollPane.setBorder(null);
+		scrollPane.setHorizontalScrollBarPolicy(javax.swing.ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
+		scrollPane.setVerticalScrollBarPolicy(javax.swing.ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);
+		scrollPane.setPreferredSize(new java.awt.Dimension(100, 225));
+
+		contentPanel.setLayout(new java.awt.GridBagLayout());
+		scrollPane.setViewportView(contentPanel);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
+		gridBagConstraints.weightx = 1.0;
+		gridBagConstraints.weighty = 1.0;
+		add(scrollPane, gridBagConstraints);
+	}// </editor-fold>//GEN-END:initComponents
+
+	// Variables declaration - do not modify//GEN-BEGIN:variables
+	private javax.swing.JPanel contentPanel;
+	private javax.swing.JScrollPane scrollPane;
+	// End of variables declaration//GEN-END:variables
 }
diff --git a/moa/src/main/java/moa/gui/outliertab/OutlierSetupTab.java b/moa/src/main/java/moa/gui/outliertab/OutlierSetupTab.java
index ab7ac542b..32fe6dd67 100644
--- a/moa/src/main/java/moa/gui/outliertab/OutlierSetupTab.java
+++ b/moa/src/main/java/moa/gui/outliertab/OutlierSetupTab.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.gui.outliertab;
@@ -25,299 +25,303 @@
 import java.io.File;
 import java.io.FileReader;
 
-import moa.clusterers.outliers.MyBaseOutlierDetector;
+import javax.swing.JFileChooser;
+
 import moa.evaluation.MeasureCollection;
 import moa.gui.FileExtensionFilter;
 import moa.gui.TextViewerPanel;
+import moa.learners.clusterers.outliers.MyBaseOutlierDetector;
 import moa.streams.clustering.ClusteringStream;
 import nz.ac.waikato.cms.gui.core.BaseFileChooser;
 
 public class OutlierSetupTab extends javax.swing.JPanel {
-    private OutlierTabPanel outlierTab;
-    private String lastfile;
-
-    /** Creates new form outlierSetupTab */
-    public OutlierSetupTab() {
-        initComponents();
-        outlierAlgoPanel0.renderAlgoPanel();
-    }
-
-    public MyBaseOutlierDetector getOutlierer0(){
-        return outlierAlgoPanel0.getClusterer0();
-    }
-    
-    public MyBaseOutlierDetector getOutlierer1(){
-        return outlierAlgoPanel0.getClusterer1();
-    }
-
-    public ClusteringStream getStream0(){
-        return outlierAlgoPanel0.getStream();
-    }
-
-    public MeasureCollection[] getMeasures(){
-        return outlierEvalPanel1.getSelectedMeasures();
-    }
-
-    public TextViewerPanel getLogPanel(){
-        return logPanel;
-    }
-
-    public void addButtonActionListener(ActionListener l){
-        buttonWeka.addActionListener(l);
-        buttonWeka.setActionCommand("weka export");
-        buttonExport.addActionListener(l);
-        buttonExport.setActionCommand("csv export");
-    }
-    /** This method is called from within the constructor to
-     * initialize the form.
-     * WARNING: Do NOT modify this code. The content of this method is
-     * always regenerated by the Form Editor.
-     */
-    @SuppressWarnings("unchecked")
-    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
-    private void initComponents() {
-        java.awt.GridBagConstraints gridBagConstraints;
-
-        outlierAlgoPanel0 = new moa.gui.outliertab.OutlierAlgoPanel();
-        outlierEvalPanel1 = new moa.gui.outliertab.OutlierEvalPanel();
-        buttonStart = new javax.swing.JButton();
-        buttonStop = new javax.swing.JButton();
-        buttonExport = new javax.swing.JButton();
-        buttonWeka = new javax.swing.JButton();
-        buttonImportSettings = new javax.swing.JButton();
-        buttonExportSettings = new javax.swing.JButton();
-        logPanel = new moa.gui.TextViewerPanel();
-
-        setLayout(new java.awt.GridBagLayout());
-
-        outlierAlgoPanel0.setMinimumSize(new java.awt.Dimension(335, 150));
-        outlierAlgoPanel0.setPanelTitle("Outlier Detection Algorithm Setup");
-        outlierAlgoPanel0.setPreferredSize(new java.awt.Dimension(500, 150));
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.gridwidth = 6;
-        gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
-        gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
-        add(outlierAlgoPanel0, gridBagConstraints);
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 4;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.gridwidth = 2;
-        gridBagConstraints.gridheight = 4;
-        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
-        gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
-        // ### add(outlierEvalPanel1, gridBagConstraints);
-
-        int iBtnHeight = 27;
-        
-        buttonStart.setText("Start");
-        buttonStart.setMinimumSize(new java.awt.Dimension(80, iBtnHeight));
-        buttonStart.setPreferredSize(new java.awt.Dimension(80, iBtnHeight));
-        buttonStart.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonStartActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 4;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
-        gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
-        add(buttonStart, gridBagConstraints);
-
-        buttonStop.setText("Stop");
-        buttonStop.setMinimumSize(new java.awt.Dimension(80, iBtnHeight));
-        buttonStop.setPreferredSize(new java.awt.Dimension(80, iBtnHeight));
-        buttonStop.setEnabled(false);
-        buttonStop.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonStopActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 1;
-        gridBagConstraints.gridy = 4;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
-        gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
-        add(buttonStop, gridBagConstraints);
-
-        buttonExport.setText("Export CSV");
-        buttonExport.setMinimumSize(new java.awt.Dimension(120, iBtnHeight));
-        buttonExport.setPreferredSize(new java.awt.Dimension(120, iBtnHeight));
-        buttonExport.setEnabled(false);
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 6;
-        gridBagConstraints.gridy = 4;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
-        gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
-        add(buttonExport, gridBagConstraints);
-
-        buttonWeka.setText("Weka Explorer");
-        buttonWeka.setMinimumSize(new java.awt.Dimension(120, iBtnHeight));
-        buttonWeka.setPreferredSize(new java.awt.Dimension(120, iBtnHeight));
-        buttonWeka.setEnabled(false);
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 4;
-        gridBagConstraints.gridy = 4;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
-        gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
-        add(buttonWeka, gridBagConstraints);
-
-        buttonImportSettings.setText("Import");
-        buttonImportSettings.setMinimumSize(new java.awt.Dimension(80, iBtnHeight));
-        buttonImportSettings.setPreferredSize(new java.awt.Dimension(80, iBtnHeight));
-        buttonImportSettings.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonImportSettingsActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 2;
-        gridBagConstraints.gridy = 4;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
-        gridBagConstraints.insets = new java.awt.Insets(4, 75, 4, 4);
-        add(buttonImportSettings, gridBagConstraints);
-
-        buttonExportSettings.setText("Export");
-        buttonExportSettings.setMinimumSize(new java.awt.Dimension(80, iBtnHeight));
-        buttonExportSettings.setPreferredSize(new java.awt.Dimension(80, iBtnHeight));
-        buttonExportSettings.addActionListener(new java.awt.event.ActionListener() {
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonExportSettingsActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 3;
-        gridBagConstraints.gridy = 4;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
-        gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
-        add(buttonExportSettings, gridBagConstraints);
-        
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 5;
-        gridBagConstraints.gridwidth = 7;
-        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
-        gridBagConstraints.weightx = 1.0;
-        gridBagConstraints.weighty = 1.0;
-        gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
-        add(logPanel, gridBagConstraints);
-    }// </editor-fold>//GEN-END:initComponents
-
-    private void buttonImportSettingsActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonImportSettingsActionPerformed
-
-        BaseFileChooser fileChooser = new BaseFileChooser();
-        fileChooser.setAcceptAllFileFilterUsed(true);
-        fileChooser.addChoosableFileFilter(new FileExtensionFilter("txt"));
-        if(lastfile!=null)
-            fileChooser.setSelectedFile(new File(lastfile));
-        if (fileChooser.showOpenDialog(this.buttonImportSettings) == BaseFileChooser.APPROVE_OPTION) {
-            lastfile = fileChooser.getSelectedFile().getPath();
-            loadOptionsFromFile(fileChooser.getSelectedFile().getPath());
-        }
-    }//GEN-LAST:event_buttonImportSettingsActionPerformed
-
-    private void buttonExportSettingsActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonExportSettingsActionPerformed
-        StringBuffer sb = new StringBuffer();
-        sb.append(outlierAlgoPanel0.getStreamValueAsCLIString()+"\n");
-        sb.append(outlierAlgoPanel0.getAlgorithm0ValueAsCLIString()+"\n");
-        
-        System.out.println(sb);
-        logPanel.addText(sb.toString());
-        
-    }//GEN-LAST:event_buttonExportSettingsActionPerformed
-
-    private void buttonStartActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonStartActionPerformed
-        toggle(true);
-    }//GEN-LAST:event_buttonStartActionPerformed
-
-    private void buttonStopActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonStopActionPerformed
-        stop(true);
-    }//GEN-LAST:event_buttonStopActionPerformed
-
-
-    private void loadOptionsFromFile(String filepath){
-        try {
-            BufferedReader in = new BufferedReader(new FileReader(filepath));
-
-            String stream0 = in.readLine();
-            outlierAlgoPanel0.setStreamValueAsCLIString(stream0);
-
-            String algo0 = in.readLine();
-            outlierAlgoPanel0.setAlgorithm0ValueAsCLIString(algo0);
-
-            System.out.println("Loading settings from "+filepath);
-            logPanel.addText("Loading settings from "+filepath);
-
-        } catch (Exception e) {
-            System.out.println("Bad option file:"+e.getMessage());
-        }
-    }
-
-    // Variables declaration - do not modify//GEN-BEGIN:variables
-    private javax.swing.JButton buttonExport;
-    private javax.swing.JButton buttonExportSettings;
-    private javax.swing.JButton buttonImportSettings;
-    private javax.swing.JButton buttonStart;
-    private javax.swing.JButton buttonStop;
-    private javax.swing.JButton buttonWeka;
-    private moa.gui.outliertab.OutlierAlgoPanel outlierAlgoPanel0;
-    private moa.gui.outliertab.OutlierEvalPanel outlierEvalPanel1;
-    private moa.gui.TextViewerPanel logPanel;
-    // End of variables declaration//GEN-END:variables
-
-    void setOutlierTab(OutlierTabPanel outlierTab) {
-        this.outlierTab = outlierTab;
-    }
-
-    public void toggleRunMode(){
-        toggle(false);
-    }
-
-    public void stopRun(){
-        stop(false);
-    }
-
-    private void toggle(boolean internal) {
-        setStateConfigButtons(false);
-        if(buttonStart.getText().equals("Pause")){
-            buttonStart.setText("Resume");
-            buttonWeka.setEnabled(true);
-            buttonExport.setEnabled(true);
-        }
-        else{
-            buttonStart.setText("Pause");
-            buttonWeka.setEnabled(false);
-            buttonExport.setEnabled(false);
-        }
-
-        //push event forward to the cluster tab
-        if(internal)
-            outlierTab.toggle();
-    }
-
-
-    private void stop(boolean internal) {
-        buttonStart.setEnabled(true);
-        buttonStart.setText("Start");
-        buttonStop.setEnabled(false);
-        buttonWeka.setEnabled(false);
-        buttonExport.setEnabled(false);
-        setStateConfigButtons(true);
-
-        //push event forward to the cluster tab
-        if(internal)
-            outlierTab.stop();
-    }
-
-    private void setStateConfigButtons(boolean state){
-        buttonStop.setEnabled(!state);
-        buttonExportSettings.setEnabled(state);
-        buttonImportSettings.setEnabled(state);
-    }
-
+	private OutlierTabPanel outlierTab;
+	private String lastfile;
+
+	/** Creates new form outlierSetupTab */
+	public OutlierSetupTab() {
+		initComponents();
+		outlierAlgoPanel0.renderAlgoPanel();
+	}
+
+	public MyBaseOutlierDetector getOutlierer0() {
+		return outlierAlgoPanel0.getClusterer0();
+	}
+
+	public MyBaseOutlierDetector getOutlierer1() {
+		return outlierAlgoPanel0.getClusterer1();
+	}
+
+	public ClusteringStream getStream0() {
+		return outlierAlgoPanel0.getStream();
+	}
+
+	public MeasureCollection[] getMeasures() {
+		return outlierEvalPanel1.getSelectedMeasures();
+	}
+
+	public TextViewerPanel getLogPanel() {
+		return logPanel;
+	}
+
+	public void addButtonActionListener(ActionListener l) {
+		buttonWeka.addActionListener(l);
+		buttonWeka.setActionCommand("weka export");
+		buttonExport.addActionListener(l);
+		buttonExport.setActionCommand("csv export");
+	}
+
+	/**
+	 * This method is called from within the constructor to initialize the form.
+	 * WARNING: Do NOT modify this code. The content of this method is always
+	 * regenerated by the Form Editor.
+	 */
+	@SuppressWarnings("unchecked")
+	// <editor-fold defaultstate="collapsed" desc="Generated
+	// Code">//GEN-BEGIN:initComponents
+	private void initComponents() {
+		java.awt.GridBagConstraints gridBagConstraints;
+
+		outlierAlgoPanel0 = new moa.gui.outliertab.OutlierAlgoPanel();
+		outlierEvalPanel1 = new moa.gui.outliertab.OutlierEvalPanel();
+		buttonStart = new javax.swing.JButton();
+		buttonStop = new javax.swing.JButton();
+		buttonExport = new javax.swing.JButton();
+		buttonWeka = new javax.swing.JButton();
+		buttonImportSettings = new javax.swing.JButton();
+		buttonExportSettings = new javax.swing.JButton();
+		logPanel = new moa.gui.TextViewerPanel();
+
+		setLayout(new java.awt.GridBagLayout());
+
+		outlierAlgoPanel0.setMinimumSize(new java.awt.Dimension(335, 150));
+		outlierAlgoPanel0.setPanelTitle("Outlier Detection Algorithm Setup");
+		outlierAlgoPanel0.setPreferredSize(new java.awt.Dimension(500, 150));
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.gridwidth = 6;
+		gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
+		gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
+		add(outlierAlgoPanel0, gridBagConstraints);
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 4;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.gridwidth = 2;
+		gridBagConstraints.gridheight = 4;
+		gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
+		gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
+		// ### add(outlierEvalPanel1, gridBagConstraints);
+
+		int iBtnHeight = 27;
+
+		buttonStart.setText("Start");
+		buttonStart.setMinimumSize(new java.awt.Dimension(80, iBtnHeight));
+		buttonStart.setPreferredSize(new java.awt.Dimension(80, iBtnHeight));
+		buttonStart.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonStartActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 4;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
+		gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
+		add(buttonStart, gridBagConstraints);
+
+		buttonStop.setText("Stop");
+		buttonStop.setMinimumSize(new java.awt.Dimension(80, iBtnHeight));
+		buttonStop.setPreferredSize(new java.awt.Dimension(80, iBtnHeight));
+		buttonStop.setEnabled(false);
+		buttonStop.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonStopActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 1;
+		gridBagConstraints.gridy = 4;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
+		gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
+		add(buttonStop, gridBagConstraints);
+
+		buttonExport.setText("Export CSV");
+		buttonExport.setMinimumSize(new java.awt.Dimension(120, iBtnHeight));
+		buttonExport.setPreferredSize(new java.awt.Dimension(120, iBtnHeight));
+		buttonExport.setEnabled(false);
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 6;
+		gridBagConstraints.gridy = 4;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
+		gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
+		add(buttonExport, gridBagConstraints);
+
+		buttonWeka.setText("Weka Explorer");
+		buttonWeka.setMinimumSize(new java.awt.Dimension(120, iBtnHeight));
+		buttonWeka.setPreferredSize(new java.awt.Dimension(120, iBtnHeight));
+		buttonWeka.setEnabled(false);
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 4;
+		gridBagConstraints.gridy = 4;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
+		gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
+		add(buttonWeka, gridBagConstraints);
+
+		buttonImportSettings.setText("Import");
+		buttonImportSettings.setMinimumSize(new java.awt.Dimension(80, iBtnHeight));
+		buttonImportSettings.setPreferredSize(new java.awt.Dimension(80, iBtnHeight));
+		buttonImportSettings.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonImportSettingsActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 2;
+		gridBagConstraints.gridy = 4;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
+		gridBagConstraints.insets = new java.awt.Insets(4, 75, 4, 4);
+		add(buttonImportSettings, gridBagConstraints);
+
+		buttonExportSettings.setText("Export");
+		buttonExportSettings.setMinimumSize(new java.awt.Dimension(80, iBtnHeight));
+		buttonExportSettings.setPreferredSize(new java.awt.Dimension(80, iBtnHeight));
+		buttonExportSettings.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonExportSettingsActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 3;
+		gridBagConstraints.gridy = 4;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
+		gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
+		add(buttonExportSettings, gridBagConstraints);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 5;
+		gridBagConstraints.gridwidth = 7;
+		gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
+		gridBagConstraints.weightx = 1.0;
+		gridBagConstraints.weighty = 1.0;
+		gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
+		add(logPanel, gridBagConstraints);
+	}// </editor-fold>//GEN-END:initComponents
+
+	private void buttonImportSettingsActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonImportSettingsActionPerformed
+
+		BaseFileChooser fileChooser = new BaseFileChooser();
+		fileChooser.setAcceptAllFileFilterUsed(true);
+		fileChooser.addChoosableFileFilter(new FileExtensionFilter("txt"));
+		if (lastfile != null)
+			fileChooser.setSelectedFile(new File(lastfile));
+		if (fileChooser.showOpenDialog(this.buttonImportSettings) == JFileChooser.APPROVE_OPTION) {
+			lastfile = fileChooser.getSelectedFile().getPath();
+			loadOptionsFromFile(fileChooser.getSelectedFile().getPath());
+		}
+	}// GEN-LAST:event_buttonImportSettingsActionPerformed
+
+	private void buttonExportSettingsActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonExportSettingsActionPerformed
+		StringBuffer sb = new StringBuffer();
+		sb.append(outlierAlgoPanel0.getStreamValueAsCLIString() + "\n");
+		sb.append(outlierAlgoPanel0.getAlgorithm0ValueAsCLIString() + "\n");
+
+		System.out.println(sb);
+		logPanel.addText(sb.toString());
+
+	}// GEN-LAST:event_buttonExportSettingsActionPerformed
+
+	private void buttonStartActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonStartActionPerformed
+		toggle(true);
+	}// GEN-LAST:event_buttonStartActionPerformed
+
+	private void buttonStopActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonStopActionPerformed
+		stop(true);
+	}// GEN-LAST:event_buttonStopActionPerformed
+
+	private void loadOptionsFromFile(String filepath) {
+		try {
+			BufferedReader in = new BufferedReader(new FileReader(filepath));
+
+			String stream0 = in.readLine();
+			outlierAlgoPanel0.setStreamValueAsCLIString(stream0);
+
+			String algo0 = in.readLine();
+			outlierAlgoPanel0.setAlgorithm0ValueAsCLIString(algo0);
+
+			System.out.println("Loading settings from " + filepath);
+			logPanel.addText("Loading settings from " + filepath);
+
+		} catch (Exception e) {
+			System.out.println("Bad option file:" + e.getMessage());
+		}
+	}
+
+	// Variables declaration - do not modify//GEN-BEGIN:variables
+	private javax.swing.JButton buttonExport;
+	private javax.swing.JButton buttonExportSettings;
+	private javax.swing.JButton buttonImportSettings;
+	private javax.swing.JButton buttonStart;
+	private javax.swing.JButton buttonStop;
+	private javax.swing.JButton buttonWeka;
+	private moa.gui.outliertab.OutlierAlgoPanel outlierAlgoPanel0;
+	private moa.gui.outliertab.OutlierEvalPanel outlierEvalPanel1;
+	private moa.gui.TextViewerPanel logPanel;
+	// End of variables declaration//GEN-END:variables
+
+	void setOutlierTab(OutlierTabPanel outlierTab) {
+		this.outlierTab = outlierTab;
+	}
+
+	public void toggleRunMode() {
+		toggle(false);
+	}
+
+	public void stopRun() {
+		stop(false);
+	}
+
+	private void toggle(boolean internal) {
+		setStateConfigButtons(false);
+		if (buttonStart.getText().equals("Pause")) {
+			buttonStart.setText("Resume");
+			buttonWeka.setEnabled(true);
+			buttonExport.setEnabled(true);
+		} else {
+			buttonStart.setText("Pause");
+			buttonWeka.setEnabled(false);
+			buttonExport.setEnabled(false);
+		}
+
+		// push event forward to the cluster tab
+		if (internal)
+			outlierTab.toggle();
+	}
+
+	private void stop(boolean internal) {
+		buttonStart.setEnabled(true);
+		buttonStart.setText("Start");
+		buttonStop.setEnabled(false);
+		buttonWeka.setEnabled(false);
+		buttonExport.setEnabled(false);
+		setStateConfigButtons(true);
+
+		// push event forward to the cluster tab
+		if (internal)
+			outlierTab.stop();
+	}
+
+	private void setStateConfigButtons(boolean state) {
+		buttonStop.setEnabled(!state);
+		buttonExportSettings.setEnabled(state);
+		buttonImportSettings.setEnabled(state);
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/outliertab/OutlierTabPanel.java b/moa/src/main/java/moa/gui/outliertab/OutlierTabPanel.java
index 21ea24d8f..752280b71 100644
--- a/moa/src/main/java/moa/gui/outliertab/OutlierTabPanel.java
+++ b/moa/src/main/java/moa/gui/outliertab/OutlierTabPanel.java
@@ -15,89 +15,91 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.gui.outliertab;
 
 import moa.gui.AbstractTabPanel;
 
-public class OutlierTabPanel extends AbstractTabPanel{
-
-    /** Creates new form ClusterTab */
-    public OutlierTabPanel() {
-        initComponents();
-        outlierVisualTab.setOutlierSetupTab(outlierSetupTab);
-        outlierSetupTab.addButtonActionListener(outlierVisualTab);
-        outlierSetupTab.setOutlierTab(this);
-    }
-
-    void toggle() {
-        outlierVisualTab.toggleVisualizer(false);
-    }
-
-    void stop() {
-        outlierVisualTab.stopVisualizer();
-    }
-
-    
-    /** This method is called from within the constructor to
-     * initialize the form.
-     * WARNING: Do NOT modify this code. The content of this method is
-     * always regenerated by the Form Editor.
-     */
-    @SuppressWarnings("unchecked")
-    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
-    private void initComponents() {
-
-        jTabbedPane1 = new javax.swing.JTabbedPane();
-        outlierSetupTab = new moa.gui.outliertab.OutlierSetupTab();
-        outlierVisualTab = new moa.gui.outliertab.OutlierVisualTab();
-
-        setLayout(new java.awt.BorderLayout());
-
-        jTabbedPane1.addMouseListener(new java.awt.event.MouseAdapter() {
-            public void mouseClicked(java.awt.event.MouseEvent evt) {
-                jTabbedPane1MouseClicked(evt);
-            }
-        });
-        jTabbedPane1.addFocusListener(new java.awt.event.FocusAdapter() {
-            public void focusGained(java.awt.event.FocusEvent evt) {
-                jTabbedPane1FocusGained(evt);
-            }
-        });
-        jTabbedPane1.addTab("Setup", outlierSetupTab);
-        jTabbedPane1.addTab("Visualization", outlierVisualTab);
-
-        add(jTabbedPane1, java.awt.BorderLayout.CENTER);
-    }// </editor-fold>//GEN-END:initComponents
-
-    private void jTabbedPane1FocusGained(java.awt.event.FocusEvent evt) {//GEN-FIRST:event_jTabbedPane1FocusGained
-        
-    }//GEN-LAST:event_jTabbedPane1FocusGained
-
-    private void jTabbedPane1MouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_jTabbedPane1MouseClicked
-        
-    }//GEN-LAST:event_jTabbedPane1MouseClicked
-
-
-
-    // Variables declaration - do not modify//GEN-BEGIN:variables
-    private moa.gui.outliertab.OutlierSetupTab outlierSetupTab;
-    private moa.gui.outliertab.OutlierVisualTab outlierVisualTab;
-    private javax.swing.JTabbedPane jTabbedPane1;
-    // End of variables declaration//GEN-END:variables
-
-    //returns the string to display as title of the tab
-    public String getTabTitle() {
-            return "Outliers";
-    }
-
-    //a short description (can be used as tool tip) of the tab, or contributor, etc.
-    public String getDescription(){
-            return "MOA Outliers";
-    }
-
+public class OutlierTabPanel extends AbstractTabPanel {
+
+	/** Creates new form ClusterTab */
+	public OutlierTabPanel() {
+		initComponents();
+		outlierVisualTab.setOutlierSetupTab(outlierSetupTab);
+		outlierSetupTab.addButtonActionListener(outlierVisualTab);
+		outlierSetupTab.setOutlierTab(this);
+	}
+
+	void toggle() {
+		outlierVisualTab.toggleVisualizer(false);
+	}
+
+	void stop() {
+		outlierVisualTab.stopVisualizer();
+	}
+
+	/**
+	 * This method is called from within the constructor to initialize the form.
+	 * WARNING: Do NOT modify this code. The content of this method is always
+	 * regenerated by the Form Editor.
+	 */
+	@SuppressWarnings("unchecked")
+	// <editor-fold defaultstate="collapsed" desc="Generated
+	// Code">//GEN-BEGIN:initComponents
+	private void initComponents() {
+
+		jTabbedPane1 = new javax.swing.JTabbedPane();
+		outlierSetupTab = new moa.gui.outliertab.OutlierSetupTab();
+		outlierVisualTab = new moa.gui.outliertab.OutlierVisualTab();
+
+		setLayout(new java.awt.BorderLayout());
+
+		jTabbedPane1.addMouseListener(new java.awt.event.MouseAdapter() {
+			@Override
+			public void mouseClicked(java.awt.event.MouseEvent evt) {
+				jTabbedPane1MouseClicked(evt);
+			}
+		});
+		jTabbedPane1.addFocusListener(new java.awt.event.FocusAdapter() {
+			@Override
+			public void focusGained(java.awt.event.FocusEvent evt) {
+				jTabbedPane1FocusGained(evt);
+			}
+		});
+		jTabbedPane1.addTab("Setup", outlierSetupTab);
+		jTabbedPane1.addTab("Visualization", outlierVisualTab);
+
+		add(jTabbedPane1, java.awt.BorderLayout.CENTER);
+	}// </editor-fold>//GEN-END:initComponents
+
+	private void jTabbedPane1FocusGained(java.awt.event.FocusEvent evt) {// GEN-FIRST:event_jTabbedPane1FocusGained
+
+	}// GEN-LAST:event_jTabbedPane1FocusGained
+
+	private void jTabbedPane1MouseClicked(java.awt.event.MouseEvent evt) {// GEN-FIRST:event_jTabbedPane1MouseClicked
+
+	}// GEN-LAST:event_jTabbedPane1MouseClicked
+
+	// Variables declaration - do not modify//GEN-BEGIN:variables
+	private moa.gui.outliertab.OutlierSetupTab outlierSetupTab;
+	private moa.gui.outliertab.OutlierVisualTab outlierVisualTab;
+	private javax.swing.JTabbedPane jTabbedPane1;
+	// End of variables declaration//GEN-END:variables
+
+	// returns the string to display as title of the tab
+	@Override
+	public String getTabTitle() {
+		return "Outliers";
+	}
+
+	// a short description (can be used as tool tip) of the tab, or contributor,
+	// etc.
+	@Override
+	public String getDescription() {
+		return "MOA Outliers";
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/outliertab/OutlierVisualEvalPanel.java b/moa/src/main/java/moa/gui/outliertab/OutlierVisualEvalPanel.java
index 24c410add..16aabbbb7 100644
--- a/moa/src/main/java/moa/gui/outliertab/OutlierVisualEvalPanel.java
+++ b/moa/src/main/java/moa/gui/outliertab/OutlierVisualEvalPanel.java
@@ -15,8 +15,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 package moa.gui.outliertab;
 
@@ -34,225 +34,223 @@
 
 import moa.evaluation.MeasureCollection;
 
-public class OutlierVisualEvalPanel extends javax.swing.JPanel{
-    private ArrayList<JLabel> names;
-    private ArrayList<JLabel> values;
-    private ArrayList<JRadioButton> radiobuttons;
-    private MeasureCollection[] measures0;
-    private ButtonGroup radioGroup;
-
-    private JLabel labelDummy;
-    private JLabel labelMeasure;
-    private JLabel labelCurrent0;
-    private JLabel labelMean0;
-
-    /** Creates new form OutlierEvalPanel */
-    public OutlierVisualEvalPanel() {
-        initComponents();
-        radioGroup = new ButtonGroup();
-    }
-
-
-    public void setMeasures(MeasureCollection[] measures0, ActionListener listener){
-        this.measures0 = measures0;
-
-        names = new ArrayList<JLabel>();
-        values = new ArrayList<JLabel>();
-        radiobuttons = new ArrayList<JRadioButton>();
-
-        for (int i = 0; i < measures0.length; i++) {
-            for (int j = 0; j < measures0[i].getNumMeasures(); j++) {
-                if(measures0[i].isEnabled(j)){
-                    names.add(new JLabel(measures0[i].getName(j)));
-
-                }
-            }
-        }
-        
-        setLayout(new java.awt.GridBagLayout());
-        GridBagConstraints gb;
-
-        //Radiobuttons
-        radioGroup = new ButtonGroup();
-        gb = new GridBagConstraints();
-        gb.gridx=0;
-        for (int i = 0; i < names.size(); i++) {
-            JRadioButton rb = new JRadioButton();
-            rb.setActionCommand(Integer.toString(i));
-            rb.addActionListener(listener);
-            radiobuttons.add(rb);
-
-            gb.gridy = i+1;
-            contentPanel.add(rb, gb);
-            radioGroup.add(rb);
-        }
-        radiobuttons.get(0).setSelected(true);
-
-        //name labels
-        gb = new GridBagConstraints();
-        gb.gridx=1;
-        for (int i = 0; i < names.size(); i++) {
-            names.get(i).setPreferredSize(new Dimension(40, 14));
-            gb.anchor = GridBagConstraints.WEST;
-            gb.insets = new java.awt.Insets(4, 7, 4, 7);
-            gb.gridy = i+1;
-            contentPanel.add(names.get(i), gb);
-        }
-
-        
-
-        int counter = 0;
-        for (int i = 0; i < measures0.length; i++) {
-            for (int j = 0; j < measures0[i].getNumMeasures(); j++) {
-                if(!measures0[i].isEnabled(j)) continue;
-                for (int k = 0; k < 4; k++) {
-                    String tooltip ="";
-                    Color color = Color.black;
-                    switch(k){
-                        case 0:
-                            tooltip = "current value";
-                            color = Color.red;
-                        break;
-                        case 1:
-                            tooltip = "current value";
-                            color = Color.blue;
-                        break;
-                        case 2:
-                            tooltip = "mean";
-                            color = Color.black;
-                        break;
-                        case 3:
-                            tooltip = "mean";
-                            color = Color.black;
-                        break;
-                    }
-                    JLabel l = new JLabel("-");
-                    l.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
-                    l.setPreferredSize(new java.awt.Dimension(50, 14));
-                    l.setToolTipText(measures0[i].getName(j)+" "+tooltip);
-                    l.setForeground(color);
-                    values.add(l);
-                    gb = new GridBagConstraints();
-                    gb.gridy = 1 + counter;
-                    gb.gridx = 2 + k;
-                    gb.weightx = 1.0;
-                    contentPanel.add(l, gb);
-                }
-                counter++;
-            }
-        }
-
-        //dummy label to align the labels at the top
-        gb = new GridBagConstraints();
-        gb.gridx = 0;
-        gb.gridy = names.size()+2;
-        gb.gridwidth = 6;
-        gb.weighty = 1.0;
-        JLabel fill = new JLabel();
-        contentPanel.add(fill, gb);
-
-        addLabels();
-
-        contentPanel.setPreferredSize(new Dimension(250, names.size()*(14+8)+20));
-    }
-
-    private void addLabels(){
-        labelMeasure = new javax.swing.JLabel("Measure");
-        labelCurrent0 = new JLabel("Current");
-        labelMean0 = new javax.swing.JLabel("Mean");
-        labelDummy = new javax.swing.JLabel();
-        GridBagConstraints gb = new GridBagConstraints();
-        gb.gridy = 0;
-
-        gb.gridx = 0;
-        contentPanel.add(labelDummy, gb);
-
-        gb.gridx = 1;
-        contentPanel.add(labelMeasure, gb);
-
-        gb = new GridBagConstraints();
-        gb.gridy = 0;
-        gb.gridx = 2;
-        gb.gridwidth = 2;
-        contentPanel.add(labelCurrent0, gb);
-
-
-        gb = new GridBagConstraints();
-        gb.gridy = 0;
-        gb.gridx=4;
-        gb.gridwidth = 2;
-        contentPanel.add(labelMean0, gb);
-
-    }
-
-    public void update(){
-        DecimalFormat d = new DecimalFormat("0.00");
-
-        if(measures0!=null){
-            int counter = 0;
-            for (MeasureCollection m : measures0) {
-                for (int i = 0; i < m.getNumMeasures(); i++) {
-                    if(!m.isEnabled(i)) continue;
-                    if(Double.isNaN(m.getLastValue(i)))
-                        values.get(counter*4).setText("-");
-                    else
-                        values.get(counter*4).setText(d.format(m.getLastValue(i)));
-
-                    if(Double.isNaN(m.getMean(i)))
-                        values.get(counter*4+2).setText("-");
-                    else
-                        values.get(counter*4+2).setText(d.format(m.getMean(i)));
-                    counter++;
-                }
-            }
-        }
-    }
-
-    @Override
-    //this is soooooo bad, but freaking gridbag somehow doesnt kick in...???
-    protected void paintComponent(Graphics g) {
-        scrollPane.setPreferredSize(new Dimension(getWidth()-20, getHeight()-30));
-        super.paintComponent(g);
-    }
-
-    /** This method is called from within the constructor to
-     * initialize the form.
-     * WARNING: Do NOT modify this code. The content of this method is
-     * always regenerated by the Form Editor.
-     */
-    @SuppressWarnings("unchecked")
-    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
-    private void initComponents() {
-        java.awt.GridBagConstraints gridBagConstraints;
-
-        scrollPane = new javax.swing.JScrollPane();
-        contentPanel = new javax.swing.JPanel();
-
-        setBorder(javax.swing.BorderFactory.createTitledBorder("Values"));
-        setPreferredSize(new java.awt.Dimension(250, 115));
-        setLayout(new java.awt.GridBagLayout());
-
-        scrollPane.setBorder(null);
-        scrollPane.setHorizontalScrollBarPolicy(javax.swing.ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
-        scrollPane.setPreferredSize(new java.awt.Dimension(270, 180));
-
-        contentPanel.setPreferredSize(new java.awt.Dimension(100, 105));
-        contentPanel.setLayout(new java.awt.GridBagLayout());
-        scrollPane.setViewportView(contentPanel);
-
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
-        gridBagConstraints.weightx = 1.0;
-        gridBagConstraints.weighty = 1.0;
-        add(scrollPane, gridBagConstraints);
-    }// </editor-fold>//GEN-END:initComponents
-
-
-    // Variables declaration - do not modify//GEN-BEGIN:variables
-    private javax.swing.JPanel contentPanel;
-    private javax.swing.JScrollPane scrollPane;
-    // End of variables declaration//GEN-END:variables
+public class OutlierVisualEvalPanel extends javax.swing.JPanel {
+	private ArrayList<JLabel> names;
+	private ArrayList<JLabel> values;
+	private ArrayList<JRadioButton> radiobuttons;
+	private MeasureCollection[] measures0;
+	private ButtonGroup radioGroup;
+
+	private JLabel labelDummy;
+	private JLabel labelMeasure;
+	private JLabel labelCurrent0;
+	private JLabel labelMean0;
+
+	/** Creates new form OutlierEvalPanel */
+	public OutlierVisualEvalPanel() {
+		initComponents();
+		radioGroup = new ButtonGroup();
+	}
+
+	public void setMeasures(MeasureCollection[] measures0, ActionListener listener) {
+		this.measures0 = measures0;
+
+		names = new ArrayList<>();
+		values = new ArrayList<>();
+		radiobuttons = new ArrayList<>();
+
+		for (int i = 0; i < measures0.length; i++) {
+			for (int j = 0; j < measures0[i].getNumMeasures(); j++) {
+				if (measures0[i].isEnabled(j)) {
+					names.add(new JLabel(measures0[i].getName(j)));
+
+				}
+			}
+		}
+
+		setLayout(new java.awt.GridBagLayout());
+		GridBagConstraints gb;
+
+		// Radiobuttons
+		radioGroup = new ButtonGroup();
+		gb = new GridBagConstraints();
+		gb.gridx = 0;
+		for (int i = 0; i < names.size(); i++) {
+			JRadioButton rb = new JRadioButton();
+			rb.setActionCommand(Integer.toString(i));
+			rb.addActionListener(listener);
+			radiobuttons.add(rb);
+
+			gb.gridy = i + 1;
+			contentPanel.add(rb, gb);
+			radioGroup.add(rb);
+		}
+		radiobuttons.get(0).setSelected(true);
+
+		// name labels
+		gb = new GridBagConstraints();
+		gb.gridx = 1;
+		for (int i = 0; i < names.size(); i++) {
+			names.get(i).setPreferredSize(new Dimension(40, 14));
+			gb.anchor = GridBagConstraints.WEST;
+			gb.insets = new java.awt.Insets(4, 7, 4, 7);
+			gb.gridy = i + 1;
+			contentPanel.add(names.get(i), gb);
+		}
+
+		int counter = 0;
+		for (int i = 0; i < measures0.length; i++) {
+			for (int j = 0; j < measures0[i].getNumMeasures(); j++) {
+				if (!measures0[i].isEnabled(j))
+					continue;
+				for (int k = 0; k < 4; k++) {
+					String tooltip = "";
+					Color color = Color.black;
+					switch (k) {
+					case 0:
+						tooltip = "current value";
+						color = Color.red;
+						break;
+					case 1:
+						tooltip = "current value";
+						color = Color.blue;
+						break;
+					case 2:
+						tooltip = "mean";
+						color = Color.black;
+						break;
+					case 3:
+						tooltip = "mean";
+						color = Color.black;
+						break;
+					}
+					JLabel l = new JLabel("-");
+					l.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
+					l.setPreferredSize(new java.awt.Dimension(50, 14));
+					l.setToolTipText(measures0[i].getName(j) + " " + tooltip);
+					l.setForeground(color);
+					values.add(l);
+					gb = new GridBagConstraints();
+					gb.gridy = 1 + counter;
+					gb.gridx = 2 + k;
+					gb.weightx = 1.0;
+					contentPanel.add(l, gb);
+				}
+				counter++;
+			}
+		}
+
+		// dummy label to align the labels at the top
+		gb = new GridBagConstraints();
+		gb.gridx = 0;
+		gb.gridy = names.size() + 2;
+		gb.gridwidth = 6;
+		gb.weighty = 1.0;
+		JLabel fill = new JLabel();
+		contentPanel.add(fill, gb);
+
+		addLabels();
+
+		contentPanel.setPreferredSize(new Dimension(250, names.size() * (14 + 8) + 20));
+	}
+
+	private void addLabels() {
+		labelMeasure = new javax.swing.JLabel("Measure");
+		labelCurrent0 = new JLabel("Current");
+		labelMean0 = new javax.swing.JLabel("Mean");
+		labelDummy = new javax.swing.JLabel();
+		GridBagConstraints gb = new GridBagConstraints();
+		gb.gridy = 0;
+
+		gb.gridx = 0;
+		contentPanel.add(labelDummy, gb);
+
+		gb.gridx = 1;
+		contentPanel.add(labelMeasure, gb);
+
+		gb = new GridBagConstraints();
+		gb.gridy = 0;
+		gb.gridx = 2;
+		gb.gridwidth = 2;
+		contentPanel.add(labelCurrent0, gb);
+
+		gb = new GridBagConstraints();
+		gb.gridy = 0;
+		gb.gridx = 4;
+		gb.gridwidth = 2;
+		contentPanel.add(labelMean0, gb);
+
+	}
+
+	public void update() {
+		DecimalFormat d = new DecimalFormat("0.00");
+
+		if (measures0 != null) {
+			int counter = 0;
+			for (MeasureCollection m : measures0) {
+				for (int i = 0; i < m.getNumMeasures(); i++) {
+					if (!m.isEnabled(i))
+						continue;
+					if (Double.isNaN(m.getLastValue(i)))
+						values.get(counter * 4).setText("-");
+					else
+						values.get(counter * 4).setText(d.format(m.getLastValue(i)));
+
+					if (Double.isNaN(m.getMean(i)))
+						values.get(counter * 4 + 2).setText("-");
+					else
+						values.get(counter * 4 + 2).setText(d.format(m.getMean(i)));
+					counter++;
+				}
+			}
+		}
+	}
+
+	@Override
+	// this is soooooo bad, but freaking gridbag somehow doesnt kick in...???
+	protected void paintComponent(Graphics g) {
+		scrollPane.setPreferredSize(new Dimension(getWidth() - 20, getHeight() - 30));
+		super.paintComponent(g);
+	}
+
+	/**
+	 * This method is called from within the constructor to initialize the form.
+	 * WARNING: Do NOT modify this code. The content of this method is always
+	 * regenerated by the Form Editor.
+	 */
+	@SuppressWarnings("unchecked")
+	// <editor-fold defaultstate="collapsed" desc="Generated
+	// Code">//GEN-BEGIN:initComponents
+	private void initComponents() {
+		java.awt.GridBagConstraints gridBagConstraints;
+
+		scrollPane = new javax.swing.JScrollPane();
+		contentPanel = new javax.swing.JPanel();
+
+		setBorder(javax.swing.BorderFactory.createTitledBorder("Values"));
+		setPreferredSize(new java.awt.Dimension(250, 115));
+		setLayout(new java.awt.GridBagLayout());
+
+		scrollPane.setBorder(null);
+		scrollPane.setHorizontalScrollBarPolicy(javax.swing.ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
+		scrollPane.setPreferredSize(new java.awt.Dimension(270, 180));
+
+		contentPanel.setPreferredSize(new java.awt.Dimension(100, 105));
+		contentPanel.setLayout(new java.awt.GridBagLayout());
+		scrollPane.setViewportView(contentPanel);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
+		gridBagConstraints.weightx = 1.0;
+		gridBagConstraints.weighty = 1.0;
+		add(scrollPane, gridBagConstraints);
+	}// </editor-fold>//GEN-END:initComponents
+
+	// Variables declaration - do not modify//GEN-BEGIN:variables
+	private javax.swing.JPanel contentPanel;
+	private javax.swing.JScrollPane scrollPane;
+	// End of variables declaration//GEN-END:variables
 
 }
diff --git a/moa/src/main/java/moa/gui/outliertab/OutlierVisualTab.java b/moa/src/main/java/moa/gui/outliertab/OutlierVisualTab.java
index 849a2474f..c382b20a1 100644
--- a/moa/src/main/java/moa/gui/outliertab/OutlierVisualTab.java
+++ b/moa/src/main/java/moa/gui/outliertab/OutlierVisualTab.java
@@ -15,8 +15,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.gui.outliertab;
@@ -31,6 +31,8 @@
 
 import javax.swing.JButton;
 import javax.swing.JComboBox;
+import javax.swing.JFileChooser;
+import javax.swing.SwingConstants;
 import javax.swing.ToolTipManager;
 
 import moa.gui.FileExtensionFilter;
@@ -39,835 +41,833 @@
 import moa.gui.visualization.StreamOutlierPanel;
 import nz.ac.waikato.cms.gui.core.BaseFileChooser;
 
-public class OutlierVisualTab extends javax.swing.JPanel implements ActionListener, ComponentListener{
-    private RunOutlierVisualizer visualizer = null;
-    private Thread visualizerThread = null;
-    private Boolean running = false;
-    private OutlierSetupTab outlierSetupTab = null;
-    private String exportFile;
-    private String screenshotFilebase;
-
-    /** Creates new form OutlierVisualTab */
-    public OutlierVisualTab() {
-        resetComponents();
-    }
-
-    private void resetComponents(){
-        initComponents();
-        comboY.setSelectedIndex(1);
-        graphCanvas.setViewport(graphScrollPanel.getViewport());
-
-        //TODO this needs to only affect the visual Panel
-        ToolTipManager.sharedInstance().setDismissDelay(20000);
-        ToolTipManager.sharedInstance().setInitialDelay(100);
-    }
-
-    public void setOutlierSetupTab(OutlierSetupTab outlierSetupTab){
-        this.outlierSetupTab = outlierSetupTab;
-    }
-
-
-    private void createVisualiterThread(){
-        visualizer = new RunOutlierVisualizer(this, outlierSetupTab);
-        visualizerThread = new Thread(visualizer);
-    }
-
-    public void setDimensionComobBoxes(int numDimensions){
-        String[] dimensions = new String[numDimensions];
-        for (int i = 0; i < dimensions.length; i++) {
-            dimensions[i] = "Dim "+(i+1);
-
-        }
-        comboX.setModel(new javax.swing.DefaultComboBoxModel(dimensions));
-        comboY.setModel(new javax.swing.DefaultComboBoxModel(dimensions));
-        comboY.setSelectedIndex(1);
-    }
-
-    public StreamOutlierPanel getLeftStreamPanel(){
-        return streamPanel0;
-    }
-
-    public StreamOutlierPanel getRightStreamPanel(){
-        return streamPanel1;
-    }
-
-    public GraphCanvas getGraphCanvas(){
-        return graphCanvas;
-    }
-
-    public OutlierVisualEvalPanel getEvalPanel(){
-        return null;
-    }
-
-    public boolean isEnabledDrawPoints(){
-        return checkboxDrawPoints.isSelected();
-    }
-    
-    public boolean isEnabledDrawOutliers(){
-        return checkboxDrawOutliers.isSelected();
-    }
-
-    public void setProcessedPointsCounter(int value){
-        label_processed_points_value.setText(Integer.toString(value));
-    }
-
-    public int getPauseInterval(){
-        return Integer.parseInt(numPauseAfterPoints.getText());
-    }
-
-    public void setPauseInterval(int pause){
-        numPauseAfterPoints.setText(Integer.toString(pause));
-    }
-    
-    private void UpdateSplitVisualDivider() {
-        if(splitVisual != null)
-            splitVisual.setDividerLocation(splitVisual.getWidth()/2);
-    }
-
-    @Override
-    public void repaint() {                
-        super.repaint();
-        UpdateSplitVisualDivider();
-    }
-    
-    @Override
-    public void componentResized(ComponentEvent ce) {
-    }
-
-    @Override
-    public void componentMoved(ComponentEvent ce) {
-    }
-
-    @Override
-    public void componentShown(ComponentEvent ce) {
-    }
-
-    @Override
-    public void componentHidden(ComponentEvent ce) {
-    }
-
-    public void toggleVisualizer(boolean internal){
-        if(visualizer == null)
-            createVisualiterThread();
-        
-        if(!visualizerThread.isAlive()){
-            visualizerThread.start();
-        }        
-        
-        //pause
-        if(running){
-            running = false;
-            visualizer.pause();
-            buttonRun.setText("Resume");
-        }
-        else{
-            running = true;
-            visualizer.resume();
-            buttonRun.setText("Pause");
-        }
-        if(internal)
-            outlierSetupTab.toggleRunMode();        
-    }
-
-    public void stopVisualizer(){
-        if (visualizer == null) return;
-        
-        visualizer.stop();
-        running = false;
-        visualizer = null;
-        visualizerThread = null;
-        removeAll();
-        resetComponents();
-    }
-
-
-    /** This method is called from within the constructor to
-     * initialize the form.
-     * WARNING: Do NOT modify this code. The content of this method is
-     * always regenerated by the Form Editor.
-     */
-    @SuppressWarnings("unchecked")
-    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
-    private void initComponents() {
-        java.awt.GridBagConstraints gridBagConstraints;
-
-        jSplitPane1 = new javax.swing.JSplitPane();
-        topWrapper = new javax.swing.JPanel();
-        panelVisualWrapper = new javax.swing.JPanel();
-        splitVisual = new javax.swing.JSplitPane();
-        scrollPane1 = new javax.swing.JScrollPane();
-        scrollPane0 = new javax.swing.JScrollPane();
-        streamPanel0 = new moa.gui.visualization.StreamOutlierPanel(Color.RED);
-        streamPanel1 = new moa.gui.visualization.StreamOutlierPanel(Color.BLUE);
-        panelControl = new javax.swing.JPanel();
-        buttonRun = new javax.swing.JButton();
-        buttonStop = new javax.swing.JButton();
-        buttonRedraw = new javax.swing.JButton();
-        buttonScreenshot = new javax.swing.JButton();
-        speedSlider = new javax.swing.JSlider();
-        jLabel1 = new javax.swing.JLabel();
-        comboX = new javax.swing.JComboBox();
-        labelX = new javax.swing.JLabel();
-        comboY = new javax.swing.JComboBox();
-        labelY = new javax.swing.JLabel();
-        checkboxDrawPoints = new javax.swing.JCheckBox();
-        checkboxDrawOutliers = new javax.swing.JCheckBox();
-        checkboxWaitWinFull = new javax.swing.JCheckBox();
-        label_processed_points = new javax.swing.JLabel();
-        label_processed_points_value = new javax.swing.JLabel();
-        labelNumPause = new javax.swing.JLabel();
-        numPauseAfterPoints = new javax.swing.JTextField();
-        panelEvalOutput = new javax.swing.JPanel();
-        // outlierVisualEvalPanel1 = new moa.gui.outliertab.OutlierVisualEvalPanel();
-        graphPanel = new javax.swing.JPanel();
-        graphPanelControlTop = new javax.swing.JPanel();
-        buttonZoomInY = new javax.swing.JButton();
-        buttonZoomOutY = new javax.swing.JButton();
-        labelEvents = new javax.swing.JLabel();
-        graphScrollPanel = new javax.swing.JScrollPane();
-        graphCanvas = new moa.gui.visualization.GraphCanvas();
-        graphPanelControlBottom = new javax.swing.JPanel();
-        buttonZoomInX = new javax.swing.JButton();
-        buttonZoomOutX = new javax.swing.JButton();
-
-        setLayout(new java.awt.GridBagLayout());
-
-        jSplitPane1.setDividerLocation(400);
-        jSplitPane1.setOrientation(javax.swing.JSplitPane.VERTICAL_SPLIT);
-
-        topWrapper.setPreferredSize(new java.awt.Dimension(688, 500));
-        topWrapper.setLayout(new java.awt.GridBagLayout());
-
-        //panelVisualWrapper.setBorder(javax.swing.BorderFactory.createBevelBorder(javax.swing.border.BevelBorder.RAISED));
-        panelVisualWrapper.setLayout(new java.awt.BorderLayout());
-
-        splitVisual.setDividerLocation(400);
-        splitVisual.setResizeWeight(1.0);
-        
-        scrollPane0.addMouseWheelListener(new java.awt.event.MouseWheelListener() {
-            public void mouseWheelMoved(java.awt.event.MouseWheelEvent evt) {
-                scrollPane0MouseWheelMoved(evt);
-            }
-        });
-        
-        streamPanel1.setPreferredSize(new java.awt.Dimension(400, 250));
-
-        javax.swing.GroupLayout streamPanel1Layout = new javax.swing.GroupLayout(streamPanel1);
-        streamPanel1.setLayout(streamPanel1Layout);
-        streamPanel1Layout.setHorizontalGroup(
-            streamPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 428, Short.MAX_VALUE)
-        );
-        streamPanel1Layout.setVerticalGroup(
-            streamPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 339, Short.MAX_VALUE)
-        );
-
-        scrollPane1.setViewportView(streamPanel1);
-        
-        splitVisual.setRightComponent(scrollPane1);
-
-        scrollPane0.addMouseWheelListener(new java.awt.event.MouseWheelListener() {
-            public void mouseWheelMoved(java.awt.event.MouseWheelEvent evt) {
-                scrollPane0MouseWheelMoved(evt);
-            }
-        });
-
-        streamPanel0.setPreferredSize(new java.awt.Dimension(400, 250));
-
-        javax.swing.GroupLayout streamPanel0Layout = new javax.swing.GroupLayout(streamPanel0);
-        streamPanel0.setLayout(streamPanel0Layout);
-        streamPanel0Layout.setHorizontalGroup(
-            streamPanel0Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 400, Short.MAX_VALUE)
-        );
-        streamPanel0Layout.setVerticalGroup(
-            streamPanel0Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 339, Short.MAX_VALUE)
-        );
-
-        scrollPane0.setViewportView(streamPanel0);
-        
-        splitVisual.setLeftComponent(scrollPane0);
-        
-        splitVisual.addComponentListener(new ComponentListener() {
-            @Override
-            public void componentResized(ComponentEvent ce) {
-                UpdateSplitVisualDivider();
-            }
-
-            @Override
-            public void componentMoved(ComponentEvent ce) {
-            }
-
-            @Override
-            public void componentShown(ComponentEvent ce) {
-            }
-
-            @Override
-            public void componentHidden(ComponentEvent ce) {
-            }
-        });
-
-        panelVisualWrapper.add(splitVisual, java.awt.BorderLayout.CENTER);
-
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 1;
-        gridBagConstraints.gridheight = java.awt.GridBagConstraints.RELATIVE;
-        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
-        gridBagConstraints.ipadx = 400;
-        gridBagConstraints.ipady = 200;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
-        gridBagConstraints.weightx = 1.0;
-        gridBagConstraints.weighty = 1.0;
-        topWrapper.add(panelVisualWrapper, gridBagConstraints);
-
-        panelControl.setMinimumSize(new java.awt.Dimension(600, 76));
-        panelControl.setPreferredSize(new java.awt.Dimension(2000, 76));
-        panelControl.setLayout(new java.awt.GridBagLayout());
-        
-        int iBtnHeight = 27;
-        int iInsetW = 2;
-        int iInsetH = 2;
-
-        buttonRun.setText("Start");
-        buttonRun.setMinimumSize(new java.awt.Dimension(90, iBtnHeight));
-        buttonRun.setPreferredSize(new java.awt.Dimension(90, iBtnHeight));
-        buttonRun.addMouseListener(new java.awt.event.MouseAdapter() {
-            @Override
-            public void mouseClicked(java.awt.event.MouseEvent evt) {
-                buttonRunMouseClicked(evt);
-            }
-        });
-        buttonRun.addActionListener(new java.awt.event.ActionListener() {
-            @Override
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonRunActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.insets = new java.awt.Insets(iInsetW, iInsetH, iInsetW, iInsetH);
-        panelControl.add(buttonRun, gridBagConstraints);
-
-        buttonStop.setText("Stop");
-        buttonStop.setMinimumSize(new java.awt.Dimension(90, iBtnHeight));
-        buttonStop.setPreferredSize(new java.awt.Dimension(90, iBtnHeight));
-        buttonStop.addActionListener(new java.awt.event.ActionListener() {
-            @Override
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonStopActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 1;
-        gridBagConstraints.insets = new java.awt.Insets(iInsetW, iInsetH, iInsetW, iInsetH);
-        panelControl.add(buttonStop, gridBagConstraints);
-        
-        buttonRedraw.setText("Redraw");
-        buttonRedraw.setMinimumSize(new java.awt.Dimension(100, iBtnHeight));
-        buttonRedraw.setPreferredSize(new java.awt.Dimension(100, iBtnHeight));
-        buttonRedraw.addMouseListener(new java.awt.event.MouseAdapter() {
-            @Override
-            public void mouseClicked(java.awt.event.MouseEvent evt) {
-                buttonRedrawMouseClicked(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 1;
-        gridBagConstraints.gridy = 1;
-        gridBagConstraints.insets = new java.awt.Insets(iInsetW, iInsetH, iInsetW, iInsetH);
-        panelControl.add(buttonRedraw, gridBagConstraints);
-
-        buttonScreenshot.setText("Screenshot");
-        buttonScreenshot.setMinimumSize(new java.awt.Dimension(100, iBtnHeight));
-        buttonScreenshot.setPreferredSize(new java.awt.Dimension(100, iBtnHeight));
-        buttonScreenshot.addMouseListener(new java.awt.event.MouseAdapter() {
-            @Override
-            public void mouseClicked(java.awt.event.MouseEvent evt) {
-                buttonScreenshotMouseClicked(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 1;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.insets = new java.awt.Insets(iInsetW, iInsetH, iInsetW, iInsetH);
-        panelControl.add(buttonScreenshot, gridBagConstraints);
-
-        speedSlider.setValue(100);
-        speedSlider.setBorder(javax.swing.BorderFactory.createTitledBorder("Visualisation Speed"));
-        speedSlider.setMinimumSize(new java.awt.Dimension(160, 68));
-        speedSlider.setPreferredSize(new java.awt.Dimension(170, 68));
-        speedSlider.addMouseMotionListener(new java.awt.event.MouseMotionAdapter() {
-            @Override
-            public void mouseDragged(java.awt.event.MouseEvent evt) {
-                speedSliderMouseDragged(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 6;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.gridheight = 2;
-        gridBagConstraints.insets = new java.awt.Insets(0, 16, 1, 5);
-        panelControl.add(speedSlider, gridBagConstraints);
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 9;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.gridheight = 2;
-        gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
-        gridBagConstraints.weightx = 1.0;
-        panelControl.add(jLabel1, gridBagConstraints);        
-
-        comboX.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "Dim 1", "Dim 2", "Dim 3", "Dim 4" }));
-        comboX.addActionListener(new java.awt.event.ActionListener() {
-            @Override
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                comboXActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 3;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.insets = new java.awt.Insets(0, 4, 0, 4);
-        panelControl.add(comboX, gridBagConstraints);
-
-        labelX.setText("X");
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 2;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.insets = new java.awt.Insets(0, 14, 0, 5);
-        panelControl.add(labelX, gridBagConstraints);
-
-        comboY.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "Dim 1", "Dim 2", "Dim 3", "Dim 4" }));
-        comboY.addActionListener(new java.awt.event.ActionListener() {
-            @Override
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                comboYActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 3;
-        gridBagConstraints.gridy = 1;
-        gridBagConstraints.insets = new java.awt.Insets(0, 4, 0, 4);
-        panelControl.add(comboY, gridBagConstraints);
-
-        labelY.setText("Y");
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 2;
-        gridBagConstraints.gridy = 1;
-        gridBagConstraints.insets = new java.awt.Insets(0, 14, 0, 5);
-        panelControl.add(labelY, gridBagConstraints);
-
-        checkboxDrawPoints.setSelected(true);
-        checkboxDrawPoints.setText("Points");
-        checkboxDrawPoints.setMargin(new java.awt.Insets(0, 0, 0, 0));
-        checkboxDrawPoints.addActionListener(new java.awt.event.ActionListener() {
-            @Override
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                checkboxDrawPointsActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 4;
-        gridBagConstraints.gridy = 0;   
-        gridBagConstraints.gridwidth = 1;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.SOUTHWEST;
-        gridBagConstraints.insets = new java.awt.Insets(0, 4, 0, 4);
-        panelControl.add(checkboxDrawPoints, gridBagConstraints);
-
-        checkboxDrawOutliers.setSelected(true);
-        checkboxDrawOutliers.setText("Outliers");
-        checkboxDrawOutliers.setMargin(new java.awt.Insets(0, 0, 0, 0));
-        checkboxDrawOutliers.addActionListener(new java.awt.event.ActionListener() {
-            @Override
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                checkboxDrawOutlierActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 4;
-        gridBagConstraints.gridy = 1;        
-        gridBagConstraints.gridwidth = 1;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
-        gridBagConstraints.insets = new java.awt.Insets(0, 4, 0, 4);
-        panelControl.add(checkboxDrawOutliers, gridBagConstraints);
-        
-        checkboxWaitWinFull.setSelected(true);
-        checkboxWaitWinFull.setText("WaitWinFull");
-        checkboxWaitWinFull.setMargin(new java.awt.Insets(0, 0, 0, 0));
-        checkboxWaitWinFull.addActionListener(new java.awt.event.ActionListener() {
-            @Override
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                checkboxWaitWinFullActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 5;
-        gridBagConstraints.gridy = 0;        
-        gridBagConstraints.gridwidth = 1;
-        gridBagConstraints.gridheight = 2;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.CENTER;
-        gridBagConstraints.insets = new java.awt.Insets(0, 0, 0, 0);
-        panelControl.add(checkboxWaitWinFull, gridBagConstraints);
-
-        label_processed_points.setText("Processed:");
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 7;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
-        gridBagConstraints.insets = new java.awt.Insets(0, 6, 0, 0);
-        panelControl.add(label_processed_points, gridBagConstraints);
-
-        label_processed_points_value.setText("0");
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 8;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
-        gridBagConstraints.weightx = 1.0;
-        panelControl.add(label_processed_points_value, gridBagConstraints);
-
-        labelNumPause.setText("Pause in:");
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 7;
-        gridBagConstraints.gridy = 1;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
-        gridBagConstraints.insets = new java.awt.Insets(0, 6, 0, 0);
-        panelControl.add(labelNumPause, gridBagConstraints);
-
-        numPauseAfterPoints.setHorizontalAlignment(javax.swing.JTextField.RIGHT);
-        numPauseAfterPoints.setText(Integer.toString(RunOutlierVisualizer.initialPauseInterval));
-        numPauseAfterPoints.setMinimumSize(new java.awt.Dimension(70, 25));
-        numPauseAfterPoints.setPreferredSize(new java.awt.Dimension(70, 25));
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 8;
-        gridBagConstraints.gridy = 1;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
-        panelControl.add(numPauseAfterPoints, gridBagConstraints);
-        
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
-        gridBagConstraints.weightx = 1.0;
-        topWrapper.add(panelControl, gridBagConstraints);
-
-        jSplitPane1.setLeftComponent(topWrapper);
-
-        panelEvalOutput.setBorder(javax.swing.BorderFactory.createTitledBorder("Evaluation"));
-        panelEvalOutput.setLayout(new java.awt.GridBagLayout());
-
-        graphPanel.setBorder(javax.swing.BorderFactory.createTitledBorder("Process time per object"));
-        graphPanel.setPreferredSize(new java.awt.Dimension(530, 115));
-        graphPanel.setLayout(new java.awt.GridBagLayout());
-
-        graphPanelControlTop.setLayout(new java.awt.GridBagLayout());
-
-        buttonZoomInY.setText("Zoom in Y");
-        buttonZoomInY.addActionListener(new java.awt.event.ActionListener() {
-            @Override
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonZoomInYActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
-        graphPanelControlTop.add(buttonZoomInY, gridBagConstraints);
-
-        buttonZoomOutY.setText("Zoom out Y");
-        buttonZoomOutY.addActionListener(new java.awt.event.ActionListener() {
-            @Override
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonZoomOutYActionPerformed(evt);
-            }
-        });
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
-        graphPanelControlTop.add(buttonZoomOutY, gridBagConstraints);
-
-        labelEvents.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
-        gridBagConstraints.weightx = 1.0;
-        gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
-        graphPanelControlTop.add(labelEvents, gridBagConstraints);
-
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
-        gridBagConstraints.weightx = 1.0;
-        graphPanel.add(graphPanelControlTop, gridBagConstraints);
-
-        graphCanvas.setPreferredSize(new java.awt.Dimension(500, 111));
-        
-        javax.swing.GroupLayout graphCanvasLayout = new javax.swing.GroupLayout(graphCanvas);
-        graphCanvas.setLayout(graphCanvasLayout);
-        graphCanvasLayout.setHorizontalGroup(
-            graphCanvasLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 515, Short.MAX_VALUE)
-        );
-        graphCanvasLayout.setVerticalGroup(
-            graphCanvasLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 128, Short.MAX_VALUE)
-        );
-
-        graphScrollPanel.setViewportView(graphCanvas);
-
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 0;
-        gridBagConstraints.gridy = 1;
-        gridBagConstraints.gridwidth = 2;
-        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
-        gridBagConstraints.weightx = 1.0;
-        gridBagConstraints.weighty = 1.0;
-        gridBagConstraints.insets = new java.awt.Insets(2, 2, 2, 2);
-        graphPanel.add(graphScrollPanel, gridBagConstraints);
-
-        buttonZoomInX.setText("Zoom in X");
-        buttonZoomInX.addActionListener(new java.awt.event.ActionListener() {
-            @Override
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonZoomInXActionPerformed(evt);
-            }
-        });
-        graphPanelControlBottom.add(buttonZoomInX);
-
-        buttonZoomOutX.setText("Zoom out X");
-        buttonZoomOutX.addActionListener(new java.awt.event.ActionListener() {
-            @Override
-            public void actionPerformed(java.awt.event.ActionEvent evt) {
-                buttonZoomOutXActionPerformed(evt);
-            }
-        });
-        graphPanelControlBottom.add(buttonZoomOutX);
-
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.gridx = 1;
-        gridBagConstraints.gridy = 0;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
-        graphPanel.add(graphPanelControlBottom, gridBagConstraints);
-
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
-        gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
-        gridBagConstraints.weightx = 2.0;
-        gridBagConstraints.weighty = 1.0;
-        panelEvalOutput.add(graphPanel, gridBagConstraints);
-        panelEvalOutput.addComponentListener(new ComponentListener() {
-            @Override
-            public void componentResized(ComponentEvent ce) {
-                //System.out.println("panelEvalOutput componentResized");
-                graphCanvas.updateCanvas(true);
-            }
-
-            @Override
-            public void componentMoved(ComponentEvent ce) {
-            }
-
-            @Override
-            public void componentShown(ComponentEvent ce) {
-            }
-
-            @Override
-            public void componentHidden(ComponentEvent ce) {
-            }
-        });
-
-        jSplitPane1.setRightComponent(panelEvalOutput);
-
-        gridBagConstraints = new java.awt.GridBagConstraints();
-        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
-        gridBagConstraints.weightx = 1.0;
-        gridBagConstraints.weighty = 1.0;
-        add(jSplitPane1, gridBagConstraints);
-        //add(topWrapper, gridBagConstraints);
-    }// </editor-fold>//GEN-END:initComponents
-
-    private void buttonRedrawMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_buttonRedrawMouseClicked
-        if (visualizer != null) 
-            visualizer.redraw();
-    }//GEN-LAST:event_buttonScreenshotMouseClicked
-
-    private void buttonScreenshotMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_buttonScreenshotMouseClicked
-        BaseFileChooser fileChooser = new BaseFileChooser();
-        fileChooser.setAcceptAllFileFilterUsed(true);
-        if(screenshotFilebase!=null)
-            fileChooser.setSelectedFile(new File(screenshotFilebase));
-        if (fileChooser.showSaveDialog(this) == BaseFileChooser.APPROVE_OPTION) {
-        	screenshotFilebase = fileChooser.getSelectedFile().getPath();
-        	streamPanel0.screenshot(screenshotFilebase+"_"+label_processed_points_value.getText()+"_0", true, true);
-        }
-    }//GEN-LAST:event_buttonScreenshotMouseClicked
-
-    private void buttonRunMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_buttonRunMouseClicked
-        toggleVisualizer(true);
-    }//GEN-LAST:event_buttonRunMouseClicked
-
-    private void speedSliderMouseDragged(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_speedSliderMouseDragged
-        if (speedSlider == null) return;
-        if (visualizer == null)  return;
-        
-        visualizer.setSpeed(speedSlider.getValue());
-
-    }//GEN-LAST:event_speedSliderMouseDragged
-    
-    public int GetSpeed() {
-        return speedSlider.getValue();
-    }
-
-    private void scrollPane0MouseWheelMoved(java.awt.event.MouseWheelEvent evt) {//GEN-FIRST:event_scrollPane0MouseWheelMoved
-        streamPanel0.setZoom(evt.getX(),evt.getY(),(-1)*evt.getWheelRotation(),scrollPane0);
-    }//GEN-LAST:event_scrollPane0MouseWheelMoved
-
-    private void buttonZoomInXActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonZoomInXActionPerformed
-        graphCanvas.scaleXResolution(false);
-        graphCanvas.updateCanvas(true);
-    }//GEN-LAST:event_buttonZoomInXActionPerformed
-
-    private void buttonZoomOutYActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonZoomOutYActionPerformed
-        graphCanvas.setSize(new Dimension(graphCanvas.getWidth(), (int)(graphCanvas.getHeight()*0.8)));
-        graphCanvas.setPreferredSize(new Dimension(graphCanvas.getWidth(), (int)(graphCanvas.getHeight()*0.8)));
-        graphCanvas.updateCanvas(true);
-    }//GEN-LAST:event_buttonZoomOutYActionPerformed
-
-    private void buttonZoomOutXActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonZoomOutXActionPerformed
-        graphCanvas.scaleXResolution(true);
-        graphCanvas.updateCanvas(true);
-    }//GEN-LAST:event_buttonZoomOutXActionPerformed
-
-    private void buttonZoomInYActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonZoomInYActionPerformed
-        graphCanvas.setSize(new Dimension(graphCanvas.getWidth(), (int)(graphCanvas.getHeight()*1.2)));
-        graphCanvas.setPreferredSize(new Dimension(graphCanvas.getWidth(), (int)(graphCanvas.getHeight()*1.2)));
-        graphCanvas.updateCanvas(true);
-    }//GEN-LAST:event_buttonZoomInYActionPerformed
-
-    public boolean getPointVisibility() {
-        return checkboxDrawPoints.isSelected();
-    }
-    
-    public boolean getOutliersVisibility() {
-        return checkboxDrawOutliers.isSelected();
-    }
-    
-    private void checkboxDrawPointsActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_checkboxDrawPointsActionPerformed
-        if (visualizer == null) return;
-        visualizer.setPointsVisibility(checkboxDrawPoints.isSelected());
-    }//GEN-LAST:event_checkboxDrawPointsActionPerformed
-
-    private void checkboxDrawOutlierActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_checkboxDrawOutlierActionPerformed
-        if (visualizer == null) return;
-        
-        if (running) {
-            // outliers layer is hidden when running
-            return;
-        }
-        // visualizer.redrawOutliers();
-        visualizer.setOutliersVisibility(checkboxDrawOutliers.isSelected());
-    }//GEN-LAST:event_checkboxDrawOutlierActionPerformed
-    
-    public boolean getWaitWinFull() {
-        return checkboxWaitWinFull.isSelected();
-    }
-
-    private void checkboxWaitWinFullActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_checkboxWaitWinFullActionPerformed
-        if (visualizer == null) return;        
-        visualizer.setWaitWinFull(checkboxWaitWinFull.isSelected());
-    }//GEN-LAST:checkboxWaitWinFullActionPerformed
-            
-    private void comboXActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_comboXActionPerformed
-        if (visualizer == null) return;
-        JComboBox cb = (JComboBox)evt.getSource();
-        int dim = cb.getSelectedIndex();
-        streamPanel0.setActiveXDim(dim);
-        streamPanel1.setActiveXDim(dim);
-        if(visualizer!=null)
-            visualizer.redraw();
-    }//GEN-LAST:event_comboXActionPerformed
-
-    private void comboYActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_comboYActionPerformed
-        if (visualizer == null) return;
-        JComboBox cb = (JComboBox)evt.getSource();
-        int dim = cb.getSelectedIndex();
-        streamPanel0.setActiveYDim(dim);
-        streamPanel1.setActiveYDim(dim);
-        if(visualizer!=null)
-            visualizer.redraw();
-    }//GEN-LAST:event_comboYActionPerformed
-
-    private void buttonStopActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonStopActionPerformed
-        stopVisualizer();
-        outlierSetupTab.stopRun();
-    }//GEN-LAST:event_buttonStopActionPerformed
-
-    private void buttonRunActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_buttonRunActionPerformed
-        // TODO add your handling code here:
-    }//GEN-LAST:event_buttonRunActionPerformed
-
-
-    // Variables declaration - do not modify//GEN-BEGIN:variables
-    private javax.swing.JButton buttonRun;
-    private javax.swing.JButton buttonScreenshot;
-    private javax.swing.JButton buttonRedraw;
-    private javax.swing.JButton buttonStop;
-    private javax.swing.JButton buttonZoomInX;
-    private javax.swing.JButton buttonZoomInY;
-    private javax.swing.JButton buttonZoomOutX;
-    private javax.swing.JButton buttonZoomOutY;
-    private javax.swing.JCheckBox checkboxDrawOutliers;
-    private javax.swing.JCheckBox checkboxDrawPoints;
-    private javax.swing.JCheckBox checkboxWaitWinFull;
-    // ### private moa.gui.outliertab.OutlierVisualEvalPanel outlierVisualEvalPanel1;
-    private javax.swing.JComboBox comboX;
-    private javax.swing.JComboBox comboY;
-    private moa.gui.visualization.GraphCanvas graphCanvas;
-    private javax.swing.JPanel graphPanel;
-    private javax.swing.JPanel graphPanelControlBottom;
-    private javax.swing.JPanel graphPanelControlTop;
-    private javax.swing.JScrollPane graphScrollPanel;
-    private javax.swing.JLabel jLabel1;
-    private javax.swing.JSplitPane jSplitPane1;
-    private javax.swing.JLabel labelEvents;
-    private javax.swing.JLabel labelNumPause;
-    private javax.swing.JLabel labelX;
-    private javax.swing.JLabel labelY;
-    private javax.swing.JLabel label_processed_points;
-    private javax.swing.JLabel label_processed_points_value;
-    private javax.swing.JTextField numPauseAfterPoints;
-    private javax.swing.JPanel panelControl;
-    private javax.swing.JPanel panelEvalOutput;
-    private javax.swing.JPanel panelVisualWrapper;
-    private javax.swing.JScrollPane scrollPane0;
-    private javax.swing.JScrollPane scrollPane1;
-    private javax.swing.JSlider speedSlider;
-    private javax.swing.JSplitPane splitVisual;
-    private moa.gui.visualization.StreamOutlierPanel streamPanel0;
-    private moa.gui.visualization.StreamOutlierPanel streamPanel1;
-    private javax.swing.JPanel topWrapper;
-    // End of variables declaration//GEN-END:variables
-
-    @Override
-    public void actionPerformed(ActionEvent e) {
-        if (visualizer == null) return;
-        if(e.getSource() instanceof JButton){
-            if(e.getActionCommand().equals("csv export")){
-                BaseFileChooser fileChooser = new BaseFileChooser();
-                fileChooser.setAcceptAllFileFilterUsed(true);
-                fileChooser.addChoosableFileFilter(new FileExtensionFilter("csv"));
-                if(exportFile!=null)
-                    fileChooser.setSelectedFile(new File(exportFile));
-                if (fileChooser.showSaveDialog(this) == BaseFileChooser.APPROVE_OPTION) {
-                    exportFile = fileChooser.getSelectedFile().getPath();
-                    visualizer.exportCSV(exportFile);
-                }
-            }
-            if(e.getActionCommand().equals("weka export")){
-                visualizer.weka();
-            }
-        }
-    }
+public class OutlierVisualTab extends javax.swing.JPanel implements ActionListener, ComponentListener {
+	private RunOutlierVisualizer visualizer = null;
+	private Thread visualizerThread = null;
+	private Boolean running = false;
+	private OutlierSetupTab outlierSetupTab = null;
+	private String exportFile;
+	private String screenshotFilebase;
+
+	/** Creates new form OutlierVisualTab */
+	public OutlierVisualTab() {
+		resetComponents();
+	}
+
+	private void resetComponents() {
+		initComponents();
+		comboY.setSelectedIndex(1);
+		graphCanvas.setViewport(graphScrollPanel.getViewport());
+
+		// TODO this needs to only affect the visual Panel
+		ToolTipManager.sharedInstance().setDismissDelay(20000);
+		ToolTipManager.sharedInstance().setInitialDelay(100);
+	}
+
+	public void setOutlierSetupTab(OutlierSetupTab outlierSetupTab) {
+		this.outlierSetupTab = outlierSetupTab;
+	}
+
+	private void createVisualiterThread() {
+		visualizer = new RunOutlierVisualizer(this, outlierSetupTab);
+		visualizerThread = new Thread(visualizer);
+	}
+
+	public void setDimensionComobBoxes(int numDimensions) {
+		String[] dimensions = new String[numDimensions];
+		for (int i = 0; i < dimensions.length; i++) {
+			dimensions[i] = "Dim " + (i + 1);
+
+		}
+		comboX.setModel(new javax.swing.DefaultComboBoxModel(dimensions));
+		comboY.setModel(new javax.swing.DefaultComboBoxModel(dimensions));
+		comboY.setSelectedIndex(1);
+	}
+
+	public StreamOutlierPanel getLeftStreamPanel() {
+		return streamPanel0;
+	}
+
+	public StreamOutlierPanel getRightStreamPanel() {
+		return streamPanel1;
+	}
+
+	public GraphCanvas getGraphCanvas() {
+		return graphCanvas;
+	}
+
+	public OutlierVisualEvalPanel getEvalPanel() {
+		return null;
+	}
+
+	public boolean isEnabledDrawPoints() {
+		return checkboxDrawPoints.isSelected();
+	}
+
+	public boolean isEnabledDrawOutliers() {
+		return checkboxDrawOutliers.isSelected();
+	}
+
+	public void setProcessedPointsCounter(int value) {
+		label_processed_points_value.setText(Integer.toString(value));
+	}
+
+	public int getPauseInterval() {
+		return Integer.parseInt(numPauseAfterPoints.getText());
+	}
+
+	public void setPauseInterval(int pause) {
+		numPauseAfterPoints.setText(Integer.toString(pause));
+	}
+
+	private void UpdateSplitVisualDivider() {
+		if (splitVisual != null)
+			splitVisual.setDividerLocation(splitVisual.getWidth() / 2);
+	}
+
+	@Override
+	public void repaint() {
+		super.repaint();
+		UpdateSplitVisualDivider();
+	}
+
+	@Override
+	public void componentResized(ComponentEvent ce) {
+	}
+
+	@Override
+	public void componentMoved(ComponentEvent ce) {
+	}
+
+	@Override
+	public void componentShown(ComponentEvent ce) {
+	}
+
+	@Override
+	public void componentHidden(ComponentEvent ce) {
+	}
+
+	public void toggleVisualizer(boolean internal) {
+		if (visualizer == null)
+			createVisualiterThread();
+
+		if (!visualizerThread.isAlive()) {
+			visualizerThread.start();
+		}
+
+		// pause
+		if (running) {
+			running = false;
+			RunOutlierVisualizer.pause();
+			buttonRun.setText("Resume");
+		} else {
+			running = true;
+			RunOutlierVisualizer.resume();
+			buttonRun.setText("Pause");
+		}
+		if (internal)
+			outlierSetupTab.toggleRunMode();
+	}
+
+	public void stopVisualizer() {
+		if (visualizer == null)
+			return;
+
+		visualizer.stop();
+		running = false;
+		visualizer = null;
+		visualizerThread = null;
+		removeAll();
+		resetComponents();
+	}
+
+	/**
+	 * This method is called from within the constructor to initialize the form.
+	 * WARNING: Do NOT modify this code. The content of this method is always
+	 * regenerated by the Form Editor.
+	 */
+	@SuppressWarnings("unchecked")
+	// <editor-fold defaultstate="collapsed" desc="Generated
+	// Code">//GEN-BEGIN:initComponents
+	private void initComponents() {
+		java.awt.GridBagConstraints gridBagConstraints;
+
+		jSplitPane1 = new javax.swing.JSplitPane();
+		topWrapper = new javax.swing.JPanel();
+		panelVisualWrapper = new javax.swing.JPanel();
+		splitVisual = new javax.swing.JSplitPane();
+		scrollPane1 = new javax.swing.JScrollPane();
+		scrollPane0 = new javax.swing.JScrollPane();
+		streamPanel0 = new moa.gui.visualization.StreamOutlierPanel(Color.RED);
+		streamPanel1 = new moa.gui.visualization.StreamOutlierPanel(Color.BLUE);
+		panelControl = new javax.swing.JPanel();
+		buttonRun = new javax.swing.JButton();
+		buttonStop = new javax.swing.JButton();
+		buttonRedraw = new javax.swing.JButton();
+		buttonScreenshot = new javax.swing.JButton();
+		speedSlider = new javax.swing.JSlider();
+		jLabel1 = new javax.swing.JLabel();
+		comboX = new javax.swing.JComboBox();
+		labelX = new javax.swing.JLabel();
+		comboY = new javax.swing.JComboBox();
+		labelY = new javax.swing.JLabel();
+		checkboxDrawPoints = new javax.swing.JCheckBox();
+		checkboxDrawOutliers = new javax.swing.JCheckBox();
+		checkboxWaitWinFull = new javax.swing.JCheckBox();
+		label_processed_points = new javax.swing.JLabel();
+		label_processed_points_value = new javax.swing.JLabel();
+		labelNumPause = new javax.swing.JLabel();
+		numPauseAfterPoints = new javax.swing.JTextField();
+		panelEvalOutput = new javax.swing.JPanel();
+		// outlierVisualEvalPanel1 = new moa.gui.outliertab.OutlierVisualEvalPanel();
+		graphPanel = new javax.swing.JPanel();
+		graphPanelControlTop = new javax.swing.JPanel();
+		buttonZoomInY = new javax.swing.JButton();
+		buttonZoomOutY = new javax.swing.JButton();
+		labelEvents = new javax.swing.JLabel();
+		graphScrollPanel = new javax.swing.JScrollPane();
+		graphCanvas = new moa.gui.visualization.GraphCanvas();
+		graphPanelControlBottom = new javax.swing.JPanel();
+		buttonZoomInX = new javax.swing.JButton();
+		buttonZoomOutX = new javax.swing.JButton();
+
+		setLayout(new java.awt.GridBagLayout());
+
+		jSplitPane1.setDividerLocation(400);
+		jSplitPane1.setOrientation(javax.swing.JSplitPane.VERTICAL_SPLIT);
+
+		topWrapper.setPreferredSize(new java.awt.Dimension(688, 500));
+		topWrapper.setLayout(new java.awt.GridBagLayout());
+
+		// panelVisualWrapper.setBorder(javax.swing.BorderFactory.createBevelBorder(javax.swing.border.BevelBorder.RAISED));
+		panelVisualWrapper.setLayout(new java.awt.BorderLayout());
+
+		splitVisual.setDividerLocation(400);
+		splitVisual.setResizeWeight(1.0);
+
+		scrollPane0.addMouseWheelListener(new java.awt.event.MouseWheelListener() {
+			@Override
+			public void mouseWheelMoved(java.awt.event.MouseWheelEvent evt) {
+				scrollPane0MouseWheelMoved(evt);
+			}
+		});
+
+		streamPanel1.setPreferredSize(new java.awt.Dimension(400, 250));
+
+		javax.swing.GroupLayout streamPanel1Layout = new javax.swing.GroupLayout(streamPanel1);
+		streamPanel1.setLayout(streamPanel1Layout);
+		streamPanel1Layout.setHorizontalGroup(streamPanel1Layout
+				.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 428, Short.MAX_VALUE));
+		streamPanel1Layout.setVerticalGroup(streamPanel1Layout
+				.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 339, Short.MAX_VALUE));
+
+		scrollPane1.setViewportView(streamPanel1);
+
+		splitVisual.setRightComponent(scrollPane1);
+
+		scrollPane0.addMouseWheelListener(new java.awt.event.MouseWheelListener() {
+			@Override
+			public void mouseWheelMoved(java.awt.event.MouseWheelEvent evt) {
+				scrollPane0MouseWheelMoved(evt);
+			}
+		});
+
+		streamPanel0.setPreferredSize(new java.awt.Dimension(400, 250));
+
+		javax.swing.GroupLayout streamPanel0Layout = new javax.swing.GroupLayout(streamPanel0);
+		streamPanel0.setLayout(streamPanel0Layout);
+		streamPanel0Layout.setHorizontalGroup(streamPanel0Layout
+				.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 400, Short.MAX_VALUE));
+		streamPanel0Layout.setVerticalGroup(streamPanel0Layout
+				.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 339, Short.MAX_VALUE));
+
+		scrollPane0.setViewportView(streamPanel0);
+
+		splitVisual.setLeftComponent(scrollPane0);
+
+		splitVisual.addComponentListener(new ComponentListener() {
+			@Override
+			public void componentResized(ComponentEvent ce) {
+				UpdateSplitVisualDivider();
+			}
+
+			@Override
+			public void componentMoved(ComponentEvent ce) {
+			}
+
+			@Override
+			public void componentShown(ComponentEvent ce) {
+			}
+
+			@Override
+			public void componentHidden(ComponentEvent ce) {
+			}
+		});
+
+		panelVisualWrapper.add(splitVisual, java.awt.BorderLayout.CENTER);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 1;
+		gridBagConstraints.gridheight = java.awt.GridBagConstraints.RELATIVE;
+		gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
+		gridBagConstraints.ipadx = 400;
+		gridBagConstraints.ipady = 200;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
+		gridBagConstraints.weightx = 1.0;
+		gridBagConstraints.weighty = 1.0;
+		topWrapper.add(panelVisualWrapper, gridBagConstraints);
+
+		panelControl.setMinimumSize(new java.awt.Dimension(600, 76));
+		panelControl.setPreferredSize(new java.awt.Dimension(2000, 76));
+		panelControl.setLayout(new java.awt.GridBagLayout());
+
+		int iBtnHeight = 27;
+		int iInsetW = 2;
+		int iInsetH = 2;
+
+		buttonRun.setText("Start");
+		buttonRun.setMinimumSize(new java.awt.Dimension(90, iBtnHeight));
+		buttonRun.setPreferredSize(new java.awt.Dimension(90, iBtnHeight));
+		buttonRun.addMouseListener(new java.awt.event.MouseAdapter() {
+			@Override
+			public void mouseClicked(java.awt.event.MouseEvent evt) {
+				buttonRunMouseClicked(evt);
+			}
+		});
+		buttonRun.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonRunActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.insets = new java.awt.Insets(iInsetW, iInsetH, iInsetW, iInsetH);
+		panelControl.add(buttonRun, gridBagConstraints);
+
+		buttonStop.setText("Stop");
+		buttonStop.setMinimumSize(new java.awt.Dimension(90, iBtnHeight));
+		buttonStop.setPreferredSize(new java.awt.Dimension(90, iBtnHeight));
+		buttonStop.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonStopActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 1;
+		gridBagConstraints.insets = new java.awt.Insets(iInsetW, iInsetH, iInsetW, iInsetH);
+		panelControl.add(buttonStop, gridBagConstraints);
+
+		buttonRedraw.setText("Redraw");
+		buttonRedraw.setMinimumSize(new java.awt.Dimension(100, iBtnHeight));
+		buttonRedraw.setPreferredSize(new java.awt.Dimension(100, iBtnHeight));
+		buttonRedraw.addMouseListener(new java.awt.event.MouseAdapter() {
+			@Override
+			public void mouseClicked(java.awt.event.MouseEvent evt) {
+				buttonRedrawMouseClicked(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 1;
+		gridBagConstraints.gridy = 1;
+		gridBagConstraints.insets = new java.awt.Insets(iInsetW, iInsetH, iInsetW, iInsetH);
+		panelControl.add(buttonRedraw, gridBagConstraints);
+
+		buttonScreenshot.setText("Screenshot");
+		buttonScreenshot.setMinimumSize(new java.awt.Dimension(100, iBtnHeight));
+		buttonScreenshot.setPreferredSize(new java.awt.Dimension(100, iBtnHeight));
+		buttonScreenshot.addMouseListener(new java.awt.event.MouseAdapter() {
+			@Override
+			public void mouseClicked(java.awt.event.MouseEvent evt) {
+				buttonScreenshotMouseClicked(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 1;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.insets = new java.awt.Insets(iInsetW, iInsetH, iInsetW, iInsetH);
+		panelControl.add(buttonScreenshot, gridBagConstraints);
+
+		speedSlider.setValue(100);
+		speedSlider.setBorder(javax.swing.BorderFactory.createTitledBorder("Visualisation Speed"));
+		speedSlider.setMinimumSize(new java.awt.Dimension(160, 68));
+		speedSlider.setPreferredSize(new java.awt.Dimension(170, 68));
+		speedSlider.addMouseMotionListener(new java.awt.event.MouseMotionAdapter() {
+			@Override
+			public void mouseDragged(java.awt.event.MouseEvent evt) {
+				speedSliderMouseDragged(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 6;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.gridheight = 2;
+		gridBagConstraints.insets = new java.awt.Insets(0, 16, 1, 5);
+		panelControl.add(speedSlider, gridBagConstraints);
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 9;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.gridheight = 2;
+		gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
+		gridBagConstraints.weightx = 1.0;
+		panelControl.add(jLabel1, gridBagConstraints);
+
+		comboX.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "Dim 1", "Dim 2", "Dim 3", "Dim 4" }));
+		comboX.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				comboXActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 3;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.insets = new java.awt.Insets(0, 4, 0, 4);
+		panelControl.add(comboX, gridBagConstraints);
+
+		labelX.setText("X");
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 2;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.insets = new java.awt.Insets(0, 14, 0, 5);
+		panelControl.add(labelX, gridBagConstraints);
+
+		comboY.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "Dim 1", "Dim 2", "Dim 3", "Dim 4" }));
+		comboY.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				comboYActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 3;
+		gridBagConstraints.gridy = 1;
+		gridBagConstraints.insets = new java.awt.Insets(0, 4, 0, 4);
+		panelControl.add(comboY, gridBagConstraints);
+
+		labelY.setText("Y");
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 2;
+		gridBagConstraints.gridy = 1;
+		gridBagConstraints.insets = new java.awt.Insets(0, 14, 0, 5);
+		panelControl.add(labelY, gridBagConstraints);
+
+		checkboxDrawPoints.setSelected(true);
+		checkboxDrawPoints.setText("Points");
+		checkboxDrawPoints.setMargin(new java.awt.Insets(0, 0, 0, 0));
+		checkboxDrawPoints.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				checkboxDrawPointsActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 4;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.gridwidth = 1;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.SOUTHWEST;
+		gridBagConstraints.insets = new java.awt.Insets(0, 4, 0, 4);
+		panelControl.add(checkboxDrawPoints, gridBagConstraints);
+
+		checkboxDrawOutliers.setSelected(true);
+		checkboxDrawOutliers.setText("Outliers");
+		checkboxDrawOutliers.setMargin(new java.awt.Insets(0, 0, 0, 0));
+		checkboxDrawOutliers.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				checkboxDrawOutlierActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 4;
+		gridBagConstraints.gridy = 1;
+		gridBagConstraints.gridwidth = 1;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
+		gridBagConstraints.insets = new java.awt.Insets(0, 4, 0, 4);
+		panelControl.add(checkboxDrawOutliers, gridBagConstraints);
+
+		checkboxWaitWinFull.setSelected(true);
+		checkboxWaitWinFull.setText("WaitWinFull");
+		checkboxWaitWinFull.setMargin(new java.awt.Insets(0, 0, 0, 0));
+		checkboxWaitWinFull.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				checkboxWaitWinFullActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 5;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.gridwidth = 1;
+		gridBagConstraints.gridheight = 2;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.CENTER;
+		gridBagConstraints.insets = new java.awt.Insets(0, 0, 0, 0);
+		panelControl.add(checkboxWaitWinFull, gridBagConstraints);
+
+		label_processed_points.setText("Processed:");
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 7;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
+		gridBagConstraints.insets = new java.awt.Insets(0, 6, 0, 0);
+		panelControl.add(label_processed_points, gridBagConstraints);
+
+		label_processed_points_value.setText("0");
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 8;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
+		gridBagConstraints.weightx = 1.0;
+		panelControl.add(label_processed_points_value, gridBagConstraints);
+
+		labelNumPause.setText("Pause in:");
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 7;
+		gridBagConstraints.gridy = 1;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
+		gridBagConstraints.insets = new java.awt.Insets(0, 6, 0, 0);
+		panelControl.add(labelNumPause, gridBagConstraints);
+
+		numPauseAfterPoints.setHorizontalAlignment(SwingConstants.RIGHT);
+		numPauseAfterPoints.setText(Integer.toString(RunOutlierVisualizer.initialPauseInterval));
+		numPauseAfterPoints.setMinimumSize(new java.awt.Dimension(70, 25));
+		numPauseAfterPoints.setPreferredSize(new java.awt.Dimension(70, 25));
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 8;
+		gridBagConstraints.gridy = 1;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
+		panelControl.add(numPauseAfterPoints, gridBagConstraints);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
+		gridBagConstraints.weightx = 1.0;
+		topWrapper.add(panelControl, gridBagConstraints);
+
+		jSplitPane1.setLeftComponent(topWrapper);
+
+		panelEvalOutput.setBorder(javax.swing.BorderFactory.createTitledBorder("Evaluation"));
+		panelEvalOutput.setLayout(new java.awt.GridBagLayout());
+
+		graphPanel.setBorder(javax.swing.BorderFactory.createTitledBorder("Process time per object"));
+		graphPanel.setPreferredSize(new java.awt.Dimension(530, 115));
+		graphPanel.setLayout(new java.awt.GridBagLayout());
+
+		graphPanelControlTop.setLayout(new java.awt.GridBagLayout());
+
+		buttonZoomInY.setText("Zoom in Y");
+		buttonZoomInY.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonZoomInYActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
+		graphPanelControlTop.add(buttonZoomInY, gridBagConstraints);
+
+		buttonZoomOutY.setText("Zoom out Y");
+		buttonZoomOutY.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonZoomOutYActionPerformed(evt);
+			}
+		});
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
+		graphPanelControlTop.add(buttonZoomOutY, gridBagConstraints);
+
+		labelEvents.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
+		gridBagConstraints.weightx = 1.0;
+		gridBagConstraints.insets = new java.awt.Insets(0, 2, 0, 2);
+		graphPanelControlTop.add(labelEvents, gridBagConstraints);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
+		gridBagConstraints.weightx = 1.0;
+		graphPanel.add(graphPanelControlTop, gridBagConstraints);
+
+		graphCanvas.setPreferredSize(new java.awt.Dimension(500, 111));
+
+		javax.swing.GroupLayout graphCanvasLayout = new javax.swing.GroupLayout(graphCanvas);
+		graphCanvas.setLayout(graphCanvasLayout);
+		graphCanvasLayout.setHorizontalGroup(graphCanvasLayout
+				.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 515, Short.MAX_VALUE));
+		graphCanvasLayout.setVerticalGroup(graphCanvasLayout
+				.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 128, Short.MAX_VALUE));
+
+		graphScrollPanel.setViewportView(graphCanvas);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 0;
+		gridBagConstraints.gridy = 1;
+		gridBagConstraints.gridwidth = 2;
+		gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
+		gridBagConstraints.weightx = 1.0;
+		gridBagConstraints.weighty = 1.0;
+		gridBagConstraints.insets = new java.awt.Insets(2, 2, 2, 2);
+		graphPanel.add(graphScrollPanel, gridBagConstraints);
+
+		buttonZoomInX.setText("Zoom in X");
+		buttonZoomInX.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonZoomInXActionPerformed(evt);
+			}
+		});
+		graphPanelControlBottom.add(buttonZoomInX);
+
+		buttonZoomOutX.setText("Zoom out X");
+		buttonZoomOutX.addActionListener(new java.awt.event.ActionListener() {
+			@Override
+			public void actionPerformed(java.awt.event.ActionEvent evt) {
+				buttonZoomOutXActionPerformed(evt);
+			}
+		});
+		graphPanelControlBottom.add(buttonZoomOutX);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.gridx = 1;
+		gridBagConstraints.gridy = 0;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
+		graphPanel.add(graphPanelControlBottom, gridBagConstraints);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
+		gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
+		gridBagConstraints.weightx = 2.0;
+		gridBagConstraints.weighty = 1.0;
+		panelEvalOutput.add(graphPanel, gridBagConstraints);
+		panelEvalOutput.addComponentListener(new ComponentListener() {
+			@Override
+			public void componentResized(ComponentEvent ce) {
+				// System.out.println("panelEvalOutput componentResized");
+				graphCanvas.updateCanvas(true);
+			}
+
+			@Override
+			public void componentMoved(ComponentEvent ce) {
+			}
+
+			@Override
+			public void componentShown(ComponentEvent ce) {
+			}
+
+			@Override
+			public void componentHidden(ComponentEvent ce) {
+			}
+		});
+
+		jSplitPane1.setRightComponent(panelEvalOutput);
+
+		gridBagConstraints = new java.awt.GridBagConstraints();
+		gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
+		gridBagConstraints.weightx = 1.0;
+		gridBagConstraints.weighty = 1.0;
+		add(jSplitPane1, gridBagConstraints);
+		// add(topWrapper, gridBagConstraints);
+	}// </editor-fold>//GEN-END:initComponents
+
+	private void buttonRedrawMouseClicked(java.awt.event.MouseEvent evt) {// GEN-FIRST:event_buttonRedrawMouseClicked
+		if (visualizer != null)
+			visualizer.redraw();
+	}// GEN-LAST:event_buttonScreenshotMouseClicked
+
+	private void buttonScreenshotMouseClicked(java.awt.event.MouseEvent evt) {// GEN-FIRST:event_buttonScreenshotMouseClicked
+		BaseFileChooser fileChooser = new BaseFileChooser();
+		fileChooser.setAcceptAllFileFilterUsed(true);
+		if (screenshotFilebase != null)
+			fileChooser.setSelectedFile(new File(screenshotFilebase));
+		if (fileChooser.showSaveDialog(this) == JFileChooser.APPROVE_OPTION) {
+			screenshotFilebase = fileChooser.getSelectedFile().getPath();
+			streamPanel0.screenshot(screenshotFilebase + "_" + label_processed_points_value.getText() + "_0", true,
+					true);
+		}
+	}// GEN-LAST:event_buttonScreenshotMouseClicked
+
+	private void buttonRunMouseClicked(java.awt.event.MouseEvent evt) {// GEN-FIRST:event_buttonRunMouseClicked
+		toggleVisualizer(true);
+	}// GEN-LAST:event_buttonRunMouseClicked
+
+	private void speedSliderMouseDragged(java.awt.event.MouseEvent evt) {// GEN-FIRST:event_speedSliderMouseDragged
+		if (speedSlider == null)
+			return;
+		if (visualizer == null)
+			return;
+
+		visualizer.setSpeed(speedSlider.getValue());
+
+	}// GEN-LAST:event_speedSliderMouseDragged
+
+	public int GetSpeed() {
+		return speedSlider.getValue();
+	}
+
+	private void scrollPane0MouseWheelMoved(java.awt.event.MouseWheelEvent evt) {// GEN-FIRST:event_scrollPane0MouseWheelMoved
+		streamPanel0.setZoom(evt.getX(), evt.getY(), (-1) * evt.getWheelRotation(), scrollPane0);
+	}// GEN-LAST:event_scrollPane0MouseWheelMoved
+
+	private void buttonZoomInXActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonZoomInXActionPerformed
+		graphCanvas.scaleXResolution(false);
+		graphCanvas.updateCanvas(true);
+	}// GEN-LAST:event_buttonZoomInXActionPerformed
+
+	private void buttonZoomOutYActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonZoomOutYActionPerformed
+		graphCanvas.setSize(new Dimension(graphCanvas.getWidth(), (int) (graphCanvas.getHeight() * 0.8)));
+		graphCanvas.setPreferredSize(new Dimension(graphCanvas.getWidth(), (int) (graphCanvas.getHeight() * 0.8)));
+		graphCanvas.updateCanvas(true);
+	}// GEN-LAST:event_buttonZoomOutYActionPerformed
+
+	private void buttonZoomOutXActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonZoomOutXActionPerformed
+		graphCanvas.scaleXResolution(true);
+		graphCanvas.updateCanvas(true);
+	}// GEN-LAST:event_buttonZoomOutXActionPerformed
+
+	private void buttonZoomInYActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonZoomInYActionPerformed
+		graphCanvas.setSize(new Dimension(graphCanvas.getWidth(), (int) (graphCanvas.getHeight() * 1.2)));
+		graphCanvas.setPreferredSize(new Dimension(graphCanvas.getWidth(), (int) (graphCanvas.getHeight() * 1.2)));
+		graphCanvas.updateCanvas(true);
+	}// GEN-LAST:event_buttonZoomInYActionPerformed
+
+	public boolean getPointVisibility() {
+		return checkboxDrawPoints.isSelected();
+	}
+
+	public boolean getOutliersVisibility() {
+		return checkboxDrawOutliers.isSelected();
+	}
+
+	private void checkboxDrawPointsActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_checkboxDrawPointsActionPerformed
+		if (visualizer == null)
+			return;
+		visualizer.setPointsVisibility(checkboxDrawPoints.isSelected());
+	}// GEN-LAST:event_checkboxDrawPointsActionPerformed
+
+	private void checkboxDrawOutlierActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_checkboxDrawOutlierActionPerformed
+		if (visualizer == null)
+			return;
+
+		if (running) {
+			// outliers layer is hidden when running
+			return;
+		}
+		// visualizer.redrawOutliers();
+		visualizer.setOutliersVisibility(checkboxDrawOutliers.isSelected());
+	}// GEN-LAST:event_checkboxDrawOutlierActionPerformed
+
+	public boolean getWaitWinFull() {
+		return checkboxWaitWinFull.isSelected();
+	}
+
+	private void checkboxWaitWinFullActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_checkboxWaitWinFullActionPerformed
+		if (visualizer == null)
+			return;
+		visualizer.setWaitWinFull(checkboxWaitWinFull.isSelected());
+	}// GEN-LAST:checkboxWaitWinFullActionPerformed
+
+	private void comboXActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_comboXActionPerformed
+		if (visualizer == null)
+			return;
+		JComboBox cb = (JComboBox) evt.getSource();
+		int dim = cb.getSelectedIndex();
+		streamPanel0.setActiveXDim(dim);
+		streamPanel1.setActiveXDim(dim);
+		if (visualizer != null)
+			visualizer.redraw();
+	}// GEN-LAST:event_comboXActionPerformed
+
+	private void comboYActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_comboYActionPerformed
+		if (visualizer == null)
+			return;
+		JComboBox cb = (JComboBox) evt.getSource();
+		int dim = cb.getSelectedIndex();
+		streamPanel0.setActiveYDim(dim);
+		streamPanel1.setActiveYDim(dim);
+		if (visualizer != null)
+			visualizer.redraw();
+	}// GEN-LAST:event_comboYActionPerformed
+
+	private void buttonStopActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonStopActionPerformed
+		stopVisualizer();
+		outlierSetupTab.stopRun();
+	}// GEN-LAST:event_buttonStopActionPerformed
+
+	private void buttonRunActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_buttonRunActionPerformed
+		// TODO add your handling code here:
+	}// GEN-LAST:event_buttonRunActionPerformed
+
+	// Variables declaration - do not modify//GEN-BEGIN:variables
+	private javax.swing.JButton buttonRun;
+	private javax.swing.JButton buttonScreenshot;
+	private javax.swing.JButton buttonRedraw;
+	private javax.swing.JButton buttonStop;
+	private javax.swing.JButton buttonZoomInX;
+	private javax.swing.JButton buttonZoomInY;
+	private javax.swing.JButton buttonZoomOutX;
+	private javax.swing.JButton buttonZoomOutY;
+	private javax.swing.JCheckBox checkboxDrawOutliers;
+	private javax.swing.JCheckBox checkboxDrawPoints;
+	private javax.swing.JCheckBox checkboxWaitWinFull;
+	// ### private moa.gui.outliertab.OutlierVisualEvalPanel
+	// outlierVisualEvalPanel1;
+	private javax.swing.JComboBox comboX;
+	private javax.swing.JComboBox comboY;
+	private moa.gui.visualization.GraphCanvas graphCanvas;
+	private javax.swing.JPanel graphPanel;
+	private javax.swing.JPanel graphPanelControlBottom;
+	private javax.swing.JPanel graphPanelControlTop;
+	private javax.swing.JScrollPane graphScrollPanel;
+	private javax.swing.JLabel jLabel1;
+	private javax.swing.JSplitPane jSplitPane1;
+	private javax.swing.JLabel labelEvents;
+	private javax.swing.JLabel labelNumPause;
+	private javax.swing.JLabel labelX;
+	private javax.swing.JLabel labelY;
+	private javax.swing.JLabel label_processed_points;
+	private javax.swing.JLabel label_processed_points_value;
+	private javax.swing.JTextField numPauseAfterPoints;
+	private javax.swing.JPanel panelControl;
+	private javax.swing.JPanel panelEvalOutput;
+	private javax.swing.JPanel panelVisualWrapper;
+	private javax.swing.JScrollPane scrollPane0;
+	private javax.swing.JScrollPane scrollPane1;
+	private javax.swing.JSlider speedSlider;
+	private javax.swing.JSplitPane splitVisual;
+	private moa.gui.visualization.StreamOutlierPanel streamPanel0;
+	private moa.gui.visualization.StreamOutlierPanel streamPanel1;
+	private javax.swing.JPanel topWrapper;
+	// End of variables declaration//GEN-END:variables
+
+	@Override
+	public void actionPerformed(ActionEvent e) {
+		if (visualizer == null)
+			return;
+		if (e.getSource() instanceof JButton) {
+			if (e.getActionCommand().equals("csv export")) {
+				BaseFileChooser fileChooser = new BaseFileChooser();
+				fileChooser.setAcceptAllFileFilterUsed(true);
+				fileChooser.addChoosableFileFilter(new FileExtensionFilter("csv"));
+				if (exportFile != null)
+					fileChooser.setSelectedFile(new File(exportFile));
+				if (fileChooser.showSaveDialog(this) == JFileChooser.APPROVE_OPTION) {
+					exportFile = fileChooser.getSelectedFile().getPath();
+					visualizer.exportCSV(exportFile);
+				}
+			}
+			if (e.getActionCommand().equals("weka export")) {
+				visualizer.weka();
+			}
+		}
+	}
 }
diff --git a/moa/src/main/java/moa/gui/visualization/AbstractGraphAxes.java b/moa/src/main/java/moa/gui/visualization/AbstractGraphAxes.java
index fc913e4e0..e316a2996 100644
--- a/moa/src/main/java/moa/gui/visualization/AbstractGraphAxes.java
+++ b/moa/src/main/java/moa/gui/visualization/AbstractGraphAxes.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 package moa.gui.visualization;
 
@@ -28,232 +28,212 @@
 
 /**
  * AbstractGraphAxes is an abstract class offering functionality to draw axes.
- * 
+ *
  * This class is partially based on GraphAxes.
- * 
+ *
  * @author Tim Sabsch (tim.sabsch@ovgu.de)
  * @version $Revision: 1 $
  * @see GraphAxes
  */
 public abstract class AbstractGraphAxes extends JPanel {
 
-    private static final long serialVersionUID = 1L;
-    protected static final int X_OFFSET_LEFT = 35;
-    protected static final int X_OFFSET_RIGHT = 15;
-    protected static final int Y_OFFSET_BOTTOM = 20;
-    protected static final int Y_OFFSET_TOP = 20;
-
-    protected int width;
-    protected int height;
-
-    protected double x_resolution;
-    protected double y_resolution;
-
-    protected double min_x_value;
-    protected double max_x_value;
-    protected double max_y_value;
-
-    protected double lower_x_value;
-    protected double upper_x_value;
-    protected double upper_y_value;
-
-    /**
-     * Initialises a AbstractGraphAxes by setting the initial values and the
-     * layout.
-     */
-    public AbstractGraphAxes() {
-        this.min_x_value = 0;
-        this.max_x_value = 1;
-        this.max_y_value = 1;
-        this.lower_x_value = 0;
-        this.upper_x_value = 1;
-        this.upper_y_value = 1;
-
-        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
-        this.setLayout(layout);
-        layout.setHorizontalGroup(layout
-                .createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                .addGap(0, 400, Short.MAX_VALUE));
-        layout.setVerticalGroup(layout
-                .createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-                .addGap(0, 300, Short.MAX_VALUE));
-    }
-
-    /**
-     * Sets the x resolution.
-     * 
-     * @param resolution
-     *            new x resolution
-     */
-    public void setXResolution(double resolution) {
-        x_resolution = resolution;
-    }
-
-    /**
-     * Sets the y resolution
-     * 
-     * @param resolution
-     *            new y resolution
-     */
-    public void setYResolution(double resolution) {
-        y_resolution = resolution;
-    }
-
-    @Override
-    protected void paintComponent(Graphics g) {
-        super.paintComponent(g);
-
-        // compute "true" width/height without offsets
-        height = getHeight() - Y_OFFSET_BOTTOM - Y_OFFSET_TOP;
-        width = getWidth() - X_OFFSET_LEFT - X_OFFSET_RIGHT;
-
-        g.setColor(new Color(236, 233, 216));
-        g.fillRect(0, 0, getWidth(), getHeight());
-
-        // draw background
-        g.setColor(Color.WHITE);
-        g.fillRect(X_OFFSET_LEFT, Y_OFFSET_TOP, width, height);
-
-        g.setFont(new Font("Tahoma", 0, 11));
-
-        xAxis(g);
-        yAxis(g);
-    }
-
-    /**
-     * Draws the x axis, containing of the axis line and the labels.
-     * 
-     * @param g
-     *            the Graphics context in which to paint
-     */
-    protected void xAxis(Graphics g) {
-        g.setColor(Color.BLACK);
-
-        // x-axis line
-        g.drawLine(X_OFFSET_LEFT, calcY(0), width + X_OFFSET_LEFT, calcY(0));
-
-        drawXLabels(g);
-    }
-
-    /**
-     * Draws the x labels onto the x axis. Must be overridden by subclasses.
-     * 
-     * @param g
-     *            the Graphics context in which to paint
-     */
-    protected abstract void drawXLabels(Graphics g);
-
-    /**
-     * Draws the y axis, containing og the axis line, the horizontal helping
-     * line and the labels.
-     * 
-     * @param g
-     *            the Graphics context in which to paint
-     */
-    private void yAxis(Graphics g) {
-        // y-axis
-        g.setColor(Color.BLACK);
-        g.drawLine(X_OFFSET_LEFT, calcY(0), X_OFFSET_LEFT, Y_OFFSET_TOP);
-
-        // center horizontal line
-        g.setColor(new Color(220, 220, 220));
-        g.drawLine(X_OFFSET_LEFT, height / 2 + Y_OFFSET_TOP, getWidth(),
-                height / 2 + Y_OFFSET_TOP);
-
-        g.setColor(Color.BLACK);
-
-        // y-achsis markers + labels
-        DecimalFormat d = new DecimalFormat("0.00");
-
-        double numLabels = Math.min(Math.pow(2, y_resolution), 32);
-        /*
-         * technically, this is numLabels-1, but as we're iterating 0 <= i <=
-         * numLabels, we need the extra label. Also don't draw more than 32
-         * labels.
-         */
-
-        for (int i = 0; i <= numLabels; i++) {
-            double fraction = i / numLabels;
-            double value = fraction * upper_y_value;
-            g.drawString(d.format(value), 1,
-                    (int) ((1 - fraction) * height) + Y_OFFSET_TOP + 5);
-            g.drawLine(X_OFFSET_LEFT - 5,
-                    (int) ((1 - fraction) * height) + Y_OFFSET_TOP,
-                    X_OFFSET_LEFT,
-                    (int) ((1 - fraction) * height) + Y_OFFSET_TOP);
-        }
-
-    }
-    
-    /**
-     * Sets the minimum x value
-     * 
-     * @param min
-     *            minimum x value
-     */
-    public void setMinXValue(double min) {
-        this.min_x_value = min;
-    }
-
-    /**
-     * Sets the maximum x value
-     * 
-     * @param max
-     *            maximum x value
-     */
-    public void setMaxXValue(double max) {
-        this.max_x_value = max;
-    }
-    
-    /**
-     * Sets the maximum y value
-     * 
-     * @param max
-     *            maximum y value
-     */
-    public void setMaxYValue(double max) {
-        this.max_y_value = max;
-    }
-    
-    /**
-     * Sets the lower value for the x-axis.
-     * 
-     * @param value
-     *            lower x value
-     */
-    public void setLowerXValue(double value) {
-        this.lower_x_value = value;
-    }
-
-    /**
-     * Sets the upper value for the x-axis.
-     * 
-     * @param value
-     *            upper x value
-     */
-    public void setUpperXValue(double value) {
-        this.upper_x_value = value;
-    }
-
-    /**
-     * Sets the upper value for the y-axis.
-     * 
-     * @param value
-     *            upper y value
-     */
-    public void setUpperYValue(double value) {
-        this.upper_y_value = value;
-    }
-
-    /**
-     * Calculates the position on the y axis for a given value.
-     * 
-     * @param value
-     *            value the y position has to be computed for
-     * @return position on the y axis
-     */
-    private int calcY(double value) {
-        return (int) (height - (value / max_y_value) * height) + Y_OFFSET_TOP;
-    }
+	private static final long serialVersionUID = 1L;
+	protected static final int X_OFFSET_LEFT = 35;
+	protected static final int X_OFFSET_RIGHT = 15;
+	protected static final int Y_OFFSET_BOTTOM = 20;
+	protected static final int Y_OFFSET_TOP = 20;
+
+	protected int width;
+	protected int height;
+
+	protected double x_resolution;
+	protected double y_resolution;
+
+	protected double min_x_value;
+	protected double max_x_value;
+	protected double max_y_value;
+
+	protected double lower_x_value;
+	protected double upper_x_value;
+	protected double upper_y_value;
+
+	/**
+	 * Initialises a AbstractGraphAxes by setting the initial values and the layout.
+	 */
+	public AbstractGraphAxes() {
+		this.min_x_value = 0;
+		this.max_x_value = 1;
+		this.max_y_value = 1;
+		this.lower_x_value = 0;
+		this.upper_x_value = 1;
+		this.upper_y_value = 1;
+
+		javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
+		this.setLayout(layout);
+		layout.setHorizontalGroup(
+				layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 400, Short.MAX_VALUE));
+		layout.setVerticalGroup(
+				layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 300, Short.MAX_VALUE));
+	}
+
+	/**
+	 * Sets the x resolution.
+	 * 
+	 * @param resolution new x resolution
+	 */
+	public void setXResolution(double resolution) {
+		x_resolution = resolution;
+	}
+
+	/**
+	 * Sets the y resolution
+	 * 
+	 * @param resolution new y resolution
+	 */
+	public void setYResolution(double resolution) {
+		y_resolution = resolution;
+	}
+
+	@Override
+	protected void paintComponent(Graphics g) {
+		super.paintComponent(g);
+
+		// compute "true" width/height without offsets
+		height = getHeight() - Y_OFFSET_BOTTOM - Y_OFFSET_TOP;
+		width = getWidth() - X_OFFSET_LEFT - X_OFFSET_RIGHT;
+
+		g.setColor(new Color(236, 233, 216));
+		g.fillRect(0, 0, getWidth(), getHeight());
+
+		// draw background
+		g.setColor(Color.WHITE);
+		g.fillRect(X_OFFSET_LEFT, Y_OFFSET_TOP, width, height);
+
+		g.setFont(new Font("Tahoma", 0, 11));
+
+		xAxis(g);
+		yAxis(g);
+	}
+
+	/**
+	 * Draws the x axis, containing of the axis line and the labels.
+	 * 
+	 * @param g the Graphics context in which to paint
+	 */
+	protected void xAxis(Graphics g) {
+		g.setColor(Color.BLACK);
+
+		// x-axis line
+		g.drawLine(X_OFFSET_LEFT, calcY(0), width + X_OFFSET_LEFT, calcY(0));
+
+		drawXLabels(g);
+	}
+
+	/**
+	 * Draws the x labels onto the x axis. Must be overridden by subclasses.
+	 * 
+	 * @param g the Graphics context in which to paint
+	 */
+	protected abstract void drawXLabels(Graphics g);
+
+	/**
+	 * Draws the y axis, containing og the axis line, the horizontal helping line
+	 * and the labels.
+	 * 
+	 * @param g the Graphics context in which to paint
+	 */
+	private void yAxis(Graphics g) {
+		// y-axis
+		g.setColor(Color.BLACK);
+		g.drawLine(X_OFFSET_LEFT, calcY(0), X_OFFSET_LEFT, Y_OFFSET_TOP);
+
+		// center horizontal line
+		g.setColor(new Color(220, 220, 220));
+		g.drawLine(X_OFFSET_LEFT, height / 2 + Y_OFFSET_TOP, getWidth(), height / 2 + Y_OFFSET_TOP);
+
+		g.setColor(Color.BLACK);
+
+		// y-achsis markers + labels
+		DecimalFormat d = new DecimalFormat("0.00");
+
+		double numLabels = Math.min(Math.pow(2, y_resolution), 32);
+		/*
+		 * technically, this is numLabels-1, but as we're iterating 0 <= i <= numLabels,
+		 * we need the extra label. Also don't draw more than 32 labels.
+		 */
+
+		for (int i = 0; i <= numLabels; i++) {
+			double fraction = i / numLabels;
+			double value = fraction * upper_y_value;
+			g.drawString(d.format(value), 1, (int) ((1 - fraction) * height) + Y_OFFSET_TOP + 5);
+			g.drawLine(X_OFFSET_LEFT - 5, (int) ((1 - fraction) * height) + Y_OFFSET_TOP, X_OFFSET_LEFT,
+					(int) ((1 - fraction) * height) + Y_OFFSET_TOP);
+		}
+
+	}
+
+	/**
+	 * Sets the minimum x value
+	 * 
+	 * @param min minimum x value
+	 */
+	public void setMinXValue(double min) {
+		this.min_x_value = min;
+	}
+
+	/**
+	 * Sets the maximum x value
+	 * 
+	 * @param max maximum x value
+	 */
+	public void setMaxXValue(double max) {
+		this.max_x_value = max;
+	}
+
+	/**
+	 * Sets the maximum y value
+	 * 
+	 * @param max maximum y value
+	 */
+	public void setMaxYValue(double max) {
+		this.max_y_value = max;
+	}
+
+	/**
+	 * Sets the lower value for the x-axis.
+	 * 
+	 * @param value lower x value
+	 */
+	public void setLowerXValue(double value) {
+		this.lower_x_value = value;
+	}
+
+	/**
+	 * Sets the upper value for the x-axis.
+	 * 
+	 * @param value upper x value
+	 */
+	public void setUpperXValue(double value) {
+		this.upper_x_value = value;
+	}
+
+	/**
+	 * Sets the upper value for the y-axis.
+	 * 
+	 * @param value upper y value
+	 */
+	public void setUpperYValue(double value) {
+		this.upper_y_value = value;
+	}
+
+	/**
+	 * Calculates the position on the y axis for a given value.
+	 * 
+	 * @param value value the y position has to be computed for
+	 * @return position on the y axis
+	 */
+	private int calcY(double value) {
+		return (int) (height - (value / max_y_value) * height) + Y_OFFSET_TOP;
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/visualization/AbstractGraphCanvas.java b/moa/src/main/java/moa/gui/visualization/AbstractGraphCanvas.java
index 824c4912e..32248207d 100644
--- a/moa/src/main/java/moa/gui/visualization/AbstractGraphCanvas.java
+++ b/moa/src/main/java/moa/gui/visualization/AbstractGraphCanvas.java
@@ -44,330 +44,324 @@
  */
 public abstract class AbstractGraphCanvas extends JPanel {
 
-    private static final long serialVersionUID = 1L;
-
-    protected MeasureCollection[] measures;
-
-    protected MeasureCollection[] measureStds;
-
-    protected int measureSelected;
-
-    protected AbstractGraphAxes axesPanel;
-
-    protected AbstractGraphPlot plotPanel;
-
-    protected static final int X_OFFSET_LEFT = 35;
-
-    protected static final int X_OFFSET_RIGHT = 15;
-
-    protected static final int Y_OFFSET_BOTTOM = 20;
-
-    protected static final int Y_OFFSET_TOP = 20;
-
-    protected double min_x_value;
-
-    protected double max_x_value;
-    protected double max_y_value;
-
-    protected double x_resolution;
-    protected double y_resolution;
-
-    protected double baseWidth;
-    protected double baseHeight;
-
-    /**
-     * Initialises an AbstractGraphCanvas by constructing its AbstractGraphAxes,
-     * AbstractGraphPlot as well as setting initial sizes.
-     */
-    public AbstractGraphCanvas(AbstractGraphAxes ax, AbstractGraphPlot g) {        
-        this.axesPanel = ax;
-        this.plotPanel = g;
-
-        this.measureSelected = 0;
-
-        this.plotPanel.setLocation(X_OFFSET_LEFT + 1, Y_OFFSET_TOP);
-
-        add(this.axesPanel);
-        this.axesPanel.add(this.plotPanel);
-
-        this.min_x_value = 0;
-        this.max_x_value = 1;
-        this.max_y_value = 1;
-        this.x_resolution = 1;
-        this.y_resolution = 1;
-
-        updateXResolution();
-        updateYResolution();
-
-        this.baseWidth = getWidth();
-        this.baseHeight = getHeight();
-    }
-
-    /**
-     * Sets the value of the plotPlanel for isStandardDeviationPainted.
-     * @param b new setting for isStandardDeviationPainted in the plotPanel
-     */
-    public void setStandardDeviationPainted(boolean b) {
-        this.plotPanel.setStandardDeviationPainted(b);
-    }
-
-    /**
-     * Updates the base width, which is used to determine the canvas size. It is
-     * defined as the current width divided by the x_resolution. To prevent
-     * unnecessary scrolling after reducing the x_resolution, the baseWidth is
-     * reset to its initial value of 500 on x_resolution = 1.
-     */
-    private void updateBaseWidth() {
-        if (x_resolution > 1) {
-            this.baseWidth = getWidth() / x_resolution;
-        } else {
-            this.baseWidth = 500;
-        }
-    }
-
-    /**
-     * Updates the base height, which is used to determine the canvas size. It
-     * is defined as the current height divided by the y_resolution. To prevent
-     * unnecessary scrolling after reducing the y_resolution, the baseHeight is
-     * reset to its initial value of 111 on y_resolution = 1.
-     */
-    private void updateBaseHeight() {
-        if (y_resolution > 1) {
-            this.baseHeight = getHeight() / y_resolution;
-        } else {
-            this.baseHeight = 111;
-        }
-    }
-
-    /**
-     * Scales the resolution on the x-axis by the given factor and updates the
-     * canvas.
-     *
-     * @param factor
-     *            factor the x_resolution will be scaled by
-     */
-    public void scaleXResolution(double factor) {
-        this.x_resolution *= factor;
-        updateXResolution();
-        updateLowerXValue();
-        updateUpperXValue();
-        updateCanvas(true);
-    }
-
-    /**
-     * Scales the resolution on the y-axis by the given factor and updates the
-     * canvas. The y-resolution must not be lower than 1.
-     *
-     * @param factor
-     *            factor the y_resolution will be scaled by
-     */
-    public void scaleYResolution(double factor) {
-        this.y_resolution = Math.max(1.0, this.y_resolution * factor);
-        updateYResolution();
-        updateUpperYValue();
-        updateCanvas(true);
-    }
-
-    /**
-     * Sets the currently selected measure index.
-     *
-     * @param selected
-     * 			  new selected measure
-     */
-    public void setMeasureSelected(int selected) {
-    	this.measureSelected = selected;
-        this.plotPanel.setMeasureSelected(selected);
-    }
-
-    /**
-     * Updates the canvas: if values have changed or it is forced, the canvas
-     * and preferred sizes are updated and the canvas is repainted. Size and
-     * preferred size are determined by the subclass extending
-     * AbstractGraphCanvas.
-     *
-     * @param force
-     *            enforce repainting
-     */
-    public void updateCanvas(boolean force) {
-        if (updateMinMaxValues() || force) {
-            setSize();
-            setPreferredSize();
-            this.repaint();
-        }
-    }
-
-    /**
-     * Sets the canvas size.
-     */
-    public abstract void setSize();
-
-    /**
-     * Sets the preferred canvas size.
-     */
-    public abstract void setPreferredSize();
-
-    /**
-     * Computes the maximum value of the underlying measures at the currently
-     * selected measure.
-     *
-     * @return max value of measures at measureSelected
-     */
-    private double getMaxSelectedValue() {
-        double max = Double.MIN_VALUE;
-
-        for (int i = 0; i < this.measures.length; i++) {
-            if (this.measures[i].getMaxValue(this.measureSelected) > max) {
-                max = this.measures[i].getMaxValue(this.measureSelected);
-            }
-        }
-        return max;
-    }
-
-    /**
-     * Returns the minimum value for the x-axis.
-     */
-    public abstract double getMinXValue();
-
-    /**
-     * Returns the maximum value for the x-axis.
-     */
-    public abstract double getMaxXValue();
-
-    /**
-     * Computes the minimum and maximum values for the x and y-axis and updates
-     * the children, if necessary.
-     *
-     * @return true, if the values have changed
-     */
-    private boolean updateMinMaxValues() {
-
-        double min_x_value_new;
-        double max_x_value_new;
-        double max_y_value_new;
-
-        if (this.measures == null) {
-            // no values received yet -> reset axes
-            min_x_value_new = 0;
-            max_x_value_new = 1;
-            max_y_value_new = 1;
-        } else {
-            min_x_value_new = getMinXValue();
-            max_x_value_new = getMaxXValue();
-            max_y_value_new = getMaxSelectedValue();
-        }
-
-        // resizing needed?
-        if (min_x_value_new != this.min_x_value
-                || max_x_value_new != this.max_x_value
-                || max_y_value_new != this.max_y_value) {
-            this.min_x_value = min_x_value_new;
-            this.max_x_value = max_x_value_new;
-            this.max_y_value = max_y_value_new;
-            updateMinXValue();
-            updateMaxXValue();
-            updateMaxYValue();
-            updateLowerXValue();
-            updateUpperXValue();
-            updateUpperYValue();
-            return true;
-        }
-        return false;
-    }
-
-    /**
-     * Updates the x resolution of the axes and plot panel.
-     */
-    private void updateXResolution() {
-        axesPanel.setXResolution(x_resolution);
-        plotPanel.setXResolution(x_resolution);
-    }
-
-    /**
-     * Updates the y resolution of the axes and plot panel.
-     */
-    private void updateYResolution() {
-        axesPanel.setYResolution(y_resolution);
-    }
-
-    /**
-     * Updates the min x value of the axes and plot panel.
-     */
-    private void updateMinXValue() {
-        axesPanel.setMinXValue(min_x_value);
-        plotPanel.setMinXValue(min_x_value);
-    }
-
-    /**
-     * Updates the max x value of the axes and plot panel.
-     */
-    private void updateMaxXValue() {
-        axesPanel.setMaxXValue(max_x_value);
-        plotPanel.setMaxXValue(max_x_value);
-    }
-
-    /**
-     * Updates the max y value of the axes and plot panel.
-     */
-    private void updateMaxYValue() {
-        axesPanel.setMaxYValue(max_y_value);
-        plotPanel.setMaxYValue(max_y_value);
-    }
-
-    /**
-     * Updates the lower value on the x-axis.
-     */
-    private void updateLowerXValue() {
-        double lower = 0.0;
-        if (this.measures != null) {
-            lower = this.min_x_value * (1 - (0.1 / x_resolution));
-        }
-
-        this.axesPanel.setLowerXValue(lower);
-        this.plotPanel.setLowerXValue(lower);
-    }
-
-    /**
-     * Updates the upper value on the x-axis.
-     */
-    private void updateUpperXValue() {
-        double upper = 1.0;
-        if (this.measures != null) {
-            upper = max_x_value * (1 + (0.1 / x_resolution));
-        }
-
-        this.axesPanel.setUpperXValue(upper);
-        this.plotPanel.setUpperXValue(upper);
-    }
-
-    /**
-     * Updates the upper value on the y-axis.
-     */
-    private void updateUpperYValue() {
-        double upper = 1.0;
-        if (this.measures != null) {
-            upper = max_y_value * (1 + (0.1 / y_resolution));
-        }
-
-        this.axesPanel.setUpperYValue(upper);
-        this.plotPanel.setUpperYValue(upper);
-    }
-
-    /**
-     * Updates the size of the axes, curve and event panel. Recomputes the event
-     * locations if necessary.
-     */
-    private void updateChildren() {
-        axesPanel.setSize(getWidth(), getHeight());
-        plotPanel.setSize(getWidth() - X_OFFSET_LEFT - X_OFFSET_RIGHT,
-                getHeight() - Y_OFFSET_BOTTOM - Y_OFFSET_TOP);
-    }
-
-    @Override
-    protected void paintChildren(Graphics g) {
-        updateBaseHeight();
-        updateBaseWidth();
-        updateChildren();
-        super.paintChildren(g);
-    }
+	private static final long serialVersionUID = 1L;
+
+	protected MeasureCollection[] measures;
+
+	protected MeasureCollection[] measureStds;
+
+	protected int measureSelected;
+
+	protected AbstractGraphAxes axesPanel;
+
+	protected AbstractGraphPlot plotPanel;
+
+	protected static final int X_OFFSET_LEFT = 35;
+
+	protected static final int X_OFFSET_RIGHT = 15;
+
+	protected static final int Y_OFFSET_BOTTOM = 20;
+
+	protected static final int Y_OFFSET_TOP = 20;
+
+	protected double min_x_value;
+
+	protected double max_x_value;
+	protected double max_y_value;
+
+	protected double x_resolution;
+	protected double y_resolution;
+
+	protected double baseWidth;
+	protected double baseHeight;
+
+	/**
+	 * Initialises an AbstractGraphCanvas by constructing its AbstractGraphAxes,
+	 * AbstractGraphPlot as well as setting initial sizes.
+	 */
+	public AbstractGraphCanvas(AbstractGraphAxes ax, AbstractGraphPlot g) {
+		this.axesPanel = ax;
+		this.plotPanel = g;
+
+		this.measureSelected = 0;
+
+		this.plotPanel.setLocation(X_OFFSET_LEFT + 1, Y_OFFSET_TOP);
+
+		add(this.axesPanel);
+		this.axesPanel.add(this.plotPanel);
+
+		this.min_x_value = 0;
+		this.max_x_value = 1;
+		this.max_y_value = 1;
+		this.x_resolution = 1;
+		this.y_resolution = 1;
+
+		updateXResolution();
+		updateYResolution();
+
+		this.baseWidth = getWidth();
+		this.baseHeight = getHeight();
+	}
+
+	/**
+	 * Sets the value of the plotPlanel for isStandardDeviationPainted.
+	 * 
+	 * @param b new setting for isStandardDeviationPainted in the plotPanel
+	 */
+	public void setStandardDeviationPainted(boolean b) {
+		this.plotPanel.setStandardDeviationPainted(b);
+	}
+
+	/**
+	 * Updates the base width, which is used to determine the canvas size. It is
+	 * defined as the current width divided by the x_resolution. To prevent
+	 * unnecessary scrolling after reducing the x_resolution, the baseWidth is reset
+	 * to its initial value of 500 on x_resolution = 1.
+	 */
+	private void updateBaseWidth() {
+		if (x_resolution > 1) {
+			this.baseWidth = getWidth() / x_resolution;
+		} else {
+			this.baseWidth = 500;
+		}
+	}
+
+	/**
+	 * Updates the base height, which is used to determine the canvas size. It is
+	 * defined as the current height divided by the y_resolution. To prevent
+	 * unnecessary scrolling after reducing the y_resolution, the baseHeight is
+	 * reset to its initial value of 111 on y_resolution = 1.
+	 */
+	private void updateBaseHeight() {
+		if (y_resolution > 1) {
+			this.baseHeight = getHeight() / y_resolution;
+		} else {
+			this.baseHeight = 111;
+		}
+	}
+
+	/**
+	 * Scales the resolution on the x-axis by the given factor and updates the
+	 * canvas.
+	 *
+	 * @param factor factor the x_resolution will be scaled by
+	 */
+	public void scaleXResolution(double factor) {
+		this.x_resolution *= factor;
+		updateXResolution();
+		updateLowerXValue();
+		updateUpperXValue();
+		updateCanvas(true);
+	}
+
+	/**
+	 * Scales the resolution on the y-axis by the given factor and updates the
+	 * canvas. The y-resolution must not be lower than 1.
+	 *
+	 * @param factor factor the y_resolution will be scaled by
+	 */
+	public void scaleYResolution(double factor) {
+		this.y_resolution = Math.max(1.0, this.y_resolution * factor);
+		updateYResolution();
+		updateUpperYValue();
+		updateCanvas(true);
+	}
+
+	/**
+	 * Sets the currently selected measure index.
+	 *
+	 * @param selected new selected measure
+	 */
+	public void setMeasureSelected(int selected) {
+		this.measureSelected = selected;
+		this.plotPanel.setMeasureSelected(selected);
+	}
+
+	/**
+	 * Updates the canvas: if values have changed or it is forced, the canvas and
+	 * preferred sizes are updated and the canvas is repainted. Size and preferred
+	 * size are determined by the subclass extending AbstractGraphCanvas.
+	 *
+	 * @param force enforce repainting
+	 */
+	public void updateCanvas(boolean force) {
+		if (updateMinMaxValues() || force) {
+			setSize();
+			setPreferredSize();
+			this.repaint();
+		}
+	}
+
+	/**
+	 * Sets the canvas size.
+	 */
+	public abstract void setSize();
+
+	/**
+	 * Sets the preferred canvas size.
+	 */
+	public abstract void setPreferredSize();
+
+	/**
+	 * Computes the maximum value of the underlying measures at the currently
+	 * selected measure.
+	 *
+	 * @return max value of measures at measureSelected
+	 */
+	private double getMaxSelectedValue() {
+		double max = Double.MIN_VALUE;
+
+		for (int i = 0; i < this.measures.length; i++) {
+			if (this.measures[i].getMaxValue(this.measureSelected) > max) {
+				max = this.measures[i].getMaxValue(this.measureSelected);
+			}
+		}
+		return max;
+	}
+
+	/**
+	 * Returns the minimum value for the x-axis.
+	 */
+	public abstract double getMinXValue();
+
+	/**
+	 * Returns the maximum value for the x-axis.
+	 */
+	public abstract double getMaxXValue();
+
+	/**
+	 * Computes the minimum and maximum values for the x and y-axis and updates the
+	 * children, if necessary.
+	 *
+	 * @return true, if the values have changed
+	 */
+	private boolean updateMinMaxValues() {
+
+		double min_x_value_new;
+		double max_x_value_new;
+		double max_y_value_new;
+
+		if (this.measures == null) {
+			// no values received yet -> reset axes
+			min_x_value_new = 0;
+			max_x_value_new = 1;
+			max_y_value_new = 1;
+		} else {
+			min_x_value_new = getMinXValue();
+			max_x_value_new = getMaxXValue();
+			max_y_value_new = getMaxSelectedValue();
+		}
+
+		// resizing needed?
+		if (min_x_value_new != this.min_x_value || max_x_value_new != this.max_x_value
+				|| max_y_value_new != this.max_y_value) {
+			this.min_x_value = min_x_value_new;
+			this.max_x_value = max_x_value_new;
+			this.max_y_value = max_y_value_new;
+			updateMinXValue();
+			updateMaxXValue();
+			updateMaxYValue();
+			updateLowerXValue();
+			updateUpperXValue();
+			updateUpperYValue();
+			return true;
+		}
+		return false;
+	}
+
+	/**
+	 * Updates the x resolution of the axes and plot panel.
+	 */
+	private void updateXResolution() {
+		axesPanel.setXResolution(x_resolution);
+		plotPanel.setXResolution(x_resolution);
+	}
+
+	/**
+	 * Updates the y resolution of the axes and plot panel.
+	 */
+	private void updateYResolution() {
+		axesPanel.setYResolution(y_resolution);
+	}
+
+	/**
+	 * Updates the min x value of the axes and plot panel.
+	 */
+	private void updateMinXValue() {
+		axesPanel.setMinXValue(min_x_value);
+		plotPanel.setMinXValue(min_x_value);
+	}
+
+	/**
+	 * Updates the max x value of the axes and plot panel.
+	 */
+	private void updateMaxXValue() {
+		axesPanel.setMaxXValue(max_x_value);
+		plotPanel.setMaxXValue(max_x_value);
+	}
+
+	/**
+	 * Updates the max y value of the axes and plot panel.
+	 */
+	private void updateMaxYValue() {
+		axesPanel.setMaxYValue(max_y_value);
+		plotPanel.setMaxYValue(max_y_value);
+	}
+
+	/**
+	 * Updates the lower value on the x-axis.
+	 */
+	private void updateLowerXValue() {
+		double lower = 0.0;
+		if (this.measures != null) {
+			lower = this.min_x_value * (1 - (0.1 / x_resolution));
+		}
+
+		this.axesPanel.setLowerXValue(lower);
+		this.plotPanel.setLowerXValue(lower);
+	}
+
+	/**
+	 * Updates the upper value on the x-axis.
+	 */
+	private void updateUpperXValue() {
+		double upper = 1.0;
+		if (this.measures != null) {
+			upper = max_x_value * (1 + (0.1 / x_resolution));
+		}
+
+		this.axesPanel.setUpperXValue(upper);
+		this.plotPanel.setUpperXValue(upper);
+	}
+
+	/**
+	 * Updates the upper value on the y-axis.
+	 */
+	private void updateUpperYValue() {
+		double upper = 1.0;
+		if (this.measures != null) {
+			upper = max_y_value * (1 + (0.1 / y_resolution));
+		}
+
+		this.axesPanel.setUpperYValue(upper);
+		this.plotPanel.setUpperYValue(upper);
+	}
+
+	/**
+	 * Updates the size of the axes, curve and event panel. Recomputes the event
+	 * locations if necessary.
+	 */
+	private void updateChildren() {
+		axesPanel.setSize(getWidth(), getHeight());
+		plotPanel.setSize(getWidth() - X_OFFSET_LEFT - X_OFFSET_RIGHT, getHeight() - Y_OFFSET_BOTTOM - Y_OFFSET_TOP);
+	}
+
+	@Override
+	protected void paintChildren(Graphics g) {
+		updateBaseHeight();
+		updateBaseWidth();
+		updateChildren();
+		super.paintChildren(g);
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/visualization/AbstractGraphPlot.java b/moa/src/main/java/moa/gui/visualization/AbstractGraphPlot.java
index 4d3aaddbb..b80b41b96 100644
--- a/moa/src/main/java/moa/gui/visualization/AbstractGraphPlot.java
+++ b/moa/src/main/java/moa/gui/visualization/AbstractGraphPlot.java
@@ -36,31 +36,31 @@
  * @version $Revision: 1 $
  * @see GraphCurve
  */
-public abstract class AbstractGraphPlot extends JPanel{
+public abstract class AbstractGraphPlot extends JPanel {
 
 	private static final long serialVersionUID = 1L;
 
 	protected MeasureCollection[] measures;
 	protected MeasureCollection[] measureStds;
-    protected int measureSelected;
+	protected int measureSelected;
 
-    protected double min_x_value;
-    protected double max_x_value;
-    protected double max_y_value;
+	protected double min_x_value;
+	protected double max_x_value;
+	protected double max_y_value;
 
-    protected double lower_x_value;
-    protected double upper_x_value;
-    protected double upper_y_value;
+	protected double lower_x_value;
+	protected double upper_x_value;
+	protected double upper_y_value;
 
-    protected double x_resolution;
+	protected double x_resolution;
 
-    protected Color[] colors;
+	protected Color[] colors;
 
-    protected boolean isStandardDeviationPainted;
+	protected boolean isStandardDeviationPainted;
 
 	public AbstractGraphPlot() {
-	    this.measureSelected = 0;
-	    this.min_x_value = 0;
+		this.measureSelected = 0;
+		this.min_x_value = 0;
 		this.max_x_value = 1;
 		this.max_y_value = 1;
 		this.lower_x_value = 0;
@@ -69,120 +69,118 @@ public AbstractGraphPlot() {
 
 		this.isStandardDeviationPainted = false;
 
-    	setOpaque(false);
-
-        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
-        this.setLayout(layout);
-        layout.setHorizontalGroup(
-            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 1000, Short.MAX_VALUE)
-        );
-        layout.setVerticalGroup(
-            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 300, Short.MAX_VALUE)
-        );
+		setOpaque(false);
+
+		javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
+		this.setLayout(layout);
+		layout.setHorizontalGroup(
+				layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 1000, Short.MAX_VALUE));
+		layout.setVerticalGroup(
+				layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 300, Short.MAX_VALUE));
 	}
 
 	/**
-	 * Sets the graph by updating the measures and currently measure index.
-	 * This method should not be directly called, but may be used by subclasses
-	 * to save space.
+	 * Sets the graph by updating the measures and currently measure index. This
+	 * method should not be directly called, but may be used by subclasses to save
+	 * space.
+	 * 
 	 * @param measures measure information
-	 * @param stds standard deviation of the measures
-	 * @param colors color encoding for the plots
+	 * @param stds     standard deviation of the measures
+	 * @param colors   color encoding for the plots
 	 */
 	protected void setGraph(MeasureCollection[] measures, MeasureCollection[] stds, Color[] colors) {
 		this.measures = measures;
 		this.measureStds = stds;
-	    this.colors = colors;
-	    repaint();
+		this.colors = colors;
+		repaint();
+	}
+
+	/**
+	 * Sets the currently selected measure index.
+	 *
+	 * @param selected new selected measure
+	 */
+	public void setMeasureSelected(int selected) {
+		this.measureSelected = selected;
+	}
+
+	/**
+	 * Sets minimum x value.
+	 * 
+	 * @param min minimum x value
+	 */
+	protected void setMinXValue(double min) {
+		this.min_x_value = min;
+	}
+
+	/**
+	 * Sets maximum x value.
+	 * 
+	 * @param max maximum x value
+	 */
+	protected void setMaxXValue(double max) {
+		this.max_x_value = max;
+	}
+
+	/**
+	 * Sets maximum y value.
+	 * 
+	 * @param max maximum y value
+	 */
+	protected void setMaxYValue(double max) {
+		this.max_y_value = max;
+	}
+
+	/**
+	 * Sets the lower value for the x-axis.
+	 * 
+	 * @param value lower x value
+	 */
+	protected void setLowerXValue(double value) {
+		this.lower_x_value = value;
+	}
+
+	/**
+	 * Sets the upper value for the x-axis.
+	 * 
+	 * @param value upper x value
+	 */
+	protected void setUpperXValue(double value) {
+		this.upper_x_value = value;
+	}
+
+	/**
+	 * Sets the upper value for the y-axis.
+	 * 
+	 * @param value upper y value
+	 */
+	protected void setUpperYValue(double value) {
+		this.upper_y_value = value;
 	}
 
-    /**
-     * Sets the currently selected measure index.
-     *
-     * @param selected
-     * 			  new selected measure
-     */
-    public void setMeasureSelected(int selected) {
-        this.measureSelected = selected;
-    }
-
-    /**
-     * Sets minimum x value.
-     * @param min minimum x value
-     */
-    protected void setMinXValue(double min){
-        this.min_x_value = min;
-    }
-
-    /**
-     * Sets maximum x value.
-     * @param max maximum x value
-     */
-    protected void setMaxXValue(double max){
-        this.max_x_value = max;
-    }
-
-    /**
-     * Sets maximum y value.
-     * @param max maximum y value
-     */
-    protected void setMaxYValue(double max){
-        this.max_y_value = max;
-    }
-
-    /**
-     * Sets the lower value for the x-axis.
-     * 
-     * @param value
-     *            lower x value
-     */
-    protected void setLowerXValue(double value) {
-        this.lower_x_value = value;
-    }
-
-    /**
-     * Sets the upper value for the x-axis.
-     * 
-     * @param value
-     *            upper x value
-     */
-    protected void setUpperXValue(double value) {
-    	this.upper_x_value = value;
-    }
-
-    /**
-     * Sets the upper value for the y-axis.
-     * 
-     * @param value
-     *            upper y value
-     */
-    protected void setUpperYValue(double value) {
-    	this.upper_y_value = value;
-    }
-
-    /**
-     * Sets the resolution on the x-axis
-     * @param x_resolution resolution on the x-axis
-     */
-    protected void setXResolution(double x_resolution) {
-        this.x_resolution = x_resolution;
-    }
-
-    /**
-     * Sets the value for isStandardDeviationPainted.
-     * @param b new setting for isStandardDeviationPainted
-     */
-    protected void setStandardDeviationPainted(boolean b) {
-        this.isStandardDeviationPainted = b;
-    }
-
-    protected void paintStandardDeviation(Graphics g, int len, int x, int y) {
-        // draw vertical line
-        g.drawLine(x, y-len, x, y+len);
-        // draw horizontal lines
-        g.drawLine(x-5, y-len, x+5, y-len);
-        g.drawLine(x-5, y+len, x+5, y+len);
-    }
+	/**
+	 * Sets the resolution on the x-axis
+	 * 
+	 * @param x_resolution resolution on the x-axis
+	 */
+	protected void setXResolution(double x_resolution) {
+		this.x_resolution = x_resolution;
+	}
+
+	/**
+	 * Sets the value for isStandardDeviationPainted.
+	 * 
+	 * @param b new setting for isStandardDeviationPainted
+	 */
+	protected void setStandardDeviationPainted(boolean b) {
+		this.isStandardDeviationPainted = b;
+	}
+
+	protected void paintStandardDeviation(Graphics g, int len, int x, int y) {
+		// draw vertical line
+		g.drawLine(x, y - len, x, y + len);
+		// draw horizontal lines
+		g.drawLine(x - 5, y - len, x + 5, y - len);
+		g.drawLine(x - 5, y + len, x + 5, y + len);
+	}
 }
diff --git a/moa/src/main/java/moa/gui/visualization/ClusterPanel.java b/moa/src/main/java/moa/gui/visualization/ClusterPanel.java
index 352100b4d..5efd4e820 100644
--- a/moa/src/main/java/moa/gui/visualization/ClusterPanel.java
+++ b/moa/src/main/java/moa/gui/visualization/ClusterPanel.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.gui.visualization;
@@ -30,186 +30,176 @@
 import moa.cluster.SphereCluster;
 
 public class ClusterPanel extends JPanel {
-    private SphereCluster cluster;
-
-    private double[] center;
-    private final static int MIN_SIZE = 5;
-    protected double decay_rate;
-
-    protected int x_dim = 0;
-    protected int y_dim = 1;
-    protected Color col;
-    protected Color default_color = Color.BLACK;
-    protected double[] direction = null;
-
-    protected StreamPanel streamPanel;
-
-    protected int panel_size;
-    protected int window_size;
-    protected boolean highligted = false;
-    private double r;
-
-
-
-    /** Creates new form ObjectPanel */
-
-    public ClusterPanel(SphereCluster cluster, Color color, StreamPanel sp) {
-        this.cluster = cluster;
-        center = cluster.getCenter();
-        r = cluster.getRadius();
-        streamPanel = sp;
-
-        default_color = col = color;
-
-        setVisible(true);
-        setOpaque(false);
-        setSize(new Dimension(1,1));
-        setLocation(0,0);
-
-        initComponents();
-    }
-
-    public void setDirection(double[] direction){
-        this.direction = direction;
-    }
-
-    public void updateLocation(){
-        x_dim = streamPanel.getActiveXDim();
-        y_dim = streamPanel.getActiveYDim();
-
-        if(cluster!=null && center==null)
-            getParent().remove(this);
-        else{
-            //size of the parent
-            window_size = Math.min(streamPanel.getWidth(),streamPanel.getHeight());
-
-            //scale down to diameter
-            panel_size = (int) (2* r * window_size);
-            if(panel_size < MIN_SIZE)
-                    panel_size = MIN_SIZE;
-
-            setSize(new Dimension(panel_size+1,panel_size+1));
-            setLocation((int)(center[x_dim]*window_size-(panel_size/2)),(int)(center[y_dim]*window_size-(panel_size/2)));
-            
-        }
-    }
-
-    public void updateTooltip(){
-        setToolTipText(cluster.getInfo());
-    }
-
-    @Override
-    public boolean contains(int x, int y) {
-        //only react on the hull of the cluster
-        double dist = Math.sqrt(Math.pow(x-panel_size/2,2)+Math.pow(y-panel_size/2,2));
-        if(panel_size/2 - 5 < dist && dist < panel_size/2 + 5)
-            return true;
-        else
-            return false;
-    }
-
-
-
-
-    /** This method is called from within the constructor to
-     * initialize the form.
-     * WARNING: Do NOT modify this code. The content of this method is
-     * always regenerated by the Form Editor.
-     */
-    @SuppressWarnings("unchecked")
-    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
-    private void initComponents() {
-
-        addMouseListener(new java.awt.event.MouseAdapter() {
-            public void mouseClicked(java.awt.event.MouseEvent evt) {
-                formMouseClicked(evt);
-            }
-        });
-
-        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
-        this.setLayout(layout);
-        layout.setHorizontalGroup(
-            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 296, Short.MAX_VALUE)
-        );
-        layout.setVerticalGroup(
-            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 266, Short.MAX_VALUE)
-        );
-    }// </editor-fold>//GEN-END:initComponents
-
-    private void formMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_formMouseClicked
-        streamPanel.setHighlightedClusterPanel(this);
-    }//GEN-LAST:event_formMouseClicked
-
-    @Override
-    protected void paintComponent(Graphics g) {
-        updateLocation();
-        if(highligted){
-            g.setColor(Color.BLUE);
-        }
-        else{
-            g.setColor(default_color);
-        }
-        int c = (int)(panel_size/2);
-
-        if(cluster.getId()>=0)
-            g.drawString("C"+(int)cluster.getId(),c,c);
-        
-        g.drawOval(0, 0, panel_size, panel_size);
-
-        if(direction!=null){
-            double length = Math.sqrt(Math.pow(direction[0], 2) + Math.pow(direction[1], 2));
-            g.drawLine(c, c, c+(int)((direction[0]/length)*panel_size), c+(int)((direction[1]/length)*panel_size));
-        }
-
-        updateTooltip();
-        
-
-    }
-
-    public void highlight(boolean enabled){
-        highligted = enabled;
-        repaint();
-    }
-
-    public boolean isValidCluster(){
-        return (center!=null);
-    }
-
-    public int getClusterID(){
-        return (int)cluster.getId();
-    }
-
-    public int getClusterLabel(){
-        return (int)cluster.getGroundTruth();
-    }
-
-
-    public String getSVGString(int width){
-        StringBuffer out = new StringBuffer();
-
-        int x = (int)(center[x_dim]*window_size);
-        int y = (int)(center[y_dim]*window_size);
-        int radius = panel_size/2;
-        
-        out.append("<circle ");
-        out.append("cx='"+x+"' cy='"+y+"' r='"+radius+"'");
-        out.append(" stroke='green' stroke-width='1' fill='white' fill-opacity='0' />");
-        out.append("\n");
-        return out.toString();
-    }
-
-    public void drawOnCanvas(Graphics2D imageGraphics){
-        int x = (int)(center[x_dim]*window_size-(panel_size/2));
-        int y = (int)(center[y_dim]*window_size-(panel_size/2));
-        int radius = panel_size;
-        imageGraphics.drawOval(x, y, radius, radius);
-    }
-
-
-    // Variables declaration - do not modify//GEN-BEGIN:variables
-    // End of variables declaration//GEN-END:variables
-
+	private SphereCluster cluster;
+
+	private double[] center;
+	private final static int MIN_SIZE = 5;
+	protected double decay_rate;
+
+	protected int x_dim = 0;
+	protected int y_dim = 1;
+	protected Color col;
+	protected Color default_color = Color.BLACK;
+	protected double[] direction = null;
+
+	protected StreamPanel streamPanel;
+
+	protected int panel_size;
+	protected int window_size;
+	protected boolean highligted = false;
+	private double r;
+
+	/** Creates new form ObjectPanel */
+
+	public ClusterPanel(SphereCluster cluster, Color color, StreamPanel sp) {
+		this.cluster = cluster;
+		center = cluster.getCenter();
+		r = cluster.getRadius();
+		streamPanel = sp;
+
+		default_color = col = color;
+
+		setVisible(true);
+		setOpaque(false);
+		setSize(new Dimension(1, 1));
+		setLocation(0, 0);
+
+		initComponents();
+	}
+
+	public void setDirection(double[] direction) {
+		this.direction = direction;
+	}
+
+	public void updateLocation() {
+		x_dim = streamPanel.getActiveXDim();
+		y_dim = streamPanel.getActiveYDim();
+
+		if (cluster != null && center == null)
+			getParent().remove(this);
+		else {
+			// size of the parent
+			window_size = Math.min(streamPanel.getWidth(), streamPanel.getHeight());
+
+			// scale down to diameter
+			panel_size = (int) (2 * r * window_size);
+			if (panel_size < MIN_SIZE)
+				panel_size = MIN_SIZE;
+
+			setSize(new Dimension(panel_size + 1, panel_size + 1));
+			setLocation((int) (center[x_dim] * window_size - (panel_size / 2)),
+					(int) (center[y_dim] * window_size - (panel_size / 2)));
+
+		}
+	}
+
+	public void updateTooltip() {
+		setToolTipText(cluster.getInfo());
+	}
+
+	@Override
+	public boolean contains(int x, int y) {
+		// only react on the hull of the cluster
+		double dist = Math.sqrt(Math.pow(x - panel_size / 2, 2) + Math.pow(y - panel_size / 2, 2));
+		if (panel_size / 2 - 5 < dist && dist < panel_size / 2 + 5)
+			return true;
+		else
+			return false;
+	}
+
+	/**
+	 * This method is called from within the constructor to initialize the form.
+	 * WARNING: Do NOT modify this code. The content of this method is always
+	 * regenerated by the Form Editor.
+	 */
+	@SuppressWarnings("unchecked")
+	// <editor-fold defaultstate="collapsed" desc="Generated
+	// Code">//GEN-BEGIN:initComponents
+	private void initComponents() {
+
+		addMouseListener(new java.awt.event.MouseAdapter() {
+			@Override
+			public void mouseClicked(java.awt.event.MouseEvent evt) {
+				formMouseClicked(evt);
+			}
+		});
+
+		javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
+		this.setLayout(layout);
+		layout.setHorizontalGroup(
+				layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 296, Short.MAX_VALUE));
+		layout.setVerticalGroup(
+				layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 266, Short.MAX_VALUE));
+	}// </editor-fold>//GEN-END:initComponents
+
+	private void formMouseClicked(java.awt.event.MouseEvent evt) {// GEN-FIRST:event_formMouseClicked
+		streamPanel.setHighlightedClusterPanel(this);
+	}// GEN-LAST:event_formMouseClicked
+
+	@Override
+	protected void paintComponent(Graphics g) {
+		updateLocation();
+		if (highligted) {
+			g.setColor(Color.BLUE);
+		} else {
+			g.setColor(default_color);
+		}
+		int c = panel_size / 2;
+
+		if (cluster.getId() >= 0)
+			g.drawString("C" + (int) cluster.getId(), c, c);
+
+		g.drawOval(0, 0, panel_size, panel_size);
+
+		if (direction != null) {
+			double length = Math.sqrt(Math.pow(direction[0], 2) + Math.pow(direction[1], 2));
+			g.drawLine(c, c, c + (int) ((direction[0] / length) * panel_size),
+					c + (int) ((direction[1] / length) * panel_size));
+		}
+
+		updateTooltip();
+
+	}
+
+	public void highlight(boolean enabled) {
+		highligted = enabled;
+		repaint();
+	}
+
+	public boolean isValidCluster() {
+		return (center != null);
+	}
+
+	public int getClusterID() {
+		return (int) cluster.getId();
+	}
+
+	public int getClusterLabel() {
+		return (int) cluster.getGroundTruth();
+	}
+
+	public String getSVGString(int width) {
+		StringBuffer out = new StringBuffer();
+
+		int x = (int) (center[x_dim] * window_size);
+		int y = (int) (center[y_dim] * window_size);
+		int radius = panel_size / 2;
+
+		out.append("<circle ");
+		out.append("cx='" + x + "' cy='" + y + "' r='" + radius + "'");
+		out.append(" stroke='green' stroke-width='1' fill='white' fill-opacity='0' />");
+		out.append("\n");
+		return out.toString();
+	}
+
+	public void drawOnCanvas(Graphics2D imageGraphics) {
+		int x = (int) (center[x_dim] * window_size - (panel_size / 2));
+		int y = (int) (center[y_dim] * window_size - (panel_size / 2));
+		int radius = panel_size;
+		imageGraphics.drawOval(x, y, radius, radius);
+	}
+
+	// Variables declaration - do not modify//GEN-BEGIN:variables
+	// End of variables declaration//GEN-END:variables
 
 }
diff --git a/moa/src/main/java/moa/gui/visualization/DataPoint.java b/moa/src/main/java/moa/gui/visualization/DataPoint.java
index 548f21f12..4cf550d9a 100644
--- a/moa/src/main/java/moa/gui/visualization/DataPoint.java
+++ b/moa/src/main/java/moa/gui/visualization/DataPoint.java
@@ -1,9 +1,9 @@
 /**
  * [DataPoint.java]
- * 
+ *
  * @author Timm Jansen (moa@cs.rwth-aachen.de)
  * @editor Yunsu Kim
- * 
+ *
  * Last edited: 2013/06/02
  * Data Management and Data Exploration Group, RWTH Aachen University
  *
@@ -18,8 +18,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.gui.visualization;
@@ -32,106 +32,106 @@
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 
-public class DataPoint extends DenseInstance{
-    
+public class DataPoint extends DenseInstance {
+
 	private static final long serialVersionUID = 1L;
-	
+
 	protected int timestamp;
-    private HashMap<String, String> measure_values;
-    
-    protected int noiseLabel;
-
-    public DataPoint(Instance nextInstance, Integer timestamp) {
-        super(nextInstance);
-        this.setDataset(nextInstance.dataset());
-        this.timestamp = timestamp;
-        measure_values = new HashMap<String, String>();
-        
-        Attribute classLabel = dataset().classAttribute();
-        noiseLabel = classLabel.indexOfValue("noise");		// -1 returned if there is no noise
-    }
-
-    public void updateWeight(int cur_timestamp, double decay_rate){
-        setWeight(Math.pow(2,(-1.0)*decay_rate*(cur_timestamp-timestamp)));
-    }
-
-    public void setMeasureValue(String measureKey, double value){
-        synchronized(measure_values){
-            measure_values.put(measureKey, Double.toString(value));
-        }
-    }
-
-    public void setMeasureValue(String measureKey,String value){
-        synchronized(measure_values){
-            measure_values.put(measureKey, value);
-        }
-    }
-
-    public String getMeasureValue(String measureKey){
-        if(measure_values.containsKey(measureKey))
-            synchronized(measure_values){
-                return measure_values.get(measureKey);
-            }
-        else
-            return "";
-    }
-
-    public int getTimestamp(){
-        return timestamp;
-    }
-    
-    public String getInfo(int x_dim, int y_dim) {
-        StringBuffer sb = new StringBuffer();
-        sb.append("<html><table>");
-        sb.append("<tr><td>Point</td><td>"+timestamp+"</td></tr>");
-        for (int i = 0; i < numAttributes() - 1; i++) { //m_AttValues.length
-            String label = "Dim "+i;
-            if(i == x_dim)
-                 label = "<b>X</b>";
-            if(i == y_dim)
-                 label = "<b>Y</b>";
-            sb.append("<tr><td>"+label+"</td><td>"+value(i)+"</td></tr>");
-        }
-        sb.append("<tr><td>Decay</td><td>"+weight()+"</td></tr>");
-        sb.append("<tr><td>True cluster</td><td>"+classValue()+"</td></tr>");
-        sb.append("</table>");
-        sb.append("<br>");
-        sb.append("<b>Evaluation</b><br>");
-        sb.append("<table>");
-
-        TreeSet<String> sortedset;
-        synchronized(measure_values){
-            sortedset = new TreeSet<String>(measure_values.keySet());
-        }
-
-        Iterator miterator = sortedset.iterator();
-         while(miterator.hasNext()) {
-             String key = (String)miterator.next();
-             sb.append("<tr><td>"+key+"</td><td>"+measure_values.get(key)+"</td></tr>");
-         }
-
-        sb.append("</table></html>");
-        return sb.toString();
-    }
-
-    public double getDistance(DataPoint other){
-        double distance = 0.0;
-        int numDims = numAttributes();
-        if(classIndex()!=0) numDims--;
-
-        for (int i = 0; i < numDims; i++) {
-            double d = value(i) - other.value(i);
-            distance += d * d;
-        }
-        return Math.sqrt(distance);
-    }
-
-    
-    public boolean isNoise() {
-		return (int)classValue() == noiseLabel;
+	private HashMap<String, String> measure_values;
+
+	protected int noiseLabel;
+
+	public DataPoint(Instance nextInstance, Integer timestamp) {
+		super(nextInstance);
+		this.setDataset(nextInstance.dataset());
+		this.timestamp = timestamp;
+		measure_values = new HashMap<>();
+
+		Attribute classLabel = dataset().classAttribute();
+		noiseLabel = classLabel.indexOfValue("noise"); // -1 returned if there is no noise
+	}
+
+	public void updateWeight(int cur_timestamp, double decay_rate) {
+		setWeight(Math.pow(2, (-1.0) * decay_rate * (cur_timestamp - timestamp)));
+	}
+
+	public void setMeasureValue(String measureKey, double value) {
+		synchronized (measure_values) {
+			measure_values.put(measureKey, Double.toString(value));
+		}
+	}
+
+	public void setMeasureValue(String measureKey, String value) {
+		synchronized (measure_values) {
+			measure_values.put(measureKey, value);
+		}
+	}
+
+	public String getMeasureValue(String measureKey) {
+		if (measure_values.containsKey(measureKey))
+			synchronized (measure_values) {
+				return measure_values.get(measureKey);
+			}
+		else
+			return "";
+	}
+
+	public int getTimestamp() {
+		return timestamp;
+	}
+
+	public String getInfo(int x_dim, int y_dim) {
+		StringBuffer sb = new StringBuffer();
+		sb.append("<html><table>");
+		sb.append("<tr><td>Point</td><td>" + timestamp + "</td></tr>");
+		for (int i = 0; i < numAttributes() - 1; i++) { // m_AttValues.length
+			String label = "Dim " + i;
+			if (i == x_dim)
+				label = "<b>X</b>";
+			if (i == y_dim)
+				label = "<b>Y</b>";
+			sb.append("<tr><td>" + label + "</td><td>" + value(i) + "</td></tr>");
+		}
+		sb.append("<tr><td>Decay</td><td>" + weight() + "</td></tr>");
+		sb.append("<tr><td>True cluster</td><td>" + classValue() + "</td></tr>");
+		sb.append("</table>");
+		sb.append("<br>");
+		sb.append("<b>Evaluation</b><br>");
+		sb.append("<table>");
+
+		TreeSet<String> sortedset;
+		synchronized (measure_values) {
+			sortedset = new TreeSet<>(measure_values.keySet());
+		}
+
+		Iterator miterator = sortedset.iterator();
+		while (miterator.hasNext()) {
+			String key = (String) miterator.next();
+			sb.append("<tr><td>" + key + "</td><td>" + measure_values.get(key) + "</td></tr>");
+		}
+
+		sb.append("</table></html>");
+		return sb.toString();
+	}
+
+	public double getDistance(DataPoint other) {
+		double distance = 0.0;
+		int numDims = numAttributes();
+		if (classIndex() != 0)
+			numDims--;
+
+		for (int i = 0; i < numDims; i++) {
+			double d = value(i) - other.value(i);
+			distance += d * d;
+		}
+		return Math.sqrt(distance);
+	}
+
+	public boolean isNoise() {
+		return (int) classValue() == noiseLabel;
+	}
+
+	public double getNoiseLabel() {
+		return noiseLabel;
 	}
-    
-    public double getNoiseLabel() {
-    	return noiseLabel;
-    }
 }
diff --git a/moa/src/main/java/moa/gui/visualization/GraphAxes.java b/moa/src/main/java/moa/gui/visualization/GraphAxes.java
index a51cd4c8a..2aeef42f8 100644
--- a/moa/src/main/java/moa/gui/visualization/GraphAxes.java
+++ b/moa/src/main/java/moa/gui/visualization/GraphAxes.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.gui.visualization;
@@ -26,148 +26,143 @@
 import java.text.DecimalFormat;
 
 public class GraphAxes extends javax.swing.JPanel {
-    private final int x_offset_left = 35;
-    private final int x_offset_right = 5;
-    private final int y_offset_bottom = 20;
-    private final int y_offset_top = 20;
-
-    private int height;
-    private int width;
-
-    private double x_resolution; //how many pixels per 1px
-    private int processFrequency;
-
-    private double min_value = 0;
-    private double max_value = 1;
-    private int max_x_value;
-
-    /** Creates new form GraphAxes */
-    public GraphAxes() {
-        initComponents();
-    }
-
-    public void setXMaxValue(int max) {
-        max_x_value = max;
-    }
-
-    public void setXResolution(double resolution){
-        x_resolution = resolution;
-    }
-
-    public void setProcessFrequency(int frequency){
-        processFrequency = frequency;
-    }
-
-    @Override
-    protected void paintComponent(Graphics g) {
-        super.paintComponent(g);
-
-        //stream not started yet
-        if(processFrequency == 0) return;
-
-        height = getHeight()-y_offset_bottom-y_offset_top;
-        width = getWidth()-x_offset_left-x_offset_right;
-
-        //System.out.println(width);
-
-        g.setColor(new Color(236,233,216));
-        g.fillRect(0, 0, getWidth(), getHeight());
-
-        //draw background
-        g.setColor(Color.WHITE);
-        g.fillRect(x_offset_left, y_offset_top, width, height);
-
-        g.setFont(new Font("Tahoma", 0, 11));
-        
-
-        xAxis(g);
-        yAxis(g);
-    }
-
-    private void xAxis(Graphics g){
-        g.setColor(Color.BLACK);
-        
-        //x-achsis
-        g.drawLine(x_offset_left, calcY(0), width+x_offset_left, calcY(0));
-
-        //x achsis labels
-        int w = 100;
-        for (int i = 0; w*i < width-x_offset_right; i++) {
-            g.drawLine(w*i+x_offset_left, height+y_offset_top, w*i+x_offset_left, height+y_offset_top+5);
-
-            String label = Integer.toString((int)(w*i*processFrequency*x_resolution));
-
-            int str_length = g.getFontMetrics().stringWidth(label);
-            g.drawString(label,w*i+x_offset_left-str_length/2,height+y_offset_top+18);
-        }
-    }
-
-
-    private void yAxis(Graphics g){
-        //y-achsis
-        g.setColor(Color.BLACK);
-        g.drawLine(x_offset_left, calcY(0), x_offset_left, y_offset_top);
-
-        //center horizontal line
-        g.setColor(new Color(220,220,220));
-        g.drawLine(x_offset_left, height/2+y_offset_top, getWidth(), height/2+y_offset_top);
-
-        //3 y-achsis markers + labels
-        g.setColor(Color.BLACK);
-        DecimalFormat d = new DecimalFormat("0.00");
-        int digits_y = (int)(Math.log10(max_value))-1;
-        double upper = Math.ceil(max_value/Math.pow(10,digits_y));
-        if(digits_y < 0) upper*=Math.pow(10,digits_y);
-
-        if(Double.isNaN(upper)) upper =1.0;
-
-        g.drawString(d.format(0.0), 3, height+y_offset_top+5);
-        g.drawString(d.format(upper/2), 3, height/2+y_offset_top + 5);
-        g.drawString(d.format(upper), 3, y_offset_top + 5);
-        g.drawLine(x_offset_left-5, height+y_offset_top, x_offset_left,height+y_offset_top);
-        g.drawLine(x_offset_left-5, height/2+y_offset_top, x_offset_left,height/2+y_offset_top);
-        g.drawLine(x_offset_left-5, y_offset_top, x_offset_left,y_offset_top);
-
-    }
-
-    public void setYMinMaxValues(double min, double max){
-        min_value = min;
-        max_value = max;
-    }
-
-    public void setMaxXValue(int max){
-        max_x_value = max;
-    }
-
-    private int calcY(double value){
-        return (int)(height-(value/max_value)*height)+y_offset_top;
-    }
+	private final int x_offset_left = 35;
+	private final int x_offset_right = 5;
+	private final int y_offset_bottom = 20;
+	private final int y_offset_top = 20;
 
-    /** This method is called from within the constructor to
-     * initialize the form.
-     * WARNING: Do NOT modify this code. The content of this method is
-     * always regenerated by the Form Editor.
-     */
-    @SuppressWarnings("unchecked")
-    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
-    private void initComponents() {
-
-        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
-        this.setLayout(layout);
-        layout.setHorizontalGroup(
-            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 400, Short.MAX_VALUE)
-        );
-        layout.setVerticalGroup(
-            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 300, Short.MAX_VALUE)
-        );
-    }// </editor-fold>//GEN-END:initComponents
+	private int height;
+	private int width;
 
+	private double x_resolution; // how many pixels per 1px
+	private int processFrequency;
 
+	private double min_value = 0;
+	private double max_value = 1;
+	private int max_x_value;
 
+	/** Creates new form GraphAxes */
+	public GraphAxes() {
+		initComponents();
+	}
 
-    // Variables declaration - do not modify//GEN-BEGIN:variables
-    // End of variables declaration//GEN-END:variables
+	public void setXMaxValue(int max) {
+		max_x_value = max;
+	}
+
+	public void setXResolution(double resolution) {
+		x_resolution = resolution;
+	}
+
+	public void setProcessFrequency(int frequency) {
+		processFrequency = frequency;
+	}
+
+	@Override
+	protected void paintComponent(Graphics g) {
+		super.paintComponent(g);
+
+		// stream not started yet
+		if (processFrequency == 0)
+			return;
+
+		height = getHeight() - y_offset_bottom - y_offset_top;
+		width = getWidth() - x_offset_left - x_offset_right;
+
+		// System.out.println(width);
+
+		g.setColor(new Color(236, 233, 216));
+		g.fillRect(0, 0, getWidth(), getHeight());
+
+		// draw background
+		g.setColor(Color.WHITE);
+		g.fillRect(x_offset_left, y_offset_top, width, height);
+
+		g.setFont(new Font("Tahoma", 0, 11));
+
+		xAxis(g);
+		yAxis(g);
+	}
+
+	private void xAxis(Graphics g) {
+		g.setColor(Color.BLACK);
+
+		// x-achsis
+		g.drawLine(x_offset_left, calcY(0), width + x_offset_left, calcY(0));
+
+		// x achsis labels
+		int w = 100;
+		for (int i = 0; w * i < width - x_offset_right; i++) {
+			g.drawLine(w * i + x_offset_left, height + y_offset_top, w * i + x_offset_left, height + y_offset_top + 5);
+
+			String label = Integer.toString((int) (w * i * processFrequency * x_resolution));
+
+			int str_length = g.getFontMetrics().stringWidth(label);
+			g.drawString(label, w * i + x_offset_left - str_length / 2, height + y_offset_top + 18);
+		}
+	}
+
+	private void yAxis(Graphics g) {
+		// y-achsis
+		g.setColor(Color.BLACK);
+		g.drawLine(x_offset_left, calcY(0), x_offset_left, y_offset_top);
+
+		// center horizontal line
+		g.setColor(new Color(220, 220, 220));
+		g.drawLine(x_offset_left, height / 2 + y_offset_top, getWidth(), height / 2 + y_offset_top);
+
+		// 3 y-achsis markers + labels
+		g.setColor(Color.BLACK);
+		DecimalFormat d = new DecimalFormat("0.00");
+		int digits_y = (int) (Math.log10(max_value)) - 1;
+		double upper = Math.ceil(max_value / Math.pow(10, digits_y));
+		if (digits_y < 0)
+			upper *= Math.pow(10, digits_y);
+
+		if (Double.isNaN(upper))
+			upper = 1.0;
+
+		g.drawString(d.format(0.0), 3, height + y_offset_top + 5);
+		g.drawString(d.format(upper / 2), 3, height / 2 + y_offset_top + 5);
+		g.drawString(d.format(upper), 3, y_offset_top + 5);
+		g.drawLine(x_offset_left - 5, height + y_offset_top, x_offset_left, height + y_offset_top);
+		g.drawLine(x_offset_left - 5, height / 2 + y_offset_top, x_offset_left, height / 2 + y_offset_top);
+		g.drawLine(x_offset_left - 5, y_offset_top, x_offset_left, y_offset_top);
+
+	}
+
+	public void setYMinMaxValues(double min, double max) {
+		min_value = min;
+		max_value = max;
+	}
+
+	public void setMaxXValue(int max) {
+		max_x_value = max;
+	}
+
+	private int calcY(double value) {
+		return (int) (height - (value / max_value) * height) + y_offset_top;
+	}
+
+	/**
+	 * This method is called from within the constructor to initialize the form.
+	 * WARNING: Do NOT modify this code. The content of this method is always
+	 * regenerated by the Form Editor.
+	 */
+	@SuppressWarnings("unchecked")
+	// <editor-fold defaultstate="collapsed" desc="Generated
+	// Code">//GEN-BEGIN:initComponents
+	private void initComponents() {
+
+		javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
+		this.setLayout(layout);
+		layout.setHorizontalGroup(
+				layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 400, Short.MAX_VALUE));
+		layout.setVerticalGroup(
+				layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 300, Short.MAX_VALUE));
+	}// </editor-fold>//GEN-END:initComponents
+
+	// Variables declaration - do not modify//GEN-BEGIN:variables
+	// End of variables declaration//GEN-END:variables
 
 }
diff --git a/moa/src/main/java/moa/gui/visualization/GraphCanvas.java b/moa/src/main/java/moa/gui/visualization/GraphCanvas.java
index fe857f285..db3f0fcf2 100644
--- a/moa/src/main/java/moa/gui/visualization/GraphCanvas.java
+++ b/moa/src/main/java/moa/gui/visualization/GraphCanvas.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 package moa.gui.visualization;
 
@@ -32,262 +32,264 @@
 
 public class GraphCanvas extends JPanel {
 
-    private MeasureCollection measure0 = null;
-
-    private MeasureCollection measure1 = null;
+	private MeasureCollection measure0 = null;
 
-    int measureSelected = 0;
+	private MeasureCollection measure1 = null;
 
-    private ArrayList<ClusterEvent> clusterEvents;
+	int measureSelected = 0;
 
-    private ArrayList<JLabel> eventLabelList;
+	private ArrayList<ClusterEvent> clusterEvents;
 
-    private GraphAxes axesPanel;
+	private ArrayList<JLabel> eventLabelList;
 
-    private GraphCurve curvePanel;
+	private GraphAxes axesPanel;
 
-    private JPanel eventPanel;
+	private GraphCurve curvePanel;
 
-    private int eventCounter = 0;
+	private JPanel eventPanel;
 
-    private final int x_offset_left = 35;
+	private int eventCounter = 0;
 
-    private final int x_offset_right = 5;
+	private final int x_offset_left = 35;
 
-    private final int y_offset_bottom = 20;
+	private final int x_offset_right = 5;
 
-    private final int y_offset_top = 20;
+	private final int y_offset_bottom = 20;
 
-    private int processFrequency;
+	private final int y_offset_top = 20;
 
-    //default values to start with;
-    private double min_y_value = 0;
+	private int processFrequency;
 
-    private double max_y_value = 1;
+	// default values to start with;
+	private double min_y_value = 0;
 
-    private double max_x_value = 250;
+	private double max_y_value = 1;
 
-    private double x_resolution = 0.5; //how many pixels per 1px
+	private double max_x_value = 250;
 
-    private double y_resolution = 1;   //full min to max scale
+	private double x_resolution = 0.5; // how many pixels per 1px
 
-    private JViewport viewport;
+	private double y_resolution = 1; // full min to max scale
 
-    /** Creates new form GraphCanvas */
-    public GraphCanvas() {
-        addComponents();
-        eventLabelList = new ArrayList<JLabel>();
-    }
+	private JViewport viewport;
 
-    public void scaleXResolution(boolean scaleUp) {
-        if (scaleUp) {
-            x_resolution *= 2;
-        } else {
-            x_resolution /= 2;
-        }
-        updateCanvas(true);
-    }
+	/** Creates new form GraphCanvas */
+	public GraphCanvas() {
+		addComponents();
+		eventLabelList = new ArrayList<>();
+	}
 
-    public void scaleYResolution(boolean scaleUp) {
-        if (scaleUp) {
-            y_resolution *= 2;
-        } else {
-            y_resolution /= 2;
-        }
-        updateCanvas(true);
-    }
+	public void scaleXResolution(boolean scaleUp) {
+		if (scaleUp) {
+			x_resolution *= 2;
+		} else {
+			x_resolution /= 2;
+		}
+		updateCanvas(true);
+	}
 
-    public int getMeasureSelected() {
-        return measureSelected;
-    }
+	public void scaleYResolution(boolean scaleUp) {
+		if (scaleUp) {
+			y_resolution *= 2;
+		} else {
+			y_resolution /= 2;
+		}
+		updateCanvas(true);
+	}
 
-    public int getProcessFrequency() {
-        return this.processFrequency;
-    }
-
-    public void setGraph(MeasureCollection measure0, MeasureCollection measure1, int mSelect, int processFrequency) {
-        this.measure0 = measure0;
-        this.measure1 = measure1;
-        measureSelected = mSelect;
-        this.processFrequency = processFrequency;
-        axesPanel.setProcessFrequency(processFrequency);
-        curvePanel.setProcessFrequency(processFrequency);
-        curvePanel.setGraph(measure0, measure1, mSelect);
-        updateCanvas();
-    }
-
-    public void updateCanvas() {
-        updateCanvas(false);
-    }
-
-    public void updateCanvas(boolean force) {
-
-        //check for new min max values first so we know if we have to do some resizing
-        if (updateMinMaxValues() || force) {
-            int maxLabel = (int) Math.ceil(max_x_value / x_resolution / 500);
-            int width = (int) (maxLabel * 500);
-            setSize(width, getHeight());
-            setPreferredSize(new Dimension(width, getHeight()));
-
-            axesPanel.setXMaxValue(maxLabel);
-
-            updateXResolution();
-            updateYValues();
-            updateSize();
-
-            axesPanel.repaint();
-        }
-
-        //check for new events
-        addEvents();
-
-        //add the latest plot point through repaint
-        //TODO: somehow realize incremental painting? (real heavyweight canvas: update())
-        curvePanel.repaint();
-    }
-
-    //returns true when values have changed
-    private boolean updateMinMaxValues() {
-        double min_y_value_new = min_y_value;
-        double max_y_value_new = max_y_value;
-        double max_x_value_new = max_x_value;
-
-        if (measure0 != null && measure1 != null) {
-            min_y_value_new = Math.min(measure0.getMinValue(measureSelected), measure1.getMinValue(measureSelected));
-            max_y_value_new = Math.max(measure0.getMaxValue(measureSelected), measure1.getMaxValue(measureSelected));
-            max_x_value_new = Math.max(measure0.getNumberOfValues(measureSelected), max_x_value);
-        } else {
-            if (measure0 != null) {
-                min_y_value_new = measure0.getMinValue(measureSelected);
-                max_y_value_new = measure0.getMaxValue(measureSelected);
-                max_x_value_new = Math.max(measure0.getNumberOfValues(measureSelected), max_x_value);
-            }
-        }
-
-        //resizing needed?
-        if (max_x_value_new != max_x_value || max_y_value_new != max_y_value || min_y_value_new != min_y_value) {
-            min_y_value = min_y_value_new;
-            max_y_value = max_y_value_new;
-            max_x_value = max_x_value_new;
-            return true;
-        }
-        return false;
-    }
-
-    private void updateXResolution() {
-        axesPanel.setXResolution(x_resolution);
-        curvePanel.setXResolution(x_resolution);
-    }
-
-    private void updateYValues() {
-        axesPanel.setYMinMaxValues(min_y_value, max_y_value);
-        curvePanel.setYMinMaxValues(min_y_value, max_y_value);
-    }
-
-    private void updateSize() {
-        axesPanel.setSize(getWidth(), getHeight());
-        //axesPanel.setPreferredSize(new Dimension(getWidth(), getHeight()));
-        curvePanel.setSize(getWidth() - x_offset_left - x_offset_right, getHeight() - y_offset_bottom - y_offset_top);
-        eventPanel.setSize(getWidth() - x_offset_left - x_offset_right, y_offset_top);
-
-        if (clusterEvents != null) {
-            //update Label positions
-            for (int i = 0; i < clusterEvents.size(); i++) {
-                int x = (int) (clusterEvents.get(i).getTimestamp() / processFrequency / x_resolution);
-                if (i < eventLabelList.size()) {
-                    eventLabelList.get(i).setLocation(x - 10, 0);
-                }
-            }
-        }
-    }
-
-    //check if there are any new events in the event list and add them to the plot
-    private void addEvents() {
-        if (clusterEvents != null && clusterEvents.size() > eventCounter) {
-            ClusterEvent ev = clusterEvents.get(eventCounter);
-            eventCounter++;
-            JLabel eventMarker = new JLabel(ev.getType().substring(0, 1));
-
-            eventMarker.setPreferredSize(new Dimension(20, y_offset_top));
-            eventMarker.setSize(new Dimension(20, y_offset_top));
-            eventMarker.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
-            int x = (int) (ev.getTimestamp() / processFrequency / x_resolution);
-
-            eventMarker.setLocation(x - 10, 0);
-            eventMarker.setToolTipText(ev.getType() + " at " + ev.getTimestamp() + ": " + ev.getMessage());
-            eventPanel.add(eventMarker);
-            eventLabelList.add(eventMarker);
-            eventPanel.repaint();
-        }
-    }
-
-    //check if there are any new events in the event list and add them to the plot
-    public void forceAddEvents() {
-        if (clusterEvents != null) {
-            eventPanel.removeAll();
-            for (int i = 0; i < clusterEvents.size(); i++) {
-
-                ClusterEvent ev = clusterEvents.get(i);
-                JLabel eventMarker = new JLabel(ev.getType().substring(0, 1));
-
-                eventMarker.setPreferredSize(new Dimension(20, y_offset_top));
-                eventMarker.setSize(new Dimension(20, y_offset_top));
-                eventMarker.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
-                int x = (int) (ev.getTimestamp() / processFrequency / x_resolution);
-
-                eventMarker.setLocation(x - 10, 0);
-                eventMarker.setToolTipText(ev.getType() + " at " + ev.getTimestamp() + ": " + ev.getMessage());
-                eventPanel.add(eventMarker);
-                eventLabelList.add(eventMarker);
-                eventPanel.repaint();
-            }
-        }
-    }
-
-    @Override
-    protected void paintComponent(Graphics g) {
-        //needed in case parent component gets resized
-        //TODO doesn't fully work yet when reducing height
-        updateSize();
-        super.paintComponent(g);
-    }
-
-    private void addComponents() {
-
-        axesPanel = new GraphAxes();
-        curvePanel = new GraphCurve();
-        eventPanel = new JPanel();
-
-        curvePanel.setLocation(x_offset_left + 1, y_offset_top);
-        eventPanel.setLocation(x_offset_left + 1, 0);
-        eventPanel.setLayout(null);
-
-        add(axesPanel);
-        axesPanel.add(curvePanel);
-        axesPanel.add(eventPanel);
-
-    }
-
-    /**
-     * This method is called from within the constructor to initialize the form.
-     * WARNING: Do NOT modify this code. The content of this method is always
-     * regenerated by the Form Editor.
-     */
-    @SuppressWarnings("unchecked")
-    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
-    private void initComponents() {
-
-        setLayout(new java.awt.GridBagLayout());
-    }// </editor-fold>//GEN-END:initComponents
-
-    public void setClusterEventsList(ArrayList<ClusterEvent> clusterEvents) {
-        this.clusterEvents = clusterEvents;
-        curvePanel.setClusterEventsList(clusterEvents);
-    }
-
-    public void setViewport(JViewport viewport) {
-        this.viewport = viewport;
-    }
-    // Variables declaration - do not modify//GEN-BEGIN:variables
-    // End of variables declaration//GEN-END:variables
+	public int getMeasureSelected() {
+		return measureSelected;
+	}
+
+	public int getProcessFrequency() {
+		return this.processFrequency;
+	}
+
+	public void setGraph(MeasureCollection measure0, MeasureCollection measure1, int mSelect, int processFrequency) {
+		this.measure0 = measure0;
+		this.measure1 = measure1;
+		measureSelected = mSelect;
+		this.processFrequency = processFrequency;
+		axesPanel.setProcessFrequency(processFrequency);
+		curvePanel.setProcessFrequency(processFrequency);
+		curvePanel.setGraph(measure0, measure1, mSelect);
+		updateCanvas();
+	}
+
+	public void updateCanvas() {
+		updateCanvas(false);
+	}
+
+	public void updateCanvas(boolean force) {
+
+		// check for new min max values first so we know if we have to do some resizing
+		if (updateMinMaxValues() || force) {
+			int maxLabel = (int) Math.ceil(max_x_value / x_resolution / 500);
+			int width = maxLabel * 500;
+			setSize(width, getHeight());
+			setPreferredSize(new Dimension(width, getHeight()));
+
+			axesPanel.setXMaxValue(maxLabel);
+
+			updateXResolution();
+			updateYValues();
+			updateSize();
+
+			axesPanel.repaint();
+		}
+
+		// check for new events
+		addEvents();
+
+		// add the latest plot point through repaint
+		// TODO: somehow realize incremental painting? (real heavyweight canvas:
+		// update())
+		curvePanel.repaint();
+	}
+
+	// returns true when values have changed
+	private boolean updateMinMaxValues() {
+		double min_y_value_new = min_y_value;
+		double max_y_value_new = max_y_value;
+		double max_x_value_new = max_x_value;
+
+		if (measure0 != null && measure1 != null) {
+			min_y_value_new = Math.min(measure0.getMinValue(measureSelected), measure1.getMinValue(measureSelected));
+			max_y_value_new = Math.max(measure0.getMaxValue(measureSelected), measure1.getMaxValue(measureSelected));
+			max_x_value_new = Math.max(measure0.getNumberOfValues(measureSelected), max_x_value);
+		} else {
+			if (measure0 != null) {
+				min_y_value_new = measure0.getMinValue(measureSelected);
+				max_y_value_new = measure0.getMaxValue(measureSelected);
+				max_x_value_new = Math.max(measure0.getNumberOfValues(measureSelected), max_x_value);
+			}
+		}
+
+		// resizing needed?
+		if (max_x_value_new != max_x_value || max_y_value_new != max_y_value || min_y_value_new != min_y_value) {
+			min_y_value = min_y_value_new;
+			max_y_value = max_y_value_new;
+			max_x_value = max_x_value_new;
+			return true;
+		}
+		return false;
+	}
+
+	private void updateXResolution() {
+		axesPanel.setXResolution(x_resolution);
+		curvePanel.setXResolution(x_resolution);
+	}
+
+	private void updateYValues() {
+		axesPanel.setYMinMaxValues(min_y_value, max_y_value);
+		curvePanel.setYMinMaxValues(min_y_value, max_y_value);
+	}
+
+	private void updateSize() {
+		axesPanel.setSize(getWidth(), getHeight());
+		// axesPanel.setPreferredSize(new Dimension(getWidth(), getHeight()));
+		curvePanel.setSize(getWidth() - x_offset_left - x_offset_right, getHeight() - y_offset_bottom - y_offset_top);
+		eventPanel.setSize(getWidth() - x_offset_left - x_offset_right, y_offset_top);
+
+		if (clusterEvents != null) {
+			// update Label positions
+			for (int i = 0; i < clusterEvents.size(); i++) {
+				int x = (int) (clusterEvents.get(i).getTimestamp() / processFrequency / x_resolution);
+				if (i < eventLabelList.size()) {
+					eventLabelList.get(i).setLocation(x - 10, 0);
+				}
+			}
+		}
+	}
+
+	// check if there are any new events in the event list and add them to the plot
+	private void addEvents() {
+		if (clusterEvents != null && clusterEvents.size() > eventCounter) {
+			ClusterEvent ev = clusterEvents.get(eventCounter);
+			eventCounter++;
+			JLabel eventMarker = new JLabel(ev.getType().substring(0, 1));
+
+			eventMarker.setPreferredSize(new Dimension(20, y_offset_top));
+			eventMarker.setSize(new Dimension(20, y_offset_top));
+			eventMarker.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
+			int x = (int) (ev.getTimestamp() / processFrequency / x_resolution);
+
+			eventMarker.setLocation(x - 10, 0);
+			eventMarker.setToolTipText(ev.getType() + " at " + ev.getTimestamp() + ": " + ev.getMessage());
+			eventPanel.add(eventMarker);
+			eventLabelList.add(eventMarker);
+			eventPanel.repaint();
+		}
+	}
+
+	// check if there are any new events in the event list and add them to the plot
+	public void forceAddEvents() {
+		if (clusterEvents != null) {
+			eventPanel.removeAll();
+			for (int i = 0; i < clusterEvents.size(); i++) {
+
+				ClusterEvent ev = clusterEvents.get(i);
+				JLabel eventMarker = new JLabel(ev.getType().substring(0, 1));
+
+				eventMarker.setPreferredSize(new Dimension(20, y_offset_top));
+				eventMarker.setSize(new Dimension(20, y_offset_top));
+				eventMarker.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
+				int x = (int) (ev.getTimestamp() / processFrequency / x_resolution);
+
+				eventMarker.setLocation(x - 10, 0);
+				eventMarker.setToolTipText(ev.getType() + " at " + ev.getTimestamp() + ": " + ev.getMessage());
+				eventPanel.add(eventMarker);
+				eventLabelList.add(eventMarker);
+				eventPanel.repaint();
+			}
+		}
+	}
+
+	@Override
+	protected void paintComponent(Graphics g) {
+		// needed in case parent component gets resized
+		// TODO doesn't fully work yet when reducing height
+		updateSize();
+		super.paintComponent(g);
+	}
+
+	private void addComponents() {
+
+		axesPanel = new GraphAxes();
+		curvePanel = new GraphCurve();
+		eventPanel = new JPanel();
+
+		curvePanel.setLocation(x_offset_left + 1, y_offset_top);
+		eventPanel.setLocation(x_offset_left + 1, 0);
+		eventPanel.setLayout(null);
+
+		add(axesPanel);
+		axesPanel.add(curvePanel);
+		axesPanel.add(eventPanel);
+
+	}
+
+	/**
+	 * This method is called from within the constructor to initialize the form.
+	 * WARNING: Do NOT modify this code. The content of this method is always
+	 * regenerated by the Form Editor.
+	 */
+	@SuppressWarnings("unchecked")
+	// <editor-fold defaultstate="collapsed" desc="Generated
+	// Code">//GEN-BEGIN:initComponents
+	private void initComponents() {
+
+		setLayout(new java.awt.GridBagLayout());
+	}// </editor-fold>//GEN-END:initComponents
+
+	public void setClusterEventsList(ArrayList<ClusterEvent> clusterEvents) {
+		this.clusterEvents = clusterEvents;
+		curvePanel.setClusterEventsList(clusterEvents);
+	}
+
+	public void setViewport(JViewport viewport) {
+		this.viewport = viewport;
+	}
+	// Variables declaration - do not modify//GEN-BEGIN:variables
+	// End of variables declaration//GEN-END:variables
 }
diff --git a/moa/src/main/java/moa/gui/visualization/GraphCurve.java b/moa/src/main/java/moa/gui/visualization/GraphCurve.java
index 46518e7a1..6d74983ef 100644
--- a/moa/src/main/java/moa/gui/visualization/GraphCurve.java
+++ b/moa/src/main/java/moa/gui/visualization/GraphCurve.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 package moa.gui.visualization;
 
@@ -28,160 +28,147 @@
 import moa.streams.clustering.ClusterEvent;
 
 public class GraphCurve extends javax.swing.JPanel {
-    private double min_value = 0;
-    private double max_value = 1;
-    private MeasureCollection measure0 = null;
-    private MeasureCollection measure1 = null;
-    private int measureSelected = 0;
-
-    private double x_resolution;
-    private int processFrequency;
-
-    private ArrayList<ClusterEvent> clusterEvents;
-    
-    
-    /** Creates new form GraphCurve */
-    public GraphCurve() {
-        initComponents();
-    }
-
-
-    public void setGraph(MeasureCollection measure0, MeasureCollection measure1, int selection){
-       this.measure0 = measure0;
-       this.measure1 = measure1;
-       this.measureSelected = selection;
-       repaint();
-    }
-    
-    void setProcessFrequency(int processFrequency) {
-        this.processFrequency = processFrequency;
-    }
-
-    @Override
-    protected void paintComponent(Graphics g) {
-        super.paintComponent(g);
-
-        g.setColor(Color.BLACK);
-
-        if(measure0!=null && measure1!=null){
-                paintFullCurve(g, measure0, measureSelected, Color.red);
-                paintFullCurve(g, measure1, measureSelected, Color.blue);
-        }
-        else{
-            if(measure0!=null){
-                paintFullCurve(g, measure0, measureSelected, Color.red);
-            }
-        }
-        paintEvents(g);
-        
-    }
-
-
-    private void paintFullCurve(Graphics g, MeasureCollection m, int mSelect, Color color){
-            if (m.getNumberOfValues(mSelect)==0) return;
-
-            boolean corrupted = false;
-            int height = getHeight();
-            int width = getWidth();
-            int n = m.getNumberOfValues(mSelect);
-            if(x_resolution > 1) 
-                n = (int)(n / (int)x_resolution);
-            int[] x = new int[n];
-            int[] y = new int[n];
-
-            for (int i = 0; i < n; i ++) {
-                if(x_resolution > 1){
-                    //we need to compress the values
-                    double sum_y = 0;
-                    int counter = 0;
-                    for (int j = 0; j < x_resolution; j++) {
-                        if((i)*x_resolution+j<m.getNumberOfValues(mSelect)){
-                            sum_y+= m.getValue(mSelect,i);
-                            counter++;
-                        }
-                        sum_y/=counter;
-                    }
-                    x[i] = i;
-                    y[i] = (int)(height-(sum_y/max_value)*height);
-                }
-                else{
-                    //spreading one value
-                    x[i] = (i)*(int)(1/x_resolution)+(int)(1/x_resolution/2);
-                    double value = m.getValue(mSelect,i);
-                    if(Double.isNaN(value)){
-                        corrupted = true;
-                        break;
-                    }
-                    y[i] = (int)(height-(value/max_value)*height);
-                    
-                }
-            }
-            if(!corrupted){
-                g.setColor(color);
-                g.drawPolyline(x, y, n);
-            }
-            
-    }
-
-    private void paintEvents(Graphics g){
-       if(clusterEvents!=null){
-            g.setColor(Color.DARK_GRAY);
-            for (int i = 0; i < clusterEvents.size(); i++) {
-                int x = (int)(clusterEvents.get(i).getTimestamp()/processFrequency/x_resolution);
-
-                g.drawLine(x, 0, x, getHeight());
-            }
-        }
-    }
-
-    public void setYMinMaxValues(double min, double max){
-        min_value = min;
-        max_value = max;
-    }
-
-    void setClusterEventsList(ArrayList<ClusterEvent> clusterEvents) {
-        this.clusterEvents = clusterEvents;
-    }
-
-    @Override
-    public Dimension getPreferredSize() {
-        return super.getPreferredSize();
-    }
-
-    void setXResolution(double x_resolution) {
-        this.x_resolution = x_resolution;
-    }
-    
-    /** This method is called from within the constructor to
-     * initialize the form.
-     * WARNING: Do NOT modify this code. The content of this method is
-     * always regenerated by the Form Editor.
-     */
-    @SuppressWarnings("unchecked")
-    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
-    private void initComponents() {
-
-        setOpaque(false);
-
-        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
-        this.setLayout(layout);
-        layout.setHorizontalGroup(
-            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 1000, Short.MAX_VALUE)
-        );
-        layout.setVerticalGroup(
-            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 300, Short.MAX_VALUE)
-        );
-    }// </editor-fold>//GEN-END:initComponents
-
-
-
-
-
-
-
-    // Variables declaration - do not modify//GEN-BEGIN:variables
-    // End of variables declaration//GEN-END:variables
+	private double min_value = 0;
+	private double max_value = 1;
+	private MeasureCollection measure0 = null;
+	private MeasureCollection measure1 = null;
+	private int measureSelected = 0;
+
+	private double x_resolution;
+	private int processFrequency;
+
+	private ArrayList<ClusterEvent> clusterEvents;
+
+	/** Creates new form GraphCurve */
+	public GraphCurve() {
+		initComponents();
+	}
+
+	public void setGraph(MeasureCollection measure0, MeasureCollection measure1, int selection) {
+		this.measure0 = measure0;
+		this.measure1 = measure1;
+		this.measureSelected = selection;
+		repaint();
+	}
+
+	void setProcessFrequency(int processFrequency) {
+		this.processFrequency = processFrequency;
+	}
+
+	@Override
+	protected void paintComponent(Graphics g) {
+		super.paintComponent(g);
+
+		g.setColor(Color.BLACK);
+
+		if (measure0 != null && measure1 != null) {
+			paintFullCurve(g, measure0, measureSelected, Color.red);
+			paintFullCurve(g, measure1, measureSelected, Color.blue);
+		} else {
+			if (measure0 != null) {
+				paintFullCurve(g, measure0, measureSelected, Color.red);
+			}
+		}
+		paintEvents(g);
+
+	}
+
+	private void paintFullCurve(Graphics g, MeasureCollection m, int mSelect, Color color) {
+		if (m.getNumberOfValues(mSelect) == 0)
+			return;
+
+		boolean corrupted = false;
+		int height = getHeight();
+		int width = getWidth();
+		int n = m.getNumberOfValues(mSelect);
+		if (x_resolution > 1)
+			n = n / (int) x_resolution;
+		int[] x = new int[n];
+		int[] y = new int[n];
+
+		for (int i = 0; i < n; i++) {
+			if (x_resolution > 1) {
+				// we need to compress the values
+				double sum_y = 0;
+				int counter = 0;
+				for (int j = 0; j < x_resolution; j++) {
+					if ((i) * x_resolution + j < m.getNumberOfValues(mSelect)) {
+						sum_y += m.getValue(mSelect, i);
+						counter++;
+					}
+					sum_y /= counter;
+				}
+				x[i] = i;
+				y[i] = (int) (height - (sum_y / max_value) * height);
+			} else {
+				// spreading one value
+				x[i] = (i) * (int) (1 / x_resolution) + (int) (1 / x_resolution / 2);
+				double value = m.getValue(mSelect, i);
+				if (Double.isNaN(value)) {
+					corrupted = true;
+					break;
+				}
+				y[i] = (int) (height - (value / max_value) * height);
+
+			}
+		}
+		if (!corrupted) {
+			g.setColor(color);
+			g.drawPolyline(x, y, n);
+		}
+
+	}
+
+	private void paintEvents(Graphics g) {
+		if (clusterEvents != null) {
+			g.setColor(Color.DARK_GRAY);
+			for (int i = 0; i < clusterEvents.size(); i++) {
+				int x = (int) (clusterEvents.get(i).getTimestamp() / processFrequency / x_resolution);
+
+				g.drawLine(x, 0, x, getHeight());
+			}
+		}
+	}
+
+	public void setYMinMaxValues(double min, double max) {
+		min_value = min;
+		max_value = max;
+	}
+
+	void setClusterEventsList(ArrayList<ClusterEvent> clusterEvents) {
+		this.clusterEvents = clusterEvents;
+	}
+
+	@Override
+	public Dimension getPreferredSize() {
+		return super.getPreferredSize();
+	}
+
+	void setXResolution(double x_resolution) {
+		this.x_resolution = x_resolution;
+	}
+
+	/**
+	 * This method is called from within the constructor to initialize the form.
+	 * WARNING: Do NOT modify this code. The content of this method is always
+	 * regenerated by the Form Editor.
+	 */
+	@SuppressWarnings("unchecked")
+	// <editor-fold defaultstate="collapsed" desc="Generated
+	// Code">//GEN-BEGIN:initComponents
+	private void initComponents() {
+
+		setOpaque(false);
+
+		javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
+		this.setLayout(layout);
+		layout.setHorizontalGroup(
+				layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 1000, Short.MAX_VALUE));
+		layout.setVerticalGroup(
+				layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 300, Short.MAX_VALUE));
+	}// </editor-fold>//GEN-END:initComponents
+
+	// Variables declaration - do not modify//GEN-BEGIN:variables
+	// End of variables declaration//GEN-END:variables
 
 }
diff --git a/moa/src/main/java/moa/gui/visualization/GraphMultiCurve.java b/moa/src/main/java/moa/gui/visualization/GraphMultiCurve.java
index 14594c04a..df29932ba 100644
--- a/moa/src/main/java/moa/gui/visualization/GraphMultiCurve.java
+++ b/moa/src/main/java/moa/gui/visualization/GraphMultiCurve.java
@@ -39,79 +39,82 @@ public class GraphMultiCurve extends AbstractGraphPlot {
 //    private int[] processFrequencies;
 //    private int min_processFrequency;
 
-    /**
-     * Updates the measure collection information and repaints the curves.
-     * @param measures 			 information about the curves
-     * @param measureStds		 standard deviation of the measures
-     * @param processFrequencies information about the process frequencies of
-     * 							 the curves
-     * @param colors			 color encodings of the curves
-     */
-    protected void setGraph(MeasureCollection[] measures, MeasureCollection[] measureStds, int[] processFrequencies, Color[] colors){
+	/**
+	 * Updates the measure collection information and repaints the curves.
+	 * 
+	 * @param measures           information about the curves
+	 * @param measureStds        standard deviation of the measures
+	 * @param processFrequencies information about the process frequencies of the
+	 *                           curves
+	 * @param colors             color encodings of the curves
+	 */
+	protected void setGraph(MeasureCollection[] measures, MeasureCollection[] measureStds, int[] processFrequencies,
+			Color[] colors) {
 //    	this.processFrequencies = processFrequencies;   
-    	super.setGraph(measures, measureStds, colors);
-    }
-
-    /**
-     * Sets the minimum process frequency, which may be used to stretch or
-     * compress curves.
-     * NOTE this is currently not implemented
-     * @param min_processFrequency minimum process frequency
-     */
-    protected void setProcessFrequency(int min_processFrequency) {
+		super.setGraph(measures, measureStds, colors);
+	}
+
+	/**
+	 * Sets the minimum process frequency, which may be used to stretch or compress
+	 * curves. NOTE this is currently not implemented
+	 * 
+	 * @param min_processFrequency minimum process frequency
+	 */
+	protected void setProcessFrequency(int min_processFrequency) {
 //        this.min_processFrequency = min_processFrequency;
-    }
+	}
 
-    @Override
-    protected void paintComponent(Graphics g) {
-        super.paintComponent(g);
+	@Override
+	protected void paintComponent(Graphics g) {
+		super.paintComponent(g);
 
-        if (this.measures == null) { 
-        	// no measures received yet -> nothing to paint
-        	return; 
-        }
+		if (this.measures == null) {
+			// no measures received yet -> nothing to paint
+			return;
+		}
 
-        // paint all curves
-        for (int i = 0; i < this.measures.length; i++) {
-        	paintFullCurve(g, i);
-        }
+		// paint all curves
+		for (int i = 0; i < this.measures.length; i++) {
+			paintFullCurve(g, i);
+		}
 
-    }
+	}
 
-    /**
-     * Draws a single curve on the canvas.
-     * @param g 	  the Graphics context in which to paint
-	 * @param i       index of the currently selected measure
-     */
-    private void paintFullCurve(Graphics g, int i){
-            if (this.measures[i].getNumberOfValues(this.measureSelected) == 0) {
-            	// no values of this measure available
-            	return;
-            }
+	/**
+	 * Draws a single curve on the canvas.
+	 * 
+	 * @param g the Graphics context in which to paint
+	 * @param i index of the currently selected measure
+	 */
+	private void paintFullCurve(Graphics g, int i) {
+		if (this.measures[i].getNumberOfValues(this.measureSelected) == 0) {
+			// no values of this measure available
+			return;
+		}
 
-            g.setColor(this.colors[i]);
+		g.setColor(this.colors[i]);
 
-            int height = getHeight();
+		int height = getHeight();
 
 //          // compute the relation of minimum PF and current PF
 //          double processFrequencyFactor = pf / this.min_processFrequency;
 
-            int n = this.measures[i].getNumberOfValues(this.measureSelected);
+		int n = this.measures[i].getNumberOfValues(this.measureSelected);
 
-            int[] x = new int[n];
-            int[] y = new int[n];
+		int[] x = new int[n];
+		int[] y = new int[n];
 
-            for (int j = 0; j < n; j++) {
-            	x[j] = (int) (j * x_resolution);
-            	y[j] = (int)(height-(this.measures[i].getValue(this.measureSelected, j)/this.upper_y_value)*height);
+		for (int j = 0; j < n; j++) {
+			x[j] = (int) (j * x_resolution);
+			y[j] = (int) (height - (this.measures[i].getValue(this.measureSelected, j) / this.upper_y_value) * height);
 
-            	if (this.isStandardDeviationPainted) {
-            	    int len = (int) ((this.measureStds[i].getValue(this.measureSelected, j)/this.upper_y_value)*height);
-            	    paintStandardDeviation(g, len, x[j], y[j]);
-            	}
-            }
+			if (this.isStandardDeviationPainted) {
+				int len = (int) ((this.measureStds[i].getValue(this.measureSelected, j) / this.upper_y_value) * height);
+				paintStandardDeviation(g, len, x[j], y[j]);
+			}
+		}
 
-            g.drawPolyline(x, y, n);
-    }
+		g.drawPolyline(x, y, n);
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/visualization/GraphScatter.java b/moa/src/main/java/moa/gui/visualization/GraphScatter.java
index b2893fb33..679bd78c3 100644
--- a/moa/src/main/java/moa/gui/visualization/GraphScatter.java
+++ b/moa/src/main/java/moa/gui/visualization/GraphScatter.java
@@ -36,68 +36,70 @@ public class GraphScatter extends AbstractGraphPlot {
 
 	private static final long serialVersionUID = 1L;
 
-    private static final int DOT_SIZE = 6;
-
-    private double[] variedParamValues;
-
-    /**
-     * Draws a scatter graph based on the varied parameter and the measures.
-     * @param measures list of measure collections, one for each task
-     * @param stds standard deviation values
-     * @param variedParamValues values of the varied parameter
-     * @param colors color encodings for the different tasks
-     */
-    public void setGraph(MeasureCollection[] measures, MeasureCollection[] stds, 
-    		double[] variedParamValues, Color[] colors) {
-        this.variedParamValues = variedParamValues;
-        super.setGraph(measures, stds, colors);
-    }
-
-    @Override
-    protected void paintComponent(Graphics g) {
-    	super.paintComponent(g);
-
-        if (this.measures == null || this.variedParamValues == null) { 
-        	// no measures received yet -> nothing to paint
-        	return; 
-        }
-
-        // scatter current param values
-        for (int i = 0; i < this.measures.length; i++) {
-                this.scatter(g, i);
-        }
-    }
-
-    /**
-     * Paint a dot onto the panel.
-     * @param g graphics object
-     * @param i index of the varied parameter
-     */
-    private void scatter(Graphics g, int i) {
-
-    	int height = getHeight();
-    	int width = getWidth();
-
-    	int x = (int)(((this.variedParamValues[i] - this.lower_x_value) / (this.upper_x_value - this.lower_x_value)) * width); 
-    	double value = this.measures[i].getLastValue(this.measureSelected);  
-
-        if(Double.isNaN(value)){
-        	// no result for this budget yet
-            return;
-        }
-
-        int y = (int)(height - (value / this.upper_y_value) * height);
-
-        g.setColor(this.colors[i]);
-
-        if (this.isStandardDeviationPainted) {
-            int len = (int) ((this.measureStds[i].getLastValue(this.measureSelected)/this.upper_y_value)*height);
-            paintStandardDeviation(g, len, x, y);
-        }
-
-    	g.fillOval(x - DOT_SIZE/2, y - DOT_SIZE/2, DOT_SIZE, DOT_SIZE);
-
-    }
+	private static final int DOT_SIZE = 6;
+
+	private double[] variedParamValues;
+
+	/**
+	 * Draws a scatter graph based on the varied parameter and the measures.
+	 * 
+	 * @param measures          list of measure collections, one for each task
+	 * @param stds              standard deviation values
+	 * @param variedParamValues values of the varied parameter
+	 * @param colors            color encodings for the different tasks
+	 */
+	public void setGraph(MeasureCollection[] measures, MeasureCollection[] stds, double[] variedParamValues,
+			Color[] colors) {
+		this.variedParamValues = variedParamValues;
+		super.setGraph(measures, stds, colors);
+	}
+
+	@Override
+	protected void paintComponent(Graphics g) {
+		super.paintComponent(g);
+
+		if (this.measures == null || this.variedParamValues == null) {
+			// no measures received yet -> nothing to paint
+			return;
+		}
+
+		// scatter current param values
+		for (int i = 0; i < this.measures.length; i++) {
+			this.scatter(g, i);
+		}
+	}
+
+	/**
+	 * Paint a dot onto the panel.
+	 * 
+	 * @param g graphics object
+	 * @param i index of the varied parameter
+	 */
+	private void scatter(Graphics g, int i) {
+
+		int height = getHeight();
+		int width = getWidth();
+
+		int x = (int) (((this.variedParamValues[i] - this.lower_x_value) / (this.upper_x_value - this.lower_x_value))
+				* width);
+		double value = this.measures[i].getLastValue(this.measureSelected);
+
+		if (Double.isNaN(value)) {
+			// no result for this budget yet
+			return;
+		}
+
+		int y = (int) (height - (value / this.upper_y_value) * height);
+
+		g.setColor(this.colors[i]);
+
+		if (this.isStandardDeviationPainted) {
+			int len = (int) ((this.measureStds[i].getLastValue(this.measureSelected) / this.upper_y_value) * height);
+			paintStandardDeviation(g, len, x, y);
+		}
+
+		g.fillOval(x - DOT_SIZE / 2, y - DOT_SIZE / 2, DOT_SIZE, DOT_SIZE);
+
+	}
 
 }
- 
\ No newline at end of file
diff --git a/moa/src/main/java/moa/gui/visualization/InfoPanel.java b/moa/src/main/java/moa/gui/visualization/InfoPanel.java
index 1c03f1a98..694028612 100644
--- a/moa/src/main/java/moa/gui/visualization/InfoPanel.java
+++ b/moa/src/main/java/moa/gui/visualization/InfoPanel.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.gui.visualization;
@@ -24,38 +24,39 @@
 
 public class InfoPanel extends javax.swing.JPanel {
 
-    private JFrame infoFrame = null;
+	private JFrame infoFrame = null;
 
-    /** Creates new form InfoPanel */
-    public InfoPanel(JFrame infoFrame) {
-        this.infoFrame = infoFrame;
-        initComponents();
-    }
+	/** Creates new form InfoPanel */
+	public InfoPanel(JFrame infoFrame) {
+		this.infoFrame = infoFrame;
+		initComponents();
+	}
 
-    public void updateInfo(String text){
-        infoFrame.setVisible(true);
-        jTextPane1.setText(text);
-    }
-    /** This method is called from within the constructor to
-     * initialize the form.
-     * WARNING: Do NOT modify this code. The content of this method is
-     * always regenerated by the Form Editor.
-     */
-    @SuppressWarnings("unchecked")
-    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
-    private void initComponents() {
+	public void updateInfo(String text) {
+		infoFrame.setVisible(true);
+		jTextPane1.setText(text);
+	}
 
-        jTextPane1 = new javax.swing.JTextPane();
+	/**
+	 * This method is called from within the constructor to initialize the form.
+	 * WARNING: Do NOT modify this code. The content of this method is always
+	 * regenerated by the Form Editor.
+	 */
+	@SuppressWarnings("unchecked")
+	// <editor-fold defaultstate="collapsed" desc="Generated
+	// Code">//GEN-BEGIN:initComponents
+	private void initComponents() {
 
-        setLayout(new java.awt.GridLayout(1, 0));
+		jTextPane1 = new javax.swing.JTextPane();
 
-        jTextPane1.setEditable(false);
-        add(jTextPane1);
-    }// </editor-fold>//GEN-END:initComponents
+		setLayout(new java.awt.GridLayout(1, 0));
 
+		jTextPane1.setEditable(false);
+		add(jTextPane1);
+	}// </editor-fold>//GEN-END:initComponents
 
-    // Variables declaration - do not modify//GEN-BEGIN:variables
-    private javax.swing.JTextPane jTextPane1;
-    // End of variables declaration//GEN-END:variables
+	// Variables declaration - do not modify//GEN-BEGIN:variables
+	private javax.swing.JTextPane jTextPane1;
+	// End of variables declaration//GEN-END:variables
 
 }
diff --git a/moa/src/main/java/moa/gui/visualization/OutlierEvent.java b/moa/src/main/java/moa/gui/visualization/OutlierEvent.java
index e00a097ec..ed8d650c6 100644
--- a/moa/src/main/java/moa/gui/visualization/OutlierEvent.java
+++ b/moa/src/main/java/moa/gui/visualization/OutlierEvent.java
@@ -11,8 +11,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.gui.visualization;
@@ -22,35 +22,35 @@
  * @author mits
  */
 class OutlierEvent implements Comparable<OutlierEvent> {
-    public DataPoint point;
-    public boolean outlier;
-    public Long timestamp;
+	public DataPoint point;
+	public boolean outlier;
+	public Long timestamp;
+
+	public OutlierEvent(DataPoint point, boolean outlier, Long timestamp) {
+		this.point = point;
+		this.outlier = outlier;
+		this.timestamp = timestamp;
+	}
+
+	@Override
+	public int compareTo(OutlierEvent o) {
+		if (this.timestamp > o.timestamp)
+			return 1;
+		else if (this.timestamp < o.timestamp)
+			return -1;
+		else {
+			if (this.point.timestamp > o.point.timestamp)
+				return 1;
+			else if (this.point.timestamp < o.point.timestamp)
+				return -1;
+		}
 
-    public OutlierEvent(DataPoint point, boolean outlier, Long timestamp) {
-        this.point = point;
-        this.outlier = outlier;
-        this.timestamp = timestamp;
-    }
-    
-    @Override
-    public int compareTo(OutlierEvent o) { 
-        if (this.timestamp > o.timestamp)
-            return 1;
-        else if (this.timestamp < o.timestamp)
-            return -1;
-        else {
-            if (this.point.timestamp > o.point.timestamp)
-                return 1;
-            else if (this.point.timestamp < o.point.timestamp)
-                return -1;
-        }
-            
-        return 0;
-    }
+		return 0;
+	}
 
-    @Override
-    public boolean equals(Object o) {
-        return ( (this.timestamp == ((OutlierEvent) o).timestamp) && 
-                 (this.point.timestamp == ((OutlierEvent) o).point.timestamp) );
-    }
+	@Override
+	public boolean equals(Object o) {
+		return ((this.timestamp == ((OutlierEvent) o).timestamp)
+				&& (this.point.timestamp == ((OutlierEvent) o).point.timestamp));
+	}
 }
diff --git a/moa/src/main/java/moa/gui/visualization/OutlierPanel.java b/moa/src/main/java/moa/gui/visualization/OutlierPanel.java
index f917a0ad9..bf4c99286 100644
--- a/moa/src/main/java/moa/gui/visualization/OutlierPanel.java
+++ b/moa/src/main/java/moa/gui/visualization/OutlierPanel.java
@@ -15,8 +15,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.gui.visualization;
@@ -36,210 +36,208 @@
 import javax.swing.JPanel;
 
 import moa.cluster.SphereCluster;
-import moa.clusterers.outliers.MyBaseOutlierDetector;
-import moa.clusterers.outliers.MyBaseOutlierDetector.Outlier;
+import moa.learners.clusterers.outliers.MyBaseOutlierDetector;
+import moa.learners.clusterers.outliers.MyBaseOutlierDetector.Outlier;
 
 public class OutlierPanel extends JPanel {
-    private boolean bAntiAlias = false;
-    
-    private MyBaseOutlierDetector myOutlierDetector;
-    private Outlier myOutlier;
-    private SphereCluster cluster;
-    
-    JDialog frameInfo = null;
-
-    private double[] center;
-    private final static int DRAW_SIZE = 4;
-    protected double decay_rate;
-
-    protected int x_dim = 0;
-    protected int y_dim = 1;
-    protected Color col;
-    protected Color default_color = Color.BLACK;
-
-    protected StreamOutlierPanel streamPanel;
-
-    protected int panel_size;
-    protected int window_size;
-    protected boolean highligted = false;
-    private double r;
-
-    /** Creates new form ObjectPanel */
-
-    public OutlierPanel(MyBaseOutlierDetector myOutlierDetector, Outlier outlier, SphereCluster cluster, Color color, StreamOutlierPanel sp) {
-        this.myOutlierDetector = myOutlierDetector;
-        this.myOutlier = outlier;
-        this.cluster = cluster;
-        center = cluster.getCenter();
-        r = cluster.getRadius();
-        streamPanel = sp;
-
-        default_color = col = color;
-
-        setVisible(true);
-        setOpaque(false);
-        setSize(new Dimension(1,1));
-        setLocation(0,0);
-
-        initComponents();
-    }
-
-    public void setDirection(double[] direction){
-    }
-
-    public void updateLocation(){
-        x_dim = streamPanel.getActiveXDim();
-        y_dim = streamPanel.getActiveYDim();
-
-        if ((cluster != null) && (center == null)) {
-            getParent().remove(this);
-        } else {
-            //size of the parent
-            window_size = Math.min(streamPanel.getWidth(), streamPanel.getHeight());
-            
-            panel_size = DRAW_SIZE + 1;
-
-            setSize(new Dimension(panel_size, panel_size));
-            
-            int x = (int) Math.round(center[x_dim] * window_size);
-            int y = (int) Math.round(center[y_dim] * window_size);
-            setLocation((int)(x - (panel_size / 2)), (int)(y - (panel_size / 2)));
-        }
-    }
-
-    public void updateTooltip(){
-        /*setToolTipText(cluster.getInfo());        
-        ToolTipManager.sharedInstance().registerComponent(this);
-        ToolTipManager.sharedInstance().setInitialDelay(0);*/
-    }
-
-    @Override
-    public boolean contains(int x, int y) {
-        //only react on the hull of the cluster
-        double dist = Math.sqrt(Math.pow(x-panel_size/2,2)+Math.pow(y-panel_size/2,2));
-        if(panel_size/2 - 5 < dist && dist < panel_size/2 + 5)
-            return true;
-        else
-            return false;
-    }
-
-    /** This method is called from within the constructor to
-     * initialize the form.
-     * WARNING: Do NOT modify this code. The content of this method is
-     * always regenerated by the Form Editor.
-     */
-    @SuppressWarnings("unchecked")
-    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
-    private void initComponents() {
-
-        addMouseListener(new java.awt.event.MouseAdapter() {
-            @Override
-            public void mouseClicked(java.awt.event.MouseEvent evt) {
-                formMouseClicked(evt);
-            }
-        });
-
-        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
-        this.setLayout(layout);
-        layout.setHorizontalGroup(
-            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 296, Short.MAX_VALUE)
-        );
-        layout.setVerticalGroup(
-            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 266, Short.MAX_VALUE)
-        );
-    }// </editor-fold>//GEN-END:initComponents
-
-    private void formMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_formMouseClicked
-        streamPanel.setHighlightedOutlierPanel(this);
-        showInfo();
-        streamPanel.setHighlightedOutlierPanel(null);
-    }//GEN-LAST:event_formMouseClicked
-
-    public String getInfo() {
-        return myOutlierDetector.getObjectInfo(myOutlier.obj);
-    }
-    
-    private void showInfo() {        
-        String title = "Outlier information";
-
-        JLabel comp = new JLabel();
-        comp.setText(getInfo());
-
-        JOptionPane pane = new JOptionPane(comp);
-        pane.setOptionType(JOptionPane.DEFAULT_OPTION);
-        pane.setMessageType(JOptionPane.PLAIN_MESSAGE);
-        
-        PointerInfo pointerInfo = MouseInfo.getPointerInfo();
-        Point mousePoint = pointerInfo.getLocation();
-        
-        JDialog dialog = pane.createDialog(this, title);        
-        dialog.setLocation(mousePoint);        
-        dialog.setVisible(true);
-    }
-    
-    @Override
-    protected void paintComponent(Graphics g) {
-        if (bAntiAlias) {            
-            Graphics2D g2d = (Graphics2D)g;
-            g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
-                    RenderingHints.VALUE_ANTIALIAS_ON);
-        }
-        
-        updateLocation();
-        if (highligted){
-            g.setColor(Color.ORANGE);
-        }
-        else{
-            g.setColor(default_color);
-        }
-        
-        int drawSize = DRAW_SIZE;
-        int drawStart = 0;
-        
-        g.fillOval(drawStart, drawStart, drawSize, drawSize);
-        g.drawOval(drawStart, drawStart, drawSize, drawSize);
-    }
-
-    public void highlight(boolean enabled){
-        highligted = enabled;
-        repaint();
-    }
-
-    public boolean isValidCluster(){
-        return (center!=null);
-    }
-
-    public int getClusterID(){
-        return (int)cluster.getId();
-    }
-
-    public int getClusterLabel(){
-        return (int)cluster.getGroundTruth();
-    }
-
-    public String getSVGString(int width){
-        StringBuffer out = new StringBuffer();
-
-        int x = (int)(center[x_dim]*window_size);
-        int y = (int)(center[y_dim]*window_size);
-        int radius = panel_size/2;
-        
-        out.append("<circle ");
-        out.append("cx='"+x+"' cy='"+y+"' r='"+radius+"'");
-        out.append(" stroke='green' stroke-width='1' fill='white' fill-opacity='0' />");
-        out.append("\n");
-        return out.toString();
-    }
-
-    public void drawOnCanvas(Graphics2D imageGraphics){
-        int x = (int)(center[x_dim]*window_size-(panel_size/2));
-        int y = (int)(center[y_dim]*window_size-(panel_size/2));
-        int radius = panel_size;
-        imageGraphics.drawOval(x, y, radius, radius);
-    }
-
-    // Variables declaration - do not modify//GEN-BEGIN:variables
-    // End of variables declaration//GEN-END:variables
+	private boolean bAntiAlias = false;
+
+	private MyBaseOutlierDetector myOutlierDetector;
+	private Outlier myOutlier;
+	private SphereCluster cluster;
+
+	JDialog frameInfo = null;
+
+	private double[] center;
+	private final static int DRAW_SIZE = 4;
+	protected double decay_rate;
+
+	protected int x_dim = 0;
+	protected int y_dim = 1;
+	protected Color col;
+	protected Color default_color = Color.BLACK;
+
+	protected StreamOutlierPanel streamPanel;
+
+	protected int panel_size;
+	protected int window_size;
+	protected boolean highligted = false;
+	private double r;
+
+	/** Creates new form ObjectPanel */
+
+	public OutlierPanel(MyBaseOutlierDetector myOutlierDetector, Outlier outlier, SphereCluster cluster, Color color,
+			StreamOutlierPanel sp) {
+		this.myOutlierDetector = myOutlierDetector;
+		this.myOutlier = outlier;
+		this.cluster = cluster;
+		center = cluster.getCenter();
+		r = cluster.getRadius();
+		streamPanel = sp;
+
+		default_color = col = color;
+
+		setVisible(true);
+		setOpaque(false);
+		setSize(new Dimension(1, 1));
+		setLocation(0, 0);
+
+		initComponents();
+	}
+
+	public void setDirection(double[] direction) {
+	}
+
+	public void updateLocation() {
+		x_dim = streamPanel.getActiveXDim();
+		y_dim = streamPanel.getActiveYDim();
+
+		if ((cluster != null) && (center == null)) {
+			getParent().remove(this);
+		} else {
+			// size of the parent
+			window_size = Math.min(streamPanel.getWidth(), streamPanel.getHeight());
+
+			panel_size = DRAW_SIZE + 1;
+
+			setSize(new Dimension(panel_size, panel_size));
+
+			int x = (int) Math.round(center[x_dim] * window_size);
+			int y = (int) Math.round(center[y_dim] * window_size);
+			setLocation(x - (panel_size / 2), y - (panel_size / 2));
+		}
+	}
+
+	public void updateTooltip() {
+		/*
+		 * setToolTipText(cluster.getInfo());
+		 * ToolTipManager.sharedInstance().registerComponent(this);
+		 * ToolTipManager.sharedInstance().setInitialDelay(0);
+		 */
+	}
+
+	@Override
+	public boolean contains(int x, int y) {
+		// only react on the hull of the cluster
+		double dist = Math.sqrt(Math.pow(x - panel_size / 2, 2) + Math.pow(y - panel_size / 2, 2));
+		if (panel_size / 2 - 5 < dist && dist < panel_size / 2 + 5)
+			return true;
+		else
+			return false;
+	}
+
+	/**
+	 * This method is called from within the constructor to initialize the form.
+	 * WARNING: Do NOT modify this code. The content of this method is always
+	 * regenerated by the Form Editor.
+	 */
+	@SuppressWarnings("unchecked")
+	// <editor-fold defaultstate="collapsed" desc="Generated
+	// Code">//GEN-BEGIN:initComponents
+	private void initComponents() {
+
+		addMouseListener(new java.awt.event.MouseAdapter() {
+			@Override
+			public void mouseClicked(java.awt.event.MouseEvent evt) {
+				formMouseClicked(evt);
+			}
+		});
+
+		javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
+		this.setLayout(layout);
+		layout.setHorizontalGroup(
+				layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 296, Short.MAX_VALUE));
+		layout.setVerticalGroup(
+				layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 266, Short.MAX_VALUE));
+	}// </editor-fold>//GEN-END:initComponents
+
+	private void formMouseClicked(java.awt.event.MouseEvent evt) {// GEN-FIRST:event_formMouseClicked
+		streamPanel.setHighlightedOutlierPanel(this);
+		showInfo();
+		streamPanel.setHighlightedOutlierPanel(null);
+	}// GEN-LAST:event_formMouseClicked
+
+	public String getInfo() {
+		return myOutlierDetector.getObjectInfo(myOutlier.obj);
+	}
+
+	private void showInfo() {
+		String title = "Outlier information";
+
+		JLabel comp = new JLabel();
+		comp.setText(getInfo());
+
+		JOptionPane pane = new JOptionPane(comp);
+		pane.setOptionType(JOptionPane.DEFAULT_OPTION);
+		pane.setMessageType(JOptionPane.PLAIN_MESSAGE);
+
+		PointerInfo pointerInfo = MouseInfo.getPointerInfo();
+		Point mousePoint = pointerInfo.getLocation();
+
+		JDialog dialog = pane.createDialog(this, title);
+		dialog.setLocation(mousePoint);
+		dialog.setVisible(true);
+	}
+
+	@Override
+	protected void paintComponent(Graphics g) {
+		if (bAntiAlias) {
+			Graphics2D g2d = (Graphics2D) g;
+			g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+		}
+
+		updateLocation();
+		if (highligted) {
+			g.setColor(Color.ORANGE);
+		} else {
+			g.setColor(default_color);
+		}
+
+		int drawSize = DRAW_SIZE;
+		int drawStart = 0;
+
+		g.fillOval(drawStart, drawStart, drawSize, drawSize);
+		g.drawOval(drawStart, drawStart, drawSize, drawSize);
+	}
+
+	public void highlight(boolean enabled) {
+		highligted = enabled;
+		repaint();
+	}
+
+	public boolean isValidCluster() {
+		return (center != null);
+	}
+
+	public int getClusterID() {
+		return (int) cluster.getId();
+	}
+
+	public int getClusterLabel() {
+		return (int) cluster.getGroundTruth();
+	}
+
+	public String getSVGString(int width) {
+		StringBuffer out = new StringBuffer();
+
+		int x = (int) (center[x_dim] * window_size);
+		int y = (int) (center[y_dim] * window_size);
+		int radius = panel_size / 2;
+
+		out.append("<circle ");
+		out.append("cx='" + x + "' cy='" + y + "' r='" + radius + "'");
+		out.append(" stroke='green' stroke-width='1' fill='white' fill-opacity='0' />");
+		out.append("\n");
+		return out.toString();
+	}
+
+	public void drawOnCanvas(Graphics2D imageGraphics) {
+		int x = (int) (center[x_dim] * window_size - (panel_size / 2));
+		int y = (int) (center[y_dim] * window_size - (panel_size / 2));
+		int radius = panel_size;
+		imageGraphics.drawOval(x, y, radius, radius);
+	}
+
+	// Variables declaration - do not modify//GEN-BEGIN:variables
+	// End of variables declaration//GEN-END:variables
 }
diff --git a/moa/src/main/java/moa/gui/visualization/ParamGraphAxes.java b/moa/src/main/java/moa/gui/visualization/ParamGraphAxes.java
index c765cff14..af6b78f66 100644
--- a/moa/src/main/java/moa/gui/visualization/ParamGraphAxes.java
+++ b/moa/src/main/java/moa/gui/visualization/ParamGraphAxes.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 package moa.gui.visualization;
 
@@ -26,43 +26,38 @@
 /**
  * ParamGraphAxes is an implementation of AbstractGraphAxes, drawing x labels
  * based on a parameter.
- * 
+ *
  * @author Tim Sabsch (tim.sabsch@ovgu.de)
  * @version $Revision: 1 $
  * @see AbstractGraphAxes
  */
 public class ParamGraphAxes extends AbstractGraphAxes {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    @Override
-    protected void drawXLabels(Graphics g) {
-        g.setColor(Color.BLACK);
+	@Override
+	protected void drawXLabels(Graphics g) {
+		g.setColor(Color.BLACK);
 
-        // x-axis markers + labels
-        DecimalFormat d = new DecimalFormat("0.00");
+		// x-axis markers + labels
+		DecimalFormat d = new DecimalFormat("0.00");
 
-        double numLabels = Math.min(Math.pow(2, (int) x_resolution), 32);
-        /*
-         * technically, this is numLabels-1, but as we're iterating 0 <= i <=
-         * numLabels, we need the extra label. Also don't draw more than 32
-         * labels.
-         */
+		double numLabels = Math.min(Math.pow(2, (int) x_resolution), 32);
+		/*
+		 * technically, this is numLabels-1, but as we're iterating 0 <= i <= numLabels,
+		 * we need the extra label. Also don't draw more than 32 labels.
+		 */
 
-        for (int i = 0; i <= numLabels; i++) {
-            double fraction = i / numLabels;
-            double value = lower_x_value + fraction * (upper_x_value - lower_x_value);
-            String label = d.format(value);
-            int str_length = g.getFontMetrics().stringWidth(label);
+		for (int i = 0; i <= numLabels; i++) {
+			double fraction = i / numLabels;
+			double value = lower_x_value + fraction * (upper_x_value - lower_x_value);
+			String label = d.format(value);
+			int str_length = g.getFontMetrics().stringWidth(label);
 
-            g.drawString(label,
-                    (int) (fraction * width) + X_OFFSET_LEFT - str_length / 2,
-                    height + Y_OFFSET_TOP + 18);
-            g.drawLine((int) (fraction * width) + X_OFFSET_LEFT,
-                    height + Y_OFFSET_TOP,
-                    (int) (fraction * width) + X_OFFSET_LEFT,
-                    height + Y_OFFSET_TOP + 5);
-        }
-    }
+			g.drawString(label, (int) (fraction * width) + X_OFFSET_LEFT - str_length / 2, height + Y_OFFSET_TOP + 18);
+			g.drawLine((int) (fraction * width) + X_OFFSET_LEFT, height + Y_OFFSET_TOP,
+					(int) (fraction * width) + X_OFFSET_LEFT, height + Y_OFFSET_TOP + 5);
+		}
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/visualization/ParamGraphCanvas.java b/moa/src/main/java/moa/gui/visualization/ParamGraphCanvas.java
index 879dee046..e429540cc 100644
--- a/moa/src/main/java/moa/gui/visualization/ParamGraphCanvas.java
+++ b/moa/src/main/java/moa/gui/visualization/ParamGraphCanvas.java
@@ -34,81 +34,75 @@
  */
 public class ParamGraphCanvas extends AbstractGraphCanvas {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    private double[] variedParamValues;
+	private double[] variedParamValues;
 
-    /**
-     * Initialises a ProcessGraphCanvas by calling the super constructor with a
-     * ParamGraphAxes as instance of AbstractGraphAxes and GraphScatter as
-     * instance of AbstractGraphPlot.
-     */
-    public ParamGraphCanvas() {
-        super(new ParamGraphAxes(), new GraphScatter());
-    }
+	/**
+	 * Initialises a ProcessGraphCanvas by calling the super constructor with a
+	 * ParamGraphAxes as instance of AbstractGraphAxes and GraphScatter as instance
+	 * of AbstractGraphPlot.
+	 */
+	public ParamGraphCanvas() {
+		super(new ParamGraphAxes(), new GraphScatter());
+	}
 
-    /**
-     * Sets the scatter graph.
-     *
-     * @param measures
-     *            information about the curves
-     * @param measureStds
-     *            standard deviation for the measures
-     * @param variedParamValues
-     *            values of the varied parameter
-     * @param colors
-     *            color encoding for the param array
-     */
-    public void setGraph(MeasureCollection[] measures, MeasureCollection[] measureStds,
-            double[] variedParamValues, Color[] colors) {
-        this.measures = measures;
-        this.variedParamValues = variedParamValues;
-        ((GraphScatter) this.plotPanel).setGraph(measures, measureStds,
-                variedParamValues, colors);
-        updateCanvas(false);
-    }
+	/**
+	 * Sets the scatter graph.
+	 *
+	 * @param measures          information about the curves
+	 * @param measureStds       standard deviation for the measures
+	 * @param variedParamValues values of the varied parameter
+	 * @param colors            color encoding for the param array
+	 */
+	public void setGraph(MeasureCollection[] measures, MeasureCollection[] measureStds, double[] variedParamValues,
+			Color[] colors) {
+		this.measures = measures;
+		this.variedParamValues = variedParamValues;
+		((GraphScatter) this.plotPanel).setGraph(measures, measureStds, variedParamValues, colors);
+		updateCanvas(false);
+	}
 
-    @Override
-    public double getMinXValue() {
-        if (this.variedParamValues == null) {
-            // no task with a varied param
-            return 0;
-        }
-        double min = Double.MAX_VALUE;
+	@Override
+	public double getMinXValue() {
+		if (this.variedParamValues == null) {
+			// no task with a varied param
+			return 0;
+		}
+		double min = Double.MAX_VALUE;
 
-        for (int i = 0; i < this.variedParamValues.length; i++) {
-            if (this.variedParamValues[i] < min) {
-                min = this.variedParamValues[i];
-            }
-        }
-        return min;
-    }
+		for (int i = 0; i < this.variedParamValues.length; i++) {
+			if (this.variedParamValues[i] < min) {
+				min = this.variedParamValues[i];
+			}
+		}
+		return min;
+	}
 
-    @Override
-    public double getMaxXValue() {
-        if (this.variedParamValues == null) {
-            // no task with a varied param
-            return 0;
-        }
-        double max = Double.MIN_VALUE;
+	@Override
+	public double getMaxXValue() {
+		if (this.variedParamValues == null) {
+			// no task with a varied param
+			return 0;
+		}
+		double max = Double.MIN_VALUE;
 
-        for (int i = 0; i < this.variedParamValues.length; i++) {
-            if (this.variedParamValues[i] > max) {
-                max = this.variedParamValues[i];
-            }
-        }
-        return max;
-    }
+		for (int i = 0; i < this.variedParamValues.length; i++) {
+			if (this.variedParamValues[i] > max) {
+				max = this.variedParamValues[i];
+			}
+		}
+		return max;
+	}
 
-    @Override
-    public void setSize() {
-        setSize((int) (baseWidth * x_resolution),
-                (int) (baseHeight * y_resolution));
-    }
+	@Override
+	public void setSize() {
+		setSize((int) (baseWidth * x_resolution), (int) (baseHeight * y_resolution));
+	}
 
-    @Override
-    public void setPreferredSize() {
-        setPreferredSize(new Dimension(getWidth(), getHeight()));
-    }
+	@Override
+	public void setPreferredSize() {
+		setPreferredSize(new Dimension(getWidth(), getHeight()));
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/visualization/PointPanel.java b/moa/src/main/java/moa/gui/visualization/PointPanel.java
index 56ee13c02..0983069b7 100644
--- a/moa/src/main/java/moa/gui/visualization/PointPanel.java
+++ b/moa/src/main/java/moa/gui/visualization/PointPanel.java
@@ -1,9 +1,9 @@
 /**
  * PointPanel.java
- * 
+ *
  * @author Timm Jansen (moa@cs.rwth-aachen.de)
  * @editor Yunsu Kim
- * 
+ *
  * Last edited: 2013/06/02
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,8 +17,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.gui.visualization;
@@ -31,266 +31,259 @@
 
 import javax.swing.JPanel;
 
-public class PointPanel extends JPanel{
-	
+public class PointPanel extends JPanel {
+
 	private static final long serialVersionUID = 1L;
-	
+
 	static final int POINTSIZE = 4;
-    DataPoint point;
-
-    protected int x_dim = 0;
-    protected int y_dim = 1;
-    protected Color col;
-    protected Color default_color = Color.BLACK;
-
-    protected int panel_size;
-    protected int window_size;
-    protected boolean highligted = false;
-
-    protected double decayRate;
-    protected double decayThreshold;
-    
-    protected int type;
-    protected final int TYPE_PLAIN = 0;
-    protected final int TYPE_CLUSTERED = 1;
-    
-    protected StreamPanel sp;
-
-
-    /**
-     * Type 1: Possibly be decayed, colored by class label.
-     * 
-     * @param point
-     * @param streamPanel
-     * @param decayRate
-     * @param decayThreshold
-     */
-    public PointPanel(DataPoint point, StreamPanel streamPanel, double decayRate, double decayThreshold) {
-    	this.point = point;
-        this.panel_size = POINTSIZE;
-        this.decayRate = decayRate;
-        this.decayThreshold = decayThreshold;
-        this.col = default_color;
-        this.sp = streamPanel;
-        this.type = TYPE_PLAIN;
-
-        setVisible(true);
-        setOpaque(false);
-        setSize(new Dimension(1, 1));
-        setLocation(0, 0);
-        initComponents();
-    }
-
-    /**
-     * Type 2: Never be decayed, single color.
-     * 
-     * @param point
-     * @param streamPanel
-     * @param color
-     */
-    public PointPanel(DataPoint point, StreamPanel streamPanel, Color color) {
-        this.point = point;
-        this.panel_size = POINTSIZE;
-        this.decayRate = 0;			// Never be decayed
-        this.decayThreshold = 0;
-        this.col = color;
-        this.sp = streamPanel;
-        this.type = TYPE_CLUSTERED;
-
-        setVisible(true);
-        setOpaque(false);
-        setSize(new Dimension(1, 1));
-        setLocation(0,0);
-        initComponents();
-    }
-
-    public void updateLocation(){
-    	window_size = Math.min(sp.getWidth(), sp.getHeight());
-
-        x_dim = sp.getActiveXDim();
-        y_dim = sp.getActiveYDim();
-
-        setSize(new Dimension(panel_size + 1, panel_size + 1));
-        setLocation((int)(point.value(x_dim) * window_size - (panel_size / 2)), (int)(point.value(y_dim) * window_size - (panel_size / 2)));
-    }
-
-    /** This method is called from within the constructor to
-     * initialize the form.
-     * WARNING: Do NOT modify this code. The content of this method is
-     * always regenerated by the Form Editor.
-     */
-    @SuppressWarnings("unchecked")
-    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
-    private void initComponents() {
-
-        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
-        this.setLayout(layout);
-        layout.setHorizontalGroup(
-            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 296, Short.MAX_VALUE)
-        );
-        layout.setVerticalGroup(
-            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 266, Short.MAX_VALUE)
-        );
-    }// </editor-fold>//GEN-END:initComponents
-
-    @Override
-    protected void paintComponent(Graphics g) {
-    	if (type == TYPE_PLAIN) {
-	    	point.updateWeight(RunVisualizer.getCurrentTimestamp(), decayRate);
-	        if (point.weight() < decayThreshold) {
-	            getParent().remove(this);
-	            return;
-	        }
-        }
-
-        Color color = getColor();
-      //Color errcolor = getErrorColor();
-        //if (errcolor == null) {
-        //    errcolor = color;
-            panel_size = POINTSIZE;
-        //} else {
-        //    panel_size = POINTSIZE + 2;
-        //}
-        
-        updateLocation();
-        
-        /*g.setColor(errcolor);
-        g.drawOval(0, 0, panel_size, panel_size);
-        g.setColor(color);
-        g.fillOval(0, 0, panel_size, panel_size);*/
-        
-        if (type == TYPE_PLAIN) {
-        	g.setColor(color);
-        	if (point.isNoise()) {
-        		g.setFont(g.getFont().deriveFont(9.0f));
-        		g.drawChars(new char[] {'x'}, 0, 1, 0, panel_size);
-        	} else {
-		        g.drawOval(0, 0, panel_size, panel_size);
-		        g.setColor(color);
-		        g.fillOval(0, 0, panel_size, panel_size);
-        	}
-        } else if (type == TYPE_CLUSTERED) {
-        	g.setColor(color);
-        	g.drawOval(0, 0, panel_size, panel_size);
-        }
-
-        setToolTipText(point.getInfo(x_dim, y_dim));
-    }
-
-            
-
-    private Color getErrorColor(){
-        String cmdvalue = point.getMeasureValue("CMM");
-        Color color = null;
-        if(!cmdvalue.equals("")){
-            double err = Double.parseDouble(cmdvalue);
-            if(err > 0.00001){
-                if(err > 0.7) err = 1;
-                int alpha = (int)(100+155*err);
-                color = new Color(255, 0, 0, alpha);
-            }
-            if(err == 0.00001){
-                color = new Color(255, 0, 0,100);
-            }
-        }
-        return color;
-    }
-
-    private Color getColor(){
-        Color color = null;
-
-        if (type == TYPE_PLAIN) {
-            ClusterPanel cp = sp.getHighlightedClusterPanel();
-            
-            if (cp != null) {
-                if (cp.getClusterLabel() == point.classValue()) {
-                    color = Color.BLUE;
-                }
-            }
-            
-            if (color == null) {
-                int alpha = (int)(point.weight() * 200 + 55);
-                float numCl = 10;
-                
-                Color c;
-                if (point.isNoise()) {
-                	c = Color.GRAY;
-                } else {
-                	c = getPointColorbyClass(point, numCl);
-                }
-
-                color = new Color(c.getRed(), c.getGreen(), c.getBlue(), alpha);
-            }
-        } else if (type == TYPE_CLUSTERED) {
-        	color = this.col;
-        }
-                
-        return color;
-    }
-
-    public static Color getPointColorbyClass(DataPoint point, float numClasses){
-        Color c;
-        int classValue = (int)point.classValue();
-        
-        if (classValue != point.noiseLabel) {
-            c = new Color(Color.HSBtoRGB((float)((classValue+1)/numClasses), 1f, 240f/240));
-        } else {
-            c = Color.GRAY;
-        }
-        return c;
-    }
-
-
-    public void highlight(boolean enabled){
-        highligted = enabled;
-        repaint();
-    }
-
-
-    public String getObjectInfo(){
-        return point.getInfo(x_dim, y_dim);
-    }
-
-    @Override
-    public String getToolTipText() {
-        return super.getToolTipText();
-    }
-
-
-    // Variables declaration - do not modify//GEN-BEGIN:variables
-    // End of variables declaration//GEN-END:variables
-
-
-    public String getSVGString(int width){
-        StringBuffer out = new StringBuffer();
-
-        int x = (int)(point.value(x_dim)*window_size);
-        int y = (int)(point.value(y_dim)*window_size);
-        int radius = panel_size/2;
-        //radius = 1;
-
-        Color c = getColor();
-
-        String color = "rgb("+c.getRed()+","+c.getGreen()+","+c.getBlue()+")";
-        double trans = c.getAlpha()/255.0;
-
-        out.append("<circle ");
-        out.append("cx='"+x+"' cy='"+y+"' r='"+radius+"'");
-        out.append(" stroke='"+color+"' stroke-width='0' fill='"+color+"' fill-opacity='"+trans+"' stroke-opacity='"+trans+"'/>");
-        out.append("\n");
-        return out.toString();
-    }
-
-    public void drawOnCanvas(Graphics2D imageGraphics) {
-    	Point location = getLocation();
-    	
-        if (type == TYPE_PLAIN) {
-	        imageGraphics.drawOval(location.x, location.y, panel_size, panel_size);
-	        imageGraphics.fillOval(location.x, location.y, panel_size, panel_size);
-        } else if (type == TYPE_CLUSTERED) {
-        	imageGraphics.drawOval(location.x, location.y, panel_size, panel_size);
-        }
-    }
+	DataPoint point;
+
+	protected int x_dim = 0;
+	protected int y_dim = 1;
+	protected Color col;
+	protected Color default_color = Color.BLACK;
+
+	protected int panel_size;
+	protected int window_size;
+	protected boolean highligted = false;
+
+	protected double decayRate;
+	protected double decayThreshold;
+
+	protected int type;
+	protected final int TYPE_PLAIN = 0;
+	protected final int TYPE_CLUSTERED = 1;
+
+	protected StreamPanel sp;
+
+	/**
+	 * Type 1: Possibly be decayed, colored by class label.
+	 * 
+	 * @param point
+	 * @param streamPanel
+	 * @param decayRate
+	 * @param decayThreshold
+	 */
+	public PointPanel(DataPoint point, StreamPanel streamPanel, double decayRate, double decayThreshold) {
+		this.point = point;
+		this.panel_size = POINTSIZE;
+		this.decayRate = decayRate;
+		this.decayThreshold = decayThreshold;
+		this.col = default_color;
+		this.sp = streamPanel;
+		this.type = TYPE_PLAIN;
+
+		setVisible(true);
+		setOpaque(false);
+		setSize(new Dimension(1, 1));
+		setLocation(0, 0);
+		initComponents();
+	}
+
+	/**
+	 * Type 2: Never be decayed, single color.
+	 * 
+	 * @param point
+	 * @param streamPanel
+	 * @param color
+	 */
+	public PointPanel(DataPoint point, StreamPanel streamPanel, Color color) {
+		this.point = point;
+		this.panel_size = POINTSIZE;
+		this.decayRate = 0; // Never be decayed
+		this.decayThreshold = 0;
+		this.col = color;
+		this.sp = streamPanel;
+		this.type = TYPE_CLUSTERED;
+
+		setVisible(true);
+		setOpaque(false);
+		setSize(new Dimension(1, 1));
+		setLocation(0, 0);
+		initComponents();
+	}
+
+	public void updateLocation() {
+		window_size = Math.min(sp.getWidth(), sp.getHeight());
+
+		x_dim = sp.getActiveXDim();
+		y_dim = sp.getActiveYDim();
+
+		setSize(new Dimension(panel_size + 1, panel_size + 1));
+		setLocation((int) (point.value(x_dim) * window_size - (panel_size / 2)),
+				(int) (point.value(y_dim) * window_size - (panel_size / 2)));
+	}
+
+	/**
+	 * This method is called from within the constructor to initialize the form.
+	 * WARNING: Do NOT modify this code. The content of this method is always
+	 * regenerated by the Form Editor.
+	 */
+	@SuppressWarnings("unchecked")
+	// <editor-fold defaultstate="collapsed" desc="Generated
+	// Code">//GEN-BEGIN:initComponents
+	private void initComponents() {
+
+		javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
+		this.setLayout(layout);
+		layout.setHorizontalGroup(
+				layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 296, Short.MAX_VALUE));
+		layout.setVerticalGroup(
+				layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 266, Short.MAX_VALUE));
+	}// </editor-fold>//GEN-END:initComponents
+
+	@Override
+	protected void paintComponent(Graphics g) {
+		if (type == TYPE_PLAIN) {
+			point.updateWeight(RunVisualizer.getCurrentTimestamp(), decayRate);
+			if (point.weight() < decayThreshold) {
+				getParent().remove(this);
+				return;
+			}
+		}
+
+		Color color = getColor();
+		// Color errcolor = getErrorColor();
+		// if (errcolor == null) {
+		// errcolor = color;
+		panel_size = POINTSIZE;
+		// } else {
+		// panel_size = POINTSIZE + 2;
+		// }
+
+		updateLocation();
+
+		/*
+		 * g.setColor(errcolor); g.drawOval(0, 0, panel_size, panel_size);
+		 * g.setColor(color); g.fillOval(0, 0, panel_size, panel_size);
+		 */
+
+		if (type == TYPE_PLAIN) {
+			g.setColor(color);
+			if (point.isNoise()) {
+				g.setFont(g.getFont().deriveFont(9.0f));
+				g.drawChars(new char[] { 'x' }, 0, 1, 0, panel_size);
+			} else {
+				g.drawOval(0, 0, panel_size, panel_size);
+				g.setColor(color);
+				g.fillOval(0, 0, panel_size, panel_size);
+			}
+		} else if (type == TYPE_CLUSTERED) {
+			g.setColor(color);
+			g.drawOval(0, 0, panel_size, panel_size);
+		}
+
+		setToolTipText(point.getInfo(x_dim, y_dim));
+	}
+
+	private Color getErrorColor() {
+		String cmdvalue = point.getMeasureValue("CMM");
+		Color color = null;
+		if (!cmdvalue.equals("")) {
+			double err = Double.parseDouble(cmdvalue);
+			if (err > 0.00001) {
+				if (err > 0.7)
+					err = 1;
+				int alpha = (int) (100 + 155 * err);
+				color = new Color(255, 0, 0, alpha);
+			}
+			if (err == 0.00001) {
+				color = new Color(255, 0, 0, 100);
+			}
+		}
+		return color;
+	}
+
+	private Color getColor() {
+		Color color = null;
+
+		if (type == TYPE_PLAIN) {
+			ClusterPanel cp = sp.getHighlightedClusterPanel();
+
+			if (cp != null) {
+				if (cp.getClusterLabel() == point.classValue()) {
+					color = Color.BLUE;
+				}
+			}
+
+			if (color == null) {
+				int alpha = (int) (point.weight() * 200 + 55);
+				float numCl = 10;
+
+				Color c;
+				if (point.isNoise()) {
+					c = Color.GRAY;
+				} else {
+					c = getPointColorbyClass(point, numCl);
+				}
+
+				color = new Color(c.getRed(), c.getGreen(), c.getBlue(), alpha);
+			}
+		} else if (type == TYPE_CLUSTERED) {
+			color = this.col;
+		}
+
+		return color;
+	}
+
+	public static Color getPointColorbyClass(DataPoint point, float numClasses) {
+		Color c;
+		int classValue = (int) point.classValue();
+
+		if (classValue != point.noiseLabel) {
+			c = new Color(Color.HSBtoRGB((classValue + 1) / numClasses, 1f, 240f / 240));
+		} else {
+			c = Color.GRAY;
+		}
+		return c;
+	}
+
+	public void highlight(boolean enabled) {
+		highligted = enabled;
+		repaint();
+	}
+
+	public String getObjectInfo() {
+		return point.getInfo(x_dim, y_dim);
+	}
+
+	@Override
+	public String getToolTipText() {
+		return super.getToolTipText();
+	}
+
+	// Variables declaration - do not modify//GEN-BEGIN:variables
+	// End of variables declaration//GEN-END:variables
+
+	public String getSVGString(int width) {
+		StringBuffer out = new StringBuffer();
+
+		int x = (int) (point.value(x_dim) * window_size);
+		int y = (int) (point.value(y_dim) * window_size);
+		int radius = panel_size / 2;
+		// radius = 1;
+
+		Color c = getColor();
+
+		String color = "rgb(" + c.getRed() + "," + c.getGreen() + "," + c.getBlue() + ")";
+		double trans = c.getAlpha() / 255.0;
+
+		out.append("<circle ");
+		out.append("cx='" + x + "' cy='" + y + "' r='" + radius + "'");
+		out.append(" stroke='" + color + "' stroke-width='0' fill='" + color + "' fill-opacity='" + trans
+				+ "' stroke-opacity='" + trans + "'/>");
+		out.append("\n");
+		return out.toString();
+	}
+
+	public void drawOnCanvas(Graphics2D imageGraphics) {
+		Point location = getLocation();
+
+		if (type == TYPE_PLAIN) {
+			imageGraphics.drawOval(location.x, location.y, panel_size, panel_size);
+			imageGraphics.fillOval(location.x, location.y, panel_size, panel_size);
+		} else if (type == TYPE_CLUSTERED) {
+			imageGraphics.drawOval(location.x, location.y, panel_size, panel_size);
+		}
+	}
 }
diff --git a/moa/src/main/java/moa/gui/visualization/ProcessGraphAxes.java b/moa/src/main/java/moa/gui/visualization/ProcessGraphAxes.java
index 51185b422..ae5b20b08 100644
--- a/moa/src/main/java/moa/gui/visualization/ProcessGraphAxes.java
+++ b/moa/src/main/java/moa/gui/visualization/ProcessGraphAxes.java
@@ -1,7 +1,7 @@
 /*
  *    ProcessGraphAxes.java
  *    Copyright (C) 2017 Otto-von-Guericke-University, Germany
- *    @author Tim Sabsch (tim.sabsch@ovgu.de) 
+ *    @author Tim Sabsch (tim.sabsch@ovgu.de)
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.gui.visualization;
@@ -25,7 +25,7 @@
 /**
  * ProcessGraphAxes is an implementation of AbstractGraphAxes, drawing x labels
  * based on the process frequency.
- * 
+ *
  * @author Tim Sabsch (tim.sabsch@ovgu.de)
  * @version $Revision: 1 $
  * @see AbstractGraphAxes
@@ -34,30 +34,30 @@ public class ProcessGraphAxes extends AbstractGraphAxes {
 
 	private static final long serialVersionUID = 1L;
 
-    private int processFrequency;
+	private int processFrequency;
 
-    /**
-     * Sets the process frequency
-     * @param frequency new process frequency
-     */
-    public void setProcessFrequency(int frequency){
-        processFrequency = frequency;
-    }
+	/**
+	 * Sets the process frequency
+	 * 
+	 * @param frequency new process frequency
+	 */
+	public void setProcessFrequency(int frequency) {
+		processFrequency = frequency;
+	}
 
 	@Override
 	protected void drawXLabels(Graphics g) {
-        //x axis labels
-        int w = 100;
+		// x axis labels
+		int w = 100;
 
-        for (int i = 0; w*i < width-X_OFFSET_RIGHT; i++) {
-            g.drawLine(w*i+X_OFFSET_LEFT, height+Y_OFFSET_TOP, 
-            		   w*i+X_OFFSET_LEFT, height+Y_OFFSET_TOP+5);
+		for (int i = 0; w * i < width - X_OFFSET_RIGHT; i++) {
+			g.drawLine(w * i + X_OFFSET_LEFT, height + Y_OFFSET_TOP, w * i + X_OFFSET_LEFT, height + Y_OFFSET_TOP + 5);
 
-            String label = Integer.toString((int)(w*i*processFrequency/x_resolution));
+			String label = Integer.toString((int) (w * i * processFrequency / x_resolution));
 
-            int str_length = g.getFontMetrics().stringWidth(label);
-            g.drawString(label,w*i+X_OFFSET_LEFT-str_length/2,height+Y_OFFSET_TOP+18);
-        }	
+			int str_length = g.getFontMetrics().stringWidth(label);
+			g.drawString(label, w * i + X_OFFSET_LEFT - str_length / 2, height + Y_OFFSET_TOP + 18);
+		}
 	}
 
 }
diff --git a/moa/src/main/java/moa/gui/visualization/ProcessGraphCanvas.java b/moa/src/main/java/moa/gui/visualization/ProcessGraphCanvas.java
index 2764cd8fa..99937a755 100644
--- a/moa/src/main/java/moa/gui/visualization/ProcessGraphCanvas.java
+++ b/moa/src/main/java/moa/gui/visualization/ProcessGraphCanvas.java
@@ -43,8 +43,8 @@ public class ProcessGraphCanvas extends AbstractGraphCanvas {
 	/**
 	 * Initialises a ProcessGraphCanvas by calling the super constructor with a
 	 * ProcessGraphAxes as instance of AbstractGraphAxes and GraphMultiCurve as
-	 * instance of AbstractGraphPlot. Also sets the min_processfrequency to
-	 * initial value.
+	 * instance of AbstractGraphPlot. Also sets the min_processfrequency to initial
+	 * value.
 	 */
 	public ProcessGraphCanvas() {
 		super(new ProcessGraphAxes(), new GraphMultiCurve());
@@ -63,7 +63,7 @@ public int getMinProcessFrequency() {
 
 	/**
 	 * Returns the list of registered process frequencies.
-	 * 
+	 *
 	 * @return list of registered process frequencies
 	 */
 	public int[] getProcessFrequencies() {
@@ -73,19 +73,15 @@ public int[] getProcessFrequencies() {
 	/**
 	 * Sets the graph containing multiple curves.
 	 *
-	 * @param measures
-	 *            information about the curves
-	 * @param measureStds
-	 * 			  standard deviation values for the measures
-	 * @param processFrequencies
-	 *            information about the process frequencies of the curves
-	 * @param min_processFrequency
-	 *            minimum process frequency
-	 * @param colors
-	 *            color encodings for the curves
+	 * @param measures             information about the curves
+	 * @param measureStds          standard deviation values for the measures
+	 * @param processFrequencies   information about the process frequencies of the
+	 *                             curves
+	 * @param min_processFrequency minimum process frequency
+	 * @param colors               color encodings for the curves
 	 */
-	public void setGraph(MeasureCollection[] measures, MeasureCollection[] measureStds, int[] processFrequencies, int min_processFrequency,
-			Color[] colors) {
+	public void setGraph(MeasureCollection[] measures, MeasureCollection[] measureStds, int[] processFrequencies,
+			int min_processFrequency, Color[] colors) {
 		this.measures = measures;
 		this.processFrequencies = processFrequencies;
 		this.min_processFrequency = min_processFrequency;
@@ -97,7 +93,7 @@ public void setGraph(MeasureCollection[] measures, MeasureCollection[] measureSt
 
 	@Override
 	public double getMinXValue() {
-	    return 0;
+		return 0;
 	}
 
 	@Override
diff --git a/moa/src/main/java/moa/gui/visualization/RunOutlierVisualizer.java b/moa/src/main/java/moa/gui/visualization/RunOutlierVisualizer.java
index 5dd794716..365b7c691 100644
--- a/moa/src/main/java/moa/gui/visualization/RunOutlierVisualizer.java
+++ b/moa/src/main/java/moa/gui/visualization/RunOutlierVisualizer.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 /*
@@ -47,10 +47,6 @@
 
 import moa.cluster.Cluster;
 import moa.cluster.Clustering;
-import moa.clusterers.outliers.MyBaseOutlierDetector;
-import moa.clusterers.outliers.MyBaseOutlierDetector.Outlier;
-import moa.clusterers.outliers.MyBaseOutlierDetector.OutlierNotifier;
-import moa.clusterers.outliers.MyBaseOutlierDetector.PrintMsg;
 import moa.core.FastVector;
 import moa.evaluation.MeasureCollection;
 import moa.evaluation.OutlierPerformance;
@@ -58,608 +54,627 @@
 import moa.gui.outliertab.OutlierSetupTab;
 import moa.gui.outliertab.OutlierVisualEvalPanel;
 import moa.gui.outliertab.OutlierVisualTab;
+import moa.learners.clusterers.outliers.MyBaseOutlierDetector;
+import moa.learners.clusterers.outliers.MyBaseOutlierDetector.Outlier;
+import moa.learners.clusterers.outliers.MyBaseOutlierDetector.OutlierNotifier;
+import moa.learners.clusterers.outliers.MyBaseOutlierDetector.PrintMsg;
 import moa.streams.clustering.ClusterEvent;
 import moa.streams.clustering.ClusterEventListener;
 import moa.streams.clustering.ClusteringStream;
 import moa.streams.clustering.RandomRBFGeneratorEvents;
 
-public class RunOutlierVisualizer implements Runnable, ActionListener, ClusterEventListener{	
-    /** the pause interval, being read from the gui at startup */
-    public static final int initialPauseInterval = 1000;
-    
-    /** factor to control the speed */
-    private int m_wait_frequency = 100;
-    
-    private int m_drawOutliersInterval = 100;
-    
-    /** after how many instances do we repaint the streampanel?
-     *  the GUI becomes very slow with small values 
-     * */
-    private int m_redrawInterval = 100;
-    
-    private int m_eventsInterval = 20;
-    private int m_eventsDecay = 100;
-    
-    // interval for measurement of processing time per object
-    private int m_MeasureInterval = 1000;
-    
-    /* flags to control the run behavior */
-    private static boolean bWork;
-    private boolean bStop = false;
-    
-    /* total amount of processed instances */
-    private static int timestamp;
-            
-    /* amount of instances to process in one step*/
-    private int m_pauseInterval;
-    
-    private boolean m_bWaitWinFull;
-    
-    /* the stream that delivers the instances */
-    private final ClusteringStream m_stream0;
-    
-    /* amount of relevant instances; older instances will be dropped;
-       creates the 'sliding window' over the stream; 
-       is strongly connected to the decay rate and decay threshold*/
-    private int m_stream0_decayHorizon;
-
-    /* the decay threshold defines the minimum weight of an instance to be relevant */
-    private double m_stream0_decay_threshold;
-    
-    /* the decay rate of the stream, often reffered to as lambda;
-       is being calculated from the horizion and the threshold 
-       as these are more intuitive to define */
-    private double m_stream0_decay_rate;   
-    
-    private static final int ALGORITHM_1 = 0;
-    private static final int ALGORITHM_2 = 1;
-    private static final int MAX_ALGORITHMS = 2;
-    
-    boolean bUseAlgorithm2 = false;
-    
-    /* the outlier detector */
-    public MyBaseOutlierDetector m_outlier[] = new MyBaseOutlierDetector[MAX_ALGORITHMS];
-    
-    /* the measure collections contain all the measures */
-    private MeasureCollection[] m_measures[] = new MeasureCollection[MAX_ALGORITHMS][];
-
-    /* left and right stream panel that datapoints and clusterings will be drawn to */
-    private StreamOutlierPanel m_streampanel[] = new StreamOutlierPanel[MAX_ALGORITHMS];
-    
-    private TreeSet<OutlierEvent> eventBuffer[] = new TreeSet[MAX_ALGORITHMS];
-    
-    /* panel that shows the evaluation results */
-    private OutlierVisualEvalPanel m_evalPanel;
-    
-    /* panel to hold the graph */
-    private GraphCanvas m_graphcanvas;
-    
-    /* reference to the visual panel */
-    private OutlierVisualTab m_visualPanel;
-    
-    /* points of window */
-    private LinkedList<DataPoint> pointBuffer0;
-    
-    //private boolean bRedrawPointImg = true;
-    
-    int nProcessed;
-    Long m_timePreObjSum[] = new Long[MAX_ALGORITHMS];
-    int m_timePreObjInterval = 100;
-    
-    /* reference to the log panel */
-    private final TextViewerPanel m_logPanel;
-    
-    private class LogPanelPrintMsg implements PrintMsg {        
-        @Override
-        public void println(String s) {
-            m_logPanel.addText(s);
-        }
-        
-        @Override
-        public void print(String s) {
-            m_logPanel.addText(s);
-        }    
-        
-        @Override
-        public void printf(String fmt, Object... args) {
-            m_logPanel.addText(String.format(fmt, args));
-        }  
-    }
-    
-    private class MyOutlierNotifier extends OutlierNotifier {
-        int idxAlgorithm;
-
-        public MyOutlierNotifier(int idxAlgorithm) {
-            this.idxAlgorithm = idxAlgorithm;
-        }
-        
-        @Override
-        public void OnOutlier(Outlier outlier) {
-            DataPoint point = new DataPoint(outlier.inst, (int)outlier.id);
-            OutlierEvent oe = new OutlierEvent(point, true, new Long(timestamp));
-            if (!eventBuffer[idxAlgorithm].add(oe)) {
-                // there is a previous such event, override it
-                eventBuffer[idxAlgorithm].remove(oe);
-                eventBuffer[idxAlgorithm].add(oe);
-            }
-            // System.out.println("OnOutlier outlier.id " + outlier.id + " timestamp " + timestamp);
-        }
-        
-        @Override
-        public void OnInlier(Outlier outlier) {
-            DataPoint point = new DataPoint(outlier.inst, (int)outlier.id);
-            OutlierEvent oe = new OutlierEvent(point, false, new Long(timestamp));
-            if (!eventBuffer[idxAlgorithm].add(oe)) {
-                // there is a previous such event, override it
-                eventBuffer[idxAlgorithm].remove(oe);
-                eventBuffer[idxAlgorithm].add(oe);
-            }
-            // System.out.println("OnInlier outlier.id " + outlier.id + " timestamp " + timestamp);
-        }
-    }
-    
-    public RunOutlierVisualizer(OutlierVisualTab visualPanel, OutlierSetupTab outlierSetupTab){
-        m_outlier[ALGORITHM_1] = outlierSetupTab.getOutlierer0();        
-        m_outlier[ALGORITHM_1].prepareForUse();        
-        // show algorithm output to log-panel
-        m_outlier[ALGORITHM_1].SetUserInfo(false, false, new LogPanelPrintMsg(), 2000);
-        m_outlier[ALGORITHM_1].outlierNotifier = new MyOutlierNotifier(ALGORITHM_1);
-        
-        m_outlier[ALGORITHM_2] = outlierSetupTab.getOutlierer1();
-        bUseAlgorithm2 = (m_outlier[ALGORITHM_2] != null);
-        if (bUseAlgorithm2) {
-            m_outlier[ALGORITHM_2].prepareForUse();        
-            // show algorithm output to log-panel
-            m_outlier[ALGORITHM_2].SetUserInfo(false, false, new LogPanelPrintMsg(), 2000);
-            m_outlier[ALGORITHM_2].outlierNotifier = new MyOutlierNotifier(ALGORITHM_2);
-        }
-        
-        m_visualPanel = visualPanel;
-        m_streampanel[ALGORITHM_1] = visualPanel.getLeftStreamPanel();
-        m_streampanel[ALGORITHM_1].setVisualizer(this);
-        m_streampanel[ALGORITHM_1].setOutlierDetector(m_outlier[ALGORITHM_1]);
-        if (bUseAlgorithm2) {
-            m_streampanel[ALGORITHM_2] = visualPanel.getRightStreamPanel();
-            m_streampanel[ALGORITHM_2].setVisualizer(this);
-            m_streampanel[ALGORITHM_2].setOutlierDetector(m_outlier[ALGORITHM_2]);
-        }
-        m_logPanel = outlierSetupTab.getLogPanel();
-        m_graphcanvas = visualPanel.getGraphCanvas();
-        m_evalPanel = visualPanel.getEvalPanel();
-
-        m_stream0 = outlierSetupTab.getStream0();
-        m_stream0_decayHorizon = m_stream0.getDecayHorizon();
-        m_stream0_decay_threshold = m_stream0.getDecayThreshold();
-        m_stream0_decay_rate = (Math.log(1.0/m_stream0_decay_threshold)/Math.log(2)/m_stream0_decayHorizon);
-
-        eventBuffer[ALGORITHM_1] = new TreeSet<OutlierEvent>();
-        eventBuffer[ALGORITHM_2] = new TreeSet<OutlierEvent>();
-        
-        timestamp = 0;
-        bWork = true;
-
-        if (m_stream0 instanceof RandomRBFGeneratorEvents) {
-            // ((RandomRBFGeneratorEvents)m_stream0).addClusterChangeListener(this);
-        }
-        m_stream0.prepareForUse();
-        
-        // clear log
-        m_logPanel.setText("");
-        
-        // init measures
-        m_measures[ALGORITHM_1] = outlierSetupTab.getMeasures();
-        m_measures[ALGORITHM_2] = outlierSetupTab.getMeasures();
-        // show as default process time per object
-        m_graphcanvas.setGraph(m_measures[ALGORITHM_1][0], m_measures[ALGORITHM_2][0], 0, 100);
-        
-        updateSettings();
-        
-        // get those values from the generator
-        if (m_stream0 instanceof moa.streams.clustering.FileStream) {
-            // manually set last value to be the class
-            m_stream0.numAttsOption.setValue(m_stream0.numAttsOption.getValue() - 1);
-        }
-        int dims = m_stream0.numAttsOption.getValue();
-        visualPanel.setDimensionComobBoxes(dims);
-    }
-    
-    private void updateSettings() {
-        m_pauseInterval = m_visualPanel.getPauseInterval();
-        m_wait_frequency = m_visualPanel.GetSpeed();
-        setPointsVisibility(m_visualPanel.getPointVisibility());
-        setOutliersVisibility(m_visualPanel.getOutliersVisibility());
-        m_bWaitWinFull = m_visualPanel.getWaitWinFull();
-    }
-
-    @Override
-    public void run() {        
-        nProcessed = 0;
-        m_timePreObjSum[ALGORITHM_1] = 0L;
-        m_timePreObjSum[ALGORITHM_2] = 0L;
-        pointBuffer0 = new LinkedList<DataPoint>();
-        
-        while (!bStop) {            
-            if (!bWork || CanPause()) {
-                updateSettings();
-                
-                drawOutliers();                
-                showOutliers(true);                
-                m_streampanel[ALGORITHM_1].repaint();
-                if (bUseAlgorithm2)
-                    m_streampanel[ALGORITHM_2].repaint();                
-                //redraw();
-                
-                work_pause();
-                if (bStop) break;
-
-                updateSettings();
-                showOutliers(false);
-                m_streampanel[ALGORITHM_1].setHighlightedOutlierPanel(null);
-                if (bUseAlgorithm2)
-                    m_streampanel[ALGORITHM_2].setHighlightedOutlierPanel(null);
-            }            
-            
-            synchronized(this) {
-                processData();
-            }
-        }
-    }
-    
-    private void MeasuredProcessStreamObj(int idxAlgorithm, Instance newInst) {        
-        m_outlier[idxAlgorithm].processNewInstanceImpl(newInst);
-        
-        if (nProcessed % m_timePreObjInterval == 0) {           
-            UpdateTimePerObj(idxAlgorithm, m_outlier[idxAlgorithm].getTimePerObj());
-        }
-    }
-    
-    private void processData() {            
-        if (m_stream0.hasMoreInstances()) {
-            timestamp++;
-            nProcessed++;
-
-            if (timestamp % 100 == 0) 
-                m_visualPanel.setProcessedPointsCounter(timestamp);
-
-            Instance nextStreamObj0 = m_stream0.nextInstance().getData();
-            DataPoint point0 = new DataPoint(nextStreamObj0,timestamp);
-
-            pointBuffer0.add(point0);
-            while (pointBuffer0.size() > m_stream0_decayHorizon) {
-                pointBuffer0.removeFirst();
-            }
-            
-            MeasuredProcessStreamObj(ALGORITHM_1, nextStreamObj0);
-            if (bUseAlgorithm2)
-                MeasuredProcessStreamObj(ALGORITHM_2, nextStreamObj0);
-            
-            // draw new point
-            m_streampanel[ALGORITHM_1].drawPoint(point0, false, false);
-            if (bUseAlgorithm2)
-                m_streampanel[ALGORITHM_2].drawPoint(point0, false, false);
-            
-            // apply decay at points    
-            if (nProcessed % m_redrawInterval == 0) {                
-                float f;
-                if (m_stream0_decayHorizon <= m_redrawInterval) 
-                    f = 1;
-                else
-                    f = ((float)m_redrawInterval) / ((float)m_stream0_decayHorizon);
-                m_streampanel[ALGORITHM_1].applyDrawDecay(f, false);
-                if (bUseAlgorithm2)
-                    m_streampanel[ALGORITHM_2].applyDrawDecay(f, false);
-            }
-            
-            // draw events
-            //if (nProcessed % m_eventsInterval == 0) {
-            drawEvents();
-            
-            // redraw point layer
-            m_streampanel[ALGORITHM_1].RedrawPointLayer();
-            if (bUseAlgorithm2)
-                m_streampanel[ALGORITHM_2].RedrawPointLayer();
-            
-            /*if (nProcessed % m_drawOutliersInterval == 0)         
-                drawOutliers();*/
-
-            if (CanPause()) {
-                // automatically pause each m_pauseInterval objects
-                
-                //updatePointsWeight();
-                showOutliers(true);
-                drawOutliers();
-
-                m_visualPanel.toggleVisualizer(true);
-            }
-        } else {
-            System.out.println("DONE");
-            pause();
-            return;
-        }
-
-        simulateVisualSpeed(); // simulate visualization speed 
-    }
-    
-    private void UpdateTimePerObj(int idxAlgorithm, double t) {
-        double ms = t / (1000.0 * 1000.0);
-        OutlierPerformance op = (OutlierPerformance) m_measures[idxAlgorithm][0];
-        op.addTimePerObject(ms);
-        
-        //m_evalPanel.update();
-        m_graphcanvas.updateCanvas();
-        
-        m_logPanel.addText("Algorithm " + idxAlgorithm + ", process time per object (ms): " + String.format("%.3f", ms));
-    }   
-
-    private void ShowStatistics() {
-        synchronized(this) {
-            m_logPanel.addText(" ");
-            m_logPanel.addText("Algorithm1 " + m_outlier[ALGORITHM_1].getStatistics());
-            if (bUseAlgorithm2)
-                m_logPanel.addText("Algorithm2 " + m_outlier[ALGORITHM_2].getStatistics());
-        }
-    }
-    
-    private boolean CanPause() {
-        if (m_pauseInterval != 0) {
-            return (nProcessed % m_pauseInterval == 0);
-        }
-        return false;
-    }
-    
-    private void simulateVisualSpeed() {        
-        int iMaxWaitFreq = 100;
-        
-        int iSleepMS = iMaxWaitFreq - m_wait_frequency;
-        if (iSleepMS < 0) iSleepMS = 0;
-        if (iSleepMS > iMaxWaitFreq) iSleepMS = iMaxWaitFreq;
-        //System.out.println("iSleepMS="+iSleepMS + ", m_wait_frequency="+m_wait_frequency);
-        
-        if (iSleepMS > 0)
-            Sleep(iSleepMS); 
-    }
-    
-    private void updatePointsWeight() {
-        for(DataPoint p : pointBuffer0)
-            p.updateWeight(timestamp, m_stream0_decay_rate);
-    }
-    
-    public void setWaitWinFull(boolean b) {
-        m_bWaitWinFull = b;
-    }
-    
-    private boolean CanShowOutliers() {
-        return (!m_bWaitWinFull || (nProcessed >= m_stream0_decayHorizon));
-    }
-
-    private void drawOutliers(){
-        drawOutliers(ALGORITHM_1);
-        if (bUseAlgorithm2)
-            drawOutliers(ALGORITHM_2);
-    }
-    
-    private void drawOutliers(int idxAlgorithm){
-        Vector<MyBaseOutlierDetector.Outlier> outliers = m_outlier[idxAlgorithm].getOutliersResult();        
-        if ((outliers != null) && (outliers.size() > 0) && CanShowOutliers())
-            m_streampanel[idxAlgorithm].drawOutliers(outliers, Color.RED);
-    }
-    
-    private void deleteExpiredEvents(int idxAlgorithm) {
-        // delete expired events older than m_eventsDecay
-        boolean b = true;
-        while (b) {
-            b = false;
-            if (eventBuffer[idxAlgorithm].size() > 0) {
-                OutlierEvent ev = eventBuffer[idxAlgorithm].first();
-                if (timestamp > ev.timestamp + m_eventsDecay) {
-                    eventBuffer[idxAlgorithm].remove(ev);
-                    b = true;
-                }
-            }
-        }
-    }
-    
-    private void drawEvents() {
-        drawEvents(ALGORITHM_1);
-        if (bUseAlgorithm2)
-            drawEvents(ALGORITHM_2);
-    }
-    
-    private void drawEvents(int idxAlgorithm) {        
-        m_streampanel[idxAlgorithm].clearEvents();
-        
-        // System.out.println("Alg " + idxAlgorithm + " events " + eventBuffer[idxAlgorithm].size());
-        
-        deleteExpiredEvents(idxAlgorithm);
-        
-        if (CanShowOutliers()) {
-            for (OutlierEvent ev : eventBuffer[idxAlgorithm]) {
-                m_streampanel[idxAlgorithm].drawEvent(ev, false);
-            }        
-        }
-        
-        //m_streampanel[idxAlgorithm].RedrawPointLayer();        
-    }
-    
-    private void drawPoints() {
-        drawPoints(ALGORITHM_1);
-        if (bUseAlgorithm2)
-            drawPoints(ALGORITHM_2);
-    }
-    
-    private void drawPoints(int idxAlgorithm) {
-        m_streampanel[idxAlgorithm].clearPoints();  
-        
-        for (DataPoint point0 : pointBuffer0) {
-            point0.updateWeight(timestamp, m_stream0_decay_rate);
-            m_streampanel[idxAlgorithm].drawPoint(point0, true, false);
-        }        
-        
-        m_streampanel[idxAlgorithm].RedrawPointLayer();        
-    }
-    
-    private void showOutliers(boolean bShow) {
-        showOutliers(ALGORITHM_1, bShow);
-        if (bUseAlgorithm2)
-            showOutliers(ALGORITHM_2, bShow);
-    }
-    
-    private void showOutliers(int idxAlgorithm, boolean bShow) {
-        if (!bWork && m_visualPanel.isEnabledDrawOutliers() && CanShowOutliers()) {
-            m_streampanel[idxAlgorithm].setOutliersVisibility(bShow);
-        }
-        else {
-            m_streampanel[idxAlgorithm].setOutliersVisibility(false);
-        }
-    }
-
-    private void _redraw() {        
-        m_streampanel[ALGORITHM_1].clearPoints();    
-        if (bUseAlgorithm2)
-            m_streampanel[ALGORITHM_2].clearPoints();  
-        
-        drawPoints();
-        drawEvents();
-        
-        showOutliers(true);
-        // drawClusterings();
-
-        m_streampanel[ALGORITHM_1].repaint();
-        if (bUseAlgorithm2)
-            m_streampanel[ALGORITHM_2].repaint();
-    }
-
-    public void redraw() {
-        synchronized(this) {
-            _redraw();
-        }
-    }
-    
-    private void _redrawOnResize() {                
-        m_streampanel[ALGORITHM_1].clearPoints();  
-        if (bUseAlgorithm2)
-            m_streampanel[ALGORITHM_2].clearPoints();  
-        
-        drawPoints();   
-        drawEvents();
-        showOutliers(true);        
-        drawOutliers();
-
-        m_streampanel[ALGORITHM_1].repaint();
-        if (bUseAlgorithm2)
-            m_streampanel[ALGORITHM_2].repaint();
-    }
-    
-    public void redrawOnResize() {
-        synchronized(this) {
-            _redrawOnResize();
-        }
-    }
-
-    public static int getCurrentTimestamp(){
-        return timestamp;
-    }
-
-    private void work_pause(){
-        while(!bWork && !bStop){
-            Sleep(200);
-       }
-    }
-    
-    private void Sleep(int ms) {
-        try {
-            Thread.sleep(ms);
-        } catch (InterruptedException ex) { }
-    }
-
-    public static void pause(){
-        bWork = false;
-    }
-
-    public static void resume(){
-        bWork = true;
-    }
-    
-    public void stop(){
-        bWork = false;
-        bStop = true;
-        ShowStatistics();
-    }
-
-    public void setSpeed(int speed) {
-        m_wait_frequency = speed;
-    }
-
-    @Override
-    public void actionPerformed(ActionEvent e) {
-    }
-
-    public void setPointsVisibility(boolean selected) {
-        m_streampanel[ALGORITHM_1].setPointsVisibility(selected);
-        if (bUseAlgorithm2)
-            m_streampanel[ALGORITHM_2].setPointsVisibility(selected);
-    }
-    
-    public void setOutliersVisibility(boolean selected) {
-        m_streampanel[ALGORITHM_1].setOutliersVisibility(selected);
-        if (bUseAlgorithm2)
-            m_streampanel[ALGORITHM_2].setOutliersVisibility(selected);
-    }
-
-    @Override
-    public void changeCluster(ClusterEvent e) {
-        System.out.println(e.getType()+": "+e.getMessage());
-    }
-
-    public void exportCSV(String filepath) {
-        PrintWriter out = null;
-        try {
-            if(!filepath.endsWith(".csv"))
-                filepath+=".csv";
-            out = new PrintWriter(new BufferedWriter(new FileWriter(filepath)));            
-            out.write("\n");            
-            out.close();
-        } catch (IOException ex) {
-            Logger.getLogger(RunVisualizer.class.getName()).log(Level.SEVERE, null, ex);
-        } finally {
-            out.close();
-        }
-    }
-
-    public void weka() {
-    	try{
-    		Class.forName("weka.gui.Logger");
-    	}
-    	catch (Exception e){
-    		m_logPanel.addText("Please add weka.jar to the classpath to use the Weka explorer.");
-    		return;
-    	}    	    	
-    	
-        Clustering wekaClustering;
-        wekaClustering = null;
-
-        if(wekaClustering == null || wekaClustering.size()==0){
-            m_logPanel.addText("Empty Clustering");
-            return;
-        }
-
-        int dims = wekaClustering.get(0).getCenter().length;
-        FastVector attributes = new FastVector();
-        for(int i = 0; i < dims; i++)
-                attributes.addElement( new Attribute("att" + i) );
-
-        InstancesHeader instances = new InstancesHeader("trainset",attributes,0);
-
-        for(int c = 0; c < wekaClustering.size(); c++){
-            Cluster cluster = wekaClustering.get(c);
-            Instance inst = new DenseInstance(cluster.getWeight(), cluster.getCenter());
-            inst.setDataset(instances);
-            instances.add(inst);
-        }
-
-        WekaExplorer explorer = new WekaExplorer(instances);
-    }
+public class RunOutlierVisualizer implements Runnable, ActionListener, ClusterEventListener {
+	/** the pause interval, being read from the gui at startup */
+	public static final int initialPauseInterval = 1000;
 
+	/** factor to control the speed */
+	private int m_wait_frequency = 100;
 
-}
+	private int m_drawOutliersInterval = 100;
+
+	/**
+	 * after how many instances do we repaint the streampanel? the GUI becomes very
+	 * slow with small values
+	 */
+	private int m_redrawInterval = 100;
+
+	private int m_eventsInterval = 20;
+	private int m_eventsDecay = 100;
+
+	// interval for measurement of processing time per object
+	private int m_MeasureInterval = 1000;
+
+	/* flags to control the run behavior */
+	private static boolean bWork;
+	private boolean bStop = false;
 
+	/* total amount of processed instances */
+	private static int timestamp;
+
+	/* amount of instances to process in one step */
+	private int m_pauseInterval;
+
+	private boolean m_bWaitWinFull;
+
+	/* the stream that delivers the instances */
+	private final ClusteringStream m_stream0;
+
+	/*
+	 * amount of relevant instances; older instances will be dropped; creates the
+	 * 'sliding window' over the stream; is strongly connected to the decay rate and
+	 * decay threshold
+	 */
+	private int m_stream0_decayHorizon;
+
+	/*
+	 * the decay threshold defines the minimum weight of an instance to be relevant
+	 */
+	private double m_stream0_decay_threshold;
+
+	/*
+	 * the decay rate of the stream, often reffered to as lambda; is being
+	 * calculated from the horizion and the threshold as these are more intuitive to
+	 * define
+	 */
+	private double m_stream0_decay_rate;
+
+	private static final int ALGORITHM_1 = 0;
+	private static final int ALGORITHM_2 = 1;
+	private static final int MAX_ALGORITHMS = 2;
+
+	boolean bUseAlgorithm2 = false;
+
+	/* the outlier detector */
+	public MyBaseOutlierDetector m_outlier[] = new MyBaseOutlierDetector[MAX_ALGORITHMS];
+
+	/* the measure collections contain all the measures */
+	private MeasureCollection[] m_measures[] = new MeasureCollection[MAX_ALGORITHMS][];
+
+	/*
+	 * left and right stream panel that datapoints and clusterings will be drawn to
+	 */
+	private StreamOutlierPanel m_streampanel[] = new StreamOutlierPanel[MAX_ALGORITHMS];
+
+	private TreeSet<OutlierEvent> eventBuffer[] = new TreeSet[MAX_ALGORITHMS];
+
+	/* panel that shows the evaluation results */
+	private OutlierVisualEvalPanel m_evalPanel;
+
+	/* panel to hold the graph */
+	private GraphCanvas m_graphcanvas;
+
+	/* reference to the visual panel */
+	private OutlierVisualTab m_visualPanel;
+
+	/* points of window */
+	private LinkedList<DataPoint> pointBuffer0;
+
+	// private boolean bRedrawPointImg = true;
+
+	int nProcessed;
+	Long m_timePreObjSum[] = new Long[MAX_ALGORITHMS];
+	int m_timePreObjInterval = 100;
+
+	/* reference to the log panel */
+	private final TextViewerPanel m_logPanel;
+
+	private class LogPanelPrintMsg implements PrintMsg {
+		@Override
+		public void println(String s) {
+			m_logPanel.addText(s);
+		}
+
+		@Override
+		public void print(String s) {
+			m_logPanel.addText(s);
+		}
+
+		@Override
+		public void printf(String fmt, Object... args) {
+			m_logPanel.addText(String.format(fmt, args));
+		}
+	}
+
+	private class MyOutlierNotifier extends OutlierNotifier {
+		int idxAlgorithm;
+
+		public MyOutlierNotifier(int idxAlgorithm) {
+			this.idxAlgorithm = idxAlgorithm;
+		}
+
+		@Override
+		public void OnOutlier(Outlier outlier) {
+			DataPoint point = new DataPoint(outlier.inst, (int) outlier.id);
+			OutlierEvent oe = new OutlierEvent(point, true, new Long(timestamp));
+			if (!eventBuffer[idxAlgorithm].add(oe)) {
+				// there is a previous such event, override it
+				eventBuffer[idxAlgorithm].remove(oe);
+				eventBuffer[idxAlgorithm].add(oe);
+			}
+			// System.out.println("OnOutlier outlier.id " + outlier.id + " timestamp " +
+			// timestamp);
+		}
+
+		@Override
+		public void OnInlier(Outlier outlier) {
+			DataPoint point = new DataPoint(outlier.inst, (int) outlier.id);
+			OutlierEvent oe = new OutlierEvent(point, false, new Long(timestamp));
+			if (!eventBuffer[idxAlgorithm].add(oe)) {
+				// there is a previous such event, override it
+				eventBuffer[idxAlgorithm].remove(oe);
+				eventBuffer[idxAlgorithm].add(oe);
+			}
+			// System.out.println("OnInlier outlier.id " + outlier.id + " timestamp " +
+			// timestamp);
+		}
+	}
+
+	public RunOutlierVisualizer(OutlierVisualTab visualPanel, OutlierSetupTab outlierSetupTab) {
+		m_outlier[ALGORITHM_1] = outlierSetupTab.getOutlierer0();
+		m_outlier[ALGORITHM_1].prepareForUse();
+		// show algorithm output to log-panel
+		m_outlier[ALGORITHM_1].SetUserInfo(false, false, new LogPanelPrintMsg(), 2000);
+		m_outlier[ALGORITHM_1].outlierNotifier = new MyOutlierNotifier(ALGORITHM_1);
+
+		m_outlier[ALGORITHM_2] = outlierSetupTab.getOutlierer1();
+		bUseAlgorithm2 = (m_outlier[ALGORITHM_2] != null);
+		if (bUseAlgorithm2) {
+			m_outlier[ALGORITHM_2].prepareForUse();
+			// show algorithm output to log-panel
+			m_outlier[ALGORITHM_2].SetUserInfo(false, false, new LogPanelPrintMsg(), 2000);
+			m_outlier[ALGORITHM_2].outlierNotifier = new MyOutlierNotifier(ALGORITHM_2);
+		}
+
+		m_visualPanel = visualPanel;
+		m_streampanel[ALGORITHM_1] = visualPanel.getLeftStreamPanel();
+		m_streampanel[ALGORITHM_1].setVisualizer(this);
+		m_streampanel[ALGORITHM_1].setOutlierDetector(m_outlier[ALGORITHM_1]);
+		if (bUseAlgorithm2) {
+			m_streampanel[ALGORITHM_2] = visualPanel.getRightStreamPanel();
+			m_streampanel[ALGORITHM_2].setVisualizer(this);
+			m_streampanel[ALGORITHM_2].setOutlierDetector(m_outlier[ALGORITHM_2]);
+		}
+		m_logPanel = outlierSetupTab.getLogPanel();
+		m_graphcanvas = visualPanel.getGraphCanvas();
+		m_evalPanel = visualPanel.getEvalPanel();
+
+		m_stream0 = outlierSetupTab.getStream0();
+		m_stream0_decayHorizon = m_stream0.getDecayHorizon();
+		m_stream0_decay_threshold = m_stream0.getDecayThreshold();
+		m_stream0_decay_rate = (Math.log(1.0 / m_stream0_decay_threshold) / Math.log(2) / m_stream0_decayHorizon);
+
+		eventBuffer[ALGORITHM_1] = new TreeSet<>();
+		eventBuffer[ALGORITHM_2] = new TreeSet<>();
+
+		timestamp = 0;
+		bWork = true;
+
+		if (m_stream0 instanceof RandomRBFGeneratorEvents) {
+			// ((RandomRBFGeneratorEvents)m_stream0).addClusterChangeListener(this);
+		}
+		m_stream0.prepareForUse();
+
+		// clear log
+		m_logPanel.setText("");
+
+		// init measures
+		m_measures[ALGORITHM_1] = outlierSetupTab.getMeasures();
+		m_measures[ALGORITHM_2] = outlierSetupTab.getMeasures();
+		// show as default process time per object
+		m_graphcanvas.setGraph(m_measures[ALGORITHM_1][0], m_measures[ALGORITHM_2][0], 0, 100);
+
+		updateSettings();
+
+		// get those values from the generator
+		if (m_stream0 instanceof moa.streams.clustering.FileStream) {
+			// manually set last value to be the class
+			m_stream0.numAttsOption.setValue(m_stream0.numAttsOption.getValue() - 1);
+		}
+		int dims = m_stream0.numAttsOption.getValue();
+		visualPanel.setDimensionComobBoxes(dims);
+	}
+
+	private void updateSettings() {
+		m_pauseInterval = m_visualPanel.getPauseInterval();
+		m_wait_frequency = m_visualPanel.GetSpeed();
+		setPointsVisibility(m_visualPanel.getPointVisibility());
+		setOutliersVisibility(m_visualPanel.getOutliersVisibility());
+		m_bWaitWinFull = m_visualPanel.getWaitWinFull();
+	}
+
+	@Override
+	public void run() {
+		nProcessed = 0;
+		m_timePreObjSum[ALGORITHM_1] = 0L;
+		m_timePreObjSum[ALGORITHM_2] = 0L;
+		pointBuffer0 = new LinkedList<>();
+
+		while (!bStop) {
+			if (!bWork || CanPause()) {
+				updateSettings();
+
+				drawOutliers();
+				showOutliers(true);
+				m_streampanel[ALGORITHM_1].repaint();
+				if (bUseAlgorithm2)
+					m_streampanel[ALGORITHM_2].repaint();
+				// redraw();
+
+				work_pause();
+				if (bStop)
+					break;
+
+				updateSettings();
+				showOutliers(false);
+				m_streampanel[ALGORITHM_1].setHighlightedOutlierPanel(null);
+				if (bUseAlgorithm2)
+					m_streampanel[ALGORITHM_2].setHighlightedOutlierPanel(null);
+			}
+
+			synchronized (this) {
+				processData();
+			}
+		}
+	}
+
+	private void MeasuredProcessStreamObj(int idxAlgorithm, Instance newInst) {
+		m_outlier[idxAlgorithm].processNewInstanceImpl(newInst);
+
+		if (nProcessed % m_timePreObjInterval == 0) {
+			UpdateTimePerObj(idxAlgorithm, m_outlier[idxAlgorithm].getTimePerObj());
+		}
+	}
+
+	private void processData() {
+		if (m_stream0.hasMoreInstances()) {
+			timestamp++;
+			nProcessed++;
+
+			if (timestamp % 100 == 0)
+				m_visualPanel.setProcessedPointsCounter(timestamp);
+
+			Instance nextStreamObj0 = m_stream0.nextInstance().getData();
+			DataPoint point0 = new DataPoint(nextStreamObj0, timestamp);
+
+			pointBuffer0.add(point0);
+			while (pointBuffer0.size() > m_stream0_decayHorizon) {
+				pointBuffer0.removeFirst();
+			}
+
+			MeasuredProcessStreamObj(ALGORITHM_1, nextStreamObj0);
+			if (bUseAlgorithm2)
+				MeasuredProcessStreamObj(ALGORITHM_2, nextStreamObj0);
+
+			// draw new point
+			m_streampanel[ALGORITHM_1].drawPoint(point0, false, false);
+			if (bUseAlgorithm2)
+				m_streampanel[ALGORITHM_2].drawPoint(point0, false, false);
+
+			// apply decay at points
+			if (nProcessed % m_redrawInterval == 0) {
+				float f;
+				if (m_stream0_decayHorizon <= m_redrawInterval)
+					f = 1;
+				else
+					f = ((float) m_redrawInterval) / ((float) m_stream0_decayHorizon);
+				m_streampanel[ALGORITHM_1].applyDrawDecay(f, false);
+				if (bUseAlgorithm2)
+					m_streampanel[ALGORITHM_2].applyDrawDecay(f, false);
+			}
+
+			// draw events
+			// if (nProcessed % m_eventsInterval == 0) {
+			drawEvents();
+
+			// redraw point layer
+			m_streampanel[ALGORITHM_1].RedrawPointLayer();
+			if (bUseAlgorithm2)
+				m_streampanel[ALGORITHM_2].RedrawPointLayer();
+
+			/*
+			 * if (nProcessed % m_drawOutliersInterval == 0) drawOutliers();
+			 */
+
+			if (CanPause()) {
+				// automatically pause each m_pauseInterval objects
+
+				// updatePointsWeight();
+				showOutliers(true);
+				drawOutliers();
+
+				m_visualPanel.toggleVisualizer(true);
+			}
+		} else {
+			System.out.println("DONE");
+			pause();
+			return;
+		}
+
+		simulateVisualSpeed(); // simulate visualization speed
+	}
+
+	private void UpdateTimePerObj(int idxAlgorithm, double t) {
+		double ms = t / (1000.0 * 1000.0);
+		OutlierPerformance op = (OutlierPerformance) m_measures[idxAlgorithm][0];
+		op.addTimePerObject(ms);
+
+		// m_evalPanel.update();
+		m_graphcanvas.updateCanvas();
+
+		m_logPanel
+				.addText("Algorithm " + idxAlgorithm + ", process time per object (ms): " + String.format("%.3f", ms));
+	}
+
+	private void ShowStatistics() {
+		synchronized (this) {
+			m_logPanel.addText(" ");
+			m_logPanel.addText("Algorithm1 " + m_outlier[ALGORITHM_1].getStatistics());
+			if (bUseAlgorithm2)
+				m_logPanel.addText("Algorithm2 " + m_outlier[ALGORITHM_2].getStatistics());
+		}
+	}
+
+	private boolean CanPause() {
+		if (m_pauseInterval != 0) {
+			return (nProcessed % m_pauseInterval == 0);
+		}
+		return false;
+	}
+
+	private void simulateVisualSpeed() {
+		int iMaxWaitFreq = 100;
+
+		int iSleepMS = iMaxWaitFreq - m_wait_frequency;
+		if (iSleepMS < 0)
+			iSleepMS = 0;
+		if (iSleepMS > iMaxWaitFreq)
+			iSleepMS = iMaxWaitFreq;
+		// System.out.println("iSleepMS="+iSleepMS + ",
+		// m_wait_frequency="+m_wait_frequency);
+
+		if (iSleepMS > 0)
+			Sleep(iSleepMS);
+	}
+
+	private void updatePointsWeight() {
+		for (DataPoint p : pointBuffer0)
+			p.updateWeight(timestamp, m_stream0_decay_rate);
+	}
+
+	public void setWaitWinFull(boolean b) {
+		m_bWaitWinFull = b;
+	}
+
+	private boolean CanShowOutliers() {
+		return (!m_bWaitWinFull || (nProcessed >= m_stream0_decayHorizon));
+	}
+
+	private void drawOutliers() {
+		drawOutliers(ALGORITHM_1);
+		if (bUseAlgorithm2)
+			drawOutliers(ALGORITHM_2);
+	}
+
+	private void drawOutliers(int idxAlgorithm) {
+		Vector<MyBaseOutlierDetector.Outlier> outliers = m_outlier[idxAlgorithm].getOutliersResult();
+		if ((outliers != null) && (outliers.size() > 0) && CanShowOutliers())
+			m_streampanel[idxAlgorithm].drawOutliers(outliers, Color.RED);
+	}
+
+	private void deleteExpiredEvents(int idxAlgorithm) {
+		// delete expired events older than m_eventsDecay
+		boolean b = true;
+		while (b) {
+			b = false;
+			if (eventBuffer[idxAlgorithm].size() > 0) {
+				OutlierEvent ev = eventBuffer[idxAlgorithm].first();
+				if (timestamp > ev.timestamp + m_eventsDecay) {
+					eventBuffer[idxAlgorithm].remove(ev);
+					b = true;
+				}
+			}
+		}
+	}
+
+	private void drawEvents() {
+		drawEvents(ALGORITHM_1);
+		if (bUseAlgorithm2)
+			drawEvents(ALGORITHM_2);
+	}
+
+	private void drawEvents(int idxAlgorithm) {
+		m_streampanel[idxAlgorithm].clearEvents();
+
+		// System.out.println("Alg " + idxAlgorithm + " events " +
+		// eventBuffer[idxAlgorithm].size());
+
+		deleteExpiredEvents(idxAlgorithm);
+
+		if (CanShowOutliers()) {
+			for (OutlierEvent ev : eventBuffer[idxAlgorithm]) {
+				m_streampanel[idxAlgorithm].drawEvent(ev, false);
+			}
+		}
+
+		// m_streampanel[idxAlgorithm].RedrawPointLayer();
+	}
+
+	private void drawPoints() {
+		drawPoints(ALGORITHM_1);
+		if (bUseAlgorithm2)
+			drawPoints(ALGORITHM_2);
+	}
+
+	private void drawPoints(int idxAlgorithm) {
+		m_streampanel[idxAlgorithm].clearPoints();
+
+		for (DataPoint point0 : pointBuffer0) {
+			point0.updateWeight(timestamp, m_stream0_decay_rate);
+			m_streampanel[idxAlgorithm].drawPoint(point0, true, false);
+		}
+
+		m_streampanel[idxAlgorithm].RedrawPointLayer();
+	}
+
+	private void showOutliers(boolean bShow) {
+		showOutliers(ALGORITHM_1, bShow);
+		if (bUseAlgorithm2)
+			showOutliers(ALGORITHM_2, bShow);
+	}
+
+	private void showOutliers(int idxAlgorithm, boolean bShow) {
+		if (!bWork && m_visualPanel.isEnabledDrawOutliers() && CanShowOutliers()) {
+			m_streampanel[idxAlgorithm].setOutliersVisibility(bShow);
+		} else {
+			m_streampanel[idxAlgorithm].setOutliersVisibility(false);
+		}
+	}
+
+	private void _redraw() {
+		m_streampanel[ALGORITHM_1].clearPoints();
+		if (bUseAlgorithm2)
+			m_streampanel[ALGORITHM_2].clearPoints();
+
+		drawPoints();
+		drawEvents();
+
+		showOutliers(true);
+		// drawClusterings();
+
+		m_streampanel[ALGORITHM_1].repaint();
+		if (bUseAlgorithm2)
+			m_streampanel[ALGORITHM_2].repaint();
+	}
+
+	public void redraw() {
+		synchronized (this) {
+			_redraw();
+		}
+	}
+
+	private void _redrawOnResize() {
+		m_streampanel[ALGORITHM_1].clearPoints();
+		if (bUseAlgorithm2)
+			m_streampanel[ALGORITHM_2].clearPoints();
+
+		drawPoints();
+		drawEvents();
+		showOutliers(true);
+		drawOutliers();
+
+		m_streampanel[ALGORITHM_1].repaint();
+		if (bUseAlgorithm2)
+			m_streampanel[ALGORITHM_2].repaint();
+	}
+
+	public void redrawOnResize() {
+		synchronized (this) {
+			_redrawOnResize();
+		}
+	}
+
+	public static int getCurrentTimestamp() {
+		return timestamp;
+	}
+
+	private void work_pause() {
+		while (!bWork && !bStop) {
+			Sleep(200);
+		}
+	}
+
+	private void Sleep(int ms) {
+		try {
+			Thread.sleep(ms);
+		} catch (InterruptedException ex) {
+		}
+	}
+
+	public static void pause() {
+		bWork = false;
+	}
+
+	public static void resume() {
+		bWork = true;
+	}
+
+	public void stop() {
+		bWork = false;
+		bStop = true;
+		ShowStatistics();
+	}
+
+	public void setSpeed(int speed) {
+		m_wait_frequency = speed;
+	}
+
+	@Override
+	public void actionPerformed(ActionEvent e) {
+	}
+
+	public void setPointsVisibility(boolean selected) {
+		m_streampanel[ALGORITHM_1].setPointsVisibility(selected);
+		if (bUseAlgorithm2)
+			m_streampanel[ALGORITHM_2].setPointsVisibility(selected);
+	}
+
+	public void setOutliersVisibility(boolean selected) {
+		m_streampanel[ALGORITHM_1].setOutliersVisibility(selected);
+		if (bUseAlgorithm2)
+			m_streampanel[ALGORITHM_2].setOutliersVisibility(selected);
+	}
+
+	@Override
+	public void changeCluster(ClusterEvent e) {
+		System.out.println(e.getType() + ": " + e.getMessage());
+	}
+
+	public void exportCSV(String filepath) {
+		PrintWriter out = null;
+		try {
+			if (!filepath.endsWith(".csv"))
+				filepath += ".csv";
+			out = new PrintWriter(new BufferedWriter(new FileWriter(filepath)));
+			out.write("\n");
+			out.close();
+		} catch (IOException ex) {
+			Logger.getLogger(RunVisualizer.class.getName()).log(Level.SEVERE, null, ex);
+		} finally {
+			out.close();
+		}
+	}
+
+	public void weka() {
+		try {
+			Class.forName("weka.gui.Logger");
+		} catch (Exception e) {
+			m_logPanel.addText("Please add weka.jar to the classpath to use the Weka explorer.");
+			return;
+		}
+
+		Clustering wekaClustering;
+		wekaClustering = null;
+
+		if (wekaClustering == null || wekaClustering.size() == 0) {
+			m_logPanel.addText("Empty Clustering");
+			return;
+		}
+
+		int dims = wekaClustering.get(0).getCenter().length;
+		FastVector attributes = new FastVector();
+		for (int i = 0; i < dims; i++)
+			attributes.addElement(new Attribute("att" + i));
+
+		InstancesHeader instances = new InstancesHeader("trainset", attributes, 0);
+
+		for (int c = 0; c < wekaClustering.size(); c++) {
+			Cluster cluster = wekaClustering.get(c);
+			Instance inst = new DenseInstance(cluster.getWeight(), cluster.getCenter());
+			inst.setDataset(instances);
+			instances.add(inst);
+		}
+
+		WekaExplorer explorer = new WekaExplorer(instances);
+	}
+
+}
diff --git a/moa/src/main/java/moa/gui/visualization/RunVisualizer.java b/moa/src/main/java/moa/gui/visualization/RunVisualizer.java
index 0e33cbebb..cd499914f 100644
--- a/moa/src/main/java/moa/gui/visualization/RunVisualizer.java
+++ b/moa/src/main/java/moa/gui/visualization/RunVisualizer.java
@@ -41,582 +41,586 @@
 
 import moa.cluster.Cluster;
 import moa.cluster.Clustering;
-import moa.clusterers.AbstractClusterer;
-import moa.clusterers.ClusterGenerator;
 import moa.core.FastVector;
 import moa.evaluation.MeasureCollection;
 import moa.gui.TextViewerPanel;
 import moa.gui.clustertab.ClusteringSetupTab;
 import moa.gui.clustertab.ClusteringVisualEvalPanel;
 import moa.gui.clustertab.ClusteringVisualTab;
+import moa.learners.clusterers.AbstractClusterer;
+import moa.learners.clusterers.ClusterGenerator;
 import moa.streams.clustering.ClusterEvent;
 import moa.streams.clustering.ClusterEventListener;
 import moa.streams.clustering.ClusteringStream;
 import moa.streams.clustering.RandomRBFGeneratorEvents;
 
-public class RunVisualizer implements Runnable, ActionListener, ClusterEventListener{
-
-
-    /** the pause interval, being read from the gui at startup */
-    public static final int initialPauseInterval = 5000;
-
-    /** factor to control the speed */
-    private int m_wait_frequency = 1000;
-
-    /** after how many instances do we repaint the streampanel?
-     *  the GUI becomes very slow with small values
-     * */
-    private int m_redrawInterval = 100;
-
-
-    /* flags to control the run behavior */
-    private static boolean work;
-    private boolean stop = false;
-
-    /* total amount of processed instances */
-    private static int timestamp;
-    private static int lastPauseTimestamp;
-
-    /* amount of instances to process in one step*/
-    private int m_processFrequency;
-
-    /* the stream that delivers the instances */
-    private final ClusteringStream m_stream0;
-
-    /* amount of relevant instances; older instances will be dropped;
-       creates the 'sliding window' over the stream;
-       is strongly connected to the decay rate and decay threshold*/
-    private int m_stream0_decayHorizon;
-
-    /* the decay threshold defines the minimum weight of an instance to be relevant */
-    private double m_stream0_decay_threshold;
-
-    /* the decay rate of the stream, often reffered to as lambda;
-       is being calculated from the horizion and the threshold
-       as these are more intuitive to define */
-    private double m_stream0_decay_rate;
-
-
-    /* the clusterer */
-    private AbstractClusterer m_clusterer0;
-    private AbstractClusterer m_clusterer1;
-
-    /* the measure collections contain all the measures */
-    private MeasureCollection[] m_measures0 = null;
-    private MeasureCollection[] m_measures1 = null;
-
-    /* left and right stream panel that datapoints and clusterings will be drawn to */
-    private StreamPanel m_streampanel0;
-    private StreamPanel m_streampanel1;
+public class RunVisualizer implements Runnable, ActionListener, ClusterEventListener {
+
+	/** the pause interval, being read from the gui at startup */
+	public static final int initialPauseInterval = 5000;
+
+	/** factor to control the speed */
+	private int m_wait_frequency = 1000;
+
+	/**
+	 * after how many instances do we repaint the streampanel? the GUI becomes very
+	 * slow with small values
+	 */
+	private int m_redrawInterval = 100;
+
+	/* flags to control the run behavior */
+	private static boolean work;
+	private boolean stop = false;
+
+	/* total amount of processed instances */
+	private static int timestamp;
+	private static int lastPauseTimestamp;
+
+	/* amount of instances to process in one step */
+	private int m_processFrequency;
+
+	/* the stream that delivers the instances */
+	private final ClusteringStream m_stream0;
+
+	/*
+	 * amount of relevant instances; older instances will be dropped; creates the
+	 * 'sliding window' over the stream; is strongly connected to the decay rate and
+	 * decay threshold
+	 */
+	private int m_stream0_decayHorizon;
+
+	/*
+	 * the decay threshold defines the minimum weight of an instance to be relevant
+	 */
+	private double m_stream0_decay_threshold;
+
+	/*
+	 * the decay rate of the stream, often reffered to as lambda; is being
+	 * calculated from the horizion and the threshold as these are more intuitive to
+	 * define
+	 */
+	private double m_stream0_decay_rate;
+
+	/* the clusterer */
+	private AbstractClusterer m_clusterer0;
+	private AbstractClusterer m_clusterer1;
+
+	/* the measure collections contain all the measures */
+	private MeasureCollection[] m_measures0 = null;
+	private MeasureCollection[] m_measures1 = null;
+
+	/*
+	 * left and right stream panel that datapoints and clusterings will be drawn to
+	 */
+	private StreamPanel m_streampanel0;
+	private StreamPanel m_streampanel1;
+
+	/* panel that shows the evaluation results */
+	private ClusteringVisualEvalPanel m_evalPanel;
+
+	/* panel to hold the graph */
+	private GraphCanvas m_graphcanvas;
+
+	/* reference to the visual panel */
+	private ClusteringVisualTab m_visualPanel;
+
+	/* all possible clusterings */
+	// not pretty to have all the clusterings, but otherwise we can't just redraw
+	// clusterings
+	private Clustering gtClustering0 = null;
+	private Clustering gtClustering1 = null;
+	private Clustering macro0 = null;
+	private Clustering macro1 = null;
+	private Clustering micro0 = null;
+	private Clustering micro1 = null;
+
+	/* holds all the events that have happend, if the stream supports events */
+	private ArrayList<ClusterEvent> clusterEvents;
+
+	/* reference to the log panel */
+	private final TextViewerPanel m_logPanel;
+
+	public RunVisualizer(ClusteringVisualTab visualPanel, ClusteringSetupTab clusteringSetupTab) {
+		m_visualPanel = visualPanel;
+		m_streampanel0 = visualPanel.getLeftStreamPanel();
+		m_streampanel1 = visualPanel.getRightStreamPanel();
+		m_graphcanvas = visualPanel.getGraphCanvas();
+		m_evalPanel = visualPanel.getEvalPanel();
+		m_logPanel = clusteringSetupTab.getLogPanel();
+
+		m_stream0 = clusteringSetupTab.getStream0();
+		m_stream0_decayHorizon = m_stream0.getDecayHorizon();
+		m_stream0_decay_threshold = m_stream0.getDecayThreshold();
+		m_stream0_decay_rate = (Math.log(1.0 / m_stream0_decay_threshold) / Math.log(2) / m_stream0_decayHorizon);
+
+		timestamp = 0;
+		lastPauseTimestamp = 0;
+		work = true;
+
+		if (m_stream0 instanceof RandomRBFGeneratorEvents) {
+			((RandomRBFGeneratorEvents) m_stream0).addClusterChangeListener(this);
+			clusterEvents = new ArrayList<>();
+			m_graphcanvas.setClusterEventsList(clusterEvents);
+		}
+		m_stream0.prepareForUse();
+
+		m_clusterer0 = clusteringSetupTab.getClusterer0();
+		m_clusterer0.prepareForUse();
+
+		m_clusterer1 = clusteringSetupTab.getClusterer1();
+		if (m_clusterer1 != null) {
+			m_clusterer1.prepareForUse();
+		}
+
+		m_measures0 = clusteringSetupTab.getMeasures();
+		m_measures1 = clusteringSetupTab.getMeasures();
+
+		/* TODO this option needs to move from the stream panel to the setup panel */
+		m_processFrequency = m_stream0.getEvaluationFrequency();
+
+		// get those values from the generator
+		int dims = m_stream0.numAttsOption.getValue();
+		visualPanel.setDimensionComobBoxes(dims);
+		visualPanel.setPauseInterval(initialPauseInterval);
+
+		m_evalPanel.setMeasures(m_measures0, m_measures1, this);
+		m_graphcanvas.setGraph(m_measures0[0], m_measures1[0], 0, m_processFrequency);
+	}
+
+	@Override
+	public void run() {
+		runVisual();
+	}
+
+	public void runVisual() {
+		int processCounter = 0;
+		int speedCounter = 0;
+		LinkedList<DataPoint> pointBuffer0 = new LinkedList<>();
+		LinkedList<DataPoint> pointBuffer1 = new LinkedList<>();
+		ArrayList<DataPoint> pointarray0 = null;
+		ArrayList<DataPoint> pointarray1 = null;
+
+		while (work || processCounter != 0) {
+			if (m_stream0.hasMoreInstances()) {
+				timestamp++;
+				speedCounter++;
+				processCounter++;
+				if (timestamp % 100 == 0) {
+					m_visualPanel.setProcessedPointsCounter(timestamp);
+				}
 
-    /* panel that shows the evaluation results */
-    private ClusteringVisualEvalPanel m_evalPanel;
+				Instance next0 = m_stream0.nextInstance().getData();
+				DataPoint point0 = new DataPoint(next0, timestamp);
 
-    /* panel to hold the graph */
-    private GraphCanvas m_graphcanvas;
+				pointBuffer0.add(point0);
+				while (pointBuffer0.size() > m_stream0_decayHorizon) {
+					pointBuffer0.removeFirst();
+				}
 
-    /* reference to the visual panel */
-    private ClusteringVisualTab m_visualPanel;
+				DataPoint point1 = null;
+				if (m_clusterer1 != null) {
+					point1 = new DataPoint(next0, timestamp);
+					pointBuffer1.add(point1);
+					while (pointBuffer1.size() > m_stream0_decayHorizon) {
+						pointBuffer1.removeFirst();
+					}
+				}
 
-    /* all possible clusterings */
-    //not pretty to have all the clusterings, but otherwise we can't just redraw clusterings
-    private Clustering gtClustering0 = null;
-    private Clustering gtClustering1 = null;
-    private Clustering macro0 = null;
-    private Clustering macro1 = null;
-    private Clustering micro0 = null;
-    private Clustering micro1 = null;
+				if (m_visualPanel.isEnabledDrawPoints()) {
+					m_streampanel0.drawPoint(point0);
+					if (m_clusterer1 != null)
+						m_streampanel1.drawPoint(point1);
+					if (processCounter % m_redrawInterval == 0) {
+						m_streampanel0.applyDrawDecay(m_stream0_decayHorizon / (float) (m_redrawInterval));
+						if (m_clusterer1 != null)
+							m_streampanel1.applyDrawDecay(m_stream0_decayHorizon / (float) (m_redrawInterval));
+					}
+				}
 
-    /* holds all the events that have happend, if the stream supports events */
-    private ArrayList<ClusterEvent> clusterEvents;
+				Instance traininst0 = new DenseInstance(point0);
+				if (m_clusterer0.keepClassLabel())
+					traininst0.setDataset(point0.dataset());
+				else
+					traininst0.deleteAttributeAt(point0.classIndex());
+				m_clusterer0.trainOnInstanceImpl(traininst0);
+
+				if (m_clusterer1 != null) {
+					Instance traininst1 = new DenseInstance(point1);
+					if (m_clusterer1.keepClassLabel())
+						traininst1.setDataset(point1.dataset());
+					else
+						traininst1.deleteAttributeAt(point1.classIndex());
+					m_clusterer1.trainOnInstanceImpl(traininst1);
+				}
 
-    /* reference to the log panel */
-    private final TextViewerPanel m_logPanel;
+				if (processCounter >= m_processFrequency) {
+					processCounter = 0;
+					for (DataPoint p : pointBuffer0)
+						p.updateWeight(timestamp, m_stream0_decay_rate);
 
-    public RunVisualizer(ClusteringVisualTab visualPanel, ClusteringSetupTab clusteringSetupTab){
-        m_visualPanel = visualPanel;
-        m_streampanel0 = visualPanel.getLeftStreamPanel();
-        m_streampanel1 = visualPanel.getRightStreamPanel();
-        m_graphcanvas = visualPanel.getGraphCanvas();
-        m_evalPanel = visualPanel.getEvalPanel();
-        m_logPanel = clusteringSetupTab.getLogPanel();
+					pointarray0 = new ArrayList<>(pointBuffer0);
 
-        m_stream0 = clusteringSetupTab.getStream0();
-        m_stream0_decayHorizon = m_stream0.getDecayHorizon();
-        m_stream0_decay_threshold = m_stream0.getDecayThreshold();
-        m_stream0_decay_rate = (Math.log(1.0/m_stream0_decay_threshold)/Math.log(2)/m_stream0_decayHorizon);
+					if (m_clusterer1 != null) {
+						for (DataPoint p : pointBuffer1)
+							p.updateWeight(timestamp, m_stream0_decay_rate);
 
-        timestamp = 0;
-        lastPauseTimestamp = 0;
-        work = true;
+						pointarray1 = new ArrayList<>(pointBuffer1);
+					}
 
+					processClusterings(pointarray0, pointarray1);
 
-        if(m_stream0 instanceof RandomRBFGeneratorEvents){
-            ((RandomRBFGeneratorEvents)m_stream0).addClusterChangeListener(this);
-            clusterEvents = new ArrayList<ClusterEvent>();
-            m_graphcanvas.setClusterEventsList(clusterEvents);
-        }
-        m_stream0.prepareForUse();
-
-        m_clusterer0 = clusteringSetupTab.getClusterer0();
-        m_clusterer0.prepareForUse();
-
-
-        m_clusterer1 = clusteringSetupTab.getClusterer1();
-        if(m_clusterer1!=null){
-            m_clusterer1.prepareForUse();
-        }
+					int pauseInterval = m_visualPanel.getPauseInterval();
+					if (pauseInterval != 0 && lastPauseTimestamp + pauseInterval <= timestamp) {
+						m_visualPanel.toggleVisualizer(true);
+					}
 
-        m_measures0 = clusteringSetupTab.getMeasures();
-        m_measures1 = clusteringSetupTab.getMeasures();
-
-
-        /* TODO this option needs to move from the stream panel to the setup panel */
-        m_processFrequency = m_stream0.getEvaluationFrequency();
-
-        //get those values from the generator
-        int dims = m_stream0.numAttsOption.getValue();
-        visualPanel.setDimensionComobBoxes(dims);
-        visualPanel.setPauseInterval(initialPauseInterval);
-
-        m_evalPanel.setMeasures(m_measures0, m_measures1, this);
-        m_graphcanvas.setGraph(m_measures0[0], m_measures1[0],0,m_processFrequency);
-    }
-
-
-    public void run() {
-            runVisual();
-    }
-
-
-    public void runVisual() {
-        int processCounter = 0;
-        int speedCounter = 0;
-        LinkedList<DataPoint> pointBuffer0 = new LinkedList<DataPoint>();
-        LinkedList<DataPoint> pointBuffer1 = new LinkedList<DataPoint>();
-        ArrayList<DataPoint> pointarray0 = null;
-        ArrayList<DataPoint> pointarray1 = null;
-
-
-        while(work || processCounter!=0){
-            if (m_stream0.hasMoreInstances()) {
-                timestamp++;
-                speedCounter++;
-                processCounter++;
-                if(timestamp%100 == 0){
-                    m_visualPanel.setProcessedPointsCounter(timestamp);
-                }
-
-                Instance next0 = m_stream0.nextInstance().getData();
-                DataPoint point0 = new DataPoint(next0,timestamp);
-
-                pointBuffer0.add(point0);
-                while(pointBuffer0.size() > m_stream0_decayHorizon){
-                    pointBuffer0.removeFirst();
-                }
-
-                DataPoint point1 = null;
-                if(m_clusterer1!=null){
-                	point1 = new DataPoint(next0,timestamp);
-                	pointBuffer1.add(point1);
-	                while(pointBuffer1.size() > m_stream0_decayHorizon){
-	                    pointBuffer1.removeFirst();
-	                }
-                }
-
-                if(m_visualPanel.isEnabledDrawPoints()){
-                    m_streampanel0.drawPoint(point0);
-                    if(m_clusterer1!=null)
-                        m_streampanel1.drawPoint(point1);
-                    if(processCounter%m_redrawInterval==0){
-                        m_streampanel0.applyDrawDecay(m_stream0_decayHorizon/(float)(m_redrawInterval));
-                        if(m_clusterer1!=null)
-                            m_streampanel1.applyDrawDecay(m_stream0_decayHorizon/(float)(m_redrawInterval));
-                    }
-                }
-
-                Instance traininst0 = new DenseInstance(point0);
-                if(m_clusterer0.keepClassLabel())
-                    traininst0.setDataset(point0.dataset());
-                else
-                    traininst0.deleteAttributeAt(point0.classIndex());
-                m_clusterer0.trainOnInstanceImpl(traininst0);
-
-
-                if(m_clusterer1!=null){
-                    Instance traininst1 = new DenseInstance(point1);
-                    if(m_clusterer1.keepClassLabel())
-                        traininst1.setDataset(point1.dataset());
-                    else
-                        traininst1.deleteAttributeAt(point1.classIndex());
-                    m_clusterer1.trainOnInstanceImpl(traininst1);
-                }
-
-                if (processCounter >= m_processFrequency) {
-                    processCounter = 0;
-                    for(DataPoint p:pointBuffer0)
-                        p.updateWeight(timestamp, m_stream0_decay_rate);
-
-                    pointarray0 = new ArrayList<DataPoint>(pointBuffer0);
-
-                    if(m_clusterer1!=null){
-                        for(DataPoint p:pointBuffer1)
-                            p.updateWeight(timestamp, m_stream0_decay_rate);
-
-                		pointarray1 = new ArrayList<DataPoint>(pointBuffer1);
-                    }
-
-
-                    processClusterings(pointarray0, pointarray1);
-
-                    int pauseInterval = m_visualPanel.getPauseInterval();
-                    if(pauseInterval!=0 && lastPauseTimestamp+pauseInterval<=timestamp){
-                        m_visualPanel.toggleVisualizer(true);
-                    }
-
-                }
-            } else {
-                System.out.println("DONE");
-                return;
-            }
-            if(speedCounter > m_wait_frequency*30 && m_wait_frequency < 15){
-                try {
-                    synchronized (this) {
-                        if(m_wait_frequency == 0)
-                            wait(50);
-                        else
-                            wait(1);
-                    }
-                } catch (InterruptedException ex) {
-
-                }
-                speedCounter = 0;
-            }
-        }
-        if(!stop){
-            m_streampanel0.drawPointPanels(pointarray0, timestamp, m_stream0_decay_rate, m_stream0_decay_threshold);
-            if(m_clusterer1!=null)
-                m_streampanel1.drawPointPanels(pointarray1, timestamp, m_stream0_decay_rate, m_stream0_decay_threshold);
-            work_pause();
-        }
-    }
-
-    private void processClusterings(ArrayList<DataPoint> points0, ArrayList<DataPoint> points1){
-        gtClustering0 = new Clustering(points0);
-        gtClustering1 = null;
-				if(m_clusterer1!=null){
-						gtClustering1 = new Clustering(points1);
 				}
+			} else {
+				System.out.println("DONE");
+				return;
+			}
+			if (speedCounter > m_wait_frequency * 30 && m_wait_frequency < 15) {
+				try {
+					synchronized (this) {
+						if (m_wait_frequency == 0)
+							wait(50);
+						else
+							wait(1);
+					}
+				} catch (InterruptedException ex) {
 
-        Clustering evalClustering0 = null;
-        Clustering evalClustering1 = null;
-
-        //special case for ClusterGenerator
-        if(gtClustering0!= null){
-            if(m_clusterer0 instanceof ClusterGenerator)
-                ((ClusterGenerator)m_clusterer0).setSourceClustering(gtClustering0);
-            if(m_clusterer1 instanceof ClusterGenerator)
-                ((ClusterGenerator)m_clusterer1).setSourceClustering(gtClustering1);
-        }
-
-        macro0 = m_clusterer0.getClusteringResult();
-        evalClustering0 = macro0;
-
-
-        //TODO: should we check if micro/macro is being drawn or needed for evaluation and skip otherwise to speed things up?
-        if(m_clusterer0.implementsMicroClusterer()){
-            micro0 = m_clusterer0.getMicroClusteringResult();
-            if(macro0 == null && micro0 != null){
-                //TODO: we need a Macro Clusterer Interface and the option for kmeans to use the non optimal centers
-                macro0 = moa.clusterers.KMeans.gaussianMeans(gtClustering0, micro0);
-            }
-            if(m_clusterer0.evaluateMicroClusteringOption.isSet())
-                evalClustering0 = micro0;
-            else
-                evalClustering0 = macro0;
-        }
-
-        if(m_clusterer1!=null){
-            macro1 = m_clusterer1.getClusteringResult();
-            evalClustering1 = macro1;
-            if(m_clusterer1.implementsMicroClusterer()){
-                micro1 = m_clusterer1.getMicroClusteringResult();
-                if(macro1 == null && micro1 != null){
-                        macro1 = moa.clusterers.KMeans.gaussianMeans(gtClustering1, micro1);
-                }
-                if(m_clusterer1.evaluateMicroClusteringOption.isSet())
-                    evalClustering1 = micro1;
-                else
-                    evalClustering1 = macro1;
-            }
-        }
-
-        evaluateClustering(evalClustering0, gtClustering0, points0, true);
-    		evaluateClustering(evalClustering1, gtClustering1, points1, false);
-
-        drawClusterings(points0, points1);
-    }
-
-    private void evaluateClustering(Clustering found_clustering, Clustering trueClustering, ArrayList<DataPoint> points, boolean algorithm0){
-        StringBuilder sb = new StringBuilder();
-        for (int i = 0; i < m_measures0.length; i++) {
-            if(algorithm0){
-                if(found_clustering!=null && found_clustering.size() > 0){
-                    try {
-                        double msec = m_measures0[i].evaluateClusteringPerformance(found_clustering, trueClustering, points);
-                        sb.append(m_measures0[i].getClass().getSimpleName()+" took "+msec+"ms (Mean:"+m_measures0[i].getMeanRunningTime()+")");
-                        sb.append("\n");
-
-                    } catch (Exception ex) { ex.printStackTrace(); }
-                }
-                else{
-                    for(int j = 0; j < m_measures0[i].getNumMeasures(); j++){
-                        m_measures0[i].addEmptyValue(j);
-                    }
-                }
-            }
-            else{
-                if(m_clusterer1!=null && found_clustering!=null && found_clustering.size() > 0){
-                    try {
-                        double msec = m_measures1[i].evaluateClusteringPerformance(found_clustering, trueClustering, points);
-                        sb.append(m_measures1[i].getClass().getSimpleName()+" took "+msec+"ms (Mean:"+m_measures1[i].getMeanRunningTime()+")");
-                        sb.append("\n");
-                    }
-                    catch (Exception ex) { ex.printStackTrace(); }
-                }
-                else{
-                    for(int j = 0; j < m_measures1[i].getNumMeasures(); j++){
-                        m_measures1[i].addEmptyValue(j);
-                    }
-                }
-            }
-        }
-        m_logPanel.setText(sb.toString());
-        m_evalPanel.update();
-        m_graphcanvas.updateCanvas();
-    }
-
-    public void drawClusterings(List<DataPoint> points0, List<DataPoint> points1){
-        if(macro0!= null && macro0.size() > 0)
-                m_streampanel0.drawMacroClustering(macro0, points0, Color.RED);
-        if(micro0!= null && micro0.size() > 0)
-                m_streampanel0.drawMicroClustering(micro0, points0, Color.GREEN);
-        if(gtClustering0!= null && gtClustering0.size() > 0)
-            m_streampanel0.drawGTClustering(gtClustering0, points0, Color.BLACK);
-
-        if(m_clusterer1!=null){
-            if(macro1!= null && macro1.size() > 0)
-                    m_streampanel1.drawMacroClustering(macro1, points1, Color.BLUE);
-            if(micro1!= null && micro1.size() > 0)
-                    m_streampanel1.drawMicroClustering(micro1, points1, Color.GREEN);
-            if(gtClustering1!= null && gtClustering1.size() > 0)
-                m_streampanel1.drawGTClustering(gtClustering1, points1, Color.BLACK);
-        }
-    }
-
-    public void redraw(){
-        m_streampanel0.repaint();
-        m_streampanel1.repaint();
-    }
-
-
-    public static int getCurrentTimestamp(){
-        return timestamp;
-    }
-
-    private void work_pause(){
-        while(!work && !stop){
-            try {
-                synchronized (this) {
-                    wait(1000);
-                }
-            } catch (InterruptedException ex) {
-
-            }
-       }
-       run();
-    }
-
-    public static void pause(){
-        work = false;
-        lastPauseTimestamp = timestamp;
-    }
-
-    public static void resume(){
-        work = true;
-    }
-
-    public void stop(){
-        work = false;
-        stop = true;
-    }
-
-    public void setSpeed(int speed) {
-        m_wait_frequency = speed;
-    }
-
-    public void actionPerformed(ActionEvent e) {
-        //reacte on graph selection and find out which measure was selected
-        int selected = Integer.parseInt(e.getActionCommand());
-        int counter = selected;
-        int m_select = 0;
-        int m_select_offset = 0;
-        boolean found = false;
-        for (int i = 0; i < m_measures0.length; i++) {
-            for (int j = 0; j < m_measures0[i].getNumMeasures(); j++) {
-                if(m_measures0[i].isEnabled(j)){
-                	counter--;
-                    if(counter<0){
-                        m_select = i;
-                        m_select_offset = j;
-                        found = true;
-                        break;
-                    }
-                }
-            }
-            if(found) break;
-        }
-        m_graphcanvas.setGraph(m_measures0[m_select], m_measures1[m_select],m_select_offset,m_processFrequency);
-    }
-
-    public void setPointLayerVisibility(boolean selected) {
-        m_streampanel0.setPointVisibility(selected);
-        m_streampanel1.setPointVisibility(selected);
-    }
-    public void setMicroLayerVisibility(boolean selected) {
-        m_streampanel0.setMicroLayerVisibility(selected);
-        m_streampanel1.setMicroLayerVisibility(selected);
-    }
-    public void setMacroVisibility(boolean selected) {
-        m_streampanel0.setMacroLayerVisibility(selected);
-        m_streampanel1.setMacroLayerVisibility(selected);
-    }
-    public void setGroundTruthVisibility(boolean selected) {
-        m_streampanel0.setGroundTruthLayerVisibility(selected);
-        m_streampanel1.setGroundTruthLayerVisibility(selected);
-    }
-
-    public void changeCluster(ClusterEvent e) {
-        if(clusterEvents!=null) clusterEvents.add(e);
-        System.out.println(e.getType()+": "+e.getMessage());
-    }
-
-
-
-    public void exportCSV(String filepath) {
-        PrintWriter out = null;
-        try {
-            if(!filepath.endsWith(".csv"))
-                filepath+=".csv";
-            out = new PrintWriter(new BufferedWriter(new FileWriter(filepath)));
-            String del = ";";
-
-            Iterator<ClusterEvent> eventIt = null;
-            ClusterEvent event = null;
-            if(clusterEvents!=null && clusterEvents.size() > 0){
-                eventIt = clusterEvents.iterator();
-                event = eventIt.next();
-            }
-
-            //raw data
-            MeasureCollection measurecol[][] = new MeasureCollection[2][];
-            measurecol[0] = m_measures0;
-            measurecol[1] = m_measures1;
-            int numValues = 0;
-            //header
-            out.write("Nr"+del);
-            out.write("Event"+del);
-            for (int m = 0; m < 2; m++) {
-                for (int i = 0; i < measurecol[m].length; i++) {
-                    for (int j = 0; j < measurecol[m][i].getNumMeasures(); j++) {
-                        if(measurecol[m][i].isEnabled(j)){
-                            out.write(m+"-"+measurecol[m][i].getName(j)+del);
-                            numValues = measurecol[m][i].getNumberOfValues(j);
-                        }
-                    }
-                }
-            }
-            out.write("\n");
-
-
-            //rows
-            for (int v = 0; v < numValues; v++){
-                //Nr
-                out.write(v+del);
-
-                //events
-                if(event!=null && event.getTimestamp()<=m_stream0_decayHorizon*v){
-                    out.write(event.getType()+del);
-                    if(eventIt!= null && eventIt.hasNext()){
-                        event=eventIt.next();
-                    }
-                    else
-                        event = null;
-                }
-                else
-                    out.write(del);
-
-                //values
-                for (int m = 0; m < 2; m++) {
-                    for (int i = 0; i < measurecol[m].length; i++) {
-                        for (int j = 0; j < measurecol[m][i].getNumMeasures(); j++) {
-                            if(measurecol[m][i].isEnabled(j)){
-                            		double value = measurecol[m][i].getValue(j, v);
-                            		if(Double.isNaN(value))
-                            			out.write(del);
-                            		else
-                            			out.write(value+del);
-                            }
-                        }
-                    }
-                }
-                out.write("\n");
-            }
-            out.close();
-        } catch (IOException ex) {
-            Logger.getLogger(RunVisualizer.class.getName()).log(Level.SEVERE, null, ex);
-        } finally {
-            out.close();
-        }
-    }
-
-    public void weka() {
-    	try{
-    		Class.forName("weka.gui.Logger");
-    	}
-    	catch (Exception e){
-    		m_logPanel.addText("Please add weka.jar to the classpath to use the Weka explorer.");
-    		return;
-    	}
-
-
-        Clustering wekaClustering;
-        if(m_clusterer0.implementsMicroClusterer() && m_clusterer0.evaluateMicroClusteringOption.isSet())
-            wekaClustering = micro0;
-        else
-            wekaClustering = macro0;
-
-        if(wekaClustering == null || wekaClustering.size()==0){
-            m_logPanel.addText("Empty Clustering");
-            return;
-        }
-
-        int dims = wekaClustering.get(0).getCenter().length;
-        FastVector attributes = new FastVector();
-        for(int i = 0; i < dims; i++)
-                attributes.addElement( new Attribute("att" + i) );
-
-        InstancesHeader instances = new InstancesHeader("trainset",attributes,0);
-
-        for(int c = 0; c < wekaClustering.size(); c++){
-            Cluster cluster = wekaClustering.get(c);
-            Instance inst = new DenseInstance(cluster.getWeight(), cluster.getCenter());
-            inst.setDataset(instances);
-            instances.add(inst);
-        }
-
-        WekaExplorer explorer = new WekaExplorer(instances);
-    }
-
+				}
+				speedCounter = 0;
+			}
+		}
+		if (!stop) {
+			m_streampanel0.drawPointPanels(pointarray0, timestamp, m_stream0_decay_rate, m_stream0_decay_threshold);
+			if (m_clusterer1 != null)
+				m_streampanel1.drawPointPanels(pointarray1, timestamp, m_stream0_decay_rate, m_stream0_decay_threshold);
+			work_pause();
+		}
+	}
+
+	private void processClusterings(ArrayList<DataPoint> points0, ArrayList<DataPoint> points1) {
+		gtClustering0 = new Clustering(points0);
+		gtClustering1 = null;
+		if (m_clusterer1 != null) {
+			gtClustering1 = new Clustering(points1);
+		}
+
+		Clustering evalClustering0 = null;
+		Clustering evalClustering1 = null;
+
+		// special case for ClusterGenerator
+		if (gtClustering0 != null) {
+			if (m_clusterer0 instanceof ClusterGenerator)
+				((ClusterGenerator) m_clusterer0).setSourceClustering(gtClustering0);
+			if (m_clusterer1 instanceof ClusterGenerator)
+				((ClusterGenerator) m_clusterer1).setSourceClustering(gtClustering1);
+		}
+
+		macro0 = m_clusterer0.getClusteringResult();
+		evalClustering0 = macro0;
+
+		// TODO: should we check if micro/macro is being drawn or needed for evaluation
+		// and skip otherwise to speed things up?
+		if (m_clusterer0.implementsMicroClusterer()) {
+			micro0 = m_clusterer0.getMicroClusteringResult();
+			if (macro0 == null && micro0 != null) {
+				// TODO: we need a Macro Clusterer Interface and the option for kmeans to use
+				// the non optimal centers
+				macro0 = moa.learners.clusterers.KMeans.gaussianMeans(gtClustering0, micro0);
+			}
+			if (m_clusterer0.evaluateMicroClusteringOption.isSet())
+				evalClustering0 = micro0;
+			else
+				evalClustering0 = macro0;
+		}
+
+		if (m_clusterer1 != null) {
+			macro1 = m_clusterer1.getClusteringResult();
+			evalClustering1 = macro1;
+			if (m_clusterer1.implementsMicroClusterer()) {
+				micro1 = m_clusterer1.getMicroClusteringResult();
+				if (macro1 == null && micro1 != null) {
+					macro1 = moa.learners.clusterers.KMeans.gaussianMeans(gtClustering1, micro1);
+				}
+				if (m_clusterer1.evaluateMicroClusteringOption.isSet())
+					evalClustering1 = micro1;
+				else
+					evalClustering1 = macro1;
+			}
+		}
+
+		evaluateClustering(evalClustering0, gtClustering0, points0, true);
+		evaluateClustering(evalClustering1, gtClustering1, points1, false);
+
+		drawClusterings(points0, points1);
+	}
+
+	private void evaluateClustering(Clustering found_clustering, Clustering trueClustering, ArrayList<DataPoint> points,
+			boolean algorithm0) {
+		StringBuilder sb = new StringBuilder();
+		for (int i = 0; i < m_measures0.length; i++) {
+			if (algorithm0) {
+				if (found_clustering != null && found_clustering.size() > 0) {
+					try {
+						double msec = m_measures0[i].evaluateClusteringPerformance(found_clustering, trueClustering,
+								points);
+						sb.append(m_measures0[i].getClass().getSimpleName() + " took " + msec + "ms (Mean:"
+								+ m_measures0[i].getMeanRunningTime() + ")");
+						sb.append("\n");
+
+					} catch (Exception ex) {
+						ex.printStackTrace();
+					}
+				} else {
+					for (int j = 0; j < m_measures0[i].getNumMeasures(); j++) {
+						m_measures0[i].addEmptyValue(j);
+					}
+				}
+			} else {
+				if (m_clusterer1 != null && found_clustering != null && found_clustering.size() > 0) {
+					try {
+						double msec = m_measures1[i].evaluateClusteringPerformance(found_clustering, trueClustering,
+								points);
+						sb.append(m_measures1[i].getClass().getSimpleName() + " took " + msec + "ms (Mean:"
+								+ m_measures1[i].getMeanRunningTime() + ")");
+						sb.append("\n");
+					} catch (Exception ex) {
+						ex.printStackTrace();
+					}
+				} else {
+					for (int j = 0; j < m_measures1[i].getNumMeasures(); j++) {
+						m_measures1[i].addEmptyValue(j);
+					}
+				}
+			}
+		}
+		m_logPanel.setText(sb.toString());
+		m_evalPanel.update();
+		m_graphcanvas.updateCanvas();
+	}
+
+	public void drawClusterings(List<DataPoint> points0, List<DataPoint> points1) {
+		if (macro0 != null && macro0.size() > 0)
+			m_streampanel0.drawMacroClustering(macro0, points0, Color.RED);
+		if (micro0 != null && micro0.size() > 0)
+			m_streampanel0.drawMicroClustering(micro0, points0, Color.GREEN);
+		if (gtClustering0 != null && gtClustering0.size() > 0)
+			m_streampanel0.drawGTClustering(gtClustering0, points0, Color.BLACK);
+
+		if (m_clusterer1 != null) {
+			if (macro1 != null && macro1.size() > 0)
+				m_streampanel1.drawMacroClustering(macro1, points1, Color.BLUE);
+			if (micro1 != null && micro1.size() > 0)
+				m_streampanel1.drawMicroClustering(micro1, points1, Color.GREEN);
+			if (gtClustering1 != null && gtClustering1.size() > 0)
+				m_streampanel1.drawGTClustering(gtClustering1, points1, Color.BLACK);
+		}
+	}
+
+	public void redraw() {
+		m_streampanel0.repaint();
+		m_streampanel1.repaint();
+	}
+
+	public static int getCurrentTimestamp() {
+		return timestamp;
+	}
+
+	private void work_pause() {
+		while (!work && !stop) {
+			try {
+				synchronized (this) {
+					wait(1000);
+				}
+			} catch (InterruptedException ex) {
+
+			}
+		}
+		run();
+	}
+
+	public static void pause() {
+		work = false;
+		lastPauseTimestamp = timestamp;
+	}
+
+	public static void resume() {
+		work = true;
+	}
+
+	public void stop() {
+		work = false;
+		stop = true;
+	}
+
+	public void setSpeed(int speed) {
+		m_wait_frequency = speed;
+	}
+
+	@Override
+	public void actionPerformed(ActionEvent e) {
+		// reacte on graph selection and find out which measure was selected
+		int selected = Integer.parseInt(e.getActionCommand());
+		int counter = selected;
+		int m_select = 0;
+		int m_select_offset = 0;
+		boolean found = false;
+		for (int i = 0; i < m_measures0.length; i++) {
+			for (int j = 0; j < m_measures0[i].getNumMeasures(); j++) {
+				if (m_measures0[i].isEnabled(j)) {
+					counter--;
+					if (counter < 0) {
+						m_select = i;
+						m_select_offset = j;
+						found = true;
+						break;
+					}
+				}
+			}
+			if (found)
+				break;
+		}
+		m_graphcanvas.setGraph(m_measures0[m_select], m_measures1[m_select], m_select_offset, m_processFrequency);
+	}
+
+	public void setPointLayerVisibility(boolean selected) {
+		m_streampanel0.setPointVisibility(selected);
+		m_streampanel1.setPointVisibility(selected);
+	}
+
+	public void setMicroLayerVisibility(boolean selected) {
+		m_streampanel0.setMicroLayerVisibility(selected);
+		m_streampanel1.setMicroLayerVisibility(selected);
+	}
+
+	public void setMacroVisibility(boolean selected) {
+		m_streampanel0.setMacroLayerVisibility(selected);
+		m_streampanel1.setMacroLayerVisibility(selected);
+	}
+
+	public void setGroundTruthVisibility(boolean selected) {
+		m_streampanel0.setGroundTruthLayerVisibility(selected);
+		m_streampanel1.setGroundTruthLayerVisibility(selected);
+	}
+
+	@Override
+	public void changeCluster(ClusterEvent e) {
+		if (clusterEvents != null)
+			clusterEvents.add(e);
+		System.out.println(e.getType() + ": " + e.getMessage());
+	}
+
+	public void exportCSV(String filepath) {
+		PrintWriter out = null;
+		try {
+			if (!filepath.endsWith(".csv"))
+				filepath += ".csv";
+			out = new PrintWriter(new BufferedWriter(new FileWriter(filepath)));
+			String del = ";";
+
+			Iterator<ClusterEvent> eventIt = null;
+			ClusterEvent event = null;
+			if (clusterEvents != null && clusterEvents.size() > 0) {
+				eventIt = clusterEvents.iterator();
+				event = eventIt.next();
+			}
+
+			// raw data
+			MeasureCollection measurecol[][] = new MeasureCollection[2][];
+			measurecol[0] = m_measures0;
+			measurecol[1] = m_measures1;
+			int numValues = 0;
+			// header
+			out.write("Nr" + del);
+			out.write("Event" + del);
+			for (int m = 0; m < 2; m++) {
+				for (int i = 0; i < measurecol[m].length; i++) {
+					for (int j = 0; j < measurecol[m][i].getNumMeasures(); j++) {
+						if (measurecol[m][i].isEnabled(j)) {
+							out.write(m + "-" + measurecol[m][i].getName(j) + del);
+							numValues = measurecol[m][i].getNumberOfValues(j);
+						}
+					}
+				}
+			}
+			out.write("\n");
+
+			// rows
+			for (int v = 0; v < numValues; v++) {
+				// Nr
+				out.write(v + del);
+
+				// events
+				if (event != null && event.getTimestamp() <= m_stream0_decayHorizon * v) {
+					out.write(event.getType() + del);
+					if (eventIt != null && eventIt.hasNext()) {
+						event = eventIt.next();
+					} else
+						event = null;
+				} else
+					out.write(del);
+
+				// values
+				for (int m = 0; m < 2; m++) {
+					for (int i = 0; i < measurecol[m].length; i++) {
+						for (int j = 0; j < measurecol[m][i].getNumMeasures(); j++) {
+							if (measurecol[m][i].isEnabled(j)) {
+								double value = measurecol[m][i].getValue(j, v);
+								if (Double.isNaN(value))
+									out.write(del);
+								else
+									out.write(value + del);
+							}
+						}
+					}
+				}
+				out.write("\n");
+			}
+			out.close();
+		} catch (IOException ex) {
+			Logger.getLogger(RunVisualizer.class.getName()).log(Level.SEVERE, null, ex);
+		} finally {
+			out.close();
+		}
+	}
+
+	public void weka() {
+		try {
+			Class.forName("weka.gui.Logger");
+		} catch (Exception e) {
+			m_logPanel.addText("Please add weka.jar to the classpath to use the Weka explorer.");
+			return;
+		}
+
+		Clustering wekaClustering;
+		if (m_clusterer0.implementsMicroClusterer() && m_clusterer0.evaluateMicroClusteringOption.isSet())
+			wekaClustering = micro0;
+		else
+			wekaClustering = macro0;
+
+		if (wekaClustering == null || wekaClustering.size() == 0) {
+			m_logPanel.addText("Empty Clustering");
+			return;
+		}
+
+		int dims = wekaClustering.get(0).getCenter().length;
+		FastVector attributes = new FastVector();
+		for (int i = 0; i < dims; i++)
+			attributes.addElement(new Attribute("att" + i));
+
+		InstancesHeader instances = new InstancesHeader("trainset", attributes, 0);
+
+		for (int c = 0; c < wekaClustering.size(); c++) {
+			Cluster cluster = wekaClustering.get(c);
+			Instance inst = new DenseInstance(cluster.getWeight(), cluster.getCenter());
+			inst.setDataset(instances);
+			instances.add(inst);
+		}
+
+		WekaExplorer explorer = new WekaExplorer(instances);
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/visualization/StreamOutlierPanel.java b/moa/src/main/java/moa/gui/visualization/StreamOutlierPanel.java
index 58f95e1a7..4359bb8ca 100644
--- a/moa/src/main/java/moa/gui/visualization/StreamOutlierPanel.java
+++ b/moa/src/main/java/moa/gui/visualization/StreamOutlierPanel.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.gui.visualization;
@@ -46,431 +46,427 @@
 import javax.swing.JScrollPane;
 
 import moa.cluster.SphereCluster;
-import moa.clusterers.outliers.MyBaseOutlierDetector;
-import moa.clusterers.outliers.MyBaseOutlierDetector.Outlier;
+import moa.learners.clusterers.outliers.MyBaseOutlierDetector;
+import moa.learners.clusterers.outliers.MyBaseOutlierDetector.Outlier;
 
 public class StreamOutlierPanel extends JPanel implements ComponentListener {
-    private OutlierPanel highlighted_outlier = null;
-    private double zoom_factor = 0.2;
-    private int zoom = 1;
-    private int width_org;
-    private int height_org;
-    private int activeXDim = 0;
-    private int activeYDim = 1;
-    
-    private JPanel layerOutliers;
-    private LabelAlgorithmPanel layerAlgorithmTitle;
-    
-    private RunOutlierVisualizer m_visualizer = null;
-    private MyBaseOutlierDetector m_outlierDetector = null;    
-    
-    //Buffered Image stuff
-    private BufferedImage pointImg;
-    private BufferedImage canvasImg; 
-    private ImgPanel layerCanvas;
-    private boolean bAntiAlias = false;
-    private int EVENTSIZE = 10;
-
-    class ImgPanel extends JPanel{
-        public BufferedImage image = null;
-        public void setImage(BufferedImage image){
-            setSize(image.getWidth(), image.getWidth());
-            this.image = image;
-        }
-        @Override
-        protected void paintComponent(Graphics g) {
-            Graphics2D g2 = (Graphics2D)g;
-            if(image!=null)
-                g2.drawImage(image, null, 0, 0);
-        }
-    }
-    
-    class LabelAlgorithmPanel extends JPanel{
-        public Color color;
-        
-        public LabelAlgorithmPanel() {
-            setOpaque(true);
-            setLayout(null);
-        }
-        
-        @Override
-        protected void paintComponent(Graphics g) {
-            Graphics2D g2 = (Graphics2D)g;
-            g2.setColor(color);
-            g2.fillRect(0, 0, getWidth(), getHeight());
-        }
-    }
-
-    public StreamOutlierPanel(Color colorAlgorithmTitle) {
-        initComponents();
-        
-        layerAlgorithmTitle = new LabelAlgorithmPanel();
-        layerAlgorithmTitle.color = colorAlgorithmTitle;
-        add(layerAlgorithmTitle);
-        
-        layerOutliers = getNewLayer();                
-        add(layerOutliers);
-        
-        layerCanvas = new ImgPanel();
-        add(layerCanvas);
-        
-        addComponentListener(this);        
-    }
-
-    private JPanel getNewLayer(){
-        JPanel layer = new JPanel();
-        layer.setOpaque(false);
-        layer.setLayout(null);
-        return layer;
-    }
-    
-    public void drawOutliers(Vector<Outlier> outliers, Color color){
-        drawOutliers(layerOutliers, outliers, color);
-    }
-    
-    public void repaintOutliers() {
-        layerOutliers.repaint();
-    }
-    
-    public void setOutliersVisibility(boolean visibility){
-        layerOutliers.setVisible(visibility);
-        layerOutliers.repaint();
-    }
-    
-    public void setPointsVisibility(boolean visibility){        
-        layerCanvas.setVisible(visibility);       
-        layerCanvas.repaint();
-    }
-    
-    public void clearPoints() {
-        Graphics2D imageGraphics = (Graphics2D) pointImg.createGraphics();
-                
-        imageGraphics.setColor(Color.WHITE);       
-        imageGraphics.setPaint(Color.WHITE);
-        imageGraphics.fill(new Rectangle2D.Double(0, 0, getWidth(), getHeight()));
-           
-        ApplyToCanvas(pointImg);
-        RedrawPointLayer();
-    }
-    
-    public void clearEvents() {
-        ApplyToCanvas(pointImg);
-        //RedrawPointLayer();
-    }
-    
-    public void ApplyToCanvas(BufferedImage img) {
-        Graphics2D g = (Graphics2D) canvasImg.createGraphics();
-        g.drawImage(img, 0, 0, this);
-    }
-    
-    public void RedrawPointLayer() {
-        //System.out.println("print?");
-        layerCanvas.setImage(canvasImg);
-        layerCanvas.repaint();
-    }
-    
-    private void drawPoint(
-            DataPoint point, 
-            boolean bShowDecay,
-            Color c, 
-            boolean bFill,
-            boolean bRedrawPointImg)
-    {
-        Graphics2D imageGraphics = (Graphics2D) pointImg.createGraphics();
-
-        if (bAntiAlias) {
-            imageGraphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
-                    RenderingHints.VALUE_ANTIALIAS_ON);
-        }
-
-        int size = Math.min(getWidth(), getHeight());
-        int x = (int) Math.round(point.value(getActiveXDim()) * size);
-        int y = (int) Math.round(point.value(getActiveYDim()) * size);
-        //System.out.println("drawPoint: size="+size+" x="+x+" y="+y);
-
-        if (c == null) {
-            // fixed color of points
-            c = Color.GRAY;
-            // get a color by class of point
-            // Color c = PointPanel.getPointColorbyClass((int)point.classValue(), 10);        
-        }
-        
-        if (bShowDecay) {
-            int minValue = 40; // 20
-            double w = point.weight();            
-            int alpha = (int) (255 * w + minValue);
-            if (alpha > 255) alpha = 255;
-            //System.out.println("alpha="+alpha+"w="+w);
-            c = new Color(c.getRed(),c.getGreen(),c.getBlue(),alpha);
-        }
-        
-        imageGraphics.setColor(c);
-        int psize = PointPanel.POINTSIZE;
-        int poffset = 2;
-        imageGraphics.drawOval(x - poffset, y - poffset, psize, psize);
-        if (bFill) imageGraphics.fillOval(x - poffset, y - poffset, psize, psize);
-        
-        if (bRedrawPointImg) {
-            ApplyToCanvas(pointImg);
-            RedrawPointLayer();
-        }
-    }
-
-    public void drawPoint(DataPoint point, boolean bShowDecay, boolean bRedrawPointImg){
-        drawPoint(point, bShowDecay, null, true, bRedrawPointImg);
-    }
-    
-    /*public static BufferedImage duplicateImage(BufferedImage image) {
-        if (image == null) {
-            throw new NullPointerException();
-        }
-
-        BufferedImage j = new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB);
-        j.setData(image.getData());
-        return j;
-    }*/
-    
-    public void drawEvent(OutlierEvent outlierEvent, boolean bRedrawPointImg)
-    {
-        Graphics2D imageGraphics = (Graphics2D) canvasImg.createGraphics();
-
-        if (bAntiAlias) {
-            imageGraphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
-                    RenderingHints.VALUE_ANTIALIAS_ON);
-        }
-
-        int size = Math.min(getWidth(), getHeight());
-        int x = (int) Math.round(outlierEvent.point.value(getActiveXDim()) * size);
-        int y = (int) Math.round(outlierEvent.point.value(getActiveYDim()) * size);
-        //System.out.println("drawPoint: size="+size+" x="+x+" y="+y);
-
-        Color c = outlierEvent.outlier ? Color.RED : Color.BLACK;
-        
-        imageGraphics.setColor(c);
-        int psize = EVENTSIZE;
-        int poffset = EVENTSIZE / 2;
-        imageGraphics.drawOval(x - poffset, y - poffset, psize, psize);
-
-        if (bRedrawPointImg) {
-            RedrawPointLayer();
-        }
-    }
-
-    public void applyDrawDecay(float factor, boolean bRedrawPointImg){
-        //System.out.println("applyDrawDecay: factor="+factor);
-                
-        // 1)
-        int v = Color.GRAY.getRed();
-        //System.out.println("applyDrawDecay: v="+v);
-        RescaleOp brightenOp = new RescaleOp(1f, (255-v)*factor, null);
-        
-        // 2)
-        //RescaleOp brightenOp = new RescaleOp(1f + factor, 0, null);
-        
-        // 3)
-        //RescaleOp brightenOp = new RescaleOp(1f, (255)*factor, null);
-        
-        pointImg = brightenOp.filter(pointImg, null);
-        
-        if (bRedrawPointImg) {
-            ApplyToCanvas(pointImg);
-            RedrawPointLayer();
-        }
-    }
-
-    private void drawOutliers(JPanel layer, Vector<Outlier> outliers, Color color){        
-        layer.removeAll();
-        for (Outlier outlier : outliers) {  
-            int length = outlier.inst.numValues() - 1; // -1
-            double[] center = new double[length]; // last value is the class
-            for (int i = 0; i < length; i++) {
-                center[i] = outlier.inst.value(i);                
-            }            
-            SphereCluster cluster = new SphereCluster(center, 0);                
-                
-            OutlierPanel outlierpanel = new OutlierPanel(m_outlierDetector, outlier, cluster, color, this);
-            
-            layer.add(outlierpanel);
-            outlierpanel.updateLocation();
-        }
-
-        layer.repaint();
-    }
-
-    public void screenshot(String filename, boolean svg, boolean png){
-    	if(layerOutliers.getComponentCount() == 0)
-            return;
-    	
-        BufferedImage image = new BufferedImage(getWidth(),getHeight(),BufferedImage.TYPE_INT_RGB);
-        if(png){
-            synchronized(getTreeLock()){
-                Graphics g = image.getGraphics();
-                paintAll(g);
-                try {
-                    ImageIO.write(image, "png", new File(filename+".png"));
-                } catch (Exception e) { }
-            }
-        }
-        if(svg){
-            try {
-                PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(filename+".svg")));
-                int width = 500;
-                out.write("<?xml version=\"1.0\"?>\n");
-                out.write("<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n");
-                out.write("<svg xmlns=\"http://www.w3.org/2000/svg\" width=\""+width+"\" height=\""+width+"\">\n");
-
-                if(layerOutliers.isVisible()){
-                    for(Component comp :layerOutliers.getComponents()){
-                        if(comp instanceof ClusterPanel)
-                            out.write(((ClusterPanel)comp).getSVGString(width));
-                    }
-                }
-                
-                out.write("</svg>");
-                out.close();
-            } catch (IOException ex) {
-                Logger.getLogger(StreamPanel.class.getName()).log(Level.SEVERE, null, ex);
-            }
-        }
-    }
-
-    public OutlierPanel getHighlightedOutlierPanel(){
-        return highlighted_outlier;
-    }
-
-    public void setHighlightedOutlierPanel(OutlierPanel outlierpanel){
-        //if (highlighted_outlier == outlierpanel) 
-        //    return;
-        
-        //System.out.println("setHighlightedOutlierPanel");
-        
-        // restore previous highlighted outlier
-        if (highlighted_outlier != null)            
-            highlighted_outlier.highlight(false);
-        
-        highlighted_outlier = outlierpanel;
-        if (highlighted_outlier != null)  
-            highlighted_outlier.highlight(true);
-        
-        repaint();
-    }
-
-    public void setZoom(int x, int y, int zoom_delta, JScrollPane scrollPane){
-        
-        if(zoom ==1){
-            width_org = getWidth();
-            height_org = getHeight();
-        }
-        zoom+=zoom_delta;
-        
-        if(zoom<1) zoom = 1;
-        else{
-            int size = (int)(Math.min(width_org, height_org)*zoom_factor*zoom);
-
-            setSize(new Dimension(size*zoom, size*zoom));
-            setPreferredSize(new Dimension(size*zoom, size*zoom));
-
-            scrollPane.getViewport().setViewPosition(new Point((int)(x*zoom_factor*zoom+x),(int)( y*zoom_factor*zoom+y)));
-        }
-    }
-
-    public int getActiveXDim() {
-        return activeXDim;
-    }
-
-    public void setActiveXDim(int activeXDim) {
-        this.activeXDim = activeXDim;
-    }
-
-    public int getActiveYDim() {
-        return activeYDim;
-    }
-
-    public void setActiveYDim(int activeYDim) {
-        this.activeYDim = activeYDim;
-    }
-
-    /** This method is called from within the constructor to
-     * initialize the form.
-     * WARNING: Do NOT modify this code. The content of this method is
-     * always regenerated by the Form Editor.
-     */
-    @SuppressWarnings("unchecked")
-    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
-    private void initComponents() {
-
-        setBackground(new java.awt.Color(255, 255, 255));
-        addMouseListener(new java.awt.event.MouseAdapter() {
-            public void mouseClicked(java.awt.event.MouseEvent evt) {
-                formMouseClicked(evt);
-            }
-        });
-
-        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
-        this.setLayout(layout);
-        layout.setHorizontalGroup(
-            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 400, Short.MAX_VALUE)
-        );
-        layout.setVerticalGroup(
-            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 300, Short.MAX_VALUE)
-        );
-    }// </editor-fold>//GEN-END:initComponents
-
-    private void formMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_formMouseClicked       
-        if (highlighted_outlier != null){
-            highlighted_outlier.highlight(false);
-            highlighted_outlier = null;
-        }
-    }//GEN-LAST:event_formMouseClicked
-
-    // Variables declaration - do not modify//GEN-BEGIN:variables
-    // End of variables declaration//GEN-END:variables
-    
-    public void setVisualizer(RunOutlierVisualizer v) {
-        m_visualizer = v;
-    }
-    
-    public void setOutlierDetector(MyBaseOutlierDetector outlierDetector) {
-        m_outlierDetector = outlierDetector;
-    }
-    
-    @Override
-    public void componentHidden(ComponentEvent e) {
-    }
-
-    @Override
-    public void componentMoved(ComponentEvent e) {
-    }
-
-    @Override
-    public void componentResized(ComponentEvent e) {
-        //System.out.println("componentResized");
-
-        int heightAlgorithmTitle = 2;
-        int size = Math.min(getWidth(), getHeight() - heightAlgorithmTitle);
-        layerOutliers.setBounds(0, heightAlgorithmTitle, size, size);
-        layerAlgorithmTitle.setBounds(0, 0, getWidth(), heightAlgorithmTitle);
-
-        pointImg = new BufferedImage(size, size, BufferedImage.TYPE_INT_RGB);
-        canvasImg = new BufferedImage(size, size, BufferedImage.TYPE_INT_RGB);
-        layerCanvas.setBounds(0, heightAlgorithmTitle, size, size); 
-
-        Graphics2D imageGraphics = (Graphics2D) pointImg.getGraphics();
-        imageGraphics.setColor(Color.white);
-        imageGraphics.fillRect(0, 0, getWidth(), getHeight());
-        imageGraphics.dispose();    
-               
-        ApplyToCanvas(pointImg);
-        RedrawPointLayer();
-        
-        if (m_visualizer != null) {
-            m_visualizer.redrawOnResize();
-        }
-    }
-
-    @Override
-    public void componentShown(ComponentEvent e) {
-    }
+	private OutlierPanel highlighted_outlier = null;
+	private double zoom_factor = 0.2;
+	private int zoom = 1;
+	private int width_org;
+	private int height_org;
+	private int activeXDim = 0;
+	private int activeYDim = 1;
+
+	private JPanel layerOutliers;
+	private LabelAlgorithmPanel layerAlgorithmTitle;
+
+	private RunOutlierVisualizer m_visualizer = null;
+	private MyBaseOutlierDetector m_outlierDetector = null;
+
+	// Buffered Image stuff
+	private BufferedImage pointImg;
+	private BufferedImage canvasImg;
+	private ImgPanel layerCanvas;
+	private boolean bAntiAlias = false;
+	private int EVENTSIZE = 10;
+
+	class ImgPanel extends JPanel {
+		public BufferedImage image = null;
+
+		public void setImage(BufferedImage image) {
+			setSize(image.getWidth(), image.getWidth());
+			this.image = image;
+		}
+
+		@Override
+		protected void paintComponent(Graphics g) {
+			Graphics2D g2 = (Graphics2D) g;
+			if (image != null)
+				g2.drawImage(image, null, 0, 0);
+		}
+	}
+
+	class LabelAlgorithmPanel extends JPanel {
+		public Color color;
+
+		public LabelAlgorithmPanel() {
+			setOpaque(true);
+			setLayout(null);
+		}
+
+		@Override
+		protected void paintComponent(Graphics g) {
+			Graphics2D g2 = (Graphics2D) g;
+			g2.setColor(color);
+			g2.fillRect(0, 0, getWidth(), getHeight());
+		}
+	}
+
+	public StreamOutlierPanel(Color colorAlgorithmTitle) {
+		initComponents();
+
+		layerAlgorithmTitle = new LabelAlgorithmPanel();
+		layerAlgorithmTitle.color = colorAlgorithmTitle;
+		add(layerAlgorithmTitle);
+
+		layerOutliers = getNewLayer();
+		add(layerOutliers);
+
+		layerCanvas = new ImgPanel();
+		add(layerCanvas);
+
+		addComponentListener(this);
+	}
+
+	private JPanel getNewLayer() {
+		JPanel layer = new JPanel();
+		layer.setOpaque(false);
+		layer.setLayout(null);
+		return layer;
+	}
+
+	public void drawOutliers(Vector<Outlier> outliers, Color color) {
+		drawOutliers(layerOutliers, outliers, color);
+	}
+
+	public void repaintOutliers() {
+		layerOutliers.repaint();
+	}
+
+	public void setOutliersVisibility(boolean visibility) {
+		layerOutliers.setVisible(visibility);
+		layerOutliers.repaint();
+	}
+
+	public void setPointsVisibility(boolean visibility) {
+		layerCanvas.setVisible(visibility);
+		layerCanvas.repaint();
+	}
+
+	public void clearPoints() {
+		Graphics2D imageGraphics = pointImg.createGraphics();
+
+		imageGraphics.setColor(Color.WHITE);
+		imageGraphics.setPaint(Color.WHITE);
+		imageGraphics.fill(new Rectangle2D.Double(0, 0, getWidth(), getHeight()));
+
+		ApplyToCanvas(pointImg);
+		RedrawPointLayer();
+	}
+
+	public void clearEvents() {
+		ApplyToCanvas(pointImg);
+		// RedrawPointLayer();
+	}
+
+	public void ApplyToCanvas(BufferedImage img) {
+		Graphics2D g = canvasImg.createGraphics();
+		g.drawImage(img, 0, 0, this);
+	}
+
+	public void RedrawPointLayer() {
+		// System.out.println("print?");
+		layerCanvas.setImage(canvasImg);
+		layerCanvas.repaint();
+	}
+
+	private void drawPoint(DataPoint point, boolean bShowDecay, Color c, boolean bFill, boolean bRedrawPointImg) {
+		Graphics2D imageGraphics = pointImg.createGraphics();
+
+		if (bAntiAlias) {
+			imageGraphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+		}
+
+		int size = Math.min(getWidth(), getHeight());
+		int x = (int) Math.round(point.value(getActiveXDim()) * size);
+		int y = (int) Math.round(point.value(getActiveYDim()) * size);
+		// System.out.println("drawPoint: size="+size+" x="+x+" y="+y);
+
+		if (c == null) {
+			// fixed color of points
+			c = Color.GRAY;
+			// get a color by class of point
+			// Color c = PointPanel.getPointColorbyClass((int)point.classValue(), 10);
+		}
+
+		if (bShowDecay) {
+			int minValue = 40; // 20
+			double w = point.weight();
+			int alpha = (int) (255 * w + minValue);
+			if (alpha > 255)
+				alpha = 255;
+			// System.out.println("alpha="+alpha+"w="+w);
+			c = new Color(c.getRed(), c.getGreen(), c.getBlue(), alpha);
+		}
+
+		imageGraphics.setColor(c);
+		int psize = PointPanel.POINTSIZE;
+		int poffset = 2;
+		imageGraphics.drawOval(x - poffset, y - poffset, psize, psize);
+		if (bFill)
+			imageGraphics.fillOval(x - poffset, y - poffset, psize, psize);
+
+		if (bRedrawPointImg) {
+			ApplyToCanvas(pointImg);
+			RedrawPointLayer();
+		}
+	}
+
+	public void drawPoint(DataPoint point, boolean bShowDecay, boolean bRedrawPointImg) {
+		drawPoint(point, bShowDecay, null, true, bRedrawPointImg);
+	}
+
+	/*
+	 * public static BufferedImage duplicateImage(BufferedImage image) { if (image
+	 * == null) { throw new NullPointerException(); }
+	 * 
+	 * BufferedImage j = new BufferedImage(image.getWidth(), image.getHeight(),
+	 * BufferedImage.TYPE_INT_ARGB); j.setData(image.getData()); return j; }
+	 */
+
+	public void drawEvent(OutlierEvent outlierEvent, boolean bRedrawPointImg) {
+		Graphics2D imageGraphics = canvasImg.createGraphics();
+
+		if (bAntiAlias) {
+			imageGraphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+		}
+
+		int size = Math.min(getWidth(), getHeight());
+		int x = (int) Math.round(outlierEvent.point.value(getActiveXDim()) * size);
+		int y = (int) Math.round(outlierEvent.point.value(getActiveYDim()) * size);
+		// System.out.println("drawPoint: size="+size+" x="+x+" y="+y);
+
+		Color c = outlierEvent.outlier ? Color.RED : Color.BLACK;
+
+		imageGraphics.setColor(c);
+		int psize = EVENTSIZE;
+		int poffset = EVENTSIZE / 2;
+		imageGraphics.drawOval(x - poffset, y - poffset, psize, psize);
+
+		if (bRedrawPointImg) {
+			RedrawPointLayer();
+		}
+	}
+
+	public void applyDrawDecay(float factor, boolean bRedrawPointImg) {
+		// System.out.println("applyDrawDecay: factor="+factor);
+
+		// 1)
+		int v = Color.GRAY.getRed();
+		// System.out.println("applyDrawDecay: v="+v);
+		RescaleOp brightenOp = new RescaleOp(1f, (255 - v) * factor, null);
+
+		// 2)
+		// RescaleOp brightenOp = new RescaleOp(1f + factor, 0, null);
+
+		// 3)
+		// RescaleOp brightenOp = new RescaleOp(1f, (255)*factor, null);
+
+		pointImg = brightenOp.filter(pointImg, null);
+
+		if (bRedrawPointImg) {
+			ApplyToCanvas(pointImg);
+			RedrawPointLayer();
+		}
+	}
+
+	private void drawOutliers(JPanel layer, Vector<Outlier> outliers, Color color) {
+		layer.removeAll();
+		for (Outlier outlier : outliers) {
+			int length = outlier.inst.numValues() - 1; // -1
+			double[] center = new double[length]; // last value is the class
+			for (int i = 0; i < length; i++) {
+				center[i] = outlier.inst.value(i);
+			}
+			SphereCluster cluster = new SphereCluster(center, 0);
+
+			OutlierPanel outlierpanel = new OutlierPanel(m_outlierDetector, outlier, cluster, color, this);
+
+			layer.add(outlierpanel);
+			outlierpanel.updateLocation();
+		}
+
+		layer.repaint();
+	}
+
+	public void screenshot(String filename, boolean svg, boolean png) {
+		if (layerOutliers.getComponentCount() == 0)
+			return;
+
+		BufferedImage image = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_INT_RGB);
+		if (png) {
+			synchronized (getTreeLock()) {
+				Graphics g = image.getGraphics();
+				paintAll(g);
+				try {
+					ImageIO.write(image, "png", new File(filename + ".png"));
+				} catch (Exception e) {
+				}
+			}
+		}
+		if (svg) {
+			try {
+				PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(filename + ".svg")));
+				int width = 500;
+				out.write("<?xml version=\"1.0\"?>\n");
+				out.write(
+						"<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n");
+				out.write("<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"" + width + "\" height=\"" + width
+						+ "\">\n");
+
+				if (layerOutliers.isVisible()) {
+					for (Component comp : layerOutliers.getComponents()) {
+						if (comp instanceof ClusterPanel)
+							out.write(((ClusterPanel) comp).getSVGString(width));
+					}
+				}
+
+				out.write("</svg>");
+				out.close();
+			} catch (IOException ex) {
+				Logger.getLogger(StreamPanel.class.getName()).log(Level.SEVERE, null, ex);
+			}
+		}
+	}
+
+	public OutlierPanel getHighlightedOutlierPanel() {
+		return highlighted_outlier;
+	}
+
+	public void setHighlightedOutlierPanel(OutlierPanel outlierpanel) {
+		// if (highlighted_outlier == outlierpanel)
+		// return;
+
+		// System.out.println("setHighlightedOutlierPanel");
+
+		// restore previous highlighted outlier
+		if (highlighted_outlier != null)
+			highlighted_outlier.highlight(false);
+
+		highlighted_outlier = outlierpanel;
+		if (highlighted_outlier != null)
+			highlighted_outlier.highlight(true);
+
+		repaint();
+	}
+
+	public void setZoom(int x, int y, int zoom_delta, JScrollPane scrollPane) {
+
+		if (zoom == 1) {
+			width_org = getWidth();
+			height_org = getHeight();
+		}
+		zoom += zoom_delta;
+
+		if (zoom < 1)
+			zoom = 1;
+		else {
+			int size = (int) (Math.min(width_org, height_org) * zoom_factor * zoom);
+
+			setSize(new Dimension(size * zoom, size * zoom));
+			setPreferredSize(new Dimension(size * zoom, size * zoom));
+
+			scrollPane.getViewport()
+					.setViewPosition(new Point((int) (x * zoom_factor * zoom + x), (int) (y * zoom_factor * zoom + y)));
+		}
+	}
+
+	public int getActiveXDim() {
+		return activeXDim;
+	}
+
+	public void setActiveXDim(int activeXDim) {
+		this.activeXDim = activeXDim;
+	}
+
+	public int getActiveYDim() {
+		return activeYDim;
+	}
+
+	public void setActiveYDim(int activeYDim) {
+		this.activeYDim = activeYDim;
+	}
+
+	/**
+	 * This method is called from within the constructor to initialize the form.
+	 * WARNING: Do NOT modify this code. The content of this method is always
+	 * regenerated by the Form Editor.
+	 */
+	@SuppressWarnings("unchecked")
+	// <editor-fold defaultstate="collapsed" desc="Generated
+	// Code">//GEN-BEGIN:initComponents
+	private void initComponents() {
+
+		setBackground(new java.awt.Color(255, 255, 255));
+		addMouseListener(new java.awt.event.MouseAdapter() {
+			@Override
+			public void mouseClicked(java.awt.event.MouseEvent evt) {
+				formMouseClicked(evt);
+			}
+		});
+
+		javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
+		this.setLayout(layout);
+		layout.setHorizontalGroup(
+				layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 400, Short.MAX_VALUE));
+		layout.setVerticalGroup(
+				layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 300, Short.MAX_VALUE));
+	}// </editor-fold>//GEN-END:initComponents
+
+	private void formMouseClicked(java.awt.event.MouseEvent evt) {// GEN-FIRST:event_formMouseClicked
+		if (highlighted_outlier != null) {
+			highlighted_outlier.highlight(false);
+			highlighted_outlier = null;
+		}
+	}// GEN-LAST:event_formMouseClicked
+
+	// Variables declaration - do not modify//GEN-BEGIN:variables
+	// End of variables declaration//GEN-END:variables
+
+	public void setVisualizer(RunOutlierVisualizer v) {
+		m_visualizer = v;
+	}
+
+	public void setOutlierDetector(MyBaseOutlierDetector outlierDetector) {
+		m_outlierDetector = outlierDetector;
+	}
+
+	@Override
+	public void componentHidden(ComponentEvent e) {
+	}
+
+	@Override
+	public void componentMoved(ComponentEvent e) {
+	}
+
+	@Override
+	public void componentResized(ComponentEvent e) {
+		// System.out.println("componentResized");
+
+		int heightAlgorithmTitle = 2;
+		int size = Math.min(getWidth(), getHeight() - heightAlgorithmTitle);
+		layerOutliers.setBounds(0, heightAlgorithmTitle, size, size);
+		layerAlgorithmTitle.setBounds(0, 0, getWidth(), heightAlgorithmTitle);
+
+		pointImg = new BufferedImage(size, size, BufferedImage.TYPE_INT_RGB);
+		canvasImg = new BufferedImage(size, size, BufferedImage.TYPE_INT_RGB);
+		layerCanvas.setBounds(0, heightAlgorithmTitle, size, size);
+
+		Graphics2D imageGraphics = (Graphics2D) pointImg.getGraphics();
+		imageGraphics.setColor(Color.white);
+		imageGraphics.fillRect(0, 0, getWidth(), getHeight());
+		imageGraphics.dispose();
+
+		ApplyToCanvas(pointImg);
+		RedrawPointLayer();
+
+		if (m_visualizer != null) {
+			m_visualizer.redrawOnResize();
+		}
+	}
+
+	@Override
+	public void componentShown(ComponentEvent e) {
+	}
 }
diff --git a/moa/src/main/java/moa/gui/visualization/StreamPanel.java b/moa/src/main/java/moa/gui/visualization/StreamPanel.java
index 0a87d74e6..1cc608054 100644
--- a/moa/src/main/java/moa/gui/visualization/StreamPanel.java
+++ b/moa/src/main/java/moa/gui/visualization/StreamPanel.java
@@ -1,10 +1,10 @@
 /**
  * StreamPanel.java
- * 
+ *
  * @author Timm Jansen (moa@cs.rwth-aachen.de)
  * @editor Yunsu Kim
- * 
- * Last edited: 2013/06/02 
+ *
+ * Last edited: 2013/06/02
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
@@ -17,8 +17,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.gui.visualization;
@@ -51,401 +51,400 @@
 import moa.cluster.Cluster;
 import moa.cluster.Clustering;
 import moa.cluster.SphereCluster;
-import moa.clusterers.macro.NonConvexCluster;
+import moa.learners.clusterers.macro.NonConvexCluster;
 
-public class StreamPanel extends JPanel implements ComponentListener{
+public class StreamPanel extends JPanel implements ComponentListener {
 
-    /**
-	 * 
+	/**
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
-	
+
 	private ClusterPanel highlighted_cluster = null;
-    private double zoom_factor = 0.2;
-    private int zoom = 1;
-    private int width_org;
-    private int height_org;
-    private int activeXDim = 0;
-    private int activeYDim = 1;
-
-    
-    private JPanel layerPoints;
-    private JPanel layerMicro;
-    private JPanel layerMacro;
-    private JPanel layerGroundTruth;
-
-    //Buffered Image stuff
-    private BufferedImage pointCanvas;
-    private pointCanvasPanel layerPointCanvas;
-    private boolean pointsVisible = true;
-    private boolean ANTIALIAS = false;
-
-
-    class pointCanvasPanel extends JPanel{
-        /**
-		 * 
+	private double zoom_factor = 0.2;
+	private int zoom = 1;
+	private int width_org;
+	private int height_org;
+	private int activeXDim = 0;
+	private int activeYDim = 1;
+
+	private JPanel layerPoints;
+	private JPanel layerMicro;
+	private JPanel layerMacro;
+	private JPanel layerGroundTruth;
+
+	// Buffered Image stuff
+	private BufferedImage pointCanvas;
+	private pointCanvasPanel layerPointCanvas;
+	private boolean pointsVisible = true;
+	private boolean ANTIALIAS = false;
+
+	class pointCanvasPanel extends JPanel {
+		/**
+		 *
 		 */
 		private static final long serialVersionUID = 1L;
-		
+
 		BufferedImage image = null;
-        public void setImage(BufferedImage image){
-            setSize(image.getWidth(), image.getWidth());
-            this.image = image;
-        }
-        @Override
-        protected void paintComponent(Graphics g) {
-            Graphics2D g2 = (Graphics2D)g;
-            if(image!=null)
-                g2.drawImage(image, null, 0, 0);
-        }
-    }
-
-
-    /** Creates new form StreamPanel */
-    public StreamPanel() {
-        initComponents();
-
-        layerPoints = getNewLayer();
-        layerPoints.setOpaque(true);
-        layerPoints.setBackground(Color.white);
-        
-        layerMicro = getNewLayer();
-        layerMacro = getNewLayer();
-        layerGroundTruth = getNewLayer();
-
-        add(layerMacro);
-        add(layerMicro);
-        add(layerGroundTruth);
-        add(layerPoints);
-
-        layerPointCanvas = new pointCanvasPanel();
-        add(layerPointCanvas);
-        
-        addComponentListener(this);
-        
-    }
-
-
-    private JPanel getNewLayer(){
-        JPanel layer = new JPanel();
-        layer.setOpaque(false);
-        layer.setLayout(null);
-        return layer;
-    }
-
-
-    public void drawMicroClustering(Clustering clustering, List<DataPoint> points, Color color){
-        drawClustering(layerMicro, clustering, points, color);
-    }
-    
-    public void drawMacroClustering(Clustering clustering, List<DataPoint> points, Color color){
-        drawClustering(layerMacro, clustering, points, color);
-    }
-    public void drawGTClustering(Clustering clustering, List<DataPoint> points, Color color){
-        drawClustering(layerGroundTruth, clustering, points, color);
-    }
-
-    public void setMicroLayerVisibility(boolean visibility){
-        layerMicro.setVisible(visibility);
-    }
-    public void setMacroLayerVisibility(boolean visibility){
-        layerMacro.setVisible(visibility);
-    }
-    public void setGroundTruthLayerVisibility(boolean visibility){
-        layerGroundTruth.setVisible(visibility);
-    }
-    public void setPointVisibility(boolean visibility){
-        pointsVisible = visibility;
-        layerPoints.setVisible(visibility);
-        if(!visibility)
-            layerPointCanvas.setVisible(false);
-    }
-
-    void drawPointPanels(ArrayList<DataPoint> points, int timestamp, double decay_rate, double decay_threshold) {
-        for(int p = 0; p < points.size(); p++){
-            PointPanel pointPanel = new PointPanel(points.get(p), this, decay_rate, decay_threshold);
-            layerPoints.add(pointPanel);
-            pointPanel.updateLocation();
-        }
-        layerPointCanvas.setVisible(false);
-        layerPoints.setVisible(pointsVisible);
-    }
-
-    public void drawPoint(DataPoint point){
-        layerPointCanvas.setVisible(pointsVisible);
-        layerPoints.setVisible(false);
-        if(!pointsVisible)
-            return;
-
-        Graphics2D imageGraphics = (Graphics2D) pointCanvas.createGraphics();
-
-        if (ANTIALIAS) {
-            imageGraphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
-                    RenderingHints.VALUE_ANTIALIAS_ON);
-        }
-
-
-        int size = Math.min(getWidth(), getHeight());
-        int x = (int) Math.round(point.value(getActiveXDim()) * size);
-        int y = (int) Math.round(point.value(getActiveYDim()) * size);
-
-        Color c = PointPanel.getPointColorbyClass(point, 10);
-        imageGraphics.setColor(c);
-        int psize = PointPanel.POINTSIZE;
-        int poffset = 2;
-        imageGraphics.drawOval(x - poffset, y - poffset, psize, psize);
-        imageGraphics.fillOval(x - poffset, y - poffset, psize, psize);
-
-        layerPointCanvas.repaint();
-    }
-
-
-    private void drawClusteringsOnCanvas(JPanel layer, Graphics2D imageGraphics){
-        for(Component comp :layer.getComponents()){
-            if(comp instanceof ClusterPanel){
-                ClusterPanel cp = (ClusterPanel)comp;
-                cp.drawOnCanvas(imageGraphics);
-            }
-        }
-    }
-
-
-    public void applyDrawDecay(float factor){
-
-        RescaleOp brightenOp = new RescaleOp(1f, 150f/factor, null);
-        pointCanvas = brightenOp.filter(pointCanvas, null);
-
-        layerPointCanvas.setImage(pointCanvas);
-        layerPointCanvas.repaint();
-    }
-
-    private void drawClustering(JPanel layer, Clustering clustering, List<DataPoint> points, Color color){
-        if (clustering.get(0) instanceof NonConvexCluster) {
-        	drawNonConvexClustering(layer, clustering, points, color);
-        } else {	
-	    	layer.removeAll();
-	        for (int c = 0; c < clustering.size(); c++) {
-	            SphereCluster cluster = (SphereCluster)clustering.get(c);
-	
-	            ClusterPanel clusterpanel = new ClusterPanel(cluster, color, this);
-	            
-	            layer.add(clusterpanel);
-	            clusterpanel.updateLocation();
-	        }
-	
-	        if(layer.isVisible() && pointsVisible){
-	            Graphics2D imageGraphics = (Graphics2D) pointCanvas.createGraphics();
-	            imageGraphics.setColor(color);
-	            drawClusteringsOnCanvas(layer, imageGraphics);
-	            layerPointCanvas.repaint();
-	        }
-	
-	        layer.repaint();
-        }
-    }
-    
-    private void drawNonConvexClustering(JPanel layer, Clustering clustering, List<DataPoint> points, Color color) {
-    	layerMacro.removeAll();
-    	
-    	List<Cluster> foundClusters = clustering.getClustering();
-    	double inclusionProbabilityThreshold = 0.5;
-    	for (DataPoint p : points) {
-    		for (int i = 0; i < foundClusters.size(); i++) {
-    			Cluster fc = foundClusters.get(i);
-    			if (fc.getInclusionProbability(p) >= inclusionProbabilityThreshold) {
-    				PointPanel pointPanel = new PointPanel(p, this, color);
-    			    layerMacro.add(pointPanel);
-    			    pointPanel.updateLocation();
-    			}
-    		}
-    	}
-
-        if (layerMacro.isVisible() && pointsVisible) {	// Points & Macro together
-            Graphics2D imageGraphics = (Graphics2D) pointCanvas.createGraphics();
-            imageGraphics.setColor(color);
-            drawClusteringsOnCanvas(layerMacro, imageGraphics);
-            layerPointCanvas.repaint();
-        }
-
-        layerMacro.repaint();
-    }
-
-    public void screenshot(String filename, boolean svg, boolean png){
-    	if(layerPoints.getComponentCount()==0 && layerMacro.getComponentCount()==0 && layerMicro.getComponentCount()==0)
-    		return;
-    	
-        BufferedImage image = new BufferedImage(getWidth(),getHeight(),BufferedImage.TYPE_INT_RGB);
-        if(png){
-            synchronized(getTreeLock()){
-                Graphics g = image.getGraphics();
-                paintAll(g);
-                try {
-                    ImageIO.write(image, "png", new File(filename+".png"));
-                } catch (Exception e) {
-                    e.printStackTrace();
-                }
-            }
-        }
-        if(svg){
-            try {
-                PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(filename+".svg")));
-                int width = 500;
-                out.write("<?xml version=\"1.0\"?>\n");
-                out.write("<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n");
-                out.write("<svg xmlns=\"http://www.w3.org/2000/svg\" width=\""+width+"\" height=\""+width+"\">\n");
-
-                if(layerMicro.isVisible()){
-                    for(Component comp :layerMicro.getComponents()){
-                        if(comp instanceof ClusterPanel)
-                            out.write(((ClusterPanel)comp).getSVGString(width));
-                    }
-                }
-
-                if(layerMacro.isVisible()){
-                    for(Component comp :layerMacro.getComponents()){
-                        if(comp instanceof ClusterPanel)
-                            out.write(((ClusterPanel)comp).getSVGString(width));
-                    }
-                }
-
-                if(layerGroundTruth.isVisible()){
-                    for(Component comp :layerGroundTruth.getComponents()){
-                        if(comp instanceof ClusterPanel)
-                            out.write(((ClusterPanel)comp).getSVGString(width));
-                    }
-                }
-
-                if(layerPoints.isVisible()){
-                    for(Component comp :layerPoints.getComponents()){
-                        if(comp instanceof PointPanel){
-                            PointPanel pp = (PointPanel) comp;
-                            out.write(pp.getSVGString(width));
-                        }
-                    }
-                }
-                
-                out.write("</svg>");
-                out.close();
-            } catch (IOException ex) {
-                Logger.getLogger(StreamPanel.class.getName()).log(Level.SEVERE, null, ex);
-            }
-        }
-    }
-
-    public ClusterPanel getHighlightedClusterPanel(){
-        return highlighted_cluster;
-    }
-
-    public void setHighlightedClusterPanel(ClusterPanel clusterpanel){
-        highlighted_cluster = clusterpanel;
-        repaint();
-    }
-
-    public void setZoom(int x, int y, int zoom_delta, JScrollPane scrollPane){
-        
-        if(zoom ==1){
-            width_org = getWidth();
-            height_org = getHeight();
-        }
-        zoom+=zoom_delta;
-        
-        if(zoom<1) zoom = 1;
-        else{
-            int size = (int)(Math.min(width_org, height_org)*zoom_factor*zoom);
-
-            setSize(new Dimension(size*zoom, size*zoom));
-            setPreferredSize(new Dimension(size*zoom, size*zoom));
-
-            scrollPane.getViewport().setViewPosition(new Point((int)(x*zoom_factor*zoom+x),(int)( y*zoom_factor*zoom+y)));
-        }
-    }
-
-    public int getActiveXDim() {
-        return activeXDim;
-    }
-
-    public void setActiveXDim(int activeXDim) {
-        this.activeXDim = activeXDim;
-    }
-
-    public int getActiveYDim() {
-        return activeYDim;
-    }
-
-    public void setActiveYDim(int activeYDim) {
-        this.activeYDim = activeYDim;
-    }
-
-    /** This method is called from within the constructor to
-     * initialize the form.
-     * WARNING: Do NOT modify this code. The content of this method is
-     * always regenerated by the Form Editor.
-     */
-    @SuppressWarnings("unchecked")
-    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
-    private void initComponents() {
-
-        setBackground(new java.awt.Color(255, 255, 255));
-        addMouseListener(new java.awt.event.MouseAdapter() {
-            public void mouseClicked(java.awt.event.MouseEvent evt) {
-                formMouseClicked(evt);
-            }
-        });
-
-        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
-        this.setLayout(layout);
-        layout.setHorizontalGroup(
-            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 400, Short.MAX_VALUE)
-        );
-        layout.setVerticalGroup(
-            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
-            .addGap(0, 300, Short.MAX_VALUE)
-        );
-    }// </editor-fold>//GEN-END:initComponents
-
-    private void formMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_formMouseClicked
-        if(highlighted_cluster!=null){
-            highlighted_cluster.highlight(false);
-            highlighted_cluster=null;
-        }
-    }//GEN-LAST:event_formMouseClicked
-
-
-    // Variables declaration - do not modify//GEN-BEGIN:variables
-    // End of variables declaration//GEN-END:variables
-
-    
-    
-    public void componentHidden(ComponentEvent e) {
-    }
-
-    public void componentMoved(ComponentEvent e) {
-    }
-
-    public void componentResized(ComponentEvent e) {
-        //System.out.println(e.getComponent().getClass().getName() + " --- Resized ");
-
-        int size = Math.min(getWidth(), getHeight());
-        layerMicro.setSize(new Dimension(size,size));
-        layerMacro.setSize(new Dimension(size,size));
-        layerGroundTruth.setSize(new Dimension(size,size));
-        layerPoints.setSize(new Dimension(size,size));
-
-
-        pointCanvas = new BufferedImage(size, size, BufferedImage.TYPE_INT_RGB);
-        layerPointCanvas.setSize(new Dimension(size,size));
-        layerPointCanvas.setImage(pointCanvas);
-
-        Graphics2D imageGraphics = (Graphics2D) pointCanvas.getGraphics();
-        imageGraphics.setColor(Color.white);
-        imageGraphics.fillRect(0, 0, getWidth(), getHeight());
-        imageGraphics.dispose();
-
-    }
-
-    public void componentShown(ComponentEvent e) {
-    }
 
+		public void setImage(BufferedImage image) {
+			setSize(image.getWidth(), image.getWidth());
+			this.image = image;
+		}
+
+		@Override
+		protected void paintComponent(Graphics g) {
+			Graphics2D g2 = (Graphics2D) g;
+			if (image != null)
+				g2.drawImage(image, null, 0, 0);
+		}
+	}
+
+	/** Creates new form StreamPanel */
+	public StreamPanel() {
+		initComponents();
+
+		layerPoints = getNewLayer();
+		layerPoints.setOpaque(true);
+		layerPoints.setBackground(Color.white);
+
+		layerMicro = getNewLayer();
+		layerMacro = getNewLayer();
+		layerGroundTruth = getNewLayer();
+
+		add(layerMacro);
+		add(layerMicro);
+		add(layerGroundTruth);
+		add(layerPoints);
+
+		layerPointCanvas = new pointCanvasPanel();
+		add(layerPointCanvas);
+
+		addComponentListener(this);
+
+	}
+
+	private JPanel getNewLayer() {
+		JPanel layer = new JPanel();
+		layer.setOpaque(false);
+		layer.setLayout(null);
+		return layer;
+	}
+
+	public void drawMicroClustering(Clustering clustering, List<DataPoint> points, Color color) {
+		drawClustering(layerMicro, clustering, points, color);
+	}
+
+	public void drawMacroClustering(Clustering clustering, List<DataPoint> points, Color color) {
+		drawClustering(layerMacro, clustering, points, color);
+	}
+
+	public void drawGTClustering(Clustering clustering, List<DataPoint> points, Color color) {
+		drawClustering(layerGroundTruth, clustering, points, color);
+	}
+
+	public void setMicroLayerVisibility(boolean visibility) {
+		layerMicro.setVisible(visibility);
+	}
+
+	public void setMacroLayerVisibility(boolean visibility) {
+		layerMacro.setVisible(visibility);
+	}
+
+	public void setGroundTruthLayerVisibility(boolean visibility) {
+		layerGroundTruth.setVisible(visibility);
+	}
+
+	public void setPointVisibility(boolean visibility) {
+		pointsVisible = visibility;
+		layerPoints.setVisible(visibility);
+		if (!visibility)
+			layerPointCanvas.setVisible(false);
+	}
+
+	void drawPointPanels(ArrayList<DataPoint> points, int timestamp, double decay_rate, double decay_threshold) {
+		for (int p = 0; p < points.size(); p++) {
+			PointPanel pointPanel = new PointPanel(points.get(p), this, decay_rate, decay_threshold);
+			layerPoints.add(pointPanel);
+			pointPanel.updateLocation();
+		}
+		layerPointCanvas.setVisible(false);
+		layerPoints.setVisible(pointsVisible);
+	}
+
+	public void drawPoint(DataPoint point) {
+		layerPointCanvas.setVisible(pointsVisible);
+		layerPoints.setVisible(false);
+		if (!pointsVisible)
+			return;
+
+		Graphics2D imageGraphics = pointCanvas.createGraphics();
+
+		if (ANTIALIAS) {
+			imageGraphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+		}
+
+		int size = Math.min(getWidth(), getHeight());
+		int x = (int) Math.round(point.value(getActiveXDim()) * size);
+		int y = (int) Math.round(point.value(getActiveYDim()) * size);
+
+		Color c = PointPanel.getPointColorbyClass(point, 10);
+		imageGraphics.setColor(c);
+		int psize = PointPanel.POINTSIZE;
+		int poffset = 2;
+		imageGraphics.drawOval(x - poffset, y - poffset, psize, psize);
+		imageGraphics.fillOval(x - poffset, y - poffset, psize, psize);
+
+		layerPointCanvas.repaint();
+	}
+
+	private void drawClusteringsOnCanvas(JPanel layer, Graphics2D imageGraphics) {
+		for (Component comp : layer.getComponents()) {
+			if (comp instanceof ClusterPanel) {
+				ClusterPanel cp = (ClusterPanel) comp;
+				cp.drawOnCanvas(imageGraphics);
+			}
+		}
+	}
+
+	public void applyDrawDecay(float factor) {
+
+		RescaleOp brightenOp = new RescaleOp(1f, 150f / factor, null);
+		pointCanvas = brightenOp.filter(pointCanvas, null);
+
+		layerPointCanvas.setImage(pointCanvas);
+		layerPointCanvas.repaint();
+	}
+
+	private void drawClustering(JPanel layer, Clustering clustering, List<DataPoint> points, Color color) {
+		if (clustering.get(0) instanceof NonConvexCluster) {
+			drawNonConvexClustering(layer, clustering, points, color);
+		} else {
+			layer.removeAll();
+			for (int c = 0; c < clustering.size(); c++) {
+				SphereCluster cluster = (SphereCluster) clustering.get(c);
+
+				ClusterPanel clusterpanel = new ClusterPanel(cluster, color, this);
+
+				layer.add(clusterpanel);
+				clusterpanel.updateLocation();
+			}
+
+			if (layer.isVisible() && pointsVisible) {
+				Graphics2D imageGraphics = pointCanvas.createGraphics();
+				imageGraphics.setColor(color);
+				drawClusteringsOnCanvas(layer, imageGraphics);
+				layerPointCanvas.repaint();
+			}
+
+			layer.repaint();
+		}
+	}
+
+	private void drawNonConvexClustering(JPanel layer, Clustering clustering, List<DataPoint> points, Color color) {
+		layerMacro.removeAll();
+
+		List<Cluster> foundClusters = clustering.getClustering();
+		double inclusionProbabilityThreshold = 0.5;
+		for (DataPoint p : points) {
+			for (int i = 0; i < foundClusters.size(); i++) {
+				Cluster fc = foundClusters.get(i);
+				if (fc.getInclusionProbability(p) >= inclusionProbabilityThreshold) {
+					PointPanel pointPanel = new PointPanel(p, this, color);
+					layerMacro.add(pointPanel);
+					pointPanel.updateLocation();
+				}
+			}
+		}
+
+		if (layerMacro.isVisible() && pointsVisible) { // Points & Macro together
+			Graphics2D imageGraphics = pointCanvas.createGraphics();
+			imageGraphics.setColor(color);
+			drawClusteringsOnCanvas(layerMacro, imageGraphics);
+			layerPointCanvas.repaint();
+		}
+
+		layerMacro.repaint();
+	}
+
+	public void screenshot(String filename, boolean svg, boolean png) {
+		if (layerPoints.getComponentCount() == 0 && layerMacro.getComponentCount() == 0
+				&& layerMicro.getComponentCount() == 0)
+			return;
+
+		BufferedImage image = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_INT_RGB);
+		if (png) {
+			synchronized (getTreeLock()) {
+				Graphics g = image.getGraphics();
+				paintAll(g);
+				try {
+					ImageIO.write(image, "png", new File(filename + ".png"));
+				} catch (Exception e) {
+					e.printStackTrace();
+				}
+			}
+		}
+		if (svg) {
+			try {
+				PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(filename + ".svg")));
+				int width = 500;
+				out.write("<?xml version=\"1.0\"?>\n");
+				out.write(
+						"<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n");
+				out.write("<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"" + width + "\" height=\"" + width
+						+ "\">\n");
+
+				if (layerMicro.isVisible()) {
+					for (Component comp : layerMicro.getComponents()) {
+						if (comp instanceof ClusterPanel)
+							out.write(((ClusterPanel) comp).getSVGString(width));
+					}
+				}
+
+				if (layerMacro.isVisible()) {
+					for (Component comp : layerMacro.getComponents()) {
+						if (comp instanceof ClusterPanel)
+							out.write(((ClusterPanel) comp).getSVGString(width));
+					}
+				}
+
+				if (layerGroundTruth.isVisible()) {
+					for (Component comp : layerGroundTruth.getComponents()) {
+						if (comp instanceof ClusterPanel)
+							out.write(((ClusterPanel) comp).getSVGString(width));
+					}
+				}
+
+				if (layerPoints.isVisible()) {
+					for (Component comp : layerPoints.getComponents()) {
+						if (comp instanceof PointPanel) {
+							PointPanel pp = (PointPanel) comp;
+							out.write(pp.getSVGString(width));
+						}
+					}
+				}
+
+				out.write("</svg>");
+				out.close();
+			} catch (IOException ex) {
+				Logger.getLogger(StreamPanel.class.getName()).log(Level.SEVERE, null, ex);
+			}
+		}
+	}
+
+	public ClusterPanel getHighlightedClusterPanel() {
+		return highlighted_cluster;
+	}
+
+	public void setHighlightedClusterPanel(ClusterPanel clusterpanel) {
+		highlighted_cluster = clusterpanel;
+		repaint();
+	}
+
+	public void setZoom(int x, int y, int zoom_delta, JScrollPane scrollPane) {
+
+		if (zoom == 1) {
+			width_org = getWidth();
+			height_org = getHeight();
+		}
+		zoom += zoom_delta;
+
+		if (zoom < 1)
+			zoom = 1;
+		else {
+			int size = (int) (Math.min(width_org, height_org) * zoom_factor * zoom);
+
+			setSize(new Dimension(size * zoom, size * zoom));
+			setPreferredSize(new Dimension(size * zoom, size * zoom));
+
+			scrollPane.getViewport()
+					.setViewPosition(new Point((int) (x * zoom_factor * zoom + x), (int) (y * zoom_factor * zoom + y)));
+		}
+	}
+
+	public int getActiveXDim() {
+		return activeXDim;
+	}
+
+	public void setActiveXDim(int activeXDim) {
+		this.activeXDim = activeXDim;
+	}
+
+	public int getActiveYDim() {
+		return activeYDim;
+	}
+
+	public void setActiveYDim(int activeYDim) {
+		this.activeYDim = activeYDim;
+	}
+
+	/**
+	 * This method is called from within the constructor to initialize the form.
+	 * WARNING: Do NOT modify this code. The content of this method is always
+	 * regenerated by the Form Editor.
+	 */
+	@SuppressWarnings("unchecked")
+	// <editor-fold defaultstate="collapsed" desc="Generated
+	// Code">//GEN-BEGIN:initComponents
+	private void initComponents() {
+
+		setBackground(new java.awt.Color(255, 255, 255));
+		addMouseListener(new java.awt.event.MouseAdapter() {
+			@Override
+			public void mouseClicked(java.awt.event.MouseEvent evt) {
+				formMouseClicked(evt);
+			}
+		});
+
+		javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
+		this.setLayout(layout);
+		layout.setHorizontalGroup(
+				layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 400, Short.MAX_VALUE));
+		layout.setVerticalGroup(
+				layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGap(0, 300, Short.MAX_VALUE));
+	}// </editor-fold>//GEN-END:initComponents
+
+	private void formMouseClicked(java.awt.event.MouseEvent evt) {// GEN-FIRST:event_formMouseClicked
+		if (highlighted_cluster != null) {
+			highlighted_cluster.highlight(false);
+			highlighted_cluster = null;
+		}
+	}// GEN-LAST:event_formMouseClicked
+
+	// Variables declaration - do not modify//GEN-BEGIN:variables
+	// End of variables declaration//GEN-END:variables
+
+	@Override
+	public void componentHidden(ComponentEvent e) {
+	}
+
+	@Override
+	public void componentMoved(ComponentEvent e) {
+	}
+
+	@Override
+	public void componentResized(ComponentEvent e) {
+		// System.out.println(e.getComponent().getClass().getName() + " --- Resized ");
+
+		int size = Math.min(getWidth(), getHeight());
+		layerMicro.setSize(new Dimension(size, size));
+		layerMacro.setSize(new Dimension(size, size));
+		layerGroundTruth.setSize(new Dimension(size, size));
+		layerPoints.setSize(new Dimension(size, size));
+
+		pointCanvas = new BufferedImage(size, size, BufferedImage.TYPE_INT_RGB);
+		layerPointCanvas.setSize(new Dimension(size, size));
+		layerPointCanvas.setImage(pointCanvas);
+
+		Graphics2D imageGraphics = (Graphics2D) pointCanvas.getGraphics();
+		imageGraphics.setColor(Color.white);
+		imageGraphics.fillRect(0, 0, getWidth(), getHeight());
+		imageGraphics.dispose();
+
+	}
+
+	@Override
+	public void componentShown(ComponentEvent e) {
+	}
 
 }
diff --git a/moa/src/main/java/moa/gui/visualization/WekaExplorer.java b/moa/src/main/java/moa/gui/visualization/WekaExplorer.java
index d097820b8..7615814c8 100644
--- a/moa/src/main/java/moa/gui/visualization/WekaExplorer.java
+++ b/moa/src/main/java/moa/gui/visualization/WekaExplorer.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
 /**
@@ -27,99 +27,97 @@
 
 package moa.gui.visualization;
 
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
-import moa.gui.LookAndFeel;
-import weka.core.Memory;
-import weka.gui.explorer.Explorer;
-
-import javax.swing.JFrame;
 import java.awt.BorderLayout;
 import java.awt.Image;
 import java.awt.Toolkit;
 import java.awt.event.WindowAdapter;
 import java.awt.event.WindowEvent;
 
-//import weka.gui.LookAndFeel;
+import javax.swing.JFrame;
 
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
+
+import moa.gui.LookAndFeel;
 import weka.core.Memory;
 import weka.gui.explorer.Explorer;
 
-
 public class WekaExplorer {
 
-    private static Explorer m_explorer;
-    /** for monitoring the Memory consumption */
-    private static Memory m_Memory = new Memory(true);
-
-    public WekaExplorer(InstancesHeader instances) {
-        //weka.core.logging.Logger.log(weka.core.logging.Logger.Level.INFO, "Logging started");
-        LookAndFeel.install();
-
-        try {
-            // uncomment to disable the memory management:
-            //m_Memory.setEnabled(false);
-
-            m_explorer = new Explorer();
-            final JFrame jf = new JFrame("Weka Explorer");
-            jf.getContentPane().setLayout(new BorderLayout());
-            jf.getContentPane().add(m_explorer, BorderLayout.CENTER);
-            jf.addWindowListener(new WindowAdapter() {
-
-                public void windowClosing(WindowEvent e) {
-                    jf.dispose();
-                }
-            });
-            jf.pack();
-            jf.setSize(800, 600);
-            jf.setVisible(true);
-            Image icon = Toolkit.getDefaultToolkit().
-                    getImage(ClassLoader.getSystemResource("weka/gui/weka_icon.gif"));
-            jf.setIconImage(icon);
-
-            if(instances !=null){
-                SamoaToWekaInstanceConverter instanceConverter = new SamoaToWekaInstanceConverter();
-                m_explorer.getPreprocessPanel().setInstances(instanceConverter.wekaInstances(instances));
-            }
-
-            Thread memMonitor = new Thread() {
-
-                public void run() {
-                    while (true) {
-                        try {
-                            //System.out.println("Before sleeping.");
-                            this.sleep(4000);
-
-                            System.gc();
-
-                            if (m_Memory.isOutOfMemory()) {
-                                // clean up
-                                jf.dispose();
-                                m_explorer = null;
-                                System.gc();
-
-                                // stop threads
-                                m_Memory.stopThreads();
-
-                                // display error
-                                System.err.println("\ndisplayed message:");
-                                m_Memory.showOutOfMemory();
-                                System.err.println("\nexiting");
-                                System.exit(-1);
-                            }
-
-                        } catch (InterruptedException ex) {
-                            ex.printStackTrace();
-                        }
-                    }
-                }
-            };
-
-            memMonitor.setPriority(Thread.MAX_PRIORITY);
-            memMonitor.start();
-        } catch (Exception ex) {
-            ex.printStackTrace();
-            System.err.println(ex.getMessage());
-        }
-    }
+	private static Explorer m_explorer;
+	/** for monitoring the Memory consumption */
+	private static Memory m_Memory = new Memory(true);
+
+	public WekaExplorer(InstancesHeader instances) {
+		// weka.core.logging.Logger.log(weka.core.logging.Logger.Level.INFO, "Logging
+		// started");
+		LookAndFeel.install();
+
+		try {
+			// uncomment to disable the memory management:
+			// m_Memory.setEnabled(false);
+
+			m_explorer = new Explorer();
+			final JFrame jf = new JFrame("Weka Explorer");
+			jf.getContentPane().setLayout(new BorderLayout());
+			jf.getContentPane().add(m_explorer, BorderLayout.CENTER);
+			jf.addWindowListener(new WindowAdapter() {
+
+				@Override
+				public void windowClosing(WindowEvent e) {
+					jf.dispose();
+				}
+			});
+			jf.pack();
+			jf.setSize(800, 600);
+			jf.setVisible(true);
+			Image icon = Toolkit.getDefaultToolkit().getImage(ClassLoader.getSystemResource("weka/gui/weka_icon.gif"));
+			jf.setIconImage(icon);
+
+			if (instances != null) {
+				SamoaToWekaInstanceConverter instanceConverter = new SamoaToWekaInstanceConverter();
+				m_explorer.getPreprocessPanel().setInstances(instanceConverter.wekaInstances(instances));
+			}
+
+			Thread memMonitor = new Thread() {
+
+				@Override
+				public void run() {
+					while (true) {
+						try {
+							// System.out.println("Before sleeping.");
+							Thread.sleep(4000);
+
+							System.gc();
+
+							if (m_Memory.isOutOfMemory()) {
+								// clean up
+								jf.dispose();
+								m_explorer = null;
+								System.gc();
+
+								// stop threads
+								m_Memory.stopThreads();
+
+								// display error
+								System.err.println("\ndisplayed message:");
+								m_Memory.showOutOfMemory();
+								System.err.println("\nexiting");
+								System.exit(-1);
+							}
+
+						} catch (InterruptedException ex) {
+							ex.printStackTrace();
+						}
+					}
+				}
+			};
+
+			memMonitor.setPriority(Thread.MAX_PRIORITY);
+			memMonitor.start();
+		} catch (Exception ex) {
+			ex.printStackTrace();
+			System.err.println(ex.getMessage());
+		}
+	}
 }
diff --git a/moa/src/main/java/moa/learners/ChangeDetectorLearner.java b/moa/src/main/java/moa/learners/ChangeDetectorLearner.java
deleted file mode 100644
index 91b93308e..000000000
--- a/moa/src/main/java/moa/learners/ChangeDetectorLearner.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- *    ChangeDetectorLearner.java
- *    Copyright (C) 2011 University of Waikato, Hamilton, New Zealand
- *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package moa.learners;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.core.driftdetection.ChangeDetector;
-import moa.core.Measurement;
-import moa.options.ClassOption;
-
-/**
- * Class for detecting concept drift and to be used as a learner.<p>data
- *
- * Valid options are:<p>
- *
- * -l classname <br> Specify the full class name of a classifier as the basis
- * for the concept drift classifier.<p>
- *
- *
- * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * @version $Revision: 7 $
- */
-public class ChangeDetectorLearner extends AbstractClassifier implements Classifier {
-
-    private static final long serialVersionUID = 1L;
-
-    public ClassOption driftDetectionMethodOption = new ClassOption("driftDetectionMethod", 'd',
-            "Drift detection method to use.", ChangeDetector.class, "DDM");
-
-    protected ChangeDetector driftDetectionMethod;
-
-    @Override
-    public void resetLearningImpl() {
-        this.driftDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.driftDetectionMethodOption)).copy();
-    }
-
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        this.driftDetectionMethod.input(inst.value(0));
-
-    }
-
-    public Prediction getPredictionForInstance(Instance inst) {
-        return new ClassificationPrediction(this.driftDetectionMethod.getOutput());
-    }
-
-    public boolean isRandomizable() {
-        return false;
-    }
-
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-        //((AbstractClassifier) this.classifier).getModelDescription(out, indent);
-    }
-
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        //return ((AbstractClassifier) this.classifier).getModelMeasurementsImpl();
-        return new Measurement[0];
-    }
-}
diff --git a/moa/src/main/java/moa/learners/Classifier.java b/moa/src/main/java/moa/learners/Classifier.java
deleted file mode 100644
index b5cf2c826..000000000
--- a/moa/src/main/java/moa/learners/Classifier.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- *    Classifier.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.learners;
-
-import com.yahoo.labs.samoa.instances.Instance;
-
-/**
- * Classifier interface for incremental classification models.
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $
- */
-public interface Classifier extends InstanceLearner {
-
-    /**
-     * Gets the classifiers of this ensemble. Returns null if this learner is a
-     * single learner.
-     *
-     * @return an array of the learners of the ensemble
-     */
-    // public Classifier[] getSubClassifiers();
-
-    /**
-     * Predicts the class memberships for a given instance. If an instance is
-     * unclassified, the returned array elements must be all zero.
-     *
-     * @param inst the instance to be classified
-     * @return an array containing the estimated membership probabilities of the
-     * test instance in each class
-     */
-    //public Prediction getPredictionForInstance(Instance inst);
-    
-    public boolean correctlyClassifies(Instance inst);
-    
-    /**
-     * Sets the reference to the header of the data stream. The header of the
-     * data stream is extended from WEKA
-     * <code>Instances</code>. This header is needed to know the number of
-     * classes and attributes
-     *
-     * @param ih the reference to the data stream header
-     */
-    //public void setModelContext(InstancesHeader ih);
-    
-    public InstanceLearner copy();
-}
diff --git a/moa/src/main/java/moa/learners/MLTask.java b/moa/src/main/java/moa/learners/MLTask.java
index 64252f02e..e795ddb94 100644
--- a/moa/src/main/java/moa/learners/MLTask.java
+++ b/moa/src/main/java/moa/learners/MLTask.java
@@ -29,7 +29,7 @@
 import moa.options.OptionHandler;
 
 /**
- * Learner interface for incremental learning models. 
+ * Learner interface for incremental learning models.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
@@ -37,116 +37,111 @@
 @SuppressWarnings("rawtypes")
 public interface MLTask<E extends Example> extends MOAObject, OptionHandler, AWTRenderable {
 
-    /**
-     * Gets whether this learner needs a random seed.
-     * Examples of methods that needs a random seed are bagging and boosting.
-     *
-     * @return true if the learner needs a random seed.
-     */
-    public boolean isRandomizable();
-
-    /**
-     * Sets the seed for random number generation.
-     *
-     * @param s the seed
-     */
-    public void setRandomSeed(int s);
-
-    /**
-     * Gets the seed for random number generation.
-     */
-    public int getRandomSeed();
-
-    
-    /**
-     * Gets whether training has started.
-     *
-     * @return true if training has started
-     */
-    public boolean trainingHasStarted();
-
-    /**
-     * Gets the sum of the weights of the instances that have been used
-     * by this learner during the training in <code>trainOnInstance</code>
-     *
-     * @return the weight of the instances that have been used training
-     */
-    public double trainingWeightSeenByModel();
-
-    /**
-     * Resets this learner. It must be similar to
-     * starting a new learner from scratch.
-     *
-     */
-    public void resetLearning();
-
-    /**
-     * Trains this learner incrementally using the given example.
-     *
-     * @param inst the instance to be used for training
-     */
-    public void trainOnInstance(E example);
-
-    /**
-     * Predicts the class memberships for a given instance. If
-     * an instance is unclassified, the returned array elements
-     * must be all zero.
-     *
-     * @param inst the instance to be classified
-     * @return an array containing the estimated membership
-     * probabilities of the test instance in each class
-     */
-	public Prediction getPredictionForInstance(E testInst);
-
-    /**
-     * Gets the current measurements of this learner.
-     *
-     * @return an array of measurements to be used in evaluation tasks
-     */
-    public Measurement[] getModelMeasurements();
-
-    /**
-     * Gets the learners of this ensemble.
-     * Returns null if this learner is a single learner.
-     *
-     * @return an array of the learners of the ensemble
-     */
-    // public Learner[] getSublearners();
-
-     /**
-     * Gets the model if this learner.
-     *
-     * @return the copy of this learner
-     */
-    public MOAObject getModel();
-    
-     /**
-     * Sets the reference to the header of the data stream.
-     * The header of the data stream is extended from WEKA <code>Instances</code>.
-     * This header is needed to know the number of classes and attributes
-     *
-     * @param ih the reference to the data stream header
-     */
-    public void setModelContext(InstancesHeader ih);
-    
-    /**
-     * Gets the reference to the header of the data stream.
-     * The header of the data stream is extended from WEKA <code>Instances</code>.
-     * This header is needed to know the number of classes and attributes
-     *
-     * @return the reference to the data stream header
-     */
-    public InstancesHeader getModelContext();
-
-    /**
-     * Returns a string representation of the model.
-     *
-     * @param out	the stringbuilder to add the description
-     * @param indent	the number of characters to indent
-     */
-    public void getModelDescription(StringBuilder out, int indent);
-    
-}
-
-
+	/**
+	 * Gets whether this learner needs a random seed. Examples of methods that needs
+	 * a random seed are bagging and boosting.
+	 *
+	 * @return true if the learner needs a random seed.
+	 */
+	boolean isRandomizable();
+
+	/**
+	 * Sets the seed for random number generation.
+	 *
+	 * @param s the seed
+	 */
+	void setRandomSeed(int s);
+
+	/**
+	 * Gets the seed for random number generation.
+	 */
+	int getRandomSeed();
+
+	/**
+	 * Gets whether training has started.
+	 *
+	 * @return true if training has started
+	 */
+	boolean trainingHasStarted();
+
+	/**
+	 * Gets the sum of the weights of the instances that have been used by this
+	 * learner during the training in <code>trainOnInstance</code>
+	 *
+	 * @return the weight of the instances that have been used training
+	 */
+	double trainingWeightSeenByModel();
+
+	/**
+	 * Resets this learner. It must be similar to starting a new learner from
+	 * scratch.
+	 *
+	 */
+	void resetLearning();
+
+	/**
+	 * Trains this learner incrementally using the given example.
+	 *
+	 * @param inst the instance to be used for training
+	 */
+	void trainOnInstance(E example);
+
+	/**
+	 * Predicts the class memberships for a given instance. If an instance is
+	 * unclassified, the returned array elements must be all zero.
+	 *
+	 * @param inst the instance to be classified
+	 * @return an array containing the estimated membership probabilities of the
+	 *         test instance in each class
+	 */
+	Prediction getPredictionForInstance(E testInst);
+
+	/**
+	 * Gets the current measurements of this learner.
+	 *
+	 * @return an array of measurements to be used in evaluation tasks
+	 */
+	Measurement[] getModelMeasurements();
+
+	/**
+	 * Gets the learners of this ensemble. Returns null if this learner is a single
+	 * learner.
+	 *
+	 * @return an array of the learners of the ensemble
+	 */
+	// public Learner[] getSublearners();
+
+	/**
+	 * Gets the model if this learner.
+	 *
+	 * @return the copy of this learner
+	 */
+	MOAObject getModel();
+
+	/**
+	 * Sets the reference to the header of the data stream. The header of the data
+	 * stream is extended from WEKA <code>Instances</code>. This header is needed to
+	 * know the number of classes and attributes
+	 *
+	 * @param ih the reference to the data stream header
+	 */
+	void setModelContext(InstancesHeader ih);
+
+	/**
+	 * Gets the reference to the header of the data stream. The header of the data
+	 * stream is extended from WEKA <code>Instances</code>. This header is needed to
+	 * know the number of classes and attributes
+	 *
+	 * @return the reference to the data stream header
+	 */
+	InstancesHeader getModelContext();
+
+	/**
+	 * Returns a string representation of the model.
+	 *
+	 * @param out    the stringbuilder to add the description
+	 * @param indent the number of characters to indent
+	 */
+	void getModelDescription(StringBuilder out, int indent);
 
+}
diff --git a/moa/src/main/java/moa/learners/MultiLabelClassifier.java b/moa/src/main/java/moa/learners/MultiLabelClassifier.java
deleted file mode 100644
index 3508f100c..000000000
--- a/moa/src/main/java/moa/learners/MultiLabelClassifier.java
+++ /dev/null
@@ -1,51 +0,0 @@
-package moa.learners;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-public interface MultiLabelClassifier extends InstanceLearner {
-	
-    /**
-     * Gets whether this classifier correctly classifies an instance. Uses
-     * getPredictionForInstance to obtain the prediction and the instance to obtain
-     * its true class.
-     *
-     *
-     * @param inst the instance to be classified
-     * @return true if the instance is correctly classified
-     */
-    // TODO Add this to AbstractLearner
-    // public boolean correctlyClassifies(MultilabelInstance inst);
-
-    /**
-     * Trains this learner incrementally using the given example.
-     *
-     * @param inst the instance to be used for training
-     */
-    public void trainOnInstanceImpl(Instance inst);
-
-    /**
-     * Sets the reference to the header of the data stream. The header of the
-     * data stream is extended from WEKA
-     * <code>Instances</code>. This header is needed to know the number of
-     * classes and attributes
-     *
-     * @param ih the reference to the data stream header
-     */
-    //public void setModelContext(InstancesHeader ih);
-    
-    /**
-     * Gets the reference to the header of the data stream. The header of the
-     * data stream is extended from WEKA
-     * <code>Instances</code>. This header is needed to know the number of
-     * classes and attributes
-     *
-     * @return the reference to the data stream header
-     */
-    //public InstancesHeader getModelContext();
-    
-    public Prediction getPredictionForInstance(Instance inst);
-    
-    public InstanceLearner copy();
-
-}
diff --git a/moa/src/main/java/moa/learners/MultiTargetRegressor.java b/moa/src/main/java/moa/learners/MultiTargetRegressor.java
deleted file mode 100644
index 35dd11865..000000000
--- a/moa/src/main/java/moa/learners/MultiTargetRegressor.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- *    MultiTargetRegressor.java
- *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
- *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- *
- *    This program is free software; you can redistribute it and/or modify
- *    it under the terms of the GNU General Public License as published by
- *    the Free Software Foundation; either version 3 of the License, or
- *    (at your option) any later version.
- *
- *    This program is distributed in the hope that it will be useful,
- *    but WITHOUT ANY WARRANTY; without even the implied warranty of
- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *    GNU General Public License for more details.
- *
- *    You should have received a copy of the GNU General Public License
- *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- */
-package moa.learners;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-/**
- * MultiTargetRegressor interface for incremental MultiTarget regression models. It is used only in the GUI MultiTargetRegression Tab. 
- *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $
- */
-public interface MultiTargetRegressor extends InstanceLearner {
-
-    /**
-     * Gets whether this classifier correctly classifies an instance. Uses
-     * getPredictionForInstance to obtain the prediction and the instance to obtain
-     * its true class.
-     *
-     *
-     * @param inst the instance to be classified
-     * @return true if the instance is correctly classified
-     */
-    // TODO Add this to AbstractLearner
-    // public boolean correctlyClassifies(MultilabelInstance inst);
-
-    /**
-     * Trains this learner incrementally using the given example.
-     *
-     * @param inst the instance to be used for training
-     */
-    public void trainOnInstanceImpl(Instance inst);
-
-    /**
-     * Sets the reference to the header of the data stream. The header of the
-     * data stream is extended from WEKA
-     * <code>Instances</code>. This header is needed to know the number of
-     * classes and attributes
-     *
-     * @param ih the reference to the data stream header
-     */
-    //public void setModelContext(InstancesHeader ih);
-    
-    /**
-     * Gets the reference to the header of the data stream. The header of the
-     * data stream is extended from WEKA
-     * <code>Instances</code>. This header is needed to know the number of
-     * classes and attributes
-     *
-     * @return the reference to the data stream header
-     */
-    //public InstancesHeader getModelContext();
-    
-    public Prediction getPredictionForInstance(Instance inst);
-
-    public InstanceLearner copy();
-}
diff --git a/moa/src/main/java/moa/clusterers/AbstractClusterer.java b/moa/src/main/java/moa/learners/clusterers/AbstractClusterer.java
similarity index 79%
rename from moa/src/main/java/moa/clusterers/AbstractClusterer.java
rename to moa/src/main/java/moa/learners/clusterers/AbstractClusterer.java
index 6635790b8..b505e14be 100644
--- a/moa/src/main/java/moa/clusterers/AbstractClusterer.java
+++ b/moa/src/main/java/moa/learners/clusterers/AbstractClusterer.java
@@ -15,9 +15,9 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.clusterers;
+package moa.learners.clusterers;
 
 import java.util.LinkedList;
 import java.util.List;
@@ -36,9 +36,8 @@
 import moa.options.AbstractOptionHandler;
 import moa.tasks.TaskMonitor;
 
-public abstract class AbstractClusterer extends AbstractOptionHandler
-		implements Clusterer {
-	
+public abstract class AbstractClusterer extends AbstractOptionHandler implements Clusterer {
+
 	@Override
 	public String getPurposeString() {
 		return "MOA Clusterer: " + getClass().getCanonicalName();
@@ -52,55 +51,52 @@ public String getPurposeString() {
 
 	protected IntOption randomSeedOption;
 
-    public FlagOption evaluateMicroClusteringOption;
+	public FlagOption evaluateMicroClusteringOption;
+
+	protected Random clustererRandom;
 
-    protected Random clustererRandom;
+	protected Clustering clustering;
 
-    protected Clustering clustering;
-    
 	public AbstractClusterer() {
 		if (isRandomizable()) {
-			this.randomSeedOption = new IntOption("randomSeed", 'r',
-					"Seed for random behaviour of the Clusterer.", 1);
+			this.randomSeedOption = new IntOption("randomSeed", 'r', "Seed for random behaviour of the Clusterer.", 1);
 		}
 
-        if( implementsMicroClusterer()){
-            this.evaluateMicroClusteringOption =
-                    new FlagOption("evaluateMicroClustering", 'M',
-                    "Evaluate the underlying microclustering instead of the macro clustering");
-        }
+		if (implementsMicroClusterer()) {
+			this.evaluateMicroClusteringOption = new FlagOption("evaluateMicroClustering", 'M',
+					"Evaluate the underlying microclustering instead of the macro clustering");
+		}
 	}
 
 	@Override
-	public void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
+	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
 		if (this.randomSeedOption != null) {
 			this.randomSeed = this.randomSeedOption.getValue();
 		}
 		if (!trainingHasStarted()) {
 			resetLearning();
 		}
-                clustering = new Clustering();
+		clustering = new Clustering();
 	}
 
+	@Override
 	public void setModelContext(InstancesHeader ih) {
 		if ((ih != null) && (ih.classIndex() < 0)) {
-			throw new IllegalArgumentException(
-					"Context for a Clusterer must include a class to learn");
+			throw new IllegalArgumentException("Context for a Clusterer must include a class to learn");
 		}
-		if (trainingHasStarted()
-				&& (this.modelContext != null)
+		if (trainingHasStarted() && (this.modelContext != null)
 				&& ((ih == null) || !contextIsCompatible(this.modelContext, ih))) {
-			throw new IllegalArgumentException(
-					"New context is not compatible with existing model");
+			throw new IllegalArgumentException("New context is not compatible with existing model");
 		}
 		this.modelContext = ih;
 	}
 
+	@Override
 	public InstancesHeader getModelContext() {
 		return this.modelContext;
 	}
 
+	@Override
 	public void setRandomSeed(int s) {
 		this.randomSeed = s;
 		if (this.randomSeedOption != null) {
@@ -109,14 +105,17 @@ public void setRandomSeed(int s) {
 		}
 	}
 
+	@Override
 	public boolean trainingHasStarted() {
 		return this.trainingWeightSeenByModel > 0.0;
 	}
 
+	@Override
 	public double trainingWeightSeenByModel() {
 		return this.trainingWeightSeenByModel;
 	}
 
+	@Override
 	public void resetLearning() {
 		this.trainingWeightSeenByModel = 0.0;
 		if (isRandomizable()) {
@@ -125,6 +124,7 @@ public void resetLearning() {
 		resetLearningImpl();
 	}
 
+	@Override
 	public void trainOnInstance(Instance inst) {
 		if (inst.weight() > 0.0) {
 			this.trainingWeightSeenByModel += inst.weight();
@@ -132,12 +132,11 @@ public void trainOnInstance(Instance inst) {
 		}
 	}
 
+	@Override
 	public Measurement[] getModelMeasurements() {
-		List<Measurement> measurementList = new LinkedList<Measurement>();
-		measurementList.add(new Measurement("model training instances",
-				trainingWeightSeenByModel()));
-		measurementList.add(new Measurement("model serialized size (bytes)",
-				measureByteSize()));
+		List<Measurement> measurementList = new LinkedList<>();
+		measurementList.add(new Measurement("model training instances", trainingWeightSeenByModel()));
+		measurementList.add(new Measurement("model serialized size (bytes)", measureByteSize()));
 		Measurement[] modelMeasurements = getModelMeasurementsImpl();
 		if (modelMeasurements != null) {
 			for (Measurement measurement : modelMeasurements) {
@@ -147,15 +146,14 @@ public Measurement[] getModelMeasurements() {
 		// add average of sub-model measurements
 		Clusterer[] subModels = getSubClusterers();
 		if ((subModels != null) && (subModels.length > 0)) {
-			List<Measurement[]> subMeasurements = new LinkedList<Measurement[]>();
+			List<Measurement[]> subMeasurements = new LinkedList<>();
 			for (Clusterer subModel : subModels) {
 				if (subModel != null) {
 					subMeasurements.add(subModel.getModelMeasurements());
 				}
 			}
 			Measurement[] avgMeasurements = Measurement
-					.averageMeasurements(subMeasurements
-							.toArray(new Measurement[subMeasurements.size()][]));
+					.averageMeasurements(subMeasurements.toArray(new Measurement[subMeasurements.size()][]));
 			for (Measurement measurement : avgMeasurements) {
 				measurementList.add(measurement);
 			}
@@ -163,22 +161,22 @@ public Measurement[] getModelMeasurements() {
 		return measurementList.toArray(new Measurement[measurementList.size()]);
 	}
 
+	@Override
 	public void getDescription(StringBuilder out, int indent) {
 		StringUtils.appendIndented(out, indent, "Model type: ");
 		out.append(this.getClass().getName());
 		StringUtils.appendNewline(out);
-		Measurement.getMeasurementsDescription(getModelMeasurements(), out,
-				indent);
+		Measurement.getMeasurementsDescription(getModelMeasurements(), out, indent);
 		StringUtils.appendNewlineIndented(out, indent, "Model description:");
 		StringUtils.appendNewline(out);
 		if (trainingHasStarted()) {
 			getModelDescription(out, indent);
 		} else {
-			StringUtils.appendIndented(out, indent,
-					"Model has not been trained.");
+			StringUtils.appendIndented(out, indent, "Model has not been trained.");
 		}
 	}
 
+	@Override
 	public Clusterer[] getSubClusterers() {
 		return null;
 	}
@@ -198,24 +196,20 @@ public String getClassNameString() {
 	}
 
 	public String getClassLabelString(int classLabelIndex) {
-		return InstancesHeader.getClassLabelString(this.modelContext,
-				classLabelIndex);
+		return InstancesHeader.getClassLabelString(this.modelContext, classLabelIndex);
 	}
 
 	public String getAttributeNameString(int attIndex) {
-		return InstancesHeader.getAttributeNameString(this.modelContext,
-				attIndex);
+		return InstancesHeader.getAttributeNameString(this.modelContext, attIndex);
 	}
 
 	public String getNominalValueString(int attIndex, int valIndex) {
-		return InstancesHeader.getNominalValueString(this.modelContext,
-				attIndex, valIndex);
+		return InstancesHeader.getNominalValueString(this.modelContext, attIndex, valIndex);
 	}
 
 	// originalContext notnull
 	// newContext notnull
-	public static boolean contextIsCompatible(InstancesHeader originalContext,
-			InstancesHeader newContext) {
+	public static boolean contextIsCompatible(InstancesHeader originalContext, InstancesHeader newContext) {
 		// rule 1: num classes can increase but never decrease
 		// rule 2: num attributes can increase but never decrease
 		// rule 3: num nominal attribute values can increase but never decrease
@@ -246,8 +240,7 @@ public static boolean contextIsCompatible(InstancesHeader originalContext,
 				if (!newContext.attribute(nPos).isNominal()) {
 					return false; // rule 4
 				}
-				if (newContext.attribute(nPos).numValues() < originalContext
-						.attribute(oPos).numValues()) {
+				if (newContext.attribute(nPos).numValues() < originalContext.attribute(oPos).numValues()) {
 					return false; // rule 3
 				}
 			} else {
@@ -262,6 +255,7 @@ public static boolean contextIsCompatible(InstancesHeader originalContext,
 		return true; // all checks clear
 	}
 
+	@Override
 	public AWTRenderer getAWTRenderer() {
 		// TODO should return a default renderer here
 		// - or should null be interpreted as the default?
@@ -280,25 +274,26 @@ public AWTRenderer getAWTRenderer() {
 
 	public abstract void getModelDescription(StringBuilder out, int indent);
 
-	protected static int modelAttIndexToInstanceAttIndex(int index,
-			Instance inst) {
+	protected static int modelAttIndexToInstanceAttIndex(int index, Instance inst) {
 		return inst.classIndex() > index ? index : index + 1;
 	}
 
-	protected static int modelAttIndexToInstanceAttIndex(int index,
-			InstancesHeader insts) {
+	protected static int modelAttIndexToInstanceAttIndex(int index, InstancesHeader insts) {
 		return insts.classIndex() > index ? index : index + 1;
 	}
 
-        public boolean  implementsMicroClusterer(){
-            return false;
-        }
-
-        public boolean  keepClassLabel(){
-            return false;
-        }
-        
-        public Clustering getMicroClusteringResult(){
-            return null;
-        };
+	@Override
+	public boolean implementsMicroClusterer() {
+		return false;
+	}
+
+	@Override
+	public boolean keepClassLabel() {
+		return false;
+	}
+
+	@Override
+	public Clustering getMicroClusteringResult() {
+		return null;
+	}
 }
diff --git a/moa/src/main/java/moa/learners/clusterers/ClusterGenerator.java b/moa/src/main/java/moa/learners/clusterers/ClusterGenerator.java
new file mode 100644
index 000000000..7b6ba4424
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/ClusterGenerator.java
@@ -0,0 +1,355 @@
+/*
+ *    ClusterGenerator.java
+ *    Copyright (C) 2010 RWTH Aachen University, Germany
+ *    @author Jansen (moa@cs.rwth-aachen.de)
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Random;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.cluster.Clustering;
+import moa.cluster.SphereCluster;
+import moa.core.Measurement;
+import moa.gui.visualization.DataPoint;
+
+public class ClusterGenerator extends AbstractClusterer {
+
+	private static final long serialVersionUID = 1L;
+
+	public IntOption timeWindowOption = new IntOption("timeWindow", 't', "Rang of the window.", 1000);
+
+	public FloatOption radiusDecreaseOption = new FloatOption("radiusDecrease", 'r',
+			"The average radii of the centroids in the model.", 0, 0, 1);
+
+	public FloatOption radiusIncreaseOption = new FloatOption("radiusIncrease", 'R',
+			"The average radii of the centroids in the model.", 0, 0, 1);
+
+	public FloatOption positionOffsetOption = new FloatOption("positionOffset", 'p',
+			"The average radii of the centroids in the model.", 0, 0, 1);
+
+	public FloatOption clusterRemoveOption = new FloatOption("clusterRemove", 'D',
+			"Deletes complete clusters from the clustering.", 0, 0, 1);
+
+	public FloatOption joinClustersOption = new FloatOption("joinClusters", 'j',
+			"Join two clusters if their hull distance is less minRadius times this factor.", 0, 0, 1);
+
+	public FloatOption clusterAddOption = new FloatOption("clusterAdd", 'A', "Adds additional clusters.", 0, 0, 1);
+
+	private static double err_intervall_width = 0.0;
+	private ArrayList<DataPoint> points;
+	private int instanceCounter;
+	private int windowCounter;
+	private Random random;
+	private Clustering sourceClustering = null;
+
+	@Override
+	public void resetLearningImpl() {
+		points = new ArrayList<>();
+		instanceCounter = 0;
+		windowCounter = 0;
+		random = new Random(227);
+
+		// joinClustersOption.set();
+		// evaluateMicroClusteringOption.set();
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		if (windowCounter >= timeWindowOption.getValue()) {
+			points.clear();
+			windowCounter = 0;
+		}
+		windowCounter++;
+		instanceCounter++;
+		points.add(new DataPoint(inst, instanceCounter));
+	}
+
+	@Override
+	public boolean implementsMicroClusterer() {
+		return true;
+	}
+
+	public void setSourceClustering(Clustering source) {
+		sourceClustering = source;
+	}
+
+	@Override
+	public Clustering getMicroClusteringResult() {
+		// System.out.println("Numcluster:"+clustering.size()+" / "+num);
+		// Clustering source_clustering = new Clustering(points, overlapThreshold,
+		// microInitMinPoints);
+		if (sourceClustering == null) {
+
+			System.out.println("You need to set a source clustering for the ClusterGenerator to work");
+			return null;
+		}
+		return alterClustering(sourceClustering);
+	}
+
+	@Override
+	public Clustering getClusteringResult() {
+		sourceClustering = new Clustering(points);
+//        if(sourceClustering == null){
+//            System.out.println("You need to set a source clustering for the ClusterGenerator to work");
+//            return null;
+//        }
+		return alterClustering(sourceClustering);
+	}
+
+	private Clustering alterClustering(Clustering scclustering) {
+		// percentage of the radius that will be cut off
+		// 0: no changes to radius
+		// 1: radius of 0
+		double errLevelRadiusDecrease = radiusDecreaseOption.getValue();
+
+		// 0: no changes to radius
+		// 1: radius 100% bigger
+		double errLevelRadiusIncrease = radiusIncreaseOption.getValue();
+
+		// 0: no changes
+		// 1: distance between centers is 2 * original radius
+		double errLevelPosition = positionOffsetOption.getValue();
+
+		int numRemoveCluster = (int) (clusterRemoveOption.getValue() * scclustering.size());
+
+		int numAddCluster = (int) (clusterAddOption.getValue() * scclustering.size());
+
+		for (int c = 0; c < numRemoveCluster; c++) {
+			int delId = random.nextInt(scclustering.size());
+			scclustering.remove(delId);
+		}
+
+		int numCluster = scclustering.size();
+		double[] err_seeds = new double[numCluster];
+		double err_seed_sum = 0.0;
+		double tmp_seed;
+		for (int i = 0; i < numCluster; i++) {
+			tmp_seed = random.nextDouble();
+			err_seeds[i] = err_seed_sum + tmp_seed;
+			err_seed_sum += tmp_seed;
+		}
+
+		double sumWeight = 0;
+		for (int i = 0; i < numCluster; i++) {
+			sumWeight += scclustering.get(i).getWeight();
+		}
+
+		Clustering clustering = new Clustering();
+
+		for (int i = 0; i < numCluster; i++) {
+			if (!(scclustering.get(i) instanceof SphereCluster)) {
+				System.out.println("Not a Sphere Cluster");
+				continue;
+			}
+			SphereCluster sourceCluster = (SphereCluster) scclustering.get(i);
+			double[] center = Arrays.copyOf(sourceCluster.getCenter(), sourceCluster.getCenter().length);
+			double weight = sourceCluster.getWeight();
+			double radius = sourceCluster.getRadius();
+
+			// move cluster center
+			if (errLevelPosition > 0) {
+				double errOffset = random.nextDouble() * err_intervall_width / 2.0;
+				double errOffsetDirection = ((random.nextBoolean()) ? 1 : -1);
+				double level = errLevelPosition + errOffsetDirection * errOffset;
+				double[] vector = new double[center.length];
+				double vectorLength = 0;
+				for (int d = 0; d < center.length; d++) {
+					vector[d] = (random.nextBoolean() ? 1 : -1) * random.nextDouble();
+					vectorLength += Math.pow(vector[d], 2);
+				}
+				vectorLength = Math.sqrt(vectorLength);
+
+				// max is when clusters are next to each other
+				double length = 2 * radius * level;
+
+				for (int d = 0; d < center.length; d++) {
+					// normalize length and then strecht to reach error position
+					vector[d] = vector[d] / vectorLength * length;
+				}
+//                System.out.println("Center "+Arrays.toString(center));
+//                System.out.println("Vector "+Arrays.toString(vector));
+				// check if error position is within bounds
+				double[] newCenter = new double[center.length];
+				for (int d = 0; d < center.length; d++) {
+					// check bounds, otherwise flip vector
+					if (center[d] + vector[d] >= 0 && center[d] + vector[d] <= 1) {
+						newCenter[d] = center[d] + vector[d];
+					} else {
+						newCenter[d] = center[d] + (-1) * vector[d];
+					}
+				}
+				center = newCenter;
+				for (int d = 0; d < center.length; d++) {
+					if (newCenter[d] >= 0 && newCenter[d] <= 1) {
+					} else {
+						System.out.println("This shouldnt have happend, Cluster center out of bounds:"
+								+ Arrays.toString(newCenter));
+					}
+				}
+				// System.out.println("new Center "+Arrays.toString(newCenter));
+
+			}
+
+			// alter radius
+			if (errLevelRadiusDecrease > 0 || errLevelRadiusIncrease > 0) {
+				double errOffset = random.nextDouble() * err_intervall_width / 2.0;
+				int errOffsetDirection = ((random.nextBoolean()) ? 1 : -1);
+
+				if (errLevelRadiusDecrease > 0 && (errLevelRadiusIncrease == 0 || random.nextBoolean())) {
+					double level = (errLevelRadiusDecrease + errOffsetDirection * errOffset);// *sourceCluster.getWeight()/sumWeight;
+					level = (level < 0) ? 0 : level;
+					level = (level > 1) ? 1 : level;
+					radius *= (1 - level);
+				} else {
+					double level = errLevelRadiusIncrease + errOffsetDirection * errOffset;
+					level = (level < 0) ? 0 : level;
+					level = (level > 1) ? 1 : level;
+					radius += radius * level;
+				}
+			}
+
+			SphereCluster newCluster = new SphereCluster(center, radius, weight);
+			newCluster.setMeasureValue("Source Cluster", "C" + sourceCluster.getId());
+
+			clustering.add(newCluster);
+		}
+
+		if (joinClustersOption.getValue() > 0) {
+			clustering = joinClusters(clustering);
+		}
+
+		// add new clusters by copying clusters and set a random center
+		for (int c = 0; c < numAddCluster; c++) {
+			int copyId = random.nextInt(clustering.size());
+			SphereCluster scorg = (SphereCluster) clustering.get(copyId);
+			int dim = scorg.getCenter().length;
+			double[] center = new double[dim];
+			double radius = scorg.getRadius();
+
+			boolean outofbounds = true;
+			int tryCounter = 0;
+			while (outofbounds && tryCounter < 20) {
+				tryCounter++;
+				outofbounds = false;
+				for (int j = 0; j < center.length; j++) {
+					center[j] = random.nextDouble();
+					if (center[j] - radius < 0 || center[j] + radius > 1) {
+						outofbounds = true;
+						break;
+					}
+				}
+			}
+			if (outofbounds) {
+				System.out.println("Coludn't place additional cluster");
+			} else {
+				SphereCluster scnew = new SphereCluster(center, radius, scorg.getWeight() / 2);
+				scorg.setWeight(scorg.getWeight() - scnew.getWeight());
+				clustering.add(scnew);
+			}
+		}
+
+		return clustering;
+
+	}
+
+	private Clustering joinClusters(Clustering clustering) {
+
+		double radiusFactor = joinClustersOption.getValue();
+		boolean[] merged = new boolean[clustering.size()];
+
+		Clustering mclustering = new Clustering();
+
+		if (radiusFactor > 0) {
+			for (int c1 = 0; c1 < clustering.size(); c1++) {
+				SphereCluster sc1 = (SphereCluster) clustering.get(c1);
+				double minDist = Double.MAX_VALUE;
+				double minOver = 1;
+				int maxindexCon = -1;
+				int maxindexOver = -1;
+				for (int c2 = 0; c2 < clustering.size(); c2++) {
+					SphereCluster sc2 = (SphereCluster) clustering.get(c2);
+//                    double over = sc1.overlapRadiusDegree(sc2);
+//                    if(over > 0 && over < minOver){
+//                       minOver = over;
+//                       maxindexOver = c2;
+//                    }
+					double dist = sc1.getHullDistance(sc2);
+					double threshold = Math.min(sc1.getRadius(), sc2.getRadius()) * radiusFactor;
+					if (dist > 0 && dist < minDist && dist < threshold) {
+						minDist = dist;
+						maxindexCon = c2;
+					}
+				}
+				int maxindex = -1;
+				if (maxindexOver != -1)
+					maxindex = maxindexOver;
+				else
+					maxindex = maxindexCon;
+
+				if (maxindex != -1 && !merged[c1]) {
+					merged[c1] = true;
+					merged[maxindex] = true;
+					SphereCluster scnew = new SphereCluster(sc1.getCenter(), sc1.getRadius(), sc1.getWeight());
+					SphereCluster sc2 = (SphereCluster) clustering.get(maxindex);
+					scnew.merge(sc2);
+					mclustering.add(scnew);
+				}
+			}
+		}
+
+		for (int i = 0; i < merged.length; i++) {
+			if (!merged[i])
+				mclustering.add(clustering.get(i));
+		}
+
+		return mclustering;
+
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+
+	@Override
+	public boolean keepClassLabel() {
+		return true;
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		return null;
+	}
+}
diff --git a/moa/src/main/java/moa/clusterers/Clusterer.java b/moa/src/main/java/moa/learners/clusterers/Clusterer.java
similarity index 63%
rename from moa/src/main/java/moa/clusterers/Clusterer.java
rename to moa/src/main/java/moa/learners/clusterers/Clusterer.java
index 8316e8dae..60699188c 100644
--- a/moa/src/main/java/moa/clusterers/Clusterer.java
+++ b/moa/src/main/java/moa/learners/clusterers/Clusterer.java
@@ -15,9 +15,9 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.clusterers;
+package moa.learners.clusterers;
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
@@ -31,36 +31,37 @@
 
 public interface Clusterer extends MOAObject, OptionHandler, AWTRenderable {
 
-	public void setModelContext(InstancesHeader ih);
+	void setModelContext(InstancesHeader ih);
+
+	InstancesHeader getModelContext();
 
-	public InstancesHeader getModelContext();
+	boolean isRandomizable();
 
-	public boolean isRandomizable();
+	void setRandomSeed(int s);
 
-	public void setRandomSeed(int s);
+	boolean trainingHasStarted();
 
-	public boolean trainingHasStarted();
+	double trainingWeightSeenByModel();
 
-	public double trainingWeightSeenByModel();
+	void resetLearning();
 
-	public void resetLearning();
+	void trainOnInstance(Instance inst);
 
-	public void trainOnInstance(Instance inst);
+	Prediction getPredictionForInstance(Instance inst);
 
-	public Prediction getPredictionForInstance(Instance inst);
+	Measurement[] getModelMeasurements();
 
-	public Measurement[] getModelMeasurements();
+	Clusterer[] getSubClusterers();
 
-	public Clusterer[] getSubClusterers();
+	@Override
+	Clusterer copy();
 
-	public Clusterer copy();
+	Clustering getClusteringResult();
 
-    public Clustering getClusteringResult();
+	boolean implementsMicroClusterer();
 
-    public boolean implementsMicroClusterer();
+	Clustering getMicroClusteringResult();
 
-    public Clustering getMicroClusteringResult();
-    
-    public boolean keepClassLabel();
+	boolean keepClassLabel();
 
 }
diff --git a/moa/src/main/java/moa/learners/clusterers/CobWeb.java b/moa/src/main/java/moa/learners/clusterers/CobWeb.java
new file mode 100644
index 000000000..e23b249df
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/CobWeb.java
@@ -0,0 +1,964 @@
+/*
+ *    CobWeb.java
+ *    Copyright (C) 2009 University of Waikato, Hamilton, New Zealand
+ *    @author Mark Hall (mhall@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.clusterers;
+
+import java.io.Serializable;
+
+import com.github.javacliparser.FloatOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.cluster.Clustering;
+import moa.cluster.SphereCluster;
+import moa.core.FastVector;
+import moa.core.Measurement;
+import moa.core.StringUtils;
+import weka.core.AttributeStats;
+import weka.experiment.Stats;
+import weka.filters.unsupervised.attribute.Add;
+
+/**
+ * Class implementing the Cobweb and Classit clustering algorithms. See:
+ * http://en.wikipedia.org/wiki/Cobweb_%28clustering%29
+ *
+ * Citation: D. Fisher (1987). Knowledge acquisition via incremental conceptual
+ * clustering. Machine Learning. 2(2):139-172.
+ **/
+public class CobWeb extends AbstractClusterer {
+
+	private static final long serialVersionUID = 1L;
+	public FloatOption acuityOption = new FloatOption("acuity", 'a', "Acuity (minimum standard deviation)", 1.0, 0.0,
+			90.0);
+	public FloatOption cutoffOption = new FloatOption("cutoff", 'c', "Cutoff (minimum category utility)", 0.002, 0.0,
+			90.0); // 0.01 * Cobweb.m_normal
+//    public IntOption randomSeedOption = new IntOption("randomSeed", 'r',
+//            "Seed for random noise.", 1);	//42
+
+	/**
+	 * Inner class handling node operations for Cobweb.
+	 *
+	 * @see Serializable
+	 */
+	private class CNode implements Serializable {
+
+		/** for serialization */
+		static final long serialVersionUID = 3452097436933325631L;
+		/**
+		 * Within cluster attribute statistics
+		 */
+		private AttributeStats[] m_attStats;
+		/**
+		 * Number of attributes
+		 */
+		private int m_numAttributes;
+		/**
+		 * Instances at this node
+		 */
+		protected InstancesHeader m_clusterInstances = null;
+		/**
+		 * Children of this node
+		 */
+		private FastVector m_children = null;
+		/**
+		 * Total instances at this node
+		 */
+		private double m_totalInstances = 0.0;
+		/**
+		 * Cluster number of this node
+		 */
+		private int m_clusterNum = -1;
+
+		/**
+		 * Creates an empty <code>CNode</code> instance.
+		 *
+		 * @param numAttributes the number of attributes in the data
+		 */
+		public CNode(int numAttributes) {
+			m_numAttributes = numAttributes;
+		}
+
+		/**
+		 * Creates a new leaf <code>CNode</code> instance.
+		 *
+		 * @param numAttributes the number of attributes in the data
+		 * @param leafInstance  the instance to store at this leaf
+		 */
+		public CNode(int numAttributes, Instance leafInstance) {
+			this(numAttributes);
+			if (m_clusterInstances == null) {
+				// System.out.println(leafInstance.numAttributes()+"-"+leafInstance.value(0)+"-"+leafInstance.value(1)+"-"+leafInstance.value(2));
+				// System.out.println(leafInstance.numAttributes()+"-"+leafInstance.attribute(0).type()+"-"+leafInstance.attribute(1).type()+"-"+leafInstance.attribute(2).type());
+				m_clusterInstances = new InstancesHeader(leafInstance.dataset(), 1);
+			}
+			m_clusterInstances.add(leafInstance);
+			updateStats(leafInstance, false);
+		}
+
+		/**
+		 * Adds an instance to this cluster.
+		 *
+		 * @param newInstance the instance to add
+		 */
+		protected void addInstance(Instance newInstance) {
+			// Add the instance to this cluster
+
+			if (m_clusterInstances == null) {
+				m_clusterInstances = new InstancesHeader(newInstance.dataset(), 1);
+				m_clusterInstances.add(newInstance);
+				updateStats(newInstance, false);
+				return;
+			} else if (m_children == null) {
+				/*
+				 * we are a leaf, so make our existing instance(s) into a child and then add the
+				 * new instance as a child
+				 */
+				m_children = new FastVector();
+				CNode tempSubCluster = new CNode(m_numAttributes, m_clusterInstances.instance(0));
+
+				// System.out.println("Dumping "+m_clusterInstances.numInstances());
+				for (int i = 1; i < m_clusterInstances.numInstances(); i++) {
+					tempSubCluster.m_clusterInstances.add(m_clusterInstances.instance(i));
+					tempSubCluster.updateStats(m_clusterInstances.instance(i), false);
+				}
+				m_children = new FastVector();
+				m_children.addElement(tempSubCluster);
+				m_children.addElement(new CNode(m_numAttributes, newInstance));
+
+				m_clusterInstances.add(newInstance);
+				updateStats(newInstance, false);
+
+				// here is where we check against cutoff (also check cutoff
+				// in findHost)
+				if (categoryUtility() < m_cutoff) {
+					// System.out.println("Cutting (leaf add) ");
+					m_children = null;
+				}
+				return;
+			}
+
+			// otherwise, find the best host for this instance
+			CNode bestHost = findHost(newInstance, false);
+			if (bestHost != null) {
+				// now add to the best host
+				bestHost.addInstance(newInstance);
+			}
+		}
+
+		/**
+		 * Temporarily adds a new instance to each of this nodes children in turn and
+		 * computes the category utility.
+		 *
+		 * @param newInstance the new instance to evaluate
+		 * @return an array of category utility values---the result of considering each
+		 *         child in turn as a host for the new instance
+		 * @throws Exception if an error occurs
+		 */
+		private double[] cuScoresForChildren(Instance newInstance) {
+			// throws Exception {
+			// look for a host in existing children
+			double[] categoryUtils = new double[m_children.size()];
+
+			// look for a home for this instance in the existing children
+			for (int i = 0; i < m_children.size(); i++) {
+				CNode temp = (CNode) m_children.elementAt(i);
+				// tentitively add the new instance to this child
+				temp.updateStats(newInstance, false);
+				categoryUtils[i] = categoryUtility();
+
+				// remove the new instance from this child
+				temp.updateStats(newInstance, true);
+			}
+			return categoryUtils;
+		}
+
+		private double cuScoreForBestTwoMerged(CNode merged, CNode a, CNode b, Instance newInstance) {// throws
+																										// Exception {
+
+			double mergedCU = -Double.MAX_VALUE;
+			// consider merging the best and second
+			// best.
+			merged.m_clusterInstances = new InstancesHeader(m_clusterInstances, 1);
+
+			merged.addChildNode(a);
+			merged.addChildNode(b);
+			merged.updateStats(newInstance, false); // add new instance to stats
+			// remove the best and second best nodes
+			m_children.removeElementAt(m_children.indexOf(a));
+			m_children.removeElementAt(m_children.indexOf(b));
+			m_children.addElement(merged);
+			mergedCU = categoryUtility();
+			// restore the status quo
+			merged.updateStats(newInstance, true);
+			m_children.removeElementAt(m_children.indexOf(merged));
+			m_children.addElement(a);
+			m_children.addElement(b);
+			return mergedCU;
+		}
+
+		/**
+		 * Finds a host for the new instance in this nodes children. Also considers
+		 * merging the two best hosts and splitting the best host.
+		 *
+		 * @param newInstance     the instance to find a host for
+		 * @param structureFrozen true if the instance is not to be added to the tree
+		 *                        and instead the best potential host is to be returned
+		 * @return the best host
+		 * @throws Exception if an error occurs
+		 */
+		private CNode findHost(Instance newInstance, boolean structureFrozen) {// throws Exception {
+
+			if (!structureFrozen) {
+				updateStats(newInstance, false);
+			}
+
+			// look for a host in existing children and also consider as a new leaf
+			double[] categoryUtils = cuScoresForChildren(newInstance);
+
+			// make a temporary new leaf for this instance and get CU
+			CNode newLeaf = new CNode(m_numAttributes, newInstance);
+			m_children.addElement(newLeaf);
+			double bestHostCU = categoryUtility();
+			CNode finalBestHost = newLeaf;
+
+			// remove new leaf when seaching for best and second best nodes to
+			// consider for merging and splitting
+			m_children.removeElementAt(m_children.size() - 1);
+
+			// now determine the best host (and the second best)
+			int best = 0;
+			int secondBest = 0;
+			for (int i = 0; i < categoryUtils.length; i++) {
+				if (categoryUtils[i] > categoryUtils[secondBest]) {
+					if (categoryUtils[i] > categoryUtils[best]) {
+						secondBest = best;
+						best = i;
+					} else {
+						secondBest = i;
+					}
+				}
+			}
+
+			CNode a = (CNode) m_children.elementAt(best);
+			CNode b = (CNode) m_children.elementAt(secondBest);
+			if (categoryUtils[best] > bestHostCU) {
+				bestHostCU = categoryUtils[best];
+				finalBestHost = a;
+				// System.out.println("Node is best");
+			}
+
+			if (structureFrozen) {
+				if (finalBestHost == newLeaf) {
+					return null; // *this* node is the best host
+				} else {
+					return finalBestHost;
+				}
+			}
+
+			double mergedCU = -Double.MAX_VALUE;
+			CNode merged = new CNode(m_numAttributes);
+			if (a != b) {
+				mergedCU = cuScoreForBestTwoMerged(merged, a, b, newInstance);
+
+				if (mergedCU > bestHostCU) {
+					bestHostCU = mergedCU;
+					finalBestHost = merged;
+				}
+			}
+
+			// Consider splitting the best
+			double splitCU = -Double.MAX_VALUE;
+			double splitBestChildCU = -Double.MAX_VALUE;
+			double splitPlusNewLeafCU = -Double.MAX_VALUE;
+			double splitPlusMergeBestTwoCU = -Double.MAX_VALUE;
+			if (a.m_children != null) {
+				FastVector tempChildren = new FastVector();
+
+				for (int i = 0; i < m_children.size(); i++) {
+					CNode existingChild = (CNode) m_children.elementAt(i);
+					if (existingChild != a) {
+						tempChildren.addElement(existingChild);
+					}
+				}
+				for (int i = 0; i < a.m_children.size(); i++) {
+					CNode promotedChild = (CNode) a.m_children.elementAt(i);
+					tempChildren.addElement(promotedChild);
+				}
+				// also add the new leaf
+				tempChildren.addElement(newLeaf);
+
+				FastVector saveStatusQuo = m_children;
+				m_children = tempChildren;
+				splitPlusNewLeafCU = categoryUtility(); // split + new leaf
+				// remove the new leaf
+				tempChildren.removeElementAt(tempChildren.size() - 1);
+				// now look for best and second best
+				categoryUtils = cuScoresForChildren(newInstance);
+
+				// now determine the best host (and the second best)
+				best = 0;
+				secondBest = 0;
+				for (int i = 0; i < categoryUtils.length; i++) {
+					if (categoryUtils[i] > categoryUtils[secondBest]) {
+						if (categoryUtils[i] > categoryUtils[best]) {
+							secondBest = best;
+							best = i;
+						} else {
+							secondBest = i;
+						}
+					}
+				}
+				CNode sa = (CNode) m_children.elementAt(best);
+				CNode sb = (CNode) m_children.elementAt(secondBest);
+				splitBestChildCU = categoryUtils[best];
+
+				// now merge best and second best
+				CNode mergedSplitChildren = new CNode(m_numAttributes);
+				if (sa != sb) {
+					splitPlusMergeBestTwoCU = cuScoreForBestTwoMerged(mergedSplitChildren, sa, sb, newInstance);
+				}
+				splitCU = (splitBestChildCU > splitPlusNewLeafCU) ? splitBestChildCU : splitPlusNewLeafCU;
+				splitCU = (splitCU > splitPlusMergeBestTwoCU) ? splitCU : splitPlusMergeBestTwoCU;
+
+				if (splitCU > bestHostCU) {
+					bestHostCU = splitCU;
+					finalBestHost = this;
+					// tempChildren.removeElementAt(tempChildren.size()-1);
+				} else {
+					// restore the status quo
+					m_children = saveStatusQuo;
+				}
+			}
+
+			if (finalBestHost != this) {
+				// can commit the instance to the set of instances at this node
+				m_clusterInstances.add(newInstance);
+			} else {
+				m_numberSplits++;
+			}
+
+			if (finalBestHost == merged) {
+				m_numberMerges++;
+				m_children.removeElementAt(m_children.indexOf(a));
+				m_children.removeElementAt(m_children.indexOf(b));
+				m_children.addElement(merged);
+			}
+
+			if (finalBestHost == newLeaf) {
+				finalBestHost = new CNode(m_numAttributes);
+				m_children.addElement(finalBestHost);
+			}
+
+			if (bestHostCU < m_cutoff) {
+				if (finalBestHost == this) {
+					// splitting was the best, but since we are cutting all children
+					// recursion is aborted and we still need to add the instance
+					// to the set of instances at this node
+					m_clusterInstances.add(newInstance);
+				}
+				m_children = null;
+				finalBestHost = null;
+			}
+
+			if (finalBestHost == this) {
+				// splitting is still the best, so downdate the stats as
+				// we'll be recursively calling on this node
+				updateStats(newInstance, true);
+			}
+
+			return finalBestHost;
+		}
+
+		/**
+		 * Adds the supplied node as a child of this node. All of the child's instances
+		 * are added to this nodes instances
+		 *
+		 * @param child the child to add
+		 */
+		protected void addChildNode(CNode child) {
+			for (int i = 0; i < child.m_clusterInstances.numInstances(); i++) {
+				Instance temp = child.m_clusterInstances.instance(i);
+				m_clusterInstances.add(temp);
+				updateStats(temp, false);
+			}
+
+			if (m_children == null) {
+				m_children = new FastVector();
+			}
+			m_children.addElement(child);
+		}
+
+		/**
+		 * Computes the utility of all children with respect to this node
+		 *
+		 * @return the category utility of the children with respect to this node.
+		 * @throws Exception if there are no children
+		 */
+		protected double categoryUtility() {// {throws Exception {
+
+			// if (m_children == null) {
+			// throw new Exception("categoryUtility: No children!");
+			// }
+
+			double totalCU = 0;
+
+			for (int i = 0; i < m_children.size(); i++) {
+				CNode child = (CNode) m_children.elementAt(i);
+				totalCU += categoryUtilityChild(child);
+			}
+
+			totalCU /= m_children.size();
+			return totalCU;
+		}
+
+		/**
+		 * Computes the utility of a single child with respect to this node
+		 *
+		 * @param child the child for which to compute the utility
+		 * @return the utility of the child with respect to this node
+		 * @throws Exception if something goes wrong
+		 */
+		protected double categoryUtilityChild(CNode child) {// throws Exception {
+
+			double sum = 0;
+			for (int i = 0; i < m_numAttributes; i++) {
+				if (m_clusterInstances.attribute(i).isNominal()) {
+					for (int j = 0; j < m_clusterInstances.attribute(i).numValues(); j++) {
+						double x = child.getProbability(i, j);
+						double y = getProbability(i, j);
+						sum += (x * x) - (y * y);
+					}
+				} else {
+					// numeric attribute
+					sum += ((m_normal / child.getStandardDev(i)) - (m_normal / getStandardDev(i)));
+
+				}
+			}
+			return (child.m_totalInstances / m_totalInstances) * sum;
+		}
+
+		/**
+		 * Returns the probability of a value of a nominal attribute in this node
+		 *
+		 * @param attIndex   the index of the attribute
+		 * @param valueIndex the index of the value of the attribute
+		 * @return the probability
+		 * @throws Exception if the requested attribute is not nominal
+		 */
+		protected double getProbability(int attIndex, int valueIndex) {
+			// throws Exception {
+
+			// if (!m_clusterInstances.attribute(attIndex).isNominal()) {
+			// throw new Exception("getProbability: attribute is not nominal");
+			// }
+
+			if (m_attStats[attIndex].totalCount <= 0) {
+				return 0;
+			}
+
+			return (double) m_attStats[attIndex].nominalCounts[valueIndex] / (double) m_attStats[attIndex].totalCount;
+		}
+
+		/**
+		 * Returns the standard deviation of a numeric attribute
+		 *
+		 * @param attIndex the index of the attribute
+		 * @return the standard deviation
+		 * @throws Exception if an error occurs
+		 */
+		protected double getStandardDev(int attIndex) { // throws Exception {
+			// if (!m_clusterInstances.attribute(attIndex).isNumeric()) {
+			// throw new Exception("getStandardDev: attribute is not numeric");
+			// }
+
+			m_attStats[attIndex].numericStats.calculateDerived();
+			double stdDev = m_attStats[attIndex].numericStats.stdDev;
+			if (Double.isNaN(stdDev) || Double.isInfinite(stdDev)) {
+				return m_acuity;
+			}
+
+			return Math.max(m_acuity, stdDev);
+		}
+
+		/**
+		 * Update attribute stats using the supplied instance.
+		 *
+		 * @param updateInstance the instance for updating
+		 * @param delete         true if the values of the supplied instance are to be
+		 *                       removed from the statistics
+		 */
+		protected void updateStats(Instance updateInstance, boolean delete) {
+
+			if (m_attStats == null) {
+				m_attStats = new AttributeStats[m_numAttributes];
+				for (int i = 0; i < m_numAttributes; i++) {
+					m_attStats[i] = new AttributeStats();
+					if (m_clusterInstances.attribute(i).isNominal()) {
+						m_attStats[i].nominalCounts = new int[m_clusterInstances.attribute(i).numValues()];
+					} else {
+						m_attStats[i].numericStats = new Stats();
+					}
+				}
+			}
+			for (int i = 0; i < m_numAttributes; i++) {
+				if (!updateInstance.isMissing(i)) {
+					double value = updateInstance.value(i);
+					if (m_clusterInstances.attribute(i).isNominal()) {
+						m_attStats[i].nominalCounts[(int) value] += (delete) ? (-1.0 * updateInstance.weight())
+								: updateInstance.weight();
+						m_attStats[i].totalCount += (delete) ? (-1.0 * updateInstance.weight())
+								: updateInstance.weight();
+					} else {
+						if (delete) {
+							m_attStats[i].numericStats.subtract(value, updateInstance.weight());
+						} else {
+							m_attStats[i].numericStats.add(value, updateInstance.weight());
+						}
+					}
+				}
+			}
+			m_totalInstances += (delete) ? (-1.0 * updateInstance.weight()) : (updateInstance.weight());
+		}
+
+		/**
+		 * Recursively assigns numbers to the nodes in the tree.
+		 *
+		 * @param cl_num an <code>int[]</code> value
+		 * @throws Exception if an error occurs
+		 */
+		private void assignClusterNums(int[] cl_num) { // throws Exception {
+			// if (m_children != null && m_children.size() < 2) {
+			// throw new Exception("assignClusterNums: tree not built correctly!");
+			// }
+
+			m_clusterNum = cl_num[0];
+			cl_num[0]++;
+			if (m_children != null) {
+				for (int i = 0; i < m_children.size(); i++) {
+					CNode child = (CNode) m_children.elementAt(i);
+					child.assignClusterNums(cl_num);
+				}
+			}
+		}
+
+		/**
+		 * Recursively build a string representation of the Cobweb tree
+		 *
+		 * @param depth depth of this node in the tree
+		 * @param text  holds the string representation
+		 */
+		protected void dumpTree(int depth, StringBuffer text) {
+
+			if (depth == 0) {
+				determineNumberOfClusters();
+			}
+
+			if (m_children == null) {
+				text.append("\n");
+				for (int j = 0; j < depth; j++) {
+					text.append("|   ");
+				}
+				text.append("leaf " + m_clusterNum + " [" + m_clusterInstances.numInstances() + "]");
+			} else {
+				for (int i = 0; i < m_children.size(); i++) {
+					text.append("\n");
+					for (int j = 0; j < depth; j++) {
+						text.append("|   ");
+					}
+					text.append("node " + m_clusterNum + " [" + m_clusterInstances.numInstances() + "]");
+					((CNode) m_children.elementAt(i)).dumpTree(depth + 1, text);
+				}
+			}
+		}
+
+		/**
+		 * Returns the instances at this node as a string. Appends the cluster number of
+		 * the child that each instance belongs to.
+		 *
+		 * @return a <code>String</code> value
+		 * @throws Exception if an error occurs
+		 */
+		protected String dumpData() { // throws Exception {
+			if (m_children == null) {
+				return m_clusterInstances.toString();
+			}
+
+			// construct instances string with cluster numbers attached
+			CNode tempNode = new CNode(m_numAttributes);
+			tempNode.m_clusterInstances = new InstancesHeader(m_clusterInstances, 1);
+			for (int i = 0; i < m_children.size(); i++) {
+				tempNode.addChildNode((CNode) m_children.elementAt(i));
+			}
+			InstancesHeader tempInst = tempNode.m_clusterInstances;
+			tempNode = null;
+
+			Add af = new Add();
+			af.setAttributeName("Cluster");
+			String labels = "";
+			for (int i = 0; i < m_children.size(); i++) {
+				CNode temp = (CNode) m_children.elementAt(i);
+				labels += ("C" + temp.m_clusterNum);
+				if (i < m_children.size() - 1) {
+					labels += ",";
+				}
+			}
+			af.setNominalLabels(labels);
+			// af.setInputFormat(tempInst);
+			// tempInst = Filter.useFilter(tempInst, af);
+			tempInst.setRelationName("Cluster " + m_clusterNum);
+
+			int z = 0;
+			for (int i = 0; i < m_children.size(); i++) {
+				CNode temp = (CNode) m_children.elementAt(i);
+				for (int j = 0; j < temp.m_clusterInstances.numInstances(); j++) {
+					tempInst.instance(z).setValue(m_numAttributes, i);
+					z++;
+				}
+			}
+			return tempInst.toString();
+		}
+
+		/**
+		 * Recursively generate the graph string for the Cobweb tree.
+		 *
+		 * @param text holds the graph string
+		 * @throws Exception if generation fails
+		 */
+		protected void graphTree(StringBuffer text) { // throws Exception {
+
+			text.append("N" + m_clusterNum + " [label=\"" + ((m_children == null) ? "leaf " : "node ") + m_clusterNum
+					+ " " + " (" + m_clusterInstances.numInstances() + ")\" "
+					+ ((m_children == null) ? "shape=box style=filled " : "")
+					+ (m_saveInstances ? "data =\n" + dumpData() + "\n,\n" : "") + "]\n");
+			if (m_children != null) {
+				for (int i = 0; i < m_children.size(); i++) {
+					CNode temp = (CNode) m_children.elementAt(i);
+					text.append("N" + m_clusterNum + "->" + "N" + temp.m_clusterNum + "\n");
+				}
+
+				for (int i = 0; i < m_children.size(); i++) {
+					CNode temp = (CNode) m_children.elementAt(i);
+					temp.graphTree(text);
+				}
+			}
+		}
+
+		/**
+		 * Recursively build a clustering representation of the Cobweb tree
+		 *
+		 * @param depth      depth of this node in the tree
+		 * @param clustering holds the Clustering representation
+		 */
+		protected void computeTreeClustering(int depth, Clustering clustering) {
+
+			if (depth == 0) {
+				determineNumberOfClusters();
+			}
+
+			if (m_children == null) {
+				// Append Cluster
+				/*
+				 * text.append("\n"); for (int j = 0; j < depth; j++) { text.append("|   "); }
+				 * text.append("leaf " + m_clusterNum + " [" + m_clusterInstances.numInstances()
+				 * + "]"); clustering.add(SphereCluster(this.coordinates, .05,
+				 * m_clusterInstances.numInstances()));
+				 */
+				if (depth == 0) {
+					double[] centroidCoordinates = new double[m_clusterInstances.numAttributes()];
+					for (int j = 0; j < m_clusterInstances.numAttributes() - 1; j++) {
+						centroidCoordinates[j] = m_clusterInstances.meanOrMode(j);
+					}
+					clustering.add(new SphereCluster(centroidCoordinates, .05, m_clusterInstances.numInstances()));
+				}
+			} else {
+				for (int i = 0; i < m_children.size(); i++) {
+					/*
+					 * text.append("\n"); for (int j = 0; j < depth; j++) { text.append("|   "); }
+					 * text.append("node " + m_clusterNum + " [" + m_clusterInstances.numInstances()
+					 * + "]");
+					 */
+					double[] centroidCoordinates = new double[m_clusterInstances.numAttributes()];
+					for (int j = 0; j < m_clusterInstances.numAttributes() - 1; j++) {
+						centroidCoordinates[j] = m_clusterInstances.meanOrMode(j);
+					}
+					clustering.add(new SphereCluster(centroidCoordinates, .05, m_clusterInstances.numInstances()));
+					((CNode) m_children.elementAt(i)).computeTreeClustering(depth + 1, clustering);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Normal constant.
+	 */
+	protected static final double m_normal = 1.0 / (2 * Math.sqrt(Math.PI));
+	/**
+	 * Acuity (minimum standard deviation).
+	 */
+	protected double m_acuity = 1.0;
+	/**
+	 * Cutoff (minimum category utility).
+	 */
+	protected double m_cutoff = 0.002;// 0.01 * Cobweb.m_normal;
+	/**
+	 * Holds the root of the Cobweb tree.
+	 */
+	protected CNode m_cobwebTree = null;
+	/**
+	 * Number of clusters (nodes in the tree). Must never be queried directly, only
+	 * via the method numberOfClusters(). Otherwise it's not guaranteed that it
+	 * contains the correct value.
+	 *
+	 * @see #numberOfClusters()
+	 * @see #m_numberOfClustersDetermined
+	 */
+	protected int m_numberOfClusters = -1;
+	/** whether the number of clusters was already determined */
+	protected boolean m_numberOfClustersDetermined = false;
+	/** the number of splits that happened */
+	protected int m_numberSplits;
+	/** the number of merges that happened */
+	protected int m_numberMerges;
+	/**
+	 * Output instances in graph representation of Cobweb tree (Allows instances at
+	 * nodes in the tree to be visualized in the Explorer).
+	 */
+	protected boolean m_saveInstances = false;
+	@SuppressWarnings("hiding")
+	public static final String classifierPurposeString = "Cobweb and Classit clustering algorithms: it always compares the best host, adding a new leaf, merging the two best hosts, and splitting the best host when considering where to place a new instance..";
+
+	@Override
+	public void resetLearningImpl() {
+		setAcuity(this.acuityOption.getValue());
+		setCutoff(this.cutoffOption.getValue());
+		m_numberOfClusters = -1;
+		m_cobwebTree = null;
+		m_numberSplits = 0;
+		m_numberMerges = 0;
+	}
+
+	/**
+	 * Adds an instance to the clusterer.
+	 *
+	 * @param newInstance the instance to be added
+	 * @throws Exception if something goes wrong
+	 */
+	// public void updateClusterer(Instance newInstance) throws Exception {
+	@Override
+	public void trainOnInstanceImpl(Instance newInstance) { // throws Exception {
+		m_numberOfClustersDetermined = false;
+
+		if (m_cobwebTree == null) {
+			m_cobwebTree = new CNode(newInstance.numAttributes(), newInstance);
+		} else {
+			m_cobwebTree.addInstance(newInstance);
+		}
+	}
+
+	/**
+	 * Classifies a given instance.
+	 *
+	 * @param instance the instance to be assigned to a cluster
+	 * @return the number of the assigned cluster as an interger if the class is
+	 *         enumerated, otherwise the predicted value
+	 * @throws Exception if instance could not be classified successfully
+	 */
+	@Override
+	public Prediction getPredictionForInstance(Instance instance) {
+		// public int clusterInstance(Instance instance) {//throws Exception {
+		CNode host = m_cobwebTree;
+		CNode temp = null;
+
+		determineNumberOfClusters();
+
+		if (this.m_numberOfClusters < 1) {
+			return new ClassificationPrediction();
+		}
+		double[] ret = new double[this.m_numberOfClusters];
+
+		do {
+			if (host.m_children == null) {
+				temp = null;
+				break;
+			}
+
+			host.updateStats(instance, false);
+			temp = host.findHost(instance, true);
+			host.updateStats(instance, true);
+
+			if (temp != null) {
+				host = temp;
+			}
+		} while (temp != null);
+
+		ret[host.m_clusterNum] = 1.0;
+		return new ClassificationPrediction(ret);
+	}
+
+	/**
+	 * determines the number of clusters if necessary
+	 *
+	 * @see #m_numberOfClusters
+	 * @see #m_numberOfClustersDetermined
+	 */
+	protected void determineNumberOfClusters() {
+		if (!m_numberOfClustersDetermined && (m_cobwebTree != null)) {
+			int[] numClusts = new int[1];
+			numClusts[0] = 0;
+			// try {
+			m_cobwebTree.assignClusterNums(numClusts);
+			// }
+			// catch (Exception e) {
+//	e.printStackTrace();
+//	numClusts[0] = 0;
+			// }
+			m_numberOfClusters = numClusts[0];
+
+			m_numberOfClustersDetermined = true;
+		}
+	}
+
+	/**
+	 * Returns the number of clusters.
+	 *
+	 * @return the number of clusters
+	 */
+	public int numberOfClusters() {
+		determineNumberOfClusters();
+		return m_numberOfClusters;
+	}
+
+	{
+//		return this.observedClassDistribution.getArrayCopy();
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return null;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		StringBuffer text = new StringBuffer();
+		if (m_cobwebTree == null) {
+			StringUtils.appendIndented(out, indent, "Cobweb hasn't been built yet!");
+			StringUtils.appendNewline(out);
+		} else {
+			m_cobwebTree.dumpTree(0, text);
+			StringUtils.appendIndented(out, indent, "CobWeb - ");
+			out.append("Number of merges: " + m_numberMerges + "\nNumber of splits: " + m_numberSplits
+					+ "\nNumber of clusters: " + numberOfClusters() + "\n" + text.toString());
+			StringUtils.appendNewline(out);
+		}
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+
+	/**
+	 * Generates the graph string of the Cobweb tree
+	 *
+	 * @return a <code>String</code> value
+	 * @throws Exception if an error occurs
+	 */
+	public String graph() {// throws Exception {
+		StringBuffer text = new StringBuffer();
+
+		text.append("digraph CobwebTree {\n");
+		m_cobwebTree.graphTree(text);
+		text.append("}\n");
+		return text.toString();
+	}
+
+	/**
+	 * set the acuity.
+	 * 
+	 * @param a the acuity value
+	 */
+	public void setAcuity(double a) {
+		m_acuity = a;
+	}
+
+	/**
+	 * get the acuity value
+	 * 
+	 * @return the acuity
+	 */
+	public double getAcuity() {
+		return m_acuity;
+	}
+
+	/**
+	 * set the cutoff
+	 * 
+	 * @param c the cutof
+	 */
+	public void setCutoff(double c) {
+		m_cutoff = c;
+	}
+
+	/**
+	 * get the cutoff
+	 * 
+	 * @return the cutoff
+	 */
+	public double getCutoff() {
+		return m_cutoff;
+	}
+
+	/**
+	 * Get the value of saveInstances.
+	 *
+	 * @return Value of saveInstances.
+	 */
+	public boolean getSaveInstanceData() {
+
+		return m_saveInstances;
+	}
+
+	/**
+	 * Set the value of saveInstances.
+	 *
+	 * @param newsaveInstances Value to assign to saveInstances.
+	 */
+	public void setSaveInstanceData(boolean newsaveInstances) {
+
+		m_saveInstances = newsaveInstances;
+	}
+
+	@Override
+	public Clustering getClusteringResult() {
+		// throw new UnsupportedOperationException("Not supported yet.");
+		Clustering result = new Clustering();
+		if (m_cobwebTree == null) {
+			// StringUtils.appendIndented(out, indent, "Cobweb hasn't been built yet!");
+			// StringUtils.appendNewline(out);
+		} else {
+			m_cobwebTree.computeTreeClustering(0, result);
+			System.out.println("After Number of clusters: " + numberOfClusters());
+		}
+		System.out.println("Number of clusters: " + result.size());
+		return result;
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/KMeans.java b/moa/src/main/java/moa/learners/clusterers/KMeans.java
new file mode 100644
index 000000000..854a86b53
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/KMeans.java
@@ -0,0 +1,197 @@
+/*
+ *    KMeans.java
+ *    Copyright (C) 2010 RWTH Aachen University, Germany
+ *    @author Jansen (moa@cs.rwth-aachen.de)
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import moa.cluster.CFCluster;
+import moa.cluster.Cluster;
+import moa.cluster.Clustering;
+import moa.cluster.SphereCluster;
+
+/**
+ * A kMeans implementation for microclusterings. For now it only uses the real
+ * centers of the groundtruthclustering for implementation. There should also be
+ * an option to use random centers. TODO: random centers TODO: Create a macro
+ * clustering interface to make different macro clustering algorithms available
+ * to micro clustering algorithms like clustream, denstream and clustree
+ *
+ */
+public class KMeans {
+
+	/**
+	 * This kMeans implementation clusters a big number of microclusters into a
+	 * smaller amount of macro clusters. To make it comparable to other algorithms
+	 * it uses the real centers of the ground truth macro clustering to have the
+	 * best possible initialization. The quality of resulting macro clustering
+	 * yields an upper bound for kMeans on the underlying microclustering.
+	 * 
+	 * @param centers of the ground truth clustering
+	 * @param data    list of microclusters
+	 * @return
+	 */
+	public static Clustering kMeans(Cluster[] centers, List<? extends Cluster> data) {
+		int k = centers.length;
+
+		int dimensions = centers[0].getCenter().length;
+
+		ArrayList<ArrayList<Cluster>> clustering = new ArrayList<>();
+		for (int i = 0; i < k; i++) {
+			clustering.add(new ArrayList<Cluster>());
+		}
+
+		int repetitions = 100;
+		while (repetitions-- >= 0) {
+			// Assign points to clusters
+			for (Cluster point : data) {
+				double minDistance = distance(point.getCenter(), centers[0].getCenter());
+				int closestCluster = 0;
+				for (int i = 1; i < k; i++) {
+					double distance = distance(point.getCenter(), centers[i].getCenter());
+					if (distance < minDistance) {
+						closestCluster = i;
+						minDistance = distance;
+					}
+				}
+
+				clustering.get(closestCluster).add(point);
+			}
+
+			// Calculate new centers and clear clustering lists
+			SphereCluster[] newCenters = new SphereCluster[centers.length];
+			for (int i = 0; i < k; i++) {
+				newCenters[i] = calculateCenter(clustering.get(i), dimensions);
+				clustering.get(i).clear();
+			}
+			centers = newCenters;
+		}
+
+		return new Clustering(centers);
+	}
+
+	private static double distance(double[] pointA, double[] pointB) {
+		double distance = 0.0;
+		for (int i = 0; i < pointA.length; i++) {
+			double d = pointA[i] - pointB[i];
+			distance += d * d;
+		}
+		return Math.sqrt(distance);
+	}
+
+	private static SphereCluster calculateCenter(ArrayList<Cluster> cluster, int dimensions) {
+		double[] res = new double[dimensions];
+		for (int i = 0; i < res.length; i++) {
+			res[i] = 0.0;
+		}
+
+		if (cluster.size() == 0) {
+			return new SphereCluster(res, 0.0);
+		}
+
+		for (Cluster point : cluster) {
+			double[] center = point.getCenter();
+			for (int i = 0; i < res.length; i++) {
+				res[i] += center[i];
+			}
+		}
+
+		// Normalize
+		for (int i = 0; i < res.length; i++) {
+			res[i] /= cluster.size();
+		}
+
+		// Calculate radius
+		double radius = 0.0;
+		for (Cluster point : cluster) {
+			double dist = distance(res, point.getCenter());
+			if (dist > radius) {
+				radius = dist;
+			}
+		}
+
+		return new SphereCluster(res, radius);
+	}
+
+	public static Clustering gaussianMeans(Clustering gtClustering, Clustering clustering) {
+		ArrayList<CFCluster> microclusters = new ArrayList<>();
+		for (int i = 0; i < clustering.size(); i++) {
+			if (clustering.get(i) instanceof CFCluster) {
+				microclusters.add((CFCluster) clustering.get(i));
+			} else {
+				System.out.println("Unsupported Cluster Type:" + clustering.get(i).getClass()
+						+ ". Cluster needs to extend moa.cluster.CFCluster");
+			}
+		}
+		Cluster[] centers = new Cluster[gtClustering.size()];
+		for (int i = 0; i < centers.length; i++) {
+			centers[i] = gtClustering.get(i);
+
+		}
+
+		int k = centers.length;
+		if (microclusters.size() < k) {
+			return new Clustering(new Cluster[0]);
+		}
+
+		Clustering kMeansResult = kMeans(centers, microclusters);
+
+		k = kMeansResult.size();
+		CFCluster[] res = new CFCluster[k];
+
+		for (CFCluster microcluster : microclusters) {
+			// Find closest kMeans cluster
+			double minDistance = Double.MAX_VALUE;
+			int closestCluster = 0;
+			for (int i = 0; i < k; i++) {
+				double distance = distance(kMeansResult.get(i).getCenter(), microcluster.getCenter());
+				if (distance < minDistance) {
+					closestCluster = i;
+					minDistance = distance;
+				}
+			}
+
+			// Add to cluster
+			if (res[closestCluster] == null) {
+				res[closestCluster] = (CFCluster) microcluster.copy();
+			} else {
+				res[closestCluster].add(microcluster);
+			}
+		}
+
+		// Clean up res
+		int count = 0;
+		for (int i = 0; i < res.length; i++) {
+			if (res[i] != null)
+				++count;
+		}
+
+		CFCluster[] cleaned = new CFCluster[count];
+		count = 0;
+		for (int i = 0; i < res.length; i++) {
+			if (res[i] != null)
+				cleaned[count++] = res[i];
+		}
+
+		return new Clustering(cleaned);
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/WekaClusteringAlgorithm.java b/moa/src/main/java/moa/learners/clusterers/WekaClusteringAlgorithm.java
new file mode 100644
index 000000000..ec320a695
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/WekaClusteringAlgorithm.java
@@ -0,0 +1,223 @@
+/*
+ *    WekaClusteringAlgorithm.java
+ *    Copyright (C) 2010 RWTH Aachen University, Germany
+ *    @author Jansen (moa@cs.rwth-aachen.de)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.clusterers;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.github.javacliparser.StringOption;
+import com.yahoo.labs.samoa.instances.Attribute;
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.cluster.Clustering;
+import moa.core.AutoClassDiscovery;
+import moa.core.AutoExpandVector;
+import moa.core.FastVector;
+import moa.core.Measurement;
+import moa.options.ClassOption;
+import weka.core.Utils;
+
+public class WekaClusteringAlgorithm extends AbstractClusterer {
+
+	private static final long serialVersionUID = 1L;
+
+	public IntOption horizonOption = new IntOption("horizon", 'h', "Range of the window.", 1000);
+
+	public MultiChoiceOption wekaAlgorithmOption;
+
+	public StringOption parameterOption = new StringOption("parameter", 'p',
+			"Parameters that will be passed to the weka algorithm. (e.g. '-N 5' for using SimpleKmeans with 5 clusters)",
+			"-N 5 -S 8");
+
+	private Class<?>[] clustererClasses;
+
+	private InstancesHeader instances;
+
+	private weka.clusterers.AbstractClusterer clusterer;
+
+	protected SamoaToWekaInstanceConverter instanceConverter;
+
+	public WekaClusteringAlgorithm() {
+		clustererClasses = findWekaClustererClasses();
+		String[] optionLabels = new String[clustererClasses.length];
+		String[] optionDescriptions = new String[clustererClasses.length];
+
+		for (int i = 0; i < clustererClasses.length; i++) {
+			optionLabels[i] = clustererClasses[i].getSimpleName();
+			optionDescriptions[i] = clustererClasses[i].getName();
+//			We do have the parameter option info, but not really a place to show it somewhere
+			/*
+			 * //System.out.println(clustererClasses[i].getSimpleName()); for (Class c :
+			 * clustererClasses[i].getInterfaces()) { if
+			 * (c.equals(weka.core.OptionHandler.class)) { try { Enumeration options =
+			 * ((weka.core.OptionHandler)clustererClasses[i].newInstance()).listOptions();
+			 * while(options.hasMoreElements()){ weka.core.Option o =
+			 * (weka.core.Option)options.nextElement(); System.out.print(o.synopsis()+" ");
+			 * }
+			 * 
+			 * } catch (InstantiationException e) { e.printStackTrace(); } catch
+			 * (IllegalAccessException e) { e.printStackTrace(); }
+			 * 
+			 * } }
+			 */
+		}
+
+		if (clustererClasses != null && clustererClasses.length > 0) {
+			wekaAlgorithmOption = new MultiChoiceOption("clusterer", 'w', "Weka cluster algorithm to use.",
+					optionLabels, optionDescriptions, 6);
+		} else {
+			horizonOption = null;
+			parameterOption = null;
+
+		}
+
+	}
+
+	@Override
+	public void resetLearningImpl() {
+		try {
+			instances = null;
+			String clistring = clustererClasses[wekaAlgorithmOption.getChosenIndex()].getName();
+			clusterer = (weka.clusterers.AbstractClusterer) ClassOption.cliStringToObject(clistring,
+					weka.clusterers.Clusterer.class, null);
+
+			String rawOptions = parameterOption.getValue();
+			String[] options = rawOptions.split(" ");
+			if (clusterer instanceof weka.core.OptionHandler) {
+				((weka.core.OptionHandler) clusterer).setOptions(options);
+				Utils.checkForRemainingOptions(options);
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		this.instanceConverter = new SamoaToWekaInstanceConverter();
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		if (instances == null) {
+			instances = getDataset(inst.numAttributes(), 0);
+		}
+		instances.add(inst);
+	}
+
+	@Override
+	public Clustering getClusteringResult() {
+		Clustering clustering = null;
+		weka.core.Instances wekaInstances = this.instanceConverter.wekaInstances(instances);
+		try {
+
+			clusterer.buildClusterer(wekaInstances);
+			int numClusters = clusterer.numberOfClusters();
+			InstancesHeader dataset = getDataset(instances.numAttributes(), numClusters);
+			List<Instance> newInstances = new ArrayList<>(); // Instances(dataset);
+
+			for (int i = 0; i < wekaInstances.numInstances(); i++) {
+				weka.core.Instance inst = wekaInstances.get(i);
+				int cnum = clusterer.clusterInstance(inst);
+
+				Instance newInst = new DenseInstance(instances.instance(cnum));
+				newInst.insertAttributeAt(inst.numAttributes());
+				newInst.setDataset(dataset);
+				newInst.setClassValue(cnum);
+				newInstances.add(newInst);
+			}
+			clustering = new Clustering(newInstances);
+
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		instances = null;
+
+		return clustering;
+	}
+
+	public InstancesHeader getDataset(int numdim, int numclass) {
+		FastVector attributes = new FastVector();
+		for (int i = 0; i < numdim; i++) {
+			attributes.addElement(new Attribute("att" + (i + 1)));
+		}
+
+		if (numclass > 0) {
+			FastVector classLabels = new FastVector();
+			for (int i = 0; i < numclass; i++) {
+				classLabels.addElement("class" + (i + 1));
+			}
+			attributes.addElement(new Attribute("class", classLabels));
+		}
+
+		InstancesHeader myDataset = new InstancesHeader("horizion", attributes, 0);
+		if (numclass > 0) {
+			myDataset.setClassIndex(myDataset.numAttributes() - 1);
+		}
+
+		return myDataset;
+	}
+
+	private Class<?>[] findWekaClustererClasses() {
+		AutoExpandVector<Class<?>> finalClasses = new AutoExpandVector<>();
+		Class<?>[] classesFound = AutoClassDiscovery.findClassesOfType("weka.clusterers",
+				weka.clusterers.AbstractClusterer.class);
+		for (Class<?> foundClass : classesFound) {
+			finalClasses.add(foundClass);
+		}
+		return finalClasses.toArray(new Class<?>[finalClasses.size()]);
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		return null;
+	}
+
+	@Override
+	public boolean keepClassLabel() {
+		return false;
+	}
+
+	@Override
+	public String getPurposeString() {
+		String purpose = "MOA Clusterer: " + getClass().getCanonicalName();
+		if (clustererClasses == null || clustererClasses.length == 0) {
+			purpose += "\nPlease add weka.jar to the classpath to use Weka clustering algorithms.";
+		}
+		return purpose;
+
+	}
+}
diff --git a/moa/src/main/java/moa/clusterers/clustream/Clustream.java b/moa/src/main/java/moa/learners/clusterers/clustream/Clustream.java
similarity index 56%
rename from moa/src/main/java/moa/clusterers/clustream/Clustream.java
rename to moa/src/main/java/moa/learners/clusterers/clustream/Clustream.java
index 68b08658a..c3ca382ea 100644
--- a/moa/src/main/java/moa/clusterers/clustream/Clustream.java
+++ b/moa/src/main/java/moa/learners/clusterers/clustream/Clustream.java
@@ -14,11 +14,11 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.clusterers.clustream;
+package moa.learners.clusterers.clustream;
 
 import java.util.ArrayList;
 import java.util.LinkedList;
@@ -33,26 +33,24 @@
 import moa.cluster.Cluster;
 import moa.cluster.Clustering;
 import moa.cluster.SphereCluster;
-import moa.clusterers.AbstractClusterer;
 import moa.core.Measurement;
+import moa.learners.clusterers.AbstractClusterer;
 
-/** Citation: CluStream: Charu C. Aggarwal, Jiawei Han, Jianyong Wang, Philip S. Yu:
- * A Framework for Clustering Evolving Data Streams. VLDB 2003: 81-92
+/**
+ * Citation: CluStream: Charu C. Aggarwal, Jiawei Han, Jianyong Wang, Philip S.
+ * Yu: A Framework for Clustering Evolving Data Streams. VLDB 2003: 81-92
  */
-public class Clustream extends AbstractClusterer{
+public class Clustream extends AbstractClusterer {
 
 	private static final long serialVersionUID = 1L;
 
-	public IntOption timeWindowOption = new IntOption("horizon",
-			'h', "Rang of the window.", 1000);
+	public IntOption timeWindowOption = new IntOption("horizon", 'h', "Rang of the window.", 1000);
 
-	public IntOption maxNumKernelsOption = new IntOption(
-			"maxNumKernels", 'k',
+	public IntOption maxNumKernelsOption = new IntOption("maxNumKernels", 'k',
 			"Maximum number of micro kernels to use.", 100);
 
-	public IntOption kernelRadiFactorOption = new IntOption(
-			"kernelRadiFactor", 't',
-			"Multiplier for the kernel radius", 2);
+	public IntOption kernelRadiFactorOption = new IntOption("kernelRadiFactor", 't', "Multiplier for the kernel radius",
+			2);
 
 	private int timeWindow;
 	private long timestamp = -1;
@@ -66,13 +64,12 @@ public class Clustream extends AbstractClusterer{
 	public Clustream() {
 	}
 
-
 	@Override
 	public void resetLearningImpl() {
 		this.kernels = new ClustreamKernel[maxNumKernelsOption.getValue()];
 		this.timeWindow = timeWindowOption.getValue();
 		this.initialized = false;
-		this.buffer = new LinkedList<ClustreamKernel>();
+		this.buffer = new LinkedList<>();
 		this.bufferSize = maxNumKernelsOption.getValue();
 		t = kernelRadiFactorOption.getValue();
 		m = maxNumKernelsOption.getValue();
@@ -83,25 +80,25 @@ public void trainOnInstanceImpl(Instance instance) {
 		int dim = instance.numValues();
 		timestamp++;
 		// 0. Initialize
-		if ( !initialized ) {
-			if ( buffer.size() < bufferSize ) {
-				buffer.add( new ClustreamKernel(instance,dim, timestamp, t, m) );
+		if (!initialized) {
+			if (buffer.size() < bufferSize) {
+				buffer.add(new ClustreamKernel(instance, dim, timestamp, t, m));
 				return;
 			}
 
 			int k = kernels.length;
-			//System.err.println("k="+k+" bufferSize="+bufferSize);
+			// System.err.println("k="+k+" bufferSize="+bufferSize);
 			assert (k <= bufferSize);
 
 			ClustreamKernel[] centers = new ClustreamKernel[k];
-			for ( int i = 0; i < k; i++ ) {
-				centers[i] = buffer.get( i ); // TODO: make random!
+			for (int i = 0; i < k; i++) {
+				centers[i] = buffer.get(i); // TODO: make random!
 			}
 			Clustering kmeans_clustering = kMeans(k, centers, buffer);
 //			Clustering kmeans_clustering = kMeans(k, buffer);
 
-			for ( int i = 0; i < kmeans_clustering.size(); i++ ) {
-				kernels[i] = new ClustreamKernel( new DenseInstance(1.0,centers[i].getCenter()), dim, timestamp, t, m );
+			for (int i = 0; i < kmeans_clustering.size(); i++) {
+				kernels[i] = new ClustreamKernel(new DenseInstance(1.0, centers[i].getCenter()), dim, timestamp, t, m);
 			}
 
 			buffer.clear();
@@ -109,14 +106,14 @@ public void trainOnInstanceImpl(Instance instance) {
 			return;
 		}
 
-
 		// 1. Determine closest kernel
 		ClustreamKernel closestKernel = null;
 		double minDistance = Double.MAX_VALUE;
-		for ( int i = 0; i < kernels.length; i++ ) {
-			//System.out.println(i+" "+kernels[i].getWeight()+" "+kernels[i].getDeviation());
-			double distance = distance(instance.toDoubleArray(), kernels[i].getCenter() );
-			if ( distance < minDistance ) {
+		for (int i = 0; i < kernels.length; i++) {
+			// System.out.println(i+" "+kernels[i].getWeight()+"
+			// "+kernels[i].getDeviation());
+			double distance = distance(instance.toDoubleArray(), kernels[i].getCenter());
+			if (distance < minDistance) {
 				closestKernel = kernels[i];
 				minDistance = distance;
 			}
@@ -124,26 +121,26 @@ public void trainOnInstanceImpl(Instance instance) {
 
 		// 2. Check whether instance fits into closestKernel
 		double radius = 0.0;
-		if ( closestKernel.getWeight() == 1 ) {
+		if (closestKernel.getWeight() == 1) {
 			// Special case: estimate radius by determining the distance to the
 			// next closest cluster
 			radius = Double.MAX_VALUE;
 			double[] center = closestKernel.getCenter();
-			for ( int i = 0; i < kernels.length; i++ ) {
-				if ( kernels[i] == closestKernel ) {
+			for (int i = 0; i < kernels.length; i++) {
+				if (kernels[i] == closestKernel) {
 					continue;
 				}
 
-				double distance = distance(kernels[i].getCenter(), center );
-				radius = Math.min( distance, radius );
+				double distance = distance(kernels[i].getCenter(), center);
+				radius = Math.min(distance, radius);
 			}
 		} else {
 			radius = closestKernel.getRadius();
 		}
 
-		if ( minDistance < radius ) {
+		if (minDistance < radius) {
 			// Date fits, put into kernel and be happy
-			closestKernel.insert( instance, timestamp );
+			closestKernel.insert(instance, timestamp);
 			return;
 		}
 
@@ -152,9 +149,9 @@ public void trainOnInstanceImpl(Instance instance) {
 		long threshold = timestamp - timeWindow; // Kernels before this can be forgotten
 
 		// 3.1 Try to forget old kernels
-		for ( int i = 0; i < kernels.length; i++ ) {
-			if ( kernels[i].getRelevanceStamp() < threshold ) {
-				kernels[i] = new ClustreamKernel( instance, dim, timestamp, t, m );
+		for (int i = 0; i < kernels.length; i++) {
+			if (kernels[i].getRelevanceStamp() < threshold) {
+				kernels[i] = new ClustreamKernel(instance, dim, timestamp, t, m);
 				return;
 			}
 		}
@@ -163,11 +160,11 @@ public void trainOnInstanceImpl(Instance instance) {
 		int closestA = 0;
 		int closestB = 0;
 		minDistance = Double.MAX_VALUE;
-		for ( int i = 0; i < kernels.length; i++ ) {
+		for (int i = 0; i < kernels.length; i++) {
 			double[] centerA = kernels[i].getCenter();
-			for ( int j = i + 1; j < kernels.length; j++ ) {
-				double dist = distance( centerA, kernels[j].getCenter() );
-				if ( dist < minDistance ) {
+			for (int j = i + 1; j < kernels.length; j++) {
+				double dist = distance(centerA, kernels[j].getCenter());
+				if (dist < minDistance) {
 					minDistance = dist;
 					closestA = i;
 					closestB = j;
@@ -176,22 +173,22 @@ public void trainOnInstanceImpl(Instance instance) {
 		}
 		assert (closestA != closestB);
 
-		kernels[closestA].add( kernels[closestB] );
-		kernels[closestB] = new ClustreamKernel( instance, dim, timestamp, t,  m );
+		kernels[closestA].add(kernels[closestB]);
+		kernels[closestB] = new ClustreamKernel(instance, dim, timestamp, t, m);
 	}
 
 	@Override
 	public Clustering getMicroClusteringResult() {
-		if ( !initialized ) {
-			return new Clustering( new Cluster[0] );
+		if (!initialized) {
+			return new Clustering(new Cluster[0]);
 		}
 
 		ClustreamKernel[] res = new ClustreamKernel[kernels.length];
-		for ( int i = 0; i < res.length; i++ ) {
-			res[i] = new ClustreamKernel( kernels[i], t, m );
+		for (int i = 0; i < res.length; i++) {
+			res[i] = new ClustreamKernel(kernels[i], t, m);
 		}
 
-		return new Clustering( res );
+		return new Clustering(res);
 	}
 
 	@Override
@@ -208,7 +205,7 @@ public String getName() {
 		return "Clustream " + timeWindow;
 	}
 
-	private static double distance(double[] pointA, double [] pointB){
+	private static double distance(double[] pointA, double[] pointB) {
 		double distance = 0.0;
 		for (int i = 0; i < pointA.length; i++) {
 			double d = pointA[i] - pointB[i];
@@ -217,102 +214,100 @@ private static double distance(double[] pointA, double [] pointB){
 		return Math.sqrt(distance);
 	}
 
-	//wrapper... we need to rewrite kmeans to points, not clusters, doesnt make sense anymore
-	//    public static Clustering kMeans( int k, ArrayList<Instance> points, int dim ) {
-	//        ArrayList<ClustreamKernel> cl = new ArrayList<ClustreamKernel>();
-	//        for(Instance inst : points){
-	//            cl.add(new ClustreamKernel(inst, dim , 0, 0, 0));
-	//        }
-	//        Clustering clustering = kMeans(k, cl);
-	//        return clustering;
-	//    }
-
-	public static Clustering kMeans( int k, List<? extends Cluster> data ) {
+	// wrapper... we need to rewrite kmeans to points, not clusters, doesnt make
+	// sense anymore
+	// public static Clustering kMeans( int k, ArrayList<Instance> points, int dim )
+	// {
+	// ArrayList<ClustreamKernel> cl = new ArrayList<ClustreamKernel>();
+	// for(Instance inst : points){
+	// cl.add(new ClustreamKernel(inst, dim , 0, 0, 0));
+	// }
+	// Clustering clustering = kMeans(k, cl);
+	// return clustering;
+	// }
+
+	public static Clustering kMeans(int k, List<? extends Cluster> data) {
 		Random random = new Random(0);
 		Cluster[] centers = new Cluster[k];
 		for (int i = 0; i < centers.length; i++) {
 			int rid = random.nextInt(k);
-			centers[i] = new SphereCluster(data.get(rid).getCenter(),0);
+			centers[i] = new SphereCluster(data.get(rid).getCenter(), 0);
 		}
 		Clustering clustering = kMeans(k, centers, data);
 		return clustering;
 	}
 
-
-
-
-
-	public static Clustering kMeans( int k, Cluster[] centers, List<? extends Cluster> data ) {
+	public static Clustering kMeans(int k, Cluster[] centers, List<? extends Cluster> data) {
 		assert (centers.length == k);
 		assert (k > 0);
 
 		int dimensions = centers[0].getCenter().length;
 
-		ArrayList<ArrayList<Cluster>> clustering = new ArrayList<ArrayList<Cluster>>();
-		for ( int i = 0; i < k; i++ ) {
-			clustering.add( new ArrayList<Cluster>() );
+		ArrayList<ArrayList<Cluster>> clustering = new ArrayList<>();
+		for (int i = 0; i < k; i++) {
+			clustering.add(new ArrayList<Cluster>());
 		}
 
 		int repetitions = 100;
-		while ( repetitions-- >= 0 ) {
+		while (repetitions-- >= 0) {
 			// Assign points to clusters
-			for ( Cluster point : data ) {
-				double minDistance = distance( point.getCenter(), centers[0].getCenter() );
+			for (Cluster point : data) {
+				double minDistance = distance(point.getCenter(), centers[0].getCenter());
 				int closestCluster = 0;
-				for ( int i = 1; i < k; i++ ) {
-					double distance = distance( point.getCenter(), centers[i].getCenter() );
-					if ( distance < minDistance ) {
+				for (int i = 1; i < k; i++) {
+					double distance = distance(point.getCenter(), centers[i].getCenter());
+					if (distance < minDistance) {
 						closestCluster = i;
 						minDistance = distance;
 					}
 				}
 
-				clustering.get( closestCluster ).add( point );
+				clustering.get(closestCluster).add(point);
 			}
 
 			// Calculate new centers and clear clustering lists
 			SphereCluster[] newCenters = new SphereCluster[centers.length];
-			for ( int i = 0; i < k; i++ ) {
-				newCenters[i] = calculateCenter( clustering.get( i ), dimensions );
-				clustering.get( i ).clear();
+			for (int i = 0; i < k; i++) {
+				newCenters[i] = calculateCenter(clustering.get(i), dimensions);
+				clustering.get(i).clear();
 			}
 			centers = newCenters;
 		}
 
-		return new Clustering( centers );
+		return new Clustering(centers);
 	}
 
-	private static SphereCluster calculateCenter( ArrayList<Cluster> cluster, int dimensions ) {
+	private static SphereCluster calculateCenter(ArrayList<Cluster> cluster, int dimensions) {
 		double[] res = new double[dimensions];
-		for ( int i = 0; i < res.length; i++ ) {
+		for (int i = 0; i < res.length; i++) {
 			res[i] = 0.0;
 		}
 
-		if ( cluster.size() == 0 ) {
-			return new SphereCluster( res, 0.0 );
+		if (cluster.size() == 0) {
+			return new SphereCluster(res, 0.0);
 		}
 
-		for ( Cluster point : cluster ) {
-			double [] center = point.getCenter();
+		for (Cluster point : cluster) {
+			double[] center = point.getCenter();
 			for (int i = 0; i < res.length; i++) {
 				res[i] += center[i];
 			}
 		}
 
 		// Normalize
-		for ( int i = 0; i < res.length; i++ ) {
+		for (int i = 0; i < res.length; i++) {
 			res[i] /= cluster.size();
 		}
 
 		// Calculate radius
 		double radius = 0.0;
-		for ( Cluster point : cluster ) {
-			double dist = distance( res, point.getCenter() );
-			if ( dist > radius ) {
+		for (Cluster point : cluster) {
+			double dist = distance(res, point.getCenter());
+			if (dist > radius) {
 				radius = dist;
 			}
 		}
-		SphereCluster sc = new SphereCluster( res, radius );
+		SphereCluster sc = new SphereCluster(res, radius);
 		sc.setWeight(cluster.size());
 		return sc;
 	}
@@ -327,14 +322,14 @@ public void getModelDescription(StringBuilder out, int indent) {
 		throw new UnsupportedOperationException("Not supported yet.");
 	}
 
+	@Override
 	public boolean isRandomizable() {
 		return false;
 	}
 
+	@Override
 	public Prediction getPredictionForInstance(Instance inst) {
 		throw new UnsupportedOperationException("Not supported yet.");
 	}
 
-
 }
-
diff --git a/moa/src/main/java/moa/learners/clusterers/clustream/ClustreamKernel.java b/moa/src/main/java/moa/learners/clusterers/clustream/ClustreamKernel.java
new file mode 100644
index 000000000..181e27324
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/clustream/ClustreamKernel.java
@@ -0,0 +1,274 @@
+/*
+ *    ClustreamKernel.java
+ *    Copyright (C) 2010 RWTH Aachen University, Germany
+ *    @author Jansen (moa@cs.rwth-aachen.de)
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.clusterers.clustream;
+
+import java.util.ArrayList;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.cluster.CFCluster;
+
+public class ClustreamKernel extends CFCluster {
+	private static final long serialVersionUID = 1L;
+
+	private final static double EPSILON = 0.00005;
+	public static final double MIN_VARIANCE = 1e-50;
+
+	protected double LST;
+	protected double SST;
+
+	int m;
+	double t;
+
+	public ClustreamKernel(Instance instance, int dimensions, long timestamp, double t, int m) {
+		super(instance, dimensions);
+		this.t = t;
+		this.m = m;
+		this.LST = timestamp;
+		this.SST = timestamp * timestamp;
+	}
+
+	public ClustreamKernel(ClustreamKernel cluster, double t, int m) {
+		super(cluster);
+		this.t = t;
+		this.m = m;
+		this.LST = cluster.LST;
+		this.SST = cluster.SST;
+	}
+
+	public void insert(Instance instance, long timestamp) {
+		N++;
+		LST += timestamp;
+		SST += timestamp * timestamp;
+
+		for (int i = 0; i < instance.numValues(); i++) {
+			LS[i] += instance.value(i);
+			SS[i] += instance.value(i) * instance.value(i);
+		}
+	}
+
+	@Override
+	public void add(CFCluster other2) {
+		ClustreamKernel other = (ClustreamKernel) other2;
+		assert (other.LS.length == this.LS.length);
+		this.N += other.N;
+		this.LST += other.LST;
+		this.SST += other.SST;
+
+		for (int i = 0; i < LS.length; i++) {
+			this.LS[i] += other.LS[i];
+			this.SS[i] += other.SS[i];
+		}
+	}
+
+	public double getRelevanceStamp() {
+		if (N < 2 * m)
+			return getMuTime();
+
+		return getMuTime() + getSigmaTime() * getQuantile((m) / (2 * N));
+	}
+
+	private double getMuTime() {
+		return LST / N;
+	}
+
+	private double getSigmaTime() {
+		return Math.sqrt(SST / N - (LST / N) * (LST / N));
+	}
+
+	private double getQuantile(double z) {
+		assert (z >= 0 && z <= 1);
+		return Math.sqrt(2) * inverseError(2 * z - 1);
+	}
+
+	@Override
+	public double getRadius() {
+		// trivial cluster
+		if (N == 1)
+			return 0;
+		if (t == 1)
+			t = 1;
+
+		return getDeviation() * radiusFactor;
+	}
+
+	@Override
+	public CFCluster getCF() {
+		return this;
+	}
+
+	private double getDeviation() {
+		double[] variance = getVarianceVector();
+		double sumOfDeviation = 0.0;
+		for (int i = 0; i < variance.length; i++) {
+			double d = Math.sqrt(variance[i]);
+			sumOfDeviation += d;
+		}
+		return sumOfDeviation / variance.length;
+	}
+
+	/**
+	 * @return this kernels' center
+	 */
+	@Override
+	public double[] getCenter() {
+		assert (!this.isEmpty());
+		double res[] = new double[this.LS.length];
+		for (int i = 0; i < res.length; i++) {
+			res[i] = this.LS[i] / N;
+		}
+		return res;
+	}
+
+	/**
+	 * See interface <code>Cluster</code>
+	 * 
+	 * @param point
+	 * @return
+	 */
+	@Override
+	public double getInclusionProbability(Instance instance) {
+		// trivial cluster
+		if (N == 1) {
+			double distance = 0.0;
+			for (int i = 0; i < LS.length; i++) {
+				double d = LS[i] - instance.value(i);
+				distance += d * d;
+			}
+			distance = Math.sqrt(distance);
+			if (distance < EPSILON)
+				return 1.0;
+			return 0.0;
+		} else {
+			double dist = calcNormalizedDistance(instance.toDoubleArray());
+			if (dist <= getRadius()) {
+				return 1;
+			} else {
+				return 0;
+			}
+//            double res = AuxiliaryFunctions.distanceProbabilty(dist, LS.length);
+//            return res;
+		}
+	}
+
+	private double[] getVarianceVector() {
+		double[] res = new double[this.LS.length];
+		for (int i = 0; i < this.LS.length; i++) {
+			double ls = this.LS[i];
+			double ss = this.SS[i];
+
+			double lsDivN = ls / this.getWeight();
+			double lsDivNSquared = lsDivN * lsDivN;
+			double ssDivN = ss / this.getWeight();
+			res[i] = ssDivN - lsDivNSquared;
+
+			// Due to numerical errors, small negative values can occur.
+			// We correct this by settings them to almost zero.
+			if (res[i] <= 0.0) {
+				if (res[i] > -EPSILON) {
+					res[i] = MIN_VARIANCE;
+				}
+			} else {
+
+			}
+		}
+		return res;
+	}
+
+	/**
+	 * Check if this cluster is empty or not.
+	 * 
+	 * @return <code>true</code> if the cluster has no data points,
+	 *         <code>false</code> otherwise.
+	 */
+	public boolean isEmpty() {
+		return this.N == 0;
+	}
+
+	/**
+	 * Calculate the normalized euclidean distance (Mahalanobis distance for
+	 * distribution w/o covariances) to a point.
+	 * 
+	 * @param other The point to which the distance is calculated.
+	 * @return The normalized distance to the cluster center.
+	 *
+	 *         TODO: check whether WEIGHTING is correctly applied to variances
+	 */
+	// ???????
+	private double calcNormalizedDistance(double[] point) {
+		double[] variance = getVarianceVector();
+		double[] center = getCenter();
+		double res = 0.0;
+
+		for (int i = 0; i < center.length; i++) {
+			double diff = center[i] - point[i];
+			res += (diff * diff);// variance[i];
+		}
+		return Math.sqrt(res);
+	}
+
+	/**
+	 * Approximates the inverse error function. Clustream needs this.
+	 * 
+	 * @param z
+	 */
+	public static double inverseError(double x) {
+		double z = Math.sqrt(Math.PI) * x;
+		double res = (z) / 2;
+
+		double z2 = z * z;
+		double zProd = z * z2; // z^3
+		res += (1.0 / 24) * zProd;
+
+		zProd *= z2; // z^5
+		res += (7.0 / 960) * zProd;
+
+		zProd *= z2; // z^7
+		res += (127 * zProd) / 80640;
+
+		zProd *= z2; // z^9
+		res += (4369 * zProd) / 11612160;
+
+		zProd *= z2; // z^11
+		res += (34807 * zProd) / 364953600;
+
+		zProd *= z2; // z^13
+		res += (20036983 * zProd) / 797058662400d;
+
+		return res;
+	}
+
+	@Override
+	protected void getClusterSpecificInfo(ArrayList<String> infoTitle, ArrayList<String> infoValue) {
+		super.getClusterSpecificInfo(infoTitle, infoValue);
+		infoTitle.add("Deviation");
+
+		double[] variance = getVarianceVector();
+		double sumOfDeviation = 0.0;
+		for (int i = 0; i < variance.length; i++) {
+			double d = Math.sqrt(variance[i]);
+			sumOfDeviation += d;
+		}
+
+		sumOfDeviation /= variance.length;
+
+		infoValue.add(Double.toString(sumOfDeviation));
+	}
+}
diff --git a/moa/src/main/java/moa/clusterers/clustream/WithKmeans.java b/moa/src/main/java/moa/learners/clusterers/clustream/WithKmeans.java
similarity index 72%
rename from moa/src/main/java/moa/clusterers/clustream/WithKmeans.java
rename to moa/src/main/java/moa/learners/clusterers/clustream/WithKmeans.java
index 2edefbf87..96a45ef49 100644
--- a/moa/src/main/java/moa/clusterers/clustream/WithKmeans.java
+++ b/moa/src/main/java/moa/learners/clusterers/clustream/WithKmeans.java
@@ -1,10 +1,10 @@
 /**
  * [CluStream_kMeans.java]
  * CluStream with k-means as macroclusterer
- * 
+ *
  * Appeared in seminar paper "Understanding of Internal Clustering Validation Measure in Streaming Environment" (Yunsu Kim)
  * for the course "Seminar: Data Mining and Multimedia Retrival" in RWTH Aachen University, WS 12/13
- * 
+ *
  * @author Yunsu Kim
  * based on the code of Timm Jansen (moa@cs.rwth-aachen.de)
  * Data Management and Data Exploration Group, RWTH Aachen University
@@ -20,11 +20,11 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.clusterers.clustream;
+package moa.learners.clusterers.clustream;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -41,27 +41,22 @@
 import moa.cluster.Cluster;
 import moa.cluster.Clustering;
 import moa.cluster.SphereCluster;
-import moa.clusterers.AbstractClusterer;
 import moa.core.Measurement;
+import moa.learners.clusterers.AbstractClusterer;
 
 public class WithKmeans extends AbstractClusterer {
-	
+
 	private static final long serialVersionUID = 1L;
 
-	public IntOption timeWindowOption = new IntOption("horizon",
-			'h', "Rang of the window.", 1000);
+	public IntOption timeWindowOption = new IntOption("horizon", 'h', "Rang of the window.", 1000);
 
-	public IntOption maxNumKernelsOption = new IntOption(
-			"maxNumKernels", 'm',
+	public IntOption maxNumKernelsOption = new IntOption("maxNumKernels", 'm',
 			"Maximum number of micro kernels to use.", 100);
 
-	public IntOption kernelRadiFactorOption = new IntOption(
-			"kernelRadiFactor", 't',
-			"Multiplier for the kernel radius", 2);
-	
-	public IntOption kOption = new IntOption(
-			"k", 'k',
-			"k of macro k-means (number of clusters)", 5);
+	public IntOption kernelRadiFactorOption = new IntOption("kernelRadiFactor", 't', "Multiplier for the kernel radius",
+			2);
+
+	public IntOption kOption = new IntOption("k", 'k', "k of macro k-means (number of clusters)", 5);
 
 	private int timeWindow;
 	private long timestamp = -1;
@@ -71,9 +66,9 @@ public class WithKmeans extends AbstractClusterer {
 	private int bufferSize;
 	private double t;
 	private int m;
-	
+
 	public WithKmeans() {
-	
+
 	}
 
 	@Override
@@ -81,7 +76,7 @@ public void resetLearningImpl() {
 		this.kernels = new ClustreamKernel[maxNumKernelsOption.getValue()];
 		this.timeWindow = timeWindowOption.getValue();
 		this.initialized = false;
-		this.buffer = new LinkedList<ClustreamKernel>();
+		this.buffer = new LinkedList<>();
 		this.bufferSize = maxNumKernelsOption.getValue();
 		t = kernelRadiFactorOption.getValue();
 		m = maxNumKernelsOption.getValue();
@@ -98,21 +93,22 @@ public void trainOnInstanceImpl(Instance instance) {
 				return;
 			} else {
 				for (int i = 0; i < buffer.size(); i++) {
-					kernels[i] = new ClustreamKernel(new DenseInstance(1.0, buffer.get(i).getCenter()), dim, timestamp, t, m);
+					kernels[i] = new ClustreamKernel(new DenseInstance(1.0, buffer.get(i).getCenter()), dim, timestamp,
+							t, m);
 				}
-	
+
 				buffer.clear();
 				initialized = true;
 				return;
 			}
 		}
 
-
 		// 1. Determine closest kernel
 		ClustreamKernel closestKernel = null;
 		double minDistance = Double.MAX_VALUE;
-		for ( int i = 0; i < kernels.length; i++ ) {
-			//System.out.println(i+" "+kernels[i].getWeight()+" "+kernels[i].getDeviation());
+		for (int i = 0; i < kernels.length; i++) {
+			// System.out.println(i+" "+kernels[i].getWeight()+"
+			// "+kernels[i].getDeviation());
 			double distance = distance(instance.toDoubleArray(), kernels[i].getCenter());
 			if (distance < minDistance) {
 				closestKernel = kernels[i];
@@ -122,26 +118,26 @@ public void trainOnInstanceImpl(Instance instance) {
 
 		// 2. Check whether instance fits into closestKernel
 		double radius = 0.0;
-		if ( closestKernel.getWeight() == 1 ) {
+		if (closestKernel.getWeight() == 1) {
 			// Special case: estimate radius by determining the distance to the
 			// next closest cluster
 			radius = Double.MAX_VALUE;
 			double[] center = closestKernel.getCenter();
-			for ( int i = 0; i < kernels.length; i++ ) {
-				if ( kernels[i] == closestKernel ) {
+			for (int i = 0; i < kernels.length; i++) {
+				if (kernels[i] == closestKernel) {
 					continue;
 				}
 
-				double distance = distance(kernels[i].getCenter(), center );
-				radius = Math.min( distance, radius );
+				double distance = distance(kernels[i].getCenter(), center);
+				radius = Math.min(distance, radius);
 			}
 		} else {
 			radius = closestKernel.getRadius();
 		}
 
-		if ( minDistance < radius ) {
+		if (minDistance < radius) {
 			// Date fits, put into kernel and be happy
-			closestKernel.insert( instance, timestamp );
+			closestKernel.insert(instance, timestamp);
 			return;
 		}
 
@@ -150,9 +146,9 @@ public void trainOnInstanceImpl(Instance instance) {
 		long threshold = timestamp - timeWindow; // Kernels before this can be forgotten
 
 		// 3.1 Try to forget old kernels
-		for ( int i = 0; i < kernels.length; i++ ) {
-			if ( kernels[i].getRelevanceStamp() < threshold ) {
-				kernels[i] = new ClustreamKernel( instance, dim, timestamp, t, m );
+		for (int i = 0; i < kernels.length; i++) {
+			if (kernels[i].getRelevanceStamp() < threshold) {
+				kernels[i] = new ClustreamKernel(instance, dim, timestamp, t, m);
 				return;
 			}
 		}
@@ -161,11 +157,11 @@ public void trainOnInstanceImpl(Instance instance) {
 		int closestA = 0;
 		int closestB = 0;
 		minDistance = Double.MAX_VALUE;
-		for ( int i = 0; i < kernels.length; i++ ) {
+		for (int i = 0; i < kernels.length; i++) {
 			double[] centerA = kernels[i].getCenter();
-			for ( int j = i + 1; j < kernels.length; j++ ) {
-				double dist = distance( centerA, kernels[j].getCenter() );
-				if ( dist < minDistance ) {
+			for (int j = i + 1; j < kernels.length; j++) {
+				double dist = distance(centerA, kernels[j].getCenter());
+				if (dist < minDistance) {
 					minDistance = dist;
 					closestA = i;
 					closestB = j;
@@ -174,10 +170,10 @@ public void trainOnInstanceImpl(Instance instance) {
 		}
 		assert (closestA != closestB);
 
-		kernels[closestA].add( kernels[closestB] );
-		kernels[closestB] = new ClustreamKernel( instance, dim, timestamp, t,  m );
+		kernels[closestA].add(kernels[closestB]);
+		kernels[closestB] = new ClustreamKernel(instance, dim, timestamp, t, m);
 	}
-	
+
 	@Override
 	public Clustering getMicroClusteringResult() {
 		if (!initialized) {
@@ -191,15 +187,15 @@ public Clustering getMicroClusteringResult() {
 
 		return new Clustering(result);
 	}
-	
+
 	@Override
 	public Clustering getClusteringResult() {
-                if (!initialized) {
-                    return new Clustering(new Cluster[0]);
+		if (!initialized) {
+			return new Clustering(new Cluster[0]);
 		}
 		return kMeans_rand(kOption.getValue(), getMicroClusteringResult());
 	}
-	
+
 	public Clustering getClusteringResult(Clustering gtClustering) {
 		return kMeans_gta(kOption.getValue(), getMicroClusteringResult(), gtClustering);
 	}
@@ -210,12 +206,12 @@ public String getName() {
 
 	/**
 	 * Distance between two vectors.
-	 * 
+	 *
 	 * @param pointA
 	 * @param pointB
 	 * @return dist
 	 */
-	private static double distance(double[] pointA, double [] pointB) {
+	private static double distance(double[] pointA, double[] pointB) {
 		double distance = 0.0;
 		for (int i = 0; i < pointA.length; i++) {
 			double d = pointA[i] - pointB[i];
@@ -225,80 +221,83 @@ private static double distance(double[] pointA, double [] pointB) {
 	}
 
 	/**
-	 * k-means of (micro)clusters, with ground-truth-aided initialization.
-	 * (to produce best results) 
-	 * 
+	 * k-means of (micro)clusters, with ground-truth-aided initialization. (to
+	 * produce best results)
+	 *
 	 * @param k
 	 * @param data
 	 * @return (macro)clustering - CFClusters
 	 */
 	public static Clustering kMeans_gta(int k, Clustering clustering, Clustering gtClustering) {
-		
-		ArrayList<CFCluster> microclusters = new ArrayList<CFCluster>();
-        for (int i = 0; i < clustering.size(); i++) {
-            if (clustering.get(i) instanceof CFCluster) {
-                microclusters.add((CFCluster)clustering.get(i));
-            } else {
-                System.out.println("Unsupported Cluster Type:" + clustering.get(i).getClass() + ". Cluster needs to extend moa.cluster.CFCluster");
-            }
-        }
-        
-        int n = microclusters.size();
+
+		ArrayList<CFCluster> microclusters = new ArrayList<>();
+		for (int i = 0; i < clustering.size(); i++) {
+			if (clustering.get(i) instanceof CFCluster) {
+				microclusters.add((CFCluster) clustering.get(i));
+			} else {
+				System.out.println("Unsupported Cluster Type:" + clustering.get(i).getClass()
+						+ ". Cluster needs to extend moa.cluster.CFCluster");
+			}
+		}
+
+		int n = microclusters.size();
 		assert (k <= n);
-		
+
 		/* k-means */
 		Random random = new Random(0);
 		Cluster[] centers = new Cluster[k];
 		int K = gtClustering.size();
-		
+
 		for (int i = 0; i < k; i++) {
-			if (i < K) {	// GT-aided
+			if (i < K) { // GT-aided
 				centers[i] = new SphereCluster(gtClustering.get(i).getCenter(), 0);
-			} else {		// Randomized
+			} else { // Randomized
 				int rid = random.nextInt(n);
 				centers[i] = new SphereCluster(microclusters.get(rid).getCenter(), 0);
 			}
 		}
-		
+
 		return cleanUpKMeans(kMeans(k, centers, microclusters), microclusters);
 	}
-	
+
 	/**
-	 * k-means of (micro)clusters, with randomized initialization. 
-	 * 
+	 * k-means of (micro)clusters, with randomized initialization.
+	 *
 	 * @param k
 	 * @param data
 	 * @return (macro)clustering - CFClusters
 	 */
 	public static Clustering kMeans_rand(int k, Clustering clustering) {
-		
-		ArrayList<CFCluster> microclusters = new ArrayList<CFCluster>();
-        for (int i = 0; i < clustering.size(); i++) {
-            if (clustering.get(i) instanceof CFCluster) {
-                microclusters.add((CFCluster)clustering.get(i));
-            } else {
-                System.out.println("Unsupported Cluster Type:" + clustering.get(i).getClass() + ". Cluster needs to extend moa.cluster.CFCluster");
-            }
-        }
-        
-        int n = microclusters.size();
+
+		ArrayList<CFCluster> microclusters = new ArrayList<>();
+		for (int i = 0; i < clustering.size(); i++) {
+			if (clustering.get(i) instanceof CFCluster) {
+				microclusters.add((CFCluster) clustering.get(i));
+			} else {
+				System.out.println("Unsupported Cluster Type:" + clustering.get(i).getClass()
+						+ ". Cluster needs to extend moa.cluster.CFCluster");
+			}
+		}
+
+		int n = microclusters.size();
 		assert (k <= n);
-		
+
 		/* k-means */
 		Random random = new Random(0);
 		Cluster[] centers = new Cluster[k];
-		
+
 		for (int i = 0; i < k; i++) {
 			int rid = random.nextInt(n);
 			centers[i] = new SphereCluster(microclusters.get(rid).getCenter(), 0);
 		}
-		
+
 		return cleanUpKMeans(kMeans(k, centers, microclusters), microclusters);
 	}
-	
+
 	/**
-	 * (The Actual Algorithm) k-means of (micro)clusters, with specified initialization points.
-	 * 
+	 * (The Actual Algorithm) k-means of (micro)clusters, with specified
+	 * initialization points.
+	 *
 	 * @param k
 	 * @param centers - initial centers
 	 * @param data
@@ -310,7 +309,7 @@ protected static Clustering kMeans(int k, Cluster[] centers, List<? extends Clus
 
 		int dimensions = centers[0].getCenter().length;
 
-		ArrayList<ArrayList<Cluster>> clustering = new ArrayList<ArrayList<Cluster>>();
+		ArrayList<ArrayList<Cluster>> clustering = new ArrayList<>();
 		for (int i = 0; i < k; i++) {
 			clustering.add(new ArrayList<Cluster>());
 		}
@@ -337,7 +336,7 @@ protected static Clustering kMeans(int k, Cluster[] centers, List<? extends Clus
 				newCenters[i] = calculateCenter(clustering.get(i), dimensions);
 				clustering.get(i).clear();
 			}
-			
+
 			// Convergence check
 			boolean converged = true;
 			for (int i = 0; i < k; i++) {
@@ -346,7 +345,7 @@ protected static Clustering kMeans(int k, Cluster[] centers, List<? extends Clus
 					break;
 				}
 			}
-			
+
 			if (converged) {
 				break;
 			} else {
@@ -356,10 +355,11 @@ protected static Clustering kMeans(int k, Cluster[] centers, List<? extends Clus
 
 		return new Clustering(centers);
 	}
-	
+
 	/**
-	 * Rearrange the k-means result into a set of CFClusters, cleaning up the redundancies.
-	 * 
+	 * Rearrange the k-means result into a set of CFClusters, cleaning up the
+	 * redundancies.
+	 *
 	 * @param kMeansResult
 	 * @param microclusters
 	 * @return
@@ -370,47 +370,46 @@ protected static Clustering cleanUpKMeans(Clustering kMeansResult, ArrayList<CFC
 		CFCluster[] converted = new CFCluster[k];
 
 		for (CFCluster mc : microclusters) {
-		    // Find closest kMeans cluster
-		    double minDistance = Double.MAX_VALUE;
-		    int closestCluster = 0;
-		    for (int i = 0; i < k; i++) {
-		    	double distance = distance(kMeansResult.get(i).getCenter(), mc.getCenter());
+			// Find closest kMeans cluster
+			double minDistance = Double.MAX_VALUE;
+			int closestCluster = 0;
+			for (int i = 0; i < k; i++) {
+				double distance = distance(kMeansResult.get(i).getCenter(), mc.getCenter());
 				if (distance < minDistance) {
-				    closestCluster = i;
-				    minDistance = distance;
+					closestCluster = i;
+					minDistance = distance;
 				}
-		    }
-
-		    // Add to cluster
-		    if ( converted[closestCluster] == null ) {
-		    	converted[closestCluster] = (CFCluster)mc.copy();
-		    } else {
-		    	converted[closestCluster].add(mc);
-		    }
+			}
+
+			// Add to cluster
+			if (converted[closestCluster] == null) {
+				converted[closestCluster] = (CFCluster) mc.copy();
+			} else {
+				converted[closestCluster].add(mc);
+			}
 		}
 
 		// Clean up
 		int count = 0;
 		for (int i = 0; i < converted.length; i++) {
-		    if (converted[i] != null)
-			count++;
+			if (converted[i] != null)
+				count++;
 		}
 
 		CFCluster[] cleaned = new CFCluster[count];
 		count = 0;
 		for (int i = 0; i < converted.length; i++) {
-		    if (converted[i] != null)
-			cleaned[count++] = converted[i];
+			if (converted[i] != null)
+				cleaned[count++] = converted[i];
 		}
 
 		return new Clustering(cleaned);
 	}
 
-	
-
 	/**
-	 * k-means helper: Calculate a wrapping cluster of assigned points[microclusters].
-	 * 
+	 * k-means helper: Calculate a wrapping cluster of assigned
+	 * points[microclusters].
+	 *
 	 * @param assigned
 	 * @param dimensions
 	 * @return SphereCluster (with center and radius)
@@ -450,27 +449,28 @@ private static SphereCluster calculateCenter(ArrayList<Cluster> assigned, int di
 		return sc;
 	}
 
-	
 	/** Miscellaneous **/
-	
+
 	@Override
 	public boolean implementsMicroClusterer() {
 		return true;
 	}
-	
+
+	@Override
 	public boolean isRandomizable() {
 		return false;
 	}
-	
+
+	@Override
 	public Prediction getPredictionForInstance(Instance inst) {
 		throw new UnsupportedOperationException("Not supported yet.");
 	}
-	
+
 	@Override
 	protected Measurement[] getModelMeasurementsImpl() {
 		throw new UnsupportedOperationException("Not supported yet.");
 	}
-	
+
 	@Override
 	public void getModelDescription(StringBuilder out, int indent) {
 		throw new UnsupportedOperationException("Not supported yet.");
diff --git a/moa/src/main/java/moa/learners/clusterers/clustree/ClusKernel.java b/moa/src/main/java/moa/learners/clusterers/clustree/ClusKernel.java
new file mode 100644
index 000000000..b53a74041
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/clustree/ClusKernel.java
@@ -0,0 +1,340 @@
+/*
+ *    ClusKernel.java
+ *    Copyright (C) 2010 RWTH Aachen University, Germany
+ *    @author Sanchez Villaamil (moa@cs.rwth-aachen.de)
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.clustree;
+
+import java.util.Arrays;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.cluster.CFCluster;
+import moa.cluster.Cluster;
+
+/**
+ * Representation of an Entry in the tree
+ */
+public class ClusKernel extends CFCluster {
+	/**
+	 * Numeric epsilon.
+	 */
+	public static final double EPSILON = 0.00000001;
+	public static final double MIN_VARIANCE = 1e-50; // 1e-100; // 0.0000001;
+
+	/**
+	 * Counting of the number of N as normal N is weighted by how much time passes
+	 * between updates. If weighted N is under a threshhold, we may consider the
+	 * cluster irrelevant and we can delete it.
+	 */
+
+	private double totalN;
+
+	/**
+	 * A constructor that makes a Kernel which just represents the given point.
+	 * 
+	 * @param point         The point to be converted into a corresponding Kernel.
+	 * @param numberClasses The number of classes possible for points in this
+	 *                      experiment(<code>Tree</code>).
+	 */
+	public ClusKernel(double[] point, int dim) {
+		super(point, dim);
+		this.totalN = 1;
+	}
+
+	/**
+	 * Constructor of the Cluster.
+	 * 
+	 * @param numberDimensions Dimensionality of the points added that can be added
+	 *                         to this cluster
+	 * @param numberClasses    The number of classes possible for points in this
+	 *                         experiment(<code>Tree</code>).
+	 */
+	protected ClusKernel(int numberDimensions) {
+		super(numberDimensions);
+		this.totalN = 0;
+	}
+
+	/**
+	 * Instantiates a copy of the given cluster.
+	 * 
+	 * @param other The <code>Cluster</code> of which we make a copy.
+	 */
+	protected ClusKernel(ClusKernel other) {
+		super(other);
+		this.totalN = other.getTotalN();
+	}
+
+	/**
+	 * Adds the given cluster to this cluster, without making this cluster older.
+	 * 
+	 * @param other
+	 */
+	public void add(ClusKernel other) {
+		super.add(other);
+		this.totalN += other.totalN;
+	}
+
+	/**
+	 * Make this cluster older bei weighting it and add to this cluster the given
+	 * cluster. If we want to add somethin to the cluster, but don't want to weight
+	 * it, we should use the function <code>add(Cluster)</code>.
+	 * 
+	 * @param other          The other cluster to be added to this one.
+	 * @param timeDifference The time elapsed between the last update of the
+	 *                       <code>Entry</code> to which this cluster belongs and
+	 *                       the update that caused the call to this function.
+	 * @param negLambda      A parameter needed to weight the cluster.
+	 * @see #add(tree.Kernel)
+	 */
+	protected void aggregate(ClusKernel other, long timeDifference, double negLambda) {
+		makeOlder(timeDifference, negLambda);
+		add(other);
+	}
+
+	/**
+	 * Make this cluster older. This means multiplying weighted N, LS and SS with a
+	 * weight factor given by the time difference and the parameter negLambda.
+	 * 
+	 * @param timeDifference The time elapsed between this current update and the
+	 *                       last one.
+	 * @param negLambda
+	 */
+	protected void makeOlder(long timeDifference, double negLambda) {
+		if (timeDifference == 0) {
+			return;
+		}
+
+		// double weightFactor = AuxiliaryFunctions.weight(negLambda, timeDifference);
+		assert (negLambda < 0);
+		assert (timeDifference > 0);
+		double weightFactor = Math.pow(2.0, negLambda * timeDifference);
+
+		this.N *= weightFactor;
+		for (int i = 0; i < LS.length; i++) {
+			LS[i] *= weightFactor;
+			SS[i] *= weightFactor;
+		}
+	}
+
+	/**
+	 * Calculate the distance to this other cluster. The other cluster is normaly
+	 * just a single data point(i.e. N = 1).
+	 * 
+	 * @param other The other cluster to which the distance is calculated.
+	 * @return The distance between this cluster and the other.
+	 */
+	public double calcDistance(ClusKernel other) {
+		// TODO: (Fernando, Felix) Adapt the distance function to the new algorithmn.
+
+		double N1 = this.getWeight();
+		double N2 = other.getWeight();
+
+		double[] thisLS = this.LS;
+		double[] otherLS = other.LS;
+
+		double res = 0.0;
+		for (int i = 0; i < thisLS.length; i++) {
+			double substracted = (thisLS[i] / N1) - (otherLS[i] / N2);
+			res += substracted * substracted;
+		}
+
+		// TODO INFO: added sqrt to the computation [PK 10.09.10]
+		return Math.sqrt(res);
+	}
+
+	/**
+	 * Returns the weighted number of points in the cluster.
+	 * 
+	 * @return The weighted number of points in the cluster.
+	 */
+	private double getTotalN() {
+		return totalN;
+	}
+
+	/**
+	 * Check if this cluster is empty or not.
+	 * 
+	 * @return <code>true</code> if the cluster has no data points,
+	 *         <code>false</code> otherwise.
+	 */
+	protected boolean isEmpty() {
+		return this.totalN == 0;
+	}
+
+	/**
+	 * Remove all points from this cluster.
+	 */
+	protected void clear() {
+		this.totalN = 0;
+		this.N = 0.0;
+		Arrays.fill(this.LS, 0.0);
+		Arrays.fill(this.SS, 0.0);
+	}
+
+	/**
+	 * Overwrites the LS, SS and weightedN in this cluster to the values of the
+	 * given cluster but adds N and classCount of the given cluster to this one.
+	 * This function is useful when the weight of an entry becomes to small, and we
+	 * want to forget the information of the old points.
+	 * 
+	 * @param other The cluster that should overwrite the information.
+	 */
+	protected void overwriteOldCluster(ClusKernel other) {
+		this.totalN = other.totalN;
+		this.N = other.N;
+		// AuxiliaryFunctions.overwriteDoubleArray(this.LS, other.LS);
+		// AuxiliaryFunctions.overwriteDoubleArray(this.SS, other.SS);
+		assert (LS.length == other.LS.length);
+		System.arraycopy(other.LS, 0, LS, 0, LS.length);
+		assert (SS.length == other.SS.length);
+		System.arraycopy(other.SS, 0, SS, 0, SS.length);
+	}
+
+	@Override
+	public double getWeight() {
+		return this.N;
+	}
+
+	@Override
+	public CFCluster getCF() {
+		return this;
+	}
+
+	/**
+	 * @return this kernels' center
+	 */
+	@Override
+	public double[] getCenter() {
+		assert (!this.isEmpty());
+		double res[] = new double[this.LS.length];
+		double weightedSize = this.getWeight();
+		for (int i = 0; i < res.length; i++) {
+			res[i] = this.LS[i] / weightedSize;
+		}
+		return res;
+	}
+
+//    @Override
+//    public double getInclusionProbability(Instance instance) {
+//
+//        double dist = calcNormalizedDistance(instance.toDoubleArray());
+//        double res = AuxiliaryFunctions.distanceProbabilty(dist, LS.length);
+//        assert (res >= 0.0 && res <= 1.0) : "Bad confidence " + res + " for"
+//                + " distance " + dist;
+//
+//        return res;
+//    }
+
+	@Override
+	public double getInclusionProbability(Instance instance) {
+		// trivial cluster
+		if (N == 1) {
+			double distance = 0.0;
+			for (int i = 0; i < LS.length; i++) {
+				double d = LS[i] - instance.value(i);
+				distance += d * d;
+			}
+			distance = Math.sqrt(distance);
+			if (distance < EPSILON)
+				return 1.0;
+			return 0.0;
+		} else {
+			double dist = calcNormalizedDistance(instance.toDoubleArray());
+			if (dist <= getRadius()) {
+				return 1;
+			} else {
+				return 0;
+			}
+//            double res = AuxiliaryFunctions.distanceProbabilty(dist, LS.length);
+//            return res;
+		}
+	}
+
+	/**
+	 * See interface <code>Cluster</code>
+	 * 
+	 * @return The radius of the cluster.
+	 * @see Cluster#getRadius()
+	 */
+	@Override
+	public double getRadius() {
+		// trivial cluster
+		if (N == 1)
+			return 0;
+
+		return getDeviation() * radiusFactor;
+	}
+
+	private double getDeviation() {
+		double[] variance = getVarianceVector();
+		double sumOfDeviation = 0.0;
+		for (int i = 0; i < variance.length; i++) {
+			double d = Math.sqrt(variance[i]);
+			sumOfDeviation += d;
+		}
+		return sumOfDeviation / variance.length;
+	}
+
+	public double[] getVarianceVector() {
+		double[] res = new double[this.LS.length];
+		for (int i = 0; i < this.LS.length; i++) {
+			double ls = this.LS[i];
+			double ss = this.SS[i];
+
+			double lsDivN = ls / this.getWeight();
+			double lsDivNSquared = lsDivN * lsDivN;
+			double ssDivN = ss / this.getWeight();
+			res[i] = ssDivN - lsDivNSquared;
+
+			// Due to numerical errors, small negative values can occur.
+			// We correct this by settings them to almost zero.
+			if (res[i] <= 0.0) {
+				if (res[i] > -EPSILON) {
+					res[i] = MIN_VARIANCE;
+				}
+			} else {
+
+			}
+		}
+		return res;
+	}
+
+	/**
+	 * Calculate the normalized euclidean distance (Mahalanobis distance for
+	 * distribution w/o covariances) to a point.
+	 * 
+	 * @param other The point to which the distance is calculated.
+	 * @return The normalized distance to the cluster center.
+	 *
+	 *         TODO: check whether WEIGHTING is correctly applied to variances
+	 */
+	// ???????
+	private double calcNormalizedDistance(double[] point) {
+		double[] variance = getVarianceVector();
+		double[] center = getCenter();
+		double res = 0.0;
+
+		for (int i = 0; i < center.length; i++) {
+			double diff = center[i] - point[i];
+			res += (diff * diff);// variance[i];
+		}
+		return Math.sqrt(res);
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/clustree/ClusTree.java b/moa/src/main/java/moa/learners/clusterers/clustree/ClusTree.java
new file mode 100644
index 000000000..0c0bff991
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/clustree/ClusTree.java
@@ -0,0 +1,832 @@
+/*
+ *    ClusTree.java
+ *    Copyright (C) 2010 RWTH Aachen University, Germany
+ *    @author Sanchez Villaamil (moa@cs.rwth-aachen.de)
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.clustree;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.cluster.Clustering;
+import moa.core.Measurement;
+import moa.learners.clusterers.AbstractClusterer;
+import moa.learners.clusterers.clustree.util.Budget;
+import moa.learners.clusterers.clustree.util.SimpleBudget;
+
+/**
+ * Citation: ClusTree: Philipp Kranen, Ira Assent, Corinna Baldauf, Thomas
+ * Seidl: The ClusTree: indexing micro-clusters for anytime stream mining.
+ * Knowl. Inf. Syst. 29(2): 249-272 (2011)
+ */
+public class ClusTree extends AbstractClusterer {
+	private static final long serialVersionUID = 1L;
+
+	public IntOption horizonOption = new IntOption("horizon", 'h', "Range of the window.", 1000);
+
+	public IntOption maxHeightOption = new IntOption("maxHeight", 'H', "The maximal height of the tree",
+			getDefaultHeight());
+
+	public FlagOption breadthFirstStrategyOption = new FlagOption("breadthFirstStrategy", 'B',
+			"Use breadth first strategy");
+
+	protected int getDefaultHeight() {
+		return 8;
+	}
+
+	private static int INSERTIONS_BETWEEN_CLEANUPS = 10000;
+	/**
+	 * The root node of the tree.
+	 */
+	protected Node root;
+	// Information about the data represented in this tree.
+	/**
+	 * Dimensionality of the data points managed by this tree.
+	 */
+	private int numberDimensions;
+	/**
+	 * Parameter for the weighting function use to weight the entries.
+	 */
+	protected double negLambda;
+	/**
+	 * The current height of the tree. Should always be smaller than maxHeight.
+	 */
+	private int height;
+	/**
+	 * The maximal height of the tree.
+	 */
+	protected int maxHeight;
+	/**
+	 * This variable is used to keep the inverse height that is stored in every node
+	 * correct.
+	 */
+	private int numRootSplits;
+	/**
+	 * The threshold for the weighting of an Entry. An Entry is irrelevant, if it is
+	 * in a leaf and the weightedN of the data Cluster is smaller than this
+	 * threshold.
+	 * 
+	 * @see Entry#data
+	 */
+	private double weightThreshold = 0.05;
+	/**
+	 * Number of points inserted into the tree.
+	 */
+	private int numberInsertions;
+	private long timestamp;
+
+	/**
+	 * Parameter to determine wich strategy to use
+	 */
+	// TODO: Add Option for that
+	protected boolean breadthFirstStrat = false;
+
+	// TODO: cleanup
+	private Entry alsoUpdate;
+
+	@Override
+	public void resetLearningImpl() {
+		breadthFirstStrat = breadthFirstStrategyOption.isSet();
+		negLambda = (1.0 / horizonOption.getValue()) * (Math.log(weightThreshold) / Math.log(2));
+		maxHeight = maxHeightOption.getValue();
+		numberDimensions = -1;
+		root = null;
+		timestamp = 0;
+		height = 0;
+		numRootSplits = 0;
+		numberInsertions = 0;
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return null;
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		return null;
+	}
+
+	@Override
+	public boolean implementsMicroClusterer() {
+		return true;
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance instance) {
+		timestamp++;
+
+		// TODO check if instance contains label
+		if (root == null) {
+			numberDimensions = instance.numAttributes();
+			root = new Node(numberDimensions, 0);
+		} else {
+			if (numberDimensions != instance.numAttributes())
+				System.out.println(
+						"Wrong dimensionality, expected:" + numberDimensions + "found:" + instance.numAttributes());
+		}
+
+		ClusKernel newPointAsKernel = new ClusKernel(instance.toDoubleArray(), numberDimensions);
+		insert(newPointAsKernel, new SimpleBudget(1000), timestamp);
+	}
+
+	/**
+	 * Insert a new point in the <code>Tree</code>. The point should be represented
+	 * as a cluster with a single data point(i.e. N = 1). A <code>Budget</code>
+	 * class is also given, which is informed of the number of operation the tree
+	 * does, and informs the tree when it does not have time left and should stop
+	 * the insertion.
+	 * 
+	 * @param newPoint  The point to be inserted.
+	 * @param budget    The budget and statistics recollector for the insertion.
+	 * @param timestamp The moment at which this point is inserted.
+	 * @see Kernel
+	 * @see Budget
+	 */
+	public void insert(ClusKernel newPoint, Budget budget, long timestamp) {
+		if (breadthFirstStrat) {
+			insertBreadthFirst(newPoint, budget, timestamp);
+		} else {
+			Entry rootEntry = new Entry(this.numberDimensions, root, timestamp, null, null);
+			ClusKernel carriedBuffer = new ClusKernel(this.numberDimensions);
+			Entry toInsertHere = insert(newPoint, carriedBuffer, root, rootEntry, budget, timestamp);
+
+			if (toInsertHere != null) {
+				this.numRootSplits++;
+				this.height += this.height < this.maxHeight ? 1 : 0;
+
+				Node newRoot = new Node(this.numberDimensions, toInsertHere.getChild().getRawLevel() + 1);
+				newRoot.addEntry(rootEntry, timestamp);
+				newRoot.addEntry(toInsertHere, timestamp);
+				rootEntry.setNode(newRoot);
+				toInsertHere.setNode(newRoot);
+				this.root = newRoot;
+			}
+		}
+
+		this.numberInsertions++;
+		if (this.numberInsertions % INSERTIONS_BETWEEN_CLEANUPS == 0) {
+			cleanUp(this.root, 0);
+		}
+	}
+
+	/**
+	 * insert newPoint into the tree using the BreadthFirst strategy, i.e.: insert
+	 * into the closest entry in a leaf node.
+	 * 
+	 * @param newPoint
+	 * @param budget
+	 * @param timestamp
+	 * @return
+	 */
+	private Entry insertBreadthFirst(ClusKernel newPoint, Budget budget, long timestamp) {
+		// check all leaf nodes and get the one with the closest entry to newPoint
+		Node bestFit = findBestLeafNode(newPoint);
+		bestFit.makeOlder(timestamp, negLambda);
+		Entry parent = bestFit.getEntries()[0].getParentEntry();
+		// Search for an Entry with a weight under the threshold.
+		Entry irrelevantEntry = bestFit.getIrrelevantEntry(this.weightThreshold);
+		int numFreeEntries = bestFit.numFreeEntries();
+		Entry newEntry = new Entry(newPoint.getCenter().length, newPoint, timestamp, parent, bestFit);
+		// if there is space, add it to the node ( doesn't ever occur, since nodes are
+		// created with 3 entries)
+		if (numFreeEntries > 0) {
+			bestFit.addEntry(newEntry, timestamp);
+		}
+		// if outdated cluster in this best fitting node, replace it
+		else if (irrelevantEntry != null) {
+			irrelevantEntry.overwriteOldEntry(newEntry);
+		}
+		// if there is space/outdated cluster on path to top, split. Else merge without
+		// split
+		else {
+			if (existsOutdatedEntryOnPath(bestFit) || !this.hasMaximalSize()) {
+				// We have to split.
+				insertHereWithSplit(newEntry, bestFit, timestamp);
+			} else {
+				mergeEntryWithoutSplit(bestFit, newEntry, timestamp);
+			}
+		}
+		// update all nodes on path to top.
+		if (bestFit.getEntries()[0].getParentEntry() != null)
+			updateToTop(bestFit.getEntries()[0].getParentEntry().getNode());
+		return null;
+	}
+
+	/**
+	 * This method checks if there is an outdated (or empty) entry on the path from
+	 * node to root. It updates the weights of nodes on path and then checks if it
+	 * is outdated.
+	 * 
+	 * @param node
+	 * @return true if an outdated/empty entry exists on the path
+	 */
+	private boolean existsOutdatedEntryOnPath(Node node) {
+		if (node == root) {
+			node.makeOlder(timestamp, negLambda);
+			return node.getIrrelevantEntry(this.weightThreshold) != null;
+		}
+		do {
+			node = node.getEntries()[0].getParentEntry().getNode();
+			node.makeOlder(timestamp, negLambda);
+			for (Entry e : node.getEntries()) {
+				e.recalculateData();
+			}
+			if (node.numFreeEntries() > 0)
+				return true;
+			if (node.getIrrelevantEntry(this.weightThreshold) != null)
+				return true;
+		} while (node.getEntries()[0].getParentEntry() != null);
+		return false;
+	}
+
+	/**
+	 * recalculates data for all entries, that lie on the path from the root to the
+	 * Entry toUpdate.
+	 */
+	private void updateToTop(Node toUpdate) {
+		while (toUpdate != null) {
+			for (Entry e : toUpdate.getEntries())
+				e.recalculateData();
+			if (toUpdate.getEntries()[0].getParentEntry() == null)
+				break;
+			toUpdate = toUpdate.getEntries()[0].getParentEntry().getNode();
+		}
+	}
+
+	/**
+	 * Method called by insertBreadthFirst.
+	 * 
+	 * @param toInsert
+	 * @param insertNode
+	 * @param timestamp
+	 * @return
+	 */
+	private Entry insertHereWithSplit(Entry toInsert, Node insertNode, long timestamp) {
+		// Handle root split
+		if (insertNode.getEntries()[0].getParentEntry() == null) {
+			root.makeOlder(timestamp, negLambda);
+			Entry irrelevantEntry = insertNode.getIrrelevantEntry(this.weightThreshold);
+			int numFreeEntries = insertNode.numFreeEntries();
+			if (irrelevantEntry != null) {
+				irrelevantEntry.overwriteOldEntry(toInsert);
+			} else if (numFreeEntries > 0) {
+				insertNode.addEntry(toInsert, timestamp);
+			} else {
+				this.numRootSplits++;
+				this.height += this.height < this.maxHeight ? 1 : 0;
+				Entry oldRootEntry = new Entry(this.numberDimensions, root, timestamp, null, null);
+				Node newRoot = new Node(this.numberDimensions, this.height);
+				Entry newRootEntry = split(toInsert, root, oldRootEntry, timestamp);
+				newRoot.addEntry(oldRootEntry, timestamp);
+				newRoot.addEntry(newRootEntry, timestamp);
+				this.root = newRoot;
+				for (Entry c : oldRootEntry.getChild().getEntries())
+					c.setParentEntry(root.getEntries()[0]);
+				for (Entry c : newRootEntry.getChild().getEntries())
+					c.setParentEntry(root.getEntries()[1]);
+			}
+			return null;
+		}
+		insertNode.makeOlder(timestamp, negLambda);
+		Entry irrelevantEntry = insertNode.getIrrelevantEntry(this.weightThreshold);
+		int numFreeEntries = insertNode.numFreeEntries();
+		if (irrelevantEntry != null) {
+			irrelevantEntry.overwriteOldEntry(toInsert);
+		} else if (numFreeEntries > 0) {
+			insertNode.addEntry(toInsert, timestamp);
+		} else {
+			// We have to split.
+			Entry parentEntry = insertNode.getEntries()[0].getParentEntry();
+			Entry residualEntry = split(toInsert, insertNode, parentEntry, timestamp);
+			if (alsoUpdate != null) {
+				alsoUpdate = residualEntry;
+			}
+			Node nodeForResidualEntry = insertNode.getEntries()[0].getParentEntry().getNode();
+			// recursive call
+			return insertHereWithSplit(residualEntry, nodeForResidualEntry, timestamp);
+		}
+
+		// no Split
+		return null;
+	}
+
+	// XXX: Document the insertion when the final implementation is done.
+	private Entry insertHere(Entry newEntry, Node currentNode, Entry parentEntry, ClusKernel carriedBuffer,
+			Budget budget, long timestamp) {
+
+		int numFreeEntries = currentNode.numFreeEntries();
+
+		// Insert the buffer that we carry.
+		if (!carriedBuffer.isEmpty()) {
+			Entry bufferEntry = new Entry(this.numberDimensions, carriedBuffer, timestamp, parentEntry, currentNode);
+
+			if (numFreeEntries <= 1) {
+				// Distance from buffer to entries.
+				Entry nearestEntryToCarriedBuffer = currentNode.nearestEntry(newEntry);
+				double distanceNearestEntryToBuffer = nearestEntryToCarriedBuffer.calcDistance(newEntry);
+
+				// Distance between buffer and point to insert.
+				double distanceBufferNewEntry = newEntry.calcDistance(carriedBuffer);
+
+				// Best distance between Entrys in the Node.
+				BestMergeInNode bestMergeInNode = calculateBestMergeInNode(currentNode);
+
+				// See what the minimal distance is and do the correspoding
+				// action.
+				if (distanceNearestEntryToBuffer <= distanceBufferNewEntry
+						&& distanceNearestEntryToBuffer <= bestMergeInNode.distance) {
+					// Aggregate buffer entry to nearest entry in node.
+					nearestEntryToCarriedBuffer.aggregateEntry(bufferEntry, timestamp, this.negLambda);
+				} else if (distanceBufferNewEntry <= distanceNearestEntryToBuffer
+						&& distanceBufferNewEntry <= bestMergeInNode.distance) {
+					newEntry.mergeWith(bufferEntry);
+				} else {
+					currentNode.mergeEntries(bestMergeInNode.entryPos1, bestMergeInNode.entryPos2);
+					currentNode.addEntry(bufferEntry, timestamp);
+				}
+
+			} else {
+				assert (currentNode.isLeaf());
+				currentNode.addEntry(bufferEntry, timestamp);
+			}
+		}
+
+		// Normally the insertion of the carries buffer does not change the
+		// number of free entries, but in case of future changes we calculate
+		// the number again.
+		numFreeEntries = currentNode.numFreeEntries();
+
+		// Search for an Entry with a weight under the threshold.
+		Entry irrelevantEntry = currentNode.getIrrelevantEntry(this.weightThreshold);
+		if (currentNode.isLeaf() && irrelevantEntry != null) {
+			irrelevantEntry.overwriteOldEntry(newEntry);
+		} else if (numFreeEntries >= 1) {
+			currentNode.addEntry(newEntry, timestamp);
+		} else {
+			if (currentNode.isLeaf() && (this.hasMaximalSize() || !budget.hasMoreTime())) {
+				mergeEntryWithoutSplit(currentNode, newEntry, timestamp);
+			} else {
+				// We have to split.
+				return split(newEntry, currentNode, parentEntry, timestamp);
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * This method calculates the distances between the new point and each Entry in
+	 * a leaf node. It returns the node that contains the entry with the smallest
+	 * distance to the new point.
+	 * 
+	 * @param newPoint
+	 * @return best fitting node
+	 */
+	private Node findBestLeafNode(ClusKernel newPoint) {
+		double minDist = Double.MAX_VALUE;
+		Node bestFit = null;
+		for (Node e : collectLeafNodes(root)) {
+			if (newPoint.calcDistance(e.nearestEntry(newPoint).getData()) < minDist) {
+				bestFit = e;
+				minDist = newPoint.calcDistance(e.nearestEntry(newPoint).getData());
+			}
+		}
+		if (bestFit != null)
+			return bestFit;
+		else
+			return root;
+	}
+
+	private ArrayList<Node> collectLeafNodes(Node curr) {
+		ArrayList<Node> toReturn = new ArrayList<>();
+		if (curr == null)
+			return toReturn;
+		if (curr.isLeaf()) {
+			toReturn.add(curr);
+			return toReturn;
+		} else {
+			for (Entry e : curr.getEntries())
+				toReturn.addAll(collectLeafNodes(e.getChild()));
+			return toReturn;
+		}
+	}
+
+	// TODO: Expand all function that work on entries to work with the Budget.
+	private Entry insert(ClusKernel pointToInsert, ClusKernel carriedBuffer, Node currentNode, Entry parentEntry,
+			Budget budget, long timestamp) {
+		assert (currentNode != null);
+		assert (currentNode.isLeaf() || currentNode.getEntries()[0].getChild() != null);
+
+		currentNode.makeOlder(timestamp, this.negLambda);
+
+		// This variable will be changed from to null to an actual reference
+		// in the following if-else block if we have to insert something here,
+		// either because this is a leaf, or because of split propagation.
+		Entry toInsertHere = null;
+
+		if (currentNode.isLeaf()) {
+			// At the end of the function the entry will be inserted.
+			toInsertHere = new Entry(this.numberDimensions, pointToInsert, timestamp, parentEntry, currentNode);
+		} else {
+
+			Entry bestEntry = currentNode.nearestEntry(pointToInsert);
+			bestEntry.aggregateCluster(pointToInsert, timestamp, this.negLambda);
+
+			boolean isCarriedBufferEmpty = carriedBuffer.isEmpty();
+
+			Entry bestBufferEntry = null;
+			if (!isCarriedBufferEmpty) {
+				bestBufferEntry = currentNode.nearestEntry(carriedBuffer);
+				bestBufferEntry.aggregateCluster(carriedBuffer, timestamp, this.negLambda);
+			}
+
+			if (!budget.hasMoreTime()) {
+				bestEntry.aggregateToBuffer(pointToInsert, timestamp, this.negLambda);
+				if (!isCarriedBufferEmpty) {
+					bestBufferEntry.aggregateToBuffer(carriedBuffer, timestamp, this.negLambda);
+				}
+				return null;
+			}
+
+			// If the way of the buffer differs from the way of the point to
+			// be inserted, leave the buffer here.
+			if (!isCarriedBufferEmpty && (bestEntry != bestBufferEntry)) {
+				bestBufferEntry.aggregateToBuffer(carriedBuffer, timestamp, this.negLambda);
+				carriedBuffer.clear();
+			}
+			// Take the buffer of the best entry for the point to be inserted
+			// along.
+			ClusKernel takeAlongBuffer = bestEntry.emptyBuffer(timestamp, this.negLambda);
+			carriedBuffer.add(takeAlongBuffer);
+
+			// Recursive call.
+			toInsertHere = insert(pointToInsert, carriedBuffer, bestEntry.getChild(), bestEntry, budget, timestamp);
+		}
+
+		// If the above block has a new Entry for this place insert it.
+		if (toInsertHere != null) {
+			return this.insertHere(toInsertHere, currentNode, parentEntry, carriedBuffer, budget, timestamp);
+		}
+
+		// If nothing else needs to be done in all the above levels
+		// return null to signalize it.
+		return null;
+	}
+
+	/**
+	 * Inserts an <code>Entry</code> into a <code>Node</code> without inducing a
+	 * split.
+	 * 
+	 * @param node      The node at which the entry is to be inserted.
+	 * @param newEntry  The entry to be inserted.
+	 * @param timestamp The moment at which this occurs.
+	 */
+	private void mergeEntryWithoutSplit(Node node, Entry newEntry, long timestamp) {
+
+		Entry nearestEntryToCarriedBuffer = node.nearestEntry(newEntry);
+		double distanceNearestEntryToBuffer = nearestEntryToCarriedBuffer.calcDistance(newEntry);
+
+		BestMergeInNode bestMergeInNode = calculateBestMergeInNode(node);
+
+		if (distanceNearestEntryToBuffer < bestMergeInNode.distance) {
+			nearestEntryToCarriedBuffer.aggregateEntry(newEntry, timestamp, this.negLambda);
+		} else {
+			node.mergeEntries(bestMergeInNode.entryPos1, bestMergeInNode.entryPos2);
+			node.addEntry(newEntry, timestamp);
+		}
+	}
+
+	/**
+	 * Calculates the best merge possible between two nodes in a node. This means
+	 * that the pair with the smallest distance is found.
+	 * 
+	 * @param node The node in which these two entries have to be found.
+	 * @return An object which encodes the two position of the entries with the
+	 *         smallest distance in the node and the distance between them.
+	 * @see BestMergeInNode
+	 * @see Entry#calcDistance(tree.Entry)
+	 */
+	private BestMergeInNode calculateBestMergeInNode(Node node) {
+		assert (node.numFreeEntries() == 0);
+
+		Entry[] entries = node.getEntries();
+
+		int toMerge1 = -1;
+		int toMerge2 = -1;
+		double distanceBetweenMergeEntries = Double.NaN;
+
+		double minDistance = Double.MAX_VALUE;
+		for (int i = 0; i < entries.length; i++) {
+			Entry e1 = entries[i];
+			for (int j = i + 1; j < entries.length; j++) {
+				Entry e2 = entries[j];
+				double distance = e1.calcDistance(e2);
+				if (distance < minDistance) {
+					toMerge1 = i;
+					toMerge2 = j;
+					distanceBetweenMergeEntries = distance;
+				}
+			}
+		}
+
+		assert (toMerge1 != -1 && toMerge2 != -1);
+		if (Double.isNaN(distanceBetweenMergeEntries)) {
+			throw new RuntimeException("The minimal distance between two "
+					+ "Entrys in a Node was Double.MAX_VAUE. That can hardly " + "be right.");
+		}
+
+		return new BestMergeInNode(toMerge1, toMerge2, distanceBetweenMergeEntries);
+	}
+
+	private boolean hasMaximalSize() {
+		// TODO: Improve hasMaximalSize(). For now it just works somehow for testing.
+		return this.height == this.maxHeight;
+	}
+
+	/**
+	 * Performs a (2,2) split on the given node with the given entry. This
+	 * implementation only works if the nodes have three entries each. The split
+	 * will generate two new nodes. One of them will be put where the old node was,
+	 * and for the other a new <code>Entry</code> will be generated and returned.
+	 * 
+	 * @param newEntry    The entry to be added to the node.
+	 * @param node        The node that is going to be splitted.
+	 * @param parentEntry The entry in the tree that points at the node that is
+	 *                    going to be splitted.
+	 * @param timestamp   The moment at which this split occurs.
+	 * @return An entry which points at the second node created in the split. This
+	 *         entry has to be introduced later in the tree.
+	 */
+	private Entry split(Entry newEntry, Node node, Entry parentEntry, long timestamp) {
+		// The implemented split function only works in trees where node
+		// have three entries.
+		// Splitting only makes sense on full nodes.
+		assert (node.numFreeEntries() == 0);
+		assert (parentEntry.getChild() == node);
+
+		// All the entries we have to separate in two nodes.
+		Entry[] allEntries = new Entry[4];
+		Entry[] nodeEntries = node.getEntries();
+		for (int i = 0; i < nodeEntries.length; i++) {
+			allEntries[i] = new Entry(nodeEntries[i]);
+		}
+		allEntries[3] = newEntry;
+
+		// Clear the given node, since we are going to refill it later.
+		node = new Node(this.numberDimensions, node.getRawLevel());
+
+		// Calculate the distance of all the possible pairings, since we want
+		// to do a (2,2) split.
+		double select01 = allEntries[0].calcDistance(allEntries[1]) + allEntries[2].calcDistance(allEntries[3]);
+
+		double select02 = allEntries[0].calcDistance(allEntries[2]) + allEntries[1].calcDistance(allEntries[3]);
+
+		double select03 = allEntries[0].calcDistance(allEntries[3]) + allEntries[1].calcDistance(allEntries[2]);
+
+		// See which of the pairings is minimal and distribute the entries
+		// accordingly.
+		Node residualNode = new Node(this.numberDimensions, node.getRawLevel());
+		if (select01 < select02) {
+			if (select01 < select03) {// select01 smallest
+				node.addEntry(allEntries[0], timestamp);
+				node.addEntry(allEntries[1], timestamp);
+				residualNode.addEntry(allEntries[2], timestamp);
+				residualNode.addEntry(allEntries[3], timestamp);
+			} else {// select03 smallest
+				node.addEntry(allEntries[0], timestamp);
+				node.addEntry(allEntries[3], timestamp);
+				residualNode.addEntry(allEntries[1], timestamp);
+				residualNode.addEntry(allEntries[2], timestamp);
+			}
+		} else {
+			if (select02 < select03) {// select02 smallest
+				node.addEntry(allEntries[0], timestamp);
+				node.addEntry(allEntries[2], timestamp);
+				residualNode.addEntry(allEntries[1], timestamp);
+				residualNode.addEntry(allEntries[3], timestamp);
+			} else {// select03 smallest
+				node.addEntry(allEntries[0], timestamp);
+				node.addEntry(allEntries[3], timestamp);
+				residualNode.addEntry(allEntries[1], timestamp);
+				residualNode.addEntry(allEntries[2], timestamp);
+			}
+		}
+
+		// Set the other node into the tree.
+		parentEntry.setChild(node);
+		parentEntry.recalculateData();
+		int count = 0;
+		for (Entry e : node.getEntries()) {
+			e.setParentEntry(parentEntry);
+			if (e.getData().getN() != 0)
+				count++;
+		}
+		// System.out.println(count);
+		// Generate a new entry for the residual node.
+		Entry residualEntry = new Entry(this.numberDimensions, residualNode, timestamp, parentEntry, node);
+		count = 0;
+		for (Entry e : residualNode.getEntries()) {
+			e.setParentEntry(residualEntry);
+			if (e.getData().getN() != 0)
+				count++;
+		}
+		// System.out.println(count);
+		return residualEntry;
+	}
+
+	/**
+	 * Return the number of time the tree has grown in size. If the tree grows and
+	 * is then cutted from a certain depth, it also counts.
+	 * 
+	 * @return The number of times the root node was splitted.
+	 */
+	public int getNumRootSplits() {
+		return numRootSplits;
+	}
+
+	/**
+	 * Return the current height of the tree. This should never be greater than
+	 * <code>maxHeight</code>.
+	 * 
+	 * @return The height of the tree.
+	 * @see #maxHeight
+	 */
+	public int getHeight() {
+		assert (height <= maxHeight);
+		return height;
+	}
+
+	private void cleanUp(Node currentNode, int level) {
+		if (currentNode == null) {
+			return;
+		}
+
+		Entry[] entries = currentNode.getEntries();
+		if (level == this.maxHeight) {
+			for (int i = 0; i < entries.length; i++) {
+				Entry e = entries[i];
+				e.setChild(null);
+			}
+		} else {
+			for (int i = 0; i < entries.length; i++) {
+				Entry e = entries[i];
+				cleanUp(e.getChild(), level + 1);
+			}
+		}
+	}
+
+	/**
+	 * @param currentTime The current time
+	 * @return The kernels at the leaf level as a clustering
+	 */
+	// TODO: Microcluster unter dem Threshhold nich zur�ckgeben (WIe bei outdated
+	// entries)
+	@Override
+	public Clustering getMicroClusteringResult() {
+		return getClustering(timestamp, -1);
+	}
+
+	@Override
+	public Clustering getClusteringResult() {
+		return null;
+	}
+
+	/**
+	 * @param currentTime The current time
+	 * @return The kernels at the given level as a clustering.
+	 */
+	public Clustering getClustering(long currentTime, int targetLevel) {
+		if (root == null) {
+			return null;
+		}
+
+		Clustering clusters = new Clustering();
+		LinkedList<Node> queue = new LinkedList<>();
+		queue.add(root);
+
+		while (!queue.isEmpty()) {
+			Node current = queue.remove();
+			// if (current == null)
+			// continue;
+			int currentLevel = current.getLevel(this);
+			boolean isLeaf = (current.isLeaf() && currentLevel <= maxHeight) || currentLevel == maxHeight;
+
+			if (currentLevel == targetLevel || (targetLevel == -1 && isLeaf)) {
+				assert (currentLevel <= maxHeight);
+
+				Entry[] entries = current.getEntries();
+				for (int i = 0; i < entries.length; i++) {
+					Entry entry = entries[i];
+					if (entry == null || entry.isEmpty()) {
+						continue;
+					}
+					// XXX
+					entry.makeOlder(currentTime, this.negLambda);
+					if (entry.isIrrelevant(this.weightThreshold))
+						continue;
+
+					ClusKernel gaussKernel = new ClusKernel(entry.getData());
+
+//                  long diff = currentTime - entry.getTimestamp();
+//                    if (diff > 0) {
+//                        gaussKernel.makeOlder(diff, negLambda);
+//                    }
+
+					clusters.add(gaussKernel);
+				}
+			} else if (!current.isLeaf()) {
+				Entry[] entries = current.getEntries();
+				for (int i = 0; i < entries.length; i++) {
+					Entry entry = entries[i];
+
+					if (entry.isEmpty()) {
+						continue;
+					}
+
+					if (entry.isIrrelevant(weightThreshold)) {
+						continue;
+					}
+
+					queue.add(entry.getChild());
+				}
+			}
+		}
+
+		return clusters;
+	}
+
+	/**************************************************************************
+	 * LOCAL CLASSES
+	 **************************************************************************/
+	/**
+	 * A class to code the return value of searching the smallest merge in a node.
+	 */
+	class BestMergeInNode {
+
+		/**
+		 * The position of the first entry in the array of the node.
+		 */
+		public int entryPos1;
+		/**
+		 * The position of the second entry in the array of the node.
+		 */
+		public int entryPos2;
+		/**
+		 * The distance between the two entries.
+		 */
+		public double distance;
+
+		/**
+		 * The constructor of this return value. It will automatically make sure that
+		 * the first position is the smaller one of the two.
+		 * 
+		 * @param pos1     One of the position.
+		 * @param pos2     One of the position.
+		 * @param distance The distance between the entries at these positions.
+		 */
+		public BestMergeInNode(int pos1, int pos2, double distance) {
+			assert (pos1 != pos2);
+
+			this.distance = distance;
+
+			if (pos1 < pos2) {
+				this.entryPos1 = pos1;
+				this.entryPos2 = pos2;
+			} else {
+				this.entryPos1 = pos2;
+				this.entryPos2 = pos1;
+			}
+		}
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/clustree/Entry.java b/moa/src/main/java/moa/learners/clusterers/clustree/Entry.java
new file mode 100644
index 000000000..434171a2b
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/clustree/Entry.java
@@ -0,0 +1,480 @@
+/*
+ *    Entry.java
+ *    Copyright (C) 2010 RWTH Aachen University, Germany
+ *    @author Sanchez Villaamil (moa@cs.rwth-aachen.de)
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.clusterers.clustree;
+
+import java.io.Serializable;
+
+public class Entry implements Serializable {
+
+	/**
+	 * The actual entry data.
+	 */
+	public ClusKernel data;
+	/**
+	 * The buffer of this entry. It can also be seen as the buffer of the child
+	 * node, it is here just to simplify the insertion recuersion.
+	 */
+	private ClusKernel buffer;
+	/**
+	 * A reference to the next node in the tree. <code>null</code> if we are at a
+	 * leaf, or this is an entry is part of a lying <code>Node</code>.
+	 */
+	private Node child;
+	/**
+	 * A reference to the Entry's parent Entry
+	 */
+	private Entry parentEntry;
+	/**
+	 * A reference to the Node, that contains this Entry
+	 */
+	private Node node;
+	/**
+	 * Last time this entry was changed.
+	 */
+	private long timestamp;
+	/**
+	 * The timestamp to be used when no operation has yet been done on this entry.
+	 * 
+	 * @see #timestamp
+	 */
+	private static final long defaultTimestamp = 0;
+
+	/**
+	 * Constructor for the entry. To be used when we want to create an empty entry.
+	 * Notice that the timestamp will be set to zero, since there is no reason to
+	 * know when an empty entry was generated.
+	 * 
+	 * @param numberDimensions The dimensionality of the data point in tree where
+	 *                         this entry is used.
+	 */
+	public Entry(int numberDimensions) {
+		this.data = new ClusKernel(numberDimensions);
+		this.buffer = new ClusKernel(numberDimensions);
+		this.child = null;
+		this.timestamp = Entry.defaultTimestamp;
+	}
+
+	/**
+	 * Constructor that creates an <code>Entry</code> that points to the given node.
+	 * The values of <code>data</code> will be calculated for this.
+	 * 
+	 * @param numberDimensions The dimensionality of the node.
+	 * @param node             The node to which the new <code>Entry</code> should
+	 *                         point.
+	 * @param currentTime      The timestamp for the moment where this Entry was was
+	 *                         generated.
+	 * @see Node
+	 * @see #data
+	 */
+	protected Entry(int numberDimensions, Node node, long currentTime, Entry parentEntry, Node containerNode) {
+		this(numberDimensions);
+		this.child = node;
+		this.parentEntry = parentEntry;
+		this.node = containerNode;
+		Entry[] entries = node.getEntries();
+		for (int i = 0; i < entries.length; i++) {
+			Entry entry = entries[i];
+			entry.setParentEntry(this);
+			if (entry.isEmpty()) {
+				break;
+			}
+
+			this.add(entry);
+		}
+
+		this.timestamp = currentTime;
+	}
+
+	/**
+	 * Constructuctor that creates an <code>Entry</code> with an empty buffer and
+	 * the <code>data</code> given by the <code>Kernel</code>.
+	 * 
+	 * @param numberDimensions The dimensionality of the information in the cluster.
+	 * @param cluster          The cluster from which the information is to be
+	 *                         extracted.
+	 * @param currentTime      The timestamp for the moment where this Entry was was
+	 *                         generated.
+	 * @see Kernel
+	 * @see #data
+	 */
+	public Entry(int numberDimensions, ClusKernel cluster, long currentTime) {
+		this(numberDimensions);
+		this.data.add(cluster);
+		this.timestamp = currentTime;
+	}
+
+	/**
+	 * extended constructor with containerNode and parentEntry
+	 * 
+	 * @param numberDimensions
+	 * @param cluster
+	 * @param currentTime
+	 * @param parentEntry
+	 * @param containerNode
+	 */
+	protected Entry(int numberDimensions, ClusKernel cluster, long currentTime, Entry parentEntry, Node containerNode) {
+		this(numberDimensions);
+		this.parentEntry = parentEntry;
+		this.data.add(cluster);
+		this.node = containerNode;
+		this.timestamp = currentTime;
+	}
+
+	/**
+	 * Copy constructor. Everythin is copied, including the child.
+	 * 
+	 * @param other
+	 */
+	protected Entry(Entry other) {
+		this.parentEntry = other.parentEntry;
+		this.node = other.node;
+		this.buffer = new ClusKernel(other.buffer);
+		this.data = new ClusKernel(other.data);
+		this.timestamp = other.timestamp;
+		this.child = other.child;
+		if (other.getChild() != null)
+			for (Entry e : other.getChild().getEntries()) {
+				e.setParentEntry(this);
+			}
+	}
+
+	public Node getNode() {
+		return node;
+	}
+
+	public void setNode(Node node) {
+		this.node = node;
+	}
+
+	/**
+	 * Clear the Entry. All points in the buffer and in the data cluster are lost,
+	 * the connection to the child is lost and the timestamp is set to the default
+	 * value.
+	 */
+	protected void clear() {
+		this.data.clear();
+		this.buffer.clear();
+		this.child = null;
+		this.timestamp = Entry.defaultTimestamp;
+	}
+
+	/**
+	 * Clear the <code>data</code> and the <code>buffer Custer</code> in this entry.
+	 * This function does not clear the child of this <code>Entry</code>.
+	 * 
+	 * @see #data
+	 * @see #buffer
+	 * @see Kernel
+	 */
+	protected void shallowClear() {
+		this.buffer.clear();
+		this.data.clear();
+	}
+
+	/**
+	 * Calculates the distance to the data in this entry.
+	 * 
+	 * @param cluster The Kernel cluster to which the distance is to be calculated.
+	 * @return The distance to the data <code>Kernel</code> in this
+	 *         <code>Entry</code>
+	 * @see Kernel
+	 * @see #data
+	 */
+	protected double calcDistance(ClusKernel cluster) {
+		return data.calcDistance(cluster);
+	}
+
+	/**
+	 * Calculates the distance to the data in this entry of the data in the given
+	 * entry.
+	 * 
+	 * @param other The <code>Entry</code> to which the distance is to be
+	 *              calculated.
+	 * @return The distance to the data <code>Kernel</code> in this
+	 *         <code>Entry</code> of the data <code>Kernel</code> in the other
+	 *         <code>Entry</code>.
+	 * @see Kernel
+	 * @see #data
+	 */
+	public double calcDistance(Entry other) {
+		return this.getData().calcDistance(other.getData());
+	}
+
+	/**
+	 * When this entry is empty, give it it's first values. It makes sense to have
+	 * this operation separated from the aggregation, because the aggregation first
+	 * weights the values in <code>data</code> and <code>Kernel</code>, which makes
+	 * no sense in an empty entry.
+	 * 
+	 * @param other       The entry with the information to be used to initialize
+	 *                    this entry.
+	 * @param currentTime The time at which this is happening.
+	 */
+	protected void initializeEntry(Entry other, long currentTime) {
+		assert (this.isEmpty());
+		assert (other.getBuffer().isEmpty());
+		this.data.add(other.data);
+		this.timestamp = currentTime;
+		this.child = other.child;
+		if (child != null) {
+			for (Entry e : child.getEntries()) {
+				e.setParentEntry(this);
+			}
+		}
+	}
+
+	/**
+	 * Add the data cluster of another entry to the data cluster of this entry. By
+	 * using this function the timestamp does not get updated, nor does this entry
+	 * get older.
+	 * 
+	 * @param other The entry of which the data cluster should be added to the local
+	 *              data cluster.
+	 * @see #data
+	 * @see Kernel#add(tree.Kernel)
+	 */
+	public void add(Entry other) {
+		this.data.add(other.data);
+	}
+
+	/**
+	 * Aggregate the <code>data</code> in the <code>Kernel</code> of the other
+	 * <code>Entry</code>.
+	 * 
+	 * @param other The <code>Entry</code> to be aggregated.
+	 * @see #data
+	 * @see Kernel
+	 */
+	protected void aggregateEntry(Entry other, long currentTime, double negLambda) {
+		this.data.aggregate(other.data, currentTime - this.timestamp, negLambda);
+		this.timestamp = currentTime;
+	}
+
+	/**
+	 * Aggregate the given <code>Kernel</code> to the <code>data</code> cluster of
+	 * this entry.
+	 * 
+	 * @param otherData The <code>Entry</code> to be aggregated.
+	 * @see #data
+	 * @see Kernel
+	 */
+	protected void aggregateCluster(ClusKernel otherData, long currentTime, double negLambda) {
+		this.getData().aggregate(otherData, currentTime - this.timestamp, negLambda);
+		this.timestamp = currentTime;
+	}
+
+	/**
+	 * Aggregate the given <code>Kernel</code> to the <code>buffer</code> cluster of
+	 * this entry.
+	 * 
+	 * @param pointToInsert The cluster to aggregate to the buffer.
+	 * @param currentTime   The time at which the aggregation occurs.
+	 * @param negLambda     A parameter needed to weight the current state of the
+	 *                      buffer.
+	 */
+	protected void aggregateToBuffer(ClusKernel pointToInsert, long currentTime, double negLambda) {
+		ClusKernel currentBuffer = this.getBuffer();
+		currentBuffer.aggregate(pointToInsert, currentTime - this.timestamp, negLambda);
+		this.timestamp = currentTime;
+	}
+
+	/**
+	 * Merge this entry witht the given <code>Entry</code>. This adds the data
+	 * cluster of the given Entry to the data cluster of this entry and sets the
+	 * timestamp to the newest one of the the two entries.
+	 * 
+	 * @param other The entry from which the data cluster is added.
+	 * @see Kernel#add(tree.Kernel)
+	 */
+	protected void mergeWith(Entry other) {
+		// We should only merge entries in leafs, and leafes should have empty
+		// buffers.
+		assert (this.child == null);
+		assert (other.child == null);
+		assert (other.buffer.isEmpty());
+
+		this.data.add(other.data);
+		if (this.timestamp < other.timestamp) {
+			this.timestamp = other.timestamp;
+		}
+	}
+
+	/**
+	 * Getter for the buffer. It is the real object, that means side effects are
+	 * possible!
+	 * 
+	 * @return A reference to the buffer in this entry.
+	 */
+	protected ClusKernel getBuffer() {
+		return buffer;
+	}
+
+	/**
+	 * Return the reference to the child of this <code>Entry</code> to navigate in
+	 * the tree.
+	 * 
+	 * @return A reference to the child of this <code>Entry</code>
+	 */
+	public Node getChild() {
+		return child;
+	}
+
+	/**
+	 * Getter for the data. It is the real object, that means side effects are
+	 * possible!
+	 * 
+	 * @return A reference to the data <code>Kernel</code> in this entry.
+	 * @see Kernel
+	 */
+	protected ClusKernel getData() {
+		return data;
+	}
+
+	public Entry getParentEntry() {
+		return parentEntry;
+	}
+
+	public void setParentEntry(Entry parent) {
+		this.parentEntry = parent;
+	}
+
+	/**
+	 * Setter for the child in this entry. Use to build the tree.
+	 * 
+	 * @param child The <code>Node</code> that should be a child of this
+	 *              <code>Entry</code>
+	 * @see Node
+	 */
+	public void setChild(Node child) {
+		this.child = child;
+	}
+
+	/**
+	 * Return the current timestamp.
+	 * 
+	 * @return The current timestamp.
+	 */
+	public long getTimestamp() {
+		return timestamp;
+	}
+
+	/**
+	 * Clear the buffer in this entry and return a copy. No side effects are
+	 * possible (given that the copy constructor of <code>Kernel</code> makes a deep
+	 * copy).
+	 * 
+	 * @return A copy of the buffer.
+	 */
+	protected ClusKernel emptyBuffer(long currentTime, double negLambda) {
+		this.buffer.makeOlder(currentTime - this.timestamp, negLambda);
+		ClusKernel bufferCopy = new ClusKernel(this.buffer);
+		this.buffer.clear();
+		return bufferCopy;
+	}
+
+	/**
+	 * Check if this <code>Entry</code> is empty or not. An <code>Entry</code> is
+	 * empty if the <code>data Kernel</code> is empty, since then the buffer has to
+	 * be empty.
+	 * 
+	 * @return <code>true</code> if the data cluster has no data points,
+	 *         <code>false</code> otherwise.
+	 */
+	protected boolean isEmpty() {
+		// Assert that if the data cluster is empty, the buffer cluster is
+		// empty too.
+		assert ((this.data.isEmpty() && this.buffer.isEmpty()) || !this.data.isEmpty());
+
+		return this.data.isEmpty();
+	}
+
+	/**
+	 * Overwrites the LS, SS and weightedN in the data cluster of this
+	 * <code>Entry</code> to the values of the data cluster in the given
+	 * <code>Entry</code>, but adds N and classCount of the cluster in the given
+	 * Entry to the data cluster in this one. This function is useful when the
+	 * weight of an entry becomes to small, and we want to forget the information of
+	 * the old points.
+	 * 
+	 * @param newEntry The cluster that should overwrite the information.
+	 */
+	protected void overwriteOldEntry(Entry newEntry) {
+		assert (this.getBuffer().isEmpty());
+		assert (newEntry.getBuffer().isEmpty());
+		this.data.overwriteOldCluster(newEntry.data);
+		newEntry.setParentEntry(this.parentEntry);
+		if (newEntry.getChild() != null)
+			for (Entry e : newEntry.getChild().getEntries())
+				e.setParentEntry(this);
+		// this.setParentEntry(newEntry.getParentEntry());
+		this.child = newEntry.child;
+	}
+
+	/**
+	 * This functions reads every entry in the child node and calculates the
+	 * corresponding <code>data Kernel</code>. Timestamps are not changed.
+	 * 
+	 * @see #data
+	 * @see Kerne
+	 */
+	protected void recalculateData() {
+		Node currentChild = this.getChild();
+		if (currentChild != null) {
+			ClusKernel currentData = this.getData();
+			currentData.clear();
+			Entry[] entries = currentChild.getEntries();
+			for (int i = 0; i < entries.length; i++) {
+				currentData.add(entries[i].getData());
+			}
+		} else {
+			this.clear();
+		}
+	}
+
+	/**
+	 * Returns true if this entry is irrelevant with respecto the given threshold.
+	 * This is done by comparing the weighted N of this Entry to the threshold, if
+	 * it is smaller, than the entry is deemed to be irrelevant.
+	 * 
+	 * @param threshold The threshold under which entries at leafs can be erased.
+	 * @return True if this entry is deemed irrelevant, false otherwise.
+	 */
+	protected boolean isIrrelevant(double threshold) {
+		return this.getData().getWeight() < threshold;
+	}
+
+	/**
+	 * Ages this entrie's data AND buffer according to the given time and aging
+	 * constant.
+	 * 
+	 * @param currentTime the current time
+	 * @param negLambda   the aging constant
+	 */
+	protected void makeOlder(long currentTime, double negLambda) {
+//        assert (currentTime > this.timestamp) : "currentTime : "
+//                + currentTime + ", this.timestamp: " + this.timestamp;
+
+		long diff = currentTime - this.timestamp;
+		this.buffer.makeOlder(diff, negLambda);
+		this.data.makeOlder(diff, negLambda);
+		this.timestamp = currentTime;
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/clustree/Node.java b/moa/src/main/java/moa/learners/clusterers/clustree/Node.java
new file mode 100644
index 000000000..e3d11edcb
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/clustree/Node.java
@@ -0,0 +1,340 @@
+/*
+ *    Node.java
+ *    Copyright (C) 2010 RWTH Aachen University, Germany
+ *    @author Sanchez Villaamil (moa@cs.rwth-aachen.de)
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.clustree;
+
+import java.io.Serializable;
+
+public class Node implements Serializable {
+
+	final int NUMBER_ENTRIES = 3;
+	static int INSERTIONS_BETWEEN_CLEANUPS = 10000;
+
+	/**
+	 * The children of this node.
+	 */
+	private Entry[] entries;
+	// Information about the state in the tree.
+	/**
+	 * The depth at which this <code>Node</code> is in the tree.
+	 */
+	private int level;
+
+	/**
+	 * Initialze a normal node, which is not fake.
+	 * 
+	 * @param numberDimensions The dimensionality of the data points it manipulates.
+	 * @param level            The INVERSE level at which this node hangs.
+	 */
+	public Node(int numberDimensions, int level) {
+		this.level = level;
+
+		this.entries = new Entry[NUMBER_ENTRIES];
+		// Generate all entries when we generate a Node.
+		// That no entry can be null makes it much easier to handle.
+		for (int i = 0; i < NUMBER_ENTRIES; i++) {
+			entries[i] = new Entry(numberDimensions);
+			entries[i].setNode(this);
+		}
+	}
+
+	/**
+	 * Initialiazes a node which is a fake root depending on the given
+	 * <code>boolean</code>.
+	 * 
+	 * @param numberDimensions The dimensionality of the data points it manipulates.
+	 * @param level            The level at which this node hangs.
+	 * @param fakeRoot         A parameter the says if the node is to be fake or
+	 *                         not.
+	 */
+	protected Node(int numberDimensions, int numberClasses, int level, boolean fakeRoot) {
+
+		this.level = level;
+
+		this.entries = new Entry[NUMBER_ENTRIES];
+		// Generate all entries when we generate a Node.
+		// That no entry can be null makes it much easier to handle.
+		for (int i = 0; i < NUMBER_ENTRIES; i++) {
+			entries[i] = new Entry(numberDimensions);
+		}
+	}
+
+	/**
+	 * USED FOR EM_TOP_DOWN BULK LOADING
+	 * 
+	 * @param numberDimensions
+	 * @param level
+	 * @param argEntries
+	 */
+	public Node(int numberDimensions, int level, Entry[] argEntries) {
+		this.level = level;
+
+		this.entries = new Entry[NUMBER_ENTRIES];
+		// Generate all entries when we generate a Node.
+		// That no entry can be null makes it much easier to handle.
+		for (int i = 0; i < NUMBER_ENTRIES; i++) {
+			entries[i] = argEntries[i];
+		}
+	}
+
+	/**
+	 * Checks if this node is a leaf. A node is a leaf when none of the entries in
+	 * the node have children.
+	 * 
+	 * @return <code>true</code> if the node is leaf, <code>false</code> otherwise.
+	 */
+	protected boolean isLeaf() {
+
+		for (int i = 0; i < entries.length; i++) {
+			Entry entry = entries[i];
+			if (entry.getChild() != null) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * Returns the neareast <code>Entry</code> to the given <code>Cluster</code>.
+	 * The distance is minimized over <code>Entry.calcDistance(Cluster)</code>.
+	 * 
+	 * @param buffer The cluster to which the distance has to be compared.
+	 * @return The <code>Entry</code> with minimal distance to the given cluster.
+	 * @throws EmptyNodeException This Exception is thrown when this function is
+	 *                            called on an empty node.
+	 * @see Kernel
+	 * @see Entry#calcDistance(moa.learners.clusterers.tree.Kernel)
+	 */
+	public Entry nearestEntry(ClusKernel buffer) {
+
+		// TODO: (Fernando) Adapt the nearestEntry(...) function to the new algorithmn.
+
+		Entry res = entries[0];
+		double min = res.calcDistance(buffer);
+		for (int i = 1; i < entries.length; i++) {
+			Entry entry = entries[i];
+
+			if (entry.isEmpty()) {
+				break;
+			}
+
+			double distance = entry.calcDistance(buffer);
+			if (distance < min) {
+				min = distance;
+				res = entry;
+			}
+		}
+
+		return res;
+	}
+
+	/**
+	 * Return the nearest entry to the given one. The
+	 * <code>calcDistance(Entry)</code> function is find the one with the shortest
+	 * distance in this node to the given one.
+	 * 
+	 * @param newEntry The entry to which the entry with the minimal distance to it
+	 *                 is calculated.
+	 * @return The entry with the minimal distance to the given one.
+	 */
+	protected Entry nearestEntry(Entry newEntry) {
+		assert (!this.entries[0].isEmpty());
+
+		Entry res = entries[0];
+		double min = res.calcDistance(newEntry);
+		for (int i = 1; i < entries.length; i++) {
+
+			if (this.entries[i].isEmpty()) {
+				break;
+			}
+
+			Entry entry = entries[i];
+			double distance = entry.calcDistance(newEntry);
+			if (distance < min) {
+				min = distance;
+				res = entry;
+			}
+		}
+
+		return res;
+	}
+
+	/**
+	 * Return the number of free <code>Entry</code>s in this node.
+	 * 
+	 * @return The number of free <code>Entry</code>s in this node.
+	 * @see Entry
+	 */
+	protected int numFreeEntries() {
+		int res = 0;
+		for (int i = 0; i < entries.length; i++) {
+			Entry entry = entries[i];
+			if (entry.isEmpty()) {
+				res++;
+			}
+		}
+
+		assert (NUMBER_ENTRIES == entries.length);
+		return res;
+	}
+
+	/**
+	 * Add a new <code>Entry</code> to this node. If there is no space left a
+	 * <code>NoFreeEntryException</code> is thrown.
+	 * 
+	 * @param newEntry The <code>Entry</code> to be added.
+	 * @throws NoFreeEntryException Is thrown when there is no space left in the
+	 *                              node for the new entry.
+	 */
+	public void addEntry(Entry newEntry, long currentTime) {
+		newEntry.setNode(this);
+		int freePosition = getNextEmptyPosition();
+		entries[freePosition].initializeEntry(newEntry, currentTime);
+	}
+
+	/**
+	 * Returns the position of the next free Entry.
+	 * 
+	 * @return The position of the next free Entry.
+	 * @throws NoFreeEntryException Is thrown when there is no free entry left in
+	 *                              the node.
+	 */
+	private int getNextEmptyPosition() {
+		int counter;
+		for (counter = 0; counter < entries.length; counter++) {
+			Entry e = entries[counter];
+			if (e.isEmpty()) {
+				break;
+			}
+		}
+
+		if (counter == entries.length) {
+			throw new RuntimeException("Entry added to a node which is already full.");
+		}
+
+		return counter;
+	}
+
+	/**
+	 * If there exists an entry, whose relevance is under the threshold given as a
+	 * parameter to the tree, this entry is returned. Otherwise <code>null</code> is
+	 * returned.
+	 * 
+	 * @return An irrelevant <code>Entry</code> if there exists one,
+	 *         <code>null</code> otherwise.
+	 * @see Entry
+	 * @see Entry#isIrrelevant(double)
+	 */
+	protected Entry getIrrelevantEntry(double threshold) {
+		for (int i = 0; i < this.entries.length; i++) {
+			Entry entry = this.entries[i];
+			if (entry.isIrrelevant(threshold)) {
+				return entry;
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * Return an array with references to the children of this node. These are not
+	 * copies, that means side effects are possible!
+	 * 
+	 * @return An array with references to the children of this node.
+	 * @see Entry
+	 */
+	public Entry[] getEntries() {
+		return entries;
+	}
+
+	/**
+	 * Return the level number in the node. This is not the real level. For the real
+	 * level one has to call <code>getLevel(Tree tree)</code>.
+	 * 
+	 * @return The raw level of the node.
+	 * @see #getLevel(moa.learners.clusterers.LiarTree.Tree)
+	 */
+	protected int getRawLevel() {
+		return level;
+	}
+
+	/**
+	 * Returns the level at which this node is in the tree. If a tree is passed to
+	 * which the node does not belonged a value is returned, but it is gibberish.
+	 * 
+	 * @param tree The tree to which this node belongs.
+	 * @return The level at which this node hangs.
+	 */
+	protected int getLevel(ClusTree tree) {
+		int numRootSplits = tree.getNumRootSplits();
+		return numRootSplits - this.getRawLevel();
+	}
+
+	/**
+	 * Clear this Node, which means that the noiseBuffer is cleared, that
+	 * <code>shallowClear</code> is called upon all the entries of the node, that
+	 * the split counter is set to zero and the node is set to not be a fake root.
+	 * Notice that the level stays the same after calling this function.
+	 * 
+	 * @see Kernel#clear()
+	 * @see Entry#shallowClear()
+	 */
+	// Level stays the same.
+	protected void clear() {
+		for (int i = 0; i < NUMBER_ENTRIES; i++) {
+			entries[i].shallowClear();
+		}
+	}
+
+	/**
+	 * Merge the two entries at the given position. The entries are reordered in the
+	 * <code>entries</code> array so that the non-empty entries are still at the
+	 * beginning.
+	 * 
+	 * @param pos1 The position of the first entry to be merged. This position has
+	 *             to be smaller than the the second position.
+	 * @param pos2 The position of the second entry to be merged. This position has
+	 *             to be greater than the the first position.
+	 */
+	protected void mergeEntries(int pos1, int pos2) {
+		assert (this.numFreeEntries() == 0);
+		assert (pos1 < pos2);
+
+		this.entries[pos1].mergeWith(this.entries[pos2]);
+
+		for (int i = pos2; i < entries.length - 1; i++) {
+			entries[i] = entries[i + 1];
+		}
+		entries[entries.length - 1].clear();
+	}
+
+	protected void makeOlder(long currentTime, double negLambda) {
+		for (int i = 0; i < this.entries.length; i++) {
+			Entry entry = this.entries[i];
+
+			if (entry.isEmpty()) {
+				break;
+			}
+
+			entry.makeOlder(currentTime, negLambda);
+		}
+	}
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/clustree/util/Budget.java b/moa/src/main/java/moa/learners/clusterers/clustree/util/Budget.java
new file mode 100644
index 000000000..ac1b14344
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/clustree/util/Budget.java
@@ -0,0 +1,124 @@
+/*
+ *    Budget.java
+ *    Copyright (C) 2010 RWTH Aachen University, Germany
+ *    @author Sanchez Villaamil (moa@cs.rwth-aachen.de)
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.clustree.util;
+
+/**
+ * This is an interface for classes that are to be given along with every data
+ * point inserted in the tree. The tree has to inform the implementation of this
+ * <code>Budget</code> interface of every operation it does, and ask at the
+ * places where it can stop prematurely if it should. This models the arrival of
+ * a new data point in the stream, before there was enough time to insert the
+ * current one.
+ */
+public interface Budget {
+
+	/**
+	 * A function for the tree to ask if there is budget(time) left.
+	 * 
+	 * @return A <code>boolean</code> that is <code>true</code> if the tree should
+	 *         go on, <code>false</code> otherwise.
+	 */
+	boolean hasMoreTime();
+
+	/**
+	 * Inform the <code>Budget</code> class that an integer addition has been
+	 * performed by the tree.
+	 */
+	void integerAddition();
+
+	/**
+	 * Inform the <code>Budget</code> that a certain number of integer additions
+	 * have been done.
+	 * 
+	 * @param number the number of additions done.
+	 */
+	void integerAddition(int number);
+
+	/**
+	 * Inform the <code>Budget</code> class that a double addition has been
+	 * performed by the tree.
+	 */
+	void doubleAddition();
+
+	/**
+	 * Inform the <code>Budget</code> that a certain number of double additions have
+	 * been performed.
+	 * 
+	 * @param number the number of additions done.
+	 */
+	void doubleAddition(int number);
+
+	/**
+	 * Inform the <code>Budget</code> class that a integer multiplicaton has been
+	 * performed by the tree.
+	 */
+	void integerMultiplication();
+
+	/**
+	 * Inform the <code>Budget</code> that a certain number of integer
+	 * multiplications have been performed.
+	 * 
+	 * @param number the number of multiplication done.
+	 */
+	void integerMultiplication(int number);
+
+	/**
+	 * Inform the <code>Budget</code> class that a double multiplicaton has been
+	 * performed by the tree.
+	 */
+	void doubleMultiplication();
+
+	/**
+	 * Inform the <code>Budget</code> that a certain number of double
+	 * multiplications have been performed.
+	 * 
+	 * @param number the number of multiplications done.
+	 */
+	void doubleMultiplication(int number);
+
+	/**
+	 * Inform the <code>Budget</code> class that a integer division has been
+	 * performed by the tree.
+	 */
+	void integerDivision();
+
+	/**
+	 * Inform the <code>Budget</code> that a certain number of integer divisions
+	 * have been performed.
+	 * 
+	 * @param number the number of division done.
+	 */
+	void integerDivision(int number);
+
+	/**
+	 * Inform the <code>Budget</code> class that a double division has been
+	 * performed by the tree.
+	 */
+	void doubleDivision();
+
+	/**
+	 * Inform the <code>Budget</code> that a certain number of double divisions have
+	 * been performed.
+	 * 
+	 * @param number the number of divisions done.
+	 */
+	void doubleDivision(int number);
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/clustree/util/SimpleBudget.java b/moa/src/main/java/moa/learners/clusterers/clustree/util/SimpleBudget.java
new file mode 100644
index 000000000..b5f871f49
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/clustree/util/SimpleBudget.java
@@ -0,0 +1,102 @@
+/*
+ *    SimpleBudget.java
+ *    Copyright (C) 2010 RWTH Aachen University, Germany
+ *    @author Reidl (moa@cs.rwth-aachen.de)
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.clustree.util;
+
+public class SimpleBudget implements Budget {
+
+	public static final int INT_ADD = 1;
+	public static final int INT_MULT = 1;
+	public static final int INT_DIV = 1;
+	public static final int DOUBLE_ADD = 1;
+	public static final int DOUBLE_MULT = 1;
+	public static final int DOUBLE_DIV = 10;
+	private int time;
+
+	public SimpleBudget(int time) {
+		assert (time >= 0);
+		this.time = time;
+	}
+
+	@Override
+	public boolean hasMoreTime() {
+		return time > 0;
+	}
+
+	@Override
+	public void integerAddition() {
+		time -= INT_ADD;
+	}
+
+	@Override
+	public void integerAddition(int number) {
+		time -= INT_ADD * number;
+	}
+
+	@Override
+	public void doubleAddition() {
+		time -= DOUBLE_ADD;
+	}
+
+	@Override
+	public void doubleAddition(int number) {
+		time -= DOUBLE_ADD * number;
+	}
+
+	@Override
+	public void integerMultiplication() {
+		time -= INT_MULT;
+	}
+
+	@Override
+	public void integerMultiplication(int number) {
+		time -= INT_MULT * number;
+	}
+
+	@Override
+	public void doubleMultiplication() {
+		time -= DOUBLE_MULT;
+	}
+
+	@Override
+	public void doubleMultiplication(int number) {
+		time -= DOUBLE_MULT * number;
+	}
+
+	@Override
+	public void integerDivision() {
+		time -= INT_DIV;
+	}
+
+	@Override
+	public void integerDivision(int number) {
+		time -= INT_DIV * number;
+	}
+
+	@Override
+	public void doubleDivision() {
+		time -= DOUBLE_DIV;
+	}
+
+	@Override
+	public void doubleDivision(int number) {
+		time -= DOUBLE_DIV * number;
+	}
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/denstream/MicroCluster.java b/moa/src/main/java/moa/learners/clusterers/denstream/MicroCluster.java
new file mode 100644
index 000000000..28a666d6e
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/denstream/MicroCluster.java
@@ -0,0 +1,159 @@
+/*
+ *    MicroCluster.java
+ *    Copyright (C) 2010 RWTH Aachen University, Germany
+ *    @author Wels (moa@cs.rwth-aachen.de)
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.clusterers.denstream;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.cluster.CFCluster;
+
+public class MicroCluster extends CFCluster {
+
+	private long lastEditT = -1;
+	private long creationTimestamp = -1;
+	private double lambda;
+	private Timestamp currentTimestamp;
+
+	public MicroCluster(double[] center, int dimensions, long creationTimestamp, double lambda,
+			Timestamp currentTimestamp) {
+		super(center, dimensions);
+		this.creationTimestamp = creationTimestamp;
+		this.lastEditT = creationTimestamp;
+		this.lambda = lambda;
+		this.currentTimestamp = currentTimestamp;
+	}
+
+	public MicroCluster(Instance instance, int dimensions, long timestamp, double lambda, Timestamp currentTimestamp) {
+		this(instance.toDoubleArray(), dimensions, timestamp, lambda, currentTimestamp);
+	}
+
+	public void insert(Instance instance, long timestamp) {
+		N++;
+		super.setWeight(super.getWeight() + 1);
+		this.lastEditT = timestamp;
+
+		for (int i = 0; i < instance.numValues(); i++) {
+			LS[i] += instance.value(i);
+			SS[i] += instance.value(i) * instance.value(i);
+		}
+	}
+
+	public long getLastEditTimestamp() {
+		return lastEditT;
+	}
+
+	private double[] calcCF2(long dt) {
+		double[] cf2 = new double[SS.length];
+		for (int i = 0; i < SS.length; i++) {
+			cf2[i] = Math.pow(2, -lambda * dt) * SS[i];
+		}
+		return cf2;
+	}
+
+	private double[] calcCF1(long dt) {
+		double[] cf1 = new double[LS.length];
+		for (int i = 0; i < LS.length; i++) {
+			cf1[i] = Math.pow(2, -lambda * dt) * LS[i];
+		}
+		return cf1;
+	}
+
+	@Override
+	public double getWeight() {
+		return getWeight(currentTimestamp.getTimestamp());
+	}
+
+	private double getWeight(long timestamp) {
+		long dt = timestamp - lastEditT;
+		return (N * Math.pow(2, -lambda * dt));
+	}
+
+	public long getCreationTime() {
+		return creationTimestamp;
+	}
+
+	@Override
+	public double[] getCenter() {
+		return getCenter(currentTimestamp.getTimestamp());
+	}
+
+	private double[] getCenter(long timestamp) {
+		long dt = timestamp - lastEditT;
+		double w = getWeight(timestamp);
+		double[] res = new double[LS.length];
+		for (int i = 0; i < LS.length; i++) {
+			res[i] = LS[i];
+			res[i] *= Math.pow(2, -lambda * dt);
+			res[i] /= w;
+		}
+		return res;
+	}
+
+	@Override
+	public double getRadius() {
+		return getRadius(currentTimestamp.getTimestamp()) * radiusFactor;
+	}
+
+	public double getRadius(long timestamp) {
+		long dt = timestamp - lastEditT;
+		double[] cf1 = calcCF1(dt);
+		double[] cf2 = calcCF2(dt);
+		double w = getWeight(timestamp);
+		double max = 0;
+		double sum = 0;
+		for (int i = 0; i < SS.length; i++) {
+			double x1 = cf2[i] / w;
+			double x2 = Math.pow(cf1[i] / w, 2);
+			// sum += Math.pow(x1 - x2,2);
+			sum += (x1 - x2);
+			if (Math.sqrt(x1 - x2) > max) {
+				max = Math.sqrt(x1 - x2);
+			}
+		}
+		return max;
+	}
+
+	@Override
+	public MicroCluster copy() {
+		MicroCluster copy = new MicroCluster(this.LS.clone(), this.LS.length, this.getCreationTime(), this.lambda,
+				this.currentTimestamp);
+		copy.setWeight(this.N + 1);
+		copy.N = this.N;
+		copy.SS = this.SS.clone();
+		copy.LS = this.LS.clone();
+		copy.lastEditT = this.lastEditT;
+		return copy;
+	}
+
+	@Override
+	public double getInclusionProbability(Instance instance) {
+		if (getCenterDistance(instance) <= getRadius()) {
+			return 1.0;
+		}
+		return 0.0;
+	}
+
+	@Override
+	public CFCluster getCF() {
+		CFCluster cf = copy();
+		double w = getWeight();
+		cf.setN(w);
+		return cf;
+	}
+}
diff --git a/moa/src/main/java/moa/clusterers/denstream/Timestamp.java b/moa/src/main/java/moa/learners/clusterers/denstream/Timestamp.java
similarity index 56%
rename from moa/src/main/java/moa/clusterers/denstream/Timestamp.java
rename to moa/src/main/java/moa/learners/clusterers/denstream/Timestamp.java
index 9c26b421a..befeea93a 100644
--- a/moa/src/main/java/moa/clusterers/denstream/Timestamp.java
+++ b/moa/src/main/java/moa/learners/clusterers/denstream/Timestamp.java
@@ -14,37 +14,39 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.clusterers.denstream;
+package moa.learners.clusterers.denstream;
 
 import moa.AbstractMOAObject;
-public class Timestamp extends AbstractMOAObject{
 
-    private long timestamp;
+public class Timestamp extends AbstractMOAObject {
+
+	private long timestamp;
 
-    public Timestamp(long timestamp) {
-        this.timestamp = timestamp;
-    }
+	public Timestamp(long timestamp) {
+		this.timestamp = timestamp;
+	}
 
-    public Timestamp() {
-        timestamp = 0;
-    }
+	public Timestamp() {
+		timestamp = 0;
+	}
 
-    public long getTimestamp() {
-        return timestamp;
-    }
+	public long getTimestamp() {
+		return timestamp;
+	}
 
-    public void increase() {
-        timestamp++;
-    }
+	public void increase() {
+		timestamp++;
+	}
 
-    public void setTimestamp(long timestamp) {
-        this.timestamp = timestamp;
-    }
+	public void setTimestamp(long timestamp) {
+		this.timestamp = timestamp;
+	}
 
-    public void getDescription(StringBuilder sb, int i) {
-    }
+	@Override
+	public void getDescription(StringBuilder sb, int i) {
+	}
 }
diff --git a/moa/src/main/java/moa/clusterers/denstream/WithDBSCAN.java b/moa/src/main/java/moa/learners/clusterers/denstream/WithDBSCAN.java
similarity index 83%
rename from moa/src/main/java/moa/clusterers/denstream/WithDBSCAN.java
rename to moa/src/main/java/moa/learners/clusterers/denstream/WithDBSCAN.java
index 48807b791..cc9fc96a6 100644
--- a/moa/src/main/java/moa/clusterers/denstream/WithDBSCAN.java
+++ b/moa/src/main/java/moa/learners/clusterers/denstream/WithDBSCAN.java
@@ -1,8 +1,8 @@
 /**
  * Subspace MOA [DenStream_DBSCAN.java]
- * 
+ *
  * DenStream with DBSCAN as the macro-clusterer.
- * 
+ *
  * @author Stephan Wels (stephan.wels@rwth-aachen.de)
  * @editor Yunsu Kim
  * Data Management and Data Exploration Group, RWTH Aachen University
@@ -18,11 +18,11 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.clusterers.denstream;
+package moa.learners.clusterers.denstream;
 
 import java.util.ArrayList;
 
@@ -34,37 +34,30 @@
 
 import moa.cluster.Cluster;
 import moa.cluster.Clustering;
-import moa.clusterers.AbstractClusterer;
-import moa.clusterers.macro.dbscan.DBScan;
 import moa.core.Measurement;
+import moa.learners.clusterers.AbstractClusterer;
+import moa.learners.clusterers.macro.dbscan.DBScan;
 
 public class WithDBSCAN extends AbstractClusterer {
-	
+
 	private static final long serialVersionUID = 1L;
-	
-	public IntOption horizonOption = new IntOption("horizon", 'h',
-			"Range of the window.", 1000);
-	public FloatOption epsilonOption = new FloatOption("epsilon", 'e',
-			"Defines the epsilon neighbourhood", 0.02, 0, 1);
+
+	public IntOption horizonOption = new IntOption("horizon", 'h', "Range of the window.", 1000);
+	public FloatOption epsilonOption = new FloatOption("epsilon", 'e', "Defines the epsilon neighbourhood", 0.02, 0, 1);
 	// public IntOption minPointsOption = new IntOption("minPoints", 'p',
 	// "Minimal number of points cluster has to contain.", 10);
 
-	public FloatOption betaOption = new FloatOption("beta", 'b', "", 0.2, 0,
-			1);
-	public FloatOption muOption = new FloatOption("mu", 'm', "", 1, 0,
-			Double.MAX_VALUE);
-	public IntOption initPointsOption = new IntOption("initPoints", 'i',
-			"Number of points to use for initialization.", 1000);
-
-	 public FloatOption offlineOption = new FloatOption("offline", 'o',
-	 "offline multiplier for epsilion.", 2, 2, 20);
-	 
-	 public FloatOption lambdaOption = new FloatOption("lambda", 'l', "",
-			 0.25,
-			 0, 1);
-	 
-	 public IntOption speedOption = new IntOption("processingSpeed", 's',
-				"Number of incoming points per time unit.", 100, 1, 1000);
+	public FloatOption betaOption = new FloatOption("beta", 'b', "", 0.2, 0, 1);
+	public FloatOption muOption = new FloatOption("mu", 'm', "", 1, 0, Double.MAX_VALUE);
+	public IntOption initPointsOption = new IntOption("initPoints", 'i', "Number of points to use for initialization.",
+			1000);
+
+	public FloatOption offlineOption = new FloatOption("offline", 'o', "offline multiplier for epsilion.", 2, 2, 20);
+
+	public FloatOption lambdaOption = new FloatOption("lambda", 'l', "", 0.25, 0, 1);
+
+	public IntOption speedOption = new IntOption("processingSpeed", 's', "Number of incoming points per time unit.",
+			100, 1, 1000);
 
 	private double weightThreshold = 0.01;
 	double lambda;
@@ -81,7 +74,7 @@ public class WithDBSCAN extends AbstractClusterer {
 	private long timestamp = 0;
 	Timestamp currentTimestamp;
 	long tp;
-	
+
 	/* #point variables */
 	protected int numInitPoints;
 	protected int numProcessedPerUnit;
@@ -89,9 +82,9 @@ public class WithDBSCAN extends AbstractClusterer {
 	// TODO Some variables to prevent duplicated processes
 
 	private class DenPoint extends DenseInstance {
-		
+
 		private static final long serialVersionUID = 1L;
-		
+
 		protected boolean covered;
 
 		public DenPoint(Instance nextInstance, Long timestamp) {
@@ -116,10 +109,10 @@ public void resetLearningImpl() {
 		initialized = false;
 		p_micro_cluster = new Clustering();
 		o_micro_cluster = new Clustering();
-		initBuffer = new ArrayList<DenPoint>();
-		
+		initBuffer = new ArrayList<>();
+
 		tp = Math.round(1 / lambda * Math.log((beta * mu) / (beta * mu - 1))) + 1;
-		
+
 		numProcessedPerUnit = 0;
 		processingSpeed = speedOption.getValue();
 	}
@@ -129,11 +122,9 @@ public void initialDBScan() {
 			DenPoint point = initBuffer.get(p);
 			if (!point.covered) {
 				point.covered = true;
-				ArrayList<Integer> neighbourhood = getNeighbourhoodIDs(point,
-						initBuffer, epsilon);
+				ArrayList<Integer> neighbourhood = getNeighbourhoodIDs(point, initBuffer, epsilon);
 				if (neighbourhood.size() > minPoints) {
-					MicroCluster mc = new MicroCluster(point,
-							point.numAttributes(), timestamp, lambda,
+					MicroCluster mc = new MicroCluster(point, point.numAttributes(), timestamp, lambda,
 							currentTimestamp);
 					expandCluster(mc, initBuffer, neighbourhood);
 					p_micro_cluster.add(mc);
@@ -148,13 +139,13 @@ public void initialDBScan() {
 	public void trainOnInstanceImpl(Instance inst) {
 		DenPoint point = new DenPoint(inst, timestamp);
 		numProcessedPerUnit++;
-		
+
 		/* Controlling the stream speed */
 		if (numProcessedPerUnit % processingSpeed == 0) {
 			timestamp++;
 			currentTimestamp.setTimestamp(timestamp);
-		}		
-		
+		}
+
 		// ////////////////
 		// Initialization//
 		// ////////////////
@@ -193,17 +184,15 @@ public void trainOnInstanceImpl(Instance inst) {
 				}
 			}
 			if (!merged) {
-				o_micro_cluster.getClustering().add(
-						new MicroCluster(point.toDoubleArray(), point
-								.toDoubleArray().length, timestamp, lambda,
-								currentTimestamp));
+				o_micro_cluster.getClustering().add(new MicroCluster(point.toDoubleArray(),
+						point.toDoubleArray().length, timestamp, lambda, currentTimestamp));
 			}
 
 			// //////////////////////////
 			// Periodic cluster removal//
 			// //////////////////////////
 			if (timestamp % tp == 0) {
-				ArrayList<MicroCluster> removalList = new ArrayList<MicroCluster>();
+				ArrayList<MicroCluster> removalList = new ArrayList<>();
 				for (Cluster c : p_micro_cluster.getClustering()) {
 					if (((MicroCluster) c).getWeight() < beta * mu) {
 						removalList.add((MicroCluster) c);
@@ -215,8 +204,7 @@ public void trainOnInstanceImpl(Instance inst) {
 
 				for (Cluster c : o_micro_cluster.getClustering()) {
 					long t0 = ((MicroCluster) c).getCreationTime();
-					double xsi1 = Math
-							.pow(2, (-lambda * (timestamp - t0 + tp))) - 1;
+					double xsi1 = Math.pow(2, (-lambda * (timestamp - t0 + tp))) - 1;
 					double xsi2 = Math.pow(2, -lambda * tp) - 1;
 					double xsi = xsi1 / xsi2;
 					if (((MicroCluster) c).getWeight() < xsi) {
@@ -231,15 +219,13 @@ public void trainOnInstanceImpl(Instance inst) {
 		}
 	}
 
-	private void expandCluster(MicroCluster mc, ArrayList<DenPoint> points,
-			ArrayList<Integer> neighbourhood) {
+	private void expandCluster(MicroCluster mc, ArrayList<DenPoint> points, ArrayList<Integer> neighbourhood) {
 		for (int p : neighbourhood) {
 			DenPoint npoint = points.get(p);
 			if (!npoint.covered) {
 				npoint.covered = true;
 				mc.insert(npoint, timestamp);
-				ArrayList<Integer> neighbourhood2 = getNeighbourhoodIDs(npoint,
-						initBuffer, epsilon);
+				ArrayList<Integer> neighbourhood2 = getNeighbourhoodIDs(npoint, initBuffer, epsilon);
 				if (neighbourhood.size() > minPoints) {
 					expandCluster(mc, points, neighbourhood2);
 				}
@@ -247,14 +233,12 @@ private void expandCluster(MicroCluster mc, ArrayList<DenPoint> points,
 		}
 	}
 
-	private ArrayList<Integer> getNeighbourhoodIDs(DenPoint point,
-			ArrayList<DenPoint> points, double eps) {
-		ArrayList<Integer> neighbourIDs = new ArrayList<Integer>();
+	private ArrayList<Integer> getNeighbourhoodIDs(DenPoint point, ArrayList<DenPoint> points, double eps) {
+		ArrayList<Integer> neighbourIDs = new ArrayList<>();
 		for (int p = 0; p < points.size(); p++) {
 			DenPoint npoint = points.get(p);
 			if (!npoint.covered) {
-				double dist = distance(point.toDoubleArray(), points.get(p)
-						.toDoubleArray());
+				double dist = distance(point.toDoubleArray(), points.get(p).toDoubleArray());
 				if (dist < eps) {
 					neighbourIDs.add(p);
 				}
@@ -291,8 +275,9 @@ private double distance(double[] pointA, double[] pointB) {
 		return Math.sqrt(distance);
 	}
 
+	@Override
 	public Clustering getClusteringResult() {
-		DBScan dbscan = new DBScan(p_micro_cluster,offlineOption.getValue() * epsilon, minPoints);
+		DBScan dbscan = new DBScan(p_micro_cluster, offlineOption.getValue() * epsilon, minPoints);
 		return dbscan.getClustering(p_micro_cluster);
 	}
 
@@ -315,14 +300,16 @@ protected Measurement[] getModelMeasurementsImpl() {
 	public void getModelDescription(StringBuilder out, int indent) {
 	}
 
+	@Override
 	public boolean isRandomizable() {
 		return true;
 	}
 
+	@Override
 	public Prediction getPredictionForInstance(Instance inst) {
 		return null;
 	}
-	
+
 	public String getParameterString() {
 		StringBuffer sb = new StringBuffer();
 		sb.append(this.getClass().getSimpleName() + " ");
diff --git a/moa/src/main/java/moa/clusterers/dstream/CharacteristicVector.java b/moa/src/main/java/moa/learners/clusterers/dstream/CharacteristicVector.java
similarity index 63%
rename from moa/src/main/java/moa/clusterers/dstream/CharacteristicVector.java
rename to moa/src/main/java/moa/learners/clusterers/dstream/CharacteristicVector.java
index 6f958da48..50e459e49 100644
--- a/moa/src/main/java/moa/clusterers/dstream/CharacteristicVector.java
+++ b/moa/src/main/java/moa/learners/clusterers/dstream/CharacteristicVector.java
@@ -1,6 +1,6 @@
 /**
  *    CharacteristicVector.java
- *    
+ *
  *    @author Richard Hugh Moulton  (rmoul026 -[at]- uottawa dot ca)
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,101 +13,96 @@
  *    distributed under the License is distributed on an "AS IS" BASIS,
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
- *    limitations under the License.  
+ *    limitations under the License.
  */
 
-package moa.clusterers.dstream;
+package moa.learners.clusterers.dstream;
 
 /**
- * The Characteristic Vector of a density grid is defined in 
- * Definition 3.2 of Chen and Tu 2007 as:
- * The characteristic vector of a grid g is a tuple (tg,tm,D, label,status), 
- * where tg is the last time when g is updated, tm is the last time when g 
- * is removed from grid list as a sporadic grid (if ever), D is the grid 
- * density at the last update, label is the class label of the grid, and 
- * status = {SPORADIC, NORMAL} is a label used for removing sporadic grids.
- * 
- * Citation: Y. Chen and L. Tu, “Density-Based Clustering for Real-Time Stream Data,” in
- * Proceedings of the 13th ACM SIGKDD international conference on Knowledge discovery and
- * data mining, 2007, pp. 133–142.
+ * The Characteristic Vector of a density grid is defined in Definition 3.2 of
+ * Chen and Tu 2007 as: The characteristic vector of a grid g is a tuple
+ * (tg,tm,D, label,status), where tg is the last time when g is updated, tm is
+ * the last time when g is removed from grid list as a sporadic grid (if ever),
+ * D is the grid density at the last update, label is the class label of the
+ * grid, and status = {SPORADIC, NORMAL} is a label used for removing sporadic
+ * grids.
+ *
+ * Citation: Y. Chen and L. Tu, “Density-Based Clustering for Real-Time Stream
+ * Data,” in Proceedings of the 13th ACM SIGKDD international conference on
+ * Knowledge discovery and data mining, 2007, pp. 133–142.
  */
 public class CharacteristicVector {
-	
+
 	private static final int SPARSE = 0;
 	private static final int TRANSITIONAL = 1;
 	private static final int DENSE = 2;
-	
+
 	/**
-	 * t_g in the characteristic vector tuple; 
-	 * The last time when g is updated
+	 * t_g in the characteristic vector tuple; The last time when g is updated
 	 */
 	private int updateTime;
-	
+
 	/**
-	 * t_m in the characteristic vector tuple;
-	 * the last time when g is removed from grid_list as a sporadic
-	 * grid (if ever).
+	 * t_m in the characteristic vector tuple; the last time when g is removed from
+	 * grid_list as a sporadic grid (if ever).
 	 */
 	private int removeTime;
-	
+
 	/**
-	 * D in the characteristic vector tuple; 
-	 * the grid density at the last update
+	 * D in the characteristic vector tuple; the grid density at the last update
 	 */
 	private double gridDensity;
-	
+
 	/**
-	 * label in the characteristic vector tuple; 
-	 * the cluster label of the grid
+	 * label in the characteristic vector tuple; the cluster label of the grid
 	 */
 	private int label;
-	
+
 	/**
-	 * status in the characteristic vector tuple; 
-	 * status = {SPORADIC, NORMAL}
+	 * status in the characteristic vector tuple; status = {SPORADIC, NORMAL}
 	 */
 	private boolean isSporadic;
-	
+
 	/**
-	 * attribute mentioned in figure 4, line 3 of Chen and Tu 2007;
-	 * attribute = {SPARSE, TRANSITIONAL, DENSE}
+	 * attribute mentioned in figure 4, line 3 of Chen and Tu 2007; attribute =
+	 * {SPARSE, TRANSITIONAL, DENSE}
 	 */
 	private int attribute;
-	
+
 	/**
-	 * time stamp at which the grid's density was last updated (including initial and adjust clusterings)
+	 * time stamp at which the grid's density was last updated (including initial
+	 * and adjust clusterings)
 	 */
 	private int densityTimeStamp;
-	
+
 	/**
-	 * Flag marking whether there was a change in the attribute field
-	 * the last time the grid density was updated.
+	 * Flag marking whether there was a change in the attribute field the last time
+	 * the grid density was updated.
 	 */
 	private boolean attChange;
-	
+
 	/**
 	 * @category Constructor method for the Characteristic Vector of grid g
-	 * @param tg - the last time when g is updated
-	 * @param tm - the last time when g is removed from grid_list
-	 * @param D - the grid density at the last update
-	 * @param label - the class label of the grid
+	 * @param tg     - the last time when g is updated
+	 * @param tm     - the last time when g is removed from grid_list
+	 * @param D      - the grid density at the last update
+	 * @param label  - the class label of the grid
 	 * @param status - SPORADIC (true) or NORMAL (false)
 	 */
-	public CharacteristicVector(int tg, int tm, double D, int label, boolean status, double dl, double dm)
-	{
+	public CharacteristicVector(int tg, int tm, double D, int label, boolean status, double dl, double dm) {
 		this.setUpdateTime(tg);
 		this.setRemoveTime(tm);
 		this.setGridDensity(D, tg);
 		this.setLabel(label);
 		this.setSporadic(status);
-		
+
 		if (this.isSparse(dl))
 			this.attribute = SPARSE;
 		else if (this.isDense(dm))
 			this.attribute = DENSE;
 		else
 			this.attribute = TRANSITIONAL;
-		
+
 		this.attChange = false;
 	}
 
@@ -145,21 +140,20 @@ public void setRemoveTime(int removeTime) {
 	public double getGridDensity() {
 		return this.gridDensity;
 	}
-	
+
 	/**
-	 * @param currTime - the current time to calculate the density for
+	 * @param currTime    - the current time to calculate the density for
 	 * @param decayFactor - the decay factor, lambda, of the algorithm
-	 * 
+	 *
 	 * @return the density of the grid at the current time
 	 */
-	public double getCurrGridDensity(int currTime, double decayFactor)
-	{
-		return Math.pow(decayFactor, (currTime-this.getUpdateTime())) * this.getGridDensity();
+	public double getCurrGridDensity(int currTime, double decayFactor) {
+		return Math.pow(decayFactor, (currTime - this.getUpdateTime())) * this.getGridDensity();
 	}
 
 	/**
 	 * @param gridDensity the density of the grid
-	 * @param timeStamp the time at which the gridDensity is being updated
+	 * @param timeStamp   the time at which the gridDensity is being updated
 	 */
 	public void setGridDensity(double gridDensity, int timeStamp) {
 		this.gridDensity = gridDensity;
@@ -188,8 +182,8 @@ public boolean isSporadic() {
 	}
 
 	/**
-	 * @param isSporadic TRUE if the characteristic vector is to be labelled as sporadic,
-	 * FALSE otherwise
+	 * @param isSporadic TRUE if the characteristic vector is to be labelled as
+	 *                   sporadic, FALSE otherwise
 	 */
 	public void setSporadic(boolean isSporadic) {
 		this.isSporadic = isSporadic;
@@ -204,41 +198,41 @@ public void setDensityTimeStamp(int densityTimeStamp) {
 	}
 
 	/**
-	 * Implements the density update function given in 
-	 * eq 5 (Proposition 3.1) of Chen and Tu 2007.
-	 * 
-	 * @param currTime the data stream's current internal time
+	 * Implements the density update function given in eq 5 (Proposition 3.1) of
+	 * Chen and Tu 2007.
+	 *
+	 * @param currTime    the data stream's current internal time
 	 * @param decayFactor the value of lambda
 	 */
-	public void densityWithNew(int currTime, double decayFactor)
-	{
+	public void densityWithNew(int currTime, double decayFactor) {
 		// Update the density grid's density
 		double densityOfG = this.getGridDensity();
-		
-		//System.out.print("["+decayFactor+"^("+currTime+" - "+this.getDensityTimeStamp()+") * "+densityOfG+"] + 1.0 = ");
-		densityOfG = (Math.pow(decayFactor, (currTime-this.getUpdateTime())) * densityOfG)+1.0;
-		//System.out.println(densityOfG);
-		
+
+		// System.out.print("["+decayFactor+"^("+currTime+" -
+		// "+this.getDensityTimeStamp()+") * "+densityOfG+"] + 1.0 = ");
+		densityOfG = (Math.pow(decayFactor, (currTime - this.getUpdateTime())) * densityOfG) + 1.0;
+		// System.out.println(densityOfG);
+
 		this.setGridDensity(densityOfG, currTime);
 	}
-	
+
 	/**
-	 * Implements the update the density of all grids step given at line 2 of 
-	 * both Fig 3 and Fig 4 of Chen and Tu 2007.
-	 * 
-	 * @param currTime the data stream's current internal time
+	 * Implements the update the density of all grids step given at line 2 of both
+	 * Fig 3 and Fig 4 of Chen and Tu 2007.
+	 *
+	 * @param currTime    the data stream's current internal time
 	 * @param decayFactor the value of lambda
-	 * @param dl the threshold for sparse grids
-	 * @param dm the threshold for dense grids
-	 * @param addRecord TRUE if a record has been added to the density grid, FALSE otherwise
+	 * @param dl          the threshold for sparse grids
+	 * @param dm          the threshold for dense grids
+	 * @param addRecord   TRUE if a record has been added to the density grid, FALSE
+	 *                    otherwise
 	 */
-	public void updateGridDensity(int currTime, double decayFactor, double dl, double dm)
-	{
+	public void updateGridDensity(int currTime, double decayFactor, double dl, double dm) {
 		// record the last attribute
 		int lastAtt = this.getAttribute();
 
 		// Update the density grid's density
-		double densityOfG = (Math.pow(decayFactor, (currTime-this.getDensityTimeStamp())) * this.getGridDensity());
+		double densityOfG = (Math.pow(decayFactor, (currTime - this.getDensityTimeStamp())) * this.getGridDensity());
 
 		this.setGridDensity(densityOfG, currTime);
 
@@ -250,51 +244,49 @@ else if (this.isDense(dm))
 		else
 			this.attribute = TRANSITIONAL;
 
-		// Evaluate whether or not the density grid attribute has changed and set the attChange flag accordingly
+		// Evaluate whether or not the density grid attribute has changed and set the
+		// attChange flag accordingly
 		if (this.getAttribute() == lastAtt)
 			this.attChange = false;
 		else
 			this.attChange = true;
 	}
-	
+
 	/**
-	 * Implements the test for whether a density grid is dense given
-	 * in eq 8 of Chen and Tu 2007.
-	 * 
+	 * Implements the test for whether a density grid is dense given in eq 8 of Chen
+	 * and Tu 2007.
+	 *
 	 * @param dm the threshold for dense grids
 	 */
-	public boolean isDense(double dm)
-	{
+	public boolean isDense(double dm) {
 		if (this.gridDensity >= dm)
 			return true;
 		else
 			return false;
 	}
-	
+
 	/**
-	 * Implements the test for whether a density grid is sparse given
-	 * in eq 9 of Chen and Tu 2007.
-	 * 
+	 * Implements the test for whether a density grid is sparse given in eq 9 of
+	 * Chen and Tu 2007.
+	 *
 	 * @param dl the threshold for sparse grids
 	 */
-	public boolean isSparse(double dl)
-	{
+	public boolean isSparse(double dl) {
 		if (this.gridDensity <= dl)
 			return true;
 		else
 			return false;
 	}
-	
+
 	/**
-	 * Implements the test for whether a density grid is transitional
-	 * given in eq 10 of Chen and Tu 2007.
-	 * 
+	 * Implements the test for whether a density grid is transitional given in eq 10
+	 * of Chen and Tu 2007.
+	 *
 	 * @param dm the threshold for dense grids
 	 * @param dl the threshold for sparse grids
 	 */
-	public boolean isTransitional(double dm, double dl)
-	{
-		if(this.isDense(dm) || this.isSparse(dl))
+	public boolean isTransitional(double dm, double dl) {
+		if (this.isDense(dm) || this.isSparse(dl))
 			return false;
 		else
 			return true;
@@ -309,44 +301,43 @@ public int getAttribute() {
 
 	/**
 	 * @return true if the characteristic vector's attribute changed during the last
-	 * density update, false otherwise.
+	 *         density update, false otherwise.
 	 */
 	public boolean isAttChanged() {
 		return this.attChange;
 	}
-	
+
 	/**
 	 * Overrides Object's toString method.
-	 * 
+	 *
 	 * @return a String listing each value in the characteristic vector tuple
 	 */
 	@Override
-	public String toString()
-	{
+	public String toString() {
 		StringBuilder sb = new StringBuilder(80);
-		
+
 		sb.append("CV / A (tg tm D class status) chgflag: ");
-		
+
 		if (this.getAttribute() == DENSE)
 			sb.append("D ");
 		else if (this.getAttribute() == SPARSE)
 			sb.append("S ");
 		else
 			sb.append("T ");
-		
-		sb.append(this.getUpdateTime()+" ");
-		sb.append(this.getRemoveTime()+" ");
-		sb.append(this.getGridDensity()+" ");
-		sb.append(this.getLabel()+" ");
-		
+
+		sb.append(this.getUpdateTime() + " ");
+		sb.append(this.getRemoveTime() + " ");
+		sb.append(this.getGridDensity() + " ");
+		sb.append(this.getLabel() + " ");
+
 		if (this.isSporadic())
 			sb.append("Sporadic ");
 		else
 			sb.append("Normal ");
-		
+
 		if (this.isAttChanged())
 			sb.append("CHANGED");
-		
+
 		return sb.toString();
 	}
 }
diff --git a/moa/src/main/java/moa/clusterers/dstream/DensityGrid.java b/moa/src/main/java/moa/learners/clusterers/dstream/DensityGrid.java
similarity index 60%
rename from moa/src/main/java/moa/clusterers/dstream/DensityGrid.java
rename to moa/src/main/java/moa/learners/clusterers/dstream/DensityGrid.java
index e3dc90646..d546b2be7 100644
--- a/moa/src/main/java/moa/clusterers/dstream/DensityGrid.java
+++ b/moa/src/main/java/moa/learners/clusterers/dstream/DensityGrid.java
@@ -1,6 +1,6 @@
 /**
  *    DensityGrid.java
- *    
+ *
  *    @author Richard Hugh Moulton  (rmoul026 -[at]- uottawa dot ca)
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,10 +13,10 @@
  *    distributed under the License is distributed on an "AS IS" BASIS,
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
- *    limitations under the License.  
+ *    limitations under the License.
  */
 
-package moa.clusterers.dstream;
+package moa.learners.clusterers.dstream;
 
 import java.util.ArrayList;
 
@@ -26,73 +26,67 @@
 
 /**
  * Density Grids are defined in equation 3 (section 3.1) of Chen and Tu 2007 as:
- * In D-Stream, we partition the d−dimensional space S into density grids. Suppose 
- * for each dimension, its space Si, i =1, ··· ,d is divided into pi partitions as
- * Si = Si,1 U Si,2 U ··· U Si,pi (2)
- * then the data space S is partitioned into N = PRODUCT (i=1..d) pi density grids. 
- * For a density grid g that is composed of S1,j1 ×S2,j2 ···×Sd,jd , ji =1, ...,pi,
- * we denote it as 
- * g =(j1,j2, ··· ,jd). (3)
- * 
- * Citation: Y. Chen and L. Tu, “Density-Based Clustering for Real-Time Stream Data,” in
- * Proceedings of the 13th ACM SIGKDD international conference on Knowledge discovery and
- * data mining, 2007, pp. 133–142.
+ * In D-Stream, we partition the d−dimensional space S into density grids.
+ * Suppose for each dimension, its space Si, i =1, ··· ,d is divided into pi
+ * partitions as Si = Si,1 U Si,2 U ··· U Si,pi (2) then the data space S is
+ * partitioned into N = PRODUCT (i=1..d) pi density grids. For a density grid g
+ * that is composed of S1,j1 ×S2,j2 ···×Sd,jd , ji =1, ...,pi, we denote it as g
+ * =(j1,j2, ··· ,jd). (3)
+ *
+ * Citation: Y. Chen and L. Tu, “Density-Based Clustering for Real-Time Stream
+ * Data,” in Proceedings of the 13th ACM SIGKDD international conference on
+ * Knowledge discovery and data mining, 2007, pp. 133–142.
  */
-public class DensityGrid extends CFCluster
-{
+public class DensityGrid extends CFCluster {
 	private static final long serialVersionUID = 7527683701564950206L;
-	
+
 	/**
-	 * For each dimension, its space Si, i =1, ··· ,d is divided into pi partitions as
-	 * Si = Si,1 U Si,2 U ··· U Si,pi
-	 * A density grid g that is composed of S1,j1 ×S2,j2 ···×Sd,jd , ji =1, ...,pi,
-	 * has coordinates (j1,j2, ··· ,jd).
+	 * For each dimension, its space Si, i =1, ··· ,d is divided into pi partitions
+	 * as Si = Si,1 U Si,2 U ··· U Si,pi A density grid g that is composed of S1,j1
+	 * ×S2,j2 ···×Sd,jd , ji =1, ...,pi, has coordinates (j1,j2, ··· ,jd).
 	 */
 	private int[] coordinates;
-	
+
 	/**
 	 * The value of 'd' for the d-dimensional space S considered by D-Stream.
 	 */
 	private int dimensions;
-	
+
 	/**
-	 * Flag denoting whether this density grid has been inspected during the adjustClustering()
-	 * step of D-Stream.
+	 * Flag denoting whether this density grid has been inspected during the
+	 * adjustClustering() step of D-Stream.
 	 */
 	private boolean isVisited;
-	
+
 	/**
 	 * A constructor method for a density grid
-	 * 
+	 *
 	 * @param c the coordinates of the density grid
 	 */
-	public DensityGrid(int[]c)
-	{
+	public DensityGrid(int[] c) {
 		super(c.length);
 		this.dimensions = c.length;
 		this.coordinates = new int[this.dimensions];
 		N = 1;
 		LS = new double[this.dimensions];
 		SS = new double[this.dimensions];
-		
-		for (int i = 0 ; i < this.dimensions ; i++)
-		{
+
+		for (int i = 0; i < this.dimensions; i++) {
 			int cI = c[i];
 			this.coordinates[i] = cI;
-			LS[i] += (double)cI;
-			SS[i] += Math.pow((double)cI, 2);
+			LS[i] += cI;
+			SS[i] += Math.pow(cI, 2);
 		}
-		
+
 		this.isVisited = false;
 	}
 
 	/**
 	 * A constructor method for a density grid
-	 * 
+	 *
 	 * @param dg the density grid to copy
 	 */
-	public DensityGrid(DensityGrid dg)
-	{
+	public DensityGrid(DensityGrid dg) {
 		super(dg.getDimensions());
 		int[] dgCoord = dg.getCoordinates();
 		this.dimensions = dg.getDimensions();
@@ -100,97 +94,92 @@ public DensityGrid(DensityGrid dg)
 		N = 1;
 		LS = new double[this.dimensions];
 		SS = new double[this.dimensions];
-		
-		for (int i = 0 ; i < this.dimensions ; i++)
-		{
+
+		for (int i = 0; i < this.dimensions; i++) {
 			int cI = dgCoord[i];
 			this.coordinates[i] = cI;
-			LS[i] += (double)cI;
-			SS[i] += Math.pow((double)cI, 2);
+			LS[i] += cI;
+			SS[i] += Math.pow(cI, 2);
 		}
-		
+
 		this.isVisited = false;
 	}
-	
+
 	/**
-	 * Overrides Object's method equals to declare that two DensityGrids are equal iff their
-	 * dimensions are the same and each of their corresponding coordinates are the same.
-	 * 
+	 * Overrides Object's method equals to declare that two DensityGrids are equal
+	 * iff their dimensions are the same and each of their corresponding coordinates
+	 * are the same.
+	 *
 	 * @param o the object being compared for equality
-	 * @return  TRUE if the objects being compared are equal; FALSE otherwise
+	 * @return TRUE if the objects being compared are equal; FALSE otherwise
 	 */
 	@Override
-	public boolean equals(Object o)
-	{
-		if(o == null)
+	public boolean equals(Object o) {
+		if (o == null)
 			return false;
-		if(o.getClass() != DensityGrid.class)
+		if (o.getClass() != DensityGrid.class)
 			return false;
-		
+
 		DensityGrid dg = (DensityGrid) o;
-		
-		if(dg.getDimensions() != dimensions)
+
+		if (dg.getDimensions() != dimensions)
 			return false;
-		
+
 		int[] dgCoord = dg.getCoordinates();
-		for(int i = 0 ; i < dimensions ; i++)
-		{
-			if(dgCoord[i] != coordinates[i])
+		for (int i = 0; i < dimensions; i++) {
+			if (dgCoord[i] != coordinates[i])
 				return false;
 		}
-		
-		return true;		
+
+		return true;
 	}
-	
+
 	/**
-	 * Overrides Object's method hashCode to generate a hashCode for DensityGrids based on
-	 * their coordinates.
+	 * Overrides Object's method hashCode to generate a hashCode for DensityGrids
+	 * based on their coordinates.
 	 *
 	 * @return hc the Object's hash code
 	 */
 	@Override
-	public int hashCode()
-	{
-		//int[] primes = {31, 37, 41, 43, 47, 53, 59};
+	public int hashCode() {
+		// int[] primes = {31, 37, 41, 43, 47, 53, 59};
 		int hc = 1;
-		
-		for (int i = 0 ; i < this.dimensions ; i++)
-		{
+
+		for (int i = 0; i < this.dimensions; i++) {
 			hc = (hc * 31) + this.coordinates[i];
 		}
-		
+
 		return hc;
 	}
-	
+
 	/**
-	 * Generates an Array List of neighbours for this density grid by varying each coordinate
-	 * by one in either direction. Does not test whether the generated neighbours are valid as 
-	 * DensityGrid is not aware of the number of partitions in each dimension.
-	 * 
+	 * Generates an Array List of neighbours for this density grid by varying each
+	 * coordinate by one in either direction. Does not test whether the generated
+	 * neighbours are valid as DensityGrid is not aware of the number of partitions
+	 * in each dimension.
+	 *
 	 * @return an Array List of neighbours for this density grid
 	 */
-	public ArrayList<DensityGrid> getNeighbours()
-	{
-		ArrayList<DensityGrid> neighbours = new ArrayList<DensityGrid>();
+	public ArrayList<DensityGrid> getNeighbours() {
+		ArrayList<DensityGrid> neighbours = new ArrayList<>();
 		DensityGrid h;
 		int[] hCoord = this.getCoordinates();
-		
-		for (int i = 0 ; i < this.dimensions ; i++)
-		{
-			hCoord[i] = hCoord[i]-1;
+
+		for (int i = 0; i < this.dimensions; i++) {
+			hCoord[i] = hCoord[i] - 1;
 			h = new DensityGrid(hCoord);
 			neighbours.add(h);
-			
-			hCoord[i] = hCoord[i]+2;
+
+			hCoord[i] = hCoord[i] + 2;
 			h = new DensityGrid(hCoord);
 			neighbours.add(h);
-			
-			hCoord[i] = hCoord[i]-1;
+
+			hCoord[i] = hCoord[i] - 1;
 		}
-		
+
 		return neighbours;
 	}
-	
+
 	/**
 	 * @return coordinates the coordinates of the density grid
 	 */
@@ -209,23 +198,21 @@ public int getDimensions() {
 	 * @return a String listing each coordinate of the density grid
 	 */
 	@Override
-	public String toString()
-	{
-		StringBuilder sb = new StringBuilder(15 + (2*this.dimensions));
+	public String toString() {
+		StringBuilder sb = new StringBuilder(15 + (2 * this.dimensions));
 		sb.append("DG:");
-		for (int i = 0 ; i < this.dimensions ; i++)
-		{
-			sb.append(" "+this.coordinates[i]);
+		for (int i = 0; i < this.dimensions; i++) {
+			sb.append(" " + this.coordinates[i]);
 		}
-		
-		sb.append(" HC:"+this.hashCode());
-		
+
+		sb.append(" HC:" + this.hashCode());
+
 		return sb.toString();
 	}
 
 	/**
 	 * Returns a reference to the DensityGrid.
-	 * 
+	 *
 	 * @return this density grid.
 	 */
 	@Override
@@ -234,25 +221,26 @@ public CFCluster getCF() {
 	}
 
 	/**
-	 * Provides the probability of the argument instance belonging to the density grid in question.
-	 * 
-	 * @return 1.0 if the instance equals the density grid's coordinates; 0.0 otherwise.
+	 * Provides the probability of the argument instance belonging to the density
+	 * grid in question.
+	 *
+	 * @return 1.0 if the instance equals the density grid's coordinates; 0.0
+	 *         otherwise.
 	 */
 	@Override
 	public double getInclusionProbability(Instance instance) {
-		for (int i = 0 ; i < this.dimensions ; i++)
-		{
+		for (int i = 0; i < this.dimensions; i++) {
 			if ((int) instance.value(i) != this.coordinates[i])
 				return 0.0;
 		}
-		
+
 		return 1.0;
 	}
 
 	/**
 	 * Provides the radius of a density grid.
-	 * 
-	 * @return	1.0, approximating a unit hypercube of dimension d.
+	 *
+	 * @return 1.0, approximating a unit hypercube of dimension d.
 	 */
 	@Override
 	public double getRadius() {
diff --git a/moa/src/main/java/moa/clusterers/dstream/Dstream.java b/moa/src/main/java/moa/learners/clusterers/dstream/Dstream.java
similarity index 54%
rename from moa/src/main/java/moa/clusterers/dstream/Dstream.java
rename to moa/src/main/java/moa/learners/clusterers/dstream/Dstream.java
index c7cf3b017..8138613d8 100644
--- a/moa/src/main/java/moa/clusterers/dstream/Dstream.java
+++ b/moa/src/main/java/moa/learners/clusterers/dstream/Dstream.java
@@ -1,6 +1,6 @@
 /*
  *    Dstream.java
- *    
+ *
  *    @author Richard Hugh Moulton  (rmoul026 -[at]- uottawa dot ca)
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,10 +13,10 @@
  *    distributed under the License is distributed on an "AS IS" BASIS,
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
- *    limitations under the License.  
+ *    limitations under the License.
  */
 
-package moa.clusterers.dstream;
+package moa.learners.clusterers.dstream;
 
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -29,12 +29,13 @@
 
 import moa.cluster.CFCluster;
 import moa.cluster.Clustering;
-import moa.clusterers.AbstractClusterer;
 import moa.core.Measurement;
+import moa.learners.clusterers.AbstractClusterer;
 
-/** Citation: Y. Chen and L. Tu, “Density-Based Clustering for Real-Time Stream Data,” in
- *  Proceedings of the 13th ACM SIGKDD international conference on Knowledge discovery and
- *  data mining, 2007, pp. 133–142.
+/**
+ * Citation: Y. Chen and L. Tu, “Density-Based Clustering for Real-Time Stream
+ * Data,” in Proceedings of the 13th ACM SIGKDD international conference on
+ * Knowledge discovery and data mining, 2007, pp. 133–142.
  */
 public class Dstream extends AbstractClusterer {
 
@@ -44,121 +45,122 @@ public class Dstream extends AbstractClusterer {
 	private static final int TRANSITIONAL = 1;
 	private static final int DENSE = 2;
 
-	public FloatOption decayFactorOption = new FloatOption("decayFactor",
-			'd', "The decay factor, lambda, in (0,1)", 0.998, 0.001, 0.999);
+	public FloatOption decayFactorOption = new FloatOption("decayFactor", 'd', "The decay factor, lambda, in (0,1)",
+			0.998, 0.001, 0.999);
 
-	public FloatOption cmOption = new FloatOption("Cm", 'm', "Controls the "
-			+ "threshold for dense grids, > 1", 3.0, 1.001, Double.MAX_VALUE);
+	public FloatOption cmOption = new FloatOption("Cm", 'm', "Controls the " + "threshold for dense grids, > 1", 3.0,
+			1.001, Double.MAX_VALUE);
 
-	public FloatOption clOption = new FloatOption("Cl", 'l', "Controls the "
-			+ "threshold for sparse grids, in (0,1)", 0.8, 0.001, 0.999);
+	public FloatOption clOption = new FloatOption("Cl", 'l', "Controls the " + "threshold for sparse grids, in (0,1)",
+			0.8, 0.001, 0.999);
 
-	public FloatOption betaOption = new FloatOption("Beta", 'b', "Adjusts the "
-			+ "window of protection for renaming previously deleted grids as "
-			+ "sporadic, > 0", 0.3, 0.001, Double.MAX_VALUE);
+	public FloatOption betaOption = new FloatOption("Beta", 'b',
+			"Adjusts the " + "window of protection for renaming previously deleted grids as " + "sporadic, > 0", 0.3,
+			0.001, Double.MAX_VALUE);
 
 	/**
 	 * The data stream's current internal time. Starts at 0.
 	 */
-	private int currTime; 
-	
+	private int currTime;
+
 	/**
 	 * User defined parameter: Time gap between calls to the offline component
 	 */
 	private int gap;
-	
+
 	/**
 	 * User defined parameter, represented as lambda in Chen and Tu 2007
 	 */
 	private double decayFactor;
-	
+
 	/**
 	 * User defined parameter: Controls the threshold for dense grids
 	 */
 	private double cm;
-	
+
 	/**
 	 * User defined parameter: Controls the threshold for sparse grids
 	 */
 	private double cl;
-	
+
 	/**
-	 * User defined parameter: Adjusts the window of protection for renaming 
+	 * User defined parameter: Adjusts the window of protection for renaming
 	 * previously deleted grids as being sporadic
 	 */
 	private double beta;
-	
+
 	/**
-	 * Density threshold for dense grids; controlled by cm; given in eq 8 of Chen and Tu 2007
-	 * 
+	 * Density threshold for dense grids; controlled by cm; given in eq 8 of Chen
+	 * and Tu 2007
+	 *
 	 * @see cm
 	 */
 	private double dm;
-	
+
 	/**
-	 * Density threshold for sparse grids; controlled by cl; given in eq 9 of Chen and Tu 2007
-	 * 
+	 * Density threshold for sparse grids; controlled by cl; given in eq 9 of Chen
+	 * and Tu 2007
+	 *
 	 * @see cl
 	 */
 	private double dl;
-	
+
 	/**
-	 * The number of dimensions in the data stream; defined in section 3.1 of Chen and Tu 2007
+	 * The number of dimensions in the data stream; defined in section 3.1 of Chen
+	 * and Tu 2007
 	 */
 	private int d;
-	
+
 	/**
 	 * The number of density grids; defined after eq 2 in Chen and Tu 2007
 	 */
 	private int N;
-	
+
 	/**
 	 * True if initialization of D-Stream is complete, false otherwise
 	 */
 	private boolean initialized;
-	
+
 	/**
-	 * A list of all density grids which are being monitored;
-	 * given in figure 1 of Chen and Tu 2007
+	 * A list of all density grids which are being monitored; given in figure 1 of
+	 * Chen and Tu 2007
 	 */
-	private HashMap<DensityGrid,CharacteristicVector> grid_list;
-	
+	private HashMap<DensityGrid, CharacteristicVector> grid_list;
+
 	/**
-	 * A list of all density grids which have been deleted;
-	 * allows the recording of tm - the last time when the 
-	 * grid is removed from grid list as a sporadic grid (if ever).
+	 * A list of all density grids which have been deleted; allows the recording of
+	 * tm - the last time when the grid is removed from grid list as a sporadic grid
+	 * (if ever).
 	 */
-	private HashMap<DensityGrid,Integer> deleted_grids;
-	
-	
+	private HashMap<DensityGrid, Integer> deleted_grids;
+
 	/**
-	 * A list of all Grid Clusters, which are defined in 
-	 * Definition 3.6 of Chen and Tu 2007
+	 * A list of all Grid Clusters, which are defined in Definition 3.6 of Chen and
+	 * Tu 2007
 	 */
 	private ArrayList<GridCluster> cluster_list;
-	
+
 	/**
 	 * A list of grid clusters used when reclustering an existing cluster.
 	 */
 	private ArrayList<GridCluster> newClusterList;
-	
+
 	/**
 	 * The minimum value seen for a numerical dimension; used to calculate N
-	 * 
+	 *
 	 * @see N
 	 */
-	private int[]minVals;
-	
+	private int[] minVals;
+
 	/**
 	 * The maximum value seen for a numerical dimension; used to calculate N
-	 * 
+	 *
 	 * @see N
 	 */
-	private int[]maxVals;
+	private int[] maxVals;
 
 	/**
-	 *  @see moa.clusterers.Clusterer#isRandomizable()
-	 * D-Stream is not randomizable.
+	 * @see moa.learners.clusterers.Clusterer#isRandomizable() D-Stream is not randomizable.
 	 */
 	@Override
 	public boolean isRandomizable() {
@@ -166,8 +168,8 @@ public boolean isRandomizable() {
 	}
 
 	/**
-	 * @see moa.clusterers.Clusterer#getVotesForInstance(com.yahoo.labs.samoa.instances.Instance)
-	 * D-Stream does not vote on instances.
+	 * @see moa.learners.clusterers.Clusterer#getVotesForInstance(com.yahoo.labs.samoa.instances.Instance)
+	 *      D-Stream does not vote on instances.
 	 */
 	@Override
 	public Prediction getPredictionForInstance(Instance inst) {
@@ -175,38 +177,37 @@ public Prediction getPredictionForInstance(Instance inst) {
 	}
 
 	/**
-	 *  @see moa.clusterers.Clusterer#getClusteringResult()
+	 * @see moa.learners.clusterers.Clusterer#getClusteringResult()
 	 */
 	@Override
 	public Clustering getClusteringResult() {
 		Clustering c = new Clustering();
-		for(GridCluster gc : cluster_list)
-		{
+		for (GridCluster gc : cluster_list) {
 			c.add(gc);
 		}
 		return c;
 	}
 
 	/**
-	 * @see moa.clusterers.AbstractClusterer#resetLearningImpl()
+	 * @see moa.learners.clusterers.AbstractClusterer#resetLearningImpl()
 	 */
 	@Override
 	public void resetLearningImpl() {
-		//System.out.println("Dstream . resetLearningImpl");
+		// System.out.println("Dstream . resetLearningImpl");
 		this.setCurrTime(0);
-		//System.out.println("Current time set...");
-		
+		// System.out.println("Current time set...");
+
 		this.decayFactor = decayFactorOption.getValue();
 		this.cm = cmOption.getValue();
 		this.cl = clOption.getValue();
 		this.beta = betaOption.getValue();
-		//System.out.println("Option values set...");
+		// System.out.println("Option values set...");
 
 		this.initialized = false;
-		this.grid_list = new HashMap<DensityGrid, CharacteristicVector>();
-		this.deleted_grids = new HashMap<DensityGrid, Integer>();
-		this.cluster_list = new ArrayList<GridCluster>();
-		//System.out.println("Data structures initialized...");
+		this.grid_list = new HashMap<>();
+		this.deleted_grids = new HashMap<>();
+		this.cluster_list = new ArrayList<>();
+		// System.out.println("Data structures initialized...");
 
 		this.gap = 1;
 		this.dm = -1.0;
@@ -215,176 +216,160 @@ public void resetLearningImpl() {
 		this.N = -1;
 		this.minVals = null;
 		this.maxVals = null;
-		//System.out.println("Dependent values initialized...\n");
-		//printDStreamState();
+		// System.out.println("Dependent values initialized...\n");
+		// printDStreamState();
 	}
 
 	/**
-	 * @see moa.clusterers.AbstractClusterer#trainOnInstanceImpl(com.yahoo.labs.samoa.instances.Instance)
-	 * 
-	 * trainOnInstanceImpl implements the procedure given in Figure 1 of Chen and Tu 2007
+	 * @see moa.learners.clusterers.AbstractClusterer#trainOnInstanceImpl(com.yahoo.labs.samoa.instances.Instance)
+	 *
+	 *      trainOnInstanceImpl implements the procedure given in Figure 1 of Chen
+	 *      and Tu 2007
 	 */
 	@Override
 	public void trainOnInstanceImpl(Instance inst) {
-		
-		//System.out.print("Dstream.trainOnInstanceImpl (");
-		int[]g;
+
+		// System.out.print("Dstream.trainOnInstanceImpl (");
+		int[] g;
 		DensityGrid dg;
 		CharacteristicVector cv;
-		boolean recalculateN = false;	// flag indicating whether N needs to be recalculated after this instance
+		boolean recalculateN = false; // flag indicating whether N needs to be recalculated after this instance
 
 		// 1. Read record x = (x1,x2,...,xd)
-		//printInst(inst);
-		//System.out.println(") time "+this.getCurrTime());
+		// printInst(inst);
+		// System.out.println(") time "+this.getCurrTime());
 		// Passed Instance inst
-		if (!this.initialized)
-		{
-			//System.out.println("Not yet initialized");
+		if (!this.initialized) {
+			// System.out.println("Not yet initialized");
 			this.d = inst.numAttributes();
-			//System.out.println("d = "+this.d);
+			// System.out.println("d = "+this.d);
 			this.minVals = new int[this.d];
 			this.maxVals = new int[this.d];
-			//System.out.println("...data initialized");
-			
-			for(int i = 0 ; i < this.d ; i++)
-			{
-				//System.out.print(i+" ");
-				if (inst.attribute(i).isNumeric())
-				{
+			// System.out.println("...data initialized");
+
+			for (int i = 0; i < this.d; i++) {
+				// System.out.print(i+" ");
+				if (inst.attribute(i).isNumeric()) {
 					maxVals[i] = (int) inst.value(i);
 					minVals[i] = (int) inst.value(i);
 				}
 			}
-			//System.out.println("...arrays initialized");
+			// System.out.println("...arrays initialized");
 			recalculateN = true;
 			this.initialized = true;
-			//System.out.println("...boolean values initialized");
-			//System.out.print("Grid list is: ");
-			//printGridList();
-		}		
+			// System.out.println("...boolean values initialized");
+			// System.out.print("Grid list is: ");
+			// printGridList();
+		}
 
 		// 2. Determine the density grid g that contains x
-		//System.out.print(" & Step 2 ");
+		// System.out.print(" & Step 2 ");
 		g = new int[this.d];
 
-		for (int i = 0 ; i < this.d ; i++)
-		{
-			if (inst.attribute(i).isNumeric())
-			{
+		for (int i = 0; i < this.d; i++) {
+			if (inst.attribute(i).isNumeric()) {
 				g[i] = (int) inst.value(i);
-				if (g[i] > maxVals[i])
-				{
+				if (g[i] > maxVals[i]) {
 					maxVals[i] = g[i];
 					recalculateN = true;
-				}
-				else if (g[i] < minVals[i])
-				{
+				} else if (g[i] < minVals[i]) {
 					minVals[i] = g[i];
 					recalculateN = true;
 				}
-			}
-			else
-			{
+			} else {
 				g[i] = (int) inst.value(i);
 			}
 		}
 
-		if (recalculateN)
-		{
-			//System.out.print(" recalculateN:");
+		if (recalculateN) {
+			// System.out.print(" recalculateN:");
 			int n = 1;
-			for (int i = 0 ; i < this.d ; i++)
-			{
-				//System.out.print(" "+n);
+			for (int i = 0; i < this.d; i++) {
+				// System.out.print(" "+n);
 				if (inst.attribute(i).isNominal())
 					n = n * inst.attribute(i).numValues();
 				else
-					n = n * (3+maxVals[i]-minVals[i]);
+					n = n * (3 + maxVals[i] - minVals[i]);
 			}
-			//System.out.print(" "+n);
+			// System.out.print(" "+n);
 			this.N = n;
-			this.dl = this.cl/(this.N * (1.0 - this.decayFactor));
-			this.dm = this.cm/(this.N * (1.0 - this.decayFactor));
-			//System.out.print(" dl = " + this.dl + ", dm = " + this.dm);
-			
-			//Calculate the value for gap using the method defined in eq 26 of Chen and Tu 2007 
-			double optionA = this.cl/this.cm;
-			double optionB = ((double)this.N-this.cm)/((double)this.N-this.cl);
-			gap = (int)Math.floor(Math.log(Math.max(optionA, optionB))/Math.log(this.getDecayFactor()));
-			// Ensure that gap is not zero (i.e. if the procedure to calculate gap rounds down to zero, then set gap to 1 and adjust clustering every instance)
-			if(gap == 0)
-			{
+			this.dl = this.cl / (this.N * (1.0 - this.decayFactor));
+			this.dm = this.cm / (this.N * (1.0 - this.decayFactor));
+			// System.out.print(" dl = " + this.dl + ", dm = " + this.dm);
+
+			// Calculate the value for gap using the method defined in eq 26 of Chen and Tu
+			// 2007
+			double optionA = this.cl / this.cm;
+			double optionB = (this.N - this.cm) / (this.N - this.cl);
+			gap = (int) Math.floor(Math.log(Math.max(optionA, optionB)) / Math.log(this.getDecayFactor()));
+			// Ensure that gap is not zero (i.e. if the procedure to calculate gap rounds
+			// down to zero, then set gap to 1 and adjust clustering every instance)
+			if (gap == 0) {
 				gap = 1;
 			}
-			//System.out.println(" A is "+optionA+", B is "+optionB+" and gap = "+gap);
+			// System.out.println(" A is "+optionA+", B is "+optionB+" and gap = "+gap);
 		}
 
 		dg = new DensityGrid(g);
-		//System.out.println(dg.toString());
-		
+		// System.out.println(dg.toString());
+
 		// 3. If (g not in grid_list) insert dg to grid_list
-		//System.out.println(" & Step 3 or 4");
-		
-		if(!this.grid_list.containsKey(dg))
-		{
-			//System.out.print("3 - dg wasn't in grid_list!");
-			if(this.deleted_grids.containsKey(dg))
-			{
-				//System.out.print(" but it was in deleted_grids!");
-				cv = new CharacteristicVector(this.getCurrTime(), this.deleted_grids.get(dg).intValue(), 1.0, -1, false, this.getDL(), this.getDM());
+		// System.out.println(" & Step 3 or 4");
+
+		if (!this.grid_list.containsKey(dg)) {
+			// System.out.print("3 - dg wasn't in grid_list!");
+			if (this.deleted_grids.containsKey(dg)) {
+				// System.out.print(" but it was in deleted_grids!");
+				cv = new CharacteristicVector(this.getCurrTime(), this.deleted_grids.get(dg), 1.0, -1, false,
+						this.getDL(), this.getDM());
 				this.deleted_grids.remove(dg);
-			}
-			else
+			} else
 				cv = new CharacteristicVector(this.getCurrTime(), -1, 1.0, -1, false, this.getDL(), this.getDM());
-			
+
 			this.grid_list.put(dg, cv);
-			//System.out.print(" "+dg.toString()+" "+cv.toString());
-			//System.out.println(" The size of grid_list is now "+grid_list.size());
+			// System.out.print(" "+dg.toString()+" "+cv.toString());
+			// System.out.println(" The size of grid_list is now "+grid_list.size());
 		}
 		// 4. Update the characteristic vector of dg
-		else
-		{
-			//System.out.print("4 - dg was in grid_list!");
+		else {
+			// System.out.print("4 - dg was in grid_list!");
 			cv = this.grid_list.get(dg);
-				
+
 			cv.densityWithNew(this.getCurrTime(), this.getDecayFactor());
-				
+
 			cv.setUpdateTime(this.getCurrTime());
-		
-			//System.out.println(" "+dg.toString()+" "+cv.toString());
-		
+
+			// System.out.println(" "+dg.toString()+" "+cv.toString());
+
 			grid_list.put(dg, cv);
 		}
 
 		// 5. If tc == gap, then initial clustering
 		// and
 		// 6. If tc mod gap == 0, then:
-		//    a. Detect and remove sporadic grids from grid_list
-		//    b. Adjust clustering
-		//System.out.println("\nCurrent Time is " + this.getCurrTime() + " and gap is " + this.gap);
-		if (this.getCurrTime() != 0 && this.getCurrTime() % gap == 0)
-		{
-			if (this.getCurrTime() == gap)
-			{
-				//System.out.print(" & Step 5 x6x");
+		// a. Detect and remove sporadic grids from grid_list
+		// b. Adjust clustering
+		// System.out.println("\nCurrent Time is " + this.getCurrTime() + " and gap is "
+		// + this.gap);
+		if (this.getCurrTime() != 0 && this.getCurrTime() % gap == 0) {
+			if (this.getCurrTime() == gap) {
+				// System.out.print(" & Step 5 x6x");
 				this.initialClustering();
-			}
-			else
-			{
-				//System.out.print(" & Step x5x 6");
+			} else {
+				// System.out.print(" & Step x5x 6");
 				this.removeSporadic();
 				this.adjustClustering();
 			}
 		}
 
 		// 7. Increment tc
-		//System.out.println(" & Step 7");
+		// System.out.println(" & Step 7");
 		this.incCurrTime();
 
 	}
 
 	/**
-	 * @see moa.clusterers.AbstractClusterer#getModelMeasurementsImpl()
+	 * @see moa.learners.clusterers.AbstractClusterer#getModelMeasurementsImpl()
 	 */
 	@Override
 	protected Measurement[] getModelMeasurementsImpl() {
@@ -392,7 +377,8 @@ protected Measurement[] getModelMeasurementsImpl() {
 	}
 
 	/**
-	 * @see moa.clusterers.AbstractClusterer#getModelDescription(java.lang.StringBuilder, int)
+	 * @see moa.learners.clusterers.AbstractClusterer#getModelDescription(java.lang.StringBuilder,
+	 *      int)
 	 */
 	@Override
 	public void getModelDescription(StringBuilder out, int indent) {
@@ -403,62 +389,59 @@ public void getModelDescription(StringBuilder out, int indent) {
 	 * Implements the procedure given in Figure 3 of Chen and Tu 2007
 	 */
 	private void initialClustering() {
-		//System.out.println("INITIAL CLUSTERING CALLED");
-		//printDStreamState();
+		// System.out.println("INITIAL CLUSTERING CALLED");
+		// printDStreamState();
 		// 1. Update the density of all grids in grid_list
 
 		updateGridListDensity();
-		//printGridList();
-				
+		// printGridList();
+
 		// 2. Assign each dense grid to a distinct cluster
 		// and
-		// 3. Label all other grids as NO_CLASS	
+		// 3. Label all other grids as NO_CLASS
 		Iterator<Map.Entry<DensityGrid, CharacteristicVector>> glIter = this.grid_list.entrySet().iterator();
-		HashMap<DensityGrid, CharacteristicVector> newGL = new HashMap<DensityGrid, CharacteristicVector>();
-		
-		while(glIter.hasNext())
-		{
+		HashMap<DensityGrid, CharacteristicVector> newGL = new HashMap<>();
+
+		while (glIter.hasNext()) {
 			Map.Entry<DensityGrid, CharacteristicVector> grid = glIter.next();
 			DensityGrid dg = grid.getKey();
 			CharacteristicVector cvOfG = grid.getValue();
 
-			//System.out.print(dg.toString());
-			if(cvOfG.getAttribute() == DENSE)
-			{
+			// System.out.print(dg.toString());
+			if (cvOfG.getAttribute() == DENSE) {
 				int gridClass = this.cluster_list.size();
 				cvOfG.setLabel(gridClass);
-				GridCluster gc = new GridCluster ((CFCluster)dg, new ArrayList<CFCluster>(), gridClass);
+				GridCluster gc = new GridCluster(dg, new ArrayList<CFCluster>(), gridClass);
 				gc.addGrid(dg);
 				this.cluster_list.add(gc);
-				//System.out.print(" was dense (class "+gridClass+")");
-			}
-			else
+				// System.out.print(" was dense (class "+gridClass+")");
+			} else
 				cvOfG.setLabel(NO_CLASS);
 
-			//System.out.println();
+			// System.out.println();
 			newGL.put(dg, cvOfG);
 		}
 
 		this.grid_list = newGL;
-		//printGridClusters();
-		
+		// printGridClusters();
+
 		// 4. Make changes to grid labels by doing:
-		//    a. For each cluster c
-		//    b. For each outside grid g of c
-		//    c. For each neighbouring grid h of g
-		//    d. If h belongs to c', label c and c' with 
-		//       the label of the largest cluster
-		//    e. Else if h is transitional, assign it to c
-		//    f. While changes can be made
+		// a. For each cluster c
+		// b. For each outside grid g of c
+		// c. For each neighbouring grid h of g
+		// d. If h belongs to c', label c and c' with
+		// the label of the largest cluster
+		// e. Else if h is transitional, assign it to c
+		// f. While changes can be made
 
 		boolean changesMade;
 
-		do{	
+		do {
 			changesMade = adjustLabels();
-		}while(changesMade);	// while changes are being made
-		
-		//printGridList();
-		//printGridClusters();
+		} while (changesMade); // while changes are being made
+
+		// printGridList();
+		// printGridClusters();
 	}
 
 	/**
@@ -467,58 +450,55 @@ private void initialClustering() {
 	 * <li>For each cluster c</li>
 	 * <li>For each outside grid g of c</li>
 	 * <li>For each neighbouring grid h of g</li>
-	 * <li>If h belongs to c', label c and c' with the label of the largest cluster</li>
+	 * <li>If h belongs to c', label c and c' with the label of the largest
+	 * cluster</li>
 	 * <li>Else if h is transitional, assign it to c</li>
 	 * </ol>
-	 * 
+	 *
 	 * @return TRUE if a change was made to any cluster's labels, FALSE otherwise
 	 */
-	private boolean adjustLabels()
-	{
+	private boolean adjustLabels() {
 		Iterator<GridCluster> gridClusIter = this.cluster_list.iterator();
 
 		// a. For each cluster c
-		while (gridClusIter.hasNext())
-		{
+		while (gridClusIter.hasNext()) {
 			GridCluster c = gridClusIter.next();
-			//System.out.print("Adjusting from cluster "+c.getClusterLabel()+", standby...");
+			// System.out.print("Adjusting from cluster "+c.getClusterLabel()+",
+			// standby...");
 
 			// b. for each grid, dg, of c
-			for (Map.Entry<DensityGrid, Boolean> grid : c.getGrids().entrySet())
-			{
+			for (Map.Entry<DensityGrid, Boolean> grid : c.getGrids().entrySet()) {
 				DensityGrid dg = grid.getKey();
 				Boolean inside = grid.getValue();
-				//System.out.print(" Inspecting density grid, dg:"+dg.toString()+", standby...");
-				
+				// System.out.print(" Inspecting density grid, dg:"+dg.toString()+",
+				// standby...");
+
 				// b. for each OUTSIDE grid, dg, of c
-				if (!inside)
-				{
-					//System.out.println(" Density grid dg is outside!");
+				if (!inside) {
+					// System.out.println(" Density grid dg is outside!");
 					// c. for each neighbouring grid, dgprime, of dg
 					Iterator<DensityGrid> dgNeighbourhood = dg.getNeighbours().iterator();
-					
-					while(dgNeighbourhood.hasNext())
-					{
+
+					while (dgNeighbourhood.hasNext()) {
 						DensityGrid dgprime = dgNeighbourhood.next();
-						//System.out.print("Inspecting neighbour, dgprime:"+dgprime.toString()+", standby...");
-						
-						if(this.grid_list.containsKey(dgprime))
-						{
+						// System.out.print("Inspecting neighbour, dgprime:"+dgprime.toString()+",
+						// standby...");
+
+						if (this.grid_list.containsKey(dgprime)) {
 							CharacteristicVector cv1 = this.grid_list.get(dg);
 							CharacteristicVector cv2 = this.grid_list.get(dgprime);
-							//System.out.print(" 1: "+cv1.toString()+", 2: "+cv2.toString());
+							// System.out.print(" 1: "+cv1.toString()+", 2: "+cv2.toString());
 							int class1 = cv1.getLabel();
 							int class2 = cv2.getLabel();
-							//System.out.println(" // classes "+class1+" and "+class2+".");
+							// System.out.println(" // classes "+class1+" and "+class2+".");
 
 							// ...and if dgprime isn't already in the same cluster as dg...
-							if (class1 != class2)
-							{
+							if (class1 != class2) {
 								// If dgprime is in cluster c', merge c and c' into the larger of the two
-								if (class2 != NO_CLASS)
-								{
-									//System.out.println("C is "+class1+" and C' is "+class2+".");
-									if (this.cluster_list.get(class1).getWeight() < this.cluster_list.get(class2).getWeight())
+								if (class2 != NO_CLASS) {
+									// System.out.println("C is "+class1+" and C' is "+class2+".");
+									if (this.cluster_list.get(class1).getWeight() < this.cluster_list.get(class2)
+											.getWeight())
 										mergeClusters(class1, class2);
 									else
 										mergeClusters(class2, class1);
@@ -527,9 +507,8 @@ private boolean adjustLabels()
 
 								}
 								// If dgprime is transitional and outside of c, assign it to c
-								else if (cv2.isTransitional(dm, dl))
-								{
-									//System.out.println("h is transitional and is assigned to cluster "+class1);
+								else if (cv2.isTransitional(dm, dl)) {
+									// System.out.println("h is transitional and is assigned to cluster "+class1);
 									cv2.setLabel(class1);
 									c.addGrid(dgprime);
 									this.cluster_list.set(class1, c);
@@ -544,224 +523,211 @@ else if (cv2.isTransitional(dm, dl))
 		}
 		return false;
 	}
-	
+
 	/**
 	 * Performs the periodic adjustment of clusters every 'gap' timesteps.
 	 * Implements the procedure given in Figure 4 of Chen and Tu 2007
-	 * 
-	 * @see moa.clusterers.dstream.Dstream.gap
+	 *
+	 * @see moa.learners.clusterers.dstream.Dstream.gap
 	 */
 	private void adjustClustering() {
-		//System.out.println("ADJUST CLUSTERING CALLED (time"+this.getCurrTime()+")");
-		//printDStreamState();
-		//printDStreamState();
-		//printGridClusters();
+		// System.out.println("ADJUST CLUSTERING CALLED (time"+this.getCurrTime()+")");
+		// printDStreamState();
+		// printDStreamState();
+		// printGridClusters();
 		// 1. Update the density of all grids in grid_list
 
 		updateGridListDensity();
-		//printGridList();
-		
+		// printGridList();
+
 		// 2. For each grid dg whose attribute is changed since last call
-		//    a. If dg is sparse
-		//    b. If dg is dense
-		//    c. If dg is transitional
+		// a. If dg is sparse
+		// b. If dg is dense
+		// c. If dg is transitional
 		boolean changesMade = false;
-		
-		do{
-			changesMade=inspectChangedGrids();
-		}while(changesMade);
-
-		//printGridList();
-		//System.out.print("Time: "+this.getCurrTime()+" and ");
-		//printGridClusters();
-		//System.out.println("Wait...");
-		//try {
-		//System.in.read();
-		//} catch (IOException e) {
-		//e.printStackTrace();
-		//}
-		 
+
+		do {
+			changesMade = inspectChangedGrids();
+		} while (changesMade);
+
+		// printGridList();
+		// System.out.print("Time: "+this.getCurrTime()+" and ");
+		// printGridClusters();
+		// System.out.println("Wait...");
+		// try {
+		// System.in.read();
+		// } catch (IOException e) {
+		// e.printStackTrace();
+		// }
+
 	}
 
 	/**
-	 * Inspects each density grid in grid_list whose attribute has changed since the last 
-	 * call to adjustClustering. Implements lines 3/4/7/19 of the procedure given in Figure 
-	 * 4 of Chen and Tu 2007.
-	 * 
+	 * Inspects each density grid in grid_list whose attribute has changed since the
+	 * last call to adjustClustering. Implements lines 3/4/7/19 of the procedure
+	 * given in Figure 4 of Chen and Tu 2007.
+	 *
 	 * @return TRUE if any grids are updated; FALSE otherwise.
 	 */
-	private boolean inspectChangedGrids()
-	{
-		HashMap<DensityGrid, CharacteristicVector> glNew = new HashMap<DensityGrid, CharacteristicVector>();
+	private boolean inspectChangedGrids() {
+		HashMap<DensityGrid, CharacteristicVector> glNew = new HashMap<>();
 		Iterator<Map.Entry<DensityGrid, CharacteristicVector>> gridIter = this.grid_list.entrySet().iterator();
-		
-		while (gridIter.hasNext() && glNew.isEmpty())
-		{
+
+		while (gridIter.hasNext() && glNew.isEmpty()) {
 			Map.Entry<DensityGrid, CharacteristicVector> grid = gridIter.next();
 			DensityGrid dg = grid.getKey();
 			CharacteristicVector cv = grid.getValue();
 			int dgClass = cv.getLabel();
-			
-			if(cv.isAttChanged() && !dg.isVisited())
-			{
+
+			if (cv.isAttChanged() && !dg.isVisited()) {
 				dg.setVisited(true);
 				glNew.put(dg, cv);
-				//System.out.print(dg.toString()+" is changed and now ");
+				// System.out.print(dg.toString()+" is changed and now ");
 				if (cv.getAttribute() == SPARSE)
 					glNew.putAll(adjustForSparseGrid(dg, cv, dgClass));
 				else if (cv.getAttribute() == DENSE)
 					glNew.putAll(adjustForDenseGrid(dg, cv, dgClass));
-				else	// TRANSITIONAL
+				else // TRANSITIONAL
 					glNew.putAll(adjustForTransitionalGrid(dg, cv, dgClass));
 			}
 		}
-		
-		// If there are grids in glNew, update the corresponding grids in grid_list and clean up the cluster list
-		if (!glNew.isEmpty())
-		{
-			//System.out.println("There are "+glNew.size()+" entries to update from glNew to grid_list.");
+
+		// If there are grids in glNew, update the corresponding grids in grid_list and
+		// clean up the cluster list
+		if (!glNew.isEmpty()) {
+			// System.out.println("There are "+glNew.size()+" entries to update from glNew
+			// to grid_list.");
 			this.grid_list.putAll(glNew);
 			cleanClusters();
 			return true;
-		}
-		else
+		} else
 			return false;
 	}
-	
-	
+
 	/**
-	 * Adjusts the clustering of a sparse density grid. Implements lines 5 and 6 from Figure 4 of Chen and Tu 2007.
-	 * 
-	 * @param dg the sparse density grid being adjusted
-	 * @param cv the characteristic vector of dg
+	 * Adjusts the clustering of a sparse density grid. Implements lines 5 and 6
+	 * from Figure 4 of Chen and Tu 2007.
+	 *
+	 * @param dg      the sparse density grid being adjusted
+	 * @param cv      the characteristic vector of dg
 	 * @param dgClass the cluster to which dg belonged
-	 * 
-	 * @return a HashMap<DensityGrid, CharacteristicVector> containing density grids for update after this iteration
+	 *
+	 * @return a HashMap<DensityGrid, CharacteristicVector> containing density grids
+	 *         for update after this iteration
 	 */
-	private HashMap<DensityGrid, CharacteristicVector> adjustForSparseGrid(DensityGrid dg, CharacteristicVector cv, int dgClass)
-	{
-		HashMap<DensityGrid, CharacteristicVector> glNew = new HashMap<DensityGrid, CharacteristicVector>();
-		//System.out.print("Density grid "+dg.toString()+" is adjusted as a sparse grid at time "+this.getCurrTime()+". ");
-		if (dgClass != NO_CLASS)
-		{
-			//System.out.println("It is removed from cluster "+dgClass+".");
+	private HashMap<DensityGrid, CharacteristicVector> adjustForSparseGrid(DensityGrid dg, CharacteristicVector cv,
+			int dgClass) {
+		HashMap<DensityGrid, CharacteristicVector> glNew = new HashMap<>();
+		// System.out.print("Density grid "+dg.toString()+" is adjusted as a sparse grid
+		// at time "+this.getCurrTime()+". ");
+		if (dgClass != NO_CLASS) {
+			// System.out.println("It is removed from cluster "+dgClass+".");
 			GridCluster gc = this.cluster_list.get(dgClass);
 			gc.removeGrid(dg);
 			cv.setLabel(NO_CLASS);
 			glNew.put(dg, cv);
 			this.cluster_list.set(dgClass, gc);
-			
-			if(gc.getWeight() > 0.0 && !gc.isConnected())
+
+			if (gc.getWeight() > 0.0 && !gc.isConnected())
 				glNew.putAll(recluster(gc));
 		}
-		//else
-			//System.out.println("It was not clustered ("+dgClass+").");
+		// else
+		// System.out.println("It was not clustered ("+dgClass+").");
 
 		return glNew;
 	}
-	
+
 	/**
-	 * Reclusters a gridcluster into two (or more) constituent clusters when it has been identified that the original cluster
-	 * is no longer a grid group. It does so by echoing the initial clustering procedure over only those grids in gc.
-	 * 
+	 * Reclusters a gridcluster into two (or more) constituent clusters when it has
+	 * been identified that the original cluster is no longer a grid group. It does
+	 * so by echoing the initial clustering procedure over only those grids in gc.
+	 *
 	 * @param gc the gridcluster to be reclustered
-	 * 
-	 * @return a HashMap<DensityGrid, CharacteristicVector> containing density grids for update after this iteration
+	 *
+	 * @return a HashMap<DensityGrid, CharacteristicVector> containing density grids
+	 *         for update after this iteration
 	 */
-	private HashMap<DensityGrid, CharacteristicVector> recluster (GridCluster gc)
-	{
-		HashMap<DensityGrid, CharacteristicVector> glNew = new HashMap<DensityGrid, CharacteristicVector>();
-		Iterator<Map.Entry<DensityGrid,Boolean>> gcIter = gc.getGrids().entrySet().iterator();
-		newClusterList = new ArrayList<GridCluster>();
-		//System.out.println("Recluster called for cluster "+gc.getClusterLabel());
-		
-		// Assign every dense grid in gc to its own cluster, assign all other grids to NO_CLASS
-		while (gcIter.hasNext())
-		{
-			Map.Entry<DensityGrid,Boolean> grid = gcIter.next();
+	private HashMap<DensityGrid, CharacteristicVector> recluster(GridCluster gc) {
+		HashMap<DensityGrid, CharacteristicVector> glNew = new HashMap<>();
+		Iterator<Map.Entry<DensityGrid, Boolean>> gcIter = gc.getGrids().entrySet().iterator();
+		newClusterList = new ArrayList<>();
+		// System.out.println("Recluster called for cluster "+gc.getClusterLabel());
+
+		// Assign every dense grid in gc to its own cluster, assign all other grids to
+		// NO_CLASS
+		while (gcIter.hasNext()) {
+			Map.Entry<DensityGrid, Boolean> grid = gcIter.next();
 			DensityGrid dg = grid.getKey();
 			CharacteristicVector cvOfG = this.grid_list.get(dg);
 
-			if(cvOfG.getAttribute() == DENSE)
-			{
+			if (cvOfG.getAttribute() == DENSE) {
 				int gridClass = newClusterList.size();
 				cvOfG.setLabel(gridClass);
-				GridCluster newClus = new GridCluster ((CFCluster)dg, new ArrayList<CFCluster>(), gridClass);
+				GridCluster newClus = new GridCluster(dg, new ArrayList<CFCluster>(), gridClass);
 				newClus.addGrid(dg);
 				newClusterList.add(newClus);
-			}
-			else
+			} else
 				cvOfG.setLabel(NO_CLASS);
 
-			glNew.put(dg, cvOfG);	
+			glNew.put(dg, cvOfG);
 		}
-		
+
 		boolean changesMade;
-		
+
 		// While changes can be made...
-		do
-		{
+		do {
 			changesMade = false;
 			HashMap<DensityGrid, CharacteristicVector> glAdjusted = adjustNewLabels(glNew);
-			
-			if(!glAdjusted.isEmpty())
-			{
+
+			if (!glAdjusted.isEmpty()) {
 				glNew.putAll(glAdjusted);
 				changesMade = true;
 			}
-		}while(changesMade);
-		
+		} while (changesMade);
+
 		// Update the cluster list with the newly formed clusters
 		gc.getGrids().clear();
 		this.cluster_list.set(gc.getClusterLabel(), gc);
 		this.cluster_list.addAll(newClusterList);
-		
+
 		return glNew;
 	}
-	
-	
-	private HashMap<DensityGrid, CharacteristicVector> adjustNewLabels(HashMap<DensityGrid, CharacteristicVector> glNew)
-	{
+
+	private HashMap<DensityGrid, CharacteristicVector> adjustNewLabels(
+			HashMap<DensityGrid, CharacteristicVector> glNew) {
 		Iterator<GridCluster> newClusIter = newClusterList.iterator();
-		HashMap<DensityGrid, CharacteristicVector> glAdjusted = new HashMap<DensityGrid, CharacteristicVector>();
+		HashMap<DensityGrid, CharacteristicVector> glAdjusted = new HashMap<>();
 
 		// a. For each cluster c
-		while (newClusIter.hasNext())
-		{
+		while (newClusIter.hasNext()) {
 			GridCluster c = newClusIter.next();
 
 			// b. for each grid, dg, of c
-			for (Map.Entry<DensityGrid, Boolean> grid : c.getGrids().entrySet())
-			{
+			for (Map.Entry<DensityGrid, Boolean> grid : c.getGrids().entrySet()) {
 				DensityGrid dg = grid.getKey();
 				Boolean inside = grid.getValue();
-				
+
 				// b. for each OUTSIDE grid, dg, of c
-				if (!inside)
-				{
+				if (!inside) {
 					// c. for each neighbouring grid, dgprime, of dg
 					Iterator<DensityGrid> dgNeighbourhood = dg.getNeighbours().iterator();
-					
-					while(dgNeighbourhood.hasNext())
-					{
+
+					while (dgNeighbourhood.hasNext()) {
 						DensityGrid dgprime = dgNeighbourhood.next();
-						
-						if(glNew.containsKey(dgprime))
-						{
+
+						if (glNew.containsKey(dgprime)) {
 							CharacteristicVector cv1 = glNew.get(dg);
 							CharacteristicVector cv2 = glNew.get(dgprime);
 							int class1 = cv1.getLabel();
 							int class2 = cv2.getLabel();
 
 							// ...and if dgprime isn't already in the same cluster as dg...
-							if (class1 != class2)
-							{
+							if (class1 != class2) {
 								GridCluster c1 = newClusterList.get(class1);
 								// If dgprime is in cluster c', merge c and c' into the larger of the two
-								if (class2 != NO_CLASS)
-								{
+								if (class2 != NO_CLASS) {
 									GridCluster c2 = newClusterList.get(class2);
-									//System.out.println("C is "+class1+" and C' is "+class2+".");
+									// System.out.println("C is "+class1+" and C' is "+class2+".");
 									if (c1.getWeight() < c2.getWeight())
 										glAdjusted.putAll(mergeNewClusters(glNew, class1, class2));
 									else
@@ -770,8 +736,7 @@ private HashMap<DensityGrid, CharacteristicVector> adjustNewLabels(HashMap<Densi
 									return glAdjusted;
 								}
 								// If dgprime is transitional and outside of c, assign it to c
-								else if (cv2.isTransitional(dm, dl))
-								{
+								else if (cv2.isTransitional(dm, dl)) {
 									cv2.setLabel(class1);
 									c1.addGrid(dgprime);
 									this.newClusterList.set(class1, c1);
@@ -784,75 +749,74 @@ else if (cv2.isTransitional(dm, dl))
 				}
 			}
 		}
-		
+
 		return glAdjusted;
 	}
-	
-	private HashMap<DensityGrid, CharacteristicVector> mergeNewClusters(HashMap<DensityGrid, CharacteristicVector> glNew, int smallClus, int bigClus)
-	{
-		//System.out.println("Merge new clusters "+smallClus+" and "+bigClus+".");
-		// Iterate through the density grids in grid_list to find those which are in highClass
-		for (Map.Entry<DensityGrid, CharacteristicVector> grid : glNew.entrySet())
-		{
+
+	private HashMap<DensityGrid, CharacteristicVector> mergeNewClusters(
+			HashMap<DensityGrid, CharacteristicVector> glNew, int smallClus, int bigClus) {
+		// System.out.println("Merge new clusters "+smallClus+" and "+bigClus+".");
+		// Iterate through the density grids in grid_list to find those which are in
+		// highClass
+		for (Map.Entry<DensityGrid, CharacteristicVector> grid : glNew.entrySet()) {
 			DensityGrid dg = grid.getKey();
 			CharacteristicVector cv = grid.getValue();
 
 			// Assign density grids in smallClus to bigClus
-			if(cv.getLabel() == smallClus)
-			{
+			if (cv.getLabel() == smallClus) {
 				cv.setLabel(bigClus);
 				glNew.put(dg, cv);
 			}
 		}
-		//System.out.println("Density grids assigned to cluster "+bigClus+".");
-		
+		// System.out.println("Density grids assigned to cluster "+bigClus+".");
+
 		// Merge the GridCluster objects representing each cluster
 		GridCluster bGC = this.newClusterList.get(bigClus);
 		bGC.absorbCluster(this.newClusterList.get(smallClus));
 		this.newClusterList.set(bigClus, bGC);
 		this.newClusterList.remove(smallClus);
-		//System.out.println("Cluster "+smallClus+" removed from list.");
+		// System.out.println("Cluster "+smallClus+" removed from list.");
 		glNew = cleanNewClusters(glNew);
-		
+
 		return glNew;
 	}
-	
+
 	/**
-	 * Adjusts the clustering of a dense density grid. Implements lines 8 through 18 from Figure 4 of Chen and Tu 2007.
-	 * 
-	 * @param dg the dense density grid being adjusted
-	 * @param cv the characteristic vector of dg
+	 * Adjusts the clustering of a dense density grid. Implements lines 8 through 18
+	 * from Figure 4 of Chen and Tu 2007.
+	 *
+	 * @param dg      the dense density grid being adjusted
+	 * @param cv      the characteristic vector of dg
 	 * @param dgClass the cluster to which dg belonged
-	 * 
-	 * @return a HashMap<DensityGrid, CharacteristicVector> containing density grids for update after this iteration
+	 *
+	 * @return a HashMap<DensityGrid, CharacteristicVector> containing density grids
+	 *         for update after this iteration
 	 */
-	private HashMap<DensityGrid, CharacteristicVector> adjustForDenseGrid(DensityGrid dg, CharacteristicVector cv, int dgClass)
-	{
-		//System.out.print("Density grid "+dg.toString()+" is adjusted as a dense grid at time "+this.getCurrTime()+". ");
-
-		// Among all neighbours of dg, find the grid h whose cluster ch has the largest size
-		GridCluster ch;								// The cluster, ch, of h
-		DensityGrid hChosen = new DensityGrid(dg);	// The chosen grid h, whose cluster ch has the largest size
-		double hChosenSize = -1.0;					// The size of ch, the largest cluster
-		DensityGrid dgH;							// The neighbour of g being considered
-		int hClass = NO_CLASS;						// The class label of h
-		int hChosenClass = NO_CLASS;				// The class label of ch
+	private HashMap<DensityGrid, CharacteristicVector> adjustForDenseGrid(DensityGrid dg, CharacteristicVector cv,
+			int dgClass) {
+		// System.out.print("Density grid "+dg.toString()+" is adjusted as a dense grid
+		// at time "+this.getCurrTime()+". ");
+
+		// Among all neighbours of dg, find the grid h whose cluster ch has the largest
+		// size
+		GridCluster ch; // The cluster, ch, of h
+		DensityGrid hChosen = new DensityGrid(dg); // The chosen grid h, whose cluster ch has the largest size
+		double hChosenSize = -1.0; // The size of ch, the largest cluster
+		DensityGrid dgH; // The neighbour of g being considered
+		int hClass = NO_CLASS; // The class label of h
+		int hChosenClass = NO_CLASS; // The class label of ch
 		Iterator<DensityGrid> dgNeighbourhood = dg.getNeighbours().iterator();
-		HashMap<DensityGrid, CharacteristicVector> glNew = new HashMap<DensityGrid, CharacteristicVector>();
-		
-		while (dgNeighbourhood.hasNext())
-		{
+		HashMap<DensityGrid, CharacteristicVector> glNew = new HashMap<>();
+
+		while (dgNeighbourhood.hasNext()) {
 			dgH = dgNeighbourhood.next();
-		
-			if (this.grid_list.containsKey(dgH))
-			{
+
+			if (this.grid_list.containsKey(dgH)) {
 				hClass = this.grid_list.get(dgH).getLabel();
-				if (hClass != NO_CLASS)
-				{
+				if (hClass != NO_CLASS) {
 					ch = this.cluster_list.get(hClass);
-			
-					if (ch.getWeight() > hChosenSize)
-					{
+
+					if (ch.getWeight() > hChosenSize) {
 						hChosenSize = ch.getWeight();
 						hChosenClass = hClass;
 						hChosen = new DensityGrid(dgH);
@@ -860,206 +824,197 @@ private HashMap<DensityGrid, CharacteristicVector> adjustForDenseGrid(DensityGri
 				}
 			}
 		}
-		
-		//System.out.println(" Chosen neighbour is "+hChosen.toString()+" from cluster "+hChosenClass+".");
-		
-		if (hChosenClass != NO_CLASS  && hChosenClass != dgClass)
-		{
+
+		// System.out.println(" Chosen neighbour is "+hChosen.toString()+" from cluster
+		// "+hChosenClass+".");
+
+		if (hChosenClass != NO_CLASS && hChosenClass != dgClass) {
 			ch = this.cluster_list.get(hChosenClass);
-			
+
 			// If h is a dense grid
-			if (this.grid_list.get(hChosen).getAttribute() == DENSE)
-			{
-				//System.out.println("h is dense.");
+			if (this.grid_list.get(hChosen).getAttribute() == DENSE) {
+				// System.out.println("h is dense.");
 				// If dg is labelled as NO_CLASS
-				if(dgClass == NO_CLASS)
-				{
-					//System.out.println("g was labelled NO_CLASS");
+				if (dgClass == NO_CLASS) {
+					// System.out.println("g was labelled NO_CLASS");
 					cv.setLabel(hChosenClass);
 					glNew.put(dg, cv);
 					ch.addGrid(dg);
 					this.cluster_list.set(hChosenClass, ch);
-					
+
 				}
 				// Else if dg belongs to cluster c and h belongs to c'
-				else
-				{
-					//System.out.println("g was labelled "+dgClass);
+				else {
+					// System.out.println("g was labelled "+dgClass);
 					double gSize = this.cluster_list.get(dgClass).getWeight();
-					
+
 					if (gSize <= hChosenSize)
 						mergeClusters(dgClass, hChosenClass);
 					else
 						mergeClusters(hChosenClass, dgClass);
 				}
 			}
-		
+
 			// Else if h is a transitional grid
-			else if (this.grid_list.get(hChosen).getAttribute() == TRANSITIONAL)
-			{
-				//System.out.print("h is transitional.");
-				// If dg is labelled as no class and if h is an outside grid if dg is added to ch
-				if (dgClass == NO_CLASS && !ch.isInside(hChosen, dg))
-				{
+			else if (this.grid_list.get(hChosen).getAttribute() == TRANSITIONAL) {
+				// System.out.print("h is transitional.");
+				// If dg is labelled as no class and if h is an outside grid if dg is added to
+				// ch
+				if (dgClass == NO_CLASS && !ch.isInside(hChosen, dg)) {
 					cv.setLabel(hChosenClass);
 					glNew.put(dg, cv);
 					ch.addGrid(dg);
 					this.cluster_list.set(hChosenClass, ch);
-					//System.out.println(" dg is added to cluster "+hChosenClass+".");
+					// System.out.println(" dg is added to cluster "+hChosenClass+".");
 				}
 				// Else if dg is in cluster c and |c| >= |ch|
-				else if (dgClass != NO_CLASS)
-				{
+				else if (dgClass != NO_CLASS) {
 					GridCluster c = this.cluster_list.get(dgClass);
 					double gSize = c.getWeight();
-					
-					if (gSize >= hChosenSize)
-					{
+
+					if (gSize >= hChosenSize) {
 						// Move h from cluster ch to cluster c
 						ch.removeGrid(hChosen);
 						c.addGrid(hChosen);
 						CharacteristicVector cvhChosen = this.grid_list.get(hChosen);
 						cvhChosen.setLabel(dgClass);
 						glNew.put(hChosen, cvhChosen);
-						//System.out.println("dgClass is "+dgClass+", hChosenClass is "+hChosenClass+", gSize is "+gSize+" and hChosenSize is "+hChosenSize+" h is added to cluster "+dgClass+".");
+						// System.out.println("dgClass is "+dgClass+", hChosenClass is "+hChosenClass+",
+						// gSize is "+gSize+" and hChosenSize is "+hChosenSize+" h is added to cluster
+						// "+dgClass+".");
 						this.cluster_list.set(hChosenClass, ch);
 						this.cluster_list.set(dgClass, c);
 					}
 				}
 			}
 		}
-		// If dgClass is dense and not in a cluster, and none if its neighbours are in a cluster,
-		// put it in its own new cluster and search the neighbourhood for transitional or dense
+		// If dgClass is dense and not in a cluster, and none if its neighbours are in a
+		// cluster,
+		// put it in its own new cluster and search the neighbourhood for transitional
+		// or dense
 		// grids to add
-		else if (dgClass == NO_CLASS)
-		{
+		else if (dgClass == NO_CLASS) {
 			int newClass = this.cluster_list.size();
-			GridCluster c = new GridCluster((CFCluster)dg, new ArrayList<CFCluster>(), newClass);
+			GridCluster c = new GridCluster(dg, new ArrayList<CFCluster>(), newClass);
 			c.addGrid(dg);
-			//System.out.println("Added "+dg.toString()+" to cluster "+newClass+".");
+			// System.out.println("Added "+dg.toString()+" to cluster "+newClass+".");
 			this.cluster_list.add(c);
 			cv.setLabel(newClass);
 			glNew.put(dg, cv);
-			
-			// Iterate through the neighbourhood until no more transitional neighbours can be added
+
+			// Iterate through the neighbourhood until no more transitional neighbours can
+			// be added
 			// (dense neighbours will add themselves as part of their adjust process)
 			dgNeighbourhood = dg.getNeighbours().iterator();
-					
-			while(dgNeighbourhood.hasNext())
-			{
+
+			while (dgNeighbourhood.hasNext()) {
 				DensityGrid dghprime = dgNeighbourhood.next();
-						
-				if (this.grid_list.containsKey(dghprime) && !c.getGrids().containsKey(dghprime))
-				{
+
+				if (this.grid_list.containsKey(dghprime) && !c.getGrids().containsKey(dghprime)) {
 					CharacteristicVector cvhprime = this.grid_list.get(dghprime);
-					if(cvhprime.getAttribute() == TRANSITIONAL)
-					{
-						//System.out.println("Added "+dghprime.toString()+" to cluster "+newClass+".");
+					if (cvhprime.getAttribute() == TRANSITIONAL) {
+						// System.out.println("Added "+dghprime.toString()+" to cluster "+newClass+".");
 						c.addGrid(dghprime);
 						cvhprime.setLabel(newClass);
 						glNew.put(dghprime, cvhprime);
 					}
 				}
 			}
-	
+
 			this.cluster_list.set(newClass, c);
-			//System.out.println("Cluster "+newClass+": "+this.cluster_list.get(newClass).toString());		
+			// System.out.println("Cluster "+newClass+":
+			// "+this.cluster_list.get(newClass).toString());
 		}
-		
+
 		return glNew;
 	}
-	
+
 	/**
-	 * Adjusts the clustering of a transitional density grid. Implements lines 20 and 21 from Figure 4 of Chen and Tu 2007.
-	 * 
-	 * @param dg the dense density grid being adjusted
-	 * @param cv the characteristic vector of dg
+	 * Adjusts the clustering of a transitional density grid. Implements lines 20
+	 * and 21 from Figure 4 of Chen and Tu 2007.
+	 *
+	 * @param dg      the dense density grid being adjusted
+	 * @param cv      the characteristic vector of dg
 	 * @param dgClass the cluster to which dg belonged
-	 * 
-	 * @return a HashMap<DensityGrid, CharacteristicVector> containing density grids for update after this iteration
+	 *
+	 * @return a HashMap<DensityGrid, CharacteristicVector> containing density grids
+	 *         for update after this iteration
 	 */
-	private HashMap<DensityGrid, CharacteristicVector> adjustForTransitionalGrid(DensityGrid dg, CharacteristicVector cv, int dgClass)
-	{
-		//System.out.print("Density grid "+dg.toString()+" is adjusted as a transitional grid at time "+this.getCurrTime()+". ");
-		
-		// Among all neighbours of dg, find the grid h whose cluster ch has the largest size
+	private HashMap<DensityGrid, CharacteristicVector> adjustForTransitionalGrid(DensityGrid dg,
+			CharacteristicVector cv, int dgClass) {
+		// System.out.print("Density grid "+dg.toString()+" is adjusted as a
+		// transitional grid at time "+this.getCurrTime()+". ");
+
+		// Among all neighbours of dg, find the grid h whose cluster ch has the largest
+		// size
 		// and satisfies that dg would be an outside grid if added to it
-		GridCluster ch;								// The cluster, ch, of h
-		double hChosenSize = 0.0;					// The size of ch, the largest cluster
-		DensityGrid dgH;							// The neighbour of dg being considered
-		int hClass = NO_CLASS;						// The class label of h
-		int hChosenClass = NO_CLASS;				// The class label of ch
+		GridCluster ch; // The cluster, ch, of h
+		double hChosenSize = 0.0; // The size of ch, the largest cluster
+		DensityGrid dgH; // The neighbour of dg being considered
+		int hClass = NO_CLASS; // The class label of h
+		int hChosenClass = NO_CLASS; // The class label of ch
 		Iterator<DensityGrid> dgNeighbourhood = dg.getNeighbours().iterator();
-		HashMap<DensityGrid, CharacteristicVector> glNew = new HashMap<DensityGrid, CharacteristicVector>();
-		
-		while (dgNeighbourhood.hasNext())
-		{
+		HashMap<DensityGrid, CharacteristicVector> glNew = new HashMap<>();
+
+		while (dgNeighbourhood.hasNext()) {
 			dgH = dgNeighbourhood.next();
-			
-			if (this.grid_list.containsKey(dgH))
-			{
+
+			if (this.grid_list.containsKey(dgH)) {
 				hClass = this.grid_list.get(dgH).getLabel();
-				if (hClass != NO_CLASS)
-				{
+				if (hClass != NO_CLASS) {
 					ch = this.cluster_list.get(hClass);
-			
-					if ((ch.getWeight() > hChosenSize) && !ch.isInside(dg, dg))
-					{
+
+					if ((ch.getWeight() > hChosenSize) && !ch.isInside(dg, dg)) {
 						hChosenSize = ch.getWeight();
 						hChosenClass = hClass;
 					}
 				}
 			}
 		}
-		
-		//System.out.println(" Chosen neighbour is from cluster "+hChosenClass+", dgClass is "+dgClass+".");
-		
-		if (hChosenClass != NO_CLASS && hChosenClass != dgClass)
-		{
+
+		// System.out.println(" Chosen neighbour is from cluster "+hChosenClass+",
+		// dgClass is "+dgClass+".");
+
+		if (hChosenClass != NO_CLASS && hChosenClass != dgClass) {
 			ch = this.cluster_list.get(hChosenClass);
 			ch.addGrid(dg);
 			this.cluster_list.set(hChosenClass, ch);
-			
-			if(dgClass != NO_CLASS)
-			{
+
+			if (dgClass != NO_CLASS) {
 				GridCluster c = this.cluster_list.get(dgClass);
 				c.removeGrid(dg);
 				this.cluster_list.set(dgClass, c);
 			}
-			
+
 			cv.setLabel(hChosenClass);
 			glNew.put(dg, cv);
 		}
-		
+
 		return glNew;
 	}
-	
+
 	/**
-	 * Iterates through cluster_list to ensure that all empty clusters have been removed and
-	 * that all cluster IDs match the cluster's index in cluster_list.
+	 * Iterates through cluster_list to ensure that all empty clusters have been
+	 * removed and that all cluster IDs match the cluster's index in cluster_list.
 	 */
-	private void cleanClusters()
-	{
-		//System.out.println("Clean Clusters");
+	private void cleanClusters() {
+		// System.out.println("Clean Clusters");
 		Iterator<GridCluster> clusIter = this.cluster_list.iterator();
-		ArrayList<GridCluster> toRem = new ArrayList<GridCluster>();
+		ArrayList<GridCluster> toRem = new ArrayList<>();
 
 		// Check to see if there are any empty clusters
-		while(clusIter.hasNext())
-		{
+		while (clusIter.hasNext()) {
 			GridCluster c = clusIter.next();
 
-			if(c.getWeight() == 0)
+			if (c.getWeight() == 0)
 				toRem.add(c);
 		}
 
 		// Remove empty clusters
-		if (!toRem.isEmpty())
-		{
+		if (!toRem.isEmpty()) {
 			clusIter = toRem.iterator();
 
-			while(clusIter.hasNext())
-			{
+			while (clusIter.hasNext()) {
 				this.cluster_list.remove(clusIter.next());
 			}
 		}
@@ -1067,8 +1022,7 @@ private void cleanClusters()
 		// Adjust remaining clusters as necessary
 		clusIter = this.cluster_list.iterator();
 
-		while(clusIter.hasNext())
-		{
+		while (clusIter.hasNext()) {
 			GridCluster c = clusIter.next();
 			int index = this.cluster_list.indexOf(c);
 
@@ -1077,44 +1031,39 @@ private void cleanClusters()
 
 			Iterator<Map.Entry<DensityGrid, Boolean>> gridsOfClus = c.getGrids().entrySet().iterator();
 
-			while(gridsOfClus.hasNext())
-			{
+			while (gridsOfClus.hasNext()) {
 				DensityGrid dg = gridsOfClus.next().getKey();
 				CharacteristicVector cv = this.grid_list.get(dg);
-				if(cv == null)
-				{
-					System.out.println("Warning, cv is null for "+dg.toString()+" from cluster "+index+".");
+				if (cv == null) {
+					System.out.println("Warning, cv is null for " + dg.toString() + " from cluster " + index + ".");
 					printGridList();
 					printGridClusters();
 				}
-				//System.out.println("Cluster "+index+": "+dg.toString()+" is here.");
+				// System.out.println("Cluster "+index+": "+dg.toString()+" is here.");
 				cv.setLabel(index);
 				this.grid_list.put(dg, cv);
 			}
 		}
 	}
-	
-	private HashMap<DensityGrid, CharacteristicVector> cleanNewClusters(HashMap<DensityGrid, CharacteristicVector> glNew)
-	{
+
+	private HashMap<DensityGrid, CharacteristicVector> cleanNewClusters(
+			HashMap<DensityGrid, CharacteristicVector> glNew) {
 		Iterator<GridCluster> clusIter = this.newClusterList.iterator();
-		ArrayList<GridCluster> toRem = new ArrayList<GridCluster>();
+		ArrayList<GridCluster> toRem = new ArrayList<>();
 
 		// Check to see if there are any empty clusters
-		while(clusIter.hasNext())
-		{
+		while (clusIter.hasNext()) {
 			GridCluster c = clusIter.next();
 
-			if(c.getWeight() == 0)
+			if (c.getWeight() == 0)
 				toRem.add(c);
 		}
 
 		// Remove empty clusters
-		if (!toRem.isEmpty())
-		{
+		if (!toRem.isEmpty()) {
 			clusIter = toRem.iterator();
 
-			while(clusIter.hasNext())
-			{
+			while (clusIter.hasNext()) {
 				this.newClusterList.remove(clusIter.next());
 			}
 		}
@@ -1122,8 +1071,7 @@ private HashMap<DensityGrid, CharacteristicVector> cleanNewClusters(HashMap<Dens
 		// Adjust remaining clusters as necessary
 		clusIter = this.newClusterList.iterator();
 
-		while(clusIter.hasNext())
-		{
+		while (clusIter.hasNext()) {
 			GridCluster c = clusIter.next();
 			int index = this.newClusterList.indexOf(c);
 
@@ -1131,162 +1079,158 @@ private HashMap<DensityGrid, CharacteristicVector> cleanNewClusters(HashMap<Dens
 
 			Iterator<Map.Entry<DensityGrid, Boolean>> gridsOfClus = c.getGrids().entrySet().iterator();
 
-			while(gridsOfClus.hasNext())
-			{
+			while (gridsOfClus.hasNext()) {
 				DensityGrid dg = gridsOfClus.next().getKey();
 				CharacteristicVector cv = glNew.get(dg);
 				cv.setLabel(index);
 				glNew.put(dg, cv);
 			}
 		}
-		
+
 		return glNew;
 	}
-	
+
 	/**
 	 * Implements the procedure described in section 4.2 of Chen and Tu 2007
 	 */
 	private void removeSporadic() {
-		//System.out.println("REMOVE SPORADIC CALLED");
+		// System.out.println("REMOVE SPORADIC CALLED");
 		// 1. For each grid g in grid_list
-		//    a. If g is sporadic
-		//       i. If currTime - tg > gap, delete g from grid_list
-		//       ii. Else if (S1 && S2), mark as sporadic
-		//       iii. Else, mark as normal
-		//    b. Else
-		//       i. If (S1 && S2), mark as sporadic
-		
+		// a. If g is sporadic
+		// i. If currTime - tg > gap, delete g from grid_list
+		// ii. Else if (S1 && S2), mark as sporadic
+		// iii. Else, mark as normal
+		// b. Else
+		// i. If (S1 && S2), mark as sporadic
+
 		// For each grid g in grid_list
 		Iterator<Map.Entry<DensityGrid, CharacteristicVector>> glIter = this.grid_list.entrySet().iterator();
-		HashMap<DensityGrid, CharacteristicVector> newGL = new HashMap<DensityGrid, CharacteristicVector>();
-		ArrayList<DensityGrid> remGL = new ArrayList<DensityGrid>();
-				
-		while(glIter.hasNext())
-		{
+		HashMap<DensityGrid, CharacteristicVector> newGL = new HashMap<>();
+		ArrayList<DensityGrid> remGL = new ArrayList<>();
+
+		while (glIter.hasNext()) {
 			Map.Entry<DensityGrid, CharacteristicVector> grid = glIter.next();
 			DensityGrid dg = grid.getKey();
 			CharacteristicVector cv = grid.getValue();
-			
+
 			// If g is sporadic
-			if (cv.isSporadic())
-			{
+			if (cv.isSporadic()) {
 				// If currTime - tg > gap, delete g from grid_list
-				if ((this.getCurrTime() - cv.getUpdateTime()) >= gap)
-				{
+				if ((this.getCurrTime() - cv.getUpdateTime()) >= gap) {
 					int dgClass = cv.getLabel();
-					
+
 					if (dgClass != -1)
 						this.cluster_list.get(dgClass).removeGrid(dg);
-					
+
 					remGL.add(dg);
-					//System.out.println("Removed "+dg.toString()+" from cluster "+dgClass);
+					// System.out.println("Removed "+dg.toString()+" from cluster "+dgClass);
 				}
 				// Else if (S1 && S2), mark as sporadic - Else mark as normal
-				else
-				{
+				else {
 					cv.setSporadic(checkIfSporadic(cv));
-					//System.out.println("within gap" + dg.toString() + " sporadicity assessed "+cv.isSporadic());
+					// System.out.println("within gap" + dg.toString() + " sporadicity assessed
+					// "+cv.isSporadic());
 					newGL.put(dg, cv);
 				}
-				
+
 			}
 			// Else if (S1 && S2), mark as sporadic
-			else
-			{
+			else {
 				cv.setSporadic(checkIfSporadic(cv));
-				//System.out.println(dg.toString() + " sporadicity assessed "+cv.isSporadic());
+				// System.out.println(dg.toString() + " sporadicity assessed "+cv.isSporadic());
 				newGL.put(dg, cv);
 			}
 		}
-		
+
 		this.grid_list.putAll(newGL);
-		
-		//System.out.println(" - Removed "+remGL.size()+" grids from grid_list.");
+
+		// System.out.println(" - Removed "+remGL.size()+" grids from grid_list.");
 		Iterator<DensityGrid> remIter = remGL.iterator();
-		
-		while(remIter.hasNext())
-		{
+
+		while (remIter.hasNext()) {
 			DensityGrid sporadicDG = remIter.next();
-			//System.out.println("Removing sporadic grid "+sporadicDG.toString()+" at time "+this.getCurrTime()+".");
+			// System.out.println("Removing sporadic grid "+sporadicDG.toString()+" at time
+			// "+this.getCurrTime()+".");
 			this.deleted_grids.put(sporadicDG, new Integer(this.getCurrTime()));
 			this.grid_list.remove(sporadicDG);
 		}
-		
+
 	}
 
 	/**
-	 * Determines whether a sparse density grid is sporadic using rules S1 and S2 of Chen and Tu 2007
-	 * 
-	 * @param cv - the CharacteristicVector of the density grid being assessed for sporadicity
+	 * Determines whether a sparse density grid is sporadic using rules S1 and S2 of
+	 * Chen and Tu 2007
+	 *
+	 * @param cv - the CharacteristicVector of the density grid being assessed for
+	 *           sporadicity
 	 */
-	private boolean checkIfSporadic(CharacteristicVector cv)
-	{
+	private boolean checkIfSporadic(CharacteristicVector cv) {
 		// Check S1
-		if(cv.getCurrGridDensity(this.getCurrTime(), this.getDecayFactor()) < densityThresholdFunction(cv.getDensityTimeStamp(), this.cl, this.getDecayFactor(), this.N))
-		{
+		if (cv.getCurrGridDensity(this.getCurrTime(), this.getDecayFactor()) < densityThresholdFunction(
+				cv.getDensityTimeStamp(), this.cl, this.getDecayFactor(), this.N)) {
 			// Check S2
-			if(cv.getRemoveTime() == -1 || this.getCurrTime() >= ((1 + this.beta)*cv.getRemoveTime()))
+			if (cv.getRemoveTime() == -1 || this.getCurrTime() >= ((1 + this.beta) * cv.getRemoveTime()))
 				return true;
 		}
-		
-		return false; 
+
+		return false;
 	}
-	
+
 	/**
 	 * Implements the function pi given in Definition 4.1 of Chen and Tu 2007
-	 * 
-	 * @param tg - the update time in the density grid's characteristic vector
-	 * @param cl - user defined parameter which controls the threshold for sparse grids
-	 * @param decayFactor - user defined parameter which is represented as lambda in Chen and Tu 2007
-	 * @param N - the number of density grids, defined after eq 2 in Chen and Tu 2007
+	 *
+	 * @param tg          - the update time in the density grid's characteristic
+	 *                    vector
+	 * @param cl          - user defined parameter which controls the threshold for
+	 *                    sparse grids
+	 * @param decayFactor - user defined parameter which is represented as lambda in
+	 *                    Chen and Tu 2007
+	 * @param N           - the number of density grids, defined after eq 2 in Chen
+	 *                    and Tu 2007
 	 */
-	private double densityThresholdFunction(int tg, double cl, double decayFactor, int N)
-	{
-		return (cl * (1.0 - Math.pow(decayFactor, (this.getCurrTime()-tg+1.0))))/(N * (1.0 - decayFactor));
+	private double densityThresholdFunction(int tg, double cl, double decayFactor, int N) {
+		return (cl * (1.0 - Math.pow(decayFactor, (this.getCurrTime() - tg + 1.0)))) / (N * (1.0 - decayFactor));
 	}
-	
+
 	/**
-	 * Reassign all grids belonging in the small cluster to the big cluster
-	 * Merge the GridCluster objects representing each cluster
-	 * 
+	 * Reassign all grids belonging in the small cluster to the big cluster Merge
+	 * the GridCluster objects representing each cluster
+	 *
 	 * @param smallClus - the index of the smaller cluster
-	 * @param bigClus - the index of the bigger cluster
+	 * @param bigClus   - the index of the bigger cluster
 	 */
-	private void mergeClusters (int smallClus, int bigClus)
-	{		
-		//System.out.println("Merge clusters "+smallClus+" and "+bigClus+".");
-		// Iterate through the density grids in grid_list to find those which are in highClass
-		for (Map.Entry<DensityGrid, CharacteristicVector> grid : grid_list.entrySet())
-		{
+	private void mergeClusters(int smallClus, int bigClus) {
+		// System.out.println("Merge clusters "+smallClus+" and "+bigClus+".");
+		// Iterate through the density grids in grid_list to find those which are in
+		// highClass
+		for (Map.Entry<DensityGrid, CharacteristicVector> grid : grid_list.entrySet()) {
 			DensityGrid dg = grid.getKey();
 			CharacteristicVector cv = grid.getValue();
 
 			// Assign density grids in smallClus to bigClus
-			if(cv.getLabel() == smallClus)
-			{
+			if (cv.getLabel() == smallClus) {
 				cv.setLabel(bigClus);
 				this.grid_list.put(dg, cv);
 			}
 		}
-		//System.out.println("Density grids assigned to cluster "+bigClus+".");
-		
+		// System.out.println("Density grids assigned to cluster "+bigClus+".");
+
 		// Merge the GridCluster objects representing each cluster
 		GridCluster bGC = this.cluster_list.get(bigClus);
 		bGC.absorbCluster(this.cluster_list.get(smallClus));
 		this.cluster_list.set(bigClus, bGC);
 		this.cluster_list.remove(smallClus);
-		//System.out.println("Cluster "+smallClus+" removed from list.");
+		// System.out.println("Cluster "+smallClus+" removed from list.");
 		cleanClusters();
 	}
 
 	/**
-	 * Iterates through grid_list and updates the density for each density grid therein.
-	 * Also marks each density grid as unvisited for this call to adjustClustering.
+	 * Iterates through grid_list and updates the density for each density grid
+	 * therein. Also marks each density grid as unvisited for this call to
+	 * adjustClustering.
 	 */
-	private void updateGridListDensity()
-	{
-		for (Map.Entry<DensityGrid, CharacteristicVector> grid : grid_list.entrySet())
-		{
+	private void updateGridListDensity() {
+		for (Map.Entry<DensityGrid, CharacteristicVector> grid : grid_list.entrySet()) {
 			DensityGrid dg = grid.getKey();
 			CharacteristicVector cvOfG = grid.getValue();
 
@@ -1300,59 +1244,55 @@ private void updateGridListDensity()
 	/**
 	 * @return currTime - the stream's internal time
 	 */
-	public int getCurrTime()
-	{
+	public int getCurrTime() {
 		return this.currTime;
 	}
 
 	/**
 	 * @param t - sets the stream's internal time to 't'
 	 */
-	private void setCurrTime(int t)
-	{
+	private void setCurrTime(int t) {
 		this.currTime = t;
 	}
 
 	/**
 	 * Increments the stream's internal time
 	 */
-	private void incCurrTime()
-	{
+	private void incCurrTime() {
 		this.currTime++;
 	}
 
 	/**
 	 * @return decay factor - represented as lambda in Chen and Tu 2007
 	 */
-	public double getDecayFactor()
-	{
+	public double getDecayFactor() {
 		return this.decayFactor;
 	}
 
 	/**
-	 * @return dm - the density threshold for dense grids. It is controlled by cl and given in eq 8 of Chen and Tu 2007
+	 * @return dm - the density threshold for dense grids. It is controlled by cl
+	 *         and given in eq 8 of Chen and Tu 2007
 	 */
-	public double getDM()
-	{
+	public double getDM() {
 		return this.dm;
 	}
 
 	/**
-	 * @return dl - the density threshold for sparse grids. It is controlled by cl and given in eq 9 of Chen and Tu 2007
+	 * @return dl - the density threshold for sparse grids. It is controlled by cl
+	 *         and given in eq 9 of Chen and Tu 2007
 	 */
-	public double getDL()
-	{
+	public double getDL() {
 		return this.dl;
 	}
-	
-	public void printInst(Instance inst)
-	{
-		for (int i = 0 ; i < inst.numAttributes() ; i++)
-			System.out.print(inst.value(i)+" ");
+
+	public void printInst(Instance inst) {
+		for (int i = 0; i < inst.numAttributes(); i++)
+			System.out.print(inst.value(i) + " ");
 	}
-	
+
 	/**
-	 * Prints out the values of the parameters associated with this instance of the D-Stream algorithm:
+	 * Prints out the values of the parameters associated with this instance of the
+	 * D-Stream algorithm:
 	 * <ol>
 	 * <li>gap;</li>
 	 * <li>decay factor (lambda);</li>
@@ -1361,49 +1301,45 @@ public void printInst(Instance inst)
 	 * <li>beta.</li>
 	 * </ol>
 	 */
-	public void printDStreamState()
-	{
+	public void printDStreamState() {
 		System.out.println("State of D-Stream algorithm");
-		System.out.println("Time Gap: "+this.gap+", Decay Factor: "+this.decayFactor);
-		System.out.println("C_m: "+this.cm+", C_l: "+this.cl);
-		System.out.println("D_m: "+this.dm+", D_l: "+this.dl);
-		System.out.println("Beta: "+this.beta);
+		System.out.println("Time Gap: " + this.gap + ", Decay Factor: " + this.decayFactor);
+		System.out.println("C_m: " + this.cm + ", C_l: " + this.cl);
+		System.out.println("D_m: " + this.dm + ", D_l: " + this.dl);
+		System.out.println("Beta: " + this.beta);
 	}
-	
+
 	/**
-	 * Iterates through grid_list and prints out each density grid therein as a string.
-	 * 
-	 * @see moa.clusterers.dstream.Dstream.grid_list
-	 * @see moa.clusterers.dstream.DensityGrid.toString
+	 * Iterates through grid_list and prints out each density grid therein as a
+	 * string.
+	 *
+	 * @see moa.learners.clusterers.dstream.Dstream.grid_list
+	 * @see moa.learners.clusterers.dstream.DensityGrid.toString
 	 */
-	public void printGridList()
-	{
-		System.out.println("Grid List. Size "+this.grid_list.size()+".");
-		for (Map.Entry<DensityGrid, CharacteristicVector> grid : grid_list.entrySet())
-		{
+	public void printGridList() {
+		System.out.println("Grid List. Size " + this.grid_list.size() + ".");
+		for (Map.Entry<DensityGrid, CharacteristicVector> grid : grid_list.entrySet()) {
 			DensityGrid dg = grid.getKey();
 			CharacteristicVector cv = grid.getValue();
-			
-			if (cv.getAttribute() != SPARSE)
-			{
+
+			if (cv.getAttribute() != SPARSE) {
 				double dtf = densityThresholdFunction(cv.getUpdateTime(), this.cl, this.getDecayFactor(), this.N);
-				System.out.println(dg.toString()+" "+cv.toString()+" // Density Threshold Function = "+dtf);
+				System.out.println(dg.toString() + " " + cv.toString() + " // Density Threshold Function = " + dtf);
 			}
 		}
 	}
-	
+
 	/**
-	 * Iterates through cluster_list and prints out each grid cluster therein as a string.
-	 * 
-	 * @see moa.clusterers.dstream.Dstream.cluster_list
-	 * @see moa.clusterers.dstream.GridCluster.toString
+	 * Iterates through cluster_list and prints out each grid cluster therein as a
+	 * string.
+	 *
+	 * @see moa.learners.clusterers.dstream.Dstream.cluster_list
+	 * @see moa.learners.clusterers.dstream.GridCluster.toString
 	 */
-	public void printGridClusters()
-	{
-		System.out.println("List of Clusters. Total "+this.cluster_list.size()+".");
-		for(GridCluster gc : this.cluster_list)
-		{
-			System.out.println(gc.getClusterLabel()+": "+gc.getWeight()+" {"+gc.toString()+"}");
+	public void printGridClusters() {
+		System.out.println("List of Clusters. Total " + this.cluster_list.size() + ".");
+		for (GridCluster gc : this.cluster_list) {
+			System.out.println(gc.getClusterLabel() + ": " + gc.getWeight() + " {" + gc.toString() + "}");
 		}
 	}
 }
diff --git a/moa/src/main/java/moa/clusterers/dstream/GridCluster.java b/moa/src/main/java/moa/learners/clusterers/dstream/GridCluster.java
similarity index 60%
rename from moa/src/main/java/moa/clusterers/dstream/GridCluster.java
rename to moa/src/main/java/moa/learners/clusterers/dstream/GridCluster.java
index 49b3dfe1f..493e11b2c 100644
--- a/moa/src/main/java/moa/clusterers/dstream/GridCluster.java
+++ b/moa/src/main/java/moa/learners/clusterers/dstream/GridCluster.java
@@ -1,6 +1,6 @@
 /**
  *    GridCluster.java
- *    
+ *
  *    @author Richard Hugh Moulton  (rmoul026 -[at]- uottawa dot ca)
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,10 +13,10 @@
  *    distributed under the License is distributed on an "AS IS" BASIS,
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
- *    limitations under the License.  
+ *    limitations under the License.
  */
 
-package moa.clusterers.dstream;
+package moa.learners.clusterers.dstream;
 
 import java.util.HashMap;
 import java.util.Iterator;
@@ -26,161 +26,147 @@
 import com.yahoo.labs.samoa.instances.Instance;
 
 import moa.cluster.CFCluster;
-import moa.clusterers.macro.NonConvexCluster;
+import moa.learners.clusterers.macro.NonConvexCluster;
 
 /**
- * Grid Clusters are defined in Definition 3.6 of Chen and Tu 2007 as:
- * Let G =(g1, ·· · ,gm) be a grid group, if every inside grid of G is 
- * a dense grid and every outside grid is either a dense grid or a 
- * transitional grid, then G is a grid cluster.
- * 
- * Citation: Y. Chen and L. Tu, “Density-Based Clustering for Real-Time Stream Data,” in
- * Proceedings of the 13th ACM SIGKDD international conference on Knowledge discovery and
- * data mining, 2007, pp. 133–142.
+ * Grid Clusters are defined in Definition 3.6 of Chen and Tu 2007 as: Let G
+ * =(g1, ·· · ,gm) be a grid group, if every inside grid of G is a dense grid
+ * and every outside grid is either a dense grid or a transitional grid, then G
+ * is a grid cluster.
+ *
+ * Citation: Y. Chen and L. Tu, “Density-Based Clustering for Real-Time Stream
+ * Data,” in Proceedings of the 13th ACM SIGKDD international conference on
+ * Knowledge discovery and data mining, 2007, pp. 133–142.
  */
-public class GridCluster extends NonConvexCluster
-{
+public class GridCluster extends NonConvexCluster {
 	private static final long serialVersionUID = -6498733665209706370L;
 	private HashMap<DensityGrid, Boolean> grids;
 	private HashMap<DensityGrid, Boolean> visited;
 	private int clusterLabel;
-	
-	public GridCluster(CFCluster cluster, List<CFCluster> microclusters, int label)
-	{
+
+	public GridCluster(CFCluster cluster, List<CFCluster> microclusters, int label) {
 		super(cluster, microclusters);
-		this.grids = new HashMap<DensityGrid,Boolean>();
+		this.grids = new HashMap<>();
 		this.clusterLabel = label;
 	}
-	
-	public GridCluster(CFCluster cluster, List<CFCluster> microclusters, HashMap<DensityGrid,Boolean> hashMap, int label)
-	{
+
+	public GridCluster(CFCluster cluster, List<CFCluster> microclusters, HashMap<DensityGrid, Boolean> hashMap,
+			int label) {
 		super(cluster, microclusters);
-		this.grids = new HashMap<DensityGrid,Boolean>();
-		
-		for (Map.Entry<DensityGrid, Boolean> grid : hashMap.entrySet())
-		{
+		this.grids = new HashMap<>();
+
+		for (Map.Entry<DensityGrid, Boolean> grid : hashMap.entrySet()) {
 			DensityGrid dg = grid.getKey();
 			Boolean inside = grid.getValue();
-			
-			this.grids.put(dg,  inside);
+
+			this.grids.put(dg, inside);
 		}
-		
+
 		this.clusterLabel = label;
-		
+
 	}
-	
+
 	/**
 	 * @param dg the density grid to add to the cluster
 	 */
-	public void addGrid(DensityGrid dg)
-	{
+	public void addGrid(DensityGrid dg) {
 		Boolean inside = isInside(dg);
 		this.grids.put(dg, inside);
-		
-		for(Map.Entry<DensityGrid, Boolean> gridToUpdate : this.grids.entrySet())
-		{
+
+		for (Map.Entry<DensityGrid, Boolean> gridToUpdate : this.grids.entrySet()) {
 			Boolean inside2U = gridToUpdate.getValue();
-			
-			if(!inside2U)
-			{
+
+			if (!inside2U) {
 				DensityGrid dg2U = gridToUpdate.getKey();
 				this.grids.put(dg2U, this.isInside(dg2U));
 			}
 		}
 	}
-	
+
 	/**
 	 * @param dg the density grid to remove from the cluster
 	 */
-	public void removeGrid(DensityGrid dg)
-	{
+	public void removeGrid(DensityGrid dg) {
 		this.grids.remove(dg);
 	}
-	
+
 	/**
 	 * @param gridClus the GridCluster to be absorbed into this cluster
 	 */
-	public void absorbCluster(GridCluster gridClus)
-	{
+	public void absorbCluster(GridCluster gridClus) {
 		DensityGrid dg;
 		Boolean inside;
 		Iterator<Map.Entry<DensityGrid, Boolean>> grid;
-		HashMap<DensityGrid, Boolean> newCluster = new HashMap<DensityGrid, Boolean>();
-		
-		//System.out.println("Absorb cluster "+gridClus.getClusterLabel()+" into cluster "+this.getClusterLabel()+".");
-		
+		HashMap<DensityGrid, Boolean> newCluster = new HashMap<>();
+
+		// System.out.println("Absorb cluster "+gridClus.getClusterLabel()+" into
+		// cluster "+this.getClusterLabel()+".");
+
 		// Add each density grid from gridClus into this.grids
 		grid = gridClus.getGrids().entrySet().iterator();
-		while (grid.hasNext())
-		{
+		while (grid.hasNext()) {
 			Map.Entry<DensityGrid, Boolean> entry = grid.next();
 			dg = entry.getKey();
 			this.grids.put(dg, false);
 		}
-		//System.out.println("...density grids added");
-		
-		// Determine which density grids in this.grids are 'inside' and which are 'outside'
+		// System.out.println("...density grids added");
+
+		// Determine which density grids in this.grids are 'inside' and which are
+		// 'outside'
 		grid = this.getGrids().entrySet().iterator();
-		while(grid.hasNext())
-		{
+		while (grid.hasNext()) {
 			Map.Entry<DensityGrid, Boolean> entry = grid.next();
 			dg = entry.getKey();
 			inside = isInside(dg);
 			newCluster.put(dg, inside);
 		}
 		this.grids = newCluster;
-		//System.out.println("...inside/outside determined");
+		// System.out.println("...inside/outside determined");
 
 	}
-	
+
 	/**
-	 * Inside Grids are defined in Definition 3.5 of Chen and Tu 2007 as:
-	 * Consider a grid group G and a grid g ∈ G, suppose g =(j1, ··· ,jd), if g has 
-	 * neighboring grids in every dimension i =1, ·· · ,d, then g is an inside grid 
-	 * in G.Otherwise g is an outside grid in G.
-	 * 
+	 * Inside Grids are defined in Definition 3.5 of Chen and Tu 2007 as: Consider a
+	 * grid group G and a grid g ∈ G, suppose g =(j1, ··· ,jd), if g has neighboring
+	 * grids in every dimension i =1, ·· · ,d, then g is an inside grid in
+	 * G.Otherwise g is an outside grid in G.
+	 *
 	 * @param dg the density grid to label as being inside or out
 	 * @return TRUE if g is an inside grid, FALSE otherwise
 	 */
-	public Boolean isInside(DensityGrid dg)
-	{
+	public Boolean isInside(DensityGrid dg) {
 		Iterator<DensityGrid> dgNeighbourhood = dg.getNeighbours().iterator();
-		
-		while(dgNeighbourhood.hasNext())
-		{
+
+		while (dgNeighbourhood.hasNext()) {
 			DensityGrid dgprime = dgNeighbourhood.next();
-			if(!this.grids.containsKey(dgprime))
-			{
+			if (!this.grids.containsKey(dgprime)) {
 				return false;
 			}
 		}
-		
+
 		return true;
 	}
-	
+
 	/**
-	 * Inside Grids are defined in Definition 3.5 of Chen and Tu 2007 as:
-	 * Consider a grid group G and a grid g ∈ G, suppose g =(j1, ··· ,jd), if g has 
-	 * neighboring grids in every dimension i =1, ·· · ,d, then g is an inside grid 
-	 * in G. Otherwise g is an outside grid in G.
-	 * 
-	 * @param dg the density grid being labelled as inside or outside
+	 * Inside Grids are defined in Definition 3.5 of Chen and Tu 2007 as: Consider a
+	 * grid group G and a grid g ∈ G, suppose g =(j1, ··· ,jd), if g has neighboring
+	 * grids in every dimension i =1, ·· · ,d, then g is an inside grid in G.
+	 * Otherwise g is an outside grid in G.
+	 *
+	 * @param dg  the density grid being labelled as inside or outside
 	 * @param dgH the density grid being proposed for addition
 	 * @return TRUE if g would be an inside grid, FALSE otherwise
 	 */
-	public Boolean isInside(DensityGrid dg, DensityGrid dgH)
-	{
+	public Boolean isInside(DensityGrid dg, DensityGrid dgH) {
 		Iterator<DensityGrid> dgNeighbourhood = dg.getNeighbours().iterator();
-		
-		while(dgNeighbourhood.hasNext())
-		{
+
+		while (dgNeighbourhood.hasNext()) {
 			DensityGrid dgprime = dgNeighbourhood.next();
-			if(!this.grids.containsKey(dgprime) && !dgprime.equals(dgH))
-			{
+			if (!this.grids.containsKey(dgprime) && !dgprime.equals(dgH)) {
 				return false;
 			}
 		}
-		
+
 		return true;
 	}
 
@@ -191,18 +177,17 @@ public int getClusterLabel() {
 		return clusterLabel;
 	}
 
-	public HashMap<DensityGrid,Boolean> getGrids()
-	{
+	public HashMap<DensityGrid, Boolean> getGrids() {
 		return this.grids;
 	}
-	
+
 	/**
 	 * @param clusterLabel the class label to assign to the cluster
 	 */
 	public void setClusterLabel(int clusterLabel) {
 		this.clusterLabel = clusterLabel;
 	}
-	
+
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
 		sb.append("Cluster of grids.");
@@ -215,112 +200,105 @@ public void getDescription(StringBuilder sb, int indent) {
 	public double getWeight() {
 		return this.grids.size();
 	}
-	
+
 	/**
-	 * Tests a grid cluster for connectedness according to Definition 3.4, Grid Group, from
-	 * Chen and Tu 2007.
+	 * Tests a grid cluster for connectedness according to Definition 3.4, Grid
+	 * Group, from Chen and Tu 2007.
+	 *
+	 * Selects one density grid in the grid cluster as a starting point and iterates
+	 * repeatedly through its neighbours until no more density grids in the grid
+	 * cluster can be visited.
 	 * 
-	 * Selects one density grid in the grid cluster as a starting point and iterates repeatedly
-	 * through its neighbours until no more density grids in the grid cluster can be visited.
-	 *  
 	 * @return TRUE if the cluster represent one single grid group; FALSE otherwise.
 	 */
-	public boolean isConnected()
-	{
-		this.visited = new HashMap<DensityGrid, Boolean>();
+	public boolean isConnected() {
+		this.visited = new HashMap<>();
 		Iterator<DensityGrid> initIter = this.grids.keySet().iterator();
 		DensityGrid dg;
-		
-		if (initIter.hasNext())
-		{
+
+		if (initIter.hasNext()) {
 			dg = initIter.next();
 			visited.put(dg, this.grids.get(dg));
 			boolean changesMade;
-			
-			do{
+
+			do {
 				changesMade = false;
-				
+
 				Iterator<Map.Entry<DensityGrid, Boolean>> visIter = this.visited.entrySet().iterator();
-				HashMap<DensityGrid, Boolean> toAdd = new HashMap<DensityGrid, Boolean>();
-				
-				while(visIter.hasNext() && toAdd.isEmpty())
-				{
+				HashMap<DensityGrid, Boolean> toAdd = new HashMap<>();
+
+				while (visIter.hasNext() && toAdd.isEmpty()) {
 					Map.Entry<DensityGrid, Boolean> toVisit = visIter.next();
 					DensityGrid dg2V = toVisit.getKey();
-					
+
 					Iterator<DensityGrid> dg2VNeighbourhood = dg2V.getNeighbours().iterator();
-					
-					while(dg2VNeighbourhood.hasNext())
-					{
+
+					while (dg2VNeighbourhood.hasNext()) {
 						DensityGrid dg2VN = dg2VNeighbourhood.next();
-						
-						if(this.grids.containsKey(dg2VN) && !this.visited.containsKey(dg2VN))
+
+						if (this.grids.containsKey(dg2VN) && !this.visited.containsKey(dg2VN))
 							toAdd.put(dg2VN, this.grids.get(dg2VN));
 					}
-					
+
 				}
-				
-				if(!toAdd.isEmpty())
-				{
+
+				if (!toAdd.isEmpty()) {
 					this.visited.putAll(toAdd);
 					changesMade = true;
 				}
-			}while(changesMade);
-			
-		}		
-		
-		if (this.visited.size() == this.grids.size())
-		{
-			//System.out.println("The cluster is still connected. "+this.visited.size()+" of "+this.grids.size()+" reached.");
-			return true;
+			} while (changesMade);
+
 		}
-		else
-		{
-			//System.out.println("The cluster is no longer connected. "+this.visited.size()+" of "+this.grids.size()+" reached.");
+
+		if (this.visited.size() == this.grids.size()) {
+			// System.out.println("The cluster is still connected. "+this.visited.size()+"
+			// of "+this.grids.size()+" reached.");
+			return true;
+		} else {
+			// System.out.println("The cluster is no longer connected.
+			// "+this.visited.size()+" of "+this.grids.size()+" reached.");
 			return false;
 		}
 	}
 
 	/**
-	 * Iterates through the DensityGrids in the cluster and calculates the inclusion probability for each.
-	 * 
+	 * Iterates through the DensityGrids in the cluster and calculates the inclusion
+	 * probability for each.
+	 *
 	 * @return 1.0 if instance matches any of the density grids; 0.0 otherwise.
 	 */
 	@Override
 	public double getInclusionProbability(Instance instance) {
 		Iterator<Map.Entry<DensityGrid, Boolean>> gridIter = grids.entrySet().iterator();
-		
-		while(gridIter.hasNext())
-		{
+
+		while (gridIter.hasNext()) {
 			Map.Entry<DensityGrid, Boolean> grid = gridIter.next();
 			DensityGrid dg = grid.getKey();
-			if(dg.getInclusionProbability(instance) == 1.0)
+			if (dg.getInclusionProbability(instance) == 1.0)
 				return 1.0;
 		}
-		
+
 		return 0.0;
 	}
-	
+
 	/**
 	 * @return a String listing each coordinate of the density grid
 	 */
 	@Override
-	public String toString()
-	{
-		StringBuilder sb = new StringBuilder(10*this.grids.size());
-		for(Map.Entry<DensityGrid, Boolean> grids : this.grids.entrySet())
-		{
+	public String toString() {
+		StringBuilder sb = new StringBuilder(10 * this.grids.size());
+		for (Map.Entry<DensityGrid, Boolean> grids : this.grids.entrySet()) {
 			DensityGrid dg = grids.getKey();
 			Boolean inside = grids.getValue();
-			
-			sb.append("("+dg.toString());
+
+			sb.append("(" + dg.toString());
 			if (inside)
 				sb.append(" In)");
 			else
 				sb.append(" Out)");
 		}
-		
+
 		return sb.toString();
 	}
-	
+
 }
diff --git a/moa/src/main/java/moa/clusterers/kmeanspm/BICO.java b/moa/src/main/java/moa/learners/clusterers/kmeanspm/BICO.java
similarity index 76%
rename from moa/src/main/java/moa/clusterers/kmeanspm/BICO.java
rename to moa/src/main/java/moa/learners/clusterers/kmeanspm/BICO.java
index 788892add..a06ac0dce 100644
--- a/moa/src/main/java/moa/clusterers/kmeanspm/BICO.java
+++ b/moa/src/main/java/moa/learners/clusterers/kmeanspm/BICO.java
@@ -17,7 +17,7 @@
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
  *
  */
-package moa.clusterers.kmeanspm;
+package moa.learners.clusterers.kmeanspm;
 
 import java.io.IOException;
 import java.io.Writer;
@@ -33,38 +33,33 @@
 import moa.cluster.Cluster;
 import moa.cluster.Clustering;
 import moa.cluster.SphereCluster;
-import moa.clusterers.AbstractClusterer;
 import moa.core.AutoExpandVector;
 import moa.core.Measurement;
+import moa.learners.clusterers.AbstractClusterer;
 
 /**
  * A instance of this class provides the BICO clustering algorithm.
  *
- * Citation: Hendrik Fichtenberger, Marc Gillé, Melanie Schmidt,
- * Chris Schwiegelshohn, Christian Sohler:
- * BICO: BIRCH Meets Coresets for k-Means Clustering.
- * ESA 2013: 481-492 (2013)
- * http://ls2-www.cs.tu-dortmund.de/bico/
+ * Citation: Hendrik Fichtenberger, Marc Gillé, Melanie Schmidt, Chris
+ * Schwiegelshohn, Christian Sohler: BICO: BIRCH Meets Coresets for k-Means
+ * Clustering. ESA 2013: 481-492 (2013) http://ls2-www.cs.tu-dortmund.de/bico/
  *
  */
 public class BICO extends AbstractClusterer {
 
 	private static final long serialVersionUID = 1L;
 
-	public IntOption numClustersOption = new IntOption("Cluster", 'k',
-			"Number of desired centers.", 5, 1, Integer.MAX_VALUE);
+	public IntOption numClustersOption = new IntOption("Cluster", 'k', "Number of desired centers.", 5, 1,
+			Integer.MAX_VALUE);
 
 	public IntOption numDimensionsOption = new IntOption("Dimensions", 'd',
-			"Number of the dimensions of the input points.", 10, 1,
-			Integer.MAX_VALUE);
+			"Number of the dimensions of the input points.", 10, 1, Integer.MAX_VALUE);
 
-	public IntOption maxNumClusterFeaturesOption = new IntOption(
-			"MaxClusterFeatures", 'n', "Maximum size of the coreset.", 5 * 200, 1,
-			Integer.MAX_VALUE);
+	public IntOption maxNumClusterFeaturesOption = new IntOption("MaxClusterFeatures", 'n',
+			"Maximum size of the coreset.", 5 * 200, 1, Integer.MAX_VALUE);
 
 	public IntOption numProjectionsOption = new IntOption("Projections", 'p',
-			"Number of random projections used for the nearest neighbour search.",
-			10, 1, Integer.MAX_VALUE);
+			"Number of random projections used for the nearest neighbour search.", 10, 1, Integer.MAX_VALUE);
 
 	protected int numClusters;
 	protected int numDimensions;
@@ -83,7 +78,7 @@ public class BICO extends AbstractClusterer {
 	/*
 	 * (non-Javadoc)
 	 *
-	 * @see moa.clusterers.Clusterer#isRandomizable()
+	 * @see moa.learners.clusterers.Clusterer#isRandomizable()
 	 */
 	@Override
 	public boolean isRandomizable() {
@@ -93,7 +88,7 @@ public boolean isRandomizable() {
 	/*
 	 * (non-Javadoc)
 	 *
-	 * @see moa.clusterers.AbstractClusterer#implementsMicroClusterer()
+	 * @see moa.learners.clusterers.AbstractClusterer#implementsMicroClusterer()
 	 */
 	@Override
 	public boolean implementsMicroClusterer() {
@@ -103,21 +98,18 @@ public boolean implementsMicroClusterer() {
 	/*
 	 * (non-Javadoc)
 	 *
-	 * @see moa.clusterers.AbstractClusterer#getMicroClusteringResult()
+	 * @see moa.learners.clusterers.AbstractClusterer#getMicroClusteringResult()
 	 */
 	@Override
 	public Clustering getMicroClusteringResult() {
-		return this.root.addToClustering(new Clustering(
-				new AutoExpandVector<Cluster>(this.rootCount)));
+		return this.root.addToClustering(new Clustering(new AutoExpandVector<Cluster>(this.rootCount)));
 	}
 
 	/**
 	 * Writes all micro cluster to a given stream.
 	 *
-	 * @param stream
-	 *            the stream
-	 * @throws IOException
-	 *            If an I/O error occurs
+	 * @param stream the stream
+	 * @throws IOException If an I/O error occurs
 	 */
 	public void printMicroClusteringResult(Writer stream) throws IOException {
 		this.root.printClusteringCenters(stream);
@@ -135,7 +127,7 @@ public int getMicroClusteringSize() {
 	/*
 	 * (non-Javadoc)
 	 *
-	 * @see moa.clusterers.Clusterer#getPredictionForInstance(weka.core.Instance)
+	 * @see moa.learners.clusterers.Clusterer#getPredictionForInstance(weka.core.Instance)
 	 */
 	@Override
 	public Prediction getPredictionForInstance(Instance inst) {
@@ -145,7 +137,7 @@ public Prediction getPredictionForInstance(Instance inst) {
 	/*
 	 * (non-Javadoc)
 	 *
-	 * @see moa.clusterers.Clusterer#getClusteringResult()
+	 * @see moa.learners.clusterers.Clusterer#getClusteringResult()
 	 */
 	@Override
 	public Clustering getClusteringResult() {
@@ -153,7 +145,7 @@ public Clustering getClusteringResult() {
 		// If the buffer phase is active then the buffer (without duplicates) is
 		// equal to the micro clustering
 		if (this.bufferPhase) {
-			microClustering = new ArrayList<double[]>(this.buffer.size());
+			microClustering = new ArrayList<>(this.buffer.size());
 			for (double[] pointA : this.buffer) {
 				// Searches for a duplicate of the current point
 				boolean duplicate = false;
@@ -182,17 +174,15 @@ public Clustering getClusteringResult() {
 			}
 		} else {
 			// Collects all nodes as arrays with the weight in the first element
-			microClustering = this.root
-					.addToClusteringCenters(new ArrayList<double[]>(this.rootCount));
+			microClustering = this.root.addToClusteringCenters(new ArrayList<double[]>(this.rootCount));
 		}
 		// Runs the k-means algorithm five times on the micro clustering
 		List<double[]> result = null;
 		double minValue = Double.POSITIVE_INFINITY;
 		for (int i = 0; i < 5; i++) {
 			// Creates the starting centroids
-			List<double[]> newResult = CoresetKMeans
-					.generatekMeansPlusPlusCentroids(this.numClusters,
-							microClustering, this.clustererRandom);
+			List<double[]> newResult = CoresetKMeans.generatekMeansPlusPlusCentroids(this.numClusters, microClustering,
+					this.clustererRandom);
 			// Runs the k-means algorithm with changing the starting centroids
 			double newValue = CoresetKMeans.kMeans(newResult, microClustering);
 			// Selects the result with minimum costs
@@ -203,8 +193,7 @@ public Clustering getClusteringResult() {
 		}
 
 		// Prepares the points for the clustering result
-		AutoExpandVector<Cluster> resultClustering = new AutoExpandVector<Cluster>(
-				result.size());
+		AutoExpandVector<Cluster> resultClustering = new AutoExpandVector<>(result.size());
 		for (double[] point : result) {
 			resultClustering.add(new SphereCluster(point, 0.0));
 		}
@@ -214,7 +203,7 @@ public Clustering getClusteringResult() {
 	/*
 	 * (non-Javadoc)
 	 *
-	 * @see moa.clusterers.AbstractClusterer#resetLearningImpl()
+	 * @see moa.learners.clusterers.AbstractClusterer#resetLearningImpl()
 	 */
 	@Override
 	public void resetLearningImpl() {
@@ -224,16 +213,13 @@ public void resetLearningImpl() {
 		this.numProjections = this.numProjectionsOption.getValue();
 
 		this.bufferPhase = true;
-		this.buffer = new ArrayList<double[]>(
-				this.maxNumClusterFeaturesOption.getValue() + 1);
+		this.buffer = new ArrayList<>(this.maxNumClusterFeaturesOption.getValue() + 1);
 		this.minDistance = Double.POSITIVE_INFINITY;
 		this.pairwiseDifferent = 0;
 
-		int hashSize = (int) Math.ceil(Math.log(
-				5 * this.maxNumClusterFeaturesOption.getValue()) / Math.log(2));
-		this.root = new ClusteringTreeHeadNode(null, new ClusteringFeature(
-				new double[0], 1), this.numDimensionsOption.getValue(),
-				this.numProjectionsOption.getValue(), Math.min(hashSize, 30),
+		int hashSize = (int) Math.ceil(Math.log(5 * this.maxNumClusterFeaturesOption.getValue()) / Math.log(2));
+		this.root = new ClusteringTreeHeadNode(null, new ClusteringFeature(new double[0], 1),
+				this.numDimensionsOption.getValue(), this.numProjectionsOption.getValue(), Math.min(hashSize, 30),
 				this.clustererRandom);
 		this.rootCount = 0;
 	}
@@ -241,15 +227,14 @@ public void resetLearningImpl() {
 	/*
 	 * (non-Javadoc)
 	 *
-	 * @see
-	 * moa.clusterers.AbstractClusterer#trainOnInstanceImpl(weka.core.Instance)
+	 * @see moa.learners.clusterers.AbstractClusterer#trainOnInstanceImpl(weka.core.Instance)
 	 */
 	@Override
 	public void trainOnInstanceImpl(Instance inst) {
 		double[] x = inst.toDoubleArray();
 		if (this.numDimensions != x.length) {
-			System.out.println("Line skipped because line dimension is "
-					+ x.length + " instead of " + this.numDimensions);
+			System.out.println(
+					"Line skipped because line dimension is " + x.length + " instead of " + this.numDimensions);
 			return;
 		}
 		// Starts with the buffer phase to calculate the starting threshold
@@ -289,8 +274,7 @@ public void trainOnInstanceImpl(Instance inst) {
 	/**
 	 * Inserts a new point into the ClusteringFeature tree.
 	 *
-	 * @param x
-	 *            the point
+	 * @param x the point
 	 */
 	protected void bicoUpdate(double[] x) {
 		assert (!this.bufferPhase && this.numDimensions == x.length);
@@ -300,9 +284,7 @@ protected void bicoUpdate(double[] x) {
 		while (true) {
 			ClusteringTreeNode y = r.nearestChild(x);
 			// Checks if the point can not be added to the current level
-			if (r.hasNoChildren()
-					|| y == null
-					|| Metric.distanceSquared(x, y.getCenter()) > calcRSquared(i)) {
+			if (r.hasNoChildren() || y == null || Metric.distanceSquared(x, y.getCenter()) > calcRSquared(i)) {
 				// Creates a new node for the point and adds it to the current
 				// root node
 				r.addChild(new ClusteringTreeNode(x, new ClusteringFeature(x, calcR(i))));
@@ -329,9 +311,9 @@ protected void bicoUpdate(double[] x) {
 	}
 
 	/**
-	 * If the number of ClusteringTreeNodes exceeds the maximum bound, the
-	 * global threshold T will be doubled and the tree will be rebuild with the
-	 * new threshold.
+	 * If the number of ClusteringTreeNodes exceeds the maximum bound, the global
+	 * threshold T will be doubled and the tree will be rebuild with the new
+	 * threshold.
 	 *
 	 */
 	protected void rebuild() {
@@ -341,7 +323,7 @@ protected void rebuild() {
 			this.T *= 2.0;
 			this.root.setThreshold(calcRSquared(1));
 			// Adds all nodes to the ClusteringFeature tree again
-			Queue<ClusteringTreeNode> Q = new LinkedList<ClusteringTreeNode>();
+			Queue<ClusteringTreeNode> Q = new LinkedList<>();
 			Q.addAll(this.root.getChildren());
 			this.root.clearChildren();
 			this.rootCount = 0;
@@ -358,8 +340,7 @@ protected void rebuild() {
 	/**
 	 * Inserts a ClusteringTreeNode into the ClusteringFeature tree.
 	 *
-	 * @param x
-	 *            the ClusteringTreeNode
+	 * @param x the ClusteringTreeNode
 	 */
 	protected void bicoCFUpdate(ClusteringTreeNode x) {
 		// Starts with the global root node as the current root node
@@ -368,8 +349,7 @@ protected void bicoCFUpdate(ClusteringTreeNode x) {
 		while (true) {
 			ClusteringTreeNode y = r.nearestChild(x.getCenter());
 			// Checks if the node can not be merged to the current level
-			if (r.hasNoChildren()
-					|| y == null
+			if (r.hasNoChildren() || y == null
 					|| Metric.distanceSquared(x.getCenter(), y.getCenter()) > calcRSquared(i)) {
 				// Adds the node to the current root node
 				x.setThreshold(calcR(i));
@@ -379,8 +359,7 @@ protected void bicoCFUpdate(ClusteringTreeNode x) {
 			} else {
 				// Checks if the node can be merged to the nearest node without
 				// exceeding the global threshold
-				if (y.getClusteringFeature().calcKMeansCosts(y.getCenter(),
-						x.getClusteringFeature()) <= this.T) {
+				if (y.getClusteringFeature().calcKMeansCosts(y.getCenter(), x.getClusteringFeature()) <= this.T) {
 					// Merges the ClusteringFeature of the node to the
 					// ClusteringFeature of the nearest node
 					y.getClusteringFeature().merge(x.getClusteringFeature());
@@ -395,23 +374,20 @@ protected void bicoCFUpdate(ClusteringTreeNode x) {
 	}
 
 	/**
-	 * Calculates the squared threshold at a specific level in the
-	 * ClusteringFeature tree.
+	 * Calculates the squared threshold at a specific level in the ClusteringFeature
+	 * tree.
 	 *
-	 * @param level
-	 *            level in the tree
+	 * @param level level in the tree
 	 * @return the squared threshold
 	 */
 	protected double calcRSquared(int level) {
-		return this.T / (double) (1 << (3 + level));
+		return this.T / (1 << (3 + level));
 	}
 
 	/**
-	 * Calculates the threshold at a specific level in the ClusteringFeature
-	 * tree.
+	 * Calculates the threshold at a specific level in the ClusteringFeature tree.
 	 *
-	 * @param level
-	 *            level in the tree
+	 * @param level level in the tree
 	 * @return the threshold
 	 */
 	protected double calcR(int level) {
@@ -421,7 +397,7 @@ protected double calcR(int level) {
 	/*
 	 * (non-Javadoc)
 	 *
-	 * @see moa.clusterers.AbstractClusterer#getModelMeasurementsImpl()
+	 * @see moa.learners.clusterers.AbstractClusterer#getModelMeasurementsImpl()
 	 */
 	@Override
 	protected Measurement[] getModelMeasurementsImpl() {
@@ -432,7 +408,8 @@ protected Measurement[] getModelMeasurementsImpl() {
 	 * (non-Javadoc)
 	 *
 	 * @see
-	 * moa.clusterers.AbstractClusterer#getModelDescription(java.lang.StringBuilder, int)
+	 * moa.learners.clusterers.AbstractClusterer#getModelDescription(java.lang.StringBuilder,
+	 * int)
 	 */
 	@Override
 	public void getModelDescription(StringBuilder out, int indent) {
diff --git a/moa/src/main/java/moa/clusterers/kmeanspm/ClusteringFeature.java b/moa/src/main/java/moa/learners/clusterers/kmeanspm/ClusteringFeature.java
similarity index 72%
rename from moa/src/main/java/moa/clusterers/kmeanspm/ClusteringFeature.java
rename to moa/src/main/java/moa/learners/clusterers/kmeanspm/ClusteringFeature.java
index 58512cd54..8e8f77f80 100644
--- a/moa/src/main/java/moa/clusterers/kmeanspm/ClusteringFeature.java
+++ b/moa/src/main/java/moa/learners/clusterers/kmeanspm/ClusteringFeature.java
@@ -17,7 +17,7 @@
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
  *
  */
-package moa.clusterers.kmeanspm;
+package moa.learners.clusterers.kmeanspm;
 
 import java.io.IOException;
 import java.io.Writer;
@@ -28,11 +28,9 @@
 /**
  * Provides a ClusteringFeature.
  *
- * Citation: Hendrik Fichtenberger, Marc Gillé, Melanie Schmidt,
- * Chris Schwiegelshohn, Christian Sohler:
- * BICO: BIRCH Meets Coresets for k-Means Clustering.
- * ESA 2013: 481-492 (2013)
- * http://ls2-www.cs.tu-dortmund.de/bico/
+ * Citation: Hendrik Fichtenberger, Marc Gillé, Melanie Schmidt, Chris
+ * Schwiegelshohn, Christian Sohler: BICO: BIRCH Meets Coresets for k-Means
+ * Clustering. ESA 2013: 481-492 (2013) http://ls2-www.cs.tu-dortmund.de/bico/
  *
  */
 public class ClusteringFeature extends SphereCluster {
@@ -46,19 +44,14 @@ public class ClusteringFeature extends SphereCluster {
 	/**
 	 * Creates a ClusteringFeature.
 	 *
-	 * @param center
-	 *            the center point
-	 * @param numPoints
-	 *            the number of points
-	 * @param sumPoints
-	 *            the sum of all points
-	 * @param sumSquaredPoints
-	 *            the sum of the squared lengths
-	 * @param radius
-	 *            the radius
+	 * @param center           the center point
+	 * @param numPoints        the number of points
+	 * @param sumPoints        the sum of all points
+	 * @param sumSquaredPoints the sum of the squared lengths
+	 * @param radius           the radius
 	 */
-	public ClusteringFeature(double[] center, int numPoints,
-			double[] sumPoints, double sumSquaredPoints, double radius) {
+	public ClusteringFeature(double[] center, int numPoints, double[] sumPoints, double sumSquaredPoints,
+			double radius) {
 		super(center, radius, numPoints);
 		assert (center.length == sumPoints.length);
 		this.numPoints = numPoints;
@@ -69,10 +62,8 @@ public ClusteringFeature(double[] center, int numPoints,
 	/**
 	 * Creates a ClusteringFeature.
 	 *
-	 * @param center
-	 *            the center point
-	 * @param radius
-	 *            the radius
+	 * @param center the center point
+	 * @param radius the radius
 	 */
 	public ClusteringFeature(double[] center, double radius) {
 		super(center, radius, 1);
@@ -85,12 +76,9 @@ public ClusteringFeature(double[] center, double radius) {
 	/**
 	 * Adds a point to the ClusteringFeature.
 	 *
-	 * @param numPoints
-	 *            the number of points to add
-	 * @param sumPoints
-	 *            the sum of points to add
-	 * @param sumSquaredPoints
-	 *            the sum of the squared lengths to add
+	 * @param numPoints        the number of points to add
+	 * @param sumPoints        the sum of points to add
+	 * @param sumSquaredPoints the sum of the squared lengths to add
 	 */
 	public void add(int numPoints, double[] sumPoints, double sumSquaredPoints) {
 		assert (this.sumPoints.length == sumPoints.length);
@@ -105,8 +93,7 @@ public void add(int numPoints, double[] sumPoints, double sumSquaredPoints) {
 	/**
 	 * Merges the ClusteringFeature with an other ClusteringFeature.
 	 *
-	 * @param x
-	 *            the ClusteringFeature to merge with
+	 * @param x the ClusteringFeature to merge with
 	 */
 	public void merge(ClusteringFeature x) {
 		assert (this.sumPoints.length == x.sumPoints.length);
@@ -150,10 +137,8 @@ public double[] toClusterCenter() {
 	/**
 	 * Writes the cluster center to a given stream.
 	 *
-	 * @param stream
-	 *            the stream
-	 * @throws IOException
-	 *            If an I/O error occurs
+	 * @param stream the stream
+	 * @throws IOException If an I/O error occurs
 	 */
 	public void printClusterCenter(Writer stream) throws IOException {
 		stream.write(String.valueOf(this.numPoints));
@@ -176,8 +161,7 @@ public int getNumPoints() {
 	/**
 	 * Sets the number of points of the ClusteringFeature.
 	 *
-	 * @param numPoints
-	 *            the number of points of the ClusteringFeature to set
+	 * @param numPoints the number of points of the ClusteringFeature to set
 	 */
 	public void setNumPoints(int numPoints) {
 		this.numPoints = numPoints;
@@ -196,8 +180,7 @@ public double[] getSumPoints() {
 	/**
 	 * Sets the sum of points of the ClusteringFeature.
 	 *
-	 * @param sumPoints
-	 *            the sum of points of the ClusteringFeature to set
+	 * @param sumPoints the sum of points of the ClusteringFeature to set
 	 */
 	public void setSumPoints(double[] sumPoints) {
 		assert (this.sumPoints.length == sumPoints.length);
@@ -216,8 +199,8 @@ public double getSumSquaredLength() {
 	/**
 	 * Sets the sum of the squared lengths of the ClusteringFeature.
 	 *
-	 * @param sumSquaredLength
-	 *            the sum of the squared lengths of the ClusteringFeature to set
+	 * @param sumSquaredLength the sum of the squared lengths of the
+	 *                         ClusteringFeature to set
 	 */
 	public void setSumSquaredLength(double sumSquaredLength) {
 		this.sumSquaredLength = sumSquaredLength;
@@ -235,8 +218,7 @@ public double getThreshold() {
 	/**
 	 * Sets the threshold of the ClusteringFeature.
 	 *
-	 * @param threshold
-	 *            the threshold of the ClusteringFeature to set
+	 * @param threshold the threshold of the ClusteringFeature to set
 	 */
 	public void setThreshold(double threshold) {
 		super.setRadius(threshold);
@@ -255,32 +237,27 @@ public void getDescription(StringBuilder sb, int indent) {
 	/**
 	 * Calculates the k-means costs of the ClusteringFeature too a center.
 	 *
-	 * @param center
-	 *            the center too calculate the costs
+	 * @param center the center too calculate the costs
 	 * @return the costs
 	 */
 	public double calcKMeansCosts(double[] center) {
 		assert (this.sumPoints.length == center.length);
-		return this.sumSquaredLength - 2
-				* Metric.dotProduct(this.sumPoints, center) + this.numPoints
-				* Metric.dotProduct(center);
+		return this.sumSquaredLength - 2 * Metric.dotProduct(this.sumPoints, center)
+				+ this.numPoints * Metric.dotProduct(center);
 	}
 
 	/**
 	 * Calculates the k-means costs of the ClusteringFeature and a point too a
 	 * center.
 	 *
-	 * @param center
-	 *            the center too calculate the costs
-	 * @param point
-	 *            the point too calculate the costs
+	 * @param center the center too calculate the costs
+	 * @param point  the point too calculate the costs
 	 * @return the costs
 	 */
 	public double calcKMeansCosts(double[] center, double[] point) {
-		assert (this.sumPoints.length == center.length &&
-				this.sumPoints.length == point.length);
-		return (this.sumSquaredLength + Metric.distanceSquared(point)) - 2
-				* Metric.dotProductWithAddition(this.sumPoints, point, center)
+		assert (this.sumPoints.length == center.length && this.sumPoints.length == point.length);
+		return (this.sumSquaredLength + Metric.distanceSquared(point))
+				- 2 * Metric.dotProductWithAddition(this.sumPoints, point, center)
 				+ (this.numPoints + 1) * Metric.dotProduct(center);
 	}
 
@@ -288,20 +265,15 @@ public double calcKMeansCosts(double[] center, double[] point) {
 	 * Calculates the k-means costs of the ClusteringFeature and another
 	 * ClusteringFeature too a center.
 	 *
-	 * @param center
-	 *            the center too calculate the costs
-	 * @param points
-	 *            the points too calculate the costs
+	 * @param center the center too calculate the costs
+	 * @param points the points too calculate the costs
 	 * @return the costs
 	 */
 	public double calcKMeansCosts(double[] center, ClusteringFeature points) {
-		assert (this.sumPoints.length == center.length &&
-				this.sumPoints.length == points.sumPoints.length);
+		assert (this.sumPoints.length == center.length && this.sumPoints.length == points.sumPoints.length);
 		return (this.sumSquaredLength + points.sumSquaredLength)
-				- 2 * Metric.dotProductWithAddition(this.sumPoints,
-						points.sumPoints, center)
-				+ (this.numPoints + points.numPoints)
-				* Metric.dotProduct(center);
+				- 2 * Metric.dotProductWithAddition(this.sumPoints, points.sumPoints, center)
+				+ (this.numPoints + points.numPoints) * Metric.dotProduct(center);
 	}
 
 }
diff --git a/moa/src/main/java/moa/clusterers/kmeanspm/ClusteringTreeHeadNode.java b/moa/src/main/java/moa/learners/clusterers/kmeanspm/ClusteringTreeHeadNode.java
similarity index 70%
rename from moa/src/main/java/moa/clusterers/kmeanspm/ClusteringTreeHeadNode.java
rename to moa/src/main/java/moa/learners/clusterers/kmeanspm/ClusteringTreeHeadNode.java
index 608198c4d..56013394d 100644
--- a/moa/src/main/java/moa/clusterers/kmeanspm/ClusteringTreeHeadNode.java
+++ b/moa/src/main/java/moa/learners/clusterers/kmeanspm/ClusteringTreeHeadNode.java
@@ -17,7 +17,7 @@
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
  *
  */
-package moa.clusterers.kmeanspm;
+package moa.learners.clusterers.kmeanspm;
 
 import java.util.ArrayList;
 import java.util.Iterator;
@@ -28,11 +28,9 @@
  * Provides a ClusteringTreeNode with an extended nearest neighbor search in the
  * root.
  *
- * Citation: Hendrik Fichtenberger, Marc Gillé, Melanie Schmidt,
- * Chris Schwiegelshohn, Christian Sohler:
- * BICO: BIRCH Meets Coresets for k-Means Clustering.
- * ESA 2013: 481-492 (2013)
- * http://ls2-www.cs.tu-dortmund.de/bico/
+ * Citation: Hendrik Fichtenberger, Marc Gillé, Melanie Schmidt, Chris
+ * Schwiegelshohn, Christian Sohler: BICO: BIRCH Meets Coresets for k-Means
+ * Clustering. ESA 2013: 481-492 (2013) http://ls2-www.cs.tu-dortmund.de/bico/
  *
  */
 public class ClusteringTreeHeadNode extends ClusteringTreeNode {
@@ -46,26 +44,22 @@ public class ClusteringTreeHeadNode extends ClusteringTreeNode {
 	private List<CuckooHashing<List<ClusteringTreeNode>>> buckets;
 
 	/**
-	 * Creates a ClusteringTreeNode with an extended nearest neighbor search in
-	 * the root.
+	 * Creates a ClusteringTreeNode with an extended nearest neighbor search in the
+	 * root.
 	 *
-	 * @param dimension
-	 *            the number of dimensions of the points
-	 * @param numProjections
-	 *            the number of projections to use for the nearest neighbor
-	 *            search
-	 * @param hashSize
-	 *            size of the hash function (must be smaller than 31)
-	 * @param random
-	 *            instance to generate a stream of pseudorandom numbers
+	 * @param dimension      the number of dimensions of the points
+	 * @param numProjections the number of projections to use for the nearest
+	 *                       neighbor search
+	 * @param hashSize       size of the hash function (must be smaller than 31)
+	 * @param random         instance to generate a stream of pseudorandom numbers
 	 */
-	public ClusteringTreeHeadNode(double[] center, ClusteringFeature cf,
-			int dimension, int numProjections, int hashSize, Random random) {
+	public ClusteringTreeHeadNode(double[] center, ClusteringFeature cf, int dimension, int numProjections,
+			int hashSize, Random random) {
 		super(center, cf);
-		assert(hashSize < 31);
+		assert (hashSize < 31);
 		this.numProjections = numProjections;
 
-		this.projections = new ArrayList<double[]>(numProjections);
+		this.projections = new ArrayList<>(numProjections);
 		for (int i = 0; i < numProjections; i++) {
 			double[] current = new double[dimension];
 			double norm = 0.0;
@@ -81,36 +75,29 @@ public ClusteringTreeHeadNode(double[] center, ClusteringFeature cf,
 			this.projections.add(current);
 		}
 
-		this.buckets = new ArrayList<CuckooHashing<List<ClusteringTreeNode>>>(
-				numProjections);
+		this.buckets = new ArrayList<>(numProjections);
 		for (int i = 0; i < numProjections; i++) {
-			this.buckets.add(new CuckooHashing<List<ClusteringTreeNode>>(
-					hashSize, random));
+			this.buckets.add(new CuckooHashing<List<ClusteringTreeNode>>(hashSize, random));
 		}
 	}
 
 	/**
 	 * Projects a point to a random projection.
 	 *
-	 * @param pointA
-	 *            the point to project
-	 * @param i
-	 *            the index of the projection
+	 * @param pointA the point to project
+	 * @param i      the index of the projection
 	 * @return the position of the point
 	 */
 	private double project(double[] pointA, int i) {
-		assert (this.projections.size() < i &&
-				this.projections.get(i).length == pointA.length);
+		assert (this.projections.size() < i && this.projections.get(i).length == pointA.length);
 		return Metric.dotProduct(pointA, this.projections.get(i));
 	}
 
 	/**
 	 * Projects a point to a random projection.
 	 *
-	 * @param pointA
-	 *            the point to project
-	 * @param i
-	 *            the projection
+	 * @param pointA the point to project
+	 * @param i      the projection
 	 * @return the position of the point
 	 */
 	private double project(double[] pointA, double[] i) {
@@ -121,8 +108,7 @@ private double project(double[] pointA, double[] i) {
 	/**
 	 * Calculates the bucket number.
 	 *
-	 * @param val
-	 *            position of the point
+	 * @param val position of the point
 	 * @return the bucket number
 	 */
 	private long calcBucketNumber(double val) {
@@ -136,22 +122,17 @@ private long calcBucketNumber(double val) {
 	 */
 	@Override
 	public ClusteringTreeNode nearestChild(double[] pointA) {
-		assert (this.projections.size() > 0 &&
-				this.projections.get(0).length == pointA.length);
+		assert (this.projections.size() > 0 && this.projections.get(0).length == pointA.length);
 		int minBucketProjection = -1;
 		int minSize = Integer.MAX_VALUE;
 		Iterator<double[]> iIterProjections = this.projections.iterator();
-		Iterator<CuckooHashing<List<ClusteringTreeNode>>> iIterBuckets = this.buckets
-				.iterator();
+		Iterator<CuckooHashing<List<ClusteringTreeNode>>> iIterBuckets = this.buckets.iterator();
 		int size = this.projections.size();
 		for (int i = 0; i < size; i++) {
-			long bucketNumber = calcBucketNumber(project(pointA,
-					iIterProjections.next()));
-			List<ClusteringTreeNode> currentBucket = iIterBuckets.next().get(
-					bucketNumber);
+			long bucketNumber = calcBucketNumber(project(pointA, iIterProjections.next()));
+			List<ClusteringTreeNode> currentBucket = iIterBuckets.next().get(bucketNumber);
 			int bucketSize;
-			if (currentBucket != null
-					&& (bucketSize = currentBucket.size()) <= minSize) {
+			if (currentBucket != null && (bucketSize = currentBucket.size()) <= minSize) {
 				minBucketProjection = i;
 				minSize = bucketSize;
 			}
@@ -160,13 +141,11 @@ public ClusteringTreeNode nearestChild(double[] pointA) {
 			return null;
 		}
 
-		long bucketNumber = calcBucketNumber(project(pointA,
-				minBucketProjection));
+		long bucketNumber = calcBucketNumber(project(pointA, minBucketProjection));
 		double minDistance = Double.POSITIVE_INFINITY;
 		ClusteringTreeNode min = null;
 		// for (int i = -1; i <= 1; i++) {
-		List<ClusteringTreeNode> currentBucket = this.buckets.get(
-				minBucketProjection).get(bucketNumber);// + i);
+		List<ClusteringTreeNode> currentBucket = this.buckets.get(minBucketProjection).get(bucketNumber);// + i);
 		if (currentBucket != null) {
 			for (ClusteringTreeNode node : currentBucket) {
 				double d = Metric.distance(pointA, node.getCenter());
@@ -188,21 +167,17 @@ public ClusteringTreeNode nearestChild(double[] pointA) {
 	 */
 	@Override
 	public boolean addChild(ClusteringTreeNode e) {
-		assert (this.projections.get(0).length == e.getClusteringFeature()
-				.getCenter().length);
+		assert (this.projections.get(0).length == e.getClusteringFeature().getCenter().length);
 		super.addChild(e);
 		Iterator<double[]> iIterProjections = this.projections.iterator();
-		Iterator<CuckooHashing<List<ClusteringTreeNode>>> iIterBuckets = this.buckets
-				.iterator();
+		Iterator<CuckooHashing<List<ClusteringTreeNode>>> iIterBuckets = this.buckets.iterator();
 		int size = this.projections.size();
 		for (int i = 0; i < size; i++) {
-			long bucketNumber = calcBucketNumber(project(e.getCenter(),
-					iIterProjections.next()));
-			CuckooHashing<List<ClusteringTreeNode>> currentBuckets = iIterBuckets
-					.next();
+			long bucketNumber = calcBucketNumber(project(e.getCenter(), iIterProjections.next()));
+			CuckooHashing<List<ClusteringTreeNode>> currentBuckets = iIterBuckets.next();
 			List<ClusteringTreeNode> bucket = currentBuckets.get(bucketNumber);
 			if (bucket == null) {
-				bucket = new ArrayList<ClusteringTreeNode>(1);
+				bucket = new ArrayList<>(1);
 				currentBuckets.put(bucketNumber, bucket);
 			}
 			bucket.add(e);
diff --git a/moa/src/main/java/moa/clusterers/kmeanspm/ClusteringTreeNode.java b/moa/src/main/java/moa/learners/clusterers/kmeanspm/ClusteringTreeNode.java
similarity index 85%
rename from moa/src/main/java/moa/clusterers/kmeanspm/ClusteringTreeNode.java
rename to moa/src/main/java/moa/learners/clusterers/kmeanspm/ClusteringTreeNode.java
index 731fae34e..38eae16fc 100644
--- a/moa/src/main/java/moa/clusterers/kmeanspm/ClusteringTreeNode.java
+++ b/moa/src/main/java/moa/learners/clusterers/kmeanspm/ClusteringTreeNode.java
@@ -17,7 +17,7 @@
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
  *
  */
-package moa.clusterers.kmeanspm;
+package moa.learners.clusterers.kmeanspm;
 
 import java.io.IOException;
 import java.io.Writer;
@@ -31,11 +31,9 @@
 /**
  * Provides a tree of ClusterFeatures.
  *
- * Citation: Hendrik Fichtenberger, Marc Gillé, Melanie Schmidt,
- * Chris Schwiegelshohn, Christian Sohler:
- * BICO: BIRCH Meets Coresets for k-Means Clustering.
- * ESA 2013: 481-492 (2013)
- * http://ls2-www.cs.tu-dortmund.de/bico/
+ * Citation: Hendrik Fichtenberger, Marc Gillé, Melanie Schmidt, Chris
+ * Schwiegelshohn, Christian Sohler: BICO: BIRCH Meets Coresets for k-Means
+ * Clustering. ESA 2013: 481-492 (2013) http://ls2-www.cs.tu-dortmund.de/bico/
  *
  */
 public class ClusteringTreeNode extends AbstractMOAObject {
@@ -49,16 +47,14 @@ public class ClusteringTreeNode extends AbstractMOAObject {
 	/**
 	 * Creates a tree node for a ClusterFeature.
 	 *
-	 * @param center
-	 *            representation of the ClusterFeature
-	 * @param cf
-	 *            the ClusterFeature
+	 * @param center representation of the ClusterFeature
+	 * @param cf     the ClusterFeature
 	 */
 	public ClusteringTreeNode(double[] center, ClusteringFeature cf) {
 		assert (center == null || center.length == cf.getSumPoints().length);
 		this.center = center;
 		this.clusteringFeature = cf;
-		this.children = new ArrayList<ClusteringTreeNode>();
+		this.children = new ArrayList<>();
 	}
 
 	/**
@@ -80,8 +76,7 @@ public int count() {
 	 * Adds all ClusterFeatures of the tree with this node as the root to a
 	 * Clustering.
 	 *
-	 * @param clustering
-	 *            the Clustering to add the ClusterFeatures too.
+	 * @param clustering the Clustering to add the ClusterFeatures too.
 	 * @return the input Clustering
 	 */
 	public Clustering addToClustering(Clustering clustering) {
@@ -95,11 +90,10 @@ public Clustering addToClustering(Clustering clustering) {
 	}
 
 	/**
-	 * Adds all clustering centers of the ClusterFeatures of the tree with this
-	 * node as the root to a List of points.
+	 * Adds all clustering centers of the ClusterFeatures of the tree with this node
+	 * as the root to a List of points.
 	 *
-	 * @param clustering
-	 *            the List to add the clustering centers too.
+	 * @param clustering the List to add the clustering centers too.
 	 * @return the input List
 	 */
 	public List<double[]> addToClusteringCenters(List<double[]> clustering) {
@@ -116,10 +110,8 @@ public List<double[]> addToClusteringCenters(List<double[]> clustering) {
 	 * Writes all clustering centers of the ClusterFeatures of the tree with this
 	 * node as the root to a given stream.
 	 *
-	 * @param stream
-	 *            the stream
-	 * @throws IOException
-	 *            If an I/O error occurs
+	 * @param stream the stream
+	 * @throws IOException If an I/O error occurs
 	 */
 	public void printClusteringCenters(Writer stream) throws IOException {
 		if (center != null && getClusteringFeature() != null) {
@@ -142,8 +134,7 @@ public double[] getCenter() {
 	/**
 	 * Sets the representation of the ClusteringFeature
 	 *
-	 * @param center
-	 *            the representation of the ClusteringFeature to set
+	 * @param center the representation of the ClusteringFeature to set
 	 */
 	public void setCenter(double[] center) {
 		assert (this.center.length == center.length);
@@ -181,8 +172,7 @@ public void getDescription(StringBuilder sb, int indent) {
 	/**
 	 * Searches for the nearest child node by comparing each representation.
 	 *
-	 * @param pointA
-	 *            to find the nearest child for
+	 * @param pointA to find the nearest child for
 	 * @return the child node which is the nearest
 	 */
 	public ClusteringTreeNode nearestChild(double[] pointA) {
@@ -202,8 +192,7 @@ public ClusteringTreeNode nearestChild(double[] pointA) {
 	/**
 	 * Adds a child node.
 	 *
-	 * @param e
-	 *            the child node to add
+	 * @param e the child node to add
 	 * @return <code>true</code>
 	 * @see java.util.List#add(java.lang.Object)
 	 */
@@ -243,8 +232,7 @@ public double getThreshold() {
 	/**
 	 * Gets the threshold of this node.
 	 *
-	 * @param threshold
-	 *            the threshold to set
+	 * @param threshold the threshold to set
 	 */
 	public void setThreshold(double threshold) {
 		this.clusteringFeature.setThreshold(threshold);
diff --git a/moa/src/main/java/moa/clusterers/kmeanspm/CoresetKMeans.java b/moa/src/main/java/moa/learners/clusterers/kmeanspm/CoresetKMeans.java
similarity index 85%
rename from moa/src/main/java/moa/clusterers/kmeanspm/CoresetKMeans.java
rename to moa/src/main/java/moa/learners/clusterers/kmeanspm/CoresetKMeans.java
index 631bb90cb..85c02b7d4 100644
--- a/moa/src/main/java/moa/clusterers/kmeanspm/CoresetKMeans.java
+++ b/moa/src/main/java/moa/learners/clusterers/kmeanspm/CoresetKMeans.java
@@ -17,7 +17,7 @@
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
  *
  */
-package moa.clusterers.kmeanspm;
+package moa.learners.clusterers.kmeanspm;
 
 import java.util.ArrayList;
 import java.util.Iterator;
@@ -28,9 +28,8 @@
  * Provides methods to execute the k-means and k-means++ algorithm with a
  * clustering.
  *
- * Citation: David Arthur, Sergei Vassilvitskii:
- * k-means++: the advantages of careful seeding.
- * SODA 2007: 1027-1035
+ * Citation: David Arthur, Sergei Vassilvitskii: k-means++: the advantages of
+ * careful seeding. SODA 2007: 1027-1035
  *
  */
 public class CoresetKMeans {
@@ -38,22 +37,18 @@ public class CoresetKMeans {
 	/**
 	 * Generates the initial centroids like the k-means++ algorithm.
 	 *
-	 * @param k
-	 *            number of centroids
-	 * @param input
-	 *            input clustering
-	 * @param random
-	 *            instance to generate a stream of pseudorandom numbers
+	 * @param k      number of centroids
+	 * @param input  input clustering
+	 * @param random instance to generate a stream of pseudorandom numbers
 	 * @return the generated centroids
 	 */
-	public static List<double[]> generatekMeansPlusPlusCentroids(int k,
-			List<double[]> input, Random random) {
+	public static List<double[]> generatekMeansPlusPlusCentroids(int k, List<double[]> input, Random random) {
 		int n = input.size();
 		assert (n > 0);
 		int d = input.get(0).length - 1;
 		assert (k <= n);
 
-		List<double[]> centerValue = new ArrayList<double[]>(k);
+		List<double[]> centerValue = new ArrayList<>(k);
 		// Selects and copies the first centroid
 		double[] lastCenter = new double[d];
 		System.arraycopy(input.get(random.nextInt(n)), 1, lastCenter, 0, d);
@@ -69,11 +64,7 @@ public static List<double[]> generatekMeansPlusPlusCentroids(int k,
 			Iterator<double[]> jIter = input.iterator();
 			for (int j = 0; j < n; j++) {
 				double[] point = jIter.next();
-				distance[j] = Math
-						.min(distance[j],
-								point[0]
-										* Metric.distanceSquared(lastCenter,
-												point, 1));
+				distance[j] = Math.min(distance[j], point[0] * Metric.distanceSquared(lastCenter, point, 1));
 				sum += distance[j];
 
 			}
@@ -98,10 +89,8 @@ public static List<double[]> generatekMeansPlusPlusCentroids(int k,
 	 * Executes the k-means algorithm with the given initial centroids until the
 	 * costs converges.
 	 *
-	 * @param centroids
-	 *            initial centroids
-	 * @param input
-	 *            input clustering
+	 * @param centroids initial centroids
+	 * @param input     input clustering
 	 * @return the k-means costs
 	 */
 	public static double kMeans(List<double[]> centroids, List<double[]> input) {
@@ -175,9 +164,7 @@ public static double kMeans(List<double[]> centroids, List<double[]> input) {
 		Iterator<double[]> lIter = input.iterator();
 		for (int l = 0; l < size; l++) {
 			double[] point = lIter.next();
-			costs += point[0]
-					* Metric.distanceSquared(center[nearestCluster[l]], point,
-							1);
+			costs += point[0] * Metric.distanceSquared(center[nearestCluster[l]], point, 1);
 		}
 		return costs;
 	}
diff --git a/moa/src/main/java/moa/clusterers/kmeanspm/CuckooHashing.java b/moa/src/main/java/moa/learners/clusterers/kmeanspm/CuckooHashing.java
similarity index 72%
rename from moa/src/main/java/moa/clusterers/kmeanspm/CuckooHashing.java
rename to moa/src/main/java/moa/learners/clusterers/kmeanspm/CuckooHashing.java
index 44fd5a288..221d449ae 100644
--- a/moa/src/main/java/moa/clusterers/kmeanspm/CuckooHashing.java
+++ b/moa/src/main/java/moa/learners/clusterers/kmeanspm/CuckooHashing.java
@@ -17,7 +17,7 @@
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
  *
  */
-package moa.clusterers.kmeanspm;
+package moa.learners.clusterers.kmeanspm;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -26,12 +26,10 @@
 /**
  * Provides a hash table based on Cuckoo Hashing.
  *
- * Citation: Rasmus Pagh, Flemming Friche Rodler:
- * Cuckoo Hashing.
- * ESA 2001: 121-133
+ * Citation: Rasmus Pagh, Flemming Friche Rodler: Cuckoo Hashing. ESA 2001:
+ * 121-133
  *
- * @param <T>
- *            class of stored elements
+ * @param <T> class of stored elements
  */
 public class CuckooHashing<T> {
 
@@ -55,19 +53,14 @@ public class CuckooHashing<T> {
 	/**
 	 * Creates a new hash table based on Cuckoo Hashing.
 	 *
-	 * @param startHashSize
-	 *            size of the hash function at the beginning (must be smaller
-	 *            than 31)
-	 * @param maxStashSize
-	 *            maximum size of the stash
-	 * @param startNumTables
-	 *            number of tables for Cuckoo hashing
-	 * @param random
-	 *            instance to generate a stream of pseudorandom numbers
+	 * @param startHashSize  size of the hash function at the beginning (must be
+	 *                       smaller than 31)
+	 * @param maxStashSize   maximum size of the stash
+	 * @param startNumTables number of tables for Cuckoo hashing
+	 * @param random         instance to generate a stream of pseudorandom numbers
 	 */
-	public CuckooHashing(int startHashSize, int maxStashSize, int startNumTables,
-			Random random) {
-		assert(startHashSize < 31);
+	public CuckooHashing(int startHashSize, int maxStashSize, int startNumTables, Random random) {
+		assert (startHashSize < 31);
 		this.startHashSize = startHashSize;
 		this.maxStashSize = maxStashSize;
 		this.startNumTables = startNumTables;
@@ -75,17 +68,17 @@ public CuckooHashing(int startHashSize, int maxStashSize, int startNumTables,
 
 		this.hashSize = startHashSize;
 		int sizeTables = 1 << startHashSize;
-		this.hashfunctions = new ArrayList<DietzfelbingerHash>(startNumTables);
-		this.elements = new ArrayList<Entry<T>>(sizeTables);
+		this.hashfunctions = new ArrayList<>(startNumTables);
+		this.elements = new ArrayList<>(sizeTables);
 		this.numElements = 0;
-		this.tables = new ArrayList<List<Entry<T>>>(startNumTables);
+		this.tables = new ArrayList<>(startNumTables);
 		this.numTables = startNumTables;
-		this.stash = new ArrayList<Entry<T>>();
+		this.stash = new ArrayList<>();
 		this.stashSize = 0;
 
 		for (int i = 0; i < startNumTables; i++) {
 			this.hashfunctions.add(new DietzfelbingerHash(startHashSize, random));
-			List<Entry<T>> table = new ArrayList<Entry<T>>(sizeTables);
+			List<Entry<T>> table = new ArrayList<>(sizeTables);
 			for (int j = 0; j < sizeTables; j++) {
 				table.add(null);
 			}
@@ -96,10 +89,8 @@ public CuckooHashing(int startHashSize, int maxStashSize, int startNumTables,
 	/**
 	 * Creates a new hash table based on Cuckoo Hashing.
 	 *
-	 * @param hashSize
-	 *            size of the hash function
-	 * @param random
-	 *            instance to generate a stream of pseudorandom numbers
+	 * @param hashSize size of the hash function
+	 * @param random   instance to generate a stream of pseudorandom numbers
 	 */
 	public CuckooHashing(int hashSize, Random random) {
 		this(hashSize, DEFAULT_STASH_SIZE, DEFAULT_NUM_TABLES, random);
@@ -108,13 +99,11 @@ public CuckooHashing(int hashSize, Random random) {
 	/**
 	 * Adds an element to the hash table.
 	 *
-	 * @param key
-	 *            key value of the element
-	 * @param element
-	 *            value of the element
+	 * @param key     key value of the element
+	 * @param element value of the element
 	 */
 	public void put(long key, T element) {
-		Entry<T> entry = new Entry<T>(key, element);
+		Entry<T> entry = new Entry<>(key, element);
 		elements.add(entry);
 		this.numElements++;
 		fileElement(entry, true);
@@ -123,21 +112,16 @@ public void put(long key, T element) {
 	/**
 	 * Adds an element to one of the tables for Cuckoo Hashing.
 	 *
-	 * @param currentElement
-	 *            entry to add in a table
-	 * @param rehash
-	 *            if <code>true</code> the hash table will be rebuild when the
-	 *            stash became too big.
+	 * @param currentElement entry to add in a table
+	 * @param rehash         if <code>true</code> the hash table will be rebuild
+	 *                       when the stash became too big.
 	 */
 	private void fileElement(Entry<T> currentElement, boolean rehash) {
-		int maxFailures = Math.max((int) Math.log(this.numElements),
-				this.numTables * 2);
+		int maxFailures = Math.max((int) Math.log(this.numElements), this.numTables * 2);
 		int currentTable = 0;
 		for (int i = 0; i < maxFailures; i++) {
-			int hash = this.hashfunctions.get(currentTable).hash(
-					currentElement.getKey());
-			currentElement = this.tables.get(currentTable).set(hash,
-					currentElement);
+			int hash = this.hashfunctions.get(currentTable).hash(currentElement.getKey());
+			currentElement = this.tables.get(currentTable).set(hash, currentElement);
 			if (currentElement == null) {
 				break;
 			}
@@ -164,14 +148,11 @@ private void increaseAndReset() {
 			this.hashSize += 1;
 			this.hashfunctions.clear();
 			for (List<Entry<T>> table : this.tables) {
-				this.hashfunctions.add(new DietzfelbingerHash(this.hashSize,
-						this.random));
-				((ArrayList<Entry<T>>) table)
-						.ensureCapacity(1 << this.hashSize);
+				this.hashfunctions.add(new DietzfelbingerHash(this.hashSize, this.random));
+				((ArrayList<Entry<T>>) table).ensureCapacity(1 << this.hashSize);
 			}
 		} else {
-			this.hashfunctions.add(new DietzfelbingerHash(this.hashSize,
-					this.random));
+			this.hashfunctions.add(new DietzfelbingerHash(this.hashSize, this.random));
 			this.tables.add(new ArrayList<Entry<T>>(1 << this.hashSize));
 			this.numTables++;
 		}
@@ -181,13 +162,11 @@ private void increaseAndReset() {
 	/**
 	 * Gets an element of the hash table.
 	 *
-	 * @param key
-	 *            key value of the element
+	 * @param key key value of the element
 	 */
 	public T get(long key) {
 		for (int i = 0; i < this.numTables; i++) {
-			Entry<T> entry = this.tables.get(i).get(
-					this.hashfunctions.get(i).hash(key));
+			Entry<T> entry = this.tables.get(i).get(this.hashfunctions.get(i).hash(key));
 			if (entry != null && entry.getKey() == key) {
 				return entry.getValue();
 			}
@@ -239,9 +218,8 @@ public void clear() {
 		this.tables.clear();
 		int sizeTables = 1 << this.startHashSize;
 		for (int i = 0; i < this.startNumTables; i++) {
-			this.hashfunctions.add(new DietzfelbingerHash(this.startHashSize,
-					this.random));
-			List<Entry<T>> table = new ArrayList<Entry<T>>(sizeTables);
+			this.hashfunctions.add(new DietzfelbingerHash(this.startHashSize, this.random));
+			List<Entry<T>> table = new ArrayList<>(sizeTables);
 			for (int j = 0; j < sizeTables; j++) {
 				table.add(null);
 			}
@@ -273,8 +251,7 @@ public boolean isEmpty() {
 	/**
 	 * Class to save an element in the hash table.
 	 *
-	 * @param <V>
-	 *            class of stored elements
+	 * @param <V> class of stored elements
 	 */
 	private class Entry<V> {
 
@@ -284,10 +261,8 @@ private class Entry<V> {
 		/**
 		 * Creates a new entry for an element.
 		 *
-		 * @param key
-		 *            key of element
-		 * @param value
-		 *            value of element
+		 * @param key   key of element
+		 * @param value value of element
 		 */
 		public Entry(long key, V value) {
 			this.key = key;
diff --git a/moa/src/main/java/moa/clusterers/kmeanspm/DietzfelbingerHash.java b/moa/src/main/java/moa/learners/clusterers/kmeanspm/DietzfelbingerHash.java
similarity index 81%
rename from moa/src/main/java/moa/clusterers/kmeanspm/DietzfelbingerHash.java
rename to moa/src/main/java/moa/learners/clusterers/kmeanspm/DietzfelbingerHash.java
index 3b8f4899a..b67c600bc 100644
--- a/moa/src/main/java/moa/clusterers/kmeanspm/DietzfelbingerHash.java
+++ b/moa/src/main/java/moa/learners/clusterers/kmeanspm/DietzfelbingerHash.java
@@ -17,16 +17,15 @@
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
  *
  */
-package moa.clusterers.kmeanspm;
+package moa.learners.clusterers.kmeanspm;
 
 import java.util.Random;
 
 /**
  * Provides a Dietzfelbinger hash function.
  *
- * Citation: Mikkel Thorup:
- * High Speed Hashing for Integers and Strings.
- * CoRR abs/1504.06804 (2015)
+ * Citation: Mikkel Thorup: High Speed Hashing for Integers and Strings. CoRR
+ * abs/1504.06804 (2015)
  *
  */
 public class DietzfelbingerHash {
@@ -40,13 +39,11 @@ public class DietzfelbingerHash {
 	/**
 	 * Creates a Dietzfelbinger hash function.
 	 *
-	 * @param hashSize
-	 *            size of the hash function (must be smaller than 31)
-	 * @param random
-	 *            instance to generate a stream of pseudorandom numbers
+	 * @param hashSize size of the hash function (must be smaller than 31)
+	 * @param random   instance to generate a stream of pseudorandom numbers
 	 */
 	public DietzfelbingerHash(int hashSize, Random random) {
-		assert(hashSize < 31);
+		assert (hashSize < 31);
 		this.hashSize = hashSize;
 		this.random = random;
 		nextHashFunction();
@@ -64,8 +61,7 @@ public void nextHashFunction() {
 	/**
 	 * Dietzfelbinger hash function.
 	 *
-	 * @param value
-	 *            to hash
+	 * @param value to hash
 	 * @return the result
 	 */
 	public int hash(long value) {
diff --git a/moa/src/main/java/moa/clusterers/kmeanspm/Metric.java b/moa/src/main/java/moa/learners/clusterers/kmeanspm/Metric.java
similarity index 70%
rename from moa/src/main/java/moa/clusterers/kmeanspm/Metric.java
rename to moa/src/main/java/moa/learners/clusterers/kmeanspm/Metric.java
index 84a2c3514..8101e99f6 100644
--- a/moa/src/main/java/moa/clusterers/kmeanspm/Metric.java
+++ b/moa/src/main/java/moa/learners/clusterers/kmeanspm/Metric.java
@@ -17,7 +17,7 @@
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
  *
  */
-package moa.clusterers.kmeanspm;
+package moa.learners.clusterers.kmeanspm;
 
 /**
  * Provides methods to calculate different distances of points.
@@ -28,8 +28,7 @@ public class Metric {
 	/**
 	 * Calculates the squared Euclidean length of a point.
 	 *
-	 * @param pointA
-	 *            point
+	 * @param pointA point
 	 * @return the squared Euclidean length
 	 */
 	public static double distanceSquared(double[] pointA) {
@@ -43,8 +42,7 @@ public static double distanceSquared(double[] pointA) {
 	/**
 	 * Calculates the Euclidean length of a point.
 	 *
-	 * @param pointA
-	 *            point
+	 * @param pointA point
 	 * @return the Euclidean length
 	 */
 	public static double distance(double[] pointA) {
@@ -55,16 +53,12 @@ public static double distance(double[] pointA) {
 	 * Calculates the squared Euclidean distance of two points. Starts at dimension
 	 * offset + 1 of pointB.
 	 *
-	 * @param pointA
-	 *            first point
-	 * @param pointB
-	 *            second point
-	 * @param offsetB
-	 *            start dimension - 1 of pointB
+	 * @param pointA  first point
+	 * @param pointB  second point
+	 * @param offsetB start dimension - 1 of pointB
 	 * @return the squared Euclidean distance
 	 */
-	public static double distanceSquared(double[] pointA, double[] pointB,
-			int offsetB) {
+	public static double distanceSquared(double[] pointA, double[] pointB, int offsetB) {
 		assert (pointA.length == pointB.length + offsetB);
 		double distance = 0.0;
 		for (int i = 0; i < pointA.length; i++) {
@@ -75,15 +69,12 @@ public static double distanceSquared(double[] pointA, double[] pointB,
 	}
 
 	/**
-	 * Calculates the Euclidean distance of two points. Starts at dimension offset
-	 * + 1 of pointB.
+	 * Calculates the Euclidean distance of two points. Starts at dimension offset +
+	 * 1 of pointB.
 	 *
-	 * @param pointA
-	 *            first point
-	 * @param pointB
-	 *            second point
-	 * @param offsetB
-	 *            start dimension - 1 of pointB
+	 * @param pointA  first point
+	 * @param pointB  second point
+	 * @param offsetB start dimension - 1 of pointB
 	 * @return the Euclidean distance
 	 */
 	public static double distance(double[] pointA, double[] pointB, int offsetB) {
@@ -93,10 +84,8 @@ public static double distance(double[] pointA, double[] pointB, int offsetB) {
 	/**
 	 * Calculates the squared Euclidean distance of two points.
 	 *
-	 * @param pointA
-	 *            first point
-	 * @param pointB
-	 *            second point
+	 * @param pointA first point
+	 * @param pointB second point
 	 * @return the squared Euclidean distance
 	 */
 	public static double distanceSquared(double[] pointA, double[] pointB) {
@@ -112,10 +101,8 @@ public static double distanceSquared(double[] pointA, double[] pointB) {
 	/**
 	 * Calculates the Euclidean distance of two points.
 	 *
-	 * @param pointA
-	 *            first point
-	 * @param pointB
-	 *            second point
+	 * @param pointA first point
+	 * @param pointB second point
 	 * @return the Euclidean distance
 	 */
 	public static double distance(double[] pointA, double[] pointB) {
@@ -125,10 +112,8 @@ public static double distance(double[] pointA, double[] pointB) {
 	/**
 	 * Calculates the squared Euclidean length of a point divided by a scalar.
 	 *
-	 * @param pointA
-	 *            point
-	 * @param dA
-	 *            scalar
+	 * @param pointA point
+	 * @param dA     scalar
 	 * @return the squared Euclidean length
 	 */
 	public static double distanceWithDivisionSquared(double[] pointA, double dA) {
@@ -143,10 +128,8 @@ public static double distanceWithDivisionSquared(double[] pointA, double dA) {
 	/**
 	 * Calculates the Euclidean length of a point divided by a scalar.
 	 *
-	 * @param pointA
-	 *            point
-	 * @param dA
-	 *            scalar
+	 * @param pointA point
+	 * @param dA     scalar
 	 * @return the Euclidean length
 	 */
 	public static double distanceWithDivision(double[] pointA, double dA) {
@@ -157,16 +140,12 @@ public static double distanceWithDivision(double[] pointA, double dA) {
 	 * Calculates the squared Euclidean distance of the first point divided by a
 	 * scalar and another second point.
 	 *
-	 * @param pointA
-	 *            first point
-	 * @param dA
-	 *            scalar
-	 * @param pointB
-	 *            second point
+	 * @param pointA first point
+	 * @param dA     scalar
+	 * @param pointB second point
 	 * @return the squared Euclidean distance
 	 */
-	public static double distanceWithDivisionSquared(double[] pointA,
-			double dA, double[] pointB) {
+	public static double distanceWithDivisionSquared(double[] pointA, double dA, double[] pointB) {
 		assert (pointA.length == pointB.length);
 		double distance = 0.0;
 		for (int i = 0; i < pointA.length; i++) {
@@ -180,16 +159,12 @@ public static double distanceWithDivisionSquared(double[] pointA,
 	 * Calculates the Euclidean distance of the first point divided by a scalar and
 	 * another second point.
 	 *
-	 * @param pointA
-	 *            first point
-	 * @param dA
-	 *            scalar
-	 * @param pointB
-	 *            second point
+	 * @param pointA first point
+	 * @param dA     scalar
+	 * @param pointB second point
 	 * @return the Euclidean distance
 	 */
-	public static double distanceWithDivision(double[] pointA, double dA,
-			double[] pointB) {
+	public static double distanceWithDivision(double[] pointA, double dA, double[] pointB) {
 		return Math.sqrt(distanceWithDivisionSquared(pointA, dA, pointB));
 	}
 
@@ -197,18 +172,13 @@ public static double distanceWithDivision(double[] pointA, double dA,
 	 * Calculates the squared Euclidean distance of the first point divided by a
 	 * first scalar and another second point divided by a second scalar.
 	 *
-	 * @param pointA
-	 *            first point
-	 * @param dA
-	 *            first scalar
-	 * @param pointB
-	 *            second point
-	 * @param dB
-	 *            second scalar
+	 * @param pointA first point
+	 * @param dA     first scalar
+	 * @param pointB second point
+	 * @param dB     second scalar
 	 * @return the squared Euclidean distance
 	 */
-	public static double distanceWithDivisionSquared(double[] pointA,
-			double dA, double[] pointB, double dB) {
+	public static double distanceWithDivisionSquared(double[] pointA, double dA, double[] pointB, double dB) {
 		assert (pointA.length == pointB.length);
 		double distance = 0.0;
 		for (int i = 0; i < pointA.length; i++) {
@@ -219,29 +189,23 @@ public static double distanceWithDivisionSquared(double[] pointA,
 	}
 
 	/**
-	 * Calculates the Euclidean distance of the first point divided by a first scalar
-	 * and another second point divided by a second scalar.
+	 * Calculates the Euclidean distance of the first point divided by a first
+	 * scalar and another second point divided by a second scalar.
 	 *
-	 * @param pointA
-	 *            first point
-	 * @param dA
-	 *            first scalar
-	 * @param pointB
-	 *            second point
-	 * @param dB
-	 *            second scalar
+	 * @param pointA first point
+	 * @param dA     first scalar
+	 * @param pointB second point
+	 * @param dB     second scalar
 	 * @return the Euclidean distance
 	 */
-	public static double distanceWithDivision(double[] pointA, double dA,
-			double[] pointB, double dB) {
+	public static double distanceWithDivision(double[] pointA, double dA, double[] pointB, double dB) {
 		return Math.sqrt(distanceWithDivisionSquared(pointA, dA, pointB, dB));
 	}
 
 	/**
 	 * Calculates the dot product of the point with itself.
 	 *
-	 * @param pointA
-	 *            point
+	 * @param pointA point
 	 * @return the dot product
 	 */
 	public static double dotProduct(double[] pointA) {
@@ -255,10 +219,8 @@ public static double dotProduct(double[] pointA) {
 	/**
 	 * Calculates the dot product of the first point with a second point.
 	 *
-	 * @param pointA
-	 *            first point
-	 * @param pointB
-	 *            second point
+	 * @param pointA first point
+	 * @param pointB second point
 	 * @return the dot product
 	 */
 	public static double dotProduct(double[] pointA, double[] pointB) {
@@ -271,19 +233,15 @@ public static double dotProduct(double[] pointA, double[] pointB) {
 	}
 
 	/**
-	 * Calculates the dot product of the addition of the first and the second
-	 * point with the third point.
+	 * Calculates the dot product of the addition of the first and the second point
+	 * with the third point.
 	 *
-	 * @param pointA1
-	 *            first point
-	 * @param pointA2
-	 *            second point
-	 * @param pointB
-	 *            third point
+	 * @param pointA1 first point
+	 * @param pointA2 second point
+	 * @param pointB  third point
 	 * @return the dot product
 	 */
-	public static double dotProductWithAddition(double[] pointA1,
-			double[] pointA2, double[] pointB) {
+	public static double dotProductWithAddition(double[] pointA1, double[] pointA2, double[] pointB) {
 		assert (pointA1.length == pointA2.length && pointA1.length == pointB.length);
 		double product = 0.0;
 		for (int i = 0; i < pointA1.length; i++) {
@@ -293,23 +251,19 @@ public static double dotProductWithAddition(double[] pointA1,
 	}
 
 	/**
-	 * Calculates the dot product of the addition of the first and the second
-	 * point with the addition of the third and the fourth point.
+	 * Calculates the dot product of the addition of the first and the second point
+	 * with the addition of the third and the fourth point.
 	 *
-	 * @param pointA1
-	 *            first point
-	 * @param pointA2
-	 *            second point
-	 * @param pointB1
-	 *            third point
-	 * @param pointB2
-	 *            fourth point
+	 * @param pointA1 first point
+	 * @param pointA2 second point
+	 * @param pointB1 third point
+	 * @param pointB2 fourth point
 	 * @return the dot product
 	 */
-	public static double dotProductWithAddition(double[] pointA1,
-			double[] pointA2, double[] pointB1, double[] pointB2) {
-		assert (pointA1.length == pointA2.length
-				&& pointB1.length == pointB2.length && pointA1.length == pointB1.length);
+	public static double dotProductWithAddition(double[] pointA1, double[] pointA2, double[] pointB1,
+			double[] pointB2) {
+		assert (pointA1.length == pointA2.length && pointB1.length == pointB2.length
+				&& pointA1.length == pointB1.length);
 		double product = 0.0;
 		for (int i = 0; i < pointA1.length; i++) {
 			product += (pointA1[i] + pointA2[i]) * (pointB1[i] + pointB2[i]);
diff --git a/moa/src/main/java/moa/clusterers/macro/AbstractMacroClusterer.java b/moa/src/main/java/moa/learners/clusterers/macro/AbstractMacroClusterer.java
similarity index 90%
rename from moa/src/main/java/moa/clusterers/macro/AbstractMacroClusterer.java
rename to moa/src/main/java/moa/learners/clusterers/macro/AbstractMacroClusterer.java
index e2b21747f..de3534cc8 100644
--- a/moa/src/main/java/moa/clusterers/macro/AbstractMacroClusterer.java
+++ b/moa/src/main/java/moa/learners/clusterers/macro/AbstractMacroClusterer.java
@@ -1,6 +1,6 @@
 /**
  * [AbstractMacroClusterer.java] for Subspace MOA
- * 
+ *
  * @author Stephen Wels
  * Data Management and Data Exploration Group, RWTH Aachen University
  *
@@ -15,10 +15,10 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
-package moa.clusterers.macro;
+package moa.learners.clusterers.macro;
 
 import java.util.HashMap;
 import java.util.List;
@@ -45,9 +45,9 @@ protected void setClusterIDs(Clustering clustering) {
 		// }
 		// }
 
-		HashMap<Double, Integer> countIDs = new HashMap<Double, Integer>();
+		HashMap<Double, Integer> countIDs = new HashMap<>();
 		for (Cluster c : clustering.getClustering()) {
-			HashMap<Double, Integer> ids = new HashMap<Double, Integer>();
+			HashMap<Double, Integer> ids = new HashMap<>();
 			NonConvexCluster ncc = (NonConvexCluster) c;
 			for (Cluster mc : ncc.getMicroClusters()) {
 				if (!ids.containsKey(mc.getId()))
@@ -82,7 +82,7 @@ protected void setClusterIDs(Clustering clustering) {
 		// check if there are 2 clusters with the same color (same id, could
 		// appear after a split);
 		double freeID = 0;
-		List<Double> reservedIDs = new Vector<Double>();
+		List<Double> reservedIDs = new Vector<>();
 		reservedIDs.addAll(countIDs.keySet());
 		for (Map.Entry<Double, Integer> entry : countIDs.entrySet()) {
 			if (entry.getValue() > 1 || entry.getKey() == -1) {
@@ -94,8 +94,7 @@ protected void setClusterIDs(Clustering clustering) {
 					to--;
 
 				for (int i = 0; i < to; i++) {
-					while (reservedIDs.contains(freeID)
-							&& freeID < ColorArray.getNumColors())
+					while (reservedIDs.contains(freeID) && freeID < ColorArray.getNumColors())
 						freeID += 1.0;
 					for (int c = clustering.size() - 1; c >= 0; c--)
 						if (clustering.get(c).getId() == entry.getKey()) {
diff --git a/moa/src/main/java/moa/learners/clusterers/macro/ColorArray.java b/moa/src/main/java/moa/learners/clusterers/macro/ColorArray.java
new file mode 100644
index 000000000..824ad3445
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/macro/ColorArray.java
@@ -0,0 +1,124 @@
+/**
+ * [ColorArray.java] for Subspace MOA
+ *
+ * @author Stephen Wels
+ * Data Management and Data Exploration Group, RWTH Aachen University
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.clusterers.macro;
+
+import java.awt.Color;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+
+public class ColorArray {
+
+	private static final ColorObject[] ORIGINAL_COLOURS = { new ColorObject("blue", new Color(0x0000ff)),
+			new ColorObject("blueviolet", new Color(0x8a2be2)), new ColorObject("brown", new Color(0xa52a2a)),
+			new ColorObject("burlywood", new Color(0xdeb887)), new ColorObject("cadetblue", new Color(0x5f9ea0)),
+			// new ColorObject("chartreuse", new Color(0x7fff00)),
+			new ColorObject("chocolate", new Color(0xd2691e)), new ColorObject("coral", new Color(0xff7f50)),
+			new ColorObject("cornflowerblue", new Color(0x6495ed)), new ColorObject("crimson", new Color(0xdc143c)),
+			new ColorObject("cyan", new Color(0x00ffff)), new ColorObject("darkblue", new Color(0x00008b)),
+			new ColorObject("darkcyan", new Color(0x008b8b)), new ColorObject("darkgoldenrod", new Color(0xb8860b)),
+			new ColorObject("darkgreen", new Color(0x006400)), new ColorObject("darkkhaki", new Color(0xbdb76b)),
+			new ColorObject("darkmagenta", new Color(0x8b008b)), new ColorObject("darkolivegreen", new Color(0x556b2f)),
+			new ColorObject("darkorange", new Color(0xff8c00)),
+			// new ColorObject("darkorchid", new Color(0x9932cc)),
+			new ColorObject("darkred", new Color(0x8b0000)), new ColorObject("darksalmon", new Color(0xe9967a)),
+			new ColorObject("darkseagreen", new Color(0x8fbc8f)), new ColorObject("darkslateblue", new Color(0x483d8b)),
+			new ColorObject("darkslategray", new Color(0x2f4f4f)),
+			// new ColorObject("darkturquoise", new Color(0x00ced1)),
+			new ColorObject("darkviolet", new Color(0x9400d3)), new ColorObject("deeppink", new Color(0xff1493)),
+			new ColorObject("deepskyblue", new Color(0x00bfff)),
+			// new ColorObject("dodgerblue", new Color(0x1e90ff)),
+			new ColorObject("firebrick", new Color(0xb22222)), new ColorObject("forestgreen", new Color(0x228b22)),
+			new ColorObject("fuchsia", new Color(0xff00ff)), new ColorObject("gold", new Color(0xffd700)),
+			new ColorObject("goldenrod", new Color(0xdaa520)),
+			// new ColorObject("green", new Color(0x008000)),
+			new ColorObject("greenyellow", new Color(0xadff2f)), new ColorObject("hotpink", new Color(0xff69b4)),
+			new ColorObject("indianred", new Color(0xcd5c5c)), new ColorObject("indigo", new Color(0x4b0082)),
+			// new ColorObject("lawngreen", new Color(0x7cfc00)),
+			// new ColorObject("lime", new Color(0x00ff00)),
+			// new ColorObject("limegreen", new Color(0x32cd32)),
+			new ColorObject("magenta", new Color(0xff00ff)), new ColorObject("maroon", new Color(0x800000)),
+			new ColorObject("olive", new Color(0x808000)), new ColorObject("orange", new Color(0xffa500)),
+			new ColorObject("orangered", new Color(0xff4500)), new ColorObject("pink", new Color(0xffc0cb)),
+			new ColorObject("powderblue", new Color(0xb0e0e6)), new ColorObject("purple", new Color(0x800080)),
+			new ColorObject("red", new Color(0xff0000)), new ColorObject("royalblue", new Color(0x4169e1)),
+			new ColorObject("saddlebrown", new Color(0x8b4513)), new ColorObject("salmon", new Color(0xfa8072)),
+			new ColorObject("seagreen", new Color(0x2e8b57)), new ColorObject("skyblue", new Color(0x87ceeb)),
+			new ColorObject("slateblue", new Color(0x6a5acd)), new ColorObject("tomato", new Color(0xff6347)),
+			new ColorObject("violet", new Color(0xee82ee)) };
+
+	private static final String COMMA_DELIMITER = ",";
+	public static ColorObject[] mVisibleColors;
+
+	static {
+		try {
+			ArrayList<ColorObject> colours = new ArrayList<>();
+			for (ColorObject obj : ORIGINAL_COLOURS)
+				colours.add(obj);
+			colours.addAll(getColors());
+			mVisibleColors = colours.toArray(new ColorObject[0]);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+	private static ArrayList<ColorObject> getColors() throws IOException {
+
+		ArrayList<ColorObject> colorObjects = new ArrayList<>();
+		ClassLoader classLoader = ColorArray.class.getClassLoader();
+		InputStream inputStream = classLoader.getResourceAsStream("colors.csv");
+		InputStreamReader streamReader = new InputStreamReader(inputStream, StandardCharsets.UTF_8);
+		BufferedReader reader = new BufferedReader(streamReader);
+		for (String line; (line = reader.readLine()) != null;) {
+			String[] values = line.split(COMMA_DELIMITER);
+			colorObjects.add(new ColorObject(values[0], Color.decode(values[1])));
+		}
+
+		return colorObjects;
+	}
+
+	public static Color getColor(int i) {
+		Color res;
+		try {
+			res = mVisibleColors[i].getColor();
+		} catch (ArrayIndexOutOfBoundsException e) {
+			return Color.BLACK;
+		}
+		return res;
+	}
+
+	public static String getName(int i) {
+		String res;
+		try {
+			res = mVisibleColors[i].getName();
+		} catch (ArrayIndexOutOfBoundsException e) {
+			throw e;
+		}
+		return res;
+	}
+
+	public static double getNumColors() {
+		return mVisibleColors.length;
+	}
+}
diff --git a/moa/src/main/java/moa/clusterers/macro/ColorObject.java b/moa/src/main/java/moa/learners/clusterers/macro/ColorObject.java
similarity index 95%
rename from moa/src/main/java/moa/clusterers/macro/ColorObject.java
rename to moa/src/main/java/moa/learners/clusterers/macro/ColorObject.java
index 74d98f59c..4334b0c3a 100644
--- a/moa/src/main/java/moa/clusterers/macro/ColorObject.java
+++ b/moa/src/main/java/moa/learners/clusterers/macro/ColorObject.java
@@ -1,6 +1,6 @@
 /**
  * [ColorObject.java] for Subspace MOA
- * 
+ *
  * @author Stephen Wels
  * Data Management and Data Exploration Group, RWTH Aachen University
  *
@@ -15,10 +15,11 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
-package moa.clusterers.macro;
+package moa.learners.clusterers.macro;
+
 import java.awt.Color;
 
 public class ColorObject {
diff --git a/moa/src/main/java/moa/clusterers/macro/IDenseMacroCluster.java b/moa/src/main/java/moa/learners/clusterers/macro/IDenseMacroCluster.java
similarity index 87%
rename from moa/src/main/java/moa/clusterers/macro/IDenseMacroCluster.java
rename to moa/src/main/java/moa/learners/clusterers/macro/IDenseMacroCluster.java
index 7962d87f3..7079f0714 100644
--- a/moa/src/main/java/moa/clusterers/macro/IDenseMacroCluster.java
+++ b/moa/src/main/java/moa/learners/clusterers/macro/IDenseMacroCluster.java
@@ -1,6 +1,6 @@
 /**
  * [IDenseMacroCluster.java] for Subspace MOA
- * 
+ *
  * @author Stephen Wels
  * Data Management and Data Exploration Group, RWTH Aachen University
  *
@@ -15,10 +15,10 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
-package moa.clusterers.macro;
+package moa.learners.clusterers.macro;
 
 import java.util.List;
 
@@ -26,7 +26,7 @@
 import moa.cluster.Clustering;
 
 public interface IDenseMacroCluster {
-	public Clustering getClustering();
+	Clustering getClustering();
 
-	public List<CFCluster> getMicroClusters();
+	List<CFCluster> getMicroClusters();
 }
diff --git a/moa/src/main/java/moa/clusterers/macro/IMacroClusterer.java b/moa/src/main/java/moa/learners/clusterers/macro/IMacroClusterer.java
similarity index 88%
rename from moa/src/main/java/moa/clusterers/macro/IMacroClusterer.java
rename to moa/src/main/java/moa/learners/clusterers/macro/IMacroClusterer.java
index 4a14ab4a4..9bb705f21 100644
--- a/moa/src/main/java/moa/clusterers/macro/IMacroClusterer.java
+++ b/moa/src/main/java/moa/learners/clusterers/macro/IMacroClusterer.java
@@ -1,6 +1,6 @@
 /**
  * [IMacroClusterer.java] for Subspace MOA
- * 
+ *
  * @author Stephen Wels
  * Data Management and Data Exploration Group, RWTH Aachen University
  *
@@ -15,14 +15,14 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
-package moa.clusterers.macro;
+package moa.learners.clusterers.macro;
 
 import moa.cluster.Clustering;
 
 public interface IMacroClusterer {
 
-	public Clustering getClustering(Clustering microClusters);
+	Clustering getClustering(Clustering microClusters);
 }
diff --git a/moa/src/main/java/moa/clusterers/macro/NonConvexCluster.java b/moa/src/main/java/moa/learners/clusterers/macro/NonConvexCluster.java
similarity index 91%
rename from moa/src/main/java/moa/clusterers/macro/NonConvexCluster.java
rename to moa/src/main/java/moa/learners/clusterers/macro/NonConvexCluster.java
index e132b69d2..0786449bc 100644
--- a/moa/src/main/java/moa/clusterers/macro/NonConvexCluster.java
+++ b/moa/src/main/java/moa/learners/clusterers/macro/NonConvexCluster.java
@@ -1,8 +1,8 @@
 /**
  * [NonConvexCluster.java] for Subspace MOA
- * 
+ *
  * A set of [CFCluster]s, grouped as a non-convex cluster.
- * 
+ *
  * @author Stephen Wels
  * @editor Yunsu Kim
  * Data Management and Data Exploration Group, RWTH Aachen University
@@ -18,10 +18,10 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
-package moa.clusterers.macro;
+package moa.learners.clusterers.macro;
 
 import java.util.List;
 import java.util.Vector;
@@ -35,13 +35,13 @@ public class NonConvexCluster extends CFCluster implements IDenseMacroCluster {
 
 	List<CFCluster> mMicroClusters;
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 
 	public NonConvexCluster(CFCluster cluster, List<CFCluster> microclusters) {
 		super(cluster); // required
-		mMicroClusters = new Vector<CFCluster>();
+		mMicroClusters = new Vector<>();
 		mMicroClusters.addAll(microclusters);
 		// assuming we have a circular shaped cluster, compute it's center: only
 		// for visualization
@@ -82,6 +82,7 @@ public double getRadius() {
 		return 0;
 	}
 
+	@Override
 	public Clustering getClustering() {
 		Clustering c = new Clustering();
 		for (CFCluster mc : mMicroClusters)
@@ -89,6 +90,7 @@ public Clustering getClustering() {
 		return c;
 	}
 
+	@Override
 	public List<CFCluster> getMicroClusters() {
 		return mMicroClusters;
 	}
diff --git a/moa/src/main/java/moa/clusterers/macro/dbscan/DBScan.java b/moa/src/main/java/moa/learners/clusterers/macro/dbscan/DBScan.java
similarity index 83%
rename from moa/src/main/java/moa/clusterers/macro/dbscan/DBScan.java
rename to moa/src/main/java/moa/learners/clusterers/macro/dbscan/DBScan.java
index 74efb2a5c..1daeb7f39 100644
--- a/moa/src/main/java/moa/clusterers/macro/dbscan/DBScan.java
+++ b/moa/src/main/java/moa/learners/clusterers/macro/dbscan/DBScan.java
@@ -1,8 +1,8 @@
 /**
  * [DBScan.java] for Subspace MOA
- * 
+ *
  * An implementation of DBSCAN.
- * 
+ *
  * @editor Yunsu Kim
  * Data Management and Data Exploration Group, RWTH Aachen University
  *
@@ -17,11 +17,11 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.clusterers.macro.dbscan;
+package moa.learners.clusterers.macro.dbscan;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -30,8 +30,8 @@
 import moa.cluster.CFCluster;
 import moa.cluster.Cluster;
 import moa.cluster.Clustering;
-import moa.clusterers.macro.AbstractMacroClusterer;
-import moa.clusterers.macro.NonConvexCluster;
+import moa.learners.clusterers.macro.AbstractMacroClusterer;
+import moa.learners.clusterers.macro.NonConvexCluster;
 
 public class DBScan extends AbstractMacroClusterer {
 
@@ -45,10 +45,8 @@ public DBScan(Clustering microClusters, double eps, int MinPts) {
 		mMinPts = MinPts;
 	}
 
-	private ArrayList<DenseMicroCluster> expandCluster(DenseMicroCluster dmc,
-			List<DenseMicroCluster> neighbours,
-			ArrayList<DenseMicroCluster> arrayList,
-			Vector<DenseMicroCluster> dbmc) {
+	private ArrayList<DenseMicroCluster> expandCluster(DenseMicroCluster dmc, List<DenseMicroCluster> neighbours,
+			ArrayList<DenseMicroCluster> arrayList, Vector<DenseMicroCluster> dbmc) {
 
 		if (!dmc.isClustered()) {
 			dmc.setClustered();
@@ -79,9 +77,8 @@ private ArrayList<DenseMicroCluster> expandCluster(DenseMicroCluster dmc,
 		return arrayList;
 	}
 
-	private List<DenseMicroCluster> getNeighbourhood(DenseMicroCluster mc,
-			Vector<DenseMicroCluster> dbmc) {
-		List<DenseMicroCluster> res = new Vector<DenseMicroCluster>();
+	private List<DenseMicroCluster> getNeighbourhood(DenseMicroCluster mc, Vector<DenseMicroCluster> dbmc) {
+		List<DenseMicroCluster> res = new Vector<>();
 		for (DenseMicroCluster dmc : dbmc) {
 			if (distance(dmc.getCFCluster().getCenter(), mc.getCFCluster().getCenter()) < mEps) {
 				res.add(dmc);
@@ -92,7 +89,7 @@ private List<DenseMicroCluster> getNeighbourhood(DenseMicroCluster mc,
 
 	/**
 	 * eclidean distance
-	 * 
+	 *
 	 * @param center
 	 * @param center2
 	 * @return
@@ -108,7 +105,7 @@ private double distance(double[] center, double[] center2) {
 	@Override
 	public Clustering getClustering(Clustering microClusters) {
 		if (microClusters != null && microClusters.size() != 0) {
-			Vector<DenseMicroCluster> dbmc = new Vector<DenseMicroCluster>();
+			Vector<DenseMicroCluster> dbmc = new Vector<>();
 			for (Cluster c : microClusters.getClustering()) {
 				CFCluster cf = null;
 				if (c instanceof CFCluster) {
@@ -118,16 +115,14 @@ public Clustering getClustering(Clustering microClusters) {
 					throw new RuntimeException();
 			}
 
-			ArrayList<ArrayList<DenseMicroCluster>> clusters = new ArrayList<ArrayList<DenseMicroCluster>>();
+			ArrayList<ArrayList<DenseMicroCluster>> clusters = new ArrayList<>();
 
 			for (DenseMicroCluster dmc : dbmc) {
 				if (!dmc.isVisited()) {
 					dmc.setVisited();
-					List<DenseMicroCluster> neighbours = getNeighbourhood(dmc,
-							dbmc);
+					List<DenseMicroCluster> neighbours = getNeighbourhood(dmc, dbmc);
 					if (neighbours.size() >= mMinPts) {
-						ArrayList<DenseMicroCluster> cluster = expandCluster(
-								dmc, neighbours,
+						ArrayList<DenseMicroCluster> cluster = expandCluster(dmc, neighbours,
 								new ArrayList<DenseMicroCluster>(), dbmc);
 						clusters.add(cluster);
 					}
@@ -153,8 +148,7 @@ public Clustering getClustering(Clustering microClusters) {
 			int clusterPos = 0;
 			for (ArrayList<DenseMicroCluster> cluster : clusters) {
 				if (cluster.size() != 0) {
-					CFCluster temp = new NonConvexCluster(
-							cluster.get(0).getCFCluster(),
+					CFCluster temp = new NonConvexCluster(cluster.get(0).getCFCluster(),
 							Convert2microclusterList(cluster));
 					res[clusterPos] = temp;
 					for (int i = 1; i < cluster.size(); i++) {
@@ -171,8 +165,7 @@ public Clustering getClustering(Clustering microClusters) {
 					noise++;
 				}
 			}
-			System.out.println("microclusters which are not clustered:: "
-					+ noise);
+			System.out.println("microclusters which are not clustered:: " + noise);
 			Clustering result = new Clustering(res);
 			setClusterIDs(result);
 			// int i = 0;
@@ -184,9 +177,8 @@ public Clustering getClustering(Clustering microClusters) {
 		return new Clustering();
 	}
 
-	private List<CFCluster> Convert2microclusterList(
-			ArrayList<DenseMicroCluster> cluster) {
-		List<CFCluster> cfCluster = new Vector<CFCluster>();
+	private List<CFCluster> Convert2microclusterList(ArrayList<DenseMicroCluster> cluster) {
+		List<CFCluster> cfCluster = new Vector<>();
 		for (DenseMicroCluster d : cluster) {
 			cfCluster.add(d.getCFCluster());
 		}
diff --git a/moa/src/main/java/moa/clusterers/macro/dbscan/DenseMicroCluster.java b/moa/src/main/java/moa/learners/clusterers/macro/dbscan/DenseMicroCluster.java
similarity index 80%
rename from moa/src/main/java/moa/clusterers/macro/dbscan/DenseMicroCluster.java
rename to moa/src/main/java/moa/learners/clusterers/macro/dbscan/DenseMicroCluster.java
index 3cd876ead..71e3fb3b3 100644
--- a/moa/src/main/java/moa/clusterers/macro/dbscan/DenseMicroCluster.java
+++ b/moa/src/main/java/moa/learners/clusterers/macro/dbscan/DenseMicroCluster.java
@@ -1,8 +1,8 @@
 /**
  * [DenseMicroCluster.java] for Subspace MOA
- * 
+ *
  * A microcluster class for DBSCAN.
- * 
+ *
  * @editor Yunsu Kim
  * Data Management and Data Exploration Group, RWTH Aachen University
  *
@@ -17,11 +17,11 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.clusterers.macro.dbscan;
+package moa.learners.clusterers.macro.dbscan;
 
 import moa.cluster.CFCluster;
 
@@ -30,30 +30,30 @@ public class DenseMicroCluster {
 	private CFCluster mCluster;
 	private boolean mVisited;
 	private boolean mIsClustered;
-	
-	public DenseMicroCluster(CFCluster mc){
+
+	public DenseMicroCluster(CFCluster mc) {
 		mCluster = mc;
 		mVisited = false;
 	}
-	
-	public void setVisited(){
+
+	public void setVisited() {
 		mVisited = true;
 	}
-	
-	public boolean isVisited(){
+
+	public boolean isVisited() {
 		return mVisited;
 	}
-	
-	public void setClustered(){
+
+	public void setClustered() {
 		mIsClustered = true;
 	}
-	
-	public boolean isClustered(){
+
+	public boolean isClustered() {
 		return mIsClustered;
 	}
-	
-	public CFCluster getCFCluster(){
+
+	public CFCluster getCFCluster() {
 		return mCluster;
 	}
-	
+
 }
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/AbstractC/AbstractC.java b/moa/src/main/java/moa/learners/clusterers/outliers/AbstractC/AbstractC.java
new file mode 100644
index 000000000..80a1920a6
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/AbstractC/AbstractC.java
@@ -0,0 +1,182 @@
+/*
+ *    AbstractC.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers.AbstractC;
+
+import java.util.Vector;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.learners.clusterers.outliers.AbstractC.ISBIndex.ISBNode;
+import moa.learners.clusterers.outliers.AbstractC.ISBIndex.ISBSearchResult;
+
+//The algorithm is presented in:
+//D. Yang, E. Rundensteiner, and M. Ward.
+//Neighbor-based pattern detection for windows over streaming data.
+//In EDBT, pages 529–540, 2009
+
+public class AbstractC extends AbstractCBase {
+	public FloatOption radiusOption = new FloatOption("radius", 'r', "Search radius.", 0.1);
+	// public FloatOption fractionOption = new FloatOption("fraction", 'f',
+	// "Parameter fraction.", 0.05);
+	public IntOption kOption = new IntOption("k", 't', "Parameter k.", 50);
+	public FlagOption waitWinFullOption = new FlagOption("waitWinFull", 'a', "Output outliers when windows is full.");
+
+	public AbstractC() {
+		// System.out.println("AbstractC: created");
+	}
+
+	@Override
+	public void Init() {
+		super.Init();
+
+		m_WindowSize = windowSizeOption.getValue();
+		m_radius = radiusOption.getValue();
+		// m_Fraction = fractionOption.getValue();
+		m_Fraction = (double) kOption.getValue() / (double) m_WindowSize;
+
+		Println("Init AbstractC:");
+		Println("   window_size: " + m_WindowSize);
+		Println("   radius: " + m_radius);
+		Println("   Fraction: " + m_Fraction);
+		Println("   (Fraction * window_size: " + String.format("%.2f", m_Fraction * m_WindowSize) + ")");
+
+		// bTrace = true;
+		bWarning = true;
+
+		objId = FIRST_OBJ_ID; // init object identifier
+		// create fifo
+		windowNodes = new Vector<>();
+		// create ISB
+		ISB = new ISBIndex(m_radius, m_Fraction);
+
+		// init statistics
+		m_nBothInlierOutlier = 0;
+		m_nOnlyInlier = 0;
+		m_nOnlyOutlier = 0;
+	}
+
+	void UpdateNeighbors(ISBNode n, ISBNode q) {
+		if (n == q)
+			return;
+		if (bTrace)
+			Println("UpdateNeighbors: n.id: " + n.id + ", q.id: " + q.id);
+
+		int len = q.lt_cnt.size();
+		for (int i = 0; i < len; i++) {
+			// n.lt_cnt++
+			n.lt_cnt.set(i, n.lt_cnt.get(i) + 1);
+			// q.lt_cnt++
+			q.lt_cnt.set(i, q.lt_cnt.get(i) + 1);
+		}
+	}
+
+	void OutputPatterns() {
+		if (bTrace)
+			Println("OutputPatterns");
+
+		double thr = m_Fraction * m_WindowSize;
+
+		for (ISBNode node : windowNodes) {
+			if (node.lt_cnt.size() > 0) {
+				if (IsWinFull() || !waitWinFullOption.isSet()) {
+					if (node.lt_cnt.get(0) < thr) {
+						SaveOutlier(node);
+					} else {
+						RemoveOutlier(node);
+					}
+				}
+				node.lt_cnt.remove(0);
+			} else {
+				if (bWarning)
+					Println("OutputPatterns: " + node.id + ".lt_cnt is empty!");
+			}
+		}
+	}
+
+	@Override
+	protected void ProcessNewStreamObj(Instance inst) {
+		if (bShowProgress)
+			ShowProgress("Processed " + (objId - 1) + " stream objects.");
+		// PrintInstance(inst);
+
+		double[] values = getInstanceValues(inst);
+		StreamObj obj = new StreamObj(values);
+
+		// process new data stream object
+		if (bTrace)
+			Println("\n- - - - - - - - - - - -\n");
+
+		// create new ISB node
+		ISBNode nodeNew = new ISBNode(inst, obj, objId);
+		if (bTrace) {
+			Print("New node: ");
+			PrintNode(nodeNew);
+		}
+
+		objId++; // update object identifier (slide window)
+
+		// purge expired node
+		ISBNode nodeExpired = GetExpiredNode();
+		if (nodeExpired != null) {
+			// purge nodeExpired
+			if (bTrace) {
+				Print("nodeExpired: ");
+				PrintNode(nodeExpired);
+			}
+			RemoveNode(nodeExpired);
+		}
+
+		// initialize nodeNew.lt_cnt
+		if (bTrace)
+			Println("initialize nodeNew");
+		for (int i = 0; i < m_WindowSize; i++) {
+			nodeNew.lt_cnt.add(1);
+		}
+		AddNode(nodeNew); // add nodeNew to window and index
+		if (bTrace)
+			PrintWindow();
+
+		// perform range query search
+		if (bTrace)
+			Println("Perform range query seach");
+		nRangeQueriesExecuted++;
+		Vector<ISBIndex.ISBSearchResult> neighbors = ISB.RangeSearch(nodeNew, m_radius);
+
+		// process each returned node
+		for (ISBSearchResult res : neighbors) {
+			ISBNode node = res.node;
+			UpdateNeighbors(nodeNew, node);
+		}
+
+		OutputPatterns();
+
+		if (bTrace) {
+			PrintOutliers();
+			for (ISBNode node : windowNodes) {
+				Print(node.id + ".lt_count: ");
+				Print_lt_cnt(node.lt_cnt);
+			}
+		}
+	}
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/AbstractC/AbstractCBase.java b/moa/src/main/java/moa/learners/clusterers/outliers/AbstractC/AbstractCBase.java
new file mode 100644
index 000000000..37d0a2585
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/AbstractC/AbstractCBase.java
@@ -0,0 +1,216 @@
+/*
+ *    AbstractCBase.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers.AbstractC;
+
+import java.util.ArrayList;
+import java.util.Vector;
+
+import moa.learners.clusterers.outliers.MyBaseOutlierDetector;
+import moa.learners.clusterers.outliers.AbstractC.ISBIndex.ISBNode;
+
+public abstract class AbstractCBase extends MyBaseOutlierDetector {
+	protected static final Long FIRST_OBJ_ID = 1L;
+
+	// object identifier increments with each new data stream object
+	protected Long objId;
+	// list used to find expired nodes
+	protected Vector<ISBNode> windowNodes;
+	protected ISBIndex ISB;
+	protected int m_WindowSize;
+	protected double m_radius;
+	protected double m_Fraction;
+	protected boolean bWarning = false;
+
+	// statistics
+	public int m_nBothInlierOutlier;
+	public int m_nOnlyInlier;
+	public int m_nOnlyOutlier;
+
+	@Override
+	public String getObjectInfo(Object obj) {
+		if (obj == null)
+			return null;
+
+		ISBNode node = (ISBNode) obj;
+
+		ArrayList<String> infoTitle = new ArrayList<>();
+		ArrayList<String> infoValue = new ArrayList<>();
+		StringBuilder sb = new StringBuilder();
+
+		// show node position
+		for (int i = 0; i < node.obj.dimensions(); i++) {
+			infoTitle.add("Dim" + (i + 1));
+			infoValue.add(String.format("%.3f", node.obj.get(i)));
+		}
+
+		// show node properties
+		infoTitle.add("id");
+		infoValue.add(String.format("%d", node.id));
+
+		sb.append("<html>");
+		sb.append("<table>");
+		int i = 0;
+		while (i < infoTitle.size() && i < infoValue.size()) {
+			sb.append("<tr><td><b>" + infoTitle.get(i) + ":</b></td><td>" + infoValue.get(i) + "</td></tr>");
+			i++;
+		}
+		sb.append("</table>");
+
+		sb.append("</html>");
+		return sb.toString();
+	}
+
+	@Override
+	public String getStatistics() {
+		StringBuilder sb = new StringBuilder();
+
+		sb.append("Statistics:\n\n");
+
+		// get counters of expired nodes
+		int nBothInlierOutlier = m_nBothInlierOutlier;
+		int nOnlyInlier = m_nOnlyInlier;
+		int nOnlyOutlier = m_nOnlyOutlier;
+
+		// add counters of non expired nodes
+		for (ISBNode node : windowNodes) {
+			if ((node.nInlier > 0) && (node.nOutlier > 0))
+				nBothInlierOutlier++;
+			else if (node.nInlier > 0)
+				nOnlyInlier++;
+			else
+				nOnlyOutlier++;
+		}
+
+		int sum = nBothInlierOutlier + nOnlyInlier + nOnlyOutlier;
+		if (sum > 0) {
+			sb.append(String.format("  Nodes always inlier: %d (%.1f%%)\n", nOnlyInlier,
+					(100 * nOnlyInlier) / (double) sum));
+			sb.append(String.format("  Nodes always outlier: %d (%.1f%%)\n", nOnlyOutlier,
+					(100 * nOnlyOutlier) / (double) sum));
+			sb.append(String.format("  Nodes both inlier and outlier: %d (%.1f%%)\n", nBothInlierOutlier,
+					(100 * nBothInlierOutlier) / (double) sum));
+
+			sb.append("  (Sum: " + sum + ")\n");
+		}
+
+		sb.append("\n  Total range queries: " + nRangeQueriesExecuted + "\n");
+		sb.append("  Max memory usage: " + iMaxMemUsage + " MB\n");
+		sb.append("  Total process time: " + String.format("%.2f ms", nTotalRunTime / 1000.0) + "\n");
+
+		return sb.toString();
+	}
+
+	Long GetWindowEnd() {
+		return objId - 1;
+	}
+
+	Long GetWindowStart() {
+		Long x = GetWindowEnd() - m_WindowSize + 1;
+		if (x < FIRST_OBJ_ID)
+			x = FIRST_OBJ_ID;
+		return x;
+	}
+
+	boolean IsWinFull() {
+		return (GetWindowEnd() >= FIRST_OBJ_ID + m_WindowSize - 1);
+	}
+
+	Long GetExpirationTime(ISBNode node) {
+		return node.id + m_WindowSize;
+	}
+
+	void AddNode(ISBNode node) {
+		windowNodes.add(node);
+		ISB.Insert(node);
+	}
+
+	void RemoveNode(ISBNode node) {
+		windowNodes.remove(node);
+		ISB.Remove(node);
+		RemoveExpiredOutlier(new Outlier(node.inst, node.id, node)); // ### remove when expired?
+		// update statistics
+		if ((node.nInlier > 0) && (node.nOutlier > 0))
+			m_nBothInlierOutlier++;
+		else if (node.nInlier > 0)
+			m_nOnlyInlier++;
+		else
+			m_nOnlyOutlier++;
+	}
+
+	ISBNode GetExpiredNode() {
+		if (windowNodes.size() <= 0)
+			return null;
+		// get oldest node
+		ISBNode node = windowNodes.get(0);
+		// check if node has expired
+		if (node.id < GetWindowStart()) {
+			return node;
+		}
+		return null;
+	}
+
+	void SaveOutlier(ISBNode node) {
+		AddOutlier(new Outlier(node.inst, node.id, node));
+		node.nOutlier++; // update statistics
+	}
+
+	void RemoveOutlier(ISBNode node) {
+		RemoveOutlier(new Outlier(node.inst, node.id, node));
+		node.nInlier++; // update statistics
+	}
+
+	@Override
+	protected boolean IsNodeIdInWin(long id) {
+		if ((GetWindowStart() <= id) && (id <= GetWindowEnd()))
+			return true;
+		else
+			return false;
+	}
+
+	void PrintWindow() {
+		Println("Window [" + GetWindowStart() + "-" + GetWindowEnd() + "]: ");
+		ISBNode node;
+		for (int i = 0; i < windowNodes.size(); i++) {
+			node = windowNodes.get(i);
+			Print("   Node: ");
+			PrintNode(node);
+		}
+	}
+
+	void PrintNode(ISBNode n) {
+		Print("id=" + n.id + " (");
+		int dim = n.obj.dimensions();
+		for (int d = 0; d < dim; d++) {
+			Print(Double.toString(n.obj.get(d)));
+			if (d < dim - 1)
+				Print(", ");
+		}
+		Println(")");
+	}
+
+	public void Print_lt_cnt(ArrayList<Integer> lt_cnt) {
+		for (int i = 0; i < lt_cnt.size(); i++) {
+			Print("(" + i + ": " + lt_cnt.get(i) + ") ");
+		}
+		Println("");
+	}
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/AbstractC/ISBIndex.java b/moa/src/main/java/moa/learners/clusterers/outliers/AbstractC/ISBIndex.java
new file mode 100644
index 000000000..77c87c14e
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/AbstractC/ISBIndex.java
@@ -0,0 +1,170 @@
+/*
+ *    ISBIndex.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers.AbstractC;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.Vector;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+public class ISBIndex {
+	public static class ISBNode {
+		public Instance inst;
+		public StreamObj obj;
+		public Long id;
+		public ArrayList<Integer> lt_cnt;
+
+		// statistics
+		public int nOutlier;
+		public int nInlier;
+
+		public ISBNode(Instance inst, StreamObj obj, Long id) {
+			this.inst = inst;
+			this.obj = obj;
+			this.id = id;
+			lt_cnt = new ArrayList<>();
+
+			// init statistics
+			nOutlier = 0;
+			nInlier = 0;
+		}
+	}
+
+	MyMTree mtree;
+	Map<Integer, Set<ISBNode>> mapNodes;
+	double m_radius;
+	double m_Fraction;
+
+	public ISBIndex(double radius, double fra) {
+		mtree = new MyMTree();
+		mapNodes = new HashMap<>();
+		m_radius = radius;
+		m_Fraction = fra;
+	}
+
+	public static class ISBSearchResult {
+		public ISBNode node;
+		public double distance;
+
+		public ISBSearchResult(ISBNode n, double distance) {
+			this.node = n;
+			this.distance = distance;
+		}
+	}
+
+	public Vector<ISBSearchResult> RangeSearch(ISBNode node, double radius) {
+		Vector<ISBSearchResult> results = new Vector<>();
+		// execute range search at mtree
+		StreamObj obj;
+		double d;
+		MyMTree.Query query = mtree.getNearestByRange(node.obj, radius);
+		for (MyMTree.ResultItem q : query) {
+			// get next obj found within range
+			obj = q.data;
+			// get distance of obj from query
+			d = q.distance;
+			// get all nodes referencing obj
+			Vector<ISBNode> nodes = MapGetNodes(obj);
+			for (int i = 0; i < nodes.size(); i++)
+				results.add(new ISBSearchResult(nodes.get(i), d));
+		}
+		return results;
+	}
+
+	public void Insert(ISBNode node) {
+		// insert object of node at mtree
+		mtree.add(node.obj);
+		// insert node at map
+		MapInsert(node);
+	}
+
+	public void Remove(ISBNode node) {
+		// remove from map
+		MapDelete(node);
+		// check if stream object at mtree is still being referenced
+		if (MapCountObjRefs(node.obj) <= 0) {
+			// delete stream object from mtree
+			mtree.remove(node.obj);
+		}
+	}
+
+	Vector<ISBNode> MapGetNodes(StreamObj obj) {
+		int h = obj.hashCode();
+		Vector<ISBNode> v = new Vector<>();
+		if (mapNodes.containsKey(h)) {
+			Set<ISBNode> s = mapNodes.get(h);
+			ISBNode node;
+			Iterator<ISBNode> i = s.iterator();
+			while (i.hasNext()) {
+				node = i.next();
+				if (node.obj.equals(obj))
+					v.add(node);
+			}
+		}
+		return v;
+	}
+
+	int MapCountObjRefs(StreamObj obj) {
+		int h = obj.hashCode();
+		int iCount = 0;
+		if (mapNodes.containsKey(h)) {
+			Set<ISBNode> s = mapNodes.get(h);
+			ISBNode n;
+			Iterator<ISBNode> i = s.iterator();
+			while (i.hasNext()) {
+				n = i.next();
+				if (n.obj.equals(obj))
+					iCount++;
+			}
+		}
+		return iCount;
+	}
+
+	void MapInsert(ISBNode node) {
+		int h = node.obj.hashCode();
+		Set<ISBNode> s;
+		if (mapNodes.containsKey(h)) {
+			s = mapNodes.get(h);
+			s.add(node);
+		} else {
+			s = new HashSet<>();
+			s.add(node);
+			mapNodes.put(h, s);
+		}
+	}
+
+	void MapDelete(ISBNode node) {
+		int h = node.obj.hashCode();
+		if (mapNodes.containsKey(h)) {
+			Set<ISBNode> s = mapNodes.get(h);
+			s.remove(node);
+			if (s.isEmpty()) { // ### added
+				mapNodes.remove(h);
+			}
+		}
+	}
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/AbstractC/MyMTree.java b/moa/src/main/java/moa/learners/clusterers/outliers/AbstractC/MyMTree.java
new file mode 100644
index 000000000..3211e6e5a
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/AbstractC/MyMTree.java
@@ -0,0 +1,66 @@
+/*
+ *    MyMTree.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers.AbstractC;
+
+import java.util.Set;
+
+import moa.learners.clusterers.outliers.utils.mtree.ComposedSplitFunction;
+import moa.learners.clusterers.outliers.utils.mtree.DistanceFunction;
+import moa.learners.clusterers.outliers.utils.mtree.DistanceFunctions;
+import moa.learners.clusterers.outliers.utils.mtree.MTree;
+import moa.learners.clusterers.outliers.utils.mtree.PartitionFunctions;
+import moa.learners.clusterers.outliers.utils.mtree.PromotionFunction;
+import moa.learners.clusterers.outliers.utils.mtree.utils.Pair;
+import moa.learners.clusterers.outliers.utils.mtree.utils.Utils;
+
+class MyMTree extends MTree<StreamObj> {
+
+	private static final PromotionFunction<StreamObj> nonRandomPromotion = new PromotionFunction<StreamObj>() {
+
+		@Override
+		public Pair<StreamObj> process(Set<StreamObj> dataSet, DistanceFunction<? super StreamObj> distanceFunction) {
+			return Utils.minMax(dataSet);
+		}
+	};
+
+	MyMTree() {
+		super(2, DistanceFunctions.EUCLIDEAN, new ComposedSplitFunction<>(nonRandomPromotion,
+				new PartitionFunctions.BalancedPartition<StreamObj>()));
+	}
+
+	@Override
+	public void add(StreamObj data) {
+		super.add(data);
+		_check();
+	}
+
+	@Override
+	public boolean remove(StreamObj data) {
+		boolean result = super.remove(data);
+		_check();
+		return result;
+	}
+
+	DistanceFunction<? super StreamObj> getDistanceFunction() {
+		return distanceFunction;
+	}
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/AbstractC/StreamObj.java b/moa/src/main/java/moa/learners/clusterers/outliers/AbstractC/StreamObj.java
new file mode 100644
index 000000000..8fb5aacfc
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/AbstractC/StreamObj.java
@@ -0,0 +1,96 @@
+/*
+ *    StreamObj.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers.AbstractC;
+
+import moa.learners.clusterers.outliers.utils.mtree.DistanceFunctions.EuclideanCoordinate;
+
+public class StreamObj implements EuclideanCoordinate, Comparable<StreamObj> {
+	private final double[] values;
+	private final int hashCode;
+
+	public StreamObj(double... values) {
+		this.values = values;
+
+		int h = 1;
+		for (double value : values) {
+			h = 31 * h + (int) value;
+		}
+		this.hashCode = h;
+	}
+
+	@Override
+	public int dimensions() {
+		return values.length;
+	}
+
+	@Override
+	public double get(int index) {
+		return values[index];
+	}
+
+	@Override
+	public int hashCode() {
+		return hashCode;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (obj instanceof StreamObj) {
+			StreamObj that = (StreamObj) obj;
+			if (this.dimensions() != that.dimensions()) {
+				return false;
+			}
+			for (int i = 0; i < this.dimensions(); i++) {
+				if (this.values[i] != that.values[i]) {
+					return false;
+				}
+			}
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	@Override
+	public int compareTo(StreamObj that) {
+		int dimensions = Math.min(this.dimensions(), that.dimensions());
+		for (int i = 0; i < dimensions; i++) {
+			double v1 = this.values[i];
+			double v2 = that.values[i];
+			if (v1 > v2) {
+				return +1;
+			}
+			if (v1 < v2) {
+				return -1;
+			}
+		}
+
+		if (this.dimensions() > dimensions) {
+			return +1;
+		}
+
+		if (that.dimensions() > dimensions) {
+			return -1;
+		}
+
+		return 0;
+	}
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/AbstractC/Test.java b/moa/src/main/java/moa/learners/clusterers/outliers/AbstractC/Test.java
new file mode 100644
index 000000000..af3bdff44
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/AbstractC/Test.java
@@ -0,0 +1,65 @@
+/*
+ *    Test.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers.AbstractC;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.streams.clustering.RandomRBFGeneratorEvents;
+
+public class Test {
+	public static void main(String[] args) throws Exception {
+		// if (true) return;
+
+		int numInstances = 10000;
+		// moa.streams.ArffFileStream stream = new
+		// ArffFileStream("./datasets/debug_1.txt", -1);
+		RandomRBFGeneratorEvents stream = new RandomRBFGeneratorEvents();
+		stream.prepareForUse();
+
+		AbstractC myOutlierDetector = new AbstractC();
+		/*
+		 * myOutlierDetector.fractionOption.setValue(0.2);
+		 * myOutlierDetector.radiusOption.setValue(3);
+		 * myOutlierDetector.windowSizeOption.setValue(12);
+		 */
+		myOutlierDetector.setModelContext(stream.getHeader());
+		myOutlierDetector.prepareForUse();
+
+		Long tmStart = System.currentTimeMillis();
+
+		int numberSamples = 0;
+		int w = myOutlierDetector.windowSizeOption.getValue();
+		while (stream.hasMoreInstances() && (numberSamples < numInstances)) {
+			Instance newInst = stream.nextInstance().getData();
+			myOutlierDetector.processNewInstanceImpl(newInst);
+			numberSamples++;
+			if (numberSamples % 100 == 0) {
+				// System.out.println("Processed " + numberSamples + " stream objects.");
+			}
+			if ((numberSamples % (w / 2)) == 0) {
+				// myOutlierDetector.PrintOutliers();
+			}
+		}
+		// myOutlierDetector.PrintOutliers();
+		System.out.println("Total time = " + (System.currentTimeMillis() - tmStart) + " ms");
+	}
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/ApproxSTORM.java b/moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/ApproxSTORM.java
new file mode 100644
index 000000000..c283a3329
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/ApproxSTORM.java
@@ -0,0 +1,359 @@
+/*
+ *    ApproxSTORM.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers.Angiulli;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Random;
+import java.util.Set;
+import java.util.Vector;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.learners.clusterers.outliers.Angiulli.ISBIndex.ISBNode;
+import moa.learners.clusterers.outliers.Angiulli.ISBIndex.ISBSearchResult;
+
+public class ApproxSTORM extends STORMBase {
+	public class ISBNodeAppr extends ISBNode {
+		public Long count_after, count_before;
+		public double fract_before;
+
+		public ISBNodeAppr(Instance inst, StreamObj obj, Long id, int k) {
+			super(inst, obj, id);
+			m_k = k;
+			count_after = 0L;
+			count_before = 0L;
+			fract_before = 0;
+		}
+	}
+
+	public FloatOption radiusOption = new FloatOption("radius", 'r', "Search radius.", 0.1);
+	public IntOption kOption = new IntOption("k", 't', "Parameter k.", 50);
+	public IntOption queryFreqOption = new IntOption("queryFreq", 'q', "Query frequency.", 1);
+	public FloatOption pOption = new FloatOption("p", 'p', "Parameter p.", 0.1);
+
+	Set<ISBNode> safe_inliers; // list of safe inliers
+	int m_FractWindowSize;
+	Random m_Random;
+
+	@Override
+	public String getObjectInfo(Object obj) {
+		if (obj == null)
+			return null;
+
+		ISBNodeAppr node = (ISBNodeAppr) obj;
+
+		ArrayList<String> infoTitle = new ArrayList<>();
+		ArrayList<String> infoValue = new ArrayList<>();
+		StringBuilder sb = new StringBuilder();
+
+		// show node position
+		for (int i = 0; i < node.obj.dimensions(); i++) {
+			infoTitle.add("Dim" + (i + 1));
+			infoValue.add(String.format("%.3f", node.obj.get(i)));
+		}
+
+		// show node properties
+		infoTitle.add("id");
+		infoValue.add(String.format("%d", node.id));
+		infoTitle.add("count_after");
+		infoValue.add(String.format("%d", node.count_after));
+		infoTitle.add("count_before");
+		infoValue.add(String.format("%d", node.count_before));
+
+		sb.append("<html>");
+		sb.append("<table>");
+		int i = 0;
+		while (i < infoTitle.size() && i < infoValue.size()) {
+			sb.append("<tr><td><b>" + infoTitle.get(i) + ":</b></td><td>" + infoValue.get(i) + "</td></tr>");
+			i++;
+		}
+		sb.append("</table>");
+
+		sb.append("</html>");
+		return sb.toString();
+	}
+
+	public ApproxSTORM() {
+		// System.out.println("DistanceOutliersAppr: created");
+	}
+
+	@Override
+	public void Init() {
+		super.Init();
+
+		m_WindowSize = windowSizeOption.getValue();
+		m_radius = radiusOption.getValue();
+		m_k = kOption.getValue();
+		m_QueryFreq = queryFreqOption.getValue();
+		m_FractWindowSize = (int) (pOption.getValue() * m_WindowSize);
+
+		Println("Init DistanceOutliersAppr:");
+		Println("   window_size: " + m_WindowSize);
+		Println("   radius: " + m_radius);
+		Println("   k: " + m_k);
+		Println("   query_freq: " + m_QueryFreq);
+
+		m_Random = new Random();
+
+		objId = FIRST_OBJ_ID; // init object identifier
+		// create fifo
+		windowNodes = new Vector<>();
+		// create ISB
+		ISB = new ISBIndex(m_radius, m_k);
+		// create safe_inliers list
+		safe_inliers = new HashSet<>();
+
+		// init statistics
+		m_nBothInlierOutlier = 0;
+		m_nOnlyInlier = 0;
+		m_nOnlyOutlier = 0;
+	}
+
+	void AddSafeInlier(ISBNode node) {
+		safe_inliers.add(node);
+	}
+
+	ISBNode GetSafeInlier(int idx) {
+		ISBNode node = null;
+		Iterator it = safe_inliers.iterator();
+		while (idx >= 0) {
+			node = (ISBNodeAppr) it.next();
+			idx--;
+		}
+		return node;
+	}
+
+	boolean IsSafeInlier(ISBNodeAppr node) {
+		return node.count_after >= m_k;
+	}
+
+	void PrintSafeInliers() {
+		Print("Safe inliers: ");
+		ISBNode node;
+		Iterator it = safe_inliers.iterator();
+		while (it.hasNext()) {
+			node = (ISBNode) it.next();
+			Print(node.id + " ");
+		}
+		Println(" ");
+	}
+
+	void RemoveNode(ISBNode node) {
+		// remove node from ISB
+		ISB.Remove(node);
+		// remove from fifo
+		windowNodes.remove(node);
+		// remove node from safe_inliers
+		safe_inliers.remove(node);
+		// remove from outliers
+		RemoveExpiredOutlier(new Outlier(node.inst, node.id, node));
+		// update statistics
+		UpdateStatistics(node);
+	}
+
+	void RemoveSafeInlier(ISBNode node) {
+		// remove node from ISB
+		ISB.Remove(node);
+		// remove node from safe_inliers
+		safe_inliers.remove(node);
+	}
+
+	void DeleteExpiredNode() {
+		if (windowNodes.size() <= 0)
+			return;
+
+		// get oldest node
+		ISBNode node = windowNodes.get(0);
+		// check if node has expired
+		if (node.id < GetWindowStart()) {
+			if (bTrace) {
+				Print("Delete expired node: ");
+				PrintNode(node);
+			}
+			// remove node
+			RemoveNode(node);
+		}
+	}
+
+	@Override
+	protected void ProcessNewStreamObj(Instance inst) {
+		if (bShowProgress)
+			ShowProgress("Processed " + objId + " stream objects.");
+		// PrintInstance(inst);
+
+		double[] values = getInstanceValues(inst);
+		StreamObj obj = new StreamObj(values);
+
+		if (bTrace)
+			Println("\n- - - - - - - - - - - -\n");
+
+		// delete a node if it has expired
+		DeleteExpiredNode();
+
+		// create new ISB node
+		ISBNodeAppr nodeNew = new ISBNodeAppr(inst, obj, objId, m_k);
+		if (bTrace) {
+			Print("New obj: ");
+			PrintNode(nodeNew);
+		}
+
+		// update object identifier
+		objId++;
+
+		// init nodeNew
+		nodeNew.count_after = 1L;
+		nodeNew.count_before = 0L;
+
+		// perform range query search
+		if (bTrace)
+			Println("Perform range query seach:");
+		nRangeQueriesExecuted++;
+		Vector<ISBIndex.ISBSearchResult> nodes = ISB.RangeSearch(nodeNew, m_radius);
+
+		// process each returned node
+		int nSafeInliers;
+		Long count_si_before = 0L;
+		for (ISBSearchResult res : nodes) {
+			ISBNodeAppr n = (ISBNodeAppr) res.node;
+			if (bTrace) {
+				Printf("   Found at d=%.2f: ", res.distance);
+				PrintNode(res.node);
+			}
+
+			n.count_after++;
+
+			if (IsSafeInlier(n)) {
+				if (bTrace)
+					Println("   Safe inlier: id=" + n.id);
+				AddSafeInlier(n);
+				count_si_before++;
+			}
+
+			nSafeInliers = safe_inliers.size();
+			if (nSafeInliers > m_FractWindowSize) {
+				// get a random safe inlier: 0 <= idx < nSafeInliers
+				int idx = m_Random.nextInt(nSafeInliers);
+				ISBNode si = GetSafeInlier(idx);
+				if (bTrace)
+					Println("   Remove random safe inlier: id=" + si.id);
+				// remove node from ISB and safe-inliers-list
+				RemoveSafeInlier(si);
+			}
+
+			nodeNew.count_before++;
+		}
+
+		// Set fract_before of curr_node which is determined as the ratio
+		// between the number of preceding neighbors of curr_node in ISB
+		// which are safe inliers and the total number of safe inliers in
+		// ISB, at the arrival time of curr_node.
+
+		nSafeInliers = safe_inliers.size();
+		if (nSafeInliers > 0) {
+			nodeNew.fract_before = (double) count_si_before / (double) nSafeInliers;
+		} else {
+			if (bTrace)
+				Println("Set fract before: no safe inliers yet, set 0.");
+			nodeNew.fract_before = 0;
+		}
+
+		if (bTrace) {
+			Println("Node: ");
+			Println("   count_after=" + nodeNew.count_after);
+			Println("   count_before=" + nodeNew.count_before);
+			Printf("   fract_before=%.3f\n", nodeNew.fract_before);
+			Println("Insert new node to ISB.");
+		}
+
+		// insert node to ISB
+		ISB.Insert(nodeNew);
+
+		// insert node at window
+		windowNodes.add(nodeNew);
+
+		if (bTrace) {
+			PrintWindow();
+			PrintSafeInliers();
+		}
+
+		if (CanSearch()) {
+			// invoke query function to detect outliers
+			SearchOutliers();
+		} else {
+			// update statistics outlierness of new node
+			UpdateNodeStatistics(nodeNew);
+		}
+	}
+
+	void SearchOutliers() {
+		if (bTrace)
+			Println("Invoke query: ");
+		ISBNodeAppr node;
+		// process each node in the ISB (also in window)
+		for (int i = 0; i < windowNodes.size(); i++) {
+			node = (ISBNodeAppr) windowNodes.get(i);
+			if (bTrace) {
+				Print("   Process node: ");
+				PrintNode(node);
+			}
+			UpdateNodeType(node);
+		}
+	}
+
+	void UpdateNodeType(ISBNodeAppr node) {
+		double succ_neighs, prec_neighs;
+
+		// get number of succeeding neighbors
+		succ_neighs = node.count_after;
+		if (bTrace)
+			Println("      succ_neighs: " + succ_neighs);
+
+		// get number of preceding neighbors
+		prec_neighs = node.fract_before * Math.abs((node.id + m_WindowSize) - GetWindowEnd());
+		if (bTrace)
+			Println("      prec_neighs: " + prec_neighs);
+
+		// check if node is an outlier
+		if (succ_neighs + prec_neighs < m_k) {
+			SaveOutlier(node);
+			if (bTrace) {
+				Print("*** Outlier: ");
+				PrintNode(node);
+			}
+		} else {
+			RemoveOutlier(node);
+		}
+	}
+
+	void UpdateNodeStatistics(ISBNodeAppr node) {
+		double succ_neighs = node.count_after;
+		double prec_neighs = node.fract_before * Math.abs((node.id + m_WindowSize) - GetWindowEnd());
+		if (succ_neighs + prec_neighs < m_k) {
+			node.nOutlier++; // update statistics
+		} else {
+			node.nInlier++; // update statistics
+		}
+	}
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/ExactSTORM.java b/moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/ExactSTORM.java
new file mode 100644
index 000000000..7e57015ec
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/ExactSTORM.java
@@ -0,0 +1,308 @@
+/*
+ *    ExactSTORM.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.clusterers.outliers.Angiulli;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Vector;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.learners.clusterers.outliers.Angiulli.ISBIndex.ISBNode;
+import moa.learners.clusterers.outliers.Angiulli.ISBIndex.ISBSearchResult;
+
+// The algorithm is presented in "Distance-based outlier queries in data streams: the novel task and algorithms.
+//Data Mining and Knowledge Discovery, 20(2):290–324,2010.
+
+public class ExactSTORM extends STORMBase {
+	public class ISBNodeExact extends ISBNode {
+		public int count_after;
+		// nn_before:
+		// A list that needs O(logn) time for ordered insertion and search.
+		// It must be able to perform a search in the list using e.g. <=.
+		private ArrayList<Long> nn_before;
+
+		public ISBNodeExact(Instance inst, StreamObj obj, Long id, int k) {
+			super(inst, obj, id);
+			m_k = k;
+			count_after = 0;
+			nn_before = new ArrayList<>();
+		}
+
+		public void AddPrecNeigh(Long id) {
+			int pos = Collections.binarySearch(nn_before, id);
+			if (pos < 0) {
+				// item does not exist, so add it to the right position
+				nn_before.add(-(pos + 1), id);
+			}
+		}
+
+		public int CountPrecNeighs(Long sinceId) {
+			if (nn_before.size() > 0) {
+				// get number of neighs with id >= sinceId
+				int startPos;
+				int pos = Collections.binarySearch(nn_before, sinceId);
+				if (pos < 0) {
+					// item does not exist, should insert at position startPos
+					startPos = -(pos + 1);
+				} else {
+					// item exists at startPos
+					startPos = pos;
+				}
+
+				if (startPos < nn_before.size()) {
+					return nn_before.size() - startPos;
+				}
+			}
+			return 0;
+		}
+
+		public void PrintPrecNeighs() {
+			Print("      nn_before: ");
+			Iterator it = nn_before.iterator();
+			while (it.hasNext()) {
+				Print(it.next() + " ");
+			}
+			Println(" ");
+		}
+	}
+
+	public FloatOption radiusOption = new FloatOption("radius", 'r', "Search radius.", 0.1);
+	public IntOption kOption = new IntOption("k", 't', "Parameter k.", 50);
+	public IntOption queryFreqOption = new IntOption("queryFreq", 'q', "Query frequency.", 1);
+
+	public ExactSTORM() {
+		// System.out.println("DistanceOutliersExact: created");
+	}
+
+	@Override
+	public String getObjectInfo(Object obj) {
+		if (obj == null)
+			return null;
+
+		ISBNodeExact node = (ISBNodeExact) obj;
+
+		ArrayList<String> infoTitle = new ArrayList<>();
+		ArrayList<String> infoValue = new ArrayList<>();
+		StringBuilder sb = new StringBuilder();
+
+		// show node position
+		for (int i = 0; i < node.obj.dimensions(); i++) {
+			infoTitle.add("Dim" + (i + 1));
+			infoValue.add(String.format("%.3f", node.obj.get(i)));
+		}
+
+		// show node properties
+		infoTitle.add("id");
+		infoValue.add(String.format("%d", node.id));
+		infoTitle.add("count_after");
+		infoValue.add(String.format("%d", node.count_after));
+		infoTitle.add("|nn_before|");
+		infoValue.add(String.format("%d", node.CountPrecNeighs(GetWindowStart())));
+
+		sb.append("<html>");
+		sb.append("<table>");
+		int i = 0;
+		while (i < infoTitle.size() && i < infoValue.size()) {
+			sb.append("<tr><td><b>" + infoTitle.get(i) + ":</b></td><td>" + infoValue.get(i) + "</td></tr>");
+			i++;
+		}
+		sb.append("</table>");
+
+		sb.append("</html>");
+		return sb.toString();
+	}
+
+	@Override
+	public void Init() {
+		super.Init();
+
+		m_WindowSize = windowSizeOption.getValue();
+		m_radius = radiusOption.getValue();
+		m_k = kOption.getValue();
+		m_QueryFreq = queryFreqOption.getValue();
+
+		Println("Init DistanceOutliersExact:");
+		Println("   window_size: " + m_WindowSize);
+		Println("   radius: " + m_radius);
+		Println("   k: " + m_k);
+		Println("   query_freq: " + m_QueryFreq);
+
+		objId = FIRST_OBJ_ID; // init object identifier
+		// create fifo
+		windowNodes = new Vector<>();
+		// create ISB
+		ISB = new ISBIndex(m_radius, m_k);
+
+		// init statistics
+		m_nBothInlierOutlier = 0;
+		m_nOnlyInlier = 0;
+		m_nOnlyOutlier = 0;
+	}
+
+	void RemoveNode(ISBNode node) {
+		// remove node from ISB
+		ISB.Remove(node);
+		// remove from fifo
+		windowNodes.remove(node);
+		// remove from outliers
+		RemoveExpiredOutlier(new Outlier(node.inst, node.id, node));
+		// update statistics
+		UpdateStatistics(node);
+	}
+
+	void DeleteExpiredNode() {
+		if (windowNodes.size() <= 0)
+			return;
+
+		// get oldest node
+		ISBNode node = windowNodes.get(0);
+		// check if node has expired
+		if (node.id < GetWindowStart()) {
+			if (bTrace) {
+				Print("Delete expired node: ");
+				PrintNode(node);
+			}
+			// remove node
+			RemoveNode(node);
+		}
+	}
+
+	@Override
+	protected void ProcessNewStreamObj(Instance inst) {
+		if (bShowProgress)
+			ShowProgress("Processed " + objId + " stream objects.");
+		// PrintInstance(inst);
+
+		double[] values = getInstanceValues(inst);
+		StreamObj obj = new StreamObj(values);
+
+		if (bTrace)
+			Println("\n- - - - - - - - - - - -\n");
+
+		// create new ISB node
+		ISBNodeExact nodeNew = new ISBNodeExact(inst, obj, objId, m_k);
+		if (bTrace) {
+			Print("New obj: ");
+			PrintNode(nodeNew);
+		}
+		// update object identifier
+		objId++;
+
+		// delete a node if it has expired
+		DeleteExpiredNode();
+
+		// init nodeNew
+		nodeNew.count_after = 1;
+
+		// perform range query search
+		if (bTrace)
+			Println("Perform range query seach:");
+		nRangeQueriesExecuted++;
+		Vector<ISBIndex.ISBSearchResult> nodes = ISB.RangeSearch(nodeNew, m_radius);
+
+		// process each returned node
+		for (ISBSearchResult res : nodes) {
+			ISBNodeExact n = (ISBNodeExact) res.node;
+			if (bTrace) {
+				Printf("   Found at d=%.2f: ", res.distance);
+				PrintNode(res.node);
+			}
+
+			n.count_after++;
+			nodeNew.AddPrecNeigh(res.node.id);
+		}
+
+		if (bTrace)
+			Println("Insert new node to ISB.");
+		ISB.Insert(nodeNew);
+
+		// insert node at window
+		windowNodes.add(nodeNew);
+		if (bTrace)
+			PrintWindow();
+
+		if (CanSearch()) {
+			// invoke query function to detect outliers
+			SearchOutliers();
+		} else {
+			// update statistics outlierness of new node
+			UpdateNodeStatistics(nodeNew);
+		}
+	}
+
+	void SearchOutliers() {
+		if (bTrace)
+			Println("Invoke query: ");
+		ISBNodeExact node;
+		// process each node in the ISB (also in window)
+		for (int i = 0; i < windowNodes.size(); i++) {
+			node = (ISBNodeExact) windowNodes.get(i);
+			if (bTrace) {
+				Print("   Process node: ");
+				PrintNode(node);
+			}
+			UpdateNodeType(node);
+		}
+	}
+
+	void UpdateNodeType(ISBNodeExact node) {
+		int succ_neighs, prec_neighs;
+
+		// get number of succeeding neighbors
+		succ_neighs = node.count_after;
+		if (bTrace)
+			Println("      succ_neighs: " + succ_neighs);
+
+		// get number of preceding neighbors with
+		// non-expired objects determined
+		prec_neighs = node.CountPrecNeighs(GetWindowStart());
+		if (bTrace) {
+			Println("      GetWindowStart(): " + GetWindowStart());
+			node.PrintPrecNeighs();
+			Println("      prec_neighs: " + prec_neighs);
+		}
+
+		// check if node is an outlier
+		if (succ_neighs + prec_neighs < m_k) {
+			SaveOutlier(node);
+			if (bTrace) {
+				Print("*** Outlier: ");
+				PrintNode(node);
+			}
+		} else {
+			RemoveOutlier(node);
+		}
+	}
+
+	void UpdateNodeStatistics(ISBNodeExact node) {
+		int succ_neighs = node.count_after;
+		int prec_neighs = node.CountPrecNeighs(GetWindowStart());
+		if (succ_neighs + prec_neighs < m_k) {
+			node.nOutlier++; // update statistics
+		} else {
+			node.nInlier++; // update statistics
+		}
+	}
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/ISBIndex.java b/moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/ISBIndex.java
new file mode 100644
index 000000000..7fe52f00c
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/ISBIndex.java
@@ -0,0 +1,165 @@
+/*
+ *    ISBIndex.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.clusterers.outliers.Angiulli;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.Vector;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+public class ISBIndex {
+	public abstract static class ISBNode {
+		public Instance inst;
+		public StreamObj obj;
+		public Long id;
+
+		// statistics
+		public int nOutlier;
+		public int nInlier;
+
+		public ISBNode(Instance inst, StreamObj obj, Long id) {
+			this.inst = inst;
+			this.obj = obj;
+			this.id = id;
+
+			// init statistics
+			nOutlier = 0;
+			nInlier = 0;
+		}
+	}
+
+	MyMTree mtree;
+	Map<Integer, Set<ISBNode>> mapNodes;
+	double m_radius;
+	int m_k; // k nearest neighbors
+
+	public ISBIndex(double radius, int k) {
+		mtree = new MyMTree();
+		mapNodes = new HashMap<>();
+		m_radius = radius;
+		m_k = k;
+	}
+
+	public static class ISBSearchResult {
+		public ISBNode node;
+		public double distance;
+
+		public ISBSearchResult(ISBNode n, double distance) {
+			this.node = n;
+			this.distance = distance;
+		}
+	}
+
+	public Vector<ISBSearchResult> RangeSearch(ISBNode node, double radius) {
+		Vector<ISBSearchResult> results = new Vector<>();
+		// execute range search at mtree
+		StreamObj obj;
+		double d;
+		MyMTree.Query query = mtree.getNearestByRange(node.obj, radius);
+		for (MyMTree.ResultItem q : query) {
+			// get next obj found within range
+			obj = q.data;
+			// get distance of obj from query
+			d = q.distance;
+			// get all nodes referencing obj
+			Vector<ISBNode> nodes = MapGetNodes(obj);
+			for (int i = 0; i < nodes.size(); i++)
+				results.add(new ISBSearchResult(nodes.get(i), d));
+		}
+		return results;
+	}
+
+	public void Insert(ISBNode node) {
+		// insert object of node at mtree
+		mtree.add(node.obj);
+		// insert node at map
+		MapInsert(node);
+	}
+
+	public void Remove(ISBNode node) {
+		// remove from map
+		MapDelete(node);
+		// check if stream object at mtree is still being referenced
+		if (MapCountObjRefs(node.obj) <= 0) {
+			// delete stream object from mtree
+			mtree.remove(node.obj);
+		}
+	}
+
+	Vector<ISBNode> MapGetNodes(StreamObj obj) {
+		int h = obj.hashCode();
+		Vector<ISBNode> v = new Vector<>();
+		if (mapNodes.containsKey(h)) {
+			Set<ISBNode> s = mapNodes.get(h);
+			ISBNode node;
+			Iterator<ISBNode> i = s.iterator();
+			while (i.hasNext()) {
+				node = i.next();
+				if (node.obj.equals(obj))
+					v.add(node);
+			}
+		}
+		return v;
+	}
+
+	int MapCountObjRefs(StreamObj obj) {
+		int h = obj.hashCode();
+		int iCount = 0;
+		if (mapNodes.containsKey(h)) {
+			Set<ISBNode> s = mapNodes.get(h);
+			ISBNode n;
+			Iterator<ISBNode> i = s.iterator();
+			while (i.hasNext()) {
+				n = i.next();
+				if (n.obj.equals(obj))
+					iCount++;
+			}
+		}
+		return iCount;
+	}
+
+	void MapInsert(ISBNode node) {
+		int h = node.obj.hashCode();
+		Set<ISBNode> s;
+		if (mapNodes.containsKey(h)) {
+			s = mapNodes.get(h);
+			s.add(node);
+		} else {
+			s = new HashSet<>();
+			s.add(node);
+			mapNodes.put(h, s);
+		}
+	}
+
+	void MapDelete(ISBNode node) {
+		int h = node.obj.hashCode();
+		if (mapNodes.containsKey(h)) {
+			Set<ISBNode> s = mapNodes.get(h);
+			s.remove(node);
+			if (s.isEmpty()) { // ### added
+				mapNodes.remove(h);
+			}
+		}
+	}
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/MyMTree.java b/moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/MyMTree.java
new file mode 100644
index 000000000..1e40dde49
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/MyMTree.java
@@ -0,0 +1,65 @@
+/*
+ *    MyMTree.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers.Angiulli;
+
+import java.util.Set;
+
+import moa.learners.clusterers.outliers.utils.mtree.ComposedSplitFunction;
+import moa.learners.clusterers.outliers.utils.mtree.DistanceFunction;
+import moa.learners.clusterers.outliers.utils.mtree.DistanceFunctions;
+import moa.learners.clusterers.outliers.utils.mtree.MTree;
+import moa.learners.clusterers.outliers.utils.mtree.PartitionFunctions;
+import moa.learners.clusterers.outliers.utils.mtree.PromotionFunction;
+import moa.learners.clusterers.outliers.utils.mtree.utils.Pair;
+import moa.learners.clusterers.outliers.utils.mtree.utils.Utils;
+
+class MyMTree extends MTree<StreamObj> {
+
+	private static final PromotionFunction<StreamObj> nonRandomPromotion = new PromotionFunction<StreamObj>() {
+
+		@Override
+		public Pair<StreamObj> process(Set<StreamObj> dataSet, DistanceFunction<? super StreamObj> distanceFunction) {
+			return Utils.minMax(dataSet);
+		}
+	};
+
+	MyMTree() {
+		super(2, DistanceFunctions.EUCLIDEAN, new ComposedSplitFunction<>(nonRandomPromotion,
+				new PartitionFunctions.BalancedPartition<StreamObj>()));
+	}
+
+	@Override
+	public void add(StreamObj data) {
+		super.add(data);
+		_check();
+	}
+
+	@Override
+	public boolean remove(StreamObj data) {
+		boolean result = super.remove(data);
+		_check();
+		return result;
+	}
+
+	DistanceFunction<? super StreamObj> getDistanceFunction() {
+		return distanceFunction;
+	}
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/STORMBase.java b/moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/STORMBase.java
new file mode 100644
index 000000000..8c1a8d599
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/STORMBase.java
@@ -0,0 +1,163 @@
+/*
+ *    STORMBase.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers.Angiulli;
+
+import java.util.Vector;
+
+import com.github.javacliparser.FlagOption;
+
+import moa.learners.clusterers.outliers.MyBaseOutlierDetector;
+import moa.learners.clusterers.outliers.Angiulli.ISBIndex.ISBNode;
+
+public abstract class STORMBase extends MyBaseOutlierDetector {
+	public FlagOption waitWinFullOption = new FlagOption("waitWinFull", 'a', "Output outliers when windows is full.");
+
+	protected static final Long FIRST_OBJ_ID = 1L;
+
+	// object identifier increments with each new data stream object
+	protected Long objId;
+	// list used to find expired nodes
+	protected Vector<ISBNode> windowNodes;
+	protected ISBIndex ISB;
+	protected int m_WindowSize;
+	protected double m_radius;
+	protected int m_k;
+	// perform a query every m_QueryFreq objects
+	protected int m_QueryFreq;
+
+	// statistics
+	public int m_nBothInlierOutlier;
+	public int m_nOnlyInlier;
+	public int m_nOnlyOutlier;
+
+	@Override
+	public String getStatistics() {
+		StringBuilder sb = new StringBuilder();
+
+		sb.append("Statistics:\n\n");
+
+		// get counters of expired nodes
+		int nBothInlierOutlier = m_nBothInlierOutlier;
+		int nOnlyInlier = m_nOnlyInlier;
+		int nOnlyOutlier = m_nOnlyOutlier;
+
+		// add counters of non expired nodes
+		for (ISBNode node : windowNodes) {
+			if ((node.nInlier > 0) && (node.nOutlier > 0))
+				nBothInlierOutlier++;
+			else if (node.nInlier > 0)
+				nOnlyInlier++;
+			else
+				nOnlyOutlier++;
+		}
+
+		int sum = nBothInlierOutlier + nOnlyInlier + nOnlyOutlier;
+		if (sum > 0) {
+			sb.append(String.format("  Nodes always inlier: %d (%.1f%%)\n", nOnlyInlier,
+					(100 * nOnlyInlier) / (double) sum));
+			sb.append(String.format("  Nodes always outlier: %d (%.1f%%)\n", nOnlyOutlier,
+					(100 * nOnlyOutlier) / (double) sum));
+			sb.append(String.format("  Nodes both inlier and outlier: %d (%.1f%%)\n", nBothInlierOutlier,
+					(100 * nBothInlierOutlier) / (double) sum));
+
+			sb.append("  (Sum: " + sum + ")\n");
+		}
+
+		sb.append("\n  Total range queries: " + nRangeQueriesExecuted + "\n");
+		sb.append("  Max memory usage: " + iMaxMemUsage + " MB\n");
+		sb.append("  Total process time: " + String.format("%.2f ms", nTotalRunTime / 1000.0) + "\n");
+
+		return sb.toString();
+	}
+
+	Long GetWindowEnd() {
+		return objId - 1;
+	}
+
+	Long GetWindowStart() {
+		Long x = GetWindowEnd() - m_WindowSize + 1;
+		if (x < FIRST_OBJ_ID)
+			x = FIRST_OBJ_ID;
+		return x;
+	}
+
+	boolean IsWinFull() {
+		return (GetWindowEnd() >= FIRST_OBJ_ID + m_WindowSize - 1);
+	}
+
+	boolean CanSearch() {
+		if (IsWinFull() || !waitWinFullOption.isSet()) {
+			if ((GetWindowEnd() - FIRST_OBJ_ID + 1) % m_QueryFreq == 0) {
+				// perform query every m_QueryFreq objects
+				return true;
+			}
+		}
+		return false;
+	}
+
+	void SaveOutlier(ISBNode node) {
+		AddOutlier(new Outlier(node.inst, node.id, node));
+		node.nOutlier++; // update statistics
+	}
+
+	void RemoveOutlier(ISBNode node) {
+		RemoveOutlier(new Outlier(node.inst, node.id, node));
+		node.nInlier++; // update statistics
+	}
+
+	protected void UpdateStatistics(ISBNode node) {
+		if ((node.nInlier > 0) && (node.nOutlier > 0))
+			m_nBothInlierOutlier++;
+		else if (node.nInlier > 0)
+			m_nOnlyInlier++;
+		else
+			m_nOnlyOutlier++;
+	}
+
+	@Override
+	protected boolean IsNodeIdInWin(long id) {
+		if ((GetWindowStart() <= id) && (id <= GetWindowEnd()))
+			return true;
+		else
+			return false;
+	}
+
+	void PrintWindow() {
+		Println("Window [" + GetWindowStart() + "-" + GetWindowEnd() + "]: ");
+		ISBNode node;
+		for (int i = 0; i < windowNodes.size(); i++) {
+			node = windowNodes.get(i);
+			Print("   Node: ");
+			PrintNode(node);
+		}
+	}
+
+	void PrintNode(ISBNode n) {
+		Print("id=" + n.id + " (");
+		int dim = n.obj.dimensions();
+		for (int d = 0; d < dim; d++) {
+			Print(Double.toString(n.obj.get(d)));
+			if (d < dim - 1)
+				Print(", ");
+		}
+		Println(")");
+	}
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/StreamObj.java b/moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/StreamObj.java
new file mode 100644
index 000000000..1236f88f1
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/StreamObj.java
@@ -0,0 +1,96 @@
+/*
+ *    StreamObj.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers.Angiulli;
+
+import moa.learners.clusterers.outliers.utils.mtree.DistanceFunctions.EuclideanCoordinate;
+
+public class StreamObj implements EuclideanCoordinate, Comparable<StreamObj> {
+	private final double[] values;
+	private final int hashCode;
+
+	public StreamObj(double... values) {
+		this.values = values;
+
+		int h = 1;
+		for (double value : values) {
+			h = 31 * h + (int) value;
+		}
+		this.hashCode = h;
+	}
+
+	@Override
+	public int dimensions() {
+		return values.length;
+	}
+
+	@Override
+	public double get(int index) {
+		return values[index];
+	}
+
+	@Override
+	public int hashCode() {
+		return hashCode;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (obj instanceof StreamObj) {
+			StreamObj that = (StreamObj) obj;
+			if (this.dimensions() != that.dimensions()) {
+				return false;
+			}
+			for (int i = 0; i < this.dimensions(); i++) {
+				if (this.values[i] != that.values[i]) {
+					return false;
+				}
+			}
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	@Override
+	public int compareTo(StreamObj that) {
+		int dimensions = Math.min(this.dimensions(), that.dimensions());
+		for (int i = 0; i < dimensions; i++) {
+			double v1 = this.values[i];
+			double v2 = that.values[i];
+			if (v1 > v2) {
+				return +1;
+			}
+			if (v1 < v2) {
+				return -1;
+			}
+		}
+
+		if (this.dimensions() > dimensions) {
+			return +1;
+		}
+
+		if (that.dimensions() > dimensions) {
+			return -1;
+		}
+
+		return 0;
+	}
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/Test.java b/moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/Test.java
new file mode 100644
index 000000000..e5e5198d7
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/Angiulli/Test.java
@@ -0,0 +1,60 @@
+/*
+ *    Test.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers.Angiulli;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.streams.clustering.RandomRBFGeneratorEvents;
+
+public class Test {
+	public static void main(String[] args) throws Exception {
+		// if (true) return;
+
+		int numInstances = 10000;
+
+		RandomRBFGeneratorEvents stream = new RandomRBFGeneratorEvents();
+		stream.prepareForUse();
+
+		// DistanceOutliersAppr myOutlierDetector= new DistanceOutliersAppr();
+		ExactSTORM myOutlierDetector = new ExactSTORM();
+		myOutlierDetector.queryFreqOption.setValue(1);
+		myOutlierDetector.setModelContext(stream.getHeader());
+		myOutlierDetector.prepareForUse();
+
+		Long tmStart = System.currentTimeMillis();
+
+		int numberSamples = 0;
+		int w = myOutlierDetector.windowSizeOption.getValue();
+		while (stream.hasMoreInstances() && (numberSamples < numInstances)) {
+			Instance newInst = stream.nextInstance().getData();
+			myOutlierDetector.processNewInstanceImpl(newInst);
+			numberSamples++;
+			if (numberSamples % 100 == 0) {
+				// System.out.println("Processed " + numberSamples + " stream objects.");
+			}
+			if ((numberSamples % (w / 2)) == 0) {
+				// myOutlierDetector.PrintOutliers();
+			}
+		}
+		// myOutlierDetector.PrintOutliers();
+		System.out.println("Total time = " + (System.currentTimeMillis() - tmStart) + " ms");
+	}
+}
diff --git a/moa/src/main/java/moa/clusterers/outliers/AnyOut/AnyOut.java b/moa/src/main/java/moa/learners/clusterers/outliers/AnyOut/AnyOut.java
similarity index 57%
rename from moa/src/main/java/moa/clusterers/outliers/AnyOut/AnyOut.java
rename to moa/src/main/java/moa/learners/clusterers/outliers/AnyOut/AnyOut.java
index 16e4a0f45..871a75c7c 100644
--- a/moa/src/main/java/moa/clusterers/outliers/AnyOut/AnyOut.java
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/AnyOut/AnyOut.java
@@ -3,7 +3,7 @@
  *
  *    @author I. Assent, P. Kranen, C. Baldauf, T. Seidl
  *    @author G. Piskas, A. Gounaris
- * 
+ *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
@@ -15,28 +15,28 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.clusterers.outliers.AnyOut;
+package moa.learners.clusterers.outliers.AnyOut;
 
 import java.util.ArrayList;
 
 import com.github.javacliparser.Options;
 import com.yahoo.labs.samoa.instances.Instance;
 
-import moa.clusterers.outliers.MyBaseOutlierDetector;
-import moa.clusterers.outliers.AnyOut.util.DataObject;
-import moa.clusterers.outliers.AnyOut.util.DataSet;
+import moa.learners.clusterers.outliers.MyBaseOutlierDetector;
+import moa.learners.clusterers.outliers.AnyOut.util.DataObject;
+import moa.learners.clusterers.outliers.AnyOut.util.DataSet;
 
 public class AnyOut extends MyBaseOutlierDetector {
-	private static final long serialVersionUID = 1L; 
+	private static final long serialVersionUID = 1L;
 
 	private final int FIRST_OBJ_ID = 0;
 	private final double minDepth = 0.5;
 	private final double maxDepth = 0.9;
-	
+
 	private AnyOutCore anyout;
 	private int idCounter;
 	private int windowSize;
@@ -50,13 +50,13 @@ public class AnyOut extends MyBaseOutlierDetector {
 	public AnyOut() {
 		anyout = new AnyOutCore();
 	}
-	
+
 	@Override
 	public void resetLearningImpl() {
 		anyout.resetLearning();
 		super.resetLearningImpl();
 	}
-	
+
 	@Override
 	protected void Init() {
 		trainingCount = 0;
@@ -67,7 +67,7 @@ protected void Init() {
 		trainingSetSize = anyout.trainingSetSizeOption.getValue();
 		idCounter = FIRST_OBJ_ID;
 		windowSize = anyout.horizonOption.getValue();
-		objects = new ArrayList<DataObject>();
+		objects = new ArrayList<>();
 		super.Init();
 	}
 
@@ -75,9 +75,9 @@ protected void Init() {
 	protected void ProcessNewStreamObj(Instance i) {
 		if (trainingSetSize >= trainingCount) {
 			if (trainingSet == null) {
-				trainingSet = new DataSet(i.numAttributes()-1);
+				trainingSet = new DataSet(i.numAttributes() - 1);
 			}
-			//fill training set
+			// fill training set
 			DataObject o = new DataObject(idCounter++, i);
 			trainingSet.addObject(o);
 			trainingCount++;
@@ -89,16 +89,16 @@ protected void ProcessNewStreamObj(Instance i) {
 				trainingSetSize = -1;
 				outlierClass = i.classAttribute().numValues() - 1;
 			}
-			
+
 			// Create DataObject from instance.
 			DataObject o = new DataObject(idCounter++, i);
 			objects.add(o);
-			
+
 			// Count ground truth.
 			if (o.getClassLabel() == outlierClass) {
 				totalOutliers += 1;
 			}
-			
+
 			// Update window objects.
 			if (objects.size() > windowSize) {
 				DataObject obj = objects.get(0);
@@ -106,10 +106,10 @@ protected void ProcessNewStreamObj(Instance i) {
 				anyout.removeObject(obj.getId());
 				RemoveExpiredOutlier(new Outlier(obj.getInstance(), obj.getId(), obj));
 			}
-			
+
 			// Calculate scores for the object.
 			anyout.initObject(o.getId(), o.getFeatures());
-			
+
 			// Simulate anyout characteristics.
 			double depth = Math.random();
 			if (depth < minDepth) {
@@ -117,23 +117,23 @@ protected void ProcessNewStreamObj(Instance i) {
 			} else if (depth > maxDepth) {
 				depth = maxDepth;
 			}
-			
-			while (anyout.moreImprovementsPossible(o.getId(), depth)){
+
+			while (anyout.moreImprovementsPossible(o.getId(), depth)) {
 				anyout.improveObjectOnce(o.getId());
-			}			
-			
+			}
+
 			// Learn object into ClusTree.
 			anyout.learnObject(o.getFeatures());
 
 			// Evaluation of the window objects.
-			for (DataObject obj : objects){
+			for (DataObject obj : objects) {
 				int id = obj.getId();
-				if(anyout.isOutlier(id)) {
-					if(obj.isOutiler() == false) { // not already outlier.
+				if (anyout.isOutlier(id)) {
+					if (obj.isOutiler() == false) { // not already outlier.
 						// Statistics gathering.
-						if(obj.getClassLabel() == outlierClass) {
+						if (obj.getClassLabel() == outlierClass) {
 							truePositive += 1;
-						}  else {
+						} else {
 							falsePositive += 1;
 						}
 						AddOutlier(new Outlier(obj.getInstance(), id, obj));
@@ -146,7 +146,7 @@ protected void ProcessNewStreamObj(Instance i) {
 			}
 		}
 	}
-	
+
 	@Override
 	public String getPurposeString() {
 		return "Anyout: Anytime Outlier Detector based on ClusTree";
@@ -167,45 +167,48 @@ private int getWindowStart() {
 			x = FIRST_OBJ_ID;
 		return x;
 	}
-	    
-    @Override
-    protected boolean IsNodeIdInWin(long id) {
-        if ((getWindowStart() <= id) && (id <= getWindowEnd()) )
-            return true;
-        else
-            return false;
-    }
-
-    @Override
-    public String getObjectInfo(Object o) {
-    	DataObject obj = (DataObject) o;
-    	double[] features = obj.getFeatures();
-    	int id = obj.getId();
-        StringBuilder sb = new StringBuilder();        
-        sb.append("<html>");
-        sb.append("<table>");
-        sb.append("<tr><td><b>ID:</b></td><td>" + id + "</td></tr>");
-        sb.append("<tr><td><b>X, Y:</b></td><td>" + String.format("%.4f", features[0]) + ", " + String.format("%.4f", features[1]) + "</td></tr>");
-        sb.append("<tr><td><b>Oscore:</b></td><td>" + String.format("%.4f", anyout.getOutlierScore(id)) + "</td></tr>");
-        sb.append("<tr><td><b>Conf:</b></td><td>" + String.format("%.4f", anyout.getConfidence(id)) + "</td></tr>");
-        sb.append("</table>");
-        sb.append("</html>");
-        
-        return sb.toString();
-    }
-    
-    @Override
-    public String getStatistics() {
-        StringBuilder sb = new StringBuilder();
-        int sum = truePositive + falsePositive;
-        sb.append("Statistics:\n\n");
-        sb.append(String.format("  Outliers found: %d (%.1f%%)\n", sum, (100 * sum) / (double)totalOutliers));
-        sb.append(String.format("  True positive found: %d (%.1f%%)\n", truePositive, (100 * truePositive) / (double)totalOutliers));
-        sb.append(String.format("  False positive found: %d (%.1f%%)\n", falsePositive, (100 * falsePositive) / (double)totalOutliers));
-        sb.append("\n");
-        sb.append("  Max memory usage: " + iMaxMemUsage + " MB\n");
-        sb.append("  Total process time: " + String.format("%.2f ms", nTotalRunTime / 1000.0) + "\n");
-        
-        return sb.toString();
-    }
+
+	@Override
+	protected boolean IsNodeIdInWin(long id) {
+		if ((getWindowStart() <= id) && (id <= getWindowEnd()))
+			return true;
+		else
+			return false;
+	}
+
+	@Override
+	public String getObjectInfo(Object o) {
+		DataObject obj = (DataObject) o;
+		double[] features = obj.getFeatures();
+		int id = obj.getId();
+		StringBuilder sb = new StringBuilder();
+		sb.append("<html>");
+		sb.append("<table>");
+		sb.append("<tr><td><b>ID:</b></td><td>" + id + "</td></tr>");
+		sb.append("<tr><td><b>X, Y:</b></td><td>" + String.format("%.4f", features[0]) + ", "
+				+ String.format("%.4f", features[1]) + "</td></tr>");
+		sb.append("<tr><td><b>Oscore:</b></td><td>" + String.format("%.4f", anyout.getOutlierScore(id)) + "</td></tr>");
+		sb.append("<tr><td><b>Conf:</b></td><td>" + String.format("%.4f", anyout.getConfidence(id)) + "</td></tr>");
+		sb.append("</table>");
+		sb.append("</html>");
+
+		return sb.toString();
+	}
+
+	@Override
+	public String getStatistics() {
+		StringBuilder sb = new StringBuilder();
+		int sum = truePositive + falsePositive;
+		sb.append("Statistics:\n\n");
+		sb.append(String.format("  Outliers found: %d (%.1f%%)\n", sum, (100 * sum) / (double) totalOutliers));
+		sb.append(String.format("  True positive found: %d (%.1f%%)\n", truePositive,
+				(100 * truePositive) / (double) totalOutliers));
+		sb.append(String.format("  False positive found: %d (%.1f%%)\n", falsePositive,
+				(100 * falsePositive) / (double) totalOutliers));
+		sb.append("\n");
+		sb.append("  Max memory usage: " + iMaxMemUsage + " MB\n");
+		sb.append("  Total process time: " + String.format("%.2f ms", nTotalRunTime / 1000.0) + "\n");
+
+		return sb.toString();
+	}
 }
diff --git a/moa/src/main/java/moa/clusterers/outliers/AnyOut/AnyOutCore.java b/moa/src/main/java/moa/learners/clusterers/outliers/AnyOut/AnyOutCore.java
similarity index 61%
rename from moa/src/main/java/moa/clusterers/outliers/AnyOut/AnyOutCore.java
rename to moa/src/main/java/moa/learners/clusterers/outliers/AnyOut/AnyOutCore.java
index a56728cc8..bd07307dc 100644
--- a/moa/src/main/java/moa/clusterers/outliers/AnyOut/AnyOutCore.java
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/AnyOut/AnyOutCore.java
@@ -3,7 +3,7 @@
  *
  *    @author I. Assent, P. Kranen, C. Baldauf, T. Seidl
  *    @author G. Piskas, A. Gounaris
- * 
+ *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
@@ -15,11 +15,11 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.clusterers.outliers.AnyOut;
+package moa.learners.clusterers.outliers.AnyOut;
 
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -29,55 +29,58 @@
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 
-import moa.clusterers.clustree.ClusKernel;
-import moa.clusterers.clustree.ClusTree;
-import moa.clusterers.clustree.Entry;
-import moa.clusterers.clustree.Node;
-import moa.clusterers.outliers.AnyOut.util.DataObject;
-import moa.clusterers.outliers.AnyOut.util.DataSet;
-
+import moa.learners.clusterers.clustree.ClusKernel;
+import moa.learners.clusterers.clustree.ClusTree;
+import moa.learners.clusterers.clustree.Entry;
+import moa.learners.clusterers.clustree.Node;
+import moa.learners.clusterers.outliers.AnyOut.util.DataObject;
+import moa.learners.clusterers.outliers.AnyOut.util.DataSet;
 
 @SuppressWarnings("serial")
 public class AnyOutCore extends ClusTree {
-	
+
 	///////////////////////////////////////////////
 	// the variables all became HashMaps to easily map the values to the objectIds,
 	// i.e. they exist once per object that is currently examined
-	// the lists have then to be used by the methods from MultipleDetector (see below)
+	// the lists have then to be used by the methods from MultipleDetector (see
+	/////////////////////////////////////////////// below)
 	// for the static manager, use ID=0 as default for the current object!
-	private HashMap<Integer,Double> aggregatedOScoreResult, lastOScoreResult, lastConfidenceResult;
+	private HashMap<Integer, Double> aggregatedOScoreResult, lastOScoreResult, lastConfidenceResult;
 	private HashMap<Integer, ClusKernel> objectAsKernel;
-	private HashMap<Integer,ArrayList<Double>> previousOScoreResultList;
-	private HashMap<Integer,Node> descendToNode;
+	private HashMap<Integer, ArrayList<Double>> previousOScoreResultList;
+	private HashMap<Integer, Node> descendToNode;
 	private HashMap<Integer, Integer> currentLevel;
 	///////////////////////////////////////////////
 
 	// Outlier score threshold.
 	private double threshold;
-	
+
 	// Entry weight threshold.
-    private double weightThreshold = 0.05;
+	private double weightThreshold = 0.05;
 	private int oScoreK;
 	private int confK;
 
-	public IntOption trainingSetSizeOption = new IntOption("TrainingSetSize", 't', "Training Set Size.", 1000, 0, 10000);
-	//public FlagOption UseBulkLoadingOption = new FlagOption("UseBulkLoading", 'b', "Use Bulkloading or traditional learning.");
+	public IntOption trainingSetSizeOption = new IntOption("TrainingSetSize", 't', "Training Set Size.", 1000, 0,
+			10000);
+	// public FlagOption UseBulkLoadingOption = new FlagOption("UseBulkLoading",
+	// 'b', "Use Bulkloading or traditional learning.");
 	public IntOption oScoreKOption = new IntOption("OScorek", 'o', "Size of Oscore aggregate.", 2, 1, 10);
 	public IntOption confKOption = new IntOption("Confidencek", 'c', "Size of confidence aggregate.", 2, 1, 10);
 	public IntOption confidenceChoiceOption = new IntOption("confidence", 'd', "Confidence Measure.", 4, 1, 6);
 	public FlagOption UseMeanScoreOption = new FlagOption("UseMeanScore", 'm', "Use Mean score or Density score.");
 	public FloatOption threshholdOption = new FloatOption("Threshold", 'z', "Threshold", 0.07, 0, 1);
-	
+
 	public AnyOutCore() {
-		lastOScoreResult = new HashMap<Integer,Double>();
-		lastConfidenceResult = new HashMap<Integer,Double>();
-		objectAsKernel = new HashMap<Integer, ClusKernel>();
-		aggregatedOScoreResult = new HashMap<Integer,Double>();
-		previousOScoreResultList = new HashMap<Integer,ArrayList<Double>>();
-		descendToNode = new HashMap<Integer,Node>();
-		currentLevel = new HashMap<Integer,Integer>();
+		lastOScoreResult = new HashMap<>();
+		lastConfidenceResult = new HashMap<>();
+		objectAsKernel = new HashMap<>();
+		aggregatedOScoreResult = new HashMap<>();
+		previousOScoreResultList = new HashMap<>();
+		descendToNode = new HashMap<>();
+		currentLevel = new HashMap<>();
 	}
-	
+
+	@Override
 	public void resetLearning() {
 		if (UseMeanScoreOption.isSet()) {
 			threshold = threshholdOption.getValue();
@@ -88,11 +91,12 @@ public void resetLearning() {
 		confK = confKOption.getValue();
 		super.resetLearningImpl();
 	}
-	
+
 	public void train(DataSet trainingSet) {
 		// TODO fix not working builder!
-		// ClusTree private variables are not updated but are mandatory for the algorithm to function.
-//		if (UseBulkLoadingOption.isSet()) { 
+		// ClusTree private variables are not updated but are mandatory for the
+		// algorithm to function.
+//		if (UseBulkLoadingOption.isSet()) {
 //			// Use BulkLoading
 //			EMTopDownTreeBuilder builder = new EMTopDownTreeBuilder();
 //			try {
@@ -101,40 +105,40 @@ public void train(DataSet trainingSet) {
 //				e.printStackTrace();
 //			}
 //		} else {
-			//Use traditional initialization
-			for (DataObject o : trainingSet.getDataObjectArray()){
-				DenseInstance inst = new DenseInstance(o.getFeatures().length);
-				for(int i=0; i<o.getFeatures().length; i++){
-					inst.setValue(i, o.getFeatures()[i]);
-				}
-				trainOnInstance(inst);
+		// Use traditional initialization
+		for (DataObject o : trainingSet.getDataObjectArray()) {
+			DenseInstance inst = new DenseInstance(o.getFeatures().length);
+			for (int i = 0; i < o.getFeatures().length; i++) {
+				inst.setValue(i, o.getFeatures()[i]);
 			}
+			trainOnInstance(inst);
+		}
 //		}
 	}
-	
+
 	public void initObject(int objectId, double[] features) {
 		previousOScoreResultList.put(objectId, new ArrayList<Double>());
 		currentLevel.put(objectId, 0);
 		// process root of the tree and set score according to the closest entry
 		ClusKernel newKernel = new ClusKernel(features, features.length);
 		objectAsKernel.put(objectId, newKernel);
-		
+
 		Entry closestEntry = root.nearestEntry(newKernel);
-		if (UseMeanScoreOption.isSet()) 
+		if (UseMeanScoreOption.isSet())
 			lastOScoreResult.put(objectId, newKernel.calcDistance(closestEntry.data));
 		else
-			lastOScoreResult.put(objectId,getDensityOutlierScore(newKernel,closestEntry.data));
-		
+			lastOScoreResult.put(objectId, getDensityOutlierScore(newKernel, closestEntry.data));
+
 		aggregatedOScoreResult.put(objectId, lastOScoreResult.get(objectId));
-		// remember (store) next Node to descend into for further processing 
+		// remember (store) next Node to descend into for further processing
 		descendToNode.put(objectId, closestEntry.getChild());
-    	//update confidence
+		// update confidence
 		updateConfidence(objectId);
 	}
-	
-	public void learnObject(double[] features){
+
+	public void learnObject(double[] features) {
 		DenseInstance inst = new DenseInstance(features.length);
-		for(int i=0; i<features.length; i++){
+		for (int i = 0; i < features.length; i++) {
 			inst.setValue(i, features[i]);
 		}
 		trainOnInstance(inst);
@@ -149,7 +153,7 @@ public void removeObject(int objectId) {
 		objectAsKernel.remove(objectId);
 		currentLevel.remove(objectId);
 	}
-	
+
 	// TODO fix not working density measure!!! Must be between 0 and 1.
 	private double getDensityOutlierScore(ClusKernel x, ClusKernel entry) {
 		double[] sigmaSquared = entry.getVarianceVector();
@@ -157,80 +161,84 @@ private double getDensityOutlierScore(ClusKernel x, ClusKernel entry) {
 		double resultDensity = 0;
 
 		// exponent = -0.5 (x- mu ) * Sigma ^-1 * (x- mu ) )
-		//                = -0.5 ( sum_d ((x_i - mu_i)^2 / var_i) )
+		// = -0.5 ( sum_d ((x_i - mu_i)^2 / var_i) )
 		double exponent = 0.0;
 		double[] mu = entry.getCenter();
 
 		// factor = 1 / sqrt ( (2*PI)^d * \prod_d(variance) )
-		//        = 1 / sqrt ((2*PI)^d) * sqrt (\prod_d(variance))
-		//        = 1 / (2*PI)^(d/2)   * \prod_d( sqrt (variance))
-		double factor = Math.pow( (2.0 * Math.PI) , ((sigmaSquared.length/2.0)) );
+		// = 1 / sqrt ((2*PI)^d) * sqrt (\prod_d(variance))
+		// = 1 / (2*PI)^(d/2) * \prod_d( sqrt (variance))
+		double factor = Math.pow((2.0 * Math.PI), ((sigmaSquared.length / 2.0)));
 		for (int i = 0; i < sigmaSquared.length; i++) {
 			factor *= Math.sqrt(sigmaSquared[i]);
-			exponent += ((x.LS[i] - mu[i])*(x.LS[i] - mu[i])) / sigmaSquared[i];
+			exponent += ((x.LS[i] - mu[i]) * (x.LS[i] - mu[i])) / sigmaSquared[i];
 		}
 
 		// factor = 1 / sqrt ( (2*PI)^d * \prod_d(variance) )
 		factor = 1 / factor;
 		exponent *= -0.5;
-		//System.out.println(factor);
+		// System.out.println(factor);
 		resultDensity = factor * Math.exp(exponent);
-		//System.out.println(resultDensity);
+		// System.out.println(resultDensity);
 
 		// TODO: dangerous, since the density is not necessarily between 0 and 1
-		return 1-resultDensity;
+		return 1 - resultDensity;
 	}
-	
+
 	private void useAggregatedOScoreResults(int objectId) {
-		if (oScoreK <= 1){
+		if (oScoreK <= 1) {
 			aggregatedOScoreResult.put(objectId, lastOScoreResult.get(objectId));
 		} else {
 			double mu = lastOScoreResult.get(objectId);
-			int count=0;
-			for (int i=Math.max(0, previousOScoreResultList.get(objectId).size()-(oScoreK-1)); i<previousOScoreResultList.get(objectId).size();i++){
+			int count = 0;
+			for (int i = Math.max(0,
+					previousOScoreResultList.get(objectId).size() - (oScoreK - 1)); i < previousOScoreResultList
+							.get(objectId).size(); i++) {
 				Double d = previousOScoreResultList.get(objectId).get(i);
-				mu+=d.doubleValue();
+				mu += d;
 				count++;
 			}
-			aggregatedOScoreResult.put(objectId, mu/(count+1));
+			aggregatedOScoreResult.put(objectId, mu / (count + 1));
 		}
 	}
-	
+
 	public boolean moreImprovementsPossible(int objectId, double depthPercentage) {
-		if(currentLevel.get(objectId) < maxHeight * depthPercentage && descendToNode.get(objectId)!=null) {
+		if (currentLevel.get(objectId) < maxHeight * depthPercentage && descendToNode.get(objectId) != null) {
 			return true;
 		}
 		return false;
 	}
-	
+
 	public void improveObjectOnce(int objectId) {
-		currentLevel.put(objectId, currentLevel.get(objectId)+1);
-		
+		currentLevel.put(objectId, currentLevel.get(objectId) + 1);
+
 		// descend into closest entry and find the next closest entry there
 		ClusKernel mKernel = objectAsKernel.get(objectId);
 		previousOScoreResultList.get(objectId).add(new Double(lastOScoreResult.get(objectId)));
 		Entry closestEntry = descendToNode.get(objectId).nearestEntry(mKernel);
-		
+
 		// return if irrelevant and keep the previous score.
-        if (closestEntry.data.getWeight()< weightThreshold){
-        //if (closestEntry.isIrrelevant(weightThreshold)) {
-        	descendToNode.remove((objectId));
-        } else {
+		if (closestEntry.data.getWeight() < weightThreshold) {
+			// if (closestEntry.isIrrelevant(weightThreshold)) {
+			descendToNode.remove((objectId));
+		} else {
 			// update score and next Node to descend into
 			if (UseMeanScoreOption.isSet())
 				lastOScoreResult.put(objectId, mKernel.calcDistance(closestEntry.data));
 			else
-				lastOScoreResult.put(objectId, getDensityOutlierScore(mKernel,closestEntry.data));
+				lastOScoreResult.put(objectId, getDensityOutlierScore(mKernel, closestEntry.data));
 			useAggregatedOScoreResults(objectId);
 			descendToNode.put(objectId, closestEntry.getChild());
-			
-			//update confidence
+
+			// update confidence
 			updateConfidence(objectId);
-        }
+		}
 	}
-		
+
 	/**
-	 * Calculates the Confidence on the basis of the standard deviation of previous OScore results
+	 * Calculates the Confidence on the basis of the standard deviation of previous
+	 * OScore results
+	 * 
 	 * @return confidence
 	 */
 	private double calcC1(int objectId) {
@@ -238,16 +246,22 @@ private double calcC1(int objectId) {
 		if (nrOfPreviousResults == 0) {
 			return 0.0;
 		}
-		int count=1;
-		double difSum_k = Math.abs(lastOScoreResult.get(objectId)-previousOScoreResultList.get(objectId).get(nrOfPreviousResults-1));
-		
-		//if previousOscoreResultList contains more than two results, this loop sums up further diffs
-		for (int i=Math.max(0, nrOfPreviousResults - (confK-1)) + 1; i < nrOfPreviousResults; i++){
-			difSum_k += Math.abs(previousOScoreResultList.get(objectId).get(i)-previousOScoreResultList.get(objectId).get(i-1));
+		int count = 1;
+		double difSum_k = Math.abs(
+				lastOScoreResult.get(objectId) - previousOScoreResultList.get(objectId).get(nrOfPreviousResults - 1));
+
+		// if previousOscoreResultList contains more than two results, this loop sums up
+		// further diffs
+		for (int i = Math.max(0, nrOfPreviousResults - (confK - 1)) + 1; i < nrOfPreviousResults; i++) {
+			difSum_k += Math.abs(
+					previousOScoreResultList.get(objectId).get(i) - previousOScoreResultList.get(objectId).get(i - 1));
 			count++;
 		}
-		// hier msste gelten count==confK-1, d.h. wenn ich die letzten 3 Werte betrachten will, bekomme ich 2 differenzen 
-		// XXX SW: Nicht ganz. Wenn ich die letzten 4 Werte betrachten will,  aber erst 2 Ergebnisse zur Verf�gung stehen, bekomme ich an anstatt der 3 Differenzen nur 1
+		// hier msste gelten count==confK-1, d.h. wenn ich die letzten 3 Werte
+		// betrachten will, bekomme ich 2 differenzen
+		// XXX SW: Nicht ganz. Wenn ich die letzten 4 Werte betrachten will, aber erst 2
+		// Ergebnisse zur Verf�gung stehen, bekomme ich an anstatt der 3 Differenzen nur
+		// 1
 		// dafr die Zhlvariable
 		difSum_k /= count;
 		return Math.pow(Math.E, (-1.0 * difSum_k));
@@ -255,27 +269,27 @@ private double calcC1(int objectId) {
 
 	private double calcC2(int objectId) {
 		int nrOfPreviousResults = previousOScoreResultList.get(objectId).size();
-		//consider last confK results (including the current one)
-		int count=1;
-		double sum_k=lastOScoreResult.get(objectId);
-		for (int i = Math.max(0, nrOfPreviousResults - (confK-1)); i < nrOfPreviousResults; i++){
+		// consider last confK results (including the current one)
+		int count = 1;
+		double sum_k = lastOScoreResult.get(objectId);
+		for (int i = Math.max(0, nrOfPreviousResults - (confK - 1)); i < nrOfPreviousResults; i++) {
 			sum_k += previousOScoreResultList.get(objectId).get(i);
 			count++;
 		}
 		// hier msste gelten count==confK, da wir die letzten confK Werte betrachten
 		// XXX SW: hier wieder wie bei C1
 		sum_k /= count;
-		
+
 		return Math.pow(Math.E, (-1.0 * sum_k));
 	}
-	
+
 	private double calcC3(int objectId) {
-		if (getHeight()==0){
-			return (1.0 * currentLevel.get(objectId))/(1.0 * maxHeight);
+		if (getHeight() == 0) {
+			return (1.0 * currentLevel.get(objectId)) / (1.0 * maxHeight);
 		}
-		return (1.0 * currentLevel.get(objectId))/(1.0 * getHeight());
+		return (1.0 * currentLevel.get(objectId)) / (1.0 * getHeight());
 	}
-	
+
 	private void updateConfidence(int objectId) {
 		int confChoice = confidenceChoiceOption.getValue();
 		if (confChoice == 1)
@@ -284,24 +298,24 @@ private void updateConfidence(int objectId) {
 			lastConfidenceResult.put(objectId, calcC2(objectId));
 		if (confChoice == 3)
 			lastConfidenceResult.put(objectId, calcC3(objectId));
-		
+
 		if (confChoice == 4)
-			lastConfidenceResult.put(objectId, calcC1(objectId)*calcC2(objectId));
+			lastConfidenceResult.put(objectId, calcC1(objectId) * calcC2(objectId));
 		if (confChoice == 5)
-			lastConfidenceResult.put(objectId, calcC1(objectId)*calcC3(objectId));
+			lastConfidenceResult.put(objectId, calcC1(objectId) * calcC3(objectId));
 		if (confChoice == 6)
-			lastConfidenceResult.put(objectId, calcC2(objectId)*calcC3(objectId));
-		
+			lastConfidenceResult.put(objectId, calcC2(objectId) * calcC3(objectId));
+
 		if (confChoice == 7)
-			lastConfidenceResult.put(objectId, calcC1(objectId)*calcC2(objectId)*calcC3(objectId));
+			lastConfidenceResult.put(objectId, calcC1(objectId) * calcC2(objectId) * calcC3(objectId));
 	}
 
 	public boolean isOutlier(int id) {
-		return aggregatedOScoreResult.get(id)/lastConfidenceResult.get(id) > threshold;
+		return aggregatedOScoreResult.get(id) / lastConfidenceResult.get(id) > threshold;
 	}
 
 	public double getOutlierScore(int id) {
-		return aggregatedOScoreResult.get(id)/lastConfidenceResult.get(id);
+		return aggregatedOScoreResult.get(id) / lastConfidenceResult.get(id);
 	}
 
 	public double getConfidence(int id) {
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/AnyOut/util/DataObject.java b/moa/src/main/java/moa/learners/clusterers/outliers/AnyOut/util/DataObject.java
new file mode 100644
index 000000000..defa2ae81
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/AnyOut/util/DataObject.java
@@ -0,0 +1,140 @@
+/*
+ *    DataObject.java
+ *
+ *    @author F. Sanchez, I. Assent, P. Kranen, C. Baldauf, T. Seidl
+ *    @author G. Piskas, A. Gounaris
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers.AnyOut.util;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+/**
+ * This object encapsulates a data point.
+ * 
+ * @author Fernando Sanchez Villaamil
+ */
+
+public class DataObject {
+
+	private int id;
+	private Instance inst;
+	private double[] features;
+	private int classLabel;
+	private boolean isOutiler;
+
+	/**
+	 * Returns the features (label attribute excluded).
+	 * 
+	 * @return An array <code>double[]</code> with the features.
+	 */
+	public double[] getFeatures() {
+		double[] filteredFeatures = new double[features.length - 1];
+		for (int i = 0; i < filteredFeatures.length; i++)
+			filteredFeatures[i] = features[i];
+		return filteredFeatures;
+	}
+
+	/**
+	 * Returns the id for the <code>DataObject</code>.
+	 * 
+	 * @return An <code>int</code> with the id of the <code>DataObject</code>.
+	 */
+	public int getId() {
+		return id;
+	}
+
+	public void setId(int id) {
+		this.id = id;
+	}
+
+	/**
+	 * Return the label for the <code>DataObject</code>.
+	 * 
+	 * @return An <code>int</code> which codes the label.
+	 */
+	public int getClassLabel() {
+		return classLabel;
+	}
+
+	/**
+	 * Return the <code>Instance</code> of the <code>DataObject</code>.
+	 * 
+	 * @return An <code>Instance</code>.
+	 */
+	public Instance getInstance() {
+		return inst;
+	}
+
+	/**
+	 * Standard constructor for <code>DataObject</code>.
+	 * 
+	 * @param idCounter  The id for the <code>DataObject</code>.
+	 * @param features   The feature as a <code>double[]</code>
+	 * @param classLabel The label id for the <code>DataObject</code>.
+	 */
+	public DataObject(int idCounter, Instance inst) {
+		this.id = idCounter;
+		this.inst = inst;
+		this.features = inst.toDoubleArray();
+		this.classLabel = (int) inst.classValue();
+		this.isOutiler = false;
+	}
+
+	/**
+	 * Returns the number of features (label attribute excluded).
+	 * 
+	 * @return The number of features in the point.
+	 */
+	public int getNrOfDimensions() {
+		return this.features.length - 1;
+	}
+
+	/**
+	 * Returns a <code>String</code> representation of the point. The features are
+	 * written comma separated between parenthesis and the label id is written after
+	 * the closing parenthesis surrounded by squared brackets.
+	 * 
+	 * @return A <code>String</code> representation of the point.
+	 */
+	@Override
+	public String toString() {
+
+		String res = "(";
+		for (int i = 0; i < features.length; i++) {
+			double d = features[i];
+			res += d;
+			if (i != features.length - 1)
+				res += ",";
+		}
+		res += ")";
+
+		res += "[" + this.classLabel + "]";
+
+		return res;
+
+	}
+
+	public void setOutiler(boolean val) {
+		isOutiler = val;
+	}
+
+	public boolean isOutiler() {
+		return isOutiler;
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/AnyOut/util/DataSet.java b/moa/src/main/java/moa/learners/clusterers/outliers/AnyOut/util/DataSet.java
new file mode 100644
index 000000000..ebd527556
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/AnyOut/util/DataSet.java
@@ -0,0 +1,296 @@
+/*
+ *    DataSet.java
+ *
+ *    @author F. Sanchez, I. Assent, P. Kranen, C. Baldauf, T. Seidl
+ *    @author G. Piskas, A. Gounaris
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers.AnyOut.util;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+
+/**
+ * A set of <code>DataObject</code>s. Internally it uses an
+ * <code>ArrayList&lt;DataObject&gt;</code> so it is recommended to use with
+ * care. For speedy operations after the data is collected use
+ * {@link #getFeaturesAsArray()}. When access speed is not a factor the iterator
+ * can be used to go through the data with a <code>foreach</code> loop.
+ * 
+ * @author Fernando Sanchez Villaamil
+ * @see #getFeaturesAsArray()
+ */
+
+public class DataSet implements Iterable<DataObject> {
+
+	private int nrOfDimensions;
+	private ArrayList<DataObject> dataList;
+
+	/**
+	 * Creates an empty set.
+	 * 
+	 * @param nrOfDimensions The dimension the <code>DataObject</code>s should have.
+	 * @see DataObject
+	 * @throws praktikum.framework.data.InconsistentDimensionException
+	 */
+	public DataSet(int nrOfDimensions) {
+		if (nrOfDimensions <= 0) {
+			System.err.println("Negative dimension given: " + nrOfDimensions);
+		} else {
+			this.nrOfDimensions = nrOfDimensions;
+			dataList = new ArrayList<>();
+		}
+	}
+
+	/**
+	 * Creates a Set with only the given object. The dimension for the
+	 * <code>DataSet</code> is given by the given <code>DataObject</code>.
+	 * 
+	 * @param newData The first <code>DataObject</code> added to the set.
+	 * @see DataObject
+	 * @throws praktikum.framework.data.InconsistentDimensionException
+	 */
+	public DataSet(DataObject newData) {
+		this.nrOfDimensions = newData.getNrOfDimensions();
+
+		dataList = new ArrayList<>();
+		dataList.add(newData);
+	}
+
+	/**
+	 * Adds a <code>DataObject</code> to the set.
+	 * 
+	 * @param newData The <code>DataObject</code> to be added.
+	 * @throws praktikum.framework.data.InconsistentDimensionException This
+	 *                                                                 <code>Exception</code>
+	 *                                                                 is thrown
+	 *                                                                 when the
+	 *                                                                 dimension of
+	 *                                                                 the object to
+	 *                                                                 be added does
+	 *                                                                 not fit the
+	 *                                                                 rest.
+	 * @see DataObject
+	 * @throws praktikum.framework.data.InconsistentDimensionException
+	 */
+	public void addObject(DataObject newData) {
+
+		if (newData.getNrOfDimensions() != nrOfDimensions) {
+			System.err.println("Inconsistent number of dimensions!"); // (this.nrOfDimensions,
+																		// newData.getNrOfDimensions());
+		} else {
+			this.dataList.add(newData);
+		}
+	}
+
+	/**
+	 * Adds all objects in the given data set
+	 * 
+	 * @see addObject(DataObject newData)
+	 * @param dataSet
+	 * @throws InconsistentDimensionException
+	 */
+	public void addObject(DataSet dataSet) throws Exception {
+		DataObject[] dataObjects = dataSet.getDataObjectArray();
+		for (int i = 0; i < dataObjects.length; i++) {
+			this.addObject(dataObjects[i]);
+		}
+	}
+
+	/**
+	 * Returns the <code>DataObject</code> at the given position. Use with care. For
+	 * speedy operations after the data is collected use
+	 * {@link #getFeaturesAsArray()}.
+	 * 
+	 * @param index The index position that is to be returned.
+	 * @return The <code>DataObeject</code> at the given position.
+	 * @see DataObject
+	 */
+	public DataObject getObject(int index) {
+		return dataList.get(index);
+	}
+
+	/**
+	 * Returns the size of the set.
+	 * 
+	 * @return The size of the set.
+	 */
+	public int size() {
+		return this.dataList.size();
+	}
+
+	/**
+	 * Return the dimension of the objects in the <code>DataSet</code>. The
+	 * <code>DataSet</code> makes sure all objects have the same dimension.
+	 * 
+	 * @return The dimension of the <code>DataObjects</code> in the
+	 *         <code>DataSet</code>.
+	 * @see DataObject
+	 */
+	public int getNrOfDimensions() {
+		return nrOfDimensions;
+	}
+
+	/**
+	 * Counts the number of classes that are present in the data set. !!! It does
+	 * not check whether all classes are contained !!!
+	 * 
+	 * @return the number of distinct class labels
+	 */
+	public int getNrOfClasses() {
+		HashMap<Integer, Integer> classes = new HashMap<>();
+
+		for (DataObject currentObject : dataList) {
+			if (!classes.containsKey(currentObject.getClassLabel()))
+				classes.put(currentObject.getClassLabel(), 1);
+		}
+
+		return classes.size();
+	}
+
+	/**
+	 * Returns an array with all the features of all the objects in the set. Be
+	 * aware that it does not copy the features so that any changes to the values of
+	 * the features in this array will result in changes in the initial
+	 * <code>DataObject</code>s.
+	 * 
+	 * @return A <code>double[][]</code> with the features. The first dimension is
+	 *         the feature number, the second the values in the feature.
+	 * @see DataObject
+	 */
+	public double[][] getFeaturesAsArray() {
+
+		double[][] data = new double[this.size()][this.nrOfDimensions];
+
+		int c = 0;
+		for (DataObject d : dataList) {
+			data[c] = d.getFeatures();
+			c++;
+		}
+
+		return data;
+	}
+
+	/**
+	 * Returns an array of all the <code>DataObject</code>s in the set. Use for
+	 * speedy access when the labels and/or the ids are also needed.
+	 * 
+	 * @return An array with all the <code>DataObject</code>s in the set.
+	 * @see DataObject
+	 */
+	public DataObject[] getDataObjectArray() {
+		DataObject[] res = new DataObject[this.dataList.size()];
+		return this.dataList.toArray(res);
+	}
+
+	/**
+	 * Separates the objects in this data set according to their class label
+	 * 
+	 * @return an array of DataSets, one for each class
+	 */
+	public DataSet[] getDataSetsPerClass() throws Exception {
+		DataSet[] dataSetsPerClass = new DataSet[this.getNrOfClasses()];
+		// create a new data set for each class
+		for (int i = 0; i < dataSetsPerClass.length; i++) {
+			dataSetsPerClass[i] = new DataSet(this.nrOfDimensions);
+		}
+
+		// fill the data sets
+		for (DataObject currentObject : dataList) {
+			dataSetsPerClass[currentObject.getClassLabel()].addObject(currentObject);
+		}
+
+		return dataSetsPerClass;
+	}
+
+	/**
+	 * Calculates the variance of this data set for each dimension
+	 * 
+	 * @return double array containing the variance per dimension
+	 */
+	public double[] getVariances() {
+		double N = this.size();
+		double[] LS = new double[this.getNrOfDimensions()];
+		double[] SS = new double[this.getNrOfDimensions()];
+		double[] tmpFeatures;
+		double[] variances = new double[this.getNrOfDimensions()];
+
+		for (DataObject dataObject : dataList) {
+			tmpFeatures = dataObject.getFeatures();
+			for (int j = 0; j < tmpFeatures.length; j++) {
+				LS[j] += tmpFeatures[j];
+				SS[j] += tmpFeatures[j] * tmpFeatures[j];
+			}
+		}
+
+		// sigmaSquared[i] = (SS[i] / N) - ((LS[i] * LS [i]) / (N * N));
+		for (int i = 0; i < LS.length; i++) {
+			variances[i] = (SS[i] / N - ((LS[i] / N) * (LS[i] / N)));
+		}
+
+		return variances;
+	}
+
+	/**
+	 * An iterator for the set. This allows to use a <code>foreach</code> loop over
+	 * the <code>DataObject</code>s. This is a nice way of going through the data,
+	 * but when the access speed is relevant its use is not recommended.
+	 * 
+	 * @return An iterator for the set.
+	 * @see DataObject
+	 */
+	@Override
+	public Iterator<DataObject> iterator() {
+		return this.dataList.iterator();
+	}
+
+	/**
+	 * Returns a <code>String</code> representation of all the
+	 * <code>DataObject</code>s in the code as a list of the representation
+	 * implemented for these.
+	 * 
+	 * @return A <code>String</code> representation of all the elements in the set.
+	 * @see DataObject
+	 */
+	@Override
+	public String toString() {
+		String res = "";
+
+		for (DataObject dataObject : dataList) {
+			res += dataObject.toString() + "\n";
+		}
+
+		return res;
+	}
+
+	/**
+	 * resets the ids, so that the set contains ids from 0 to noOfObjects-1
+	 */
+	public void manipulateIds() {
+		int id = 0;
+		for (DataObject o : dataList) {
+			o.setId(id);
+			id++;
+		}
+
+	}
+
+	public void clear() {
+		dataList.clear();
+	}
+}
diff --git a/moa/src/main/java/moa/clusterers/outliers/AnyOut/util/EMProjectedClustering.java b/moa/src/main/java/moa/learners/clusterers/outliers/AnyOut/util/EMProjectedClustering.java
similarity index 83%
rename from moa/src/main/java/moa/clusterers/outliers/AnyOut/util/EMProjectedClustering.java
rename to moa/src/main/java/moa/learners/clusterers/outliers/AnyOut/util/EMProjectedClustering.java
index e4f49ae9c..d235d9845 100644
--- a/moa/src/main/java/moa/clusterers/outliers/AnyOut/util/EMProjectedClustering.java
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/AnyOut/util/EMProjectedClustering.java
@@ -3,7 +3,7 @@
  *
  *    @author I. Assent, P. Kranen, C. Baldauf, T. Seidl
  *    @author G. Piskas, A. Gounaris
- * 
+ *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
@@ -15,36 +15,38 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.clusterers.outliers.AnyOut.util;
+package moa.learners.clusterers.outliers.AnyOut.util;
 
 import java.util.ArrayList;
 import java.util.Random;
 import java.util.TreeSet;
 
 /**
- * Implements clustering via Expectation Maximization
- * but return a clear partitioning of the data, 
- * i.e. a point belongs to only one cluster (the most probable)
+ * Implements clustering via Expectation Maximization but return a clear
+ * partitioning of the data, i.e. a point belongs to only one cluster (the most
+ * probable)
+ * 
  * @author kranen
  *
  */
 public class EMProjectedClustering {
-	
+
 	private long randomSeed = 1L;
 
 	// the points to cluster
 	double[][] pointArray;
-	int n;		// the total number of points
-	int dim;	// the number of dimensions
-	int k;		// the number of requested partitions
-	
+	int n; // the total number of points
+	int dim; // the number of dimensions
+	int k; // the number of requested partitions
+
 	// mininum variance (like kernel bandwidth) to avoid division by zero
 	private final double minVariance = 0.01;
-	// stop criterion: deviation of expectation as minDeviation = 1 - (E_old / E_new)
+	// stop criterion: deviation of expectation as minDeviation = 1 - (E_old /
+	// E_new)
 	private final double minDeviation = 0.01;
 	private final int MAXITER = 20;
 
@@ -52,7 +54,7 @@ public class EMProjectedClustering {
 	double[][] clusterMeans;
 	// variance vectors of the clusters
 	double[][] clusterVariances;
-	
+
 	// probability for the points given a cluster
 	double[][] pXgivenC;
 	// probabilities for points to belong to a cluster
@@ -62,26 +64,30 @@ public class EMProjectedClustering {
 	// probabilities of the points
 	double[] pX;
 
-	public  EMProjectedClustering() {}
-	
+	public EMProjectedClustering() {
+	}
+
 	/**
-	 * Performs an EM clustering on the provided data set
-	 * !! Only the variances are calculated and used for point assignments !
-	 * !!! the number k' of returned clusters might be smaller than k !!! 
-	 * @param pointArray the data set as an array[n][d] of n points with d dimensions
-	 * @param k the number of requested partitions (!might return less)
-	 * @return a mapping int[n][k'] of the n given points to the k' resulting clusters
+	 * Performs an EM clustering on the provided data set !! Only the variances are
+	 * calculated and used for point assignments ! !!! the number k' of returned
+	 * clusters might be smaller than k !!!
+	 * 
+	 * @param pointArray the data set as an array[n][d] of n points with d
+	 *                   dimensions
+	 * @param k          the number of requested partitions (!might return less)
+	 * @return a mapping int[n][k'] of the n given points to the k' resulting
+	 *         clusters
 	 */
 	public int[][] getEMClusteringVariances(double[][] pointArray, int k) {
 		// initialize field and clustering
 		initFields(pointArray, k);
 		setInitialPartitions(pointArray, k);
-		
+
 		// iterate M and E
 		double currentExpectation, newExpectation = 0.0;
 		double expectationDeviation;
 		int count = 0;
-		do{
+		do {
 			currentExpectation = newExpectation;
 			// reassign objects
 			getNewClusterRepresentation();
@@ -92,17 +98,17 @@ public int[][] getEMClusteringVariances(double[][] pointArray, int k) {
 			expectationDeviation = 1.0 - (currentExpectation / newExpectation);
 			count++;
 		} while (expectationDeviation > minDeviation && count < MAXITER);
-		
+
 		// return the resulting mapping from points to clusters
 		return createProjectedClustering();
 	}
-	
+
 	public int[][] getEMClusteringVariancesBestChoice(double[][] pointArray, int k, int nrOfChoices) {
 		nrOfChoices = Math.max(1, nrOfChoices);
 		int[][] bestChoice = null;
 		int[][] tmpChoice = null;
 		double tmpMeasure, bestMeasure = Double.NEGATIVE_INFINITY;
-		
+
 		for (int i = 0; i < nrOfChoices; i++) {
 			this.randomSeed = i;
 			tmpChoice = this.getEMClusteringVariances(pointArray, k);
@@ -112,26 +118,26 @@ public int[][] getEMClusteringVariancesBestChoice(double[][] pointArray, int k,
 				bestChoice = tmpChoice;
 			}
 		}
-		
+
 		return bestChoice;
 	}
-	
+
 	/**
-	 * @param n nrOfPoints
+	 * @param n   nrOfPoints
 	 * @param dim nrOfDimensions
-	 * @param k nrOfClusters
+	 * @param k   nrOfClusters
 	 */
 	private void initFields(double[][] pointArray, int k) {
 		this.pointArray = pointArray;
 		this.n = pointArray.length;
 		this.dim = pointArray[0].length;
 		this.k = k;
-		
+
 		// means of the clusters
 		this.clusterMeans = new double[k][dim];
 		// variance vectors of the clusters
 		this.clusterVariances = new double[k][dim];
-		
+
 		// probability for the points given a cluster
 		this.pXgivenC = new double[n][k];
 		// probabilities for points to belong to a cluster
@@ -141,9 +147,10 @@ private void initFields(double[][] pointArray, int k) {
 		// probabilities of the points
 		this.pX = new double[n];
 	}
-	
+
 	/**
 	 * creates an initial partitioning
+	 * 
 	 * @param pointArray
 	 * @param k
 	 */
@@ -152,14 +159,15 @@ private void setInitialPartitions(double[][] pointArray, int k) {
 			System.err.println("cannot cluster less than k points into k clusters...");
 			System.exit(0);
 		}
-		
+
 		// select randomly k initial means
-		// TODO: choose more stable initialization (comment: this is run several times (with different random seeds), i.e. the worst case should not occur)
-        Random random = new Random(randomSeed);
-		TreeSet<Integer> usedPoints = new TreeSet<Integer>();
+		// TODO: choose more stable initialization (comment: this is run several times
+		// (with different random seeds), i.e. the worst case should not occur)
+		Random random = new Random(randomSeed);
+		TreeSet<Integer> usedPoints = new TreeSet<>();
 		int nextIndex;
 		for (int i = 0; i < k; i++) {
-			nextIndex = ((Double)(Math.floor(random.nextDouble() * n))).intValue();
+			nextIndex = ((Double) (Math.floor(random.nextDouble() * n))).intValue();
 			if (usedPoints.contains(nextIndex)) {
 				i--;
 				continue;
@@ -169,7 +177,7 @@ private void setInitialPartitions(double[][] pointArray, int k) {
 				}
 			}
 		}
-		
+
 		// set pCgivenX=1 for the closest C for each point
 		int minDistIndex = 0;
 		double minDist, currentDist;
@@ -185,7 +193,7 @@ private void setInitialPartitions(double[][] pointArray, int k) {
 			pCgivenX[minDistIndex][x] = 1.0;
 		}
 	}
-	
+
 	private double euclideanDistance(double[] x, double[] y) {
 		double result = 0.0;
 		// d(x, y) = sqrt( \sum_{i=1 to d} ( (x_i - y_i)^2 ) )
@@ -194,13 +202,13 @@ private double euclideanDistance(double[] x, double[] y) {
 		}
 		return Math.sqrt(result);
 	}
-	
+
 	private void getNewClusterRepresentation() {
 		calculateWeights();
 		calculateMeans();
 		calculateVariances();
 	}
-	
+
 	private void calculateWeights() {
 		// W_i = 1/n * \sum_{x in D} ( P(C_i|x) )
 		for (int i = 0; i < k; i++) {
@@ -211,7 +219,7 @@ private void calculateWeights() {
 			clusterWeights[i] /= n;
 		}
 	}
-	
+
 	private void calculateMeans() {
 		// per dimension d:
 		// mu_i = [\sum_{x in D} ( x * P(C_i|x) )] / [W_i * n]
@@ -227,7 +235,7 @@ private void calculateMeans() {
 			}
 		}
 	}
-	
+
 	private void calculateVariances() {
 		// per dimension d:
 		// sigma_i = [\sum_{x in D} (P(C_i|x) * (x-mu_i)^2)] / ] / [W_i * n]
@@ -243,25 +251,25 @@ private void calculateVariances() {
 				}
 				if (clusterVariances[i][d] < this.minVariance)
 					clusterVariances[i][d] = this.minVariance;
-				else 
+				else
 					clusterVariances[i][d] /= (clusterWeights[i] * n);
 			}
 		}
 	}
-	
+
 	private void calculateClassConditionalDensities() {
 		// P(x|C) = factor * e^( -0.5 (x-mu) * Sigma^-1 * (x-mu) )
-		
+
 		// exponent = -0.5 (x-mu) * Sigma^-1 * (x-mu) )
-		// 			= -0.5 ( sum_d ((x_i - mu_i)^2 / var_i) )
+		// = -0.5 ( sum_d ((x_i - mu_i)^2 / var_i) )
 		double exponent;
 		double xMinusMu;
 
 		// factor = 1 / sqrt( (2*PI)^d * \prod_d(variance) )
-		//        = 1 / sqrt((2*PI)^d) * sqrt(\prod_d(variance))
-		//        = 1 / (2*PI)^(d/2)   * \prod_d(sqrt(variance))
+		// = 1 / sqrt((2*PI)^d) * sqrt(\prod_d(variance))
+		// = 1 / (2*PI)^(d/2) * \prod_d(sqrt(variance))
 		double factor;
-		
+
 		// for each cluster C_i
 		for (int i = 0; i < pXgivenC[0].length; i++) {
 			// if the cluster is empty, set P(x|C_i) = 0
@@ -270,15 +278,15 @@ private void calculateClassConditionalDensities() {
 					pXgivenC[x][i] = 0.0;
 				continue;
 			}
-			
+
 			// calculate the factor for each cluster
-			factor = Math.pow( (2.0 * Math.PI) , ((dim/2.0)) );
+			factor = Math.pow((2.0 * Math.PI), ((dim / 2.0)));
 			for (int d = 0; d < dim; d++) {
 				factor *= Math.sqrt(clusterVariances[i][d]);
 			}
 			// factor = 1 / sqrt( (2*PI)^d * \prod_d(variance) )
 			factor = 1 / factor;
-			
+
 			// calculate the density for each point x
 			for (int x = 0; x < pXgivenC.length; x++) {
 				exponent = 0.0;
@@ -291,7 +299,7 @@ private void calculateClassConditionalDensities() {
 			}
 		}
 	}
-	
+
 	private void calculatePX() {
 		// P(x) = \sum_{i=1 to k} ( W_i * P(x|C_i) )
 		for (int x = 0; x < n; x++) {
@@ -301,7 +309,7 @@ private void calculatePX() {
 			}
 		}
 	}
-	
+
 	private void calculatePCgivenX() {
 		// P(C_i|x) = W_i * P(x|C_i)/P(x)
 		for (int i = 0; i < k; i++) {
@@ -313,31 +321,31 @@ private void calculatePCgivenX() {
 			}
 		}
 	}
-	
+
 	private void calculateAllProbabilities() {
 		this.calculateClassConditionalDensities();
 		this.calculatePX();
 		this.calculatePCgivenX();
 	}
-	
+
 	private double expectation() {
 		// E(M) = \sum_{x in D} ( P(x) )
 		double result = 0.0;
 		for (int x = 0; x < n; x++) {
-			//result += Math.log(pX[x]);
+			// result += Math.log(pX[x]);
 			result += pX[x];
 		}
 		return result;
 	}
-	
+
 	@SuppressWarnings("unchecked")
 	private int[][] createProjectedClustering() {
-		TreeSet<Integer> nonEmptyClusters = new TreeSet<Integer>();
+		TreeSet<Integer> nonEmptyClusters = new TreeSet<>();
 		ArrayList<Integer>[] clusterMemberLists = new ArrayList[k];
 		for (int i = 0; i < k; i++) {
-			clusterMemberLists[i] = new ArrayList<Integer>();
+			clusterMemberLists[i] = new ArrayList<>();
 		}
-		
+
 		double maxProbability;
 		int maxProbIndex = 0;
 		// for each point ...
@@ -354,8 +362,9 @@ private int[][] createProjectedClustering() {
 			clusterMemberLists[maxProbIndex].add(x);
 			nonEmptyClusters.add(maxProbIndex);
 		}
-		
-		// copy the member lists to an array while removing the empty lists (i.e. empty clusters)
+
+		// copy the member lists to an array while removing the empty lists (i.e. empty
+		// clusters)
 		int[][] result = new int[nonEmptyClusters.size()][];
 		int counter = 0;
 		for (int i = 0; i < clusterMemberLists.length; i++) {
diff --git a/moa/src/main/java/moa/clusterers/outliers/AnyOut/util/EMTopDownTreeBuilder.java b/moa/src/main/java/moa/learners/clusterers/outliers/AnyOut/util/EMTopDownTreeBuilder.java
similarity index 81%
rename from moa/src/main/java/moa/clusterers/outliers/AnyOut/util/EMTopDownTreeBuilder.java
rename to moa/src/main/java/moa/learners/clusterers/outliers/AnyOut/util/EMTopDownTreeBuilder.java
index bf5befb34..ed4fb1d82 100644
--- a/moa/src/main/java/moa/clusterers/outliers/AnyOut/util/EMTopDownTreeBuilder.java
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/AnyOut/util/EMTopDownTreeBuilder.java
@@ -3,7 +3,7 @@
  *
  *    @author I. Assent, P. Kranen, C. Baldauf, T. Seidl
  *    @author G. Piskas, A. Gounaris
- * 
+ *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
@@ -15,15 +15,15 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.clusterers.outliers.AnyOut.util;
+package moa.learners.clusterers.outliers.AnyOut.util;
 
-import moa.clusterers.clustree.ClusKernel;
-import moa.clusterers.clustree.Entry;
-import moa.clusterers.clustree.Node;
+import moa.learners.clusterers.clustree.ClusKernel;
+import moa.learners.clusterers.clustree.Entry;
+import moa.learners.clusterers.clustree.Node;
 
 public class EMTopDownTreeBuilder {
 
@@ -32,10 +32,11 @@ public class EMTopDownTreeBuilder {
 	private boolean ALLOW_KERNELS_IN_INNER_NODES = true;
 
 	// constructors
-	public EMTopDownTreeBuilder() {}
+	public EMTopDownTreeBuilder() {
+	}
 
 	/**
-	 * 
+	 *
 	 * @param dataSet All data except the left out class
 	 * @return the root node of the resulting tree
 	 * @throws Exception
@@ -52,33 +53,37 @@ private Node buildTreeRecursively(DataSet dataSet, int level) throws Exception {
 		int count = 0;
 		// There are two cases where this method returns a leaf node
 		// 1) the number of objects in the given data set is smaller than the fanout
-		// 2) the data can not be split into at least two data sets with at least two objects each
+		// 2) the data can not be split into at least two data sets with at least two
+		// objects each
 
 		// case 1: if size is too small: create leaf node
 		if (dataSet.size() <= maxFanout) {
 			// create a kernel estimator for each object and insert it into the leaf node
-			for(DataObject dataObject : dataSet) {
+			for (DataObject dataObject : dataSet) {
 				// fill entry using the current 'dataObject'
 				entries[count] = new Entry(dataSet.getNrOfDimensions());
-				entries[count].add(new Entry(dataObject.getNrOfDimensions(),new ClusKernel(dataObject.getFeatures(),dataObject.getFeatures().length), 0));
+				entries[count].add(new Entry(dataObject.getNrOfDimensions(),
+						new ClusKernel(dataObject.getFeatures(), dataObject.getFeatures().length), 0));
 				count++;
 			}
 			// else split DataSet
 		} else {
 			DataSet[] subSets = splitDataSetUsingEM(dataSet, maxFanout);
 
-			// case 2: if the data set could not be split, we insert all objects into a new leaf node
+			// case 2: if the data set could not be split, we insert all objects into a new
+			// leaf node
 			if (subSets.length == 1) {
 				// force all objects into #maxFanout entries
-				for(DataObject dataObject : dataSet) {
-					Entry newEntry = new Entry(dataObject.getNrOfDimensions(),new ClusKernel(dataObject.getFeatures(),dataObject.getFeatures().length), 0);
+				for (DataObject dataObject : dataSet) {
+					Entry newEntry = new Entry(dataObject.getNrOfDimensions(),
+							new ClusKernel(dataObject.getFeatures(), dataObject.getFeatures().length), 0);
 					if (count < maxFanout) {
 						// fill entry using the current 'dataObject'
 						entries[count] = new Entry(dataSet.getNrOfDimensions());
 						entries[count].add(newEntry);
 					} else {
 						// rather than [count % maxFanout] merge it to the closest existing entry
-						double tmpDist, minDist = Double.MIN_VALUE; 
+						double tmpDist, minDist = Double.MIN_VALUE;
 						int closestEntry = 0;
 						for (int i = 0; i < entries.length; i++) {
 							tmpDist = entries[i].calcDistance(newEntry);
@@ -111,13 +116,16 @@ private Node buildTreeRecursively(DataSet dataSet, int level) throws Exception {
 							} else {
 								// fill entry using the one dataObject subSets[i].getObject(0)
 								entries[i] = new Entry(dataSet.getNrOfDimensions());
-								entries[i].add(new Entry(subSets[i].getObject(0).getNrOfDimensions(),new ClusKernel(subSets[i].getObject(0).getFeatures(),subSets[i].getObject(0).getFeatures().length), 0));
+								entries[i].add(new Entry(subSets[i].getObject(0).getNrOfDimensions(),
+										new ClusKernel(subSets[i].getObject(0).getFeatures(),
+												subSets[i].getObject(0).getFeatures().length),
+										0));
 							}
 						} else {
 							// fill entry using newChildNodes[i]
 							entries[i] = new Entry(dataSet.getNrOfDimensions());
 							entries[i].setChild(newChildNodes[i]);
-							for (Entry e : newChildNodes[i].getEntries()){
+							for (Entry e : newChildNodes[i].getEntries()) {
 								entries[i].add(e);
 							}
 						}
@@ -135,41 +143,44 @@ private Node buildTreeRecursively(DataSet dataSet, int level) throws Exception {
 		}
 		// and add them all to the resulting node
 		resultNode = new Node(dataSet.getNrOfDimensions(), level);
-		for (Entry e : entries){
-			resultNode.addEntry(e,0);
+		for (Entry e : entries) {
+			resultNode.addEntry(e, 0);
 		}
 
 		return resultNode;
 	}
 
 	/**
-	 * This methods splits the given data set into partitions using the EM algorithm.
-	 * The resulting number of partitions is <= nrOfPartitions.
-	 * If EM returns only one partition, the data set is split using mean shift.
-	 * The size of each resulting partition is AT LEAST 2, 
-	 * i.e. partitions with size 1 are merged with the closest remaining partition.
-	 * Hence, this method might return only one partition containing the whole data set. 
-	 *  
+	 * This methods splits the given data set into partitions using the EM
+	 * algorithm. The resulting number of partitions is <= nrOfPartitions. If EM
+	 * returns only one partition, the data set is split using mean shift. The size
+	 * of each resulting partition is AT LEAST 2, i.e. partitions with size 1 are
+	 * merged with the closest remaining partition. Hence, this method might return
+	 * only one partition containing the whole data set.
+	 * 
 	 * @param dataSet
 	 * @param nrOfPartitions
-	 * @return an array of DataSets containing the partitions (minimal 1, maximal nrOfPartitions)
+	 * @return an array of DataSets containing the partitions (minimal 1, maximal
+	 *         nrOfPartitions)
 	 * @throws Exception
 	 */
 	private DataSet[] splitDataSetUsingEM(DataSet dataSet, int nrOfPartitions) throws Exception {
-		if (dataSet.size() <= 1) throw new Exception("EMsplit needs at least 2 objects!");
+		if (dataSet.size() <= 1)
+			throw new Exception("EMsplit needs at least 2 objects!");
 		EMProjectedClustering myEM = new EMProjectedClustering();
 		// iterate several times and take best solution
 		int nrOfIterations = 1;
-		// maximum      --> 10 iterations
+		// maximum --> 10 iterations
 		// 10^2 objects --> 8 iterations
 		// 10^6 objects --> 4 iteration
-		// minimum      --> 2 iterations
+		// minimum --> 2 iterations
 		//
 		// #iterations = max{1, (10 - log_10(#objects)) }
-		double log10 = Math.log(dataSet.size()*1.0)/Math.log(10.0);		
+		double log10 = Math.log(dataSet.size() * 1.0) / Math.log(10.0);
 		nrOfIterations = Math.max(1, (10 - ((Long) Math.round(log10)).intValue()));
 		nrOfIterations = Math.min(10, nrOfIterations);
-		int[][] emMapping = myEM.getEMClusteringVariancesBestChoice(dataSet.getFeaturesAsArray(), nrOfPartitions, nrOfIterations);
+		int[][] emMapping = myEM.getEMClusteringVariancesBestChoice(dataSet.getFeaturesAsArray(), nrOfPartitions,
+				nrOfIterations);
 
 		DataSet[] subDataSets = new DataSet[emMapping.length];
 		for (int i = 0; i < subDataSets.length; i++) {
@@ -227,7 +238,7 @@ private DataSet[] splitDataSetUsingMeanShift(DataSet dataSet) {
 		double[] mean = new double[dim];
 		for (int i = 0; i < dim; i++) {
 			mean[i] = LS[i] / N;
-			sigmaSquared[i] = (SS[i] / N) - ((LS[i] * LS [i]) / (N * N));
+			sigmaSquared[i] = (SS[i] / N) - ((LS[i] * LS[i]) / (N * N));
 			if (sigmaSquared[i] <= 0.0) {
 				sigmaSquared[i] = 0.1;
 			}
@@ -238,7 +249,7 @@ private DataSet[] splitDataSetUsingMeanShift(DataSet dataSet) {
 		for (int i = 0; i < dim; i++) {
 			mean1[i] = mean[i] + Math.sqrt(sigmaSquared[i]);
 			mean2[i] = mean[i] - Math.sqrt(sigmaSquared[i]);
-		}		
+		}
 		// assign objects to closest mean in two data set
 		DataSet[] subDataSets = new DataSet[2];
 		try {
@@ -258,7 +269,7 @@ private DataSet[] splitDataSetUsingMeanShift(DataSet dataSet) {
 		}
 
 		// if one data set is empty return only one
-		if(subDataSets[0].size() == 0) {
+		if (subDataSets[0].size() == 0) {
 			DataSet tmpDS = subDataSets[1];
 			subDataSets = new DataSet[1];
 			subDataSets[0] = tmpDS;
@@ -272,7 +283,7 @@ private DataSet[] splitDataSetUsingMeanShift(DataSet dataSet) {
 	}
 
 	private DataSet[] mergeDataSets(DataSet[] subDataSets, int setToMerge) throws Exception {
-		DataSet[] result = new DataSet[subDataSets.length-1];
+		DataSet[] result = new DataSet[subDataSets.length - 1];
 
 		DataSet tmpDataSet;
 		int nrOfDim = subDataSets[0].getNrOfDimensions();
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/MCOD/ISBIndex.java b/moa/src/main/java/moa/learners/clusterers/outliers/MCOD/ISBIndex.java
new file mode 100644
index 000000000..7a748a9c5
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/MCOD/ISBIndex.java
@@ -0,0 +1,273 @@
+/*
+ *    ISBIndex.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers.MCOD;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.Vector;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+public class ISBIndex {
+	public static class ISBNode implements Comparable<ISBNode> {
+		public enum NodeType {
+			OUTLIER, INLIER_MC, INLIER_PD
+		}
+
+		public Instance inst;
+		public StreamObj obj;
+		public Long id;
+		public MicroCluster mc;
+		public Set<MicroCluster> Rmc;
+		public int count_after;
+		public NodeType nodeType;
+		private ArrayList<ISBNode> nn_before;
+
+		// statistics
+		public int nOutlier;
+		public int nInlier;
+
+		public ISBNode(Instance inst, StreamObj obj, Long id) {
+			this.inst = inst;
+			this.obj = obj;
+			this.id = id;
+
+			// init statistics
+			nOutlier = 0;
+			nInlier = 0;
+
+			// init other fields
+			InitNode();
+		}
+
+		public void InitNode() {
+			this.mc = null;
+			this.Rmc = new TreeSet<>();
+			this.count_after = 1;
+			this.nodeType = NodeType.INLIER_PD;
+			this.nn_before = new ArrayList<>();
+		}
+
+		@Override
+		public int compareTo(ISBNode t) {
+			if (this.id > t.id)
+				return +1;
+			else if (this.id < t.id)
+				return -1;
+			return 0;
+		}
+
+		public void AddPrecNeigh(ISBNode node) {
+			int pos = Collections.binarySearch(nn_before, node);
+			if (pos < 0) {
+				// item does not exist, so add it to the right position
+				nn_before.add(-(pos + 1), node);
+			}
+		}
+
+		public void RemovePrecNeigh(ISBNode node) {
+			int pos = Collections.binarySearch(nn_before, node);
+			if (pos >= 0) {
+				// item exists
+				nn_before.remove(pos);
+			}
+		}
+
+		public ISBNode GetMinPrecNeigh(Long sinceId) {
+			if (nn_before.size() > 0) {
+				int startPos;
+				ISBNode dummy = new ISBNode(null, null, sinceId);
+
+				int pos = Collections.binarySearch(nn_before, dummy);
+				if (pos < 0) {
+					// item does not exist, should insert at position startPos
+					startPos = -(pos + 1);
+				} else {
+					// item exists at startPos
+					startPos = pos;
+				}
+
+				if (startPos < nn_before.size()) {
+					return nn_before.get(startPos);
+				}
+			}
+			return null;
+		}
+
+		public int CountPrecNeighs(Long sinceId) {
+			if (nn_before.size() > 0) {
+				// get number of neighs with id >= sinceId
+				int startPos;
+				ISBNode dummy = new ISBNode(null, null, sinceId);
+				int pos = Collections.binarySearch(nn_before, dummy);
+				if (pos < 0) {
+					// item does not exist, should insert at position startPos
+					startPos = -(pos + 1);
+				} else {
+					// item exists at startPos
+					startPos = pos;
+				}
+
+				if (startPos < nn_before.size()) {
+					return nn_before.size() - startPos;
+				}
+			}
+			return 0;
+		}
+
+		public List<ISBNode> Get_nn_before() {
+			return nn_before;
+		}
+	}
+
+	MTreeStreamObjects mtree;
+	Map<Integer, Set<ISBNode>> mapNodes;
+	double m_radius;
+	int m_k; // k nearest neighbors
+
+	public ISBIndex(double radius, int k) {
+		mtree = new MTreeStreamObjects();
+		mapNodes = new HashMap<>();
+		m_radius = radius;
+		m_k = k;
+	}
+
+	Vector<ISBNode> GetAllNodes() {
+		Vector<ISBNode> v = new Vector<>();
+		Iterator it = mapNodes.entrySet().iterator();
+		while (it.hasNext()) {
+			Map.Entry pairs = (Map.Entry) it.next();
+			Set<ISBNode> setNodes = (Set<ISBNode>) pairs.getValue();
+			for (ISBNode n : setNodes) {
+				v.add(n);
+			}
+		}
+		return v;
+	}
+
+	public static class ISBSearchResult {
+		public ISBNode node;
+		public double distance;
+
+		public ISBSearchResult(ISBNode n, double distance) {
+			this.node = n;
+			this.distance = distance;
+		}
+	}
+
+	public Vector<ISBSearchResult> RangeSearch(ISBNode node, double radius) {
+		Vector<ISBSearchResult> results = new Vector<>();
+		StreamObj obj;
+		double d;
+		MTreeStreamObjects.Query query = mtree.getNearestByRange(node.obj, radius);
+		for (MTreeStreamObjects.ResultItem q : query) {
+			// get next obj found within range
+			obj = q.data;
+			// get distance of obj from query
+			d = q.distance;
+			// get all nodes referencing obj
+			Vector<ISBNode> nodes = MapGetNodes(obj);
+			for (int i = 0; i < nodes.size(); i++)
+				results.add(new ISBSearchResult(nodes.get(i), d));
+		}
+		return results;
+	}
+
+	public void Insert(ISBNode node) {
+		// insert object of node at mtree
+		mtree.add(node.obj);
+		// insert node at map
+		MapInsert(node);
+	}
+
+	public void Remove(ISBNode node) {
+		// remove from map
+		MapDelete(node);
+		// check if stream object at mtree is still being referenced
+		if (MapCountObjRefs(node.obj) <= 0) {
+			// delete stream object from mtree
+			mtree.remove(node.obj);
+		}
+	}
+
+	Vector<ISBNode> MapGetNodes(StreamObj obj) {
+		int h = obj.hashCode();
+		Vector<ISBNode> v = new Vector<>();
+		if (mapNodes.containsKey(h)) {
+			Set<ISBNode> s = mapNodes.get(h);
+			ISBNode node;
+			Iterator<ISBNode> i = s.iterator();
+			while (i.hasNext()) {
+				node = i.next();
+				if (node.obj.equals(obj))
+					v.add(node);
+			}
+		}
+		return v;
+	}
+
+	int MapCountObjRefs(StreamObj obj) {
+		int h = obj.hashCode();
+		int iCount = 0;
+		if (mapNodes.containsKey(h)) {
+			Set<ISBNode> s = mapNodes.get(h);
+			ISBNode n;
+			Iterator<ISBNode> i = s.iterator();
+			while (i.hasNext()) {
+				n = i.next();
+				if (n.obj.equals(obj))
+					iCount++;
+			}
+		}
+		return iCount;
+	}
+
+	void MapInsert(ISBNode node) {
+		int h = node.obj.hashCode();
+		Set<ISBNode> s;
+		if (mapNodes.containsKey(h)) {
+			s = mapNodes.get(h);
+			s.add(node);
+		} else {
+			s = new HashSet<>();
+			s.add(node);
+			mapNodes.put(h, s);
+		}
+	}
+
+	void MapDelete(ISBNode node) {
+		int h = node.obj.hashCode();
+		if (mapNodes.containsKey(h)) {
+			Set<ISBNode> s = mapNodes.get(h);
+			s.remove(node);
+			if (s.isEmpty()) { // ### added
+				mapNodes.remove(h);
+			}
+		}
+	}
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/MCOD/MCOD.java b/moa/src/main/java/moa/learners/clusterers/outliers/MCOD/MCOD.java
new file mode 100644
index 000000000..a9755be0a
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/MCOD/MCOD.java
@@ -0,0 +1,464 @@
+/*
+ *    MCOD.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers.MCOD;
+
+import java.util.ArrayList;
+import java.util.TreeSet;
+import java.util.Vector;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.learners.clusterers.outliers.MCOD.ISBIndex.ISBNode;
+import moa.learners.clusterers.outliers.MCOD.ISBIndex.ISBSearchResult;
+import moa.learners.clusterers.outliers.MCOD.ISBIndex.ISBNode.NodeType;
+
+//The algorithm is described in
+// M. Kontaki, A. Gounaris, A. N. Papadopoulos, K. Tsichlas, and Y. Manolopoulos.
+//Continuous monitoring of distance-based outliers over data streams.
+//In ICDE, pages 135–146, 2011.
+
+public class MCOD extends MCODBase {
+	public FloatOption radiusOption = new FloatOption("radius", 'r', "Search radius.", 0.1);
+	public IntOption kOption = new IntOption("k", 't', "Parameter k.", 50);
+
+	public MCOD() {
+		// System.out.println("MCOD: created");
+	}
+
+	@Override
+	public void Init() {
+		super.Init();
+
+		m_WindowSize = windowSizeOption.getValue();
+		m_radius = radiusOption.getValue();
+		m_k = kOption.getValue();
+
+		Println("Init MCOD:");
+		Println("   window_size: " + m_WindowSize);
+		Println("   radius: " + m_radius);
+		Println("   k: " + m_k);
+
+		// bTrace = true;
+		// bWarning = true;
+
+		objId = FIRST_OBJ_ID; // init object identifier
+		// create nodes list of window
+		windowNodes = new Vector<>();
+		// create ISB
+		ISB_PD = new ISBIndex(m_radius, m_k);
+		// create helper sets for micro-cluster management
+		setMC = new TreeSet<>();
+		// micro-cluster index
+		mtreeMC = new MTreeMicroClusters();
+		// create event queue
+		eventQueue = new EventQueue();
+
+		// init statistics
+		m_nBothInlierOutlier = 0;
+		m_nOnlyInlier = 0;
+		m_nOnlyOutlier = 0;
+	}
+
+	void SetNodeType(ISBNode node, NodeType type) {
+		node.nodeType = type;
+		// update statistics
+		if (type == NodeType.OUTLIER)
+			node.nOutlier++;
+		else
+			node.nInlier++;
+	}
+
+	void AddNeighbor(ISBNode node, ISBNode q, boolean bUpdateState) {
+		if (bTrace)
+			Println("AddNeighbor: node.id: " + node.id + ", q.id: " + q.id);
+
+		// check if q still in window
+		if (IsNodeIdInWin(q.id) == false) {
+			if (bWarning)
+				Println("AddNeighbor: node.id: " + node.id + ", q.id: " + q.id + " (expired)");
+			return;
+		}
+
+		if (q.id < node.id) {
+			node.AddPrecNeigh(q);
+		} else {
+			node.count_after++;
+		}
+
+		if (bUpdateState) {
+			// check if node inlier or outlier
+			int count = node.count_after + node.CountPrecNeighs(GetWindowStart());
+			if ((node.nodeType == NodeType.OUTLIER) && (count >= m_k)) {
+				// remove node from outliers
+				if (bTrace)
+					Println("Remove node from outliers");
+				RemoveOutlier(node);
+				// add node to inlier set PD
+				SetNodeType(node, NodeType.INLIER_PD);
+				// insert node to event queue
+				ISBNode nodeMinExp = node.GetMinPrecNeigh(GetWindowStart());
+				AddToEventQueue(node, nodeMinExp);
+			}
+		}
+	}
+
+	void ProcessNewNode(ISBNode nodeNew, boolean bNewNode) {
+		if (bTrace) {
+			Print("ProcessNewNode: ");
+			PrintNode(nodeNew);
+		}
+
+		if (bTrace)
+			Println("Perform 3R/2 range query to cluster centers w.r.t new node");
+		Vector<SearchResultMC> resultsMC;
+		// results are sorted ascenting by distance
+		resultsMC = RangeSearchMC(nodeNew, 1.5 * m_radius);
+		if (bTrace) {
+			Println("MC query found: ");
+			for (SearchResultMC sr : resultsMC) {
+				Printf("  (%.1f) mcc: ", sr.distance);
+				PrintNode(sr.mc.mcc);
+			}
+		}
+
+		if (bTrace)
+			Println("Get closest micro-cluster");
+		MicroCluster mcClosest = null;
+		if (resultsMC.size() > 0) {
+			mcClosest = resultsMC.get(0).mc;
+			if (bTrace)
+				Println("Closest mcc: " + mcClosest.mcc.id);
+		}
+
+		// check if nodeNew can be insterted to closest micro-cluster
+		boolean bFoundMC = false;
+		if (mcClosest != null) {
+			double d = GetEuclideanDist(nodeNew, mcClosest.mcc);
+			if (d <= m_radius / 2) {
+				bFoundMC = true;
+			} else {
+				if (bTrace)
+					Println("Not close enough to closest mcc");
+			}
+		}
+
+		if (bFoundMC) {
+			if (bTrace)
+				Println("Add new node to micro-cluster");
+			nodeNew.mc = mcClosest;
+			SetNodeType(nodeNew, NodeType.INLIER_MC);
+			mcClosest.AddNode(nodeNew);
+			if (bTrace) {
+				Print("mcClosest.nodes: ");
+				PrintNodeList(mcClosest.nodes);
+			}
+
+			if (bTrace)
+				Println("Update neighbors of set PD");
+			Vector<ISBNode> nodes;
+			nodes = ISB_PD.GetAllNodes();
+			for (ISBNode q : nodes) {
+				if (q.Rmc.contains(mcClosest)) {
+					if (GetEuclideanDist(q, nodeNew) <= m_radius) {
+						if (bNewNode) {
+							// update q.count_after and its' outlierness
+							AddNeighbor(q, nodeNew, true);
+						} else {
+							if (nodesReinsert.contains(q)) {
+								// update q.count_after or q.nn_before and its' outlierness
+								AddNeighbor(q, nodeNew, true);
+							}
+						}
+					}
+				}
+			}
+		} else {
+			// No close enough micro-cluster found.
+			// Perform 3R/2 range query to nodes in set PD.
+
+			if (bTrace)
+				Println("Perform 3R/2 range query to nodes in set PD");
+			nRangeQueriesExecuted++;
+			// create helper sets for micro-cluster management
+			ArrayList<ISBNode> setNC = new ArrayList<>();
+			ArrayList<ISBNode> setNNC = new ArrayList<>();
+			Vector<ISBSearchResult> resultNodes;
+			resultNodes = ISB_PD.RangeSearch(nodeNew, 1.5 * m_radius); // 1.5 ###
+			for (ISBSearchResult sr : resultNodes) {
+				ISBNode q = sr.node;
+				if (sr.distance <= m_radius) {
+					// add q to neighs of nodeNew
+					AddNeighbor(nodeNew, q, false);
+					if (bNewNode) {
+						// update q.count_after and its' outlierness
+						AddNeighbor(q, nodeNew, true);
+					} else {
+						if (nodesReinsert.contains(q)) {
+							// update q.count_after or q.nn_before and its' outlierness
+							AddNeighbor(q, nodeNew, true);
+						}
+					}
+				}
+
+				if (sr.distance <= m_radius / 2.0) {
+					setNC.add(q);
+				} else {
+					setNNC.add(q);
+				}
+			}
+			if (bTrace) {
+				Print("Prec neighs of new node: ");
+				PrintNodeList(nodeNew.Get_nn_before());
+				Print("NC: ");
+				PrintNodeList(setNC);
+				Print("NNC: ");
+				PrintNodeList(setNNC);
+			}
+
+			// check if size of set NC big enough to create cluster
+			if (bTrace)
+				Println("Check size of set NC");
+			if (setNC.size() >= m_theta * m_k) {
+				// create new micro-cluster with center nodeNew
+				if (bTrace)
+					Println("Create new micro-cluster");
+				MicroCluster mcNew = new MicroCluster(nodeNew);
+				AddMicroCluster(mcNew);
+				nodeNew.mc = mcNew;
+				SetNodeType(nodeNew, NodeType.INLIER_MC);
+
+				if (bTrace)
+					Println("Add to new mc nodes within range R/2");
+				for (ISBNode q : setNC) {
+					q.mc = mcNew;
+					mcNew.AddNode(q);
+					// move q from set PD to set inlier-mc
+					SetNodeType(q, NodeType.INLIER_MC);
+					ISB_PD.Remove(q);
+					RemoveOutlier(q); // needed? ###
+				}
+				if (bTrace) {
+					Print("mcNew.nodes: ");
+					PrintNodeList(mcNew.nodes);
+					PrintPD();
+				}
+
+				if (bTrace)
+					Println("Update Rmc lists of nodes of PD in range 3R/2 from mcNew");
+				for (ISBNode q : setNNC) {
+					q.Rmc.add(mcNew);
+					if (bTrace) {
+						Print(q.id + ".Rmc: ");
+						PrintMCSet(q.Rmc);
+					}
+				}
+			} else {
+				if (bTrace)
+					Println("Add to nodeNew neighs nodes of near micro-clusters");
+				for (SearchResultMC sr : resultsMC) {
+					for (ISBNode q : sr.mc.nodes) {
+						if (GetEuclideanDist(q, nodeNew) <= m_radius) {
+							// add q to neighs of nodeNew
+							AddNeighbor(nodeNew, q, false);
+						}
+					}
+				}
+				if (bTrace) {
+					Println("nodeNew.count_after = " + nodeNew.count_after);
+					Print("nodeNew.nn_before: ");
+					PrintNodeList(nodeNew.Get_nn_before());
+				}
+
+				if (bTrace)
+					Println("Insert nodeNew to index of nodes of PD");
+				ISB_PD.Insert(nodeNew);
+				if (bTrace)
+					PrintPD();
+
+				// check if nodeNew is an inlier or outlier
+				// use both nn_before and count_after for case bNewNode=false
+				int count = nodeNew.CountPrecNeighs(GetWindowStart()) + nodeNew.count_after;
+				if (count >= m_k) {
+					if (bTrace)
+						Println("nodeNew is an inlier");
+					SetNodeType(nodeNew, NodeType.INLIER_PD);
+					// insert nodeNew to event queue
+					ISBNode nodeMinExp = nodeNew.GetMinPrecNeigh(GetWindowStart());
+					AddToEventQueue(nodeNew, nodeMinExp);
+				} else {
+					if (bTrace)
+						Println("nodeNew is an outlier");
+					SetNodeType(nodeNew, NodeType.OUTLIER);
+					SaveOutlier(nodeNew);
+				}
+
+				if (bTrace)
+					Println("Update nodeNew.Rmc");
+				for (SearchResultMC sr : resultsMC) {
+					nodeNew.Rmc.add(sr.mc);
+				}
+				if (bTrace) {
+					Print("nodeNew.Rmc: ");
+					PrintMCSet(nodeNew.Rmc);
+				}
+			}
+		}
+	}
+
+	void AddToEventQueue(ISBNode x, ISBNode nodeMinExp) {
+		if (bTrace)
+			Println("AddToEventQueue x.id: " + x.id);
+		if (nodeMinExp != null) {
+			Long expTime = GetExpirationTime(nodeMinExp);
+			eventQueue.Insert(x, expTime);
+			if (bTrace) {
+				Print("x.nn_before: ");
+				PrintNodeList(x.Get_nn_before());
+				Println("nodeMinExp: " + nodeMinExp.id + ", expTime = " + expTime);
+				PrintEventQueue();
+			}
+		} else {
+			if (bWarning)
+				Println("AddToEventQueue: Cannot add x.id: " + x.id
+						+ " to event queue (nn_before is empty, count_after=" + x.count_after + ")");
+		}
+	}
+
+	void ProcessEventQueue(ISBNode nodeExpired) {
+		EventItem e = eventQueue.FindMin();
+		while ((e != null) && (e.timeStamp <= GetWindowEnd())) {
+			e = eventQueue.ExtractMin();
+			ISBNode x = e.node;
+			if (bTrace)
+				Println("Process event queue: check node x: " + x.id);
+			// node x must be in window and not in any micro-cluster
+			boolean bValid = (IsNodeIdInWin(x.id) && (x.mc == null));
+			if (bValid) {
+				// remove nodeExpired from x.nn_before
+				x.RemovePrecNeigh(nodeExpired);
+				// get amount of neighbors of x
+				int count = x.count_after + x.CountPrecNeighs(GetWindowStart());
+				if (count < m_k) {
+					if (bTrace)
+						Println("x is an outlier");
+					SetNodeType(x, NodeType.OUTLIER);
+					SaveOutlier(x);
+				} else {
+					if (bTrace)
+						Println("x is an inlier, add to event queue");
+					// get oldest preceding neighbor of x
+					ISBNode nodeMinExp = x.GetMinPrecNeigh(GetWindowStart());
+					// add x to event queue
+					AddToEventQueue(x, nodeMinExp);
+				}
+			} else {
+				if (bWarning)
+					Println("Process event queue: node x.id: " + x.id + " is not valid!");
+			}
+			e = eventQueue.FindMin();
+		}
+	}
+
+	void ProcessExpiredNode(ISBNode nodeExpired) {
+		if (nodeExpired != null) {
+			if (bTrace)
+				Println("\nnodeExpired: " + nodeExpired.id);
+			MicroCluster mc = nodeExpired.mc;
+			if (mc != null) {
+				if (bTrace)
+					Println("nodeExpired belongs to mc: " + mc.mcc.id);
+				mc.RemoveNode(nodeExpired);
+				if (bTrace) {
+					Print("mc.nodes: ");
+					PrintNodeList(mc.nodes);
+				}
+
+				if (bTrace)
+					Println("Check if mc has enough objects");
+				if (mc.GetNodesCount() < m_k) {
+					// remove micro-cluster mc
+					if (bTrace)
+						Println("Remove mc");
+					RemoveMicroCluster(mc);
+
+					// insert nodes of mc to set nodesReinsert
+					nodesReinsert = new TreeSet<>();
+					for (ISBNode q : mc.nodes) {
+						nodesReinsert.add(q);
+					}
+
+					// treat each node of mc as new node
+					for (ISBNode q : mc.nodes) {
+						if (bTrace)
+							Println("\nTreat as new node q: " + q.id);
+						q.InitNode();
+						ProcessNewNode(q, false);
+					}
+				}
+			} else {
+				// nodeExpired belongs to set PD
+				// remove nodeExpired from PD index
+				ISB_PD.Remove(nodeExpired);
+			}
+
+			RemoveNode(nodeExpired);
+			ProcessEventQueue(nodeExpired);
+		}
+	}
+
+	@Override
+	protected void ProcessNewStreamObj(Instance inst) {
+		if (bShowProgress)
+			ShowProgress("Processed " + (objId - 1) + " stream objects.");
+		// PrintInstance(inst);
+
+		double[] values = getInstanceValues(inst);
+		StreamObj obj = new StreamObj(values);
+
+		if (bTrace)
+			Println("\n- - - - - - - - - - - -\n");
+
+		// create new ISB node
+		ISBNode nodeNew = new ISBNode(inst, obj, objId);
+		if (bTrace) {
+			Print("New node: ");
+			PrintNode(nodeNew);
+		}
+
+		objId++; // update object identifier (slide window)
+
+		AddNode(nodeNew); // add nodeNew to window
+		if (bTrace)
+			PrintWindow();
+
+		ProcessNewNode(nodeNew, true);
+		ProcessExpiredNode(GetExpiredNode());
+
+		if (bTrace) {
+			Print("Micro-clusters: ");
+			PrintMCSet(setMC);
+			PrintOutliers();
+			PrintPD();
+		}
+	}
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/MCOD/MCODBase.java b/moa/src/main/java/moa/learners/clusterers/outliers/MCOD/MCODBase.java
new file mode 100644
index 000000000..09293b83a
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/MCOD/MCODBase.java
@@ -0,0 +1,374 @@
+/*
+ *    MCODBase.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers.MCOD;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.Vector;
+
+import moa.learners.clusterers.outliers.MyBaseOutlierDetector;
+import moa.learners.clusterers.outliers.MCOD.ISBIndex.ISBNode;
+import moa.learners.clusterers.outliers.MCOD.ISBIndex.ISBNode.NodeType;
+
+public abstract class MCODBase extends MyBaseOutlierDetector {
+	protected static class EventItem implements Comparable<EventItem> {
+		public ISBNode node;
+		public Long timeStamp;
+
+		public EventItem(ISBNode node, Long timeStamp) {
+			this.node = node;
+			this.timeStamp = timeStamp;
+		}
+
+		@Override
+		public int compareTo(EventItem t) {
+			if (this.timeStamp > t.timeStamp) {
+				return +1;
+			} else if (this.timeStamp < t.timeStamp) {
+				return -1;
+			} else {
+				if (this.node.id > t.node.id)
+					return +1;
+				else if (this.node.id < t.node.id)
+					return -1;
+			}
+			return 0;
+		}
+	}
+
+	protected static class EventQueue {
+		public TreeSet<EventItem> setEvents;
+
+		public EventQueue() {
+			setEvents = new TreeSet<>();
+		}
+
+		public void Insert(ISBNode node, Long expTime) {
+			setEvents.add(new EventItem(node, expTime));
+		}
+
+		public EventItem FindMin() {
+			if (setEvents.size() > 0) {
+				// events are sorted ascenting by expiration time
+				return setEvents.first();
+			}
+			return null;
+		}
+
+		public EventItem ExtractMin() {
+			EventItem e = FindMin();
+			if (e != null) {
+				setEvents.remove(e);
+				return e;
+			}
+			return null;
+		}
+	}
+
+	protected static final Long FIRST_OBJ_ID = 1L;
+
+	// object identifier increments with each new data stream object
+	protected Long objId;
+	// list used to find expired nodes
+	protected Vector<ISBNode> windowNodes;
+	protected EventQueue eventQueue;
+	// MTree index of micro-clusters
+	protected MTreeMicroClusters mtreeMC;
+	// set of micro-clusters (for trace)
+	protected TreeSet<MicroCluster> setMC;
+	// nodes treated as new nodes when a mc removed
+	protected TreeSet<ISBNode> nodesReinsert;
+	// index of objects not in any micro-cluster
+	protected ISBIndex ISB_PD;
+	protected int m_WindowSize;
+	protected double m_radius;
+	protected int m_k;
+	protected double m_theta = 1.0;
+
+	public boolean bWarning = false;
+
+	// statistics
+	public int m_nBothInlierOutlier;
+	public int m_nOnlyInlier;
+	public int m_nOnlyOutlier;
+
+	@Override
+	public String getObjectInfo(Object obj) {
+		if (obj == null)
+			return null;
+
+		ISBNode node = (ISBNode) obj;
+
+		ArrayList<String> infoTitle = new ArrayList<>();
+		ArrayList<String> infoValue = new ArrayList<>();
+		StringBuilder sb = new StringBuilder();
+
+		// show node type
+		infoTitle.add("Node type");
+		infoValue.add((node.nodeType == NodeType.OUTLIER) ? "Outlier" : "Inlier");
+
+		// show node position
+		for (int i = 0; i < node.obj.dimensions(); i++) {
+			infoTitle.add("Dim" + (i + 1));
+			infoValue.add(String.format("%.3f", node.obj.get(i)));
+		}
+
+		// show node properties
+		infoTitle.add("id");
+		infoValue.add(String.format("%d", node.id));
+		infoTitle.add("count_after");
+		infoValue.add(String.format("%d", node.count_after));
+		infoTitle.add("|nn_before|");
+		infoValue.add(String.format("%d", node.CountPrecNeighs(GetWindowStart())));
+
+		sb.append("<html>");
+		sb.append("<table>");
+		int i = 0;
+		while (i < infoTitle.size() && i < infoValue.size()) {
+			sb.append("<tr><td><b>" + infoTitle.get(i) + ":</b></td><td>" + infoValue.get(i) + "</td></tr>");
+			i++;
+		}
+		sb.append("</table>");
+
+		sb.append("</html>");
+		return sb.toString();
+	}
+
+	@Override
+	public String getStatistics() {
+		StringBuilder sb = new StringBuilder();
+
+		sb.append("Statistics:\n\n");
+
+		// get counters of expired nodes
+		int nBothInlierOutlier = m_nBothInlierOutlier;
+		int nOnlyInlier = m_nOnlyInlier;
+		int nOnlyOutlier = m_nOnlyOutlier;
+
+		// add counters of non expired nodes
+		for (ISBNode node : windowNodes) {
+			if ((node.nInlier > 0) && (node.nOutlier > 0))
+				nBothInlierOutlier++;
+			else if (node.nInlier > 0)
+				nOnlyInlier++;
+			else
+				nOnlyOutlier++;
+		}
+
+		int sum = nBothInlierOutlier + nOnlyInlier + nOnlyOutlier;
+		if (sum > 0) {
+			sb.append(String.format("  Nodes always inlier: %d (%.1f%%)\n", nOnlyInlier,
+					(100 * nOnlyInlier) / (double) sum));
+			sb.append(String.format("  Nodes always outlier: %d (%.1f%%)\n", nOnlyOutlier,
+					(100 * nOnlyOutlier) / (double) sum));
+			sb.append(String.format("  Nodes both inlier and outlier: %d (%.1f%%)\n", nBothInlierOutlier,
+					(100 * nBothInlierOutlier) / (double) sum));
+
+			sb.append("  (Sum: " + sum + ")\n");
+		}
+
+		sb.append("\n  Total range queries: " + nRangeQueriesExecuted + "\n");
+		sb.append("  Max memory usage: " + iMaxMemUsage + " MB\n");
+		sb.append("  Total process time: " + String.format("%.2f ms", nTotalRunTime / 1000.0) + "\n");
+
+		return sb.toString();
+	}
+
+	Long GetWindowEnd() {
+		return objId - 1;
+	}
+
+	Long GetWindowStart() {
+		Long x = GetWindowEnd() - m_WindowSize + 1;
+		if (x < FIRST_OBJ_ID)
+			x = FIRST_OBJ_ID;
+		return x;
+	}
+
+	boolean IsWinFull() {
+		return (GetWindowEnd() >= FIRST_OBJ_ID + m_WindowSize - 1);
+	}
+
+	Long GetExpirationTime(ISBNode node) {
+		return node.id + m_WindowSize;
+	}
+
+	void SaveOutlier(ISBNode node) {
+		AddOutlier(new Outlier(node.inst, node.id, node));
+		node.nOutlier++; // update statistics
+	}
+
+	void RemoveOutlier(ISBNode node) {
+		RemoveOutlier(new Outlier(node.inst, node.id, node));
+		node.nInlier++; // update statistics
+	}
+
+	@Override
+	protected boolean IsNodeIdInWin(long id) {
+		int toleranceStart = 1;
+		Long start = GetWindowStart() - toleranceStart;
+		if ((start <= id) && (id <= GetWindowEnd()))
+			return true;
+		else
+			return false;
+	}
+
+	void AddNode(ISBNode node) {
+		windowNodes.add(node);
+	}
+
+	void RemoveNode(ISBNode node) {
+		windowNodes.remove(node);
+		RemoveExpiredOutlier(new Outlier(node.inst, node.id, node)); // ### remove when expired?
+		// update statistics
+		UpdateStatistics(node);
+	}
+
+	void UpdateStatistics(ISBNode node) {
+		if ((node.nInlier > 0) && (node.nOutlier > 0))
+			m_nBothInlierOutlier++;
+		else if (node.nInlier > 0)
+			m_nOnlyInlier++;
+		else
+			m_nOnlyOutlier++;
+	}
+
+	ISBNode GetExpiredNode() {
+		if (windowNodes.size() <= 0)
+			return null;
+		// get oldest node
+		ISBNode node = windowNodes.get(0);
+		// check if node has expired
+		if (node.id < GetWindowStart()) {
+			return node;
+		}
+		return null;
+	}
+
+	void AddMicroCluster(MicroCluster mc) {
+		mtreeMC.add(mc);
+		setMC.add(mc);
+	}
+
+	void RemoveMicroCluster(MicroCluster mc) {
+		mtreeMC.remove(mc);
+		setMC.remove(mc);
+	}
+
+	class SearchResultMC {
+		MicroCluster mc;
+		double distance;
+
+		public SearchResultMC(MicroCluster mc, double distance) {
+			this.mc = mc;
+			this.distance = distance;
+		}
+	}
+
+	Vector<SearchResultMC> RangeSearchMC(ISBNode nodeNew, double radius) {
+		Vector<SearchResultMC> results = new Vector<>();
+		// create a dummy mc in order to search w.r.t. nodeNew
+		MicroCluster dummy = new MicroCluster(nodeNew);
+		// query results are returned ascenting by distance
+		MTreeMicroClusters.Query query = mtreeMC.getNearestByRange(dummy, radius);
+		for (MTreeMicroClusters.ResultItem q : query) {
+			results.add(new SearchResultMC(q.data, q.distance));
+		}
+		return results;
+	}
+
+	double GetEuclideanDist(ISBNode n1, ISBNode n2) {
+		double diff;
+		double sum = 0;
+		int d = n1.obj.dimensions();
+		for (int i = 0; i < d; i++) {
+			diff = n1.obj.get(i) - n2.obj.get(i);
+			sum += Math.pow(diff, 2);
+		}
+		return Math.sqrt(sum);
+	}
+
+	void PrintWindow() {
+		Println("Window [" + GetWindowStart() + "-" + GetWindowEnd() + "]: ");
+		ISBNode node;
+		for (int i = 0; i < windowNodes.size(); i++) {
+			node = windowNodes.get(i);
+			Print("   Node: ");
+			PrintNode(node);
+		}
+	}
+
+	void PrintNode(ISBNode n) {
+		Print("id=" + n.id + " (");
+		int dim = n.obj.dimensions();
+		for (int d = 0; d < dim; d++) {
+			Print(Double.toString(n.obj.get(d)));
+			if (d < dim - 1)
+				Print(", ");
+		}
+		Println(")");
+	}
+
+	public void PrintNodeSet(Set<ISBNode> set) {
+		for (ISBNode n : set) {
+			Print(n.id + " ");
+		}
+		Println("");
+	}
+
+	public void PrintMCSet(Set<MicroCluster> set) {
+		for (MicroCluster n : set) {
+			Print(n.mcc.id + " ");
+		}
+		Println("");
+	}
+
+	public void PrintNodeVector(Vector<ISBNode> vector) {
+		for (ISBNode n : vector) {
+			Print(n.id + " ");
+		}
+		Println("");
+	}
+
+	public void PrintNodeList(List<ISBNode> list) {
+		for (ISBNode n : list) {
+			Print(n.id + " ");
+		}
+		Println("");
+	}
+
+	public void PrintEventQueue() {
+		Println("event queue: ");
+		for (EventItem n : eventQueue.setEvents) {
+			Printf("  id=%d, exp=%d\n", n.node.id, n.timeStamp);
+		}
+	}
+
+	public void PrintPD() {
+		Print("PD: ");
+		for (ISBNode n : ISB_PD.GetAllNodes()) {
+			Print(n.id + " ");
+		}
+		Println("");
+	}
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/MCOD/MTreeMicroClusters.java b/moa/src/main/java/moa/learners/clusterers/outliers/MCOD/MTreeMicroClusters.java
new file mode 100644
index 000000000..58c12443c
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/MCOD/MTreeMicroClusters.java
@@ -0,0 +1,66 @@
+/*
+ *    MTreeMicroClusters.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers.MCOD;
+
+import java.util.Set;
+
+import moa.learners.clusterers.outliers.utils.mtree.ComposedSplitFunction;
+import moa.learners.clusterers.outliers.utils.mtree.DistanceFunction;
+import moa.learners.clusterers.outliers.utils.mtree.DistanceFunctions;
+import moa.learners.clusterers.outliers.utils.mtree.MTree;
+import moa.learners.clusterers.outliers.utils.mtree.PartitionFunctions;
+import moa.learners.clusterers.outliers.utils.mtree.PromotionFunction;
+import moa.learners.clusterers.outliers.utils.mtree.utils.Pair;
+import moa.learners.clusterers.outliers.utils.mtree.utils.Utils;
+
+class MTreeMicroClusters extends MTree<MicroCluster> {
+
+	private static final PromotionFunction<MicroCluster> nonRandomPromotion = new PromotionFunction<MicroCluster>() {
+
+		@Override
+		public Pair<MicroCluster> process(Set<MicroCluster> dataSet,
+				DistanceFunction<? super MicroCluster> distanceFunction) {
+			return Utils.minMax(dataSet);
+		}
+	};
+
+	MTreeMicroClusters() {
+		super(2, DistanceFunctions.EUCLIDEAN, new ComposedSplitFunction<>(nonRandomPromotion,
+				new PartitionFunctions.BalancedPartition<MicroCluster>()));
+	}
+
+	@Override
+	public void add(MicroCluster data) {
+		super.add(data);
+		_check();
+	}
+
+	@Override
+	public boolean remove(MicroCluster data) {
+		boolean result = super.remove(data);
+		_check();
+		return result;
+	}
+
+	DistanceFunction<? super MicroCluster> getDistanceFunction() {
+		return distanceFunction;
+	}
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/MCOD/MTreeStreamObjects.java b/moa/src/main/java/moa/learners/clusterers/outliers/MCOD/MTreeStreamObjects.java
new file mode 100644
index 000000000..c719d5444
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/MCOD/MTreeStreamObjects.java
@@ -0,0 +1,65 @@
+/*
+ *    MTreeStreamObjects.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers.MCOD;
+
+import java.util.Set;
+
+import moa.learners.clusterers.outliers.utils.mtree.ComposedSplitFunction;
+import moa.learners.clusterers.outliers.utils.mtree.DistanceFunction;
+import moa.learners.clusterers.outliers.utils.mtree.DistanceFunctions;
+import moa.learners.clusterers.outliers.utils.mtree.MTree;
+import moa.learners.clusterers.outliers.utils.mtree.PartitionFunctions;
+import moa.learners.clusterers.outliers.utils.mtree.PromotionFunction;
+import moa.learners.clusterers.outliers.utils.mtree.utils.Pair;
+import moa.learners.clusterers.outliers.utils.mtree.utils.Utils;
+
+class MTreeStreamObjects extends MTree<StreamObj> {
+
+	private static final PromotionFunction<StreamObj> nonRandomPromotion = new PromotionFunction<StreamObj>() {
+
+		@Override
+		public Pair<StreamObj> process(Set<StreamObj> dataSet, DistanceFunction<? super StreamObj> distanceFunction) {
+			return Utils.minMax(dataSet);
+		}
+	};
+
+	MTreeStreamObjects() {
+		super(2, DistanceFunctions.EUCLIDEAN, new ComposedSplitFunction<>(nonRandomPromotion,
+				new PartitionFunctions.BalancedPartition<StreamObj>()));
+	}
+
+	@Override
+	public void add(StreamObj data) {
+		super.add(data);
+		_check();
+	}
+
+	@Override
+	public boolean remove(StreamObj data) {
+		boolean result = super.remove(data);
+		_check();
+		return result;
+	}
+
+	DistanceFunction<? super StreamObj> getDistanceFunction() {
+		return distanceFunction;
+	}
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/MCOD/MicroCluster.java b/moa/src/main/java/moa/learners/clusterers/outliers/MCOD/MicroCluster.java
new file mode 100644
index 000000000..828e3217b
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/MCOD/MicroCluster.java
@@ -0,0 +1,104 @@
+/*
+ *    MicroCluster.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers.MCOD;
+
+import java.util.ArrayList;
+
+import moa.learners.clusterers.outliers.MCOD.ISBIndex.ISBNode;
+import moa.learners.clusterers.outliers.utils.mtree.DistanceFunctions.EuclideanCoordinate;
+
+public class MicroCluster implements EuclideanCoordinate, Comparable<MicroCluster> {
+	public ISBNode mcc;
+	public ArrayList<ISBNode> nodes;
+
+	public MicroCluster(ISBNode mcc) {
+		this.mcc = mcc;
+		nodes = new ArrayList<>();
+		AddNode(mcc);
+	}
+
+	public void AddNode(ISBNode node) {
+		if (node != null)
+			nodes.add(node);
+	}
+
+	public void RemoveNode(ISBNode node) {
+		if (node != null)
+			nodes.remove(node);
+	}
+
+	public int GetNodesCount() {
+		return nodes.size();
+	}
+
+	@Override
+	public int dimensions() {
+		return mcc.obj.dimensions();
+	}
+
+	@Override
+	public double get(int index) {
+		return mcc.obj.get(index);
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (obj instanceof MicroCluster) {
+			MicroCluster that = (MicroCluster) obj;
+			if (this.dimensions() != that.dimensions()) {
+				return false;
+			}
+			for (int i = 0; i < this.dimensions(); i++) {
+				if (this.mcc.obj.get(i) != that.mcc.obj.get(i)) {
+					return false;
+				}
+			}
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	@Override
+	public int compareTo(MicroCluster that) {
+		int dimensions = Math.min(this.dimensions(), that.dimensions());
+		for (int i = 0; i < dimensions; i++) {
+			double v1 = this.mcc.obj.get(i);
+			double v2 = that.mcc.obj.get(i);
+			if (v1 > v2) {
+				return +1;
+			}
+			if (v1 < v2) {
+				return -1;
+			}
+		}
+
+		if (this.dimensions() > dimensions) {
+			return +1;
+		}
+
+		if (that.dimensions() > dimensions) {
+			return -1;
+		}
+
+		return 0;
+	}
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/MCOD/StreamObj.java b/moa/src/main/java/moa/learners/clusterers/outliers/MCOD/StreamObj.java
new file mode 100644
index 000000000..3f7bd5199
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/MCOD/StreamObj.java
@@ -0,0 +1,96 @@
+/*
+ *    StreamObj.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers.MCOD;
+
+import moa.learners.clusterers.outliers.utils.mtree.DistanceFunctions.EuclideanCoordinate;
+
+public class StreamObj implements EuclideanCoordinate, Comparable<StreamObj> {
+	private final double[] values;
+	private final int hashCode;
+
+	public StreamObj(double... values) {
+		this.values = values;
+
+		int h = 1;
+		for (double value : values) {
+			h = 31 * h + (int) value;
+		}
+		this.hashCode = h;
+	}
+
+	@Override
+	public int dimensions() {
+		return values.length;
+	}
+
+	@Override
+	public double get(int index) {
+		return values[index];
+	}
+
+	@Override
+	public int hashCode() {
+		return hashCode;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (obj instanceof StreamObj) {
+			StreamObj that = (StreamObj) obj;
+			if (this.dimensions() != that.dimensions()) {
+				return false;
+			}
+			for (int i = 0; i < this.dimensions(); i++) {
+				if (this.values[i] != that.values[i]) {
+					return false;
+				}
+			}
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	@Override
+	public int compareTo(StreamObj that) {
+		int dimensions = Math.min(this.dimensions(), that.dimensions());
+		for (int i = 0; i < dimensions; i++) {
+			double v1 = this.values[i];
+			double v2 = that.values[i];
+			if (v1 > v2) {
+				return +1;
+			}
+			if (v1 < v2) {
+				return -1;
+			}
+		}
+
+		if (this.dimensions() > dimensions) {
+			return +1;
+		}
+
+		if (that.dimensions() > dimensions) {
+			return -1;
+		}
+
+		return 0;
+	}
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/MCOD/Test.java b/moa/src/main/java/moa/learners/clusterers/outliers/MCOD/Test.java
new file mode 100644
index 000000000..42fc50416
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/MCOD/Test.java
@@ -0,0 +1,64 @@
+/*
+ *    Test.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers.MCOD;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.streams.clustering.RandomRBFGeneratorEvents;
+
+public class Test {
+	public static void main(String[] args) throws Exception {
+		// if (true) return;
+
+		int numInstances = 50000;
+		// moa.streams.ArffFileStream stream = new
+		// ArffFileStream("./datasets/debug_2.txt", -1);
+		RandomRBFGeneratorEvents stream = new RandomRBFGeneratorEvents();
+		stream.prepareForUse();
+
+		MCOD myOutlierDetector = new MCOD();
+		/*
+		 * myOutlierDetector.kOption.setValue(3);
+		 * myOutlierDetector.radiusOption.setValue(5);
+		 * myOutlierDetector.windowSizeOption.setValue(6);
+		 */
+		myOutlierDetector.setModelContext(stream.getHeader());
+		myOutlierDetector.prepareForUse();
+
+		Long tmStart = System.currentTimeMillis();
+
+		int numberSamples = 0;
+		int w = myOutlierDetector.windowSizeOption.getValue();
+		while (stream.hasMoreInstances() && (numberSamples < numInstances)) {
+			Instance newInst = stream.nextInstance().getData();
+			myOutlierDetector.processNewInstanceImpl(newInst);
+			numberSamples++;
+			if (numberSamples % 100 == 0) {
+				// System.out.println("Processed " + numberSamples + " stream objects.");
+			}
+			if ((numberSamples % (w / 2)) == 0) {
+				// myOutlierDetector.PrintOutliers();
+			}
+		}
+		// myOutlierDetector.PrintOutliers();
+		System.out.println("Total time = " + (System.currentTimeMillis() - tmStart) + " ms");
+	}
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/MyBaseOutlierDetector.java b/moa/src/main/java/moa/learners/clusterers/outliers/MyBaseOutlierDetector.java
new file mode 100644
index 000000000..6848881b0
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/MyBaseOutlierDetector.java
@@ -0,0 +1,457 @@
+/*
+ *    MyBaseOutlierDetector.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.PrintStream;
+import java.util.Random;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.Vector;
+
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.cluster.Cluster;
+import moa.cluster.Clustering;
+import moa.cluster.SphereCluster;
+import moa.core.Measurement;
+import moa.learners.clusterers.AbstractClusterer;
+
+public abstract class MyBaseOutlierDetector extends AbstractClusterer {
+	public static class Outlier implements Comparable<Outlier> {
+		public long id;
+		public Instance inst;
+		public Object obj;
+
+		public Outlier(Instance inst, long id, Object obj) {
+			this.id = id;
+			this.inst = inst;
+			this.obj = obj;
+		}
+
+		@Override
+		public int compareTo(Outlier o) {
+			if (this.id > o.id)
+				return 1;
+			else if (this.id < o.id)
+				return -1;
+			else
+				return 0;
+		}
+
+		@Override
+		public boolean equals(Object o) {
+			return (this.id == ((Outlier) o).id);
+		}
+	}
+
+	public static abstract class OutlierNotifier {
+		public void OnOutlier(Outlier outlier) {
+			throw new UnsupportedOperationException("Not yet implemented");
+		}
+
+		public void OnInlier(Outlier outlier) {
+			throw new UnsupportedOperationException("Not yet implemented");
+		}
+	}
+
+	public IntOption windowSizeOption = new IntOption("windowSize", 'w', "Size of the window.", 1000);
+
+	public OutlierNotifier outlierNotifier = null;
+
+	protected Random random;
+	protected int iMaxMemUsage = 0;
+	protected int nRangeQueriesExecuted = 0;
+	protected Long nTotalRunTime = 0L;
+	protected double nTimePerObj;
+
+	private Clustering myClusters = null;
+	private TreeSet<Outlier> outliersFound;
+	private Long m_timePreObjSum;
+	private int nProcessed;
+	private static final int m_timePreObjInterval = 100;
+
+	protected void UpdateMaxMemUsage() {
+		int x = GetMemoryUsage();
+		if (iMaxMemUsage < x)
+			iMaxMemUsage = x;
+	}
+
+	public double getTimePerObj() {
+		return nTimePerObj;
+	}
+
+	public String getObjectInfo(Object obj) {
+		throw new UnsupportedOperationException("Not yet implemented");
+	}
+
+	public String getStatistics() {
+		throw new UnsupportedOperationException("Not yet implemented");
+	}
+
+	public double[] getInstanceValues(Instance inst) {
+		int length = inst.numValues() - 1;
+		double[] values = new double[length]; // last attribute is the class
+		for (int i = 0; i < length; i++) {
+			values[i] = inst.value(i);
+		}
+		return values;
+	}
+
+	public void PrintInstance(Instance inst) {
+		Print("instance: [ ");
+		for (int i = 0; i < inst.numValues() - 1; i++) { // -1 last value is the class
+			Printf("%.2f ", inst.value(i));
+		}
+		Print("] ");
+		Println("");
+	}
+
+	@Override
+	public void resetLearningImpl() {
+		Init();
+	}
+
+	protected void Init() {
+		random = new Random(System.currentTimeMillis());
+		outliersFound = new TreeSet<>();
+
+		m_timePreObjSum = 0L;
+		nProcessed = 0;
+		nTimePerObj = 0L;
+
+		StdPrintMsg printer = new StdPrintMsg();
+		printer.RedirectToDisplay();
+
+		// timePerObjInfo = new MyTimePerObjInfo();
+		// timePerObjInfo.Init();
+
+		SetUserInfo(true, false, printer, 1000);
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		processNewInstanceImpl(inst);
+	}
+
+	public void processNewInstanceImpl(Instance inst) {
+		Long nsNow = System.nanoTime();
+
+		ProcessNewStreamObj(inst);
+
+		UpdateMaxMemUsage();
+		nTotalRunTime += (System.nanoTime() - nsNow) / (1024 * 1024);
+
+		// update process time per object
+		nProcessed++;
+		m_timePreObjSum += System.nanoTime() - nsNow;
+		if (nProcessed % m_timePreObjInterval == 0) {
+			nTimePerObj = ((double) m_timePreObjSum) / ((double) m_timePreObjInterval);
+			if (bShowProgress)
+				ShowTimePerObj();
+			// init
+			m_timePreObjSum = 0L;
+		}
+	}
+
+	private void ShowTimePerObj() {
+		double ms = nTimePerObj / (1000.0 * 1000.0);
+		Println("Process time per object (ms): " + String.format("%.3f", ms));
+	}
+
+	protected void ProcessNewStreamObj(Instance inst) {
+		throw new UnsupportedOperationException("Not yet implemented");
+	}
+
+	public void PrintOutliers() {
+		Print("Outliers: ");
+		for (Outlier o : outliersFound) {
+			Printf("[%d] ", o.id);
+		}
+		Println("");
+	}
+
+	public Set<Outlier> GetOutliersFound() {
+		return outliersFound;
+	}
+
+	protected boolean IsNodeIdInWin(long id) {
+		throw new UnsupportedOperationException("Not yet implemented");
+	}
+
+	@Override
+	public Clustering getClusteringResult() {
+		myClusters = new Clustering();
+		for (Outlier o : outliersFound) {
+			if (IsNodeIdInWin(o.id)) {
+				double[] center = new double[o.inst.numValues() - 1];
+				for (int i = 0; i < o.inst.numValues() - 1; i++) {
+					center[i] = o.inst.value(i);
+				}
+				Cluster c = new SphereCluster(center, 0);
+				myClusters.add(c);
+			}
+		}
+		return myClusters;
+	}
+
+	public Vector<Outlier> getOutliersResult() {
+		Vector<Outlier> outliers = new Vector<>();
+		for (Outlier o : outliersFound) {
+			if (IsNodeIdInWin(o.id)) {
+				outliers.add(o);
+			}
+		}
+		return outliers;
+	}
+
+	protected void AddOutlier(Outlier newOutlier) {
+		boolean bNewAdd = outliersFound.add(newOutlier);
+		if ((outlierNotifier != null) && bNewAdd) {
+			outlierNotifier.OnOutlier(newOutlier);
+		}
+	}
+
+	protected boolean RemoveExpiredOutlier(Outlier outlier) {
+		boolean bFound = outliersFound.remove(outlier);
+		return bFound;
+	}
+
+	protected boolean RemoveOutlier(Outlier outlier) {
+		boolean bFound = outliersFound.remove(outlier);
+		if ((outlierNotifier != null) && bFound) {
+			outlierNotifier.OnInlier(outlier);
+		}
+		return bFound;
+	}
+
+	@Override
+	public boolean implementsMicroClusterer() {
+		return false;
+	}
+
+	@Override
+	public Clustering getMicroClusteringResult() {
+		return null;
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+
+	@Override
+	public boolean keepClassLabel() {
+		return true;
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		return null;
+	}
+
+	// show progress through object
+	protected ProgressInfo myProgressInfo;
+	protected PrintMsg myOut;
+	protected boolean bTrace = false;
+	protected boolean bShowProgress = false;
+	public boolean bStopAlgorithm = false;
+	// time measurement for progress
+	private Long _msPrev = 0L, _msNow = 0L;
+
+	public void SetShowProgress(boolean b) {
+		bShowProgress = b;
+	}
+
+	public void SetTrace(boolean b) {
+		bTrace = b;
+	}
+
+	public void SetProgressInterval(int iProgressInterval) {
+		myProgressInfo = new MyProgressInfo(iProgressInterval);
+	}
+
+	public void SetMessagePrinter(PrintMsg logPrinter) {
+		myOut = logPrinter;
+	}
+
+	public void SetUserInfo(boolean bShowProgress, boolean bTrace, PrintMsg logPrinter, int iProgressInterval) {
+		this.bShowProgress = bShowProgress;
+		this.bTrace = bTrace;
+
+		myProgressInfo = new MyProgressInfo(iProgressInterval);
+		myOut = logPrinter;
+	}
+
+	public interface PrintMsg {
+		void print(String s);
+
+		void println(String s);
+
+		void printf(String fmt, Object... args);
+	}
+
+	public interface ProgressInfo {
+		int GetInterval();
+
+		void ShowProgress(String sMsg);
+	}
+
+	public class StdPrintMsg implements PrintMsg {
+		private PrintStream printStream, fileStream;
+
+		public StdPrintMsg() {
+			RedirectToDisplay();
+		}
+
+		public StdPrintMsg(String sFilename) {
+			RedirectToFile(sFilename);
+		}
+
+		public void RedirectToDisplay() {
+			printStream = System.out;
+		}
+
+		public void RedirectToFile(String sFilename) {
+			File file = new File(sFilename);
+			try {
+				fileStream = new PrintStream(new FileOutputStream(file));
+				printStream = fileStream;
+			} catch (Exception ex) {
+			}
+		}
+
+		public void RedirectToFile() {
+			printStream = fileStream;
+		}
+
+		@Override
+		public void println(String s) {
+			printStream.println(s);
+		}
+
+		@Override
+		public void print(String s) {
+			printStream.print(s);
+		}
+
+		@Override
+		public void printf(String fmt, Object... args) {
+			printStream.printf(fmt, args);
+		}
+	}
+
+	class MyProgressInfo implements ProgressInfo {
+		int progressInterval;
+
+		public MyProgressInfo(int interval) {
+			progressInterval = interval;
+		}
+
+		public void setProgressInterval(int progressInterval) {
+			this.progressInterval = progressInterval;
+		}
+
+		@Override
+		public int GetInterval() {
+			return progressInterval;
+		}
+
+		@Override
+		public void ShowProgress(String sMsg) {
+			myOut.println(sMsg);
+		}
+	}
+
+	protected void ShowProgress(String sMsg) {
+		ShowProgress(sMsg, false);
+	}
+
+	protected void ShowProgress(String sMsg, boolean bShowAlways) {
+		if (bShowAlways || (_msNow - _msPrev >= myProgressInfo.GetInterval())) {
+			// call user progress function
+			myProgressInfo.ShowProgress(sMsg);
+
+			_msNow = System.currentTimeMillis();
+			_msPrev = _msNow;
+		} else {
+			_msNow = System.currentTimeMillis();
+		}
+	}
+
+	/*
+	 * public class MyTimePerObjInfo { Long nPrevObj, nsPrevObj; Long _msTimerPrev =
+	 * 0L, _msTimerNow = 0L;
+	 * 
+	 * public MyTimePerObjInfo() { Init(); }
+	 * 
+	 * public void Init() { nPrevObj = 0L; nsPrevObj = 0L; }
+	 * 
+	 * private void _ShowTimePerObj(Long nObj) { Double timePerObj = 0.0; Long nsNow
+	 * = System.nanoTime(); Long d = nObj - nPrevObj + 1; if ((d > 0) && (nsPrevObj
+	 * > 0)) { timePerObj = (double)(nsNow - nsPrevObj) / (double)d; } nsPrevObj =
+	 * nsNow; nPrevObj = nObj;
+	 * 
+	 * // call user progress function
+	 * myProgressInfo.ShowProgress("Processing time per object (ms): " +
+	 * String.format("%.3f", timePerObj / (1000.0 * 1000.0))); }
+	 * 
+	 * public void ShowTimePerObj(Long nObj, boolean bShowAlways) { if (bShowAlways
+	 * || (_msTimerNow - _msTimerPrev >= myProgressInfo.GetInterval())) {
+	 * _ShowTimePerObj(nObj); _msTimerNow = System.currentTimeMillis(); _msTimerPrev
+	 * = _msTimerNow; } else { _msTimerNow = System.currentTimeMillis(); } }
+	 * 
+	 * public void ShowTimePerObj(Long nObj) { ShowTimePerObj(nObj, false); } }
+	 */
+
+	protected void Println(String s) {
+		if (myOut != null)
+			myOut.println(s);
+	}
+
+	protected void Print(String s) {
+		if (myOut != null)
+			myOut.print(s);
+	}
+
+	protected void Printf(String fmt, Object... args) {
+		if (myOut != null)
+			myOut.printf(fmt, args);
+	}
+
+	protected int GetMemoryUsage() {
+		int iMemory = (int) ((Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()) / (1024 * 1024));
+		return iMemory;
+	}
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/SimpleCOD/ISBIndex.java b/moa/src/main/java/moa/learners/clusterers/outliers/SimpleCOD/ISBIndex.java
new file mode 100644
index 000000000..57ce3b636
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/SimpleCOD/ISBIndex.java
@@ -0,0 +1,259 @@
+/*
+ *    ISBIndex.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers.SimpleCOD;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Vector;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+public class ISBIndex {
+	public static class ISBNode implements Comparable<ISBNode> {
+		public Instance inst;
+		public StreamObj obj;
+		public Long id;
+		public boolean bOutlier;
+		public int count_after;
+		private ArrayList<ISBNode> nn_before;
+
+		// statistics
+		public int nOutlier;
+		public int nInlier;
+
+		public ISBNode(Instance inst, StreamObj obj, Long id) {
+			this.inst = inst;
+			this.obj = obj;
+			this.id = id;
+
+			this.bOutlier = false;
+			this.count_after = 1;
+			this.nn_before = new ArrayList<>();
+
+			// init statistics
+			nOutlier = 0;
+			nInlier = 0;
+		}
+
+		@Override
+		public int compareTo(ISBNode t) {
+			if (this.id > t.id)
+				return +1;
+			else if (this.id < t.id)
+				return -1;
+			return 0;
+		}
+
+		public void AddPrecNeigh(ISBNode node) {
+			int pos = Collections.binarySearch(nn_before, node);
+			if (pos < 0) {
+				// item does not exist, so add it to the right position
+				nn_before.add(-(pos + 1), node);
+			}
+		}
+
+		public void RemovePrecNeigh(ISBNode node) {
+			int pos = Collections.binarySearch(nn_before, node);
+			if (pos >= 0) {
+				// item exists
+				nn_before.remove(pos);
+			}
+		}
+
+		public ISBNode GetMinPrecNeigh(Long sinceId) {
+			if (nn_before.size() > 0) {
+				int startPos;
+				ISBNode dummy = new ISBNode(null, null, sinceId);
+
+				int pos = Collections.binarySearch(nn_before, dummy);
+				if (pos < 0) {
+					// item does not exist, should insert at position startPos
+					startPos = -(pos + 1);
+				} else {
+					// item exists at startPos
+					startPos = pos;
+				}
+
+				if (startPos < nn_before.size()) {
+					return nn_before.get(startPos);
+				}
+			}
+			return null;
+		}
+
+		public int CountPrecNeighs(Long sinceId) {
+			if (nn_before.size() > 0) {
+				// get number of neighs with id >= sinceId
+				int startPos;
+				ISBNode dummy = new ISBNode(null, null, sinceId);
+				int pos = Collections.binarySearch(nn_before, dummy);
+				if (pos < 0) {
+					// item does not exist, should insert at position startPos
+					startPos = -(pos + 1);
+				} else {
+					// item exists at startPos
+					startPos = pos;
+				}
+
+				if (startPos < nn_before.size()) {
+					return nn_before.size() - startPos;
+				}
+			}
+			return 0;
+		}
+
+		public List<ISBNode> Get_nn_before() {
+			return nn_before;
+		}
+	}
+
+	MyMTree mtree;
+	Map<Integer, Set<ISBNode>> mapNodes;
+	double m_radius;
+	int m_k; // k nearest neighbors
+
+	public ISBIndex(double radius, int k) {
+		mtree = new MyMTree();
+		mapNodes = new HashMap<>();
+		m_radius = radius;
+		m_k = k;
+	}
+
+	Vector<ISBNode> GetAllNodes() {
+		Vector<ISBNode> v = new Vector<>();
+		Iterator it = mapNodes.entrySet().iterator();
+		while (it.hasNext()) {
+			Map.Entry pairs = (Map.Entry) it.next();
+			Set<ISBNode> setNodes = (Set<ISBNode>) pairs.getValue();
+			for (ISBNode n : setNodes) {
+				v.add(n);
+			}
+		}
+		return v;
+	}
+
+	public static class ISBSearchResult {
+		public ISBNode node;
+		public double distance;
+
+		public ISBSearchResult(ISBNode n, double distance) {
+			this.node = n;
+			this.distance = distance;
+		}
+	}
+
+	public Vector<ISBSearchResult> RangeSearch(ISBNode node, double radius) {
+		Vector<ISBSearchResult> results = new Vector<>();
+		StreamObj obj;
+		double d;
+		MyMTree.Query query = mtree.getNearestByRange(node.obj, radius);
+		for (MyMTree.ResultItem q : query) {
+			// get next obj found within range
+			obj = q.data;
+			// get distance of obj from query
+			d = q.distance;
+			// get all nodes referencing obj
+			Vector<ISBNode> nodes = MapGetNodes(obj);
+			for (int i = 0; i < nodes.size(); i++)
+				results.add(new ISBSearchResult(nodes.get(i), d));
+		}
+		return results;
+	}
+
+	public void Insert(ISBNode node) {
+		// insert object of node at mtree
+		mtree.add(node.obj);
+		// insert node at map
+		MapInsert(node);
+	}
+
+	public void Remove(ISBNode node) {
+		// remove from map
+		MapDelete(node);
+		// check if stream object at mtree is still being referenced
+		if (MapCountObjRefs(node.obj) <= 0) {
+			// delete stream object from mtree
+			mtree.remove(node.obj);
+		}
+	}
+
+	Vector<ISBNode> MapGetNodes(StreamObj obj) {
+		int h = obj.hashCode();
+		Vector<ISBNode> v = new Vector<>();
+		if (mapNodes.containsKey(h)) {
+			Set<ISBNode> s = mapNodes.get(h);
+			ISBNode node;
+			Iterator<ISBNode> i = s.iterator();
+			while (i.hasNext()) {
+				node = i.next();
+				if (node.obj.equals(obj))
+					v.add(node);
+			}
+		}
+		return v;
+	}
+
+	int MapCountObjRefs(StreamObj obj) {
+		int h = obj.hashCode();
+		int iCount = 0;
+		if (mapNodes.containsKey(h)) {
+			Set<ISBNode> s = mapNodes.get(h);
+			ISBNode n;
+			Iterator<ISBNode> i = s.iterator();
+			while (i.hasNext()) {
+				n = i.next();
+				if (n.obj.equals(obj))
+					iCount++;
+			}
+		}
+		return iCount;
+	}
+
+	void MapInsert(ISBNode node) {
+		int h = node.obj.hashCode();
+		Set<ISBNode> s;
+		if (mapNodes.containsKey(h)) {
+			s = mapNodes.get(h);
+			s.add(node);
+		} else {
+			s = new HashSet<>();
+			s.add(node);
+			mapNodes.put(h, s);
+		}
+	}
+
+	void MapDelete(ISBNode node) {
+		int h = node.obj.hashCode();
+		if (mapNodes.containsKey(h)) {
+			Set<ISBNode> s = mapNodes.get(h);
+			s.remove(node);
+			if (s.isEmpty()) { // ### added
+				mapNodes.remove(h);
+			}
+		}
+	}
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/SimpleCOD/MyMTree.java b/moa/src/main/java/moa/learners/clusterers/outliers/SimpleCOD/MyMTree.java
new file mode 100644
index 000000000..0cc8a2190
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/SimpleCOD/MyMTree.java
@@ -0,0 +1,65 @@
+/*
+ *    MyMTree.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers.SimpleCOD;
+
+import java.util.Set;
+
+import moa.learners.clusterers.outliers.utils.mtree.ComposedSplitFunction;
+import moa.learners.clusterers.outliers.utils.mtree.DistanceFunction;
+import moa.learners.clusterers.outliers.utils.mtree.DistanceFunctions;
+import moa.learners.clusterers.outliers.utils.mtree.MTree;
+import moa.learners.clusterers.outliers.utils.mtree.PartitionFunctions;
+import moa.learners.clusterers.outliers.utils.mtree.PromotionFunction;
+import moa.learners.clusterers.outliers.utils.mtree.utils.Pair;
+import moa.learners.clusterers.outliers.utils.mtree.utils.Utils;
+
+class MyMTree extends MTree<StreamObj> {
+
+	private static final PromotionFunction<StreamObj> nonRandomPromotion = new PromotionFunction<StreamObj>() {
+
+		@Override
+		public Pair<StreamObj> process(Set<StreamObj> dataSet, DistanceFunction<? super StreamObj> distanceFunction) {
+			return Utils.minMax(dataSet);
+		}
+	};
+
+	MyMTree() {
+		super(2, DistanceFunctions.EUCLIDEAN, new ComposedSplitFunction<>(nonRandomPromotion,
+				new PartitionFunctions.BalancedPartition<StreamObj>()));
+	}
+
+	@Override
+	public void add(StreamObj data) {
+		super.add(data);
+		_check();
+	}
+
+	@Override
+	public boolean remove(StreamObj data) {
+		boolean result = super.remove(data);
+		_check();
+		return result;
+	}
+
+	DistanceFunction<? super StreamObj> getDistanceFunction() {
+		return distanceFunction;
+	}
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/SimpleCOD/SimpleCOD.java b/moa/src/main/java/moa/learners/clusterers/outliers/SimpleCOD/SimpleCOD.java
new file mode 100644
index 000000000..f574c3074
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/SimpleCOD/SimpleCOD.java
@@ -0,0 +1,229 @@
+/*
+ *    SimpleCOD.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers.SimpleCOD;
+
+import java.util.Vector;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.learners.clusterers.outliers.SimpleCOD.ISBIndex.ISBNode;
+import moa.learners.clusterers.outliers.SimpleCOD.ISBIndex.ISBSearchResult;
+
+////The algorithm is described in
+// M. Kontaki, A. Gounaris, A. N. Papadopoulos, K. Tsichlas, and Y. Manolopoulos.
+//Continuous monitoring of distance-based outliers over data streams.
+//In ICDE, pages 135–146, 2011.
+
+public class SimpleCOD extends SimpleCODBase {
+	public FloatOption radiusOption = new FloatOption("radius", 'r', "Search radius.", 0.1);
+	public IntOption kOption = new IntOption("k", 't', "Parameter k.", 50);
+
+	public SimpleCOD() {
+		// System.out.println("SimpleCOD: created");
+	}
+
+	@Override
+	public void Init() {
+		super.Init();
+
+		m_WindowSize = windowSizeOption.getValue();
+		m_radius = radiusOption.getValue();
+		m_k = kOption.getValue();
+
+		Println("Init SimpleCOD:");
+		Println("   window_size: " + m_WindowSize);
+		Println("   radius: " + m_radius);
+		Println("   k: " + m_k);
+
+		// bTrace = true;
+		// bWarning = true;
+
+		objId = FIRST_OBJ_ID; // init object identifier
+		// create nodes list of window
+		windowNodes = new Vector<>();
+		// create ISB
+		ISB = new ISBIndex(m_radius, m_k);
+		// create event queue
+		eventQueue = new EventQueue();
+
+		// init statistics
+		m_nBothInlierOutlier = 0;
+		m_nOnlyInlier = 0;
+		m_nOnlyOutlier = 0;
+	}
+
+	void ProcessNewNode(ISBNode nodeNew, boolean bNewNode) {
+		if (bTrace) {
+			Print("ProcessNewNode: ");
+			PrintNode(nodeNew);
+		}
+
+		if (bTrace)
+			Println("Perform R range query");
+		nRangeQueriesExecuted++;
+		Vector<ISBSearchResult> resultNodes;
+		resultNodes = ISB.RangeSearch(nodeNew, m_radius);
+		for (ISBSearchResult sr : resultNodes) {
+			double distance = sr.distance;
+			ISBNode q = sr.node;
+			if ((nodeNew != q) && (distance <= m_radius)) {
+				if (bTrace)
+					Println("nodeNew has neighbor q.id " + q.id);
+				nodeNew.AddPrecNeigh(q);
+				q.count_after++;
+
+				if (q.bOutlier) {
+					int count = q.CountPrecNeighs(GetWindowStart()) + q.count_after;
+					if (count >= m_k) {
+						if (bTrace)
+							Println("q.id " + q.id + " is now an inlier");
+						q.bOutlier = false;
+						RemoveOutlier(q);
+						// insert q to event queue
+						ISBNode nodeMinExp = q.GetMinPrecNeigh(GetWindowStart());
+						AddToEventQueue(q, nodeMinExp);
+					}
+				}
+			}
+		}
+
+		if (bTrace)
+			Println("Check if nodeNew is an inlier or outlier");
+		int count = nodeNew.CountPrecNeighs(GetWindowStart()) + nodeNew.count_after;
+		if (count >= m_k) {
+			if (bTrace)
+				Println("nodeNew is an inlier");
+			nodeNew.bOutlier = false;
+			RemoveOutlier(nodeNew); // updates statistics
+			// insert nodeNew to event queue
+			ISBNode nodeMinExp = nodeNew.GetMinPrecNeigh(GetWindowStart());
+			AddToEventQueue(nodeNew, nodeMinExp);
+		} else {
+			if (bTrace)
+				Println("nodeNew is an outlier");
+			nodeNew.bOutlier = true;
+			SaveOutlier(nodeNew);
+		}
+	}
+
+	void AddToEventQueue(ISBNode x, ISBNode nodeMinExp) {
+		if (bTrace)
+			Println("AddToEventQueue x.id: " + x.id);
+		if (nodeMinExp != null) {
+			Long expTime = GetExpirationTime(nodeMinExp);
+			eventQueue.Insert(x, expTime);
+			if (bTrace) {
+				Print("x.nn_before: ");
+				PrintNodeList(x.Get_nn_before());
+				Println("nodeMinExp: " + nodeMinExp.id + ", expTime = " + expTime);
+				PrintEventQueue();
+			}
+		} else {
+			if (bWarning)
+				Println("AddToEventQueue: Cannot add x.id: " + x.id
+						+ " to event queue (nn_before is empty, count_after=" + x.count_after + ")");
+		}
+	}
+
+	void ProcessEventQueue(ISBNode nodeExpired) {
+		EventItem e = eventQueue.FindMin();
+		while ((e != null) && (e.timeStamp <= GetWindowEnd())) {
+			e = eventQueue.ExtractMin();
+			ISBNode x = e.node;
+			if (bTrace)
+				Println("Process event queue: check node x: " + x.id);
+			// node x must be in window
+			if (IsNodeIdInWin(x.id)) {
+				// remove nodeExpired from x.nn_before
+				x.RemovePrecNeigh(nodeExpired);
+				// get amount of neighbors of x
+				int count = x.count_after + x.CountPrecNeighs(GetWindowStart());
+				if (count < m_k) {
+					if (bTrace)
+						Println("x is an outlier");
+					x.bOutlier = true;
+					SaveOutlier(x);
+				} else {
+					if (bTrace)
+						Println("x is an inlier, add to event queue");
+					x.bOutlier = false;
+					// get oldest preceding neighbor of x
+					ISBNode nodeMinExp = x.GetMinPrecNeigh(GetWindowStart());
+					// add x to event queue
+					AddToEventQueue(x, nodeMinExp);
+				}
+			} else {
+				if (bWarning)
+					Println("Process event queue: node x.id: " + x.id + " has expired!");
+			}
+			e = eventQueue.FindMin();
+		}
+	}
+
+	void ProcessExpiredNode(ISBNode nodeExpired) {
+		if (nodeExpired != null) {
+			if (bTrace)
+				Println("\nnodeExpired: " + nodeExpired.id);
+			ISB.Remove(nodeExpired); // remove nodeExpired from index
+			RemoveNode(nodeExpired);
+			ProcessEventQueue(nodeExpired);
+		}
+	}
+
+	@Override
+	protected void ProcessNewStreamObj(Instance inst) {
+		if (bShowProgress)
+			ShowProgress("Processed " + (objId - 1) + " stream objects.");
+		// PrintInstance(inst);
+
+		double[] values = getInstanceValues(inst);
+		StreamObj obj = new StreamObj(values);
+
+		if (bTrace)
+			Println("\n- - - - - - - - - - - -\n");
+
+		// create new ISB node
+		ISBNode nodeNew = new ISBNode(inst, obj, objId);
+		if (bTrace) {
+			Print("New node: ");
+			PrintNode(nodeNew);
+		}
+
+		objId++; // update object identifier (slide window)
+
+		AddNode(nodeNew); // add nodeNew to window
+		if (bTrace)
+			PrintWindow();
+
+		// insert new node to ISB index
+		ISB.Insert(nodeNew);
+
+		ProcessNewNode(nodeNew, true);
+		ProcessExpiredNode(GetExpiredNode());
+
+		if (bTrace) {
+			PrintOutliers();
+			PrintISB();
+		}
+	}
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/SimpleCOD/SimpleCODBase.java b/moa/src/main/java/moa/learners/clusterers/outliers/SimpleCOD/SimpleCODBase.java
new file mode 100644
index 000000000..39adecb8a
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/SimpleCOD/SimpleCODBase.java
@@ -0,0 +1,321 @@
+/*
+ *    SimpleCODBase.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.clusterers.outliers.SimpleCOD;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.Vector;
+
+import moa.learners.clusterers.outliers.MyBaseOutlierDetector;
+import moa.learners.clusterers.outliers.SimpleCOD.ISBIndex.ISBNode;
+
+public abstract class SimpleCODBase extends MyBaseOutlierDetector {
+	protected static class EventItem implements Comparable<EventItem> {
+		public ISBNode node;
+		public Long timeStamp;
+
+		public EventItem(ISBNode node, Long timeStamp) {
+			this.node = node;
+			this.timeStamp = timeStamp;
+		}
+
+		@Override
+		public int compareTo(EventItem t) {
+			if (this.timeStamp > t.timeStamp) {
+				return +1;
+			} else if (this.timeStamp < t.timeStamp) {
+				return -1;
+			} else {
+				if (this.node.id > t.node.id)
+					return +1;
+				else if (this.node.id < t.node.id)
+					return -1;
+			}
+			return 0;
+		}
+	}
+
+	protected static class EventQueue {
+		public TreeSet<EventItem> setEvents;
+
+		public EventQueue() {
+			setEvents = new TreeSet<>();
+		}
+
+		public void Insert(ISBNode node, Long expTime) {
+			setEvents.add(new EventItem(node, expTime));
+		}
+
+		public EventItem FindMin() {
+			if (setEvents.size() > 0) {
+				// events are sorted ascenting by expiration time
+				return setEvents.first();
+			}
+			return null;
+		}
+
+		public EventItem ExtractMin() {
+			EventItem e = FindMin();
+			if (e != null) {
+				setEvents.remove(e);
+				return e;
+			}
+			return null;
+		}
+	}
+
+	protected static final Long FIRST_OBJ_ID = 1L;
+
+	// object identifier increments with each new data stream object
+	protected Long objId;
+	// list used to find expired nodes
+	protected Vector<ISBNode> windowNodes;
+	protected EventQueue eventQueue;
+	// index of objects
+	protected ISBIndex ISB;
+	protected int m_WindowSize;
+	protected double m_radius;
+	protected int m_k;
+	public boolean bWarning = false;
+
+	// statistics
+	public int m_nBothInlierOutlier;
+	public int m_nOnlyInlier;
+	public int m_nOnlyOutlier;
+
+	@Override
+	public String getObjectInfo(Object obj) {
+		if (obj == null)
+			return null;
+
+		ISBNode node = (ISBNode) obj;
+
+		ArrayList<String> infoTitle = new ArrayList<>();
+		ArrayList<String> infoValue = new ArrayList<>();
+		StringBuilder sb = new StringBuilder();
+
+		// show node position
+		for (int i = 0; i < node.obj.dimensions(); i++) {
+			infoTitle.add("Dim" + (i + 1));
+			infoValue.add(String.format("%.3f", node.obj.get(i)));
+		}
+
+		// show node properties
+		infoTitle.add("id");
+		infoValue.add(String.format("%d", node.id));
+		infoTitle.add("count_after");
+		infoValue.add(String.format("%d", node.count_after));
+		infoTitle.add("|nn_before|");
+		infoValue.add(String.format("%d", node.CountPrecNeighs(GetWindowStart())));
+
+		sb.append("<html>");
+		sb.append("<table>");
+		int i = 0;
+		while (i < infoTitle.size() && i < infoValue.size()) {
+			sb.append("<tr><td><b>" + infoTitle.get(i) + ":</b></td><td>" + infoValue.get(i) + "</td></tr>");
+			i++;
+		}
+		sb.append("</table>");
+
+		sb.append("</html>");
+		return sb.toString();
+	}
+
+	@Override
+	public String getStatistics() {
+		StringBuilder sb = new StringBuilder();
+
+		sb.append("Statistics:\n\n");
+
+		// get counters of expired nodes
+		int nBothInlierOutlier = m_nBothInlierOutlier;
+		int nOnlyInlier = m_nOnlyInlier;
+		int nOnlyOutlier = m_nOnlyOutlier;
+
+		// add counters of non expired nodes
+		for (ISBNode node : windowNodes) {
+			if ((node.nInlier > 0) && (node.nOutlier > 0))
+				nBothInlierOutlier++;
+			else if (node.nInlier > 0)
+				nOnlyInlier++;
+			else
+				nOnlyOutlier++;
+		}
+
+		int sum = nBothInlierOutlier + nOnlyInlier + nOnlyOutlier;
+		if (sum > 0) {
+			sb.append(String.format("  Nodes always inlier: %d (%.1f%%)\n", nOnlyInlier,
+					(100 * nOnlyInlier) / (double) sum));
+			sb.append(String.format("  Nodes always outlier: %d (%.1f%%)\n", nOnlyOutlier,
+					(100 * nOnlyOutlier) / (double) sum));
+			sb.append(String.format("  Nodes both inlier and outlier: %d (%.1f%%)\n", nBothInlierOutlier,
+					(100 * nBothInlierOutlier) / (double) sum));
+
+			sb.append("  (Sum: " + sum + ")\n");
+		}
+
+		sb.append("\n  Total range queries: " + nRangeQueriesExecuted + "\n");
+		sb.append("  Max memory usage: " + iMaxMemUsage + " MB\n");
+		sb.append("  Total process time: " + String.format("%.2f ms", nTotalRunTime / 1000.0) + "\n");
+
+		return sb.toString();
+	}
+
+	Long GetWindowEnd() {
+		return objId - 1;
+	}
+
+	Long GetWindowStart() {
+		Long x = GetWindowEnd() - m_WindowSize + 1;
+		if (x < FIRST_OBJ_ID)
+			x = FIRST_OBJ_ID;
+		return x;
+	}
+
+	boolean IsWinFull() {
+		return (GetWindowEnd() >= FIRST_OBJ_ID + m_WindowSize - 1);
+	}
+
+	Long GetExpirationTime(ISBNode node) {
+		return node.id + m_WindowSize;
+	}
+
+	void SaveOutlier(ISBNode node) {
+		AddOutlier(new Outlier(node.inst, node.id, node));
+		node.nOutlier++; // update statistics
+	}
+
+	void RemoveOutlier(ISBNode node) {
+		RemoveOutlier(new Outlier(node.inst, node.id, node));
+		node.nInlier++; // update statistics
+	}
+
+	@Override
+	protected boolean IsNodeIdInWin(long id) {
+		int toleranceStart = 1;
+		Long start = GetWindowStart() - toleranceStart;
+		if ((start <= id) && (id <= GetWindowEnd()))
+			return true;
+		else
+			return false;
+	}
+
+	void AddNode(ISBNode node) {
+		windowNodes.add(node);
+	}
+
+	void RemoveNode(ISBNode node) {
+		windowNodes.remove(node);
+		RemoveExpiredOutlier(new Outlier(node.inst, node.id, node)); // ### remove when expired?
+		// update statistics
+		UpdateStatistics(node);
+	}
+
+	void UpdateStatistics(ISBNode node) {
+		if ((node.nInlier > 0) && (node.nOutlier > 0))
+			m_nBothInlierOutlier++;
+		else if (node.nInlier > 0)
+			m_nOnlyInlier++;
+		else
+			m_nOnlyOutlier++;
+	}
+
+	ISBNode GetExpiredNode() {
+		if (windowNodes.size() <= 0)
+			return null;
+		// get oldest node
+		ISBNode node = windowNodes.get(0);
+		// check if node has expired
+		if (node.id < GetWindowStart()) {
+			return node;
+		}
+		return null;
+	}
+
+	double GetEuclideanDist(ISBNode n1, ISBNode n2) {
+		double diff;
+		double sum = 0;
+		int d = n1.obj.dimensions();
+		for (int i = 0; i < d; i++) {
+			diff = n1.obj.get(i) - n2.obj.get(i);
+			sum += Math.pow(diff, 2);
+		}
+		return Math.sqrt(sum);
+	}
+
+	void PrintWindow() {
+		Println("Window [" + GetWindowStart() + "-" + GetWindowEnd() + "]: ");
+		ISBNode node;
+		for (int i = 0; i < windowNodes.size(); i++) {
+			node = windowNodes.get(i);
+			Print("   Node: ");
+			PrintNode(node);
+		}
+	}
+
+	void PrintNode(ISBNode n) {
+		Print("id=" + n.id + " (");
+		int dim = n.obj.dimensions();
+		for (int d = 0; d < dim; d++) {
+			Print(Double.toString(n.obj.get(d)));
+			if (d < dim - 1)
+				Print(", ");
+		}
+		Println(")");
+	}
+
+	public void PrintNodeSet(Set<ISBNode> set) {
+		for (ISBNode n : set) {
+			Print(n.id + " ");
+		}
+		Println("");
+	}
+
+	public void PrintNodeVector(Vector<ISBNode> vector) {
+		for (ISBNode n : vector) {
+			Print(n.id + " ");
+		}
+		Println("");
+	}
+
+	public void PrintNodeList(List<ISBNode> list) {
+		for (ISBNode n : list) {
+			Print(n.id + " ");
+		}
+		Println("");
+	}
+
+	public void PrintEventQueue() {
+		Println("event queue: ");
+		for (EventItem n : eventQueue.setEvents) {
+			Printf("  id=%d, exp=%d\n", n.node.id, n.timeStamp);
+		}
+	}
+
+	public void PrintISB() {
+		Print("PD: ");
+		for (ISBNode n : ISB.GetAllNodes()) {
+			Print(n.id + " ");
+		}
+		Println("");
+	}
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/SimpleCOD/StreamObj.java b/moa/src/main/java/moa/learners/clusterers/outliers/SimpleCOD/StreamObj.java
new file mode 100644
index 000000000..245b171ae
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/SimpleCOD/StreamObj.java
@@ -0,0 +1,96 @@
+/*
+ *    StreamObj.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers.SimpleCOD;
+
+import moa.learners.clusterers.outliers.utils.mtree.DistanceFunctions.EuclideanCoordinate;
+
+public class StreamObj implements EuclideanCoordinate, Comparable<StreamObj> {
+	private final double[] values;
+	private final int hashCode;
+
+	public StreamObj(double... values) {
+		this.values = values;
+
+		int h = 1;
+		for (double value : values) {
+			h = 31 * h + (int) value;
+		}
+		this.hashCode = h;
+	}
+
+	@Override
+	public int dimensions() {
+		return values.length;
+	}
+
+	@Override
+	public double get(int index) {
+		return values[index];
+	}
+
+	@Override
+	public int hashCode() {
+		return hashCode;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (obj instanceof StreamObj) {
+			StreamObj that = (StreamObj) obj;
+			if (this.dimensions() != that.dimensions()) {
+				return false;
+			}
+			for (int i = 0; i < this.dimensions(); i++) {
+				if (this.values[i] != that.values[i]) {
+					return false;
+				}
+			}
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	@Override
+	public int compareTo(StreamObj that) {
+		int dimensions = Math.min(this.dimensions(), that.dimensions());
+		for (int i = 0; i < dimensions; i++) {
+			double v1 = this.values[i];
+			double v2 = that.values[i];
+			if (v1 > v2) {
+				return +1;
+			}
+			if (v1 < v2) {
+				return -1;
+			}
+		}
+
+		if (this.dimensions() > dimensions) {
+			return +1;
+		}
+
+		if (that.dimensions() > dimensions) {
+			return -1;
+		}
+
+		return 0;
+	}
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/SimpleCOD/Test.java b/moa/src/main/java/moa/learners/clusterers/outliers/SimpleCOD/Test.java
new file mode 100644
index 000000000..9411d64c9
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/SimpleCOD/Test.java
@@ -0,0 +1,55 @@
+/*
+ *    Test.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers.SimpleCOD;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.streams.ArffFileStream;
+
+public class Test {
+	public static void main(String[] args) throws Exception {
+		// if (true) return;
+
+		int numInstances = 30;
+		moa.streams.ArffFileStream stream = new ArffFileStream("./datasets/debug_1.txt", -1);
+		// RandomRBFGeneratorEvents stream = new RandomRBFGeneratorEvents();
+		stream.prepareForUse();
+
+		SimpleCOD myOutlierDetector = new SimpleCOD();
+		myOutlierDetector.kOption.setValue(3);
+		myOutlierDetector.radiusOption.setValue(5);
+		myOutlierDetector.windowSizeOption.setValue(6);
+		myOutlierDetector.setModelContext(stream.getHeader());
+		myOutlierDetector.prepareForUse();
+
+		Long tmStart = System.currentTimeMillis();
+
+		int numberSamples = 0;
+		int w = myOutlierDetector.windowSizeOption.getValue();
+		while (stream.hasMoreInstances() && (numberSamples < numInstances)) {
+			Instance newInst = stream.nextInstance().getData();
+			myOutlierDetector.processNewInstanceImpl(newInst);
+			numberSamples++;
+		}
+		// myOutlierDetector.PrintOutliers();
+		System.out.println("Total time = " + (System.currentTimeMillis() - tmStart) + " ms");
+	}
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/outliers/TestSpeed.java b/moa/src/main/java/moa/learners/clusterers/outliers/TestSpeed.java
new file mode 100644
index 000000000..275e07fe5
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/TestSpeed.java
@@ -0,0 +1,73 @@
+/*
+ *    TestSpeed.java
+ *    Copyright (C) 2013 Aristotle University of Thessaloniki, Greece
+ *    @author D. Georgiadis, A. Gounaris, A. Papadopoulos, K. Tsichlas, Y. Manolopoulos
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.clusterers.outliers;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.learners.clusterers.outliers.AbstractC.AbstractC;
+import moa.learners.clusterers.outliers.Angiulli.ExactSTORM;
+import moa.learners.clusterers.outliers.MCOD.MCOD;
+import moa.learners.clusterers.outliers.SimpleCOD.SimpleCOD;
+import moa.streams.clustering.RandomRBFGeneratorEvents;
+
+public class TestSpeed {
+	public static void main(String[] args) throws Exception {
+		int numInstances = 2000;
+		RandomRBFGeneratorEvents stream = new RandomRBFGeneratorEvents();
+		stream.prepareForUse();
+
+		SimpleCOD scod = new SimpleCOD();
+		MCOD mcod = new MCOD();
+		ExactSTORM angiulli = new ExactSTORM();
+		// DistanceOutliersAppr angiulli = new DistanceOutliersAppr();
+		AbstractC abstractC = new AbstractC();
+
+		angiulli.queryFreqOption.setValue(1);
+
+		scod.setModelContext(stream.getHeader());
+		scod.prepareForUse();
+
+		mcod.setModelContext(stream.getHeader());
+		mcod.prepareForUse();
+
+		angiulli.setModelContext(stream.getHeader());
+		angiulli.prepareForUse();
+
+		abstractC.setModelContext(stream.getHeader());
+		abstractC.prepareForUse();
+
+		Long tmStart = System.currentTimeMillis();
+
+		int numberSamples = 0;
+		while (stream.hasMoreInstances() && (numberSamples < numInstances)) {
+			Instance newInst = stream.nextInstance().getData();
+
+			// scod.processNewInstanceImpl(newInst);
+			mcod.processNewInstanceImpl(newInst);
+			// angiulli.processNewInstanceImpl(newInst);
+			// abstractC.processNewInstanceImpl(newInst);
+
+			numberSamples++;
+		}
+
+		System.out.println("Total time = " + (System.currentTimeMillis() - tmStart) + " ms");
+	}
+}
diff --git a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/ComposedSplitFunction.java b/moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/ComposedSplitFunction.java
similarity index 81%
rename from moa/src/main/java/moa/clusterers/outliers/utils/mtree/ComposedSplitFunction.java
rename to moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/ComposedSplitFunction.java
index 4ff154c4e..08146222b 100644
--- a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/ComposedSplitFunction.java
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/ComposedSplitFunction.java
@@ -11,18 +11,18 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
-package moa.clusterers.outliers.utils.mtree;
+package moa.learners.clusterers.outliers.utils.mtree;
 
 import java.util.Set;
 
-import moa.clusterers.outliers.utils.mtree.utils.Pair;
+import moa.learners.clusterers.outliers.utils.mtree.utils.Pair;
 
 /**
- * A {@linkplain SplitFunction split function} that is defined by composing
- * a {@linkplain PromotionFunction promotion function} and a
+ * A {@linkplain SplitFunction split function} that is defined by composing a
+ * {@linkplain PromotionFunction promotion function} and a
  * {@linkplain PartitionFunction partition function}.
  *
  * @param <DATA> The type of the data objects.
@@ -36,21 +36,16 @@ public class ComposedSplitFunction<DATA> implements SplitFunction<DATA> {
 	 * The constructor of a {@link SplitFunction} composed by a
 	 * {@link PromotionFunction} and a {@link PartitionFunction}.
 	 */
-	public ComposedSplitFunction(
-			PromotionFunction<DATA> promotionFunction,
-			PartitionFunction<DATA> partitionFunction
-		)
-	{
+	public ComposedSplitFunction(PromotionFunction<DATA> promotionFunction, PartitionFunction<DATA> partitionFunction) {
 		this.promotionFunction = promotionFunction;
 		this.partitionFunction = partitionFunction;
 	}
 
-	
 	@Override
 	public SplitResult<DATA> process(Set<DATA> dataSet, DistanceFunction<? super DATA> distanceFunction) {
 		Pair<DATA> promoted = promotionFunction.process(dataSet, distanceFunction);
 		Pair<Set<DATA>> partitions = partitionFunction.process(promoted, dataSet, distanceFunction);
-		return new SplitResult<DATA>(promoted, partitions);
+		return new SplitResult<>(promoted, partitions);
 	}
 
 }
diff --git a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/DistanceFunction.java b/moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/DistanceFunction.java
similarity index 93%
rename from moa/src/main/java/moa/clusterers/outliers/utils/mtree/DistanceFunction.java
rename to moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/DistanceFunction.java
index bde99b252..dd8fd0827 100644
--- a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/DistanceFunction.java
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/DistanceFunction.java
@@ -11,10 +11,10 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
-package moa.clusterers.outliers.utils.mtree;
+package moa.learners.clusterers.outliers.utils.mtree;
 
 /**
  * An object that can calculate the distance between two data objects.
@@ -22,7 +22,7 @@
  * @param <DATA> The type of the data objects.
  */
 public interface DistanceFunction<DATA> {
-	
+
 	double calculate(DATA data1, DATA data2);
-	
+
 }
diff --git a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/DistanceFunctions.java b/moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/DistanceFunctions.java
similarity index 73%
rename from moa/src/main/java/moa/clusterers/outliers/utils/mtree/DistanceFunctions.java
rename to moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/DistanceFunctions.java
index a40de96c3..9de68b696 100644
--- a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/DistanceFunctions.java
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/DistanceFunctions.java
@@ -11,10 +11,10 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
-package moa.clusterers.outliers.utils.mtree;
+package moa.learners.clusterers.outliers.utils.mtree;
 
 import java.util.HashMap;
 import java.util.List;
@@ -25,20 +25,19 @@
  * functions}.
  */
 public final class DistanceFunctions {
-	
-    /**
-     * Don't let anyone instantiate this class.
-     */
-	private DistanceFunctions() {}
-	
-	
+
+	/**
+	 * Don't let anyone instantiate this class.
+	 */
+	private DistanceFunctions() {
+	}
+
 	/**
 	 * Creates a cached version of a {@linkplain DistanceFunction distance
-	 * function}. This method is used internally by {@link MTree} to create
-	 * a cached distance function to pass to the {@linkplain SplitFunction split
-	 * function}.
-	 * @param distanceFunction The distance function to create a cached version
-	 *        of.
+	 * function}. This method is used internally by {@link MTree} to create a cached
+	 * distance function to pass to the {@linkplain SplitFunction split function}.
+	 * 
+	 * @param distanceFunction The distance function to create a cached version of.
 	 * @return The cached distance function.
 	 */
 	public static <Data> DistanceFunction<Data> cached(final DistanceFunction<Data> distanceFunction) {
@@ -46,7 +45,7 @@ public static <Data> DistanceFunction<Data> cached(final DistanceFunction<Data>
 			class Pair {
 				Data data1;
 				Data data2;
-				
+
 				public Pair(Data data1, Data data2) {
 					this.data1 = data1;
 					this.data2 = data2;
@@ -56,35 +55,34 @@ public Pair(Data data1, Data data2) {
 				public int hashCode() {
 					return data1.hashCode() ^ data2.hashCode();
 				}
-				
+
 				@Override
 				public boolean equals(Object arg0) {
-					if(arg0 instanceof Pair) {
+					if (arg0 instanceof Pair) {
 						Pair that = (Pair) arg0;
-						return this.data1.equals(that.data1)
-						    && this.data2.equals(that.data2);
+						return this.data1.equals(that.data1) && this.data2.equals(that.data2);
 					} else {
 						return false;
 					}
 				}
 			}
-			
-			private final Map<Pair, Double> cache = new HashMap<Pair, Double>();
-			
+
+			private final Map<Pair, Double> cache = new HashMap<>();
+
 			@Override
 			public double calculate(Data data1, Data data2) {
 				Pair pair1 = new Pair(data1, data2);
 				Double distance = cache.get(pair1);
-				if(distance != null) {
+				if (distance != null) {
 					return distance;
 				}
-				
+
 				Pair pair2 = new Pair(data2, data1);
 				distance = cache.get(pair2);
-				if(distance != null) {
+				if (distance != null) {
 					return distance;
 				}
-				
+
 				distance = distanceFunction.calculate(data1, data2);
 				cache.put(pair1, distance);
 				cache.put(pair2, distance);
@@ -92,38 +90,36 @@ public double calculate(Data data1, Data data2) {
 			}
 		};
 	}
-	
-	
-	
+
 	/**
 	 * An interface to represent coordinates in Euclidean spaces.
-	 * @see <a href="http://en.wikipedia.org/wiki/Euclidean_space">"Euclidean
-	 *      Space" article at Wikipedia</a>
+	 * 
+	 * @see <a href="http://en.wikipedia.org/wiki/Euclidean_space">"Euclidean Space"
+	 *      article at Wikipedia</a>
 	 */
 	public interface EuclideanCoordinate {
 		/**
 		 * The number of dimensions.
 		 */
 		int dimensions();
-		
+
 		/**
 		 * A method to access the {@code index}-th component of the coordinate.
-		 * 
-		 * @param index The index of the component. Must be less than {@link
-		 *              #dimensions()}. 
+		 *
+		 * @param index The index of the component. Must be less than
+		 *              {@link #dimensions()}.
 		 */
 		double get(int index);
 	}
-	
-	
+
 	/**
-	 * Calculates the distance between two {@linkplain EuclideanCoordinate 
-	 * euclidean coordinates}.
+	 * Calculates the distance between two {@linkplain EuclideanCoordinate euclidean
+	 * coordinates}.
 	 */
 	public static double euclidean(EuclideanCoordinate coord1, EuclideanCoordinate coord2) {
 		int size = Math.min(coord1.dimensions(), coord2.dimensions());
 		double distance = 0;
-		for(int i = 0; i < size; i++) {
+		for (int i = 0; i < size; i++) {
 			double diff = coord1.get(i) - coord2.get(i);
 			distance += diff * diff;
 		}
@@ -131,11 +127,9 @@ public static double euclidean(EuclideanCoordinate coord1, EuclideanCoordinate c
 		return distance;
 	}
 
-
 	/**
-	 * A {@linkplain DistanceFunction distance function} object that calculates
-	 * the distance between two {@linkplain EuclideanCoordinate euclidean
-	 * coordinates}.
+	 * A {@linkplain DistanceFunction distance function} object that calculates the
+	 * distance between two {@linkplain EuclideanCoordinate euclidean coordinates}.
 	 */
 	public static final DistanceFunction<EuclideanCoordinate> EUCLIDEAN = new DistanceFunction<DistanceFunctions.EuclideanCoordinate>() {
 		@Override
@@ -143,42 +137,65 @@ public double calculate(EuclideanCoordinate coord1, EuclideanCoordinate coord2)
 			return DistanceFunctions.euclidean(coord1, coord2);
 		}
 	};
-	
-	
+
 	/**
-	 * A {@linkplain DistanceFunction distance function} object that calculates
-	 * the distance between two coordinates represented by {@linkplain 
-	 * java.util.List lists} of {@link java.lang.Integer}s.
+	 * A {@linkplain DistanceFunction distance function} object that calculates the
+	 * distance between two coordinates represented by {@linkplain java.util.List
+	 * lists} of {@link java.lang.Integer}s.
 	 */
 	public static final DistanceFunction<List<Integer>> EUCLIDEAN_INTEGER_LIST = new DistanceFunction<List<Integer>>() {
 		@Override
 		public double calculate(List<Integer> data1, List<Integer> data2) {
 			class IntegerListEuclideanCoordinate implements EuclideanCoordinate {
 				List<Integer> list;
-				public IntegerListEuclideanCoordinate(List<Integer> list) { this.list = list; }
-				@Override public int dimensions() { return list.size(); }
-				@Override public double get(int index) { return list.get(index); }
-			};
+
+				public IntegerListEuclideanCoordinate(List<Integer> list) {
+					this.list = list;
+				}
+
+				@Override
+				public int dimensions() {
+					return list.size();
+				}
+
+				@Override
+				public double get(int index) {
+					return list.get(index);
+				}
+			}
+			;
 			IntegerListEuclideanCoordinate coord1 = new IntegerListEuclideanCoordinate(data1);
 			IntegerListEuclideanCoordinate coord2 = new IntegerListEuclideanCoordinate(data2);
 			return DistanceFunctions.euclidean(coord1, coord2);
 		}
 	};
-	
+
 	/**
-	 * A {@linkplain DistanceFunction distance function} object that calculates
-	 * the distance between two coordinates represented by {@linkplain 
-	 * java.util.List lists} of {@link java.lang.Double}s.
+	 * A {@linkplain DistanceFunction distance function} object that calculates the
+	 * distance between two coordinates represented by {@linkplain java.util.List
+	 * lists} of {@link java.lang.Double}s.
 	 */
 	public static final DistanceFunction<List<Double>> EUCLIDEAN_DOUBLE_LIST = new DistanceFunction<List<Double>>() {
 		@Override
 		public double calculate(List<Double> data1, List<Double> data2) {
 			class DoubleListEuclideanCoordinate implements EuclideanCoordinate {
 				List<Double> list;
-				public DoubleListEuclideanCoordinate(List<Double> list) { this.list = list; }
-				@Override public int dimensions() { return list.size(); }
-				@Override public double get(int index) { return list.get(index); }
-			};
+
+				public DoubleListEuclideanCoordinate(List<Double> list) {
+					this.list = list;
+				}
+
+				@Override
+				public int dimensions() {
+					return list.size();
+				}
+
+				@Override
+				public double get(int index) {
+					return list.get(index);
+				}
+			}
+			;
 			DoubleListEuclideanCoordinate coord1 = new DoubleListEuclideanCoordinate(data1);
 			DoubleListEuclideanCoordinate coord2 = new DoubleListEuclideanCoordinate(data2);
 			return DistanceFunctions.euclidean(coord1, coord2);
diff --git a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/MTree.java b/moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/MTree.java
similarity index 72%
rename from moa/src/main/java/moa/clusterers/outliers/utils/mtree/MTree.java
rename to moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/MTree.java
index fc4271bc4..3b45225c3 100644
--- a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/MTree.java
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/MTree.java
@@ -11,10 +11,10 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
-package moa.clusterers.outliers.utils.mtree;
+package moa.learners.clusterers.outliers.utils.mtree;
 
 import java.util.ArrayDeque;
 import java.util.Deque;
@@ -25,16 +25,15 @@
 import java.util.PriorityQueue;
 import java.util.Set;
 
-import moa.clusterers.outliers.utils.mtree.SplitFunction.SplitResult;
-
-
+import moa.learners.clusterers.outliers.utils.mtree.SplitFunction.SplitResult;
 
 /**
  * The main class that implements the M-Tree.
  *
  * @param <DATA> The type of data that will be indexed by the M-Tree. Objects of
- *        this type are stored in HashMaps and HashSets, so their
- *        {@code hashCode()} and {@code equals()} methods must be consistent.
+ *               this type are stored in HashMaps and HashSets, so their
+ *               {@code hashCode()} and {@code equals()} methods must be
+ *               consistent.
  */
 public class MTree<DATA> {
 
@@ -50,61 +49,59 @@ private ResultItem(DATA data, double distance) {
 		/** A nearest-neighbor. */
 		public DATA data;
 
-		/** 
-		 * The distance from the nearest-neighbor to the query data object
-		 * parameter.
+		/**
+		 * The distance from the nearest-neighbor to the query data object parameter.
 		 */
 		public double distance;
 	}
-	
-	
+
 	// Exception classes
 	private static class SplitNodeReplacement extends Exception {
-		// A subclass of Throwable cannot be generic.  :-(
+		// A subclass of Throwable cannot be generic. :-(
 		// So, we have newNodes declared as Object[] instead of Node[].
 		private Object newNodes[];
-		
+
 		private SplitNodeReplacement(Object... newNodes) {
 			this.newNodes = newNodes;
 		}
 	}
-	
+
 	private static class RootNodeReplacement extends Exception {
-		// A subclass of Throwable cannot be generic.  :-(
+		// A subclass of Throwable cannot be generic. :-(
 		// So, we have newRoot declared as Object instead of Node.
 		private Object newRoot;
-		
+
 		private RootNodeReplacement(Object newRoot) {
 			this.newRoot = newRoot;
 		}
 	}
 
-	
-	private static class NodeUnderCapacity extends Exception { }
-	
+	private static class NodeUnderCapacity extends Exception {
+	}
 
-	private static class DataNotFound extends Exception { }
+	private static class DataNotFound extends Exception {
+	}
 
 	/**
 	 * An {@link Iterable} class which can be iterated to fetch the results of a
 	 * nearest-neighbors query.
-	 * 
-	 * <p>The neighbors are presented in non-decreasing order from the {@code
+	 *
+	 * <p>
+	 * The neighbors are presented in non-decreasing order from the {@code
 	 * queryData} argument to the {@link MTree#getNearest(Object, double, int)
-	 * getNearest*()}
-	 * call.
-	 * 
-	 * <p>The query on the M-Tree is executed during the iteration, as the
-	 * results are fetched. It means that, by the time when the <i>n</i>-th
-	 * result is fetched, the next result may still not be known, and the
-	 * resources allocated were only the necessary to identify the <i>n</i>
-	 * first results.
+	 * getNearest*()} call.
+	 *
+	 * <p>
+	 * The query on the M-Tree is executed during the iteration, as the results are
+	 * fetched. It means that, by the time when the <i>n</i>-th result is fetched,
+	 * the next result may still not be known, and the resources allocated were only
+	 * the necessary to identify the <i>n</i> first results.
 	 */
 	public class Query implements Iterable<ResultItem> {
 
 		private class ResultsIterator implements Iterator<ResultItem> {
-			
-			private class ItemWithDistances <U> implements Comparable<ItemWithDistances<U>> {
+
+			private class ItemWithDistances<U> implements Comparable<ItemWithDistances<U>> {
 				private U item;
 				private double distance;
 				private double minDistance;
@@ -117,59 +114,57 @@ public ItemWithDistances(U item, double distance, double minDistance) {
 
 				@Override
 				public int compareTo(ItemWithDistances<U> that) {
-					if(this.minDistance < that.minDistance) {
+					if (this.minDistance < that.minDistance) {
 						return -1;
-					} else if(this.minDistance > that.minDistance) {
+					} else if (this.minDistance > that.minDistance) {
 						return +1;
 					} else {
 						return 0;
 					}
 				}
 			}
-			
-			
+
 			private ResultItem nextResultItem = null;
 			private boolean finished = false;
-			private PriorityQueue<ItemWithDistances<Node>> pendingQueue = new PriorityQueue<ItemWithDistances<Node>>();
+			private PriorityQueue<ItemWithDistances<Node>> pendingQueue = new PriorityQueue<>();
 			private double nextPendingMinDistance;
-			private PriorityQueue<ItemWithDistances<Entry>> nearestQueue = new PriorityQueue<ItemWithDistances<Entry>>();
+			private PriorityQueue<ItemWithDistances<Entry>> nearestQueue = new PriorityQueue<>();
 			private int yieldedCount;
-			
+
 			private ResultsIterator() {
-				if(MTree.this.root == null) {
+				if (MTree.this.root == null) {
 					finished = true;
 					return;
 				}
-				
+
 				double distance = MTree.this.distanceFunction.calculate(Query.this.data, MTree.this.root.data);
 				double minDistance = Math.max(distance - MTree.this.root.radius, 0.0);
-				
-				pendingQueue.add(new ItemWithDistances<Node>(MTree.this.root, distance, minDistance));
+
+				pendingQueue.add(new ItemWithDistances<>(MTree.this.root, distance, minDistance));
 				nextPendingMinDistance = minDistance;
 			}
-			
-			
+
 			@Override
 			public boolean hasNext() {
-				if(finished) {
+				if (finished) {
 					return false;
 				}
-				
-				if(nextResultItem == null) {
+
+				if (nextResultItem == null) {
 					fetchNext();
 				}
-				
-				if(nextResultItem == null) {
+
+				if (nextResultItem == null) {
 					finished = true;
 					return false;
 				} else {
 					return true;
 				}
 			}
-			
+
 			@Override
 			public ResultItem next() {
-				if(hasNext()) {
+				if (hasNext()) {
 					ResultItem next = nextResultItem;
 					nextResultItem = null;
 					return next;
@@ -177,50 +172,51 @@ public ResultItem next() {
 					throw new NoSuchElementException();
 				}
 			}
-			
+
 			@Override
 			public void remove() {
 				throw new UnsupportedOperationException();
 			}
-			
-			
+
 			private void fetchNext() {
 				assert !finished;
-				
-				if(finished  ||  yieldedCount >= Query.this.limit) {
+
+				if (finished || yieldedCount >= Query.this.limit) {
 					finished = true;
 					return;
 				}
-				
-				while(!pendingQueue.isEmpty()  ||  !nearestQueue.isEmpty()) {
-					if(prepareNextNearest()) {
+
+				while (!pendingQueue.isEmpty() || !nearestQueue.isEmpty()) {
+					if (prepareNextNearest()) {
 						return;
 					}
-					
+
 					assert !pendingQueue.isEmpty();
-					
+
 					ItemWithDistances<Node> pending = pendingQueue.poll();
 					Node node = pending.item;
-					
-					for(IndexItem child : node.children.values()) {
-						if(Math.abs(pending.distance - child.distanceToParent) - child.radius <= Query.this.range) {
+
+					for (IndexItem child : node.children.values()) {
+						if (Math.abs(pending.distance - child.distanceToParent) - child.radius <= Query.this.range) {
 							double childDistance = MTree.this.distanceFunction.calculate(Query.this.data, child.data);
 							double childMinDistance = Math.max(childDistance - child.radius, 0.0);
-							if(childMinDistance <= Query.this.range) {
-								if(child instanceof MTree.Entry) {
+							if (childMinDistance <= Query.this.range) {
+								if (child instanceof MTree.Entry) {
 									@SuppressWarnings("unchecked")
-									Entry entry = (Entry)child;
-									nearestQueue.add(new ItemWithDistances<Entry>(entry, childDistance, childMinDistance));
+									Entry entry = (Entry) child;
+									nearestQueue
+											.add(new ItemWithDistances<>(entry, childDistance, childMinDistance));
 								} else {
 									@SuppressWarnings("unchecked")
-									Node childNode = (Node)child;
-									pendingQueue.add(new ItemWithDistances<Node>(childNode, childDistance, childMinDistance));
+									Node childNode = (Node) child;
+									pendingQueue.add(
+											new ItemWithDistances<>(childNode, childDistance, childMinDistance));
 								}
 							}
 						}
 					}
-					
-					if(pendingQueue.isEmpty()) {
+
+					if (pendingQueue.isEmpty()) {
 						nextPendingMinDistance = Double.POSITIVE_INFINITY;
 					} else {
 						nextPendingMinDistance = pendingQueue.peek().minDistance;
@@ -230,127 +226,115 @@ private void fetchNext() {
 				finished = true;
 			}
 
-			
 			private boolean prepareNextNearest() {
-				if(!nearestQueue.isEmpty()) {
+				if (!nearestQueue.isEmpty()) {
 					ItemWithDistances<Entry> nextNearest = nearestQueue.peek();
-					if(nextNearest.distance <= nextPendingMinDistance) {
+					if (nextNearest.distance <= nextPendingMinDistance) {
 						nearestQueue.poll();
 						nextResultItem = new ResultItem(nextNearest.item.data, nextNearest.distance);
 						++yieldedCount;
 						return true;
 					}
 				}
-				
+
 				return false;
 			}
-			
+
 		}
-		
-		
+
 		private Query(DATA data, double range, int limit) {
 			this.data = data;
 			this.range = range;
 			this.limit = limit;
 		}
-		
-		
+
 		@Override
 		public Iterator<ResultItem> iterator() {
 			return new ResultsIterator();
 		}
 
-		
 		private DATA data;
 		private double range;
 		private int limit;
 	}
 
-
-	
 	/**
-	 * The default minimum capacity of nodes in an M-Tree, when not specified in
-	 * the constructor call.
+	 * The default minimum capacity of nodes in an M-Tree, when not specified in the
+	 * constructor call.
 	 */
 	public static final int DEFAULT_MIN_NODE_CAPACITY = 50;
 
-
 	protected int minNodeCapacity;
 	protected int maxNodeCapacity;
 	protected DistanceFunction<? super DATA> distanceFunction;
 	protected SplitFunction<DATA> splitFunction;
 	protected Node root;
-	
-	
+
 	/**
 	 * Constructs an M-Tree with the specified distance function.
-	 * @param distanceFunction The object used to calculate the distance between
-	 *        two data objects.
+	 * 
+	 * @param distanceFunction The object used to calculate the distance between two
+	 *                         data objects.
 	 */
-	public MTree(DistanceFunction<? super DATA> distanceFunction,
-			SplitFunction<DATA> splitFunction) {
+	public MTree(DistanceFunction<? super DATA> distanceFunction, SplitFunction<DATA> splitFunction) {
 		this(DEFAULT_MIN_NODE_CAPACITY, distanceFunction, splitFunction);
 	}
-	
+
 	/**
-	 * Constructs an M-Tree with the specified minimum node capacity and
-	 * distance function.
-	 * @param minNodeCapacity The minimum capacity for the nodes of the tree.
-	 * @param distanceFunction The object used to calculate the distance between
-	 *        two data objects.
-	 * @param splitFunction The object used to process the split of nodes if
-	 *        they are full when a new child must be added.
+	 * Constructs an M-Tree with the specified minimum node capacity and distance
+	 * function.
+	 * 
+	 * @param minNodeCapacity  The minimum capacity for the nodes of the tree.
+	 * @param distanceFunction The object used to calculate the distance between two
+	 *                         data objects.
+	 * @param splitFunction    The object used to process the split of nodes if they
+	 *                         are full when a new child must be added.
 	 */
-	public MTree(int minNodeCapacity,
-			DistanceFunction<? super DATA> distanceFunction,
+	public MTree(int minNodeCapacity, DistanceFunction<? super DATA> distanceFunction,
 			SplitFunction<DATA> splitFunction) {
 		this(minNodeCapacity, 2 * minNodeCapacity - 1, distanceFunction, splitFunction);
 	}
-	
+
 	/**
-	 * Constructs an M-Tree with the specified minimum and maximum node
-	 * capacities and distance function.
-	 * @param minNodeCapacity The minimum capacity for the nodes of the tree.
-	 * @param maxNodeCapacity The maximum capacity for the nodes of the tree.
-	 * @param distanceFunction The object used to calculate the distance between
-	 *        two data objects.
-	 * @param splitFunction The object used to process the split of nodes if
-	 *        they are full when a new child must be added.
+	 * Constructs an M-Tree with the specified minimum and maximum node capacities
+	 * and distance function.
+	 * 
+	 * @param minNodeCapacity  The minimum capacity for the nodes of the tree.
+	 * @param maxNodeCapacity  The maximum capacity for the nodes of the tree.
+	 * @param distanceFunction The object used to calculate the distance between two
+	 *                         data objects.
+	 * @param splitFunction    The object used to process the split of nodes if they
+	 *                         are full when a new child must be added.
 	 */
-	public MTree(int minNodeCapacity, int maxNodeCapacity,
-			DistanceFunction<? super DATA> distanceFunction,
-			SplitFunction<DATA> splitFunction)
-	{
-		if(minNodeCapacity < 2  ||  maxNodeCapacity <= minNodeCapacity  ||
-		   distanceFunction == null) {
+	public MTree(int minNodeCapacity, int maxNodeCapacity, DistanceFunction<? super DATA> distanceFunction,
+			SplitFunction<DATA> splitFunction) {
+		if (minNodeCapacity < 2 || maxNodeCapacity <= minNodeCapacity || distanceFunction == null) {
 			throw new IllegalArgumentException();
 		}
-		
-		if(splitFunction == null) {
-			splitFunction = new ComposedSplitFunction<DATA>(
-					new PromotionFunctions.RandomPromotion<DATA>(),
-					new PartitionFunctions.BalancedPartition<DATA>()
-				);
+
+		if (splitFunction == null) {
+			splitFunction = new ComposedSplitFunction<>(new PromotionFunctions.RandomPromotion<DATA>(),
+					new PartitionFunctions.BalancedPartition<DATA>());
 		}
-		
+
 		this.minNodeCapacity = minNodeCapacity;
 		this.maxNodeCapacity = maxNodeCapacity;
 		this.distanceFunction = distanceFunction;
 		this.splitFunction = splitFunction;
 		this.root = null;
 	}
-	
-	
+
 	/**
 	 * Adds and indexes a data object.
-	 * 
-	 * <p>An object that is already indexed should not be added. There is no
-	 * validation regarding this, and the behavior is undefined if done.
-	 * 
+	 *
+	 * <p>
+	 * An object that is already indexed should not be added. There is no validation
+	 * regarding this, and the behavior is undefined if done.
+	 *
 	 * @param data The data object to index.
 	 */
 	public void add(DATA data) {
-		if(root == null) {
+		if (root == null) {
 			root = new RootLeafNode(data);
 			try {
 				root.addData(data, 0);
@@ -361,10 +345,10 @@ public void add(DATA data) {
 			double distance = distanceFunction.calculate(data, root.data);
 			try {
 				root.addData(data, distance);
-			} catch(SplitNodeReplacement e) {
+			} catch (SplitNodeReplacement e) {
 				Node newRoot = new RootNode(data);
 				root = newRoot;
-				for(int i = 0; i < e.newNodes.length; i++) {
+				for (int i = 0; i < e.newNodes.length; i++) {
 					@SuppressWarnings("unchecked")
 					Node newNode = (Node) e.newNodes[i];
 					distance = distanceFunction.calculate(root.data, newNode.data);
@@ -374,25 +358,25 @@ public void add(DATA data) {
 		}
 	}
 
-
 	/**
 	 * Removes a data object from the M-Tree.
+	 * 
 	 * @param data The data object to be removed.
 	 * @return {@code true} if and only if the object was found.
 	 */
 	public boolean remove(DATA data) {
-		if(root == null) {
+		if (root == null) {
 			return false;
 		}
-		
+
 		double distanceToRoot = distanceFunction.calculate(data, root.data);
 		try {
 			root.removeData(data, distanceToRoot);
-		} catch(RootNodeReplacement e) {
+		} catch (RootNodeReplacement e) {
 			@SuppressWarnings("unchecked")
 			Node newRoot = (Node) e.newRoot;
 			root = newRoot;
-		} catch(DataNotFound e) {
+		} catch (DataNotFound e) {
 			return false;
 		} catch (NodeUnderCapacity e) {
 			throw new RuntimeException("Should have never happened", e);
@@ -402,6 +386,7 @@ public boolean remove(DATA data) {
 
 	/**
 	 * Performs a nearest-neighbors query on the M-Tree, constrained by distance.
+	 * 
 	 * @param queryData The query data object.
 	 * @param range     The maximum distance from {@code queryData} to fetched
 	 *                  neighbors.
@@ -410,11 +395,11 @@ public boolean remove(DATA data) {
 	public Query getNearestByRange(DATA queryData, double range) {
 		return getNearest(queryData, range, Integer.MAX_VALUE);
 	}
-	
-	
+
 	/**
-	 * Performs a nearest-neighbors query on the M-Tree, constrained by the
-	 * number of neighbors.
+	 * Performs a nearest-neighbors query on the M-Tree, constrained by the number
+	 * of neighbors.
+	 * 
 	 * @param queryData The query data object.
 	 * @param limit     The maximum number of neighbors to fetch.
 	 * @return A {@link Query} object used to iterate on the results.
@@ -426,6 +411,7 @@ public Query getNearestByLimit(DATA queryData, int limit) {
 	/**
 	 * Performs a nearest-neighbor query on the M-Tree, constrained by distance
 	 * and/or the number of neighbors.
+	 * 
 	 * @param queryData The query data object.
 	 * @param range     The maximum distance from {@code queryData} to fetched
 	 *                  neighbors.
@@ -438,20 +424,19 @@ public Query getNearest(DATA queryData, double range, int limit) {
 
 	/**
 	 * Performs a nearest-neighbor query on the M-Tree, without constraints.
+	 * 
 	 * @param queryData The query data object.
 	 * @return A {@link Query} object used to iterate on the results.
 	 */
 	public Query getNearest(DATA queryData) {
 		return new Query(queryData, Double.POSITIVE_INFINITY, Integer.MAX_VALUE);
 	}
-	
-	
+
 	protected void _check() {
-		if(root != null) {
+		if (root != null) {
 			root._check();
 		}
 	}
-	
 
 	private class IndexItem {
 		DATA data;
@@ -481,22 +466,19 @@ protected void _checkDistanceToParent() {
 		}
 	}
 
-	
-	
 	private abstract class Node extends IndexItem {
 
-		protected Map<DATA, IndexItem> children = new HashMap<DATA, IndexItem>();
-		protected Rootness       rootness;
+		protected Map<DATA, IndexItem> children = new HashMap<>();
+		protected Rootness rootness;
 		protected Leafness<DATA> leafness;
-		
-		private
-		<R extends NodeTrait & Rootness, L extends NodeTrait & Leafness<DATA>>
-		Node(DATA data, R rootness, L leafness) {
+
+		private <R extends NodeTrait & Rootness, L extends NodeTrait & Leafness<DATA>> Node(DATA data, R rootness,
+				L leafness) {
 			super(data);
-			
+
 			rootness.thisNode = this;
 			this.rootness = rootness;
-			
+
 			leafness.thisNode = this;
 			this.leafness = leafness;
 		}
@@ -506,13 +488,14 @@ private final void addData(DATA data, double distance) throws SplitNodeReplaceme
 			checkMaxCapacity();
 		}
 
+		@Override
 		int _check() {
 			super._check();
 			_checkMinCapacity();
 			_checkMaxCapacity();
 
 			int childHeight = -1;
-			for(Map.Entry<DATA, IndexItem> e : children.entrySet()) {
+			for (Map.Entry<DATA, IndexItem> e : children.entrySet()) {
 				DATA data = e.getKey();
 				IndexItem child = e.getValue();
 				assert child.data.equals(data);
@@ -521,7 +504,7 @@ int _check() {
 				_checkChildMetrics(child);
 
 				int height = child._check();
-				if(childHeight < 0) {
+				if (childHeight < 0) {
 					childHeight = height;
 				} else {
 					assert childHeight == height;
@@ -540,25 +523,27 @@ protected void doRemoveData(DATA data, double distance) throws DataNotFound {
 		}
 
 		private final void checkMaxCapacity() throws SplitNodeReplacement {
-			if(children.size() > MTree.this.maxNodeCapacity) {
-				DistanceFunction<? super DATA> cachedDistanceFunction = DistanceFunctions.cached(MTree.this.distanceFunction);
-				SplitResult<DATA> splitResult = MTree.this.splitFunction.process(children.keySet(), cachedDistanceFunction);
-				
+			if (children.size() > MTree.this.maxNodeCapacity) {
+				DistanceFunction<? super DATA> cachedDistanceFunction = DistanceFunctions
+						.cached(MTree.this.distanceFunction);
+				SplitResult<DATA> splitResult = MTree.this.splitFunction.process(children.keySet(),
+						cachedDistanceFunction);
+
 				Node newNode0 = null;
 				Node newNode1 = null;
-				for(int i = 0; i < 2; ++i) {
-					DATA promotedData   = splitResult.promoted.get(i);
+				for (int i = 0; i < 2; ++i) {
+					DATA promotedData = splitResult.promoted.get(i);
 					Set<DATA> partition = splitResult.partitions.get(i);
-					
+
 					Node newNode = newSplitNodeReplacement(promotedData);
-					for(DATA data : partition) {
+					for (DATA data : partition) {
 						IndexItem child = children.get(data);
 						children.remove(data);
 						double distance = cachedDistanceFunction.calculate(promotedData, data);
 						newNode.addChild(child, distance);
 					}
 
-					if(i == 0) {
+					if (i == 0) {
 						newNode0 = newNode;
 					} else {
 						newNode1 = newNode;
@@ -581,7 +566,7 @@ protected void addChild(IndexItem child, double distance) {
 
 		void removeData(DATA data, double distance) throws RootNodeReplacement, NodeUnderCapacity, DataNotFound {
 			doRemoveData(data, distance);
-			if(children.size() < getMinCapacity()) {
+			if (children.size() < getMinCapacity()) {
 				throw new NodeUnderCapacity();
 			}
 		}
@@ -596,8 +581,8 @@ private void updateMetrics(IndexItem child, double distance) {
 		}
 
 		private void updateRadius(IndexItem child) {
-                        if (child != null) // ### added by mits
-                            this.radius = Math.max(this.radius, child.distanceToParent + child.radius);
+			if (child != null) // ### added by mits
+				this.radius = Math.max(this.radius, child.distanceToParent + child.radius);
 		}
 
 		void _checkMinCapacity() {
@@ -619,7 +604,8 @@ private void _checkChildMetrics(IndexItem child) {
 			double sum = child.distanceToParent + child.radius;
 			assert sum <= this.radius;
 		}
-		
+
+		@Override
 		protected void _checkDistanceToParent() {
 			rootness._checkDistanceToParent();
 		}
@@ -628,37 +614,38 @@ private MTree<DATA> mtree() {
 			return MTree.this;
 		}
 	}
-	
-	
-	
-	
+
 	private abstract class NodeTrait {
 		protected Node thisNode;
 	}
-	
+
 	private interface Leafness<DATA> {
 		void doAddData(DATA data, double distance);
+
 		void addChild(MTree<DATA>.IndexItem child, double distance);
+
 		void doRemoveData(DATA data, double distance) throws DataNotFound;
+
 		MTree<DATA>.Node newSplitNodeReplacement(DATA data);
+
 		void _checkChildClass(MTree<DATA>.IndexItem child);
 	}
-	
+
 	private interface Rootness {
 		int getMinCapacity();
+
 		void _checkDistanceToParent();
+
 		void _checkMinCapacity();
 	}
-	
-	
-	
+
 	private class RootNodeTrait extends NodeTrait implements Rootness {
-		
+
 		@Override
 		public int getMinCapacity() {
 			throw new RuntimeException("Should not be called!");
 		}
-		
+
 		@Override
 		public void _checkDistanceToParent() {
 			assert thisNode.distanceToParent == -1;
@@ -668,31 +655,30 @@ public void _checkDistanceToParent() {
 		public void _checkMinCapacity() {
 			thisNode._checkMinCapacity();
 		}
-		
-	};
 
+	}
 
 	private class NonRootNodeTrait extends NodeTrait implements Rootness {
-		
+
 		@Override
 		public int getMinCapacity() {
 			return MTree.this.minNodeCapacity;
 		}
-		
+
 		@Override
 		public void _checkMinCapacity() {
 			assert thisNode.children.size() >= thisNode.mtree().minNodeCapacity;
 		}
-		
+
 		@Override
 		public void _checkDistanceToParent() {
 			assert thisNode.distanceToParent >= 0;
 		}
-	};
-	
-	
+	}
+
 	private class LeafNodeTrait extends NodeTrait implements Leafness<DATA> {
-		
+
+		@Override
 		public void doAddData(DATA data, double distance) {
 			Entry entry = thisNode.mtree().new Entry(data);
 			assert !thisNode.children.containsKey(data);
@@ -701,78 +687,79 @@ public void doAddData(DATA data, double distance) {
 			thisNode.updateMetrics(entry, distance);
 		}
 
+		@Override
 		public void addChild(IndexItem child, double distance) {
 			assert !thisNode.children.containsKey(child.data);
 			thisNode.children.put(child.data, child);
 			assert thisNode.children.containsKey(child.data);
 			thisNode.updateMetrics(child, distance);
 		}
-		
+
+		@Override
 		public Node newSplitNodeReplacement(DATA data) {
 			return thisNode.mtree().new LeafNode(data);
 		}
-		
 
 		@Override
 		public void doRemoveData(DATA data, double distance) throws DataNotFound {
-			if(thisNode.children.remove(data) == null) {
+			if (thisNode.children.remove(data) == null) {
 				throw new DataNotFound();
 			}
 		}
 
+		@Override
 		public void _checkChildClass(IndexItem child) {
 			assert child instanceof MTree.Entry;
 		}
 	}
 
-
 	class NonLeafNodeTrait extends NodeTrait implements Leafness<DATA> {
-		
+
+		@Override
 		public void doAddData(DATA data, double distance) {
 			class CandidateChild {
 				Node node;
 				double distance;
 				double metric;
+
 				private CandidateChild(Node node, double distance, double metric) {
 					this.node = node;
 					this.distance = distance;
 					this.metric = metric;
 				}
 			}
-			
+
 			CandidateChild minRadiusIncreaseNeeded = new CandidateChild(null, -1.0, Double.POSITIVE_INFINITY);
-			CandidateChild nearestDistance         = new CandidateChild(null, -1.0, Double.POSITIVE_INFINITY);
-			
-			for(IndexItem item : thisNode.children.values()) {
+			CandidateChild nearestDistance = new CandidateChild(null, -1.0, Double.POSITIVE_INFINITY);
+
+			for (IndexItem item : thisNode.children.values()) {
 				@SuppressWarnings("unchecked")
-				Node child = (Node)item;
+				Node child = (Node) item;
 				double childDistance = thisNode.mtree().distanceFunction.calculate(child.data, data);
-				if(childDistance > child.radius) {
+				if (childDistance > child.radius) {
 					double radiusIncrease = childDistance - child.radius;
-					if(radiusIncrease < minRadiusIncreaseNeeded.metric) {
+					if (radiusIncrease < minRadiusIncreaseNeeded.metric) {
 						minRadiusIncreaseNeeded = new CandidateChild(child, childDistance, radiusIncrease);
 					}
 				} else {
-					if(childDistance < nearestDistance.metric) {
+					if (childDistance < nearestDistance.metric) {
 						nearestDistance = new CandidateChild(child, childDistance, childDistance);
 					}
 				}
 			}
-			
-			CandidateChild chosen = (nearestDistance.node != null)
-			                      ? nearestDistance
-			                      : minRadiusIncreaseNeeded;
-			
+
+			CandidateChild chosen = (nearestDistance.node != null) ? nearestDistance : minRadiusIncreaseNeeded;
+
 			Node child = chosen.node;
 			try {
 				child.addData(data, chosen.distance);
 				thisNode.updateRadius(child);
-			} catch(SplitNodeReplacement e) {
+			} catch (SplitNodeReplacement e) {
 				// Replace current child with new nodes
 				IndexItem ii = thisNode.children.remove(child.data);
 				assert ii != null;
-				
-				for(int i = 0; i < e.newNodes.length; ++i) {
+
+				for (int i = 0; i < e.newNodes.length; ++i) {
 					@SuppressWarnings("unchecked")
 					Node newChild = (Node) e.newNodes[i];
 					distance = thisNode.mtree().distanceFunction.calculate(thisNode.data, newChild.data);
@@ -780,47 +767,48 @@ private CandidateChild(Node node, double distance, double metric) {
 				}
 			}
 		}
-		
 
+		@Override
 		public void addChild(IndexItem newChild_, double distance) {
 			@SuppressWarnings("unchecked")
 			Node newChild = (Node) newChild_;
-			
+
 			class ChildWithDistance {
 				Node child;
 				double distance;
+
 				private ChildWithDistance(Node child, double distance) {
 					this.child = child;
 					this.distance = distance;
 				}
 			}
-			
-			Deque<ChildWithDistance> newChildren = new ArrayDeque<ChildWithDistance>();
+
+			Deque<ChildWithDistance> newChildren = new ArrayDeque<>();
 			newChildren.addFirst(new ChildWithDistance(newChild, distance));
-			
-			while(!newChildren.isEmpty()) {
+
+			while (!newChildren.isEmpty()) {
 				ChildWithDistance cwd = newChildren.removeFirst();
-				
+
 				newChild = cwd.child;
 				distance = cwd.distance;
-				if(thisNode.children.containsKey(newChild.data)) {
+				if (thisNode.children.containsKey(newChild.data)) {
 					@SuppressWarnings("unchecked")
 					Node existingChild = (Node) thisNode.children.get(newChild.data);
 					assert existingChild.data.equals(newChild.data);
-					
+
 					// Transfer the _children_ of the newChild to the existingChild
-					for(IndexItem grandchild : newChild.children.values()) {
+					for (IndexItem grandchild : newChild.children.values()) {
 						existingChild.addChild(grandchild, grandchild.distanceToParent);
 					}
 					newChild.children.clear();
-					
+
 					try {
 						existingChild.checkMaxCapacity();
-					} catch(SplitNodeReplacement e) {
+					} catch (SplitNodeReplacement e) {
 						IndexItem ii = thisNode.children.remove(existingChild.data);
 						assert ii != null;
-						
-						for(int i = 0; i < e.newNodes.length; ++i) {
+
+						for (int i = 0; i < e.newNodes.length; ++i) {
 							@SuppressWarnings("unchecked")
 							Node newNode = (Node) e.newNodes[i];
 							distance = thisNode.mtree().distanceFunction.calculate(thisNode.data, newNode.data);
@@ -834,26 +822,26 @@ private ChildWithDistance(Node child, double distance) {
 			}
 		}
 
-
+		@Override
 		public Node newSplitNodeReplacement(DATA data) {
 			return new InternalNode(data);
 		}
 
-
+		@Override
 		public void doRemoveData(DATA data, double distance) throws DataNotFound {
-			for(IndexItem childItem : thisNode.children.values()) {
+			for (IndexItem childItem : thisNode.children.values()) {
 				@SuppressWarnings("unchecked")
-				Node child = (Node)childItem;
-				if(Math.abs(distance - child.distanceToParent) <= child.radius) {
+				Node child = (Node) childItem;
+				if (Math.abs(distance - child.distanceToParent) <= child.radius) {
 					double distanceToChild = thisNode.mtree().distanceFunction.calculate(data, child.data);
-					if(distanceToChild <= child.radius) {
+					if (distanceToChild <= child.radius) {
 						try {
 							child.removeData(data, distanceToChild);
 							thisNode.updateRadius(child);
 							return;
-						} catch(DataNotFound e) {
+						} catch (DataNotFound e) {
 							// If DataNotFound was thrown, then the data was not found in the child
-						} catch(NodeUnderCapacity e) {
+						} catch (NodeUnderCapacity e) {
 							Node expandedChild = balanceChildren(child);
 							thisNode.updateRadius(expandedChild);
 							return;
@@ -863,53 +851,56 @@ public void doRemoveData(DATA data, double distance) throws DataNotFound {
 					}
 				}
 			}
-			
+
 			throw new DataNotFound();
 		}
 
-		
 		private Node balanceChildren(Node theChild) {
 			// Tries to find anotherChild which can donate a grand-child to theChild.
-			
+
 			Node nearestDonor = null;
 			double distanceNearestDonor = Double.POSITIVE_INFINITY;
-			
+
 			Node nearestMergeCandidate = null;
 			double distanceNearestMergeCandidate = Double.POSITIVE_INFINITY;
 
-			for(IndexItem child : thisNode.children.values()) {
+			for (IndexItem child : thisNode.children.values()) {
 				@SuppressWarnings("unchecked")
-				Node anotherChild = (Node)child;
-				if(anotherChild == theChild) continue;
+				Node anotherChild = (Node) child;
+				if (anotherChild == theChild)
+					continue;
 
 				double distance = thisNode.mtree().distanceFunction.calculate(theChild.data, anotherChild.data);
-				if(anotherChild.children.size() > anotherChild.getMinCapacity()) {
-					if(distance < distanceNearestDonor) {
+				if (anotherChild.children.size() > anotherChild.getMinCapacity()) {
+					if (distance < distanceNearestDonor) {
 						distanceNearestDonor = distance;
 						nearestDonor = anotherChild;
 					}
 				} else {
-					if(distance < distanceNearestMergeCandidate) {
+					if (distance < distanceNearestMergeCandidate) {
 						distanceNearestMergeCandidate = distance;
 						nearestMergeCandidate = anotherChild;
 					}
 				}
 			}
 
-			if(nearestDonor == null) {
+			if (nearestDonor == null) {
 				// Merge
-				for(IndexItem grandchild : theChild.children.values()) {
-                                    //if (thisNode == null) System.out.println("thisNode is null");
-                                    //if (thisNode.mtree() == null) System.out.println("thisNode.mtree() is null");
-                                    //if (grandchild == null) System.out.println("grandchild is null");
-                                    //if (grandchild.data == null) System.out.println("grandchild.data is null");                                
-                                    //if (nearestMergeCandidate == null) System.out.println("nearestMergeCandidate is null");                                
-                                    //if (nearestMergeCandidate.data == null) System.out.println("nearestMergeCandidate.data is null");
-
-                                    if (nearestMergeCandidate != null) { // ### added by mits
-                                        double distance = thisNode.mtree().distanceFunction.calculate(grandchild.data, nearestMergeCandidate.data);
-                                        nearestMergeCandidate.addChild(grandchild, distance); 
-                                    }                                    
+				for (IndexItem grandchild : theChild.children.values()) {
+					// if (thisNode == null) System.out.println("thisNode is null");
+					// if (thisNode.mtree() == null) System.out.println("thisNode.mtree() is null");
+					// if (grandchild == null) System.out.println("grandchild is null");
+					// if (grandchild.data == null) System.out.println("grandchild.data is null");
+					// if (nearestMergeCandidate == null) System.out.println("nearestMergeCandidate
+					// is null");
+					// if (nearestMergeCandidate.data == null)
+					// System.out.println("nearestMergeCandidate.data is null");
+
+					if (nearestMergeCandidate != null) { // ### added by mits
+						double distance = thisNode.mtree().distanceFunction.calculate(grandchild.data,
+								nearestMergeCandidate.data);
+						nearestMergeCandidate.addChild(grandchild, distance);
+					}
 				}
 
 				IndexItem removed = thisNode.children.remove(theChild.data);
@@ -920,9 +911,9 @@ private Node balanceChildren(Node theChild) {
 				// Look for the nearest grandchild
 				IndexItem nearestGrandchild = null;
 				double nearestGrandchildDistance = Double.POSITIVE_INFINITY;
-				for(IndexItem grandchild : nearestDonor.children.values()) {
+				for (IndexItem grandchild : nearestDonor.children.values()) {
 					double distance = thisNode.mtree().distanceFunction.calculate(grandchild.data, theChild.data);
-					if(distance < nearestGrandchildDistance) {
+					if (distance < nearestGrandchildDistance) {
 						nearestGrandchildDistance = distance;
 						nearestGrandchild = grandchild;
 					}
@@ -935,20 +926,19 @@ private Node balanceChildren(Node theChild) {
 			}
 		}
 
-
+		@Override
 		public void _checkChildClass(IndexItem child) {
-			assert child instanceof MTree.InternalNode
-			    || child instanceof MTree.LeafNode;
+			assert child instanceof MTree.InternalNode || child instanceof MTree.LeafNode;
 		}
 	}
 
-
 	private class RootLeafNode extends Node {
-		
+
 		private RootLeafNode(DATA data) {
 			super(data, new RootNodeTrait(), new LeafNodeTrait());
 		}
-		
+
+		@Override
 		void removeData(DATA data, double distance) throws RootNodeReplacement, DataNotFound {
 			try {
 				super.removeData(data, distance);
@@ -957,11 +947,13 @@ void removeData(DATA data, double distance) throws RootNodeReplacement, DataNotF
 				throw new RootNodeReplacement(null);
 			}
 		}
-		
+
+		@Override
 		protected int getMinCapacity() {
 			return 1;
 		}
 
+		@Override
 		void _checkMinCapacity() {
 			assert children.size() >= 1;
 		}
@@ -972,23 +964,24 @@ private class RootNode extends Node {
 		private RootNode(DATA data) {
 			super(data, new RootNodeTrait(), new NonLeafNodeTrait());
 		}
-		
+
+		@Override
 		void removeData(DATA data, double distance) throws RootNodeReplacement, NodeUnderCapacity, DataNotFound {
 			try {
 				super.removeData(data, distance);
-			} catch(NodeUnderCapacity e) {
+			} catch (NodeUnderCapacity e) {
 				// Promote the only child to root
 				@SuppressWarnings("unchecked")
-				Node theChild = (Node)(children.values().iterator().next());
+				Node theChild = (Node) (children.values().iterator().next());
 				Node newRoot;
-				if(theChild instanceof MTree.InternalNode) {
+				if (theChild instanceof MTree.InternalNode) {
 					newRoot = new RootNode(theChild.data);
 				} else {
 					assert theChild instanceof MTree.LeafNode;
 					newRoot = new RootLeafNode(theChild.data);
 				}
 
-				for(IndexItem grandchild : theChild.children.values()) {
+				for (IndexItem grandchild : theChild.children.values()) {
 					distance = MTree.this.distanceFunction.calculate(newRoot.data, grandchild.data);
 					newRoot.addChild(grandchild, distance);
 				}
@@ -997,26 +990,23 @@ void removeData(DATA data, double distance) throws RootNodeReplacement, NodeUnde
 				throw new RootNodeReplacement(newRoot);
 			}
 		}
-		
-		
+
 		@Override
 		protected int getMinCapacity() {
 			return 2;
 		}
-		
+
 		@Override
 		void _checkMinCapacity() {
 			assert children.size() >= 2;
 		}
 	}
 
-
 	private class InternalNode extends Node {
 		private InternalNode(DATA data) {
 			super(data, new NonRootNodeTrait(), new NonLeafNodeTrait());
 		}
-	};
-
+	}
 
 	private class LeafNode extends Node {
 
@@ -1025,7 +1015,6 @@ public LeafNode(DATA data) {
 		}
 	}
 
-
 	private class Entry extends IndexItem {
 		private Entry(DATA data) {
 			super(data);
diff --git a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/PartitionFunction.java b/moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/PartitionFunction.java
similarity index 71%
rename from moa/src/main/java/moa/clusterers/outliers/utils/mtree/PartitionFunction.java
rename to moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/PartitionFunction.java
index 3247d171d..b95599080 100644
--- a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/PartitionFunction.java
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/PartitionFunction.java
@@ -11,14 +11,14 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
-package moa.clusterers.outliers.utils.mtree;
+package moa.learners.clusterers.outliers.utils.mtree;
 
 import java.util.Set;
 
-import moa.clusterers.outliers.utils.mtree.utils.Pair;
+import moa.learners.clusterers.outliers.utils.mtree.utils.Pair;
 
 /**
  * An object with partitions a set of data into two sub-sets.
@@ -26,18 +26,18 @@
  * @param <DATA> The type of the data on the sets.
  */
 public interface PartitionFunction<DATA> {
-	
+
 	/**
 	 * Executes the partitioning.
-	 * 
-	 * @param promoted The pair of data objects that will guide the partition
-	 *        process.
-	 * @param dataSet The original set of data objects to be partitioned.
-	 * @param distanceFunction A {@linkplain DistanceFunction distance function}
-	 *        to be used on the partitioning.
-	 * @return A pair of partition sub-sets. Each sub-set must correspond to one
-	 *         of the {@code promoted} data objects.
+	 *
+	 * @param promoted         The pair of data objects that will guide the
+	 *                         partition process.
+	 * @param dataSet          The original set of data objects to be partitioned.
+	 * @param distanceFunction A {@linkplain DistanceFunction distance function} to
+	 *                         be used on the partitioning.
+	 * @return A pair of partition sub-sets. Each sub-set must correspond to one of
+	 *         the {@code promoted} data objects.
 	 */
 	Pair<Set<DATA>> process(Pair<DATA> promoted, Set<DATA> dataSet, DistanceFunction<? super DATA> distanceFunction);
-	
+
 }
diff --git a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/PartitionFunctions.java b/moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/PartitionFunctions.java
similarity index 71%
rename from moa/src/main/java/moa/clusterers/outliers/utils/mtree/PartitionFunctions.java
rename to moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/PartitionFunctions.java
index 8b1acf17b..cf1367629 100644
--- a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/PartitionFunctions.java
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/PartitionFunctions.java
@@ -11,10 +11,10 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
-package moa.clusterers.outliers.utils.mtree;
+package moa.learners.clusterers.outliers.utils.mtree;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -23,7 +23,7 @@
 import java.util.List;
 import java.util.Set;
 
-import moa.clusterers.outliers.utils.mtree.utils.Pair;
+import moa.learners.clusterers.outliers.utils.mtree.utils.Pair;
 
 /**
  * Some pre-defined implementations of {@linkplain PartitionFunction partition
@@ -31,48 +31,47 @@
  */
 public final class PartitionFunctions {
 
-    /**
-     * Don't let anyone instantiate this class.
-     */
-	private PartitionFunctions() {}
-	
-	
 	/**
-	 * A {@linkplain PartitionFunction partition function} that tries to
-	 * distribute the data objects equally between the promoted data objects,
-	 * associating to each promoted data objects the nearest data objects.
-	 * 
+	 * Don't let anyone instantiate this class.
+	 */
+	private PartitionFunctions() {
+	}
+
+	/**
+	 * A {@linkplain PartitionFunction partition function} that tries to distribute
+	 * the data objects equally between the promoted data objects, associating to
+	 * each promoted data objects the nearest data objects.
+	 *
 	 * @param <DATA> The type of the data objects.
 	 */
 	public static class BalancedPartition<DATA> implements PartitionFunction<DATA> {
-		
+
 		/**
 		 * Processes the balanced partition.
+		 *
+		 * <p>
+		 * The algorithm is roughly equivalent to this:
 		 * 
-		 * <p>The algorithm is roughly equivalent to this:
 		 * <pre>
 		 *     While dataSet is not Empty:
 		 *         X := The object in dataSet which is nearest to promoted.<b>first</b>
 		 *         Remove X from dataSet
 		 *         Add X to result.<b>first</b>
-		 *         
+		 *
 		 *         Y := The object in dataSet which is nearest to promoted.<b>second</b>
 		 *         Remove Y from dataSet
 		 *         Add Y to result.<b>second</b>
-		 *         
+		 *
 		 *     Return result
 		 * </pre>
-		 * 
-		 * @see mtree.PartitionFunction#process(mtree.utils.Pair, java.util.Set, mtree.DistanceFunction)
+		 *
+		 * @see mtree.PartitionFunction#process(mtree.utils.Pair, java.util.Set,
+		 *      mtree.DistanceFunction)
 		 */
 		@Override
-		public Pair<Set<DATA>> process(
-				final Pair<DATA> promoted,
-				Set<DATA> dataSet,
-				final DistanceFunction<? super DATA> distanceFunction
-			)
-		{
-			List<DATA> queue1 = new ArrayList<DATA>(dataSet);
+		public Pair<Set<DATA>> process(final Pair<DATA> promoted, Set<DATA> dataSet,
+				final DistanceFunction<? super DATA> distanceFunction) {
+			List<DATA> queue1 = new ArrayList<>(dataSet);
 			// Sort by distance to the first promoted data
 			Collections.sort(queue1, new Comparator<DATA>() {
 				@Override
@@ -82,8 +81,8 @@ public int compare(DATA data1, DATA data2) {
 					return Double.compare(distance1, distance2);
 				}
 			});
-			
-			List<DATA> queue2 = new ArrayList<DATA>(dataSet);
+
+			List<DATA> queue2 = new ArrayList<>(dataSet);
 			// Sort by distance to the second promoted data
 			Collections.sort(queue2, new Comparator<DATA>() {
 				@Override
@@ -93,30 +92,30 @@ public int compare(DATA data1, DATA data2) {
 					return Double.compare(distance1, distance2);
 				}
 			});
-			
-			Pair<Set<DATA>> partitions = new Pair<Set<DATA>>(new HashSet<DATA>(), new HashSet<DATA>());
-			
+
+			Pair<Set<DATA>> partitions = new Pair<>(new HashSet<DATA>(), new HashSet<DATA>());
+
 			int index1 = 0;
 			int index2 = 0;
-	
-			while(index1 < queue1.size()  ||  index2 != queue2.size()) {
-				while(index1 < queue1.size()) {
+
+			while (index1 < queue1.size() || index2 != queue2.size()) {
+				while (index1 < queue1.size()) {
 					DATA data = queue1.get(index1++);
-					if(!partitions.second.contains(data)) {
+					if (!partitions.second.contains(data)) {
 						partitions.first.add(data);
 						break;
 					}
 				}
-	
-				while(index2 < queue2.size()) {
+
+				while (index2 < queue2.size()) {
 					DATA data = queue2.get(index2++);
-					if(!partitions.first.contains(data)) {
+					if (!partitions.first.contains(data)) {
 						partitions.second.add(data);
 						break;
 					}
 				}
 			}
-			
+
 			return partitions;
 		}
 	}
diff --git a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/PromotionFunction.java b/moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/PromotionFunction.java
similarity index 82%
rename from moa/src/main/java/moa/clusterers/outliers/utils/mtree/PromotionFunction.java
rename to moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/PromotionFunction.java
index b785b0566..de5f1e638 100644
--- a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/PromotionFunction.java
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/PromotionFunction.java
@@ -11,14 +11,14 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
-package moa.clusterers.outliers.utils.mtree;
+package moa.learners.clusterers.outliers.utils.mtree;
 
 import java.util.Set;
 
-import moa.clusterers.outliers.utils.mtree.utils.Pair;
+import moa.learners.clusterers.outliers.utils.mtree.utils.Pair;
 
 /**
  * An object that chooses a pair from a set of data objects.
@@ -26,16 +26,16 @@
  * @param <DATA> The type of the data objects.
  */
 public interface PromotionFunction<DATA> {
-	
+
 	/**
 	 * Chooses (promotes) a pair of objects according to some criteria that is
 	 * suitable for the application using the M-Tree.
-	 * 
-	 * @param dataSet The set of objects to choose a pair from.
-	 * @param distanceFunction A function that can be used for choosing the 
-	 *        promoted objects.
+	 *
+	 * @param dataSet          The set of objects to choose a pair from.
+	 * @param distanceFunction A function that can be used for choosing the promoted
+	 *                         objects.
 	 * @return A pair of chosen objects.
 	 */
 	Pair<DATA> process(Set<DATA> dataSet, DistanceFunction<? super DATA> distanceFunction);
-	
+
 }
diff --git a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/PromotionFunctions.java b/moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/PromotionFunctions.java
similarity index 73%
rename from moa/src/main/java/moa/clusterers/outliers/utils/mtree/PromotionFunctions.java
rename to moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/PromotionFunctions.java
index b603935b4..63e4b5582 100644
--- a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/PromotionFunctions.java
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/PromotionFunctions.java
@@ -11,16 +11,16 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
-package moa.clusterers.outliers.utils.mtree;
+package moa.learners.clusterers.outliers.utils.mtree;
 
 import java.util.List;
 import java.util.Set;
 
-import moa.clusterers.outliers.utils.mtree.utils.Pair;
-import moa.clusterers.outliers.utils.mtree.utils.Utils;
+import moa.learners.clusterers.outliers.utils.mtree.utils.Pair;
+import moa.learners.clusterers.outliers.utils.mtree.utils.Utils;
 
 /**
  * Some pre-defined implementations of {@linkplain PromotionFunction promotion
@@ -28,12 +28,12 @@
  */
 public final class PromotionFunctions {
 
-    /**
-     * Don't let anyone instantiate this class.
-     */
-	private PromotionFunctions() {}
-	
-	
+	/**
+	 * Don't let anyone instantiate this class.
+	 */
+	private PromotionFunctions() {
+	}
+
 	/**
 	 * A {@linkplain PromotionFunction promotion function} object that randomly
 	 * chooses ("promotes") two data objects.
@@ -42,12 +42,10 @@ private PromotionFunctions() {}
 	 */
 	public static class RandomPromotion<DATA> implements PromotionFunction<DATA> {
 		@Override
-		public Pair<DATA> process(Set<DATA> dataSet,
-				DistanceFunction<? super DATA> distanceFunction)
-		{
+		public Pair<DATA> process(Set<DATA> dataSet, DistanceFunction<? super DATA> distanceFunction) {
 			List<DATA> promotedList = Utils.randomSample(dataSet, 2);
-			return new Pair<DATA>(promotedList.get(0), promotedList.get(1));
+			return new Pair<>(promotedList.get(0), promotedList.get(1));
 		}
 	}
-	
+
 }
diff --git a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/SplitFunction.java b/moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/SplitFunction.java
similarity index 76%
rename from moa/src/main/java/moa/clusterers/outliers/utils/mtree/SplitFunction.java
rename to moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/SplitFunction.java
index f6d4e3700..d6eb44359 100644
--- a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/SplitFunction.java
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/SplitFunction.java
@@ -11,22 +11,23 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
-package moa.clusterers.outliers.utils.mtree;
+package moa.learners.clusterers.outliers.utils.mtree;
 
 import java.util.Set;
 
-import moa.clusterers.outliers.utils.mtree.utils.Pair;
+import moa.learners.clusterers.outliers.utils.mtree.utils.Pair;
 
 /**
  * Defines an object to be used to split a node in an M-Tree. A node must be
  * split when it has reached its maximum capacity and a new child node would be
  * added to it.
- * 
- * <p>The splitting consists in choosing a pair of "promoted" data objects from
- * the children and then partition the set of children in two partitions
+ *
+ * <p>
+ * The splitting consists in choosing a pair of "promoted" data objects from the
+ * children and then partition the set of children in two partitions
  * corresponding to the two promoted data objects.
  *
  * @param <DATA> The type of the data objects.
@@ -35,17 +36,16 @@ public interface SplitFunction<DATA> {
 
 	/**
 	 * Processes the splitting of a node.
-	 * 
-	 * @param dataSet A set of data that are keys to the children of the node
-	 *        to be split.
+	 *
+	 * @param dataSet          A set of data that are keys to the children of the
+	 *                         node to be split.
 	 * @param distanceFunction A {@linkplain DistanceFunction distance function}
-	 *        that can be used to help splitting the node.
-	 * @return A {@link SplitResult} object with a pair of promoted data objects
-	 *         and a pair of corresponding partitions of the data objects.
+	 *                         that can be used to help splitting the node.
+	 * @return A {@link SplitResult} object with a pair of promoted data objects and
+	 *         a pair of corresponding partitions of the data objects.
 	 */
 	SplitResult<DATA> process(Set<DATA> dataSet, DistanceFunction<? super DATA> distanceFunction);
-	
-	
+
 	/**
 	 * An object used as the result for the
 	 * {@link SplitFunction#process(Set, DistanceFunction)} method.
@@ -58,10 +58,9 @@ public static class SplitResult<DATA> {
 		 * A pair of promoted data objects.
 		 */
 		public Pair<DATA> promoted;
-		
+
 		/**
-		 * A pair of partitions corresponding to the {@code promoted} data
-		 * objects.
+		 * A pair of partitions corresponding to the {@code promoted} data objects.
 		 */
 		public Pair<Set<DATA>> partitions;
 
@@ -72,7 +71,7 @@ public SplitResult(Pair<DATA> promoted, Pair<Set<DATA>> partitions) {
 			this.promoted = promoted;
 			this.partitions = partitions;
 		}
-		
+
 	}
-	
+
 }
diff --git a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/utils/Pair.java b/moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/utils/Pair.java
similarity index 85%
rename from moa/src/main/java/moa/clusterers/outliers/utils/mtree/utils/Pair.java
rename to moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/utils/Pair.java
index 6f8d89daf..b536ecabb 100644
--- a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/utils/Pair.java
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/utils/Pair.java
@@ -11,10 +11,10 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
-package moa.clusterers.outliers.utils.mtree.utils;
+package moa.learners.clusterers.outliers.utils.mtree.utils;
 
 /**
  * A pair of objects of the same type.
@@ -22,25 +22,26 @@
  * @param <T> The type of the objects.
  */
 public class Pair<T> {
-	
+
 	/**
 	 * The first object.
 	 */
 	public T first;
-	
-	
+
 	/**
 	 * The second object.
 	 */
 	public T second;
-	
+
 	/**
 	 * Creates a pair of {@code null} objects.
 	 */
-	public Pair() {}
-	
+	public Pair() {
+	}
+
 	/**
 	 * Creates a pair with the objects specified in the arguments.
+	 * 
 	 * @param first  The first object.
 	 * @param second The second object.
 	 */
@@ -52,17 +53,21 @@ public Pair(T first, T second) {
 	/**
 	 * Accesses an object by its index. The {@link #first} object has index
 	 * {@code 0} and the {@link #second} object has index {@code 1}.
+	 * 
 	 * @param index The index of the object to be accessed.
 	 * @return The {@link #first} object if {@code index} is {@code 0}; the
 	 *         {@link #second} object if {@code index} is {@code 1}.
-	 * @throws IllegalArgumentException If {@code index} is neither {@code 0}
-	 *         or {@code 1}.
+	 * @throws IllegalArgumentException If {@code index} is neither {@code 0} or
+	 *                                  {@code 1}.
 	 */
 	public T get(int index) throws IllegalArgumentException {
-		switch(index) {
-		case 0: return first;
-		case 1: return second;
-		default: throw new IllegalArgumentException();
+		switch (index) {
+		case 0:
+			return first;
+		case 1:
+			return second;
+		default:
+			throw new IllegalArgumentException();
 		}
 	}
 
diff --git a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/utils/Utils.java b/moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/utils/Utils.java
similarity index 72%
rename from moa/src/main/java/moa/clusterers/outliers/utils/mtree/utils/Utils.java
rename to moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/utils/Utils.java
index 140a8110e..5ecb146c3 100644
--- a/moa/src/main/java/moa/clusterers/outliers/utils/mtree/utils/Utils.java
+++ b/moa/src/main/java/moa/learners/clusterers/outliers/utils/mtree/utils/Utils.java
@@ -11,10 +11,10 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
-package moa.clusterers.outliers.utils.mtree.utils;
+package moa.learners.clusterers.outliers.utils.mtree.utils;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -27,64 +27,65 @@
  */
 public final class Utils {
 
-    /**
-     * Don't let anyone instantiate this class.
-     */
-	private Utils() {}
+	/**
+	 * Don't let anyone instantiate this class.
+	 */
+	private Utils() {
+	}
 
-	
 	/**
-	 * Identifies the minimum and maximum elements from an iterable, according
-	 * to the natural ordering of the elements.
+	 * Identifies the minimum and maximum elements from an iterable, according to
+	 * the natural ordering of the elements.
+	 * 
 	 * @param items An {@link Iterable} object with the elements
-	 * @param <T> The type of the elements.
+	 * @param <T>   The type of the elements.
 	 * @return A pair with the minimum and maximum elements.
 	 */
 	public static <T extends Comparable<T>> Pair<T> minMax(Iterable<T> items) {
 		Iterator<T> iterator = items.iterator();
-		if(!iterator.hasNext()) {
+		if (!iterator.hasNext()) {
 			return null;
 		}
-		
+
 		T min = iterator.next();
 		T max = min;
-		
-		while(iterator.hasNext()) {
+
+		while (iterator.hasNext()) {
 			T item = iterator.next();
-			if(item.compareTo(min) < 0) {
+			if (item.compareTo(min) < 0) {
 				min = item;
 			}
-			if(item.compareTo(max) > 0) {
+			if (item.compareTo(max) > 0) {
 				max = item;
 			}
 		}
-		
-		return new Pair<T>(min, max);
+
+		return new Pair<>(min, max);
 	}
-	
-	
+
 	/**
 	 * Randomly chooses elements from the collection.
+	 * 
 	 * @param collection The collection.
-	 * @param n The number of elements to choose.
-	 * @param <T> The type of the elements.
+	 * @param n          The number of elements to choose.
+	 * @param <T>        The type of the elements.
 	 * @return A list with the chosen elements.
 	 */
 	public static <T> List<T> randomSample(Collection<T> collection, int n) {
-		List<T> list = new ArrayList<T>(collection);
-		List<T> sample = new ArrayList<T>(n);
+		List<T> list = new ArrayList<>(collection);
+		List<T> sample = new ArrayList<>(n);
 		Random random = new Random();
-		while(n > 0  &&  !list.isEmpty()) {
+		while (n > 0 && !list.isEmpty()) {
 			int index = random.nextInt(list.size());
 			sample.add(list.get(index));
 			int indexLast = list.size() - 1;
 			T last = list.remove(indexLast);
-			if(index < indexLast) {
+			if (index < indexLast) {
 				list.set(index, last);
 			}
 			n--;
 		}
 		return sample;
 	}
-	
+
 }
diff --git a/moa/src/main/java/moa/learners/clusterers/streamkm/BucketManager.java b/moa/src/main/java/moa/learners/clusterers/streamkm/BucketManager.java
new file mode 100644
index 000000000..d5370e13b
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/streamkm/BucketManager.java
@@ -0,0 +1,157 @@
+package moa.learners.clusterers.streamkm;
+
+/**
+ *
+ * @author Marcel R. Ackermann, Christiane Lammersen, Marcus Maertens, Christoph
+ *         Raupach, Christian Sohler, Kamil Swierkot
+ * 
+ *         Modified by Richard Hugh Moulton (24 Jul 2017)
+ */
+public class BucketManager {
+
+	protected class Bucket {
+		int cursize;
+		Point[] points;
+		Point[] spillover;
+
+		public Bucket(int d, int maxsize) {
+			this.cursize = 0;
+			this.points = new Point[maxsize];
+			this.spillover = new Point[maxsize];
+			for (int i = 0; i < maxsize; i++) {
+				this.points[i] = new Point(d);
+				this.spillover[i] = new Point(d);
+			}
+		}
+
+	}
+
+	protected int numberOfBuckets;
+	protected int maxBucketsize;
+	protected Bucket[] buckets;
+	protected MTRandom clustererRandom;
+	protected TreeCoreset treeCoreset;
+
+	/**
+	 * initializes a bucketmanager for n points with bucketsize maxsize and
+	 * dimension d
+	 **/
+	public BucketManager(int n, int d, int maxsize, MTRandom random) {
+		this.clustererRandom = random;
+		this.numberOfBuckets = (int) Math.ceil(Math.log((double) n / (double) maxsize) / Math.log(2)) + 2;
+		this.maxBucketsize = maxsize;
+		this.buckets = new Bucket[this.numberOfBuckets];
+		for (int i = 0; i < this.numberOfBuckets; i++) {
+			this.buckets[i] = new Bucket(d, maxsize);
+		}
+		this.treeCoreset = new TreeCoreset();
+		// printf("Created manager with %d buckets of dimension %d
+		// \n",this.numberOfBuckets,d);
+	}
+
+	/**
+	 * inserts a single point into the bucketmanager
+	 **/
+	void insertPoint(Point p) {
+
+		// check if there is enough space in the first bucket
+		int cursize = this.buckets[0].cursize;
+		if (cursize >= this.maxBucketsize) {
+			// printf("Bucket 0 full \n");
+			// start spillover process
+			int curbucket = 0;
+			int nextbucket = 1;
+
+			// check if the next bucket is empty
+			if (this.buckets[nextbucket].cursize == 0) {
+				// copy the bucket
+				int i;
+				for (i = 0; i < this.maxBucketsize; i++) {
+					this.buckets[nextbucket].points[i] = this.buckets[curbucket].points[i].clone();
+					// copyPointWithoutInit: we should not copy coordinates?
+				}
+				// bucket is now full
+				this.buckets[nextbucket].cursize = this.maxBucketsize;
+				// first bucket is now empty
+				this.buckets[curbucket].cursize = 0;
+				cursize = 0;
+			} else {
+				// printf("Bucket %d full \n",nextbucket);
+				// copy bucket to spillover and continue
+				int i;
+				for (i = 0; i < this.maxBucketsize; i++) {
+					this.buckets[nextbucket].spillover[i] = this.buckets[curbucket].points[i].clone();
+					// copyPointWithoutInit: we should not copy coordinates?
+				}
+				this.buckets[0].cursize = 0;
+				cursize = 0;
+				curbucket++;
+				nextbucket++;
+				/*
+				 * as long as the next bucket is full output the coreset to the spillover of the
+				 * next bucket
+				 */
+				while (this.buckets[nextbucket].cursize == this.maxBucketsize) {
+					// printf("Bucket %d full \n",nextbucket);
+					this.treeCoreset.unionTreeCoreset(this.maxBucketsize, this.maxBucketsize, this.maxBucketsize,
+							p.dimension, this.buckets[curbucket].points, this.buckets[curbucket].spillover,
+							this.buckets[nextbucket].spillover, this.clustererRandom);
+					// bucket now empty
+					this.buckets[curbucket].cursize = 0;
+					curbucket++;
+					nextbucket++;
+				}
+				this.treeCoreset.unionTreeCoreset(this.maxBucketsize, this.maxBucketsize, this.maxBucketsize,
+						p.dimension, this.buckets[curbucket].points, this.buckets[curbucket].spillover,
+						this.buckets[nextbucket].points, this.clustererRandom);
+				this.buckets[curbucket].cursize = 0;
+				this.buckets[nextbucket].cursize = this.maxBucketsize;
+			}
+		}
+		// insert point into the first bucket
+		this.buckets[0].points[cursize] = p.clone();
+		// copyPointWithoutInit: we should not copy coordinates?
+		this.buckets[0].cursize++;
+	}
+
+	/**
+	 * It may happen that the manager is not full (since n is not always a power of
+	 * 2). In this case we extract the coreset from the manager by computing a
+	 * coreset of all nonempty buckets
+	 * 
+	 * Case 1: the last bucket is full => n is a power of 2 and we return the
+	 * contents of the last bucket
+	 * 
+	 * Case2: the last bucket is not full => we compute a coreset of all nonempty
+	 * buckets
+	 * 
+	 * this operation should only be called after the streaming process is finished
+	 **/
+	Point[] getCoresetFromManager(int d) {
+		Point[] coreset = new Point[d];
+		int i = 0;
+		// if(this.buckets[this.numberOfBuckets-1].cursize == this.maxBucketsize){
+		// coreset = this.buckets[this.numberOfBuckets-1].points;
+
+		// } else {
+		// find the first nonempty bucket
+		for (i = 0; i < this.numberOfBuckets; i++) {
+			if (this.buckets[i].cursize != 0) {
+				coreset = this.buckets[i].points;
+				break;
+			}
+		}
+		// as long as there is a nonempty bucket compute a coreset
+		int j;
+		for (j = i + 1; j < this.numberOfBuckets; j++) {
+			if (this.buckets[j].cursize != 0) {
+				// output the coreset into the spillover of bucket j
+				this.treeCoreset.unionTreeCoreset(this.maxBucketsize, this.maxBucketsize, this.maxBucketsize, d,
+						this.buckets[j].points, coreset, this.buckets[j].spillover, this.clustererRandom);
+				coreset = this.buckets[j].spillover;
+			}
+		}
+		// }
+		return coreset;
+	}
+}
diff --git a/moa/src/main/java/moa/clusterers/streamkm/CoresetCostTriple.java b/moa/src/main/java/moa/learners/clusterers/streamkm/CoresetCostTriple.java
similarity index 80%
rename from moa/src/main/java/moa/clusterers/streamkm/CoresetCostTriple.java
rename to moa/src/main/java/moa/learners/clusterers/streamkm/CoresetCostTriple.java
index e08076898..ed9af1e95 100644
--- a/moa/src/main/java/moa/clusterers/streamkm/CoresetCostTriple.java
+++ b/moa/src/main/java/moa/learners/clusterers/streamkm/CoresetCostTriple.java
@@ -1,51 +1,52 @@
-package moa.clusterers.streamkm;
+package moa.learners.clusterers.streamkm;
 
 /**
- * 
- * CoresetCostTriple is a wrapper that allows the lloydPlusPlus method in StreamKM to return the coresetCentres,
- * radii of the associated clusters and the cost associated with the coreset.
- * 
+ *
+ * CoresetCostTriple is a wrapper that allows the lloydPlusPlus method in
+ * StreamKM to return the coresetCentres, radii of the associated clusters and
+ * the cost associated with the coreset.
+ *
  * @author Richard Hugh Moulton
  *
  */
 
-public class CoresetCostTriple
-{
+public class CoresetCostTriple {
 	private Point[] coresetCentres;
 	private double[] radii;
 	private double coresetCost;
-	
-	public CoresetCostTriple(Point[] centres, double[] rad, double cost)
-	{
+
+	public CoresetCostTriple(Point[] centres, double[] rad, double cost) {
 		this.coresetCentres = new Point[centres.length];
-				
-		for (int i = 0 ; i < centres.length ; i++)
-		{
+
+		for (int i = 0; i < centres.length; i++) {
 			this.coresetCentres[i] = centres[i].clone();
 		}
-		
+
 		this.radii = rad.clone();
 		this.coresetCost = cost;
 	}
-	
+
 	/**
 	 * @return the coresetCentres
 	 */
 	public Point[] getCoresetCentres() {
 		return coresetCentres;
 	}
+
 	/**
 	 * @param coresetCentres the coresetCentres to set
 	 */
 	public void setCoresetCentres(Point[] coresetCentres) {
 		this.coresetCentres = coresetCentres;
 	}
+
 	/**
 	 * @return the coresetCost
 	 */
 	public double getCoresetCost() {
 		return coresetCost;
 	}
+
 	/**
 	 * @param coresetCost the coresetCost to set
 	 */
diff --git a/moa/src/main/java/moa/learners/clusterers/streamkm/MTRandom.java b/moa/src/main/java/moa/learners/clusterers/streamkm/MTRandom.java
new file mode 100644
index 000000000..edc7c9444
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/streamkm/MTRandom.java
@@ -0,0 +1,410 @@
+/*
+ * MTRandom : A Java implementation of the MT19937 (Mersenne Twister)
+ *            pseudo random number generator algorithm based upon the
+ *            original C code by Makoto Matsumoto and Takuji Nishimura.
+ * Author   : David Beaumont
+ * Email    : mersenne-at-www.goui.net
+ *
+ * For the original C code, see:
+ *     http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
+ *
+ * This version, Copyright (C) 2005, David Beaumont.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package moa.learners.clusterers.streamkm;
+
+import java.util.Random;
+
+/**
+ * @version 1.0
+ * @author David Beaumont, Copyright 2005
+ *         <p>
+ *         A Java implementation of the MT19937 (Mersenne Twister) pseudo random
+ *         number generator algorithm based upon the original C code by Makoto
+ *         Matsumoto and Takuji Nishimura (see
+ *         <a href="http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html">
+ *         http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html</a> for more
+ *         information.
+ *         <p>
+ *         As a subclass of java.util.Random this class provides a single
+ *         canonical method next() for generating bits in the pseudo random
+ *         number sequence. Anyone using this class should invoke the public
+ *         inherited methods (nextInt(), nextFloat etc.) to obtain values as
+ *         normal. This class should provide a drop-in replacement for the
+ *         standard implementation of java.util.Random with the additional
+ *         advantage of having a far longer period and the ability to use a far
+ *         larger seed value.
+ *         <p>
+ *         This is <b>not</b> a cryptographically strong source of randomness
+ *         and should <b>not</b> be used for cryptographic systems or in any
+ *         other situation where true random numbers are required.
+ *         <p>
+ *         <!-- Creative Commons License -->
+ *         <a href="http://creativecommons.org/licenses/LGPL/2.1/"><img alt=
+ *         "CC-GNU LGPL" border="0" src=
+ *         "http://creativecommons.org/images/public/cc-LGPL-a.png" /></a><br />
+ *         This software is licensed under the
+ *         <a href="http://creativecommons.org/licenses/LGPL/2.1/">CC-GNU
+ *         LGPL</a>. <!-- /Creative Commons License -->
+ *
+ *         <!-- <rdf:RDF xmlns="http://web.resource.org/cc/" xmlns:dc=
+ *         "http://purl.org/dc/elements/1.1/" xmlns:rdf=
+ *         "http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+ * 
+ *         <Work rdf:about="">
+ *         <license rdf:resource="http://creativecommons.org/licenses/LGPL/2.1/"
+ *         /> <dc:type rdf:resource="http://purl.org/dc/dcmitype/Software" />
+ *         </Work>
+ *
+ *         <License rdf:about="http://creativecommons.org/licenses/LGPL/2.1/">
+ *         <permits rdf:resource="http://web.resource.org/cc/Reproduction" />
+ *         <permits rdf:resource="http://web.resource.org/cc/Distribution" />
+ *         <requires rdf:resource="http://web.resource.org/cc/Notice" />
+ *         <permits rdf:resource="http://web.resource.org/cc/DerivativeWorks" />
+ *         <requires rdf:resource="http://web.resource.org/cc/ShareAlike" />
+ *         <requires rdf:resource="http://web.resource.org/cc/SourceCode" />
+ *         </License>
+ *
+ *         </rdf:RDF> -->
+ *
+ */
+public class MTRandom extends Random {
+
+	/**
+	 * Auto-generated serial version UID. Note that MTRandom does NOT support
+	 * serialisation of its internal state and it may even be necessary to implement
+	 * read/write methods to re-seed it properly. This is only here to make Eclipse
+	 * shut up about it being missing.
+	 */
+	private static final long serialVersionUID = -515082678588212038L;
+
+	// Constants used in the original C implementation
+	private final static int UPPER_MASK = 0x80000000;
+	private final static int LOWER_MASK = 0x7fffffff;
+
+	private final static int N = 624;
+	private final static int M = 397;
+	private final static int MAGIC[] = { 0x0, 0x9908b0df };
+	private final static int MAGIC_FACTOR1 = 1812433253;
+	private final static int MAGIC_FACTOR2 = 1664525;
+	private final static int MAGIC_FACTOR3 = 1566083941;
+	private final static int MAGIC_MASK1 = 0x9d2c5680;
+	private final static int MAGIC_MASK2 = 0xefc60000;
+	private final static int MAGIC_SEED = 19650218;
+	private final static long DEFAULT_SEED = 5489L;
+
+	// Internal state
+	private transient int[] mt;
+	private transient int mti;
+	private transient boolean compat = false;
+
+	// Temporary buffer used during setSeed(long)
+	private transient int[] ibuf;
+
+	/**
+	 * The default constructor for an instance of MTRandom. This invokes the
+	 * no-argument constructor for java.util.Random which will result in the class
+	 * being initialised with a seed value obtained by calling
+	 * System.currentTimeMillis().
+	 */
+	public MTRandom() {
+	}
+
+	/**
+	 * This version of the constructor can be used to implement identical behaviour
+	 * to the original C code version of this algorithm including exactly
+	 * replicating the case where the seed value had not been set prior to calling
+	 * genrand_int32.
+	 * <p>
+	 * If the compatibility flag is set to true, then the algorithm will be seeded
+	 * with the same default value as was used in the original C code. Furthermore
+	 * the setSeed() method, which must take a 64 bit long value, will be limited to
+	 * using only the lower 32 bits of the seed to facilitate seamless migration of
+	 * existing C code into Java where identical behaviour is required.
+	 * <p>
+	 * Whilst useful for ensuring backwards compatibility, it is advised that this
+	 * feature not be used unless specifically required, due to the reduction in
+	 * strength of the seed value.
+	 *
+	 * @param compatible Compatibility flag for replicating original behaviour.
+	 */
+	public MTRandom(boolean compatible) {
+		super(0L);
+		compat = compatible;
+		setSeed(compat ? DEFAULT_SEED : System.currentTimeMillis());
+	}
+
+	/**
+	 * This version of the constructor simply initialises the class with the given
+	 * 64 bit seed value. For a better random number sequence this seed value should
+	 * contain as much entropy as possible.
+	 *
+	 * @param seed The seed value with which to initialise this class.
+	 */
+	public MTRandom(long seed) {
+		super(seed);
+	}
+
+	/**
+	 * This version of the constructor initialises the class with the given byte
+	 * array. All the data will be used to initialise this instance.
+	 *
+	 * @param buf The non-empty byte array of seed information.
+	 * @throws NullPointerException     if the buffer is null.
+	 * @throws IllegalArgumentException if the buffer has zero length.
+	 */
+	public MTRandom(byte[] buf) {
+		super(0L);
+		setSeed(buf);
+	}
+
+	/**
+	 * This version of the constructor initialises the class with the given integer
+	 * array. All the data will be used to initialise this instance.
+	 *
+	 * @param buf The non-empty integer array of seed information.
+	 * @throws NullPointerException     if the buffer is null.
+	 * @throws IllegalArgumentException if the buffer has zero length.
+	 */
+	public MTRandom(int[] buf) {
+		super(0L);
+		setSeed(buf);
+	}
+
+	// Initializes mt[N] with a simple integer seed. This method is
+	// required as part of the Mersenne Twister algorithm but need
+	// not be made public.
+	private final void setSeed(int seed) {
+
+		// Annoying runtime check for initialisation of internal data
+		// caused by java.util.Random invoking setSeed() during init.
+		// This is unavoidable because no fields in our instance will
+		// have been initialised at this point, not even if the code
+		// were placed at the declaration of the member variable.
+		if (mt == null)
+			mt = new int[N];
+
+		// ---- Begin Mersenne Twister Algorithm ----
+		mt[0] = seed;
+		for (mti = 1; mti < N; mti++) {
+			mt[mti] = (MAGIC_FACTOR1 * (mt[mti - 1] ^ (mt[mti - 1] >>> 30)) + mti);
+		}
+		// ---- End Mersenne Twister Algorithm ----
+	}
+
+	/**
+	 * This method resets the state of this instance using the 64 bits of seed data
+	 * provided. Note that if the same seed data is passed to two different
+	 * instances of MTRandom (both of which share the same compatibility state) then
+	 * the sequence of numbers generated by both instances will be identical.
+	 * <p>
+	 * If this instance was initialised in 'compatibility' mode then this method
+	 * will only use the lower 32 bits of any seed value passed in and will match
+	 * the behaviour of the original C code exactly with respect to state
+	 * initialisation.
+	 *
+	 * @param seed The 64 bit value used to initialise the random number generator
+	 *             state.
+	 */
+	@Override
+	public final synchronized void setSeed(long seed) {
+		if (compat) {
+			setSeed((int) seed);
+		} else {
+
+			// Annoying runtime check for initialisation of internal data
+			// caused by java.util.Random invoking setSeed() during init.
+			// This is unavoidable because no fields in our instance will
+			// have been initialised at this point, not even if the code
+			// were placed at the declaration of the member variable.
+			if (ibuf == null)
+				ibuf = new int[2];
+
+			ibuf[0] = (int) seed;
+			ibuf[1] = (int) (seed >>> 32);
+			setSeed(ibuf);
+		}
+	}
+
+	/**
+	 * This method resets the state of this instance using the byte array of seed
+	 * data provided. Note that calling this method is equivalent to calling
+	 * "setSeed(pack(buf))" and in particular will result in a new integer array
+	 * being generated during the call. If you wish to retain this seed data to
+	 * allow the pseudo random sequence to be restarted then it would be more
+	 * efficient to use the "pack()" method to convert it into an integer array
+	 * first and then use that to re-seed the instance. The behaviour of the class
+	 * will be the same in both cases but it will be more efficient.
+	 *
+	 * @param buf The non-empty byte array of seed information.
+	 * @throws NullPointerException     if the buffer is null.
+	 * @throws IllegalArgumentException if the buffer has zero length.
+	 */
+	public final void setSeed(byte[] buf) {
+		setSeed(pack(buf));
+	}
+
+	/**
+	 * This method resets the state of this instance using the integer array of seed
+	 * data provided. This is the canonical way of resetting the pseudo random
+	 * number sequence.
+	 *
+	 * @param buf The non-empty integer array of seed information.
+	 * @throws NullPointerException     if the buffer is null.
+	 * @throws IllegalArgumentException if the buffer has zero length.
+	 */
+	public final synchronized void setSeed(int[] buf) {
+		int length = buf.length;
+		if (length == 0)
+			throw new IllegalArgumentException("Seed buffer may not be empty");
+		// ---- Begin Mersenne Twister Algorithm ----
+		int i = 1, j = 0, k = (N > length ? N : length);
+		setSeed(MAGIC_SEED);
+		for (; k > 0; k--) {
+			mt[i] = (mt[i] ^ ((mt[i - 1] ^ (mt[i - 1] >>> 30)) * MAGIC_FACTOR2)) + buf[j] + j;
+			i++;
+			j++;
+			if (i >= N) {
+				mt[0] = mt[N - 1];
+				i = 1;
+			}
+			if (j >= length)
+				j = 0;
+		}
+		for (k = N - 1; k > 0; k--) {
+			mt[i] = (mt[i] ^ ((mt[i - 1] ^ (mt[i - 1] >>> 30)) * MAGIC_FACTOR3)) - i;
+			i++;
+			if (i >= N) {
+				mt[0] = mt[N - 1];
+				i = 1;
+			}
+		}
+		mt[0] = UPPER_MASK; // MSB is 1; assuring non-zero initial array
+		// ---- End Mersenne Twister Algorithm ----
+	}
+
+	/**
+	 * This method forms the basis for generating a pseudo random number sequence
+	 * from this class. If given a value of 32, this method behaves identically to
+	 * the genrand_int32 function in the original C code and ensures that using the
+	 * standard nextInt() function (inherited from Random) we are able to replicate
+	 * behaviour exactly.
+	 * <p>
+	 * Note that where the number of bits requested is not equal to 32 then bits
+	 * will simply be masked out from the top of the returned integer value. That is
+	 * to say that:
+	 * 
+	 * <pre>
+	 * mt.setSeed(12345);
+	 * int foo = mt.nextInt(16) + (mt.nextInt(16) << 16);
+	 * </pre>
+	 * 
+	 * will not give the same result as
+	 * 
+	 * <pre>
+	 * mt.setSeed(12345);
+	 * int foo = mt.nextInt(32);
+	 * </pre>
+	 *
+	 * @param bits The number of significant bits desired in the output.
+	 * @return The next value in the pseudo random sequence with the specified
+	 *         number of bits in the lower part of the integer.
+	 */
+	@Override
+	protected final synchronized int next(int bits) {
+		// ---- Begin Mersenne Twister Algorithm ----
+		int y, kk;
+		if (mti >= N) { // generate N words at one time
+
+			// In the original C implementation, mti is checked here
+			// to determine if initialisation has occurred; if not
+			// it initialises this instance with DEFAULT_SEED (5489).
+			// This is no longer necessary as initialisation of the
+			// Java instance must result in initialisation occurring
+			// Use the constructor MTRandom(true) to enable backwards
+			// compatible behaviour.
+
+			for (kk = 0; kk < N - M; kk++) {
+				y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK);
+				mt[kk] = mt[kk + M] ^ (y >>> 1) ^ MAGIC[y & 0x1];
+			}
+			for (; kk < N - 1; kk++) {
+				y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK);
+				mt[kk] = mt[kk + (M - N)] ^ (y >>> 1) ^ MAGIC[y & 0x1];
+			}
+			y = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK);
+			mt[N - 1] = mt[M - 1] ^ (y >>> 1) ^ MAGIC[y & 0x1];
+
+			mti = 0;
+		}
+
+		y = mt[mti++];
+
+		// Tempering
+		y ^= (y >>> 11);
+		y ^= (y << 7) & MAGIC_MASK1;
+		y ^= (y << 15) & MAGIC_MASK2;
+		y ^= (y >>> 18);
+		// ---- End Mersenne Twister Algorithm ----
+		return (y >>> (32 - bits));
+	}
+
+	// This is a fairly obscure little code section to pack a
+	// byte[] into an int[] in little endian ordering.
+
+	/**
+	 * This simply utility method can be used in cases where a byte array of seed
+	 * data is to be used to repeatedly re-seed the random number sequence. By
+	 * packing the byte array into an integer array first, using this method, and
+	 * then invoking setSeed() with that; it removes the need to re-pack the byte
+	 * array each time setSeed() is called.
+	 * <p>
+	 * If the length of the byte array is not a multiple of 4 then it is implicitly
+	 * padded with zeros as necessary. For example:
+	 * 
+	 * <pre>
+	 *     byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 }
+	 * </pre>
+	 * 
+	 * becomes
+	 * 
+	 * <pre>
+	 *     int[]  { 0x04030201, 0x00000605 }
+	 * </pre>
+	 * <p>
+	 * Note that this method will not complain if the given byte array is empty and
+	 * will produce an empty integer array, but the setSeed() method will throw an
+	 * exception if the empty integer array is passed to it.
+	 *
+	 * @param buf The non-null byte array to be packed.
+	 * @return A non-null integer array of the packed bytes.
+	 * @throws NullPointerException if the given byte array is null.
+	 */
+	public static int[] pack(byte[] buf) {
+		int k, blen = buf.length, ilen = ((buf.length + 3) >>> 2);
+		int[] ibuf = new int[ilen];
+		for (int n = 0; n < ilen; n++) {
+			int m = (n + 1) << 2;
+			if (m > blen)
+				m = blen;
+			for (k = buf[--m] & 0xff; (m & 0x3) != 0; k = (k << 8) | buf[--m] & 0xff)
+				;
+			ibuf[n] = k;
+		}
+		return ibuf;
+	}
+}
diff --git a/moa/src/main/java/moa/clusterers/streamkm/Point.java b/moa/src/main/java/moa/learners/clusterers/streamkm/Point.java
similarity index 54%
rename from moa/src/main/java/moa/clusterers/streamkm/Point.java
rename to moa/src/main/java/moa/learners/clusterers/streamkm/Point.java
index e2966c069..ab6406d88 100644
--- a/moa/src/main/java/moa/clusterers/streamkm/Point.java
+++ b/moa/src/main/java/moa/learners/clusterers/streamkm/Point.java
@@ -1,4 +1,4 @@
-package moa.clusterers.streamkm;
+package moa.learners.clusterers.streamkm;
 
 import com.yahoo.labs.samoa.instances.Instance;
 
@@ -7,28 +7,28 @@
 
 /**
  *
- * @author Marcel R. Ackermann, Christiane Lammersen, Marcus Maertens, Christoph Raupach, 
-Christian Sohler, Kamil Swierkot
+ * @author Marcel R. Ackermann, Christiane Lammersen, Marcus Maertens, Christoph
+ *         Raupach, Christian Sohler, Kamil Swierkot
  */
 public class Point {
 
-	//dimension
+	// dimension
 	int dimension;
 
-	//Clustering Features (weight, squareSum, linearSum)
+	// Clustering Features (weight, squareSum, linearSum)
 	double weight;
 	double squareSum;
 	double[] coordinates;
 
-	//cost and index of the centre, the point is currently assigned to
+	// cost and index of the centre, the point is currently assigned to
 	double curCost;
 	int centreIndex;
-	
-	//id and class (if there is class information in the file)
+
+	// id and class (if there is class information in the file)
 	int id;
 	int cl;
 
-	public Point(int dimension){
+	public Point(int dimension) {
 		this.weight = 1.0;
 		this.squareSum = 0.0;
 		this.dimension = dimension;
@@ -37,12 +37,12 @@ public Point(int dimension){
 		this.cl = -1;
 		this.curCost = 0;
 		this.centreIndex = -1;
-		for(int l=0;l<dimension;l++){
+		for (int l = 0; l < dimension; l++) {
 			this.coordinates[l] = 0.0;
 		}
 	}
-	
-	public Point(Instance inst, int id){
+
+	public Point(Instance inst, int id) {
 		this.weight = inst.weight();
 		this.squareSum = 0.0;
 		this.dimension = inst.numAttributes();
@@ -51,14 +51,15 @@ public Point(Instance inst, int id){
 		this.cl = 0;// NOT USED (int) inst.classValue();
 		this.curCost = 0;
 		this.centreIndex = -1;
-		for(int l=0;l<this.dimension;l++){
+		for (int l = 0; l < this.dimension; l++) {
 			double nextNumber = inst.value(l) * inst.value(l);
 			this.coordinates[l] = inst.value(l);
-			this.squareSum += nextNumber*nextNumber;
+			this.squareSum += nextNumber * nextNumber;
 		}
 	}
-		
-	public Point clone(){
+
+	@Override
+	public Point clone() {
 		Point res = new Point(this.dimension);
 		res.weight = this.weight;
 		res.squareSum = this.squareSum;
@@ -70,124 +71,122 @@ public Point clone(){
 		res.centreIndex = this.centreIndex;
 		return res;
 	}
-	
-	public Cluster toCluster(double radius){
-		//Convert point to Cluster
+
+	public Cluster toCluster(double radius) {
+		// Convert point to Cluster
 		double[] centre = new double[this.dimension];
-		
-		for (int i = 0 ; i < this.dimension ; i++)
-		{
-			centre[i] = this.coordinates[i]/this.weight;
+
+		for (int i = 0; i < this.dimension; i++) {
+			centre[i] = this.coordinates[i] / this.weight;
 		}
-		
+
 		return (new SphereCluster(centre, radius, this.weight));
-		
+
 	}
 
 	/**
-	Computes the cost of this point with the given array of centres centres[] (of size k)
-	**/
-	public double costOfPoint(int k, Point[] centres){
+	 * Computes the cost of this point with the given array of centres centres[] (of
+	 * size k)
+	 **/
+	public double costOfPoint(int k, Point[] centres) {
 		double nearestCost = -1.0;
-		for(int j=0; j<k; j++){
+		for (int j = 0; j < k; j++) {
 			double distance = 0.0;
 			int l = 0;
-			for(l=0;l<this.dimension;l++){
-				//Centroid coordinate of the point
+			for (l = 0; l < this.dimension; l++) {
+				// Centroid coordinate of the point
 				double centroidCoordinatePoint;
-				if(this.weight != 0.0){
+				if (this.weight != 0.0) {
 					centroidCoordinatePoint = this.coordinates[l] / this.weight;
 				} else {
 					centroidCoordinatePoint = this.coordinates[l];
 				}
-				//Centroid coordinate of the centre
+				// Centroid coordinate of the centre
 				double centroidCoordinateCentre;
-				if(centres[j].weight != 0.0){
+				if (centres[j].weight != 0.0) {
 					centroidCoordinateCentre = centres[j].coordinates[l] / centres[j].weight;
 				} else {
 					centroidCoordinateCentre = centres[j].coordinates[l];
 				}
-				distance += (centroidCoordinatePoint-centroidCoordinateCentre) * 
-						(centroidCoordinatePoint-centroidCoordinateCentre) ;
+				distance += (centroidCoordinatePoint - centroidCoordinateCentre)
+						* (centroidCoordinatePoint - centroidCoordinateCentre);
 			}
-			
-			if(nearestCost <0 || distance < nearestCost) {
+
+			if (nearestCost < 0 || distance < nearestCost) {
 				nearestCost = distance;
-			} 
+			}
 		}
 		return this.weight * nearestCost;
 	}
 
-
 	/**
-	Computes the index of the centre nearest to this point with the given array of centres centres[] (of size k)
-	**/
-	public int determineClusterCentreKMeans(int k, Point[] centres){
+	 * Computes the index of the centre nearest to this point with the given array
+	 * of centres centres[] (of size k)
+	 **/
+	public int determineClusterCentreKMeans(int k, Point[] centres) {
 		int centre = 0;
 		double nearestCost = -1.0;
-		for(int j=0; j < k; j++){
+		for (int j = 0; j < k; j++) {
 			double distance = 0.0;
-			for(int l=0; l<this.dimension;l++){
-				//Centroid coordinate of the point
+			for (int l = 0; l < this.dimension; l++) {
+				// Centroid coordinate of the point
 				double centroidCoordinatePoint;
-				if(this.weight != 0.0){
+				if (this.weight != 0.0) {
 					centroidCoordinatePoint = this.coordinates[l] / this.weight;
 				} else {
 					centroidCoordinatePoint = this.coordinates[l];
 				}
-				//Centroid coordinate of the centre
+				// Centroid coordinate of the centre
 				double centroidCoordinateCentre;
-				if(centres[j].weight != 0.0){
+				if (centres[j].weight != 0.0) {
 					centroidCoordinateCentre = centres[j].coordinates[l] / centres[j].weight;
 				} else {
 					centroidCoordinateCentre = centres[j].coordinates[l];
 				}
-				distance += (centroidCoordinatePoint-centroidCoordinateCentre) * 
-						(centroidCoordinatePoint-centroidCoordinateCentre) ;
+				distance += (centroidCoordinatePoint - centroidCoordinateCentre)
+						* (centroidCoordinatePoint - centroidCoordinateCentre);
 			}
-			
-			if(nearestCost <0 || distance < nearestCost) {
+
+			if (nearestCost < 0 || distance < nearestCost) {
 				nearestCost = distance;
 				centre = j;
-			} 
+			}
 		}
-		return centre;	
+		return centre;
 	}
 
-
 	/**
-	Computes the cost of this point with centre centre
-	**/
-	public double costOfPointToCenter(Point centre){
-		if(this.weight == 0.0){
+	 * Computes the cost of this point with centre centre
+	 **/
+	public double costOfPointToCenter(Point centre) {
+		if (this.weight == 0.0) {
 			return 0.0;
 		}
 
-		//stores the distance between p and centre
+		// stores the distance between p and centre
 		double distance = 0.0;
 
-		//loop counter
-		for(int l=0; l<this.dimension; l++){
-			//Centroid coordinate of the point
+		// loop counter
+		for (int l = 0; l < this.dimension; l++) {
+			// Centroid coordinate of the point
 			double centroidCoordinatePoint;
-			if(this.weight != 0.0){
+			if (this.weight != 0.0) {
 				centroidCoordinatePoint = this.coordinates[l] / this.weight;
 			} else {
 				centroidCoordinatePoint = this.coordinates[l];
 			}
-			//Centroid coordinate of the centre
+			// Centroid coordinate of the centre
 			double centroidCoordinateCentre;
-			if(centre.weight != 0.0){
+			if (centre.weight != 0.0) {
 				centroidCoordinateCentre = centre.coordinates[l] / centre.weight;
 			} else {
 				centroidCoordinateCentre = centre.coordinates[l];
 			}
-			distance += (centroidCoordinatePoint-centroidCoordinateCentre) * 
-					(centroidCoordinatePoint-centroidCoordinateCentre) ;
-					
+			distance += (centroidCoordinatePoint - centroidCoordinateCentre)
+					* (centroidCoordinatePoint - centroidCoordinateCentre);
+
 		}
 		return distance * this.weight;
 	}
 
-
 }
diff --git a/moa/src/main/java/moa/learners/clusterers/streamkm/StreamKM.java b/moa/src/main/java/moa/learners/clusterers/streamkm/StreamKM.java
new file mode 100644
index 000000000..a4c3d94d6
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/streamkm/StreamKM.java
@@ -0,0 +1,365 @@
+package moa.learners.clusterers.streamkm;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.cluster.Clustering;
+import moa.core.Measurement;
+import moa.learners.clusterers.AbstractClusterer;
+
+/**
+ *
+ * @author Marcel R. Ackermann, Christiane Lammersen, Marcus Maertens, Christoph
+ *         Raupach, Christian Sohler, Kamil Swierkot
+ * 
+ *         Modified by Richard Hugh Moulton (24 Jul 2017)
+ * 
+ *         Citation: Marcel R. Ackermann, Christiane Lammersen, Marcus Märtens,
+ *         Christoph Raupach, Christian Sohler, Kamil Swierkot: StreamKM++: A
+ *         Clustering Algorithms for Data Streams. ALENEX 2010: 173-187
+ */
+
+public class StreamKM extends AbstractClusterer {
+
+	public IntOption sizeCoresetOption = new IntOption("sizeCoreset", 's', "Size of the coreset (m).", 10000);
+
+	public IntOption numClustersOption = new IntOption("numClusters", 'k', "Number of clusters to compute.", 5);
+
+	public IntOption lengthOption = new IntOption("length", 'l', "Length of the data stream (n).", 100000, 0,
+			Integer.MAX_VALUE);
+
+	public FlagOption evaluateOption = new FlagOption("evaluateFinalOnly", 'e',
+			"If true, only the final clustering is evaluated.");
+
+	public IntOption randomSeedOption = new IntOption("randomSeed", 'r', "Seed for random behaviour of the classifier.",
+			1);
+
+	protected MTRandom clustererRandom;
+	protected Point[] centresStreamingCoreset;
+
+	protected int numberInstances;
+
+	protected int dimension;
+	protected int length;
+	protected int numberOfCentres;
+	protected int coresetsize;
+
+	protected BucketManager manager;
+
+	protected boolean initialized = false;
+
+	private final static double THRESHOLD = 1.000;
+
+	@Override
+	public void resetLearningImpl() {
+		this.initialized = false;
+		this.coresetsize = sizeCoresetOption.getValue();
+		this.numberOfCentres = numClustersOption.getValue();
+		this.length = lengthOption.getValue();
+		this.centresStreamingCoreset = new Point[this.numberOfCentres];
+
+		// initalize random generator with seed
+		this.clustererRandom = new MTRandom(this.randomSeedOption.getValue());
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+
+		if (this.initialized == false) {
+			this.dimension = inst.numAttributes();
+			manager = new BucketManager(this.length, this.dimension, this.coresetsize, this.clustererRandom);
+			this.initialized = true;
+		}
+
+		manager.insertPoint(new Point(inst, this.numberInstances));
+
+		this.numberInstances++;
+		if (this.numberInstances % lengthOption.getValue() == 0) {
+
+			Point[] streamingCoreset = manager.getCoresetFromManager(dimension);
+
+			// compute 5 clusterings of the coreset with kMeans++ and take the best
+			CoresetCostTriple triple;
+			double minCost = 0.0;
+			double curCost = 0.0;
+
+			triple = lloydPlusPlus(numberOfCentres, coresetsize, dimension, streamingCoreset);
+			minCost = triple.getCoresetCost();
+			for (int j = 0; j < this.numberOfCentres; j++) {
+				centresStreamingCoreset[j] = triple.getCoresetCentres()[j].clone();
+			}
+			curCost = minCost;
+
+			for (int i = 1; i < 5; i++) {
+				triple = lloydPlusPlus(numberOfCentres, coresetsize, dimension, streamingCoreset);
+				curCost = triple.getCoresetCost();
+
+				if (curCost < minCost) {
+					minCost = curCost;
+					for (int j = 0; j < this.numberOfCentres; j++) {
+						centresStreamingCoreset[j] = triple.getCoresetCentres()[j].clone();
+					}
+				}
+			}
+		}
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public Clustering getClusteringResult() {
+		if (!this.initialized) {
+			return new Clustering();
+		}
+
+		Clustering clustering = new Clustering();
+
+		if (!evaluateOption.isSet()) {
+			Point[] streamingCoreset = manager.getCoresetFromManager(dimension);
+
+			// compute 5 clusterings of the coreset with kMeans++ and take the best
+			CoresetCostTriple triple;
+			double minCost = 0.0;
+			double curCost = 0.0;
+
+			triple = lloydPlusPlus(numberOfCentres, coresetsize, dimension, streamingCoreset);
+			minCost = triple.getCoresetCost();
+			for (int j = 0; j < this.numberOfCentres; j++) {
+				centresStreamingCoreset[j] = triple.getCoresetCentres()[j].clone();
+			}
+			curCost = minCost;
+
+			for (int i = 1; i < 5; i++) {
+				triple = lloydPlusPlus(numberOfCentres, coresetsize, dimension, streamingCoreset);
+				curCost = triple.getCoresetCost();
+
+				if (curCost < minCost) {
+					minCost = curCost;
+					for (int j = 0; j < this.numberOfCentres; j++) {
+						centresStreamingCoreset[j] = triple.getCoresetCentres()[j].clone();
+					}
+				}
+			}
+
+			for (int i = 0; i < centresStreamingCoreset.length; i++) {
+				if (centresStreamingCoreset[i] != null) {
+					clustering.add(centresStreamingCoreset[i].toCluster(triple.getRadii()[i]));
+				}
+			}
+		}
+
+		return clustering;
+	}
+
+	public CoresetCostTriple lloydPlusPlus(int k, int n, int d, Point points[]) {
+		// printf("starting kMeans++\n");
+		CoresetCostTriple triple;
+		double[] radii = new double[k];
+		// choose random centres
+		// choose random centres
+		Point[] centres = chooseRandomCentres(k, n, d, points);
+		double cost = targetFunctionValue(k, n, centres, points);
+		double newCost = cost;
+
+		Point[] massCentres = new Point[k];
+		double[] numberOfPoints = new double[k];
+
+		do {
+			cost = newCost;
+			// reset centres of mass
+			int i = 0;
+			for (i = 0; i < k; i++) {
+				massCentres[i] = new Point(d);
+				numberOfPoints[i] = 0.0;
+			}
+			// compute centres of mass
+			for (i = 0; i < n; i++) {
+				int centre = points[i].determineClusterCentreKMeans(k, centres);
+				for (int l = 0; l < massCentres[centre].dimension; l++) {
+					if (points[i].weight != 0.0)
+						massCentres[centre].coordinates[l] += points[i].coordinates[l];
+				}
+				numberOfPoints[centre] += points[i].weight;
+
+			}
+
+			// move centres
+			for (i = 0; i < k; i++) {
+				for (int l = 0; l < centres[i].dimension; l++) {
+					centres[i].coordinates[l] = massCentres[i].coordinates[l];
+				}
+				centres[i].weight = numberOfPoints[i];
+			}
+
+			// calculate costs
+			newCost = targetFunctionValue(k, n, centres, points);
+			// printf("old cost:%f, new cost:%f \n",cost,newCost);
+		} while (newCost < THRESHOLD * cost);
+
+		// compute radii
+		for (int i = 0; i < n; i++) {
+			int centre = points[i].determineClusterCentreKMeans(k, centres);
+			double radius = 0.0;
+			double distance;
+
+			for (int j = 0; j < points[i].dimension; j++) {
+				distance = Math.abs((centres[centre].coordinates[j] / centres[centre].weight)
+						- (points[i].coordinates[j] / points[i].weight));
+				radius += Math.pow(distance, 2.0);
+			}
+
+			radii[centre] += radius * points[i].weight;
+		}
+		for (int i = 0; i < k; i++) {
+			radii[i] = 2.0 * Math.sqrt(radii[i] / centres[i].weight);
+		}
+
+		/*
+		 * printf("Centres: \n"); int i=0; for(i=0;i<k;i++){ printf("("); int l = 0;
+		 * for(l=0;l<centres[i].dimension;l++){ printf("%f,",centres[i].coordinates[l] /
+		 * centres[i].weight); } printf(")\n"); } printf("kMeans++ finished\n");
+		 */
+		triple = new CoresetCostTriple(centres, radii, newCost);
+
+		return triple;
+	}
+
+	private Point[] chooseRandomCentres(int k, int n, int d, Point points[]) {
+
+		// array to store the choosen centres
+		Point[] centres = new Point[k];
+
+		// choose the first centre (each point has the same probability of being
+		// choosen)
+		int i = 0;
+
+		int next = 0;
+		int j = 0;
+		do { // only choose from the n-i points not already choosen
+			next = this.clustererRandom.nextInt(n - 1);
+
+			// check if the choosen point is not a dummy
+		} while (points[next].weight < 1);
+
+		// set j to next unchoosen point
+		j = next;
+		// copy the choosen point to the array
+		centres[i] = points[j].clone();
+
+		// set the current centre for all points to the choosen centre
+		for (i = 0; i < n; i++) {
+			points[i].centreIndex = 0;
+			points[i].curCost = points[i].costOfPointToCenter(centres[0]);
+
+		}
+		// choose centre 1 to k-1 with the kMeans++ distribution
+		for (i = 1; i < k; i++) {
+
+			double cost = 0.0;
+			for (j = 0; j < n; j++) {
+				cost += points[j].curCost;
+			}
+
+			double random = 0;
+			double sum = 0.0;
+			int pos = -1;
+
+			do {
+				random = this.clustererRandom.nextDouble();// genrand_real3();
+				sum = 0.0;
+				pos = -1;
+
+				for (j = 0; j < n; j++) {
+					sum = sum + points[j].curCost;
+					if (random <= sum / cost) {
+						pos = j;
+						break;
+					}
+				}
+			} while (points[pos].weight < 1);
+
+			// copy the choosen centre
+			centres[i] = points[pos].clone();
+			// check which points are closest to the new centre
+			for (j = 0; j < n; j++) {
+				double newCost = points[j].costOfPointToCenter(centres[i]);
+				if (points[j].curCost > newCost) {
+					points[j].curCost = newCost;
+					points[j].centreIndex = i;
+				}
+			}
+
+		}
+
+		/*
+		 * printf("random centres: \n"); for(i = 0; i < k; i++){ //printf("%d: (",i);
+		 * int l = 0; for(l = 0; l < centres[i].dimension; l++){
+		 * printf("%f,",centres[i].coordinates[l] / centres[i].weight); } printf(")\n");
+		 * }
+		 */
+
+		return centres;
+	}
+
+	/**
+	 * computes the target function for the given pointarray points[] (of size n)
+	 * with the given array of centres centres[] (of size k)
+	 **/
+	public double targetFunctionValue(int k, int n, Point[] centres, Point[] points) {
+		int i = 0;
+		double sum = 0.0;
+		for (i = 0; i < n; i++) {
+			double nearestCost = -1.0;
+			int j = 0;
+			for (j = 0; j < k; j++) {
+				double distance = 0.0;
+				int l = 0;
+				for (l = 0; l < points[i].dimension; l++) {
+					// Centroid coordinate of the point
+					double centroidCoordinatePoint;
+					if (points[i].weight != 0.0) {
+						centroidCoordinatePoint = points[i].coordinates[l] / points[i].weight;
+					} else {
+						centroidCoordinatePoint = points[i].coordinates[l];
+					}
+					// Centroid coordinate of the centre
+					double centroidCoordinateCentre;
+					if (centres[j].weight != 0.0) {
+						centroidCoordinateCentre = centres[j].coordinates[l] / centres[j].weight;
+					} else {
+						centroidCoordinateCentre = centres[j].coordinates[l];
+					}
+					distance += (centroidCoordinatePoint - centroidCoordinateCentre)
+							* (centroidCoordinatePoint - centroidCoordinateCentre);
+
+				}
+				if (nearestCost < 0 || distance < nearestCost) {
+					nearestCost = distance;
+				}
+			}
+			sum += nearestCost * points[i].weight;
+		}
+		return sum;
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/clusterers/streamkm/TreeCoreset.java b/moa/src/main/java/moa/learners/clusterers/streamkm/TreeCoreset.java
new file mode 100644
index 000000000..b9bc6b12c
--- /dev/null
+++ b/moa/src/main/java/moa/learners/clusterers/streamkm/TreeCoreset.java
@@ -0,0 +1,613 @@
+package moa.learners.clusterers.streamkm;
+
+/**
+ *
+ * @author Marcel R. Ackermann, Christiane Lammersen, Marcus Maertens, Christoph
+ *         Raupach, Christian Sohler, Kamil Swierkot
+ */
+public class TreeCoreset {
+
+	/**
+	 * datastructure representing a node within a tree
+	 **/
+	protected class treeNode {
+		// number of points in this node
+		int n;
+
+		// array with pointers on points
+		Point[] points;
+
+		// pointer on the centre of the treenode
+		Point centre;
+
+		// pointer on the left childnode
+		treeNode lc;
+
+		// pointer on the right childnode
+		treeNode rc;
+
+		// pointer on the parent node
+		treeNode parent;
+
+		// cost of the treenode
+		double cost;
+
+		void free() {
+			this.parent = null;
+			this.lc = null;
+			this.rc = null;
+			this.points = null;
+			this.centre = null;
+		}
+
+		public treeNode(int n, Point[] points, Point centre, treeNode parent) {
+			this.n = n;
+			this.points = points;
+			this.centre = centre;
+			this.lc = null;
+			this.rc = null;
+			this.parent = parent;
+			this.cost = treeNodeTargetFunctionValue();
+		}
+
+		/**
+		 * initalizes root as a treenode with the union of setA and setB as pointset and
+		 * centre as centre
+		 **/
+		public treeNode(Point[] setA, Point[] setB, int n_1, int n_2, Point centre, int centreIndex) {
+			// loop counter variable
+			int i;
+
+			// the root has no parent and no child nodes in the beginning
+			this.parent = null;
+			this.lc = null;
+			this.rc = null;
+
+			// array with points to the points
+			this.points = new Point[n_1 + n_2];
+			this.n = n_1 + n_2;
+
+			for (i = 0; i < this.n; i++) {
+				if (i < n_1) {
+					this.points[i] = setA[i];
+					this.points[i].centreIndex = centreIndex;
+				} else {
+					this.points[i] = setB[i - n_1];
+					this.points[i].centreIndex = centreIndex;
+				}
+			}
+
+			// set the centre
+			this.centre = centre;
+
+			// calculate costs
+			this.cost = treeNodeTargetFunctionValue();
+		}
+
+		/**
+		 * Computes the target function value of the n points of the treenode. Differs
+		 * from the function "targetFunctionValue" in three things:
+		 * 
+		 * 1. only the centre of the treenode is used as a centre
+		 * 
+		 * 2. works on arrays of pointers instead on arrays of points
+		 * 
+		 * 3. stores the cost in the treenode
+		 **/
+		double treeNodeTargetFunctionValue() {
+			// loop counter variable
+			int i;
+
+			// stores the cost
+			double sum = 0.0;
+
+			for (i = 0; i < this.n; i++) {
+				// stores the distance
+				double distance = 0.0;
+
+				// loop counter variable
+				int l;
+
+				for (l = 0; l < this.points[i].dimension; l++) {
+					// centroid coordinate of the point
+					double centroidCoordinatePoint;
+					if (this.points[i].weight != 0.0) {
+						centroidCoordinatePoint = this.points[i].coordinates[l] / this.points[i].weight;
+					} else {
+						centroidCoordinatePoint = this.points[i].coordinates[l];
+					}
+					// centroid coordinate of the centre
+					double centroidCoordinateCentre;
+					if (this.centre.weight != 0.0) {
+						centroidCoordinateCentre = this.centre.coordinates[l] / this.centre.weight;
+					} else {
+						centroidCoordinateCentre = this.centre.coordinates[l];
+					}
+					distance += (centroidCoordinatePoint - centroidCoordinateCentre)
+							* (centroidCoordinatePoint - centroidCoordinateCentre);
+
+				}
+
+				sum += distance * this.points[i].weight;
+			}
+			return sum;
+		}
+	}
+
+	/**
+	 * computes the hypothetical cost if the node would be split with new centers
+	 * centreA, centreB
+	 **/
+	double treeNodeSplitCost(treeNode node, Point centreA, Point centreB) {
+		// loop counter variable
+		int i;
+
+		// stores the cost
+		double sum = 0.0;
+
+		for (i = 0; i < node.n; i++) {
+			// loop counter variable
+			int l;
+
+			// stores the distance between p and centreA
+			double distanceA = 0.0;
+
+			for (l = 0; l < node.points[i].dimension; l++) {
+				// centroid coordinate of the point
+				double centroidCoordinatePoint;
+				if (node.points[i].weight != 0.0) {
+					centroidCoordinatePoint = node.points[i].coordinates[l] / node.points[i].weight;
+				} else {
+					centroidCoordinatePoint = node.points[i].coordinates[l];
+				}
+				// centroid coordinate of the centre
+				double centroidCoordinateCentre;
+				if (centreA.weight != 0.0) {
+					centroidCoordinateCentre = centreA.coordinates[l] / centreA.weight;
+				} else {
+					centroidCoordinateCentre = centreA.coordinates[l];
+				}
+
+				distanceA += (centroidCoordinatePoint - centroidCoordinateCentre)
+						* (centroidCoordinatePoint - centroidCoordinateCentre);
+			}
+
+			// stores the distance between p and centreB
+			double distanceB = 0.0;
+
+			for (l = 0; l < node.points[i].dimension; l++) {
+				// centroid coordinate of the point
+				double centroidCoordinatePoint;
+				if (node.points[i].weight != 0.0) {
+					centroidCoordinatePoint = node.points[i].coordinates[l] / node.points[i].weight;
+				} else {
+					centroidCoordinatePoint = node.points[i].coordinates[l];
+				}
+				// centroid coordinate of the centre
+				double centroidCoordinateCentre;
+				if (centreB.weight != 0.0) {
+					centroidCoordinateCentre = centreB.coordinates[l] / centreB.weight;
+				} else {
+					centroidCoordinateCentre = centreB.coordinates[l];
+				}
+
+				distanceB += (centroidCoordinatePoint - centroidCoordinateCentre)
+						* (centroidCoordinatePoint - centroidCoordinateCentre);
+			}
+
+			// add the cost of the closest centre to the sum
+			if (distanceA < distanceB) {
+				sum += distanceA * node.points[i].weight;
+			} else {
+				sum += distanceB * node.points[i].weight;
+			}
+
+		}
+
+		// return the total cost
+		return sum;
+
+	}
+
+	/**
+	 * computes the cost of point p with the centre of treenode node
+	 **/
+	double treeNodeCostOfPoint(treeNode node, Point p) {
+		if (p.weight == 0.0) {
+			return 0.0;
+		}
+
+		// stores the distance between centre and p
+		double distance = 0.0;
+
+		// loop counter variable
+		int l;
+
+		for (l = 0; l < p.dimension; l++) {
+			// centroid coordinate of the point
+			double centroidCoordinatePoint;
+			if (p.weight != 0.0) {
+				centroidCoordinatePoint = p.coordinates[l] / p.weight;
+			} else {
+				centroidCoordinatePoint = p.coordinates[l];
+			}
+			// centroid coordinate of the centre
+			double centroidCoordinateCentre;
+			if (node.centre.weight != 0.0) {
+				centroidCoordinateCentre = node.centre.coordinates[l] / node.centre.weight;
+			} else {
+				centroidCoordinateCentre = node.centre.coordinates[l];
+			}
+			distance += (centroidCoordinatePoint - centroidCoordinateCentre)
+					* (centroidCoordinatePoint - centroidCoordinateCentre);
+
+		}
+		return distance * p.weight;
+	}
+
+	/**
+	 * tests if a node is a leaf
+	 **/
+	boolean isLeaf(treeNode node) {
+
+		if (node.lc == null && node.rc == null) {
+			return true;
+		} else {
+			return false;
+		}
+
+	}
+
+	/**
+	 * selects a leaf node (using the kMeans++ distribution)
+	 **/
+	treeNode selectNode(treeNode root, MTRandom clustererRandom) {
+
+		// random number between 0 and 1
+		double random = clustererRandom.nextDouble();
+
+		while (!isLeaf(root)) {
+			if (root.lc.cost == 0 && root.rc.cost == 0) {
+				if (root.lc.n == 0) {
+					root = root.rc;
+				} else if (root.rc.n == 0) {
+					root = root.lc;
+				} else if (random < 0.5) {
+					random = clustererRandom.nextDouble();
+					root = root.lc;
+				} else {
+					random = clustererRandom.nextDouble();
+					root = root.rc;
+				}
+			} else {
+
+				if (random < root.lc.cost / root.cost) {
+
+					root = root.lc;
+				} else {
+
+					root = root.rc;
+				}
+			}
+		}
+
+		return root;
+	}
+
+	/**
+	 * selects a new centre from the treenode (using the kMeans++ distribution)
+	 **/
+	Point chooseCentre(treeNode node, MTRandom clustererRandom) {
+
+		// How many times should we try to choose a centre ??
+		int times = 3;
+
+		// stores the nodecost if node is split with the best centre
+		double minCost = node.cost;
+		Point bestCentre = null;
+
+		// loop counter variable
+		int i;
+		int j;
+
+		for (j = 0; j < times; j++) {
+			// sum of the relativ cost of the points
+			double sum = 0.0;
+			// random number between 0 and 1
+			double random = clustererRandom.nextDouble();
+
+			for (i = 0; i < node.n; i++) {
+
+				sum += treeNodeCostOfPoint(node, node.points[i]) / node.cost;
+				if (sum >= random) {
+					if (node.points[i].weight == 0.0) {
+						// printf("ERROR: CHOOSEN DUMMY NODE THOUGH OTHER AVAILABLE \n");
+						return null;
+					}
+					double curCost = treeNodeSplitCost(node, node.centre, node.points[i]);
+					if (curCost < minCost) {
+						bestCentre = node.points[i];
+						minCost = curCost;
+					}
+					break;
+				}
+			}
+		}
+		if (bestCentre == null) {
+			return node.points[0];
+		} else {
+			return bestCentre;
+		}
+	}
+
+	/**
+	 * returns the next centre
+	 **/
+	Point determineClosestCentre(Point p, Point centreA, Point centreB) {
+
+		// loop counter variable
+		int l;
+
+		// stores the distance between p and centreA
+		double distanceA = 0.0;
+
+		for (l = 0; l < p.dimension; l++) {
+			// centroid coordinate of the point
+			double centroidCoordinatePoint;
+			if (p.weight != 0.0) {
+				centroidCoordinatePoint = p.coordinates[l] / p.weight;
+			} else {
+				centroidCoordinatePoint = p.coordinates[l];
+			}
+			// centroid coordinate of the centre
+			double centroidCoordinateCentre;
+			if (centreA.weight != 0.0) {
+				centroidCoordinateCentre = centreA.coordinates[l] / centreA.weight;
+			} else {
+				centroidCoordinateCentre = centreA.coordinates[l];
+			}
+
+			distanceA += (centroidCoordinatePoint - centroidCoordinateCentre)
+					* (centroidCoordinatePoint - centroidCoordinateCentre);
+		}
+
+		// stores the distance between p and centreB
+		double distanceB = 0.0;
+
+		for (l = 0; l < p.dimension; l++) {
+			// centroid coordinate of the point
+			double centroidCoordinatePoint;
+			if (p.weight != 0.0) {
+				centroidCoordinatePoint = p.coordinates[l] / p.weight;
+			} else {
+				centroidCoordinatePoint = p.coordinates[l];
+			}
+			// centroid coordinate of the centre
+			double centroidCoordinateCentre;
+			if (centreB.weight != 0.0) {
+				centroidCoordinateCentre = centreB.coordinates[l] / centreB.weight;
+			} else {
+				centroidCoordinateCentre = centreB.coordinates[l];
+			}
+
+			distanceB += (centroidCoordinatePoint - centroidCoordinateCentre)
+					* (centroidCoordinatePoint - centroidCoordinateCentre);
+		}
+
+		// return the nearest centre
+		if (distanceA < distanceB) {
+			return centreA;
+		} else {
+			return centreB;
+		}
+	}
+
+	/**
+	 * splits the parent node and creates two child nodes (one with the old centre
+	 * and one with the new one)
+	 **/
+	void split(treeNode parent, Point newCentre, int newCentreIndex) {
+
+		// loop counter variable
+		int i;
+
+		// 1. Counts how many points belong to the new and how many points belong to the
+		// old centre
+		int nOld = 0;
+		int nNew = 0;
+		for (i = 0; i < parent.n; i++) {
+			Point centre = determineClosestCentre(parent.points[i], parent.centre, newCentre);
+			if (centre == newCentre) {
+				nNew++;
+			} else {
+				nOld++;
+			}
+		}
+
+		// 2. initalizes the arrays for the pointer
+
+		// array for pointer on the points belonging to the old centre
+		Point[] oldPoints = new Point[nOld];
+
+		// array for pointer on the points belonging to the new centre
+		Point[] newPoints = new Point[nNew];
+
+		int indexOld = 0;
+		int indexNew = 0;
+
+		for (i = 0; i < parent.n; i++) {
+			Point centre = determineClosestCentre(parent.points[i], parent.centre, newCentre);
+			if (centre == newCentre) {
+				newPoints[indexNew] = parent.points[i];
+				newPoints[indexNew].centreIndex = newCentreIndex;
+				indexNew++;
+			} else if (centre == parent.centre) {
+				oldPoints[indexOld] = parent.points[i];
+				indexOld++;
+			} else {
+				// printf("ERROR !!! NO CENTER NEAREST !! \n");
+			}
+		}
+
+		// left child: old centre
+		treeNode lc = new treeNode(nOld, oldPoints, parent.centre, parent);
+		/*
+		 * lc.centre = parent.centre; lc.points = oldPoints; lc.n = nOld;
+		 * 
+		 * lc.lc = null; lc.rc = null; lc.parent = parent;
+		 * 
+		 * treeNodeTargetFunctionValue(lc);
+		 */
+
+		// right child: new centre
+		treeNode rc = new treeNode(nNew, newPoints, newCentre, parent);
+		/*
+		 * rc.centre = newCentre; rc.points = newPoints; rc.n = nNew;
+		 * 
+		 * rc.lc = null; rc.rc = null; rc.parent = parent;
+		 * 
+		 * treeNodeTargetFunctionValue(rc);
+		 */
+
+		// set childs of the parent node
+		parent.lc = lc;
+		parent.rc = rc;
+
+		// propagate the cost changes to the parent nodes
+		while (parent != null) {
+			parent.cost = parent.lc.cost + parent.rc.cost;
+			parent = parent.parent;
+		}
+
+	}
+
+	/**
+	 * Checks if the storage is completly freed
+	 **/
+	boolean treeFinished(treeNode root) {
+		return (root.parent == null && root.lc == null && root.rc == null);
+	}
+
+	/**
+	 * frees a tree of its storage
+	 **/
+	void freeTree(treeNode root) {
+
+		while (!treeFinished(root)) {
+			if (root.lc == null && root.rc == null) {
+				root = root.parent;
+			} else if (root.lc == null && root.rc != null) {
+				// Schau ob rc ein Blatt ist
+				if (isLeaf(root.rc)) {
+					// Gebe rechtes Kind frei
+					root.rc.free();
+					root.rc = null;
+				} else {
+					// Fahre mit rechtem Kind fort
+					root = root.rc;
+				}
+			} else if (root.lc != null) {
+				if (isLeaf(root.lc)) {
+					root.lc.free();
+					root.lc = null;
+				} else {
+					root = root.lc;
+				}
+			}
+		}
+		root.free();
+
+	}
+
+	/**
+	 * Constructs a coreset of size k from the union of setA and setB
+	 **/
+	void unionTreeCoreset(int k, int n_1, int n_2, int d, Point[] setA, Point[] setB, Point[] centres,
+			MTRandom clustererRandom) {
+		// printf("Computing coreset...\n");
+		// total number of points
+		int n = n_1 + n_2;
+
+		// choose the first centre (each point has the same probability of being
+		// choosen)
+
+		// stores, how many centres have been choosen yet
+		int choosenPoints = 0;
+
+		// only choose from the n-i points not already choosen
+		int j = clustererRandom.nextInt(n - choosenPoints);
+
+		// copy the choosen point
+		if (j < n_1) {
+			// copyPointWithoutInit(&setA[j],&centres[choosenPoints]);
+			centres[choosenPoints] = setA[j].clone();
+		} else {
+			j = j - n_1;
+			// copyPointWithoutInit(&setB[j],&centres[choosenPoints]);
+			centres[choosenPoints] = setB[j].clone();
+		}
+		treeNode root = new treeNode(setA, setB, n_1, n_2, centres[choosenPoints], choosenPoints); // ??
+		choosenPoints = 1;
+
+		// choose the remaining points
+		while (choosenPoints < k) {
+			if (root.cost > 0.0) {
+				treeNode leaf = selectNode(root, clustererRandom);
+				Point centre = chooseCentre(leaf, clustererRandom);
+				split(leaf, centre, choosenPoints);
+				// copyPointWithoutInit(centre,&centres[choosenPoints]);
+				centres[choosenPoints] = centre;
+			} else {
+				// create a dummy point
+				// copyPointWithoutInit(root.centre,&centres[choosenPoints]);
+				centres[choosenPoints] = root.centre;
+				int l;
+				for (l = 0; l < root.centre.dimension; l++) {
+					centres[choosenPoints].coordinates[l] = -1 * 1000000;
+				}
+				centres[choosenPoints].id = -1;
+				centres[choosenPoints].weight = 0.0;
+				centres[choosenPoints].squareSum = 0.0;
+			}
+
+			choosenPoints++;
+		}
+
+		// free the tree
+		freeTree(root);
+
+		// recalculate clustering features
+		int i;
+		for (i = 0; i < n; i++) {
+
+			if (i < n_1) {
+
+				int index = setA[i].centreIndex;
+				if (centres[index].id != setA[i].id) {
+					centres[index].weight += setA[i].weight;
+					centres[index].squareSum += setA[i].squareSum;
+					int l;
+					for (l = 0; l < centres[index].dimension; l++) {
+						if (setA[i].weight != 0.0) {
+							centres[index].coordinates[l] += setA[i].coordinates[l];
+						}
+					}
+				}
+			} else {
+
+				int index = setB[i - n_1].centreIndex;
+				if (centres[index].id != setB[i - n_1].id) {
+					centres[index].weight += setB[i - n_1].weight;
+					centres[index].squareSum += setB[i - n_1].squareSum;
+					int l;
+					for (l = 0; l < centres[index].dimension; l++) {
+						if (setB[i - n_1].weight != 0.0) {
+							centres[index].coordinates[l] += setB[i - n_1].coordinates[l];
+						}
+					}
+				}
+			}
+		}
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/AbstractClassifier.java b/moa/src/main/java/moa/learners/predictors/AbstractClassifier.java
new file mode 100644
index 000000000..cc5716d51
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/AbstractClassifier.java
@@ -0,0 +1,248 @@
+package moa.learners.predictors;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
+import moa.capabilities.CapabilitiesHandler;
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
+import moa.core.Measurement;
+import moa.core.ObjectRepository;
+import moa.core.Utils;
+import moa.gui.AWTRenderer;
+import moa.tasks.TaskMonitor;
+
+public abstract class AbstractClassifier extends AbstractInstanceLearner<Classifier>
+		implements Classifier, CapabilitiesHandler {
+
+	@Override
+	public String getPurposeString() {
+		return "MOA Classifier: " + getClass().getCanonicalName();
+	}
+
+	/**
+	 * Creates an classifier and setups the random seed option if the classifier is
+	 * randomizable.
+	 */
+	public AbstractClassifier() {
+		super(Classifier.class);
+	}
+
+	@Override
+	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		if (this.randomSeedOption != null) {
+			this.randomSeed = this.randomSeedOption.getValue();
+		}
+		if (!trainingHasStarted()) {
+			resetLearning();
+		}
+	}
+
+	@Override
+	public void setModelContext(InstancesHeader ih) {
+		if ((ih != null) && (ih.classIndex() < 0)) {
+			throw new IllegalArgumentException("Context for a classifier must include a class to learn");
+		}
+		if (trainingHasStarted() && (this.modelContext != null)
+				&& ((ih == null) || !contextIsCompatible(this.modelContext, ih))) {
+			throw new IllegalArgumentException("New context is not compatible with existing model");
+		}
+		this.modelContext = ih;
+	}
+
+	@Override
+	public boolean correctlyClassifies(Instance inst) {
+		return Utils.maxIndex(getPredictionForInstance(inst).asDoubleArray()) == (int) inst.classValue();
+	}
+
+	/**
+	 * Gets the name of the attribute of the class from the header.
+	 *
+	 * @return the string with name of the attribute of the class
+	 */
+	@Override
+	public String getClassNameString() {
+		return InstancesHeader.getClassNameString(this.modelContext);
+	}
+
+	/**
+	 * Gets the name of a label of the class from the header.
+	 *
+	 * @param classLabelIndex the label index
+	 * @return the name of the label of the class
+	 */
+	@Override
+	public String getClassLabelString(int classLabelIndex) {
+		return InstancesHeader.getClassLabelString(this.modelContext, classLabelIndex);
+	}
+
+	/**
+	 * Gets the name of an attribute from the header.
+	 *
+	 * @param attIndex the attribute index
+	 * @return the name of the attribute
+	 */
+	@Override
+	public String getAttributeNameString(int attIndex) {
+		return InstancesHeader.getAttributeNameString(this.modelContext, attIndex);
+	}
+
+	/**
+	 * Gets the name of a value of an attribute from the header.
+	 *
+	 * @param attIndex the attribute index
+	 * @param valIndex the value of the attribute
+	 * @return the name of the value of the attribute
+	 */
+	@Override
+	public String getNominalValueString(int attIndex, int valIndex) {
+		return InstancesHeader.getNominalValueString(this.modelContext, attIndex, valIndex);
+	}
+
+	/**
+	 * Returns if two contexts or headers of instances are compatible.<br>
+	 * <br>
+	 *
+	 * Two contexts are compatible if they follow the following rules:<br>
+	 * Rule 1: num classes can increase but never decrease<br>
+	 * Rule 2: num attributes can increase but never decrease<br>
+	 * Rule 3: num nominal attribute values can increase but never decrease<br>
+	 * Rule 4: attribute types must stay in the same order (although class can move;
+	 * is always skipped over)<br>
+	 * <br>
+	 *
+	 * Attribute names are free to change, but should always still represent the
+	 * original attributes.
+	 *
+	 * @param originalContext the first context to compare
+	 * @param newContext      the second context to compare
+	 * @return true if the two contexts are compatible.
+	 */
+	public static boolean contextIsCompatible(InstancesHeader originalContext, InstancesHeader newContext) {
+
+		if (newContext.numClasses() < originalContext.numClasses()) {
+			return false; // rule 1
+		}
+		if (newContext.numAttributes() < originalContext.numAttributes()) {
+			return false; // rule 2
+		}
+		int oPos = 0;
+		int nPos = 0;
+		while (oPos < originalContext.numAttributes()) {
+			if (oPos == originalContext.classIndex()) {
+				oPos++;
+				if (!(oPos < originalContext.numAttributes())) {
+					break;
+				}
+			}
+			if (nPos == newContext.classIndex()) {
+				nPos++;
+			}
+			if (originalContext.attribute(oPos).isNominal()) {
+				if (!newContext.attribute(nPos).isNominal()) {
+					return false; // rule 4
+				}
+				if (newContext.attribute(nPos).numValues() < originalContext.attribute(oPos).numValues()) {
+					return false; // rule 3
+				}
+			} else {
+				assert (originalContext.attribute(oPos).isNumeric());
+				if (!newContext.attribute(nPos).isNumeric()) {
+					return false; // rule 4
+				}
+			}
+			oPos++;
+			nPos++;
+		}
+		return true; // all checks clear
+	}
+
+	/**
+	 * Returns the AWT Renderer
+	 *
+	 * @return the AWT Renderer
+	 */
+	@Override
+	public AWTRenderer getAWTRenderer() {
+		// TODO should return a default renderer here
+		// - or should null be interpreted as the default?
+		return null;
+	}
+
+	/**
+	 * Resets this classifier. It must be similar to starting a new classifier from
+	 * scratch. <br>
+	 * <br>
+	 * 
+	 * The reason for ...Impl methods: ease programmer burden by not requiring them
+	 * to remember calls to super in overridden methods. Note that this will produce
+	 * compiler errors if not overridden.
+	 */
+	@Override
+	public abstract void resetLearningImpl();
+
+	/**
+	 * Trains this classifier incrementally using the given instance.<br>
+	 * <br>
+	 * 
+	 * The reason for ...Impl methods: ease programmer burden by not requiring them
+	 * to remember calls to super in overridden methods. Note that this will produce
+	 * compiler errors if not overridden.
+	 *
+	 * @param inst the instance to be used for training
+	 */
+	@Override
+	public abstract void trainOnInstanceImpl(Instance inst);
+
+	/**
+	 * Gets the current measurements of this classifier.<br>
+	 * <br>
+	 * 
+	 * The reason for ...Impl methods: ease programmer burden by not requiring them
+	 * to remember calls to super in overridden methods. Note that this will produce
+	 * compiler errors if not overridden.
+	 *
+	 * @return an array of measurements to be used in evaluation tasks
+	 */
+	@Override
+	protected abstract Measurement[] getModelMeasurementsImpl();
+
+	/**
+	 * Returns a string representation of the model.
+	 *
+	 * @param out    the stringbuilder to add the description
+	 * @param indent the number of characters to indent
+	 */
+	@Override
+	public abstract void getModelDescription(StringBuilder out, int indent);
+
+	/**
+	 * Gets the index of the attribute in the instance, given the index of the
+	 * attribute in the learner.
+	 *
+	 * @param index the index of the attribute in the learner
+	 * @param inst  the instance
+	 * @return the index in the instance
+	 */
+	protected static int modelAttIndexToInstanceAttIndex(int index, Instance inst) {
+		return inst.classIndex() > index ? index : index + 1;
+	}
+
+	/**
+	 * Gets the index of the attribute in a set of instances, given the index of the
+	 * attribute in the learner.
+	 * 
+	 * @param index the index of the attribute in the learner
+	 * @param insts the instances
+	 * @return the index of the attribute in the instances
+	 */
+	protected static int modelAttIndexToInstanceAttIndex(int index, InstancesHeader insts) {
+		return insts.classIndex() > index ? index : index + 1;
+	}
+
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		// We are restricting classifiers based on view mode
+		return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/AbstractEnsembleLearner.java b/moa/src/main/java/moa/learners/predictors/AbstractEnsembleLearner.java
new file mode 100644
index 000000000..20a09b393
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/AbstractEnsembleLearner.java
@@ -0,0 +1,97 @@
+package moa.learners.predictors;
+
+import java.util.ArrayList;
+
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Measurement;
+import moa.options.ClassOption;
+
+public abstract class AbstractEnsembleLearner<MLTask extends InstanceLearner> extends AbstractInstanceLearner<MLTask> {
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption baseLearnerOption;
+
+	public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's', "The number of models in the ensemble.",
+			10, 1, Integer.MAX_VALUE);
+
+	public ArrayList<MLTask> ensemble;
+
+	public AbstractEnsembleLearner(Class<MLTask> task) {
+		super(task);
+	}
+
+	@Override
+	public long measureByteSize() {
+		long size = 0;
+		for (MLTask c : ensemble)
+			size += c.measureByteSize();
+		return size;
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public void resetLearningImpl() {
+		this.ensemble = new ArrayList<>(this.ensembleSizeOption.getValue());
+		MLTask baseLearner = (MLTask) getPreparedClassOption(baseLearnerOption);
+		for (int i = 0; i < this.ensembleSizeOption.getValue(); i++) {
+			MLTask learner = (MLTask) baseLearner.copy();
+			learner.prepareForUse();
+			this.ensemble.add(learner);
+		}
+		this.setRandomSeed(randomSeed);
+	}
+
+	@Override
+	public void setRandomSeed(int seed) {
+		super.setRandomSeed(seed);
+		if (this.ensemble != null)
+			for (int i = 0; i < this.ensembleSizeOption.getValue(); i++) {
+				if (this.ensemble.get(i) != null)
+					this.ensemble.get(i).setRandomSeed(this.randomSeed + i + 1);
+			}
+	}
+
+	public abstract Prediction combinePredictions(Prediction[] predictions);
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		Prediction[] predictions = new Prediction[this.ensemble.size()];
+		for (int i = 0; i < this.ensemble.size(); i++) {
+			predictions[i] = this.ensemble.get(i).getPredictionForInstance(inst);
+		}
+		return combinePredictions(predictions);
+	}
+
+	public Prediction getPredictionForInstanceUsingN(Instance inst, int n) {
+		Prediction[] predictions = new Prediction[this.ensemble.size()];
+		for (int i = 0; i < n; i++) {
+			predictions[i] = this.ensemble.get(i).getPredictionForInstance(inst);
+		}
+		return combinePredictions(predictions);
+	}
+
+	@Override
+	public void modelContextSet() {
+		for (int i = 0; i < this.ensemble.size(); i++) {
+			this.ensemble.get(i).setModelContext(this.getModelContext());
+		}
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[] { new Measurement("ensemble size", this.ensemble != null ? this.ensemble.size() : 0) };
+	}
+
+	@Override
+	public MLTask[] getSublearners() {
+		MLTask[] out = ((MLTask[]) java.lang.reflect.Array.newInstance(TaskClass, this.ensemble.size()));
+		for (int i = 0; i < this.ensemble.size(); i++) {
+			out[i] = this.ensemble.get(i);
+		}
+		return out;
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/AbstractInstanceLearner.java b/moa/src/main/java/moa/learners/predictors/AbstractInstanceLearner.java
new file mode 100644
index 000000000..0074d4281
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/AbstractInstanceLearner.java
@@ -0,0 +1,385 @@
+/*
+ *    AbstractClassifier.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package moa.learners.predictors;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Random;
+
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.MOAObject;
+import moa.core.Example;
+import moa.core.Measurement;
+import moa.core.ObjectRepository;
+import moa.core.StringUtils;
+import moa.core.Utils;
+import moa.gui.AWTRenderer;
+import moa.options.AbstractOptionHandler;
+import moa.tasks.TaskMonitor;
+
+public abstract class AbstractInstanceLearner<MLTask extends InstanceLearner> extends AbstractOptionHandler
+		implements InstanceLearner {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "MOA Classifier: " + getClass().getCanonicalName();
+	}
+
+	/** Header of the instances of the data stream */
+	protected InstancesHeader modelContext;
+
+	protected Class<MLTask> TaskClass;
+
+	/** Sum of the weights of the instances trained by this model */
+	protected double trainingWeightSeenByModel = 0.0;
+
+	/** Random seed used in randomizable learners */
+	public int randomSeed = 1;
+
+	/** Option for randomizable learners to change the random seed */
+	public IntOption randomSeedOption;
+
+	/** Random Generator used in randomizable learners */
+	public Random classifierRandom;
+
+	/**
+	 * Creates an classifier and setups the random seed option if the classifier is
+	 * randomizable.
+	 */
+	public AbstractInstanceLearner(Class<MLTask> task) {
+		TaskClass = task;
+		if (isRandomizable()) {
+			this.randomSeedOption = new IntOption("randomSeed", 'r', "Seed for random behaviour of the classifier.", 1);
+		}
+	}
+
+	@Override
+	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		if (this.randomSeedOption != null) {
+			this.randomSeed = this.randomSeedOption.getValue();
+		}
+
+		// resetLearning should not be called if the classifier has not yet received the
+		// context
+		if (!trainingHasStarted()) {
+			resetLearning();
+		}
+	}
+
+	@Override
+	public abstract Prediction getPredictionForInstance(Instance instance);
+
+	@Override
+	public Prediction getPredictionForInstance(Example<Instance> example) {
+		return getPredictionForInstance(example.getData());
+	}
+
+	@Override
+	public void setModelContext(InstancesHeader ih) {
+		if ((ih != null) && (ih.numOutputAttributes() < 1)) {
+			throw new IllegalArgumentException("Context for a classifier must include a class to learn");
+		}
+		if (trainingHasStarted() && (this.modelContext != null)
+				&& ((ih == null) || !contextIsCompatible(this.modelContext, ih))) {
+			throw new IllegalArgumentException("New context is not compatible with existing model");
+		}
+		this.modelContext = ih;
+		this.modelContextSet();
+	}
+
+	public void modelContextSet() {
+	}
+
+	@Override
+	public InstancesHeader getModelContext() {
+		return this.modelContext;
+	}
+
+	@Override
+	public void setRandomSeed(int s) {
+		this.randomSeed = s;
+		if (this.randomSeedOption != null) {
+			// keep option consistent
+			this.randomSeedOption.setValue(s);
+		}
+	}
+
+	@Override
+	public int getRandomSeed() {
+		return this.randomSeed;
+	}
+
+	@Override
+	public boolean trainingHasStarted() {
+		return this.trainingWeightSeenByModel > 0.0;
+	}
+
+	@Override
+	public double trainingWeightSeenByModel() {
+		return this.trainingWeightSeenByModel;
+	}
+
+	@Override
+	public void resetLearning() {
+		this.trainingWeightSeenByModel = 0.0;
+		if (isRandomizable()) {
+			this.classifierRandom = new Random(this.randomSeed);
+		}
+		resetLearningImpl();
+	}
+
+	@Override
+	public void trainOnInstance(Instance inst) {
+		boolean isTraining = (inst.weight() > 0.0);
+		if (!(this instanceof SemiSupervisedInstanceLearner) && inst.missingOutputs()) {
+			isTraining = false;
+		}
+		if (isTraining) {
+			this.trainingWeightSeenByModel += inst.weight();
+			trainOnInstanceImpl(inst);
+		}
+	}
+
+	public abstract void trainOnInstanceImpl(Instance inst);
+
+	@Override
+	public Measurement[] getModelMeasurements() {
+		List<Measurement> measurementList = new LinkedList<>();
+		measurementList.add(new Measurement("model training instances", trainingWeightSeenByModel()));
+		measurementList.add(new Measurement("model serialized size (bytes)", measureByteSize()));
+		Measurement[] modelMeasurements = getModelMeasurementsImpl();
+		if (modelMeasurements != null) {
+			measurementList.addAll(Arrays.asList(modelMeasurements));
+		}
+		// add average of sub-model measurements
+		InstanceLearner[] subModels = getSublearners();
+		if ((subModels != null) && (subModels.length > 0)) {
+			List<Measurement[]> subMeasurements = new LinkedList<>();
+			for (InstanceLearner subModel : subModels) {
+				if (subModel != null) {
+					subMeasurements.add(subModel.getModelMeasurements());
+				}
+			}
+			Measurement[] avgMeasurements = Measurement
+					.averageMeasurements(subMeasurements.toArray(new Measurement[subMeasurements.size()][]));
+			measurementList.addAll(Arrays.asList(avgMeasurements));
+		}
+		return measurementList.toArray(new Measurement[measurementList.size()]);
+	}
+
+	@Override
+	public void getDescription(StringBuilder out, int indent) {
+		StringUtils.appendIndented(out, indent, "Model type: ");
+		out.append(this.getClass().getName());
+		StringUtils.appendNewline(out);
+		Measurement.getMeasurementsDescription(getModelMeasurements(), out, indent);
+		StringUtils.appendNewlineIndented(out, indent, "Model description:");
+		StringUtils.appendNewline(out);
+		if (trainingHasStarted()) {
+			getModelDescription(out, indent);
+		} else {
+			StringUtils.appendIndented(out, indent, "Model has not been trained.");
+		}
+	}
+
+	@Override
+	public InstanceLearner[] getSublearners() {
+		return getSubClassifiers();
+	}
+
+	public MLTask[] getSubClassifiers() {
+		return null;
+	}
+
+	@Override
+	public InstanceLearner copy() {
+		return (InstanceLearner) super.copy();
+	}
+
+	@Override
+	public MOAObject getModel() {
+		return this;
+	}
+
+	@Override
+	public void trainOnInstance(Example<Instance> example) {
+		trainOnInstance(example.getData());
+	}
+
+	/**
+	 * Gets the name of the attribute of the class from the header.
+	 *
+	 * @return the string with name of the attribute of the class
+	 */
+	public String getClassNameString() {
+		return InstancesHeader.getClassNameString(this.modelContext);
+	}
+
+	/**
+	 * Gets the name of a label of the class from the header.
+	 *
+	 * @param classLabelIndex the label index
+	 * @return the name of the label of the class
+	 */
+	public String getClassLabelString(int classLabelIndex) {
+		return InstancesHeader.getClassLabelString(this.modelContext, classLabelIndex);
+	}
+
+	/**
+	 * Gets the name of an attribute from the header.
+	 *
+	 * @param attIndex the attribute index
+	 * @return the name of the attribute
+	 */
+	public String getAttributeNameString(int attIndex) {
+		return InstancesHeader.getAttributeNameString(this.modelContext, attIndex);
+	}
+
+	/**
+	 * Gets the name of a value of an attribute from the header.
+	 *
+	 * @param attIndex the attribute index
+	 * @param valIndex the value of the attribute
+	 * @return the name of the value of the attribute
+	 */
+	public String getNominalValueString(int attIndex, int valIndex) {
+		return InstancesHeader.getNominalValueString(this.modelContext, attIndex, valIndex);
+	}
+
+	/**
+	 * Returns if two contexts or headers of instances are compatible.<br>
+	 * <br>
+	 *
+	 * Two contexts are compatible if they follow the following rules:<br>
+	 * Rule 1: num classes can increase but never decrease<br>
+	 * Rule 2: num attributes can increase but never decrease<br>
+	 * Rule 3: num nominal attribute values can increase but never decrease<br>
+	 * Rule 4: attribute types must stay in the same order (although class can move;
+	 * is always skipped over)<br>
+	 * <br>
+	 *
+	 * Attribute names are free to change, but should always still represent the
+	 * original attributes.
+	 *
+	 * @param originalContext the first context to compare
+	 * @param newContext      the second context to compare
+	 * @return true if the two contexts are compatible.
+	 */
+	public static boolean contextIsCompatible(InstancesHeader originalContext, InstancesHeader newContext) {
+		if (newContext.numInputAttributes() < originalContext.numInputAttributes()) {
+			return false; // rule 2
+		}
+		if (newContext.numOutputAttributes() < originalContext.numOutputAttributes()) {
+			return false; // rule 2
+		}
+		for (int i = 0; i < originalContext.numOutputAttributes(); i++) {
+			if (originalContext.inputAttribute(i).attributeType() != newContext.inputAttribute(i).attributeType()) {
+				return false; // rule 4
+			}
+			if (newContext.outputAttribute(i).numValues() < originalContext.outputAttribute(i).numValues()) {
+				return false; // rule 1
+			}
+		}
+		// Input attributes
+		for (int i = 0; i < originalContext.numInputAttributes(); i++) {
+			if (originalContext.inputAttribute(i).attributeType() != newContext.inputAttribute(i).attributeType()) {
+				return false; // rule 4
+			} else if (originalContext.inputAttribute(i).isNumeric()) {
+				if (newContext.inputAttribute(i).numValues() < originalContext.inputAttribute(i).numValues()) {
+					return false; // rule 3
+				}
+			}
+		}
+		return true; // all checks clear
+	}
+
+	/**
+	 * Returns the AWT Renderer
+	 *
+	 * @return the AWT Renderer
+	 */
+	@Override
+	public AWTRenderer getAWTRenderer() {
+		// TODO should return a default renderer here
+		// - or should null be interpreted as the default?
+		return null;
+	}
+
+	/**
+	 * Resets this classifier. It must be similar to starting a new classifier from
+	 * scratch. <br>
+	 * <br>
+	 * 
+	 * The reason for ...Impl methods: ease programmer burden by not requiring them
+	 * to remember calls to super in overridden methods. Note that this will produce
+	 * compiler errors if not overridden.
+	 */
+	public abstract void resetLearningImpl();
+
+	/**
+	 * Gets the current measurements of this classifier.<br>
+	 * <br>
+	 * 
+	 * The reason for ...Impl methods: ease programmer burden by not requiring them
+	 * to remember calls to super in overridden methods. Note that this will produce
+	 * compiler errors if not overridden.
+	 *
+	 * @return an array of measurements to be used in evaluation MLTasks
+	 */
+	protected abstract Measurement[] getModelMeasurementsImpl();
+
+	/**
+	 * Gets the index of the attribute in the instance, given the index of the
+	 * attribute in the learner.I
+	 *
+	 * @param index the index of the attribute in the learner
+	 * @param inst  the instance
+	 * @return the index in the instance
+	 */
+	protected static int modelAttIndexToInstanceAttIndex(int index, Instance inst) {
+		return inst.classIndex() > index ? index : index + 1;
+	}
+
+	/**
+	 * Gets the index of the attribute in a set of instances, given the index of the
+	 * attribute in the learner.
+	 * 
+	 * @param index the index of the attribute in the learner
+	 * @param insts the instances
+	 * @return the index of the attribute in the instances
+	 */
+	protected static int modelAttIndexToInstanceAttIndex(int index, InstancesHeader insts) {
+		return insts.classIndex() > index ? index : index + 1;
+	}
+
+	public boolean correctlyClassifies(Instance inst) {
+		// This is included here for ease of use. It should only be used by classifiers.
+		return Utils.maxIndex(getPredictionForInstance(inst)) == (int) inst.classValue();
+	}
+
+}
diff --git a/moa/src/main/java/moa/classifiers/AbstractMultiLabelClassifier.java b/moa/src/main/java/moa/learners/predictors/AbstractMultiLabelClassifier.java
similarity index 56%
rename from moa/src/main/java/moa/classifiers/AbstractMultiLabelClassifier.java
rename to moa/src/main/java/moa/learners/predictors/AbstractMultiLabelClassifier.java
index 33673a7ca..09158ff18 100644
--- a/moa/src/main/java/moa/classifiers/AbstractMultiLabelClassifier.java
+++ b/moa/src/main/java/moa/learners/predictors/AbstractMultiLabelClassifier.java
@@ -1,9 +1,8 @@
-package moa.classifiers;
+package moa.learners.predictors;
 
-import moa.learners.MultiLabelClassifier;
+public abstract class AbstractMultiLabelClassifier extends AbstractInstanceLearner<MultiLabelClassifier>
+		implements MultiLabelClassifier {
 
-public abstract class AbstractMultiLabelClassifier extends AbstractInstanceLearner<MultiLabelClassifier> implements MultiLabelClassifier {
-	
 	private static final long serialVersionUID = 1L;
 
 	public AbstractMultiLabelClassifier() {
diff --git a/moa/src/main/java/moa/classifiers/AbstractMultiTargetRegressor.java b/moa/src/main/java/moa/learners/predictors/AbstractMultiTargetRegressor.java
similarity index 56%
rename from moa/src/main/java/moa/classifiers/AbstractMultiTargetRegressor.java
rename to moa/src/main/java/moa/learners/predictors/AbstractMultiTargetRegressor.java
index 386ebd176..99a3fd68c 100644
--- a/moa/src/main/java/moa/classifiers/AbstractMultiTargetRegressor.java
+++ b/moa/src/main/java/moa/learners/predictors/AbstractMultiTargetRegressor.java
@@ -1,8 +1,7 @@
-package moa.classifiers;
+package moa.learners.predictors;
 
-import moa.learners.MultiTargetRegressor;
-
-public abstract class AbstractMultiTargetRegressor extends AbstractInstanceLearner<MultiTargetRegressor> implements MultiTargetRegressor {
+public abstract class AbstractMultiTargetRegressor extends AbstractInstanceLearner<MultiTargetRegressor>
+		implements MultiTargetRegressor {
 
 	private static final long serialVersionUID = 1L;
 
diff --git a/moa/src/main/java/moa/classifiers/AbstractRegressor.java b/moa/src/main/java/moa/learners/predictors/AbstractRegressor.java
similarity index 76%
rename from moa/src/main/java/moa/classifiers/AbstractRegressor.java
rename to moa/src/main/java/moa/learners/predictors/AbstractRegressor.java
index 7bcd5c9e4..69b96534e 100644
--- a/moa/src/main/java/moa/classifiers/AbstractRegressor.java
+++ b/moa/src/main/java/moa/learners/predictors/AbstractRegressor.java
@@ -1,6 +1,4 @@
-package moa.classifiers;
-
-import moa.learners.Regressor;
+package moa.learners.predictors;
 
 public abstract class AbstractRegressor extends AbstractInstanceLearner<Regressor> implements Regressor {
 
diff --git a/moa/src/main/java/moa/learners/predictors/ChangeDetectorLearner.java b/moa/src/main/java/moa/learners/predictors/ChangeDetectorLearner.java
new file mode 100644
index 000000000..69607964f
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/ChangeDetectorLearner.java
@@ -0,0 +1,86 @@
+/*
+ *    ChangeDetectorLearner.java
+ *    Copyright (C) 2011 University of Waikato, Hamilton, New Zealand
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package moa.learners.predictors;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Measurement;
+import moa.learners.predictors.core.driftdetection.ChangeDetector;
+import moa.options.ClassOption;
+
+/**
+ * Class for detecting concept drift and to be used as a learner.
+ * <p>
+ * data
+ *
+ * Valid options are:
+ * <p>
+ *
+ * -l classname <br>
+ * Specify the full class name of a classifier as the basis for the concept
+ * drift classifier.
+ * <p>
+ *
+ *
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @version $Revision: 7 $
+ */
+public class ChangeDetectorLearner extends AbstractClassifier implements Classifier {
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption driftDetectionMethodOption = new ClassOption("driftDetectionMethod", 'd',
+			"Drift detection method to use.", ChangeDetector.class, "DDM");
+
+	protected ChangeDetector driftDetectionMethod;
+
+	@Override
+	public void resetLearningImpl() {
+		this.driftDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.driftDetectionMethodOption)).copy();
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		this.driftDetectionMethod.input(inst.value(0));
+
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		return new ClassificationPrediction(this.driftDetectionMethod.getOutput());
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		// ((AbstractClassifier) this.classifier).getModelDescription(out, indent);
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		// return ((AbstractClassifier) this.classifier).getModelMeasurementsImpl();
+		return new Measurement[0];
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/Classifier.java b/moa/src/main/java/moa/learners/predictors/Classifier.java
new file mode 100644
index 000000000..24ace942b
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/Classifier.java
@@ -0,0 +1,63 @@
+/*
+ *    Classifier.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+/**
+ * Classifier interface for incremental classification models.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public interface Classifier extends InstanceLearner {
+
+	/**
+	 * Gets the classifiers of this ensemble. Returns null if this learner is a
+	 * single learner.
+	 *
+	 * @return an array of the learners of the ensemble
+	 */
+	// public Classifier[] getSubClassifiers();
+
+	/**
+	 * Predicts the class memberships for a given instance. If an instance is
+	 * unclassified, the returned array elements must be all zero.
+	 *
+	 * @param inst the instance to be classified
+	 * @return an array containing the estimated membership probabilities of the
+	 *         test instance in each class
+	 */
+	// public Prediction getPredictionForInstance(Instance inst);
+
+	boolean correctlyClassifies(Instance inst);
+
+	/**
+	 * Sets the reference to the header of the data stream. The header of the data
+	 * stream is extended from WEKA <code>Instances</code>. This header is needed to
+	 * know the number of classes and attributes
+	 *
+	 * @param ih the reference to the data stream header
+	 */
+	// public void setModelContext(InstancesHeader ih);
+
+	@Override
+	InstanceLearner copy();
+}
diff --git a/moa/src/main/java/moa/learners/InstanceLearner.java b/moa/src/main/java/moa/learners/predictors/InstanceLearner.java
similarity index 61%
rename from moa/src/main/java/moa/learners/InstanceLearner.java
rename to moa/src/main/java/moa/learners/predictors/InstanceLearner.java
index f863bfa1b..12644ac98 100644
--- a/moa/src/main/java/moa/learners/InstanceLearner.java
+++ b/moa/src/main/java/moa/learners/predictors/InstanceLearner.java
@@ -17,42 +17,38 @@
  *    along with this program; if not, write to the Free Software
  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
-package moa.learners;
+package moa.learners.predictors;
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
 import moa.core.Example;
+import moa.learners.MLTask;
 
 /**
- * Learner interface for incremental learning models. 
+ * Learner interface for incremental learning models.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
 public interface InstanceLearner extends MLTask<Example<Instance>> {
 
-
-        /**
-     * Trains this learner incrementally using the given example.
-     *
-     * @param inst the instance to be used for training
-     */
-    public void trainOnInstance(Instance example);
-
-    /**
-     * Predicts the class memberships for a given instance. If
-     * an instance is unclassified, the returned array elements
-     * must be all zero.
-     *
-     * @param inst the instance to be classified
-     * @return an array containing the estimated membership
-     * probabilities of the test instance in each class
-     */
-        public Prediction getPredictionForInstance(Instance testInst);
-	
-	public InstanceLearner[] getSublearners();
+	/**
+	 * Trains this learner incrementally using the given example.
+	 *
+	 * @param inst the instance to be used for training
+	 */
+	void trainOnInstance(Instance example);
+
+	/**
+	 * Predicts the class memberships for a given instance. If an instance is
+	 * unclassified, the returned array elements must be all zero.
+	 *
+	 * @param inst the instance to be classified
+	 * @return an array containing the estimated membership probabilities of the
+	 *         test instance in each class
+	 */
+	Prediction getPredictionForInstance(Instance testInst);
+
+	InstanceLearner[] getSublearners();
 }
-
-
-
diff --git a/moa/src/main/java/moa/learners/LearnerSemiSupervised.java b/moa/src/main/java/moa/learners/predictors/LearnerSemiSupervised.java
similarity index 80%
rename from moa/src/main/java/moa/learners/LearnerSemiSupervised.java
rename to moa/src/main/java/moa/learners/predictors/LearnerSemiSupervised.java
index 22ae383e1..aee1284b8 100644
--- a/moa/src/main/java/moa/learners/LearnerSemiSupervised.java
+++ b/moa/src/main/java/moa/learners/predictors/LearnerSemiSupervised.java
@@ -14,22 +14,23 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
-package moa.learners;
+package moa.learners.predictors;
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
 import moa.core.Example;
+import moa.learners.MLTask;
 
 /**
  *
  * @author RSousa
  */
-public interface LearnerSemiSupervised<E extends Example> extends MLTask<Example<Instance>>{
-    
-   public Prediction getTrainingPrediction();
- 
+public interface LearnerSemiSupervised<E extends Example<Instance>> extends MLTask<Example<Instance>> {
+
+	Prediction getTrainingPrediction();
+
 }
diff --git a/moa/src/main/java/moa/learners/predictors/MultiLabelClassifier.java b/moa/src/main/java/moa/learners/predictors/MultiLabelClassifier.java
new file mode 100644
index 000000000..eb7743137
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/MultiLabelClassifier.java
@@ -0,0 +1,51 @@
+package moa.learners.predictors;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+public interface MultiLabelClassifier extends InstanceLearner {
+
+	/**
+	 * Gets whether this classifier correctly classifies an instance. Uses
+	 * getPredictionForInstance to obtain the prediction and the instance to obtain
+	 * its true class.
+	 *
+	 *
+	 * @param inst the instance to be classified
+	 * @return true if the instance is correctly classified
+	 */
+	// TODO Add this to AbstractLearner
+	// public boolean correctlyClassifies(MultilabelInstance inst);
+
+	/**
+	 * Trains this learner incrementally using the given example.
+	 *
+	 * @param inst the instance to be used for training
+	 */
+	void trainOnInstanceImpl(Instance inst);
+
+	/**
+	 * Sets the reference to the header of the data stream. The header of the data
+	 * stream is extended from WEKA <code>Instances</code>. This header is needed to
+	 * know the number of classes and attributes
+	 *
+	 * @param ih the reference to the data stream header
+	 */
+	// public void setModelContext(InstancesHeader ih);
+
+	/**
+	 * Gets the reference to the header of the data stream. The header of the data
+	 * stream is extended from WEKA <code>Instances</code>. This header is needed to
+	 * know the number of classes and attributes
+	 *
+	 * @return the reference to the data stream header
+	 */
+	// public InstancesHeader getModelContext();
+
+	@Override
+	Prediction getPredictionForInstance(Instance inst);
+
+	@Override
+	InstanceLearner copy();
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/MultiTargetRegressor.java b/moa/src/main/java/moa/learners/predictors/MultiTargetRegressor.java
new file mode 100644
index 000000000..be9c8f3cf
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/MultiTargetRegressor.java
@@ -0,0 +1,76 @@
+/*
+ *    MultiTargetRegressor.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+/**
+ * MultiTargetRegressor interface for incremental MultiTarget regression models.
+ * It is used only in the GUI MultiTargetRegression Tab.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public interface MultiTargetRegressor extends InstanceLearner {
+
+	/**
+	 * Gets whether this classifier correctly classifies an instance. Uses
+	 * getPredictionForInstance to obtain the prediction and the instance to obtain
+	 * its true class.
+	 *
+	 *
+	 * @param inst the instance to be classified
+	 * @return true if the instance is correctly classified
+	 */
+	// TODO Add this to AbstractLearner
+	// public boolean correctlyClassifies(MultilabelInstance inst);
+
+	/**
+	 * Trains this learner incrementally using the given example.
+	 *
+	 * @param inst the instance to be used for training
+	 */
+	void trainOnInstanceImpl(Instance inst);
+
+	/**
+	 * Sets the reference to the header of the data stream. The header of the data
+	 * stream is extended from WEKA <code>Instances</code>. This header is needed to
+	 * know the number of classes and attributes
+	 *
+	 * @param ih the reference to the data stream header
+	 */
+	// public void setModelContext(InstancesHeader ih);
+
+	/**
+	 * Gets the reference to the header of the data stream. The header of the data
+	 * stream is extended from WEKA <code>Instances</code>. This header is needed to
+	 * know the number of classes and attributes
+	 *
+	 * @return the reference to the data stream header
+	 */
+	// public InstancesHeader getModelContext();
+
+	@Override
+	Prediction getPredictionForInstance(Instance inst);
+
+	@Override
+	InstanceLearner copy();
+}
diff --git a/moa/src/main/java/moa/classifiers/OneClassClassifier.java b/moa/src/main/java/moa/learners/predictors/OneClassClassifier.java
similarity index 64%
rename from moa/src/main/java/moa/classifiers/OneClassClassifier.java
rename to moa/src/main/java/moa/learners/predictors/OneClassClassifier.java
index dd778c372..dee333210 100644
--- a/moa/src/main/java/moa/classifiers/OneClassClassifier.java
+++ b/moa/src/main/java/moa/learners/predictors/OneClassClassifier.java
@@ -15,32 +15,33 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.classifiers;
+package moa.learners.predictors;
 
 import java.util.Collection;
 
 import com.yahoo.labs.samoa.instances.Instance;
 
 /**
- * An interface for incremental classifier models. As an extension of MultiClassClassifier, these
- * classifiers appear in the GUI Classification Tab. Marking them as OneClassClassifiers also
- * allows them to appear specifically when one-class classifiers are needed.
- * 
+ * An interface for incremental classifier models. As an extension of
+ * MultiClassClassifier, these classifiers appear in the GUI Classification Tab.
+ * Marking them as OneClassClassifiers also allows them to appear specifically
+ * when one-class classifiers are needed.
+ *
  * @author Richard Hugh Moulton
  *
  */
-public interface OneClassClassifier extends MultiClassClassifier
-{
+public interface OneClassClassifier extends Classifier {
 	/**
-	 * Allows a one class classifier to be initialized with a starting set of training instances.
+	 * Allows a one class classifier to be initialized with a starting set of
+	 * training instances.
 	 */
-	public void initialize(Collection<Instance> trainingPoints);
-	
+	void initialize(Collection<Instance> trainingPoints);
+
 	/**
-	 * For use when an anomaly score is needed instead of a vote.
-	 * The higher an instance's anomaly score is, the more likely it is an anomaly.
+	 * For use when an anomaly score is needed instead of a vote. The higher an
+	 * instance's anomaly score is, the more likely it is an anomaly.
 	 */
-	public double getAnomalyScore(Instance inst);
+	double getAnomalyScore(Instance inst);
 }
diff --git a/moa/src/main/java/moa/learners/Regressor.java b/moa/src/main/java/moa/learners/predictors/Regressor.java
similarity index 90%
rename from moa/src/main/java/moa/learners/Regressor.java
rename to moa/src/main/java/moa/learners/predictors/Regressor.java
index b12e980b5..2f8347728 100644
--- a/moa/src/main/java/moa/learners/Regressor.java
+++ b/moa/src/main/java/moa/learners/predictors/Regressor.java
@@ -15,18 +15,20 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.learners;
+package moa.learners.predictors;
 
 /**
- * Regressor interface for incremental regression models. It is used only in the GUI Regression Tab. 
+ * Regressor interface for incremental regression models. It is used only in the
+ * GUI Regression Tab.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
 public interface Regressor extends InstanceLearner {
 
-    public InstanceLearner copy();
-	
+	@Override
+	InstanceLearner copy();
+
 }
diff --git a/moa/src/main/java/moa/classifiers/drift/SingleClassifierDrift.java b/moa/src/main/java/moa/learners/predictors/SemiSupervisedClassifier.java
similarity index 54%
rename from moa/src/main/java/moa/classifiers/drift/SingleClassifierDrift.java
rename to moa/src/main/java/moa/learners/predictors/SemiSupervisedClassifier.java
index 583381b8a..06fbf7e83 100644
--- a/moa/src/main/java/moa/classifiers/drift/SingleClassifierDrift.java
+++ b/moa/src/main/java/moa/learners/predictors/SemiSupervisedClassifier.java
@@ -1,7 +1,7 @@
 /*
- *    SingleClassifierDrift.java
- *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
- *    @author Manuel Baena (mbaena@lcc.uma.es)
+ *    Regressor.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  *
  *    This program is free software; you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
@@ -15,26 +15,17 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.classifiers.drift;
-
+package moa.learners.predictors;
 
 /**
- * Class for handling concept drift datasets with a wrapper on a
- * classifier.<p>
- *
- * Valid options are:<p>
+ * Regressor interface for incremental regression models. It is used only in the
+ * GUI Regression Tab.
  *
- * -l classname <br>
- * Specify the full class name of a classifier as the basis for
- * the concept drift classifier.<p>
- * -d Drift detection method to use<br>
- *
- * @author Manuel Baena (mbaena@lcc.uma.es)
- * @version 1.1
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
  */
-public class SingleClassifierDrift extends DriftDetectionMethodClassifier{
-
+public interface SemiSupervisedClassifier extends SemiSupervisedInstanceLearner {
 
 }
diff --git a/moa/src/main/java/moa/learners/predictors/SemiSupervisedInstanceLearner.java b/moa/src/main/java/moa/learners/predictors/SemiSupervisedInstanceLearner.java
new file mode 100644
index 000000000..bdd9bfcde
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/SemiSupervisedInstanceLearner.java
@@ -0,0 +1,35 @@
+/*
+ *    SemiSupervisedLearner.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+/**
+ * Learner interface for incremental semi supervised models. It is used only in
+ * the GUI Regression Tab.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public interface SemiSupervisedInstanceLearner extends InstanceLearner {
+	
+	Prediction getTrainingPrediction(Instance inst);
+}
diff --git a/moa/src/main/java/moa/learners/predictors/SemiSupervisedMultiLabelClassifier.java b/moa/src/main/java/moa/learners/predictors/SemiSupervisedMultiLabelClassifier.java
new file mode 100644
index 000000000..324edca4f
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/SemiSupervisedMultiLabelClassifier.java
@@ -0,0 +1,31 @@
+/*
+ *    Regressor.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors;
+
+/**
+ * Regressor interface for incremental regression models. It is used only in the
+ * GUI Regression Tab.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public interface SemiSupervisedMultiLabelClassifier extends SemiSupervisedInstanceLearner {
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/SemiSupervisedMultiTargetRegressor.java b/moa/src/main/java/moa/learners/predictors/SemiSupervisedMultiTargetRegressor.java
new file mode 100644
index 000000000..1ed21d7d7
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/SemiSupervisedMultiTargetRegressor.java
@@ -0,0 +1,31 @@
+/*
+ *    Regressor.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors;
+
+/**
+ * Regressor interface for incremental regression models. It is used only in the
+ * GUI Regression Tab.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public interface SemiSupervisedMultiTargetRegressor extends SemiSupervisedInstanceLearner {
+
+}
diff --git a/moa/src/main/java/moa/classifiers/SemiSupervisedLearner.java b/moa/src/main/java/moa/learners/predictors/SemiSupervisedRegressor.java
similarity index 78%
rename from moa/src/main/java/moa/classifiers/SemiSupervisedLearner.java
rename to moa/src/main/java/moa/learners/predictors/SemiSupervisedRegressor.java
index 05caec5a0..dfee97fac 100644
--- a/moa/src/main/java/moa/classifiers/SemiSupervisedLearner.java
+++ b/moa/src/main/java/moa/learners/predictors/SemiSupervisedRegressor.java
@@ -1,5 +1,5 @@
 /*
- *    SemiSupervisedLearner.java
+ *    Regressor.java
  *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
  *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  *
@@ -15,16 +15,17 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.classifiers;
+package moa.learners.predictors;
 
 /**
- * Learner interface for incremental semi supervised models. It is used only in the GUI Regression Tab. 
+ * Regressor interface for incremental regression models. It is used only in the
+ * GUI Regression Tab.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public interface SemiSupervisedLearner {
-    
+public interface SemiSupervisedRegressor extends SemiSupervisedInstanceLearner {
+
 }
diff --git a/moa/src/main/java/moa/classifiers/active/ALClassifier.java b/moa/src/main/java/moa/learners/predictors/active/ALClassifier.java
similarity index 79%
rename from moa/src/main/java/moa/classifiers/active/ALClassifier.java
rename to moa/src/main/java/moa/learners/predictors/active/ALClassifier.java
index 34801b626..28889a916 100644
--- a/moa/src/main/java/moa/classifiers/active/ALClassifier.java
+++ b/moa/src/main/java/moa/learners/predictors/active/ALClassifier.java
@@ -15,24 +15,25 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.classifiers.active;
+package moa.learners.predictors.active;
 
-import moa.learners.Classifier;
+import moa.learners.predictors.Classifier;
 
 /**
- * Active Learning Classifier Interface to make AL Classifiers selectable in AL tasks.
+ * Active Learning Classifier Interface to make AL Classifiers selectable in AL
+ * tasks.
  *
  * @author Daniel Kottke (daniel dot kottke at ovgu dot de)
  * @version $Revision: 1 $
  */
 public interface ALClassifier extends Classifier {
 
-   /**
-     * Returns true if the previously chosen instance was added to the training set 
-     * of the active learner.
-     *
-     */
-	public int getLastLabelAcqReport();
+	/**
+	 * Returns true if the previously chosen instance was added to the training set
+	 * of the active learner.
+	 *
+	 */
+	int getLastLabelAcqReport();
 }
diff --git a/moa/src/main/java/moa/classifiers/active/ALRandom.java b/moa/src/main/java/moa/learners/predictors/active/ALRandom.java
similarity index 57%
rename from moa/src/main/java/moa/classifiers/active/ALRandom.java
rename to moa/src/main/java/moa/learners/predictors/active/ALRandom.java
index 0946d9e08..50f14ca3f 100644
--- a/moa/src/main/java/moa/classifiers/active/ALRandom.java
+++ b/moa/src/main/java/moa/learners/predictors/active/ALRandom.java
@@ -15,9 +15,9 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.classifiers.active;
+package moa.learners.predictors.active;
 
 import java.util.LinkedList;
 import java.util.List;
@@ -26,44 +26,42 @@
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.active.budget.BudgetManager;
 import moa.core.Measurement;
-import moa.learners.Classifier;
-import moa.learners.InstanceLearner;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.InstanceLearner;
+import moa.learners.predictors.active.budget.BudgetManager;
 import moa.options.ClassOption;
 
 public class ALRandom extends AbstractClassifier implements ALClassifier {
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 
-    @Override
-    public String getPurposeString() {
-        return "Random Active learning classifier for evolving data streams";
-    }
-    
-    public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l',
-            "Classifier to train.", Classifier.class, "moa.classifiers.drift.SingleClassifierDrift");
+	@Override
+	public String getPurposeString() {
+		return "Random Active learning classifier for evolving data streams";
+	}
+
+	public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l', "Classifier to train.", Classifier.class,
+			"drift.DriftDetectionMethodClassifier");
+
+	public ClassOption budgetManagerOption = new ClassOption("budgetManager", 'b', "BudgetManager that should be used.",
+			BudgetManager.class, "FixedBM");
 
-    public ClassOption budgetManagerOption = new ClassOption("budgetManager",
-            'b', "BudgetManager that should be used.",
-            BudgetManager.class, "FixedBM");
+	public Classifier classifier;
 
-    
-    public Classifier classifier;
+	public BudgetManager budgetManager;
 
-    public BudgetManager budgetManager;
-    
 	@Override
 	public int getLastLabelAcqReport() {
 		return budgetManager.getLastLabelAcqReport();
 	}
-	
+
 	@Override
 	public boolean isRandomizable() {
-        return true;
+		return true;
 	}
 
 	@Override
@@ -73,33 +71,33 @@ public Prediction getPredictionForInstance(Instance inst) {
 
 	@Override
 	public void resetLearningImpl() {
-        this.classifier = (Classifier) ((InstanceLearner) getPreparedClassOption(this.baseLearnerOption)).copy();
-        this.classifier.resetLearning();
-        this.budgetManager = ((BudgetManager) getPreparedClassOption(this.budgetManagerOption));
-        this.budgetManager.resetLearning();
+		this.classifier = (Classifier) ((InstanceLearner) getPreparedClassOption(this.baseLearnerOption)).copy();
+		this.classifier.resetLearning();
+		this.budgetManager = ((BudgetManager) getPreparedClassOption(this.budgetManagerOption));
+		this.budgetManager.resetLearning();
 	}
 
 	@Override
 	public void trainOnInstanceImpl(Instance inst) {
 		double value = this.classifierRandom.nextDouble();
-		if (this.budgetManager.isAbove(value)){
-            this.classifier.trainOnInstance(inst);
+		if (this.budgetManager.isAbove(value)) {
+			this.classifier.trainOnInstance(inst);
 		}
-		
+
 	}
 
 	@Override
 	protected Measurement[] getModelMeasurementsImpl() {
-        List<Measurement> measurementList = new LinkedList<Measurement>();
-        return measurementList.toArray(new Measurement[measurementList.size()]);
+		List<Measurement> measurementList = new LinkedList<>();
+		return measurementList.toArray(new Measurement[measurementList.size()]);
 	}
 
 	@Override
 	public void getModelDescription(StringBuilder out, int indent) {
-        ((AbstractClassifier) this.classifier).getModelDescription(out, indent);
-		
+		((AbstractClassifier) this.classifier).getModelDescription(out, indent);
+
 	}
-	
+
 	@Override
 	public void setModelContext(InstancesHeader ih) {
 		super.setModelContext(ih);
diff --git a/moa/src/main/java/moa/learners/predictors/active/ALUncertainty.java b/moa/src/main/java/moa/learners/predictors/active/ALUncertainty.java
new file mode 100644
index 000000000..8c90b9e21
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/active/ALUncertainty.java
@@ -0,0 +1,277 @@
+/*
+ *    ALUncertainty.java
+ *    Copyright (C) 2011 University of Waikato, Hamilton, New Zealand
+ *    @author Indre Zliobaite (zliobaite at gmail dot com)
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.active;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.Utils;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.InstanceLearner;
+import moa.options.ClassOption;
+
+/**
+ * Active learning setting for evolving data streams.
+ *
+ * <p>
+ * Active learning focuses on learning an accurate model with as few labels as
+ * possible. Streaming data poses additional challenges for active learning,
+ * since the data distribution may change over time (concept drift) and
+ * classifiers need to adapt. Conventional active learning strategies
+ * concentrate on querying the most uncertain instances, which are typically
+ * concentrated around the decision boundary. If changes do not occur close to
+ * the boundary, they will be missed and classifiers will fail to adapt. This
+ * class contains three active learning strategies for streaming data that
+ * explicitly handle concept drift. They are based on fixed uncertainty, dynamic
+ * allocation of labeling efforts over time and randomization of the search
+ * space [ZBPH]. It also contains the Selective Sampling strategy, which is
+ * adapted from [CGZ] and uses a variable labeling threshold.
+ * </p>
+ *
+ * <p>
+ * [ZBPH] Indre Zliobaite, Albert Bifet, Bernhard Pfahringer, Geoff Holmes:
+ * Active Learning with Evolving Streaming Data. ECML/PKDD (3) 2011: 597-612
+ * </p>
+ *
+ * <p>
+ * [CGZ] N. Cesa-Bianchi, C. Gentile, and L. Zaniboni. Worst-case analysis of
+ * selective sampling for linear classification. J. Mach. Learn. Res. (7) 2006:
+ * 1205-1230
+ * </p>
+ * .
+ *
+ * <p>
+ * Parameters:
+ * </p>
+ * <ul>
+ * <li>-l : Classifier to train</li>
+ * <li>-d : Strategy to use: FixedUncertainty, VarUncertainty,
+ * RandVarUncertainty, SelSampling</li>
+ * <li>-b : Budget to use</li>
+ * <li>-u : Fixed threshold</li>
+ * <li>-s : Floating budget step</li>
+ * <li>-n : Number of instances at beginning without active learning</li>
+ * </ul>
+ *
+ * <p>
+ * Structural changes to match active learning framework by Daniel Kottke.
+ * </p>
+ *
+ * @author Indre Zliobaite (zliobaite at gmail dot com)
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @author Daniel Kottke (daniel dot kottke at ovgu dot de) - adapted to AL
+ *         framework
+ * @version $Revision: 7 $
+ */
+public class ALUncertainty extends AbstractClassifier implements ALClassifier {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Active learning classifier for evolving data streams based on uncertainty";
+	}
+
+	public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l', "Classifier to train.", Classifier.class,
+			"drift.DriftDetectionMethodClassifier");
+
+	public MultiChoiceOption activeLearningStrategyOption = new MultiChoiceOption("activeLearningStrategy", 'd',
+			"Active Learning Strategy to use.",
+			new String[] { "FixedUncertainty", "VarUncertainty", "RandVarUncertainty", "SelSampling" },
+			new String[] { "Fixed uncertainty strategy", "Uncertainty strategy with variable threshold",
+					"Uncertainty strategy with randomized variable threshold", "Selective Sampling" },
+			0);
+
+	public FloatOption budgetOption = new FloatOption("budget", 'b', "Budget to use.", 0.1, 0.0, 1.0);
+
+	public FloatOption fixedThresholdOption = new FloatOption("fixedThreshold", 'u', "Fixed threshold.", 0.9, 0.00,
+			1.00);
+
+	public FloatOption stepOption = new FloatOption("step", 's', "Floating budget step.", 0.01, 0.00, 1.00);
+
+	public FloatOption numInstancesInitOption = new FloatOption("numInstancesInit", 'n',
+			"Number of instances at beginning without active learning.", 0.0, 0.00, Integer.MAX_VALUE);
+
+	public Classifier classifier;
+
+	public int lastLabelAcq = 0;
+
+	public int costLabeling;
+
+	public int iterationControl;
+
+	public double newThreshold;
+
+	public double maxPosterior;
+
+	public double accuracyBaseLearner;
+
+	private double outPosterior;
+
+	private double getMaxPosterior(double[] incomingPrediction) {
+		if (incomingPrediction.length > 1) {
+			DoubleVector vote = new DoubleVector(incomingPrediction);
+			if (vote.sumOfValues() > 0.0) {
+				vote.normalize();
+			}
+			incomingPrediction = vote.getArrayRef();
+			outPosterior = (incomingPrediction[Utils.maxIndex(incomingPrediction)]);
+		} else {
+			outPosterior = 0;
+		}
+		return outPosterior;
+	}
+
+	private void labelFixed(double incomingPosterior, Instance inst) {
+		if (incomingPosterior < this.fixedThresholdOption.getValue()) {
+			this.classifier.trainOnInstance(inst);
+			this.costLabeling++;
+			this.lastLabelAcq += 1;
+		}
+	}
+
+	private void labelVar(double incomingPosterior, Instance inst) {
+		if (incomingPosterior < this.newThreshold) {
+			this.classifier.trainOnInstance(inst);
+			this.costLabeling++;
+			this.lastLabelAcq += 1;
+			this.newThreshold *= (1 - this.stepOption.getValue());
+		} else {
+			this.newThreshold *= (1 + this.stepOption.getValue());
+		}
+	}
+
+	private void labelSelSampling(double incomingPosterior, Instance inst) {
+		double p = Math.abs(incomingPosterior - 1.0 / (inst.numClasses()));
+		double budget = this.budgetOption.getValue() / (this.budgetOption.getValue() + p);
+		if (this.classifierRandom.nextDouble() < budget) {
+			this.classifier.trainOnInstance(inst);
+			this.costLabeling++;
+			this.lastLabelAcq += 1;
+		}
+	}
+
+	@Override
+	public void resetLearningImpl() {
+		this.classifier = (Classifier) ((InstanceLearner) getPreparedClassOption(this.baseLearnerOption)).copy();
+		this.classifier.resetLearning();
+		this.costLabeling = 0;
+		this.iterationControl = 0;
+		this.newThreshold = 1.0;
+		this.accuracyBaseLearner = 0;
+		this.lastLabelAcq = 0;
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+
+		this.iterationControl++;
+
+		double costNow;
+
+		if (this.iterationControl <= this.numInstancesInitOption.getValue()) {
+			costNow = 0;
+			// Use all instances at the beginning
+			this.classifier.trainOnInstance(inst);
+			this.costLabeling++;
+			return;
+		} else {
+			costNow = (this.costLabeling - this.numInstancesInitOption.getValue())
+					/ (this.iterationControl - this.numInstancesInitOption.getValue());
+		}
+
+		if (costNow < this.budgetOption.getValue()) { // allow to label
+			switch (this.activeLearningStrategyOption.getChosenIndex()) {
+			case 0: // Random
+				maxPosterior = getMaxPosterior(this.classifier.getPredictionForInstance(inst).asDoubleArray());
+				labelFixed(maxPosterior, inst);
+				break;
+			case 1: // variable
+				maxPosterior = getMaxPosterior(this.classifier.getPredictionForInstance(inst).asDoubleArray());
+				labelVar(maxPosterior, inst);
+				break;
+			case 2: // randomized
+				maxPosterior = getMaxPosterior(this.classifier.getPredictionForInstance(inst).asDoubleArray());
+				maxPosterior = maxPosterior / (this.classifierRandom.nextGaussian() + 1.0);
+				labelVar(maxPosterior, inst);
+				break;
+			case 3: // selective-sampling
+				maxPosterior = getMaxPosterior(this.classifier.getPredictionForInstance(inst).asDoubleArray());
+				labelSelSampling(maxPosterior, inst);
+				break;
+			}
+		}
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		return this.classifier.getPredictionForInstance(inst);
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		((AbstractClassifier) this.classifier).getModelDescription(out, indent);
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		List<Measurement> measurementList = new LinkedList<>();
+		measurementList.add(new Measurement("labeling cost", this.costLabeling));
+		measurementList.add(new Measurement("newThreshold", this.newThreshold));
+		measurementList.add(new Measurement("maxPosterior", this.maxPosterior));
+		measurementList.add(
+				new Measurement("accuracyBaseLearner (percent)", 100 * this.accuracyBaseLearner / this.costLabeling));
+		Measurement[] modelMeasurements = ((AbstractClassifier) this.classifier).getModelMeasurements();
+		if (modelMeasurements != null) {
+			for (Measurement measurement : modelMeasurements) {
+				measurementList.add(measurement);
+			}
+		}
+		return measurementList.toArray(new Measurement[measurementList.size()]);
+	}
+
+	@Override
+	public int getLastLabelAcqReport() {
+		int help = this.lastLabelAcq;
+		this.lastLabelAcq = 0;
+		return help;
+	}
+
+	@Override
+	public void setModelContext(InstancesHeader ih) {
+		super.setModelContext(ih);
+		classifier.setModelContext(ih);
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/active/budget/BudgetManager.java b/moa/src/main/java/moa/learners/predictors/active/budget/BudgetManager.java
similarity index 87%
rename from moa/src/main/java/moa/classifiers/active/budget/BudgetManager.java
rename to moa/src/main/java/moa/learners/predictors/active/budget/BudgetManager.java
index 684aa6ff4..77f0dece1 100644
--- a/moa/src/main/java/moa/classifiers/active/budget/BudgetManager.java
+++ b/moa/src/main/java/moa/learners/predictors/active/budget/BudgetManager.java
@@ -15,17 +15,17 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
-package moa.classifiers.active.budget;
+package moa.learners.predictors.active.budget;
 
 /**
  * Budget Manager Interface to make AL Classifiers select the most beneficial
  * instances. A Budget Manager is defined in that way that it defines a
  * threshold internally and tests if the internal value is above or equal that
  * threshold.
- * 
+ *
  * This Budget Manager assumes that a new instance is processed each time the
  * method 'isAbove' is called and that the number of acquired instances equals
  * the number of returned 'true's.
@@ -36,19 +36,19 @@
 public interface BudgetManager {
 
 	/**
-	 * Returns true if the given value is above an internal threshold and the 
-	 * label should be acquired.
+	 * Returns true if the given value is above an internal threshold and the label
+	 * should be acquired.
 	 */
-	public boolean isAbove(double value);
+	boolean isAbove(double value);
 
 	/**
-	 * Returns the number of labels that have been chosen for acquisition since
-	 * the last report.
+	 * Returns the number of labels that have been chosen for acquisition since the
+	 * last report.
 	 */
-	public int getLastLabelAcqReport();
+	int getLastLabelAcqReport();
 
 	/**
 	 * Resets the budget manager.
 	 */
-	public void resetLearning();
+	void resetLearning();
 }
diff --git a/moa/src/main/java/moa/classifiers/active/budget/FixedBM.java b/moa/src/main/java/moa/learners/predictors/active/budget/FixedBM.java
similarity index 82%
rename from moa/src/main/java/moa/classifiers/active/budget/FixedBM.java
rename to moa/src/main/java/moa/learners/predictors/active/budget/FixedBM.java
index 3bbd3ef5b..472282bf6 100644
--- a/moa/src/main/java/moa/classifiers/active/budget/FixedBM.java
+++ b/moa/src/main/java/moa/learners/predictors/active/budget/FixedBM.java
@@ -15,9 +15,9 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.classifiers.active.budget;
+package moa.learners.predictors.active.budget;
 
 import com.github.javacliparser.FloatOption;
 
@@ -27,27 +27,25 @@
 
 public class FixedBM extends AbstractOptionHandler implements BudgetManager {
 
-    
 	@Override
-    public String getPurposeString() {
-        return "Budget manager with a fixed budget.";
-    }
-	
-	public FloatOption budgetOption = new FloatOption("budget",
-    		'b', "The budget that should be used by the BudgetManager.",
-    		0.1, 0.00, 1.00);
-    
+	public String getPurposeString() {
+		return "Budget manager with a fixed budget.";
+	}
+
+	public FloatOption budgetOption = new FloatOption("budget", 'b',
+			"The budget that should be used by the BudgetManager.", 0.1, 0.00, 1.00);
+
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 
 	int acquisitionReport = 0;
-	
+
 	@Override
 	public boolean isAbove(double value) {
 		boolean acquire = false;
-		if (value >= (1-budgetOption.getValue()))
+		if (value >= (1 - budgetOption.getValue()))
 			acquire = true;
 		if (acquire)
 			this.acquisitionReport++;
@@ -68,12 +66,12 @@ public void resetLearning() {
 
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
-		
+
 	}
 
 	@Override
 	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-		
+
 	}
 
 }
diff --git a/moa/src/main/java/moa/learners/predictors/bayes/NaiveBayes.java b/moa/src/main/java/moa/learners/predictors/bayes/NaiveBayes.java
new file mode 100644
index 000000000..54cdb7f8a
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/bayes/NaiveBayes.java
@@ -0,0 +1,198 @@
+/*
+ *    NaiveBayes.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.bayes;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.capabilities.CapabilitiesHandler;
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.StringUtils;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.core.attributeclassobservers.AttributeClassObserver;
+import moa.learners.predictors.core.attributeclassobservers.GaussianNumericAttributeClassObserver;
+import moa.learners.predictors.core.attributeclassobservers.NominalAttributeClassObserver;
+
+/**
+ * Naive Bayes incremental learner.
+ *
+ * <p>
+ * Performs classic bayesian prediction while making naive assumption that all
+ * inputs are independent.<br />
+ * Naive Bayes is a classifier algorithm known for its simplicity and low
+ * computational cost. Given n different classes, the trained Naive Bayes
+ * classifier predicts for every unlabelled instance I the class C to which it
+ * belongs with high accuracy.
+ * </p>
+ *
+ * <p>
+ * Parameters:
+ * </p>
+ * <ul>
+ * <li>-r : Seed for random behaviour of the classifier</li>
+ * </ul>
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public class NaiveBayes extends AbstractClassifier implements Classifier, CapabilitiesHandler {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Naive Bayes classifier: performs classic bayesian prediction while making naive assumption that all inputs are independent.";
+	}
+
+	protected DoubleVector observedClassDistribution;
+
+	protected AutoExpandVector<AttributeClassObserver> attributeObservers;
+
+	@Override
+	public void resetLearningImpl() {
+		this.observedClassDistribution = new DoubleVector();
+		this.attributeObservers = new AutoExpandVector<>();
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight());
+		for (int i = 0; i < inst.numAttributes() - 1; i++) {
+			int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
+			AttributeClassObserver obs = this.attributeObservers.get(i);
+			if (obs == null) {
+				obs = inst.attribute(instAttIndex).isNominal() ? newNominalClassObserver() : newNumericClassObserver();
+				this.attributeObservers.set(i, obs);
+			}
+			obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
+		}
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		return new ClassificationPrediction(
+				doNaiveBayesPrediction(inst, this.observedClassDistribution, this.attributeObservers));
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return null;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		for (int i = 0; i < this.observedClassDistribution.numValues(); i++) {
+			StringUtils.appendIndented(out, indent, "Observations for ");
+			out.append(getClassNameString());
+			out.append(" = ");
+			out.append(getClassLabelString(i));
+			out.append(":");
+			StringUtils.appendNewlineIndented(out, indent + 1, "Total observed weight = ");
+			out.append(this.observedClassDistribution.getValue(i));
+			out.append(" / prob = ");
+			out.append(this.observedClassDistribution.getValue(i) / this.observedClassDistribution.sumOfValues());
+			for (int j = 0; j < this.attributeObservers.size(); j++) {
+				StringUtils.appendNewlineIndented(out, indent + 1, "Observations for ");
+				out.append(getAttributeNameString(j));
+				out.append(": ");
+				// TODO: implement observer output
+				out.append(this.attributeObservers.get(j));
+			}
+			StringUtils.appendNewline(out);
+		}
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+
+	protected AttributeClassObserver newNominalClassObserver() {
+		return new NominalAttributeClassObserver();
+	}
+
+	protected AttributeClassObserver newNumericClassObserver() {
+		return new GaussianNumericAttributeClassObserver();
+	}
+
+	public static double[] doNaiveBayesPrediction(Instance inst, DoubleVector observedClassDistribution,
+			AutoExpandVector<AttributeClassObserver> attributeObservers) {
+		double[] votes = new double[observedClassDistribution.numValues()];
+		double observedClassSum = observedClassDistribution.sumOfValues();
+		for (int classIndex = 0; classIndex < votes.length; classIndex++) {
+			votes[classIndex] = observedClassDistribution.getValue(classIndex) / observedClassSum;
+			for (int attIndex = 0; attIndex < inst.numAttributes() - 1; attIndex++) {
+				int instAttIndex = modelAttIndexToInstanceAttIndex(attIndex, inst);
+				AttributeClassObserver obs = attributeObservers.get(attIndex);
+				if ((obs != null) && !inst.isMissing(instAttIndex)) {
+					votes[classIndex] *= obs.probabilityOfAttributeValueGivenClass(inst.value(instAttIndex),
+							classIndex);
+				}
+			}
+		}
+		// TODO: need logic to prevent underflow?
+		return votes;
+	}
+
+	// Naive Bayes Prediction using log10 for VFDR rules
+	public static double[] doNaiveBayesPredictionLog(Instance inst, DoubleVector observedClassDistribution,
+			AutoExpandVector<AttributeClassObserver> observers, AutoExpandVector<AttributeClassObserver> observers2) {
+		AttributeClassObserver obs;
+		double[] votes = new double[observedClassDistribution.numValues()];
+		double observedClassSum = observedClassDistribution.sumOfValues();
+		for (int classIndex = 0; classIndex < votes.length; classIndex++) {
+			votes[classIndex] = Math.log10(observedClassDistribution.getValue(classIndex) / observedClassSum);
+			for (int attIndex = 0; attIndex < inst.numAttributes() - 1; attIndex++) {
+				int instAttIndex = modelAttIndexToInstanceAttIndex(attIndex, inst);
+				if (inst.attribute(instAttIndex).isNominal()) {
+					obs = observers.get(attIndex);
+				} else {
+					obs = observers2.get(attIndex);
+				}
+
+				if ((obs != null) && !inst.isMissing(instAttIndex)) {
+					votes[classIndex] += Math
+							.log10(obs.probabilityOfAttributeValueGivenClass(inst.value(instAttIndex), classIndex));
+
+				}
+			}
+		}
+		return votes;
+
+	}
+
+	public void manageMemory(int currentByteSize, int maxByteSize) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == NaiveBayes.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/bayes/NaiveBayesMultinomial.java b/moa/src/main/java/moa/learners/predictors/bayes/NaiveBayesMultinomial.java
new file mode 100644
index 000000000..a690c2301
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/bayes/NaiveBayesMultinomial.java
@@ -0,0 +1,278 @@
+/*
+ *    NaiveBayesMultinomial.java
+ *    Copyright (C) 2011 University of Waikato, Hamilton, New Zealand
+ *    @author Bernhard Pfahringer (bernhard@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package moa.learners.predictors.bayes;
+
+import java.util.Arrays;
+
+import com.github.javacliparser.FloatOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.StringUtils;
+import moa.core.Utils;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+
+/**
+ * <!-- globalinfo-start --> Class for building and using a multinomial Naive
+ * Bayes classifier. Performs text classic bayesian prediction while making
+ * naive assumption that all inputs are independent. For more information
+ * see,<br/>
+ * <br/>
+ * Andrew Mccallum, Kamal Nigam: A Comparison of Event Models for Naive Bayes
+ * Text Classification. In: AAAI-98 Workshop on 'Learning for Text
+ * Categorization', 1998.<br/>
+ * <br/>
+ * The core equation for this classifier:<br/>
+ * <br/>
+ * P[Ci|D] = (P[D|Ci] x P[Ci]) / P[D] (Bayes rule)<br/>
+ * <br/>
+ * where Ci is class i and D is a document.<br/>
+ * <br/>
+ * Incremental version of the algorithm.
+ * <p/>
+ * <!-- globalinfo-end --> * <!-- technical-bibtex-start --> BibTeX:
+ * 
+ * <pre>
+ * &#64;inproceedings{Mccallum1998,
+ *    author = {Andrew Mccallum and Kamal Nigam},
+ *    booktitle = {AAAI-98 Workshop on 'Learning for Text Categorization'},
+ *    title = {A Comparison of Event Models for Naive Bayes Text Classification},
+ *    year = {1998}
+ * }
+ * </pre>
+ * <p/>
+ * <!-- technical-bibtex-end -->
+ */
+public class NaiveBayesMultinomial extends AbstractClassifier implements Classifier {
+
+	public FloatOption laplaceCorrectionOption = new FloatOption("laplaceCorrection", 'l', "Laplace correction factor.",
+			1.0, 0.00, Integer.MAX_VALUE);
+
+	/**
+	 * for serialization
+	 */
+	private static final long serialVersionUID = -7204398796974263187L;
+
+	@Override
+	public String getPurposeString() {
+		return "Multinomial Naive Bayes classifier: performs classic bayesian prediction while making naive assumption that all inputs are independent.";
+	}
+
+	/**
+	 * sum of weight_of_instance * word_count_of_instance for each class
+	 */
+	protected double[] m_classTotals;
+
+	/**
+	 * copy of header information for use in toString method
+	 */
+	protected InstancesHeader m_headerInfo;
+
+	/**
+	 * number of class values
+	 */
+	protected int m_numClasses;
+
+	/**
+	 * the probability of a class (i.e. Pr[H])
+	 */
+	protected double[] m_probOfClass;
+
+	/**
+	 * probability that a word (w) exists in a class (H) (i.e. Pr[w|H]) The matrix
+	 * is in the this format: m_wordTotalForClass[wordAttribute][class]
+	 */
+	protected DoubleVector[] m_wordTotalForClass;
+
+	protected boolean reset = false;
+
+	@Override
+	public void resetLearningImpl() {
+		this.reset = true;
+	}
+
+	/**
+	 * Trains the classifier with the given instance.
+	 *
+	 * @param inst the new training instance to include in the model
+	 */
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		if (this.reset == true) {
+			this.m_numClasses = inst.numClasses();
+			double laplace = this.laplaceCorrectionOption.getValue();
+			int numAttributes = inst.numAttributes();
+
+			m_probOfClass = new double[m_numClasses];
+			Arrays.fill(m_probOfClass, laplace);
+
+			m_classTotals = new double[m_numClasses];
+			Arrays.fill(m_classTotals, laplace * numAttributes);
+
+			m_wordTotalForClass = new DoubleVector[m_numClasses];
+			for (int i = 0; i < m_numClasses; i++) {
+				// Arrays.fill(wordTotal, laplace);
+				m_wordTotalForClass[i] = new DoubleVector();
+			}
+			this.reset = false;
+		}
+		// Update classifier
+		int classIndex = inst.classIndex();
+		int classValue = (int) inst.classValue();// value(classIndex);
+
+		double w = inst.weight();
+		m_probOfClass[classValue] += w;
+
+		m_classTotals[classValue] += w * totalSize(inst);
+		double total = m_classTotals[classValue];
+
+		for (int i = 0; i < inst.numValues(); i++) {
+			int index = inst.index(i);
+			if (index != classIndex && !inst.isMissing(i)) {
+				// m_wordTotalForClass[index][classValue] += w * inst.valueSparse(i);
+				double laplaceCorrection = 0.0;
+				if (m_wordTotalForClass[classValue].getValue(index) == 0) {
+					laplaceCorrection = this.laplaceCorrectionOption.getValue();
+				}
+				m_wordTotalForClass[classValue].addToValue(index, w * inst.valueSparse(i) + laplaceCorrection);
+			}
+		}
+	}
+
+	/**
+	 * Calculates the class membership probabilities for the given test instance.
+	 *
+	 * @param instance the instance to be classified
+	 * @return predicted class probability distribution
+	 */
+	@Override
+	public Prediction getPredictionForInstance(Instance instance) {
+		if (this.reset == true) {
+			return new ClassificationPrediction();
+		}
+		double[] probOfClassGivenDoc = new double[m_numClasses];
+		double totalSize = totalSize(instance);
+
+		for (int i = 0; i < m_numClasses; i++) {
+			probOfClassGivenDoc[i] = Math.log(m_probOfClass[i]) - totalSize * Math.log(m_classTotals[i]);
+		}
+
+		for (int i = 0; i < instance.numValues(); i++) {
+
+			int index = instance.index(i);
+			if (index == instance.classIndex() || instance.isMissing(i)) {
+				continue;
+			}
+
+			double wordCount = instance.valueSparse(i);
+			for (int c = 0; c < m_numClasses; c++) {
+				double value = m_wordTotalForClass[c].getValue(index);
+				probOfClassGivenDoc[c] += wordCount
+						* Math.log(value == 0 ? this.laplaceCorrectionOption.getValue() : value);
+			}
+		}
+
+		return new ClassificationPrediction(Utils.logs2probs(probOfClassGivenDoc));
+	}
+
+	public double totalSize(Instance instance) {
+		int classIndex = instance.classIndex();
+		double total = 0.0;
+		for (int i = 0; i < instance.numValues(); i++) {
+			int index = instance.index(i);
+			if (index == classIndex || instance.isMissing(i)) {
+				continue;
+			}
+			double count = instance.valueSparse(i);
+			if (count >= 0) {
+				total += count;
+			} else {
+				// throw new Exception("Numeric attribute value is not >= 0. " + i + " " + index
+				// + " " +
+				// instance.valueSparse(i) + " " + " " + instance);
+			}
+		}
+		return total;
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return null;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder result, int indent) {
+		StringUtils.appendIndented(result, indent, "xxx MNB1 xxx\n\n");
+
+		result.append("The independent probability of a class\n");
+		result.append("--------------------------------------\n");
+
+		for (int c = 0; c < m_numClasses; c++) {
+			result.append(m_headerInfo.classAttribute().value(c)).append("\t").append(Double.toString(m_probOfClass[c]))
+					.append("\n");
+		}
+
+		result.append("\nThe probability of a word given the class\n");
+		result.append("-----------------------------------------\n\t");
+
+		for (int c = 0; c < m_numClasses; c++) {
+			result.append(m_headerInfo.classAttribute().value(c)).append("\t");
+		}
+
+		result.append("\n");
+
+		for (int w = 0; w < m_headerInfo.numAttributes(); w++) {
+			if (w == m_headerInfo.classIndex()) {
+				continue;
+			}
+			result.append(m_headerInfo.attribute(w).name()).append("\t");
+			for (int c = 0; c < m_numClasses; c++) {
+				double value = m_wordTotalForClass[c].getValue(w);
+				if (value == 0) {
+					value = this.laplaceCorrectionOption.getValue();
+				}
+				result.append(value / m_classTotals[c]).append("\t");
+			}
+			result.append("\n");
+		}
+		StringUtils.appendNewline(result);
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == NaiveBayesMultinomial.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/AttributeSplitSuggestion.java b/moa/src/main/java/moa/learners/predictors/core/AttributeSplitSuggestion.java
new file mode 100644
index 000000000..4867cc349
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/AttributeSplitSuggestion.java
@@ -0,0 +1,65 @@
+/*
+ *    AttributeSplitSuggestion.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.core;
+
+import moa.AbstractMOAObject;
+import moa.learners.predictors.core.conditionaltests.InstanceConditionalTest;
+
+/**
+ * Class for computing attribute split suggestions given a split test.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public class AttributeSplitSuggestion extends AbstractMOAObject implements Comparable<AttributeSplitSuggestion> {
+
+	private static final long serialVersionUID = 1L;
+
+	public InstanceConditionalTest splitTest;
+
+	public double[][] resultingClassDistributions;
+
+	public double merit;
+
+	public AttributeSplitSuggestion(InstanceConditionalTest splitTest, double[][] resultingClassDistributions,
+			double merit) {
+		this.splitTest = splitTest;
+		this.resultingClassDistributions = resultingClassDistributions.clone();
+		this.merit = merit;
+	}
+
+	public int numSplits() {
+		return this.resultingClassDistributions.length;
+	}
+
+	public double[] resultingClassDistributionFromSplit(int splitIndex) {
+		return this.resultingClassDistributions[splitIndex].clone();
+	}
+
+	@Override
+	public int compareTo(AttributeSplitSuggestion comp) {
+		return Double.compare(this.merit, comp.merit);
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java b/moa/src/main/java/moa/learners/predictors/core/LearningLiteral.java
similarity index 54%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java
rename to moa/src/main/java/moa/learners/predictors/core/LearningLiteral.java
index fefc2788d..19f607ad0 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/LearningLiteral.java
+++ b/moa/src/main/java/moa/learners/predictors/core/LearningLiteral.java
@@ -1,4 +1,4 @@
-package moa.classifiers.rules.multilabel.core;
+package moa.learners.predictors.core;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -9,44 +9,42 @@
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-import moa.classifiers.core.driftdetection.ChangeDetector;
-import moa.classifiers.mlc.core.attributeclassobservers.AttributeStatisticsObserver;
-import moa.classifiers.mlc.core.attributeclassobservers.NominalStatisticsObserver;
-import moa.classifiers.mlc.core.attributeclassobservers.NumericStatisticsObserver;
-import moa.classifiers.mlc.core.splitcriteria.MultiLabelSplitCriterion;
-import moa.classifiers.rules.core.AttributeExpansionSuggestion;
-import moa.classifiers.rules.core.anomalydetection.AnomalyDetector;
-import moa.classifiers.rules.multilabel.errormeasurers.MultiLabelErrorMeasurer;
-import moa.classifiers.rules.multilabel.inputselectors.InputAttributesSelector;
-import moa.classifiers.rules.multilabel.instancetransformers.InstanceTransformer;
-import moa.classifiers.rules.multilabel.outputselectors.OutputAttributesSelector;
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
-import moa.learners.InstanceLearner;
-import moa.learners.MultiLabelClassifier;
+import moa.learners.predictors.InstanceLearner;
+import moa.learners.predictors.core.attributeclassobservers.AttributeStatisticsObserver;
+import moa.learners.predictors.core.attributeclassobservers.NominalStatisticsObserver;
+import moa.learners.predictors.core.attributeclassobservers.NumericStatisticsObserver;
+import moa.learners.predictors.core.driftdetection.ChangeDetector;
+import moa.learners.predictors.core.errormeasurers.MultiLabelErrorMeasurer;
+import moa.learners.predictors.core.inputselectors.InputAttributesSelector;
+import moa.learners.predictors.core.instancetransformers.InstanceTransformer;
+import moa.learners.predictors.core.outputselectors.OutputAttributesSelector;
+import moa.learners.predictors.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.learners.predictors.rules.core.AttributeExpansionSuggestion;
+import moa.learners.predictors.rules.core.anomalydetection.AnomalyDetector;
 import moa.options.AbstractOptionHandler;
 
-
 public abstract class LearningLiteral extends AbstractOptionHandler {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 
-	protected AutoExpandVector<AttributeStatisticsObserver> attributeObservers ;
+	protected AutoExpandVector<AttributeStatisticsObserver> attributeObservers;
 
 	protected DoubleVector[] literalStatistics;
 
 	protected int[] outputsToLearn;
 
-	protected int [] inputsToLearn;
+	protected int[] inputsToLearn;
 
 	protected InstanceLearner learner;
 
 	protected MultiLabelErrorMeasurer errorMeasurer;
 
-	//change detector for each outputsToLearn
+	// change detector for each outputsToLearn
 	protected ChangeDetector[] changeDetectors;
 
 	protected ChangeDetector changeDetector;
@@ -62,72 +60,72 @@ public abstract class LearningLiteral extends AbstractOptionHandler {
 	protected LearningLiteral expandedLearningLiteral;
 
 	protected LearningLiteral otherBranchLearningLiteral;
-	
+
 	protected LearningLiteral otherOutputsLearningLiteral;
 
 	protected AttributeExpansionSuggestion bestSuggestion;
 
 	protected NumericStatisticsObserver numericStatisticsObserver;
-	
+
 	protected NominalStatisticsObserver nominalStatisticsObserver;
 
 	protected OutputAttributesSelector outputSelector;
 
 	protected InputAttributesSelector inputSelector;
-	
+
 	protected InstanceInformation instanceInformation;
 
 	protected Random randomGenerator;
-	
-    protected boolean [] attributesMask; //TODO: JD Use sparse representation?
-    protected double attributesPercentage;
+
+	protected boolean[] attributesMask; // TODO: JD Use sparse representation?
+	protected double attributesPercentage;
 
 	protected InstanceTransformer instanceTransformer;
-	
+
 	protected InstancesHeader instanceHeader;
 
-	double [] meritPerInput; //for feature
+	double[] meritPerInput; // for feature
 
-	// Maintain statistics for input and output attributes for standard deviation computation?
+	// Maintain statistics for input and output attributes for standard deviation
+	// computation?
 
-	public LearningLiteral(){
+	public LearningLiteral() {
 	}
 
-	public LearningLiteral(int [] outputsToLearn){
+	public LearningLiteral(int[] outputsToLearn) {
 		this();
-		this.outputsToLearn=outputsToLearn.clone();
+		this.outputsToLearn = outputsToLearn.clone();
 	}
 
 	abstract public void trainOnInstance(Instance instance);
 
 	public Prediction getPredictionForInstance(Instance instance) {
-		Prediction prediction=null;
-		if (learner!=null){ 
-			Instance transfInstance=this.instanceTransformer.sourceInstanceToTarget(instance);
-			Prediction targetPrediction=learner.getPredictionForInstance(transfInstance);
-			prediction=this.instanceTransformer.targetPredictionToSource(targetPrediction);
+		Prediction prediction = null;
+		if (learner != null) {
+			Instance transfInstance = this.instanceTransformer.sourceInstanceToTarget(instance);
+			Prediction targetPrediction = learner.getPredictionForInstance(transfInstance);
+			prediction = this.instanceTransformer.targetPredictionToSource(targetPrediction);
 		}
 		return prediction;
 	}
 
-
 	public abstract boolean tryToExpand(double splitConfidence, double tieThresholdOption);
 
 	public boolean updateAndCheckChange(Instance instance) {
-		boolean hasChanged=false;
-		if (hasStarted){
-			if (changeDetectors==null){
-				changeDetectors=new ChangeDetector[outputsToLearn.length]; 
-				for (int i=0; i<outputsToLearn.length; i++){
-					changeDetectors[i]=changeDetector.copy();
+		boolean hasChanged = false;
+		if (hasStarted) {
+			if (changeDetectors == null) {
+				changeDetectors = new ChangeDetector[outputsToLearn.length];
+				for (int i = 0; i < outputsToLearn.length; i++) {
+					changeDetectors[i] = changeDetector.copy();
 				}
 			}
-			Prediction prediction=getPredictionForInstance(instance);
-			double []normalizedErrors=getNormalizedErrors(prediction, instance);
-			for (int i=0; i<outputsToLearn.length;i++){
+			Prediction prediction = getPredictionForInstance(instance);
+			double[] normalizedErrors = getNormalizedErrors(prediction, instance);
+			for (int i = 0; i < outputsToLearn.length; i++) {
 				changeDetectors[i].input(normalizedErrors[i]);
-				if(changeDetectors[i].getChange()){
-					hasChanged=true;
+				if (changeDetectors[i].getChange()) {
+					hasChanged = true;
 					break;
 				}
 			}
@@ -135,18 +133,15 @@ public boolean updateAndCheckChange(Instance instance) {
 		return hasChanged;
 	}
 
-
-	protected abstract double[] getNormalizedErrors(Prediction prediction,
-			Instance inst);
+	protected abstract double[] getNormalizedErrors(Prediction prediction, Instance inst);
 
 	public boolean updateAndCheckAnomalyDetection(Instance instance) {
-		if(hasStarted)
+		if (hasStarted)
 			return anomalyDetector.updateAndCheckAnomalyDetection(instance);
 		else
 			return false;
 	}
 
-
 	public double getWeightSeenSinceExpansion() {
 		return weightSeen;
 	}
@@ -172,108 +167,102 @@ public LearningLiteral getOtherBranchLearningLiteral() {
 	}
 
 	public double[] getErrors() {
-		double [] errors=null;
-		if(errorMeasurer!=null)
-			errors=errorMeasurer.getCurrentErrors();
+		double[] errors = null;
+		if (errorMeasurer != null)
+			errors = errorMeasurer.getCurrentErrors();
 		return errors;
 	}
 
 	public void setSplitCriterion(MultiLabelSplitCriterion splitCriterion) {
-		this.splitCriterion=splitCriterion;
+		this.splitCriterion = splitCriterion;
 
 	}
 
 	public void setChangeDetector(ChangeDetector changeDetector) {
-		this.changeDetectors=null;
-		this.changeDetector=changeDetector; //copy()?
+		this.changeDetectors = null;
+		this.changeDetector = changeDetector; // copy()?
 
 	}
 
 	public void setAnomalyDetector(AnomalyDetector anomalyDetector) {
-		this.anomalyDetector=anomalyDetector; //copy()?
+		this.anomalyDetector = anomalyDetector; // copy()?
 
 	}
 
 	public void setNumericObserverOption(NumericStatisticsObserver numericStatisticsObserver) {
-		if(this.attributeObservers!=null){
+		if (this.attributeObservers != null) {
 			for (AttributeStatisticsObserver obs : this.attributeObservers)
-				if( obs instanceof NumericStatisticsObserver)
-					obs=null;
+				if (obs instanceof NumericStatisticsObserver)
+					obs = null;
 		}
-		this.numericStatisticsObserver=numericStatisticsObserver;
+		this.numericStatisticsObserver = numericStatisticsObserver;
 	}
 
 	public void setLearner(InstanceLearner learner) {
-		this.learner=learner;
+		this.learner = learner;
 	}
 
 	public void setErrorMeasurer(MultiLabelErrorMeasurer errorMeasurer) {
-		this.errorMeasurer=errorMeasurer;
+		this.errorMeasurer = errorMeasurer;
 
 	}
 
-	public 	AttributeExpansionSuggestion getBestSuggestion(){
+	public AttributeExpansionSuggestion getBestSuggestion() {
 		return bestSuggestion;
 	}
 
-	public static double computeHoeffdingBound(double range, double confidence,
-			double n) {
-		return Math.sqrt(((range * range) * Math.log(1.0 / confidence))
-				/ (2.0 * n));
+	public static double computeHoeffdingBound(double range, double confidence, double n) {
+		return Math.sqrt(((range * range) * Math.log(1.0 / confidence)) / (2.0 * n));
 	}
 
-	public void setOutputAttributesSelector(
-			OutputAttributesSelector outputSelector) {
-		this.outputSelector=outputSelector;
-		
+	public void setOutputAttributesSelector(OutputAttributesSelector outputSelector) {
+		this.outputSelector = outputSelector;
+
 	}
 
 	public void setNominalObserverOption(NominalStatisticsObserver nominalStatisticsObserver) {
-		this.nominalStatisticsObserver=nominalStatisticsObserver;
+		this.nominalStatisticsObserver = nominalStatisticsObserver;
 	}
-	
-
-	
 
 	public void setRandomGenerator(Random random) {
-		this.randomGenerator=random;
-		
+		this.randomGenerator = random;
+
 	}
 
 	public void setAttributesPercentage(double attributesPercentage) {
-		this.attributesPercentage=attributesPercentage;
+		this.attributesPercentage = attributesPercentage;
 	}
-	
+
 	protected int initializeAttibutesMask(Instance inst) {
-		int numInputAttributes=inst.numInputAttributes();
-		int numAttributesSelected=(int)Math.round(numInputAttributes*attributesPercentage/100);
-		
-		attributesMask=new boolean[numInputAttributes]; 
-		ArrayList<Integer> indices = new ArrayList<Integer>(numInputAttributes);
-		for(int i=0; i<numInputAttributes; i++)
-				indices.add(i);
-		if(numInputAttributes!=numAttributesSelected)
-		Collections.shuffle(indices, this.randomGenerator);
-		
-		for (int i=0; i<numAttributesSelected;++i)
-			attributesMask[indices.get(i)]=true;
-		
+		int numInputAttributes = inst.numInputAttributes();
+		int numAttributesSelected = (int) Math.round(numInputAttributes * attributesPercentage / 100);
+
+		attributesMask = new boolean[numInputAttributes];
+		ArrayList<Integer> indices = new ArrayList<>(numInputAttributes);
+		for (int i = 0; i < numInputAttributes; i++)
+			indices.add(i);
+		if (numInputAttributes != numAttributesSelected)
+			Collections.shuffle(indices, this.randomGenerator);
+
+		for (int i = 0; i < numAttributesSelected; ++i)
+			attributesMask[indices.get(i)] = true;
+
 		return numAttributesSelected;
 	}
-	
+
 	public void setInputAttributesSelector(InputAttributesSelector inputSelector) {
-		this.inputSelector=inputSelector;
+		this.inputSelector = inputSelector;
 	}
-	
+
 	abstract public String getStaticOutput(InstancesHeader instanceInformation);
-	
+
 	public int[] getInputsToLearn() {
 		return this.inputsToLearn;
 	}
 
 	public void setInstanceTransformer(InstanceTransformer instanceTransformer) {
-		this.instanceTransformer=instanceTransformer;
-		
+		this.instanceTransformer = instanceTransformer;
+
 	}
 
 	public LearningLiteral getOtherOutputsLearningLiteral() {
@@ -281,15 +270,15 @@ public LearningLiteral getOtherOutputsLearningLiteral() {
 	}
 
 	public void setInstanceInformation(InstanceInformation instanceInformation) {
-		this.instanceInformation=instanceInformation;
+		this.instanceInformation = instanceInformation;
 	}
 
-	public double [] getMeritInputAttributes(){
+	public double[] getMeritInputAttributes() {
 		return meritPerInput;
 	}
 
 	public boolean[] getAttributeMask() {
 		return attributesMask;
 	}
-	//	abstract public void resetLearning();
+	// abstract public void resetLearning();
 }
diff --git a/moa/src/main/java/moa/learners/predictors/core/LearningLiteralClassification.java b/moa/src/main/java/moa/learners/predictors/core/LearningLiteralClassification.java
new file mode 100644
index 000000000..2cf2e09d0
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/LearningLiteralClassification.java
@@ -0,0 +1,381 @@
+/*
+ *    LearningLiteralClassification.java
+ *    Copyright (C) 2017 University of Porto, Portugal
+ *    @author R. Sousa, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.predictors.core;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.ObjectRepository;
+import moa.learners.predictors.MultiLabelClassifier;
+import moa.learners.predictors.core.attributeclassobservers.AttributeStatisticsObserver;
+import moa.learners.predictors.core.attributeclassobservers.NominalStatisticsObserver;
+import moa.learners.predictors.core.attributeclassobservers.NumericStatisticsObserver;
+import moa.learners.predictors.core.functions.AMRulesFunction;
+import moa.learners.predictors.core.instancetransformers.InstanceOutputAttributesSelector;
+import moa.learners.predictors.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.learners.predictors.rules.core.AttributeExpansionSuggestion;
+import moa.learners.predictors.rules.core.NumericRulePredicate;
+import moa.learners.predictors.rules.core.Utils;
+import moa.tasks.TaskMonitor;
+
+/**
+ * This class contains the functions for learning the literals for Multi-label
+ * classification (in same way as Multi-Target regression). used by multi-label
+ * AMRules.
+ * 
+ * @author RSousa * @version $Revision: 1 $
+ */
+
+public class LearningLiteralClassification extends LearningLiteral {
+
+	/**
+	 *
+	 */
+	private static final long serialVersionUID = 1L;
+
+	double[] EntropyShift; // for proper computation of entropy
+
+	public LearningLiteralClassification() {
+		super();
+	}
+
+	public LearningLiteralClassification(int[] outputsToLearn) {
+		super(outputsToLearn);
+	}
+
+	@Override
+	protected double[] getNormalizedErrors(Prediction prediction, Instance instance) {
+		double[] errors = new double[outputsToLearn.length];
+
+		for (int i = 0; i < outputsToLearn.length; i++) {
+			double predY = normalizeOutputValue(i, prediction.getVote(outputsToLearn[i], 0));
+			double trueY = normalizeOutputValue(i, instance.valueOutputAttribute(outputsToLearn[i]));
+			errors[i] = Math.abs(predY - trueY);
+		}
+		return errors;
+	}
+
+	private double normalizeOutputValue(int outputToLearnIndex, double value) {
+		double meanY = this.literalStatistics[outputToLearnIndex].getValue(1)
+				/ this.literalStatistics[outputToLearnIndex].getValue(0);
+		double sdY = Utils.computeSD(this.literalStatistics[outputToLearnIndex].getValue(2),
+				this.literalStatistics[outputToLearnIndex].getValue(1),
+				this.literalStatistics[outputToLearnIndex].getValue(0));
+		double normalizedY = 0.0;
+		if (sdY > 0.0000001) {
+			normalizedY = (value - meanY) / (sdY);
+		}
+		return normalizedY;
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+
+	}
+
+	@Override
+	public boolean tryToExpand(double splitConfidence, double tieThreshold) {
+
+		boolean shouldSplit = false;
+
+		// find the best split per attribute and rank the results
+		AttributeExpansionSuggestion[] bestSplitSuggestions = this.getBestSplitSuggestions(splitCriterion);
+
+		double sumMerit = 0;
+		meritPerInput = new double[attributesMask.length];
+		for (int i = 0; i < bestSplitSuggestions.length; i++) {
+			double merit = bestSplitSuggestions[i].getMerit();
+			if (merit > 0) {
+				meritPerInput[bestSplitSuggestions[i].predicate.getAttributeIndex()] = merit;
+				sumMerit += merit;
+			}
+		}
+
+		// if merit==0 it means the split have not enough examples in the smallest
+		// branch
+		if (sumMerit == 0)
+			meritPerInput = null; // this indicates that no merit should be considered (e.g. for feature ranking)
+
+		Arrays.sort(bestSplitSuggestions);
+
+		// disable attributes that are not relevant
+		int[] oldInputs = inputsToLearn.clone();
+		inputsToLearn = inputSelector.getNextInputIndices(bestSplitSuggestions); //
+		Arrays.sort(this.inputsToLearn);
+		for (int i = 0; i < oldInputs.length; i++) {
+			if (attributesMask[oldInputs[i]]) {
+				if (Arrays.binarySearch(inputsToLearn, oldInputs[i]) < 0) {
+					this.attributeObservers.set(oldInputs[i], null);
+				}
+			}
+		}
+
+		// If only one split was returned, use it
+		if (bestSplitSuggestions.length < 2) {
+			// shouldSplit = ((bestSplitSuggestions.length > 0) &&
+			// (bestSplitSuggestions[0].merit > 0));
+			bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+			shouldSplit = true;
+		} // Otherwise, consider which of the splits proposed may be worth trying
+		else {
+			double hoeffdingBound = computeHoeffdingBound(splitCriterion.getRangeOfMerit(this.literalStatistics),
+					splitConfidence, weightSeen);
+			// debug("Hoeffding bound " + hoeffdingBound, 4);
+			// Determine the top two ranked splitting suggestions
+			bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+			AttributeExpansionSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
+			if ((((bestSuggestion.merit - secondBestSuggestion.merit)) > hoeffdingBound)
+					|| (hoeffdingBound < tieThreshold)) {
+				// if ((((secondBestSuggestion.merit/bestSuggestion.merit) + hoeffdingBound) <
+				// 1) || (hoeffdingBound < tieThreshold)) {
+				// debug("Expanded ", 5);
+				shouldSplit = true;
+				// System.out.println(bestSuggestion.merit);
+			}
+		}
+
+		if (shouldSplit) {
+
+			// check which branch is better and update bestSuggestion (in amrules the splits
+			// are binary )
+			DoubleVector[][] resultingStatistics = bestSuggestion.getResultingNodeStatistics();
+
+			// if not or higher is better, change predicate (negate condition)
+			double[] branchMerits = splitCriterion.getBranchesSplitMerits(resultingStatistics);
+			DoubleVector[] newLiteralStatistics;
+			if (branchMerits[1] > branchMerits[0]) {
+				bestSuggestion.getPredicate().negateCondition();
+				newLiteralStatistics = getBranchStatistics(resultingStatistics, 1);
+			} else {
+				newLiteralStatistics = getBranchStatistics(resultingStatistics, 0);
+			}
+
+			int[] newOutputs = outputSelector.getNextOutputIndices(newLiteralStatistics, literalStatistics,
+					outputsToLearn);
+			Arrays.sort(newOutputs); // Must be ordered for latter correspondence algorithm to work
+
+			// set other branch (only used if default rule expands)
+			otherBranchLearningLiteral = new LearningLiteralClassification();
+			otherBranchLearningLiteral.instanceHeader = instanceHeader;
+			otherBranchLearningLiteral.learner = (MultiLabelClassifier) learner.copy();
+			otherBranchLearningLiteral.instanceTransformer = this.instanceTransformer;
+
+			// keep a rule learning to the complement set of newOutputs
+
+			// Set expanding branch
+			// if is AMRulesFunction and the number of output attributes changes, start
+			// learning a new predictor
+			// should we do the same for input attributes (attributesMask)?. It would have
+			// impact in RandomAMRules
+			if (learner instanceof AMRulesFunction) { // Reset learning
+				if (newOutputs.length != outputsToLearn.length) {
+					// other outputs
+					int[] otherOutputs = Utils.complementSet(outputsToLearn, newOutputs);
+					int[] indices;
+					if (otherOutputs.length > 0) {
+						otherOutputsLearningLiteral = new LearningLiteralClassification(otherOutputs);
+						MultiLabelClassifier otherOutputsLearner = (MultiLabelClassifier) learner.copy();
+						indices = Utils.getIndexCorrespondence(outputsToLearn, otherOutputs);
+						((AMRulesFunction) otherOutputsLearner).selectOutputsToLearn(indices);
+						((AMRulesFunction) otherOutputsLearner).resetWithMemory();
+						otherOutputsLearningLiteral.learner = otherOutputsLearner;
+						otherOutputsLearningLiteral.instanceHeader = instanceHeader;
+						otherOutputsLearningLiteral.instanceTransformer = new InstanceOutputAttributesSelector(
+								instanceHeader, otherOutputs);
+					}
+					// expanded
+					indices = Utils.getIndexCorrespondence(outputsToLearn, newOutputs);
+					((AMRulesFunction) learner).selectOutputsToLearn(indices);
+				}
+
+				((AMRulesFunction) learner).resetWithMemory();
+			}
+			// just reset learning
+			else {
+				// other outputs //TODO JD: Test for general learner (other than AMRules
+				// functions
+				if (newOutputs.length != outputsToLearn.length) {
+					int[] otherOutputs = Utils.complementSet(outputsToLearn, newOutputs);
+					if (otherOutputs.length > 0) {
+						otherOutputsLearningLiteral = new LearningLiteralClassification();
+						MultiLabelClassifier otherOutputsLearner = (MultiLabelClassifier) learner.copy();
+						otherOutputsLearner.resetLearning();
+						otherOutputsLearningLiteral.learner = otherOutputsLearner;
+						otherOutputsLearningLiteral.instanceHeader = instanceHeader;
+						otherOutputsLearningLiteral.instanceTransformer = new InstanceOutputAttributesSelector(
+								instanceHeader, otherOutputs);
+					}
+				}
+				// expanded
+				learner.resetLearning();
+			}
+			expandedLearningLiteral = new LearningLiteralClassification(newOutputs);
+			expandedLearningLiteral.learner = (MultiLabelClassifier) this.learner.copy();
+			expandedLearningLiteral.instanceHeader = instanceHeader;
+			expandedLearningLiteral.instanceTransformer = new InstanceOutputAttributesSelector(instanceHeader,
+					newOutputs);
+
+		}
+
+		return shouldSplit;
+	}
+
+	private DoubleVector[] getBranchStatistics(DoubleVector[][] resultingStatistics, int indexBranch) {
+		DoubleVector[] selBranchStats = new DoubleVector[resultingStatistics.length];
+		for (int i = 0; i < resultingStatistics.length; i++)
+			selBranchStats[i] = resultingStatistics[i][indexBranch];
+		return selBranchStats;
+	}
+
+	private AttributeExpansionSuggestion[] getBestSplitSuggestions(MultiLabelSplitCriterion criterion) {
+
+		List<AttributeExpansionSuggestion> bestSuggestions = new LinkedList<>();
+		for (int i = 0; i < this.inputsToLearn.length; i++) {
+			if (attributesMask[inputsToLearn[i]]) { // Should always be true (check trainOnInstance(). Remove?
+				AttributeStatisticsObserver obs = this.attributeObservers.get(inputsToLearn[i]);
+				if (obs != null) {
+					AttributeExpansionSuggestion bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion,
+							literalStatistics, inputsToLearn[i]);
+
+					if (bestSuggestion == null) {
+						// ALL attributes must have a best suggestion. Adding dummy suggestion with
+						// minimal merit.
+						bestSuggestion = new AttributeExpansionSuggestion(
+								new NumericRulePredicate(inputsToLearn[i], 0, true), null, -Double.MAX_VALUE);
+					}
+					bestSuggestions.add(bestSuggestion);
+				}
+			}
+		}
+		return bestSuggestions.toArray(new AttributeExpansionSuggestion[bestSuggestions.size()]);
+	}
+
+	@Override
+	public void trainOnInstance(Instance instance) {
+		int numInputs = 0;
+		if (attributesMask == null)
+			numInputs = initializeAttibutesMask(instance);
+
+		// learn for all output attributes if not specified at construction time
+		int numOutputs = instance.numOutputAttributes();
+
+		if (!hasStarted) {
+			if (this.learner.isRandomizable())
+				this.learner.setRandomSeed(this.randomGenerator.nextInt());
+			if (outputsToLearn == null) {
+				outputsToLearn = new int[numOutputs];
+				for (int i = 0; i < numOutputs; i++) {
+					outputsToLearn[i] = i;
+				}
+			}
+			if (inputsToLearn == null) {
+				inputsToLearn = new int[numInputs];
+				int ct = 0;
+				for (int i = 0; i < instance.numInputAttributes(); i++) {// TODO JD: check with mask?
+					if (attributesMask[i]) {
+						inputsToLearn[ct] = i;
+						ct++;
+					}
+				}
+			}
+
+			literalStatistics = new DoubleVector[outputsToLearn.length];
+			EntropyShift = new double[outputsToLearn.length];
+			for (int i = 0; i < outputsToLearn.length; i++) {
+				literalStatistics[i] = new DoubleVector(new double[5]);
+				EntropyShift[i] = instance.valueOutputAttribute(outputsToLearn[i]);
+			}
+			instanceHeader = instance.dataset();
+			hasStarted = true;
+		}
+		double weight = instance.weight();
+		DoubleVector[] exampleStatistics = new DoubleVector[outputsToLearn.length];
+		for (int i = 0; i < outputsToLearn.length; i++) {
+			double target = instance.valueOutputAttribute(outputsToLearn[i]);
+
+			double sum = weight * target; // Needed for expansion
+			double squaredSum = weight * target * target; // Not needed for now
+			double sumShifted = weight * target - EntropyShift[i]; // Needed for Output Selector
+			double squaredSumShifted = weight * (target - EntropyShift[i]) * (target - EntropyShift[i]);// Not needed
+																										// for now
+			exampleStatistics[i] = new DoubleVector(
+					new double[] { weight, sum, squaredSum, sumShifted, squaredSumShifted });
+			literalStatistics[i].addValues(exampleStatistics[i].getArrayRef());
+
+		}
+
+		if (this.attributeObservers == null)
+			this.attributeObservers = new AutoExpandVector<>();
+		for (int i = 0; i < inputsToLearn.length; i++) {
+			if (attributesMask[inputsToLearn[i]]) { // this is checked above. Remove?
+				AttributeStatisticsObserver obs = this.attributeObservers.get(inputsToLearn[i]);
+				if (obs == null) {
+					if (instance.attribute(inputsToLearn[i]).isNumeric()) {
+						obs = ((NumericStatisticsObserver) numericStatisticsObserver.copy());
+					} else if (instance.attribute(inputsToLearn[i]).isNominal()) { // just to make sure its nominal (in
+																					// the future there may be ordinal?
+						obs = ((NominalStatisticsObserver) nominalStatisticsObserver.copy());
+					}
+					this.attributeObservers.set(inputsToLearn[i], obs);
+				}
+				obs.observeAttribute(instance.valueInputAttribute(inputsToLearn[i]), exampleStatistics);
+			}
+		}
+
+		// Transform instance for learning
+		Instance transformedInstance = instanceTransformer.sourceInstanceToTarget(instance);
+		Prediction prediction = null;
+		Prediction targetPrediction = learner.getPredictionForInstance(transformedInstance);
+		if (targetPrediction != null)
+			prediction = instanceTransformer.targetPredictionToSource(targetPrediction);
+
+		if (prediction != null)
+			errorMeasurer.addPrediction(prediction, instance);
+
+		learner.trainOnInstance(transformedInstance);
+
+		weightSeen += instance.weight();
+	}
+
+	@Override
+	public String getStaticOutput(InstancesHeader instanceInformation) {
+		StringBuffer sb = new StringBuffer();
+		if (this.literalStatistics != null) {
+			for (int i = 0; i < this.literalStatistics.length; i++) {
+				sb.append(instanceInformation.outputAttribute(outputsToLearn[i]).name() + ": "
+						+ literalStatistics[i].getValue(1) / literalStatistics[i].getValue(0) + " "); //
+			}
+		}
+
+		return sb.toString();
+	}
+
+	/*
+	 * @Override public void resetLearning() { weightSeen=0; //hasStarted=false; }
+	 */
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/LearningLiteralRegression.java b/moa/src/main/java/moa/learners/predictors/core/LearningLiteralRegression.java
new file mode 100644
index 000000000..639b57cc4
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/LearningLiteralRegression.java
@@ -0,0 +1,341 @@
+package moa.learners.predictors.core;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.ObjectRepository;
+import moa.learners.predictors.MultiLabelClassifier;
+import moa.learners.predictors.core.attributeclassobservers.AttributeStatisticsObserver;
+import moa.learners.predictors.core.attributeclassobservers.NominalStatisticsObserver;
+import moa.learners.predictors.core.attributeclassobservers.NumericStatisticsObserver;
+import moa.learners.predictors.core.functions.AMRulesFunction;
+import moa.learners.predictors.core.instancetransformers.InstanceOutputAttributesSelector;
+import moa.learners.predictors.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.learners.predictors.rules.core.AttributeExpansionSuggestion;
+import moa.learners.predictors.rules.core.NumericRulePredicate;
+import moa.learners.predictors.rules.core.Utils;
+import moa.tasks.TaskMonitor;
+
+public class LearningLiteralRegression extends LearningLiteral {
+
+	/**
+	 *
+	 */
+	private static final long serialVersionUID = 1L;
+
+	double[] varianceShift; // for proper computation of variance
+
+	public LearningLiteralRegression() {
+		super();
+	}
+
+	public LearningLiteralRegression(int[] outputsToLearn) {
+		super(outputsToLearn);
+	}
+
+	@Override
+	protected double[] getNormalizedErrors(Prediction prediction, Instance instance) {
+		double[] errors = new double[outputsToLearn.length];
+
+		for (int i = 0; i < outputsToLearn.length; i++) {
+			double predY = normalizeOutputValue(i, prediction.getVote(outputsToLearn[i], 0));
+			double trueY = normalizeOutputValue(i, instance.valueOutputAttribute(outputsToLearn[i]));
+			errors[i] = Math.abs(predY - trueY);
+		}
+		return errors;
+	}
+
+	private double normalizeOutputValue(int outputToLearnIndex, double value) {
+		double meanY = this.literalStatistics[outputToLearnIndex].getValue(1)
+				/ this.literalStatistics[outputToLearnIndex].getValue(0);
+		double sdY = Utils.computeSD(this.literalStatistics[outputToLearnIndex].getValue(2),
+				this.literalStatistics[outputToLearnIndex].getValue(1),
+				this.literalStatistics[outputToLearnIndex].getValue(0));
+		double normalizedY = 0.0;
+		if (sdY > 0.0000001) {
+			normalizedY = (value - meanY) / (sdY);
+		}
+		return normalizedY;
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+
+	}
+
+	@Override
+	public boolean tryToExpand(double splitConfidence, double tieThreshold) {
+		boolean shouldSplit = false;
+		// find the best split per attribute and rank the results
+		AttributeExpansionSuggestion[] bestSplitSuggestions = this.getBestSplitSuggestions(splitCriterion);
+
+		double sumMerit = 0;
+		meritPerInput = new double[attributesMask.length];
+		for (int i = 0; i < bestSplitSuggestions.length; i++) {
+			double merit = bestSplitSuggestions[i].getMerit();
+			if (merit > 0) {
+				meritPerInput[bestSplitSuggestions[i].predicate.getAttributeIndex()] = merit;
+				sumMerit += merit;
+			}
+		}
+
+		// if merit==0 it means the split have not enough examples in the smallest
+		// branch
+		if (sumMerit == 0)
+			meritPerInput = null; // this indicates that no merit should be considered (e.g. for feature ranking)
+
+		Arrays.sort(bestSplitSuggestions);
+
+		// disable attributes that are not relevant
+		int[] oldInputs = inputsToLearn.clone();
+		inputsToLearn = inputSelector.getNextInputIndices(bestSplitSuggestions); //
+		Arrays.sort(this.inputsToLearn);
+		for (int i = 0; i < oldInputs.length; i++) {
+			if (attributesMask[oldInputs[i]]) {
+				if (Arrays.binarySearch(inputsToLearn, oldInputs[i]) < 0) {
+					this.attributeObservers.set(oldInputs[i], null);
+				}
+			}
+		}
+
+		// If only one split was returned, use it
+		if (bestSplitSuggestions.length < 2) {
+			// shouldSplit = ((bestSplitSuggestions.length > 0) &&
+			// (bestSplitSuggestions[0].merit > 0));
+			bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+			shouldSplit = true;
+		} // Otherwise, consider which of the splits proposed may be worth trying
+		else {
+			double hoeffdingBound = computeHoeffdingBound(splitCriterion.getRangeOfMerit(this.literalStatistics),
+					splitConfidence, weightSeen);
+			// debug("Hoeffding bound " + hoeffdingBound, 4);
+			// Determine the top two ranked splitting suggestions
+			bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+			AttributeExpansionSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
+			if ((((bestSuggestion.merit - secondBestSuggestion.merit)) > hoeffdingBound)
+					|| (hoeffdingBound < tieThreshold)) {
+				// if ((((secondBestSuggestion.merit/bestSuggestion.merit) + hoeffdingBound) <
+				// 1) || (hoeffdingBound < tieThreshold)) {
+				// debug("Expanded ", 5);
+				shouldSplit = true;
+				// System.out.println(bestSuggestion.merit);
+			}
+		}
+		if (shouldSplit) {
+			// check which branch is better and update bestSuggestion (in amrules the splits
+			// are binary )
+			DoubleVector[][] resultingStatistics = bestSuggestion.getResultingNodeStatistics();
+			// if not or higher is better, change predicate (negate condition)
+			double[] branchMerits = splitCriterion.getBranchesSplitMerits(resultingStatistics);
+			DoubleVector[] newLiteralStatistics;
+			if (branchMerits[1] > branchMerits[0]) {
+				bestSuggestion.getPredicate().negateCondition();
+				newLiteralStatistics = getBranchStatistics(resultingStatistics, 1);
+			} else {
+				newLiteralStatistics = getBranchStatistics(resultingStatistics, 0);
+			}
+			//
+			int[] newOutputs = outputSelector.getNextOutputIndices(newLiteralStatistics, literalStatistics,
+					outputsToLearn);
+			Arrays.sort(newOutputs); // Must be ordered for latter correspondence algorithm to work
+
+			// set other branch (only used if default rule expands)
+			otherBranchLearningLiteral = new LearningLiteralRegression();
+			otherBranchLearningLiteral.instanceHeader = instanceHeader;
+			otherBranchLearningLiteral.learner = (MultiLabelClassifier) learner.copy();
+			otherBranchLearningLiteral.instanceTransformer = this.instanceTransformer;
+
+			// keep a rule learning to the complement set of newOutputs
+
+			// Set expanding branch
+			// if is AMRulesFunction and the number of output attributes changes, start
+			// learning a new predictor
+			// should we do the same for input attributes (attributesMask)?. It would have
+			// impact in RandomAMRules
+			if (learner instanceof AMRulesFunction) { // Reset learning
+				if (newOutputs.length != outputsToLearn.length) {
+					// other outputs
+					int[] otherOutputs = Utils.complementSet(outputsToLearn, newOutputs);
+					int[] indices;
+					if (otherOutputs.length > 0) {
+						otherOutputsLearningLiteral = new LearningLiteralRegression(otherOutputs);
+						MultiLabelClassifier otherOutputsLearner = (MultiLabelClassifier) learner.copy();
+						indices = Utils.getIndexCorrespondence(outputsToLearn, otherOutputs);
+						((AMRulesFunction) otherOutputsLearner).selectOutputsToLearn(indices);
+						((AMRulesFunction) otherOutputsLearner).resetWithMemory();
+						otherOutputsLearningLiteral.learner = otherOutputsLearner;
+						otherOutputsLearningLiteral.instanceHeader = instanceHeader;
+						otherOutputsLearningLiteral.instanceTransformer = new InstanceOutputAttributesSelector(
+								instanceHeader, otherOutputs);
+					}
+					// expanded
+					indices = Utils.getIndexCorrespondence(outputsToLearn, newOutputs);
+					((AMRulesFunction) learner).selectOutputsToLearn(indices);
+				}
+
+				((AMRulesFunction) learner).resetWithMemory();
+			}
+			// just reset learning
+			else {
+				// other outputs //TODO JD: Test for general learner (other than AMRules
+				// functions
+				if (newOutputs.length != outputsToLearn.length) {
+					int[] otherOutputs = Utils.complementSet(outputsToLearn, newOutputs);
+					if (otherOutputs.length > 0) {
+						otherOutputsLearningLiteral = new LearningLiteralRegression();
+						MultiLabelClassifier otherOutputsLearner = (MultiLabelClassifier) learner.copy();
+						otherOutputsLearner.resetLearning();
+						otherOutputsLearningLiteral.learner = otherOutputsLearner;
+						otherOutputsLearningLiteral.instanceHeader = instanceHeader;
+						otherOutputsLearningLiteral.instanceTransformer = new InstanceOutputAttributesSelector(
+								instanceHeader, otherOutputs);
+					}
+				}
+				// expanded
+				learner.resetLearning();
+			}
+			expandedLearningLiteral = new LearningLiteralRegression(newOutputs);
+			expandedLearningLiteral.learner = (MultiLabelClassifier) this.learner.copy();
+			expandedLearningLiteral.instanceHeader = instanceHeader;
+			expandedLearningLiteral.instanceTransformer = new InstanceOutputAttributesSelector(instanceHeader,
+					newOutputs);
+		}
+		return shouldSplit;
+	}
+
+	private DoubleVector[] getBranchStatistics(DoubleVector[][] resultingStatistics, int indexBranch) {
+		DoubleVector[] selBranchStats = new DoubleVector[resultingStatistics.length];
+		for (int i = 0; i < resultingStatistics.length; i++)
+			selBranchStats[i] = resultingStatistics[i][indexBranch];
+		return selBranchStats;
+	}
+
+	private AttributeExpansionSuggestion[] getBestSplitSuggestions(MultiLabelSplitCriterion criterion) {
+		List<AttributeExpansionSuggestion> bestSuggestions = new LinkedList<>();
+		for (int i = 0; i < this.inputsToLearn.length; i++) {
+			if (attributesMask[inputsToLearn[i]]) { // Should always be true (check trainOnInstance(). Remove?
+				AttributeStatisticsObserver obs = this.attributeObservers.get(inputsToLearn[i]);
+				if (obs != null) {
+					AttributeExpansionSuggestion bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion,
+							literalStatistics, inputsToLearn[i]);
+
+					if (bestSuggestion == null) {
+						// ALL attributes must have a best suggestion. Adding dummy suggestion with
+						// minimal merit.
+						bestSuggestion = new AttributeExpansionSuggestion(
+								new NumericRulePredicate(inputsToLearn[i], 0, true), null, -Double.MAX_VALUE);
+					}
+					bestSuggestions.add(bestSuggestion);
+				}
+			}
+		}
+		return bestSuggestions.toArray(new AttributeExpansionSuggestion[bestSuggestions.size()]);
+	}
+
+	@Override
+	public void trainOnInstance(Instance instance) {
+		int numInputs = 0;
+		if (attributesMask == null)
+			numInputs = initializeAttibutesMask(instance);
+
+		// learn for all output attributes if not specified at construction time
+		int numOutputs = instance.numOutputAttributes();
+
+		if (!hasStarted) {
+			if (this.learner.isRandomizable())
+				this.learner.setRandomSeed(this.randomGenerator.nextInt());
+			if (outputsToLearn == null) {
+				outputsToLearn = new int[numOutputs];
+				for (int i = 0; i < numOutputs; i++) {
+					outputsToLearn[i] = i;
+				}
+			}
+			if (inputsToLearn == null) {
+				inputsToLearn = new int[numInputs];
+				int ct = 0;
+				for (int i = 0; i < instance.numInputAttributes(); i++) {// TODO JD: check with mask?
+					if (attributesMask[i]) {
+						inputsToLearn[ct] = i;
+						ct++;
+					}
+				}
+			}
+
+			literalStatistics = new DoubleVector[outputsToLearn.length];
+			varianceShift = new double[outputsToLearn.length];
+			for (int i = 0; i < outputsToLearn.length; i++) {
+				literalStatistics[i] = new DoubleVector(new double[5]);
+				varianceShift[i] = instance.valueOutputAttribute(outputsToLearn[i]);
+			}
+			instanceHeader = instance.dataset();
+			hasStarted = true;
+		}
+		double weight = instance.weight();
+		DoubleVector[] exampleStatistics = new DoubleVector[outputsToLearn.length];
+		for (int i = 0; i < outputsToLearn.length; i++) {
+			double target = instance.valueOutputAttribute(outputsToLearn[i]);
+			double sum = weight * target;
+			double squaredSum = weight * target * target;
+			double sumShifted = weight * target - varianceShift[i];
+			double squaredSumShifted = weight * (target - varianceShift[i]) * (target - varianceShift[i]);
+			exampleStatistics[i] = new DoubleVector(
+					new double[] { weight, sum, squaredSum, sumShifted, squaredSumShifted });
+			literalStatistics[i].addValues(exampleStatistics[i].getArrayRef());
+		}
+
+		if (this.attributeObservers == null)
+			this.attributeObservers = new AutoExpandVector<>();
+		for (int i = 0; i < inputsToLearn.length; i++) {
+			if (attributesMask[inputsToLearn[i]]) { // this is checked above. Remove?
+				AttributeStatisticsObserver obs = this.attributeObservers.get(inputsToLearn[i]);
+				if (obs == null) {
+					if (instance.attribute(inputsToLearn[i]).isNumeric()) {
+						obs = ((NumericStatisticsObserver) numericStatisticsObserver.copy());
+					} else if (instance.attribute(inputsToLearn[i]).isNominal()) { // just to make sure its nominal (in
+																					// the future there may be ordinal?
+						obs = ((NominalStatisticsObserver) nominalStatisticsObserver.copy());
+					}
+					this.attributeObservers.set(inputsToLearn[i], obs);
+				}
+				obs.observeAttribute(instance.valueInputAttribute(inputsToLearn[i]), exampleStatistics);
+			}
+		}
+
+		// Transform instance for learning
+		Instance transformedInstance = instanceTransformer.sourceInstanceToTarget(instance);
+		Prediction prediction = null;
+		Prediction targetPrediction = learner.getPredictionForInstance(transformedInstance);
+		if (targetPrediction != null)
+			prediction = instanceTransformer.targetPredictionToSource(targetPrediction);
+
+		if (prediction != null)
+			errorMeasurer.addPrediction(prediction, instance);
+
+		learner.trainOnInstance(transformedInstance);
+
+		weightSeen += instance.weight();
+	}
+
+	@Override
+	public String getStaticOutput(InstancesHeader instanceInformation) {
+		StringBuffer sb = new StringBuffer();
+		if (this.literalStatistics != null) {
+			for (int i = 0; i < this.literalStatistics.length; i++) {
+				sb.append(instanceInformation.outputAttribute(outputsToLearn[i]).name() + ": "
+						+ literalStatistics[i].getValue(1) / literalStatistics[i].getValue(0) + " ");
+			}
+		}
+		return sb.toString();
+	}
+
+	/*
+	 * @Override public void resetLearning() { weightSeen=0; //hasStarted=false; }
+	 */
+}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/Literal.java b/moa/src/main/java/moa/learners/predictors/core/Literal.java
similarity index 75%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/core/Literal.java
rename to moa/src/main/java/moa/learners/predictors/core/Literal.java
index 58da9419e..495bc4378 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/Literal.java
+++ b/moa/src/main/java/moa/learners/predictors/core/Literal.java
@@ -1,43 +1,41 @@
-package moa.classifiers.rules.multilabel.core;
+package moa.learners.predictors.core;
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import moa.AbstractMOAObject;
-import moa.classifiers.rules.core.Predicate;
+import moa.learners.predictors.rules.core.Predicate;
 
-public class Literal extends AbstractMOAObject{
+public class Literal extends AbstractMOAObject {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 
 	protected Predicate predicate;
-	
-	public Literal(Predicate predicate){
-		this.predicate=predicate;
+
+	public Literal(Predicate predicate) {
+		this.predicate = predicate;
 	}
-	
-	
-	public int getAttributeIndex(){
+
+	public int getAttributeIndex() {
 		return this.predicate.getAttributeIndex();
 	}
-	
 
 	public boolean evaluate(Instance inst) {
 		return predicate.evaluate(inst);
 	}
-	
+
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
 		predicate.getDescription(sb, indent, null);
 	}
-	
+
 	public void getDescription(StringBuilder sb, int indent, InstancesHeader instanceInformation) {
 		predicate.getDescription(sb, indent, instanceInformation);
 	}
-	
+
 	@Override
 	public String toString() {
 		StringBuilder sb = new StringBuilder();
@@ -45,5 +43,4 @@ public String toString() {
 		return sb.toString();
 	}
 
-
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java b/moa/src/main/java/moa/learners/predictors/core/MultiLabelRule.java
similarity index 51%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java
rename to moa/src/main/java/moa/learners/predictors/core/MultiLabelRule.java
index c05440e7d..998fc779c 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRule.java
+++ b/moa/src/main/java/moa/learners/predictors/core/MultiLabelRule.java
@@ -1,4 +1,4 @@
-package moa.classifiers.rules.multilabel.core;
+package moa.learners.predictors.core;
 
 import java.util.Iterator;
 import java.util.LinkedList;
@@ -9,32 +9,29 @@
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-import moa.classifiers.core.driftdetection.ChangeDetector;
-import moa.classifiers.mlc.core.attributeclassobservers.NominalStatisticsObserver;
-import moa.classifiers.mlc.core.attributeclassobservers.NumericStatisticsObserver;
-import moa.classifiers.mlc.core.splitcriteria.MultiLabelSplitCriterion;
-import moa.classifiers.rules.core.anomalydetection.AnomalyDetector;
-import moa.classifiers.rules.featureranking.messages.MeritCheckMessage;
-import moa.classifiers.rules.featureranking.messages.RuleExpandedMessage;
-import moa.classifiers.rules.multilabel.errormeasurers.MultiLabelErrorMeasurer;
-import moa.classifiers.rules.multilabel.inputselectors.InputAttributesSelector;
-import moa.classifiers.rules.multilabel.instancetransformers.InstanceTransformer;
-import moa.classifiers.rules.multilabel.outputselectors.OutputAttributesSelector;
 import moa.core.DoubleVector;
 import moa.core.StringUtils;
-import moa.learners.InstanceLearner;
-import moa.learners.MultiLabelClassifier;
-
-
+import moa.learners.predictors.InstanceLearner;
+import moa.learners.predictors.core.attributeclassobservers.NominalStatisticsObserver;
+import moa.learners.predictors.core.attributeclassobservers.NumericStatisticsObserver;
+import moa.learners.predictors.core.driftdetection.ChangeDetector;
+import moa.learners.predictors.core.errormeasurers.MultiLabelErrorMeasurer;
+import moa.learners.predictors.core.featureranking.messages.MeritCheckMessage;
+import moa.learners.predictors.core.featureranking.messages.RuleExpandedMessage;
+import moa.learners.predictors.core.inputselectors.InputAttributesSelector;
+import moa.learners.predictors.core.instancetransformers.InstanceTransformer;
+import moa.learners.predictors.core.outputselectors.OutputAttributesSelector;
+import moa.learners.predictors.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.learners.predictors.rules.core.anomalydetection.AnomalyDetector;
 
 public class MultiLabelRule extends ObservableMOAObject {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 
-	protected List<Literal> literalList = new LinkedList<Literal>();
+	protected List<Literal> literalList = new LinkedList<>();
 
 	protected LearningLiteral learningLiteral;
 
@@ -46,10 +43,10 @@ public class MultiLabelRule extends ObservableMOAObject {
 
 	protected InstancesHeader instanceInformation;
 
-	//double [] attributesDemeritAccum; //forWeighted VoteFeatureRanking
+	// double [] attributesDemeritAccum; //forWeighted VoteFeatureRanking
 
 	public MultiLabelRule(LearningLiteral learningLiteral) {
-		this.learningLiteral=learningLiteral; //copy()?
+		this.learningLiteral = learningLiteral; // copy()?
 	}
 
 	public MultiLabelRule() {
@@ -58,7 +55,7 @@ public MultiLabelRule() {
 
 	public MultiLabelRule(int id) {
 		this();
-		ruleNumberID=id;
+		ruleNumberID = id;
 	}
 
 	public int getRuleNumberID() {
@@ -90,12 +87,14 @@ public int[] getInputsCovered() {
 
 	@Override
 	public void getDescription(StringBuilder out, int indent) {
-		StringUtils.appendIndented(out, indent+1, "Rule Nr." + this.ruleNumberID + " Instances seen:" + this.learningLiteral.getWeightSeenSinceExpansion() + "\n"); 
+		StringUtils.appendIndented(out, indent + 1, "Rule Nr." + this.ruleNumberID + " Instances seen:"
+				+ this.learningLiteral.getWeightSeenSinceExpansion() + "\n");
 		for (Literal literal : literalList) {
-			literal.getDescription(out, indent+1, instanceInformation);
-			StringUtils.appendIndented(out, indent+1, " ");
+			literal.getDescription(out, indent + 1, instanceInformation);
+			StringUtils.appendIndented(out, indent + 1, " ");
 		}
-		StringUtils.appendIndented(out, indent+1, " Output: " + this.learningLiteral.getStaticOutput(instanceInformation));
+		StringUtils.appendIndented(out, indent + 1,
+				" Output: " + this.learningLiteral.getStaticOutput(instanceInformation));
 	}
 
 	protected String getStaticOutput() {
@@ -111,8 +110,8 @@ public boolean updateAnomalyDetection(Instance instance) {
 	}
 
 	public void trainOnInstance(Instance instance) {
-		if(this.instanceInformation==null)
-			this.instanceInformation=instance.dataset();
+		if (this.instanceInformation == null)
+			this.instanceInformation = instance.dataset();
 		learningLiteral.trainOnInstance(instance);
 	}
 
@@ -124,79 +123,81 @@ public LearningLiteral getLearningNode() {
 		return learningLiteral;
 	}
 
-	public double [] getCurrentErrors() {
+	public double[] getCurrentErrors() {
 		return learningLiteral.getErrors();
 	}
 
-	public  Prediction getPredictionForInstance(Instance instance) {
+	public Prediction getPredictionForInstance(Instance instance) {
 		return learningLiteral.getPredictionForInstance(instance);
 	}
 
-	public double getAnomalyScore(){
-		//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
-		//System.out.print("MultiLabelRule.getAnomalyScore:AScore=" + this.learningLiteral.anomalyDetector.getAnomalyScore() + "\n");
-		//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 
-		return  this.learningLiteral.anomalyDetector.getAnomalyScore();
+	public double getAnomalyScore() {
+		// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+		// System.out.print("MultiLabelRule.getAnomalyScore:AScore=" +
+		// this.learningLiteral.anomalyDetector.getAnomalyScore() + "\n");
+		// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+		return this.learningLiteral.anomalyDetector.getAnomalyScore();
 	}
+
 	public boolean tryToExpand(double splitConfidence, double tieThresholdOption) {
-		boolean hasExpanded=learningLiteral.tryToExpand(splitConfidence,tieThresholdOption);
-
-		//Merit check event
-		double[] merit=learningLiteral.getMeritInputAttributes();
-		if(merit!=null)
-			this.notifyAll( new MeritCheckMessage(new DoubleVector(merit), this.learningLiteral.getAttributeMask()));
-
-		if(hasExpanded){
-
-			LearningLiteral otherOutputsLiteral=learningLiteral.getOtherOutputsLearningLiteral();
-			//if && this.literalList.size()>0 is removed then consider including this code for default rule also
-			if(otherOutputsLiteral!=null && this.literalList.size()>0){ //only add "other outputs" rule if antecedent is not empty
-				otherOutputsRule=new MultiLabelRule();
-				otherOutputsRule.instanceInformation=instanceInformation; 
-				otherOutputsRule.literalList=new LinkedList<Literal>(this.literalList);
-				otherOutputsRule.learningLiteral=otherOutputsLiteral;
+		boolean hasExpanded = learningLiteral.tryToExpand(splitConfidence, tieThresholdOption);
+
+		// Merit check event
+		double[] merit = learningLiteral.getMeritInputAttributes();
+		if (merit != null)
+			this.notifyAll(new MeritCheckMessage(new DoubleVector(merit), this.learningLiteral.getAttributeMask()));
+
+		if (hasExpanded) {
+
+			LearningLiteral otherOutputsLiteral = learningLiteral.getOtherOutputsLearningLiteral();
+			// if && this.literalList.size()>0 is removed then consider including this code
+			// for default rule also
+			if (otherOutputsLiteral != null && this.literalList.size() > 0) { // only add "other outputs" rule if
+																				// antecedent is not empty
+				otherOutputsRule = new MultiLabelRule();
+				otherOutputsRule.instanceInformation = instanceInformation;
+				otherOutputsRule.literalList = new LinkedList<>(this.literalList);
+				otherOutputsRule.learningLiteral = otherOutputsLiteral;
 			}
 
-			otherBranchRule=new MultiLabelRule((LearningLiteral)learningLiteral.getOtherBranchLearningLiteral());
-			//check for obsolete predicate
-			int attribIndex=learningLiteral.getBestSuggestion().getPredicate().getAttributeIndex();
-			boolean isEqualOrLess=learningLiteral.getBestSuggestion().getPredicate().isEqualOrLess();
-
-			boolean isSpecialization=false;
-			Iterator<Literal> it=literalList.iterator();
-			while(it.hasNext()){
-				Literal l=it.next();
-				if(l.predicate.getAttributeIndex()==attribIndex && l.predicate.isEqualOrLess()==isEqualOrLess)
-				{
+			otherBranchRule = new MultiLabelRule(learningLiteral.getOtherBranchLearningLiteral());
+			// check for obsolete predicate
+			int attribIndex = learningLiteral.getBestSuggestion().getPredicate().getAttributeIndex();
+			boolean isEqualOrLess = learningLiteral.getBestSuggestion().getPredicate().isEqualOrLess();
+
+			boolean isSpecialization = false;
+			Iterator<Literal> it = literalList.iterator();
+			while (it.hasNext()) {
+				Literal l = it.next();
+				if (l.predicate.getAttributeIndex() == attribIndex && l.predicate.isEqualOrLess() == isEqualOrLess) {
 					it.remove();
-					isSpecialization=true;
+					isSpecialization = true;
 					break;
 				}
 			}
 
-			//Rule expansion event
+			// Rule expansion event
 			this.notifyAll(new RuleExpandedMessage(attribIndex, isSpecialization));
 
 			this.literalList.add(new Literal(learningLiteral.getBestSuggestion().getPredicate()));
-			learningLiteral=learningLiteral.getExpandedLearningLiteral();
+			learningLiteral = learningLiteral.getExpandedLearningLiteral();
 		}
 		return hasExpanded;
 	}
 
-	public MultiLabelRule getNewRuleFromOtherBranch(){
-		MultiLabelRule r=otherBranchRule;
-		otherBranchRule=null;
+	public MultiLabelRule getNewRuleFromOtherBranch() {
+		MultiLabelRule r = otherBranchRule;
+		otherBranchRule = null;
 		return r;
 	}
 
-	public MultiLabelRule getNewRuleFromOtherOutputs(){
-		MultiLabelRule r=otherOutputsRule;
+	public MultiLabelRule getNewRuleFromOtherOutputs() {
+		MultiLabelRule r = otherOutputsRule;
 		return r;
 	}
 
 	@Override
-	public String toString()
-	{
+	public String toString() {
 		StringBuilder out = new StringBuilder();
 		getDescription(out, 1);
 		return out.toString();
@@ -217,8 +218,7 @@ public void setAnomalyDetector(AnomalyDetector anomalyDetector) {
 
 	}
 
-	public void setNumericObserverOption(
-			NumericStatisticsObserver numericStatisticsObserver) {
+	public void setNumericObserverOption(NumericStatisticsObserver numericStatisticsObserver) {
 		learningLiteral.setNumericObserverOption(numericStatisticsObserver);
 
 	}
@@ -239,7 +239,7 @@ public void setOutputAttributesSelector(OutputAttributesSelector outputSelector)
 	}
 
 	public void setNominalObserverOption(NominalStatisticsObserver nominalStatisticsObserver) {
-		learningLiteral.setNominalObserverOption(nominalStatisticsObserver);	
+		learningLiteral.setNominalObserverOption(nominalStatisticsObserver);
 	}
 
 	public void setRandomGenerator(Random random) {
@@ -257,7 +257,7 @@ public void setInputAttributesSelector(InputAttributesSelector inputSelector) {
 	}
 
 	public boolean hasNewRuleFromOtherOutputs() {
-		return this.otherOutputsRule!=null;
+		return this.otherOutputsRule != null;
 	}
 
 	public void setInstanceTransformer(InstanceTransformer instanceTransformer) {
@@ -270,13 +270,12 @@ public void addObserver(ObserverMOAObject o) {
 		observers.add(o);
 	}
 
-	public List<Literal> getLiterals(){
+	public List<Literal> getLiterals() {
 		return literalList;
 	}
 
 	public void clearOtherOutputs() {
-		otherOutputsRule=null;
+		otherOutputsRule = null;
 	}
 
-
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRuleClassification.java b/moa/src/main/java/moa/learners/predictors/core/MultiLabelRuleClassification.java
similarity index 73%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRuleClassification.java
rename to moa/src/main/java/moa/learners/predictors/core/MultiLabelRuleClassification.java
index b806c7bfe..ffdbcdc54 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRuleClassification.java
+++ b/moa/src/main/java/moa/learners/predictors/core/MultiLabelRuleClassification.java
@@ -1,27 +1,25 @@
-package moa.classifiers.rules.multilabel.core;
-
+package moa.learners.predictors.core;
 
 public class MultiLabelRuleClassification extends MultiLabelRule {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
-	
+
 	public MultiLabelRuleClassification(LearningLiteralClassification learningLiteral) {
 		super(learningLiteral);
 	}
 
 	public MultiLabelRuleClassification() {
 		super();
-		learningLiteral=new LearningLiteralClassification();
-		
-		
+		learningLiteral = new LearningLiteralClassification();
+
 	}
 
 	public MultiLabelRuleClassification(int id) {
 		this();
-		ruleNumberID=id;
+		ruleNumberID = id;
 	}
 
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRuleRegression.java b/moa/src/main/java/moa/learners/predictors/core/MultiLabelRuleRegression.java
similarity index 72%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRuleRegression.java
rename to moa/src/main/java/moa/learners/predictors/core/MultiLabelRuleRegression.java
index e39348fb2..493b2c0c1 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRuleRegression.java
+++ b/moa/src/main/java/moa/learners/predictors/core/MultiLabelRuleRegression.java
@@ -1,9 +1,9 @@
-package moa.classifiers.rules.multilabel.core;
+package moa.learners.predictors.core;
 
 public class MultiLabelRuleRegression extends MultiLabelRule {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 
@@ -13,14 +13,13 @@ public MultiLabelRuleRegression(LearningLiteralRegression learningLiteral) {
 
 	public MultiLabelRuleRegression() {
 		super();
-		learningLiteral=new LearningLiteralRegression();
-		
-		
+		learningLiteral = new LearningLiteralRegression();
+
 	}
 
 	public MultiLabelRuleRegression(int id) {
 		this();
-		ruleNumberID=id;
+		ruleNumberID = id;
 	}
 
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRuleSet.java b/moa/src/main/java/moa/learners/predictors/core/MultiLabelRuleSet.java
similarity index 90%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRuleSet.java
rename to moa/src/main/java/moa/learners/predictors/core/MultiLabelRuleSet.java
index 61412c91e..5a54b7e09 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/MultiLabelRuleSet.java
+++ b/moa/src/main/java/moa/learners/predictors/core/MultiLabelRuleSet.java
@@ -14,15 +14,15 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
-package moa.classifiers.rules.multilabel.core;
+package moa.learners.predictors.core;
 
 import java.util.LinkedList;
 
 public class MultiLabelRuleSet extends LinkedList<MultiLabelRule> {
 
 	private static final long serialVersionUID = 1L;
-	
+
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/ObservableMOAObject.java b/moa/src/main/java/moa/learners/predictors/core/ObservableMOAObject.java
similarity index 70%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/core/ObservableMOAObject.java
rename to moa/src/main/java/moa/learners/predictors/core/ObservableMOAObject.java
index ccafe08a3..dbb0303d9 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/ObservableMOAObject.java
+++ b/moa/src/main/java/moa/learners/predictors/core/ObservableMOAObject.java
@@ -18,39 +18,38 @@
  *
  */
 
-package moa.classifiers.rules.multilabel.core;
+package moa.learners.predictors.core;
 
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
 
 import moa.AbstractMOAObject;
-import moa.classifiers.rules.featureranking.messages.FeatureRankingMessage;
+import moa.learners.predictors.core.featureranking.messages.FeatureRankingMessage;
 
 //For allowing the implementation of observer pattern for feature ranking in RandomAMRules
 abstract public class ObservableMOAObject extends AbstractMOAObject {
 
 	/**
-	 * 
+	 *
 	 */
-	List<ObserverMOAObject> observers= new LinkedList<ObserverMOAObject>();
+	List<ObserverMOAObject> observers = new LinkedList<>();
 	private static final long serialVersionUID = 1L;
-	
+
 	abstract public void addObserver(ObserverMOAObject o);
-	
-	public void notifyAll(FeatureRankingMessage message){
-		Iterator<ObserverMOAObject> it= observers.iterator();
-		while(it.hasNext()){
+
+	public void notifyAll(FeatureRankingMessage message) {
+		Iterator<ObserverMOAObject> it = observers.iterator();
+		while (it.hasNext()) {
 			it.next().update(this, message);
 		}
- 		
+
 	}
-	
-	public void notify(ObserverMOAObject o,FeatureRankingMessage message){
+
+	public void notify(ObserverMOAObject o, FeatureRankingMessage message) {
 		o.update(this, message);
 	}
-	
-	//abstract public void receiveFeedback(ObserverMOAObject o, Object feedback);
 
-	
+	// abstract public void receiveFeedback(ObserverMOAObject o, Object feedback);
+
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/ObserverMOAObject.java b/moa/src/main/java/moa/learners/predictors/core/ObserverMOAObject.java
similarity index 87%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/core/ObserverMOAObject.java
rename to moa/src/main/java/moa/learners/predictors/core/ObserverMOAObject.java
index 019c064b9..1f50e86fc 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/ObserverMOAObject.java
+++ b/moa/src/main/java/moa/learners/predictors/core/ObserverMOAObject.java
@@ -17,8 +17,8 @@
  *
  *
  */
-package moa.classifiers.rules.multilabel.core;
+package moa.learners.predictors.core;
 
 public interface ObserverMOAObject {
-	public void update(ObservableMOAObject o, Object arg);
+	void update(ObservableMOAObject o, Object arg);
 }
diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/AbstractAttributeClassObserver.java b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/AbstractAttributeClassObserver.java
similarity index 79%
rename from moa/src/main/java/moa/classifiers/core/attributeclassobservers/AbstractAttributeClassObserver.java
rename to moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/AbstractAttributeClassObserver.java
index a790396d5..8f91be056 100644
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/AbstractAttributeClassObserver.java
+++ b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/AbstractAttributeClassObserver.java
@@ -1,4 +1,4 @@
-package moa.classifiers.core.attributeclassobservers;
+package moa.learners.predictors.core.attributeclassobservers;
 
 import moa.options.AbstractOptionHandler;
 
@@ -6,7 +6,7 @@ public abstract class AbstractAttributeClassObserver extends AbstractOptionHandl
 
 	@Override
 	public void observeAttributeValue(double attVal, double value, double weight) {
-		if (this instanceof NumericAttributeClassObserver) 
+		if (this instanceof NumericAttributeClassObserver)
 			this.observeAttributeTarget(attVal, value);
 		else if (this instanceof DiscreteAttributeClassObserver) {
 			this.observeAttributeClass(attVal, (int) value, weight);
diff --git a/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/AttributeClassObserver.java b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/AttributeClassObserver.java
new file mode 100644
index 000000000..0f8ec4ea7
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/AttributeClassObserver.java
@@ -0,0 +1,71 @@
+/*
+ *    AttributeClassObserver.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.core.attributeclassobservers;
+
+import moa.learners.predictors.core.AttributeSplitSuggestion;
+import moa.learners.predictors.core.splitcriteria.SplitCriterion;
+import moa.options.OptionHandler;
+
+/**
+ * Interface for observing the class data distribution for an attribute. This
+ * observer monitors the class distribution of a given attribute. Used in naive
+ * Bayes and decision trees to monitor data statistics on leaves.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public interface AttributeClassObserver extends OptionHandler {
+
+	/**
+	 * Updates statistics of this observer given an attribute value, a class and the
+	 * weight of the instance observed
+	 *
+	 * @param attVal   the value of the attribute
+	 * @param classVal the class
+	 * @param weight   the weight of the instance
+	 */
+	void observeAttributeClass(double attVal, int classVal, double weight);
+
+	/**
+	 * Gets the probability for an attribute value given a class
+	 *
+	 * @param attVal   the attribute value
+	 * @param classVal the class
+	 * @return probability for an attribute value given a class
+	 */
+	double probabilityOfAttributeValueGivenClass(double attVal, int classVal);
+
+	/**
+	 * Gets the best split suggestion given a criterion and a class distribution
+	 *
+	 * @param criterion    the split criterion to use
+	 * @param preSplitDist the class distribution before the split
+	 * @param attIndex     the attribute index
+	 * @param binaryOnly   true to use binary splits
+	 * @return suggestion of best attribute split
+	 */
+	AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(SplitCriterion criterion, double[] preSplitDist,
+			int attIndex, boolean binaryOnly);
+
+	void observeAttributeTarget(double attVal, double target);
+
+	void observeAttributeValue(double attVal, double value, double weight);
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/AttributeStatisticsObserver.java b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/AttributeStatisticsObserver.java
new file mode 100644
index 000000000..c6e31fe97
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/AttributeStatisticsObserver.java
@@ -0,0 +1,58 @@
+/*
+ *    AttributeClassObserver.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.core.attributeclassobservers;
+
+import moa.core.DoubleVector;
+import moa.learners.predictors.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.learners.predictors.rules.core.AttributeExpansionSuggestion;
+import moa.options.OptionHandler;
+
+/**
+ * Interface for observing the statistics for an attribute. This observer
+ * monitors the statistics for a given attribute. Used in
+ * AMRulesMultiLabelLearners
+ *
+ * @author João Duarte (joaomaiaduarte@gmail.com)
+ * @version $Revision: 1 $
+ */
+public interface AttributeStatisticsObserver extends OptionHandler {
+
+	/**
+	 * Updates statistics of this observer given an attribute value, the index of
+	 * the statistic and the weight of the instance observed
+	 *
+	 * @param inputAttributeValue the value for the attribute attribute
+	 * @param statistics          numOutputs x numStatistics the index of the
+	 *                            statistic to store
+	 */
+	void observeAttribute(double inputAttributeValue, DoubleVector[] statistics);
+
+	/**
+	 * Gets the best split suggestion given a criterion and a class distribution
+	 *
+	 * @param criterion    the split criterion to use
+	 * @param preSplitDist the class distribution before the split
+	 * @param attIndex     the input attribute index
+	 * @return suggestion of best attribute split
+	 */
+	AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(MultiLabelSplitCriterion criterion,
+			DoubleVector[] preSplitStatistics, int inputAttributeIndex);
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserver.java b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserver.java
new file mode 100644
index 000000000..d1f6fe213
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserver.java
@@ -0,0 +1,177 @@
+/*
+ *    BinaryTreeNumericAttributeClassObserver.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz), Andreas Hapfelmeier (Andreas.Hapfelmeier@in.tum.de)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ *
+ */
+package moa.learners.predictors.core.attributeclassobservers;
+
+import java.io.Serializable;
+
+import moa.core.DoubleVector;
+import moa.core.ObjectRepository;
+import moa.learners.predictors.core.AttributeSplitSuggestion;
+import moa.learners.predictors.core.conditionaltests.NumericAttributeBinaryTest;
+import moa.learners.predictors.core.splitcriteria.SplitCriterion;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Class for observing the class data distribution for a numeric attribute using
+ * a binary tree. This observer monitors the class distribution of a given
+ * attribute. Used in naive Bayes and decision trees to monitor data statistics
+ * on leaves.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public class BinaryTreeNumericAttributeClassObserver extends AbstractAttributeClassObserver
+		implements NumericAttributeClassObserver {
+
+	private static final long serialVersionUID = 1L;
+
+	public class Node implements Serializable {
+
+		private static final long serialVersionUID = 1L;
+
+		public double cut_point;
+
+		public DoubleVector classCountsLeft = new DoubleVector();
+
+		public DoubleVector classCountsRight = new DoubleVector();
+
+		public Node left;
+
+		public Node right;
+
+		public Node(double val, int label, double weight) {
+			this.cut_point = val;
+			this.classCountsLeft.addToValue(label, weight);
+		}
+
+		public void insertValue(double val, int label, double weight) {
+			if (val == this.cut_point) {
+				this.classCountsLeft.addToValue(label, weight);
+			} else if (val <= this.cut_point) {
+				this.classCountsLeft.addToValue(label, weight);
+				if (this.left == null) {
+					this.left = new Node(val, label, weight);
+				} else {
+					this.left.insertValue(val, label, weight);
+				}
+			} else { // val > cut_point
+				this.classCountsRight.addToValue(label, weight);
+				if (this.right == null) {
+					this.right = new Node(val, label, weight);
+				} else {
+					this.right.insertValue(val, label, weight);
+				}
+			}
+		}
+	}
+
+	public Node root = null;
+
+	@Override
+	public void observeAttributeClass(double attVal, int classVal, double weight) {
+		if (Double.isNaN(attVal)) { // Instance.isMissingValue(attVal)
+		} else {
+			if (this.root == null) {
+				this.root = new Node(attVal, classVal, weight);
+			} else {
+				this.root.insertValue(attVal, classVal, weight);
+			}
+		}
+	}
+
+	@Override
+	public double probabilityOfAttributeValueGivenClass(double attVal, int classVal) {
+		// TODO: NaiveBayes broken until implemented
+		return 0.0;
+	}
+
+	@Override
+	public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(SplitCriterion criterion, double[] preSplitDist,
+			int attIndex, boolean binaryOnly) {
+		return searchForBestSplitOption(this.root, null, null, null, null, false, criterion, preSplitDist, attIndex);
+	}
+
+	protected AttributeSplitSuggestion searchForBestSplitOption(Node currentNode,
+			AttributeSplitSuggestion currentBestOption, double[] actualParentLeft, double[] parentLeft,
+			double[] parentRight, boolean leftChild, SplitCriterion criterion, double[] preSplitDist, int attIndex) {
+		if (currentNode == null) {
+			return currentBestOption;
+		}
+		DoubleVector leftDist = new DoubleVector();
+		DoubleVector rightDist = new DoubleVector();
+		if (parentLeft == null) {
+			leftDist.addValues(currentNode.classCountsLeft);
+			rightDist.addValues(currentNode.classCountsRight);
+		} else {
+			leftDist.addValues(parentLeft);
+			rightDist.addValues(parentRight);
+			if (leftChild) {
+				// get the exact statistics of the parent value
+				DoubleVector exactParentDist = new DoubleVector();
+				exactParentDist.addValues(actualParentLeft);
+				exactParentDist.subtractValues(currentNode.classCountsLeft);
+				exactParentDist.subtractValues(currentNode.classCountsRight);
+
+				// move the subtrees
+				leftDist.subtractValues(currentNode.classCountsRight);
+				rightDist.addValues(currentNode.classCountsRight);
+
+				// move the exact value from the parent
+				rightDist.addValues(exactParentDist);
+				leftDist.subtractValues(exactParentDist);
+
+			} else {
+				leftDist.addValues(currentNode.classCountsLeft);
+				rightDist.subtractValues(currentNode.classCountsLeft);
+			}
+		}
+		double[][] postSplitDists = new double[][] { leftDist.getArrayRef(), rightDist.getArrayRef() };
+		double merit = criterion.getMeritOfSplit(preSplitDist, postSplitDists);
+		if ((currentBestOption == null) || (merit > currentBestOption.merit)) {
+			currentBestOption = new AttributeSplitSuggestion(
+					new NumericAttributeBinaryTest(attIndex, currentNode.cut_point, true), postSplitDists, merit);
+
+		}
+		currentBestOption = searchForBestSplitOption(currentNode.left, currentBestOption,
+				currentNode.classCountsLeft.getArrayRef(), postSplitDists[0], postSplitDists[1], true, criterion,
+				preSplitDist, attIndex);
+		currentBestOption = searchForBestSplitOption(currentNode.right, currentBestOption,
+				currentNode.classCountsLeft.getArrayRef(), postSplitDists[0], postSplitDists[1], false, criterion,
+				preSplitDist, attIndex);
+		return currentBestOption;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public void observeAttributeTarget(double attVal, double target) {
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserverRegression.java b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserverRegression.java
new file mode 100644
index 000000000..77481c09f
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/BinaryTreeNumericAttributeClassObserverRegression.java
@@ -0,0 +1,151 @@
+/*
+ *    BinaryTreeNumericAttributeClassObserverRegression.java
+ *    Copyright (C) 2013 University of Porto, Portugal
+ *    @author E. Almeida, J. Gama
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ *
+ */
+
+package moa.learners.predictors.core.attributeclassobservers;
+
+import java.io.Serializable;
+
+import moa.core.ObjectRepository;
+import moa.learners.predictors.core.AttributeSplitSuggestion;
+import moa.learners.predictors.core.splitcriteria.SplitCriterion;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Class for observing the class data distribution for a numeric attribute using
+ * a binary tree. This observer monitors the class distribution of a given
+ * attribute.
+ *
+ * <p>
+ * Learning Adaptive Model Rules from High-Speed Data Streams, ECML 2013, E.
+ * Almeida, C. Ferreira, P. Kosina and J. Gama;
+ * </p>
+ *
+ * @author E. Almeida, J. Gama
+ * @version $Revision: 2$
+ */
+public class BinaryTreeNumericAttributeClassObserverRegression extends AbstractAttributeClassObserver
+		implements NumericAttributeClassObserver {
+
+	public static final long serialVersionUID = 1L;
+
+	public class Node implements Serializable {
+
+		private static final long serialVersionUID = 1L;
+
+		public double cut_point;
+
+		public double[] lessThan; // This array maintains statistics for the instance reaching the node with
+									// attribute values less than or iqual to the cutpoint.
+
+		public double[] greaterThan; // This array maintains statistics for the instance reaching the node with
+										// attribute values greater than to the cutpoint.
+
+		public Node left;
+
+		public Node right;
+
+		public Node(double val, double target) {
+			this.cut_point = val;
+			this.lessThan = new double[3];
+			this.greaterThan = new double[3];
+			this.lessThan[0] = target; // The sum of their target attribute values.
+			this.lessThan[1] = target * target; // The sum of the squared target attribute values.
+			this.lessThan[2] = 1.0; // A counter of the number of instances that have reached the node.
+			this.greaterThan[0] = 0.0;
+			this.greaterThan[1] = 0.0;
+			this.greaterThan[2] = 0.0;
+		}
+
+		public void insertValue(double val, double target) {
+			if (val == this.cut_point) {
+				this.lessThan[0] = this.lessThan[0] + target;
+				this.lessThan[1] = this.lessThan[1] + (target * target);
+				this.lessThan[2] = this.lessThan[2] + 1;
+			} else if (val <= this.cut_point) {
+				this.lessThan[0] = this.lessThan[0] + target;
+				this.lessThan[1] = this.lessThan[1] + (target * target);
+				this.lessThan[2] = this.lessThan[2] + 1;
+				if (this.left == null) {
+					this.left = new Node(val, target);
+				} else {
+					this.left.insertValue(val, target);
+				}
+			} else {
+				this.greaterThan[0] = this.greaterThan[0] + target;
+				this.greaterThan[1] = this.greaterThan[1] + (target * target);
+				this.greaterThan[2] = this.greaterThan[2] + 1;
+				if (this.right == null) {
+					this.right = new Node(val, target);
+				} else {
+					this.right.insertValue(val, target);
+				}
+			}
+		}
+	}
+
+	public Node root1 = null;
+
+	@Override
+	public void observeAttributeTarget(double attVal, double target) {
+		if (Double.isNaN(attVal)) {
+		} else {
+			if (this.root1 == null) {
+				this.root1 = new Node(attVal, target);
+			} else {
+				this.root1.insertValue(attVal, target);
+			}
+		}
+	}
+
+	@Override
+	public void observeAttributeClass(double attVal, int classVal, double weight) {
+
+	}
+
+	@Override
+	public double probabilityOfAttributeValueGivenClass(double attVal, int classVal) {
+		// TODO: NaiveBayes broken until implemented
+		return 0.0;
+	}
+
+	@Override
+	public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(SplitCriterion criterion, double[] preSplitDist,
+			int attIndex, boolean binaryOnly) {
+		return searchForBestSplitOption(this.root1, null, null, null, null, false, criterion, preSplitDist, attIndex);
+	}
+
+	protected AttributeSplitSuggestion searchForBestSplitOption(Node currentNode,
+			AttributeSplitSuggestion currentBestOption, double[] actualParentLeft, double[] parentLeft,
+			double[] parentRight, boolean leftChild, SplitCriterion criterion, double[] preSplitDist, int attIndex) {
+
+		return currentBestOption;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// TODO Auto-generated method stub
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/DiscreteAttributeClassObserver.java b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/DiscreteAttributeClassObserver.java
similarity index 79%
rename from moa/src/main/java/moa/classifiers/core/attributeclassobservers/DiscreteAttributeClassObserver.java
rename to moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/DiscreteAttributeClassObserver.java
index f20d44006..f2cdb17f9 100644
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/DiscreteAttributeClassObserver.java
+++ b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/DiscreteAttributeClassObserver.java
@@ -15,19 +15,19 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.classifiers.core.attributeclassobservers;
+package moa.learners.predictors.core.attributeclassobservers;
 
 /**
- * Interface for observing the class data distribution for a discrete (nominal) attribute.
- * This observer monitors the class distribution of a given attribute.
- * Used in naive Bayes and decision trees to monitor data statistics on leaves.
+ * Interface for observing the class data distribution for a discrete (nominal)
+ * attribute. This observer monitors the class distribution of a given
+ * attribute. Used in naive Bayes and decision trees to monitor data statistics
+ * on leaves.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $ 
+ * @version $Revision: 7 $
  */
 public interface DiscreteAttributeClassObserver extends AttributeClassObserver {
 
-   
 }
diff --git a/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/FIMTDDNumericAttributeClassLimitObserver.java b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/FIMTDDNumericAttributeClassLimitObserver.java
new file mode 100644
index 000000000..2f58abbeb
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/FIMTDDNumericAttributeClassLimitObserver.java
@@ -0,0 +1,106 @@
+/*
+ *    FIMTDDNumericAttributeClassLimitObserver.java
+ *    Copyright (C) 2014 University of Porto, Portugal
+ *    @author A. Bifet, J. Duarte, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.predictors.core.attributeclassobservers;
+
+import com.github.javacliparser.IntOption;
+
+public class FIMTDDNumericAttributeClassLimitObserver extends FIMTDDNumericAttributeClassObserver {
+
+	/**
+	 *
+	 */
+	private static final long serialVersionUID = 1L;
+	protected int maxNodes;
+	public IntOption maxNodesOption = new IntOption("maxNodesOption", 'z', "Maximum number of nodes", 50, 0,
+			Integer.MAX_VALUE);
+
+	protected int numNodes;
+
+	@Override
+	public void observeAttributeClass(double attVal, double classVal, double weight) {
+		if (Double.isNaN(attVal)) { // Instance.isMissingValue(attVal)
+		} else {
+			if (this.root == null) {
+				maxNodes = maxNodesOption.getValue();
+				this.root = new FIMTDDNumericAttributeClassLimitObserver.Node(attVal, classVal, weight);
+			} else {
+				this.root.insertValue(attVal, classVal, weight);
+			}
+		}
+	}
+
+	protected class Node extends FIMTDDNumericAttributeClassObserver.Node {
+		/**
+		 *
+		 */
+		private static final long serialVersionUID = -4484141636424708465L;
+
+		public Node(double val, double label, double weight) {
+			super(val, label, weight);
+		}
+
+		protected Node root = null;
+
+		/**
+		 * Insert a new value into the tree, updating both the sum of values and sum of
+		 * squared values arrays
+		 */
+		@Override
+		public void insertValue(double val, double label, double weight) {
+
+			// If the new value equals the value stored in a node, update
+			// the left (<=) node information
+			if (val == this.cut_point) {
+				this.leftStatistics.addToValue(0, 1);
+				this.leftStatistics.addToValue(1, label);
+				this.leftStatistics.addToValue(2, label * label);
+			}
+			// If the new value is less than the value in a node, update the
+			// left distribution and send the value down to the left child node.
+			// If no left child exists, create one
+			else if (val < this.cut_point) {
+				this.leftStatistics.addToValue(0, 1);
+				this.leftStatistics.addToValue(1, label);
+				this.leftStatistics.addToValue(2, label * label);
+				if (this.left == null) {
+					if (numNodes < maxNodes) {
+						this.left = new Node(val, label, weight);
+						++numNodes;
+					}
+				} else {
+					this.left.insertValue(val, label, weight);
+				}
+			}
+			// If the new value is greater than the value in a node, update the
+			// right (>) distribution and send the value down to the right child node.
+			// If no right child exists, create one
+			else { // val > cut_point
+				if (this.right == null) {
+					if (numNodes < maxNodes) {
+						this.right = new Node(val, label, weight);
+						++numNodes;
+					}
+				} else {
+					this.right.insertValue(val, label, weight);
+				}
+			}
+		}
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/FIMTDDNumericAttributeClassObserver.java b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/FIMTDDNumericAttributeClassObserver.java
new file mode 100644
index 000000000..0c0c0791c
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/FIMTDDNumericAttributeClassObserver.java
@@ -0,0 +1,268 @@
+/*
+ *    FIMTDDNumericAttributeClassObserver.java
+ *    Copyright (C) 2013 University of Porto, Portugal
+ *    @author Katie de Lange, E. Almeida, J. Gama
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ *
+ */
+
+/* Project Knowledge Discovery from Data Streams, FCT LIAAD-INESC TEC,
+ *
+ * Contact: jgama@fep.up.pt
+ */
+
+package moa.learners.predictors.core.attributeclassobservers;
+
+import java.io.Serializable;
+
+import moa.core.DoubleVector;
+import moa.core.ObjectRepository;
+import moa.learners.predictors.core.AttributeSplitSuggestion;
+import moa.learners.predictors.core.conditionaltests.NumericAttributeBinaryTest;
+import moa.learners.predictors.core.splitcriteria.SplitCriterion;
+import moa.tasks.TaskMonitor;
+
+public class FIMTDDNumericAttributeClassObserver extends BinaryTreeNumericAttributeClassObserver
+		implements NumericAttributeClassObserver {
+
+	private static final long serialVersionUID = 1L;
+
+	protected class Node implements Serializable {
+
+		private static final long serialVersionUID = 1L;
+
+		// The split point to use
+		public double cut_point;
+
+		// E-BST statistics
+		public DoubleVector leftStatistics = new DoubleVector();
+		// public DoubleVector rightStatistics = new DoubleVector();
+
+		// Child nodes
+		public Node left;
+		public Node right;
+
+		public Node(double val, double label, double weight) {
+			this.cut_point = val;
+			this.leftStatistics.addToValue(0, weight);
+			this.leftStatistics.addToValue(1, weight * label);
+			this.leftStatistics.addToValue(2, weight * label * label);
+		}
+
+		/**
+		 * Insert a new value into the tree, updating both the sum of values and sum of
+		 * squared values arrays
+		 */
+		public void insertValue(double val, double label, double weight) {
+
+			// If the new value equals the value stored in a node, update
+			// the left (<=) node information
+			if (val == this.cut_point) {
+				this.leftStatistics.addToValue(0, weight);
+				this.leftStatistics.addToValue(1, weight * label);
+				this.leftStatistics.addToValue(2, weight * label * label);
+			} // If the new value is less than the value in a node, update the
+				// left distribution and send the value down to the left child node.
+				// If no left child exists, create one
+			else if (val <= this.cut_point) {
+				this.leftStatistics.addToValue(0, weight);
+				this.leftStatistics.addToValue(1, weight * label);
+				this.leftStatistics.addToValue(2, weight * label * label);
+				if (this.left == null) {
+					this.left = new Node(val, label, weight);
+				} else {
+					this.left.insertValue(val, label, weight);
+				}
+			} // If the new value is greater than the value in a node, update the
+				// right (>) distribution and send the value down to the right child node.
+				// If no right child exists, create one
+			else { // val > cut_point
+					// this.rightStatistics.addToValue(0, weight);
+					// this.rightStatistics.addToValue(1, weight * label);
+					// this.rightStatistics.addToValue(2, weight * label * label);
+					// if (this.right == null) {
+					// this.right = new Node(val, label, weight);
+					// } else {
+					// this.right.insertValue(val, label, weight);
+					// }
+			}
+		}
+	}
+
+	// Root node of the E-BST structure for this attribute
+	protected Node root = null;
+
+	// Global variables for use in the FindBestSplit algorithm
+	double sumTotalLeft;
+	double sumTotalRight;
+	double sumSqTotalLeft;
+	double sumSqTotalRight;
+	double countRightTotal;
+	double countLeftTotal;
+
+	public static double roundToSignificantFigures(double num, int n) {
+		final double d = Math.ceil(Math.log10(num < 0 ? -num : num));
+		final int power = n - (int) d;
+
+		final double magnitude = Math.pow(10, power);
+		final long shifted = (long) (num * magnitude);
+		return shifted / magnitude;
+	}
+
+	public void observeAttributeClass(double attVal, double classVal, double weight) {
+		if (Double.isNaN(attVal)) { // Instance.isMissingValue(attVal)
+		} else {
+			if (this.root == null) {
+//            	if ((long) attVal != attVal) attVal = roundToSignificantFigures(attVal, 4);
+				this.root = new Node(attVal, classVal, weight);
+			} else {
+				this.root.insertValue(attVal, classVal, weight);
+			}
+		}
+	}
+
+	@Override
+	public double probabilityOfAttributeValueGivenClass(double attVal, int classVal) {
+		// TODO: NaiveBayes broken until implemented
+		return 0.0;
+	}
+
+	@Override
+	public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(SplitCriterion criterion, double[] preSplitDist,
+			int attIndex, boolean binaryOnly) {
+
+		// Initialise global variables
+		sumTotalLeft = 0;
+		sumTotalRight = preSplitDist[1];
+		sumSqTotalLeft = 0;
+		sumSqTotalRight = preSplitDist[2];
+		countLeftTotal = 0;
+		countRightTotal = preSplitDist[0];
+		return searchForBestSplitOption(this.root, null, criterion, attIndex);
+	}
+
+	/**
+	 * Implementation of the FindBestSplit algorithm from E.Ikonomovska et al.
+	 */
+	protected AttributeSplitSuggestion searchForBestSplitOption(Node currentNode,
+			AttributeSplitSuggestion currentBestOption, SplitCriterion criterion, int attIndex) {
+		// Return null if the current node is null or we have finished looking through
+		// all the possible splits
+		if (currentNode == null || countRightTotal == 0.0) {
+			return currentBestOption;
+		}
+
+		if (currentNode.left != null) {
+			currentBestOption = searchForBestSplitOption(currentNode.left, currentBestOption, criterion, attIndex);
+		}
+
+		sumTotalLeft += currentNode.leftStatistics.getValue(1);
+		sumTotalRight -= currentNode.leftStatistics.getValue(1);
+		sumSqTotalLeft += currentNode.leftStatistics.getValue(2);
+		sumSqTotalRight -= currentNode.leftStatistics.getValue(2);
+		countLeftTotal += currentNode.leftStatistics.getValue(0);
+		countRightTotal -= currentNode.leftStatistics.getValue(0);
+
+		double[][] postSplitDists = new double[][] { { countLeftTotal, sumTotalLeft, sumSqTotalLeft },
+				{ countRightTotal, sumTotalRight, sumSqTotalRight } };
+		double[] preSplitDist = new double[] { (countLeftTotal + countRightTotal), (sumTotalLeft + sumTotalRight),
+				(sumSqTotalLeft + sumSqTotalRight) };
+		double merit = criterion.getMeritOfSplit(preSplitDist, postSplitDists);
+
+		if ((currentBestOption == null) || (merit > currentBestOption.merit)) {
+			currentBestOption = new AttributeSplitSuggestion(
+					new NumericAttributeBinaryTest(attIndex, currentNode.cut_point, true), postSplitDists, merit);
+
+		}
+
+		if (currentNode.right != null) {
+			currentBestOption = searchForBestSplitOption(currentNode.right, currentBestOption, criterion, attIndex);
+		}
+		sumTotalLeft -= currentNode.leftStatistics.getValue(1);
+		sumTotalRight += currentNode.leftStatistics.getValue(1);
+		sumSqTotalLeft -= currentNode.leftStatistics.getValue(2);
+		sumSqTotalRight += currentNode.leftStatistics.getValue(2);
+		countLeftTotal -= currentNode.leftStatistics.getValue(0);
+		countRightTotal += currentNode.leftStatistics.getValue(0);
+
+		return currentBestOption;
+	}
+
+	/**
+	 * A method to remove all nodes in the E-BST in which it and all it's children
+	 * represent 'bad' split points
+	 */
+	public void removeBadSplits(SplitCriterion criterion, double lastCheckRatio, double lastCheckSDR,
+			double lastCheckE) {
+		removeBadSplitNodes(criterion, this.root, lastCheckRatio, lastCheckSDR, lastCheckE);
+	}
+
+	/**
+	 * Recursive method that first checks all of a node's children before deciding
+	 * if it is 'bad' and may be removed
+	 */
+	private boolean removeBadSplitNodes(SplitCriterion criterion, Node currentNode, double lastCheckRatio,
+			double lastCheckSDR, double lastCheckE) {
+		boolean isBad = false;
+
+		if (currentNode == null) {
+			return true;
+		}
+
+		if (currentNode.left != null) {
+			isBad = removeBadSplitNodes(criterion, currentNode.left, lastCheckRatio, lastCheckSDR, lastCheckE);
+		}
+
+		if (currentNode.right != null && isBad) {
+			isBad = removeBadSplitNodes(criterion, currentNode.left, lastCheckRatio, lastCheckSDR, lastCheckE);
+		}
+
+		if (isBad) {
+
+			// double[][] postSplitDists = new
+			// double[][]{{currentNode.leftStatistics.getValue(0),
+			// currentNode.leftStatistics.getValue(1),
+			// currentNode.leftStatistics.getValue(2)},
+			// {currentNode.rightStatistics.getValue(0),
+			// currentNode.rightStatistics.getValue(1),
+			// currentNode.rightStatistics.getValue(2)}};
+			// double[] preSplitDist = new double[]{(currentNode.leftStatistics.getValue(0)
+			// + currentNode.rightStatistics.getValue(0)),
+			// (currentNode.leftStatistics.getValue(1) +
+			// currentNode.rightStatistics.getValue(1)),
+			// (currentNode.leftStatistics.getValue(2) +
+			// currentNode.rightStatistics.getValue(2))};
+			// double merit = criterion.getMeritOfSplit(preSplitDist, postSplitDists);
+
+			// if ((merit / lastCheckSDR) < (lastCheckRatio - (2 * lastCheckE))) {
+			// currentNode = null;
+			// return true;
+			// }
+		}
+
+		return false;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// TODO Auto-generated method stub
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/GaussianNumericAttributeClassObserver.java b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/GaussianNumericAttributeClassObserver.java
new file mode 100644
index 000000000..dd16a4b1e
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/GaussianNumericAttributeClassObserver.java
@@ -0,0 +1,170 @@
+/*
+ *    GaussianNumericAttributeClassObserver.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.core.attributeclassobservers;
+
+import java.util.Set;
+import java.util.TreeSet;
+
+import com.github.javacliparser.IntOption;
+
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.GaussianEstimator;
+import moa.core.ObjectRepository;
+import moa.core.Utils;
+import moa.learners.predictors.core.AttributeSplitSuggestion;
+import moa.learners.predictors.core.conditionaltests.NumericAttributeBinaryTest;
+import moa.learners.predictors.core.splitcriteria.SplitCriterion;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Class for observing the class data distribution for a numeric attribute using
+ * gaussian estimators. This observer monitors the class distribution of a given
+ * attribute. Used in naive Bayes and decision trees to monitor data statistics
+ * on leaves.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public class GaussianNumericAttributeClassObserver extends AbstractAttributeClassObserver
+		implements NumericAttributeClassObserver {
+
+	private static final long serialVersionUID = 1L;
+
+	protected DoubleVector minValueObservedPerClass = new DoubleVector();
+
+	protected DoubleVector maxValueObservedPerClass = new DoubleVector();
+
+	protected AutoExpandVector<GaussianEstimator> attValDistPerClass = new AutoExpandVector<>();
+
+	public IntOption numBinsOption = new IntOption("numBins", 'n', "The number of bins.", 10, 1, Integer.MAX_VALUE);
+
+	@Override
+	public void observeAttributeClass(double attVal, int classVal, double weight) {
+		if (Utils.isMissingValue(attVal)) {
+		} else {
+			GaussianEstimator valDist = this.attValDistPerClass.get(classVal);
+			if (valDist == null) {
+				valDist = new GaussianEstimator();
+				this.attValDistPerClass.set(classVal, valDist);
+				this.minValueObservedPerClass.setValue(classVal, attVal);
+				this.maxValueObservedPerClass.setValue(classVal, attVal);
+			} else {
+				if (attVal < this.minValueObservedPerClass.getValue(classVal)) {
+					this.minValueObservedPerClass.setValue(classVal, attVal);
+				}
+				if (attVal > this.maxValueObservedPerClass.getValue(classVal)) {
+					this.maxValueObservedPerClass.setValue(classVal, attVal);
+				}
+			}
+			valDist.addObservation(attVal, weight);
+		}
+	}
+
+	@Override
+	public double probabilityOfAttributeValueGivenClass(double attVal, int classVal) {
+		GaussianEstimator obs = this.attValDistPerClass.get(classVal);
+		return obs != null ? obs.probabilityDensity(attVal) : 0.0;
+	}
+
+	@Override
+	public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(SplitCriterion criterion, double[] preSplitDist,
+			int attIndex, boolean binaryOnly) {
+		AttributeSplitSuggestion bestSuggestion = null;
+		double[] suggestedSplitValues = getSplitPointSuggestions();
+		for (double splitValue : suggestedSplitValues) {
+			double[][] postSplitDists = getClassDistsResultingFromBinarySplit(splitValue);
+			double merit = criterion.getMeritOfSplit(preSplitDist, postSplitDists);
+			if ((bestSuggestion == null) || (merit > bestSuggestion.merit)) {
+				bestSuggestion = new AttributeSplitSuggestion(
+						new NumericAttributeBinaryTest(attIndex, splitValue, true), postSplitDists, merit);
+			}
+		}
+		return bestSuggestion;
+	}
+
+	public double[] getSplitPointSuggestions() {
+		Set<Double> suggestedSplitValues = new TreeSet<>();
+		double minValue = Double.POSITIVE_INFINITY;
+		double maxValue = Double.NEGATIVE_INFINITY;
+		for (int i = 0; i < this.attValDistPerClass.size(); i++) {
+			GaussianEstimator estimator = this.attValDistPerClass.get(i);
+			if (estimator != null) {
+				if (this.minValueObservedPerClass.getValue(i) < minValue) {
+					minValue = this.minValueObservedPerClass.getValue(i);
+				}
+				if (this.maxValueObservedPerClass.getValue(i) > maxValue) {
+					maxValue = this.maxValueObservedPerClass.getValue(i);
+				}
+			}
+		}
+		if (minValue < Double.POSITIVE_INFINITY) {
+			double range = maxValue - minValue;
+			for (int i = 0; i < this.numBinsOption.getValue(); i++) {
+				double splitValue = range / (this.numBinsOption.getValue() + 1.0) * (i + 1) + minValue;
+				if ((splitValue > minValue) && (splitValue < maxValue)) {
+					suggestedSplitValues.add(splitValue);
+				}
+			}
+		}
+		double[] suggestions = new double[suggestedSplitValues.size()];
+		int i = 0;
+		for (double suggestion : suggestedSplitValues) {
+			suggestions[i++] = suggestion;
+		}
+		return suggestions;
+	}
+
+	// assume all values equal to splitValue go to lhs
+	public double[][] getClassDistsResultingFromBinarySplit(double splitValue) {
+		DoubleVector lhsDist = new DoubleVector();
+		DoubleVector rhsDist = new DoubleVector();
+		for (int i = 0; i < this.attValDistPerClass.size(); i++) {
+			GaussianEstimator estimator = this.attValDistPerClass.get(i);
+			if (estimator != null) {
+				if (splitValue < this.minValueObservedPerClass.getValue(i)) {
+					rhsDist.addToValue(i, estimator.getTotalWeightObserved());
+				} else if (splitValue >= this.maxValueObservedPerClass.getValue(i)) {
+					lhsDist.addToValue(i, estimator.getTotalWeightObserved());
+				} else {
+					double[] weightDist = estimator.estimatedWeight_LessThan_EqualTo_GreaterThan_Value(splitValue);
+					lhsDist.addToValue(i, weightDist[0] + weightDist[1]);
+					rhsDist.addToValue(i, weightDist[2]);
+				}
+			}
+		}
+		return new double[][] { lhsDist.getArrayRef(), rhsDist.getArrayRef() };
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public void observeAttributeTarget(double attVal, double target) {
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/GreenwaldKhannaNumericAttributeClassObserver.java b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/GreenwaldKhannaNumericAttributeClassObserver.java
new file mode 100644
index 000000000..12d5e4012
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/GreenwaldKhannaNumericAttributeClassObserver.java
@@ -0,0 +1,122 @@
+/*
+ *    GreenwaldKhannaNumericAttributeClassObserver.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.core.attributeclassobservers;
+
+import com.github.javacliparser.IntOption;
+
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.GreenwaldKhannaQuantileSummary;
+import moa.core.ObjectRepository;
+import moa.core.Utils;
+import moa.learners.predictors.core.AttributeSplitSuggestion;
+import moa.learners.predictors.core.conditionaltests.NumericAttributeBinaryTest;
+import moa.learners.predictors.core.splitcriteria.SplitCriterion;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Class for observing the class data distribution for a numeric attribute using
+ * Greenwald and Khanna methodology. This observer monitors the class
+ * distribution of a given attribute. Used in naive Bayes and decision trees to
+ * monitor data statistics on leaves.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public class GreenwaldKhannaNumericAttributeClassObserver extends AbstractAttributeClassObserver
+		implements NumericAttributeClassObserver {
+
+	private static final long serialVersionUID = 1L;
+
+	protected AutoExpandVector<GreenwaldKhannaQuantileSummary> attValDistPerClass = new AutoExpandVector<>();
+
+	public IntOption numTuplesOption = new IntOption("numTuples", 'n', "The number of tuples.", 10, 1,
+			Integer.MAX_VALUE);
+
+	@Override
+	public void observeAttributeClass(double attVal, int classVal, double weight) {
+		if (Utils.isMissingValue(attVal)) {
+		} else {
+			GreenwaldKhannaQuantileSummary valDist = this.attValDistPerClass.get(classVal);
+			if (valDist == null) {
+				valDist = new GreenwaldKhannaQuantileSummary(this.numTuplesOption.getValue());
+				this.attValDistPerClass.set(classVal, valDist);
+			}
+			// TODO: not taking weight into account
+			valDist.insert(attVal);
+		}
+	}
+
+	@Override
+	public double probabilityOfAttributeValueGivenClass(double attVal, int classVal) {
+		// TODO: NaiveBayes broken until implemented
+		return 0.0;
+	}
+
+	@Override
+	public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(SplitCriterion criterion, double[] preSplitDist,
+			int attIndex, boolean binaryOnly) {
+		AttributeSplitSuggestion bestSuggestion = null;
+		for (GreenwaldKhannaQuantileSummary qs : this.attValDistPerClass) {
+			if (qs != null) {
+				double[] cutpoints = qs.getSuggestedCutpoints();
+				for (double cutpoint : cutpoints) {
+					double[][] postSplitDists = getClassDistsResultingFromBinarySplit(cutpoint);
+					double merit = criterion.getMeritOfSplit(preSplitDist, postSplitDists);
+					if ((bestSuggestion == null) || (merit > bestSuggestion.merit)) {
+						bestSuggestion = new AttributeSplitSuggestion(
+								new NumericAttributeBinaryTest(attIndex, cutpoint, true), postSplitDists, merit);
+					}
+				}
+			}
+		}
+		return bestSuggestion;
+	}
+
+	// assume all values equal to splitValue go to lhs
+	public double[][] getClassDistsResultingFromBinarySplit(double splitValue) {
+		DoubleVector lhsDist = new DoubleVector();
+		DoubleVector rhsDist = new DoubleVector();
+		for (int i = 0; i < this.attValDistPerClass.size(); i++) {
+			GreenwaldKhannaQuantileSummary estimator = this.attValDistPerClass.get(i);
+			if (estimator != null) {
+				long countBelow = estimator.getCountBelow(splitValue);
+				lhsDist.addToValue(i, countBelow);
+				rhsDist.addToValue(i, estimator.getTotalCount() - countBelow);
+			}
+		}
+		return new double[][] { lhsDist.getArrayRef(), rhsDist.getArrayRef() };
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public void observeAttributeTarget(double attVal, double target) {
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/MultiLabelBSTree.java b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/MultiLabelBSTree.java
similarity index 55%
rename from moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/MultiLabelBSTree.java
rename to moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/MultiLabelBSTree.java
index c6790279a..a07b511b1 100644
--- a/moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/MultiLabelBSTree.java
+++ b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/MultiLabelBSTree.java
@@ -1,24 +1,25 @@
-package moa.classifiers.mlc.core.attributeclassobservers;
+package moa.learners.predictors.core.attributeclassobservers;
 
 import java.io.Serializable;
 
 import com.github.javacliparser.IntOption;
 
-import moa.classifiers.mlc.core.splitcriteria.MultiLabelSplitCriterion;
-import moa.classifiers.rules.core.AttributeExpansionSuggestion;
-import moa.classifiers.rules.core.NumericRulePredicate;
-import moa.classifiers.rules.core.Utils;
 import moa.core.DoubleVector;
 import moa.core.ObjectRepository;
+import moa.learners.predictors.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.learners.predictors.rules.core.AttributeExpansionSuggestion;
+import moa.learners.predictors.rules.core.NumericRulePredicate;
+import moa.learners.predictors.rules.core.Utils;
 import moa.options.AbstractOptionHandler;
 import moa.tasks.TaskMonitor;
 
 public class MultiLabelBSTree extends AbstractOptionHandler implements NumericStatisticsObserver {
 
 	/**
-	 * 
+	 *
 	 */
-	public IntOption maxNodesOption = new IntOption("maxNodesOption", 'z', "Maximum number of nodes", 2000, 0, Integer.MAX_VALUE);
+	public IntOption maxNodesOption = new IntOption("maxNodesOption", 'z', "Maximum number of nodes", 2000, 0,
+			Integer.MAX_VALUE);
 	protected int maxNodes;
 	protected int numNodes;
 
@@ -30,12 +31,12 @@ public class MultiLabelBSTree extends AbstractOptionHandler implements NumericSt
 	protected DoubleVector[] rightStatistics;
 
 	public static double roundToSignificantFigures(double num, int n) {
-		final double d = Math.ceil(Math.log10(num < 0 ? -num: num));
+		final double d = Math.ceil(Math.log10(num < 0 ? -num : num));
 		final int power = n - (int) d;
 
 		final double magnitude = Math.pow(10, power);
-		final long shifted = (long) (num*magnitude);
-		return shifted/magnitude;
+		final long shifted = (long) (num * magnitude);
+		return shifted / magnitude;
 	}
 
 	@Override
@@ -51,60 +52,65 @@ public void observeAttribute(double inputAttributeValue, DoubleVector[] statisti
 
 	}
 
-
 	@Override
-	public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(MultiLabelSplitCriterion criterion, DoubleVector[] preSplitStatistics, int inputAttributeIndex) {
+	public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(MultiLabelSplitCriterion criterion,
+			DoubleVector[] preSplitStatistics, int inputAttributeIndex) {
 		// Initialize global variables
-		int numOutputs=preSplitStatistics.length;
-		leftStatistics=new DoubleVector[numOutputs];
-		rightStatistics=new DoubleVector[numOutputs];
-		for (int i=0; i< numOutputs; i++)
-		{
-			leftStatistics[i]=new DoubleVector(new double [preSplitStatistics[i].numValues()]); //sets statistics to zeros
-			rightStatistics[i]=new DoubleVector(preSplitStatistics[i]);
+		int numOutputs = preSplitStatistics.length;
+		leftStatistics = new DoubleVector[numOutputs];
+		rightStatistics = new DoubleVector[numOutputs];
+		for (int i = 0; i < numOutputs; i++) {
+			leftStatistics[i] = new DoubleVector(new double[preSplitStatistics[i].numValues()]); // sets statistics to
+																									// zeros
+			rightStatistics[i] = new DoubleVector(preSplitStatistics[i]);
 		}
 
-		AttributeExpansionSuggestion out = searchForBestSplitOption(this.root, null, criterion, preSplitStatistics, inputAttributeIndex);
+		AttributeExpansionSuggestion out = searchForBestSplitOption(this.root, null, criterion, preSplitStatistics,
+				inputAttributeIndex);
 		leftStatistics = null;
 		rightStatistics = null;
 		return out;
 	}
 
-	protected AttributeExpansionSuggestion searchForBestSplitOption(Node currentNode, AttributeExpansionSuggestion currentBestOption, MultiLabelSplitCriterion criterion, DoubleVector [] preSplitStatistics, int inputAttributeIndex) {
-		// Return null if the current node is null or we have finished looking through all the possible splits
+	protected AttributeExpansionSuggestion searchForBestSplitOption(Node currentNode,
+			AttributeExpansionSuggestion currentBestOption, MultiLabelSplitCriterion criterion,
+			DoubleVector[] preSplitStatistics, int inputAttributeIndex) {
+		// Return null if the current node is null or we have finished looking through
+		// all the possible splits
 		if (currentNode == null) { // TODO: JD check || countRightTotal == 0.0
 			return currentBestOption;
 		}
 
 		if (currentNode.left != null) {
-			currentBestOption = searchForBestSplitOption(currentNode.left, currentBestOption, criterion, preSplitStatistics, inputAttributeIndex);
+			currentBestOption = searchForBestSplitOption(currentNode.left, currentBestOption, criterion,
+					preSplitStatistics, inputAttributeIndex);
 		}
 
-		for (int i=0; i<leftStatistics.length; i++)
-		{
+		for (int i = 0; i < leftStatistics.length; i++) {
 			leftStatistics[i].addValues(currentNode.statistics[i]);
 			rightStatistics[i].subtractValues(currentNode.statistics[i]);
 		}
 
-		DoubleVector[][] postSplitDists = new DoubleVector [leftStatistics.length][2];
-		for (int i=0; i<leftStatistics.length; i++)
-		{
-			postSplitDists[i]= new DoubleVector[2];
-			postSplitDists[i][0]=leftStatistics[i];
-			postSplitDists[i][1]=rightStatistics[i];
+		DoubleVector[][] postSplitDists = new DoubleVector[leftStatistics.length][2];
+		for (int i = 0; i < leftStatistics.length; i++) {
+			postSplitDists[i] = new DoubleVector[2];
+			postSplitDists[i][0] = leftStatistics[i];
+			postSplitDists[i][1] = rightStatistics[i];
 		}
 
 		double merit = criterion.getMeritOfSplit(preSplitStatistics, postSplitDists);
 
 		if ((currentBestOption == null) || (merit > currentBestOption.merit)) {
-			currentBestOption= new AttributeExpansionSuggestion(new NumericRulePredicate(inputAttributeIndex, currentNode.cutPoint, true), Utils.copy(postSplitDists), merit);
+			currentBestOption = new AttributeExpansionSuggestion(
+					new NumericRulePredicate(inputAttributeIndex, currentNode.cutPoint, true),
+					Utils.copy(postSplitDists), merit);
 		}
 
 		if (currentNode.right != null) {
-			currentBestOption = searchForBestSplitOption(currentNode.right, currentBestOption, criterion, preSplitStatistics, inputAttributeIndex);
+			currentBestOption = searchForBestSplitOption(currentNode.right, currentBestOption, criterion,
+					preSplitStatistics, inputAttributeIndex);
 		}
-		for (int i=0; i<leftStatistics.length; i++)
-		{
+		for (int i = 0; i < leftStatistics.length; i++) {
 			leftStatistics[i].subtractValues(currentNode.statistics[i]);
 			rightStatistics[i].addValues(currentNode.statistics[i]);
 		}
@@ -112,26 +118,21 @@ protected AttributeExpansionSuggestion searchForBestSplitOption(Node currentNode
 		return currentBestOption;
 	}
 
-
-
-
 	@Override
 	public String getPurposeString() {
 		return "Stores statistics for all output attributes for a giver input attribute.";
 	}
 
 	@Override
-	public void getDescription(StringBuilder sb, int indent) {	
+	public void getDescription(StringBuilder sb, int indent) {
 	}
 
 	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
 
 	}
 
-
-	//Inner classes inspired in FIMTDDNumericalAttributeClassObserver
+	// Inner classes inspired in FIMTDDNumericalAttributeClassObserver
 
 	protected class Node implements Serializable {
 
@@ -147,36 +148,34 @@ protected class Node implements Serializable {
 		private Node left;
 		private Node right;
 
-		public Node(double inputAttributeValue, DoubleVector [] statistics) {
+		public Node(double inputAttributeValue, DoubleVector[] statistics) {
 			cutPoint = inputAttributeValue;
-			int numOutputAttributes=statistics.length;
-			this.statistics=new DoubleVector[numOutputAttributes];
-			for (int i=0; i<numOutputAttributes; i++)
-			{					
-				this.statistics[i]=new DoubleVector(statistics[i]);
+			int numOutputAttributes = statistics.length;
+			this.statistics = new DoubleVector[numOutputAttributes];
+			for (int i = 0; i < numOutputAttributes; i++) {
+				this.statistics[i] = new DoubleVector(statistics[i]);
 			}
 		}
 
 		/**
 		 * Updates tree with new observation
 		 */
-		public void observeAttribute(double inputAttributeValue, DoubleVector [] statistics) {
+		public void observeAttribute(double inputAttributeValue, DoubleVector[] statistics) {
 			if (inputAttributeValue == this.cutPoint) {
-				for (int i=0; i<statistics.length; i++)
+				for (int i = 0; i < statistics.length; i++)
 					this.statistics[i].addValues(statistics[i]);
-			}
-			else if (inputAttributeValue < this.cutPoint) {
+			} else if (inputAttributeValue < this.cutPoint) {
 				if (this.left == null) {
-					if(numNodes < maxNodes){
+					if (numNodes < maxNodes) {
 						this.left = new Node(inputAttributeValue, statistics);
 						++numNodes;
 					}
 				} else {
 					this.left.observeAttribute(inputAttributeValue, statistics);
 				}
-			} else { 
+			} else {
 				if (this.right == null) {
-					if(numNodes < maxNodes){
+					if (numNodes < maxNodes) {
 						this.right = new Node(inputAttributeValue, statistics);
 						++numNodes;
 					}
diff --git a/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/MultiLabelBSTreeFloat.java b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/MultiLabelBSTreeFloat.java
new file mode 100644
index 000000000..cf790e9d8
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/MultiLabelBSTreeFloat.java
@@ -0,0 +1,218 @@
+/*
+ *    MultiLabelBSTreeFloat.java
+ *    Copyright (C) 2017 University of Porto, Portugal
+ *    @author J. Duarte, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.predictors.core.attributeclassobservers;
+
+import java.io.Serializable;
+
+import com.github.javacliparser.IntOption;
+
+import moa.core.DoubleVector;
+import moa.core.ObjectRepository;
+import moa.learners.predictors.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.learners.predictors.rules.core.AttributeExpansionSuggestion;
+import moa.learners.predictors.rules.core.NumericRulePredicate;
+import moa.learners.predictors.rules.core.Utils;
+import moa.options.AbstractOptionHandler;
+import moa.tasks.TaskMonitor;
+
+public class MultiLabelBSTreeFloat extends AbstractOptionHandler implements NumericStatisticsObserver {
+
+	/**
+	 *
+	 */
+	public IntOption maxNodesOption = new IntOption("maxNodesOption", 'z', "Maximum number of nodes", 50, 0,
+			Integer.MAX_VALUE);
+	protected int maxNodes;
+	protected int numNodes;
+
+	private static final long serialVersionUID = 1L;
+
+	protected Node root = null;
+
+	protected DoubleVector[] leftStatistics;
+	protected DoubleVector[] rightStatistics;
+
+	@Override
+	public void observeAttribute(double inputAttributeValue, DoubleVector[] statistics) {
+		if (!Double.isNaN(inputAttributeValue)) {
+			if (this.root == null) {
+				this.root = new Node(inputAttributeValue, statistics);
+				maxNodes = maxNodesOption.getValue();
+			} else {
+				this.root.observeAttribute(inputAttributeValue, statistics);
+			}
+		}
+
+	}
+
+	@Override
+	public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(MultiLabelSplitCriterion criterion,
+			DoubleVector[] preSplitStatistics, int inputAttributeIndex) {
+		// Initialize global variables
+		int numOutputs = preSplitStatistics.length;
+		leftStatistics = new DoubleVector[numOutputs];
+		rightStatistics = new DoubleVector[numOutputs];
+		for (int i = 0; i < numOutputs; i++) {
+			leftStatistics[i] = new DoubleVector(new double[preSplitStatistics[i].numValues()]); // sets statistics to
+																									// zeros
+			rightStatistics[i] = new DoubleVector(preSplitStatistics[i]);
+		}
+		AttributeExpansionSuggestion ret = searchForBestSplitOption(this.root, null, criterion, preSplitStatistics,
+				inputAttributeIndex);
+		leftStatistics = null;
+		rightStatistics = null;
+		return ret;
+	}
+
+	protected AttributeExpansionSuggestion searchForBestSplitOption(Node currentNode,
+			AttributeExpansionSuggestion currentBestOption, MultiLabelSplitCriterion criterion,
+			DoubleVector[] preSplitStatistics, int inputAttributeIndex) {
+		// Return null if the current node is null or we have finished looking through
+		// all the possible splits
+		if (currentNode == null) { // TODO: JD check || countRightTotal == 0.0
+			return currentBestOption;
+		}
+
+		if (currentNode.left != null) {
+			currentBestOption = searchForBestSplitOption(currentNode.left, currentBestOption, criterion,
+					preSplitStatistics, inputAttributeIndex);
+		}
+		for (int i = 0; i < leftStatistics.length; i++) {
+			DoubleVector leftStatsDouble = Utils.floatToDoubleVector(currentNode.leftStatistics[i]);
+			leftStatistics[i].addValues(leftStatsDouble);
+			rightStatistics[i].subtractValues(leftStatsDouble);
+		}
+
+		DoubleVector[][] postSplitDists = new DoubleVector[leftStatistics.length][2];
+		for (int i = 0; i < leftStatistics.length; i++) {
+			postSplitDists[i] = new DoubleVector[2];
+			postSplitDists[i][0] = leftStatistics[i];
+			postSplitDists[i][1] = rightStatistics[i];
+		}
+
+		double merit = criterion.getMeritOfSplit(preSplitStatistics, postSplitDists);
+
+		if ((currentBestOption == null) || (merit > currentBestOption.merit)) {
+			currentBestOption = new AttributeExpansionSuggestion(
+					new NumericRulePredicate(inputAttributeIndex, currentNode.cutPoint, true),
+					Utils.copy(postSplitDists), merit);
+		}
+
+		if (currentNode.right != null) {
+			currentBestOption = searchForBestSplitOption(currentNode.right, currentBestOption, criterion,
+					preSplitStatistics, inputAttributeIndex);
+		}
+		for (int i = 0; i < leftStatistics.length; i++) {
+			DoubleVector leftStatsDouble = Utils.floatToDoubleVector(currentNode.leftStatistics[i]);
+			leftStatistics[i].subtractValues(leftStatsDouble);
+			rightStatistics[i].addValues(leftStatsDouble);
+		}
+		return currentBestOption;
+	}
+
+	@Override
+	public String getPurposeString() {
+		return "Stores statistics for all output attributes for a giver input attribute.";
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+
+	}
+
+	// Inner classes inspired in FIMTDDNumericalAttributeClassObserver
+
+	protected class Node implements Serializable {
+
+		private static final long serialVersionUID = 1L;
+
+		// The split point to use
+		private float cutPoint;
+
+		// E-BST statistics
+		private SingleVector[] leftStatistics;
+		private SingleVector[] rightStatistics;
+
+		// Child nodes
+		private Node left;
+		private Node right;
+
+		public Node(float inputAttributeValue, SingleVector[] statistics) {
+			cutPoint = inputAttributeValue;
+			int numOutputAttributes = statistics.length;
+			leftStatistics = new SingleVector[numOutputAttributes];
+			for (int i = 0; i < numOutputAttributes; i++) {
+				leftStatistics[i] = statistics[i];
+			}
+			// this.leftStatistics=statistics.clone();
+
+			this.rightStatistics = new SingleVector[numOutputAttributes];
+			for (int i = 0; i < numOutputAttributes; i++)
+				this.rightStatistics[i] = new SingleVector();
+		}
+
+		public Node(double inputAttributeValue, DoubleVector[] statistics) {
+			this((float) inputAttributeValue, Utils.copyAsFloatVector(statistics));
+		}
+
+		/**
+		 * Updates tree with new observation
+		 */
+		public void observeAttribute(double inputAttributeValue, DoubleVector[] statistics) {
+			this.observeAttribute((float) inputAttributeValue, Utils.copyAsFloatVector(statistics));
+
+		}
+
+		public void observeAttribute(float inputAttributeValue, SingleVector[] statistics) {
+			if (inputAttributeValue == this.cutPoint) {
+				for (int i = 0; i < statistics.length; i++)
+					this.leftStatistics[i].addValues(statistics[i]);
+			} else if (inputAttributeValue < this.cutPoint) {
+				for (int i = 0; i < statistics.length; i++)
+					this.leftStatistics[i].addValues(statistics[i]);
+
+				if (this.left == null) {
+					if (numNodes < maxNodes) {
+						this.left = new Node(inputAttributeValue, statistics);
+						++numNodes;
+					}
+				} else {
+					this.left.observeAttribute(inputAttributeValue, statistics);
+				}
+			} else {
+				for (int i = 0; i < statistics.length; i++)
+					this.rightStatistics[i].addValues(statistics[i]);
+				if (this.right == null) {
+					if (numNodes < maxNodes) {
+						this.right = new Node(inputAttributeValue, statistics);
+						++numNodes;
+					}
+				} else {
+					this.right.observeAttribute(inputAttributeValue, statistics);
+				}
+			}
+		}
+	}
+
+}
diff --git a/moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/MultiLabelBSTreePCT.java b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/MultiLabelBSTreePCT.java
similarity index 60%
rename from moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/MultiLabelBSTreePCT.java
rename to moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/MultiLabelBSTreePCT.java
index b61d18bad..b9fc7fabe 100644
--- a/moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/MultiLabelBSTreePCT.java
+++ b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/MultiLabelBSTreePCT.java
@@ -1,25 +1,26 @@
-package moa.classifiers.mlc.core.attributeclassobservers;
+package moa.learners.predictors.core.attributeclassobservers;
 
 import java.io.Serializable;
 
 import com.github.javacliparser.IntOption;
 
-import moa.classifiers.mlc.core.splitcriteria.MultiLabelSplitCriterion;
-import moa.classifiers.mlc.core.splitcriteria.PCTWeightedICVarianceReduction;
-import moa.classifiers.rules.core.AttributeExpansionSuggestion;
-import moa.classifiers.rules.core.NumericRulePredicate;
-import moa.classifiers.rules.core.Utils;
 import moa.core.DoubleVector;
 import moa.core.ObjectRepository;
+import moa.learners.predictors.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.learners.predictors.core.splitcriteria.PCTWeightedICVarianceReduction;
+import moa.learners.predictors.rules.core.AttributeExpansionSuggestion;
+import moa.learners.predictors.rules.core.NumericRulePredicate;
+import moa.learners.predictors.rules.core.Utils;
 import moa.options.AbstractOptionHandler;
 import moa.tasks.TaskMonitor;
 
 public class MultiLabelBSTreePCT extends AbstractOptionHandler implements NumericStatisticsObserver {
 
 	/**
-	 * 
+	 *
 	 */
-	public IntOption maxNodesOption = new IntOption("maxNodesOption", 'z', "Maximum number of nodes", 2000, 0, Integer.MAX_VALUE);
+	public IntOption maxNodesOption = new IntOption("maxNodesOption", 'z', "Maximum number of nodes", 2000, 0,
+			Integer.MAX_VALUE);
 	protected int maxNodes;
 	protected int numNodes;
 
@@ -33,24 +34,24 @@ public class MultiLabelBSTreePCT extends AbstractOptionHandler implements Numeri
 	protected DoubleVector[] leftInputStatistics;
 	protected DoubleVector[] rightInputStatistics;
 
-
 	public static double roundToSignificantFigures(double num, int n) {
-		final double d = Math.ceil(Math.log10(num < 0 ? -num: num));
+		final double d = Math.ceil(Math.log10(num < 0 ? -num : num));
 		final int power = n - (int) d;
 
 		final double magnitude = Math.pow(10, power);
-		final long shifted = (long) (num*magnitude);
-		return shifted/magnitude;
+		final long shifted = (long) (num * magnitude);
+		return shifted / magnitude;
 	}
 
 	@Override
 	public void observeAttribute(double inputAttributeValue, DoubleVector[] statistics) {
-		throw new UnsupportedOperationException("This is an attribute observer used for PCTs and needs both input and output statistics.");
+		throw new UnsupportedOperationException(
+				"This is an attribute observer used for PCTs and needs both input and output statistics.");
 	}
 
-	public void observeAttribute(double inputAttributeValue, DoubleVector[] targetStatistics, DoubleVector[] inputStatistics) {
-		if (!Double.isNaN(inputAttributeValue))
-		{
+	public void observeAttribute(double inputAttributeValue, DoubleVector[] targetStatistics,
+			DoubleVector[] inputStatistics) {
+		if (!Double.isNaN(inputAttributeValue)) {
 			if (this.root == null) {
 				this.root = new Node(inputAttributeValue, targetStatistics, inputStatistics);
 				maxNodes = maxNodesOption.getValue();
@@ -61,13 +62,15 @@ public void observeAttribute(double inputAttributeValue, DoubleVector[] targetSt
 
 	}
 
-
 	@Override
-	public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(MultiLabelSplitCriterion criterion, DoubleVector[] preSplitStatistics, int inputAttributeIndex) {
-		throw new UnsupportedOperationException("This is an attribute observer used for PCTs and needs both input and output statistics.");
+	public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(MultiLabelSplitCriterion criterion,
+			DoubleVector[] preSplitStatistics, int inputAttributeIndex) {
+		throw new UnsupportedOperationException(
+				"This is an attribute observer used for PCTs and needs both input and output statistics.");
 	}
 
-	public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(MultiLabelSplitCriterion criterion, DoubleVector[] preSplitTargetStatistics, DoubleVector[] preSplitInputStatistics, int inputAttributeIndex) {
+	public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(MultiLabelSplitCriterion criterion,
+			DoubleVector[] preSplitTargetStatistics, DoubleVector[] preSplitInputStatistics, int inputAttributeIndex) {
 		// Initialize global variables
 		int numOutputs = preSplitTargetStatistics.length;
 		int numInputs = preSplitInputStatistics.length;
@@ -78,68 +81,73 @@ public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(MultiLabelSp
 		leftInputStatistics = new DoubleVector[numInputs];
 		rightInputStatistics = new DoubleVector[numInputs];
 
-		for (int i=0; i < numOutputs; i++)
-		{
-			leftTargetStatistics[i] = new DoubleVector(new double [preSplitTargetStatistics[i].numValues()]); //sets statistics to zeros
+		for (int i = 0; i < numOutputs; i++) {
+			leftTargetStatistics[i] = new DoubleVector(new double[preSplitTargetStatistics[i].numValues()]); // sets
+																												// statistics
+																												// to
+																												// zeros
 			rightTargetStatistics[i] = new DoubleVector(preSplitTargetStatistics[i]);
 		}
-		for (int i=0; i < numInputs; i++)
-		{
-			leftInputStatistics[i] = new DoubleVector(new double [preSplitInputStatistics[i].numValues()]); //sets statistics to zeros
+		for (int i = 0; i < numInputs; i++) {
+			leftInputStatistics[i] = new DoubleVector(new double[preSplitInputStatistics[i].numValues()]); // sets
+																											// statistics
+																											// to zeros
 			rightInputStatistics[i] = new DoubleVector(preSplitInputStatistics[i]);
 		}
 
-		return searchForBestSplitOption(this.root, null, criterion, preSplitTargetStatistics, preSplitInputStatistics, inputAttributeIndex);
+		return searchForBestSplitOption(this.root, null, criterion, preSplitTargetStatistics, preSplitInputStatistics,
+				inputAttributeIndex);
 	}
 
-
-	protected AttributeExpansionSuggestion searchForBestSplitOption(Node currentNode, AttributeExpansionSuggestion currentBestOption, MultiLabelSplitCriterion criterion, DoubleVector[] preSplitTargetStatistics, DoubleVector[] preSplitInputStatistics, int inputAttributeIndex) {
-		// Return null if the current node is null or we have finished looking through all the possible splits
+	protected AttributeExpansionSuggestion searchForBestSplitOption(Node currentNode,
+			AttributeExpansionSuggestion currentBestOption, MultiLabelSplitCriterion criterion,
+			DoubleVector[] preSplitTargetStatistics, DoubleVector[] preSplitInputStatistics, int inputAttributeIndex) {
+		// Return null if the current node is null or we have finished looking through
+		// all the possible splits
 		if (currentNode == null) { // TODO: JD check || countRightTotal == 0.0
 			return currentBestOption;
 		}
 
 		if (currentNode.left != null) {
-			currentBestOption = searchForBestSplitOption(currentNode.left, currentBestOption, criterion, preSplitTargetStatistics, preSplitInputStatistics, inputAttributeIndex);
+			currentBestOption = searchForBestSplitOption(currentNode.left, currentBestOption, criterion,
+					preSplitTargetStatistics, preSplitInputStatistics, inputAttributeIndex);
 		}
 
-		for (int i=0; i<leftTargetStatistics.length; i++)
-		{
+		for (int i = 0; i < leftTargetStatistics.length; i++) {
 			leftTargetStatistics[i].addValues(currentNode.targetStatistics[i]);
 			rightTargetStatistics[i].subtractValues(currentNode.targetStatistics[i]);
 		}
 
-		for (int i=0; i<leftInputStatistics.length; i++)
-		{
+		for (int i = 0; i < leftInputStatistics.length; i++) {
 			leftInputStatistics[i].addValues(currentNode.inputStatistics[i]);
 			rightInputStatistics[i].subtractValues(currentNode.inputStatistics[i]);
 		}
 
-
-		DoubleVector[][] postSplitTargetDists = new DoubleVector [leftTargetStatistics.length][2];
-		DoubleVector[][] postSplitInputDists = new DoubleVector [leftInputStatistics.length][2];
-		for (int i=0; i<leftTargetStatistics.length; i++)
-		{
+		DoubleVector[][] postSplitTargetDists = new DoubleVector[leftTargetStatistics.length][2];
+		DoubleVector[][] postSplitInputDists = new DoubleVector[leftInputStatistics.length][2];
+		for (int i = 0; i < leftTargetStatistics.length; i++) {
 			postSplitTargetDists[i] = new DoubleVector[2];
 			postSplitTargetDists[i][0] = leftTargetStatistics[i];
 			postSplitTargetDists[i][1] = rightTargetStatistics[i];
 		}
-		for (int i=0; i<leftInputStatistics.length; i++)
-		{
+		for (int i = 0; i < leftInputStatistics.length; i++) {
 			postSplitInputDists[i] = new DoubleVector[2];
 			postSplitInputDists[i][0] = leftInputStatistics[i];
 			postSplitInputDists[i][1] = rightInputStatistics[i];
 		}
 
-
-		double merit = ((PCTWeightedICVarianceReduction) criterion).getMeritOfSplit(preSplitTargetStatistics, postSplitTargetDists, preSplitInputStatistics, postSplitInputDists);
+		double merit = ((PCTWeightedICVarianceReduction) criterion).getMeritOfSplit(preSplitTargetStatistics,
+				postSplitTargetDists, preSplitInputStatistics, postSplitInputDists);
 
 		if ((!Double.isNaN(merit)) && (currentBestOption == null || (merit > currentBestOption.merit))) {
-			currentBestOption = new AttributeExpansionSuggestion(new NumericRulePredicate(inputAttributeIndex, currentNode.cutPoint, true), Utils.copy(postSplitTargetDists), merit);
+			currentBestOption = new AttributeExpansionSuggestion(
+					new NumericRulePredicate(inputAttributeIndex, currentNode.cutPoint, true),
+					Utils.copy(postSplitTargetDists), merit);
 		}
 
 		if (currentNode.right != null) {
-			currentBestOption = searchForBestSplitOption(currentNode.right, currentBestOption, criterion, preSplitTargetStatistics, preSplitInputStatistics, inputAttributeIndex);
+			currentBestOption = searchForBestSplitOption(currentNode.right, currentBestOption, criterion,
+					preSplitTargetStatistics, preSplitInputStatistics, inputAttributeIndex);
 		}
 		for (int i = 0; i < leftTargetStatistics.length; i++) {
 			leftTargetStatistics[i].subtractValues(currentNode.targetStatistics[i]);
@@ -153,26 +161,21 @@ protected AttributeExpansionSuggestion searchForBestSplitOption(Node currentNode
 		return currentBestOption;
 	}
 
-
-
-
 	@Override
 	public String getPurposeString() {
 		return "Stores statistics for all output and input attributes for a giver input attribute.";
 	}
 
 	@Override
-	public void getDescription(StringBuilder sb, int indent) {	
+	public void getDescription(StringBuilder sb, int indent) {
 	}
 
 	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
 
 	}
 
-
-	//Inner classes inspired in FIMTDDNumericalAttributeClassObserver
+	// Inner classes inspired in FIMTDDNumericalAttributeClassObserver
 
 	protected class Node implements Serializable {
 
@@ -185,7 +188,6 @@ protected class Node implements Serializable {
 		private DoubleVector[] targetStatistics;
 		private DoubleVector[] inputStatistics;
 
-
 		// Child nodes
 		private Node left;
 		private Node right;
@@ -196,26 +198,27 @@ public Node(double inputAttributeValue, DoubleVector[] targetStatistics, DoubleV
 			int numInputAttributes = inputStatistics.length;
 			this.targetStatistics = new DoubleVector[numOutputAttributes];
 			this.inputStatistics = new DoubleVector[numInputAttributes];
-			for (int i=0; i<numOutputAttributes; i++) {		
+			for (int i = 0; i < numOutputAttributes; i++) {
 				if (targetStatistics[i] != null)
-					this.targetStatistics[i]= new DoubleVector(targetStatistics[i]);
+					this.targetStatistics[i] = new DoubleVector(targetStatistics[i]);
 				else
 					this.targetStatistics[i] = new DoubleVector();
 			}
-			for (int i=0; i<numInputAttributes; i++) {					
-				this.inputStatistics[i]=new DoubleVector(inputStatistics[i]);
+			for (int i = 0; i < numInputAttributes; i++) {
+				this.inputStatistics[i] = new DoubleVector(inputStatistics[i]);
 			}
 		}
 
 		/**
 		 * Updates tree with new observation
 		 */
-		public void observeAttribute(double inputAttributeValue, DoubleVector[] targetStatistics, DoubleVector[] inputStatistics) {
+		public void observeAttribute(double inputAttributeValue, DoubleVector[] targetStatistics,
+				DoubleVector[] inputStatistics) {
 			if (inputAttributeValue == this.cutPoint) {
-				for (int i=0; i < targetStatistics.length; i++)
+				for (int i = 0; i < targetStatistics.length; i++)
 					if (targetStatistics[i] != null)
 						this.targetStatistics[i].addValues(targetStatistics[i]);
-				for (int i=0; i < inputStatistics.length; i++)
+				for (int i = 0; i < inputStatistics.length; i++)
 					this.inputStatistics[i].addValues(inputStatistics[i]);
 
 			} else if (inputAttributeValue < this.cutPoint) {
@@ -227,9 +230,9 @@ public void observeAttribute(double inputAttributeValue, DoubleVector[] targetSt
 				} else {
 					this.left.observeAttribute(inputAttributeValue, targetStatistics, inputStatistics);
 				}
-			} else { 
+			} else {
 				if (this.right == null) {
-					if(numNodes < maxNodes){
+					if (numNodes < maxNodes) {
 						this.right = new Node(inputAttributeValue, targetStatistics, inputStatistics);
 						numNodes++;
 					}
@@ -240,5 +243,4 @@ public void observeAttribute(double inputAttributeValue, DoubleVector[] targetSt
 		}
 	}
 
-
 }
diff --git a/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/MultiLabelNominalAttributeObserver.java b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/MultiLabelNominalAttributeObserver.java
new file mode 100644
index 000000000..778f5a1d6
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/MultiLabelNominalAttributeObserver.java
@@ -0,0 +1,101 @@
+package moa.learners.predictors.core.attributeclassobservers;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map.Entry;
+
+import com.github.javacliparser.FlagOption;
+
+import moa.core.DoubleVector;
+import moa.core.ObjectRepository;
+import moa.learners.predictors.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.learners.predictors.rules.core.AttributeExpansionSuggestion;
+import moa.learners.predictors.rules.core.NominalRulePredicate;
+import moa.learners.predictors.rules.core.Utils;
+import moa.options.AbstractOptionHandler;
+import moa.tasks.TaskMonitor;
+
+public class MultiLabelNominalAttributeObserver extends AbstractOptionHandler implements NominalStatisticsObserver {
+
+	/**
+	 *
+	 */
+	protected FlagOption addUndeclaredValuesOption = new FlagOption("addUndeclaredValues", 'a',
+			"Add to the domain values not declared? If false, the value is not used.");
+	protected HashMap<Integer, DoubleVector[]> statisticsByNominalValue;
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public void observeAttribute(double inputAttributeValue, DoubleVector[] observedStatistics) {
+		if (statisticsByNominalValue == null) {
+			statisticsByNominalValue = new HashMap<>();
+		}
+		DoubleVector[] current = statisticsByNominalValue.get((int) inputAttributeValue);
+		if (current == null)
+			current = copyOfStatistics(observedStatistics);
+		else
+			addStatistics(current, observedStatistics);
+
+		statisticsByNominalValue.put((int) inputAttributeValue, current);
+
+	}
+
+	@Override
+	public AttributeExpansionSuggestion getBestEvaluatedSplitSuggestion(MultiLabelSplitCriterion criterion,
+			DoubleVector[] preSplitStatistics, int inputAttributeIndex) {
+
+		double bestSuggestionMerit = Double.MIN_VALUE;
+		AttributeExpansionSuggestion bestSuggestiong = null;
+
+		Iterator<Entry<Integer, DoubleVector[]>> it = statisticsByNominalValue.entrySet().iterator();
+		while (it.hasNext()) {
+			Entry<Integer, DoubleVector[]> pair = it.next();
+			int splitValue = pair.getKey();
+			DoubleVector[] statistics = pair.getValue();
+
+			DoubleVector[][] resultingStatistics = new DoubleVector[statistics.length][2];
+			for (int i = 0; i < statistics.length; i++) {
+				resultingStatistics[i] = new DoubleVector[2];
+				resultingStatistics[i][0] = statistics[i];
+				resultingStatistics[i][1] = new DoubleVector(preSplitStatistics[i]);
+				resultingStatistics[i][1].subtractValues(statistics[i]);
+			}
+
+			double merit = criterion.getMeritOfSplit(preSplitStatistics, resultingStatistics);
+			if (merit > bestSuggestionMerit) {
+				bestSuggestionMerit = merit;
+				bestSuggestiong = new AttributeExpansionSuggestion(
+						new NominalRulePredicate(inputAttributeIndex, splitValue, true),
+						Utils.copy(resultingStatistics), merit);
+			}
+		}
+
+		return bestSuggestiong;
+	}
+
+	private void addStatistics(DoubleVector[] current, DoubleVector[] observedStatistics) {
+		for (int i = 0; i < current.length; i++) {
+			current[i].addValues(observedStatistics[i]);
+		}
+	}
+
+	private DoubleVector[] copyOfStatistics(DoubleVector[] statistics) {
+		DoubleVector[] copy = new DoubleVector[statistics.length];
+		for (int i = 0; i < statistics.length; i++) {
+			copy[i] = new DoubleVector(statistics[i]);
+		}
+		return copy;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/NominalAttributeClassObserver.java b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/NominalAttributeClassObserver.java
new file mode 100644
index 000000000..d9d454554
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/NominalAttributeClassObserver.java
@@ -0,0 +1,166 @@
+/*
+ *    NominalAttributeClassObserver.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.core.attributeclassobservers;
+
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.ObjectRepository;
+import moa.core.Utils;
+import moa.learners.predictors.core.AttributeSplitSuggestion;
+import moa.learners.predictors.core.conditionaltests.NominalAttributeBinaryTest;
+import moa.learners.predictors.core.conditionaltests.NominalAttributeMultiwayTest;
+import moa.learners.predictors.core.splitcriteria.SplitCriterion;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Class for observing the class data distribution for a nominal attribute. This
+ * observer monitors the class distribution of a given attribute. Used in naive
+ * Bayes and decision trees to monitor data statistics on leaves.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public class NominalAttributeClassObserver extends AbstractAttributeClassObserver
+		implements DiscreteAttributeClassObserver {
+
+	private static final long serialVersionUID = 1L;
+
+	protected double totalWeightObserved = 0.0;
+
+	protected double missingWeightObserved = 0.0;
+
+	public AutoExpandVector<DoubleVector> attValDistPerClass = new AutoExpandVector<>();
+
+	@Override
+	public void observeAttributeClass(double attVal, int classVal, double weight) {
+		if (Utils.isMissingValue(attVal)) {
+			this.missingWeightObserved += weight;
+		} else {
+			int attValInt = (int) attVal;
+			DoubleVector valDist = this.attValDistPerClass.get(classVal);
+			if (valDist == null) {
+				valDist = new DoubleVector();
+				this.attValDistPerClass.set(classVal, valDist);
+			}
+			valDist.addToValue(attValInt, weight);
+		}
+		this.totalWeightObserved += weight;
+	}
+
+	@Override
+	public double probabilityOfAttributeValueGivenClass(double attVal, int classVal) {
+		DoubleVector obs = this.attValDistPerClass.get(classVal);
+		return obs != null ? (obs.getValue((int) attVal) + 1.0) / (obs.sumOfValues() + obs.numValues()) : 0.0;
+	}
+
+	public double totalWeightOfClassObservations() {
+		return this.totalWeightObserved;
+	}
+
+	public double weightOfObservedMissingValues() {
+		return this.missingWeightObserved;
+	}
+
+	@Override
+	public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(SplitCriterion criterion, double[] preSplitDist,
+			int attIndex, boolean binaryOnly) {
+		AttributeSplitSuggestion bestSuggestion = null;
+		int maxAttValsObserved = getMaxAttValsObserved();
+		if (!binaryOnly) {
+			double[][] postSplitDists = getClassDistsResultingFromMultiwaySplit(maxAttValsObserved);
+			double merit = criterion.getMeritOfSplit(preSplitDist, postSplitDists);
+			bestSuggestion = new AttributeSplitSuggestion(new NominalAttributeMultiwayTest(attIndex), postSplitDists,
+					merit);
+		}
+		for (int valIndex = 0; valIndex < maxAttValsObserved; valIndex++) {
+			double[][] postSplitDists = getClassDistsResultingFromBinarySplit(valIndex);
+			double merit = criterion.getMeritOfSplit(preSplitDist, postSplitDists);
+			if ((bestSuggestion == null) || (merit > bestSuggestion.merit)) {
+				bestSuggestion = new AttributeSplitSuggestion(new NominalAttributeBinaryTest(attIndex, valIndex),
+						postSplitDists, merit);
+			}
+		}
+		return bestSuggestion;
+	}
+
+	public int getMaxAttValsObserved() {
+		int maxAttValsObserved = 0;
+		for (DoubleVector attValDist : this.attValDistPerClass) {
+			if ((attValDist != null) && (attValDist.numValues() > maxAttValsObserved)) {
+				maxAttValsObserved = attValDist.numValues();
+			}
+		}
+		return maxAttValsObserved;
+	}
+
+	public double[][] getClassDistsResultingFromMultiwaySplit(int maxAttValsObserved) {
+		DoubleVector[] resultingDists = new DoubleVector[maxAttValsObserved];
+		for (int i = 0; i < resultingDists.length; i++) {
+			resultingDists[i] = new DoubleVector();
+		}
+		for (int i = 0; i < this.attValDistPerClass.size(); i++) {
+			DoubleVector attValDist = this.attValDistPerClass.get(i);
+			if (attValDist != null) {
+				for (int j = 0; j < attValDist.numValues(); j++) {
+					resultingDists[j].addToValue(i, attValDist.getValue(j));
+				}
+			}
+		}
+		double[][] distributions = new double[maxAttValsObserved][];
+		for (int i = 0; i < distributions.length; i++) {
+			distributions[i] = resultingDists[i].getArrayRef();
+		}
+		return distributions;
+	}
+
+	public double[][] getClassDistsResultingFromBinarySplit(int valIndex) {
+		DoubleVector equalsDist = new DoubleVector();
+		DoubleVector notEqualDist = new DoubleVector();
+		for (int i = 0; i < this.attValDistPerClass.size(); i++) {
+			DoubleVector attValDist = this.attValDistPerClass.get(i);
+			if (attValDist != null) {
+				for (int j = 0; j < attValDist.numValues(); j++) {
+					if (j == valIndex) {
+						equalsDist.addToValue(i, attValDist.getValue(j));
+					} else {
+						notEqualDist.addToValue(i, attValDist.getValue(j));
+					}
+				}
+			}
+		}
+		return new double[][] { equalsDist.getArrayRef(), notEqualDist.getArrayRef() };
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public void observeAttributeTarget(double attVal, double target) {
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+}
diff --git a/moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/NominalStatisticsObserver.java b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/NominalStatisticsObserver.java
similarity index 57%
rename from moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/NominalStatisticsObserver.java
rename to moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/NominalStatisticsObserver.java
index 4a403bad9..c477d8022 100644
--- a/moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/NominalStatisticsObserver.java
+++ b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/NominalStatisticsObserver.java
@@ -1,5 +1,4 @@
-package moa.classifiers.mlc.core.attributeclassobservers;
-
+package moa.learners.predictors.core.attributeclassobservers;
 
 public interface NominalStatisticsObserver extends AttributeStatisticsObserver {
 
diff --git a/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/NullAttributeClassObserver.java b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/NullAttributeClassObserver.java
new file mode 100644
index 000000000..a3e9bc8fe
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/NullAttributeClassObserver.java
@@ -0,0 +1,76 @@
+/*
+ *    NullAttributeClassObserver.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.core.attributeclassobservers;
+
+import moa.core.ObjectRepository;
+import moa.learners.predictors.core.AttributeSplitSuggestion;
+import moa.learners.predictors.core.splitcriteria.SplitCriterion;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Class for observing the class data distribution for a null attribute. This
+ * method is used to disable the observation for an attribute. Used in decision
+ * trees to monitor data statistics on leaves.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public class NullAttributeClassObserver extends AbstractAttributeClassObserver implements AttributeClassObserver {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public void observeAttributeClass(double attVal, int classVal, double weight) {
+	}
+
+	@Override
+	public double probabilityOfAttributeValueGivenClass(double attVal, int classVal) {
+		return 0.0;
+	}
+
+	public double totalWeightOfClassObservations() {
+		return 0.0;
+	}
+
+	public double weightOfObservedMissingValues() {
+		return 0.0;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(SplitCriterion criterion, double[] preSplitDist,
+			int attIndex, boolean binaryOnly) {
+		return null;
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public void observeAttributeTarget(double attVal, double target) {
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/NumericAttributeClassObserver.java b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/NumericAttributeClassObserver.java
similarity index 86%
rename from moa/src/main/java/moa/classifiers/core/attributeclassobservers/NumericAttributeClassObserver.java
rename to moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/NumericAttributeClassObserver.java
index e2834285b..36d877d95 100644
--- a/moa/src/main/java/moa/classifiers/core/attributeclassobservers/NumericAttributeClassObserver.java
+++ b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/NumericAttributeClassObserver.java
@@ -15,19 +15,18 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.classifiers.core.attributeclassobservers;
+package moa.learners.predictors.core.attributeclassobservers;
 
 /**
  * Interface for observing the class data distribution for a numeric attribute.
- * This observer monitors the class distribution of a given attribute.
- * Used in naive Bayes and decision trees to monitor data statistics on leaves.
+ * This observer monitors the class distribution of a given attribute. Used in
+ * naive Bayes and decision trees to monitor data statistics on leaves.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $ 
+ * @version $Revision: 7 $
  */
 public interface NumericAttributeClassObserver extends AttributeClassObserver {
 
-   
 }
diff --git a/moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/NumericStatisticsObserver.java b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/NumericStatisticsObserver.java
similarity index 57%
rename from moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/NumericStatisticsObserver.java
rename to moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/NumericStatisticsObserver.java
index a7c067175..c6e6aeb7a 100644
--- a/moa/src/main/java/moa/classifiers/mlc/core/attributeclassobservers/NumericStatisticsObserver.java
+++ b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/NumericStatisticsObserver.java
@@ -1,5 +1,4 @@
-package moa.classifiers.mlc.core.attributeclassobservers;
-
+package moa.learners.predictors.core.attributeclassobservers;
 
 public interface NumericStatisticsObserver extends AttributeStatisticsObserver {
 
diff --git a/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/SingleVector.java b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/SingleVector.java
new file mode 100644
index 000000000..76bf95a68
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/SingleVector.java
@@ -0,0 +1,202 @@
+/*
+ *    DoubleVector.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.core.attributeclassobservers;
+
+import com.github.javacliparser.StringUtils;
+
+import moa.AbstractMOAObject;
+
+/**
+ * Vector of float numbers with some utilities.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public class SingleVector extends AbstractMOAObject {
+
+	private static final long serialVersionUID = 1L;
+
+	protected float[] array;
+
+	public SingleVector() {
+		this.array = new float[0];
+	}
+
+	public SingleVector(float[] toCopy) {
+		this.array = new float[toCopy.length];
+		System.arraycopy(toCopy, 0, this.array, 0, toCopy.length);
+	}
+
+	public SingleVector(SingleVector toCopy) {
+		this(toCopy.getArrayRef());
+	}
+
+	public SingleVector(double[] arrayRef) {
+		this.array = new float[arrayRef.length];
+		for (int i = 0; i < arrayRef.length; i++)
+			this.array[i] = (float) arrayRef[i];
+	}
+
+	public int numValues() {
+		return this.array.length;
+	}
+
+	public void setValue(int i, float v) {
+		if (i >= this.array.length) {
+			setArrayLength(i + 1);
+		}
+		this.array[i] = v;
+	}
+
+	public void addToValue(int i, float v) {
+		if (i >= this.array.length) {
+			setArrayLength(i + 1);
+		}
+		this.array[i] += v;
+	}
+
+	public void addValues(SingleVector toAdd) {
+		addValues(toAdd.getArrayRef());
+	}
+
+	public void addValues(float[] toAdd) {
+		if (toAdd.length > this.array.length) {
+			setArrayLength(toAdd.length);
+		}
+		for (int i = 0; i < toAdd.length; i++) {
+			this.array[i] += toAdd[i];
+		}
+	}
+
+	public void subtractValues(SingleVector toSubtract) {
+		subtractValues(toSubtract.getArrayRef());
+	}
+
+	public void subtractValues(float[] toSubtract) {
+		if (toSubtract.length > this.array.length) {
+			setArrayLength(toSubtract.length);
+		}
+		for (int i = 0; i < toSubtract.length; i++) {
+			this.array[i] -= toSubtract[i];
+		}
+	}
+
+	public void addToValues(float toAdd) {
+		for (int i = 0; i < this.array.length; i++) {
+			this.array[i] = this.array[i] + toAdd;
+		}
+	}
+
+	public void scaleValues(float multiplier) {
+		for (int i = 0; i < this.array.length; i++) {
+			this.array[i] = this.array[i] * multiplier;
+		}
+	}
+
+	// returns 0.0 for values outside of range
+	public float getValue(int i) {
+		return ((i >= 0) && (i < this.array.length)) ? this.array[i] : 0.0f;
+	}
+
+	public float sumOfValues() {
+		float sum = 0.0f;
+		for (float element : this.array) {
+			sum += element;
+		}
+		return sum;
+	}
+
+	public int maxIndex() {
+		int max = -1;
+		for (int i = 0; i < this.array.length; i++) {
+			if ((max < 0) || (this.array[i] > this.array[max])) {
+				max = i;
+			}
+		}
+		return max;
+	}
+
+	public void normalize() {
+		scaleValues(1.0f / sumOfValues());
+	}
+
+	public int numNonZeroEntries() {
+		int count = 0;
+		for (float element : this.array) {
+			if (element != 0.0) {
+				count++;
+			}
+		}
+		return count;
+	}
+
+	public float minWeight() {
+		if (this.array.length > 0) {
+			float min = this.array[0];
+			for (int i = 1; i < this.array.length; i++) {
+				if (this.array[i] < min) {
+					min = this.array[i];
+				}
+			}
+			return min;
+		}
+		return 0.0f;
+	}
+
+	public float[] getArrayCopy() {
+		float[] aCopy = new float[this.array.length];
+		System.arraycopy(this.array, 0, aCopy, 0, this.array.length);
+		return aCopy;
+	}
+
+	public float[] getArrayRef() {
+		return this.array;
+	}
+
+	protected void setArrayLength(int l) {
+		float[] newArray = new float[l];
+		int numToCopy = this.array.length;
+		if (numToCopy > l) {
+			numToCopy = l;
+		}
+		System.arraycopy(this.array, 0, newArray, 0, numToCopy);
+		this.array = newArray;
+	}
+
+	public void getSingleLineDescription(StringBuilder out) {
+		getSingleLineDescription(out, numValues());
+	}
+
+	public void getSingleLineDescription(StringBuilder out, int numValues) {
+		out.append("{");
+		for (int i = 0; i < numValues; i++) {
+			if (i > 0) {
+				out.append("|");
+			}
+			out.append(StringUtils.doubleToString(getValue(i), 3));
+		}
+		out.append("}");
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		getSingleLineDescription(sb);
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/VFMLNumericAttributeClassObserver.java b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/VFMLNumericAttributeClassObserver.java
new file mode 100644
index 000000000..827e04941
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/attributeclassobservers/VFMLNumericAttributeClassObserver.java
@@ -0,0 +1,212 @@
+/*
+ *    VFMLNumericAttributeClassObserver.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.core.attributeclassobservers;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+
+import com.github.javacliparser.IntOption;
+
+import moa.core.DoubleVector;
+import moa.core.ObjectRepository;
+import moa.core.Utils;
+import moa.learners.predictors.core.AttributeSplitSuggestion;
+import moa.learners.predictors.core.conditionaltests.NumericAttributeBinaryTest;
+import moa.learners.predictors.core.splitcriteria.SplitCriterion;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Class for observing the class data distribution for a numeric attribute as in
+ * VFML. Used in naive Bayes and decision trees to monitor data statistics on
+ * leaves.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public class VFMLNumericAttributeClassObserver extends AbstractAttributeClassObserver
+		implements NumericAttributeClassObserver {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public void observeAttributeTarget(double attVal, double target) {
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	protected class Bin implements Serializable {
+
+		private static final long serialVersionUID = 1L;
+
+		public double lowerBound, upperBound;
+
+		public DoubleVector classWeights = new DoubleVector();
+
+		public int boundaryClass;
+
+		public double boundaryWeight;
+	}
+
+	protected List<Bin> binList = new ArrayList<>();
+
+	public IntOption numBinsOption = new IntOption("numBins", 'n', "The number of bins.", 10, 1, Integer.MAX_VALUE);
+
+	@Override
+	public void observeAttributeClass(double attVal, int classVal, double weight) {
+		if (Utils.isMissingValue(attVal)) {
+		} else {
+			if (this.binList.size() < 1) {
+				// create the first bin
+				Bin newBin = new Bin();
+				newBin.classWeights.addToValue(classVal, weight);
+				newBin.boundaryClass = classVal;
+				newBin.boundaryWeight = weight;
+				newBin.upperBound = attVal;
+				newBin.lowerBound = attVal;
+				this.binList.add(newBin);
+			} else {
+				// find bin containing new example with binary search
+				int index = -1;
+				boolean found = false;
+				int min = 0;
+				int max = this.binList.size() - 1;
+				index = 0;
+				while ((min <= max) && !found) {
+					int i = (min + max) / 2;
+					Bin bin = this.binList.get(i);
+					if (((attVal >= bin.lowerBound) && (attVal < bin.upperBound)) || ((i == this.binList.size() - 1)
+							&& (attVal >= bin.lowerBound) && (attVal <= bin.upperBound))) {
+						found = true;
+						index = i;
+					} else if (attVal < bin.lowerBound) {
+						max = i - 1;
+					} else {
+						min = i + 1;
+					}
+				}
+				boolean first = false;
+				boolean last = false;
+				if (!found) {
+					// determine if it is before or after the existing range
+					Bin bin = this.binList.get(0);
+					if (bin.lowerBound > attVal) {
+						// go before the first bin
+						index = 0;
+						first = true;
+					} else {
+						// if we haven't found it yet value must be > last bins
+						// upperBound
+						index = this.binList.size() - 1;
+						last = true;
+					}
+				}
+				Bin bin = this.binList.get(index); // VLIndex(ct->bins, index);
+				if ((bin.lowerBound == attVal) || (this.binList.size() >= this.numBinsOption.getValue())) {// Option.getValue())
+					// {//1000)
+					// {
+					// if this is the exact same boundary and class as the bin
+					// boundary or we aren't adding new bins any more then
+					// increment
+					// boundary counts
+					bin.classWeights.addToValue(classVal, weight);
+					if ((bin.boundaryClass == classVal) && (bin.lowerBound == attVal)) {
+						// if it is also the same class then special case it
+						bin.boundaryWeight += weight;
+					}
+				} else {
+					// create a new bin
+					Bin newBin = new Bin();
+					newBin.classWeights.addToValue(classVal, weight);
+					newBin.boundaryWeight = weight;
+					newBin.boundaryClass = classVal;
+					newBin.upperBound = bin.upperBound;
+					newBin.lowerBound = attVal;
+
+					double percent = 0.0;
+					// estimate initial counts with a linear interpolation
+					if (!((bin.upperBound - bin.lowerBound == 0) || last || first)) {
+						percent = 1.0 - ((attVal - bin.lowerBound) / (bin.upperBound - bin.lowerBound));
+					}
+
+					// take out the boundry points, they stay with the old bin
+					bin.classWeights.addToValue(bin.boundaryClass, -bin.boundaryWeight);
+					DoubleVector weightToShift = new DoubleVector(bin.classWeights);
+					weightToShift.scaleValues(percent);
+					newBin.classWeights.addValues(weightToShift);
+					bin.classWeights.subtractValues(weightToShift);
+					// put the boundry examples back in
+					bin.classWeights.addToValue(bin.boundaryClass, bin.boundaryWeight);
+
+					// insert the new bin in the right place
+					if (last) {
+						bin.upperBound = attVal;
+						newBin.upperBound = attVal;
+						this.binList.add(newBin);
+					} else if (first) {
+						newBin.upperBound = bin.lowerBound;
+						this.binList.add(0, newBin);
+					} else {
+						newBin.upperBound = bin.upperBound;
+						bin.upperBound = attVal;
+						this.binList.add(index + 1, newBin);
+					}
+				}
+			}
+		}
+	}
+
+	@Override
+	public double probabilityOfAttributeValueGivenClass(double attVal, int classVal) {
+		// TODO: NaiveBayes broken until implemented
+		return 0.0;
+	}
+
+	@Override
+	public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(SplitCriterion criterion, double[] preSplitDist,
+			int attIndex, boolean binaryOnly) {
+		AttributeSplitSuggestion bestSuggestion = null;
+		DoubleVector rightDist = new DoubleVector();
+		for (Bin bin : this.binList) {
+			rightDist.addValues(bin.classWeights);
+		}
+		DoubleVector leftDist = new DoubleVector();
+		for (Bin bin : this.binList) {
+			leftDist.addValues(bin.classWeights);
+			rightDist.subtractValues(bin.classWeights);
+			double[][] postSplitDists = new double[][] { leftDist.getArrayCopy(), rightDist.getArrayCopy() };
+			double merit = criterion.getMeritOfSplit(preSplitDist, postSplitDists);
+			if ((bestSuggestion == null) || (merit > bestSuggestion.merit)) {
+				bestSuggestion = new AttributeSplitSuggestion(
+						new NumericAttributeBinaryTest(attIndex, bin.upperBound, false), postSplitDists, merit);
+			}
+		}
+		return bestSuggestion;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// TODO Auto-generated method stub
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/core/conditionaltests/InstanceConditionalBinaryTest.java b/moa/src/main/java/moa/learners/predictors/core/conditionaltests/InstanceConditionalBinaryTest.java
similarity index 87%
rename from moa/src/main/java/moa/classifiers/core/conditionaltests/InstanceConditionalBinaryTest.java
rename to moa/src/main/java/moa/learners/predictors/core/conditionaltests/InstanceConditionalBinaryTest.java
index a37291d95..c54ee26ee 100644
--- a/moa/src/main/java/moa/classifiers/core/conditionaltests/InstanceConditionalBinaryTest.java
+++ b/moa/src/main/java/moa/learners/predictors/core/conditionaltests/InstanceConditionalBinaryTest.java
@@ -15,20 +15,21 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.classifiers.core.conditionaltests;
+package moa.learners.predictors.core.conditionaltests;
 
 /**
- * Abstract binary conditional test for instances to use to split nodes in Hoeffding trees.
+ * Abstract binary conditional test for instances to use to split nodes in
+ * Hoeffding trees.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
 public abstract class InstanceConditionalBinaryTest extends InstanceConditionalTest {
 
-    @Override
-    public int maxBranches() {
-        return 2;
-    }
+	@Override
+	public int maxBranches() {
+		return 2;
+	}
 }
diff --git a/moa/src/main/java/moa/learners/predictors/core/conditionaltests/InstanceConditionalTest.java b/moa/src/main/java/moa/learners/predictors/core/conditionaltests/InstanceConditionalTest.java
new file mode 100644
index 000000000..5a3220797
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/conditionaltests/InstanceConditionalTest.java
@@ -0,0 +1,77 @@
+/*
+ *    InstanceConditionalTest.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.core.conditionaltests;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
+import moa.AbstractMOAObject;
+
+/**
+ * Abstract conditional test for instances to use to split nodes in Hoeffding
+ * trees.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public abstract class InstanceConditionalTest extends AbstractMOAObject {
+
+	/**
+	 * Returns the number of the branch for an instance, -1 if unknown.
+	 *
+	 * @param inst the instance to be used
+	 * @return the number of the branch for an instance, -1 if unknown.
+	 */
+	public abstract int branchForInstance(Instance inst);
+
+	/**
+	 * Gets whether the number of the branch for an instance is known.
+	 *
+	 * @param inst
+	 * @return true if the number of the branch for an instance is known
+	 */
+	public boolean resultKnownForInstance(Instance inst) {
+		return branchForInstance(inst) >= 0;
+	}
+
+	/**
+	 * Gets the number of maximum branches, -1 if unknown.
+	 *
+	 * @return the number of maximum branches, -1 if unknown..
+	 */
+	public abstract int maxBranches();
+
+	/**
+	 * Gets the text that describes the condition of a branch. It is used to
+	 * describe the branch.
+	 *
+	 * @param branch  the number of the branch to describe
+	 * @param context the context or header of the data stream
+	 * @return the text that describes the condition of the branch
+	 */
+	public abstract String describeConditionForBranch(int branch, InstancesHeader context);
+
+	/**
+	 * Returns an array with the attributes that the test depends on.
+	 *
+	 * @return an array with the attributes that the test depends on
+	 */
+	public abstract int[] getAttsTestDependsOn();
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/conditionaltests/NominalAttributeBinaryTest.java b/moa/src/main/java/moa/learners/predictors/core/conditionaltests/NominalAttributeBinaryTest.java
new file mode 100644
index 000000000..8ea50526f
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/conditionaltests/NominalAttributeBinaryTest.java
@@ -0,0 +1,69 @@
+/*
+ *    NominalAttributeBinaryTest.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.core.conditionaltests;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
+/**
+ * Nominal binary conditional test for instances to use to split nodes in
+ * Hoeffding trees.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public class NominalAttributeBinaryTest extends InstanceConditionalBinaryTest {
+
+	private static final long serialVersionUID = 1L;
+
+	protected int attIndex;
+
+	protected int attValue;
+
+	public NominalAttributeBinaryTest(int attIndex, int attValue) {
+		this.attIndex = attIndex;
+		this.attValue = attValue;
+	}
+
+	@Override
+	public int branchForInstance(Instance inst) {
+		int instAttIndex = this.attIndex < inst.classIndex() ? this.attIndex : this.attIndex + 1;
+		return inst.isMissing(instAttIndex) ? -1 : ((int) inst.value(instAttIndex) == this.attValue ? 0 : 1);
+	}
+
+	@Override
+	public String describeConditionForBranch(int branch, InstancesHeader context) {
+		if ((branch == 0) || (branch == 1)) {
+			return InstancesHeader.getInputAttributeNameString(context, this.attIndex) + (branch == 0 ? " = " : " != ")
+					+ InstancesHeader.getNominalValueString(context, this.attIndex, this.attValue);
+		}
+		throw new IndexOutOfBoundsException();
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public int[] getAttsTestDependsOn() {
+		return new int[] { this.attIndex };
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeMultiwayTest.java b/moa/src/main/java/moa/learners/predictors/core/conditionaltests/NominalAttributeMultiwayTest.java
similarity index 51%
rename from moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeMultiwayTest.java
rename to moa/src/main/java/moa/learners/predictors/core/conditionaltests/NominalAttributeMultiwayTest.java
index eb1135ef1..146dcb338 100644
--- a/moa/src/main/java/moa/classifiers/core/conditionaltests/NominalAttributeMultiwayTest.java
+++ b/moa/src/main/java/moa/learners/predictors/core/conditionaltests/NominalAttributeMultiwayTest.java
@@ -15,56 +15,55 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.classifiers.core.conditionaltests;
+package moa.learners.predictors.core.conditionaltests;
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
- * Nominal multi way conditional test for instances to use to split nodes in Hoeffding trees.
+ * Nominal multi way conditional test for instances to use to split nodes in
+ * Hoeffding trees.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
 public class NominalAttributeMultiwayTest extends InstanceConditionalTest {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    protected int attIndex;
+	protected int attIndex;
 
-    public NominalAttributeMultiwayTest(int attIndex) {
-        this.attIndex = attIndex;
-    }
+	public NominalAttributeMultiwayTest(int attIndex) {
+		this.attIndex = attIndex;
+	}
 
-    @Override
-    public int branchForInstance(Instance inst) {
-        int instAttIndex = this.attIndex  ; //< inst.classIndex() ? this.attIndex
-                //: this.attIndex + 1;
-        return inst.isMissing(instAttIndex) ? -1 : (int) inst.value(instAttIndex);
-    }
+	@Override
+	public int branchForInstance(Instance inst) {
+		int instAttIndex = this.attIndex; // < inst.classIndex() ? this.attIndex
+		// : this.attIndex + 1;
+		return inst.isMissing(instAttIndex) ? -1 : (int) inst.value(instAttIndex);
+	}
 
-    @Override
-    public String describeConditionForBranch(int branch, InstancesHeader context) {
-        return InstancesHeader.getAttributeNameString(context, this.attIndex)
-                + " = "
-                + InstancesHeader.getNominalValueString(context, this.attIndex,
-                branch);
-    }
+	@Override
+	public String describeConditionForBranch(int branch, InstancesHeader context) {
+		return InstancesHeader.getAttributeNameString(context, this.attIndex) + " = "
+				+ InstancesHeader.getNominalValueString(context, this.attIndex, branch);
+	}
 
-    @Override
-    public int maxBranches() {
-        return -1;
-    }
+	@Override
+	public int maxBranches() {
+		return -1;
+	}
 
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
 
-    @Override
-    public int[] getAttsTestDependsOn() {
-        return new int[]{this.attIndex};
-    }
+	@Override
+	public int[] getAttsTestDependsOn() {
+		return new int[] { this.attIndex };
+	}
 }
diff --git a/moa/src/main/java/moa/learners/predictors/core/conditionaltests/NumericAttributeBinaryTest.java b/moa/src/main/java/moa/learners/predictors/core/conditionaltests/NumericAttributeBinaryTest.java
new file mode 100644
index 000000000..7d1943008
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/conditionaltests/NumericAttributeBinaryTest.java
@@ -0,0 +1,88 @@
+/*
+ *    NumericAttributeBinaryTest.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.core.conditionaltests;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
+/**
+ * Numeric binary conditional test for instances to use to split nodes in
+ * Hoeffding trees.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public class NumericAttributeBinaryTest extends InstanceConditionalBinaryTest {
+
+	private static final long serialVersionUID = 1L;
+
+	protected int attIndex;
+
+	protected double attValue;
+
+	protected boolean equalsPassesTest;
+
+	public NumericAttributeBinaryTest(int attIndex, double attValue, boolean equalsPassesTest) {
+		this.attIndex = attIndex;
+		this.attValue = attValue;
+		this.equalsPassesTest = equalsPassesTest;
+	}
+
+	@Override
+	public int branchForInstance(Instance inst) {
+		int instAttIndex = this.attIndex; // < inst.classIndex() ? this.attIndex
+		// : this.attIndex + 1;
+		if (inst.isMissing(instAttIndex)) {
+			return -1;
+		}
+		double v = inst.valueInputAttribute(instAttIndex); // if the attIndex is not calculated above this is the
+															// correct method call
+		if (v == this.attValue) {
+			return this.equalsPassesTest ? 0 : 1;
+		}
+		return v < this.attValue ? 0 : 1;
+	}
+
+	@Override
+	public String describeConditionForBranch(int branch, InstancesHeader context) {
+		if ((branch == 0) || (branch == 1)) {
+			char compareChar = branch == 0 ? '<' : '>';
+			int equalsBranch = this.equalsPassesTest ? 0 : 1;
+			return InstancesHeader.getInputAttributeNameString(context, this.attIndex) + ' ' + compareChar
+					+ (branch == equalsBranch ? "= " : " ")
+					+ InstancesHeader.getNumericValueString(context, this.attIndex, this.attValue);
+		}
+		throw new IndexOutOfBoundsException();
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public int[] getAttsTestDependsOn() {
+		return new int[] { this.attIndex };
+	}
+
+	public double getSplitValue() {
+		return this.attValue;
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/driftdetection/ADWIN.java b/moa/src/main/java/moa/learners/predictors/core/driftdetection/ADWIN.java
new file mode 100644
index 000000000..2747ec775
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/driftdetection/ADWIN.java
@@ -0,0 +1,597 @@
+/*
+ *    ADWIN.java
+ *    Copyright (C) 2008 UPC-Barcelona Tech, Catalonia
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.core.driftdetection;
+
+import moa.AbstractMOAObject;
+
+/**
+ * ADaptive sliding WINdow method. This method is a change detector and
+ * estimator. It keeps a variable-length window of recently seen items, with the
+ * property that the window has the maximal length statistically consistent with
+ * the hypothesis "there has been no change in the average value inside the
+ * window".
+ *
+ *
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @version $Revision: 7 $
+ */
+public class ADWIN extends AbstractMOAObject {
+
+	private class List extends AbstractMOAObject {
+
+		protected int count;
+
+		protected ListItem head;
+
+		protected ListItem tail;
+
+		public List() {
+//			post: initializes the list to be empty.
+			clear();
+			addToHead();
+		}
+
+		/* Interface Store Methods */
+		public int size() {
+			// post: returns the number of elements in the list.
+			return this.count;
+		}
+
+		public ListItem head() {
+			// post: returns the number of elements in the list.
+			return this.head;
+		}
+
+		public ListItem tail() {
+			// post: returns the number of elements in the list.
+			return this.tail;
+		}
+
+		public boolean isEmpty() {
+			// post: returns the true iff store is empty.
+			return (this.size() == 0);
+		}
+
+		public void clear() {
+			// post: clears the list so that it contains no elements.
+			this.head = null;
+			this.tail = null;
+			this.count = 0;
+		}
+
+		/* Interface List Methods */
+		public void addToHead() {
+			// pre: anObject is non-null
+			// post: the object is added to the beginning of the list
+			this.head = new ListItem(this.head, null);
+			if (this.tail == null) {
+				this.tail = this.head;
+			}
+			this.count++;
+		}
+
+		public void removeFromHead() {
+			// pre: list is not empty
+			// post: removes and returns first object from the list
+//			ListItem temp;
+//			temp = this.head;
+			this.head = this.head.next();
+			if (this.head != null) {
+				this.head.setPrevious(null);
+			} else {
+				this.tail = null;
+			}
+			this.count--;
+			// temp=null;
+			return;
+		}
+
+		public void addToTail() {
+//			pre: anObject is non-null
+//			post: the object is added at the end of the list
+			this.tail = new ListItem(null, this.tail);
+			if (this.head == null) {
+				this.head = this.tail;
+			}
+			this.count++;
+		}
+
+		public void removeFromTail() {
+//			pre: list is not empty
+//			post: the last object in the list is removed and returned
+//			ListItem temp;
+//			temp = this.tail;
+			this.tail = this.tail.previous();
+			if (this.tail == null) {
+				this.head = null;
+			} else {
+				this.tail.setNext(null);
+			}
+			this.count--;
+			// temp=null;
+			return;
+		}
+
+		@Override
+		public void getDescription(StringBuilder sb, int indent) {
+		}
+	}
+
+	private class ListItem extends AbstractMOAObject {
+//		protected Object data;
+
+		protected ListItem next;
+
+		protected ListItem previous;
+
+		protected int bucketSizeRow = 0;
+
+		protected int MAXBUCKETS = ADWIN.MAXBUCKETS;
+
+		protected double bucketTotal[] = new double[MAXBUCKETS + 1];
+
+		protected double bucketVariance[] = new double[MAXBUCKETS + 1];
+
+		public ListItem() {
+//			post: initializes the node to be a tail node
+//			containing the given value.
+			this(null, null);
+		}
+
+		public void clear() {
+			bucketSizeRow = 0;
+			for (int k = 0; k <= MAXBUCKETS; k++) {
+				clearBucket(k);
+			}
+		}
+
+		private void clearBucket(int k) {
+			setTotal(0, k);
+			setVariance(0, k);
+		}
+
+		public ListItem(ListItem nextNode, ListItem previousNode) {
+//			post: initializes the node to contain the given
+//			object and link to the given next node.
+			// this.data = element;
+			this.next = nextNode;
+			this.previous = previousNode;
+			if (nextNode != null) {
+				nextNode.previous = this;
+			}
+			if (previousNode != null) {
+				previousNode.next = this;
+			}
+			clear();
+		}
+
+		public void insertBucket(double Value, double Variance) {
+//			insert a Bucket at the end
+			int k = bucketSizeRow;
+			bucketSizeRow++;
+			// Insert new bucket
+			setTotal(Value, k);
+			setVariance(Variance, k);
+		}
+
+		public void RemoveBucket() {
+//			Removes the first Buvket
+			compressBucketsRow(1);
+		}
+
+		public void compressBucketsRow(int NumberItemsDeleted) {
+			// Delete first elements
+			for (int k = NumberItemsDeleted; k <= MAXBUCKETS; k++) {
+				bucketTotal[k - NumberItemsDeleted] = bucketTotal[k];
+				bucketVariance[k - NumberItemsDeleted] = bucketVariance[k];
+			}
+			for (int k = 1; k <= NumberItemsDeleted; k++) {
+				clearBucket(MAXBUCKETS - k + 1);
+			}
+			bucketSizeRow -= NumberItemsDeleted;
+			// BucketNumber-=NumberItemsDeleted;
+		}
+
+		public ListItem previous() {
+//			post: returns the previous node.
+			return this.previous;
+		}
+
+		public void setPrevious(ListItem previous) {
+//			post: sets the previous node to be the given node
+			this.previous = previous;
+		}
+
+		public ListItem next() {
+//			post: returns the next node.
+			return this.next;
+		}
+
+		public void setNext(ListItem next) {
+//			post: sets the next node to be the given node
+			this.next = next;
+		}
+
+		public double Total(int k) {
+//			post: returns the element in this node
+			return bucketTotal[k];
+		}
+
+		public double Variance(int k) {
+//			post: returns the element in this node
+			return bucketVariance[k];
+		}
+
+		public void setTotal(double value, int k) {
+//			post: sets the element in this node to the given
+//			object.
+			bucketTotal[k] = value;
+		}
+
+		public void setVariance(double value, int k) {
+//			post: sets the element in this node to the given
+//			object.
+			bucketVariance[k] = value;
+		}
+		/*
+		 * public ListItem(Object element, ListItem nextNode){ // post: initializes the
+		 * node to contain the given // object and link to the given next node.
+		 * this.data = element; this.next = nextNode; } public ListItem(Object element)
+		 * { // post: initializes the node to be a tail node // containing the given
+		 * value. this(element, null); }
+		 * 
+		 * 
+		 * public Object value() { // post: returns the element in this node return
+		 * this.data; } public void setValue(Object anObject) { // post: sets the
+		 * element in this node to the given // object. this.data = anObject; }
+		 */
+
+		@Override
+		public void getDescription(StringBuilder sb, int indent) {
+		}
+	}
+
+	public static final double DELTA = .002; // .1;
+
+	private static final int mintMinimLongitudWindow = 10; // 10
+
+	private double mdbldelta = .002; // .1;
+
+	private int mintTime = 0;
+
+	private int mintClock = 32;
+
+	private double mdblWidth = 0; // Mean of Width = mdblWidth/Number of items
+	// BUCKET
+
+	public static final int MAXBUCKETS = 5;
+
+	private int lastBucketRow = 0;
+
+	private double TOTAL = 0;
+
+	private double VARIANCE = 0;
+
+	private int WIDTH = 0;
+
+	private int BucketNumber = 0;
+
+	private int Detect = 0;
+
+	private int numberDetections = 0;
+
+	private int DetectTwice = 0;
+
+	private boolean blnBucketDeleted = false;
+
+	private int BucketNumberMAX = 0;
+
+	private int mintMinWinLength = 5;
+
+	private List listRowBuckets;
+
+	public boolean getChange() {
+		return blnBucketDeleted;
+	}
+
+	public void resetChange() {
+		blnBucketDeleted = false;
+	}
+
+	public int getBucketsUsed() {
+		return BucketNumberMAX;
+	}
+
+	public int getWidth() {
+		return WIDTH;
+	}
+
+	public void setClock(int intClock) {
+		mintClock = intClock;
+	}
+
+	public int getClock() {
+		return mintClock;
+	}
+
+	public boolean getWarning() {
+		return false;
+	}
+
+	public boolean getDetect() {
+		return (Detect == mintTime);
+	}
+
+	public int getNumberDetections() {
+		return numberDetections;
+	}
+
+	public double getTotal() {
+		return TOTAL;
+	}
+
+	public double getEstimation() {
+		return TOTAL / WIDTH;
+	}
+
+	public double getVariance() {
+		return VARIANCE / WIDTH;
+	}
+
+	public double getWidthT() {
+		return mdblWidth;
+	}
+
+	private void initBuckets() {
+		// Init buckets
+		listRowBuckets = new List();
+		lastBucketRow = 0;
+		TOTAL = 0;
+		VARIANCE = 0;
+		WIDTH = 0;
+		BucketNumber = 0;
+	}
+
+	private void insertElement(double Value) {
+		WIDTH++;
+		insertElementBucket(0, Value, listRowBuckets.head());
+		double incVariance = 0;
+		if (WIDTH > 1) {
+			incVariance = (WIDTH - 1) * (Value - TOTAL / (WIDTH - 1)) * (Value - TOTAL / (WIDTH - 1)) / WIDTH;
+		}
+		VARIANCE += incVariance;
+		TOTAL += Value;
+		compressBuckets();
+	}
+
+	private void insertElementBucket(double Variance, double Value, ListItem Node) {
+		// Insert new bucket
+		Node.insertBucket(Value, Variance);
+		BucketNumber++;
+		if (BucketNumber > BucketNumberMAX) {
+			BucketNumberMAX = BucketNumber;
+		}
+	}
+
+	private int bucketSize(int Row) {
+		return (int) Math.pow(2, Row);
+	}
+
+	public int deleteElement() {
+		// LIST
+		// Update statistics
+		ListItem Node;
+		Node = listRowBuckets.tail();
+		int n1 = bucketSize(lastBucketRow);
+		WIDTH -= n1;
+		TOTAL -= Node.Total(0);
+		double u1 = Node.Total(0) / n1;
+		double incVariance = Node.Variance(0) + n1 * WIDTH * (u1 - TOTAL / WIDTH) * (u1 - TOTAL / WIDTH) / (n1 + WIDTH);
+		VARIANCE -= incVariance;
+
+		// Delete Bucket
+		Node.RemoveBucket();
+		BucketNumber--;
+		if (Node.bucketSizeRow == 0) {
+			listRowBuckets.removeFromTail();
+			lastBucketRow--;
+		}
+		return n1;
+	}
+
+	public void compressBuckets() {
+		// Traverse the list of buckets in increasing order
+		int n1, n2;
+		double u2, u1, incVariance;
+		ListItem cursor;
+		ListItem nextNode;
+		cursor = listRowBuckets.head();
+		int i = 0;
+		do {
+			// Find the number of buckets in a row
+			int k = cursor.bucketSizeRow;
+			// If the row is full, merge buckets
+			if (k == MAXBUCKETS + 1) {
+				nextNode = cursor.next();
+				if (nextNode == null) {
+					listRowBuckets.addToTail();
+					nextNode = cursor.next();
+					lastBucketRow++;
+				}
+				n1 = bucketSize(i);
+				n2 = bucketSize(i);
+				u1 = cursor.Total(0) / n1;
+				u2 = cursor.Total(1) / n2;
+				incVariance = n1 * n2 * (u1 - u2) * (u1 - u2) / (n1 + n2);
+
+				nextNode.insertBucket(cursor.Total(0) + cursor.Total(1),
+						cursor.Variance(0) + cursor.Variance(1) + incVariance);
+				BucketNumber++;
+				cursor.compressBucketsRow(2);
+				if (nextNode.bucketSizeRow <= MAXBUCKETS) {
+					break;
+				}
+			} else {
+				break;
+			}
+			cursor = cursor.next();
+			i++;
+		} while (cursor != null);
+	}
+
+	public boolean setInput(double intEntrada) {
+		return setInput(intEntrada, mdbldelta);
+	}
+
+	public boolean setInput(double intEntrada, double delta) {
+		boolean blnChange = false;
+		boolean blnExit = false;
+		ListItem cursor;
+		mintTime++;
+
+		// 1,2)Increment window in one element
+		insertElement(intEntrada);
+		blnBucketDeleted = false;
+		// 3)Reduce window
+		if (mintTime % mintClock == 0 && getWidth() > mintMinimLongitudWindow) {
+			boolean blnReduceWidth = true; // Diference
+
+			while (blnReduceWidth) // Diference
+			{
+				blnReduceWidth = false; // Diference
+				blnExit = false;
+				int n0 = 0;
+				int n1 = WIDTH;
+				double u0 = 0;
+				double u1 = getTotal();
+				double v0 = 0;
+				double v1 = VARIANCE;
+				double n2 = 0;
+				double u2 = 0;
+
+				cursor = listRowBuckets.tail();
+				int i = lastBucketRow;
+				do {
+					for (int k = 0; k <= (cursor.bucketSizeRow - 1); k++) {
+						n2 = bucketSize(i);
+						u2 = cursor.Total(k);
+						if (n0 > 0) {
+							v0 += cursor.Variance(k) + n0 * n2 * (u0 / n0 - u2 / n2) * (u0 / n0 - u2 / n2) / (n0 + n2);
+						}
+						if (n1 > 0) {
+							v1 -= cursor.Variance(k) + n1 * n2 * (u1 / n1 - u2 / n2) * (u1 / n1 - u2 / n2) / (n1 + n2);
+						}
+
+						n0 += bucketSize(i);
+						n1 -= bucketSize(i);
+						u0 += cursor.Total(k);
+						u1 -= cursor.Total(k);
+
+						if (i == 0 && k == cursor.bucketSizeRow - 1) {
+							blnExit = true;
+							break;
+						}
+						double absvalue = u0 / n0 - (u1 / n1); // n1<WIDTH-mintMinWinLength-1
+						if ((n1 > mintMinWinLength + 1 && n0 > mintMinWinLength + 1) && // Diference NEGATIVE
+						// if(
+								blnCutexpression(n0, n1, u0, u1, v0, v1, absvalue, delta)) {
+							blnBucketDeleted = true;
+							Detect = mintTime;
+
+							if (Detect == 0) {
+								Detect = mintTime;
+								// blnFirst=true;
+								// blnWarning=true;
+							} else if (DetectTwice == 0) {
+								DetectTwice = mintTime;
+								// blnDetect=true;
+							}
+							blnReduceWidth = true; // Diference
+							blnChange = true;
+							if (getWidth() > 0) { // Reduce width of the window
+								// while (n0>0) // Diference NEGATIVE
+								n0 -= deleteElement();
+								blnExit = true;
+								break;
+							}
+						} // End if
+					} // Next k
+					cursor = cursor.previous();
+					i--;
+				} while (((!blnExit && cursor != null)));
+			} // End While // Diference
+		} // End if
+
+		mdblWidth += getWidth();
+		if (blnChange) {
+			numberDetections++;
+		}
+		return blnChange;
+	}
+
+	private boolean blnCutexpression(int n0, int n1, double u0, double u1, double v0, double v1, double absvalue,
+			double delta) {
+		int n = getWidth();
+		double dd = Math.log(2 * Math.log(n) / delta); // -- ull perque el ln n va al numerador.
+		// Formula Gener 2008
+		double v = getVariance();
+		double m = ((double) 1 / ((n0 - mintMinWinLength + 1))) + ((double) 1 / ((n1 - mintMinWinLength + 1)));
+		double epsilon = Math.sqrt(2 * m * v * dd) + (double) 2 / 3 * dd * m;
+
+		return (Math.abs(absvalue) > epsilon);
+	}
+
+	public ADWIN() {
+		mdbldelta = DELTA;
+		initBuckets();
+		Detect = 0;
+		numberDetections = 0;
+		DetectTwice = 0;
+
+	}
+
+	public ADWIN(double d) {
+		mdbldelta = d;
+		initBuckets();
+		Detect = 0;
+		numberDetections = 0;
+		DetectTwice = 0;
+	}
+
+	public ADWIN(int cl) {
+		mdbldelta = DELTA;
+		initBuckets();
+		Detect = 0;
+		numberDetections = 0;
+		DetectTwice = 0;
+		mintClock = cl;
+	}
+
+	public String getEstimatorInfo() {
+		return "ADWIN;;";
+	}
+
+	public void setW(int W0) {
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/core/driftdetection/ADWINChangeDetector.java b/moa/src/main/java/moa/learners/predictors/core/driftdetection/ADWINChangeDetector.java
similarity index 56%
rename from moa/src/main/java/moa/classifiers/core/driftdetection/ADWINChangeDetector.java
rename to moa/src/main/java/moa/learners/predictors/core/driftdetection/ADWINChangeDetector.java
index 62c0fdae7..8d29b6cdb 100644
--- a/moa/src/main/java/moa/classifiers/core/driftdetection/ADWINChangeDetector.java
+++ b/moa/src/main/java/moa/learners/predictors/core/driftdetection/ADWINChangeDetector.java
@@ -16,7 +16,7 @@
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
-package moa.classifiers.core.driftdetection;
+package moa.learners.predictors.core.driftdetection;
 
 import com.github.javacliparser.FloatOption;
 
@@ -36,41 +36,40 @@
  */
 public class ADWINChangeDetector extends AbstractChangeDetector {
 
-    protected ADWIN adwin;
+	protected ADWIN adwin;
 
-    public FloatOption deltaAdwinOption = new FloatOption("deltaAdwin", 'a',
-            "Delta of Adwin change detection", 0.002, 0.0, 1.0);
+	public FloatOption deltaAdwinOption = new FloatOption("deltaAdwin", 'a', "Delta of Adwin change detection", 0.002,
+			0.0, 1.0);
 
-    @Override
-    public void input(double inputValue) {
-        if (this.adwin == null) {
-            resetLearning();
-        }
-        double ErrEstim = this.adwin.getEstimation();
-        if(adwin.setInput(inputValue)) {
-            if (this.adwin.getEstimation() > ErrEstim) {
-                this.isChangeDetected = true;
-            }
-        }
-        this.isWarningZone = false;
-        this.delay = 0.0;
-        this.estimation = adwin.getEstimation();
-    }
+	@Override
+	public void input(double inputValue) {
+		if (this.adwin == null) {
+			resetLearning();
+		}
+		double ErrEstim = this.adwin.getEstimation();
+		if (adwin.setInput(inputValue)) {
+			if (this.adwin.getEstimation() > ErrEstim) {
+				this.isChangeDetected = true;
+			}
+		}
+		this.isWarningZone = false;
+		this.delay = 0.0;
+		this.estimation = adwin.getEstimation();
+	}
 
-    @Override
-    public void resetLearning() {
-        adwin = new ADWIN((double) this.deltaAdwinOption.getValue());
-        super.resetLearning();
-    }
+	@Override
+	public void resetLearning() {
+		adwin = new ADWIN(this.deltaAdwinOption.getValue());
+		super.resetLearning();
+	}
 
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
 
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        // TODO Auto-generated method stub
-    }
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// TODO Auto-generated method stub
+	}
 }
diff --git a/moa/src/main/java/moa/learners/predictors/core/driftdetection/AbstractChangeDetector.java b/moa/src/main/java/moa/learners/predictors/core/driftdetection/AbstractChangeDetector.java
new file mode 100644
index 000000000..f0c4ea6a5
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/driftdetection/AbstractChangeDetector.java
@@ -0,0 +1,153 @@
+/*
+ *    AbstractChangeDetector.java
+ *    Copyright (C) 2011 University of Waikato, Hamilton, New Zealand
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package moa.learners.predictors.core.driftdetection;
+
+import moa.options.AbstractOptionHandler;
+
+/**
+ * Abstract Change Detector. All change detectors in MOA extend this class.
+ *
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @version $Revision: 7 $
+ */
+public abstract class AbstractChangeDetector extends AbstractOptionHandler implements ChangeDetector {
+
+	/**
+	 * Change was detected
+	 */
+	protected boolean isChangeDetected;
+
+	/**
+	 * Warning Zone: after a warning and before a change
+	 */
+	protected boolean isWarningZone;
+
+	/**
+	 * Prediction for the next value based in previous seen values
+	 */
+	protected double estimation;
+
+	/**
+	 * Delay in detecting change
+	 */
+	protected double delay;
+
+	/**
+	 * The change detector has been initialized with the option values
+	 */
+	protected boolean isInitialized;
+
+	/**
+	 * Resets this change detector. It must be similar to starting a new change
+	 * detector from scratch.
+	 *
+	 */
+	@Override
+	public void resetLearning() {
+		this.isChangeDetected = false;
+		this.isWarningZone = false;
+		this.estimation = 0.0;
+		this.delay = 0.0;
+		this.isInitialized = false;
+	}
+
+	/**
+	 * Adding a numeric value to the change detector<br>
+	 * <br>
+	 *
+	 * The output of the change detector is modified after the insertion of a new
+	 * item inside.
+	 *
+	 * @param inputValue the number to insert into the change detector
+	 */
+	@Override
+	public abstract void input(double inputValue);
+
+	/**
+	 * Gets whether there is change detected.
+	 *
+	 * @return true if there is change
+	 */
+	@Override
+	public boolean getChange() {
+		return this.isChangeDetected;
+	}
+
+	/**
+	 * Gets whether the change detector is in the warning zone, after a warning
+	 * alert and before a change alert.
+	 *
+	 * @return true if the change detector is in the warning zone
+	 */
+	@Override
+	public boolean getWarningZone() {
+		return this.isWarningZone;
+	}
+
+	/**
+	 * Gets the prediction of next values.
+	 *
+	 * @return a prediction of the next value
+	 */
+	@Override
+	public double getEstimation() {
+		return this.estimation;
+	}
+
+	/**
+	 * Gets the length of the delay in the change detected.
+	 *
+	 * @return he length of the delay in the change detected
+	 */
+	@Override
+	public double getDelay() {
+		return this.delay;
+	}
+
+	/**
+	 * Gets the output state of the change detection.
+	 *
+	 * @return an array with the number of change detections, number of warnings,
+	 *         delay, and estimation.
+	 */
+	@Override
+	public double[] getOutput() {
+		double[] res = { this.isChangeDetected ? 1 : 0, this.isWarningZone ? 1 : 0, this.delay, this.estimation };
+		return res;
+	}
+
+	/**
+	 * Returns a string representation of the model.
+	 *
+	 * @param out    the stringbuilder to add the description
+	 * @param indent the number of characters to indent
+	 */
+	@Override
+	public abstract void getDescription(StringBuilder sb, int indent);
+
+	/**
+	 * Produces a copy of this change detector method
+	 *
+	 * @return the copy of this change detector method
+	 */
+	@Override
+	public ChangeDetector copy() {
+		return (ChangeDetector) super.copy();
+	}
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/learners/predictors/core/driftdetection/ChangeDetector.java b/moa/src/main/java/moa/learners/predictors/core/driftdetection/ChangeDetector.java
new file mode 100644
index 000000000..f64b97fac
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/driftdetection/ChangeDetector.java
@@ -0,0 +1,102 @@
+/*
+ *    ChangeDetector.java
+ *    Copyright (C) 2011 University of Waikato, Hamilton, New Zealand
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package moa.learners.predictors.core.driftdetection;
+
+import moa.options.OptionHandler;
+
+/**
+ * Change Detector interface to implement methods that detects change.
+ *
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @version $Revision: 7 $
+ */
+public interface ChangeDetector extends OptionHandler {
+
+	/**
+	 * Resets this change detector. It must be similar to starting a new change
+	 * detector from scratch.
+	 *
+	 */
+	void resetLearning();
+
+	/**
+	 * Adding a numeric value to the change detector<br>
+	 * <br>
+	 *
+	 * The output of the change detector is modified after the insertion of a new
+	 * item inside.
+	 *
+	 * @param inputValue the number to insert into the change detector
+	 */
+	void input(double inputValue);
+
+	/**
+	 * Gets whether there is change detected.
+	 *
+	 * @return true if there is change
+	 */
+	boolean getChange();
+
+	/**
+	 * Gets whether the change detector is in the warning zone, after a warning
+	 * alert and before a change alert.
+	 *
+	 * @return true if the change detector is in the warning zone
+	 */
+	boolean getWarningZone();
+
+	/**
+	 * Gets the prediction of next values.
+	 *
+	 * @return a prediction of the next value
+	 */
+	double getEstimation();
+
+	/**
+	 * Gets the length of the delay in the change detected.
+	 *
+	 * @return he length of the delay in the change detected
+	 */
+	double getDelay();
+
+	/**
+	 * Gets the output state of the change detection.
+	 *
+	 * @return an array with the number of change detections, number of warnings,
+	 *         delay, and estimation.
+	 */
+	double[] getOutput();
+
+	/**
+	 * Returns a string representation of the model.
+	 *
+	 * @param out    the stringbuilder to add the description
+	 * @param indent the number of characters to indent
+	 */
+	@Override
+	void getDescription(StringBuilder sb, int indent);
+
+	/**
+	 * Produces a copy of this drift detection method
+	 *
+	 * @return the copy of this drift detection method
+	 */
+	@Override
+	ChangeDetector copy();
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/learners/predictors/core/driftdetection/CusumDM.java b/moa/src/main/java/moa/learners/predictors/core/driftdetection/CusumDM.java
new file mode 100644
index 000000000..0ba4d1f13
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/driftdetection/CusumDM.java
@@ -0,0 +1,107 @@
+/*
+ *    DDM.java
+ *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
+ *    @author Manuel Baena (mbaena@lcc.uma.es)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package moa.learners.predictors.core.driftdetection;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+
+import moa.core.ObjectRepository;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Drift detection method based in Cusum
+ *
+ *
+ * @author Manuel Baena (mbaena@lcc.uma.es)
+ * @version $Revision: 7 $
+ */
+public class CusumDM extends AbstractChangeDetector {
+
+	private static final long serialVersionUID = -3518369648142099719L;
+
+	public IntOption minNumInstancesOption = new IntOption("minNumInstances", 'n',
+			"The minimum number of instances before permitting detecting change.", 30, 0, Integer.MAX_VALUE);
+
+	public FloatOption deltaOption = new FloatOption("delta", 'd', "Delta parameter of the Cusum Test", 0.005, 0.0,
+			1.0);
+
+	public FloatOption lambdaOption = new FloatOption("lambda", 'l', "Threshold parameter of the Cusum Test", 50, 0.0,
+			Float.MAX_VALUE);
+
+	private int m_n;
+
+	private double sum;
+
+	private double x_mean;
+
+	private double delta;
+
+	private double lambda;
+
+	public CusumDM() {
+		resetLearning();
+	}
+
+	@Override
+	public void resetLearning() {
+		m_n = 1;
+		x_mean = 0.0;
+		sum = 0.0;
+		delta = this.deltaOption.getValue();
+		lambda = this.lambdaOption.getValue();
+	}
+
+	@Override
+	public void input(double x) {
+		// It monitors the error rate
+		if (this.isChangeDetected == true || this.isInitialized == false) {
+			resetLearning();
+			this.isInitialized = true;
+		}
+
+		x_mean = x_mean + (x - x_mean) / m_n;
+		sum = Math.max(0, sum + x - x_mean - this.delta);
+
+		m_n++;
+
+		// System.out.print(prediction + " " + m_n + " " + (m_p+m_s) + " ");
+		this.estimation = x_mean;
+		this.isChangeDetected = false;
+		this.isWarningZone = false;
+		this.delay = 0;
+
+		if (m_n < this.minNumInstancesOption.getValue()) {
+			return;
+		}
+
+		if (sum > this.lambda) {
+			this.isChangeDetected = true;
+		}
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// TODO Auto-generated method stub
+	}
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/learners/predictors/core/driftdetection/DDM.java b/moa/src/main/java/moa/learners/predictors/core/driftdetection/DDM.java
new file mode 100644
index 000000000..3f1f8a528
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/driftdetection/DDM.java
@@ -0,0 +1,137 @@
+/*
+ *    DDM.java
+ *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
+ *    @author Manuel Baena (mbaena@lcc.uma.es)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package moa.learners.predictors.core.driftdetection;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+
+import moa.core.ObjectRepository;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Drift detection method based in DDM method of Joao Gama SBIA 2004.
+ *
+ * <p>
+ * João Gama, Pedro Medas, Gladys Castillo, Pedro Pereira Rodrigues: Learning
+ * with Drift Detection. SBIA 2004: 286-295
+ * </p>
+ *
+ * @author Manuel Baena (mbaena@lcc.uma.es)
+ * @version $Revision: 7 $
+ */
+public class DDM extends AbstractChangeDetector {
+
+	private static final long serialVersionUID = -3518369648142099719L;
+
+	// private static final int DDM_MINNUMINST = 30;
+	public IntOption minNumInstancesOption = new IntOption("minNumInstances", 'n',
+			"The minimum number of instances before permitting detecting change.", 30, 0, Integer.MAX_VALUE);
+
+	public FloatOption warningLevelOption = new FloatOption("warningLevel", 'w', "Warning Level.", 2.0, 1.0, 4.0);
+
+	public FloatOption outcontrolLevelOption = new FloatOption("outcontrolLevel", 'o', "Outcontrol Level.", 3.0, 1.0,
+			5.0);
+
+	private int m_n;
+
+	private int minNumInstances;
+
+	private double m_p;
+
+	private double m_s;
+
+	private double m_psmin;
+
+	private double m_pmin;
+
+	private double m_smin;
+
+	private double warningLevel;
+
+	private double outcontrolLevel;
+
+	public DDM() {
+		resetLearning();
+	}
+
+	@Override
+	public void resetLearning() {
+		m_n = 1;
+		m_p = 1;
+		m_s = 0;
+		m_psmin = Double.MAX_VALUE;
+		m_pmin = Double.MAX_VALUE;
+		m_smin = Double.MAX_VALUE;
+		minNumInstances = this.minNumInstancesOption.getValue();
+		warningLevel = this.warningLevelOption.getValue();
+		outcontrolLevel = this.outcontrolLevelOption.getValue();
+	}
+
+	@Override
+	public void input(double prediction) {
+		// prediction must be 1 or 0
+		// It monitors the error rate
+		if (this.isChangeDetected == true || this.isInitialized == false) {
+			resetLearning();
+			this.isInitialized = true;
+		}
+		m_p = m_p + (prediction - m_p) / m_n;
+		m_s = Math.sqrt(m_p * (1 - m_p) / m_n);
+
+		m_n++;
+
+		// System.out.print(prediction + " " + m_n + " " + (m_p+m_s) + " ");
+		this.estimation = m_p;
+		this.isChangeDetected = false;
+		this.isWarningZone = false;
+		this.delay = 0;
+
+		if (m_n < minNumInstances) {
+			return;
+		}
+
+		if (m_p + m_s <= m_psmin) {
+			m_pmin = m_p;
+			m_smin = m_s;
+			m_psmin = m_p + m_s;
+		}
+
+		if (m_n > minNumInstances && m_p + m_s > m_pmin + outcontrolLevel * m_smin) {
+			// System.out.println(m_p + ",D");
+			this.isChangeDetected = true;
+			// resetLearning();
+		} else if (m_p + m_s > m_pmin + warningLevel * m_smin) {
+			// System.out.println(m_p + ",W");
+			this.isWarningZone = true;
+		} else {
+			this.isWarningZone = false;
+			// System.out.println(m_p + ",N");
+		}
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// TODO Auto-generated method stub
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/driftdetection/EDDM.java b/moa/src/main/java/moa/learners/predictors/core/driftdetection/EDDM.java
new file mode 100644
index 000000000..9d2e183b8
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/driftdetection/EDDM.java
@@ -0,0 +1,158 @@
+/*
+ *    EDDM.java
+ *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
+ *    @author Manuel Baena (mbaena@lcc.uma.es)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package moa.learners.predictors.core.driftdetection;
+
+import moa.core.ObjectRepository;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Drift detection method based in EDDM method of Manuel Baena et al.
+ *
+ * <p>
+ * Early Drift Detection Method. Manuel Baena-Garcia, Jose Del Campo-Avila, Raúl
+ * Fidalgo, Albert Bifet, Ricard Gavalda, Rafael Morales-Bueno. In Fourth
+ * International Workshop on Knowledge Discovery from Data Streams, 2006.
+ * </p>
+ *
+ * @author Manuel Baena (mbaena@lcc.uma.es)
+ * @version $Revision: 7 $
+ */
+public class EDDM extends AbstractChangeDetector {
+
+	/**
+	 *
+	 */
+	private static final long serialVersionUID = 140980267062162000L;
+
+	private static final double FDDM_OUTCONTROL = 0.9;
+
+	private static final double FDDM_WARNING = 0.95;
+
+	private static final double FDDM_MINNUMINSTANCES = 30;
+
+	private double m_numErrors;
+
+	private int m_minNumErrors = 30;
+
+	private int m_n;
+
+	private int m_d;
+
+	private int m_lastd;
+
+	private double m_mean;
+
+	private double m_stdTemp;
+
+	private double m_m2smax;
+
+	// private int m_lastLevel;
+
+	public EDDM() {
+		resetLearning();
+	}
+
+	@Override
+	public void resetLearning() {
+		m_n = 1;
+		m_numErrors = 0;
+		m_d = 0;
+		m_lastd = 0;
+		m_mean = 0.0;
+		m_stdTemp = 0.0;
+		m_m2smax = 0.0;
+		// m_lastLevel = DDM_INCONTROL_LEVEL;
+		this.estimation = 0.0;
+	}
+
+	@Override
+	public void input(double prediction) {
+		// prediction must be 1 or 0
+		// It monitors the error rate
+		// System.out.print(prediction + " " + m_n + " " + probability + " ");
+		if (this.isChangeDetected == true || this.isInitialized == false) {
+			resetLearning();
+			this.isInitialized = true;
+		}
+
+		this.isChangeDetected = false;
+
+		m_n++;
+		if (prediction == 1.0) {
+			this.isWarningZone = false;
+			this.delay = 0;
+			m_numErrors += 1;
+			m_lastd = m_d;
+			m_d = m_n - 1;
+			int distance = m_d - m_lastd;
+			double oldmean = m_mean;
+			m_mean = m_mean + (distance - m_mean) / m_numErrors;
+			this.estimation = m_mean;
+			m_stdTemp = m_stdTemp + (distance - m_mean) * (distance - oldmean);
+			double std = Math.sqrt(m_stdTemp / m_numErrors);
+			double m2s = m_mean + 2 * std;
+
+			// System.out.print(m_numErrors + " " + m_mean + " " + std + " " +
+			// m2s + " " + m_m2smax + " ");
+
+			if (m2s > m_m2smax) {
+				if (m_n > FDDM_MINNUMINSTANCES) {
+					m_m2smax = m2s;
+				}
+				// m_lastLevel = DDM_INCONTROL_LEVEL;
+				// System.out.print(1 + " ");
+			} else {
+				double p = m2s / m_m2smax;
+				// System.out.print(p + " ");
+				if (m_n > FDDM_MINNUMINSTANCES && m_numErrors > m_minNumErrors && p < FDDM_OUTCONTROL) {
+					// System.out.println(m_mean + ",D");
+					this.isChangeDetected = true;
+					// resetLearning();
+					// return DDM_OUTCONTROL_LEVEL;
+				} else if (m_n > FDDM_MINNUMINSTANCES && m_numErrors > m_minNumErrors && p < FDDM_WARNING) {
+					// System.out.println(m_mean + ",W");
+					// m_lastLevel = DDM_WARNING_LEVEL;
+					this.isWarningZone = true;
+					// return DDM_WARNING_LEVEL;
+				} else {
+					this.isWarningZone = false;
+					// System.out.println(m_mean + ",N");
+					// m_lastLevel = DDM_INCONTROL_LEVEL;
+					// return DDM_INCONTROL_LEVEL;
+				}
+			}
+		} else {
+			// System.out.print(m_numErrors + " " + m_mean + " " +
+			// Math.sqrt(m_stdTemp/m_numErrors) + " " + (m_mean +
+			// 2*Math.sqrt(m_stdTemp/m_numErrors)) + " " + m_m2smax + " ");
+			// System.out.print(((m_mean +
+			// 2*Math.sqrt(m_stdTemp/m_numErrors))/m_m2smax) + " ");
+		}
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// TODO Auto-generated method stub
+	}
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/learners/predictors/core/driftdetection/EWMAChartDM.java b/moa/src/main/java/moa/learners/predictors/core/driftdetection/EWMAChartDM.java
new file mode 100644
index 000000000..950c549c0
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/driftdetection/EWMAChartDM.java
@@ -0,0 +1,130 @@
+/*
+ *    EWMAChartDM.java
+ *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
+ *    @author Manuel Baena (mbaena@lcc.uma.es)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package moa.learners.predictors.core.driftdetection;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+
+import moa.core.ObjectRepository;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Drift detection method based in EWMA Charts of Ross, Adams, Tasoulis and Hand
+ * 2012
+ *
+ *
+ * @author Manuel Baena (mbaena@lcc.uma.es)
+ * @version $Revision: 7 $
+ */
+public class EWMAChartDM extends AbstractChangeDetector {
+
+	private static final long serialVersionUID = -3518369648142099719L;
+
+	// private static final int DDM_MINNUMINST = 30;
+	public IntOption minNumInstancesOption = new IntOption("minNumInstances", 'n',
+			"The minimum number of instances before permitting detecting change.", 30, 0, Integer.MAX_VALUE);
+
+	public FloatOption lambdaOption = new FloatOption("lambda", 'l', "Lambda parameter of the EWMA Chart Method", 0.2,
+			0.0, Float.MAX_VALUE);
+
+	private double m_n;
+
+	private double m_sum;
+
+	private double m_p;
+
+	private double m_s;
+
+	private double lambda;
+
+	private double z_t;
+
+	public EWMAChartDM() {
+		resetLearning();
+	}
+
+	@Override
+	public void resetLearning() {
+		m_n = 1.0;
+		m_sum = 0.0;
+		m_p = 0.0;
+		m_s = 0.0;
+		z_t = 0.0;
+		lambda = this.lambdaOption.getValue();
+	}
+
+	@Override
+	public void input(double prediction) {
+		// prediction must be 1 or 0
+		// It monitors the error rate
+		if (this.isChangeDetected == true || this.isInitialized == false) {
+			resetLearning();
+			this.isInitialized = true;
+		}
+
+		m_sum += prediction;
+
+		m_p = m_sum / m_n; // m_p + (prediction - m_p) / (double) (m_n+1);
+
+		m_s = Math.sqrt(m_p * (1.0 - m_p) * lambda * (1.0 - Math.pow(1.0 - lambda, 2.0 * m_n)) / (2.0 - lambda));
+
+		m_n++;
+
+		z_t += lambda * (prediction - z_t);
+
+		// double L_t = 2.76 - 6.23 * m_p + 18.12 * Math.pow(m_p, 3) - 312.45 *
+		// Math.pow(m_p, 5) + 1002.18 * Math.pow(m_p, 7); //%1 FP
+		double L_t = 3.97 - 6.56 * m_p + 48.73 * Math.pow(m_p, 3) - 330.13 * Math.pow(m_p, 5)
+				+ 848.18 * Math.pow(m_p, 7); // %1 FP
+		// double L_t = 1.17 + 7.56 * m_p - 21.24 * Math.pow(m_p, 3) + 112.12 *
+		// Math.pow(m_p, 5) - 987.23 * Math.pow(m_p, 7); //%1 FP
+
+		// System.out.print(prediction + " " + m_n + " " + (m_p+m_s) + " ");
+		this.estimation = m_p;
+		this.isChangeDetected = false;
+		this.isWarningZone = false;
+		this.delay = 0;
+
+		if (m_n < this.minNumInstancesOption.getValue()) {
+			return;
+		}
+
+		if (m_n > this.minNumInstancesOption.getValue() && z_t > m_p + L_t * m_s) {
+			// System.out.println(m_p + ",D");
+			this.isChangeDetected = true;
+			// resetLearning();
+		} else if (z_t > m_p + 0.5 * L_t * m_s) {
+			// System.out.println(m_p + ",W");
+			this.isWarningZone = true;
+		} else {
+			this.isWarningZone = false;
+			// System.out.println(m_p + ",N");
+		}
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// TODO Auto-generated method stub
+	}
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/learners/predictors/core/driftdetection/EnsembleDriftDetectionMethods.java b/moa/src/main/java/moa/learners/predictors/core/driftdetection/EnsembleDriftDetectionMethods.java
new file mode 100644
index 000000000..20be2bca7
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/driftdetection/EnsembleDriftDetectionMethods.java
@@ -0,0 +1,136 @@
+/*
+ *    DDM.java
+ *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
+ *    @author Manuel Baena (mbaena@lcc.uma.es)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package moa.learners.predictors.core.driftdetection;
+
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.ListOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.github.javacliparser.Option;
+
+import moa.core.ObjectRepository;
+import moa.options.ClassOption;
+import moa.options.OptionHandler;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Ensemble Drift detection method
+ *
+ *
+ * @author Manuel Baena (mbaena@lcc.uma.es)
+ * @version $Revision: 7 $
+ */
+public class EnsembleDriftDetectionMethods extends AbstractChangeDetector {
+
+	private static final long serialVersionUID = -3518369648142099719L;
+
+	// private static final int DDM_MINNUMINST = 30;
+	public IntOption minNumInstancesOption = new IntOption("minNumInstances", 'n',
+			"The minimum number of instances before permitting detecting change.", 30, 0, Integer.MAX_VALUE);
+
+	public ListOption changeDetectorsOption = new ListOption("changeDetectors", 'c', "Change Detectors to use.",
+			new ClassOption("driftDetectionMethod", 'd', "Drift detection method to use.", ChangeDetector.class, "DDM"),
+			new Option[0], ',');
+
+	public MultiChoiceOption predictionOption = new MultiChoiceOption("prediction", 'l', "Prediction to use.",
+			new String[] { "max", "min", "majority" }, new String[] { "Maximum", "Minimum", "Majority" }, 0);
+
+	public EnsembleDriftDetectionMethods() {
+		resetLearning();
+	}
+
+	@Override
+	public void resetLearning() {
+		// if (preds == null) {
+		preds = new Boolean[this.changeDetectorsOption.getList().length];
+		// }
+		for (int i = 0; i < preds.length; i++) {
+			preds[i] = false;
+		}
+	}
+
+	protected ChangeDetector[] cds;
+
+	protected Boolean[] preds;
+
+	@Override
+	public void input(double prediction) {
+		for (int i = 0; i < cds.length; i++) {
+			cds[i].input(prediction);
+			if (cds[i].getChange()) {
+				preds[i] = true;
+			}
+		}
+		int typePrediction = this.predictionOption.getChosenIndex();
+		int numberDetections = 0;
+		for (int i = 0; i < cds.length; i++) {
+			if (preds[i] == true) {
+				numberDetections++;
+			}
+		}
+		if (typePrediction == 0) {
+			// Choose Max
+			this.isChangeDetected = (numberDetections == cds.length);
+		} else if (typePrediction == 1) {
+			// Choose Min
+			this.isChangeDetected = (numberDetections > 0);
+		} else if (typePrediction == 2) {
+			// Choose Avg
+			this.isChangeDetected = (numberDetections > cds.length / 2);
+		}
+		if (this.isChangeDetected == true) {
+			this.resetLearning();
+		}
+	}
+
+	// public double[] getOutput() {
+	// double[] res = {this.isChangeDetected ? 1 : 0, this.isWarningZone ? 1 : 0,
+	// this.delay, this.estimation};
+	// return res;
+	// }
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// TODO Auto-generated method stub
+		Option[] changeDetectorOptions = this.changeDetectorsOption.getList();
+		cds = new ChangeDetector[changeDetectorOptions.length];
+		preds = new Boolean[changeDetectorOptions.length];
+		for (int i = 0; i < cds.length; i++) {
+			// monitor.setCurrentActivity("Materializing change detector " + (i + 1)
+			// + "...", -1.0);
+			cds[i] = ((ChangeDetector) ((ClassOption) changeDetectorOptions[i]).materializeObject(monitor, repository))
+					.copy();
+			if (monitor.taskShouldAbort()) {
+				return;
+			}
+			if (cds[i] instanceof OptionHandler) {
+				monitor.setCurrentActivity("Preparing change detector " + (i + 1) + "...", -1.0);
+				((OptionHandler) cds[i]).prepareForUse(monitor, repository);
+				if (monitor.taskShouldAbort()) {
+					return;
+				}
+			}
+			preds[i] = false;
+		}
+	}
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/learners/predictors/core/driftdetection/GeometricMovingAverageDM.java b/moa/src/main/java/moa/learners/predictors/core/driftdetection/GeometricMovingAverageDM.java
new file mode 100644
index 000000000..7294a2e5a
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/driftdetection/GeometricMovingAverageDM.java
@@ -0,0 +1,109 @@
+/*
+ *    DDM.java
+ *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
+ *    @author Manuel Baena (mbaena@lcc.uma.es)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package moa.learners.predictors.core.driftdetection;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+
+import moa.core.ObjectRepository;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Drift detection method based in Geometric Moving Average Test
+ *
+ *
+ * @author Manuel Baena (mbaena@lcc.uma.es)
+ * @version $Revision: 7 $
+ */
+public class GeometricMovingAverageDM extends AbstractChangeDetector {
+
+	private static final long serialVersionUID = -3518369648142099719L;
+
+	public IntOption minNumInstancesOption = new IntOption("minNumInstances", 'n',
+			"The minimum number of instances before permitting detecting change.", 30, 0, Integer.MAX_VALUE);
+
+	public FloatOption lambdaOption = new FloatOption("lambda", 'l',
+			"Threshold parameter of the Geometric Moving Average Test", 1, 0.0, Float.MAX_VALUE);
+
+	public FloatOption alphaOption = new FloatOption("alpha", 'a',
+			"Alpha parameter of the Geometric Moving Average Test", .99, 0.0, 1.0);
+
+	private double m_n;
+
+	private double sum;
+
+	private double x_mean;
+
+	private double alpha;
+
+	private double delta;
+
+	private double lambda;
+
+	public GeometricMovingAverageDM() {
+		resetLearning();
+	}
+
+	@Override
+	public void resetLearning() {
+		m_n = 1.0;
+		x_mean = 0.0;
+		sum = 0.0;
+		alpha = this.alphaOption.getValue();
+		lambda = this.lambdaOption.getValue();
+	}
+
+	@Override
+	public void input(double x) {
+		// It monitors the error rate
+		if (this.isChangeDetected == true || this.isInitialized == false) {
+			resetLearning();
+			this.isInitialized = true;
+		}
+
+		x_mean = x_mean + (x - x_mean) / m_n;
+		sum = alpha * sum + (1.0 - alpha) * (x - x_mean);
+
+		m_n++;
+
+		// System.out.print(prediction + " " + m_n + " " + (m_p+m_s) + " ");
+		this.estimation = x_mean;
+		this.isChangeDetected = false;
+		this.isWarningZone = false;
+		this.delay = 0;
+
+		if (m_n < this.minNumInstancesOption.getValue()) {
+			return;
+		}
+
+		if (sum > this.lambda) {
+			this.isChangeDetected = true;
+		}
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// TODO Auto-generated method stub
+	}
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/learners/predictors/core/driftdetection/HDDM_A_Test.java b/moa/src/main/java/moa/learners/predictors/core/driftdetection/HDDM_A_Test.java
new file mode 100644
index 000000000..8bfa4c95f
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/driftdetection/HDDM_A_Test.java
@@ -0,0 +1,184 @@
+/*
+ *    HDDM_A_Test.java
+ *
+ *    @author Isvani Frias-Blanco (ifriasb@udg.co.cu)
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.predictors.core.driftdetection;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.MultiChoiceOption;
+
+import moa.core.ObjectRepository;
+import moa.tasks.TaskMonitor;
+
+/**
+ * <p>
+ * Online drift detection method based on Hoeffding's bounds.
+ * HDDM<sub><i>A</i>-test</sub> uses the average as estimator. It receives as
+ * input a stream of real values and returns the estimated status of the stream:
+ * STABLE, WARNING or DRIFT.
+ * </p>
+ *
+ * <p>
+ * I. Frias-Blanco, J. del Campo-Avila, G. Ramos-Jimenez, R. Morales-Bueno, A.
+ * Ortiz-Diaz, and Y. Caballero-Mota, Online and non-parametric drift detection
+ * methods based on Hoeffding's bound, IEEE Transactions on Knowledge and Data
+ * Engineering, 2014. DOI 10.1109/TKDE.2014.2345382.
+ * </p>
+ *
+ * <p>
+ * Parameters:
+ * </p>
+ * <ul>
+ * <li>-d : Confidence to the drift</li>
+ * <li>-w : Confidence to the warning</li>
+ * <li>-t : Option to monitor error increments and decrements (two-sided) or
+ * only increments (one-sided)</li>
+ * </ul>
+ *
+ * @author Isvani Frias-Blanco (ifriasb@udg.co.cu)
+ *
+ */
+
+public class HDDM_A_Test extends AbstractChangeDetector {
+
+	public FloatOption driftConfidenceOption = new FloatOption("driftConfidence", 'd', "Confidence to the drift", 0.001,
+			0, 1);
+	public FloatOption warningConfidenceOption = new FloatOption("warningConfidence", 'w', "Confidence to the warning",
+			0.005, 0, 1);
+	public MultiChoiceOption oneSidedTestOption = new MultiChoiceOption("typeOfTest", 't',
+			"Monitors error increments and decrements (two-sided) or only increments (one-sided)",
+			new String[] { "One-sided", "Two-sided" }, new String[] { "One-sided", "Two-sided" }, 1);
+
+	protected int n_min = 0;
+	protected double c_min = 0;
+	protected int total_n = 0;
+	protected double total_c = 0;
+	protected int n_max = 0;
+	protected double c_max = 0;
+	protected double cEstimacion = 0;
+	protected int nEstimacion = 0;
+
+	public HDDM_A_Test() {
+		resetLearning();
+	}
+
+	@Override
+	public void input(double value) {
+		total_n++;
+		total_c += value;
+		if (n_min == 0) {
+			n_min = total_n;
+			c_min = total_c;
+		}
+		if (n_max == 0) {
+			n_max = total_n;
+			c_max = total_c;
+		}
+
+		double cota = Math.sqrt(1.0 / (2 * n_min) * Math.log(1.0 / driftConfidenceOption.getValue())),
+				cota1 = Math.sqrt(1.0 / (2 * total_n) * Math.log(1.0 / driftConfidenceOption.getValue()));
+		if (c_min / n_min + cota >= total_c / total_n + cota1) {
+			c_min = total_c;
+			n_min = total_n;
+		}
+
+		cota = Math.sqrt(1.0 / (2 * n_max) * Math.log(1.0 / driftConfidenceOption.getValue()));
+		if (c_max / n_max - cota <= total_c / total_n - cota1) {
+			c_max = total_c;
+			n_max = total_n;
+		}
+		if (meanIncr(c_min, n_min, total_c, total_n, driftConfidenceOption.getValue())) {
+			nEstimacion = total_n - n_min;
+			cEstimacion = total_c - c_min;
+			n_min = n_max = total_n = 0;
+			c_min = c_max = total_c = 0;
+			this.isChangeDetected = true;
+			this.isWarningZone = false;
+		} else if (meanIncr(c_min, n_min, total_c, total_n, warningConfidenceOption.getValue())) {
+			this.isChangeDetected = false;
+			this.isWarningZone = true;
+		} else {
+			this.isChangeDetected = false;
+			this.isWarningZone = false;
+		}
+		if (this.oneSidedTestOption.getChosenIndex() == 1 && meanDecr(c_max, n_max, total_c, total_n)) {
+			nEstimacion = total_n - n_max;
+			cEstimacion = total_c - c_max;
+			n_min = n_max = total_n = 0;
+			c_min = c_max = total_c = 0;
+		}
+		updateEstimations();
+	}
+
+	private boolean meanIncr(double c_min, int n_min, double total_c, int total_n, double confianzaCambio) {
+		if (n_min == total_n) {
+			return false;
+		}
+		double m = (double) (total_n - n_min) / n_min * (1.0 / total_n);
+		double cota = Math.sqrt(m / 2 * Math.log(2.0 / confianzaCambio));
+		return total_c / total_n - c_min / n_min >= cota;
+	}
+
+	private boolean meanDecr(double c_max, int n_max, double total_c, int total_n) {
+		if (n_max == total_n) {
+			return false;
+		}
+		double m = (double) (total_n - n_max) / n_max * (1.0 / total_n);
+		double cota = Math.sqrt(m / 2 * Math.log(2.0 / driftConfidenceOption.getValue()));
+		return c_max / n_max - total_c / total_n >= cota;
+	}
+
+	@Override
+	public void resetLearning() {
+		super.resetLearning();
+		n_min = 0;
+		c_min = 0;
+		total_n = 0;
+		total_c = 0;
+		n_max = 0;
+		c_max = 0;
+		cEstimacion = 0;
+		nEstimacion = 0;
+	}
+
+	protected void updateEstimations() {
+		if (this.total_n >= this.nEstimacion) {
+			this.cEstimacion = this.nEstimacion = 0;
+			this.estimation = this.total_c / this.total_n;
+			this.delay = this.total_n;
+		} else {
+			this.estimation = this.cEstimacion / this.nEstimacion;
+			this.delay = this.nEstimacion;
+		}
+	}
+
+	@Override
+	public double getEstimation() {
+		return this.estimation;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		resetLearning();
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/driftdetection/HDDM_W_Test.java b/moa/src/main/java/moa/learners/predictors/core/driftdetection/HDDM_W_Test.java
new file mode 100644
index 000000000..9eba1fab5
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/driftdetection/HDDM_W_Test.java
@@ -0,0 +1,223 @@
+/*
+ *    HDDM_W_Test.java
+ *
+ *    @author Isvani Frias-Blanco (ifriasb@udg.co.cu)
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.predictors.core.driftdetection;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.MultiChoiceOption;
+
+import moa.core.ObjectRepository;
+import moa.tasks.TaskMonitor;
+
+/**
+ * <p>
+ * Online drift detection method based on McDiarmid's bounds.
+ * HDDM<sub><i>W</i>-test</sub> uses the EWMA statistic as estimator. It
+ * receives as input a stream of real values and returns the estimated status of
+ * the stream: STABLE, WARNING or DRIFT.
+ * </p>
+ *
+ * <p>
+ * I. Frias-Blanco, J. del Campo-Avila, G. Ramos-Jimenez, R. Morales-Bueno, A.
+ * Ortiz-Diaz, and Y. Caballero-Mota, Online and non-parametric drift detection
+ * methods based on Hoeffding's bound, IEEE Transactions on Knowledge and Data
+ * Engineering, 2014. DOI 10.1109/TKDE.2014.2345382.
+ * </p>
+ *
+ * <p>
+ * Parameters:
+ * </p>
+ * <ul>
+ * <li>-d : Confidence to the drift</li>
+ * <li>-w : Confidence to the warning</li>
+ * <li>-m : Controls how much weight is given to more recent data compared to
+ * older data. Smaller values mean less weight given to recent data</li>
+ * <li>-t : Option to monitor error increments and decrements (two-sided) or
+ * only increments (one-sided)</li>
+ * </ul>
+ *
+ * @author Isvani Frias-Blanco (ifriasb@udg.co.cu)
+ *
+ */
+
+public class HDDM_W_Test extends AbstractChangeDetector {
+
+	protected static final long serialVersionUID = 1L;
+	public FloatOption driftConfidenceOption = new FloatOption("driftConfidence", 'd', "Confidence to the drift", 0.001,
+			0, 1);
+	public FloatOption warningConfidenceOption = new FloatOption("warningConfidence", 'w', "Confidence to the warning",
+			0.005, 0, 1);
+	public FloatOption lambdaOption = new FloatOption("lambda", 'm',
+			"Controls how much weight is given to more recent data compared to older data. Smaller values mean less weight given to recent data.",
+			0.050, 0, 1);
+	public MultiChoiceOption oneSidedTestOption = new MultiChoiceOption("typeOfTest", 't',
+			"Monitors error increments and decrements (two-sided) or only increments (one-sided)",
+			new String[] { "One-sided", "Two-sided" }, new String[] { "One-sided", "Two-sided" }, 0);
+
+	public static class SampleInfo {
+
+		private static final long serialVersionUID = 1L;
+		public double EWMA_Estimator;
+		public double independentBoundedConditionSum;
+
+		public SampleInfo() {
+			this.EWMA_Estimator = -1.0;
+		}
+	}
+
+	private static SampleInfo sample1_IncrMonitoring, sample2_IncrMonitoring, sample1_DecrMonitoring,
+			sample2_DecrMonitoring, total;
+	protected double incrCutPoint, decrCutPoint;
+	protected double lambda;
+	protected double warningConfidence;
+	protected double driftConfidence;
+	protected boolean oneSidedTest;
+	protected int width;
+
+	public HDDM_W_Test() {
+		resetLearning();
+	}
+
+	@Override
+	public void resetLearning() {
+		super.resetLearning();
+		HDDM_W_Test.total = new SampleInfo();
+		HDDM_W_Test.sample1_DecrMonitoring = new SampleInfo();
+		HDDM_W_Test.sample1_IncrMonitoring = new SampleInfo();
+		HDDM_W_Test.sample2_DecrMonitoring = new SampleInfo();
+		HDDM_W_Test.sample2_IncrMonitoring = new SampleInfo();
+		this.incrCutPoint = Double.MAX_VALUE;
+		this.decrCutPoint = Double.MIN_VALUE;
+		this.lambda = this.lambdaOption.getValue();
+		this.driftConfidence = this.driftConfidenceOption.getValue();
+		this.warningConfidence = this.warningConfidenceOption.getValue();
+		this.oneSidedTest = this.oneSidedTestOption.getChosenIndex() == 0;
+		this.width = 0;
+		this.delay = 0;
+	}
+
+	public void input(boolean prediction) {
+		double value = prediction == false ? 1.0 : 0.0;
+		input(value);
+	}
+
+	@Override
+	public void input(double value) {
+		double auxDecayRate = 1.0 - lambda;
+		this.width++;
+		if (total.EWMA_Estimator < 0) {
+			total.EWMA_Estimator = value;
+			total.independentBoundedConditionSum = 1;
+		} else {
+			total.EWMA_Estimator = lambda * value + auxDecayRate * total.EWMA_Estimator;
+			total.independentBoundedConditionSum = lambda * lambda
+					+ auxDecayRate * auxDecayRate * total.independentBoundedConditionSum;
+		}
+		updateIncrStatistics(value, driftConfidence);
+		if (monitorMeanIncr(value, driftConfidence)) {
+			resetLearning();
+			this.isChangeDetected = true;
+			this.isWarningZone = false;
+		} else if (monitorMeanIncr(value, warningConfidence)) {
+			this.isChangeDetected = false;
+			this.isWarningZone = true;
+		} else {
+			this.isChangeDetected = false;
+			this.isWarningZone = false;
+		}
+		updateDecrStatistics(value, driftConfidence);
+		if (!oneSidedTest && monitorMeanDecr(value, driftConfidence)) {
+			resetLearning();
+		}
+		this.estimation = HDDM_W_Test.total.EWMA_Estimator;
+	}
+
+	public boolean detectMeanIncrement(SampleInfo sample1, SampleInfo sample2, double confidence) {
+		if (sample1.EWMA_Estimator < 0 || sample2.EWMA_Estimator < 0) {
+			return false;
+		}
+		double bound = Math.sqrt((sample1.independentBoundedConditionSum + sample2.independentBoundedConditionSum)
+				* Math.log(1 / confidence) / 2);
+		return sample2.EWMA_Estimator - sample1.EWMA_Estimator > bound;
+	}
+
+	void updateIncrStatistics(double valor, double confidence) {
+		double auxDecay = 1.0 - lambda;
+		double bound = Math.sqrt(total.independentBoundedConditionSum * Math.log(1.0 / driftConfidence) / 2);
+
+		if (total.EWMA_Estimator + bound < incrCutPoint) {
+			incrCutPoint = total.EWMA_Estimator + bound;
+			sample1_IncrMonitoring.EWMA_Estimator = total.EWMA_Estimator;
+			sample1_IncrMonitoring.independentBoundedConditionSum = total.independentBoundedConditionSum;
+			sample2_IncrMonitoring = new SampleInfo();
+			this.delay = 0;
+		} else {
+			this.delay++;
+			if (sample2_IncrMonitoring.EWMA_Estimator < 0) {
+				sample2_IncrMonitoring.EWMA_Estimator = valor;
+				sample2_IncrMonitoring.independentBoundedConditionSum = 1;
+			} else {
+				sample2_IncrMonitoring.EWMA_Estimator = lambda * valor
+						+ auxDecay * sample2_IncrMonitoring.EWMA_Estimator;
+				sample2_IncrMonitoring.independentBoundedConditionSum = lambda * lambda
+						+ auxDecay * auxDecay * sample2_IncrMonitoring.independentBoundedConditionSum;
+			}
+		}
+
+	}
+
+	protected boolean monitorMeanIncr(double valor, double confidence) {
+		return detectMeanIncrement(sample1_IncrMonitoring, sample2_IncrMonitoring, confidence);
+	}
+
+	void updateDecrStatistics(double valor, double confidence) {
+		double auxDecay = 1.0 - lambda;
+		double epsilon = Math.sqrt(total.independentBoundedConditionSum * Math.log(1.0 / driftConfidence) / 2);
+
+		if (total.EWMA_Estimator - epsilon > decrCutPoint) {
+			decrCutPoint = total.EWMA_Estimator - epsilon;
+			sample1_DecrMonitoring.EWMA_Estimator = total.EWMA_Estimator;
+			sample1_DecrMonitoring.independentBoundedConditionSum = total.independentBoundedConditionSum;
+			sample2_DecrMonitoring = new SampleInfo();
+		} else {
+			if (sample2_DecrMonitoring.EWMA_Estimator < 0) {
+				sample2_DecrMonitoring.EWMA_Estimator = valor;
+				sample2_DecrMonitoring.independentBoundedConditionSum = 1;
+			} else {
+				sample2_DecrMonitoring.EWMA_Estimator = lambda * valor
+						+ auxDecay * sample2_DecrMonitoring.EWMA_Estimator;
+				sample2_DecrMonitoring.independentBoundedConditionSum = lambda * lambda
+						+ auxDecay * auxDecay * sample2_DecrMonitoring.independentBoundedConditionSum;
+			}
+		}
+	}
+
+	protected boolean monitorMeanDecr(double valor, double confidence) {
+		return detectMeanIncrement(sample2_DecrMonitoring, sample1_DecrMonitoring, confidence);
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		resetLearning();
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/driftdetection/NoChangeDetection.java b/moa/src/main/java/moa/learners/predictors/core/driftdetection/NoChangeDetection.java
new file mode 100644
index 000000000..5de3f4580
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/driftdetection/NoChangeDetection.java
@@ -0,0 +1,45 @@
+package moa.learners.predictors.core.driftdetection;
+
+import moa.core.ObjectRepository;
+import moa.tasks.TaskMonitor;
+
+public class NoChangeDetection extends AbstractChangeDetector implements ChangeDetector {
+
+	/**
+	 *
+	 */
+	private static final long serialVersionUID = 1L;
+
+	public NoChangeDetection() {
+		resetLearning();
+	}
+
+	@Override
+	public void input(double inputValue) {
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+
+	}
+
+	@Override
+	public void resetLearning() {
+		this.isInitialized = true;
+		this.isChangeDetected = false;
+		this.isWarningZone = false;
+		this.estimation = 0.0;
+		this.delay = 0.0;
+	}
+
+	@Override
+	public String getPurposeString() {
+		return "Use this class to NOT detect changes.";
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/driftdetection/PageHinkleyDM.java b/moa/src/main/java/moa/learners/predictors/core/driftdetection/PageHinkleyDM.java
new file mode 100644
index 000000000..62fbe069d
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/driftdetection/PageHinkleyDM.java
@@ -0,0 +1,113 @@
+/*
+ *    DDM.java
+ *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
+ *    @author Manuel Baena (mbaena@lcc.uma.es)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package moa.learners.predictors.core.driftdetection;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+
+import moa.core.ObjectRepository;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Drift detection method based in Page Hinkley Test.
+ *
+ *
+ * @author Manuel Baena (mbaena@lcc.uma.es)
+ * @version $Revision: 7 $
+ */
+public class PageHinkleyDM extends AbstractChangeDetector {
+
+	private static final long serialVersionUID = -3518369648142099719L;
+
+	public IntOption minNumInstancesOption = new IntOption("minNumInstances", 'n',
+			"The minimum number of instances before permitting detecting change.", 30, 0, Integer.MAX_VALUE);
+
+	public FloatOption deltaOption = new FloatOption("delta", 'd', "Delta parameter of the Page Hinkley Test", 0.005,
+			0.0, 1.0);
+
+	public FloatOption lambdaOption = new FloatOption("lambda", 'l', "Lambda parameter of the Page Hinkley Test", 50,
+			0.0, Float.MAX_VALUE);
+
+	public FloatOption alphaOption = new FloatOption("alpha", 'a', "Alpha parameter of the Page Hinkley Test",
+			1 - 0.0001, 0.0, 1.0);
+
+	private int m_n;
+
+	private double sum;
+
+	private double x_mean;
+
+	private double alpha;
+
+	private double delta;
+
+	private double lambda;
+
+	public PageHinkleyDM() {
+		resetLearning();
+	}
+
+	@Override
+	public void resetLearning() {
+		m_n = 1;
+		x_mean = 0.0;
+		sum = 0.0;
+		delta = this.deltaOption.getValue();
+		alpha = this.alphaOption.getValue();
+		lambda = this.lambdaOption.getValue();
+	}
+
+	@Override
+	public void input(double x) {
+		// It monitors the error rate
+		if (this.isChangeDetected == true || this.isInitialized == false) {
+			resetLearning();
+			this.isInitialized = true;
+		}
+
+		x_mean = x_mean + (x - x_mean) / m_n;
+		sum = this.alpha * sum + (x - x_mean - this.delta);
+
+		m_n++;
+
+		// System.out.print(prediction + " " + m_n + " " + (m_p+m_s) + " ");
+		this.estimation = x_mean;
+		this.isChangeDetected = false;
+		this.isWarningZone = false;
+		this.delay = 0;
+
+		if (m_n < this.minNumInstancesOption.getValue()) {
+			return;
+		}
+
+		if (sum > this.lambda) {
+			this.isChangeDetected = true;
+		}
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// TODO Auto-generated method stub
+	}
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/learners/predictors/core/driftdetection/RDDM.java b/moa/src/main/java/moa/learners/predictors/core/driftdetection/RDDM.java
new file mode 100644
index 000000000..bf98f0006
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/driftdetection/RDDM.java
@@ -0,0 +1,228 @@
+/*
+ *    RDDM.java
+ *    Copyright (C) 2016 Barros, Cabral, Goncalves, Santos
+ *    @authors Roberto S. M. Barros (roberto@cin.ufpe.br)
+ *             Danilo Cabral (danilocabral@danilocabral.com.br)
+ *             Paulo M. Goncalves Jr. (paulomgj@gmail.com)
+ *             Silas G. T. C. Santos (sgtcs@cin.ufpe.br)
+ *    @version $Version: 1 $
+ *
+ *    Evolved from DDM.java
+ *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
+ *    @author Manuel Baena (mbaena@lcc.uma.es)
+ *    @version $Revision: 7 $
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ * Reactive Drift Detection Method (RDDM)
+ * published as:
+ *     Roberto S. M. Barros, Danilo R. L. Cabral, Paulo M. Goncalves Jr.,
+ *     and Silas G. T. C. Santos:
+ *     RDDM: Reactive Drift Detection Method.
+ *     Expert Systems With Applications 90C (2017) pp. 344-355.
+ *     DOI: 10.1016/j.eswa.2017.08.023
+ */
+
+package moa.learners.predictors.core.driftdetection;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+
+import moa.core.ObjectRepository;
+import moa.tasks.TaskMonitor;
+
+public class RDDM extends AbstractChangeDetector {
+	private static final long serialVersionUID = -489867468386968209L;
+
+	public IntOption minNumInstancesOption = new IntOption("minNumInstances", 'n',
+			"Minimum number of instances before monitoring changes.", 129, 0, Integer.MAX_VALUE);
+
+	public FloatOption warningLevelOption = new FloatOption("warningLevel", 'w', "Warning Level.", 1.773, 1.0, 4.0);
+
+	public FloatOption driftLevelOption = new FloatOption("driftLevel", 'o', "Drift Level.", 2.258, 1.0, 5.0);
+
+	public IntOption maxSizeConceptOption = new IntOption("maxSizeConcept", 'x', "Maximum Size of Concept.", 40000, 1,
+			Integer.MAX_VALUE);
+
+	public IntOption minSizeStableConceptOption = new IntOption("minSizeStableConcept", 'y',
+			"Minimum Size of Stable Concept.", 7000, 1, 20000);
+
+	public IntOption warnLimitOption = new IntOption("warnLimit", 'z', "Warning Limit of instances", 1400, 1, 20000);
+
+	private int minNumInstances;
+	private double warningLevel;
+	private double driftLevel;
+	private int maxSizeConcept;
+	private int minSizeStableConcept;
+	private int warnLimit;
+
+	private int m_n;
+	private double m_p;
+	private double m_s;
+	private double m_pmin;
+	private double m_smin;
+	private double m_psmin;
+
+	private byte[] storedPredictions;
+	private int numStoredInstances, firstPos, lastPos, pos, i;
+	private int lastWarnInst, lastWarnPos;
+	private int instNum;
+	private boolean rddmDrift;
+
+	public void initialize() {
+		minNumInstances = this.minNumInstancesOption.getValue();
+		warningLevel = this.warningLevelOption.getValue();
+		driftLevel = this.driftLevelOption.getValue();
+		maxSizeConcept = this.maxSizeConceptOption.getValue();
+		minSizeStableConcept = this.minSizeStableConceptOption.getValue();
+		warnLimit = this.warnLimitOption.getValue();
+		storedPredictions = new byte[minSizeStableConcept];
+		numStoredInstances = 0;
+		firstPos = 0;
+		lastPos = -1; // This means storedPredictions is empty.
+		lastWarnPos = -1;
+		lastWarnInst = -1;
+		instNum = 0;
+		rddmDrift = false;
+		this.isChangeDetected = false;
+
+		resetLearning();
+		m_pmin = Double.MAX_VALUE;
+		m_smin = Double.MAX_VALUE;
+		m_psmin = Double.MAX_VALUE;
+	}
+
+	@Override
+	public void resetLearning() {
+		m_n = 1;
+		m_p = 1;
+		m_s = 0;
+		if (this.isChangeDetected) {
+			m_pmin = Double.MAX_VALUE;
+			m_smin = Double.MAX_VALUE;
+			m_psmin = Double.MAX_VALUE;
+		}
+	}
+
+	@Override
+	public void input(double prediction) { // In MOA, 1.0=false, 0.0=true.
+		if (!this.isInitialized) {
+			initialize();
+			this.isInitialized = true;
+		}
+		if (rddmDrift) {
+			resetLearning();
+			if (lastWarnPos != -1) {
+				firstPos = lastWarnPos;
+				numStoredInstances = lastPos - firstPos + 1;
+				if (numStoredInstances <= 0) {
+					numStoredInstances += minSizeStableConcept;
+				}
+			}
+
+			pos = firstPos;
+			for (i = 0; i < numStoredInstances; i++) {
+				m_p = m_p + (storedPredictions[pos] - m_p) / m_n;
+				m_s = Math.sqrt(m_p * (1 - m_p) / m_n);
+				if (this.isChangeDetected && (m_n > minNumInstances) && (m_p + m_s < m_psmin)) {
+					m_pmin = m_p;
+					m_smin = m_s;
+					m_psmin = m_p + m_s;
+				}
+				m_n++;
+				pos = (pos + 1) % minSizeStableConcept;
+			}
+
+			lastWarnPos = -1;
+			lastWarnInst = -1;
+			rddmDrift = false;
+			this.isChangeDetected = false;
+		}
+
+		lastPos = (lastPos + 1) % minSizeStableConcept; // Adds prediction at the end of the window.
+		storedPredictions[lastPos] = (byte) prediction;
+		if (numStoredInstances < minSizeStableConcept) { // The window grows.
+			numStoredInstances++;
+		} else { // The window is full.
+			firstPos = (firstPos + 1) % minSizeStableConcept; // Start of the window moves.
+			if (lastWarnPos == lastPos) {
+				lastWarnPos = -1;
+			}
+		}
+
+		m_p = m_p + (prediction - m_p) / m_n;
+		m_s = Math.sqrt(m_p * (1 - m_p) / m_n);
+
+		instNum++;
+		m_n++;
+		this.estimation = m_p;
+		this.isWarningZone = false;
+
+		if (m_n <= minNumInstances) {
+			return;
+		}
+
+		if (m_p + m_s < m_psmin) {
+			m_pmin = m_p;
+			m_smin = m_s;
+			m_psmin = m_p + m_s;
+		}
+
+		if (m_p + m_s > m_pmin + driftLevel * m_smin) { // DDM Drift
+			this.isChangeDetected = true;
+			rddmDrift = true;
+			if (lastWarnInst == -1) { // DDM Drift without previous warning
+				firstPos = lastPos;
+				numStoredInstances = 1;
+			}
+			return;
+		}
+
+		if (m_p + m_s > m_pmin + warningLevel * m_smin) { // Warning Level
+			// Warning level for warnLimit consecutive instances will force drifts
+			if ((lastWarnInst != -1) && (lastWarnInst + warnLimit <= instNum)) {
+				this.isChangeDetected = true;
+				rddmDrift = true;
+				firstPos = lastPos;
+				numStoredInstances = 1;
+				lastWarnPos = -1;
+				lastWarnInst = -1;
+				return;
+			}
+			// Warning Zone
+			this.isWarningZone = true;
+			if (lastWarnInst == -1) {
+				lastWarnInst = instNum;
+				lastWarnPos = lastPos;
+			}
+		} else { // Neither DDM Drift nor Warning - disregard false warnings
+			lastWarnInst = -1;
+			lastWarnPos = -1;
+		}
+		if (m_n > maxSizeConcept && (!isWarningZone)) { // RDDM Drift
+			rddmDrift = true;
+		}
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// TODO Auto-generated method stub
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/driftdetection/SEEDChangeDetector.java b/moa/src/main/java/moa/learners/predictors/core/driftdetection/SEEDChangeDetector.java
new file mode 100644
index 000000000..6797e8482
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/driftdetection/SEEDChangeDetector.java
@@ -0,0 +1,536 @@
+/*
+ * SEEDChangeDetector.java
+ * author: David T.J. Huang - The University of Auckland
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *             http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific
+ * language governing permissions and limitations under the
+ * License.
+ *
+ */
+
+package moa.learners.predictors.core.driftdetection;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+
+import moa.core.ObjectRepository;
+import moa.tasks.TaskMonitor;
+
+/**
+ *
+ * Drift detection method as published in:
+ * </p>
+ * David Tse Jung Huang, Yun Sing Koh, Gillian Dobbie, and Russel Pears:
+ * Detecting Volatility Shift in Data Streams. ICDM 2014: 863-868
+ * </p>
+ * Usage: {@link #setInput(double)}
+ * </p>
+ *
+ * @author David T.J. Huang - The University of Auckland
+ * @version 1.0
+ */
+
+public class SEEDChangeDetector extends AbstractChangeDetector {
+	protected SEED seed;
+
+	public FloatOption deltaSEEDOption = new FloatOption("deltaSEED", 'd', "Delta value of SEED Detector", 0.05, 0.0,
+			1.0);
+	public IntOption blockSizeSEEDOption = new IntOption("blockSizeSEED", 'b', "BlockSize value of SEED Detector", 32,
+			32, 256);
+	public FloatOption epsilonPrimeSEEDOption = new FloatOption("epsilonPrimeSEED", 'e',
+			"EpsilonPrime value of SEED Detector", 0.01, 0.0025, 0.01);
+	public FloatOption alphaSEEDOption = new FloatOption("alphaSEED", 'a', "Alpha value of SEED Detector", 0.8, 0.2,
+			0.8);
+	public IntOption compressTermSEEDOption = new IntOption("compressTermSEED", 'c',
+			"CompressTerm value of SEED Detector", 75, 50, 100);
+
+	@Override
+	public void input(double inputValue) {
+		if (this.seed == null) {
+			resetLearning();
+		}
+		this.isChangeDetected = seed.setInput(inputValue);
+		this.isWarningZone = false;
+		this.delay = 0.0;
+		this.estimation = 0.0;
+	}
+
+	@Override
+	public void resetLearning() {
+		seed = new SEED(this.deltaSEEDOption.getValue(), this.blockSizeSEEDOption.getValue(),
+				this.epsilonPrimeSEEDOption.getValue(), this.alphaSEEDOption.getValue(),
+				this.compressTermSEEDOption.getValue());
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// TODO Auto-generated method stub
+	}
+
+	public class SEED {
+		public SEEDWindow window;
+		private double DELTA;
+		private int blockSize;
+		private int elementCount;
+
+		/**
+		 * Constructor for all required parameters.
+		 * 
+		 * @param delta
+		 * @param blockSize       Recommended value: 32
+		 * @param epsilonPrime    Recommended values between [0.0025, 0.01]
+		 * @param alpha           Growth parameter - Recommended values between [0.2,
+		 *                        0.8]
+		 * @param compressionterm Recommended values between [50, 100]
+		 */
+		public SEED(double delta, int blockSize, double epsilonPrime, double alpha, int term) {
+			this.DELTA = delta;
+			this.blockSize = blockSize;
+			this.window = new SEEDWindow(blockSize, 1, 1, epsilonPrime, alpha, term);
+		}
+
+		/**
+		 * Main method for passing in input values and performing drift detection
+		 * 
+		 * @param inputValue instance from the stream
+		 * @return boolean value true or false signaling whether a drift has occurred
+		 */
+		public boolean setInput(double inputValue) {
+			SEEDBlock cursor;
+
+			addElement(inputValue);
+
+			if (elementCount % blockSize == 0 && window.getBlockCount() >= 2) // Drift Point Check
+			{
+				boolean blnReduceWidth = true;
+
+				while (blnReduceWidth) {
+					blnReduceWidth = false;
+					int n1 = 0;
+					int n0 = window.getWidth();
+					double u1 = 0;
+					double u0 = window.getTotal();
+
+					cursor = window.getTail();
+					while (cursor.getPrevious() != null) {
+						n0 -= cursor.getItemCount();
+						n1 += cursor.getItemCount();
+						u0 -= cursor.getTotal();
+						u1 += cursor.getTotal();
+						double diff = Math.abs(u1 / n1 - (u0 / n0));
+
+						if (diff > getADWINBound(n0, n1)) {
+							blnReduceWidth = true;
+							window.setHead(cursor);
+
+							while (cursor.getPrevious() != null) {
+								cursor = cursor.getPrevious();
+								window.setWidth(window.getWidth() - cursor.getItemCount());
+								window.setTotal(window.getTotal() - cursor.getTotal());
+								window.setVariance(window.getVariance() - cursor.getVariance());
+								window.setBlockCount(window.getBlockCount() - 1);
+							}
+
+							window.getHead().setPrevious(null);
+
+							return true;
+						}
+						cursor = cursor.getPrevious();
+					}
+				}
+			}
+
+			return false;
+		}
+
+		private double getADWINBound(double n0, double n1) {
+			double n = n0 + n1;
+			double dd = Math.log(2 * Math.log(n) / DELTA);
+			double v = window.getVariance() / window.getWidth();
+			double m = (1 / (n0)) + (1 / (n1));
+			double epsilon = Math.sqrt(2 * m * v * dd) + (double) 2 / 3 * dd * m;
+
+			return epsilon;
+		}
+
+		public void addElement(double value) {
+			window.addTransaction(value);
+			elementCount++;
+		}
+	}
+
+	public class SEEDBlock {
+		private SEEDBlock next;
+		private SEEDBlock previous;
+
+		private int blockSize;
+		private double total;
+		private double variance;
+		private int itemCount;
+
+		public SEEDBlock(int blockSize) {
+			this.next = null;
+			this.previous = null;
+			this.blockSize = blockSize;
+
+			this.total = 0;
+			this.variance = 0;
+			this.itemCount = 0;
+		}
+
+		public SEEDBlock(SEEDBlock block) {
+			this.next = block.getNext();
+			this.previous = block.getPrevious();
+			this.blockSize = block.blockSize;
+
+			this.total = block.total;
+			this.variance = block.variance;
+			this.itemCount = block.itemCount;
+		}
+
+		public void setNext(SEEDBlock next) {
+			this.next = next;
+		}
+
+		public SEEDBlock getNext() {
+			return this.next;
+		}
+
+		public void setPrevious(SEEDBlock previous) {
+			this.previous = previous;
+		}
+
+		public SEEDBlock getPrevious() {
+			return this.previous;
+		}
+
+		public int getBlockSize() {
+			return blockSize;
+		}
+
+		public void setBlockSize(int blockSize) {
+			this.blockSize = blockSize;
+		}
+
+		public void add(double value) {
+			itemCount++;
+			total += value;
+		}
+
+		public boolean isFull() {
+			if (itemCount == blockSize) {
+				return true;
+			} else {
+				return false;
+			}
+		}
+
+		public double getMean() {
+			return this.total / this.itemCount;
+		}
+
+		public void setTotal(double value) {
+			this.total = value;
+		}
+
+		public double getTotal() {
+			return this.total;
+		}
+
+		public void setItemCount(int value) {
+			this.itemCount = value;
+		}
+
+		public int getItemCount() {
+			return this.itemCount;
+		}
+
+		public void setVariance(double value) {
+			this.variance = value;
+		}
+
+		public double getVariance() {
+			return this.variance;
+		}
+
+	}
+
+	public class SEEDWindow {
+		private SEEDBlock head;
+		private SEEDBlock tail;
+
+		private int blockSize;
+		private int width;
+		private double total;
+		private double variance;
+		private int blockCount;
+
+		private int DECAY_MODE = 1;
+		private final int LINEAR_DECAY = 1;
+		private final int EXPONENTIAL_DECAY = 2;
+
+		private int COMPRESSION_MODE = 1;
+		private final int FIXED_TERM = 1;
+
+		private int decayCompressionCount = 0;
+		private int linearFixedTermSize = 50;
+
+		private double epsilonPrime = 0.0;
+		private double alpha = 0.0;
+
+		public SEEDWindow(int blockSize) {
+			clear();
+			this.blockSize = blockSize;
+			addBlockToHead(new SEEDBlock(blockSize));
+		}
+
+		public SEEDWindow(int blockSize, int decayMode, int compressionMode, double epsilonPrime, double alpha,
+				int compressionTerm) {
+			clear();
+			this.blockSize = blockSize;
+			this.DECAY_MODE = decayMode;
+			this.COMPRESSION_MODE = compressionMode;
+			this.epsilonPrime = epsilonPrime;
+			this.alpha = alpha;
+			setCompressionTerm(compressionTerm);
+			addBlockToHead(new SEEDBlock(blockSize));
+		}
+
+		public void clear() {
+			head = null;
+			tail = null;
+			width = 0;
+			blockCount = 0;
+			total = 0;
+			variance = 0;
+		}
+
+		public void addTransaction(double value) {
+			if (tail.isFull()) {
+				if (COMPRESSION_MODE == FIXED_TERM) {
+					if (tail.getPrevious() != null && decayCompressionCount > linearFixedTermSize) {
+						decayCompressionCount = 0;
+						SEEDBlock cursor = tail;
+
+						double epsilon = 0.0;
+
+						int i = 0;
+
+						while (cursor != null && cursor.getPrevious() != null) {
+							double n0 = cursor.getItemCount();
+							double n1 = cursor.getPrevious().getItemCount();
+							double u0 = cursor.getTotal();
+							double u1 = cursor.getPrevious().getTotal();
+
+							double diff = Math.abs(u1 / n1 - (u0 / n0));
+
+							if (DECAY_MODE == LINEAR_DECAY) {
+								epsilon += epsilonPrime * alpha;
+							} else if (DECAY_MODE == EXPONENTIAL_DECAY) {
+								epsilon = epsilonPrime * Math.pow(1 + alpha, i);
+							}
+
+							if (diff < epsilon) {
+								compressBlock(cursor);
+							}
+							cursor = cursor.getPrevious();
+							i++;
+						}
+					}
+				}
+
+				addBlockToTail(new SEEDBlock(this.blockSize));
+				decayCompressionCount++;
+			}
+			tail.add(value);
+			total += value;
+
+			width++;
+			if (width >= 2) {
+				double incVariance = (width - 1) * (value - total / (width - 1)) * (value - total / (width - 1))
+						/ width;
+				variance += incVariance;
+				tail.setVariance(tail.getVariance() + incVariance);
+			}
+
+		}
+
+		public void compressBlock(SEEDBlock cursor) {
+			cursor.getPrevious().setTotal(cursor.getTotal() + cursor.getPrevious().getTotal());
+			cursor.getPrevious().setItemCount(cursor.getItemCount() + cursor.getPrevious().getItemCount());
+			cursor.getPrevious().setVariance(cursor.getVariance() + cursor.getPrevious().getVariance());
+			cursor.getPrevious().setBlockSize(cursor.getBlockSize() + cursor.getPrevious().getBlockSize());
+
+			if (cursor.getNext() != null) {
+				cursor.getPrevious().setNext(cursor.getNext());
+				cursor.getNext().setPrevious(cursor.getPrevious());
+			} else {
+				cursor.getPrevious().setNext(null);
+				tail = cursor.getPrevious();
+			}
+
+			blockCount--;
+		}
+
+		public boolean checkHomogeneity(SEEDBlock block) {
+			double diff = Math.abs(block.getMean() - block.getPrevious().getMean());
+			double epsilonPrime = getADWINBound(block.getItemCount(), block.getPrevious().getItemCount());
+			// double epsilonPrime = 0.01;
+			if (diff < epsilonPrime) {
+				return true;
+			} else {
+				return false;
+			}
+		}
+
+		private double getADWINBound(double n0, double n1) {
+			double n = n0 + n1;
+			double dd = Math.log(2 * Math.log(n) / 0.99);
+			double v = variance / width;
+			double m = (1 / (n0)) + (1 / (n1));
+			double epsilon = Math.sqrt(2 * m * v * dd) + (double) 2 / 3 * dd * m;
+
+			return epsilon;
+		}
+
+		public void addBlockToHead(SEEDBlock block) {
+			if (head == null) {
+				head = block;
+				tail = block;
+			} else {
+				block.setNext(head);
+				head.setPrevious(block);
+				head = block;
+			}
+			blockCount++;
+		}
+
+		public void removeBlock(SEEDBlock block) {
+			width -= block.getItemCount();
+			total -= block.getTotal();
+			variance -= block.getVariance();
+			blockCount--;
+
+			if (block.getPrevious() != null && block.getNext() != null) {
+				block.getPrevious().setNext(block.getNext());
+				block.getNext().setPrevious(block.getPrevious());
+				block.setNext(null);
+				block.setPrevious(null);
+			} else if (block.getPrevious() == null && block.getNext() != null) {
+				block.getNext().setPrevious(null);
+				head = block.getNext();
+				block.setNext(null);
+			} else if (block.getPrevious() != null && block.getNext() == null) {
+				block.getPrevious().setNext(null);
+				tail = block.getPrevious();
+				block.setPrevious(null);
+			} else if (block.getPrevious() == null && block.getNext() == null) {
+				head = null;
+				tail = null;
+			}
+		}
+
+		public void addBlockToTail(SEEDBlock block) {
+			if (tail == null) {
+				tail = block;
+				head = block;
+			} else {
+				block.setPrevious(tail);
+				tail.setNext(block);
+				tail = block;
+			}
+			blockCount++;
+		}
+
+		public int getBlockCount() {
+			return this.blockCount;
+		}
+
+		public void setBlockCount(int value) {
+			this.blockCount = value;
+		}
+
+		public int getWidth() {
+			return this.width;
+		}
+
+		public void setWidth(int value) {
+			this.width = value;
+		}
+
+		public void setHead(SEEDBlock head) {
+			this.head = head;
+		}
+
+		public void setTail(SEEDBlock tail) {
+			this.tail = tail;
+		}
+
+		public SEEDBlock getHead() {
+			return this.head;
+		}
+
+		public SEEDBlock getTail() {
+			return this.tail;
+		}
+
+		public double getTotal() {
+			return this.total;
+		}
+
+		public void setTotal(double value) {
+			this.total = value;
+		}
+
+		public double getVariance() {
+			return this.variance;
+		}
+
+		public void setVariance(double value) {
+			this.variance = value;
+		}
+
+		public void setBlockSize(int value) {
+			if (value > 32) {
+				this.blockSize = value;
+			} else {
+				this.blockSize = 32;
+			}
+		}
+
+		public int getBlockSize() {
+			return this.blockSize;
+		}
+
+		public double getEpsilonPrime() {
+			return epsilonPrime;
+		}
+
+		public void setEpsilonPrime(double epsilonPrime) {
+			this.epsilonPrime = epsilonPrime;
+		}
+
+		public void setAlpha(double alpha) {
+			this.alpha = alpha;
+		}
+
+		public void setCompressionTerm(int value) {
+			this.linearFixedTermSize = value;
+		}
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/driftdetection/STEPD.java b/moa/src/main/java/moa/learners/predictors/core/driftdetection/STEPD.java
new file mode 100644
index 000000000..2966c8528
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/driftdetection/STEPD.java
@@ -0,0 +1,140 @@
+/*
+ *    STEPD.java
+ *    Copyright (C) 2015 Santos, Barros
+ *    @authors Silas Garrido T. de Carvalho Santos (sgtcs@cin.ufpe.br)
+ *             Roberto S. M. Barros (roberto@cin.ufpe.br)
+ *    @version $Version: 3 $
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Statistical Test of Equal Proportions method (STEPD),
+ * published as:
+ * <p> Kyosuke Nishida and Koichiro Yamauchi:
+ *     Detecting Concept Drift Using Statistical Testing.
+ *     Discovery Science 2007, Springer, vol 4755 of LNCS, pp. 264-269. </p>
+ */
+
+package moa.learners.predictors.core.driftdetection;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+
+import moa.core.ObjectRepository;
+import moa.tasks.TaskMonitor;
+import weka.core.Statistics;
+
+public class STEPD extends AbstractChangeDetector {
+	private static final long serialVersionUID = -3518369648142099719L;
+
+	public IntOption windowSizeOption = new IntOption("windowSize", 'r', "Recent Window Size.", 30, 0, 1000);
+
+	public FloatOption alphaDriftOption = new FloatOption("alphaDrift", 'o', "Drift Significance Level.", 0.003, 0.0,
+			1.0);
+
+	public FloatOption alphaWarningOption = new FloatOption("alphaWarning", 'w', "Warning Significance Level.", 0.05,
+			0.0, 1.0);
+
+	private int windowSize;
+	private double alphaDrift, alphaWarning;
+
+	private byte[] storedPredictions;
+	private int firstPos, lastPos;
+
+	private double ro, rr, wo, wr; // Correct and incorrect prediction numbers in both windows
+	private int no, nr; // Number of instances in both windows
+	private double p, Z, sizeInvertedSum;
+
+	public void initialize() {
+		windowSize = this.windowSizeOption.getValue();
+		alphaDrift = this.alphaDriftOption.getValue();
+		alphaWarning = this.alphaWarningOption.getValue();
+		storedPredictions = new byte[windowSize];
+		resetLearning();
+	}
+
+	@Override
+	public void resetLearning() {
+		firstPos = 0;
+		lastPos = -1; // This means storedPredictions is empty.
+		wo = wr = 0.0;
+		no = nr = 0;
+		this.isChangeDetected = false;
+	}
+
+	@Override
+	public void input(double prediction) { // In MOA, 1.0=false, 0.0=true.
+		if (!this.isInitialized) {
+			initialize();
+			this.isInitialized = true;
+		} else {
+			if (this.isChangeDetected) {
+				resetLearning();
+			}
+		}
+
+		if (nr == windowSize) { // Recent window is full.
+			wo = wo + storedPredictions[firstPos]; // Oldest prediction in recent window
+			no++; // is moved to older window,
+			wr = wr - storedPredictions[firstPos];
+			firstPos++; // Start of recent window moves.
+			if (firstPos == windowSize) {
+				firstPos = 0;
+			}
+		} else { // Recent window grows.
+			nr++;
+		}
+
+		lastPos++; // Adds prediction at the end of recent window.
+		if (lastPos == windowSize) {
+			lastPos = 0;
+		}
+		storedPredictions[lastPos] = (byte) prediction;
+		wr += prediction;
+
+		this.isWarningZone = false;
+
+		if (no >= windowSize) { // The same as: (no + nr) >= 2 * windowSize.
+			ro = no - wo; // Numbers of correct predictions are calculated.
+			rr = nr - wr;
+			sizeInvertedSum = 1.0 / no + 1.0 / nr; // Auxiliary variable.
+			p = (ro + rr) / (no + nr); // Calculation of the statistics of STEPD.
+			Z = Math.abs(ro / no - rr / nr);
+			Z = Z - sizeInvertedSum / 2.0;
+			Z = Z / Math.sqrt(p * (1.0 - p) * sizeInvertedSum);
+
+			Z = Statistics.normalProbability(Math.abs(Z));
+			Z = 2 * (1 - Z);
+
+			if (Z < alphaDrift) { // Drift Level
+				this.isChangeDetected = true;
+			} else {
+				if (Z < alphaWarning) { // Warning Level
+					this.isWarningZone = true;
+				}
+			}
+		}
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// TODO Auto-generated method stub
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/driftdetection/SeqDrift1ChangeDetector.java b/moa/src/main/java/moa/learners/predictors/core/driftdetection/SeqDrift1ChangeDetector.java
new file mode 100644
index 000000000..b7cd7f82e
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/driftdetection/SeqDrift1ChangeDetector.java
@@ -0,0 +1,513 @@
+/*
+ *    SeqDrift1ChangeDetector.java
+ *    Copyright (C) 2011 University of Waikato, Hamilton, New Zealand
+ *    @author Sakthithasan Sripirakas sripirakas363 at yahoo dot com
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package moa.learners.predictors.core.driftdetection;
+
+import java.util.ArrayList;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+
+import moa.AbstractMOAObject;
+import moa.core.ObjectRepository;
+import moa.learners.predictors.core.driftdetection.SeqDrift2ChangeDetector.Repository;
+import moa.tasks.TaskMonitor;
+
+/**
+ * SeqDrift1ChangeDetector.java. This extends Abstract Change Detector as
+ * required by MOA.
+ *
+ * Sakthithasan, S., Pears, R., & Koh, Y. (2013). One Pass Concept Change
+ * Detection for Data Streams. In J. Pei, V. Tseng, L. Cao, H. Motoda, & G. Xu
+ * (Eds.), Advances in Knowledge Discovery and Data Mining (Vol. 7819, pp.
+ * 461-472): Springer Berlin Heidelberg.
+ *
+ * @author Sakthithasan Sripirakas sripirakas363 at yahoo dot com
+ * @version $Revision: 7 $
+ */
+public class SeqDrift1ChangeDetector extends AbstractChangeDetector {
+
+	protected SeqDrift1 seqDrift1;
+	// protected ADWIN adwin;
+
+	public FloatOption deltaOption = new FloatOption("deltaSeqDrift1", 'd', "Delta of SeqDrift1 change detection", 0.01,
+			0.0, 1.0);
+
+	public FloatOption deltaWarningOption = new FloatOption("deltaWarningOption", 'w',
+			"Delta of SeqDrift1 change detector to declare warning state", 0.1, 0.0, 1.0);
+
+	public IntOption blockSeqDriftOption = new IntOption("blockSeqDrift1Option", 'b',
+			"Block size of SeqDrift1 change detector", 200, 100, 10000);
+
+	@Override
+	public void input(double inputValue) {
+		if (this.seqDrift1 == null) {
+			resetLearning();
+		}
+		this.isChangeDetected = seqDrift1.setInput(inputValue);
+		this.isWarningZone = false;
+		this.delay = 0.0;
+		this.estimation = seqDrift1.getEstimation();
+	}
+
+	@Override
+	public void resetLearning() {
+		seqDrift1 = new SeqDrift1(this.deltaOption.getValue(), (this.blockSeqDriftOption.getValue()),
+				(this.deltaWarningOption.getValue()));
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// TODO Auto-generated method stub
+	}
+
+	/**
+	 * SeqDrift1 uses sliding window to build a sequential change detection model
+	 * that uses statistically sound guarantees defined using Bernstein Bound on
+	 * false positive and false negative rates. This is a block based approach and
+	 * checks for changes in the data values only at block boundaries as opposed to
+	 * the methods on per instance basis. SeqDrift1 maintains a sliding window and
+	 * repository. Repository gathers the new instances and sliding window stores
+	 * only the data values that are statistically not different, in other words
+	 * from the same distribution. If the data values in the repository are
+	 * consistent with the values in sliding window the data values of the
+	 * repository are copied to the sliding window applying reservoir algorithm. The
+	 * hypothesis is that the mean values of the sliding window and right repository
+	 * are not statistically different. In addition, SeqDrift1 declares a warning
+	 * state depending on warning significance level and increases sample size to
+	 * get a statistically more rigorous mean value
+	 *
+	 *
+	 *
+	 * Sakthithasan, S., Pears, R., & Koh, Y. (2013). One Pass Concept Change
+	 * Detection for Data Streams. In J. Pei, V. Tseng, L. Cao, H. Motoda, & G. Xu
+	 * (Eds.), Advances in Knowledge Discovery and Data Mining (Vol. 7819, pp.
+	 * 461-472): Springer Berlin Heidelberg.
+	 *
+	 * @author Sakthithasan Sripirakas sripirakas363 at yahoo dot com
+	 */
+	public class SeqDrift1 extends AbstractMOAObject {
+
+		private Repository leftRepository = null;
+		private Repository rightRepository = null;
+		private ArrayList<Integer> uniqueRandomNumbers = null;
+
+		// parameters
+		private double significanceLevel = 0.01;
+		private int blockSize = 200;
+		private int sampleSize = 200;
+		private int slidingWindowBlockCount;
+		private double warningSignificanceLevel = 0.1;
+
+		// variables
+		private int instanceCount = 0;
+		private double leftRepositoryMean = 0.0;
+		private double rightRepositoryMean = 0.0;
+		private int blockCount = 0;
+		private double variance = 0.0;
+		private boolean isWarning = false;
+		private double total = 0.0;
+
+		private Epsilon epsilon = null;
+
+		public final static int DRIFT = 0;
+		public final static int WARNING = 1;
+		public final static int HOMOGENEOUS = 2;
+		public final static int INTERNAL_DRIFT = 3;
+
+		public SeqDrift1(double _significanceLevel, int _blockSize, double _significanceWarningLevel) {
+			// Parameters
+			significanceLevel = _significanceLevel;
+			blockSize = _blockSize;
+			sampleSize = _blockSize;
+			slidingWindowBlockCount = (int) (1 / _significanceLevel); // Sliding window size is automaticall set as
+																		// 1/delta
+			warningSignificanceLevel = _significanceWarningLevel;
+
+			// Variables
+			instanceCount = 0;
+			blockCount = 0;
+			variance = 0.0;
+			isWarning = false;
+			total = 0.0;
+			epsilon = new Epsilon();
+
+			// Data Structures
+			SeqDrift2ChangeDetector sd = new SeqDrift2ChangeDetector();
+			leftRepository = sd.new Repository(blockSize);
+			rightRepository = sd.new Repository(blockSize);
+
+			uniqueRandomNumbers = new ArrayList<>();
+		}
+
+		public boolean setInput(double _inputValue) {
+			++instanceCount;
+
+			addToRightRepository(_inputValue);
+			total = total + _inputValue;
+
+			if ((instanceCount % sampleSize) == 0) // Drift point check
+			{
+				rightRepository.markLastAddedBlock();
+
+				if (isWarning) {
+					removeExcessRightRepositoryValues();
+				}
+				// Assume that there is no warning or drift now
+				isWarning = false;
+
+				// Detect a drift with warning significance level
+				int iDriftType = getDriftType();
+
+				if (iDriftType == DRIFT) {
+					isWarning = false; // Warning state is set to false as it is an actual drift
+					clearLeftRepository();
+					moveValuesFromRightToLeft();
+					sampleSize = blockSize;
+					return true;
+				} else if (iDriftType == WARNING) {
+					isWarning = true;
+					sampleSize = sampleSize * 2;
+					return false;// In warning state no instance is moved from sliding window to repository. Thus
+									// returning now
+				} /*
+					 * else if(iDriftType == INTERNAL_DRIFT) { isWarning = false; isDrift = false;
+					 * sampleSize = blockSize; clearrepository(); //Due to drift clear the data that
+					 * belong to the old concept in repository movefromsliding windowTorepository();
+					 * return false; }
+					 */
+				else {
+					isWarning = false;
+					moveValuesFromRightToLeft(); // All instances in sliding window should be moved to repository if no
+													// drift or if drift but not in warning
+					return false;
+				}
+			}
+			return false;
+		}
+
+		/**
+		 * Adding new instance to sliding window
+		 * <p>
+		 * 
+		 * @param _inputValue A double instance
+		 * @return void
+		 */
+		private void addToRightRepository(double _inputValue) {
+			if ((rightRepository.getSize() < sampleSize) || isWarning) // By default sliding window should have maximum
+																		// of blockSize instances except in warning
+																		// state
+			{
+				rightRepository.add(new Double(_inputValue));
+			} else {
+				System.out.println("request to add to sliding window sliding window size :" + rightRepository.getSize()
+						+ " Warning :" + isWarning);
+			}
+		}
+
+		/**
+		 * Removes excess instances in sliding window when the number of blocks is more
+		 * than the sliding window size threshold
+		 * <p>
+		 * 
+		 * @param void
+		 * @return void
+		 */
+		private void removeExcessRightRepositoryValues() {
+			int maxRightRepositorySize = slidingWindowBlockCount * blockSize;
+			while (rightRepository.getSize() > maxRightRepositorySize) {
+				total = total - rightRepository.getFirstBlockTotal();
+				rightRepository.removeFirstBlock();
+			}
+		}
+
+		/**
+		 * Moving the instances from sliding window to repository
+		 * <p>
+		 * 
+		 * @param void
+		 * @return void
+		 */
+		private void moveValuesFromRightToLeft() {
+			for (int iIndex = 0; iIndex < rightRepository.getSize(); iIndex++) // Copy all instances from sliding window
+																				// to repository
+			{
+				if (((iIndex) % sampleSize) == 0) {
+					leftRepository.add(rightRepository.get(iIndex), true);
+				} else {
+					leftRepository.add(rightRepository.get(iIndex));
+				}
+			}
+			blockCount = blockCount + rightRepository.getSize() / blockSize; // Determine the block counter value after
+																				// adding the instances
+
+			if (slidingWindowBlockCount > 0) // Sliding is enabled
+			{
+				while (blockCount > slidingWindowBlockCount) // Remove old instances from repository
+				{
+					total = total - leftRepository.getFirstBlockTotal();
+					leftRepository.removeFirstBlock();
+					--blockCount;
+				}
+			}
+			if (!isWarning) // If in warning do not remove the instances from sliding window
+			{
+				rightRepository.removeAll();
+			} else {
+				System.out.println("ERROR: requested to move instances from  sliding window to  repository");
+				System.exit(2);
+			}
+		}
+
+		/**
+		 * Remove all elements from repository after a drift is detected
+		 * <p>
+		 * After deletion the block counter is set to zero
+		 *
+		 * @param void
+		 * @return void
+		 */
+		private void clearLeftRepository() {
+			blockCount = 0;
+			total = total - leftRepository.getTotal();
+			leftRepository.removeAll();
+		}
+
+		/**
+		 * Detects a drift
+		 * <p>
+		 * 
+		 * @param _bIsWarning Drift detection in warning significance level or actual
+		 *                    significance level
+		 * @return boolean True - if drift is detected. False - otherwise
+		 */
+		private int getDriftType() {
+			if (getWidth() > blockSize) {
+				leftRepositoryMean = getLeftRepositorySampleMean(); // Get the subsample mean from repository
+				rightRepositoryMean = getRightRepositorySampleMean(); // Get the subsample mean from sliding window
+				epsilon = getEpsilon();
+
+				double absValue = Math.abs(rightRepositoryMean - leftRepositoryMean);
+				if (instanceCount > sampleSize && leftRepository.getSize() > 0) {
+					if (epsilon.d_warningEpsilon <= absValue) // Warning Drift is detetced
+					{
+						if (epsilon.d_driftEpsilon <= absValue) // Drift is detetced
+						{
+							// if(rightRepositoryMean > leftRepositoryMean)
+							// {
+							return DRIFT;
+							// }
+							/*
+							 * else { return INTERNAL_DRIFT; }
+							 */
+						} else {
+							return WARNING;
+						}
+					} else {
+						return HOMOGENEOUS;
+					}
+				}
+				return HOMOGENEOUS;
+			} else {
+				return HOMOGENEOUS;
+			}
+		}
+
+		private double getLeftRepositorySampleMean() {
+			double leftTotal = 0.0;
+			if (leftRepository.getSize() > 0) {
+				if (leftRepository.getSize() <= sampleSize) {
+					return getLeftResitoryMean();
+				} else {
+					int iPossibleSampleSize = getPossibleSampleSize();
+
+					for (int iCount = 0; iCount < iPossibleSampleSize; iCount++) {
+						int iNextRandomNumber = getNextRandomNumber(leftRepository.getSize() - 1);
+						if (isUniqueRandomNumber(iNextRandomNumber)) {
+							leftTotal = leftTotal + leftRepository.get(iNextRandomNumber);
+						} else {
+							iCount--;
+						}
+					}
+					uniqueRandomNumbers.clear();
+				}
+			}
+			return leftTotal / sampleSize;
+		}
+
+		private int getPossibleSampleSize() {
+			int iNumberSampleElements = 0;
+			int leftResitorySize = leftRepository.getSize();
+			int rightRepositorySize = rightRepository.getSize();
+
+			if (sampleSize <= leftResitorySize && sampleSize <= rightRepositorySize) {
+				iNumberSampleElements = sampleSize;
+			} else {
+				if (leftResitorySize > rightRepositorySize) {
+					sampleSize = leftResitorySize;
+				} else {
+					sampleSize = rightRepositorySize;
+				}
+			}
+			return iNumberSampleElements;
+		}
+
+		private boolean isUniqueRandomNumber(int _iTrialNum) {
+			for (int iIndex = 0; iIndex < uniqueRandomNumbers.size(); iIndex++) {
+				if (uniqueRandomNumbers.get(iIndex) == _iTrialNum) {
+					return false;
+				}
+			}
+			uniqueRandomNumbers.add(_iTrialNum);
+			return true;
+		}
+
+		private double getLeftResitoryMean() {
+			double dTotal = 0.0;
+			dTotal = dTotal + leftRepository.getTotal();
+			return dTotal / sampleSize;
+		}
+
+		private double getRightRepositoryMean() {
+			double dTotal = 0.0;
+			dTotal = dTotal + rightRepository.getTotal();
+			return dTotal / sampleSize;
+		}
+
+		private double getRightRepositorySampleMean() {
+			double dTotal = 0.0;
+			if (rightRepository.getSize() > 0) {
+				if (rightRepository.getSize() <= sampleSize) {
+					return getRightRepositoryMean();
+				} else {
+					int iPossibleSampleSize = getPossibleSampleSize();
+					for (int iCount = 0; iCount < iPossibleSampleSize; iCount++) {
+						int iNextRandomNumber = getNextRandomNumber(rightRepository.getSize() - 1);
+						if (isUniqueRandomNumber(iNextRandomNumber)) {
+							dTotal = dTotal + rightRepository.get(iNextRandomNumber);
+						} else {
+							iCount--;
+						}
+					}
+					uniqueRandomNumbers.clear();
+				}
+			}
+			return dTotal / sampleSize;
+		}
+
+		private int getNextRandomNumber(int _iSize) {
+			double dRandomNumber = _iSize * Math.random();
+			long lRoundedNumber = Math.round(dRandomNumber);
+			return (int) lRoundedNumber;
+		}
+
+		private double getVariance() {
+			double dMean = getPopulationMean();
+			double d1minusMean = dMean - 1;
+			double dtotalsize = getWidth();
+			double x = total * d1minusMean * d1minusMean + (dtotalsize - total) * dMean * dMean;
+			double y = dtotalsize - 1;
+			return x / y;
+		}
+
+		private Epsilon getEpsilon() {
+			int iNumberOfTests = leftRepository.getNumOfTests() + rightRepository.getNumOfTests();
+
+			if (iNumberOfTests > 1) {
+				variance = getVariance();
+
+				// Drift epsilon
+				double ddeltadash = getDriftEpsilon(iNumberOfTests);
+				double x = Math.log(4.0 / ddeltadash);
+				double squareRootValue = Math.sqrt(x * x + 18 * variance * sampleSize * x);
+				double depsilon = (2.0 / (3 * sampleSize)) * (x + squareRootValue);
+				epsilon.d_driftEpsilon = depsilon;
+
+				// warning epsilon
+				ddeltadash = getWarningEpsilon(iNumberOfTests);
+				x = Math.log(4.0 / ddeltadash);
+				squareRootValue = Math.sqrt(x * x + 18 * variance * sampleSize * x);
+				depsilon = (2.0 / (3 * sampleSize)) * (x + squareRootValue);
+				epsilon.d_warningEpsilon = depsilon;
+			}
+			return epsilon;
+		}
+
+		private double getDriftEpsilon(int _inumTests) {
+			double errorValue = 2.0 * (1.0 - Math.pow(0.5, _inumTests));
+
+			double ddeltadash = significanceLevel;
+			ddeltadash = significanceLevel / errorValue;
+
+			return ddeltadash;
+		}
+
+		private double getWarningEpsilon(int _inumTests) {
+			double dTotalError = 2.0 * (1.0 - Math.pow(0.5, _inumTests));
+			double ddeltadash = warningSignificanceLevel / dTotalError;
+
+			return ddeltadash;
+		}
+
+		private double getPopulationMean() {
+			return getTotal() / getWidth();
+		}
+
+		private double getTotal() {
+			return total;
+		}
+
+		public int getWidth() {
+			return leftRepository.getSize() + rightRepository.getSize();
+		}
+
+		public double getEstimation() {
+			int iWidth = getWidth();
+
+			if (iWidth != 0) {
+				return getTotal() / getWidth();
+			} else {
+				return 0;
+			}
+		}
+
+		@Override
+		public void getDescription(StringBuilder sb, int indent) {
+		}
+
+	}
+
+	class Epsilon {
+
+		double d_warningEpsilon = 0.0;
+		double d_driftEpsilon = 0.0;
+
+		public Epsilon() {
+			d_warningEpsilon = 0.0;
+			d_driftEpsilon = 0.0;
+		}
+
+		public void getDescription(StringBuilder sb, int indent) {
+		}
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/driftdetection/SeqDrift2ChangeDetector.java b/moa/src/main/java/moa/learners/predictors/core/driftdetection/SeqDrift2ChangeDetector.java
new file mode 100644
index 000000000..5efb00d7b
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/driftdetection/SeqDrift2ChangeDetector.java
@@ -0,0 +1,584 @@
+/*
+ *    SeqDrift2ChangeDetector.java
+ *    Copyright (C) 2011 University of Waikato, Hamilton, New Zealand
+ *    @author Sakthithasan Sripirakas sripirakas363 at yahoo dot com
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package moa.learners.predictors.core.driftdetection;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+
+import moa.AbstractMOAObject;
+import moa.core.ObjectRepository;
+import moa.tasks.TaskMonitor;
+
+/**
+ * SeqDriftChangeDetector.java. This extends Abstract Change Detector as
+ * required by MOA.
+ *
+ * Pears, R., Sakthithasan, S., & Koh, Y. (2014). Detecting concept change in
+ * dynamic data streams. Machine Learning, 97(3), 259-293.
+ * doi:10.1007/s10994-013-5433-9
+ *
+ * @author Sakthithasan Sripirakas sripirakas363 at yahoo dot com
+ * @version $Revision: 7 $
+ */
+public class SeqDrift2ChangeDetector extends AbstractChangeDetector {
+
+	protected SeqDrift2 seqdrift;
+
+	public FloatOption deltaSeqDrift2Option = new FloatOption("deltaSeq2Drift", 'd',
+			"Delta of SeqDrift2 change detection", 0.01, 0.0, 1.0);
+
+	public IntOption blockSeqDrift2Option = new IntOption("blockSeqDrift2Option", 'b',
+			"Block size of SeqDrift2 change detector", 200, 100, 10000);
+
+	@Override
+	public void input(double inputValue) {
+		if (this.seqdrift == null) {
+			resetLearning();
+		}
+		this.isChangeDetected = seqdrift.setInput(inputValue);
+		this.isWarningZone = false;
+		this.delay = 0.0;
+		this.estimation = seqdrift.getEstimation();
+	}
+
+	@Override
+	public void resetLearning() {
+		seqdrift = new SeqDrift2(this.deltaSeqDrift2Option.getValue(), (this.blockSeqDrift2Option.getValue()));
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// TODO Auto-generated method stub
+	}
+
+	/**
+	 * SeqDrift2 uses reservoir sampling to build a sequential change detection
+	 * model that uses statistically sound guarantees defined using Bernstein Bound
+	 * on false positive and false negative rates. This is a block based approach
+	 * and checks for changes in the data values only at block boundaries as opposed
+	 * to the methods on per instance basis. SeqDrift maintains a reservoir and a
+	 * repository. Repository gathers the new instances and reservoir stores only
+	 * the data values that are statistically not different, in other words from the
+	 * same distribution. If the data values in the repository are consistent with
+	 * the values in reservoir, the data values of the repository are copied to the
+	 * reservoir applying reservoir algorithm.The hypothesis is that the mean values
+	 * of the reservoir and right repository are not statistically different
+	 * 
+	 * 
+	 * 
+	 * Pears, R., Sakthithasan, S., & Koh, Y. (2014). Detecting concept change in
+	 * dynamic data streams. Machine Learning, 97(3), 259-293.
+	 * doi:10.1007/s10994-013-5433-9
+	 * 
+	 * @author Sakthithasan Sripirakas sripirakas363 at yahoo dot com
+	 */
+	public class SeqDrift2 extends AbstractMOAObject {
+
+		private final Reservoir rightRepository;
+		private final Reservoir leftReservoir;
+
+		// parameters
+		private final int blockSize;
+
+		// parameters that are optimized
+		private final double significanceLevel;
+		private int leftReservoirSize;
+		private final int rightRepositorySize;
+		private final double k;
+
+		// variables
+		private int instanceCount = 0;
+		private double leftReservoirMean = 0.0;
+		private double rightRepositoryMean = 0.0;
+		private double variance = 0.0;
+		private double total = 0.0;
+		private double epsilon = 0.0;
+
+		private final static int DRIFT = 0;
+		private final static int NODRIFT = 2;
+		private final static int INTERNAL_DRIFT = 3;
+
+		/**
+		 * SeqDrift change detector requires two parameters: significance level and
+		 * block size. Significance level controls the false positive rate and block
+		 * size sets the interval of two consecutive hypothesis tests Block Size is a
+		 * positive integer and significance level is a double value between 0 and 1
+		 * 
+		 * @param _significanceLevel
+		 * @param _blockSize
+		 */
+		public SeqDrift2(double _significanceLevel, int _blockSize) {
+			significanceLevel = _significanceLevel;
+			blockSize = _blockSize;
+			leftReservoirSize = _blockSize;
+			rightRepositorySize = _blockSize;
+			k = 0.5;
+
+			instanceCount = 0;
+			variance = 0;
+			total = 0.0;
+			epsilon = 0.0;
+
+			// Data Structures
+			leftReservoir = new Reservoir(leftReservoirSize, blockSize);
+			rightRepository = new Reservoir(rightRepositorySize, blockSize);
+		}
+
+		/**
+		 * This method can be used to directly interface with SeqDrift change detector.
+		 * This method requires a numerical value as an input. The return value
+		 * indicates whether there is a change detected or not.
+		 * 
+		 * @param input numerical value
+		 */
+		public boolean setInput(double _inputValue) {
+			++instanceCount;
+			// i_numInstances++;
+
+			addToRightReservoir(_inputValue);
+			total = total + _inputValue;
+
+			if ((instanceCount % blockSize) == 0) // checking for drift at block boundary
+			{
+				int iDriftType = getDriftType();
+
+				if (iDriftType == DRIFT) {
+					clearLeftReservoir();
+					moveFromRepositoryToReservoir();
+					return true;
+				}
+				/*
+				 * else if (iDriftType == INTERNAL_DRIFT) { //Ignoring the changes where mean
+				 * values decrease clearLeftReservoir(); moveFromRepositoryToReservoir(); return
+				 * false; }
+				 */
+				else // No drift is detected
+				{
+					moveFromRepositoryToReservoir();
+					return false;
+				}
+			}
+			return false;
+		}
+
+		/**
+		 *
+		 * <p>
+		 * This method adds new value to right reservoir
+		 *
+		 * @param _inputValue A double data value
+		 * @return void
+		 */
+		private void addToRightReservoir(double _inputValue) {
+			rightRepository.addElement(_inputValue);
+		}
+
+		/**
+		 *
+		 * <p>
+		 * This method copies the data values of the repository to the reservoir
+		 * applying reservoir algorithm
+		 *
+		 * @param void
+		 * @return void
+		 */
+		private void moveFromRepositoryToReservoir() {
+			leftReservoir.copy(rightRepository);
+		}
+
+		/**
+		 *
+		 * <p>
+		 * This method removes all elements from the reservoir after a drift is
+		 * detected.
+		 *
+		 * @param void
+		 * @return void
+		 */
+		private void clearLeftReservoir() {
+			total = total - leftReservoir.getTotal();
+			leftReservoir.clear();
+		}
+
+		/**
+		 *
+		 * <p>
+		 * This method returns the type of drift detected The possible values are:
+		 * DRIFT, INTERNAL_DRIFT and NODRIFT
+		 *
+		 * @param
+		 * @return boolean True - if drift is detected. False - otherwise
+		 */
+		private int getDriftType() {
+			if (getWidth() > blockSize) {
+				leftReservoirMean = getLeftReservoirMean();
+				rightRepositoryMean = getRightRepositoryMean();
+				optimizeEpsilon();
+
+				if ((instanceCount > blockSize) && (leftReservoir.getSize() > 0)) {
+					if (epsilon <= Math.abs(rightRepositoryMean - leftReservoirMean)) {
+						// if (rightRepositoryMean > leftReservoirMean) {
+						return DRIFT;
+						// }
+						/*
+						 * else { return INTERNAL_DRIFT; }
+						 */
+					} else {
+						return NODRIFT;
+					}
+				}
+				return NODRIFT;
+			} else {
+				return NODRIFT;
+			}
+		}
+
+		private double getLeftReservoirMean() {
+			return leftReservoir.getSampleMean();
+		}
+
+		private double getRightRepositoryMean() {
+			return rightRepository.getSampleMean();
+		}
+
+		private double getVariance() {
+			double mean = getMean();
+			double meanminum1 = mean - 1;
+			double size = getWidth();
+			double x = getTotal() * meanminum1 * meanminum1 + (size - getTotal()) * mean * mean;
+			double y = size - 1;
+			return x / y;
+		}
+
+		private void optimizeEpsilon() {
+			int tests = leftReservoir.getSize() / blockSize;
+
+			if (tests >= 1) {
+				variance = getVariance();
+				if (variance == 0) {
+					variance = 0.0001; // to avoid divide by zero exception
+				}
+
+				// Drift epsilon
+				double ddeltadash = getDriftEpsilon(tests);
+				double x = Math.log(4.0 / ddeltadash);
+				double ktemp = this.k;
+
+				double previousStepEpsilon;
+				double currentStepEpsilon;
+				double squareRootValue = 0.0;
+
+				boolean IsNotOptimized = true;
+				while (IsNotOptimized) {
+					squareRootValue = Math.sqrt(x * x + 18 * rightRepositorySize * x * variance);
+					previousStepEpsilon = (1.0 / (3 * rightRepositorySize * (1 - ktemp))) * (x + squareRootValue);
+					ktemp = 3 * ktemp / 4;
+					currentStepEpsilon = (1.0 / (3 * rightRepositorySize * (1 - ktemp))) * (x + squareRootValue);
+
+					if (((previousStepEpsilon - currentStepEpsilon) / previousStepEpsilon) < 0.0001) {
+						IsNotOptimized = false;
+					}
+				}
+				ktemp = 4 * ktemp / 3;
+				ktemp = adjustForDataRate(ktemp);
+				leftReservoirSize = (int) (rightRepositorySize * (1 - ktemp) / ktemp);
+				leftReservoir.setMaxSize(leftReservoirSize);
+				squareRootValue = Math.sqrt(x * x + 18 * rightRepositorySize * x * variance);
+				currentStepEpsilon = (1.0 / (3 * rightRepositorySize * (1 - ktemp))) * (x + squareRootValue);
+				epsilon = currentStepEpsilon;
+
+			}
+		}
+
+		private double getDriftEpsilon(int _inumTests) {
+			double dSeriesTotal = 2.0 * (1.0 - Math.pow(0.5, _inumTests));
+			double ddeltadash = significanceLevel / dSeriesTotal;
+			return ddeltadash;
+		}
+
+		private double getMean() {
+			return getTotal() / getWidth();
+		}
+
+		private double getTotal() {
+			return rightRepository.getTotal() + leftReservoir.getTotal();
+		}
+
+		private double adjustForDataRate(double _dKr) {
+			double meanIncrease = (rightRepository.getSampleMean() - leftReservoir.getSampleMean());
+			double dk = _dKr;
+			if (meanIncrease > 0) {
+				dk = dk + ((-1) * (meanIncrease * meanIncrease * meanIncrease * meanIncrease) + 1) * _dKr;
+			} else if (meanIncrease <= 0) {
+				dk = _dKr;
+			}
+			return dk;
+		}
+
+		private int getWidth() {
+			return leftReservoir.getSize() + rightRepository.getSize();
+		}
+
+		/**
+		 * Gets the prediction of next values.
+		 * 
+		 * @return Predicted value of next data value
+		 */
+		public double getEstimation() {
+			int iWidth = getWidth();
+
+			if (iWidth != 0) {
+				return getTotal() / getWidth();
+			} else {
+				return 0;
+			}
+		}
+
+		@Override
+		public void getDescription(StringBuilder sb, int indent) {
+		}
+
+	}
+
+	public class Reservoir {
+
+		private int size;
+		private double total;
+		private final int blocksize;
+		private final Repository dataContainer;
+		private int instanceCount;
+		private int MAX_SIZE;
+
+		public Reservoir(int _iSize, int _iBlockSize) {
+			MAX_SIZE = _iSize;
+			total = 0;
+			blocksize = _iBlockSize;
+			instanceCount = 0;
+			dataContainer = new Repository(blocksize);
+		}
+
+		public double getSampleMean() {
+			return total / size;
+		}
+
+		public void addElement(double _dValue) {
+			try {
+				if (size < MAX_SIZE) {
+					dataContainer.add(new Double(_dValue));
+					total = total + _dValue;
+					size++;
+				} else {
+					int irIndex = (int) (Math.random() * instanceCount);
+					if (irIndex < MAX_SIZE) {
+						total = total - dataContainer.get(irIndex);
+						dataContainer.addAt(irIndex, _dValue);
+						total = total + _dValue;
+					}
+				}
+				instanceCount++;
+			} catch (Exception e) {
+				System.out.println("2 Exception" + e);
+			}
+
+		}
+
+		public double get(int _iIndex) {
+			return dataContainer.get(_iIndex);
+		}
+
+		public int getSize() {
+			return size;
+		}
+
+		public void clear() {
+			dataContainer.removeAll();
+			total = 0;
+			size = 0;
+		}
+
+		public double getTotal() {
+			return total;
+		}
+
+		public void copy(Reservoir _oSource) {
+			for (int iIndex = 0; iIndex < _oSource.getSize(); iIndex++) {
+				addElement(_oSource.get(iIndex));
+			}
+			_oSource.clear();
+		}
+
+		public void setMaxSize(int _iMaxSize) {
+			MAX_SIZE = _iMaxSize;
+		}
+
+	}
+
+	public class Repository {
+
+		private final int blockSize;
+		private final List<Block> blocks;
+		private int indexOfLastBlock;
+		private int instanceCount;
+		private double total;
+
+		public Repository(int _iBlockSize) {
+			blockSize = _iBlockSize;
+			indexOfLastBlock = -1;
+			instanceCount = 0;
+			total = 0;
+			blocks = new ArrayList<>();
+		}
+
+		public void add(double _dValue) {
+			if ((instanceCount % blockSize) == 0) {
+				blocks.add(new Block(blockSize));
+				indexOfLastBlock++;
+			}
+			blocks.get(indexOfLastBlock).add(_dValue);
+			instanceCount++;
+			total = total + _dValue;
+		}
+
+		public void add(double _dValue, boolean _isTested) {
+			if ((instanceCount % blockSize) == 0) {
+				blocks.add(new Block(blockSize, _isTested));
+				indexOfLastBlock++;
+			}
+			blocks.get(indexOfLastBlock).add(_dValue);
+			instanceCount++;
+			total = total + _dValue;
+		}
+
+		public double get(int _iIndex) {
+			return blocks.get(_iIndex / blockSize).data[(_iIndex % blockSize)];
+		}
+
+		public void addAt(int _iIndex, double _dValue) {
+			blocks.get(_iIndex / blockSize).addAt(_iIndex % blockSize, _dValue);
+		}
+
+		public int getSize() {
+			return instanceCount;
+		}
+
+		public double getTotal() {
+			double dTotal = 0.0;
+			for (int iIndex = 0; iIndex < blocks.size(); iIndex++) {
+				dTotal = dTotal + blocks.get(iIndex).total;
+			}
+			return dTotal;
+		}
+
+		public double getFirstBlockTotal() {
+			return blocks.get(0).total;
+
+		}
+
+		public void markLastAddedBlock() {
+			if (blocks.size() > 0) {
+				blocks.get(blocks.size() - 1).setTested(true);
+			}
+		}
+
+		public void removeFirstBlock() {
+			total = total - blocks.get(0).total;
+			blocks.remove(0);
+			instanceCount = instanceCount - blockSize;
+			indexOfLastBlock--;
+		}
+
+		public void removeAll() {
+			blocks.clear();
+			indexOfLastBlock = -1;
+			instanceCount = 0;
+			total = 0;
+		}
+
+		public int getNumOfTests() {
+			int iNumTests = 0;
+			for (int iIndex = 0; iIndex < blocks.size(); iIndex++) {
+				if (blocks.get(iIndex).IsTested())
+					iNumTests++;
+			}
+			return iNumTests;
+		}
+
+	}
+
+	public class Block {
+
+		public double[] data;
+		public double total;
+		private int indexOfLastValue;
+
+		private boolean b_IsTested;
+
+		Block(int _iLength) {
+			data = new double[_iLength];
+			total = 0.0;
+			indexOfLastValue = 0;
+			for (int iIndex = 0; iIndex < data.length; iIndex++) {
+				data[iIndex] = -1;
+			}
+		}
+
+		Block(int _iLength, boolean _isTested) {
+			data = new double[_iLength];
+			total = 0.0;
+			indexOfLastValue = 0;
+			b_IsTested = _isTested;
+			for (int iIndex = 0; iIndex < data.length; iIndex++) {
+				data[iIndex] = -1;
+			}
+		}
+
+		public void add(double _dValue) {
+			if (indexOfLastValue < data.length) {
+				data[indexOfLastValue] = _dValue;
+				total = total + _dValue;
+				indexOfLastValue++;
+			} else {
+				System.out.println("ERROR in adding to Block. Last Index :" + indexOfLastValue + " Total :" + total
+						+ " Array Length :" + data.length);
+				System.exit(2);
+			}
+		}
+
+		public void addAt(int _iIndex, double _dNewValue) {
+			total = total - data[_iIndex] + _dNewValue;
+			data[_iIndex] = _dNewValue;
+		}
+
+		public void setTested(boolean _isTested) {
+			b_IsTested = _isTested;
+		}
+
+		public boolean IsTested() {
+			return b_IsTested;
+		}
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiLabelErrorMeasurer.java b/moa/src/main/java/moa/learners/predictors/core/errormeasurers/AbstractMultiLabelErrorMeasurer.java
similarity index 73%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiLabelErrorMeasurer.java
rename to moa/src/main/java/moa/learners/predictors/core/errormeasurers/AbstractMultiLabelErrorMeasurer.java
index bd098cd80..d270c1fe3 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiLabelErrorMeasurer.java
+++ b/moa/src/main/java/moa/learners/predictors/core/errormeasurers/AbstractMultiLabelErrorMeasurer.java
@@ -17,7 +17,7 @@
  *
  *
  */
-package moa.classifiers.rules.multilabel.errormeasurers;
+package moa.learners.predictors.core.errormeasurers;
 
 import com.github.javacliparser.FloatOption;
 import com.yahoo.labs.samoa.instances.Instance;
@@ -27,48 +27,51 @@
 import moa.options.AbstractOptionHandler;
 import moa.tasks.TaskMonitor;
 
-
-
-
-
-public abstract class AbstractMultiLabelErrorMeasurer  extends AbstractOptionHandler implements MultiTargetErrorMeasurer{
+public abstract class AbstractMultiLabelErrorMeasurer extends AbstractOptionHandler
+		implements MultiTargetErrorMeasurer {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
-	
-	public FloatOption fadingErrorFactorOption = new FloatOption(
-			"fadingErrorFactor", 'f', 
+
+	public FloatOption fadingErrorFactorOption = new FloatOption("fadingErrorFactor", 'f',
 			"Fading factor for the error", 0.99, 0, 1);
-	
+
 	protected double fadingErrorFactor;
-	
+
+	@Override
 	abstract public void addPrediction(Prediction prediction, Prediction trueClass, double weight);
-	
-	public void addPrediction(Prediction prediction, Prediction trueClass){
-		addPrediction(prediction, trueClass,1.0);
+
+	@Override
+	public void addPrediction(Prediction prediction, Prediction trueClass) {
+		addPrediction(prediction, trueClass, 1.0);
 	}
-	
+
+	@Override
 	abstract public void addPrediction(Prediction prediction, Instance inst);
-	
+
+	@Override
 	abstract public double getCurrentError();
-	
+
+	@Override
 	abstract public double getCurrentError(int index);
-	
-	abstract public double [] getCurrentErrors();
-	
+
+	@Override
+	abstract public double[] getCurrentErrors();
+
 	public AbstractMultiLabelErrorMeasurer() {
-		fadingErrorFactor=fadingErrorFactorOption.getValue();
+		fadingErrorFactor = fadingErrorFactorOption.getValue();
 	}
-	
+
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
-		
+
 	}
+
 	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,ObjectRepository repository) {
-		
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+
 	}
 
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiTargetErrorMeasurer.java b/moa/src/main/java/moa/learners/predictors/core/errormeasurers/AbstractMultiTargetErrorMeasurer.java
similarity index 80%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiTargetErrorMeasurer.java
rename to moa/src/main/java/moa/learners/predictors/core/errormeasurers/AbstractMultiTargetErrorMeasurer.java
index 9e2644738..1fc7e1875 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/AbstractMultiTargetErrorMeasurer.java
+++ b/moa/src/main/java/moa/learners/predictors/core/errormeasurers/AbstractMultiTargetErrorMeasurer.java
@@ -17,23 +17,25 @@
  *
  *
  */
-package moa.classifiers.rules.multilabel.errormeasurers;
+package moa.learners.predictors.core.errormeasurers;
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-public abstract class AbstractMultiTargetErrorMeasurer extends AbstractMultiLabelErrorMeasurer implements MultiLabelErrorMeasurer{
+public abstract class AbstractMultiTargetErrorMeasurer extends AbstractMultiLabelErrorMeasurer
+		implements MultiLabelErrorMeasurer {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 
-	public void addPrediction(Prediction prediction, Instance inst){
-		int numOutputs=inst.numOutputAttributes();
-		Prediction trueClass= new MultiLabelClassificationPrediction(numOutputs);
-		for (int i=0; i<numOutputs; i++){
+	@Override
+	public void addPrediction(Prediction prediction, Instance inst) {
+		int numOutputs = inst.numOutputAttributes();
+		Prediction trueClass = new MultiLabelClassificationPrediction(numOutputs);
+		for (int i = 0; i < numOutputs; i++) {
 			trueClass.setVote(i, inst.valueOutputAttribute(i));
 		}
 		addPrediction(prediction, trueClass, inst.weight());
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/MeanAbsoluteDeviationMT.java b/moa/src/main/java/moa/learners/predictors/core/errormeasurers/MeanAbsoluteDeviationMT.java
similarity index 58%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/MeanAbsoluteDeviationMT.java
rename to moa/src/main/java/moa/learners/predictors/core/errormeasurers/MeanAbsoluteDeviationMT.java
index 511bf01e4..9e3208d60 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/MeanAbsoluteDeviationMT.java
+++ b/moa/src/main/java/moa/learners/predictors/core/errormeasurers/MeanAbsoluteDeviationMT.java
@@ -17,71 +17,69 @@
  *
  *
  */
-package moa.classifiers.rules.multilabel.errormeasurers;
+package moa.learners.predictors.core.errormeasurers;
 
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-
 /**
  * Mean Absolute Deviation for multitarget and with fading factor
  */
 
-
 public class MeanAbsoluteDeviationMT extends AbstractMultiTargetErrorMeasurer {
 
 	/**
-	 * 
+	 *
 	 */
 	protected double weightSeen;
-	protected double [] sumError;
+	protected double[] sumError;
 	private static final long serialVersionUID = 1L;
 	protected boolean hasStarted;
 	protected int numLearnedOutputs;
 
 	@Override
 	public void addPrediction(Prediction prediction, Prediction trueClass, double weight) {
-		int numOutputs=prediction.numOutputAttributes();
-		if (!hasStarted){
-			sumError=new double[numOutputs];
-			hasStarted=true;
-			for(int i=0; i<numOutputs;i++)
-				if(prediction.hasVotesForAttribute(i))
+		int numOutputs = prediction.numOutputAttributes();
+		if (!hasStarted) {
+			sumError = new double[numOutputs];
+			hasStarted = true;
+			for (int i = 0; i < numOutputs; i++)
+				if (prediction.hasVotesForAttribute(i))
 					++numLearnedOutputs;
-			hasStarted=true;
+			hasStarted = true;
 		}
-		for(int i=0; i<numOutputs;i++){
-			if(prediction.hasVotesForAttribute(i))
-				sumError[i]=Math.abs(prediction.getVote(i, 0)-trueClass.getVote(i, 0))*weight+fadingErrorFactor*sumError[i];
+		for (int i = 0; i < numOutputs; i++) {
+			if (prediction.hasVotesForAttribute(i))
+				sumError[i] = Math.abs(prediction.getPrediction(i) - trueClass.getPrediction(i)) * weight
+						+ fadingErrorFactor * sumError[i];
 		}
-		weightSeen=weight+fadingErrorFactor*weightSeen;
+		weightSeen = weight + fadingErrorFactor * weightSeen;
 	}
 
 	@Override
 	public double getCurrentError() {
-		if(weightSeen==0)
+		if (weightSeen == 0)
 			return Double.MAX_VALUE;
-		else
-		{
-			double sum=0;
-			int numOutputs=sumError.length;
-			for (int i=0; i<numOutputs; i++)
-				sum+=sumError[i];
-			return sum/(weightSeen*numLearnedOutputs);
+		else {
+			double sum = 0;
+			int numOutputs = sumError.length;
+			for (int i = 0; i < numOutputs; i++)
+				sum += sumError[i];
+			return sum / (weightSeen * numLearnedOutputs);
 		}
 	}
 
 	@Override
 	public double getCurrentError(int index) {
-		return sumError[index]/weightSeen;
+		return sumError[index] / weightSeen;
 	}
 
 	@Override
 	public double[] getCurrentErrors() {
-		double [] errors=null;
-		if(sumError!=null){
-			errors=new double[sumError.length];
-			for (int i=0;i<sumError.length; i++)
-				errors[i]=sumError[i]/weightSeen;
+		double[] errors = null;
+		if (sumError != null) {
+			errors = new double[sumError.length];
+			for (int i = 0; i < sumError.length; i++)
+				errors[i] = sumError[i] / weightSeen;
 		}
 		return errors;
 	}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/MultiLabelErrorMeasurer.java b/moa/src/main/java/moa/learners/predictors/core/errormeasurers/MultiLabelErrorMeasurer.java
similarity index 70%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/MultiLabelErrorMeasurer.java
rename to moa/src/main/java/moa/learners/predictors/core/errormeasurers/MultiLabelErrorMeasurer.java
index f7b0c0815..c6a41e66f 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/MultiLabelErrorMeasurer.java
+++ b/moa/src/main/java/moa/learners/predictors/core/errormeasurers/MultiLabelErrorMeasurer.java
@@ -18,7 +18,7 @@
  *
  */
 
-package moa.classifiers.rules.multilabel.errormeasurers;
+package moa.learners.predictors.core.errormeasurers;
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
@@ -27,16 +27,16 @@
 
 public interface MultiLabelErrorMeasurer extends OptionHandler {
 
-	public void addPrediction(Prediction prediction, Prediction trueClass, double weight);
+	void addPrediction(Prediction prediction, Prediction trueClass, double weight);
 
-	public void addPrediction(Prediction prediction, Prediction trueClass);
+	void addPrediction(Prediction prediction, Prediction trueClass);
 
-	public void addPrediction(Prediction prediction, Instance inst);
+	void addPrediction(Prediction prediction, Instance inst);
 
-	public double getCurrentError();
+	double getCurrentError();
 
-	public double getCurrentError(int index);
+	double getCurrentError(int index);
 
-	public double [] getCurrentErrors();
+	double[] getCurrentErrors();
 
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/MultiTargetErrorMeasurer.java b/moa/src/main/java/moa/learners/predictors/core/errormeasurers/MultiTargetErrorMeasurer.java
similarity index 93%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/MultiTargetErrorMeasurer.java
rename to moa/src/main/java/moa/learners/predictors/core/errormeasurers/MultiTargetErrorMeasurer.java
index da05ee7f0..011d4642e 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/MultiTargetErrorMeasurer.java
+++ b/moa/src/main/java/moa/learners/predictors/core/errormeasurers/MultiTargetErrorMeasurer.java
@@ -17,7 +17,7 @@
  *
  *
  */
-package moa.classifiers.rules.multilabel.errormeasurers;
+package moa.learners.predictors.core.errormeasurers;
 
 public interface MultiTargetErrorMeasurer extends MultiLabelErrorMeasurer {
 
diff --git a/moa/src/main/java/moa/learners/predictors/core/errormeasurers/RelativeMeanAbsoluteDeviationMT.java b/moa/src/main/java/moa/learners/predictors/core/errormeasurers/RelativeMeanAbsoluteDeviationMT.java
new file mode 100644
index 000000000..d4d13df2b
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/errormeasurers/RelativeMeanAbsoluteDeviationMT.java
@@ -0,0 +1,100 @@
+/*
+ *    RelativeMeanAbsoluteDeviationMT.java
+ *    Copyright (C) 2017 University of Porto, Portugal
+ *    @author J. Duarte, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.predictors.core.errormeasurers;
+
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+/**
+ * Relative Mean Absolute Deviation for multitarget and with fading factor
+ */
+
+public class RelativeMeanAbsoluteDeviationMT extends AbstractMultiTargetErrorMeasurer {
+
+	/**
+	 *
+	 */
+	protected double weightSeen;
+	protected double[] sumError;
+
+	protected double[] sumY;
+	protected double[] sumErrorToTargetMean;
+
+	private static final long serialVersionUID = 1L;
+	protected boolean hasStarted;
+	protected int numLearnedOutputs;
+
+	@Override
+	public void addPrediction(Prediction prediction, Prediction trueClass, double weight) {
+		int numOutputs = prediction.numOutputAttributes();
+		if (!hasStarted) {
+			sumError = new double[numOutputs];
+			sumY = new double[numOutputs];
+			sumErrorToTargetMean = new double[numOutputs];
+			hasStarted = true;
+			for (int i = 0; i < numOutputs; i++)
+				if (prediction.hasVotesForAttribute(i))
+					++numLearnedOutputs;
+			hasStarted = true;
+		}
+		weightSeen = weight + fadingErrorFactor * weightSeen;
+		for (int i = 0; i < numOutputs; i++) {
+			if (prediction.hasVotesForAttribute(i)) {
+				sumError[i] = Math.abs(prediction.getPrediction(i) - trueClass.getPrediction(i)) * weight
+						+ fadingErrorFactor * sumError[i];
+				sumY[i] = trueClass.getPrediction(i) * weight + fadingErrorFactor * sumY[i];
+				double errorOutputTM = Math.abs(prediction.getPrediction(i) - sumY[i] / weightSeen); // error to target
+																									// mean
+				sumErrorToTargetMean[i] = errorOutputTM * weight + fadingErrorFactor * sumErrorToTargetMean[i];
+			}
+		}
+
+	}
+
+	@Override
+	public double getCurrentError() {
+		if (weightSeen == 0)
+			return Double.MAX_VALUE;
+		else {
+			double sum = 0;
+			int numOutputs = sumError.length;
+			for (int i = 0; i < numOutputs; i++)
+				sum += getCurrentError(i);
+			return sum / numLearnedOutputs;
+		}
+	}
+
+	@Override
+	public double getCurrentError(int index) {
+		return sumError[index] / sumErrorToTargetMean[index];
+	}
+
+	@Override
+	public double[] getCurrentErrors() {
+		double[] errors = null;
+		if (sumError != null) {
+			errors = new double[sumError.length];
+			for (int i = 0; i < sumError.length; i++)
+				errors[i] = getCurrentError(i);
+		}
+		return errors;
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/errormeasurers/RelativeRootMeanSquaredErrorMT.java b/moa/src/main/java/moa/learners/predictors/core/errormeasurers/RelativeRootMeanSquaredErrorMT.java
new file mode 100644
index 000000000..7b3a1781d
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/errormeasurers/RelativeRootMeanSquaredErrorMT.java
@@ -0,0 +1,97 @@
+/*
+ *    RelativeRootMeanSquaredErrorMT.java
+ *    Copyright (C) 2017 University of Porto, Portugal
+ *    @author J. Duarte, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.predictors.core.errormeasurers;
+
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+/**
+ * Relative Root Mean Squared Error for multitarget and with fading factor
+ */
+
+public class RelativeRootMeanSquaredErrorMT extends AbstractMultiTargetErrorMeasurer {
+
+	/**
+	 *
+	 */
+	protected double weightSeen;
+	protected double[] sumY;
+	protected double[] sumSquaredError;
+	protected double[] sumSquaredErrorToTargetMean;
+	protected static final long serialVersionUID = 1L;
+	protected boolean hasStarted;
+	protected int numLearnedOutputs;
+
+	@Override
+	public void addPrediction(Prediction prediction, Prediction trueClass, double weight) {
+		int numOutputs = prediction.numOutputAttributes();
+		if (!hasStarted) {
+			sumSquaredError = new double[numOutputs];
+			sumY = new double[numOutputs];
+			sumSquaredErrorToTargetMean = new double[numOutputs];
+			hasStarted = true;
+			for (int i = 0; i < numOutputs; i++)
+				if (prediction.hasVotesForAttribute(i))
+					++numLearnedOutputs;
+			hasStarted = true;
+		}
+		weightSeen = weight + fadingErrorFactor * weightSeen;
+		for (int i = 0; i < numOutputs; i++) {
+			if (prediction.hasVotesForAttribute(i)) {
+				sumY[i] = trueClass.getPrediction(i) * weight + fadingErrorFactor * sumY[i]; // sum target
+				double errorOutput = prediction.getPrediction(i) - trueClass.getPrediction(i);
+				double errorOutputTM = prediction.getPrediction(i) - sumY[i] / weightSeen; // error to target mean
+				sumSquaredError[i] = errorOutput * errorOutput * weight + fadingErrorFactor * sumSquaredError[i];
+				sumSquaredErrorToTargetMean[i] = errorOutputTM * errorOutputTM * weight
+						+ fadingErrorFactor * sumSquaredErrorToTargetMean[i];
+			}
+		}
+
+	}
+
+	@Override
+	public double getCurrentError() {
+		if (weightSeen == 0)
+			return Double.MAX_VALUE;
+		else {
+			double sum = 0;
+			int numOutputs = sumSquaredError.length;
+			for (int i = 0; i < numOutputs; i++)
+				sum += Math.sqrt(sumSquaredError[i] / sumSquaredErrorToTargetMean[i]);
+			return sum / numLearnedOutputs;
+		}
+	}
+
+	@Override
+	public double getCurrentError(int index) {
+		return Math.sqrt(sumSquaredError[index] / sumSquaredErrorToTargetMean[index]);
+	}
+
+	@Override
+	public double[] getCurrentErrors() {
+		double[] errors = null;
+		if (sumSquaredError != null) {
+			errors = new double[sumSquaredError.length];
+			for (int i = 0; i < sumSquaredError.length; i++)
+				errors[i] = getCurrentError(i);
+		}
+		return errors;
+	}
+
+}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/RootMeanSquaredErrorMT.java b/moa/src/main/java/moa/learners/predictors/core/errormeasurers/RootMeanSquaredErrorMT.java
similarity index 55%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/RootMeanSquaredErrorMT.java
rename to moa/src/main/java/moa/learners/predictors/core/errormeasurers/RootMeanSquaredErrorMT.java
index 21f5c25b5..5b8fa4d28 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/errormeasurers/RootMeanSquaredErrorMT.java
+++ b/moa/src/main/java/moa/learners/predictors/core/errormeasurers/RootMeanSquaredErrorMT.java
@@ -18,7 +18,7 @@
  *
  */
 
-package moa.classifiers.rules.multilabel.errormeasurers;
+package moa.learners.predictors.core.errormeasurers;
 
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
@@ -26,67 +26,64 @@
  * Root Mean Squared Error for multitarget and with fading factor
  */
 
-
 public class RootMeanSquaredErrorMT extends AbstractMultiTargetErrorMeasurer {
 
 	/**
-	 * 
+	 *
 	 */
 	private double weightSeen;
-	private double [] sumSquaredError;
+	private double[] sumSquaredError;
 	private static final long serialVersionUID = 1L;
 	protected boolean hasStarted;
 	protected int numLearnedOutputs;
 
 	@Override
 	public void addPrediction(Prediction prediction, Prediction trueClass, double weight) {
-		int numOutputs=prediction.numOutputAttributes();
-		if (!hasStarted){
-			sumSquaredError=new double[numOutputs];
-			hasStarted=true;
-			for(int i=0; i<numOutputs;i++)
-				if(prediction.hasVotesForAttribute(i))
+		int numOutputs = prediction.numOutputAttributes();
+		if (!hasStarted) {
+			sumSquaredError = new double[numOutputs];
+			hasStarted = true;
+			for (int i = 0; i < numOutputs; i++)
+				if (prediction.hasVotesForAttribute(i))
 					++numLearnedOutputs;
-			hasStarted=true;
+			hasStarted = true;
 		}
-		for(int i=0; i<numOutputs;i++){
-			if(prediction.hasVotesForAttribute(i)){
-				double errorOutput=prediction.getVote(i, 0)-trueClass.getVote(i, 0);
-				sumSquaredError[i]=errorOutput*errorOutput*weight+fadingErrorFactor*sumSquaredError[i];
+		for (int i = 0; i < numOutputs; i++) {
+			if (prediction.hasVotesForAttribute(i)) {
+				double errorOutput = prediction.getPrediction(i) - trueClass.getPrediction(i);
+				sumSquaredError[i] = errorOutput * errorOutput * weight + fadingErrorFactor * sumSquaredError[i];
 			}
 		}
-		weightSeen=weight+fadingErrorFactor*weightSeen;
+		weightSeen = weight + fadingErrorFactor * weightSeen;
 	}
 
 	@Override
 	public double getCurrentError() {
-		if(weightSeen==0)
+		if (weightSeen == 0)
 			return Double.MAX_VALUE;
-		else
-		{
-			double sum=0;
-			int numOutputs=sumSquaredError.length;
-			for (int i=0; i<numOutputs; i++)
-				sum+=sumSquaredError[i];
-			return Math.sqrt(sum/(weightSeen*numLearnedOutputs));
+		else {
+			double sum = 0;
+			int numOutputs = sumSquaredError.length;
+			for (int i = 0; i < numOutputs; i++)
+				sum += sumSquaredError[i];
+			return Math.sqrt(sum / (weightSeen * numLearnedOutputs));
 		}
 	}
 
 	@Override
 	public double getCurrentError(int index) {
-		return Math.sqrt(sumSquaredError[index]/weightSeen);
+		return Math.sqrt(sumSquaredError[index] / weightSeen);
 	}
 
 	@Override
 	public double[] getCurrentErrors() {
-		double [] errors=null;
-		if(sumSquaredError!=null){
-			errors= new double[sumSquaredError.length];
-			for (int i=0;i<sumSquaredError.length; i++)
-				errors[i]=Math.sqrt(sumSquaredError[i]/weightSeen);
+		double[] errors = null;
+		if (sumSquaredError != null) {
+			errors = new double[sumSquaredError.length];
+			for (int i = 0; i < sumSquaredError.length; i++)
+				errors[i] = Math.sqrt(sumSquaredError[i] / weightSeen);
 		}
 		return errors;
 	}
 
-
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/featureranking/AbstractFeatureRanking.java b/moa/src/main/java/moa/learners/predictors/core/featureranking/AbstractFeatureRanking.java
similarity index 82%
rename from moa/src/main/java/moa/classifiers/rules/featureranking/AbstractFeatureRanking.java
rename to moa/src/main/java/moa/learners/predictors/core/featureranking/AbstractFeatureRanking.java
index 6a2daade8..c198884dc 100644
--- a/moa/src/main/java/moa/classifiers/rules/featureranking/AbstractFeatureRanking.java
+++ b/moa/src/main/java/moa/learners/predictors/core/featureranking/AbstractFeatureRanking.java
@@ -17,22 +17,21 @@
  *
  *
  */
-package moa.classifiers.rules.featureranking;
+package moa.learners.predictors.core.featureranking;
 
-import moa.classifiers.rules.multilabel.core.ObservableMOAObject;
 import moa.core.DoubleVector;
 import moa.core.ObjectRepository;
+import moa.learners.predictors.core.ObservableMOAObject;
 import moa.options.AbstractOptionHandler;
 import moa.tasks.TaskMonitor;
 
-abstract public class AbstractFeatureRanking extends AbstractOptionHandler implements FeatureRanking{
+abstract public class AbstractFeatureRanking extends AbstractOptionHandler implements FeatureRanking {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 
-
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
 
@@ -40,14 +39,13 @@ public void getDescription(StringBuilder sb, int indent) {
 
 	@Override
 	abstract public void update(ObservableMOAObject o, Object arg);
-	
 
+	@Override
 	abstract public DoubleVector getFeatureRankings();
-	
+
 	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
-	
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+
 	}
 
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/featureranking/BasicFeatureRanking.java b/moa/src/main/java/moa/learners/predictors/core/featureranking/BasicFeatureRanking.java
similarity index 56%
rename from moa/src/main/java/moa/classifiers/rules/featureranking/BasicFeatureRanking.java
rename to moa/src/main/java/moa/learners/predictors/core/featureranking/BasicFeatureRanking.java
index e1dabb7ae..2876c8133 100644
--- a/moa/src/main/java/moa/classifiers/rules/featureranking/BasicFeatureRanking.java
+++ b/moa/src/main/java/moa/learners/predictors/core/featureranking/BasicFeatureRanking.java
@@ -18,102 +18,89 @@
  *
  */
 
-package moa.classifiers.rules.featureranking;
+package moa.learners.predictors.core.featureranking;
 
 import java.util.HashMap;
 
-import moa.classifiers.rules.featureranking.messages.ChangeDetectedMessage;
-import moa.classifiers.rules.featureranking.messages.RuleExpandedMessage;
-import moa.classifiers.rules.multilabel.core.ObservableMOAObject;
 import moa.core.DoubleVector;
+import moa.learners.predictors.core.ObservableMOAObject;
+import moa.learners.predictors.core.featureranking.messages.ChangeDetectedMessage;
+import moa.learners.predictors.core.featureranking.messages.RuleExpandedMessage;
 
 /**
- * Basic Feature Ranking method
- * João Duarte, João Gama,Feature ranking in hoeffding algorithms for regression. SAC 2017: 836-841
+ * Basic Feature Ranking method João Duarte, João Gama,Feature ranking in
+ * hoeffding algorithms for regression. SAC 2017: 836-841
  */
 
-
-public class BasicFeatureRanking extends AbstractFeatureRanking{
+public class BasicFeatureRanking extends AbstractFeatureRanking {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
-	
+
 	protected DoubleVector attributeImportance;
 	protected HashMap<ObservableMOAObject, RuleInformation> ruleInformation;
 
-
 	public BasicFeatureRanking() {
 		super();
 		this.attributeImportance = new DoubleVector();
-		this.ruleInformation= new HashMap<ObservableMOAObject, RuleInformation>();
+		this.ruleInformation = new HashMap<>();
 	}
 
+	@Override
 	public void update(ObservableMOAObject o, Object arg) {
-		
-		if (arg instanceof RuleExpandedMessage){
-			
-			RuleInformation ri=ruleInformation.get(o);
-			if(ri==null)
-			{
-				ri=new RuleInformation();
+
+		if (arg instanceof RuleExpandedMessage) {
+
+			RuleInformation ri = ruleInformation.get(o);
+			if (ri == null) {
+				ri = new RuleInformation();
 				ruleInformation.put(o, ri);
 			}
-			RuleExpandedMessage msg=((RuleExpandedMessage)arg);
-			int index=msg.getAttributeIndex();
-			if(!msg.isSpecialization()){
-				ri.addMerit(index,1.0);	
+			RuleExpandedMessage msg = ((RuleExpandedMessage) arg);
+			int index = msg.getAttributeIndex();
+			if (!msg.isSpecialization()) {
+				ri.addMerit(index, 1.0);
 				this.attributeImportance.addToValue(index, 1.0);
 			}
-				
-		}
-		else if (arg instanceof ChangeDetectedMessage) {
-			RuleInformation ri=ruleInformation.get(o);
+
+		} else if (arg instanceof ChangeDetectedMessage) {
+			RuleInformation ri = ruleInformation.get(o);
 			DoubleVector accumulatedMerit = ri.getAccumulatedMerit();
 			attributeImportance.subtractValues(accumulatedMerit);
 			ruleInformation.remove(o);
 		}
-		
 
 	}
 
-
-	
-
 	@Override
 	public DoubleVector getFeatureRankings() {
-		/*DoubleVector normRankings=null;
-		if(attributeImportance!=null){
-			normRankings=new DoubleVector(attributeImportance.getArrayCopy());
-			normRankings.normalize();
-		}
-		return normRankings;*/
-		if(attributeImportance==null)
+		/*
+		 * DoubleVector normRankings=null; if(attributeImportance!=null){
+		 * normRankings=new DoubleVector(attributeImportance.getArrayCopy());
+		 * normRankings.normalize(); } return normRankings;
+		 */
+		if (attributeImportance == null)
 			return new DoubleVector();
 		return attributeImportance;
 	}
-	
 
-	
-	public class RuleInformation{
+	public class RuleInformation {
 		private DoubleVector accumulatedMerit;
-		
+
 		public RuleInformation() {
-			accumulatedMerit= new DoubleVector();
+			accumulatedMerit = new DoubleVector();
 		}
 
-		
 		public void addMerit(int index, double value) {
 			accumulatedMerit.addToValue(index, value);
 		}
 
-
-		public DoubleVector getAccumulatedMerit(){
+		public DoubleVector getAccumulatedMerit() {
 			return accumulatedMerit;
-			
+
 		}
 	}
 
-
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/featureranking/FeatureRanking.java b/moa/src/main/java/moa/learners/predictors/core/featureranking/FeatureRanking.java
similarity index 77%
rename from moa/src/main/java/moa/classifiers/rules/featureranking/FeatureRanking.java
rename to moa/src/main/java/moa/learners/predictors/core/featureranking/FeatureRanking.java
index 2c5ef46b5..b02911d1e 100644
--- a/moa/src/main/java/moa/classifiers/rules/featureranking/FeatureRanking.java
+++ b/moa/src/main/java/moa/learners/predictors/core/featureranking/FeatureRanking.java
@@ -18,11 +18,11 @@
  *
  */
 
-package moa.classifiers.rules.featureranking;
+package moa.learners.predictors.core.featureranking;
 
-import moa.classifiers.rules.multilabel.core.ObserverMOAObject;
 import moa.core.DoubleVector;
+import moa.learners.predictors.core.ObserverMOAObject;
 
-public interface FeatureRanking extends ObserverMOAObject{
-	public DoubleVector getFeatureRankings();
+public interface FeatureRanking extends ObserverMOAObject {
+	DoubleVector getFeatureRankings();
 }
diff --git a/moa/src/main/java/moa/learners/predictors/core/featureranking/MeritFeatureRanking.java b/moa/src/main/java/moa/learners/predictors/core/featureranking/MeritFeatureRanking.java
new file mode 100644
index 000000000..ad9e1a5c0
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/featureranking/MeritFeatureRanking.java
@@ -0,0 +1,164 @@
+/*
+ *    MeritFeatureRanking.java
+ *    Copyright (C) 2017 University of Porto, Portugal
+ *    @author J. Duarte, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.predictors.core.featureranking;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import moa.core.DoubleVector;
+import moa.learners.predictors.core.ObservableMOAObject;
+import moa.learners.predictors.core.featureranking.messages.ChangeDetectedMessage;
+import moa.learners.predictors.core.featureranking.messages.MeritCheckMessage;
+import moa.learners.predictors.core.featureranking.messages.RuleExpandedMessage;
+
+/**
+ * Merit Feature Ranking method João Duarte, João Gama,Feature ranking in
+ * hoeffding algorithms for regression. SAC 2017: 836-841
+ */
+
+public class MeritFeatureRanking extends AbstractFeatureRanking implements FeatureRanking {
+
+	/**
+	 *
+	 */
+	private static final long serialVersionUID = 1L;
+
+	protected DoubleVector attributeImportance;
+	protected HashMap<ObservableMOAObject, RuleInformation> ruleInformation;
+
+	public MeritFeatureRanking() {
+		super();
+		this.attributeImportance = new DoubleVector();
+		this.ruleInformation = new HashMap<>();
+	}
+
+	@Override
+	public void update(ObservableMOAObject o, Object arg) {
+
+		if (arg instanceof MeritCheckMessage) {
+			RuleInformation ri = ruleInformation.get(o);
+			if (ri == null) {
+				ri = new RuleInformation();
+				ruleInformation.put(o, ri);
+			}
+			DoubleVector merits = ri.getCurrent();
+			if (!ri.isFirstAfterExpansion())
+				this.attributeImportance.subtractValues(merits);
+			MeritCheckMessage msg = (MeritCheckMessage) arg;
+			ri.updateCurrent(msg.getMerits());
+			merits = ri.getCurrent();
+			this.attributeImportance.addValues(merits);
+		} else if (arg instanceof RuleExpandedMessage) {
+			RuleInformation ri = ruleInformation.get(o);
+			if (!((RuleExpandedMessage) arg).isSpecialization())
+				ri.addNumLiterals();
+		} else if (arg instanceof ChangeDetectedMessage) {
+			RuleInformation ri = ruleInformation.get(o);
+			this.attributeImportance.subtractValues(ri.getAccumulated());
+			ruleInformation.remove(o);
+		}
+
+	}
+
+	@Override
+	public DoubleVector getFeatureRankings() {
+		/*
+		 * DoubleVector normRankings=null; if(attributeImportance!=null){ double
+		 * total=0; for (int i=0; i<attributeImportance.numValues();i++)
+		 * total+=attributeImportance.getValue(i);
+		 * 
+		 * // normRankings=new DoubleVector(); double[] aux= new
+		 * double[attributeImportance.numValues()]; for (int i=0;
+		 * i<attributeImportance.numValues();i++)
+		 * aux[i]=attributeImportance.getValue(i)/total; normRankings= new
+		 * DoubleVector(aux); } return normRankings;
+		 */
+
+		if (attributeImportance == null)
+			return new DoubleVector();
+		return attributeImportance;
+	}
+
+	public DoubleVector getAccumulated() {
+		DoubleVector accumulated = new DoubleVector();
+		Iterator<Entry<ObservableMOAObject, RuleInformation>> it = this.ruleInformation.entrySet().iterator();
+		while (it.hasNext()) {
+			Map.Entry<ObservableMOAObject, RuleInformation> pair = it.next();
+			accumulated.addValues(pair.getValue().getAccumulated());
+		}
+		return accumulated;
+	}
+
+	/*
+	 * Rule information class
+	 */
+	public class RuleInformation {
+		private DoubleVector accumulated;
+		private DoubleVector current;
+		// private HashMap<Integer, Integer> literalAttributes;
+		private boolean isFirstAfterExpansion;
+		private int numLiterals;
+
+		public RuleInformation() {
+			// literalAttributes=new HashMap<Integer, Integer>();
+			isFirstAfterExpansion = false;
+			accumulated = new DoubleVector();
+			current = new DoubleVector();
+			numLiterals = 0;
+		}
+
+		public DoubleVector getAccumulated() {
+			return accumulated;
+		}
+
+		public DoubleVector getCurrent() {
+			return current;
+		}
+
+		public void updateCurrent(DoubleVector merits) {
+			DoubleVector newMerits = new DoubleVector(merits);
+			if (!isFirstAfterExpansion) {
+				accumulated.subtractValues(current);
+			}
+			newMerits.scaleValues(1.0 / (1 + numLiterals));
+			accumulated.addValues(newMerits);
+			current = newMerits;
+			isFirstAfterExpansion = false;
+		}
+
+		public void addNumLiterals() {
+			/*
+			 * boolean contains=false; Iterator<Integer> it=literalAttributes.iterator();
+			 * while (it.hasNext() && !contains){ if(it.next()==attribIndex) contains=true;
+			 * } if(!contains){ literalAttributes.add(attribIndex); }
+			 */
+			this.numLiterals++;
+			isFirstAfterExpansion = true;
+		}
+
+		public boolean isFirstAfterExpansion() {
+			return isFirstAfterExpansion;
+		}
+
+	}
+
+}
diff --git a/moa/src/main/java/moa/classifiers/rules/featureranking/NoFeatureRanking.java b/moa/src/main/java/moa/learners/predictors/core/featureranking/NoFeatureRanking.java
similarity index 84%
rename from moa/src/main/java/moa/classifiers/rules/featureranking/NoFeatureRanking.java
rename to moa/src/main/java/moa/learners/predictors/core/featureranking/NoFeatureRanking.java
index 4da48b281..b92b75281 100644
--- a/moa/src/main/java/moa/classifiers/rules/featureranking/NoFeatureRanking.java
+++ b/moa/src/main/java/moa/learners/predictors/core/featureranking/NoFeatureRanking.java
@@ -17,37 +17,34 @@
  *
  *
  */
-package moa.classifiers.rules.featureranking;
+package moa.learners.predictors.core.featureranking;
 
-import moa.classifiers.rules.multilabel.core.ObservableMOAObject;
 import moa.core.DoubleVector;
+import moa.learners.predictors.core.ObservableMOAObject;
 
 /**
  * No feature ranking is performed
  */
 
-
-public class NoFeatureRanking extends AbstractFeatureRanking{
+public class NoFeatureRanking extends AbstractFeatureRanking {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
-	
+
 	public NoFeatureRanking() {
 		super();
 	}
 
+	@Override
 	public void update(ObservableMOAObject o, Object arg) {
-		
-	}
 
-
-	
+	}
 
 	@Override
 	public DoubleVector getFeatureRankings() {
 		return null;
 	}
-	
+
 }
diff --git a/moa/src/main/java/moa/learners/predictors/core/featureranking/WeightedMajorityFeatureRanking.java b/moa/src/main/java/moa/learners/predictors/core/featureranking/WeightedMajorityFeatureRanking.java
new file mode 100644
index 000000000..43bef2bb0
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/featureranking/WeightedMajorityFeatureRanking.java
@@ -0,0 +1,199 @@
+/*
+ *    WeightedMajorityFeatureRanking.java
+ *    Copyright (C) 2017 University of Porto, Portugal
+ *    @author J. Duarte, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.predictors.core.featureranking;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+import com.github.javacliparser.FloatOption;
+
+import moa.core.DoubleVector;
+import moa.learners.predictors.core.ObservableMOAObject;
+import moa.learners.predictors.core.featureranking.messages.ChangeDetectedMessage;
+import moa.learners.predictors.core.featureranking.messages.MeritCheckMessage;
+import moa.learners.predictors.core.featureranking.messages.RuleExpandedMessage;
+
+/**
+ * Weighted Majority Feature Ranking method João Duarte, João Gama,Feature
+ * ranking in hoeffding algorithms for regression. SAC 2017: 836-841
+ */
+
+public class WeightedMajorityFeatureRanking extends AbstractFeatureRanking implements FeatureRanking {
+
+	/**
+	 *
+	 */
+	private static final long serialVersionUID = 1L;
+
+	protected double[] attributeImportance;
+	protected HashMap<ObservableMOAObject, RuleInformation> ruleInformation;
+
+	public FloatOption meritThresholdOption = new FloatOption("meritThreshold", 'm',
+			"Merit threshold value. If the merit of an input attribute is below the threshold its importance will decrease",
+			0.01, 0.0, 1.0);
+
+	public WeightedMajorityFeatureRanking() {
+		super();
+		this.ruleInformation = new HashMap<>();
+	}
+
+	@Override
+	public void update(ObservableMOAObject o, Object arg) {
+
+		if (arg instanceof MeritCheckMessage) {
+
+			MeritCheckMessage msg = (MeritCheckMessage) arg;
+			// Get Learning attributes
+			boolean[] attributesMask = msg.getLearningAttributes().clone(); // because it will be modified
+
+			int numAttributes = attributesMask.length;
+
+			if (this.attributeImportance == null) {
+				this.attributeImportance = new double[numAttributes];
+				for (int i = 0; i < attributesMask.length; i++)
+					attributeImportance[i] = 1.0;
+			}
+			int numRules = ruleInformation.size();
+			RuleInformation ri = ruleInformation.get(o);
+			// Merit check of a new rule
+			if (ri == null) {
+				ri = new RuleInformation(numAttributes);
+				ruleInformation.put(o, ri);
+				// new
+				for (int i = 0; i < numAttributes; i++)
+					attributeImportance[i] = (attributeImportance[i] * numRules + 1) / (numRules + 1);
+			}
+			// Merit check of an existing rule
+			else {
+				double[] old = ri.getAttributesImportance().clone(); // it may change after update
+				List<Integer> updated = ri.update(msg.getMerits().getArrayRef(), attributesMask,
+						meritThresholdOption.getValue());
+
+				Iterator<Integer> it = updated.iterator();
+				while (it.hasNext()) {
+					int attIndex = it.next();
+
+					this.attributeImportance[attIndex] = (attributeImportance[attIndex] * numRules - old[attIndex]
+							+ ri.getAttributeImportance(attIndex)) / numRules;
+				}
+			}
+		}
+		// Rule expanded
+		else if (arg instanceof RuleExpandedMessage) {
+			int numRules = ruleInformation.size();
+			RuleInformation ri = ruleInformation.get(o);
+			RuleExpandedMessage msg = ((RuleExpandedMessage) arg);
+			int attIndex = msg.getAttributeIndex();
+
+			double oldValue = ri.getAttributeImportance(attIndex);
+			this.attributeImportance[attIndex] = (attributeImportance[attIndex] * numRules - oldValue + 1) / numRules;
+			ri.addLiteralAttribute(attIndex);
+
+		}
+		// Rule will be removed
+		else if (arg instanceof ChangeDetectedMessage) {
+			RuleInformation ri = ruleInformation.get(o);
+			int numRules = ruleInformation.size();
+			double[] attribImportance = ri.getAttributesImportance();
+			for (int i = 0; i < this.attributeImportance.length; i++)
+				attributeImportance[i] = (attributeImportance[i] * numRules - attribImportance[i]) / (numRules - 1);
+			ruleInformation.remove(o);
+		}
+
+	}
+
+	@Override
+	public DoubleVector getFeatureRankings() {
+		/*
+		 * DoubleVector normRankings=new DoubleVector(); if(attributeImportance!=null){
+		 * double total=0; for (int i=0; i<attributeImportance.numValues();i++)
+		 * total+=attributeImportance.getValue(i);
+		 * 
+		 * // double[] aux= new double[attributeImportance.numValues()]; for (int i=0;
+		 * i<attributeImportance.numValues();i++)
+		 * aux[i]=attributeImportance.getValue(i)/total; normRankings.addValues(aux); }
+		 * return normRankings;
+		 */
+		if (attributeImportance == null)
+			return new DoubleVector();
+		return new DoubleVector(attributeImportance);
+	}
+
+	/***********************************
+	 *
+	 * Rule information class
+	 *
+	 **********************************/
+	public class RuleInformation {
+		private double[] attributeImportance;
+		private double depth;
+		private List<Integer> literalAttributes = new LinkedList<>();
+
+		public RuleInformation(int numAttributes) {
+			attributeImportance = new double[numAttributes];
+			depth = 0;
+			for (int i = 0; i < numAttributes; i++)
+				attributeImportance[i] = 1.0;
+		}
+
+		public void addLiteralAttribute(int attribIndex) {
+			// it means rule expanded. depth always increases.
+			// However, the number of literals may be inferior
+			depth++;
+			attributeImportance[attribIndex] = 1.0;
+			if (!literalAttributes.contains(attribIndex))
+				literalAttributes.add(attribIndex);
+		}
+
+		public double[] getAttributesImportance() {
+			return attributeImportance;
+		}
+
+		public double getAttributeImportance(int attribIndex) {
+			return attributeImportance[attribIndex];
+		}
+
+		/*
+		 * Update the attributes importance if the merit is below the giver threshold
+		 * and the attribute is being considered (attributesMask[i]==true) Returns the
+		 * list of attributes whose merit had change
+		 */
+		public List<Integer> update(double[] merits, boolean[] attributesMask, double threshold) {
+			boolean[] attributesMaskAux = attributesMask.clone();
+			Iterator<Integer> it = literalAttributes.iterator();
+			while (it.hasNext())
+				attributesMaskAux[it.next()] = false;
+
+			List<Integer> updated = new LinkedList<>();
+			for (int i = 0; i < attributesMaskAux.length; i++) {
+				if (merits[i] < threshold && attributesMaskAux[i]) {
+					attributeImportance[i] *= (1 + depth) / (2 + depth);
+					updated.add(i);
+				}
+			}
+			return updated;
+		}
+
+	}
+
+}
diff --git a/moa/src/main/java/moa/classifiers/rules/featureranking/messages/ChangeDetectedMessage.java b/moa/src/main/java/moa/learners/predictors/core/featureranking/messages/ChangeDetectedMessage.java
similarity index 92%
rename from moa/src/main/java/moa/classifiers/rules/featureranking/messages/ChangeDetectedMessage.java
rename to moa/src/main/java/moa/learners/predictors/core/featureranking/messages/ChangeDetectedMessage.java
index 526efd972..db664eb12 100644
--- a/moa/src/main/java/moa/classifiers/rules/featureranking/messages/ChangeDetectedMessage.java
+++ b/moa/src/main/java/moa/learners/predictors/core/featureranking/messages/ChangeDetectedMessage.java
@@ -17,8 +17,7 @@
  *
  *
  */
-package moa.classifiers.rules.featureranking.messages;
-
+package moa.learners.predictors.core.featureranking.messages;
 
 public class ChangeDetectedMessage implements FeatureRankingMessage {
 
diff --git a/moa/src/main/java/moa/classifiers/rules/featureranking/messages/FeatureRankingMessage.java b/moa/src/main/java/moa/learners/predictors/core/featureranking/messages/FeatureRankingMessage.java
similarity index 92%
rename from moa/src/main/java/moa/classifiers/rules/featureranking/messages/FeatureRankingMessage.java
rename to moa/src/main/java/moa/learners/predictors/core/featureranking/messages/FeatureRankingMessage.java
index 01609b0d2..91964d644 100644
--- a/moa/src/main/java/moa/classifiers/rules/featureranking/messages/FeatureRankingMessage.java
+++ b/moa/src/main/java/moa/learners/predictors/core/featureranking/messages/FeatureRankingMessage.java
@@ -17,7 +17,7 @@
  *
  *
  */
-package moa.classifiers.rules.featureranking.messages;
+package moa.learners.predictors.core.featureranking.messages;
 
 public interface FeatureRankingMessage {
 
diff --git a/moa/src/main/java/moa/classifiers/rules/featureranking/messages/MeritCheckMessage.java b/moa/src/main/java/moa/learners/predictors/core/featureranking/messages/MeritCheckMessage.java
similarity index 79%
rename from moa/src/main/java/moa/classifiers/rules/featureranking/messages/MeritCheckMessage.java
rename to moa/src/main/java/moa/learners/predictors/core/featureranking/messages/MeritCheckMessage.java
index f3354dfd3..8748eff3d 100644
--- a/moa/src/main/java/moa/classifiers/rules/featureranking/messages/MeritCheckMessage.java
+++ b/moa/src/main/java/moa/learners/predictors/core/featureranking/messages/MeritCheckMessage.java
@@ -17,29 +17,28 @@
  *
  *
  */
-package moa.classifiers.rules.featureranking.messages;
+package moa.learners.predictors.core.featureranking.messages;
 
 import moa.core.DoubleVector;
 
 public class MeritCheckMessage implements FeatureRankingMessage {
 	protected DoubleVector merits;
-	boolean [] learningAttributes;
+	boolean[] learningAttributes;
 
 	public MeritCheckMessage(DoubleVector merits) {
 		this.merits = merits;
 	}
-	
-	public MeritCheckMessage(DoubleVector merits, boolean [] learningAttributes) {
+
+	public MeritCheckMessage(DoubleVector merits, boolean[] learningAttributes) {
 		this.merits = merits;
-		this.learningAttributes=learningAttributes;
+		this.learningAttributes = learningAttributes;
 	}
-	
+
 	public DoubleVector getMerits() {
 		return merits;
 	}
-	
-	
-	public boolean [] getLearningAttributes() {
+
+	public boolean[] getLearningAttributes() {
 		return learningAttributes;
 	}
 
diff --git a/moa/src/main/java/moa/classifiers/rules/featureranking/messages/RuleExpandedMessage.java b/moa/src/main/java/moa/learners/predictors/core/featureranking/messages/RuleExpandedMessage.java
similarity index 95%
rename from moa/src/main/java/moa/classifiers/rules/featureranking/messages/RuleExpandedMessage.java
rename to moa/src/main/java/moa/learners/predictors/core/featureranking/messages/RuleExpandedMessage.java
index cdfea799d..75806b94b 100644
--- a/moa/src/main/java/moa/classifiers/rules/featureranking/messages/RuleExpandedMessage.java
+++ b/moa/src/main/java/moa/learners/predictors/core/featureranking/messages/RuleExpandedMessage.java
@@ -17,8 +17,7 @@
  *
  *
  */
-package moa.classifiers.rules.featureranking.messages;
-
+package moa.learners.predictors.core.featureranking.messages;
 
 public class RuleExpandedMessage implements FeatureRankingMessage {
 	private int attributeIndex;
@@ -32,7 +31,7 @@ public RuleExpandedMessage(int attributeIndex) {
 		this.attributeIndex = attributeIndex;
 		setSpecialization(false);
 	}
-	
+
 	public RuleExpandedMessage(int attributeIndex, boolean isSpecialization) {
 		this.attributeIndex = attributeIndex;
 		this.setSpecialization(isSpecialization);
@@ -46,5 +45,4 @@ protected void setSpecialization(boolean isSpecialization) {
 		this.isSpecialization = isSpecialization;
 	}
 
-
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/AMRulesFunction.java b/moa/src/main/java/moa/learners/predictors/core/functions/AMRulesFunction.java
similarity index 83%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/functions/AMRulesFunction.java
rename to moa/src/main/java/moa/learners/predictors/core/functions/AMRulesFunction.java
index c3d4e963e..5e9423069 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/AMRulesFunction.java
+++ b/moa/src/main/java/moa/learners/predictors/core/functions/AMRulesFunction.java
@@ -17,9 +17,10 @@
  *
  *
  */
-package moa.classifiers.rules.multilabel.functions;
+package moa.learners.predictors.core.functions;
 
 public interface AMRulesFunction {
-	public void resetWithMemory();
-	public void selectOutputsToLearn(int [] outtputAtributtes);
+	void resetWithMemory();
+
+	void selectOutputsToLearn(int[] outtputAtributtes);
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/AbstractAMRulesFunctionBasicMlLearner.java b/moa/src/main/java/moa/learners/predictors/core/functions/AbstractAMRulesFunctionBasicMlLearner.java
similarity index 65%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/functions/AbstractAMRulesFunctionBasicMlLearner.java
rename to moa/src/main/java/moa/learners/predictors/core/functions/AbstractAMRulesFunctionBasicMlLearner.java
index 2cefb89a9..52189964e 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/AbstractAMRulesFunctionBasicMlLearner.java
+++ b/moa/src/main/java/moa/learners/predictors/core/functions/AbstractAMRulesFunctionBasicMlLearner.java
@@ -17,18 +17,19 @@
  *
  *
  */
-package moa.classifiers.rules.multilabel.functions;
+package moa.learners.predictors.core.functions;
 
-import moa.classifiers.mlc.BasicMultiLabelLearner;
-import moa.classifiers.mtr.BasicMultiTargetRegressor;
-import moa.learners.Classifier;
-import moa.learners.Regressor;
+import java.util.ArrayList;
+import java.util.List;
 
-abstract public class AbstractAMRulesFunctionBasicMlLearner extends
-BasicMultiTargetRegressor implements AMRulesFunction {
+import moa.learners.predictors.Regressor;
+import moa.learners.predictors.meta.mtr.LocalMultiTargetRegressor;
+
+abstract public class AbstractAMRulesFunctionBasicMlLearner extends LocalMultiTargetRegressor
+		implements AMRulesFunction {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 
@@ -37,12 +38,11 @@ abstract public class AbstractAMRulesFunctionBasicMlLearner extends
 
 	@Override
 	public void selectOutputsToLearn(int[] outputsToLearn) {
-		Regressor[] newEnsemble= new Regressor[outputsToLearn.length];
-		for(int i=0; i<outputsToLearn.length; i++){
-			newEnsemble[i] = (Regressor) this.ensemble[outputsToLearn[i]].copy();
+		List<Regressor> newEnsemble = new ArrayList<Regressor>(outputsToLearn.length);
+		for (int i = 0; i < outputsToLearn.length; i++) {
+			newEnsemble.set(i, (Regressor) this.regressors.get(outputsToLearn[i]).copy());
 		}
-		this.ensemble=newEnsemble;
+		this.regressors = newEnsemble;
 	}
 
-
 }
diff --git a/moa/src/main/java/moa/learners/predictors/core/functions/AdaptiveMultiTargetRegressor.java b/moa/src/main/java/moa/learners/predictors/core/functions/AdaptiveMultiTargetRegressor.java
new file mode 100644
index 000000000..b61ee3be0
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/functions/AdaptiveMultiTargetRegressor.java
@@ -0,0 +1,175 @@
+/*
+ *    AdaptiveMultiTargetRegressor.java
+ *    Copyright (C) 2017 University of Porto, Portugal
+ *    @author J. Duarte, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.predictors.core.functions;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Measurement;
+import moa.learners.predictors.AbstractMultiTargetRegressor;
+import moa.learners.predictors.MultiTargetRegressor;
+import moa.learners.predictors.core.errormeasurers.AbstractMultiTargetErrorMeasurer;
+import moa.learners.predictors.core.errormeasurers.MeanAbsoluteDeviationMT;
+import moa.learners.predictors.core.errormeasurers.MultiTargetErrorMeasurer;
+import moa.options.ClassOption;
+
+/**
+ * Adaptive MultiTarget Regressor uses two learner The first is used in first
+ * stage when high error are produced(e.g. Target mean) The second is used in a
+ * second stage when low error are produced(e.g perceptron) baseLearnerOption1-
+ * Learner one ; baseLearnerOption2- learner two
+ */
+
+public class AdaptiveMultiTargetRegressor extends AbstractMultiTargetRegressor
+		implements MultiTargetRegressor, AMRulesFunction {
+
+	/**
+	 *
+	 */
+	private static final long serialVersionUID = 1L;
+
+	private static final int NUM_LEARNERS = 2;
+
+	public ClassOption baseLearnerOption1;
+	public ClassOption baseLearnerOption2;
+
+	public ClassOption errorMeasurerOption;
+
+//	public IntOption randomSeedOption = new IntOption("randomSeedOption",
+//			'r', "randomSeedOption",
+//			1,Integer.MIN_VALUE, Integer.MAX_VALUE);
+
+	protected boolean hasStarted;
+
+	protected MultiTargetRegressor baseLearner[];
+
+	protected MultiTargetErrorMeasurer[] errorMeasurer;
+
+	public AdaptiveMultiTargetRegressor() {
+		super.randomSeedOption = randomSeedOption;
+		baseLearnerOption1 = new ClassOption("baseLearner1", 'l', "First base learner.", AMRulesFunction.class,
+				MultiTargetMeanRegressor.class.getName());
+		baseLearnerOption2 = new ClassOption("baseLearner2", 'm', "Second base learner.", AMRulesFunction.class,
+				MultiTargetPerceptronRegressor.class.getName());
+		errorMeasurerOption = new ClassOption("errorMeasurer", 'e',
+				"Measure of error for deciding which learner should predict.", AbstractMultiTargetErrorMeasurer.class,
+				MeanAbsoluteDeviationMT.class.getName());
+
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance instance) {
+		if (!this.hasStarted) {
+			baseLearner = new MultiTargetRegressor[NUM_LEARNERS];
+			errorMeasurer = new MultiTargetErrorMeasurer[NUM_LEARNERS];
+			baseLearner[0] = (MultiTargetRegressor) getPreparedClassOption(this.baseLearnerOption1);
+			baseLearner[1] = (MultiTargetRegressor) getPreparedClassOption(this.baseLearnerOption2);
+			for (int i = 0; i < NUM_LEARNERS; i++) {
+				if (baseLearner[i].isRandomizable())
+					baseLearner[i].setRandomSeed(this.randomSeed);
+				baseLearner[i].resetLearning();
+				baseLearner[i].setModelContext(instance.dataset());
+				errorMeasurer[i] = (MultiTargetErrorMeasurer) ((MultiTargetErrorMeasurer) getPreparedClassOption(
+						this.errorMeasurerOption)).copy();
+
+			}
+			this.hasStarted = true;
+		}
+		for (int i = 0; i < NUM_LEARNERS; i++) {
+			// Update online errors
+			Prediction prediction = baseLearner[i].getPredictionForInstance(instance);
+			if (prediction != null)// should happen only for first instance
+				errorMeasurer[i].addPrediction(prediction, instance);
+			// Train
+			baseLearner[i].trainOnInstanceImpl(instance);
+		}
+
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		Prediction prediction = null;
+		if (hasStarted) {
+			int bestIndex = 0;
+			double minError = Double.MAX_VALUE;
+			for (int i = 0; i < NUM_LEARNERS; i++) {
+				double error = errorMeasurer[i].getCurrentError();
+				if (error < minError) {
+					minError = error;
+					bestIndex = i;
+				}
+			}
+			prediction = baseLearner[bestIndex].getPredictionForInstance(inst);
+		}
+		return prediction;
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	@Override
+	public void resetLearningImpl() {
+		this.hasStarted = false;
+		if (baseLearner != null) {
+			for (int i = 0; i < baseLearner.length; i++) {
+				classifierRandom.setSeed(randomSeedOption.getValue());
+				baseLearner[i].setRandomSeed(this.randomSeed);
+				baseLearner[i].resetLearning();
+			}
+		}
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return null;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+
+	}
+
+	@Override
+	public String getPurposeString() {
+		return "Learns two regressors and uses the regressor with less error to predict.";
+	}
+
+	@Override
+	public void resetWithMemory() {
+		if (errorMeasurer == null)
+			errorMeasurer = new MultiTargetErrorMeasurer[NUM_LEARNERS];
+		for (int i = 0; i < NUM_LEARNERS; i++) {
+			errorMeasurer[i] = (MultiTargetErrorMeasurer) ((MultiTargetErrorMeasurer) getPreparedClassOption(
+					this.errorMeasurerOption)).copy();
+			if (baseLearner[i] instanceof AMRulesFunction)
+				((AMRulesFunction) baseLearner[i]).resetWithMemory();
+		}
+	}
+
+	@Override
+	public void selectOutputsToLearn(int[] outtputAtributtes) {
+		for (int i = 0; i < NUM_LEARNERS; i++) {
+			((AMRulesFunction) baseLearner[i]).selectOutputsToLearn(outtputAtributtes);
+		}
+	}
+
+}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/DominantLabelsClassifier.java b/moa/src/main/java/moa/learners/predictors/core/functions/DominantLabelsClassifier.java
similarity index 62%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/functions/DominantLabelsClassifier.java
rename to moa/src/main/java/moa/learners/predictors/core/functions/DominantLabelsClassifier.java
index 95360966a..aecbb57b1 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/DominantLabelsClassifier.java
+++ b/moa/src/main/java/moa/learners/predictors/core/functions/DominantLabelsClassifier.java
@@ -17,24 +17,24 @@
  *
  *
  */
-package moa.classifiers.rules.multilabel.functions;
+package moa.learners.predictors.core.functions;
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-import moa.classifiers.AbstractMultiLabelClassifier;
 import moa.core.Measurement;
-import moa.learners.MultiLabelClassifier;
-
-public class DominantLabelsClassifier extends AbstractMultiLabelClassifier implements MultiLabelClassifier, AMRulesFunction {
+import moa.learners.predictors.AbstractMultiLabelClassifier;
+import moa.learners.predictors.MultiLabelClassifier;
 
+public class DominantLabelsClassifier extends AbstractMultiLabelClassifier
+		implements MultiLabelClassifier, AMRulesFunction {
 
 	/**
 	 * Predicts for each label by majority voting
 	 */
 	private static final long serialVersionUID = 1L;
-	
+
 	private double countVector[];
 	private double numInstances;
 
@@ -45,41 +45,41 @@ public boolean isRandomizable() {
 
 	@Override
 	public void resetWithMemory() {
-		//0-1 vector with majority class by label? Use fading strategy instead?
+		// 0-1 vector with majority class by label? Use fading strategy instead?
 
 	}
 
 	@Override
 	public void selectOutputsToLearn(int[] outputAttributes) {
-		int n=outputAttributes.length;
-		double [] newCountVector=new double[n];
-		for(int i=0; i<n; i++)
-			newCountVector[i]=countVector[outputAttributes[i]];
-		newCountVector=countVector;
+		int n = outputAttributes.length;
+		double[] newCountVector = new double[n];
+		for (int i = 0; i < n; i++)
+			newCountVector[i] = countVector[outputAttributes[i]];
+		newCountVector = countVector;
 	}
 
 	@Override
 	public void trainOnInstanceImpl(Instance instance) {
-		int numOutputs=instance.numOutputAttributes();
-		if(countVector==null){
-			countVector=new double[numOutputs];
+		int numOutputs = instance.numOutputAttributes();
+		if (countVector == null) {
+			countVector = new double[numOutputs];
 		}
-		double weight=instance.weight();
-		for(int i=0; i<numOutputs;i++){
-			countVector[i]+=weight*instance.valueOutputAttribute(i);
+		double weight = instance.weight();
+		for (int i = 0; i < numOutputs; i++) {
+			countVector[i] += weight * instance.valueOutputAttribute(i);
 		}
-		numInstances+=weight;
+		numInstances += weight;
 	}
 
 	@Override
 	public Prediction getPredictionForInstance(Instance inst) {
-		int numOutputs=inst.numOutputAttributes();
-		Prediction p=new MultiLabelClassificationPrediction(numOutputs);
-		if(countVector!=null){
-			for (int i=0; i<numOutputs; i++){
-				double frac=countVector[i]/numInstances;
+		int numOutputs = inst.numOutputAttributes();
+		Prediction p = new MultiLabelClassificationPrediction(numOutputs);
+		if (countVector != null) {
+			for (int i = 0; i < numOutputs; i++) {
+				double frac = countVector[i] / numInstances;
 				p.setVote(i, 1, frac);
-				p.setVote(i, 0, 1-frac);
+				p.setVote(i, 0, 1 - frac);
 			}
 		}
 		return p;
@@ -87,8 +87,8 @@ public Prediction getPredictionForInstance(Instance inst) {
 
 	@Override
 	public void resetLearningImpl() {
-		countVector=null;
-		numInstances=0;
+		countVector = null;
+		numInstances = 0;
 	}
 
 	@Override
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/MultiLabelNaiveBayes.java b/moa/src/main/java/moa/learners/predictors/core/functions/MultiLabelNaiveBayes.java
similarity index 68%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/functions/MultiLabelNaiveBayes.java
rename to moa/src/main/java/moa/learners/predictors/core/functions/MultiLabelNaiveBayes.java
index 282ed6728..b1ecc46ad 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/MultiLabelNaiveBayes.java
+++ b/moa/src/main/java/moa/learners/predictors/core/functions/MultiLabelNaiveBayes.java
@@ -17,27 +17,27 @@
  *
  *
  */
-package moa.classifiers.rules.multilabel.functions;
+package moa.learners.predictors.core.functions;
 
-import moa.classifiers.bayes.NaiveBayes;
-import moa.learners.MultiLabelClassifier;
+import moa.learners.predictors.MultiLabelClassifier;
+import moa.learners.predictors.bayes.NaiveBayes;
 import moa.options.ClassOption;
 
 /**
- *  Binary relevance with Naive Bayes
+ * Binary relevance with Naive Bayes
  */
 
-public class MultiLabelNaiveBayes extends AbstractAMRulesFunctionBasicMlLearner implements MultiLabelClassifier, AMRulesFunction {
+public class MultiLabelNaiveBayes extends AbstractAMRulesFunctionBasicMlLearner
+		implements MultiLabelClassifier, AMRulesFunction {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
-	
-	@Override
-	protected void init(){
-		baseLearnerOption=new ClassOption("baseLearner", 'l',
-				"NaiveBayes", NaiveBayes.class, "moa.classifiers.bayes.NaiveBayes");
+
+	protected MultiLabelNaiveBayes() {
+		super();
+		regressorOption = new ClassOption("baseLearner", 'l', "NaiveBayes", NaiveBayes.class, "NaiveBayes");
 	}
 
 	@Override
@@ -48,10 +48,10 @@ public String getPurposeString() {
 
 	@Override
 	public void resetWithMemory() {
-		//for (int i = 0; i < this.ensemble.length; i++) {
-		//TODO: JD - reset all statistics? how can we keep some memory?
-		//}
-		
+		// for (int i = 0; i < this.ensemble.length; i++) {
+		// TODO: JD - reset all statistics? how can we keep some memory?
+		// }
+
 	}
 
 }
diff --git a/moa/src/main/java/moa/learners/predictors/core/functions/MultiLabelPerceptronClassification.java b/moa/src/main/java/moa/learners/predictors/core/functions/MultiLabelPerceptronClassification.java
new file mode 100644
index 000000000..a97d8e284
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/functions/MultiLabelPerceptronClassification.java
@@ -0,0 +1,57 @@
+/*
+ *    MultiLabelPerceptronClassification.java
+ *    Copyright (C) 2017 University of Porto, Portugal
+ *    @author R. Sousa, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.predictors.core.functions;
+
+import moa.learners.predictors.MultiLabelClassifier;
+import moa.options.ClassOption;
+
+/**
+ * Multi-Label perceptron classifier (by Binary Relevance). This method computes
+ * a perceptron classifier per output
+ * 
+ * @author RSousa
+ * @version $Revision: 1 $
+ */
+public class MultiLabelPerceptronClassification extends AbstractAMRulesFunctionBasicMlLearner
+		implements MultiLabelClassifier, AMRulesFunction {
+
+	private static final long serialVersionUID = 1L;
+
+	public MultiLabelPerceptronClassification() {
+		// super();
+		regressorOption = new ClassOption("baseLearner", 'l', "Perceptron",
+				moa.learners.predictors.functions.Perceptron.class, "Perceptron");
+
+	}
+
+	@Override
+	public String getPurposeString() {
+		return "Uses an ensemble of rules.Perceptron to preform multitarget regression.\n"
+				+ "Extends BasicMultiLabelLearner by allowing only rules.Perceptron";
+	}
+
+	@Override
+	public void resetWithMemory() {
+		// for (int i = 0; i < this.ensemble.length; i++) {
+		// TODO: JD - reset all statistics? how can we keep some memory?
+		//
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/MultiTargetMeanRegressor.java b/moa/src/main/java/moa/learners/predictors/core/functions/MultiTargetMeanRegressor.java
similarity index 69%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/functions/MultiTargetMeanRegressor.java
rename to moa/src/main/java/moa/learners/predictors/core/functions/MultiTargetMeanRegressor.java
index b55505e54..a3e9da297 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/MultiTargetMeanRegressor.java
+++ b/moa/src/main/java/moa/learners/predictors/core/functions/MultiTargetMeanRegressor.java
@@ -17,34 +17,30 @@
  *
  *
  */
-package moa.classifiers.rules.multilabel.functions;
+package moa.learners.predictors.core.functions;
 
 import com.yahoo.labs.samoa.instances.Instance;
 
-import moa.classifiers.rules.functions.TargetMean;
-import moa.learners.Classifier;
-import moa.learners.MultiTargetRegressor;
+import moa.learners.predictors.MultiTargetRegressor;
+import moa.learners.predictors.rules.functions.TargetMean;
 import moa.options.ClassOption;
 
 /**
- *  Target mean regressor
+ * Target mean regressor
  *
  */
 
-
-
 public class MultiTargetMeanRegressor extends AbstractAMRulesFunctionBasicMlLearner
 		implements MultiTargetRegressor, AMRulesFunction {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 
-	@Override
-	protected void init(){
-		baseLearnerOption=new ClassOption("baseLearner", 'l',
-				"TargetMean", TargetMean.class, "TargetMean") ;
+	public MultiTargetMeanRegressor() {
+		super();
+		regressorOption = new ClassOption("baseLearner", 'l', "TargetMean", TargetMean.class, "TargetMean");
 	}
 
 	@Override
@@ -55,15 +51,12 @@ public String getPurposeString() {
 
 	@Override
 	public void resetWithMemory() {
-		for (int i = 0; i < this.ensemble.length; i++) {
-			TargetMean tm=new TargetMean((TargetMean)this.ensemble[i]);
-			double mean=tm.getPredictionForInstance((Instance)null).asDoubleArray()[0];
+		for (int i = 0; i < this.regressors.size(); i++) {
+			TargetMean tm = new TargetMean((TargetMean) this.regressors.get(i));
+			double mean = tm.getPredictionForInstance((Instance) null).asDoubleArray()[0];
 			tm.reset(mean, 1);
-			this.ensemble[i] = tm;
+			this.regressors.set(i, tm);
 		}
 	}
-	
-	
-	
-	
+
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/MultiTargetPerceptronRegressor.java b/moa/src/main/java/moa/learners/predictors/core/functions/MultiTargetPerceptronRegressor.java
similarity index 67%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/functions/MultiTargetPerceptronRegressor.java
rename to moa/src/main/java/moa/learners/predictors/core/functions/MultiTargetPerceptronRegressor.java
index a3d530721..249ef2073 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/functions/MultiTargetPerceptronRegressor.java
+++ b/moa/src/main/java/moa/learners/predictors/core/functions/MultiTargetPerceptronRegressor.java
@@ -17,31 +17,28 @@
  *
  *
  */
-package moa.classifiers.rules.multilabel.functions;
+package moa.learners.predictors.core.functions;
 
-import moa.classifiers.rules.functions.Perceptron;
-import moa.learners.Classifier;
-import moa.learners.MultiTargetRegressor;
+import moa.learners.predictors.MultiTargetRegressor;
+import moa.learners.predictors.rules.functions.Perceptron;
 import moa.options.ClassOption;
 
 /**
  * Binary relevance with a regression perceptron
  */
 
-
-
 public class MultiTargetPerceptronRegressor extends AbstractAMRulesFunctionBasicMlLearner
 		implements MultiTargetRegressor, AMRulesFunction {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
-	
-	@Override
-	protected void init(){
-		baseLearnerOption=new ClassOption("baseLearner", 'l',
-				"Perceptron", Perceptron.class, "Perceptron");
+
+	public MultiTargetPerceptronRegressor() {
+		super();
+		regressorOption = new ClassOption("baseLearner", 'l', "Perceptron", Perceptron.class, "Perceptron");
+		// TODO Auto-generated constructor stub
 	}
 
 	@Override
@@ -52,15 +49,12 @@ public String getPurposeString() {
 
 	@Override
 	public void resetWithMemory() {
-		for (int i = 0; i < this.ensemble.length; i++) {
-			Perceptron p=new Perceptron((Perceptron)this.ensemble[i]);
-			p.setLearningRatio(((Perceptron)getPreparedClassOption(baseLearnerOption)).learningRatioOption.getValue());
-			this.ensemble[i] = p;
+		for (int i = 0; i < this.regressors.size(); i++) {
+			Perceptron p = new Perceptron((Perceptron) this.regressors.get(i));
+			p.setLearningRatio(((Perceptron) getPreparedClassOption(regressorOption)).learningRatioOption.getValue());
+			this.regressors.set(i, p);
 		}
-		
+
 	}
-	
-	
-	
-	
+
 }
diff --git a/moa/src/main/java/moa/learners/predictors/core/functions/StackedPredictor.java b/moa/src/main/java/moa/learners/predictors/core/functions/StackedPredictor.java
new file mode 100644
index 000000000..a9df2da17
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/functions/StackedPredictor.java
@@ -0,0 +1,405 @@
+/*
+ *    StackedPredictor.java
+ *    Copyright (C) 2017 University of Porto, Portugal
+ *    @author J. Duarte, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.predictors.core.functions;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.Random;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Measurement;
+import moa.learners.predictors.AbstractMultiTargetRegressor;
+import moa.learners.predictors.MultiTargetRegressor;
+import moa.learners.predictors.rules.core.Utils;
+
+public class StackedPredictor extends AbstractMultiTargetRegressor implements MultiTargetRegressor, AMRulesFunction {
+
+	/**
+	 * Multi-Target Stacked Predictor for regression
+	 */
+	private static final long serialVersionUID = 1L;
+
+	// THRESHOLD for normalizing attribute and target values
+	private final double SD_THRESHOLD = 0.0000001;
+
+	// Parameters and options
+	public FlagOption constantLearningRatioDecayOption = new FlagOption("learningRatio_Decay_set_constant", 'd',
+			"Learning Ratio Decay in Perceptron set to be constant. (The next parameter).");
+
+	public FloatOption learningRatioOption = new FloatOption("learningRatio", 'l',
+			"Learning Ratio to use for training the 1st layer.", 0.025);
+
+	public FloatOption learningRatio2ndLayerOption = new FloatOption("learningRatio2ndLayer", 'n',
+			"Learning Ratio to use in the second layer.", 0.001);
+
+	public FloatOption learningRateDecayOption = new FloatOption("learningRateDecay", 'm',
+			" Learning Rate decay to use for training the 1st layer.", 0.001);
+
+	public FlagOption skipStackingOption = new FlagOption("skipStackingOption", 's',
+			"Predicts the outputs of the first layer (no dependence among output is computed)");
+
+//	public IntOption randomSeedOption = new IntOption("randomSeed", 'r',
+//			"Seed for random behaviour of the classifier.", 1);
+
+	public FlagOption printWeightsOption = new FlagOption("printWeights", 'p',
+			"Outputs the 2nd layer weights as measurements.");
+
+	/*
+	 * Other class attributes
+	 */
+
+	private boolean hasStarted;
+	// Weight seen so far
+	private double count;
+
+	// Input attributes statistics
+	private double[] inAttrSum;
+	private double[] inAttrSquaredSum;
+
+	// Output attributes statistics
+	private double[] outAttrSum;
+	private double[] outAttrSquaredSum;
+
+	// First Layer Weights
+	private double[][] layer1Weights;
+
+	// Second Layer Weights
+	private double[][] layer2Weights;
+
+	// Algorithm auxiliary variables
+	double currentLearningRate;
+
+	LinkedList<Integer> numericIndices;
+
+	/*
+	 * Algorithm's behavior
+	 */
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	@Override
+	public void resetWithMemory() {
+		currentLearningRate = this.learningRatioOption.getValue();
+
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance instance) {
+		int numOutputs = instance.numOutputAttributes();
+
+		if (!hasStarted) {
+			hasStarted = true;
+			numericIndices = new LinkedList<>();
+			// Initialize numericAttributesIndex
+			for (int i = 0; i < instance.numInputAttributes(); i++)
+				if (instance.inputAttribute(i).isNumeric())
+					numericIndices.add(i);
+
+			int numInputs = numericIndices.size();
+			inAttrSum = new double[numInputs];
+			inAttrSquaredSum = new double[numInputs];
+
+			outAttrSum = new double[numOutputs];
+			outAttrSquaredSum = new double[numOutputs];
+
+			layer1Weights = new double[numInputs + 1][numOutputs];
+			layer2Weights = new double[numOutputs + 1][numOutputs];
+
+			/*
+			 * Initialize first layer randomly uniform between -1 and 1 Initialize second
+			 * layer such that the weights between correspondent outputs are 1 and the
+			 * remaining are 0
+			 */
+			for (int j = 0; j < numOutputs; j++) {
+				// Iterator<Integer> it=numericIndices.iterator();
+				for (int i = 0; i < numInputs + 1; i++)
+					// while(it.hasNext())
+					layer1Weights[i][j] = 2 * this.classifierRandom.nextDouble() - 1;
+				layer2Weights[j][j] = 1.0;
+			}
+
+			/*
+			 * for (int i=0; i<numOutputs+1; i++) for (int j=0; j<numOutputs; j++)
+			 * layer2Weights[i][j]= 2 * this.classifierRandom.nextDouble() - 1;
+			 */
+
+		}
+
+		/*
+		 * Update statistics
+		 */
+		int numInputs = numericIndices.size();
+		// Update input statistics
+		double w = instance.weight();
+		count += w;
+		Iterator<Integer> it = numericIndices.iterator();
+		int ct = 0;
+		while (it.hasNext()) {
+			double value = instance.valueInputAttribute(it.next());
+			inAttrSum[ct] += value * w;
+			inAttrSquaredSum[ct] += value * value * w;
+			ct++;
+		}
+
+		// Update output statistics
+		for (int i = 0; i < numOutputs; i++) {
+			double value = instance.valueOutputAttribute(i);
+			outAttrSum[i] += value * w;
+			outAttrSquaredSum[i] += value * value * w;
+		}
+
+		/*
+		 * Learn new weights
+		 */
+
+		// predict outputs
+		double[] normInputs = getNormalizedInput(instance);
+		// 1st Layer
+		double[] firstLayerOutput = predict1stLayer(normInputs);
+		// 2nd Layer
+		double[] secondLayerOutput = null;
+		if (!skipStackingOption.isSet()) {
+			secondLayerOutput = predict2ndLayer(firstLayerOutput);
+		}
+
+		if (!constantLearningRatioDecayOption.isSet()) {
+			currentLearningRate = learningRatioOption.getValue()
+					/ (1 + count * this.learningRateDecayOption.getValue());
+		}
+
+		// update weights
+		// 1st Layer
+		double[] normOutputs = getNormalizedOutput(instance);
+		for (int j = 0; j < numOutputs; j++) {
+			double delta = normOutputs[j] - firstLayerOutput[j];
+			double sumLayer = 0;
+			for (int i = 0; i < numInputs; i++) {
+				layer1Weights[i][j] += currentLearningRate * delta * normInputs[i] * instance.weight();
+				sumLayer += Math.abs(layer1Weights[i][j]);
+			}
+
+			layer1Weights[numInputs][j] += currentLearningRate * delta * instance.weight();
+			sumLayer += Math.abs(layer1Weights[numInputs][j]);
+			if (sumLayer > (numInputs)) {
+				for (int i = 0; i < (numInputs + 1); i++)
+					layer1Weights[i][j] /= sumLayer;
+			}
+		}
+		if (!skipStackingOption.isSet()) {
+			// update weights
+			// 2nd Layer
+			double learningRate2ndLayer = learningRatio2ndLayerOption.getValue();
+			for (int j = 0; j < numOutputs; j++) {
+				double delta = normOutputs[j] - secondLayerOutput[j];
+				double sumLayer = 0;
+				for (int i = 0; i < numOutputs; i++) {
+					layer2Weights[i][j] += learningRate2ndLayer * delta * firstLayerOutput[i] * instance.weight();
+					sumLayer += Math.abs(layer2Weights[i][j]);
+				}
+
+				layer2Weights[numOutputs][j] += learningRate2ndLayer * delta * instance.weight();
+				sumLayer += Math.abs(layer2Weights[numOutputs][j]);
+				if (sumLayer > (numOutputs)) {
+					for (int i = 0; i < (numOutputs + 1); i++)
+						layer2Weights[i][j] /= sumLayer;
+				}
+			}
+
+		}
+
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		Prediction pred = null;
+		if (hasStarted) {
+			int numOutputs = outAttrSum.length;
+			pred = new MultiLabelClassificationPrediction(numOutputs);
+
+			double[] normInputs = getNormalizedInput(inst);
+			double[] firstLayerOutput = predict1stLayer(normInputs);
+
+			double[] denormalizedOutput = null;
+			if (!skipStackingOption.isSet()) {
+				double[] secondLayerOutput = predict2ndLayer(firstLayerOutput);
+				denormalizedOutput = getDenormalizedOutput(secondLayerOutput);
+			} else
+				denormalizedOutput = getDenormalizedOutput(firstLayerOutput);
+
+			for (int i = 0; i < numOutputs; i++)
+				pred.setVotes(i, new double[] { denormalizedOutput[i] });
+		}
+		return pred;
+	}
+
+	@Override
+	public void resetLearningImpl() {
+
+		hasStarted = false;
+		count = 0;
+		inAttrSum = null;
+		inAttrSquaredSum = null;
+
+		outAttrSum = null;
+		outAttrSquaredSum = null;
+
+		layer1Weights = null;
+		layer2Weights = null;
+
+		numericIndices = null;
+
+		currentLearningRate = this.learningRatioOption.getValue();
+
+		// TODO: JD Check if random generator is somehow overridden
+		this.classifierRandom = new Random();
+		this.classifierRandom.setSeed(randomSeedOption.getValue());
+
+	}
+
+	protected double[] getNormalizedInput(Instance instance) {
+		int numInputs = numericIndices.size();
+		double[] normalizedInput = new double[numInputs];
+		Iterator<Integer> it = numericIndices.iterator();
+		int i = 0;
+		while (it.hasNext()) {
+			double mean = inAttrSum[i] / count;
+			double std = Utils.computeSD(inAttrSquaredSum[i], inAttrSum[i], count);
+			normalizedInput[i] = instance.valueInputAttribute(it.next()) - mean;
+			if (std > SD_THRESHOLD)
+				normalizedInput[i] /= std;
+			i++;
+		}
+		return normalizedInput;
+	}
+
+	protected double[] getNormalizedOutput(Instance instance) {
+		int numOutputs = instance.numOutputAttributes();
+		double[] normalizedOutput = new double[numOutputs];
+		for (int i = 0; i < numOutputs; i++) {
+			double mean = outAttrSum[i] / count;
+			double std = Utils.computeSD(outAttrSquaredSum[i], outAttrSum[i], count);
+			normalizedOutput[i] = instance.valueOutputAttribute(i) - mean;
+			if (std > SD_THRESHOLD)
+				normalizedOutput[i] /= std;
+		}
+		return normalizedOutput;
+	}
+
+	protected double[] getDenormalizedOutput(double[] normOutputs) {
+		int numOutputs = normOutputs.length;
+		double[] denormalizedOutput = new double[numOutputs];
+
+		for (int i = 0; i < numOutputs; i++) {
+			double mean = outAttrSum[i] / count;
+			double std = Utils.computeSD(outAttrSquaredSum[i], outAttrSum[i], count);
+			if (std > SD_THRESHOLD)
+				denormalizedOutput[i] = normOutputs[i] * std + mean;
+			else
+				denormalizedOutput[i] = normOutputs[i] + mean;
+		}
+		return denormalizedOutput;
+	}
+
+	private double[] predict1stLayer(double[] normInputs) {
+		int numInputs = numericIndices.size();
+		int numOutputs = this.outAttrSum.length;
+
+		double[] firstLayerOutput = new double[numOutputs];
+		for (int j = 0; j < numOutputs; j++) {
+			for (int i = 0; i < numInputs; i++)
+				firstLayerOutput[j] += normInputs[i] * layer1Weights[i][j];
+			firstLayerOutput[j] += layer1Weights[numInputs][j]; // bias
+		}
+		return firstLayerOutput;
+	}
+
+	private double[] predict2ndLayer(double[] firstLayerOutput) {
+		int numOutputs = firstLayerOutput.length;
+		double[] secondLayerOutput = new double[numOutputs];
+		for (int j = 0; j < numOutputs; j++) {
+			for (int i = 0; i < numOutputs; i++)
+				secondLayerOutput[j] += firstLayerOutput[i] * layer2Weights[i][j];
+			secondLayerOutput[j] += layer2Weights[numOutputs][j]; // bias
+		}
+		return secondLayerOutput;
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		Measurement[] measurements = null;
+		if (printWeightsOption.isSet()) {
+			int numWeights = this.layer2Weights.length;
+			measurements = new Measurement[numWeights * (numWeights - 1)];
+			int ct = 0;
+			for (int j = 0; j < numWeights - 1; j++) {
+				for (int i = 0; i < numWeights - 1; i++) {
+					measurements[ct++] = new Measurement("W Out" + (i + 1) + ": Out" + (j + 1), layer2Weights[i][j]);
+				}
+
+				measurements[ct++] = new Measurement("W Bias: Out" + (j + 1), layer2Weights[numWeights - 1][j]);
+			}
+		}
+		return measurements;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void selectOutputsToLearn(int[] outputAtributtes) {
+
+		// Remove weights for unselected outputs
+		int numOutputs = outputAtributtes.length;
+		double[] newOutAttrSum = new double[numOutputs];
+		double[] newOutAttrSquaredSum = new double[numOutputs];
+		int numInputsPlus1 = layer1Weights.length;
+
+		double[][] newLayer1Weights = new double[numInputsPlus1][numOutputs];
+		double[][] newLayer2Weights = new double[numInputsPlus1][numOutputs];
+
+		int oldNumOutputs = layer2Weights.length - 1;
+		for (int j = 0; j < numOutputs; j++) {
+			int out = outputAtributtes[j];
+			newOutAttrSum[j] = outAttrSum[out];
+			newOutAttrSquaredSum[j] = outAttrSquaredSum[out];
+			for (int i = 0; i < numInputsPlus1; i++)
+				newLayer1Weights[i][j] = layer1Weights[i][out];
+			for (int i = 0; i < numOutputs; i++) {
+				int out2 = outputAtributtes[i];
+				newLayer2Weights[i][j] = layer2Weights[out2][out];
+			}
+			newLayer2Weights[numOutputs][j] = layer2Weights[oldNumOutputs][out];
+		}
+		outAttrSum = newOutAttrSum;
+		outAttrSquaredSum = newOutAttrSquaredSum;
+		layer1Weights = newLayer1Weights;
+		layer2Weights = newLayer2Weights;
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/inputselectors/InputAttributesSelector.java b/moa/src/main/java/moa/learners/predictors/core/inputselectors/InputAttributesSelector.java
similarity index 79%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/inputselectors/InputAttributesSelector.java
rename to moa/src/main/java/moa/learners/predictors/core/inputselectors/InputAttributesSelector.java
index 78ff04e09..5e23ce7e1 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/inputselectors/InputAttributesSelector.java
+++ b/moa/src/main/java/moa/learners/predictors/core/inputselectors/InputAttributesSelector.java
@@ -18,12 +18,12 @@
  *
  */
 
-package moa.classifiers.rules.multilabel.inputselectors;
+package moa.learners.predictors.core.inputselectors;
 
-import moa.classifiers.rules.core.AttributeExpansionSuggestion;
+import moa.learners.predictors.rules.core.AttributeExpansionSuggestion;
 import moa.options.OptionHandler;
 
-public interface InputAttributesSelector extends OptionHandler{
-	//must be descending sorted
+public interface InputAttributesSelector extends OptionHandler {
+	// must be descending sorted
 	int[] getNextInputIndices(AttributeExpansionSuggestion[] sortedSplitSuggestions);
 }
diff --git a/moa/src/main/java/moa/learners/predictors/core/inputselectors/MeritThreshold.java b/moa/src/main/java/moa/learners/predictors/core/inputselectors/MeritThreshold.java
new file mode 100644
index 000000000..8964f0103
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/inputselectors/MeritThreshold.java
@@ -0,0 +1,82 @@
+/*
+ *    MeritThreshold.java
+ *    Copyright (C) 2017 University of Porto, Portugal
+ *    @author J. Duarte, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.predictors.core.inputselectors;
+
+import com.github.javacliparser.FloatOption;
+
+import moa.core.ObjectRepository;
+import moa.learners.predictors.rules.core.AttributeExpansionSuggestion;
+import moa.options.AbstractOptionHandler;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Input selection algorithm based on Merit threshold
+ */
+
+public class MeritThreshold extends AbstractOptionHandler implements InputAttributesSelector {
+
+	/**
+	 *
+	 */
+	private static final long serialVersionUID = 1L;
+
+	public FloatOption percentageThresholdOption = new FloatOption("percentageThreshold", 'p',
+			"Allowed merit decrease in percentage of best input attribute.", 0.1, 0.0, 1.0);
+
+	@Override
+	public int[] getNextInputIndices(AttributeExpansionSuggestion[] sortedSplitSuggestions) {
+		int[] nextInput = null;
+		if (sortedSplitSuggestions.length > 0) {
+			int[] temp = new int[sortedSplitSuggestions.length]; // use list instead?
+			double threshold = sortedSplitSuggestions[sortedSplitSuggestions.length - 1].merit
+					* (percentageThresholdOption.getValue());
+			temp[0] = sortedSplitSuggestions[sortedSplitSuggestions.length - 1].predicate.getAttributeIndex();
+			int c = 1;
+			for (int i = sortedSplitSuggestions.length - 2; i >= 0
+					&& sortedSplitSuggestions[i].merit >= threshold; i--) {
+				temp[c] = sortedSplitSuggestions[i].getPredicate().getAttributeIndex();
+				c++;
+			}
+			if (c == 1 && sortedSplitSuggestions.length > 1) { // if only one is selected, add a second attribute for
+																// computing hoeffding bound
+				c = 2;
+				temp[1] = sortedSplitSuggestions[sortedSplitSuggestions.length - 2].predicate.getAttributeIndex();
+			}
+			nextInput = new int[c];
+			for (int i = 0; i < c; i++) {
+				nextInput[i] = temp[i];
+			}
+
+		}
+		// System.out.println("Indices: " + java.util.Arrays.toString(nextInput));
+		return nextInput;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+	}
+
+}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/inputselectors/SelectAllInputs.java b/moa/src/main/java/moa/learners/predictors/core/inputselectors/SelectAllInputs.java
similarity index 65%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/inputselectors/SelectAllInputs.java
rename to moa/src/main/java/moa/learners/predictors/core/inputselectors/SelectAllInputs.java
index 46de0d2da..fddb6e280 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/inputselectors/SelectAllInputs.java
+++ b/moa/src/main/java/moa/learners/predictors/core/inputselectors/SelectAllInputs.java
@@ -17,40 +17,36 @@
  *
  *
  */
-package moa.classifiers.rules.multilabel.inputselectors;
+package moa.learners.predictors.core.inputselectors;
 
-import moa.classifiers.rules.core.AttributeExpansionSuggestion;
 import moa.core.ObjectRepository;
+import moa.learners.predictors.rules.core.AttributeExpansionSuggestion;
 import moa.options.AbstractOptionHandler;
 import moa.tasks.TaskMonitor;
 
 /**
- *  Does not selects inputs
+ * Does not selects inputs
  */
 
 public class SelectAllInputs extends AbstractOptionHandler implements InputAttributesSelector {
 
-
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 
-
 	@Override
-	public int[] getNextInputIndices(
-			AttributeExpansionSuggestion[] sortedSplitSuggestions) {
-		int [] nextInput=null;
-		if(sortedSplitSuggestions.length>0){
-			nextInput=new int[sortedSplitSuggestions.length];
-			for (int i=0; i<sortedSplitSuggestions.length; i++){
-				nextInput[i]=sortedSplitSuggestions[i].getPredicate().getAttributeIndex();		
+	public int[] getNextInputIndices(AttributeExpansionSuggestion[] sortedSplitSuggestions) {
+		int[] nextInput = null;
+		if (sortedSplitSuggestions.length > 0) {
+			nextInput = new int[sortedSplitSuggestions.length];
+			for (int i = 0; i < sortedSplitSuggestions.length; i++) {
+				nextInput[i] = sortedSplitSuggestions[i].getPredicate().getAttributeIndex();
 			}
 		}
 		return nextInput;
 	}
 
-	
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
 		// TODO Auto-generated method stub
@@ -58,12 +54,8 @@ public void getDescription(StringBuilder sb, int indent) {
 	}
 
 	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
-		
-	}
-
-
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
 
+	}
 
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/instancetransformers/InstanceAttributesSelector.java b/moa/src/main/java/moa/learners/predictors/core/instancetransformers/InstanceAttributesSelector.java
similarity index 64%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/instancetransformers/InstanceAttributesSelector.java
rename to moa/src/main/java/moa/learners/predictors/core/instancetransformers/InstanceAttributesSelector.java
index 9132f4e7c..d82c93b64 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/instancetransformers/InstanceAttributesSelector.java
+++ b/moa/src/main/java/moa/learners/predictors/core/instancetransformers/InstanceAttributesSelector.java
@@ -18,8 +18,7 @@
  *
  */
 
-
-package moa.classifiers.rules.multilabel.instancetransformers;
+package moa.learners.predictors.core.instancetransformers;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -30,72 +29,66 @@
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 /**
- * Transforms instances considering both a subset of input attributes
- * and a subset of output attributes
+ * Transforms instances considering both a subset of input attributes and a
+ * subset of output attributes
  *
  * @author João Duarte (joaomaiaduarte@gmail.com)
  */
 public class InstanceAttributesSelector extends InstanceOutputAttributesSelector implements InstanceTransformer {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 
 	public InstancesHeader targetInstances;
-	public int [] targetInputIndices;
-	public int [] targetOutputIndices;
+	public int[] targetInputIndices;
+	public int[] targetOutputIndices;
 	public int numSourceInstancesOutputs;
 
-	public InstanceAttributesSelector(InstancesHeader sourceInstances, int [] targetInputIndices, int [] targetOutputIndices){
-		this.targetInputIndices=targetInputIndices;
-		this.targetOutputIndices=targetOutputIndices;
-		this.numSourceInstancesOutputs=sourceInstances.numOutputAttributes();
-
+	public InstanceAttributesSelector(InstancesHeader sourceInstances, int[] targetInputIndices,
+			int[] targetOutputIndices) {
+		this.targetInputIndices = targetInputIndices;
+		this.targetOutputIndices = targetOutputIndices;
+		this.numSourceInstancesOutputs = sourceInstances.numOutputAttributes();
 
-		int totAttributes=this.targetInputIndices.length+this.targetOutputIndices.length;
-		targetInstances= new InstancesHeader();
+		int totAttributes = this.targetInputIndices.length + this.targetOutputIndices.length;
+		targetInstances = new InstancesHeader();
 
-		List<Attribute> v = new ArrayList<Attribute>(totAttributes);
-		List<Integer> indexValues = new ArrayList<Integer>(totAttributes);
-		for (int i=0; i<this.targetInputIndices.length;i++)
-		{
+		List<Attribute> v = new ArrayList<>(totAttributes);
+		List<Integer> indexValues = new ArrayList<>(totAttributes);
+		for (int i = 0; i < this.targetInputIndices.length; i++) {
 			v.add(sourceInstances.inputAttribute(this.targetInputIndices[i]));
 		}
 
-		ArrayList<Integer> outputIndices = new ArrayList<Integer>();
-		for (int i=0; i<this.targetOutputIndices.length;i++)
-		{
+		ArrayList<Integer> outputIndices = new ArrayList<>();
+		for (int i = 0; i < this.targetOutputIndices.length; i++) {
 			v.add(sourceInstances.outputAttribute(this.targetOutputIndices[i]));
 			outputIndices.add(this.targetInputIndices.length + i);
 		}
 
 		targetInstances.setAttributes(v);
-		
+
 		targetInstances.setOutputIndexes(outputIndices);
 		targetInstances.setInputIndexes();
 	}
 
 	@Override
 	public Instance sourceInstanceToTarget(Instance sourceInstance) {
-		double [] attValues = new double[targetInstances.numAttributes()];
-		Instance newInstance=new InstanceImpl(sourceInstance.weight(),attValues);
-		for (int i=0; i<this.targetInputIndices.length; i++){
+		double[] attValues = new double[targetInstances.numAttributes()];
+		Instance newInstance = new InstanceImpl(sourceInstance.weight(), attValues);
+		for (int i = 0; i < this.targetInputIndices.length; i++) {
 			newInstance.setValue(i, sourceInstance.valueInputAttribute(targetInputIndices[i]));
 		}
-		for (int i=0; i<this.targetOutputIndices.length; i++){
+		for (int i = 0; i < this.targetOutputIndices.length; i++) {
 			newInstance.setValue(i, sourceInstance.valueOutputAttribute(targetOutputIndices[i]));
 		}
 		newInstance.setDataset(targetInstances);
 		return newInstance;
 	}
 
-
-
 	@Override
-	public void getDescription(StringBuilder sb, int indent) {	
+	public void getDescription(StringBuilder sb, int indent) {
 	}
 
-
-
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/instancetransformers/InstanceOutputAttributesSelector.java b/moa/src/main/java/moa/learners/predictors/core/instancetransformers/InstanceOutputAttributesSelector.java
similarity index 63%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/instancetransformers/InstanceOutputAttributesSelector.java
rename to moa/src/main/java/moa/learners/predictors/core/instancetransformers/InstanceOutputAttributesSelector.java
index 794cba922..746c04474 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/instancetransformers/InstanceOutputAttributesSelector.java
+++ b/moa/src/main/java/moa/learners/predictors/core/instancetransformers/InstanceOutputAttributesSelector.java
@@ -18,7 +18,7 @@
  *
  */
 
-package moa.classifiers.rules.multilabel.instancetransformers;
+package moa.learners.predictors.core.instancetransformers;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -42,50 +42,48 @@ public class InstanceOutputAttributesSelector extends AbstractMOAObject implemen
 	private static final long serialVersionUID = 1L;
 
 	public InstancesHeader targetInstances;
-	public int [] targetOutputIndices;
+	public int[] targetOutputIndices;
 	public int numSourceInstancesOutputs;
 
-	public InstanceOutputAttributesSelector(){
-		
+	public InstanceOutputAttributesSelector() {
+
 	}
-	public InstanceOutputAttributesSelector(InstancesHeader sourceInstances, int [] targetOutputIndices){
-		this.targetOutputIndices=targetOutputIndices;
-		this.numSourceInstancesOutputs=sourceInstances.numOutputAttributes();
 
-		int totAttributes=sourceInstances.numInputAttributes()+this.targetOutputIndices.length;
-		targetInstances= new InstancesHeader();
+	public InstanceOutputAttributesSelector(InstancesHeader sourceInstances, int[] targetOutputIndices) {
+		this.targetOutputIndices = targetOutputIndices;
+		this.numSourceInstancesOutputs = sourceInstances.numOutputAttributes();
+
+		int totAttributes = sourceInstances.numInputAttributes() + this.targetOutputIndices.length;
+		targetInstances = new InstancesHeader();
 
-		List<Attribute> v = new ArrayList<Attribute>(totAttributes);
-		int numInputs=sourceInstances.numInputAttributes();
-		for (int i=0; i<numInputs;i++)
-		{
+		List<Attribute> v = new ArrayList<>(totAttributes);
+		int numInputs = sourceInstances.numInputAttributes();
+		for (int i = 0; i < numInputs; i++) {
 			v.add(sourceInstances.inputAttribute(i));
 		}
 
-		ArrayList<Integer> outputIndices = new ArrayList<Integer>();
-		for (int i=0; i<this.targetOutputIndices.length;i++)
-		{
+		ArrayList<Integer> outputIndices = new ArrayList<>();
+		for (int i = 0; i < this.targetOutputIndices.length; i++) {
 			v.add(sourceInstances.outputAttribute(this.targetOutputIndices[i]));
 			outputIndices.add(numInputs + i);
 		}
 
 		targetInstances.setAttributes(v);
-		
+
 		targetInstances.setOutputIndexes(outputIndices);
 		targetInstances.setInputIndexes();
 	}
 
-
 	@Override
 	public Instance sourceInstanceToTarget(Instance sourceInstance) {
-		double [] attValues = new double[targetInstances.numAttributes()];
-		Instance newInstance=new InstanceImpl(sourceInstance.weight(),attValues);
-		int numInputs=this.targetInstances.numInputAttributes();
-		for (int i=0; i<numInputs; i++){
+		double[] attValues = new double[targetInstances.numAttributes()];
+		Instance newInstance = new InstanceImpl(sourceInstance.weight(), attValues);
+		int numInputs = this.targetInstances.numInputAttributes();
+		for (int i = 0; i < numInputs; i++) {
 			newInstance.setValue(i, sourceInstance.valueInputAttribute(i));
 		}
-		for (int i=0; i<this.targetOutputIndices.length; i++){
-			newInstance.setValue(numInputs+i, sourceInstance.valueOutputAttribute(targetOutputIndices[i]));
+		for (int i = 0; i < this.targetOutputIndices.length; i++) {
+			newInstance.setValue(numInputs + i, sourceInstance.valueOutputAttribute(targetOutputIndices[i]));
 		}
 		newInstance.setDataset(targetInstances);
 		return newInstance;
@@ -93,18 +91,15 @@ public Instance sourceInstanceToTarget(Instance sourceInstance) {
 
 	@Override
 	public Prediction targetPredictionToSource(Prediction targetPrediction) {
-		Prediction sourcePrediction=new MultiLabelClassificationPrediction(this.numSourceInstancesOutputs);
-		for (int i=0; i<targetPrediction.numOutputAttributes();i++){
+		Prediction sourcePrediction = new MultiLabelClassificationPrediction(this.numSourceInstancesOutputs);
+		for (int i = 0; i < targetPrediction.numOutputAttributes(); i++) {
 			sourcePrediction.setVotes(this.targetOutputIndices[i], targetPrediction.getVotes(i));
 		}
 		return sourcePrediction;
 	}
 
-
 	@Override
-	public void getDescription(StringBuilder sb, int indent) {	
+	public void getDescription(StringBuilder sb, int indent) {
 	}
 
-
-
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/instancetransformers/InstanceTransformer.java b/moa/src/main/java/moa/learners/predictors/core/instancetransformers/InstanceTransformer.java
similarity index 78%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/instancetransformers/InstanceTransformer.java
rename to moa/src/main/java/moa/learners/predictors/core/instancetransformers/InstanceTransformer.java
index d8dd70e8e..d6dfde777 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/instancetransformers/InstanceTransformer.java
+++ b/moa/src/main/java/moa/learners/predictors/core/instancetransformers/InstanceTransformer.java
@@ -18,7 +18,7 @@
  *
  */
 
-package moa.classifiers.rules.multilabel.instancetransformers;
+package moa.learners.predictors.core.instancetransformers;
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
@@ -31,9 +31,10 @@
  * @author João Duarte (joaomaiaduarte@gmail.com)
  */
 
-public interface InstanceTransformer extends MOAObject{
-	
-	public Instance sourceInstanceToTarget(Instance sourceInstance);
-	public Prediction targetPredictionToSource(Prediction targetPrediction);
+public interface InstanceTransformer extends MOAObject {
+
+	Instance sourceInstanceToTarget(Instance sourceInstance);
+
+	Prediction targetPredictionToSource(Prediction targetPrediction);
 
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/instancetransformers/NoInstanceTransformation.java b/moa/src/main/java/moa/learners/predictors/core/instancetransformers/NoInstanceTransformation.java
similarity index 88%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/instancetransformers/NoInstanceTransformation.java
rename to moa/src/main/java/moa/learners/predictors/core/instancetransformers/NoInstanceTransformation.java
index 1837fc9d6..d68f180c4 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/instancetransformers/NoInstanceTransformation.java
+++ b/moa/src/main/java/moa/learners/predictors/core/instancetransformers/NoInstanceTransformation.java
@@ -18,8 +18,7 @@
  *
  */
 
-
-package moa.classifiers.rules.multilabel.instancetransformers;
+package moa.learners.predictors.core.instancetransformers;
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
@@ -32,22 +31,22 @@
  * @author João Duarte (joaomaiaduarte@gmail.com)
  */
 
-public class NoInstanceTransformation extends AbstractMOAObject implements InstanceTransformer{
+public class NoInstanceTransformation extends AbstractMOAObject implements InstanceTransformer {
 	private static final long serialVersionUID = 1L;
 
 	@Override
 	public Instance sourceInstanceToTarget(Instance sourceInstance) {
-		return sourceInstance; //.copy?
+		return sourceInstance; // .copy?
 	}
 
 	@Override
 	public Prediction targetPredictionToSource(Prediction targetPrediction) {
-		return targetPrediction; //.copy?
+		return targetPrediction; // .copy?
 	}
-	
+
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
-		
+
 	}
 
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/outputselectors/EntropyThreshold.java b/moa/src/main/java/moa/learners/predictors/core/outputselectors/EntropyThreshold.java
similarity index 53%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/outputselectors/EntropyThreshold.java
rename to moa/src/main/java/moa/learners/predictors/core/outputselectors/EntropyThreshold.java
index 840c277f6..a9c4f2138 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/outputselectors/EntropyThreshold.java
+++ b/moa/src/main/java/moa/learners/predictors/core/outputselectors/EntropyThreshold.java
@@ -14,85 +14,80 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
-package moa.classifiers.rules.multilabel.outputselectors;
+package moa.learners.predictors.core.outputselectors;
 
 import java.util.LinkedList;
 
 import com.github.javacliparser.FloatOption;
 
-import moa.classifiers.rules.core.Utils;
 import moa.core.DoubleVector;
 import moa.core.ObjectRepository;
+import moa.learners.predictors.rules.core.Utils;
 import moa.options.AbstractOptionHandler;
 import moa.tasks.TaskMonitor;
 
 /**
  * Entropy measure use by online multi-label AMRules for heuristics computation.
+ * 
  * @author RSousa
  */
-public class EntropyThreshold extends AbstractOptionHandler implements
-OutputAttributesSelector {
+public class EntropyThreshold extends AbstractOptionHandler implements OutputAttributesSelector {
 
 	/**
-	 * 
+	 *
 	 */
-	
-    @Override
-    public String getPurposeString() {
-        return "Entropy measure use by online multi-label AMRules for heuristics computation.";
-    }
-	
+
+	@Override
+	public String getPurposeString() {
+		return "Entropy measure use by online multi-label AMRules for heuristics computation.";
+	}
+
 	private static final long serialVersionUID = 1L;
 
-	public FloatOption thresholdOption = new FloatOption("Threshold",
-			'p', "Maximum allowed Entropy (entropy(new)/entropy(old)).",
-			1.0, 0.5, 2.0);
+	public FloatOption thresholdOption = new FloatOption("Threshold", 'p',
+			"Maximum allowed Entropy (entropy(new)/entropy(old)).", 1.0, 0.5, 2.0);
 
+	@Override
+	public int[] getNextOutputIndices(DoubleVector[] resultingStatistics, DoubleVector[] currentLiteralStatistics,
+			int[] currentIndices) {
 
-	public int[] getNextOutputIndices(DoubleVector[] resultingStatistics, DoubleVector[] currentLiteralStatistics, int[] currentIndices) {
-            
-		int numCurrentOutputs=resultingStatistics.length;
-		double threshold=thresholdOption.getValue();
-		
+		int numCurrentOutputs = resultingStatistics.length;
+		double threshold = thresholdOption.getValue();
 
-        //get new outputs
-		LinkedList<Integer> newOutputsList= new LinkedList<Integer>();
-		for(int i=0; i<numCurrentOutputs;i++){
+		// get new outputs
+		LinkedList<Integer> newOutputsList = new LinkedList<>();
+		for (int i = 0; i < numCurrentOutputs; i++) {
 
-            double EntRes=Utils.computeEntropy(resultingStatistics[i].getValue(0),resultingStatistics[i].getValue(1));
-			double EntCur=Utils.computeEntropy(currentLiteralStatistics[i].getValue(0),currentLiteralStatistics[i].getValue(1));
+			double EntRes = Utils.computeEntropy(resultingStatistics[i].getValue(0),
+					resultingStatistics[i].getValue(1));
+			double EntCur = Utils.computeEntropy(currentLiteralStatistics[i].getValue(0),
+					currentLiteralStatistics[i].getValue(1));
 
-                        if( (EntCur-EntRes) > 0 || EntCur==0) 
+			if ((EntCur - EntRes) > 0 || EntCur == 0)
 				newOutputsList.add(currentIndices[i]);
-                        
+
 		}
-		//list to array
-		int [] newOutputs=new int[newOutputsList.size()];
-		int ct=0;
-		for(int outIndex : newOutputsList){
-			newOutputs[ct]=outIndex;
+		// list to array
+		int[] newOutputs = new int[newOutputsList.size()];
+		int ct = 0;
+		for (int outIndex : newOutputsList) {
+			newOutputs[ct] = outIndex;
 			++ct;
 		}
 		return newOutputs;
 	}
 
-
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
 
 	}
 
-
-
 	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
 
 	}
 
 }
-
-    
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/outputselectors/OutputAttributesSelector.java b/moa/src/main/java/moa/learners/predictors/core/outputselectors/OutputAttributesSelector.java
similarity index 81%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/outputselectors/OutputAttributesSelector.java
rename to moa/src/main/java/moa/learners/predictors/core/outputselectors/OutputAttributesSelector.java
index 9b89ead79..9ddb8d25b 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/outputselectors/OutputAttributesSelector.java
+++ b/moa/src/main/java/moa/learners/predictors/core/outputselectors/OutputAttributesSelector.java
@@ -18,11 +18,12 @@
  *
  */
 
-package moa.classifiers.rules.multilabel.outputselectors;
+package moa.learners.predictors.core.outputselectors;
 
 import moa.core.DoubleVector;
 import moa.options.OptionHandler;
 
-public interface OutputAttributesSelector extends OptionHandler{
-	int[] getNextOutputIndices(DoubleVector[] resultingLiteralStatistics,DoubleVector[] currentLiteralStatistics, int[] currentIndices);
+public interface OutputAttributesSelector extends OptionHandler {
+	int[] getNextOutputIndices(DoubleVector[] resultingLiteralStatistics, DoubleVector[] currentLiteralStatistics,
+			int[] currentIndices);
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/outputselectors/SelectAllOutputs.java b/moa/src/main/java/moa/learners/predictors/core/outputselectors/SelectAllOutputs.java
similarity index 89%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/outputselectors/SelectAllOutputs.java
rename to moa/src/main/java/moa/learners/predictors/core/outputselectors/SelectAllOutputs.java
index 7cd8102d7..1b86ff584 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/outputselectors/SelectAllOutputs.java
+++ b/moa/src/main/java/moa/learners/predictors/core/outputselectors/SelectAllOutputs.java
@@ -18,7 +18,7 @@
  *
  */
 
-package moa.classifiers.rules.multilabel.outputselectors;
+package moa.learners.predictors.core.outputselectors;
 
 import moa.core.DoubleVector;
 import moa.core.ObjectRepository;
@@ -27,7 +27,7 @@
 
 public class SelectAllOutputs extends AbstractOptionHandler implements OutputAttributesSelector {
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 
@@ -39,13 +39,12 @@ public int[] getNextOutputIndices(DoubleVector[] resultingStatistics, DoubleVect
 
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
-		
+
 	}
 
 	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
-		
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+
 	}
 
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/outputselectors/StdDevThreshold.java b/moa/src/main/java/moa/learners/predictors/core/outputselectors/StdDevThreshold.java
similarity index 53%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/outputselectors/StdDevThreshold.java
rename to moa/src/main/java/moa/learners/predictors/core/outputselectors/StdDevThreshold.java
index 30d07e23a..b9f587b16 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/outputselectors/StdDevThreshold.java
+++ b/moa/src/main/java/moa/learners/predictors/core/outputselectors/StdDevThreshold.java
@@ -18,64 +18,61 @@
  *
  */
 
-package moa.classifiers.rules.multilabel.outputselectors;
+package moa.learners.predictors.core.outputselectors;
 
 import java.util.LinkedList;
 
 import com.github.javacliparser.FloatOption;
 
-import moa.classifiers.rules.core.Utils;
 import moa.core.DoubleVector;
 import moa.core.ObjectRepository;
+import moa.learners.predictors.rules.core.Utils;
 import moa.options.AbstractOptionHandler;
 import moa.tasks.TaskMonitor;
 
-public class StdDevThreshold extends AbstractOptionHandler implements
-OutputAttributesSelector {
+public class StdDevThreshold extends AbstractOptionHandler implements OutputAttributesSelector {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 
-	public FloatOption thresholdOption = new FloatOption("Threshold",
-			'p', "Maximum allowed standar deviation ratio (stdev(new)/stdev(old)).",
-			1.0, 0.5, 2.0);
+	public FloatOption thresholdOption = new FloatOption("Threshold", 'p',
+			"Maximum allowed standar deviation ratio (stdev(new)/stdev(old)).", 1.0, 0.5, 2.0);
 
-
-	public int[] getNextOutputIndices(DoubleVector[] resultingStatistics, DoubleVector[] currentLiteralStatistics, int[] currentIndices) {
-		int numCurrentOutputs=resultingStatistics.length;
-		double threshold=thresholdOption.getValue();
-		//get new outputs
-		LinkedList<Integer> newOutputsList= new LinkedList<Integer>();
-		for(int i=0; i<numCurrentOutputs;i++){
-			double stdRes=Math.sqrt(Utils.computeVariance(resultingStatistics[i].getValue(0),resultingStatistics[i].getValue(3),resultingStatistics[i].getValue(4)));
-			double stdCur=Math.sqrt(Utils.computeVariance(currentLiteralStatistics[i].getValue(0),currentLiteralStatistics[i].getValue(3),currentLiteralStatistics[i].getValue(4)));
-	
-			if(stdRes/stdCur<=threshold)
+	@Override
+	public int[] getNextOutputIndices(DoubleVector[] resultingStatistics, DoubleVector[] currentLiteralStatistics,
+			int[] currentIndices) {
+		int numCurrentOutputs = resultingStatistics.length;
+		double threshold = thresholdOption.getValue();
+		// get new outputs
+		LinkedList<Integer> newOutputsList = new LinkedList<>();
+		for (int i = 0; i < numCurrentOutputs; i++) {
+			double stdRes = Math.sqrt(Utils.computeVariance(resultingStatistics[i].getValue(0),
+					resultingStatistics[i].getValue(3), resultingStatistics[i].getValue(4)));
+			double stdCur = Math.sqrt(Utils.computeVariance(currentLiteralStatistics[i].getValue(0),
+					currentLiteralStatistics[i].getValue(3), currentLiteralStatistics[i].getValue(4)));
+
+			if (stdRes / stdCur <= threshold)
 				newOutputsList.add(currentIndices[i]);
 		}
-		//list to array
-		int [] newOutputs=new int[newOutputsList.size()];
-		int ct=0;
-		for(int outIndex : newOutputsList){
-			newOutputs[ct]=outIndex;
+		// list to array
+		int[] newOutputs = new int[newOutputsList.size()];
+		int ct = 0;
+		for (int outIndex : newOutputsList) {
+			newOutputs[ct] = outIndex;
 			++ct;
 		}
 		return newOutputs;
 	}
 
-
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
 
 	}
 
-
-
 	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
 
 	}
 
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/outputselectors/VarianceThreshold.java b/moa/src/main/java/moa/learners/predictors/core/outputselectors/VarianceThreshold.java
similarity index 53%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/outputselectors/VarianceThreshold.java
rename to moa/src/main/java/moa/learners/predictors/core/outputselectors/VarianceThreshold.java
index 47238763d..381ccbe41 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/outputselectors/VarianceThreshold.java
+++ b/moa/src/main/java/moa/learners/predictors/core/outputselectors/VarianceThreshold.java
@@ -17,64 +17,61 @@
  *
  *
  */
-package moa.classifiers.rules.multilabel.outputselectors;
+package moa.learners.predictors.core.outputselectors;
 
 import java.util.LinkedList;
 
 import com.github.javacliparser.FloatOption;
 
-import moa.classifiers.rules.core.Utils;
 import moa.core.DoubleVector;
 import moa.core.ObjectRepository;
+import moa.learners.predictors.rules.core.Utils;
 import moa.options.AbstractOptionHandler;
 import moa.tasks.TaskMonitor;
 
-public class VarianceThreshold extends AbstractOptionHandler implements
-OutputAttributesSelector {
+public class VarianceThreshold extends AbstractOptionHandler implements OutputAttributesSelector {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 
-	public FloatOption thresholdOption = new FloatOption("Threshold",
-			'p', "Maximum allowed variance ratio (variance(new)/variance(old)).",
-			1.0, 0.5, 2.0);
+	public FloatOption thresholdOption = new FloatOption("Threshold", 'p',
+			"Maximum allowed variance ratio (variance(new)/variance(old)).", 1.0, 0.5, 2.0);
 
-
-	public int[] getNextOutputIndices(DoubleVector[] resultingStatistics, DoubleVector[] currentLiteralStatistics, int[] currentIndices) {
-		int numCurrentOutputs=resultingStatistics.length;
-		double threshold=thresholdOption.getValue();
-		//get new outputs
-		LinkedList<Integer> newOutputsList= new LinkedList<Integer>();
-		for(int i=0; i<numCurrentOutputs;i++){
-			double stdRes=Utils.computeVariance(resultingStatistics[i].getValue(0),resultingStatistics[i].getValue(3),resultingStatistics[i].getValue(4));
-			double stdCur=Utils.computeVariance(currentLiteralStatistics[i].getValue(0),currentLiteralStatistics[i].getValue(3),currentLiteralStatistics[i].getValue(4));
-	
-			if(stdRes/stdCur<=threshold || stdCur==0) 
+	@Override
+	public int[] getNextOutputIndices(DoubleVector[] resultingStatistics, DoubleVector[] currentLiteralStatistics,
+			int[] currentIndices) {
+		int numCurrentOutputs = resultingStatistics.length;
+		double threshold = thresholdOption.getValue();
+		// get new outputs
+		LinkedList<Integer> newOutputsList = new LinkedList<>();
+		for (int i = 0; i < numCurrentOutputs; i++) {
+			double stdRes = Utils.computeVariance(resultingStatistics[i].getValue(0),
+					resultingStatistics[i].getValue(3), resultingStatistics[i].getValue(4));
+			double stdCur = Utils.computeVariance(currentLiteralStatistics[i].getValue(0),
+					currentLiteralStatistics[i].getValue(3), currentLiteralStatistics[i].getValue(4));
+
+			if (stdRes / stdCur <= threshold || stdCur == 0)
 				newOutputsList.add(currentIndices[i]);
 		}
-		//list to array
-		int [] newOutputs=new int[newOutputsList.size()];
-		int ct=0;
-		for(int outIndex : newOutputsList){
-			newOutputs[ct]=outIndex;
+		// list to array
+		int[] newOutputs = new int[newOutputsList.size()];
+		int ct = 0;
+		for (int outIndex : newOutputsList) {
+			newOutputs[ct] = outIndex;
 			++ct;
 		}
 		return newOutputs;
 	}
 
-
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
 
 	}
 
-
-
 	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
 
 	}
 
diff --git a/moa/src/main/java/moa/learners/predictors/core/splitcriteria/GiniSplitCriterion.java b/moa/src/main/java/moa/learners/predictors/core/splitcriteria/GiniSplitCriterion.java
new file mode 100644
index 000000000..33eb7392f
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/splitcriteria/GiniSplitCriterion.java
@@ -0,0 +1,81 @@
+/*
+ *    GiniSplitCriterion.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.core.splitcriteria;
+
+import moa.core.ObjectRepository;
+import moa.core.Utils;
+import moa.options.AbstractOptionHandler;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Class for computing splitting criteria using Gini with respect to
+ * distributions of class values. The split criterion is used as a parameter on
+ * decision trees and decision stumps.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public class GiniSplitCriterion extends AbstractOptionHandler implements SplitCriterion {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public double getMeritOfSplit(double[] preSplitDist, double[][] postSplitDists) {
+		double totalWeight = 0.0;
+		double[] distWeights = new double[postSplitDists.length];
+		for (int i = 0; i < postSplitDists.length; i++) {
+			distWeights[i] = Utils.sum(postSplitDists[i]);
+			totalWeight += distWeights[i];
+		}
+		double gini = 0.0;
+		for (int i = 0; i < postSplitDists.length; i++) {
+			gini += (distWeights[i] / totalWeight) * computeGini(postSplitDists[i], distWeights[i]);
+		}
+		return 1.0 - gini;
+	}
+
+	@Override
+	public double getRangeOfMerit(double[] preSplitDist) {
+		return 1.0;
+	}
+
+	public static double computeGini(double[] dist, double distSumOfWeights) {
+		double gini = 1.0;
+		for (int i = 0; i < dist.length; i++) {
+			double relFreq = dist[i] / distSumOfWeights;
+			gini -= relFreq * relFreq;
+		}
+		return gini;
+	}
+
+	public static double computeGini(double[] dist) {
+		return computeGini(dist, Utils.sum(dist));
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// TODO Auto-generated method stub
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/splitcriteria/ICVarianceReduction.java b/moa/src/main/java/moa/learners/predictors/core/splitcriteria/ICVarianceReduction.java
new file mode 100644
index 000000000..ad0e7cd34
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/splitcriteria/ICVarianceReduction.java
@@ -0,0 +1,110 @@
+package moa.learners.predictors.core.splitcriteria;
+
+import moa.core.DoubleVector;
+import moa.core.ObjectRepository;
+import moa.options.AbstractOptionHandler;
+import moa.tasks.TaskMonitor;
+
+public class ICVarianceReduction extends AbstractOptionHandler implements MultiLabelSplitCriterion {
+
+	/**
+	 *
+	 */
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public double getMeritOfSplit(DoubleVector[] preSplitDist, DoubleVector[][] postSplitDists) {
+		double error = 0;
+		int numOutputs = preSplitDist.length;
+		for (int i = 0; i < numOutputs; i++)
+			error += getMeritOfSplitForOutput(preSplitDist, postSplitDists, i);
+		return error / numOutputs;
+	}
+
+	public double[] getBranchSplitVarianceOutput(DoubleVector[] postSplitDists) {
+		double[] variances = new double[postSplitDists.length];
+		for (int i = 0; i < postSplitDists.length; i++)
+			variances[i] = computeVariance(postSplitDists[i]);
+		return variances;
+
+	}
+
+	public double computeVariance(double n, double sum, double squares) {
+		if (n > 1) {
+			return (squares - sum * sum / n) / (n - 1);
+		}
+		return 0;
+	}
+
+	public double computeVariance(DoubleVector v) {
+		return computeVariance(v.getValue(0), v.getValue(1), v.getValue(2));
+	}
+
+	@Override
+	public double[] getBranchesSplitMerits(DoubleVector[][] postSplitDists) {
+		int numOutputs = postSplitDists.length;
+		int numBranches = postSplitDists[0].length;
+		double[] merits = new double[numBranches];
+		for (int j = 0; j < numOutputs; j++) {
+			double[] branchMeritsOutput = getBranchSplitVarianceOutput(postSplitDists[j]);
+
+			for (int i = 0; i < numBranches; i++) {
+				if (postSplitDists[j][i].getValue(0) > 0)
+					merits[i] -= branchMeritsOutput[i];
+				else
+					merits[i] = Double.MIN_VALUE;
+			}
+		}
+		return merits;
+	}
+
+	protected double getMeritOfSplitForOutput(DoubleVector[] preSplitDist, DoubleVector[][] postSplitDists,
+			int outputAttributeIndex) {
+		return getMeritOfSplitForAttribute(preSplitDist[outputAttributeIndex], postSplitDists[outputAttributeIndex]);
+	}
+
+	protected double getMeritOfSplitForAttribute(DoubleVector preSplitDist, DoubleVector[] postSplitDists) {
+		double merit = 0;
+		// count number of branches with weightSeen higher than threshold
+		int count = 0;
+		for (int i = 0; i < postSplitDists.length; i++)
+			if (postSplitDists[i].getValue(0) >= 0.05 * preSplitDist.getValue(0))
+				count = count + 1;
+		// Consider split if all branches have required weight seen
+		if (count == postSplitDists.length) {
+			double varPreSplit = computeVariance(preSplitDist);
+			double sumVarPostSplit = 0;
+			double weightTotal = 0;
+			for (int i = 0; i < postSplitDists.length; i++) {
+				weightTotal += postSplitDists[i].getValue(0);
+			}
+			double[] variances = getBranchSplitVarianceOutput(postSplitDists);
+			for (int i = 0; i < variances.length; i++)
+				if (postSplitDists[i].getValue(0) > 0)
+					sumVarPostSplit += (postSplitDists[i].getValue(0) / weightTotal * variances[i]); // weight variance
+			if (sumVarPostSplit == 0 && varPreSplit == 0)
+				merit = 0;
+			else
+				merit = 1 - sumVarPostSplit / varPreSplit;
+		}
+		/*
+		 * if(merit<0 || merit>1) System.out.println("out of range");
+		 */
+		return merit;
+	}
+
+	@Override
+	public double getRangeOfMerit(DoubleVector[] preSplitDist) {
+		return 1;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/splitcriteria/InfoGainSplitCriterion.java b/moa/src/main/java/moa/learners/predictors/core/splitcriteria/InfoGainSplitCriterion.java
new file mode 100644
index 000000000..7682a17a5
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/splitcriteria/InfoGainSplitCriterion.java
@@ -0,0 +1,112 @@
+/*
+ *    InfoGainSplitCriterion.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.core.splitcriteria;
+
+import com.github.javacliparser.FloatOption;
+
+import moa.core.ObjectRepository;
+import moa.core.Utils;
+import moa.options.AbstractOptionHandler;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Class for computing splitting criteria using information gain with respect to
+ * distributions of class values. The split criterion is used as a parameter on
+ * decision trees and decision stumps.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public class InfoGainSplitCriterion extends AbstractOptionHandler implements SplitCriterion {
+
+	private static final long serialVersionUID = 1L;
+
+	public FloatOption minBranchFracOption = new FloatOption("minBranchFrac", 'f',
+			"Minimum fraction of weight required down at least two branches.", 0.01, 0.0, 0.5);
+
+	@Override
+	public double getMeritOfSplit(double[] preSplitDist, double[][] postSplitDists) {
+		if (numSubsetsGreaterThanFrac(postSplitDists, this.minBranchFracOption.getValue()) < 2) {
+			return Double.NEGATIVE_INFINITY;
+		}
+		return computeEntropy(preSplitDist) - computeEntropy(postSplitDists);
+	}
+
+	@Override
+	public double getRangeOfMerit(double[] preSplitDist) {
+		int numClasses = preSplitDist.length > 2 ? preSplitDist.length : 2;
+		return Utils.log2(numClasses);
+	}
+
+	public static double computeEntropy(double[] dist) {
+		double entropy = 0.0;
+		double sum = 0.0;
+		for (double d : dist) {
+			if (d > 0.0) { // TODO: how small can d be before log2 overflows?
+				entropy -= d * Utils.log2(d);
+				sum += d;
+			}
+		}
+		return sum > 0.0 ? (entropy + sum * Utils.log2(sum)) / sum : 0.0;
+	}
+
+	public static double computeEntropy(double[][] dists) {
+		double totalWeight = 0.0;
+		double[] distWeights = new double[dists.length];
+		for (int i = 0; i < dists.length; i++) {
+			distWeights[i] = Utils.sum(dists[i]);
+			totalWeight += distWeights[i];
+		}
+		double entropy = 0.0;
+		for (int i = 0; i < dists.length; i++) {
+			entropy += distWeights[i] * computeEntropy(dists[i]);
+		}
+		return entropy / totalWeight;
+	}
+
+	public static int numSubsetsGreaterThanFrac(double[][] distributions, double minFrac) {
+		double totalWeight = 0.0;
+		double[] distSums = new double[distributions.length];
+		for (int i = 0; i < distSums.length; i++) {
+			for (int j = 0; j < distributions[i].length; j++) {
+				distSums[i] += distributions[i][j];
+			}
+			totalWeight += distSums[i];
+		}
+		int numGreater = 0;
+		for (double d : distSums) {
+			double frac = d / totalWeight;
+			if (frac > minFrac) {
+				numGreater++;
+			}
+		}
+		return numGreater;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// TODO Auto-generated method stub
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/core/splitcriteria/InfoGainSplitCriterionMultilabel.java b/moa/src/main/java/moa/learners/predictors/core/splitcriteria/InfoGainSplitCriterionMultilabel.java
similarity index 67%
rename from moa/src/main/java/moa/classifiers/core/splitcriteria/InfoGainSplitCriterionMultilabel.java
rename to moa/src/main/java/moa/learners/predictors/core/splitcriteria/InfoGainSplitCriterionMultilabel.java
index c280ecd3f..66e152a23 100644
--- a/moa/src/main/java/moa/classifiers/core/splitcriteria/InfoGainSplitCriterionMultilabel.java
+++ b/moa/src/main/java/moa/learners/predictors/core/splitcriteria/InfoGainSplitCriterionMultilabel.java
@@ -16,9 +16,9 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.classifiers.core.splitcriteria;
+package moa.learners.predictors.core.splitcriteria;
 
 import moa.core.Utils;
 
@@ -33,22 +33,22 @@
  */
 public class InfoGainSplitCriterionMultilabel extends InfoGainSplitCriterion {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public static double computeEntropy(double[] dist) {
-        double entropy = 0.0;
-        double sum = 0.0;
-        for (double d : dist) {
-            sum += d;
-        }
-        if (sum > 0.0) {
-            for (double num : dist) {
-                double d = num / sum;
-                if (d > 0.0) { // TODO: how small can d be before log2 overflows?
-                    entropy -= d * Utils.log2(d) + (1 - d) * Utils.log2(1 - d); //Extension to Multilabel
-                }
-            }
-        }
-        return sum > 0.0 ? entropy : 0.0;
-    }
+	public static double computeEntropy(double[] dist) {
+		double entropy = 0.0;
+		double sum = 0.0;
+		for (double d : dist) {
+			sum += d;
+		}
+		if (sum > 0.0) {
+			for (double num : dist) {
+				double d = num / sum;
+				if (d > 0.0) { // TODO: how small can d be before log2 overflows?
+					entropy -= d * Utils.log2(d) + (1 - d) * Utils.log2(1 - d); // Extension to Multilabel
+				}
+			}
+		}
+		return sum > 0.0 ? entropy : 0.0;
+	}
 }
diff --git a/moa/src/main/java/moa/learners/predictors/core/splitcriteria/MultiLabelSplitCriterion.java b/moa/src/main/java/moa/learners/predictors/core/splitcriteria/MultiLabelSplitCriterion.java
new file mode 100644
index 000000000..5aee1120f
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/splitcriteria/MultiLabelSplitCriterion.java
@@ -0,0 +1,14 @@
+package moa.learners.predictors.core.splitcriteria;
+
+import moa.core.DoubleVector;
+import moa.options.OptionHandler;
+
+public interface MultiLabelSplitCriterion extends OptionHandler {
+
+	double getMeritOfSplit(DoubleVector[] preSplitDist, DoubleVector[][] postSplitDists);
+
+	double getRangeOfMerit(DoubleVector[] preSplitDist);
+
+	double[] getBranchesSplitMerits(DoubleVector[][] postSplitDists);
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/splitcriteria/MultiTargetVarianceRatio.java b/moa/src/main/java/moa/learners/predictors/core/splitcriteria/MultiTargetVarianceRatio.java
new file mode 100644
index 000000000..37457c5d9
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/splitcriteria/MultiTargetVarianceRatio.java
@@ -0,0 +1,104 @@
+package moa.learners.predictors.core.splitcriteria;
+
+import moa.core.DoubleVector;
+import moa.core.ObjectRepository;
+import moa.learners.predictors.rules.core.Utils;
+import moa.options.AbstractOptionHandler;
+import moa.tasks.TaskMonitor;
+
+public class MultiTargetVarianceRatio extends AbstractOptionHandler implements MultiLabelSplitCriterion {
+
+	/**
+	 *
+	 */
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public double getMeritOfSplit(DoubleVector[] preSplitDist, DoubleVector[][] postSplitDists) {
+		double error = 0;
+		int numOutputs = preSplitDist.length;
+		for (int i = 0; i < numOutputs; i++)
+			error += getMeritOfSplitForOutput(preSplitDist, postSplitDists, i);
+		return error / numOutputs;
+	}
+
+	public double[] getBranchSplitVarianceOutput(DoubleVector[] postSplitDists) {
+		double[] variances = new double[postSplitDists.length];
+		for (int i = 0; i < postSplitDists.length; i++)
+			variances[i] = Utils.computeVariance(postSplitDists[i]);
+		return variances;
+
+	}
+
+	@Override
+	public double[] getBranchesSplitMerits(DoubleVector[][] postSplitDists) {
+		int numOutputs = postSplitDists.length;
+		int numBranches = postSplitDists[0].length;
+		double[] merits = new double[numBranches];
+		for (int j = 0; j < numOutputs; j++) {
+			double[] branchMeritsOutput = getBranchSplitVarianceOutput(postSplitDists[j]);
+			/*
+			 * double weightTotal=0; for (int i=0; i<numBranches;i++){
+			 * weightTotal+=postSplitDists[j][i].getValue(0)/weightTotal*postSplitDists[j][i
+			 * ].getValue(0); } for (int i=0; i<numBranches;i++){
+			 * merits[i]+=postSplitDists[j][i].getValue(0)/weightTotal*branchMeritsOutput[i]
+			 * ; }
+			 */
+
+			for (int i = 0; i < numBranches; i++) {
+				if (postSplitDists[j][i].getValue(0) > 0)
+					merits[i] -= branchMeritsOutput[i];
+				else
+					merits[i] = -Double.MAX_VALUE;
+			}
+		}
+		return merits;
+	}
+
+	protected double getMeritOfSplitForOutput(DoubleVector[] preSplitDist, DoubleVector[][] postSplitDists,
+			int outputAttributeIndex) {
+		return getMeritOfSplitForOutput(preSplitDist[outputAttributeIndex], postSplitDists[outputAttributeIndex]);
+	}
+
+	protected double getMeritOfSplitForOutput(DoubleVector preSplitDist, DoubleVector[] postSplitDists) {
+		double merit = 0;
+		// count number of branches with weightSeen higher than threshold
+		int count = 0;
+		for (int i = 0; i < postSplitDists.length; i++)
+			if (postSplitDists[i].getValue(0) >= 0.05 * preSplitDist.getValue(0))
+				count = count + 1;
+		// Consider split if all branches have required weight seen
+		if (count == postSplitDists.length) {
+			double varPreSplit = Utils.computeVariance(preSplitDist);
+			double sumVarPostSplit = 0;
+			double weightTotal = 0;
+			for (int i = 0; i < postSplitDists.length; i++) {
+				weightTotal += postSplitDists[i].getValue(0);
+			}
+			double[] variances = getBranchSplitVarianceOutput(postSplitDists);
+			for (int i = 0; i < variances.length; i++)
+				if (postSplitDists[i].getValue(0) > 0)
+					sumVarPostSplit += (postSplitDists[i].getValue(0) / weightTotal * variances[i]); // weight variance
+			merit = (1 - sumVarPostSplit / varPreSplit);
+		}
+		/*
+		 * if(merit<0 || merit>1) System.out.println("out of range");
+		 */
+		return merit;
+	}
+
+	@Override
+	public double getRangeOfMerit(DoubleVector[] preSplitDist) {
+		return 1;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/splitcriteria/MultilabelInformationGain.java b/moa/src/main/java/moa/learners/predictors/core/splitcriteria/MultilabelInformationGain.java
new file mode 100644
index 000000000..732eb11a9
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/splitcriteria/MultilabelInformationGain.java
@@ -0,0 +1,131 @@
+/*
+ *    MultilabelInformationGain.java
+ *    Copyright (C) 2017 University of Porto, Portugal
+ *    @author R. Sousa, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.predictors.core.splitcriteria;
+
+import moa.core.DoubleVector;
+import moa.core.ObjectRepository;
+import moa.learners.predictors.rules.core.Utils;
+import moa.options.AbstractOptionHandler;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Multi-label Information Gain. Online Multi-label Classification heuristic for
+ * AMRules.
+ *
+ * @author RSousa
+ */
+public class MultilabelInformationGain extends AbstractOptionHandler implements MultiLabelSplitCriterion {
+
+	@Override
+	public String getPurposeString() {
+		return "Online Multi-label Classification heuristic for AMRules.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public double getMeritOfSplit(DoubleVector[] preSplitDist, DoubleVector[][] postSplitDists) {
+
+		double error = 0;
+		int numOutputs = preSplitDist.length;
+		for (int i = 0; i < numOutputs; i++)
+			error += getMeritOfSplitForOutput(preSplitDist, postSplitDists, i);
+
+		return error / numOutputs;
+	}
+
+	public double[] getBranchSplitEntropyOutput(DoubleVector[] postSplitDists) {
+		double[] entropies = new double[postSplitDists.length];
+		for (int i = 0; i < postSplitDists.length; i++) {
+			entropies[i] = Utils.computeEntropy(postSplitDists[i]);
+		}
+		return entropies;
+	}
+
+	@Override
+	public double[] getBranchesSplitMerits(DoubleVector[][] postSplitDists) {
+
+		int numOutputs = postSplitDists.length;
+		int numBranches = postSplitDists[0].length;
+		double[] merits = new double[numBranches];
+		for (int j = 0; j < numOutputs; j++) {
+			double[] branchMeritsOutput = getBranchSplitEntropyOutput(postSplitDists[j]);
+
+			for (int i = 0; i < numBranches; i++) {
+				if (postSplitDists[j][i].getValue(0) > 0)
+					merits[i] -= branchMeritsOutput[i];
+				else
+					merits[i] = -Double.MAX_VALUE;
+			}
+		}
+		return merits;
+	}
+
+	protected double getMeritOfSplitForOutput(DoubleVector[] preSplitDist, DoubleVector[][] postSplitDists,
+			int outputAttributeIndex) {
+		return getMeritOfSplitForOutput(preSplitDist[outputAttributeIndex], postSplitDists[outputAttributeIndex]);
+	}
+
+	protected double getMeritOfSplitForOutput(DoubleVector preSplitDist, DoubleVector[] postSplitDists) {
+		double merit = 0;
+
+		// count number of branches with weightSeen higher than threshold
+		int count = 0;
+		for (int i = 0; i < postSplitDists.length; i++)
+			if (postSplitDists[i].getValue(0) >= 0.05 * preSplitDist.getValue(0))
+				count = count + 1;
+
+		// Consider split if all branches have required weight seen
+		if (count == postSplitDists.length) {
+
+			double EntPreSplit = Utils.computeEntropy(preSplitDist);
+			double sumEntPostSplit = 0;
+			double weightTotal = 0;
+			for (int i = 0; i < postSplitDists.length; i++) {
+				weightTotal += postSplitDists[i].getValue(0);
+			}
+			double[] Entropies = getBranchSplitEntropyOutput(postSplitDists);
+
+			for (int i = 0; i < Entropies.length; i++)
+				if (postSplitDists[i].getValue(0) > 0)
+					sumEntPostSplit += (postSplitDists[i].getValue(0) / weightTotal * Entropies[i]); // weight variance
+			merit = (EntPreSplit - sumEntPostSplit);
+		}
+		/*
+		 * if(merit<0 || merit>1) System.out.println("out of range");
+		 */
+		return merit;
+	}
+
+	@Override
+	public double getRangeOfMerit(DoubleVector[] preSplitDist) {
+		return 1;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/splitcriteria/PCTWeightedICVarianceReduction.java b/moa/src/main/java/moa/learners/predictors/core/splitcriteria/PCTWeightedICVarianceReduction.java
new file mode 100644
index 000000000..5fbaf9e44
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/splitcriteria/PCTWeightedICVarianceReduction.java
@@ -0,0 +1,91 @@
+package moa.learners.predictors.core.splitcriteria;
+
+import moa.core.DoubleVector;
+
+public class PCTWeightedICVarianceReduction extends WeightedICVarianceReduction {
+
+	private static final long serialVersionUID = 1L;
+
+	public DoubleVector inputWeights;
+
+	public double targetInputTradeoff; // \in [0, 1]
+
+	public PCTWeightedICVarianceReduction(DoubleVector targetWeights, DoubleVector inputWeights,
+			double targetInputTradeoff) {
+		super(targetWeights);
+		this.inputWeights = inputWeights;
+		this.targetInputTradeoff = targetInputTradeoff;
+	}
+
+	public double getMeritOfSplit(DoubleVector[] preSplitTargetDist, DoubleVector[][] postSplitTargetDists,
+			DoubleVector[] preSplitInputDist, DoubleVector[][] postSplitInputDists) {
+		double targetError = 0;
+		double inputError = 0;
+		int numTargets = preSplitTargetDist.length;
+		int numInputs = preSplitInputDist.length;
+		for (int i = 0; i < numTargets; i++) {
+			if (postSplitTargetDists[i][0].getValue(0) == 0 || postSplitTargetDists[i][1].getValue(0) == 0)
+				// If the split would result in a leaf without labeled instances, discard it
+				return Double.NaN;
+			targetError += weights.getValue(i)
+					* getMeritOfSplitForAttribute(preSplitTargetDist[i], postSplitTargetDists[i]);
+		}
+		for (int i = 0; i < numInputs; i++)
+			inputError += inputWeights.getValue(i)
+					* getMeritOfSplitForAttribute(preSplitInputDist[i], postSplitInputDists[i]);
+
+		return targetInputTradeoff * targetError / weights.sumOfValues()
+				+ (1 - targetInputTradeoff) * inputError / inputWeights.sumOfValues();
+	}
+
+	@Override
+	protected double getMeritOfSplitForAttribute(DoubleVector preSplitDist, DoubleVector[] postSplitDists) {
+		double merit = 0;
+		// count number of branches with weightSeen higher than threshold
+		int count = 0;
+		for (int i = 0; i < postSplitDists.length; i++)
+			if (postSplitDists[i].getValue(0) >= 0.05 * preSplitDist.getValue(0))
+				count = count + 1;
+		// Consider split if all branches have required weight seen
+		if (count == postSplitDists.length) {
+			double varPreSplit = computeVariance(preSplitDist);
+			double sumVarPostSplit = 0;
+			double weightTotal = 0;
+			for (int i = 0; i < postSplitDists.length; i++) {
+				weightTotal += postSplitDists[i].getValue(0);
+			}
+			double[] variances = getBranchSplitVarianceOutput(postSplitDists);
+			for (int i = 0; i < variances.length; i++)
+				if (postSplitDists[i].getValue(0) > 0)
+					sumVarPostSplit += (postSplitDists[i].getValue(0) / weightTotal * variances[i]); // weight variance
+			if (varPreSplit > 0.0)
+				merit = 1 - sumVarPostSplit / varPreSplit;
+			else
+				merit = 0.0;
+		}
+		/*
+		 * if(merit<0 || merit>1) System.out.println("out of range");
+		 */
+		return merit;
+	}
+
+//	private double computeVariance(double n, double sum, double squares) {
+//		if (n > 1) {
+//			return (squares - sum * sum / n) / (n - 1);
+//		}
+//		return 0;
+//	}
+
+//	private double computeVariance(DoubleVector v) {
+//		return computeVariance(v.getValue(0), v.getValue(1), v.getValue(2));
+//	}
+
+	public double getMeritOfSplit(DoubleVector[] preSplitTargetDist, DoubleVector[] preSplitInputDist,
+			DoubleVector[][] postSplitTargetDists, DoubleVector[][] postSplitInputDists) {
+		double error = 0;
+		int numOutputs = preSplitTargetDist.length;
+		for (int i = 0; i < numOutputs; i++)
+			error += weights.getValue(i) * getMeritOfSplitForOutput(preSplitTargetDist, postSplitTargetDists, i);
+		return error / weights.sumOfValues();
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/core/splitcriteria/SDRSplitCriterion.java b/moa/src/main/java/moa/learners/predictors/core/splitcriteria/SDRSplitCriterion.java
similarity index 83%
rename from moa/src/main/java/moa/classifiers/core/splitcriteria/SDRSplitCriterion.java
rename to moa/src/main/java/moa/learners/predictors/core/splitcriteria/SDRSplitCriterion.java
index e5d9dd346..8cfebdd76 100644
--- a/moa/src/main/java/moa/classifiers/core/splitcriteria/SDRSplitCriterion.java
+++ b/moa/src/main/java/moa/learners/predictors/core/splitcriteria/SDRSplitCriterion.java
@@ -15,25 +15,25 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
- *    
+ *
+ *
  */
 
-/* Project Knowledge Discovery from Data Streams, FCT LIAAD-INESC TEC, 
+/* Project Knowledge Discovery from Data Streams, FCT LIAAD-INESC TEC,
  *
  * Contact: jgama@fep.up.pt
  */
 
-package moa.classifiers.core.splitcriteria;
+package moa.learners.predictors.core.splitcriteria;
 
 public class SDRSplitCriterion extends VarianceReductionSplitCriterion {
 	private static final long serialVersionUID = 1L;
 
 	public static double computeSD(double[] dist) {
-    	int N = (int)dist[0];
-        double sum = dist[1];
-        double sumSq = dist[2];
-        return Math.sqrt((sumSq - ((sum * sum)/N))/N);
-    }
+		int N = (int) dist[0];
+		double sum = dist[1];
+		double sumSq = dist[2];
+		return Math.sqrt((sumSq - ((sum * sum) / N)) / N);
+	}
 
 }
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/core/splitcriteria/SplitCriterion.java b/moa/src/main/java/moa/learners/predictors/core/splitcriteria/SplitCriterion.java
similarity index 50%
rename from moa/src/main/java/moa/classifiers/core/splitcriteria/SplitCriterion.java
rename to moa/src/main/java/moa/learners/predictors/core/splitcriteria/SplitCriterion.java
index 25b4a82a3..31085986c 100644
--- a/moa/src/main/java/moa/classifiers/core/splitcriteria/SplitCriterion.java
+++ b/moa/src/main/java/moa/learners/predictors/core/splitcriteria/SplitCriterion.java
@@ -15,41 +15,38 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.classifiers.core.splitcriteria;
+package moa.learners.predictors.core.splitcriteria;
 
 import moa.options.OptionHandler;
 
 /**
- * Interface for computing splitting criteria.
- * with respect to distributions of class values.
- * The split criterion is used as a parameter on
- * decision trees and decision stumps.
- * The two split criteria most used are 
- * Information Gain and Gini. 
+ * Interface for computing splitting criteria. with respect to distributions of
+ * class values. The split criterion is used as a parameter on decision trees
+ * and decision stumps. The two split criteria most used are Information Gain
+ * and Gini.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $ 
+ * @version $Revision: 7 $
  */
 public interface SplitCriterion extends OptionHandler {
 
-    /**
-     * Computes the merit of splitting for a given
-     * ditribution before the split and after it.
-     *
-     * @param preSplitDist the class distribution before the split
-     * @param postSplitDist the class distribution after the split
-     * @return value of the merit of splitting
-     */
-    public double getMeritOfSplit(double[] preSplitDist,
-            double[][] postSplitDists);
+	/**
+	 * Computes the merit of splitting for a given ditribution before the split and
+	 * after it.
+	 *
+	 * @param preSplitDist  the class distribution before the split
+	 * @param postSplitDist the class distribution after the split
+	 * @return value of the merit of splitting
+	 */
+	double getMeritOfSplit(double[] preSplitDist, double[][] postSplitDists);
 
-    /**
-     * Computes the range of splitting merit
-     *
-     * @param preSplitDist the class distribution before the split
-     * @return value of the range of splitting merit
-     */
-    public double getRangeOfMerit(double[] preSplitDist);
+	/**
+	 * Computes the range of splitting merit
+	 *
+	 * @param preSplitDist the class distribution before the split
+	 * @return value of the range of splitting merit
+	 */
+	double getRangeOfMerit(double[] preSplitDist);
 }
diff --git a/moa/src/main/java/moa/learners/predictors/core/splitcriteria/VarianceReductionSplitCriterion.java b/moa/src/main/java/moa/learners/predictors/core/splitcriteria/VarianceReductionSplitCriterion.java
new file mode 100644
index 000000000..e27d3cafd
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/splitcriteria/VarianceReductionSplitCriterion.java
@@ -0,0 +1,97 @@
+/*
+ *    VarianceReductionSplitCriterion.java
+ *    Copyright (C) 2013 University of Porto, Portugal
+ *    @author Katie de Lange, E. Almeida, J. Gama
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ *
+ */
+
+/* Project Knowledge Discovery from Data Streams, FCT LIAAD-INESC TEC,
+ *
+ * Contact: jgama@fep.up.pt
+ */
+
+package moa.learners.predictors.core.splitcriteria;
+
+import moa.core.ObjectRepository;
+import moa.options.AbstractOptionHandler;
+import moa.tasks.TaskMonitor;
+
+public class VarianceReductionSplitCriterion extends AbstractOptionHandler implements SplitCriterion {
+
+	private static final long serialVersionUID = 1L;
+
+	/*
+	 * @Override public double getMeritOfSplit(double[] preSplitDist, double[][]
+	 * postSplitDists) {
+	 * 
+	 * double N = preSplitDist[0]; double SDR = computeSD(preSplitDist);
+	 * 
+	 * // System.out.print("postSplitDists.length"+postSplitDists.length+"\n");
+	 * for(int i = 0; i < postSplitDists.length; i++) { double Ni =
+	 * postSplitDists[i][0]; SDR -= (Ni/N)*computeSD(postSplitDists[i]); }
+	 * 
+	 * return SDR; }
+	 */
+
+	@Override
+	public double getMeritOfSplit(double[] preSplitDist, double[][] postSplitDists) {
+		double SDR = 0.0;
+		double N = preSplitDist[0];
+		int count = 0;
+
+		for (int i = 0; i < postSplitDists.length; i++) {
+			double Ni = postSplitDists[i][0];
+			if (Ni >= 5.0) {
+				count = count + 1;
+			}
+		}
+
+		if (count == postSplitDists.length) {
+			SDR = computeSD(preSplitDist);
+			for (int i = 0; i < postSplitDists.length; i++) {
+				double Ni = postSplitDists[i][0];
+				SDR -= (Ni / N) * computeSD(postSplitDists[i]);
+			}
+		}
+		return SDR;
+	}
+
+	@Override
+	public double getRangeOfMerit(double[] preSplitDist) {
+		return 1;
+	}
+
+	public static double computeSD(double[] dist) {
+
+		int N = (int) dist[0];
+		double sum = dist[1];
+		double sumSq = dist[2];
+		// return Math.sqrt((sumSq - ((sum * sum)/N))/N);
+		return (sumSq - ((sum * sum) / N)) / N;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// TODO Auto-generated method stub
+	}
+
+}
diff --git a/moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/WeightedICVarianceReduction.java b/moa/src/main/java/moa/learners/predictors/core/splitcriteria/WeightedICVarianceReduction.java
similarity index 62%
rename from moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/WeightedICVarianceReduction.java
rename to moa/src/main/java/moa/learners/predictors/core/splitcriteria/WeightedICVarianceReduction.java
index a78ffab05..ef37980ef 100644
--- a/moa/src/main/java/moa/classifiers/mlc/core/splitcriteria/WeightedICVarianceReduction.java
+++ b/moa/src/main/java/moa/learners/predictors/core/splitcriteria/WeightedICVarianceReduction.java
@@ -1,11 +1,12 @@
-package moa.classifiers.mlc.core.splitcriteria;
+package moa.learners.predictors.core.splitcriteria;
 
 import moa.core.DoubleVector;
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
 
 /**
- * Weighted intra cluster variance reduction split criterion 
+ * Weighted intra cluster variance reduction split criterion
+ * 
  * @author Aljaž Osojnik <aljaz.osojnik@ijs.si>
  *
  */
@@ -13,25 +14,26 @@
 public class WeightedICVarianceReduction extends ICVarianceReduction {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
-	
+
 	public DoubleVector weights;
-	
+
 	public WeightedICVarianceReduction(DoubleVector targetWeights) {
 		super();
 		this.weights = targetWeights;
 	}
-	
+
 	@Override
 	public double getMeritOfSplit(DoubleVector[] preSplitDist, DoubleVector[][] postSplitDists) {
-		double error=0;
-		int numOutputs=preSplitDist.length;
-		for (int i=0; i<numOutputs; i++)
+		double error = 0;
+		int numOutputs = preSplitDist.length;
+		for (int i = 0; i < numOutputs; i++)
 			// TEMPORARY
-			//error += (1 / weights.getValue(i)) * getMeritOfSplitForOutput(preSplitDist,postSplitDists,i);
-			error += weights.getValue(i) * getMeritOfSplitForOutput(preSplitDist,postSplitDists,i);
+			// error += (1 / weights.getValue(i)) *
+			// getMeritOfSplitForOutput(preSplitDist,postSplitDists,i);
+			error += weights.getValue(i) * getMeritOfSplitForOutput(preSplitDist, postSplitDists, i);
 		return error / weights.sumOfValues();
 	}
 
@@ -41,8 +43,7 @@ public void getDescription(StringBuilder sb, int indent) {
 	}
 
 	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {		
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
 	}
-	
+
 }
diff --git a/moa/src/main/java/moa/learners/predictors/core/statisticaltests/Cramer.java b/moa/src/main/java/moa/learners/predictors/core/statisticaltests/Cramer.java
new file mode 100644
index 000000000..1cc425dc7
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/statisticaltests/Cramer.java
@@ -0,0 +1,740 @@
+/*
+ *    Cramer.java
+ *    Copyright (C) 2017 Instituto Federal de Pernambuco
+ *    @author Paulo Gonçalves (paulogoncalves@recife.ifpe.edu.br)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.core.statisticaltests;
+
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+import org.apache.commons.math3.complex.Complex;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.ArffLoader;
+import com.yahoo.labs.samoa.instances.Instance;
+
+import Jama.EigenvalueDecomposition;
+import Jama.Matrix;
+import moa.core.ObjectRepository;
+import moa.options.AbstractOptionHandler;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Implements the Multivariate Non-parametric Cramer Von Mises Statistical Test.
+ *
+ * @author Paulo Gonçalves
+ *
+ */
+public class Cramer extends AbstractOptionHandler implements StatisticalTest {
+
+	private List<Instance> sample1i;
+	private List<Instance> sample2i;
+
+	public FloatOption confidenceLevelOption = new FloatOption("confidenceLevel", 'q',
+			"The confidence level to use in the Cramer test.", 0.95, 0, 1);
+
+	public IntOption replicatesOption = new IntOption("replicates", 'r', "Number of replications.", 1000, 1,
+			Integer.MAX_VALUE);
+
+	public MultiChoiceOption kernelOption = new MultiChoiceOption("kernel", 'f', "Kernel function to use.",
+			new String[] { "CRAMER", "BAHR", "LOG", "FRAC A", "FRAC B" },
+			new String[] { "CRAMER", "BAHR", "LOG", "FRAC A", "FRAC B" }, 0);
+
+	public FloatOption maxMOption = new FloatOption("maxM", 'm', "Maximum M.", Math.pow(2, 14), 1, Float.MAX_VALUE);
+
+	public IntOption kOption = new IntOption("k", 'k', "K value.", 160, 1, Integer.MAX_VALUE);
+
+	public static final int CRAMER = 0;
+	public static final int BAHR = 1;
+	public static final int LOG = 2;
+	public static final int FRACA = 3;
+	public static final int FRACB = 4;
+
+	// compute the FFT of x[], assuming its length is a power of 2
+	private Complex[] fft(Complex[] x) {
+		int N = x.length;
+
+		// base case
+		if (N == 1) {
+			return new Complex[] { x[0] };
+		}
+
+		// radix 2 Cooley-Tukey FFT
+		if (N % 2 != 0) {
+			throw new RuntimeException("N is not a power of 2");
+		}
+
+		// fft of even terms
+		Complex[] even = new Complex[N / 2];
+		for (int k = 0; k < N / 2; k++) {
+			even[k] = x[2 * k];
+		}
+		Complex[] q = fft(even);
+
+		// fft of odd terms
+		Complex[] odd = even; // reuse the array
+		for (int k = 0; k < N / 2; k++) {
+			odd[k] = x[2 * k + 1];
+		}
+		Complex[] r = fft(odd);
+
+		// combine
+		Complex[] yy = new Complex[N];
+		for (int k = 0; k < N / 2; k++) {
+			double kth = -2 * k * Math.PI / N;
+			Complex wk = new Complex(Math.cos(kth), Math.sin(kth));
+			yy[k] = q[k].add(wk.multiply(r[k]));
+			yy[k + N / 2] = q[k].subtract(wk.multiply(r[k]));
+		}
+		return yy;
+	}
+
+	private double phiCramer(double x) {
+		return (Math.sqrt(x) / 2);
+	}
+
+	private double phiBahr(double x) {
+		return (1 - Math.exp(-x / 2));
+	}
+
+	private double phiLog(double x) {
+		return (Math.log(1 + x));
+	}
+
+	private double phiFracA(double x) {
+		return (1 - 1 / (1 + x));
+	}
+
+	private double phiFracB(double x) {
+		return (1 - 1 / ((1 + x) * (1 + x)));
+	}
+
+	private double subtractRows(double[][] matrix, int i, int j) {
+		double sum = 0;
+		for (int k = 0; k < matrix[i].length; k++) {
+			sum += (matrix[i][k] - matrix[j][k]) * (matrix[i][k] - matrix[j][k]);
+		}
+		return sum;
+	}
+
+	private void kernel(int kernel, double[][] lookup) {
+		for (double[] lookup1 : lookup) {
+			for (int j = 0; j < lookup1.length; j++) {
+				switch (kernel) {
+				case CRAMER:
+					lookup1[j] = this.phiCramer(lookup1[j]);
+					break;
+				case BAHR:
+					lookup1[j] = this.phiBahr(lookup1[j]);
+					break;
+				case FRACA:
+					lookup1[j] = this.phiFracA(lookup1[j]);
+					break;
+				case FRACB:
+					lookup1[j] = this.phiFracB(lookup1[j]);
+					break;
+				case LOG:
+					lookup1[j] = this.phiLog(lookup1[j]);
+					break;
+				}
+			}
+		}
+	}
+
+	private double sumCells(double[][] lookup, int[] xind, int[] yind) {
+		double sum = 0;
+		for (int i = 0; i < xind.length; i++) {
+			for (int j = 0; j < yind.length; j++) {
+				sum += lookup[xind[i]][yind[j]];
+			}
+		}
+		return sum;
+	}
+
+	private double cramerStatistic(int m, int n, double[][] lookup) {
+		int[] xind = new int[m];
+		for (int i = 0; i < m; i++) {
+			xind[i] = i;
+		}
+		int[] yind = new int[n];
+		for (int i = m, j = 0; i < m + n; i++, j++) {
+			yind[j] = i;
+		}
+		double mm = m, nn = n;
+		return mm * nn / (mm + nn) * (2 * this.sumCells(lookup, xind, yind) / (mm * nn)
+				- this.sumCells(lookup, xind, xind) / (mm * mm) - this.sumCells(lookup, yind, yind) / (nn * nn));
+	}
+
+	class Boot {
+
+		double t0;
+		double[][] t;
+	}
+
+	private double rank(double t0, double[][] t) {
+		double[] temp = new double[t.length * t[0].length + 1];
+		temp[0] = t0;
+		int p = 1;
+		for (double[] t1 : t) {
+			for (int j = 0; j < t1.length; j++) {
+				temp[p++] = t1[j];
+			}
+		}
+		double[] ordTemp = temp.clone();
+		Arrays.sort(ordTemp);
+		Map<Double, Double> map = new TreeMap();
+		for (int i = 0; i < ordTemp.length; i++) {
+			double xTemp = ordTemp[i], sum = i;
+			int count = 1;
+			while (i + 1 < ordTemp.length && xTemp == ordTemp[++i]) {
+				sum += i;
+				count++;
+			}
+			map.put(xTemp, 1 + sum / count);
+			if (i + 1 == ordTemp.length) {
+				map.put(ordTemp[i], 1.0 + i);
+				break;
+			} else {
+				i--;
+			}
+		}
+		return map.get(t0);
+	}
+
+	private double[] linearize(double[][] matrix) {
+		double[] vector = new double[matrix.length * matrix[0].length];
+		int p = 0;
+		for (double[] matrix1 : matrix) {
+			for (int j = 0; j < matrix1.length; j++) {
+				vector[p++] = matrix1[j];
+			}
+		}
+		return vector;
+	}
+
+	private double[] createVector(int replicates) {
+		double[] result = new double[replicates];
+		for (int i = 0; i < replicates; i++) {
+			result[i] = (i + 1) / replicates;
+		}
+		return result;
+	}
+
+	private void divide(double[] vector, double divisor) {
+		for (int i = 0; i < vector.length; i++) {
+			vector[i] /= divisor;
+		}
+	}
+
+	private void divide(double[][] matrix, double divisor) {
+		for (double[] matrix1 : matrix) {
+			for (int j = 0; j < matrix1.length; j++) {
+				matrix1[j] /= divisor;
+			}
+		}
+	}
+
+	private double[] createArray(int M, double k) {
+		double[] result = new double[M];
+		for (int i = 0; i < M; i++) {
+			result[i] = i * k / M;
+		}
+		return result;
+	}
+
+	private double[] createArray2(int M, double k) {
+		double[] result = new double[M];
+		for (int i = 0; i < M; i++) {
+			result[i] = i * 2 * Math.PI / k;
+		}
+		return result;
+	}
+
+	private Complex[][] complex(Complex[] v, double[] t) {
+		Complex[][] complex = new Complex[v.length][t.length];
+		for (int i = 0; i < v.length; i++) {
+			for (int j = 0; j < t.length; j++) {
+				complex[i][j] = v[i].multiply(t[j]).add(new Complex(1, 0)).log().multiply(-0.5);
+			}
+		}
+		return complex;
+	}
+
+	private Complex[] characteristic(double[] lambdasquare, double[] t) {
+		// z<--0.5*log(1-2i*lambdasquare%*%t(t));
+		Complex c = new Complex(0, -2);
+		Complex[] temp = new Complex[lambdasquare.length];
+		for (int i = 0; i < temp.length; i++) {
+			temp[i] = c.multiply(lambdasquare[i]);
+		}
+		Complex[][] z = this.complex(temp, t);
+		// return(exp(complex(length(t),rowsum(Re(z),rep(1,length(lambdasquare))),rowsum(Im(z),rep(1,length(lambdasquare))))))
+		double[] real = new double[t.length];
+		double[] imag = new double[t.length];
+		for (int j = 0; j < t.length; j++) {
+			for (Complex[] z1 : z) {
+				real[j] += z1[j].getReal();
+				imag[j] += z1[j].getImaginary();
+			}
+		}
+		Complex[] result = new Complex[t.length];
+		for (int i = 0; i < t.length; i++) {
+			result[i] = new Complex(real[i], imag[i]);
+			result[i] = result[i].exp();
+		}
+		return result;
+	}
+
+	private double[] imaginary(Complex[] c) {
+		double[] ret = new double[c.length];
+		for (int i = 0; i < c.length; i++) {
+			ret[i] = c[i].getImaginary();
+		}
+		return ret;
+	}
+
+	private double[] plus(double[] array, double m) {
+		double[] ret = new double[array.length];
+		for (int i = 0; i < ret.length; i++) {
+			ret[i] = array[i] + m;
+		}
+		return ret;
+	}
+
+	private double sum(double[] lambdasquare) {
+		double sum = 0;
+		for (int i = 0; i < lambdasquare.length; i++) {
+			sum += lambdasquare[i];
+		}
+		return sum;
+	}
+
+	private double[] sum(double[] a, double[] b) {
+		double[] c = new double[a.length];
+		for (int i = 0; i < c.length; i++) {
+			c[i] = a[i] + b[i];
+		}
+		return c;
+	}
+
+	private int whichMin(double[] a, int M, double confLevel) {
+		double[] ret = new double[M / 2];
+		for (int i = 0; i < ret.length; i++) {
+			ret[i] = Math.abs(a[i] - confLevel);
+		}
+		int minIndex = 0;
+		double minValue = Double.MAX_VALUE;
+		for (int i = 0; i < ret.length; i++) {
+			if (ret[i] < minValue) {
+				minValue = ret[i];
+				minIndex = i;
+			}
+		}
+		return minIndex;
+	}
+
+	private int whichMin(double[] ret) {
+		int minIndex = 0;
+		double minValue = Double.MAX_VALUE;
+		for (int i = 0; i < ret.length; i++) {
+			if (ret[i] < minValue) {
+				minValue = ret[i];
+				minIndex = i;
+			}
+		}
+		return minIndex;
+	}
+
+	class Kritwert {
+
+		double quantile;
+		double[] x;
+		double[] Fx;
+
+		public Kritwert(double quantile, double[] x, double[] fx) {
+			super();
+			this.quantile = quantile;
+			this.x = x;
+			Fx = fx;
+		}
+	}
+
+	private Complex[] multiply(double[] t, Complex c) {
+		Complex[] ret = new Complex[t.length];
+		for (int i = 0; i < ret.length; i++) {
+			ret[i] = c.multiply(t[i]);
+		}
+		return ret;
+	}
+
+	private void multiply(double[] t, Complex[] c) {
+		for (int i = 0; i < c.length; i++) {
+			c[i] = c[i].multiply(t[i]);
+		}
+	}
+
+	private void multiply(Complex[] c, double multiply) {
+		for (int i = 0; i < c.length; i++) {
+			c[i] = c[i].multiply(multiply);
+		}
+	}
+
+	private void multiply(double[] c, double multiply) {
+		for (int i = 0; i < c.length; i++) {
+			c[i] *= multiply;
+		}
+	}
+
+	private Kritwert kritwertfft(double[] lambdasquare, double confLevel, double maxM, int k) {
+		double sumLambasquare = this.sum(lambdasquare);
+		// M<-2^11
+		int M = (int) Math.pow(2, 11);
+		// while (150*pi*M/K^2<(2*sum(lambdasquare)+lambdasquare[1])) M<-M*2
+		while (150 * Math.PI * M / (k * k) < (2 * sumLambasquare + lambdasquare[0])) {
+			M *= 2;
+		}
+		// M<-min(c(M,maxM))
+		M = (int) Math.min(M, maxM);
+		// goodlimit<-150*pi*M/K^2
+		double goodlimit = 150 * Math.PI * M / (k * k);
+		// a<-0
+		// t<-0:(M-1)*K/M
+		double[] t = this.createArray(M, k);
+		// x<-0:(M-1)*2*pi/K
+		double[] xx = this.createArray2(M, k);
+		// t[1]<-1
+		t[0] = 1;
+		// h<-.cramer.characteristicfunction(lambdasquare,t)/t*exp(-a*1i*t);
+		Complex[] h = this.characteristic(lambdasquare, t);
+		Complex z = new Complex(0, 1).multiply(-0);
+		Complex[] hTemp = this.multiply(t, z);
+		for (int i = 0; i < hTemp.length; i++) {
+			hTemp[i] = hTemp[i].exp();
+		}
+		this.multiply(t, hTemp);
+		for (int i = 0; i < h.length; i++) {
+			h[i] = h[i].divide(hTemp[i]);
+		}
+		// h[1]<-complex(1,0,1)*sum(lambdasquare)
+		h[0] = new Complex(0, 1).multiply(sumLambasquare);
+		// Fx<-1/2-Im(K/(M*pi)*fft(h,inverse=FALSE))+K/(2*M*pi)*(sum(lambdasquare)+x+a)
+		Complex[] temp = fft(h);
+		this.multiply(temp, k / (M * Math.PI));
+		double[] tempFx = this.imaginary(temp);
+		this.multiply(tempFx, -1);
+		tempFx = this.plus(tempFx, 0.5);
+		double[] tempX = this.plus(xx, sumLambasquare);
+		this.multiply(tempX, k / (2 * M * Math.PI));
+		double[] Fx = this.sum(tempFx, tempX);
+		// xindex<-which.min(abs(Fx[1:(M/2)]-conf.level))
+		int xindex = this.whichMin(Fx, M, confLevel);
+		// if (Fx[xindex]>conf.level) xindex<-xindex-1
+		if (Fx[xindex] > confLevel) {
+			xindex--;
+		}
+		// if (xindex<1) xindex<-1
+		if (xindex < 1) {
+			xindex = 0;
+		}
+		// quantile<-x[xindex]+(conf.level-Fx[xindex])*(x[xindex+1]-x[xindex])/(Fx[xindex+1]-Fx[xindex])
+		double quantile = xx[xindex]
+				+ (confLevel - Fx[xindex]) * (xx[xindex + 1] - xx[xindex]) / (Fx[xindex + 1] - Fx[xindex]);
+		if (Fx[M / 2] < confLevel) {
+			System.out.println("Quantile calculation discrepance. Try to increase K!");
+		}
+		if (quantile > goodlimit) {
+			System.out.println("Quantile beyond good approximation limit. Try to increase maxM or decrease K!");
+		}
+		return new Kritwert(quantile, xx, Fx);
+	}
+
+	public CramerTest cramerTest(List<Instance> x, List<Instance> y) {
+		return this.cramerTest(x, y, this.confidenceLevelOption.getValue(), this.replicatesOption.getValue(),
+				"ordinary", false, this.kernelOption.getChosenIndex(), this.maxMOption.getValue(),
+				this.kOption.getValue());
+	}
+
+	public CramerTest cramerTest1(List<List<Double>> x, List<List<Double>> y) {
+		return this.cramerTest1(x, y, this.confidenceLevelOption.getValue(), this.replicatesOption.getValue(),
+				"ordinary", false, this.kernelOption.getChosenIndex(), this.maxMOption.getValue(),
+				this.kOption.getValue());
+	}
+
+	public CramerTest cramerTest1(List<List<Double>> x, List<List<Double>> y, double confLevel, int replicates,
+			String sim, boolean justStatistic, int kernel, double maxM, int k) {
+		CramerTest RVAL = new CramerTest(0, 0, 0, 0, 0, 0, 0, confLevel, replicates, null, null, null);
+		// if ((is.matrix(x))&&(is.matrix(y))) if (ncol(x)==ncol(y)) RVAL$d<-ncol(x)
+		RVAL.d = x.get(0).size();
+		// RVAL$m<-nrow(x)
+		RVAL.m = x.size();
+		// RVAL$n<-nrow(y)
+		RVAL.n = y.size();
+		// daten<-matrix(c(t(x),t(y)),ncol=ncol(x),byrow=TRUE)
+		double[][] daten = new double[RVAL.m + RVAL.n][];
+		for (int i = 0; i < RVAL.m; i++) {
+			double[] values = new double[x.get(i).size() - 1];
+			System.arraycopy(x.get(i).toArray(), 0, values, 0, values.length);
+			daten[i] = values;
+		}
+		for (int i = 0; i < RVAL.n; i++) {
+			double[] values = new double[y.get(i).size() - 1];
+			System.arraycopy(y.get(i).toArray(), 0, values, 0, values.length);
+			daten[i + RVAL.m] = values;
+		}
+		return this.compute(RVAL, daten, replicates, sim, justStatistic, kernel, maxM, k);
+	}
+
+	private CramerTest compute(CramerTest RVAL, double[][] daten, int replicates, String sim, boolean justStatistic,
+			int kernel, double maxM, int k) {
+		// lookup<-matrix(rep(0,(RVAL$m+RVAL$n)^2),ncol=(RVAL$m+RVAL$n))
+		double[][] lookup = new double[RVAL.m + RVAL.n][RVAL.m + RVAL.n];
+		// for (i in 2:(RVAL$m+RVAL$n)) for (j in 1:(i-1)) {
+		// lookup[i,j]<-sum((daten[i,]-daten[j,])^2); lookup[j,i]<-lookup[i,j]; }
+		for (int i = 1; i < RVAL.m + RVAL.n; i++) {
+			for (int j = 0; j <= i - 1; j++) {
+				lookup[i][j] = this.subtractRows(daten, i, j);
+				lookup[j][i] = lookup[i][j];
+			}
+		}
+		// lookup<-eval(call(kernel,lookup))
+		this.kernel(kernel, lookup);
+		if (justStatistic) {
+			RVAL.statistic = this.cramerStatistic(RVAL.m, RVAL.n, lookup);
+		} else if (sim.equals("eigenvalue")) {
+			/* To be implemented! */
+			Boot boot = new Boot();
+			RVAL.statistic = boot.t0;
+			RVAL.pValue = 1 - this.rank(boot.t0, boot.t) / (replicates + 1);
+			double[] toSort = this.linearize(boot.t);
+			Arrays.sort(toSort);
+			RVAL.critValue = toSort[(int) Math.round(RVAL.confLevel * RVAL.replicates)];
+			if (RVAL.statistic > RVAL.critValue) {
+				RVAL.result = 1;
+			}
+			RVAL.hypdistX = toSort;
+			RVAL.hypdistFx = this.createVector(replicates);
+		} else {
+			// RVAL$statistic<-.cramer.statistic(daten,1:(RVAL$m+RVAL$n),RVAL$m,RVAL$n,lookup)
+			RVAL.statistic = this.cramerStatistic(RVAL.m, RVAL.n, lookup);
+			// N<-RVAL$m+RVAL$n
+			int N = RVAL.m + RVAL.n;
+			// C1<-rep(0,N)
+			double[] C1 = new double[N];
+			// for (i in 1:N) for (j in 1:N) C1[i]<-C1[i]+lookup[i,j]
+			for (int i = 0; i < N; i++) {
+				for (int j = 0; j < N; j++) {
+					C1[i] += lookup[i][j];
+				}
+			}
+			// C1<-C1/N
+			this.divide(C1, N);
+			// C2<-0
+			double C2 = 0;
+			// for (i in 1:N) for (j in 1:N) C2<-C2+lookup[i,j]
+			for (int i = 0; i < N; i++) {
+				for (int j = 0; j < N; j++) {
+					C2 += lookup[i][j];
+				}
+			}
+			// C2<-C2/N^2
+			C2 /= (N * N);
+			// B<-matrix(rep(0,N^2),ncol=N)
+			double[][] B = new double[N][N];
+			// for (i in 1:N) for (j in 1:N) B[i,j]<-C1[i]+C1[j]-C2-lookup[i,j]
+			for (int i = 0; i < N; i++) {
+				for (int j = 0; j < N; j++) {
+					B[i][j] = C1[i] + C1[j] - C2 - lookup[i][j];
+				}
+			}
+			// B<-B/N
+			this.divide(B, N);
+			// RVAL$ev<-eigen(B,FALSE)
+			Matrix matrix = new Matrix(B);
+			EigenvalueDecomposition evd = matrix.eig();
+			double[] lambdasquare = evd.getRealEigenvalues();
+			Arrays.sort(lambdasquare);
+			this.reverse(lambdasquare);
+			RVAL.ev = lambdasquare;
+			// kritwert<-.cramer.kritwertfft(Re((RVAL$ev)$values),conf.level,maxM,K)
+			Kritwert kw = this.kritwertfft(lambdasquare, RVAL.confLevel, maxM, k);
+			// RVAL$p.value<-1-(kritwert$hypdist.Fx)[which.min(abs((kritwert$hypdist.x)[1:(3*length(kritwert$hypdist.x)/4)]-RVAL$statistic))];
+			double[] temp = Arrays.copyOf(kw.x, 3 * kw.x.length / 4);
+			temp = this.plus(temp, -RVAL.statistic);
+			for (int i = 0; i < temp.length; i++) {
+				temp[i] = Math.abs(temp[i]);
+			}
+			RVAL.pValue = 1 - kw.Fx[this.whichMin(temp)];
+			// RVAL$crit.value<-kritwert$quantile
+			RVAL.critValue = kw.quantile;
+			// RVAL$hypdist.x<-kritwert$hypdist.x
+			RVAL.hypdistX = kw.x;
+			// RVAL$hypdist.Fx<-kritwert$hypdist.Fx
+			RVAL.hypdistFx = kw.Fx;
+			// if (RVAL$statistic>RVAL$crit.value) RVAL$result<-1
+			if (RVAL.statistic > RVAL.critValue) {
+				RVAL.result = 1.0;
+			}
+		}
+		return RVAL;
+	}
+
+	public CramerTest cramerTest(List<Instance> x, List<Instance> y, double confLevel, int replicates, String sim,
+			boolean justStatistic, int kernel, double maxM, int k) {
+		CramerTest RVAL = new CramerTest(0, 0, 0, 0, 0, 0, 0, confLevel, replicates, null, null, null);
+		// if ((is.matrix(x))&&(is.matrix(y))) if (ncol(x)==ncol(y)) RVAL$d<-ncol(x)
+		RVAL.d = x.get(0).numAttributes();
+		// RVAL$m<-nrow(x)
+		RVAL.m = x.size();
+		// RVAL$n<-nrow(y)
+		RVAL.n = y.size();
+		// daten<-matrix(c(t(x),t(y)),ncol=ncol(x),byrow=TRUE)
+		double[][] daten = new double[RVAL.m + RVAL.n][];
+		for (int i = 0; i < RVAL.m; i++) {
+			Instance inst = x.get(i);
+			double[] values = new double[inst.numAttributes() - 1];
+			for (int j = 0; j < values.length; j++) {
+				values[j] = inst.value(j);
+			}
+			daten[i] = values;
+		}
+		for (int i = 0; i < RVAL.n; i++) {
+			Instance inst = y.get(i);
+			double[] values = new double[inst.numAttributes() - 1];
+			for (int j = 0; j < values.length; j++) {
+				values[j] = inst.value(j);
+			}
+			daten[i + RVAL.m] = values;
+		}
+		return this.compute(RVAL, daten, replicates, sim, justStatistic, kernel, maxM, k);
+	}
+
+	private void reverse(double[] array) {
+		double temp;
+		for (int i = 0, j = array.length - 1; i < j; i++, j--) {
+			// swap the elements
+			temp = array[i];
+			array[i] = array[j];
+			array[j] = temp;
+		}
+	}
+
+	public class CramerTest {
+
+		int d, m, n;
+		double pValue, critValue, statistic, result, confLevel, replicates;
+		double[] hypdistX, hypdistFx, ev;
+
+		public CramerTest(int d, int m, int n, double pValue, double critValue, double statistic, double result,
+				double confLevel, double replicates, double[] hypdistX, double[] hypdistFx, double[] ev) {
+			super();
+			this.d = d;
+			this.m = m;
+			this.n = n;
+			this.pValue = pValue;
+			this.critValue = critValue;
+			this.statistic = statistic;
+			this.result = result;
+			this.confLevel = confLevel;
+			this.replicates = replicates;
+			this.hypdistX = hypdistX;
+			this.hypdistFx = hypdistFx;
+			this.ev = ev;
+		}
+	}
+
+	public static List<Instance> fileToInstances(String path) {
+		List<Instance> x = new ArrayList();
+		try {
+			FileReader reader = new FileReader(path);
+			ArffLoader arff = new ArffLoader(reader, 1, -1);
+			Instance inst = arff.readInstance();
+			while (inst != null) {
+				x.add(inst);
+				inst = arff.readInstance();
+			}
+		} catch (FileNotFoundException e) {
+			System.out.println(e);
+		}
+		return x;
+	}
+
+	public static List<List<Double>> fileToMatrix(String path) {
+		List<List<Double>> x = new ArrayList();
+		try {
+			FileReader reader = new FileReader(path);
+			ArffLoader arff = new ArffLoader(reader, 1, -1);
+			Instance inst = arff.readInstance();
+			while (inst != null) {
+				double[] dArray = inst.toDoubleArray();
+				List<Double> list = new ArrayList();
+				for (double d : dArray) {
+					list.add(d);
+				}
+				x.add(list);
+				inst = arff.readInstance();
+			}
+		} catch (FileNotFoundException e) {
+			System.out.println(e);
+		}
+		return x;
+	}
+
+	public static void main(String[] args) throws Exception {
+		List<Instance> x = Cramer.fileToInstances("c:\\Users\\Paulo\\Documents\\test1-x.arff");
+		List<Instance> y = Cramer.fileToInstances("c:\\Users\\Paulo\\Documents\\test1-y.arff");
+
+		Cramer c = new Cramer();
+		Cramer.CramerTest ct = c.cramerTest(x, y);
+		System.out.println("p Value [Resultado esperado: 0.7092907] [Resultado obtido..: " + ct.pValue + "]");
+		System.out.println("Critical value [Resultado esperado: 2.379552] [Resultado obtido: " + ct.critValue + "]");
+		System.out.println("Statistic [Resultado esperado: 0.8160198] [Resultado obtido: " + ct.statistic + "]");
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public double test(List<Instance> x, List<Instance> y) {
+		return this.cramerTest(x, y).confLevel;
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public Double call() throws Exception {
+		return this.test(sample1i, sample2i);
+	}
+
+	@Override
+	public void set(List<Instance> x, List<Instance> y) {
+		this.sample1i = x;
+		this.sample2i = y;
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/core/statisticaltests/KNN.java b/moa/src/main/java/moa/learners/predictors/core/statisticaltests/KNN.java
new file mode 100644
index 000000000..e549497e1
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/statisticaltests/KNN.java
@@ -0,0 +1,412 @@
+/*
+ *    KNN.java
+ *    Copyright (C) 2017 Instituto Federal de Pernambuco
+ *    @author Paulo Gonçalves (paulogoncalves@recife.ifpe.edu.br)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.core.statisticaltests;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.PriorityQueue;
+
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.core.ObjectRepository;
+import moa.options.AbstractOptionHandler;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Implements the multivariate non-parametric KNN statistical test.
+ *
+ * @author Paulo Goncalves
+ *
+ */
+public class KNN extends AbstractOptionHandler implements StatisticalTest {
+
+	private List<Instance> sample1i;
+	private List<Instance> sample2i;
+
+	public IntOption kValueOption = new IntOption("kValue", 'k', "K value of the K nearest neighbours algorithm.", 5, 1,
+			Integer.MAX_VALUE);
+
+	private double[] compute(double[][] set, int d, int n1, int n2) throws InterruptedException {
+		double n = n1 + n2;
+		Arrays.fill(set[d], 0, n1, 1.0);
+		Arrays.fill(set[d], n1, n1 + n2, 2.0);
+		int[] counts = this.knn(set, n1 + n2, d, this.kValueOption.getValue());
+		double Tk = 0;
+		for (int i = 0; i < counts.length; i++) {
+			Tk += counts[i];
+		}
+		Tk /= (n * this.kValueOption.getValue());
+		double V = (n1 - 1) * (n2 - 1) / ((n - 1) * (n - 1))
+				+ 4 * ((n1 - 1) * (n1 - 2) / ((n - 1) * (n - 2))) * ((n2 - 1) * (n2 - 2) / ((n - 1) * (n - 2)));
+		double Z = Math.sqrt(n * this.kValueOption.getValue())
+				* (Tk - (n1 - 1) * (n1 - 2) / ((n - 1) * (n - 2)) - (n2 - 1) * (n2 - 2) / ((n - 1) * (n - 2)))
+				/ Math.sqrt(V);
+		double P = this.pnorm(Z, 0, 1, false, false);
+
+		return new double[] { Tk, Z, P };
+	}
+
+	private double[] attributeToDoubleArray(List<Instance> list, int attIndex) {
+		double[] ret = new double[list.size()];
+		for (int i = 0; i < list.size(); i++) {
+			ret[i] = list.get(i).value(attIndex);
+		}
+		return ret;
+	}
+
+	public double[] mtsknn(List<Instance> x, List<Instance> y) throws InterruptedException {
+		if (x.get(0).numAttributes() != y.get(0).numAttributes()) {
+			System.out.println("The dimensions of two samples must match!!!");
+			return null;
+		}
+		int d = x.get(0).numAttributes() - 1;
+		int n1 = x.size();
+		int n2 = y.size();
+		double[][] set = new double[d + 1][n1 + n2];
+		for (int i = 0; i < d; i++) {
+			double[] t1 = this.attributeToDoubleArray(x, i);
+			double[] t2 = this.attributeToDoubleArray(y, i);
+			System.arraycopy(t1, 0, set[i], 0, t1.length);
+			System.arraycopy(t2, 0, set[i], t1.length, t2.length);
+		}
+		return this.compute(set, d, n1, n2);
+	}
+
+	private double pnorm(double x, double mu, double sigma, boolean lower_tail, boolean log_p) {
+		double p;
+
+		if (Double.isNaN(x) || Double.isNaN(mu) || Double.isNaN(sigma)) {
+			return x + mu + sigma;
+		}
+		if (Double.isInfinite(x) && mu == x) {
+			return Double.NaN;/* x-mu is NaN */
+		}
+		if (sigma <= 0) {
+			// if(sigma < 0) ML_ERR_return_NAN;
+			if (x < mu) {
+				R_DT(lower_tail, log_p);
+			}
+		}
+		p = (x - mu) / sigma;
+		if (Double.isInfinite(p)) {
+			if (x < mu) {
+				R_DT(lower_tail, log_p);
+			}
+		}
+		x = p;
+
+		double[] ret = this.pnorm_both(x, p, (lower_tail ? 0 : 1), log_p);
+
+		return (lower_tail ? ret[0] : ret[1]);
+	}
+
+	private class DIPair {
+
+		double e = 0;
+		int i = 0;
+
+		public DIPair(double e0, int i0) {
+			this.e = e0;
+			this.i = i0;
+		}
+
+		public double getE() {
+			return e;
+		}
+
+		public int getI() {
+			return i;
+		}
+	}
+
+	private class HigherComparator implements Comparator<DIPair> {
+
+		@Override
+		public int compare(DIPair o1, DIPair o2) {
+			return (o1.e > o2.e) ? -1 : ((o1.e == o2.e) ? 0 : 1);
+		}
+	}
+
+	// Calculando as distancias entre dois pontos para todos os atributos
+	private double dist(double[][] points, int v1, int v2, int d) {
+		double sum = 0;
+		for (int i = 0; i != d; ++i) {
+			// Do not use Math.pow! It is 8x slower than computing directly
+			sum += (points[i][v1] - points[i][v2]) * (points[i][v1] - points[i][v2]);
+		}
+		return sum;
+	}
+
+	/**
+	 * Computes, for each instance, the number of the k nearest neighbors that are
+	 * from the same sample.
+	 *
+	 * @param points Instances of both samples put together, with the last column
+	 *               having 1 for the first sample and 2 for the second sample.
+	 * @param n      Number of instances.
+	 * @param d      Number of attributes + 1 column.
+	 * @param k      K nearest neighbors.
+	 * @return the number of the closest neighbors that are from the same sample.
+	 * @throws InterruptedException
+	 */
+	private int[] knn(double[][] points, int n, int d, int k) throws InterruptedException {
+		int[] counts = new int[n];
+		int[] closest = new int[n * k];
+		// Percorrendo todos os atributos
+		for (int i = 0; i != n; ++i) {
+			if (Thread.interrupted()) {
+				// We've been interrupted: no more crunching.
+				throw new InterruptedException();
+			}
+			PriorityQueue<DIPair> q = new PriorityQueue(k, new HigherComparator());
+			// Percorrendo os valores do atributo
+			for (int j = 0; j != n; ++j) {
+				if (i != j) {
+					DIPair dis = new DIPair(this.dist(points, i, j, d), j);
+					if (q.size() == k) {
+						if (dis.getE() < q.peek().getE()) {
+							q.add(dis);
+							q.poll();
+						}
+					} else {
+						q.add(dis);
+					}
+				}
+			}
+			// Armazenando as posicoes das k menores distancias em ordem
+			// crescente para cada instancia
+			for (int j = 0; j != k; ++j) {
+				closest[i * k + j] = q.poll().getI();
+			}
+		}
+		// Percorrendo todas as instancias
+		for (int i = 0; i != n; ++i) {
+			if (Thread.interrupted()) {
+				// We've been interrupted: no more crunching.
+				throw new InterruptedException();
+			}
+			// Percorrendo os k valores mais proximos
+			for (int j = 0; j != k; ++j) {
+				// Verificando se as instancias mais proximas sao da mesma
+				// amostra
+				if (points[d][closest[i * k + j]] == points[d][i]) {
+					counts[i] += 1;
+				}
+			}
+		}
+		return counts;
+	}
+
+	private double R_DT(boolean lower_tail, boolean log_p) {
+		return (lower_tail) ? ((log_p) ? Double.NEGATIVE_INFINITY : 0) : ((log_p) ? 0 : 1);
+	}
+
+	private double[] pnorm_both(double x, double cum, int i_tail, boolean log_p) {
+		double ccum = 0;
+		final double a[] = { 2.2352520354606839287, 161.02823106855587881, 1067.6894854603709582, 18154.981253343561249,
+				0.065682337918207449113 };
+		final double b[] = { 47.20258190468824187, 976.09855173777669322, 10260.932208618978205,
+				45507.789335026729956 };
+		final double c[] = { 0.39894151208813466764, 8.8831497943883759412, 93.506656132177855979,
+				597.27027639480026226, 2494.5375852903726711, 6848.1904505362823326, 11602.651437647350124,
+				9842.7148383839780218, 1.0765576773720192317e-8 };
+		final double d[] = { 22.266688044328115691, 235.38790178262499861, 1519.377599407554805, 6485.558298266760755,
+				18615.571640885098091, 34900.952721145977266, 38912.003286093271411, 19685.429676859990727 };
+		final double p[] = { 0.21589853405795699, 0.1274011611602473639, 0.022235277870649807, 0.001421619193227893466,
+				2.9112874951168792e-5, 0.02307344176494017303 };
+		final double q[] = { 1.28426009614491121, 0.468238212480865118, 0.0659881378689285515, 0.00378239633202758244,
+				7.29751555083966205e-5 };
+		final double M_SQRT_32 = 5.656854249492380195206754896838;
+		final double M_1_SQRT_2PI = 0.398942280401432677939946059934;
+		double xden, xnum, temp, eps, xsq, y;
+		double min = Double.MIN_VALUE;
+		int i;
+		boolean lower, upper;
+
+		if (Double.isNaN(x)) {
+			cum = ccum = x;
+			return new double[] { cum, ccum };
+		}
+
+		eps = 1E-9 * 0.5;
+
+		lower = i_tail != 1;
+		upper = i_tail != 0;
+
+		y = Math.abs(x);
+		if (y <= 0.67448975) {
+			/*
+			 * qnorm(3/4) = .6744.... -- earlier had 0.66291
+			 */
+			if (y > eps) {
+				xsq = x * x;
+				xnum = a[4] * xsq;
+				xden = xsq;
+				for (i = 0; i < 3; ++i) {
+					xnum = (xnum + a[i]) * xsq;
+					xden = (xden + b[i]) * xsq;
+				}
+			} else {
+				xnum = xden = 0.0;
+			}
+
+			temp = x * (xnum + a[3]) / (xden + b[3]);
+			if (lower) {
+				cum = 0.5 + temp;
+			}
+			if (upper) {
+				ccum = 0.5 - temp;
+			}
+			if (log_p) {
+				if (lower) {
+					cum = Math.log(cum);
+				}
+				if (upper) {
+					ccum = Math.log(ccum);
+				}
+			}
+		} else if (y <= M_SQRT_32) {
+			xnum = c[8] * y;
+			xden = y;
+			for (i = 0; i < 7; ++i) {
+				xnum = (xnum + c[i]) * y;
+				xden = (xden + d[i]) * y;
+			}
+			temp = (xnum + c[7]) / (xden + d[7]);
+
+			double[] retorno = do_del(y, log_p, cum, ccum, lower, x, temp, upper);
+			retorno = swap_tail(x, temp, retorno[0], lower, retorno[1]);
+			cum = retorno[0];
+			ccum = retorno[1];
+		} else if (log_p || (lower && -37.5193 < x && x < 8.2924) || (upper && -8.2924 < x && x < 37.5193)) {
+
+			/* Evaluate pnorm for x in (-37.5, -5.657) union (5.657, 37.5) */
+			xsq = 1.0 / (x * x);
+			xnum = p[5] * xsq;
+			xden = xsq;
+			for (i = 0; i < 4; ++i) {
+				xnum = (xnum + p[i]) * xsq;
+				xden = (xden + q[i]) * xsq;
+			}
+			temp = xsq * (xnum + p[4]) / (xden + q[4]);
+			temp = (M_1_SQRT_2PI - temp) / y;
+
+			double[] retorno = do_del(x, log_p, cum, ccum, lower, x, temp, upper);
+			retorno = swap_tail(x, temp, retorno[0], lower, retorno[1]);
+			cum = retorno[0];
+			ccum = retorno[1];
+		} else /* no log_p , large x such that probs are 0 or 1 */ if (x > 0) {
+			cum = 1.;
+			ccum = 0.;
+		} else {
+			cum = 0.;
+			ccum = 1.;
+		}
+
+		/* do not return "denormalized" -- we do in R */
+		if (log_p) {
+			if (cum > -min) {
+				cum = -0.;
+			}
+			if (ccum > -min) {
+				ccum = -0.;
+			}
+		} else {
+			if (cum < min) {
+				cum = 0.;
+			}
+			if (ccum < min) {
+				ccum = 0.;
+			}
+		}
+		return new double[] { cum, ccum };
+	}
+
+	private double[] do_del(double X, boolean log_p, double cum, double ccum, boolean lower, double x, double temp,
+			boolean upper) {
+		final int SIXTEN = 16;
+		double xsq = Math.ceil(X * SIXTEN) / SIXTEN;
+		double del = (X - xsq) * (X + xsq);
+		if (log_p) {
+			cum = (-xsq * xsq * 0.5) + (-del * 0.5) + Math.log(temp);
+			if ((lower && x > 0.) || (upper && x <= 0.)) {
+				ccum = Math.log1p(-Math.exp(-xsq * xsq * 0.5) * Math.exp(-del * 0.5) * temp);
+			}
+		} else {
+			cum = Math.exp(-xsq * xsq * 0.5) * Math.exp(-del * 0.5) * temp;
+			ccum = 1.0 - cum;
+		}
+		return new double[] { cum, ccum };
+	}
+
+	private double[] swap_tail(double x, double temp, double cum, boolean lower, double ccum) {
+		if (x > 0.) {/* swap ccum <--> cum */
+			temp = cum;
+			if (lower) {
+				cum = ccum;
+			}
+			ccum = temp;
+		}
+		return new double[] { cum, ccum };
+	}
+
+	@Override
+	public double test(List<Instance> x, List<Instance> y) {
+		try {
+			return this.mtsknn(x, y)[2];
+		} catch (InterruptedException ie) {
+			return 0.0;
+		}
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public Double call() throws Exception {
+		return this.test(sample1i, sample2i);
+	}
+
+	@Override
+	public void set(List<Instance> x, List<Instance> y) {
+		this.sample1i = x;
+		this.sample2i = y;
+	}
+
+	public static void main(String[] args) throws Exception {
+		List<Instance> x = Cramer.fileToInstances("c:\\Users\\Paulo\\Documents\\test1-x.arff");
+		List<Instance> y = Cramer.fileToInstances("c:\\Users\\Paulo\\Documents\\test1-y.arff");
+
+		KNN c = new KNN();
+		double[] ct = c.mtsknn(x, y);
+		System.out.println("p Value [Resultado esperado: 0.09866699171730517] [Resultado obtido..: " + ct[2] + "]");
+		System.out.println("Critical value [Resultado esperado: 0.521] [Resultado obtido: " + ct[0] + "]");
+		System.out.println("Statistic [Resultado esperado: 1.2891844104764096] [Resultado obtido: " + ct[1] + "]");
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/core/statisticaltests/StatisticalTest.java b/moa/src/main/java/moa/learners/predictors/core/statisticaltests/StatisticalTest.java
similarity index 65%
rename from moa/src/main/java/moa/classifiers/core/statisticaltests/StatisticalTest.java
rename to moa/src/main/java/moa/learners/predictors/core/statisticaltests/StatisticalTest.java
index ab1a4d38b..b5b359ffb 100644
--- a/moa/src/main/java/moa/classifiers/core/statisticaltests/StatisticalTest.java
+++ b/moa/src/main/java/moa/learners/predictors/core/statisticaltests/StatisticalTest.java
@@ -15,9 +15,9 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.classifiers.core.statisticaltests;
+package moa.learners.predictors.core.statisticaltests;
 
 import java.util.List;
 import java.util.concurrent.Callable;
@@ -33,18 +33,21 @@
  *
  */
 public interface StatisticalTest extends OptionHandler, Callable<Double> {
-    /**
-     * This method performs a test and returns the correspoding p-value.
-     * @param x List of instances
-     * @param y List of instances
-     * @return p-value
-     */
-    public double test(List<Instance> x, List<Instance> y);
-    /**
-     * This method sets the instances for later use in concurrent scenarios. 
-     * The test is performed by using the call() method.
-     * @param x List of instances
-     * @param y List of instances
-     */
-    public void set(List<Instance> x, List<Instance> y);
+	/**
+	 * This method performs a test and returns the correspoding p-value.
+	 * 
+	 * @param x List of instances
+	 * @param y List of instances
+	 * @return p-value
+	 */
+	double test(List<Instance> x, List<Instance> y);
+
+	/**
+	 * This method sets the instances for later use in concurrent scenarios. The
+	 * test is performed by using the call() method.
+	 * 
+	 * @param x List of instances
+	 * @param y List of instances
+	 */
+	void set(List<Instance> x, List<Instance> y);
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/AbstractErrorWeightedVoteMultiLabel.java b/moa/src/main/java/moa/learners/predictors/core/voting/AbstractErrorWeightedVoteMultiLabel.java
similarity index 54%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/AbstractErrorWeightedVoteMultiLabel.java
rename to moa/src/main/java/moa/learners/predictors/core/voting/AbstractErrorWeightedVoteMultiLabel.java
index 56d25139e..c05b7c116 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/AbstractErrorWeightedVoteMultiLabel.java
+++ b/moa/src/main/java/moa/learners/predictors/core/voting/AbstractErrorWeightedVoteMultiLabel.java
@@ -14,11 +14,11 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.classifiers.rules.multilabel.core.voting;
+package moa.learners.predictors.core.voting;
 
 import java.util.LinkedList;
 import java.util.List;
@@ -28,65 +28,61 @@
 import moa.AbstractMOAObject;
 
 /**
- * AbstractErrorWeightedVote class for weighted votes based on estimates of errors. 
+ * AbstractErrorWeightedVote class for weighted votes based on estimates of
+ * errors.
  *
  * @author João Duarte (jmduarte@inescporto.pt)
  * @version $Revision: 1 $
  */
-public abstract class AbstractErrorWeightedVoteMultiLabel extends AbstractMOAObject implements ErrorWeightedVoteMultiLabel{
+public abstract class AbstractErrorWeightedVoteMultiLabel extends AbstractMOAObject
+		implements ErrorWeightedVoteMultiLabel {
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1;
 	protected List<Prediction> votes;
 	protected List<double[]> errors;
 	protected double[][] weights;
-	protected int [] outputAttributesCount;
-	protected Prediction weightedVote=null;
-
+	protected int[] outputAttributesCount;
+	protected Prediction weightedVote = null;
 
 	public AbstractErrorWeightedVoteMultiLabel() {
 		super();
-		votes = new LinkedList<Prediction>();
-		errors = new LinkedList<double[]>();
+		votes = new LinkedList<>();
+		errors = new LinkedList<>();
 	}
 
-
 	@Override
-	public void addVote(Prediction vote, double [] error) {
-		int numOutputs=vote.numOutputAttributes();
-		if(outputAttributesCount==null)
-			outputAttributesCount=new int[numOutputs];
+	public void addVote(Prediction vote, double[] error) {
+		int numOutputs = vote.numOutputAttributes();
+		if (outputAttributesCount == null)
+			outputAttributesCount = new int[numOutputs];
 
-		for(int i=0; i<numOutputs; i++)
+		for (int i = 0; i < numOutputs; i++)
 			if (vote.getVotes()[i] != 0)
 				outputAttributesCount[i]++;
 		votes.add(vote);
 		errors.add(error);
 	}
 
-
 	@Override
 	abstract public Prediction computeWeightedVote();
 
 	@Override
-	public double getWeightedError()
-	{
-		double [] errors=getOutputAttributesErrors();
-		if(errors!=null){
-			int numOutputs=errors.length;
-			double error=0;
-			
-			for (int i=0; i<numOutputs;i++)
-				error+=errors[i];
-			
-			return error/numOutputs;
-		}
-		else
-			return Double.MAX_VALUE; 
-		
-	}
+	public double getWeightedError() {
+		double[] errors = getOutputAttributesErrors();
+		if (errors != null) {
+			int numOutputs = errors.length;
+			double error = 0;
+
+			for (int i = 0; i < numOutputs; i++)
+				error += errors[i];
 
+			return error / numOutputs;
+		} else
+			return Double.MAX_VALUE;
+
+	}
 
 	@Override
 	public double[][] getWeights() {
@@ -98,57 +94,56 @@ public int getNumberVotes() {
 		return votes.size();
 	}
 
-
 	@Override
 	public int getNumberVotes(int outputAttribute) {
 		return outputAttributesCount[outputAttribute];
 	}
 
-
 	@Override
 	public double[] getOutputAttributesErrors() {
-		double [] weightedError;
-		if (weights!=null && weights.length==errors.size())
-		{
-			int numOutputs=outputAttributesCount.length;
-			int numVotes=weights.length;
-			weightedError=new double[numOutputs];
-			
-			//For all votes
-			for (int i=0; i<numVotes; ++i){
-				//For each output attribute
-				for (int j=0; j<numOutputs; j++){
-					if(errors.get(i)!=null && errors.get(i)[j]!=Double.MAX_VALUE)
-						weightedError[j]+=errors.get(i)[j]*weights[i][j];
+		double[] weightedError;
+		if (weights != null && weights.length == errors.size()) {
+			int numOutputs = outputAttributesCount.length;
+			int numVotes = weights.length;
+			weightedError = new double[numOutputs];
+
+			// For all votes
+			for (int i = 0; i < numVotes; ++i) {
+				// For each output attribute
+				for (int j = 0; j < numOutputs; j++) {
+					if (errors.get(i) != null && errors.get(i)[j] != Double.MAX_VALUE)
+						weightedError[j] += errors.get(i)[j] * weights[i][j];
 				}
 			}
 			return weightedError;
-		}
-		else
-			//weightedError=-1; 
+		} else
+			// weightedError=-1;
 			return null;
 	}
+
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
-		
+
 	}
-	
-	public Prediction getPrediction(){
-		if (this.weightedVote==null)
-			weightedVote=computeWeightedVote();
+
+	@Override
+	public Prediction getPrediction() {
+		if (this.weightedVote == null)
+			weightedVote = computeWeightedVote();
 		return weightedVote;
 	}
-	
-	public boolean coversAllOutputs(){
-		int i=0;
-		boolean flag=false;
-		
-		if(outputAttributesCount!=null){
-			while( i<outputAttributesCount.length && outputAttributesCount[i]>0)
+
+	@Override
+	public boolean coversAllOutputs() {
+		int i = 0;
+		boolean flag = false;
+
+		if (outputAttributesCount != null) {
+			while (i < outputAttributesCount.length && outputAttributesCount[i] > 0)
 				i++;
-			flag=i==outputAttributesCount.length;
+			flag = i == outputAttributesCount.length;
 		}
 		return flag;
 	}
-	
+
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/ErrorWeightedVoteMultiLabel.java b/moa/src/main/java/moa/learners/predictors/core/voting/ErrorWeightedVoteMultiLabel.java
similarity index 59%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/ErrorWeightedVoteMultiLabel.java
rename to moa/src/main/java/moa/learners/predictors/core/voting/ErrorWeightedVoteMultiLabel.java
index 20cf08f35..2381dc50d 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/ErrorWeightedVoteMultiLabel.java
+++ b/moa/src/main/java/moa/learners/predictors/core/voting/ErrorWeightedVoteMultiLabel.java
@@ -14,94 +14,93 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.classifiers.rules.multilabel.core.voting;
+package moa.learners.predictors.core.voting;
 
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
 import moa.MOAObject;
 
 /**
- * ErrorWeightedVoteMultiLabel interface for weighted votes based on estimates of errors. 
+ * ErrorWeightedVoteMultiLabel interface for weighted votes based on estimates
+ * of errors.
  *
  * @author João Duarte (joaomaiaduarte@gmail.com)
  * @version $Revision: 1 $
  */
 public interface ErrorWeightedVoteMultiLabel {
-	
+
 	/**
-	 * Adds a vote and the corresponding error for the computation of the weighted vote and respective weighted error.
-	 * 
-	 * @param  vote - a vote returned by a classifier
-	 * @param  error - the error associated to the vote
+	 * Adds a vote and the corresponding error for the computation of the weighted
+	 * vote and respective weighted error.
+	 *
+	 * @param vote  - a vote returned by a classifier
+	 * @param error - the error associated to the vote
 	 */
-	public void addVote(Prediction prediction, double [] error);
-	
+	void addVote(Prediction prediction, double[] error);
+
 	/**
-	 * Computes the weighted vote.
-	 * Also updates the weights of the votes.
-	 * 
-	 * @return      the weighted vote
+	 * Computes the weighted vote. Also updates the weights of the votes.
+	 *
+	 * @return the weighted vote
 	 */
-	public Prediction computeWeightedVote();
-	
+	Prediction computeWeightedVote();
+
 	/**
 	 * Returns the weighted error.
-	 * 
+	 *
 	 * @pre computeWeightedVote()
-	 * @return      the weighted error
+	 * @return the weighted error
 	 */
-	public double getWeightedError();
-	
+	double getWeightedError();
+
 	/**
 	 * Returns the weighted error.
-	 * 
+	 *
 	 * @pre computeWeightedVote()
-	 * @return      the weighted error for each output attribute
+	 * @return the weighted error for each output attribute
 	 */
-	public double[] getOutputAttributesErrors();
-	
+	double[] getOutputAttributesErrors();
+
 	/**
 	 * Return the weights error.
-	 * 
+	 *
 	 * @pre computeWeightedVote()
-	 * @return      the weights for each output attribute
+	 * @return the weights for each output attribute
 	 */
-	public double[][]  getWeights();
-	
-	
+	double[][] getWeights();
+
 	/**
 	 * The number of votes added so far.
-	 * 
-	 * @return      the number of votes
+	 *
+	 * @return the number of votes
 	 */
-	public int getNumberVotes();
-	
-	
+	int getNumberVotes();
+
 	/**
 	 * The number of votes for a given output attribute.
-	 * 
+	 *
 	 * @param outputAttribute the index of the output attribute
-	 * 
-	 * @return      the number of votes
+	 *
+	 * @return the number of votes
 	 */
-	public int getNumberVotes(int outputAttribute);
-	
+	int getNumberVotes(int outputAttribute);
+
 	/**
 	 * Check if vote has a value for each output
-	 * 
+	 *
 	 */
-	public boolean coversAllOutputs();
-	
+	boolean coversAllOutputs();
+
 	/**
 	 * Creates a copy of the object
-	 * 
-	 * @return      copy of the object
+	 *
+	 * @return copy of the object
 	 */
-	public MOAObject copy();
+	MOAObject copy();
 
-	public Prediction getPrediction();
+	Prediction getPrediction();
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/FirstHitVoteMultiLabel.java b/moa/src/main/java/moa/learners/predictors/core/voting/FirstHitVoteMultiLabel.java
similarity index 67%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/FirstHitVoteMultiLabel.java
rename to moa/src/main/java/moa/learners/predictors/core/voting/FirstHitVoteMultiLabel.java
index dd188eae3..1e1db11e4 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/FirstHitVoteMultiLabel.java
+++ b/moa/src/main/java/moa/learners/predictors/core/voting/FirstHitVoteMultiLabel.java
@@ -14,16 +14,15 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.classifiers.rules.multilabel.core.voting;
+package moa.learners.predictors.core.voting;
 
 import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-
 /**
  * FirstHitVoteMultiLabel class for weighted votes based on estimates of errors.
  * Returns the first vote for each output attribute as the weighted vote.
@@ -33,29 +32,28 @@
  */
 public class FirstHitVoteMultiLabel extends AbstractErrorWeightedVoteMultiLabel {
 
-
 	private static final long serialVersionUID = 1;
+
 	@Override
 	public Prediction computeWeightedVote() {
-		int n=votes.size();
-		if (n>0){
-			int numOutputs=outputAttributesCount.length;
-			weights=new double[n][numOutputs];
-			weightedVote=new MultiLabelClassificationPrediction(numOutputs);
+		int n = votes.size();
+		if (n > 0) {
+			int numOutputs = outputAttributesCount.length;
+			weights = new double[n][numOutputs];
+			weightedVote = new MultiLabelClassificationPrediction(numOutputs);
 
-			//For each output attribute
-			for (int o=0;o<numOutputs;o++)
-			{
-				//int numClasses=votes.get(0).numClasses(o);
-				//For each vote
-				for (int i=0; i<n; i++)
-				{
-					if(votes.get(i).hasVotesForAttribute(o)){
-						//set as weighted vote and set weight to 1	
-						weights[i][o]=1;
-						/*for(int j=0; j<numClasses; j++){
-							weightedVote.setVote(o, j, votes.get(i).getVote(o, j));
-						}*/
+			// For each output attribute
+			for (int o = 0; o < numOutputs; o++) {
+				// int numClasses=votes.get(0).numClasses(o);
+				// For each vote
+				for (int i = 0; i < n; i++) {
+					if (votes.get(i).hasVotesForAttribute(o)) {
+						// set as weighted vote and set weight to 1
+						weights[i][o] = 1;
+						/*
+						 * for(int j=0; j<numClasses; j++){ weightedVote.setVote(o, j,
+						 * votes.get(i).getVote(o, j)); }
+						 */
 						weightedVote.setVote(o, votes.get(i).getPrediction(o));
 						break;
 					}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/InverseErrorWeightedVoteMultiLabel.java b/moa/src/main/java/moa/learners/predictors/core/voting/InverseErrorWeightedVoteMultiLabel.java
similarity index 55%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/InverseErrorWeightedVoteMultiLabel.java
rename to moa/src/main/java/moa/learners/predictors/core/voting/InverseErrorWeightedVoteMultiLabel.java
index a52c48d1a..4e4bd5c75 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/InverseErrorWeightedVoteMultiLabel.java
+++ b/moa/src/main/java/moa/learners/predictors/core/voting/InverseErrorWeightedVoteMultiLabel.java
@@ -14,16 +14,17 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
-package moa.classifiers.rules.multilabel.core.voting;
+package moa.learners.predictors.core.voting;
 
 import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
 /**
- * InverseErrorWeightedVoteMuliLabel class for weighted votes based on estimates of errors. 
+ * InverseErrorWeightedVoteMuliLabel class for weighted votes based on estimates
+ * of errors.
  *
  * @author João Duarte (joaomaiaduarte@gmail.com)
  * @version $Revision: 1 $
@@ -31,48 +32,43 @@
 public class InverseErrorWeightedVoteMultiLabel extends AbstractErrorWeightedVoteMultiLabel {
 
 	/**
-	 * 
+	 *
 	 */
-	private static final double EPS = 0.000000001; //just to prevent divide by 0 in 1/X -> 1/(x+EPS)
+	private static final double EPS = 0.000000001; // just to prevent divide by 0 in 1/X -> 1/(x+EPS)
 	private static final long serialVersionUID = 6359349250620616482L;
 
 	@Override
 	public Prediction computeWeightedVote() {
-		int n=votes.size();
-		if (n>0){
-			int numOutputs=outputAttributesCount.length;
-
-			weights=new double[n][numOutputs];
+		int n = votes.size();
+		if (n > 0) {
+			int numOutputs = outputAttributesCount.length;
 
+			weights = new double[n][numOutputs];
 
-			weightedVote=new MultiLabelClassificationPrediction(numOutputs);
+			weightedVote = new MultiLabelClassificationPrediction(numOutputs);
 
-			double [] sumError= new double[numOutputs];
-			//For each output attribute
-			for (int o=0;o<numOutputs;o++)
-			{
-				for (int i=0; i<n; i++)
-				{
-					if(votes.get(i).hasVotesForAttribute(o) && errors.get(i)!=null){
-						weights[i][o]=1.0/(errors.get(i)[o]+EPS);
-						sumError[o]+=weights[i][o];
+			double[] sumError = new double[numOutputs];
+			// For each output attribute
+			for (int o = 0; o < numOutputs; o++) {
+				for (int i = 0; i < n; i++) {
+					if (votes.get(i).hasVotesForAttribute(o) && errors.get(i) != null) {
+						weights[i][o] = 1.0 / (errors.get(i)[o] + EPS);
+						sumError[o] += weights[i][o];
 					}
 				}
 
-				//For each vote
-				for (int i=0; i<n; i++)
-				{
-					if(votes.get(i).hasVotesForAttribute(o)){
-						if(sumError[o]>0)
-							weights[i][o]/=sumError[o];
+				// For each vote
+				for (int i = 0; i < n; i++) {
+					if (votes.get(i).hasVotesForAttribute(o)) {
+						if (sumError[o] > 0)
+							weights[i][o] /= sumError[o];
 						else
-							weights[i][o]=1.0/outputAttributesCount[o];
+							weights[i][o] = 1.0 / outputAttributesCount[o];
 					}
-					//For each class
-						weightedVote.setVote(o, 0, weightedVote.getVote(o, 0)+votes.get(i).getVote(o, 0)*weights[i][o]);
+					// For each class
+					weightedVote.setVote(o, weightedVote.getPrediction(o) + votes.get(i).getPrediction(o) * weights[i][o]);
 
-
-				}	
+				}
 
 			}
 
@@ -80,5 +76,4 @@ public Prediction computeWeightedVote() {
 		return weightedVote;
 	}
 
-
 }
diff --git a/moa/src/main/java/moa/learners/predictors/core/voting/MultiLabelVote.java b/moa/src/main/java/moa/learners/predictors/core/voting/MultiLabelVote.java
new file mode 100644
index 000000000..915be07d3
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/core/voting/MultiLabelVote.java
@@ -0,0 +1,48 @@
+package moa.learners.predictors.core.voting;
+
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+public class MultiLabelVote {
+	protected Prediction vote;
+	protected double error;
+
+	public MultiLabelVote(Prediction vote, double error) {
+		super();
+		this.vote = vote;
+		this.error = error;
+	}
+
+	public Prediction getVote() {
+		return vote;
+	}
+
+	public void setVote(Prediction vote) {
+		this.vote = vote;
+	}
+
+	public double getError() {
+		return error;
+	}
+
+	public void setError(double error) {
+		this.error = error;
+	}
+
+	public double[] sumVoteDistrib() {
+		int numOutputs = vote.numOutputAttributes();
+		double[] sum = new double[numOutputs];
+		for (int j = 0; j < numOutputs; j++) {
+			for (int i = 0; i < vote.numClasses(j); ++i)
+				sum[j] += vote.getVote(j, i);
+		}
+		return sum;
+	}
+
+	public void normalize() {
+		double[] sum = sumVoteDistrib();
+		for (int j = 0; j < vote.numOutputAttributes(); j++)
+			for (int i = 0; i < vote.numClasses(j); ++i)
+				if (sum[j] != 0)
+					vote.setVote(j, i, vote.getVote(j, i) / sum[j]);
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/UniformWeightedVoteMultiLabel.java b/moa/src/main/java/moa/learners/predictors/core/voting/UniformWeightedVoteMultiLabel.java
similarity index 64%
rename from moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/UniformWeightedVoteMultiLabel.java
rename to moa/src/main/java/moa/learners/predictors/core/voting/UniformWeightedVoteMultiLabel.java
index 53667bd18..60c77eb6b 100644
--- a/moa/src/main/java/moa/classifiers/rules/multilabel/core/voting/UniformWeightedVoteMultiLabel.java
+++ b/moa/src/main/java/moa/learners/predictors/core/voting/UniformWeightedVoteMultiLabel.java
@@ -14,53 +14,50 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.classifiers.rules.multilabel.core.voting;
+package moa.learners.predictors.core.voting;
 
 import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-
 /**
- * UniformWeightedVote class for weighted votes based on estimates of errors. 
+ * UniformWeightedVote class for weighted votes based on estimates of errors.
  *
  * @author João Duarte (joaomaiaduarte@gmail.com)
  * @version $Revision: 1 $
  */
 public class UniformWeightedVoteMultiLabel extends AbstractErrorWeightedVoteMultiLabel {
 
-
 	private static final long serialVersionUID = 1;
+
 	@Override
 	public Prediction computeWeightedVote() {
-		int n=votes.size();
-		if (n>0){
-			int numOutputs=outputAttributesCount.length;
-			weights=new double[n][numOutputs];
-			weightedVote=new MultiLabelClassificationPrediction(numOutputs);
+		int n = votes.size();
+		if (n > 0) {
+			int numOutputs = outputAttributesCount.length;
+			weights = new double[n][numOutputs];
+			weightedVote = new MultiLabelClassificationPrediction(numOutputs);
 
 			// For each vote
-			for (int i=0; i<n; i++)
-			{
+			for (int i = 0; i < n; i++) {
 
-				//For each output attribute
-				for (int o=0;o<numOutputs;o++)
-				{
-					//int numClasses=2;
-					if(votes.get(i).hasVotesForAttribute(o))
-						weights[i][o]=1.0/outputAttributesCount[o];
+				// For each output attribute
+				for (int o = 0; o < numOutputs; o++) {
+					// int numClasses=2;
+					if (votes.get(i).hasVotesForAttribute(o))
+						weights[i][o] = 1.0 / outputAttributesCount[o];
 					else
-						weights[i][o]=0.0;
-					//else takes value 0
+						weights[i][o] = 0.0;
+					// else takes value 0
 
-					// In multi-label classification there are only two classes for 
-					//For each class
-					//for(int j=0; j<numClasses; j++){
-						weightedVote.setVote(o, 0, weightedVote.getVote(o, 0)+votes.get(i).getVote(o, 0)*weights[i][o]);
-					//}
+					// In multi-label classification there are only two classes for
+					// For each class
+					// for(int j=0; j<numClasses; j++){
+					weightedVote.setVote(o, 0, weightedVote.getVote(o, 0) + votes.get(i).getVote(o, 0) * weights[i][o]);
+					// }
 				}
 			}
 
diff --git a/moa/src/main/java/moa/learners/predictors/drift/DriftDetectionMethodClassifier.java b/moa/src/main/java/moa/learners/predictors/drift/DriftDetectionMethodClassifier.java
new file mode 100644
index 000000000..469c7f4b4
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/drift/DriftDetectionMethodClassifier.java
@@ -0,0 +1,204 @@
+/*
+ *    DriftDetectionMethodClassifier.java
+ *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
+ *    @author Manuel Baena (mbaena@lcc.uma.es)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package moa.learners.predictors.drift;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.capabilities.CapabilitiesHandler;
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
+import moa.core.Measurement;
+import moa.core.Utils;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.AbstractInstanceLearner;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.core.driftdetection.ChangeDetector;
+import moa.learners.predictors.meta.WEKAClassifier;
+import moa.options.ClassOption;
+
+/**
+ * Class for handling concept drift datasets with a wrapper on a classifier.
+ * <p>
+ *
+ * Valid options are:
+ * <p>
+ *
+ * -l classname <br>
+ * Specify the full class name of a classifier as the basis for the concept
+ * drift classifier.
+ * <p>
+ * -d Drift detection method to use<br>
+ *
+ * @author Manuel Baena (mbaena@lcc.uma.es)
+ * @version 1.1
+ */
+public class DriftDetectionMethodClassifier extends AbstractClassifier implements Classifier, CapabilitiesHandler {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Classifier that replaces the current classifier with a new one when a change is detected in accuracy.";
+	}
+
+	public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l', "Classifier to train.", Classifier.class,
+			"bayes.NaiveBayes");
+
+	public ClassOption driftDetectionMethodOption = new ClassOption("driftDetectionMethod", 'd',
+			"Drift detection method to use.", ChangeDetector.class, "DDM");
+
+	protected Classifier classifier;
+
+	protected Classifier newclassifier;
+
+	protected ChangeDetector driftDetectionMethod;
+
+	protected boolean newClassifierReset;
+	// protected int numberInstances = 0;
+
+	protected int ddmLevel;
+
+	public boolean isWarningDetected() {
+		return (this.ddmLevel == DDM_WARNING_LEVEL);
+	}
+
+	public boolean isChangeDetected() {
+		return (this.ddmLevel == DDM_OUTCONTROL_LEVEL);
+	}
+
+	public static final int DDM_INCONTROL_LEVEL = 0;
+
+	public static final int DDM_WARNING_LEVEL = 1;
+
+	public static final int DDM_OUTCONTROL_LEVEL = 2;
+
+	@Override
+	public void resetLearningImpl() {
+		this.classifier = (Classifier) ((Classifier) getPreparedClassOption(this.baseLearnerOption)).copy();
+		this.newclassifier = (Classifier) this.classifier.copy();
+		this.classifier.resetLearning();
+		this.newclassifier.resetLearning();
+		this.driftDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.driftDetectionMethodOption)).copy();
+		this.newClassifierReset = false;
+	}
+
+	protected int changeDetected = 0;
+
+	protected int warningDetected = 0;
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		// this.numberInstances++;
+		int trueClass = (int) inst.classValue();
+		boolean prediction;
+		if (Utils.maxIndex(this.classifier.getPredictionForInstance(inst)) == trueClass) {
+			prediction = true;
+		} else {
+			prediction = false;
+		}
+		// this.ddmLevel = this.driftDetectionMethod.computeNextVal(prediction);
+		this.driftDetectionMethod.input(prediction ? 0.0 : 1.0);
+		this.ddmLevel = DDM_INCONTROL_LEVEL;
+		if (this.driftDetectionMethod.getChange()) {
+			this.ddmLevel = DDM_OUTCONTROL_LEVEL;
+		}
+		if (this.driftDetectionMethod.getWarningZone()) {
+			this.ddmLevel = DDM_WARNING_LEVEL;
+		}
+		switch (this.ddmLevel) {
+		case DDM_WARNING_LEVEL:
+			// System.out.println("1 0 W");
+			// System.out.println("DDM_WARNING_LEVEL");
+			if (newClassifierReset == true) {
+				this.warningDetected++;
+				this.newclassifier.resetLearning();
+				newClassifierReset = false;
+			}
+			this.newclassifier.trainOnInstance(inst);
+			break;
+
+		case DDM_OUTCONTROL_LEVEL:
+			// System.out.println("0 1 O");
+			// System.out.println("DDM_OUTCONTROL_LEVEL");
+			this.changeDetected++;
+			this.classifier = null;
+			this.classifier = this.newclassifier;
+			if (this.classifier instanceof WEKAClassifier) {
+				((WEKAClassifier) this.classifier).buildClassifier();
+			}
+			this.newclassifier = (Classifier) ((Classifier) getPreparedClassOption(this.baseLearnerOption)).copy();
+			this.newclassifier.resetLearning();
+			break;
+
+		case DDM_INCONTROL_LEVEL:
+			// System.out.println("0 0 I");
+			// System.out.println("DDM_INCONTROL_LEVEL");
+			newClassifierReset = true;
+			break;
+		default:
+			// System.out.println("ERROR!");
+
+		}
+
+		this.classifier.trainOnInstance(inst);
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		return this.classifier.getPredictionForInstance(inst);
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		((AbstractInstanceLearner) this.classifier).getModelDescription(out, indent);
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		List<Measurement> measurementList = new LinkedList<>();
+		measurementList.add(new Measurement("Change detected", this.changeDetected));
+		measurementList.add(new Measurement("Warning detected", this.warningDetected));
+		Measurement[] modelMeasurements = ((AbstractInstanceLearner) this.classifier).getModelMeasurements();
+		if (modelMeasurements != null) {
+			for (Measurement measurement : modelMeasurements) {
+				measurementList.add(measurement);
+			}
+		}
+		this.changeDetected = 0;
+		this.warningDetected = 0;
+		return measurementList.toArray(new Measurement[measurementList.size()]);
+	}
+
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == DriftDetectionMethodClassifier.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/functions/AdaGrad.java b/moa/src/main/java/moa/learners/predictors/functions/AdaGrad.java
new file mode 100644
index 000000000..9b1b518b6
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/functions/AdaGrad.java
@@ -0,0 +1,182 @@
+/*
+ *    AdaGrad.java
+ *    Copyright (C) 2016 University of Waikato, Hamilton, New Zealand
+ *    @author Henry Gouk (hgrg1{[at]}students{[dot]}waikato{[dot]}ac{[dot]}nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.functions;
+
+import com.github.javacliparser.FloatOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.core.DoubleVector;
+
+/**
+ * <!-- globalinfo-start --> Implements the AdaGrad oneline optimiser for
+ * learning various linear models (binary class SVM, binary class logistic
+ * regression and linear regression). For more information, see<br/>
+ * <br/>
+ * Duchi, J., Hazan, E., &amp; Singer, Y. (2011). Adaptive subgradient methods
+ * for online learning and stochastic optimization. Journal of Machine Learning
+ * Research, 12 (Jul), 2121-2159.
+ * <p/>
+ * <!-- globalinfo-end --> * <!-- technical-bibtex-start --> BibTeX:
+ * 
+ * <pre>
+ * &#64;inproceedings{duchi2011,
+ *    author = {Duchi, John and Hazan, Elad and Singer, Yoram},
+ *    booktitle = {Journal of Machine Learning Research},
+ *    pages = {2121--2159},
+ *    volume={12},
+ *    number={Jul},
+ *    title = {Adaptive subgradient methods for online learning and stochastic optimization},
+ *    year = {2011}
+ * }
+ * </pre>
+ * <p/>
+ * <!-- technical-bibtex-end -->
+ *
+ */
+public class AdaGrad extends SGD {
+
+	/** For serialization */
+	private static final long serialVersionUID = -3732968666673530291L;
+
+	@Override
+	public String getPurposeString() {
+		return "An online optimiser for learning various linear models (binary class SVM, binary class logistic regression and linear regression).";
+	}
+
+	/** The epsilon value */
+	protected double m_epsilon = 1e-8;
+
+	public FloatOption epsilonOption = new FloatOption("epsilon", 'p', "epsilon parameter.", 1e-8);
+
+	/** Stores the weights (+ bias in the last element) */
+	protected DoubleVector m_velocity;
+	protected double m_biasVelocity;
+
+	/**
+	 * Set the epsilon value.
+	 *
+	 * @param eps the epsilon value to use.
+	 */
+	public void setEpsilon(double eps) {
+		m_epsilon = eps;
+	}
+
+	/**
+	 * Get the epsilon value.
+	 *
+	 * @return the epsilon value
+	 */
+	public double getEpsilon() {
+		return m_epsilon;
+	}
+
+	public AdaGrad() {
+		lambdaRegularizationOption = new FloatOption(lambdaRegularizationOption.getName(),
+				lambdaRegularizationOption.getCLIChar(), lambdaRegularizationOption.getPurpose(), 0.0);
+
+		learningRateOption = new FloatOption(learningRateOption.getName(), learningRateOption.getCLIChar(),
+				learningRateOption.getPurpose(), 0.01);
+	}
+
+	@Override
+	public void resetLearningImpl() {
+		reset();
+		setLambda(this.lambdaRegularizationOption.getValue());
+		setLearningRate(this.learningRateOption.getValue());
+		setEpsilon(this.epsilonOption.getValue());
+		setLossFunction(this.lossFunctionOption.getChosenIndex());
+	}
+
+	/**
+	 * Trains the classifier with the given instance.
+	 *
+	 * @param instance the new training instance to include in the model
+	 */
+	@Override
+	public void trainOnInstanceImpl(Instance instance) {
+
+		if (m_weights == null) {
+			m_weights = new DoubleVector();
+			m_velocity = new DoubleVector();
+			m_bias = 0;
+
+			m_weights.setValue(instance.numAttributes(), 0);
+			m_velocity.setValue(instance.numAttributes(), 0);
+		}
+
+		if (instance.classIsMissing()) {
+			return;
+		}
+
+		double z = dotProd(instance, m_weights, instance.classIndex()) + m_bias;
+
+		double y;
+		double dldz;
+
+		if (instance.classAttribute().isNominal()) {
+			y = (instance.classValue() == 0) ? 0 : 1;
+
+			if (m_loss == LOGLOSS) {
+				double yhat = 1.0 / (1.0 + Math.exp(-z));
+				dldz = (yhat - y);
+			} else {
+				y = y * 2 - 1;
+
+				if (y * z < 1.0) {
+					dldz = -y;
+				} else {
+					dldz = 0;
+				}
+			}
+		} else {
+			y = instance.classValue();
+			dldz = z - y;
+		}
+
+		int n = instance.numValues();
+		DoubleVector gradients = new DoubleVector();
+		gradients.setValue(instance.numAttributes(), 0);
+
+		for (int i = 0; i < n; i++) {
+			int idx = instance.index(i);
+			gradients.setValue(idx,
+					instance.valueSparse(i) * dldz + (m_lambda / (m_t + m_epsilon)) * m_weights.getValue(idx));
+		}
+
+		// Weight update for the bias
+		double biasGradient = dldz;
+		m_biasVelocity += biasGradient * biasGradient;
+		m_bias -= (m_learningRate / (Math.sqrt(m_biasVelocity) + m_epsilon)) * biasGradient;
+
+		for (int i = 0; i < m_weights.numValues(); i++) {
+			// Weight update
+			double g = gradients.getValue(i);
+			m_velocity.addToValue(i, g * g);
+			m_weights.addToValue(i, -(m_learningRate / (Math.sqrt(m_velocity.getValue(i)) + m_epsilon)) * g);
+		}
+
+		m_t += 1.0;
+	}
+
+	@Override
+	protected String getModelName() {
+		return "AdaGrad";
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/functions/MajorityClass.java b/moa/src/main/java/moa/learners/predictors/functions/MajorityClass.java
new file mode 100644
index 000000000..fd9c59dd8
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/functions/MajorityClass.java
@@ -0,0 +1,99 @@
+/*
+ *    MajorityClass.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.functions;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.StringUtils;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+
+/**
+ * Majority class learner. This is the simplest classifier.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public class MajorityClass extends AbstractClassifier implements Classifier {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Majority class classifier: always predicts the class that has been observed most frequently the in the training data.";
+	}
+
+	protected DoubleVector observedClassDistribution;
+
+	@Override
+	public void resetLearningImpl() {
+		this.observedClassDistribution = new DoubleVector();
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight());
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance i) {
+		return new ClassificationPrediction(this.observedClassDistribution.getArrayCopy());
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return null;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		StringUtils.appendIndented(out, indent, "Predicted majority ");
+		out.append(getClassNameString());
+		out.append(" = ");
+		out.append(getClassLabelString(this.observedClassDistribution.maxIndex()));
+		StringUtils.appendNewline(out);
+		for (int i = 0; i < this.observedClassDistribution.numValues(); i++) {
+			StringUtils.appendIndented(out, indent, "Observed weight of ");
+			out.append(getClassLabelString(i));
+			out.append(": ");
+			out.append(this.observedClassDistribution.getValue(i));
+			StringUtils.appendNewline(out);
+		}
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == MajorityClass.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/functions/MajorityLabelset.java b/moa/src/main/java/moa/learners/predictors/functions/MajorityLabelset.java
new file mode 100644
index 000000000..ec757cfaf
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/functions/MajorityLabelset.java
@@ -0,0 +1,110 @@
+/*
+ *    MajorityLabelset.java
+ *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
+ *    @author Jesse Read (jesse@tsc.uc3m.es)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.functions;
+
+import java.util.HashMap;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Measurement;
+import moa.core.StringUtils;
+import moa.learners.predictors.AbstractMultiLabelClassifier;
+import moa.learners.predictors.MultiLabelClassifier;
+
+/**
+ * Majority Labelset classifier. Each labelset combination of relevances, e.g.
+ * [0,0,1,1,0,0], is treated as a single class value.
+ *
+ * @author Jesse Read (jesse@tsc.uc3m.es)
+ * @version $Revision: 1 $
+ */
+public class MajorityLabelset extends AbstractMultiLabelClassifier implements MultiLabelClassifier {
+	// AbstractClassifier {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Majority labelset classifier: always predicts the labelvector most frequently seen so far.";
+	}
+
+	private double maxValue = -1.0;
+
+	private MultiLabelClassificationPrediction majorityLabelset = null;
+
+	private HashMap<String, Double> vectorCounts = new HashMap<>();
+
+	@Override
+	public void resetLearningImpl() {
+		this.majorityLabelset = null;
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance x) {
+		int L = x.numOutputAttributes();
+
+		MultiLabelClassificationPrediction y = new MultiLabelClassificationPrediction(L);
+		for (int j = 0; j < L; j++)
+			y.setVotes(j, new double[] { 1 - x.classValue(j), x.classValue(j) });
+
+		double freq = x.weight();
+		if (this.vectorCounts.containsKey(y.toString())) {
+			freq += this.vectorCounts.get(y.toString());
+		}
+		this.vectorCounts.put(y.toString(), freq);
+		if (freq > this.maxValue) {
+			this.maxValue = freq;
+			this.majorityLabelset = y;
+		}
+		// System.out.println("---"+this.majorityLabelset);
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance x) {
+
+		if (this.majorityLabelset == null) {
+			int L = x.numOutputAttributes();
+			return new MultiLabelClassificationPrediction(L);
+		}
+
+		return this.majorityLabelset;
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return null;
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		StringUtils.appendIndented(out, indent, "");
+		out.append(this.majorityLabelset.toString());
+		StringUtils.appendNewline(out);
+
+	}
+
+}
diff --git a/moa/src/main/java/moa/classifiers/functions/Mean.java b/moa/src/main/java/moa/learners/predictors/functions/Mean.java
similarity index 85%
rename from moa/src/main/java/moa/classifiers/functions/Mean.java
rename to moa/src/main/java/moa/learners/predictors/functions/Mean.java
index f4d534e34..3785ac031 100644
--- a/moa/src/main/java/moa/classifiers/functions/Mean.java
+++ b/moa/src/main/java/moa/learners/predictors/functions/Mean.java
@@ -1,19 +1,19 @@
-package moa.classifiers.functions;
+package moa.learners.predictors.functions;
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 import com.yahoo.labs.samoa.instances.predictions.RegressionPrediction;
 
-import moa.classifiers.AbstractRegressor;
 import moa.core.Measurement;
 import moa.core.StringUtils;
-import moa.learners.Regressor;
+import moa.learners.predictors.AbstractRegressor;
+import moa.learners.predictors.Regressor;
 
 public class Mean extends AbstractRegressor implements Regressor {
 
 	double n = 0;
 	double sum = 0;
-	
+
 	@Override
 	public boolean isRandomizable() {
 		// TODO Auto-generated method stub
@@ -37,7 +37,7 @@ public Prediction getPredictionForInstance(Instance instance) {
 	@Override
 	public void trainOnInstanceImpl(Instance inst) {
 		n += inst.weight();
-		sum += inst.classValue() * inst.weight(); 
+		sum += inst.classValue() * inst.weight();
 	}
 
 	@Override
diff --git a/moa/src/main/java/moa/learners/predictors/functions/MultiTargetNoChange.java b/moa/src/main/java/moa/learners/predictors/functions/MultiTargetNoChange.java
new file mode 100644
index 000000000..d2d01bb24
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/functions/MultiTargetNoChange.java
@@ -0,0 +1,70 @@
+package moa.learners.predictors.functions;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.MultiTargetRegressionPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.learners.predictors.AbstractMultiTargetRegressor;
+import moa.learners.predictors.MultiTargetRegressor;
+
+/**
+ * MultiTargetNoChange class regressor. It always predicts the last target
+ * values seen.
+ *
+ * @author Albert Bifet (abifet@cs.waikato.ac.nz)
+ * @version $Revision: 1 $
+ */
+public class MultiTargetNoChange extends AbstractMultiTargetRegressor implements MultiTargetRegressor {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Weather Forecast class classifier: always predicts the last class seen.";
+	}
+
+	// protected InstanceData lastSeenClasses;
+	Prediction lastSeenClasses;
+
+	@Override
+	public void resetLearningImpl() {
+		this.lastSeenClasses = null;
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		int numOutputs = inst.numOutputAttributes();
+		DoubleVector prediction = new DoubleVector();
+
+		for (int i = 0; i < numOutputs; i++)
+			prediction.setValue(i, inst.classValue(i));
+
+		this.lastSeenClasses = new MultiTargetRegressionPrediction(prediction);
+
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return null;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		// return (lastSeenClasses!=null) ? this.lastSeenClasses : new
+		// MultiLabelPrediction();
+		return (lastSeenClasses != null) ? this.lastSeenClasses : null;
+	}
+
+}
diff --git a/moa/src/main/java/moa/classifiers/functions/NoChange.java b/moa/src/main/java/moa/learners/predictors/functions/NoChange.java
similarity index 55%
rename from moa/src/main/java/moa/classifiers/functions/NoChange.java
rename to moa/src/main/java/moa/learners/predictors/functions/NoChange.java
index 152042e4c..b5f6758be 100644
--- a/moa/src/main/java/moa/classifiers/functions/NoChange.java
+++ b/moa/src/main/java/moa/learners/predictors/functions/NoChange.java
@@ -15,17 +15,17 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.classifiers.functions;
+package moa.learners.predictors.functions;
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-import moa.classifiers.AbstractClassifier;
 import moa.core.Measurement;
-import moa.learners.Classifier;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
 
 /**
  * NoChange class classifier. It always predicts the last class seen.
@@ -35,42 +35,44 @@
  */
 public class NoChange extends AbstractClassifier implements Classifier {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Weather Forecast class classifier: always predicts the last class seen.";
+	}
 
-    @Override
-    public String getPurposeString() {
-        return "Weather Forecast class classifier: always predicts the last class seen.";
-    }
+	protected double lastSeenClass;
 
-    protected double lastSeenClass;
+	@Override
+	public void resetLearningImpl() {
+		this.lastSeenClass = 0;
+	}
 
-    @Override
-    public void resetLearningImpl() {
-        this.lastSeenClass = 0;
-    }
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		this.lastSeenClass = inst.classValue();
+	}
 
-    @Override
-    public void trainOnInstanceImpl(Instance inst) {
-        this.lastSeenClass = inst.classValue();
-    }
+	@Override
+	public Prediction getPredictionForInstance(Instance i) {
+		double[] votes = new double[i.numClasses()];
+		votes[(int) lastSeenClass] = 1.0;
+		return new ClassificationPrediction(votes);
+	}
 
-    public Prediction getPredictionForInstance(Instance i) {
-        double[] votes = new double[i.numClasses()];
-        votes[(int) lastSeenClass] = 1.0;
-        return new ClassificationPrediction(votes);
-    }
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return null;
+	}
 
-    @Override
-    protected Measurement[] getModelMeasurementsImpl() {
-        return null;
-    }
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
 
-    @Override
-    public void getModelDescription(StringBuilder out, int indent) {
-       
-    }
+	}
 
-    public boolean isRandomizable() {
-        return false;
-    }
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
 }
diff --git a/moa/src/main/java/moa/learners/predictors/functions/Perceptron.java b/moa/src/main/java/moa/learners/predictors/functions/Perceptron.java
new file mode 100644
index 000000000..f43d6d263
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/functions/Perceptron.java
@@ -0,0 +1,166 @@
+/*
+ *    Perceptron.java
+ *    Copyright (C) 2009 University of Waikato, Hamilton, New Zealand
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.functions;
+
+import com.github.javacliparser.FloatOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Measurement;
+import moa.core.Utils;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+
+/**
+ * Single perceptron classifier.
+ *
+ * <p>
+ * Performs classic perceptron multiclass learning incrementally.
+ * </p>
+ *
+ * <p>
+ * Parameters:
+ * </p>
+ * <ul>
+ * <li>-r : Learning ratio of the classifier</li>
+ * </ul>
+ *
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @version $Revision: 7 $
+ */
+public class Perceptron extends AbstractClassifier implements Classifier {
+
+	private static final long serialVersionUID = 221L;
+
+	@Override
+	public String getPurposeString() {
+		return "Perceptron classifier: Single perceptron classifier.";
+	}
+
+	public FloatOption learningRatioOption = new FloatOption("learningRatio", 't', "Learning ratio", 1);
+
+	protected double[][] weightAttribute;
+
+	protected boolean reset;
+
+	protected int numberAttributes;
+
+	protected int numberClasses;
+
+	protected int numberDetections;
+
+	@Override
+	public void resetLearningImpl() {
+		this.reset = true;
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+
+		// Init Perceptron
+		if (this.reset == true) {
+			this.reset = false;
+			this.numberAttributes = inst.numAttributes();
+			this.numberClasses = inst.numClasses();
+			this.weightAttribute = new double[inst.numClasses()][inst.numAttributes()];
+			for (int i = 0; i < inst.numClasses(); i++) {
+				for (int j = 0; j < inst.numAttributes(); j++) {
+					weightAttribute[i][j] = 0.2 * this.classifierRandom.nextDouble() - 0.1;
+				}
+			}
+		}
+
+		double[] preds = new double[inst.numClasses()];
+		for (int i = 0; i < inst.numClasses(); i++) {
+			preds[i] = prediction(inst, i);
+		}
+		double learningRatio = learningRatioOption.getValue();
+
+		int actualClass = (int) inst.classValue();
+		for (int i = 0; i < inst.numClasses(); i++) {
+			double actual = (i == actualClass) ? 1.0 : 0.0;
+			double delta = (actual - preds[i]) * preds[i] * (1 - preds[i]);
+			for (int j = 0; j < inst.numAttributes() - 1; j++) {
+				this.weightAttribute[i][j] += learningRatio * delta * inst.valueInputAttribute(j);
+			}
+			this.weightAttribute[i][inst.numAttributes() - 1] += learningRatio * delta;
+		}
+	}
+
+	public void setWeights(double[][] w) {
+		// Perceptron Hoeffding Tree
+		this.weightAttribute = w;
+	}
+
+	public double[][] getWeights() {
+		// Perceptron Hoeffding Tree
+		return this.weightAttribute;
+	}
+
+	public int getNumberAttributes() {
+		// Perceptron Hoeffding Tree
+		return this.numberAttributes;
+	}
+
+	public int getNumberClasses() {
+		// Perceptron Hoeffding Tree
+		return this.numberClasses;
+	}
+
+	public double prediction(Instance inst, int classVal) {
+		double sum = 0.0;
+		for (int i = 0; i < inst.numAttributes() - 1; i++) {
+			sum += weightAttribute[classVal][i] * inst.valueInputAttribute(i);
+		}
+		sum += weightAttribute[classVal][inst.numAttributes() - 1];
+		return 1.0 / (1.0 + Math.exp(-sum));
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		double[] votes = new double[inst.numClasses()];
+		if (this.reset == false) {
+			for (int i = 0; i < votes.length; i++) {
+				votes[i] = prediction(inst, i);
+			}
+			try {
+				Utils.normalize(votes);
+			} catch (Exception e) {
+				// ignore all zero votes error
+			}
+		}
+		return new ClassificationPrediction(votes);
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return null;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/functions/SGD.java b/moa/src/main/java/moa/learners/predictors/functions/SGD.java
new file mode 100644
index 000000000..a43918279
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/functions/SGD.java
@@ -0,0 +1,383 @@
+/*
+ *    SGD.java
+ *    Copyright (C) 2009 University of Waikato, Hamilton, New Zealand
+ *    @author Eibe Frank (eibe{[at]}cs{[dot]}waikato{[dot]}ac{[dot]}nz)
+ *    @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/*
+ *    SGD.java
+ *    Copyright (C) 2009 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package moa.learners.predictors.functions;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+import com.yahoo.labs.samoa.instances.predictions.RegressionPrediction;
+
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.StringUtils;
+import moa.core.Utils;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.Regressor;
+
+/**
+ * <!-- globalinfo-start --> Implements stochastic gradient descent for learning
+ * various linear models (binary class SVM, binary class logistic regression and
+ * linear regression).
+ * <p/>
+ * <!-- globalinfo-end -->
+ *
+ */
+public class SGD extends AbstractClassifier implements Classifier, Regressor {
+
+	/** For serialization */
+	private static final long serialVersionUID = -3732968666673530290L;
+
+	@Override
+	public String getPurposeString() {
+		return "AStochastic gradient descent for learning various linear models (binary class SVM, binary class logistic regression and linear regression).";
+	}
+
+	/** The regularization parameter */
+	protected double m_lambda = 0.0001;
+
+	public FloatOption lambdaRegularizationOption = new FloatOption("lambdaRegularization", 'l',
+			"Lambda regularization parameter .", 0.0001, 0.00, Integer.MAX_VALUE);
+
+	/** The learning rate */
+	protected double m_learningRate = 0.01;
+
+	public FloatOption learningRateOption = new FloatOption("learningRate", 'r', "Learning rate parameter.", 0.0001,
+			0.00, Integer.MAX_VALUE);
+
+	/** Stores the weights (+ bias in the last element) */
+	protected DoubleVector m_weights;
+
+	protected double m_bias;
+
+	/** Holds the current iteration number */
+	protected double m_t;
+
+	/** The number of training instances */
+	protected double m_numInstances;
+
+	protected static final int HINGE = 0;
+
+	protected static final int LOGLOSS = 1;
+
+	protected static final int SQUAREDLOSS = 2;
+
+	/** The current loss function to minimize */
+	protected int m_loss = HINGE;
+
+	public MultiChoiceOption lossFunctionOption = new MultiChoiceOption("lossFunction", 'o',
+			"The loss function to use.", new String[] { "HINGE", "LOGLOSS", "SQUAREDLOSS" },
+			new String[] { "Hinge loss (SVM)", "Log loss (logistic regression)", "Squared loss (regression)" }, 0);
+
+	/**
+	 * Set the value of lambda to use
+	 *
+	 * @param lambda the value of lambda to use
+	 */
+	public void setLambda(double lambda) {
+		m_lambda = lambda;
+	}
+
+	/**
+	 * Get the current value of lambda
+	 *
+	 * @return the current value of lambda
+	 */
+	public double getLambda() {
+		return m_lambda;
+	}
+
+	/**
+	 * Set the loss function to use.
+	 *
+	 * @param function the loss function to use.
+	 */
+	public void setLossFunction(int function) {
+		m_loss = function;
+	}
+
+	/**
+	 * Get the current loss function.
+	 *
+	 * @return the current loss function.
+	 */
+	public int getLossFunction() {
+		return m_loss;
+	}
+
+	/**
+	 * Set the learning rate.
+	 *
+	 * @param lr the learning rate to use.
+	 */
+	public void setLearningRate(double lr) {
+		m_learningRate = lr;
+	}
+
+	/**
+	 * Get the learning rate.
+	 *
+	 * @return the learning rate
+	 */
+	public double getLearningRate() {
+		return m_learningRate;
+	}
+
+	/**
+	 * Reset the classifier.
+	 */
+	public void reset() {
+		m_t = 1;
+		m_weights = null;
+		m_bias = 0.0;
+	}
+
+	protected double dloss(double z) {
+		if (m_loss == HINGE) {
+			return (z < 1) ? 1 : 0;
+		}
+
+		if (m_loss == LOGLOSS) {
+			// log loss
+			if (z < 0) {
+				return 1.0 / (Math.exp(z) + 1.0);
+			} else {
+				double t = Math.exp(-z);
+				return t / (t + 1);
+			}
+		}
+
+		// squared loss
+		return z;
+	}
+
+	protected static double dotProd(Instance inst1, DoubleVector weights, int classIndex) {
+		double result = 0;
+
+		int n1 = inst1.numValues();
+		int n2 = weights.numValues();
+
+		for (int p1 = 0, p2 = 0; p1 < n1 && p2 < n2;) {
+			int ind1 = inst1.index(p1);
+			int ind2 = p2;
+			if (ind1 == ind2) {
+				if (ind1 != classIndex && !inst1.isMissingSparse(p1)) {
+					result += inst1.valueSparse(p1) * weights.getValue(p2);
+				}
+				p1++;
+				p2++;
+			} else if (ind1 > ind2) {
+				p2++;
+			} else {
+				p1++;
+			}
+		}
+		return (result);
+	}
+
+	@Override
+	public void resetLearningImpl() {
+		reset();
+		setLambda(this.lambdaRegularizationOption.getValue());
+		setLearningRate(this.learningRateOption.getValue());
+		setLossFunction(this.lossFunctionOption.getChosenIndex());
+	}
+
+	/**
+	 * Trains the classifier with the given instance.
+	 *
+	 * @param instance the new training instance to include in the model
+	 */
+	@Override
+	public void trainOnInstanceImpl(Instance instance) {
+
+		if (m_weights == null) {
+			m_weights = new DoubleVector();
+			m_bias = 0.0;
+		}
+
+		if (!instance.classIsMissing()) {
+
+			double wx = dotProd(instance, m_weights, instance.classIndex());
+
+			double y;
+			double z;
+			if (instance.classAttribute().isNominal()) {
+				y = (instance.classValue() == 0) ? -1 : 1;
+				z = y * (wx + m_bias);
+			} else {
+				y = instance.classValue();
+				z = y - (wx + m_bias);
+				y = 1;
+			}
+
+			// Compute multiplier for weight decay
+			double multiplier = 1.0;
+			if (m_numInstances == 0) {
+				multiplier = 1.0 - (m_learningRate * m_lambda) / m_t;
+			} else {
+				multiplier = 1.0 - (m_learningRate * m_lambda) / m_numInstances;
+			}
+			for (int i = 0; i < m_weights.numValues(); i++) {
+				m_weights.setValue(i, m_weights.getValue(i) * multiplier);
+			}
+
+			// Only need to do the following if the loss is non-zero
+			if (m_loss != HINGE || (z < 1)) {
+
+				// Compute Factor for updates
+				double factor = m_learningRate * y * dloss(z);
+
+				// Update coefficients for attributes
+				int n1 = instance.numValues();
+				for (int p1 = 0; p1 < n1; p1++) {
+					int indS = instance.index(p1);
+					if (indS != instance.classIndex() && !instance.isMissingSparse(p1)) {
+						m_weights.addToValue(indS, factor * instance.valueSparse(p1));
+					}
+				}
+
+				// update the bias
+				m_bias += factor;
+			}
+			m_t++;
+		}
+	}
+
+	/**
+	 * Calculates the class membership probabilities for the given test instance.
+	 *
+	 * @param instance the instance to be classified
+	 * @return predicted class probability distribution
+	 */
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+
+		if (m_weights == null) {
+			return new ClassificationPrediction();
+		}
+		double[] result = (inst.classAttribute().isNominal()) ? new double[2] : new double[1];
+
+		double wx = dotProd(inst, m_weights, inst.classIndex());// * m_wScale;
+		double z = (wx + m_bias);
+
+		if (inst.classAttribute().isNumeric()) {
+			// TODO This should not be happening here!
+			result[0] = z;
+			return new RegressionPrediction(result[0]);
+		}
+
+		if (z <= 0) {
+			// z = 0;
+			if (m_loss == LOGLOSS) {
+				result[0] = 1.0 / (1.0 + Math.exp(z));
+				result[1] = 1.0 - result[0];
+			} else {
+				result[0] = 1;
+			}
+		} else {
+			if (m_loss == LOGLOSS) {
+				result[1] = 1.0 / (1.0 + Math.exp(-z));
+				result[0] = 1.0 - result[1];
+			} else {
+				result[1] = 1;
+			}
+		}
+		return new ClassificationPrediction(result);
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder result, int indent) {
+		StringUtils.appendIndented(result, indent, toString());
+		StringUtils.appendNewline(result);
+	}
+
+	protected String getModelName() {
+		return "SGD";
+	}
+
+	/**
+	 * Prints out the classifier.
+	 *
+	 * @return a description of the classifier as a string
+	 */
+	@Override
+	public String toString() {
+		if (m_weights == null) {
+			return getModelName() + ": No model built yet.\n";
+		}
+		StringBuffer buff = new StringBuffer();
+		buff.append("Loss function: ");
+		if (m_loss == HINGE) {
+			buff.append("Hinge loss (SVM)\n\n");
+		} else if (m_loss == LOGLOSS) {
+			buff.append("Log loss (logistic regression)\n\n");
+		} else {
+			buff.append("Squared loss (linear regression)\n\n");
+		}
+
+		// buff.append(m_data.classAttribute().name() + " = \n\n");
+		int printed = 0;
+
+		for (int i = 0; i < m_weights.numValues(); i++) {
+			// if (i != m_data.classIndex()) {
+			if (printed > 0) {
+				buff.append(" + ");
+			} else {
+				buff.append("   ");
+			}
+
+			buff.append(Utils.doubleToString(m_weights.getValue(i), 12, 4) + " "
+			// + m_data.attribute(i).name()
+					+ "\n");
+
+			printed++;
+			// }
+		}
+
+		if (m_bias > 0) {
+			buff.append(" + " + Utils.doubleToString(m_bias, 12, 4));
+		} else {
+			buff.append(" - " + Utils.doubleToString(-m_bias, 12, 4));
+		}
+
+		return buff.toString();
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return null;
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/functions/SGDMultiClass.java b/moa/src/main/java/moa/learners/predictors/functions/SGDMultiClass.java
new file mode 100644
index 000000000..5c57798be
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/functions/SGDMultiClass.java
@@ -0,0 +1,402 @@
+/*
+ *    SGDMultiClass.java
+ *    Copyright (C) 2009 University of Waikato, Hamilton, New Zealand
+ *    @author Eibe Frank (eibe{[at]}cs{[dot]}waikato{[dot]}ac{[dot]}nz)
+ *    @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/*
+ *    SGDMultiClass.java
+ *    Copyright (C) 2009 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package moa.learners.predictors.functions;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+import com.yahoo.labs.samoa.instances.predictions.RegressionPrediction;
+
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.StringUtils;
+import moa.core.Utils;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.Regressor;
+
+/**
+ * <!-- globalinfo-start --> Implements stochastic gradient descent for learning
+ * various linear models (binary class SVM, binary class logistic regression and
+ * linear regression).
+ * <p/>
+ * <!-- globalinfo-end -->
+ *
+ */
+public class SGDMultiClass extends AbstractClassifier implements Classifier, Regressor {
+
+	/** For serialization */
+	private static final long serialVersionUID = -3732968666673530290L;
+
+	@Override
+	public String getPurposeString() {
+		return "AStochastic gradient descent for learning various linear models (binary class SVM, binary class logistic regression and linear regression).";
+	}
+
+	/** The regularization parameter */
+	protected double m_lambda = 0.0001;
+
+	public FloatOption lambdaRegularizationOption = new FloatOption("lambdaRegularization", 'l',
+			"Lambda regularization parameter .", 0.0001, 0.00, Integer.MAX_VALUE);
+
+	/** The learning rate */
+	protected double m_learningRate = 0.01;
+
+	public FloatOption learningRateOption = new FloatOption("learningRate", 'r', "Learning rate parameter.", 0.0001,
+			0.00, Integer.MAX_VALUE);
+
+	/** Stores the weights (+ bias in the last element) */
+	protected DoubleVector[] m_weights;
+
+	protected double[] m_bias;
+
+	/** Holds the current iteration number */
+	protected double m_t;
+
+	/** The number of training instances */
+	protected double m_numInstances;
+
+	protected static final int HINGE = 0;
+
+	protected static final int LOGLOSS = 1;
+
+	protected static final int SQUAREDLOSS = 2;
+
+	/** The current loss function to minimize */
+	protected int m_loss = HINGE;
+
+	public MultiChoiceOption lossFunctionOption = new MultiChoiceOption("lossFunction", 'o',
+			"The loss function to use.", new String[] { "HINGE", "LOGLOSS", "SQUAREDLOSS" },
+			new String[] { "Hinge loss (SVM)", "Log loss (logistic regression)", "Squared loss (regression)" }, 0);
+
+	/**
+	 * Set the value of lambda to use
+	 *
+	 * @param lambda the value of lambda to use
+	 */
+	public void setLambda(double lambda) {
+		m_lambda = lambda;
+	}
+
+	/**
+	 * Get the current value of lambda
+	 *
+	 * @return the current value of lambda
+	 */
+	public double getLambda() {
+		return m_lambda;
+	}
+
+	/**
+	 * Set the loss function to use.
+	 *
+	 * @param function the loss function to use.
+	 */
+	public void setLossFunction(int function) {
+		m_loss = function;
+	}
+
+	/**
+	 * Get the current loss function.
+	 *
+	 * @return the current loss function.
+	 */
+	public int getLossFunction() {
+		return m_loss;
+	}
+
+	/**
+	 * Set the learning rate.
+	 *
+	 * @param lr the learning rate to use.
+	 */
+	public void setLearningRate(double lr) {
+		m_learningRate = lr;
+	}
+
+	/**
+	 * Get the learning rate.
+	 *
+	 * @return the learning rate
+	 */
+	public double getLearningRate() {
+		return m_learningRate;
+	}
+
+	/**
+	 * Reset the classifier.
+	 */
+	public void reset() {
+		m_t = 1;
+		m_weights = null;
+		m_bias = null; // 0.0;
+	}
+
+	protected double dloss(double z) {
+		if (m_loss == HINGE) {
+			return (z < 1) ? 1 : 0;
+		}
+
+		if (m_loss == LOGLOSS) {
+			// log loss
+			if (z < 0) {
+				return 1.0 / (Math.exp(z) + 1.0);
+			} else {
+				double t = Math.exp(-z);
+				return t / (t + 1);
+			}
+		}
+
+		// squared loss
+		return z;
+	}
+
+	protected static double dotProd(Instance inst1, DoubleVector weights, int classIndex) {
+		double result = 0;
+
+		int n1 = inst1.numValues();
+		int n2 = weights.numValues();
+
+		for (int p1 = 0, p2 = 0; p1 < n1 && p2 < n2;) {
+			int ind1 = inst1.index(p1);
+			int ind2 = p2;
+			if (ind1 == ind2) {
+				if (ind1 != classIndex && !inst1.isMissingSparse(p1)) {
+					result += inst1.valueSparse(p1) * weights.getValue(p2);
+				}
+				p1++;
+				p2++;
+			} else if (ind1 > ind2) {
+				p2++;
+			} else {
+				p1++;
+			}
+		}
+		return (result);
+	}
+
+	@Override
+	public void resetLearningImpl() {
+		reset();
+		setLambda(this.lambdaRegularizationOption.getValue());
+		setLearningRate(this.learningRateOption.getValue());
+		setLossFunction(this.lossFunctionOption.getChosenIndex());
+	}
+
+	/**
+	 * Trains the classifier with the given instance.
+	 *
+	 * @param instance the new training instance to include in the model
+	 */
+	@Override
+	public void trainOnInstanceImpl(Instance instance) {
+
+		if (m_weights == null) {
+			int length;
+			if (instance.classAttribute().isNominal()) {
+				length = instance.numClasses();
+			} else {
+				length = 1;
+			}
+			m_weights = new DoubleVector[length];
+			m_bias = new double[length];
+			for (int i = 0; i < m_weights.length; i++) {
+				m_weights[i] = new DoubleVector();
+				m_bias[i] = 0.0;
+			}
+		}
+		for (int i = 0; i < m_weights.length; i++) {
+			this.trainOnInstanceImpl(instance, i);
+		}
+		m_t++;
+	}
+
+	public void trainOnInstanceImpl(Instance instance, int classLabel) {
+		if (!instance.classIsMissing()) {
+
+			double wx = dotProd(instance, m_weights[classLabel], instance.classIndex());
+
+			double y;
+			double z;
+			if (instance.classAttribute().isNominal()) {
+				y = (instance.classValue() != classLabel) ? -1 : 1;
+				z = y * (wx + m_bias[classLabel]);
+			} else {
+				y = instance.classValue();
+				z = y - (wx + m_bias[classLabel]);
+				y = 1;
+			}
+
+			// Compute multiplier for weight decay
+			double multiplier = 1.0;
+			if (m_numInstances == 0) {
+				multiplier = 1.0 - (m_learningRate * m_lambda) / m_t;
+			} else {
+				multiplier = 1.0 - (m_learningRate * m_lambda) / m_numInstances;
+			}
+			for (int i = 0; i < m_weights[classLabel].numValues(); i++) {
+				m_weights[classLabel].setValue(i, m_weights[classLabel].getValue(i) * multiplier);
+			}
+
+			// Only need to do the following if the loss is non-zero
+			if (m_loss != HINGE || (z < 1)) {
+
+				// Compute Factor for updates
+				double factor = m_learningRate * y * dloss(z);
+
+				// Update coefficients for attributes
+				int n1 = instance.numValues();
+				for (int p1 = 0; p1 < n1; p1++) {
+					int indS = instance.index(p1);
+					if (indS != instance.classIndex() && !instance.isMissingSparse(p1)) {
+						m_weights[classLabel].addToValue(indS, factor * instance.valueSparse(p1));
+					}
+				}
+
+				// update the bias
+				m_bias[classLabel] += factor;
+			}
+
+		}
+	}
+
+	/**
+	 * Calculates the class membership probabilities for the given test instance.
+	 *
+	 * @param instance the instance to be classified
+	 * @return predicted class probability distribution
+	 */
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+
+		if (m_weights == null) {
+			return new ClassificationPrediction();
+		}
+		double[] result = (inst.classAttribute().isNominal()) ? new double[inst.numClasses()] : new double[1];
+
+		if (inst.classAttribute().isNumeric()) {
+			// TODO This should not be happening here!
+			double wx = dotProd(inst, m_weights[0], inst.classIndex());// * m_wScale;
+			double z = (wx + m_bias[0]);
+			result[0] = z;
+			return new RegressionPrediction(result[0]);
+		}
+
+		for (int i = 0; i < m_weights.length; i++) {
+			double wx = dotProd(inst, m_weights[i], inst.classIndex());// * m_wScale;
+			double z = (wx + m_bias[i]);
+			if (z <= 0) {
+				// z = 0;
+				if (m_loss == LOGLOSS) {
+					// result[0] = 1.0 / (1.0 + Math.exp(z));
+					// result[1] = 1.0 - result[0];
+					result[i] = 1.0 - 1.0 / (1.0 + Math.exp(z));
+				} else {
+					// result[0] = 1;
+					result[i] = 0;
+				}
+			} else {
+				if (m_loss == LOGLOSS) {
+					// result[1] = 1.0 / (1.0 + Math.exp(-z));
+					// result[0] = 1.0 - result[1];
+					result[i] = 1.0 / (1.0 + Math.exp(-z));
+				} else {
+					// result[1] = 1;
+					result[i] = 1;
+				}
+			}
+		}
+		return new ClassificationPrediction(result);
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder result, int indent) {
+		StringUtils.appendIndented(result, indent, toString());
+		StringUtils.appendNewline(result);
+	}
+
+	/**
+	 * Prints out the classifier.
+	 *
+	 * @return a description of the classifier as a string
+	 */
+	@Override
+	public String toString() {
+		if (m_weights == null) {
+			return "SGD: No model built yet.\n";
+		}
+		StringBuffer buff = new StringBuffer();
+		buff.append("Loss function: ");
+		if (m_loss == HINGE) {
+			buff.append("Hinge loss (SVM)\n\n");
+		} else if (m_loss == LOGLOSS) {
+			buff.append("Log loss (logistic regression)\n\n");
+		} else {
+			buff.append("Squared loss (linear regression)\n\n");
+		}
+
+		// buff.append(m_data.classAttribute().name() + " = \n\n");
+		int printed = 0;
+
+		for (int i = 0; i < m_weights[0].numValues(); i++) {
+			// if (i != m_data.classIndex()) {
+			if (printed > 0) {
+				buff.append(" + ");
+			} else {
+				buff.append("   ");
+			}
+
+			buff.append(Utils.doubleToString(m_weights[0].getValue(i), 12, 4) + " "
+			// + m_data.attribute(i).name()
+					+ "\n");
+
+			printed++;
+			// }
+		}
+
+		if (m_bias[0] > 0) {
+			buff.append(" + " + Utils.doubleToString(m_bias[0], 12, 4));
+		} else {
+			buff.append(" - " + Utils.doubleToString(-m_bias[0], 12, 4));
+		}
+
+		return buff.toString();
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return null;
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/functions/SPegasos.java b/moa/src/main/java/moa/learners/predictors/functions/SPegasos.java
new file mode 100644
index 000000000..48255fdb0
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/functions/SPegasos.java
@@ -0,0 +1,354 @@
+/*
+ *    SPegasos.java
+ *    Copyright (C) 2009 University of Waikato, Hamilton, New Zealand
+ *    @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/*
+ *    SPegasos.java
+ *    Copyright (C) 2009 University of Waikato, Hamilton, New Zealand
+ *
+ */
+package moa.learners.predictors.functions;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Measurement;
+import moa.core.StringUtils;
+import moa.core.Utils;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+
+/**
+ * <!-- globalinfo-start --> Implements the stochastic variant of the Pegasos
+ * (Primal Estimated sub-GrAdient SOlver for SVM) method of Shalev-Shwartz et
+ * al. (2007). For more information, see<br/>
+ * <br/>
+ * S. Shalev-Shwartz, Y. Singer, N. Srebro: Pegasos: Primal Estimated
+ * sub-GrAdient SOlver for SVM. In: 24th International Conference on
+ * MachineLearning, 807-814, 2007.
+ * <p/>
+ * <!-- globalinfo-end --> * <!-- technical-bibtex-start --> BibTeX:
+ * 
+ * <pre>
+ * &#64;inproceedings{Shalev-Shwartz2007,
+ *    author = {S. Shalev-Shwartz and Y. Singer and N. Srebro},
+ *    booktitle = {24th International Conference on MachineLearning},
+ *    pages = {807-814},
+ *    title = {Pegasos: Primal Estimated sub-GrAdient SOlver for SVM},
+ *    year = {2007}
+ * }
+ * </pre>
+ * <p/>
+ * <!-- technical-bibtex-end -->
+ *
+ */
+public class SPegasos extends AbstractClassifier implements Classifier {
+
+	/**
+	 * For serialization
+	 */
+	private static final long serialVersionUID = -3732968666673530290L;
+
+	@Override
+	public String getPurposeString() {
+		return "Stochastic variant of the Pegasos (Primal Estimated sub-GrAdient SOlver for SVM) method of Shalev-Shwartz et al. (2007).";
+	}
+
+	/**
+	 * The regularization parameter
+	 */
+	protected double m_lambda = 0.0001;
+
+	public FloatOption lambdaRegularizationOption = new FloatOption("lambdaRegularization", 'l',
+			"Lambda regularization parameter .", 0.0001, 0.00, Integer.MAX_VALUE);
+
+	protected static final int HINGE = 0;
+
+	protected static final int LOGLOSS = 1;
+
+	/**
+	 * The current loss function to minimize
+	 */
+	protected int m_loss = HINGE;
+
+	public MultiChoiceOption lossFunctionOption = new MultiChoiceOption("lossFunction", 'o',
+			"The loss function to use.", new String[] { "HINGE", "LOGLOSS" },
+			new String[] { "Hinge loss (SVM)", "Log loss (logistic regression)" }, 0);
+
+	/**
+	 * Stores the weights (+ bias in the last element)
+	 */
+	protected double[] m_weights;
+
+	/**
+	 * Holds the current iteration number
+	 */
+	protected double m_t;
+
+	/**
+	 * Set the value of lambda to use
+	 *
+	 * @param lambda the value of lambda to use
+	 */
+	public void setLambda(double lambda) {
+		m_lambda = lambda;
+	}
+
+	/**
+	 * Get the current value of lambda
+	 *
+	 * @return the current value of lambda
+	 */
+	public double getLambda() {
+		return m_lambda;
+	}
+
+	/**
+	 * Set the loss function to use.
+	 *
+	 * @param function the loss function to use.
+	 */
+	public void setLossFunction(int function) {
+		m_loss = function;
+	}
+
+	/**
+	 * Get the current loss function.
+	 *
+	 * @return the current loss function.
+	 */
+	public int getLossFunction() {
+		return m_loss;
+	}
+
+	/**
+	 * Reset the classifier.
+	 */
+	public void reset() {
+		m_t = 2;
+		m_weights = null;
+	}
+
+	protected static double dotProd(Instance inst1, double[] weights, int classIndex) {
+		double result = 0;
+
+		int n1 = inst1.numValues();
+		int n2 = weights.length - 1;
+
+		for (int p1 = 0, p2 = 0; p1 < n1 && p2 < n2;) {
+			int ind1 = inst1.index(p1);
+			int ind2 = p2;
+			if (ind1 == ind2) {
+				if (ind1 != classIndex && !inst1.isMissingSparse(p1)) {
+					result += inst1.valueSparse(p1) * weights[p2];
+				}
+				p1++;
+				p2++;
+			} else if (ind1 > ind2) {
+				p2++;
+			} else {
+				p1++;
+			}
+		}
+		return (result);
+	}
+
+	protected double dloss(double z) {
+		if (m_loss == HINGE) {
+			return (z < 1) ? 1 : 0;
+		}
+
+		// log loss
+		if (z < 0) {
+			return 1.0 / (Math.exp(z) + 1.0);
+		} else {
+			double t = Math.exp(-z);
+			return t / (t + 1);
+		}
+	}
+
+	@Override
+	public void resetLearningImpl() {
+		reset();
+		setLambda(this.lambdaRegularizationOption.getValue());
+		setLossFunction(this.lossFunctionOption.getChosenIndex());
+	}
+
+	/**
+	 * Trains the classifier with the given instance.
+	 *
+	 * @param instance the new training instance to include in the model
+	 */
+	@Override
+	public void trainOnInstanceImpl(Instance instance) {
+
+		if (m_weights == null) {
+			m_weights = new double[instance.numAttributes() + 1];
+		}
+		if (!instance.classIsMissing()) {
+
+			double learningRate = 1.0 / (m_lambda * m_t);
+			// double scale = 1.0 - learningRate * m_lambda;
+			double scale = 1.0 - 1.0 / m_t;
+			double y = (instance.classValue() == 0) ? -1 : 1;
+			double wx = dotProd(instance, m_weights, instance.classIndex());
+			double z = y * (wx + m_weights[m_weights.length - 1]);
+
+			for (int j = 0; j < m_weights.length - 1; j++) {
+				if (j != instance.classIndex()) {
+					m_weights[j] *= scale;
+				}
+			}
+
+			if (m_loss == LOGLOSS || (z < 1)) {
+				double loss = dloss(z);
+				int n1 = instance.numValues();
+				for (int p1 = 0; p1 < n1; p1++) {
+					int indS = instance.index(p1);
+					if (indS != instance.classIndex() && !instance.isMissingSparse(p1)) {
+						double m = learningRate * loss * (instance.valueSparse(p1) * y);
+						m_weights[indS] += m;
+					}
+				}
+
+				// update the bias
+				m_weights[m_weights.length - 1] += learningRate * loss * y;
+			}
+
+			double norm = 0;
+			for (int k = 0; k < m_weights.length - 1; k++) {
+				if (k != instance.classIndex()) {
+					norm += (m_weights[k] * m_weights[k]);
+				}
+			}
+
+			double scale2 = Math.min(1.0, (1.0 / (m_lambda * norm)));
+			if (scale2 < 1.0) {
+				scale2 = Math.sqrt(scale2);
+				for (int j = 0; j < m_weights.length - 1; j++) {
+					if (j != instance.classIndex()) {
+						m_weights[j] *= scale2;
+					}
+				}
+			}
+			m_t++;
+		}
+	}
+
+	/**
+	 * Calculates the class membership probabilities for the given test instance.
+	 *
+	 * @param instance the instance to be classified
+	 * @return predicted class probability distribution
+	 */
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+
+		if (m_weights == null) {
+			return new ClassificationPrediction();
+		}
+
+		double[] result = new double[2];
+
+		double wx = dotProd(inst, m_weights, inst.classIndex());// * m_wScale;
+		double z = (wx + m_weights[m_weights.length - 1]);
+		// System.out.print("" + z + ": ");
+		// System.out.println(1.0 / (1.0 + Math.exp(-z)));
+		if (z <= 0) {
+			// z = 0;
+			if (m_loss == LOGLOSS) {
+				result[0] = 1.0 / (1.0 + Math.exp(z));
+				result[1] = 1.0 - result[0];
+			} else {
+				result[0] = 1;
+			}
+		} else {
+			if (m_loss == LOGLOSS) {
+				result[1] = 1.0 / (1.0 + Math.exp(-z));
+				result[0] = 1.0 - result[1];
+			} else {
+				result[1] = 1;
+			}
+		}
+		return new ClassificationPrediction(result);
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder result, int indent) {
+		StringUtils.appendIndented(result, indent, toString());
+		StringUtils.appendNewline(result);
+	}
+
+	/**
+	 * Prints out the classifier.
+	 *
+	 * @return a description of the classifier as a string
+	 */
+	@Override
+	public String toString() {
+		if (m_weights == null) {
+			return "SPegasos: No model built yet.\n";
+		}
+		StringBuffer buff = new StringBuffer();
+		buff.append("Loss function: ");
+		if (m_loss == HINGE) {
+			buff.append("Hinge loss (SVM)\n\n");
+		} else {
+			buff.append("Log loss (logistic regression)\n\n");
+		}
+		int printed = 0;
+
+		for (int i = 0; i < m_weights.length - 1; i++) {
+			// if (i != m_data.classIndex()) {
+			if (printed > 0) {
+				buff.append(" + ");
+			} else {
+				buff.append("   ");
+			}
+
+			buff.append(Utils.doubleToString(m_weights[i], 12, 4) + " "
+			// + m_data.attribute(i).name()
+					+ "\n");
+
+			printed++;
+		}
+		// }
+
+		if (m_weights[m_weights.length - 1] > 0) {
+			buff.append(" + " + Utils.doubleToString(m_weights[m_weights.length - 1], 12, 4));
+		} else {
+			buff.append(" - " + Utils.doubleToString(-m_weights[m_weights.length - 1], 12, 4));
+		}
+
+		return buff.toString();
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return null;
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/lazy/SAMkNN.java b/moa/src/main/java/moa/learners/predictors/lazy/SAMkNN.java
similarity index 65%
rename from moa/src/main/java/moa/classifiers/lazy/SAMkNN.java
rename to moa/src/main/java/moa/learners/predictors/lazy/SAMkNN.java
index 0810f3ef5..17b54256f 100644
--- a/moa/src/main/java/moa/classifiers/lazy/SAMkNN.java
+++ b/moa/src/main/java/moa/learners/predictors/lazy/SAMkNN.java
@@ -12,9 +12,9 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
+ *
  */
-package moa.classifiers.lazy;
+package moa.learners.predictors.lazy;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -26,60 +26,66 @@
 import java.util.SortedSet;
 import java.util.TreeSet;
 
-import com.yahoo.labs.samoa.instances.InstanceImpl;
-import moa.capabilities.CapabilitiesHandler;
-import moa.capabilities.Capability;
-import moa.capabilities.ImmutableCapabilities;
-import moa.classifiers.AbstractClassifier;
-import moa.core.Measurement;
-
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstanceImpl;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-import moa.clusterers.kmeanspm.CoresetKMeans;
+import moa.capabilities.CapabilitiesHandler;
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
+import moa.core.Measurement;
+import moa.learners.clusterers.kmeanspm.CoresetKMeans;
+import moa.learners.predictors.AbstractClassifier;
+
 /**
- * Self Adjusting Memory (SAM) coupled with the k Nearest Neighbor classifier (kNN) .<p>
+ * Self Adjusting Memory (SAM) coupled with the k Nearest Neighbor classifier
+ * (kNN) .
+ * <p>
  *
- * Valid options are:<p>
+ * Valid options are:
+ * <p>
  *
- * -k number of neighbours <br> -w max instances <br> -m minimum number of instances in the STM <br> -p LTM size relative to max instances <br> -r Recalculation of the STM error <br>
+ * -k number of neighbours <br>
+ * -w max instances <br>
+ * -m minimum number of instances in the STM <br>
+ * -p LTM size relative to max instances <br>
+ * -r Recalculation of the STM error <br>
  *
- * @author Viktor Losing (vlosing@techfak.uni-bielefeld.de)
- * Paper:
- * "KNN Classifier with Self Adjusting Memory for Heterogeneous Concept Drift"
- *  Viktor Losing, Barbara Hammer and Heiko Wersing
- * http://ieeexplore.ieee.org/document/7837853
- * PDF can be found at https://pub.uni-bielefeld.de/download/2907622/2907623
- * BibTex:
- * "@INPROCEEDINGS{7837853,
- * author={V. Losing and B. Hammer and H. Wersing},
- * booktitle={2016 IEEE 16th International Conference on Data Mining (ICDM)},
- * title={KNN Classifier with Self Adjusting Memory for Heterogeneous Concept Drift},
- * year={2016},
- * pages={291-300},
- * keywords={data mining;optimisation;pattern classification;Big Data;Internet of Things;KNN classifier;SAM-kNN robustness;data mining;k nearest neighbor algorithm;metaparameter optimization;nonstationary data streams;performance evaluation;self adjusting memory model;Adaptation models;Benchmark testing;Biological system modeling;Data mining;Heuristic algorithms;Prediction algorithms;Predictive models;Data streams;concept drift;data mining;kNN},
- * doi={10.1109/ICDM.2016.0040},
- * month={Dec}
- * }"
+ * @author Viktor Losing (vlosing@techfak.uni-bielefeld.de) Paper: "KNN
+ *         Classifier with Self Adjusting Memory for Heterogeneous Concept
+ *         Drift" Viktor Losing, Barbara Hammer and Heiko Wersing
+ *         http://ieeexplore.ieee.org/document/7837853 PDF can be found at
+ *         https://pub.uni-bielefeld.de/download/2907622/2907623 BibTex:
+ *         "@INPROCEEDINGS{7837853, author={V. Losing and B. Hammer and H.
+ *         Wersing}, booktitle={2016 IEEE 16th International Conference on Data
+ *         Mining (ICDM)}, title={KNN Classifier with Self Adjusting Memory for
+ *         Heterogeneous Concept Drift}, year={2016}, pages={291-300},
+ *         keywords={data mining;optimisation;pattern classification;Big
+ *         Data;Internet of Things;KNN classifier;SAM-kNN robustness;data
+ *         mining;k nearest neighbor algorithm;metaparameter
+ *         optimization;nonstationary data streams;performance evaluation;self
+ *         adjusting memory model;Adaptation models;Benchmark testing;Biological
+ *         system modeling;Data mining;Heuristic algorithms;Prediction
+ *         algorithms;Predictive models;Data streams;concept drift;data
+ *         mining;kNN}, doi={10.1109/ICDM.2016.0040}, month={Dec} }"
  */
 public class SAMkNN extends AbstractClassifier implements CapabilitiesHandler {
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-	public IntOption kOption = new IntOption( "k", 'k', "The number of neighbors", 5, 1, Integer.MAX_VALUE);
+	public IntOption kOption = new IntOption("k", 'k', "The number of neighbors", 5, 1, Integer.MAX_VALUE);
 
-	public IntOption limitOption = new IntOption( "limit", 'w', "The maximum number of instances to store", 5000, 1, Integer.MAX_VALUE);
-	public IntOption minSTMSizeOption = new IntOption( "minSTMSize", 'm', "The minimum number of instances in the STM", 50, 1, Integer.MAX_VALUE);
+	public IntOption limitOption = new IntOption("limit", 'w', "The maximum number of instances to store", 5000, 1,
+			Integer.MAX_VALUE);
+	public IntOption minSTMSizeOption = new IntOption("minSTMSize", 'm', "The minimum number of instances in the STM",
+			50, 1, Integer.MAX_VALUE);
 
-	public FloatOption relativeLTMSizeOption = new FloatOption(
-			"relativeLTMSize",
-			'p',
-			"The allowed LTM size relative to the total limit.",
-			0.4, 0.0, 1.0);
+	public FloatOption relativeLTMSizeOption = new FloatOption("relativeLTMSize", 'p',
+			"The allowed LTM size relative to the total limit.", 0.4, 0.0, 1.0);
 
 	public FlagOption recalculateSTMErrorOption = new FlagOption("recalculateError", 'r',
 			"Recalculates the error rate of the STM for size adaption (Costly operation). Otherwise, an approximation is used.");
@@ -98,18 +104,19 @@ public String getPurposeString() {
 	private List<Integer> ltmHistory;
 	private List<Integer> cmHistory;
 	private double[][] distanceMatrixSTM;
-	//private int trainStepCount;
+	// private int trainStepCount;
 	private Map<Integer, List<Integer>> predictionHistories;
 	private Random random;
 
-	protected void init(){
-		this.maxLTMSize = (int)(relativeLTMSizeOption.getValue() * limitOption.getValue());
+	protected void init() {
+		this.maxLTMSize = (int) (relativeLTMSizeOption.getValue() * limitOption.getValue());
 		this.maxSTMSize = limitOption.getValue() - this.maxLTMSize;
 		this.stmHistory = new ArrayList<>();
 		this.ltmHistory = new ArrayList<>();
 		this.cmHistory = new ArrayList<>();
-		//store calculated STM distances in a matrix to avoid recalculation, are reused in the STM adaption phase
-		this.distanceMatrixSTM = new double[limitOption.getValue()+1][limitOption.getValue()+1];
+		// store calculated STM distances in a matrix to avoid recalculation, are reused
+		// in the STM adaption phase
+		this.distanceMatrixSTM = new double[limitOption.getValue() + 1][limitOption.getValue() + 1];
 		this.predictionHistories = new HashMap<>();
 		this.random = new Random();
 
@@ -120,10 +127,10 @@ public void setModelContext(InstancesHeader context) {
 		try {
 			this.stm = new InstancesHeader(context, 0);
 			this.stm.setClassIndex(context.classIndex());
-			this.ltm = new InstancesHeader(context, 0); 
+			this.ltm = new InstancesHeader(context, 0);
 			this.ltm.setClassIndex(context.classIndex());
 			this.init();
-		} catch(Exception e) {
+		} catch (Exception e) {
 			System.err.println("Error: no Model Context available.");
 			e.printStackTrace();
 			System.exit(1);
@@ -143,15 +150,15 @@ public void resetLearningImpl() {
 
 	@Override
 	public void trainOnInstanceImpl(Instance inst) {
-		//this.trainStepCount++;
+		// this.trainStepCount++;
 		if (inst.classValue() > maxClassValue)
-			maxClassValue = (int)inst.classValue();
+			maxClassValue = (int) inst.classValue();
 		this.stm.add(inst);
 		memorySizeCheck();
 		clean(this.stm, this.ltm, true);
 		double distancesSTM[] = this.get1ToNDistances(inst, this.stm);
-		for (int i =0; i < this.stm.numInstances();i++){
-			this.distanceMatrixSTM[this.stm.numInstances()-1][i] = distancesSTM[i];
+		for (int i = 0; i < this.stm.numInstances(); i++) {
+			this.distanceMatrixSTM[this.stm.numInstances() - 1][i] = distancesSTM[i];
 		}
 		int oldWindowSize = this.stm.numInstances();
 		int newWindowSize = this.getNewSTMSize(recalculateSTMErrorOption.isSet());
@@ -160,13 +167,13 @@ public void trainOnInstanceImpl(Instance inst) {
 			int diff = oldWindowSize - newWindowSize;
 			InstancesHeader discardedSTMInstances = new InstancesHeader(this.stm, 0);
 
-			for (int i = diff; i>0;i--){
+			for (int i = diff; i > 0; i--) {
 				discardedSTMInstances.add(this.stm.get(0).copy());
 				this.stm.delete(0);
 			}
-			for (int i = 0; i < this.stm.numInstances(); i++){
-				for (int j = 0; j < this.stm.numInstances(); j++){
-					this.distanceMatrixSTM[i][j] = this.distanceMatrixSTM[diff+i][diff+j];
+			for (int i = 0; i < this.stm.numInstances(); i++) {
+				for (int j = 0; j < this.stm.numInstances(); j++) {
+					this.distanceMatrixSTM[i][j] = this.distanceMatrixSTM[diff + i][diff + j];
 				}
 			}
 			for (int i = 0; i < diff; i++) {
@@ -176,12 +183,13 @@ public void trainOnInstanceImpl(Instance inst) {
 			}
 
 			this.clean(this.stm, discardedSTMInstances, false);
-			for (int i = 0; i < discardedSTMInstances.numInstances(); i++){
+			for (int i = 0; i < discardedSTMInstances.numInstances(); i++) {
 				this.ltm.add(discardedSTMInstances.get(i).copy());
 			}
 			memorySizeCheck();
 		}
 	}
+
 	/**
 	 * Predicts the label of a given sample by using the STM, LTM and the CM.
 	 */
@@ -198,7 +206,7 @@ public Prediction getPredictionForInstance(Instance inst) {
 		int predClassLTM = 0;
 		int predClassCM = 0;
 		try {
-			if (this.stm.numInstances()>0) {
+			if (this.stm.numInstances() > 0) {
 				distancesSTM = get1ToNDistances(inst, this.stm);
 				int nnIndicesSTM[] = nArgMin(Math.min(distancesSTM.length, this.kOption.getValue()), distancesSTM);
 				vSTM = getDistanceWeightedVotes(distancesSTM, nnIndicesSTM, this.stm);
@@ -210,26 +218,26 @@ public Prediction getPredictionForInstance(Instance inst) {
 					int nnIndicesLTM[] = nArgMin(Math.min(distancesLTM.length, this.kOption.getValue()), distancesLTM);
 					vLTM = getDistanceWeightedVotes(distancesLTM, nnIndicesLTM, this.ltm);
 					predClassLTM = this.getClassFromVotes(vLTM);
-				}else{
+				} else {
 					vLTM = new double[inst.numClasses()];
 				}
 				int correctSTM = historySum(this.stmHistory);
 				int correctLTM = historySum(this.ltmHistory);
 				int correctCM = historySum(this.cmHistory);
-				if(correctSTM>=correctLTM && correctSTM>=correctCM){
-					v=vSTM;
-				}else if(correctLTM>correctSTM && correctLTM>=correctCM){
-					v=vLTM;
-				}else{
-					v=vCM;
+				if (correctSTM >= correctLTM && correctSTM >= correctCM) {
+					v = vSTM;
+				} else if (correctLTM > correctSTM && correctLTM >= correctCM) {
+					v = vLTM;
+				} else {
+					v = vCM;
 				}
-			}else {
+			} else {
 				v = new double[inst.numClasses()];
 			}
-			this.stmHistory.add((predClassSTM==inst.classValue()) ? 1 : 0);
-			this.ltmHistory.add((predClassLTM==inst.classValue()) ? 1 : 0);
-			this.cmHistory.add((predClassCM==inst.classValue()) ? 1 : 0);
-		} catch(Exception e) {
+			this.stmHistory.add((predClassSTM == inst.classValue()) ? 1 : 0);
+			this.ltmHistory.add((predClassLTM == inst.classValue()) ? 1 : 0);
+			this.cmHistory.add((predClassCM == inst.classValue()) ? 1 : 0);
+		} catch (Exception e) {
 			return new ClassificationPrediction(new double[inst.numClasses()]);
 		}
 		return new ClassificationPrediction(v);
@@ -244,12 +252,12 @@ protected Measurement[] getModelMeasurementsImpl() {
 	public void getModelDescription(StringBuilder out, int indent) {
 	}
 
+	@Override
 	public boolean isRandomizable() {
 		return false;
 	}
 
-
-	private int historySum(List<Integer> history){
+	private int historySum(List<Integer> history) {
 		int sum = 0;
 		for (Integer e : history) {
 			sum += e;
@@ -257,29 +265,31 @@ private int historySum(List<Integer> history){
 		return sum;
 	}
 
-	private List<double[]> kMeans(List<double[]> points, int k){
-		List<double[]> centroids = CoresetKMeans
-				.generatekMeansPlusPlusCentroids(k,
-						points, this.random);
+	private List<double[]> kMeans(List<double[]> points, int k) {
+		List<double[]> centroids = CoresetKMeans.generatekMeansPlusPlusCentroids(k, points, this.random);
 		CoresetKMeans.kMeans(centroids, points);
 		return centroids;
 	}
+
 	/**
-	 * Performs classwise kMeans++ clustering for given samples with corresponding labels. The number of samples is halved per class.
+	 * Performs classwise kMeans++ clustering for given samples with corresponding
+	 * labels. The number of samples is halved per class.
 	 */
-	private void clusterDown(){
+	private void clusterDown() {
 		int classIndex = this.ltm.classIndex();
-		for (int c = 0; c <= this.maxClassValue; c++){
+		for (int c = 0; c <= this.maxClassValue; c++) {
 			List<double[]> classSamples = new ArrayList<>();
-			for (int i = this.ltm.numInstances()-1; i >-1 ; i--) {
+			for (int i = this.ltm.numInstances() - 1; i > -1; i--) {
 				if (this.ltm.get(i).classValue() == c) {
 					classSamples.add(this.ltm.get(i).toDoubleArray());
 					this.ltm.delete(i);
 				}
 			}
 			if (classSamples.size() > 0) {
-				//used kMeans++ implementation expects the weight of each sample at the first index,
-				// make sure that the first value gets the uniform weight 1, overwrite class value
+				// used kMeans++ implementation expects the weight of each sample at the first
+				// index,
+				// make sure that the first value gets the uniform weight 1, overwrite class
+				// value
 				for (double[] sample : classSamples) {
 					if (classIndex != 0) {
 						sample[classIndex] = sample[0];
@@ -292,9 +302,9 @@ private void clusterDown(){
 				for (double[] centroid : centroids) {
 
 					double[] attributes = new double[this.ltm.numAttributes()];
-					//returned centroids do not contain the weight anymore, but simply the data
+					// returned centroids do not contain the weight anymore, but simply the data
 					System.arraycopy(centroid, 0, attributes, 1, this.ltm.numAttributes() - 1);
-					//switch back if necessary
+					// switch back if necessary
 					if (classIndex != 0) {
 						attributes[0] = attributes[classIndex];
 					}
@@ -311,13 +321,13 @@ private void clusterDown(){
 	/**
 	 * Makes sure that the STM and LTM combined doe not surpass the maximum size.
 	 */
-	private void memorySizeCheck(){
-		if (this.stm.numInstances() + this.ltm.numInstances() > this.maxSTMSize + this.maxLTMSize){
-			if (this.ltm.numInstances() > this.maxLTMSize){
+	private void memorySizeCheck() {
+		if (this.stm.numInstances() + this.ltm.numInstances() > this.maxSTMSize + this.maxLTMSize) {
+			if (this.ltm.numInstances() > this.maxLTMSize) {
 				this.clusterDown();
-			}else{ //shift values from STM directly to LTM since STM is full
+			} else { // shift values from STM directly to LTM since STM is full
 				int numShifts = this.maxLTMSize - this.ltm.numInstances() + 1;
-				for (int i = 0; i < numShifts; i++){
+				for (int i = 0; i < numShifts; i++) {
 					this.ltm.add(this.stm.get(0).copy());
 					this.stm.delete(0);
 					this.stmHistory.remove(0);
@@ -326,16 +336,16 @@ private void memorySizeCheck(){
 				}
 				this.clusterDown();
 				this.predictionHistories.clear();
-				for (int i = 0; i < this.stm.numInstances(); i++){
-					for (int j = 0; j < this.stm.numInstances(); j++){
-						this.distanceMatrixSTM[i][j] = this.distanceMatrixSTM[numShifts+i][numShifts+j];
+				for (int i = 0; i < this.stm.numInstances(); i++) {
+					for (int j = 0; j < this.stm.numInstances(); j++) {
+						this.distanceMatrixSTM[i][j] = this.distanceMatrixSTM[numShifts + i][numShifts + j];
 					}
 				}
 			}
 		}
 	}
 
-	private void cleanSingle(InstancesHeader cleanAgainst, int cleanAgainstindex, InstancesHeader toClean){
+	private void cleanSingle(InstancesHeader cleanAgainst, int cleanAgainstindex, InstancesHeader toClean) {
 		InstancesHeader cleanAgainstTmp = cleanAgainst.getEmptyHeader();
 		cleanAgainstTmp.delete(cleanAgainstindex);
 		double distancesSTM[] = get1ToNDistances(cleanAgainst.get(cleanAgainstindex), cleanAgainstTmp);
@@ -344,17 +354,17 @@ private void cleanSingle(InstancesHeader cleanAgainst, int cleanAgainstindex, In
 		double distancesLTM[] = get1ToNDistances(cleanAgainst.get(cleanAgainstindex), toClean);
 		int nnIndicesLTM[] = nArgMin(Math.min(this.kOption.getValue(), distancesLTM.length), distancesLTM);
 		double distThreshold = 0;
-		for (int nnIdx: nnIndicesSTM){
-			if (cleanAgainstTmp.get(nnIdx).classValue() == cleanAgainst.get(cleanAgainstindex).classValue()){
-				if (distancesSTM[nnIdx] > distThreshold){
+		for (int nnIdx : nnIndicesSTM) {
+			if (cleanAgainstTmp.get(nnIdx).classValue() == cleanAgainst.get(cleanAgainstindex).classValue()) {
+				if (distancesSTM[nnIdx] > distThreshold) {
 					distThreshold = distancesSTM[nnIdx];
 				}
 			}
 		}
 		List<Integer> delIndices = new ArrayList<>();
-		for (int nnIdx: nnIndicesLTM){
+		for (int nnIdx : nnIndicesLTM) {
 			if (toClean.get(nnIdx).classValue() != cleanAgainst.get(cleanAgainstindex).classValue()) {
-				if (distancesLTM[nnIdx] <= distThreshold){
+				if (distancesLTM[nnIdx] <= distThreshold) {
 					delIndices.add(nnIdx);
 				}
 			}
@@ -363,39 +373,44 @@ private void cleanSingle(InstancesHeader cleanAgainst, int cleanAgainstindex, In
 		for (Integer idx : delIndices)
 			toClean.delete(idx);
 	}
+
 	/**
-	 * Removes distance-based all instances from the input samples that contradict those in the STM.
+	 * Removes distance-based all instances from the input samples that contradict
+	 * those in the STM.
 	 */
 	private void clean(InstancesHeader cleanAgainst, InstancesHeader toClean, boolean onlyLast) {
-		if (cleanAgainst.numInstances() > this.kOption.getValue() && toClean.numInstances() > 0){
-			if (onlyLast){
-				cleanSingle(cleanAgainst, (cleanAgainst.numInstances()-1), toClean);
-			}else{
-				for (int i=0; i < cleanAgainst.numInstances(); i++){
+		if (cleanAgainst.numInstances() > this.kOption.getValue() && toClean.numInstances() > 0) {
+			if (onlyLast) {
+				cleanSingle(cleanAgainst, (cleanAgainst.numInstances() - 1), toClean);
+			} else {
+				for (int i = 0; i < cleanAgainst.numInstances(); i++) {
 					cleanSingle(cleanAgainst, i, toClean);
 				}
 			}
 		}
 	}
+
 	/**
 	 * Returns the distance weighted votes.
 	 */
-	private double [] getDistanceWeightedVotes(double distances[], int[] nnIndices, InstancesHeader instances){
+	private double[] getDistanceWeightedVotes(double distances[], int[] nnIndices, InstancesHeader instances) {
 
-		double v[] = new double[this.maxClassValue +1];
+		double v[] = new double[this.maxClassValue + 1];
 		for (int nnIdx : nnIndices) {
-			v[(int)instances.instance(nnIdx).classValue()] += 1./Math.max(distances[nnIdx], 0.000000001);
+			v[(int) instances.instance(nnIdx).classValue()] += 1. / Math.max(distances[nnIdx], 0.000000001);
 		}
 		return v;
 	}
 
-	private double [] getDistanceWeightedVotesCM(double distances[], int[] nnIndices, InstancesHeader stm, InstancesHeader ltm){
-		double v[] = new double[this.maxClassValue +1];
+	private double[] getDistanceWeightedVotesCM(double distances[], int[] nnIndices, InstancesHeader stm,
+			InstancesHeader ltm) {
+		double v[] = new double[this.maxClassValue + 1];
 		for (int nnIdx : nnIndices) {
 			if (nnIdx < stm.numInstances()) {
 				v[(int) stm.instance(nnIdx).classValue()] += 1. / Math.max(distances[nnIdx], 0.000000001);
-			} else{
-				v[(int) ltm.instance((nnIdx-stm.numInstances())).classValue()] += 1. / Math.max(distances[nnIdx], 0.000000001);
+			} else {
+				v[(int) ltm.instance((nnIdx - stm.numInstances())).classValue()] += 1.
+						/ Math.max(distances[nnIdx], 0.000000001);
 			}
 		}
 		return v;
@@ -404,7 +419,8 @@ private void clean(InstancesHeader cleanAgainst, InstancesHeader toClean, boolea
 	/**
 	 * Returns the distance weighted votes for the combined memory (CM).
 	 */
-	private double [] getCMVotes(double distancesSTM[], InstancesHeader stm, double distancesLTM[], InstancesHeader ltm){
+	private double[] getCMVotes(double distancesSTM[], InstancesHeader stm, double distancesLTM[],
+			InstancesHeader ltm) {
 		double[] distancesCM = new double[distancesSTM.length + distancesLTM.length];
 		System.arraycopy(distancesSTM, 0, distancesCM, 0, distancesSTM.length);
 		System.arraycopy(distancesLTM, 0, distancesCM, distancesSTM.length, distancesLTM.length);
@@ -415,11 +431,11 @@ private void clean(InstancesHeader cleanAgainst, InstancesHeader toClean, boolea
 	/**
 	 * Returns the class with maximum vote.
 	 */
-	private int getClassFromVotes(double votes[]){
+	private int getClassFromVotes(double votes[]) {
 		double maxVote = -1;
 		int maxVoteClass = -1;
-		for (int i = 0; i < votes.length; i++){
-			if (votes[i] > maxVote){
+		for (int i = 0; i < votes.length; i++) {
+			if (votes[i] > maxVote) {
 				maxVote = votes[i];
 				maxVoteClass = i;
 			}
@@ -427,7 +443,7 @@ private int getClassFromVotes(double votes[]){
 		return maxVoteClass;
 	}
 
-	private int getLabelFct(double distances[], InstancesHeader instances, int startIdx, int endIdx){
+	private int getLabelFct(double distances[], InstancesHeader instances, int startIdx, int endIdx) {
 		int nnIndices[] = nArgMin(Math.min(this.kOption.getValue(), distances.length), distances, startIdx, endIdx);
 		double votes[] = getDistanceWeightedVotes(distances, nnIndices, instances);
 		return this.getClassFromVotes(votes);
@@ -436,23 +452,22 @@ private int getLabelFct(double distances[], InstancesHeader instances, int start
 	/**
 	 * Returns the Euclidean distance.
 	 */
-	private double getDistance(Instance sample, Instance sample2)
-	{
-		double sum=0;
-		for (int i=0; i<sample.numInputAttributes(); i++)
-		{
-			double diff = sample.valueInputAttribute(i)-sample2.valueInputAttribute(i);
-			sum += diff*diff;
+	private double getDistance(Instance sample, Instance sample2) {
+		double sum = 0;
+		for (int i = 0; i < sample.numInputAttributes(); i++) {
+			double diff = sample.valueInputAttribute(i) - sample2.valueInputAttribute(i);
+			sum += diff * diff;
 		}
 		return Math.sqrt(sum);
 	}
 
 	/**
-	 * Returns the Euclidean distance between one sample and a collection of samples in an 1D-array.
+	 * Returns the Euclidean distance between one sample and a collection of samples
+	 * in an 1D-array.
 	 */
-	private double[] get1ToNDistances(Instance sample, InstancesHeader samples){
+	private double[] get1ToNDistances(Instance sample, InstancesHeader samples) {
 		double distances[] = new double[samples.numInstances()];
-		for (int i=0; i<samples.numInstances(); i++){
+		for (int i = 0; i < samples.numInstances(); i++) {
 			distances[i] = this.getDistance(sample, samples.get(i));
 		}
 		return distances;
@@ -461,19 +476,19 @@ private double[] get1ToNDistances(Instance sample, InstancesHeader samples){
 	/**
 	 * Returns the n smallest indices of the smallest values (sorted).
 	 */
-	private int[] nArgMin(int n, double[] values, int startIdx, int endIdx){
+	private int[] nArgMin(int n, double[] values, int startIdx, int endIdx) {
 		int indices[] = new int[n];
-		for (int i=0; i<n; i++){
+		for (int i = 0; i < n; i++) {
 			double minValue = Double.MAX_VALUE;
-			for (int j=startIdx; j<endIdx+1; j++){
-				if (values[j] < minValue){
+			for (int j = startIdx; j < endIdx + 1; j++) {
+				if (values[j] < minValue) {
 					boolean alreadyUsed = false;
-					for (int k=0; k<i; k++){
-						if (indices[k]==j){
+					for (int k = 0; k < i; k++) {
+						if (indices[k] == j) {
 							alreadyUsed = true;
 						}
 					}
-					if (!alreadyUsed){
+					if (!alreadyUsed) {
 						indices[i] = j;
 						minValue = values[j];
 					}
@@ -483,21 +498,22 @@ private int[] nArgMin(int n, double[] values, int startIdx, int endIdx){
 		return indices;
 	}
 
-	private int[] nArgMin(int n, double[] values){
-		return nArgMin(n, values, 0, values.length-1);
+	private int[] nArgMin(int n, double[] values) {
+		return nArgMin(n, values, 0, values.length - 1);
 	}
 
 	/**
-	 * Removes predictions of the largest window size and shifts the remaining ones accordingly.
+	 * Removes predictions of the largest window size and shifts the remaining ones
+	 * accordingly.
 	 */
-	private void adaptHistories(int numberOfDeletions){
-		for (int i = 0; i < numberOfDeletions; i++){
+	private void adaptHistories(int numberOfDeletions) {
+		for (int i = 0; i < numberOfDeletions; i++) {
 			SortedSet<Integer> keys = new TreeSet<>(this.predictionHistories.keySet());
 			this.predictionHistories.remove(keys.first());
 			keys = new TreeSet<>(this.predictionHistories.keySet());
-			for (Integer key : keys){
+			for (Integer key : keys) {
 				List<Integer> predHistory = this.predictionHistories.remove(key);
-				this.predictionHistories.put(key-keys.first(), predHistory);
+				this.predictionHistories.put(key - keys.first(), predHistory);
 			}
 		}
 	}
@@ -505,24 +521,30 @@ private void adaptHistories(int numberOfDeletions){
 	/**
 	 * Creates a prediction history incrementally by using the previous predictions.
 	 */
-	private List<Integer> getIncrementalTestTrainPredHistory(InstancesHeader instances, int startIdx, List<Integer> predictionHistory){
-		for (int i= startIdx + this.kOption.getValue() + predictionHistory.size(); i < instances.numInstances(); i++){
-			predictionHistory.add((this.getLabelFct(distanceMatrixSTM[i], instances, startIdx,  i-1)==instances.get(i).classValue()) ? 1 : 0);
+	private List<Integer> getIncrementalTestTrainPredHistory(InstancesHeader instances, int startIdx,
+			List<Integer> predictionHistory) {
+		for (int i = startIdx + this.kOption.getValue() + predictionHistory.size(); i < instances.numInstances(); i++) {
+			predictionHistory.add((this.getLabelFct(distanceMatrixSTM[i], instances, startIdx, i - 1) == instances
+					.get(i).classValue()) ? 1 : 0);
 		}
 		return predictionHistory;
 	}
+
 	/**
 	 * Creates a prediction history from the scratch.
 	 */
-	private List<Integer> getTestTrainPredHistory(InstancesHeader instances, int startIdx){
+	private List<Integer> getTestTrainPredHistory(InstancesHeader instances, int startIdx) {
 		List<Integer> predictionHistory = new ArrayList<>();
-		for (int i= startIdx + this.kOption.getValue(); i < instances.numInstances(); i++){
-			predictionHistory.add((this.getLabelFct(distanceMatrixSTM[i], instances, startIdx, i-1)==instances.get(i).classValue()) ? 1 : 0);
+		for (int i = startIdx + this.kOption.getValue(); i < instances.numInstances(); i++) {
+			predictionHistory.add((this.getLabelFct(distanceMatrixSTM[i], instances, startIdx, i - 1) == instances
+					.get(i).classValue()) ? 1 : 0);
 		}
 		return predictionHistory;
 	}
+
 	/**
-	 * Returns the window size with the minimum Interleaved test-train error, using bisection (with recalculation of the STM error).
+	 * Returns the window size with the minimum Interleaved test-train error, using
+	 * bisection (with recalculation of the STM error).
 	 */
 	private int getMinErrorRateWindowSize() {
 
@@ -547,7 +569,8 @@ private int getMinErrorRateWindowSize() {
 				int idx = numSamples - numSamplesIt;
 				List<Integer> predHistory;
 				if (this.predictionHistories.containsKey(idx)) {
-					predHistory = this.getIncrementalTestTrainPredHistory(this.stm, idx, this.predictionHistories.get(idx));
+					predHistory = this.getIncrementalTestTrainPredHistory(this.stm, idx,
+							this.predictionHistories.get(idx));
 				} else {
 					predHistory = this.getTestTrainPredHistory(this.stm, idx);
 				}
@@ -562,10 +585,11 @@ private int getMinErrorRateWindowSize() {
 			return windowSize;
 		}
 	}
+
 	/**
 	 * Calculates the achieved error rate of a history.
 	 */
-	private double getHistoryErrorRate(List<Integer> predHistory){
+	private double getHistoryErrorRate(List<Integer> predHistory) {
 		double sumCorrect = 0;
 		for (Integer e : predHistory) {
 			sumCorrect += e;
@@ -574,7 +598,8 @@ private double getHistoryErrorRate(List<Integer> predHistory){
 	}
 
 	/**
-	 * Returns the window size with the minimum Interleaved test-train error, using bisection (without recalculation using an incremental approximation).
+	 * Returns the window size with the minimum Interleaved test-train error, using
+	 * bisection (without recalculation using an incremental approximation).
 	 */
 	private int getMinErrorRateWindowSizeIncremental() {
 		int numSamples = this.stm.numInstances();
@@ -590,9 +615,10 @@ private int getMinErrorRateWindowSizeIncremental() {
 				int idx = numSamples - numSamplesIt;
 				List<Integer> predHistory;
 				if (this.predictionHistories.containsKey(idx)) {
-					predHistory = this.getIncrementalTestTrainPredHistory(this.stm, idx, this.predictionHistories.get(idx));
-				} else if (this.predictionHistories.containsKey(idx-1)){
-					predHistory = this.predictionHistories.remove(idx-1);
+					predHistory = this.getIncrementalTestTrainPredHistory(this.stm, idx,
+							this.predictionHistories.get(idx));
+				} else if (this.predictionHistories.containsKey(idx - 1)) {
+					predHistory = this.predictionHistories.remove(idx - 1);
 					predHistory.remove(0);
 					predHistory = this.getIncrementalTestTrainPredHistory(this.stm, idx, predHistory);
 					this.predictionHistories.put(idx, predHistory);
@@ -604,8 +630,8 @@ private int getMinErrorRateWindowSizeIncremental() {
 			}
 			int minErrorRateIdx = errorRates.indexOf(Collections.min(errorRates));
 			if (minErrorRateIdx > 0) {
-				for (int i = 1; i < errorRates.size(); i++){
-					if (errorRates.get(i) < errorRates.get(0)){
+				for (int i = 1; i < errorRates.size(); i++) {
+					if (errorRates.get(i) < errorRates.get(0)) {
 						int idx = numSamples - numSamplesRange.get(i);
 						List<Integer> predHistory = this.getTestTrainPredHistory(this.stm, idx);
 						errorRates.set(i, this.getHistoryErrorRate(predHistory));
@@ -622,21 +648,23 @@ private int getMinErrorRateWindowSizeIncremental() {
 			return windowSize;
 		}
 	}
+
 	/**
-	 * Returns the bisected STM size which minimizes the interleaved-test-train error.
+	 * Returns the bisected STM size which minimizes the interleaved-test-train
+	 * error.
 	 */
-	private int getNewSTMSize(boolean recalculateErrors){
+	private int getNewSTMSize(boolean recalculateErrors) {
 		if (recalculateErrors)
 			return this.getMinErrorRateWindowSize();
 		else
 			return this.getMinErrorRateWindowSizeIncremental();
 	}
 
-  @Override
-  public ImmutableCapabilities defineImmutableCapabilities() {
-    if (this.getClass() == SAMkNN.class)
-      return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-    else
-      return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-  }
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == SAMkNN.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
 }
diff --git a/moa/src/main/java/moa/learners/predictors/lazy/kNN.java b/moa/src/main/java/moa/learners/predictors/lazy/kNN.java
new file mode 100644
index 000000000..09cbcebff
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/lazy/kNN.java
@@ -0,0 +1,141 @@
+/*
+ *    kNN.java
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.lazy;
+
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Measurement;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.lazy.neighboursearch.KDTree;
+import moa.learners.predictors.lazy.neighboursearch.LinearNNSearch;
+import moa.learners.predictors.lazy.neighboursearch.NearestNeighbourSearch;
+
+/**
+ * k Nearest Neighbor.
+ * <p>
+ *
+ * Valid options are:
+ * <p>
+ *
+ * -k number of neighbours <br>
+ * -m max instances <br>
+ *
+ * @author Jesse Read (jesse@tsc.uc3m.es)
+ * @version 03.2012
+ */
+public class kNN extends AbstractClassifier implements Classifier {
+
+	private static final long serialVersionUID = 1L;
+
+	public IntOption kOption = new IntOption("k", 'k', "The number of neighbors", 10, 1, Integer.MAX_VALUE);
+
+	public IntOption limitOption = new IntOption("limit", 'w', "The maximum number of instances to store", 1000, 1,
+			Integer.MAX_VALUE);
+
+	public MultiChoiceOption nearestNeighbourSearchOption = new MultiChoiceOption("nearestNeighbourSearch", 'n',
+			"Nearest Neighbour Search to use", new String[] { "LinearNN", "KDTree" },
+			new String[] { "Brute force search algorithm for nearest neighbour search. ",
+					"KDTree search algorithm for nearest neighbour search" },
+			0);
+
+	int C = 0;
+
+	@Override
+	public String getPurposeString() {
+		return "kNN: special.";
+	}
+
+	protected InstancesHeader window;
+
+	@Override
+	public void setModelContext(InstancesHeader context) {
+		try {
+			this.window = new InstancesHeader(context, 0); // new StringReader(context.toString())
+			this.window.setClassIndex(context.classIndex());
+		} catch (Exception e) {
+			System.err.println("Error: no Model Context available.");
+			e.printStackTrace();
+			System.exit(1);
+		}
+	}
+
+	@Override
+	public void resetLearningImpl() {
+		this.window = null;
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		if (inst.classValue() > C)
+			C = (int) inst.classValue();
+		if (this.window == null) {
+			this.window = inst.dataset().getEmptyHeader();
+		}
+		if (this.limitOption.getValue() <= this.window.numInstances()) {
+			this.window.delete(0);
+		}
+		this.window.add(inst);
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		double v[] = new double[C + 1];
+		try {
+			NearestNeighbourSearch search;
+			if (this.nearestNeighbourSearchOption.getChosenIndex() == 0) {
+				search = new LinearNNSearch(this.window);
+			} else {
+				search = new KDTree();
+				search.setInstances(this.window);
+			}
+			if (this.window.numInstances() > 0) {
+				InstancesHeader neighbours = search.kNearestNeighbours(inst,
+						Math.min(kOption.getValue(), this.window.numInstances()));
+				for (int i = 0; i < neighbours.numInstances(); i++) {
+					v[(int) neighbours.instance(i).classValue()]++;
+				}
+			}
+		} catch (Exception e) {
+			// System.err.println("Error: kNN search failed.");
+			// e.printStackTrace();
+			// System.exit(1);
+			return new ClassificationPrediction();
+		}
+		return new ClassificationPrediction(v);
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return null;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/lazy/kNNwithPAW.java b/moa/src/main/java/moa/learners/predictors/lazy/kNNwithPAW.java
new file mode 100644
index 000000000..2757938d8
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/lazy/kNNwithPAW.java
@@ -0,0 +1,80 @@
+/*
+ *    kNNwithPAW.java
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.lazy;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+/**
+ * k Nearest Neighbor ADAPTIVE with PAW.
+ * <p>
+ *
+ * Valid options are:
+ * <p>
+ *
+ * -k number of neighbours <br>
+ *
+ * @author Jesse Read (jesse@tsc.uc3m.es)
+ * @version 03.2012
+ */
+public class kNNwithPAW extends kNN {
+
+	private static final long serialVersionUID = 1L;
+
+	protected int marker = 0;
+
+	@Override
+	public String getPurposeString() {
+		return "kNN+PAW: kNN with Probabilistic Approximate Window";
+	}
+
+	protected double prob;
+
+	@Override
+	public void resetLearningImpl() {
+		this.window = null;
+		this.prob = Math.pow(2.0, -1.0 / this.limitOption.getValue());
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		if (inst.classValue() > C) {
+			C = (int) inst.classValue();
+		}
+		if (this.window == null) {
+			this.window = inst.dataset().getEmptyHeader();
+		}
+
+		for (int i = 0; i < this.window.size(); i++) {
+			if (this.classifierRandom.nextDouble() > this.prob) {
+				this.window.delete(i);
+			}
+		}
+		this.window.add(inst);
+
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/lazy/kNNwithPAWandADWIN.java b/moa/src/main/java/moa/learners/predictors/lazy/kNNwithPAWandADWIN.java
new file mode 100644
index 000000000..588269d5c
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/lazy/kNNwithPAWandADWIN.java
@@ -0,0 +1,111 @@
+/*
+ *    kNNAdaptive.java
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.lazy;
+
+import java.util.ArrayList;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.core.driftdetection.ADWIN;
+
+/**
+ * k Nearest Neighbor ADAPTIVE with ADWIN+PAW.
+ * <p>
+ *
+ * Valid options are:
+ * <p>
+ *
+ * -k number of neighbours <br>
+ *
+ * @author Jesse Read (jesse@tsc.uc3m.es)
+ * @version 03.2012
+ */
+public class kNNwithPAWandADWIN extends kNN implements Classifier {
+
+	private static final long serialVersionUID = 1L;
+
+	private ADWIN adwin;
+
+	protected int marker = 0;
+
+	protected ArrayList<Integer> timeStamp;
+
+	@Override
+	public String getPurposeString() {
+		return "kNNwithPAWandADWIN: kNN with Probabilistic Approximate Window and ADWIN";
+	}
+
+	protected double prob;
+
+	@Override
+	public void resetLearningImpl() {
+		this.window = null;
+		this.adwin = new ADWIN();
+		this.prob = Math.pow(2.0, -1.0 / this.limitOption.getValue());
+		this.time = 0;
+	}
+
+	protected int time;
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		if (inst.classValue() > C) {
+			C = (int) inst.classValue();
+		}
+		// ADWIN
+		if (this.window == null) {
+			this.window = inst.dataset().getEmptyHeader();
+		}
+
+		if (this.timeStamp == null) {
+			this.timeStamp = new ArrayList<>(10);
+		}
+		for (int i = 0; i < this.window.size(); i++) {
+			if (this.classifierRandom.nextDouble() > this.prob) {
+				this.window.delete(i);
+				this.timeStamp.remove(i);
+			}
+		}
+		this.window.add(inst);
+		this.timeStamp.add(this.time);
+		this.time++;
+		boolean correctlyClassifies = this.correctlyClassifies(inst);
+		if (this.adwin.setInput(correctlyClassifies ? 0 : 1)) {
+			// Change
+			int size = this.adwin.getWidth();
+			for (int i = 0; i < this.window.size(); i++) {
+				if (this.timeStamp.get(i) < this.time - size) {
+					this.window.delete(i);
+					this.timeStamp.remove(i);
+				}
+			}
+		}
+
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/DistanceFunction.java b/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/DistanceFunction.java
new file mode 100644
index 000000000..6c4294328
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/DistanceFunction.java
@@ -0,0 +1,126 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ *    DistanceFunction.java
+ *    Copyright (C) 1999-2012 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package moa.learners.predictors.lazy.neighboursearch;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
+/**
+ * Interface for any class that can compute and return distances between two
+ * instances.
+ *
+ * @author Ashraf M. Kibriya (amk14@cs.waikato.ac.nz)
+ * @version $Revision: 8034 $
+ */
+public interface DistanceFunction {
+
+	/**
+	 * Sets the instances.
+	 * 
+	 * @param insts the instances to use
+	 */
+	void setInstances(InstancesHeader insts);
+
+	/**
+	 * returns the instances currently set.
+	 * 
+	 * @return the current instances
+	 */
+	InstancesHeader getInstances();
+
+	/**
+	 * Sets the range of attributes to use in the calculation of the distance. The
+	 * indices start from 1, 'first' and 'last' are valid as well. E.g.:
+	 * first-3,5,6-last
+	 * 
+	 * @param value the new attribute index range
+	 */
+	void setAttributeIndices(String value);
+
+	/**
+	 * Gets the range of attributes used in the calculation of the distance.
+	 * 
+	 * @return the attribute index range
+	 */
+	String getAttributeIndices();
+
+	/**
+	 * Sets whether the matching sense of attribute indices is inverted or not.
+	 * 
+	 * @param value if true the matching sense is inverted
+	 */
+	void setInvertSelection(boolean value);
+
+	/**
+	 * Gets whether the matching sense of attribute indices is inverted or not.
+	 * 
+	 * @return true if the matching sense is inverted
+	 */
+	boolean getInvertSelection();
+
+	/**
+	 * Calculates the distance between two instances.
+	 * 
+	 * @param first  the first instance
+	 * @param second the second instance
+	 * @return the distance between the two given instances
+	 */
+	double distance(Instance first, Instance second);
+
+	/**
+	 * Calculates the distance between two instances. Offers speed up (if the
+	 * distance function class in use supports it) in nearest neighbour search by
+	 * taking into account the cutOff or maximum distance. Depending on the distance
+	 * function class, post processing of the distances by
+	 * postProcessDistances(double []) may be required if this function is used.
+	 *
+	 * @param first       the first instance
+	 * @param second      the second instance
+	 * @param cutOffValue If the distance being calculated becomes larger than
+	 *                    cutOffValue then the rest of the calculation is discarded.
+	 * @return the distance between the two given instances or
+	 *         Double.POSITIVE_INFINITY if the distance being calculated becomes
+	 *         larger than cutOffValue.
+	 */
+	double distance(Instance first, Instance second, double cutOffValue);
+
+	/**
+	 * Does post processing of the distances (if necessary) returned by
+	 * distance(distance(Instance first, Instance second, double cutOffValue). It
+	 * may be necessary, depending on the distance function, to do post processing
+	 * to set the distances on the correct scale. Some distance function classes may
+	 * not return correct distances using the cutOffValue distance function to
+	 * minimize the inaccuracies resulting from floating point comparison and
+	 * manipulation.
+	 * 
+	 * @param distances the distances to post-process
+	 */
+	void postProcessDistances(double distances[]);
+
+	/**
+	 * Update the distance function (if necessary) for the newly added instance.
+	 * 
+	 * @param ins the instance to add
+	 */
+	void update(Instance ins);
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/EuclideanDistance.java b/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/EuclideanDistance.java
new file mode 100644
index 000000000..e824181d6
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/EuclideanDistance.java
@@ -0,0 +1,231 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ *    EuclideanDistance.java
+ *    Copyright (C) 1999-2012 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package moa.learners.predictors.lazy.neighboursearch;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
+/**
+ * <!-- globalinfo-start --> Implementing Euclidean distance (or similarity)
+ * function.<br/>
+ * <br/>
+ * One object defines not one distance but the data model in which the distances
+ * between objects of that data model can be computed.<br/>
+ * <br/>
+ * Attention: For efficiency reasons the use of consistency checks (like are the
+ * data models of the two instances exactly the same), is low.<br/>
+ * <br/>
+ * For more information, see:<br/>
+ * <br/>
+ * Wikipedia. Euclidean distance. URL
+ * http://en.wikipedia.org/wiki/Euclidean_distance.
+ * <p/>
+ * <!-- globalinfo-end -->
+ *
+ * <!-- technical-bibtex-start --> BibTeX:
+ * 
+ * <pre>
+ * &#64;misc{missing_id,
+ *    author = {Wikipedia},
+ *    title = {Euclidean distance},
+ *    URL = {http://en.wikipedia.org/wiki/Euclidean_distance}
+ * }
+ * </pre>
+ * <p/>
+ * <!-- technical-bibtex-end -->
+ *
+ * <!-- options-start --> Valid options are:
+ * <p/>
+ *
+ * <pre>
+ *  -D
+ *  Turns off the normalization of attribute
+ *  values in distance calculation.
+ * </pre>
+ *
+ * <pre>
+ *  -R &lt;col1,col2-col4,...&gt;
+ *  Specifies list of columns to used in the calculation of the
+ *  distance. 'first' and 'last' are valid indices.
+ *  (default: first-last)
+ * </pre>
+ *
+ * <pre>
+ *  -V
+ *  Invert matching sense of column indices.
+ * </pre>
+ * 
+ * <!-- options-end -->
+ *
+ * @author Gabi Schmidberger (gabi@cs.waikato.ac.nz)
+ * @author Ashraf M. Kibriya (amk14@cs.waikato.ac.nz)
+ * @author FracPete (fracpete at waikato dot ac dot nz)
+ * @version $Revision: 8034 $
+ */
+public class EuclideanDistance extends NormalizableDistance implements Cloneable {
+
+	/** for serialization. */
+	private static final long serialVersionUID = 1068606253458807903L;
+
+	/**
+	 * Constructs an Euclidean Distance object, Instances must be still set.
+	 */
+	public EuclideanDistance() {
+		super();
+	}
+
+	/**
+	 * Constructs an Euclidean Distance object and automatically initializes the
+	 * ranges.
+	 * 
+	 * @param data the instances the distance function should work on
+	 */
+	public EuclideanDistance(InstancesHeader data) {
+		super(data);
+	}
+
+	/**
+	 * Returns a string describing this object.
+	 * 
+	 * @return a description of the evaluator suitable for displaying in the
+	 *         explorer/experimenter gui
+	 */
+	@Override
+	public String globalInfo() {
+		return "Implementing Euclidean distance (or similarity) function.\n\n"
+				+ "One object defines not one distance but the data model in which "
+				+ "the distances between objects of that data model can be computed.\n\n"
+				+ "Attention: For efficiency reasons the use of consistency checks "
+				+ "(like are the data models of the two instances exactly the same), " + "is low.\n\n";
+	}
+
+	/**
+	 * Calculates the distance between two instances.
+	 * 
+	 * @param first  the first instance
+	 * @param second the second instance
+	 * @return the distance between the two given instances
+	 */
+	@Override
+	public double distance(Instance first, Instance second) {
+		return Math.sqrt(distance(first, second, Double.POSITIVE_INFINITY));
+	}
+
+	/**
+	 * Updates the current distance calculated so far with the new difference
+	 * between two attributes. The difference between the attributes was calculated
+	 * with the difference(int,double,double) method.
+	 * 
+	 * @param currDist the current distance calculated so far
+	 * @param diff     the difference between two new attributes
+	 * @return the update distance
+	 * @see #difference(int, double, double)
+	 */
+	@Override
+	protected double updateDistance(double currDist, double diff) {
+		double result;
+
+		result = currDist;
+		result += diff * diff;
+
+		return result;
+	}
+
+	/**
+	 * Does post processing of the distances (if necessary) returned by
+	 * distance(distance(Instance first, Instance second, double cutOffValue). It is
+	 * necessary to do so to get the correct distances if distance(distance(Instance
+	 * first, Instance second, double cutOffValue) is used. This is because that
+	 * function actually returns the squared distance to avoid inaccuracies arising
+	 * from floating point comparison.
+	 * 
+	 * @param distances the distances to post-process
+	 */
+	@Override
+	public void postProcessDistances(double distances[]) {
+		for (int i = 0; i < distances.length; i++) {
+			distances[i] = Math.sqrt(distances[i]);
+		}
+	}
+
+	/**
+	 * Returns the squared difference of two values of an attribute.
+	 * 
+	 * @param index the attribute index
+	 * @param val1  the first value
+	 * @param val2  the second value
+	 * @return the squared difference
+	 */
+	public double sqDifference(int index, double val1, double val2) {
+		double val = difference(index, val1, val2);
+		return val * val;
+	}
+
+	/**
+	 * Returns value in the middle of the two parameter values.
+	 * 
+	 * @param ranges the ranges to this dimension
+	 * @return the middle value
+	 */
+	public double getMiddle(double[] ranges) {
+
+		double middle = ranges[R_MIN] + ranges[R_WIDTH] * 0.5;
+		return middle;
+	}
+
+	/**
+	 * Returns the index of the closest point to the current instance. Index is
+	 * index in Instances object that is the second parameter.
+	 *
+	 * @param instance  the instance to assign a cluster to
+	 * @param allPoints all points
+	 * @param pointList the list of points
+	 * @return the index of the closest point
+	 * @throws Exception if something goes wrong
+	 */
+	public int closestPoint(Instance instance, InstancesHeader allPoints, int[] pointList) throws Exception {
+		double minDist = Integer.MAX_VALUE;
+		int bestPoint = 0;
+		for (int i = 0; i < pointList.length; i++) {
+			double dist = distance(instance, allPoints.instance(pointList[i]), Double.POSITIVE_INFINITY);
+			if (dist < minDist) {
+				minDist = dist;
+				bestPoint = i;
+			}
+		}
+		return pointList[bestPoint];
+	}
+
+	/**
+	 * Returns true if the value of the given dimension is smaller or equal the
+	 * value to be compared with.
+	 * 
+	 * @param instance the instance where the value should be taken of
+	 * @param dim      the dimension of the value
+	 * @param value    the value to compare with
+	 * @return true if value of instance is smaller or equal value
+	 */
+	public boolean valueIsSmallerEqual(Instance instance, int dim, double value) { // This stays
+		return instance.value(dim) <= value;
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/KDTree.java b/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/KDTree.java
new file mode 100644
index 000000000..081b4fda8
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/KDTree.java
@@ -0,0 +1,1091 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ *    KDTree.java
+ *    Copyright (C) 2000-2012 University of Waikato
+ *
+ */
+
+package moa.learners.predictors.lazy.neighboursearch;
+
+import java.util.Enumeration;
+import java.util.Vector;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
+import moa.learners.predictors.lazy.neighboursearch.kdtrees.KDTreeNode;
+import moa.learners.predictors.lazy.neighboursearch.kdtrees.KDTreeNodeSplitter;
+import moa.learners.predictors.lazy.neighboursearch.kdtrees.SlidingMidPointOfWidestSide;
+
+/**
+ * <!-- globalinfo-start --> Class implementing the KDTree search algorithm for
+ * nearest neighbour search.<br/>
+ * The connection to dataset is only a reference. For the tree structure the
+ * indexes are stored in an array. <br/>
+ * Building the tree:<br/>
+ * If a node has &lt;maximal-inst-number&gt; (option -L) instances no further
+ * splitting is done. Also if the split would leave one side empty, the branch
+ * is not split any further even if the instances in the resulting node are more
+ * than &lt;maximal-inst-number&gt; instances.<br/>
+ * **PLEASE NOTE:** The algorithm can not handle missing values, so it is
+ * advisable to run ReplaceMissingValues filter if there are any missing values
+ * in the dataset.<br/>
+ * <br/>
+ * For more information see:<br/>
+ * <br/>
+ * Jerome H. Friedman, Jon Luis Bentley, Raphael Ari Finkel (1977). An Algorithm
+ * for Finding Best Matches in Logarithmic Expected Time. ACM Transactions on
+ * Mathematics Software. 3(3):209-226.<br/>
+ * <br/>
+ * Andrew Moore (1991). A tutorial on kd-trees.
+ * <p/>
+ * <!-- globalinfo-end -->
+ * 
+ * <!-- technical-bibtex-start --> BibTeX:
+ * 
+ * <pre>
+ * &#64;article{Friedman1977,
+ *    author = {Jerome H. Friedman and Jon Luis Bentley and Raphael Ari Finkel},
+ *    journal = {ACM Transactions on Mathematics Software},
+ *    month = {September},
+ *    number = {3},
+ *    pages = {209-226},
+ *    title = {An Algorithm for Finding Best Matches in Logarithmic Expected Time},
+ *    volume = {3},
+ *    year = {1977}
+ * }
+ *
+ * &#64;techreport{Moore1991,
+ *    author = {Andrew Moore},
+ *    booktitle = {University of Cambridge Computer Laboratory Technical Report No. 209},
+ *    howpublished = {Extract from PhD Thesis},
+ *    title = {A tutorial on kd-trees},
+ *    year = {1991},
+ *    HTTP = {Available from http://www.autonlab.org/autonweb/14665.html}
+ * }
+ * </pre>
+ * <p/>
+ * <!-- technical-bibtex-end -->
+ * 
+ * <!-- options-start --> Valid options are:
+ * <p/>
+ *
+ * <pre>
+ *  -S &lt;classname and options&gt;
+ *  Node splitting method to use.
+ *  (default: weka.core.neighboursearch.kdtrees.SlidingMidPointOfWidestSide)
+ * </pre>
+ *
+ * <pre>
+ *  -W &lt;value&gt;
+ *  Set minimal width of a box
+ *  (default: 1.0E-2).
+ * </pre>
+ *
+ * <pre>
+ *  -L
+ *  Maximal number of instances in a leaf
+ *  (default: 40).
+ * </pre>
+ *
+ * <pre>
+ *  -N
+ *  Normalizing will be done
+ *  (Select dimension for split, with normalising to universe).
+ * </pre>
+ * 
+ * <!-- options-end -->
+ *
+ * @author Gabi Schmidberger (gabi[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
+ * @author Malcolm Ware (mfw4[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
+ * @author Ashraf M. Kibriya (amk14[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
+ * @version $Revision: 8034 $
+ */
+public class KDTree extends NearestNeighbourSearch {
+
+	/** For serialization. */
+	private static final long serialVersionUID = 1505717283763272533L;
+
+	/**
+	 * Array holding the distances of the nearest neighbours. It is filled up both
+	 * by nearestNeighbour() and kNearestNeighbours().
+	 */
+	protected double[] m_DistanceList;
+
+	/**
+	 * Indexlist of the instances of this kdtree. Instances get sorted according to
+	 * the splits. the nodes of the KDTree just hold their start and end indices
+	 */
+	protected int[] m_InstList;
+
+	/** The root node of the tree. */
+	protected KDTreeNode m_Root;
+
+	/** The node splitter. */
+	protected KDTreeNodeSplitter m_Splitter = new SlidingMidPointOfWidestSide();
+
+	/** Tree stats. */
+	protected int m_NumNodes, m_NumLeaves, m_MaxDepth;
+
+	// Constants
+	/** The index of MIN value in attributes' range array. */
+	public static final int MIN = EuclideanDistance.R_MIN;
+
+	/** The index of MAX value in attributes' range array. */
+	public static final int MAX = EuclideanDistance.R_MAX;
+
+	/** The index of WIDTH (MAX-MIN) value in attributes' range array. */
+	public static final int WIDTH = EuclideanDistance.R_WIDTH;
+
+	/**
+	 * Creates a new instance of KDTree.
+	 */
+	public KDTree() {
+		super();
+	}
+
+	/**
+	 * Creates a new instance of KDTree. It also builds the tree on supplied set of
+	 * Instances.
+	 * 
+	 * @param insts The instances/points on which the BallTree should be built on.
+	 */
+	public KDTree(InstancesHeader insts) {
+		super(insts);
+	}
+
+	/**
+	 * Builds the KDTree on the supplied set of instances/points. It is adviseable
+	 * to run the replace missing attributes filter on the passed instances first.
+	 * NOTE: This method should not be called from outside this class. Outside
+	 * classes should call setInstances(Instances) instead.
+	 * 
+	 * @param instances The instances to build the tree on
+	 * @throws Exception if something goes wrong
+	 */
+	protected void buildKDTree(InstancesHeader instances) throws Exception {
+
+		checkMissing(instances);
+		if (m_EuclideanDistance == null)
+			m_DistanceFunction = m_EuclideanDistance = new EuclideanDistance(instances);
+		else
+			m_EuclideanDistance.setInstances(instances);
+
+		m_Instances = instances;
+		int numInst = m_Instances.numInstances();
+
+		// Make the global index list
+		m_InstList = new int[numInst];
+
+		for (int i = 0; i < numInst; i++) {
+			m_InstList[i] = i;
+		}
+
+		double[][] universe = m_EuclideanDistance.getRanges();
+
+		// initializing internal fields of KDTreeSplitter
+		m_Splitter.setInstances(m_Instances);
+		m_Splitter.setInstanceList(m_InstList);
+		m_Splitter.setEuclideanDistanceFunction(m_EuclideanDistance);
+		m_Splitter.setNodeWidthNormalization(m_NormalizeNodeWidth);
+
+		// building tree
+		m_NumNodes = m_NumLeaves = 1;
+		m_MaxDepth = 0;
+		m_Root = new KDTreeNode(m_NumNodes, 0, m_Instances.numInstances() - 1, universe);
+
+		splitNodes(m_Root, universe, m_MaxDepth + 1);
+	}
+
+	/**
+	 * Recursively splits nodes of a tree starting from the supplied node. The
+	 * splitting stops for any node for which the number of instances/points falls
+	 * below a given threshold (given by m_MaxInstInLeaf), or if the maximum
+	 * relative width/range of the instances/points (i.e. max_i(max(att_i) -
+	 * min(att_i)) ) falls below a given threshold (given by m_MinBoxRelWidth).
+	 * 
+	 * @param node     The node to start splitting from.
+	 * @param universe The attribute ranges of the whole dataset.
+	 * @param depth    The depth of the supplied node.
+	 * @throws Exception If there is some problem splitting.
+	 */
+	protected void splitNodes(KDTreeNode node, double[][] universe, int depth) throws Exception {
+		double[][] nodeRanges = m_EuclideanDistance.initializeRanges(m_InstList, node.m_Start, node.m_End);
+		if (node.numInstances() <= m_MaxInstInLeaf || getMaxRelativeNodeWidth(nodeRanges, universe) <= m_MinBoxRelWidth)
+			return;
+
+		// splitting a node so it is no longer a leaf
+		m_NumLeaves--;
+
+		if (depth > m_MaxDepth)
+			m_MaxDepth = depth;
+
+		m_Splitter.splitNode(node, m_NumNodes, nodeRanges, universe);
+		m_NumNodes += 2;
+		m_NumLeaves += 2;
+
+		splitNodes(node.m_Left, universe, depth + 1);
+		splitNodes(node.m_Right, universe, depth + 1);
+	}
+
+	/**
+	 * Returns (in the supplied heap object) the k nearest neighbours of the given
+	 * instance starting from the give tree node. &gt;k neighbours are returned if
+	 * there are more than one neighbours at the kth boundary. NOTE: This method
+	 * should not be used from outside this class. Outside classes should call
+	 * kNearestNeighbours(Instance, int).
+	 * 
+	 * @param target            The instance to find the nearest neighbours for.
+	 * @param node              The KDTreeNode to start the search from.
+	 * @param k                 The number of neighbours to find.
+	 * @param heap              The MyHeap object to store/update the kNNs found
+	 *                          during the search.
+	 * @param distanceToParents The distance of the supplied target to the parents
+	 *                          of the supplied tree node.
+	 * @throws Exception if the nearest neighbour could not be found.
+	 */
+	protected void findNearestNeighbours(Instance target, KDTreeNode node, int k, MyHeap heap, double distanceToParents)
+			throws Exception {
+		if (node.isALeaf()) {
+			double distance;
+			// look at all the instances in this leaf
+			for (int idx = node.m_Start; idx <= node.m_End; idx++) {
+				if (target == m_Instances.instance(m_InstList[idx])) // for
+																		// hold-one-out
+																		// cross-validation
+					continue;
+				if (heap.size() < k) {
+					distance = m_EuclideanDistance.distance(target, m_Instances.instance(m_InstList[idx]),
+							Double.POSITIVE_INFINITY);
+					heap.put(m_InstList[idx], distance);
+				} else {
+					MyHeapElement temp = heap.peek();
+					distance = m_EuclideanDistance.distance(target, m_Instances.instance(m_InstList[idx]),
+							temp.distance);
+					if (distance < temp.distance) {
+						heap.putBySubstitute(m_InstList[idx], distance);
+					} else if (distance == temp.distance) {
+						heap.putKthNearest(m_InstList[idx], distance);
+					}
+				} // end else heap.size==k
+			} // end for
+
+		} else {
+			KDTreeNode nearer, further;
+			boolean targetInLeft = m_EuclideanDistance.valueIsSmallerEqual(target, node.m_SplitDim, node.m_SplitValue);
+
+			if (targetInLeft) {
+				nearer = node.m_Left;
+				further = node.m_Right;
+			} else {
+				nearer = node.m_Right;
+				further = node.m_Left;
+			}
+			findNearestNeighbours(target, nearer, k, heap, distanceToParents);
+
+			// ... now look in further half if maxDist reaches into it
+			if (heap.size() < k) { // if haven't found the first k
+				double distanceToSplitPlane = distanceToParents + m_EuclideanDistance.sqDifference(node.m_SplitDim,
+						target.value(node.m_SplitDim), node.m_SplitValue);
+				findNearestNeighbours(target, further, k, heap, distanceToSplitPlane);
+				return;
+			} else { // else see if ball centered at query intersects with the other
+						// side.
+				double distanceToSplitPlane = distanceToParents + m_EuclideanDistance.sqDifference(node.m_SplitDim,
+						target.value(node.m_SplitDim), node.m_SplitValue);
+				if (heap.peek().distance >= distanceToSplitPlane) {
+					findNearestNeighbours(target, further, k, heap, distanceToSplitPlane);
+				}
+			} // end else
+		} // end else_if an internal node
+	}
+
+	/**
+	 * Returns the k nearest neighbours of the supplied instance. &gt;k neighbours
+	 * are returned if there are more than one neighbours at the kth boundary.
+	 * 
+	 * @param target The instance to find the nearest neighbours for.
+	 * @param k      The number of neighbours to find.
+	 * @return The k nearest neighbours (or &gt;k if more there are than one
+	 *         neighbours at the kth boundary).
+	 * @throws Exception if the nearest neighbour could not be found.
+	 */
+	@Override
+	public InstancesHeader kNearestNeighbours(Instance target, int k) throws Exception {
+		checkMissing(target);
+
+		MyHeap heap = new MyHeap(k);
+		findNearestNeighbours(target, m_Root, k, heap, 0.0);
+
+		InstancesHeader neighbours = new InstancesHeader(m_Instances, (heap.size() + heap.noOfKthNearest()));
+		m_DistanceList = new double[heap.size() + heap.noOfKthNearest()];
+		int[] indices = new int[heap.size() + heap.noOfKthNearest()];
+		int i = indices.length - 1;
+		MyHeapElement h;
+		while (heap.noOfKthNearest() > 0) {
+			h = heap.getKthNearest();
+			indices[i] = h.index;
+			m_DistanceList[i] = h.distance;
+			i--;
+		}
+		while (heap.size() > 0) {
+			h = heap.get();
+			indices[i] = h.index;
+			m_DistanceList[i] = h.distance;
+			i--;
+		}
+		m_DistanceFunction.postProcessDistances(m_DistanceList);
+
+		for (int idx = 0; idx < indices.length; idx++) {
+			neighbours.add(m_Instances.instance(indices[idx]));
+		}
+
+		return neighbours;
+	}
+
+	/**
+	 * Returns the nearest neighbour of the supplied target instance.
+	 * 
+	 * @param target The instance to find the nearest neighbour for.
+	 * @return The nearest neighbour from among the previously supplied training
+	 *         instances.
+	 * @throws Exception if the neighbours could not be found.
+	 */
+	@Override
+	public Instance nearestNeighbour(Instance target) throws Exception {
+		return (kNearestNeighbours(target, 1)).instance(0);
+	}
+
+	/**
+	 * Returns the distances to the kNearest or 1 nearest neighbour currently found
+	 * with either the kNearestNeighbours or the nearestNeighbour method.
+	 * 
+	 * @return array containing the distances of the nearestNeighbours. The length
+	 *         and ordering of the array is the same as that of the instances
+	 *         returned by nearestNeighbour functions.
+	 * @throws Exception if called before calling kNearestNeighbours or
+	 *                   nearestNeighbours.
+	 */
+	@Override
+	public double[] getDistances() throws Exception {
+		if (m_Instances == null || m_DistanceList == null)
+			throw new Exception("The tree has not been supplied with a set of "
+					+ "instances or getDistances() has been called " + "before calling kNearestNeighbours().");
+		return m_DistanceList;
+	}
+
+	/**
+	 * Builds the KDTree on the given set of instances.
+	 * 
+	 * @param instances The insts on which the KDTree is to be built.
+	 * @throws Exception If some error occurs while building the KDTree
+	 */
+	@Override
+	public void setInstances(InstancesHeader instances) throws Exception {
+		super.setInstances(instances);
+		buildKDTree(instances);
+	}
+
+	/**
+	 * Adds one instance to the KDTree. This updates the KDTree structure to take
+	 * into account the newly added training instance.
+	 * 
+	 * @param instance the instance to be added. Usually the newly added instance in
+	 *                 the training set.
+	 * @throws Exception If the instance cannot be added.
+	 */
+	@Override
+	public void update(Instance instance) throws Exception { // better to change
+																// to addInstance
+		if (m_Instances == null)
+			throw new Exception("No instances supplied yet. Have to call "
+					+ "setInstances(instances) with a set of Instances " + "first.");
+
+		addInstanceInfo(instance);
+		addInstanceToTree(instance, m_Root);
+	}
+
+	/**
+	 * Recursively adds an instance to the tree starting from the supplied
+	 * KDTreeNode. NOTE: This should not be called by outside classes, outside
+	 * classes should instead call update(Instance) method.
+	 * 
+	 * @param inst The instance to add to the tree
+	 * @param node The node to start the recursive search from, for the leaf node
+	 *             where the supplied instance would go.
+	 * @throws Exception If some error occurs while adding the instance.
+	 */
+	protected void addInstanceToTree(Instance inst, KDTreeNode node) throws Exception {
+		if (node.isALeaf()) {
+			int instList[] = new int[m_Instances.numInstances()];
+			try {
+				System.arraycopy(m_InstList, 0, instList, 0, node.m_End + 1); // m_InstList.squeezeIn(m_End,
+																				// index);
+				if (node.m_End < m_InstList.length - 1)
+					System.arraycopy(m_InstList, node.m_End + 1, instList, node.m_End + 2,
+							m_InstList.length - node.m_End - 1);
+				instList[node.m_End + 1] = m_Instances.numInstances() - 1;
+			} catch (ArrayIndexOutOfBoundsException ex) {
+				System.err.println("m_InstList.length: " + m_InstList.length + " instList.length: " + instList.length
+						+ "node.m_End+1: " + (node.m_End + 1) + "m_InstList.length-node.m_End+1: "
+						+ (m_InstList.length - node.m_End - 1));
+				throw ex;
+			}
+			m_InstList = instList;
+
+			node.m_End++;
+			node.m_NodeRanges = m_EuclideanDistance.updateRanges(inst, node.m_NodeRanges);
+
+			m_Splitter.setInstanceList(m_InstList);
+
+			// split this leaf node if necessary
+			double[][] universe = m_EuclideanDistance.getRanges();
+			if (node.numInstances() > m_MaxInstInLeaf
+					&& getMaxRelativeNodeWidth(node.m_NodeRanges, universe) > m_MinBoxRelWidth) {
+				m_Splitter.splitNode(node, m_NumNodes, node.m_NodeRanges, universe);
+				m_NumNodes += 2;
+			}
+		} // end if node is a leaf
+		else {
+			if (m_EuclideanDistance.valueIsSmallerEqual(inst, node.m_SplitDim, node.m_SplitValue)) {
+				addInstanceToTree(inst, node.m_Left);
+				afterAddInstance(node.m_Right);
+			} else
+				addInstanceToTree(inst, node.m_Right);
+
+			node.m_End++;
+			node.m_NodeRanges = m_EuclideanDistance.updateRanges(inst, node.m_NodeRanges);
+		}
+	}
+
+	/**
+	 * Corrects the start and end indices of a KDTreeNode after an instance is added
+	 * to the tree. The start and end indices for the master index array
+	 * (m_InstList) stored in the nodes need to be updated for all nodes in the
+	 * subtree on the right of a node where the instance was added. NOTE: No outside
+	 * class should call this method.
+	 * 
+	 * @param node KDTreeNode whose start and end indices need to be updated.
+	 */
+	protected void afterAddInstance(KDTreeNode node) {
+		node.m_Start++;
+		node.m_End++;
+		if (!node.isALeaf()) {
+			afterAddInstance(node.m_Left);
+			afterAddInstance(node.m_Right);
+		}
+	}
+
+	/**
+	 * Adds one instance to KDTree loosly. It only changes the ranges in
+	 * EuclideanDistance, and does not affect the structure of the KDTree.
+	 * 
+	 * @param instance the new instance. Usually this is the test instance supplied
+	 *                 to update the range of attributes in the distance function.
+	 */
+	@Override
+	public void addInstanceInfo(Instance instance) {
+		m_EuclideanDistance.updateRanges(instance);
+	}
+
+	/**
+	 * Checks if there is any instance with missing values. Throws an exception if
+	 * there is, as KDTree does not handle missing values.
+	 * 
+	 * @param instances the instances to check
+	 * @throws Exception if missing values are encountered
+	 */
+	protected void checkMissing(InstancesHeader instances) throws Exception {
+		for (int i = 0; i < instances.numInstances(); i++) {
+			Instance ins = instances.instance(i);
+			for (int j = 0; j < ins.numValues(); j++) {
+				if (ins.index(j) != ins.classIndex())
+					if (ins.isMissingSparse(j)) {
+						throw new Exception("ERROR: KDTree can not deal with missing "
+								+ "values. Please run ReplaceMissingValues filter "
+								+ "on the dataset before passing it on to the KDTree.");
+					}
+			}
+		}
+	}
+
+	/**
+	 * Checks if there is any missing value in the given instance.
+	 * 
+	 * @param ins The instance to check missing values in.
+	 * @throws Exception If there is a missing value in the instance.
+	 */
+	protected void checkMissing(Instance ins) throws Exception {
+		for (int j = 0; j < ins.numValues(); j++) {
+			if (ins.index(j) != ins.classIndex())
+				if (ins.isMissingSparse(j)) {
+					throw new Exception("ERROR: KDTree can not deal with missing "
+							+ "values. Please run ReplaceMissingValues filter "
+							+ "on the dataset before passing it on to the KDTree.");
+				}
+		}
+	}
+
+	/**
+	 * Returns the maximum attribute width of instances/points in a KDTreeNode
+	 * relative to the whole dataset.
+	 * 
+	 * @param nodeRanges The attribute ranges of the KDTreeNode whose maximum
+	 *                   relative width is to be determined.
+	 * @param universe   The attribute ranges of the whole dataset (training
+	 *                   instances + test instances so far encountered).
+	 * @return The maximum relative width
+	 */
+	protected double getMaxRelativeNodeWidth(double[][] nodeRanges, double[][] universe) {
+		int widest = widestDim(nodeRanges, universe);
+		if (widest < 0)
+			return 0.0;
+		else
+			return nodeRanges[widest][WIDTH] / universe[widest][WIDTH];
+	}
+
+	/**
+	 * Returns the widest dimension/attribute in a KDTreeNode (widest after
+	 * normalizing).
+	 * 
+	 * @param nodeRanges The attribute ranges of the KDTreeNode.
+	 * @param universe   The attribute ranges of the whole dataset (training
+	 *                   instances + test instances so far encountered).
+	 * @return The index of the widest dimension/attribute.
+	 */
+	protected int widestDim(double[][] nodeRanges, double[][] universe) {
+		final int classIdx = m_Instances.classIndex();
+		double widest = 0.0;
+		int w = -1;
+		if (m_NormalizeNodeWidth) {
+			for (int i = 0; i < nodeRanges.length; i++) {
+				double newWidest = nodeRanges[i][WIDTH] / universe[i][WIDTH];
+				if (newWidest > widest) {
+					if (i == classIdx)
+						continue;
+					widest = newWidest;
+					w = i;
+				}
+			}
+		} else {
+			for (int i = 0; i < nodeRanges.length; i++) {
+				if (nodeRanges[i][WIDTH] > widest) {
+					if (i == classIdx)
+						continue;
+					widest = nodeRanges[i][WIDTH];
+					w = i;
+				}
+			}
+		}
+		return w;
+	}
+
+	/**
+	 * Returns the size of the tree.
+	 * 
+	 * @return the size of the tree
+	 */
+	public double measureTreeSize() {
+		return m_NumNodes;
+	}
+
+	/**
+	 * Returns the number of leaves.
+	 * 
+	 * @return the number of leaves
+	 */
+	public double measureNumLeaves() {
+		return m_NumLeaves;
+	}
+
+	/**
+	 * Returns the depth of the tree.
+	 * 
+	 * @return The depth of the tree
+	 */
+	public double measureMaxDepth() {
+		return m_MaxDepth;
+	}
+
+	/**
+	 * Returns an enumeration of the additional measure names.
+	 * 
+	 * @return an enumeration of the measure names
+	 */
+	public Enumeration enumerateMeasures() {
+		Vector<String> newVector = new Vector<>();
+		newVector.addElement("measureTreeSize");
+		newVector.addElement("measureNumLeaves");
+		newVector.addElement("measureMaxDepth");
+		return newVector.elements();
+	}
+
+	/**
+	 * Returns the value of the named measure.
+	 * 
+	 * @param additionalMeasureName the name of the measure to query for its value.
+	 * @return The value of the named measure
+	 * @throws IllegalArgumentException If the named measure is not supported.
+	 */
+	public double getMeasure(String additionalMeasureName) {
+		if (additionalMeasureName.compareToIgnoreCase("measureMaxDepth") == 0) {
+			return measureMaxDepth();
+		} else if (additionalMeasureName.compareToIgnoreCase("measureTreeSize") == 0) {
+			return measureTreeSize();
+		} else if (additionalMeasureName.compareToIgnoreCase("measureNumLeaves") == 0) {
+			return measureNumLeaves();
+		} else {
+			throw new IllegalArgumentException(additionalMeasureName + " not supported (KDTree)");
+		}
+	}
+
+	/**
+	 * Sets whether to calculate the performance statistics or not.
+	 * 
+	 * @param measurePerformance Should be true if performance statistics are to be
+	 *                           measured.
+	 */
+	public void setMeasurePerformance(boolean measurePerformance) {
+		m_MeasurePerformance = measurePerformance;
+	}
+
+	/**
+	 * Assigns instances to centers using KDTree.
+	 * 
+	 * @param centers     the current centers
+	 * @param assignments the centerindex for each instance
+	 * @param pc          the threshold value for pruning.
+	 * @throws Exception If there is some problem assigning instances to centers.
+	 */
+	public void centerInstances(InstancesHeader centers, int[] assignments, double pc) throws Exception {
+
+		int[] centList = new int[centers.numInstances()];
+		for (int i = 0; i < centers.numInstances(); i++)
+			centList[i] = i;
+
+		determineAssignments(m_Root, centers, centList, assignments, pc);
+	}
+
+	/**
+	 * Assigns instances to the current centers called candidates.
+	 * 
+	 * @param node        The node to start assigning the instances from.
+	 * @param centers     all the current centers.
+	 * @param candidates  the current centers the method works on.
+	 * @param assignments the center index for each instance.
+	 * @param pc          the threshold value for pruning.
+	 * @throws Exception If there is some problem assigning instances to centers.
+	 */
+	protected void determineAssignments(KDTreeNode node, InstancesHeader centers, int[] candidates, int[] assignments,
+			double pc) throws Exception {
+
+		// reduce number of owners for current hyper rectangle
+		int[] owners = refineOwners(node, centers, candidates);
+
+		// only one owner
+		if (owners.length == 1) {
+			// all instances of this node are owned by one center
+			for (int i = node.m_Start; i <= node.m_End; i++) {
+				assignments[m_InstList[i]] // the assignment of this instance
+						= owners[0]; // is the current owner
+			}
+		} else if (!node.isALeaf()) {
+			// more than one owner and it is not a leaf
+			determineAssignments(node.m_Left, centers, owners, assignments, pc);
+			determineAssignments(node.m_Right, centers, owners, assignments, pc);
+		} else {
+			// this is a leaf and there are more than 1 owner
+			// XMeans.
+			assignSubToCenters(node, centers, owners, assignments);
+		}
+	}
+
+	/**
+	 * Refines the ownerlist.
+	 * 
+	 * @param node       The current tree node.
+	 * @param centers    all centers
+	 * @param candidates the indexes of those centers that are candidates.
+	 * @return list of owners
+	 * @throws Exception If some problem occurs in refining.
+	 */
+	protected int[] refineOwners(KDTreeNode node, InstancesHeader centers, int[] candidates) throws Exception {
+
+		int[] owners = new int[candidates.length];
+		double minDistance = Double.POSITIVE_INFINITY;
+		int ownerIndex = -1;
+		Instance owner;
+		int numCand = candidates.length;
+		double[] distance = new double[numCand];
+		boolean[] inside = new boolean[numCand];
+		for (int i = 0; i < numCand; i++) {
+			distance[i] = distanceToHrect(node, centers.instance(candidates[i]));
+			inside[i] = (distance[i] == 0.0);
+			if (distance[i] < minDistance) {
+				minDistance = distance[i];
+				ownerIndex = i;
+			}
+		}
+		owner = centers.instance(candidates[ownerIndex]).copy();
+
+		// are there other owners
+		// loop also goes over already found owner, keeps order
+		// in owner list
+		int index = 0;
+		for (int i = 0; i < numCand; i++) {
+			// 1. all centers that are points within rectangle are owners
+			if ((inside[i])
+
+					// 2. take all points with same distance to the rect. as the owner
+					|| (distance[i] == distance[ownerIndex])) {
+
+				// add competitor to owners list
+				owners[index++] = candidates[i];
+			} else {
+
+				Instance competitor = centers.instance(candidates[i]).copy();
+				if
+
+				// 3. point has larger distance to rectangle but still can compete
+				// with owner for some points in the rectangle
+				(!candidateIsFullOwner(node, owner, competitor))
+
+				{
+					// also add competitor to owners list
+					owners[index++] = candidates[i];
+				}
+			}
+		}
+		int[] result = new int[index];
+		for (int i = 0; i < index; i++)
+			result[i] = owners[i];
+		return result;
+	}
+
+	/**
+	 * Returns the distance between a point and an hyperrectangle.
+	 * 
+	 * @param node The current node from whose hyperrectangle the distance is to be
+	 *             measured.
+	 * @param x    the point
+	 * @return the distance
+	 * @throws Exception If some problem occurs in determining the distance to the
+	 *                   hyperrectangle.
+	 */
+	protected double distanceToHrect(KDTreeNode node, Instance x) throws Exception {
+		double distance = 0.0;
+
+		Instance closestPoint = x.copy();
+		boolean inside;
+		inside = clipToInsideHrect(node, closestPoint);
+		if (!inside)
+			distance = m_EuclideanDistance.distance(closestPoint, x);
+		return distance;
+	}
+
+	/**
+	 * Finds the closest point in the hyper rectangle to a given point. Change the
+	 * given point to this closest point by clipping of at all the dimensions to be
+	 * clipped of. If the point is inside the rectangle it stays unchanged. The
+	 * return value is true if the point was not changed, so the the return value is
+	 * true if the point was inside the rectangle.
+	 * 
+	 * @param node The current KDTreeNode in whose hyperrectangle the closest point
+	 *             is to be found.
+	 * @param x    a point
+	 * @return true if the input point stayed unchanged.
+	 */
+	protected boolean clipToInsideHrect(KDTreeNode node, Instance x) {
+		boolean inside = true;
+		for (int i = 0; i < m_Instances.numAttributes(); i++) {
+			// TODO treat nominals differently!??
+
+			if (x.value(i) < node.m_NodeRanges[i][MIN]) {
+				x.setValue(i, node.m_NodeRanges[i][MIN]);
+				inside = false;
+			} else if (x.value(i) > node.m_NodeRanges[i][MAX]) {
+				x.setValue(i, node.m_NodeRanges[i][MAX]);
+				inside = false;
+			}
+		}
+		return inside;
+	}
+
+	/**
+	 * Returns true if candidate is a full owner in respect to a competitor.
+	 * <p>
+	 * 
+	 * The candidate has been the closer point to the current rectangle or even has
+	 * been a point within the rectangle. The competitor is competing with the
+	 * candidate for a few points out of the rectangle although it is a point
+	 * further away from the rectangle then the candidate. The extrem point is the
+	 * corner of the rectangle that is furthest away from the candidate towards the
+	 * direction of the competitor.
+	 * 
+	 * If the distance candidate to this extreme point is smaller then the distance
+	 * competitor to this extreme point, then it is proven that none of the points
+	 * in the rectangle can be owned be the competitor and the candidate is full
+	 * owner of the rectangle in respect to this competitor. See also D. Pelleg and
+	 * A. Moore's paper 'Accelerating exact k-means Algorithms with Geometric
+	 * Reasoning'.
+	 * <p>
+	 * 
+	 * @param node       The current KDTreeNode / hyperrectangle.
+	 * @param candidate  instance that is candidate to be owner
+	 * @param competitor instance that competes against the candidate
+	 * @return true if candidate is full owner
+	 * @throws Exception If some problem occurs.
+	 */
+	protected boolean candidateIsFullOwner(KDTreeNode node, Instance candidate, Instance competitor) throws Exception {
+		// get extreme point
+		Instance extreme = candidate.copy();
+		for (int i = 0; i < m_Instances.numAttributes(); i++) {
+			if ((competitor.value(i) - candidate.value(i)) > 0) {
+				extreme.setValue(i, node.m_NodeRanges[i][MAX]);
+			} else {
+				extreme.setValue(i, node.m_NodeRanges[i][MIN]);
+			}
+		}
+		boolean isFullOwner = m_EuclideanDistance.distance(extreme, candidate) < m_EuclideanDistance.distance(extreme,
+				competitor);
+
+		return isFullOwner;
+	}
+
+	/**
+	 * Assigns instances of this node to center. Center to be assign to is decided
+	 * by the distance function.
+	 * 
+	 * @param node        The KDTreeNode whose instances are to be assigned.
+	 * @param centers     all the input centers
+	 * @param centList    the list of centers to work with
+	 * @param assignments index list of last assignments
+	 * @throws Exception If there is error assigning the instances.
+	 */
+	public void assignSubToCenters(KDTreeNode node, InstancesHeader centers, int[] centList, int[] assignments)
+			throws Exception {
+		// todo: undecided situations
+		int numCent = centList.length;
+
+		// WARNING: assignments is "input/output-parameter"
+		// should not be null and the following should not happen
+		if (assignments == null) {
+			assignments = new int[m_Instances.numInstances()];
+			for (int i = 0; i < assignments.length; i++) {
+				assignments[i] = -1;
+			}
+		}
+
+		// set assignments for all instances of this node
+		for (int i = node.m_Start; i <= node.m_End; i++) {
+			int instIndex = m_InstList[i];
+			Instance inst = m_Instances.instance(instIndex);
+			// if (instList[i] == 664) System.out.println("664***");
+			int newC = m_EuclideanDistance.closestPoint(inst, centers, centList);
+			// int newC = clusterProcessedInstance(inst, centers);
+			assignments[instIndex] = newC;
+		}
+	}
+
+	/**
+	 * Properties' variables =====================================================
+	 */
+
+	/** flag for normalizing. */
+	boolean m_NormalizeNodeWidth = true;
+
+	/** The euclidean distance function to use. */
+	protected EuclideanDistance m_EuclideanDistance;
+	{ // to make sure we have only one object of EuclideanDistance
+		if (m_DistanceFunction instanceof EuclideanDistance)
+			m_EuclideanDistance = (EuclideanDistance) m_DistanceFunction;
+		else
+			m_DistanceFunction = m_EuclideanDistance = new EuclideanDistance();
+	}
+
+	/** minimal relative width of a KDTree rectangle. */
+	protected double m_MinBoxRelWidth = 1.0E-2;
+
+	/** maximal number of instances in a leaf. */
+	protected int m_MaxInstInLeaf = 40;
+
+	/**
+	 * the GET and SET - functions ===============================================
+	 */
+
+	/**
+	 * Tip text for this property.
+	 * 
+	 * @return the tip text for this property
+	 */
+	public String minBoxRelWidthTipText() {
+		return "The minimum relative width of the box. A node is only made a leaf "
+				+ "if the width of the split dimension of the instances in a node "
+				+ "normalized over the width of the split dimension of all the "
+				+ "instances is less than or equal to this minimum relative width.";
+	}
+
+	/**
+	 * Sets the minimum relative box width.
+	 * 
+	 * @param i the minimum relative box width
+	 */
+	public void setMinBoxRelWidth(double i) {
+		m_MinBoxRelWidth = i;
+	}
+
+	/**
+	 * Gets the minimum relative box width.
+	 * 
+	 * @return the minimum relative box width
+	 */
+	public double getMinBoxRelWidth() {
+		return m_MinBoxRelWidth;
+	}
+
+	/**
+	 * Tip text for this property.
+	 * 
+	 * @return the tip text for this property
+	 */
+	public String maxInstInLeafTipText() {
+		return "The max number of instances in a leaf.";
+	}
+
+	/**
+	 * Sets the maximum number of instances in a leaf.
+	 * 
+	 * @param i the maximum number of instances in a leaf
+	 */
+	public void setMaxInstInLeaf(int i) {
+		m_MaxInstInLeaf = i;
+	}
+
+	/**
+	 * Get the maximum number of instances in a leaf.
+	 * 
+	 * @return the maximum number of instances in a leaf
+	 */
+	public int getMaxInstInLeaf() {
+		return m_MaxInstInLeaf;
+	}
+
+	/**
+	 * Tip text for this property.
+	 * 
+	 * @return the tip text for this property
+	 */
+	public String normalizeNodeWidthTipText() {
+		return "Whether if the widths of the KDTree node should be normalized "
+				+ "by the width of the universe or not. "
+				+ "Where, width of the node is the range of the split attribute "
+				+ "based on the instances in that node, and width of the "
+				+ "universe is the range of the split attribute based on all the " + "instances (default: false).";
+	}
+
+	/**
+	 * Sets the flag for normalizing the widths of a KDTree Node by the width of the
+	 * dimension in the universe.
+	 * 
+	 * @param n true to use normalizing.
+	 */
+	public void setNormalizeNodeWidth(boolean n) {
+		m_NormalizeNodeWidth = n;
+	}
+
+	/**
+	 * Gets the normalize flag.
+	 * 
+	 * @return True if normalizing
+	 */
+	public boolean getNormalizeNodeWidth() {
+		return m_NormalizeNodeWidth;
+	}
+
+	/**
+	 * returns the distance function currently in use.
+	 * 
+	 * @return the distance function
+	 */
+	@Override
+	public DistanceFunction getDistanceFunction() {
+		return m_EuclideanDistance;
+	}
+
+	/**
+	 * sets the distance function to use for nearest neighbour search.
+	 * 
+	 * @param df the distance function to use
+	 * @throws Exception if not EuclideanDistance
+	 */
+	@Override
+	public void setDistanceFunction(DistanceFunction df) throws Exception {
+		if (!(df instanceof EuclideanDistance))
+			throw new Exception("KDTree currently only works with " + "EuclideanDistanceFunction.");
+		m_DistanceFunction = m_EuclideanDistance = (EuclideanDistance) df;
+	}
+
+	/**
+	 * Returns the tip text for this property.
+	 * 
+	 * @return tip text for this property suitable for displaying in the
+	 *         explorer/experimenter gui
+	 */
+	public String nodeSplitterTipText() {
+		return "The the splitting method to split the nodes of the KDTree.";
+	}
+
+	/**
+	 * Returns the splitting method currently in use to split the nodes of the
+	 * KDTree.
+	 * 
+	 * @return The KDTreeNodeSplitter currently in use.
+	 */
+	public KDTreeNodeSplitter getNodeSplitter() {
+		return m_Splitter;
+	}
+
+	/**
+	 * Sets the splitting method to use to split the nodes of the KDTree.
+	 * 
+	 * @param splitter The KDTreeNodeSplitter to use.
+	 */
+	public void setNodeSplitter(KDTreeNodeSplitter splitter) {
+		m_Splitter = splitter;
+	}
+
+	/**
+	 * Returns a string describing this nearest neighbour search algorithm.
+	 * 
+	 * @return a description of the algorithm for displaying in the
+	 *         explorer/experimenter gui
+	 */
+	@Override
+	public String globalInfo() {
+		return "Class implementing the KDTree search algorithm for nearest " + "neighbour search.\n"
+				+ "The connection to dataset is only a reference. For the tree "
+				+ "structure the indexes are stored in an array. \n" + "Building the tree:\n"
+				+ "If a node has <maximal-inst-number> (option -L) instances no "
+				+ "further splitting is done. Also if the split would leave one "
+				+ "side empty, the branch is not split any further even if the "
+				+ "instances in the resulting node are more than " + "<maximal-inst-number> instances.\n"
+				+ "**PLEASE NOTE:** The algorithm can not handle missing values, so it "
+				+ "is advisable to run ReplaceMissingValues filter if there are any "
+				+ "missing values in the dataset.\n\n" + "For more information see:\n\n";
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/LinearNNSearch.java b/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/LinearNNSearch.java
new file mode 100644
index 000000000..975acc08c
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/LinearNNSearch.java
@@ -0,0 +1,284 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ *    LinearNNSearch.java
+ *    Copyright (C) 1999-2012 University of Waikato
+ */
+
+package moa.learners.predictors.lazy.neighboursearch;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+//import weka.core.Option;
+//import weka.core.RevisionUtils;
+//import weka.core.Utils;
+
+/**
+ * <!-- globalinfo-start --> Class implementing the brute force search algorithm
+ * for nearest neighbour search.
+ * <p/>
+ * <!-- globalinfo-end -->
+ * 
+ * <!-- options-start --> Valid options are:
+ * <p/>
+ *
+ * <pre>
+ *  -S
+ *  Skip identical instances (distances equal to zero).
+ * </pre>
+ * 
+ * <!-- options-end -->
+ *
+ * @author Ashraf M. Kibriya (amk14[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
+ * @version $Revision: 8034 $
+ */
+public class LinearNNSearch extends NearestNeighbourSearch {
+
+	/** for serialization. */
+	private static final long serialVersionUID = 1915484723703917241L;
+
+	/**
+	 * Array holding the distances of the nearest neighbours. It is filled up both
+	 * by nearestNeighbour() and kNearestNeighbours().
+	 */
+	protected double[] m_Distances;
+
+	/**
+	 * Whether to skip instances from the neighbours that are identical to the query
+	 * instance.
+	 */
+	protected boolean m_SkipIdentical = false;
+
+	/**
+	 * Constructor. Needs setInstances(Instances) to be called before the class is
+	 * usable.
+	 */
+	public LinearNNSearch() {
+		super();
+	}
+
+	/**
+	 * Constructor that uses the supplied set of instances.
+	 * 
+	 * @param insts the instances to use
+	 */
+	public LinearNNSearch(InstancesHeader insts) {
+		super(insts);
+		m_DistanceFunction.setInstances(insts);
+	}
+
+	/**
+	 * Returns a string describing this nearest neighbour search algorithm.
+	 * 
+	 * @return a description of the algorithm for displaying in the
+	 *         explorer/experimenter gui
+	 */
+	@Override
+	public String globalInfo() {
+		return "Class implementing the brute force search algorithm for nearest " + "neighbour search.";
+	}
+
+	/**
+	 * Returns the tip text for this property.
+	 * 
+	 * @return tip text for this property suitable for displaying in the
+	 *         explorer/experimenter gui
+	 */
+	public String skipIdenticalTipText() {
+		return "Whether to skip identical instances (with distance 0 to the target)";
+	}
+
+	/**
+	 * Sets the property to skip identical instances (with distance zero from the
+	 * target) from the set of neighbours returned.
+	 * 
+	 * @param skip if true, identical intances are skipped
+	 */
+	public void setSkipIdentical(boolean skip) {
+		m_SkipIdentical = skip;
+	}
+
+	/**
+	 * Gets whether if identical instances are skipped from the neighbourhood.
+	 * 
+	 * @return true if identical instances are skipped
+	 */
+	public boolean getSkipIdentical() {
+		return m_SkipIdentical;
+	}
+
+	/**
+	 * Returns the nearest instance in the current neighbourhood to the supplied
+	 * instance.
+	 * 
+	 * @param target The instance to find the nearest neighbour for.
+	 * @return the nearest instance
+	 * @throws Exception if the nearest neighbour could not be found.
+	 */
+	@Override
+	public Instance nearestNeighbour(Instance target) throws Exception {
+		return (kNearestNeighbours(target, 1)).instance(0);
+	}
+
+	/**
+	 * Returns k nearest instances in the current neighbourhood to the supplied
+	 * instance.
+	 * 
+	 * @param target The instance to find the k nearest neighbours for.
+	 * @param kNN    The number of nearest neighbours to find.
+	 * @return the k nearest neighbors
+	 * @throws Exception if the neighbours could not be found.
+	 */
+	@Override
+	public InstancesHeader kNearestNeighbours(Instance target, int kNN) throws Exception {
+
+		// debug
+		boolean print = false;
+
+		MyHeap heap = new MyHeap(kNN);
+		double distance;
+		int firstkNN = 0;
+		for (int i = 0; i < m_Instances.numInstances(); i++) {
+			if (target == m_Instances.instance(i)) // for hold-one-out cross-validation
+				continue;
+			if (firstkNN < kNN) {
+				if (print)
+					System.out.println("K(a): " + (heap.size() + heap.noOfKthNearest()));
+				distance = m_DistanceFunction.distance(target, m_Instances.instance(i), Double.POSITIVE_INFINITY);
+				if (distance == 0.0 && m_SkipIdentical)
+					if (i < m_Instances.numInstances() - 1)
+						continue;
+					else
+						heap.put(i, distance);
+				heap.put(i, distance);
+				firstkNN++;
+			} else {
+				MyHeapElement temp = heap.peek();
+				if (print)
+					System.out.println("K(b): " + (heap.size() + heap.noOfKthNearest()));
+				distance = m_DistanceFunction.distance(target, m_Instances.instance(i), temp.distance);
+				if (distance == 0.0 && m_SkipIdentical)
+					continue;
+				if (distance < temp.distance) {
+					heap.putBySubstitute(i, distance);
+				} else if (distance == temp.distance) {
+					heap.putKthNearest(i, distance);
+				}
+
+			}
+		}
+
+		InstancesHeader neighbours = new InstancesHeader(m_Instances, (heap.size() + heap.noOfKthNearest()));
+		m_Distances = new double[heap.size() + heap.noOfKthNearest()];
+		int[] indices = new int[heap.size() + heap.noOfKthNearest()];
+		int i = 1;
+		MyHeapElement h;
+		while (heap.noOfKthNearest() > 0) {
+			h = heap.getKthNearest();
+			indices[indices.length - i] = h.index;
+			m_Distances[indices.length - i] = h.distance;
+			i++;
+		}
+		while (heap.size() > 0) {
+			h = heap.get();
+			indices[indices.length - i] = h.index;
+			m_Distances[indices.length - i] = h.distance;
+			i++;
+		}
+
+		m_DistanceFunction.postProcessDistances(m_Distances);
+
+		for (int k = 0; k < indices.length; k++) {
+			neighbours.add(m_Instances.instance(indices[k]));
+		}
+
+		return neighbours;
+	}
+
+	/**
+	 * Returns the distances of the k nearest neighbours. The kNearestNeighbours or
+	 * nearestNeighbour must always be called before calling this function. If this
+	 * function is called before calling either the kNearestNeighbours or the
+	 * nearestNeighbour, then it throws an exception. If, however, if either of the
+	 * nearestNeighbour functions are called at any point in the past then no
+	 * exception is thrown and the distances of the training set from the last
+	 * supplied target instance (to either one of the nearestNeighbour functions)
+	 * is/are returned.
+	 *
+	 * @return array containing the distances of the nearestNeighbours. The length
+	 *         and ordering of the array is the same as that of the instances
+	 *         returned by nearestNeighbour functions.
+	 * @throws Exception if called before calling kNearestNeighbours or
+	 *                   nearestNeighbours.
+	 */
+	@Override
+	public double[] getDistances() throws Exception {
+		if (m_Distances == null)
+			throw new Exception(
+					"No distances available. Please call either " + "kNearestNeighbours or nearestNeighbours first.");
+		return m_Distances;
+	}
+
+	/**
+	 * Sets the instances comprising the current neighbourhood.
+	 * 
+	 * @param insts The set of instances on which the nearest neighbour search is
+	 *              carried out. Usually this set is the training set.
+	 * @throws Exception if setting of instances fails
+	 */
+	@Override
+	public void setInstances(InstancesHeader insts) throws Exception {
+		m_Instances = insts;
+		m_DistanceFunction.setInstances(insts);
+	}
+
+	/**
+	 * Updates the LinearNNSearch to cater for the new added instance. This
+	 * implementation only updates the ranges of the DistanceFunction class, since
+	 * our set of instances is passed by reference and should already have the newly
+	 * added instance.
+	 * 
+	 * @param ins The instance to add. Usually this is the instance that is added to
+	 *            our neighbourhood i.e. the training instances.
+	 * @throws Exception if the given instances are null
+	 */
+	@Override
+	public void update(Instance ins) throws Exception {
+		if (m_Instances == null)
+			throw new Exception(
+					"No instances supplied yet. Cannot update without" + "supplying a set of instances first.");
+		m_DistanceFunction.update(ins);
+	}
+
+	/**
+	 * Adds the given instance info. This implementation updates the range
+	 * datastructures of the DistanceFunction class.
+	 * 
+	 * @param ins The instance to add the information of. Usually this is the test
+	 *            instance supplied to update the range of attributes in the
+	 *            distance function.
+	 */
+	@Override
+	public void addInstanceInfo(Instance ins) {
+		if (m_Instances != null)
+			try {
+				update(ins);
+			} catch (Exception ex) {
+				ex.printStackTrace();
+			}
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/NearestNeighbourSearch.java b/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/NearestNeighbourSearch.java
new file mode 100644
index 000000000..86473b33e
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/NearestNeighbourSearch.java
@@ -0,0 +1,717 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ *    NearestNeighbourSearch.java
+ *    Copyright (C) 1999-2012 University of Waikato
+ */
+
+package moa.learners.predictors.lazy.neighboursearch;
+
+import java.io.Serializable;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
+/**
+ * Abstract class for nearest neighbour search. All algorithms (classes) that do
+ * nearest neighbour search should extend this class.
+ *
+ * @author Ashraf M. Kibriya (amk14[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
+ * @version $Revision: 8034 $
+ */
+public abstract class NearestNeighbourSearch implements Serializable {
+
+	/**
+	 * A class for a heap to store the nearest k neighbours to an instance. The heap
+	 * also takes care of cases where multiple neighbours are the same distance
+	 * away. i.e. the minimum size of the heap is k.
+	 *
+	 * @author Ashraf M. Kibriya (amk14[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
+	 * @version $Revision: 8034 $
+	 */
+	protected class MyHeap {
+
+		/** the heap. */
+		MyHeapElement m_heap[] = null;
+
+		/**
+		 * constructor.
+		 * 
+		 * @param maxSize the maximum size of the heap
+		 */
+		public MyHeap(int maxSize) {
+			if ((maxSize % 2) == 0)
+				maxSize++;
+
+			m_heap = new MyHeapElement[maxSize + 1];
+			m_heap[0] = new MyHeapElement(0, 0);
+		}
+
+		/**
+		 * returns the size of the heap.
+		 * 
+		 * @return the size
+		 */
+		public int size() {
+			return m_heap[0].index;
+		}
+
+		/**
+		 * peeks at the first element.
+		 * 
+		 * @return the first element
+		 */
+		public MyHeapElement peek() {
+			return m_heap[1];
+		}
+
+		/**
+		 * returns the first element and removes it from the heap.
+		 * 
+		 * @return the first element
+		 * @throws Exception if no elements in heap
+		 */
+		public MyHeapElement get() throws Exception {
+			if (m_heap[0].index == 0)
+				throw new Exception("No elements present in the heap");
+			MyHeapElement r = m_heap[1];
+			m_heap[1] = m_heap[m_heap[0].index];
+			m_heap[0].index--;
+			downheap();
+			return r;
+		}
+
+		/**
+		 * adds the value to the heap.
+		 * 
+		 * @param i the index
+		 * @param d the distance
+		 * @throws Exception if the heap gets too large
+		 */
+		public void put(int i, double d) throws Exception {
+			if ((m_heap[0].index + 1) > (m_heap.length - 1))
+				throw new Exception("the number of elements cannot exceed the " + "initially set maximum limit");
+			m_heap[0].index++;
+			m_heap[m_heap[0].index] = new MyHeapElement(i, d);
+			upheap();
+		}
+
+		/**
+		 * Puts an element by substituting it in place of the top most element.
+		 * 
+		 * @param i the index
+		 * @param d the distance
+		 * @throws Exception if distance is smaller than that of the head element
+		 */
+		public void putBySubstitute(int i, double d) throws Exception {
+			MyHeapElement head = get();
+			put(i, d);
+			// System.out.println("previous: "+head.distance+" current:
+			// "+m_heap[1].distance);
+			if (head.distance == m_heap[1].distance) { // Utils.eq(head.distance, m_heap[1].distance)) {
+				putKthNearest(head.index, head.distance);
+			} else if (head.distance > m_heap[1].distance) { // Utils.gr(head.distance, m_heap[1].distance)) {
+				m_KthNearest = null;
+				m_KthNearestSize = 0;
+				initSize = 10;
+			} else if (head.distance < m_heap[1].distance) {
+				throw new Exception("The substituted element is smaller than the "
+						+ "head element. put() should have been called " + "in place of putBySubstitute()");
+			}
+		}
+
+		/** the kth nearest ones. */
+		MyHeapElement m_KthNearest[] = null;
+
+		/** The number of kth nearest elements. */
+		int m_KthNearestSize = 0;
+
+		/** the initial size of the heap. */
+		int initSize = 10;
+
+		/**
+		 * returns the number of k nearest.
+		 * 
+		 * @return the number of k nearest
+		 * @see #m_KthNearestSize
+		 */
+		public int noOfKthNearest() {
+			return m_KthNearestSize;
+		}
+
+		/**
+		 * Stores kth nearest elements (if there are more than one).
+		 * 
+		 * @param i the index
+		 * @param d the distance
+		 */
+		public void putKthNearest(int i, double d) {
+			if (m_KthNearest == null) {
+				m_KthNearest = new MyHeapElement[initSize];
+			}
+			if (m_KthNearestSize >= m_KthNearest.length) {
+				initSize += initSize;
+				MyHeapElement temp[] = new MyHeapElement[initSize];
+				System.arraycopy(m_KthNearest, 0, temp, 0, m_KthNearest.length);
+				m_KthNearest = temp;
+			}
+			m_KthNearest[m_KthNearestSize++] = new MyHeapElement(i, d);
+		}
+
+		/**
+		 * returns the kth nearest element or null if none there.
+		 * 
+		 * @return the kth nearest element
+		 */
+		public MyHeapElement getKthNearest() {
+			if (m_KthNearestSize == 0)
+				return null;
+			m_KthNearestSize--;
+			return m_KthNearest[m_KthNearestSize];
+		}
+
+		/**
+		 * performs upheap operation for the heap to maintian its properties.
+		 */
+		protected void upheap() {
+			int i = m_heap[0].index;
+			MyHeapElement temp;
+			while (i > 1 && m_heap[i].distance > m_heap[i / 2].distance) {
+				temp = m_heap[i];
+				m_heap[i] = m_heap[i / 2];
+				i = i / 2;
+				m_heap[i] = temp; // this is i/2 done here to avoid another division.
+			}
+		}
+
+		/**
+		 * performs downheap operation for the heap to maintian its properties.
+		 */
+		protected void downheap() {
+			int i = 1;
+			MyHeapElement temp;
+			while (((2 * i) <= m_heap[0].index && m_heap[i].distance < m_heap[2 * i].distance)
+					|| ((2 * i + 1) <= m_heap[0].index && m_heap[i].distance < m_heap[2 * i + 1].distance)) {
+				if ((2 * i + 1) <= m_heap[0].index) {
+					if (m_heap[2 * i].distance > m_heap[2 * i + 1].distance) {
+						temp = m_heap[i];
+						m_heap[i] = m_heap[2 * i];
+						i = 2 * i;
+						m_heap[i] = temp;
+					} else {
+						temp = m_heap[i];
+						m_heap[i] = m_heap[2 * i + 1];
+						i = 2 * i + 1;
+						m_heap[i] = temp;
+					}
+				} else {
+					temp = m_heap[i];
+					m_heap[i] = m_heap[2 * i];
+					i = 2 * i;
+					m_heap[i] = temp;
+				}
+			}
+		}
+
+		/**
+		 * returns the total size.
+		 * 
+		 * @return the total size
+		 */
+		public int totalSize() {
+			return size() + noOfKthNearest();
+		}
+
+	}
+
+	/**
+	 * A class for storing data about a neighboring instance.
+	 *
+	 * @author Ashraf M. Kibriya (amk14[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
+	 * @version $Revision: 8034 $
+	 */
+	protected class MyHeapElement {
+
+		/** the index of this element. */
+		public int index;
+
+		/** the distance of this element. */
+		public double distance;
+
+		/**
+		 * constructor.
+		 * 
+		 * @param i the index
+		 * @param d the distance
+		 */
+		public MyHeapElement(int i, double d) {
+			distance = d;
+			index = i;
+		}
+
+	}
+
+	/**
+	 * A class for storing data about a neighboring instance.
+	 *
+	 * @author Ashraf M. Kibriya (amk14[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
+	 * @version $Revision: 8034 $
+	 */ // better to change this into a heap element
+	protected class NeighborNode {
+
+		/** The neighbor instance. */
+		public Instance m_Instance;
+
+		/** The distance from the current instance to this neighbor. */
+		public double m_Distance;
+
+		/** A link to the next neighbor instance. */
+		public NeighborNode m_Next;
+
+		/**
+		 * Create a new neighbor node.
+		 *
+		 * @param distance the distance to the neighbor
+		 * @param instance the neighbor instance
+		 * @param next     the next neighbor node
+		 */
+		public NeighborNode(double distance, Instance instance, NeighborNode next) {
+			m_Distance = distance;
+			m_Instance = instance;
+			m_Next = next;
+		}
+
+		/**
+		 * Create a new neighbor node that doesn't link to any other nodes.
+		 *
+		 * @param distance the distance to the neighbor
+		 * @param instance the neighbor instance
+		 */
+		public NeighborNode(double distance, Instance instance) {
+
+			this(distance, instance, null);
+		}
+
+	}
+
+	/**
+	 * A class for a linked list to store the nearest k neighbours to an instance.
+	 * We use a list so that we can take care of cases where multiple neighbours are
+	 * the same distance away. i.e. the minimum length of the list is k.
+	 *
+	 * @author Ashraf M. Kibriya (amk14[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
+	 * @version $Revision: 8034 $
+	 */ // better to change this into a heap
+	protected class NeighborList {
+
+		/** The first node in the list. */
+		protected NeighborNode m_First;
+
+		/** The last node in the list. */
+		protected NeighborNode m_Last;
+
+		/** The number of nodes to attempt to maintain in the list. */
+		protected int m_Length = 1;
+
+		/**
+		 * Creates the neighborlist with a desired length.
+		 *
+		 * @param length the length of list to attempt to maintain
+		 */
+		public NeighborList(int length) {
+			m_Length = length;
+		}
+
+		/**
+		 * Gets whether the list is empty.
+		 *
+		 * @return true if list is empty
+		 */
+		public boolean isEmpty() {
+			return (m_First == null);
+		}
+
+		/**
+		 * Gets the current length of the list.
+		 *
+		 * @return the current length of the list
+		 */
+		public int currentLength() {
+			int i = 0;
+			NeighborNode current = m_First;
+			while (current != null) {
+				i++;
+				current = current.m_Next;
+			}
+			return i;
+		}
+
+		/**
+		 * Inserts an instance neighbor into the list, maintaining the list sorted by
+		 * distance.
+		 *
+		 * @param distance the distance to the instance
+		 * @param instance the neighboring instance
+		 */
+		public void insertSorted(double distance, Instance instance) {
+
+			if (isEmpty()) {
+				m_First = m_Last = new NeighborNode(distance, instance);
+			} else {
+				NeighborNode current = m_First;
+				if (distance < m_First.m_Distance) {// Insert at head
+					m_First = new NeighborNode(distance, instance, m_First);
+				} else { // Insert further down the list
+					for (; (current.m_Next != null) && (current.m_Next.m_Distance < distance); current = current.m_Next)
+						;
+					current.m_Next = new NeighborNode(distance, instance, current.m_Next);
+					if (current.equals(m_Last)) {
+						m_Last = current.m_Next;
+					}
+				}
+
+				// Trip down the list until we've got k list elements (or more if the
+				// distance to the last elements is the same).
+				int valcount = 0;
+				for (current = m_First; current.m_Next != null; current = current.m_Next) {
+					valcount++;
+					if ((valcount >= m_Length) && (current.m_Distance != current.m_Next.m_Distance)) {
+						m_Last = current;
+						current.m_Next = null;
+						break;
+					}
+				}
+			}
+		}
+
+		/**
+		 * Prunes the list to contain the k nearest neighbors. If there are multiple
+		 * neighbors at the k'th distance, all will be kept.
+		 *
+		 * @param k the number of neighbors to keep in the list.
+		 */
+		public void pruneToK(int k) {
+
+			if (isEmpty()) {
+				return;
+			}
+			if (k < 1) {
+				k = 1;
+			}
+			int currentK = 0;
+			double currentDist = m_First.m_Distance;
+			NeighborNode current = m_First;
+			for (; current.m_Next != null; current = current.m_Next) {
+				currentK++;
+				currentDist = current.m_Distance;
+				if ((currentK >= k) && (currentDist != current.m_Next.m_Distance)) {
+					m_Last = current;
+					current.m_Next = null;
+					break;
+				}
+			}
+		}
+
+		/**
+		 * Prints out the contents of the neighborlist.
+		 */
+		public void printList() {
+
+			if (isEmpty()) {
+				System.out.println("Empty list");
+			} else {
+				NeighborNode current = m_First;
+				while (current != null) {
+					System.out.println("Node: instance " + current.m_Instance + ", distance " + current.m_Distance);
+					current = current.m_Next;
+				}
+				System.out.println();
+			}
+		}
+
+		/**
+		 * returns the first element in the list.
+		 * 
+		 * @return the first element
+		 */
+		public NeighborNode getFirst() {
+			return m_First;
+		}
+
+		/**
+		 * returns the last element in the list.
+		 * 
+		 * @return the last element
+		 */
+		public NeighborNode getLast() {
+			return m_Last;
+		}
+
+	}
+
+	/** The neighbourhood of instances to find neighbours in. */
+	protected InstancesHeader m_Instances;
+
+	/** The number of neighbours to find. */
+	protected int m_kNN;
+
+	/** the distance function used. */
+	protected DistanceFunction m_DistanceFunction = new EuclideanDistance();
+
+	/** Should we measure Performance. */
+	protected boolean m_MeasurePerformance = false;
+
+	/**
+	 * Constructor.
+	 */
+	public NearestNeighbourSearch() {
+	}
+
+	/**
+	 * Constructor.
+	 * 
+	 * @param insts The set of instances that constitute the neighbourhood.
+	 */
+	public NearestNeighbourSearch(InstancesHeader insts) {
+		this();
+		m_Instances = insts;
+	}
+
+	/**
+	 * Returns a string describing this nearest neighbour search algorithm.
+	 * 
+	 * @return a description of the algorithm for displaying in the
+	 *         explorer/experimenter gui
+	 */
+	public String globalInfo() {
+		return "Abstract class for nearest neighbour search. All algorithms (classes) that "
+				+ "do nearest neighbour search should extend this class.";
+	}
+
+	/**
+	 * Returns the tip text for this property.
+	 * 
+	 * @return tip text for this property suitable for displaying in the
+	 *         explorer/experimenter gui
+	 */
+	public String distanceFunctionTipText() {
+		return "The distance function to use for finding neighbours " + "(default: weka.core.EuclideanDistance). ";
+	}
+
+	/**
+	 * returns the distance function currently in use.
+	 * 
+	 * @return the distance function
+	 */
+	public DistanceFunction getDistanceFunction() {
+		return m_DistanceFunction;
+	}
+
+	/**
+	 * sets the distance function to use for nearest neighbour search.
+	 * 
+	 * @param df the new distance function to use
+	 * @throws Exception if instances cannot be processed
+	 */
+	public void setDistanceFunction(DistanceFunction df) throws Exception {
+		m_DistanceFunction = df;
+	}
+
+	/**
+	 * Returns the tip text for this property.
+	 * 
+	 * @return tip text for this property suitable for displaying in the
+	 *         explorer/experimenter gui
+	 */
+	public String measurePerformanceTipText() {
+		return "Whether to calculate performance statistics " + "for the NN search or not";
+	}
+
+	/**
+	 * Gets whether performance statistics are being calculated or not.
+	 * 
+	 * @return true if the measure performance is calculated
+	 */
+	public boolean getMeasurePerformance() {
+		return m_MeasurePerformance;
+	}
+
+	/**
+	 * Returns the nearest instance in the current neighbourhood to the supplied
+	 * instance.
+	 * 
+	 * @param target The instance to find the nearest neighbour for.
+	 * @return the nearest neighbor
+	 * @throws Exception if the nearest neighbour could not be found.
+	 */
+	public abstract Instance nearestNeighbour(Instance target) throws Exception;
+
+	/**
+	 * Returns k nearest instances in the current neighbourhood to the supplied
+	 * instance.
+	 * 
+	 * @param target The instance to find the k nearest neighbours for.
+	 * @param k      The number of nearest neighbours to find.
+	 * @return the k nearest neighbors
+	 * @throws Exception if the neighbours could not be found.
+	 */
+	public abstract InstancesHeader kNearestNeighbours(Instance target, int k) throws Exception;
+
+	/**
+	 * Returns the distances of the k nearest neighbours. The kNearestNeighbours or
+	 * nearestNeighbour needs to be called first for this to work.
+	 *
+	 * @return the distances
+	 * @throws Exception if called before calling kNearestNeighbours or
+	 *                   nearestNeighbours.
+	 */
+	public abstract double[] getDistances() throws Exception;
+
+	/**
+	 * Updates the NearNeighbourSearch algorithm for the new added instance. P.S.:
+	 * The method assumes the instance has already been added to the m_Instances
+	 * object by the caller.
+	 * 
+	 * @param ins the instance to add
+	 * @throws Exception if updating fails
+	 */
+	public abstract void update(Instance ins) throws Exception;
+
+	/**
+	 * Adds information from the given instance without modifying the datastructure
+	 * a lot.
+	 * 
+	 * @param ins the instance to add the information from
+	 */
+	public void addInstanceInfo(Instance ins) {
+	}
+
+	/**
+	 * Sets the instances.
+	 * 
+	 * @param insts the instances to use
+	 * @throws Exception if setting fails
+	 */
+	public void setInstances(InstancesHeader insts) throws Exception {
+		m_Instances = insts;
+	}
+
+	/**
+	 * returns the instances currently set.
+	 * 
+	 * @return the current instances
+	 */
+	public InstancesHeader getInstances() {
+		return m_Instances;
+	}
+
+	/**
+	 * sorts the two given arrays.
+	 * 
+	 * @param arrayToSort The array sorting should be based on.
+	 * @param linkedArray The array that should have the same ordering as
+	 *                    arrayToSort.
+	 */
+	public static void combSort11(double arrayToSort[], int linkedArray[]) {
+		int switches, j, top, gap;
+		double hold1;
+		int hold2;
+		gap = arrayToSort.length;
+		do {
+			gap = (int) (gap / 1.3);
+			switch (gap) {
+			case 0:
+				gap = 1;
+				break;
+			case 9:
+			case 10:
+				gap = 11;
+				break;
+			default:
+				break;
+			}
+			switches = 0;
+			top = arrayToSort.length - gap;
+			for (int i = 0; i < top; i++) {
+				j = i + gap;
+				if (arrayToSort[i] > arrayToSort[j]) {
+					hold1 = arrayToSort[i];
+					hold2 = linkedArray[i];
+					arrayToSort[i] = arrayToSort[j];
+					linkedArray[i] = linkedArray[j];
+					arrayToSort[j] = hold1;
+					linkedArray[j] = hold2;
+					switches++;
+				} // endif
+			} // endfor
+		} while (switches > 0 || gap > 1);
+	}
+
+	/**
+	 * Partitions the instances around a pivot. Used by quicksort and
+	 * kthSmallestValue.
+	 *
+	 * @param arrayToSort the array of doubles to be sorted
+	 * @param linkedArray the linked array
+	 * @param l           the first index of the subset
+	 * @param r           the last index of the subset
+	 * @return the index of the middle element
+	 */
+	protected static int partition(double[] arrayToSort, double[] linkedArray, int l, int r) {
+		double pivot = arrayToSort[(l + r) / 2];
+		double help;
+
+		while (l < r) {
+			while ((arrayToSort[l] < pivot) && (l < r)) {
+				l++;
+			}
+			while ((arrayToSort[r] > pivot) && (l < r)) {
+				r--;
+			}
+			if (l < r) {
+				help = arrayToSort[l];
+				arrayToSort[l] = arrayToSort[r];
+				arrayToSort[r] = help;
+				help = linkedArray[l];
+				linkedArray[l] = linkedArray[r];
+				linkedArray[r] = help;
+				l++;
+				r--;
+			}
+		}
+		if ((l == r) && (arrayToSort[r] > pivot)) {
+			r--;
+		}
+
+		return r;
+	}
+
+	/**
+	 * performs quicksort.
+	 * 
+	 * @param arrayToSort the array to sort
+	 * @param linkedArray the linked array
+	 * @param left        the first index of the subset
+	 * @param right       the last index of the subset
+	 */
+	public static void quickSort(double[] arrayToSort, double[] linkedArray, int left, int right) {
+		if (left < right) {
+			int middle = partition(arrayToSort, linkedArray, left, right);
+			quickSort(arrayToSort, linkedArray, left, middle);
+			quickSort(arrayToSort, linkedArray, middle + 1, right);
+		}
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/NormalizableDistance.java b/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/NormalizableDistance.java
new file mode 100644
index 000000000..12ec122fd
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/NormalizableDistance.java
@@ -0,0 +1,702 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ *    NormalizableDistance.java
+ *    Copyright (C) 2007-2012 University of Waikato, Hamilton, New Zealand
+ *
+ */
+
+package moa.learners.predictors.lazy.neighboursearch;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
+/**
+ * Represents the abstract ancestor for normalizable distance functions, like
+ * Euclidean or Manhattan distance.
+ *
+ * @author Fracpete (fracpete at waikato dot ac dot nz)
+ * @author Gabi Schmidberger (gabi@cs.waikato.ac.nz) -- original code from
+ *         weka.core.EuclideanDistance
+ * @author Ashraf M. Kibriya (amk14@cs.waikato.ac.nz) -- original code from
+ *         weka.core.EuclideanDistance
+ * @version $Revision: 8034 $
+ */
+public abstract class NormalizableDistance implements DistanceFunction {
+
+	/** Index in ranges for MIN. */
+	public static final int R_MIN = 0;
+
+	/** Index in ranges for MAX. */
+
+	public static final int R_MAX = 1;
+
+	/** Index in ranges for WIDTH. */
+	public static final int R_WIDTH = 2;
+
+	/** the instances used internally. */
+	protected InstancesHeader m_Data = null;
+
+	/** True if normalization is turned off (default false). */
+	protected boolean m_DontNormalize = false;
+
+	/** The range of the attributes. */
+	protected double[][] m_Ranges;
+
+	/** The range of attributes to use for calculating the distance. */
+//  protected Range m_AttributeIndices = new Range("first-last");
+
+	/** The boolean flags, whether an attribute will be used or not. */
+	protected boolean[] m_ActiveIndices;
+
+	/** Whether all the necessary preparations have been done. */
+	protected boolean m_Validated;
+
+	/**
+	 * Invalidates the distance function, Instances must be still set.
+	 */
+	public NormalizableDistance() {
+		invalidate();
+	}
+
+	/**
+	 * Initializes the distance function and automatically initializes the ranges.
+	 * 
+	 * @param data the instances the distance function should work on
+	 */
+	public NormalizableDistance(InstancesHeader data) {
+		setInstances(data);
+	}
+
+	/**
+	 * Returns a string describing this object.
+	 * 
+	 * @return a description of the evaluator suitable for displaying in the
+	 *         explorer/experimenter gui
+	 */
+	public abstract String globalInfo();
+
+	/**
+	 * Returns the tip text for this property.
+	 * 
+	 * @return tip text for this property suitable for displaying in the
+	 *         explorer/experimenter gui
+	 */
+	public String dontNormalizeTipText() {
+		return "Whether if the normalization of attributes should be turned off "
+				+ "for distance calculation (Default: false i.e. attribute values " + "are normalized). ";
+	}
+
+	/**
+	 * Sets whether if the attribute values are to be normalized in distance
+	 * calculation.
+	 * 
+	 * @param dontNormalize if true the values are not normalized
+	 */
+	public void setDontNormalize(boolean dontNormalize) {
+		m_DontNormalize = dontNormalize;
+		invalidate();
+	}
+
+	/**
+	 * Gets whether if the attribute values are to be normazlied in distance
+	 * calculation. (default false i.e. attribute values are normalized.)
+	 * 
+	 * @return false if values get normalized
+	 */
+	public boolean getDontNormalize() {
+		return m_DontNormalize;
+	}
+
+	/**
+	 * Returns the tip text for this property.
+	 *
+	 * @return tip text for this property suitable for displaying in the
+	 *         explorer/experimenter gui
+	 */
+	public String attributeIndicesTipText() {
+		return "Specify range of attributes to act on. " + "This is a comma separated list of attribute indices, with "
+				+ "\"first\" and \"last\" valid values. Specify an inclusive "
+				+ "range with \"-\". E.g: \"first-3,5,6-10,last\".";
+	}
+
+	/**
+	 * Sets the range of attributes to use in the calculation of the distance. The
+	 * indices start from 1, 'first' and 'last' are valid as well. E.g.:
+	 * first-3,5,6-last
+	 * 
+	 * @param value the new attribute index range
+	 */
+	@Override
+	public void setAttributeIndices(String value) {
+		// m_AttributeIndices.setRanges(value);
+		invalidate();
+	}
+
+	/**
+	 * Gets the range of attributes used in the calculation of the distance.
+	 * 
+	 * @return the attribute index range
+	 */
+	@Override
+	public String getAttributeIndices() {
+		return null; // m_AttributeIndices.getRanges();
+	}
+
+	/**
+	 * Returns the tip text for this property.
+	 *
+	 * @return tip text for this property suitable for displaying in the
+	 *         explorer/experimenter gui
+	 */
+	public String invertSelectionTipText() {
+		return "Set attribute selection mode. If false, only selected "
+				+ "attributes in the range will be used in the distance calculation; if "
+				+ "true, only non-selected attributes will be used for the calculation.";
+	}
+
+	/**
+	 * Sets whether the matching sense of attribute indices is inverted or not.
+	 * 
+	 * @param value if true the matching sense is inverted
+	 */
+	@Override
+	public void setInvertSelection(boolean value) {
+		// m_AttributeIndices.setInvert(value);
+		invalidate();
+	}
+
+	/**
+	 * Gets whether the matching sense of attribute indices is inverted or not.
+	 * 
+	 * @return true if the matching sense is inverted
+	 */
+	@Override
+	public boolean getInvertSelection() {
+		return false; // m_AttributeIndices.getInvert();
+	}
+
+	/**
+	 * invalidates all initializations.
+	 */
+	protected void invalidate() {
+		m_Validated = false;
+	}
+
+	/**
+	 * performs the initializations if necessary.
+	 */
+	protected void validate() {
+		if (!m_Validated) {
+			initialize();
+			m_Validated = true;
+		}
+	}
+
+	/**
+	 * initializes the ranges and the attributes being used.
+	 */
+	protected void initialize() {
+		initializeAttributeIndices();
+		initializeRanges();
+	}
+
+	/**
+	 * initializes the attribute indices.
+	 */
+	protected void initializeAttributeIndices() {
+		// m_AttributeIndices.setUpper(m_Data.numAttributes() - 1);
+		m_ActiveIndices = new boolean[m_Data.numAttributes()];
+		for (int i = 0; i < m_ActiveIndices.length; i++)
+			m_ActiveIndices[i] = true; // m_AttributeIndices.isInRange(i);
+	}
+
+	/**
+	 * Sets the instances.
+	 * 
+	 * @param insts the instances to use
+	 */
+	@Override
+	public void setInstances(InstancesHeader insts) {
+		m_Data = insts;
+		invalidate();
+	}
+
+	/**
+	 * returns the instances currently set.
+	 * 
+	 * @return the current instances
+	 */
+	@Override
+	public InstancesHeader getInstances() {
+		return m_Data;
+	}
+
+	/**
+	 * Does nothing, derived classes may override it though.
+	 * 
+	 * @param distances the distances to post-process
+	 */
+	@Override
+	public void postProcessDistances(double[] distances) {
+	}
+
+	/**
+	 * Update the distance function (if necessary) for the newly added instance.
+	 * 
+	 * @param ins the instance to add
+	 */
+	@Override
+	public void update(Instance ins) {
+		validate();
+
+		m_Ranges = updateRanges(ins, m_Ranges);
+	}
+
+	/**
+	 * Calculates the distance between two instances.
+	 * 
+	 * @param first  the first instance
+	 * @param second the second instance
+	 * @return the distance between the two given instances
+	 */
+	@Override
+	public double distance(Instance first, Instance second) {
+		return distance(first, second, Double.POSITIVE_INFINITY);
+	}
+
+	/**
+	 * Calculates the distance between two instances. Offers speed up (if the
+	 * distance function class in use supports it) in nearest neighbour search by
+	 * taking into account the cutOff or maximum distance. Depending on the distance
+	 * function class, post processing of the distances by
+	 * postProcessDistances(double []) may be required if this function is used.
+	 *
+	 * @param first       the first instance
+	 * @param second      the second instance
+	 * @param cutOffValue If the distance being calculated becomes larger than
+	 *                    cutOffValue then the rest of the calculation is discarded.
+	 * @return the distance between the two given instances or
+	 *         Double.POSITIVE_INFINITY if the distance being calculated becomes
+	 *         larger than cutOffValue.
+	 */
+	@Override
+	public double distance(Instance first, Instance second, double cutOffValue) {
+		double distance = 0;
+		int firstI, secondI;
+		int firstNumValues = first.numValues();
+		int secondNumValues = second.numValues();
+		int numAttributes = m_Data.numAttributes();
+		int classIndex = m_Data.classIndex();
+
+		validate();
+
+		for (int p1 = 0, p2 = 0; p1 < firstNumValues || p2 < secondNumValues;) {
+			if (p1 >= firstNumValues)
+				firstI = numAttributes;
+			else
+				firstI = first.index(p1);
+
+			if (p2 >= secondNumValues)
+				secondI = numAttributes;
+			else
+				secondI = second.index(p2);
+
+			if (firstI == classIndex) {
+				p1++;
+				continue;
+			}
+			if ((firstI < numAttributes) && !m_ActiveIndices[firstI]) {
+				p1++;
+				continue;
+			}
+
+			if (secondI == classIndex) {
+				p2++;
+				continue;
+			}
+			if ((secondI < numAttributes) && !m_ActiveIndices[secondI]) {
+				p2++;
+				continue;
+			}
+
+			double diff;
+
+			if (firstI == secondI) {
+				diff = difference(firstI, first.valueSparse(p1), second.valueSparse(p2));
+				p1++;
+				p2++;
+			} else if (firstI > secondI) {
+				diff = difference(secondI, 0, second.valueSparse(p2));
+				p2++;
+			} else {
+				diff = difference(firstI, first.valueSparse(p1), 0);
+				p1++;
+			}
+
+			distance = updateDistance(distance, diff);
+			if (distance > cutOffValue)
+				return Double.POSITIVE_INFINITY;
+		}
+
+		return distance;
+	}
+
+	/**
+	 * Updates the current distance calculated so far with the new difference
+	 * between two attributes. The difference between the attributes was calculated
+	 * with the difference(int,double,double) method.
+	 * 
+	 * @param currDist the current distance calculated so far
+	 * @param diff     the difference between two new attributes
+	 * @return the update distance
+	 * @see #difference(int, double, double)
+	 */
+	protected abstract double updateDistance(double currDist, double diff);
+
+	/**
+	 * Normalizes a given value of a numeric attribute.
+	 *
+	 * @param x the value to be normalized
+	 * @param i the attribute's index
+	 * @return the normalized value
+	 */
+	protected double norm(double x, int i) {
+		if (Double.isNaN(m_Ranges[i][R_MIN]) || (m_Ranges[i][R_MAX] == m_Ranges[i][R_MIN]))
+			return 0;
+		else
+			return (x - m_Ranges[i][R_MIN]) / (m_Ranges[i][R_WIDTH]);
+	}
+
+	/**
+	 * Computes the difference between two given attribute values.
+	 * 
+	 * @param index the attribute index
+	 * @param val1  the first value
+	 * @param val2  the second value
+	 * @return the difference
+	 */
+	protected double difference(int index, double val1, double val2) {
+		// switch (m_Data.attribute(index).type()) {
+		// case Attribute.NOMINAL:
+		if (m_Data.attribute(index).isNominal() == true) {
+			if (isMissingValue(val1) || isMissingValue(val2) || ((int) val1 != (int) val2)) {
+				return 1;
+			} else {
+				return 0;
+			}
+		} else {
+			// case Attribute.NUMERIC:
+			if (isMissingValue(val1) || isMissingValue(val2)) {
+				if (isMissingValue(val1) && isMissingValue(val2)) {
+					if (!m_DontNormalize) // We are doing normalization
+						return 1;
+					else
+						return (m_Ranges[index][R_MAX] - m_Ranges[index][R_MIN]);
+				} else {
+					double diff;
+					if (isMissingValue(val2)) {
+						diff = (!m_DontNormalize) ? norm(val1, index) : val1;
+					} else {
+						diff = (!m_DontNormalize) ? norm(val2, index) : val2;
+					}
+					if (!m_DontNormalize && diff < 0.5) {
+						diff = 1.0 - diff;
+					} else if (m_DontNormalize) {
+						if ((m_Ranges[index][R_MAX] - diff) > (diff - m_Ranges[index][R_MIN]))
+							return m_Ranges[index][R_MAX] - diff;
+						else
+							return diff - m_Ranges[index][R_MIN];
+					}
+					return diff;
+				}
+			} else {
+				return (!m_DontNormalize) ? (norm(val1, index) - norm(val2, index)) : (val1 - val2);
+			}
+
+			// default:
+			// return 0;
+		}
+	}
+
+	/**
+	 * Initializes the ranges using all instances of the dataset. Sets m_Ranges.
+	 * 
+	 * @return the ranges
+	 */
+	public double[][] initializeRanges() {
+		if (m_Data == null) {
+			m_Ranges = null;
+			return m_Ranges;
+		}
+
+		int numAtt = m_Data.numAttributes();
+		double[][] ranges = new double[numAtt][3];
+
+		if (m_Data.numInstances() <= 0) {
+			initializeRangesEmpty(numAtt, ranges);
+			m_Ranges = ranges;
+			return m_Ranges;
+		} else {
+			// initialize ranges using the first instance
+			updateRangesFirst(m_Data.instance(0), numAtt, ranges);
+		}
+
+		// update ranges, starting from the second
+		for (int i = 1; i < m_Data.numInstances(); i++)
+			updateRanges(m_Data.instance(i), numAtt, ranges);
+
+		m_Ranges = ranges;
+
+		return m_Ranges;
+	}
+
+	/**
+	 * Used to initialize the ranges. For this the values of the first instance is
+	 * used to save time. Sets low and high to the values of the first instance and
+	 * width to zero.
+	 * 
+	 * @param instance the new instance
+	 * @param numAtt   number of attributes in the model
+	 * @param ranges   low, high and width values for all attributes
+	 */
+	public void updateRangesFirst(Instance instance, int numAtt, double[][] ranges) {
+		for (int j = 0; j < numAtt; j++) {
+			if (!instance.isMissing(j)) {
+				ranges[j][R_MIN] = instance.value(j);
+				ranges[j][R_MAX] = instance.value(j);
+				ranges[j][R_WIDTH] = 0.0;
+			} else { // if value was missing
+				ranges[j][R_MIN] = Double.POSITIVE_INFINITY;
+				ranges[j][R_MAX] = -Double.POSITIVE_INFINITY;
+				ranges[j][R_WIDTH] = Double.POSITIVE_INFINITY;
+			}
+		}
+	}
+
+	/**
+	 * Updates the minimum and maximum and width values for all the attributes based
+	 * on a new instance.
+	 * 
+	 * @param instance the new instance
+	 * @param numAtt   number of attributes in the model
+	 * @param ranges   low, high and width values for all attributes
+	 */
+	public void updateRanges(Instance instance, int numAtt, double[][] ranges) {
+		// updateRangesFirst must have been called on ranges
+		for (int j = 0; j < numAtt; j++) {
+			double value = instance.value(j);
+			if (!instance.isMissing(j)) {
+				if (value < ranges[j][R_MIN]) {
+					ranges[j][R_MIN] = value;
+					ranges[j][R_WIDTH] = ranges[j][R_MAX] - ranges[j][R_MIN];
+					if (value > ranges[j][R_MAX]) { // if this is the first value that is
+						ranges[j][R_MAX] = value; // not missing. The,0
+						ranges[j][R_WIDTH] = ranges[j][R_MAX] - ranges[j][R_MIN];
+					}
+				} else {
+					if (value > ranges[j][R_MAX]) {
+						ranges[j][R_MAX] = value;
+						ranges[j][R_WIDTH] = ranges[j][R_MAX] - ranges[j][R_MIN];
+					}
+				}
+			}
+		}
+	}
+
+	/**
+	 * Used to initialize the ranges.
+	 * 
+	 * @param numAtt number of attributes in the model
+	 * @param ranges low, high and width values for all attributes
+	 */
+	public void initializeRangesEmpty(int numAtt, double[][] ranges) {
+		for (int j = 0; j < numAtt; j++) {
+			ranges[j][R_MIN] = Double.POSITIVE_INFINITY;
+			ranges[j][R_MAX] = -Double.POSITIVE_INFINITY;
+			ranges[j][R_WIDTH] = Double.POSITIVE_INFINITY;
+		}
+	}
+
+	/**
+	 * Updates the ranges given a new instance.
+	 * 
+	 * @param instance the new instance
+	 * @param ranges   low, high and width values for all attributes
+	 * @return the updated ranges
+	 */
+	public double[][] updateRanges(Instance instance, double[][] ranges) {
+		// updateRangesFirst must have been called on ranges
+		for (int j = 0; j < ranges.length; j++) {
+			double value = instance.value(j);
+			if (!instance.isMissing(j)) {
+				if (value < ranges[j][R_MIN]) {
+					ranges[j][R_MIN] = value;
+					ranges[j][R_WIDTH] = ranges[j][R_MAX] - ranges[j][R_MIN];
+				} else {
+					if (instance.value(j) > ranges[j][R_MAX]) {
+						ranges[j][R_MAX] = value;
+						ranges[j][R_WIDTH] = ranges[j][R_MAX] - ranges[j][R_MIN];
+					}
+				}
+			}
+		}
+
+		return ranges;
+	}
+
+	/**
+	 * Initializes the ranges of a subset of the instances of this dataset.
+	 * Therefore m_Ranges is not set.
+	 * 
+	 * @param instList list of indexes of the subset
+	 * @return the ranges
+	 * @throws Exception if something goes wrong
+	 */
+	public double[][] initializeRanges(int[] instList) throws Exception {
+		if (m_Data == null)
+			throw new Exception("No instances supplied.");
+
+		int numAtt = m_Data.numAttributes();
+		double[][] ranges = new double[numAtt][3];
+
+		if (m_Data.numInstances() <= 0) {
+			initializeRangesEmpty(numAtt, ranges);
+			return ranges;
+		} else {
+			// initialize ranges using the first instance
+			updateRangesFirst(m_Data.instance(instList[0]), numAtt, ranges);
+			// update ranges, starting from the second
+			for (int i = 1; i < instList.length; i++) {
+				updateRanges(m_Data.instance(instList[i]), numAtt, ranges);
+			}
+		}
+		return ranges;
+	}
+
+	/**
+	 * Initializes the ranges of a subset of the instances of this dataset.
+	 * Therefore m_Ranges is not set. The caller of this method should ensure that
+	 * the supplied start and end indices are valid (start &lt;= end,
+	 * end&lt;instList.length etc) and correct.
+	 *
+	 * @param instList list of indexes of the instances
+	 * @param startIdx start index of the subset of instances in the indices array
+	 * @param endIdx   end index of the subset of instances in the indices array
+	 * @return the ranges
+	 * @throws Exception if something goes wrong
+	 */
+	public double[][] initializeRanges(int[] instList, int startIdx, int endIdx) throws Exception {
+		if (m_Data == null)
+			throw new Exception("No instances supplied.");
+
+		int numAtt = m_Data.numAttributes();
+		double[][] ranges = new double[numAtt][3];
+
+		if (m_Data.numInstances() <= 0) {
+			initializeRangesEmpty(numAtt, ranges);
+			return ranges;
+		} else {
+			// initialize ranges using the first instance
+			updateRangesFirst(m_Data.instance(instList[startIdx]), numAtt, ranges);
+			// update ranges, starting from the second
+			for (int i = startIdx + 1; i <= endIdx; i++) {
+				updateRanges(m_Data.instance(instList[i]), numAtt, ranges);
+			}
+		}
+
+		return ranges;
+	}
+
+	/**
+	 * Update the ranges if a new instance comes.
+	 * 
+	 * @param instance the new instance
+	 */
+	public void updateRanges(Instance instance) {
+		validate();
+
+		m_Ranges = updateRanges(instance, m_Ranges);
+	}
+
+	/**
+	 * Test if an instance is within the given ranges.
+	 * 
+	 * @param instance the instance
+	 * @param ranges   the ranges the instance is tested to be in
+	 * @return true if instance is within the ranges
+	 */
+	public boolean inRanges(Instance instance, double[][] ranges) {
+		boolean isIn = true;
+
+		// updateRangesFirst must have been called on ranges
+		for (int j = 0; isIn && (j < ranges.length); j++) {
+			if (!instance.isMissing(j)) {
+				double value = instance.value(j);
+				isIn = value <= ranges[j][R_MAX];
+				if (isIn)
+					isIn = value >= ranges[j][R_MIN];
+			}
+		}
+
+		return isIn;
+	}
+
+	/**
+	 * Check if ranges are set.
+	 * 
+	 * @return true if ranges are set
+	 */
+	public boolean rangesSet() {
+		return (m_Ranges != null);
+	}
+
+	/**
+	 * Method to get the ranges.
+	 * 
+	 * @return the ranges
+	 * @throws Exception if no randes are set yet
+	 */
+	public double[][] getRanges() throws Exception {
+		validate();
+
+		if (m_Ranges == null)
+			throw new Exception("Ranges not yet set.");
+
+		return m_Ranges;
+	}
+
+	/**
+	 * Returns an empty string.
+	 * 
+	 * @return an empty string
+	 */
+	@Override
+	public String toString() {
+		return "";
+	}
+
+	/**
+	 * Tests if the given value codes "missing".
+	 *
+	 * @param val the value to be tested
+	 * @return true if val codes "missing"
+	 */
+	public static boolean isMissingValue(double val) {
+
+		return Double.isNaN(val);
+	}
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/kdtrees/KDTreeNode.java b/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/kdtrees/KDTreeNode.java
new file mode 100644
index 000000000..773005e8f
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/kdtrees/KDTreeNode.java
@@ -0,0 +1,172 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * KDTreeNode.java
+ * Copyright (C) 2007-2012 University of Waikato, Hamilton, New Zealand
+ */
+
+package moa.learners.predictors.lazy.neighboursearch.kdtrees;
+
+import java.io.Serializable;
+
+/**
+ * A class representing a KDTree node. A node does not explicitly store the
+ * instances that it contains. Instead, it only stores the start and end index
+ * of a portion in a master index array. Each node is assigned a portion in the
+ * master index array that stores the indices of the instances that the node
+ * contains. Every time a node is split by the KDTree's contruction method, the
+ * instances of its left child are moved to the left and the instances of its
+ * right child are moved to the right, in the portion of the master index array
+ * belonging to the node. The start and end index in each of its children are
+ * then set accordingly within that portion so that each have their own portion
+ * which contains their instances. P.S.: The master index array is only stored
+ * in KDTree class.
+ *
+ * @author Ashraf M. Kibriya (amk14[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
+ * @version $Revision: 8034 $
+ */
+public class KDTreeNode implements Serializable {
+
+	/**
+	 * for serialization.
+	 */
+	private static final long serialVersionUID = -3660396067582792648L;
+
+	/**
+	 * node number (only for debug).
+	 */
+	public int m_NodeNumber;
+
+	/**
+	 * left subtree; contains instances with smaller or equal to split value.
+	 */
+	public KDTreeNode m_Left = null;
+
+	/**
+	 * right subtree; contains instances with larger than split value.
+	 */
+	public KDTreeNode m_Right = null;
+
+	/**
+	 * value to split on.
+	 */
+	public double m_SplitValue;
+
+	/**
+	 * attribute to split on.
+	 */
+	public int m_SplitDim;
+
+	/**
+	 * lowest and highest value and width (= high - low) for each dimension.
+	 */
+	public double[][] m_NodeRanges;
+
+	/**
+	 * The lo and high bounds of the hyper rectangle described by the node.
+	 */
+	public double[][] m_NodesRectBounds;
+
+	/**
+	 * The start index of the portion of the master index array, which stores the
+	 * indices of the instances/points the node contains.
+	 */
+	public int m_Start = 0;
+
+	/**
+	 * The end index of the portion of the master index array, which stores indices
+	 * of the instances/points the node contains.
+	 */
+	public int m_End = 0;
+
+	/**
+	 * Constructor.
+	 */
+	public KDTreeNode() {
+	}
+
+	/**
+	 * Constructor.
+	 *
+	 * @param nodeNum    The node number/id.
+	 * @param startidx   The start index of node's portion in master index array.
+	 * @param endidx     The start index of node's portion in master index array.
+	 * @param nodeRanges The attribute ranges of the Instances/points contained in
+	 *                   this node.
+	 */
+	public KDTreeNode(int nodeNum, int startidx, int endidx, double[][] nodeRanges) {
+		m_NodeNumber = nodeNum;
+		m_Start = startidx;
+		m_End = endidx;
+		m_NodeRanges = nodeRanges;
+	}
+
+	/**
+	 * @param nodeNum    The node number/id.
+	 * @param startidx   The start index of node's portion in master index array.
+	 * @param endidx     The start index of node's portion in master index array.
+	 * @param nodeRanges The attribute ranges of the Instances/points contained in
+	 *                   this node.
+	 * @param rectBounds The range of the rectangular region in the point space that
+	 *                   this node represents (points inside this rectangular region
+	 *                   can have different range).
+	 */
+	public KDTreeNode(int nodeNum, int startidx, int endidx, double[][] nodeRanges, double[][] rectBounds) {
+		m_NodeNumber = nodeNum;
+		m_Start = startidx;
+		m_End = endidx;
+		m_NodeRanges = nodeRanges;
+		m_NodesRectBounds = rectBounds;
+	}
+
+	/**
+	 * Gets the splitting dimension.
+	 *
+	 * @return splitting dimension
+	 */
+	public int getSplitDim() {
+		return m_SplitDim;
+	}
+
+	/**
+	 * Gets the splitting value.
+	 *
+	 * @return splitting value
+	 */
+	public double getSplitValue() {
+		return m_SplitValue;
+	}
+
+	/**
+	 * Checks if node is a leaf.
+	 *
+	 * @return true if it is a leaf
+	 */
+	public boolean isALeaf() {
+		return (m_Left == null);
+	}
+
+	/**
+	 * Returns the number of Instances in the rectangular region defined by this
+	 * node.
+	 *
+	 * @return The number of instances in this KDTreeNode.
+	 */
+	public int numInstances() {
+		return (m_End - m_Start + 1);
+	}
+
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/kdtrees/KDTreeNodeSplitter.java b/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/kdtrees/KDTreeNodeSplitter.java
new file mode 100644
index 000000000..6ea1d6997
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/kdtrees/KDTreeNodeSplitter.java
@@ -0,0 +1,227 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * KDTreeNodeSplitter.java
+ * Copyright (C) 1999-2012 University of Waikato
+ */
+
+package moa.learners.predictors.lazy.neighboursearch.kdtrees;
+
+import java.io.Serializable;
+import java.util.Enumeration;
+import java.util.Vector;
+
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
+import moa.learners.predictors.lazy.neighboursearch.EuclideanDistance;
+
+/**
+ * Class that splits up a KDTreeNode.
+ *
+ * @author Ashraf M. Kibriya (amk14[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
+ * @version $Revision: 8034 $
+ */
+public abstract class KDTreeNodeSplitter implements Serializable {
+
+	/** The instances that'll be used for tree construction. */
+	protected InstancesHeader m_Instances;
+
+	/** The distance function used for building the tree. */
+	protected EuclideanDistance m_EuclideanDistance;
+
+	/**
+	 * The master index array that'll be reshuffled as nodes are split and the tree
+	 * is constructed.
+	 */
+	protected int[] m_InstList;
+
+	/**
+	 * Stores whether if the width of a KDTree node is normalized or not.
+	 */
+	protected boolean m_NormalizeNodeWidth;
+
+	// Constants
+	/** Index of min value in an array of attributes' range. */
+	public static final int MIN = EuclideanDistance.R_MIN;
+
+	/** Index of max value in an array of attributes' range. */
+	public static final int MAX = EuclideanDistance.R_MAX;
+
+	/** Index of width value (max-min) in an array of attributes' range. */
+	public static final int WIDTH = EuclideanDistance.R_WIDTH;
+
+	/**
+	 * default constructor.
+	 */
+	public KDTreeNodeSplitter() {
+	}
+
+	/**
+	 * Creates a new instance of KDTreeNodeSplitter.
+	 * 
+	 * @param instList Reference of the master index array.
+	 * @param insts    The set of training instances on which the tree is built.
+	 * @param e        The EuclideanDistance object that is used in tree
+	 *                 contruction.
+	 */
+	public KDTreeNodeSplitter(int[] instList, InstancesHeader insts, EuclideanDistance e) {
+		m_InstList = instList;
+		m_Instances = insts;
+		m_EuclideanDistance = e;
+	}
+
+	/**
+	 * Returns an enumeration describing the available options.
+	 *
+	 * @return an enumeration of all the available options.
+	 */
+	public Enumeration listOptions() {
+		return new Vector().elements();
+	}
+
+	/**
+	 * Parses a given list of options.
+	 * 
+	 * @param options the list of options as an array of strings
+	 * @throws Exception if an option is not supported
+	 */
+	public void setOptions(String[] options) throws Exception {
+	}
+
+	/**
+	 * Gets the current settings of the object.
+	 *
+	 * @return an array of strings suitable for passing to setOptions
+	 */
+	public String[] getOptions() {
+		return new String[0];
+	}
+
+	/**
+	 * Checks whether an object of this class has been correctly initialized.
+	 * Performs checks to see if all the necessary things (master index array,
+	 * training instances, distance function) have been supplied or not.
+	 * 
+	 * @throws Exception If the object has not been correctly initialized.
+	 */
+	protected void correctlyInitialized() throws Exception {
+		if (m_Instances == null)
+			throw new Exception("No instances supplied.");
+		else if (m_InstList == null)
+			throw new Exception("No instance list supplied.");
+		else if (m_EuclideanDistance == null)
+			throw new Exception("No Euclidean distance function supplied.");
+		else if (m_Instances.numInstances() != m_InstList.length)
+			throw new Exception("The supplied instance list doesn't seem to match " + "the supplied instances");
+	}
+
+	/**
+	 * Splits a node into two. After splitting two new nodes are created and
+	 * correctly initialised. And, node.left and node.right are set appropriately.
+	 * 
+	 * @param node            The node to split.
+	 * @param numNodesCreated The number of nodes that so far have been created for
+	 *                        the tree, so that the newly created nodes are assigned
+	 *                        correct/meaningful node numbers/ids.
+	 * @param nodeRanges      The attributes' range for the points inside the node
+	 *                        that is to be split.
+	 * @param universe        The attributes' range for the whole point-space.
+	 * @throws Exception If there is some problem in splitting the given node.
+	 */
+	public abstract void splitNode(KDTreeNode node, int numNodesCreated, double[][] nodeRanges, double[][] universe)
+			throws Exception;
+
+	/**
+	 * Sets the training instances on which the tree is (or is to be) built.
+	 * 
+	 * @param inst The training instances.
+	 */
+	public void setInstances(InstancesHeader inst) {
+		m_Instances = inst;
+	}
+
+	/**
+	 * Sets the master index array containing indices of the training instances.
+	 * This array will be rearranged as the tree is built, so that each node is
+	 * assigned a portion in this array which contain the instances insides the
+	 * node's region.
+	 * 
+	 * @param instList The master index array.
+	 */
+	public void setInstanceList(int[] instList) {
+		m_InstList = instList;
+	}
+
+	/**
+	 * Sets the EuclideanDistance object to use for splitting nodes.
+	 * 
+	 * @param func The EuclideanDistance object.
+	 */
+	public void setEuclideanDistanceFunction(EuclideanDistance func) {
+		m_EuclideanDistance = func;
+	}
+
+	/**
+	 * Sets whether if a nodes region is normalized or not. If set to true then,
+	 * when selecting the widest attribute/dimension for splitting, the width of
+	 * each attribute/dimension, of the points inside the node's region, is divided
+	 * by the width of that attribute/dimension for the whole point-space. Thus,
+	 * each attribute/dimension of that node is normalized.
+	 * 
+	 * @param normalize Should be true if normalization is required.
+	 */
+	public void setNodeWidthNormalization(boolean normalize) {
+		m_NormalizeNodeWidth = normalize;
+	}
+
+	/**
+	 * Returns the widest dimension. The width of each dimension (for the points
+	 * inside the node) is normalized, if m_NormalizeNodeWidth is set to true.
+	 * 
+	 * @param nodeRanges The attributes' range of the points inside the node that is
+	 *                   to be split.
+	 * @param universe   The attributes' range for the whole point-space.
+	 * @return The index of the attribute/dimension in which the points of the node
+	 *         have widest spread.
+	 */
+	protected int widestDim(double[][] nodeRanges, double[][] universe) {
+		final int classIdx = m_Instances.classIndex();
+		double widest = 0.0;
+		int w = -1;
+		if (m_NormalizeNodeWidth) {
+			for (int i = 0; i < nodeRanges.length; i++) {
+				double newWidest = nodeRanges[i][WIDTH] / universe[i][WIDTH];
+				if (newWidest > widest) {
+					if (i == classIdx)
+						continue;
+					widest = newWidest;
+					w = i;
+				}
+			}
+		} else {
+			for (int i = 0; i < nodeRanges.length; i++) {
+				if (nodeRanges[i][WIDTH] > widest) {
+					if (i == classIdx)
+						continue;
+					widest = nodeRanges[i][WIDTH];
+					w = i;
+				}
+			}
+		}
+		return w;
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/kdtrees/KMeansInpiredMethod.java b/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/kdtrees/KMeansInpiredMethod.java
new file mode 100644
index 000000000..e0631b10b
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/kdtrees/KMeansInpiredMethod.java
@@ -0,0 +1,320 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * KMeansInpiredMethod.java
+ * Copyright (C) 2007-2012 University of Waikato, Hamilton, New Zealand
+ */
+
+package moa.learners.predictors.lazy.neighboursearch.kdtrees;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
+/**
+ * <!-- globalinfo-start --> The class that splits a node into two such that the
+ * overall sum of squared distances of points to their centres on both sides of
+ * the (axis-parallel) splitting plane is minimum.<br/>
+ * <br/>
+ * For more information see also:<br/>
+ * <br/>
+ * Ashraf Masood Kibriya (2007). Fast Algorithms for Nearest Neighbour Search.
+ * Hamilton, New Zealand.
+ * <p/>
+ * <!-- globalinfo-end -->
+ *
+ * <!-- technical-bibtex-start --> BibTeX:
+ * 
+ * <pre>
+ * &#64;mastersthesis{Kibriya2007,
+ *    address = {Hamilton, New Zealand},
+ *    author = {Ashraf Masood Kibriya},
+ *    school = {Department of Computer Science, School of Computing and Mathematical Sciences, University of Waikato},
+ *    title = {Fast Algorithms for Nearest Neighbour Search},
+ *    year = {2007}
+ * }
+ * </pre>
+ * <p/>
+ * <!-- technical-bibtex-end -->
+ *
+ * <!-- options-start --> <!-- options-end -->
+ *
+ * @author Ashraf M. Kibriya (amk14[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
+ * @version $Revision: 8034 $
+ */
+public class KMeansInpiredMethod extends KDTreeNodeSplitter {
+
+	/** for serialization. */
+	private static final long serialVersionUID = -866783749124714304L;
+
+	/**
+	 * Returns a string describing this nearest neighbour search algorithm.
+	 * 
+	 * @return a description of the algorithm for displaying in the
+	 *         explorer/experimenter gui
+	 */
+	public String globalInfo() {
+		return "The class that splits a node into two such that the overall sum "
+				+ "of squared distances of points to their centres on both sides "
+				+ "of the (axis-parallel) splitting plane is minimum.\n\n" + "For more information see also:\n\n";
+	}
+
+	/**
+	 * Splits a node into two such that the overall sum of squared distances of
+	 * points to their centres on both sides of the (axis-parallel) splitting plane
+	 * is minimum. The two nodes created after the whole splitting are correctly
+	 * initialised. And, node.left and node.right are set appropriately.
+	 * 
+	 * @param node            The node to split.
+	 * @param numNodesCreated The number of nodes that so far have been created for
+	 *                        the tree, so that the newly created nodes are assigned
+	 *                        correct/meaningful node numbers/ids.
+	 * @param nodeRanges      The attributes' range for the points inside the node
+	 *                        that is to be split.
+	 * @param universe        The attributes' range for the whole point-space.
+	 * @throws Exception If there is some problem in splitting the given node.
+	 */
+	@Override
+	public void splitNode(KDTreeNode node, int numNodesCreated, double[][] nodeRanges, double[][] universe)
+			throws Exception {
+
+		correctlyInitialized();
+
+		int splitDim = -1;
+		double splitVal = Double.NEGATIVE_INFINITY;
+
+		double leftAttSum[] = new double[m_Instances.numAttributes()],
+				rightAttSum[] = new double[m_Instances.numAttributes()],
+				leftAttSqSum[] = new double[m_Instances.numAttributes()],
+				rightAttSqSum[] = new double[m_Instances.numAttributes()], rightSqMean, leftSqMean, leftSqSum,
+				rightSqSum, minSum = Double.POSITIVE_INFINITY, val;
+
+		for (int dim = 0; dim < m_Instances.numAttributes(); dim++) {
+			// m_MaxRelativeWidth in KDTree ensure there'll be atleast one dim with
+			// width > 0.0
+			if (node.m_NodeRanges[dim][WIDTH] == 0.0 || dim == m_Instances.classIndex())
+				continue;
+
+			quickSort(m_Instances, m_InstList, dim, node.m_Start, node.m_End);
+
+			for (int i = node.m_Start; i <= node.m_End; i++) {
+				for (int j = 0; j < m_Instances.numAttributes(); j++) {
+					if (j == m_Instances.classIndex())
+						continue;
+					val = m_Instances.instance(m_InstList[i]).value(j);
+					if (m_NormalizeNodeWidth) {
+						if (Double.isNaN(universe[j][MIN]) || universe[j][MIN] == universe[j][MAX])
+							val = 0.0;
+						else
+							val = ((val - universe[j][MIN]) / universe[j][WIDTH]); // normalizing
+																					// value
+					}
+					if (i == node.m_Start) {
+						leftAttSum[j] = rightAttSum[j] = leftAttSqSum[j] = rightAttSqSum[j] = 0.0;
+					}
+					rightAttSum[j] += val;
+					rightAttSqSum[j] += val * val;
+				}
+			}
+
+			for (int i = node.m_Start; i <= node.m_End - 1; i++) {
+				Instance inst = m_Instances.instance(m_InstList[i]);
+				leftSqSum = rightSqSum = 0.0;
+				for (int j = 0; j < m_Instances.numAttributes(); j++) {
+					if (j == m_Instances.classIndex())
+						continue;
+					val = inst.value(j);
+
+					if (m_NormalizeNodeWidth) {
+						if (Double.isNaN(universe[j][MIN]) || universe[j][MIN] == universe[j][MAX])
+							val = 0.0;
+						else
+							val = ((val - universe[j][MIN]) / universe[j][WIDTH]); // normalizing
+																					// value
+					}
+
+					leftAttSum[j] += val;
+					rightAttSum[j] -= val;
+					leftAttSqSum[j] += val * val;
+					rightAttSqSum[j] -= val * val;
+					leftSqMean = leftAttSum[j] / (i - node.m_Start + 1);
+					leftSqMean *= leftSqMean;
+					rightSqMean = rightAttSum[j] / (node.m_End - i);
+					rightSqMean *= rightSqMean;
+
+					leftSqSum += leftAttSqSum[j] - (i - node.m_Start + 1) * leftSqMean;
+					rightSqSum += rightAttSqSum[j] - (node.m_End - i) * rightSqMean;
+				}
+
+				if (minSum > (leftSqSum + rightSqSum)) {
+					minSum = leftSqSum + rightSqSum;
+
+					if (i < node.m_End)
+						splitVal = (m_Instances.instance(m_InstList[i]).value(dim)
+								+ m_Instances.instance(m_InstList[i + 1]).value(dim)) / 2;
+					else
+						splitVal = m_Instances.instance(m_InstList[i]).value(dim);
+
+					splitDim = dim;
+				}
+			} // end for instance i
+		} // end for attribute dim
+
+		int rightStart = rearrangePoints(m_InstList, node.m_Start, node.m_End, splitDim, splitVal);
+
+		if (rightStart == node.m_Start || rightStart > node.m_End) {
+			System.out.println("node.m_Start: " + node.m_Start + " node.m_End: " + node.m_End + " splitDim: " + splitDim
+					+ " splitVal: " + splitVal + " node.min: " + node.m_NodeRanges[splitDim][MIN] + " node.max: "
+					+ node.m_NodeRanges[splitDim][MAX] + " node.numInstances: " + node.numInstances());
+
+			if (rightStart == node.m_Start)
+				throw new Exception("Left child is empty in node " + node.m_NodeNumber + ". Not possible with "
+						+ "KMeanInspiredMethod splitting method. Please " + "check code.");
+			else
+				throw new Exception("Right child is empty in node " + node.m_NodeNumber + ". Not possible with "
+						+ "KMeansInspiredMethod splitting method. Please " + "check code.");
+		}
+
+		node.m_SplitDim = splitDim;
+		node.m_SplitValue = splitVal;
+		node.m_Left = new KDTreeNode(numNodesCreated + 1, node.m_Start, rightStart - 1,
+				m_EuclideanDistance.initializeRanges(m_InstList, node.m_Start, rightStart - 1));
+		node.m_Right = new KDTreeNode(numNodesCreated + 2, rightStart, node.m_End,
+				m_EuclideanDistance.initializeRanges(m_InstList, rightStart, node.m_End));
+	}
+
+	/**
+	 * Partitions the instances around a pivot. Used by quicksort and
+	 * kthSmallestValue.
+	 *
+	 * @param insts  The instances on which the tree is (or is to be) built.
+	 * @param index  The master index array containing indices of the instances.
+	 * @param attidx The attribution/dimension based on which the instances should
+	 *               be partitioned.
+	 * @param l      The begining index of the portion of master index array that
+	 *               should be partitioned.
+	 * @param r      The end index of the portion of master index array that should
+	 *               be partitioned.
+	 * @return the index of the middle element
+	 */
+	protected static int partition(InstancesHeader insts, int[] index, int attidx, int l, int r) {
+
+		double pivot = insts.instance(index[(l + r) / 2]).value(attidx);
+		int help;
+
+		while (l < r) {
+			while ((insts.instance(index[l]).value(attidx) < pivot) && (l < r)) {
+				l++;
+			}
+			while ((insts.instance(index[r]).value(attidx) > pivot) && (l < r)) {
+				r--;
+			}
+			if (l < r) {
+				help = index[l];
+				index[l] = index[r];
+				index[r] = help;
+				l++;
+				r--;
+			}
+		}
+		if ((l == r) && (insts.instance(index[r]).value(attidx) > pivot)) {
+			r--;
+		}
+
+		return r;
+	}
+
+	/**
+	 * Sorts the instances according to the given attribute/dimension. The sorting
+	 * is done on the master index array and not on the actual instances object.
+	 * 
+	 * @param insts   The instances on which the tree is (or is to be) built.
+	 * @param indices The master index array containing indices of the instances.
+	 * @param attidx  The dimension/attribute based on which the instances should be
+	 *                sorted.
+	 * @param left    The begining index of the portion of the master index array
+	 *                that needs to be sorted.
+	 * @param right   The end index of the portion of the master index array that
+	 *                needs to be sorted.
+	 */
+	protected static void quickSort(InstancesHeader insts, int[] indices, int attidx, int left, int right) {
+
+		if (left < right) {
+			int middle = partition(insts, indices, attidx, left, right);
+			quickSort(insts, indices, attidx, left, middle);
+			quickSort(insts, indices, attidx, middle + 1, right);
+		}
+	}
+
+	/**
+	 * Method to validate the sorting done by quickSort().
+	 * 
+	 * @param insts   The instances on which the tree is (or is to be) built.
+	 * @param indices The master index array containing indices of the instances.
+	 * @param attidx  The dimension/attribute based on which the instances should be
+	 *                sorted.
+	 * @param start   The start of the portion in master index array that needs to
+	 *                be sorted.
+	 * @param end     The end of the portion in master index array that needs to be
+	 *                sorted.
+	 * @throws Exception If the indices of the instances are not in sorted order.
+	 */
+	private static void checkSort(InstancesHeader insts, int[] indices, int attidx, int start, int end)
+			throws Exception {
+		for (int i = start + 1; i <= end; i++) {
+			if (insts.instance(indices[i - 1]).value(attidx) > insts.instance(indices[i]).value(attidx)) {
+				System.out.println("value[i-1]: " + insts.instance(indices[i - 1]).value(attidx));
+				System.out.println("value[i]: " + insts.instance(indices[i]).value(attidx));
+				System.out.println("indices[i-1]: " + indices[i - 1]);
+				System.out.println("indices[i]: " + indices[i]);
+				System.out.println("i: " + i);
+				if (insts.instance(indices[i - 1]).value(attidx) > insts.instance(indices[i]).value(attidx))
+					System.out.println("value[i-1] > value[i]");
+
+				throw new Exception("Indices not sorted correctly.");
+			} // end if
+		}
+	}
+
+	/**
+	 * Re-arranges the indices array so that in the portion of the array belonging
+	 * to the node to be split, the points <= to the splitVal are on the left of the
+	 * portion and those > the splitVal are on the right.
+	 * 
+	 * @param indices  The master index array.
+	 * @param startidx The begining index of portion of indices that needs
+	 *                 re-arranging.
+	 * @param endidx   The end index of portion of indices that needs re-arranging.
+	 * @param splitDim The split dimension/attribute.
+	 * @param splitVal The split value.
+	 * @return The startIdx of the points > the splitVal (the points belonging to
+	 *         the right child of the node).
+	 */
+	protected int rearrangePoints(int[] indices, final int startidx, final int endidx, final int splitDim,
+			final double splitVal) {
+
+		int tmp, left = startidx - 1;
+		for (int i = startidx; i <= endidx; i++) {
+			if (m_EuclideanDistance.valueIsSmallerEqual(m_Instances.instance(indices[i]), splitDim, splitVal)) {
+				left++;
+				tmp = indices[left];
+				indices[left] = indices[i];
+				indices[i] = tmp;
+			} // end valueIsSmallerEqual
+		} // endfor
+		return left + 1;
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/kdtrees/MedianOfWidestDimension.java b/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/kdtrees/MedianOfWidestDimension.java
new file mode 100644
index 000000000..3ba882156
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/kdtrees/MedianOfWidestDimension.java
@@ -0,0 +1,183 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * MedianOfWidestDimension.java
+ * Copyright (C) 2007-2012 University of Waikato, Hamilton, New Zealand
+ */
+
+package moa.learners.predictors.lazy.neighboursearch.kdtrees;
+
+/**
+ * <!-- globalinfo-start --> The class that splits a KDTree node based on the
+ * median value of a dimension in which the node's points have the widest
+ * spread.<br/>
+ * <br/>
+ * For more information see also:<br/>
+ * <br/>
+ * Jerome H. Friedman, Jon Luis Bentley, Raphael Ari Finkel (1977). An Algorithm
+ * for Finding Best Matches in Logarithmic Expected Time. ACM Transactions on
+ * Mathematics Software. 3(3):209-226.
+ * <p/>
+ * <!-- globalinfo-end -->
+ *
+ * <!-- technical-bibtex-start --> BibTeX:
+ * 
+ * <pre>
+ * &#64;article{Friedman1977,
+ *    author = {Jerome H. Friedman and Jon Luis Bentley and Raphael Ari Finkel},
+ *    journal = {ACM Transactions on Mathematics Software},
+ *    month = {September},
+ *    number = {3},
+ *    pages = {209-226},
+ *    title = {An Algorithm for Finding Best Matches in Logarithmic Expected Time},
+ *    volume = {3},
+ *    year = {1977}
+ * }
+ * </pre>
+ * <p/>
+ * <!-- technical-bibtex-end -->
+ *
+ * <!-- options-start --> <!-- options-end -->
+ *
+ * @author Ashraf M. Kibriya (amk14[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
+ * @version $Revision: 8034 $
+ */
+public class MedianOfWidestDimension extends KDTreeNodeSplitter {
+
+	/** for serialization. */
+	private static final long serialVersionUID = 1383443320160540663L;
+
+	/**
+	 * Returns a string describing this nearest neighbour search algorithm.
+	 * 
+	 * @return a description of the algorithm for displaying in the
+	 *         explorer/experimenter gui
+	 */
+	public String globalInfo() {
+		return "The class that splits a KDTree node based on the median value of "
+				+ "a dimension in which the node's points have the widest spread.\n\n"
+				+ "For more information see also:\n\n";
+	}
+
+	/**
+	 * Splits a node into two based on the median value of the dimension in which
+	 * the points have the widest spread. After splitting two new nodes are created
+	 * and correctly initialised. And, node.left and node.right are set
+	 * appropriately.
+	 * 
+	 * @param node            The node to split.
+	 * @param numNodesCreated The number of nodes that so far have been created for
+	 *                        the tree, so that the newly created nodes are assigned
+	 *                        correct/meaningful node numbers/ids.
+	 * @param nodeRanges      The attributes' range for the points inside the node
+	 *                        that is to be split.
+	 * @param universe        The attributes' range for the whole point-space.
+	 * @throws Exception If there is some problem in splitting the given node.
+	 */
+	@Override
+	public void splitNode(KDTreeNode node, int numNodesCreated, double[][] nodeRanges, double[][] universe)
+			throws Exception {
+
+		correctlyInitialized();
+
+		int splitDim = widestDim(nodeRanges, universe);
+
+		// In this case median is defined to be either the middle value (in case of
+		// odd number of values) or the left of the two middle values (in case of
+		// even number of values).
+		int medianIdxIdx = node.m_Start + (node.m_End - node.m_Start) / 2;
+		// the following finds the median and also re-arranges the array so all
+		// elements to the left are < median and those to the right are > median.
+		int medianIdx = select(splitDim, m_InstList, node.m_Start, node.m_End, (node.m_End - node.m_Start) / 2 + 1);
+
+		node.m_SplitDim = splitDim;
+		node.m_SplitValue = m_Instances.instance(m_InstList[medianIdx]).value(splitDim);
+
+		node.m_Left = new KDTreeNode(numNodesCreated + 1, node.m_Start, medianIdxIdx,
+				m_EuclideanDistance.initializeRanges(m_InstList, node.m_Start, medianIdxIdx));
+		node.m_Right = new KDTreeNode(numNodesCreated + 2, medianIdxIdx + 1, node.m_End,
+				m_EuclideanDistance.initializeRanges(m_InstList, medianIdxIdx + 1, node.m_End));
+	}
+
+	/**
+	 * Partitions the instances around a pivot. Used by quicksort and
+	 * kthSmallestValue.
+	 *
+	 * @param attIdx The attribution/dimension based on which the instances should
+	 *               be partitioned.
+	 * @param index  The master index array containing indices of the instances.
+	 * @param l      The begining index of the portion of master index array that
+	 *               should be partitioned.
+	 * @param r      The end index of the portion of master index array that should
+	 *               be partitioned.
+	 * @return the index of the middle element
+	 */
+	protected int partition(int attIdx, int[] index, int l, int r) {
+
+		double pivot = m_Instances.instance(index[(l + r) / 2]).value(attIdx);
+		int help;
+
+		while (l < r) {
+			while ((m_Instances.instance(index[l]).value(attIdx) < pivot) && (l < r)) {
+				l++;
+			}
+			while ((m_Instances.instance(index[r]).value(attIdx) > pivot) && (l < r)) {
+				r--;
+			}
+			if (l < r) {
+				help = index[l];
+				index[l] = index[r];
+				index[r] = help;
+				l++;
+				r--;
+			}
+		}
+		if ((l == r) && (m_Instances.instance(index[r]).value(attIdx) > pivot)) {
+			r--;
+		}
+
+		return r;
+	}
+
+	/**
+	 * Implements computation of the kth-smallest element according to Manber's
+	 * "Introduction to Algorithms".
+	 *
+	 * @param attIdx  The dimension/attribute of the instances in which to find the
+	 *                kth-smallest element.
+	 * @param indices The master index array containing indices of the instances.
+	 * @param left    The begining index of the portion of the master index array in
+	 *                which to find the kth-smallest element.
+	 * @param right   The end index of the portion of the master index array in
+	 *                which to find the kth-smallest element.
+	 * @param k       The value of k
+	 * @return The index of the kth-smallest element
+	 */
+	public int select(int attIdx, int[] indices, int left, int right, int k) {
+
+		if (left == right) {
+			return left;
+		} else {
+			int middle = partition(attIdx, indices, left, right);
+			if ((middle - left + 1) >= k) {
+				return select(attIdx, indices, left, middle, k);
+			} else {
+				return select(attIdx, indices, middle + 1, right, k - (middle - left + 1));
+			}
+		}
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/kdtrees/MidPointOfWidestDimension.java b/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/kdtrees/MidPointOfWidestDimension.java
new file mode 100644
index 000000000..999ecbb5e
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/kdtrees/MidPointOfWidestDimension.java
@@ -0,0 +1,143 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * MidPointOfWidestDimension.java
+ * Copyright (C) 2007-2012 University of Waikato, Hamilton, New Zealand
+ */
+
+package moa.learners.predictors.lazy.neighboursearch.kdtrees;
+
+/**
+ * <!-- globalinfo-start --> The class that splits a KDTree node based on the
+ * midpoint value of a dimension in which the node's points have the widest
+ * spread.<br/>
+ * <br/>
+ * For more information see also:<br/>
+ * <br/>
+ * Andrew Moore (1991). A tutorial on kd-trees.
+ * <p/>
+ * <!-- globalinfo-end -->
+ *
+ * <!-- technical-bibtex-start --> BibTeX:
+ * 
+ * <pre>
+ * &#64;techreport{Moore1991,
+ *    author = {Andrew Moore},
+ *    booktitle = {University of Cambridge Computer Laboratory Technical Report No. 209},
+ *    howpublished = {Extract from PhD Thesis},
+ *    title = {A tutorial on kd-trees},
+ *    year = {1991},
+ *    HTTP = {http://www.autonlab.org/autonweb/14665.html}
+ * }
+ * </pre>
+ * <p/>
+ * <!-- technical-bibtex-end -->
+ *
+ * <!-- options-start --> <!-- options-end -->
+ *
+ * @author Ashraf M. Kibriya (amk14[at-the-rate]cs[dot]waikato[dot]ac[dot]nz)
+ * @version $Revision: 8034 $
+ */
+public class MidPointOfWidestDimension extends KDTreeNodeSplitter {
+
+	/** for serialization. */
+	private static final long serialVersionUID = -7617277960046591906L;
+
+	/**
+	 * Returns a string describing this nearest neighbour search algorithm.
+	 * 
+	 * @return a description of the algorithm for displaying in the
+	 *         explorer/experimenter gui
+	 */
+	public String globalInfo() {
+		return "The class that splits a KDTree node based on the midpoint value of "
+				+ "a dimension in which the node's points have the widest spread.\n\n"
+				+ "For more information see also:\n\n";
+	}
+
+	/**
+	 * Splits a node into two based on the midpoint value of the dimension in which
+	 * the points have the widest spread. After splitting two new nodes are created
+	 * and correctly initialised. And, node.left and node.right are set
+	 * appropriately.
+	 * 
+	 * @param node            The node to split.
+	 * @param numNodesCreated The number of nodes that so far have been created for
+	 *                        the tree, so that the newly created nodes are assigned
+	 *                        correct/meaningful node numbers/ids.
+	 * @param nodeRanges      The attributes' range for the points inside the node
+	 *                        that is to be split.
+	 * @param universe        The attributes' range for the whole point-space.
+	 * @throws Exception If there is some problem in splitting the given node.
+	 */
+	@Override
+	public void splitNode(KDTreeNode node, int numNodesCreated, double[][] nodeRanges, double[][] universe)
+			throws Exception {
+
+		correctlyInitialized();
+
+		int splitDim = widestDim(nodeRanges, universe);
+
+		double splitVal = m_EuclideanDistance.getMiddle(nodeRanges[splitDim]);
+
+		int rightStart = rearrangePoints(m_InstList, node.m_Start, node.m_End, splitDim, splitVal);
+
+		if (rightStart == node.m_Start || rightStart > node.m_End) {
+			if (rightStart == node.m_Start)
+				throw new Exception("Left child is empty in node " + node.m_NodeNumber + ". Not possible with "
+						+ "MidPointofWidestDim splitting method. Please " + "check code.");
+			else
+				throw new Exception("Right child is empty in node " + node.m_NodeNumber + ". Not possible with "
+						+ "MidPointofWidestDim splitting method. Please " + "check code.");
+		}
+
+		node.m_SplitDim = splitDim;
+		node.m_SplitValue = splitVal;
+		node.m_Left = new KDTreeNode(numNodesCreated + 1, node.m_Start, rightStart - 1,
+				m_EuclideanDistance.initializeRanges(m_InstList, node.m_Start, rightStart - 1));
+		node.m_Right = new KDTreeNode(numNodesCreated + 2, rightStart, node.m_End,
+				m_EuclideanDistance.initializeRanges(m_InstList, rightStart, node.m_End));
+	}
+
+	/**
+	 * Re-arranges the indices array such that the points <= to the splitVal are on
+	 * the left of the array and those > the splitVal are on the right.
+	 * 
+	 * @param indices  The master index array.
+	 * @param startidx The begining index of portion of indices that needs
+	 *                 re-arranging.
+	 * @param endidx   The end index of portion of indices that needs re-arranging.
+	 * @param splitDim The split dimension/attribute.
+	 * @param splitVal The split value.
+	 * @return The startIdx of the points > the splitVal (the points belonging to
+	 *         the right child of the node).
+	 */
+	protected int rearrangePoints(int[] indices, final int startidx, final int endidx, final int splitDim,
+			final double splitVal) {
+
+		int tmp, left = startidx - 1;
+		for (int i = startidx; i <= endidx; i++) {
+			if (m_EuclideanDistance.valueIsSmallerEqual(m_Instances.instance(indices[i]), splitDim, splitVal)) {
+				left++;
+				tmp = indices[left];
+				indices[left] = indices[i];
+				indices[i] = tmp;
+			} // end if valueIsSmallerEqual
+		} // end for
+		return left + 1;
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/kdtrees/SlidingMidPointOfWidestSide.java b/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/kdtrees/SlidingMidPointOfWidestSide.java
new file mode 100644
index 000000000..3fd297a9d
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/lazy/neighboursearch/kdtrees/SlidingMidPointOfWidestSide.java
@@ -0,0 +1,211 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * SlidingMidPointOfWidestSide.java
+ * Copyright (C) 2007-2012 University of Waikato, Hamilton, New Zealand
+ */
+
+package moa.learners.predictors.lazy.neighboursearch.kdtrees;
+
+/**
+ * <!-- globalinfo-start --> The class that splits a node into two based on the
+ * midpoint value of the dimension in which the node's rectangle is widest. If
+ * after splitting one side is empty then it is slided towards the non-empty
+ * side until there is at least one point on the empty side.<br/>
+ * <br/>
+ * For more information see also:<br/>
+ * <br/>
+ * David M. Mount (2006). ANN Programming Manual. College Park, MD, USA.
+ * <p/>
+ * <!-- globalinfo-end -->
+ *
+ * <!-- technical-bibtex-start --> BibTeX:
+ * 
+ * <pre>
+ * &#64;manual{Mount2006,
+ *    address = {College Park, MD, USA},
+ *    author = {David M. Mount},
+ *    organization = {Department of Computer Science, University of Maryland},
+ *    title = {ANN Programming Manual},
+ *    year = {2006},
+ *    HTTP = {Available from http://www.cs.umd.edu/\~mount/ANN/}
+ * }
+ * </pre>
+ * <p/>
+ * <!-- technical-bibtex-end -->
+ *
+ * <!-- options-start --> <!-- options-end -->
+ *
+ * @author Ashraf M. Kibriya (amk14@waikato.ac.nz)
+ * @version $Revision: 8034 $
+ */
+public class SlidingMidPointOfWidestSide extends KDTreeNodeSplitter {
+
+	/** for serialization. */
+	private static final long serialVersionUID = 852857628205680562L;
+
+	/**
+	 * The floating point error to tolerate in finding the widest rectangular side.
+	 */
+	protected static double ERR = 0.001;
+
+	/**
+	 * Returns a string describing this nearest neighbour search algorithm.
+	 * 
+	 * @return a description of the algorithm for displaying in the
+	 *         explorer/experimenter gui
+	 */
+	public String globalInfo() {
+		return "The class that splits a node into two based on the midpoint value of "
+				+ "the dimension in which the node's rectangle is widest. If after "
+				+ "splitting one side is empty then it is slided towards the non-empty "
+				+ "side until there is at least one point on the empty side.\n\n"
+				+ "For more information see also:\n\n";
+	}
+
+	/**
+	 * Splits a node into two based on the midpoint value of the dimension in which
+	 * the node's rectangle is widest. If after splitting one side is empty then it
+	 * is slided towards the non-empty side until there is at least one point on the
+	 * empty side. The two nodes created after the whole splitting are correctly
+	 * initialised. And, node.left and node.right are set appropriately.
+	 * 
+	 * @param node            The node to split.
+	 * @param numNodesCreated The number of nodes that so far have been created for
+	 *                        the tree, so that the newly created nodes are assigned
+	 *                        correct/meaningful node numbers/ids.
+	 * @param nodeRanges      The attributes' range for the points inside the node
+	 *                        that is to be split.
+	 * @param universe        The attributes' range for the whole point-space.
+	 * @throws Exception If there is some problem in splitting the given node.
+	 */
+	@Override
+	public void splitNode(KDTreeNode node, int numNodesCreated, double[][] nodeRanges, double[][] universe)
+			throws Exception {
+
+		correctlyInitialized();
+
+		if (node.m_NodesRectBounds == null) {
+			node.m_NodesRectBounds = new double[2][node.m_NodeRanges.length];
+			for (int i = 0; i < node.m_NodeRanges.length; i++) {
+				node.m_NodesRectBounds[MIN][i] = node.m_NodeRanges[i][MIN];
+				node.m_NodesRectBounds[MAX][i] = node.m_NodeRanges[i][MAX];
+			}
+		}
+
+		// finding widest side of the hyper rectangle
+		double maxRectWidth = Double.NEGATIVE_INFINITY, maxPtWidth = Double.NEGATIVE_INFINITY, tempval;
+		int splitDim = -1, classIdx = m_Instances.classIndex();
+
+		for (int i = 0; i < node.m_NodesRectBounds[0].length; i++) {
+			if (i == classIdx)
+				continue;
+			tempval = node.m_NodesRectBounds[MAX][i] - node.m_NodesRectBounds[MIN][i];
+			if (m_NormalizeNodeWidth) {
+				tempval = tempval / universe[i][WIDTH];
+			}
+			if (tempval > maxRectWidth && node.m_NodeRanges[i][WIDTH] > 0.0)
+				maxRectWidth = tempval;
+		}
+
+		for (int i = 0; i < node.m_NodesRectBounds[0].length; i++) {
+			if (i == classIdx)
+				continue;
+			tempval = node.m_NodesRectBounds[MAX][i] - node.m_NodesRectBounds[MIN][i];
+			if (m_NormalizeNodeWidth) {
+				tempval = tempval / universe[i][WIDTH];
+			}
+			if (tempval >= maxRectWidth * (1 - ERR) && node.m_NodeRanges[i][WIDTH] > 0.0) {
+				if (node.m_NodeRanges[i][WIDTH] > maxPtWidth) {
+					maxPtWidth = node.m_NodeRanges[i][WIDTH];
+					if (m_NormalizeNodeWidth)
+						maxPtWidth = maxPtWidth / universe[i][WIDTH];
+					splitDim = i;
+				}
+			}
+		}
+
+		double splitVal = node.m_NodesRectBounds[MIN][splitDim]
+				+ (node.m_NodesRectBounds[MAX][splitDim] - node.m_NodesRectBounds[MIN][splitDim]) * 0.5;
+		// might want to try to slide it further to contain more than one point on
+		// the
+		// side that is resulting empty
+		if (splitVal < node.m_NodeRanges[splitDim][MIN])
+			splitVal = node.m_NodeRanges[splitDim][MIN];
+		else if (splitVal >= node.m_NodeRanges[splitDim][MAX])
+			splitVal = node.m_NodeRanges[splitDim][MAX] - node.m_NodeRanges[splitDim][WIDTH] * 0.001;
+
+		int rightStart = rearrangePoints(m_InstList, node.m_Start, node.m_End, splitDim, splitVal);
+
+		if (rightStart == node.m_Start || rightStart > node.m_End) {
+			if (rightStart == node.m_Start)
+				throw new Exception("Left child is empty in node " + node.m_NodeNumber + ". Not possible with "
+						+ "SlidingMidPointofWidestSide splitting method. Please " + "check code.");
+			else
+				throw new Exception("Right child is empty in node " + node.m_NodeNumber + ". Not possible with "
+						+ "SlidingMidPointofWidestSide splitting method. Please " + "check code.");
+		}
+
+		node.m_SplitDim = splitDim;
+		node.m_SplitValue = splitVal;
+
+		double[][] widths = new double[2][node.m_NodesRectBounds[0].length];
+
+		System.arraycopy(node.m_NodesRectBounds[MIN], 0, widths[MIN], 0, node.m_NodesRectBounds[MIN].length);
+		System.arraycopy(node.m_NodesRectBounds[MAX], 0, widths[MAX], 0, node.m_NodesRectBounds[MAX].length);
+		widths[MAX][splitDim] = splitVal;
+
+		node.m_Left = new KDTreeNode(numNodesCreated + 1, node.m_Start, rightStart - 1,
+				m_EuclideanDistance.initializeRanges(m_InstList, node.m_Start, rightStart - 1), widths);
+
+		widths = new double[2][node.m_NodesRectBounds[0].length];
+		System.arraycopy(node.m_NodesRectBounds[MIN], 0, widths[MIN], 0, node.m_NodesRectBounds[MIN].length);
+		System.arraycopy(node.m_NodesRectBounds[MAX], 0, widths[MAX], 0, node.m_NodesRectBounds[MAX].length);
+		widths[MIN][splitDim] = splitVal;
+
+		node.m_Right = new KDTreeNode(numNodesCreated + 2, rightStart, node.m_End,
+				m_EuclideanDistance.initializeRanges(m_InstList, rightStart, node.m_End), widths);
+	}
+
+	/**
+	 * Re-arranges the indices array such that the points <= to the splitVal are on
+	 * the left of the array and those > the splitVal are on the right.
+	 * 
+	 * @param indices  The master index array.
+	 * @param startidx The begining index of portion of indices that needs
+	 *                 re-arranging.
+	 * @param endidx   The end index of portion of indices that needs re-arranging.
+	 * @param splitDim The split dimension/attribute.
+	 * @param splitVal The split value.
+	 * @return The startIdx of the points > the splitVal (the points belonging to
+	 *         the right child of the node).
+	 */
+	protected int rearrangePoints(int[] indices, final int startidx, final int endidx, final int splitDim,
+			final double splitVal) {
+
+		int tmp, left = startidx - 1;
+		for (int i = startidx; i <= endidx; i++) {
+			if (m_EuclideanDistance.valueIsSmallerEqual(m_Instances.instance(indices[i]), splitDim, splitVal)) {
+				left++;
+				tmp = indices[left];
+				indices[left] = indices[i];
+				indices[i] = tmp;
+			} // end valueIsSmallerEqual
+		} // endfor
+		return left + 1;
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/meta/ADACC.java b/moa/src/main/java/moa/learners/predictors/meta/ADACC.java
new file mode 100644
index 000000000..d54cac097
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/meta/ADACC.java
@@ -0,0 +1,295 @@
+/*
+ *    ADACC.java
+ *
+ *    @author Ghazal Jaber (ghazal.jaber@gmail.com)
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.predictors.meta;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
+import moa.core.Measurement;
+import moa.core.Utils;
+import moa.learners.predictors.Classifier;
+
+/**
+ * Anticipative and Dynamic Adaptation to Concept Changes. Ensemble method for
+ * data streams that adapts to concept changes and deals with concept
+ * recurrence.
+ *
+ * Reference: JABER, G., CORNUEJOLS, A., and TARROUX, P. A New On-Line Learning
+ * Method for Coping with Recurring Concepts: The ADACC System. In : Neural
+ * Information Processing. Springer Berlin Heidelberg, 2013. p. 595-604.
+ *
+ * @author Ghazal Jaber (ghazal.jaber@gmail.com)
+ *
+ */
+
+public class ADACC extends DACC {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Anticipative and Dynamic Adaptation to Concept Changes for data streams.";
+	}
+
+	/**
+	 * Evaluation window for the stability index computation
+	 */
+	public IntOption tauSizeOption = new IntOption("tau", 't',
+			"The size of the evaluation window for the meta-learning.", 100, 1, 10000);
+	/**
+	 * Threshold for the stability index
+	 */
+	public FloatOption stabIndexSizeOption = new FloatOption("StabThr", 'z', "The threshold for stability", 0.8, 0, 1);
+	/**
+	 * Threshold for concept equivalence
+	 */
+	public FloatOption equivIndexSizeOption = new FloatOption("CeThr", 'q', "The threshold for concept equivalence",
+			0.7, 0, 1);
+	/**
+	 * Size of the evaluation window to compute the stability index
+	 */
+	protected int tau_size = 0;
+	/**
+	 * Last chunk of data of size (tau_size) to compute the stability index
+	 */
+	protected InstancesHeader recentChunk;
+	/**
+	 * Threshold values for the stability index and concept equivalence
+	 */
+	protected double theta_stab, theta_diff;
+	/**
+	 * Current stability index
+	 */
+	protected double index;
+	/**
+	 * Maximum number of snapshots (copies of classifiers kept in case of
+	 * recurrence)
+	 */
+	protected final static int MAXPERMANENT = 100;
+	/**
+	 * Number of added snapshots
+	 */
+	protected int addedPermanent = 0;
+
+	@Override
+	protected void initVariables() {
+
+		this.tau_size = this.tauSizeOption.getValue();
+		this.theta_stab = this.stabIndexSizeOption.getValue();
+		this.theta_diff = this.equivIndexSizeOption.getValue();
+		this.recentChunk = null;
+
+		int ensembleSize = (int) this.memberCountOption.getValue() + MAXPERMANENT;
+		this.ensemble = new Classifier[ensembleSize];
+		this.ensembleAges = new double[ensembleSize];
+		this.ensembleWindows = new int[ensembleSize][(int) this.evaluationSizeOption.getValue()];
+
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+
+		if (recentChunk == null)
+			recentChunk = this.getModelContext().getEmptyHeader();
+
+		if (recentChunk.size() < this.tau_size)
+			recentChunk.add(inst);
+		else
+			recentChunk.set(this.nbInstances % this.tau_size, inst);
+
+		trainAndClassify(inst);
+
+		if ((this.nbInstances % this.tau_size) == 0)
+			takeSnapshot();
+	}
+
+	/**
+	 * If the environment is stable enough, take a snapshot (a copy) of the best
+	 * adaptive classifier and keep it for future use, in case of concept recurrence
+	 */
+	private void takeSnapshot() {
+
+		this.index = computeStabilityIndex();
+
+		if (this.index >= this.theta_stab)
+			if (addedPermanent == 0) {
+				this.ensemble[this.ensemble.length - MAXPERMANENT
+						+ addedPermanent] = (Classifier) getBestAdaptiveClassifier().copy();
+				addedPermanent++;
+			} else {
+
+				Classifier candidate = (Classifier) getBestAdaptiveClassifier().copy();
+
+				boolean duplicate = false;
+				for (int j = 0; j < Math.min(MAXPERMANENT, addedPermanent); j++) {
+					Classifier lastSnapshot = this.ensemble[this.ensemble.length - MAXPERMANENT + j];
+
+					int[][] votes = new int[2][tau_size];
+					for (int k = 0; k < tau_size; k++) {
+						votes[0][k] = Utils.maxIndex(candidate.getPredictionForInstance(recentChunk.get(k)));
+						votes[1][k] = Utils.maxIndex(lastSnapshot.getPredictionForInstance(recentChunk.get(k)));
+					}
+					double kappa = computeKappa(votes[0], votes[1]);
+
+					if (kappa >= this.theta_diff) {
+						duplicate = true;
+						break;
+					}
+				}
+				if (!duplicate) {
+					this.ensemble[this.ensemble.length - MAXPERMANENT + (addedPermanent % MAXPERMANENT)] = candidate;
+					addedPermanent++;
+				}
+			}
+	}
+
+	/**
+	 * Returns the kappa statistics, a statistical measure of agreement in the
+	 * predictions of 2 classifiers. Used as a measure of diversity of predictive
+	 * models: the higher the kappa value, the smaller the diversity
+	 * 
+	 * @param y1 the predictions of classifier A
+	 * @param y2 the predictions of classifier B
+	 * @return the kappa measure
+	 */
+	private double computeKappa(int[] y1, int[] y2) {
+
+		int m = y1.length;
+
+		double theta1 = 0;
+		double counts[][] = new double[2][this.modelContext.numClasses()];
+
+		for (int i = 0; i < m; i++) {
+
+			if (y1[i] == y2[i])
+				theta1 = theta1 + 1;
+
+			counts[0][y1[i]] = counts[0][y1[i]] + 1;
+			counts[1][y2[i]] = counts[1][y2[i]] + 1;
+
+		}
+
+		theta1 = theta1 / m;
+
+		double theta2 = 0;
+
+		for (int i = 0; i < this.modelContext.numClasses(); i++)
+			theta2 += counts[0][i] / m * counts[1][i] / m;
+
+		if (theta1 == theta2 && theta2 == 1)
+			return 1;
+
+		return (theta1 - theta2) / (1 - theta2);
+	}
+
+	/**
+	 * Returns the stability index of the adaptive ensemble of classifiers. The
+	 * ensemble is considered stable here if its diversity level and error rates are
+	 * low.
+	 * 
+	 * @return the stability measure value
+	 */
+	private double computeStabilityIndex() {
+
+		int m = (int) Math.floor((this.ensemble.length - MAXPERMANENT) / 2);
+		int[][] votes = new int[m][tau_size];
+		double errors = 0;
+		int count = 0;
+
+		Pair[] arr = getHalf(true);
+
+		for (int i = 0; i < m; i++) {
+			for (int j = 0; j < tau_size; j++) {
+				votes[i][j] = Utils.maxIndex(this.ensemble[arr[i].index].getPredictionForInstance(recentChunk.get(j)));
+				errors += (votes[i][j] == (int) this.recentChunk.get(j).classValue()) ? 0 : 1;
+				count++;
+			}
+		}
+		errors = errors / count;
+
+		double res = 0;
+		count = 0;
+		for (int i = 0; i < m; i++)
+			for (int j = i + 1; j < m; j++)
+				if (i != j) {
+					res += computeKappa(votes[i], votes[j]);
+					count++;
+				}
+
+		return res / count - errors;
+	}
+
+	/**
+	 * Returns the adaptive classifier with the highest weight
+	 * 
+	 * @return the best adaptive classifier
+	 */
+	private Classifier getBestAdaptiveClassifier() {
+
+		// take a copy of the ensemble weights (excluding snapshots)
+		Pair[] newEnsembleWeights = new Pair[ensembleWeights.length - MAXPERMANENT];
+		for (int i = 0; i < newEnsembleWeights.length; i++)
+			newEnsembleWeights[i] = ensembleWeights[i];
+
+		// sort the weight values
+		Arrays.sort(newEnsembleWeights, Collections.reverseOrder());
+
+		return (Classifier) this.ensemble[newEnsembleWeights[0].index].copy();
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		Measurement[] measurements = new Measurement[10];
+
+		measurements[0] = new Measurement("size ", this.ensemble.length - MAXPERMANENT);
+		measurements[1] = new Measurement("maturity ", this.maturityOption.getValue());
+		measurements[2] = new Measurement("evalsize ", this.evaluationSizeOption.getValue());
+		measurements[3] = new Measurement("cmb ", this.combinationOption.getChosenIndex());
+		measurements[4] = new Measurement("tau", this.tau_size);
+		measurements[5] = new Measurement("MaxSnapshotsSize", MAXPERMANENT);
+		measurements[6] = new Measurement("SnapshotsSize", this.addedPermanent);
+		measurements[7] = new Measurement("stabilityIndex", this.index);
+		measurements[8] = new Measurement("stabilityThreshold", this.theta_stab);
+		measurements[9] = new Measurement("differenceThreshold", this.theta_diff);
+
+		return measurements;
+	}
+
+	@Override
+	protected int getNbActiveClassifiers() {
+		return ensemble.length - MAXPERMANENT + Math.min(addedPermanent, MAXPERMANENT);
+	}
+
+	@Override
+	protected int getNbAdaptiveClassifiers() {
+		return this.ensemble.length - MAXPERMANENT;
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/meta/ADOB.java b/moa/src/main/java/moa/learners/predictors/meta/ADOB.java
new file mode 100644
index 000000000..030ab3865
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/meta/ADOB.java
@@ -0,0 +1,208 @@
+/*
+ *    ADOB.java
+ *    Copyright (C) 2014 Santos, Goncalves, Barros
+ *    @author Silas G. T. C. Santos (sgtcs@cin.ufpe.br)
+ *            Paulo M. Goncalves Jr. (paulomgj@gmail.com)
+ *            Roberto S. M. Barros (roberto@cin.ufpe.br)
+ *    @version $Version: 1 $
+ *
+ *    Evolved from OzaBoost.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *    @version $Revision: 7 $
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+package moa.learners.predictors.meta;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.MiscUtils;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.options.ClassOption;
+
+/**
+ * Adaptable Diversity-based Online Boosting (ADOB) is a modified version of the
+ * online boosting, as proposed by Oza and Russell, which is aimed at speeding
+ * up the experts recovery after concept drifts.
+ *
+ * published as: Silas G. T. C. Santos, Paulo M. Goncalves Jr., Geyson D. S.
+ * Silva, and Roberto S. M. Barros: Speeding Up Recovery from Concept Drifts. In
+ * book: Machine Learning and Knowledge Discovery in Databases, ECML/PKDD 2014,
+ * Part III, LNCS 8726, pp. 179-194. 09/2014. DOI: 10.1007/978-3-662-44845-8_12
+ */
+
+public class ADOB extends AbstractClassifier {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Adaptable Diversity-based Online Boosting (ADOB)";
+	}
+
+	public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l', "Classifier to train.", Classifier.class,
+			"drift.DriftDetectionMethodClassifier -l trees.HoeffdingTree -d ADWINChangeDetector");
+
+	public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's', "The number of models to boost.", 10, 1,
+			Integer.MAX_VALUE);
+
+	public FlagOption pureBoostOption = new FlagOption("pureBoost", 'p', "Boost with weights only; no poisson.");
+
+	protected Classifier[] ensemble;
+
+	protected int[] orderPosition;
+
+	protected double[] scms;
+
+	protected double[] swms;
+
+	@Override
+	public void resetLearningImpl() {
+		this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
+		this.orderPosition = new int[this.ensemble.length];
+		Classifier baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
+		baseLearner.resetLearning();
+		for (int i = 0; i < this.ensemble.length; i++) {
+			this.ensemble[i] = (Classifier) baseLearner.copy();
+			this.orderPosition[i] = i;
+		}
+		this.scms = new double[this.ensemble.length];
+		this.swms = new double[this.ensemble.length];
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		// Calculates current accuracy of experts
+		double[] acc = new double[this.ensemble.length];
+		for (int i = 0; i < this.ensemble.length; i++) {
+			acc[i] = this.scms[this.orderPosition[i]] + this.swms[this.orderPosition[i]];
+			if (acc[i] != 0.0) {
+				acc[i] = this.scms[this.orderPosition[i]] / acc[i];
+			}
+		}
+
+		// Sort by accuracy in ascending order
+		double key_acc;
+		int key_position, j;
+		for (int i = 1; i < this.ensemble.length; i++) {
+			key_position = this.orderPosition[i];
+			key_acc = acc[i];
+			j = i - 1;
+			while (j >= 0 && acc[j] < key_acc) {
+				this.orderPosition[j + 1] = this.orderPosition[j];
+				acc[j + 1] = acc[j];
+				j--;
+			}
+			this.orderPosition[j + 1] = key_position;
+			acc[j + 1] = key_acc;
+		}
+
+		boolean correct = false;
+		int pos;
+		double lambda_d = 1.0;
+		int maxAcc = 0, minAcc = this.ensemble.length - 1;
+		for (int i = 0; i < this.ensemble.length; i++) {
+			if (correct) {
+				pos = this.orderPosition[maxAcc];
+				maxAcc++;
+			} else {
+				pos = this.orderPosition[minAcc];
+				minAcc--;
+			}
+
+			double k;
+			if (this.pureBoostOption.isSet()) {
+				k = lambda_d;
+			} else {
+				k = MiscUtils.poisson(lambda_d, this.classifierRandom);
+			}
+
+			if (k > 0.0) {
+				Instance weightedInst = inst.copy();
+				weightedInst.setWeight(inst.weight() * k);
+				this.ensemble[pos].trainOnInstance(weightedInst);
+			}
+
+			// Increases or decreases lambda based on the prediction of instance
+			if (this.ensemble[pos].correctlyClassifies(inst)) {
+				this.scms[pos] += lambda_d;
+				lambda_d *= this.trainingWeightSeenByModel / (2 * this.scms[pos]);
+				correct = true;
+			} else {
+				this.swms[pos] += lambda_d;
+				lambda_d *= this.trainingWeightSeenByModel / (2 * this.swms[pos]);
+				correct = false;
+			}
+		}
+	}
+
+	protected double getEnsembleMemberWeight(int i) {
+		if (this.scms[i] > 0.0 && this.swms[i] > 0.0) {
+			double em = this.swms[i] / (this.scms[i] + this.swms[i]);
+			if (em <= 0.5) {
+				double Bm = em / (1.0 - em);
+				return Math.log(1.0 / Bm);
+			}
+		}
+		return 0.0;
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		DoubleVector combinedVote = new DoubleVector();
+		for (int i = 0; i < this.ensemble.length; i++) {
+			double memberWeight = getEnsembleMemberWeight(i);
+			if (memberWeight > 0.0) {
+				DoubleVector vote = new DoubleVector(this.ensemble[i].getPredictionForInstance(inst).asDoubleArray());
+				if (vote.sumOfValues() > 0.0) {
+					vote.normalize();
+					vote.scaleValues(memberWeight);
+					combinedVote.addValues(vote);
+				}
+			} else {
+				break;
+			}
+		}
+
+		return new ClassificationPrediction(combinedVote.getArrayRef());
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[] { new Measurement("ensemble size", this.ensemble != null ? this.ensemble.length : 0) };
+	}
+
+	@Override
+	public Classifier[] getSubClassifiers() {
+		return this.ensemble.clone();
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/meta/AbstractOzaBag.java b/moa/src/main/java/moa/learners/predictors/meta/AbstractOzaBag.java
similarity index 70%
rename from moa/src/main/java/moa/classifiers/meta/AbstractOzaBag.java
rename to moa/src/main/java/moa/learners/predictors/meta/AbstractOzaBag.java
index ee0ac5113..4df014271 100644
--- a/moa/src/main/java/moa/classifiers/meta/AbstractOzaBag.java
+++ b/moa/src/main/java/moa/learners/predictors/meta/AbstractOzaBag.java
@@ -15,35 +15,42 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.classifiers.meta;
+package moa.learners.predictors.meta;
 
 import com.github.javacliparser.FloatOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
-import moa.classifiers.AbstractEnsembleLearner;
 import moa.core.MiscUtils;
 import moa.core.Utils;
-import moa.learners.InstanceLearner;
+import moa.learners.predictors.AbstractEnsembleLearner;
+import moa.learners.predictors.InstanceLearner;
 import moa.options.ClassOption;
 
 /**
  * Incremental on-line bagging of Oza and Russell.
  *
- * <p>Oza and Russell developed online versions of bagging and boosting for
- * Data Streams. They show how the process of sampling bootstrap replicates
- * from training data can be simulated in a data stream context. They observe
- * that the probability that any individual example will be chosen for a
- * replicate tends to a Poisson(1) distribution.</p>
+ * <p>
+ * Oza and Russell developed online versions of bagging and boosting for Data
+ * Streams. They show how the process of sampling bootstrap replicates from
+ * training data can be simulated in a data stream context. They observe that
+ * the probability that any individual example will be chosen for a replicate
+ * tends to a Poisson(1) distribution.
+ * </p>
  *
- * <p>[OR] N. Oza and S. Russell. Online bagging and boosting.
- * In Artificial Intelligence and Statistics 2001, pages 105–112.
- * Morgan Kaufmann, 2001.</p>
+ * <p>
+ * [OR] N. Oza and S. Russell. Online bagging and boosting. In Artificial
+ * Intelligence and Statistics 2001, pages 105–112. Morgan Kaufmann, 2001.
+ * </p>
  *
- * <p>Parameters:</p> <ul>
+ * <p>
+ * Parameters:
+ * </p>
+ * <ul>
  * <li>-l : Classifier to train</li>
- * <li>-s : The number of models in the bag</li> </ul>
+ * <li>-s : The number of models in the bag</li>
+ * </ul>
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
@@ -51,7 +58,7 @@
 public abstract class AbstractOzaBag<MLTask extends InstanceLearner> extends AbstractEnsembleLearner<MLTask> {
 
 	public FloatOption lambdaOption = new FloatOption("lambda", 'u', "Lambda parameter of Poisson distribution", 1);
-	
+
 	public AbstractOzaBag(Class<MLTask> task, String defaultCLIString) {
 		super(task);
 		this.baseLearnerOption = new ClassOption("baseLearner", 'l', "Classifier to train.", task, defaultCLIString);
@@ -69,31 +76,32 @@ public boolean isRandomizable() {
 		return true;
 	}
 
+	@Override
 	public void trainOnInstanceImpl(Instance inst) {
 		for (int i = 0; i < this.ensemble.size(); i++) {
 			int k = MiscUtils.poisson(lambdaOption.getValue(), this.classifierRandom);
 			if (k > 0) {
-				Instance weightedInst = (Instance) inst.copy();
+				Instance weightedInst = inst.copy();
 				weightedInst.setWeight(inst.weight() * k);
 				this.ensemble.get(i).trainOnInstance(weightedInst);
 			}
 		}
 	}
-	
+
 	@Override
 	public void getModelDescription(StringBuilder out, int indent) {
 		// TODO Auto-generated method stub
-		
+
 	}
-	
+
+	@Override
 	public boolean correctlyClassifies(Instance inst) {
 		// This is here for easy implementation of ensemble classifiers.
-        return Utils.maxIndex(getPredictionForInstance(inst)) == (int) inst.classValue();
+		return Utils.maxIndex(getPredictionForInstance(inst)) == (int) inst.classValue();
 	}
 
-	
-	//    @Override
-	//    public Classifier[] getSubClassifiers() {
-	//        return this.ensemble.clone();
-	//    }
+	// @Override
+	// public Classifier[] getSubClassifiers() {
+	// return this.ensemble.clone();
+	// }
 }
diff --git a/moa/src/main/java/moa/learners/predictors/meta/AbstractOzaBagAdwin.java b/moa/src/main/java/moa/learners/predictors/meta/AbstractOzaBagAdwin.java
new file mode 100644
index 000000000..29b591f26
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/meta/AbstractOzaBagAdwin.java
@@ -0,0 +1,175 @@
+/*
+ *    OzaBagAdwin.java
+ *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.meta;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.capabilities.CapabilitiesHandler;
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
+import moa.core.Measurement;
+import moa.core.MiscUtils;
+import moa.learners.predictors.InstanceLearner;
+import moa.learners.predictors.core.driftdetection.ADWIN;
+
+/**
+ * Bagging for evolving data streams using ADWIN.
+ *
+ * <p>
+ * ADWIN is a change detector and estimator that solves in a well-specified way
+ * the problem of tracking the average of a stream of bits or real-valued
+ * numbers. ADWIN keeps a variable-length window of recently seen items, with
+ * the property that the window has the maximal length statistically consistent
+ * with the hypothesis “there has been no change in the average value inside the
+ * window”.<br />
+ * More precisely, an older fragment of the window is dropped if and only if
+ * there is enough evidence that its average value differs from that of the rest
+ * of the window. This has two consequences: one, that change reliably declared
+ * whenever the window shrinks; and two, that at any time the average over the
+ * existing window can be reliably taken as an estimation of the current average
+ * in the stream (barring a very small or very recent change that is still not
+ * statistically visible). A formal and quantitative statement of these two
+ * points (a theorem) appears in
+ * <p>
+ *
+ * Albert Bifet and Ricard Gavaldà. Learning from time-changing data with
+ * adaptive windowing. In SIAM International Conference on Data Mining, 2007.
+ * </p>
+ * <p>
+ * ADWIN is parameter- and assumption-free in the sense that it automatically
+ * detects and adapts to the current rate of change. Its only parameter is a
+ * confidence bound δ, indicating how confident we want to be in the algorithm’s
+ * output, inherent to all algorithms dealing with random processes. Also
+ * important, ADWIN does not maintain the window explicitly, but compresses it
+ * using a variant of the exponential histogram technique. This means that it
+ * keeps a window of length W using only O(log W) memory and O(log W) processing
+ * time per item.<br />
+ * ADWIN Bagging is the online bagging method of Oza and Rusell with the
+ * addition of the ADWIN algorithm as a change detector and as an estimator for
+ * the weights of the boosting method. When a change is detected, the worst
+ * classifier of the ensemble of classifiers is removed and a new classifier is
+ * added to the ensemble.
+ * </p>
+ * <p>
+ * See details in:<br />
+ * [BHPKG] Albert Bifet, Geoff Holmes, Bernhard Pfahringer, Richard Kirkby, and
+ * Ricard Gavaldà . New ensemble methods for evolving data streams. In 15th ACM
+ * SIGKDD International Conference on Knowledge Discovery and Data Mining, 2009.
+ * </p>
+ * <p>
+ * Example:
+ * </p>
+ * <code>OzaBagAdwin -l HoeffdingTreeNBAdaptive -s 10</code>
+ * <p>
+ * Parameters:
+ * </p>
+ * <ul>
+ * <li>-l : Classifier to train</li>
+ * <li>-s : The number of models in the bag</li>
+ * </ul>
+ *
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @version $Revision: 7 $
+ */
+public abstract class AbstractOzaBagAdwin<MLTask extends InstanceLearner> extends AbstractOzaBag<MLTask>
+		implements CapabilitiesHandler {
+
+	private static final long serialVersionUID = 1L;
+
+	public AbstractOzaBagAdwin(Class<MLTask> MLTask, String defaultCLIString) {
+		super(MLTask, defaultCLIString);
+	}
+
+	@Override
+	public String getPurposeString() {
+		return "Bagging for evolving data streams using ADWIN.";
+	}
+
+	protected ADWIN[] ADError;
+
+	@Override
+	public void resetLearningImpl() {
+		super.resetLearningImpl();
+		this.ADError = new ADWIN[this.ensemble.size()];
+		for (int i = 0; i < this.ensemble.size(); i++) {
+			this.ADError[i] = new ADWIN();
+		}
+	}
+
+	public abstract double getAdwinError(Instance inst, int i);
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		boolean Change = false;
+		for (int i = 0; i < this.ensemble.size(); i++) {
+			int k = MiscUtils.poisson(6.0, this.classifierRandom);
+			if (k > 0) {
+				Instance weightedInst = inst.copy();
+				weightedInst.setWeight(inst.weight() * k);
+				this.ensemble.get(i).trainOnInstance(weightedInst);
+			}
+			double ErrEstim = this.ADError[i].getEstimation();
+			if (this.ADError[i].setInput(this.getAdwinError(inst, i))) {
+				if (this.ADError[i].getEstimation() > ErrEstim) {
+					Change = true;
+				}
+			}
+		}
+		if (Change) {
+			double max = 0.0;
+			int imax = -1;
+			for (int i = 0; i < this.ensemble.size(); i++) {
+				if (max < this.ADError[i].getEstimation()) {
+					max = this.ADError[i].getEstimation();
+					imax = i;
+				}
+			}
+			if (imax != -1) {
+				this.ensemble.get(imax).resetLearning();
+				this.ensemble.get(imax).setRandomSeed(this.ensemble.get(imax).getRandomSeed() * 2);
+				this.ensemble.get(imax).trainOnInstance(inst);
+				this.ADError[imax] = new ADWIN();
+			}
+		}
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[] { new Measurement("ensemble size", this.ensemble != null ? this.ensemble.size() : 0) };
+	}
+
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this instanceof AbstractOzaBagAdwin)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/meta/AbstractOzaBoost.java b/moa/src/main/java/moa/learners/predictors/meta/AbstractOzaBoost.java
new file mode 100644
index 000000000..498a726f9
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/meta/AbstractOzaBoost.java
@@ -0,0 +1,154 @@
+/*
+ *    OzaBoost.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.meta;
+
+import com.github.javacliparser.FlagOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Measurement;
+import moa.core.MiscUtils;
+import moa.learners.predictors.AbstractEnsembleLearner;
+import moa.learners.predictors.InstanceLearner;
+import moa.options.ClassOption;
+
+/**
+ * Incremental on-line boosting of Oza and Russell.
+ *
+ * <p>
+ * See details in:<br />
+ * N. Oza and S. Russell. Online bagging and boosting. In Artificial Intelligence
+ * and Statistics 2001, pages 105–112. Morgan Kaufmann, 2001.
+ * </p>
+ * <p>
+ * For the boosting method, Oza and Russell note that the weighting procedure of
+ * AdaBoost actually divides the total example weight into two halves – half of
+ * the weight is assigned to the correctly classified examples, and the other
+ * half goes to the misclassified examples. They use the Poisson distribution for
+ * deciding the random probability that an example is used for training, only
+ * this time the parameter changes according to the boosting weight of the
+ * example as it is passed through each model in sequence.
+ * </p>
+ *
+ * <p>
+ * Parameters:
+ * </p>
+ * <ul>
+ * <li>-l : Classifier to train</li>
+ * <li>-s : The number of models to boost</li>
+ * <li>-p : Boost with weights only; no poisson</li>
+ * </ul>
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public abstract class AbstractOzaBoost<MLTask extends InstanceLearner> extends AbstractEnsembleLearner<MLTask> {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Incremental on-line boosting of Oza and Russell.";
+	}
+
+	public AbstractOzaBoost(Class<MLTask> task, String defaultCLIString) {
+		super(task);
+		this.baseLearnerOption = new ClassOption("baseLearner", 'l', "Classifier to train.", task, defaultCLIString);
+	}
+
+	public FlagOption pureBoostOption = new FlagOption("pureBoost", 'p', "Boost with weights only; no poisson.");
+
+	protected double[] scms;
+
+	protected double[] swms;
+
+	@Override
+	public void resetLearningImpl() {
+		super.resetLearningImpl();
+
+		this.scms = new double[this.ensemble.size()];
+		this.swms = new double[this.ensemble.size()];
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		double lambda_d = 1.0;
+		for (int i = 0; i < this.ensemble.size(); i++) {
+			double k = this.pureBoostOption.isSet() ? lambda_d : MiscUtils.poisson(lambda_d, this.classifierRandom);
+			if (k > 0.0) {
+				Instance weightedInst = inst.copy();
+				weightedInst.setWeight(inst.weight() * k);
+				this.ensemble.get(i).trainOnInstance(weightedInst);
+			}
+			lambda_d = updateWeight(i, inst, lambda_d);
+		}
+	}
+
+	public abstract double updateWeight(int i, Instance inst, double lambda_d);
+
+	protected double getEnsembleMemberWeight(int i) {
+		double em = this.swms[i] / (this.scms[i] + this.swms[i]);
+		if ((em == 0.0) || (em > 0.5)) {
+			return 0.0;
+		}
+		double Bm = em / (1.0 - em);
+		return Math.log(1.0 / Bm);
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		Prediction[] predictions = new Prediction[this.ensemble.size()];
+		double[] weights = new double[this.ensemble.size()];
+		for (int i = 0; i < this.ensemble.size(); i++) {
+			weights[i] = getEnsembleMemberWeight(i);
+			if (weights[i] > 0.0) {
+				predictions[i] = this.ensemble.get(i).getPredictionForInstance(inst);
+
+			} else {
+				break;
+			}
+		}
+		return combinePredictions(predictions, weights);
+	}
+
+	public abstract Prediction combinePredictions(Prediction[] predictions, double[] weights);
+
+	@Override
+	public Prediction combinePredictions(Prediction[] prediction) {
+		throw new UnsupportedOperationException(
+				"This is a boosting ensemble and does not use unweighted combining of predictions.");
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[] { new Measurement("ensemble size", this.ensemble != null ? this.ensemble.size() : 0) };
+	}
+
+}
diff --git a/moa/src/main/java/moa/classifiers/meta/AccuracyUpdatedEnsemble.java b/moa/src/main/java/moa/learners/predictors/meta/AccuracyUpdatedEnsemble.java
similarity index 84%
rename from moa/src/main/java/moa/classifiers/meta/AccuracyUpdatedEnsemble.java
rename to moa/src/main/java/moa/learners/predictors/meta/AccuracyUpdatedEnsemble.java
index 602b16afe..620a51aab 100644
--- a/moa/src/main/java/moa/classifiers/meta/AccuracyUpdatedEnsemble.java
+++ b/moa/src/main/java/moa/learners/predictors/meta/AccuracyUpdatedEnsemble.java
@@ -17,7 +17,7 @@
  *    along with this program; if not, write to the Free Software
  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
-package moa.classifiers.meta;
+package moa.learners.predictors.meta;
 
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
@@ -25,12 +25,12 @@
 import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.trees.HoeffdingTree;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
-import moa.learners.Classifier;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.trees.HoeffdingTree;
 import moa.options.ClassOption;
 import moa.tasks.TaskMonitor;
 
@@ -46,8 +46,8 @@ public class AccuracyUpdatedEnsemble extends AbstractClassifier implements Class
 	/**
 	 * Type of classifier to use as a component classifier.
 	 */
-	public ClassOption learnerOption = new ClassOption("learner", 'l', "Classifier to train.", Classifier.class, 
-			"moa.classifiers.trees.HoeffdingTree -e 2000000 -g 100 -c 0.01");
+	public ClassOption learnerOption = new ClassOption("learner", 'l', "Classifier to train.", Classifier.class,
+			"trees.HoeffdingTree -e 2000000 -g 100 -c 0.01");
 
 	/**
 	 * Number of component classifiers.
@@ -68,32 +68,31 @@ public class AccuracyUpdatedEnsemble extends AbstractClassifier implements Class
 			33554432, 0, Integer.MAX_VALUE);
 
 	/**
-	 * The weights of stored classifiers. 
-	 * weights[x][0] = weight
-	 * weights[x][1] = classifier number in learners
+	 * The weights of stored classifiers. weights[x][0] = weight weights[x][1] =
+	 * classifier number in learners
 	 */
 	protected double[][] weights;
-	
+
 	/**
 	 * Class distributions.
 	 */
 	protected long[] classDistributions;
-	
+
 	/**
 	 * Ensemble classifiers.
 	 */
 	protected Classifier[] learners;
-	
+
 	/**
 	 * Number of processed examples.
 	 */
 	protected int processedInstances;
-	
+
 	/**
 	 * Candidate classifier.
 	 */
 	protected Classifier candidate;
-	
+
 	/**
 	 * Current chunk of instances.
 	 */
@@ -134,6 +133,7 @@ public void trainOnInstanceImpl(Instance inst) {
 	/**
 	 * Determines whether the classifier is randomizable.
 	 */
+	@Override
 	public boolean isRandomizable() {
 		return false;
 	}
@@ -141,13 +141,15 @@ public boolean isRandomizable() {
 	/**
 	 * Predicts a class for an example.
 	 */
+	@Override
 	public Prediction getPredictionForInstance(Instance inst) {
 		DoubleVector combinedVote = new DoubleVector();
 
 		if (this.trainingWeightSeenByModel > 0.0) {
 			for (int i = 0; i < this.learners.length; i++) {
 				if (this.weights[i][0] > 0.0) {
-					DoubleVector vote = this.learners[(int) this.weights[i][1]].getPredictionForInstance(inst).asDoubleVector();
+					DoubleVector vote = this.learners[(int) this.weights[i][1]].getPredictionForInstance(inst)
+							.asDoubleVector();
 
 					if (vote.sumOfValues() > 0.0) {
 						vote.normalize();
@@ -158,8 +160,8 @@ public Prediction getPredictionForInstance(Instance inst) {
 				}
 			}
 		}
-		
-		//combinedVote.normalize();
+
+		// combinedVote.normalize();
 		return new ClassificationPrediction(combinedVote.getArrayRef());
 	}
 
@@ -167,13 +169,14 @@ public Prediction getPredictionForInstance(Instance inst) {
 	public void getModelDescription(StringBuilder out, int indent) {
 	}
 
+	@Override
 	public Classifier[] getSubClassifiers() {
 		return this.learners.clone();
 	}
 
 	/**
-	 * Processes a chunk of instances.
-	 * This method is called after collecting a chunk of examples.
+	 * Processes a chunk of instances. This method is called after collecting a
+	 * chunk of examples.
 	 */
 	protected void processChunk() {
 		Classifier addedClassifier = null;
@@ -183,8 +186,9 @@ protected void processChunk() {
 		double candidateClassifierWeight = 1.0 / (mse_r + Double.MIN_VALUE);
 
 		for (int i = 0; i < this.learners.length; i++) {
-			this.weights[i][0] = 1.0 / (mse_r + this.computeMse(this.learners[(int) this.weights[i][1]], this.currentChunk) + Double.MIN_VALUE);
-		}	
+			this.weights[i][0] = 1.0 / (mse_r
+					+ this.computeMse(this.learners[(int) this.weights[i][1]], this.currentChunk) + Double.MIN_VALUE);
+		}
 
 		if (this.learners.length < this.memberCountOption.getValue()) {
 			// Train and add classifier
@@ -214,21 +218,22 @@ protected void processChunk() {
 	}
 
 	/**
-	 * Checks if the memory limit is exceeded and if so prunes the classifiers in the ensemble.
+	 * Checks if the memory limit is exceeded and if so prunes the classifiers in
+	 * the ensemble.
 	 */
 	protected void enforceMemoryLimit() {
 		double memoryLimit = this.maxByteSizeOption.getValue() / (double) (this.learners.length + 1);
 
 		for (int i = 0; i < this.learners.length; i++) {
-			((HoeffdingTree) this.learners[(int) this.weights[i][1]]).maxByteSizeOption.setValue((int) Math
-					.round(memoryLimit));
+			((HoeffdingTree) this.learners[(int) this.weights[i][1]]).maxByteSizeOption
+					.setValue((int) Math.round(memoryLimit));
 			((HoeffdingTree) this.learners[(int) this.weights[i][1]]).enforceTrackerLimit();
 		}
 	}
 
 	/**
 	 * Computes the MSEr threshold.
-	 * 
+	 *
 	 * @return The MSEr threshold.
 	 */
 	protected double computeMseR() {
@@ -242,11 +247,12 @@ protected double computeMseR() {
 
 		return mse_r;
 	}
-	
+
 	/**
 	 * Computes the MSE of a learner for a given chunk of examples.
+	 * 
 	 * @param learner classifier to compute error
-	 * @param chunk chunk of examples
+	 * @param chunk   chunk of examples
 	 * @return the computed error.
 	 */
 	protected double computeMse(Classifier learner, InstancesHeader chunk) {
@@ -263,8 +269,8 @@ protected double computeMse(Classifier learner, InstancesHeader chunk) {
 				}
 
 				if (voteSum > 0) {
-					f_ci = learner.getPredictionForInstance(chunk.instance(i)).asDoubleArray()[(int) chunk.instance(i).classValue()]
-							/ voteSum;
+					f_ci = learner.getPredictionForInstance(chunk.instance(i))
+							.asDoubleArray()[(int) chunk.instance(i).classValue()] / voteSum;
 					mse_i += (1 - f_ci) * (1 - f_ci);
 				} else {
 					mse_i += 1;
@@ -278,13 +284,13 @@ protected double computeMse(Classifier learner, InstancesHeader chunk) {
 
 		return mse_i;
 	}
-	
+
 	/**
 	 * Adds ensemble weights to the measurements.
 	 */
 	@Override
 	protected Measurement[] getModelMeasurementsImpl() {
-		Measurement[] measurements = new Measurement[(int) this.memberCountOption.getValue()];
+		Measurement[] measurements = new Measurement[this.memberCountOption.getValue()];
 
 		for (int m = 0; m < this.memberCountOption.getValue(); m++) {
 			measurements[m] = new Measurement("Member weight " + (m + 1), -1);
@@ -301,11 +307,9 @@ protected Measurement[] getModelMeasurementsImpl() {
 
 	/**
 	 * Adds a classifier to the storage.
-	 * 
-	 * @param newClassifier
-	 *            The classifier to add.
-	 * @param newClassifiersWeight
-	 *            The new classifiers weight.
+	 *
+	 * @param newClassifier        The classifier to add.
+	 * @param newClassifiersWeight The new classifiers weight.
 	 */
 	protected Classifier addToStored(Classifier newClassifier, double newClassifiersWeight) {
 		Classifier addedClassifier = null;
@@ -328,23 +332,24 @@ protected Classifier addToStored(Classifier newClassifier, double newClassifiers
 
 		return addedClassifier;
 	}
-	
+
 	/**
 	 * Finds the index of the classifier with the smallest weight.
+	 * 
 	 * @return
 	 */
 	private int getPoorestClassifierIndex() {
 		int minIndex = 0;
-		
+
 		for (int i = 1; i < this.weights.length; i++) {
-			if(this.weights[i][0] < this.weights[minIndex][0]){
+			if (this.weights[i][0] < this.weights[minIndex][0]) {
 				minIndex = i;
 			}
 		}
-		
+
 		return minIndex;
 	}
-	
+
 	/**
 	 * Initiates the current chunk and class distribution variables.
 	 */
@@ -361,12 +366,11 @@ private void initVariables() {
 			}
 		}
 	}
-	
+
 	/**
 	 * Trains a component classifier on the most recent chunk of data.
-	 * 
-	 * @param classifierToTrain
-	 *            Classifier being trained.
+	 *
+	 * @param classifierToTrain Classifier being trained.
 	 */
 	private void trainOnChunk(Classifier classifierToTrain) {
 		for (int num = 0; num < this.chunkSizeOption.getValue(); num++) {
diff --git a/moa/src/main/java/moa/learners/predictors/meta/AccuracyWeightedEnsemble.java b/moa/src/main/java/moa/learners/predictors/meta/AccuracyWeightedEnsemble.java
new file mode 100644
index 000000000..37ab63757
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/meta/AccuracyWeightedEnsemble.java
@@ -0,0 +1,481 @@
+/*
+ *    AccuracyWeightedEnsemble.java
+ *    Copyright (C) 2010 Poznan University of Technology, Poznan, Poland
+ *    @author Dariusz Brzezinski (dariusz.brzezinski@cs.put.poznan.pl)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.meta;
+
+import java.util.Random;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.ObjectRepository;
+import moa.core.Utils;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.options.ClassOption;
+import moa.tasks.TaskMonitor;
+
+/**
+ * The Accuracy Weighted Ensemble classifier as proposed by Wang et al. in
+ * "Mining concept-drifting data streams using ensemble classifiers", KDD 2003.
+ */
+public class AccuracyWeightedEnsemble extends AbstractClassifier implements Classifier {
+
+	@Override
+	public String getPurposeString() {
+		return "Accuracy Weighted Ensemble classifier as proposed by Wang et al. in 'Mining concept-drifting data streams using ensemble classifiers', KDD 2003";
+	}
+
+	/**
+	 * Simple weight comparator. Needed for sorting component classifiers.
+	 */
+	private static final class ClassifierWeightComparator implements java.util.Comparator<double[]> {
+
+		@Override
+		public int compare(double[] o1, double[] o2) {
+			if (o1[0] > o2[0]) {
+				return 1;
+			} else if (o1[0] < o2[0]) {
+				return -1;
+			} else {
+				return 0;
+			}
+		}
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	/**
+	 * Simple weight comparator.
+	 */
+	protected static java.util.Comparator<double[]> weightComparator = new ClassifierWeightComparator();
+
+	/**
+	 * Type of classifier to use as a component classifier.
+	 */
+	public ClassOption learnerOption = new ClassOption("learner", 'l', "Classifier to train.", Classifier.class,
+			"trees.HoeffdingTree -l NB -e 1000 -g 100 -c 0.01");
+
+	/**
+	 * Number of component classifiers.
+	 */
+	public FloatOption memberCountOption = new FloatOption("memberCount", 'n',
+			"The maximum number of classifier in an ensemble.", 15, 1, Integer.MAX_VALUE);
+
+	/**
+	 * Number of classifiers remembered and available for ensemble construction.
+	 */
+	public FloatOption storedCountOption = new FloatOption("storedCount", 'r',
+			"The maximum number of classifiers to store and choose from when creating an ensemble.", 30, 1,
+			Integer.MAX_VALUE);
+
+	/**
+	 * Chunk size.
+	 */
+	public IntOption chunkSizeOption = new IntOption("chunkSize", 'c',
+			"The chunk size used for classifier creation and evaluation.", 500, 1, Integer.MAX_VALUE);
+
+	/**
+	 * Number of folds in candidate classifier cross-validation.
+	 */
+	public IntOption numFoldsOption = new IntOption("numFolds", 'f',
+			"Number of cross-validation folds for candidate classifier testing.", 10, 1, Integer.MAX_VALUE);
+
+	protected long[] classDistributions;
+
+	protected Classifier[] ensemble;
+
+	protected Classifier[] storedLearners;
+
+	protected double[] ensembleWeights;
+
+	/**
+	 * The weights of stored classifiers. storedWeights[x][0] = weight
+	 * storedWeights[x][1] = classifier
+	 */
+	protected double[][] storedWeights;
+
+	protected int processedInstances;
+
+	protected int chunkSize;
+
+	protected int numFolds;
+
+	protected int maxMemberCount;
+
+	protected int maxStoredCount;
+
+	protected Classifier candidateClassifier;
+
+	protected InstancesHeader currentChunk;
+
+	@Override
+	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		this.maxMemberCount = (int) memberCountOption.getValue();
+		this.maxStoredCount = (int) storedCountOption.getValue();
+
+		if (this.maxMemberCount > this.maxStoredCount) {
+			this.maxStoredCount = this.maxMemberCount;
+		}
+
+		this.chunkSize = this.chunkSizeOption.getValue();
+		this.numFolds = this.numFoldsOption.getValue();
+		this.candidateClassifier = (Classifier) getPreparedClassOption(this.learnerOption);
+		this.candidateClassifier.resetLearning();
+
+		super.prepareForUseImpl(monitor, repository);
+	}
+
+	@Override
+	public void resetLearningImpl() {
+		this.currentChunk = null;
+		this.classDistributions = null;
+		this.processedInstances = 0;
+		this.ensemble = new Classifier[0];
+		this.storedLearners = new Classifier[0];
+
+		this.candidateClassifier = (Classifier) getPreparedClassOption(this.learnerOption);
+		this.candidateClassifier.resetLearning();
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		this.initVariables();
+
+		this.classDistributions[(int) inst.classValue()]++;
+		this.currentChunk.add(inst);
+		this.processedInstances++;
+
+		if (this.processedInstances % this.chunkSize == 0) {
+			this.processChunk();
+		}
+	}
+
+	/**
+	 * Initiates the current chunk and class distribution variables.
+	 */
+	private void initVariables() {
+		if (this.currentChunk == null) {
+			this.currentChunk = this.getModelContext().getEmptyHeader();
+		}
+
+		if (this.classDistributions == null) {
+			this.classDistributions = new long[this.getModelContext().classAttribute().numValues()];
+
+			for (int i = 0; i < this.classDistributions.length; i++) {
+				this.classDistributions[i] = 0;
+			}
+		}
+	}
+
+	/**
+	 * Processes a chunk.
+	 *
+	 * @param useMseR Determines whether to use the MSEr threshold.
+	 */
+	protected void processChunk() {
+		// Compute weights
+		double candidateClassifierWeight = this.computeCandidateWeight(this.candidateClassifier, this.currentChunk,
+				this.numFolds);
+
+		for (int i = 0; i < this.storedLearners.length; i++) {
+			this.storedWeights[i][0] = this.computeWeight(this.storedLearners[(int) this.storedWeights[i][1]],
+					this.currentChunk);
+		}
+
+		if (this.storedLearners.length < this.maxStoredCount) {
+			// Train and add classifier
+			for (int num = 0; num < this.chunkSize; num++) {
+				this.candidateClassifier.trainOnInstance(this.currentChunk.instance(num));
+			}
+
+			this.addToStored(this.candidateClassifier, candidateClassifierWeight);
+		} else {
+			// Substitute poorest classifier
+			java.util.Arrays.sort(this.storedWeights, weightComparator);
+
+			if (this.storedWeights[0][0] < candidateClassifierWeight) {
+				for (int num = 0; num < this.chunkSize; num++) {
+					this.candidateClassifier.trainOnInstance(this.currentChunk.instance(num));
+				}
+
+				this.storedWeights[0][0] = candidateClassifierWeight;
+				this.storedLearners[(int) this.storedWeights[0][1]] = (Classifier) this.candidateClassifier.copy();
+			}
+		}
+
+		int ensembleSize = java.lang.Math.min(this.storedLearners.length, this.maxMemberCount);
+		this.ensemble = new Classifier[ensembleSize];
+		this.ensembleWeights = new double[ensembleSize];
+
+		// Sort learners according to their weights
+		java.util.Arrays.sort(this.storedWeights, weightComparator);
+
+		// Select top k classifiers to construct the ensemble
+		int storeSize = this.storedLearners.length;
+		for (int i = 0; i < ensembleSize; i++) {
+			this.ensembleWeights[i] = this.storedWeights[storeSize - i - 1][0];
+			this.ensemble[i] = this.storedLearners[(int) this.storedWeights[storeSize - i - 1][1]];
+		}
+
+		this.classDistributions = null;
+		this.currentChunk = null;
+		this.candidateClassifier = (Classifier) getPreparedClassOption(this.learnerOption);
+		this.candidateClassifier.resetLearning();
+	}
+
+	/**
+	 * Computes the weight of a candidate classifier.
+	 *
+	 * @param candidate Candidate classifier.
+	 * @param chunk     Data chunk of examples.
+	 * @param numFolds  Number of folds in candidate classifier cross-validation.
+	 * @param useMseR   Determines whether to use the MSEr threshold.
+	 * @return Candidate classifier weight.
+	 */
+	protected double computeCandidateWeight(Classifier candidate, InstancesHeader chunk, int numFolds) {
+		double candidateWeight = 0.0;
+		Random random = new Random(1);
+		InstancesHeader randData = new InstancesHeader(chunk);
+		randData.randomize(random);
+		if (randData.classAttribute().isNominal()) {
+			randData.stratify(numFolds);
+		}
+
+		for (int n = 0; n < numFolds; n++) {
+			InstancesHeader train = randData.trainCV(numFolds, n, random);
+			InstancesHeader test = randData.testCV(numFolds, n);
+
+			Classifier learner = (Classifier) candidate.copy();
+
+			for (int num = 0; num < train.numInstances(); num++) {
+				learner.trainOnInstance(train.instance(num));
+			}
+
+			candidateWeight += computeWeight(learner, test);
+		}
+
+		double resultWeight = candidateWeight / numFolds;
+
+		if (Double.isInfinite(resultWeight)) {
+			return Double.MAX_VALUE;
+		} else {
+			return resultWeight;
+		}
+	}
+
+	/**
+	 * Computes the weight of a given classifie.
+	 *
+	 * @param learner Classifier to calculate weight for.
+	 * @param chunk   Data chunk of examples.
+	 * @param useMseR Determines whether to use the MSEr threshold.
+	 * @return The given classifier's weight.
+	 */
+	protected double computeWeight(Classifier learner, InstancesHeader chunk) {
+		double mse_i = 0;
+		double mse_r = 0;
+
+		double f_ci;
+		double voteSum;
+
+		for (int i = 0; i < chunk.numInstances(); i++) {
+			try {
+				voteSum = 0;
+				double[] prediction = learner.getPredictionForInstance(chunk.instance(i)).asDoubleArray();
+				for (double element : prediction) {
+					voteSum += element;
+				}
+
+				if (voteSum > 0) {
+					f_ci = prediction[(int) chunk.instance(i).classValue()] / voteSum;
+					mse_i += (1 - f_ci) * (1 - f_ci);
+				} else {
+					mse_i += 1;
+				}
+			} catch (Exception e) {
+				mse_i += 1;
+			}
+		}
+
+		mse_i /= this.chunkSize;
+		mse_r = this.computeMseR();
+
+		return java.lang.Math.max(mse_r - mse_i, 0);
+	}
+
+	/**
+	 * Computes the MSEr threshold.
+	 *
+	 * @return The MSEr threshold.
+	 */
+	protected double computeMseR() {
+		double p_c;
+		double mse_r = 0;
+
+		for (int i = 0; i < this.classDistributions.length; i++) {
+			p_c = (double) this.classDistributions[i] / (double) this.chunkSize;
+			mse_r += p_c * ((1 - p_c) * (1 - p_c));
+		}
+
+		return mse_r;
+	}
+
+	/**
+	 * Predicts a class for an example.
+	 */
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		DoubleVector combinedVote = new DoubleVector();
+
+		if (this.trainingWeightSeenByModel > 0.0) {
+			for (int i = 0; i < this.ensemble.length; i++) {
+				if (this.ensembleWeights[i] > 0.0) {
+					DoubleVector vote = this.ensemble[i].getPredictionForInstance(inst).asDoubleVector();
+
+					if (vote.sumOfValues() > 0.0) {
+						vote.normalize();
+						// scale weight and prevent overflow
+						vote.scaleValues(this.ensembleWeights[i] / (1.0 * this.ensemble.length + 1));
+						combinedVote.addValues(vote);
+					}
+				}
+			}
+		}
+		combinedVote.normalize();
+		return new ClassificationPrediction(combinedVote.getArrayRef());
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+	}
+
+	/**
+	 * Adds ensemble weights to the measurements.
+	 */
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		Measurement[] measurements = new Measurement[this.maxStoredCount];
+
+		for (int m = 0; m < this.maxMemberCount; m++) {
+			measurements[m] = new Measurement("Member weight " + (m + 1), -1);
+		}
+
+		for (int s = this.maxMemberCount; s < this.maxStoredCount; s++) {
+			measurements[s] = new Measurement("Stored member weight " + (s + 1), -1);
+		}
+
+		if (this.storedWeights != null) {
+			int storeSize = this.storedWeights.length;
+
+			for (int i = 0; i < storeSize; i++) {
+				if (i < this.ensemble.length) {
+					measurements[i] = new Measurement("Member weight " + (i + 1),
+							this.storedWeights[storeSize - i - 1][0]);
+				} else {
+					measurements[i] = new Measurement("Stored member weight " + (i + 1),
+							this.storedWeights[storeSize - i - 1][0]);
+				}
+			}
+		}
+		return measurements;
+	}
+
+	/**
+	 * Determines whether the classifier is randomizable.
+	 */
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+
+	@Override
+	public Classifier[] getSubClassifiers() {
+		return this.ensemble.clone();
+	}
+
+	/**
+	 * Adds a classifier to the storage.
+	 *
+	 * @param newClassifier        The classifier to add.
+	 * @param newClassifiersWeight The new classifiers weight.
+	 */
+	protected Classifier addToStored(Classifier newClassifier, double newClassifiersWeight) {
+		Classifier addedClassifier = null;
+		Classifier[] newStored = new Classifier[this.storedLearners.length + 1];
+		double[][] newStoredWeights = new double[newStored.length][2];
+
+		for (int i = 0; i < newStored.length; i++) {
+			if (i < this.storedLearners.length) {
+				newStored[i] = this.storedLearners[i];
+				newStoredWeights[i][0] = this.storedWeights[i][0];
+				newStoredWeights[i][1] = this.storedWeights[i][1];
+			} else {
+				newStored[i] = addedClassifier = (Classifier) newClassifier.copy();
+				newStoredWeights[i][0] = newClassifiersWeight;
+				newStoredWeights[i][1] = i;
+			}
+		}
+		this.storedLearners = newStored;
+		this.storedWeights = newStoredWeights;
+
+		return addedClassifier;
+	}
+
+	/**
+	 * Removes the poorest classifier from the model, thus decreasing the models
+	 * size.
+	 *
+	 * @return the size of the removed classifier.
+	 */
+	protected long removePoorestModelBytes() {
+		int poorestIndex = Utils.minIndex(this.ensembleWeights);
+		long byteSize = this.ensemble[poorestIndex].measureByteSize();
+		discardModel(poorestIndex);
+		return byteSize;
+	}
+
+	/**
+	 * Removes the classifier at a given index from the model, thus decreasing the
+	 * models size.
+	 *
+	 * @param index
+	 */
+	protected void discardModel(int index) {
+		Classifier[] newEnsemble = new Classifier[this.ensemble.length - 1];
+		double[] newEnsembleWeights = new double[newEnsemble.length];
+		int oldPos = 0;
+		for (int i = 0; i < newEnsemble.length; i++) {
+			if (oldPos == index) {
+				oldPos++;
+			}
+			newEnsemble[i] = this.ensemble[oldPos];
+			newEnsembleWeights[i] = this.ensembleWeights[oldPos];
+			oldPos++;
+		}
+		this.ensemble = newEnsemble;
+		this.ensembleWeights = newEnsembleWeights;
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/meta/AdaptiveRandomForest.java b/moa/src/main/java/moa/learners/predictors/meta/AdaptiveRandomForest.java
new file mode 100644
index 000000000..5178d331b
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/meta/AdaptiveRandomForest.java
@@ -0,0 +1,486 @@
+/*
+ *    AdaptiveRandomForest.java
+ *
+ *    @author Heitor Murilo Gomes (heitor_murilo_gomes at yahoo dot com dot br)
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ */
+package moa.learners.predictors.meta;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.AbstractMOAObject;
+import moa.capabilities.CapabilitiesHandler;
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
+import moa.core.DoubleVector;
+import moa.core.InstanceExample;
+import moa.core.Measurement;
+import moa.core.MiscUtils;
+import moa.evaluation.evaluators.BasicClassificationPerformanceEvaluator;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.core.driftdetection.ChangeDetector;
+import moa.learners.predictors.trees.ARFHoeffdingTree;
+import moa.options.ClassOption;
+
+/**
+ * Adaptive Random Forest
+ *
+ * <p>
+ * Adaptive Random Forest (ARF). The 3 most important aspects of this ensemble
+ * classifier are: (1) inducing diversity through resampling; (2) inducing
+ * diversity through randomly selecting subsets of features for node splits (See
+ * moa.learners.predictors.trees.ARFHoeffdingTree.java); (3) drift detectors per base
+ * tree, which cause selective resets in response to drifts. It also allows
+ * training background trees, which start training if a warning is detected and
+ * replace the active tree if the warning escalates to a drift.
+ * </p>
+ *
+ * <p>
+ * See details in:<br>
+ * Heitor Murilo Gomes, Albert Bifet, Jesse Read, Jean Paul Barddal, Fabricio
+ * Enembreck, Bernhard Pfharinger, Geoff Holmes, Talel Abdessalem. Adaptive
+ * random forests for evolving data stream classification. In Machine Learning,
+ * DOI: 10.1007/s10994-017-5642-8, Springer, 2017.
+ * </p>
+ *
+ * <p>
+ * Parameters:
+ * </p>
+ * <ul>
+ * <li>-l : Classifier to train. Must be set to ARFHoeffdingTree</li>
+ * <li>-s : The number of trees in the ensemble</li>
+ * <li>-o : How the number of features is interpreted (4 options): "Specified m
+ * (integer value)", "sqrt(M)+1", "M-(sqrt(M)+1)"</li>
+ * <li>-m : Number of features allowed considered for each split. Negative
+ * values corresponds to M - m</li>
+ * <li>-a : The lambda value for bagging (lambda=6 corresponds to levBag)</li>
+ * <li>-j : Number of threads to be used for training</li>
+ * <li>-x : Change detector for drifts and its parameters</li>
+ * <li>-p : Change detector for warnings (start training bkg learner)</li>
+ * <li>-w : Should use weighted voting?</li>
+ * <li>-u : Should use drift detection? If disabled then bkg learner is also
+ * disabled</li>
+ * <li>-q : Should use bkg learner? If disabled then reset tree immediately</li>
+ * </ul>
+ *
+ * @author Heitor Murilo Gomes (heitor_murilo_gomes at yahoo dot com dot br)
+ * @version $Revision: 1 $
+ */
+public class AdaptiveRandomForest extends AbstractClassifier implements Classifier, CapabilitiesHandler {
+
+	@Override
+	public String getPurposeString() {
+		return "Adaptive Random Forest algorithm for evolving data streams from Gomes et al.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption treeLearnerOption = new ClassOption("treeLearner", 'l', "Random Forest Tree.",
+			ARFHoeffdingTree.class, "ARFHoeffdingTree -e 2000000 -g 50 -c 0.01");
+
+	public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's', "The number of trees.", 10, 1,
+			Integer.MAX_VALUE);
+
+	public MultiChoiceOption mFeaturesModeOption = new MultiChoiceOption("mFeaturesMode", 'o',
+			"Defines how m, defined by mFeaturesPerTreeSize, is interpreted. M represents the total number of features.",
+			new String[] { "Specified m (integer value)", "sqrt(M)+1", "M-(sqrt(M)+1)", "Percentage (M * (m / 100))" },
+			new String[] { "SpecifiedM", "SqrtM1", "MSqrtM1", "Percentage" }, 1);
+
+	public IntOption mFeaturesPerTreeSizeOption = new IntOption("mFeaturesPerTreeSize", 'm',
+			"Number of features allowed considered for each split. Negative values corresponds to M - m", 2,
+			Integer.MIN_VALUE, Integer.MAX_VALUE);
+
+	public FloatOption lambdaOption = new FloatOption("lambda", 'a', "The lambda parameter for bagging.", 6.0, 1.0,
+			Float.MAX_VALUE);
+
+	public IntOption numberOfJobsOption = new IntOption("numberOfJobs", 'j',
+			"Total number of concurrent jobs used for processing (-1 = as much as possible, 0 = do not use multithreading)",
+			1, -1, Integer.MAX_VALUE);
+
+	public ClassOption driftDetectionMethodOption = new ClassOption("driftDetectionMethod", 'x',
+			"Change detector for drifts and its parameters", ChangeDetector.class, "ADWINChangeDetector -a 1.0E-5");
+
+	public ClassOption warningDetectionMethodOption = new ClassOption("warningDetectionMethod", 'p',
+			"Change detector for warnings (start training bkg learner)", ChangeDetector.class,
+			"ADWINChangeDetector -a 1.0E-4");
+
+	public FlagOption disableWeightedVote = new FlagOption("disableWeightedVote", 'w', "Should use weighted voting?");
+
+	public FlagOption disableDriftDetectionOption = new FlagOption("disableDriftDetection", 'u',
+			"Should use drift detection? If disabled then bkg learner is also disabled");
+
+	public FlagOption disableBackgroundLearnerOption = new FlagOption("disableBackgroundLearner", 'q',
+			"Should use bkg learner? If disabled then reset tree immediately.");
+
+	public static final int FEATURES_M = 0;
+	public static final int FEATURES_SQRT = 1;
+	public static final int FEATURES_SQRT_INV = 2;
+	public static final int FEATURES_PERCENT = 3;
+
+	protected static final int SINGLE_THREAD = 0;
+
+	protected ARFBaseLearner[] ensemble;
+	protected long instancesSeen;
+	protected int subspaceSize;
+	protected BasicClassificationPerformanceEvaluator evaluator;
+
+	private ExecutorService executor;
+
+	@Override
+	public void resetLearningImpl() {
+		// Reset attributes
+		this.ensemble = null;
+		this.subspaceSize = 0;
+		this.instancesSeen = 0;
+		this.evaluator = new BasicClassificationPerformanceEvaluator();
+
+		// Multi-threading
+		int numberOfJobs;
+		if (this.numberOfJobsOption.getValue() == -1)
+			numberOfJobs = Runtime.getRuntime().availableProcessors();
+		else
+			numberOfJobs = this.numberOfJobsOption.getValue();
+		// SINGLE_THREAD and requesting for only 1 thread are equivalent.
+		// this.executor will be null and not used...
+		if (numberOfJobs != AdaptiveRandomForest.SINGLE_THREAD && numberOfJobs != 1)
+			this.executor = Executors.newFixedThreadPool(numberOfJobs);
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance instance) {
+		++this.instancesSeen;
+		if (this.ensemble == null)
+			initEnsemble(instance);
+
+		Collection<TrainingRunnable> trainers = new ArrayList<>();
+		for (int i = 0; i < this.ensemble.length; i++) {
+			DoubleVector vote = new DoubleVector(this.ensemble[i].getVotesForInstance(instance));
+			InstanceExample example = new InstanceExample(instance);
+			this.ensemble[i].evaluator.addResult(example, vote.getArrayRef());
+			int k = MiscUtils.poisson(this.lambdaOption.getValue(), this.classifierRandom);
+			if (k > 0) {
+				if (this.executor != null) {
+					TrainingRunnable trainer = new TrainingRunnable(this.ensemble[i], instance, k, this.instancesSeen);
+					trainers.add(trainer);
+				} else { // SINGLE_THREAD is in-place...
+					this.ensemble[i].trainOnInstance(instance, k, this.instancesSeen);
+				}
+			}
+		}
+		if (this.executor != null) {
+			try {
+				this.executor.invokeAll(trainers);
+			} catch (InterruptedException ex) {
+				throw new RuntimeException("Could not call invokeAll() on training threads.");
+			}
+		}
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance instance) {
+		Instance testInstance = instance.copy();
+		if (this.ensemble == null)
+			initEnsemble(testInstance);
+		DoubleVector combinedVote = new DoubleVector();
+
+		for (int i = 0; i < this.ensemble.length; ++i) {
+			DoubleVector vote = new DoubleVector(this.ensemble[i].getVotesForInstance(testInstance));
+			if (vote.sumOfValues() > 0.0) {
+				vote.normalize();
+				double acc = this.ensemble[i].evaluator.getPerformanceMeasurements()[1].getValue();
+				if (!this.disableWeightedVote.isSet() && acc > 0.0) {
+					for (int v = 0; v < vote.numValues(); ++v) {
+						vote.setValue(v, vote.getValue(v) * acc);
+					}
+				}
+				combinedVote.addValues(vote);
+			}
+		}
+		return new ClassificationPrediction(combinedVote.getArrayRef());
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder arg0, int arg1) {
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return null;
+	}
+
+	protected void initEnsemble(Instance instance) {
+		// Init the ensemble.
+		int ensembleSize = this.ensembleSizeOption.getValue();
+		this.ensemble = new ARFBaseLearner[ensembleSize];
+
+		// TODO: this should be an option with default =
+		// BasicClassificationPerformanceEvaluator
+//        BasicClassificationPerformanceEvaluator classificationEvaluator = (BasicClassificationPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
+		BasicClassificationPerformanceEvaluator classificationEvaluator = new BasicClassificationPerformanceEvaluator();
+
+		this.subspaceSize = this.mFeaturesPerTreeSizeOption.getValue();
+
+		// The size of m depends on:
+		// 1) mFeaturesPerTreeSizeOption
+		// 2) mFeaturesModeOption
+		int n = instance.numAttributes() - 1; // Ignore class label ( -1 )
+
+		switch (this.mFeaturesModeOption.getChosenIndex()) {
+		case AdaptiveRandomForest.FEATURES_SQRT:
+			this.subspaceSize = (int) Math.round(Math.sqrt(n)) + 1;
+			break;
+		case AdaptiveRandomForest.FEATURES_SQRT_INV:
+			this.subspaceSize = n - (int) Math.round(Math.sqrt(n) + 1);
+			break;
+		case AdaptiveRandomForest.FEATURES_PERCENT:
+			// If subspaceSize is negative, then first find out the actual percent, i.e.,
+			// 100% - m.
+			double percent = this.subspaceSize < 0 ? (100 + this.subspaceSize) / 100.0 : this.subspaceSize / 100.0;
+			this.subspaceSize = (int) Math.round(n * percent);
+			break;
+		}
+		// Notice that if the selected mFeaturesModeOption was
+		// AdaptiveRandomForest.FEATURES_M then nothing is performed in the
+		// previous switch-case, still it is necessary to check (and adjusted)
+		// for when a negative value was used.
+
+		// m is negative, use size(features) + -m
+		if (this.subspaceSize < 0)
+			this.subspaceSize = n + this.subspaceSize;
+		// Other sanity checks to avoid runtime errors.
+		// m <= 0 (m can be negative if this.subspace was negative and
+		// abs(m) > n), then use m = 1
+		if (this.subspaceSize <= 0)
+			this.subspaceSize = 1;
+		// m > n, then it should use n
+		if (this.subspaceSize > n)
+			this.subspaceSize = n;
+
+		ARFHoeffdingTree treeLearner = (ARFHoeffdingTree) getPreparedClassOption(this.treeLearnerOption);
+		treeLearner.resetLearning();
+
+		for (int i = 0; i < ensembleSize; ++i) {
+			treeLearner.subspaceSizeOption.setValue(this.subspaceSize);
+			this.ensemble[i] = new ARFBaseLearner(i, (ARFHoeffdingTree) treeLearner.copy(),
+					(BasicClassificationPerformanceEvaluator) classificationEvaluator.copy(), this.instancesSeen,
+					!this.disableBackgroundLearnerOption.isSet(), !this.disableDriftDetectionOption.isSet(),
+					driftDetectionMethodOption, warningDetectionMethodOption, false);
+		}
+	}
+
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == AdaptiveRandomForest.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
+
+	/**
+	 * Inner class that represents a single tree member of the forest. It contains
+	 * some analysis information, such as the numberOfDriftsDetected,
+	 */
+	protected final class ARFBaseLearner extends AbstractMOAObject {
+		public int indexOriginal;
+		public long createdOn;
+		public long lastDriftOn;
+		public long lastWarningOn;
+		public ARFHoeffdingTree classifier;
+		public boolean isBackgroundLearner;
+
+		// The drift and warning object parameters.
+		protected ClassOption driftOption;
+		protected ClassOption warningOption;
+
+		// Drift and warning detection
+		protected ChangeDetector driftDetectionMethod;
+		protected ChangeDetector warningDetectionMethod;
+
+		public boolean useBkgLearner;
+		public boolean useDriftDetector;
+
+		// Bkg learner
+		protected ARFBaseLearner bkgLearner;
+		// Statistics
+		public BasicClassificationPerformanceEvaluator evaluator;
+		protected int numberOfDriftsDetected;
+		protected int numberOfWarningsDetected;
+
+		private void init(int indexOriginal, ARFHoeffdingTree instantiatedClassifier,
+				BasicClassificationPerformanceEvaluator evaluatorInstantiated, long instancesSeen,
+				boolean useBkgLearner, boolean useDriftDetector, ClassOption driftOption, ClassOption warningOption,
+				boolean isBackgroundLearner) {
+			this.indexOriginal = indexOriginal;
+			this.createdOn = instancesSeen;
+			this.lastDriftOn = 0;
+			this.lastWarningOn = 0;
+
+			this.classifier = instantiatedClassifier;
+			this.evaluator = evaluatorInstantiated;
+			this.useBkgLearner = useBkgLearner;
+			this.useDriftDetector = useDriftDetector;
+
+			this.numberOfDriftsDetected = 0;
+			this.numberOfWarningsDetected = 0;
+			this.isBackgroundLearner = isBackgroundLearner;
+
+			if (this.useDriftDetector) {
+				this.driftOption = driftOption;
+				this.driftDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.driftOption)).copy();
+			}
+
+			// Init Drift Detector for Warning detection.
+			if (this.useBkgLearner) {
+				this.warningOption = warningOption;
+				this.warningDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.warningOption)).copy();
+			}
+		}
+
+		public ARFBaseLearner(int indexOriginal, ARFHoeffdingTree instantiatedClassifier,
+				BasicClassificationPerformanceEvaluator evaluatorInstantiated, long instancesSeen,
+				boolean useBkgLearner, boolean useDriftDetector, ClassOption driftOption, ClassOption warningOption,
+				boolean isBackgroundLearner) {
+			init(indexOriginal, instantiatedClassifier, evaluatorInstantiated, instancesSeen, useBkgLearner,
+					useDriftDetector, driftOption, warningOption, isBackgroundLearner);
+		}
+
+		public void reset() {
+			if (this.useBkgLearner && this.bkgLearner != null) {
+				this.classifier = this.bkgLearner.classifier;
+
+				this.driftDetectionMethod = this.bkgLearner.driftDetectionMethod;
+				this.warningDetectionMethod = this.bkgLearner.warningDetectionMethod;
+
+				this.evaluator = this.bkgLearner.evaluator;
+				this.createdOn = this.bkgLearner.createdOn;
+				this.bkgLearner = null;
+			} else {
+				this.classifier.resetLearning();
+				this.createdOn = instancesSeen;
+				this.driftDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.driftOption)).copy();
+			}
+			this.evaluator.reset();
+		}
+
+		public void trainOnInstance(Instance instance, double weight, long instancesSeen) {
+			Instance weightedInstance = instance.copy();
+			weightedInstance.setWeight(instance.weight() * weight);
+			this.classifier.trainOnInstance(weightedInstance);
+
+			if (this.bkgLearner != null)
+				this.bkgLearner.classifier.trainOnInstance(instance);
+
+			// Should it use a drift detector? Also, is it a backgroundLearner? If so, then
+			// do not "incept" another one.
+			if (this.useDriftDetector && !this.isBackgroundLearner) {
+				boolean correctlyClassifies = this.classifier.correctlyClassifies(instance);
+				// Check for warning only if useBkgLearner is active
+				if (this.useBkgLearner) {
+					// Update the warning detection method
+					this.warningDetectionMethod.input(correctlyClassifies ? 0 : 1);
+					// Check if there was a change
+					if (this.warningDetectionMethod.getChange()) {
+						this.lastWarningOn = instancesSeen;
+						this.numberOfWarningsDetected++;
+						// Create a new bkgTree classifier
+						ARFHoeffdingTree bkgClassifier = (ARFHoeffdingTree) this.classifier.copy();
+						bkgClassifier.resetLearning();
+
+						// Resets the evaluator
+						BasicClassificationPerformanceEvaluator bkgEvaluator = (BasicClassificationPerformanceEvaluator) this.evaluator
+								.copy();
+						bkgEvaluator.reset();
+
+						// Create a new bkgLearner object
+						this.bkgLearner = new ARFBaseLearner(indexOriginal, bkgClassifier, bkgEvaluator, instancesSeen,
+								this.useBkgLearner, this.useDriftDetector, this.driftOption, this.warningOption, true);
+
+						// Update the warning detection object for the current object
+						// (this effectively resets changes made to the object while it was still a bkg
+						// learner).
+						this.warningDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.warningOption))
+								.copy();
+					}
+				}
+
+				/*********** drift detection ***********/
+
+				// Update the DRIFT detection method
+				this.driftDetectionMethod.input(correctlyClassifies ? 0 : 1);
+				// Check if there was a change
+				if (this.driftDetectionMethod.getChange()) {
+					this.lastDriftOn = instancesSeen;
+					this.numberOfDriftsDetected++;
+					this.reset();
+				}
+			}
+		}
+
+		public double[] getVotesForInstance(Instance instance) {
+			DoubleVector vote = new DoubleVector(this.classifier.getPredictionForInstance(instance).asDoubleArray());
+			return vote.getArrayRef();
+		}
+
+		@Override
+		public void getDescription(StringBuilder sb, int indent) {
+		}
+	}
+
+	/***
+	 * Inner class to assist with the multi-thread execution.
+	 */
+	protected class TrainingRunnable implements Runnable, Callable<Integer> {
+		final private ARFBaseLearner learner;
+		final private Instance instance;
+		final private double weight;
+		final private long instancesSeen;
+
+		public TrainingRunnable(ARFBaseLearner learner, Instance instance, double weight, long instancesSeen) {
+			this.learner = learner;
+			this.instance = instance;
+			this.weight = weight;
+			this.instancesSeen = instancesSeen;
+		}
+
+		@Override
+		public void run() {
+			learner.trainOnInstance(this.instance, this.weight, this.instancesSeen);
+		}
+
+		@Override
+		public Integer call() throws Exception {
+			run();
+			return 0;
+		}
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/meta/BOLE.java b/moa/src/main/java/moa/learners/predictors/meta/BOLE.java
new file mode 100644
index 000000000..80115dd0e
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/meta/BOLE.java
@@ -0,0 +1,221 @@
+/*
+ *    BOLE.java
+ *    Copyright (C) 2015 Santos, Barros
+ *    @authors Silas G. T. C. Santos (sgtcs@cin.ufpe.br)
+ *             Roberto Souto Maior de Barros (roberto@cin.ufpe.br)
+ *    @version $Version: 1 $
+ *
+ *    Evolved from ADOB.java
+ *    Copyright (C) 2014 Santos, Goncalves, Barros
+ *    @author Silas G. T. C. Santos (sgtcs@cin.ufpe.br)
+ *            Paulo M. Goncalves Jr. (paulomgj@gmail.com)
+ *            Roberto S. M. Barros (roberto@cin.ufpe.br)
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ * Boosting-like Online Learning Ensemble (BOLE).
+ *
+ * published as:
+ *     Roberto Souto Maior de Barros, Silas Garrido T. de Carvalho Santos,
+ *     and Paulo Mauricio Goncalves Jr.:
+ *     A Boosting-like Online Learning Ensemble.
+ *     In Proceedings of IEEE International Joint Conference
+ *     on Neural Networks (IJCNN), Vancouver, Canada, 2016.
+ *     DOI: 10.1109/IJCNN.2016.7727427
+ */
+
+package moa.learners.predictors.meta;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.MiscUtils;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.options.ClassOption;
+
+public class BOLE extends AbstractClassifier {
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l', "Classifier to train.", Classifier.class,
+			"drift.DriftDetectionMethodClassifier -l trees.HoeffdingTree -d (DDM -n 7 -w 1.2 -o 1.95)");
+
+	public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's', "The number of models to boost.", 10, 1,
+			Integer.MAX_VALUE);
+
+	public FlagOption pureBoostOption = new FlagOption("pureBoost", 'p', "Boost with weights only; no poisson.");
+
+	public FlagOption breakVotesOption = new FlagOption("breakVotes", 'b', "Break Votes? unchecked=no, checked=yes");
+
+	public FloatOption errorBoundOption = new FloatOption("errorBound", 'e',
+			"Error bound percentage for allowing experts to vote.", 0.5, 0.1, 1.0);
+
+	public FloatOption weightShiftOption = new FloatOption("weightShift", 'w',
+			"Weight shift associated with the error bound.", 0.0, 0.0, 5.0);
+
+	private double memberWeight;
+	private double key_acc;
+	private int key_position, i, j;
+	private int maxAcc, minAcc, pos;
+	private double lambda_d, k;
+	private boolean correct, okay;
+	private double em, Bm;
+
+	protected Classifier[] ensemble;
+	protected int[] orderPosition;
+	protected double[] scms;
+	protected double[] swms;
+
+	@Override
+	public String getPurposeString() {
+		return "Boosting-like Online Learning Ensemble (BOLE)";
+	}
+
+	@Override
+	public void resetLearningImpl() {
+		this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
+		this.orderPosition = new int[this.ensemble.length];
+		Classifier baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
+		baseLearner.resetLearning();
+		for (i = 0; i < this.ensemble.length; i++) {
+			this.ensemble[i] = (Classifier) baseLearner.copy();
+			this.orderPosition[i] = i;
+		}
+		this.scms = new double[this.ensemble.length];
+		this.swms = new double[this.ensemble.length];
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		// Calculates current accuracy of experts
+		double[] acc = new double[this.ensemble.length];
+		for (i = 0; i < this.ensemble.length; i++) {
+			acc[i] = this.scms[this.orderPosition[i]] + this.swms[this.orderPosition[i]];
+			if (acc[i] != 0.0) {
+				acc[i] = this.scms[this.orderPosition[i]] / acc[i];
+			}
+		}
+
+		// Sort by accuracy in ascending order
+		for (i = 1; i < this.ensemble.length; i++) {
+			key_position = this.orderPosition[i];
+			key_acc = acc[i];
+			j = i - 1;
+			while ((j >= 0) && (acc[j] < key_acc)) {
+				this.orderPosition[j + 1] = this.orderPosition[j];
+				acc[j + 1] = acc[j];
+				j--;
+			}
+			this.orderPosition[j + 1] = key_position;
+			acc[j + 1] = key_acc;
+		}
+
+		correct = false;
+		maxAcc = 0;
+		minAcc = this.ensemble.length - 1;
+		lambda_d = 1.0;
+		for (i = 0; i < this.ensemble.length; i++) {
+			if (correct) {
+				pos = this.orderPosition[maxAcc];
+				maxAcc++;
+			} else {
+				pos = this.orderPosition[minAcc];
+				minAcc--;
+			}
+
+			if (this.pureBoostOption.isSet())
+				k = lambda_d;
+			else
+				k = MiscUtils.poisson(lambda_d, this.classifierRandom);
+
+			if (k > 0.0) {
+				Instance weightedInst = inst.copy();
+				weightedInst.setWeight(inst.weight() * k);
+				this.ensemble[pos].trainOnInstance(weightedInst);
+			}
+
+			// Increases or decreases lambda based on the prediction of instance
+			if (this.ensemble[pos].correctlyClassifies(inst)) {
+				this.scms[pos] += lambda_d;
+				lambda_d *= (this.trainingWeightSeenByModel / (2 * this.scms[pos]));
+				correct = true;
+			} else {
+				this.swms[pos] += lambda_d;
+				lambda_d *= (this.trainingWeightSeenByModel / (2 * this.swms[pos]));
+				correct = false;
+			}
+		}
+	}
+
+	protected double getEnsembleMemberWeight(int i) {
+		if ((this.scms[i] > 0.0) && (this.swms[i] > 0.0)) {
+			em = this.swms[i] / (this.scms[i] + this.swms[i]);
+			if (em <= this.errorBoundOption.getValue()) {
+				Bm = em / (1.0 - em);
+				okay = true;
+				return Math.log(1.0 / Bm);
+			}
+
+		}
+		okay = false;
+		return 0.0;
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		DoubleVector combinedVote = new DoubleVector();
+		for (i = 0; i < this.ensemble.length; i++) {
+			memberWeight = getEnsembleMemberWeight(i) + this.weightShiftOption.getValue();
+			if (okay) {
+				DoubleVector vote = new DoubleVector(this.ensemble[i].getPredictionForInstance(inst).asDoubleArray());
+				if (vote.sumOfValues() > 0.0) {
+					vote.normalize();
+					vote.scaleValues(memberWeight);
+					combinedVote.addValues(vote);
+				}
+			} else if (this.breakVotesOption.isSet()) {
+				break;
+			}
+		}
+		return new ClassificationPrediction(combinedVote.getArrayRef());
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[] { new Measurement("ensemble size", this.ensemble != null ? this.ensemble.length : 0) };
+	}
+
+	@Override
+	public Classifier[] getSubClassifiers() {
+		return this.ensemble.clone();
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/meta/DACC.java b/moa/src/main/java/moa/learners/predictors/meta/DACC.java
new file mode 100644
index 000000000..621e16a1b
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/meta/DACC.java
@@ -0,0 +1,430 @@
+/*
+ *    DACC.java
+ *
+ *    @author Ghazal Jaber (ghazal.jaber@gmail.com)
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.predictors.meta;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.options.ClassOption;
+
+/**
+ * Dynamic Adaptation to Concept Changes. Ensemble method for data streams that
+ * adapts to concept changes.
+ *
+ * Reference: JABER, G., CORNUEJOLS, A., and TARROUX, P. A New On-Line Learning
+ * Method for Coping with Recurring Concepts: The ADACC System. In : Neural
+ * Information Processing. Springer Berlin Heidelberg, 2013. p. 595-604.
+ *
+ * @author Ghazal Jaber (ghazal.jaber@gmail.com)
+ *
+ */
+
+public class DACC extends AbstractClassifier implements Classifier {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Dynamic Adaptation to Concept Changes for data streams.";
+	}
+
+	/**
+	 * Base classifier
+	 */
+	public ClassOption learnerOption = new ClassOption("baseLearner", 'l', "Classifier to train.", Classifier.class,
+			"bayes.NaiveBayes");
+	/**
+	 * Ensemble size
+	 */
+	public FloatOption memberCountOption = new FloatOption("ensembleSize", 'n',
+			"The maximum number of classifiers in an ensemble.", 20, 1, Integer.MAX_VALUE);
+	/**
+	 * Maturity age of classifiers
+	 */
+	public FloatOption maturityOption = new FloatOption("maturity", 'a', "The maturity age.", 20, 0, 100);
+	/**
+	 * Size of the evaluation window for weights computing
+	 */
+	public FloatOption evaluationSizeOption = new FloatOption("evalSize", 'e', "The size of the evaluation window.", 20,
+			1, 1000);
+	/**
+	 * Combination functions: MAX and WVD (MAX leads to a faster reactivity to the
+	 * change, WVD is more robust to noise)
+	 */
+	public MultiChoiceOption combinationOption = new MultiChoiceOption("cmb", 'c', "The combination function.",
+			new String[] { "MAX", "WVD" }, new String[] { "Maximum", "Weighted Vote of the best" }, 0);
+	/**
+	 * Ensemble of classifiers
+	 */
+	protected Classifier[] ensemble;
+	/**
+	 * Weights of classifiers
+	 */
+	protected Pair[] ensembleWeights;
+	/**
+	 * Age of classifiers (to compare with maturity age)
+	 */
+	protected double[] ensembleAges;
+	/**
+	 * Evaluation windows (recent classification errors)
+	 */
+	protected int[][] ensembleWindows;
+	/**
+	 * Number of instances from the stream
+	 */
+	protected int nbInstances = 0;
+
+	/**
+	 * Initializes the method variables
+	 */
+	protected void initVariables() {
+		int ensembleSize = (int) this.memberCountOption.getValue();
+		this.ensemble = new Classifier[ensembleSize];
+		this.ensembleAges = new double[ensembleSize];
+		this.ensembleWindows = new int[ensembleSize][(int) this.evaluationSizeOption.getValue()];
+	}
+
+	@Override
+	public void resetLearningImpl() {
+
+		Classifier learner = (Classifier) getPreparedClassOption(this.learnerOption);
+		learner.resetLearning();
+
+		initVariables();
+
+		this.ensembleWeights = new Pair[this.ensemble.length];
+
+		for (int i = 0; i < this.ensemble.length; i++) {
+			this.ensemble[i] = (Classifier) learner.copy();
+			this.ensembleAges[i] = 0;
+			this.ensembleWeights[i] = new Pair(0.0, i);
+			this.ensembleWindows[i] = new int[(int) this.evaluationSizeOption.getValue()];
+		}
+
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		trainAndClassify(inst);
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+
+		DoubleVector combinedVote = new DoubleVector();
+		ArrayList<Integer> arr;
+
+		int cmb = this.combinationOption.getChosenIndex();
+
+		if (cmb == 0)
+			arr = getMAXIndexes();
+		else
+			arr = getWVDIndexes();
+
+		if (this.trainingWeightSeenByModel > 0.0) {
+
+			for (int i = 0; i < arr.size(); i++) {
+				if (this.ensembleWeights[arr.get(i)].val > 0.0) {
+
+					DoubleVector vote = this.ensemble[arr.get(i)].getPredictionForInstance(inst).asDoubleVector();
+
+					if (vote.sumOfValues() > 0.0) {
+						vote.normalize();
+						vote.scaleValues(this.ensembleWeights[arr.get(i)].val);
+						combinedVote.addValues(vote);
+					}
+				}
+			}
+		}
+		return new ClassificationPrediction(combinedVote.getArrayRef());
+	}
+
+	/**
+	 * Receives a training instance from the stream and updates the adaptive
+	 * classifiers accordingly
+	 * 
+	 * @param inst the instance from the stream
+	 */
+	protected void trainAndClassify(Instance inst) {
+
+		nbInstances++;
+
+		boolean mature = true;
+		boolean unmature = true;
+
+		for (int i = 0; i < getNbActiveClassifiers(); i++) {
+
+			// check if all adaptive learners are mature
+			if (this.ensembleAges[i] < this.maturityOption.getValue() && i < getNbAdaptiveClassifiers())
+				mature = false;
+
+			// check if all adaptive learners are not mature
+			if (this.ensembleAges[i] >= this.maturityOption.getValue() && i < getNbAdaptiveClassifiers())
+				unmature = false;
+
+			if (this.nbInstances >= this.ensembleWeights[i].index + 1) {
+
+				// train adaptive learners
+				if (i < getNbAdaptiveClassifiers())
+					this.ensemble[i].trainOnInstance(inst);
+
+				int val = this.ensemble[i].correctlyClassifies(inst) ? 1 : 0;
+				double sum = updateEvaluationWindow(i, val);
+				this.ensembleWeights[i].val = sum;
+				this.ensembleAges[i] = this.ensembleAges[i] + 1;
+
+			}
+
+		}
+
+		// if all adaptive learners are not mature --> set weights to one
+		if (unmature)
+			for (int i = 0; i < getNbAdaptiveClassifiers(); i++)
+				this.ensembleWeights[i].val = 1;
+
+		// if all adaptive learners are mature --> delete one learner
+		if (mature) {
+			Pair[] learners = getHalf(false);
+
+			if (learners.length > 0) {
+				double rand = classifierRandom.nextInt(learners.length);
+				discardModel(learners[(int) rand].index);
+			}
+		}
+
+	}
+
+	/**
+	 * Resets a classifier in the ensemble
+	 * 
+	 * @param index the index of the classifier in the ensemble
+	 */
+	public void discardModel(int index) {
+		this.ensemble[index].resetLearning();
+		this.ensembleWeights[index].val = 0;
+		this.ensembleAges[index] = 0;
+		this.ensembleWindows[index] = new int[(int) this.evaluationSizeOption.getValue()];
+	}
+
+	/**
+	 * Updates the evaluation window of a classifier and returns the updated weight
+	 * value.
+	 * 
+	 * @param index the index of the classifier in the ensemble
+	 * @param val   the last evaluation record of the classifier
+	 * @return the updated weight value of the classifier
+	 */
+	protected double updateEvaluationWindow(int index, int val) {
+
+		int[] newEnsembleWindows = new int[this.ensembleWindows[index].length];
+
+		int wsize = (int) Math.min(this.evaluationSizeOption.getValue(), this.ensembleAges[index] + 1);
+
+		int sum = 0;
+		for (int i = 0; i < wsize - 1; i++) {
+			newEnsembleWindows[i + 1] = this.ensembleWindows[index][i];
+			sum = sum + this.ensembleWindows[index][i];
+		}
+
+		newEnsembleWindows[0] = val;
+		this.ensembleWindows[index] = newEnsembleWindows;
+
+		if (this.ensembleAges[index] >= this.maturityOption.getValue())
+			return (sum + val) * 1.0 / wsize;
+		else
+			return 0;
+
+	}
+
+	/**
+	 * Returns the best (or worst) half of classifiers in the adaptive ensemble. The
+	 * best classifiers are used to compute the stability index in ADACC. The worst
+	 * classifiers are returned in order to select a classifier for deletion.
+	 * 
+	 * @param bestHalf boolean value set to true (false) if we want to return the
+	 *                 best (worst) half of adaptive classifiers.
+	 * @param horizon
+	 * @return an array containing the weight values of the corresponding
+	 *         classifiers and their indexes in the ensemble.
+	 */
+	protected Pair[] getHalf(boolean bestHalf) {
+
+		Pair[] newEnsembleWeights = new Pair[getNbAdaptiveClassifiers()];
+		System.arraycopy(ensembleWeights, 0, newEnsembleWeights, 0, newEnsembleWeights.length);
+
+		if (bestHalf)
+			Arrays.sort(newEnsembleWeights, Collections.reverseOrder());
+		else
+			Arrays.sort(newEnsembleWeights);
+
+		Pair[] result = new Pair[(int) Math.floor(newEnsembleWeights.length / 2)];
+		System.arraycopy(newEnsembleWeights, 0, result, 0, result.length);
+
+		return result;
+	}
+
+	/**
+	 * Returns the classifiers that vote for the final prediction when the MAX
+	 * combination function is selected
+	 * 
+	 * @return the classifiers with the highest weight value
+	 */
+	protected ArrayList<Integer> getMAXIndexes() {
+
+		ArrayList<Integer> maxWIndex = new ArrayList<>();
+		Pair[] newEnsembleWeights = new Pair[getNbActiveClassifiers()];
+		System.arraycopy(ensembleWeights, 0, newEnsembleWeights, 0, newEnsembleWeights.length);
+
+		Arrays.sort(newEnsembleWeights);
+
+		double maxWVal = newEnsembleWeights[newEnsembleWeights.length - 1].val;
+
+		for (int i = newEnsembleWeights.length - 1; i >= 0; i--) {
+			if (newEnsembleWeights[i].val != maxWVal)
+				break;
+			else
+				maxWIndex.add(newEnsembleWeights[i].index);
+
+		}
+		return maxWIndex;
+	}
+
+	/**
+	 * Returns the classifiers that vote for the final prediction when the WVD
+	 * combination function is selected
+	 * 
+	 * @return the classifiers whose weights lie in the higher half of the
+	 *         ensemble's weight interval.
+	 */
+	protected ArrayList<Integer> getWVDIndexes() {
+
+		ArrayList<Integer> maxWIndex = new ArrayList<>();
+
+		Pair[] newEnsembleWeights = new Pair[getNbActiveClassifiers()];
+
+		System.arraycopy(ensembleWeights, 0, newEnsembleWeights, 0, newEnsembleWeights.length);
+
+		Arrays.sort(newEnsembleWeights);
+
+		double minWVal = newEnsembleWeights[0].val;
+		double maxWVal = newEnsembleWeights[newEnsembleWeights.length - 1].val;
+		double med = (maxWVal - minWVal) * 1.0 / 2;
+
+		for (int i = newEnsembleWeights.length - 1; i >= 0; i--)
+			if (newEnsembleWeights[i].val < med)
+				break;
+			else
+				maxWIndex.add(newEnsembleWeights[i].index);
+
+		return maxWIndex;
+	}
+
+	/**
+	 * Returns the number of classifiers used for prediction which includes the
+	 * adaptive learners and the snapshots in ADACC
+	 * 
+	 * @return the number of classifiers used for prediction
+	 */
+	protected int getNbActiveClassifiers() {
+		return this.ensemble.length;
+	}
+
+	/**
+	 * Returns the number of adaptive classifiers in the ensemble which excludes the
+	 * static snapshots in ADACC
+	 * 
+	 * @return the number of adaptive classifiers
+	 */
+	protected int getNbAdaptiveClassifiers() {
+		return this.ensemble.length;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		Measurement[] measurements = new Measurement[4];
+		measurements[0] = new Measurement("size ", this.ensemble.length);
+		measurements[1] = new Measurement("maturity ", this.maturityOption.getValue());
+		measurements[2] = new Measurement("evalsize ", this.evaluationSizeOption.getValue());
+		measurements[3] = new Measurement("cmb ", this.combinationOption.getChosenIndex());
+		return measurements;
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	@Override
+	public Classifier[] getSubClassifiers() {
+		return this.ensemble.clone();
+	}
+
+	/**
+	 * This helper class is used to sort an array of pairs of integers: val and
+	 * index. The array is sorted based on the val field.
+	 * 
+	 * @author Ghazal Jaber
+	 *
+	 */
+	protected class Pair implements Comparable<Pair>, Serializable {
+
+		private static final long serialVersionUID = 1L;
+		double val;
+		int index;
+
+		public Pair(double d, int i) {
+			this.val = d;
+			this.index = i;
+		}
+
+		@Override
+		public int compareTo(Pair other) {
+			if (this.val - other.val > 0)
+				return 1;
+			else if (this.val == other.val)
+				return 0;
+			return -1;
+		}
+
+		public double getValue() {
+			return val;
+		}
+
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/meta/DynamicWeightedMajority.java b/moa/src/main/java/moa/learners/predictors/meta/DynamicWeightedMajority.java
new file mode 100644
index 000000000..cce9eb413
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/meta/DynamicWeightedMajority.java
@@ -0,0 +1,184 @@
+/*
+ *    DynamicWeightedMajority.java
+ *    Copyright (C) 2016 Instituto Federal de Pernambuco
+ *    @author Paulo Gonçalves (paulogoncalves@recife.ifpe.edu.br)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.meta;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Measurement;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.options.ClassOption;
+import weka.core.Utils;
+
+/**
+ * Dynamic weighted majority algorithm.
+ *
+ * Extends the Weighted Majority Algorithm to add and remove experts based on
+ * local and global accuracy.
+ *
+ * <p>
+ * J. Zico Kolter and Marcus A. Maloof. Dynamic weighted majority: An ensemble
+ * method for drifting concepts. The Journal of Machine Learning Research,
+ * 8:2755-2790, December 2007. ISSN 1532-4435. URL
+ * http://dl.acm.org/citation.cfm?id=1314498.1390333.
+ * </p>
+ *
+ * <p>
+ * Based on the source code provided by the author at
+ * <a href="http://people.cs.georgetown.edu/~maloof/pubs/jmlr07.php">
+ * http://people.cs.georgetown.edu/~maloof/pubs/jmlr07.php</a>
+ * </p>
+ *
+ * @author Paulo Goncalves (paulogoncalves at recife dot ifpe dot edu dot br)
+ *
+ */
+public class DynamicWeightedMajority extends AbstractClassifier implements Classifier {
+
+	public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l', "Base classifiers to train.",
+			Classifier.class, "bayes.NaiveBayes");
+
+	public IntOption periodOption = new IntOption("period", 'p',
+			"Period between expert removal, creation, and weight update.", 50, 1, Integer.MAX_VALUE);
+
+	public FloatOption betaOption = new FloatOption("beta", 'b', "Factor to punish mistakes by.", 0.5, 0.0, 1.0);
+
+	public FloatOption thetaOption = new FloatOption("theta", 't', "Minimum fraction of weight per model.", 0.01, 0.0,
+			1.0);
+
+	public IntOption maxExpertsOption = new IntOption("maxExperts", 'e', "Maximum number of allowed experts.",
+			Integer.MAX_VALUE, 2, Integer.MAX_VALUE);
+
+	protected List<Classifier> experts;
+	protected List<Double> weights;
+	protected long epochs;
+
+	@Override
+	public void resetLearningImpl() {
+		this.experts = new ArrayList<>(50);
+		Classifier classifier = (Classifier) ((Classifier) getPreparedClassOption(this.baseLearnerOption)).copy();
+		classifier.resetLearning();
+		this.experts.add(classifier);
+		this.weights = new ArrayList<>(50);
+		this.weights.add(1.0);
+		this.epochs = 0;
+	}
+
+	protected void scaleWeights(double maxWeight) {
+		double sf = 1.0 / maxWeight;
+		for (int i = 0; i < weights.size(); i++) {
+			weights.set(i, weights.get(i) * sf);
+		}
+	}
+
+	protected void removeExperts() {
+		for (int i = experts.size() - 1; i >= 0; i--) {
+			if (weights.get(i) < this.thetaOption.getValue()) {
+				experts.remove(i);
+				weights.remove(i);
+			} // if
+		} // for
+	} // DWM::removeExperts
+
+	protected void removeWeakestExpert(int i) {
+		experts.remove(i);
+		weights.remove(i);
+	} // DWM::removeWeakestExpert
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		this.epochs++;
+		double[] Pr = new double[inst.numClasses()];
+		double maxWeight = 0.0;
+		double weakestExpertWeight = 1.0;
+		int weakestExpertIndex = -1;
+		// Loop over experts
+		for (int i = 0; i < this.experts.size(); i++) {
+			double[] pr = this.experts.get(i).getPredictionForInstance(inst).asDoubleArray();
+			int yHat = Utils.maxIndex(pr);
+			if ((yHat != (int) inst.classValue()) && this.epochs % this.periodOption.getValue() == 0) {
+				this.weights.set(i, this.weights.get(i) * this.betaOption.getValue());
+			}
+			Pr[yHat] += this.weights.get(i);
+			maxWeight = Math.max(maxWeight, this.weights.get(i));
+			if (this.weights.get(i) < weakestExpertWeight) {
+				weakestExpertIndex = i;
+				weakestExpertWeight = weights.get(i);
+			}
+		}
+		int yHat = Utils.maxIndex(Pr);
+		if (this.epochs % this.periodOption.getValue() == 0) {
+			scaleWeights(maxWeight);
+			removeExperts();
+			if (yHat != (int) inst.classValue()) {
+				if (experts.size() == this.maxExpertsOption.getValue()) {
+					removeWeakestExpert(weakestExpertIndex);
+				}
+				Classifier classifier = (Classifier) ((Classifier) getPreparedClassOption(this.baseLearnerOption))
+						.copy();
+				classifier.resetLearning();
+				this.experts.add(classifier);
+				this.weights.add(1.0);
+			}
+		}
+		// train experts
+		for (Classifier expert : this.experts) {
+			expert.trainOnInstance(inst);
+		}
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		double[] Pr = new double[inst.numClasses()];
+		for (int i = 0; i < this.experts.size(); i++) {
+			double[] pr = this.experts.get(i).getPredictionForInstance(inst).asDoubleArray();
+			int yHat = Utils.maxIndex(pr);
+			Pr[yHat] += this.weights.get(i);
+		} // for
+		Utils.normalize(Pr);
+		return new ClassificationPrediction(Pr);
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		Measurement[] measurements = null;
+		if (this.weights != null) {
+			measurements = new Measurement[1];
+			measurements[0] = new Measurement("members size", this.weights.size());
+		}
+		return measurements;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/meta/HeterogeneousEnsembleAbstract.java b/moa/src/main/java/moa/learners/predictors/meta/HeterogeneousEnsembleAbstract.java
similarity index 81%
rename from moa/src/main/java/moa/classifiers/meta/HeterogeneousEnsembleAbstract.java
rename to moa/src/main/java/moa/learners/predictors/meta/HeterogeneousEnsembleAbstract.java
index f4a38d61b..3e47ca244 100644
--- a/moa/src/main/java/moa/classifiers/meta/HeterogeneousEnsembleAbstract.java
+++ b/moa/src/main/java/moa/learners/predictors/meta/HeterogeneousEnsembleAbstract.java
@@ -15,9 +15,9 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.classifiers.meta;
+package moa.learners.predictors.meta;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -32,10 +32,10 @@
 import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-import moa.classifiers.AbstractClassifier;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
-import moa.learners.Classifier;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
 import moa.options.ClassOption;
 import moa.tasks.TaskMonitor;
 
@@ -45,8 +45,8 @@
  * <p>
  * Given a set of (heterogeneous) classifiers, BLAST builds an ensemble, and
  * determines the weights of all ensemble members based on their performance on
- * recent observed instances. Used as Abstact Base Class for 
- * HeterogeneousEnsembleBlast and HeterogeneousEnsembleBlastFadingFactors. 
+ * recent observed instances. Used as Abstact Base Class for
+ * HeterogeneousEnsembleBlast and HeterogeneousEnsembleBlastFadingFactors.
  * </p>
  *
  * <p>
@@ -73,25 +73,21 @@ public abstract class HeterogeneousEnsembleAbstract extends AbstractClassifier {
 
 	public ListOption baselearnersOption = new ListOption("baseClassifiers", 'b',
 			"The classifiers the ensemble consists of.",
-			new ClassOption("learner", ' ', "", Classifier.class, "moa.classifiers.trees.HoeffdingTree"),
-			new Option[] {
-					new ClassOption("", ' ', "", Classifier.class, "moa.classifiers.bayes.NaiveBayes"),
-					new ClassOption("", ' ', "", Classifier.class, "moa.classifiers.functions.Perceptron"),
-					new ClassOption("", ' ', "", Classifier.class, "moa.classifiers.functions.SGD"),
-					new ClassOption("", ' ', "", Classifier.class, "moa.classifiers.lazy.kNN"),
-					new ClassOption("", ' ', "", Classifier.class, "moa.classifiers.trees.HoeffdingTree") },
+			new ClassOption("learner", ' ', "", Classifier.class, "trees.HoeffdingTree"),
+			new Option[] { new ClassOption("", ' ', "", Classifier.class, "bayes.NaiveBayes"),
+					new ClassOption("", ' ', "", Classifier.class, "functions.Perceptron"),
+					new ClassOption("", ' ', "", Classifier.class, "functions.SGD"),
+					new ClassOption("", ' ', "", Classifier.class, "lazy.kNN"),
+					new ClassOption("", ' ', "", Classifier.class, "trees.HoeffdingTree") },
 			',');
 
 	public IntOption gracePerionOption = new IntOption("gracePeriod", 'g',
-			"How many instances before we reevalate the best classifier", 1, 1,
-			Integer.MAX_VALUE);
+			"How many instances before we reevalate the best classifier", 1, 1, Integer.MAX_VALUE);
 
-	public IntOption activeClassifiersOption = new IntOption("activeClassifiers",
-			'k', "The number of active classifiers (used for voting)", 1, 1,
-			Integer.MAX_VALUE);
+	public IntOption activeClassifiersOption = new IntOption("activeClassifiers", 'k',
+			"The number of active classifiers (used for voting)", 1, 1, Integer.MAX_VALUE);
 
-	public FlagOption weightClassifiersOption = new FlagOption(
-			"weightClassifiers", 'p',
+	public FlagOption weightClassifiersOption = new FlagOption("weightClassifiers", 'p',
 			"Uses online performance estimation to weight the classifiers");
 
 	protected Classifier[] ensemble;
@@ -105,8 +101,7 @@ public abstract class HeterogeneousEnsembleAbstract extends AbstractClassifier {
 	@Override
 	public String getPurposeString() {
 		return "The model-free heterogeneous ensemble as presented in "
-				+ "'Having a Blast: Meta-Learning and Heterogeneous Ensembles "
-				+ "for Data Streams' (ICDM 2015).";
+				+ "'Having a Blast: Meta-Learning and Heterogeneous Ensembles " + "for Data Streams' (ICDM 2015).";
 	}
 
 	public int getEnsembleSize() {
@@ -124,8 +119,7 @@ public Prediction getPredictionForInstance(Instance inst) {
 		double[] votes = new double[inst.classAttribute().numValues()];
 
 		for (int i = 0; i < topK.size(); ++i) {
-			double[] memberVotes = normalize(
-					ensemble[topK.get(i)].getPredictionForInstance(inst).asDoubleArray());
+			double[] memberVotes = normalize(ensemble[topK.get(i)].getPredictionForInstance(inst).asDoubleArray());
 			double weight = 1.0;
 
 			if (weightClassifiersOption.isSet()) {
@@ -166,16 +160,13 @@ protected Measurement[] getModelMeasurementsImpl() {
 	}
 
 	@Override
-	public void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
+	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
 
 		Option[] learnerOptions = this.baselearnersOption.getList();
 		this.ensemble = new Classifier[learnerOptions.length];
 		for (int i = 0; i < learnerOptions.length; i++) {
-			monitor.setCurrentActivity("Materializing learner " + (i + 1) + "...",
-					-1.0);
-			this.ensemble[i] = (Classifier) ((ClassOption) learnerOptions[i])
-					.materializeObject(monitor, repository);
+			monitor.setCurrentActivity("Materializing learner " + (i + 1) + "...", -1.0);
+			this.ensemble[i] = (Classifier) ((ClassOption) learnerOptions[i]).materializeObject(monitor, repository);
 			if (monitor.taskShouldAbort()) {
 				return;
 			}
@@ -193,7 +184,7 @@ public void prepareForUseImpl(TaskMonitor monitor,
 	protected static List<Integer> topK(double[] scores, int k) {
 		double[] scoresWorking = Arrays.copyOf(scores, scores.length);
 
-		List<Integer> topK = new ArrayList<Integer>();
+		List<Integer> topK = new ArrayList<>();
 
 		for (int i = 0; i < k; ++i) {
 			int bestIdx = maxIndex(scoresWorking);
diff --git a/moa/src/main/java/moa/classifiers/meta/HeterogeneousEnsembleBlast.java b/moa/src/main/java/moa/learners/predictors/meta/HeterogeneousEnsembleBlast.java
similarity index 95%
rename from moa/src/main/java/moa/classifiers/meta/HeterogeneousEnsembleBlast.java
rename to moa/src/main/java/moa/learners/predictors/meta/HeterogeneousEnsembleBlast.java
index 62ee368a1..298b21bfb 100644
--- a/moa/src/main/java/moa/classifiers/meta/HeterogeneousEnsembleBlast.java
+++ b/moa/src/main/java/moa/learners/predictors/meta/HeterogeneousEnsembleBlast.java
@@ -15,22 +15,21 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.classifiers.meta;
+package moa.learners.predictors.meta;
 
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
-
 /**
  * BLAST (Best Last) for Heterogeneous Ensembles implemented with Fading Factors
  *
  * <p>
  * Given a set of (heterogeneous) classifiers, BLAST builds an ensemble, and
  * determines the weights of all ensemble members based on their performance on
- * recent observed instances. This implementation uses a window of recent 
- * instances, the size is determined by the 'w' parameter. 
+ * recent observed instances. This implementation uses a window of recent
+ * instances, the size is determined by the 'w' parameter.
  * </p>
  *
  * <p>
@@ -59,14 +58,12 @@ public class HeterogeneousEnsembleBlast extends HeterogeneousEnsembleAbstract {
 	protected boolean[][] onlineHistory;
 
 	public IntOption windowSizeOption = new IntOption("windowSize", 'w',
-			"The window size over which Online Performance Estimation is done.", 1000,
-			1, Integer.MAX_VALUE);
+			"The window size over which Online Performance Estimation is done.", 1000, 1, Integer.MAX_VALUE);
 
 	@Override
 	public void resetLearningImpl() {
 		this.historyTotal = new double[this.ensemble.length];
-		this.onlineHistory = new boolean[this.ensemble.length][windowSizeOption
-				.getValue()];
+		this.onlineHistory = new boolean[this.ensemble.length][windowSizeOption.getValue()];
 		this.instancesSeen = 0;
 
 		for (int i = 0; i < this.ensemble.length; i++) {
diff --git a/moa/src/main/java/moa/classifiers/meta/HeterogeneousEnsembleBlastFadingFactors.java b/moa/src/main/java/moa/learners/predictors/meta/HeterogeneousEnsembleBlastFadingFactors.java
similarity index 91%
rename from moa/src/main/java/moa/classifiers/meta/HeterogeneousEnsembleBlastFadingFactors.java
rename to moa/src/main/java/moa/learners/predictors/meta/HeterogeneousEnsembleBlastFadingFactors.java
index 0e652c346..46aa3c211 100644
--- a/moa/src/main/java/moa/classifiers/meta/HeterogeneousEnsembleBlastFadingFactors.java
+++ b/moa/src/main/java/moa/learners/predictors/meta/HeterogeneousEnsembleBlastFadingFactors.java
@@ -15,9 +15,9 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.classifiers.meta;
+package moa.learners.predictors.meta;
 
 import com.github.javacliparser.FloatOption;
 import com.yahoo.labs.samoa.instances.Instance;
@@ -51,8 +51,7 @@
  * @author Jan N. van Rijn (j.n.van.rijn@liacs.leidenuniv.nl)
  * @version $Revision: 1 $
  */
-public class HeterogeneousEnsembleBlastFadingFactors
-		extends HeterogeneousEnsembleAbstract {
+public class HeterogeneousEnsembleBlastFadingFactors extends HeterogeneousEnsembleAbstract {
 
 	private static final long serialVersionUID = 1L;
 
@@ -64,8 +63,7 @@ public class HeterogeneousEnsembleBlastFadingFactors
 
 	private int trainingErrors;
 
-	public FloatOption alphaOption = new FloatOption("alpha", 'a',
-			"The fading factor.", 0.999, 0, 1);
+	public FloatOption alphaOption = new FloatOption("alpha", 'a', "The fading factor.", 0.999, 0, 1);
 
 	@Override
 	public void resetLearningImpl() {
@@ -100,8 +98,7 @@ public void trainOnInstanceImpl(Instance inst) {
 				this.trainingErrors += 1;
 
 				if (trainingErrors > MAX_TOLLERATED_TRAINING_ERRROS) {
-					throw new RuntimeException(
-							"Too much training errors! Latest: " + e.getMessage());
+					throw new RuntimeException("Too much training errors! Latest: " + e.getMessage());
 				}
 			}
 		}
diff --git a/moa/src/main/java/moa/learners/predictors/meta/LearnNSE.java b/moa/src/main/java/moa/learners/predictors/meta/LearnNSE.java
new file mode 100644
index 000000000..417530ec9
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/meta/LearnNSE.java
@@ -0,0 +1,276 @@
+/*
+ *    LearnNSE.java
+ *    Copyright (C) 2016 Instituto Federal de Pernambuco
+ *    @author Paulo Gonçalves (paulogoncalves@recife.ifpe.edu.br)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.meta;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.options.ClassOption;
+
+/**
+ * <p>
+ * Ensemble of classifiers-based approach for incremental learning of concept
+ * drift, characterized by nonstationary environments (NSEs), where the
+ * underlying data distributions change over time. It learns from consecutive
+ * batches of data that experience constant or variable rate of drift, addition
+ * or deletion of concept classes, as well as cyclical drift.
+ * </p>
+ *
+ * <p>
+ * Based on: Ryan Elwell and Robi Polikar. Incremental learning of concept drift
+ * in non-stationary environments. IEEE Transactions on Neural Networks,
+ * 22(10):1517-1531, October 2011. ISSN 1045-9227. URL
+ * http://dx.doi.org/10.1109/TNN.2011.2160459
+ * </p>
+ *
+ * @author Paulo Gonçalves (paulogoncalves@recife.ifpe.edu.br)
+ * @author Dariusz Brzezinski
+ *
+ *
+ */
+public class LearnNSE extends AbstractClassifier implements Classifier {
+
+	public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l', "Classifier to train.", Classifier.class,
+			"bayes.NaiveBayes");
+
+	public IntOption periodOption = new IntOption("period", 'p', "Size of the environments.", 250, 1,
+			Integer.MAX_VALUE);
+
+	public FloatOption sigmoidSlopeOption = new FloatOption("sigmoidSlope", 'a',
+			"Slope of the sigmoid function controlling the number "
+					+ "of previous periods taken into account during weighting.",
+			0.5, 0, Float.MAX_VALUE);
+
+	public FloatOption sigmoidCrossingPointOption = new FloatOption("sigmoidCrossingPoint", 'b',
+			"Halfway crossing point of the sigmoid function controlling the number of previous "
+					+ "periods taken into account during weighting.",
+			10, 0, Float.MAX_VALUE);
+
+	public IntOption ensembleSizeOption = new IntOption("ensembleSize", 'e', "Ensemble size.", 15, 1,
+			Integer.MAX_VALUE);
+
+	public MultiChoiceOption pruningStrategyOption = new MultiChoiceOption("pruningStrategy", 's',
+			"Classifiers pruning strategy to be used.", new String[] { "NO", "AGE", "ERROR" },
+			new String[] { "Don't prune classifiers", "Age-based", "Error-based" }, 0);
+
+	protected List<Classifier> ensemble;
+	protected List<Double> ensembleWeights;
+	protected List<ArrayList<Double>> bkts, wkts;
+	protected InstancesHeader buffer;
+	protected long index;
+	protected double slope, crossingPoint;
+	protected int pruning, ensembleSize;
+
+	@Override
+	public void resetLearningImpl() {
+		this.ensemble = new ArrayList<>();
+		this.ensembleWeights = new ArrayList<>();
+		this.bkts = new ArrayList<>();
+		this.wkts = new ArrayList<>();
+		this.index = 0;
+		this.buffer = null;
+		this.slope = this.sigmoidSlopeOption.getValue();
+		this.crossingPoint = this.sigmoidCrossingPointOption.getValue();
+		this.pruning = this.pruningStrategyOption.getChosenIndex();
+		this.ensembleSize = this.ensembleSizeOption.getValue();
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		this.index++;
+		// Store instance in the buffer
+		if (this.buffer == null) {
+			this.buffer = inst.dataset().getEmptyHeader();
+		}
+		this.buffer.add(inst);
+
+		if (this.index % this.periodOption.getValue() == 0) {
+			this.index = 0;
+			double mt = this.buffer.numInstances();
+			Classifier classifier = ((Classifier) getPreparedClassOption(this.baseLearnerOption));
+			classifier.resetLearning();
+
+			if (this.ensemble.size() > 0) {
+				double et = 0;
+				// Reading all data chunk instances
+				for (int i = 0; i < mt; i++) {
+					// Compute error of the existing ensemble on new data
+					boolean vote = this.correctlyClassifies(this.buffer.instance(i));
+					if (!vote) {
+						et += 1.0 / mt;
+					}
+				}
+				// Normalizing error
+				double weightSum = 0.0;
+				// Reading all data chunk instances
+				for (int i = 0; i < mt; i++) {
+					Instance instance = this.buffer.instance(i);
+					// Updating instance weights
+					boolean vote = this.correctlyClassifies(instance);
+					double error = (1.0 / mt) * (vote ? et : 1.0);
+					instance.setWeight(error);
+					weightSum += error;
+				}
+				// Reading all data chunk instances
+				for (int i = 0; i < mt; i++) {
+					Instance instance = this.buffer.instance(i);
+					// Normalize weights
+					instance.setWeight(instance.weight() / weightSum);
+
+					// Call base classifier
+					Instance trainingInstance = instance.copy();
+					trainingInstance.setWeight(1);
+					classifier.trainOnInstance(trainingInstance);
+				}
+			} else {
+				// First run! Iterating through all instances in the data chunk
+				for (int i = 0; i < mt; i++) {
+					Instance instance = this.buffer.instance(i);
+
+					// Initialize weights
+					instance.setWeight(1.0 / mt);
+
+					// Call base classifier
+					Instance trainingInstance = instance.copy();
+					trainingInstance.setWeight(1);
+					classifier.trainOnInstance(trainingInstance);
+				}
+			}
+			this.ensemble.add(classifier);
+			this.bkts.add(new ArrayList());
+			this.wkts.add(new ArrayList());
+			this.ensembleWeights.clear();
+			int t = this.ensemble.size();
+			double maxError = Double.NEGATIVE_INFINITY;
+			int errorIndex = Integer.MIN_VALUE;
+			// Evaluate all existing classifiers on new data set
+			for (int k = 1; k <= t; k++) {
+				double ekt = 0;
+				// Reading all data chunk instances
+				for (int i = 0; i < mt; i++) {
+					Instance instance = this.buffer.instance(i);
+					if (!this.ensemble.get(k - 1).correctlyClassifies(instance)) {
+						// Ensemble incorrectly classifies this instance
+						ekt += instance.weight();
+					}
+				}
+				if (k == t && ekt > 0.5) {
+					// Generate a new classifier
+					Classifier c = (Classifier) getPreparedClassOption(this.baseLearnerOption);
+					c.resetLearning();
+					this.ensemble.set(k - 1, c);
+				} else if (ekt > 0.5) {
+					// Remove voting power of this classifier
+					ekt = 0.5;
+				}
+				// Storing the index of the classifier with higher error in case
+				// of error-based pruning
+				if (ekt > maxError) {
+					maxError = ekt;
+					errorIndex = k;
+				}
+				// Normalizing errors
+				double bkt = ekt / (1.0 - ekt);
+				// Retrieving normalized errors for this classifier
+				ArrayList<Double> nbkt = this.bkts.get(k - 1);
+				nbkt.add(bkt);
+				// Compute the weighted average of all normalized errors for kth
+				// classifier h_k
+				double wkt = 1.0 / (1.0 + Math.exp(-this.slope * (t - k - this.crossingPoint)));
+				List<Double> weights = this.wkts.get(k - 1);
+				double sum = 0;
+				for (Double weight : weights) {
+					sum += weight;
+				}
+				weights.add(wkt / (sum + wkt));
+				double sbkt = 0.0;
+				for (int j = 0; j < weights.size(); j++) {
+					sbkt += weights.get(j) * nbkt.get(j);
+				}
+				// Calculate classifier voting weights
+				this.ensembleWeights.add(Math.log(1.0 / sbkt));
+			}
+			// Ensemble pruning strategy
+			if (pruning == 1 && t > ensembleSize) { // Age-based
+				this.ensemble.remove(0);
+				this.ensembleWeights.remove(0);
+				this.bkts.remove(0);
+				this.wkts.remove(0);
+			} else if (pruning == 2 && t > ensembleSize) { // Error-based
+				this.ensemble.remove(errorIndex - 1);
+				this.ensembleWeights.remove(errorIndex - 1);
+				this.bkts.remove(errorIndex - 1);
+				this.wkts.remove(errorIndex - 1);
+			}
+			this.buffer = this.getModelContext().getEmptyHeader();
+		}
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		DoubleVector combinedVote = new DoubleVector();
+		if (this.trainingWeightSeenByModel > 0.0) {
+			for (int i = 0; i < this.ensemble.size(); i++) {
+				if (this.ensembleWeights.get(i) > 0.0) {
+					DoubleVector vote = this.ensemble.get(i).getPredictionForInstance(inst).asDoubleVector();
+					if (vote.sumOfValues() > 0.0) {
+						vote.normalize();
+						vote.scaleValues(this.ensembleWeights.get(i));
+						combinedVote.addValues(vote);
+					}
+				}
+			}
+		}
+		return new ClassificationPrediction(combinedVote.getArrayRef());
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		Measurement[] measurements = null;
+		if (this.ensembleWeights != null) {
+			measurements = new Measurement[this.ensembleWeights.size()];
+			for (int i = 0; i < this.ensembleWeights.size(); i++) {
+				measurements[i] = new Measurement("member weight " + (i + 1), this.ensembleWeights.get(i));
+			}
+		}
+		return measurements;
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/meta/LeveragingBag.java b/moa/src/main/java/moa/learners/predictors/meta/LeveragingBag.java
new file mode 100644
index 000000000..20a060f02
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/meta/LeveragingBag.java
@@ -0,0 +1,285 @@
+/*
+ *    LeveragingBag.java
+ *    Copyright (C) 2010 University of Waikato, Hamilton, New Zealand
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.meta;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.capabilities.CapabilitiesHandler;
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.MiscUtils;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.core.driftdetection.ADWIN;
+import moa.options.ClassOption;
+
+/**
+ * Leveraging Bagging for evolving data streams using ADWIN. Leveraging Bagging
+ * and Leveraging Bagging MC using Random Output Codes ( -o option).
+ *
+ * <p>
+ * See details in:<br />
+ * Albert Bifet, Geoffrey Holmes, Bernhard Pfahringer. Leveraging Bagging for
+ * Evolving Data Streams Machine Learning and Knowledge Discovery in Databases,
+ * European Conference, ECML PKDD}, 2010.
+ * </p>
+ *
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @version $Revision: 7 $
+ */
+public class LeveragingBag extends AbstractClassifier implements Classifier, CapabilitiesHandler {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Leveraging Bagging for evolving data streams using ADWIN.";
+	}
+
+	public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l', "Classifier to train.", Classifier.class,
+			"trees.HoeffdingTree");
+
+	public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's', "The number of models in the bag.", 10, 1,
+			Integer.MAX_VALUE);
+
+	public FloatOption weightShrinkOption = new FloatOption("weightShrink", 'w',
+			"The number to use to compute the weight of new instances.", 6, 0.0, Float.MAX_VALUE);
+
+	public FloatOption deltaAdwinOption = new FloatOption("deltaAdwin", 'a', "Delta of Adwin change detection", 0.002,
+			0.0, 1.0);
+
+	// Leveraging Bagging MC: uses this option to use Output Codes
+	public FlagOption outputCodesOption = new FlagOption("outputCodes", 'o',
+			"Use Output Codes to use binary classifiers.");
+
+	public MultiChoiceOption leveraginBagAlgorithmOption = new MultiChoiceOption("leveraginBagAlgorithm", 'm',
+			"Leveraging Bagging to use.",
+			new String[] { "LeveragingBag", "LeveragingBagME", "LeveragingBagHalf", "LeveragingBagWT",
+					"LeveragingSubag" },
+			new String[] { "Leveraging Bagging for evolving data streams using ADWIN",
+					"Leveraging Bagging ME using weight 1 if misclassified, otherwise error/(1-error)",
+					"Leveraging Bagging Half using resampling without replacement half of the instances",
+					"Leveraging Bagging WT without taking out all instances.",
+					"Leveraging Subagging using resampling without replacement." },
+			0);
+
+	protected Classifier[] ensemble;
+
+	protected ADWIN[] ADError;
+
+	protected int numberOfChangesDetected;
+
+	protected int[][] matrixCodes;
+
+	protected boolean initMatrixCodes = false;
+
+	@Override
+	public void resetLearningImpl() {
+		this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
+		Classifier baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
+		baseLearner.resetLearning();
+		for (int i = 0; i < this.ensemble.length; i++) {
+			this.ensemble[i] = (Classifier) baseLearner.copy();
+		}
+		this.ADError = new ADWIN[this.ensemble.length];
+		for (int i = 0; i < this.ensemble.length; i++) {
+			this.ADError[i] = new ADWIN(this.deltaAdwinOption.getValue());
+		}
+		this.numberOfChangesDetected = 0;
+		if (this.outputCodesOption.isSet()) {
+			this.initMatrixCodes = true;
+		}
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		int numClasses = inst.numClasses();
+		// Output Codes
+		if (this.initMatrixCodes == true) {
+			this.matrixCodes = new int[this.ensemble.length][inst.numClasses()];
+			for (int i = 0; i < this.ensemble.length; i++) {
+				int numberOnes;
+				int numberZeros;
+
+				do { // until we have the same number of zeros and ones
+					numberOnes = 0;
+					numberZeros = 0;
+					for (int j = 0; j < numClasses; j++) {
+						int result = 0;
+						if (j == 1 && numClasses == 2) {
+							result = 1 - this.matrixCodes[i][0];
+						} else {
+							result = (this.classifierRandom.nextBoolean() ? 1 : 0);
+						}
+						this.matrixCodes[i][j] = result;
+						if (result == 1) {
+							numberOnes++;
+						} else {
+							numberZeros++;
+						}
+					}
+				} while ((numberOnes - numberZeros) * (numberOnes - numberZeros) > (this.ensemble.length % 2));
+
+			}
+			this.initMatrixCodes = false;
+		}
+
+		boolean Change = false;
+		Instance weightedInst = inst.copy();
+		double w = this.weightShrinkOption.getValue();
+
+		// Train ensemble of classifiers
+		for (int i = 0; i < this.ensemble.length; i++) {
+			double k = 0.0;
+			switch (this.leveraginBagAlgorithmOption.getChosenIndex()) {
+			case 0: // LeveragingBag
+				k = MiscUtils.poisson(w, this.classifierRandom);
+				break;
+			case 1: // LeveragingBagME
+				double error = this.ADError[i].getEstimation();
+				k = !this.ensemble[i].correctlyClassifies(weightedInst) ? 1.0
+						: (this.classifierRandom.nextDouble() < (error / (1.0 - error)) ? 1.0 : 0.0);
+				break;
+			case 2: // LeveragingBagHalf
+				w = 1.0;
+				k = this.classifierRandom.nextBoolean() ? 0.0 : w;
+				break;
+			case 3: // LeveragingBagWT
+				w = 1.0;
+				k = 1.0 + MiscUtils.poisson(w, this.classifierRandom);
+				break;
+			case 4: // LeveragingSubag
+				w = 1.0;
+				k = MiscUtils.poisson(1, this.classifierRandom);
+				k = (k > 0) ? w : 0;
+				break;
+			}
+			if (k > 0) {
+				if (this.outputCodesOption.isSet()) {
+					weightedInst.setClassValue(this.matrixCodes[i][(int) inst.classValue()]);
+				}
+				weightedInst.setWeight(inst.weight() * k);
+				this.ensemble[i].trainOnInstance(weightedInst);
+			}
+			boolean correctlyClassifies = this.ensemble[i].correctlyClassifies(weightedInst);
+			double ErrEstim = this.ADError[i].getEstimation();
+			if (this.ADError[i].setInput(correctlyClassifies ? 0 : 1)) {
+				if (this.ADError[i].getEstimation() > ErrEstim) {
+					Change = true;
+				}
+			}
+		}
+		if (Change) {
+			numberOfChangesDetected++;
+			double max = 0.0;
+			int imax = -1;
+			for (int i = 0; i < this.ensemble.length; i++) {
+				if (max < this.ADError[i].getEstimation()) {
+					max = this.ADError[i].getEstimation();
+					imax = i;
+				}
+			}
+			if (imax != -1) {
+				this.ensemble[imax].resetLearning();
+				// this.ensemble[imax].trainOnInstance(inst);
+				this.ADError[imax] = new ADWIN(this.deltaAdwinOption.getValue());
+			}
+		}
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		if (this.outputCodesOption.isSet()) {
+			return getPredictionForInstanceBinary(inst);
+		}
+		DoubleVector combinedVote = new DoubleVector();
+		for (int i = 0; i < this.ensemble.length; i++) {
+			DoubleVector vote = this.ensemble[i].getPredictionForInstance(inst).asDoubleVector();
+			if (vote.sumOfValues() > 0.0) {
+				vote.normalize();
+				combinedVote.addValues(vote);
+			}
+		}
+		return new ClassificationPrediction(combinedVote.getArrayRef());
+	}
+
+	public Prediction getPredictionForInstanceBinary(Instance inst) {
+		double combinedVote[] = new double[inst.numClasses()];
+		Instance weightedInst = inst.copy();
+		if (this.initMatrixCodes == false) {
+			for (int i = 0; i < this.ensemble.length; i++) {
+				// Replace class by OC
+				weightedInst.setClassValue(this.matrixCodes[i][(int) inst.classValue()]);
+
+				double vote[];
+				vote = this.ensemble[i].getPredictionForInstance(weightedInst).asDoubleArray();
+				// Binary Case
+				int voteClass = 0;
+				if (vote.length == 2) {
+					voteClass = (vote[1] > vote[0] ? 1 : 0);
+				}
+				// Update votes
+				for (int j = 0; j < inst.numClasses(); j++) {
+					if (this.matrixCodes[i][j] == voteClass) {
+						combinedVote[j] += 1;
+					}
+				}
+			}
+		}
+		return new ClassificationPrediction(combinedVote);
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[] { new Measurement("ensemble size", this.ensemble != null ? this.ensemble.length : 0),
+				new Measurement("change detections", this.numberOfChangesDetected) };
+	}
+
+	@Override
+	public Classifier[] getSubClassifiers() {
+		return this.ensemble.clone();
+	}
+
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == LeveragingBag.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/meta/LimAttClassifier.java b/moa/src/main/java/moa/learners/predictors/meta/LimAttClassifier.java
new file mode 100644
index 000000000..8d8eead3b
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/meta/LimAttClassifier.java
@@ -0,0 +1,538 @@
+/*
+ *    LimAttClassifier.java
+ *    Copyright (C) 2010 University of Waikato, Hamilton, New Zealand
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *    @author Eibe Frank (eibe{[at]}cs{[dot]}waikato{[dot]}ac{[dot]}nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.meta;
+
+import java.math.BigInteger;
+import java.util.Arrays;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Measurement;
+import moa.core.Utils;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.core.driftdetection.ADWIN;
+import moa.learners.predictors.trees.LimAttHoeffdingTree;
+import moa.options.ClassOption;
+
+/**
+ * Ensemble Combining Restricted Hoeffding Trees using Stacking. It produces a
+ * classification model based on an ensemble of restricted decision trees, where
+ * each tree is built from a distinct subset of the attributes. The overall
+ * model is formed by combining the log-odds of the predicted class
+ * probabilities of these trees using sigmoid perceptrons, with one perceptron
+ * per class. In contrast to the standard boosting approach, which forms an
+ * ensemble classifier in a greedy fashion, building each tree in sequence and
+ * assigning corresponding weights as a by-product, our method generates each
+ * tree in parallel and combines them using perceptron classifiers by adopting
+ * the stacking approach.
+ *
+ * For more information see,<br/>
+ * <br/>
+ * Albert Bifet, Eibe Frank, Geoffrey Holmes, Bernhard Pfahringer: Accurate
+ * Ensembles for Data Streams: Combining Restricted Hoeffding Trees using
+ * Stacking. Journal of Machine Learning Research - Proceedings Track 13:
+ * 225-240 (2010)
+ *
+ * <!-- technical-bibtex-start --> BibTeX:
+ * 
+ * <pre>
+ * &#64;article{BifetFHP10,
+ * author    = {Albert Bifet and
+ *              Eibe Frank and
+ *              Geoffrey Holmes and
+ *              Bernhard Pfahringer},
+ * title     = {Accurate Ensembles for Data Streams: Combining Restricted
+ *              Hoeffding Trees using Stacking},
+ * journal   = {Journal of Machine Learning Research - Proceedings Track},
+ * volume    = {13},
+ * year      = {2010},
+ * pages     = {225-240}
+ * }
+ * </pre>
+ * <p/>
+ * <!-- technical-bibtex-end -->
+ *
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @author Eibe Frank (eibe{[at]}cs{[dot]}waikato{[dot]}ac{[dot]}nz)
+ * @version $Revision: 7 $
+ */
+public class LimAttClassifier extends AbstractClassifier implements Classifier {
+
+	@Override
+	public String getPurposeString() {
+		return "Ensemble Combining Restricted Hoeffding Trees using Stacking";
+	}
+
+	/*
+	 * Class that generates all combinations of n elements, taken r at a time. The
+	 * algorithm is described by
+	 *
+	 * Kenneth H. Rosen, Discrete Mathematics and Its Applications, 2nd edition (NY:
+	 * McGraw-Hill, 1991), pp. 284-286.
+	 *
+	 * @author Michael Gilleland (megilleland@yahoo.com)
+	 */
+	public class CombinationGenerator {
+
+		private int[] a;
+
+		private int n;
+
+		private int r;
+
+		private BigInteger numLeft;
+
+		private BigInteger total;
+		// ------------
+		// Constructor
+		// ------------
+
+		public CombinationGenerator(int n, int r) {
+			if (r > n) {
+				throw new IllegalArgumentException();
+			}
+			if (n < 1) {
+				throw new IllegalArgumentException();
+			}
+			this.n = n;
+			this.r = r;
+			a = new int[r];
+			BigInteger nFact = getFactorial(n);
+			BigInteger rFact = getFactorial(r);
+			BigInteger nminusrFact = getFactorial(n - r);
+			total = nFact.divide(rFact.multiply(nminusrFact));
+			reset();
+		}
+		// ------
+		// Reset
+		// ------
+
+		public void reset() {
+			for (int i = 0; i < a.length; i++) {
+				a[i] = i;
+			}
+			numLeft = new BigInteger(total.toString());
+		}
+		// ------------------------------------------------
+		// Return number of combinations not yet generated
+		// ------------------------------------------------
+
+		public BigInteger getNumLeft() {
+			return numLeft;
+		}
+		// -----------------------------
+		// Are there more combinations?
+		// -----------------------------
+
+		public boolean hasMore() {
+			return numLeft.compareTo(BigInteger.ZERO) == 1;
+		}
+		// ------------------------------------
+		// Return total number of combinations
+		// ------------------------------------
+
+		public BigInteger getTotal() {
+			return total;
+		}
+		// ------------------
+		// Compute factorial
+		// ------------------
+
+		private BigInteger getFactorial(int n) {
+			BigInteger fact = BigInteger.ONE;
+			for (int i = n; i > 1; i--) {
+				fact = fact.multiply(new BigInteger(Integer.toString(i)));
+			}
+			return fact;
+		}
+		// --------------------------------------------------------
+		// Generate next combination (algorithm from Rosen p. 286)
+		// --------------------------------------------------------
+
+		public int[] getNext() {
+			if (numLeft.equals(total)) {
+				numLeft = numLeft.subtract(BigInteger.ONE);
+				int[] b = new int[a.length];
+				for (int k = 0; k < a.length; k++) {
+					b[k] = a[k];
+				}
+				return b;
+			}
+			int i = r - 1;
+			while (a[i] == n - r + i) {
+				i--;
+			}
+			a[i] = a[i] + 1;
+			for (int j = i + 1; j < r; j++) {
+				a[j] = a[i] + j - i;
+			}
+			numLeft = numLeft.subtract(BigInteger.ONE);
+			int[] b = new int[a.length];
+			for (int k = 0; k < a.length; k++) {
+				b[k] = a[k];
+			}
+			return b;
+		}
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l', "Classifier to train.", Classifier.class,
+			"trees.LimAttHoeffdingTree");
+
+	public IntOption numAttributesOption = new IntOption("numAttributes", 'n',
+			"The number of attributes to use per model.", 1, 1, Integer.MAX_VALUE);
+
+	public FloatOption weightShrinkOption = new FloatOption("weightShrink", 'w',
+			"The number to multiply the weight misclassified counts.", 0.5, 0.0, Float.MAX_VALUE);
+
+	public FloatOption deltaAdwinOption = new FloatOption("deltaAdwin", 'a', "Delta of Adwin change detection", 0.002,
+			0.0, 1.0);
+
+	public FloatOption oddsOffsetOption = new FloatOption("oddsOffset", 'o',
+			"Offset for odds to avoid probabilities that are zero.", 0.001, 0.0, Float.MAX_VALUE);
+
+	public FlagOption pruneOption = new FlagOption("prune", 'x', "Enable pruning.");
+
+	public FlagOption bigTreesOption = new FlagOption("bigTrees", 'b', "Use m-n attributes on the trees.");
+
+	public IntOption numEnsemblePruningOption = new IntOption("numEnsemblePruning", 'm',
+			"The pruned number of classifiers to use to predict.", 10, 1, Integer.MAX_VALUE);
+
+	public FlagOption adwinReplaceWorstClassifierOption = new FlagOption("adwinReplaceWorstClassifier", 'z',
+			"When one Adwin detects change, replace worst classifier.");
+
+	protected Classifier[] ensemble;
+
+	protected ADWIN[] ADError;
+
+	protected int numberOfChangesDetected;
+
+	protected int[][] matrixCodes;
+
+	protected boolean initMatrixCodes = false;
+
+	protected boolean initClassifiers = false;
+
+	protected int numberAttributes = 1;
+
+	protected int numInstances = 0;
+
+	@Override
+	public void resetLearningImpl() {
+		this.initClassifiers = true;
+		this.reset = true;
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		int numClasses = inst.numClasses();
+		// Init Ensemble
+		if (this.initClassifiers == true) {
+			numberAttributes = numAttributesOption.getValue();
+			if (bigTreesOption.isSet()) {
+				numberAttributes = inst.numAttributes() - 1 - numAttributesOption.getValue();
+			}
+			CombinationGenerator x = new CombinationGenerator(inst.numAttributes() - 1, this.numberAttributes);
+			int numberClassifiers = x.getTotal().intValue();
+			this.ensemble = new Classifier[numberClassifiers];
+			Classifier baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
+			baseLearner.resetLearning();
+			for (int i = 0; i < this.ensemble.length; i++) {
+				this.ensemble[i] = (Classifier) baseLearner.copy();
+			}
+			this.ADError = new ADWIN[this.ensemble.length];
+			for (int i = 0; i < this.ensemble.length; i++) {
+				this.ADError[i] = new ADWIN(this.deltaAdwinOption.getValue());
+			}
+			this.numberOfChangesDetected = 0;
+			// Prepare combinations
+			int i = 0;
+			if (baseLearner instanceof LimAttHoeffdingTree) {
+				while (x.hasMore()) {
+					((LimAttHoeffdingTree) this.ensemble[i]).setlistAttributes(x.getNext());
+					i++;
+				}
+			}
+
+			this.initClassifiers = false;
+		}
+
+		boolean Change = false;
+		Instance weightedInst = inst.copy();
+
+		// Train Perceptron
+		double[][] votes = new double[this.ensemble.length + 1][numClasses];
+		for (int i = 0; i < this.ensemble.length; i++) {
+			double[] v = new double[numClasses];
+			for (int j = 0; j < v.length; j++) {
+				v[j] = this.oddsOffsetOption.getValue();
+			}
+			double[] vt = this.ensemble[i].getPredictionForInstance(inst).asDoubleArray();
+			double sum = Utils.sum(vt);
+			if (!Double.isNaN(sum) && (sum > 0)) {
+				for (int j = 0; j < vt.length; j++) {
+					vt[j] /= sum;
+				}
+			} else {
+				// Just in case the base learner returns NaN
+				for (int k = 0; k < vt.length; k++) {
+					vt[k] = 0.0;
+				}
+			}
+			sum = numClasses * this.oddsOffsetOption.getValue();
+			for (int j = 0; j < vt.length; j++) {
+				v[j] += vt[j];
+				sum += vt[j];
+			}
+			for (int j = 0; j < vt.length; j++) {
+				votes[i][j] = Math.log(v[j] / (sum - v[j]));
+			}
+		}
+
+		if (adwinReplaceWorstClassifierOption.isSet() == false) {
+			// Train ensemble of classifiers
+			for (int i = 0; i < this.ensemble.length; i++) {
+				boolean correctlyClassifies = this.ensemble[i].correctlyClassifies(weightedInst);
+				double ErrEstim = this.ADError[i].getEstimation();
+				if (this.ADError[i].setInput(correctlyClassifies ? 0 : 1)) {
+					numInstances = initialNumInstancesOption.getValue();
+					if (this.ADError[i].getEstimation() > ErrEstim) {
+						Change = true;
+						// Replace classifier if ADWIN has detected change
+						numberOfChangesDetected++;
+						this.ensemble[i].resetLearning();
+						this.ADError[i] = new ADWIN(this.deltaAdwinOption.getValue());
+						for (int ii = 0; ii < inst.numClasses(); ii++) {
+							weightAttribute[ii][i] = 0.0;// 0.2 * Math.random() - 0.1;
+						}
+					}
+				}
+			}
+		} else {
+			// Train ensemble of classifiers
+			for (int i = 0; i < this.ensemble.length; i++) {
+				boolean correctlyClassifies = this.ensemble[i].correctlyClassifies(weightedInst);
+				double ErrEstim = this.ADError[i].getEstimation();
+				if (this.ADError[i].setInput(correctlyClassifies ? 0 : 1)) {
+					if (this.ADError[i].getEstimation() > ErrEstim) {
+						Change = true;
+					}
+				}
+			}
+			// Replace classifier with higher error if ADWIN has detected change
+			if (Change) {
+				numberOfChangesDetected++;
+				double max = 0.0;
+				int imax = -1;
+				for (int i = 0; i < this.ensemble.length; i++) {
+					if (max < this.ADError[i].getEstimation()) {
+						max = this.ADError[i].getEstimation();
+						imax = i;
+					}
+				}
+				if (imax != -1) {
+					this.ensemble[imax].resetLearning();
+					this.ADError[imax] = new ADWIN(this.deltaAdwinOption.getValue());
+					for (int ii = 0; ii < inst.numClasses(); ii++) {
+						weightAttribute[ii][imax] = 0.0;
+					}
+				}
+			}
+		}
+
+		trainOnInstanceImplPerceptron(inst.numClasses(), (int) inst.classValue(), votes);
+
+		for (int i = 0; i < this.ensemble.length; i++) {
+			this.ensemble[i].trainOnInstance(inst);
+		}
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		if (this.initClassifiers == true) {
+			return new ClassificationPrediction();
+		}
+		int numClasses = inst.numClasses();
+
+		int sizeEnsemble = this.ensemble.length;
+		if (pruneOption.isSet()) {
+			sizeEnsemble = this.numEnsemblePruningOption.getValue();
+		}
+
+		double[][] votes = new double[sizeEnsemble + 1][numClasses];
+		int[] bestClassifiers = new int[sizeEnsemble];
+		if (pruneOption.isSet()) {
+			// Check for the best classifiers
+			double[] weight = new double[this.ensemble.length];
+			for (int i = 0; i < numClasses; i++) {
+				for (int j = 0; j < this.ensemble.length; j++) {
+					weight[j] += weightAttribute[i][j];
+				}
+			}
+			Arrays.sort(weight);
+			double cutValue = weight[this.ensemble.length - sizeEnsemble]; // reverse order
+			int ii = 0;
+			for (int j = 0; j < this.ensemble.length; j++) {
+				if (weight[j] >= cutValue && ii < sizeEnsemble) {
+					bestClassifiers[ii] = j;
+					ii++;
+				}
+			}
+		} else { // Not pruning: all classifiers
+			for (int ii = 0; ii < sizeEnsemble; ii++) {
+				bestClassifiers[ii] = ii;
+			}
+		}
+		for (int ii = 0; ii < sizeEnsemble; ii++) {
+			int i = bestClassifiers[ii];
+			double[] v = new double[numClasses];
+			for (int j = 0; j < v.length; j++) {
+				v[j] = this.oddsOffsetOption.getValue();
+			}
+			double[] vt = this.ensemble[i].getPredictionForInstance(inst).asDoubleArray();
+			double sum = Utils.sum(vt);
+			if (!Double.isNaN(sum) && (sum > 0)) {
+				for (int j = 0; j < vt.length; j++) {
+					vt[j] /= sum;
+				}
+			} else {
+				// Just in case the base learner returns NaN
+				for (int k = 0; k < vt.length; k++) {
+					vt[k] = 0.0;
+				}
+			}
+			sum = numClasses * this.oddsOffsetOption.getValue();
+			for (int j = 0; j < vt.length; j++) {
+				v[j] += vt[j];
+				sum += vt[j];
+			}
+			for (int j = 0; j < vt.length; j++) {
+				votes[ii][j] = Math.log(v[j] / (sum - v[j]));
+				// votes[i][j] = vt[j];
+			}
+		}
+		return getPredictionForInstancePerceptron(votes, bestClassifiers, inst.numClasses());
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[] { new Measurement("ensemble size", this.ensemble != null ? this.ensemble.length : 0),
+				new Measurement("change detections", this.numberOfChangesDetected) };
+	}
+
+	@Override
+	public Classifier[] getSubClassifiers() {
+		return this.ensemble.clone();
+	}
+
+	// Perceptron
+	public FloatOption learningRatioOption = new FloatOption("learningRatio", 't', "Learning ratio", 1);
+
+	public FloatOption penaltyFactorOption = new FloatOption("lambda", 'p', "Lambda", 0.0);
+
+	public IntOption initialNumInstancesOption = new IntOption("initialNumInstances", 'i', "initialNumInstances", 10);
+
+	protected double[][] weightAttribute;
+
+	protected boolean reset;
+
+	public void trainOnInstanceImplPerceptron(int numClasses, int actualClass, double[][] votes) {
+
+		// Init Perceptron
+		if (this.reset == true) {
+			this.reset = false;
+			this.weightAttribute = new double[numClasses][votes.length];
+			for (int i = 0; i < numClasses; i++) {
+				for (int j = 0; j < votes.length - 1; j++) {
+					weightAttribute[i][j] = 1.0 / (votes.length - 1.0);
+				}
+			}
+			numInstances = initialNumInstancesOption.getValue();
+		}
+
+		// Weight decay
+		double learningRatio = learningRatioOption.getValue() * 2.0 / (numInstances + (votes.length - 1) + 2.0);
+		double lambda = penaltyFactorOption.getValue();
+		numInstances++;
+
+		double[] preds = new double[numClasses];
+
+		for (int i = 0; i < numClasses; i++) {
+			preds[i] = prediction(votes, i);
+		}
+		for (int i = 0; i < numClasses; i++) {
+			double actual = (i == actualClass) ? 1.0 : 0.0;
+			double delta = (actual - preds[i]) * preds[i] * (1 - preds[i]);
+			for (int j = 0; j < this.ensemble.length; j++) {
+				this.weightAttribute[i][j] += learningRatio
+						* (delta * votes[j][i] - lambda * this.weightAttribute[i][j]);
+			}
+			this.weightAttribute[i][this.ensemble.length] += learningRatio * delta;
+		}
+	}
+
+	public double predictionPruning(double[][] votes, int[] bestClassifiers, int classVal) {
+		double sum = 0.0;
+		for (int i = 0; i < votes.length - 1; i++) {
+			sum += weightAttribute[classVal][bestClassifiers[i]] * votes[i][classVal];
+		}
+		sum += weightAttribute[classVal][votes.length - 1];
+		return 1.0 / (1.0 + Math.exp(-sum));
+	}
+
+	public double prediction(double[][] votes, int classVal) {
+		double sum = 0.0;
+		for (int i = 0; i < votes.length - 1; i++) {
+			sum += weightAttribute[classVal][i] * votes[i][classVal];
+		}
+		sum += weightAttribute[classVal][votes.length - 1];
+		return 1.0 / (1.0 + Math.exp(-sum));
+	}
+
+	public Prediction getPredictionForInstancePerceptron(double[][] votesEnsemble, int[] bestClassifiers,
+			int numClasses) {
+		double[] votes = new double[numClasses];
+		if (this.reset == false) {
+			for (int i = 0; i < votes.length; i++) {
+				votes[i] = predictionPruning(votesEnsemble, bestClassifiers, i);
+			}
+		}
+		return new ClassificationPrediction(votes);
+
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/meta/OCBoost.java b/moa/src/main/java/moa/learners/predictors/meta/OCBoost.java
new file mode 100644
index 000000000..6dff97603
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/meta/OCBoost.java
@@ -0,0 +1,200 @@
+/*
+ *    OCBoost.java
+ *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.meta;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Measurement;
+import moa.core.Utils;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.options.ClassOption;
+
+/**
+ * Online Coordinate boosting for two classes evolving data streams.
+ *
+ * <p>
+ * Pelossof et al. presented Online Coordinate Boosting, a new online boosting
+ * algorithm for adapting the weights of a boosted classifier, which yields a
+ * closer approximation to Freund and Schapire’s AdaBoost algorithm. The weight
+ * update procedure is derived by minimizing AdaBoost’s loss when viewed in an
+ * incremental form. This boosting method may be reduced to a form similar to
+ * Oza and Russell’s algorithm.
+ * </p>
+ *
+ * <p>
+ * See details in:<br />
+ * Raphael Pelossof, Michael Jones, Ilia Vovsha, and Cynthia Rudin. Online
+ * coordinate boosting. 2008.
+ * </p>
+ * <p>
+ * Example:
+ * </p>
+ * <code>OCBoost -l HoeffdingTreeNBAdaptive -e 0.5</code>
+ * <p>
+ * Parameters:
+ * </p>
+ * <ul>
+ * <li>-l : Classifier to train</li>
+ * <li>-s : The number of models to boost</li>
+ * <li>-e : Smoothing parameter</li>
+ * </ul>
+ *
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @version $Revision: 7 $
+ */
+
+public class OCBoost extends AbstractClassifier implements Classifier {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Online Coordinate boosting for two classes evolving data streams.";
+	}
+
+	public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l', "Classifier to train.", Classifier.class,
+			"trees.HoeffdingTree");
+
+	public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's', "The number of models to boost.", 10, 1,
+			Integer.MAX_VALUE);
+
+	public FloatOption smoothingOption = new FloatOption("smoothingParameter", 'e', "Smoothing parameter.", 0.5, 0.0,
+			100.0);
+
+	protected Classifier[] ensemble;
+
+	protected double[] alpha;
+
+	protected double[] alphainc;
+
+	protected double[] pipos;
+
+	protected double[] pineg;
+
+	protected double[][] wpos;
+
+	protected double[][] wneg;
+
+	@Override
+	public void resetLearningImpl() {
+		this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
+		this.alpha = new double[this.ensemble.length];
+		this.alphainc = new double[this.ensemble.length];
+		this.pipos = new double[this.ensemble.length];
+		this.pineg = new double[this.ensemble.length];
+		this.wpos = new double[this.ensemble.length][this.ensemble.length];
+		this.wneg = new double[this.ensemble.length][this.ensemble.length];
+
+		Classifier baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
+		baseLearner.resetLearning();
+		for (int i = 0; i < this.ensemble.length; i++) {
+			this.ensemble[i] = (Classifier) baseLearner.copy();
+			alpha[i] = 0.0;
+			alphainc[i] = 0.0;
+			for (int j = 0; j < this.ensemble.length; j++) {
+				wpos[i][j] = this.smoothingOption.getValue();
+				wneg[i][j] = this.smoothingOption.getValue();
+			}
+		}
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		double d = 1.0;
+		int[] m = new int[this.ensemble.length];
+		for (int j = 0; j < this.ensemble.length; j++) {
+			int j0 = 0; // max(0,j-K)
+			pipos[j] = 1.0;
+			pineg[j] = 1.0;
+			m[j] = -1;
+			if (this.ensemble[j].correctlyClassifies(inst) == true) {
+				m[j] = 1;
+			}
+			for (int k = j0; k <= j - 1; k++) {
+				pipos[j] *= wpos[j][k] / wpos[j][j] * Math.exp(-alphainc[k])
+						+ (1.0 - wpos[j][k] / wpos[j][j]) * Math.exp(alphainc[k]);
+				pineg[j] *= wneg[j][k] / wneg[j][j] * Math.exp(-alphainc[k])
+						+ (1.0 - wneg[j][k] / wneg[j][j]) * Math.exp(alphainc[k]);
+			}
+			for (int k = 0; k <= j; k++) {
+				wpos[j][k] = wpos[j][k] * pipos[j] + d * (m[k] == 1 ? 1 : 0) * (m[j] == 1 ? 1 : 0);
+				wneg[j][k] = wneg[j][k] * pineg[j] + d * (m[k] == -1 ? 1 : 0) * (m[j] == -1 ? 1 : 0);
+			}
+			alphainc[j] = -alpha[j];
+			alpha[j] = 0.5 * Math.log(wpos[j][j] / wneg[j][j]);
+			alphainc[j] += alpha[j];
+
+			d = d * Math.exp(-alpha[j] * m[j]);
+
+			if (d > 0.0) {
+				Instance weightedInst = inst.copy();
+				weightedInst.setWeight(inst.weight() * d);
+				this.ensemble[j].trainOnInstance(weightedInst);
+			}
+		}
+	}
+
+	protected double getEnsembleMemberWeight(int i) {
+		return alpha[i];
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		double[] output = new double[2];
+		int vote;
+		double combinedVote = 0.0;
+		for (int i = 0; i < this.ensemble.length; i++) {
+			vote = Utils.maxIndex(this.ensemble[i].getPredictionForInstance(inst));
+			if (vote == 0) {
+				vote = -1;
+			}
+			combinedVote += vote * getEnsembleMemberWeight(i);
+		}
+		output[0] = 0;
+		output[1] = 0;
+		output[combinedVote > 0 ? 1 : 0] = 1;
+		return new ClassificationPrediction(output);
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[] { new Measurement("ensemble size", this.ensemble != null ? this.ensemble.length : 0) };
+	}
+
+	@Override
+	public Classifier[] getSubClassifiers() {
+		return this.ensemble.clone();
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/meta/OnlineAccuracyUpdatedEnsemble.java b/moa/src/main/java/moa/learners/predictors/meta/OnlineAccuracyUpdatedEnsemble.java
similarity index 61%
rename from moa/src/main/java/moa/classifiers/meta/OnlineAccuracyUpdatedEnsemble.java
rename to moa/src/main/java/moa/learners/predictors/meta/OnlineAccuracyUpdatedEnsemble.java
index 7ab452775..ad5f3a6f3 100644
--- a/moa/src/main/java/moa/classifiers/meta/OnlineAccuracyUpdatedEnsemble.java
+++ b/moa/src/main/java/moa/learners/predictors/meta/OnlineAccuracyUpdatedEnsemble.java
@@ -15,9 +15,9 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.classifiers.meta;
+package moa.learners.predictors.meta;
 
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
@@ -26,19 +26,19 @@
 import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.trees.HoeffdingTree;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
-import moa.learners.Classifier;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.trees.HoeffdingTree;
 import moa.options.ClassOption;
 import moa.tasks.TaskMonitor;
 
 /**
- * The online version of the Accuracy Updated Ensemble as proposed by
- * Brzezinski and Stefanowski in "Combining block-based and online methods 
- * in learning ensembles from concept drifting data streams", Information Sciences, 2014.
+ * The online version of the Accuracy Updated Ensemble as proposed by Brzezinski
+ * and Stefanowski in "Combining block-based and online methods in learning
+ * ensembles from concept drifting data streams", Information Sciences, 2014.
  */
 public class OnlineAccuracyUpdatedEnsemble extends AbstractClassifier implements Classifier {
 
@@ -47,8 +47,8 @@ public class OnlineAccuracyUpdatedEnsemble extends AbstractClassifier implements
 	/**
 	 * Type of classifier to use as a component classifier.
 	 */
-	public ClassOption learnerOption = new ClassOption("learner", 'l', "Classifier to train.", Classifier.class, 
-			"moa.classifiers.trees.HoeffdingTree -e 2000000 -g 100 -c 0.01");
+	public ClassOption learnerOption = new ClassOption("learner", 'l', "Classifier to train.", Classifier.class,
+			"trees.HoeffdingTree -e 2000000 -g 100 -c 0.01");
 
 	/**
 	 * Number of component classifiers.
@@ -67,64 +67,66 @@ public class OnlineAccuracyUpdatedEnsemble extends AbstractClassifier implements
 	 */
 	public IntOption maxByteSizeOption = new IntOption("maxByteSize", 'm', "Maximum memory consumed by ensemble.",
 			33554432, 0, Integer.MAX_VALUE);
-	
+
 	/**
 	 * Determines whether additional information should be sent to the output.
 	 */
-	public FlagOption verboseOption = new FlagOption("verbose", 'v', "When checked the algorithm outputs additional information about component classifier weights.");
-	
+	public FlagOption verboseOption = new FlagOption("verbose", 'v',
+			"When checked the algorithm outputs additional information about component classifier weights.");
+
 	/**
 	 * Determines whether additional information should be sent to the output.
 	 */
-	public FlagOption linearOption = new FlagOption("linearFunction", 'f', "When checked the algorithm uses a linear weighting function.");
+	public FlagOption linearOption = new FlagOption("linearFunction", 'f',
+			"When checked the algorithm uses a linear weighting function.");
 
-	
 	/**
-	 * The weights of stored classifiers. 
-	 * weights[x][0] = weight
-	 * weights[x][1] = classifier number in learners
+	 * The weights of stored classifiers. weights[x][0] = weight weights[x][1] =
+	 * classifier number in learners
 	 */
 	protected double[][] weights;
-	
+
 	/**
 	 * Class distributions.
 	 */
 	protected long[] classDistributions;
-	
+
 	/**
 	 * Ensemble classifiers.
 	 */
 	protected ClassifierWithMemory[] ensemble;
-	
+
 	/**
 	 * Number of processed examples.
 	 */
 	protected int processedInstances;
-	
+
 	/**
 	 * Candidate classifier.
 	 */
 	protected ClassifierWithMemory candidate;
-	
+
 	/**
 	 * Current window of instance class values.
 	 */
 	protected int[] currentWindow;
-	
+
 	/**
-	 * The mean square residual in a given moment, based on a window of latest examples.
+	 * The mean square residual in a given moment, based on a window of latest
+	 * examples.
 	 */
 	protected double mse_r = 0;
-	
+
 	/**
 	 * Window size.
 	 */
 	protected int windowSize = 0;
-	
+
 	@Override
 	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-		this.windowSize = (int)this.windowSizeOption.getValue();
-		this.candidate = new ClassifierWithMemory((Classifier) ((Classifier) getPreparedClassOption(this.learnerOption)).copy(), this.windowSize);
+		this.windowSize = (int) this.windowSizeOption.getValue();
+		this.candidate = new ClassifierWithMemory(
+				(Classifier) ((Classifier) getPreparedClassOption(this.learnerOption)).copy(), this.windowSize);
 		this.candidate.classifier.resetLearning();
 
 		super.prepareForUseImpl(monitor, repository);
@@ -133,51 +135,50 @@ public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository)
 	@Override
 	public void resetLearningImpl() {
 		this.currentWindow = null;
-		this.windowSize = (int)this.windowSizeOption.getValue();
+		this.windowSize = (int) this.windowSizeOption.getValue();
 		this.classDistributions = null;
 		this.processedInstances = 0;
 		this.ensemble = new ClassifierWithMemory[0];
 
-		this.candidate = new ClassifierWithMemory((Classifier) ((Classifier) getPreparedClassOption(this.learnerOption)).copy(), this.windowSize);
+		this.candidate = new ClassifierWithMemory(
+				(Classifier) ((Classifier) getPreparedClassOption(this.learnerOption)).copy(), this.windowSize);
 		this.candidate.classifier.resetLearning();
 	}
 
 	@Override
 	public void trainOnInstanceImpl(Instance inst) {
 		this.initVariables();
-    	
-    	if(this.processedInstances < this.windowSize)
-        {
-    		this.classDistributions[(int) inst.classValue()]++;			
-        }
-    	else
-        {  		
-    		this.classDistributions[this.currentWindow[processedInstances % this.windowSize]]--;
-    		this.classDistributions[(int) inst.classValue()]++;
-        }
-    	
-    	this.currentWindow[processedInstances % this.windowSize] = (int)inst.classValue();		 	
-    	this.processedInstances++;
-    	this.computeMseR();
-    	
-        if (this.processedInstances % this.windowSize == 0) {
-            this.createNewClassifier(inst);
-        } else {
-        	this.candidate.classifier.trainOnInstance(inst);
-        	
-        	for (int i = 0; i < this.ensemble.length; i++) {
-        		this.weights[i][0] = this.computeWeight(i, inst);
-            }
-        }
-        	
-    	for (int i = 0; i < this.ensemble.length; i++) {
+
+		if (this.processedInstances < this.windowSize) {
+			this.classDistributions[(int) inst.classValue()]++;
+		} else {
+			this.classDistributions[this.currentWindow[processedInstances % this.windowSize]]--;
+			this.classDistributions[(int) inst.classValue()]++;
+		}
+
+		this.currentWindow[processedInstances % this.windowSize] = (int) inst.classValue();
+		this.processedInstances++;
+		this.computeMseR();
+
+		if (this.processedInstances % this.windowSize == 0) {
+			this.createNewClassifier(inst);
+		} else {
+			this.candidate.classifier.trainOnInstance(inst);
+
+			for (int i = 0; i < this.ensemble.length; i++) {
+				this.weights[i][0] = this.computeWeight(i, inst);
+			}
+		}
+
+		for (int i = 0; i < this.ensemble.length; i++) {
 			this.ensemble[i].classifier.trainOnInstance(inst);
-        }
+		}
 	}
 
 	/**
 	 * Determines whether the classifier is randomizable.
 	 */
+	@Override
 	public boolean isRandomizable() {
 		return false;
 	}
@@ -185,13 +186,15 @@ public boolean isRandomizable() {
 	/**
 	 * Predicts a class for an example.
 	 */
+	@Override
 	public Prediction getPredictionForInstance(Instance inst) {
 		DoubleVector combinedVote = new DoubleVector();
 
 		if (this.trainingWeightSeenByModel > 0.0) {
 			for (int i = 0; i < this.ensemble.length; i++) {
 				if (this.weights[i][0] > 0.0) {
-					DoubleVector vote = this.ensemble[(int) this.weights[i][1]].classifier.getPredictionForInstance(inst).asDoubleVector();
+					DoubleVector vote = this.ensemble[(int) this.weights[i][1]].classifier
+							.getPredictionForInstance(inst).asDoubleVector();
 
 					if (vote.sumOfValues() > 0.0) {
 						vote.normalize();
@@ -202,8 +205,8 @@ public Prediction getPredictionForInstance(Instance inst) {
 				}
 			}
 		}
-		
-		//combinedVote.normalize();
+
+		// combinedVote.normalize();
 		return new ClassificationPrediction(combinedVote.getArrayRef());
 	}
 
@@ -211,40 +214,40 @@ public Prediction getPredictionForInstance(Instance inst) {
 	public void getModelDescription(StringBuilder out, int indent) {
 	}
 
+	@Override
 	public Classifier[] getSubClassifiers() {
 		Classifier[] subClassifiers = new Classifier[this.ensemble.length];
-		
+
 		for (int i = 0; i < this.ensemble.length; i++) {
 			subClassifiers[i] = this.ensemble[i].classifier;
 		}
-		
+
 		return subClassifiers;
 	}
 
 	/**
-     * Processes a chunk.
-     *
-     * @param inst New example
-     */
-    protected void createNewClassifier(Instance inst) {
-        // Compute weights
-    	double candidateClassifierWeight = 1.0 / (this.mse_r + Double.MIN_VALUE);
-    	
-    	if(linearOption.isSet())
-        {
-    		candidateClassifierWeight = java.lang.Math.max(this.mse_r, Double.MIN_VALUE);
-        }
-    	
-    	for (int i = 0; i < this.ensemble.length; i++) {
+	 * Processes a chunk.
+	 *
+	 * @param inst New example
+	 */
+	protected void createNewClassifier(Instance inst) {
+		// Compute weights
+		double candidateClassifierWeight = 1.0 / (this.mse_r + Double.MIN_VALUE);
+
+		if (linearOption.isSet()) {
+			candidateClassifierWeight = java.lang.Math.max(this.mse_r, Double.MIN_VALUE);
+		}
+
+		for (int i = 0; i < this.ensemble.length; i++) {
 			this.weights[i][0] = this.computeWeight(i, inst);
-		}	
-    	
-    	// Configure candidate classifier
-    	// The candidate classifier has been trained on the last window of examples
-    	this.candidate.birthday = this.processedInstances;
-    	
-    	if (this.ensemble.length < this.memberCountOption.getValue()) {
-			// Add candidate classifier		
+		}
+
+		// Configure candidate classifier
+		// The candidate classifier has been trained on the last window of examples
+		this.candidate.birthday = this.processedInstances;
+
+		if (this.ensemble.length < this.memberCountOption.getValue()) {
+			// Add candidate classifier
 			this.addToStored(this.candidate, candidateClassifierWeight);
 		} else {
 			// Substitute poorest classifier
@@ -257,28 +260,30 @@ protected void createNewClassifier(Instance inst) {
 			}
 		}
 
-    	this.candidate = new ClassifierWithMemory((Classifier) ((Classifier) getPreparedClassOption(this.learnerOption)).copy(), this.windowSize);
+		this.candidate = new ClassifierWithMemory(
+				(Classifier) ((Classifier) getPreparedClassOption(this.learnerOption)).copy(), this.windowSize);
 		this.candidate.classifier.resetLearning();
-		
+
 		this.enforceMemoryLimit();
-    }
-	
+	}
+
 	/**
-	 * Checks if the memory limit is exceeded and if so prunes the classifiers in the ensemble.
+	 * Checks if the memory limit is exceeded and if so prunes the classifiers in
+	 * the ensemble.
 	 */
 	protected void enforceMemoryLimit() {
 		double memoryLimit = this.maxByteSizeOption.getValue() / (double) (this.ensemble.length + 1);
 
 		for (int i = 0; i < this.ensemble.length; i++) {
-			((HoeffdingTree) this.ensemble[(int) this.weights[i][1]].classifier).maxByteSizeOption.setValue((int) Math
-					.round(memoryLimit));
+			((HoeffdingTree) this.ensemble[(int) this.weights[i][1]].classifier).maxByteSizeOption
+					.setValue((int) Math.round(memoryLimit));
 			((HoeffdingTree) this.ensemble[(int) this.weights[i][1]].classifier).enforceTrackerLimit();
 		}
 	}
 
 	/**
 	 * Computes the MSEr threshold.
-	 * 
+	 *
 	 * @return The MSEr threshold.
 	 */
 	protected void computeMseR() {
@@ -290,96 +295,86 @@ protected void computeMseR() {
 			this.mse_r += p_c * ((1 - p_c) * (1 - p_c));
 		}
 	}
-	
+
 	/**
 	 * Computes the weight of a learner before training a given example.
-	 * @param i the identifier (in terms of array learners) 
-	 * of the classifier for which the weight is supposed to be computed
+	 * 
+	 * @param i       the identifier (in terms of array learners) of the classifier
+	 *                for which the weight is supposed to be computed
 	 * @param example the newest example
 	 * @return the computed weight.
-	 */	
-    protected double computeWeight(int i, Instance example) {
-    	
-    	int d = this.windowSize;
-    	int t = this.processedInstances - this.ensemble[i].birthday;
-
-        double e_it = 0;
-        double mse_it = 0;
-        double voteSum = 0;
-        
-        try{
-	        double[] votes = this.ensemble[i].classifier.getPredictionForInstance(example).asDoubleArray();
-	        
-	        for (double element : votes) {
-	            voteSum += element;
-	        }
-	        
-	        if (voteSum > 0) {
-		        double f_it = 1 - (votes[(int) example.classValue()] / voteSum);
-		        e_it = f_it * f_it;
-	        } else {
-	        	e_it = 1;
-	        }
+	 */
+	protected double computeWeight(int i, Instance example) {
+
+		int d = this.windowSize;
+		int t = this.processedInstances - this.ensemble[i].birthday;
+
+		double e_it = 0;
+		double mse_it = 0;
+		double voteSum = 0;
+
+		try {
+			double[] votes = this.ensemble[i].classifier.getPredictionForInstance(example).asDoubleArray();
+
+			for (double element : votes) {
+				voteSum += element;
+			}
+
+			if (voteSum > 0) {
+				double f_it = 1 - (votes[(int) example.classValue()] / voteSum);
+				e_it = f_it * f_it;
+			} else {
+				e_it = 1;
+			}
 		} catch (Exception e) {
 			e_it = 1;
 		}
-        
-        if(t > d)
-        {
-        	mse_it = this.ensemble[i].mse_it + e_it/(double)d - this.ensemble[i].squareErrors[t % d]/(double)d;
-        }
-        else
-        {
-        	mse_it = this.ensemble[i].mse_it*(t-1)/t + e_it/(double)t;
-        }
-
-        this.ensemble[i].squareErrors[t % d] = e_it;
-        this.ensemble[i].mse_it = mse_it;
-        
-        if(linearOption.isSet())
-        {
-        	return java.lang.Math.max(mse_r - mse_it, Double.MIN_VALUE);
-        }
-        else
-        {
-        	return 1.0 / (this.mse_r + mse_it + Double.MIN_VALUE);
-        }
-    }
-	
+
+		if (t > d) {
+			mse_it = this.ensemble[i].mse_it + e_it / d - this.ensemble[i].squareErrors[t % d] / d;
+		} else {
+			mse_it = this.ensemble[i].mse_it * (t - 1) / t + e_it / t;
+		}
+
+		this.ensemble[i].squareErrors[t % d] = e_it;
+		this.ensemble[i].mse_it = mse_it;
+
+		if (linearOption.isSet()) {
+			return java.lang.Math.max(mse_r - mse_it, Double.MIN_VALUE);
+		} else {
+			return 1.0 / (this.mse_r + mse_it + Double.MIN_VALUE);
+		}
+	}
+
 	/**
 	 * Adds ensemble weights to the measurements.
 	 */
 	@Override
 	protected Measurement[] getModelMeasurementsImpl() {
-		if(this.verboseOption.isSet())
-		{
-			Measurement[] measurements = new Measurement[(int) this.memberCountOption.getValue()];
-	
+		if (this.verboseOption.isSet()) {
+			Measurement[] measurements = new Measurement[this.memberCountOption.getValue()];
+
 			for (int m = 0; m < this.memberCountOption.getValue(); m++) {
 				measurements[m] = new Measurement("Member weight " + (m + 1), -1);
 			}
-	
+
 			if (this.weights != null) {
 				for (int i = 0; i < this.weights.length; i++) {
 					measurements[i] = new Measurement("Member weight " + (i + 1), this.weights[i][0]);
 				}
 			}
-	
+
 			return measurements;
-		}
-		else
-		{
+		} else {
 			return null;
 		}
 	}
 
 	/**
 	 * Adds a classifier to the storage.
-	 * 
-	 * @param newClassifier
-	 *            The classifier to add.
-	 * @param newClassifiersWeight
-	 *            The new classifiers weight.
+	 *
+	 * @param newClassifier        The classifier to add.
+	 * @param newClassifiersWeight The new classifiers weight.
 	 */
 	protected void addToStored(ClassifierWithMemory newClassifier, double newClassifiersWeight) {
 		ClassifierWithMemory[] newStored = new ClassifierWithMemory[this.ensemble.length + 1];
@@ -399,23 +394,24 @@ protected void addToStored(ClassifierWithMemory newClassifier, double newClassif
 		this.ensemble = newStored;
 		this.weights = newStoredWeights;
 	}
-	
+
 	/**
 	 * Finds the index of the classifier with the smallest weight.
+	 * 
 	 * @return
 	 */
 	private int getPoorestClassifierIndex() {
 		int minIndex = 0;
-		
+
 		for (int i = 1; i < this.weights.length; i++) {
-			if(this.weights[i][0] < this.weights[minIndex][0]){
+			if (this.weights[i][0] < this.weights[minIndex][0]) {
 				minIndex = i;
 			}
 		}
-		
+
 		return minIndex;
 	}
-	
+
 	/**
 	 * Initiates the current chunk and class distribution variables.
 	 */
@@ -428,16 +424,14 @@ private void initVariables() {
 			this.classDistributions = new long[this.getModelContext().classAttribute().numValues()];
 		}
 	}
-	
-	protected class ClassifierWithMemory
-	{
+
+	protected class ClassifierWithMemory {
 		private Classifier classifier;
 		private int birthday;
 		private double[] squareErrors;
 		private double mse_it;
-			
-		protected ClassifierWithMemory(Classifier classifier, int windowSize)
-		{
+
+		protected ClassifierWithMemory(Classifier classifier, int windowSize) {
 			this.classifier = classifier;
 			this.squareErrors = new double[windowSize];
 			this.mse_it = 0;
diff --git a/moa/src/main/java/moa/learners/predictors/meta/OnlineSmoothBoost.java b/moa/src/main/java/moa/learners/predictors/meta/OnlineSmoothBoost.java
new file mode 100644
index 000000000..9e6954d8a
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/meta/OnlineSmoothBoost.java
@@ -0,0 +1,153 @@
+/*
+ *    OnlineSmoothBoost.java
+ *    Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.meta;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.options.ClassOption;
+
+/**
+ * Incremental on-line boosting with Theoretical Justifications of Shang-Tse
+ * Chen, Hsuan-Tien Lin and Chi-Jen Lu.
+ *
+ * <p>
+ * See details in:<br />
+ * </p>
+ *
+ * <p>
+ * Parameters:
+ * </p>
+ * <ul>
+ * <li>-l : Classifier to train</li>
+ * <li>-s : The number of models to boost</li>
+ * </ul>
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public class OnlineSmoothBoost extends AbstractClassifier implements Classifier {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Incremental on-line boosting of Shang-Tse Chen, Hsuan-Tien Lin and Chi-Jen Lu.";
+	}
+
+	public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l', "Classifier to train.", Classifier.class,
+			"trees.HoeffdingTree");
+
+	public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's', "The number of models to boost.", 10, 1,
+			Integer.MAX_VALUE);
+
+	// public FlagOption pureBoostOption = new FlagOption("pureBoost", 'p',
+	// "Boost with weights only; no poisson.");
+
+	public FloatOption gammaOption = new FloatOption("gamma", 'g', "The value of the gamma parameter.", 0.1, 0.0, 1.0);
+
+	protected Classifier[] ensemble;
+
+	protected double[] alpha;
+
+	protected double gamma;
+
+	protected double theta;
+
+	@Override
+	public void resetLearningImpl() {
+		this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
+		Classifier baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
+		baseLearner.resetLearning();
+		this.alpha = new double[this.ensemble.length];
+		for (int i = 0; i < this.ensemble.length; i++) {
+			this.ensemble[i] = (Classifier) baseLearner.copy();
+			this.alpha[i] = 1.0 / this.ensemble.length;
+		}
+		this.gamma = this.gammaOption.getValue();
+		this.theta = this.gamma / (2.0 + this.gamma);
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		double zt = 0.0;
+		double weight = 1.0;
+		for (int i = 0; i < this.ensemble.length; i++) {
+			zt += (this.ensemble[i].correctlyClassifies(inst) ? 1 : -1) - theta;
+			// normalized_predict(ex.x) * ex.y - theta;
+			Instance weightedInst = inst.copy();
+			weightedInst.setWeight(weight);
+			this.ensemble[i].trainOnInstance(weightedInst);
+			weight = (zt <= 0) ? 1.0 : Math.pow(1.0 - gamma, zt / 2.0);
+		}
+
+	}
+
+	protected double getEnsembleMemberWeight(int i) {
+		return this.alpha[i];
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+
+		DoubleVector combinedVote = new DoubleVector();
+		for (int i = 0; i < this.ensemble.length; i++) {
+			double memberWeight = getEnsembleMemberWeight(i);
+			if (memberWeight > 0.0) {
+				DoubleVector vote = this.ensemble[i].getPredictionForInstance(inst).asDoubleVector();
+				if (vote.sumOfValues() > 0.0) {
+					vote.normalize();
+					vote.scaleValues(memberWeight);
+					combinedVote.addValues(vote);
+				}
+			} else {
+				break;
+			}
+		}
+		return new ClassificationPrediction(combinedVote.getArrayRef());
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[] { new Measurement("ensemble size", this.ensemble != null ? this.ensemble.length : 0) };
+	}
+
+	@Override
+	public Classifier[] getSubClassifiers() {
+		return this.ensemble.clone();
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/meta/OzaBagASHT.java b/moa/src/main/java/moa/learners/predictors/meta/OzaBagASHT.java
new file mode 100644
index 000000000..e50f9dda4
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/meta/OzaBagASHT.java
@@ -0,0 +1,192 @@
+/*
+ *    OzaBagASHT.java
+ *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.meta;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.MiscUtils;
+import moa.core.Utils;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.trees.ASHoeffdingTree;
+import moa.options.ClassOption;
+
+/**
+ * Bagging using trees of different size. The Adaptive-Size Hoeffding Tree
+ * (ASHT) is derived from the Hoeffding Tree algorithm with the following
+ * differences:
+ * <ul>
+ * <li>it has a maximum number of split nodes, or size
+ * <li>after one node splits, if the number of split nodes of the ASHT tree is
+ * higher than the maximum value, then it deletes some nodes to reduce its size
+ * </ul>
+ * The intuition behind this method is as follows: smaller trees adapt more
+ * quickly to changes, and larger trees do better during periods with no or
+ * little change, simply because they were built on more data. Trees limited to
+ * size s will be reset about twice as often as trees with a size limit of 2s.
+ * This creates a set of different reset-speeds for an ensemble of such trees,
+ * and therefore a subset of trees that are a good approximation for the current
+ * rate of change. It is important to note that resets will happen all the time,
+ * even for stationary datasets, but this behaviour should not have a negative
+ * impact on the ensemble’s predictive performance. When the tree size exceeds
+ * the maximun size value, there are two different delete options:
+ * <ul>
+ * <li>delete the oldest node, the root, and all of its children except the one
+ * where the split has been made. After that, the root of the child not deleted
+ * becomes the new root
+ * <li>delete all the nodes of the tree, i.e., restart from a new root.
+ * </ul>
+ * The maximum allowed size for the n-th ASHT tree is twice the maximum allowed
+ * size for the (n-1)-th tree. Moreover, each tree has a weight proportional to
+ * the inverse of the square of its error, and it monitors its error with an
+ * exponential weighted moving average (EWMA) with alpha = .01. The size of the
+ * first tree is 2. <br/>
+ * <br/>
+ * With this new method, it is attempted to improve bagging performance by
+ * increasing tree diversity. It has been observed that boosting tends to
+ * produce a more diverse set of classifiers than bagging, and this has been
+ * cited as a factor in increased performance.<br/>
+ * See more details in:<br/>
+ * <br/>
+ * Albert Bifet, Geoff Holmes, Bernhard Pfahringer, Richard Kirkby, and Ricard
+ * Gavaldà. New ensemble methods for evolving data streams. In 15th ACM SIGKDD
+ * International Conference on Knowledge Discovery and Data Mining, 2009.<br/>
+ * <br/>
+ * The learner must be ASHoeffdingTree, a Hoeffding Tree with a maximum size
+ * value.<br/>
+ * <br/>
+ * Example:<br/>
+ * <br/>
+ * <code>OzaBagASHT -l ASHoeffdingTree -s 10 -u -r </code> Parameters:
+ * <ul>
+ * <li>Same parameters as <code>OzaBag</code>
+ * <li>-f : the size of first classifier in the bag.
+ * <li>-u : Enable weight classifiers
+ * <li>-e : Reset trees when size is higher than the max
+ * </ul>
+ *
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @version $Revision: 7 $
+ */
+public class OzaBagASHT extends AbstractClassifier implements Classifier {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Bagging using trees of different size.";
+	}
+
+	public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's', "The number of models in the bag.", 10, 1,
+			Integer.MAX_VALUE);
+
+	public IntOption firstClassifierSizeOption = new IntOption("firstClassifierSize", 'f',
+			"The size of first classifier in the bag.", 1, 1, Integer.MAX_VALUE);
+
+	public FlagOption useWeightOption = new FlagOption("useWeight", 'u', "Enable weight classifiers.");
+
+	public FlagOption resetTreesOption = new FlagOption("resetTrees", 'e',
+			"Reset trees when size is higher than the max.");
+
+	public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l', "ASHoeffdingTree to train.",
+			ASHoeffdingTree.class, "ASHoeffdingTree");
+
+	protected ASHoeffdingTree[] ensemble;
+	protected double[] error;
+	protected double alpha = 0.01;
+
+	@Override
+	public void resetLearningImpl() {
+		this.ensemble = new ASHoeffdingTree[this.ensembleSizeOption.getValue()];
+		this.error = new double[this.ensembleSizeOption.getValue()];
+		Classifier baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
+		baseLearner.resetLearning();
+		int pow = this.firstClassifierSizeOption.getValue();
+		for (int i = 0; i < this.ensemble.length; i++) {
+			this.ensemble[i] = (ASHoeffdingTree) baseLearner.copy();
+			this.error[i] = 0.0;
+			this.ensemble[i].setMaxSize(pow);
+			if ((this.resetTreesOption != null) && this.resetTreesOption.isSet()) {
+				this.ensemble[i].setResetTree();
+			}
+			pow *= 2;
+		}
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		int trueClass = (int) inst.classValue();
+		for (int i = 0; i < this.ensemble.length; i++) {
+			int k = MiscUtils.poisson(1.0, this.classifierRandom);
+			if (k > 0) {
+				Instance weightedInst = inst.copy();
+				weightedInst.setWeight(inst.weight() * k);
+				if (Utils.maxIndex(this.ensemble[i].getPredictionForInstance(inst)) == trueClass) {
+					this.error[i] += alpha * (0.0 - this.error[i]); // EWMA
+				} else {
+					this.error[i] += alpha * (1.0 - this.error[i]); // EWMA
+				}
+				this.ensemble[i].trainOnInstance(weightedInst);
+			}
+		}
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		DoubleVector combinedVote = new DoubleVector();
+		for (int i = 0; i < this.ensemble.length; i++) {
+			DoubleVector vote = this.ensemble[i].getPredictionForInstance(inst).asDoubleVector();
+			if (vote.sumOfValues() > 0.0) {
+				vote.normalize();
+				if ((this.useWeightOption != null) && this.useWeightOption.isSet()) {
+					vote.scaleValues(1.0 / (this.error[i] * this.error[i]));
+				}
+				combinedVote.addValues(vote);
+			}
+		}
+		return new ClassificationPrediction(combinedVote.getArrayRef());
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[] { new Measurement("ensemble size", this.ensemble != null ? this.ensemble.length : 0) };
+	}
+
+	@Override
+	public Classifier[] getSubClassifiers() {
+		return this.ensemble.clone();
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/meta/OzaBoostAdwin.java b/moa/src/main/java/moa/learners/predictors/meta/OzaBoostAdwin.java
new file mode 100644
index 000000000..470851600
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/meta/OzaBoostAdwin.java
@@ -0,0 +1,277 @@
+/*
+ *    OzaBoostAdwin.java
+ *    Copyright (C) 2010 University of Waikato, Hamilton, New Zealand
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.meta;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.MiscUtils;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.core.driftdetection.ADWIN;
+import moa.options.ClassOption;
+
+/**
+ * Boosting for evolving data streams using ADWIN.
+ *
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @version $Revision: 7 $
+ */
+public class OzaBoostAdwin extends AbstractClassifier implements Classifier {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Boosting for evolving data streams using ADWIN.";
+	}
+
+	public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l', "Classifier to train.", Classifier.class,
+			"trees.HoeffdingTree");
+
+	public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's', "The number of models to boost.", 10, 1,
+			Integer.MAX_VALUE);
+
+	public FlagOption pureBoostOption = new FlagOption("pureBoost", 'p', "Boost with weights only; no poisson.");
+
+	public FloatOption deltaAdwinOption = new FloatOption("deltaAdwin", 'a', "Delta of Adwin change detection", 0.002,
+			0.0, 1.0);
+
+	public FlagOption outputCodesOption = new FlagOption("outputCodes", 'o',
+			"Use Output Codes to use binary classifiers.");
+
+	public FlagOption sammeOption = new FlagOption("same", 'e', "Use Samme Algorithm.");
+
+	protected Classifier[] ensemble;
+
+	protected double[] scms;
+
+	protected double[] swms;
+
+	protected ADWIN[] ADError;
+
+	protected int numberOfChangesDetected;
+
+	protected int[][] matrixCodes;
+
+	protected boolean initMatrixCodes = false;
+
+	protected double logKm1 = 0.0;
+
+	protected int Km1 = 1;
+
+	protected boolean initKm1 = false;
+
+	@Override
+	public void resetLearningImpl() {
+		this.ensemble = new Classifier[this.ensembleSizeOption.getValue()];
+		Classifier baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
+		baseLearner.resetLearning();
+		for (int i = 0; i < this.ensemble.length; i++) {
+			this.ensemble[i] = (Classifier) baseLearner.copy();
+		}
+		this.scms = new double[this.ensemble.length];
+		this.swms = new double[this.ensemble.length];
+		this.ADError = new ADWIN[this.ensemble.length];
+		for (int i = 0; i < this.ensemble.length; i++) {
+			this.ADError[i] = new ADWIN(this.deltaAdwinOption.getValue());
+		}
+		this.numberOfChangesDetected = 0;
+		if (this.outputCodesOption.isSet()) {
+			this.initMatrixCodes = true;
+		}
+		if (this.sammeOption.isSet()) {
+			this.initKm1 = true;
+		}
+
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		int numClasses = inst.numClasses();
+		// Set log (k-1) and (k-1) for SAMME Method
+		if (this.sammeOption.isSet()) {
+			this.Km1 = numClasses - 1;
+			this.logKm1 = Math.log(this.Km1);
+			this.initKm1 = false;
+		}
+		// Output Codes
+		if (this.initMatrixCodes == true) {
+
+			this.matrixCodes = new int[this.ensemble.length][inst.numClasses()];
+			for (int i = 0; i < this.ensemble.length; i++) {
+				int numberOnes;
+				int numberZeros;
+
+				do { // until we have the same number of zeros and ones
+					numberOnes = 0;
+					numberZeros = 0;
+					for (int j = 0; j < numClasses; j++) {
+						int result = 0;
+						if (j == 1 && numClasses == 2) {
+							result = 1 - this.matrixCodes[i][0];
+						} else {
+							result = (this.classifierRandom.nextBoolean() ? 1 : 0);
+						}
+						this.matrixCodes[i][j] = result;
+						if (result == 1) {
+							numberOnes++;
+						} else {
+							numberZeros++;
+						}
+					}
+				} while ((numberOnes - numberZeros) * (numberOnes - numberZeros) > (this.ensemble.length % 2));
+
+			}
+			this.initMatrixCodes = false;
+		}
+
+		boolean Change = false;
+		double lambda_d = 1.0;
+		Instance weightedInst = inst.copy();
+		for (int i = 0; i < this.ensemble.length; i++) {
+			double k = this.pureBoostOption.isSet() ? lambda_d
+					: MiscUtils.poisson(lambda_d * this.Km1, this.classifierRandom);
+			if (k > 0.0) {
+				if (this.outputCodesOption.isSet()) {
+					weightedInst.setClassValue(this.matrixCodes[i][(int) inst.classValue()]);
+				}
+				weightedInst.setWeight(inst.weight() * k);
+				this.ensemble[i].trainOnInstance(weightedInst);
+			}
+			boolean correctlyClassifies = this.ensemble[i].correctlyClassifies(weightedInst);
+			if (correctlyClassifies) {
+				this.scms[i] += lambda_d;
+				lambda_d *= this.trainingWeightSeenByModel / (2 * this.scms[i]);
+			} else {
+				this.swms[i] += lambda_d;
+				lambda_d *= this.trainingWeightSeenByModel / (2 * this.swms[i]);
+			}
+
+			double ErrEstim = this.ADError[i].getEstimation();
+			if (this.ADError[i].setInput(correctlyClassifies ? 0 : 1)) {
+				if (this.ADError[i].getEstimation() > ErrEstim) {
+					Change = true;
+				}
+			}
+		}
+		if (Change) {
+			numberOfChangesDetected++;
+			double max = 0.0;
+			int imax = -1;
+			for (int i = 0; i < this.ensemble.length; i++) {
+				if (max < this.ADError[i].getEstimation()) {
+					max = this.ADError[i].getEstimation();
+					imax = i;
+				}
+			}
+			if (imax != -1) {
+				this.ensemble[imax].resetLearning();
+				// this.ensemble[imax].trainOnInstance(inst);
+				this.ADError[imax] = new ADWIN(this.deltaAdwinOption.getValue());
+				this.scms[imax] = 0;
+				this.swms[imax] = 0;
+			}
+		}
+	}
+
+	protected double getEnsembleMemberWeight(int i) {
+		double em = this.swms[i] / (this.scms[i] + this.swms[i]);
+		if ((em == 0.0) || (em > 0.5)) {
+			return this.logKm1;
+		}
+		return Math.log((1.0 - em) / em) + this.logKm1;
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		if (this.outputCodesOption.isSet()) {
+			return getPredictionForInstanceBinary(inst);
+		}
+		DoubleVector combinedVote = new DoubleVector();
+		for (int i = 0; i < this.ensemble.length; i++) {
+			double memberWeight = getEnsembleMemberWeight(i);
+			if (memberWeight > 0.0) {
+				DoubleVector vote = this.ensemble[i].getPredictionForInstance(inst).asDoubleVector();
+				if (vote.sumOfValues() > 0.0) {
+					vote.normalize();
+					vote.scaleValues(memberWeight);
+					combinedVote.addValues(vote);
+				}
+			} else {
+				break;
+			}
+		}
+		return new ClassificationPrediction(combinedVote.getArrayRef());
+	}
+
+	public Prediction getPredictionForInstanceBinary(Instance inst) {
+		double combinedVote[] = new double[inst.numClasses()];
+		Instance weightedInst = inst.copy();
+		if (this.initMatrixCodes == false) {
+			for (int i = 0; i < this.ensemble.length; i++) {
+				// Replace class by OC
+				weightedInst.setClassValue(this.matrixCodes[i][(int) inst.classValue()]);
+
+				double vote[];
+				vote = this.ensemble[i].getPredictionForInstance(weightedInst).asDoubleArray();
+				// Binary Case
+				int voteClass = 0;
+				if (vote.length == 2) {
+					voteClass = (vote[1] > vote[0] ? 1 : 0);
+				}
+				// Update votes
+				for (int j = 0; j < inst.numClasses(); j++) {
+					if (this.matrixCodes[i][j] == voteClass) {
+						combinedVote[j] += getEnsembleMemberWeight(i);
+					}
+				}
+			}
+		}
+		return new ClassificationPrediction(combinedVote);
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[] { new Measurement("ensemble size", this.ensemble != null ? this.ensemble.length : 0),
+				new Measurement("change detections", this.numberOfChangesDetected) };
+	}
+
+	@Override
+	public Classifier[] getSubClassifiers() {
+		return this.ensemble.clone();
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/meta/PairedLearners.java b/moa/src/main/java/moa/learners/predictors/meta/PairedLearners.java
new file mode 100644
index 000000000..0bc6a6970
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/meta/PairedLearners.java
@@ -0,0 +1,147 @@
+/*
+ *    PairedLearners.java
+ *    Copyright (C) 2015 Instituto Federal de Pernambuco, Recife, Brazil
+ *    @author Paulo Gonçalves (paulogoncalves@recife.ifpe.edu.br)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package moa.learners.predictors.meta;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Measurement;
+import moa.core.Utils;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.AbstractInstanceLearner;
+import moa.learners.predictors.Classifier;
+import moa.options.ClassOption;
+
+/**
+ * Creates two classifiers: a stable and a reactive. The first represents the
+ * actual stable concept, while the second is trained on the most recent data.
+ * If the accuracy of the reactive is higher than that of the stable, it means
+ * the concept has changed. The stable classifier is then substituted by the
+ * reactive, and the reactive is reset.
+ *
+ * <p>
+ * Stephen H. Bach, Marcus A. Maloof, "Paired Learners for Concept Drift",
+ * Eighth IEEE International Conference on Data Mining (ICDM), 2008, pp.23-32
+ * </p>
+ *
+ * @author Paulo Gonçalves (paulogoncalves at recife.ifpe.edu.br)
+ *
+ */
+
+public class PairedLearners extends AbstractClassifier implements Classifier {
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption stableLearnerOption = new ClassOption("stableLearner", 's', "Stable learner", Classifier.class,
+			"bayes.NaiveBayes");
+
+	public ClassOption reactiveLearnerOption = new ClassOption("reactiveLearner", 'r', "Reactive learner",
+			Classifier.class, "bayes.NaiveBayes");
+
+	public IntOption windowSizeOption = new IntOption("windowSize", 'w', "Window size for the reactive learner", 12, 1,
+			Integer.MAX_VALUE);
+
+	public FloatOption thresholdOption = new FloatOption("threshold", 't',
+			"Threashold for creating a new stable learner", 0.2, 0, 1);
+
+	protected int[] c;
+	protected Classifier stableLearner;
+	protected Classifier reactiveLearner;
+	protected int t;
+	protected int w;
+	protected int theta;
+	protected Instance[] instances;
+	protected int changeDetected = 0;
+	protected int numberOfErrors = 0;
+	protected int i;
+
+	@Override
+	public void resetLearningImpl() {
+		this.t = 0;
+		this.w = this.windowSizeOption.getValue();
+		this.c = new int[this.w];
+		this.theta = (int) (this.w * this.thresholdOption.getValue());
+		this.instances = new Instance[this.w];
+
+		this.stableLearner = (Classifier) ((Classifier) getPreparedClassOption(this.stableLearnerOption)).copy();
+		this.stableLearner.resetLearning();
+		this.reactiveLearner = (Classifier) ((Classifier) getPreparedClassOption(this.reactiveLearnerOption)).copy();
+		this.reactiveLearner.resetLearning();
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		this.instances[this.t] = inst;
+		int trueClass = (int) inst.classValue();
+		boolean stablePrediction = Utils.maxIndex(this.stableLearner.getPredictionForInstance(inst)) == trueClass;
+		boolean reactivePrediction = Utils.maxIndex(this.reactiveLearner.getPredictionForInstance(inst)) == trueClass;
+
+		this.numberOfErrors = this.numberOfErrors - this.c[this.t];
+		if (!stablePrediction && reactivePrediction) {
+			this.c[this.t] = 1;
+			this.numberOfErrors++;
+		} else {
+			this.c[this.t] = 0;
+		}
+		if (this.theta < this.numberOfErrors) {
+			this.changeDetected++;
+			this.stableLearner = (Classifier) this.reactiveLearner.copy();
+			Arrays.fill(this.c, 0); // Resets c
+			this.numberOfErrors = 0;
+		}
+		this.stableLearner.trainOnInstance(inst);
+		this.reactiveLearner.resetLearning();
+		for (i = 0; i < this.instances.length && this.instances[i] != null; i++) {
+			this.reactiveLearner.trainOnInstance(this.instances[i]);
+		}
+		this.t = (this.t + 1) % this.w;
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		return this.stableLearner.getPredictionForInstance(inst);
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		List<Measurement> measurementList = new LinkedList();
+		measurementList.add(new Measurement("Change detected", this.changeDetected));
+		Measurement[] modelMeasurements = ((AbstractInstanceLearner) this.stableLearner).getModelMeasurements();
+		if (modelMeasurements != null) {
+			measurementList.addAll(Arrays.asList(modelMeasurements));
+		}
+		this.changeDetected = 0;
+		return measurementList.toArray(new Measurement[measurementList.size()]);
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/meta/RCD.java b/moa/src/main/java/moa/learners/predictors/meta/RCD.java
new file mode 100644
index 000000000..940b885e8
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/meta/RCD.java
@@ -0,0 +1,272 @@
+/*
+ *    RCD.java
+ *    Copyright (C) 2017 Instituto Federal de Pernambuco
+ *    @author Paulo Gonçalves (paulogoncalves@recife.ifpe.edu.br)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.meta;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Utils;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.core.statisticaltests.StatisticalTest;
+import moa.learners.predictors.drift.DriftDetectionMethodClassifier;
+import moa.options.ClassOption;
+
+/**
+ * Creates a set of classifiers, each one representing a different context.
+ * Reuses classifier associating to each one a sample of data and compares new
+ * data to old ones using a multivariate non-parametric statistical test. Tests
+ * are performed in parallel and classifiers are stored based on their accuracy
+ * and stored time.
+ *
+ * 1) Parameterized number of classifiers to store. 2) Classifiers are stored
+ * removing the older ones if the set is full. 3) Classifier with higher
+ * significance value is selected.
+ *
+ * Based on: Gonçalves Jr, Paulo Mauricio, and Roberto Souto Maior De Barros.
+ * "RCD: A recurring concept drift framework." Pattern Recognition Letters 34.9
+ * (2013): 1018-1025.
+ *
+ * @author Paulo Goncalves (paulogoncalves at recife dot ifpe dot edu dot br)
+ *
+ */
+public class RCD extends DriftDetectionMethodClassifier {
+
+	private static final long serialVersionUID = 1L;
+
+	private class ClassifierKS implements Serializable {
+
+		private final Classifier classifier;
+		private final List<Instance> instances;
+
+		public ClassifierKS(Classifier classifier, List<Instance> instances) {
+			this.classifier = classifier;
+			this.instances = instances;
+		}
+
+		public Classifier getClassifier() {
+			return classifier;
+		}
+
+		public List<Instance> getInstances() {
+			return instances;
+		}
+	}
+
+	public ClassOption statisticalTestOption = new ClassOption("statisticalTest", 'a',
+			"Non-parametric multivariate statistical test to use.", StatisticalTest.class, "KNN");
+
+	public FloatOption similarityBetweenDistributionsOption = new FloatOption("similarityBetweenDistributions", 's',
+			"The minimum percentual similarity between distributions (p-value).", 0.01, 0, 1);
+
+	public IntOption bufferSizeOption = new IntOption("bufferSize", 'b',
+			"The size of the buffer that represents the distributions.", 400, 1, Integer.MAX_VALUE);
+
+	public IntOption testFrequencyOption = new IntOption("testFrequency", 't',
+			"In the testing phase, test for best stored classifier after how many instances.", 400, 1,
+			Integer.MAX_VALUE);
+
+	public IntOption classifiersSizeOption = new IntOption("classifiersSize", 'c',
+			"The maximum amount of classifiers to store. 0 means unlimited.", 15, 0, Integer.MAX_VALUE);
+
+	public IntOption threadSizeOption = new IntOption("threadSize", 'm',
+			"The thread pool size, indicating how many simultaneous tests are allowed.", 4, 1, Integer.MAX_VALUE);
+
+	public IntOption quantityClassifiersTestOption = new IntOption("quantityClassifiersTest", 'q',
+			"Quantity of identified classifiers to check.", 1, 1, Integer.MAX_VALUE);
+
+	private List<ClassifierKS> classifiers;
+
+	protected List<Instance> currentChunk;
+
+	protected List<Instance> currentChunk2;
+
+	protected List<Instance> testChunk;
+
+	protected int bufferSize;
+
+	protected int previousState;
+
+	protected int index;
+
+	@Override
+	public void resetLearningImpl() {
+		super.resetLearningImpl();
+		this.classifiers = new ArrayList();
+		this.bufferSize = bufferSizeOption.getValue();
+		this.currentChunk = null;
+		this.currentChunk2 = null;
+		this.testChunk = null;
+		this.previousState = Integer.MIN_VALUE;
+		this.index = 0;
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		int trueClass = (int) inst.classValue();
+		boolean prediction = Utils.maxIndex(this.classifier.getPredictionForInstance(inst)) == trueClass;
+		this.driftDetectionMethod.input(prediction ? 0.0 : 1.0);
+		this.ddmLevel = DDM_INCONTROL_LEVEL;
+		if (this.driftDetectionMethod.getChange()) {
+			this.ddmLevel = DDM_OUTCONTROL_LEVEL;
+		}
+		if (this.driftDetectionMethod.getWarningZone()) {
+			this.ddmLevel = DDM_WARNING_LEVEL;
+		}
+		switch (this.ddmLevel) {
+		case DDM_WARNING_LEVEL:
+			this.warningDetected++;
+			switch (this.previousState) {
+			case DDM_INCONTROL_LEVEL:
+				this.newclassifier.resetLearning();
+				this.currentChunk2 = new ArrayList();
+				break;
+			}
+			this.newclassifier.trainOnInstance(inst);
+			this.addInstance(this.currentChunk2, inst);
+			this.previousState = DDM_WARNING_LEVEL;
+			break;
+		case DDM_OUTCONTROL_LEVEL:
+			this.changeDetected++;
+			switch (this.previousState) {
+			case DDM_WARNING_LEVEL:
+				ClassifierKS cs = this.getPreviousClassifier(this.classifier, this.currentChunk2);
+				if (cs == null) {
+					this.classifier = this.newclassifier;
+					this.newclassifier = (Classifier) ((Classifier) getPreparedClassOption(this.baseLearnerOption))
+							.copy();
+					this.classifiers.add(new ClassifierKS(this.classifier, this.currentChunk2));
+					this.currentChunk = this.currentChunk2;
+					int maxSize = this.classifiersSizeOption.getValue();
+					if (this.classifiers.size() > maxSize && maxSize > 0) {
+						this.classifiers.remove(0);
+					}
+				} else {
+					this.classifier = cs.getClassifier();
+					this.currentChunk = cs.getInstances();
+				}
+				this.currentChunk2 = null;
+				this.newclassifier.resetLearning();
+			}
+			this.previousState = DDM_OUTCONTROL_LEVEL;
+			break;
+		case DDM_INCONTROL_LEVEL:
+			switch (this.previousState) {
+			case DDM_INCONTROL_LEVEL:
+			case DDM_OUTCONTROL_LEVEL:
+				break;
+			case DDM_WARNING_LEVEL:
+				this.currentChunk2 = null;
+				break;
+			default:
+				this.currentChunk = new ArrayList();
+				this.classifiers.add(new ClassifierKS(this.classifier, this.currentChunk));
+				break;
+			}
+			this.addInstance(this.currentChunk, inst);
+			this.previousState = DDM_INCONTROL_LEVEL;
+			break;
+		}
+		this.classifier.trainOnInstance(inst);
+	}
+
+	private void addInstance(List<Instance> instances, Instance instance) {
+		if (instances.size() >= bufferSize) {
+			instances.remove(0);
+		}
+		instances.add(instance);
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		if (this.testChunk == null) {
+			this.testChunk = new ArrayList();
+		}
+		this.addInstance(this.testChunk, inst);
+		if (this.index++ == testFrequencyOption.getValue()) {
+			this.index = 0;
+			ClassifierKS cs = this.getPreviousClassifier(this.classifier, this.testChunk);
+			if (cs != null) {
+				this.classifier = cs.getClassifier();
+			}
+		}
+		return this.classifier.getPredictionForInstance(inst);
+	}
+
+	/**
+	 * Searches for the classifier best suited for actual data. All statistical
+	 * tests are performed in parallel.
+	 *
+	 * @param classifier Classifier to be added
+	 * @param instances  Instances used to build the classifier
+	 * @return
+	 */
+	private ClassifierKS getPreviousClassifier(Classifier classifier, List<Instance> instances) {
+		ExecutorService threadPool = Executors.newFixedThreadPool(this.threadSizeOption.getValue());
+		int SIZE = this.classifiers.size();
+		Map<Integer, Future<Double>> futures = new HashMap<>();
+		for (int i = 0; i < SIZE; i++) {
+			ClassifierKS cs = this.classifiers.get(i);
+			if (cs != null) {
+				if (cs.getClassifier() != classifier) {
+					StatisticalTest st = (StatisticalTest) getPreparedClassOption(this.statisticalTestOption);
+					StatisticalTest temp = (StatisticalTest) st.copy();
+					temp.set(instances, cs.getInstances());
+					futures.put(i, threadPool.submit(temp));
+				}
+			} else {
+				break;
+			}
+		}
+		ClassifierKS cks = null;
+		int qtd = this.quantityClassifiersTestOption.getValue();
+		double maxPValue = this.similarityBetweenDistributionsOption.getValue();
+		try {
+			for (int i = 0; i < SIZE && qtd > 0; i++) {
+				Future<Double> f = futures.get(i);
+				if (f != null) {
+					double p = f.get();
+					if (p < maxPValue) {
+						maxPValue = p;
+						cks = this.classifiers.get(i);
+						qtd--;
+					}
+				}
+			}
+		} catch (InterruptedException e) {
+			System.out.println("Processing interrupted.");
+		} catch (ExecutionException e) {
+			throw new RuntimeException("Error computing statistical test.", e);
+		}
+		threadPool.shutdownNow();
+		return cks;
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/meta/RandomRules.java b/moa/src/main/java/moa/learners/predictors/meta/RandomRules.java
similarity index 69%
rename from moa/src/main/java/moa/classifiers/meta/RandomRules.java
rename to moa/src/main/java/moa/learners/predictors/meta/RandomRules.java
index d525f6852..234310bf3 100644
--- a/moa/src/main/java/moa/classifiers/meta/RandomRules.java
+++ b/moa/src/main/java/moa/learners/predictors/meta/RandomRules.java
@@ -15,9 +15,9 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.classifiers.meta;
+package moa.learners.predictors.meta;
 
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
@@ -28,25 +28,20 @@
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 import com.yahoo.labs.samoa.instances.predictions.RegressionPrediction;
 
-import moa.classifiers.AbstractRegressor;
 import moa.core.DoubleVector;
 import moa.core.FastVector;
 import moa.core.Measurement;
 import moa.core.MiscUtils;
-import moa.learners.Classifier;
-import moa.learners.Regressor;
+import moa.learners.predictors.AbstractRegressor;
+import moa.learners.predictors.Regressor;
 import moa.options.ClassOption;
 import moa.streams.InstanceStream;
 
-
 public class RandomRules extends AbstractRegressor implements Regressor {
 
-	public IntOption VerbosityOption = new IntOption(
-			"verbosity",
-			'v',
-			"Output Verbosity Control Level. 1 (Less) to 2 (More)",
-			1, 1, 2);
-	
+	public IntOption VerbosityOption = new IntOption("verbosity", 'v',
+			"Output Verbosity Control Level. 1 (Less) to 2 (More)", 1, 1, 2);
+
 	@Override
 	public String getPurposeString() {
 		return "RandomRules";
@@ -54,16 +49,16 @@ public String getPurposeString() {
 
 	private static final long serialVersionUID = 1L;
 
-	public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l', "Regressor to train.", Regressor.class, "rules.AMRulesRegressor"); 
+	public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l', "Regressor to train.", Regressor.class,
+			"rules.AMRulesRegressor");
 
-	public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's',
-			"The number of models in the bag.", 10, 1, Integer.MAX_VALUE);
+	public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's', "The number of models in the bag.", 10, 1,
+			Integer.MAX_VALUE);
 
 	public FloatOption numAttributesPercentageOption = new FloatOption("numAttributesPercentage", 'n',
-			"The number of attributes to use per model.", 63.2, 0, 100); 
+			"The number of attributes to use per model.", 63.2, 0, 100);
 
-	public FlagOption useBaggingOption = new FlagOption("useBagging", 'p',
-			"Use Bagging.");
+	public FlagOption useBaggingOption = new FlagOption("useBagging", 'p', "Use Bagging.");
 
 	protected Regressor[] ensemble;
 
@@ -84,11 +79,11 @@ public void resetLearningImpl() {
 	public void trainOnInstanceImpl(Instance inst) {
 		for (int i = 0; i < this.ensemble.length; i++) {
 			int k = 1;
-			if ( this.useBaggingOption.isSet()) {
+			if (this.useBaggingOption.isSet()) {
 				k = MiscUtils.poisson(1.0, this.classifierRandom);
-			} 
+			}
 			if (k > 0) {
-				Instance weightedInst = transformInstance(inst,i);
+				Instance weightedInst = transformInstance(inst, i);
 				weightedInst.setWeight(inst.weight() * k);
 				this.ensemble[i].trainOnInstance(weightedInst);
 			}
@@ -99,23 +94,23 @@ public void trainOnInstanceImpl(Instance inst) {
 	public Prediction getPredictionForInstance(Instance inst) {
 		DoubleVector combinedVote = new DoubleVector();
 		StringBuilder sb = null;
-		if (VerbosityOption.getValue()>1)
-			sb=new StringBuilder();
-		
+		if (VerbosityOption.getValue() > 1)
+			sb = new StringBuilder();
+
 		for (int i = 0; i < this.ensemble.length; i++) {
-			DoubleVector vote = this.ensemble[i].getPredictionForInstance(transformInstance(inst,i)).asDoubleVector();
-			if (VerbosityOption.getValue()>1)
-					sb.append(vote.getValue(0) + ", ");
-			if (this.isRegression == false && vote.sumOfValues() != 0.0){
+			DoubleVector vote = this.ensemble[i].getPredictionForInstance(transformInstance(inst, i)).asDoubleVector();
+			if (VerbosityOption.getValue() > 1)
+				sb.append(vote.getValue(0) + ", ");
+			if (this.isRegression == false && vote.sumOfValues() != 0.0) {
 				vote.normalize();
 			}
 			combinedVote.addValues(vote);
 		}
-		if (this.isRegression == true){
-			combinedVote.scaleValues(1.0/this.ensemble.length);
+		if (this.isRegression == true) {
+			combinedVote.scaleValues(1.0 / this.ensemble.length);
 		}
-		if (VerbosityOption.getValue()>1){
-			sb.append(combinedVote.getValue(0)  + ", ").append(inst.classValue());
+		if (VerbosityOption.getValue() > 1) {
+			sb.append(combinedVote.getValue(0) + ", ").append(inst.classValue());
 			System.out.println(sb.toString());
 		}
 		return new RegressionPrediction(combinedVote.getValue(0));
@@ -132,12 +127,12 @@ public void getModelDescription(StringBuilder out, int indent) {
 
 	@Override
 	protected Measurement[] getModelMeasurementsImpl() {
-		return new Measurement[]{new Measurement("ensemble size",
-				this.ensemble != null ? this.ensemble.length : 0)};
+		return new Measurement[] { new Measurement("ensemble size", this.ensemble != null ? this.ensemble.length : 0) };
 	}
 
+	@Override
 	public Regressor[] getSubClassifiers() {
-		return this.ensemble; //.clone();
+		return this.ensemble; // .clone();
 	}
 
 	protected int[][] listAttributes;
@@ -146,15 +141,19 @@ public Regressor[] getSubClassifiers() {
 
 	protected Instance transformInstance(Instance inst, int classifierIndex) {
 		if (this.listAttributes == null) {
-			//  this.numAttributes = (int) (this.numAttributesPercentageOption.getValue() * inst.numAttributes()/100.0); // JD: number of attributes should not consider class
-			this.numAttributes = (int) (this.numAttributesPercentageOption.getValue() * (inst.numAttributes()-1)/100.0);
+			// this.numAttributes = (int) (this.numAttributesPercentageOption.getValue() *
+			// inst.numAttributes()/100.0); // JD: number of attributes should not consider
+			// class
+			this.numAttributes = (int) (this.numAttributesPercentageOption.getValue() * (inst.numAttributes() - 1)
+					/ 100.0);
 			this.listAttributes = new int[this.numAttributes][this.ensemble.length];
 			this.dataset = new InstancesHeader[this.ensemble.length];
 			for (int ensembleIndex = 0; ensembleIndex < this.ensemble.length; ensembleIndex++) {
 				for (int attributeIndex = 0; attributeIndex < this.numAttributes; attributeIndex++) {
 					boolean isUnique = false;
 					while (isUnique == false) {
-						this.listAttributes[attributeIndex][ensembleIndex] = this.classifierRandom.nextInt(inst.numAttributes() - 1);
+						this.listAttributes[attributeIndex][ensembleIndex] = this.classifierRandom
+								.nextInt(inst.numAttributes() - 1);
 						isUnique = true;
 						for (int k = 0; k < attributeIndex; k++) {
 							if (this.listAttributes[attributeIndex][ensembleIndex] == this.listAttributes[k][ensembleIndex]) {
@@ -163,28 +162,30 @@ protected Instance transformInstance(Instance inst, int classifierIndex) {
 							}
 						}
 					}
-					//this.listAttributes[attributeIndex][ensembleIndex] = attributeIndex;
+					// this.listAttributes[attributeIndex][ensembleIndex] = attributeIndex;
 				}
-				//Create Header
+				// Create Header
 				FastVector attributes = new FastVector();
 				for (int attributeIndex = 0; attributeIndex < this.numAttributes; attributeIndex++) {
 					attributes.addElement(inst.attribute(this.listAttributes[attributeIndex][ensembleIndex]));
 					System.out.print(this.listAttributes[attributeIndex][ensembleIndex]);
 				}
-				//System.out.println("Number of attributes: "+this.numAttributes+ ","+inst.numAttributes()); //JD
-				System.out.println("Number of attributes: "+this.numAttributes+ ","+(inst.numAttributes()-1));
+				// System.out.println("Number of attributes: "+this.numAttributes+
+				// ","+inst.numAttributes()); //JD
+				System.out.println("Number of attributes: " + this.numAttributes + "," + (inst.numAttributes() - 1));
 				attributes.addElement(inst.classAttribute());
-				this.dataset[ensembleIndex] =  new InstancesHeader(new InstancesHeader(
-						getCLICreationString(InstanceStream.class), attributes, 0));
+				this.dataset[ensembleIndex] = new InstancesHeader(
+						new InstancesHeader(getCLICreationString(InstanceStream.class), attributes, 0));
 				this.dataset[ensembleIndex].setClassIndex(this.numAttributes);
 				this.ensemble[ensembleIndex].setModelContext(this.dataset[ensembleIndex]);
 			}
 		}
-		//Instance instance = new DenseInstance(this.numAttributes+1);
-		//instance.setDataset(dataset[classifierIndex]);
+		// Instance instance = new DenseInstance(this.numAttributes+1);
+		// instance.setDataset(dataset[classifierIndex]);
 		double[] attVals = new double[this.numAttributes + 1];
 		for (int attributeIndex = 0; attributeIndex < this.numAttributes; attributeIndex++) {
-			//instance.setValue(attributeIndex, inst.value(this.listAttributes[attributeIndex][classifierIndex]));
+			// instance.setValue(attributeIndex,
+			// inst.value(this.listAttributes[attributeIndex][classifierIndex]));
 			attVals[attributeIndex] = inst.value(this.listAttributes[attributeIndex][classifierIndex]);
 		}
 		Instance instance = new DenseInstance(1.0, attVals);
@@ -196,4 +197,3 @@ protected Instance transformInstance(Instance inst, int classifierIndex) {
 		return instance;
 	}
 }
-
diff --git a/moa/src/main/java/moa/classifiers/meta/RegressionViaMTR.java b/moa/src/main/java/moa/learners/predictors/meta/RegressionViaMTR.java
similarity index 72%
rename from moa/src/main/java/moa/classifiers/meta/RegressionViaMTR.java
rename to moa/src/main/java/moa/learners/predictors/meta/RegressionViaMTR.java
index eb52367c1..4307b92f1 100644
--- a/moa/src/main/java/moa/classifiers/meta/RegressionViaMTR.java
+++ b/moa/src/main/java/moa/learners/predictors/meta/RegressionViaMTR.java
@@ -1,20 +1,22 @@
-package moa.classifiers.meta;
+package moa.learners.predictors.meta;
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 import com.yahoo.labs.samoa.instances.predictions.RegressionPrediction;
 
-import moa.classifiers.AbstractRegressor;
 import moa.core.Measurement;
-import moa.learners.MultiTargetRegressor;
-import moa.learners.Regressor;
+import moa.learners.predictors.AbstractRegressor;
+import moa.learners.predictors.MultiTargetRegressor;
+import moa.learners.predictors.Regressor;
 import moa.options.ClassOption;
 
 public class RegressionViaMTR extends AbstractRegressor implements Regressor {
 
 	public MultiTargetRegressor mtr;
 
-	public ClassOption regressorOption = new ClassOption("MTRegessor", 'c', "Multi-target regressor to be used as a single target regressor.", MultiTargetRegressor.class, "moa.classifiers.mtr.trees.ISOUPTree");
+	public ClassOption regressorOption = new ClassOption("MTRegessor", 'c',
+			"Multi-target regressor to be used as a single target regressor.", MultiTargetRegressor.class,
+			"trees.ISOUPTree");
 
 	@Override
 	public boolean isRandomizable() {
@@ -49,6 +51,9 @@ protected Measurement[] getModelMeasurementsImpl() {
 		return this.mtr.getModelMeasurements();
 	}
 
-
-
+	@Override
+	public void modelContextSet() {
+		this.mtr.setModelContext(getModelContext());
+	}
+	
 }
diff --git a/moa/src/main/java/moa/learners/predictors/meta/TemporallyAugmentedClassifier.java b/moa/src/main/java/moa/learners/predictors/meta/TemporallyAugmentedClassifier.java
new file mode 100644
index 000000000..3e4352184
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/meta/TemporallyAugmentedClassifier.java
@@ -0,0 +1,198 @@
+/*
+ *    TemporallyAugmentedClassifier.java
+ *    Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ *    @author Bernhard Pfahringer (bernhard@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.meta;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Attribute;
+import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Measurement;
+import moa.core.Utils;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.AbstractInstanceLearner;
+import moa.learners.predictors.Classifier;
+import moa.options.ClassOption;
+
+/**
+ * Include labels of previous instances into the training data
+ *
+ * <p>
+ * This enables a classifier to exploit potentially present auto-correlation
+ * </p>
+ *
+ * <p>
+ * Parameters:
+ * </p>
+ * <ul>
+ * <li>-l : Classifier to train</li>
+ * <li>-n : The number of old labels to include</li>
+ * </ul>
+ *
+ * @author Bernhard Pfahringer (bernhard@cs.waikato.ac.nz)
+ * @version $Revision: 1 $
+ */
+public class TemporallyAugmentedClassifier extends AbstractClassifier implements Classifier {
+
+	@Override
+	public String getPurposeString() {
+		return "Add some old labels to every instance";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l', "Classifier to train.", Classifier.class,
+			"trees.HoeffdingTree");
+
+	public IntOption numOldLabelsOption = new IntOption("numOldLabels", 'n',
+			"The number of old labels to add to each example.", 1, 0, Integer.MAX_VALUE);
+
+	protected Classifier baseLearner;
+
+	protected double[] oldLabels;
+
+	protected InstancesHeader header;
+
+	public FlagOption labelDelayOption = new FlagOption("labelDelay", 'd',
+			"Labels arrive with Delay. Use predictions instead of true Labels.");
+
+	@Override
+	public void resetLearningImpl() {
+		this.baseLearner = (Classifier) getPreparedClassOption(this.baseLearnerOption);
+		this.oldLabels = new double[this.numOldLabelsOption.getValue()];
+		this.header = null;
+		baseLearner.resetLearning();
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance instance) {
+		this.baseLearner.trainOnInstance(extendWithOldLabels(instance));
+		if (this.labelDelayOption.isSet() == false) {
+			// Use true old Labels to add attributes to instances
+			addOldLabel(instance.classValue());
+		}
+	}
+
+	public void addOldLabel(double newPrediction) {
+		int numLabels = this.oldLabels.length;
+		if (numLabels > 0) {
+			for (int i = 1; i < numLabels; i++) {
+				this.oldLabels[i - 1] = this.oldLabels[i];
+			}
+			this.oldLabels[numLabels - 1] = newPrediction;
+		}
+	}
+
+	public void initHeader(InstancesHeader dataset) {
+		int numLabels = this.numOldLabelsOption.getValue();
+		Attribute target = dataset.classAttribute();
+
+		List<String> possibleValues = new ArrayList<>();
+		int n = target.numValues();
+		for (int i = 0; i < n; i++) {
+			possibleValues.add(target.value(i));
+		}
+
+		ArrayList<Attribute> attrs = new ArrayList<>(numLabels + dataset.numAttributes());
+		for (int i = 0; i < numLabels; i++) {
+			attrs.add(new Attribute(target.name() + "_" + i, possibleValues));
+		}
+		for (int i = 0; i < dataset.numAttributes(); i++) {
+			Attribute attr = dataset.attribute(i);
+			Attribute newAttribute = null;
+			if (attr.isNominal() == true) {
+				newAttribute = new Attribute(attr.name(), attr.getAttributeValues());
+			}
+			if (attr.isNumeric() == true) {
+				newAttribute = new Attribute(attr.name());
+			}
+			if (newAttribute != null) {
+				attrs.add(newAttribute);
+			}
+		}
+		this.header = new InstancesHeader("extended_" + dataset.getRelationName(), attrs, 0);
+		this.header.setClassIndex(numLabels + dataset.classIndex());
+	}
+
+	public Instance extendWithOldLabels(Instance instance) {
+		if (this.header == null) {
+			initHeader(instance.dataset());
+			this.baseLearner.setModelContext(this.header.getEmptyHeader());
+		}
+		int numLabels = this.oldLabels.length;
+		if (numLabels == 0) {
+			return instance;
+		}
+		double[] x = instance.toDoubleArray();
+		double[] x2 = Arrays.copyOfRange(this.oldLabels, 0, numLabels + x.length);
+		System.arraycopy(x, 0, x2, numLabels, x.length);
+		Instance extendedInstance = new DenseInstance(instance.weight(), x2);
+		extendedInstance.setDataset(this.header);
+		// System.out.println( extendedInstance);
+		return extendedInstance;
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance instance) {
+		double[] prediction = this.baseLearner.getPredictionForInstance(extendWithOldLabels(instance)).asDoubleArray();
+		if (this.labelDelayOption.isSet() == true) {
+			// Use predicted Labels to add attributes to instances
+			addOldLabel(Utils.maxIndex(prediction));
+		}
+		return new ClassificationPrediction(prediction);
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false; // ??? this.baseLearner.isRandomizable;
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		List<Measurement> measurementList = new LinkedList<>();
+		Measurement[] modelMeasurements = ((AbstractInstanceLearner) this.baseLearner).getModelMeasurements();
+		if (modelMeasurements != null) {
+			for (Measurement measurement : modelMeasurements) {
+				measurementList.add(measurement);
+			}
+		}
+		return measurementList.toArray(new Measurement[measurementList.size()]);
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public String toString() {
+		return "TemporallyAugmentedClassifier using " + this.numOldLabelsOption.getValue() + " labels\n"
+				+ this.baseLearner;
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/meta/WEKAClassifier.java b/moa/src/main/java/moa/learners/predictors/meta/WEKAClassifier.java
new file mode 100644
index 000000000..3007a4657
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/meta/WEKAClassifier.java
@@ -0,0 +1,207 @@
+/*
+ *    WEKAClassifier.java
+ *    Copyright (C) 2009 University of Waikato, Hamilton, New Zealand
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *    @author FracPete (fracpete at waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.meta;
+
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Measurement;
+import moa.learners.predictors.AbstractClassifier;
+import moa.options.WEKAClassOption;
+import weka.classifiers.Classifier;
+import weka.classifiers.UpdateableClassifier;
+
+/**
+ * Class for using a classifier from WEKA.
+ *
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @author FracPete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class WEKAClassifier extends AbstractClassifier implements moa.learners.predictors.Classifier {
+
+	private static final long serialVersionUID = 1L;
+
+	protected SamoaToWekaInstanceConverter instanceConverter;
+
+	@Override
+	public String getPurposeString() {
+		return "Classifier from Weka";
+	}
+
+	public WEKAClassOption baseLearnerOption = new WEKAClassOption("baseLearner", 'l', "Classifier to train.",
+			weka.classifiers.Classifier.class, "weka.classifiers.bayes.NaiveBayesUpdateable");
+
+	public IntOption widthOption = new IntOption("width", 'w', "Size of Window for training learner.", 0, 0,
+			Integer.MAX_VALUE);
+
+	public IntOption widthInitOption = new IntOption("widthInit", 'i', "Size of first Window for training learner.",
+			1000, 0, Integer.MAX_VALUE);
+
+	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency", 'f',
+			"How many instances between samples of the learning performance.", 0, 0, Integer.MAX_VALUE);
+
+	protected Classifier classifier;
+
+	protected int numberInstances;
+
+	protected weka.core.Instances instancesBuffer;
+
+	protected boolean isClassificationEnabled;
+
+	protected boolean isBufferStoring;
+
+	@Override
+	public void resetLearningImpl() {
+
+		try {
+			// System.out.println(baseLearnerOption.getValue());
+			String[] options = weka.core.Utils.splitOptions(baseLearnerOption.getValueAsCLIString());
+			createWekaClassifier(options);
+		} catch (Exception e) {
+			System.err.println("Creating a new classifier: " + e.getMessage());
+		}
+		numberInstances = 0;
+		isClassificationEnabled = false;
+		this.isBufferStoring = true;
+		this.instanceConverter = new SamoaToWekaInstanceConverter();
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance samoaInstance) {
+		weka.core.Instance inst = this.instanceConverter.wekaInstance(samoaInstance);
+		try {
+			if (numberInstances == 0) {
+				this.instancesBuffer = new weka.core.Instances(inst.dataset());
+				if (classifier instanceof UpdateableClassifier) {
+					classifier.buildClassifier(instancesBuffer);
+					this.isClassificationEnabled = true;
+				} else {
+					this.isBufferStoring = true;
+				}
+			}
+			numberInstances++;
+
+			if (classifier instanceof UpdateableClassifier) {
+				if (numberInstances > 0) {
+					((UpdateableClassifier) classifier).updateClassifier(inst);
+				}
+			} else {
+				if (numberInstances == widthInitOption.getValue()) {
+					// Build first time Classifier
+					buildClassifier();
+					isClassificationEnabled = true;
+					// Continue to store instances
+					if (sampleFrequencyOption.getValue() != 0) {
+						isBufferStoring = true;
+					}
+				}
+				if (widthOption.getValue() == 0) {
+					// Used from SingleClassifierDrift
+					if (isBufferStoring == true) {
+						instancesBuffer.add(inst);
+					}
+				} else {
+					// Used form WekaClassifier without using SingleClassifierDrift
+					int numInstances = numberInstances % sampleFrequencyOption.getValue();
+					if (sampleFrequencyOption.getValue() == 0) {
+						numInstances = numberInstances;
+					}
+					if (numInstances == 0) {
+						// Begin to store instances
+						isBufferStoring = true;
+					}
+					if (isBufferStoring == true && numInstances <= widthOption.getValue()) {
+						// Store instances
+						instancesBuffer.add(inst);
+					}
+					if (numInstances == widthOption.getValue()) {
+						// Build Classifier
+						buildClassifier();
+						isClassificationEnabled = true;
+						this.instancesBuffer = new weka.core.Instances(inst.dataset());
+					}
+				}
+			}
+		} catch (Exception e) {
+			System.err.println("Training: " + e.getMessage());
+		}
+	}
+
+	public void buildClassifier() {
+		try {
+			if ((classifier instanceof UpdateableClassifier) == false) {
+				Classifier auxclassifier = weka.classifiers.AbstractClassifier.makeCopy(classifier);
+				auxclassifier.buildClassifier(instancesBuffer);
+				classifier = auxclassifier;
+				isBufferStoring = false;
+			}
+		} catch (Exception e) {
+			System.err.println("Building WEKA Classifier: " + e.getMessage());
+		}
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance samoaInstance) {
+		weka.core.Instance inst = this.instanceConverter.wekaInstance(samoaInstance);
+		double[] votes = new double[inst.numClasses()];
+		if (isClassificationEnabled == false) {
+			for (int i = 0; i < inst.numClasses(); i++) {
+				votes[i] = 1.0 / inst.numClasses();
+			}
+		} else {
+			try {
+				votes = this.classifier.distributionForInstance(inst);
+			} catch (Exception e) {
+				System.err.println(e.getMessage());
+			}
+		}
+		return new ClassificationPrediction(votes);
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		if (classifier != null) {
+			out.append(classifier.toString());
+		}
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		Measurement[] m = new Measurement[0];
+		return m;
+	}
+
+	public void createWekaClassifier(String[] options) throws Exception {
+		String classifierName = options[0];
+		String[] newoptions = options.clone();
+		newoptions[0] = "";
+		this.classifier = weka.classifiers.AbstractClassifier.forName(classifierName, newoptions);
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/meta/WeightedMajorityAlgorithm.java b/moa/src/main/java/moa/learners/predictors/meta/WeightedMajorityAlgorithm.java
new file mode 100644
index 000000000..7047dfd32
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/meta/WeightedMajorityAlgorithm.java
@@ -0,0 +1,193 @@
+/*
+ *    WeightedMajorityAlgorithm.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.meta;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.ListOption;
+import com.github.javacliparser.Option;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.ObjectRepository;
+import moa.core.Utils;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.options.ClassOption;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Weighted majority algorithm for data streams.
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public class WeightedMajorityAlgorithm extends AbstractClassifier implements Classifier {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Weighted majority algorithm for data streams.";
+	}
+
+	public ListOption learnerListOption = new ListOption("learners", 'l', "The learners to combine.",
+			new ClassOption("learner", ' ', "", Classifier.class, "trees.HoeffdingTree"),
+			new Option[] { new ClassOption("", ' ', "", Classifier.class, "trees.HoeffdingTree -l MC"),
+					new ClassOption("", ' ', "", Classifier.class, "trees.HoeffdingTree -l NB"),
+					new ClassOption("", ' ', "", Classifier.class, "trees.HoeffdingTree -l NBAdaptive"),
+					new ClassOption("", ' ', "", Classifier.class, "bayes.NaiveBayes") },
+			',');
+
+	public FloatOption betaOption = new FloatOption("beta", 'b', "Factor to punish mistakes by.", 0.9, 0.0, 1.0);
+
+	public FloatOption gammaOption = new FloatOption("gamma", 'g', "Minimum fraction of weight per model.", 0.01, 0.0,
+			0.5);
+
+	public FlagOption pruneOption = new FlagOption("prune", 'p', "Prune poorly performing models from ensemble.");
+
+	protected Classifier[] ensemble;
+
+	protected double[] ensembleWeights;
+
+	@Override
+	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		Option[] learnerOptions = this.learnerListOption.getList();
+		this.ensemble = new Classifier[learnerOptions.length];
+		for (int i = 0; i < learnerOptions.length; i++) {
+			monitor.setCurrentActivity("Materializing learner " + (i + 1) + "...", -1.0);
+			this.ensemble[i] = (Classifier) ((ClassOption) learnerOptions[i]).materializeObject(monitor, repository);
+			if (monitor.taskShouldAbort()) {
+				return;
+			}
+			monitor.setCurrentActivity("Preparing learner " + (i + 1) + "...", -1.0);
+			this.ensemble[i].prepareForUse(monitor, repository);
+			if (monitor.taskShouldAbort()) {
+				return;
+			}
+		}
+		super.prepareForUseImpl(monitor, repository);
+	}
+
+	@Override
+	public void resetLearningImpl() {
+		this.ensembleWeights = new double[this.ensemble.length];
+		for (int i = 0; i < this.ensemble.length; i++) {
+			this.ensemble[i].resetLearning();
+			this.ensembleWeights[i] = 1.0;
+		}
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		double totalWeight = 0.0;
+		for (int i = 0; i < this.ensemble.length; i++) {
+			boolean prune = false;
+			if (!this.ensemble[i].correctlyClassifies(inst)) {
+				if (this.ensembleWeights[i] > this.gammaOption.getValue() / this.ensembleWeights.length) {
+					this.ensembleWeights[i] *= this.betaOption.getValue() * inst.weight();
+				} else if (this.pruneOption.isSet()) {
+					prune = true;
+					discardModel(i);
+					i--;
+				}
+			}
+			if (!prune) {
+				totalWeight += this.ensembleWeights[i];
+				this.ensemble[i].trainOnInstance(inst);
+			}
+		}
+		// normalize weights
+		for (int i = 0; i < this.ensembleWeights.length; i++) {
+			this.ensembleWeights[i] /= totalWeight;
+		}
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		DoubleVector combinedVote = new DoubleVector();
+		if (this.trainingWeightSeenByModel > 0.0) {
+			for (int i = 0; i < this.ensemble.length; i++) {
+				if (this.ensembleWeights[i] > 0.0) {
+					DoubleVector vote = this.ensemble[i].getPredictionForInstance(inst).asDoubleVector();
+					if (vote.sumOfValues() > 0.0) {
+						vote.normalize();
+						vote.scaleValues(this.ensembleWeights[i]);
+						combinedVote.addValues(vote);
+					}
+				}
+			}
+		}
+		return new ClassificationPrediction(combinedVote.getArrayRef());
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		Measurement[] measurements = null;
+		if (this.ensembleWeights != null) {
+			measurements = new Measurement[this.ensembleWeights.length];
+			for (int i = 0; i < this.ensembleWeights.length; i++) {
+				measurements[i] = new Measurement("member weight " + (i + 1), this.ensembleWeights[i]);
+			}
+		}
+		return measurements;
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+
+	@Override
+	public Classifier[] getSubClassifiers() {
+		return this.ensemble.clone();
+	}
+
+	public void discardModel(int index) {
+		Classifier[] newEnsemble = new Classifier[this.ensemble.length - 1];
+		double[] newEnsembleWeights = new double[newEnsemble.length];
+		int oldPos = 0;
+		for (int i = 0; i < newEnsemble.length; i++) {
+			if (oldPos == index) {
+				oldPos++;
+			}
+			newEnsemble[i] = this.ensemble[oldPos];
+			newEnsembleWeights[i] = this.ensembleWeights[oldPos];
+			oldPos++;
+		}
+		this.ensemble = newEnsemble;
+		this.ensembleWeights = newEnsembleWeights;
+	}
+
+	protected long removePoorestModelBytes() {
+		int poorestIndex = Utils.minIndex(this.ensembleWeights);
+		long byteSize = this.ensemble[poorestIndex].measureByteSize();
+		discardModel(poorestIndex);
+		return byteSize;
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBagClassification.java b/moa/src/main/java/moa/learners/predictors/meta/classifiers/OzaBag.java
similarity index 65%
rename from moa/src/main/java/moa/classifiers/meta/OzaBagClassification.java
rename to moa/src/main/java/moa/learners/predictors/meta/classifiers/OzaBag.java
index 41acd896a..e870ded94 100644
--- a/moa/src/main/java/moa/classifiers/meta/OzaBagClassification.java
+++ b/moa/src/main/java/moa/learners/predictors/meta/classifiers/OzaBag.java
@@ -1,20 +1,21 @@
-package moa.classifiers.meta;
+package moa.learners.predictors.meta.classifiers;
 
 import com.yahoo.labs.samoa.instances.predictions.MultiTargetRegressionPrediction;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
 import moa.core.DoubleVector;
-import moa.learners.Classifier;
-
-public class OzaBagClassification extends AbstractOzaBag<Classifier> implements Classifier {
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.meta.AbstractOzaBag;
 
+public class OzaBag extends AbstractOzaBag<Classifier> implements Classifier {
 
 	private static final long serialVersionUID = 1L;
 
-	public OzaBagClassification() {
-		super(Classifier.class, "moa.classifiers.trees.HoeffdingTree");
+	public OzaBag() {
+		super(Classifier.class, "trees.HoeffdingTree");
 	}
-	
+
+	@Override
 	public Prediction combinePredictions(Prediction[] predictions) {
 		DoubleVector sums = new DoubleVector();
 		for (Prediction p : predictions) {
@@ -27,7 +28,7 @@ public Prediction combinePredictions(Prediction[] predictions) {
 	@Override
 	public void getModelDescription(StringBuilder out, int indent) {
 		// TODO Auto-generated method stub
-		
+
 	}
-	
+
 }
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBagAdwinClassification.java b/moa/src/main/java/moa/learners/predictors/meta/classifiers/OzaBagAdwin.java
similarity index 65%
rename from moa/src/main/java/moa/classifiers/meta/OzaBagAdwinClassification.java
rename to moa/src/main/java/moa/learners/predictors/meta/classifiers/OzaBagAdwin.java
index ae568d20e..3dec07915 100644
--- a/moa/src/main/java/moa/classifiers/meta/OzaBagAdwinClassification.java
+++ b/moa/src/main/java/moa/learners/predictors/meta/classifiers/OzaBagAdwin.java
@@ -1,24 +1,27 @@
-package moa.classifiers.meta;
+package moa.learners.predictors.meta.classifiers;
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.predictions.MultiTargetRegressionPrediction;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
 import moa.core.DoubleVector;
-import moa.learners.Classifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.meta.AbstractOzaBagAdwin;
 
-public class OzaBagAdwinClassification extends AbstractOzaBagAdwin<Classifier> implements Classifier{
+public class OzaBagAdwin extends AbstractOzaBagAdwin<Classifier> implements Classifier {
 
 	private static final long serialVersionUID = 1L;
 
-	public OzaBagAdwinClassification() {
-		super(Classifier.class, "moa.classifiers.trees.HoeffdingTree");
+	public OzaBagAdwin() {
+		super(Classifier.class, "trees.HoeffdingTree");
 	}
 
+	@Override
 	public double getAdwinError(Instance inst, int i) {
 		return this.ensemble.get(i).correctlyClassifies(inst) ? 0 : 1;
 	}
 
+	@Override
 	public Prediction combinePredictions(Prediction[] predictions) {
 		DoubleVector sums = new DoubleVector();
 		for (Prediction p : predictions) {
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBoostClassification.java b/moa/src/main/java/moa/learners/predictors/meta/classifiers/OzaBoost.java
similarity index 76%
rename from moa/src/main/java/moa/classifiers/meta/OzaBoostClassification.java
rename to moa/src/main/java/moa/learners/predictors/meta/classifiers/OzaBoost.java
index 8edb3d2f4..b8c3f6e13 100644
--- a/moa/src/main/java/moa/classifiers/meta/OzaBoostClassification.java
+++ b/moa/src/main/java/moa/learners/predictors/meta/classifiers/OzaBoost.java
@@ -1,18 +1,19 @@
-package moa.classifiers.meta;
+package moa.learners.predictors.meta.classifiers;
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
 import moa.core.DoubleVector;
-import moa.learners.Classifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.meta.AbstractOzaBoost;
 
-public class OzaBoostClassification extends AbstractOzaBoost<Classifier> implements Classifier {
+public class OzaBoost extends AbstractOzaBoost<Classifier> implements Classifier {
 
 	private static final long serialVersionUID = 1L;
 
-	public OzaBoostClassification() {
-		super(Classifier.class, "moa.classifiers.trees.HoeffdingTree");
+	public OzaBoost() {
+		super(Classifier.class, "trees.HoeffdingTree");
 	}
 
 	@Override
diff --git a/moa/src/main/java/moa/classifiers/mlc/BasicMultiLabelLearner.java b/moa/src/main/java/moa/learners/predictors/meta/mlc/LocalMultiLabelClassifier.java
similarity index 55%
rename from moa/src/main/java/moa/classifiers/mlc/BasicMultiLabelLearner.java
rename to moa/src/main/java/moa/learners/predictors/meta/mlc/LocalMultiLabelClassifier.java
index 7ed697068..6cc30e2f2 100644
--- a/moa/src/main/java/moa/classifiers/mlc/BasicMultiLabelLearner.java
+++ b/moa/src/main/java/moa/learners/predictors/meta/mlc/LocalMultiLabelClassifier.java
@@ -17,62 +17,50 @@
  *
  *
  */
-package moa.classifiers.mlc;
+package moa.learners.predictors.meta.mlc;
 
-import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.AbstractMultiLabelClassifier;
-
-import moa.classifiers.rules.AMRulesRegressor;
 import moa.core.FastVector;
 import moa.core.Measurement;
 import moa.core.StringUtils;
-import moa.learners.Classifier;
-import moa.learners.InstanceLearner;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.AbstractMultiLabelClassifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.InstanceLearner;
+import moa.learners.predictors.rules.AMRulesRegressor;
 import moa.options.ClassOption;
-import moa.streams.InstanceStream;
-
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Attribute;
-import com.yahoo.labs.samoa.instances.DenseInstance;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.MultiLabelInstance;
-
-
-import java.util.Arrays;;
+import moa.streams.InstanceStream;;
 
 /**
  * Binary relevance Multilabel Classifier
  *
  */
 
+public class LocalMultiLabelClassifier extends AbstractMultiLabelClassifier {
 
-public class BasicMultiLabelLearner extends AbstractMultiLabelClassifier {
-	
 //	public IntOption randomSeedOption = new IntOption("randomSeedOption",
-//			'r', "randomSeedOption", 
+//			'r', "randomSeedOption",
 //			1,Integer.MIN_VALUE, Integer.MAX_VALUE);
 
-	public BasicMultiLabelLearner() {
-		super.randomSeedOption=randomSeedOption;
+	public LocalMultiLabelClassifier() {
+		super.randomSeedOption = randomSeedOption;
 		init();
 	}
 
 	protected void init() {
-		baseLearnerOption = new ClassOption("baseLearner", 'l',
-				"Classifier to train.", Classifier.class, AMRulesRegressor.class.getName());
+		baseLearnerOption = new ClassOption("baseLearner", 'l', "Classifier to train.", Classifier.class,
+				AMRulesRegressor.class.getName());
 	}
 
 	private static final long serialVersionUID = 1L;
 
-	public ClassOption baseLearnerOption; //rules.AMRules"); 
+	public ClassOption baseLearnerOption; // rules.AMRules");
 
 	protected Classifier[] ensemble;
 
@@ -81,8 +69,8 @@ protected void init() {
 	@Override
 	public void resetLearningImpl() {
 		this.hasStarted = false;
-		if(ensemble!=null){
-			for (int i=0; i<ensemble.length; i++){
+		if (ensemble != null) {
+			for (int i = 0; i < ensemble.length; i++) {
 				ensemble[i].resetLearning();
 			}
 		}
@@ -90,10 +78,10 @@ public void resetLearningImpl() {
 
 	@Override
 	public void trainOnInstanceImpl(Instance instance) {
-		if (this.hasStarted == false){		
+		if (this.hasStarted == false) {
 			this.ensemble = new Classifier[instance.numOutputAttributes()];
 			InstanceLearner baseLearner = (InstanceLearner) getPreparedClassOption(this.baseLearnerOption);
-			if(baseLearner.isRandomizable())
+			if (baseLearner.isRandomizable())
 				baseLearner.setRandomSeed(this.randomSeed);
 			baseLearner.resetLearning();
 			for (int i = 0; i < this.ensemble.length; i++) {
@@ -102,8 +90,8 @@ public void trainOnInstanceImpl(Instance instance) {
 			this.hasStarted = true;
 		}
 		for (int i = 0; i < this.ensemble.length; i++) {
-			Instance weightedInst = transformInstance(instance,i);
-			this.ensemble[i].trainOnInstance(weightedInst); 
+			Instance weightedInst = transformInstance(instance, i);
+			this.ensemble[i].trainOnInstance(weightedInst);
 		}
 	}
 
@@ -114,21 +102,22 @@ protected Instance transformInstance(Instance inst, int outputIndex) {
 			this.header = new InstancesHeader[this.ensemble.length];
 		}
 		if (header[outputIndex] == null) {
-			//Create Header
+			// Create Header
 			FastVector<Attribute> attributes = new FastVector<>();
 			for (int attributeIndex = 0; attributeIndex < inst.numInputAttributes(); attributeIndex++) {
 				attributes.addElement(inst.inputAttribute(attributeIndex));
 			}
-			//System.out.println("Number of attributes: "+this.numAttributes+ ","+inst.numAttributes());
+			// System.out.println("Number of attributes: "+this.numAttributes+
+			// ","+inst.numAttributes());
 			attributes.addElement(inst.outputAttribute(outputIndex));
-			this.header[outputIndex] =  new InstancesHeader(getCLICreationString(InstanceStream.class), attributes, 0);
-			this.header[outputIndex].setClassIndex(attributes.size()-1);
+			this.header[outputIndex] = new InstancesHeader(getCLICreationString(InstanceStream.class), attributes, 0);
+			this.header[outputIndex].setClassIndex(attributes.size() - 1);
 			this.ensemble[outputIndex].setModelContext(this.header[outputIndex]);
 		}
-		//Instance instance = new DenseInstance(this.numAttributes+1);
-		//instance.setDataset(dataset[classifierIndex]);
+		// Instance instance = new DenseInstance(this.numAttributes+1);
+		// instance.setDataset(dataset[classifierIndex]);
 		int numAttributes = this.header[outputIndex].numInputAttributes();
-		double[] attVals = new double[numAttributes+1]; //JD - +1 for class
+		double[] attVals = new double[numAttributes + 1]; // JD - +1 for class
 		for (int attributeIndex = 0; attributeIndex < numAttributes; attributeIndex++) {
 			attVals[attributeIndex] = inst.valueInputAttribute(attributeIndex);
 		}
@@ -141,72 +130,67 @@ protected Instance transformInstance(Instance inst, int outputIndex) {
 		return instance;
 	}
 
-
 	@Override
 	public boolean isRandomizable() {
 		return true;
 	}
 
-
 	@Override
 	protected Measurement[] getModelMeasurementsImpl() {
-		Measurement [] baseLearnerMeasurements=((Classifier) getPreparedClassOption(this.baseLearnerOption)).getModelMeasurements();
-		int nMeasurements=baseLearnerMeasurements.length;
-		Measurement [] m=new Measurement[nMeasurements];
-
-		if(this.ensemble !=null){	
-			int ensembleSize=this.ensemble.length;
-			for(int i=0; i<nMeasurements; i++){
-				double value=0;
-				for (int j=0; j<ensembleSize; ++j){
-					value+=ensemble[j].getModelMeasurements()[i].getValue();
+		Measurement[] baseLearnerMeasurements = ((Classifier) getPreparedClassOption(this.baseLearnerOption))
+				.getModelMeasurements();
+		int nMeasurements = baseLearnerMeasurements.length;
+		Measurement[] m = new Measurement[nMeasurements];
+
+		if (this.ensemble != null) {
+			int ensembleSize = this.ensemble.length;
+			for (int i = 0; i < nMeasurements; i++) {
+				double value = 0;
+				for (int j = 0; j < ensembleSize; ++j) {
+					value += ensemble[j].getModelMeasurements()[i].getValue();
 				}
-				m[i]= new Measurement("Sum " + baseLearnerMeasurements[i].getName(), value);
+				m[i] = new Measurement("Sum " + baseLearnerMeasurements[i].getName(), value);
 			}
-		}
-		else{
-			for(int i=0; i<baseLearnerMeasurements.length; i++)
-				m[i]=baseLearnerMeasurements[i];
+		} else {
+			for (int i = 0; i < baseLearnerMeasurements.length; i++)
+				m[i] = baseLearnerMeasurements[i];
 		}
 		return m;
 	}
 
-
 	@Override
 	public void getModelDescription(StringBuilder out, int indent) {
-		if(ensemble.length>0 && ensemble[0] instanceof AbstractClassifier)
-		{
-			for (int i=0; i<ensemble.length;i++){
-				StringUtils.appendIndented(out,indent+1,"\nModel output attribute #" + i);
-				((AbstractClassifier)ensemble[i]).getModelDescription(out, indent+1);
+		if (ensemble.length > 0 && ensemble[0] instanceof AbstractClassifier) {
+			for (int i = 0; i < ensemble.length; i++) {
+				StringUtils.appendIndented(out, indent + 1, "\nModel output attribute #" + i);
+				((AbstractClassifier) ensemble[i]).getModelDescription(out, indent + 1);
 			}
 		}
 	}
 
-
 	@Override
 	public Prediction getPredictionForInstance(Instance instance) {
-		Prediction prediction=null;
-		
-		if (this.hasStarted){ 
-			prediction=new MultiLabelClassificationPrediction(ensemble.length);
+		Prediction prediction = null;
+
+		if (this.hasStarted) {
+			prediction = new MultiLabelClassificationPrediction(ensemble.length);
 			for (int i = 0; i < this.ensemble.length; i++) {
-				Instance inst = transformInstance(instance,i);
-				double[] votes = this.ensemble[i].getPredictionForInstance(transformInstance(instance,i)).asDoubleArray();
-				
-				if(inst.classAttribute().isNumeric()) {
+				Instance inst = transformInstance(instance, i);
+				double[] votes = this.ensemble[i].getPredictionForInstance(transformInstance(instance, i))
+						.asDoubleArray();
+
+				if (inst.classAttribute().isNumeric()) {
 					prediction.setVote(i, 0, votes[0]);
-				}
-				else {
+				} else {
 					double[] dist = new double[votes.length];
 					double sum = 0;
-					
-					for(int l = 0; l < votes.length; l++) {
+
+					for (int l = 0; l < votes.length; l++) {
 						dist[l] = votes[l];
 						sum += votes[l];
 					}
 
-					for(int l = 0; l < votes.length; l++) {
+					for (int l = 0; l < votes.length; l++) {
 						dist[l] /= sum;
 					}
 
@@ -218,7 +202,4 @@ public Prediction getPredictionForInstance(Instance instance) {
 		return prediction;
 	}
 
-
 }
-
-
diff --git a/moa/src/main/java/moa/learners/predictors/meta/mlc/MEKAClassifier.java b/moa/src/main/java/moa/learners/predictors/meta/mlc/MEKAClassifier.java
new file mode 100644
index 000000000..6a5cbd34b
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/meta/mlc/MEKAClassifier.java
@@ -0,0 +1,174 @@
+/*
+ *    MEKAClassifier.java
+ *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
+ *    @author Jesse Read
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.meta.mlc;
+
+import java.io.Serializable;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.MultiLabelInstance;
+import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
+import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Measurement;
+import moa.learners.predictors.AbstractMultiLabelClassifier;
+import moa.learners.predictors.MultiLabelClassifier;
+import moa.options.WEKAClassOption;
+import weka.classifiers.Classifier;
+import weka.classifiers.UpdateableClassifier;
+
+/**
+ * Wrapper for MEKA classifiers.
+ *
+ * @author Jesse Read
+ * @version $Revision: 1 $
+ */
+public class MEKAClassifier extends AbstractMultiLabelClassifier implements MultiLabelClassifier, Serializable {
+
+	private static final long serialVersionUID = 1L;
+
+	protected SamoaToWekaInstanceConverter instanceConverter;
+
+	@Override
+	public String getPurposeString() {
+		return "Classifier from Meka";
+	}
+
+	public WEKAClassOption baseLearnerOption = new WEKAClassOption("baseLearner", 'l', "Classifier to train.",
+			weka.classifiers.Classifier.class, "meka.classifiers.multilabel.incremental.BRUpdateable");
+
+	protected Classifier classifier;
+
+	protected weka.core.Instances instancesBuffer;
+
+	protected boolean isClassificationEnabled;
+
+	// protected boolean isBufferStoring;
+
+	private int L = 0;
+
+	@Override
+	public void resetLearningImpl() {
+
+		try {
+			// System.out.println(baseLearnerOption.getValue());
+			String[] options = weka.core.Utils.splitOptions(baseLearnerOption.getValueAsCLIString());
+			createWekaClassifier(options);
+		} catch (Exception e) {
+			System.err.println("[ERROR] Creating a new classifier: " + e.getMessage());
+		}
+		isClassificationEnabled = false;
+		// this.isBufferStoring = true;
+		this.instanceConverter = new SamoaToWekaInstanceConverter();
+
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance samoaInstance) {
+		// Convert Samoa instance to Weka instance (as used in Meka)
+		L = samoaInstance.numOutputAttributes();
+		weka.core.Instance x = this.instanceConverter.wekaInstance(samoaInstance);
+		x.dataset().setClassIndex(L);
+
+		if (this.isClassificationEnabled == false) {
+			/*
+			 * INITIALISE
+			 */
+			this.instancesBuffer = new weka.core.Instances(x.dataset());
+			try {
+				instancesBuffer.setClassIndex(L);
+				classifier.buildClassifier(instancesBuffer);
+			} catch (Exception e) {
+				System.err.println("[ERROR] Failed to build classifier, L=" + L);
+				e.printStackTrace();
+				// System.exit(1);
+			}
+			this.isClassificationEnabled = true;
+		} else {
+			/*
+			 * UPDATE
+			 */
+			try {
+				((UpdateableClassifier) classifier).updateClassifier(x);
+			} catch (Exception e) {
+				System.err.println("[ERROR] Failed to update classifier");
+				e.printStackTrace();
+				// System.exit(1);
+			}
+		}
+
+	}
+
+	public Prediction getPredictionForInstance(Instance samoaInstance) {
+
+		MultiLabelClassificationPrediction prediction = new MultiLabelClassificationPrediction(L);
+		double votes[] = new double[L];
+		weka.core.Instance inst = this.instanceConverter.wekaInstance(samoaInstance);
+
+		if (isClassificationEnabled == true) {
+
+			try {
+				votes = this.classifier.distributionForInstance(inst);
+			} catch (Exception e) {
+				System.err.println("[WARNING] Failed to get votes from multi-label classifier (not trained yet?).");
+				// e.printStackTrace();
+				// System.exit(1);
+			}
+			
+			for (int j = 0; j < L; j++) {
+				prediction.setVotes(j, new double[] { 1. - votes[j], votes[j] });
+			}
+
+		}
+		// else there's no model yet... (just return empty prediction).
+
+		return prediction;
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return null;
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		if (classifier != null) {
+			out.append(classifier.toString());
+		}
+	}
+
+	public void createWekaClassifier(String[] options) throws Exception {
+		String classifierName = options[0];
+		String[] newoptions = options.clone();
+		newoptions[0] = "";
+		this.classifier = weka.classifiers.AbstractClassifier.forName(classifierName, newoptions);
+		if (!(this.classifier instanceof UpdateableClassifier)) {
+			// TODO: Non-Updateable MEKA classifiers could also work here.
+			System.err.println("[ERROR] You must use an Updateable Classifier");
+			throw new Exception("Only Updateable MEKA classifiers can be used.");
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/mlc/meta/OzaBagAdwinMultiLabelClassification.java b/moa/src/main/java/moa/learners/predictors/meta/mlc/OzaBagAdwinMultiLabelClassification.java
similarity index 78%
rename from moa/src/main/java/moa/classifiers/mlc/meta/OzaBagAdwinMultiLabelClassification.java
rename to moa/src/main/java/moa/learners/predictors/meta/mlc/OzaBagAdwinMultiLabelClassification.java
index b90e5831a..0af493b1d 100644
--- a/moa/src/main/java/moa/classifiers/mlc/meta/OzaBagAdwinMultiLabelClassification.java
+++ b/moa/src/main/java/moa/learners/predictors/meta/mlc/OzaBagAdwinMultiLabelClassification.java
@@ -1,7 +1,7 @@
 /*
  *    OzaBagAdwinML.java
  *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
- * 
+ *
  *    This program is free software; you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
  *    the Free Software Foundation; either version 3 of the License, or
@@ -14,9 +14,9 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.classifiers.mlc.meta;
+package moa.learners.predictors.meta.mlc;
 
 import com.github.javacliparser.FloatOption;
 import com.yahoo.labs.samoa.instances.Instance;
@@ -24,17 +24,18 @@
 import com.yahoo.labs.samoa.instances.predictions.MultiTargetRegressionPrediction;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-import moa.classifiers.meta.AbstractOzaBagAdwin;
 import moa.core.DoubleVector;
-import moa.learners.MultiLabelClassifier;
+import moa.learners.predictors.MultiLabelClassifier;
+import moa.learners.predictors.meta.AbstractOzaBagAdwin;
 
 /**
  * OzaBagAdwinML: Changes the way to compute accuracy as an input for Adwin
- * 
+ *
  * @author Jesse Read
  * @version $Revision: 1 $
  */
-public class OzaBagAdwinMultiLabelClassification extends AbstractOzaBagAdwin<MultiLabelClassifier> implements MultiLabelClassifier {
+public class OzaBagAdwinMultiLabelClassification extends AbstractOzaBagAdwin<MultiLabelClassifier>
+		implements MultiLabelClassifier {
 
 	private static final long serialVersionUID = 1L;
 
@@ -43,10 +44,9 @@ public OzaBagAdwinMultiLabelClassification() {
 		super(MultiLabelClassifier.class, "");
 	}
 
-	public FloatOption splitConfidenceOption = new FloatOption(
-			"classificationThreshold", 't', "The threhshold a label must pass to be predicted as present.",
-			0.5, 0.0, 1.0);
-     
+	public FloatOption splitConfidenceOption = new FloatOption("classificationThreshold", 't',
+			"The threhshold a label must pass to be predicted as present.", 0.5, 0.0, 1.0);
+
 	public void trainOnInstanceImpl(MultiLabelInstance instance) {
 		this.trainOnInstanceImpl((Instance) instance);
 	}
@@ -60,22 +60,23 @@ public double getAdwinError(Instance inst, int i) {
 		double actual[] = new double[inst.numOutputAttributes()];
 		double prediction[] = this.ensemble.get(i).getPredictionForInstance(inst).asDoubleArray();
 		for (int j = 0; j < inst.numOutputAttributes(); j++) {
-			actual[j] = (double)inst.valueOutputAttribute(j);
+			actual[j] = inst.valueOutputAttribute(j);
 		}
 
 		// compute loss
-		//double loss = Metrics.L_ZeroOne(A.toIntArray(actual,0.5), A.toIntArray(prediction,0.5));
-		//System.err.println("loss["+i+"] = "+loss);
+		// double loss = Metrics.L_ZeroOne(A.toIntArray(actual,0.5),
+		// A.toIntArray(prediction,0.5));
+		// System.err.println("loss["+i+"] = "+loss);
 
 		int set_union = 0;
 		int set_inter = 0;
 		double t = 0.01;
-		for(int j = 0; j < prediction.length; j++) {
+		for (int j = 0; j < prediction.length; j++) {
 			int p = (prediction[j] >= t) ? 1 : 0;
 			int R = (int) actual[j];
-			if (p==1) {
+			if (p == 1) {
 				// predt 1, real 1
-				if(R==1) {
+				if (R == 1) {
 					set_inter++;
 					set_union++;
 				}
@@ -83,23 +84,23 @@ public double getAdwinError(Instance inst, int i) {
 				else {
 					set_union++;
 				}
-			}
-			else {                      
+			} else {
 				// predt 0, real 1
-				if(R==1) { 
+				if (R == 1) {
 					set_union++;
 				}
 				// predt 0, real 0
-				else {   
+				else {
 				}
 			}
 		}
 		double accuracy = 0.0;
-		if(set_union > 0)	//avoid NaN
+		if (set_union > 0) // avoid NaN
 			accuracy = ((double) set_inter / (double) set_union);
 		return 1 - accuracy;
 	}
 
+	@Override
 	public Prediction combinePredictions(Prediction[] predictions) {
 		DoubleVector sums = new DoubleVector();
 		for (Prediction p : predictions) {
@@ -110,4 +111,3 @@ public Prediction combinePredictions(Prediction[] predictions) {
 	}
 
 }
-
diff --git a/moa/src/main/java/moa/classifiers/mlc/meta/OzaBagMultiLabelClassification.java b/moa/src/main/java/moa/learners/predictors/meta/mlc/OzaBagMultiLabelClassification.java
similarity index 81%
rename from moa/src/main/java/moa/classifiers/mlc/meta/OzaBagMultiLabelClassification.java
rename to moa/src/main/java/moa/learners/predictors/meta/mlc/OzaBagMultiLabelClassification.java
index d0209c7ea..c8adcf672 100644
--- a/moa/src/main/java/moa/classifiers/mlc/meta/OzaBagMultiLabelClassification.java
+++ b/moa/src/main/java/moa/learners/predictors/meta/mlc/OzaBagMultiLabelClassification.java
@@ -1,7 +1,7 @@
 /*
  *    OzaBagML.java
  *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
- * 
+ *
  *    This program is free software; you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
  *    the Free Software Foundation; either version 3 of the License, or
@@ -14,35 +14,36 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.classifiers.mlc.meta;
+package moa.learners.predictors.meta.mlc;
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.predictions.MultiTargetRegressionPrediction;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-import moa.classifiers.meta.AbstractOzaBag;
 import moa.core.DoubleVector;
-import moa.learners.MultiLabelClassifier;
+import moa.learners.predictors.MultiLabelClassifier;
+import moa.learners.predictors.meta.AbstractOzaBag;
 
 /**
  * OzaBag for Multi-label data.
- * 
+ *
  * @author Jesse Read
  * @version $Revision: 1 $
  */
-public class OzaBagMultiLabelClassification extends AbstractOzaBag<MultiLabelClassifier> implements MultiLabelClassifier {
+public class OzaBagMultiLabelClassification extends AbstractOzaBag<MultiLabelClassifier>
+		implements MultiLabelClassifier {
 
 	private static final long serialVersionUID = 1L;
 
 	public OzaBagMultiLabelClassification() {
-    	super(MultiLabelClassifier.class, "multilabel.trees.ISOUPTree");
-    }
+		super(MultiLabelClassifier.class, "multilabel.trees.ISOUPTree");
+	}
 
 	@Override
 	public Prediction getPredictionForInstance(Instance inst) {
-		return this.getPredictionForInstance((Instance) inst);
+		return this.getPredictionForInstance(inst);
 	}
 
 	@Override
@@ -57,9 +58,8 @@ public Prediction combinePredictions(Prediction[] predictions) {
 
 	@Override
 	public void trainOnInstanceImpl(Instance inst) {
-		this.trainOnInstanceImpl((Instance) inst);
-		
+		this.trainOnInstanceImpl(inst);
+
 	}
-    
-}
 
+}
diff --git a/moa/src/main/java/moa/learners/predictors/meta/mtr/AdaptiveRandomForest.java b/moa/src/main/java/moa/learners/predictors/meta/mtr/AdaptiveRandomForest.java
new file mode 100644
index 000000000..39b733069
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/meta/mtr/AdaptiveRandomForest.java
@@ -0,0 +1,523 @@
+/*
+ *    AdaptiveRandomForest.java
+ *
+ *    @author Heitor Murilo Gomes (heitor_murilo_gomes at yahoo dot com dot br)
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ */
+package moa.learners.predictors.meta.mtr;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.MultiTargetRegressionPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.AbstractMOAObject;
+// import moa.learners.predictors.MultiClassClassifier;
+import moa.core.DoubleVector;
+import moa.core.InstanceExample;
+import moa.core.Measurement;
+import moa.core.MiscUtils;
+import moa.evaluation.evaluators.BasicClassificationPerformanceEvaluator;
+import moa.learners.predictors.AbstractMultiTargetRegressor;
+import moa.learners.predictors.MultiTargetRegressor;
+import moa.learners.predictors.core.driftdetection.ChangeDetector;
+import moa.learners.predictors.trees.ISOUPTree;
+import moa.learners.predictors.trees.ISOUPTreeRF;
+import moa.options.ClassOption;
+
+/**
+ * Adaptive Random Forest
+ *
+ * <p>
+ * Adaptive Random Forest (ARF). The 3 most important aspects of this ensemble
+ * classifier are: (1) inducing diversity through resampling; (2) inducing
+ * diversity through randomly selecting subsets of features for node splits (See
+ * moa.learners.predictors.trees.ARFHoeffdingTree.java); (3) drift detectors per base
+ * tree, which cause selective resets in response to drifts. It also allows
+ * training background trees, which start training if a warning is detected and
+ * replace the active tree if the warning escalates to a drift.
+ * </p>
+ *
+ * <p>
+ * See details in:<br>
+ * Heitor Murilo Gomes, Albert Bifet, Jesse Read, Jean Paul Barddal, Fabricio
+ * Enembreck, Bernhard Pfharinger, Geoff Holmes, Talel Abdessalem. Adaptive
+ * random forests for evolving data stream classification. In Machine Learning,
+ * DOI: 10.1007/s10994-017-5642-8, Springer, 2017.
+ * </p>
+ *
+ * <p>
+ * Parameters:
+ * </p>
+ * <ul>
+ * <li>-l : Classifier to train. Must be set to ARFHoeffdingTree</li>
+ * <li>-s : The number of trees in the ensemble</li>
+ * <li>-o : How the number of features is interpreted (4 options): "Specified m
+ * (integer value)", "sqrt(M)+1", "M-(sqrt(M)+1)"</li>
+ * <li>-m : Number of features allowed considered for each split. Negative
+ * values corresponds to M - m</li>
+ * <li>-a : The lambda value for bagging (lambda=6 corresponds to levBag)</li>
+ * <li>-j : Number of threads to be used for training</li>
+ * <li>-x : Change detector for drifts and its parameters</li>
+ * <li>-p : Change detector for warnings (start training bkg learner)</li>
+ * <li>-w : Should use weighted voting?</li>
+ * <li>-u : Should use drift detection? If disabled then bkg learner is also
+ * disabled</li>
+ * <li>-q : Should use bkg learner? If disabled then reset tree immediately</li>
+ * </ul>
+ *
+ * @author Heitor Murilo Gomes (heitor_murilo_gomes at yahoo dot com dot br)
+ * @version $Revision: 1 $
+ */
+public class AdaptiveRandomForest extends AbstractMultiTargetRegressor
+		implements MultiTargetRegressor {
+
+	@Override
+	public String getPurposeString() {
+		return "Adaptive Random Forest algorithm for evolving data streams from Gomes et al.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption treeLearnerOption = new ClassOption("treeLearner", 'l', "Random Forest Tree.",
+			MultiTargetRegressor.class, "iSOUPTreeRF");
+
+	public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's', "The number of trees.", 10, 1,
+			Integer.MAX_VALUE);
+
+	public MultiChoiceOption mFeaturesModeOption = new MultiChoiceOption("mFeaturesMode", 'o',
+			"Defines how m, defined by mFeaturesPerTreeSize, is interpreted. M represents the total number of features.",
+			new String[] { "Specified m (integer value)", "sqrt(M)+1", "M-(sqrt(M)+1)", "Percentage (M * (m / 100))" },
+			new String[] { "SpecifiedM", "SqrtM1", "MSqrtM1", "Percentage" }, 1);
+
+	public IntOption mFeaturesPerTreeSizeOption = new IntOption("mFeaturesPerTreeSize", 'm',
+			"Number of features allowed considered for each split. Negative values corresponds to M - m", 2,
+			Integer.MIN_VALUE, Integer.MAX_VALUE);
+
+	public FloatOption lambdaOption = new FloatOption("lambda", 'a', "The lambda parameter for bagging.", 6.0, 1.0,
+			Float.MAX_VALUE);
+
+	public IntOption numberOfJobsOption = new IntOption("numberOfJobs", 'j',
+			"Total number of concurrent jobs used for processing (-1 = as much as possible, 0 = do not use multithreading)",
+			1, -1, Integer.MAX_VALUE);
+
+	public ClassOption driftDetectionMethodOption = new ClassOption("driftDetectionMethod", 'x',
+			"Change detector for drifts and its parameters", ChangeDetector.class, "ADWINChangeDetector -a 1.0E-5");
+
+	public ClassOption warningDetectionMethodOption = new ClassOption("warningDetectionMethod", 'p',
+			"Change detector for warnings (start training bkg learner)", ChangeDetector.class,
+			"ADWINChangeDetector -a 1.0E-4");
+
+	public FlagOption disableWeightedVote = new FlagOption("disableWeightedVote", 'w', "Should use weighted voting?");
+
+	public FlagOption disableDriftDetectionOption = new FlagOption("disableDriftDetection", 'u',
+			"Should use drift detection? If disabled then bkg learner is also disabled");
+
+	public FlagOption disableBackgroundLearnerOption = new FlagOption("disableBackgroundLearner", 'q',
+			"Should use bkg learner? If disabled then reset tree immediately.");
+
+	protected static final int FEATURES_M = 0;
+	protected static final int FEATURES_SQRT = 1;
+	protected static final int FEATURES_SQRT_INV = 2;
+	protected static final int FEATURES_PERCENT = 3;
+
+	protected static final int SINGLE_THREAD = 0;
+
+	protected ARFBaseLearnerMTR[] ensemble;
+	protected long instancesSeen;
+	protected int subspaceSize;
+	protected BasicClassificationPerformanceEvaluator evaluator;
+
+	private ExecutorService executor;
+
+	@Override
+	public void resetLearningImpl() {
+		// Reset attributes
+		this.ensemble = null;
+		this.subspaceSize = 0;
+		this.instancesSeen = 0;
+		this.evaluator = new BasicClassificationPerformanceEvaluator();
+
+		// Multi-threading
+		int numberOfJobs;
+		if (this.numberOfJobsOption.getValue() == -1)
+			numberOfJobs = Runtime.getRuntime().availableProcessors();
+		else
+			numberOfJobs = this.numberOfJobsOption.getValue();
+		// SINGLE_THREAD and requesting for only 1 thread are equivalent.
+		// this.executor will be null and not used...
+		if (numberOfJobs != AdaptiveRandomForest.SINGLE_THREAD && numberOfJobs != 1)
+			this.executor = Executors.newFixedThreadPool(numberOfJobs);
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance instance) {
+		++this.instancesSeen;
+		if (this.ensemble == null)
+			initEnsemble(instance);
+
+		Collection<TrainingRunnable> trainers = new ArrayList<>();
+		for (int i = 0; i < this.ensemble.length; i++) {
+			DoubleVector vote = this.ensemble[i].getPredictionForInstance(instance).asDoubleVector();
+			InstanceExample example = new InstanceExample(instance);
+			this.ensemble[i].evaluator.addResult(example, vote.getArrayRef());
+			int k = MiscUtils.poisson(this.lambdaOption.getValue(), this.classifierRandom);
+			if (k > 0) {
+				if (this.executor != null) {
+					TrainingRunnable trainer = new TrainingRunnable(this.ensemble[i], instance, k, this.instancesSeen);
+					trainers.add(trainer);
+				} else { // SINGLE_THREAD is in-place...
+					this.ensemble[i].trainOnInstance(instance, k, this.instancesSeen);
+				}
+			}
+		}
+		if (this.executor != null) {
+			try {
+				this.executor.invokeAll(trainers);
+			} catch (InterruptedException ex) {
+				throw new RuntimeException("Could not call invokeAll() on training threads.");
+			}
+		}
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance instance) {
+		Instance testInstance = instance.copy();
+		if (this.ensemble == null)
+			initEnsemble(testInstance);
+		DoubleVector combinedVote = new DoubleVector();
+
+		for (int i = 0; i < this.ensemble.length; ++i) {
+			DoubleVector vote = this.ensemble[i].getPredictionForInstance(testInstance).asDoubleVector();
+			if (vote.sumOfValues() > 0.0) {
+				vote.normalize();
+				double acc = this.ensemble[i].evaluator.getPerformanceMeasurements()[1].getValue();
+				if (!this.disableWeightedVote.isSet() && acc > 0.0) {
+					for (int v = 0; v < vote.numValues(); ++v) {
+						vote.setValue(v, vote.getValue(v) * acc);
+					}
+				}
+				combinedVote.addValues(vote);
+			}
+		}
+		return new MultiTargetRegressionPrediction(combinedVote);
+	}
+
+	// @Override
+	public double[] getVotesForInstance(Instance instance) {
+		Instance testInstance = instance.copy();
+		if (this.ensemble == null)
+			initEnsemble(testInstance);
+		DoubleVector combinedVote = new DoubleVector();
+
+		for (int i = 0; i < this.ensemble.length; ++i) {
+			DoubleVector vote = new DoubleVector(this.ensemble[i].getVotesForInstance(testInstance));
+			if (vote.sumOfValues() > 0.0) {
+				vote.normalize();
+				double acc = this.ensemble[i].evaluator.getPerformanceMeasurements()[1].getValue();
+				if (!this.disableWeightedVote.isSet() && acc > 0.0) {
+					for (int v = 0; v < vote.numValues(); ++v) {
+						vote.setValue(v, vote.getValue(v) * acc);
+					}
+				}
+				combinedVote.addValues(vote);
+			}
+		}
+		return combinedVote.getArrayRef();
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder arg0, int arg1) {
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return null;
+	}
+
+	protected void initEnsemble(Instance instance) {
+		// Init the ensemble.
+		int ensembleSize = this.ensembleSizeOption.getValue();
+		this.ensemble = new ARFBaseLearnerMTR[ensembleSize];
+
+		// TODO: this should be an option with default =
+		// BasicClassificationPerformanceEvaluator
+//        BasicClassificationPerformanceEvaluator classificationEvaluator = (BasicClassificationPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
+		BasicClassificationPerformanceEvaluator classificationEvaluator = new BasicClassificationPerformanceEvaluator();
+
+		this.subspaceSize = this.mFeaturesPerTreeSizeOption.getValue();
+
+		// The size of m depends on:
+		// 1) mFeaturesPerTreeSizeOption
+		// 2) mFeaturesModeOption
+		int n = instance.numAttributes() - 1; // Ignore class label ( -1 )
+
+		switch (this.mFeaturesModeOption.getChosenIndex()) {
+		case AdaptiveRandomForest.FEATURES_SQRT:
+			this.subspaceSize = (int) Math.round(Math.sqrt(n)) + 1;
+			break;
+		case AdaptiveRandomForest.FEATURES_SQRT_INV:
+			this.subspaceSize = n - (int) Math.round(Math.sqrt(n) + 1);
+			break;
+		case AdaptiveRandomForest.FEATURES_PERCENT:
+			// If subspaceSize is negative, then first find out the actual percent, i.e.,
+			// 100% - m.
+			double percent = this.subspaceSize < 0 ? (100 + this.subspaceSize) / 100.0 : this.subspaceSize / 100.0;
+			this.subspaceSize = (int) Math.round(n * percent);
+			break;
+		}
+		// Notice that if the selected mFeaturesModeOption was
+		// AdaptiveRandomForest.FEATURES_M then nothing is performed in the
+		// previous switch-case, still it is necessary to check (and adjusted)
+		// for when a negative value was used.
+
+		// m is negative, use size(features) + -m
+		if (this.subspaceSize < 0)
+			this.subspaceSize = n + this.subspaceSize;
+		// Other sanity checks to avoid runtime errors.
+		// m <= 0 (m can be negative if this.subspace was negative and
+		// abs(m) > n), then use m = 1
+		if (this.subspaceSize <= 0)
+			this.subspaceSize = 1;
+		// m > n, then it should use n
+		if (this.subspaceSize > n)
+			this.subspaceSize = n;
+
+		ISOUPTreeRF treeLearner = (ISOUPTreeRF) getPreparedClassOption(this.treeLearnerOption);
+		treeLearner.resetLearning();
+
+		for (int i = 0; i < ensembleSize; ++i) {
+			treeLearner.subspaceSize = this.subspaceSize;
+			this.ensemble[i] = new ARFBaseLearnerMTR(i, (ISOUPTreeRF) treeLearner.copy(),
+					(BasicClassificationPerformanceEvaluator) classificationEvaluator.copy(), this.instancesSeen,
+					!this.disableBackgroundLearnerOption.isSet(), !this.disableDriftDetectionOption.isSet(),
+					driftDetectionMethodOption, warningDetectionMethodOption, false);
+		}
+	}
+
+	/**
+	 * Inner class that represents a single tree member of the forest. It contains
+	 * some analysis information, such as the numberOfDriftsDetected,
+	 */
+	protected final class ARFBaseLearnerMTR extends AbstractMOAObject {
+		public int indexOriginal;
+		public long createdOn;
+		public long lastDriftOn;
+		public long lastWarningOn;
+		public ISOUPTreeRF classifier;
+		public boolean isBackgroundLearner;
+
+		// The drift and warning object parameters.
+		protected ClassOption driftOption;
+		protected ClassOption warningOption;
+
+		// Drift and warning detection
+		protected ChangeDetector driftDetectionMethod;
+		protected ChangeDetector warningDetectionMethod;
+
+		public boolean useBkgLearner;
+		public boolean useDriftDetector;
+
+		// Bkg learner
+		protected ARFBaseLearnerMTR bkgLearner;
+		// Statistics
+		public BasicClassificationPerformanceEvaluator evaluator;
+		protected int numberOfDriftsDetected;
+		protected int numberOfWarningsDetected;
+
+		private void init(int indexOriginal, ISOUPTreeRF instantiatedClassifier,
+				BasicClassificationPerformanceEvaluator evaluatorInstantiated, long instancesSeen,
+				boolean useBkgLearner, boolean useDriftDetector, ClassOption driftOption, ClassOption warningOption,
+				boolean isBackgroundLearner) {
+			this.indexOriginal = indexOriginal;
+			this.createdOn = instancesSeen;
+			this.lastDriftOn = 0;
+			this.lastWarningOn = 0;
+
+			this.classifier = instantiatedClassifier;
+			this.evaluator = evaluatorInstantiated;
+			this.useBkgLearner = useBkgLearner;
+			this.useDriftDetector = useDriftDetector;
+
+			this.numberOfDriftsDetected = 0;
+			this.numberOfWarningsDetected = 0;
+			this.isBackgroundLearner = isBackgroundLearner;
+
+			if (this.useDriftDetector) {
+				this.driftOption = driftOption;
+				this.driftDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.driftOption)).copy();
+			}
+
+			// Init Drift Detector for Warning detection.
+			if (this.useBkgLearner) {
+				this.warningOption = warningOption;
+				this.warningDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.warningOption)).copy();
+			}
+		}
+
+		public ARFBaseLearnerMTR(int indexOriginal, ISOUPTreeRF instantiatedClassifier,
+				BasicClassificationPerformanceEvaluator evaluatorInstantiated, long instancesSeen,
+				boolean useBkgLearner, boolean useDriftDetector, ClassOption driftOption, ClassOption warningOption,
+				boolean isBackgroundLearner) {
+			init(indexOriginal, instantiatedClassifier, evaluatorInstantiated, instancesSeen, useBkgLearner,
+					useDriftDetector, driftOption, warningOption, isBackgroundLearner);
+		}
+
+		public void reset() {
+			if (this.useBkgLearner && this.bkgLearner != null) {
+				this.classifier = this.bkgLearner.classifier;
+
+				this.driftDetectionMethod = this.bkgLearner.driftDetectionMethod;
+				this.warningDetectionMethod = this.bkgLearner.warningDetectionMethod;
+
+				this.evaluator = this.bkgLearner.evaluator;
+				this.createdOn = this.bkgLearner.createdOn;
+				this.bkgLearner = null;
+			} else {
+				this.classifier.resetLearning();
+				this.createdOn = instancesSeen;
+				this.driftDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.driftOption)).copy();
+			}
+			this.evaluator.reset();
+		}
+
+		public void trainOnInstance(Instance instance, double weight, long instancesSeen) {
+			Instance weightedInstance = instance.copy();
+			weightedInstance.setWeight(instance.weight() * weight);
+			this.classifier.trainOnInstance(weightedInstance);
+
+			if (this.bkgLearner != null)
+				this.bkgLearner.classifier.trainOnInstance(instance);
+
+			// Should it use a drift detector? Also, is it a backgroundLearner? If so, then
+			// do not "incept" another one.
+			if (this.useDriftDetector && !this.isBackgroundLearner) {
+				// boolean correctlyClassifies = this.classifier.(instance);
+				// public double getAdwinError(Instance inst, int i) {
+				double sum = 0.0;
+				if (this.classifier instanceof ISOUPTree) {
+					double[] normalizedError = ((ISOUPTree) this.classifier).getNormalizedError(instance,
+							this.classifier.getPredictionForInstance(instance).asDoubleArray());
+					for (int j = 0; j < instance.numOutputAttributes(); j++) {
+						sum += normalizedError[j];
+					}
+				} else {
+					Prediction prediction = this.classifier.getPredictionForInstance(instance);
+					for (int j = 0; j < instance.numOutputAttributes(); j++) {
+						sum += Math.abs(prediction.getPrediction(j) - instance.valueOutputAttribute(j));
+					}
+				}
+				sum = sum / instance.numOutputAttributes();
+				// return sum;
+				// }
+				// Check for warning only if useBkgLearner is active
+				if (this.useBkgLearner) {
+					// Update the warning detection method
+					this.warningDetectionMethod.input(sum);
+					// Check if there was a change
+					if (this.warningDetectionMethod.getChange()) {
+						this.lastWarningOn = instancesSeen;
+						this.numberOfWarningsDetected++;
+						// Create a new bkgTree classifier
+						ISOUPTreeRF bkgClassifier = (ISOUPTreeRF) this.classifier.copy();
+						bkgClassifier.resetLearning();
+
+						// Resets the evaluator
+						BasicClassificationPerformanceEvaluator bkgEvaluator = (BasicClassificationPerformanceEvaluator) this.evaluator
+								.copy();
+						bkgEvaluator.reset();
+
+						// Create a new bkgLearner object
+						this.bkgLearner = new ARFBaseLearnerMTR(indexOriginal, bkgClassifier, bkgEvaluator,
+								instancesSeen, this.useBkgLearner, this.useDriftDetector, this.driftOption,
+								this.warningOption, true);
+
+						// Update the warning detection object for the current object
+						// (this effectively resets changes made to the object while it was still a bkg
+						// learner).
+						this.warningDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.warningOption))
+								.copy();
+					}
+				}
+
+				/*********** drift detection ***********/
+
+				// Update the DRIFT detection method
+				this.driftDetectionMethod.input(sum);
+				// Check if there was a change
+				if (this.driftDetectionMethod.getChange()) {
+					this.lastDriftOn = instancesSeen;
+					this.numberOfDriftsDetected++;
+					this.reset();
+				}
+			}
+		}
+
+		public Prediction getPredictionForInstance(Instance instance) {
+			return this.classifier.getPredictionForInstance(instance);
+		}
+
+		public double[] getVotesForInstance(Instance instance) {
+			DoubleVector vote = new DoubleVector(this.classifier.getPredictionForInstance(instance).asDoubleArray());
+			return vote.getArrayRef();
+		}
+
+		@Override
+		public void getDescription(StringBuilder sb, int indent) {
+		}
+	}
+
+	/***
+	 * Inner class to assist with the multi-thread execution.
+	 */
+	protected class TrainingRunnable implements Runnable, Callable<Integer> {
+		final private ARFBaseLearnerMTR learner;
+		final private Instance instance;
+		final private double weight;
+		final private long instancesSeen;
+
+		public TrainingRunnable(ARFBaseLearnerMTR learner, Instance instance, double weight, long instancesSeen) {
+			this.learner = learner;
+			this.instance = instance;
+			this.weight = weight;
+			this.instancesSeen = instancesSeen;
+		}
+
+		@Override
+		public void run() {
+			learner.trainOnInstance(this.instance, this.weight, this.instancesSeen);
+		}
+
+		@Override
+		public Integer call() throws Exception {
+			run();
+			return 0;
+		}
+	}
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/mtr/LocalMultiTargetRegressor.java b/moa/src/main/java/moa/learners/predictors/meta/mtr/LocalMultiTargetRegressor.java
similarity index 67%
rename from moa/src/main/java/moa/classifiers/mtr/LocalMultiTargetRegressor.java
rename to moa/src/main/java/moa/learners/predictors/meta/mtr/LocalMultiTargetRegressor.java
index a83d1cee9..39e76784c 100644
--- a/moa/src/main/java/moa/classifiers/mtr/LocalMultiTargetRegressor.java
+++ b/moa/src/main/java/moa/learners/predictors/meta/mtr/LocalMultiTargetRegressor.java
@@ -1,4 +1,4 @@
-package moa.classifiers.mtr;
+package moa.learners.predictors.meta.mtr;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -10,28 +10,25 @@
 import com.yahoo.labs.samoa.instances.predictions.MultiTargetRegressionPrediction;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-import moa.classifiers.AbstractMultiTargetRegressor;
-import moa.classifiers.AbstractRegressor;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.SizeOf;
-import moa.learners.MultiTargetRegressor;
-import moa.learners.Regressor;
+import moa.core.StringUtils;
+import moa.learners.predictors.AbstractMultiTargetRegressor;
+import moa.learners.predictors.AbstractRegressor;
+import moa.learners.predictors.MultiTargetRegressor;
+import moa.learners.predictors.Regressor;
 import moa.options.ClassOption;
 
-public class LocalMultiTargetRegressor extends AbstractMultiTargetRegressor implements  MultiTargetRegressor {
+public class LocalMultiTargetRegressor extends AbstractMultiTargetRegressor implements MultiTargetRegressor {
 
 	private static final long serialVersionUID = 1L;
 
-	public ClassOption regressorOption = new ClassOption(
-			"regressor",
-			'c',
-			"Single-target regressor to use.",
-			Regressor.class,
-			"moa.classifiers.trees.FIMTDD");
-	
-	ArrayList<Regressor> regressors = null;
-	ArrayList<InstancesHeader> headers = null;
+	public ClassOption regressorOption = new ClassOption("regressor", 'c', "Single-target regressor to use.",
+			Regressor.class, "trees.FIMTDD");
+
+	protected List<Regressor> regressors = null;
+	protected List<InstancesHeader> headers = null;
 
 	@Override
 	public long measureByteSize() {
@@ -43,37 +40,37 @@ public long measureByteSize() {
 		}
 		return size;
 	}
-	
+
 	@Override
 	public boolean isRandomizable() {
 		return true;
 	}
 
 	private InstancesHeader getHeader(int target) {
-		if (headers == null) 
+		if (headers == null)
 			makeHeaders();
 		return headers.get(target);
-	
+
 	}
-	
+
 	private void makeHeaders() {
 		if (headers == null) {
-			headers = new ArrayList<InstancesHeader>();
+			headers = new ArrayList<>();
 			for (int target = 0; target < getModelContext().numOutputAttributes(); target++) {
-				List<Attribute> attributes = new ArrayList<Attribute>();
+				List<Attribute> attributes = new ArrayList<>();
 				for (int i = 0; i < getModelContext().numInputAttributes(); i++) {
 					attributes.add(getModelContext().inputAttribute(i));
 				}
 				attributes.add(getModelContext().outputAttribute(target));
 				InstancesHeader STHeader = new InstancesHeader();
 				STHeader.setAttributes(attributes);
-				STHeader.setInstances(new ArrayList<Instance>()); 
+				STHeader.setInstances(new ArrayList<Instance>());
 				STHeader.setClassIndex(getModelContext().numInputAttributes());
 				headers.add(STHeader);
 			}
 		}
 	}
-	
+
 	private Instance getSTInstance(Instance inst, int target) {
 		double[] instanceData = new double[getModelContext().numInputAttributes() + 1];
 		for (int i = 0; i < inst.numInputAttributes(); i++)
@@ -85,10 +82,10 @@ private Instance getSTInstance(Instance inst, int target) {
 	}
 	
 	@Override
-	public void trainOnInstanceImpl(Instance instance) {		
+	public void trainOnInstanceImpl(Instance instance) {
 		for (int j = 0; j < instance.numOutputAttributes(); j++) {
 			Instance STInst = getSTInstance(instance, j);
-			
+
 			regressors.get(j).trainOnInstance(STInst);
 		}
 	}
@@ -96,7 +93,6 @@ public void trainOnInstanceImpl(Instance instance) {
 	@Override
 	public Prediction getPredictionForInstance(Instance inst) {
 		DoubleVector pred = new DoubleVector();
-		// MultiTargetRegressionPrediction prediction = new MultiTargetRegressionPrediction(getModelContext().numOutputAttributes());
 		for (int j = 0; j < inst.numOutputAttributes(); j++) {
 			Instance STInst = getSTInstance(inst, j);
 			pred.setValue(j, regressors.get(j).getPredictionForInstance(STInst).asDouble());
@@ -104,20 +100,23 @@ public Prediction getPredictionForInstance(Instance inst) {
 		return new MultiTargetRegressionPrediction(pred);
 	}
 
+	
 	@Override
 	public void resetLearningImpl() {
 		regressors = null;
+		headers = null;
 	}
-	
+
+	@Override
 	public void modelContextSet() {
-		initializeClassifiers();
+		initializeRegressors();
 		makeHeaders();
 		for (int i = 0; i < regressors.size(); i++)
 			regressors.get(i).setModelContext(getHeader(i));
 	}
 
-	public void initializeClassifiers() {
-		regressors = new ArrayList<Regressor>();
+	public void initializeRegressors() {
+		regressors = new ArrayList<>();
 		for (int i = 0; i < getModelContext().numOutputAttributes(); i++) {
 			Regressor learner = (Regressor) ((Regressor) getPreparedClassOption(this.regressorOption)).copy();
 			regressors.add(learner);
@@ -125,20 +124,26 @@ public void initializeClassifiers() {
 			((AbstractRegressor) learner).classifierRandom = this.classifierRandom;
 		}
 	}
-	
+
 	@Override
 	protected Measurement[] getModelMeasurementsImpl() {
-		// TODO Auto-generated method stub
-		return null;
+		List<Measurement> combined = new ArrayList<Measurement>();
+		for (int i = 0; i < regressors.size(); i++) {
+			Measurement[] measurements = regressors.get(i).getModelMeasurements();
+			for (Measurement m : measurements) {
+				combined.add(new Measurement(m.getName() + "[" + getModelContext().outputAttribute(i).name() + "]", m.getValue()));
+			}
+					
+		}
+		return (Measurement[]) combined.toArray();
 	}
 
 	@Override
 	public void getModelDescription(StringBuilder out, int indent) {
-		for (int i =0; i < getModelContext().numOutputAttributes(); i++) {
-			out.append(getModelContext().outputAttribute(i).name() + '\n');
-			regressors.get(i).getModelDescription(out, indent);
+		for (int i = 0; i < getModelContext().numOutputAttributes(); i++) {
+			StringUtils.appendIndented(out, indent, getModelContext().outputAttribute(i).name() + ":\n");
+			regressors.get(i).getModelDescription(out, indent + 2);
 		}
 	}
-
+	
 }
- 
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/mlc/meta/OzaBagMultiTargetRegression.java b/moa/src/main/java/moa/learners/predictors/meta/mtr/OzaBag.java
similarity index 77%
rename from moa/src/main/java/moa/classifiers/mlc/meta/OzaBagMultiTargetRegression.java
rename to moa/src/main/java/moa/learners/predictors/meta/mtr/OzaBag.java
index 10c186a83..9a572ae61 100644
--- a/moa/src/main/java/moa/classifiers/mlc/meta/OzaBagMultiTargetRegression.java
+++ b/moa/src/main/java/moa/learners/predictors/meta/mtr/OzaBag.java
@@ -2,7 +2,7 @@
  *    MLOzaBag.java
  *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
  *    @author Jesse Read (jesse@tsc.uc3m.es)
- * 
+ *
  *    This program is free software; you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
  *    the Free Software Foundation; either version 3 of the License, or
@@ -15,35 +15,35 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.classifiers.mlc.meta;
+package moa.learners.predictors.meta.mtr;
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.predictions.MultiTargetRegressionPrediction;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-import moa.classifiers.meta.AbstractOzaBag;
 import moa.core.DoubleVector;
-import moa.learners.MultiTargetRegressor;
+import moa.learners.predictors.MultiTargetRegressor;
+import moa.learners.predictors.meta.AbstractOzaBag;
 
 /**
  * OzaBag for Multi-label data.
- * 
+ *
  * @author Jesse Read (jesse@tsc.uc3m.es)
  * @version $Revision: 1 $
  */
-public class OzaBagMultiTargetRegression extends AbstractOzaBag<MultiTargetRegressor> implements MultiTargetRegressor {
+public class OzaBag extends AbstractOzaBag<MultiTargetRegressor> implements MultiTargetRegressor {
 
 	private static final long serialVersionUID = 1L;
 
-	public OzaBagMultiTargetRegression() {
-    	super(MultiTargetRegressor.class, "moa.classifiers.mtr.trees.ISOUPTree");
-    }
+	public OzaBag() {
+		super(MultiTargetRegressor.class, "mtr.trees.ISOUPTree");
+	}
 
 	@Override
 	public Prediction getPredictionForInstance(Instance inst) {
-		return this.getPredictionForInstance((Instance) inst);
+		return this.getPredictionForInstance(inst);
 	}
 
 	@Override
@@ -58,8 +58,8 @@ public Prediction combinePredictions(Prediction[] predictions) {
 
 	@Override
 	public void trainOnInstanceImpl(Instance inst) {
-		this.trainOnInstanceImpl((Instance) inst);
-		
+		this.trainOnInstanceImpl(inst);
+
 	}
-    
+
 }
diff --git a/moa/src/main/java/moa/classifiers/mlc/meta/OzaBagAdwinMultiTargetRegression.java b/moa/src/main/java/moa/learners/predictors/meta/mtr/OzaBagAdwin.java
similarity index 77%
rename from moa/src/main/java/moa/classifiers/mlc/meta/OzaBagAdwinMultiTargetRegression.java
rename to moa/src/main/java/moa/learners/predictors/meta/mtr/OzaBagAdwin.java
index 94b8298fd..30e31e1da 100644
--- a/moa/src/main/java/moa/classifiers/mlc/meta/OzaBagAdwinMultiTargetRegression.java
+++ b/moa/src/main/java/moa/learners/predictors/meta/mtr/OzaBagAdwin.java
@@ -2,7 +2,7 @@
  *    MLOzaBagAdwin.java
  *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
  *    @author Jesse Read (jesse@tsc.uc3m.es)
- * 
+ *
  *    This program is free software; you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
  *    the Free Software Foundation; either version 3 of the License, or
@@ -15,32 +15,35 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.classifiers.mlc.meta;
+package moa.learners.predictors.meta.mtr;
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.predictions.MultiTargetRegressionPrediction;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-import moa.classifiers.meta.AbstractOzaBagAdwin;
-import moa.classifiers.mtr.trees.ISOUPTree;
 import moa.core.DoubleVector;
-import moa.learners.MultiTargetRegressor;
+import moa.learners.predictors.MultiTargetRegressor;
+import moa.learners.predictors.meta.AbstractOzaBagAdwin;
+import moa.learners.predictors.trees.ISOUPTree;
 
-public class OzaBagAdwinMultiTargetRegression extends AbstractOzaBagAdwin<MultiTargetRegressor> implements MultiTargetRegressor {
+public class OzaBagAdwin extends AbstractOzaBagAdwin<MultiTargetRegressor>
+		implements MultiTargetRegressor {
 
 	private static final long serialVersionUID = 1L;
 
-	public OzaBagAdwinMultiTargetRegression() {
-		super(MultiTargetRegressor.class, "moa.classifiers.mtr.trees.ISOUPTree");
+	public OzaBagAdwin() {
+		super(MultiTargetRegressor.class, "mtr.trees.ISOUPTree");
 	}
 
+	@Override
 	public double getAdwinError(Instance inst, int i) {
 		// TODO this needs a rework
 		double sum = 0.0;
 		if (this.ensemble.get(i) instanceof ISOUPTree) {
-			double[] normalizedError = ((ISOUPTree) this.ensemble.get(i)).getNormalizedError(inst, this.ensemble.get(i).getPredictionForInstance(inst).asDoubleArray());
+			double[] normalizedError = ((ISOUPTree) this.ensemble.get(i)).getNormalizedError(inst,
+					this.ensemble.get(i).getPredictionForInstance(inst).asDoubleArray());
 			for (int j = 0; j < inst.numOutputAttributes(); j++) {
 				sum += normalizedError[j];
 			}
@@ -66,12 +69,12 @@ public Prediction combinePredictions(Prediction[] predictions) {
 
 	@Override
 	public void trainOnInstanceImpl(Instance inst) {
-		this.trainOnInstanceImpl((Instance) inst);
+		this.trainOnInstanceImpl(inst);
 	}
 
 	@Override
 	public Prediction getPredictionForInstance(Instance inst) {
-		return this.getPredictionForInstance((Instance) inst);
+		return this.getPredictionForInstance(inst);
 	}
 
 }
diff --git a/moa/src/main/java/moa/learners/predictors/meta/regressors/AdaptiveRandomForestRegressor.java b/moa/src/main/java/moa/learners/predictors/meta/regressors/AdaptiveRandomForestRegressor.java
new file mode 100644
index 000000000..189e77e5a
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/meta/regressors/AdaptiveRandomForestRegressor.java
@@ -0,0 +1,376 @@
+/*
+ *    AdaptiveRandomForestRegressor.java
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ */
+package moa.learners.predictors.meta.regressors;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+import com.yahoo.labs.samoa.instances.predictions.RegressionPrediction;
+
+import moa.AbstractMOAObject;
+import moa.core.DoubleVector;
+import moa.core.InstanceExample;
+import moa.core.Measurement;
+import moa.core.MiscUtils;
+import moa.evaluation.evaluators.BasicRegressionPerformanceEvaluator;
+import moa.learners.predictors.AbstractRegressor;
+import moa.learners.predictors.Regressor;
+import moa.learners.predictors.core.driftdetection.ChangeDetector;
+import moa.learners.predictors.meta.AdaptiveRandomForest;
+import moa.learners.predictors.trees.ARFFIMTDD;
+import moa.options.ClassOption;
+
+/**
+ * Implementation of AdaptiveRandomForestRegressor, an extension of
+ * AdaptiveRandomForest for classification.
+ *
+ * <p>
+ * See details in:<br>
+ * Heitor Murilo Gomes, Jean Paul Barddal, Luis Eduardo Boiko Ferreira, Albert
+ * Bifet. Adaptive random forests for data stream regression. In European
+ * Symposium on Artificial Neural Networks, Computational Intelligence and
+ * Machine Learning (ESANN), 2018.
+ * https://www.elen.ucl.ac.be/Proceedings/esann/esannpdf/es2018-183.pdf
+ * </p>
+ */
+public class AdaptiveRandomForestRegressor extends AbstractRegressor implements Regressor {
+
+	@Override
+	public String getPurposeString() {
+		return "Adaptive Random Forest Regressor algorithm for evolving data streams from Gomes et al.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption treeLearnerOption = new ClassOption("treeLearner", 'l', "Random Forest Tree.", ARFFIMTDD.class,
+			"ARFFIMTDD");
+
+	public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's', "The number of trees.", 10, 1,
+			Integer.MAX_VALUE);
+
+	public MultiChoiceOption mFeaturesModeOption = new MultiChoiceOption("mFeaturesMode", 'o',
+			"Defines how m, defined by mFeaturesPerTreeSize, is interpreted. M represents the total number of features.",
+			new String[] { "Specified m (integer value)", "sqrt(M)+1", "M-(sqrt(M)+1)", "Percentage (M * (m / 100))" },
+			new String[] { "SpecifiedM", "SqrtM1", "MSqrtM1", "Percentage" }, 1);
+
+	public IntOption mFeaturesPerTreeSizeOption = new IntOption("mFeaturesPerTreeSize", 'm',
+			"Number of features allowed considered for each split. Negative values corresponds to M - m", 2,
+			Integer.MIN_VALUE, Integer.MAX_VALUE);
+
+	public FloatOption lambdaOption = new FloatOption("lambda", 'a', "The lambda parameter for bagging.", 6.0, 1.0,
+			Float.MAX_VALUE);
+
+	public ClassOption driftDetectionMethodOption = new ClassOption("driftDetectionMethod", 'x',
+			"Change detector for drifts and its parameters", ChangeDetector.class, "ADWINChangeDetector -a 1.0E-5");
+
+	public ClassOption warningDetectionMethodOption = new ClassOption("warningDetectionMethod", 'p',
+			"Change detector for warnings (start training bkg learner)", ChangeDetector.class,
+			"ADWINChangeDetector -a 1.0E-4");
+
+	public FlagOption disableWeightedVote = new FlagOption("disableWeightedVote", 'w', "Should use weighted voting?");
+
+	public FlagOption disableDriftDetectionOption = new FlagOption("disableDriftDetection", 'u',
+			"Should use drift detection? If disabled then bkg learner is also disabled");
+
+	public FlagOption disableBackgroundLearnerOption = new FlagOption("disableBackgroundLearner", 'q',
+			"Should use bkg learner? If disabled then reset tree immediately.");
+
+	protected static final int FEATURES_M = 0;
+	protected static final int FEATURES_SQRT = 1;
+	protected static final int FEATURES_SQRT_INV = 2;
+	protected static final int FEATURES_PERCENT = 3;
+
+	protected ARFFIMTDDBaseLearner[] ensemble;
+	protected long instancesSeen;
+	protected int subspaceSize;
+	protected BasicRegressionPerformanceEvaluator evaluator;
+
+	@Override
+	public void resetLearningImpl() {
+		// Reset attributes
+		this.ensemble = null;
+		this.subspaceSize = 0;
+		this.instancesSeen = 0;
+		this.evaluator = new BasicRegressionPerformanceEvaluator();
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance instance) {
+		++this.instancesSeen;
+		if (this.ensemble == null)
+			initEnsemble(instance);
+
+		for (int i = 0; i < this.ensemble.length; i++) {
+			DoubleVector vote = new DoubleVector(this.ensemble[i].getVotesForInstance(instance));
+			InstanceExample example = new InstanceExample(instance);
+			this.ensemble[i].evaluator.addResult(example, vote.getArrayRef());
+			int k = MiscUtils.poisson(this.lambdaOption.getValue(), this.classifierRandom);
+			if (k > 0) {
+				this.ensemble[i].trainOnInstance(instance, k, this.instancesSeen);
+			}
+		}
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance instance) {
+		Instance testInstance = instance.copy();
+		if (this.ensemble == null)
+			initEnsemble(testInstance);
+		double accounted = 0;
+
+		DoubleVector predictions = new DoubleVector();
+		DoubleVector ages = new DoubleVector();
+		DoubleVector performance = new DoubleVector();
+
+		for (int i = 0; i < this.ensemble.length; ++i) {
+			double currentPrediction = this.ensemble[i].getVotesForInstance(testInstance)[0];
+
+			ages.addToValue(i, this.instancesSeen - this.ensemble[i].createdOn);
+			performance.addToValue(i, this.ensemble[i].evaluator.getSquareError());
+			predictions.addToValue(i, currentPrediction);
+			++accounted;
+		}
+		double predicted = predictions.sumOfValues() / accounted;
+
+		return new RegressionPrediction(predicted);
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return null;
+	}
+
+	protected void initEnsemble(Instance instance) {
+		// Init the ensemble.
+		int ensembleSize = this.ensembleSizeOption.getValue();
+		this.ensemble = new ARFFIMTDDBaseLearner[ensembleSize];
+
+		// TODO: this should be an option with default =
+		// BasicClassificationPerformanceEvaluator
+		BasicRegressionPerformanceEvaluator regressionEvaluator = new BasicRegressionPerformanceEvaluator();
+
+		this.subspaceSize = this.mFeaturesPerTreeSizeOption.getValue();
+
+		// The size of m depends on:
+		// 1) mFeaturesPerTreeSizeOption
+		// 2) mFeaturesModeOption
+		int n = instance.numAttributes() - 1; // Ignore class label ( -1 )
+
+		switch (this.mFeaturesModeOption.getChosenIndex()) {
+		case AdaptiveRandomForest.FEATURES_SQRT:
+			this.subspaceSize = (int) Math.round(Math.sqrt(n)) + 1;
+			break;
+		case AdaptiveRandomForest.FEATURES_SQRT_INV:
+			this.subspaceSize = n - (int) Math.round(Math.sqrt(n) + 1);
+			break;
+		case AdaptiveRandomForest.FEATURES_PERCENT:
+			// If subspaceSize is negative, then first find out the actual percent, i.e.,
+			// 100% - m.
+			double percent = this.subspaceSize < 0 ? (100 + this.subspaceSize) / 100.0 : this.subspaceSize / 100.0;
+			this.subspaceSize = (int) Math.round(n * percent);
+			break;
+		}
+		// Notice that if the selected mFeaturesModeOption was
+		// AdaptiveRandomForest.FEATURES_M then nothing is performed in the
+		// previous switch-case, still it is necessary to check (and adjusted)
+		// for when a negative value was used.
+
+		// m is negative, use size(features) + -m
+		if (this.subspaceSize < 0)
+			this.subspaceSize = n + this.subspaceSize;
+		// Other sanity checks to avoid runtime errors.
+		// m <= 0 (m can be negative if this.subspace was negative and
+		// abs(m) > n), then use m = 1
+		if (this.subspaceSize <= 0)
+			this.subspaceSize = 1;
+		// m > n, then it should use n
+		if (this.subspaceSize > n)
+			this.subspaceSize = n;
+
+		ARFFIMTDD treeLearner = (ARFFIMTDD) getPreparedClassOption(this.treeLearnerOption);
+		treeLearner.resetLearning();
+
+		for (int i = 0; i < ensembleSize; ++i) {
+			treeLearner.subspaceSizeOption.setValue(this.subspaceSize);
+			this.ensemble[i] = new ARFFIMTDDBaseLearner(i, (ARFFIMTDD) treeLearner.copy(),
+					(BasicRegressionPerformanceEvaluator) regressionEvaluator.copy(), this.instancesSeen,
+					!this.disableBackgroundLearnerOption.isSet(), !this.disableDriftDetectionOption.isSet(),
+					driftDetectionMethodOption, warningDetectionMethodOption, false);
+		}
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	protected final class ARFFIMTDDBaseLearner extends AbstractMOAObject {
+		public int indexOriginal;
+		public long createdOn;
+		public long lastDriftOn;
+		public long lastWarningOn;
+		public ARFFIMTDD classifier;
+		public boolean isBackgroundLearner;
+
+		// The drift and warning object parameters.
+		protected ClassOption driftOption;
+		protected ClassOption warningOption;
+
+		// Drift and warning detection
+		protected ChangeDetector driftDetectionMethod;
+		protected ChangeDetector warningDetectionMethod;
+
+		public boolean useBkgLearner;
+		public boolean useDriftDetector;
+
+		// Bkg learner
+		protected ARFFIMTDDBaseLearner bkgLearner;
+		// Statistics
+		public BasicRegressionPerformanceEvaluator evaluator;
+		protected int numberOfDriftsDetected;
+		protected int numberOfWarningsDetected;
+
+		private void init(int indexOriginal, ARFFIMTDD instantiatedClassifier,
+				BasicRegressionPerformanceEvaluator evaluatorInstantiated, long instancesSeen, boolean useBkgLearner,
+				boolean useDriftDetector, ClassOption driftOption, ClassOption warningOption,
+				boolean isBackgroundLearner) {
+			this.indexOriginal = indexOriginal;
+			this.createdOn = instancesSeen;
+			this.lastDriftOn = 0;
+			this.lastWarningOn = 0;
+
+			this.classifier = instantiatedClassifier;
+			this.evaluator = evaluatorInstantiated;
+			this.useBkgLearner = useBkgLearner;
+			this.useDriftDetector = useDriftDetector;
+
+			this.numberOfDriftsDetected = 0;
+			this.numberOfWarningsDetected = 0;
+			this.isBackgroundLearner = isBackgroundLearner;
+
+			if (this.useDriftDetector) {
+				this.driftOption = driftOption;
+				this.driftDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.driftOption)).copy();
+			}
+
+			// Init Drift Detector for Warning detection.
+			if (this.useBkgLearner) {
+				this.warningOption = warningOption;
+				this.warningDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.warningOption)).copy();
+			}
+		}
+
+		public ARFFIMTDDBaseLearner(int indexOriginal, ARFFIMTDD instantiatedClassifier,
+				BasicRegressionPerformanceEvaluator evaluatorInstantiated, long instancesSeen, boolean useBkgLearner,
+				boolean useDriftDetector, ClassOption driftOption, ClassOption warningOption,
+				boolean isBackgroundLearner) {
+			init(indexOriginal, instantiatedClassifier, evaluatorInstantiated, instancesSeen, useBkgLearner,
+					useDriftDetector, driftOption, warningOption, isBackgroundLearner);
+		}
+
+		public void reset() {
+			if (this.useBkgLearner && this.bkgLearner != null) {
+				this.classifier = this.bkgLearner.classifier;
+
+				this.driftDetectionMethod = this.bkgLearner.driftDetectionMethod;
+				this.warningDetectionMethod = this.bkgLearner.warningDetectionMethod;
+
+				this.evaluator = this.bkgLearner.evaluator;
+				this.createdOn = this.bkgLearner.createdOn;
+				this.bkgLearner = null;
+			} else {
+				this.classifier.resetLearning();
+				this.createdOn = instancesSeen;
+				this.driftDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.driftOption)).copy();
+			}
+			this.evaluator.reset();
+		}
+
+		public void trainOnInstance(Instance instance, double weight, long instancesSeen) {
+			Instance weightedInstance = instance.copy();
+			weightedInstance.setWeight(instance.weight() * weight);
+			this.classifier.trainOnInstance(weightedInstance);
+
+			if (this.bkgLearner != null)
+				this.bkgLearner.classifier.trainOnInstance(instance);
+
+			// Should it use a drift detector? Also, is it a backgroundLearner? If so, then
+			// do not "incept" another one.
+			if (this.useDriftDetector && !this.isBackgroundLearner) {
+//                boolean correctlyClassifies = this.classifier.correctlyClassifies(instance);
+				double prediction = this.classifier.getPredictionForInstance(instance).asDouble();
+				// Check for warning only if useBkgLearner is active
+				if (this.useBkgLearner) {
+					// Update the warning detection method
+					this.warningDetectionMethod.input(prediction);
+					// Check if there was a change
+					if (this.warningDetectionMethod.getChange()) {
+						this.lastWarningOn = instancesSeen;
+						this.numberOfWarningsDetected++;
+						// Create a new bkgTree classifier
+						ARFFIMTDD bkgClassifier = (ARFFIMTDD) this.classifier.copy();
+						bkgClassifier.resetLearning();
+
+						// Resets the evaluator
+						BasicRegressionPerformanceEvaluator bkgEvaluator = (BasicRegressionPerformanceEvaluator) this.evaluator
+								.copy();
+						bkgEvaluator.reset();
+
+						// Create a new bkgLearner object
+						this.bkgLearner = new ARFFIMTDDBaseLearner(indexOriginal, bkgClassifier, bkgEvaluator,
+								instancesSeen, this.useBkgLearner, this.useDriftDetector, this.driftOption,
+								this.warningOption, true);
+
+						// Update the warning detection object for the current object
+						// (this effectively resets changes made to the object while it was still a bkg
+						// learner).
+						this.warningDetectionMethod = ((ChangeDetector) getPreparedClassOption(this.warningOption))
+								.copy();
+					}
+				}
+
+				/*********** drift detection ***********/
+
+				// Update the DRIFT detection method
+				this.driftDetectionMethod.input(prediction);
+				// Check if there was a change
+				if (this.driftDetectionMethod.getChange()) {
+					this.lastDriftOn = instancesSeen;
+					this.numberOfDriftsDetected++;
+					this.reset();
+				}
+			}
+		}
+
+		public double[] getVotesForInstance(Instance instance) {
+//            DoubleVector vote = new DoubleVector(this.classifier.getVotesForInstance(instance));
+//            return vote.getArrayRef();
+			return this.classifier.getPredictionForInstance(instance).asDoubleArray();
+		}
+
+		@Override
+		public void getDescription(StringBuilder sb, int indent) {
+		}
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBagRegression.java b/moa/src/main/java/moa/learners/predictors/meta/regressors/OzaBag.java
similarity index 55%
rename from moa/src/main/java/moa/classifiers/meta/OzaBagRegression.java
rename to moa/src/main/java/moa/learners/predictors/meta/regressors/OzaBag.java
index 4f715b8c1..559799268 100644
--- a/moa/src/main/java/moa/classifiers/meta/OzaBagRegression.java
+++ b/moa/src/main/java/moa/learners/predictors/meta/regressors/OzaBag.java
@@ -1,18 +1,20 @@
-package moa.classifiers.meta;
+package moa.learners.predictors.meta.regressors;
 
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 import com.yahoo.labs.samoa.instances.predictions.RegressionPrediction;
 
-import moa.learners.Regressor;
+import moa.learners.predictors.Regressor;
+import moa.learners.predictors.meta.AbstractOzaBag;
+
+public class OzaBag extends AbstractOzaBag<Regressor> implements Regressor {
 
-public class OzaBagRegression extends AbstractOzaBag<Regressor> implements Regressor {
-	
 	private static final long serialVersionUID = 1L;
 
-	public OzaBagRegression() {
-		super(Regressor.class, "moa.classifiers.trees.FIMTDD");
+	public OzaBag() {
+		super(Regressor.class, "trees.FIMTDD");
 	}
-	
+
+	@Override
 	public Prediction combinePredictions(Prediction[] predictions) {
 		double sum = 0;
 		for (Prediction p : predictions) {
diff --git a/moa/src/main/java/moa/classifiers/meta/OzaBagAdwinRegression.java b/moa/src/main/java/moa/learners/predictors/meta/regressors/OzaBagAdwin.java
similarity index 63%
rename from moa/src/main/java/moa/classifiers/meta/OzaBagAdwinRegression.java
rename to moa/src/main/java/moa/learners/predictors/meta/regressors/OzaBagAdwin.java
index 70fc13629..0d0b1fb6a 100644
--- a/moa/src/main/java/moa/classifiers/meta/OzaBagAdwinRegression.java
+++ b/moa/src/main/java/moa/learners/predictors/meta/regressors/OzaBagAdwin.java
@@ -1,23 +1,26 @@
-package moa.classifiers.meta;
+package moa.learners.predictors.meta.regressors;
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 import com.yahoo.labs.samoa.instances.predictions.RegressionPrediction;
 
-import moa.learners.Regressor;
+import moa.learners.predictors.Regressor;
+import moa.learners.predictors.meta.AbstractOzaBagAdwin;
 
-public class OzaBagAdwinRegression extends AbstractOzaBagAdwin<Regressor> implements Regressor {
+public class OzaBagAdwin extends AbstractOzaBagAdwin<Regressor> implements Regressor {
 
 	private static final long serialVersionUID = 1L;
 
-	public OzaBagAdwinRegression() {
-		super(Regressor.class, "moa.classifiers.trees.FIMTDD");
+	public OzaBagAdwin() {
+		super(Regressor.class, "trees.FIMTDD");
 	}
 
+	@Override
 	public double getAdwinError(Instance inst, int i) {
 		return Math.abs(this.ensemble.get(i).getPredictionForInstance(inst).asDouble() - inst.classValue());
 	}
 
+	@Override
 	public Prediction combinePredictions(Prediction[] predictions) {
 		double sum = 0;
 		for (Prediction p : predictions) {
diff --git a/moa/src/main/java/moa/classifiers/oneclass/Autoencoder.java b/moa/src/main/java/moa/learners/predictors/oneclass/Autoencoder.java
similarity index 61%
rename from moa/src/main/java/moa/classifiers/oneclass/Autoencoder.java
rename to moa/src/main/java/moa/learners/predictors/oneclass/Autoencoder.java
index a9e370f11..39a26d1d9 100644
--- a/moa/src/main/java/moa/classifiers/oneclass/Autoencoder.java
+++ b/moa/src/main/java/moa/learners/predictors/oneclass/Autoencoder.java
@@ -15,385 +15,365 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
-package moa.classifiers.oneclass;
+package moa.learners.predictors.oneclass;
 
 import java.util.Collection;
 import java.util.Iterator;
 
-import org.apache.commons.math3.linear.*;
+import org.apache.commons.math3.linear.Array2DRowRealMatrix;
+import org.apache.commons.math3.linear.RealMatrix;
 
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.Classifier;
-import moa.classifiers.OneClassClassifier;
 import moa.core.Measurement;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.OneClassClassifier;
 
 /**
- * Implements an autoencoder: a neural network that attempts to reconstruct the input.
- * The autoencoder's structure is an input layer with one neuron for each non-class attribute,
- * a hidden layer of two neurons and an output layer with one neuron for each non-class attribute.
- * 
- * Partially modeled on Albert Bifet's Perceptron.java, also found in the MOA project.
- * 
- * Backpropagation implementation based on Matt Mazur's excellent tutorial on this topic:
+ * Implements an autoencoder: a neural network that attempts to reconstruct the
+ * input. The autoencoder's structure is an input layer with one neuron for each
+ * non-class attribute, a hidden layer of two neurons and an output layer with
+ * one neuron for each non-class attribute.
+ *
+ * Partially modeled on Albert Bifet's Perceptron.java, also found in the MOA
+ * project.
+ *
+ * Backpropagation implementation based on Matt Mazur's excellent tutorial on
+ * this topic:
  * https://mattmazur.com/2015/03/17/a-step-by-step-backpropagation-example/
- * 
+ *
  * @author Richard Hugh Moulton
  *
  */
-public class Autoencoder extends AbstractClassifier implements Classifier, OneClassClassifier
-{
+public class Autoencoder extends AbstractClassifier implements Classifier, OneClassClassifier {
 	private static final long serialVersionUID = 1L;
 
-	public String getPurposeString()
-	{
+	@Override
+	public String getPurposeString() {
 		return "An autoencoder is a neural network that attempts to reconstruct the input vector.";
 	}
-	
+
 	public IntOption hiddenLayerOption = new IntOption("hiddenLayer", 'h', "The number of neurons in the hidden layer."
 			+ " Should be less than the dimensionality of the data stream to ensure that the identity function is not learned.",
 			2, 1, 100);
-	
-	public FloatOption learningRateOption = new FloatOption("learningRate", 'l', 
+
+	public FloatOption learningRateOption = new FloatOption("learningRate", 'l',
 			"The rate to adapt the autoencoder's weights after each instance.", 0.5);
-	
+
 	public FloatOption thresholdOption = new FloatOption("threshold", 't',
-			"Determines the threshold for recognizing outliers. Higher values means fewer outliers.", 0.6, 0.001, 0.999);
-	
+			"Determines the threshold for recognizing outliers. Higher values means fewer outliers.", 0.6, 0.001,
+			0.999);
+
 	/**
 	 * If <b>true</b>, denotes that the autoencoder needs to be initialized.
 	 */
 	private boolean reset;
-	
+
 	/**
 	 * The dimensionality of the data stream.
 	 */
 	private int numAttributes;
-	
+
 	/**
 	 * The number of neurons in the hidden layer.
 	 */
 	private int hiddenLayerSize;
-	
+
 	/**
 	 * The weights between the input layer and the hidden layer.
 	 */
 	private RealMatrix weightsOne;
-	
+
 	/**
 	 * the weights between the hidden layer and the output layer.
 	 */
 	private RealMatrix weightsTwo;
-	
+
 	/**
 	 * The bias for the calculations between the input layer and the hidden layer.
 	 */
 	private double biasOne;
-	
+
 	/**
 	 * the bias for the calculations between the hidden layer and the output layer.
 	 */
 	private double biasTwo;
-	
+
 	/**
-	 * The learning rate; controls the size of the adjustments of the weights and bias unit.
+	 * The learning rate; controls the size of the adjustments of the weights and
+	 * bias unit.
 	 */
 	private double learningRate;
-	
+
 	/**
-	 * Controls the cut off point for declaring outliers. 
+	 * Controls the cut off point for declaring outliers.
 	 */
 	private double threshold;
-	
+
 	/**
 	 * Marks the autoencoder as needing to be reinitialized.
 	 */
 	@Override
-	public void resetLearningImpl()
-	{
+	public void resetLearningImpl() {
 		this.reset = true;
 	}
-	
+
 	/**
 	 * Initializes the autoencoder network.
 	 */
-	private void initializeNetwork()
-	{
+	private void initializeNetwork() {
 		this.hiddenLayerSize = this.hiddenLayerOption.getValue();
 		this.learningRate = this.learningRateOption.getValue();
 		this.threshold = this.thresholdOption.getValue();
 		double[][] randomWeightsOne = new double[this.hiddenLayerSize][this.numAttributes];
 		double[][] randomWeightsTwo = new double[this.numAttributes][this.hiddenLayerSize];
-		
-		for(int i = 0 ; i < this.numAttributes ; i++)
-		{
-			for(int j = 0 ; j < this.hiddenLayerSize ; j++)
-			{
+
+		for (int i = 0; i < this.numAttributes; i++) {
+			for (int j = 0; j < this.hiddenLayerSize; j++) {
 				randomWeightsOne[j][i] = this.classifierRandom.nextDouble();
 				randomWeightsTwo[i][j] = this.classifierRandom.nextDouble();
 			}
 		}
-		
+
 		this.weightsOne = new Array2DRowRealMatrix(randomWeightsOne);
 		this.weightsTwo = new Array2DRowRealMatrix(randomWeightsTwo);
 		this.biasOne = this.classifierRandom.nextDouble();
 		this.biasTwo = this.classifierRandom.nextDouble();
-		
+
 		this.reset = false;
 	}
-	
+
 	/**
 	 * Uses backpropagation to update the weights in the autoencoder.
 	 */
 	@Override
-	public void trainOnInstanceImpl(Instance inst)
-	{
-		//Initialize
-		if(this.reset)
-		{
-			this.numAttributes = inst.numAttributes()-1;
+	public void trainOnInstanceImpl(Instance inst) {
+		// Initialize
+		if (this.reset) {
+			this.numAttributes = inst.numAttributes() - 1;
 			this.initializeNetwork();
 		}
-		
-		this.backpropagation(inst);		
+
+		this.backpropagation(inst);
 	}
-	
+
 	/**
-	 * Performs the requisite calculations between the input layer and the hidden layer.
-	 * 
+	 * Performs the requisite calculations between the input layer and the hidden
+	 * layer.
+	 *
 	 * @param input the input values
-	 * 
+	 *
 	 * @return the activations of the hidden units
 	 */
-	private RealMatrix firstLayer(RealMatrix input)
-	{
+	private RealMatrix firstLayer(RealMatrix input) {
 		RealMatrix hidden = (this.weightsOne.multiply(input)).scalarAdd(this.biasOne);
 		double[] tempValues = new double[this.hiddenLayerSize];
-		
+
 		// Logistic function used for hidden layer activation
-		for(int i = 0 ; i < this.hiddenLayerSize ; i++)
-		{
-			tempValues[i] = 1.0 / (1.0 + Math.pow(Math.E, -1.0*hidden.getEntry(i, 0)));
+		for (int i = 0; i < this.hiddenLayerSize; i++) {
+			tempValues[i] = 1.0 / (1.0 + Math.pow(Math.E, -1.0 * hidden.getEntry(i, 0)));
 		}
-		
+
 		return new Array2DRowRealMatrix(tempValues);
 	}
-	
+
 	/**
-	 * Performs the requisite calculations between the hidden layer and the output layer.
-	 * 
+	 * Performs the requisite calculations between the hidden layer and the output
+	 * layer.
+	 *
 	 * @param hidden the activations of the hidden units
-	 * 
+	 *
 	 * @return the activations of the output layer
 	 */
-	private RealMatrix secondLayer(RealMatrix hidden)
-	{
+	private RealMatrix secondLayer(RealMatrix hidden) {
 		RealMatrix output = (this.weightsTwo.multiply(hidden)).scalarAdd(this.biasTwo);
 		double[] tempValues = new double[this.numAttributes];
-		
+
 		// Logistic function used for output layer activation
-		for(int i = 0 ; i < this.numAttributes ; i++)
-		{
-			tempValues[i] = 1.0 / (1.0 + Math.pow(Math.E, -1.0*output.getEntry(i, 0)));
+		for (int i = 0; i < this.numAttributes; i++) {
+			tempValues[i] = 1.0 / (1.0 + Math.pow(Math.E, -1.0 * output.getEntry(i, 0)));
 		}
-		
+
 		return new Array2DRowRealMatrix(tempValues);
-		
+
 	}
-	
+
 	/**
 	 * Performs backpropagation based on a training instance.
-	 * 
+	 *
 	 * @param inst the training instance
 	 */
-	private void backpropagation(Instance inst)
-	{
-		double [] attributeValues = new double[this.numAttributes];
-		
-		for(int i = 0 ; i < this.numAttributes ; i++)
-		{
+	private void backpropagation(Instance inst) {
+		double[] attributeValues = new double[this.numAttributes];
+
+		for (int i = 0; i < this.numAttributes; i++) {
 			attributeValues[i] = inst.value(i);
 		}
-		
+
 		RealMatrix input = new Array2DRowRealMatrix(attributeValues);
 		RealMatrix hidden = firstLayer(input);
 		RealMatrix output = secondLayer(hidden);
-		
-		RealMatrix delta = new Array2DRowRealMatrix(this.numAttributes,1);
+
+		RealMatrix delta = new Array2DRowRealMatrix(this.numAttributes, 1);
 
 		double adjustBiasTwo = 0.0;
-		
+
 		// Backpropagation to adjust the weights in layer two
-		for(int i = 0 ; i < this.numAttributes ; i++)
-		{
+		for (int i = 0; i < this.numAttributes; i++) {
 			double inputVal = input.getEntry(i, 0);
 			double outputVal = output.getEntry(i, 0);
-			delta.setEntry(i, 0, (outputVal-inputVal)*outputVal*(1.0-outputVal));
-			//squaredError += 0.5*Math.pow((outputVal-inputVal), 2.0);
-			adjustBiasTwo -= this.learningRate*delta.getEntry(i, 0)*this.biasTwo;
+			delta.setEntry(i, 0, (outputVal - inputVal) * outputVal * (1.0 - outputVal));
+			// squaredError += 0.5*Math.pow((outputVal-inputVal), 2.0);
+			adjustBiasTwo -= this.learningRate * delta.getEntry(i, 0) * this.biasTwo;
 		}
-		
-		RealMatrix adjustmentTwo = (delta.multiply(hidden.transpose())).scalarMultiply(-1.0*this.learningRate);
-				
+
+		RealMatrix adjustmentTwo = (delta.multiply(hidden.transpose())).scalarMultiply(-1.0 * this.learningRate);
+
 		// Back propagation to adjust the weights in layer one
 		RealMatrix hidden2 = hidden.scalarMultiply(-1.0).scalarAdd(1.0);
 		RealMatrix delta2 = delta.transpose().multiply(this.weightsTwo);
 		double adjustBiasOne = 0.0;
-		
-		for (int i = 0 ; i < this.hiddenLayerSize ; i++)
-		{
-			delta2.setEntry(0, i, delta2.getEntry(0, i)*hidden2.getEntry(i, 0)*hidden.getEntry(i, 0));
-			adjustBiasOne -= this.learningRate*delta2.getEntry(0, i)*this.biasOne;
+
+		for (int i = 0; i < this.hiddenLayerSize; i++) {
+			delta2.setEntry(0, i, delta2.getEntry(0, i) * hidden2.getEntry(i, 0) * hidden.getEntry(i, 0));
+			adjustBiasOne -= this.learningRate * delta2.getEntry(0, i) * this.biasOne;
 		}
-		
-		RealMatrix adjustmentOne = delta2.transpose().multiply(input.transpose()).scalarMultiply(-1.0*this.learningRate);
-		
+
+		RealMatrix adjustmentOne = delta2.transpose().multiply(input.transpose())
+				.scalarMultiply(-1.0 * this.learningRate);
+
 		this.weightsOne = this.weightsOne.add(adjustmentOne);
 		this.biasOne += adjustBiasOne;
 		this.weightsTwo = this.weightsTwo.add(adjustmentTwo);
 		this.biasTwo += adjustBiasTwo;
 	}
-	
+
 	/**
 	 * Calculates the autoencoder's output for a given input instance
-	 * 
+	 *
 	 * @param inst the instance given to the autoencoder
-	 * @return the outputs of the hidden layer and the output vector that attempts to reconstruct the input
+	 * @return the outputs of the hidden layer and the output vector that attempts
+	 *         to reconstruct the input
 	 *
-	private RealMatrix prediction(RealMatrix input)
-	{
-		RealMatrix output = new double[this.numAttributes+2];
-		
-		// Initialize arrays and compute total net input for the hidden layer
-		for(int i = 0 ; i < this.numAttributes ; i++)
-		{
-			input[i] = inst.value(i);
-			output[i+2] = this.biasTwo;
-			output[0] += input[i]*this.weightsOne[i][0];
-			output[1] += input[i]*this.weightsOne[i][1];
-		}
-		
-		// Logistic function used for hidden layer activation 
-		output[0] = 1.0 / (1.0 + Math.pow(Math.E,-1.0 * (output[0] + this.biasOne)));
-		output[1] = 1.0 / (1.0 + Math.pow(Math.E,-1.0 * (output[1] + this.biasOne)));
-		
-		// Compute total net input for the output layer
-		// Use the logistic function for output layer activation.
-		for(int i = 2 ; i < this.numAttributes ; i++)
-		{
-			output[i] += (output[0]*this.weightsTwo[0][i])+(output[1]*this.weightsTwo[1][i]);
-			output[i] = 1.0 / (1.0 + Math.pow(Math.E,-1.0 * output[i]));
-		}
-		
-		return output;
-	}*/
+	 *         private RealMatrix prediction(RealMatrix input) { RealMatrix output =
+	 *         new double[this.numAttributes+2];
+	 * 
+	 *         // Initialize arrays and compute total net input for the hidden layer
+	 *         for(int i = 0 ; i < this.numAttributes ; i++) { input[i] =
+	 *         inst.value(i); output[i+2] = this.biasTwo; output[0] +=
+	 *         input[i]*this.weightsOne[i][0]; output[1] +=
+	 *         input[i]*this.weightsOne[i][1]; }
+	 * 
+	 *         // Logistic function used for hidden layer activation output[0] = 1.0
+	 *         / (1.0 + Math.pow(Math.E,-1.0 * (output[0] + this.biasOne)));
+	 *         output[1] = 1.0 / (1.0 + Math.pow(Math.E,-1.0 * (output[1] +
+	 *         this.biasOne)));
+	 * 
+	 *         // Compute total net input for the output layer // Use the logistic
+	 *         function for output layer activation. for(int i = 2 ; i <
+	 *         this.numAttributes ; i++) { output[i] +=
+	 *         (output[0]*this.weightsTwo[0][i])+(output[1]*this.weightsTwo[1][i]);
+	 *         output[i] = 1.0 / (1.0 + Math.pow(Math.E,-1.0 * output[i])); }
+	 * 
+	 *         return output; }
+	 */
 
 	/**
-	 * Calculates the error between the autoencoder's reconstruction of the input and the argument instances.
-	 * This error is converted to vote scores.
-	 * 
+	 * Calculates the error between the autoencoder's reconstruction of the input
+	 * and the argument instances. This error is converted to vote scores.
+	 *
 	 * @param inst the instance to get votes for
-	 * 
+	 *
 	 * @return the votes for the instance's label [normal, outlier]
 	 */
 	@Override
-	public double[] getVotesForInstance(Instance inst)
-	{
+	public Prediction getPredictionForInstance(Instance inst) {
 		double[] votes = new double[2];
 
-		if (this.reset == false)
-		{
+		if (this.reset == false) {
 			double error = this.getAnomalyScore(inst);
-			
+
 			// Exponential function to convert the error [0, +inf) into a vote [1,0].
 			votes[0] = Math.pow(2.0, -1.0 * (error / this.threshold));
 			votes[1] = 1.0 - votes[0];
 		}
 
-		return votes;
+		return new ClassificationPrediction(votes);
 	}
 
 	/**
-	 * Returns the squared error between the input value and the reconstructed value as 
-	 * the anomaly score for the argument instance.
-	 * 
+	 * Returns the squared error between the input value and the reconstructed value
+	 * as the anomaly score for the argument instance.
+	 *
 	 * @param inst the instance to score
-	 * 
+	 *
 	 * @return the argument instance's anomaly score.
 	 */
-	public double getAnomalyScore(Instance inst)
-	{
+	@Override
+	public double getAnomalyScore(Instance inst) {
 		double error = 0.0;
-		
-		if(!this.reset)
-		{
-			double [] attributeValues = new double[inst.numAttributes()-1];
 
+		if (!this.reset) {
+			double[] attributeValues = new double[inst.numAttributes() - 1];
 
-			for(int i = 0 ; i < attributeValues.length ; i++)
-			{
+			for (int i = 0; i < attributeValues.length; i++) {
 				attributeValues[i] = inst.value(i);
 			}
 
 			RealMatrix input = new Array2DRowRealMatrix(attributeValues);
 			RealMatrix output = secondLayer(firstLayer(input));
 
-			for(int i = 0 ; i < this.numAttributes ; i++)
-			{
+			for (int i = 0; i < this.numAttributes; i++) {
 				error += 0.5 * Math.pow(output.getEntry(i, 0) - input.getEntry(i, 0), 2.0);
 			}
 		}
-		
+
 		return error;
 	}
-	
-	
+
 	/**
 	 * Autoencoder is randomizable.
 	 */
 	@Override
-	public boolean isRandomizable()
-	{
+	public boolean isRandomizable() {
 		return true;
 	}
-	
+
 	@Override
-	protected Measurement[] getModelMeasurementsImpl()
-	{
+	protected Measurement[] getModelMeasurementsImpl() {
 		return null;
 	}
 
 	@Override
-	public void getModelDescription(StringBuilder out, int indent)
-	{
+	public void getModelDescription(StringBuilder out, int indent) {
 	}
 
 	/**
 	 * Initializes the Autoencoder classifier on the argument trainingPoints.
-	 * 
-	 * @param trainingPoints the Collection of instances on which to initialize the Autoencoder classifier.
+	 *
+	 * @param trainingPoints the Collection of instances on which to initialize the
+	 *                       Autoencoder classifier.
 	 */
 	@Override
-	public void initialize(Collection<Instance> trainingPoints)
-	{
+	public void initialize(Collection<Instance> trainingPoints) {
 		Iterator<Instance> trgPtsIterator = trainingPoints.iterator();
-		
-		if(trgPtsIterator.hasNext() && this.reset)
-		{
-			Instance inst = (Instance)trgPtsIterator.next();
-			this.numAttributes = inst.numAttributes()-1;
+
+		if (trgPtsIterator.hasNext() && this.reset) {
+			Instance inst = trgPtsIterator.next();
+			this.numAttributes = inst.numAttributes() - 1;
 			this.initializeNetwork();
 		}
-		
-		while(trgPtsIterator.hasNext())
-		{
-			this.trainOnInstance((Instance)trgPtsIterator.next());			
+
+		while (trgPtsIterator.hasNext()) {
+			this.trainOnInstance(trgPtsIterator.next());
 		}
 	}
 
diff --git a/moa/src/main/java/moa/classifiers/oneclass/HSTreeNode.java b/moa/src/main/java/moa/learners/predictors/oneclass/HSTreeNode.java
similarity index 61%
rename from moa/src/main/java/moa/classifiers/oneclass/HSTreeNode.java
rename to moa/src/main/java/moa/learners/predictors/oneclass/HSTreeNode.java
index 21b3bdf8d..b861f3a83 100644
--- a/moa/src/main/java/moa/classifiers/oneclass/HSTreeNode.java
+++ b/moa/src/main/java/moa/learners/predictors/oneclass/HSTreeNode.java
@@ -15,10 +15,10 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
-package moa.classifiers.oneclass;
+package moa.learners.predictors.oneclass;
 
 import java.io.Serializable;
 
@@ -26,25 +26,26 @@
 
 /**
  * A node in an HSTree. Based on the work S. C. Tan, K. M. Ting, and T. F. Liu,
- * “Fast anomaly detection for streaming data,” in IJCAI Proceedings-International
- * Joint Conference on Artificial Intelligence, 2011, vol. 22, no. 1, pp. 1511–1516.
- * 
+ * “Fast anomaly detection for streaming data,” in IJCAI
+ * Proceedings-International Joint Conference on Artificial Intelligence, 2011,
+ * vol. 22, no. 1, pp. 1511–1516.
+ *
  * Made use of by HSTrees.java.
- * 
+ *
  * @author Richard Hugh Moulton
  *
  */
-public class HSTreeNode implements Serializable
-{
+public class HSTreeNode implements Serializable {
 	private static final long serialVersionUID = 1L;
 
 	/**
 	 * The left/right nodes pointed to by this node.
 	 */
 	private HSTreeNode left, right;
-	
+
 	/**
-	 * The randomly chosen attribute that this node splits on. In the paper this is 'q'.
+	 * The randomly chosen attribute that this node splits on. In the paper this is
+	 * 'q'.
 	 */
 	private int splitAttribute;
 	/**
@@ -65,47 +66,49 @@ public class HSTreeNode implements Serializable
 	private int depth;
 	/**
 	 * The midpoint of the split attribute in the workspace of the node.
+	 * 
 	 * @see splitAttribute
 	 */
 	private double splitValue;
 	/**
-	 * If this node is an internal node: <b>true</b>, if it is a leaf node: <b>false</b>.
+	 * If this node is an internal node: <b>true</b>, if it is a leaf node:
+	 * <b>false</b>.
 	 */
 	private boolean internalNode;
-	
+
 	/**
 	 * Constructor for an HSTreeNode.
-	 * 
-	 * @param min the minimum values of the attributes for this node's workspace
-	 * @param max the maximum values of the attributes for this node's workspace
-	 * @param k the depth of this node in the HSTree
+	 *
+	 * @param min      the minimum values of the attributes for this node's
+	 *                 workspace
+	 * @param max      the maximum values of the attributes for this node's
+	 *                 workspace
+	 * @param k        the depth of this node in the HSTree
 	 * @param maxDepth the maximum depth of this HSTree
 	 */
-	public HSTreeNode(double[] min, double[] max, int k, int maxDepth)
-	{
+	public HSTreeNode(double[] min, double[] max, int k, int maxDepth) {
 		this.r = 0;
 		this.l = 0;
 		this.dimensions = min.length;
 		this.depth = k;
-		
-		//If this node is not at the maximum depth level, then create two subordinate nodes.
-		if((depth < maxDepth))
-		{
+
+		// If this node is not at the maximum depth level, then create two subordinate
+		// nodes.
+		if ((depth < maxDepth)) {
 			this.internalNode = true;
 			this.splitAttribute = (int) Math.floor((Math.random() * (this.dimensions)));
 			this.splitValue = (min[this.splitAttribute] + max[this.splitAttribute]) / 2.0;
-			
+
 			double temp = max[this.splitAttribute];
 			max[this.splitAttribute] = this.splitValue;
-			this.left = new HSTreeNode(min, max, k+1, maxDepth);
-			
+			this.left = new HSTreeNode(min, max, k + 1, maxDepth);
+
 			max[this.splitAttribute] = temp;
 			min[this.splitAttribute] = this.splitValue;
-			this.right = new HSTreeNode(min, max, k+1, maxDepth);
+			this.right = new HSTreeNode(min, max, k + 1, maxDepth);
 		}
 		// If this node is a leaf node, mark it as such.
-		else
-		{
+		else {
 			this.splitAttribute = -1;
 			this.internalNode = false;
 		}
@@ -113,80 +116,75 @@ public HSTreeNode(double[] min, double[] max, int k, int maxDepth)
 
 	/**
 	 * Update the mass profile of this node.
-	 * 
-	 * @param inst the instance being passed through the HSTree.
-	 * @param referenceWindow if the HSTree is in the initial reference window: <b>true</b>, else: <b>false</b>
+	 *
+	 * @param inst            the instance being passed through the HSTree.
+	 * @param referenceWindow if the HSTree is in the initial reference window:
+	 *                        <b>true</b>, else: <b>false</b>
 	 */
-	public void updateMass(Instance inst, boolean referenceWindow)
-	{
-		if(referenceWindow)
+	public void updateMass(Instance inst, boolean referenceWindow) {
+		if (referenceWindow)
 			r++;
 		else
 			l++;
-		
-		if(internalNode)
-		{
-			if(inst.value(this.splitAttribute) > this.splitValue)
+
+		if (internalNode) {
+			if (inst.value(this.splitAttribute) > this.splitValue)
 				right.updateMass(inst, referenceWindow);
 			else
 				left.updateMass(inst, referenceWindow);
 		}
 	}
-	
+
 	/**
-	 * Update the node's model by setting the latest window's mass profile as the reference window's mass profile,
-	 * resetting the latest window's mass profile to zero and updating any subordinates nodes' models.
+	 * Update the node's model by setting the latest window's mass profile as the
+	 * reference window's mass profile, resetting the latest window's mass profile
+	 * to zero and updating any subordinates nodes' models.
 	 */
-	public void updateModel()
-	{
+	public void updateModel() {
 		this.r = this.l;
 		this.l = 0;
-		
-		if(internalNode)
-		{
+
+		if (internalNode) {
 			left.updateModel();
 			right.updateModel();
 		}
 	}
 
 	/**
-	 * If this node is a leaf node or it has a mass profile of less than sizeLimit, this returns the anomaly score for the argument instance.
-	 * Otherwise this node determines which of its subordinate nodes the argument instance belongs to and asks it provide the anomaly score.
-	 * 
-	 * @param inst the instance being passed through the tree
-	 * @param sizeLimit the minimum mass profile for a node to calculate the argument instance's anomaly score
-	 * 
+	 * If this node is a leaf node or it has a mass profile of less than sizeLimit,
+	 * this returns the anomaly score for the argument instance. Otherwise this node
+	 * determines which of its subordinate nodes the argument instance belongs to
+	 * and asks it provide the anomaly score.
+	 *
+	 * @param inst      the instance being passed through the tree
+	 * @param sizeLimit the minimum mass profile for a node to calculate the
+	 *                  argument instance's anomaly score
+	 *
 	 * @return the argument instance's anomaly score (r * 2^depth)
 	 */
-	public double score(Instance inst, int sizeLimit)
-	{
+	public double score(Instance inst, int sizeLimit) {
 		double anomalyScore = 0.0;
-		
-		if(this.internalNode && this.r > sizeLimit)
-		{
-			if(inst.value(this.splitAttribute) > this.splitValue)
+
+		if (this.internalNode && this.r > sizeLimit) {
+			if (inst.value(this.splitAttribute) > this.splitValue)
 				anomalyScore = right.score(inst, sizeLimit);
 			else
 				anomalyScore = left.score(inst, sizeLimit);
-		}
-		else
-		{
+		} else {
 			anomalyScore = this.r * Math.pow(2.0, this.depth);
 		}
-		
+
 		return anomalyScore;
 	}
-	
+
 	/**
-	 * Prints this node to string and, if it is an internal node, prints its children nodes as well.
-	 * Useful for debugging the entire tree structure.
+	 * Prints this node to string and, if it is an internal node, prints its
+	 * children nodes as well. Useful for debugging the entire tree structure.
 	 */
-	protected void printNode()
-	{
-		System.out.println(this.depth+", "+this.splitAttribute+", "+this.splitValue+", "+this.r);
-		
-		if(this.internalNode)
-		{
+	protected void printNode() {
+		System.out.println(this.depth + ", " + this.splitAttribute + ", " + this.splitValue + ", " + this.r);
+
+		if (this.internalNode) {
 			this.right.printNode();
 			this.left.printNode();
 		}
diff --git a/moa/src/main/java/moa/classifiers/oneclass/HSTrees.java b/moa/src/main/java/moa/learners/predictors/oneclass/HSTrees.java
similarity index 69%
rename from moa/src/main/java/moa/classifiers/oneclass/HSTrees.java
rename to moa/src/main/java/moa/learners/predictors/oneclass/HSTrees.java
index bb8b55b1e..eeaf2f41d 100644
--- a/moa/src/main/java/moa/classifiers/oneclass/HSTrees.java
+++ b/moa/src/main/java/moa/learners/predictors/oneclass/HSTrees.java
@@ -15,10 +15,10 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
-package moa.classifiers.oneclass;
+package moa.learners.predictors.oneclass;
 
 import java.util.Collection;
 import java.util.Iterator;
@@ -26,93 +26,96 @@
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.Classifier;
-import moa.classifiers.OneClassClassifier;
 import moa.core.Measurement;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.OneClassClassifier;
 
 /**
  * Implements the Streaming Half-Space Trees one-class classifier described in
- * S. C. Tan, K. M. Ting, and T. F. Liu, “Fast anomaly detection for streaming data,”
- * in IJCAI Proceedings-International Joint Conference on Artificial Intelligence,
- * 2011, vol. 22, no. 1, pp. 1511–1516.
- * 
+ * S. C. Tan, K. M. Ting, and T. F. Liu, “Fast anomaly detection for streaming
+ * data,” in IJCAI Proceedings-International Joint Conference on Artificial
+ * Intelligence, 2011, vol. 22, no. 1, pp. 1511–1516.
+ *
  * @author Richard Hugh Moulton
  *
  */
-public class HSTrees extends AbstractClassifier implements Classifier, OneClassClassifier
-{
+public class HSTrees extends AbstractClassifier implements Classifier, OneClassClassifier {
 	private static final long serialVersionUID = 1L;
 
-	public String getPurposeString()
-	{
+	@Override
+	public String getPurposeString() {
 		return "HSTrees is a forest of Streaming Half-Space Trees.";
 	}
-	
+
 	public IntOption windowSizeOption = new IntOption("windowSize", 'p', "The size of the landmark windows used.", 250);
 	public IntOption numTreesOption = new IntOption("numberOfTrees", 't', "The number of trees in the ensemble.", 25);
 	public IntOption maxDepthOption = new IntOption("maxDepth", 'h', "The maximum depth of the trees", 15);
-	public FloatOption anomalyThresholdOption = new FloatOption("anomalyThreshold", 'a', 
-			"Threshold (as a fraction of the maximum mass value) below which an instance is declared an anomaly.", 
-			0.5, Double.MIN_VALUE, 1.0);
+	public FloatOption anomalyThresholdOption = new FloatOption("anomalyThreshold", 'a',
+			"Threshold (as a fraction of the maximum mass value) below which an instance is declared an anomaly.", 0.5,
+			Double.MIN_VALUE, 1.0);
 	public FloatOption sizeLimitOption = new FloatOption("sizeLimit", 's', "The minimum mass required in a node (as a "
 			+ "fraction of the window size) to calculate the anomaly score.", 0.1, Double.MIN_VALUE, 1.0);
-	
-	// Respectively, these variables store: the window size, the number of trees, the maximum depth of the trees,
-	// the dimensionality of the data stream and the number of instances seen to date.
+
+	// Respectively, these variables store: the window size, the number of trees,
+	// the maximum depth of the trees,
+	// the dimensionality of the data stream and the number of instances seen to
+	// date.
 	/**
 	 * The size of the landmark windows used - 'psi' in the original paper.
 	 */
 	private int windowSize;
-	
+
 	/**
 	 * The number of trees in the ensemble - 't' in the original paper.
 	 */
 	private int numTrees;
-	
+
 	/**
 	 * The maximum depth of the trees - 'maxDepth' in the original paper.
 	 */
 	private int maxDepth;
-	
+
 	/**
-	 * The minimum mass required in a node (as a fraction of the window size) to calculate the anomaly score.
-	 * 'sizeLimit' in the original paper.
+	 * The minimum mass required in a node (as a fraction of the window size) to
+	 * calculate the anomaly score. 'sizeLimit' in the original paper.
 	 */
 	private double sizeLimit;
-	
+
 	/**
 	 * The dimensionality of the data stream.
 	 */
 	private int dimensions;
-	
+
 	/**
 	 * The number of instances from the data stream processed to date.
 	 */
 	private int numInstances;
-	
+
 	/**
 	 * The threshold for declaring anomalies
 	 */
 	private double anomalyThreshold;
-	
+
 	/**
 	 * The forest of HSTrees
 	 */
 	private HSTreeNode[] forest;
-	
+
 	/**
-	 * If the classifier is in the first reference window: <b>true</b>, else: <b>false</b>
+	 * If the classifier is in the first reference window: <b>true</b>, else:
+	 * <b>false</b>
 	 */
 	private boolean referenceWindow;
-	
+
 	/**
 	 * Reset the classifier's parameters and data structures.
 	 */
 	@Override
-	public void resetLearningImpl()
-	{
+	public void resetLearningImpl() {
 		this.windowSize = this.windowSizeOption.getValue();
 		this.numTrees = this.numTreesOption.getValue();
 		this.maxDepth = this.maxDepthOption.getValue();
@@ -125,154 +128,138 @@ public void resetLearningImpl()
 
 	/**
 	 * Update the forest with the argument instance
-	 * 
+	 *
 	 * @param inst the instance to pass to the forest
 	 */
 	@Override
-	public void trainOnInstanceImpl(Instance inst)
-	{
+	public void trainOnInstanceImpl(Instance inst) {
 		// If this is the first instance, then initialize the forest.
-		if(this.numInstances == 0)
-		{
+		if (this.numInstances == 0) {
 			this.buildForest(inst);
 		}
-		
+
 		// Update the mass profile of every HSTree in the forest
-		for(int i = 0 ; i < this.numTrees ; i++)
-		{
+		for (int i = 0; i < this.numTrees; i++) {
 			forest[i].updateMass(inst, referenceWindow);
 		}
-		
-		if(this.numInstances > 50)
+
+		if (this.numInstances > 50)
 			referenceWindow = false;
-		
+
 		// If this is the last instance of the window, update every HSTree's model
-		if(this.numInstances % windowSize == 0)
-		{
-			for(int i = 0 ; i < this.numTrees ; i++)
-			{
+		if (this.numInstances % windowSize == 0) {
+			for (int i = 0; i < this.numTrees; i++) {
 				forest[i].updateModel();
 			}
 		}
-		
+
 		this.numInstances++;
 	}
-	
+
 	/**
 	 * Build the forest of Streaming Half-Space Trees
-	 * 
+	 *
 	 * @param inst an example instance
 	 */
-	private void buildForest(Instance inst)
-	{
+	private void buildForest(Instance inst) {
 		this.dimensions = inst.numAttributes();
-		double[]max = new double[dimensions];
-		double[]min = new double[dimensions];
+		double[] max = new double[dimensions];
+		double[] min = new double[dimensions];
 		double sq;
-		
-		for (int i = 0 ; i < this.numTrees ; i++)
-		{
-			for(int j = 0 ; j < this.dimensions ; j++)
-			{
+
+		for (int i = 0; i < this.numTrees; i++) {
+			for (int j = 0; j < this.dimensions; j++) {
 				sq = this.classifierRandom.nextDouble();
-				min[j] = sq - (2.0*Math.max(sq, 1.0-sq));
-				max[j] = sq + (2.0*Math.max(sq, 1.0-sq));
+				min[j] = sq - (2.0 * Math.max(sq, 1.0 - sq));
+				max[j] = sq + (2.0 * Math.max(sq, 1.0 - sq));
 			}
 
 			forest[i] = new HSTreeNode(min, max, 1, maxDepth);
 		}
 	}
-	
+
 	/**
-	 * Combine the anomaly scores from each HSTree in the forest and convert into a vote score.
-	 * 
+	 * Combine the anomaly scores from each HSTree in the forest and convert into a
+	 * vote score.
+	 *
 	 * @param inst the instance to get votes for
-	 * 
+	 *
 	 * @return the votes for the instance's label [normal, outlier]
 	 */
 	@Override
-	public double[] getVotesForInstance(Instance inst)
-	{
-		double[] votes = {0.5, 0.5};
-		
-		if(!referenceWindow)
-		{
+	public Prediction getPredictionForInstance(Instance inst) {
+		double[] votes = { 0.5, 0.5 };
+
+		if (!referenceWindow) {
 			votes[1] = this.getAnomalyScore(inst) + 0.5 - this.anomalyThreshold;
 			votes[0] = 1.0 - votes[1];
 		}
-		
-		return votes;
+
+		return new ClassificationPrediction(votes);
 	}
 
 	/**
 	 * Returns the anomaly score for the argument instance.
-	 * 
+	 *
 	 * @param inst the argument instance
-	 * 
+	 *
 	 * @return inst's anomaly score
 	 */
-	public double getAnomalyScore(Instance inst)
-	{
-		if(this.referenceWindow)
+	@Override
+	public double getAnomalyScore(Instance inst) {
+		if (this.referenceWindow)
 			return 0.5;
-		else
-		{
+		else {
 			double accumulatedScore = 0.0;
-			int massLimit = (int) (Math.ceil(this.sizeLimit*this.windowSize));
+			int massLimit = (int) (Math.ceil(this.sizeLimit * this.windowSize));
 			double maxScore = this.windowSize * Math.pow(2.0, this.maxDepth);
 
-			for(int i = 0 ; i < this.numTrees ; i++)
-			{
+			for (int i = 0; i < this.numTrees; i++) {
 				accumulatedScore += (forest[i].score(inst, massLimit) / maxScore);
 			}
 
-			accumulatedScore = accumulatedScore / (((double) this.numTrees));
+			accumulatedScore = accumulatedScore / ((this.numTrees));
 
 			return 0.5 - accumulatedScore + this.anomalyThreshold;
 		}
 	}
-	
+
 	/**
 	 * HSTrees is randomizable.
 	 */
 	@Override
-	public boolean isRandomizable()
-	{
+	public boolean isRandomizable() {
 		return true;
 	}
-	
+
 	@Override
-	protected Measurement[] getModelMeasurementsImpl()
-	{
+	protected Measurement[] getModelMeasurementsImpl() {
 		return null;
 	}
 
 	@Override
-	public void getModelDescription(StringBuilder out, int indent)
-	{
+	public void getModelDescription(StringBuilder out, int indent) {
 
 	}
 
 	/**
 	 * Initializes the Streaming HS-Trees classifier on the argument trainingPoints.
-	 * 
-	 * @param trainingPoints the Collection of instance with which to initialize the Streaming Hs-Trees classifier.
+	 *
+	 * @param trainingPoints the Collection of instance with which to initialize the
+	 *                       Streaming Hs-Trees classifier.
 	 */
 	@Override
-	public void initialize(Collection<Instance> trainingPoints)
-	{
+	public void initialize(Collection<Instance> trainingPoints) {
 		Iterator<Instance> trgPtsIterator = trainingPoints.iterator();
-		
-		if(trgPtsIterator.hasNext() && this.numInstances == 0)
-		{
+
+		if (trgPtsIterator.hasNext() && this.numInstances == 0) {
 			Instance inst = trgPtsIterator.next();
 			this.buildForest(inst);
 			this.trainOnInstance(inst);
 		}
-		
-		while(trgPtsIterator.hasNext())
-		{
-			this.trainOnInstance((Instance)trgPtsIterator.next());			
+
+		while (trgPtsIterator.hasNext()) {
+			this.trainOnInstance(trgPtsIterator.next());
 		}
 	}
 
diff --git a/moa/src/main/java/moa/classifiers/oneclass/NearestNeighbourDescription.java b/moa/src/main/java/moa/learners/predictors/oneclass/NearestNeighbourDescription.java
similarity index 59%
rename from moa/src/main/java/moa/classifiers/oneclass/NearestNeighbourDescription.java
rename to moa/src/main/java/moa/learners/predictors/oneclass/NearestNeighbourDescription.java
index 1c8696a0f..69766cf95 100644
--- a/moa/src/main/java/moa/classifiers/oneclass/NearestNeighbourDescription.java
+++ b/moa/src/main/java/moa/learners/predictors/oneclass/NearestNeighbourDescription.java
@@ -15,10 +15,10 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
-package moa.classifiers.oneclass;
+package moa.learners.predictors.oneclass;
 
 import java.util.Collection;
 import java.util.Iterator;
@@ -27,63 +27,64 @@
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-import moa.classifiers.AbstractClassifier;
-import moa.classifiers.Classifier;
-import moa.classifiers.OneClassClassifier;
 import moa.core.FixedLengthList;
 import moa.core.Measurement;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.OneClassClassifier;
 
 /**
  * Implements David Tax's Nearest Neighbour Description method described in
- * Section 3.4.2 of D. M. J. Tax, “One-Class Classification: Concept-learning 
- * in the absence of counter-examples,” Delft University of Technology, 2001
- * with adaptations for the data stream environment.
- * 
+ * Section 3.4.2 of D. M. J. Tax, “One-Class Classification: Concept-learning in
+ * the absence of counter-examples,” Delft University of Technology, 2001 with
+ * adaptations for the data stream environment.
+ *
  * @author Richard Hugh Moulton
  *
  */
-public class NearestNeighbourDescription extends AbstractClassifier implements Classifier, OneClassClassifier
-{
+public class NearestNeighbourDescription extends AbstractClassifier implements Classifier, OneClassClassifier {
 	private static final long serialVersionUID = 1L;
 
-	public String getPurposeString()
-	{
+	@Override
+	public String getPurposeString() {
 		return "NN-d is a nearest neighbour method for one-class classification.";
 	}
-	
+
 	public IntOption neighbourhoodSizeOption = new IntOption("neighbourhoodSize", 'n',
 			"The number of instances to store in the neighbourhood.", 200, 1, Integer.MAX_VALUE);
-	
-	//public IntOption kOption = new IntOption("k", 'k',
-	//		"Up to the kth nearest neighbour of the argument instance will be considered. //NOT IMPLEMENTED//", 1);
-	
-	//public IntOption mOption = new IntOption("m", 'm',
-	//		"Up to the mth nearest neighbour of the argument's nearest neighbour(s) will be considered. //NOT IMPLEMENTED//", 1);
-	
+
+	// public IntOption kOption = new IntOption("k", 'k',
+	// "Up to the kth nearest neighbour of the argument instance will be considered.
+	// //NOT IMPLEMENTED//", 1);
+
+	// public IntOption mOption = new IntOption("m", 'm',
+	// "Up to the mth nearest neighbour of the argument's nearest neighbour(s) will
+	// be considered. //NOT IMPLEMENTED//", 1);
+
 	public FloatOption thresholdOption = new FloatOption("tau", 't',
 			"The threshold value to determine whether an instance is a member of the target class or an outlier", 1.0);
-	
+
 	private int nbhdSize;
-	//private int instances, k, m; //NOT IMPLEMENTED//
+	// private int instances, k, m; //NOT IMPLEMENTED//
 	private double tau;
 	private FixedLengthList<Instance> neighbourhood;
-		
-	public NearestNeighbourDescription()
-	{
-		
+
+	public NearestNeighbourDescription() {
+
 	}
-	
+
 	/**
-	 * Constructor for a Nearest Neighbour Description classifier based on an argument
-	 * training set of instances.
-	 * 
+	 * Constructor for a Nearest Neighbour Description classifier based on an
+	 * argument training set of instances.
+	 *
 	 * @param trainingSet the instances on which to train the classifier
 	 */
-	public NearestNeighbourDescription(List<Instance> trainingSet)
-	{
+	public NearestNeighbourDescription(List<Instance> trainingSet) {
 		this.resetLearningImpl();
-		
+
 		neighbourhood.addAll(trainingSet);
 	}
 
@@ -91,125 +92,118 @@ public NearestNeighbourDescription(List<Instance> trainingSet)
 	 * Resets the implementation's parameters and data structures.
 	 */
 	@Override
-	public void resetLearningImpl()
-	{
+	public void resetLearningImpl() {
 		this.nbhdSize = this.neighbourhoodSizeOption.getValue();
-		//this.k = this.kOption.getValue(); //NOT IMPLEMENTED//
-		//this.m = this.mOption.getValue(); //NOT IMPLEMENTED//
-		
+		// this.k = this.kOption.getValue(); //NOT IMPLEMENTED//
+		// this.m = this.mOption.getValue(); //NOT IMPLEMENTED//
+
 		this.tau = this.thresholdOption.getValue();
-		
-		this.neighbourhood = new FixedLengthList<Instance>(nbhdSize);
+
+		this.neighbourhood = new FixedLengthList<>(nbhdSize);
 	}
-	
+
 	/**
-	 * The classifier adds the argument instance to its neighbourhood. If the neighbourhood
-	 * is full, then the FixedLengthList removes the oldest instance in it to accommodate 
-	 * the new instance.
+	 * The classifier adds the argument instance to its neighbourhood. If the
+	 * neighbourhood is full, then the FixedLengthList removes the oldest instance
+	 * in it to accommodate the new instance.
 	 */
 	@Override
-	public void trainOnInstanceImpl(Instance inst)
-	{
-		if(this.getAnomalyScore(inst) < 0.5)
+	public void trainOnInstanceImpl(Instance inst) {
+		if (this.getAnomalyScore(inst) < 0.5)
 			this.neighbourhood.add(inst);
 	}
-	
+
 	/**
-	 * Calculates the distance between the argument instance and its nearest neighbour as well as the distance between that
-	 * nearest neighbour and its own nearest neighbour. The ratio of these distances is compared to the threshold value, tau,
-	 * and converted into a vote score.
-	 * 
+	 * Calculates the distance between the argument instance and its nearest
+	 * neighbour as well as the distance between that nearest neighbour and its own
+	 * nearest neighbour. The ratio of these distances is compared to the threshold
+	 * value, tau, and converted into a vote score.
+	 *
 	 * @param inst the instance to get votes for.
-	 * 
+	 *
 	 * @return the votes for the instance's label [normal, outlier]
 	 */
 	@Override
-	public double[] getVotesForInstance(Instance inst)
-	{
-		double[] votes = {0.5, 0.5};
+	public Prediction getPredictionForInstance(Instance inst) {
+		double[] votes = { 0.5, 0.5 };
 
-		if(this.neighbourhood.size() > 2)
-		{
+		if (this.neighbourhood.size() > 2) {
 			votes[1] = Math.pow(2.0, -1.0 * this.getAnomalyScore(inst) / this.tau);
 			votes[0] = 1.0 - votes[1];
 		}
-				
-		return votes;
+
+		return new ClassificationPrediction(votes);
 	}
-	
+
 	/**
-	 * Returns the anomaly score for an argument instance based on the distance from it to its nearest neighbour compared
-	 * to the distance from its nearest neighbour to the neighbour's nearest neighbour.
-	 * 
+	 * Returns the anomaly score for an argument instance based on the distance from
+	 * it to its nearest neighbour compared to the distance from its nearest
+	 * neighbour to the neighbour's nearest neighbour.
+	 *
 	 * @param inst the argument instance
-	 * 
+	 *
 	 * @return d(inst, instNN) / d(instNN, instNNNN)
 	 */
-	public double getAnomalyScore(Instance inst)
-	{
-		if(this.neighbourhood.size() < 2)
+	@Override
+	public double getAnomalyScore(Instance inst) {
+		if (this.neighbourhood.size() < 2)
 			return 1.0;
-		
+
 		Instance nearestNeighbour = getNearestNeighbour(inst, this.neighbourhood, false);
 		Instance nnNearestNeighbour = getNearestNeighbour(nearestNeighbour, this.neighbourhood, true);
-		
+
 		double indicatorArgument = distance(inst, nearestNeighbour) / distance(nearestNeighbour, nnNearestNeighbour);
-				
+
 		return indicatorArgument;
 	}
 
 	/**
-	 * Searches the neighbourhood in order to find the argument instance's nearest neighbour.
-	 * 
-	 * @param inst the instance whose nearest neighbour is sought
+	 * Searches the neighbourhood in order to find the argument instance's nearest
+	 * neighbour.
+	 *
+	 * @param inst           the instance whose nearest neighbour is sought
 	 * @param neighbourhood2 the neighbourhood to search for the nearest neighbour
-	 * @param inNbhd if inst is in neighbourhood2: <b>true</b>, else: <b>false</b>
-	 * 
+	 * @param inNbhd         if inst is in neighbourhood2: <b>true</b>, else:
+	 *                       <b>false</b>
+	 *
 	 * @return the instance that is inst's nearest neighbour in neighbourhood2
 	 */
-	private Instance getNearestNeighbour(Instance inst, List<Instance> neighbourhood2, boolean inNbhd)
-	{
+	private Instance getNearestNeighbour(Instance inst, List<Instance> neighbourhood2, boolean inNbhd) {
 		double dist = Double.MAX_VALUE;
 		Instance nearestNeighbour = null;
-		
-		for(Instance candidateNN : neighbourhood2)
-		{
-			// If inst is in neighbourhood2 and an identical instance is found, then it is no longer required to
+
+		for (Instance candidateNN : neighbourhood2) {
+			// If inst is in neighbourhood2 and an identical instance is found, then it is
+			// no longer required to
 			// look for inst and the inNbhd flag can be set to FALSE.
-			if(inNbhd && (distance(inst, candidateNN) == 0))
-			{
+			if (inNbhd && (distance(inst, candidateNN) == 0)) {
 				inNbhd = false;
-			}
-			else
-			{
-				if(distance(inst, candidateNN) < dist)
-				{
+			} else {
+				if (distance(inst, candidateNN) < dist) {
 					nearestNeighbour = candidateNN.copy();
 					dist = distance(inst, candidateNN);
 				}
 			}
 		}
-		
+
 		return nearestNeighbour;
 	}
 
 	/**
 	 * Calculates the Euclidean distance between two instances.
-	 * 
+	 *
 	 * @param inst1 the first instance
 	 * @param inst2 the second instance
-	 * 
+	 *
 	 * @return the Euclidean distance between the two instances
 	 */
-	private double distance(Instance inst1, Instance inst2)
-	{
+	private double distance(Instance inst1, Instance inst2) {
 		double dist = 0.0;
-		
-		for(int i = 0 ; i < inst1.numAttributes() ; i++)
-		{
+
+		for (int i = 0; i < inst1.numAttributes(); i++) {
 			dist += Math.pow((inst1.value(i) - inst2.value(i)), 2.0);
 		}
-		
+
 		return Math.sqrt(dist);
 	}
 
@@ -217,34 +211,32 @@ private double distance(Instance inst1, Instance inst2)
 	 * Nearest Neighbour Description is not randomizable.
 	 */
 	@Override
-	public boolean isRandomizable()
-	{
+	public boolean isRandomizable() {
 		return false;
 	}
-	
+
 	@Override
-	protected Measurement[] getModelMeasurementsImpl()
-	{
+	protected Measurement[] getModelMeasurementsImpl() {
 		return null;
 	}
 
 	@Override
-	public void getModelDescription(StringBuilder out, int indent)
-	{
+	public void getModelDescription(StringBuilder out, int indent) {
 
 	}
 
 	/**
-	 * Initializes the Nearest Neighbour Distance (NN-d) classifier with the argument training points.
-	 * 
-	 * @param trainingPoints the Collection of instances on which to initialize the NN-d classifier.
+	 * Initializes the Nearest Neighbour Distance (NN-d) classifier with the
+	 * argument training points.
+	 *
+	 * @param trainingPoints the Collection of instances on which to initialize the
+	 *                       NN-d classifier.
 	 */
 	@Override
-	public void initialize(Collection<Instance> trainingPoints)
-	{
+	public void initialize(Collection<Instance> trainingPoints) {
 		Iterator<Instance> trgPtsIterator = trainingPoints.iterator();
-		
-		if(trgPtsIterator.hasNext())
+
+		if (trgPtsIterator.hasNext())
 			this.trainOnInstance(trgPtsIterator.next());
 	}
 }
diff --git a/moa/src/main/java/moa/learners/predictors/rules/AMRulesMultiLabelClassifier.java b/moa/src/main/java/moa/learners/predictors/rules/AMRulesMultiLabelClassifier.java
new file mode 100644
index 000000000..6a88644de
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/rules/AMRulesMultiLabelClassifier.java
@@ -0,0 +1,86 @@
+/*
+ *    AMRulesMultiLabelLearnerSemiSuper.java
+ *    Copyright (C) 2017 University of Porto, Portugal
+ *    @author R. Sousa, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.predictors.rules;
+
+import moa.learners.predictors.MultiLabelClassifier;
+import moa.learners.predictors.core.MultiLabelRule;
+import moa.learners.predictors.core.MultiLabelRuleClassification;
+import moa.learners.predictors.core.driftdetection.ChangeDetector;
+import moa.learners.predictors.core.errormeasurers.MultiLabelErrorMeasurer;
+import moa.learners.predictors.core.errormeasurers.RelativeMeanAbsoluteDeviationMT;
+import moa.learners.predictors.core.functions.MultiLabelNaiveBayes;
+import moa.learners.predictors.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.learners.predictors.core.splitcriteria.MultiTargetVarianceRatio;
+import moa.learners.predictors.core.voting.ErrorWeightedVoteMultiLabel;
+import moa.learners.predictors.core.voting.UniformWeightedVoteMultiLabel;
+import moa.options.ClassOption;
+
+/**
+ * Method for online multi-Label classification. This method consists of the
+ * adaptation of the Multi-target Regression method to Multi-label
+ * Classification by problem transformation. This also implied the adaption of
+ * AMRules to the output binary variable through the substitution of some
+ * heurístics such as variance measures by entropy measures.
+ * 
+ * 
+ * The algorithm is fully explained in the following publication:
+ * 
+ * Sousa R., Gama J. (2016) Online Multi-label Classification with Adaptive
+ * Model Rules. In: Luaces O. et al. (eds) Advances in Artificial Intelligence.
+ * CAEPIA 2016. Lecture Notes in Computer Science, vol 9868. Springer.
+ * 
+ * @author RSousa
+ * @version $Revision: 2 $
+ */
+
+public class AMRulesMultiLabelClassifier extends AMRulesMultiLabelLearner implements MultiLabelClassifier {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Method for online multi-Label classification.This method consists of the adaptation of the Multi-target Regression method to Multi-label Classification by problem transformation.This also implied the adaption of AMRules to the output binary variable through the substitution ofsome heurístics such as variance measures by entropy measures.";
+	}
+
+	public AMRulesMultiLabelClassifier() {
+		splitCriterionOption = new ClassOption("splitCriterionOption", 'S',
+				"Split criterion used to assess the merit of a split", MultiLabelSplitCriterion.class,
+				MultiTargetVarianceRatio.class.getName());
+
+		weightedVoteOption = new ClassOption("weightedVoteOption", 'w', "Weighted vote type",
+				ErrorWeightedVoteMultiLabel.class, UniformWeightedVoteMultiLabel.class.getName());
+
+		learnerOption = new ClassOption("learnerOption", 'L', "Learner", MultiLabelClassifier.class,
+				MultiLabelNaiveBayes.class.getName());
+
+		errorMeasurerOption = new ClassOption("errorMeasurer", 'e',
+				"Measure of error for deciding which learner should predict.", MultiLabelErrorMeasurer.class,
+				RelativeMeanAbsoluteDeviationMT.class.getName());
+
+		changeDetector = new ClassOption("changeDetector", 'H', "Change Detector.", ChangeDetector.class, "DDM");
+	}
+
+	@Override
+	protected MultiLabelRule newDefaultRule() {
+		return new MultiLabelRuleClassification(1);
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/rules/AMRulesMultiLabelLearner.java b/moa/src/main/java/moa/learners/predictors/rules/AMRulesMultiLabelLearner.java
new file mode 100644
index 000000000..d1c75e919
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/rules/AMRulesMultiLabelLearner.java
@@ -0,0 +1,552 @@
+/*
+ *    AMRulesMultiLabel.java
+ *    Copyright (C) 2014 University of Porto, Portugal
+ *    @author J. Duarte, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.predictors.rules;
+
+import java.util.ListIterator;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.StringUtils;
+import moa.learners.predictors.AbstractMultiTargetRegressor;
+import moa.learners.predictors.InstanceLearner;
+import moa.learners.predictors.MultiTargetRegressor;
+import moa.learners.predictors.core.MultiLabelRule;
+import moa.learners.predictors.core.MultiLabelRuleSet;
+import moa.learners.predictors.core.ObserverMOAObject;
+import moa.learners.predictors.core.attributeclassobservers.NominalStatisticsObserver;
+import moa.learners.predictors.core.attributeclassobservers.NumericStatisticsObserver;
+import moa.learners.predictors.core.driftdetection.ChangeDetector;
+import moa.learners.predictors.core.errormeasurers.MultiLabelErrorMeasurer;
+import moa.learners.predictors.core.featureranking.FeatureRanking;
+import moa.learners.predictors.core.featureranking.NoFeatureRanking;
+import moa.learners.predictors.core.featureranking.messages.ChangeDetectedMessage;
+import moa.learners.predictors.core.functions.MultiLabelPerceptronClassification;
+import moa.learners.predictors.core.inputselectors.InputAttributesSelector;
+import moa.learners.predictors.core.inputselectors.SelectAllInputs;
+import moa.learners.predictors.core.instancetransformers.NoInstanceTransformation;
+import moa.learners.predictors.core.outputselectors.OutputAttributesSelector;
+import moa.learners.predictors.core.outputselectors.SelectAllOutputs;
+import moa.learners.predictors.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.learners.predictors.core.voting.ErrorWeightedVoteMultiLabel;
+import moa.learners.predictors.rules.core.anomalydetection.AnomalyDetector;
+import moa.learners.predictors.rules.core.anomalydetection.OddsRatioScore;
+import moa.options.ClassOption;
+
+/**
+ * Adaptive Model Rules for MultiLabel problems (AMRulesML), the streaming rule
+ * learning algorithm.
+ *
+ * @author J. Duarte, J. Gama (jgama@fep.up.pt)
+ * @version $Revision: 2$*
+ *
+ *          This algorithm learns ordered and unordered rule set from data
+ *          streams. Each rule detect anomalies and react to changes by pruning
+ *          the rule set. This algorithm also does the detection of anomalies.
+ *
+ **/
+
+public abstract class AMRulesMultiLabelLearner extends AbstractMultiTargetRegressor implements MultiTargetRegressor {
+
+	private static final long serialVersionUID = 1L;
+	protected MultiLabelRuleSet ruleSet;
+	protected MultiLabelRule defaultRule;
+	protected int ruleNumberID = 1;
+	protected double[] statistics;
+	protected ObserverMOAObject observer;
+	// public static final double NORMAL_CONSTANT = Math.sqrt(2 * Math.PI);
+	public FloatOption splitConfidenceOption = new FloatOption("splitConfidence", 'c',
+			"Hoeffding Bound Parameter. The allowable error in split decision, values closer to 0 will take longer to decide.",
+			0.0000001, 0.0, 1.0);
+	public FloatOption tieThresholdOption = new FloatOption("tieThreshold", 't',
+			"Hoeffding Bound Parameter. Threshold below which a split will be forced to break ties.", 0.05, 0.0, 1.0);
+	public IntOption gracePeriodOption = new IntOption("gracePeriod", 'g',
+			"Hoeffding Bound Parameter. The number of instances a leaf should observe between split attempts.", 200, 1,
+			Integer.MAX_VALUE);
+
+	public ClassOption learnerOption;
+
+	public FlagOption unorderedRulesOption = new FlagOption("setUnorderedRulesOn", 'U', "unorderedRules.");
+
+	public FlagOption dropOldRuleAfterExpansionOption = new FlagOption("dropOldRuleAfterExpansion", 'D',
+			"Drop old rule if it expanded (by default the rule is kept for the set of outputs not selected for expansion.)");
+
+	public ClassOption changeDetector = new ClassOption("changeDetector", 'H', "Change Detector.", ChangeDetector.class,
+			"PageHinkleyDM -d 0.05 -l 35.0");
+
+	public ClassOption anomalyDetector = new ClassOption("anomalyDetector", 'A', "Anomaly Detector.",
+			AnomalyDetector.class, OddsRatioScore.class.getName());
+
+	public ClassOption splitCriterionOption;
+
+	public ClassOption errorMeasurerOption;
+
+	public ClassOption weightedVoteOption;
+
+	public ClassOption numericObserverOption = new ClassOption("numericObserver", 'y', "Numeric observer.",
+			NumericStatisticsObserver.class, "MultiLabelBSTree");
+
+	public ClassOption nominalObserverOption = new ClassOption("nominalObserver", 'z', "Nominal observer.",
+			NominalStatisticsObserver.class, "MultiLabelNominalAttributeObserver");
+
+	public IntOption VerbosityOption = new IntOption("verbosity", 'v',
+			"Output Verbosity Control Level. 1 (Less) to 5 (More)", 1, 1, 5);
+
+	// TODO The followint two options are deprecated
+	public ClassOption outputSelectorOption = new ClassOption("outputSelector", 'O', "Output attributes selector",
+			OutputAttributesSelector.class,
+			// "StdDevThreshold");
+			SelectAllOutputs.class.getName());
+
+	public ClassOption inputSelectorOption = new ClassOption("inputSelector", 'I', "Input attributes selector",
+			InputAttributesSelector.class,
+			// "MeritThreshold");
+			SelectAllInputs.class.getName());
+//	public IntOption randomSeedOption = new IntOption("randomSeedOption",
+//			'r', "randomSeedOption",
+//			1,Integer.MIN_VALUE, Integer.MAX_VALUE);
+
+	public ClassOption featureRankingOption = new ClassOption("featureRanking", 'F', "Feature ranking algorithm.",
+			FeatureRanking.class, NoFeatureRanking.class.getName());
+
+	private int nAttributes = 0;
+
+	protected double attributesPercentage;
+
+	public double getAttributesPercentage() {
+		return attributesPercentage;
+	}
+
+	public void setAttributesPercentage(double attributesPercentage) {
+		this.attributesPercentage = attributesPercentage;
+	}
+
+	public AMRulesMultiLabelLearner() {
+		super();
+		super.randomSeedOption = this.randomSeedOption;
+		attributesPercentage = 100;
+	}
+
+	public AMRulesMultiLabelLearner(double attributesPercentage) {
+		this();
+		this.attributesPercentage = attributesPercentage;
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		ErrorWeightedVoteMultiLabel vote = getVotes(inst);
+
+		Prediction pred = vote.getPrediction();
+		if (vote != null) {
+			if (getPreparedClassOption(this.learnerOption) instanceof MultiLabelPerceptronClassification) {
+				for (int i = 0; i < pred.size(); i++) {
+					pred.setVote(i, 0, pred.getVote(i, 0) < 0.5 ? 1 : 0);
+				}
+			}
+			return pred;
+		} else
+			return null;
+	}
+
+	/**
+	 * getVotes extension of the instance method getPredictionForInstance in
+	 * moa.classifier.java returns the prediction of the instance.
+	 */
+	public ErrorWeightedVoteMultiLabel getVotes(Instance instance) {
+		ErrorWeightedVoteMultiLabel errorWeightedVote = newErrorWeightedVote();
+		// DoubleVector combinedVote = new DoubleVector();
+
+		VerboseToConsole(instance); // Verbose to console Dataset name.
+		for (MultiLabelRule rule : ruleSet) {
+			if (rule.isCovering(instance) == true) {
+				// DoubleVector vote = new DoubleVector(rule.getPrediction(instance));
+				Prediction vote = rule.getPredictionForInstance(instance);
+				if (vote != null) { // should only happen for first instance
+					double[] errors = rule.getCurrentErrors();
+					if (errors == null) // if errors==null, rule has seen no predictions since expansion: return maximum
+										// error, since prediction is not reliable
+						errors = defaultRuleErrors(vote);
+					debug("Rule No" + rule.getRuleNumberID() + " Vote: " + vote.toString() + " Error: " + errors
+							+ " Y: " + instance.classValue(), 3); // predictionValueForThisRule);
+					errorWeightedVote.addVote(vote, errors);
+				}
+				if (!this.unorderedRulesOption.isSet()) { // Ordered Rules Option. //TODO: Only break if all outputs
+															// have values assigned.Complete Prediction only with the
+															// missing values
+					break; // Only one rule cover the instance.
+				}
+			}
+		}
+
+		if (!errorWeightedVote.coversAllOutputs()) {
+			// combinedVote = new DoubleVector(defaultRule.getPrediction(instance));
+			Prediction vote = errorWeightedVote.getPrediction();
+			if (vote == null) { // use default rule
+				vote = new MultiLabelClassificationPrediction(instance.numOutputAttributes());
+			}
+			Prediction defaultVote = defaultRule.getPredictionForInstance(instance);
+			if (defaultVote != null) {
+				double[] defaultErrors = defaultRule.getCurrentErrors();
+				if (defaultErrors == null)
+					defaultErrors = defaultRuleErrors(defaultVote);
+				double[] fixErrors = new double[vote.numOutputAttributes()];
+				Prediction fixVote = new MultiLabelClassificationPrediction(vote.numOutputAttributes());
+				for (int i = 0; i < vote.numOutputAttributes(); i++) {
+					if (!vote.hasVotesForAttribute(i)) {
+						fixVote.setVote(i, defaultVote.getPrediction(i));
+						fixErrors[i] = defaultErrors[i];
+					}
+				}
+				errorWeightedVote.addVote(fixVote, fixErrors);
+				debug("Default Rule Vote " + defaultVote.toString() + "\n Error " + defaultErrors + "  Y: " + instance,
+						3);
+			}
+		}
+		errorWeightedVote.computeWeightedVote();
+		return errorWeightedVote;
+	}
+
+	/*
+	 * Returns the estimate error for each output of a rule Should be used when
+	 * rule.getCurrentErrors() returns null
+	 */
+	protected double[] defaultRuleErrors(Prediction vote) {
+		double[] errors = new double[vote.numOutputAttributes()];
+		for (int i = 0; i < vote.numOutputAttributes(); i++) {
+			if (vote.hasVotesForAttribute(i))
+				errors[i] = Double.MAX_VALUE;
+		}
+		return errors;
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	/**
+	 * AMRules Algorithm. Method for updating (training) the AMRules model using a
+	 * new instance
+	 */
+
+	private double numChangesDetected; // Just for statistics
+	private double numAnomaliesDetected; // Just for statistics
+	private double numInstances; // Just for statistics
+	private FeatureRanking featureRanking;
+
+	@Override
+	public void trainOnInstanceImpl(Instance instance) {
+		/**
+		 * AMRules Algorithm
+		 * 
+		 * //For each rule in the rule set //If rule covers the instance //if the
+		 * instance is not an anomaly //Update Change Detection Tests //Compute
+		 * prediction error //Call PHTest //If change is detected then //Remove rule
+		 * //Else //Update sufficient statistics of rule //If number of examples in rule
+		 * > Nmin //Expand rule //If ordered set then //break //If none of the rule
+		 * covers the instance //Update sufficient statistics of default rule //If
+		 * number of examples in default rule is multiple of Nmin //Expand default rule
+		 * and add it to the set of rules //Reset the default rule
+		 */
+		if (nAttributes == 0)
+			nAttributes = instance.numInputAttributes();
+		numInstances += instance.weight();
+		debug("Train", 3);
+		debug("Nº instance " + numInstances + " - " + instance.toString(), 3);
+		boolean rulesCoveringInstance = false;
+		ListIterator<MultiLabelRule> ruleIterator = this.ruleSet.listIterator();
+		while (ruleIterator.hasNext()) {
+			MultiLabelRule rule = ruleIterator.next();
+			if (rule.isCovering(instance) == true) {
+				rulesCoveringInstance = true; // TODO: JD use different strategies for this validation (first rule,
+												// first complete rule (all out attributes covered), voted complete
+												// rule, etc)
+				if (!rule.updateAnomalyDetection(instance)) {
+					if (rule.updateChangeDetection(instance)) {
+						debug("I) Drift Detected. Exa. : " + this.numInstances + " ("
+								+ rule.getWeightSeenSinceExpansion() + ") Remove Rule: " + rule.getRuleNumberID(), 1);
+						ruleIterator.remove();
+
+						// Rule expansion event
+						rule.notifyAll(new ChangeDetectedMessage());
+
+						this.numChangesDetected += instance.weight(); // Just for statistics
+					} else {
+						rule.trainOnInstance(instance);
+						if (rule.getWeightSeenSinceExpansion() % this.gracePeriodOption.getValue() == 0.0) {
+							if (rule.tryToExpand(this.splitConfidenceOption.getValue(),
+									this.tieThresholdOption.getValue())) {
+
+								MultiLabelRule otherMultiLabelRule = rule.getNewRuleFromOtherOutputs(); // Need to be
+																										// outside to
+																										// make sure
+																										// other rules
+																										// are cleaned
+								if (!dropOldRuleAfterExpansionOption.isSet() && rule.hasNewRuleFromOtherOutputs()) {
+									rule.clearOtherOutputs();
+									otherMultiLabelRule.setRuleNumberID(++ruleNumberID);
+									setRuleOptions(otherMultiLabelRule);
+									ruleIterator.add(otherMultiLabelRule);
+									if (observer != null)
+										otherMultiLabelRule.addObserver(observer);
+								}
+								setRuleOptions(rule);
+								debug("Rule Expanded:", 2);
+								debug(rule.toString(), 2);
+							}
+						}
+					}
+				} else {
+					debug("Anomaly Detected: " + this.numInstances + " Rule: " + rule.getRuleNumberID(), 1);
+					this.numAnomaliesDetected += instance.weight();// Just for statistics
+				}
+				if (!this.unorderedRulesOption.isSet())
+					break;
+
+			}
+		}
+
+		if (rulesCoveringInstance == false) {
+			defaultRule.trainOnInstance(instance);
+			if (defaultRule.getWeightSeenSinceExpansion() % this.gracePeriodOption.getValue() == 0.0) {
+				debug("Nr. examples " + defaultRule.getWeightSeenSinceExpansion(), 4);
+
+				if (defaultRule.tryToExpand(this.splitConfidenceOption.getValue(),
+						this.tieThresholdOption.getValue()) == true) {
+					// create new default rule
+					MultiLabelRule newDefaultRule = defaultRule.getNewRuleFromOtherBranch();
+					newDefaultRule.setRuleNumberID(++ruleNumberID);
+					setRuleOptions(newDefaultRule);
+
+					// Add expanded rule to ruleset
+					setRuleOptions(defaultRule);
+					ruleSet.add(this.defaultRule);
+
+					debug("Default rule expanded! New Rule:", 2);
+					debug(defaultRule.toString(), 2);
+					debug("New default rule:", 3);
+					debug(newDefaultRule.toString(), 3);
+					defaultRule = newDefaultRule;
+					if (observer != null)
+						defaultRule.addObserver(observer);
+				}
+			}
+		}
+	}
+
+	/**
+	 * print GUI evaluate model
+	 */
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		Measurement[] m = null;
+		Measurement[] mNoFeatureRanking = new Measurement[] {
+				new Measurement("anomaly detections", this.numAnomaliesDetected),
+				new Measurement("change detections", this.numChangesDetected),
+				new Measurement("rules (number)", this.ruleSet.size() + 1),
+				new Measurement("Avg #inputs/rule", getAverageInputs()),
+				new Measurement("Avg #outputs/rule", getAverageOutputs()) };
+
+		if (featureRanking instanceof NoFeatureRanking) {
+			m = mNoFeatureRanking;
+		} else {
+			m = new Measurement[mNoFeatureRanking.length + this.nAttributes];
+			for (int i = 0; i < mNoFeatureRanking.length; i++)
+				m[i] = mNoFeatureRanking[i];
+			DoubleVector rankings = this.featureRanking.getFeatureRankings();
+			for (int i = 0; i < this.nAttributes; i++)
+				m[i + mNoFeatureRanking.length] = new Measurement("Attribute" + i, rankings.getValue(i));
+		}
+		return m;
+	}
+
+	protected double getAverageInputs() {
+		double avg = 0;
+		int ct = 0;
+		if (ruleSet.size() > 0) {
+			for (MultiLabelRule r : ruleSet) {
+				int[] aux = r.getInputsCovered();
+				if (aux != null) {
+					avg += aux.length;
+					ct++;
+				}
+			}
+		}
+		int[] aux = defaultRule.getInputsCovered();
+		if (aux != null) {
+			avg += aux.length;
+			ct++;
+		}
+		if (ct > 0)
+			avg /= ct;
+		return avg;
+	}
+
+	protected double getAverageOutputs() {
+		double avg = 0;
+		int ct = 0;
+		if (ruleSet.size() > 0) {
+			for (MultiLabelRule r : ruleSet) {
+				int[] aux = r.getOutputsCovered();
+				if (aux != null) {
+					avg += aux.length;
+					ct++;
+				}
+			}
+		}
+		int[] aux = defaultRule.getOutputsCovered();
+		if (aux != null) {
+			avg += aux.length;
+			ct++;
+		}
+		if (ct > 0)
+			avg /= ct;
+		return avg;
+	}
+
+	/**
+	 * print GUI learn model
+	 */
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		if (!this.unorderedRulesOption.isSet()) {
+			StringUtils.appendIndented(out, indent, "Method Ordered");
+			StringUtils.appendNewline(out);
+		} else {
+			StringUtils.appendIndented(out, indent, "Method Unordered");
+			StringUtils.appendNewline(out);
+		}
+		StringUtils.appendIndented(out, indent, "Number of Rules: " + (this.ruleSet.size() + 1));
+		StringUtils.appendNewline(out);
+
+		StringUtils.appendIndented(out, indent, "Default rule :");
+		this.defaultRule.getDescription(out, indent);
+		StringUtils.appendNewline(out);
+
+		StringUtils.appendIndented(out, indent, "Rules in ruleSet:");
+		StringUtils.appendNewline(out);
+		for (MultiLabelRule rule : ruleSet) {
+			rule.getDescription(out, indent);
+			StringUtils.appendNewline(out);
+		}
+	}
+
+	/**
+	 * Print to console
+	 * 
+	 * @param string
+	 */
+	protected void debug(String string, int level) {
+		if (VerbosityOption.getValue() >= level) {
+			System.out.println(string);
+		}
+	}
+
+	protected void VerboseToConsole(Instance inst) {
+		if (VerbosityOption.getValue() >= 5) {
+			System.out.println();
+			System.out.println("I) Dataset: " + inst.dataset().getRelationName());
+
+			if (!this.unorderedRulesOption.isSet()) {
+				System.out.println("I) Method Ordered");
+			} else {
+				System.out.println("I) Method Unordered");
+			}
+		}
+	}
+
+	public void PrintRuleSet() {
+		debug("Default rule :", 2);
+		debug(this.defaultRule.toString(), 2);
+
+		debug("Rules in ruleSet:", 2);
+		for (MultiLabelRule rule : ruleSet) {
+			debug(rule.toString(), 2);
+		}
+	}
+
+	@Override
+	public void resetLearningImpl() {
+		defaultRule = newDefaultRule();
+		this.classifierRandom.setSeed(this.randomSeed);
+		InstanceLearner l = (InstanceLearner) ((InstanceLearner) getPreparedClassOption(learnerOption)).copy();
+		l.setRandomSeed(this.randomSeed);
+		l.resetLearning();
+		defaultRule.setLearner(l);
+		defaultRule.setInstanceTransformer(new NoInstanceTransformation());
+		setRuleOptions(defaultRule);
+		ruleSet = new MultiLabelRuleSet();
+		ruleNumberID = 1;
+		statistics = null;
+		this.featureRanking = (FeatureRanking) getPreparedClassOption(this.featureRankingOption);
+		setObserver(featureRanking);
+	}
+
+	protected void setRuleOptions(MultiLabelRule rule) {
+		rule.setSplitCriterion(
+				(MultiLabelSplitCriterion) ((MultiLabelSplitCriterion) getPreparedClassOption(splitCriterionOption))
+						.copy());
+		rule.setChangeDetector(((ChangeDetector) getPreparedClassOption(changeDetector)).copy());
+		rule.setAnomalyDetector(((AnomalyDetector) getPreparedClassOption(anomalyDetector)).copy());
+		rule.setNumericObserverOption(
+				(NumericStatisticsObserver) ((NumericStatisticsObserver) getPreparedClassOption(numericObserverOption))
+						.copy());
+		rule.setNominalObserverOption(
+				(NominalStatisticsObserver) ((NominalStatisticsObserver) getPreparedClassOption(nominalObserverOption))
+						.copy());
+		rule.setErrorMeasurer(
+				(MultiLabelErrorMeasurer) ((MultiLabelErrorMeasurer) getPreparedClassOption(errorMeasurerOption))
+						.copy());
+		rule.setOutputAttributesSelector(
+				(OutputAttributesSelector) ((OutputAttributesSelector) getPreparedClassOption(outputSelectorOption))
+						.copy());
+		rule.setRandomGenerator(this.classifierRandom);
+		rule.setAttributesPercentage(this.attributesPercentage);
+		rule.setInputAttributesSelector(
+				(InputAttributesSelector) ((InputAttributesSelector) getPreparedClassOption(inputSelectorOption))
+						.copy());
+	}
+
+	abstract protected MultiLabelRule newDefaultRule();
+
+	public ErrorWeightedVoteMultiLabel newErrorWeightedVote() {
+		return (ErrorWeightedVoteMultiLabel) ((ErrorWeightedVoteMultiLabel) getPreparedClassOption(weightedVoteOption))
+				.copy();
+	}
+
+	@Override
+	public void setRandomSeed(int randomSeed) {
+		super.setRandomSeed(randomSeed);
+		this.classifierRandom.setSeed(randomSeed);
+	}
+
+	public void setObserver(ObserverMOAObject observer) {
+		this.observer = observer;
+		this.defaultRule.addObserver(observer);
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/rules/AMRulesMultiLabelLearnerSemiSuper.java b/moa/src/main/java/moa/learners/predictors/rules/AMRulesMultiLabelLearnerSemiSuper.java
new file mode 100644
index 000000000..164252fdc
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/rules/AMRulesMultiLabelLearnerSemiSuper.java
@@ -0,0 +1,608 @@
+/*
+ *    AMRulesMultiLabelLearnerSemiSuper.java
+ *    Copyright (C) 2017 University of Porto, Portugal
+ *    @author R. Sousa, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.predictors.rules;
+
+import java.util.ListIterator;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.MultiTargetRegressionPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.StringUtils;
+import moa.learners.predictors.AbstractMultiLabelClassifier;
+import moa.learners.predictors.InstanceLearner;
+import moa.learners.predictors.MultiLabelClassifier;
+import moa.learners.predictors.SemiSupervisedMultiLabelClassifier;
+import moa.learners.predictors.core.MultiLabelRule;
+import moa.learners.predictors.core.MultiLabelRuleSet;
+import moa.learners.predictors.core.ObserverMOAObject;
+import moa.learners.predictors.core.attributeclassobservers.NominalStatisticsObserver;
+import moa.learners.predictors.core.attributeclassobservers.NumericStatisticsObserver;
+import moa.learners.predictors.core.driftdetection.ChangeDetector;
+import moa.learners.predictors.core.errormeasurers.MultiLabelErrorMeasurer;
+import moa.learners.predictors.core.featureranking.FeatureRanking;
+import moa.learners.predictors.core.featureranking.NoFeatureRanking;
+import moa.learners.predictors.core.featureranking.messages.ChangeDetectedMessage;
+import moa.learners.predictors.core.inputselectors.InputAttributesSelector;
+import moa.learners.predictors.core.inputselectors.SelectAllInputs;
+import moa.learners.predictors.core.instancetransformers.NoInstanceTransformation;
+import moa.learners.predictors.core.outputselectors.OutputAttributesSelector;
+import moa.learners.predictors.core.outputselectors.SelectAllOutputs;
+import moa.learners.predictors.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.learners.predictors.core.voting.ErrorWeightedVoteMultiLabel;
+import moa.learners.predictors.rules.core.anomalydetection.AnomalyDetector;
+import moa.learners.predictors.rules.core.anomalydetection.OddsRatioScore;
+import moa.options.ClassOption;
+import weka.core.pmml.jaxbbindings.TrainingInstances;
+
+/**
+ * Semi-supervised method for online multi-target regression. This method uses
+ * the AMRules as learner and it based on probabilistic method very similar to
+ * anomaly detection. This method measures predicts the benefit of a unlabeled
+ * example to the models(using only the input information) to the model. If this
+ * benefit is higher than <scoreThreshold> then the algorithm predicts an output
+ * and artificially labels the example and use it for training.
+ * 
+ * 
+ * The algorithm is fully explained in the following publication:
+ * 
+ * Sousa R., Gama J. (2016) Online Semi-supervised Learning for Multi-target
+ * Regression in Data Streams Using AMRules. In: Boström H., Knobbe A., Soares
+ * C., Papapetrou P. (eds) Advances in Intelligent Data Analysis XV. IDA 2016.
+ * Lecture Notes in Computer Science, vol 9897. Springer.
+ * 
+ * @author RSousa
+ * @version $Revision: 2 $
+ */
+
+public abstract class AMRulesMultiLabelLearnerSemiSuper extends AbstractMultiLabelClassifier
+		implements MultiLabelClassifier, SemiSupervisedMultiLabelClassifier {
+
+	private static final long serialVersionUID = 1L;
+	protected MultiLabelRuleSet ruleSet;
+	protected MultiLabelRule defaultRule;
+	protected int ruleNumberID = 1;
+	protected double[] statistics;
+	protected ObserverMOAObject observer;
+
+	//
+	public FloatOption splitConfidenceOption = new FloatOption("splitConfidence", 'c',
+			"Hoeffding Bound Parameter. The allowable error in split decision, values closer to 0 will take longer to decide.",
+			0.0000001, 0.0, 1.0);
+	public FloatOption tieThresholdOption = new FloatOption("tieThreshold", 't',
+			"Hoeffding Bound Parameter. Threshold below which a split will be forced to break ties.", 0.05, 0.0, 1.0);
+	public IntOption gracePeriodOption = new IntOption("gracePeriod", 'g',
+			"Hoeffding Bound Parameter. The number of instances a leaf should observe between split attempts.", 200, 1,
+			Integer.MAX_VALUE);
+	public ClassOption learnerOption;
+	public FlagOption unorderedRulesOption = new FlagOption("setUnorderedRulesOn", 'U', "unorderedRules.");
+	public FlagOption dropOldRuleAfterExpansionOption = new FlagOption("dropOldRuleAfterExpansion", 'D',
+			"Drop old rule if it expanded (by default the rule is kept for the set of outputs not selected for expansion.)");
+	public ClassOption changeDetector;
+
+	public ClassOption anomalyDetector = new ClassOption("anomalyDetector", 'A', "Anomaly Detector.",
+			AnomalyDetector.class, OddsRatioScore.class.getName());
+	public ClassOption splitCriterionOption;
+
+	public ClassOption errorMeasurerOption;
+
+	public ClassOption weightedVoteOption;
+
+	public ClassOption numericObserverOption = new ClassOption("numericObserver", 'y', "Numeric observer.",
+			NumericStatisticsObserver.class, "MultiLabelBSTree");
+	public ClassOption nominalObserverOption = new ClassOption("nominalObserver", 'z', "Nominal observer.",
+			NominalStatisticsObserver.class, "MultiLabelNominalAttributeObserver");
+	public IntOption VerbosityOption = new IntOption("verbosity", 'v',
+			"Output Verbosity Control Level. 1 (Less) to 5 (More)", 1, 1, 5);
+	public ClassOption outputSelectorOption = new ClassOption("outputSelector", 'O', "Output attributes selector",
+			OutputAttributesSelector.class, SelectAllOutputs.class.getName());
+	public ClassOption inputSelectorOption = new ClassOption("inputSelector", 'I', "Input attributes selector",
+			InputAttributesSelector.class, SelectAllInputs.class.getName());
+//	public IntOption randomSeedOption = new IntOption("randomSeedOption",
+//			'r', "randomSeedOption",
+//			1,Integer.MIN_VALUE, Integer.MAX_VALUE);
+	public ClassOption featureRankingOption = new ClassOption("featureRanking", 'F', "Feature ranking algorithm.",
+			FeatureRanking.class, NoFeatureRanking.class.getName());
+	public FloatOption scoreThreshold = new FloatOption("scoreThreshold", 'h', "Initial dataset (%)", 1);
+	public IntOption slidingWindowSize = new IntOption("slidingWindowSize", 'W', "slidingWindowSize", 1000);
+	public IntOption slidingWindowStep = new IntOption("slidingWindowStep", 'j', "slidingWindowStep", 1);
+
+	private int nAttributes = 0;
+
+	protected double attributesPercentage;
+
+	public double getAttributesPercentage() {
+		return attributesPercentage;
+	}
+
+	public void setAttributesPercentage(double attributesPercentage) {
+		this.attributesPercentage = attributesPercentage;
+	}
+
+	public AMRulesMultiLabelLearnerSemiSuper() {
+		super();
+		super.randomSeedOption = this.randomSeedOption;
+		attributesPercentage = 100;
+	}
+
+	public AMRulesMultiLabelLearnerSemiSuper(double attributesPercentage) {
+		this();
+		this.attributesPercentage = attributesPercentage;
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		ErrorWeightedVoteMultiLabel vote = getVotes(inst);
+		if (vote != null)
+			return vote.getPrediction();
+		else
+			return null;
+	}
+
+	/**
+	 * getVotes extension of the instance method getVotesForInstance in
+	 * moa.classifier.java returns the prediction of the instance.
+	 */
+	public ErrorWeightedVoteMultiLabel getVotes(Instance instance) {
+
+		ErrorWeightedVoteMultiLabel errorWeightedVote = newErrorWeightedVote();
+		// int numberOfRulesCovering = 0;
+		VerboseToConsole(instance); // Verbose to console Dataset name.
+
+		for (MultiLabelRule rule : ruleSet) {
+
+			if (rule.isCovering(instance) == true) {
+				// numberOfRulesCovering++;
+
+				Prediction vote = rule.getPredictionForInstance(instance);
+
+				if (vote != null) { // should only happen for first instance
+					double[] errors = rule.getCurrentErrors();
+					if (errors == null) // if errors==null, rule has seen no predictions since expansion: return maximum
+										// error, since prediction is not reliable
+						errors = defaultRuleErrors(vote);
+					debug("Rule No" + rule.getRuleNumberID() + " Vote: " + vote.toString() + " Error: " + errors
+							+ " Y: " + instance.classValue(), 3); // predictionValueForThisRule);
+					errorWeightedVote.addVote(vote, errors);
+				}
+
+				if (VerbosityOption.getValue() > 1) {
+					System.out.print("Rule " + rule.getRuleNumberID() + ": ");
+					for (int i = 0; i < instance.numOutputAttributes(); i++) {
+						System.out.print(" " + vote.getVotes(i)[0]);
+					}
+					System.out.print("\n");
+				}
+
+				if (!this.unorderedRulesOption.isSet()) { // Ordered Rules Option.
+					break; // Only one rule cover the instance.
+				}
+			}
+		}
+
+		if (!errorWeightedVote.coversAllOutputs()) {
+			// Complete Prediction (fill missing outputs with default)
+			Prediction vote = errorWeightedVote.getPrediction();
+
+			if (vote == null) { // use default rule
+				vote = new MultiTargetRegressionPrediction(instance.numOutputAttributes());
+			}
+
+			Prediction defaultVote = defaultRule.getPredictionForInstance(instance);
+			if (defaultVote != null) {
+
+				double[] defaultErrors = defaultRule.getCurrentErrors();
+
+				if (defaultErrors == null)
+					defaultErrors = defaultRuleErrors(defaultVote);
+
+				double[] fixErrors = new double[vote.numOutputAttributes()];
+				Prediction fixVote = new MultiTargetRegressionPrediction(vote.numOutputAttributes());
+				for (int i = 0; i < vote.numOutputAttributes(); i++) {
+					if (!vote.hasVotesForAttribute(i)) {
+						fixVote.setVote(i, defaultVote.getPrediction(i));
+						fixErrors[i] = defaultErrors[i];
+					}
+				}
+				errorWeightedVote.addVote(fixVote, fixErrors);
+				debug("Default Rule Vote " + defaultVote.toString() + "\n Error " + defaultErrors + "  Y: " + instance,
+						3);
+			}
+		}
+		errorWeightedVote.computeWeightedVote();
+
+		return errorWeightedVote;
+	}
+
+	/*
+	 * Returns the estimate error for each output of a rule Should be used when
+	 * rule.getCurrentErrors() returns null
+	 */
+	protected double[] defaultRuleErrors(Prediction vote) {
+		double[] errors = new double[vote.numOutputAttributes()];
+		for (int i = 0; i < vote.numOutputAttributes(); i++) {
+			if (vote.hasVotesForAttribute(i))
+				errors[i] = Double.MAX_VALUE;
+		}
+		return errors;
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	/**
+	 * AMRules Algorithm. Method for updating (training) the AMRules model using a
+	 * new instance
+	 */
+
+	private double numChangesDetected; // Just for statistics
+	private double numAnomaliesDetected; // Just for statistics
+	private double numInstances; // Just for statistics
+	private FeatureRanking featureRanking;
+	public Prediction prediction;
+	public int numberTotalExamples;
+	public boolean hasModel = false;
+	boolean isUnlabeled;
+	public AnomalyDetector anomalyDetector2;
+
+	@Override
+	public void trainOnInstanceImpl(Instance instance) {
+
+		if (nAttributes == 0)
+			nAttributes = instance.numInputAttributes();
+
+		numInstances += instance.weight();
+		debug("Train", 3);
+		debug("Nº instance "
+				+ numInstances + " - " + instance.toString(), 3);
+
+		boolean rulesCoveringInstance = false;
+		ListIterator<MultiLabelRule> ruleIterator = this.ruleSet.listIterator();
+
+		numberTotalExamples++;
+
+		prediction = new MultiLabelClassificationPrediction(instance.numOutputAttributes());
+		boolean isUnlabeledRejected = true;
+
+		isUnlabeled = false;
+		for (int m = 0; m < instance.numOutputAttributes(); m++) {
+			if (instance.valueOutputAttribute(m) == Double.NEGATIVE_INFINITY) {
+				isUnlabeled = true;
+				break;
+			}
+		}
+
+		if (numberTotalExamples == 1) {
+			anomalyDetector2 = new OddsRatioScore();
+		}
+
+		// ----------------------------------------------------------------------
+		while (ruleIterator.hasNext()) {
+			MultiLabelRule rule = ruleIterator.next();
+			if (rule.isCovering(instance) == true) {
+				rulesCoveringInstance = true;
+				if (!rule.updateAnomalyDetection(instance)) {
+					prediction = rule.getPredictionForInstance(instance);
+					if (isUnlabeled) {
+						if (rule.getAnomalyScore() >= scoreThreshold.getValue()) {
+							for (int a = 0; a < instance.numOutputAttributes(); a++)
+								instance.setClassValue(a, prediction.getVote(a, 0));
+							isUnlabeledRejected = false; // Unlabeled rejected
+						} else
+							continue;
+					}
+
+					// ----------------------------------------------------------
+					if (rule.updateChangeDetection(instance)) {
+						debug("I) Drift Detected. Exa. : " + numInstances + " (" + rule.getWeightSeenSinceExpansion()
+								+ ") Remove Rule: " + rule.getRuleNumberID(), 1);
+						ruleIterator.remove(); // Remove a regra
+						rule.notifyAll(new ChangeDetectedMessage()); // Rule expansion event
+						this.numChangesDetected += instance.weight(); // Just for statistics
+					} else {
+
+						rule.trainOnInstance(instance); // <<<<<<<<<<<<
+						if (rule.getWeightSeenSinceExpansion() % gracePeriodOption.getValue() == 0.0) {
+							if (rule.tryToExpand(splitConfidenceOption.getValue(), tieThresholdOption.getValue())) {
+
+								MultiLabelRule otherMultiLabelRule = rule.getNewRuleFromOtherOutputs(); // Need to be
+																										// outside to
+																										// make sure
+																										// other rules
+																										// are cleaned
+
+								if (!dropOldRuleAfterExpansionOption.isSet() && rule.hasNewRuleFromOtherOutputs()) {
+									rule.clearOtherOutputs();
+									otherMultiLabelRule.setRuleNumberID(++ruleNumberID);
+									setRuleOptions(otherMultiLabelRule);
+									ruleIterator.add(otherMultiLabelRule);
+									if (observer != null)
+										otherMultiLabelRule.addObserver(observer);
+								}
+								setRuleOptions(rule);
+								debug("Rule Expanded:", 2);
+								debug(rule.toString(), 2);
+							}
+						}
+					}
+				} else {
+					debug("Anomaly Detected: " + numInstances + " Rule: " + rule.getRuleNumberID(), 1);
+					numAnomaliesDetected += instance.weight();// Just for statistics
+				}
+
+				// Testa se ordered ou unordered
+				if (!unorderedRulesOption.isSet())
+					break;
+			}
+
+		}
+
+		// ----------------------------------------------------------------------
+
+		if (rulesCoveringInstance == false) {
+
+			isUnlabeledRejected = false;
+
+			for (int m = 0; m < instance.numOutputAttributes(); m++) {
+				if (instance.valueOutputAttribute(m) == Double.NEGATIVE_INFINITY) {
+
+					prediction = defaultRule.getPredictionForInstance(instance);
+
+					for (int a = 0; a < instance.numOutputAttributes(); a++) {
+						instance.setClassValue(a, prediction.getVote(a, 0));
+					}
+					break;
+				}
+			}
+
+			defaultRule.trainOnInstance(instance);
+
+			if (defaultRule.getWeightSeenSinceExpansion() % this.gracePeriodOption.getValue() == 0.0) {
+				debug("Nr. examples " + defaultRule.getWeightSeenSinceExpansion(), 4);
+				if (defaultRule.tryToExpand(this.splitConfidenceOption.getValue(),
+						this.tieThresholdOption.getValue()) == true) {
+					MultiLabelRule newDefaultRule = defaultRule.getNewRuleFromOtherBranch();
+					newDefaultRule.setRuleNumberID(++ruleNumberID);
+					setRuleOptions(newDefaultRule);
+					setRuleOptions(defaultRule);
+					ruleSet.add(defaultRule);
+					debug("Default rule expanded! New Rule:", 2);
+					debug(defaultRule.toString(), 2);
+					debug("New default rule:", 3);
+					debug(newDefaultRule.toString(), 3);
+					defaultRule = newDefaultRule;
+					if (observer != null)
+						defaultRule.addObserver(observer);
+				}
+			}
+		}
+		// ----------------------------------------------------------------------
+	}
+
+	/**
+	 * print GUI evaluate model
+	 */
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		Measurement[] m = null;
+		Measurement[] mNoFeatureRanking = new Measurement[] {
+				new Measurement("anomaly detections", this.numAnomaliesDetected),
+				new Measurement("change detections", this.numChangesDetected),
+				new Measurement("rules (number)", this.ruleSet.size() + 1),
+				new Measurement("Avg #inputs/rule", getAverageInputs()),
+				new Measurement("Avg #outputs/rule", getAverageOutputs()) };
+
+		if (featureRanking instanceof NoFeatureRanking) {
+			m = mNoFeatureRanking;
+		} else {
+			m = new Measurement[mNoFeatureRanking.length + this.nAttributes];
+			for (int i = 0; i < mNoFeatureRanking.length; i++)
+				m[i] = mNoFeatureRanking[i];
+			DoubleVector rankings = this.featureRanking.getFeatureRankings();
+			for (int i = 0; i < this.nAttributes; i++)
+				m[i + mNoFeatureRanking.length] = new Measurement("Attribute" + i, rankings.getValue(i));
+		}
+		return m;
+	}
+
+	protected double getAverageInputs() {
+		double avg = 0;
+		int ct = 0;
+		if (ruleSet.size() > 0) {
+			for (MultiLabelRule r : ruleSet) {
+				int[] aux = r.getInputsCovered();
+				if (aux != null) {
+					avg += aux.length;
+					ct++;
+				}
+			}
+		}
+		int[] aux = defaultRule.getInputsCovered();
+		if (aux != null) {
+			avg += aux.length;
+			ct++;
+		}
+		if (ct > 0)
+			avg /= ct;
+		return avg;
+	}
+
+	protected double getAverageOutputs() {
+		double avg = 0;
+		int ct = 0;
+		if (ruleSet.size() > 0) {
+			for (MultiLabelRule r : ruleSet) {
+				int[] aux = r.getOutputsCovered();
+				if (aux != null) {
+					avg += aux.length;
+					ct++;
+				}
+			}
+		}
+		int[] aux = defaultRule.getOutputsCovered();
+		if (aux != null) {
+			avg += aux.length;
+			ct++;
+		}
+		if (ct > 0)
+			avg /= ct;
+		return avg;
+	}
+
+	/**
+	 * print GUI learn model
+	 */
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		if (!this.unorderedRulesOption.isSet()) {
+			StringUtils.appendIndented(out, indent, "Method Ordered");
+			StringUtils.appendNewline(out);
+		} else {
+			StringUtils.appendIndented(out, indent, "Method Unordered");
+			StringUtils.appendNewline(out);
+		}
+		StringUtils.appendIndented(out, indent, "Number of Rules: " + (this.ruleSet.size() + 1));
+		StringUtils.appendNewline(out);
+
+		StringUtils.appendIndented(out, indent, "Default rule :");
+		this.defaultRule.getDescription(out, indent);
+		StringUtils.appendNewline(out);
+
+		StringUtils.appendIndented(out, indent, "Rules in ruleSet:");
+		StringUtils.appendNewline(out);
+		for (MultiLabelRule rule : ruleSet) {
+			rule.getDescription(out, indent);
+			StringUtils.appendNewline(out);
+		}
+	}
+
+	/**
+	 * Print to console
+	 * 
+	 * @param string
+	 */
+	protected void debug(String string, int level) {
+		if (VerbosityOption.getValue() >= level) {
+			System.out.println(string);
+		}
+	}
+
+	protected void VerboseToConsole(Instance inst) {
+		if (VerbosityOption.getValue() >= 5) {
+			System.out.println();
+			System.out.println("I) Dataset: " + inst.dataset().getRelationName());
+
+			if (!this.unorderedRulesOption.isSet()) {
+				System.out.println("I) Method Ordered");
+			} else {
+				System.out.println("I) Method Unordered");
+			}
+		}
+	}
+
+	public void PrintRuleSet() {
+		debug("Default rule :", 2);
+		debug(this.defaultRule.toString(), 2);
+
+		debug("Rules in ruleSet:", 2);
+		for (MultiLabelRule rule : ruleSet) {
+			debug(rule.toString(), 2);
+		}
+	}
+
+	@Override
+	public void resetLearningImpl() {
+
+		defaultRule = newDefaultRule();
+		this.classifierRandom.setSeed(this.randomSeed);
+		InstanceLearner l = (InstanceLearner) ((InstanceLearner) getPreparedClassOption(learnerOption)).copy();
+
+		l.setRandomSeed(this.randomSeed);
+
+		l.resetLearning();
+		defaultRule.setLearner(l);
+		defaultRule.setInstanceTransformer(new NoInstanceTransformation());
+		setRuleOptions(defaultRule);
+		ruleSet = new MultiLabelRuleSet();
+		ruleNumberID = 1;
+		statistics = null;
+		this.featureRanking = (FeatureRanking) getPreparedClassOption(this.featureRankingOption);
+		setObserver(featureRanking);
+
+	}
+
+	protected void setRuleOptions(MultiLabelRule rule) {
+		rule.setSplitCriterion(
+				(MultiLabelSplitCriterion) ((MultiLabelSplitCriterion) getPreparedClassOption(splitCriterionOption))
+						.copy());
+		rule.setChangeDetector(((ChangeDetector) getPreparedClassOption(changeDetector)).copy());
+		rule.setAnomalyDetector(((AnomalyDetector) getPreparedClassOption(anomalyDetector)).copy());
+		rule.setNumericObserverOption(
+				(NumericStatisticsObserver) ((NumericStatisticsObserver) getPreparedClassOption(numericObserverOption))
+						.copy());
+		rule.setNominalObserverOption(
+				(NominalStatisticsObserver) ((NominalStatisticsObserver) getPreparedClassOption(nominalObserverOption))
+						.copy());
+		rule.setErrorMeasurer(
+				(MultiLabelErrorMeasurer) ((MultiLabelErrorMeasurer) getPreparedClassOption(errorMeasurerOption))
+						.copy());
+		rule.setOutputAttributesSelector(
+				(OutputAttributesSelector) ((OutputAttributesSelector) getPreparedClassOption(outputSelectorOption))
+						.copy());
+		rule.setRandomGenerator(this.classifierRandom);
+		rule.setAttributesPercentage(this.attributesPercentage);
+		rule.setInputAttributesSelector(
+				(InputAttributesSelector) ((InputAttributesSelector) getPreparedClassOption(inputSelectorOption))
+						.copy());
+	}
+
+	abstract protected MultiLabelRule newDefaultRule();
+
+	public ErrorWeightedVoteMultiLabel newErrorWeightedVote() {
+		return (ErrorWeightedVoteMultiLabel) ((ErrorWeightedVoteMultiLabel) getPreparedClassOption(weightedVoteOption))
+				.copy();
+	}
+
+	@Override
+	public void setRandomSeed(int randomSeed) {
+		super.setRandomSeed(randomSeed);
+		this.classifierRandom.setSeed(randomSeed);
+	}
+
+	public void setObserver(ObserverMOAObject observer) {
+		this.observer = observer;
+		this.defaultRule.addObserver(observer);
+	}
+
+	@Override
+	public Prediction getTrainingPrediction(Instance trainInst) {
+		return prediction;
+	}
+
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/learners/predictors/rules/AMRulesMultiTargetRegressor.java b/moa/src/main/java/moa/learners/predictors/rules/AMRulesMultiTargetRegressor.java
new file mode 100644
index 000000000..48880752f
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/rules/AMRulesMultiTargetRegressor.java
@@ -0,0 +1,96 @@
+/*
+ *    AMRulesMultiTargetRegressor.java
+ *    Copyright (C) 2017 University of Porto, Portugal
+ *    @author J. Duarte, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.predictors.rules;
+
+import moa.learners.predictors.MultiTargetRegressor;
+import moa.learners.predictors.core.MultiLabelRule;
+import moa.learners.predictors.core.MultiLabelRuleRegression;
+import moa.learners.predictors.core.driftdetection.ChangeDetector;
+import moa.learners.predictors.core.errormeasurers.MultiLabelErrorMeasurer;
+import moa.learners.predictors.core.errormeasurers.RelativeMeanAbsoluteDeviationMT;
+import moa.learners.predictors.core.functions.AdaptiveMultiTargetRegressor;
+import moa.learners.predictors.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.learners.predictors.core.splitcriteria.MultiTargetVarianceRatio;
+import moa.learners.predictors.core.voting.ErrorWeightedVoteMultiLabel;
+import moa.learners.predictors.core.voting.InverseErrorWeightedVoteMultiLabel;
+import moa.options.ClassOption;
+
+/**
+ * AMRules Algorithm for multitarget
+ *
+ * splitCriterionOption- Split criterion used to assess the merit of a split
+ *
+ * weightedVoteOption - Weighted vote type
+ *
+ * learnerOption - Learner selection
+ *
+ * errorMeasurerOption - Measure of error for deciding which learner should
+ * predict
+ *
+ * changeDetector - Change selection
+ *
+ * João Duarte, João Gama, Albert Bifet, Adaptive Model Rules From High-Speed
+ * Data Streams. TKDD 10(3): 30:1-30:22 (2016)
+ * 
+ */
+
+public class AMRulesMultiTargetRegressor extends AMRulesMultiLabelLearner implements MultiTargetRegressor {
+
+	/**
+	 *
+	 */
+	private static final long serialVersionUID = 1L;
+
+	public AMRulesMultiTargetRegressor() {
+		splitCriterionOption = new ClassOption("splitCriterionOption", 'S',
+				"Split criterion used to assess the merit of a split", MultiLabelSplitCriterion.class,
+				MultiTargetVarianceRatio.class.getName());
+
+		weightedVoteOption = new ClassOption("weightedVoteOption", 'w', "Weighted vote type",
+				ErrorWeightedVoteMultiLabel.class, InverseErrorWeightedVoteMultiLabel.class.getName());
+
+		learnerOption = new ClassOption("learnerOption", 'L', "Learner", MultiTargetRegressor.class,
+				AdaptiveMultiTargetRegressor.class.getName());
+
+		errorMeasurerOption = new ClassOption("errorMeasurer", 'e',
+				"Measure of error for deciding which learner should predict.", MultiLabelErrorMeasurer.class,
+				RelativeMeanAbsoluteDeviationMT.class.getName());
+
+		changeDetector = new ClassOption("changeDetector", 'H', "Change Detector.", ChangeDetector.class,
+				"PageHinkleyDM -d 0.05 -l 35.0");
+	}
+
+	@Override
+	public ErrorWeightedVoteMultiLabel newErrorWeightedVote() {
+		return (ErrorWeightedVoteMultiLabel) ((ErrorWeightedVoteMultiLabel) getPreparedClassOption(weightedVoteOption))
+				.copy();
+
+	}
+
+	@Override
+	protected MultiLabelRule newDefaultRule() {
+		return new MultiLabelRuleRegression(1);
+	}
+
+	public AMRulesMultiTargetRegressor(double attributesPercentage) {
+		super(attributesPercentage);
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/rules/AMRulesMultiTargetRegressorSemiSuper.java b/moa/src/main/java/moa/learners/predictors/rules/AMRulesMultiTargetRegressorSemiSuper.java
new file mode 100644
index 000000000..2332eef25
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/rules/AMRulesMultiTargetRegressorSemiSuper.java
@@ -0,0 +1,71 @@
+/*
+ *    AMRulesMultiTargetRegressorSemiSuper.java
+ *    Copyright (C) 2017 University of Porto, Portugal
+ *    @author R. Sousa, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.predictors.rules;
+
+import moa.learners.predictors.MultiTargetRegressor;
+import moa.learners.predictors.SemiSupervisedInstanceLearner;
+import moa.learners.predictors.core.MultiLabelRule;
+import moa.learners.predictors.core.MultiLabelRuleRegression;
+import moa.learners.predictors.core.driftdetection.ChangeDetector;
+import moa.learners.predictors.core.errormeasurers.MultiLabelErrorMeasurer;
+import moa.learners.predictors.core.errormeasurers.RelativeMeanAbsoluteDeviationMT;
+import moa.learners.predictors.core.functions.AdaptiveMultiTargetRegressor;
+import moa.learners.predictors.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.learners.predictors.core.splitcriteria.MultiTargetVarianceRatio;
+import moa.learners.predictors.core.voting.ErrorWeightedVoteMultiLabel;
+import moa.learners.predictors.core.voting.InverseErrorWeightedVoteMultiLabel;
+import moa.options.ClassOption;
+
+public class AMRulesMultiTargetRegressorSemiSuper extends AMRulesMultiLabelLearnerSemiSuper
+		implements MultiTargetRegressor, SemiSupervisedInstanceLearner { // MultiTargetRegressor,
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Semi-supervised AMRules method for online multi-target regression.This method measures predicts the benefit of a unlabeled example to the models(using only the input information) to the model. If this benefit is higher than <scoreThreshold> then the algorithm predicts an output and artificially labels the example and use it for training.";
+	}
+
+	public AMRulesMultiTargetRegressorSemiSuper() {
+		splitCriterionOption = new ClassOption("splitCriterionOption", 'S',
+				"Split criterion used to assess the merit of a split", MultiLabelSplitCriterion.class,
+				MultiTargetVarianceRatio.class.getName());
+		weightedVoteOption = new ClassOption("weightedVoteOption", 'w', "Weighted vote type",
+				ErrorWeightedVoteMultiLabel.class, InverseErrorWeightedVoteMultiLabel.class.getName());
+		learnerOption = new ClassOption("learnerOption", 'L', "Learner", MultiTargetRegressor.class,
+				AdaptiveMultiTargetRegressor.class.getName());
+		errorMeasurerOption = new ClassOption("errorMeasurer", 'e',
+				"Measure of error for deciding which learner should predict.", MultiLabelErrorMeasurer.class,
+				RelativeMeanAbsoluteDeviationMT.class.getName());
+		changeDetector = new ClassOption("changeDetector", 'H', "Change Detector.", ChangeDetector.class,
+				"PageHinkleyDM -d 0.05 -l 35.0");
+	}
+
+	@Override
+	protected MultiLabelRule newDefaultRule() {
+		return new MultiLabelRuleRegression(1);
+	}
+
+	public AMRulesMultiTargetRegressorSemiSuper(double attributesPercentage) {
+		super(attributesPercentage);
+	}
+
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/rules/AMRulesRegressor.java b/moa/src/main/java/moa/learners/predictors/rules/AMRulesRegressor.java
similarity index 69%
rename from moa/src/main/java/moa/classifiers/rules/AMRulesRegressor.java
rename to moa/src/main/java/moa/learners/predictors/rules/AMRulesRegressor.java
index 34e148c1f..851d80572 100644
--- a/moa/src/main/java/moa/classifiers/rules/AMRulesRegressor.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/AMRulesRegressor.java
@@ -1,12 +1,11 @@
-package moa.classifiers.rules;
+package moa.learners.predictors.rules;
 
-import moa.classifiers.rules.multilabel.AMRulesMultiTargetRegressor;
-import moa.learners.MultiTargetRegressor;
+import moa.learners.predictors.MultiTargetRegressor;
 
 public class AMRulesRegressor extends AMRulesMultiTargetRegressor implements MultiTargetRegressor {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 
diff --git a/moa/src/main/java/moa/classifiers/rules/AMRulesRegressorOld.java b/moa/src/main/java/moa/learners/predictors/rules/AMRulesRegressorOld.java
similarity index 55%
rename from moa/src/main/java/moa/classifiers/rules/AMRulesRegressorOld.java
rename to moa/src/main/java/moa/learners/predictors/rules/AMRulesRegressorOld.java
index d1d6b5a02..09e87e451 100644
--- a/moa/src/main/java/moa/classifiers/rules/AMRulesRegressorOld.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/AMRulesRegressorOld.java
@@ -14,25 +14,25 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.classifiers.rules;
+package moa.learners.predictors.rules;
 
 /**
  * Adaptive Model Rules (AMRules), the streaming rule learning algorithm for regression problems.
- * 
+ *
  * @author  A. Bifet, J. Duarte, J. Gama (jgama@fep.up.pt)
- * @version $Revision: 2 $* 
- * 
- * This algorithm learn ordered and unordered rule set from data stream. Each rule in AMRules use a 
+ * @version $Revision: 2 $*
+ *
+ * This algorithm learn ordered and unordered rule set from data stream. Each rule in AMRules use a
  * Page-Hinkley test to detect changes in the processing generating data and react to changes by pruning the rule set.
  * This algorithm also does the detection of anomalies.
- * 
+ *
  * <p>Learning Adaptive Model Rules from High-Speed Data Streams, ECML 2013, E. Almeida, C. Ferreira, and J. Gama; </p>
  * Project Knowledge Discovery from Data Streams, FCT LIAAD-INESC TEC,.
- *  
+ *
  * <p>Parameters:</p>
  * <ul>
  * <li> Hoeffding Bound parameters</li>
@@ -41,7 +41,7 @@
  * <li> -g: GracePeriod, the number of instances a leaf should observe between split attempts </li>
  * <li> Page-Hinckley parameters</li>
  * <li> -H: Drift detection OFF</li>
- * <li> -a: The alpha value to use in the Page Hinckley change detection tests.</li> 
+ * <li> -a: The alpha value to use in the Page Hinckley change detection tests.</li>
  * <li> -l: The threshold value (Lambda) to be used in the Page Hinckley change detection tests.</li>
  * <li> Anomaly Detection parameters</li>
  * <li> -A: Anomaly detection ON</li>
@@ -54,7 +54,7 @@
  * <li> -s: randomSeed</li>
  * <li> -r: learning Ratio </li>
  * <li> -d: learning Ratio Decay</li>
- * <li> Output Verbose Level </li> 
+ * <li> Output Verbose Level </li>
  * <li> -v: Verbosity level 1 to 5<li>
  * </ul>
  */
@@ -63,142 +63,121 @@
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.MultiChoiceOption;
 
-import moa.classifiers.rules.core.Rule;
-import moa.classifiers.rules.core.Rule.Builder;
-import moa.classifiers.rules.core.RuleActiveLearningNode;
-import moa.classifiers.rules.core.RuleActiveRegressionNode;
-import moa.classifiers.rules.core.splitcriteria.AMRulesSplitCriterion;
-import moa.classifiers.rules.core.voting.ErrorWeightedVote;
-import moa.classifiers.rules.functions.Perceptron;
 import moa.core.StringUtils;
-import moa.learners.MultiTargetRegressor;
+import moa.learners.predictors.MultiTargetRegressor;
+import moa.learners.predictors.rules.core.Rule;
+import moa.learners.predictors.rules.core.RuleActiveLearningNode;
+import moa.learners.predictors.rules.core.RuleActiveRegressionNode;
+import moa.learners.predictors.rules.core.Rule.Builder;
+import moa.learners.predictors.rules.core.splitcriteria.AMRulesSplitCriterion;
+import moa.learners.predictors.rules.core.voting.ErrorWeightedVote;
+import moa.learners.predictors.rules.functions.Perceptron;
 import moa.options.ClassOption;
 
-
-
 public class AMRulesRegressorOld extends AbstractAMRules implements MultiTargetRegressor {
-	
-	
-	
+
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 5988040868275521928L;
 
-	//============================= SET OPTIONS ==============================//
-	
-	public FlagOption constantLearningRatioDecayOption = new FlagOption(
-			"learningRatio_Decay_set_constant", 'd',
+	// ============================= SET OPTIONS ==============================//
+
+	public FlagOption constantLearningRatioDecayOption = new FlagOption("learningRatio_Decay_set_constant", 'd',
 			"Learning Ratio Decay in Perceptron set to be constant. (The next parameter).");
-	
-	public FloatOption learningRatioOption = new FloatOption(
-			"learningRatio", 's', 
-			"Constante Learning Ratio to use for training the Perceptrons in the leaves.", 0.025); 
-	
-	public MultiChoiceOption predictionFunctionOption = new MultiChoiceOption(
-			"predictionFunctionOption", 'P', "The prediction function to use.", new String[]{
-					"Adaptative","Perceptron", "Target Mean"}, new String[]{
-					"Adaptative","Perceptron", "Target Mean"}, 0);
-	
-	public ClassOption votingTypeOption = new ClassOption("votingType",
-			'V', "Voting Type.", 
-			ErrorWeightedVote.class,
+
+	public FloatOption learningRatioOption = new FloatOption("learningRatio", 's',
+			"Constante Learning Ratio to use for training the Perceptrons in the leaves.", 0.025);
+
+	public MultiChoiceOption predictionFunctionOption = new MultiChoiceOption("predictionFunctionOption", 'P',
+			"The prediction function to use.", new String[] { "Adaptative", "Perceptron", "Target Mean" },
+			new String[] { "Adaptative", "Perceptron", "Target Mean" }, 0);
+
+	public ClassOption votingTypeOption = new ClassOption("votingType", 'V', "Voting Type.", ErrorWeightedVote.class,
 			"InverseErrorWeightedVote");
-	
-	public ClassOption splitCriterionOption = new ClassOption("splitCriterionOption",
-			'S', "Split Criterion", 
-			AMRulesSplitCriterion.class,
-			"VRSplitCriterion");
 
-	//============================= END SET OPTIONS ==============================//
+	public ClassOption splitCriterionOption = new ClassOption("splitCriterionOption", 'S', "Split Criterion",
+			AMRulesSplitCriterion.class, "VRSplitCriterion");
+
+	// ============================= END SET OPTIONS
+	// ==============================//
 
-	
-	//============================== Classes ====================================//
+	// ============================== Classes ====================================//
 
+	@Override
 	protected Rule newRule(int ID, RuleActiveLearningNode node, double[] statistics) {
-		Rule r=newRule(ID);
-		
-		if (node!=null)
-		{
-			if(((RuleActiveRegressionNode)node).getPerceptron()!=null)
-			{
-				((RuleActiveRegressionNode)r.getLearningNode()).setPerceptron(new Perceptron(((RuleActiveRegressionNode)node).getPerceptron()));
-				((RuleActiveRegressionNode)r.getLearningNode()).getPerceptron().setLearningRatio(this.learningRatioOption.getValue());
+		Rule r = newRule(ID);
+
+		if (node != null) {
+			if (((RuleActiveRegressionNode) node).getPerceptron() != null) {
+				((RuleActiveRegressionNode) r.getLearningNode())
+						.setPerceptron(new Perceptron(((RuleActiveRegressionNode) node).getPerceptron()));
+				((RuleActiveRegressionNode) r.getLearningNode()).getPerceptron()
+						.setLearningRatio(this.learningRatioOption.getValue());
 			}
-			if (statistics==null)
-			{
+			if (statistics == null) {
 				double mean;
-		        if(node.getNodeStatistics().getValue(0)>0){
-		        	mean=node.getNodeStatistics().getValue(1)/node.getNodeStatistics().getValue(0);
-		        	((RuleActiveRegressionNode)r.getLearningNode()).getTargetMean().reset(mean, 1); 
-		        }
-			}  
+				if (node.getNodeStatistics().getValue(0) > 0) {
+					mean = node.getNodeStatistics().getValue(1) / node.getNodeStatistics().getValue(0);
+					((RuleActiveRegressionNode) r.getLearningNode()).getTargetMean().reset(mean, 1);
+				}
+			}
 		}
-		if (statistics!=null && ((RuleActiveRegressionNode)r.getLearningNode()).getTargetMean()!=null)
-		{
+		if (statistics != null && ((RuleActiveRegressionNode) r.getLearningNode()).getTargetMean() != null) {
 			double mean;
-	        if(statistics[0]>0){
-	        	mean=statistics[1]/statistics[0];
-	        	((RuleActiveRegressionNode)r.getLearningNode()).getTargetMean().reset(mean, (long)statistics[0]); 
-	        }
+			if (statistics[0] > 0) {
+				mean = statistics[1] / statistics[0];
+				((RuleActiveRegressionNode) r.getLearningNode()).getTargetMean().reset(mean, (long) statistics[0]);
+			}
 		}
 		return r;
 	}
 
-
+	@Override
 	public RuleActiveLearningNode newRuleActiveLearningNode(Builder builder) {
-			return new RuleActiveRegressionNode(builder);
-		}
-	    
+		return new RuleActiveRegressionNode(builder);
+	}
+
+	@Override
 	public RuleActiveLearningNode newRuleActiveLearningNode(double[] initialClassObservations) {
-	    	return new RuleActiveRegressionNode(initialClassObservations);
+		return new RuleActiveRegressionNode(initialClassObservations);
 	}
-	
+
 	@Override
 	public void getModelDescription(StringBuilder out, int indent) {
 		super.getModelDescription(out, indent);
-		StringUtils.appendIndented(out, indent, "The prediction function used: "+this.predictionFunctionOption.getChosenLabel());
+		StringUtils.appendIndented(out, indent,
+				"The prediction function used: " + this.predictionFunctionOption.getChosenLabel());
 		StringUtils.appendNewline(out);
 	}
-	
+
 	/**
 	 * This method initializes and resets the algorithm.
 	 */
 	@Override
 	public void resetLearningImpl() {
-		this.statistics= new double[]{0.0,0,0};	
-		this.ruleNumberID=0;
+		this.statistics = new double[] { 0.0, 0, 0 };
+		this.ruleNumberID = 0;
 		this.defaultRule = newRule(++this.ruleNumberID);
 	}
- 
 
 	private Rule newRule(int ID) {
-		Rule r=new Rule.Builder().
-				threshold(this.pageHinckleyThresholdOption.getValue()).
-				alpha(this.pageHinckleyAlphaOption.getValue()).
-				changeDetection(this.DriftDetectionOption.isSet()).
-				predictionFunction(this.predictionFunctionOption.getChosenIndex()).
-		        statistics(new double[3]).
-				id(ID).
-				amRules(this).build();
+		Rule r = new Rule.Builder().threshold(this.pageHinckleyThresholdOption.getValue())
+				.alpha(this.pageHinckleyAlphaOption.getValue()).changeDetection(this.DriftDetectionOption.isSet())
+				.predictionFunction(this.predictionFunctionOption.getChosenIndex()).statistics(new double[3]).id(ID)
+				.amRules(this).build();
 		r.getBuilder().setOwner(r);
 		return r;
 	}
 
-
 	@Override
 	public boolean isRandomizable() {
 		return true;
 	}
 
-
 	@Override
 	public ErrorWeightedVote newErrorWeightedVote() {
-		return  (ErrorWeightedVote)((ErrorWeightedVote) votingTypeOption.getPreMaterializedObject()).copy();
+		return (ErrorWeightedVote) ((ErrorWeightedVote) votingTypeOption.getPreMaterializedObject()).copy();
 	}
 
 }
-		
-		
-
-
diff --git a/moa/src/main/java/moa/learners/predictors/rules/AbstractAMRules.java b/moa/src/main/java/moa/learners/predictors/rules/AbstractAMRules.java
new file mode 100644
index 000000000..e7b731df1
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/rules/AbstractAMRules.java
@@ -0,0 +1,410 @@
+/*
+ *    AbstractAMRules.java
+ *    Copyright (C) 2014 University of Porto, Portugal
+ *    @author A. Bifet, J. Duarte, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.predictors.rules;
+
+/**
+ * Adaptive Model Rules (AMRules), the streaming rule learning algorithm for regression problems.
+ *
+ *  @author  A. Bifet, J. Duarte, J. Gama (jgama@fep.up.pt)
+ * @version $Revision: 2 $*
+ *
+ * This algorithm learn ordered and unordered rule set from data stream. Each rule in AMRules use a
+ * Page-Hinkley test to detect changes in the processing generating data and react to changes by pruning the rule set.
+ * This algorithm also does the detection of anomalies.
+ *
+ **/
+
+import java.util.Arrays;
+import java.util.Iterator;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.MultiTargetRegressionPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Measurement;
+import moa.core.StringUtils;
+import moa.learners.predictors.AbstractMultiTargetRegressor;
+import moa.learners.predictors.core.attributeclassobservers.FIMTDDNumericAttributeClassLimitObserver;
+import moa.learners.predictors.rules.core.Rule;
+import moa.learners.predictors.rules.core.RuleActiveLearningNode;
+import moa.learners.predictors.rules.core.RuleSet;
+import moa.learners.predictors.rules.core.Rule.Builder;
+import moa.learners.predictors.rules.core.voting.ErrorWeightedVote;
+import moa.learners.predictors.rules.core.voting.Vote;
+import moa.options.ClassOption;
+
+public abstract class AbstractAMRules extends AbstractMultiTargetRegressor {
+
+	private static final long serialVersionUID = 1L;
+	protected RuleSet ruleSet = new RuleSet();
+	protected Rule defaultRule;
+	protected int ruleNumberID;
+	protected double[] statistics;
+	public static final double NORMAL_CONSTANT = Math.sqrt(2 * Math.PI);
+	public FloatOption splitConfidenceOption = new FloatOption("splitConfidence", 'c',
+			"Hoeffding Bound Parameter. The allowable error in split decision, values closer to 0 will take longer to decide.",
+			0.0000001, 0.0, 1.0);
+	public FloatOption tieThresholdOption = new FloatOption("tieThreshold", 't',
+			"Hoeffding Bound Parameter. Threshold below which a split will be forced to break ties.", 0.05, 0.0, 1.0);
+	public IntOption gracePeriodOption = new IntOption("gracePeriod", 'g',
+			"Hoeffding Bound Parameter. The number of instances a leaf should observe between split attempts.", 200, 1,
+			Integer.MAX_VALUE);
+	public FlagOption DriftDetectionOption = new FlagOption("DoNotDetectChanges", 'H',
+			"Drift Detection. Page-Hinkley.");
+	public FloatOption pageHinckleyAlphaOption = new FloatOption("pageHinckleyAlpha", 'a',
+			"The alpha value to use in the Page Hinckley change detection tests.", 0.005, 0.0, 1.0);
+	public IntOption pageHinckleyThresholdOption = new IntOption("pageHinckleyThreshold", 'l',
+			"The threshold value (Lambda) to be used in the Page Hinckley change detection tests.", 35, 0,
+			Integer.MAX_VALUE);
+	public FlagOption noAnomalyDetectionOption = new FlagOption("noAnomalyDetection", 'A',
+			"Disable anomaly Detection.");
+	public FloatOption multivariateAnomalyProbabilityThresholdOption = new FloatOption(
+			"multivariateAnomalyProbabilityThresholdd", 'm', "Multivariate anomaly threshold value.", 0.99, 0.0, 1.0);
+	public FloatOption univariateAnomalyprobabilityThresholdOption = new FloatOption(
+			"univariateAnomalyprobabilityThreshold", 'u', "Univariate anomaly threshold value.", 0.10, 0.0, 1.0);
+	public IntOption anomalyNumInstThresholdOption = new IntOption("anomalyThreshold", 'n',
+			"The threshold value of anomalies to be used in the anomaly detection.", 30, 0, Integer.MAX_VALUE);
+	public FlagOption unorderedRulesOption = new FlagOption("setUnorderedRulesOn", 'U', "unorderedRules.");
+
+	public IntOption VerbosityOption = new IntOption("verbosity", 'v',
+			"Output Verbosity Control Level. 1 (Less) to 5 (More)", 1, 1, 5);
+
+	public ClassOption numericObserverOption = new ClassOption("numericObserver", 'z', "Numeric observer.",
+			FIMTDDNumericAttributeClassLimitObserver.class, "FIMTDDNumericAttributeClassLimitObserver");
+
+	protected double attributesPercentage;
+
+	public double getAttributesPercentage() {
+		return attributesPercentage;
+	}
+
+	public void setAttributesPercentage(double attributesPercentage) {
+		this.attributesPercentage = attributesPercentage;
+	}
+
+	public AbstractAMRules() {
+		super();
+		attributesPercentage = 100;
+	}
+
+	public AbstractAMRules(double attributesPercentage) {
+		this();
+		this.attributesPercentage = attributesPercentage;
+	}
+
+	/**
+	 * description of the Methods used. isRandomizable resetLearningImpl newRule //
+	 * to build an object with the parameters. trainOnInstanceImpl isAnomaly
+	 * getPredictionForInstance getModelMeasurementsImpl getModelDescription // to
+	 * printout to MOA GUI debug // use debug('string') to printout to console
+	 */
+	@Override
+	public abstract boolean isRandomizable();
+
+	/**
+	 * Rule.Builder() to build an object with the parameters. If you have an
+	 * algorithm with many parameters, especially if some of them are optional, it
+	 * can be beneficial to define an object that represents all of the parameters.
+	 * 
+	 * @return
+	 */
+	abstract protected Rule newRule(int ID, RuleActiveLearningNode learningNode, double[] statistics); // Learning node
+																										// and
+																										// statistics
+																										// can be null
+
+	/**
+	 * AMRules Algorithm. Method for updating (training) the AMRules model using a
+	 * new instance
+	 */
+
+	private double numChangesDetected; // Just for statistics
+	private double numAnomaliesDetected; // Just for statistics
+	private double numInstances; //// Just for statistics
+
+	@Override
+	public void trainOnInstanceImpl(Instance instance) {
+		/**
+		 * AMRules Algorithm
+		 * 
+		 * //For each rule in the rule set //If rule covers the instance //if the
+		 * instance is not an anomaly //Update Change Detection Tests //Compute
+		 * prediction error //Call PHTest //If change is detected then //Remove rule
+		 * //Else //Update sufficient statistics of rule //If number of examples in rule
+		 * > Nmin //Expand rule //If ordered set then //break //If none of the rule
+		 * covers the instance //Update sufficient statistics of default rule //If
+		 * number of examples in default rule is multiple of Nmin //Expand default rule
+		 * and add it to the set of rules //Reset the default rule
+		 */
+		numInstances += instance.weight();
+		debug("Train", 3);
+		debug("Nº instance " + numInstances + " - " + instance.toString(), 3);
+		boolean rulesCoveringInstance = false;
+		Iterator<Rule> ruleIterator = this.ruleSet.iterator();
+		while (ruleIterator.hasNext()) {
+			Rule rule = ruleIterator.next();
+			if (rule.isCovering(instance) == true) {
+				rulesCoveringInstance = true;
+				if (isAnomaly(instance, rule) == false) {
+					// Update Change Detection Tests
+					double error = rule.computeError(instance); // Use adaptive mode error
+					boolean changeDetected = rule.getLearningNode().updateChangeDetection(error);
+					if (changeDetected == true) {
+						debug("I) Drift Detected. Exa. : " + this.numInstances + " (" + rule.getInstancesSeen()
+								+ ") Remove Rule: " + rule.getRuleNumberID(), 1);
+
+						ruleIterator.remove();
+						this.numChangesDetected += instance.weight(); // Just for statistics
+					} else {
+						rule.updateStatistics(instance);
+						if (rule.getInstancesSeen() % this.gracePeriodOption.getValue() == 0.0) {
+							if (rule.tryToExpand(this.splitConfidenceOption.getValue(),
+									this.tieThresholdOption.getValue())) {
+								rule.split();
+								debug("Rule Expanded:", 2);
+								debug(rule.printRule(), 2);
+							}
+						}
+					}
+				} else {
+					debug("Anomaly Detected: " + this.numInstances + " Rule: " + rule.getRuleNumberID(), 1);
+					this.numAnomaliesDetected += instance.weight();// Just for statistics
+				}
+				if (!this.unorderedRulesOption.isSet())
+					break;
+			}
+		}
+
+		if (rulesCoveringInstance == false) {
+			defaultRule.updateStatistics(instance);
+			if (defaultRule.getInstancesSeen() % this.gracePeriodOption.getValue() == 0.0) {
+				debug("Nr. examples " + defaultRule.getInstancesSeen(), 4);
+
+				if (defaultRule.tryToExpand(this.splitConfidenceOption.getValue(),
+						this.tieThresholdOption.getValue()) == true) {
+					Rule newDefaultRule = newRule(defaultRule.getRuleNumberID(), defaultRule.getLearningNode(),
+							defaultRule.getLearningNode().getStatisticsOtherBranchSplit()); // other branch
+					defaultRule.split();
+					defaultRule.setRuleNumberID(++ruleNumberID);
+					this.ruleSet.add(this.defaultRule);
+
+					debug("Default rule expanded! New Rule:", 2);
+					debug(defaultRule.printRule(), 2);
+					debug("New default rule:", 3);
+					debug(newDefaultRule.printRule(), 3);
+					defaultRule = newDefaultRule;
+
+				}
+			}
+		}
+	}
+
+	/**
+	 * Method to verify if the instance is an anomaly.
+	 * 
+	 * @param instance
+	 * @param rule
+	 * @return
+	 */
+	private boolean isAnomaly(Instance instance, Rule rule) {
+		// AMRUles is equipped with anomaly detection. If on, compute the anomaly value.
+		boolean isAnomaly = false;
+		if (this.noAnomalyDetectionOption.isSet() == false) {
+			if (rule.getInstancesSeen() >= this.anomalyNumInstThresholdOption.getValue()) {
+				isAnomaly = rule.isAnomaly(instance, this.univariateAnomalyprobabilityThresholdOption.getValue(),
+						this.multivariateAnomalyProbabilityThresholdOption.getValue(),
+						this.anomalyNumInstThresholdOption.getValue());
+			}
+		}
+		return isAnomaly;
+	}
+
+	/**
+	 * getPredictionForInstance extension of the instance method
+	 * getPredictionForInstance in moa.classifier.java returns the prediction of the
+	 * instance. Called in EvaluateModelRegression
+	 */
+	@Override
+	public Prediction getPredictionForInstance(Instance instance) {
+		return new MultiTargetRegressionPrediction(getVotes(instance).getVote());
+	}
+
+	/**
+	 * print GUI evaluate model
+	 */
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[] { new Measurement("anomaly detections", this.numAnomaliesDetected),
+				new Measurement("change detections", this.numChangesDetected),
+				new Measurement("rules (number)", this.ruleSet.size() + 1) };
+	}
+
+	/**
+	 * print GUI learn model
+	 */
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		indent = 0;
+		if (!this.unorderedRulesOption.isSet()) {
+			StringUtils.appendIndented(out, indent, "Method Ordered");
+			StringUtils.appendNewline(out);
+		} else {
+			StringUtils.appendIndented(out, indent, "Method Unordered");
+			StringUtils.appendNewline(out);
+		}
+		if (this.DriftDetectionOption.isSet()) {
+			StringUtils.appendIndented(out, indent, "Change Detection OFF");
+			StringUtils.appendNewline(out);
+		} else {
+			StringUtils.appendIndented(out, indent, "Change Detection ON");
+			StringUtils.appendNewline(out);
+		}
+		if (this.noAnomalyDetectionOption.isSet()) {
+			StringUtils.appendIndented(out, indent, "Anomaly Detection OFF");
+			StringUtils.appendNewline(out);
+		} else {
+			StringUtils.appendIndented(out, indent, "Anomaly Detection ON");
+			StringUtils.appendNewline(out);
+		}
+		StringUtils.appendIndented(out, indent, "Number of Rules: " + (this.ruleSet.size() + 1));
+		StringUtils.appendNewline(out);
+	}
+
+	/**
+	 * Print to console
+	 * 
+	 * @param string
+	 */
+	protected void debug(String string, int level) {
+		if (VerbosityOption.getValue() >= level) {
+			System.out.println(string);
+		}
+	}
+
+	protected void VerboseToConsole(Instance inst) {
+		if (VerbosityOption.getValue() >= 5) {
+			System.out.println();
+			System.out.println("I) Dataset: " + inst.dataset().getRelationName());
+
+			if (!this.unorderedRulesOption.isSet()) {
+				System.out.println("I) Method Ordered");
+			} else {
+				System.out.println("I) Method Unordered");
+			}
+		}
+	}
+
+	public void PrintRuleSet() {
+		debug("Rule in RuleSet:", 2);
+		for (Rule rule : ruleSet) {
+			debug(rule.printRule(), 2);
+		}
+
+		debug("Default rule :", 2);
+		debug(this.defaultRule.printRule(), 2);
+	}
+
+	abstract public RuleActiveLearningNode newRuleActiveLearningNode(Builder builder);
+
+	abstract public RuleActiveLearningNode newRuleActiveLearningNode(double[] initialClassObservations);
+
+	public int getModelAttIndexToInstanceAttIndex(int index, Instance inst) {
+		return modelAttIndexToInstanceAttIndex(index, inst);
+	}
+
+	@Override
+	public void resetLearningImpl() {
+
+	}
+
+	/**
+	 * Gets the index of the attribute in the instance, given the index of the
+	 * attribute in the learner.
+	 *
+	 * @param index the index of the attribute in the learner
+	 * @param inst  the instance
+	 * @return the index in the instance
+	 */
+	public static int modelAttIndexToInstanceAttIndex(int index, Instance inst) {
+		return index <= inst.classIndex() ? index : index + 1;
+	}
+
+	abstract public ErrorWeightedVote newErrorWeightedVote();
+
+	/**
+	 * getVotes extension of the instance method getPredictionForInstance in
+	 * moa.classifier.java returns the prediction of the instance. Called in
+	 * WeightedRandomRules
+	 */
+	public Vote getVotes(Instance instance) {
+		ErrorWeightedVote errorWeightedVote = newErrorWeightedVote();
+		// DoubleVector combinedVote = new DoubleVector();
+		debug("Test", 3);
+		int numberOfRulesCovering = 0;
+
+		VerboseToConsole(instance); // Verbose to console Dataset name.
+		for (Rule rule : ruleSet) {
+			if (rule.isCovering(instance) == true) {
+				numberOfRulesCovering++;
+				// DoubleVector vote = new DoubleVector(rule.getPrediction(instance));
+				double[] vote = rule.getPrediction(instance);
+				double error = rule.getCurrentError();
+				debug("Rule No" + rule.getRuleNumberID() + " Vote: " + Arrays.toString(vote) + " Error: " + error
+						+ " Y: " + instance.classValue(), 3); // predictionValueForThisRule);
+				errorWeightedVote.addVote(vote, error);
+				// combinedVote.addValues(vote);
+				if (!this.unorderedRulesOption.isSet()) { // Ordered Rules Option.
+					break; // Only one rule cover the instance.
+				}
+			}
+		}
+
+		if (numberOfRulesCovering == 0) {
+			// combinedVote = new DoubleVector(defaultRule.getPrediction(instance));
+			double[] vote = defaultRule.getPrediction(instance);
+			double error = defaultRule.getCurrentError();
+			errorWeightedVote.addVote(vote, error);
+
+			debug("Default Rule Vote " + Arrays.toString(vote) + " Error " + error + "  Y: " + instance.classValue(),
+					3);
+		}
+		double[] weightedVote = errorWeightedVote.computeWeightedVote();
+		double weightedError = errorWeightedVote.getWeightedError();
+
+		debug("Weighted Rule - Vote: " + Arrays.toString(weightedVote) + " Weighted Error: " + weightedError + " Y:"
+				+ instance.classValue(), 3);
+		return new Vote(weightedVote, weightedError);
+	}
+
+	@Override
+	public void setRandomSeed(int randomSeed) {
+		// this.randomSeed=randomSeed;
+		this.classifierRandom.setSeed(randomSeed);
+	}
+
+	// public int getRandomSeed(){
+	// return this.randomSeed;
+	// }
+
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/rules/BinaryClassifierFromRegressor.java b/moa/src/main/java/moa/learners/predictors/rules/BinaryClassifierFromRegressor.java
similarity index 67%
rename from moa/src/main/java/moa/classifiers/rules/BinaryClassifierFromRegressor.java
rename to moa/src/main/java/moa/learners/predictors/rules/BinaryClassifierFromRegressor.java
index 36cf4771e..94654986b 100644
--- a/moa/src/main/java/moa/classifiers/rules/BinaryClassifierFromRegressor.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/BinaryClassifierFromRegressor.java
@@ -18,16 +18,16 @@
  *
  */
 
-package moa.classifiers.rules;
+package moa.learners.predictors.rules;
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-import moa.classifiers.AbstractClassifier;
 import moa.core.Measurement;
-import moa.learners.Classifier;
-import moa.learners.Regressor;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.Regressor;
 import moa.options.ClassOption;
 
 /**
@@ -38,13 +38,14 @@
 public class BinaryClassifierFromRegressor extends AbstractClassifier {
 
 	/**
-	 * 
+	 *
 	 */
-    public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'r',
-            "Regressor to train.", Regressor.class, "rules.AMRulesRegressor");
-    
+	public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'r', "Regressor to train.", Regressor.class,
+			"rules.AMRulesRegressor");
+
 	private static final long serialVersionUID = 8271864290912280188L;
 	private Classifier regressor;
+
 	@Override
 	public boolean isRandomizable() {
 		// TODO Auto-generated method stub
@@ -53,25 +54,26 @@ public boolean isRandomizable() {
 
 	@Override
 	public Prediction getPredictionForInstance(Instance inst) {
-		//TODO: use a parameter determining the function to use to return the output.
-		//Current function is the step function. By default should return regressor values
-		double vote=this.regressor.getPredictionForInstance(inst).asDouble(); //Maybe pass the value through a sigmoid function
-		double [] ret = new double[2];
-		if (vote < 0.5){
-			ret[0]=1;
-			ret[1]=0;
-		}
-		else{
-			ret[0]=0;
-			ret[1]=1;
+		// TODO: use a parameter determining the function to use to return the output.
+		// Current function is the step function. By default should return regressor
+		// values
+		double vote = this.regressor.getPredictionForInstance(inst).asDouble(); // Maybe pass the value through a
+																				// sigmoid function
+		double[] ret = new double[2];
+		if (vote < 0.5) {
+			ret[0] = 1;
+			ret[1] = 0;
+		} else {
+			ret[0] = 0;
+			ret[1] = 1;
 		}
 		return new ClassificationPrediction(ret);
 	}
 
 	@Override
 	public void resetLearningImpl() {
-        this.regressor = (Classifier) getPreparedClassOption(this.baseLearnerOption);
-        this.regressor.resetLearning();
+		this.regressor = (Classifier) getPreparedClassOption(this.baseLearnerOption);
+		this.regressor.resetLearning();
 	}
 
 	@Override
@@ -87,7 +89,7 @@ protected Measurement[] getModelMeasurementsImpl() {
 
 	@Override
 	public void getModelDescription(StringBuilder out, int indent) {
-		
+
 	}
 
 }
\ No newline at end of file
diff --git a/moa/src/main/java/moa/learners/predictors/rules/MultiLabelRandomAMRules.java b/moa/src/main/java/moa/learners/predictors/rules/MultiLabelRandomAMRules.java
new file mode 100644
index 000000000..9756a341a
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/rules/MultiLabelRandomAMRules.java
@@ -0,0 +1,234 @@
+/*
+ *    MultiLabelRandomAMRules.java
+ *    Copyright (C) 2017 University of Porto, Portugal
+ *    @author J. Duarte, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.predictors.rules;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.MiscUtils;
+import moa.learners.predictors.AbstractMultiTargetRegressor;
+import moa.learners.predictors.MultiTargetRegressor;
+import moa.learners.predictors.core.errormeasurers.AbstractMultiTargetErrorMeasurer;
+import moa.learners.predictors.core.errormeasurers.MultiLabelErrorMeasurer;
+import moa.learners.predictors.core.featureranking.FeatureRanking;
+import moa.learners.predictors.core.featureranking.NoFeatureRanking;
+import moa.learners.predictors.core.voting.ErrorWeightedVoteMultiLabel;
+import moa.learners.predictors.core.voting.UniformWeightedVoteMultiLabel;
+import moa.options.ClassOption;
+
+public class MultiLabelRandomAMRules extends AbstractMultiTargetRegressor implements MultiTargetRegressor {
+
+	/**
+	 *
+	 */
+	private static final long serialVersionUID = 1L;
+	private int nAttributes = 0;
+
+	public IntOption VerbosityOption = new IntOption("verbosity", 'v',
+			"Output Verbosity Control Level. 1 (Less) to 2 (More)", 1, 1, 2);
+
+	public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l', "Classifier to train.",
+			AMRulesMultiLabelLearner.class, "AMRulesMultiTargetRegressor");
+
+	public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's', "The number of models in the bag.", 10, 1,
+			Integer.MAX_VALUE);
+
+	public FloatOption numAttributesPercentageOption = new FloatOption("numAttributesPercentage", 'n',
+			"The number of attributes to use per model.", 63.2, 0, 100);
+
+	public FlagOption useBaggingOption = new FlagOption("useBagging", 'p', "Use Bagging.");
+
+	public ClassOption votingFunctionOption = new ClassOption("votingFunction", 'V', "Voting Function.",
+			ErrorWeightedVoteMultiLabel.class, UniformWeightedVoteMultiLabel.class.getName());
+
+	public MultiChoiceOption votingTypeOption = new MultiChoiceOption("votingTypeOption", 'C',
+			"Select whether the base learner error is computed as the overall error or only the error of the rules that cover the example.",
+			new String[] { "Overall (Static)", "Only rules covered (Dynamic)" }, new String[] { "Overall", "Covered" },
+			0);
+
+//	public IntOption randomSeedOption = new IntOption("randomSeed", 'r',
+//			"Seed for random behaviour of the classifier.", 1);
+	protected AMRulesMultiLabelLearner[] ensemble;
+
+	protected MultiLabelErrorMeasurer[] errorMeasurer;
+
+	public ClassOption errorMeasurerOption = new ClassOption("errorMeasurer", 'e',
+			"Measure of error for deciding which learner should predict.", AbstractMultiTargetErrorMeasurer.class,
+			"MeanAbsoluteDeviationMT");
+
+	/*
+	 * protected double[] sumError; protected double[] nError;
+	 */
+
+	public ClassOption featureRankingOption = new ClassOption("featureRanking", 'F', "Feature ranking algorithm.",
+			FeatureRanking.class, NoFeatureRanking.class.getName());
+
+	protected boolean isRegression;
+	protected FeatureRanking featureRanking;
+
+	@Override
+	public void resetLearningImpl() {
+		this.classifierRandom.setSeed(this.randomSeedOption.getValue());
+		int n = this.ensembleSizeOption.getValue();
+		this.ensemble = new AMRulesMultiLabelLearner[n];
+		this.errorMeasurer = new MultiLabelErrorMeasurer[n];
+
+		AMRulesMultiLabelLearner baseLearner = (AMRulesMultiLabelLearner) getPreparedClassOption(
+				this.baseLearnerOption);
+		MultiLabelErrorMeasurer measurer = (MultiLabelErrorMeasurer) getPreparedClassOption(this.errorMeasurerOption);
+		baseLearner.setAttributesPercentage(numAttributesPercentageOption.getValue());
+		baseLearner.resetLearning();
+		for (int i = 0; i < this.ensemble.length; i++) {
+			this.ensemble[i] = (AMRulesMultiLabelLearner) baseLearner.copy();
+			this.ensemble[i].setRandomSeed(this.classifierRandom.nextInt());
+			this.errorMeasurer[i] = (MultiLabelErrorMeasurer) measurer.copy();
+		}
+		this.isRegression = (baseLearner instanceof MultiTargetRegressor);
+		featureRanking = (FeatureRanking) getPreparedClassOption(this.featureRankingOption);
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance instance) {
+		if (featureRanking == null) {
+			featureRanking = (FeatureRanking) getPreparedClassOption(this.featureRankingOption);
+			for (int i = 0; i < this.ensemble.length; i++) {
+				this.ensemble[i].setObserver(featureRanking);
+			}
+			nAttributes = instance.numInputAttributes();
+		}
+		for (int i = 0; i < this.ensemble.length; i++) {
+			Instance inst = instance.copy();
+			int k = 1;
+			if (this.useBaggingOption.isSet()) {
+				k = MiscUtils.poisson(1.0, this.classifierRandom);
+			}
+			if (k > 0) {
+				// Instance weightedInst = transformInstance(inst,i);
+				inst.setWeight(inst.weight() * k);
+				// estimate error
+				Prediction p = ensemble[i].getPredictionForInstance(inst);
+				if (p != null)
+					errorMeasurer[i].addPrediction(p, inst);
+				// train learner
+				this.ensemble[i].trainOnInstance(inst);
+			}
+		}
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		Prediction vote = null;
+		// ErrorWeightedVote combinedVote = (ErrorWeightedVote)((ErrorWeightedVote)
+		// votingTypeOption.getPreMaterializedObject()).copy();
+		ErrorWeightedVoteMultiLabel combinedVote = (ErrorWeightedVoteMultiLabel) ((ErrorWeightedVoteMultiLabel) getPreparedClassOption(
+				this.votingFunctionOption)).copy();
+		StringBuilder sb = null;
+		if (VerbosityOption.getValue() > 1)
+			sb = new StringBuilder();
+
+		for (int i = 0; i < this.ensemble.length; i++) {
+			// transformInstance method visibility changed from private to protected in
+			// RandomRules
+			ErrorWeightedVoteMultiLabel v = this.ensemble[i].getVotes(inst);
+			if (VerbosityOption.getValue() > 1)
+				sb.append(v.getPrediction() + ", " + " E: " + v.getWeightedError() + " ");
+			/*
+			 * if (!this.isRegression){ v.normalize(); }
+			 */
+			Prediction p = v.getPrediction();
+			if (p != null) {
+				if (this.votingTypeOption.getChosenIndex() == 0) {// Overall error estimation
+					combinedVote.addVote(p, errorMeasurer[i].getCurrentErrors());
+				} else // Error estimation over the rules that cover the example
+					combinedVote.addVote(p, v.getOutputAttributesErrors());
+			}
+		}
+		vote = combinedVote.computeWeightedVote();
+		if (VerbosityOption.getValue() > 1) {
+			sb.append(vote + ", ").append(inst.classValue());
+			System.out.println(sb.toString());
+		}
+		return vote;
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		// Measurement [] baseLearnerMeasurements=((AMRulesMultiLabelLearner)
+		// getPreparedClassOption(this.baseLearnerOption)).getModelMeasurements();
+		Measurement[] baseLearnerMeasurements = ensemble[0].getModelMeasurements();
+		int nMeasurements = baseLearnerMeasurements.length;
+
+		int numMeasurements;
+		if (featureRanking instanceof NoFeatureRanking)
+			numMeasurements = nMeasurements + 1;
+		else
+			numMeasurements = nMeasurements + nAttributes + 1;
+
+		Measurement[] m = new Measurement[numMeasurements];
+
+		int ensembleSize = 0;
+		if (this.ensemble != null) {
+			ensembleSize = this.ensemble.length;
+			for (int i = 0; i < nMeasurements; i++) {
+				double value = 0;
+				for (int j = 0; j < ensembleSize; ++j) {
+					Measurement[] measurements = ensemble[j].getModelMeasurements();
+					value += measurements[i].getValue();
+				}
+				m[i + 1] = new Measurement("Avg " + baseLearnerMeasurements[i].getName(), value / ensembleSize);
+			}
+		} else {
+			for (int i = 0; i < baseLearnerMeasurements.length; i++)
+				m[i + 1] = baseLearnerMeasurements[i];
+		}
+
+		m[0] = new Measurement("ensemble size", ensembleSize);
+
+		// add feature importance is a method was selected
+		if (!(featureRanking instanceof NoFeatureRanking)) {
+			DoubleVector rankings = this.featureRanking.getFeatureRankings();
+			for (int i = 0; i < nAttributes; i++) {
+				double importance = 0;
+				if (rankings != null)
+					importance = rankings.getValue(i);
+				m[i + nMeasurements + 1] = new Measurement("Attribute" + i, importance);
+			}
+		}
+		return m;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/rules/Predicates.java b/moa/src/main/java/moa/learners/predictors/rules/Predicates.java
similarity index 69%
rename from moa/src/main/java/moa/classifiers/rules/Predicates.java
rename to moa/src/main/java/moa/learners/predictors/rules/Predicates.java
index db1583359..60b8d0cc7 100644
--- a/moa/src/main/java/moa/classifiers/rules/Predicates.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/Predicates.java
@@ -14,85 +14,83 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-
-package moa.classifiers.rules;
+package moa.learners.predictors.rules;
 
 import com.yahoo.labs.samoa.instances.Instance;
 
 /**
  * Class that creates and evaluates the predicates
- * 
+ *
  * <p>Learning Decision Rules from Data Streams, IJCAI 2011, J. Gama,  P. Kosina </p>
  *
  * @author P. Kosina, E. Almeida, J. Gama
  * @version $Revision: 2 $
- * 
+ *
  */
 
 import moa.AbstractMOAObject;
 
-public class Predicates extends AbstractMOAObject{
-	
+public class Predicates extends AbstractMOAObject {
+
 	private static final long serialVersionUID = 1L;
-	
+
 	private double attributeValue;
-	
+
 	private double symbol;
-	
+
 	private double value;
-		
-	public Predicates(double attribVal, double symb,double val){
-	this.attributeValue = attribVal;
-	this.symbol = symb;
-	this.value = val;
-}
-	
+
+	public Predicates(double attribVal, double symb, double val) {
+		this.attributeValue = attribVal;
+		this.symbol = symb;
+		this.value = val;
+	}
+
 	public double getAttributeValue() {
 		return this.attributeValue;
 	}
-	
+
 	public double getSymbol() {
 		return this.symbol;
 	}
-	
+
 	public double getValue() {
 		return this.value;
 	}
-	
+
 	public void setAttributeValue(double attributeValue) {
 		this.attributeValue = attributeValue;
 	}
-	
+
 	public void setSymbol(double symbol) {
 		this.symbol = symbol;
 	}
-	
+
 	public void setValue(double value) {
 		this.value = value;
 	}
 
-	 public boolean evaluate(Instance inst) {
-	    boolean result = false;
-	    double attributeValue = inst.value((int) this.attributeValue);
-	    if (this.symbol == 0.0 && attributeValue == this.value) {
-	        result = true;
-	    } else if (this.symbol == -1.0 && attributeValue <= this.value) {
-	        result = true;
-	    } else if (this.symbol == 1.0 && attributeValue > this.value) {
-	        result = true;
-	    }
-	    return result;
+	public boolean evaluate(Instance inst) {
+		boolean result = false;
+		double attributeValue = inst.value((int) this.attributeValue);
+		if (this.symbol == 0.0 && attributeValue == this.value) {
+			result = true;
+		} else if (this.symbol == -1.0 && attributeValue <= this.value) {
+			result = true;
+		} else if (this.symbol == 1.0 && attributeValue > this.value) {
+			result = true;
+		}
+		return result;
 	}
 
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
 		// TODO Auto-generated method stub
-		
+
 	}
-         
 
 }
diff --git a/moa/src/main/java/moa/learners/predictors/rules/RuleClassification.java b/moa/src/main/java/moa/learners/predictors/rules/RuleClassification.java
new file mode 100644
index 000000000..10809faa5
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/rules/RuleClassification.java
@@ -0,0 +1,124 @@
+/*
+ *    RuleClassification.java
+ *    Copyright (C) 2012 University of Porto, Portugal
+ *    @author P. Kosina, E. Almeida, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.predictors.rules;
+
+/**
+ * Class that stores an arrayList  of predicates of a rule and the observers (statistics).
+ * This class implements a function that evaluates a rule.
+ *
+ * <p>Learning Decision Rules from Data Streams, IJCAI 2011, J. Gama,  P. Kosina </p>
+ *
+ * @author P. Kosina, E. Almeida, J. Gama
+ * @version $Revision: 2 $
+ *
+ *
+ */
+
+import java.util.ArrayList;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.AbstractMOAObject;
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.learners.predictors.core.attributeclassobservers.AttributeClassObserver;
+
+public class RuleClassification extends AbstractMOAObject {
+
+	private static final long serialVersionUID = 1L;
+
+	protected ArrayList<Predicates> predicateSet = new ArrayList<>();
+
+	protected AutoExpandVector<AttributeClassObserver> observers = new AutoExpandVector<>(); // Statistics.
+
+	protected AutoExpandVector<AttributeClassObserver> observersGauss = new AutoExpandVector<>(); // Statistics.
+
+	protected ArrayList<ArrayList<Double>> attributeStatisticsSupervised = new ArrayList<>();
+
+	protected ArrayList<ArrayList<Double>> squaredAttributeStatisticsSupervised = new ArrayList<>();
+
+	protected double[] weightAttribute; // The Perception weights.
+
+	protected DoubleVector attributeStatistics = new DoubleVector(); // Statistics used for error calculations.
+
+	protected DoubleVector attributesProbability = new DoubleVector(); // Probalility of each attribute.
+
+	protected DoubleVector squaredAttributeStatistics = new DoubleVector();
+
+	protected DoubleVector obserClassDistrib = new DoubleVector();
+
+	protected DoubleVector attributeMissingValues = new DoubleVector(); // for each attribute counts the number of
+																		// missing values.
+
+	protected int instancesSeen = 0; // The number of instances contributing to this model.
+
+	protected int instancesSeenTest = 0; // The number of instances test seen by the rule.
+
+	protected boolean reset = true; // If the model should be reset or not.
+
+	// Statistics used for normalize actualClass and predictedClass.
+	protected double actualClassStatistics = 0.0;
+
+	protected double squaredActualClassStatistics = 0.0;
+
+	protected double PHmT = 0; // The cumulative sum of the errors.
+
+	protected double PHMT = Double.MAX_VALUE; // The minimum error value seen so far.
+
+	protected double XiSum = 0; // Absolute error.
+
+	protected double ValorTargetRule = 0; // Target value of the rule.
+
+	public RuleClassification(RuleClassification x) {
+		for (int i = 0; i < x.predicateSet.size(); i++) {
+			Predicates pred = new Predicates(x.predicateSet.get(i).getAttributeValue(),
+					x.predicateSet.get(i).getSymbol(), x.predicateSet.get(i).getValue());
+			this.predicateSet.add(pred);
+		}
+
+	}
+
+	public RuleClassification() {
+
+	}
+
+	public boolean ruleEvaluate(Instance inst) {
+		int countTrue = 0;
+		boolean ruleEvalu = false;
+		for (int i = 0; i < predicateSet.size(); i++) {
+			if (predicateSet.get(i).evaluate(inst) == true) {
+				countTrue = countTrue + 1;
+			}
+		}
+		if (countTrue == predicateSet.size()) {
+			ruleEvalu = true;
+		} else {
+			ruleEvalu = false;
+		}
+		return ruleEvalu;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/rules/RuleClassifier.java b/moa/src/main/java/moa/learners/predictors/rules/RuleClassifier.java
new file mode 100644
index 000000000..4e88a5f08
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/rules/RuleClassifier.java
@@ -0,0 +1,1426 @@
+/*
+ *    RuleClassifier.java
+ *    Copyright (C) 2012 University of Porto, Portugal
+ *    @author P. Kosina, E. Almeida, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.predictors.rules;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.Collections;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.StringUtils;
+import moa.core.Utils;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.core.attributeclassobservers.AttributeClassObserver;
+import moa.learners.predictors.core.attributeclassobservers.BinaryTreeNumericAttributeClassObserver;
+import moa.learners.predictors.core.attributeclassobservers.GaussianNumericAttributeClassObserver;
+import moa.learners.predictors.core.attributeclassobservers.NominalAttributeClassObserver;
+import moa.learners.predictors.core.attributeclassobservers.BinaryTreeNumericAttributeClassObserver.Node;
+
+/**
+ * This classifier learn ordered and unordered rule set from data stream. This
+ * algorithm also does the detection of anomalies.
+ *
+ * <p>
+ * Learning Decision RuleClassifications from Data Streams, IJCAI 2011, J. Gama,
+ * P. Kosina
+ * </p>
+ *
+ *
+ * <p>
+ * Parameters:
+ * </p>
+ * <ul>
+ * <li>-p: Minimum value of p</li>
+ * <li>-t: Tie Threshold</li>
+ * <li>-c: Split Confidence</li>
+ * <li>-g: GracePeriod, the number of instances a leaf should observe between
+ * split attempts</li>
+ * <li>-o: Prediction function to use. Ex:FirstHit</li>
+ * <li>-r: Learn ordered or unordered rule</li>
+ * </ul>
+ *
+ * @author P. Kosina, E. Almeida, J. Gama
+ * @version $Revision: 2 $
+ */
+
+public class RuleClassifier extends AbstractClassifier implements Classifier {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Rule Classifier.";
+	}
+
+	protected Instance instance;
+
+	protected AutoExpandVector<AttributeClassObserver> attributeObservers;
+
+	protected AutoExpandVector<AttributeClassObserver> attributeObserversGauss;
+
+	protected DoubleVector observedClassDistribution;
+
+	protected DoubleVector saveBestEntropy = new DoubleVector(); // Saves the best value of entropy, cut_Point and
+																	// symbol.
+
+	protected DoubleVector saveBestEntropyNominalAttrib = new DoubleVector(); // Saves the best value of entropy and
+																				// their cut_Point.
+
+	protected DoubleVector ruleClassIndex = new DoubleVector(); // The index of the class for each rule.
+
+	protected DoubleVector saveBestGlobalEntropy = new DoubleVector();
+
+	protected ArrayList<ArrayList<Double>> saveBestValGlobalEntropy = new ArrayList<>(); // For each
+																											// attribute
+																											// contains
+																											// the best
+																											// value of
+																											// entropy
+																											// and its
+																											// cutPoint.
+
+	protected ArrayList<Double> saveTheBest = new ArrayList<>(); // Contains the best attribute.
+
+	protected ArrayList<RuleClassification> ruleSet = new ArrayList<>();
+
+	// protected DoubleVector ruleClassIndexAnomalis = new DoubleVector();
+	protected ArrayList<RuleClassification> ruleSetAnomalies = new ArrayList<>();
+
+	protected ArrayList<Integer> ruleAnomaliesIndex = new ArrayList<>();
+
+	protected ArrayList<ArrayList<Integer>> caseAnomaly = new ArrayList<>();
+
+	protected ArrayList<ArrayList<ArrayList<Double>>> ruleAttribAnomalyStatistics = new ArrayList<>();
+
+	protected ArrayList<RuleClassification> ruleSetAnomaliesSupervised = new ArrayList<>();
+
+	protected ArrayList<Integer> ruleAnomaliesIndexSupervised = new ArrayList<>();
+
+	protected ArrayList<ArrayList<Integer>> caseAnomalySupervised = new ArrayList<>();
+
+	protected ArrayList<ArrayList<ArrayList<Double>>> ruleAttribAnomalyStatisticsSupervised = new ArrayList<>();
+
+	double minEntropyTemp = Double.MAX_VALUE;
+
+	double cutPointTemp = 0.0;
+
+	double minEntropyNominalAttrib = Double.MAX_VALUE;
+
+	double symbol = 0.0;
+
+	int numInstance = 0;
+
+	int numAttributes = 0;
+
+	int numClass = 0;
+
+	Node root;
+
+	Predicates pred;
+
+	public FloatOption PminOption = new FloatOption("Pmin", 'p',
+			"Percentage of the total number of example seen in the node.", 0.1, 0.0, 1.0);
+
+	public FloatOption splitConfidenceOption = new FloatOption("splitConfidence", 'c',
+			"The allowable error in split decision, values closer to 0 will take longer to decide.", 0.000001, 0.0,
+			1.0);
+
+	public FloatOption tieThresholdOption = new FloatOption("tieThreshold", 't',
+			"Threshold below which a split will be forced to break ties.", 0.05, 0.0, 1.0);
+
+	public FloatOption anomalyProbabilityThresholdOption = new FloatOption("anomalyprobabilityThreshold", 'o',
+			"The threshold value.", 0.99, 0.0, 1.0);
+
+	public FloatOption probabilityThresholdOption = new FloatOption("probabilityThreshold", 'k', "The threshold value.",
+			0.10, 0.0, 1.0);
+
+	public IntOption anomalyNumInstThresholdOption = new IntOption("anomalyThreshold", 'i',
+			"The threshold value to be used in the anomaly detection.", 15, 0, Integer.MAX_VALUE);
+
+	public IntOption gracePeriodOption = new IntOption("gracePeriod", 'g',
+			"The number of instances a leaf should observe between split attempts.", 200, 0, Integer.MAX_VALUE);
+
+	public MultiChoiceOption predictionFunctionOption = new MultiChoiceOption("predictionFunctionOption", 'z',
+			"The prediction function to use.", new String[] { "firstHit", "weightedSum", "weightedMax" },
+			new String[] { "first Hit", "weighted Sum", "weighted Max" }, 0);
+
+	public FlagOption orderedRulesOption = new FlagOption("orderedRules", 'r', "orderedRules.");
+
+	public FlagOption anomalyDetectionOption = new FlagOption("anomalyDetection", 'u', "anomaly Detection.");
+
+	public FlagOption Supervised = new FlagOption("supervised", 'n', "supervised.");
+
+	public FlagOption Unsupervised = new FlagOption("unsupervised", 'm', "unsupervised.");
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		double[] votes = new double[this.numClass];
+		switch (this.predictionFunctionOption.getChosenIndex()) {
+		case 0:
+			votes = firstHit(inst);
+			break;
+		case 1:
+			votes = weightedSum(inst);
+			break;
+		case 2:
+			votes = weightedMax(inst);
+			break;
+		}
+		return new ClassificationPrediction(votes);
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return null;
+	}
+
+	@Override
+	public void resetLearningImpl() {
+		this.observedClassDistribution = new DoubleVector();
+		this.attributeObservers = new AutoExpandVector<>();
+		this.attributeObserversGauss = new AutoExpandVector<>();
+	}
+
+	public double getWeightSeen() {
+		return this.observedClassDistribution.sumOfValues();
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		int countRuleFiredTrue = 0;
+		boolean ruleFired = false;
+		this.instance = inst;
+		this.numAttributes = instance.numAttributes() - 1;
+		this.numClass = instance.numClasses();
+		this.numInstance = numInstance + 1;
+		int conta1 = 0;
+		for (int j = 0; j < ruleSet.size(); j++) {
+			if (this.ruleSet.get(j).ruleEvaluate(inst) == true) {
+				countRuleFiredTrue = countRuleFiredTrue + 1;
+
+				double anomaly = 0.0;
+				if (this.Supervised.isSet()) {
+					anomaly = computeAnomalySupervised(this.ruleSet.get(j), j, inst); // compute anomaly (Supervised
+																						// method)
+				} else if (this.Unsupervised.isSet()) {
+					anomaly = computeAnomalyUnsupervised(this.ruleSet.get(j), j, inst); // compute anomaly (Unsupervised
+																						// method)
+				}
+
+				if (anomaly >= this.anomalyProbabilityThresholdOption.getValue()) {
+					conta1 = conta1 + 1;
+				}
+				// System.out.print(numInstance+";"+anomaly+"\n");
+				try {
+
+					File dir = new File("SeaAnomaliesUnsupervised.txt");
+					FileWriter fileWriter = new FileWriter(dir, true);
+					PrintWriter printWriter = new PrintWriter(fileWriter);
+					printWriter.println(numInstance + ";" + anomaly);
+					printWriter.flush();
+					printWriter.close();
+
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+				if ((this.ruleSet.get(j).instancesSeen <= this.anomalyNumInstThresholdOption.getValue())
+						|| (anomaly < this.anomalyProbabilityThresholdOption.getValue()
+								&& this.anomalyDetectionOption.isSet())
+						|| !this.anomalyDetectionOption.isSet()) {
+					this.ruleSet.get(j).obserClassDistrib.addToValue((int) inst.classValue(), inst.weight());
+					for (int i = 0; i < inst.numAttributes() - 1; i++) {
+						int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
+
+						if (!inst.isMissing(instAttIndex)) {
+							AttributeClassObserver obs = this.ruleSet.get(j).observers.get(i); // Nominal and binary
+																								// tree.
+							AttributeClassObserver obsGauss = this.ruleSet.get(j).observersGauss.get(i); // Gaussian.
+							if (obs == null) {
+								obs = inst.attribute(instAttIndex).isNominal() ? newNominalClassObserver()
+										: newNumericClassObserver();
+								this.ruleSet.get(j).observers.set(i, obs);
+							}
+							if (obsGauss == null) {
+								obsGauss = inst.attribute(instAttIndex).isNumeric() ? newNumericClassObserver2() : null;
+								this.ruleSet.get(j).observersGauss.set(i, obsGauss);
+							}
+							obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
+							if (inst.attribute(instAttIndex).isNumeric()) {
+								obsGauss.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(),
+										inst.weight());
+							}
+						}
+					}
+					expandeRule(this.ruleSet.get(j), inst, j); // This function expands the rule
+				}
+				if (this.orderedRulesOption.isSet()) { // Ordered rules
+					break;
+				}
+			}
+		}
+		if (countRuleFiredTrue > 0) {
+			ruleFired = true;
+		} else {
+			ruleFired = false;
+		}
+		if (ruleFired == false) { // If none of the rules cover the example update sufficient statistics of the
+									// default rule
+			this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight());
+			for (int i = 0; i < inst.numAttributes() - 1; i++) {
+				int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
+				if (!inst.isMissing(instAttIndex)) {
+					AttributeClassObserver obs = this.attributeObservers.get(i);
+					AttributeClassObserver obsGauss = this.attributeObserversGauss.get(i);
+					if (obs == null) {
+						obs = inst.attribute(instAttIndex).isNominal() ? newNominalClassObserver()
+								: newNumericClassObserver();
+						this.attributeObservers.set(i, obs);
+					}
+					if (obsGauss == null) {
+						obsGauss = inst.attribute(instAttIndex).isNumeric() ? newNumericClassObserver2() : null;
+						this.attributeObserversGauss.set(i, obsGauss);
+					}
+					obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
+					if (inst.attribute(instAttIndex).isNumeric()) {
+						obsGauss.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(),
+								inst.weight());
+					}
+				}
+			}
+			createRule(inst); // This function creates a rule
+		}
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		if (this.anomalyDetectionOption.isSet()) {
+			if (this.Supervised.isSet()) {
+				this.printAnomaliesSupervised(out, indent); // Get Model Description (Supervised method)
+			} else if (this.Unsupervised.isSet()) {
+				this.printAnomaliesUnsupervised(out, indent); // Get Model Description (Unsupervised method)
+			}
+		} else {
+			this.getModelDescriptionNoAnomalyDetection(out, indent); // Get Model Description no Anomaly detection
+
+		}
+	}
+
+	public void printAnomaliesUnsupervised(StringBuilder out, int indent) { // Get Model Description (Unsupervised
+																			// method)
+
+		StringUtils.appendNewline(out);
+		StringUtils.appendIndented(out, indent, "**********************UNSUPERVISED*****************");
+		StringUtils.appendNewline(out);
+		StringUtils.appendNewline(out);
+		for (int k = 0; k < this.ruleSetAnomalies.size(); k++) {
+			StringUtils.appendIndented(out, indent, "Case: " + this.caseAnomaly.get(k).get(0) + "   Anomaly Score: "
+					+ this.caseAnomaly.get(k).get(1) + "%");
+			StringUtils.appendNewline(out); // Ver outra parte default
+			StringUtils.appendIndented(out, indent, "Rule " + this.ruleAnomaliesIndex.get(k) + ": ");
+			for (int i = 0; i < this.ruleSetAnomalies.get(k).predicateSet.size(); i++) {
+				if (this.ruleSetAnomalies.get(k).predicateSet.size() == 1) {
+					if (this.ruleSetAnomalies.get(k).predicateSet.get(i).getSymbol() == 0.0) {
+						String nam = this.instance
+								.attribute((int) this.ruleSetAnomalies.get(k).predicateSet.get(i).getAttributeValue())
+								.name();
+						String val = this.instance
+								.attribute((int) this.ruleSetAnomalies.get(k).predicateSet.get(i).getAttributeValue())
+								.value((int) this.ruleSetAnomalies.get(k).predicateSet.get(i).getValue());
+						StringUtils.appendIndented(out, indent, nam + " = " + val + " --> " + this.instance
+								.classAttribute().value((int) getRuleMajorityClassIndex(this.ruleSetAnomalies.get(k))));
+						StringUtils.appendNewline(out);
+					} else if (this.ruleSetAnomalies.get(k).predicateSet.get(i).getSymbol() == -1.0) {
+						String nam = this.instance
+								.attribute((int) this.ruleSetAnomalies.get(k).predicateSet.get(i).getAttributeValue())
+								.name();
+						StringUtils.appendIndented(out, indent,
+								nam + " <= " + this.ruleSetAnomalies.get(k).predicateSet.get(i).getValue() + " --> "
+										+ this.instance.classAttribute()
+												.value((int) ruleClassIndex.getValue(ruleAnomaliesIndex.get(k) - 1)));
+						StringUtils.appendNewline(out);
+					} else {
+						String nam = this.instance
+								.attribute((int) this.ruleSetAnomalies.get(k).predicateSet.get(i).getAttributeValue())
+								.name();
+						StringUtils.appendIndented(out, indent,
+								nam + " > " + this.ruleSetAnomalies.get(k).predicateSet.get(i).getValue() + " --> "
+										+ this.instance.classAttribute().value(
+												(int) this.ruleClassIndex.getValue(ruleAnomaliesIndex.get(k) - 1)));
+						StringUtils.appendNewline(out);
+					}
+				} else {
+					if (this.ruleSetAnomalies.get(k).predicateSet.get(i).getSymbol() == 0.0) {
+						String nam = this.instance
+								.attribute((int) this.ruleSetAnomalies.get(k).predicateSet.get(i).getAttributeValue())
+								.name();
+						String val = this.instance
+								.attribute((int) this.ruleSetAnomalies.get(k).predicateSet.get(i).getAttributeValue())
+								.value((int) this.ruleSetAnomalies.get(k).predicateSet.get(i).getValue());
+						StringUtils.appendIndented(out, indent, nam + " = " + val + " ");
+					} else if (this.ruleSetAnomalies.get(k).predicateSet.get(i).getSymbol() == -1.0) {
+						String nam = this.instance
+								.attribute((int) this.ruleSetAnomalies.get(k).predicateSet.get(i).getAttributeValue())
+								.name();
+						StringUtils.appendIndented(out, indent,
+								nam + " <= " + this.ruleSetAnomalies.get(k).predicateSet.get(i).getValue() + " ");
+					} else {
+						String nam = this.instance
+								.attribute((int) this.ruleSetAnomalies.get(k).predicateSet.get(i).getAttributeValue())
+								.name();
+						StringUtils.appendIndented(out, indent,
+								nam + " > " + this.ruleSetAnomalies.get(k).predicateSet.get(i).getValue() + " ");
+					}
+					if (i < this.ruleSetAnomalies.get(k).predicateSet.size() - 1) {
+						StringUtils.appendIndented(out, indent, "and ");
+					} else {
+						int count = getCountNominalAttrib(this.ruleSetAnomalies.get(k).predicateSet);
+						if ((this.ruleSetAnomalies.get(k).predicateSet.get(i).getSymbol() == 0.0) || (count != 0)) {
+							StringUtils.appendIndented(out, indent, " --> " + this.instance.classAttribute()
+									.value((int) getRuleMajorityClassIndex(this.ruleSetAnomalies.get(k))));
+							StringUtils.appendNewline(out);
+						} else {
+							StringUtils.appendIndented(out, indent, " --> " + this.instance.classAttribute()
+									.value((int) this.ruleClassIndex.getValue(ruleAnomaliesIndex.get(k) - 1)));
+							StringUtils.appendNewline(out);
+						}
+					}
+				}
+			}
+			for (int z = 0; z < this.ruleAttribAnomalyStatistics.get(k).size(); z++) {
+				if (this.ruleAttribAnomalyStatistics.get(k).get(z).size() == 5) {
+					String s = String.format("%.3e", this.ruleAttribAnomalyStatistics.get(k).get(z).get(4));
+					StringUtils.appendIndented(out, indent,
+							instance.attribute(this.ruleAttribAnomalyStatistics.get(k).get(z).get(0).intValue()).name()
+									+ "=" + round(this.ruleAttribAnomalyStatistics.get(k).get(z).get(1)) + "   ("
+									+ round(this.ruleAttribAnomalyStatistics.get(k).get(z).get(2)) + " +- "
+									+ round(this.ruleAttribAnomalyStatistics.get(k).get(z).get(3)) + ")   P=" + s);
+					StringUtils.appendNewline(out);
+				} else {
+					String s = String.format("%.3e", this.ruleAttribAnomalyStatistics.get(k).get(z).get(2));
+					String val = this.instance
+							.attribute(this.ruleAttribAnomalyStatistics.get(k).get(z).get(0).intValue())
+							.value(this.ruleAttribAnomalyStatistics.get(k).get(z).get(1).intValue());
+					StringUtils.appendIndented(out, indent,
+							instance.attribute(this.ruleAttribAnomalyStatistics.get(k).get(z).get(0).intValue()).name()
+									+ "=" + val + "   P=" + s);
+					StringUtils.appendNewline(out);
+				}
+
+			}
+			StringUtils.appendNewline(out);
+		}
+
+	}
+
+	public void printAnomaliesSupervised(StringBuilder out, int indent) { // Get Model Description (Supervised method)
+
+		StringUtils.appendNewline(out);
+		StringUtils.appendIndented(out, indent, "************************SUPERVISED*******************");
+		StringUtils.appendNewline(out);
+		StringUtils.appendNewline(out);
+		for (int k = 0; k < this.ruleSetAnomaliesSupervised.size(); k++) {
+			StringUtils.appendIndented(out, indent, "Case: " + this.caseAnomalySupervised.get(k).get(0)
+					+ "   Anomaly Score: " + this.caseAnomalySupervised.get(k).get(1) + "%");
+			StringUtils.appendNewline(out); // Ver outra parte default
+			StringUtils.appendIndented(out, indent, "Rule " + this.ruleAnomaliesIndexSupervised.get(k) + ": ");
+			for (int i = 0; i < this.ruleSetAnomaliesSupervised.get(k).predicateSet.size(); i++) {
+				if (this.ruleSetAnomaliesSupervised.get(k).predicateSet.size() == 1) {
+					if (this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getSymbol() == 0.0) {
+						String nam = this.instance.attribute(
+								(int) this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getAttributeValue())
+								.name();
+						String val = this.instance.attribute(
+								(int) this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getAttributeValue())
+								.value((int) this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getValue());
+						StringUtils.appendIndented(out, indent,
+								nam + " = " + val + " --> " + this.instance.classAttribute().value(
+										(int) getRuleMajorityClassIndex(this.ruleSetAnomaliesSupervised.get(k))));
+						StringUtils.appendNewline(out);
+					} else if (this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getSymbol() == -1.0) {
+						String nam = this.instance.attribute(
+								(int) this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getAttributeValue())
+								.name();
+						StringUtils.appendIndented(out, indent, nam + " <= "
+								+ this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getValue() + " --> "
+								+ this.instance.classAttribute()
+										.value((int) ruleClassIndex.getValue(ruleAnomaliesIndexSupervised.get(k) - 1)));
+						StringUtils.appendNewline(out);
+					} else {
+						String nam = this.instance.attribute(
+								(int) this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getAttributeValue())
+								.name();
+						StringUtils.appendIndented(out, indent, nam + " > "
+								+ this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getValue() + " --> "
+								+ this.instance.classAttribute().value(
+										(int) this.ruleClassIndex.getValue(ruleAnomaliesIndexSupervised.get(k) - 1)));
+						StringUtils.appendNewline(out);
+					}
+				} else {
+					if (this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getSymbol() == 0.0) {
+						String nam = this.instance.attribute(
+								(int) this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getAttributeValue())
+								.name();
+						String val = this.instance.attribute(
+								(int) this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getAttributeValue())
+								.value((int) this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getValue());
+						StringUtils.appendIndented(out, indent, nam + " = " + val + " ");
+					} else if (this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getSymbol() == -1.0) {
+						String nam = this.instance.attribute(
+								(int) this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getAttributeValue())
+								.name();
+						StringUtils.appendIndented(out, indent, nam + " <= "
+								+ this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getValue() + " ");
+					} else {
+						String nam = this.instance.attribute(
+								(int) this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getAttributeValue())
+								.name();
+						StringUtils.appendIndented(out, indent, nam + " > "
+								+ this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getValue() + " ");
+					}
+					if (i < this.ruleSetAnomaliesSupervised.get(k).predicateSet.size() - 1) {
+						StringUtils.appendIndented(out, indent, "and ");
+					} else {
+						int count = getCountNominalAttrib(this.ruleSetAnomaliesSupervised.get(k).predicateSet);
+						if ((this.ruleSetAnomaliesSupervised.get(k).predicateSet.get(i).getSymbol() == 0.0)
+								|| (count != 0)) {
+							StringUtils.appendIndented(out, indent, " --> " + this.instance.classAttribute()
+									.value((int) getRuleMajorityClassIndex(this.ruleSetAnomaliesSupervised.get(k))));
+							StringUtils.appendNewline(out);
+						} else {
+							StringUtils.appendIndented(out, indent, " --> " + this.instance.classAttribute().value(
+									(int) this.ruleClassIndex.getValue(ruleAnomaliesIndexSupervised.get(k) - 1)));
+							StringUtils.appendNewline(out);
+						}
+					}
+				}
+			}
+			for (int z = 0; z < this.ruleAttribAnomalyStatisticsSupervised.get(k).size(); z++) {
+				if (this.ruleAttribAnomalyStatisticsSupervised.get(k).get(z).size() == 5) {
+					String s = String.format("%.3e", this.ruleAttribAnomalyStatisticsSupervised.get(k).get(z).get(4));
+					StringUtils.appendIndented(out, indent,
+							instance.attribute(
+									this.ruleAttribAnomalyStatisticsSupervised.get(k).get(z).get(0).intValue()).name()
+									+ "=" + round(this.ruleAttribAnomalyStatisticsSupervised.get(k).get(z).get(1))
+									+ "   (" + round(this.ruleAttribAnomalyStatisticsSupervised.get(k).get(z).get(2))
+									+ " +- " + round(this.ruleAttribAnomalyStatisticsSupervised.get(k).get(z).get(3))
+									+ ")   P=" + s);
+					StringUtils.appendNewline(out);
+				} else {
+					String s = String.format("%.3e", this.ruleAttribAnomalyStatisticsSupervised.get(k).get(z).get(2));
+					String val = this.instance
+							.attribute(this.ruleAttribAnomalyStatisticsSupervised.get(k).get(z).get(0).intValue())
+							.value(this.ruleAttribAnomalyStatisticsSupervised.get(k).get(z).get(1).intValue());
+					StringUtils.appendIndented(out, indent,
+							instance.attribute(
+									this.ruleAttribAnomalyStatisticsSupervised.get(k).get(z).get(0).intValue()).name()
+									+ "=" + val + "   P=" + s);
+					StringUtils.appendNewline(out);
+				}
+
+			}
+			StringUtils.appendNewline(out);
+		}
+
+	}
+
+	public void getModelDescriptionNoAnomalyDetection(StringBuilder out, int indent) { // Get Model Description no
+																						// Anomaly detection
+		StringUtils.appendNewline(out);
+		StringUtils.appendIndented(out, indent, "Number of Rule: " + ruleSet.size());
+		StringUtils.appendNewline(out);
+		StringUtils.appendNewline(out);
+		for (int k = 0; k < this.ruleSet.size(); k++) {
+			StringUtils.appendIndented(out, indent, "Rule " + (k + 1) + ": ");
+			for (int i = 0; i < this.ruleSet.get(k).predicateSet.size(); i++) {
+				if (this.ruleSet.get(k).predicateSet.size() == 1) {
+					if (this.ruleSet.get(k).predicateSet.get(i).getSymbol() == 0.0) {
+						String nam = this.instance
+								.attribute((int) this.ruleSet.get(k).predicateSet.get(i).getAttributeValue()).name();
+						String val = this.instance
+								.attribute((int) this.ruleSet.get(k).predicateSet.get(i).getAttributeValue())
+								.value((int) this.ruleSet.get(k).predicateSet.get(i).getValue());
+						StringUtils.appendIndented(out, indent, nam + " = " + val + " --> " + this.instance
+								.classAttribute().value((int) getRuleMajorityClassIndex(this.ruleSet.get(k))));
+						StringUtils.appendNewline(out);
+					} else if (this.ruleSet.get(k).predicateSet.get(i).getSymbol() == -1.0) {
+						String nam = this.instance
+								.attribute((int) this.ruleSet.get(k).predicateSet.get(i).getAttributeValue()).name();
+						StringUtils.appendIndented(out, indent,
+								nam + " <= " + this.ruleSet.get(k).predicateSet.get(i).getValue() + " --> "
+										+ this.instance.classAttribute().value((int) ruleClassIndex.getValue(k)));
+						StringUtils.appendNewline(out);
+					} else {
+						String nam = this.instance
+								.attribute((int) this.ruleSet.get(k).predicateSet.get(i).getAttributeValue()).name();
+						StringUtils.appendIndented(out, indent,
+								nam + " > " + this.ruleSet.get(k).predicateSet.get(i).getValue() + " --> "
+										+ this.instance.classAttribute().value((int) this.ruleClassIndex.getValue(k)));
+						StringUtils.appendNewline(out);
+					}
+				} else {
+					if (this.ruleSet.get(k).predicateSet.get(i).getSymbol() == 0.0) {
+						String nam = this.instance
+								.attribute((int) this.ruleSet.get(k).predicateSet.get(i).getAttributeValue()).name();
+						String val = this.instance
+								.attribute((int) this.ruleSet.get(k).predicateSet.get(i).getAttributeValue())
+								.value((int) this.ruleSet.get(k).predicateSet.get(i).getValue());
+						StringUtils.appendIndented(out, indent, nam + " = " + val + " ");
+					} else if (this.ruleSet.get(k).predicateSet.get(i).getSymbol() == -1.0) {
+						String nam = this.instance
+								.attribute((int) this.ruleSet.get(k).predicateSet.get(i).getAttributeValue()).name();
+						StringUtils.appendIndented(out, indent,
+								nam + " <= " + this.ruleSet.get(k).predicateSet.get(i).getValue() + " ");
+					} else {
+						String nam = this.instance
+								.attribute((int) this.ruleSet.get(k).predicateSet.get(i).getAttributeValue()).name();
+						StringUtils.appendIndented(out, indent,
+								nam + " > " + this.ruleSet.get(k).predicateSet.get(i).getValue() + " ");
+					}
+					if (i < this.ruleSet.get(k).predicateSet.size() - 1) {
+						StringUtils.appendIndented(out, indent, "and ");
+					} else {
+						int count = getCountNominalAttrib(this.ruleSet.get(k).predicateSet);
+						if ((this.ruleSet.get(k).predicateSet.get(i).getSymbol() == 0.0) || (count != 0)) {
+							StringUtils.appendIndented(out, indent, " --> " + this.instance.classAttribute()
+									.value((int) getRuleMajorityClassIndex(this.ruleSet.get(k))));
+							StringUtils.appendNewline(out);
+						} else {
+							StringUtils.appendIndented(out, indent, " --> "
+									+ this.instance.classAttribute().value((int) this.ruleClassIndex.getValue(k)));
+							StringUtils.appendNewline(out);
+						}
+					}
+				}
+			}
+			StringUtils.appendNewline(out);
+		}
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+
+	public int getCountNominalAttrib(ArrayList<Predicates> predicateSet) {
+		int count = 0;
+		for (int i = 0; i < predicateSet.size(); i++) {
+			if (predicateSet.get(i).getSymbol() == 0.0) {
+				count = count + 1;
+				break;
+			}
+		}
+		return count;
+	}
+
+	// Round an number
+	protected BigDecimal round(double val) {
+		BigDecimal value = new BigDecimal(val);
+		if (val != 0.0) {
+			value = value.setScale(3, BigDecimal.ROUND_DOWN);
+		}
+		return value;
+	}
+
+	// This function initializes the statistics of a rule
+	public void initializeRuleStatistics(RuleClassification rl, Predicates pred, Instance inst) {
+		rl.predicateSet.add(pred);
+		rl.obserClassDistrib = new DoubleVector();
+		rl.observers = new AutoExpandVector<>();
+		rl.observersGauss = new AutoExpandVector<>();
+		rl.instancesSeen = 0;
+		rl.attributeStatistics = new DoubleVector();
+		rl.squaredAttributeStatistics = new DoubleVector();
+		rl.attributeStatisticsSupervised = new ArrayList<>();
+		rl.squaredAttributeStatisticsSupervised = new ArrayList<>();
+		rl.attributeMissingValues = new DoubleVector();
+	}
+
+	// Update rule statistics
+	public void updateRuleAttribStatistics(Instance inst, RuleClassification rl, int ruleIndex) {
+		rl.instancesSeen++;
+		if (rl.squaredAttributeStatisticsSupervised.size() == 0 && rl.attributeStatisticsSupervised.size() == 0) {
+			for (int s = 0; s < inst.numAttributes() - 1; s++) {
+				ArrayList<Double> temp1 = new ArrayList<>();
+				ArrayList<Double> temp2 = new ArrayList<>();
+				rl.attributeStatisticsSupervised.add(temp1);
+				rl.squaredAttributeStatisticsSupervised.add(temp2);
+				int instAttIndex = modelAttIndexToInstanceAttIndex(s, inst);
+				if (instance.attribute(instAttIndex).isNumeric()) {
+					for (int i = 0; i < inst.numClasses(); i++) {
+						rl.attributeStatisticsSupervised.get(s).add(0.0);
+						rl.squaredAttributeStatisticsSupervised.get(s).add(1.0);
+					}
+				}
+			}
+		}
+		for (int s = 0; s < inst.numAttributes() - 1; s++) {
+			int instAttIndex = modelAttIndexToInstanceAttIndex(s, inst);
+			if (!inst.isMissing(instAttIndex)) {
+				if (instance.attribute(instAttIndex).isNumeric()) {
+					rl.attributeStatistics.addToValue(s, inst.value(s));
+					rl.squaredAttributeStatistics.addToValue(s, inst.value(s) * inst.value(s));
+					double sumValue = rl.attributeStatisticsSupervised.get(s).get((int) inst.classValue())
+							+ inst.value(s);
+					rl.attributeStatisticsSupervised.get(s).set((int) inst.classValue(), sumValue);
+					double squaredSumvalue = rl.squaredAttributeStatisticsSupervised.get(s).get((int) inst.classValue())
+							+ (inst.value(s) * inst.value(s));
+					rl.squaredAttributeStatisticsSupervised.get(s).set((int) inst.classValue(), squaredSumvalue);
+				}
+			} else {
+				rl.attributeMissingValues.addToValue(s, 1);
+			}
+		}
+	}
+
+	// Compute anomalies unsupervised
+	public double computeAnomalyUnsupervised(RuleClassification rl, int ruleIndex, Instance inst) { // Unsupervised
+		ArrayList<Integer> caseAnomalyTemp = new ArrayList<>();
+		ArrayList<ArrayList<Double>> AttribAnomalyStatisticTemp2 = new ArrayList<>();
+		double D = 0.0;
+		double N = 0.0;
+
+		if (rl.instancesSeen > this.anomalyNumInstThresholdOption.getValue() && this.anomalyDetectionOption.isSet()) {
+			for (int x = 0; x < inst.numAttributes() - 1; x++) {
+				if (!inst.isMissing(x)) {
+					ArrayList<Double> AttribAnomalyStatisticTemp = new ArrayList<>();
+					if (inst.attribute(x).isNumeric()) { // Numeric Attributes
+						if ((rl.instancesSeen - rl.attributeMissingValues.getValue(x)) > 30) {
+							double mean = computeMean(rl.attributeStatistics.getValue(x), rl.instancesSeen);
+							double sd = computeSD(rl.squaredAttributeStatistics.getValue(x),
+									rl.attributeStatistics.getValue(x), rl.instancesSeen);
+							double probability = computeProbability(mean, sd, inst.value(x));
+							if (probability != 0.0) {
+								D = D + Math.log(probability);
+								if (probability < this.probabilityThresholdOption.getValue()) { // 0.10
+									N = N + Math.log(probability);
+									AttribAnomalyStatisticTemp.add((double) x);
+									AttribAnomalyStatisticTemp.add(inst.value(x));
+									AttribAnomalyStatisticTemp.add(mean);
+									AttribAnomalyStatisticTemp.add(sd);
+									AttribAnomalyStatisticTemp.add(probability);
+									AttribAnomalyStatisticTemp2.add(AttribAnomalyStatisticTemp);
+								}
+							}
+						}
+					} else { // Nominal Attributes
+						AutoExpandVector<DoubleVector> attribNominal = ((NominalAttributeClassObserver) rl.observers
+								.get(x)).attValDistPerClass; // Attributes values distribution per class
+						double numbAttribValue = 0.0;
+						double attribVal = inst.value(x); // Attribute value
+						for (int i = 0; i < attribNominal.size(); i++) {
+							if (attribNominal.get(i) != null) {
+								numbAttribValue = numbAttribValue + attribNominal.get(i).getValue((int) attribVal);
+							}
+						}
+						double probability = numbAttribValue / rl.instancesSeen;
+						if (probability != 0.0) {
+							D = D + Math.log(probability);
+							if (probability < this.probabilityThresholdOption.getValue()) { // 0.10
+								N = N + Math.log(probability);
+								AttribAnomalyStatisticTemp.add((double) x);
+								AttribAnomalyStatisticTemp.add(inst.value(x));
+								AttribAnomalyStatisticTemp.add(probability);
+								AttribAnomalyStatisticTemp2.add(AttribAnomalyStatisticTemp);
+							}
+						}
+					}
+				}
+			}
+		}
+		double anomaly = 0.0;
+		if (D != 0) {
+			anomaly = Math.abs(N / D);
+		}
+		if (anomaly >= this.anomalyProbabilityThresholdOption.getValue()) {
+			caseAnomalyTemp.add(this.numInstance);
+			double val = anomaly * 100;
+			caseAnomalyTemp.add((int) val);
+			this.caseAnomaly.add(caseAnomalyTemp);
+			RuleClassification x = new RuleClassification(this.ruleSet.get(ruleIndex));
+			this.ruleSetAnomalies.add(x);
+			this.ruleAnomaliesIndex.add(ruleIndex + 1);
+			this.ruleAttribAnomalyStatistics.add(AttribAnomalyStatisticTemp2);
+
+		}
+		return anomaly;
+	}
+
+	// Compute anomalies unsupervised
+	public double computeAnomalySupervised(RuleClassification rl, int ruleIndex, Instance inst) { // Not supervised
+		ArrayList<Integer> caseAnomalyTemp = new ArrayList<>();
+		ArrayList<ArrayList<Double>> AttribAnomalyStatisticTemp2 = new ArrayList<>();
+		double D = 0.0;
+		double N = 0.0;
+		if (rl.instancesSeen > this.anomalyNumInstThresholdOption.getValue() && this.anomalyDetectionOption.isSet()) {
+			for (int x = 0; x < inst.numAttributes() - 1; x++) {
+				if (!inst.isMissing(x)) {
+					ArrayList<Double> AttribAnomalyStatisticTemp = new ArrayList<>();
+					if (inst.attribute(x).isNumeric()) { // Numeric Attributes
+						if ((rl.instancesSeen - rl.attributeMissingValues.getValue(x)) > 30) {
+							double mean = computeMean(
+									rl.attributeStatisticsSupervised.get(x).get((int) inst.classValue()),
+									(int) rl.obserClassDistrib.getValue((int) inst.classValue()));
+							double sd = computeSD(
+									rl.squaredAttributeStatisticsSupervised.get(x).get((int) inst.classValue()),
+									rl.attributeStatisticsSupervised.get(x).get((int) inst.classValue()),
+									(int) rl.obserClassDistrib.getValue((int) inst.classValue()));
+							double probability = computeProbability(mean, sd, inst.value(x));
+							if (probability != 0.0) {
+								D = D + Math.log(probability);
+								if (probability < this.probabilityThresholdOption.getValue()) { // 0.10
+									N = N + Math.log(probability);
+									AttribAnomalyStatisticTemp.add((double) x);
+									AttribAnomalyStatisticTemp.add(inst.value(x));
+									AttribAnomalyStatisticTemp.add(mean);
+									AttribAnomalyStatisticTemp.add(sd);
+									AttribAnomalyStatisticTemp.add(probability);
+									AttribAnomalyStatisticTemp2.add(AttribAnomalyStatisticTemp);
+								}
+							}
+						}
+					} else { // Nominal
+						double attribVal = inst.value(x); // Attribute value
+						double classVal = inst.classValue(); // Attribute value
+						double probability = rl.observers.get(x).probabilityOfAttributeValueGivenClass(attribVal,
+								(int) classVal);
+						if (probability != 0.0) {
+							D = D + Math.log(probability);
+							if (probability < this.probabilityThresholdOption.getValue()) { // 0.10
+								N = N + Math.log(probability);
+								AttribAnomalyStatisticTemp.add((double) x);
+								AttribAnomalyStatisticTemp.add(inst.value(x));
+								AttribAnomalyStatisticTemp.add(probability);
+								AttribAnomalyStatisticTemp2.add(AttribAnomalyStatisticTemp);
+							}
+						}
+					}
+				}
+			}
+		}
+		double anomaly = 0.0;
+		if (D != 0) {
+			anomaly = Math.abs(N / D);
+		}
+		if (anomaly >= this.anomalyProbabilityThresholdOption.getValue()) {
+			caseAnomalyTemp.add(this.numInstance);
+			double val = anomaly * 100;
+			caseAnomalyTemp.add((int) val);
+			this.caseAnomalySupervised.add(caseAnomalyTemp);
+			RuleClassification y = new RuleClassification(this.ruleSet.get(ruleIndex));
+			this.ruleSetAnomaliesSupervised.add(y);
+			this.ruleAnomaliesIndexSupervised.add(ruleIndex + 1);
+			this.ruleAttribAnomalyStatisticsSupervised.add(AttribAnomalyStatisticTemp2);
+		}
+		return anomaly;
+	}
+
+	// Mean
+	public double computeMean(double sum, int size) {
+		return sum / size;
+	}
+
+	// Standard Deviation
+	public double computeSD(double squaredVal, double val, int size) {
+		return Math.sqrt((squaredVal - ((val * val) / size)) / size);
+	}
+
+	// Attribute probability
+	public double computeProbability(double mean, double sd, double value) {
+		sd = sd + 0.00001;
+		double probability = 0.0;
+		double diff = value - mean;
+		if (sd > 0.0) {
+			double k = (Math.abs(value - mean) / sd);
+			if (k > 1.0) {
+				probability = 1.0 / (k * k);
+			} else {
+				probability = Math.exp(-(diff * diff / (2.0 * sd * sd)));
+			}
+		}
+		return probability;
+	}
+
+	// This function creates a rule
+	public void createRule(Instance inst) {
+		int remainder = (int) Double.MAX_VALUE;
+		int numInstanciaObservers = (int) this.observedClassDistribution.sumOfValues();
+		if (numInstanciaObservers != 0 && this.gracePeriodOption.getValue() != 0) {
+			remainder = (numInstanciaObservers) % (this.gracePeriodOption.getValue());
+		}
+		if (remainder == 0) {
+			this.saveBestValGlobalEntropy = new ArrayList<>();
+			this.saveBestGlobalEntropy = new DoubleVector();
+			this.saveTheBest = new ArrayList<>();
+			this.minEntropyTemp = Double.MAX_VALUE;
+			this.minEntropyNominalAttrib = Double.MAX_VALUE;
+			theBestAttributes(inst, this.attributeObservers);
+			boolean HB = checkBestAttrib(numInstanciaObservers, this.attributeObservers,
+					this.observedClassDistribution);
+			if (HB == true) {
+				// System.out.print("this.saveTheBest"+this.saveTheBest+"\n");
+				double attributeValue = this.saveTheBest.get(3);
+				double symbol = this.saveTheBest.get(2); // =, <=, > : (0.0, -1.0, 1.0).
+				double value = this.saveTheBest.get(0); // Value of the attribute
+				this.pred = new Predicates(attributeValue, symbol, value);
+				RuleClassification Rl = new RuleClassification(); // Create RuleClassification.
+				Rl.predicateSet.add(pred);
+				this.ruleSet.add(Rl);
+				if (Rl.predicateSet.get(0).getSymbol() == -1.0 || Rl.predicateSet.get(0).getSymbol() == 1.0) {
+					double posClassDouble = this.saveTheBest.get(4);
+					this.ruleClassIndex.setValue(this.ruleSet.size() - 1, posClassDouble);
+				} else {
+					this.ruleClassIndex.setValue(ruleSet.size() - 1, 0.0);
+				}
+				this.observedClassDistribution = new DoubleVector();
+				this.attributeObservers = new AutoExpandVector<>();
+				this.attributeObserversGauss = new AutoExpandVector<>();
+			}
+		}
+	}
+
+	// This function This expands the rule
+	public void expandeRule(RuleClassification rl, Instance inst, int ruleIndex) {
+		int remainder = (int) Double.MAX_VALUE;
+		int numInstanciaObservers = (int) rl.obserClassDistrib.sumOfValues(); // Number of instances for this rule
+																				// observers.
+		this.updateRuleAttribStatistics(inst, rl, ruleIndex);
+		if (numInstanciaObservers != 0 && this.gracePeriodOption.getValue() != 0) {
+			remainder = (numInstanciaObservers) % (this.gracePeriodOption.getValue());
+		}
+		if (remainder == 0) {
+			this.saveBestValGlobalEntropy = new ArrayList<>();
+			this.saveBestGlobalEntropy = new DoubleVector();
+			this.saveTheBest = new ArrayList<>();
+			this.minEntropyTemp = Double.MAX_VALUE;
+			this.minEntropyNominalAttrib = Double.MAX_VALUE;
+			theBestAttributes(inst, rl.observers); // The best value of entropy for each attribute.
+			boolean HB = checkBestAttrib(numInstanciaObservers, rl.observers, rl.obserClassDistrib); // Check if the
+																										// best
+																										// attribute
+																										// value is
+																										// really the
+																										// best.
+			if (HB == true) {
+				double attributeValue = this.saveTheBest.get(3);
+				double symbol = this.saveTheBest.get(2); // =, <=, > (0.0, -1.0, 1.0).
+				double value = this.saveTheBest.get(0); // Value of the attribute.
+				this.pred = new Predicates(attributeValue, symbol, value);
+				int countPred = 0;
+				for (int i = 0; i < rl.predicateSet.size(); i++) { // Checks if the new predicate is not yet in the
+																	// predicateSet.
+					if (this.pred.getSymbol() == 0.0) { // Nominal Attribute.
+						if (rl.predicateSet.get(i).getAttributeValue() != this.pred.getAttributeValue()) {
+							countPred = countPred + 1;
+						}
+					} else {
+						if (rl.predicateSet.get(i).getAttributeValue() != this.pred.getAttributeValue()
+								|| rl.predicateSet.get(i).getSymbol() != this.pred.getSymbol()
+								|| rl.predicateSet.get(i).getValue() != this.pred.getValue()) {
+							countPred = countPred + 1;
+						}
+					}
+				}
+				if (countPred == rl.predicateSet.size()) {
+					int countDifPred = 0;
+					ArrayList<Predicates> predicSetTemp = new ArrayList<>();
+					for (int x = 0; x < rl.predicateSet.size(); x++) {
+						predicSetTemp.add(rl.predicateSet.get(x));
+					}
+					predicSetTemp.add(this.pred);
+					for (int f = 0; f < this.ruleSet.size(); f++) {
+						int countDifPredTemp = 0;
+						if (this.ruleSet.get(f).predicateSet.size() == predicSetTemp.size()) {
+							for (int x = 0; x < this.ruleSet.get(f).predicateSet.size(); x++) {
+								if (this.ruleSet.get(f).predicateSet.get(x).getAttributeValue() == predicSetTemp.get(x)
+										.getAttributeValue()
+										&& this.ruleSet.get(f).predicateSet.get(x).getSymbol() == predicSetTemp.get(x)
+												.getSymbol()
+										&& this.ruleSet.get(f).predicateSet.get(x).getValue() == predicSetTemp.get(x)
+												.getValue()) {
+									countDifPredTemp = countDifPredTemp + 1;
+								}
+							}
+							if (countDifPredTemp == predicSetTemp.size()) {
+								break;
+							} else {
+								countDifPred = countDifPred + 1;
+							}
+						} else {
+							countDifPred = countDifPred + 1;
+						}
+					}
+					if (countDifPred == this.ruleSet.size()) {
+						if (this.pred.getSymbol() == 0.0) {
+							initializeRuleStatistics(rl, pred, inst);
+						} else if (this.pred.getSymbol() == 1.0) {
+							int countIqualPred = 0;
+							for (int f = 0; f < rl.predicateSet.size(); f++) {
+								if (this.pred.getAttributeValue() == rl.predicateSet.get(f).getAttributeValue()
+										&& this.pred.getSymbol() == rl.predicateSet.get(f).getSymbol()) {
+									countIqualPred = countIqualPred + 1;
+									if (this.pred.getValue() > rl.predicateSet.get(f).getValue()) {
+										rl.predicateSet.remove(f);
+										initializeRuleStatistics(rl, pred, inst);
+									}
+								}
+							}
+							if (countIqualPred == 0) {
+								initializeRuleStatistics(rl, pred, inst);
+							}
+						} else {
+							int countIqualPred = 0;
+							for (int f = 0; f < rl.predicateSet.size(); f++) {
+								if (this.pred.getAttributeValue() == rl.predicateSet.get(f).getAttributeValue()
+										&& this.pred.getSymbol() == rl.predicateSet.get(f).getSymbol()) {
+									countIqualPred = countIqualPred + 1;
+									if (this.pred.getValue() < rl.predicateSet.get(f).getValue()) {
+										rl.predicateSet.remove(f);
+										initializeRuleStatistics(rl, pred, inst);
+									}
+								}
+							}
+							if (countIqualPred == 0) {
+								initializeRuleStatistics(rl, pred, inst);
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// This function gives the best value of entropy for each attribute
+	public void theBestAttributes(Instance instance, AutoExpandVector<AttributeClassObserver> observersParameter) {
+		for (int z = 0; z < instance.numAttributes() - 1; z++) {
+			if (!instance.isMissing(z)) {
+				int instAttIndex = modelAttIndexToInstanceAttIndex(z, instance);
+				ArrayList<Double> attribBest = new ArrayList<>();
+				if (instance.attribute(instAttIndex).isNominal()) {
+					this.minEntropyNominalAttrib = Double.MAX_VALUE;
+					AutoExpandVector<DoubleVector> attribNominal = ((NominalAttributeClassObserver) observersParameter
+							.get(z)).attValDistPerClass;
+					findBestValEntropyNominalAtt(attribNominal, instance.attribute(z).numValues()); // The best value
+																									// (lowest entropy)
+																									// of a nominal
+																									// attribute.
+					attribBest.add(this.saveBestEntropyNominalAttrib.getValue(0));
+					attribBest.add(this.saveBestEntropyNominalAttrib.getValue(1));
+					attribBest.add(this.saveBestEntropyNominalAttrib.getValue(2));
+					this.saveBestValGlobalEntropy.add(attribBest);
+					this.saveBestGlobalEntropy.setValue(z, this.saveBestEntropyNominalAttrib.getValue(1));
+				} else {
+					this.root = ((BinaryTreeNumericAttributeClassObserver) observersParameter.get(z)).root;
+					mainFindBestValEntropy(this.root); // The best value (lowest entropy) of a numeric attribute.
+					attribBest.add(this.saveBestEntropy.getValue(0));
+					attribBest.add(this.saveBestEntropy.getValue(1));
+					attribBest.add(this.saveBestEntropy.getValue(2));
+					attribBest.add(this.saveBestEntropy.getValue(4));
+					this.saveBestValGlobalEntropy.add(attribBest);
+					this.saveBestGlobalEntropy.setValue(z, this.saveBestEntropy.getValue(1));
+				}
+			} else {
+				double value = Double.MAX_VALUE;
+				this.saveBestGlobalEntropy.setValue(z, value);
+			}
+		}
+	}
+
+	// Compute Entropy
+	public double entropy(DoubleVector ValorDistClassE) {
+		double entropy = 0.0;
+		double sum = 0.0;
+		for (double d : ValorDistClassE.getArrayCopy()) {
+			if (d > 0.0) {
+				entropy -= d * Utils.log2(d);
+				sum += d;
+			}
+		}
+		return sum > 0.0 ? (entropy + sum * Utils.log2(sum)) / sum : 0.0;
+	}
+
+	// Get the best value of entropy and its cutPoint for a numeric attribute
+	public void findBestValEntropy(Node node, DoubleVector classCountL, DoubleVector classCountR, boolean status,
+			double minEntropy, DoubleVector parentCCLeft) {
+		if (this.root != null) {
+			if (node != null) {
+				int numClass = 0;
+				DoubleVector classCountLTemp = new DoubleVector();
+				DoubleVector classCountRTemp = new DoubleVector();
+				DoubleVector parentCCL = new DoubleVector();
+				DoubleVector parentCCLParameter = new DoubleVector();
+				for (int f = 0; f < node.classCountsLeft.numValues(); f++) {
+					parentCCLParameter.setValue(f, node.classCountsLeft.getValue(f));
+				}
+				for (int p = 0; p < parentCCLeft.numValues(); p++) {
+					parentCCL.addToValue(p, parentCCLeft.getValue(p));
+				}
+				if (classCountL.numValues() >= classCountR.numValues()) {
+					numClass = classCountL.numValues();
+				} else {
+					numClass = classCountR.numValues();
+				}
+				// Counting the real class count left and the real class count right.
+				if (node.cut_point != this.root.cut_point) {
+					for (int i = 0; i < numClass; i++) {
+						if (status == true) { // Left node.
+							double parentss = parentCCL.getValue(i)
+									- (node.classCountsLeft.getValue(i) + node.classCountsRight.getValue(i));
+							double left = classCountL.getValue(i) - node.classCountsRight.getValue(i) - parentss;
+							double right = classCountR.getValue(i) + node.classCountsRight.getValue(i) + parentss;
+							classCountLTemp.addToValue(i, left);
+							classCountRTemp.addToValue(i, right);
+						}
+						if (status == false) { // Right node.
+							double left = classCountL.getValue(i) + node.classCountsLeft.getValue(i);
+							double right = classCountR.getValue(i) - node.classCountsLeft.getValue(i);
+							classCountLTemp.addToValue(i, left);
+							classCountRTemp.addToValue(i, right);
+						}
+					}
+				} else {
+					classCountLTemp = classCountL;
+					classCountRTemp = classCountR;
+				}
+				double classCountLSum = classCountLTemp.sumOfValues();
+				double classCountRSum = classCountRTemp.sumOfValues();
+				double numInst = this.root.classCountsLeft.sumOfValues() + this.root.classCountsRight.sumOfValues();
+				// The entropy value for all nodes except for the root.
+				if ((classCountLSum > this.PminOption.getValue() * numInst)
+						&& (classCountRSum > this.PminOption.getValue() * numInst)) {
+					double classCountLEntropy = entropy(classCountLTemp); // Entropy of class count left.
+					double classCountREntropy = entropy(classCountRTemp); // Entropy of class count right
+					if (((classCountLSum / numInst) * classCountLEntropy
+							+ (classCountRSum / numInst) * classCountREntropy) <= minEntropy) {
+						this.minEntropyTemp = (classCountLSum / numInst) * classCountLEntropy
+								+ (classCountRSum / numInst) * classCountREntropy;
+						this.cutPointTemp = node.cut_point;
+						if (classCountLEntropy <= classCountREntropy) {
+							this.symbol = -1.0;
+							double value = 0.0;
+							double index = 0.0;
+							for (int h = 0; h < numClass; h++) {
+								if (value <= classCountLTemp.getValue(h)) {
+									value = classCountLTemp.getValue(h);
+									index = h;
+								}
+							}
+							this.saveBestEntropy.setValue(0, this.cutPointTemp);
+							this.saveBestEntropy.setValue(1, classCountLEntropy);
+							this.saveBestEntropy.setValue(2, this.symbol);
+							this.saveBestEntropy.setValue(4, index);
+						} else {
+							this.symbol = 1.0;
+							double value = 0.0;
+							double index = 0.0;
+							for (int h = 0; h < numClass; h++) {
+								if (value <= classCountRTemp.getValue(h)) {
+									value = classCountRTemp.getValue(h);
+									index = h;
+								}
+							}
+							this.saveBestEntropy.setValue(0, this.cutPointTemp);
+							this.saveBestEntropy.setValue(1, classCountREntropy);
+							this.saveBestEntropy.setValue(2, this.symbol);
+							this.saveBestEntropy.setValue(4, index);
+						}
+					}
+				}
+				findBestValEntropy(node.left, classCountLTemp, classCountRTemp, true, this.minEntropyTemp,
+						parentCCLParameter);
+				findBestValEntropy(node.right, classCountLTemp, classCountRTemp, false, this.minEntropyTemp,
+						parentCCLParameter);
+			}
+		}
+	}
+
+	// Best value of entropy
+	public void mainFindBestValEntropy(Node root) {
+		if (root != null) {
+			DoubleVector parentClassCL = new DoubleVector();
+			DoubleVector classCountL = root.classCountsLeft; // class count left
+			DoubleVector classCountR = root.classCountsRight; // class count left
+			double numInst = root.classCountsLeft.sumOfValues() + root.classCountsRight.sumOfValues();
+			double classCountLSum = root.classCountsLeft.sumOfValues();
+			double classCountRSum = root.classCountsRight.sumOfValues();
+			double classCountLEntropy = entropy(classCountL);
+			double classCountREntropy = entropy(classCountR);
+			this.minEntropyTemp = (classCountLSum / numInst) * classCountLEntropy
+					+ (classCountRSum / numInst) * classCountREntropy;
+			for (int f = 0; f < root.classCountsLeft.numValues(); f++) {
+				parentClassCL.setValue(f, root.classCountsLeft.getValue(f));
+			}
+			findBestValEntropy(root, classCountL, classCountR, true, this.minEntropyTemp, parentClassCL);
+		}
+	}
+
+	// Find best value of entropy for nominal attributes
+	public void findBestValEntropyNominalAtt(AutoExpandVector<DoubleVector> attrib, int attNumValues) {
+		ArrayList<ArrayList<Double>> distClassValue = new ArrayList<>();
+		// System.out.print("attrib"+attrib+"\n");
+		for (int z = 0; z < attrib.size(); z++) {
+			distClassValue.add(new ArrayList<Double>());
+		}
+		for (int v = 0; v < attNumValues; v++) {
+			DoubleVector saveVal = new DoubleVector();
+			for (int z = 0; z < attrib.size(); z++) {
+				if (attrib.get(z) != null) {
+					distClassValue.get(z).add(attrib.get(z).getValue(v));
+				} else {
+					distClassValue.get(z).add(0.0);
+				}
+				if (distClassValue.get(z).get(v).isNaN()) {
+					distClassValue.get(z).add(0.0);
+				}
+				saveVal.setValue(z, distClassValue.get(z).get(v));
+			}
+			double sumValue = saveVal.sumOfValues();
+			if (sumValue > 0.0) {
+				double entropyVal = entropy(saveVal);
+				if (entropyVal <= this.minEntropyNominalAttrib) {
+					this.minEntropyNominalAttrib = entropyVal;
+					this.saveBestEntropyNominalAttrib.setValue(0, v);
+					this.saveBestEntropyNominalAttrib.setValue(1, entropyVal);
+					this.saveBestEntropyNominalAttrib.setValue(2, 0.0);
+				}
+			}
+		}
+	}
+
+	// Hoeffding Bound
+	public double ComputeHoeffdingBound(double range, double confidence, double n) {
+		return Math.sqrt(((range * range) * Math.log(1.0 / confidence)) / (2.0 * n));
+	}
+
+	// Check if the best attribute is really the best
+	public boolean checkBestAttrib(double n, AutoExpandVector<AttributeClassObserver> observerss,
+			DoubleVector observedClassDistribution) {
+		double h0 = entropy(observedClassDistribution);
+		boolean isTheBest = false;
+		double[] entropyValues = getBestSecondBestEntropy(this.saveBestGlobalEntropy);
+		double bestEntropy = entropyValues[0];
+		double secondBestEntropy = entropyValues[1];
+		double range = Utils.log2(this.numClass);
+		double hoeffdingBound = ComputeHoeffdingBound(range, this.splitConfidenceOption.getValue(), n);
+		if ((h0 > bestEntropy) && ((secondBestEntropy - bestEntropy > hoeffdingBound)
+				|| (hoeffdingBound < this.tieThresholdOption.getValue()))) {
+			for (int i = 0; i < this.saveBestValGlobalEntropy.size(); i++) {
+				if (bestEntropy == (this.saveBestValGlobalEntropy.get(i).get(1))) {
+					this.saveTheBest.add(this.saveBestValGlobalEntropy.get(i).get(0));
+					this.saveTheBest.add(this.saveBestValGlobalEntropy.get(i).get(1));
+					this.saveTheBest.add(this.saveBestValGlobalEntropy.get(i).get(2));
+					this.saveTheBest.add((double) i);
+					if (this.saveTheBest.get(2) != 0.0) {
+						this.saveTheBest.add(this.saveBestValGlobalEntropy.get(i).get(3));
+					}
+					break;
+				}
+			}
+			isTheBest = true;
+		} else {
+			isTheBest = false;
+		}
+		return isTheBest;
+	}
+
+	// Get best and second best attributes
+	protected double[] getBestSecondBestEntropy(DoubleVector entropy) {
+		double[] entropyValues = new double[2];
+		double best = Double.MAX_VALUE;
+		double secondBest = Double.MAX_VALUE;
+		for (int i = 0; i < entropy.numValues(); i++) {
+			if (entropy.getValue(i) < best) {
+				secondBest = best;
+				best = entropy.getValue(i);
+			} else {
+				if (entropy.getValue(i) < secondBest) {
+					secondBest = entropy.getValue(i);
+				}
+			}
+		}
+		entropyValues[0] = best;
+		entropyValues[1] = secondBest;
+
+		return entropyValues;
+	}
+
+	// Get rule majority class index
+	protected double getRuleMajorityClassIndex(RuleClassification r) {
+		double maxvalue = 0.0;
+		int posMaxValue = 0;
+		for (int i = 0; i < r.obserClassDistrib.numValues(); i++) {
+			if (r.obserClassDistrib.getValue(i) > maxvalue) {
+				maxvalue = r.obserClassDistrib.getValue(i);
+				posMaxValue = i;
+			}
+		}
+		return posMaxValue;
+	}
+
+	// Get observers class distribution probability
+	protected double[] oberversDistribProb(Instance inst, DoubleVector classDistrib) {
+		double[] votes = new double[this.numClass];
+		double sum = classDistrib.sumOfValues();
+		for (int z = 0; z < this.numClass; z++) {
+			votes[z] = classDistrib.getValue(z) / sum;
+		}
+		return votes;
+	}
+
+	// The following three functions are used for the prediction
+	protected double[] firstHit(Instance inst) {
+		boolean fired = false;
+		int countFired = 0;
+		double[] votes = new double[this.numClass];
+		for (int j = 0; j < this.ruleSet.size(); j++) {
+			if (this.ruleSet.get(j).ruleEvaluate(inst) == true) {
+				countFired = countFired + 1;
+				for (int z = 0; z < this.numClass; z++) {
+					votes[z] = this.ruleSet.get(j).obserClassDistrib.getValue(z)
+							/ this.ruleSet.get(j).obserClassDistrib.sumOfValues();
+				}
+				return votes;
+			}
+		}
+		if (countFired > 0) {
+			fired = true;
+		} else {
+			fired = false;
+		}
+		if (fired == false) {
+			votes = oberversDistribProb(inst, this.observedClassDistribution);
+		}
+		return votes;
+	}
+
+	// Get the votes using weighted Max
+	protected double[] weightedMax(Instance inst) {
+		int countFired = 0;
+		boolean fired = false;
+		double highest = 0.0;
+		double[] votes = new double[this.numClass];
+		ArrayList<Double> ruleSetVotes = new ArrayList<>();
+		ArrayList<ArrayList<Double>> majorityProb = new ArrayList<>();
+		for (int j = 0; j < this.ruleSet.size(); j++) {
+			ArrayList<Double> ruleProb = new ArrayList<>();
+			if (this.ruleSet.get(j).ruleEvaluate(inst) == true) {
+				countFired = countFired + 1;
+				for (int z = 0; z < this.numClass; z++) {
+					ruleSetVotes.add(this.ruleSet.get(j).obserClassDistrib.getValue(z)
+							/ this.ruleSet.get(j).obserClassDistrib.sumOfValues());
+					ruleProb.add(this.ruleSet.get(j).obserClassDistrib.getValue(z)
+							/ this.ruleSet.get(j).obserClassDistrib.sumOfValues());
+				}
+				majorityProb.add(ruleProb);
+			}
+		}
+		if (countFired > 0) {
+			fired = true;
+			Collections.sort(ruleSetVotes);
+			highest = ruleSetVotes.get(ruleSetVotes.size() - 1);
+			for (int t = 0; t < majorityProb.size(); t++) {
+				for (int m = 0; m < majorityProb.get(t).size(); m++) {
+					if (majorityProb.get(t).get(m) == highest) {
+						for (int h = 0; h < majorityProb.get(t).size(); h++) {
+							votes[h] = majorityProb.get(t).get(h);
+						}
+						break;
+					}
+				}
+			}
+		} else {
+			fired = false;
+		}
+		if (fired == false) {
+			votes = oberversDistribProb(inst, this.observedClassDistribution);
+		}
+		return votes;
+	}
+
+	// Get the votes using weighted Sum
+	protected double[] weightedSum(Instance inst) {
+		boolean fired = false;
+		int countFired = 0;
+		double[] votes = new double[this.numClass];
+		ArrayList<Double> weightSum = new ArrayList<>();
+		ArrayList<ArrayList<Double>> majorityProb = new ArrayList<>();
+		for (int j = 0; j < this.ruleSet.size(); j++) {
+			ArrayList<Double> ruleProb = new ArrayList<>();
+			if (this.ruleSet.get(j).ruleEvaluate(inst) == true) {
+				countFired = countFired + 1;
+				for (int z = 0; z < this.numClass; z++) {
+					ruleProb.add(this.ruleSet.get(j).obserClassDistrib.getValue(z)
+							/ this.ruleSet.get(j).obserClassDistrib.sumOfValues());
+				}
+				majorityProb.add(ruleProb);
+			}
+		}
+		if (countFired > 0) {
+			fired = true;
+			for (int m = 0; m < majorityProb.get(0).size(); m++) {
+				double sum = 0.0;
+				for (int t = 0; t < majorityProb.size(); t++) {
+					sum = sum + majorityProb.get(t).get(m);
+				}
+				weightSum.add(sum);
+			}
+			for (int h = 0; h < weightSum.size(); h++) {
+				votes[h] = weightSum.get(h) / majorityProb.size();
+			}
+		} else {
+			fired = false;
+		}
+		if (fired == false) {
+			votes = oberversDistribProb(inst, this.observedClassDistribution);
+		}
+		return votes;
+	}
+
+	protected AttributeClassObserver newNominalClassObserver() {
+		return new NominalAttributeClassObserver();
+	}
+
+	protected AttributeClassObserver newNumericClassObserver() {
+		return new BinaryTreeNumericAttributeClassObserver();
+	}
+
+	protected AttributeClassObserver newNumericClassObserver2() {
+		return new GaussianNumericAttributeClassObserver();
+	}
+
+	public void manageMemory(int currentByteSize, int maxByteSize) {
+		// TODO Auto-generated method stub
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/rules/RuleClassifierNBayes.java b/moa/src/main/java/moa/learners/predictors/rules/RuleClassifierNBayes.java
new file mode 100644
index 000000000..b45bbdb44
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/rules/RuleClassifierNBayes.java
@@ -0,0 +1,261 @@
+/*
+ *    RuleClassifierNBayes.java
+ *    Copyright (C) 2012 University of Porto, Portugal
+ *    @author P. Kosina, E. Almeida, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.predictors.rules;
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.learners.predictors.bayes.NaiveBayes;
+
+/**
+ * This classifier learn ordered and unordered rule set from data stream with
+ * naive Bayes learners.
+ * <p>
+ * This algorithm also does the detection of anomalies.
+ *
+ * <p>
+ * Learning Decision RuleClassifications from Data Streams, IJCAI 2011, J. Gama,
+ * P. Kosina
+ * </p>
+ *
+ * <p>
+ * Parameters:
+ * </p>
+ * <ul>
+ * <li>-q: The number of instances a leaf should observe before permitting Naive
+ * Bayes.</li>
+ * <li>-p: Minimum value of p</li>
+ * <li>-t: Tie Threshold</li>
+ * <li>-c: Split Confidence</li>
+ * <li>-g: GracePeriod, the number of instances a leaf should observe between
+ * split attempts</li>
+ * <li>-o: Prediction function to use. Ex:FirstHit</li>
+ * <li>-r: Learn ordered or unordered rule</li>
+ * </ul>
+ *
+ * @author P. Kosina, E. Almeida, J. Gama
+ * @version $Revision: 2 $
+ */
+public class RuleClassifierNBayes extends RuleClassifier {
+
+	private static final long serialVersionUID = 1L;
+
+	public IntOption nbThresholdOption = new IntOption("nbThreshold", 'q',
+			"The number of instances a leaf should observe before permitting Naive Bayes.", 0, 0, Integer.MAX_VALUE);
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		double[] votes = new double[numClass];
+		switch (super.predictionFunctionOption.getChosenIndex()) {
+		case 0:
+			votes = firstHitNB(inst);
+			break;
+		case 1:
+			votes = weightedSumNB(inst);
+			break;
+		case 2:
+			votes = weightedMaxNB(inst);
+			break;
+		}
+		return new ClassificationPrediction(votes);
+	}
+
+	// The following three functions are used for the prediction
+	protected double[] firstHitNB(Instance inst) {
+		int countFired = 0;
+		boolean fired = false;
+		double[] votes = new double[this.numClass];
+		for (int j = 0; j < this.ruleSet.size(); j++) {
+			if (this.ruleSet.get(j).ruleEvaluate(inst) == true) {
+				countFired = countFired + 1;
+				if (this.ruleSet.get(j).obserClassDistrib.sumOfValues() >= this.nbThresholdOption.getValue()) {
+					votes = NaiveBayes.doNaiveBayesPredictionLog(inst, this.ruleSet.get(j).obserClassDistrib,
+							this.ruleSet.get(j).observers, this.ruleSet.get(j).observersGauss);
+					votes = exponential(votes);
+					votes = normalize(votes);
+				} else {
+					for (int z = 0; z < this.numClass; z++) {
+						votes[z] = this.ruleSet.get(j).obserClassDistrib.getValue(z)
+								/ this.ruleSet.get(j).obserClassDistrib.sumOfValues();
+					}
+				}
+				break;
+			}
+		}
+		if (countFired > 0) {
+			fired = true;
+		} else {
+			fired = false;
+		}
+		if (fired == false) {
+			if (super.getWeightSeen() >= this.nbThresholdOption.getValue()) {
+				votes = NaiveBayes.doNaiveBayesPredictionLog(inst, this.observedClassDistribution,
+						this.attributeObservers, this.attributeObserversGauss);
+				votes = exponential(votes);
+				votes = normalize(votes);
+			} else {
+				votes = super.oberversDistribProb(inst, this.observedClassDistribution);
+			}
+		}
+		return votes;
+	}
+
+	protected double[] weightedMaxNB(Instance inst) {
+		int countFired = 0;
+		int count = 0;
+		boolean fired = false;
+		double highest = 0.0;
+		double[] votes = new double[this.numClass];
+		ArrayList<Double> ruleSetVotes = new ArrayList<>();
+		ArrayList<ArrayList<Double>> majorityProb = new ArrayList<>();
+		for (int j = 0; j < this.ruleSet.size(); j++) {
+			ArrayList<Double> ruleClassDistribProb = new ArrayList<>();
+			if (this.ruleSet.get(j).ruleEvaluate(inst) == true) {
+				countFired = countFired + 1;
+				if (this.ruleSet.get(j).obserClassDistrib.sumOfValues() >= this.nbThresholdOption.getValue()) {
+					votes = NaiveBayes.doNaiveBayesPredictionLog(inst, this.ruleSet.get(j).obserClassDistrib,
+							this.ruleSet.get(j).observers, this.ruleSet.get(j).observersGauss);
+					votes = exponential(votes);
+					votes = normalize(votes);
+				} else {
+					count = count + 1;
+					for (int z = 0; z < this.numClass; z++) {
+						ruleSetVotes.add(this.ruleSet.get(j).obserClassDistrib.getValue(z)
+								/ this.ruleSet.get(j).obserClassDistrib.sumOfValues());
+						ruleClassDistribProb.add(this.ruleSet.get(j).obserClassDistrib.getValue(z)
+								/ this.ruleSet.get(j).obserClassDistrib.sumOfValues());
+					}
+					majorityProb.add(ruleClassDistribProb);
+				}
+			}
+		}
+		if (count > 0) {
+			Collections.sort(ruleSetVotes);
+			highest = ruleSetVotes.get(ruleSetVotes.size() - 1);
+			for (int t = 0; t < majorityProb.size(); t++) {
+				for (int m = 0; m < majorityProb.get(t).size(); m++) {
+					if (majorityProb.get(t).get(m) == highest) {
+						for (int h = 0; h < majorityProb.get(t).size(); h++) {
+							votes[h] = majorityProb.get(t).get(h);
+						}
+						break;
+					}
+				}
+			}
+		}
+		if (countFired > 0) {
+			fired = true;
+		} else {
+			fired = false;
+		}
+		if (fired == false) {
+			if (super.getWeightSeen() >= this.nbThresholdOption.getValue()) {
+				votes = NaiveBayes.doNaiveBayesPredictionLog(inst, this.observedClassDistribution,
+						this.attributeObservers, this.attributeObserversGauss);
+				votes = exponential(votes);
+				votes = normalize(votes);
+			} else {
+				votes = super.oberversDistribProb(inst, this.observedClassDistribution);
+			}
+		}
+		return votes;
+	}
+
+	protected double[] weightedSumNB(Instance inst) {
+		int countFired = 0;
+		int count = 0;
+		boolean fired = false;
+		double[] votes = new double[this.numClass];
+		ArrayList<Double> weightSum = new ArrayList<>();
+		ArrayList<ArrayList<Double>> majorityProb = new ArrayList<>();
+		for (int j = 0; j < this.ruleSet.size(); j++) {
+			ArrayList<Double> ruleClassDistribProb = new ArrayList<>();
+			if (this.ruleSet.get(j).ruleEvaluate(inst) == true) {
+				countFired = countFired + 1;
+				if (this.ruleSet.get(j).obserClassDistrib.sumOfValues() >= this.nbThresholdOption.getValue()) {
+					votes = NaiveBayes.doNaiveBayesPredictionLog(inst, this.ruleSet.get(j).obserClassDistrib,
+							ruleSet.get(j).observers, this.ruleSet.get(j).observersGauss);
+					votes = exponential(votes);
+					votes = normalize(votes);
+				} else {
+					count = count + 1;
+					for (int z = 0; z < this.numClass; z++) {
+						ruleClassDistribProb.add(this.ruleSet.get(j).obserClassDistrib.getValue(z)
+								/ this.ruleSet.get(j).obserClassDistrib.sumOfValues());
+					}
+					majorityProb.add(ruleClassDistribProb);
+				}
+			}
+		}
+		if (count > 0) {
+			for (int m = 0; m < majorityProb.get(0).size(); m++) {
+				double sum = 0.0;
+				for (int t = 0; t < majorityProb.size(); t++) {
+					sum = sum + majorityProb.get(t).get(m);
+				}
+				weightSum.add(sum);
+			}
+			for (int h = 0; h < weightSum.size(); h++) {
+				votes[h] = weightSum.get(h) / majorityProb.size();
+			}
+		}
+		if (countFired > 0) {
+			fired = true;
+		} else {
+			fired = false;
+		}
+		if (fired == false) {
+			if (super.getWeightSeen() >= this.nbThresholdOption.getValue()) {
+				votes = NaiveBayes.doNaiveBayesPredictionLog(inst, this.observedClassDistribution,
+						this.attributeObservers, this.attributeObserversGauss);
+				votes = exponential(votes);
+				votes = normalize(votes);
+			} else {
+				votes = super.oberversDistribProb(inst, this.observedClassDistribution);
+			}
+		}
+		return votes;
+	}
+
+	protected double[] normalize(double[] votes) {
+		double sum = 0;
+		for (int i = 0; i < votes.length; i++) {
+			sum = sum + votes[i];
+		}
+		for (int j = 0; j < votes.length; j++) {
+			votes[j] = votes[j] / sum;
+		}
+		return votes;
+	}
+
+	protected double[] exponential(double[] votes) {
+		for (int i = 0; i < votes.length; i++) {
+			votes[i] = Math.exp(votes[i]);
+		}
+		return votes;
+	}
+
+}
diff --git a/moa/src/main/java/moa/classifiers/rules/core/AttributeExpansionSuggestion.java b/moa/src/main/java/moa/learners/predictors/rules/core/AttributeExpansionSuggestion.java
similarity index 55%
rename from moa/src/main/java/moa/classifiers/rules/core/AttributeExpansionSuggestion.java
rename to moa/src/main/java/moa/learners/predictors/rules/core/AttributeExpansionSuggestion.java
index 05f8dd162..257489fef 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/AttributeExpansionSuggestion.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/AttributeExpansionSuggestion.java
@@ -15,9 +15,9 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.classifiers.rules.core;
+package moa.learners.predictors.rules.core;
 
 import moa.AbstractMOAObject;
 import moa.core.DoubleVector;
@@ -28,58 +28,51 @@
  * @author João Duarte (joaomaiaduarte@gmail.com)
  * @version $Revision: 1 $
  */
-public class AttributeExpansionSuggestion extends AbstractMOAObject implements
-        Comparable<AttributeExpansionSuggestion> {
+public class AttributeExpansionSuggestion extends AbstractMOAObject
+		implements Comparable<AttributeExpansionSuggestion> {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public Predicate predicate;
+	public Predicate predicate;
 
-    public DoubleVector[][] resultingNodeStatistics;
+	public DoubleVector[][] resultingNodeStatistics;
 
-    public double merit;
+	public double merit;
 
-    public Predicate getPredicate() {
+	public Predicate getPredicate() {
 		return predicate;
 	}
-    
-    public void setPredicate(Predicate predicate) {
-    	this.predicate=predicate;
-	}
-
 
+	public void setPredicate(Predicate predicate) {
+		this.predicate = predicate;
+	}
 
 	public DoubleVector[][] getResultingNodeStatistics() {
 		return resultingNodeStatistics;
 	}
 
-
-
 	public double getMerit() {
 		return merit;
 	}
 
+	public AttributeExpansionSuggestion(Predicate predicate, DoubleVector[][] resultingNodeStatistics, double merit) {
+		this.predicate = predicate;
+		this.resultingNodeStatistics = resultingNodeStatistics;
+		this.merit = merit;
+	}
 
+	@Override
+	public int compareTo(AttributeExpansionSuggestion comp) {
+		if (Double.isNaN(this.merit) && Double.isNaN(comp.merit))
+			return 0;
+		if (Double.isNaN(this.merit))
+			return -1;
+		if (Double.isNaN(comp.merit))
+			return 1;
+		return Double.compare(this.merit, comp.merit);
+	}
 
-	public AttributeExpansionSuggestion(Predicate predicate,  DoubleVector[][] resultingNodeStatistics, double merit) {
-        this.predicate = predicate;
-        this.resultingNodeStatistics = resultingNodeStatistics;
-        this.merit = merit;
-    }
-
-
-
-
-
-    @Override
-    public int compareTo(AttributeExpansionSuggestion comp) {
-    	if (Double.isNaN(this.merit) && Double.isNaN(comp.merit)) return 0;
-    	if (Double.isNaN(this.merit)) return -1;
-    	if (Double.isNaN(comp.merit)) return 1;
-        return Double.compare(this.merit, comp.merit);
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-    }
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+	}
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java b/moa/src/main/java/moa/learners/predictors/rules/core/NominalRulePredicate.java
similarity index 60%
rename from moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java
rename to moa/src/main/java/moa/learners/predictors/rules/core/NominalRulePredicate.java
index ef0bffdf3..28a6254de 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/NominalRulePredicate.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/NominalRulePredicate.java
@@ -18,11 +18,10 @@
  *
  */
 
-package moa.classifiers.rules.core;
+package moa.learners.predictors.rules.core;
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.AbstractMOAObject;
 import moa.core.StringUtils;
@@ -30,71 +29,67 @@
 public class NominalRulePredicate extends AbstractMOAObject implements Predicate {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 	private int inputAttributeIndex;
 	private double attributeValue;
-	private boolean isEqual; 
+	private boolean isEqual;
 
 	public NominalRulePredicate(int inputAttributeIndex, double attributeValue, boolean isEqual) {
-		this.inputAttributeIndex=inputAttributeIndex;
-		this.attributeValue=attributeValue;
-		this.isEqual=isEqual;
-	}
-	@Override
-	public boolean evaluate(Instance instance){
-		return evaluate((StructuredInstance) instance);
+		this.inputAttributeIndex = inputAttributeIndex;
+		this.attributeValue = attributeValue;
+		this.isEqual = isEqual;
 	}
 
-	public boolean evaluate(StructuredInstance instance) {
+
+	public boolean evaluate(Instance instance) {
 		if (instance.isMissing(inputAttributeIndex)) {
 			return false;
 		}
-		boolean evaluation=false;	
-		if (instance.valueInputAttribute(inputAttributeIndex)==attributeValue) {
-			evaluation=true;
+		boolean evaluation = false;
+		if (instance.valueInputAttribute(inputAttributeIndex) == attributeValue) {
+			evaluation = true;
 		}
 		return (isEqual ? evaluation : (!evaluation));
 
-
 	}
 
 	public double getAttributeValue() {
 		return attributeValue;
 	}
 
-
 	@Override
 	public void negateCondition() {
-		isEqual=!isEqual;
+		isEqual = !isEqual;
 
 	}
 
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
-		if(isEqual)
-			StringUtils.appendIndented(sb, indent+1, "In" + inputAttributeIndex + " == " + attributeValue);
+		if (isEqual)
+			StringUtils.appendIndented(sb, indent + 1, "In" + inputAttributeIndex + " == " + attributeValue);
 		else
-			StringUtils.appendIndented(sb, indent+1, "In" + inputAttributeIndex + " <> " + attributeValue);
+			StringUtils.appendIndented(sb, indent + 1, "In" + inputAttributeIndex + " <> " + attributeValue);
 	}
 
 	@Override
 	public void getDescription(StringBuilder sb, int indent, InstancesHeader instHeader) {
 		if (instHeader != null) {
-			if(isEqual)
-				StringUtils.appendIndented(sb, indent+1, instHeader.inputAttribute(inputAttributeIndex).name() + " == " + instHeader.inputAttribute(inputAttributeIndex).value((int)attributeValue));
+			if (isEqual)
+				StringUtils.appendIndented(sb, indent + 1, instHeader.inputAttribute(inputAttributeIndex).name()
+						+ " == " + instHeader.inputAttribute(inputAttributeIndex).value((int) attributeValue));
 			else
-				StringUtils.appendIndented(sb, indent+1, instHeader.inputAttribute(inputAttributeIndex).name() + " <> " + instHeader.inputAttribute(inputAttributeIndex).value((int)attributeValue));
-		}
-		else 
-			getDescription(sb,indent);
+				StringUtils.appendIndented(sb, indent + 1, instHeader.inputAttribute(inputAttributeIndex).name()
+						+ " <> " + instHeader.inputAttribute(inputAttributeIndex).value((int) attributeValue));
+		} else
+			getDescription(sb, indent);
 	}
 
 	@Override
-	public String toString(){
+	public String toString() {
 		StringBuilder sb = new StringBuilder();
-		getDescription(sb,0);
+		getDescription(sb, 0);
 		return sb.toString();
 	}
 
diff --git a/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java b/moa/src/main/java/moa/learners/predictors/rules/core/NumericRulePredicate.java
similarity index 62%
rename from moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java
rename to moa/src/main/java/moa/learners/predictors/rules/core/NumericRulePredicate.java
index 2f7c86abf..1eda8d886 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/NumericRulePredicate.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/NumericRulePredicate.java
@@ -17,11 +17,10 @@
  *
  *
  */
-package moa.classifiers.rules.core;
+package moa.learners.predictors.rules.core;
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.StructuredInstance;
 
 import moa.AbstractMOAObject;
 import moa.core.StringUtils;
@@ -29,56 +28,52 @@
 public class NumericRulePredicate extends AbstractMOAObject implements Predicate {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 	private int inputAttributeIndex;
 	private double attributeValue;
-	private boolean isEqualOrLower; 
+	private boolean isEqualOrLower;
 
 	public NumericRulePredicate(int inputAttributeIndex, double attributeValue, boolean isEqualOrLower) {
-		this.inputAttributeIndex=inputAttributeIndex;
-		this.attributeValue=attributeValue;
-		this.isEqualOrLower=isEqualOrLower;
-	}
-	@Override
-	public boolean evaluate(Instance instance){
-		return evaluate((StructuredInstance) instance);
+		this.inputAttributeIndex = inputAttributeIndex;
+		this.attributeValue = attributeValue;
+		this.isEqualOrLower = isEqualOrLower;
 	}
 
-	public boolean evaluate(StructuredInstance instance) {
+	public boolean evaluate(Instance instance) {
 		if (instance.isMissing(inputAttributeIndex)) {
 			return false;
 		}
-		boolean evaluation=false;	
-		if (instance.valueInputAttribute(inputAttributeIndex)<=attributeValue) {
-			evaluation=true;
+		boolean evaluation = false;
+		if (instance.valueInputAttribute(inputAttributeIndex) <= attributeValue) {
+			evaluation = true;
 		}
 		return (isEqualOrLower ? evaluation : (!evaluation));
 
-
 	}
 
 	@Override
 	public void negateCondition() {
-		isEqualOrLower=!isEqualOrLower;
-		
+		isEqualOrLower = !isEqualOrLower;
+
 	}
-	
+
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
-		if(isEqualOrLower)
-			StringUtils.appendIndented(sb, indent+1, inputAttributeIndex + " <= " + attributeValue);
+		if (isEqualOrLower)
+			StringUtils.appendIndented(sb, indent + 1, inputAttributeIndex + " <= " + attributeValue);
 		else
-			StringUtils.appendIndented(sb, indent+1, inputAttributeIndex + " > " + attributeValue);
+			StringUtils.appendIndented(sb, indent + 1, inputAttributeIndex + " > " + attributeValue);
 	}
+
 	@Override
-	public String toString(){
+	public String toString() {
 		StringBuilder sb = new StringBuilder();
-		getDescription(sb,0);
+		getDescription(sb, 0);
 		return sb.toString();
 	}
-	
+
 	@Override
 	public int getAttributeIndex() {
 		return inputAttributeIndex;
@@ -92,12 +87,15 @@ public boolean isEqualOrLess() {
 	public double getAttributeValue() {
 		return attributeValue;
 	}
-	
+
 	@Override
 	public void getDescription(StringBuilder sb, int indent, InstancesHeader header) {
-		if(isEqualOrLower)
-			StringUtils.appendIndented(sb, indent, InstancesHeader.getAttributeNameString(header, inputAttributeIndex) + " <= " + attributeValue);
+		if (isEqualOrLower)
+			StringUtils.appendIndented(sb, indent,
+					InstancesHeader.getAttributeNameString(header, inputAttributeIndex) + " <= " + attributeValue);
 		else
-			StringUtils.appendIndented(sb, indent, InstancesHeader.getAttributeNameString(header, inputAttributeIndex) + " > " + attributeValue);	}
+			StringUtils.appendIndented(sb, indent,
+					InstancesHeader.getAttributeNameString(header, inputAttributeIndex) + " > " + attributeValue);
+	}
 
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/core/Predicate.java b/moa/src/main/java/moa/learners/predictors/rules/core/Predicate.java
similarity index 69%
rename from moa/src/main/java/moa/classifiers/rules/core/Predicate.java
rename to moa/src/main/java/moa/learners/predictors/rules/core/Predicate.java
index 75517efc3..78e880e55 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/Predicate.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/Predicate.java
@@ -14,21 +14,26 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
-package moa.classifiers.rules.core;
+package moa.learners.predictors.rules.core;
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 public interface Predicate {
-	
-	 public boolean evaluate(Instance instance);
-	 public void negateCondition();
-	 public int getAttributeIndex();
-	 public boolean isEqualOrLess();
-	 public void getDescription(StringBuilder sb, int indent);
-	 public void getDescription(StringBuilder sb, int indent, InstancesHeader header);
-	 
+
+	boolean evaluate(Instance instance);
+
+	void negateCondition();
+
+	int getAttributeIndex();
+
+	boolean isEqualOrLess();
+
+	void getDescription(StringBuilder sb, int indent);
+
+	void getDescription(StringBuilder sb, int indent, InstancesHeader header);
+
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/core/Rule.java b/moa/src/main/java/moa/learners/predictors/rules/core/Rule.java
similarity index 75%
rename from moa/src/main/java/moa/classifiers/rules/core/Rule.java
rename to moa/src/main/java/moa/learners/predictors/rules/core/Rule.java
index 4cea1b6dc..592b3c6b5 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/Rule.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/Rule.java
@@ -14,10 +14,10 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
-package moa.classifiers.rules.core;
+package moa.learners.predictors.rules.core;
 
 import java.io.Serializable;
 import java.util.LinkedList;
@@ -41,19 +41,18 @@
 import com.yahoo.labs.samoa.instances.Instance;
 
 import moa.AbstractMOAObject;
-import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
-import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
-import moa.classifiers.rules.AbstractAMRules;
-import moa.classifiers.rules.core.conditionaltests.NumericAttributeBinaryRulePredicate;
 import moa.core.DoubleVector;
 import moa.core.StringUtils;
-
+import moa.learners.predictors.core.conditionaltests.InstanceConditionalTest;
+import moa.learners.predictors.core.conditionaltests.NumericAttributeBinaryTest;
+import moa.learners.predictors.rules.AbstractAMRules;
+import moa.learners.predictors.rules.core.conditionaltests.NumericAttributeBinaryRulePredicate;
 
 public class Rule extends AbstractMOAObject {
 
 	private static final long serialVersionUID = 1L;
 
-	protected List<RuleSplitNode> nodeList = new LinkedList<RuleSplitNode>();
+	protected List<RuleSplitNode> nodeList = new LinkedList<>();
 
 	protected RuleActiveLearningNode learningNode;
 
@@ -67,7 +66,6 @@ public void setRuleNumberID(int ruleNumberID) {
 		this.ruleNumberID = ruleNumberID;
 	}
 
-
 	private double[] statisticsOtherBranchSplit;
 
 	private Builder builder;
@@ -103,21 +101,21 @@ public Rule(Builder builder) {
 		this.setBuilder(builder);
 		this.amRules = builder.getAMRules();
 		this.learningNode = newRuleActiveLearningNode(builder);
-		//JD - use builder ID to set ruleNumberID
-		this.ruleNumberID=builder.id;        
+		// JD - use builder ID to set ruleNumberID
+		this.ruleNumberID = builder.id;
 	}
 
-
 	protected AbstractAMRules amRules;
 
 	private RuleActiveLearningNode newRuleActiveLearningNode(Builder builder) {
 		return amRules.newRuleActiveLearningNode(builder);
 	}
 
-	/*private RuleActiveLearningNode newRuleActiveLearningNode(double[] initialClassObservations) {
-    	return amRules.newRuleActiveLearningNode(initialClassObservations);
-    }*/
-
+	/*
+	 * private RuleActiveLearningNode newRuleActiveLearningNode(double[]
+	 * initialClassObservations) { return
+	 * amRules.newRuleActiveLearningNode(initialClassObservations); }
+	 */
 
 	public boolean isCovering(Instance inst) {
 		boolean isCovering = true;
@@ -149,7 +147,7 @@ public static class Builder implements Serializable {
 		protected double[] statistics;
 
 		protected double lastTargetMean;
-		private Rule owner; //jd
+		private Rule owner; // jd
 
 		public FlagOption constantLearningRatioDecayOption;
 		public FloatOption learningRatioOption;
@@ -188,7 +186,7 @@ public Builder statistics(double[] statistics) {
 			return this;
 		}
 
-		public Builder owner(Rule owner) { 
+		public Builder owner(Rule owner) {
 			this.setOwner(owner);
 			return this;
 		}
@@ -202,6 +200,7 @@ public Builder id(int id) {
 			this.id = id;
 			return this;
 		}
+
 		public Rule build() {
 			return new Rule(this);
 		}
@@ -221,78 +220,79 @@ public void updateStatistics(Instance instance) {
 	}
 
 	/**
-	 *  Try to Expand method.
+	 * Try to Expand method.
+	 * 
 	 * @param splitConfidence
 	 * @param tieThreshold
 	 * @return
 	 */
 	public boolean tryToExpand(double splitConfidence, double tieThreshold) {
 
-		boolean shouldSplit= this.learningNode.tryToExpand(splitConfidence, tieThreshold);
+		boolean shouldSplit = this.learningNode.tryToExpand(splitConfidence, tieThreshold);
 		return shouldSplit;
 
 	}
-	//JD: Only call after tryToExpand returning true
-	public void split()
-	{
 
-		//this.statisticsOtherBranchSplit  = this.learningNode.getStatisticsOtherBranchSplit(); 
-		//create a split node,
+	// JD: Only call after tryToExpand returning true
+	public void split() {
+
+		// this.statisticsOtherBranchSplit =
+		// this.learningNode.getStatisticsOtherBranchSplit();
+		// create a split node,
 		int splitIndex = this.learningNode.getSplitIndex();
-		InstanceConditionalTest st=this.learningNode.getBestSuggestion().splitTest;
-		if(st instanceof NumericAttributeBinaryTest ) {
+		InstanceConditionalTest st = this.learningNode.getBestSuggestion().splitTest;
+		if (st instanceof NumericAttributeBinaryTest) {
 			NumericAttributeBinaryTest splitTest = (NumericAttributeBinaryTest) st;
 			NumericAttributeBinaryRulePredicate predicate = new NumericAttributeBinaryRulePredicate(
-					splitTest.getAttsTestDependsOn()[0], splitTest.getSplitValue(),
-					splitIndex + 1);
-			RuleSplitNode ruleSplitNode = new RuleSplitNode(predicate, this.learningNode.getStatisticsBranchSplit() );
-
-
+					splitTest.getAttsTestDependsOn()[0], splitTest.getSplitValue(), splitIndex + 1);
+			RuleSplitNode ruleSplitNode = new RuleSplitNode(predicate, this.learningNode.getStatisticsBranchSplit());
 
 			if (this.nodeListAdd(ruleSplitNode) == true) {
 				// create a new learning node
-				RuleActiveLearningNode newLearningNode = newRuleActiveLearningNode(this.getBuilder().statistics(this.learningNode.getStatisticsNewRuleActiveLearningNode())); 
+				RuleActiveLearningNode newLearningNode = newRuleActiveLearningNode(
+						this.getBuilder().statistics(this.learningNode.getStatisticsNewRuleActiveLearningNode()));
 				newLearningNode.initialize(this.learningNode);
 				this.learningNode = newLearningNode;
 			}
-		}
-		else
+		} else
 			throw new UnsupportedOperationException("AMRules (currently) only supports numerical attributes.");
 
 	}
 
-
 	private boolean nodeListAdd(RuleSplitNode ruleSplitNode) {
-		//Check that the node is not already in the list
+		// Check that the node is not already in the list
 		boolean isIncludedInNodeList = false;
-		boolean isUpdated=false;
+		boolean isUpdated = false;
 		for (RuleSplitNode node : nodeList) {
 			NumericAttributeBinaryRulePredicate nodeTest = (NumericAttributeBinaryRulePredicate) node.getSplitTest();
-			NumericAttributeBinaryRulePredicate ruleSplitNodeTest = (NumericAttributeBinaryRulePredicate) ruleSplitNode.getSplitTest();
+			NumericAttributeBinaryRulePredicate ruleSplitNodeTest = (NumericAttributeBinaryRulePredicate) ruleSplitNode
+					.getSplitTest();
 			if (nodeTest.isUsingSameAttribute(ruleSplitNodeTest)) {
 				isIncludedInNodeList = true;
-				if (nodeTest.isIncludedInRuleNode(ruleSplitNodeTest) == true) { //remove this line to keep the most recent attribute value
-					//replace the value
+				if (nodeTest.isIncludedInRuleNode(ruleSplitNodeTest) == true) { // remove this line to keep the most
+																				// recent attribute value
+					// replace the value
 					nodeTest.setAttributeValue(ruleSplitNodeTest);
-					isUpdated=true; //if is updated (i.e. an expansion happened) a new learning node should be created
+					isUpdated = true; // if is updated (i.e. an expansion happened) a new learning node should be
+										// created
 				}
 			}
 		}
 		if (isIncludedInNodeList == false) {
 			this.nodeList.add(ruleSplitNode);
 		}
-		return (!isIncludedInNodeList || isUpdated); 
+		return (!isIncludedInNodeList || isUpdated);
 	}
 
 	public double[] statisticsOtherBranchSplit() {
 		return this.statisticsOtherBranchSplit;
 	}
 
-
 	public String printRule() {
 		StringBuilder out = new StringBuilder();
 		int indent = 1;
-		StringUtils.appendIndented(out, indent, "Rule Nr." + this.ruleNumberID + " Instances seen:" + this.learningNode.getInstancesSeen() + "\n"); // AC
+		StringUtils.appendIndented(out, indent,
+				"Rule Nr." + this.ruleNumberID + " Instances seen:" + this.learningNode.getInstancesSeen() + "\n"); // AC
 		for (RuleSplitNode node : nodeList) {
 			StringUtils.appendIndented(out, indent, node.getSplitTest().toString());
 			StringUtils.appendIndented(out, indent, " ");
@@ -303,29 +303,24 @@ public String printRule() {
 		StringUtils.appendNewline(out);
 
 		if (this.learningNode instanceof RuleActiveRegressionNode) {
-			if(((RuleActiveRegressionNode)this.learningNode).perceptron!=null){
-				((RuleActiveRegressionNode)this.learningNode).perceptron.getModelDescription(out,0 );
+			if (((RuleActiveRegressionNode) this.learningNode).perceptron != null) {
+				((RuleActiveRegressionNode) this.learningNode).perceptron.getModelDescription(out, 0);
 				StringUtils.appendNewline(out);
 			}
 		}
-		return(out.toString());
+		return (out.toString());
 	}
 
-
-
 	protected void debug(String string, int level) {
-		if (this.amRules.VerbosityOption.getValue()>=level) {
+		if (this.amRules.VerbosityOption.getValue() >= level) {
 			System.out.println(string);
 		}
 	}
 
-	public boolean isAnomaly(Instance instance,
-			double uniVariateAnomalyProbabilityThreshold,
-			double multiVariateAnomalyProbabilityThreshold,
-			int numberOfInstanceesForAnomaly) {
+	public boolean isAnomaly(Instance instance, double uniVariateAnomalyProbabilityThreshold,
+			double multiVariateAnomalyProbabilityThreshold, int numberOfInstanceesForAnomaly) {
 		return this.learningNode.isAnomaly(instance, uniVariateAnomalyProbabilityThreshold,
-				multiVariateAnomalyProbabilityThreshold,
-				numberOfInstanceesForAnomaly);
+				multiVariateAnomalyProbabilityThreshold, numberOfInstanceesForAnomaly);
 	}
 
 	public double computeError(Instance instance) {
@@ -355,6 +350,5 @@ public void setBuilder(Builder builder) {
 	public double getCurrentError() {
 		return this.learningNode.getCurrentError();
 	}
-	
 
 }
diff --git a/moa/src/main/java/moa/learners/predictors/rules/core/RuleActiveLearningNode.java b/moa/src/main/java/moa/learners/predictors/rules/core/RuleActiveLearningNode.java
new file mode 100644
index 000000000..4d4dd120d
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/RuleActiveLearningNode.java
@@ -0,0 +1,399 @@
+/*
+ *    RuleActiveLearningNode.java
+ *    Copyright (C) 2014 University of Porto, Portugal
+ *    @author A. Bifet, J. Duarte, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.predictors.rules.core;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.learners.predictors.core.AttributeSplitSuggestion;
+import moa.learners.predictors.core.attributeclassobservers.AttributeClassObserver;
+import moa.learners.predictors.rules.AbstractAMRules;
+import moa.learners.predictors.rules.driftdetection.PageHinkleyFading;
+import moa.learners.predictors.rules.driftdetection.PageHinkleyTest;
+import moa.learners.predictors.trees.HoeffdingTree;
+import moa.learners.predictors.trees.HoeffdingTree.ActiveLearningNode;
+
+/**
+ * A modified ActiveLearningNode that uses a Perceptron as the leaf node model,
+ * and ensures that the class values sent to the attribute observers are not
+ * truncated to ints if regression is being performed
+ */
+public abstract class RuleActiveLearningNode extends ActiveLearningNode {
+
+	protected PageHinkleyTest pageHinckleyTest;
+
+	protected int predictionFunction;
+
+	protected boolean changeDetection;
+
+	protected Rule owner;
+
+	protected boolean[] attributesMask;
+	protected int numAttributesSelected;
+
+	private static final long serialVersionUID = 9129659494380381126L;
+
+	// The statistics for this node:
+	// Number of instances that have reached it
+	// Sum of y values
+	// Sum of squared y values
+	protected DoubleVector nodeStatistics;
+
+	/**
+	 * Create a new RuleActiveLearningNode
+	 */
+	public RuleActiveLearningNode(double[] initialClassObservations) {
+		super(initialClassObservations);
+		this.nodeStatistics = new DoubleVector(initialClassObservations);
+	}
+
+	public RuleActiveLearningNode() {
+		this(new double[0]);
+	}
+
+	protected AbstractAMRules amRules;
+
+	public RuleActiveLearningNode(Rule.Builder builder) {
+		this(builder.statistics);
+		this.changeDetection = builder.changeDetection;
+		if (builder.changeDetection == false) {
+			this.pageHinckleyTest = new PageHinkleyFading(builder.threshold, builder.alpha);
+		}
+
+		this.amRules = builder.amRules;
+		this.predictionFunction = builder.predictionFunction;
+		this.owner = builder.getOwner();
+
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * moa.learners.predictors.rules.RuleActiveLearningNodeInterface#learnFromInstance(weka.
+	 * core.Instance)
+	 */
+	abstract public void learnFromInstance(Instance inst);
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * moa.learners.predictors.rules.RuleActiveLearningNodeInterface#learnFromInstance(weka.
+	 * core.Instance, moa.learners.predictors.trees.HoeffdingTree)
+	 */
+	@Override
+	public void learnFromInstance(Instance inst, HoeffdingTree ht) {
+		learnFromInstance(inst);
+	}
+
+	protected AttributeClassObserver newNumericClassObserver() {
+		// return new FIMTDDNumericAttributeClassObserver();
+		// return new FIMTDDNumericAttributeClassLimitObserver();
+		return (AttributeClassObserver) ((AttributeClassObserver) this.amRules.numericObserverOption
+				.getPreMaterializedObject()).copy();
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * moa.learners.predictors.rules.RuleActiveLearningNodeInterface#updateStatistics(weka.
+	 * core.Instance)
+	 */
+	public void updateStatistics(Instance instance) {
+		learnFromInstance(instance);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * moa.learners.predictors.rules.RuleActiveLearningNodeInterface#getAttributeObservers()
+	 */
+	public AutoExpandVector<AttributeClassObserver> getAttributeObservers() {
+		return this.attributeObservers;
+	}
+
+	protected void debug(String string, int level) {
+		if (this.amRules.VerbosityOption.getValue() >= level) {
+			System.out.println(string);
+		}
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * moa.learners.predictors.rules.RuleActiveLearningNodeInterface#getPrediction(weka.core
+	 * .Instance)
+	 */
+	public double[] getPrediction(Instance instance) {
+		int predictionMode = this.getLearnerToUse(instance, this.predictionFunction);
+		return getPrediction(instance, predictionMode);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * moa.learners.predictors.rules.RuleActiveLearningNodeInterface#getPrediction(weka.core
+	 * .Instance, int)
+	 */
+	abstract public double[] getPrediction(Instance instance, int predictionMode);
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * moa.learners.predictors.rules.RuleActiveLearningNodeInterface#getNormalizedPrediction
+	 * (weka.core.Instance)
+	 */
+
+	abstract public int getLearnerToUse(Instance instance, int predictionMode);
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * moa.learners.predictors.rules.RuleActiveLearningNodeInterface#computeError(weka.core.
+	 * Instance)
+	 */
+	abstract public double computeError(Instance instance);
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * moa.learners.predictors.rules.RuleActiveLearningNodeInterface#updatePageHinckleyTest(
+	 * double)
+	 */
+	public boolean updatePageHinckleyTest(double error) {
+		boolean changeDetected = false;
+		if (this.changeDetection == false) {
+			changeDetected = pageHinckleyTest.update(error);
+		}
+		return changeDetected;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see moa.learners.predictors.rules.RuleActiveLearningNodeInterface#getInstancesSeen()
+	 */
+	public long getInstancesSeen() {
+		return (long) this.getWeightSeen();
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * moa.learners.predictors.rules.RuleActiveLearningNodeInterface#isAnomaly(weka.core.
+	 * Instance, double, double, int)
+	 */
+	abstract public boolean isAnomaly(Instance instance, double uniVariateAnomalyProbabilityThreshold,
+			double multiVariateAnomalyProbabilityThreshold, int numberOfInstanceesForAnomaly);
+
+	// Attribute probability
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * moa.learners.predictors.rules.RuleActiveLearningNodeInterface#computeProbability(
+	 * double, double, double)
+	 */
+	public double computeProbability(double mean, double sd, double value) {
+		double probability = 0.0;
+
+		/*
+		 * double diff = value - mean; if (sd > 0.0) { double k = (Math.abs(value -
+		 * mean) / sd); if (k > 1.0) { probability = 1.0 / (k * k); // Chebyshev's
+		 * inequality } else { probability = Math.exp(-(diff * diff / (2.0 * sd * sd)));
+		 * } }
+		 */
+
+		if (sd > 0.0) {
+			double k = (Math.abs(value - mean) / sd); // One tailed variant of Chebyshev's inequality
+			probability = 1.0 / (1 + k * k); // cantelli's (one-tailed)
+			double var = Math.pow(sd, 2);
+			probability = 2 * var / (var + Math.pow(Math.abs(value - mean), 2));
+			// probability= 1.0 / (1+k*k);
+			// probability= 1.0 / (k*k); //chebyshev
+			// normal distribution
+			// double diff = value - mean;
+			// probability = Math.exp(-(diff * diff / (2.0 * sd * sd)));
+		}
+
+		return probability;
+	}
+
+	protected AttributeSplitSuggestion bestSuggestion = null;
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see moa.learners.predictors.rules.RuleActiveLearningNodeInterface#getSplitIndex()
+	 */
+	public int getSplitIndex() {
+		return splitIndex;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see moa.learners.predictors.rules.RuleActiveLearningNodeInterface#setSplitIndex(int)
+	 */
+	public void setSplitIndex(int splitIndex) {
+		this.splitIndex = splitIndex;
+	}
+
+	protected int splitIndex = 0;
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * moa.learners.predictors.rules.RuleActiveLearningNodeInterface#getBestSuggestion()
+	 */
+	public AttributeSplitSuggestion getBestSuggestion() {
+		return bestSuggestion;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * moa.learners.predictors.rules.RuleActiveLearningNodeInterface#setBestSuggestion(moa.
+	 * classifiers.core.AttributeSplitSuggestion)
+	 */
+	public void setBestSuggestion(AttributeSplitSuggestion bestSuggestion) {
+		this.bestSuggestion = bestSuggestion;
+	}
+
+	protected double[] statisticsNewRuleActiveLearningNode = null;
+
+	protected double[] statisticsBranchSplit = null;
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see moa.learners.predictors.rules.RuleActiveLearningNodeInterface#
+	 * getStatisticsBranchSplit()
+	 */
+	public double[] getStatisticsBranchSplit() {
+		return statisticsBranchSplit;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see moa.learners.predictors.rules.RuleActiveLearningNodeInterface#
+	 * setStatisticsBranchSplit(double[])
+	 */
+	public void setStatisticsBranchSplit(double[] statisticsBranchSplit) {
+		this.statisticsBranchSplit = statisticsBranchSplit;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see moa.learners.predictors.rules.RuleActiveLearningNodeInterface#
+	 * getStatisticsNewRuleActiveLearningNode()
+	 */
+	public double[] getStatisticsNewRuleActiveLearningNode() {
+		return statisticsNewRuleActiveLearningNode;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see moa.learners.predictors.rules.RuleActiveLearningNodeInterface#
+	 * setStatisticsNewRuleActiveLearningNode(double[])
+	 */
+	public void setStatisticsNewRuleActiveLearningNode(double[] statisticsNewRuleActiveLearningNode) {
+		this.statisticsNewRuleActiveLearningNode = statisticsNewRuleActiveLearningNode;
+	}
+
+	protected double[] statisticsOtherBranchSplit;
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see moa.learners.predictors.rules.RuleActiveLearningNodeInterface#
+	 * getStatisticsOtherBranchSplit()
+	 */
+	public double[] getStatisticsOtherBranchSplit() {
+		return statisticsOtherBranchSplit;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see moa.learners.predictors.rules.RuleActiveLearningNodeInterface#
+	 * setStatisticsOtherBranchSplit(double[])
+	 */
+	public void setStatisticsOtherBranchSplit(double[] statisticsOtherBranchSplit) {
+		this.statisticsOtherBranchSplit = statisticsOtherBranchSplit;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * moa.learners.predictors.rules.RuleActiveLearningNodeInterface#tryToExpand(double,
+	 * double)
+	 */
+	abstract public boolean tryToExpand(double splitConfidence, double tieThreshold);
+
+	public static double computeHoeffdingBound(double range, double confidence, double n) {
+		return Math.sqrt(((range * range) * Math.log(1.0 / confidence)) / (2.0 * n));
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see moa.learners.predictors.rules.RuleActiveLearningNodeInterface#initialize(moa.
+	 * classifiers.rules.RuleActiveLearningNode)
+	 */
+	abstract public void initialize(RuleActiveLearningNode oldLearningNode);
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * moa.learners.predictors.rules.RuleActiveLearningNodeInterface#getSimplePrediction()
+	 */
+	abstract public double[] getSimplePrediction();
+
+	public DoubleVector getNodeStatistics() {
+		return this.nodeStatistics;
+	}
+
+	public boolean updateChangeDetection(double error) {
+		if (changeDetection == false) {
+			return pageHinckleyTest.update(error);
+		} else
+			return false;
+	}
+
+	abstract public double getCurrentError();
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/rules/core/RuleActiveRegressionNode.java b/moa/src/main/java/moa/learners/predictors/rules/core/RuleActiveRegressionNode.java
similarity index 50%
rename from moa/src/main/java/moa/classifiers/rules/core/RuleActiveRegressionNode.java
rename to moa/src/main/java/moa/learners/predictors/rules/core/RuleActiveRegressionNode.java
index 83072d5a8..ce46aaae0 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/RuleActiveRegressionNode.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/RuleActiveRegressionNode.java
@@ -14,11 +14,11 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.classifiers.rules.core;
+package moa.learners.predictors.rules.core;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -28,30 +28,31 @@
 
 import com.yahoo.labs.samoa.instances.Instance;
 
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
-import moa.classifiers.rules.AMRulesRegressorOld;
-import moa.classifiers.rules.core.splitcriteria.AMRulesSplitCriterion;
-import moa.classifiers.rules.functions.Perceptron;
-import moa.classifiers.rules.functions.TargetMean;
 import moa.core.DoubleVector;
+import moa.learners.predictors.core.AttributeSplitSuggestion;
+import moa.learners.predictors.core.attributeclassobservers.AttributeClassObserver;
+import moa.learners.predictors.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
+import moa.learners.predictors.core.splitcriteria.SplitCriterion;
+import moa.learners.predictors.rules.AMRulesRegressorOld;
+import moa.learners.predictors.rules.AbstractAMRules;
+import moa.learners.predictors.rules.core.splitcriteria.AMRulesSplitCriterion;
+import moa.learners.predictors.rules.functions.Perceptron;
+import moa.learners.predictors.rules.functions.TargetMean;
 
 /**
  * A modified ActiveLearningNode that uses a Perceptron as the leaf node model,
  * and ensures that the class values sent to the attribute observers are not
  * truncated to ints if regression is being performed
  */
-public class RuleActiveRegressionNode extends RuleActiveLearningNode{
+public class RuleActiveRegressionNode extends RuleActiveLearningNode {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1607453624545272049L;
 
 	protected Perceptron perceptron;
-	
+
 	public Perceptron getPerceptron() {
 		return perceptron;
 	}
@@ -69,6 +70,7 @@ public void setTargetMean(TargetMean targetMean) {
 	}
 
 	protected TargetMean targetMean;
+
 	public RuleActiveRegressionNode(double[] initialClassObservations) {
 		super(initialClassObservations);
 	}
@@ -81,96 +83,107 @@ public RuleActiveRegressionNode(Rule.Builder builder) {
 		super(builder);
 		this.perceptron = new Perceptron();
 		this.perceptron.prepareForUse();
-		this.perceptron.learningRatioOption = ((AMRulesRegressorOld)this.amRules).learningRatioOption;
-		this.perceptron.constantLearningRatioDecayOption = ((AMRulesRegressorOld)this.amRules).constantLearningRatioDecayOption;	
-
+		this.perceptron.learningRatioOption = ((AMRulesRegressorOld) this.amRules).learningRatioOption;
+		this.perceptron.constantLearningRatioDecayOption = ((AMRulesRegressorOld) this.amRules).constantLearningRatioDecayOption;
 
-		if(this.predictionFunction!=1)
-		{
-			this.targetMean = new TargetMean(); 
-			if (builder.statistics[0]>0)
-				this.targetMean.reset(builder.statistics[1]/builder.statistics[0],(long)builder.statistics[0]);
+		if (this.predictionFunction != 1) {
+			this.targetMean = new TargetMean();
+			if (builder.statistics[0] > 0)
+				this.targetMean.reset(builder.statistics[1] / builder.statistics[0], (long) builder.statistics[0]);
 		}
 		this.predictionFunction = builder.predictionFunction;
-		if (builder.statistics!=null)
-			this.nodeStatistics=new DoubleVector(builder.statistics);
+		if (builder.statistics != null)
+			this.nodeStatistics = new DoubleVector(builder.statistics);
 	}
 
-	/* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#updateStatistics(weka.core.Instance)
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * moa.learners.predictors.rules.RuleActiveLearningNodeInterface#updateStatistics(weka.
+	 * core.Instance)
 	 */
+	@Override
 	public void updateStatistics(Instance instance) {
 		super.updateStatistics(instance);
 		this.perceptron.trainOnInstance(instance);
-		if (this.predictionFunction != 1) { //Train target mean if prediction function is not Perceptron
+		if (this.predictionFunction != 1) { // Train target mean if prediction function is not Perceptron
 			this.targetMean.trainOnInstance(instance);
 		}
 	}
 
+	@Override
 	public double[] getPrediction(Instance instance, int predictionMode) {
-		double[] ret = new double[1];  
+		double[] ret = new double[1];
 		if (predictionMode == 1)
-			ret=this.perceptron.getPredictionForInstance(instance).asDoubleArray();
+			ret = this.perceptron.getPredictionForInstance(instance).asDoubleArray();
 		else
-			ret=this.targetMean.getPredictionForInstance(instance).asDoubleArray();
+			ret = this.targetMean.getPredictionForInstance(instance).asDoubleArray();
 		return ret;
 	}
 
 	public double getNormalizedPrediction(Instance instance) {
 		double res;
-		double [] aux;
+		double[] aux;
 		switch (this.predictionFunction) {
-		//perceptron - 1
+		// perceptron - 1
 		case 1:
-			res=this.perceptron.normalizedPrediction(instance); ;
+			res = this.perceptron.normalizedPrediction(instance);
+			;
 			break;
-			//target mean - 2
+		// target mean - 2
 		case 2:
-			aux=this.targetMean.getPredictionForInstance((Instance)null).asDoubleArray();
-			res=normalize(aux[0]);
+			aux = this.targetMean.getPredictionForInstance((Instance) null).asDoubleArray();
+			res = normalize(aux[0]);
 			break;
-			//adaptive	- 0
-		case 0:  
+		// adaptive - 0
+		case 0:
 			int predictionMode = this.getLearnerToUse(instance, 0);
-			if(predictionMode == 1)
-			{
-				res=this.perceptron.normalizedPrediction(instance);
-			}
-			else{
-				aux=this.targetMean.getPredictionForInstance(instance).asDoubleArray();
-				res = normalize(aux[0]); 
+			if (predictionMode == 1) {
+				res = this.perceptron.normalizedPrediction(instance);
+			} else {
+				aux = this.targetMean.getPredictionForInstance(instance).asDoubleArray();
+				res = normalize(aux[0]);
 			}
 			break;
-		default: 
+		default:
 			throw new UnsupportedOperationException("Prediction mode not in range.");
 		}
 		return res;
 	}
 
-	/* (non-Javadoc)
-	 * @see moa.classifiers.rules.RuleActiveLearningNodeInterface#getLearnerToUse(weka.core.Instance, int)
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see
+	 * moa.learners.predictors.rules.RuleActiveLearningNodeInterface#getLearnerToUse(weka.
+	 * core.Instance, int)
 	 */
+	@Override
 	public int getLearnerToUse(Instance instance, int predMode) {
 		int predictionMode = predMode;
 		if (predictionMode == 0) {
-			double 	perceptronError= this.perceptron.getCurrentError();
-			double meanTargetError =this.targetMean.getCurrentError();
-			debug("\n Check P:" + perceptronError + " M:" + meanTargetError,5);
-			debug("Rule" + this.owner.ruleNumberID + " P:" + this.perceptron.getPredictionForInstance(instance).asDoubleArray()[0] + " (" + perceptronError + ")" + " M:" + this.targetMean.getPredictionForInstance(instance).asDoubleArray()[0]+ " (" + meanTargetError + ")",3) ; //Commented by JD
-			debug("Observed Value: " + instance.classValue(),5);
+			double perceptronError = this.perceptron.getCurrentError();
+			double meanTargetError = this.targetMean.getCurrentError();
+			debug("\n Check P:" + perceptronError + " M:" + meanTargetError, 5);
+			debug("Rule" + this.owner.ruleNumberID + " P:"
+					+ this.perceptron.getPredictionForInstance(instance).asDoubleArray()[0] + " (" + perceptronError
+					+ ")" + " M:" + this.targetMean.getPredictionForInstance(instance).asDoubleArray()[0] + " ("
+					+ meanTargetError + ")", 3); // Commented by JD
+			debug("Observed Value: " + instance.classValue(), 5);
 			if (perceptronError < meanTargetError) {
-				predictionMode = 1; //PERCEPTRON
+				predictionMode = 1; // PERCEPTRON
 			} else {
-				predictionMode = 2; //TARGET MEAN
+				predictionMode = 2; // TARGET MEAN
 			}
 		}
 		return predictionMode;
 	}
 
-
 	private double normalize(double value) {
-		double meanY = this.nodeStatistics.getValue(1)/this.nodeStatistics.getValue(0);
-		double sdY = computeSD(this.nodeStatistics.getValue(2), this.nodeStatistics.getValue(1), (long)this.nodeStatistics.getValue(0));
+		double meanY = this.nodeStatistics.getValue(1) / this.nodeStatistics.getValue(0);
+		double sdY = computeSD(this.nodeStatistics.getValue(2), this.nodeStatistics.getValue(1),
+				(long) this.nodeStatistics.getValue(0));
 		double normalizedY = 0.0;
 		if (sdY > 0.0000001) {
 			normalizedY = (value - meanY) / (sdY);
@@ -178,31 +191,31 @@ private double normalize(double value) {
 		return normalizedY;
 	}
 
-
 	public double computeSD(double squaredVal, double val, double size) {
 		if (size > 1) {
 			return Math.sqrt((squaredVal - ((val * val) / size)) / (size - 1.0));
 		}
 		return 0.0;
 	}
+
 	public double computeSD(double squaredVal, double val, long size) {
 
-		return computeSD(squaredVal, val, (double)size);
+		return computeSD(squaredVal, val, (double) size);
 	}
 
-
+	@Override
 	public double computeError(Instance instance) {
-		double normalizedPrediction = getNormalizedPrediction(instance); 
+		double normalizedPrediction = getNormalizedPrediction(instance);
 		double normalizedClassValue = normalize(instance.classValue());
 		return Math.abs(normalizedClassValue - normalizedPrediction);
 	}
-	public boolean isAnomaly(Instance instance,
-			double uniVariateAnomalyProbabilityThreshold,
-			double multiVariateAnomalyProbabilityThreshold,
-			int numberOfInstanceesForAnomaly) {
-		//AMRUles is equipped with anomaly detection. If on, compute the anomaly value.
-		double perceptronIntancesSeen=this.perceptron.getInstancesSeen();
-		if ( perceptronIntancesSeen>= numberOfInstanceesForAnomaly) {
+
+	@Override
+	public boolean isAnomaly(Instance instance, double uniVariateAnomalyProbabilityThreshold,
+			double multiVariateAnomalyProbabilityThreshold, int numberOfInstanceesForAnomaly) {
+		// AMRUles is equipped with anomaly detection. If on, compute the anomaly value.
+		double perceptronIntancesSeen = this.perceptron.getInstancesSeen();
+		if (perceptronIntancesSeen >= numberOfInstanceesForAnomaly) {
 			double atribSum = 0.0;
 			double atribSquredSum = 0.0;
 			double D = 0.0;
@@ -212,67 +225,56 @@ public boolean isAnomaly(Instance instance,
 			for (int x = 0; x < instance.numAttributes() - 1; x++) {
 				// Perceptron is initialized each rule.
 				// this is a local anomaly.
-				int instAttIndex = AMRulesRegressorOld.modelAttIndexToInstanceAttIndex(x, instance);
+				int instAttIndex = AbstractAMRules.modelAttIndexToInstanceAttIndex(x, instance);
 				atribSum = this.perceptron.perceptronattributeStatistics.getValue(x);
 				atribSquredSum = this.perceptron.squaredperceptronattributeStatistics.getValue(x);
 				double mean = atribSum / perceptronIntancesSeen;
 				double sd = computeSD(atribSquredSum, atribSum, perceptronIntancesSeen);
 				double probability = computeProbability(mean, sd, instance.value(instAttIndex));
-				
-				/* old implementation
-				if (probability > 0.0) {
-					D = D + Math.abs(Math.log(probability));
-					if (probability < uniVariateAnomalyProbabilityThreshold) {//0.10
-						N = N + Math.abs(Math.log(probability));
-					}
-				} else {
-					debug("Anomaly with probability 0 in atribute : " + x, 4);
-				}*/
-				
-				//odds ratio
-				if(probability>0)
-					anomaly+=Math.log(probability/(1-probability));
-				if(probability==1) //TODO: JD comment: only for testing
-					anomaly+=Math.log(probability/(1-probability));
-			}
 
-			/*anomaly = 0.0; //Old implementation
-			if (D != 0.0) { 
-				anomaly = N / D;
+				/*
+				 * old implementation if (probability > 0.0) { D = D +
+				 * Math.abs(Math.log(probability)); if (probability <
+				 * uniVariateAnomalyProbabilityThreshold) {//0.10 N = N +
+				 * Math.abs(Math.log(probability)); } } else {
+				 * debug("Anomaly with probability 0 in atribute : " + x, 4); }
+				 */
+
+				// odds ratio
+				if (probability > 0)
+					anomaly += Math.log(probability / (1 - probability));
+				if (probability == 1) // TODO: JD comment: only for testing
+					anomaly += Math.log(probability / (1 - probability));
 			}
-			if (anomaly >= multiVariateAnomalyProbabilityThreshold) {
-				debuganomaly(instance,
-						uniVariateAnomalyProbabilityThreshold,
-						multiVariateAnomalyProbabilityThreshold,
-						anomaly);
-				return true;
-			}*/
-			System.out.println("Anomaly = " + anomaly); //TODO: JD remove commented code
-			/*try {
-			    PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("/home/jduarte/fried_anomalies.txt", true)));
-			    out.println(anomaly);
-			    out.close();
-			} catch (IOException e) {
-			    //exception handling left as an exercise for the reader
-			}*/
-			return anomaly<0;
+
+			/*
+			 * anomaly = 0.0; //Old implementation if (D != 0.0) { anomaly = N / D; } if
+			 * (anomaly >= multiVariateAnomalyProbabilityThreshold) { debuganomaly(instance,
+			 * uniVariateAnomalyProbabilityThreshold,
+			 * multiVariateAnomalyProbabilityThreshold, anomaly); return true; }
+			 */
+			System.out.println("Anomaly = " + anomaly); // TODO: JD remove commented code
+			/*
+			 * try { PrintWriter out = new PrintWriter(new BufferedWriter(new
+			 * FileWriter("/home/jduarte/fried_anomalies.txt", true)));
+			 * out.println(anomaly); out.close(); } catch (IOException e) { //exception
+			 * handling left as an exercise for the reader }
+			 */
+			return anomaly < 0;
 		}
 		return false;
 	}
+
 	protected void debuganomaly(Instance instance, double uni, double multi, double probability) {
 		double atribSum = 0.0;
 		double atribSquredSum = 0.0;
 
 		for (int x = 0; x < instance.numAttributes() - 1; x++) {
-			int instAttIndex = AMRulesRegressorOld.modelAttIndexToInstanceAttIndex(x, instance);
+			int instAttIndex = AbstractAMRules.modelAttIndexToInstanceAttIndex(x, instance);
 			atribSum = perceptron.perceptronattributeStatistics.getValue(x);
 			atribSquredSum = perceptron.squaredperceptronattributeStatistics.getValue(x);
 			double mean = atribSum / perceptron.getInstancesSeen();
-			double sd = computeSD(
-					atribSquredSum,
-					atribSum,
-					perceptron.getInstancesSeen()
-					);
+			double sd = computeSD(atribSquredSum, atribSum, perceptron.getInstancesSeen());
 			debug("Attribute : " + x, 5);
 			debug("Value : " + instance.value(instAttIndex), 5);
 			debug("Mean : " + mean, 5);
@@ -283,79 +285,89 @@ protected void debuganomaly(Instance instance, double uni, double multi, double
 			debug("Anomaly in rule :" + this.owner.ruleNumberID, 5);
 		}
 	}
+
+	@Override
 	public void initialize(RuleActiveLearningNode oldLearningNode) {
 
-		if(((RuleActiveRegressionNode) oldLearningNode).perceptron!=null)
-		{
-			this.perceptron=new Perceptron(((RuleActiveRegressionNode) oldLearningNode).perceptron);
+		if (((RuleActiveRegressionNode) oldLearningNode).perceptron != null) {
+			this.perceptron = new Perceptron(((RuleActiveRegressionNode) oldLearningNode).perceptron);
 			this.perceptron.resetError();
-			this.perceptron.setLearningRatio(((AMRulesRegressorOld)this.amRules).learningRatioOption.getValue());
+			this.perceptron.setLearningRatio(((AMRulesRegressorOld) this.amRules).learningRatioOption.getValue());
 		}
 
-		if(((RuleActiveRegressionNode) oldLearningNode).targetMean!=null)
-		{
-			this.targetMean= new TargetMean(((RuleActiveRegressionNode) oldLearningNode).targetMean);
+		if (((RuleActiveRegressionNode) oldLearningNode).targetMean != null) {
+			this.targetMean = new TargetMean(((RuleActiveRegressionNode) oldLearningNode).targetMean);
 			this.targetMean.resetError();
 		}
-		//reset statistics
+		// reset statistics
 		this.nodeStatistics.setValue(0, 0);
 		this.nodeStatistics.setValue(1, 0);
 		this.nodeStatistics.setValue(2, 0);
 
 	}
 
+	@Override
 	public double[] getSimplePrediction() {
-		if( this.targetMean!=null)
+		if (this.targetMean != null)
 			return this.targetMean.getPredictionForInstance((Instance) null).asDoubleArray();
 		else
-			return new double[]{0};
+			return new double[] { 0 };
 
 	}
 
+	@Override
 	public boolean tryToExpand(double splitConfidence, double tieThreshold) {
 
 		// splitConfidence. Hoeffding Bound test parameter.
 		// tieThreshold. Hoeffding Bound test parameter.
-		//SplitCriterion splitCriterion = new SDRSplitCriterionAMRules(); 
-			//SplitCriterion splitCriterion = new SDRSplitCriterionAMRulesNode();//JD for assessing only best branch
-		AMRulesSplitCriterion splitCriterion=(AMRulesSplitCriterion)((AMRulesSplitCriterion) ((AMRulesRegressorOld)this.amRules).splitCriterionOption.getPreMaterializedObject()).copy();
+		// SplitCriterion splitCriterion = new SDRSplitCriterionAMRules();
+		// SplitCriterion splitCriterion = new SDRSplitCriterionAMRulesNode();//JD for
+		// assessing only best branch
+		AMRulesSplitCriterion splitCriterion = (AMRulesSplitCriterion) ((AMRulesSplitCriterion) ((AMRulesRegressorOld) this.amRules).splitCriterionOption
+				.getPreMaterializedObject()).copy();
 
 		// Using this criterion, find the best split per attribute and rank the results
-		AttributeSplitSuggestion[] bestSplitSuggestions
-		= this.getBestSplitSuggestions(splitCriterion);
+		AttributeSplitSuggestion[] bestSplitSuggestions = this.getBestSplitSuggestions(splitCriterion);
 		Arrays.sort(bestSplitSuggestions);
 		// Declare a variable to determine if any of the splits should be performed
 		boolean shouldSplit = false;
 
-
 		// If only one split was returned, use it
 		if (bestSplitSuggestions.length < 2) {
-			shouldSplit = ((bestSplitSuggestions.length > 0) && (bestSplitSuggestions[0].merit > 0)); 
+			shouldSplit = ((bestSplitSuggestions.length > 0) && (bestSplitSuggestions[0].merit > 0));
 			bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
 		} // Otherwise, consider which of the splits proposed may be worth trying
 		else {
-			// Determine the hoeffding bound value, used to select how many instances should be used to make a test decision
-			// to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
+			// Determine the hoeffding bound value, used to select how many instances should
+			// be used to make a test decision
+			// to feel reasonably confident that the test chosen by this sample is the same
+			// as what would be chosen using infinite examples
 			double hoeffdingBound = computeHoeffdingBound(1, splitConfidence, getWeightSeen());
 			debug("Hoeffding bound " + hoeffdingBound, 4);
 			// Determine the top two ranked splitting suggestions
 			bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-			AttributeSplitSuggestion secondBestSuggestion
-			= bestSplitSuggestions[bestSplitSuggestions.length - 2];
+			AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
 
 			debug("Merits: " + secondBestSuggestion.merit + " " + bestSuggestion.merit, 4);
 
-			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
-			// as determined using the hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
-			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
+			// If the upper bound of the sample mean for the ratio of SDR(best suggestion)
+			// to SDR(second best suggestion),
+			// as determined using the hoeffding bound, is less than 1, then the true mean
+			// is also less than 1, and thus at this
+			// particular moment of observation the bestSuggestion is indeed the best split
+			// option with confidence 1-delta, and
 			// splitting should occur.
-			// Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
-			// (default 0.05) is applied to the hoeffding bound; if the hoeffding bound is smaller than this limit then the two
-			// competing attributes are equally good, and the split will be made on the one with the higher SDR value.
+			// Alternatively, if two or more splits are very similar or identical in terms
+			// of their splits, then a threshold limit
+			// (default 0.05) is applied to the hoeffding bound; if the hoeffding bound is
+			// smaller than this limit then the two
+			// competing attributes are equally good, and the split will be made on the one
+			// with the higher SDR value.
 
 			if (bestSuggestion.merit > 0) {
-				//if ((((secondBestSuggestion.merit / bestSuggestion.merit) + hoeffdingBound) < 1) //ratio
-				if ((((bestSuggestion.merit-secondBestSuggestion.merit) ) > hoeffdingBound) // if normalized
+				// if ((((secondBestSuggestion.merit / bestSuggestion.merit) + hoeffdingBound) <
+				// 1) //ratio
+				if ((((bestSuggestion.merit - secondBestSuggestion.merit)) > hoeffdingBound) // if normalized
 						|| (hoeffdingBound < tieThreshold)) {
 					debug("Expanded ", 5);
 					shouldSplit = true;
@@ -366,7 +378,7 @@ public boolean tryToExpand(double splitConfidence, double tieThreshold) {
 		if (shouldSplit == true) {
 			AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
 			double minValue = Double.MAX_VALUE;
-			 double[] branchMerits = splitCriterion.computeBranchSplitMerits(bestSuggestion.resultingClassDistributions);
+			double[] branchMerits = splitCriterion.computeBranchSplitMerits(bestSuggestion.resultingClassDistributions);
 
 			for (int i = 0; i < bestSuggestion.numSplits(); i++) {
 				double value = branchMerits[i];
@@ -383,75 +395,73 @@ public boolean tryToExpand(double splitConfidence, double tieThreshold) {
 		return shouldSplit;
 	}
 
+	@Override
 	public void learnFromInstance(Instance inst) {
 
 		// Update the statistics for this node
 		// number of instances passing through the node
 		nodeStatistics.addToValue(0, inst.weight());
 		// sum of y values
-		nodeStatistics.addToValue(1, inst.classValue()*inst.weight());
+		nodeStatistics.addToValue(1, inst.classValue() * inst.weight());
 		// sum of squared y values
-		nodeStatistics.addToValue(2, inst.classValue()*inst.classValue()*inst.weight());
+		nodeStatistics.addToValue(2, inst.classValue() * inst.classValue() * inst.weight());
 		/*
-		for (int i = 0; i < inst.numAttributes() - 1; i++) {
-			int instAttIndex = AbstractAMRules.modelAttIndexToInstanceAttIndex(i, inst);
-
-			AttributeClassObserver obs = this.attributeObservers.get(i);
-			if (obs == null) {
-				// At this stage all nominal attributes are ignored
-				if (inst.attribute(instAttIndex).isNumeric()) //instAttIndex
-				{
-					obs = newNumericClassObserver();
-					this.attributeObservers.set(i, obs);
-				}
-			}
-			if (obs != null) {
-				((FIMTDDNumericAttributeClassObserver) obs).observeAttributeClass(inst.value(instAttIndex), inst.classValue(), inst.weight());
-			}
-		}*/
-		//if was of attributes was not created so far, generate one and create perceptron
-		if (attributesMask==null)
-		{
-			numAttributesSelected=(int)Math.round((inst.numAttributes()-1)*this.amRules.getAttributesPercentage())/100;
-			
-			attributesMask=new boolean[inst.numAttributes()];
-			ArrayList<Integer> indices = new ArrayList<Integer>();
-			for(int i=0; i<inst.numAttributes(); i++)
-				if(i!=inst.classIndex())
+		 * for (int i = 0; i < inst.numAttributes() - 1; i++) { int instAttIndex =
+		 * AbstractAMRules.modelAttIndexToInstanceAttIndex(i, inst);
+		 * 
+		 * AttributeClassObserver obs = this.attributeObservers.get(i); if (obs == null)
+		 * { // At this stage all nominal attributes are ignored if
+		 * (inst.attribute(instAttIndex).isNumeric()) //instAttIndex { obs =
+		 * newNumericClassObserver(); this.attributeObservers.set(i, obs); } } if (obs
+		 * != null) { ((FIMTDDNumericAttributeClassObserver)
+		 * obs).observeAttributeClass(inst.value(instAttIndex), inst.classValue(),
+		 * inst.weight()); } }
+		 */
+		// if was of attributes was not created so far, generate one and create
+		// perceptron
+		if (attributesMask == null) {
+			numAttributesSelected = (int) Math
+					.round((inst.numAttributes() - 1) * this.amRules.getAttributesPercentage()) / 100;
+
+			attributesMask = new boolean[inst.numAttributes()];
+			ArrayList<Integer> indices = new ArrayList<>();
+			for (int i = 0; i < inst.numAttributes(); i++)
+				if (i != inst.classIndex())
 					indices.add(i);
 			Collections.shuffle(indices, this.amRules.classifierRandom);
 			indices.add(inst.classIndex()); // add class index only after shuffle
-			
-			for (int i=0; i<numAttributesSelected;++i)
-				attributesMask[indices.get(i)]=true;
+
+			for (int i = 0; i < numAttributesSelected; ++i)
+				attributesMask[indices.get(i)] = true;
 		}
-		
-		for (int i = 0, ct=0; i < attributesMask.length; i++) {
-			if(attributesMask[i])
-			{
-			AttributeClassObserver obs = this.attributeObservers.get(ct);
-			if (obs == null) {
-				// At this stage all nominal attributes are ignored
-				if (inst.attribute(ct).isNumeric()) //instAttIndex
-				{
-					obs = newNumericClassObserver();
-					this.attributeObservers.set(ct, obs);
+
+		for (int i = 0, ct = 0; i < attributesMask.length; i++) {
+			if (attributesMask[i]) {
+				AttributeClassObserver obs = this.attributeObservers.get(ct);
+				if (obs == null) {
+					// At this stage all nominal attributes are ignored
+					if (inst.attribute(ct).isNumeric()) // instAttIndex
+					{
+						obs = newNumericClassObserver();
+						this.attributeObservers.set(ct, obs);
+					}
 				}
-			}
-			if (obs != null) {
-				((FIMTDDNumericAttributeClassObserver) obs).observeAttributeClass(inst.value(i), inst.classValue(), inst.weight());
-			}
-			++ct;
+				if (obs != null) {
+					((FIMTDDNumericAttributeClassObserver) obs).observeAttributeClass(inst.value(i), inst.classValue(),
+							inst.weight());
+				}
+				++ct;
 			}
 		}
-		
+
 	}
 
 	public AttributeSplitSuggestion[] getBestSplitSuggestions(SplitCriterion criterion) {
 
-		List<AttributeSplitSuggestion> bestSuggestions = new LinkedList<AttributeSplitSuggestion>();
+		List<AttributeSplitSuggestion> bestSuggestions = new LinkedList<>();
 
-		// Set the nodeStatistics up as the preSplitDistribution, rather than the observedClassDistribution
+		// Set the nodeStatistics up as the preSplitDistribution, rather than the
+		// observedClassDistribution
 		double[] nodeSplitDist = this.nodeStatistics.getArrayCopy();
 
 		for (int i = 0; i < this.attributeObservers.size(); i++) {
@@ -484,17 +494,16 @@ public double getWeightSeen() {
 	@Override
 	public double getCurrentError() {
 		double error;
-		if (this.perceptron!=null){
-			if (targetMean==null)
-				error=perceptron.getCurrentError();
-			else{
-				double errorP=perceptron.getCurrentError();
-				double errorTM=targetMean.getCurrentError();
-				error = (errorP<errorTM) ? errorP : errorTM;	
-			}		
-		}
-		else
-			error=Double.MAX_VALUE;
+		if (this.perceptron != null) {
+			if (targetMean == null)
+				error = perceptron.getCurrentError();
+			else {
+				double errorP = perceptron.getCurrentError();
+				double errorTM = targetMean.getCurrentError();
+				error = (errorP < errorTM) ? errorP : errorTM;
+			}
+		} else
+			error = Double.MAX_VALUE;
 		return error;
 	}
 }
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/rules/core/RuleSet.java b/moa/src/main/java/moa/learners/predictors/rules/core/RuleSet.java
similarity index 91%
rename from moa/src/main/java/moa/classifiers/rules/core/RuleSet.java
rename to moa/src/main/java/moa/learners/predictors/rules/core/RuleSet.java
index 7ebd705ce..fb7907609 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/RuleSet.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/RuleSet.java
@@ -14,15 +14,15 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
-package moa.classifiers.rules.core;
+package moa.learners.predictors.rules.core;
 
 import java.util.ArrayList;
 
 public class RuleSet extends ArrayList<Rule> {
 
 	private static final long serialVersionUID = 1L;
-	
+
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/core/RuleSplitNode.java b/moa/src/main/java/moa/learners/predictors/rules/core/RuleSplitNode.java
similarity index 53%
rename from moa/src/main/java/moa/classifiers/rules/core/RuleSplitNode.java
rename to moa/src/main/java/moa/learners/predictors/rules/core/RuleSplitNode.java
index f0590eb85..7ed43fe69 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/RuleSplitNode.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/RuleSplitNode.java
@@ -14,40 +14,40 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
-package moa.classifiers.rules.core;
+package moa.learners.predictors.rules.core;
 
 import com.yahoo.labs.samoa.instances.Instance;
 
-import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
-import moa.classifiers.trees.HoeffdingTree.SplitNode;
+import moa.learners.predictors.core.conditionaltests.InstanceConditionalTest;
+import moa.learners.predictors.trees.HoeffdingTree.SplitNode;
 
 /**
  * A modified SplitNode method implementing the extra information
  */
 public class RuleSplitNode extends SplitNode {
 
-    protected double lastTargetMean;
-    protected int operatorObserver;
+	protected double lastTargetMean;
+	protected int operatorObserver;
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public InstanceConditionalTest getSplitTest() {
-        return this.splitTest;
-    }
+	public InstanceConditionalTest getSplitTest() {
+		return this.splitTest;
+	}
 
-    /**
-     * Create a new RuleSplitNode
-     */
-    public RuleSplitNode(InstanceConditionalTest splitTest, double[] classObservations) {
-        super(splitTest, classObservations);
-    }
+	/**
+	 * Create a new RuleSplitNode
+	 */
+	public RuleSplitNode(InstanceConditionalTest splitTest, double[] classObservations) {
+		super(splitTest, classObservations);
+	}
 
-    public boolean evaluate(Instance instance) {
-        Predicate predicate = (Predicate) this.splitTest;
-        return predicate.evaluate(instance);
-    }
+	public boolean evaluate(Instance instance) {
+		Predicate predicate = (Predicate) this.splitTest;
+		return predicate.evaluate(instance);
+	}
 
 }
diff --git a/moa/src/main/java/moa/learners/predictors/rules/core/Utils.java b/moa/src/main/java/moa/learners/predictors/rules/core/Utils.java
new file mode 100644
index 000000000..8faf1c7af
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/Utils.java
@@ -0,0 +1,132 @@
+/*
+ *    Utils.java
+ *    Copyright (C) 2017 University of Porto, Portugal
+ *    @author J. Duarte, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.predictors.rules.core;
+
+import moa.core.DoubleVector;
+import moa.learners.predictors.core.attributeclassobservers.SingleVector;
+
+/**
+ * Class that contains several utilities Variance Standard deviation Vector
+ * operations(copy, etc) Entropy Complementary set
+ */
+
+public final class Utils {
+
+	public static double computeVariance(double count, double sum, double sumSquares) {
+		return (sumSquares - ((sum * sum) / count)) / count;
+	}
+
+	public static double computeVariance(DoubleVector statistics) {
+		return computeVariance(statistics.getValue(0), statistics.getValue(1), statistics.getValue(2));
+	}
+
+	public static double computeVariance(double[] statistics) {
+		return computeVariance(statistics[0], statistics[1], statistics[2]);
+	}
+
+	public static double computeSD(double squaredSum, double sum, double weightSeen) {
+		if (weightSeen > 1) {
+			return Math.sqrt((squaredSum - ((sum * sum) / weightSeen)) / (weightSeen - 1.0));
+		}
+		return 0.0;
+	}
+
+	public static double computeSD(DoubleVector statistics) {
+		return computeSD(statistics.getValue(0), statistics.getValue(1), statistics.getValue(2));
+	}
+
+	public static DoubleVector[][] copy(DoubleVector[][] toCopy) {
+		DoubleVector[][] copy = new DoubleVector[toCopy.length][];
+		for (int i = 0; i < toCopy.length; i++)
+			copy[i] = Utils.copy(toCopy[i]);
+		return copy;
+	}
+
+	public static DoubleVector[] copy(DoubleVector[] toCopy) {
+		DoubleVector[] copy = new DoubleVector[toCopy.length];
+		for (int i = 0; i < toCopy.length; i++)
+			copy[i] = new DoubleVector(toCopy[i]);
+		return copy;
+	}
+
+	public static SingleVector[] copyAsFloatVector(DoubleVector[] toCopy) {
+		SingleVector[] toCopyFloat = new SingleVector[toCopy.length];
+		for (int i = 0; i < toCopy.length; i++)
+			toCopyFloat[i] = new SingleVector(toCopy[i].getArrayRef());
+		return toCopyFloat;
+	}
+
+	public static SingleVector[] copy(SingleVector[] toCopy) {
+		SingleVector[] copy = new SingleVector[toCopy.length];
+		for (int i = 0; i < toCopy.length; i++)
+			copy[i] = new SingleVector(toCopy[i]);
+		return copy;
+	}
+
+	public static DoubleVector floatToDoubleVector(SingleVector toCopy) {
+		float[] ref = toCopy.getArrayRef();
+		double[] array = new double[ref.length];
+		for (int i = 0; i < ref.length; i++) {
+			array[i] = ref[i];
+		}
+		return new DoubleVector(array);
+	}
+
+	public static int[] complementSet(int[] referenceSet, int[] comparingSet) {
+		int[] indices = new int[referenceSet.length - comparingSet.length];
+		int j = 0, l = 0, i;
+		for (i = 0; i < referenceSet.length && l < comparingSet.length; i++) {
+			if (referenceSet[i] != comparingSet[l]) {
+				indices[j] = referenceSet[i];
+				j++;
+			} else
+				l++;
+		}
+		while (i < referenceSet.length) {
+			indices[j] = referenceSet[i];
+			i++;
+			j++;
+		}
+		return indices;
+	}
+
+	public static int[] getIndexCorrespondence(int[] originalSet, int[] subSet) {
+		int[] indices = new int[subSet.length];
+		int j = 0;
+		for (int i = 0; i < subSet.length; i++) {
+			while (originalSet[j] != subSet[i])
+				j++;
+			indices[i] = j;
+		}
+		return indices;
+	}
+
+	public static double computeEntropy(DoubleVector statistics) {
+		return computeEntropy(statistics.getValue(0), statistics.getValue(1));
+	}
+
+	public static double computeEntropy(double count, double sum) {
+		if (sum / count == 1 || sum == 0)
+			return 0;
+		else
+			return -(sum / count * Math.log(sum / count) + (1 - sum / count) * Math.log(1 - sum / count));
+
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AbstractAnomalyDetector.java b/moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/AbstractAnomalyDetector.java
similarity index 94%
rename from moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AbstractAnomalyDetector.java
rename to moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/AbstractAnomalyDetector.java
index b91de0c4a..73c0c18de 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AbstractAnomalyDetector.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/AbstractAnomalyDetector.java
@@ -18,17 +18,16 @@
  *
  */
 
-package moa.classifiers.rules.core.anomalydetection;
+package moa.learners.predictors.rules.core.anomalydetection;
 
 import com.yahoo.labs.samoa.instances.Instance;
 
 import moa.options.AbstractOptionHandler;
 
-
 public abstract class AbstractAnomalyDetector extends AbstractOptionHandler implements AnomalyDetector {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 
diff --git a/moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/AnomalinessRatioScore.java b/moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/AnomalinessRatioScore.java
new file mode 100644
index 000000000..4e7d2bf81
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/AnomalinessRatioScore.java
@@ -0,0 +1,149 @@
+/*
+ *    AnomalinessRatioScore.java
+ *    Copyright (C) 2017 University of Porto, Portugal
+ *    @author J. Duarte, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.predictors.rules.core.anomalydetection;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.core.AutoExpandVector;
+import moa.core.ObjectRepository;
+import moa.learners.predictors.rules.core.Utils;
+import moa.learners.predictors.rules.core.anomalydetection.probabilityfunctions.ProbabilityFunction;
+import moa.options.ClassOption;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Score for anomaly detection
+ *
+ * percentageAnomalousAttributesOption - Percentage of anomalous attributes.
+ * univariateAnomalyprobabilityThresholdOption - Univariate anomaly threshold
+ * value minNumberInstancesOption - The minimum number of instances required to
+ * perform anomaly detection probabilityFunctionOption - Probability function
+ * selection
+ */
+
+public class AnomalinessRatioScore extends AbstractAnomalyDetector {
+
+	/**
+	 *
+	 */
+	private static final long serialVersionUID = 1L;
+	private static final double MINSTD = 0.01;
+
+	public FloatOption percentageAnomalousAttributesOption = new FloatOption("percentageAnomalousAttributes", 'm',
+			"Percentage of anomalous attributes.", 0.5, 0.0, 1.0);
+	public FloatOption univariateAnomalyprobabilityThresholdOption = new FloatOption(
+			"univariateAnomalyprobabilityThreshold", 'u', "Univariate anomaly threshold value.", 0.90, 0.0, 1.0);
+
+	public IntOption minNumberInstancesOption = new IntOption("minNumberInstances", 'n',
+			"The minimum number of instances required to perform anomaly detection.", 30, 0, Integer.MAX_VALUE);
+
+	public ClassOption probabilityFunctionOption = new ClassOption("probabilityFunction", 'p', "Probability function",
+			ProbabilityFunction.class, "GaussInequality");
+
+	private int minInstances;
+	private double weightSeen;
+	private double univariateThreshold;
+	private double percentageAnomalous;
+	AutoExpandVector<double[]> sufficientStatistics;
+	private ProbabilityFunction probabilityFunction;
+
+	public double anomalyScore;
+
+	@Override
+	public double getAnomalyScore() {
+		return anomalyScore;
+	}
+
+	@Override
+	public boolean updateAndCheckAnomalyDetection(Instance instance) {
+		boolean isAnomaly = false;
+		if (probabilityFunction == null) {
+			weightSeen = 0.0;
+			// load options
+			minInstances = minNumberInstancesOption.getValue();
+			univariateThreshold = univariateAnomalyprobabilityThresholdOption.getValue();
+			percentageAnomalous = percentageAnomalousAttributesOption.getValue();
+			probabilityFunction = (ProbabilityFunction) getPreparedClassOption(probabilityFunctionOption);
+
+			// free memory
+			minNumberInstancesOption = null;
+			univariateAnomalyprobabilityThresholdOption = null;
+			percentageAnomalousAttributesOption = null;
+			probabilityFunctionOption = null;
+		}
+		double anomaly = 0;
+		if (weightSeen > minInstances) {
+			int anomalousTotal = 0, total = 0;
+			// check if it is anomaly
+			for (int i = 0; i < instance.numInputAttributes(); i++) {
+				double prob = 0;
+				double[] stats = sufficientStatistics.get(i);
+				if (instance.attribute(i).isNumeric()) {
+					double val = instance.valueInputAttribute(i);
+					double sd = Utils.computeSD(stats[1], stats[0], weightSeen);
+					if (sd > MINSTD) {
+						prob = probabilityFunction.getProbability(stats[0] / weightSeen,
+								Utils.computeSD(stats[1], stats[0], weightSeen), val);
+						if ((1 - prob) > univariateThreshold)
+							anomalousTotal++;
+						total++;
+					}
+				}
+			}
+			if (total > 0)
+				anomaly = anomaly / total;
+			isAnomaly = (anomalousTotal / ((double) total) > percentageAnomalous);
+			anomalyScore = anomaly;
+		}
+		// update stats
+		if (!isAnomaly) {
+			if (sufficientStatistics == null)
+				sufficientStatistics = new AutoExpandVector<>();
+			weightSeen += instance.weight();
+			for (int i = 0; i < instance.numInputAttributes(); i++) {
+				double[] stats = sufficientStatistics.get(i);
+				if (instance.attribute(i).isNumeric()) {
+					double val = instance.valueInputAttribute(i);
+					if (stats != null) {
+						// update statistics for numeric attributes
+						stats[0] += val;
+						stats[1] += (val * val);
+					} else {
+						stats = new double[] { instance.weight() * val, instance.weight() * val * val };
+						sufficientStatistics.set(i, stats);
+					}
+				}
+			}
+		}
+		return isAnomaly;
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+	}
+
+}
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalyDetector.java b/moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/AnomalyDetector.java
similarity index 68%
rename from moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalyDetector.java
rename to moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/AnomalyDetector.java
index f6af8d300..d8174af41 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/AnomalyDetector.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/AnomalyDetector.java
@@ -18,30 +18,30 @@
  *
  */
 
-package moa.classifiers.rules.core.anomalydetection;
+package moa.learners.predictors.rules.core.anomalydetection;
+
 import com.yahoo.labs.samoa.instances.Instance;
 
 import moa.options.OptionHandler;
 
-
 /**
- *  Anomaly Detector interface to implement methods that detects change.
+ * Anomaly Detector interface to implement methods that detects change.
  *
  * @author João Duarte (joaomaiaduarte at gmail dot com)
  * @version $Revision: 1$
  */
 public interface AnomalyDetector extends OptionHandler {
 
+	/**
+	 * Adding an instance to the anomaly detector<br>
+	 * <br>
+	 *
+	 * @return true if anomaly is detected and false otherwise
+	 */
+	boolean updateAndCheckAnomalyDetection(Instance instance);
 
-    /**
-     * Adding an instance to the anomaly detector<br><br>
-     *
-     * @return true if anomaly is detected and false otherwise
-     */
-    public boolean updateAndCheckAnomalyDetection(Instance instance);
+	double getAnomalyScore();
 
-    public double getAnomalyScore();
-    
-    @Override
-    public AnomalyDetector copy();
+	@Override
+	AnomalyDetector copy();
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/NoAnomalyDetection.java b/moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/NoAnomalyDetection.java
similarity index 68%
rename from moa/src/main/java/moa/classifiers/rules/core/anomalydetection/NoAnomalyDetection.java
rename to moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/NoAnomalyDetection.java
index 59a80961b..2bea592e7 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/NoAnomalyDetection.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/NoAnomalyDetection.java
@@ -17,28 +17,27 @@
  *
  *
  */
-package moa.classifiers.rules.core.anomalydetection;
+package moa.learners.predictors.rules.core.anomalydetection;
 
 import com.yahoo.labs.samoa.instances.Instance;
 
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
 
-
 /**
- *  No anomaly detection is performed
+ * No anomaly detection is performed
  */
 
-public class NoAnomalyDetection extends AbstractAnomalyDetector{
+public class NoAnomalyDetection extends AbstractAnomalyDetector {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
-		
+
 	}
 
 	@Override
@@ -47,20 +46,20 @@ public boolean updateAndCheckAnomalyDetection(Instance instance) {
 	}
 
 	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
-		
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+
 	}
-	
-        public double anomalyScore;
 
-        @Override 
-        public double getAnomalyScore(){
-            return anomalyScore;
-        }
-    @Override
-    public String getPurposeString() {
-        return "Use this class to NOT detect anomalies.";
-    }
+	public double anomalyScore;
+
+	@Override
+	public double getAnomalyScore() {
+		return anomalyScore;
+	}
+
+	@Override
+	public String getPurposeString() {
+		return "Use this class to NOT detect anomalies.";
+	}
 
 }
diff --git a/moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/OddsRatioScore.java b/moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/OddsRatioScore.java
new file mode 100644
index 000000000..452cec760
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/OddsRatioScore.java
@@ -0,0 +1,176 @@
+/*
+ *    OddsRatioScore.java
+ *    Copyright (C) 2017 University of Porto, Portugal
+ *    @author J. Duarte, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.predictors.rules.core.anomalydetection;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.core.AutoExpandVector;
+import moa.core.ObjectRepository;
+import moa.learners.predictors.rules.core.Utils;
+import moa.learners.predictors.rules.core.anomalydetection.probabilityfunctions.CantellisInequality;
+import moa.learners.predictors.rules.core.anomalydetection.probabilityfunctions.ProbabilityFunction;
+import moa.options.ClassOption;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Score for anomaly detection: OddsRatio
+ *
+ * thresholdOption - The threshold value for detecting anomalies
+ * minNumberInstancesOption - The minimum number of instances required to
+ * perform anomaly detection probabilityFunctionOption - Probability function
+ * selection
+ */
+
+public class OddsRatioScore extends AbstractAnomalyDetector {
+
+	/**
+	 *
+	 */
+	private static final long serialVersionUID = 1L;
+	private static final double MINSTD = 0.01;
+	private static final double MINPROB = 0.01;
+	private static final double MAXPROB = 1 - MINPROB;
+
+	public IntOption minNumberInstancesOption = new IntOption("minNumberInstances", 'n',
+			"The minimum number of instances required to perform anomaly detection.", 30, 0, Integer.MAX_VALUE);
+
+	public FloatOption thresholdOption = new FloatOption("threshold", 't',
+			"The threshold value for detecting anomalies.", -0.75, -10, 0);
+
+	public ClassOption probabilityFunctionOption = new ClassOption("probabilityFunction", 'p', "Probability function",
+			ProbabilityFunction.class, CantellisInequality.class.getName());
+
+	private int minInstances;
+	private double weightSeen;
+	private double threshold;
+	AutoExpandVector<double[]> sufficientStatistics;
+	private ProbabilityFunction probabilityFunction;
+	public double anomalyScore;
+
+	@Override
+	public double getAnomalyScore() {
+		return anomalyScore;
+	}
+
+	@Override
+	public boolean updateAndCheckAnomalyDetection(Instance instance) {
+		boolean isAnomaly = false;
+		if (probabilityFunction == null) {
+			weightSeen = 0.0;
+			// load options
+			minInstances = minNumberInstancesOption.getValue();
+			threshold = thresholdOption.getValue();
+			probabilityFunction = (ProbabilityFunction) getPreparedClassOption(probabilityFunctionOption);
+			// free memory
+			minNumberInstancesOption = null;
+			probabilityFunctionOption = null;
+		}
+		double anomaly = 0;
+		if (weightSeen > minInstances) {
+			int ct = 0;
+			// check if it is anomaly
+			for (int i = 0; i < instance.numInputAttributes(); i++) {
+				double prob = 0;
+				double[] stats = sufficientStatistics.get(i);
+				if (instance.attribute(i).isNumeric()) {
+					double val = instance.valueInputAttribute(i);
+					double sd = Utils.computeSD(stats[1], stats[0], weightSeen);
+					if (sd > MINSTD) {
+						prob = probabilityFunction.getProbability(stats[0] / weightSeen, sd, val);
+						if (prob > MAXPROB)
+							prob = MAXPROB;
+						else if (prob < MINPROB)
+							prob = MINPROB;
+						anomaly += Math.log(prob) - Math.log(1 - prob);
+						ct++;
+					}
+				}
+			}
+			if (ct > 0)
+				anomaly = anomaly / ct;
+			isAnomaly = anomaly < threshold;
+		}
+		// update stats
+		if (!isAnomaly) {
+			if (sufficientStatistics == null)
+				sufficientStatistics = new AutoExpandVector<>();
+			weightSeen += instance.weight();
+			for (int i = 0; i < instance.numInputAttributes(); i++) {
+				double[] stats = sufficientStatistics.get(i);
+				if (instance.attribute(i).isNumeric()) {
+					double val = instance.valueInputAttribute(i);
+					if (stats != null) {
+						// update statistics for numeric attributes
+						stats[0] += val;
+						stats[1] += (val * val);
+					} else {
+						stats = new double[] { instance.weight() * val, instance.weight() * val * val };
+						sufficientStatistics.set(i, stats);
+					}
+				}
+			}
+		}
+		/*
+		 * else { //System.out.println("Anomaly = " + anomaly + "#instances: " +
+		 * weightSeen); printAnomaly(instance, anomaly); }
+		 */
+		return isAnomaly;
+	}
+
+	protected void printAnomaly(Instance inst, double anomaly) {
+		StringBuffer sb = new StringBuffer();
+		for (int i = 0; i < inst.numInputAttributes(); i++) {
+			if (inst.attribute(i).isNumeric()) {
+				double[] stats;
+				// Attribute name
+				sb.append("Attribute " + i + " (" + inst.attribute(i).name() + ") - ");
+				// Val for instance
+				double val = inst.valueInputAttribute(i);
+				sb.append("Value: ").append(val);
+				stats = sufficientStatistics.get(i);
+				double mean = stats[0] / weightSeen;
+				double std = Utils.computeSD(stats[1], stats[0], weightSeen);
+				double prob = probabilityFunction.getProbability(mean, Utils.computeSD(stats[1], stats[0], weightSeen),
+						val);
+				// Mean
+				sb.append(" - Prob: ").append(prob);
+				// Mean
+				sb.append(" - Mean: ").append(mean);
+				// SD
+				sb.append(" - Std: ").append(std).append("\n");
+			}
+		}
+		sb.append("Score - ").append(anomaly);
+		System.out.println(sb);
+
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+	}
+
+}
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/CantellisInequality.java b/moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/probabilityfunctions/CantellisInequality.java
similarity index 73%
rename from moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/CantellisInequality.java
rename to moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/probabilityfunctions/CantellisInequality.java
index 9be03406d..1d3c29df3 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/CantellisInequality.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/probabilityfunctions/CantellisInequality.java
@@ -17,37 +17,33 @@
  *
  *
  */
-package moa.classifiers.rules.core.anomalydetection.probabilityfunctions;
+package moa.learners.predictors.rules.core.anomalydetection.probabilityfunctions;
 
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.tasks.TaskMonitor;
 
-
 /**
- * Returns the probability for anomaly detection according to a Cantelli inequality
- * mean- mean of a  data variable
- * sd- standard deviation of a data variable
- * value- current value of the variable
+ * Returns the probability for anomaly detection according to a Cantelli
+ * inequality mean- mean of a data variable sd- standard deviation of a data
+ * variable value- current value of the variable
  */
 
-
-
 public class CantellisInequality extends AbstractOptionHandler implements ProbabilityFunction {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 
 	@Override
 	public double getProbability(double mean, double sd, double value) {
-		if(sd==0)
-			sd=10^-9;
-		double var=Math.pow(sd, 2);
-		double prob=2*var/(var+Math.pow(value - mean, 2));
-		if(prob>1)
-			prob=1;
+		if (sd == 0)
+			sd = 10 ^ -9;
+		double var = Math.pow(sd, 2);
+		double prob = 2 * var / (var + Math.pow(value - mean, 2));
+		if (prob > 1)
+			prob = 1;
 		return prob;
 	}
 
@@ -57,11 +53,8 @@ public void getDescription(StringBuilder sb, int indent) {
 	}
 
 	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
-
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
 
 	}
 
-
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/ChebyshevInequality.java b/moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/probabilityfunctions/ChebyshevInequality.java
similarity index 65%
rename from moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/ChebyshevInequality.java
rename to moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/probabilityfunctions/ChebyshevInequality.java
index eec483dcb..64acb5858 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/ChebyshevInequality.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/probabilityfunctions/ChebyshevInequality.java
@@ -17,59 +17,51 @@
  *
  *
  */
-package moa.classifiers.rules.core.anomalydetection.probabilityfunctions;
+package moa.learners.predictors.rules.core.anomalydetection.probabilityfunctions;
 
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.tasks.TaskMonitor;
 
 /**
- * Returns the probability for anomaly detection according to a Chebyshev inequality
- * mean- mean of a  data variable
- * sd- standard deviation of a data variable
- * value- current value of the variable
+ * Returns the probability for anomaly detection according to a Chebyshev
+ * inequality mean- mean of a data variable sd- standard deviation of a data
+ * variable value- current value of the variable
  */
 
-
-
-
 public class ChebyshevInequality extends AbstractOptionHandler implements ProbabilityFunction {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
-		
-		
+
 	}
 
 	@Override
 	public double getProbability(double mean, double sd, double value) {
 		{
 			double probability = 0.0;
-		//	double diff = value - mean;
-	        if (sd > 0.0) {
-	            double k = (Math.abs(value - mean) / sd);
-	            if (k > 1.0) {
-	                probability = 1.0 / (k * k); // Chebyshev's inequality
-	            } else {
-	                //probability = Math.exp(-(diff * diff / (2.0 * sd * sd)));
-	            	probability=1;
-	            }
-	        }
+			// double diff = value - mean;
+			if (sd > 0.0) {
+				double k = (Math.abs(value - mean) / sd);
+				if (k > 1.0) {
+					probability = 1.0 / (k * k); // Chebyshev's inequality
+				} else {
+					// probability = Math.exp(-(diff * diff / (2.0 * sd * sd)));
+					probability = 1;
+				}
+			}
 			return probability;
 		}
 	}
 
 	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
-		
-		
-	}
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
 
+	}
 
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/GaussInequality.java b/moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/probabilityfunctions/GaussInequality.java
similarity index 62%
rename from moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/GaussInequality.java
rename to moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/probabilityfunctions/GaussInequality.java
index c4338ed41..1d1c22677 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/GaussInequality.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/probabilityfunctions/GaussInequality.java
@@ -18,7 +18,7 @@
  *
  */
 
-package moa.classifiers.rules.core.anomalydetection.probabilityfunctions;
+package moa.learners.predictors.rules.core.anomalydetection.probabilityfunctions;
 
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
@@ -26,55 +26,42 @@
 
 /**
  * Returns the probability for anomaly detection according to a Gauss inequality
- * mean- mean of a  data variable
- * sd- standard deviation of a data variable
+ * mean- mean of a data variable sd- standard deviation of a data variable
  * value- current value of the variable
  */
 
-
-
-
 public class GaussInequality extends AbstractOptionHandler implements ProbabilityFunction {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
-	private static final double SQRT3=Math.sqrt(3);
+	private static final double SQRT3 = Math.sqrt(3);
 
 	@Override
 	public double getProbability(double mean, double sd, double value) {
 		/*
-		 * From Wikipedia
-		 * http://en.wikipedia.org/wiki/Gauss's_inequality
+		 * From Wikipedia http://en.wikipedia.org/wiki/Gauss's_inequality
 		 */
 		/*
-		if(sd==0)
-			sd=0.0000001;
-		double k=Math.abs(value-mean);
-		double r=Math.sqrt(Math.pow(k,2)+Math.pow(sd,2));
-		if (k>2*r/SQRT3)
-			return Math.pow(2*r/(3*k),2);
-		else if(r>0)
-			return 1-k/(r*SQRT3);
-		else
-			return 1;
-		*/
-		
+		 * if(sd==0) sd=0.0000001; double k=Math.abs(value-mean); double
+		 * r=Math.sqrt(Math.pow(k,2)+Math.pow(sd,2)); if (k>2*r/SQRT3) return
+		 * Math.pow(2*r/(3*k),2); else if(r>0) return 1-k/(r*SQRT3); else return 1;
+		 */
+
 		/*
-		 * From "Generalized Gauss Inequalities via Semidefinite Programming 
-		 * by Bart P.G. Van Pary, Paul J. Goulart and Daniel Kuhn
+		 * From "Generalized Gauss Inequalities via Semidefinite Programming by Bart
+		 * P.G. Van Pary, Paul J. Goulart and Daniel Kuhn
 		 */
-		
-		if(sd==0)
-			sd=0.0000001;
-		double k=Math.abs(value-mean)/sd;
-		if (k>2/SQRT3)
-			return 4/(9*Math.pow(k,2));
-		else 
-			return 1-k/SQRT3;
-			
-		
+
+		if (sd == 0)
+			sd = 0.0000001;
+		double k = Math.abs(value - mean) / sd;
+		if (k > 2 / SQRT3)
+			return 4 / (9 * Math.pow(k, 2));
+		else
+			return 1 - k / SQRT3;
+
 	}
 
 	@Override
@@ -83,11 +70,8 @@ public void getDescription(StringBuilder sb, int indent) {
 	}
 
 	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
-
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
 
 	}
 
-
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/ProbabilityFunction.java b/moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/probabilityfunctions/ProbabilityFunction.java
similarity index 91%
rename from moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/ProbabilityFunction.java
rename to moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/probabilityfunctions/ProbabilityFunction.java
index e29de1fbf..24bedf020 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/anomalydetection/probabilityfunctions/ProbabilityFunction.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/anomalydetection/probabilityfunctions/ProbabilityFunction.java
@@ -17,7 +17,7 @@
  *
  *
  */
-package moa.classifiers.rules.core.anomalydetection.probabilityfunctions;
+package moa.learners.predictors.rules.core.anomalydetection.probabilityfunctions;
 
 import moa.options.OptionHandler;
 
diff --git a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java b/moa/src/main/java/moa/learners/predictors/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java
similarity index 66%
rename from moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java
rename to moa/src/main/java/moa/learners/predictors/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java
index df2405a5a..1b64642a5 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/conditionaltests/NominalAttributeBinaryRulePredicate.java
@@ -14,17 +14,17 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
-package moa.classifiers.rules.core.conditionaltests;
+package moa.learners.predictors.rules.core.conditionaltests;
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
-import moa.classifiers.core.conditionaltests.NominalAttributeBinaryTest;
-import moa.classifiers.rules.core.Predicate;
 import moa.core.StringUtils;
+import moa.learners.predictors.core.conditionaltests.NominalAttributeBinaryTest;
+import moa.learners.predictors.rules.core.Predicate;
 
 /**
  * Nominal binary conditional test for instances to use to split nodes in rules.
@@ -36,37 +36,38 @@ public class NominalAttributeBinaryRulePredicate extends NominalAttributeBinaryT
 	public NominalAttributeBinaryRulePredicate(int attIndex, int attValue) {
 		super(attIndex, attValue);
 	}
-	//used for negation
-	protected boolean state=true;
+
+	// used for negation
+	protected boolean state = true;
 
 	private static final long serialVersionUID = 1L;
 
 	@Override
 	public boolean evaluate(Instance inst) {
-		if(state)
-			return (branchForInstance(inst) == 0) ;
+		if (state)
+			return (branchForInstance(inst) == 0);
 		else
 			return (branchForInstance(inst) != 0);
 	}
 
 	@Override
 	public void negateCondition() {
-		state=!state;
-		
+		state = !state;
+
 	}
 
 	@Override
-	public void getDescription(StringBuilder sb, int indent) {   
-		if(state)
-			StringUtils.appendIndented(sb, indent+1, "In" + attIndex + " = " + attValue);
+	public void getDescription(StringBuilder sb, int indent) {
+		if (state)
+			StringUtils.appendIndented(sb, indent + 1, "In" + attIndex + " = " + attValue);
 		else
-			StringUtils.appendIndented(sb, indent+1, "In" + attIndex + " <> " + attValue);
+			StringUtils.appendIndented(sb, indent + 1, "In" + attIndex + " <> " + attValue);
 	}
-	
+
 	@Override
-	public String toString(){
+	public String toString() {
 		StringBuilder sb = new StringBuilder();
-		getDescription(sb,0);
+		getDescription(sb, 0);
 		return sb.toString();
 	}
 
@@ -82,11 +83,12 @@ public boolean isEqualOrLess() {
 
 	@Override
 	public void getDescription(StringBuilder sb, int indent, InstancesHeader header) {
-		if(state)
-			StringUtils.appendIndented(sb, indent, InstancesHeader.getAttributeNameString(header, attIndex) + " = " + attValue);
+		if (state)
+			StringUtils.appendIndented(sb, indent,
+					InstancesHeader.getAttributeNameString(header, attIndex) + " = " + attValue);
 		else
-			StringUtils.appendIndented(sb, indent, InstancesHeader.getAttributeNameString(header, attIndex) + " <> " + attValue);		
+			StringUtils.appendIndented(sb, indent,
+					InstancesHeader.getAttributeNameString(header, attIndex) + " <> " + attValue);
 	}
-	
-	
+
 }
diff --git a/moa/src/main/java/moa/learners/predictors/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java b/moa/src/main/java/moa/learners/predictors/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java
new file mode 100644
index 000000000..11a571900
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/conditionaltests/NumericAttributeBinaryRulePredicate.java
@@ -0,0 +1,165 @@
+/*
+ *    NumericAttributeBinaryRulePredicate.java
+ *    Copyright (C) 2013 University of Porto, Portugal
+ *    @author E. Almeida, A. Carvalho, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.predictors.rules.core.conditionaltests;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
+import moa.core.StringUtils;
+import moa.learners.predictors.core.conditionaltests.InstanceConditionalBinaryTest;
+import moa.learners.predictors.rules.core.Predicate;
+
+/**
+ * Numeric binary conditional test for instances to use to split nodes in
+ * AMRules.
+ *
+ * @version $Revision: 1 $
+ */
+public class NumericAttributeBinaryRulePredicate extends InstanceConditionalBinaryTest implements Predicate {
+
+	private static final long serialVersionUID = 1L;
+
+	protected int attIndex;
+
+	protected double attValue;
+
+	protected int operator; // 0 =, 1<=, 2>
+
+	protected boolean state = true;
+
+	public NumericAttributeBinaryRulePredicate(int attIndex, double attValue, int operator) {
+		this.attIndex = attIndex;
+		this.attValue = attValue;
+		this.operator = operator;
+	}
+
+	@Override
+	public void negateCondition() {
+		state = !state;
+
+	}
+
+	@Override
+	public int branchForInstance(Instance inst) {
+		int instAttIndex = this.attIndex < inst.classIndex() ? this.attIndex : this.attIndex + 1;
+		if (inst.isMissing(instAttIndex)) {
+			return -1;
+		}
+		double v = inst.value(instAttIndex);
+		int ret = 0;
+		switch (this.operator) {
+		case 0:
+			ret = (v == this.attValue) ? 0 : 1;
+			break;
+		case 1:
+			ret = (v <= this.attValue) ? 0 : 1;
+			break;
+		case 2:
+			ret = (v > this.attValue) ? 0 : 1;
+		}
+		return ret;
+	}
+
+	/**
+	 *
+	 */
+	@Override
+	public String describeConditionForBranch(int branch, InstancesHeader context) {
+		if ((branch >= 0) && (branch <= 2)) {
+			String compareChar = (branch == 0) ? "=" : (branch == 1) ? "<=" : ">";
+			return InstancesHeader.getAttributeNameString(context, this.attIndex) + ' ' + compareChar
+					+ InstancesHeader.getNumericValueString(context, this.attIndex, this.attValue);
+		}
+		throw new IndexOutOfBoundsException();
+	}
+
+	@Override
+	public int[] getAttsTestDependsOn() {
+		return new int[] { this.attIndex };
+	}
+
+	public double getSplitValue() {
+		return this.attValue;
+	}
+
+	@Override
+	public boolean evaluate(Instance inst) {
+		if (state)
+			return (branchForInstance(inst) == 0);
+		else
+			return (branchForInstance(inst) != 0);
+	}
+
+	public boolean isEqual(NumericAttributeBinaryRulePredicate predicate) {
+		return (this.attIndex == predicate.attIndex && this.attValue == predicate.attValue
+				&& this.operator == predicate.operator);
+	}
+
+	public boolean isUsingSameAttribute(NumericAttributeBinaryRulePredicate predicate) {
+		return (this.attIndex == predicate.attIndex && this.operator == predicate.operator);
+	}
+
+	public boolean isIncludedInRuleNode(NumericAttributeBinaryRulePredicate predicate) {
+		boolean ret;
+		if (this.operator == 1) { // <=
+			ret = (predicate.attValue <= this.attValue);
+		} else { // >
+			ret = (predicate.attValue > this.attValue);
+		}
+
+		return ret;
+	}
+
+	public void setAttributeValue(NumericAttributeBinaryRulePredicate ruleSplitNodeTest) {
+		this.attValue = ruleSplitNodeTest.attValue;
+
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		String compareChar = (operator == 0) ? "=" : (operator == 1) ? "<=" : ">";
+		StringUtils.appendIndented(sb, indent + 1, "In" + attIndex + compareChar + attValue);
+	}
+
+	@Override
+	public String toString() {
+		StringBuilder sb = new StringBuilder();
+		getDescription(sb, 0);
+		return sb.toString();
+	}
+
+	@Override
+	public int getAttributeIndex() {
+		return attIndex;
+	}
+
+	@Override
+	public boolean isEqualOrLess() {
+		return state;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent, InstancesHeader header) {
+		String compareChar = (operator == 0) ? "=" : (operator == 1) ? "<=" : ">";
+		StringUtils.appendIndented(sb, indent,
+				InstancesHeader.getAttributeNameString(header, attIndex) + compareChar + attValue);
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/rules/core/splitcriteria/AMRulesSplitCriterion.java b/moa/src/main/java/moa/learners/predictors/rules/core/splitcriteria/AMRulesSplitCriterion.java
new file mode 100644
index 000000000..ef4bf033b
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/splitcriteria/AMRulesSplitCriterion.java
@@ -0,0 +1,14 @@
+package moa.learners.predictors.rules.core.splitcriteria;
+
+import moa.learners.predictors.core.splitcriteria.SplitCriterion;
+
+public interface AMRulesSplitCriterion extends SplitCriterion {
+
+	double[] computeBranchSplitMerits(double[][] postSplitDists);
+
+	@Override
+	double getMeritOfSplit(double[] preSplitDist, double[][] postSplitDists);
+
+	@Override
+	double getRangeOfMerit(double[] preSplitDist);
+}
diff --git a/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/SDRSplitCriterionAMRules.java b/moa/src/main/java/moa/learners/predictors/rules/core/splitcriteria/SDRSplitCriterionAMRules.java
similarity index 71%
rename from moa/src/main/java/moa/classifiers/rules/core/splitcriteria/SDRSplitCriterionAMRules.java
rename to moa/src/main/java/moa/learners/predictors/rules/core/splitcriteria/SDRSplitCriterionAMRules.java
index b5fc4d1fa..d31895347 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/splitcriteria/SDRSplitCriterionAMRules.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/splitcriteria/SDRSplitCriterionAMRules.java
@@ -14,69 +14,61 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
-package moa.classifiers.rules.core.splitcriteria;
-
-import moa.classifiers.core.splitcriteria.SDRSplitCriterion;
+package moa.learners.predictors.rules.core.splitcriteria;
 
+import moa.learners.predictors.core.splitcriteria.SDRSplitCriterion;
 
 public class SDRSplitCriterionAMRules extends SDRSplitCriterion implements AMRulesSplitCriterion {
 
 	private static final long serialVersionUID = 1L;
 
-
 	@Override
 	public double getMeritOfSplit(double[] preSplitDist, double[][] postSplitDists) {
-		double SDR=0.0;
+		double SDR = 0.0;
 		double N = preSplitDist[0];
-		int count = 0; 
+		int count = 0;
 
-		for(int i = 0; i < postSplitDists.length; i++)
-		{
+		for (int i = 0; i < postSplitDists.length; i++) {
 			double Ni = postSplitDists[i][0];
-			if(Ni >=0.05*preSplitDist[0]){
-				count = count +1;
+			if (Ni >= 0.05 * preSplitDist[0]) {
+				count = count + 1;
 			}
 		}
-		if(count == postSplitDists.length){
+		if (count == postSplitDists.length) {
 			SDR = computeSD(preSplitDist);
 
-			for(int i = 0; i < postSplitDists.length; i++)
-			{
+			for (int i = 0; i < postSplitDists.length; i++) {
 				double Ni = postSplitDists[i][0];
-				SDR -= (Ni/N)*computeSD(postSplitDists[i]);
+				SDR -= (Ni / N) * computeSD(postSplitDists[i]);
 
 			}
 		}
 		return SDR;
 	}
 
-
-
 	@Override
 	public double getRangeOfMerit(double[] preSplitDist) {
 		return 1;
 	}
 
+	@Override
 	public double[] computeBranchSplitMerits(double[][] postSplitDists) {
 		double[] SDR = new double[postSplitDists.length];
 		double N = 0;
 
-		for(int i = 0; i < postSplitDists.length; i++)
-		{
+		for (int i = 0; i < postSplitDists.length; i++) {
 			double Ni = postSplitDists[i][0];
 			N += Ni;
 		}
-		for(int i = 0; i < postSplitDists.length; i++)
-		{
+		for (int i = 0; i < postSplitDists.length; i++) {
 			double Ni = postSplitDists[i][0];
-			SDR[i] = (Ni/N)*computeSD(postSplitDists[i]);
+			SDR[i] = (Ni / N) * computeSD(postSplitDists[i]);
 		}
 		return SDR;
 
 	}
 
-
 }
diff --git a/moa/src/main/java/moa/learners/predictors/rules/core/splitcriteria/SDRSplitCriterionAMRulesNode.java b/moa/src/main/java/moa/learners/predictors/rules/core/splitcriteria/SDRSplitCriterionAMRulesNode.java
new file mode 100644
index 000000000..0a05a1035
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/splitcriteria/SDRSplitCriterionAMRulesNode.java
@@ -0,0 +1,64 @@
+/*
+ *    SDRSplitCriterionAMRulesNode.java
+ *    Copyright (C) 2014 University of Porto, Portugal
+ *    @author A. Bifet, J. Duarte, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.predictors.rules.core.splitcriteria;
+
+public class SDRSplitCriterionAMRulesNode extends SDRSplitCriterionAMRules implements AMRulesSplitCriterion {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public double getMeritOfSplit(double[] preSplitDist, double[][] postSplitDists) {
+		double SDR = 0.0;
+		int count = 0;
+
+		for (int i = 0; i < postSplitDists.length; i++) {
+			double Ni = postSplitDists[i][0];
+			if (Ni >= 0.05 * preSplitDist[0]) {
+				count = count + 1;
+			}
+		}
+		if (count == postSplitDists.length) {
+			SDR = computeSD(preSplitDist);
+			double min = Double.MAX_VALUE;
+			for (int i = 0; i < postSplitDists.length; i++) {
+				double val = computeSD(postSplitDists[i]);
+				if (val < min)
+					min = val;
+			}
+			SDR -= min;
+		}
+		return SDR;
+	}
+
+	@Override
+	public double[] computeBranchSplitMerits(double[][] postSplitDists) {
+		double[] SDR = new double[postSplitDists.length];
+		for (int i = 0; i < postSplitDists.length; i++)
+			SDR[i] = computeSD(postSplitDists[i]);
+		return SDR;
+
+	}
+
+	@Override
+	public double getRangeOfMerit(double[] preSplitDist) {
+		return 1;
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/rules/core/splitcriteria/VRSplitCriterion.java b/moa/src/main/java/moa/learners/predictors/rules/core/splitcriteria/VRSplitCriterion.java
new file mode 100644
index 000000000..66d474dbd
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/splitcriteria/VRSplitCriterion.java
@@ -0,0 +1,49 @@
+package moa.learners.predictors.rules.core.splitcriteria;
+
+import moa.learners.predictors.core.splitcriteria.VarianceReductionSplitCriterion;
+
+public class VRSplitCriterion extends VarianceReductionSplitCriterion implements AMRulesSplitCriterion {
+
+	private static final long serialVersionUID = -1066043659710778883L;
+
+	@Override
+	public double[] computeBranchSplitMerits(double[][] postSplitDists) {
+		double[] SDR = new double[postSplitDists.length];
+		double N = 0;
+
+		for (int i = 0; i < postSplitDists.length; i++) {
+			double Ni = postSplitDists[i][0];
+			N += Ni;
+		}
+		for (int i = 0; i < postSplitDists.length; i++) {
+			double Ni = postSplitDists[i][0];
+			SDR[i] = (Ni / N) * computeSD(postSplitDists[i]);
+		}
+		return SDR;
+
+	}
+
+	@Override
+	public double getMeritOfSplit(double[] preSplitDist, double[][] postSplitDists) {
+		double SDR = 0.0;
+		double N = preSplitDist[0];
+		int count = 0;
+
+		for (int i = 0; i < postSplitDists.length; i++) {
+			double Ni = postSplitDists[i][0];
+			if (Ni >= 0.05 * N) {
+				count = count + 1;
+			}
+		}
+
+		if (count == postSplitDists.length) {
+			SDR = computeSD(preSplitDist);
+			for (int i = 0; i < postSplitDists.length; i++) {
+				double Ni = postSplitDists[i][0];
+				SDR -= (Ni / N) * computeSD(postSplitDists[i]);
+			}
+		}
+		return SDR;
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/rules/core/splitcriteria/VarianceRatioSplitCriterion.java b/moa/src/main/java/moa/learners/predictors/rules/core/splitcriteria/VarianceRatioSplitCriterion.java
new file mode 100644
index 000000000..7c2da4848
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/splitcriteria/VarianceRatioSplitCriterion.java
@@ -0,0 +1,73 @@
+package moa.learners.predictors.rules.core.splitcriteria;
+
+import moa.core.ObjectRepository;
+import moa.learners.predictors.core.splitcriteria.VarianceReductionSplitCriterion;
+import moa.options.AbstractOptionHandler;
+import moa.tasks.TaskMonitor;
+
+public class VarianceRatioSplitCriterion extends AbstractOptionHandler implements AMRulesSplitCriterion {
+
+	private static final long serialVersionUID = -1066043659710778883L;
+
+	@Override
+	public double[] computeBranchSplitMerits(double[][] postSplitDists) {
+		double[] SDR = new double[postSplitDists.length];
+		double N = 0;
+
+		for (int i = 0; i < postSplitDists.length; i++) {
+			double Ni = postSplitDists[i][0];
+			N += Ni;
+		}
+		for (int i = 0; i < postSplitDists.length; i++) {
+			double Ni = postSplitDists[i][0];
+			// SDR[i] = Ni/N*VarianceReductionSplitCriterion.computeSD(postSplitDists[i]);
+			SDR[i] = VarianceReductionSplitCriterion.computeSD(postSplitDists[i]);
+		}
+		return SDR;
+
+	}
+
+	@Override
+	public double getMeritOfSplit(double[] preSplitDist, double[][] postSplitDists) {
+
+		double N = preSplitDist[0];
+		int count = 0;
+
+		for (int i = 0; i < postSplitDists.length; i++) {
+			double Ni = postSplitDists[i][0];
+			if (Ni >= 0.05 * preSplitDist[0]) {
+				count = count + 1;
+			}
+		}
+
+		if (count == postSplitDists.length) {
+			double SDR = VarianceReductionSplitCriterion.computeSD(preSplitDist);
+			double sumPostSDR = 0;
+			for (int i = 0; i < postSplitDists.length; i++) {
+				double Ni = postSplitDists[i][0];
+				sumPostSDR += (Ni / N) * VarianceReductionSplitCriterion.computeSD(postSplitDists[i]);
+				// sumPostSDR += VarianceReductionSplitCriterion.computeSD(postSplitDists[i]);
+			}
+			// SDR=1-(sumPostSDR)/SDR;
+			return (1 - (sumPostSDR / postSplitDists.length) / SDR);
+		} else
+			return -Double.MAX_VALUE;
+
+	}
+
+	@Override
+	public double getRangeOfMerit(double[] preSplitDist) {
+		return 1;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+
+	}
+
+}
diff --git a/moa/src/main/java/moa/classifiers/rules/core/voting/AbstractErrorWeightedVote.java b/moa/src/main/java/moa/learners/predictors/rules/core/voting/AbstractErrorWeightedVote.java
similarity index 73%
rename from moa/src/main/java/moa/classifiers/rules/core/voting/AbstractErrorWeightedVote.java
rename to moa/src/main/java/moa/learners/predictors/rules/core/voting/AbstractErrorWeightedVote.java
index 98ce19126..53fa3bc7d 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/voting/AbstractErrorWeightedVote.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/voting/AbstractErrorWeightedVote.java
@@ -14,11 +14,11 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.classifiers.rules.core.voting;
+package moa.learners.predictors.rules.core.voting;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -26,56 +26,49 @@
 import moa.AbstractMOAObject;
 
 /**
- * AbstractErrorWeightedVote class for weighted votes based on estimates of errors. 
+ * AbstractErrorWeightedVote class for weighted votes based on estimates of
+ * errors.
  *
  * @author João Duarte (jmduarte@inescporto.pt)
  * @version $Revision: 1 $
  */
-public abstract class AbstractErrorWeightedVote extends AbstractMOAObject implements ErrorWeightedVote{
+public abstract class AbstractErrorWeightedVote extends AbstractMOAObject implements ErrorWeightedVote {
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = -7340491298217227675L;
 	protected List<double[]> votes;
 	protected List<Double> errors;
 	protected double[] weights;
-	
-	
 
 	public AbstractErrorWeightedVote() {
 		super();
-		votes = new ArrayList<double[]>();
-		errors = new ArrayList<Double>();
+		votes = new ArrayList<>();
+		errors = new ArrayList<>();
 	}
 
-
 	@Override
-	public void addVote(double [] vote, double error) {
+	public void addVote(double[] vote, double error) {
 		votes.add(vote);
 		errors.add(error);
 	}
 
-
 	@Override
 	abstract public double[] computeWeightedVote();
 
 	@Override
-	public double getWeightedError()
-	{
-		double weightedError=0;
-		if (weights!=null && weights.length==errors.size())
-		{
-			for (int i=0; i<weights.length; ++i)
-				weightedError+=errors.get(i)*weights[i];
-		}
-		else
-			weightedError=-1;
+	public double getWeightedError() {
+		double weightedError = 0;
+		if (weights != null && weights.length == errors.size()) {
+			for (int i = 0; i < weights.length; ++i)
+				weightedError += errors.get(i) * weights[i];
+		} else
+			weightedError = -1;
 		return weightedError;
 	}
-	
-	
+
 	@Override
-	public double [] getWeights() {
+	public double[] getWeights() {
 		return weights;
 	}
 
@@ -83,5 +76,5 @@ public double getWeightedError()
 	public int getNumberVotes() {
 		return votes.size();
 	}
-	
+
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/core/voting/ErrorWeightedVote.java b/moa/src/main/java/moa/learners/predictors/rules/core/voting/ErrorWeightedVote.java
similarity index 62%
rename from moa/src/main/java/moa/classifiers/rules/core/voting/ErrorWeightedVote.java
rename to moa/src/main/java/moa/learners/predictors/rules/core/voting/ErrorWeightedVote.java
index 1f3ac7ff9..8145485d0 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/voting/ErrorWeightedVote.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/voting/ErrorWeightedVote.java
@@ -14,66 +14,65 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.classifiers.rules.core.voting;
+package moa.learners.predictors.rules.core.voting;
 
 import moa.MOAObject;
 
 /**
- * ErrorWeightedVote interface for weighted votes based on estimates of errors. 
+ * ErrorWeightedVote interface for weighted votes based on estimates of errors.
  *
  * @author João Duarte (jmduarte@inescporto.pt)
  * @version $Revision: 1 $
  */
 public interface ErrorWeightedVote {
-	
+
 	/**
-	 * Adds a vote and the corresponding error for the computation of the weighted vote and respective weighted error.
-	 * 
-	 * @param  vote a vote returned by a classifier
-	 * @param  error the error associated to the vote
+	 * Adds a vote and the corresponding error for the computation of the weighted
+	 * vote and respective weighted error.
+	 *
+	 * @param vote  a vote returned by a classifier
+	 * @param error the error associated to the vote
 	 */
-	public void addVote(double [] vote, double error);
-	
+	void addVote(double[] vote, double error);
+
 	/**
-	 * Computes the weighted vote.
-	 * Also updates the weights of the votes.
-	 * 
-	 * @return      the weighted vote
+	 * Computes the weighted vote. Also updates the weights of the votes.
+	 *
+	 * @return the weighted vote
 	 */
-	public double [] computeWeightedVote();
-	
+	double[] computeWeightedVote();
+
 	/**
 	 * Returns the weighted error.
-	 * 
+	 *
 	 * @pre computeWeightedVote()
-	 * @return      the weighted error
+	 * @return the weighted error
 	 */
-	public double getWeightedError();
-	
+	double getWeightedError();
+
 	/**
 	 * Return the weights error.
-	 * 
+	 *
 	 * @pre computeWeightedVote()
-	 * @return      the weights
+	 * @return the weights
 	 */
-	public double []  getWeights();
-	
-	
+	double[] getWeights();
+
 	/**
 	 * The number of votes added so far.
-	 * 
-	 * @return      the number of votes
+	 *
+	 * @return the number of votes
 	 */
-	public int getNumberVotes();
-	
+	int getNumberVotes();
+
 	/**
 	 * Creates a copy of the object
-	 * 
-	 * @return      copy of the object
+	 *
+	 * @return copy of the object
 	 */
-	public MOAObject copy();
+	MOAObject copy();
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/core/voting/ExpNegErrorWeightedVote.java b/moa/src/main/java/moa/learners/predictors/rules/core/voting/ExpNegErrorWeightedVote.java
similarity index 58%
rename from moa/src/main/java/moa/classifiers/rules/core/voting/ExpNegErrorWeightedVote.java
rename to moa/src/main/java/moa/learners/predictors/rules/core/voting/ExpNegErrorWeightedVote.java
index 7257cc38e..663425059 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/voting/ExpNegErrorWeightedVote.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/voting/ExpNegErrorWeightedVote.java
@@ -14,13 +14,14 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
-package moa.classifiers.rules.core.voting;
+package moa.learners.predictors.rules.core.voting;
 
 /**
- * ExpNegErrorWeightedVote class for weighted votes based on estimates of errors. 
+ * ExpNegErrorWeightedVote class for weighted votes based on estimates of
+ * errors.
  *
  * @author João Duarte (jmduarte@inescporto.pt)
  * @version $Revision: 1 $
@@ -28,48 +29,45 @@
 public class ExpNegErrorWeightedVote extends AbstractErrorWeightedVote {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 6359349250620616482L;
 
 	@Override
 	public double[] computeWeightedVote() {
-		int n=votes.size();
-		weights=new double[n];
-		double [] weightedVote=null;
-		if (n>0){
-			int d=votes.get(0).length;
-			weightedVote=new double[d];
-			double sumError=0;
-			//weights are 1/(error+eps)
-			for (int i=0; i<n; ++i){
-				weights[i]=Math.exp(-errors.get(i));
-				sumError+=weights[i];	
-			}
-			
-			if(sumError>0)
-			for (int i=0; i<n; ++i)
-			{
-				//normalize so that weights sum 1
-				weights[i]/=sumError;
-				//compute weighted vote
-				for(int j=0; j<d; j++)
-					weightedVote[j]+=votes.get(i)[j]*weights[i];
+		int n = votes.size();
+		weights = new double[n];
+		double[] weightedVote = null;
+		if (n > 0) {
+			int d = votes.get(0).length;
+			weightedVote = new double[d];
+			double sumError = 0;
+			// weights are 1/(error+eps)
+			for (int i = 0; i < n; ++i) {
+				weights[i] = Math.exp(-errors.get(i));
+				sumError += weights[i];
 			}
-			//Only occurs if all errors=Double.MAX_VALUE
-			else
-			{
-				//compute arithmetic vote
-				for (int i=0; i<n; ++i)
-				{
-					for(int j=0; j<d; j++)
-						weightedVote[j]+=votes.get(i)[j]/n;
+
+			if (sumError > 0)
+				for (int i = 0; i < n; ++i) {
+					// normalize so that weights sum 1
+					weights[i] /= sumError;
+					// compute weighted vote
+					for (int j = 0; j < d; j++)
+						weightedVote[j] += votes.get(i)[j] * weights[i];
+				}
+			// Only occurs if all errors=Double.MAX_VALUE
+			else {
+				// compute arithmetic vote
+				for (int i = 0; i < n; ++i) {
+					for (int j = 0; j < d; j++)
+						weightedVote[j] += votes.get(i)[j] / n;
 				}
 			}
 		}
 		return weightedVote;
 	}
-	
+
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
 		// TODO Auto-generated method stub
diff --git a/moa/src/main/java/moa/classifiers/rules/core/voting/InverseErrorWeightedVote.java b/moa/src/main/java/moa/learners/predictors/rules/core/voting/InverseErrorWeightedVote.java
similarity index 54%
rename from moa/src/main/java/moa/classifiers/rules/core/voting/InverseErrorWeightedVote.java
rename to moa/src/main/java/moa/learners/predictors/rules/core/voting/InverseErrorWeightedVote.java
index 3ed396971..08e53c4c4 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/voting/InverseErrorWeightedVote.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/voting/InverseErrorWeightedVote.java
@@ -14,13 +14,14 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
-package moa.classifiers.rules.core.voting;
+package moa.learners.predictors.rules.core.voting;
 
 /**
- * InverseErrorWeightedVoteMultiLabel class for weighted votes based on estimates of errors. 
+ * InverseErrorWeightedVoteMultiLabel class for weighted votes based on
+ * estimates of errors.
  *
  * @author João Duarte (jmduarte@inescporto.pt)
  * @version $Revision: 1 $
@@ -28,54 +29,50 @@
 public class InverseErrorWeightedVote extends AbstractErrorWeightedVote {
 
 	/**
-	 * 
+	 *
 	 */
-	private static final double EPS = 0.000000001; //just to prevent divide by 0 in 1/X -> 1/(x+EPS)
+	private static final double EPS = 0.000000001; // just to prevent divide by 0 in 1/X -> 1/(x+EPS)
 	private static final long serialVersionUID = 6359349250620616482L;
 
 	@Override
 	public double[] computeWeightedVote() {
-		int n=votes.size();
-		weights=new double[n];
-		double [] weightedVote=null;
-		if (n>0){
-			int d=votes.get(0).length;
-			weightedVote=new double[d];
-			double sumError=0;
-			//weights are 1/(error+eps)
-			for (int i=0; i<n; ++i){
-				if(errors.get(i)<Double.MAX_VALUE){
-					weights[i]=1.0/(errors.get(i)+EPS);
-					sumError+=weights[i];
-				}
-				else
-					weights[i]=0;
-					
-			}
-			
-			if(sumError>0)
-			for (int i=0; i<n; ++i)
-			{
-				//normalize so that weights sum 1
-				weights[i]/=sumError;
-				//compute weighted vote
-				for(int j=0; j<d; j++)
-					weightedVote[j]+=votes.get(i)[j]*weights[i];
+		int n = votes.size();
+		weights = new double[n];
+		double[] weightedVote = null;
+		if (n > 0) {
+			int d = votes.get(0).length;
+			weightedVote = new double[d];
+			double sumError = 0;
+			// weights are 1/(error+eps)
+			for (int i = 0; i < n; ++i) {
+				if (errors.get(i) < Double.MAX_VALUE) {
+					weights[i] = 1.0 / (errors.get(i) + EPS);
+					sumError += weights[i];
+				} else
+					weights[i] = 0;
+
 			}
-			//Only occurs if all errors=Double.MAX_VALUE
-			else
-			{
-				//compute arithmetic vote
-				for (int i=0; i<n; ++i)
-				{
-					for(int j=0; j<d; j++)
-						weightedVote[j]+=votes.get(i)[j]/n;
+
+			if (sumError > 0)
+				for (int i = 0; i < n; ++i) {
+					// normalize so that weights sum 1
+					weights[i] /= sumError;
+					// compute weighted vote
+					for (int j = 0; j < d; j++)
+						weightedVote[j] += votes.get(i)[j] * weights[i];
+				}
+			// Only occurs if all errors=Double.MAX_VALUE
+			else {
+				// compute arithmetic vote
+				for (int i = 0; i < n; ++i) {
+					for (int j = 0; j < d; j++)
+						weightedVote[j] += votes.get(i)[j] / n;
 				}
 			}
 		}
 		return weightedVote;
 	}
-	
+
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
 		// TODO Auto-generated method stub
diff --git a/moa/src/main/java/moa/classifiers/rules/core/voting/MinErrorWeightedVote.java b/moa/src/main/java/moa/learners/predictors/rules/core/voting/MinErrorWeightedVote.java
similarity index 71%
rename from moa/src/main/java/moa/classifiers/rules/core/voting/MinErrorWeightedVote.java
rename to moa/src/main/java/moa/learners/predictors/rules/core/voting/MinErrorWeightedVote.java
index a2db2db1e..5bb3effc9 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/voting/MinErrorWeightedVote.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/voting/MinErrorWeightedVote.java
@@ -14,13 +14,13 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
-package moa.classifiers.rules.core.voting;
+package moa.learners.predictors.rules.core.voting;
 
 /**
- * MinErrorWeightedVote class for weighted votes based on estimates of errors. 
+ * MinErrorWeightedVote class for weighted votes based on estimates of errors.
  *
  * @author João Duarte (jmduarte@inescporto.pt)
  * @version $Revision: 1 $
@@ -28,36 +28,35 @@
 public class MinErrorWeightedVote extends AbstractErrorWeightedVote {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = -205142097727766386L;
 
 	@Override
 	public double[] computeWeightedVote() {
-		int n=votes.size();
-		int min=0;
+		int n = votes.size();
+		int min = 0;
 
-		double [] weightedVote = null;
-		double minError=Double.MAX_VALUE;
-		
-		if (n>0){
-			int d=votes.get(0).length;
-			weightedVote=new double[d];	
-			for (int i=0; i<n; i++)
-			{
-				if(errors.get(i)<minError) {
-					minError=errors.get(i);
-					min=i;
+		double[] weightedVote = null;
+		double minError = Double.MAX_VALUE;
+
+		if (n > 0) {
+			int d = votes.get(0).length;
+			weightedVote = new double[d];
+			for (int i = 0; i < n; i++) {
+				if (errors.get(i) < minError) {
+					minError = errors.get(i);
+					min = i;
 				}
 			}
-			weights=new double[n];
-			weights[min]=1.0;
-			weightedVote=votes.get(min);
+			weights = new double[n];
+			weights[min] = 1.0;
+			weightedVote = votes.get(min);
 		}
 
 		return weightedVote;
 	}
-	
+
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
 
diff --git a/moa/src/main/java/moa/classifiers/rules/core/voting/OneMinusErrorWeightedVote.java b/moa/src/main/java/moa/learners/predictors/rules/core/voting/OneMinusErrorWeightedVote.java
similarity index 62%
rename from moa/src/main/java/moa/classifiers/rules/core/voting/OneMinusErrorWeightedVote.java
rename to moa/src/main/java/moa/learners/predictors/rules/core/voting/OneMinusErrorWeightedVote.java
index 1bf95eb4a..b5b121dbe 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/voting/OneMinusErrorWeightedVote.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/voting/OneMinusErrorWeightedVote.java
@@ -14,46 +14,45 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.classifiers.rules.core.voting;
+package moa.learners.predictors.rules.core.voting;
 
 public class OneMinusErrorWeightedVote extends AbstractErrorWeightedVote {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 920127665512056969L;
 
 	@Override
 	public double[] computeWeightedVote() {
-		int n=votes.size();
-		weights=new double[n];
-		double [] weightedVote=null;
-		if (n>0){
-			int d=votes.get(0).length;
-			weightedVote=new double[d];
-			double sumError=0;
-			//weights are 1-error (assumes error in [0-1])
-			for (int i=0; i<n; ++i){
-				weights[i]=1-errors.get(i);
-				sumError+=weights[i];
+		int n = votes.size();
+		weights = new double[n];
+		double[] weightedVote = null;
+		if (n > 0) {
+			int d = votes.get(0).length;
+			weightedVote = new double[d];
+			double sumError = 0;
+			// weights are 1-error (assumes error in [0-1])
+			for (int i = 0; i < n; ++i) {
+				weights[i] = 1 - errors.get(i);
+				sumError += weights[i];
 			}
-			
-			for (int i=0; i<n; ++i)
-			{
-				//normalize so that weights sum 1
-				weights[i]/=sumError;
-				//compute weighted vote
-				for(int j=0; j<d; j++)
-					weightedVote[j]+=votes.get(i)[j]*weights[i];
+
+			for (int i = 0; i < n; ++i) {
+				// normalize so that weights sum 1
+				weights[i] /= sumError;
+				// compute weighted vote
+				for (int j = 0; j < d; j++)
+					weightedVote[j] += votes.get(i)[j] * weights[i];
 			}
 		}
 		return weightedVote;
 	}
-	
+
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
 
diff --git a/moa/src/main/java/moa/classifiers/rules/core/voting/UniformWeightedVote.java b/moa/src/main/java/moa/learners/predictors/rules/core/voting/UniformWeightedVote.java
similarity index 75%
rename from moa/src/main/java/moa/classifiers/rules/core/voting/UniformWeightedVote.java
rename to moa/src/main/java/moa/learners/predictors/rules/core/voting/UniformWeightedVote.java
index 25cced870..8e1762803 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/voting/UniformWeightedVote.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/voting/UniformWeightedVote.java
@@ -14,43 +14,40 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.classifiers.rules.core.voting;
-
+package moa.learners.predictors.rules.core.voting;
 
 /**
- * UniformWeightedVote class for weighted votes based on estimates of errors. 
+ * UniformWeightedVote class for weighted votes based on estimates of errors.
  *
  * @author João Duarte (jmduarte@inescporto.pt)
  * @version $Revision: 1 $
  */
 public class UniformWeightedVote extends AbstractErrorWeightedVote {
 
-
 	private static final long serialVersionUID = 6359349250620616482L;
 
 	@Override
 	public double[] computeWeightedVote() {
-		int n=votes.size();
-		weights=new double[n];
-		double [] weightedVote=null;
-		if (n>0){
-			int d=votes.get(0).length;
-			weightedVote=new double[d];					
-			for (int i=0; i<n; i++)
-			{
-				weights[i]=1.0/n;
-				for(int j=0; j<d; j++)
-					weightedVote[j]+=(votes.get(i)[j]*weights[i]);
+		int n = votes.size();
+		weights = new double[n];
+		double[] weightedVote = null;
+		if (n > 0) {
+			int d = votes.get(0).length;
+			weightedVote = new double[d];
+			for (int i = 0; i < n; i++) {
+				weights[i] = 1.0 / n;
+				for (int j = 0; j < d; j++)
+					weightedVote[j] += (votes.get(i)[j] * weights[i]);
 			}
-			
+
 		}
 		return weightedVote;
 	}
-	
+
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
 		// TODO Auto-generated method stub
diff --git a/moa/src/main/java/moa/classifiers/rules/core/voting/Vote.java b/moa/src/main/java/moa/learners/predictors/rules/core/voting/Vote.java
similarity index 74%
rename from moa/src/main/java/moa/classifiers/rules/core/voting/Vote.java
rename to moa/src/main/java/moa/learners/predictors/rules/core/voting/Vote.java
index aef29b547..963dd1500 100644
--- a/moa/src/main/java/moa/classifiers/rules/core/voting/Vote.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/core/voting/Vote.java
@@ -14,58 +14,55 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.classifiers.rules.core.voting;
+package moa.learners.predictors.rules.core.voting;
 
 /**
- * Vote class for weighted votes based on estimates of errors. 
+ * Vote class for weighted votes based on estimates of errors.
  *
  * @author João Duarte (jmduarte@inescporto.pt)
  * @version $Revision: 1 $
  */
 public class Vote {
-	double [] vote;
+	double[] vote;
 	double error;
-	
-	
+
 	public Vote(double[] vote, double error) {
 		super();
 		this.vote = vote;
 		this.error = error;
 	}
-	
+
 	public double[] getVote() {
 		return vote;
 	}
-	
+
 	public void setVote(double[] vote) {
 		this.vote = vote;
 	}
-	
+
 	public double getError() {
 		return error;
 	}
-	
+
 	public void setError(double error) {
 		this.error = error;
 	}
-	
-	public double sumVoteDistrib()
-	{
-		double sum=0;
-		for (int i=0; i<vote.length; ++i)
-			sum+=vote[i];
-		return sum;		
+
+	public double sumVoteDistrib() {
+		double sum = 0;
+		for (int i = 0; i < vote.length; ++i)
+			sum += vote[i];
+		return sum;
 	}
-	
-	public void normalize()
-	{
-		double sum=sumVoteDistrib();
-		for (int i=0; i<vote.length; ++i)
-			vote[i]/=sum;	
+
+	public void normalize() {
+		double sum = sumVoteDistrib();
+		for (int i = 0; i < vote.length; ++i)
+			vote[i] /= sum;
 	}
-	
+
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/driftdetection/PageHinkleyFading.java b/moa/src/main/java/moa/learners/predictors/rules/driftdetection/PageHinkleyFading.java
similarity index 56%
rename from moa/src/main/java/moa/classifiers/rules/driftdetection/PageHinkleyFading.java
rename to moa/src/main/java/moa/learners/predictors/rules/driftdetection/PageHinkleyFading.java
index 6061ec861..9fa4632f1 100644
--- a/moa/src/main/java/moa/classifiers/rules/driftdetection/PageHinkleyFading.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/driftdetection/PageHinkleyFading.java
@@ -14,48 +14,48 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
-package moa.classifiers.rules.driftdetection;
+package moa.learners.predictors.rules.driftdetection;
 
 public class PageHinkleyFading extends PageHinkleyTest {
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 7110953184708812339L;
-	private double fadingFactor=0.99;
-	
+	private double fadingFactor = 0.99;
+
 	public PageHinkleyFading(double threshold, double alpha) {
 		super(threshold, alpha);
 	}
+
 	protected double instancesSeen;
 
 	@Override
 	public void reset() {
 
 		super.reset();
-		this.instancesSeen=0;
-		
+		this.instancesSeen = 0;
+
 	}
 
 	@Override
 	public boolean update(double error) {
-		this.instancesSeen=1+fadingFactor*this.instancesSeen;
-        double absolutError = Math.abs(error);
-        
-        this.sumAbsolutError = fadingFactor*this.sumAbsolutError + absolutError;
-        if (this.instancesSeen > 30) {
-        	double mT = absolutError - (this.sumAbsolutError / this.instancesSeen) - this.alpha;
-        	this.cumulativeSum = this.cumulativeSum + mT; // Update the cumulative mT sum
-        	if (this.cumulativeSum < this.minimumValue) { // Update the minimum mT value if the new mT is smaller than the current minimum
-        		this.minimumValue = this.cumulativeSum;
-        	}
-        	return (((this.cumulativeSum - this.minimumValue) > this.threshold));
-        }
-        return false;
-	}
-
+		this.instancesSeen = 1 + fadingFactor * this.instancesSeen;
+		double absolutError = Math.abs(error);
 
+		this.sumAbsolutError = fadingFactor * this.sumAbsolutError + absolutError;
+		if (this.instancesSeen > 30) {
+			double mT = absolutError - (this.sumAbsolutError / this.instancesSeen) - this.alpha;
+			this.cumulativeSum = this.cumulativeSum + mT; // Update the cumulative mT sum
+			if (this.cumulativeSum < this.minimumValue) { // Update the minimum mT value if the new mT is smaller than
+															// the current minimum
+				this.minimumValue = this.cumulativeSum;
+			}
+			return (((this.cumulativeSum - this.minimumValue) > this.threshold));
+		}
+		return false;
+	}
 
 }
diff --git a/moa/src/main/java/moa/learners/predictors/rules/driftdetection/PageHinkleyTest.java b/moa/src/main/java/moa/learners/predictors/rules/driftdetection/PageHinkleyTest.java
new file mode 100644
index 000000000..513c0b0ef
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/rules/driftdetection/PageHinkleyTest.java
@@ -0,0 +1,74 @@
+/*
+ *    SDRSplitCriterionAMRules.java
+ *    Copyright (C) 2014 University of Porto, Portugal
+ *    @author A. Bifet, J. Duarte, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.predictors.rules.driftdetection;
+
+import java.io.Serializable;
+
+public class PageHinkleyTest implements Serializable {
+
+	private static final long serialVersionUID = 1L;
+	protected double cumulativeSum;
+
+	public double getCumulativeSum() {
+		return cumulativeSum;
+	}
+
+	public double getMinimumValue() {
+		return minimumValue;
+	}
+
+	protected double minimumValue;
+	protected double sumAbsolutError;
+	protected long phinstancesSeen;
+	protected double threshold;
+	protected double alpha;
+
+	public PageHinkleyTest(double threshold, double alpha) {
+		this.threshold = threshold;
+		this.alpha = alpha;
+		this.reset();
+	}
+
+	public void reset() {
+		this.cumulativeSum = 0.0;
+		this.minimumValue = Double.MAX_VALUE;
+		this.sumAbsolutError = 0.0;
+		this.phinstancesSeen = 0;
+	}
+
+	// Compute Page-Hinkley test
+	public boolean update(double error) {
+
+		this.phinstancesSeen++;
+		double absolutError = Math.abs(error);
+		this.sumAbsolutError = this.sumAbsolutError + absolutError;
+		if (this.phinstancesSeen > 30) {
+			double mT = absolutError - (this.sumAbsolutError / this.phinstancesSeen) - this.alpha;
+			this.cumulativeSum = this.cumulativeSum + mT; // Update the cumulative mT sum
+			if (this.cumulativeSum < this.minimumValue) { // Update the minimum mT value if the new mT is smaller than
+															// the current minimum
+				this.minimumValue = this.cumulativeSum;
+			}
+			return (((this.cumulativeSum - this.minimumValue) > this.threshold));
+		}
+		return false;
+	}
+
+}
diff --git a/moa/src/main/java/moa/classifiers/rules/errormeasurers/ErrorMeasurement.java b/moa/src/main/java/moa/learners/predictors/rules/errormeasurers/ErrorMeasurement.java
similarity index 75%
rename from moa/src/main/java/moa/classifiers/rules/errormeasurers/ErrorMeasurement.java
rename to moa/src/main/java/moa/learners/predictors/rules/errormeasurers/ErrorMeasurement.java
index 9811f5dda..f93f53d65 100644
--- a/moa/src/main/java/moa/classifiers/rules/errormeasurers/ErrorMeasurement.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/errormeasurers/ErrorMeasurement.java
@@ -18,7 +18,7 @@
  *
  */
 
-package moa.classifiers.rules.errormeasurers;
+package moa.learners.predictors.rules.errormeasurers;
 
 import com.github.javacliparser.FloatOption;
 import com.yahoo.labs.samoa.instances.Instance;
@@ -26,31 +26,30 @@
 import moa.AbstractMOAObject;
 
 /**
- * Computes error measures with a fading factor
- * fadingErrorFactorOption - Fading factor
+ * Computes error measures with a fading factor fadingErrorFactorOption - Fading
+ * factor
  */
 
-
-
 abstract public class ErrorMeasurement extends AbstractMOAObject {
-	
-	public FloatOption fadingErrorFactorOption = new FloatOption(
-			"fadingErrorFactor", 'e', 
+
+	public FloatOption fadingErrorFactorOption = new FloatOption("fadingErrorFactor", 'e',
 			"Fading factor for the error", 0.99, 0, 1);
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
-	
+
 	protected double fadingErrorFactor;
-	abstract public void addPrediction(double [] prediction, Instance inst);
-	
+
+	abstract public void addPrediction(double[] prediction, Instance inst);
+
 	abstract public double getCurrentError();
 
-	public ErrorMeasurement(){
-		fadingErrorFactor=fadingErrorFactorOption.getValue();
+	public ErrorMeasurement() {
+		fadingErrorFactor = fadingErrorFactorOption.getValue();
 	}
+
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
 		// TODO Auto-generated method stub
diff --git a/moa/src/main/java/moa/classifiers/rules/errormeasurers/MeanAbsoluteDeviation.java b/moa/src/main/java/moa/learners/predictors/rules/errormeasurers/MeanAbsoluteDeviation.java
similarity index 76%
rename from moa/src/main/java/moa/classifiers/rules/errormeasurers/MeanAbsoluteDeviation.java
rename to moa/src/main/java/moa/learners/predictors/rules/errormeasurers/MeanAbsoluteDeviation.java
index c57055f8b..814862053 100644
--- a/moa/src/main/java/moa/classifiers/rules/errormeasurers/MeanAbsoluteDeviation.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/errormeasurers/MeanAbsoluteDeviation.java
@@ -17,7 +17,7 @@
  *
  *
  */
-package moa.classifiers.rules.errormeasurers;
+package moa.learners.predictors.rules.errormeasurers;
 
 import com.yahoo.labs.samoa.instances.Instance;
 
@@ -27,25 +27,25 @@
 public class MeanAbsoluteDeviation extends ErrorMeasurement {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
-	
-	private double weightSeen=0;
-	private double sumError=0;
+
+	private double weightSeen = 0;
+	private double sumError = 0;
 
 	@Override
 	public double getCurrentError() {
-		if(weightSeen==0)
+		if (weightSeen == 0)
 			return Double.MAX_VALUE;
 		else
-			return sumError/weightSeen;
+			return sumError / weightSeen;
 	}
 
 	@Override
 	public void addPrediction(double[] prediction, Instance inst) {
-		sumError=Math.abs(prediction[0]-inst.classValue())*inst.weight()+fadingErrorFactor*sumError;
-		weightSeen=inst.weight()+fadingErrorFactor*weightSeen;
+		sumError = Math.abs(prediction[0] - inst.classValue()) * inst.weight() + fadingErrorFactor * sumError;
+		weightSeen = inst.weight() + fadingErrorFactor * weightSeen;
 	}
 
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/errormeasurers/RootMeanSquaredError.java b/moa/src/main/java/moa/learners/predictors/rules/errormeasurers/RootMeanSquaredError.java
similarity index 73%
rename from moa/src/main/java/moa/classifiers/rules/errormeasurers/RootMeanSquaredError.java
rename to moa/src/main/java/moa/learners/predictors/rules/errormeasurers/RootMeanSquaredError.java
index 110f23fa3..53779c3c0 100644
--- a/moa/src/main/java/moa/classifiers/rules/errormeasurers/RootMeanSquaredError.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/errormeasurers/RootMeanSquaredError.java
@@ -17,7 +17,7 @@
  *
  *
  */
-package moa.classifiers.rules.errormeasurers;
+package moa.learners.predictors.rules.errormeasurers;
 
 import com.yahoo.labs.samoa.instances.Instance;
 
@@ -25,34 +25,30 @@
  * Computes the Root Mean Squared Error for single target regression problems
  */
 
-
 public class RootMeanSquaredError extends ErrorMeasurement {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 
-	private double weightSeen=0;
-	private double sumSquaredError=0;
-	
+	private double weightSeen = 0;
+	private double sumSquaredError = 0;
 
 	@Override
 	public double getCurrentError() {
-		if(weightSeen==0)
+		if (weightSeen == 0)
 			return Double.MAX_VALUE;
 		else
-			return Math.sqrt(sumSquaredError/weightSeen);
+			return Math.sqrt(sumSquaredError / weightSeen);
 	}
 
 	@Override
 	public void addPrediction(double[] prediction, Instance inst) {
-		double error=(prediction[0]-inst.classValue());
-		sumSquaredError=error*error*inst.weight()+fadingErrorFactor*sumSquaredError;
-		weightSeen=inst.weight()+fadingErrorFactor*weightSeen;
-		
-	}
-
+		double error = (prediction[0] - inst.classValue());
+		sumSquaredError = error * error * inst.weight() + fadingErrorFactor * sumSquaredError;
+		weightSeen = inst.weight() + fadingErrorFactor * weightSeen;
 
+	}
 
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/functions/AMRulesClassifierFunction.java b/moa/src/main/java/moa/learners/predictors/rules/functions/AMRulesClassifierFunction.java
similarity index 94%
rename from moa/src/main/java/moa/classifiers/rules/functions/AMRulesClassifierFunction.java
rename to moa/src/main/java/moa/learners/predictors/rules/functions/AMRulesClassifierFunction.java
index e1f93f976..e00964c7b 100644
--- a/moa/src/main/java/moa/classifiers/rules/functions/AMRulesClassifierFunction.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/functions/AMRulesClassifierFunction.java
@@ -18,7 +18,7 @@
  *
  */
 
-package moa.classifiers.rules.functions;
+package moa.learners.predictors.rules.functions;
 
 public interface AMRulesClassifierFunction {
 
diff --git a/moa/src/main/java/moa/classifiers/rules/functions/AMRulesLearner.java b/moa/src/main/java/moa/learners/predictors/rules/functions/AMRulesLearner.java
similarity index 86%
rename from moa/src/main/java/moa/classifiers/rules/functions/AMRulesLearner.java
rename to moa/src/main/java/moa/learners/predictors/rules/functions/AMRulesLearner.java
index 10f398505..cdc29c495 100644
--- a/moa/src/main/java/moa/classifiers/rules/functions/AMRulesLearner.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/functions/AMRulesLearner.java
@@ -17,12 +17,12 @@
  *
  *
  */
-package moa.classifiers.rules.functions;
+package moa.learners.predictors.rules.functions;
 
-import moa.learners.InstanceLearner;
+import moa.learners.predictors.InstanceLearner;
 
 public interface AMRulesLearner extends InstanceLearner {
-	
-	public double getCurrentError();
+
+	double getCurrentError();
 
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/functions/AdaptiveNodePredictor.java b/moa/src/main/java/moa/learners/predictors/rules/functions/AdaptiveNodePredictor.java
similarity index 76%
rename from moa/src/main/java/moa/classifiers/rules/functions/AdaptiveNodePredictor.java
rename to moa/src/main/java/moa/learners/predictors/rules/functions/AdaptiveNodePredictor.java
index 922575236..3ec9333aa 100644
--- a/moa/src/main/java/moa/classifiers/rules/functions/AdaptiveNodePredictor.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/functions/AdaptiveNodePredictor.java
@@ -17,32 +17,31 @@
  *
  *
  */
-package moa.classifiers.rules.functions;
+package moa.learners.predictors.rules.functions;
 
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-import moa.classifiers.AbstractClassifier;
 import moa.core.Measurement;
+import moa.learners.predictors.AbstractClassifier;
 
 /*
  * Chooses between Perceptron and Target Mean make predictions
  * Selection is made according to the current error os each predictor
  */
-public class AdaptiveNodePredictor extends AbstractClassifier implements AMRulesRegressorFunction {
+public class AdaptiveNodePredictor extends AbstractClassifier {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 	protected Perceptron p;
 	protected TargetMean tm;
-	protected boolean hasStarted=false;
+	protected boolean hasStarted = false;
 
-	@Override
 	public double getCurrentError() {
-		if(p.getCurrentError()<tm.getCurrentError())
+		if (p.getCurrentError() < tm.getCurrentError())
 			return p.getCurrentError();
 		else
 			return tm.getCurrentError();
@@ -55,32 +54,31 @@ public boolean isRandomizable() {
 
 	@Override
 	public Prediction getPredictionForInstance(Instance inst) {
-		double [] ret=null;
-		if(hasStarted){
-			if(p.getCurrentError()<tm.getCurrentError())
-				ret=p.getPredictionForInstance(inst).asDoubleArray();
+		double[] ret = null;
+		if (hasStarted) {
+			if (p.getCurrentError() < tm.getCurrentError())
+				ret = p.getPredictionForInstance(inst).asDoubleArray();
 			else
-				ret=tm.getPredictionForInstance(inst).asDoubleArray();
-		}
-		else 
-			ret=new double[]{0};
+				ret = tm.getPredictionForInstance(inst).asDoubleArray();
+		} else
+			ret = new double[] { 0 };
 		return new ClassificationPrediction(ret);
-		
+
 	}
 
 	@Override
 	public void resetLearningImpl() {
-		hasStarted=false;
+		hasStarted = false;
 	}
 
 	@Override
 	public void trainOnInstanceImpl(Instance inst) {
-		if(!hasStarted){
-			p=new Perceptron();
-			tm=new TargetMean();
+		if (!hasStarted) {
+			p = new Perceptron();
+			tm = new TargetMean();
 			p.resetLearning();
 			tm.resetLearning();
-			hasStarted=true;
+			hasStarted = true;
 		}
 		p.trainOnInstance(inst);
 		tm.trainOnInstance(inst);
@@ -100,6 +98,5 @@ public void getModelDescription(StringBuilder out, int indent) {
 	public String getPurposeString() {
 		return "Returns the prediction of a perceptron or the target mean, according to the current mean absolute error.";
 	}
-	
 
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/functions/FadingTargetMean.java b/moa/src/main/java/moa/learners/predictors/rules/functions/FadingTargetMean.java
similarity index 78%
rename from moa/src/main/java/moa/classifiers/rules/functions/FadingTargetMean.java
rename to moa/src/main/java/moa/learners/predictors/rules/functions/FadingTargetMean.java
index d4d38f6a5..af5b2de0c 100644
--- a/moa/src/main/java/moa/classifiers/rules/functions/FadingTargetMean.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/functions/FadingTargetMean.java
@@ -14,46 +14,47 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
-package moa.classifiers.rules.functions;
+package moa.learners.predictors.rules.functions;
 
 import com.github.javacliparser.FloatOption;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 import com.yahoo.labs.samoa.instances.predictions.RegressionPrediction;
 
-public class FadingTargetMean extends TargetMean implements AMRulesRegressorFunction{
+public class FadingTargetMean extends TargetMean {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = -1383391769242905972L;
 
-	public FloatOption fadingFactorOption = new FloatOption(
-			"fadingFactor", 'f', 
+	public FloatOption fadingFactorOption = new FloatOption("fadingFactor", 'f',
 			"Fading factor for the FadingTargetMean accumulated error", 0.99, 0, 1);
 
 	private double nD;
 	private double fadingFactor;
+
 	@Override
 	public void trainOnInstanceImpl(Instance inst) {
 		updateAccumulatedError(inst);
-		nD=inst.weight()+fadingFactor*nD;
-		sum=inst.classValue()*inst.weight()+fadingFactor*sum;	
-	}	
+		nD = inst.weight() + fadingFactor * nD;
+		sum = inst.classValue() * inst.weight() + fadingFactor * sum;
+	}
+
 	@Override
 	public void resetLearningImpl() {
 		super.resetLearningImpl();
-		this.fadingFactor=fadingFactorOption.getValue();
+		this.fadingFactor = fadingFactorOption.getValue();
 	}
 
 	@Override
 	public Prediction getPredictionForInstance(Instance inst) {
 		double currentMean = 0;
-		if (nD>0)
-			currentMean = sum/nD;
+		if (nD > 0)
+			currentMean = sum / nD;
 		return new RegressionPrediction(currentMean);
 	}
 
diff --git a/moa/src/main/java/moa/classifiers/rules/functions/LowPassFilteredLearner.java b/moa/src/main/java/moa/learners/predictors/rules/functions/LowPassFilteredLearner.java
similarity index 68%
rename from moa/src/main/java/moa/classifiers/rules/functions/LowPassFilteredLearner.java
rename to moa/src/main/java/moa/learners/predictors/rules/functions/LowPassFilteredLearner.java
index 06ccae192..38254f8fd 100644
--- a/moa/src/main/java/moa/classifiers/rules/functions/LowPassFilteredLearner.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/functions/LowPassFilteredLearner.java
@@ -18,38 +18,39 @@
  *
  */
 
-package moa.classifiers.rules.functions;
+package moa.learners.predictors.rules.functions;
 
 import com.github.javacliparser.FloatOption;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-import moa.classifiers.AbstractClassifier;
 import moa.core.Measurement;
+import moa.learners.predictors.AbstractClassifier;
 import moa.options.ClassOption;
 
-public class LowPassFilteredLearner extends AbstractClassifier implements AMRulesRegressorFunction {
+public class LowPassFilteredLearner extends AbstractClassifier {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 
-	public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l',
-			"Base learner.", AbstractClassifier.class, AdaptiveNodePredictor.class.getName());
-	
-	public FloatOption alphaOption = new FloatOption("alpha", 'a',
-			"Alpha value. Y=Yold+alpha*(Yold+Prediction)",0.15, 0, 1);
-	
+	public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l', "Base learner.",
+			AbstractClassifier.class, AdaptiveNodePredictor.class.getName());
+
+	public FloatOption alphaOption = new FloatOption("alpha", 'a', "Alpha value. Y=Yold+alpha*(Yold+Prediction)", 0.15,
+			0, 1);
+
 	protected AbstractClassifier learner;
-	protected boolean hasStarted=false;
+	protected boolean hasStarted = false;
 	protected double lastX, lastY, alpha;
+
 	public LowPassFilteredLearner() {
-		
+
 	}
 
-	@Override
+	
 	public double getCurrentError() {
 		return 0;
 	}
@@ -61,35 +62,32 @@ public boolean isRandomizable() {
 
 	@Override
 	public Prediction getPredictionForInstance(Instance inst) {
-		return new ClassificationPrediction(new double[]{lastY});
+		return new ClassificationPrediction(new double[] { lastY });
 	}
 
 	@Override
 	public void resetLearningImpl() {
-		hasStarted=false;
-		if(learner!=null)
+		hasStarted = false;
+		if (learner != null)
 			learner.resetLearning();
-		
+
 	}
 
 	@Override
 	public void trainOnInstanceImpl(Instance inst) {
-		if(!hasStarted){
-			learner=(AbstractClassifier) getPreparedClassOption(this.baseLearnerOption);
-			hasStarted=true;
+		if (!hasStarted) {
+			learner = (AbstractClassifier) getPreparedClassOption(this.baseLearnerOption);
+			hasStarted = true;
 			learner.trainOnInstance(inst);
-			lastX=learner.getPredictionForInstance(inst).asDouble();
-			lastY=lastX;
-			alpha=alphaOption.getValue();
-		}
-		else{
+			lastX = learner.getPredictionForInstance(inst).asDouble();
+			lastY = lastX;
+			alpha = alphaOption.getValue();
+		} else {
 			learner.trainOnInstance(inst);
-			lastX=learner.getPredictionForInstance(inst).asDouble();
-			lastY=lastY+alpha*(lastX-lastY);
+			lastX = learner.getPredictionForInstance(inst).asDouble();
+			lastY = lastY + alpha * (lastX - lastY);
 		}
 
-		
-		
 	}
 
 	@Override
@@ -99,7 +97,6 @@ protected Measurement[] getModelMeasurementsImpl() {
 
 	@Override
 	public void getModelDescription(StringBuilder out, int indent) {
-		
 
 	}
 
@@ -107,6 +104,5 @@ public void getModelDescription(StringBuilder out, int indent) {
 	public String getPurposeString() {
 		return "Low pass filtered output (Y=Yold+alpha*(Yold+Prediction))";
 	}
-	
 
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/functions/Perceptron.java b/moa/src/main/java/moa/learners/predictors/rules/functions/Perceptron.java
similarity index 54%
rename from moa/src/main/java/moa/classifiers/rules/functions/Perceptron.java
rename to moa/src/main/java/moa/learners/predictors/rules/functions/Perceptron.java
index b3cdeb1d1..6b009d801 100644
--- a/moa/src/main/java/moa/classifiers/rules/functions/Perceptron.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/functions/Perceptron.java
@@ -14,48 +14,43 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
-package moa.classifiers.rules.functions;
+package moa.learners.predictors.rules.functions;
 
 import java.util.LinkedList;
 
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 import com.yahoo.labs.samoa.instances.predictions.RegressionPrediction;
 
-import moa.classifiers.AbstractRegressor;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
-import moa.learners.Classifier;
-import moa.learners.Regressor;
+import moa.learners.predictors.AbstractRegressor;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.Regressor;
 
-public class Perceptron extends AbstractRegressor implements AMRulesRegressorFunction, Regressor, Classifier {
+public class Perceptron extends AbstractRegressor implements Regressor {
 
-	private final double SD_THRESHOLD = 0.0000001; //THRESHOLD for normalizing attribute and target values
+	private final double SD_THRESHOLD = 0.0000001; // THRESHOLD for normalizing attribute and target values
 
 	private static final long serialVersionUID = 1L;
 
-	public FlagOption constantLearningRatioDecayOption = new FlagOption(
-			"learningRatio_Decay_set_constant", 'd',
+	public FlagOption constantLearningRatioDecayOption = new FlagOption("learningRatio_Decay_set_constant", 'd',
 			"Learning Ratio Decay in Perceptron set to be constant. (The next parameter).");
 
-	public FloatOption learningRatioOption = new FloatOption(
-			"learningRatio", 'l', 
+	public FloatOption learningRatioOption = new FloatOption("learningRatio", 'l',
 			"Constante Learning Ratio to use for training the Perceptrons in the leaves.", 0.025);
 
-	public FloatOption learningRateDecayOption = new FloatOption(
-			"learningRateDecay", 'm', 
+	public FloatOption learningRateDecayOption = new FloatOption("learningRateDecay", 'm',
 			" Learning Rate decay to use for training the Perceptron.", 0.001);
 
-	public FloatOption fadingFactorOption = new FloatOption(
-			"fadingFactor", 'e', 
+	public FloatOption fadingFactorOption = new FloatOption("fadingFactor", 'e',
 			"Fading factor for the Perceptron accumulated error", 0.99, 0, 1);
-	
+
 //	public IntOption randomSeedOption = new IntOption("randomSeed", 'r',
 //            "Seed for random behaviour of the classifier.", 1);
 
@@ -66,8 +61,8 @@ public class Perceptron extends AbstractRegressor implements AMRulesRegressorFun
 
 	protected double learningRateDecay;
 
-	// The Perception weights 
-	protected double[] weightAttribute; 
+	// The Perception weights
+	protected double[] weightAttribute;
 
 	// Statistics used for error calculations
 	public DoubleVector perceptronattributeStatistics = new DoubleVector();
@@ -79,19 +74,18 @@ public class Perceptron extends AbstractRegressor implements AMRulesRegressorFun
 
 	protected double accumulatedError;
 
-	// If the model  (weights) should be reset or not
-	protected boolean initialisePerceptron; 
+	// If the model (weights) should be reset or not
+	protected boolean initialisePerceptron;
 
 	protected double perceptronsumY;
 
 	protected double squaredperceptronsumY;
 
-	protected int [] numericAttributesIndex;
+	protected int[] numericAttributesIndex;
 
-	public Perceptron()
-	{
+	public Perceptron() {
 		super();
-		super.randomSeedOption=randomSeedOption;
+		super.randomSeedOption = randomSeedOption;
 		this.initialisePerceptron = true;
 	}
 
@@ -102,13 +96,13 @@ public Perceptron(Perceptron p) {
 		super();
 		this.constantLearningRatioDecayOption = p.constantLearningRatioDecayOption;
 		this.learningRatioOption = p.learningRatioOption;
-		this.learningRateDecayOption=p.learningRateDecayOption;
+		this.learningRateDecayOption = p.learningRateDecayOption;
 		this.fadingFactorOption = p.fadingFactorOption;
 		this.nError = p.nError;
 		this.fadingFactor = p.fadingFactor;
 		this.learningRatio = p.learningRatio;
 		this.learningRateDecay = p.learningRateDecay;
-		if (p.weightAttribute!=null)
+		if (p.weightAttribute != null)
 			this.weightAttribute = p.weightAttribute.clone();
 
 		this.perceptronattributeStatistics = new DoubleVector(p.perceptronattributeStatistics);
@@ -118,22 +112,18 @@ public Perceptron(Perceptron p) {
 		this.initialisePerceptron = p.initialisePerceptron;
 		this.perceptronsumY = p.perceptronsumY;
 		this.squaredperceptronsumY = p.squaredperceptronsumY;
-		this.perceptronYSeen=p.perceptronYSeen;
-		this.numericAttributesIndex=p.numericAttributesIndex.clone();
+		this.perceptronYSeen = p.perceptronYSeen;
+		this.numericAttributesIndex = p.numericAttributesIndex.clone();
 	}
 
-	public void setWeights(double[] w)
-	{
-		this.weightAttribute = w;	    
+	public void setWeights(double[] w) {
+		this.weightAttribute = w;
 	}
 
-	public double[] getWeights()
-	{
-		return this.weightAttribute;	    
+	public double[] getWeights() {
+		return this.weightAttribute;
 	}
 
-
-
 	public double getInstancesSeen() {
 		return perceptronInstancesSeen;
 	}
@@ -142,55 +132,57 @@ public void setInstancesSeen(int pInstancesSeen) {
 		this.perceptronInstancesSeen = pInstancesSeen;
 	}
 
-
 	/**
 	 * A method to reset the model
 	 */
+	@Override
 	public void resetLearningImpl() {
-		this.initialisePerceptron = true; 
-		this.reset(); 
+		this.initialisePerceptron = true;
+		this.reset();
 	}
 
-	public void reset(){
+	public void reset() {
 		this.classifierRandom.setSeed(this.randomSeed);
-		this.nError=0.0;
+		this.nError = 0.0;
 		this.accumulatedError = 0.0;
-		this.perceptronInstancesSeen = 0;	
+		this.perceptronInstancesSeen = 0;
 		this.perceptronattributeStatistics = new DoubleVector();
 		this.squaredperceptronattributeStatistics = new DoubleVector();
 		this.perceptronsumY = 0.0;
 		this.squaredperceptronsumY = 0.0;
-		this.perceptronYSeen=0;
+		this.perceptronYSeen = 0;
 	}
 
-	public void resetError(){
-		this.nError=0.0;
+	public void resetError() {
+		this.nError = 0.0;
 		this.accumulatedError = 0.0;
 	}
 
 	/**
 	 * Update the model using the provided instance
 	 */
+	@Override
 	public void trainOnInstanceImpl(Instance inst) {
-		accumulatedError= Math.abs(this.prediction(inst)-inst.classValue())*inst.weight() + fadingFactor*accumulatedError;
-		nError=inst.weight()+fadingFactor*nError;
-		// Initialise Perceptron if necessary   
+		accumulatedError = Math.abs(this.prediction(inst) - inst.classValue()) * inst.weight()
+				+ fadingFactor * accumulatedError;
+		nError = inst.weight() + fadingFactor * nError;
+		// Initialise Perceptron if necessary
 		if (this.initialisePerceptron == true) {
-			//Initialize numericAttributesIndex
-			LinkedList<Integer> numericIndices= new LinkedList<Integer>();
+			// Initialize numericAttributesIndex
+			LinkedList<Integer> numericIndices = new LinkedList<>();
 			for (int i = 0; i < inst.numAttributes(); i++)
-				if(inst.attribute(i).isNumeric() && i!=inst.classIndex())
+				if (inst.attribute(i).isNumeric() && i != inst.classIndex())
 					numericIndices.add(i);
-			numericAttributesIndex=new int[numericIndices.size()];
-			int j=0;
-			for(Integer index : numericIndices)
-				numericAttributesIndex[j++]=index;
+			numericAttributesIndex = new int[numericIndices.size()];
+			int j = 0;
+			for (Integer index : numericIndices)
+				numericAttributesIndex[j++] = index;
 
-			this.fadingFactor=this.fadingFactorOption.getValue();
+			this.fadingFactor = this.fadingFactorOption.getValue();
 			this.initialisePerceptron = false; // not in resetLearningImpl() because it needs Instance!
-			this.weightAttribute = new double[numericAttributesIndex.length+1];
-			for (int i = 0; i < numericAttributesIndex.length+1; i++) {
-				//if (inst.attribute(i).isNumeric())
+			this.weightAttribute = new double[numericAttributesIndex.length + 1];
+			for (int i = 0; i < numericAttributesIndex.length + 1; i++) {
+				// if (inst.attribute(i).isNumeric())
 				weightAttribute[i] = 2 * this.classifierRandom.nextDouble() - 1;
 			}
 			// Update Learning Rate
@@ -200,143 +192,140 @@ public void trainOnInstanceImpl(Instance inst) {
 		}
 
 		// Update attribute statistics
-		this.perceptronInstancesSeen+=inst.weight();
-		this.perceptronYSeen+=inst.weight();
-
+		this.perceptronInstancesSeen += inst.weight();
+		this.perceptronYSeen += inst.weight();
 
-		for(int j = 0; j < numericAttributesIndex.length; j++)
-		{
+		for (int j = 0; j < numericAttributesIndex.length; j++) {
 			int instAttIndex = modelAttIndexToInstanceAttIndex(numericAttributesIndex[j], inst);
-			double value=inst.value(instAttIndex);
-			perceptronattributeStatistics.addToValue(j, value*inst.weight());	
-			squaredperceptronattributeStatistics.addToValue(j, value*value*inst.weight());
+			double value = inst.value(instAttIndex);
+			perceptronattributeStatistics.addToValue(j, value * inst.weight());
+			squaredperceptronattributeStatistics.addToValue(j, value * value * inst.weight());
 		}
-		double value=inst.classValue();
-		this.perceptronsumY += value*inst.weight();
-		this.squaredperceptronsumY += value * value*inst.weight();
+		double value = inst.classValue();
+		this.perceptronsumY += value * inst.weight();
+		this.squaredperceptronsumY += value * value * inst.weight();
 
-		if(constantLearningRatioDecayOption.isSet()==false){
-			learningRatio = learningRatioOption.getValue() / (1+ perceptronInstancesSeen*learningRateDecay); 
+		if (constantLearningRatioDecayOption.isSet() == false) {
+			learningRatio = learningRatioOption.getValue() / (1 + perceptronInstancesSeen * learningRateDecay);
 		}
 
-		//double prediction = this.updateWeights(inst,learningRatio);
-		//accumulatedError= Math.abs(prediction-inst.classValue()) + fadingFactor*accumulatedError;
-
+		// double prediction = this.updateWeights(inst,learningRatio);
+		// accumulatedError= Math.abs(prediction-inst.classValue()) +
+		// fadingFactor*accumulatedError;
 
-		this.updateWeights(inst,learningRatio);
+		this.updateWeights(inst, learningRatio);
 
 	}
 
 	/**
 	 * Output the prediction made by this perceptron on the given instance
 	 */
-	private double prediction(Instance inst)
-	{
-		if(this.initialisePerceptron){
+	private double prediction(Instance inst) {
+		if (this.initialisePerceptron) {
 			return 0;
-		}else{
-			double[] normalizedInstance = normalizedInstance(inst); 
+		} else {
+			double[] normalizedInstance = normalizedInstance(inst);
 			double normalizedPrediction = prediction(normalizedInstance);
 			return denormalizedPrediction(normalizedPrediction);
 		}
 	}
 
-	public double normalizedPrediction(Instance inst)
-	{
-		double[] normalizedInstance = normalizedInstance(inst); 
+	public double normalizedPrediction(Instance inst) {
+		double[] normalizedInstance = normalizedInstance(inst);
 		double normalizedPrediction = prediction(normalizedInstance);
 		return normalizedPrediction;
 	}
 
 	private double denormalizedPrediction(double normalizedPrediction) {
-		if (this.initialisePerceptron==false){
+		if (this.initialisePerceptron == false) {
 			double meanY = perceptronsumY / perceptronYSeen;
 			double sdY = computeSD(squaredperceptronsumY, perceptronsumY, perceptronYSeen);
-			if (sdY > SD_THRESHOLD)	
+			if (sdY > SD_THRESHOLD)
 				return normalizedPrediction * sdY + meanY;
 			else
 				return normalizedPrediction + meanY;
-		}
-		else
-			return normalizedPrediction; //Perceptron may have been "reseted". Use old weights to predict
+		} else
+			return normalizedPrediction; // Perceptron may have been "reseted". Use old weights to predict
 
 	}
 
-	public double prediction(double[] instanceValues)
-	{
+	public double prediction(double[] instanceValues) {
 		double prediction = 0.0;
-		if(this.initialisePerceptron == false)
-		{
+		if (this.initialisePerceptron == false) {
 			for (int j = 0; j < instanceValues.length - 1; j++) {
 				prediction += this.weightAttribute[j] * instanceValues[j];
-			} 
+			}
 			prediction += this.weightAttribute[instanceValues.length - 1];
-		}	
+		}
 		return prediction;
 	}
 
-	public double[] normalizedInstance(Instance inst){
+	public double[] normalizedInstance(Instance inst) {
 		// Normalize Instance
-		double[] normalizedInstance = new double[numericAttributesIndex.length+1];
-		for(int j = 0; j < numericAttributesIndex.length; j++) {
+		double[] normalizedInstance = new double[numericAttributesIndex.length + 1];
+		for (int j = 0; j < numericAttributesIndex.length; j++) {
 			int instAttIndex = modelAttIndexToInstanceAttIndex(numericAttributesIndex[j], inst);
 			double mean = perceptronattributeStatistics.getValue(j) / perceptronYSeen;
-			double sd = computeSD(squaredperceptronattributeStatistics.getValue(j), perceptronattributeStatistics.getValue(j), perceptronYSeen);
-			if (sd > SD_THRESHOLD) 
-				normalizedInstance[j] = (inst.value(instAttIndex) - mean)/ sd; 
+			double sd = computeSD(squaredperceptronattributeStatistics.getValue(j),
+					perceptronattributeStatistics.getValue(j), perceptronYSeen);
+			if (sd > SD_THRESHOLD)
+				normalizedInstance[j] = (inst.value(instAttIndex) - mean) / sd;
 			else
 				normalizedInstance[j] = inst.value(instAttIndex) - mean;
 		}
 		return normalizedInstance;
 	}
 
-	public  double computeSD(double squaredVal, double val, double size) {
+	public double computeSD(double squaredVal, double val, double size) {
 		if (size > 1) {
-			return  Math.sqrt((squaredVal - ((val * val) / size)) / (size - 1.0));
+			return Math.sqrt((squaredVal - ((val * val) / size)) / (size - 1.0));
 		}
 		return 0.0;
 	}
 
-	public void updateWeights(Instance inst, double learningRatio ){
+	public void updateWeights(Instance inst, double learningRatio) {
 		// Normalize Instance
-		double[] normalizedInstance = normalizedInstance(inst); 
+		double[] normalizedInstance = normalizedInstance(inst);
 		// Compute the Normalized Prediction of Perceptron
-		double normalizedPredict= prediction(normalizedInstance);
+		double normalizedPredict = prediction(normalizedInstance);
 		double normalizedY = normalizeActualClassValue(inst);
-		double sumWeights = 0.0;		
+		double sumWeights = 0.0;
 		double delta = normalizedY - normalizedPredict;
 
 		for (int j = 0; j < numericAttributesIndex.length; j++) {
-			//int instAttIndex = modelAttIndexToInstanceAttIndex(numericAttributesIndex[j], inst);
-			//if(inst.attribute(instAttIndex).isNumeric()) {
-				this.weightAttribute[j] += learningRatio * delta * normalizedInstance[j]*inst.weight();
-				sumWeights += Math.abs(this.weightAttribute[j]);
-			//}
+			// int instAttIndex = modelAttIndexToInstanceAttIndex(numericAttributesIndex[j],
+			// inst);
+			// if(inst.attribute(instAttIndex).isNumeric()) {
+			this.weightAttribute[j] += learningRatio * delta * normalizedInstance[j] * inst.weight();
+			sumWeights += Math.abs(this.weightAttribute[j]);
+			// }
 		}
-		this.weightAttribute[numericAttributesIndex.length] += learningRatio * delta*inst.weight();
+		this.weightAttribute[numericAttributesIndex.length] += learningRatio * delta * inst.weight();
 		sumWeights += Math.abs(this.weightAttribute[numericAttributesIndex.length]);
 		if (sumWeights > numericAttributesIndex.length) { // Lasso regression
 			for (int j = 0; j < numericAttributesIndex.length; j++) {
-				//int instAttIndex = modelAttIndexToInstanceAttIndex(numericAttributesIndex[j], inst);
-				//if(inst.attribute(instAttIndex).isNumeric()) {
-					this.weightAttribute[j] = this.weightAttribute[j] / sumWeights;
-				//}
+				// int instAttIndex = modelAttIndexToInstanceAttIndex(numericAttributesIndex[j],
+				// inst);
+				// if(inst.attribute(instAttIndex).isNumeric()) {
+				this.weightAttribute[j] = this.weightAttribute[j] / sumWeights;
+				// }
 			}
-			this.weightAttribute[numericAttributesIndex.length]  = this.weightAttribute[numericAttributesIndex.length] / sumWeights;
+			this.weightAttribute[numericAttributesIndex.length] = this.weightAttribute[numericAttributesIndex.length]
+					/ sumWeights;
 		}
 
-		//return denormalizedPrediction(normalizedPredict);
+		// return denormalizedPrediction(normalizedPredict);
 	}
 
-	public void normalizeWeights(){
-		double sumWeights = 0.0;		
+	public void normalizeWeights() {
+		double sumWeights = 0.0;
 
-		for (int j = 0; j < this.weightAttribute.length ; j++) {
+		for (int j = 0; j < this.weightAttribute.length; j++) {
 			sumWeights += Math.abs(this.weightAttribute[j]);
 		}
 		for (int j = 0; j < this.weightAttribute.length; j++) {
 			this.weightAttribute[j] = this.weightAttribute[j] / sumWeights;
-		}	
+		}
 	}
 
 	private double normalizeActualClassValue(Instance inst) {
@@ -344,9 +333,9 @@ private double normalizeActualClassValue(Instance inst) {
 		double sdY = computeSD(squaredperceptronsumY, perceptronsumY, perceptronYSeen);
 
 		double normalizedY = 0.0;
-		if (sdY > SD_THRESHOLD){
+		if (sdY > SD_THRESHOLD) {
 			normalizedY = (inst.classValue() - meanY) / sdY;
-		}else{
+		} else {
 			normalizedY = inst.classValue() - meanY;
 		}
 		return normalizedY;
@@ -359,7 +348,7 @@ public boolean isRandomizable() {
 
 	@Override
 	public Prediction getPredictionForInstance(Instance inst) {
-		if (!this.initialisePerceptron) //has started training
+		if (!this.initialisePerceptron) // has started training
 			return new RegressionPrediction(this.prediction(inst));
 		else
 			return new RegressionPrediction(0);
@@ -372,34 +361,30 @@ protected Measurement[] getModelMeasurementsImpl() {
 
 	@Override
 	public void getModelDescription(StringBuilder out, int indent) {
-		if(this.weightAttribute!=null){
-			for(int i=0; i< this.weightAttribute.length-1; ++i)
-			{
-				if(this.weightAttribute[i]>0 && i>0)
-					out.append(" +" + Math.round(this.weightAttribute[i]*1000)/1000.0 + " X" + i );
-				else if(this.weightAttribute[i]<0 || i==0)
-					out.append(" " + Math.round(this.weightAttribute[i]*1000)/1000.0 + " X" + i );
+		if (this.weightAttribute != null) {
+			for (int i = 0; i < this.weightAttribute.length - 1; ++i) {
+				if (this.weightAttribute[i] > 0 && i > 0)
+					out.append(" +" + Math.round(this.weightAttribute[i] * 1000) / 1000.0 + " X" + i);
+				else if (this.weightAttribute[i] < 0 || i == 0)
+					out.append(" " + Math.round(this.weightAttribute[i] * 1000) / 1000.0 + " X" + i);
 			}
-			if(this.weightAttribute[this.weightAttribute.length-1]>=0 )
-				out.append(" +" + Math.round(this.weightAttribute[this.weightAttribute.length-1]*1000)/1000.0);
-			else 
-				out.append(" " + Math.round(this.weightAttribute[this.weightAttribute.length-1]*1000)/1000.0);
-		}	
+			if (this.weightAttribute[this.weightAttribute.length - 1] >= 0)
+				out.append(" +" + Math.round(this.weightAttribute[this.weightAttribute.length - 1] * 1000) / 1000.0);
+			else
+				out.append(" " + Math.round(this.weightAttribute[this.weightAttribute.length - 1] * 1000) / 1000.0);
+		}
 	}
 
 	public void setLearningRatio(double learningRatio) {
-		this.learningRatio=learningRatio;
+		this.learningRatio = learningRatio;
 
 	}
 
-	public double getCurrentError()
-	{
-		if (nError>0)
-			return accumulatedError/nError;
-		else 
+	public double getCurrentError() {
+		if (nError > 0)
+			return accumulatedError / nError;
+		else
 			return Double.MAX_VALUE;
 	}
 
 }
-
-
diff --git a/moa/src/main/java/moa/classifiers/rules/functions/TargetMean.java b/moa/src/main/java/moa/learners/predictors/rules/functions/TargetMean.java
similarity index 65%
rename from moa/src/main/java/moa/classifiers/rules/functions/TargetMean.java
rename to moa/src/main/java/moa/learners/predictors/rules/functions/TargetMean.java
index 03055c490..03dedaf95 100644
--- a/moa/src/main/java/moa/classifiers/rules/functions/TargetMean.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/functions/TargetMean.java
@@ -14,45 +14,44 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
-package moa.classifiers.rules.functions;
+package moa.learners.predictors.rules.functions;
+
 /**
  * TargetMean - Returns the mean of the target variable of the training instances
- * 
- * @author João Duarte 
- * 
+ *
+ * @author João Duarte
+ *
  *  */
 import com.github.javacliparser.FloatOption;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 import com.yahoo.labs.samoa.instances.predictions.RegressionPrediction;
 
-import moa.classifiers.AbstractRegressor;
 import moa.core.Measurement;
 import moa.core.StringUtils;
-import moa.learners.Classifier;
-import moa.learners.Regressor;
-
+import moa.learners.predictors.AbstractRegressor;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.Regressor;
 
-public class TargetMean extends AbstractRegressor implements Classifier, Regressor, AMRulesRegressorFunction {
+public class TargetMean extends AbstractRegressor implements Regressor{
 
 	/**
-	 * 
+	 *
 	 */
 	protected double n;
 	protected double sum;
 	protected double errorSum;
 	protected double nError;
 	private double fadingErrorFactor;
-	
+
 	private static final long serialVersionUID = 7152547322803559115L;
 
-	public FloatOption fadingErrorFactorOption = new FloatOption(
-			"fadingErrorFactor", 'e', 
+	public FloatOption fadingErrorFactorOption = new FloatOption("fadingErrorFactor", 'e',
 			"Fading error factor for the TargetMean accumulated error", 0.99, 0, 1);
-	
+
 	@Override
 	public boolean isRandomizable() {
 		return false;
@@ -61,31 +60,32 @@ public boolean isRandomizable() {
 	@Override
 	public Prediction getPredictionForInstance(Instance inst) {
 		double currentMean = 0;
-		if (n>0)
+		if (n > 0)
 			currentMean = sum / n;
 		return new RegressionPrediction(currentMean);
 	}
 
 	@Override
 	public void resetLearningImpl() {
-		sum=0;
-		n=0;
-		errorSum=Double.MAX_VALUE;
-		nError=0;
+		sum = 0;
+		n = 0;
+		errorSum = Double.MAX_VALUE;
+		nError = 0;
 	}
 
 	@Override
 	public void trainOnInstanceImpl(Instance inst) {
 		updateAccumulatedError(inst);
-		this.n+=inst.weight();
-		this.sum+=inst.classValue()*inst.weight();
+		this.n += inst.weight();
+		this.sum += inst.classValue() * inst.weight();
 	}
-	protected void updateAccumulatedError(Instance inst){
-		double mean=0;
-		nError=inst.weight()+fadingErrorFactor*nError;
-		if(n>0)
-			mean=sum/n;			
-		errorSum=Math.abs(inst.classValue()-mean)*inst.weight()+fadingErrorFactor*errorSum;	
+
+	protected void updateAccumulatedError(Instance inst) {
+		double mean = 0;
+		nError = inst.weight() + fadingErrorFactor * nError;
+		if (n > 0)
+			mean = sum / n;
+		errorSum = Math.abs(inst.classValue() - mean) * inst.weight() + fadingErrorFactor * errorSum;
 	}
 
 	@Override
@@ -95,25 +95,26 @@ protected Measurement[] getModelMeasurementsImpl() {
 
 	@Override
 	public void getModelDescription(StringBuilder out, int indent) {
-		StringUtils.appendIndented(out, indent, "Current Mean: " + this.sum/this.n);
-		StringUtils.appendNewline(out);	
-		
+		StringUtils.appendIndented(out, indent, "Current Mean: " + this.sum / this.n);
+		StringUtils.appendNewline(out);
+
 	}
-	/* JD
-	 * Resets the learner but initializes with a starting point 
-	 * */
+
+	/*
+	 * JD Resets the learner but initializes with a starting point
+	 */
 	public void reset(double currentMean, double numberOfInstances) {
-		this.sum=currentMean*numberOfInstances;
-		this.n=numberOfInstances;
+		this.sum = currentMean * numberOfInstances;
+		this.n = numberOfInstances;
 		this.resetError();
 	}
-	
-	/* JD
-	 * Resets the learner but initializes with a starting point 
-	 * */
-	public double getCurrentError(){
-		if(this.nError>0)
-			return this.errorSum/this.nError;
+
+	/*
+	 * JD Resets the learner but initializes with a starting point
+	 */
+	public double getCurrentError() {
+		if (this.nError > 0)
+			return this.errorSum / this.nError;
 		else
 			return Double.MAX_VALUE;
 	}
@@ -130,14 +131,12 @@ public TargetMean(TargetMean t) {
 
 	public TargetMean() {
 		super();
-		fadingErrorFactor=fadingErrorFactorOption.getValue();
+		fadingErrorFactor = fadingErrorFactorOption.getValue();
 	}
 
 	public void resetError() {
-		this.errorSum=0;
-		this.nError=0;
+		this.errorSum = 0;
+		this.nError = 0;
 	}
-	
-
 
 }
diff --git a/moa/src/main/java/moa/classifiers/rules/meta/RandomAMRules.java b/moa/src/main/java/moa/learners/predictors/rules/meta/RandomAMRules.java
similarity index 76%
rename from moa/src/main/java/moa/classifiers/rules/meta/RandomAMRules.java
rename to moa/src/main/java/moa/learners/predictors/rules/meta/RandomAMRules.java
index 1626f2b8a..c21a8e4d9 100644
--- a/moa/src/main/java/moa/classifiers/rules/meta/RandomAMRules.java
+++ b/moa/src/main/java/moa/learners/predictors/rules/meta/RandomAMRules.java
@@ -17,23 +17,24 @@
  *
  *
  */
-package moa.classifiers.rules.meta;
+package moa.learners.predictors.rules.meta;
 
-import moa.classifiers.rules.multilabel.AMRulesMultiLabelLearner;
-import moa.classifiers.rules.multilabel.meta.MultiLabelRandomAMRules;
-import moa.learners.MultiTargetRegressor;
+import moa.learners.predictors.MultiTargetRegressor;
+import moa.learners.predictors.rules.AMRulesMultiLabelLearner;
+import moa.learners.predictors.rules.MultiLabelRandomAMRules;
 import moa.options.ClassOption;
 
 public class RandomAMRules extends MultiLabelRandomAMRules implements MultiTargetRegressor {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 
 	public RandomAMRules() {
 		super();
-		baseLearnerOption = new ClassOption("baseLearner", 'l', "Classifier to train.", AMRulesMultiLabelLearner.class, "AMRulesMultiTargetRegressor"); 
+		baseLearnerOption = new ClassOption("baseLearner", 'l', "Classifier to train.", AMRulesMultiLabelLearner.class,
+				"AMRulesMultiTargetRegressor");
 	}
 
 }
diff --git a/moa/src/main/java/moa/learners/predictors/rules/meta/RandomAMRulesOld.java b/moa/src/main/java/moa/learners/predictors/rules/meta/RandomAMRulesOld.java
new file mode 100644
index 000000000..409a6826b
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/rules/meta/RandomAMRulesOld.java
@@ -0,0 +1,204 @@
+/*
+ *    RandomRules.java
+ *    Copyright (C) 2014 University of Waikato, Hamilton, New Zealand
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.rules.meta;
+
+import java.util.Arrays;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.predictions.MultiTargetRegressionPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Measurement;
+import moa.core.MiscUtils;
+import moa.learners.predictors.AbstractMultiTargetRegressor;
+import moa.learners.predictors.MultiTargetRegressor;
+import moa.learners.predictors.Regressor;
+import moa.learners.predictors.rules.AMRulesRegressorOld;
+import moa.learners.predictors.rules.AbstractAMRules;
+import moa.learners.predictors.rules.core.voting.ErrorWeightedVote;
+import moa.learners.predictors.rules.core.voting.Vote;
+import moa.options.ClassOption;
+
+public class RandomAMRulesOld extends AbstractMultiTargetRegressor implements MultiTargetRegressor {
+
+	public IntOption VerbosityOption = new IntOption("verbosity", 'v',
+			"Output Verbosity Control Level. 1 (Less) to 2 (More)", 1, 1, 2);
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption baseLearnerOption = new ClassOption("baseLearner", 'l', "Regressor to train.",
+			AbstractAMRules.class, AMRulesRegressorOld.class.getName());
+
+	public IntOption ensembleSizeOption = new IntOption("ensembleSize", 's', "The number of models in the bag.", 10, 1,
+			Integer.MAX_VALUE);
+
+	public FloatOption numAttributesPercentageOption = new FloatOption("numAttributesPercentage", 'n',
+			"The number of attributes to use per model.", 63.2, 0, 100);
+
+	public FlagOption useBaggingOption = new FlagOption("useBagging", 'p', "Use Bagging.");
+
+	public ClassOption votingFunctionOption = new ClassOption("votingFunction", 'V', "Voting Function.",
+			ErrorWeightedVote.class, "UniformWeightedVote");
+
+	public MultiChoiceOption votingTypeOption = new MultiChoiceOption("votingTypeOption", 'C',
+			"Select whether the base learner error is computed as the overall error os only the error of the rules that cover the example.",
+			new String[] { "Overall", "Only rules covered" }, new String[] { "Overall", "Covered" }, 0);
+
+	public FloatOption fadingErrorFactorOption = new FloatOption("fadingErrorFactor", 'e',
+			"Fading error factor for the accumulated error", 0.99, 0, 1);
+
+	protected AbstractAMRules[] ensemble;
+	protected double[] sumError;
+	protected double[] nError;
+
+	protected boolean isRegression;
+
+	@Override
+	public void resetLearningImpl() {
+		this.classifierRandom.setSeed(this.randomSeedOption.getValue());
+		int n = this.ensembleSizeOption.getValue();
+		this.ensemble = new AbstractAMRules[n];
+		sumError = new double[n];
+		nError = new double[n];
+
+		// Classifier baseLearner = (Classifier)
+		// getPreparedClassOption(this.baseLearnerOption);
+		AbstractAMRules baseLearner = (AbstractAMRules) getPreparedClassOption(this.baseLearnerOption);
+		baseLearner.setAttributesPercentage(numAttributesPercentageOption.getValue());
+		baseLearner.resetLearning();
+		for (int i = 0; i < this.ensemble.length; i++) {
+			this.ensemble[i] = (AbstractAMRules) baseLearner.copy();
+			this.ensemble[i].setRandomSeed(this.classifierRandom.nextInt());
+		}
+		this.isRegression = (baseLearner instanceof Regressor);
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance instance) {
+		double factor = this.fadingErrorFactorOption.getValue();
+		for (int i = 0; i < this.ensemble.length; i++) {
+			Instance inst = instance.copy();
+			int k = 1;
+			if (this.useBaggingOption.isSet()) {
+				k = MiscUtils.poisson(1.0, this.classifierRandom);
+			}
+			if (k > 0) {
+				// Instance weightedInst = transformInstance(inst,i);
+				inst.setWeight(inst.weight() * k);
+
+				// estimate error
+				double error = Math
+						.abs(inst.classValue() - ensemble[i].getPredictionForInstance(inst).asDoubleArray()[0]);
+				sumError[i] = error * inst.weight() + sumError[i] * factor;
+				nError[i] = inst.weight() + nError[i] * factor;
+				// train learner
+				this.ensemble[i].trainOnInstance(inst);
+			}
+		}
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		double[] votes = null;
+		// ErrorWeightedVote combinedVote = (ErrorWeightedVote)((ErrorWeightedVote)
+		// votingTypeOption.getPreMaterializedObject()).copy();
+		ErrorWeightedVote combinedVote = (ErrorWeightedVote) ((ErrorWeightedVote) getPreparedClassOption(
+				this.votingFunctionOption)).copy();
+		StringBuilder sb = null;
+		if (VerbosityOption.getValue() > 1)
+			sb = new StringBuilder();
+
+		for (int i = 0; i < this.ensemble.length; i++) {
+			// transformInstance method visibility changed from private to protected in
+			// RandomRules
+			Vote v = this.ensemble[i].getVotes(inst);
+			if (VerbosityOption.getValue() > 1)
+				sb.append(Arrays.toString(v.getVote()) + ", " + " E: " + v.getError() + " ");
+			if (this.isRegression == false && v.sumVoteDistrib() != 0.0) {
+				v.normalize();
+			}
+			if (this.votingTypeOption.getChosenIndex() == 0) {// Overall error estimation
+				combinedVote.addVote(v.getVote(), this.sumError[i] / this.nError[i]);
+			} else // Error estimation over the rules that cover the example
+				combinedVote.addVote(v.getVote(), v.getError());
+		}
+		votes = combinedVote.computeWeightedVote();
+		if (VerbosityOption.getValue() > 1) {
+			sb.append(Arrays.toString(votes) + ", ").append(inst.classValue());
+			System.out.println(sb.toString());
+		}
+		return new MultiTargetRegressionPrediction(votes);
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		Measurement[] baseLearnerMeasurements = ((AbstractAMRules) getPreparedClassOption(this.baseLearnerOption))
+				.getModelMeasurements();
+		int nMeasurements = baseLearnerMeasurements.length;
+		Measurement[] m = new Measurement[nMeasurements + 1];
+
+		for (int i = 0; i < baseLearnerMeasurements.length; i++)
+			m[i + 1] = baseLearnerMeasurements[i];
+
+		int ensembleSize = 0;
+		if (this.ensemble != null) {
+			ensembleSize = this.ensemble.length;
+			for (int i = 0; i < nMeasurements; i++) {
+				double value = 0;
+				for (int j = 0; j < ensembleSize; ++j) {
+					value += ensemble[j].getModelMeasurements()[i].getValue();
+				}
+				m[i + 1] = new Measurement("Avg " + baseLearnerMeasurements[i].getName(), value / ensembleSize);
+			}
+		}
+
+		m[0] = new Measurement("ensemble size", ensembleSize);
+
+		return m;
+	}
+
+//	public Classifier[] getSubClassifiers() {
+//		return this.ensemble; //.clone();
+//	}
+
+	protected int[][] listAttributes;
+	protected int numAttributes;
+	protected InstancesHeader[] dataset;
+
+	@Override
+	public String getPurposeString() {
+		return "WeightedRandomRules";
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/trees/ARFFIMTDD.java b/moa/src/main/java/moa/learners/predictors/trees/ARFFIMTDD.java
new file mode 100644
index 000000000..a3e512ced
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/trees/ARFFIMTDD.java
@@ -0,0 +1,1049 @@
+/*
+ *    ARFFIMTDD.java
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ */
+
+package moa.learners.predictors.trees;
+
+import java.io.Serializable;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+import com.yahoo.labs.samoa.instances.predictions.RegressionPrediction;
+
+import moa.AbstractMOAObject;
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.SizeOf;
+import moa.core.StringUtils;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Regressor;
+import moa.learners.predictors.core.AttributeSplitSuggestion;
+import moa.learners.predictors.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
+import moa.learners.predictors.core.conditionaltests.InstanceConditionalTest;
+import moa.learners.predictors.core.splitcriteria.SplitCriterion;
+import moa.options.ClassOption;
+
+/**
+ * Implementation of ARFFIMTDD, an extension of ARFFIMTDD to be used by
+ * AdaptiveRandomForestRegressor.
+ *
+ * <p>
+ * See details in:<br>
+ * Heitor Murilo Gomes, Jean Paul Barddal, Luis Eduardo Boiko Ferreira, Albert
+ * Bifet. Adaptive random forests for data stream regression. In European
+ * Symposium on Artificial Neural Networks, Computational Intelligence and
+ * Machine Learning (ESANN), 2018.
+ * https://www.elen.ucl.ac.be/Proceedings/esann/esannpdf/es2018-183.pdf
+ * </p>
+ */
+public class ARFFIMTDD extends AbstractClassifier implements Regressor {
+
+	private static final long serialVersionUID = 1L;
+
+	protected Node treeRoot;
+
+	protected int leafNodeCount = 0;
+	protected int splitNodeCount = 0;
+
+	protected double examplesSeen = 0.0;
+	protected double sumOfValues = 0.0;
+	protected double sumOfSquares = 0.0;
+
+	protected DoubleVector sumOfAttrValues = new DoubleVector();
+	protected DoubleVector sumOfAttrSquares = new DoubleVector();
+
+	public int maxID = 0;
+
+	public IntOption subspaceSizeOption = new IntOption("subspaceSizeSize", 'k',
+			"Number of features per subset for each node split. Negative values = #features - k", 2, Integer.MIN_VALUE,
+			Integer.MAX_VALUE);
+
+	// region ================ OPTIONS ================
+
+	public ClassOption splitCriterionOption = new ClassOption("splitCriterion", 's', "Split criterion to use.",
+			SplitCriterion.class, "core.splitcriteria.VarianceReductionSplitCriterion");
+
+	public IntOption gracePeriodOption = new IntOption("gracePeriod", 'g',
+			"Number of instances a leaf should observe between split attempts.", 200, 0, Integer.MAX_VALUE);
+
+	public FloatOption splitConfidenceOption = new FloatOption("splitConfidence", 'c',
+			"Allowed error in split decision, values close to 0 will take long to decide.", 0.0000001, 0.0, 1.0);
+
+	public FloatOption tieThresholdOption = new FloatOption("tieThreshold", 't',
+			"Threshold below which a split will be forced to break ties.", 0.05, 0.0, 1.0);
+
+	public FloatOption PageHinckleyAlphaOption = new FloatOption("PageHinckleyAlpha", 'a',
+			"Alpha value to use in the Page Hinckley change detection tests.", 0.005, 0.0, 1.0);
+
+	public IntOption PageHinckleyThresholdOption = new IntOption("PageHinckleyThreshold", 'h',
+			"Threshold value used in the Page Hinckley change detection tests.", 50, 0, Integer.MAX_VALUE);
+
+	public FloatOption alternateTreeFadingFactorOption = new FloatOption("alternateTreeFadingFactor", 'f',
+			"Fading factor used to decide if an alternate tree should replace an original.", 0.995, 0.0, 1.0);
+
+	public IntOption alternateTreeTMinOption = new IntOption("alternateTreeTMin", 'y',
+			"Tmin value used to decide if an alternate tree should replace an original.", 150, 0, Integer.MAX_VALUE);
+
+	public IntOption alternateTreeTimeOption = new IntOption("alternateTreeTime", 'u',
+			"The number of instances used to decide if an alternate tree should be discarded.", 1500, 0,
+			Integer.MAX_VALUE);
+
+	public FlagOption regressionTreeOption = new FlagOption("regressionTree", 'e',
+			"Build a regression tree instead of a model tree.");
+
+	public FloatOption learningRatioOption = new FloatOption("learningRatio", 'l',
+			"Learning ratio to used for training the Perceptrons in the leaves.", 0.02, 0, 1.00);
+
+	public FloatOption learningRateDecayFactorOption = new FloatOption("learningRatioDecayFactor", 'd',
+			"Learning rate decay factor (not used when learning rate is constant).", 0.001, 0, 1.00);
+
+	public FlagOption learningRatioConstOption = new FlagOption("learningRatioConst", 'p',
+			"Keep learning rate constant instead of decaying.");
+
+	// endregion ================ OPTIONS ================
+
+	// region ================ CLASSES ================
+
+	public abstract static class Node extends AbstractMOAObject {
+
+		private static final long serialVersionUID = 1L;
+
+		public int ID;
+
+		protected ARFFIMTDD tree;
+
+		protected boolean changeDetection = true;
+
+		protected Node parent;
+
+		protected Node alternateTree;
+		protected Node originalNode;
+
+		// The statistics for this node:
+		// Number of instances that have reached it
+		protected double examplesSeen;
+		// Sum of y values
+		protected double sumOfValues;
+		// Sum of squared y values
+		protected double sumOfSquares;
+		// Sum of absolute errors
+		protected double sumOfAbsErrors; // Needed for PH tracking of mean error
+
+		public Node(ARFFIMTDD tree) {
+			this.tree = tree;
+			ID = tree.maxID;
+		}
+
+		public void copyStatistics(Node node) {
+			examplesSeen = node.examplesSeen;
+			sumOfValues = node.sumOfValues;
+			sumOfSquares = node.sumOfSquares;
+			sumOfAbsErrors = node.sumOfAbsErrors;
+		}
+
+		public int calcByteSize() {
+			return (int) SizeOf.fullSizeOf(this);
+		}
+
+		/**
+		 * Set the parent node
+		 */
+		public void setParent(Node parent) {
+			this.parent = parent;
+		}
+
+		/**
+		 * Return the parent node
+		 */
+		public Node getParent() {
+			return parent;
+		}
+
+		public void disableChangeDetection() {
+			changeDetection = false;
+		}
+
+		public void restartChangeDetection() {
+			changeDetection = true;
+		}
+
+		@Override
+		public void getDescription(StringBuilder sb, int indent) {
+
+		}
+
+		public double getPrediction(Instance inst) {
+			return 0;
+		}
+
+		public void describeSubtree(StringBuilder out, int indent) {
+			StringUtils.appendIndented(out, indent, "Leaf");
+		}
+
+		public int getLevel() {
+			Node target = this;
+			int level = 0;
+			while (target.getParent() != null) {
+				if (target.skipInLevelCount()) {
+					target = target.getParent();
+					continue;
+				}
+				level = level + 1;
+				target = target.getParent();
+			}
+			if (target.originalNode == null) {
+				return level;
+			} else {
+				return level + originalNode.getLevel();
+			}
+		}
+
+		public void setChild(int parentBranch, Node node) {
+		}
+
+		public int getChildIndex(Node child) {
+			return -1;
+		}
+
+		public int getNumSubtrees() {
+			return 1;
+		}
+
+		protected boolean skipInLevelCount() {
+			return false;
+		}
+	}
+
+	public static class LeafNode extends Node {
+
+		private static final long serialVersionUID = 1L;
+
+		// Perceptron model that carries out the actual learning in each node
+		public FIMTDDPerceptron learningModel;
+
+		protected AutoExpandVector<FIMTDDNumericAttributeClassObserver> attributeObservers = new AutoExpandVector<>();
+
+		protected double examplesSeenAtLastSplitEvaluation = 0;
+
+		protected int[] listAttributes;
+
+		protected int numAttributes;
+
+		/**
+		 * Create a new LeafNode
+		 */
+		public LeafNode(ARFFIMTDD tree, int subspaceSize) {
+			super(tree);
+			if (tree.buildingModelTree()) {
+				learningModel = tree.newLeafModel();
+			}
+			examplesSeen = 0;
+			sumOfValues = 0;
+			sumOfSquares = 0;
+			sumOfAbsErrors = 0;
+
+			this.numAttributes = subspaceSize;
+		}
+
+		@Override
+		public void setChild(int parentBranch, Node node) {
+		}
+
+		@Override
+		public int getChildIndex(Node child) {
+			return -1;
+		}
+
+		@Override
+		public int getNumSubtrees() {
+			return 1;
+		}
+
+		@Override
+		protected boolean skipInLevelCount() {
+			return false;
+		}
+
+		/**
+		 * Method to learn from an instance that passes the new instance to the
+		 * perceptron learner, and also prevents the class value from being truncated to
+		 * an int when it is passed to the attribute observer
+		 */
+		public void learnFromInstance(Instance inst, boolean growthAllowed, ARFFIMTDD arffimtdd) {
+			// The prediction must be calculated here -- it may be different from the tree's
+			// prediction due to alternate trees
+
+			// Update the statistics for this node
+			// number of instances passing through the node
+			examplesSeen += inst.weight();
+
+			// sum of y values
+			sumOfValues += inst.weight() * inst.classValue();
+
+			// sum of squared y values
+			sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
+
+			// sum of absolute errors
+			sumOfAbsErrors += inst.weight()
+					* Math.abs(tree.normalizeTargetValue(Math.abs(inst.classValue() - getPrediction(inst))));
+
+			if (tree.buildingModelTree())
+				learningModel.updatePerceptron(inst);
+
+			if (this.listAttributes == null) {
+				this.listAttributes = new int[this.numAttributes];
+				for (int j = 0; j < this.numAttributes; j++) {
+					boolean isUnique = false;
+					while (isUnique == false) {
+						this.listAttributes[j] = arffimtdd.classifierRandom.nextInt(inst.numAttributes() - 1);
+						isUnique = true;
+						for (int i = 0; i < j; i++) {
+							if (this.listAttributes[j] == this.listAttributes[i]) {
+								isUnique = false;
+								break;
+							}
+						}
+					}
+				}
+			}
+
+//                        for (int j = 0; j < this.numAttributes - 1; j++) {
+//                            int i = this.listAttributes[j];
+//                            int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
+//                            AttributeClassObserver obs = this.attributeObservers.get(i);
+//                            if (obs == null) {
+//                                obs = inst.attribute(instAttIndex).isNominal() ? ht.newNominalClassObserver() : ht.newNumericClassObserver();
+//                                this.attributeObservers.set(i, obs);
+//                            }
+//                            obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
+//                        }
+
+			for (int j = 0; j < this.listAttributes.length; j++) {
+				int i = this.listAttributes[j];
+				int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
+				FIMTDDNumericAttributeClassObserver obs = attributeObservers.get(i);
+				if (obs == null) {
+					// At this stage all nominal attributes are ignored
+					if (inst.attribute(instAttIndex).isNumeric()) {
+						obs = tree.newNumericClassObserver();
+						this.attributeObservers.set(i, obs);
+					}
+				}
+				if (obs != null) {
+					obs.observeAttributeClass(inst.value(instAttIndex), inst.classValue(), inst.weight());
+				}
+			}
+
+			if (growthAllowed) {
+				checkForSplit(tree);
+			}
+		}
+
+		/**
+		 * Return the best split suggestions for this node using the given split
+		 * criteria
+		 */
+		public AttributeSplitSuggestion[] getBestSplitSuggestions(SplitCriterion criterion) {
+
+			List<AttributeSplitSuggestion> bestSuggestions = new LinkedList<>();
+
+			// Set the nodeStatistics up as the preSplitDistribution, rather than the
+			// observedClassDistribution
+			double[] nodeSplitDist = new double[] { examplesSeen, sumOfValues, sumOfSquares };
+
+			for (int i = 0; i < this.attributeObservers.size(); i++) {
+				FIMTDDNumericAttributeClassObserver obs = this.attributeObservers.get(i);
+				if (obs != null) {
+
+					// AT THIS STAGE NON-NUMERIC ATTRIBUTES ARE IGNORED
+					AttributeSplitSuggestion bestSuggestion = null;
+					if (obs instanceof FIMTDDNumericAttributeClassObserver) {
+						bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion, nodeSplitDist, i, true);
+					}
+
+					if (bestSuggestion != null) {
+						bestSuggestions.add(bestSuggestion);
+					}
+				}
+			}
+			return bestSuggestions.toArray(new AttributeSplitSuggestion[bestSuggestions.size()]);
+		}
+
+		/**
+		 * Retrieve the class votes using the perceptron learner
+		 */
+		public double getPredictionModel(Instance inst) {
+			return learningModel.prediction(inst);
+		}
+
+		public double getPredictionTargetMean(Instance inst) {
+			return (examplesSeen > 0.0) ? sumOfValues / examplesSeen : 0.0;
+		}
+
+		@Override
+		public double getPrediction(Instance inst) {
+			return (tree.buildingModelTree()) ? getPredictionModel(inst) : getPredictionTargetMean(inst);
+		}
+
+		public void checkForSplit(ARFFIMTDD tree) {
+			// If it has seen Nmin examples since it was last tested for splitting, attempt
+			// a split of this node
+			if (examplesSeen - examplesSeenAtLastSplitEvaluation >= tree.gracePeriodOption.getValue()) {
+				int index = (parent != null) ? parent.getChildIndex(this) : 0;
+				tree.attemptToSplit(this, parent, index);
+
+				// Take note of how many instances were seen when this split evaluation was
+				// made, so we know when to perform the next split evaluation
+				examplesSeenAtLastSplitEvaluation = examplesSeen;
+			}
+		}
+
+		@Override
+		public void describeSubtree(StringBuilder out, int indent) {
+			StringUtils.appendIndented(out, indent, "Leaf ");
+			if (tree.buildingModelTree()) {
+				learningModel.getModelDescription(out, 0);
+			} else {
+				out.append(tree.getClassNameString() + " = " + String.format("%.4f", (sumOfValues / examplesSeen)));
+				StringUtils.appendNewline(out);
+			}
+		}
+	}
+
+	public abstract static class InnerNode extends Node {
+		// The InnerNode and SplitNode design is used for easy extension in ORTO
+		private static final long serialVersionUID = 1L;
+
+		protected AutoExpandVector<Node> children = new AutoExpandVector<>();
+
+		// The error values for the Page Hinckley test
+		// PHmT = the cumulative sum of the errors
+		// PHMT = the minimum error value seen so far
+		protected double PHsum = 0;
+		protected double PHmin = Double.MAX_VALUE;
+
+		// Keep track of the statistics for loss error calculations
+		protected double lossExamplesSeen;
+		protected double lossFadedSumOriginal;
+		protected double lossFadedSumAlternate;
+		protected double lossNumQiTests;
+		protected double lossSumQi;
+		protected double previousWeight = 0;
+
+		public InnerNode(ARFFIMTDD tree) {
+			super(tree);
+		}
+
+		public int numChildren() {
+			return children.size();
+		}
+
+		public Node getChild(int index) {
+			return children.get(index);
+		}
+
+		@Override
+		public int getChildIndex(Node child) {
+			return children.indexOf(child);
+		}
+
+		@Override
+		public void setChild(int index, Node child) {
+			children.set(index, child);
+		}
+
+		@Override
+		public void disableChangeDetection() {
+			changeDetection = false;
+			for (Node child : children) {
+				child.disableChangeDetection();
+			}
+		}
+
+		@Override
+		public void restartChangeDetection() {
+			if (alternateTree == null) {
+				changeDetection = true;
+				PHsum = 0;
+				PHmin = Integer.MAX_VALUE;
+				for (Node child : children)
+					child.restartChangeDetection();
+			}
+		}
+
+		/**
+		 * Check to see if the tree needs updating
+		 */
+		public boolean PageHinckleyTest(double error, double threshold) {
+			// Update the cumulative mT sum
+			PHsum += error;
+
+			// Update the minimum mT value if the new mT is
+			// smaller than the current minimum
+			if (PHsum < PHmin) {
+				PHmin = PHsum;
+			}
+			// Return true if the cumulative value - the current minimum is
+			// greater than the current threshold (in which case we should adapt)
+			return PHsum - PHmin > threshold;
+		}
+
+		public void initializeAlternateTree() {
+			// Start a new alternate tree, beginning with a learning node
+			alternateTree = tree.newLeafNode();
+			alternateTree.originalNode = this;
+
+			// Set up the blank statistics
+			// Number of instances reaching this node since the alternate tree was started
+			lossExamplesSeen = 0;
+			// Faded squared error (original tree)
+			lossFadedSumOriginal = 0;
+			// Faded squared error (alternate tree)
+			lossFadedSumAlternate = 0;
+			// Number of evaluations of alternate tree
+			lossNumQiTests = 0;
+			// Sum of Qi values
+			lossSumQi = 0;
+			// Number of examples at last test
+			previousWeight = 0;
+
+			// Disable the change detection mechanism bellow this node
+			disableChangeDetection();
+		}
+	}
+
+	public static class SplitNode extends InnerNode {
+
+		private static final long serialVersionUID = 1L;
+
+		protected InstanceConditionalTest splitTest;
+
+		/**
+		 * Create a new SplitNode
+		 * 
+		 * @param tree
+		 */
+		public SplitNode(InstanceConditionalTest splitTest, ARFFIMTDD tree) {
+			super(tree);
+			this.splitTest = splitTest;
+		}
+
+		public int instanceChildIndex(Instance inst) {
+			return splitTest.branchForInstance(inst);
+		}
+
+		public Node descendOneStep(Instance inst) {
+			return children.get(splitTest.branchForInstance(inst));
+		}
+
+		@Override
+		public void describeSubtree(StringBuilder out, int indent) {
+			for (int branch = 0; branch < children.size(); branch++) {
+				Node child = getChild(branch);
+				if (child != null) {
+					StringUtils.appendIndented(out, indent, "if ");
+					out.append(this.splitTest.describeConditionForBranch(branch, tree.getModelContext()));
+					out.append(": ");
+					StringUtils.appendNewline(out);
+					child.describeSubtree(out, indent + 2);
+				}
+			}
+		}
+
+		@Override
+		public double getPrediction(Instance inst) {
+			return children.get(splitTest.branchForInstance(inst)).getPrediction(inst);
+		}
+	}
+
+	public class FIMTDDPerceptron implements Serializable {
+
+		private static final long serialVersionUID = 1L;
+
+		protected ARFFIMTDD tree;
+
+		// The Perception weights
+		protected DoubleVector weightAttribute = new DoubleVector();
+
+		protected double sumOfValues;
+		protected double sumOfSquares;
+
+		// The number of instances contributing to this model
+		protected double instancesSeen = 0;
+
+		// If the model should be reset or not
+		protected boolean reset;
+
+		public String getPurposeString() {
+			return "A perceptron regressor as specified by Ikonomovska et al. used for FIMTDD";
+		}
+
+		public FIMTDDPerceptron(FIMTDDPerceptron original) {
+			this.tree = original.tree;
+			weightAttribute = (DoubleVector) original.weightAttribute.copy();
+			reset = false;
+		}
+
+		public FIMTDDPerceptron(ARFFIMTDD tree) {
+			this.tree = tree;
+			reset = true;
+		}
+
+		public DoubleVector getWeights() {
+			return weightAttribute;
+		}
+
+		/**
+		 * Update the model using the provided instance
+		 */
+		public void updatePerceptron(Instance inst) {
+
+			// Initialize perceptron if necessary
+			if (reset == true) {
+				reset = false;
+				weightAttribute = new DoubleVector();
+				instancesSeen = 0;
+				for (int j = 0; j < inst.numAttributes(); j++) { // The last index corresponds to the constant b
+					weightAttribute.setValue(j, 2 * tree.classifierRandom.nextDouble() - 1);
+				}
+			}
+
+			// Update attribute statistics
+			instancesSeen += inst.weight();
+
+			// Update weights
+			double learningRatio = 0.0;
+			if (tree.learningRatioConstOption.isSet()) {
+				learningRatio = learningRatioOption.getValue();
+			} else {
+				learningRatio = learningRatioOption.getValue()
+						/ (1 + instancesSeen * tree.learningRateDecayFactorOption.getValue());
+			}
+
+			sumOfValues += inst.weight() * inst.classValue();
+			sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
+
+			// Loop for compatibility with bagging methods
+			for (int i = 0; i < (int) inst.weight(); i++) {
+				updateWeights(inst, learningRatio);
+			}
+		}
+
+		public void updateWeights(Instance inst, double learningRatio) {
+			// Compute the normalized instance and the delta
+			DoubleVector normalizedInstance = normalizedInstance(inst);
+			double normalizedPrediction = prediction(normalizedInstance);
+			double normalizedValue = tree.normalizeTargetValue(inst.classValue());
+			double delta = normalizedValue - normalizedPrediction;
+			normalizedInstance.scaleValues(delta * learningRatio);
+
+			weightAttribute.addValues(normalizedInstance);
+		}
+
+		public DoubleVector normalizedInstance(Instance inst) {
+			// Normalize Instance
+			DoubleVector normalizedInstance = new DoubleVector();
+			for (int j = 0; j < inst.numAttributes() - 1; j++) {
+				int instAttIndex = modelAttIndexToInstanceAttIndex(j, inst);
+				double mean = tree.sumOfAttrValues.getValue(j) / tree.examplesSeen;
+				double sd = computeSD(tree.sumOfAttrSquares.getValue(j), tree.sumOfAttrValues.getValue(j),
+						tree.examplesSeen);
+				if (inst.attribute(instAttIndex).isNumeric() && tree.examplesSeen > 1 && sd > 0)
+					normalizedInstance.setValue(j, (inst.value(instAttIndex) - mean) / (3 * sd));
+				else
+					normalizedInstance.setValue(j, 0);
+			}
+			if (tree.examplesSeen > 1)
+				normalizedInstance.setValue(inst.numAttributes() - 1, 1.0); // Value to be multiplied with the constant
+																			// factor
+			else
+				normalizedInstance.setValue(inst.numAttributes() - 1, 0.0);
+			return normalizedInstance;
+		}
+
+		/**
+		 * Output the prediction made by this perceptron on the given instance
+		 */
+		public double prediction(DoubleVector instanceValues) {
+			return scalarProduct(weightAttribute, instanceValues);
+		}
+
+		protected double prediction(Instance inst) {
+			DoubleVector normalizedInstance = normalizedInstance(inst);
+			double normalizedPrediction = prediction(normalizedInstance);
+			return denormalizePrediction(normalizedPrediction, tree);
+		}
+
+		private double denormalizePrediction(double normalizedPrediction, ARFFIMTDD tree) {
+			double mean = tree.sumOfValues / tree.examplesSeen;
+			double sd = computeSD(tree.sumOfSquares, tree.sumOfValues, tree.examplesSeen);
+			if (examplesSeen > 1)
+				return normalizedPrediction * sd * 3 + mean;
+			else
+				return 0.0;
+		}
+
+		public void getModelDescription(StringBuilder out, int indent) {
+			StringUtils.appendIndented(out, indent, getClassNameString() + " =");
+			if (getModelContext() != null) {
+				for (int j = 0; j < getModelContext().numAttributes() - 1; j++) {
+					if (getModelContext().attribute(j).isNumeric()) {
+						out.append((j == 0 || weightAttribute.getValue(j) < 0) ? " " : " + ");
+						out.append(String.format("%.4f", weightAttribute.getValue(j)));
+						out.append(" * ");
+						out.append(getAttributeNameString(j));
+					}
+				}
+				out.append(" + " + weightAttribute.getValue((getModelContext().numAttributes() - 1)));
+			}
+			StringUtils.appendNewline(out);
+		}
+	}
+
+	// endregion ================ CLASSES ================
+
+	// region ================ METHODS ================
+
+	// region --- Regressor methods
+
+	@Override
+	public String getPurposeString() {
+		return "Implementation of the FIMT-DD tree as described by Ikonomovska et al.";
+	}
+
+	@Override
+	public void resetLearningImpl() {
+		this.treeRoot = null;
+		this.leafNodeCount = 0;
+		this.splitNodeCount = 0;
+		this.maxID = 0;
+		this.examplesSeen = 0;
+		this.sumOfValues = 0.0;
+		this.sumOfSquares = 0.0;
+
+		this.sumOfAttrValues = new DoubleVector();
+		this.sumOfAttrSquares = new DoubleVector();
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		if (treeRoot != null)
+			treeRoot.describeSubtree(out, indent);
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[] { new Measurement("tree size (leaves)", this.leafNodeCount) };
+	}
+
+	public int calcByteSize() {
+		return (int) SizeOf.fullSizeOf(this);
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		if (treeRoot == null) {
+			return new RegressionPrediction();
+		}
+
+		double prediction = treeRoot.getPrediction(inst);
+
+		return new RegressionPrediction(prediction);
+	}
+
+	public double normalizeTargetValue(double value) {
+		if (examplesSeen > 1) {
+			double sd = Math.sqrt((sumOfSquares - ((sumOfValues * sumOfValues) / examplesSeen)) / examplesSeen);
+			double average = sumOfValues / examplesSeen;
+			if (sd > 0 && examplesSeen > 1)
+				return (value - average) / (3 * sd);
+			else
+				return 0.0;
+		}
+		return 0.0;
+	}
+
+	public double getNormalizedError(Instance inst, double prediction) {
+		double normalPrediction = normalizeTargetValue(prediction);
+		double normalValue = normalizeTargetValue(inst.classValue());
+		return Math.abs(normalValue - normalPrediction);
+	}
+
+	/**
+	 * Method for updating (training) the model using a new instance
+	 */
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		checkRoot();
+
+		examplesSeen += inst.weight();
+		sumOfValues += inst.weight() * inst.classValue();
+		sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
+
+		for (int i = 0; i < inst.numAttributes() - 1; i++) {
+			int aIndex = modelAttIndexToInstanceAttIndex(i, inst);
+			sumOfAttrValues.addToValue(i, inst.weight() * inst.value(aIndex));
+			sumOfAttrSquares.addToValue(i, inst.weight() * inst.value(aIndex) * inst.value(aIndex));
+		}
+
+		double prediction = treeRoot.getPrediction(inst);
+		processInstance(inst, treeRoot, prediction, getNormalizedError(inst, prediction), true, false);
+	}
+
+	public void processInstance(Instance inst, Node node, double prediction, double normalError, boolean growthAllowed,
+			boolean inAlternate) {
+		Node currentNode = node;
+		while (true) {
+			if (currentNode instanceof LeafNode) {
+				((LeafNode) currentNode).learnFromInstance(inst, growthAllowed, this);
+				break;
+			} else {
+				currentNode.examplesSeen += inst.weight();
+				currentNode.sumOfAbsErrors += inst.weight() * normalError;
+				SplitNode iNode = (SplitNode) currentNode;
+				if (!inAlternate && iNode.alternateTree != null) {
+					boolean altTree = true;
+					double lossO = Math.pow(inst.classValue() - prediction, 2);
+					double lossA = Math.pow(inst.classValue() - iNode.alternateTree.getPrediction(inst), 2);
+
+					// Loop for compatibility with bagging methods
+					for (int i = 0; i < inst.weight(); i++) {
+						iNode.lossFadedSumOriginal = lossO
+								+ alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
+						iNode.lossFadedSumAlternate = lossA
+								+ alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
+						iNode.lossExamplesSeen++;
+
+						double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
+						iNode.lossSumQi += Qi;
+						iNode.lossNumQiTests += 1;
+					}
+					double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
+					double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+					double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+
+					if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
+						iNode.previousWeight = iNode.lossExamplesSeen;
+						if (Qi > 0) {
+							// Switch the subtrees
+							Node parent = currentNode.getParent();
+
+							if (parent != null) {
+								Node replacementTree = iNode.alternateTree;
+								parent.setChild(parent.getChildIndex(currentNode), replacementTree);
+								if (growthAllowed)
+									replacementTree.restartChangeDetection();
+							} else {
+								treeRoot = iNode.alternateTree;
+								treeRoot.restartChangeDetection();
+							}
+
+							currentNode = iNode.alternateTree;
+							currentNode.originalNode = null;
+							altTree = false;
+						} else if ((QiAverage < previousQiAverage
+								&& iNode.lossExamplesSeen >= (10 * this.gracePeriodOption.getValue()))
+								|| iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()) {
+							// Remove the alternate tree
+							iNode.alternateTree = null;
+							if (growthAllowed)
+								iNode.restartChangeDetection();
+							altTree = false;
+						}
+					}
+
+					if (altTree) {
+						growthAllowed = false;
+						processInstance(inst, iNode.alternateTree, prediction, normalError, true, true);
+					}
+				}
+
+				if (iNode.changeDetection && !inAlternate) {
+					if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen
+							- PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+						iNode.initializeAlternateTree();
+					}
+				}
+				if (currentNode instanceof SplitNode) {
+					currentNode = ((SplitNode) currentNode).descendOneStep(inst);
+				}
+			}
+		}
+	}
+
+	// endregion --- Regressor methods
+
+	// region --- Object instatiation methods
+
+	protected FIMTDDNumericAttributeClassObserver newNumericClassObserver() {
+		return new FIMTDDNumericAttributeClassObserver();
+	}
+
+	protected SplitNode newSplitNode(InstanceConditionalTest splitTest) {
+		maxID++;
+		return new SplitNode(splitTest, this);
+	}
+
+	protected LeafNode newLeafNode() {
+		maxID++;
+		return new LeafNode(this, this.subspaceSizeOption.getValue());
+	}
+
+	protected FIMTDDPerceptron newLeafModel() {
+		return new FIMTDDPerceptron(this);
+	}
+
+	// endregion --- Object instatiation methods
+
+	// region --- Processing methods
+
+	protected void checkRoot() {
+		if (treeRoot == null) {
+			treeRoot = newLeafNode();
+			leafNodeCount = 1;
+		}
+	}
+
+	public static double computeHoeffdingBound(double range, double confidence, double n) {
+		return Math.sqrt(((range * range) * Math.log(1 / confidence)) / (2.0 * n));
+	}
+
+	public boolean buildingModelTree() {
+		return !regressionTreeOption.isSet();
+	}
+
+	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex) {
+		// Set the split criterion to use to the SDR split criterion as described by
+		// Ikonomovska et al.
+		SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
+
+		// Using this criterion, find the best split per attribute and rank the results
+		AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion);
+		Arrays.sort(bestSplitSuggestions);
+
+		// Declare a variable to determine if any of the splits should be performed
+		boolean shouldSplit = false;
+
+		// If only one split was returned, use it
+		if (bestSplitSuggestions.length < 2) {
+			shouldSplit = bestSplitSuggestions.length > 0;
+		} else { // Otherwise, consider which of the splits proposed may be worth trying
+
+			// Determine the Hoeffding bound value, used to select how many instances should
+			// be used to make a test decision
+			// to feel reasonably confident that the test chosen by this sample is the same
+			// as what would be chosen using infinite examples
+			double hoeffdingBound = computeHoeffdingBound(1, this.splitConfidenceOption.getValue(), node.examplesSeen);
+			// Determine the top two ranked splitting suggestions
+			AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+			AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
+
+			// If the upper bound of the sample mean for the ratio of SDR(best suggestion)
+			// to SDR(second best suggestion),
+			// as determined using the Hoeffding bound, is less than 1, then the true mean
+			// is also less than 1, and thus at this
+			// particular moment of observation the bestSuggestion is indeed the best split
+			// option with confidence 1-delta, and
+			// splitting should occur.
+			// Alternatively, if two or more splits are very similar or identical in terms
+			// of their splits, then a threshold limit
+			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is
+			// smaller than this limit then the two
+			// competing attributes are equally good, and the split will be made on the one
+			// with the higher SDR value.
+			if ((secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound)
+					|| (hoeffdingBound < this.tieThresholdOption.getValue())) {
+				shouldSplit = true;
+			}
+			// If the splitting criterion was not met, initiate pruning of the E-BST
+			// structures in each attribute observer
+			else {
+				for (int i = 0; i < node.attributeObservers.size(); i++) {
+					FIMTDDNumericAttributeClassObserver obs = node.attributeObservers.get(i);
+					if (obs != null) {
+						obs.removeBadSplits(splitCriterion, secondBestSuggestion.merit / bestSuggestion.merit,
+								bestSuggestion.merit, hoeffdingBound);
+					}
+				}
+			}
+		}
+
+		// If the splitting criterion were met, split the current node using the chosen
+		// attribute test, and
+		// make two new branches leading to (empty) leaves
+		if (shouldSplit) {
+			AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+
+			SplitNode newSplit = newSplitNode(splitDecision.splitTest);
+			newSplit.copyStatistics(node);
+			newSplit.changeDetection = node.changeDetection;
+			newSplit.ID = node.ID;
+			leafNodeCount--;
+			for (int i = 0; i < splitDecision.numSplits(); i++) {
+				LeafNode newChild = newLeafNode();
+				if (buildingModelTree()) {
+					// Copy the splitting node's perceptron to it's children
+					newChild.learningModel = new FIMTDDPerceptron(node.learningModel);
+
+				}
+				newChild.changeDetection = node.changeDetection;
+				newChild.setParent(newSplit);
+				newSplit.setChild(i, newChild);
+				leafNodeCount++;
+			}
+			if (parent == null && node.originalNode == null) {
+				treeRoot = newSplit;
+			} else if (parent == null && node.originalNode != null) {
+				node.originalNode.alternateTree = newSplit;
+			} else {
+				((SplitNode) parent).setChild(parentIndex, newSplit);
+				newSplit.setParent(parent);
+			}
+
+			splitNodeCount++;
+		}
+	}
+
+	public double computeSD(double squaredVal, double val, double size) {
+		if (size > 1)
+			return Math.sqrt((squaredVal - ((val * val) / size)) / size);
+		else
+			return 0.0;
+	}
+
+	public double scalarProduct(DoubleVector u, DoubleVector v) {
+		double ret = 0.0;
+		for (int i = 0; i < Math.max(u.numValues(), v.numValues()); i++) {
+			ret += u.getValue(i) * v.getValue(i);
+		}
+		return ret;
+	}
+	// endregion --- Processing methods
+
+	// endregion ================ METHODS ================
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/learners/predictors/trees/ARFHoeffdingTree.java b/moa/src/main/java/moa/learners/predictors/trees/ARFHoeffdingTree.java
new file mode 100644
index 000000000..2be74f590
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/trees/ARFHoeffdingTree.java
@@ -0,0 +1,189 @@
+/*
+ *    ARFHoeffdingTree.java
+ *
+ *    @author Heitor Murilo Gomes (heitor_murilo_gomes at yahoo dot com dot br)
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ */
+
+package moa.learners.predictors.trees;
+
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.core.Utils;
+import moa.learners.predictors.bayes.NaiveBayes;
+import moa.learners.predictors.core.attributeclassobservers.AttributeClassObserver;
+
+/**
+ * Adaptive Random Forest Hoeffding Tree.
+ *
+ * <p>
+ * Adaptive Random Forest Hoeffding Tree. This is the base model for the
+ * Adaptive Random Forest ensemble learner (See
+ * moa.learners.predictors.meta.AdaptiveRandomForest.java). This Hoeffding Tree includes
+ * a subspace size k parameter, which defines the number of randomly selected
+ * features to be considered at each split.
+ * </p>
+ *
+ * <p>
+ * See details in:<br>
+ * Heitor Murilo Gomes, Albert Bifet, Jesse Read, Jean Paul Barddal, Fabricio
+ * Enembreck, Bernhard Pfharinger, Geoff Holmes, Talel Abdessalem. Adaptive
+ * random forests for evolving data stream classification. In Machine Learning,
+ * DOI: 10.1007/s10994-017-5642-8, Springer, 2017.
+ * </p>
+ *
+ * @author Heitor Murilo Gomes (heitor_murilo_gomes at yahoo dot com dot br)
+ * @version $Revision: 1 $
+ */
+public class ARFHoeffdingTree extends HoeffdingTree {
+
+	private static final long serialVersionUID = 1L;
+
+	public IntOption subspaceSizeOption = new IntOption("subspaceSizeSize", 'k',
+			"Number of features per subset for each node split. Negative values = #features - k", 2, Integer.MIN_VALUE,
+			Integer.MAX_VALUE);
+
+	@Override
+	public String getPurposeString() {
+		return "Adaptive Random Forest Hoeffding Tree for data streams. " + "Base learner for AdaptiveRandomForest.";
+	}
+
+	public static class RandomLearningNode extends ActiveLearningNode {
+
+		private static final long serialVersionUID = 1L;
+
+		protected int[] listAttributes;
+
+		protected int numAttributes;
+
+		public RandomLearningNode(double[] initialClassObservations, int subspaceSize) {
+			super(initialClassObservations);
+			this.numAttributes = subspaceSize;
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, HoeffdingTree ht) {
+			this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight());
+			if (this.listAttributes == null) {
+				this.listAttributes = new int[this.numAttributes];
+				for (int j = 0; j < this.numAttributes; j++) {
+					boolean isUnique = false;
+					while (isUnique == false) {
+						this.listAttributes[j] = ht.classifierRandom.nextInt(inst.numAttributes() - 1);
+						isUnique = true;
+						for (int i = 0; i < j; i++) {
+							if (this.listAttributes[j] == this.listAttributes[i]) {
+								isUnique = false;
+								break;
+							}
+						}
+					}
+
+				}
+			}
+			for (int j = 0; j < this.numAttributes - 1; j++) {
+				int i = this.listAttributes[j];
+				int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
+				AttributeClassObserver obs = this.attributeObservers.get(i);
+				if (obs == null) {
+					obs = inst.attribute(instAttIndex).isNominal() ? ht.newNominalClassObserver()
+							: ht.newNumericClassObserver();
+					this.attributeObservers.set(i, obs);
+				}
+				obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
+			}
+		}
+	}
+
+	public static class LearningNodeNB extends RandomLearningNode {
+
+		private static final long serialVersionUID = 1L;
+
+		public LearningNodeNB(double[] initialClassObservations, int subspaceSize) {
+			super(initialClassObservations, subspaceSize);
+		}
+
+		@Override
+		public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
+			if (getWeightSeen() >= ht.nbThresholdOption.getValue()) {
+				return NaiveBayes.doNaiveBayesPrediction(inst, this.observedClassDistribution, this.attributeObservers);
+			}
+			return super.getClassVotes(inst, ht);
+		}
+
+		@Override
+		public void disableAttribute(int attIndex) {
+			// should not disable poor atts - they are used in NB calc
+		}
+	}
+
+	public static class LearningNodeNBAdaptive extends LearningNodeNB {
+
+		private static final long serialVersionUID = 1L;
+
+		protected double mcCorrectWeight = 0.0;
+
+		protected double nbCorrectWeight = 0.0;
+
+		public LearningNodeNBAdaptive(double[] initialClassObservations, int subspaceSize) {
+			super(initialClassObservations, subspaceSize);
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, HoeffdingTree ht) {
+			int trueClass = (int) inst.classValue();
+			if (this.observedClassDistribution.maxIndex() == trueClass) {
+				this.mcCorrectWeight += inst.weight();
+			}
+			if (Utils.maxIndex(NaiveBayes.doNaiveBayesPrediction(inst, this.observedClassDistribution,
+					this.attributeObservers)) == trueClass) {
+				this.nbCorrectWeight += inst.weight();
+			}
+			super.learnFromInstance(inst, ht);
+		}
+
+		@Override
+		public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
+			if (this.mcCorrectWeight > this.nbCorrectWeight) {
+				return this.observedClassDistribution.getArrayCopy();
+			}
+			return NaiveBayes.doNaiveBayesPrediction(inst, this.observedClassDistribution, this.attributeObservers);
+		}
+	}
+
+	public ARFHoeffdingTree() {
+		this.removePoorAttsOption = null;
+	}
+
+	@Override
+	protected LearningNode newLearningNode(double[] initialClassObservations) {
+		LearningNode ret;
+		int predictionOption = this.leafpredictionOption.getChosenIndex();
+		if (predictionOption == 0) { // MC
+			ret = new RandomLearningNode(initialClassObservations, this.subspaceSizeOption.getValue());
+		} else if (predictionOption == 1) { // NB
+			ret = new LearningNodeNB(initialClassObservations, this.subspaceSizeOption.getValue());
+		} else { // NBAdaptive
+			ret = new LearningNodeNBAdaptive(initialClassObservations, this.subspaceSizeOption.getValue());
+		}
+		return ret;
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/trees/ASHoeffdingTree.java b/moa/src/main/java/moa/learners/predictors/trees/ASHoeffdingTree.java
new file mode 100644
index 000000000..708fffb00
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/trees/ASHoeffdingTree.java
@@ -0,0 +1,184 @@
+/*
+ *    ASHoeffdingTree.java
+ *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.trees;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+/**
+ * Adaptive Size Hoeffding Tree used in Bagging using trees of different size.
+ * The Adaptive-Size Hoeffding Tree (ASHT) is derived from the Hoeffding Tree
+ * algorithm with the following differences:
+ * <ul>
+ * <li>it has a maximum number of split nodes, or size
+ * <li>after one node splits, if the number of split nodes of the ASHT tree is
+ * higher than the maximum value, then it deletes some nodes to reduce its size
+ * </ul>
+ * The intuition behind this method is as follows: smaller trees adapt more
+ * quickly to changes, and larger trees do better during periods with no or
+ * little change, simply because they were built on more data. Trees limited to
+ * size s will be reset about twice as often as trees with a size limit of 2s.
+ * This creates a set of different reset-speeds for an ensemble of such trees,
+ * and therefore a subset of trees that are a good approximation for the current
+ * rate of change. It is important to note that resets will happen all the time,
+ * even for stationary datasets, but this behaviour should not have a negative
+ * impact on the ensemble’s predictive performance. When the tree size exceeds
+ * the maximun size value, there are two different delete options:
+ * <ul>
+ * <li>delete the oldest node, the root, and all of its children except the one
+ * where the split has been made. After that, the root of the child not deleted
+ * becomes the new root
+ * <li>delete all the nodes of the tree, i.e., restart from a new root.
+ * </ul>
+ * The maximum allowed size for the n-th ASHT tree is twice the maximum allowed
+ * size for the (n-1)-th tree. Moreover, each tree has a weight proportional to
+ * the inverse of the square of its error, and it monitors its error with an
+ * exponential weighted moving average (EWMA) with alpha = .01. The size of the
+ * first tree is 2. <br/>
+ * <br/>
+ * With this new method, it is attempted to improve bagging performance by
+ * increasing tree diversity. It has been observed that boosting tends to
+ * produce a more diverse set of classifiers than bagging, and this has been
+ * cited as a factor in increased performance.<br/>
+ * See more details in:<br/>
+ * <br/>
+ * Albert Bifet, Geoff Holmes, Bernhard Pfahringer, Richard Kirkby, and Ricard
+ * Gavaldà. New ensemble methods for evolving data streams. In 15th ACM SIGKDD
+ * International Conference on Knowledge Discovery and Data Mining, 2009.<br/>
+ * <br/>
+ * The learner must be ASHoeffdingTree, a Hoeffding Tree with a maximum size
+ * value.<br/>
+ * <br/>
+ * Example:<br/>
+ * <br/>
+ * <code>OzaBagASHT -l ASHoeffdingTree -s 10 -u -r </code> Parameters:
+ * <ul>
+ * <li>Same parameters as <code>OzaBag</code>
+ * <li>-f : the size of first classifier in the bag.
+ * <li>-u : Enable weight classifiers
+ * <li>-r : Reset trees when size is higher than the max
+ * </ul>
+ *
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @version $Revision: 7 $
+ */
+public class ASHoeffdingTree extends HoeffdingTree {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Adaptive Size Hoeffding Tree used in Bagging using trees of different size.";
+	}
+
+	protected int maxSize = 10000; // EXTENSION TO ASHT
+
+	protected boolean resetTree = false;
+
+	@Override
+	public void resetLearningImpl() {
+		this.treeRoot = null;
+		this.decisionNodeCount = 0;
+		this.activeLeafNodeCount = 0;
+		this.inactiveLeafNodeCount = 0;
+		this.inactiveLeafByteSizeEstimate = 0.0;
+		this.activeLeafByteSizeEstimate = 0.0;
+		this.byteSizeEstimateOverheadFraction = 1.0;
+		this.growthAllowed = true;
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		if (this.treeRoot == null) {
+			this.treeRoot = newLearningNode();
+			this.activeLeafNodeCount = 1;
+		}
+		FoundNode foundNode = this.treeRoot.filterInstanceToLeaf(inst, null, -1);
+		Node leafNode = foundNode.node;
+		if (leafNode == null) {
+			leafNode = newLearningNode();
+			foundNode.parent.setChild(foundNode.parentBranch, leafNode);
+			this.activeLeafNodeCount++;
+		}
+		if (leafNode instanceof LearningNode) {
+			LearningNode learningNode = (LearningNode) leafNode;
+			learningNode.learnFromInstance(inst, this);
+			if (this.growthAllowed && (learningNode instanceof ActiveLearningNode)) {
+				ActiveLearningNode activeLearningNode = (ActiveLearningNode) learningNode;
+				double weightSeen = activeLearningNode.getWeightSeen();
+				if (weightSeen - activeLearningNode.getWeightSeenAtLastSplitEvaluation() >= this.gracePeriodOption
+						.getValue()) {
+					attemptToSplit(activeLearningNode, foundNode.parent, foundNode.parentBranch);
+					// EXTENSION TO ASHT
+					// if size too big, resize tree ONLY Split Nodes
+					while (this.decisionNodeCount >= this.maxSize && this.treeRoot instanceof SplitNode) {
+						if (this.resetTree == false) {
+							resizeTree(this.treeRoot, ((SplitNode) this.treeRoot).instanceChildIndex(inst));
+							this.treeRoot = ((SplitNode) this.treeRoot)
+									.getChild(((SplitNode) this.treeRoot).instanceChildIndex(inst));
+						} else {
+							resetLearningImpl();
+						}
+					}
+					activeLearningNode.setWeightSeenAtLastSplitEvaluation(weightSeen);
+				}
+			}
+		}
+		if (this.trainingWeightSeenByModel % this.memoryEstimatePeriodOption.getValue() == 0) {
+			estimateModelByteSizes();
+		}
+	}
+
+	// EXTENSION TO ASHT
+	public void setMaxSize(int mSize) {
+		this.maxSize = mSize;
+	}
+
+	public void setResetTree() {
+		this.resetTree = true;
+	}
+
+	public void deleteNode(Node node, int childIndex) {
+		Node child = ((SplitNode) node).getChild(childIndex);
+		// if (child != null) {
+		// }
+		if (child instanceof SplitNode) {
+			for (int branch = 0; branch < ((SplitNode) child).numChildren(); branch++) {
+				deleteNode(child, branch);
+			}
+			this.decisionNodeCount--;
+		} else if (child instanceof InactiveLearningNode) {
+			this.inactiveLeafNodeCount--;
+		} else if (child instanceof ActiveLearningNode) {
+			this.activeLeafNodeCount--;
+		}
+		child = null;
+	}
+
+	public void resizeTree(Node node, int childIndex) {
+		// Assume that this is root node
+		if (node instanceof SplitNode) {
+			for (int branch = 0; branch < ((SplitNode) node).numChildren(); branch++) {
+				if (branch != childIndex) {
+					deleteNode(node, branch);
+				}
+			}
+		}
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/trees/AdaHoeffdingOptionTree.java b/moa/src/main/java/moa/learners/predictors/trees/AdaHoeffdingOptionTree.java
new file mode 100644
index 000000000..54355dc4c
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/trees/AdaHoeffdingOptionTree.java
@@ -0,0 +1,115 @@
+/*
+ *    AdaHoeffdingOptionTree.java
+ *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.trees;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.core.Utils;
+import moa.learners.predictors.bayes.NaiveBayes;
+
+/**
+ * Adaptive decision option tree for streaming data with adaptive Naive Bayes
+ * classification at leaves. An Adaptive Hoeffding Option Tree is a Hoeffding
+ * Option Tree with the following improvement: each leaf stores an estimation of
+ * the current error. It uses an EWMA estimator with alpha = .2. The weight of
+ * each node in the voting process is proportional to the square of the inverse
+ * of the error. <br/>
+ * <br/>
+ * Example:<br/>
+ * <code>AdaHoeffdingOptionTree -o 50 </code> Parameters:
+ * <ul>
+ * <li>Same parameters as <code>HoeffdingOptionTreeNB<code>
+ * </ul>
+ *
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @version $Revision: 7 $
+ */
+public class AdaHoeffdingOptionTree extends HoeffdingOptionTree {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Adaptive decision option tree for streaming data with adaptive Naive Bayes classification at leaves.";
+	}
+
+	public static class AdaLearningNode extends LearningNodeNB {
+
+		private static final long serialVersionUID = 1L;
+
+		protected double mcCorrectWeight = 0.0;
+
+		protected double nbCorrectWeight = 0.0;
+
+		protected double CorrectWeight = 0.0;
+
+		protected double alpha = 0.2;
+
+		public AdaLearningNode(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, HoeffdingOptionTree hot) {
+			int trueClass = (int) inst.classValue();
+			boolean blCorrect = false;
+			if (this.observedClassDistribution.maxIndex() == trueClass) {
+				this.mcCorrectWeight += inst.weight();
+				if (this.mcCorrectWeight > this.nbCorrectWeight) {
+					blCorrect = true;
+				}
+			}
+			if (Utils.maxIndex(NaiveBayes.doNaiveBayesPrediction(inst, this.observedClassDistribution,
+					this.attributeObservers)) == trueClass) {
+				this.nbCorrectWeight += inst.weight();
+				if (this.mcCorrectWeight <= this.nbCorrectWeight) {
+					blCorrect = true;
+				}
+			}
+			if (blCorrect == true) {
+				this.CorrectWeight += alpha * (1.0 - this.CorrectWeight); // EWMA
+			} else {
+				this.CorrectWeight -= alpha * this.CorrectWeight; // EWMA
+			}
+			super.learnFromInstance(inst, hot);
+		}
+
+		@Override
+		public double[] getClassVotes(Instance inst, HoeffdingOptionTree ht) {
+			double[] dist;
+			if (this.mcCorrectWeight > this.nbCorrectWeight) {
+				dist = this.observedClassDistribution.getArrayCopy();
+			} else {
+				dist = NaiveBayes.doNaiveBayesPrediction(inst, this.observedClassDistribution, this.attributeObservers);
+			}
+			double distSum = Utils.sum(dist);
+			if (distSum * (1.0 - this.CorrectWeight) * (1.0 - this.CorrectWeight) > 0.0) {
+				Utils.normalize(dist, distSum * (1.0 - this.CorrectWeight) * (1.0 - this.CorrectWeight)); // Adding
+																											// weight
+			}
+			return dist;
+		}
+	}
+
+	@Override
+	protected LearningNode newLearningNode(double[] initialClassObservations) {
+		return new AdaLearningNode(initialClassObservations);
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/trees/DecisionStump.java b/moa/src/main/java/moa/learners/predictors/trees/DecisionStump.java
new file mode 100644
index 000000000..193493e81
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/trees/DecisionStump.java
@@ -0,0 +1,157 @@
+/*
+ *    DecisionStump.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.trees;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.core.AttributeSplitSuggestion;
+import moa.learners.predictors.core.attributeclassobservers.AttributeClassObserver;
+import moa.learners.predictors.core.attributeclassobservers.GaussianNumericAttributeClassObserver;
+import moa.learners.predictors.core.attributeclassobservers.NominalAttributeClassObserver;
+import moa.learners.predictors.core.splitcriteria.SplitCriterion;
+import moa.options.ClassOption;
+
+/**
+ * Decision trees of one level.<br />
+ *
+ * Parameters:
+ * </p>
+ * <ul>
+ * <li>-g : The number of instances to observe between model changes</li>
+ * <li>-b : Only allow binary splits</li>
+ * <li>-c : Split criterion to use. Example : InfoGainSplitCriterion</li>
+ * <li>-r : Seed for random behaviour of the classifier</li>
+ * </ul>
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public class DecisionStump extends AbstractClassifier implements Classifier {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Decision trees of one level.";
+	}
+
+	public IntOption gracePeriodOption = new IntOption("gracePeriod", 'g',
+			"The number of instances to observe between model changes.", 1000, 0, Integer.MAX_VALUE);
+
+	public FlagOption binarySplitsOption = new FlagOption("binarySplits", 'b', "Only allow binary splits.");
+
+	public ClassOption splitCriterionOption = new ClassOption("splitCriterion", 'c', "Split criterion to use.",
+			SplitCriterion.class, "InfoGainSplitCriterion");
+
+	protected AttributeSplitSuggestion bestSplit;
+
+	protected DoubleVector observedClassDistribution;
+
+	protected AutoExpandVector<AttributeClassObserver> attributeObservers;
+
+	protected double weightSeenAtLastSplit;
+
+	@Override
+	public void resetLearningImpl() {
+		this.bestSplit = null;
+		this.observedClassDistribution = new DoubleVector();
+		this.attributeObservers = new AutoExpandVector<>();
+		this.weightSeenAtLastSplit = 0.0;
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return null;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight());
+		for (int i = 0; i < inst.numAttributes() - 1; i++) {
+			int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
+			AttributeClassObserver obs = this.attributeObservers.get(i);
+			if (obs == null) {
+				obs = inst.attribute(instAttIndex).isNominal() ? newNominalClassObserver() : newNumericClassObserver();
+				this.attributeObservers.set(i, obs);
+			}
+			obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
+		}
+		if (this.trainingWeightSeenByModel - this.weightSeenAtLastSplit >= this.gracePeriodOption.getValue()) {
+			this.bestSplit = findBestSplit((SplitCriterion) getPreparedClassOption(this.splitCriterionOption));
+			this.weightSeenAtLastSplit = this.trainingWeightSeenByModel;
+		}
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		if (this.bestSplit != null) {
+			int branch = this.bestSplit.splitTest.branchForInstance(inst);
+			if (branch >= 0) {
+				return new ClassificationPrediction(this.bestSplit.resultingClassDistributionFromSplit(branch));
+			}
+		}
+		return new ClassificationPrediction(observedClassDistribution.getArrayCopy());
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+
+	protected AttributeClassObserver newNominalClassObserver() {
+		return new NominalAttributeClassObserver();
+	}
+
+	protected AttributeClassObserver newNumericClassObserver() {
+		return new GaussianNumericAttributeClassObserver();
+	}
+
+	protected AttributeSplitSuggestion findBestSplit(SplitCriterion criterion) {
+		AttributeSplitSuggestion bestFound = null;
+		double bestMerit = Double.NEGATIVE_INFINITY;
+		double[] preSplitDist = this.observedClassDistribution.getArrayCopy();
+		for (int i = 0; i < this.attributeObservers.size(); i++) {
+			AttributeClassObserver obs = this.attributeObservers.get(i);
+			if (obs != null) {
+				AttributeSplitSuggestion suggestion = obs.getBestEvaluatedSplitSuggestion(criterion, preSplitDist, i,
+						this.binarySplitsOption.isSet());
+				if (suggestion != null && suggestion.merit > bestMerit) {
+					bestMerit = suggestion.merit;
+					bestFound = suggestion;
+				}
+			}
+		}
+		return bestFound;
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/trees/EFDT.java b/moa/src/main/java/moa/learners/predictors/trees/EFDT.java
new file mode 100644
index 000000000..d91e70c5f
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/trees/EFDT.java
@@ -0,0 +1,1536 @@
+/*
+ *    RandomHoeffdingTree.java
+ *    Copyright (C) 2019 University of Waikato, Hamilton, New Zealand
+ *    @author Chaitanya Manapragada
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/*
+ * Author: Chaitanya Manapragada.
+ * <p>
+ * Based on HoeffdingTree.java by Richard Kirkby.
+ * <p>
+ * There is a lot of code repetition from VFDT.java. This needs to be fixed as per DRY principles.
+ * <p>
+ * Research code written to test the EFDT idea.
+ * <p>
+ * Bug-fixed version of Richard Kirkby's  HoeffdingTree.Java written by Chaitanya Manapragada.
+ * <p>
+ * Bug1 : average delta G's are computed where specified in the Domingos/Hulten paper algorithm listing. This was a bug in the HoeffdingTree.java implementation- fixed here.
+ * <p>
+ * Bug2: splitting was occurring when the top attribute had no IG, and splitting was occurring on the same attribute. This was also fixed.
+ * <p>
+ * The correct reference is:
+ * Domingos, P., & Hulten, G. (2000, August). Mining high-speed data streams. In Proceedings of the sixth ACM SIGKDD international conference on Knowledge discovery and data mining (pp. 71-80). ACM.
+ */
+
+package moa.learners.predictors.trees;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.AbstractMOAObject;
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.SizeOf;
+import moa.core.StringUtils;
+import moa.core.Utils;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.bayes.NaiveBayes;
+import moa.learners.predictors.core.AttributeSplitSuggestion;
+import moa.learners.predictors.core.attributeclassobservers.AttributeClassObserver;
+import moa.learners.predictors.core.attributeclassobservers.DiscreteAttributeClassObserver;
+import moa.learners.predictors.core.attributeclassobservers.NullAttributeClassObserver;
+import moa.learners.predictors.core.attributeclassobservers.NumericAttributeClassObserver;
+import moa.learners.predictors.core.conditionaltests.InstanceConditionalTest;
+import moa.learners.predictors.core.conditionaltests.NominalAttributeBinaryTest;
+import moa.learners.predictors.core.conditionaltests.NominalAttributeMultiwayTest;
+import moa.learners.predictors.core.conditionaltests.NumericAttributeBinaryTest;
+import moa.learners.predictors.core.splitcriteria.SplitCriterion;
+import moa.options.ClassOption;
+
+public class EFDT extends AbstractClassifier implements Classifier {
+
+	private static final long serialVersionUID = 2L;
+
+	public IntOption reEvalPeriodOption = new IntOption("reevaluationPeriod", 'R',
+			"The number of instances an internal node should observe between re-evaluation attempts.", 2000, 0,
+			Integer.MAX_VALUE);
+
+	public IntOption maxByteSizeOption = new IntOption("maxByteSize", 'm', "Maximum memory consumed by the tree.",
+			33554432, 0, Integer.MAX_VALUE);
+
+	/*
+	 * public MultiChoiceOption numericEstimatorOption = new MultiChoiceOption(
+	 * "numericEstimator", 'n', "Numeric estimator to use.", new String[]{
+	 * "GAUSS10", "GAUSS100", "GK10", "GK100", "GK1000", "VFML10", "VFML100",
+	 * "VFML1000", "BINTREE"}, new String[]{ "Gaussian approximation evaluating 10
+	 * splitpoints", "Gaussian approximation evaluating 100 splitpoints",
+	 * "Greenwald-Khanna quantile summary with 10 tuples", "Greenwald-Khanna
+	 * quantile summary with 100 tuples", "Greenwald-Khanna quantile summary with
+	 * 1000 tuples", "VFML method with 10 bins", "VFML method with 100 bins", "VFML
+	 * method with 1000 bins", "Exhaustive binary tree"}, 0);
+	 */
+	public ClassOption numericEstimatorOption = new ClassOption("numericEstimator", 'n', "Numeric estimator to use.",
+			NumericAttributeClassObserver.class, "GaussianNumericAttributeClassObserver");
+
+	public ClassOption nominalEstimatorOption = new ClassOption("nominalEstimator", 'd', "Nominal estimator to use.",
+			DiscreteAttributeClassObserver.class, "NominalAttributeClassObserver");
+
+	public IntOption memoryEstimatePeriodOption = new IntOption("memoryEstimatePeriod", 'e',
+			"How many instances between memory consumption checks.", 1000000, 0, Integer.MAX_VALUE);
+
+	public IntOption gracePeriodOption = new IntOption("gracePeriod", 'g',
+			"The number of instances a leaf should observe between split attempts.", 200, 0, Integer.MAX_VALUE);
+
+	public ClassOption splitCriterionOption = new ClassOption("splitCriterion", 's', "Split criterion to use.",
+			SplitCriterion.class, "InfoGainSplitCriterion");
+
+	public FloatOption splitConfidenceOption = new FloatOption("splitConfidence", 'c',
+			"The allowable error in split decision, values closer to 0 will take longer to decide.", 0.0000001, 0.0,
+			1.0);
+
+	public FloatOption tieThresholdOption = new FloatOption("tieThreshold", 't',
+			"Threshold below which a split will be forced to break ties.", 0.05, 0.0, 1.0);
+
+	public FlagOption binarySplitsOption = new FlagOption("binarySplits", 'b', "Only allow binary splits.");
+
+	public FlagOption stopMemManagementOption = new FlagOption("stopMemManagement", 'z',
+			"Stop growing as soon as memory limit is hit.");
+
+	public FlagOption removePoorAttsOption = new FlagOption("removePoorAtts", 'r', "Disable poor attributes.");
+
+	public FlagOption noPrePruneOption = new FlagOption("noPrePrune", 'p', "Disable pre-pruning.");
+
+	public MultiChoiceOption leafpredictionOption = new MultiChoiceOption("leafprediction", 'l',
+			"Leaf prediction to use.", new String[] { "MC", "NB", "NBAdaptive" },
+			new String[] { "Majority class", "Naive Bayes", "Naive Bayes Adaptive" }, 2);
+
+	public IntOption nbThresholdOption = new IntOption("nbThreshold", 'q',
+			"The number of instances a leaf should observe before permitting Naive Bayes.", 0, 0, Integer.MAX_VALUE);
+
+	protected Node treeRoot = null;
+
+	protected int decisionNodeCount;
+
+	protected int activeLeafNodeCount;
+
+	protected int inactiveLeafNodeCount;
+
+	protected double inactiveLeafByteSizeEstimate;
+
+	protected double activeLeafByteSizeEstimate;
+
+	protected double byteSizeEstimateOverheadFraction;
+
+	protected boolean growthAllowed;
+
+	protected int numInstances = 0;
+
+	protected int splitCount = 0;
+
+	@Override
+	public String getPurposeString() {
+		return "Hoeffding Tree or VFDT.";
+	}
+
+	public int calcByteSize() {
+		int size = (int) SizeOf.sizeOf(this);
+		if (this.treeRoot != null) {
+			size += this.treeRoot.calcByteSizeIncludingSubtree();
+		}
+		return size;
+	}
+
+	@Override
+	public long measureByteSize() {
+		return calcByteSize();
+	}
+
+	@Override
+	public void resetLearningImpl() {
+		this.treeRoot = null;
+		this.decisionNodeCount = 0;
+		this.activeLeafNodeCount = 0;
+		this.inactiveLeafNodeCount = 0;
+		this.inactiveLeafByteSizeEstimate = 0.0;
+		this.activeLeafByteSizeEstimate = 0.0;
+		this.byteSizeEstimateOverheadFraction = 1.0;
+		this.growthAllowed = true;
+		if (this.leafpredictionOption.getChosenIndex() > 0) {
+			this.removePoorAttsOption = null;
+		}
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		if (this.treeRoot != null) {
+			FoundNode foundNode = this.treeRoot.filterInstanceToLeaf(inst, null, -1);
+			Node leafNode = foundNode.node;
+			if (leafNode == null) {
+				leafNode = foundNode.parent;
+			}
+			return new ClassificationPrediction(leafNode.getClassVotes(inst, this));
+		} else {
+			int numClasses = inst.dataset().numClasses();
+			return new ClassificationPrediction(new double[numClasses]);
+		}
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		FoundNode[] learningNodes = findLearningNodes();
+
+		return new Measurement[] {
+
+				new Measurement("tree size (nodes)",
+						this.decisionNodeCount + this.activeLeafNodeCount + this.inactiveLeafNodeCount),
+				new Measurement("tree size (leaves)", learningNodes.length),
+				new Measurement("active learning leaves", this.activeLeafNodeCount),
+				new Measurement("tree depth", measureTreeDepth()),
+				new Measurement("active leaf byte size estimate", this.activeLeafByteSizeEstimate),
+				new Measurement("inactive leaf byte size estimate", this.inactiveLeafByteSizeEstimate),
+				new Measurement("byte size estimate overhead", this.byteSizeEstimateOverheadFraction),
+				new Measurement("splits", this.splitCount) };
+	}
+
+	public int measureTreeDepth() {
+		if (this.treeRoot != null) {
+			return this.treeRoot.subtreeDepth();
+		}
+		return 0;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		this.treeRoot.describeSubtree(this, out, indent);
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+
+	public static double computeHoeffdingBound(double range, double confidence, double n) {
+		return Math.sqrt(((range * range) * Math.log(1.0 / confidence)) / (2.0 * n));
+	}
+
+	protected AttributeClassObserver newNominalClassObserver() {
+		AttributeClassObserver nominalClassObserver = (AttributeClassObserver) getPreparedClassOption(
+				this.nominalEstimatorOption);
+		return (AttributeClassObserver) nominalClassObserver.copy();
+	}
+
+	protected AttributeClassObserver newNumericClassObserver() {
+		AttributeClassObserver numericClassObserver = (AttributeClassObserver) getPreparedClassOption(
+				this.numericEstimatorOption);
+		return (AttributeClassObserver) numericClassObserver.copy();
+	}
+
+	public void enforceTrackerLimit() {
+		if ((this.inactiveLeafNodeCount > 0) || ((this.activeLeafNodeCount * this.activeLeafByteSizeEstimate
+				+ this.inactiveLeafNodeCount * this.inactiveLeafByteSizeEstimate)
+				* this.byteSizeEstimateOverheadFraction > this.maxByteSizeOption.getValue())) {
+			if (this.stopMemManagementOption.isSet()) {
+				this.growthAllowed = false;
+				return;
+			}
+			FoundNode[] learningNodes = findLearningNodes();
+			Arrays.sort(learningNodes, new Comparator<FoundNode>() {
+
+				@Override
+				public int compare(FoundNode fn1, FoundNode fn2) {
+					return Double.compare(fn1.node.calculatePromise(), fn2.node.calculatePromise());
+				}
+			});
+			int maxActive = 0;
+			while (maxActive < learningNodes.length) {
+				maxActive++;
+				if ((maxActive * this.activeLeafByteSizeEstimate
+						+ (learningNodes.length - maxActive) * this.inactiveLeafByteSizeEstimate)
+						* this.byteSizeEstimateOverheadFraction > this.maxByteSizeOption.getValue()) {
+					maxActive--;
+					break;
+				}
+			}
+			int cutoff = learningNodes.length - maxActive;
+			for (int i = 0; i < cutoff; i++) {
+				if (learningNodes[i].node instanceof ActiveLearningNode) {
+					deactivateLearningNode((ActiveLearningNode) learningNodes[i].node, learningNodes[i].parent,
+							learningNodes[i].parentBranch);
+				}
+			}
+			for (int i = cutoff; i < learningNodes.length; i++) {
+				if (learningNodes[i].node instanceof InactiveLearningNode) {
+					activateLearningNode((InactiveLearningNode) learningNodes[i].node, learningNodes[i].parent,
+							learningNodes[i].parentBranch);
+				}
+			}
+		}
+	}
+
+	public void estimateModelByteSizes() {
+		FoundNode[] learningNodes = findLearningNodes();
+		long totalActiveSize = 0;
+		long totalInactiveSize = 0;
+		for (FoundNode foundNode : learningNodes) {
+			if (foundNode.node instanceof ActiveLearningNode) {
+				totalActiveSize += SizeOf.fullSizeOf(foundNode.node);
+			} else {
+				totalInactiveSize += SizeOf.fullSizeOf(foundNode.node);
+			}
+		}
+		if (totalActiveSize > 0) {
+			this.activeLeafByteSizeEstimate = (double) totalActiveSize / this.activeLeafNodeCount;
+		}
+		if (totalInactiveSize > 0) {
+			this.inactiveLeafByteSizeEstimate = (double) totalInactiveSize / this.inactiveLeafNodeCount;
+		}
+		long actualModelSize = this.measureByteSize();
+		double estimatedModelSize = (this.activeLeafNodeCount * this.activeLeafByteSizeEstimate
+				+ this.inactiveLeafNodeCount * this.inactiveLeafByteSizeEstimate);
+		this.byteSizeEstimateOverheadFraction = actualModelSize / estimatedModelSize;
+		if (actualModelSize > this.maxByteSizeOption.getValue()) {
+			enforceTrackerLimit();
+		}
+	}
+
+	public void deactivateAllLeaves() {
+		FoundNode[] learningNodes = findLearningNodes();
+		for (FoundNode learningNode : learningNodes) {
+			if (learningNode.node instanceof ActiveLearningNode) {
+				deactivateLearningNode((ActiveLearningNode) learningNode.node, learningNode.parent,
+						learningNode.parentBranch);
+			}
+		}
+	}
+
+	protected void deactivateLearningNode(ActiveLearningNode toDeactivate, SplitNode parent, int parentBranch) {
+		Node newLeaf = new InactiveLearningNode(toDeactivate.getObservedClassDistribution());
+		if (parent == null) {
+			this.treeRoot = newLeaf;
+		} else {
+			parent.setChild(parentBranch, newLeaf);
+		}
+		this.activeLeafNodeCount--;
+		this.inactiveLeafNodeCount++;
+	}
+
+	protected void activateLearningNode(InactiveLearningNode toActivate, SplitNode parent, int parentBranch) {
+		Node newLeaf = newLearningNode(toActivate.getObservedClassDistribution());
+		if (parent == null) {
+			this.treeRoot = newLeaf;
+		} else {
+			parent.setChild(parentBranch, newLeaf);
+		}
+		this.activeLeafNodeCount++;
+		this.inactiveLeafNodeCount--;
+	}
+
+	protected FoundNode[] findLearningNodes() {
+		List<FoundNode> foundList = new LinkedList<>();
+		findLearningNodes(this.treeRoot, null, -1, foundList);
+		return foundList.toArray(new FoundNode[foundList.size()]);
+	}
+
+	protected void findLearningNodes(Node node, SplitNode parent, int parentBranch, List<FoundNode> found) {
+		if (node != null) {
+			if (node instanceof LearningNode) {
+				found.add(new FoundNode(node, parent, parentBranch));
+			}
+			if (node instanceof SplitNode) {
+				SplitNode splitNode = (SplitNode) node;
+				for (int i = 0; i < splitNode.numChildren(); i++) {
+					findLearningNodes(splitNode.getChild(i), splitNode, i, found);
+				}
+			}
+		}
+	}
+
+	protected void attemptToSplit(ActiveLearningNode node, SplitNode parent, int parentIndex) {
+
+		if (!node.observedClassDistributionIsPure()) {
+			node.addToSplitAttempts(1); // even if we don't actually attempt to split, we've computed infogains
+
+			SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
+			AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion, this);
+			Arrays.sort(bestSplitSuggestions);
+			boolean shouldSplit = false;
+
+			for (AttributeSplitSuggestion bestSplitSuggestion : bestSplitSuggestions) {
+
+				if (bestSplitSuggestion.splitTest != null) {
+					if (!node.getInfogainSum().containsKey((bestSplitSuggestion.splitTest.getAttsTestDependsOn()[0]))) {
+						node.getInfogainSum().put((bestSplitSuggestion.splitTest.getAttsTestDependsOn()[0]), 0.0);
+					}
+					double currentSum = node.getInfogainSum()
+							.get((bestSplitSuggestion.splitTest.getAttsTestDependsOn()[0]));
+					node.getInfogainSum().put((bestSplitSuggestion.splitTest.getAttsTestDependsOn()[0]),
+							currentSum + bestSplitSuggestion.merit);
+				}
+
+				else { // handle the null attribute
+					double currentSum = node.getInfogainSum().get(-1); // null split
+					node.getInfogainSum().put(-1, Math.max(0.0, currentSum + bestSplitSuggestion.merit));
+					assert node.getInfogainSum().get(-1) >= 0.0 : "Negative infogain shouldn't be possible here.";
+				}
+
+			}
+
+			if (bestSplitSuggestions.length < 2) {
+				shouldSplit = bestSplitSuggestions.length > 0;
+			}
+
+			else {
+				double hoeffdingBound = computeHoeffdingBound(
+						splitCriterion.getRangeOfMerit(node.getObservedClassDistribution()),
+						this.splitConfidenceOption.getValue(), node.getWeightSeen());
+				AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+
+				double bestSuggestionAverageMerit;
+				double currentAverageMerit = node.getInfogainSum().get(-1) / node.getNumSplitAttempts();
+
+				// because this is an unsplit leaf. current average merit should be always zero
+				// on the null split.
+
+				if (bestSuggestion.splitTest == null) { // if you have a null split
+					bestSuggestionAverageMerit = node.getInfogainSum().get(-1) / node.getNumSplitAttempts();
+				} else {
+					bestSuggestionAverageMerit = node.getInfogainSum()
+							.get((bestSuggestion.splitTest.getAttsTestDependsOn()[0])) / node.getNumSplitAttempts();
+				}
+
+				if (bestSuggestion.merit < 1e-10) {
+					shouldSplit = false; // we don't use average here
+				}
+
+				else if ((bestSuggestionAverageMerit - currentAverageMerit) > hoeffdingBound
+						|| (hoeffdingBound < this.tieThresholdOption.getValue())) {
+					if (bestSuggestionAverageMerit - currentAverageMerit < hoeffdingBound) {
+						// Placeholder to list this possibility
+					}
+					shouldSplit = true;
+				}
+
+				if (shouldSplit) {
+					for (Integer i : node.usedNominalAttributes) {
+						if (bestSuggestion.splitTest.getAttsTestDependsOn()[0] == i) {
+							shouldSplit = false;
+							break;
+						}
+					}
+				}
+
+				// }
+				if ((this.removePoorAttsOption != null) && this.removePoorAttsOption.isSet()) {
+					Set<Integer> poorAtts = new HashSet<>();
+					// scan 1 - add any poor to set
+					for (AttributeSplitSuggestion bestSplitSuggestion : bestSplitSuggestions) {
+						if (bestSplitSuggestion.splitTest != null) {
+							int[] splitAtts = bestSplitSuggestion.splitTest.getAttsTestDependsOn();
+							if (splitAtts.length == 1) {
+								if (bestSuggestion.merit - bestSplitSuggestion.merit > hoeffdingBound) {
+									poorAtts.add(splitAtts[0]);
+								}
+							}
+						}
+					}
+					// scan 2 - remove good ones from set
+					for (AttributeSplitSuggestion bestSplitSuggestion : bestSplitSuggestions) {
+						if (bestSplitSuggestion.splitTest != null) {
+							int[] splitAtts = bestSplitSuggestion.splitTest.getAttsTestDependsOn();
+							if (splitAtts.length == 1) {
+								if (bestSuggestion.merit - bestSplitSuggestion.merit < hoeffdingBound) {
+									poorAtts.remove(splitAtts[0]);
+								}
+							}
+						}
+					}
+					for (int poorAtt : poorAtts) {
+						node.disableAttribute(poorAtt);
+					}
+				}
+			}
+			if (shouldSplit) {
+				splitCount++;
+
+				AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+				if (splitDecision.splitTest == null) {
+					// preprune - null wins
+					deactivateLearningNode(node, parent, parentIndex);
+				} else {
+					Node newSplit = newSplitNode(splitDecision.splitTest, node.getObservedClassDistribution(),
+							splitDecision.numSplits());
+					((EFDTSplitNode) newSplit).attributeObservers = node.attributeObservers; // copy the attribute
+																								// observers
+					newSplit.setInfogainSum(node.getInfogainSum()); // transfer infogain history, leaf to split
+
+					for (int i = 0; i < splitDecision.numSplits(); i++) {
+
+						double[] j = splitDecision.resultingClassDistributionFromSplit(i);
+
+						Node newChild = newLearningNode(splitDecision.resultingClassDistributionFromSplit(i));
+
+						if (splitDecision.splitTest.getClass() == NominalAttributeBinaryTest.class
+								|| splitDecision.splitTest.getClass() == NominalAttributeMultiwayTest.class) {
+							newChild.usedNominalAttributes = new ArrayList<>(node.usedNominalAttributes); // deep copy
+							newChild.usedNominalAttributes.add(splitDecision.splitTest.getAttsTestDependsOn()[0]);
+							// no nominal attribute should be split on more than once in the path
+						}
+						((EFDTSplitNode) newSplit).setChild(i, newChild);
+					}
+					this.activeLeafNodeCount--;
+					this.decisionNodeCount++;
+					this.activeLeafNodeCount += splitDecision.numSplits();
+					if (parent == null) {
+						this.treeRoot = newSplit;
+					} else {
+						parent.setChild(parentIndex, newSplit);
+					}
+
+				}
+				// manage memory
+				enforceTrackerLimit();
+			}
+		}
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+
+		if (this.treeRoot == null) {
+			this.treeRoot = newLearningNode();
+			((EFDTNode) this.treeRoot).setRoot(true);
+			this.activeLeafNodeCount = 1;
+		}
+
+		FoundNode foundNode = this.treeRoot.filterInstanceToLeaf(inst, null, -1);
+		Node leafNode = foundNode.node;
+
+		if (leafNode == null) {
+			leafNode = newLearningNode();
+			foundNode.parent.setChild(foundNode.parentBranch, leafNode);
+			this.activeLeafNodeCount++;
+		}
+
+		((EFDTNode) this.treeRoot).learnFromInstance(inst, this, null, -1);
+
+		numInstances++;
+	}
+
+	protected LearningNode newLearningNode() {
+		return new EFDTLearningNode(new double[0]);
+	}
+
+	protected LearningNode newLearningNode(double[] initialClassObservations) {
+		return new EFDTLearningNode(initialClassObservations);
+	}
+
+	protected SplitNode newSplitNode(InstanceConditionalTest splitTest, double[] classObservations, int size) {
+		return new EFDTSplitNode(splitTest, classObservations, size);
+	}
+
+	protected SplitNode newSplitNode(InstanceConditionalTest splitTest, double[] classObservations) {
+		return new EFDTSplitNode(splitTest, classObservations);
+	}
+
+	private int argmax(double[] array) {
+
+		double max = array[0];
+		int maxarg = 0;
+
+		for (int i = 1; i < array.length; i++) {
+
+			if (array[i] > max) {
+				max = array[i];
+				maxarg = i;
+			}
+		}
+		return maxarg;
+	}
+
+	public interface EFDTNode {
+
+		boolean isRoot();
+
+		void setRoot(boolean isRoot);
+
+		void learnFromInstance(Instance inst, EFDT ht, EFDTSplitNode parent, int parentBranch);
+
+		void setParent(EFDTSplitNode parent);
+
+		EFDTSplitNode getParent();
+
+	}
+
+	public static class FoundNode {
+
+		public Node node;
+
+		public SplitNode parent;
+
+		public int parentBranch;
+
+		public FoundNode(Node node, SplitNode parent, int parentBranch) {
+			this.node = node;
+			this.parent = parent;
+			this.parentBranch = parentBranch;
+		}
+	}
+
+	public static class Node extends AbstractMOAObject {
+
+		private HashMap<Integer, Double> infogainSum;
+
+		private int numSplitAttempts = 0;
+
+		private static final long serialVersionUID = 1L;
+
+		protected DoubleVector observedClassDistribution;
+
+		protected DoubleVector classDistributionAtTimeOfCreation;
+
+		protected int nodeTime;
+
+		protected List<Integer> usedNominalAttributes = new ArrayList<>();
+
+		public Node(double[] classObservations) {
+			this.observedClassDistribution = new DoubleVector(classObservations);
+			this.classDistributionAtTimeOfCreation = new DoubleVector(classObservations);
+			this.infogainSum = new HashMap<>();
+			this.infogainSum.put(-1, 0.0); // Initialize for null split
+
+		}
+
+		public int getNumSplitAttempts() {
+			return numSplitAttempts;
+		}
+
+		public void addToSplitAttempts(int i) {
+			numSplitAttempts += i;
+		}
+
+		public HashMap<Integer, Double> getInfogainSum() {
+			return infogainSum;
+		}
+
+		public void setInfogainSum(HashMap<Integer, Double> igs) {
+			infogainSum = igs;
+		}
+
+		public int calcByteSize() {
+			return (int) (SizeOf.sizeOf(this) + SizeOf.fullSizeOf(this.observedClassDistribution));
+		}
+
+		public int calcByteSizeIncludingSubtree() {
+			return calcByteSize();
+		}
+
+		public boolean isLeaf() {
+			return true;
+		}
+
+		public FoundNode filterInstanceToLeaf(Instance inst, SplitNode parent, int parentBranch) {
+			return new FoundNode(this, parent, parentBranch);
+		}
+
+		public double[] getObservedClassDistribution() {
+			return this.observedClassDistribution.getArrayCopy();
+		}
+
+		public double[] getClassVotes(Instance inst, EFDT ht) {
+			return this.observedClassDistribution.getArrayCopy();
+		}
+
+		public double[] getClassDistributionAtTimeOfCreation() {
+			return this.classDistributionAtTimeOfCreation.getArrayCopy();
+		}
+
+		public boolean observedClassDistributionIsPure() {
+			return this.observedClassDistribution.numNonZeroEntries() < 2;
+		}
+
+		public void describeSubtree(EFDT ht, StringBuilder out, int indent) {
+			StringUtils.appendIndented(out, indent, "Leaf ");
+			out.append(ht.getClassNameString());
+			out.append(" = ");
+			out.append(ht.getClassLabelString(this.observedClassDistribution.maxIndex()));
+			out.append(" weights: ");
+			this.observedClassDistribution.getSingleLineDescription(out,
+					ht.treeRoot.observedClassDistribution.numValues());
+			StringUtils.appendNewline(out);
+		}
+
+		public int subtreeDepth() {
+			return 0;
+		}
+
+		public double calculatePromise() {
+			double totalSeen = this.observedClassDistribution.sumOfValues();
+			return totalSeen > 0.0
+					? (totalSeen - this.observedClassDistribution.getValue(this.observedClassDistribution.maxIndex()))
+					: 0.0;
+		}
+
+		@Override
+		public void getDescription(StringBuilder sb, int indent) {
+			describeSubtree(null, sb, indent);
+		}
+	}
+
+	public static class SplitNode extends Node {
+
+		private static final long serialVersionUID = 1L;
+
+		protected InstanceConditionalTest splitTest;
+
+		protected AutoExpandVector<Node> children; // = new AutoExpandVector<Node>();
+
+		@Override
+		public int calcByteSize() {
+			return super.calcByteSize() + (int) (SizeOf.sizeOf(this.children) + SizeOf.fullSizeOf(this.splitTest));
+		}
+
+		@Override
+		public int calcByteSizeIncludingSubtree() {
+			int byteSize = calcByteSize();
+			for (Node child : this.children) {
+				if (child != null) {
+					byteSize += child.calcByteSizeIncludingSubtree();
+				}
+			}
+			return byteSize;
+		}
+
+		public SplitNode(InstanceConditionalTest splitTest, double[] classObservations, int size) {
+			super(classObservations);
+			this.splitTest = splitTest;
+			this.children = new AutoExpandVector<>(size);
+		}
+
+		public SplitNode(InstanceConditionalTest splitTest, double[] classObservations) {
+			super(classObservations);
+			this.splitTest = splitTest;
+			this.children = new AutoExpandVector<>();
+		}
+
+		public int numChildren() {
+			return this.children.size();
+		}
+
+		public void setChild(int index, Node child) {
+			if ((this.splitTest.maxBranches() >= 0) && (index >= this.splitTest.maxBranches())) {
+				throw new IndexOutOfBoundsException();
+			}
+			this.children.set(index, child);
+		}
+
+		public Node getChild(int index) {
+			return this.children.get(index);
+		}
+
+		public int instanceChildIndex(Instance inst) {
+			return this.splitTest.branchForInstance(inst);
+		}
+
+		@Override
+		public boolean isLeaf() {
+			return false;
+		}
+
+		@Override
+		public FoundNode filterInstanceToLeaf(Instance inst, SplitNode parent, int parentBranch) {
+
+			// System.err.println("OVERRIDING ");
+
+			int childIndex = instanceChildIndex(inst);
+			if (childIndex >= 0) {
+				Node child = getChild(childIndex);
+				if (child != null) {
+					return child.filterInstanceToLeaf(inst, this, childIndex);
+				}
+				return new FoundNode(null, this, childIndex);
+			}
+			return new FoundNode(this, parent, parentBranch);
+		}
+
+		@Override
+		public void describeSubtree(EFDT ht, StringBuilder out, int indent) {
+			for (int branch = 0; branch < numChildren(); branch++) {
+				Node child = getChild(branch);
+				if (child != null) {
+					StringUtils.appendIndented(out, indent, "if ");
+					out.append(this.splitTest.describeConditionForBranch(branch, ht.getModelContext()));
+					out.append(": ");
+					StringUtils.appendNewline(out);
+					child.describeSubtree(ht, out, indent + 2);
+				}
+			}
+		}
+
+		@Override
+		public int subtreeDepth() {
+			int maxChildDepth = 0;
+			for (Node child : this.children) {
+				if (child != null) {
+					int depth = child.subtreeDepth();
+					if (depth > maxChildDepth) {
+						maxChildDepth = depth;
+					}
+				}
+			}
+			return maxChildDepth + 1;
+		}
+	}
+
+	public class EFDTSplitNode extends SplitNode implements EFDTNode {
+
+		/**
+		 *
+		 */
+
+		private boolean isRoot;
+
+		private EFDTSplitNode parent = null;
+
+		private static final long serialVersionUID = 1L;
+
+		protected AutoExpandVector<AttributeClassObserver> attributeObservers;
+
+		public EFDTSplitNode(InstanceConditionalTest splitTest, double[] classObservations, int size) {
+			super(splitTest, classObservations, size);
+		}
+
+		public EFDTSplitNode(InstanceConditionalTest splitTest, double[] classObservations) {
+			super(splitTest, classObservations);
+		}
+
+		@Override
+		public boolean isRoot() {
+			return isRoot;
+		}
+
+		@Override
+		public void setRoot(boolean isRoot) {
+			this.isRoot = isRoot;
+		}
+
+		public void killSubtree(EFDT ht) {
+			for (Node child : this.children) {
+				if (child != null) {
+
+					// Recursive delete of SplitNodes
+					if (child instanceof SplitNode) {
+						((EFDTSplitNode) child).killSubtree(ht);
+					} else if (child instanceof ActiveLearningNode) {
+						ht.activeLeafNodeCount--;
+					} else if (child instanceof InactiveLearningNode) {
+						ht.inactiveLeafNodeCount--;
+					}
+				}
+			}
+		}
+
+		// DRY Don't Repeat Yourself... code duplicated from ActiveLearningNode in
+		// VFDT.java. However, this is the most practical way to share stand-alone.
+		public AttributeSplitSuggestion[] getBestSplitSuggestions(SplitCriterion criterion, EFDT ht) {
+			List<AttributeSplitSuggestion> bestSuggestions = new LinkedList<>();
+			double[] preSplitDist = this.observedClassDistribution.getArrayCopy();
+			if (!ht.noPrePruneOption.isSet()) {
+				// add null split as an option
+				bestSuggestions.add(new AttributeSplitSuggestion(null, new double[0][],
+						criterion.getMeritOfSplit(preSplitDist, new double[][] { preSplitDist })));
+			}
+			for (int i = 0; i < this.attributeObservers.size(); i++) {
+				AttributeClassObserver obs = this.attributeObservers.get(i);
+				if (obs != null) {
+					AttributeSplitSuggestion bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion,
+							preSplitDist, i, ht.binarySplitsOption.isSet());
+					if (bestSuggestion != null) {
+						bestSuggestions.add(bestSuggestion);
+					}
+				}
+			}
+			return bestSuggestions.toArray(new AttributeSplitSuggestion[bestSuggestions.size()]);
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, EFDT ht, EFDTSplitNode parent, int parentBranch) {
+
+			nodeTime++;
+			//// Update node statistics and class distribution
+
+			this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight()); // update prior
+																								// (predictor)
+
+			for (int i = 0; i < inst.numAttributes() - 1; i++) { // update likelihood
+				int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
+				AttributeClassObserver obs = this.attributeObservers.get(i);
+				if (obs == null) {
+					obs = inst.attribute(instAttIndex).isNominal() ? ht.newNominalClassObserver()
+							: ht.newNumericClassObserver();
+					this.attributeObservers.set(i, obs);
+				}
+				obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
+			}
+
+			// check if a better split is available. if so, chop the tree at this point,
+			// copying likelihood. predictors for children are from parent likelihood.
+			if (ht.numInstances % ht.reEvalPeriodOption.getValue() == 0) {
+				this.reEvaluateBestSplit(this, parent, parentBranch);
+			}
+
+			int childBranch = this.instanceChildIndex(inst);
+			Node child = this.getChild(childBranch);
+
+			if (child != null) {
+				((EFDTNode) child).learnFromInstance(inst, ht, this, childBranch);
+			}
+
+		}
+
+		protected void reEvaluateBestSplit(EFDTSplitNode node, EFDTSplitNode parent, int parentIndex) {
+
+			node.addToSplitAttempts(1);
+
+			// EFDT must transfer over gain averages when replacing a node: leaf to split,
+			// split to leaf, or split to split
+			// It must replace split nodes with leaves if null wins
+
+			// node is a reference to this anyway... why have it at all?
+
+			int currentSplit = -1;
+			// and if we always choose to maintain tree structure
+
+			// lets first find out X_a, the current split
+
+			if (this.splitTest != null) {
+				currentSplit = this.splitTest.getAttsTestDependsOn()[0];
+				// given the current implementations in MOA, we're only ever expecting one int
+				// to be returned
+			}
+
+			// compute Hoeffding bound
+			SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(EFDT.this.splitCriterionOption);
+			double hoeffdingBound = computeHoeffdingBound(
+					splitCriterion.getRangeOfMerit(node.getClassDistributionAtTimeOfCreation()),
+					EFDT.this.splitConfidenceOption.getValue(), node.observedClassDistribution.sumOfValues());
+
+			// get best split suggestions
+			AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion, EFDT.this);
+			Arrays.sort(bestSplitSuggestions);
+
+			// get the best suggestion
+			AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+
+			for (AttributeSplitSuggestion bestSplitSuggestion : bestSplitSuggestions) {
+
+				if (bestSplitSuggestion.splitTest != null) {
+					if (!node.getInfogainSum().containsKey((bestSplitSuggestion.splitTest.getAttsTestDependsOn()[0]))) {
+						node.getInfogainSum().put((bestSplitSuggestion.splitTest.getAttsTestDependsOn()[0]), 0.0);
+					}
+					double currentSum = node.getInfogainSum()
+							.get((bestSplitSuggestion.splitTest.getAttsTestDependsOn()[0]));
+					node.getInfogainSum().put((bestSplitSuggestion.splitTest.getAttsTestDependsOn()[0]),
+							currentSum + bestSplitSuggestion.merit);
+				}
+
+				else { // handle the null attribute. this is fine to do- it'll always average zero, and
+						// we will use this later to potentially burn bad splits.
+					double currentSum = node.getInfogainSum().get(-1); // null split
+					node.getInfogainSum().put(-1, currentSum + bestSplitSuggestion.merit);
+				}
+
+			}
+
+			// get the average merit for best and current splits
+
+			double bestSuggestionAverageMerit;
+			double currentAverageMerit;
+
+			if (bestSuggestion.splitTest == null) { // best is null
+				bestSuggestionAverageMerit = node.getInfogainSum().get(-1) / node.getNumSplitAttempts();
+			} else {
+
+				bestSuggestionAverageMerit = node.getInfogainSum()
+						.get(bestSuggestion.splitTest.getAttsTestDependsOn()[0]) / node.getNumSplitAttempts();
+			}
+
+			if (node.splitTest == null) { // current is null- shouldn't happen, check for robustness
+				currentAverageMerit = node.getInfogainSum().get(-1) / node.getNumSplitAttempts();
+			} else {
+				currentAverageMerit = node.getInfogainSum().get(node.splitTest.getAttsTestDependsOn()[0])
+						/ node.getNumSplitAttempts();
+			}
+
+			double tieThreshold = EFDT.this.tieThresholdOption.getValue();
+
+			// compute the average deltaG
+			double deltaG = bestSuggestionAverageMerit - currentAverageMerit;
+
+			if (deltaG > hoeffdingBound || (hoeffdingBound < tieThreshold && deltaG > tieThreshold / 2)) {
+
+				System.err.println(numInstances);
+
+				AttributeSplitSuggestion splitDecision = bestSuggestion;
+
+				// if null split wins
+				if (splitDecision.splitTest == null) {
+
+					node.killSubtree(EFDT.this);
+					EFDTLearningNode replacement = (EFDTLearningNode) newLearningNode();
+					replacement.setInfogainSum(node.getInfogainSum()); // transfer infogain history, split to
+																		// replacement leaf
+					if (node.getParent() != null) {
+						node.getParent().setChild(parentIndex, replacement);
+					} else {
+						assert (node.isRoot());
+						node.setRoot(true);
+					}
+				}
+
+				else {
+
+					Node newSplit = newSplitNode(splitDecision.splitTest, node.getObservedClassDistribution(),
+							splitDecision.numSplits());
+
+					((EFDTSplitNode) newSplit).attributeObservers = node.attributeObservers; // copy the attribute
+																								// observers
+					newSplit.setInfogainSum(node.getInfogainSum()); // transfer infogain history, split to replacement
+																	// split
+
+					if (node.splitTest == splitDecision.splitTest
+							&& node.splitTest.getClass() == NumericAttributeBinaryTest.class
+							&& (argmax(splitDecision.resultingClassDistributions[0]) == argmax(
+									node.getChild(0).getObservedClassDistribution())
+									|| argmax(splitDecision.resultingClassDistributions[1]) == argmax(
+											node.getChild(1).getObservedClassDistribution()))) {
+						// change split but don't destroy the subtrees
+						for (int i = 0; i < splitDecision.numSplits(); i++) {
+							((EFDTSplitNode) newSplit).setChild(i, this.getChild(i));
+						}
+
+					} else {
+
+						// otherwise, torch the subtree and split on the new best attribute.
+
+						this.killSubtree(EFDT.this);
+
+						for (int i = 0; i < splitDecision.numSplits(); i++) {
+
+							double[] j = splitDecision.resultingClassDistributionFromSplit(i);
+
+							Node newChild = newLearningNode(splitDecision.resultingClassDistributionFromSplit(i));
+
+							if (splitDecision.splitTest.getClass() == NominalAttributeBinaryTest.class
+									|| splitDecision.splitTest.getClass() == NominalAttributeMultiwayTest.class) {
+								newChild.usedNominalAttributes = new ArrayList<>(node.usedNominalAttributes); // deep
+																												// copy
+								newChild.usedNominalAttributes.add(splitDecision.splitTest.getAttsTestDependsOn()[0]);
+								// no nominal attribute should be split on more than once in the path
+							}
+							((EFDTSplitNode) newSplit).setChild(i, newChild);
+						}
+
+						EFDT.this.activeLeafNodeCount--;
+						EFDT.this.decisionNodeCount++;
+						EFDT.this.activeLeafNodeCount += splitDecision.numSplits();
+
+					}
+
+					if (parent == null) {
+						((EFDTNode) newSplit).setRoot(true);
+						((EFDTNode) newSplit).setParent(null);
+						EFDT.this.treeRoot = newSplit;
+					} else {
+						((EFDTNode) newSplit).setRoot(false);
+						((EFDTNode) newSplit).setParent(parent);
+						parent.setChild(parentIndex, newSplit);
+					}
+				}
+			}
+		}
+
+		@Override
+		public void setParent(EFDTSplitNode parent) {
+			this.parent = parent;
+		}
+
+		@Override
+		public EFDTSplitNode getParent() {
+			return this.parent;
+		}
+	}
+
+	public static abstract class LearningNode extends Node {
+
+		private static final long serialVersionUID = 1L;
+
+		public LearningNode(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		public abstract void learnFromInstance(Instance inst, EFDT ht);
+	}
+
+	public class EFDTLearningNode extends LearningNodeNBAdaptive implements EFDTNode {
+
+		private boolean isRoot;
+
+		private EFDTSplitNode parent = null;
+
+		public EFDTLearningNode(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		/**
+		 *
+		 */
+		private static final long serialVersionUID = -2525042202040084035L;
+
+		@Override
+		public boolean isRoot() {
+			return isRoot;
+		}
+
+		@Override
+		public void setRoot(boolean isRoot) {
+			this.isRoot = isRoot;
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, EFDT ht) {
+			super.learnFromInstance(inst, ht);
+
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, EFDT ht, EFDTSplitNode parent, int parentBranch) {
+			learnFromInstance(inst, ht);
+
+			if (ht.growthAllowed) {
+				ActiveLearningNode activeLearningNode = this;
+				double weightSeen = activeLearningNode.getWeightSeen();
+				if (activeLearningNode.nodeTime % ht.gracePeriodOption.getValue() == 0) {
+					attemptToSplit(activeLearningNode, parent, parentBranch);
+					activeLearningNode.setWeightSeenAtLastSplitEvaluation(weightSeen);
+				}
+			}
+		}
+
+		@Override
+		public void setParent(EFDTSplitNode parent) {
+			this.parent = parent;
+		}
+
+		@Override
+		public EFDTSplitNode getParent() {
+			return this.parent;
+		}
+
+	}
+
+	public static class InactiveLearningNode extends LearningNode {
+
+		private static final long serialVersionUID = 1L;
+
+		public InactiveLearningNode(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, EFDT ht) {
+			this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight());
+		}
+	}
+
+	public static class ActiveLearningNode extends LearningNode {
+
+		private static final long serialVersionUID = 1L;
+
+		protected double weightSeenAtLastSplitEvaluation;
+
+		protected AutoExpandVector<AttributeClassObserver> attributeObservers = new AutoExpandVector<>();
+
+		protected boolean isInitialized;
+
+		public ActiveLearningNode(double[] initialClassObservations) {
+			super(initialClassObservations);
+			this.weightSeenAtLastSplitEvaluation = getWeightSeen();
+			this.isInitialized = false;
+		}
+
+		@Override
+		public int calcByteSize() {
+			return super.calcByteSize() + (int) (SizeOf.fullSizeOf(this.attributeObservers));
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, EFDT ht) {
+			nodeTime++;
+
+			if (this.isInitialized) {
+				this.attributeObservers = new AutoExpandVector<>(inst.numAttributes());
+				this.isInitialized = true;
+			}
+			this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight());
+			for (int i = 0; i < inst.numAttributes() - 1; i++) {
+				int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
+				AttributeClassObserver obs = this.attributeObservers.get(i);
+				if (obs == null) {
+					obs = inst.attribute(instAttIndex).isNominal() ? ht.newNominalClassObserver()
+							: ht.newNumericClassObserver();
+					this.attributeObservers.set(i, obs);
+				}
+				obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
+			}
+		}
+
+		public double getWeightSeen() {
+			return this.observedClassDistribution.sumOfValues();
+		}
+
+		public double getWeightSeenAtLastSplitEvaluation() {
+			return this.weightSeenAtLastSplitEvaluation;
+		}
+
+		public void setWeightSeenAtLastSplitEvaluation(double weight) {
+			this.weightSeenAtLastSplitEvaluation = weight;
+		}
+
+		public AttributeSplitSuggestion[] getBestSplitSuggestions(SplitCriterion criterion, EFDT ht) {
+			List<AttributeSplitSuggestion> bestSuggestions = new LinkedList<>();
+			double[] preSplitDist = this.observedClassDistribution.getArrayCopy();
+			if (!ht.noPrePruneOption.isSet()) {
+				// add null split as an option
+				bestSuggestions.add(new AttributeSplitSuggestion(null, new double[0][],
+						criterion.getMeritOfSplit(preSplitDist, new double[][] { preSplitDist })));
+			}
+			for (int i = 0; i < this.attributeObservers.size(); i++) {
+				AttributeClassObserver obs = this.attributeObservers.get(i);
+				if (obs != null) {
+					AttributeSplitSuggestion bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion,
+							preSplitDist, i, ht.binarySplitsOption.isSet());
+					if (bestSuggestion != null) {
+						bestSuggestions.add(bestSuggestion);
+					}
+				}
+			}
+			return bestSuggestions.toArray(new AttributeSplitSuggestion[bestSuggestions.size()]);
+		}
+
+		public void disableAttribute(int attIndex) {
+			this.attributeObservers.set(attIndex, new NullAttributeClassObserver());
+		}
+	}
+
+	public static class LearningNodeNB extends ActiveLearningNode {
+
+		private static final long serialVersionUID = 1L;
+
+		public LearningNodeNB(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		@Override
+		public double[] getClassVotes(Instance inst, EFDT ht) {
+			if (getWeightSeen() >= ht.nbThresholdOption.getValue()) {
+				return NaiveBayes.doNaiveBayesPrediction(inst, this.observedClassDistribution, this.attributeObservers);
+			}
+			return super.getClassVotes(inst, ht);
+		}
+
+		@Override
+		public void disableAttribute(int attIndex) {
+			// should not disable poor atts - they are used in NB calc
+		}
+	}
+
+	public static class LearningNodeNBAdaptive extends LearningNodeNB {
+
+		private static final long serialVersionUID = 1L;
+
+		protected double mcCorrectWeight = 0.0;
+
+		protected double nbCorrectWeight = 0.0;
+
+		public LearningNodeNBAdaptive(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, EFDT ht) {
+			int trueClass = (int) inst.classValue();
+			if (this.observedClassDistribution.maxIndex() == trueClass) {
+				this.mcCorrectWeight += inst.weight();
+			}
+			if (Utils.maxIndex(NaiveBayes.doNaiveBayesPrediction(inst, this.observedClassDistribution,
+					this.attributeObservers)) == trueClass) {
+				this.nbCorrectWeight += inst.weight();
+			}
+			super.learnFromInstance(inst, ht);
+		}
+
+		@Override
+		public double[] getClassVotes(Instance inst, EFDT ht) {
+			if (this.mcCorrectWeight > this.nbCorrectWeight) {
+				return this.observedClassDistribution.getArrayCopy();
+			}
+			return NaiveBayes.doNaiveBayesPrediction(inst, this.observedClassDistribution, this.attributeObservers);
+		}
+	}
+
+	static class VFDT extends EFDT {
+
+		@Override
+		protected void attemptToSplit(ActiveLearningNode node, SplitNode parent, int parentIndex) {
+			if (!node.observedClassDistributionIsPure()) {
+
+				SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
+				AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion, this);
+
+				Arrays.sort(bestSplitSuggestions);
+				boolean shouldSplit = false;
+
+				for (int i = 0; i < bestSplitSuggestions.length; i++) {
+
+					node.addToSplitAttempts(1); // even if we don't actually attempt to split, we've computed infogains
+
+					if (bestSplitSuggestions[i].splitTest != null) {
+						if (!node.getInfogainSum()
+								.containsKey((bestSplitSuggestions[i].splitTest.getAttsTestDependsOn()[0]))) {
+							node.getInfogainSum().put((bestSplitSuggestions[i].splitTest.getAttsTestDependsOn()[0]),
+									0.0);
+						}
+						double currentSum = node.getInfogainSum()
+								.get((bestSplitSuggestions[i].splitTest.getAttsTestDependsOn()[0]));
+						node.getInfogainSum().put((bestSplitSuggestions[i].splitTest.getAttsTestDependsOn()[0]),
+								currentSum + bestSplitSuggestions[i].merit);
+					}
+
+					else { // handle the null attribute
+						double currentSum = node.getInfogainSum().get(-1); // null split
+						node.getInfogainSum().put(-1, currentSum + Math.max(0.0, bestSplitSuggestions[i].merit));
+						assert node.getInfogainSum().get(-1) >= 0.0 : "Negative infogain shouldn't be possible here.";
+					}
+
+				}
+
+				if (bestSplitSuggestions.length < 2) {
+					shouldSplit = bestSplitSuggestions.length > 0;
+				}
+
+				else {
+
+					double hoeffdingBound = computeHoeffdingBound(
+							splitCriterion.getRangeOfMerit(node.getObservedClassDistribution()),
+							this.splitConfidenceOption.getValue(), node.getWeightSeen());
+
+					AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+					AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length
+							- 2];
+
+					double bestSuggestionAverageMerit = 0.0;
+					double secondBestSuggestionAverageMerit = 0.0;
+
+					if (bestSuggestion.splitTest == null) { // if you have a null split
+						bestSuggestionAverageMerit = node.getInfogainSum().get(-1) / node.getNumSplitAttempts();
+					} else {
+						bestSuggestionAverageMerit = node.getInfogainSum()
+								.get((bestSuggestion.splitTest.getAttsTestDependsOn()[0])) / node.getNumSplitAttempts();
+					}
+
+					if (secondBestSuggestion.splitTest == null) { // if you have a null split
+						secondBestSuggestionAverageMerit = node.getInfogainSum().get(-1) / node.getNumSplitAttempts();
+					} else {
+						secondBestSuggestionAverageMerit = node.getInfogainSum()
+								.get((secondBestSuggestion.splitTest.getAttsTestDependsOn()[0]))
+								/ node.getNumSplitAttempts();
+					}
+
+					// comment this if statement to get VFDT bug
+					if (bestSuggestion.merit < 1e-10) { // we don't use average here
+						shouldSplit = false;
+					}
+
+					else if ((bestSuggestionAverageMerit - secondBestSuggestionAverageMerit > hoeffdingBound)
+							|| (hoeffdingBound < this.tieThresholdOption.getValue())) {
+						shouldSplit = true;
+					}
+
+					if (shouldSplit) {
+						for (Integer i : node.usedNominalAttributes) {
+							if (bestSuggestion.splitTest.getAttsTestDependsOn()[0] == i) {
+								shouldSplit = false;
+								break;
+							}
+						}
+					}
+
+					// }
+					if ((this.removePoorAttsOption != null) && this.removePoorAttsOption.isSet()) {
+						Set<Integer> poorAtts = new HashSet<>();
+						// scan 1 - add any poor to set
+						for (int i = 0; i < bestSplitSuggestions.length; i++) {
+							if (bestSplitSuggestions[i].splitTest != null) {
+								int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
+								if (splitAtts.length == 1) {
+									if (bestSuggestion.merit - bestSplitSuggestions[i].merit > hoeffdingBound) {
+										poorAtts.add(new Integer(splitAtts[0]));
+									}
+								}
+							}
+						}
+						// scan 2 - remove good ones from set
+						for (int i = 0; i < bestSplitSuggestions.length; i++) {
+							if (bestSplitSuggestions[i].splitTest != null) {
+								int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
+								if (splitAtts.length == 1) {
+									if (bestSuggestion.merit - bestSplitSuggestions[i].merit < hoeffdingBound) {
+										poorAtts.remove(new Integer(splitAtts[0]));
+									}
+								}
+							}
+						}
+						for (int poorAtt : poorAtts) {
+							node.disableAttribute(poorAtt);
+						}
+					}
+				}
+				if (shouldSplit) {
+					splitCount++;
+
+					AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+					if (splitDecision.splitTest == null) {
+						// preprune - null wins
+						deactivateLearningNode(node, parent, parentIndex);
+					} else {
+						SplitNode newSplit = newSplitNode(splitDecision.splitTest, node.getObservedClassDistribution(),
+								splitDecision.numSplits());
+						for (int i = 0; i < splitDecision.numSplits(); i++) {
+
+							double[] j = splitDecision.resultingClassDistributionFromSplit(i);
+
+							Node newChild = newLearningNode(splitDecision.resultingClassDistributionFromSplit(i));
+
+							if (splitDecision.splitTest.getClass() == NominalAttributeBinaryTest.class
+									|| splitDecision.splitTest.getClass() == NominalAttributeMultiwayTest.class) {
+								newChild.usedNominalAttributes = new ArrayList<>(node.usedNominalAttributes); // deep
+																														// copy
+								newChild.usedNominalAttributes.add(splitDecision.splitTest.getAttsTestDependsOn()[0]);
+								// no nominal attribute should be split on more than once in the path
+							}
+							newSplit.setChild(i, newChild);
+						}
+						this.activeLeafNodeCount--;
+						this.decisionNodeCount++;
+						this.activeLeafNodeCount += splitDecision.numSplits();
+						if (parent == null) {
+							this.treeRoot = newSplit;
+						} else {
+							parent.setChild(parentIndex, newSplit);
+						}
+
+					}
+
+					// manage memory
+					enforceTrackerLimit();
+				}
+			}
+		}
+
+		@Override
+		protected LearningNode newLearningNode() {
+			return newLearningNode(new double[0]);
+		}
+
+		@Override
+		protected LearningNode newLearningNode(double[] initialClassObservations) {
+			LearningNode ret;
+			int predictionOption = this.leafpredictionOption.getChosenIndex();
+			if (predictionOption == 0) { // MC
+				ret = new ActiveLearningNode(initialClassObservations);
+			} else if (predictionOption == 1) { // NB
+				ret = new LearningNodeNB(initialClassObservations);
+			} else { // NBAdaptive
+				ret = new LearningNodeNBAdaptive(initialClassObservations);
+			}
+			return ret;
+		}
+
+		@Override
+		protected SplitNode newSplitNode(InstanceConditionalTest splitTest, double[] classObservations, int size) {
+			return new SplitNode(splitTest, classObservations, size);
+		}
+
+		@Override
+		protected SplitNode newSplitNode(InstanceConditionalTest splitTest, double[] classObservations) {
+			return new SplitNode(splitTest, classObservations);
+		}
+
+		@Override
+		public void trainOnInstanceImpl(Instance inst) {
+			// System.err.println(i++);
+			if (this.treeRoot == null) {
+				this.treeRoot = newLearningNode();
+				this.activeLeafNodeCount = 1;
+			}
+			FoundNode foundNode = this.treeRoot.filterInstanceToLeaf(inst, null, -1);
+			Node leafNode = foundNode.node;
+
+			if (leafNode == null) {
+				leafNode = newLearningNode();
+				foundNode.parent.setChild(foundNode.parentBranch, leafNode);
+				this.activeLeafNodeCount++;
+			}
+
+			if (leafNode instanceof LearningNode) {
+				LearningNode learningNode = (LearningNode) leafNode;
+				learningNode.learnFromInstance(inst, this);
+				if (this.growthAllowed && (learningNode instanceof ActiveLearningNode)) {
+					ActiveLearningNode activeLearningNode = (ActiveLearningNode) learningNode;
+					double weightSeen = activeLearningNode.getWeightSeen();
+					if (activeLearningNode.nodeTime % this.gracePeriodOption.getValue() == 0) {
+						attemptToSplit(activeLearningNode, foundNode.parent, foundNode.parentBranch);
+						activeLearningNode.setWeightSeenAtLastSplitEvaluation(weightSeen);
+					}
+				}
+			}
+
+			if (this.trainingWeightSeenByModel % this.memoryEstimatePeriodOption.getValue() == 0) {
+				estimateModelByteSizes();
+			}
+
+			numInstances++;
+		}
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java b/moa/src/main/java/moa/learners/predictors/trees/FIMTDD.java
similarity index 77%
rename from moa/src/main/java/moa/classifiers/trees/FIMTDD.java
rename to moa/src/main/java/moa/learners/predictors/trees/FIMTDD.java
index 5182fa149..a0be58554 100644
--- a/moa/src/main/java/moa/classifiers/trees/FIMTDD.java
+++ b/moa/src/main/java/moa/learners/predictors/trees/FIMTDD.java
@@ -14,11 +14,11 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.classifiers.trees;
+package moa.learners.predictors.trees;
 
 import java.io.Serializable;
 import java.util.Arrays;
@@ -33,17 +33,17 @@
 import com.yahoo.labs.samoa.instances.predictions.RegressionPrediction;
 
 import moa.AbstractMOAObject;
-import moa.classifiers.AbstractRegressor;
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
-import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.SizeOf;
 import moa.core.StringUtils;
-import moa.learners.Regressor;
+import moa.learners.predictors.AbstractRegressor;
+import moa.learners.predictors.Regressor;
+import moa.learners.predictors.core.AttributeSplitSuggestion;
+import moa.learners.predictors.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
+import moa.learners.predictors.core.conditionaltests.InstanceConditionalTest;
+import moa.learners.predictors.core.splitcriteria.SplitCriterion;
 import moa.options.ClassOption;
 
 /*
@@ -68,65 +68,54 @@ public class FIMTDD extends AbstractRegressor implements Regressor {
 
 	public int maxID = 0;
 
-	//region ================ OPTIONS ================
+	// region ================ OPTIONS ================
+
+	public ClassOption splitCriterionOption = new ClassOption("splitCriterion", 's', "Split criterion to use.",
+			SplitCriterion.class, "VarianceReductionSplitCriterion");
 
-	public ClassOption splitCriterionOption = new ClassOption(
-			"splitCriterion", 's', "Split criterion to use.",
-			SplitCriterion.class, "moa.classifiers.core.splitcriteria.VarianceReductionSplitCriterion");
+	public IntOption gracePeriodOption = new IntOption("gracePeriod", 'g',
+			"Number of instances a leaf should observe between split attempts.", 200, 0, Integer.MAX_VALUE);
 
-	public IntOption gracePeriodOption = new IntOption(
-			"gracePeriod", 'g', "Number of instances a leaf should observe between split attempts.",
-			200, 0, Integer.MAX_VALUE);
+	public FloatOption splitConfidenceOption = new FloatOption("splitConfidence", 'c',
+			"Allowed error in split decision, values close to 0 will take long to decide.", 0.0000001, 0.0, 1.0);
 
-	public FloatOption splitConfidenceOption = new FloatOption(
-			"splitConfidence", 'c', "Allowed error in split decision, values close to 0 will take long to decide.",
-			0.0000001, 0.0, 1.0);
+	public FloatOption tieThresholdOption = new FloatOption("tieThreshold", 't',
+			"Threshold below which a split will be forced to break ties.", 0.05, 0.0, 1.0);
 
-	public FloatOption tieThresholdOption = new FloatOption(
-			"tieThreshold", 't', "Threshold below which a split will be forced to break ties.",
-			0.05, 0.0, 1.0);
+	public FloatOption PageHinckleyAlphaOption = new FloatOption("PageHinckleyAlpha", 'a',
+			"Alpha value to use in the Page Hinckley change detection tests.", 0.005, 0.0, 1.0);
 
-	public FloatOption PageHinckleyAlphaOption = new FloatOption(
-			"PageHinckleyAlpha", 'a', "Alpha value to use in the Page Hinckley change detection tests.",
-			0.005, 0.0, 1.0);
+	public IntOption PageHinckleyThresholdOption = new IntOption("PageHinckleyThreshold", 'h',
+			"Threshold value used in the Page Hinckley change detection tests.", 50, 0, Integer.MAX_VALUE);
 
-	public IntOption PageHinckleyThresholdOption = new IntOption(
-			"PageHinckleyThreshold", 'h', "Threshold value used in the Page Hinckley change detection tests.",
-			50, 0, Integer.MAX_VALUE);
+	public FloatOption alternateTreeFadingFactorOption = new FloatOption("alternateTreeFadingFactor", 'f',
+			"Fading factor used to decide if an alternate tree should replace an original.", 0.995, 0.0, 1.0);
 
-	public FloatOption alternateTreeFadingFactorOption = new FloatOption(
-			"alternateTreeFadingFactor", 'f', "Fading factor used to decide if an alternate tree should replace an original.",
-			0.995, 0.0, 1.0);
+	public IntOption alternateTreeTMinOption = new IntOption("alternateTreeTMin", 'y',
+			"Tmin value used to decide if an alternate tree should replace an original.", 150, 0, Integer.MAX_VALUE);
 
-	public IntOption alternateTreeTMinOption = new IntOption(
-			"alternateTreeTMin", 'y', "Tmin value used to decide if an alternate tree should replace an original.",
-			150, 0, Integer.MAX_VALUE);
+	public IntOption alternateTreeTimeOption = new IntOption("alternateTreeTime", 'u',
+			"The number of instances used to decide if an alternate tree should be discarded.", 1500, 0,
+			Integer.MAX_VALUE);
 
-	public IntOption alternateTreeTimeOption = new IntOption(
-			"alternateTreeTime", 'u', "The number of instances used to decide if an alternate tree should be discarded.",
-			1500, 0, Integer.MAX_VALUE);
+	public FlagOption regressionTreeOption = new FlagOption("regressionTree", 'e',
+			"Build a regression tree instead of a model tree.");
 
-	public FlagOption regressionTreeOption = new FlagOption(
-			"regressionTree", 'e', "Build a regression tree instead of a model tree.");
+	public FloatOption learningRatioOption = new FloatOption("learningRatio", 'l',
+			"Learning ratio to used for training the Perceptrons in the leaves.", 0.003, 0, 1.00);
 
-	public FloatOption learningRatioOption = new FloatOption(
-			"learningRatio", 'l', "Learning ratio to used for training the Perceptrons in the leaves.",
-			0.003, 0, 1.00);
+	public FloatOption learningRateDecayFactorOption = new FloatOption("learningRatioDecayFactor", 'd',
+			"Learning rate decay factor (not used when learning rate is constant).", 0.001, 0, 1.00);
 
-	public FloatOption learningRateDecayFactorOption = new FloatOption(
-			"learningRatioDecayFactor", 'd', "Learning rate decay factor (not used when learning rate is constant).",
-			0.001, 0, 1.00);
+	public FlagOption learningRatioConstOption = new FlagOption("learningRatioConst", 'p',
+			"Keep learning rate constant instead of decaying.");
 
-	public FlagOption learningRatioConstOption = new FlagOption(
-			"learningRatioConst", 'p', "Keep learning rate constant instead of decaying.");
-	
-	public IntOption maxDepthOption = new IntOption(
-			"maxDepthFactor", 'b', "The maximum depth of the tree.",
+	public IntOption maxDepthOption = new IntOption("maxDepthFactor", 'b', "The maximum depth of the tree.",
 			Integer.MAX_VALUE, 0, Integer.MAX_VALUE);
 
-	//endregion ================ OPTIONS ================
+	// endregion ================ OPTIONS ================
 
-	//region ================ CLASSES ================
+	// region ================ CLASSES ================
 
 	public abstract static class Node extends AbstractMOAObject {
 
@@ -135,9 +124,9 @@ public abstract static class Node extends AbstractMOAObject {
 		public int ID;
 
 		protected FIMTDD tree;
-		
+
 		protected boolean changeDetection = true;
-		
+
 		protected Node parent;
 
 		protected Node alternateTree;
@@ -155,7 +144,7 @@ public abstract static class Node extends AbstractMOAObject {
 
 		public Node(FIMTDD tree) {
 			this.tree = tree;
-			ID = tree.maxID; 
+			ID = tree.maxID;
 		}
 
 		public void copyStatistics(Node node) {
@@ -166,14 +155,15 @@ public void copyStatistics(Node node) {
 		}
 
 		public long calcByteSize() {
-			return SizeOf.sizeOf(this) + (originalNode == null && alternateTree != null ? alternateTree.calcByteSize() : 0);
+			return SizeOf.sizeOf(this)
+					+ (originalNode == null && alternateTree != null ? alternateTree.calcByteSize() : 0);
 		}
 
 		/**
 		 * Set the parent node
 		 */
 		public void setParent(Node parent) {
-			this.parent = parent;    
+			this.parent = parent;
 		}
 
 		/**
@@ -190,19 +180,20 @@ public void disableChangeDetection() {
 		public void restartChangeDetection() {
 			changeDetection = true;
 		}
-		
+
+		@Override
 		public void getDescription(StringBuilder sb, int indent) {
-			
+
 		}
 
 		public double getPrediction(Instance inst) {
 			return 0;
 		}
-		
+
 		public void describeSubtree(StringBuilder out, int indent) {
 			StringUtils.appendIndented(out, indent, "Leaf");
 		}
-		
+
 		public int getLevel() {
 			Node target = this;
 			int level = 0;
@@ -235,7 +226,7 @@ public int getNumSubtrees() {
 		public int numLeaves() {
 			return 1;
 		}
-		
+
 		protected boolean skipInLevelCount() {
 			return false;
 		}
@@ -247,12 +238,12 @@ public static class LeafNode extends Node {
 
 		public double errorModel = 0.0;
 		public double errorTargetMean = 0.0;
-		
+
 		// Perceptron model that carries out the actual learning in each node
 		public FIMTDDPerceptron learningModel;
 
-		protected AutoExpandVector<FIMTDDNumericAttributeClassObserver> attributeObservers = new AutoExpandVector<FIMTDDNumericAttributeClassObserver>();
-		
+		protected AutoExpandVector<FIMTDDNumericAttributeClassObserver> attributeObservers = new AutoExpandVector<>();
+
 		protected double examplesSeenAtLastSplitEvaluation = 0;
 
 		/**
@@ -269,6 +260,7 @@ public LeafNode(FIMTDD tree) {
 			sumOfAbsErrors = 0;
 		}
 
+		@Override
 		public long calcByteSize() {
 			long size = super.calcByteSize();
 			if (tree.buildingModelTree())
@@ -276,30 +268,35 @@ public long calcByteSize() {
 			size += SizeOf.fullSizeOf(attributeObservers);
 			return size;
 		}
-		
+
+		@Override
 		public void setChild(int parentBranch, Node node) {
 		}
 
+		@Override
 		public int getChildIndex(Node child) {
 			return -1;
 		}
 
+		@Override
 		public int getNumSubtrees() {
 			return 1;
 		}
 
+		@Override
 		protected boolean skipInLevelCount() {
 			return false;
 		}
-		
+
 		/**
-		 * Method to learn from an instance that passes the new instance to the perceptron learner,
-		 * and also prevents the class value from being truncated to an int when it is passed to the
-		 * attribute observer
+		 * Method to learn from an instance that passes the new instance to the
+		 * perceptron learner, and also prevents the class value from being truncated to
+		 * an int when it is passed to the attribute observer
 		 */
 		public void learnFromInstance(Instance inst, boolean growthAllowed, double prediction) {
-			//The prediction must be calculated here -- it may be different from the tree's prediction due to alternate trees
-			
+			// The prediction must be calculated here -- it may be different from the tree's
+			// prediction due to alternate trees
+
 			// Update the statistics for this node
 			// number of instances passing through the node
 			examplesSeen += inst.weight();
@@ -311,15 +308,16 @@ public void learnFromInstance(Instance inst, boolean growthAllowed, double predi
 			sumOfSquares += inst.weight() * inst.classValue() * inst.classValue();
 
 			// sum of absolute errors
-			sumOfAbsErrors += inst.weight() * Math.abs(tree.normalizeTargetValue(Math.abs(inst.classValue() - prediction)));
-			
+			sumOfAbsErrors += inst.weight()
+					* Math.abs(tree.normalizeTargetValue(Math.abs(inst.classValue() - prediction)));
+
 			if (tree.buildingModelTree()) {
 				double predictionModel = getPredictionModel(inst);
 				double predictionTargetMean = getPredictionTargetMean(inst);
-				
+
 				errorModel = errorModel * 0.95 + Math.abs(predictionModel - inst.classValue());
 				errorTargetMean = errorTargetMean * 0.95 + Math.abs(predictionTargetMean - inst.classValue());
-				
+
 				learningModel.updatePerceptron(inst);
 			}
 
@@ -344,14 +342,16 @@ public void learnFromInstance(Instance inst, boolean growthAllowed, double predi
 		}
 
 		/**
-		 * Return the best split suggestions for this node using the given split criteria
+		 * Return the best split suggestions for this node using the given split
+		 * criteria
 		 */
 		public AttributeSplitSuggestion[] getBestSplitSuggestions(SplitCriterion criterion) {
 
-			List<AttributeSplitSuggestion> bestSuggestions = new LinkedList<AttributeSplitSuggestion>();
+			List<AttributeSplitSuggestion> bestSuggestions = new LinkedList<>();
 
-			// Set the nodeStatistics up as the preSplitDistribution, rather than the observedClassDistribution
-			double[] nodeSplitDist = new double[] {examplesSeen, sumOfValues, sumOfSquares};
+			// Set the nodeStatistics up as the preSplitDistribution, rather than the
+			// observedClassDistribution
+			double[] nodeSplitDist = new double[] { examplesSeen, sumOfValues, sumOfSquares };
 
 			for (int i = 0; i < this.attributeObservers.size(); i++) {
 				FIMTDDNumericAttributeClassObserver obs = this.attributeObservers.get(i);
@@ -382,24 +382,29 @@ public double getPredictionTargetMean(Instance inst) {
 			return (examplesSeen > 0.0) ? sumOfValues / examplesSeen : 0.0;
 		}
 
+		@Override
 		public double getPrediction(Instance inst) {
 			if (tree.buildingModelTree()) {
 				return (errorModel < errorTargetMean) ? getPredictionModel(inst) : getPredictionTargetMean(inst);
 			} else
 				return getPredictionTargetMean(inst);
 		}
-		
+
 		public void checkForSplit(Instance inst, double prediction) {
-			// If it has seen Nmin examples since it was last tested for splitting, attempt a split of this node
-			if (this.getLevel() < tree.maxDepthOption.getValue() && examplesSeen - examplesSeenAtLastSplitEvaluation >= tree.gracePeriodOption.getValue()) {
+			// If it has seen Nmin examples since it was last tested for splitting, attempt
+			// a split of this node
+			if (this.getLevel() < tree.maxDepthOption.getValue()
+					&& examplesSeen - examplesSeenAtLastSplitEvaluation >= tree.gracePeriodOption.getValue()) {
 				int index = (parent != null) ? parent.getChildIndex(this) : 0;
 				tree.attemptToSplit(this, parent, index, inst, prediction);
 
-				// Take note of how many instances were seen when this split evaluation was made, so we know when to perform the next split evaluation
+				// Take note of how many instances were seen when this split evaluation was
+				// made, so we know when to perform the next split evaluation
 				examplesSeenAtLastSplitEvaluation = examplesSeen;
 			}
 		}
 
+		@Override
 		public void describeSubtree(StringBuilder out, int indent) {
 			StringUtils.appendIndented(out, indent, "Leaf ");
 			if (tree.buildingModelTree()) {
@@ -415,7 +420,7 @@ public abstract static class InnerNode extends Node {
 		// The InnerNode and SplitNode design is used for easy extension in ORTO
 		private static final long serialVersionUID = 1L;
 
-		protected AutoExpandVector<Node> children = new AutoExpandVector<Node>();
+		protected AutoExpandVector<Node> children = new AutoExpandVector<>();
 
 		// The error values for the Page Hinckley test
 		// PHmT = the cumulative sum of the errors
@@ -430,11 +435,12 @@ public abstract static class InnerNode extends Node {
 		protected double lossNumQiTests;
 		protected double lossSumQi;
 		protected double previousWeight = 0;
-		
+
 		public InnerNode(FIMTDD tree) {
 			super(tree);
 		}
-		
+
+		@Override
 		public long calcByteSize() {
 			long size = super.calcByteSize();
 			for (Node child : children)
@@ -446,24 +452,29 @@ public int numChildren() {
 			return children.size();
 		}
 
+		@Override
 		public int numLeaves() {
 			int leaves = 0;
-			for (Node child : children) leaves += child.numLeaves();
+			for (Node child : children)
+				leaves += child.numLeaves();
 			return leaves;
 		}
-		
+
 		public Node getChild(int index) {
 			return children.get(index);
 		}
 
+		@Override
 		public int getChildIndex(Node child) {
 			return children.indexOf(child);
 		}
 
+		@Override
 		public void setChild(int index, Node child) {
 			children.set(index, child);
 		}
 
+		@Override
 		public void disableChangeDetection() {
 			changeDetection = false;
 			for (Node child : children) {
@@ -471,6 +482,7 @@ public void disableChangeDetection() {
 			}
 		}
 
+		@Override
 		public void restartChangeDetection() {
 			if (alternateTree == null) {
 				changeDetection = true;
@@ -480,24 +492,24 @@ public void restartChangeDetection() {
 					child.restartChangeDetection();
 			}
 		}
-		
+
 		/**
 		 * Check to see if the tree needs updating
 		 */
-		public boolean PageHinckleyTest(double error, double threshold) {    
+		public boolean PageHinckleyTest(double error, double threshold) {
 			// Update the cumulative mT sum
 			PHsum += error;
 
 			// Update the minimum mT value if the new mT is
 			// smaller than the current minimum
-			if(PHsum < PHmin) {
+			if (PHsum < PHmin) {
 				PHmin = PHsum;
 			}
 			// Return true if the cumulative value - the current minimum is
 			// greater than the current threshold (in which case we should adapt)
 			return PHsum - PHmin > threshold;
 		}
-		
+
 		public void initializeAlternateTree() {
 			// Start a new alternate tree, beginning with a learning node
 			alternateTree = tree.newLeafNode();
@@ -521,7 +533,7 @@ public void initializeAlternateTree() {
 			disableChangeDetection();
 		}
 	}
-	
+
 	public static class SplitNode extends InnerNode {
 
 		private static final long serialVersionUID = 1L;
@@ -530,13 +542,15 @@ public static class SplitNode extends InnerNode {
 
 		/**
 		 * Create a new SplitNode
-		 * @param tree 
+		 * 
+		 * @param tree
 		 */
 		public SplitNode(InstanceConditionalTest splitTest, FIMTDD tree) {
 			super(tree);
 			this.splitTest = splitTest;
 		}
-		
+
+		@Override
 		public long calcByteSize() {
 			long size = super.calcByteSize();
 			size += SizeOf.sizeOf(splitTest);
@@ -546,18 +560,18 @@ public long calcByteSize() {
 		public int instanceChildIndex(Instance inst) {
 			return splitTest.branchForInstance(inst);
 		}
-		
+
 		public Node descendOneStep(Instance inst) {
 			return children.get(splitTest.branchForInstance(inst));
 		}
 
+		@Override
 		public void describeSubtree(StringBuilder out, int indent) {
 			for (int branch = 0; branch < children.size(); branch++) {
 				Node child = getChild(branch);
 				if (child != null) {
 					StringUtils.appendIndented(out, indent, "if ");
-					out.append(this.splitTest.describeConditionForBranch(branch,
-							tree.getModelContext()));
+					out.append(this.splitTest.describeConditionForBranch(branch, tree.getModelContext()));
 					out.append(": ");
 					StringUtils.appendNewline(out);
 					child.describeSubtree(out, indent + 2);
@@ -565,6 +579,7 @@ public void describeSubtree(StringBuilder out, int indent) {
 			}
 		}
 
+		@Override
 		public double getPrediction(Instance inst) {
 			return children.get(splitTest.branchForInstance(inst)).getPrediction(inst);
 		}
@@ -573,11 +588,11 @@ public double getPrediction(Instance inst) {
 	public class FIMTDDPerceptron implements Serializable {
 
 		private static final long serialVersionUID = 1L;
-		
+
 		protected FIMTDD tree;
-		
-		// The Perception weights 
-		protected double[] weightAttribute; 
+
+		// The Perception weights
+		protected double[] weightAttribute;
 
 		// The number of instances contributing to this model
 		protected double instancesSeen = 0;
@@ -601,17 +616,17 @@ public FIMTDDPerceptron(FIMTDD tree) {
 		public long calcByteSize() {
 			return SizeOf.sizeOf(this);
 		}
-		
+
 		public void initializeWeights() {
-			weightAttribute = new double[tree.getModelContext().numInputAttributes()+1];
+			weightAttribute = new double[tree.getModelContext().numInputAttributes() + 1];
 			instancesSeen = 0;
-			for (int j = 0; j < tree.getModelContext().numInputAttributes()+1; j++) {
+			for (int j = 0; j < tree.getModelContext().numInputAttributes() + 1; j++) {
 				// The last index corresponds to the constant b
 				weightAttribute[j] = 2 * tree.classifierRandom.nextDouble() - 1;
 			}
 			normalizeWeights();
 		}
-		
+
 		/**
 		 * Update the model using the provided instance
 		 */
@@ -625,29 +640,30 @@ public void updatePerceptron(Instance inst) {
 			if (tree.learningRatioConstOption.isSet()) {
 				learningRatio = learningRatioOption.getValue();
 			} else {
-				learningRatio = learningRatioOption.getValue() / (1 + instancesSeen * tree.learningRateDecayFactorOption.getValue());
+				learningRatio = learningRatioOption.getValue()
+						/ (1 + instancesSeen * tree.learningRateDecayFactorOption.getValue());
 			}
 
-			// Loop for compatibility with bagging methods 
+			// Loop for compatibility with bagging methods
 			for (int i = 0; i < (int) inst.weight(); i++) {
 				updateWeights(inst, learningRatio);
 			}
-		
+
 		}
 
 		public void updateWeights(Instance inst, double learningRatio) {
 			// Compute the normalized instance and the delta
-			double[] normalizedInstance = normalizedInstance(inst); 
+			double[] normalizedInstance = normalizedInstance(inst);
 			double normalizedPrediction = prediction(normalizedInstance);
 			double normalizedValue = tree.normalizeTargetValue(inst.classValue());
 			double delta = normalizedValue - normalizedPrediction;
 			for (int i = 0; i < weightAttribute.length; i++) {
 				weightAttribute[i] += delta * learningRatio * normalizedInstance[i];
 			}
-			
+
 			normalizeWeights();
 		}
-		
+
 		public void normalizeWeights() {
 			double sum = 0;
 			for (int i = 0; i < this.weightAttribute.length; i++)
@@ -658,16 +674,18 @@ public void normalizeWeights() {
 
 		public double[] normalizedInstance(Instance inst) {
 			// Normalize Instance
-			double[] normalizedInstance = new double[inst.numInputAttributes()+1];
+			double[] normalizedInstance = new double[inst.numInputAttributes() + 1];
 			for (int j = 0; j < inst.numInputAttributes(); j++) {
 				double mean = tree.sumOfAttrValues.getValue(j) / tree.examplesSeen;
-				double sd = computeSD(tree.sumOfAttrSquares.getValue(j), tree.sumOfAttrValues.getValue(j), tree.examplesSeen);
+				double sd = computeSD(tree.sumOfAttrSquares.getValue(j), tree.sumOfAttrValues.getValue(j),
+						tree.examplesSeen);
 				if (inst.inputAttribute(j).isNumeric() && tree.examplesSeen > 1 && sd > 0.0000001)
 					normalizedInstance[j] = (inst.valueInputAttribute(j) - mean) / (sd);
 				else
 					normalizedInstance[j] = 0;
 			}
-			normalizedInstance[inst.numInputAttributes()] = tree.examplesSeen > 1 ? 1 : 0; // Value to be multiplied with the constant factor
+			normalizedInstance[inst.numInputAttributes()] = tree.examplesSeen > 1 ? 1 : 0; // Value to be multiplied
+																							// with the constant factor
 			return normalizedInstance;
 		}
 
@@ -690,40 +708,41 @@ protected double prediction(Instance inst) {
 		private double denormalizePrediction(double normalizedPrediction) {
 			double mean = tree.sumOfValues / tree.examplesSeen;
 			double sd = computeSD(tree.sumOfSquares, tree.sumOfValues, tree.examplesSeen);
-			if (examplesSeen > 1) 
+			if (examplesSeen > 1)
 				return normalizedPrediction * sd + mean;
 			else
 				return 0.0;
 		}
-		
+
 		public void getModelDescription(StringBuilder out, int indent) {
-	        StringUtils.appendIndented(out, indent, getClassNameString() + " =");
+			StringUtils.appendIndented(out, indent, getClassNameString() + " =");
 			if (getModelContext() != null) {
 				for (int j = 0; j < getModelContext().numAttributes() - 1; j++) {
 					if (getModelContext().attribute(j).isNumeric()) {
 						out.append((j == 0 || weightAttribute[j] < 0) ? " " : " + ");
-		                out.append(String.format("%.4f", weightAttribute[j]));
-		                out.append(" * ");
-		                out.append(getAttributeNameString(j));
-		            }
-		        }
+						out.append(String.format("%.4f", weightAttribute[j]));
+						out.append(" * ");
+						out.append(getAttributeNameString(j));
+					}
+				}
 				out.append(" + " + weightAttribute[getModelContext().numInputAttributes()]);
 			}
-	        StringUtils.appendNewline(out);
+			StringUtils.appendNewline(out);
 		}
 	}
 
+	// endregion ================ CLASSES ================
 
-	//endregion ================ CLASSES ================
-
-	//region ================ METHODS ================
+	// region ================ METHODS ================
 
 	// region --- Regressor methods
-	
+
+	@Override
 	public String getPurposeString() {
 		return "Implementation of the FIMT-DD tree as described by Ikonomovska et al.";
 	}
 
+	@Override
 	public void resetLearningImpl() {
 		this.treeRoot = null;
 		this.leafNodeCount = 0;
@@ -737,38 +756,41 @@ public void resetLearningImpl() {
 		this.sumOfAttrSquares = new DoubleVector();
 	}
 
+	@Override
 	public boolean isRandomizable() {
 		return true;
 	}
 
+	@Override
 	public void getModelDescription(StringBuilder out, int indent) {
-		if (treeRoot != null) treeRoot.describeSubtree(out, indent);
+		if (treeRoot != null)
+			treeRoot.describeSubtree(out, indent);
 	}
 
+	@Override
 	protected Measurement[] getModelMeasurementsImpl() {
-		return new Measurement[]{ 
-				new Measurement("tree size (leaves)", this.leafNodeCount)
-		};
+		return new Measurement[] { new Measurement("tree size (leaves)", this.leafNodeCount) };
 	}
 
 	@Override
 	public long measureByteSize() {
 		return calcByteSize();
 	}
-	
+
 	public long calcByteSize() {
-		long size = (long) (SizeOf.sizeOf(this)) + this.treeRoot.calcByteSize();
-		size += (long) (SizeOf.sizeOf(this.sumOfAttrValues)) + (int) (SizeOf.sizeOf(this.sumOfAttrSquares));
+		long size = (SizeOf.sizeOf(this)) + this.treeRoot.calcByteSize();
+		size += (SizeOf.sizeOf(this.sumOfAttrValues)) + (int) (SizeOf.sizeOf(this.sumOfAttrSquares));
 		return size;
 	}
 
+	@Override
 	public Prediction getPredictionForInstance(Instance inst) {
 		return new RegressionPrediction((treeRoot == null) ? 0 : treeRoot.getPrediction(inst));
 	}
 
 	public double normalizeTargetValue(double value) {
 		if (examplesSeen > 1) {
-			double sd = Math.sqrt((sumOfSquares - ((sumOfValues * sumOfValues)/examplesSeen))/examplesSeen);
+			double sd = Math.sqrt((sumOfSquares - ((sumOfValues * sumOfValues) / examplesSeen)) / examplesSeen);
 			double average = sumOfValues / examplesSeen;
 			if (sd > 0 && examplesSeen > 1)
 				return (value - average) / sd;
@@ -784,7 +806,6 @@ public double getNormalizedError(Instance inst, double prediction) {
 		return Math.abs(normalValue - normalPrediction);
 	}
 
-	
 	public void updateStatistics(Instance inst) {
 		examplesSeen += inst.weight();
 		sumOfValues += inst.weight() * inst.classValue();
@@ -800,19 +821,21 @@ public void updateStatistics(Instance inst) {
 	/**
 	 * Method for updating (training) the model using a new instance
 	 */
+	@Override
 	public void trainOnInstanceImpl(Instance inst) {
 		checkRoot();
 
 		double prediction = treeRoot.getPrediction(inst);
 		double normalError = getNormalizedError(inst, prediction);
-	
+
 		processInstance(inst, treeRoot, prediction, normalError, true, false);
-		
+
 		updateStatistics(inst);
 
 	}
 
-	public void processInstance(Instance inst, Node node, double prediction, double normalError, boolean growthAllowed, boolean inAlternate) {
+	public void processInstance(Instance inst, Node node, double prediction, double normalError, boolean growthAllowed,
+			boolean inAlternate) {
 		Node currentNode = node;
 		while (true) {
 			if (currentNode instanceof LeafNode) {
@@ -826,13 +849,15 @@ public void processInstance(Instance inst, Node node, double prediction, double
 					boolean altTree = true;
 					double lossO = Math.pow(inst.classValue() - prediction, 2);
 					double lossA = Math.pow(inst.classValue() - iNode.alternateTree.getPrediction(inst), 2);
-					
+
 					// Loop for compatibility with bagging methods
 					for (int i = 0; i < inst.weight(); i++) {
-						iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
-						iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
+						iNode.lossFadedSumOriginal = lossO
+								+ alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
+						iNode.lossFadedSumAlternate = lossA
+								+ alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
 						iNode.lossExamplesSeen++;
-						
+
 						double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
 						iNode.lossSumQi += Qi;
 						iNode.lossNumQiTests += 1;
@@ -840,7 +865,7 @@ public void processInstance(Instance inst, Node node, double prediction, double
 					double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
 					double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
 					double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
-					
+
 					if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
 						iNode.previousWeight = iNode.lossExamplesSeen;
 						if (Qi > 0) {
@@ -851,21 +876,24 @@ public void processInstance(Instance inst, Node node, double prediction, double
 							if (parent != null) {
 								Node replacementTree = iNode.alternateTree;
 								parent.setChild(parent.getChildIndex(iNode), replacementTree);
-								if (growthAllowed) replacementTree.restartChangeDetection();
+								if (growthAllowed)
+									replacementTree.restartChangeDetection();
 							} else {
 								treeRoot = iNode.alternateTree;
 								treeRoot.restartChangeDetection();
 							}
 							leafNodeCount += iNode.alternateTree.numLeaves() - iNode.numLeaves();
 
-
 							currentNode = iNode.alternateTree;
 							currentNode.originalNode = null;
 							altTree = false;
-						} else if (QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * alternateTreeTMinOption.getValue()) || iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()) {
+						} else if (QiAverage < previousQiAverage
+								&& iNode.lossExamplesSeen >= (10 * alternateTreeTMinOption.getValue())
+								|| iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()) {
 							// Remove the alternate tree
 							iNode.alternateTree = null;
-							if (growthAllowed) iNode.restartChangeDetection();
+							if (growthAllowed)
+								iNode.restartChangeDetection();
 							altTree = false;
 						}
 					}
@@ -877,7 +905,8 @@ public void processInstance(Instance inst, Node node, double prediction, double
 				}
 
 				if (iNode.changeDetection && !inAlternate) {
-					if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+					if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen
+							- PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
 						System.out.println("CD triggered!");
 						iNode.initializeAlternateTree();
 						growthAllowed = false;
@@ -885,13 +914,13 @@ public void processInstance(Instance inst, Node node, double prediction, double
 				}
 				if (currentNode instanceof SplitNode) {
 					currentNode = ((SplitNode) currentNode).descendOneStep(inst);
-				} 
+				}
 			}
 		}
 	}
 
 	// endregion --- Regressor methods
-	
+
 	// region --- Object instatiation methods
 
 	protected FIMTDDNumericAttributeClassObserver newNumericClassObserver() {
@@ -912,10 +941,10 @@ protected FIMTDDPerceptron newLeafModel() {
 		return new FIMTDDPerceptron(this);
 	}
 
-	//endregion --- Object instatiation methods
-	
+	// endregion --- Object instatiation methods
+
 	// region --- Processing methods
-	
+
 	public void checkRoot() {
 		if (treeRoot == null) {
 			treeRoot = newLeafNode();
@@ -924,7 +953,7 @@ public void checkRoot() {
 	}
 
 	public static double computeHoeffdingBound(double range, double confidence, double n) {
-		return Math.sqrt(( (range * range) * Math.log(1 / confidence)) / (2.0 * n));
+		return Math.sqrt(((range * range) * Math.log(1 / confidence)) / (2.0 * n));
 	}
 
 	public boolean buildingModelTree() {
@@ -933,8 +962,9 @@ public boolean buildingModelTree() {
 
 	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex, Instance inst, double prediction) {
 
-		// Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
- 		SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
+		// Set the split criterion to use to the SDR split criterion as described by
+		// Ikonomovska et al.
+		SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
 
 		// Using this criterion, find the best split per attribute and rank the results
 		AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion);
@@ -948,39 +978,51 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex, Insta
 			shouldSplit = bestSplitSuggestions.length > 0;
 		} else { // Otherwise, consider which of the splits proposed may be worth trying
 
-			// Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
-			// to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
+			// Determine the Hoeffding bound value, used to select how many instances should
+			// be used to make a test decision
+			// to feel reasonably confident that the test chosen by this sample is the same
+			// as what would be chosen using infinite examples
 			double hoeffdingBound = computeHoeffdingBound(1, this.splitConfidenceOption.getValue(), node.examplesSeen);
 			// Determine the top two ranked splitting suggestions
 			AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
 			AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
 
-			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
-			// as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
-			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
+			// If the upper bound of the sample mean for the ratio of SDR(best suggestion)
+			// to SDR(second best suggestion),
+			// as determined using the Hoeffding bound, is less than 1, then the true mean
+			// is also less than 1, and thus at this
+			// particular moment of observation the bestSuggestion is indeed the best split
+			// option with confidence 1-delta, and
 			// splitting should occur.
-			// Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
-			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
-			// competing attributes are equally good, and the split will be made on the one with the higher SDR value.
-			if ((secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) || (hoeffdingBound < this.tieThresholdOption.getValue())) {
+			// Alternatively, if two or more splits are very similar or identical in terms
+			// of their splits, then a threshold limit
+			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is
+			// smaller than this limit then the two
+			// competing attributes are equally good, and the split will be made on the one
+			// with the higher SDR value.
+			if ((secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound)
+					|| (hoeffdingBound < this.tieThresholdOption.getValue())) {
 				shouldSplit = true;
 			}
-			// If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
+			// If the splitting criterion was not met, initiate pruning of the E-BST
+			// structures in each attribute observer
 			else {
 				for (int i = 0; i < node.attributeObservers.size(); i++) {
 					FIMTDDNumericAttributeClassObserver obs = node.attributeObservers.get(i);
 					if (obs != null) {
-						obs.removeBadSplits(splitCriterion, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound);    
+						obs.removeBadSplits(splitCriterion, secondBestSuggestion.merit / bestSuggestion.merit,
+								bestSuggestion.merit, hoeffdingBound);
 					}
 				}
 			}
 		}
 
-		// If the splitting criterion were met, split the current node using the chosen attribute test, and
+		// If the splitting criterion were met, split the current node using the chosen
+		// attribute test, and
 		// make two new branches leading to (empty) leaves
 		if (shouldSplit) {
 			AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
-						
+
 			SplitNode newSplit = newSplitNode(splitDecision.splitTest);
 			newSplit.copyStatistics(node);
 			newSplit.changeDetection = node.changeDetection;
@@ -990,8 +1032,8 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex, Insta
 				LeafNode newChild = newLeafNode();
 				if (buildingModelTree()) {
 					// Copy the splitting node's perceptron to it's children
-					newChild.learningModel = new FIMTDDPerceptron((FIMTDDPerceptron) node.learningModel);
-					
+					newChild.learningModel = new FIMTDDPerceptron(node.learningModel);
+
 				}
 				newChild.changeDetection = node.changeDetection;
 				newChild.setParent(newSplit);
@@ -1006,18 +1048,18 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex, Insta
 				((SplitNode) parent).setChild(parentIndex, newSplit);
 				newSplit.setParent(parent);
 			}
-			
+
 			splitNodeCount++;
 		}
 	}
-	
+
 	public double computeSD(double squaredVal, double val, double size) {
 		if (size > 1)
 			return Math.sqrt((squaredVal - ((val * val) / size)) / size);
 		else
 			return 0.0;
 	}
-	
+
 	public double scalarProduct(DoubleVector u, DoubleVector v) {
 		double ret = 0.0;
 		for (int i = 0; i < Math.max(u.numValues(), v.numValues()); i++) {
@@ -1025,7 +1067,7 @@ public double scalarProduct(DoubleVector u, DoubleVector v) {
 		}
 		return ret;
 	}
-	//endregion --- Processing methods
-	
-	//endregion ================ METHODS ================
+	// endregion --- Processing methods
+
+	// endregion ================ METHODS ================
 }
\ No newline at end of file
diff --git a/moa/src/main/java/moa/learners/predictors/trees/HoeffdingAdaptiveTree.java b/moa/src/main/java/moa/learners/predictors/trees/HoeffdingAdaptiveTree.java
new file mode 100644
index 000000000..c2c32f4bc
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/trees/HoeffdingAdaptiveTree.java
@@ -0,0 +1,514 @@
+/*
+ *    HoeffdingAdaptiveTree.java
+ *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.trees;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Random;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
+import moa.core.DoubleVector;
+import moa.core.MiscUtils;
+import moa.core.Utils;
+import moa.learners.predictors.bayes.NaiveBayes;
+import moa.learners.predictors.core.conditionaltests.InstanceConditionalTest;
+import moa.learners.predictors.core.driftdetection.ADWIN;
+
+/**
+ * Hoeffding Adaptive Tree for evolving data streams.
+ *
+ * <p>
+ * This adaptive Hoeffding Tree uses ADWIN to monitor performance of branches on
+ * the tree and to replace them with new branches when their accuracy decreases
+ * if the new branches are more accurate.
+ * </p>
+ * See details in:
+ * </p>
+ * <p>
+ * Adaptive Learning from Evolving Data Streams. Albert Bifet, Ricard Gavaldà.
+ * IDA 2009
+ * </p>
+ *
+ * <ul>
+ * <li>Same parameters as <code>HoeffdingTreeNBAdaptive</code></li>
+ * <li>-l : Leaf prediction to use: MajorityClass (MC), Naive Bayes (NB) or
+ * NaiveBayes adaptive (NBAdaptive).
+ * </ul>
+ *
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @version $Revision: 7 $
+ */
+public class HoeffdingAdaptiveTree extends HoeffdingTree {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Hoeffding Adaptive Tree for evolving data streams that uses ADWIN to replace branches for new ones.";
+	}
+
+	/*
+	 * public MultiChoiceOption leafpredictionOption = new MultiChoiceOption(
+	 * "leafprediction", 'l', "Leaf prediction to use.", new String[]{ "MC", "NB",
+	 * "NBAdaptive"}, new String[]{ "Majority class", "Naive Bayes",
+	 * "Naive Bayes Adaptive"}, 2);
+	 */
+
+	public interface NewNode {
+
+		// Change for adwin
+		// public boolean getErrorChange();
+		int numberLeaves();
+
+		double getErrorEstimation();
+
+		double getErrorWidth();
+
+		boolean isNullError();
+
+		void killTreeChilds(HoeffdingAdaptiveTree ht);
+
+		void learnFromInstance(Instance inst, HoeffdingAdaptiveTree ht, SplitNode parent, int parentBranch);
+
+		void filterInstanceToLeaves(Instance inst, SplitNode myparent, int parentBranch, List<FoundNode> foundNodes,
+				boolean updateSplitterCounts);
+	}
+
+	public static class AdaSplitNode extends SplitNode implements NewNode {
+
+		private static final long serialVersionUID = 1L;
+
+		protected Node alternateTree;
+
+		protected ADWIN estimationErrorWeight;
+		// public boolean isAlternateTree = false;
+
+		public boolean ErrorChange = false;
+
+		protected int randomSeed = 1;
+
+		protected Random classifierRandom;
+
+		// public boolean getErrorChange() {
+		// return ErrorChange;
+		// }
+		@Override
+		public int calcByteSizeIncludingSubtree() {
+			int byteSize = calcByteSize();
+			if (alternateTree != null) {
+				byteSize += alternateTree.calcByteSizeIncludingSubtree();
+			}
+			if (estimationErrorWeight != null) {
+				byteSize += estimationErrorWeight.measureByteSize();
+			}
+			for (Node child : this.children) {
+				if (child != null) {
+					byteSize += child.calcByteSizeIncludingSubtree();
+				}
+			}
+			return byteSize;
+		}
+
+		public AdaSplitNode(InstanceConditionalTest splitTest, double[] classObservations, int size) {
+			super(splitTest, classObservations, size);
+			this.classifierRandom = new Random(this.randomSeed);
+		}
+
+		public AdaSplitNode(InstanceConditionalTest splitTest, double[] classObservations) {
+			super(splitTest, classObservations);
+			this.classifierRandom = new Random(this.randomSeed);
+		}
+
+		@Override
+		public int numberLeaves() {
+			int numLeaves = 0;
+			for (Node child : this.children) {
+				if (child != null) {
+					numLeaves += ((NewNode) child).numberLeaves();
+				}
+			}
+			return numLeaves;
+		}
+
+		@Override
+		public double getErrorEstimation() {
+			return this.estimationErrorWeight.getEstimation();
+		}
+
+		@Override
+		public double getErrorWidth() {
+			double w = 0.0;
+			if (isNullError() == false) {
+				w = this.estimationErrorWeight.getWidth();
+			}
+			return w;
+		}
+
+		@Override
+		public boolean isNullError() {
+			return (this.estimationErrorWeight == null);
+		}
+
+		// SplitNodes can have alternative trees, but LearningNodes can't
+		// LearningNodes can split, but SplitNodes can't
+		// Parent nodes are allways SplitNodes
+		@Override
+		public void learnFromInstance(Instance inst, HoeffdingAdaptiveTree ht, SplitNode parent, int parentBranch) {
+			int trueClass = (int) inst.classValue();
+			// New option vore
+			int k = MiscUtils.poisson(1.0, this.classifierRandom);
+			Instance weightedInst = inst.copy();
+			if (k > 0) {
+				// weightedInst.setWeight(inst.weight() * k);
+			}
+			// Compute ClassPrediction using filterInstanceToLeaf
+			// int ClassPrediction = Utils.maxIndex(filterInstanceToLeaf(inst, null,
+			// -1).node.getClassVotes(inst, ht));
+			int ClassPrediction = 0;
+			if (filterInstanceToLeaf(inst, parent, parentBranch).node != null) {
+				ClassPrediction = Utils
+						.maxIndex(filterInstanceToLeaf(inst, parent, parentBranch).node.getClassVotes(inst, ht));
+			}
+
+			boolean blCorrect = (trueClass == ClassPrediction);
+
+			if (this.estimationErrorWeight == null) {
+				this.estimationErrorWeight = new ADWIN();
+			}
+			double oldError = this.getErrorEstimation();
+			this.ErrorChange = this.estimationErrorWeight.setInput(blCorrect == true ? 0.0 : 1.0);
+			if (this.ErrorChange == true && oldError > this.getErrorEstimation()) {
+				// if error is decreasing, don't do anything
+				this.ErrorChange = false;
+			}
+
+			// Check condition to build a new alternate tree
+			// if (this.isAlternateTree == false) {
+			if (this.ErrorChange == true) {// && this.alternateTree == null) {
+				// Start a new alternative tree : learning node
+				this.alternateTree = ht.newLearningNode();
+				// this.alternateTree.isAlternateTree = true;
+				ht.alternateTrees++;
+			} // Check condition to replace tree
+			else if (this.alternateTree != null && ((NewNode) this.alternateTree).isNullError() == false) {
+				if (this.getErrorWidth() > 300 && ((NewNode) this.alternateTree).getErrorWidth() > 300) {
+					double oldErrorRate = this.getErrorEstimation();
+					double altErrorRate = ((NewNode) this.alternateTree).getErrorEstimation();
+					double fDelta = .05;
+					// if (gNumAlts>0) fDelta=fDelta/gNumAlts;
+					double fN = 1.0 / (((NewNode) this.alternateTree).getErrorWidth()) + 1.0 / (this.getErrorWidth());
+					double Bound = Math.sqrt(2.0 * oldErrorRate * (1.0 - oldErrorRate) * Math.log(2.0 / fDelta) * fN);
+					if (Bound < oldErrorRate - altErrorRate) {
+						// Switch alternate tree
+						ht.activeLeafNodeCount -= this.numberLeaves();
+						ht.activeLeafNodeCount += ((NewNode) this.alternateTree).numberLeaves();
+						killTreeChilds(ht);
+						if (parent != null) {
+							parent.setChild(parentBranch, this.alternateTree);
+							// ((AdaSplitNode) parent.getChild(parentBranch)).alternateTree = null;
+						} else {
+							// Switch root tree
+							ht.treeRoot = ((AdaSplitNode) ht.treeRoot).alternateTree;
+						}
+						ht.switchedAlternateTrees++;
+					} else if (Bound < altErrorRate - oldErrorRate) {
+						// Erase alternate tree
+						if (this.alternateTree instanceof ActiveLearningNode) {
+							this.alternateTree = null;
+							// ht.activeLeafNodeCount--;
+						} else if (this.alternateTree instanceof InactiveLearningNode) {
+							this.alternateTree = null;
+							// ht.inactiveLeafNodeCount--;
+						} else {
+							((AdaSplitNode) this.alternateTree).killTreeChilds(ht);
+						}
+						ht.prunedAlternateTrees++;
+					}
+				}
+			}
+			// }
+			// learnFromInstance alternate Tree and Child nodes
+			if (this.alternateTree != null) {
+				((NewNode) this.alternateTree).learnFromInstance(weightedInst, ht, parent, parentBranch);
+			}
+			int childBranch = this.instanceChildIndex(inst);
+			Node child = this.getChild(childBranch);
+			if (child != null) {
+				((NewNode) child).learnFromInstance(weightedInst, ht, this, childBranch);
+			}
+		}
+
+		@Override
+		public void killTreeChilds(HoeffdingAdaptiveTree ht) {
+			for (Node child : this.children) {
+				if (child != null) {
+					// Delete alternate tree if it exists
+					if (child instanceof AdaSplitNode && ((AdaSplitNode) child).alternateTree != null) {
+						((NewNode) ((AdaSplitNode) child).alternateTree).killTreeChilds(ht);
+						ht.prunedAlternateTrees++;
+					}
+					// Recursive delete of SplitNodes
+					if (child instanceof AdaSplitNode) {
+						((NewNode) child).killTreeChilds(ht);
+					}
+					if (child instanceof ActiveLearningNode) {
+						child = null;
+						ht.activeLeafNodeCount--;
+					} else if (child instanceof InactiveLearningNode) {
+						child = null;
+						ht.inactiveLeafNodeCount--;
+					}
+				}
+			}
+		}
+
+		// New for option votes
+		// @Override
+		@Override
+		public void filterInstanceToLeaves(Instance inst, SplitNode myparent, int parentBranch,
+				List<FoundNode> foundNodes, boolean updateSplitterCounts) {
+			if (updateSplitterCounts) {
+				this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight());
+			}
+			int childIndex = instanceChildIndex(inst);
+			if (childIndex >= 0) {
+				Node child = getChild(childIndex);
+				if (child != null) {
+					((NewNode) child).filterInstanceToLeaves(inst, this, childIndex, foundNodes, updateSplitterCounts);
+				} else {
+					foundNodes.add(new FoundNode(null, this, childIndex));
+				}
+			}
+			if (this.alternateTree != null) {
+				((NewNode) this.alternateTree).filterInstanceToLeaves(inst, this, -999, foundNodes,
+						updateSplitterCounts);
+			}
+		}
+	}
+
+	public static class AdaLearningNode extends LearningNodeNBAdaptive implements NewNode {
+
+		private static final long serialVersionUID = 1L;
+
+		protected ADWIN estimationErrorWeight;
+
+		public boolean ErrorChange = false;
+
+		protected int randomSeed = 1;
+
+		protected Random classifierRandom;
+
+		@Override
+		public int calcByteSize() {
+			int byteSize = super.calcByteSize();
+			if (estimationErrorWeight != null) {
+				byteSize += estimationErrorWeight.measureByteSize();
+			}
+			return byteSize;
+		}
+
+		public AdaLearningNode(double[] initialClassObservations) {
+			super(initialClassObservations);
+			this.classifierRandom = new Random(this.randomSeed);
+		}
+
+		@Override
+		public int numberLeaves() {
+			return 1;
+		}
+
+		@Override
+		public double getErrorEstimation() {
+			if (this.estimationErrorWeight != null) {
+				return this.estimationErrorWeight.getEstimation();
+			} else {
+				return 0;
+			}
+		}
+
+		@Override
+		public double getErrorWidth() {
+			return this.estimationErrorWeight.getWidth();
+		}
+
+		@Override
+		public boolean isNullError() {
+			return (this.estimationErrorWeight == null);
+		}
+
+		@Override
+		public void killTreeChilds(HoeffdingAdaptiveTree ht) {
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, HoeffdingAdaptiveTree ht, SplitNode parent, int parentBranch) {
+			int trueClass = (int) inst.classValue();
+			// New option vore
+			int k = MiscUtils.poisson(1.0, this.classifierRandom);
+			Instance weightedInst = inst.copy();
+			if (k > 0) {
+				weightedInst.setWeight(inst.weight() * k);
+			}
+			// Compute ClassPrediction using filterInstanceToLeaf
+			int ClassPrediction = Utils.maxIndex(this.getClassVotes(inst, ht));
+
+			boolean blCorrect = (trueClass == ClassPrediction);
+
+			if (this.estimationErrorWeight == null) {
+				this.estimationErrorWeight = new ADWIN();
+			}
+			double oldError = this.getErrorEstimation();
+			this.ErrorChange = this.estimationErrorWeight.setInput(blCorrect == true ? 0.0 : 1.0);
+			if (this.ErrorChange == true && oldError > this.getErrorEstimation()) {
+				this.ErrorChange = false;
+			}
+
+			// Update statistics
+			learnFromInstance(weightedInst, ht); // inst
+
+			// Check for Split condition
+			double weightSeen = this.getWeightSeen();
+			if (weightSeen - this.getWeightSeenAtLastSplitEvaluation() >= ht.gracePeriodOption.getValue()) {
+				ht.attemptToSplit(this, parent, parentBranch);
+				this.setWeightSeenAtLastSplitEvaluation(weightSeen);
+			}
+
+			// learnFromInstance alternate Tree and Child nodes
+			/*
+			 * if (this.alternateTree != null) {
+			 * this.alternateTree.learnFromInstance(inst,ht); } for (Node child :
+			 * this.children) { if (child != null) { child.learnFromInstance(inst,ht); } }
+			 */
+		}
+
+		@Override
+		public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
+			double[] dist;
+			int predictionOption = ((HoeffdingAdaptiveTree) ht).leafpredictionOption.getChosenIndex();
+			if (predictionOption == 0) { // MC
+				dist = this.observedClassDistribution.getArrayCopy();
+			} else if (predictionOption == 1) { // NB
+				dist = NaiveBayes.doNaiveBayesPrediction(inst, this.observedClassDistribution, this.attributeObservers);
+			} else { // NBAdaptive
+				if (this.mcCorrectWeight > this.nbCorrectWeight) {
+					dist = this.observedClassDistribution.getArrayCopy();
+				} else {
+					dist = NaiveBayes.doNaiveBayesPrediction(inst, this.observedClassDistribution,
+							this.attributeObservers);
+				}
+			}
+			// New for option votes
+			double distSum = Utils.sum(dist);
+			if (distSum * this.getErrorEstimation() * this.getErrorEstimation() > 0.0) {
+				Utils.normalize(dist, distSum * this.getErrorEstimation() * this.getErrorEstimation()); // Adding weight
+			}
+			return dist;
+		}
+
+		// New for option votes
+		@Override
+		public void filterInstanceToLeaves(Instance inst, SplitNode splitparent, int parentBranch,
+				List<FoundNode> foundNodes, boolean updateSplitterCounts) {
+			foundNodes.add(new FoundNode(this, splitparent, parentBranch));
+		}
+	}
+
+	protected int alternateTrees;
+
+	protected int prunedAlternateTrees;
+
+	protected int switchedAlternateTrees;
+
+	@Override
+	protected LearningNode newLearningNode(double[] initialClassObservations) {
+		// IDEA: to choose different learning nodes depending on predictionOption
+		return new AdaLearningNode(initialClassObservations);
+	}
+
+	@Override
+	protected SplitNode newSplitNode(InstanceConditionalTest splitTest, double[] classObservations, int size) {
+		return new AdaSplitNode(splitTest, classObservations, size);
+	}
+
+	@Override
+	protected SplitNode newSplitNode(InstanceConditionalTest splitTest, double[] classObservations) {
+		return new AdaSplitNode(splitTest, classObservations);
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		if (this.treeRoot == null) {
+			this.treeRoot = newLearningNode();
+			this.activeLeafNodeCount = 1;
+		}
+		((NewNode) this.treeRoot).learnFromInstance(inst, this, null, -1);
+	}
+
+	// New for options vote
+	public FoundNode[] filterInstanceToLeaves(Instance inst, SplitNode parent, int parentBranch,
+			boolean updateSplitterCounts) {
+		List<FoundNode> nodes = new LinkedList<>();
+		((NewNode) this.treeRoot).filterInstanceToLeaves(inst, parent, parentBranch, nodes, updateSplitterCounts);
+		return nodes.toArray(new FoundNode[nodes.size()]);
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		if (this.treeRoot != null) {
+			FoundNode[] foundNodes = filterInstanceToLeaves(inst, null, -1, false);
+			DoubleVector result = new DoubleVector();
+			int predictionPaths = 0;
+			for (FoundNode foundNode : foundNodes) {
+				if (foundNode.parentBranch != -999) {
+					Node leafNode = foundNode.node;
+					if (leafNode == null) {
+						leafNode = foundNode.parent;
+					}
+					double[] dist = leafNode.getClassVotes(inst, this);
+					// Albert: changed for weights
+					// double distSum = Utils.sum(dist);
+					// if (distSum > 0.0) {
+					// Utils.normalize(dist, distSum);
+					// }
+					result.addValues(dist);
+					// predictionPaths++;
+				}
+			}
+			// if (predictionPaths > this.maxPredictionPaths) {
+			// this.maxPredictionPaths++;
+			// }
+			return new ClassificationPrediction(result.getArrayRef());
+		}
+		return new ClassificationPrediction();
+	}
+
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == HoeffdingAdaptiveTree.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/trees/HoeffdingAdaptiveTreeClassifLeaves.java b/moa/src/main/java/moa/learners/predictors/trees/HoeffdingAdaptiveTreeClassifLeaves.java
new file mode 100644
index 000000000..d76118cb4
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/trees/HoeffdingAdaptiveTreeClassifLeaves.java
@@ -0,0 +1,185 @@
+/*
+ *    HoeffdingAdaptiveTreeClassifLeaves.java
+ *    Copyright (C) 2016 Pontifical Catholic University of Paraná, Curitiba, Brazil
+ *    @author Jean Paul Barddal (jean.barddal@ppgia.pucpr.br)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.trees;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.core.AttributeSplitSuggestion;
+import moa.learners.predictors.core.splitcriteria.SplitCriterion;
+import moa.options.ClassOption;
+
+/**
+ * Hoeffding Adaptive Tree for evolving data streams that has a classifier at
+ * the leaves.
+ *
+ * @version 1.0
+ * @see First used in the data stream configuration in J. P. Barddal, H. M.
+ *      Gomes, F. Enembreck, B. Pfahringer & A. Bifet. ON DYNAMIC FEATURE
+ *      WEIGHTING FOR FEATURE DRIFTING DATA STREAMS. In European Conference on
+ *      Machine Learning and Principles and Practice of Knowledge Discovery
+ *      (ECML/PKDD'16). 2016.
+ */
+public class HoeffdingAdaptiveTreeClassifLeaves extends HoeffdingAdaptiveTree {
+
+	public ClassOption leaveLearnerOption = new ClassOption("leaveLearner", 'a', "Classifier to train.",
+			Classifier.class, "bayes.NaiveBayes");
+
+	public HoeffdingAdaptiveTreeClassifLeaves() {
+		this.removePoorAttsOption = null;
+	}
+
+	@Override
+	protected LearningNode newLearningNode(double[] initialClassObservations) {
+		return new LearningNodeHATClassifier(initialClassObservations, null, this);
+	}
+
+	// @Override
+	protected LearningNode newLearningNode(double[] initialClassObservations, Classifier cl) {
+		return new LearningNodeHATClassifier(initialClassObservations, cl, this);
+	}
+
+	@Override
+	protected void attemptToSplit(ActiveLearningNode node, SplitNode parent, int parentIndex) {
+		if (!node.observedClassDistributionIsPure()) {
+			SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
+			AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion, this);
+			Arrays.sort(bestSplitSuggestions);
+			boolean shouldSplit = false;
+			if (bestSplitSuggestions.length < 2) {
+				shouldSplit = bestSplitSuggestions.length > 0;
+			} else {
+				double hoeffdingBound = computeHoeffdingBound(
+						splitCriterion.getRangeOfMerit(node.getObservedClassDistribution()),
+						this.splitConfidenceOption.getValue(), node.getWeightSeen());
+				AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+				AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
+
+				if ((bestSuggestion.merit - secondBestSuggestion.merit > hoeffdingBound)
+						|| (hoeffdingBound < this.tieThresholdOption.getValue())) {
+					shouldSplit = true;
+				}
+
+				if ((this.removePoorAttsOption != null) && this.removePoorAttsOption.isSet()) {
+					Set<Integer> poorAtts = new HashSet<>();
+					// scan 1 - add any poor to set
+					for (int i = 0; i < bestSplitSuggestions.length; i++) {
+						if (bestSplitSuggestions[i].splitTest != null) {
+							int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
+							if (splitAtts.length == 1) {
+								if (bestSuggestion.merit - bestSplitSuggestions[i].merit > hoeffdingBound) {
+									poorAtts.add(new Integer(splitAtts[0]));
+								}
+							}
+						}
+					}
+					// scan 2 - remove good ones from set
+					for (int i = 0; i < bestSplitSuggestions.length; i++) {
+						if (bestSplitSuggestions[i].splitTest != null) {
+							int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
+							if (splitAtts.length == 1) {
+								if (bestSuggestion.merit - bestSplitSuggestions[i].merit < hoeffdingBound) {
+									poorAtts.remove(new Integer(splitAtts[0]));
+								}
+							}
+						}
+					}
+					for (int poorAtt : poorAtts) {
+						node.disableAttribute(poorAtt);
+					}
+				}
+			}
+			if (shouldSplit) {
+				AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+				if (splitDecision.splitTest == null) {
+					// preprune - null wins
+					deactivateLearningNode(node, parent, parentIndex);
+				} else {
+					SplitNode newSplit = newSplitNode(splitDecision.splitTest, node.getObservedClassDistribution());
+					for (int i = 0; i < splitDecision.numSplits(); i++) {
+						// Unique Change of HoeffdingTree
+						Node newChild = newLearningNode(splitDecision.resultingClassDistributionFromSplit(i),
+								((LearningNodeHATClassifier) node).getClassifier());
+						newSplit.setChild(i, newChild);
+					}
+					this.activeLeafNodeCount--;
+					this.decisionNodeCount++;
+					this.activeLeafNodeCount += splitDecision.numSplits();
+					if (parent == null) {
+						this.treeRoot = newSplit;
+					} else {
+						parent.setChild(parentIndex, newSplit);
+					}
+				}
+				// manage memory
+				enforceTrackerLimit();
+			}
+		}
+	}
+
+	public class LearningNodeHATClassifier extends AdaLearningNode {
+
+		protected Classifier classifier;
+
+		public LearningNodeHATClassifier(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		public LearningNodeHATClassifier(double[] initialClassObservations, Classifier cl,
+				HoeffdingAdaptiveTreeClassifLeaves ht) {
+			super(initialClassObservations);
+
+			if (cl == null) {
+				this.classifier = (Classifier) getPreparedClassOption(ht.leaveLearnerOption);
+			} else {
+				this.classifier = (Classifier) cl.copy();
+			}
+		}
+
+		@Override
+		public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
+			if (getWeightSeen() >= ((HoeffdingAdaptiveTreeClassifLeaves) ht).nbThresholdOption.getValue()) {
+				return this.classifier.getPredictionForInstance(inst).asDoubleArray();
+			}
+			return super.getClassVotes(inst, ht);
+		}
+
+		@Override
+		public void disableAttribute(int attIndex) {
+			// should not disable poor atts - they are used in NB calc
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, HoeffdingTree ht) {
+			this.classifier.trainOnInstance(inst);
+			super.learnFromInstance(inst, ht);
+		}
+
+		public Classifier getClassifier() {
+			return this.classifier;
+		}
+
+	}
+
+}
diff --git a/moa/src/main/java/moa/learners/predictors/trees/HoeffdingOptionTree.java b/moa/src/main/java/moa/learners/predictors/trees/HoeffdingOptionTree.java
new file mode 100644
index 000000000..84b0e5711
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/trees/HoeffdingOptionTree.java
@@ -0,0 +1,1157 @@
+/*
+ *    HoeffdingOptionTree.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.trees;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.PrintStream;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
+import com.github.javacliparser.FileOption;
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.AbstractMOAObject;
+import moa.capabilities.CapabilitiesHandler;
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.SizeOf;
+import moa.core.StringUtils;
+import moa.core.Utils;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.bayes.NaiveBayes;
+import moa.learners.predictors.core.AttributeSplitSuggestion;
+import moa.learners.predictors.core.attributeclassobservers.AttributeClassObserver;
+import moa.learners.predictors.core.attributeclassobservers.DiscreteAttributeClassObserver;
+import moa.learners.predictors.core.attributeclassobservers.NullAttributeClassObserver;
+import moa.learners.predictors.core.attributeclassobservers.NumericAttributeClassObserver;
+import moa.learners.predictors.core.conditionaltests.InstanceConditionalTest;
+import moa.learners.predictors.core.conditionaltests.NumericAttributeBinaryTest;
+import moa.learners.predictors.core.splitcriteria.SplitCriterion;
+import moa.options.ClassOption;
+
+/**
+ * Hoeffding Option Tree.
+ *
+ * <p>
+ * Hoeffding Option Trees are regular Hoeffding trees containing additional
+ * option nodes that allow several tests to be applied, leading to multiple
+ * Hoeffding trees as separate paths. They consist of a single structure that
+ * efficiently represents multiple trees. A particular example can travel down
+ * multiple paths of the tree, contributing, in different ways, to different
+ * options.
+ * </p>
+ *
+ * <p>
+ * See for details:
+ * </p>
+ * <p>
+ * B. Pfahringer, G. Holmes, and R. Kirkby. New options for hoeffding trees. In
+ * AI, pages 90–99, 2007.
+ * </p>
+ *
+ * <p>
+ * Parameters:
+ * </p>
+ * <ul>
+ * <li>-o : Maximum number of option paths per node</li>
+ * <li>-m : Maximum memory consumed by the tree</li>
+ * <li>-n : Numeric estimator to use :</li>
+ * <ul>
+ * <li>Gaussian approximation evaluating 10 splitpoints</li>
+ * <li>Gaussian approximation evaluating 100 splitpoints</li>
+ * <li>Greenwald-Khanna quantile summary with 10 tuples</li>
+ * <li>Greenwald-Khanna quantile summary with 100 tuples</li>
+ * <li>Greenwald-Khanna quantile summary with 1000 tuples</li>
+ * <li>VFML method with 10 bins</li>
+ * <li>VFML method with 100 bins</li>
+ * <li>VFML method with 1000 bins</li>
+ * <li>Exhaustive binary tree</li>
+ * </ul>
+ * <li>-e : How many instances between memory consumption checks</li>
+ * <li>-g : The number of instances a leaf should observe between split
+ * attempts</li>
+ * <li>-s : Split criterion to use. Example : InfoGainSplitCriterion</li>
+ * <li>-c : The allowable error in split decision, values closer to 0 will take
+ * longer to decide</li>
+ * <li>-w : The allowable error in secondary split decisions, values closer to 0
+ * will take longer to decide</li>
+ * <li>-t : Threshold below which a split will be forced to break ties</li>
+ * <li>-b : Only allow binary splits</li>
+ * <li>-z : Memory strategy to use</li>
+ * <li>-r : Disable poor attributes</li>
+ * <li>-p : Disable pre-pruning</li>
+ * <li>-d : File to append option table to.</li>
+ * <li>-l : Leaf prediction to use: MajorityClass (MC), Naive Bayes (NB) or
+ * NaiveBayes adaptive (NBAdaptive).</li>
+ * <li>-q : The number of instances a leaf should observe before permitting
+ * Naive Bayes</li>
+ * </ul>
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public class HoeffdingOptionTree extends AbstractClassifier implements Classifier, CapabilitiesHandler {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Hoeffding Option Tree: single tree that represents multiple trees.";
+	}
+
+	public IntOption maxOptionPathsOption = new IntOption("maxOptionPaths", 'o',
+			"Maximum number of option paths per node.", 5, 1, Integer.MAX_VALUE);
+
+	public IntOption maxByteSizeOption = new IntOption("maxByteSize", 'm', "Maximum memory consumed by the tree.",
+			33554432, 0, Integer.MAX_VALUE);
+
+	/*
+	 * public MultiChoiceOption numericEstimatorOption = new MultiChoiceOption(
+	 * "numericEstimator", 'n', "Numeric estimator to use.", new String[]{
+	 * "GAUSS10", "GAUSS100", "GK10", "GK100", "GK1000", "VFML10", "VFML100",
+	 * "VFML1000", "BINTREE"}, new String[]{ "Gaussian approximation evaluating 10
+	 * splitpoints", "Gaussian approximation evaluating 100 splitpoints",
+	 * "Greenwald-Khanna quantile summary with 10 tuples", "Greenwald-Khanna
+	 * quantile summary with 100 tuples", "Greenwald-Khanna quantile summary with
+	 * 1000 tuples", "VFML method with 10 bins", "VFML method with 100 bins", "VFML
+	 * method with 1000 bins", "Exhaustive binary tree"}, 0);
+	 */
+	public ClassOption numericEstimatorOption = new ClassOption("numericEstimator", 'n', "Numeric estimator to use.",
+			NumericAttributeClassObserver.class, "GaussianNumericAttributeClassObserver");
+
+	public ClassOption nominalEstimatorOption = new ClassOption("nominalEstimator", 'd', "Nominal estimator to use.",
+			DiscreteAttributeClassObserver.class, "NominalAttributeClassObserver");
+
+	public IntOption memoryEstimatePeriodOption = new IntOption("memoryEstimatePeriod", 'e',
+			"How many instances between memory consumption checks.", 1000000, 0, Integer.MAX_VALUE);
+
+	public IntOption gracePeriodOption = new IntOption("gracePeriod", 'g',
+			"The number of instances a leaf should observe between split attempts.", 200, 0, Integer.MAX_VALUE);
+
+	public ClassOption splitCriterionOption = new ClassOption("splitCriterion", 's', "Split criterion to use.",
+			SplitCriterion.class, "InfoGainSplitCriterion");
+
+	public FloatOption splitConfidenceOption = new FloatOption("splitConfidence", 'c',
+			"The allowable error in split decision, values closer to 0 will take longer to decide.", 0.0000001, 0.0,
+			1.0);
+
+	public FloatOption secondarySplitConfidenceOption = new FloatOption("secondarySplitConfidence", 'w',
+			"The allowable error in secondary split decisions, values closer to 0 will take longer to decide.", 0.1,
+			0.0, 1.0);
+
+	public FloatOption tieThresholdOption = new FloatOption("tieThreshold", 't',
+			"Threshold below which a split will be forced to break ties.", 0.05, 0.0, 1.0);
+
+	public FlagOption binarySplitsOption = new FlagOption("binarySplits", 'b', "Only allow binary splits.");
+
+	public FlagOption removePoorAttsOption = new FlagOption("removePoorAtts", 'r', "Disable poor attributes.");
+
+	public FlagOption noPrePruneOption = new FlagOption("noPrePrune", 'p', "Disable pre-pruning.");
+
+	public FileOption dumpFileOption = new FileOption("dumpFile", 'f', "File to append option table to.", null, "csv",
+			true);
+
+	public IntOption memoryStrategyOption = new IntOption("memStrategy", 'z', "Memory strategy to use.", 2);
+
+	public static class FoundNode {
+
+		public Node node;
+
+		public SplitNode parent;
+
+		public int parentBranch; // set to -999 for option leaves
+
+		public FoundNode(Node node, SplitNode parent, int parentBranch) {
+			this.node = node;
+			this.parent = parent;
+			this.parentBranch = parentBranch;
+		}
+	}
+
+	public static class Node extends AbstractMOAObject {
+
+		private static final long serialVersionUID = 1L;
+
+		protected DoubleVector observedClassDistribution;
+
+		public Node(double[] classObservations) {
+			this.observedClassDistribution = new DoubleVector(classObservations);
+		}
+
+		public int calcByteSize() {
+			return (int) (SizeOf.sizeOf(this) + SizeOf.fullSizeOf(this.observedClassDistribution));
+		}
+
+		public int calcByteSizeIncludingSubtree() {
+			return calcByteSize();
+		}
+
+		public boolean isLeaf() {
+			return true;
+		}
+
+		public FoundNode[] filterInstanceToLeaves(Instance inst, SplitNode parent, int parentBranch,
+				boolean updateSplitterCounts) {
+			List<FoundNode> nodes = new LinkedList<>();
+			filterInstanceToLeaves(inst, parent, parentBranch, nodes, updateSplitterCounts);
+			return nodes.toArray(new FoundNode[nodes.size()]);
+		}
+
+		public void filterInstanceToLeaves(Instance inst, SplitNode splitparent, int parentBranch,
+				List<FoundNode> foundNodes, boolean updateSplitterCounts) {
+			foundNodes.add(new FoundNode(this, splitparent, parentBranch));
+		}
+
+		public double[] getObservedClassDistribution() {
+			return this.observedClassDistribution.getArrayCopy();
+		}
+
+		public double[] getClassVotes(Instance inst, HoeffdingOptionTree ht) {
+			double[] dist = this.observedClassDistribution.getArrayCopy();
+			double distSum = Utils.sum(dist);
+			if (distSum > 0.0) {
+				Utils.normalize(dist, distSum);
+			}
+			return dist;
+		}
+
+		public boolean observedClassDistributionIsPure() {
+			return this.observedClassDistribution.numNonZeroEntries() < 2;
+		}
+
+		public void describeSubtree(HoeffdingOptionTree ht, StringBuilder out, int indent) {
+			StringUtils.appendIndented(out, indent, "Leaf ");
+			out.append(ht.getClassNameString());
+			out.append(" = ");
+			out.append(ht.getClassLabelString(this.observedClassDistribution.maxIndex()));
+			out.append(" weights: ");
+			this.observedClassDistribution.getSingleLineDescription(out,
+					ht.treeRoot.observedClassDistribution.numValues());
+			StringUtils.appendNewline(out);
+		}
+
+		public int subtreeDepth() {
+			return 0;
+		}
+
+		public double calculatePromise() {
+			double totalSeen = this.observedClassDistribution.sumOfValues();
+			return totalSeen > 0.0
+					? (totalSeen - this.observedClassDistribution.getValue(this.observedClassDistribution.maxIndex()))
+					: 0.0;
+		}
+
+		@Override
+		public void getDescription(StringBuilder sb, int indent) {
+			describeSubtree(null, sb, indent);
+		}
+	}
+
+	public static class SplitNode extends Node {
+
+		private static final long serialVersionUID = 1L;
+
+		protected InstanceConditionalTest splitTest;
+
+		protected SplitNode parent;
+
+		protected Node nextOption;
+
+		protected int optionCount; // set to -999 for optional splits
+
+		protected AutoExpandVector<Node> children = new AutoExpandVector<>();
+
+		@Override
+		public int calcByteSize() {
+			return super.calcByteSize() + (int) (SizeOf.sizeOf(this.children) + SizeOf.fullSizeOf(this.splitTest));
+		}
+
+		@Override
+		public int calcByteSizeIncludingSubtree() {
+			int byteSize = calcByteSize();
+			for (Node child : this.children) {
+				if (child != null) {
+					byteSize += child.calcByteSizeIncludingSubtree();
+				}
+			}
+			if (this.nextOption != null) {
+				byteSize += this.nextOption.calcByteSizeIncludingSubtree();
+			}
+			return byteSize;
+		}
+
+		public SplitNode(InstanceConditionalTest splitTest, double[] classObservations) {
+			super(classObservations);
+			this.splitTest = splitTest;
+		}
+
+		public int numChildren() {
+			return this.children.size();
+		}
+
+		public void setChild(int index, Node child) {
+			if ((this.splitTest.maxBranches() >= 0) && (index >= this.splitTest.maxBranches())) {
+				throw new IndexOutOfBoundsException();
+			}
+			this.children.set(index, child);
+		}
+
+		public Node getChild(int index) {
+			return this.children.get(index);
+		}
+
+		public int instanceChildIndex(Instance inst) {
+			return this.splitTest.branchForInstance(inst);
+		}
+
+		@Override
+		public boolean isLeaf() {
+			return false;
+		}
+
+		@Override
+		public void filterInstanceToLeaves(Instance inst, SplitNode myparent, int parentBranch,
+				List<FoundNode> foundNodes, boolean updateSplitterCounts) {
+			if (updateSplitterCounts) {
+				this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight());
+			}
+			int childIndex = instanceChildIndex(inst);
+			if (childIndex >= 0) {
+				Node child = getChild(childIndex);
+				if (child != null) {
+					child.filterInstanceToLeaves(inst, this, childIndex, foundNodes, updateSplitterCounts);
+				} else {
+					foundNodes.add(new FoundNode(null, this, childIndex));
+				}
+			}
+			if (this.nextOption != null) {
+				this.nextOption.filterInstanceToLeaves(inst, this, -999, foundNodes, updateSplitterCounts);
+			}
+		}
+
+		@Override
+		public void describeSubtree(HoeffdingOptionTree ht, StringBuilder out, int indent) {
+			for (int branch = 0; branch < numChildren(); branch++) {
+				Node child = getChild(branch);
+				if (child != null) {
+					StringUtils.appendIndented(out, indent, "if ");
+					out.append(this.splitTest.describeConditionForBranch(branch, ht.getModelContext()));
+					out.append(": ");
+					out.append("** option count = " + this.optionCount);
+					StringUtils.appendNewline(out);
+					child.describeSubtree(ht, out, indent + 2);
+				}
+			}
+		}
+
+		@Override
+		public int subtreeDepth() {
+			int maxChildDepth = 0;
+			for (Node child : this.children) {
+				if (child != null) {
+					int depth = child.subtreeDepth();
+					if (depth > maxChildDepth) {
+						maxChildDepth = depth;
+					}
+				}
+			}
+			return maxChildDepth + 1;
+		}
+
+		public double computeMeritOfExistingSplit(SplitCriterion splitCriterion, double[] preDist) {
+			double[][] postDists = new double[this.children.size()][];
+			for (int i = 0; i < this.children.size(); i++) {
+				postDists[i] = this.children.get(i).getObservedClassDistribution();
+			}
+			return splitCriterion.getMeritOfSplit(preDist, postDists);
+		}
+
+		public void updateOptionCount(SplitNode source, HoeffdingOptionTree hot) {
+			if (this.optionCount == -999) {
+				this.parent.updateOptionCount(source, hot);
+			} else {
+				int maxChildCount = -999;
+				SplitNode curr = this;
+				while (curr != null) {
+					for (Node child : curr.children) {
+						if (child instanceof SplitNode) {
+							SplitNode splitChild = (SplitNode) child;
+							if (splitChild.optionCount > maxChildCount) {
+								maxChildCount = splitChild.optionCount;
+							}
+						}
+					}
+					if ((curr.nextOption != null) && (curr.nextOption instanceof SplitNode)) {
+						curr = (SplitNode) curr.nextOption;
+					} else {
+						curr = null;
+					}
+				}
+				if (maxChildCount > this.optionCount) { // currently only works
+					// one
+					// way - adding, not
+					// removing
+					int delta = maxChildCount - this.optionCount;
+					this.optionCount = maxChildCount;
+					if (this.optionCount >= hot.maxOptionPathsOption.getValue()) {
+						killOptionLeaf(hot);
+					}
+					curr = this;
+					while (curr != null) {
+						for (Node child : curr.children) {
+							if (child instanceof SplitNode) {
+								SplitNode splitChild = (SplitNode) child;
+								if (splitChild != source) {
+									splitChild.updateOptionCountBelow(delta, hot);
+								}
+							}
+						}
+						if ((curr.nextOption != null) && (curr.nextOption instanceof SplitNode)) {
+							curr = (SplitNode) curr.nextOption;
+						} else {
+							curr = null;
+						}
+					}
+					if (this.parent != null) {
+						this.parent.updateOptionCount(this, hot);
+					}
+				}
+			}
+		}
+
+		public void updateOptionCountBelow(int delta, HoeffdingOptionTree hot) {
+			if (this.optionCount != -999) {
+				this.optionCount += delta;
+				if (this.optionCount >= hot.maxOptionPathsOption.getValue()) {
+					killOptionLeaf(hot);
+				}
+			}
+			for (Node child : this.children) {
+				if (child instanceof SplitNode) {
+					SplitNode splitChild = (SplitNode) child;
+					splitChild.updateOptionCountBelow(delta, hot);
+				}
+			}
+			if (this.nextOption instanceof SplitNode) {
+				((SplitNode) this.nextOption).updateOptionCountBelow(delta, hot);
+			}
+		}
+
+		private void killOptionLeaf(HoeffdingOptionTree hot) {
+			if (this.nextOption instanceof SplitNode) {
+				((SplitNode) this.nextOption).killOptionLeaf(hot);
+			} else if (this.nextOption instanceof ActiveLearningNode) {
+				this.nextOption = null;
+				hot.activeLeafNodeCount--;
+			} else if (this.nextOption instanceof InactiveLearningNode) {
+				this.nextOption = null;
+				hot.inactiveLeafNodeCount--;
+			}
+		}
+
+		public int getHeadOptionCount() {
+			SplitNode sn = this;
+			while (sn.optionCount == -999) {
+				sn = sn.parent;
+			}
+			return sn.optionCount;
+		}
+	}
+
+	public static abstract class LearningNode extends Node {
+
+		private static final long serialVersionUID = 1L;
+
+		public LearningNode(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		public abstract void learnFromInstance(Instance inst, HoeffdingOptionTree ht);
+	}
+
+	public static class InactiveLearningNode extends LearningNode {
+
+		private static final long serialVersionUID = 1L;
+
+		public InactiveLearningNode(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, HoeffdingOptionTree ht) {
+			this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight());
+		}
+	}
+
+	public static class ActiveLearningNode extends LearningNode {
+
+		private static final long serialVersionUID = 1L;
+
+		protected double weightSeenAtLastSplitEvaluation;
+
+		protected AutoExpandVector<AttributeClassObserver> attributeObservers = new AutoExpandVector<>();
+
+		public ActiveLearningNode(double[] initialClassObservations) {
+			super(initialClassObservations);
+			this.weightSeenAtLastSplitEvaluation = getWeightSeen();
+		}
+
+		@Override
+		public int calcByteSize() {
+			return super.calcByteSize() + (int) (SizeOf.fullSizeOf(this.attributeObservers));
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, HoeffdingOptionTree ht) {
+			this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight());
+			for (int i = 0; i < inst.numAttributes() - 1; i++) {
+				int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
+				AttributeClassObserver obs = this.attributeObservers.get(i);
+				if (obs == null) {
+					obs = inst.attribute(instAttIndex).isNominal() ? ht.newNominalClassObserver()
+							: ht.newNumericClassObserver();
+					this.attributeObservers.set(i, obs);
+				}
+				obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
+			}
+		}
+
+		public double getWeightSeen() {
+			return this.observedClassDistribution.sumOfValues();
+		}
+
+		public double getWeightSeenAtLastSplitEvaluation() {
+			return this.weightSeenAtLastSplitEvaluation;
+		}
+
+		public void setWeightSeenAtLastSplitEvaluation(double weight) {
+			this.weightSeenAtLastSplitEvaluation = weight;
+		}
+
+		public AttributeSplitSuggestion[] getBestSplitSuggestions(SplitCriterion criterion, HoeffdingOptionTree ht) {
+			List<AttributeSplitSuggestion> bestSuggestions = new LinkedList<>();
+			double[] preSplitDist = this.observedClassDistribution.getArrayCopy();
+			if (!ht.noPrePruneOption.isSet()) {
+				// add null split as an option
+				bestSuggestions.add(new AttributeSplitSuggestion(null, new double[0][],
+						criterion.getMeritOfSplit(preSplitDist, new double[][] { preSplitDist })));
+			}
+			for (int i = 0; i < this.attributeObservers.size(); i++) {
+				AttributeClassObserver obs = this.attributeObservers.get(i);
+				if (obs != null) {
+					AttributeSplitSuggestion bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion,
+							preSplitDist, i, ht.binarySplitsOption.isSet());
+					if (bestSuggestion != null) {
+						bestSuggestions.add(bestSuggestion);
+					}
+				}
+			}
+			return bestSuggestions.toArray(new AttributeSplitSuggestion[bestSuggestions.size()]);
+		}
+
+		public void disableAttribute(int attIndex) {
+			this.attributeObservers.set(attIndex, new NullAttributeClassObserver());
+		}
+	}
+
+	protected Node treeRoot;
+
+	protected int decisionNodeCount;
+
+	protected int activeLeafNodeCount;
+
+	protected int inactiveLeafNodeCount;
+
+	protected double inactiveLeafByteSizeEstimate;
+
+	protected double activeLeafByteSizeEstimate;
+
+	protected double byteSizeEstimateOverheadFraction;
+
+	protected int maxPredictionPaths;
+
+	public long calcByteSize() {
+		long size = SizeOf.sizeOf(this);
+		if (this.treeRoot != null) {
+			size += this.treeRoot.calcByteSizeIncludingSubtree();
+		}
+		return size;
+	}
+
+	@Override
+	public long measureByteSize() {
+		return calcByteSize();
+	}
+
+	@Override
+	public void resetLearningImpl() {
+		this.treeRoot = null;
+		this.decisionNodeCount = 0;
+		this.activeLeafNodeCount = 0;
+		this.inactiveLeafNodeCount = 0;
+		this.inactiveLeafByteSizeEstimate = 0.0;
+		this.activeLeafByteSizeEstimate = 0.0;
+		this.byteSizeEstimateOverheadFraction = 1.0;
+		this.maxPredictionPaths = 0;
+		if (this.leafpredictionOption.getChosenIndex() > 0) {
+			this.removePoorAttsOption = null;
+		}
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		if (this.treeRoot == null) {
+			this.treeRoot = newLearningNode();
+			this.activeLeafNodeCount = 1;
+		}
+		FoundNode[] foundNodes = this.treeRoot.filterInstanceToLeaves(inst, null, -1, true);
+		for (FoundNode foundNode : foundNodes) {
+			// option leaves will have a parentBranch of -999
+			// option splits will have an option count of -999
+			Node leafNode = foundNode.node;
+			if (leafNode == null) {
+				leafNode = newLearningNode();
+				foundNode.parent.setChild(foundNode.parentBranch, leafNode);
+				this.activeLeafNodeCount++;
+			}
+			if (leafNode instanceof LearningNode) {
+				LearningNode learningNode = (LearningNode) leafNode;
+				learningNode.learnFromInstance(inst, this);
+				if (learningNode instanceof ActiveLearningNode) {
+					ActiveLearningNode activeLearningNode = (ActiveLearningNode) learningNode;
+					double weightSeen = activeLearningNode.getWeightSeen();
+					if (weightSeen - activeLearningNode.getWeightSeenAtLastSplitEvaluation() >= this.gracePeriodOption
+							.getValue()) {
+						attemptToSplit(activeLearningNode, foundNode.parent, foundNode.parentBranch);
+						activeLearningNode.setWeightSeenAtLastSplitEvaluation(weightSeen);
+					}
+				}
+			}
+		}
+		if (this.trainingWeightSeenByModel % this.memoryEstimatePeriodOption.getValue() == 0) {
+			estimateModelByteSizes();
+		}
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		if (this.treeRoot != null) {
+			FoundNode[] foundNodes = this.treeRoot.filterInstanceToLeaves(inst, null, -1, false);
+			DoubleVector result = new DoubleVector();
+			int predictionPaths = 0;
+			for (FoundNode foundNode : foundNodes) {
+				if (foundNode.parentBranch != -999) {
+					Node leafNode = foundNode.node;
+					if (leafNode == null) {
+						leafNode = foundNode.parent;
+					}
+					double[] dist = leafNode.getClassVotes(inst, this);
+					// Albert: changed for weights
+					// double distSum = Utils.sum(dist);
+					// if (distSum > 0.0) {
+					// Utils.normalize(dist, distSum);
+					// }
+					result.addValues(dist);
+					predictionPaths++;
+				}
+			}
+			if (predictionPaths > this.maxPredictionPaths) {
+				this.maxPredictionPaths++;
+			}
+			return new ClassificationPrediction(result.getArrayRef());
+		}
+		return new ClassificationPrediction(new double[0]);
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[] {
+				new Measurement("tree size (nodes)",
+						this.decisionNodeCount + this.activeLeafNodeCount + this.inactiveLeafNodeCount),
+				new Measurement("tree size (leaves)", this.activeLeafNodeCount + this.inactiveLeafNodeCount),
+				new Measurement("active learning leaves", this.activeLeafNodeCount),
+				new Measurement("tree depth", measureTreeDepth()),
+				new Measurement("active leaf byte size estimate", this.activeLeafByteSizeEstimate),
+				new Measurement("inactive leaf byte size estimate", this.inactiveLeafByteSizeEstimate),
+				new Measurement("byte size estimate overhead", this.byteSizeEstimateOverheadFraction),
+				new Measurement("maximum prediction paths used", this.maxPredictionPaths) };
+	}
+
+	public int measureTreeDepth() {
+		if (this.treeRoot != null) {
+			return this.treeRoot.subtreeDepth();
+		}
+		return 0;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		this.treeRoot.describeSubtree(this, out, indent);
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+
+	public static double computeHoeffdingBound(double range, double confidence, double n) {
+		return Math.sqrt(((range * range) * Math.log(1.0 / confidence)) / (2.0 * n));
+	}
+
+	protected AttributeClassObserver newNominalClassObserver() {
+		AttributeClassObserver nominalClassObserver = (AttributeClassObserver) getPreparedClassOption(
+				this.nominalEstimatorOption);
+		return (AttributeClassObserver) nominalClassObserver.copy();
+	}
+
+	protected AttributeClassObserver newNumericClassObserver() {
+		AttributeClassObserver numericClassObserver = (AttributeClassObserver) getPreparedClassOption(
+				this.numericEstimatorOption);
+		return (AttributeClassObserver) numericClassObserver.copy();
+	}
+
+	protected void attemptToSplit(ActiveLearningNode node, SplitNode parent, int parentIndex) {
+		if (!node.observedClassDistributionIsPure()) {
+			SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
+			AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion, this);
+			Arrays.sort(bestSplitSuggestions);
+			boolean shouldSplit = false;
+			if (parentIndex != -999) {
+				if (bestSplitSuggestions.length < 2) {
+					shouldSplit = bestSplitSuggestions.length > 0;
+				} else {
+					double hoeffdingBound = computeHoeffdingBound(
+							splitCriterion.getRangeOfMerit(node.getObservedClassDistribution()),
+							this.splitConfidenceOption.getValue(), node.getWeightSeen());
+					AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+					AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length
+							- 2];
+					if ((bestSuggestion.merit - secondBestSuggestion.merit > hoeffdingBound)
+							|| (hoeffdingBound < this.tieThresholdOption.getValue())) {
+						shouldSplit = true;
+					}
+					if ((this.removePoorAttsOption != null) && this.removePoorAttsOption.isSet()) {
+						Set<Integer> poorAtts = new HashSet<>();
+						// scan 1 - add any poor to set
+						for (int i = 0; i < bestSplitSuggestions.length; i++) {
+							if (bestSplitSuggestions[i].splitTest != null) {
+								int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
+								if (splitAtts.length == 1) {
+									if (bestSuggestion.merit - bestSplitSuggestions[i].merit > hoeffdingBound) {
+										poorAtts.add(new Integer(splitAtts[0]));
+									}
+								}
+							}
+						}
+						// scan 2 - remove good ones from set
+						for (int i = 0; i < bestSplitSuggestions.length; i++) {
+							if (bestSplitSuggestions[i].splitTest != null) {
+								int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
+								if (splitAtts.length == 1) {
+									if (bestSuggestion.merit - bestSplitSuggestions[i].merit < hoeffdingBound) {
+										poorAtts.remove(new Integer(splitAtts[0]));
+									}
+								}
+							}
+						}
+						for (int poorAtt : poorAtts) {
+							node.disableAttribute(poorAtt);
+						}
+					}
+				}
+			} else if (bestSplitSuggestions.length > 0) {
+				double hoeffdingBound = computeHoeffdingBound(
+						splitCriterion.getRangeOfMerit(node.getObservedClassDistribution()),
+						this.secondarySplitConfidenceOption.getValue(), node.getWeightSeen());
+				AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+				// in option case, scan back through existing options to
+				// find best
+				SplitNode current = parent;
+				double bestPreviousMerit = Double.NEGATIVE_INFINITY;
+				double[] preDist = node.getObservedClassDistribution();
+				while (true) {
+					double merit = current.computeMeritOfExistingSplit(splitCriterion, preDist);
+					if (merit > bestPreviousMerit) {
+						bestPreviousMerit = merit;
+					}
+					if (current.optionCount != -999) {
+						break;
+					}
+					current = current.parent;
+				}
+
+				if (bestSuggestion.merit - bestPreviousMerit > hoeffdingBound) {
+					shouldSplit = true;
+				}
+			}
+			if (shouldSplit) {
+				AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+				if (splitDecision.splitTest == null) {
+					// preprune - null wins
+					if (parentIndex != -999) {
+						deactivateLearningNode(node, parent, parentIndex);
+					}
+				} else {
+					SplitNode newSplit = new SplitNode(splitDecision.splitTest, node.getObservedClassDistribution());
+					newSplit.parent = parent;
+					// add option procedure
+					SplitNode optionHead = parent;
+					if (parent != null) {
+						while (optionHead.optionCount == -999) {
+							optionHead = optionHead.parent;
+						}
+					}
+					if ((parentIndex == -999) && (parent != null)) {
+						// adding a new option
+						newSplit.optionCount = -999;
+						optionHead.updateOptionCountBelow(1, this);
+						if (optionHead.parent != null) {
+							optionHead.parent.updateOptionCount(optionHead, this);
+						}
+						addToOptionTable(splitDecision, optionHead.parent);
+					} else {
+						// adding a regular leaf
+						if (optionHead == null) {
+							newSplit.optionCount = 1;
+						} else {
+							newSplit.optionCount = optionHead.optionCount;
+						}
+					}
+					int numOptions = 1;
+					if (optionHead != null) {
+						numOptions = optionHead.optionCount;
+					}
+					if (numOptions < this.maxOptionPathsOption.getValue()) {
+						newSplit.nextOption = node; // preserve leaf
+						// disable attribute just used
+						int[] splitAtts = splitDecision.splitTest.getAttsTestDependsOn();
+						for (int i : splitAtts) {
+							node.disableAttribute(i);
+						}
+					} else {
+						this.activeLeafNodeCount--;
+					}
+					for (int i = 0; i < splitDecision.numSplits(); i++) {
+						Node newChild = newLearningNode(splitDecision.resultingClassDistributionFromSplit(i));
+						newSplit.setChild(i, newChild);
+					}
+					this.decisionNodeCount++;
+					this.activeLeafNodeCount += splitDecision.numSplits();
+					if (parent == null) {
+						this.treeRoot = newSplit;
+					} else {
+						if (parentIndex != -999) {
+							parent.setChild(parentIndex, newSplit);
+						} else {
+							parent.nextOption = newSplit;
+						}
+					}
+				}
+				// manage memory
+				enforceTrackerLimit();
+			}
+		}
+	}
+
+	private void addToOptionTable(AttributeSplitSuggestion bestSuggestion, SplitNode parent) {
+		File dumpFile = this.dumpFileOption.getFile();
+		PrintStream immediateResultStream = null;
+		if (dumpFile != null) {
+			try {
+				if (dumpFile.exists()) {
+					immediateResultStream = new PrintStream(new FileOutputStream(dumpFile, true), true);
+				} else {
+					immediateResultStream = new PrintStream(new FileOutputStream(dumpFile), true);
+				}
+			} catch (Exception ex) {
+				throw new RuntimeException("Unable to open dump file: " + dumpFile, ex);
+			}
+			int splitAtt = bestSuggestion.splitTest.getAttsTestDependsOn()[0];
+			double splitVal = -1.0;
+			if (bestSuggestion.splitTest instanceof NumericAttributeBinaryTest) {
+				NumericAttributeBinaryTest test = (NumericAttributeBinaryTest) bestSuggestion.splitTest;
+				splitVal = test.getSplitValue();
+			}
+			int treeDepth = 0;
+			while (parent != null) {
+				parent = parent.parent;
+				treeDepth++;
+			}
+			immediateResultStream
+					.println(this.trainingWeightSeenByModel + "," + treeDepth + "," + splitAtt + "," + splitVal);
+			immediateResultStream.flush();
+			immediateResultStream.close();
+		}
+	}
+
+	public void enforceTrackerLimit() {
+		if ((this.inactiveLeafNodeCount > 0) || ((this.activeLeafNodeCount * this.activeLeafByteSizeEstimate
+				+ this.inactiveLeafNodeCount * this.inactiveLeafByteSizeEstimate)
+				* this.byteSizeEstimateOverheadFraction > this.maxByteSizeOption.getValue())) {
+			FoundNode[] learningNodes = findLearningNodes();
+			Arrays.sort(learningNodes, new Comparator<FoundNode>() {
+
+				@Override
+				public int compare(FoundNode fn1, FoundNode fn2) {
+					if (HoeffdingOptionTree.this.memoryStrategyOption.getValue() == 0) {
+						// strategy 1 - every leaf treated equal
+						return Double.compare(fn1.node.calculatePromise(), fn2.node.calculatePromise());
+					} else if (HoeffdingOptionTree.this.memoryStrategyOption.getValue() == 1) {
+						// strategy 2 - internal leaves penalised
+						double p1 = fn1.node.calculatePromise();
+						if (fn1.parentBranch == -999) {
+							p1 /= fn1.parent.getHeadOptionCount();
+						}
+						double p2 = fn2.node.calculatePromise();
+						if (fn2.parentBranch == -999) {
+							p1 /= fn2.parent.getHeadOptionCount();
+						}
+						return Double.compare(p1, p2);
+					} else {
+						// strategy 3 - all true leaves beat internal leaves
+						if (fn1.parentBranch == -999) {
+							if (fn2.parentBranch == -999) {
+								return Double.compare(fn1.node.calculatePromise(), fn2.node.calculatePromise());
+							}
+							return -1; // fn1 < fn2
+						}
+						if (fn2.parentBranch == -999) {
+							return 1; // fn1 > fn2
+						}
+						return Double.compare(fn1.node.calculatePromise(), fn2.node.calculatePromise());
+					}
+				}
+			});
+			int maxActive = 0;
+			while (maxActive < learningNodes.length) {
+				maxActive++;
+				if ((maxActive * this.activeLeafByteSizeEstimate
+						+ (learningNodes.length - maxActive) * this.inactiveLeafByteSizeEstimate)
+						* this.byteSizeEstimateOverheadFraction > this.maxByteSizeOption.getValue()) {
+					maxActive--;
+					break;
+				}
+			}
+			int cutoff = learningNodes.length - maxActive;
+			for (int i = 0; i < cutoff; i++) {
+				if (learningNodes[i].node instanceof ActiveLearningNode) {
+					deactivateLearningNode((ActiveLearningNode) learningNodes[i].node, learningNodes[i].parent,
+							learningNodes[i].parentBranch);
+				}
+			}
+			for (int i = cutoff; i < learningNodes.length; i++) {
+				if (learningNodes[i].node instanceof InactiveLearningNode) {
+					activateLearningNode((InactiveLearningNode) learningNodes[i].node, learningNodes[i].parent,
+							learningNodes[i].parentBranch);
+				}
+			}
+		}
+	}
+
+	public void estimateModelByteSizes() {
+		FoundNode[] learningNodes = findLearningNodes();
+		long totalActiveSize = 0;
+		long totalInactiveSize = 0;
+		for (FoundNode foundNode : learningNodes) {
+			if (foundNode.node instanceof ActiveLearningNode) {
+				totalActiveSize += SizeOf.fullSizeOf(foundNode.node);
+			} else {
+				totalInactiveSize += SizeOf.fullSizeOf(foundNode.node);
+			}
+		}
+		if (totalActiveSize > 0) {
+			this.activeLeafByteSizeEstimate = (double) totalActiveSize / this.activeLeafNodeCount;
+		}
+		if (totalInactiveSize > 0) {
+			this.inactiveLeafByteSizeEstimate = (double) totalInactiveSize / this.inactiveLeafNodeCount;
+		}
+		long actualModelSize = this.measureByteSize();
+		double estimatedModelSize = (this.activeLeafNodeCount * this.activeLeafByteSizeEstimate
+				+ this.inactiveLeafNodeCount * this.inactiveLeafByteSizeEstimate);
+		this.byteSizeEstimateOverheadFraction = actualModelSize / estimatedModelSize;
+		if (actualModelSize > this.maxByteSizeOption.getValue()) {
+			enforceTrackerLimit();
+		}
+	}
+
+	public void deactivateAllLeaves() {
+		FoundNode[] learningNodes = findLearningNodes();
+		for (int i = 0; i < learningNodes.length; i++) {
+			if (learningNodes[i].node instanceof ActiveLearningNode) {
+				deactivateLearningNode((ActiveLearningNode) learningNodes[i].node, learningNodes[i].parent,
+						learningNodes[i].parentBranch);
+			}
+		}
+	}
+
+	protected void deactivateLearningNode(ActiveLearningNode toDeactivate, SplitNode parent, int parentBranch) {
+		Node newLeaf = new InactiveLearningNode(toDeactivate.getObservedClassDistribution());
+		if (parent == null) {
+			this.treeRoot = newLeaf;
+		} else {
+			if (parentBranch != -999) {
+				parent.setChild(parentBranch, newLeaf);
+			} else {
+				parent.nextOption = newLeaf;
+			}
+		}
+		this.activeLeafNodeCount--;
+		this.inactiveLeafNodeCount++;
+	}
+
+	protected void activateLearningNode(InactiveLearningNode toActivate, SplitNode parent, int parentBranch) {
+		Node newLeaf = newLearningNode(toActivate.getObservedClassDistribution());
+		if (parent == null) {
+			this.treeRoot = newLeaf;
+		} else {
+			if (parentBranch != -999) {
+				parent.setChild(parentBranch, newLeaf);
+			} else {
+				parent.nextOption = newLeaf;
+			}
+		}
+		this.activeLeafNodeCount++;
+		this.inactiveLeafNodeCount--;
+	}
+
+	protected FoundNode[] findLearningNodes() {
+		List<FoundNode> foundList = new LinkedList<>();
+		findLearningNodes(this.treeRoot, null, -1, foundList);
+		return foundList.toArray(new FoundNode[foundList.size()]);
+	}
+
+	protected void findLearningNodes(Node node, SplitNode parent, int parentBranch, List<FoundNode> found) {
+		if (node != null) {
+			if (node instanceof LearningNode) {
+				found.add(new FoundNode(node, parent, parentBranch));
+			}
+			if (node instanceof SplitNode) {
+				SplitNode splitNode = (SplitNode) node;
+				for (int i = 0; i < splitNode.numChildren(); i++) {
+					findLearningNodes(splitNode.getChild(i), splitNode, i, found);
+				}
+				findLearningNodes(splitNode.nextOption, splitNode, -999, found);
+			}
+		}
+	}
+
+	public MultiChoiceOption leafpredictionOption = new MultiChoiceOption("leafprediction", 'l',
+			"Leaf prediction to use.", new String[] { "MC", "NB", "NBAdaptive" },
+			new String[] { "Majority class", "Naive Bayes", "Naive Bayes Adaptive" }, 2);
+
+	public IntOption nbThresholdOption = new IntOption("nbThreshold", 'q',
+			"The number of instances a leaf should observe before permitting Naive Bayes.", 0, 0, Integer.MAX_VALUE);
+
+	public static class LearningNodeNB extends ActiveLearningNode {
+
+		private static final long serialVersionUID = 1L;
+
+		public LearningNodeNB(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		@Override
+		public double[] getClassVotes(Instance inst, HoeffdingOptionTree hot) {
+			if (getWeightSeen() >= hot.nbThresholdOption.getValue()) {
+				return NaiveBayes.doNaiveBayesPrediction(inst, this.observedClassDistribution, this.attributeObservers);
+			}
+			return super.getClassVotes(inst, hot);
+		}
+
+		@Override
+		public void disableAttribute(int attIndex) {
+			// should not disable poor atts - they are used in NB calc
+		}
+	}
+
+	public static class LearningNodeNBAdaptive extends LearningNodeNB {
+
+		private static final long serialVersionUID = 1L;
+
+		protected double mcCorrectWeight = 0.0;
+
+		protected double nbCorrectWeight = 0.0;
+
+		public LearningNodeNBAdaptive(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, HoeffdingOptionTree hot) {
+			int trueClass = (int) inst.classValue();
+			if (this.observedClassDistribution.maxIndex() == trueClass) {
+				this.mcCorrectWeight += inst.weight();
+			}
+			if (Utils.maxIndex(NaiveBayes.doNaiveBayesPrediction(inst, this.observedClassDistribution,
+					this.attributeObservers)) == trueClass) {
+				this.nbCorrectWeight += inst.weight();
+			}
+			super.learnFromInstance(inst, hot);
+		}
+
+		@Override
+		public double[] getClassVotes(Instance inst, HoeffdingOptionTree ht) {
+			if (this.mcCorrectWeight > this.nbCorrectWeight) {
+				return this.observedClassDistribution.getArrayCopy();
+			}
+			return NaiveBayes.doNaiveBayesPrediction(inst, this.observedClassDistribution, this.attributeObservers);
+		}
+	}
+
+	protected LearningNode newLearningNode() {
+		return newLearningNode(new double[0]);
+	}
+
+	protected LearningNode newLearningNode(double[] initialClassObservations) {
+		LearningNode ret;
+		int predictionOption = this.leafpredictionOption.getChosenIndex();
+		if (predictionOption == 0) { // MC
+			ret = new ActiveLearningNode(initialClassObservations);
+		} else if (predictionOption == 1) { // NB
+			ret = new LearningNodeNB(initialClassObservations);
+		} else { // NBAdaptive
+			ret = new LearningNodeNBAdaptive(initialClassObservations);
+		}
+		return ret;
+	}
+
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == HoeffdingOptionTree.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/trees/HoeffdingTree.java b/moa/src/main/java/moa/learners/predictors/trees/HoeffdingTree.java
new file mode 100644
index 000000000..e5833b57b
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/trees/HoeffdingTree.java
@@ -0,0 +1,888 @@
+/*
+ *    HoeffdingTree.java
+ *    Copyright (C) 2007 University of Waikato, Hamilton, New Zealand
+ *    @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.trees;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.AbstractMOAObject;
+import moa.capabilities.CapabilitiesHandler;
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.SizeOf;
+import moa.core.StringUtils;
+import moa.core.Utils;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.bayes.NaiveBayes;
+import moa.learners.predictors.core.AttributeSplitSuggestion;
+import moa.learners.predictors.core.attributeclassobservers.AttributeClassObserver;
+import moa.learners.predictors.core.attributeclassobservers.DiscreteAttributeClassObserver;
+import moa.learners.predictors.core.attributeclassobservers.NullAttributeClassObserver;
+import moa.learners.predictors.core.attributeclassobservers.NumericAttributeClassObserver;
+import moa.learners.predictors.core.conditionaltests.InstanceConditionalTest;
+import moa.learners.predictors.core.splitcriteria.SplitCriterion;
+import moa.options.ClassOption;
+
+/**
+ * Hoeffding Tree or VFDT.
+ *
+ * A Hoeffding tree is an incremental, anytime decision tree induction algorithm
+ * that is capable of learning from massive data streams, assuming that the
+ * distribution generating examples does not change over time. Hoeffding trees
+ * exploit the fact that a small sample can often be enough to choose an optimal
+ * splitting attribute. This idea is supported mathematically by the Hoeffding
+ * bound, which quantifies the number of observations (in our case, examples)
+ * needed to estimate some statistics within a prescribed precision (in our
+ * case, the goodness of an attribute).
+ * </p>
+ * <p>
+ * A theoretically appealing feature of Hoeffding Trees not shared by other
+ * incremental decision tree learners is that it has sound guarantees of
+ * performance. Using the Hoeffding bound one can show that its output is
+ * asymptotically nearly identical to that of a non-incremental learner using
+ * infinitely many examples. See for details:
+ * </p>
+ *
+ * <p>
+ * G. Hulten, L. Spencer, and P. Domingos. Mining time-changing data streams. In
+ * KDD’01, pages 97–106, San Francisco, CA, 2001. ACM Press.
+ * </p>
+ *
+ * <p>
+ * Parameters:
+ * </p>
+ * <ul>
+ * <li>-m : Maximum memory consumed by the tree</li>
+ * <li>-n : Numeric estimator to use :
+ * <ul>
+ * <li>Gaussian approximation evaluating 10 splitpoints</li>
+ * <li>Gaussian approximation evaluating 100 splitpoints</li>
+ * <li>Greenwald-Khanna quantile summary with 10 tuples</li>
+ * <li>Greenwald-Khanna quantile summary with 100 tuples</li>
+ * <li>Greenwald-Khanna quantile summary with 1000 tuples</li>
+ * <li>VFML method with 10 bins</li>
+ * <li>VFML method with 100 bins</li>
+ * <li>VFML method with 1000 bins</li>
+ * <li>Exhaustive binary tree</li>
+ * </ul>
+ * </li>
+ * <li>-e : How many instances between memory consumption checks</li>
+ * <li>-g : The number of instances a leaf should observe between split
+ * attempts</li>
+ * <li>-s : Split criterion to use. Example : InfoGainSplitCriterion</li>
+ * <li>-c : The allowable error in split decision, values closer to 0 will take
+ * longer to decide</li>
+ * <li>-t : Threshold below which a split will be forced to break ties</li>
+ * <li>-b : Only allow binary splits</li>
+ * <li>-z : Stop growing as soon as memory limit is hit</li>
+ * <li>-r : Disable poor attributes</li>
+ * <li>-p : Disable pre-pruning</li>
+ * <li>-l : Leaf prediction to use: MajorityClass (MC), Naive Bayes (NB) or
+ * NaiveBayes adaptive (NBAdaptive).</li>
+ * <li>-q : The number of instances a leaf should observe before permitting
+ * Naive Bayes</li>
+ * </ul>
+ *
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
+ * @version $Revision: 7 $
+ */
+public class HoeffdingTree extends AbstractClassifier implements Classifier, CapabilitiesHandler {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Hoeffding Tree or VFDT.";
+	}
+
+	public IntOption maxByteSizeOption = new IntOption("maxByteSize", 'm', "Maximum memory consumed by the tree.",
+			33554432, 0, Integer.MAX_VALUE);
+
+	/*
+	 * public MultiChoiceOption numericEstimatorOption = new MultiChoiceOption(
+	 * "numericEstimator", 'n', "Numeric estimator to use.", new String[]{
+	 * "GAUSS10", "GAUSS100", "GK10", "GK100", "GK1000", "VFML10", "VFML100",
+	 * "VFML1000", "BINTREE"}, new String[]{ "Gaussian approximation evaluating 10
+	 * splitpoints", "Gaussian approximation evaluating 100 splitpoints",
+	 * "Greenwald-Khanna quantile summary with 10 tuples", "Greenwald-Khanna
+	 * quantile summary with 100 tuples", "Greenwald-Khanna quantile summary with
+	 * 1000 tuples", "VFML method with 10 bins", "VFML method with 100 bins", "VFML
+	 * method with 1000 bins", "Exhaustive binary tree"}, 0);
+	 */
+	public ClassOption numericEstimatorOption = new ClassOption("numericEstimator", 'n', "Numeric estimator to use.",
+			NumericAttributeClassObserver.class, "GaussianNumericAttributeClassObserver");
+
+	public ClassOption nominalEstimatorOption = new ClassOption("nominalEstimator", 'd', "Nominal estimator to use.",
+			DiscreteAttributeClassObserver.class, "NominalAttributeClassObserver");
+
+	public IntOption memoryEstimatePeriodOption = new IntOption("memoryEstimatePeriod", 'e',
+			"How many instances between memory consumption checks.", 1000000, 0, Integer.MAX_VALUE);
+
+	public IntOption gracePeriodOption = new IntOption("gracePeriod", 'g',
+			"The number of instances a leaf should observe between split attempts.", 200, 0, Integer.MAX_VALUE);
+
+	public ClassOption splitCriterionOption = new ClassOption("splitCriterion", 's', "Split criterion to use.",
+			SplitCriterion.class, "InfoGainSplitCriterion");
+
+	public FloatOption splitConfidenceOption = new FloatOption("splitConfidence", 'c',
+			"The allowable error in split decision, values closer to 0 will take longer to decide.", 0.0000001, 0.0,
+			1.0);
+
+	public FloatOption tieThresholdOption = new FloatOption("tieThreshold", 't',
+			"Threshold below which a split will be forced to break ties.", 0.05, 0.0, 1.0);
+
+	public FlagOption binarySplitsOption = new FlagOption("binarySplits", 'b', "Only allow binary splits.");
+
+	public FlagOption stopMemManagementOption = new FlagOption("stopMemManagement", 'z',
+			"Stop growing as soon as memory limit is hit.");
+
+	public FlagOption removePoorAttsOption = new FlagOption("removePoorAtts", 'r', "Disable poor attributes.");
+
+	public FlagOption noPrePruneOption = new FlagOption("noPrePrune", 'p', "Disable pre-pruning.");
+
+	public static class FoundNode {
+
+		public Node node;
+
+		public SplitNode parent;
+
+		public int parentBranch;
+
+		public FoundNode(Node node, SplitNode parent, int parentBranch) {
+			this.node = node;
+			this.parent = parent;
+			this.parentBranch = parentBranch;
+		}
+	}
+
+	public static class Node extends AbstractMOAObject {
+
+		private static final long serialVersionUID = 1L;
+
+		protected DoubleVector observedClassDistribution;
+
+		public Node(double[] classObservations) {
+			this.observedClassDistribution = new DoubleVector(classObservations);
+		}
+
+		public int calcByteSize() {
+			return (int) (SizeOf.sizeOf(this) + SizeOf.fullSizeOf(this.observedClassDistribution));
+		}
+
+		public int calcByteSizeIncludingSubtree() {
+			return calcByteSize();
+		}
+
+		public boolean isLeaf() {
+			return true;
+		}
+
+		public FoundNode filterInstanceToLeaf(Instance inst, SplitNode parent, int parentBranch) {
+			return new FoundNode(this, parent, parentBranch);
+		}
+
+		public double[] getObservedClassDistribution() {
+			return this.observedClassDistribution.getArrayCopy();
+		}
+
+		public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
+			return this.observedClassDistribution.getArrayCopy();
+		}
+
+		public boolean observedClassDistributionIsPure() {
+			return this.observedClassDistribution.numNonZeroEntries() < 2;
+		}
+
+		public void describeSubtree(HoeffdingTree ht, StringBuilder out, int indent) {
+			StringUtils.appendIndented(out, indent, "Leaf ");
+			out.append(ht.getClassNameString());
+			out.append(" = ");
+			out.append(ht.getClassLabelString(this.observedClassDistribution.maxIndex()));
+			out.append(" weights: ");
+			this.observedClassDistribution.getSingleLineDescription(out,
+					ht.treeRoot.observedClassDistribution.numValues());
+			StringUtils.appendNewline(out);
+		}
+
+		public int subtreeDepth() {
+			return 0;
+		}
+
+		public double calculatePromise() {
+			double totalSeen = this.observedClassDistribution.sumOfValues();
+			return totalSeen > 0.0
+					? (totalSeen - this.observedClassDistribution.getValue(this.observedClassDistribution.maxIndex()))
+					: 0.0;
+		}
+
+		@Override
+		public void getDescription(StringBuilder sb, int indent) {
+			describeSubtree(null, sb, indent);
+		}
+	}
+
+	public static class SplitNode extends Node {
+
+		private static final long serialVersionUID = 1L;
+
+		protected InstanceConditionalTest splitTest;
+
+		protected AutoExpandVector<Node> children; // = new AutoExpandVector<Node>();
+
+		@Override
+		public int calcByteSize() {
+			return super.calcByteSize() + (int) (SizeOf.sizeOf(this.children) + SizeOf.fullSizeOf(this.splitTest));
+		}
+
+		@Override
+		public int calcByteSizeIncludingSubtree() {
+			int byteSize = calcByteSize();
+			for (Node child : this.children) {
+				if (child != null) {
+					byteSize += child.calcByteSizeIncludingSubtree();
+				}
+			}
+			return byteSize;
+		}
+
+		public SplitNode(InstanceConditionalTest splitTest, double[] classObservations, int size) {
+			super(classObservations);
+			this.splitTest = splitTest;
+			this.children = new AutoExpandVector<>(size);
+		}
+
+		public SplitNode(InstanceConditionalTest splitTest, double[] classObservations) {
+			super(classObservations);
+			this.splitTest = splitTest;
+			this.children = new AutoExpandVector<>();
+		}
+
+		public int numChildren() {
+			return this.children.size();
+		}
+
+		public void setChild(int index, Node child) {
+			if ((this.splitTest.maxBranches() >= 0) && (index >= this.splitTest.maxBranches())) {
+				throw new IndexOutOfBoundsException();
+			}
+			this.children.set(index, child);
+		}
+
+		public Node getChild(int index) {
+			return this.children.get(index);
+		}
+
+		public int instanceChildIndex(Instance inst) {
+			return this.splitTest.branchForInstance(inst);
+		}
+
+		@Override
+		public boolean isLeaf() {
+			return false;
+		}
+
+		@Override
+		public FoundNode filterInstanceToLeaf(Instance inst, SplitNode parent, int parentBranch) {
+			int childIndex = instanceChildIndex(inst);
+			if (childIndex >= 0) {
+				Node child = getChild(childIndex);
+				if (child != null) {
+					return child.filterInstanceToLeaf(inst, this, childIndex);
+				}
+				return new FoundNode(null, this, childIndex);
+			}
+			return new FoundNode(this, parent, parentBranch);
+		}
+
+		@Override
+		public void describeSubtree(HoeffdingTree ht, StringBuilder out, int indent) {
+			for (int branch = 0; branch < numChildren(); branch++) {
+				Node child = getChild(branch);
+				if (child != null) {
+					StringUtils.appendIndented(out, indent, "if ");
+					out.append(this.splitTest.describeConditionForBranch(branch, ht.getModelContext()));
+					out.append(": ");
+					StringUtils.appendNewline(out);
+					child.describeSubtree(ht, out, indent + 2);
+				}
+			}
+		}
+
+		@Override
+		public int subtreeDepth() {
+			int maxChildDepth = 0;
+			for (Node child : this.children) {
+				if (child != null) {
+					int depth = child.subtreeDepth();
+					if (depth > maxChildDepth) {
+						maxChildDepth = depth;
+					}
+				}
+			}
+			return maxChildDepth + 1;
+		}
+	}
+
+	public static abstract class LearningNode extends Node {
+
+		private static final long serialVersionUID = 1L;
+
+		public LearningNode(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		public abstract void learnFromInstance(Instance inst, HoeffdingTree ht);
+	}
+
+	public static class InactiveLearningNode extends LearningNode {
+
+		private static final long serialVersionUID = 1L;
+
+		public InactiveLearningNode(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, HoeffdingTree ht) {
+			this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight());
+		}
+	}
+
+	public static class ActiveLearningNode extends LearningNode {
+
+		private static final long serialVersionUID = 1L;
+
+		protected double weightSeenAtLastSplitEvaluation;
+
+		protected AutoExpandVector<AttributeClassObserver> attributeObservers = new AutoExpandVector<>();
+
+		protected boolean isInitialized;
+
+		public ActiveLearningNode(double[] initialClassObservations) {
+			super(initialClassObservations);
+			this.weightSeenAtLastSplitEvaluation = getWeightSeen();
+			this.isInitialized = false;
+		}
+
+		@Override
+		public int calcByteSize() {
+			return super.calcByteSize() + (int) (SizeOf.fullSizeOf(this.attributeObservers));
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, HoeffdingTree ht) {
+			if (this.isInitialized == false) {
+				this.attributeObservers = new AutoExpandVector<>(inst.numAttributes());
+				this.isInitialized = true;
+			}
+			this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight());
+			for (int i = 0; i < inst.numAttributes() - 1; i++) {
+				int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
+				AttributeClassObserver obs = this.attributeObservers.get(i);
+				if (obs == null) {
+					obs = inst.attribute(instAttIndex).isNominal() ? ht.newNominalClassObserver()
+							: ht.newNumericClassObserver();
+					this.attributeObservers.set(i, obs);
+				}
+				obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
+			}
+		}
+
+		public double getWeightSeen() {
+			return this.observedClassDistribution.sumOfValues();
+		}
+
+		public double getWeightSeenAtLastSplitEvaluation() {
+			return this.weightSeenAtLastSplitEvaluation;
+		}
+
+		public void setWeightSeenAtLastSplitEvaluation(double weight) {
+			this.weightSeenAtLastSplitEvaluation = weight;
+		}
+
+		public AttributeSplitSuggestion[] getBestSplitSuggestions(SplitCriterion criterion, HoeffdingTree ht) {
+			List<AttributeSplitSuggestion> bestSuggestions = new LinkedList<>();
+			double[] preSplitDist = this.observedClassDistribution.getArrayCopy();
+			if (!ht.noPrePruneOption.isSet()) {
+				// add null split as an option
+				bestSuggestions.add(new AttributeSplitSuggestion(null, new double[0][],
+						criterion.getMeritOfSplit(preSplitDist, new double[][] { preSplitDist })));
+			}
+			for (int i = 0; i < this.attributeObservers.size(); i++) {
+				AttributeClassObserver obs = this.attributeObservers.get(i);
+				if (obs != null) {
+					AttributeSplitSuggestion bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion,
+							preSplitDist, i, ht.binarySplitsOption.isSet());
+					if (bestSuggestion != null) {
+						bestSuggestions.add(bestSuggestion);
+					}
+				}
+			}
+			return bestSuggestions.toArray(new AttributeSplitSuggestion[bestSuggestions.size()]);
+		}
+
+		public void disableAttribute(int attIndex) {
+			this.attributeObservers.set(attIndex, new NullAttributeClassObserver());
+		}
+	}
+
+	protected Node treeRoot;
+
+	protected int decisionNodeCount;
+
+	protected int activeLeafNodeCount;
+
+	protected int inactiveLeafNodeCount;
+
+	protected double inactiveLeafByteSizeEstimate;
+
+	protected double activeLeafByteSizeEstimate;
+
+	protected double byteSizeEstimateOverheadFraction;
+
+	protected boolean growthAllowed;
+
+	public long calcByteSize() {
+		long size = SizeOf.sizeOf(this);
+		if (this.treeRoot != null) {
+			size += this.treeRoot.calcByteSizeIncludingSubtree();
+		}
+		return size;
+	}
+
+	@Override
+	public long measureByteSize() {
+		return calcByteSize();
+	}
+
+	@Override
+	public void resetLearningImpl() {
+		this.treeRoot = null;
+		this.decisionNodeCount = 0;
+		this.activeLeafNodeCount = 0;
+		this.inactiveLeafNodeCount = 0;
+		this.inactiveLeafByteSizeEstimate = 0.0;
+		this.activeLeafByteSizeEstimate = 0.0;
+		this.byteSizeEstimateOverheadFraction = 1.0;
+		this.growthAllowed = true;
+		if (this.leafpredictionOption.getChosenIndex() > 0) {
+			this.removePoorAttsOption = null;
+		}
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		if (this.treeRoot == null) {
+			this.treeRoot = newLearningNode();
+			this.activeLeafNodeCount = 1;
+		}
+		FoundNode foundNode = this.treeRoot.filterInstanceToLeaf(inst, null, -1);
+		Node leafNode = foundNode.node;
+		if (leafNode == null) {
+			leafNode = newLearningNode();
+			foundNode.parent.setChild(foundNode.parentBranch, leafNode);
+			this.activeLeafNodeCount++;
+		}
+		if (leafNode instanceof LearningNode) {
+			LearningNode learningNode = (LearningNode) leafNode;
+			learningNode.learnFromInstance(inst, this);
+			if (this.growthAllowed && (learningNode instanceof ActiveLearningNode)) {
+				ActiveLearningNode activeLearningNode = (ActiveLearningNode) learningNode;
+				double weightSeen = activeLearningNode.getWeightSeen();
+				if (weightSeen - activeLearningNode.getWeightSeenAtLastSplitEvaluation() >= this.gracePeriodOption
+						.getValue()) {
+					attemptToSplit(activeLearningNode, foundNode.parent, foundNode.parentBranch);
+					activeLearningNode.setWeightSeenAtLastSplitEvaluation(weightSeen);
+				}
+			}
+		}
+		if (this.trainingWeightSeenByModel % this.memoryEstimatePeriodOption.getValue() == 0) {
+			estimateModelByteSizes();
+		}
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		if (this.treeRoot != null) {
+			FoundNode foundNode = this.treeRoot.filterInstanceToLeaf(inst, null, -1);
+			Node leafNode = foundNode.node;
+			if (leafNode == null) {
+				leafNode = foundNode.parent;
+			}
+			return new ClassificationPrediction(leafNode.getClassVotes(inst, this));
+		} else {
+			return new ClassificationPrediction();
+		}
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[] {
+				new Measurement("tree size (nodes)",
+						this.decisionNodeCount + this.activeLeafNodeCount + this.inactiveLeafNodeCount),
+				new Measurement("tree size (leaves)", this.activeLeafNodeCount + this.inactiveLeafNodeCount),
+				new Measurement("active learning leaves", this.activeLeafNodeCount),
+				new Measurement("tree depth", measureTreeDepth()),
+				new Measurement("active leaf byte size estimate", this.activeLeafByteSizeEstimate),
+				new Measurement("inactive leaf byte size estimate", this.inactiveLeafByteSizeEstimate),
+				new Measurement("byte size estimate overhead", this.byteSizeEstimateOverheadFraction) };
+	}
+
+	public int measureTreeDepth() {
+		if (this.treeRoot != null) {
+			return this.treeRoot.subtreeDepth();
+		}
+		return 0;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		this.treeRoot.describeSubtree(this, out, indent);
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+
+	public static double computeHoeffdingBound(double range, double confidence, double n) {
+		return Math.sqrt(((range * range) * Math.log(1.0 / confidence)) / (2.0 * n));
+	}
+
+	// Procedure added for Hoeffding Adaptive Trees (ADWIN)
+	protected SplitNode newSplitNode(InstanceConditionalTest splitTest, double[] classObservations, int size) {
+		return new SplitNode(splitTest, classObservations, size);
+	}
+
+	protected SplitNode newSplitNode(InstanceConditionalTest splitTest, double[] classObservations) {
+		return new SplitNode(splitTest, classObservations);
+	}
+
+	protected AttributeClassObserver newNominalClassObserver() {
+		AttributeClassObserver nominalClassObserver = (AttributeClassObserver) getPreparedClassOption(
+				this.nominalEstimatorOption);
+		return (AttributeClassObserver) nominalClassObserver.copy();
+	}
+
+	protected AttributeClassObserver newNumericClassObserver() {
+		AttributeClassObserver numericClassObserver = (AttributeClassObserver) getPreparedClassOption(
+				this.numericEstimatorOption);
+		return (AttributeClassObserver) numericClassObserver.copy();
+	}
+
+	protected void attemptToSplit(ActiveLearningNode node, SplitNode parent, int parentIndex) {
+		if (!node.observedClassDistributionIsPure()) {
+			SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
+			AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion, this);
+			Arrays.sort(bestSplitSuggestions);
+			boolean shouldSplit = false;
+			if (bestSplitSuggestions.length < 2) {
+				shouldSplit = bestSplitSuggestions.length > 0;
+			} else {
+				double hoeffdingBound = computeHoeffdingBound(
+						splitCriterion.getRangeOfMerit(node.getObservedClassDistribution()),
+						this.splitConfidenceOption.getValue(), node.getWeightSeen());
+				AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+				AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
+				if ((bestSuggestion.merit - secondBestSuggestion.merit > hoeffdingBound)
+						|| (hoeffdingBound < this.tieThresholdOption.getValue())) {
+					shouldSplit = true;
+				}
+				// }
+				if ((this.removePoorAttsOption != null) && this.removePoorAttsOption.isSet()) {
+					Set<Integer> poorAtts = new HashSet<>();
+					// scan 1 - add any poor to set
+					for (int i = 0; i < bestSplitSuggestions.length; i++) {
+						if (bestSplitSuggestions[i].splitTest != null) {
+							int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
+							if (splitAtts.length == 1) {
+								if (bestSuggestion.merit - bestSplitSuggestions[i].merit > hoeffdingBound) {
+									poorAtts.add(new Integer(splitAtts[0]));
+								}
+							}
+						}
+					}
+					// scan 2 - remove good ones from set
+					for (int i = 0; i < bestSplitSuggestions.length; i++) {
+						if (bestSplitSuggestions[i].splitTest != null) {
+							int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
+							if (splitAtts.length == 1) {
+								if (bestSuggestion.merit - bestSplitSuggestions[i].merit < hoeffdingBound) {
+									poorAtts.remove(new Integer(splitAtts[0]));
+								}
+							}
+						}
+					}
+					for (int poorAtt : poorAtts) {
+						node.disableAttribute(poorAtt);
+					}
+				}
+			}
+			if (shouldSplit) {
+				AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+				if (splitDecision.splitTest == null) {
+					// preprune - null wins
+					deactivateLearningNode(node, parent, parentIndex);
+				} else {
+					SplitNode newSplit = newSplitNode(splitDecision.splitTest, node.getObservedClassDistribution(),
+							splitDecision.numSplits());
+					for (int i = 0; i < splitDecision.numSplits(); i++) {
+						Node newChild = newLearningNode(splitDecision.resultingClassDistributionFromSplit(i));
+						newSplit.setChild(i, newChild);
+					}
+					this.activeLeafNodeCount--;
+					this.decisionNodeCount++;
+					this.activeLeafNodeCount += splitDecision.numSplits();
+					if (parent == null) {
+						this.treeRoot = newSplit;
+					} else {
+						parent.setChild(parentIndex, newSplit);
+					}
+				}
+				// manage memory
+				enforceTrackerLimit();
+			}
+		}
+	}
+
+	public void enforceTrackerLimit() {
+		if ((this.inactiveLeafNodeCount > 0) || ((this.activeLeafNodeCount * this.activeLeafByteSizeEstimate
+				+ this.inactiveLeafNodeCount * this.inactiveLeafByteSizeEstimate)
+				* this.byteSizeEstimateOverheadFraction > this.maxByteSizeOption.getValue())) {
+			if (this.stopMemManagementOption.isSet()) {
+				this.growthAllowed = false;
+				return;
+			}
+			FoundNode[] learningNodes = findLearningNodes();
+			Arrays.sort(learningNodes, new Comparator<FoundNode>() {
+
+				@Override
+				public int compare(FoundNode fn1, FoundNode fn2) {
+					return Double.compare(fn1.node.calculatePromise(), fn2.node.calculatePromise());
+				}
+			});
+			int maxActive = 0;
+			while (maxActive < learningNodes.length) {
+				maxActive++;
+				if ((maxActive * this.activeLeafByteSizeEstimate
+						+ (learningNodes.length - maxActive) * this.inactiveLeafByteSizeEstimate)
+						* this.byteSizeEstimateOverheadFraction > this.maxByteSizeOption.getValue()) {
+					maxActive--;
+					break;
+				}
+			}
+			int cutoff = learningNodes.length - maxActive;
+			for (int i = 0; i < cutoff; i++) {
+				if (learningNodes[i].node instanceof ActiveLearningNode) {
+					deactivateLearningNode((ActiveLearningNode) learningNodes[i].node, learningNodes[i].parent,
+							learningNodes[i].parentBranch);
+				}
+			}
+			for (int i = cutoff; i < learningNodes.length; i++) {
+				if (learningNodes[i].node instanceof InactiveLearningNode) {
+					activateLearningNode((InactiveLearningNode) learningNodes[i].node, learningNodes[i].parent,
+							learningNodes[i].parentBranch);
+				}
+			}
+		}
+	}
+
+	public void estimateModelByteSizes() {
+		FoundNode[] learningNodes = findLearningNodes();
+		long totalActiveSize = 0;
+		long totalInactiveSize = 0;
+		for (FoundNode foundNode : learningNodes) {
+			if (foundNode.node instanceof ActiveLearningNode) {
+				totalActiveSize += SizeOf.fullSizeOf(foundNode.node);
+			} else {
+				totalInactiveSize += SizeOf.fullSizeOf(foundNode.node);
+			}
+		}
+		if (totalActiveSize > 0) {
+			this.activeLeafByteSizeEstimate = (double) totalActiveSize / this.activeLeafNodeCount;
+		}
+		if (totalInactiveSize > 0) {
+			this.inactiveLeafByteSizeEstimate = (double) totalInactiveSize / this.inactiveLeafNodeCount;
+		}
+		long actualModelSize = this.measureByteSize();
+		double estimatedModelSize = (this.activeLeafNodeCount * this.activeLeafByteSizeEstimate
+				+ this.inactiveLeafNodeCount * this.inactiveLeafByteSizeEstimate);
+		this.byteSizeEstimateOverheadFraction = actualModelSize / estimatedModelSize;
+		if (actualModelSize > this.maxByteSizeOption.getValue()) {
+			enforceTrackerLimit();
+		}
+	}
+
+	public void deactivateAllLeaves() {
+		FoundNode[] learningNodes = findLearningNodes();
+		for (int i = 0; i < learningNodes.length; i++) {
+			if (learningNodes[i].node instanceof ActiveLearningNode) {
+				deactivateLearningNode((ActiveLearningNode) learningNodes[i].node, learningNodes[i].parent,
+						learningNodes[i].parentBranch);
+			}
+		}
+	}
+
+	protected void deactivateLearningNode(ActiveLearningNode toDeactivate, SplitNode parent, int parentBranch) {
+		Node newLeaf = new InactiveLearningNode(toDeactivate.getObservedClassDistribution());
+		if (parent == null) {
+			this.treeRoot = newLeaf;
+		} else {
+			parent.setChild(parentBranch, newLeaf);
+		}
+		this.activeLeafNodeCount--;
+		this.inactiveLeafNodeCount++;
+	}
+
+	protected void activateLearningNode(InactiveLearningNode toActivate, SplitNode parent, int parentBranch) {
+		Node newLeaf = newLearningNode(toActivate.getObservedClassDistribution());
+		if (parent == null) {
+			this.treeRoot = newLeaf;
+		} else {
+			parent.setChild(parentBranch, newLeaf);
+		}
+		this.activeLeafNodeCount++;
+		this.inactiveLeafNodeCount--;
+	}
+
+	protected FoundNode[] findLearningNodes() {
+		List<FoundNode> foundList = new LinkedList<>();
+		findLearningNodes(this.treeRoot, null, -1, foundList);
+		return foundList.toArray(new FoundNode[foundList.size()]);
+	}
+
+	protected void findLearningNodes(Node node, SplitNode parent, int parentBranch, List<FoundNode> found) {
+		if (node != null) {
+			if (node instanceof LearningNode) {
+				found.add(new FoundNode(node, parent, parentBranch));
+			}
+			if (node instanceof SplitNode) {
+				SplitNode splitNode = (SplitNode) node;
+				for (int i = 0; i < splitNode.numChildren(); i++) {
+					findLearningNodes(splitNode.getChild(i), splitNode, i, found);
+				}
+			}
+		}
+	}
+
+	public MultiChoiceOption leafpredictionOption = new MultiChoiceOption("leafprediction", 'l',
+			"Leaf prediction to use.", new String[] { "MC", "NB", "NBAdaptive" },
+			new String[] { "Majority class", "Naive Bayes", "Naive Bayes Adaptive" }, 2);
+
+	public IntOption nbThresholdOption = new IntOption("nbThreshold", 'q',
+			"The number of instances a leaf should observe before permitting Naive Bayes.", 0, 0, Integer.MAX_VALUE);
+
+	public static class LearningNodeNB extends ActiveLearningNode {
+
+		private static final long serialVersionUID = 1L;
+
+		public LearningNodeNB(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		@Override
+		public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
+			if (getWeightSeen() >= ht.nbThresholdOption.getValue()) {
+				return NaiveBayes.doNaiveBayesPrediction(inst, this.observedClassDistribution, this.attributeObservers);
+			}
+			return super.getClassVotes(inst, ht);
+		}
+
+		@Override
+		public void disableAttribute(int attIndex) {
+			// should not disable poor atts - they are used in NB calc
+		}
+	}
+
+	public static class LearningNodeNBAdaptive extends LearningNodeNB {
+
+		private static final long serialVersionUID = 1L;
+
+		protected double mcCorrectWeight = 0.0;
+
+		protected double nbCorrectWeight = 0.0;
+
+		public LearningNodeNBAdaptive(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, HoeffdingTree ht) {
+			int trueClass = (int) inst.classValue();
+			if (this.observedClassDistribution.maxIndex() == trueClass) {
+				this.mcCorrectWeight += inst.weight();
+			}
+			if (Utils.maxIndex(NaiveBayes.doNaiveBayesPrediction(inst, this.observedClassDistribution,
+					this.attributeObservers)) == trueClass) {
+				this.nbCorrectWeight += inst.weight();
+			}
+			super.learnFromInstance(inst, ht);
+		}
+
+		@Override
+		public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
+			if (this.mcCorrectWeight > this.nbCorrectWeight) {
+				return this.observedClassDistribution.getArrayCopy();
+			}
+			return NaiveBayes.doNaiveBayesPrediction(inst, this.observedClassDistribution, this.attributeObservers);
+		}
+	}
+
+	protected LearningNode newLearningNode() {
+		return newLearningNode(new double[0]);
+	}
+
+	protected LearningNode newLearningNode(double[] initialClassObservations) {
+		LearningNode ret;
+		int predictionOption = this.leafpredictionOption.getChosenIndex();
+		if (predictionOption == 0) { // MC
+			ret = new ActiveLearningNode(initialClassObservations);
+		} else if (predictionOption == 1) { // NB
+			ret = new LearningNodeNB(initialClassObservations);
+		} else { // NBAdaptive
+			ret = new LearningNodeNBAdaptive(initialClassObservations);
+		}
+		return ret;
+	}
+
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == HoeffdingTree.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/trees/HoeffdingTreeClassifLeaves.java b/moa/src/main/java/moa/learners/predictors/trees/HoeffdingTreeClassifLeaves.java
new file mode 100644
index 000000000..5bce9a388
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/trees/HoeffdingTreeClassifLeaves.java
@@ -0,0 +1,189 @@
+/*
+ *    HoeffdingTreeClassifLeaves.java
+ *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
+ *    @author Jesse Read (jesse@tsc.uc3m.es)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.trees;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.core.AttributeSplitSuggestion;
+import moa.learners.predictors.core.splitcriteria.SplitCriterion;
+import moa.options.ClassOption;
+
+/**
+ * Hoeffding Tree that have a classifier at the leaves.
+ *
+ * A Hoeffding tree is an incremental, anytime decision tree induction algorithm
+ * that is capable of learning from massive data streams, assuming that the
+ * distribution generating examples does not change over time.
+ *
+ *
+ */
+public class HoeffdingTreeClassifLeaves extends HoeffdingTree {
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption learnerOption = new ClassOption("learner", 'a', "Classifier to train.", Classifier.class,
+			"bayes.NaiveBayes");
+
+	public class LearningNodeClassifier extends ActiveLearningNode {
+
+		protected Classifier classifier;
+
+		private static final long serialVersionUID = 1L;
+
+		public LearningNodeClassifier(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		public LearningNodeClassifier(double[] initialClassObservations, Classifier cl, HoeffdingTreeClassifLeaves ht) {
+			super(initialClassObservations);
+			// public void LearningNodeClassifier1(double[] initialClassObservations,
+			// Classifier cl, HoeffdingTreeClassifLeaves ht ) {
+
+			if (cl == null) {
+				this.classifier = (Classifier) getPreparedClassOption(ht.learnerOption);
+			} else {
+				this.classifier = (Classifier) cl.copy();
+			}
+		}
+
+		@Override
+		public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
+			if (getWeightSeen() >= ((HoeffdingTreeClassifLeaves) ht).nbThresholdOption.getValue()) {
+				return this.classifier.getPredictionForInstance(inst).asDoubleArray();
+			}
+			return super.getClassVotes(inst, ht);
+		}
+
+		@Override
+		public void disableAttribute(int attIndex) {
+			// should not disable poor atts - they are used in NB calc
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, HoeffdingTree ht) {
+			this.classifier.trainOnInstance(inst);
+			super.learnFromInstance(inst, ht);
+		}
+
+		public Classifier getClassifier() {
+			return this.classifier;
+		}
+	}
+
+	public HoeffdingTreeClassifLeaves() {
+		this.removePoorAttsOption = null;
+	}
+
+	@Override
+	protected LearningNode newLearningNode(double[] initialClassObservations) {
+		return new LearningNodeClassifier(initialClassObservations, null, this);
+	}
+
+	// @Override
+	protected LearningNode newLearningNode(double[] initialClassObservations, Classifier cl) {
+		return new LearningNodeClassifier(initialClassObservations, cl, this);
+	}
+
+	@Override
+	protected void attemptToSplit(ActiveLearningNode node, SplitNode parent, int parentIndex) {
+		// ßSystem.out.println("Attempt to Split");
+		if (!node.observedClassDistributionIsPure()) {
+			SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
+			AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion, this);
+			Arrays.sort(bestSplitSuggestions);
+			boolean shouldSplit = false;
+			if (bestSplitSuggestions.length < 2) {
+				shouldSplit = bestSplitSuggestions.length > 0;
+			} else {
+				double hoeffdingBound = computeHoeffdingBound(
+						splitCriterion.getRangeOfMerit(node.getObservedClassDistribution()),
+						this.splitConfidenceOption.getValue(), node.getWeightSeen());
+				AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+				AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
+				// System.out.println(bestSuggestion.merit+" - "+secondBestSuggestion.merit+":"+
+				// (bestSuggestion.merit - secondBestSuggestion.merit)+" > "+hoeffdingBound+
+				// "<"+this.tieThresholdOption.getValue());
+				if ((bestSuggestion.merit - secondBestSuggestion.merit > hoeffdingBound)
+						|| (hoeffdingBound < this.tieThresholdOption.getValue())) {
+					shouldSplit = true;
+				}
+				// }
+				if ((this.removePoorAttsOption != null) && this.removePoorAttsOption.isSet()) {
+					Set<Integer> poorAtts = new HashSet<>();
+					// scan 1 - add any poor to set
+					for (int i = 0; i < bestSplitSuggestions.length; i++) {
+						if (bestSplitSuggestions[i].splitTest != null) {
+							int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
+							if (splitAtts.length == 1) {
+								if (bestSuggestion.merit - bestSplitSuggestions[i].merit > hoeffdingBound) {
+									poorAtts.add(new Integer(splitAtts[0]));
+								}
+							}
+						}
+					}
+					// scan 2 - remove good ones from set
+					for (int i = 0; i < bestSplitSuggestions.length; i++) {
+						if (bestSplitSuggestions[i].splitTest != null) {
+							int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
+							if (splitAtts.length == 1) {
+								if (bestSuggestion.merit - bestSplitSuggestions[i].merit < hoeffdingBound) {
+									poorAtts.remove(new Integer(splitAtts[0]));
+								}
+							}
+						}
+					}
+					for (int poorAtt : poorAtts) {
+						node.disableAttribute(poorAtt);
+					}
+				}
+			}
+			if (shouldSplit) {
+				AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+				if (splitDecision.splitTest == null) {
+					// preprune - null wins
+					deactivateLearningNode(node, parent, parentIndex);
+				} else {
+					SplitNode newSplit = newSplitNode(splitDecision.splitTest, node.getObservedClassDistribution());
+					for (int i = 0; i < splitDecision.numSplits(); i++) {
+						// Unique Change of HoeffdingTree
+						Node newChild = newLearningNode(splitDecision.resultingClassDistributionFromSplit(i),
+								((LearningNodeClassifier) node).getClassifier());
+						newSplit.setChild(i, newChild);
+					}
+					this.activeLeafNodeCount--;
+					this.decisionNodeCount++;
+					this.activeLeafNodeCount += splitDecision.numSplits();
+					if (parent == null) {
+						this.treeRoot = newSplit;
+					} else {
+						parent.setChild(parentIndex, newSplit);
+					}
+				}
+				// manage memory
+				enforceTrackerLimit();
+			}
+		}
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/mtr/trees/ISOUPOptionTree.java b/moa/src/main/java/moa/learners/predictors/trees/ISOUPOptionTree.java
similarity index 75%
rename from moa/src/main/java/moa/classifiers/mtr/trees/ISOUPOptionTree.java
rename to moa/src/main/java/moa/learners/predictors/trees/ISOUPOptionTree.java
index f0e35d3f2..55f790663 100644
--- a/moa/src/main/java/moa/classifiers/mtr/trees/ISOUPOptionTree.java
+++ b/moa/src/main/java/moa/learners/predictors/trees/ISOUPOptionTree.java
@@ -1,4 +1,4 @@
-package moa.classifiers.mtr.trees;
+package moa.learners.predictors.trees;
 
 import java.util.Arrays;
 import java.util.LinkedList;
@@ -10,14 +10,14 @@
 import com.github.javacliparser.MultiChoiceOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
-import moa.classifiers.mlc.core.splitcriteria.MultiLabelSplitCriterion;
-import moa.classifiers.mlc.core.splitcriteria.WeightedICVarianceReduction;
-import moa.classifiers.rules.core.AttributeExpansionSuggestion;
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.SizeOf;
 import moa.core.StringUtils;
+import moa.learners.predictors.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.learners.predictors.core.splitcriteria.WeightedICVarianceReduction;
+import moa.learners.predictors.rules.core.AttributeExpansionSuggestion;
 
 public class ISOUPOptionTree extends ISOUPTree {
 
@@ -27,45 +27,32 @@ public class ISOUPOptionTree extends ISOUPTree {
 
 	private int numTrees = 1;
 
-	//region ================ OPTIONS ================
+	// region ================ OPTIONS ================
 
-	public IntOption maxTreesOption = new IntOption(
-			"maxTrees",
-			'm',
-			"The maximum number of trees contained in the option tree.",
-			125, 1, Integer.MAX_VALUE);
+	public IntOption maxTreesOption = new IntOption("maxTrees", 'm',
+			"The maximum number of trees contained in the option tree.", 125, 1, Integer.MAX_VALUE);
 
-	public IntOption maxOptionLevelOption = new IntOption(
-			"maxOptionLevel",
-			'x',
-			"The maximal depth at which option nodes can be created.",
-			3, 0, Integer.MAX_VALUE);
+	public IntOption maxOptionLevelOption = new IntOption("maxOptionLevel", 'x',
+			"The maximal depth at which option nodes can be created.", 3, 0, Integer.MAX_VALUE);
 
-	public FloatOption optionDecayFactorOption = new FloatOption(
-			"optionDecayFactor",
-			'z',
-			"The option decay factor that determines how many options can be selected at a given level.",
-			0.9, 0.0, 1.0);
+	public FloatOption optionDecayFactorOption = new FloatOption("optionDecayFactor", 'z',
+			"The option decay factor that determines how many options can be selected at a given level.", 0.9, 0.0,
+			1.0);
 
-	public MultiChoiceOption optionNodeAggregationOption = new MultiChoiceOption(
-			"optionNodeAggregation",
-			'p',
-			"The aggregation method used to combine predictions in option nodes.", 
-			new String[]{"average", "bestTree"}, new String[]{"Average", "Best tree"}, 0);
+	public MultiChoiceOption optionNodeAggregationOption = new MultiChoiceOption("optionNodeAggregation", 'p',
+			"The aggregation method used to combine predictions in option nodes.",
+			new String[] { "average", "bestTree" }, new String[] { "Average", "Best tree" }, 0);
 
-	public FloatOption optionFadingFactorOption = new FloatOption(
-			"optionFadingFactor",
-			'q',
-			"The fading factor used for comparing subtrees of an option node.",
-			0.9995, 0.0, 1.0);
+	public FloatOption optionFadingFactorOption = new FloatOption("optionFadingFactor", 'q',
+			"The fading factor used for comparing subtrees of an option node.", 0.9995, 0.0, 1.0);
 
-	//endregion ================ OPTIONS ================
+	// endregion ================ OPTIONS ================
 
-	//region ================ CLASSES ================
+	// region ================ CLASSES ================
 
 	public static class OptionNode extends InnerNode {
 		/**
-		 * 
+		 *
 		 */
 		private static final long serialVersionUID = 1L;
 
@@ -75,16 +62,17 @@ public static class OptionNode extends InnerNode {
 		public OptionNode(ISOUPTree tree) {
 			super(tree);
 		}
-		
+
+		@Override
 		public long calcByteSize() {
 			long size = super.calcByteSize();
-			size += SizeOf.fullSizeOf(optionFFSSL) + SizeOf.fullSizeOf(optionFFSeen); 
+			size += SizeOf.fullSizeOf(optionFFSSL) + SizeOf.fullSizeOf(optionFFSeen);
 			return size;
 		}
 
 		public void resetFF() {
-			optionFFSSL = new AutoExpandVector<DoubleVector>();
-			optionFFSeen = new AutoExpandVector<DoubleVector>();
+			optionFFSSL = new AutoExpandVector<>();
+			optionFFSeen = new AutoExpandVector<>();
 			for (int i = 0; i < numChildren(); i++) {
 				optionFFSSL.set(i, new DoubleVector());
 				optionFFSeen.set(i, new DoubleVector());
@@ -95,6 +83,7 @@ public void resetFF() {
 			}
 		}
 
+		@Override
 		public int getNumSubtrees() {
 			int num = 0;
 			for (Node child : children) {
@@ -103,6 +92,7 @@ public int getNumSubtrees() {
 			return num;
 		}
 
+		@Override
 		public double[] getPrediction(Instance inst) {
 			double[][] predictions = new double[numChildren()][tree.getModelContext().numOutputAttributes()];
 			for (int i = 0; i < numChildren(); i++) {
@@ -147,13 +137,16 @@ public int directionForBestTree() {
 		}
 
 		public double getFFRatio(int childIndex, int targetIndex) {
-			return optionFFSSL.get(childIndex).getValue(targetIndex) / optionFFSeen.get(childIndex).getValue(targetIndex); 
+			return optionFFSSL.get(childIndex).getValue(targetIndex)
+					/ optionFFSeen.get(childIndex).getValue(targetIndex);
 		}
 
+		@Override
 		protected boolean skipInLevelCount() {
 			return true;
 		}
 
+		@Override
 		public void describeSubtree(StringBuilder out, int indent) {
 			for (int branch = 0; branch < children.size(); branch++) {
 				Node child = getChild(branch);
@@ -163,30 +156,32 @@ public void describeSubtree(StringBuilder out, int indent) {
 					StringUtils.appendNewline(out);
 					child.describeSubtree(out, indent + 2);
 				}
-			}			
+			}
 		}
 	}
 
-	//endregion ================ CLASSES ================
+	// endregion ================ CLASSES ================
 
-	//region ================ METHODS ================
+	// region ================ METHODS ================
 
+	@Override
 	public String getPurposeString() {
 		return "Implementation of the iSOUPOptionTree";
 	}
 
+	@Override
 	public void resetLearningImpl() {
 		super.resetLearningImpl();
 		this.optionNodeCount = 0;
 	}
 
-
+	@Override
 	protected Measurement[] getModelMeasurementsImpl() {
-		return new Measurement[]{ 
-				new Measurement("number of subtrees", this.numTrees),
-				//new Measurement("tree size (nodes)", this.leafNodeCount + this.innerNodeCount),
-				//new Measurement("tree size (leaves)", this.leafNodeCount),
-				new Measurement("number of option nodes", this.optionNodeCount),};
+		return new Measurement[] { new Measurement("number of subtrees", this.numTrees),
+				// new Measurement("tree size (nodes)", this.leafNodeCount +
+				// this.innerNodeCount),
+				// new Measurement("tree size (leaves)", this.leafNodeCount),
+				new Measurement("number of option nodes", this.optionNodeCount), };
 	}
 
 	// region --- Object instantiation methods
@@ -199,7 +194,8 @@ protected OptionNode newOptionNode() {
 	// endregion --- Object instantiation methods
 
 	@Override
-	public void processInstance(Instance inst, Node node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
+	public void processInstance(Instance inst, Node node, double[] prediction, double[] normalError,
+			boolean growthAllowed, boolean inAlternate) {
 		if (node instanceof OptionNode) {
 			processInstanceOptionNode(inst, (OptionNode) node, prediction, normalError, growthAllowed, inAlternate);
 		} else {
@@ -209,28 +205,28 @@ public void processInstance(Instance inst, Node node, double[] prediction, doubl
 					((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
 					break;
 				} else {
-					//currentNode.examplesSeen += inst.weight();
+					// currentNode.examplesSeen += inst.weight();
 //					if (!inAlternate && iNode.alternateTree != null) {
 //						boolean altTree = true;
 //						double lossO = Math.pow(inst.classValue() - prediction, 2);
 //						double lossA = Math.pow(inst.classValue() - currentNode.alternateTree.getPrediction(inst), 2);
-//						
+//
 //						iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
 //						iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
 //						iNode.lossExamplesSeen++;
-//						
+//
 //						double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
 //						double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
 //						iNode.lossSumQi += Qi;
 //						iNode.lossNumQiTests += 1;
 //						double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
-//						
+//
 //						if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
 //							iNode.previousWeight = iNode.lossExamplesSeen;
 //							if (Qi > 0) {
 //								// Switch the subtrees
 //								Node parent = currentNode.parent;
-//								
+//
 //								if (parent != null) {
 //									Node replacementTree = iNode.alternateTree;
 //									parent.setChild(parent.getChildIndex(iNode), replacementTree);
@@ -241,7 +237,7 @@ public void processInstance(Instance inst, Node node, double[] prediction, doubl
 //								}
 //								optionNodeCount += currentNode.alternateTree.getNumSubtrees() - currentNode.getNumSubtrees();
 //								removeExcessTrees();
-//										
+//
 //								currentNode = iNode.alternateTree;
 //								currentNode.originalNode = null;
 //								altTree = false;
@@ -270,9 +266,11 @@ public void processInstance(Instance inst, Node node, double[] prediction, doubl
 //						}
 //					}
 					if (currentNode instanceof SplitNode) {
-						currentNode = ((SplitNode) currentNode).getChild(((SplitNode) currentNode).instanceChildIndex(inst));
+						currentNode = ((SplitNode) currentNode)
+								.getChild(((SplitNode) currentNode).instanceChildIndex(inst));
 					} else if (currentNode instanceof OptionNode) {
-						processInstanceOptionNode(inst, (OptionNode) currentNode, prediction, normalError, growthAllowed, inAlternate);
+						processInstanceOptionNode(inst, (OptionNode) currentNode, prediction, normalError,
+								growthAllowed, inAlternate);
 						break;
 					}
 				}
@@ -281,38 +279,53 @@ public void processInstance(Instance inst, Node node, double[] prediction, doubl
 
 	}
 
-	public void processInstanceOptionNode(Instance inst, OptionNode node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
-		//		if (node.changeDetection) {
-		//			double error = Math.abs(prediction - inst.classValue());
-		//			node.sumOfAbsErrors += error;
-		//			
-		//			if (((InnerNode) node).PageHinckleyTest(error - node.sumOfAbsErrors / node.examplesSeen + PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
-		//				node.initializeAlternateTree();
-		//			}
-		//		}
+	public void processInstanceOptionNode(Instance inst, OptionNode node, double[] prediction, double[] normalError,
+			boolean growthAllowed, boolean inAlternate) {
+		// if (node.changeDetection) {
+		// double error = Math.abs(prediction - inst.classValue());
+		// node.sumOfAbsErrors += error;
+		//
+		// if (((InnerNode) node).PageHinckleyTest(error - node.sumOfAbsErrors /
+		// node.examplesSeen + PageHinckleyAlphaOption.getValue(),
+		// PageHinckleyThresholdOption.getValue())) {
+		// node.initializeAlternateTree();
+		// }
+		// }
 
 		double[][] childPredictions = new double[node.numChildren()][];
 		for (Node child : node.children) {
 			int i = node.getChildIndex(child);
 			childPredictions[i] = child.getPrediction(inst);
-			for (int j = 0; j < getModelContext().numOutputAttributes(); j++)  {
-				node.optionFFSeen.get(i).setValue(j, node.optionFFSeen.get(i).getValue(j) * optionFadingFactorOption.getValue() + 1);
-				node.optionFFSSL.get(i).setValue(j, node.optionFFSSL.get(i).getValue(j) * optionFadingFactorOption.getValue() + (childPredictions[i][j] - inst.valueOutputAttribute(j)) * (childPredictions[i][j] - inst.valueOutputAttribute(j)));
+			for (int j = 0; j < getModelContext().numOutputAttributes(); j++) {
+				node.optionFFSeen.get(i).setValue(j,
+						node.optionFFSeen.get(i).getValue(j) * optionFadingFactorOption.getValue() + 1);
+				node.optionFFSSL.get(i).setValue(j,
+						node.optionFFSSL.get(i).getValue(j) * optionFadingFactorOption.getValue()
+								+ (childPredictions[i][j] - inst.valueOutputAttribute(j))
+										* (childPredictions[i][j] - inst.valueOutputAttribute(j)));
 			}
-			processInstance(inst, child, childPredictions[node.getChildIndex(child)], normalError, growthAllowed && node.alternateTree == null, inAlternate);
+			processInstance(inst, child, childPredictions[node.getChildIndex(child)], normalError,
+					growthAllowed && node.alternateTree == null, inAlternate);
 		}
 	}
 
-	//endregion ================ METHODS ================
+	// endregion ================ METHODS ================
 
+	@Override
 	protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex) {
-		//System.out.println(examplesSeen);
-		// Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
+		// System.out.println(examplesSeen);
+		// Set the split criterion to use to the SDR split criterion as described by
+		// Ikonomovska et al.
 		MultiLabelSplitCriterion splitCriterion = new WeightedICVarianceReduction(targetWeights);
 
 		// Using this criterion, find the best split per attribute and rank the results
-		AttributeExpansionSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion); // TODO update with split criterion option
-		List<AttributeExpansionSuggestion> acceptedSplits = new LinkedList<AttributeExpansionSuggestion>();
+		AttributeExpansionSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion); // TODO
+																											// update
+																											// with
+																											// split
+																											// criterion
+																											// option
+		List<AttributeExpansionSuggestion> acceptedSplits = new LinkedList<>();
 
 		// Declare a variable to determine the number of splits to be performed
 		int numSplits = 0;
@@ -321,26 +334,36 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 		if (bestSplitSuggestions.length == 1) {
 			numSplits = 1;
 			acceptedSplits.add(bestSplitSuggestions[0]);
-		} else if (bestSplitSuggestions.length > 1) { // Otherwise, consider which of the splits proposed may be worth trying
+		} else if (bestSplitSuggestions.length > 1) { // Otherwise, consider which of the splits proposed may be worth
+														// trying
 			Arrays.sort(bestSplitSuggestions);
-			// Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
-			// to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
-			double numExamples = node.examplesSeen.getValue(node.examplesSeen.maxIndex()); // Use the max index (TODO for partially labeled)
+			// Determine the Hoeffding bound value, used to select how many instances should
+			// be used to make a test decision
+			// to feel reasonably confident that the test chosen by this sample is the same
+			// as what would be chosen using infinite examples
+			double numExamples = node.examplesSeen.getValue(node.examplesSeen.maxIndex()); // Use the max index (TODO
+																							// for partially labeled)
 			double hoeffdingBound = computeHoeffdingBound(1, splitConfidenceOption.getValue(), numExamples);
 			// Determine the top two ranked splitting suggestions
 			AttributeExpansionSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
 			AttributeExpansionSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
 
-			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
-			// as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
-			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
+			// If the upper bound of the sample mean for the ratio of SDR(best suggestion)
+			// to SDR(second best suggestion),
+			// as determined using the Hoeffding bound, is less than 1, then the true mean
+			// is also less than 1, and thus at this
+			// particular moment of observation the bestSuggestion is indeed the best split
+			// option with confidence 1-delta, and
 			// splitting should occur.
-			// Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
-			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
-			// competing attributes are equally good, and the split will be made on the one with the higher SDR value.
-			//System.out.print(hoeffdingBound);
-			//System.out.print(" ");
-			///System.out.println(secondBestSuggestion.merit / bestSuggestion.merit);
+			// Alternatively, if two or more splits are very similar or identical in terms
+			// of their splits, then a threshold limit
+			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is
+			// smaller than this limit then the two
+			// competing attributes are equally good, and the split will be made on the one
+			// with the higher SDR value.
+			// System.out.print(hoeffdingBound);
+			// System.out.print(" ");
+			/// System.out.println(secondBestSuggestion.merit / bestSuggestion.merit);
 			if (secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) {
 				numSplits = 1;
 				acceptedSplits.add(bestSuggestion);
@@ -374,12 +397,13 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 //			}
 		}
 
-		//System.out.println("Found " + numSplits + " candidates.");
-		
-		// If the splitting criterion were met, split the current node using the chosen attribute test, and
+		// System.out.println("Found " + numSplits + " candidates.");
+
+		// If the splitting criterion were met, split the current node using the chosen
+		// attribute test, and
 		// make two new branches leading to (empty) leaves
 		if (numSplits > 0) {
-			double optionFactor = numSplits * Math.pow(optionDecayFactorOption.getValue(), (double) node.getLevel());
+			double optionFactor = numSplits * Math.pow(optionDecayFactorOption.getValue(), node.getLevel());
 			log(Integer.toString(node.ID) + ',' + this.examplesSeen.toString());
 
 			if (numSplits == 1) {
@@ -392,9 +416,9 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 					newChild.setParent(newSplit);
 					newSplit.setChild(i, newChild);
 				}
-				//leafNodeCount--;
-				//innerNodeCount++;
-				//leafNodeCount += splitDecision.numSplits();
+				// leafNodeCount--;
+				// innerNodeCount++;
+				// leafNodeCount += splitDecision.numSplits();
 				if (parent == null && node.originalNode == null) {
 					treeRoot = newSplit;
 				} else if (parent == null && node.originalNode != null) {
@@ -408,7 +432,7 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 				OptionNode optionNode = newOptionNode();
 				optionNode.ID = node.ID;
 
-				//leafNodeCount--;
+				// leafNodeCount--;
 				int j = 0;
 
 				for (AttributeExpansionSuggestion splitDecision : acceptedSplits) {
@@ -422,8 +446,8 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 						newSplit.setChild(i, newChild);
 					}
 
-					//leafNodeCount += splitDecision.numSplits();
-					//innerNodeCount++;
+					// leafNodeCount += splitDecision.numSplits();
+					// innerNodeCount++;
 					numTrees++;
 
 					newSplit.setParent(optionNode);
@@ -431,7 +455,7 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 					j++;
 				}
 
-				//innerNodeCount++;
+				// innerNodeCount++;
 				optionNodeCount++;
 
 				if (parent == null) {
@@ -444,12 +468,12 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 				optionNode.resetFF();
 			}
 		}
-		//System.out.println("Splits finished...");
+		// System.out.println("Splits finished...");
 	}
 
 	// region --- Option tree methods
 	protected Node findWorstOption() {
-		Stack<Node> stack = new Stack<Node>();
+		Stack<Node> stack = new Stack<>();
 		stack.add(treeRoot);
 
 		double ratio = Double.MIN_VALUE;
@@ -464,7 +488,7 @@ protected Node findWorstOption() {
 				for (int i = 0; i < getModelContext().numOutputAttributes(); i++) {
 					nodeRatios.setValue(i, myParent.getFFRatio(nodeIndex, i));
 				}
-				double nodeRatio = nodeRatios.sumOfValues() / nodeRatios.numValues(); 
+				double nodeRatio = nodeRatios.sumOfValues() / nodeRatios.numValues();
 
 				if (nodeRatio > ratio) {
 					ratio = nodeRatio;
@@ -494,9 +518,9 @@ protected void removeExcessTrees() {
 					parent.parent.setChild(parent.parent.getChildIndex(parent), chld);
 				}
 			} else {
-				AutoExpandVector<Node> children = new AutoExpandVector<Node>();
-				AutoExpandVector<DoubleVector> optionFFSSL = new AutoExpandVector<DoubleVector>();
-				AutoExpandVector<DoubleVector> optionFFSeen = new AutoExpandVector<DoubleVector>();
+				AutoExpandVector<Node> children = new AutoExpandVector<>();
+				AutoExpandVector<DoubleVector> optionFFSSL = new AutoExpandVector<>();
+				AutoExpandVector<DoubleVector> optionFFSeen = new AutoExpandVector<>();
 
 				int seen = 0;
 
diff --git a/moa/src/main/java/moa/classifiers/mtr/trees/ISOUPTree.java b/moa/src/main/java/moa/learners/predictors/trees/ISOUPTree.java
similarity index 74%
rename from moa/src/main/java/moa/classifiers/mtr/trees/ISOUPTree.java
rename to moa/src/main/java/moa/learners/predictors/trees/ISOUPTree.java
index df8999b53..56fdc7e21 100644
--- a/moa/src/main/java/moa/classifiers/mtr/trees/ISOUPTree.java
+++ b/moa/src/main/java/moa/learners/predictors/trees/ISOUPTree.java
@@ -14,17 +14,16 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-/* Project MAESTRA (Learning from Massive, Incompletely annotated, and Structured Data) 
+/* Project MAESTRA (Learning from Massive, Incompletely annotated, and Structured Data)
  *
  * Contact: saso.dzeroski@ijs.si
  */
 
-package moa.classifiers.mtr.trees;
-
+package moa.learners.predictors.trees;
 
 import java.io.BufferedWriter;
 import java.io.FileWriter;
@@ -46,25 +45,25 @@
 import com.yahoo.labs.samoa.instances.predictions.MultiTargetRegressionPrediction;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-import moa.classifiers.AbstractMultiTargetRegressor;
-import moa.classifiers.SemiSupervisedLearner;
-import moa.classifiers.mlc.core.attributeclassobservers.AttributeStatisticsObserver;
-import moa.classifiers.mlc.core.attributeclassobservers.MultiLabelBSTree;
-import moa.classifiers.mlc.core.attributeclassobservers.MultiLabelBSTreePCT;
-import moa.classifiers.mlc.core.attributeclassobservers.MultiLabelNominalAttributeObserver;
-import moa.classifiers.mlc.core.attributeclassobservers.NominalStatisticsObserver;
-import moa.classifiers.mlc.core.attributeclassobservers.NumericStatisticsObserver;
-import moa.classifiers.mlc.core.splitcriteria.MultiLabelSplitCriterion;
-import moa.classifiers.mlc.core.splitcriteria.PCTWeightedICVarianceReduction;
-import moa.classifiers.mlc.core.splitcriteria.WeightedICVarianceReduction;
-import moa.classifiers.rules.core.AttributeExpansionSuggestion;
-import moa.classifiers.rules.core.Predicate;
 import moa.core.AutoExpandVector;
 import moa.core.DoubleVector;
 import moa.core.Measurement;
 import moa.core.SizeOf;
 import moa.core.StringUtils;
-import moa.learners.MultiTargetRegressor;
+import moa.learners.predictors.AbstractMultiTargetRegressor;
+import moa.learners.predictors.MultiTargetRegressor;
+import moa.learners.predictors.SemiSupervisedMultiTargetRegressor;
+import moa.learners.predictors.core.attributeclassobservers.AttributeStatisticsObserver;
+import moa.learners.predictors.core.attributeclassobservers.MultiLabelBSTree;
+import moa.learners.predictors.core.attributeclassobservers.MultiLabelBSTreePCT;
+import moa.learners.predictors.core.attributeclassobservers.MultiLabelNominalAttributeObserver;
+import moa.learners.predictors.core.attributeclassobservers.NominalStatisticsObserver;
+import moa.learners.predictors.core.attributeclassobservers.NumericStatisticsObserver;
+import moa.learners.predictors.core.splitcriteria.MultiLabelSplitCriterion;
+import moa.learners.predictors.core.splitcriteria.PCTWeightedICVarianceReduction;
+import moa.learners.predictors.core.splitcriteria.WeightedICVarianceReduction;
+import moa.learners.predictors.rules.core.AttributeExpansionSuggestion;
+import moa.learners.predictors.rules.core.Predicate;
 
 /**
  * iSOUPTree class for structured output prediction.
@@ -72,7 +71,7 @@
  * @author Aljaž Osojnik (aljaz.osojnik@ijs.si)
  * @version $Revision: 1 $
  */
-public class ISOUPTree extends AbstractMultiTargetRegressor implements MultiTargetRegressor, SemiSupervisedLearner {
+public class ISOUPTree extends AbstractMultiTargetRegressor implements MultiTargetRegressor, SemiSupervisedMultiTargetRegressor {
 
 	private static final long serialVersionUID = 1L;
 
@@ -96,94 +95,58 @@ public class ISOUPTree extends AbstractMultiTargetRegressor implements MultiTarg
 	private BufferedWriter writer;
 	public DoubleVector targetWeights;
 
-	//region ================ OPTIONS ================
-
-	public IntOption gracePeriodOption = new IntOption(
-			"gracePeriod",
-			'g',
-			"The number of instances a leaf should observe between split attempts.",
-			200, 0, Integer.MAX_VALUE);
-
-	public FloatOption splitConfidenceOption = new FloatOption(
-			"splitConfidence",
-			'c',
-			"The allowable error in split decision, values closer to 0 will take longer to decide.",
-			0.0000001, 0.0, 1.0);
-
-	public FloatOption tieThresholdOption = new FloatOption(
-			"tieThreshold",
-			't',
-			"Threshold below which a split will be forced to break ties.",
-			0.05, 0.0, 1.0);
-
-	public FloatOption PageHinckleyAlphaOption = new FloatOption(
-			"PageHinckleyAlpha",
-			'a',
-			"The alpha value to use in the Page Hinckley change detection tests.",
-			0.005, 0.0, 1.0);
-
-	public IntOption PageHinckleyThresholdOption = new IntOption(
-			"PageHinckleyThreshold",
-			'h',
-			"The threshold value to be used in the Page Hinckley change detection tests.",
-			50, 0, Integer.MAX_VALUE);
-
-	public FloatOption alternateTreeFadingFactorOption = new FloatOption(
-			"alternateTreeFadingFactor",
-			'f',
-			"The fading factor to use when deciding if an alternate tree should replace an original.",
-			0.995, 0.0, 1.0);
-
-	public IntOption alternateTreeTMinOption = new IntOption(
-			"alternateTreeTMin",
-			'y',
-			"The Tmin value to use when deciding if an alternate tree should replace an original.",
-			150, 0, Integer.MAX_VALUE);
-
-	public IntOption alternateTreeTimeOption = new IntOption(
-			"alternateTreeTime",
-			'u',
+	// region ================ OPTIONS ================
+
+	public IntOption gracePeriodOption = new IntOption("gracePeriod", 'g',
+			"The number of instances a leaf should observe between split attempts.", 200, 0, Integer.MAX_VALUE);
+
+	public FloatOption splitConfidenceOption = new FloatOption("splitConfidence", 'c',
+			"The allowable error in split decision, values closer to 0 will take longer to decide.", 0.0000001, 0.0,
+			1.0);
+
+	public FloatOption tieThresholdOption = new FloatOption("tieThreshold", 't',
+			"Threshold below which a split will be forced to break ties.", 0.05, 0.0, 1.0);
+
+	public FloatOption PageHinckleyAlphaOption = new FloatOption("PageHinckleyAlpha", 'a',
+			"The alpha value to use in the Page Hinckley change detection tests.", 0.005, 0.0, 1.0);
+
+	public IntOption PageHinckleyThresholdOption = new IntOption("PageHinckleyThreshold", 'h',
+			"The threshold value to be used in the Page Hinckley change detection tests.", 50, 0, Integer.MAX_VALUE);
+
+	public FloatOption alternateTreeFadingFactorOption = new FloatOption("alternateTreeFadingFactor", 'f',
+			"The fading factor to use when deciding if an alternate tree should replace an original.", 0.995, 0.0, 1.0);
+
+	public IntOption alternateTreeTMinOption = new IntOption("alternateTreeTMin", 'y',
+			"The Tmin value to use when deciding if an alternate tree should replace an original.", 150, 0,
+			Integer.MAX_VALUE);
+
+	public IntOption alternateTreeTimeOption = new IntOption("alternateTreeTime", 'u',
 			"The 'time' (in terms of number of instances) value to use when deciding if an alternate tree should be discarded.",
 			1500, 0, Integer.MAX_VALUE);
 
-	public FlagOption regressionTreeOption = new FlagOption(
-			"regressionTree",
-			's',
+	public FlagOption regressionTreeOption = new FlagOption("regressionTree", 's',
 			"Build a regression tree instead of a model tree.");
 
-	public FloatOption learningRatioOption = new FloatOption(
-			"learningRatio", 
-			'l',
-			"Learning ratio to use for training the Perceptrons in the leaves.",
-			0.02);
-
-	public FloatOption learningRateDecayFactorOption = new FloatOption(
-			"learningRatioDecayFactor",
-			'd',
-			"Learning rate decay factor (not used when learning rate is constant).",
-			0.001);
-
-	public FlagOption learningRatioConstOption = new FlagOption(
-			"learningRatioConst",
-			'o',
+	public FloatOption learningRatioOption = new FloatOption("learningRatio", 'l',
+			"Learning ratio to use for training the Perceptrons in the leaves.", 0.02);
+
+	public FloatOption learningRateDecayFactorOption = new FloatOption("learningRatioDecayFactor", 'd',
+			"Learning rate decay factor (not used when learning rate is constant).", 0.001);
+
+	public FlagOption learningRatioConstOption = new FlagOption("learningRatioConst", 'o',
 			"Keep learning rate constant instead of decaying (if kept constant learning ratio is suggested to be 0.001).");
 
-	public FlagOption runAsPCTOption = new FlagOption(
-			"runAsPCT",
-			'p',
+	public FlagOption runAsPCTOption = new FlagOption("runAsPCT", 'p',
 			"Run as a predictive clustering tree, i.e., use input attributes in heuristic calculation.");
 
+	public FlagOption doNotNormalizeOption = new FlagOption("doNotNormalize", 'n', "Don't normalize.");
 
-	public FlagOption doNotNormalizeOption = new FlagOption(
-			"doNotNormalize",
-			'n',
-			"Don't normalize.");
-
-	public FileOption weightFile = new FileOption("targetWeightFile", 'w', "File with the weights of the targets.", null, null, false);
+	public FileOption weightFile = new FileOption("targetWeightFile", 'w', "File with the weights of the targets.",
+			null, null, false);
 
-	//endregion ================ OPTIONS ================
+	// endregion ================ OPTIONS ================
 
-	//region ================ CLASSES ================
+	// region ================ CLASSES ================
 
 	public abstract static class Node implements Serializable {
 
@@ -201,7 +164,6 @@ public abstract static class Node implements Serializable {
 		protected Node alternateTree;
 		protected Node originalNode;
 
-
 		// The error values for the Page Hinckley test
 		// PHmT = the cumulative sum of the errors
 		// PHMT = the minimum error value seen so far
@@ -222,7 +184,6 @@ public abstract static class Node implements Serializable {
 		// Sum of squared y values
 		public DoubleVector sumOfInputSquares;
 
-
 		public Node(ISOUPTree tree) {
 			this.tree = tree;
 			this.ID = tree.maxID;
@@ -240,9 +201,11 @@ public void copyStatistics(Node node) {
 		}
 
 		public long calcByteSize() {
-			long size = SizeOf.sizeOf(this) + SizeOf.sizeOf(sumOfSquares) + SizeOf.sizeOf(sumOfValues) + SizeOf.sizeOf(examplesSeen);
+			long size = SizeOf.sizeOf(this) + SizeOf.sizeOf(sumOfSquares) + SizeOf.sizeOf(sumOfValues)
+					+ SizeOf.sizeOf(examplesSeen);
 			if (tree.runAsPCTOption.isSet()) {
-				size += SizeOf.sizeOf(sumOfInputSquares) + SizeOf.sizeOf(sumOfInputValues) + SizeOf.sizeOf(weightOfInputs);
+				size += SizeOf.sizeOf(sumOfInputSquares) + SizeOf.sizeOf(sumOfInputValues)
+						+ SizeOf.sizeOf(weightOfInputs);
 			}
 			return size;
 		}
@@ -251,7 +214,7 @@ public long calcByteSize() {
 		 * Set the parent node
 		 */
 		public void setParent(InnerNode parent) {
-			this.parent = parent;    
+			this.parent = parent;
 		}
 
 		/**
@@ -269,7 +232,8 @@ public void restartChangeDetection() {
 			changeDetection = true;
 		}
 
-		public void getDescription(StringBuilder sb, int i) {}
+		public void getDescription(StringBuilder sb, int i) {
+		}
 
 		public abstract double[] getPrediction(Instance inst);
 
@@ -317,7 +281,7 @@ public static class LeafNode extends Node {
 
 		// Perceptron model that carries out the actual learning in each node
 		public MultitargetPerceptron learningModel;
-		
+
 		public double learningWeight = 0.0;
 
 		public DoubleVector errorP = new DoubleVector();
@@ -327,7 +291,7 @@ public static class LeafNode extends Node {
 
 		protected double examplesSeenAtLastSplitEvaluation = 0;
 
-		protected AutoExpandVector<AttributeStatisticsObserver> attributeObservers = new AutoExpandVector<AttributeStatisticsObserver>();
+		protected AutoExpandVector<AttributeStatisticsObserver> attributeObservers = new AutoExpandVector<>();
 
 		/**
 		 * Create a new LeafNode
@@ -349,6 +313,7 @@ public LeafNode(ISOUPTree tree) {
 			}
 		}
 
+		@Override
 		public long calcByteSize() {
 			long size = super.calcByteSize();
 			if (tree.buildingModelTree()) {
@@ -366,9 +331,9 @@ public void initializeInputIndexes() {
 		}
 
 		/**
-		 * Method to learn from an instance that passes the new instance to the perceptron learner,
-		 * and also prevents the class value from being truncated to an int when it is passed to the
-		 * attribute observer
+		 * Method to learn from an instance that passes the new instance to the
+		 * perceptron learner, and also prevents the class value from being truncated to
+		 * an int when it is passed to the attribute observer
 		 */
 		public void learnFromInstance(Instance inst, double[] prediction, boolean growthAllowed) {
 			// Update the statistics for this node
@@ -382,10 +347,11 @@ public void learnFromInstance(Instance inst, double[] prediction, boolean growth
 			// number of instances passing through the node
 			learningWeight += weight;
 
-				// sum of y values
+			// sum of y values
 
-			if (tree.buildingModelTree() && !inst.missingOutputs()) learningModel.updatePerceptron(inst);
-				// sum of squared y values
+			if (tree.buildingModelTree() && !inst.missingOutputs())
+				learningModel.updatePerceptron(inst);
+			// sum of squared y values
 			for (int i = 0; i < tree.numOutputAttributes; i++) {
 				if (!inst.isOutputMissing(i)) {
 					double outVal = inst.valueOutputAttribute(i);
@@ -396,13 +362,14 @@ public void learnFromInstance(Instance inst, double[] prediction, boolean growth
 					// sum of squared y values
 					sumOfSquares.addToValue(i, weight * outVal * outVal);
 
-				if (tree.buildingModelTree()) {
+					if (tree.buildingModelTree()) {
 						errorP.setValue(i, errorP.getValue(i) * 0.95 + Math.abs(predictionP[i] - outVal));
 						errorM.setValue(i, errorM.getValue(i) * 0.95 + Math.abs(predictionM[i] - outVal));
-				}
+					}
 
-					observations[i] = new DoubleVector(new double[] {weight, weight * outVal, weight * outVal * outVal}); 
-			}
+					observations[i] = new DoubleVector(
+							new double[] { weight, weight * outVal, weight * outVal * outVal });
+				}
 			}
 
 			if (tree.runAsPCTOption.isSet()) {
@@ -418,7 +385,8 @@ public void learnFromInstance(Instance inst, double[] prediction, boolean growth
 						// sum of squared attr values
 						sumOfInputSquares.addToValue(i, weight * inVal * inVal);
 
-						inputObservations[i] = new DoubleVector(new double[] {weight, weight * inVal, weight * inVal * inVal}); 
+						inputObservations[i] = new DoubleVector(
+								new double[] { weight, weight * inVal, weight * inVal * inVal });
 					}
 				}
 			}
@@ -438,7 +406,8 @@ public void learnFromInstance(Instance inst, double[] prediction, boolean growth
 				if (!tree.runAsPCTOption.isSet() || !inst.inputAttribute(i).isNumeric()) {
 					obs.observeAttribute(inst.valueInputAttribute(i), observations);
 				} else {
-					((MultiLabelBSTreePCT) obs).observeAttribute(inst.valueInputAttribute(i), observations, inputObservations);
+					((MultiLabelBSTreePCT) obs).observeAttribute(inst.valueInputAttribute(i), observations,
+							inputObservations);
 				}
 			}
 
@@ -448,11 +417,12 @@ public void learnFromInstance(Instance inst, double[] prediction, boolean growth
 		}
 
 		/**
-		 * Return the best split suggestions for this node using the given split criteria
+		 * Return the best split suggestions for this node using the given split
+		 * criteria
 		 */
 		public AttributeExpansionSuggestion[] getBestSplitSuggestions(MultiLabelSplitCriterion criterion) {
 
-			List<AttributeExpansionSuggestion> bestSuggestions = new LinkedList<AttributeExpansionSuggestion>();
+			List<AttributeExpansionSuggestion> bestSuggestions = new LinkedList<>();
 
 			for (int i : inputIndexes) {
 				AttributeStatisticsObserver obs = attributeObservers.get(i);
@@ -479,9 +449,10 @@ public AttributeExpansionSuggestion[] getBestSplitSuggestions(MultiLabelSplitCri
 
 					AttributeExpansionSuggestion bestSuggestion = null;
 					if (tree.runAsPCTOption.isSet() && tree.modelContext.inputAttribute(i).isNumeric()) {
-						bestSuggestion = ((MultiLabelBSTreePCT) obs).getBestEvaluatedSplitSuggestion(criterion, preSplitStatistics, preSplitInputStatistics, i);
+						bestSuggestion = ((MultiLabelBSTreePCT) obs).getBestEvaluatedSplitSuggestion(criterion,
+								preSplitStatistics, preSplitInputStatistics, i);
 					} else {
-					bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion, preSplitStatistics, i);
+						bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion, preSplitStatistics, i);
 					}
 
 					if (bestSuggestion != null) {
@@ -511,6 +482,7 @@ public double[] getPredictionTargetMean(Instance inst) {
 			return pred;
 		}
 
+		@Override
 		public double[] getPrediction(Instance inst) {
 			if (tree.buildingModelTree()) {
 				double[] predictionP = getPredictionModel(inst);
@@ -530,22 +502,25 @@ public double[] getPrediction(Instance inst) {
 
 		}
 
-		//		public double[] getClassVotes(MultiLabelInstance inst, ISOUPTrees tree) {
-		//			return new double[] {getPrediction(inst, tree)};
-		//		}
+		// public double[] getClassVotes(MultiLabelInstance inst, ISOUPTrees tree) {
+		// return new double[] {getPrediction(inst, tree)};
+		// }
 
 		public void checkForSplit() {
-			// If it has seen Nmin examples since it was last tested for splitting, attempt a split of this node
+			// If it has seen Nmin examples since it was last tested for splitting, attempt
+			// a split of this node
 			// TODO How does this interact with partially labeled examples
 			if (learningWeight - examplesSeenAtLastSplitEvaluation >= tree.gracePeriodOption.getValue()) {
 				int index = (parent != null) ? parent.getChildIndex(this) : 0;
 				tree.attemptToSplit(this, parent, index);
 
-				// Take note of how many instances were seen when this split evaluation was made, so we know when to perform the next split evaluation
+				// Take note of how many instances were seen when this split evaluation was
+				// made, so we know when to perform the next split evaluation
 				examplesSeenAtLastSplitEvaluation = learningWeight;
 			}
 		}
 
+		@Override
 		public void describeSubtree(StringBuilder out, int indent) {
 			StringUtils.appendIndented(out, indent, "Leaf ");
 			StringUtils.appendNewline(out);
@@ -553,7 +528,8 @@ public void describeSubtree(StringBuilder out, int indent) {
 			if (tree.buildingModelTree()) {
 				learningModel.getModelDescription(out, indent + 2);
 			} else {
-				//out.append(tree.getClassNameString() + " = " + String.format("%.4f", (sumOfValues / examplesSeen)));
+				// out.append(tree.getClassNameString() + " = " + String.format("%.4f",
+				// (sumOfValues / examplesSeen)));
 				out.append("Leaf node");
 				StringUtils.appendNewline(out);
 			}
@@ -562,14 +538,15 @@ public void describeSubtree(StringBuilder out, int indent) {
 	}
 
 	public static abstract class InnerNode extends Node {
-		// The InnerNode and SplitNode design is used for easy extension in ISOUPOptionTree
+		// The InnerNode and SplitNode design is used for easy extension in
+		// ISOUPOptionTree
 		private static final long serialVersionUID = 1L;
 
-		protected AutoExpandVector<Node> children = new AutoExpandVector<Node>();
+		protected AutoExpandVector<Node> children = new AutoExpandVector<>();
 
 		// Sum of absolute errors
 		protected DoubleVector sumOfAbsErrors = new DoubleVector(); // Needed for PH tracking of mean error
-		
+
 		protected DoubleVector PHsums = new DoubleVector();
 		protected DoubleVector PHmins = new DoubleVector();
 
@@ -585,6 +562,7 @@ public InnerNode(ISOUPTree tree) {
 			super(tree);
 		}
 
+		@Override
 		public long calcByteSize() {
 			long size = super.calcByteSize();
 			size += SizeOf.sizeOf(PHsums) + SizeOf.sizeOf(PHmins) + SizeOf.sizeOf(sumOfAbsErrors);
@@ -601,14 +579,17 @@ public Node getChild(int i) {
 			return children.get(i);
 		}
 
+		@Override
 		public int getChildIndex(Node child) {
 			return children.indexOf(child);
 		}
 
+		@Override
 		public void setChild(int i, Node child) {
 			children.set(i, child);
 		}
 
+		@Override
 		public void disableChangeDetection() {
 			changeDetection = false;
 			for (Node child : children) {
@@ -616,6 +597,7 @@ public void disableChangeDetection() {
 			}
 		}
 
+		@Override
 		public void restartChangeDetection() {
 			if (this.alternateTree == null) {
 				changeDetection = true;
@@ -623,7 +605,7 @@ public void restartChangeDetection() {
 				PHmins = new DoubleVector();
 				for (int i = 0; i < tree.numOutputAttributes; i++) {
 					PHmins.setValue(i, Double.MAX_VALUE);
-				}				
+				}
 				for (Node child : children)
 					child.restartChangeDetection();
 			}
@@ -632,14 +614,14 @@ public void restartChangeDetection() {
 		/**
 		 * Check to see if the tree needs updating
 		 */
-		public boolean PageHinckleyTest(double error, double threshold, int targetIndex) {    
+		public boolean PageHinckleyTest(double error, double threshold, int targetIndex) {
 			// Update the cumulative mT sum
 			PHsums.addToValue(targetIndex, error);
 
 			// Update the minimum mT value if the new mT is
 			// smaller than the current minimum
-			if(PHsums.getValue(targetIndex) < PHmins.getValue(targetIndex)) {
-				PHmins.setValue(targetIndex, PHsums.getValue(targetIndex));;
+			if (PHsums.getValue(targetIndex) < PHmins.getValue(targetIndex)) {
+				PHmins.setValue(targetIndex, PHsums.getValue(targetIndex));
 			}
 			// Return true if the cumulative value - the current minimum is
 			// greater than the current threshold (in which case we should adapt)
@@ -678,6 +660,7 @@ public static class SplitNode extends InnerNode {
 
 		/**
 		 * Create a new SplitNode
+		 * 
 		 * @param predicate
 		 * @param tree
 		 */
@@ -687,6 +670,7 @@ public SplitNode(Predicate predicate, ISOUPTree tree) {
 			ID = tree.maxID;
 		}
 
+		@Override
 		public long calcByteSize() {
 			return super.calcByteSize() + SizeOf.sizeOf(predicate);
 		}
@@ -695,6 +679,7 @@ public int instanceChildIndex(Instance inst) {
 			return (predicate.evaluate(inst)) ? 0 : 1;
 		}
 
+		@Override
 		public void describeSubtree(StringBuilder out, int indent) {
 			for (int branch = 0; branch < children.size(); branch++) {
 				Node child = getChild(branch);
@@ -712,6 +697,7 @@ public void describeSubtree(StringBuilder out, int indent) {
 			}
 		}
 
+		@Override
 		public double[] getPrediction(Instance inst) {
 			return children.get(predicate.evaluate(inst) ? 0 : 1).getPrediction(inst);
 		}
@@ -720,14 +706,14 @@ public double[] getPrediction(Instance inst) {
 	public class MultitargetPerceptron implements Serializable {
 
 		/**
-		 * 
+		 *
 		 */
 		private static final long serialVersionUID = 1L;
 
 		protected ISOUPTree tree;
 
-		// The Perception weights 
-		public double[][] weights; 
+		// The Perception weights
+		public double[][] weights;
 
 		// The number of instances contributing to this model
 		protected int instancesSeen = 0;
@@ -753,14 +739,13 @@ public String getPurposeString() {
 			return "A multi-target perceptron";
 		}
 
-
 		public void initializeWeights() {
 			instancesSeen = 0;
 			int numTargets = tree.numOutputAttributes;
 			int numInputs = tree.numInputAttributes;
-			weights = new double[numTargets][numInputs+1];
+			weights = new double[numTargets][numInputs + 1];
 			for (int i = 0; i < numTargets; i++) {
-				for (int j = 0; j < numInputs + 1; j++) { 
+				for (int j = 0; j < numInputs + 1; j++) {
 					// The last index corresponds to the constant b
 					weights[i][j] = 2 * tree.classifierRandom.nextDouble() - 1;
 				}
@@ -774,16 +759,17 @@ public void initializeWeights() {
 		public void updatePerceptron(Instance inst) {
 			// Update attribute statistics
 			instancesSeen += inst.weight();
-			
+
 			// Update weights
 			double learningRatio = 0.0;
 			if (tree.learningRatioConstOption.isSet()) {
 				learningRatio = tree.learningRatioOption.getValue();
 			} else {
-				learningRatio = tree.learningRatioOption.getValue() / (1 + instancesSeen * tree.learningRateDecayFactorOption.getValue());
+				learningRatio = tree.learningRatioOption.getValue()
+						/ (1 + instancesSeen * tree.learningRateDecayFactorOption.getValue());
 			}
 
-			// Loop for compatibility with bagging methods 
+			// Loop for compatibility with bagging methods
 			for (int i = 0; i < (int) inst.weight(); i++) {
 				updateWeights(inst, learningRatio);
 			}
@@ -792,15 +778,15 @@ public void updatePerceptron(Instance inst) {
 		public void updateWeights(Instance inst, double learningRatio) {
 			if (instancesSeen > 1.0) {
 				// Compute the normalized instance and the delta
-				double[] normalizedInput = tree.normalizedInputVector(inst); 
-			    double[] normalizedPrediction = prediction(normalizedInput);
+				double[] normalizedInput = tree.normalizedInputVector(inst);
+				double[] normalizedPrediction = prediction(normalizedInput);
 
 				double[] normalizedTarget = tree.normalizedTargetVector(inst);
-				for (int i = 0; i < tree.numOutputAttributes; i++){
+				for (int i = 0; i < tree.numOutputAttributes; i++) {
 					if (!Double.isNaN(normalizedTarget[i])) { /* to account for missing target values */
-					double delta = normalizedTarget[i] - normalizedPrediction[i];
-					for (int j = 0; j < normalizedInput.length; j++) {
-						weights[i][j] += delta * learningRatio * normalizedInput[j];
+						double delta = normalizedTarget[i] - normalizedPrediction[i];
+						for (int j = 0; j < normalizedInput.length; j++) {
+							weights[i][j] += delta * learningRatio * normalizedInput[j];
 						}
 					}
 				}
@@ -809,7 +795,7 @@ public void updateWeights(Instance inst, double learningRatio) {
 		}
 
 		public void normalizeWeights() {
-			for (int j =0; j < weights.length; j++) {
+			for (int j = 0; j < weights.length; j++) {
 				double sum = 0;
 				for (int i = 0; i < weights[j].length; i++)
 					sum += Math.abs(weights[j][i]);
@@ -843,38 +829,42 @@ private double[] denormalizePrediction(double[] normalizedPrediction) {
 			if (tree.normalize()) {
 				for (int i = 0; i < tree.numOutputAttributes; i++) {
 					double mean = tree.sumOfValues.getValue(i) / tree.examplesSeen.getValue(i);
-					double sd = computeSD(tree.sumOfSquares.getValue(i), tree.sumOfValues.getValue(i), tree.examplesSeen.getValue(i));
-					if (examplesSeen.getValue(i) > 1) 
+					double sd = computeSD(tree.sumOfSquares.getValue(i), tree.sumOfValues.getValue(i),
+							tree.examplesSeen.getValue(i));
+					if (examplesSeen.getValue(i) > 1)
 						out[i] = normalizedPrediction[i] * sd + mean;
 					else
 						out[i] = 0;
 				}
 				return out;
-			} else return normalizedPrediction;
+			} else
+				return normalizedPrediction;
 		}
 
 		public void getModelDescription(StringBuilder out, int indent) {
-				if (getModelContext() != null) {
+			if (getModelContext() != null) {
 				for (int i = 0; i < tree.numOutputAttributes; i++) {
-					StringUtils.appendIndented(out, indent, " [" + tree.getModelContext().outputAttribute(i).name() + "] =");
+					StringUtils.appendIndented(out, indent,
+							" [" + tree.getModelContext().outputAttribute(i).name() + "] =");
 					for (int j = 0; j < tree.numInputAttributes; j++) {
 						if (getModelContext().inputAttribute(j).isNumeric()) {
 							out.append((j == 0 && weights[i][j] >= 0) ? " " : (weights[i][j] < 0) ? " - " : " + ");
 							out.append(String.format("%.4f", Math.abs(weights[i][j])));
-										out.append(" * ");
+							out.append(" * ");
 							out.append(getModelContext().inputAttribute(j).name());
-									}
-				}
-					out.append((weights[i][tree.numInputAttributes] < 0 ? " - " : " + ") + String.format("%.4f", Math.abs(weights[i][tree.numInputAttributes])));
+						}
+					}
+					out.append((weights[i][tree.numInputAttributes] < 0 ? " - " : " + ")
+							+ String.format("%.4f", Math.abs(weights[i][tree.numInputAttributes])));
 				}
 				StringUtils.appendNewline(out);
 			}
 		}
 	}
 
-	//endregion ================ CLASSES ================
+	// endregion ================ CLASSES ================
 
-	//region ================ METHODS ================
+	// region ================ METHODS ================
 
 	// Regressor methods
 	public ISOUPTree() {
@@ -882,20 +872,22 @@ public ISOUPTree() {
 	}
 
 	public List<Integer> newInputIndexes() {
-		List<Integer> indexes = new Vector<Integer>();
+		List<Integer> indexes = new Vector<>();
 		for (int i = 0; i < this.numInputAttributes; i++) {
 			indexes.add(i, i);
 		}
 		return indexes;
 	}
 
+	@Override
 	public String getPurposeString() {
 		return "Implementation of the iSOUP-Tree algorithm as described by Osojnik et al.";
 	}
 
+	@Override
 	public void resetLearningImpl() {
 		treeRoot = null;
-		
+
 		if (this.getModelContext() != null)
 			checkRoot();
 
@@ -922,25 +914,31 @@ public void loadWeights() {
 		targetWeights = new DoubleVector();
 		try {
 			List<String> lines = Files.readAllLines(Paths.get(weightFile.getValue()), Charset.defaultCharset());
-			for (int i = 0 ; i < lines.size(); i++) targetWeights.setValue(i, Double.valueOf(lines.get(i)));
+			for (int i = 0; i < lines.size(); i++)
+				targetWeights.setValue(i, Double.valueOf(lines.get(i)));
 		} catch (Exception e) {
 			for (int i = 0; i < this.numOutputAttributes; i++)
 				targetWeights.setValue(i, 1.0);
 		}
 	}
 
+	@Override
 	public boolean isRandomizable() {
 		return true;
 	}
 
+	@Override
 	public void getModelDescription(StringBuilder out, int indent) {
-		if (treeRoot != null) treeRoot.describeSubtree(out, indent);
+		if (treeRoot != null)
+			treeRoot.describeSubtree(out, indent);
 	}
 
+	@Override
 	protected Measurement[] getModelMeasurementsImpl() {
-		return new Measurement[]{ 
-				//new Measurement("tree size (nodes)", this.leafNodeCount + this.splitNodeCount),
-				//new Measurement("tree size (leaves)", this.leafNodeCount)
+		return new Measurement[] {
+				// new Measurement("tree size (nodes)", this.leafNodeCount +
+				// this.splitNodeCount),
+				// new Measurement("tree size (leaves)", this.leafNodeCount)
 		};
 	}
 
@@ -960,20 +958,27 @@ public long calcByteSize() {
 		return size;
 	}
 
+	@Override
 	public Prediction getPredictionForInstance(Instance inst) {
 		double[] predictionVector = treeRoot.getPrediction(inst);
 		return new MultiTargetRegressionPrediction(predictionVector);
 	}
 
+	@Override
+	public Prediction getTrainingPrediction(Instance inst) {
+		return getPredictionForInstance(inst);
+	}
+	
 	public double[] normalizedInputVector(Instance inst) {
 		// Normalize Instance
-		double[] normalizedInput = new double[this.numInputAttributes+1];
+		double[] normalizedInput = new double[this.numInputAttributes + 1];
 		if (normalize()) {
 			for (int j = 0; j < this.numInputAttributes; j++) {
 				Attribute attr = inst.inputAttribute(j);
-				double value =  inst.valueInputAttribute(j);
+				double value = inst.valueInputAttribute(j);
 				double mean = sumOfAttrValues.getValue(j) / weightOfInputs.getValue(j);
-				double sd = computeSD(sumOfAttrSquares.getValue(j), sumOfAttrValues.getValue(j), weightOfInputs.getValue(j));
+				double sd = computeSD(sumOfAttrSquares.getValue(j), sumOfAttrValues.getValue(j),
+						weightOfInputs.getValue(j));
 				if (weightOfInputs.getValue(j) > 1 && sd > 0.00001) {
 					if (attr.isNumeric())
 						normalizedInput[j] = (value - mean) / sd;
@@ -996,15 +1001,16 @@ public double[] normalizedTargetVector(Instance inst) {
 		double[] out = new double[this.numOutputAttributes];
 		if (normalize()) {
 			for (int i = 0; i < this.numOutputAttributes; i++) {
-				double value = (inst.isOutputMissing(i)) ? Double.NaN : inst.valueOutputAttribute(i);;
+				double value = (inst.isOutputMissing(i)) ? Double.NaN : inst.valueOutputAttribute(i);
 				if (!Double.isNaN(value)) {
 					double sd = computeSD(sumOfSquares.getValue(i), sumOfValues.getValue(i), examplesSeen.getValue(i));
 					double average = sumOfValues.getValue(i) / examplesSeen.getValue(i);
 					if (sd > 0 && examplesSeen.getValue(i) > 1)
-					out[i] = (value - average) / (sd);
-				else
-					out[i] = 0;
-				} else out[i] = value;
+						out[i] = (value - average) / (sd);
+					else
+						out[i] = 0;
+				} else
+					out[i] = value;
 			}
 		} else {
 			for (int i = 0; i < this.numOutputAttributes; i++) {
@@ -1027,10 +1033,10 @@ public double[] normalizeTargetVector(double[] pred) {
 					out[i] = 0;
 			}
 			return out;
-		} else return pred;
+		} else
+			return pred;
 	}
 
-
 	public double normalizeTargetValue(Instance inst, int i) {
 		if (normalize()) {
 			if (examplesSeen.getValue(i) > 1) {
@@ -1043,7 +1049,8 @@ public double normalizeTargetValue(Instance inst, int i) {
 					return 0;
 			}
 			return 0;
-		} else return inst.valueOutputAttribute(i);
+		} else
+			return inst.valueOutputAttribute(i);
 	}
 
 	public double normalizeTargetValue(double value, int i) {
@@ -1057,7 +1064,8 @@ public double normalizeTargetValue(double value, int i) {
 					return 0;
 			}
 			return 0;
-		} else return value;
+		} else
+			return value;
 	}
 
 	public double[] getNormalizedError(Instance inst, double[] prediction) {
@@ -1066,22 +1074,22 @@ public double[] getNormalizedError(Instance inst, double[] prediction) {
 		double[] out = new double[this.numOutputAttributes];
 		if (normalPrediction != null)
 			for (int i = 0; i < this.numOutputAttributes; i++) {
-			out[i] = Math.abs(normalValue[i] - normalPrediction[i]);
-		}
+				out[i] = Math.abs(normalValue[i] - normalPrediction[i]);
+			}
 		return out;
 	}
 
-
 	/**
 	 * Method for updating (training) the model using a new instance
 	 */
+	@Override
 	public void trainOnInstanceImpl(Instance inst) {
 		if (inst.weight() > 0) {
 
 			double[] prediction = treeRoot.getPrediction(inst);
-			//double[] normalError = getNormalizedError(inst, prediction);
+			// double[] normalError = getNormalizedError(inst, prediction);
 			double[] normalError = null;
-			//normalError.scaleValues(inst.weight());
+			// normalError.scaleValues(inst.weight());
 			processInstance(inst, treeRoot, prediction, normalError, true, false);
 
 			double weight = inst.weight();
@@ -1107,88 +1115,102 @@ public void trainOnInstanceImpl(Instance inst) {
 		}
 	}
 
-	public void processInstance(Instance inst, Node node, double[] prediction, double[] normalError, boolean growthAllowed, boolean inAlternate) {
+	public void processInstance(Instance inst, Node node, double[] prediction, double[] normalError,
+			boolean growthAllowed, boolean inAlternate) {
 		Node currentNode = node;
 		while (true) {
 			if (currentNode instanceof LeafNode) {
 				((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
 				break;
 			} else {
-				//currentNode.sumOfAbsErrors.addValues(normalError);
-				//				SplitNode iNode = (SplitNode) currentNode;
-				//				if (!inAlternate && iNode.alternateTree != null) {
-				//					boolean altTree = true;
-				//					double lossO = Math.pow(inst.valueOutputAttribute() - prediction, 2);
-				//					double lossA = Math.pow(inst.valueOutputAttribute() - iNode.alternateTree.getPrediction(inst), 2);
+				// currentNode.sumOfAbsErrors.addValues(normalError);
+				// SplitNode iNode = (SplitNode) currentNode;
+				// if (!inAlternate && iNode.alternateTree != null) {
+				// boolean altTree = true;
+				// double lossO = Math.pow(inst.valueOutputAttribute() - prediction, 2);
+				// double lossA = Math.pow(inst.valueOutputAttribute() -
+				// iNode.alternateTree.getPrediction(inst), 2);
 				//
-				//					iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
-				//					iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
-				//					iNode.lossExamplesSeen++;
+				// iNode.lossFadedSumOriginal = lossO +
+				// alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
+				// iNode.lossFadedSumAlternate = lossA +
+				// alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
+				// iNode.lossExamplesSeen++;
 				//
-				//					double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
-				//					double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
-				//					iNode.lossSumQi += Qi;
-				//					iNode.lossNumQiTests += 1;
-				//					double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+				// double Qi = Math.log((iNode.lossFadedSumOriginal) /
+				// (iNode.lossFadedSumAlternate));
+				// double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
+				// iNode.lossSumQi += Qi;
+				// iNode.lossNumQiTests += 1;
+				// double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
 				//
-				//					if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
-				//						iNode.previousWeight = iNode.lossExamplesSeen;
-				//						if (Qi > 0) {
-				//							SplitNode parent = currentNode.getParent();
+				// if (iNode.lossExamplesSeen - iNode.previousWeight >=
+				// alternateTreeTMinOption.getValue()) {
+				// iNode.previousWeight = iNode.lossExamplesSeen;
+				// if (Qi > 0) {
+				// SplitNode parent = currentNode.getParent();
 				//
-				//							if (parent != null) {
-				//								Node replacementTree = iNode.alternateTree;
-				//								parent.setChild(parent.getChildIndex(currentNode), replacementTree);
-				//								if (growthAllowed) replacementTree.restartChangeDetection();
-				//							} else {
-				//								treeRoot = iNode.alternateTree;
-				//								treeRoot.restartChangeDetection();
-				//							}
+				// if (parent != null) {
+				// Node replacementTree = iNode.alternateTree;
+				// parent.setChild(parent.getChildIndex(currentNode), replacementTree);
+				// if (growthAllowed) replacementTree.restartChangeDetection();
+				// } else {
+				// treeRoot = iNode.alternateTree;
+				// treeRoot.restartChangeDetection();
+				// }
 				//
-				//							currentNode = iNode.alternateTree;
-				//							altTree = false;
-				//						} else if (
-				//								(QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * this.gracePeriodOption.getValue()))
-				//								|| iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()
-				//								) {
-				//							iNode.alternateTree = null;
-				//							if (growthAllowed) iNode.restartChangeDetection();
-				//							altTree = false;
-				//						}
-				//					}
+				// currentNode = iNode.alternateTree;
+				// altTree = false;
+				// } else if (
+				// (QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 *
+				// this.gracePeriodOption.getValue()))
+				// || iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()
+				// ) {
+				// iNode.alternateTree = null;
+				// if (growthAllowed) iNode.restartChangeDetection();
+				// altTree = false;
+				// }
+				// }
 				//
-				//					if (altTree) {
-				//						growthAllowed = false;
-				//						processInstance(inst, iNode.alternateTree, prediction, normalError, true, true);
-				//					}
-				//				}
-
-				//				if (iNode.changeDetection && !inAlternate) {
-				//					if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
-				//						iNode.initializeAlternateTree(this);
-				//					}
-				//				}
-				//				}
-				//if (currentNode instanceof SplitNode) {
-					currentNode = ((SplitNode) currentNode).getChild(((SplitNode) currentNode).instanceChildIndex(inst));
-				//} else { // if the replaced alternate tree is just a leaf node
-				//	 ((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
-				//break;
+				// if (altTree) {
+				// growthAllowed = false;
+				// processInstance(inst, iNode.alternateTree, prediction, normalError, true,
+				// true);
+				// }
+				// }
+
+				// if (iNode.changeDetection && !inAlternate) {
+				// if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors /
+				// iNode.examplesSeen - PageHinckleyAlphaOption.getValue(),
+				// PageHinckleyThresholdOption.getValue())) {
+				// iNode.initializeAlternateTree(this);
+				// }
+				// }
+				// }
+				// if (currentNode instanceof SplitNode) {
+				currentNode = ((SplitNode) currentNode).getChild(((SplitNode) currentNode).instanceChildIndex(inst));
+				// } else { // if the replaced alternate tree is just a leaf node
+				// ((LeafNode) currentNode).learnFromInstance(inst, prediction, growthAllowed);
+				// break;
 			}
 		}
 	}
 
-	//region --- Object instatiation methods
+	// region --- Object instatiation methods
 
 	protected NumericStatisticsObserver newNumericClassObserver() {
 		try {
-			//NumericStatisticsObserver o = (NumericStatisticsObserver) ClassOption.cliStringToObject("MultiLabelBSTree -z 2000", MultiLabelBSTree.class, null);
-			//NumericStatisticsObserver o = (NumericStatisticsObserver) ClassOption.cliStringToObject("MultiLabelBSTree2 -z 2000", MultiLabelBSTree2.class, null);
+			// NumericStatisticsObserver o = (NumericStatisticsObserver)
+			// ClassOption.cliStringToObject("MultiLabelBSTree -z 2000",
+			// MultiLabelBSTree.class, null);
+			// NumericStatisticsObserver o = (NumericStatisticsObserver)
+			// ClassOption.cliStringToObject("MultiLabelBSTree2 -z 2000",
+			// MultiLabelBSTree2.class, null);
 			if (runAsPCTOption.isSet()) {
 				return new MultiLabelBSTreePCT();
 			} else {
-		return new MultiLabelBSTree();
-	}
+				return new MultiLabelBSTree();
+			}
 
 		} catch (Exception e) {
 			return null;
@@ -1199,10 +1221,10 @@ public NominalStatisticsObserver newNominalClassObserver() {
 		return new MultiLabelNominalAttributeObserver();
 	}
 
-	//	protected SplitNode newSplitNode(InstanceConditionalTest splitTest) {
-	//		maxID++;
-	//		return new SplitNode(splitTest, this);
-	//	}
+	// protected SplitNode newSplitNode(InstanceConditionalTest splitTest) {
+	// maxID++;
+	// return new SplitNode(splitTest, this);
+	// }
 
 	protected SplitNode newSplitNode(Predicate predicate) {
 		maxID++;
@@ -1218,9 +1240,9 @@ public MultitargetPerceptron newLeafModel() {
 		return new MultitargetPerceptron(this);
 	}
 
-	//endregion --- Object instatiation methods
+	// endregion --- Object instatiation methods
 
-	//region --- Processing methods
+	// region --- Processing methods
 	protected void checkRoot() {
 		if (treeRoot == null) {
 			treeRoot = newLeafNode();
@@ -1228,7 +1250,7 @@ protected void checkRoot() {
 	}
 
 	public static double computeHoeffdingBound(double range, double confidence, double n) {
-		return Math.sqrt(( (range * range) * Math.log(1 / confidence)) / (2.0 * n));
+		return Math.sqrt(((range * range) * Math.log(1 / confidence)) / (2.0 * n));
 	}
 
 	public boolean buildingModelTree() {
@@ -1240,18 +1262,25 @@ public boolean normalize() {
 	}
 
 	protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex) {
-		//System.out.println("Evaluating splits");
+		// System.out.println("Evaluating splits");
 		MultiLabelSplitCriterion splitCriterion = null;
 		if (!runAsPCTOption.isSet()) {
 			splitCriterion = new WeightedICVarianceReduction(targetWeights);
 		} else {
 			DoubleVector inputWeights = new DoubleVector();
-			for (int i = 0; i < numInputAttributes; i++) inputWeights.setValue(i, 1);
+			for (int i = 0; i < numInputAttributes; i++)
+				inputWeights.setValue(i, 1);
 			splitCriterion = new PCTWeightedICVarianceReduction(targetWeights, inputWeights, 0.5);
 		}
-		//System.out.println(examplesSeen);
-		// Set the split criterion to use to the SDR split criterion as described by Ikonomovska et al. 
-		AttributeExpansionSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion); // TODO update with split criterion option
+		// System.out.println(examplesSeen);
+		// Set the split criterion to use to the SDR split criterion as described by
+		// Ikonomovska et al.
+		AttributeExpansionSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion); // TODO
+																											// update
+																											// with
+																											// split
+																											// criterion
+																											// option
 
 		// Using this criterion, find the best split per attribute and rank the results
 
@@ -1263,27 +1292,38 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 		} else { // Otherwise, consider which of the splits proposed may be worth trying
 			Arrays.sort(bestSplitSuggestions);
 
-			// Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
+			// Determine the Hoeffding bound value, used to select how many instances should
+			// be used to make a test decision
 			double numExamples = node.learningWeight;
 			double hoeffdingBound = computeHoeffdingBound(1, splitConfidenceOption.getValue(), numExamples);
 			// Determine the top two ranked splitting suggestions
 			AttributeExpansionSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
 			AttributeExpansionSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
 
-			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
-			// as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
-			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
+			// If the upper bound of the sample mean for the ratio of SDR(best suggestion)
+			// to SDR(second best suggestion),
+			// as determined using the Hoeffding bound, is less than 1, then the true mean
+			// is also less than 1, and thus at this
+			// particular moment of observation the bestSuggestion is indeed the best split
+			// option with confidence 1-delta, and
 			// splitting should occur.
-			// Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
-			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
-			// competing attributes are equally good, and the split will be made on the one with the higher SDR value.
-			shouldSplit = (secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) || (hoeffdingBound < this.tieThresholdOption.getValue());
-			//System.out.print(hoeffdingBound);
-			//System.out.print(" ");
-			///System.out.println(secondBestSuggestion.merit / bestSuggestion.merit);
-			// If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
-				// TODO pruning is currently disabled
-						//TODO obs.removeBadSplits(null, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound, getModelContext().numOutputAttributes());
+			// Alternatively, if two or more splits are very similar or identical in terms
+			// of their splits, then a threshold limit
+			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is
+			// smaller than this limit then the two
+			// competing attributes are equally good, and the split will be made on the one
+			// with the higher SDR value.
+			shouldSplit = (secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound)
+					|| (hoeffdingBound < this.tieThresholdOption.getValue());
+			// System.out.print(hoeffdingBound);
+			// System.out.print(" ");
+			/// System.out.println(secondBestSuggestion.merit / bestSuggestion.merit);
+			// If the splitting criterion was not met, initiate pruning of the E-BST
+			// structures in each attribute observer
+			// TODO pruning is currently disabled
+			// TODO obs.removeBadSplits(null, secondBestSuggestion.merit /
+			// bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound,
+			// getModelContext().numOutputAttributes());
 //					AttributeStatisticsObserver obs = node.attributeObservers.get(i);
 //					if (obs != null) {
 //						if (getModelContext().attribute(i).isNumeric());
@@ -1292,11 +1332,11 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 //						// TODO nominal class observers
 //					}
 //				}
-						// TODO nominal class observers
-					}
-
+			// TODO nominal class observers
+		}
 
-		// If the splitting criterion were met, split the current node using the chosen attribute test, and
+		// If the splitting criterion were met, split the current node using the chosen
+		// attribute test, and
 		// make two new branches leading to (empty) leaves
 		if (shouldSplit) {
 			AttributeExpansionSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
@@ -1336,7 +1376,7 @@ protected void attemptToSplit(LeafNode node, InnerNode parent, int parentIndex)
 		}
 	}
 
-	public  double computeSD(double squaredVal, double val, double size) {
+	public double computeSD(double squaredVal, double val, double size) {
 		if (size > 1)
 			return Math.sqrt((squaredVal - ((val * val) / size)) / size);
 		else
@@ -1350,7 +1390,7 @@ public static double scalarProduct(DoubleVector u, DoubleVector v) {
 		}
 		return ret;
 	}
-	//endregion --- Processing methods
+	// endregion --- Processing methods
 
 	public void initWriter(String filename) {
 		try {
@@ -1383,7 +1423,7 @@ public void log(String s) {
 			}
 		}
 	}
-	//endregion --- Processing methods
+	// endregion --- Processing methods
 
-	//endregion ================ METHODS ================
+	// endregion ================ METHODS ================
 }
diff --git a/moa/src/main/java/moa/classifiers/mtr/trees/ISOUPTreeRF.java b/moa/src/main/java/moa/learners/predictors/trees/ISOUPTreeRF.java
similarity index 71%
rename from moa/src/main/java/moa/classifiers/mtr/trees/ISOUPTreeRF.java
rename to moa/src/main/java/moa/learners/predictors/trees/ISOUPTreeRF.java
index 1ac0b1075..63a3f143e 100644
--- a/moa/src/main/java/moa/classifiers/mtr/trees/ISOUPTreeRF.java
+++ b/moa/src/main/java/moa/learners/predictors/trees/ISOUPTreeRF.java
@@ -1,4 +1,4 @@
-package moa.classifiers.mtr.trees;
+package moa.learners.predictors.trees;
 
 import java.util.List;
 import java.util.Vector;
@@ -10,35 +10,33 @@
 public class ISOUPTreeRF extends ISOUPTree {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
-	
-	public MultiChoiceOption subspaceSizeOption = new MultiChoiceOption(
-			"randomForestFunAttr",
-			'z',
-			"The function of the number of input attribtues to use in the random forest construction.", 
-			new String[]{"sqrt", "log", "percent"}, new String[]{"Square root", "Logarithm", "10% percent"}, 0);
-	
-	
+
+	public MultiChoiceOption subspaceSizeOption = new MultiChoiceOption("randomForestFunAttr", 'z',
+			"The function of the number of input attribtues to use in the random forest construction.",
+			new String[] { "sqrt", "log", "percent" }, new String[] { "Square root", "Logarithm", "10% percent" }, 0);
+
 	public Integer subspaceSize = null;
-	
+
 	public int numRFAttrs() {
 		if (subspaceSize == null) {
 			switch (subspaceSizeOption.getChosenLabel()) {
-				case "sqrt": this.subspaceSize = 1 + (int) Math.ceil(Math.sqrt(this.getModelContext().numInputAttributes()));
-				case "log": this.subspaceSize = 1 + (int) Math.ceil(Math.log(this.getModelContext().numInputAttributes()));
-				case "percent": this.subspaceSize = (int) Math.ceil(0.1 * this.getModelContext().numInputAttributes());
+			case "sqrt":
+				this.subspaceSize = 1 + (int) Math.ceil(Math.sqrt(this.getModelContext().numInputAttributes()));
+			case "log":
+				this.subspaceSize = 1 + (int) Math.ceil(Math.log(this.getModelContext().numInputAttributes()));
+			case "percent":
+				this.subspaceSize = (int) Math.ceil(0.1 * this.getModelContext().numInputAttributes());
 			}
 		}
 		return this.subspaceSize;
 	}
-	
-	
-	
+
 	@Override
 	public List<Integer> newInputIndexes() {
-		List<Integer> indexes = new Vector<Integer>();
+		List<Integer> indexes = new Vector<>();
 		int numAttrs = this.getModelContext().numInputAttributes();
 		for (int i = 0; i < numAttrs; i++) {
 			indexes.add(i, i);
@@ -51,11 +49,11 @@ public List<Integer> newInputIndexes() {
 		}
 		return indexes.subList(0, numRFAttrs());
 	}
-	
+
 	public DoubleVector getFeatureScores() {
 		return getNodeFeatureScore(treeRoot);
 	}
-	
+
 	public DoubleVector getNodeFeatureScore(ISOUPTree.Node node) {
 		if (node instanceof ISOUPTree.SplitNode) {
 			DoubleVector scores = new DoubleVector(new double[getModelContext().numInputAttributes()]);
@@ -68,5 +66,5 @@ public DoubleVector getNodeFeatureScore(ISOUPTree.Node node) {
 			return new DoubleVector();
 		}
 	}
-	
+
 }
diff --git a/moa/src/main/java/moa/learners/predictors/trees/LimAttHoeffdingTree.java b/moa/src/main/java/moa/learners/predictors/trees/LimAttHoeffdingTree.java
new file mode 100644
index 000000000..ea4c88245
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/trees/LimAttHoeffdingTree.java
@@ -0,0 +1,196 @@
+/*
+ *    LimAttHoeffdingTree.java
+ *    Copyright (C) 2010 University of Waikato, Hamilton, New Zealand
+ *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.trees;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.core.Utils;
+import moa.learners.predictors.bayes.NaiveBayes;
+import moa.learners.predictors.core.attributeclassobservers.AttributeClassObserver;
+
+/**
+ * Hoeffding decision trees with a restricted number of attributes for data
+ * streams. LimAttClassifier is the stacking method that can be used with these
+ * decision trees. For more information see,<br/>
+ * <br/>
+ * Albert Bifet, Eibe Frank, Geoffrey Holmes, Bernhard Pfahringer: Accurate
+ * Ensembles for Data Streams: Combining Restricted Hoeffding Trees using
+ * Stacking. Journal of Machine Learning Research - Proceedings Track 13:
+ * 225-240 (2010) * <!-- technical-bibtex-start --> BibTeX:
+ * 
+ * <pre>
+ * &#64;article{BifetFHP10,
+ * author    = {Albert Bifet and
+ *              Eibe Frank and
+ *              Geoffrey Holmes and
+ *              Bernhard Pfahringer},
+ * title     = {Accurate Ensembles for Data Streams: Combining Restricted
+ *              Hoeffding Trees using Stacking},
+ * journal   = {Journal of Machine Learning Research - Proceedings Track},
+ * volume    = {13},
+ * year      = {2010},
+ * pages     = {225-240}
+ * }
+ * </pre>
+ * <p/>
+ * <!-- technical-bibtex-end -->
+ *
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @version $Revision: 7 $
+ */
+public class LimAttHoeffdingTree extends HoeffdingTree {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Hoeffding decision trees with a restricted number of attributes for data streams.";
+	}
+
+	protected int[] listAttributes;
+
+	public void setlistAttributes(int[] list) {
+		this.listAttributes = list;
+	}
+
+	public static class LimAttLearningNode extends ActiveLearningNode {
+
+		private static final long serialVersionUID = 1L;
+
+		protected double weightSeenAtLastSplitEvaluation;
+
+		protected int[] listAttributes;
+
+		protected int numAttributes;
+
+		public LimAttLearningNode(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		public void setlistAttributes(int[] list) {
+			this.listAttributes = list;
+			this.numAttributes = list.length;
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, HoeffdingTree ht) {
+			this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight());
+			if (this.listAttributes == null) {
+				setlistAttributes(((LimAttHoeffdingTree) ht).listAttributes);
+			}
+
+			for (int j = 0; j < this.numAttributes; j++) {
+				int i = this.listAttributes[j];
+				int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
+				AttributeClassObserver obs = this.attributeObservers.get(i);
+				if (obs == null) {
+					obs = inst.attribute(instAttIndex).isNominal() ? ht.newNominalClassObserver()
+							: ht.newNumericClassObserver();
+					this.attributeObservers.set(i, obs);
+				}
+				obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
+			}
+		}
+	}
+
+	public LimAttHoeffdingTree() {
+		this.removePoorAttsOption = null;
+	}
+
+	public static class LearningNodeNB extends LimAttLearningNode {
+
+		private static final long serialVersionUID = 1L;
+
+		public LearningNodeNB(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		@Override
+		public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
+			if (getWeightSeen() >= ht.nbThresholdOption.getValue()) {
+				return NaiveBayes.doNaiveBayesPrediction(inst, this.observedClassDistribution, this.attributeObservers);
+			}
+			return super.getClassVotes(inst, ht);
+		}
+
+		@Override
+		public void disableAttribute(int attIndex) {
+			// should not disable poor atts - they are used in NB calc
+		}
+	}
+
+	public static class LearningNodeNBAdaptive extends LearningNodeNB {
+
+		private static final long serialVersionUID = 1L;
+
+		protected double mcCorrectWeight = 0.0;
+
+		protected double nbCorrectWeight = 0.0;
+
+		public LearningNodeNBAdaptive(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, HoeffdingTree ht) {
+			int trueClass = (int) inst.classValue();
+			if (this.observedClassDistribution.maxIndex() == trueClass) {
+				this.mcCorrectWeight += inst.weight();
+			}
+			if (Utils.maxIndex(NaiveBayes.doNaiveBayesPrediction(inst, this.observedClassDistribution,
+					this.attributeObservers)) == trueClass) {
+				this.nbCorrectWeight += inst.weight();
+			}
+			super.learnFromInstance(inst, ht);
+		}
+
+		@Override
+		public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
+			if (this.mcCorrectWeight > this.nbCorrectWeight) {
+				return this.observedClassDistribution.getArrayCopy();
+			}
+			double ret[] = NaiveBayes.doNaiveBayesPrediction(inst, this.observedClassDistribution,
+					this.attributeObservers);
+			for (int i = 0; i < ret.length; i++) {
+				ret[i] *= this.observedClassDistribution.sumOfValues();
+			}
+			return ret;
+		}
+	}
+
+	@Override
+	protected LearningNode newLearningNode(double[] initialClassObservations) {
+		LearningNode ret;
+		int predictionOption = this.leafpredictionOption.getChosenIndex();
+		if (predictionOption == 0) { // MC
+			ret = new LimAttLearningNode(initialClassObservations);
+		} else if (predictionOption == 1) { // NB
+			ret = new LearningNodeNB(initialClassObservations);
+		} else { // NBAdaptive
+			ret = new LearningNodeNBAdaptive(initialClassObservations);
+		}
+		return ret;
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/trees/MultilabelHoeffdingTree.java b/moa/src/main/java/moa/learners/predictors/trees/MultilabelHoeffdingTree.java
new file mode 100644
index 000000000..e41efcb3c
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/trees/MultilabelHoeffdingTree.java
@@ -0,0 +1,919 @@
+/*
+ *    MultilabelMultilabelHoeffdingTree.java
+ *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
+ *    @author Jesse Read (jesse@tsc.uc3m.es)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.trees;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
+import com.github.javacliparser.FlagOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.AbstractMOAObject;
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.Example;
+import moa.core.Measurement;
+import moa.core.SizeOf;
+import moa.core.StringUtils;
+import moa.learners.predictors.AbstractMultiLabelClassifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.MultiLabelClassifier;
+import moa.learners.predictors.core.AttributeSplitSuggestion;
+import moa.learners.predictors.core.attributeclassobservers.AttributeClassObserver;
+import moa.learners.predictors.core.attributeclassobservers.DiscreteAttributeClassObserver;
+import moa.learners.predictors.core.attributeclassobservers.NullAttributeClassObserver;
+import moa.learners.predictors.core.attributeclassobservers.NumericAttributeClassObserver;
+import moa.learners.predictors.core.conditionaltests.InstanceConditionalTest;
+import moa.learners.predictors.core.splitcriteria.SplitCriterion;
+import moa.options.ClassOption;
+
+/**
+ * Hoeffding Tree for classifying multi-label data.
+ *
+ * A Hoeffding tree is an incremental, anytime decision tree induction algorithm
+ * that is capable of learning from massive data streams, assuming that the
+ * distribution generating examples does not change over time.
+ *
+ *
+ */
+public class MultilabelHoeffdingTree extends AbstractMultiLabelClassifier implements MultiLabelClassifier {
+// Needs to use InfoGainSplitCriterionMultiLabel, since multilabel entropy is calculated in a different way
+// Trains a mlinstance adding statistics of several class values and training node classifiers
+// Get votes from the classifier in the learning node of the tree
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption learnerOption = new ClassOption("learner", 'a', "Classifier to train.", Classifier.class,
+			"bayes.NaiveBayes");
+
+	public IntOption maxByteSizeOption = new IntOption("maxByteSize", 'm', "Maximum memory consumed by the tree.",
+			33554432, 0, Integer.MAX_VALUE);
+
+	public ClassOption numericEstimatorOption = new ClassOption("numericEstimator", 'n', "Numeric estimator to use.",
+			NumericAttributeClassObserver.class, "GaussianNumericAttributeClassObserver");
+
+	public ClassOption nominalEstimatorOption = new ClassOption("nominalEstimator", 'd', "Nominal estimator to use.",
+			DiscreteAttributeClassObserver.class, "NominalAttributeClassObserver");
+
+	public IntOption memoryEstimatePeriodOption = new IntOption("memoryEstimatePeriod", 'e',
+			"How many instances between memory consumption checks.", 1000000, 0, Integer.MAX_VALUE);
+
+	public IntOption gracePeriodOption = new IntOption("gracePeriod", 'g',
+			"The number of instances a leaf should observe between split attempts.", 200, 0, Integer.MAX_VALUE);
+
+	public ClassOption splitCriterionOption = new ClassOption("splitCriterion", 's', "Split criterion to use.",
+			SplitCriterion.class, "InfoGainSplitCriterion");
+
+	public FloatOption splitConfidenceOption = new FloatOption("splitConfidence", 'c',
+			"The allowable error in split decision, values closer to 0 will take longer to decide.", 0.0000001, 0.0,
+			1.0);
+
+	public FloatOption tieThresholdOption = new FloatOption("tieThreshold", 't',
+			"Threshold below which a split will be forced to break ties.", 0.05, 0.0, 1.0);
+
+	public FlagOption binarySplitsOption = new FlagOption("binarySplits", 'b', "Only allow binary splits.");
+
+	public FlagOption stopMemManagementOption = new FlagOption("stopMemManagement", 'z',
+			"Stop growing as soon as memory limit is hit.");
+
+	public FlagOption removePoorAttsOption = new FlagOption("removePoorAtts", 'r', "Disable poor attributes.");
+
+	public FlagOption noPrePruneOption = new FlagOption("noPrePrune", 'p', "Disable pre-pruning.");
+
+	public MultiChoiceOption leafpredictionOption = new MultiChoiceOption("leafprediction", 'l',
+			"Leaf prediction to use.", new String[] { "MC", "NB", "NBAdaptive" },
+			new String[] { "Majority class", "Naive Bayes", "Naive Bayes Adaptive" }, 2);
+
+	public IntOption nbThresholdOption = new IntOption("nbThreshold", 'q',
+			"The number of instances a leaf should observe before permitting Naive Bayes.", 0, 0, Integer.MAX_VALUE);
+
+	/*
+	 * public MultilabelMultilabelHoeffdingTree() { this.removePoorAttsOption =
+	 * null; }
+	 */
+
+	public static class FoundNode {
+
+		public Node node;
+
+		public SplitNode parent;
+
+		public int parentBranch;
+
+		public FoundNode(Node node, SplitNode parent, int parentBranch) {
+			this.node = node;
+			this.parent = parent;
+			this.parentBranch = parentBranch;
+		}
+	}
+
+	public static class Node extends AbstractMOAObject {
+
+		private static final long serialVersionUID = 1L;
+
+		protected DoubleVector observedClassDistribution;
+
+		public Node(double[] classObservations) {
+			this.observedClassDistribution = new DoubleVector(classObservations);
+		}
+
+		public int calcByteSize() {
+			return (int) (SizeOf.sizeOf(this) + SizeOf.fullSizeOf(this.observedClassDistribution));
+		}
+
+		public int calcByteSizeIncludingSubtree() {
+			return calcByteSize();
+		}
+
+		public boolean isLeaf() {
+			return true;
+		}
+
+		public FoundNode filterInstanceToLeaf(Instance inst, SplitNode parent, int parentBranch) {
+			return new FoundNode(this, parent, parentBranch);
+		}
+
+		public double[] getObservedClassDistribution() {
+			return this.observedClassDistribution.getArrayCopy();
+		}
+
+		public double[] getClassVotes(Instance inst, MultilabelHoeffdingTree ht) {
+			return this.observedClassDistribution.getArrayCopy();
+		}
+
+		public boolean observedClassDistributionIsPure() {
+			return this.observedClassDistribution.numNonZeroEntries() < 2;
+		}
+
+		public void describeSubtree(MultilabelHoeffdingTree ht, StringBuilder out, int indent) {
+			StringUtils.appendIndented(out, indent, "Leaf ");
+			out.append(ht.getClassNameString());
+			out.append(" = ");
+			out.append(ht.getClassLabelString(this.observedClassDistribution.maxIndex()));
+			out.append(" weights: ");
+			this.observedClassDistribution.getSingleLineDescription(out,
+					ht.treeRoot.observedClassDistribution.numValues());
+			StringUtils.appendNewline(out);
+		}
+
+		public int subtreeDepth() {
+			return 0;
+		}
+
+		public double calculatePromise() {
+			double totalSeen = this.observedClassDistribution.sumOfValues();
+			return totalSeen > 0.0
+					? (totalSeen - this.observedClassDistribution.getValue(this.observedClassDistribution.maxIndex()))
+					: 0.0;
+		}
+
+		@Override
+		public void getDescription(StringBuilder sb, int indent) {
+			describeSubtree(null, sb, indent);
+		}
+	}
+
+	public static class SplitNode extends Node {
+
+		private static final long serialVersionUID = 1L;
+
+		protected InstanceConditionalTest splitTest;
+
+		protected AutoExpandVector<Node> children; // = new AutoExpandVector<Node>();
+
+		@Override
+		public int calcByteSize() {
+			return super.calcByteSize() + (int) (SizeOf.sizeOf(this.children) + SizeOf.fullSizeOf(this.splitTest));
+		}
+
+		@Override
+		public int calcByteSizeIncludingSubtree() {
+			int byteSize = calcByteSize();
+			for (Node child : this.children) {
+				if (child != null) {
+					byteSize += child.calcByteSizeIncludingSubtree();
+				}
+			}
+			return byteSize;
+		}
+
+		public SplitNode(InstanceConditionalTest splitTest, double[] classObservations, int size) {
+			super(classObservations);
+			this.splitTest = splitTest;
+			this.children = new AutoExpandVector<>(size);
+		}
+
+		public SplitNode(InstanceConditionalTest splitTest, double[] classObservations) {
+			super(classObservations);
+			this.splitTest = splitTest;
+			this.children = new AutoExpandVector<>();
+		}
+
+		public int numChildren() {
+			return this.children.size();
+		}
+
+		public void setChild(int index, Node child) {
+			if ((this.splitTest.maxBranches() >= 0) && (index >= this.splitTest.maxBranches())) {
+				throw new IndexOutOfBoundsException();
+			}
+			this.children.set(index, child);
+		}
+
+		public Node getChild(int index) {
+			return this.children.get(index);
+		}
+
+		public int instanceChildIndex(Instance inst) {
+			return this.splitTest.branchForInstance(inst);
+		}
+
+		@Override
+		public boolean isLeaf() {
+			return false;
+		}
+
+		@Override
+		public FoundNode filterInstanceToLeaf(Instance inst, SplitNode parent, int parentBranch) {
+			int childIndex = instanceChildIndex(inst);
+			if (childIndex >= 0) {
+				Node child = getChild(childIndex);
+				if (child != null) {
+					return child.filterInstanceToLeaf(inst, this, childIndex);
+				}
+				return new FoundNode(null, this, childIndex);
+			}
+			return new FoundNode(this, parent, parentBranch);
+		}
+
+		@Override
+		public void describeSubtree(MultilabelHoeffdingTree ht, StringBuilder out, int indent) {
+			for (int branch = 0; branch < numChildren(); branch++) {
+				Node child = getChild(branch);
+				if (child != null) {
+					StringUtils.appendIndented(out, indent, "if ");
+					out.append(this.splitTest.describeConditionForBranch(branch, ht.getModelContext()));
+					out.append(": ");
+					StringUtils.appendNewline(out);
+					child.describeSubtree(ht, out, indent + 2);
+				}
+			}
+		}
+
+		@Override
+		public int subtreeDepth() {
+			int maxChildDepth = 0;
+			for (Node child : this.children) {
+				if (child != null) {
+					int depth = child.subtreeDepth();
+					if (depth > maxChildDepth) {
+						maxChildDepth = depth;
+					}
+				}
+			}
+			return maxChildDepth + 1;
+		}
+	}
+
+	public static abstract class LearningNode extends Node {
+
+		private static final long serialVersionUID = 1L;
+
+		public LearningNode(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		public abstract void learnFromInstance(Instance inst, MultilabelHoeffdingTree ht);
+	}
+
+	public static class InactiveLearningNode extends LearningNode {
+
+		private static final long serialVersionUID = 1L;
+
+		public InactiveLearningNode(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, MultilabelHoeffdingTree ht) {
+			this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight());
+		}
+	}
+
+	public static class ActiveLearningNode extends LearningNode {
+
+		private static final long serialVersionUID = 1L;
+
+		protected double weightSeenAtLastSplitEvaluation;
+
+		protected AutoExpandVector<AttributeClassObserver> attributeObservers = new AutoExpandVector<>();
+
+		protected boolean isInitialized;
+
+		public ActiveLearningNode(double[] initialClassObservations) {
+			super(initialClassObservations);
+			this.weightSeenAtLastSplitEvaluation = getWeightSeen();
+			this.isInitialized = false;
+		}
+
+		@Override
+		public int calcByteSize() {
+			return super.calcByteSize() + (int) (SizeOf.fullSizeOf(this.attributeObservers));
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, MultilabelHoeffdingTree ht) {
+			if (this.isInitialized == false) {
+				this.attributeObservers = new AutoExpandVector<>(inst.numAttributes());
+				this.isInitialized = true;
+			}
+			this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight());
+			for (int i = 0; i < inst.numAttributes() - 1; i++) {
+				int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
+				AttributeClassObserver obs = this.attributeObservers.get(i);
+				if (obs == null) {
+					obs = inst.attribute(instAttIndex).isNominal() ? ht.newNominalClassObserver()
+							: ht.newNumericClassObserver();
+					this.attributeObservers.set(i, obs);
+				}
+				obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
+			}
+		}
+
+		public double getWeightSeen() {
+			return this.observedClassDistribution.sumOfValues();
+		}
+
+		public double getWeightSeenAtLastSplitEvaluation() {
+			return this.weightSeenAtLastSplitEvaluation;
+		}
+
+		public void setWeightSeenAtLastSplitEvaluation(double weight) {
+			this.weightSeenAtLastSplitEvaluation = weight;
+		}
+
+		public AttributeSplitSuggestion[] getBestSplitSuggestions(SplitCriterion criterion,
+				MultilabelHoeffdingTree ht) {
+			List<AttributeSplitSuggestion> bestSuggestions = new LinkedList<>();
+			double[] preSplitDist = this.observedClassDistribution.getArrayCopy();
+			if (!ht.noPrePruneOption.isSet()) {
+				// add null split as an option
+				bestSuggestions.add(new AttributeSplitSuggestion(null, new double[0][],
+						criterion.getMeritOfSplit(preSplitDist, new double[][] { preSplitDist })));
+			}
+			for (int i = 0; i < this.attributeObservers.size(); i++) {
+				AttributeClassObserver obs = this.attributeObservers.get(i);
+				if (obs != null) {
+					AttributeSplitSuggestion bestSuggestion = obs.getBestEvaluatedSplitSuggestion(criterion,
+							preSplitDist, i, ht.binarySplitsOption.isSet());
+					if (bestSuggestion != null) {
+						bestSuggestions.add(bestSuggestion);
+					}
+				}
+			}
+			return bestSuggestions.toArray(new AttributeSplitSuggestion[bestSuggestions.size()]);
+		}
+
+		public void disableAttribute(int attIndex) {
+			this.attributeObservers.set(attIndex, new NullAttributeClassObserver());
+		}
+	}
+
+	public class LearningNodeClassifier extends ActiveLearningNode {
+
+		protected Classifier classifier;
+
+		private static final long serialVersionUID = 1L;
+
+		public LearningNodeClassifier(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		public LearningNodeClassifier(double[] initialClassObservations, Classifier cl, HoeffdingTreeClassifLeaves ht) {
+			super(initialClassObservations);
+			// public void LearningNodeClassifier1(double[] initialClassObservations,
+			// Classifier cl, HoeffdingTreeClassifLeaves ht ) {
+
+			if (cl == null) {
+				this.classifier = (Classifier) getPreparedClassOption(ht.learnerOption);
+			} else {
+				this.classifier = (Classifier) cl.copy();
+			}
+		}
+
+		@Override
+		public double[] getClassVotes(Instance inst, MultilabelHoeffdingTree ht) {
+			if (getWeightSeen() >= ht.nbThresholdOption.getValue()) {
+				return this.classifier.getPredictionForInstance(inst).asDoubleArray();
+			}
+			return super.getClassVotes(inst, ht);
+		}
+
+		@Override
+		public void disableAttribute(int attIndex) {
+			// should not disable poor atts - they are used in NB calc
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, MultilabelHoeffdingTree ht) {
+			this.classifier.trainOnInstance(inst);
+			super.learnFromInstance(inst, ht);
+		}
+
+		public Classifier getClassifier() {
+			return this.classifier;
+		}
+	}
+
+	public static class MultilabelInactiveLearningNode extends InactiveLearningNode {
+
+		private static final long serialVersionUID = 1L;
+
+		public MultilabelInactiveLearningNode(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, MultilabelHoeffdingTree ht) {
+			List<Integer> labels = getRelevantLabels(inst);
+			for (int l : labels) {
+				this.observedClassDistribution.addToValue(l, inst.weight());
+			}
+		}
+	}
+
+	public class MultilabelLearningNodeClassifier extends LearningNodeClassifier {
+		// It uses classifier at nodes, and to be able to train with several class
+		// values
+
+		private static final long serialVersionUID = 1L;
+
+		public MultilabelLearningNodeClassifier(double[] initialClassObservations, Classifier cl,
+				MultilabelHoeffdingTree ht) {
+			super(initialClassObservations);
+			this.observedClassDistribution = new DoubleVector(initialClassObservations);
+			this.weightSeenAtLastSplitEvaluation = getWeightSeen();
+			this.isInitialized = false;
+
+			if (cl == null) {
+				this.classifier = (Classifier) ((Classifier) getPreparedClassOption(ht.learnerOption)).copy();
+				this.classifier.resetLearning();
+
+				InstancesHeader raw_header = ht.getModelContext();
+				this.classifier.setModelContext(raw_header);
+			} else {
+				this.classifier = (Classifier) cl.copy();
+			}
+		}
+
+		public Prediction getPrediction(Instance inst, MultilabelHoeffdingTree ht) {
+
+			return this.classifier.getPredictionForInstance(inst);
+		}
+
+		public Prediction getPredictionForInstance(Instance inst, MultilabelHoeffdingTree ht) {
+
+			return this.classifier.getPredictionForInstance(inst);
+		}
+
+		@Override
+		public void disableAttribute(int attIndex) {
+			// should not disable poor atts - they are used in NB calc
+		}
+
+		@Override
+		public Classifier getClassifier() {
+			return this.classifier;
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, MultilabelHoeffdingTree ht) {
+
+			// It uses different class values, not only one
+			this.classifier.trainOnInstance(inst);
+			List<Integer> labels = MultilabelHoeffdingTree.getRelevantLabels(inst);
+			for (int l : labels) {
+				this.observedClassDistribution.addToValue(l, inst.weight());
+			}
+
+			for (int i = 0; i < inst.numInputAttributes(); i++) {
+				int instAttIndex = i;
+				AttributeClassObserver obs = this.attributeObservers.get(instAttIndex); // i
+				if (obs == null) {
+					obs = inst.inputAttribute(i).isNominal() ? ht.newNominalClassObserver()
+							: ht.newNumericClassObserver();
+					this.attributeObservers.set(i, obs);
+				}
+				for (int l : labels) {
+					obs.observeAttributeClass(inst.valueInputAttribute(i), l, inst.weight());
+				}
+			}
+		}
+
+		@Override
+		public void describeSubtree(MultilabelHoeffdingTree ht, StringBuilder out, int indent) {
+			StringUtils.appendIndented(out, indent, "Leaf ");
+			out.append(" = ");
+			out.append(" weights: ");
+			this.observedClassDistribution.getSingleLineDescription(out, this.observedClassDistribution.numValues());
+			StringUtils.appendNewline(out);
+		}
+	}
+
+	protected Node treeRoot;
+
+	protected int decisionNodeCount;
+
+	protected int activeLeafNodeCount;
+
+	protected int inactiveLeafNodeCount;
+
+	protected double inactiveLeafByteSizeEstimate;
+
+	protected double activeLeafByteSizeEstimate;
+
+	protected double byteSizeEstimateOverheadFraction;
+
+	protected boolean growthAllowed;
+
+	protected LearningNode newLearningNode(double[] initialClassObservations) {
+		// Create new Learning Node with a null classifier
+		return new MultilabelLearningNodeClassifier(initialClassObservations, null, this);
+	}
+
+	// @Override
+	protected LearningNode newLearningNode(double[] initialClassObservations, Classifier cl) {
+		// Create new Learning Node
+		return new MultilabelLearningNodeClassifier(initialClassObservations, cl, this);
+	}
+
+	protected void deactivateLearningNode(ActiveLearningNode toDeactivate, SplitNode parent, int parentBranch) {
+		// It uses MultilabelInactiveLearningNode since there are several class values
+		Node newLeaf = new MultilabelInactiveLearningNode(toDeactivate.getObservedClassDistribution());
+		if (parent == null) {
+			this.treeRoot = newLeaf;
+		} else {
+			parent.setChild(parentBranch, newLeaf);
+		}
+		this.activeLeafNodeCount--;
+		this.inactiveLeafNodeCount++;
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Example<Instance> example) {
+		return getPredictionForInstance(example.getData());
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+
+		if (this.treeRoot != null) {
+			FoundNode foundNode = this.treeRoot.filterInstanceToLeaf(inst, null, -1);
+			Node leafNode = foundNode.node;
+			MultilabelLearningNodeClassifier multilabelLeafNode = (MultilabelLearningNodeClassifier) leafNode;
+			if (leafNode == null) {
+				leafNode = foundNode.parent;
+			}
+			return multilabelLeafNode.getPrediction(inst, this);
+		} else {
+			System.err.println("[WARNING] Root Node == Null !!!!!!");
+		}
+
+		// Return empty array (this should only happen once! -- before we build the root
+		// node).
+		return null;
+	}
+
+	@Override
+	public void trainOnInstance(Instance inst) {
+		boolean isTraining = (inst.weight() > 0.0);
+		if (isTraining) {
+			this.trainingWeightSeenByModel += inst.weight();
+			trainOnInstanceImpl(inst);
+		}
+	}
+
+	public static List<Integer> getRelevantLabels(Instance x) {
+		List<Integer> classValues = new LinkedList<>();
+		// get all class attributes
+		for (int j = 0; j < x.numOutputAttributes(); j++) {
+			if (x.classValue(j) > 0.0) {
+				classValues.add(j);
+			}
+		}
+		return classValues;
+	}
+
+	protected AttributeClassObserver newNominalClassObserver() {
+		AttributeClassObserver nominalClassObserver = (AttributeClassObserver) getPreparedClassOption(
+				this.nominalEstimatorOption);
+		return (AttributeClassObserver) nominalClassObserver.copy();
+	}
+
+	protected AttributeClassObserver newNumericClassObserver() {
+		AttributeClassObserver numericClassObserver = (AttributeClassObserver) getPreparedClassOption(
+				this.numericEstimatorOption);
+		return (AttributeClassObserver) numericClassObserver.copy();
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	public void estimateModelByteSizes() {
+		FoundNode[] learningNodes = findLearningNodes();
+		long totalActiveSize = 0;
+		long totalInactiveSize = 0;
+		for (FoundNode foundNode : learningNodes) {
+			if (foundNode.node instanceof ActiveLearningNode) {
+				totalActiveSize += SizeOf.fullSizeOf(foundNode.node);
+			} else {
+				totalInactiveSize += SizeOf.fullSizeOf(foundNode.node);
+			}
+		}
+		if (totalActiveSize > 0) {
+			this.activeLeafByteSizeEstimate = (double) totalActiveSize / this.activeLeafNodeCount;
+		}
+		if (totalInactiveSize > 0) {
+			this.inactiveLeafByteSizeEstimate = (double) totalInactiveSize / this.inactiveLeafNodeCount;
+		}
+		long actualModelSize = this.measureByteSize();
+		double estimatedModelSize = (this.activeLeafNodeCount * this.activeLeafByteSizeEstimate
+				+ this.inactiveLeafNodeCount * this.inactiveLeafByteSizeEstimate);
+		this.byteSizeEstimateOverheadFraction = actualModelSize / estimatedModelSize;
+		if (actualModelSize > this.maxByteSizeOption.getValue()) {
+			enforceTrackerLimit();
+		}
+	}
+
+	public void deactivateAllLeaves() {
+		FoundNode[] learningNodes = findLearningNodes();
+		for (int i = 0; i < learningNodes.length; i++) {
+			if (learningNodes[i].node instanceof ActiveLearningNode) {
+				deactivateLearningNode((ActiveLearningNode) learningNodes[i].node, learningNodes[i].parent,
+						learningNodes[i].parentBranch);
+			}
+		}
+	}
+
+	public void enforceTrackerLimit() {
+		if ((this.inactiveLeafNodeCount > 0) || ((this.activeLeafNodeCount * this.activeLeafByteSizeEstimate
+				+ this.inactiveLeafNodeCount * this.inactiveLeafByteSizeEstimate)
+				* this.byteSizeEstimateOverheadFraction > this.maxByteSizeOption.getValue())) {
+			if (this.stopMemManagementOption.isSet()) {
+				this.growthAllowed = false;
+				return;
+			}
+			FoundNode[] learningNodes = findLearningNodes();
+			Arrays.sort(learningNodes, new Comparator<FoundNode>() {
+
+				@Override
+				public int compare(FoundNode fn1, FoundNode fn2) {
+					return Double.compare(fn1.node.calculatePromise(), fn2.node.calculatePromise());
+				}
+			});
+			int maxActive = 0;
+			while (maxActive < learningNodes.length) {
+				maxActive++;
+				if ((maxActive * this.activeLeafByteSizeEstimate
+						+ (learningNodes.length - maxActive) * this.inactiveLeafByteSizeEstimate)
+						* this.byteSizeEstimateOverheadFraction > this.maxByteSizeOption.getValue()) {
+					maxActive--;
+					break;
+				}
+			}
+			int cutoff = learningNodes.length - maxActive;
+			for (int i = 0; i < cutoff; i++) {
+				if (learningNodes[i].node instanceof ActiveLearningNode) {
+					deactivateLearningNode((ActiveLearningNode) learningNodes[i].node, learningNodes[i].parent,
+							learningNodes[i].parentBranch);
+				}
+			}
+			for (int i = cutoff; i < learningNodes.length; i++) {
+				if (learningNodes[i].node instanceof InactiveLearningNode) {
+					activateLearningNode((InactiveLearningNode) learningNodes[i].node, learningNodes[i].parent,
+							learningNodes[i].parentBranch);
+				}
+			}
+		}
+	}
+
+	protected void activateLearningNode(InactiveLearningNode toActivate, SplitNode parent, int parentBranch) {
+		Node newLeaf = newLearningNode(toActivate.getObservedClassDistribution());
+		if (parent == null) {
+			this.treeRoot = newLeaf;
+		} else {
+			parent.setChild(parentBranch, newLeaf);
+		}
+		this.activeLeafNodeCount++;
+		this.inactiveLeafNodeCount--;
+	}
+
+	protected FoundNode[] findLearningNodes() {
+		List<FoundNode> foundList = new LinkedList<>();
+		findLearningNodes(this.treeRoot, null, -1, foundList);
+		return foundList.toArray(new FoundNode[foundList.size()]);
+	}
+
+	protected void findLearningNodes(Node node, SplitNode parent, int parentBranch, List<FoundNode> found) {
+		if (node != null) {
+			if (node instanceof LearningNode) {
+				found.add(new FoundNode(node, parent, parentBranch));
+			}
+			if (node instanceof SplitNode) {
+				SplitNode splitNode = (SplitNode) node;
+				for (int i = 0; i < splitNode.numChildren(); i++) {
+					findLearningNodes(splitNode.getChild(i), splitNode, i, found);
+				}
+			}
+		}
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		if (this.treeRoot == null) {
+			this.treeRoot = newLearningNode();
+			this.activeLeafNodeCount = 1;
+		}
+		FoundNode foundNode = this.treeRoot.filterInstanceToLeaf(inst, null, -1);
+		Node leafNode = foundNode.node;
+		if (leafNode == null) {
+			leafNode = newLearningNode();
+			foundNode.parent.setChild(foundNode.parentBranch, leafNode);
+			this.activeLeafNodeCount++;
+		}
+		if (leafNode instanceof LearningNode) {
+			LearningNode learningNode = (LearningNode) leafNode;
+			learningNode.learnFromInstance(inst, this);
+			if (this.growthAllowed && (learningNode instanceof ActiveLearningNode)) {
+				ActiveLearningNode activeLearningNode = (ActiveLearningNode) learningNode;
+				double weightSeen = activeLearningNode.getWeightSeen();
+				if (weightSeen - activeLearningNode.getWeightSeenAtLastSplitEvaluation() >= this.gracePeriodOption
+						.getValue()) {
+					attemptToSplit(activeLearningNode, foundNode.parent, foundNode.parentBranch);
+					activeLearningNode.setWeightSeenAtLastSplitEvaluation(weightSeen);
+				}
+			}
+		}
+		if (this.trainingWeightSeenByModel % this.memoryEstimatePeriodOption.getValue() == 0) {
+			estimateModelByteSizes();
+		}
+	}
+
+	@Override
+	public void resetLearningImpl() {
+		this.treeRoot = null;
+		this.decisionNodeCount = 0;
+		this.activeLeafNodeCount = 0;
+		this.inactiveLeafNodeCount = 0;
+		this.inactiveLeafByteSizeEstimate = 0.0;
+		this.activeLeafByteSizeEstimate = 0.0;
+		this.byteSizeEstimateOverheadFraction = 1.0;
+		this.growthAllowed = true;
+		if (this.leafpredictionOption.getChosenIndex() > 0) {
+			this.removePoorAttsOption = null;
+		}
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[] {
+				new Measurement("tree size (nodes)",
+						this.decisionNodeCount + this.activeLeafNodeCount + this.inactiveLeafNodeCount),
+				new Measurement("tree size (leaves)", this.activeLeafNodeCount + this.inactiveLeafNodeCount),
+				new Measurement("active learning leaves", this.activeLeafNodeCount),
+				new Measurement("tree depth", measureTreeDepth()),
+				new Measurement("active leaf byte size estimate", this.activeLeafByteSizeEstimate),
+				new Measurement("inactive leaf byte size estimate", this.inactiveLeafByteSizeEstimate),
+				new Measurement("byte size estimate overhead", this.byteSizeEstimateOverheadFraction) };
+	}
+
+	public int measureTreeDepth() {
+		if (this.treeRoot != null) {
+			return this.treeRoot.subtreeDepth();
+		}
+		return 0;
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+		this.treeRoot.describeSubtree(this, out, indent);
+	}
+
+	protected void attemptToSplit(ActiveLearningNode node, SplitNode parent, int parentIndex) {
+		if (!node.observedClassDistributionIsPure()) {
+			SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(this.splitCriterionOption);
+			AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion, this);
+			Arrays.sort(bestSplitSuggestions);
+			boolean shouldSplit = false;
+			if (bestSplitSuggestions.length < 2) {
+				shouldSplit = bestSplitSuggestions.length > 0;
+			} else {
+				double hoeffdingBound = computeHoeffdingBound(
+						splitCriterion.getRangeOfMerit(node.getObservedClassDistribution()),
+						this.splitConfidenceOption.getValue(), node.getWeightSeen());
+				AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+				AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
+				if ((bestSuggestion.merit - secondBestSuggestion.merit > hoeffdingBound)
+						|| (hoeffdingBound < this.tieThresholdOption.getValue())) {
+					shouldSplit = true;
+				}
+				// }
+				if ((this.removePoorAttsOption != null) && this.removePoorAttsOption.isSet()) {
+					Set<Integer> poorAtts = new HashSet<>();
+					// scan 1 - add any poor to set
+					for (int i = 0; i < bestSplitSuggestions.length; i++) {
+						if (bestSplitSuggestions[i].splitTest != null) {
+							int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
+							if (splitAtts.length == 1) {
+								if (bestSuggestion.merit - bestSplitSuggestions[i].merit > hoeffdingBound) {
+									poorAtts.add(new Integer(splitAtts[0]));
+								}
+							}
+						}
+					}
+					// scan 2 - remove good ones from set
+					for (int i = 0; i < bestSplitSuggestions.length; i++) {
+						if (bestSplitSuggestions[i].splitTest != null) {
+							int[] splitAtts = bestSplitSuggestions[i].splitTest.getAttsTestDependsOn();
+							if (splitAtts.length == 1) {
+								if (bestSuggestion.merit - bestSplitSuggestions[i].merit < hoeffdingBound) {
+									poorAtts.remove(new Integer(splitAtts[0]));
+								}
+							}
+						}
+					}
+					for (int poorAtt : poorAtts) {
+						node.disableAttribute(poorAtt);
+					}
+				}
+			}
+			if (shouldSplit) {
+				AttributeSplitSuggestion splitDecision = bestSplitSuggestions[bestSplitSuggestions.length - 1];
+				if (splitDecision.splitTest == null) {
+					// preprune - null wins
+					deactivateLearningNode(node, parent, parentIndex);
+				} else {
+					SplitNode newSplit = newSplitNode(splitDecision.splitTest, node.getObservedClassDistribution(),
+							splitDecision.numSplits());
+					for (int i = 0; i < splitDecision.numSplits(); i++) {
+						Node newChild = newLearningNode(splitDecision.resultingClassDistributionFromSplit(i));
+						newSplit.setChild(i, newChild);
+					}
+					this.activeLeafNodeCount--;
+					this.decisionNodeCount++;
+					this.activeLeafNodeCount += splitDecision.numSplits();
+					if (parent == null) {
+						this.treeRoot = newSplit;
+					} else {
+						parent.setChild(parentIndex, newSplit);
+					}
+				}
+				// manage memory
+				enforceTrackerLimit();
+			}
+		}
+	}
+
+	// Procedure added for Hoeffding Adaptive Trees (ADWIN)
+	protected SplitNode newSplitNode(InstanceConditionalTest splitTest, double[] classObservations, int size) {
+		return new SplitNode(splitTest, classObservations, size);
+	}
+
+	protected LearningNode newLearningNode() {
+		return newLearningNode(new double[0]);
+	}
+
+	public static double computeHoeffdingBound(double range, double confidence, double n) {
+		return Math.sqrt(((range * range) * Math.log(1.0 / confidence)) / (2.0 * n));
+	}
+
+}
diff --git a/moa/src/main/java/moa/classifiers/trees/ORTO.java b/moa/src/main/java/moa/learners/predictors/trees/ORTO.java
similarity index 77%
rename from moa/src/main/java/moa/classifiers/trees/ORTO.java
rename to moa/src/main/java/moa/learners/predictors/trees/ORTO.java
index 296f65874..9257b84e1 100644
--- a/moa/src/main/java/moa/classifiers/trees/ORTO.java
+++ b/moa/src/main/java/moa/learners/predictors/trees/ORTO.java
@@ -14,11 +14,11 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.classifiers.trees;
+package moa.learners.predictors.trees;
 
 import java.util.Arrays;
 import java.util.LinkedList;
@@ -30,15 +30,14 @@
 import com.github.javacliparser.MultiChoiceOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.attributeclassobservers.AttributeClassObserver;
-import moa.classifiers.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
-import moa.classifiers.core.splitcriteria.SplitCriterion;
 import moa.core.AutoExpandVector;
 import moa.core.Measurement;
 import moa.core.StringUtils;
-import moa.learners.Regressor;
-
+import moa.learners.predictors.Regressor;
+import moa.learners.predictors.core.AttributeSplitSuggestion;
+import moa.learners.predictors.core.attributeclassobservers.AttributeClassObserver;
+import moa.learners.predictors.core.attributeclassobservers.FIMTDDNumericAttributeClassObserver;
+import moa.learners.predictors.core.splitcriteria.SplitCriterion;
 
 /*
  * Implementation of ORTO, option trees for data streams.
@@ -53,42 +52,28 @@ public class ORTO extends FIMTDD implements Regressor {
 
 	private int numTrees = 1;
 
+	// region ================ OPTIONS ================
 
-	//region ================ OPTIONS ================
-
-	public IntOption maxTreesOption = new IntOption(
-			"maxTrees",
-			'm',
-			"The maximum number of trees contained in the option tree.",
-			10, 1, Integer.MAX_VALUE);
+	public IntOption maxTreesOption = new IntOption("maxTrees", 'm',
+			"The maximum number of trees contained in the option tree.", 10, 1, Integer.MAX_VALUE);
 
-	public IntOption maxOptionLevelOption = new IntOption(
-			"maxOptionLevel",
-			'x',
-			"The maximal depth at which option nodes can be created.",
-			10, 0, Integer.MAX_VALUE);
+	public IntOption maxOptionLevelOption = new IntOption("maxOptionLevel", 'x',
+			"The maximal depth at which option nodes can be created.", 10, 0, Integer.MAX_VALUE);
 
-	public FloatOption optionDecayFactorOption = new FloatOption(
-			"optionDecayFactor",
-			'z',
-			"The option decay factor that determines how many options can be selected at a given level.",
-			0.9, 0.0, 1.0);
+	public FloatOption optionDecayFactorOption = new FloatOption("optionDecayFactor", 'z',
+			"The option decay factor that determines how many options can be selected at a given level.", 0.9, 0.0,
+			1.0);
 
-	public MultiChoiceOption optionNodeAggregationOption = new MultiChoiceOption(
-			"optionNodeAggregation",
-			'o',
-			"The aggregation method used to combine predictions in option nodes.", 
-			new String[]{"average", "bestTree"}, new String[]{"Average", "Best tree"}, 0);
+	public MultiChoiceOption optionNodeAggregationOption = new MultiChoiceOption("optionNodeAggregation", 'o',
+			"The aggregation method used to combine predictions in option nodes.",
+			new String[] { "average", "bestTree" }, new String[] { "Average", "Best tree" }, 0);
 
-	public FloatOption optionFadingFactorOption = new FloatOption(
-			"optionFadingFactor",
-			'q',
-			"The fading factor used for comparing subtrees of an option node.",
-			0.9995, 0.0, 1.0);
+	public FloatOption optionFadingFactorOption = new FloatOption("optionFadingFactor", 'q',
+			"The fading factor used for comparing subtrees of an option node.", 0.9995, 0.0, 1.0);
 
-	//endregion ================ OPTIONS ================
+	// endregion ================ OPTIONS ================
 
-	//region ================ CLASSES ================
+	// region ================ CLASSES ================
 
 	public static class OptionNode extends InnerNode {
 
@@ -100,17 +85,18 @@ public static class OptionNode extends InnerNode {
 		public OptionNode(FIMTDD tree) {
 			super(tree);
 		}
-		
+
 		public void resetFF() {
 			optionFFSSL = new double[children.size()];
 			optionFFSeen = new double[children.size()];
-			
+
 			for (int i = 0; i < children.size(); i++) {
 				optionFFSSL[i] = 0.0;
 				optionFFSeen[i] = 0.0;
 			}
 		}
 
+		@Override
 		public int getNumSubtrees() {
 			int num = 0;
 			for (Node child : children) {
@@ -132,6 +118,7 @@ public int directionForBestTree() {
 			return d;
 		}
 
+		@Override
 		public double getPrediction(Instance inst) {
 			double[] predictions = new double[numChildren()];
 			for (int i = 0; i < numChildren(); i++) {
@@ -158,11 +145,12 @@ private double aggregate(double[] predictions) {
 		public double getFFRatio(int childIndex) {
 			return optionFFSSL[childIndex] / optionFFSeen[childIndex];
 		}
-		
+
+		@Override
 		protected boolean skipInLevelCount() {
 			return true;
 		}
-		
+
 		@Override
 		public void describeSubtree(StringBuilder out, int indent) {
 			StringUtils.appendIndented(out, indent, "[option node]");
@@ -176,32 +164,35 @@ public void describeSubtree(StringBuilder out, int indent) {
 		}
 	}
 
-	//endregion ================ CLASSES ================
+	// endregion ================ CLASSES ================
 
-	//region ================ METHODS ================
+	// region ================ METHODS ================
 
 	// region --- Regressor methods
 
+	@Override
 	public String getPurposeString() {
 		return "Implementation of the ORTO tree as described by Ikonomovska et al.";
 	}
 
+	@Override
 	public void resetLearningImpl() {
 		super.resetLearningImpl();
 		this.innerNodeCount = 0;
 		this.optionNodeCount = 0;
 	}
 
-	
+	@Override
 	protected Measurement[] getModelMeasurementsImpl() {
-		return new Measurement[]{ 
-				new Measurement("number of subtrees", this.numTrees),
+		return new Measurement[] { new Measurement("number of subtrees", this.numTrees),
 				new Measurement("tree size (nodes)", this.leafNodeCount + this.innerNodeCount),
 				new Measurement("tree size (leaves)", this.leafNodeCount),
-				new Measurement("number of option nodes", this.optionNodeCount),};
+				new Measurement("number of option nodes", this.optionNodeCount), };
 	}
 
-	public void processInstance(Instance inst, Node node, double prediction, double normalError, boolean growthAllowed, boolean inAlternate) {
+	@Override
+	public void processInstance(Instance inst, Node node, double prediction, double normalError, boolean growthAllowed,
+			boolean inAlternate) {
 		if (node instanceof OptionNode) {
 			processInstanceOptionNode(inst, (OptionNode) node, prediction, normalError, growthAllowed, inAlternate);
 		} else {
@@ -218,13 +209,15 @@ public void processInstance(Instance inst, Node node, double prediction, double
 						boolean altTree = true;
 						double lossO = Math.pow(inst.classValue() - prediction, 2);
 						double lossA = Math.pow(inst.classValue() - iNode.alternateTree.getPrediction(inst), 2);
-						
+
 						// Loop for compatibility with bagging methods
 						for (int i = 0; i < inst.weight(); i++) {
-							iNode.lossFadedSumOriginal = lossO + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
-							iNode.lossFadedSumAlternate = lossA + alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
+							iNode.lossFadedSumOriginal = lossO
+									+ alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumOriginal;
+							iNode.lossFadedSumAlternate = lossA
+									+ alternateTreeFadingFactorOption.getValue() * iNode.lossFadedSumAlternate;
 							iNode.lossExamplesSeen++;
-							
+
 							double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
 							iNode.lossSumQi += Qi;
 							iNode.lossNumQiTests += 1;
@@ -232,71 +225,87 @@ public void processInstance(Instance inst, Node node, double prediction, double
 						double Qi = Math.log((iNode.lossFadedSumOriginal) / (iNode.lossFadedSumAlternate));
 						double previousQiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
 						double QiAverage = iNode.lossSumQi / iNode.lossNumQiTests;
-						
+
 						if (iNode.lossExamplesSeen - iNode.previousWeight >= alternateTreeTMinOption.getValue()) {
 							iNode.previousWeight = iNode.lossExamplesSeen;
 							if (Qi > 0) {
 								// Switch the subtrees
 								Node parent = iNode.getParent();
-								
+
 								if (parent != null) {
 									Node replacementTree = iNode.alternateTree;
 									parent.setChild(parent.getChildIndex(iNode), replacementTree);
-									if (growthAllowed) replacementTree.restartChangeDetection();
+									if (growthAllowed)
+										replacementTree.restartChangeDetection();
 								} else {
 									treeRoot = iNode.alternateTree;
 									treeRoot.restartChangeDetection();
 								}
 								optionNodeCount += iNode.alternateTree.getNumSubtrees() - iNode.getNumSubtrees();
 								removeExcessTrees();
-										
+
 								currentNode = iNode.alternateTree;
 								currentNode.originalNode = null;
 								altTree = false;
-							} else if (QiAverage < previousQiAverage && iNode.lossExamplesSeen >= (10 * alternateTreeTMinOption.getValue()) || iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()) {
+							} else if (QiAverage < previousQiAverage
+									&& iNode.lossExamplesSeen >= (10 * alternateTreeTMinOption.getValue())
+									|| iNode.lossExamplesSeen >= alternateTreeTimeOption.getValue()) {
 								// Remove the alternate tree
 								iNode.alternateTree = null;
-								if (growthAllowed) iNode.restartChangeDetection();
+								if (growthAllowed)
+									iNode.restartChangeDetection();
 								altTree = false;
 							}
 						}
 						if (altTree) {
 							growthAllowed = false; // this is the growth of the original tree
-							processInstance(inst, iNode.alternateTree, prediction, normalError, true, true); // growth is allowed in the alt tree
+							processInstance(inst, iNode.alternateTree, prediction, normalError, true, true); // growth
+																												// is
+																												// allowed
+																												// in
+																												// the
+																												// alt
+																												// tree
 						} else if (currentNode instanceof OptionNode) {
 							// this happens when an option node is switched into the tree
 							for (Node child : ((OptionNode) currentNode).children) {
-								processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed, inAlternate);
+								processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed,
+										inAlternate);
 							}
 							break;
 						}
 					}
-				
+
 					if (iNode.changeDetection && !inAlternate) {
-						if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen - PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+						if (iNode.PageHinckleyTest(normalError - iNode.sumOfAbsErrors / iNode.examplesSeen
+								- PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
 							iNode.initializeAlternateTree();
 						}
 					}
 					if (currentNode instanceof SplitNode) {
 						currentNode = ((SplitNode) currentNode).descendOneStep(inst);
 					} else if (currentNode instanceof OptionNode) {
-						processInstanceOptionNode(inst, (OptionNode) currentNode, prediction, normalError, growthAllowed, inAlternate);
+						processInstanceOptionNode(inst, (OptionNode) currentNode, prediction, normalError,
+								growthAllowed, inAlternate);
 						break;
 					}
 				}
 			}
 		}
-		
+
 	}
-	
-	public void processInstanceOptionNode(Instance inst, OptionNode node, double prediction, double normalError, boolean growthAllowed, boolean inAlternate) {
+
+	public void processInstanceOptionNode(Instance inst, OptionNode node, double prediction, double normalError,
+			boolean growthAllowed, boolean inAlternate) {
 		node.examplesSeen += inst.weight();
 		node.sumOfAbsErrors += inst.weight() * normalError;
 		if (node.changeDetection) {
 			double error = Math.abs(prediction - inst.classValue());
 			node.sumOfAbsErrors += error;
-			
-			if (((InnerNode) node).PageHinckleyTest(error - node.sumOfAbsErrors / node.examplesSeen + PageHinckleyAlphaOption.getValue(), PageHinckleyThresholdOption.getValue())) {
+
+			if (((InnerNode) node).PageHinckleyTest(
+					error - node.sumOfAbsErrors / node.examplesSeen + PageHinckleyAlphaOption.getValue(),
+					PageHinckleyThresholdOption.getValue())) {
 				node.initializeAlternateTree();
 				growthAllowed = false;
 			}
@@ -309,35 +318,38 @@ public void processInstanceOptionNode(Instance inst, OptionNode node, double pre
 			// Loop for compatibility with bagging methods
 			for (int i = 0; i < inst.weight(); i++) {
 				node.optionFFSeen[index] = node.optionFFSeen[index] * optionFadingFactorOption.getValue() + 1;
-				node.optionFFSSL[index] = node.optionFFSSL[index] * optionFadingFactorOption.getValue() + Math.pow(childPrediction - inst.classValue(), 2);
+				node.optionFFSSL[index] = node.optionFFSSL[index] * optionFadingFactorOption.getValue()
+						+ Math.pow(childPrediction - inst.classValue(), 2);
 			}
 		}
 
 		for (Node child : node.children) {
-			processInstance(inst, child, child.getPrediction(inst), normalError, growthAllowed && node.alternateTree == null, inAlternate);
+			processInstance(inst, child, child.getPrediction(inst), normalError,
+					growthAllowed && node.alternateTree == null, inAlternate);
 		}
 	}
-	
+
 	// endregion --- Regressor methods
-	
+
 	// region --- Object instantiation methods
 
 	protected OptionNode newOptionNode() {
 		maxID++;
 		return new OptionNode(this);
 	}
-	
+
 	// endregion --- Object instantiation methods
 
 	// region --- Processing methods
 
+	@Override
 	protected void attemptToSplit(LeafNode node, Node parent, int parentIndex, Instance inst, double prediction) {
-		// Initialize the split criterion 
+		// Initialize the split criterion
 		SplitCriterion splitCriterion = (SplitCriterion) getPreparedClassOption(splitCriterionOption);
 
 		// Using this criterion, find the best split per attribute and rank the results
 		AttributeSplitSuggestion[] bestSplitSuggestions = node.getBestSplitSuggestions(splitCriterion);
-		List<AttributeSplitSuggestion> acceptedSplits = new LinkedList<AttributeSplitSuggestion>();
+		List<AttributeSplitSuggestion> acceptedSplits = new LinkedList<>();
 		Arrays.sort(bestSplitSuggestions);
 
 		// Declare a variable to determine the number of splits to be performed
@@ -347,24 +359,32 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex, Insta
 		if (bestSplitSuggestions.length == 1) {
 			numSplits = 1;
 			acceptedSplits.add(bestSplitSuggestions[0]);
-		} else if (bestSplitSuggestions.length > 1) { // Otherwise, consider which of the splits proposed may be worth trying
+		} else if (bestSplitSuggestions.length > 1) { // Otherwise, consider which of the splits proposed may be worth
+														// trying
 
-			// Determine the Hoeffding bound value, used to select how many instances should be used to make a test decision
-			// to feel reasonably confident that the test chosen by this sample is the same as what would be chosen using infinite examples
+			// Determine the Hoeffding bound value, used to select how many instances should
+			// be used to make a test decision
+			// to feel reasonably confident that the test chosen by this sample is the same
+			// as what would be chosen using infinite examples
 			double hoeffdingBound = computeHoeffdingBound(1, splitConfidenceOption.getValue(), node.examplesSeen);
 
 			// Determine the top two ranked splitting suggestions
 			AttributeSplitSuggestion bestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 1];
 			AttributeSplitSuggestion secondBestSuggestion = bestSplitSuggestions[bestSplitSuggestions.length - 2];
 
-
-			// If the upper bound of the sample mean for the ratio of SDR(best suggestion) to SDR(second best suggestion),
-			// as determined using the Hoeffding bound, is less than 1, then the true mean is also less than 1, and thus at this
-			// particular moment of observation the bestSuggestion is indeed the best split option with confidence 1-delta, and
+			// If the upper bound of the sample mean for the ratio of SDR(best suggestion)
+			// to SDR(second best suggestion),
+			// as determined using the Hoeffding bound, is less than 1, then the true mean
+			// is also less than 1, and thus at this
+			// particular moment of observation the bestSuggestion is indeed the best split
+			// option with confidence 1-delta, and
 			// splitting should occur.
-			// Alternatively, if two or more splits are very similar or identical in terms of their splits, then a threshold limit
-			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is smaller than this limit then the two
-			// competing attributes are equally good, and the split will be made on the one with the higher SDR value.
+			// Alternatively, if two or more splits are very similar or identical in terms
+			// of their splits, then a threshold limit
+			// (default 0.05) is applied to the Hoeffding bound; if the Hoeffding bound is
+			// smaller than this limit then the two
+			// competing attributes are equally good, and the split will be made on the one
+			// with the higher SDR value.
 			if (secondBestSuggestion.merit / bestSuggestion.merit < 1 - hoeffdingBound) {
 				numSplits = 1;
 				acceptedSplits.add(bestSuggestion);
@@ -381,20 +401,24 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex, Insta
 			} else if (hoeffdingBound < tieThresholdOption.getValue()) {
 				numSplits = 1;
 				acceptedSplits.add(bestSuggestion);
-			} else { // If the splitting criterion was not met, initiate pruning of the E-BST structures in each attribute observer
+			} else { // If the splitting criterion was not met, initiate pruning of the E-BST
+						// structures in each attribute observer
 				for (int i = 0; i < node.attributeObservers.size(); i++) {
 					AttributeClassObserver obs = node.attributeObservers.get(i);
 					if (obs != null) {
-						((FIMTDDNumericAttributeClassObserver) obs).removeBadSplits(splitCriterion, secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit, hoeffdingBound);    
+						((FIMTDDNumericAttributeClassObserver) obs).removeBadSplits(splitCriterion,
+								secondBestSuggestion.merit / bestSuggestion.merit, bestSuggestion.merit,
+								hoeffdingBound);
 					}
 				}
 			}
 		}
 
-		// If the splitting criterion was met, split the current node using the chosen attribute test, and
+		// If the splitting criterion was met, split the current node using the chosen
+		// attribute test, and
 		// make two new branches leading to (empty) leaves
 		if (numSplits > 0) {
-			double optionFactor = numSplits * Math.pow(optionDecayFactorOption.getValue(), (double) node.getLevel());
+			double optionFactor = numSplits * Math.pow(optionDecayFactorOption.getValue(), node.getLevel());
 
 			if (numSplits == 1 || optionFactor < 2.0 || maxTreesOption.getValue() - numTrees <= 1) {
 				AttributeSplitSuggestion splitDecision = acceptedSplits.get(0);
@@ -455,11 +479,11 @@ protected void attemptToSplit(LeafNode node, Node parent, int parentIndex, Insta
 		}
 	}
 
-	// endregion --- Processing methods 
-	
+	// endregion --- Processing methods
+
 	// region --- Option tree methods
 	protected Node findWorstOption() {
-		Stack<Node> stack = new Stack<Node>();
+		Stack<Node> stack = new Stack<>();
 		stack.add(treeRoot);
 
 		double ratio = Double.MIN_VALUE;
@@ -470,7 +494,7 @@ protected Node findWorstOption() {
 			if (node.getParent() instanceof OptionNode) {
 				OptionNode myParent = (OptionNode) node.getParent();
 				int nodeIndex = myParent.getChildIndex(node);
-				double nodeRatio = myParent.getFFRatio(nodeIndex); 
+				double nodeRatio = myParent.getFFRatio(nodeIndex);
 
 				if (nodeRatio > ratio) {
 					ratio = nodeRatio;
@@ -500,7 +524,7 @@ protected void removeExcessTrees() {
 					parent.parent.setChild(parent.parent.getChildIndex(parent), chld);
 				}
 			} else {
-				AutoExpandVector<Node> children = new AutoExpandVector<Node>();
+				AutoExpandVector<Node> children = new AutoExpandVector<>();
 				double[] optionFFSSL = new double[parent.children.size() - 1];
 				double[] optionFFSeen = new double[parent.children.size() - 1];
 
@@ -525,8 +549,8 @@ protected void removeExcessTrees() {
 			numTrees--;
 		}
 	}
-	
+
 	// endregion --- Option tree methods
-	
-	//endregion ================ METHODS ================
+
+	// endregion ================ METHODS ================
 }
diff --git a/moa/src/main/java/moa/learners/predictors/trees/RandomHoeffdingTree.java b/moa/src/main/java/moa/learners/predictors/trees/RandomHoeffdingTree.java
new file mode 100644
index 000000000..e51ddd593
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/trees/RandomHoeffdingTree.java
@@ -0,0 +1,168 @@
+/*
+ *    RandomHoeffdingTree.java
+ *    Copyright (C) 2010 University of Waikato, Hamilton, New Zealand
+ *    @author Albert Bifet (abifet@cs.waikato.ac.nz)
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package moa.learners.predictors.trees;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.core.Utils;
+import moa.learners.predictors.bayes.NaiveBayes;
+import moa.learners.predictors.core.attributeclassobservers.AttributeClassObserver;
+
+/**
+ * Random decision trees for data streams.
+ *
+ * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
+ * @version $Revision: 7 $
+ */
+public class RandomHoeffdingTree extends HoeffdingTree {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public String getPurposeString() {
+		return "Random decision trees for data streams.";
+	}
+
+	public static class RandomLearningNode extends ActiveLearningNode {
+
+		private static final long serialVersionUID = 1L;
+
+		protected int[] listAttributes;
+
+		protected int numAttributes;
+
+		public RandomLearningNode(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, HoeffdingTree ht) {
+			this.observedClassDistribution.addToValue((int) inst.classValue(), inst.weight());
+			if (this.listAttributes == null) {
+				this.numAttributes = (int) Math.floor(Math.sqrt(inst.numAttributes()));
+				this.listAttributes = new int[this.numAttributes];
+				for (int j = 0; j < this.numAttributes; j++) {
+					boolean isUnique = false;
+					while (isUnique == false) {
+						this.listAttributes[j] = ht.classifierRandom.nextInt(inst.numAttributes() - 1);
+						isUnique = true;
+						for (int i = 0; i < j; i++) {
+							if (this.listAttributes[j] == this.listAttributes[i]) {
+								isUnique = false;
+								break;
+							}
+						}
+					}
+
+				}
+			}
+			for (int j = 0; j < this.numAttributes - 1; j++) {
+				int i = this.listAttributes[j];
+				int instAttIndex = modelAttIndexToInstanceAttIndex(i, inst);
+				AttributeClassObserver obs = this.attributeObservers.get(i);
+				if (obs == null) {
+					obs = inst.attribute(instAttIndex).isNominal() ? ht.newNominalClassObserver()
+							: ht.newNumericClassObserver();
+					this.attributeObservers.set(i, obs);
+				}
+				obs.observeAttributeClass(inst.value(instAttIndex), (int) inst.classValue(), inst.weight());
+			}
+		}
+	}
+
+	public static class LearningNodeNB extends RandomLearningNode {
+
+		private static final long serialVersionUID = 1L;
+
+		public LearningNodeNB(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		@Override
+		public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
+			if (getWeightSeen() >= ht.nbThresholdOption.getValue()) {
+				return NaiveBayes.doNaiveBayesPrediction(inst, this.observedClassDistribution, this.attributeObservers);
+			}
+			return super.getClassVotes(inst, ht);
+		}
+
+		@Override
+		public void disableAttribute(int attIndex) {
+			// should not disable poor atts - they are used in NB calc
+		}
+	}
+
+	public static class LearningNodeNBAdaptive extends LearningNodeNB {
+
+		private static final long serialVersionUID = 1L;
+
+		protected double mcCorrectWeight = 0.0;
+
+		protected double nbCorrectWeight = 0.0;
+
+		public LearningNodeNBAdaptive(double[] initialClassObservations) {
+			super(initialClassObservations);
+		}
+
+		@Override
+		public void learnFromInstance(Instance inst, HoeffdingTree ht) {
+			int trueClass = (int) inst.classValue();
+			if (this.observedClassDistribution.maxIndex() == trueClass) {
+				this.mcCorrectWeight += inst.weight();
+			}
+			if (Utils.maxIndex(NaiveBayes.doNaiveBayesPrediction(inst, this.observedClassDistribution,
+					this.attributeObservers)) == trueClass) {
+				this.nbCorrectWeight += inst.weight();
+			}
+			super.learnFromInstance(inst, ht);
+		}
+
+		@Override
+		public double[] getClassVotes(Instance inst, HoeffdingTree ht) {
+			if (this.mcCorrectWeight > this.nbCorrectWeight) {
+				return this.observedClassDistribution.getArrayCopy();
+			}
+			return NaiveBayes.doNaiveBayesPrediction(inst, this.observedClassDistribution, this.attributeObservers);
+		}
+	}
+
+	public RandomHoeffdingTree() {
+		this.removePoorAttsOption = null;
+	}
+
+	@Override
+	protected LearningNode newLearningNode(double[] initialClassObservations) {
+		LearningNode ret;
+		int predictionOption = this.leafpredictionOption.getChosenIndex();
+		if (predictionOption == 0) { // MC
+			ret = new RandomLearningNode(initialClassObservations);
+		} else if (predictionOption == 1) { // NB
+			ret = new LearningNodeNB(initialClassObservations);
+		} else { // NBAdaptive
+			ret = new LearningNodeNBAdaptive(initialClassObservations);
+		}
+		return ret;
+	}
+
+	@Override
+	public boolean isRandomizable() {
+		return true;
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/trees/iadem/Iadem2.java b/moa/src/main/java/moa/learners/predictors/trees/iadem/Iadem2.java
new file mode 100644
index 000000000..155a4fd79
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/trees/iadem/Iadem2.java
@@ -0,0 +1,1900 @@
+/*
+ *    IADEM2cTree.java
+ *
+ *    @author José del Campo-Ávila
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.predictors.trees.iadem;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.github.javacliparser.MultiChoiceOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.ClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.core.Utils;
+import moa.learners.predictors.AbstractClassifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.core.conditionaltests.InstanceConditionalTest;
+import moa.learners.predictors.core.conditionaltests.NominalAttributeBinaryTest;
+import moa.learners.predictors.core.driftdetection.AbstractChangeDetector;
+import moa.options.ClassOption;
+
+public class Iadem2 extends AbstractClassifier implements Classifier {
+
+	private static final long serialVersionUID = 1L;
+	public ClassOption numericEstimatorOption = new ClassOption("numericEstimator", 'z', "Numeric estimator to use.",
+			IademNumericAttributeObserver.class, "IademGaussianNumericAttributeClassObserver");
+	public IntOption gracePeriodOption = new IntOption("gracePeriod", 'n',
+			"The number of instances the tree should observe between splitting attempts.", 100, 1, Integer.MAX_VALUE);
+	public MultiChoiceOption splitCriterionOption = new MultiChoiceOption("splitCriterion", 's',
+			"Split criterion to use.",
+			new String[] { "entropy", "entropy_logVar", "entropy_logVar+Peso", "entropy_Peso", "beta1", "gamma1",
+					"beta2", "gamma2", "beta4", "gamma4" },
+			new String[] { "entropy", "entropy_logVar", "entropy_logVar+Peso", "entropy_Peso", "beta1", "gamma1",
+					"beta2", "gamma2", "beta4", "gamma4" },
+			0);
+	public FloatOption splitConfidenceOption = new FloatOption("splitConfidence", 'c',
+			"The allowable error in split decision, values closer to 0 will take longer to decide.", 0.01, 0.0, 1.0);
+	public MultiChoiceOption splitTestsOption = new MultiChoiceOption("splitChoice", 'i',
+			"Methods for splitting leaf nodes.", new String[] { "onlyBinarySplit", "onlyMultiwaySplit", "bestSplit" },
+			new String[] { "onlyBinary", "onlyMultiway", "bestSplit" }, 2);
+
+	public MultiChoiceOption leafPredictionOption = new MultiChoiceOption("leafPrediction", 'b',
+			"Leaf prediction to use.", new String[] { "MC", "NB", "NBKirkby", "WeightedVote" },
+			new String[] { "MC: Majority class.", "NB: Naïve Bayes.", "NBKirkby.",
+					"WeightedVote: Weighted vote between NB and MC." },
+			1);
+	public ClassOption driftDetectionMethodOption = new ClassOption("driftDetectionMethod", 'd',
+			"Drift detection method to use.", AbstractChangeDetector.class, "HDDM_A_Test");
+
+	// fixed option...
+	public FloatOption attributeDiferentiation = new FloatOption("attritubeDiferentiation", 'a',
+			"Attribute differenciation", 0.1, 0.0, 1.0);
+
+	public final int naiveBayesLimit = 0;
+	public final double percentInCommon = 0.75;
+	protected int numberOfInstancesProcessed = 0;
+
+	@Override
+	public boolean isRandomizable() {
+		return false;
+	}
+
+	@Override
+	public void resetLearningImpl() {
+		this.numberOfInstancesProcessed = 0;
+		this.treeRoot = null;
+	}
+
+	@Override
+	public void trainOnInstanceImpl(Instance inst) {
+		if (this.treeRoot == null) {
+			IademCommonProcedures.setConfidence(this.splitConfidenceOption.getValue());
+			this.estimator = (AbstractChangeDetector) ((AbstractChangeDetector) getPreparedClassOption(
+					this.driftDetectionMethodOption)).copy();
+			createRoot(inst);
+		}
+		try {
+			learnFromInstance(inst);
+		} catch (IademException ex) {
+			Logger.getLogger(Iadem2.class.getName()).log(Level.SEVERE, null, ex);
+		}
+	}
+
+	protected IademNumericAttributeObserver newNumericClassObserver() {
+		IademNumericAttributeObserver numericClassObserver = (IademNumericAttributeObserver) getPreparedClassOption(
+				this.numericEstimatorOption);
+		return (IademNumericAttributeObserver) numericClassObserver.copy();
+	}
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[] { new Measurement("tree size (nodes)", this.getNumberOfNodes()),
+				new Measurement("tree size (leaves)", this.getNumberOfLeaves()) };
+	}
+
+	@Override
+	public void getModelDescription(StringBuilder out, int indent) {
+	}
+
+	@Override
+	public Prediction getPredictionForInstance(Instance inst) {
+		if (this.treeRoot == null) {
+			DoubleVector classVotes = new DoubleVector();
+			double estimation = 1.0 / inst.classAttribute().numValues();
+			for (int i = 0; i < inst.classAttribute().numValues(); i++) {
+				classVotes.addToValue(i, estimation);
+			}
+			return new ClassificationPrediction(classVotes.getArrayCopy());
+
+		}
+		DoubleVector predicciones = new DoubleVector(this.treeRoot.getClassVotes(inst));
+		return new ClassificationPrediction(predicciones.getArrayCopy());
+
+	}
+
+	final public static double ERROR_MARGIN = 1.0e-9;
+	protected Node treeRoot;
+
+	protected AbstractChangeDetector estimator;
+
+	public int numberOfNodes = 1, numberOfLeaves = 1;
+
+	public AbstractChangeDetector newEstimator() {
+		return (AbstractChangeDetector) this.estimator.copy();
+	}
+
+	public void createRoot(Instance instance) {
+		double[] arrayCounter = new double[instance.numClasses()];
+		Arrays.fill(arrayCounter, 0);
+
+		this.treeRoot = newLeafNode(null, 0, 0, arrayCounter, instance);
+	}
+
+	public int getMaxNumberOfBins() {
+		return (int) this.newNumericClassObserver().getMaxOfValues();
+	}
+
+	public IademNumericAttributeObserver getNumericAttObserver() {
+		return newNumericClassObserver();
+	}
+
+	public long getNumberOfInstancesProcessed() {
+		return numberOfInstancesProcessed;
+	}
+
+	public LeafNode newLeafNode(Node parent, long instTreeCountSinceVirtual, long instNodeCountSinceVirtual,
+			double[] classDist, Instance instance) {
+		switch (this.leafPredictionOption.getChosenIndex()) {
+		case 0: {
+			return new LeafNode(this, parent, instTreeCountSinceVirtual, instNodeCountSinceVirtual, classDist,
+					newNumericClassObserver(), this.splitTestsOption.getChosenIndex() == 2,
+					this.splitTestsOption.getChosenIndex() == 0, instance);
+		}
+		case 1: {
+			return new LeafNodeNB(this, parent, instTreeCountSinceVirtual, instNodeCountSinceVirtual, classDist,
+					newNumericClassObserver(), this.naiveBayesLimit, this.splitTestsOption.getChosenIndex() == 2,
+					this.splitTestsOption.getChosenIndex() == 0, instance);
+		}
+		case 2: {
+			return new LeafNodeNBKirkby(this, parent, instTreeCountSinceVirtual, instNodeCountSinceVirtual, classDist,
+					newNumericClassObserver(), this.naiveBayesLimit, this.splitTestsOption.getChosenIndex() == 2,
+					this.splitTestsOption.getChosenIndex() == 0,
+					(AbstractChangeDetector) ((AbstractChangeDetector) getPreparedClassOption(
+							this.driftDetectionMethodOption)).copy(),
+					instance);
+		}
+		default: {
+			return new LeafNodeWeightedVote(this, parent, instTreeCountSinceVirtual, instNodeCountSinceVirtual,
+					classDist, newNumericClassObserver(), this.naiveBayesLimit,
+					this.splitTestsOption.getChosenIndex() == 2, this.splitTestsOption.getChosenIndex() == 0,
+					(AbstractChangeDetector) ((AbstractChangeDetector) getPreparedClassOption(
+							this.driftDetectionMethodOption)).copy(),
+					instance);
+		}
+		}
+	}
+
+	public double getAttributeDifferentiation() {
+		return this.attributeDiferentiation.getValue();
+	}
+
+	public IademSplitCriterion getMeasure() throws IademException {
+		return new IademSplitCriterion(this.splitCriterionOption.getChosenLabel());
+	}
+
+	public void setTreeRoot(Node newRoot) {
+		this.treeRoot = newRoot;
+	}
+
+	public void learnFromInstance(Instance instance) throws IademException {
+		this.numberOfInstancesProcessed++;
+		this.treeRoot.learnFromInstance(instance);
+	}
+
+	public Node getTreeRoot() {
+		return this.treeRoot;
+	}
+
+	public double[] getClassVotes(Instance instance) {
+		return this.treeRoot.getClassVotes(instance);
+	}
+
+	public double getPercentInCommon() {
+		return this.percentInCommon;
+	}
+
+	public int getValuesOfNominalAttributes(int attIndex, Instance instance) {
+		return instance.attribute(attIndex).numValues();
+	}
+
+	public int getNaiveBayesLimit() {
+		return this.naiveBayesLimit;
+	}
+
+	public boolean isOnlyMultiwayTest() {
+		return this.splitTestsOption.getChosenIndex() == 2;
+	}
+
+	public boolean isOnlyBinaryTest() {
+		return this.splitTestsOption.getChosenIndex() == 0;
+	}
+
+	public void incrNumberOfInstancesProcessed() {
+		this.numberOfInstancesProcessed++;
+	}
+
+	public void getNumberOfNodes(int[] count) {
+		this.treeRoot.getNumberOfNodes(count);
+	}
+
+	public void newSplit(int numOfLeaves) {
+		this.numberOfLeaves += numOfLeaves - 1;
+		this.numberOfNodes += numOfLeaves;
+	}
+
+	public int getNumberOfNodes() {
+		return numberOfNodes;
+	}
+
+	public void setNumberOfNodes(int numberOfNodes) {
+		this.numberOfNodes = numberOfNodes;
+	}
+
+	public int getNumberOfLeaves() {
+		return numberOfLeaves;
+	}
+
+	public void setNumberOfLeaves(int numberOfLeaves) {
+		this.numberOfLeaves = numberOfLeaves;
+	}
+
+	public abstract class Node implements Serializable {
+
+		private static final long serialVersionUID = 1L;
+
+		protected Iadem2 tree;
+
+		protected DoubleVector classValueDist;
+
+		public Node parent;
+
+		public DoubleVector getClassValueDist() {
+			return classValueDist;
+		}
+
+		public void setClassValueDist(DoubleVector classValueDist) {
+			this.classValueDist = classValueDist;
+		}
+
+		public Iadem2 getTree() {
+			return tree;
+		}
+
+		public void setTree(Iadem2 tree) {
+			this.tree = tree;
+		}
+
+		public Node(Iadem2 tree, Node parent, double[] initialClassCount) {
+			this.tree = tree;
+			this.parent = parent;
+			this.classValueDist = new DoubleVector(initialClassCount);
+		}
+
+		public abstract int getSubtreeNodeCount();
+
+		public void setParent(Node parent) {
+			this.parent = parent;
+		}
+
+		public Node getParent() {
+			return parent;
+		}
+
+		public abstract Node learnFromInstance(Instance instance);
+
+		public abstract ArrayList<LeafNode> getLeaves();
+
+		public abstract double[] getClassVotes(Instance instance);
+
+		public int getChildCount() {
+			return 0;
+		}
+
+		public abstract void getNumberOfNodes(int[] count);
+	}
+
+	public class LeafNode extends Node {
+
+		private static final long serialVersionUID = 1L;
+		protected long instNodeCountSinceVirtual;
+		protected long instTreeCountSinceReal;
+		protected long instNodeCountSinceReal;
+		protected AutoExpandVector<VirtualNode> virtualChildren = new AutoExpandVector<>();
+		protected boolean allAttUsed;
+
+		protected double instSeenSinceLastSplitAttempt = 0;
+
+		protected boolean split;
+
+		public LeafNode(Iadem2 tree, Node parent, long instTreeCountSinceVirtual, long instNodeCountSinceVirtual,
+				double[] initialClassCount, IademNumericAttributeObserver numericAttClassObserver,
+				boolean onlyMultiwayTest, boolean onlyBinaryTest, Instance instance) {
+			super(tree, parent, initialClassCount);
+			this.instNodeCountSinceVirtual = instNodeCountSinceVirtual;
+			this.instTreeCountSinceReal = 0;
+			this.instNodeCountSinceReal = 0;
+			this.split = true;
+			createVirtualNodes(numericAttClassObserver, onlyMultiwayTest, onlyBinaryTest, instance);
+		}
+
+		public double getInstSeenSinceLastSplitAttempt() {
+			return instSeenSinceLastSplitAttempt;
+		}
+
+		public void setInstSeenSinceLastSplitAttempt(double instSeenSinceLastSplitAttempt) {
+			this.instSeenSinceLastSplitAttempt = instSeenSinceLastSplitAttempt;
+		}
+
+		public AutoExpandVector<VirtualNode> getVirtualChildren() {
+			return this.virtualChildren;
+		}
+
+		public void setVirtualChildren(AutoExpandVector<VirtualNode> virtualChildren) {
+			this.virtualChildren = virtualChildren;
+		}
+
+		protected void createVirtualNodes(IademNumericAttributeObserver numericObserver, boolean onlyMultiwayTest,
+				boolean onlyBinaryTest, Instance instance) {
+			for (int i = 0; i < instance.numAttributes(); i++) {
+				if (instance.classIndex() != i && instance.attribute(i).isNominal()) {
+					this.virtualChildren.set(i,
+							new NominalVirtualNode(this.tree, this, i, onlyMultiwayTest, onlyBinaryTest));
+				} else if (instance.classIndex() != i && instance.attribute(i).isNumeric()) {
+					this.virtualChildren.set(i, new NumericVirtualNode(this.tree, this, i, numericObserver));
+
+				} else { // class attribute
+					this.virtualChildren.set(i, null);
+				}
+			}
+
+		}
+
+		protected ArrayList<Integer> nominalAttUsed(Instance instance) {
+			SplitNode currentNode = (SplitNode) this.parent;
+			ArrayList<Integer> nomAttUsed = new ArrayList<>();
+			while (currentNode != null) {
+				if (instance.attribute(currentNode.splitTest.getAttsTestDependsOn()[0]).isNominal()) {
+					nomAttUsed.add(currentNode.splitTest.getAttsTestDependsOn()[0]);
+				}
+				currentNode = (SplitNode) currentNode.parent;
+			}
+			return nomAttUsed;
+		}
+
+		@Override
+		public Iadem2 getTree() {
+			return this.tree;
+		}
+
+		@Override
+		public int getSubtreeNodeCount() {
+			return 1;
+		}
+
+		@Override
+		public ArrayList<LeafNode> getLeaves() {
+			ArrayList<LeafNode> leaf = new ArrayList<>();
+			leaf.add(this);
+			return leaf;
+		}
+
+		public boolean isAllAttUsed() {
+			return allAttUsed;
+		}
+
+		public void attemptToSplit(Instance instance) {
+			if (this.classValueDist.numNonZeroEntries() > 1) {
+				if (hasInformationToSplit()) {
+					try {
+						this.instSeenSinceLastSplitAttempt = 0;
+						IademAttributeSplitSuggestion bestSplitSuggestion;
+
+						bestSplitSuggestion = getBestSplitSuggestion(instance);
+						if (bestSplitSuggestion != null) {
+							doSplit(bestSplitSuggestion, instance);
+						}
+					} catch (IademException ex) {
+						Logger.getLogger(LeafNode.class.getName()).log(Level.SEVERE, null, ex);
+					}
+				}
+			}
+		}
+
+		@Override
+		public Node learnFromInstance(Instance inst) {
+			this.instNodeCountSinceVirtual += inst.weight();
+			this.classValueDist.addToValue((int) inst.value(inst.classIndex()), inst.weight());
+			this.instNodeCountSinceReal += inst.weight();
+			this.instSeenSinceLastSplitAttempt += inst.weight();
+			for (int i = 0; i < inst.numAttributes() - 1; i++) {
+				VirtualNode virtual = this.virtualChildren.get(i);
+				if (virtual != null) {
+					virtual.learnFromInstance(inst);
+				}
+			}
+			if (this.split) {
+				attemptToSplit(inst);
+			}
+			return this;
+		}
+
+		protected IademAttributeSplitSuggestion getFastSplitSuggestion(Instance instance) throws IademException {
+			int bestAttIndex = -1;
+			double bestAttValue = Double.MAX_VALUE;
+			for (int i = 0; i < virtualChildren.size(); i++) {
+				VirtualNode currentVirtualChild = virtualChildren.get(i);
+				if (currentVirtualChild != null) {
+					try {
+						currentVirtualChild.updateHeuristicMeasure(instance);
+					} catch (IademException e) {
+						throw new IademException("LeafNode", "getFastSplitSuggestion",
+								"Problems when updating measures: \n" + e.getMessage());
+					}
+					if (currentVirtualChild.getHeuristicMeasureUpper(instance) >= 0) {
+						if (currentVirtualChild.getHeuristicMeasureUpper(instance) < bestAttValue) {
+							bestAttIndex = i;
+							bestAttValue = currentVirtualChild.getHeuristicMeasureUpper(instance);
+						}
+					}
+				}
+			}
+			if (bestAttIndex != -1) {
+				return virtualChildren.get(bestAttIndex).getBestSplitSuggestion();
+			} else {
+				return null;
+			}
+		}
+
+		public IademAttributeSplitSuggestion getBestSplitSuggestion(Instance instance) throws IademException {
+			return getBestSplitSuggestionIADEM(instance);
+		}
+
+		public LeafNode[] doSplit(IademAttributeSplitSuggestion bestSuggestion, Instance instance) {
+			SplitNode splitNode = virtualChildren.get(bestSuggestion.splitTest.getAttsTestDependsOn()[0])
+					.getNewSplitNode(this.instTreeCountSinceReal, this.parent, bestSuggestion, instance);
+			splitNode.setParent(this.parent);
+
+			if (this.parent == null) {
+				this.tree.setTreeRoot(splitNode);
+			} else {
+				((SplitNode) this.parent).changeChildren(this, splitNode);
+			}
+
+			this.tree.newSplit(splitNode.getLeaves().size());
+			return null;
+		}
+
+		@Override
+		public double[] getClassVotes(Instance obs) {
+			return getMajorityClassVotes(obs);
+		}
+
+		public double[] getMajorityClassVotes(Instance instance) {
+			double[] votes = new double[instance.attribute(instance.classIndex()).numValues()];
+			Arrays.fill(votes, 0.0);
+			if (instNodeCountSinceVirtual == 0) {
+				if (parent != null) {
+					ArrayList<LeafNode> siblings = parent.getLeaves();
+					siblings.remove(this);
+					ArrayList<LeafNode> siblingWithInfo = new ArrayList<>();
+					long count = 0;
+					for (LeafNode currentSibling : siblings) {
+						if (currentSibling.getInstNodeCountSinceVirtual() > 0) {
+							siblingWithInfo.add(currentSibling);
+							count += currentSibling.getInstNodeCountSinceVirtual();
+						}
+					}
+					if (count > 0) {
+						for (LeafNode currentSibling : siblingWithInfo) {
+							double[] sibVotes = currentSibling.getMajorityClassVotes(instance);
+							double weight = (double) currentSibling.getInstNodeCountSinceVirtual() / (double) count;
+							for (int i = 0; i < votes.length; i++) {
+								votes[i] += weight * sibVotes[i];
+							}
+						}
+					}
+				}
+			} else {
+				for (int i = 0; i < votes.length; i++) {
+					votes[i] = classValueDist.getValue(i) / instNodeCountSinceVirtual;
+				}
+			}
+			// normalize votes
+			double voteCount = 0.0;
+			for (int i = 0; i < votes.length; i++) {
+				voteCount += votes[i];
+			}
+			if (voteCount == 0.0) {
+				for (int i = 0; i < votes.length; i++) {
+					votes[i] = 1.0 / votes.length;
+				}
+			} else {
+				for (int i = 0; i < votes.length; i++) {
+					votes[i] /= voteCount;
+				}
+			}
+			return votes;
+		}
+
+		public long getInstNodeCountSinceVirtual() {
+			return instNodeCountSinceVirtual;
+		}
+
+		private double percentInCommon(double A_upper, double A_lower, double B_upper, double B_lower) {
+			double percent;
+
+			// nothing in common
+			if ((A_lower >= B_upper) || (A_upper <= B_lower)) {
+				percent = 0.0;
+			} else { // something in common
+				double A_out = 0.0;
+				double A_margin = A_upper - A_lower;
+
+				if ((A_upper <= B_upper) && (A_lower >= B_lower)) {
+					A_out = 0.0;
+				} else if ((A_upper > B_upper) && (A_lower >= B_lower)) {
+					A_out = A_upper - B_upper;
+				} else if ((A_upper > B_upper) && (A_lower < B_lower)) {
+					A_out = (A_upper - B_upper) + (B_lower - A_lower);
+				} else if ((A_upper <= B_upper) && (A_lower < B_lower)) {
+					A_out = B_lower - A_lower;
+				} else {
+					// TODO remove next line
+					System.out.println("Something is wrong");
+				}
+				percent = (A_margin - A_out) / A_margin;
+			}
+
+			return percent;
+		}
+
+		public boolean hasInformationToSplit() {
+			return this.instSeenSinceLastSplitAttempt >= this.tree.gracePeriodOption.getValue();
+		}
+
+		public IademAttributeSplitSuggestion getBestSplitSuggestionIADEM(Instance instance) throws IademException {
+			int bestAtt;
+
+			int bestAttIndex = -1;
+			int secondBestAttIndex = -1;
+			double bestAtt_upper = Double.MAX_VALUE;
+			double bestAtt_lower = Double.MAX_VALUE;
+			double secondBestAtt_upper = Double.MAX_VALUE;
+			double secondBestAtt_lower = Double.MAX_VALUE;
+			double worstAtt_upper = Double.MIN_VALUE;
+			double worstAtt_lower = Double.MIN_VALUE;
+
+			for (int i = 0; i < virtualChildren.size(); i++) {
+				VirtualNode currentVirtualChild = virtualChildren.get(i);
+				if (currentVirtualChild != null) {
+					try {
+						currentVirtualChild.updateHeuristicMeasure(instance);
+					} catch (IademException e) {
+						throw new IademException("LeafNode", "getBestSplitSuggestion7",
+								"Problems when updating measures: \n" + e.getMessage());
+					}
+					// find the best and second-best attributes
+					if (currentVirtualChild.getHeuristicMeasureUpper(instance) >= 0) {
+						if ((currentVirtualChild.getHeuristicMeasureUpper(instance) < bestAtt_upper)
+								|| ((currentVirtualChild.getHeuristicMeasureUpper(instance) == bestAtt_upper)
+										&& (currentVirtualChild.getHeuristicMeasureLower(instance) < bestAtt_lower))) {
+
+							secondBestAttIndex = bestAttIndex;
+							secondBestAtt_upper = bestAtt_upper;
+							secondBestAtt_lower = bestAtt_lower;
+
+							bestAttIndex = i;
+							bestAtt_upper = currentVirtualChild.getHeuristicMeasureUpper(instance);
+							bestAtt_lower = currentVirtualChild.getHeuristicMeasureLower(instance);
+						} else if ((currentVirtualChild.getHeuristicMeasureUpper(instance) < secondBestAtt_upper)
+								|| ((currentVirtualChild.getHeuristicMeasureUpper(instance) == secondBestAtt_upper)
+										&& (currentVirtualChild
+												.getHeuristicMeasureLower(instance) < secondBestAtt_lower))) {
+							secondBestAttIndex = i;
+							secondBestAtt_upper = currentVirtualChild.getHeuristicMeasureUpper(instance);
+							secondBestAtt_lower = currentVirtualChild.getHeuristicMeasureLower(instance);
+						}
+						// find the worst attribute
+						if ((currentVirtualChild.getHeuristicMeasureUpper(instance) > worstAtt_upper)
+								|| ((currentVirtualChild.getHeuristicMeasureUpper(instance) == worstAtt_upper)
+										&& (currentVirtualChild.getHeuristicMeasureLower(instance) > worstAtt_lower))) {
+							worstAtt_upper = currentVirtualChild.getHeuristicMeasureUpper(instance);
+							worstAtt_lower = currentVirtualChild.getHeuristicMeasureLower(instance);
+						}
+					}
+				}
+			}
+			bestAtt = bestAttIndex;
+			if (secondBestAttIndex != -1) {
+				// percents in common
+				// best and worst
+				double best_worst = percentInCommon(bestAtt_upper, bestAtt_lower, worstAtt_upper, worstAtt_lower);
+				double worst_best = percentInCommon(worstAtt_upper, worstAtt_lower, bestAtt_upper, bestAtt_lower);
+
+				double d = tree.getAttributeDifferentiation();
+
+				boolean similarityBestWorst = (best_worst >= (1.0 - d)) && (worst_best >= (1.0 - d));
+
+				boolean similarityWithConfidenceBestWorst = similarityBestWorst
+						&& ((bestAtt_upper - bestAtt_lower) <= d);
+
+				boolean differenceBestWorst = (best_worst <= d) || (worst_best <= d);
+				if (!similarityWithConfidenceBestWorst && !differenceBestWorst) {
+					bestAtt = -1;
+				}
+			}
+
+			if (bestAtt != -1) {
+				VirtualNode bestNode = virtualChildren.get(bestAtt);
+				double percent;
+				if (bestNode instanceof NumericVirtualNode) {
+					percent = 1.0 - bestNode.getPercent();
+				} else {
+					percent = bestNode.getPercent();
+				}
+				if (percent > tree.getPercentInCommon()) {
+					bestAtt = -1;
+				}
+			}
+			if (bestAtt >= 0) {
+				return virtualChildren.get(bestAtt).bestSplitSuggestion;
+			}
+			return null;
+		}
+
+		@Override
+		public void getNumberOfNodes(int[] count) {
+			count[1]++;
+		}
+
+		public void setSplit(boolean split) {
+			this.split = split;
+		}
+	}
+
+	public class LeafNodeNB extends LeafNode {
+
+		private static final long serialVersionUID = 1L;
+		protected int naiveBayesLimit;
+
+		public LeafNodeNB(Iadem2 tree, Node parent, long instTreeCountSinceVirtual, long instNodeCountSinceVirtual,
+				double[] initialClassVotes, IademNumericAttributeObserver numericAttClassObserver, int naiveBayesLimit,
+				boolean onlyMultiwayTest, boolean onlyBinaryTest, Instance instance) {
+			super(tree, parent, instTreeCountSinceVirtual, instNodeCountSinceVirtual, initialClassVotes,
+					numericAttClassObserver, onlyMultiwayTest, onlyBinaryTest, instance);
+			this.naiveBayesLimit = naiveBayesLimit;
+		}
+
+		@Override
+		public double[] getClassVotes(Instance inst) {
+			double[] classVotes;
+			if (instNodeCountSinceVirtual == 0 || instNodeCountSinceReal < naiveBayesLimit) {
+				classVotes = getMajorityClassVotes(inst);
+			} else {
+				classVotes = getNaiveBayesPrediction(inst);
+			}
+			return classVotes;
+		}
+
+		protected double[] getNaiveBayesPrediction(Instance obs) {
+			double[] classVotes = getMajorityClassVotes(obs);
+			DoubleVector condProbabilities;
+			for (int i = 0; i < virtualChildren.size(); i++) {
+				VirtualNode currentVirtualNode = virtualChildren.get(i);
+				if (currentVirtualNode != null && currentVirtualNode.hasInformation()) {
+					double valor = obs.value(i);
+					condProbabilities = currentVirtualNode.computeConditionalProbability(valor);
+					if (condProbabilities != null) {
+						for (int j = 0; j < classVotes.length; j++) {
+							classVotes[j] *= condProbabilities.getValue(j);
+						}
+					}
+				}
+			}
+			// normalize class votes
+			double classVoteCount = 0.0;
+			for (int i = 0; i < classVotes.length; i++) {
+				classVoteCount += classVotes[i];
+			}
+			if (classVoteCount == 0.0) {
+				for (int i = 0; i < classVotes.length; i++) {
+					classVotes[i] = 1.0 / classVotes.length;
+				}
+			} else {
+				for (int i = 0; i < classVotes.length; i++) {
+					classVotes[i] /= classVoteCount;
+				}
+			}
+			return classVotes;
+		}
+	}
+
+	public class LeafNodeNBKirkby extends LeafNodeNB {
+
+		private static final long serialVersionUID = 1L;
+		protected int naiveBayesError, majorityClassError;
+
+		public LeafNodeNBKirkby(Iadem2 tree, Node parent, long instancesProcessedByTheTree,
+				long instancesProcessedByThisLeaf, double[] classDist,
+				IademNumericAttributeObserver numericAttClassObserver, int naiveBayesLimit, boolean onlyMultiwayTest,
+				boolean onlyBinaryTest, AbstractChangeDetector estimator, Instance instance) {
+			super(tree, parent, instancesProcessedByTheTree, instancesProcessedByThisLeaf, classDist,
+					numericAttClassObserver, naiveBayesLimit, onlyMultiwayTest, onlyBinaryTest, instance);
+			this.naiveBayesError = 0;
+			this.majorityClassError = 0;
+		}
+
+		@Override
+		public double[] getClassVotes(Instance instance) {
+			if (naiveBayesError > majorityClassError) {
+				return getMajorityClassVotes(instance);
+			} else {
+				return getNaiveBayesPrediction(instance);
+			}
+		}
+
+		@Override
+		public Node learnFromInstance(Instance inst) {
+			// test-then-train
+			double[] prediccion = getMajorityClassVotes(inst);
+			double error = (Utils.maxIndex(prediccion) == (int) inst.classValue()) ? 0.0 : 1.0;
+			this.majorityClassError += error;
+
+			prediccion = getNaiveBayesPrediction(inst);
+			error = (Utils.maxIndex(prediccion) == (int) inst.classValue()) ? 0.0 : 1.0;
+			this.naiveBayesError += error;
+
+			return super.learnFromInstance(inst);
+		}
+	}
+
+	public class LeafNodeWeightedVote extends LeafNodeNB {
+
+		private static final long serialVersionUID = 1L;
+		protected AbstractChangeDetector naiveBayesError, majorityClassError;
+
+		public LeafNodeWeightedVote(Iadem2 tree, Node parent, long instancesProcessedByTheTree,
+				long instancesProcessedByThisLeaf, double[] classDist,
+				IademNumericAttributeObserver observadorContinuos, int naiveBayesLimit, boolean onlyMultiwayTest,
+				boolean onlyBinaryTest, AbstractChangeDetector estimator, Instance instance) {
+			super(tree, parent, instancesProcessedByTheTree, instancesProcessedByThisLeaf, classDist,
+					observadorContinuos, naiveBayesLimit, onlyMultiwayTest, onlyBinaryTest, instance);
+			this.naiveBayesError = (AbstractChangeDetector) estimator.copy();
+			this.majorityClassError = (AbstractChangeDetector) estimator.copy();
+		}
+
+		@Override
+		public double[] getClassVotes(Instance instance) {
+			double NBweight = 1 - this.naiveBayesError.getEstimation(),
+					MCweight = 1 - this.majorityClassError.getEstimation();
+			double[] MC = getMajorityClassVotes(instance), NB = getNaiveBayesPrediction(instance),
+					classVotes = new double[MC.length];
+			for (int i = 0; i < MC.length; i++) {
+				classVotes[i] = MC[i] * MCweight + NB[i] * NBweight;
+			}
+			return classVotes;
+		}
+
+		@Override
+		public Node learnFromInstance(Instance inst) {
+			// test-then-train
+			double[] classVotes = getMajorityClassVotes(inst);
+			double error = (Utils.maxIndex(classVotes) == (int) inst.classValue()) ? 0.0 : 1.0;
+			this.majorityClassError.input(error);
+
+			classVotes = getNaiveBayesPrediction(inst);
+			error = (Utils.maxIndex(classVotes) == (int) inst.classValue()) ? 0.0 : 1.0;
+			this.naiveBayesError.input(error);
+			return super.learnFromInstance(inst);
+		}
+	}
+
+	public abstract class VirtualNode extends Node {
+
+		private static final long serialVersionUID = 1L;
+		protected int attIndex;
+
+		protected boolean heuristicMeasureUpdated;
+
+		protected IademAttributeSplitSuggestion bestSplitSuggestion = null;
+
+		public VirtualNode(Iadem2 tree, Node parent, int attIndex) {
+			super(tree, parent, new double[0]);
+			this.attIndex = attIndex;
+			this.heuristicMeasureUpdated = false;
+		}
+
+		public IademAttributeSplitSuggestion getBestSplitSuggestion() {
+			return bestSplitSuggestion;
+		}
+
+		public int getAttIndex() {
+			return attIndex;
+		}
+
+		@Override
+		public int getSubtreeNodeCount() {
+			return 0;
+		}
+
+		@Override
+		public ArrayList<LeafNode> getLeaves() {
+			return new ArrayList<>();
+		}
+
+		public abstract SplitNode getNewSplitNode(long newInstancesSeen, Node parent,
+				IademAttributeSplitSuggestion bestSuggestion, Instance instance);
+
+		public abstract void updateHeuristicMeasure(Instance instance) throws IademException;
+
+		public abstract DoubleVector computeConditionalProbability(double value);
+
+		public abstract double getPercent();
+
+		public abstract boolean hasInformation();
+
+		public double getHeuristicMeasureUpper(Instance instance) throws IademException {
+			if (!this.heuristicMeasureUpdated) {
+				updateHeuristicMeasure(instance);
+			}
+			if (this.bestSplitSuggestion == null) {
+				return -1;
+			}
+			return this.bestSplitSuggestion.merit;
+		}
+
+		public double getHeuristicMeasureLower(Instance instance) throws IademException {
+			if (!this.heuristicMeasureUpdated) {
+				updateHeuristicMeasure(instance);
+			}
+			if (this.bestSplitSuggestion == null) {
+				return -1;
+			}
+			return this.bestSplitSuggestion.getMeritLowerBound();
+		}
+
+		@Override
+		public double[] getClassVotes(Instance inst) {
+			return this.classValueDist.getArrayCopy();
+		}
+	}
+
+	public class NominalVirtualNode extends VirtualNode {
+
+		private static final long serialVersionUID = 1L;
+
+		protected AutoExpandVector<DoubleVector> nominalAttClassObserver = new AutoExpandVector<>();
+
+		protected DoubleVector attValueDist;
+		protected boolean onlyMultiwayTest = false;
+		protected boolean onlyBinaryTest = false;
+
+		public NominalVirtualNode(Iadem2 tree, Node parent, int attIndex, boolean onlyMultiwayTest,
+				boolean onlyBinaryTest) {
+			super(tree, parent, attIndex);
+
+			this.attValueDist = new DoubleVector();
+			this.onlyMultiwayTest = onlyMultiwayTest;
+			this.onlyBinaryTest = onlyBinaryTest;
+		}
+
+		public AutoExpandVector<DoubleVector> getNominalAttClassObserver() {
+			return nominalAttClassObserver;
+		}
+
+		@Override
+		public Node learnFromInstance(Instance inst) {
+			double attValue = inst.value(this.attIndex);
+			if (Utils.isMissingValue(attValue)) {
+			} else {
+				int intAttValue = (int) attValue;
+
+				this.attValueDist.addToValue(intAttValue, inst.weight());
+				this.classValueDist.addToValue((int) inst.value(inst.classIndex()), inst.weight());
+
+				DoubleVector valDist = this.nominalAttClassObserver.get(intAttValue);
+				if (valDist == null) {
+					valDist = new DoubleVector();
+					this.nominalAttClassObserver.set(intAttValue, valDist);
+				}
+				int classValue = (int) inst.classValue();
+				valDist.addToValue(classValue, inst.weight());
+
+				this.heuristicMeasureUpdated = false;
+			}
+			return this;
+		}
+
+		@Override
+		public SplitNode getNewSplitNode(long newTotal, Node parent, IademAttributeSplitSuggestion bestSuggestion,
+				Instance instance) {
+			SplitNode splitNode = new SplitNode(this.tree, parent, null,
+					((LeafNode) this.parent).getMajorityClassVotes(instance), bestSuggestion.splitTest);
+
+			Node[] children;
+			if (bestSuggestion.splitTest instanceof IademNominalAttributeMultiwayTest) {
+				children = new Node[instance.attribute(this.attIndex).numValues()];
+				for (int i = 0; i < children.length; i++) {
+					long count = 0;
+					double[] tmpClassDist = new double[instance.attribute(instance.classIndex()).numValues()];
+					Arrays.fill(tmpClassDist, 0);
+					for (int j = 0; j < tmpClassDist.length; j++) {
+
+						DoubleVector classCount = nominalAttClassObserver.get(i);
+						double contadorAtributoClase = classCount != null ? classCount.getValue(j) : 0.0;
+						tmpClassDist[j] = contadorAtributoClase;
+						count += tmpClassDist[j];
+					}
+					children[i] = tree.newLeafNode(splitNode, newTotal, count, tmpClassDist, instance);
+				}
+			} else { // binary split
+				children = new Node[2];
+				IademNominalAttributeBinaryTest binarySplit = (IademNominalAttributeBinaryTest) bestSuggestion.splitTest;
+				// to the left
+				double[] tmpClassDist = new double[instance.attribute(instance.classIndex()).numValues()];
+				// total de valores
+				double tmpCount = 0;
+				Arrays.fill(tmpClassDist, 0);
+				DoubleVector classDist = nominalAttClassObserver.get(binarySplit.getAttValue());
+				if (classDist != null) {
+					for (int i = 0; i < tmpClassDist.length; i++) {
+						tmpClassDist[i] = classDist.getValue(i);
+						tmpCount += classDist.getValue(i);
+					}
+				}
+				children[0] = tree.newLeafNode(splitNode, newTotal, (int) tmpCount, tmpClassDist, instance);
+				// to the right
+				tmpCount = this.classValueDist.sumOfValues() - tmpCount;
+				for (int i = 0; i < tmpClassDist.length; i++) {
+					tmpClassDist[i] = this.classValueDist.getValue(i) - tmpClassDist[i];
+				}
+				children[1] = tree.newLeafNode(splitNode, newTotal, (int) tmpCount, tmpClassDist, instance);
+
+			}
+			splitNode.setChildren(children);
+			return splitNode;
+		}
+
+		protected boolean moreThanOneAttValueObserved() {
+			int count = 0;
+			for (DoubleVector tmpClassDist : this.nominalAttClassObserver) {
+				if (tmpClassDist != null) {
+					count++;
+				}
+				if (count > 1) {
+					return true;
+				}
+			}
+			return false;
+		}
+
+		@Override
+		public void updateHeuristicMeasure(Instance instance) throws IademException {
+			if (moreThanOneAttValueObserved()/**/) {
+				if (!this.onlyBinaryTest) {
+					updateHeuristicMeasureMultiwayTest(instance);
+				}
+				if (!this.onlyMultiwayTest) {
+					updateHeuristicMeasureBinaryTest(instance);
+				}
+			} else {
+				this.bestSplitSuggestion = null;
+			}
+			this.heuristicMeasureUpdated = true;
+		}
+
+		public void updateHeuristicMeasureBinaryTest(Instance instance) throws IademException {
+			if (!this.heuristicMeasureUpdated) {
+				double measureLower, measureUpper;
+				IademSplitCriterion measure = tree.getMeasure();
+				if (this.bestSplitSuggestion != null
+						&& this.bestSplitSuggestion.splitTest instanceof NominalAttributeBinaryTest) {
+					this.bestSplitSuggestion = null;
+				}
+
+				int numberOfSplits = 2, // binary test
+						numberOfTests = this.tree.getValuesOfNominalAttributes(this.attIndex, instance);
+				int numberOfClasses = instance.attribute(instance.classIndex()).numValues();
+
+				double[][][] classDistPerTestAndSplit_lower = new double[numberOfTests][numberOfSplits][numberOfClasses];
+				double[][][] classDistPerTestAndSplit_upper = new double[numberOfTests][numberOfSplits][numberOfClasses];
+				computeClassDistBinaryTest(classDistPerTestAndSplit_lower, classDistPerTestAndSplit_upper);
+
+				for (int k = 0; k < numberOfTests; k++) {
+					double[] sumPerSplit_lower = new double[numberOfSplits];
+					double[] availableErrorPerSplit = new double[numberOfSplits];
+					Arrays.fill(sumPerSplit_lower, 0.0);
+					for (int i = 0; i < numberOfSplits; i++) {
+						for (int j = 0; j < numberOfClasses; j++) {
+							sumPerSplit_lower[i] += classDistPerTestAndSplit_lower[k][i][j];
+						}
+						availableErrorPerSplit[i] = 1.0 - sumPerSplit_lower[i];
+
+						if (availableErrorPerSplit[i] < 0.0) {
+							if (Math.abs(availableErrorPerSplit[i]) < Iadem2.ERROR_MARGIN) {
+								availableErrorPerSplit[i] = 0.0;
+							} else {
+								throw new IademException("NominalVirtualNode", "updateHeuristicMeasureBinaryTest",
+										"Problems when calculating measures");
+							}
+						}
+					}
+
+					double[] measurePerSplit_upper = new double[numberOfSplits];
+
+					double[] valueLevels = new double[numberOfSplits];
+					for (int i = 0; i < numberOfSplits; i++) {
+						ArrayList<Double> lot = new ArrayList<>();
+						lot.add(0.0);
+						lot.add(1.0);
+
+						ArrayList<Integer> hole = new ArrayList<>();
+						hole.add(0);
+						for (int j = 0; j < numberOfClasses; j++) {
+							IademCommonProcedures.insertLotsHoles(lot, hole, classDistPerTestAndSplit_lower[k][i][j],
+									classDistPerTestAndSplit_upper[k][i][j]);
+						}
+						valueLevels[i] = IademCommonProcedures.computeLevel(lot, hole, availableErrorPerSplit[i]);
+					}
+					for (int i = 0; i < numberOfSplits; i++) {
+						ArrayList<Double> vectorToMeasure = new ArrayList<>();
+						for (int j = 0; j < numberOfClasses; j++) {
+							double measureProb_uppper = Math.max(valueLevels[i],
+									classDistPerTestAndSplit_lower[k][i][j]);
+							measureProb_uppper = Math.min(classDistPerTestAndSplit_upper[k][i][j], measureProb_uppper);
+							vectorToMeasure.add(measureProb_uppper);
+						}
+						measurePerSplit_upper[i] = measure.doMeasure(vectorToMeasure);
+					}
+
+					double[] measurePerSplit_lower = new double[numberOfSplits];
+
+					for (int i = 0; i < numberOfSplits; i++) {
+						double tmpAvailable = availableErrorPerSplit[i];
+
+						ArrayList<Integer> decOrderClassDist_upper = new ArrayList<>();
+
+						ArrayList<Integer> unusedClasses = new ArrayList<>();
+						for (int j = 0; j < numberOfClasses; j++) {
+							unusedClasses.add(j);
+						}
+
+						double auxAvailable = availableErrorPerSplit[i];
+						for (int j = 0; j < numberOfClasses; j++) {
+							if (auxAvailable < 0.0) {
+								if (Math.abs(auxAvailable) < Iadem2.ERROR_MARGIN) {
+									auxAvailable = 0.0;
+								} else {
+									throw new IademException("NominalVirtualNode", "updateHeuristicMeasureBinaryTest",
+											"Problems when calculating measures");
+								}
+							}
+							int classIndex = getClassProbabilities(i, unusedClasses, classDistPerTestAndSplit_lower[k],
+									classDistPerTestAndSplit_upper[k], auxAvailable);
+							double probUp = Math.min(classDistPerTestAndSplit_upper[k][i][classIndex],
+									classDistPerTestAndSplit_lower[k][i][classIndex] + auxAvailable);
+
+							auxAvailable -= (probUp - classDistPerTestAndSplit_lower[k][i][classIndex]);
+
+							unusedClasses.remove(new Integer(classIndex));
+							decOrderClassDist_upper.add(new Integer(classIndex));
+						}
+
+						ArrayList<Double> vectorToMeasure = new ArrayList<>();
+						for (int j = 0; j < decOrderClassDist_upper.size(); j++) {
+							int classIndex = decOrderClassDist_upper.get(j);
+
+							if (tmpAvailable < 0.0) {
+								if (Math.abs(tmpAvailable) < Iadem2.ERROR_MARGIN) {
+									tmpAvailable = 0.0;
+								} else {
+									throw new IademException("NominalVirtualNode", "updateHeuristicMeasureBinaryTest",
+											"Problems when calculating measures");
+								}
+							}
+							double probUp = Math.min(classDistPerTestAndSplit_upper[k][i][classIndex],
+									classDistPerTestAndSplit_lower[k][i][classIndex] + tmpAvailable);
+							tmpAvailable -= (probUp - classDistPerTestAndSplit_lower[k][i][classIndex]);
+							vectorToMeasure.add(probUp);
+						}
+
+						measurePerSplit_lower[i] = measure.doMeasure(vectorToMeasure);
+					}
+
+					double dividendUpper = 0.0;
+					double dividendLower = 0.0;
+
+					double leftDivUpper = measurePerSplit_upper[0] * attValueDist.getValue(k),
+							leftDivLower = measurePerSplit_lower[0] * attValueDist.getValue(k);
+					double divisor = classValueDist.sumOfValues(), rightTotal = divisor - attValueDist.getValue(k);
+					double rightDivUpper = measurePerSplit_upper[1] * rightTotal,
+							rightDivLower = measurePerSplit_lower[1] * rightTotal;
+					dividendUpper = leftDivUpper + rightDivUpper;
+					dividendLower = leftDivLower + rightDivLower;
+
+					if (divisor != 0) {
+						measureLower = dividendLower / divisor;
+						measureUpper = dividendUpper / divisor;
+						if (this.bestSplitSuggestion == null) {
+							DoubleVector tmpClassDist = this.nominalAttClassObserver.get(k);
+							if (tmpClassDist != null) { // is it a useful split?
+								NominalAttributeBinaryTest test = new IademNominalAttributeBinaryTest(this.attIndex, k);
+								this.bestSplitSuggestion = new IademAttributeSplitSuggestion(test, new double[0][0],
+										measureUpper, measureLower);
+							}
+						} // compete with multiway test
+						else if (!this.onlyBinaryTest) {
+							if ((measureUpper < this.bestSplitSuggestion.merit)
+									|| (measureUpper == this.bestSplitSuggestion.merit
+											&& measureLower < this.bestSplitSuggestion.getMeritLowerBound())) {
+								DoubleVector tmpClassDist = this.nominalAttClassObserver.get(k);
+								if (tmpClassDist != null) { // is it a useful split?
+									NominalAttributeBinaryTest test = new IademNominalAttributeBinaryTest(this.attIndex,
+											k);
+									this.bestSplitSuggestion = new IademAttributeSplitSuggestion(test, new double[0][0],
+											measureUpper, measureLower);
+								}
+							}
+						}
+					}
+				}
+
+			}
+		}
+
+		protected void computeClassDistBinaryTest(double[][][] classDistPerTestAndSplit_lower,
+				double[][][] classDistPerTestAndSplit_upper) {
+			int numberOfClasses = classDistPerTestAndSplit_lower[0][0].length;
+			double estimator, bound;
+			double leftTotal = this.classValueDist.sumOfValues();
+			for (int currentAttIndex = 0; currentAttIndex < classDistPerTestAndSplit_lower.length; currentAttIndex++) {
+				for (int j = 0; j < numberOfClasses; j++) {
+					// compute probabilities in the left branch
+					DoubleVector classCounter = nominalAttClassObserver.get(currentAttIndex);
+					double attClassCounter = classCounter != null ? classCounter.getValue(j) : 0.0;
+					if (attValueDist.getValue(currentAttIndex) != 0) {
+						estimator = attClassCounter / attValueDist.getValue(currentAttIndex);
+						bound = IademCommonProcedures.getIADEM_HoeffdingBound(estimator,
+								attValueDist.getValue(currentAttIndex));
+						classDistPerTestAndSplit_lower[currentAttIndex][0][j] = Math.max(0.0, estimator - bound);
+						classDistPerTestAndSplit_upper[currentAttIndex][0][j] = Math.min(1.0, estimator + bound);
+					} else {
+						classDistPerTestAndSplit_lower[currentAttIndex][0][j] = 0.0;
+						classDistPerTestAndSplit_upper[currentAttIndex][0][j] = 1.0;
+					}
+					// compute probabilities in the right branch
+					attClassCounter = classValueDist.getValue(j) - attClassCounter;
+					double rightTotal = leftTotal - attValueDist.getValue(currentAttIndex);
+					if (rightTotal != 0) {
+						estimator = attClassCounter / rightTotal;
+						bound = IademCommonProcedures.getIADEM_HoeffdingBound(estimator, rightTotal);
+						classDistPerTestAndSplit_lower[currentAttIndex][1][j] = Math.max(0.0, estimator - bound);
+						classDistPerTestAndSplit_upper[currentAttIndex][1][j] = Math.min(1.0, estimator + bound);
+					} else {
+						classDistPerTestAndSplit_lower[currentAttIndex][1][j] = 0.0;
+						classDistPerTestAndSplit_upper[currentAttIndex][1][j] = 1.0;
+					}
+				}
+			}
+		}
+
+		public void updateHeuristicMeasureMultiwayTest(Instance instance) throws IademException {
+			if (!this.heuristicMeasureUpdated) {
+				this.bestSplitSuggestion = null;
+				double measureLower, measureUpper;
+				IademSplitCriterion measure = tree.getMeasure();
+
+				int numberOfValues = tree.getValuesOfNominalAttributes(attIndex, instance);
+				int numberOfClasses = instance.attribute(instance.classIndex()).numValues();
+				double[][] classDist_lower = new double[numberOfValues][numberOfClasses];
+				double[][] classDist_upper = new double[numberOfValues][numberOfClasses];
+
+				computeClassDistPerValue(classDist_lower, classDist_upper);
+
+				double[] sumPerValue_lower = new double[numberOfValues];
+				double[] availableErrorPerValue = new double[numberOfValues];
+				Arrays.fill(sumPerValue_lower, 0.0);
+				for (int i = 0; i < numberOfValues; i++) {
+					for (int j = 0; j < numberOfClasses; j++) {
+						sumPerValue_lower[i] += classDist_lower[i][j];
+					}
+					availableErrorPerValue[i] = 1.0 - sumPerValue_lower[i];
+
+					if (availableErrorPerValue[i] < 0.0) {
+						if (Math.abs(availableErrorPerValue[i]) < Iadem2.ERROR_MARGIN) {
+							availableErrorPerValue[i] = 0.0;
+						} else {
+							throw new IademException("NominalVirtualNode", "updateHeuristicMeasureMultiwayTest",
+									"Problems when calculating measures");
+						}
+					}
+				}
+
+				double[] measuerPerValue_upper = new double[numberOfValues];
+
+				double[] valueLevels = new double[numberOfValues];
+				for (int i = 0; i < numberOfValues; i++) {
+					ArrayList<Double> lot = new ArrayList<>();
+					lot.add(0.0);
+					lot.add(1.0);
+
+					ArrayList<Integer> hole = new ArrayList<>();
+					hole.add(0);
+					for (int j = 0; j < numberOfClasses; j++) {
+						IademCommonProcedures.insertLotsHoles(lot, hole, classDist_lower[i][j], classDist_upper[i][j]);
+					}
+
+					valueLevels[i] = IademCommonProcedures.computeLevel(lot, hole, availableErrorPerValue[i]);
+				}
+
+				for (int i = 0; i < numberOfValues; i++) {
+					ArrayList<Double> vectorToMeasure = new ArrayList<>();
+					for (int j = 0; j < numberOfClasses; j++) {
+						double p_sup_medida = Math.max(valueLevels[i], classDist_lower[i][j]);
+						p_sup_medida = Math.min(classDist_upper[i][j], p_sup_medida);
+						vectorToMeasure.add(p_sup_medida);
+					}
+					measuerPerValue_upper[i] = measure.doMeasure(vectorToMeasure);
+				}
+				// compute measure lower bounds
+				double[] measurePerValue_lower = new double[numberOfValues];
+				for (int i = 0; i < numberOfValues; i++) {
+					double availableError = availableErrorPerValue[i];
+					ArrayList<Integer> decOrderClassDist_upper = new ArrayList<>();
+
+					ArrayList<Integer> unusedClasses = new ArrayList<>();
+					for (int j = 0; j < numberOfClasses; j++) {
+						unusedClasses.add(j);
+					}
+
+					double auxAvailable = availableErrorPerValue[i];
+					for (int j = 0; j < numberOfClasses; j++) {
+						if (auxAvailable < 0.0) {
+							if (Math.abs(auxAvailable) < Iadem2.ERROR_MARGIN) {
+								auxAvailable = 0.0;
+							} else {
+								throw new IademException("NominalVirtualNode", "updateHeuristicMeasureMultiwayTest",
+										"Problems when calculating measures");
+							}
+						}
+
+						int classID = getClassProbabilities(i, unusedClasses, classDist_lower, classDist_upper,
+								auxAvailable);
+						double probUp = Math.min(classDist_upper[i][classID],
+								classDist_lower[i][classID] + auxAvailable);
+
+						auxAvailable -= (probUp - classDist_lower[i][classID]);
+
+						unusedClasses.remove(new Integer(classID));
+						decOrderClassDist_upper.add(new Integer(classID));
+					}
+
+					ArrayList<Double> vectorToMeasure = new ArrayList<>();
+					for (int j = 0; j < decOrderClassDist_upper.size(); j++) {
+						int classID = decOrderClassDist_upper.get(j);
+
+						if (availableError < 0.0) {
+							if (Math.abs(availableError) < Iadem2.ERROR_MARGIN) {
+								availableError = 0.0;
+							} else {
+								throw new IademException("NominalVirtualNode", "updateHeuristicMeasureMultiwayTest",
+										"Problems when calculating measures");
+							}
+						}
+						double probUp = Math.min(classDist_upper[i][classID],
+								classDist_lower[i][classID] + availableError);
+						availableError -= (probUp - classDist_lower[i][classID]);
+						vectorToMeasure.add(probUp);
+					}
+
+					measurePerValue_lower[i] = measure.doMeasure(vectorToMeasure);
+				}
+
+				double dividendUpper = 0.0;
+				double dividendLower = 0.0;
+				double divisor = 0.0;
+
+				for (int i = 0; i < attValueDist.numValues(); i++) {
+					dividendUpper += (measuerPerValue_upper[i] * attValueDist.getValue(i));
+					dividendLower += (measurePerValue_lower[i] * attValueDist.getValue(i));
+					divisor += attValueDist.getValue(i);
+				}
+				measureLower = dividendLower / divisor;
+				measureUpper = dividendUpper / divisor;
+
+				int maxBranches = instance.attribute(attIndex).numValues();
+				IademNominalAttributeMultiwayTest test = new IademNominalAttributeMultiwayTest(this.attIndex,
+						maxBranches);
+				bestSplitSuggestion = new IademAttributeSplitSuggestion(test, new double[0][0], measureUpper,
+						measureLower);
+			}
+		}
+
+		private void computeClassDistPerValue(double[][] classDistLower, double[][] classDistUpper) {
+			double estimator, classDistError;
+
+			int numberOfValues = classDistLower.length;
+			int numberOfClasses = classDistLower[0].length;
+
+			for (int i = 0; i < numberOfValues; i++) {
+				for (int j = 0; j < numberOfClasses; j++) {
+					if (attValueDist.getValue(i) == 0.0) {
+						classDistLower[i][j] = 0.0;
+						classDistUpper[i][j] = 1.0;
+					} else {
+						DoubleVector classCounter = nominalAttClassObserver.get(i);
+						double attValuePerClassCounter = classCounter != null ? classCounter.getValue(j) : 0.0;
+						estimator = attValuePerClassCounter / attValueDist.getValue(i);
+						classDistError = IademCommonProcedures.getIADEM_HoeffdingBound(estimator,
+								attValueDist.getValue(i));
+						classDistLower[i][j] = Math.max(0.0, estimator - classDistError);
+						classDistUpper[i][j] = Math.min(1.0, estimator + classDistError);
+					}
+				}
+			}
+		}
+
+		private int getClassProbabilities(int attributeValue, ArrayList<Integer> attValueList,
+				double[][] classDistPerValueLower, double[][] classDistPerValueUpper, double available) {
+			int max, tmp;
+			double maxProbUp, newProbUp;
+			if (attValueList.isEmpty()) {
+				return -1;
+			} else {
+				max = attValueList.get(0);
+				maxProbUp = Math.min(classDistPerValueUpper[attributeValue][max],
+						classDistPerValueLower[attributeValue][max] + available);
+
+				for (int i = 1; i < attValueList.size(); i++) {
+					tmp = attValueList.get(i);
+					newProbUp = Math.min(classDistPerValueUpper[attributeValue][tmp],
+							classDistPerValueLower[attributeValue][tmp] + available);
+					if (newProbUp > maxProbUp) {
+						max = tmp;
+						maxProbUp = newProbUp;
+					}
+				}
+				return max;
+			}
+		}
+
+		@Override
+		public DoubleVector computeConditionalProbability(double valor) {
+			int numberOfValues = nominalAttClassObserver.size();
+			DoubleVector conditionalProbability = new DoubleVector();
+
+			DoubleVector sumsPerClass = new DoubleVector();
+			for (int i = 0; i < numberOfValues; i++) {
+				DoubleVector classCounter = nominalAttClassObserver.get(i);
+				int numberOfClasses = classCounter != null ? classCounter.numValues() : 0;
+				for (int j = 0; j < numberOfClasses; j++) {
+					double attClassCounter = classCounter.getValue(j);
+					sumsPerClass.addToValue(j, attClassCounter);
+				}
+			}
+
+			for (int i = 0; i < sumsPerClass.numValues(); i++) {
+				if (sumsPerClass.getValue(i) != 0.0) {
+					DoubleVector contadorClase = nominalAttClassObserver.get((int) valor);
+					double attClassCounter = contadorClase != null ? contadorClase.getValue(i) : 0.0;
+					conditionalProbability.setValue(i, attClassCounter / sumsPerClass.getValue(i));
+				}
+			}
+
+			return conditionalProbability;
+		}
+
+		@Override
+		public double getPercent() {
+			double counter = 0;
+			double maxInstances = 0;
+			for (int i = 0; i < attValueDist.numValues(); i++) {
+				counter += attValueDist.getValue(i);
+				if (attValueDist.getValue(i) > maxInstances) {
+					maxInstances = attValueDist.getValue(i);
+				}
+			}
+			double maxPercent = maxInstances / counter;
+			return maxPercent;
+		}
+
+		@Override
+		public boolean hasInformation() {
+			return true;
+		}
+
+		@Override
+		public void getNumberOfNodes(int[] count) {
+			count[1]++;
+		}
+	}
+
+	public class NumericVirtualNode extends VirtualNode {
+
+		private static final long serialVersionUID = 1L;
+		private static final int MAX_BINS_EQUAL_WIDTH = 10;
+		protected IademNumericAttributeObserver numericAttClassObserver;
+		protected double bestCutPoint;
+
+		public NumericVirtualNode(Iadem2 tree, Node parent, int attIndex,
+				IademNumericAttributeObserver numericAttClassObs) {
+			super(tree, parent, attIndex);
+			int numIntervalos = this.tree.getMaxNumberOfBins();
+			this.numericAttClassObserver = (IademNumericAttributeObserver) numericAttClassObs.copy();
+			this.numericAttClassObserver.setMaxBins(numIntervalos);
+			this.bestCutPoint = 0.0;
+		}
+
+		public IademNumericAttributeObserver getNumericAttClassObserver() {
+			return numericAttClassObserver;
+		}
+
+		@Override
+		public Node learnFromInstance(Instance instance) {
+			this.numericAttClassObserver.addValue(instance.value(this.attIndex),
+					(int) instance.value(instance.classIndex()), instance.weight());
+			this.classValueDist.addToValue((int) instance.value(instance.classIndex()), instance.weight());
+			this.heuristicMeasureUpdated = false;
+			return this;
+		}
+
+		long arrSum(long[] arr) {
+			long count = 0;
+			for (int i = 0; i < arr.length; i++) {
+				count += arr[i];
+			}
+			return count;
+		}
+
+		@Override
+		public SplitNode getNewSplitNode(long newTotal, Node parent, IademAttributeSplitSuggestion bestSuggestion,
+				Instance instance) {
+			double[] cut = new double[] { this.bestCutPoint };
+
+			Node[] children = new Node[2]; // a traditional binary split test for numeric attributes
+
+			long[] newClassVotesAndTotal = this.numericAttClassObserver.getLeftClassDist(this.bestCutPoint);
+			long totalLeft = arrSum(newClassVotesAndTotal);
+
+			long total = this.numericAttClassObserver.getValueCount();
+			long[] classVotesTotal = this.numericAttClassObserver.getClassDist();
+			boolean equalsPassesTest = true;
+			if (this.numericAttClassObserver instanceof IademVFMLNumericAttributeClassObserver) {
+				equalsPassesTest = false;
+			}
+			SplitNode splitNode = new SplitNode(this.tree, parent, null,
+					((LeafNode) this.parent).getMajorityClassVotes(instance),
+					new IademNumericAttributeBinaryTest(this.attIndex, cut[0], equalsPassesTest));
+
+			long newTotalLeft = totalLeft;
+			long newTotalRight = total - newTotalLeft;
+			double[] newClassVotesLeft = new double[instance.attribute(instance.classIndex()).numValues()];
+			double[] newClassVotesRight = new double[instance.attribute(instance.classIndex()).numValues()];
+
+			Arrays.fill(newClassVotesLeft, 0);
+			Arrays.fill(newClassVotesRight, 0);
+
+			for (int i = 0; i < newClassVotesAndTotal.length; i++) {
+				newClassVotesLeft[i] = newClassVotesAndTotal[i];
+				newClassVotesRight[i] = classVotesTotal[i] - newClassVotesLeft[i];
+			}
+
+			splitNode.setChildren((Node[]) null);
+			children[0] = this.tree.newLeafNode(splitNode, newTotal, newTotalLeft, newClassVotesLeft, instance);
+			children[1] = this.tree.newLeafNode(splitNode, newTotal, newTotalRight, newClassVotesRight, instance);
+
+			splitNode.setChildren(children);
+
+			return splitNode;
+		}
+
+		@Override
+		public void updateHeuristicMeasure(Instance instance) throws IademException {
+			if (!this.heuristicMeasureUpdated) {
+				if (this.numericAttClassObserver.getNumberOfCutPoints() < 2) {
+					this.bestSplitSuggestion = null;
+				} else {
+					IademSplitCriterion measure = ((LeafNode) this.parent).getTree().getMeasure();
+					int numberOfClasses = instance.attribute(instance.classIndex()).numValues();
+
+					int numberOfSplits = 2;
+					int numberOfCuts = (int) this.numericAttClassObserver.getNumberOfCutPoints();
+
+					double[] measureLower = new double[numberOfCuts];
+					double[] measureUpper = new double[numberOfCuts];
+
+					double[][][] classVotesPerCutAndSplit_lower = new double[numberOfCuts][numberOfSplits][numberOfClasses];
+					double[][][] classVotesPerCutAndSplit_upper = new double[numberOfCuts][numberOfSplits][numberOfClasses];
+
+					double[][] totalPerCutAndSplit = new double[numberOfCuts][numberOfSplits];
+
+					computeClassVoteBounds(classVotesPerCutAndSplit_lower, classVotesPerCutAndSplit_upper,
+							totalPerCutAndSplit, true);
+
+					for (int k = 0; k < numberOfCuts; k++) {
+						double[] countPerSplit_lower = new double[numberOfSplits];
+						double[] availableErrorPerSplit = new double[numberOfSplits];
+						Arrays.fill(countPerSplit_lower, 0.0);
+						for (int i = 0; i < numberOfSplits; i++) {
+							for (int j = 0; j < numberOfClasses; j++) {
+								countPerSplit_lower[i] += classVotesPerCutAndSplit_lower[k][i][j];
+							}
+							availableErrorPerSplit[i] = 1.0 - countPerSplit_lower[i];
+
+							if (availableErrorPerSplit[i] < 0.0) {
+								if (Math.abs(availableErrorPerSplit[i]) < Iadem2.ERROR_MARGIN) {
+									availableErrorPerSplit[i] = 0.0;
+								} else {
+									throw new IademException("NumericVirtualNode", "updateHeuristicMeasure",
+											"Problems when calculating measures");
+								}
+							}
+						}
+
+						// compute measure upper bounds
+						double[] measurePerSplit_upper = new double[numberOfSplits];
+
+						double[] splitLevels = new double[numberOfSplits];
+						for (int i = 0; i < numberOfSplits; i++) {
+							ArrayList<Double> lot = new ArrayList<>();
+							lot.add(0.0);
+							lot.add(1.0);
+							ArrayList<Integer> hole = new ArrayList<>();
+							hole.add(0);
+							for (int j = 0; j < numberOfClasses; j++) {
+								IademCommonProcedures.insertLotsHoles(lot, hole,
+										classVotesPerCutAndSplit_lower[k][i][j],
+										classVotesPerCutAndSplit_upper[k][i][j]);
+							}
+							splitLevels[i] = IademCommonProcedures.computeLevel(lot, hole, availableErrorPerSplit[i]);
+						}
+
+						for (int i = 0; i < numberOfSplits; i++) {
+							ArrayList<Double> vectorToMeasure = new ArrayList<>();
+							for (int j = 0; j < numberOfClasses; j++) {
+								double tmpMeasureUpper = Math.max(splitLevels[i],
+										classVotesPerCutAndSplit_lower[k][i][j]);
+								tmpMeasureUpper = Math.min(classVotesPerCutAndSplit_upper[k][i][j], tmpMeasureUpper);
+								vectorToMeasure.add(tmpMeasureUpper);
+							}
+							measurePerSplit_upper[i] = measure.doMeasure(vectorToMeasure);
+						}
+
+						double[] measurePerSplit_lower = new double[numberOfSplits];
+
+						for (int i = 0; i < numberOfSplits; i++) {
+							double availableProb = availableErrorPerSplit[i];
+
+							ArrayList<Integer> decOrderClassVotes_upper = new ArrayList<>();
+
+							ArrayList<Integer> unusedClasses = new ArrayList<>();
+							for (int j = 0; j < numberOfClasses; j++) {
+								unusedClasses.add(j);
+							}
+
+							double auxAvailable = availableErrorPerSplit[i];
+							for (int j = 0; j < numberOfClasses; j++) {
+								if (auxAvailable < 0.0) {
+									if (Math.abs(auxAvailable) < Iadem2.ERROR_MARGIN) {
+										auxAvailable = 0.0;
+									} else {
+										throw new IademException("NodoVirtualContinuo", "actualizaMedida",
+												"Problems calculating measure");
+									}
+								}
+
+								int classIndex = getClassValueProbabilities(i, unusedClasses,
+										classVotesPerCutAndSplit_lower[k], classVotesPerCutAndSplit_upper[k],
+										auxAvailable);
+								double probUpper = Math.min(classVotesPerCutAndSplit_upper[k][i][classIndex],
+										classVotesPerCutAndSplit_lower[k][i][classIndex] + auxAvailable);
+
+								auxAvailable -= (probUpper - classVotesPerCutAndSplit_lower[k][i][classIndex]);
+
+								unusedClasses.remove(new Integer(classIndex));
+								decOrderClassVotes_upper.add(new Integer(classIndex));
+							}
+
+							ArrayList<Double> vectorToMeasure = new ArrayList<>();
+							for (int j = 0; j < decOrderClassVotes_upper.size(); j++) {
+								int classIndex = decOrderClassVotes_upper.get(j);
+
+								if (availableProb < 0.0) {
+									if (Math.abs(availableProb) < Iadem2.ERROR_MARGIN) {
+										availableProb = 0.0;
+									} else {
+										throw new IademException("NumericVirtualNode", "updateMeasure",
+												"Problems when calculating measures");
+									}
+								}
+								double probUpper = Math.min(classVotesPerCutAndSplit_upper[k][i][classIndex],
+										classVotesPerCutAndSplit_lower[k][i][classIndex] + availableProb);
+								availableProb -= (probUpper - classVotesPerCutAndSplit_lower[k][i][classIndex]);
+								vectorToMeasure.add(probUpper);
+							}
+
+							measurePerSplit_lower[i] = measure.doMeasure(vectorToMeasure);
+						}
+
+						double dividendUpper = 0.0;
+						double dividendLower = 0.0;
+						double divisor = 0.0;
+
+						for (int i = 0; i < totalPerCutAndSplit[k].length; i++) {
+							dividendUpper += (measurePerSplit_upper[i] * totalPerCutAndSplit[k][i]);
+							dividendLower += (measurePerSplit_lower[i] * totalPerCutAndSplit[k][i]);
+							divisor += totalPerCutAndSplit[k][i];
+						}
+
+						measureLower[k] = dividendLower / divisor;
+						measureUpper[k] = dividendUpper / divisor;
+					}
+
+					ArrayList<Integer> indMinSupMedida = new ArrayList<>();
+					double minSupMedida = measureUpper[0];
+					indMinSupMedida.add(0);
+
+					for (int i = 1; i < measureUpper.length; i++) {
+						if (measureUpper[i] < minSupMedida) {
+							minSupMedida = measureUpper[i];
+							indMinSupMedida.clear();
+							indMinSupMedida.add(i);
+						} else if (measureUpper[i] == minSupMedida) {
+							indMinSupMedida.add(i);
+						}
+					}
+
+					Iterator<Integer> iterator = indMinSupMedida.iterator();
+					Integer element = iterator.next();
+					int minMeasureLowerIndex = element;
+					double minMeasureLower = measureLower[element];
+
+					while (iterator.hasNext()) {
+						element = iterator.next();
+						if (measureLower[element] < minMeasureLower) {
+							minMeasureLower = measureLower[element];
+							minMeasureLowerIndex = element;
+						}
+					}
+
+					this.bestCutPoint = this.numericAttClassObserver.getCut(minMeasureLowerIndex);
+					boolean equalsPassesTest = true;
+					if (this.numericAttClassObserver instanceof IademVFMLNumericAttributeClassObserver) {
+						equalsPassesTest = false;
+					}
+					IademNumericAttributeBinaryTest test = new IademNumericAttributeBinaryTest(this.attIndex,
+							this.bestCutPoint, equalsPassesTest);
+					this.bestSplitSuggestion = new IademAttributeSplitSuggestion(test, new double[0][0], minSupMedida,
+							minMeasureLower);
+				}
+				this.heuristicMeasureUpdated = true;
+			}
+		}
+
+		private void computeClassVoteBounds(double[][][] classVotesPerCutAndSplit_lower,
+				double[][][] classVotesPerCutAndSplit_upper, double[][] totalPerCutAndSplit,
+				boolean withIntervalEstimates) {
+			this.numericAttClassObserver.computeClassDistProbabilities(classVotesPerCutAndSplit_lower,
+					classVotesPerCutAndSplit_upper, totalPerCutAndSplit, withIntervalEstimates);
+		}
+
+		private int getClassValueProbabilities(int value, ArrayList<Integer> valueList,
+				double[][] classValuePerSplitLower, double[][] classValuePerSplitUpper, double availableProb) {
+			int max, newValue;
+			double max_up, newValue_up;
+			if (valueList.isEmpty()) {
+				return -1;
+			} else {
+				max = valueList.get(0);
+				max_up = Math.min(classValuePerSplitUpper[value][max],
+						classValuePerSplitLower[value][max] + availableProb);
+
+				for (int i = 1; i < valueList.size(); i++) {
+					newValue = valueList.get(i);
+					newValue_up = Math.min(classValuePerSplitUpper[value][newValue],
+							classValuePerSplitLower[value][newValue] + availableProb);
+					if (newValue_up > max_up) {
+						max = newValue;
+						max_up = newValue_up;
+					}
+				}
+				return max;
+			}
+		}
+
+		@Override
+		public boolean hasInformation() {
+			return (this.numericAttClassObserver.getNumberOfCutPoints() > 1);
+		}
+
+		private ArrayList<Double> getCuts() {
+			return this.numericAttClassObserver.cutPointSuggestion(NumericVirtualNode.MAX_BINS_EQUAL_WIDTH);
+		}
+
+		@Override
+		public double getPercent() {
+			long[] classVotesLeft = this.numericAttClassObserver.getLeftClassDist(this.bestCutPoint);
+
+			double leftCount = arrSum(classVotesLeft);
+			double total = this.numericAttClassObserver.getValueCount();
+
+			double leftPercent = leftCount / total;
+			double rightPercent = 1.0 - leftPercent;
+
+			if (rightPercent < leftPercent) {
+				return rightPercent;
+			} else {
+				return leftPercent;
+			}
+		}
+
+		@Override
+		public DoubleVector computeConditionalProbability(double value) {
+			ArrayList<Double> cut = getCuts();
+			return new DoubleVector(this.numericAttClassObserver.computeConditionalProb(cut, value));
+		}
+
+		@Override
+		public void getNumberOfNodes(int[] count) {
+			count[1]++;
+		}
+	}
+
+	public class SplitNode extends Node {
+
+		private static final long serialVersionUID = 1L;
+
+		public InstanceConditionalTest splitTest;
+
+		public AutoExpandVector<Node> children = new AutoExpandVector<>();
+
+		public SplitNode(Iadem2 tree, Node parent, Node[] children, double[] initialClassCount,
+				InstanceConditionalTest splitTest) {
+			super(tree, parent, initialClassCount);
+			this.splitTest = splitTest;
+			this.setChildren(children);
+		}
+
+		public InstanceConditionalTest getSplitTest() {
+			return splitTest;
+		}
+
+		public void setChild(Node child, int index) {
+			if ((this.splitTest.maxBranches() >= 0) && (index >= this.splitTest.maxBranches())) {
+				throw new IndexOutOfBoundsException();
+			}
+			this.children.set(index, child);
+		}
+
+		@Override
+		public int getSubtreeNodeCount() {
+			int count = 1;
+			for (Node currentChild : this.children) {
+				count += currentChild.getSubtreeNodeCount();
+			}
+			return count;
+		}
+
+		@Override
+		public ArrayList<LeafNode> getLeaves() {
+			ArrayList<LeafNode> leaves = new ArrayList<>();
+			for (Node currentChild : this.children) {
+				leaves.addAll(currentChild.getLeaves());
+			}
+			return leaves;
+		}
+
+		public void changeChildren(Node oldChild, Node newChild) {
+			boolean found = false;
+			int pos = 0;
+			while ((!found) && (pos < this.children.size())) {
+				if (this.children.get(pos).equals(oldChild)) {
+					found = true;
+					this.children.set(pos, newChild);
+				}
+				pos++;
+			}
+		}
+
+		public int instanceChildIndex(Instance inst) {
+			return this.splitTest.branchForInstance(inst);
+		}
+
+		public Node getChild(int index) {
+			return this.children.get(index);
+		}
+
+		final public void setChildren(Node[] children) {
+			this.children.clear();
+			if (children != null) {
+				this.children.addAll(Arrays.asList(children));
+			}
+		}
+
+		public void setChild(AutoExpandVector<Node> children) {
+			this.children.clear();
+			this.children.addAll(children);
+		}
+
+		@Override
+		public Node learnFromInstance(Instance inst) {
+			int childIndex = instanceChildIndex(inst);
+			if (childIndex >= 0) {
+				Node child = getChild(childIndex);
+				if (child != null) {
+					return child.learnFromInstance(inst);
+				}
+			}
+			return null;
+		}
+
+		@Override
+		public double[] getClassVotes(Instance inst) {
+			int childIndex = instanceChildIndex(inst);
+			// there is no missing value
+			if (childIndex >= 0) {
+				Node currentChild = getChild(childIndex);
+				return currentChild.getClassVotes(inst);
+			} else {
+				return this.classValueDist.getArrayCopy();
+			}
+		}
+
+		@Override
+		public int getChildCount() {
+			return this.children.size();
+		}
+
+		public void removeChild(Node child) {
+			this.children.remove(child);
+		}
+
+		public void addChild(Node child) {
+			this.children.add(child);
+		}
+
+		@Override
+		public void getNumberOfNodes(int[] count) {
+			count[0]++;
+			for (Node child : children) {
+				child.getNumberOfNodes(count);
+			}
+		}
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/trees/iadem/Iadem3.java b/moa/src/main/java/moa/learners/predictors/trees/iadem/Iadem3.java
new file mode 100644
index 000000000..f1920cadd
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/trees/iadem/Iadem3.java
@@ -0,0 +1,1151 @@
+/*
+ *    IADEM3Tree.java
+ *
+ *    @author Isvani Frías-Blanco
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.predictors.trees.iadem;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.TreeSet;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.Measurement;
+import moa.learners.predictors.core.conditionaltests.InstanceConditionalTest;
+import moa.learners.predictors.core.conditionaltests.NominalAttributeMultiwayTest;
+import moa.learners.predictors.core.conditionaltests.NumericAttributeBinaryTest;
+import moa.learners.predictors.core.driftdetection.AbstractChangeDetector;
+import weka.core.Utils;
+
+/**
+ *
+ * @author Isvani Frías Blanco (ifriasb at hotmail dot com)
+ */
+public class Iadem3 extends Iadem2 {
+
+	private static final long serialVersionUID = 1L;
+
+	public IntOption maxNestingLevelOption = new IntOption("maxNestingLevel", 'p',
+			"Maximum level of nesting for alternative subtrees (-1 => unbounded).", 1, -1, Integer.MAX_VALUE);
+
+	public IntOption maxSubtreesPerNodeOption = new IntOption("maxSubtreesPerNode", 'w',
+			"Maximum number of alternative subtrees per split node (-1 => unbounded).", 1, -1, Integer.MAX_VALUE);
+
+	protected final boolean restartAtDrift = true;
+
+	protected int interchangedTrees = 0;
+	protected int deletedTrees = 0;
+	protected int numTrees = 0;
+
+	protected int lastPrediction = -1, lastPredictionInLeaf = -1;
+	//
+	protected int treeLevel = 0;
+	protected AutoExpandVector<Iadem3Subtree> subtreeList = new AutoExpandVector<>();
+
+	protected int currentSplitState = -1;
+	protected final int SPLIT_BY_TIE_BREAKING = 0, SPLIT_WITH_CONFIDENCE = 1;
+
+	public int numSplitsByBreakingTies = 0;
+
+	@Override
+	protected Measurement[] getModelMeasurementsImpl() {
+		return new Measurement[] { new Measurement("tree size (nodes)", this.getNumberOfNodes()),
+				new Measurement("tree size (leaves)", this.getNumberOfLeaves()),
+				new Measurement("interchanged trees", this.getChangedTrees()) };
+	}
+
+	public AbstractChangeDetector getEstimatorCopy() {
+		return (AbstractChangeDetector) ((AbstractChangeDetector) getPreparedClassOption(
+				this.driftDetectionMethodOption)).copy();
+	}
+
+	@Override
+	public void createRoot(Instance instance) {
+
+		double[] arrayCont = new double[instance.numClasses()];
+		Arrays.fill(arrayCont, 0);
+
+		this.treeRoot = newLeafNode(null, 0, 0, arrayCont, instance);
+	}
+
+	public void addSubtree(Iadem3Subtree subtree) {
+		this.subtreeList.add(subtree);
+	}
+
+	public void removeSubtree(Iadem3Subtree subtree) {
+		this.subtreeList.remove(subtree);
+	}
+
+	public boolean canCreateSubtree() {
+		if (this.maxSubtreesPerNodeOption.getValue() > 0) {
+			int count = getNumberOfSubtrees();
+			if (count >= this.maxSubtreesPerNodeOption.getValue()) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	@Override
+	public LeafNode newLeafNode(Node parent, long instTreeCountSinceVirtual, long instNodeCountSinceVirtual,
+			double[] initialClassCount, Instance instance) {
+		switch (this.leafPredictionOption.getChosenIndex()) {
+		case 0: {
+			return new AdaptiveLeafNode(this, parent, instTreeCountSinceVirtual, instNodeCountSinceVirtual,
+					initialClassCount, newNumericClassObserver(), this.estimator,
+					this.splitTestsOption.getChosenIndex() == 2, this.splitTestsOption.getChosenIndex() == 0, instance);
+		}
+		case 1: {
+			return new AdaptiveLeafNodeNB(this, parent, instTreeCountSinceVirtual, instNodeCountSinceVirtual,
+					initialClassCount, newNumericClassObserver(), this.naiveBayesLimit, this.estimator,
+					this.splitTestsOption.getChosenIndex() == 2, this.splitTestsOption.getChosenIndex() == 0, instance);
+		}
+		case 2: {
+			return new AdaptiveLeafNodeNBKirkby(this, parent, instTreeCountSinceVirtual, instNodeCountSinceVirtual,
+					initialClassCount, newNumericClassObserver(), this.naiveBayesLimit,
+					this.splitTestsOption.getChosenIndex() == 2, this.splitTestsOption.getChosenIndex() == 0,
+					this.estimator, instance);
+		}
+		default: {
+			return new AdaptiveLeafNodeWeightedVote(this, parent, instTreeCountSinceVirtual, instNodeCountSinceVirtual,
+					initialClassCount, newNumericClassObserver(), this.naiveBayesLimit,
+					this.splitTestsOption.getChosenIndex() == 2, this.splitTestsOption.getChosenIndex() == 0,
+					this.estimator, instance);
+		}
+		}
+	}
+
+	public int getTreeLevel() {
+		return treeLevel;
+	}
+
+	public int getMaxAltSubtreesPerNode() {
+		return this.maxSubtreesPerNodeOption.getValue();
+	}
+
+	public int getMaxNestingLevels() {
+		return this.maxNestingLevelOption.getValue();
+	}
+
+	public boolean isRestaurarVectoresPrediccion() {
+		return restartAtDrift;
+	}
+
+	public int numDeletedTrees() {
+		return deletedTrees;
+	}
+
+	public int numTrees() {
+		int subtreeCount;
+		if (this.treeRoot instanceof AdaptiveLeafNode) {
+			subtreeCount = 0;
+		} else {
+			AdaptiveSplitNode nodo = (AdaptiveSplitNode) this.treeRoot;
+			subtreeCount = nodo.getNumTrees();
+		}
+		return subtreeCount;
+	}
+
+	public void newTreeChange() {
+		interchangedTrees++;
+		numTrees--;
+	}
+
+	public void newDeletedTree() {
+		deletedTrees++;
+		numTrees--;
+	}
+
+	public int numSubtrees() {
+		return tmpNumSubtrees(treeRoot);
+	}
+
+	private int tmpNumSubtrees(Node node) {
+		int count = 0;
+		if (node instanceof AdaptiveSplitNode) {
+			count++;
+			AutoExpandVector<Iadem3Subtree> subtree = ((AdaptiveSplitNode) node).alternativeTree;
+			for (Iadem3Subtree currentSubtree : subtree) {
+				count += currentSubtree.numSubtrees();
+			}
+		}
+		if (node instanceof AdaptiveSplitNode) {
+			AdaptiveSplitNode nodoAuxiliar = (AdaptiveSplitNode) node;
+			for (Node child : nodoAuxiliar.children) {
+				count += tmpNumSubtrees(child);
+			}
+		}
+		return count;
+	}
+
+	protected boolean hasTree(Node node) {
+
+		boolean ret = false;
+		if (node instanceof AdaptiveSplitNode) {
+			AdaptiveSplitNode tmp = (AdaptiveSplitNode) node;
+			if (tmp.alternativeTree != null) {
+				ret = true;
+			}
+			for (int i = 0; ret == false && i < tmp.children.size(); i++) {
+				ret = ret || hasTree(tmp.children.get(i));
+			}
+		}
+		return ret;
+	}
+
+	@Override
+	public void learnFromInstance(Instance instance) throws IademException {
+		getClassVotes(instance); // to update lastPrediction in the trees
+		getClassVotesFromLeaf(instance);
+		super.learnFromInstance(instance);
+	}
+
+	protected void getClassVotesFromLeaf(Instance instance) {
+		double[] votes = null;
+		Node node = this.treeRoot;
+		while (votes == null) {
+			if (node instanceof AdaptiveSplitNode) {
+				AdaptiveSplitNode splitNode = (AdaptiveSplitNode) node;
+				int childIndex = splitNode.instanceChildIndex(instance);
+				if (childIndex >= 0) {
+					node = splitNode.getChild(childIndex);
+				} else {
+					votes = splitNode.leaf.getClassVotes(instance);
+				}
+			} else {
+				AdaptiveLeafNode leafNode = (AdaptiveLeafNode) node;
+				votes = leafNode.getClassVotes(instance);
+			}
+		}
+		this.lastPredictionInLeaf = Utils.maxIndex(votes);
+	}
+
+	public void copyTree(Iadem3Subtree arbol) {
+		this.treeRoot = arbol.treeRoot;
+	}
+
+	void setNewTree() {
+		numTrees++;
+	}
+
+	public int getChangedTrees() {
+		return interchangedTrees;
+	}
+
+	@Override
+	public double[] getClassVotes(Instance instance) {
+		double[] votes = super.getClassVotes(instance);
+		this.lastPrediction = Utils.maxIndex(votes);
+		return votes;
+	}
+
+	public int getNumberOfSubtrees() {
+		if (this.treeRoot instanceof AdaptiveSplitNode) {
+			return ((AdaptiveSplitNode) this.treeRoot).getNumberOfSubtrees();
+		}
+		return 0;
+	}
+
+	protected Iadem3 getMainTree() {
+		return this;
+	}
+
+	public void updateNumberOfLeaves(int amount) {
+		this.numberOfLeaves += amount;
+	}
+
+	public void updateNumberOfNodes(int amount) {
+		this.numberOfNodes += amount;
+	}
+
+	public void updateNumberOfNodesSplitByTieBreaking(int amount) {
+		this.numSplitsByBreakingTies += amount;
+	}
+
+	public class AdaptiveLeafNode extends LeafNode implements Serializable {
+
+		private static final long serialVersionUID = 1L;
+		protected AbstractChangeDetector estimator;
+
+		public AdaptiveLeafNode(Iadem3 arbol, Node parent, long instTreeCountSinceVirtual,
+				long instNodeCountSinceVirtual, double[] initialClassCount,
+				IademNumericAttributeObserver numericAttClassObserver, AbstractChangeDetector estimator,
+				boolean onlyMultiwayTest, boolean onlyBinaryTest, Instance instance) {
+			super(arbol, parent, instTreeCountSinceVirtual, instNodeCountSinceVirtual, initialClassCount,
+					numericAttClassObserver, onlyMultiwayTest, onlyBinaryTest, instance);
+			if (estimator != null) {
+				this.estimator = (AbstractChangeDetector) estimator.copy();
+			} else {
+				this.estimator = null;
+			}
+		}
+
+		@Override
+		protected void createVirtualNodes(IademNumericAttributeObserver numericAttClassObserver,
+				boolean onlyMultiwayTest, boolean onlyBinaryTest, Instance instance) {
+			ArrayList<Integer> nominalUsed = nominalAttUsed(instance);
+			TreeSet<Integer> sort = new TreeSet<>(nominalUsed);
+			for (int i = 0; i < instance.numAttributes(); i++) {
+				if (instance.classIndex() != i && instance.attribute(i).isNominal()) {
+					if ((!sort.isEmpty()) && (i == sort.first())) {
+						sort.remove(new Integer(sort.first()));
+						virtualChildren.set(i, null);
+					} else {
+						virtualChildren.set(i, new AdaptiveNominalVirtualNode((Iadem3) tree, this, i, onlyMultiwayTest,
+								onlyBinaryTest));
+					}
+				} else if (instance.classIndex() != i && instance.attribute(i).isNumeric()) {
+					virtualChildren.set(i,
+							new AdaptiveNumericVirtualNode((Iadem3) tree, this, i, numericAttClassObserver));
+				} else {
+					virtualChildren.set(i, null);
+				}
+			}
+		}
+
+		private void updateCounters(Instance experiencia) {
+			double[] classVotes = this.getClassVotes(experiencia);
+			boolean trueClass = (Utils.maxIndex(classVotes) == (int) experiencia.classValue());
+			if (estimator != null && ((Iadem3) this.tree).restartAtDrift) {
+				double error = trueClass == true ? 0.0 : 1.0;
+				this.estimator.input(error);
+				if (this.estimator.getChange()) {
+					this.restartVariablesAtDrift();
+				}
+			}
+		}
+
+		@Override
+		public void attemptToSplit(Instance instance) {
+			if (this.classValueDist.numNonZeroEntries() > 1) {
+				if (hasInformationToSplit()) {
+					try {
+						this.instSeenSinceLastSplitAttempt = 0;
+						IademAttributeSplitSuggestion bestSplitSuggestion;
+						if (this.instNodeCountSinceReal > 5000) {
+							((Iadem3) this.tree).updateNumberOfNodesSplitByTieBreaking(1);
+							bestSplitSuggestion = getFastSplitSuggestion(instance);
+							if (bestSplitSuggestion != null) {
+								((Iadem3) this.tree).currentSplitState = ((Iadem3) this.tree).SPLIT_BY_TIE_BREAKING;
+								doSplit(bestSplitSuggestion, instance);
+							}
+						} else {
+							bestSplitSuggestion = getBestSplitSuggestion(instance);
+							if (bestSplitSuggestion != null) {
+								((Iadem3) this.tree).currentSplitState = ((Iadem3) this.tree).SPLIT_WITH_CONFIDENCE;
+								doSplit(bestSplitSuggestion, instance);
+							}
+						}
+					} catch (IademException ex) {
+						Logger.getLogger(LeafNode.class.getName()).log(Level.SEVERE, null, ex);
+					}
+				}
+			}
+		}
+
+		@Override
+		public Node learnFromInstance(Instance inst) {
+			updateCounters(inst);
+			return super.learnFromInstance(inst);
+		}
+
+		@Override
+		public AdaptiveLeafNode[] doSplit(IademAttributeSplitSuggestion mejorExpansion, Instance instance) {
+			AdaptiveSplitNode splitNode;
+			splitNode = (AdaptiveSplitNode) virtualChildren.get(mejorExpansion.splitTest.getAttsTestDependsOn()[0])
+					.getNewSplitNode(instTreeCountSinceReal, parent, mejorExpansion, instance);
+			splitNode.setParent(this.parent);
+			splitNode.estimator = this.tree.newEstimator();
+
+			if (this.parent == null) {
+				tree.setTreeRoot(splitNode);
+			} else {
+				((SplitNode) parent).changeChildren(this, splitNode);
+			}
+			this.tree.newSplit(splitNode.getLeaves().size());
+			return null;
+		}
+
+		protected void restartVariablesAtDrift() {
+			instNodeCountSinceVirtual = 0;
+
+			classValueDist = new DoubleVector();
+
+			instTreeCountSinceReal = 0;
+			instNodeCountSinceReal = 0;
+			for (int i = 0; i < virtualChildren.size(); i++) {
+				if (virtualChildren.get(i) != null) {
+					((restartsVariablesAtDrift) virtualChildren.get(i)).resetVariablesAtDrift();
+				}
+			}
+		}
+	}
+
+	public class AdaptiveLeafNodeNB extends AdaptiveLeafNode {
+
+		private static final long serialVersionUID = 1L;
+		protected int limitNaiveBayes;
+
+		public AdaptiveLeafNodeNB(Iadem3 tree, Node parent, long instTreeCountSinceVirtual,
+				long instNodeCountSinceVirtual, double[] initialClassCount,
+				IademNumericAttributeObserver numericAttClassObserver, int limitNaiveBayes,
+				AbstractChangeDetector estimator, boolean onlyMultiwayTest, boolean onlyBinaryTest, Instance instance) {
+			super(tree, parent, instTreeCountSinceVirtual, instNodeCountSinceVirtual, initialClassCount,
+					numericAttClassObserver, estimator, onlyMultiwayTest, onlyBinaryTest, instance);
+			this.limitNaiveBayes = limitNaiveBayes;
+		}
+
+		@Override
+		public double[] getClassVotes(Instance inst) {
+			double[] votes;
+			if (instNodeCountSinceVirtual == 0 || instNodeCountSinceReal < limitNaiveBayes) {
+				votes = getMajorityClassVotes(inst);
+			} else {
+				votes = getNaiveBayesPrediction(inst);
+			}
+			return votes;
+		}
+
+		protected double[] getNaiveBayesPrediction(Instance inst) {
+			double[] classDist = getMajorityClassVotes(inst);
+			DoubleVector conditionalProbability = null;
+			for (int i = 0; i < virtualChildren.size(); i++) {
+				VirtualNode virtual = virtualChildren.get(i);
+				if (virtual != null && virtual.hasInformation()) {
+					double currentValue = inst.value(i);
+					conditionalProbability = virtual.computeConditionalProbability(currentValue);
+					if (conditionalProbability != null) {
+						for (int j = 0; j < classDist.length; j++) {
+							classDist[j] *= conditionalProbability.getValue(j);
+						}
+					}
+				}
+			}
+			double sum = 0.0;
+			for (int i = 0; i < classDist.length; i++) {
+				sum += classDist[i];
+			}
+			if (sum == 0.0) {
+				for (int i = 0; i < classDist.length; i++) {
+					classDist[i] = 1.0 / classDist.length;
+				}
+			} else {
+				for (int i = 0; i < classDist.length; i++) {
+					classDist[i] /= sum;
+				}
+			}
+			return classDist;
+		}
+	}
+
+	public class AdaptiveLeafNodeNBAdaptive extends AdaptiveLeafNodeNB {
+
+		private static final long serialVersionUID = 1L;
+		protected AbstractChangeDetector naiveBayesError, majorityClassError;
+
+		public AdaptiveLeafNodeNBAdaptive(Iadem3 tree, Node parent, long instancesProcessedByTheTree,
+				long instancesProcessedByThisLeaf, double[] classDist,
+				IademNumericAttributeObserver observadorContinuos, int naiveBayesLimit, boolean onlyMultiwayTest,
+				boolean onlyBinaryTest, AbstractChangeDetector estimator, Instance instance) {
+			super(tree, parent, instancesProcessedByTheTree, instancesProcessedByThisLeaf, classDist,
+					observadorContinuos, naiveBayesLimit, estimator, onlyMultiwayTest, onlyBinaryTest, instance);
+			this.naiveBayesError = (AbstractChangeDetector) estimator.copy();
+			this.majorityClassError = (AbstractChangeDetector) estimator.copy();
+		}
+
+		@Override
+		public double[] getClassVotes(Instance instance) {
+			double mean1 = this.naiveBayesError.getEstimation(), mean2 = this.majorityClassError.getEstimation();
+			if (mean1 > mean2) {
+				return getMajorityClassVotes(instance);
+			} else {
+				return getNaiveBayesPrediction(instance);
+			}
+		}
+
+		@Override
+		public Node learnFromInstance(Instance inst) {
+			double[] classVote = getMajorityClassVotes(inst);
+			double error = (Utils.maxIndex(classVote) == (int) inst.classValue()) ? 0.0 : 1.0;
+			this.majorityClassError.input(error);
+
+			classVote = getNaiveBayesPrediction(inst);
+			error = (Utils.maxIndex(classVote) == (int) inst.classValue()) ? 0.0 : 1.0;
+			this.naiveBayesError.input(error);
+
+			return super.learnFromInstance(inst);
+		}
+
+	}
+
+	public class AdaptiveLeafNodeNBKirkby extends AdaptiveLeafNodeNB {
+
+		private static final long serialVersionUID = 1L;
+		protected int naiveBayesError, majorityClassError;
+
+		public AdaptiveLeafNodeNBKirkby(Iadem3 tree, Node parent, long instancesProcessedByTheTree,
+				long instancesProcessedByThisLeaf, double[] classDist,
+				IademNumericAttributeObserver observadorContinuos, int naiveBayesLimit, boolean onlyMultiwayTest,
+				boolean onlyBinaryTest, AbstractChangeDetector estimator, Instance instance) {
+			super(tree, parent, instancesProcessedByTheTree, instancesProcessedByThisLeaf, classDist,
+					observadorContinuos, naiveBayesLimit, estimator, onlyMultiwayTest, onlyBinaryTest, instance);
+			this.naiveBayesError = 0;
+			this.majorityClassError = 0;
+		}
+
+		@Override
+		public double[] getClassVotes(Instance instance) {
+			if (naiveBayesError > majorityClassError) {
+				return getMajorityClassVotes(instance);
+			} else {
+				return getNaiveBayesPrediction(instance);
+			}
+		}
+
+		@Override
+		public Node learnFromInstance(Instance inst) {
+			double[] classVotes = getMajorityClassVotes(inst);
+			double error = (Utils.maxIndex(classVotes) == (int) inst.classValue()) ? 0.0 : 1.0;
+			this.majorityClassError += error;
+
+			classVotes = getNaiveBayesPrediction(inst);
+			error = (Utils.maxIndex(classVotes) == (int) inst.classValue()) ? 0.0 : 1.0;
+			this.naiveBayesError += error;
+
+			return super.learnFromInstance(inst);
+		}
+
+	}
+
+	public class AdaptiveLeafNodeWeightedVote extends AdaptiveLeafNodeNBAdaptive {
+
+		private static final long serialVersionUID = 1L;
+
+		public AdaptiveLeafNodeWeightedVote(Iadem3 tree, Node parent, long instTreeCountSinceVirtual,
+				long instNodeCountSinceVirtual, double[] classDist, IademNumericAttributeObserver observadorContinuos,
+				int naiveBayesLimit, boolean onlyMultiwayTest, boolean onlyBinaryTest, AbstractChangeDetector estimator,
+				Instance instance) {
+			super(tree, parent, instTreeCountSinceVirtual, instNodeCountSinceVirtual, classDist, observadorContinuos,
+					naiveBayesLimit, onlyMultiwayTest, onlyBinaryTest, estimator, instance);
+		}
+
+		@Override
+		public double[] getClassVotes(Instance instance) {
+			double NBweight = 1 - this.naiveBayesError.getEstimation(),
+					MCweight = 1 - this.majorityClassError.getEstimation();
+			double[] MC = getMajorityClassVotes(instance), NB = getNaiveBayesPrediction(instance),
+					votes = new double[MC.length];
+			for (int i = 0; i < MC.length; i++) {
+				votes[i] = MC[i] * MCweight + NB[i] * NBweight;
+			}
+			return votes;
+		}
+
+		protected boolean isSignificantlyGreaterThan(double mean1, double mean2, int n1, int n2) {
+			double m = 1.0 / n1 + 1.0 / n2, confidence = 0.001, log = Math.log(1.0 / confidence),
+					bound = Math.sqrt(m * log / 2);
+			return mean1 - mean2 > bound;
+		}
+	}
+
+	public class AdaptiveNominalVirtualNode extends NominalVirtualNode
+			implements Serializable, restartsVariablesAtDrift {
+
+		private static final long serialVersionUID = 1L;
+
+		protected AbstractChangeDetector estimador;
+
+		public AdaptiveNominalVirtualNode(Iadem3 tree, Node parent, int attID, boolean onlyMultiwayTest,
+				boolean onlyBinaryTest) {
+			super(tree, parent, attID, onlyMultiwayTest, onlyBinaryTest);
+		}
+
+		@Override
+		public Node learnFromInstance(Instance inst) {
+			double attValue = inst.value(attIndex);
+			if (Utils.isMissingValue(attValue)) {
+			} else {
+				updateCountersForChange(inst);
+			}
+			return super.learnFromInstance(inst);
+		}
+
+		private void updateCountersForChange(Instance inst) {
+			double[] classVotes = this.getClassVotes(inst);
+			boolean trueClass = (Utils.maxIndex(classVotes) == (int) inst.classValue());
+			if (estimador != null && ((Iadem3) this.tree).restartAtDrift) {
+				double error = trueClass == true ? 0.0 : 1.0;
+				this.estimador.input(error);
+				if (this.estimador.getChange()) {
+					this.resetVariablesAtDrift();
+				}
+			}
+		}
+
+		@Override
+		public SplitNode getNewSplitNode(long counter, Node parent, IademAttributeSplitSuggestion bestSplit,
+				Instance instance) {
+			AdaptiveSplitNode splitNode = new AdaptiveSplitNode((Iadem3) this.tree, parent, null,
+					((LeafNode) this.parent).getMajorityClassVotes(instance), bestSplit.splitTest,
+					((AdaptiveLeafNode) this.parent).estimator, (AdaptiveLeafNode) this.parent,
+					((Iadem3) this.tree).currentSplitState);
+
+			Node[] children;
+			if (bestSplit.splitTest instanceof NominalAttributeMultiwayTest) {
+				children = new Node[instance.attribute(this.attIndex).numValues()];
+				for (int i = 0; i < children.length; i++) {
+					long tmpConter = 0;
+					double[] newClassDist = new double[instance.attribute(instance.classIndex()).numValues()];
+					Arrays.fill(newClassDist, 0);
+					for (int j = 0; j < newClassDist.length; j++) {
+						DoubleVector tmpClassDist = nominalAttClassObserver.get(i);
+						double tmpAttClassCounter = tmpClassDist != null ? tmpClassDist.getValue(j) : 0.0;
+						newClassDist[j] = tmpAttClassCounter;
+						tmpConter += newClassDist[j];
+					}
+					children[i] = ((Iadem3) tree).newLeafNode(splitNode, counter, tmpConter, newClassDist, instance);
+				}
+			} else { // binary split
+				children = new Node[2];
+				IademNominalAttributeBinaryTest binarySplit = (IademNominalAttributeBinaryTest) bestSplit.splitTest;
+				double[] newClassDist = new double[instance.attribute(instance.classIndex()).numValues()];
+				double tmpCounter = 0;
+				Arrays.fill(newClassDist, 0);
+				DoubleVector classDist = nominalAttClassObserver.get(binarySplit.getAttValue());
+				for (int i = 0; i < newClassDist.length; i++) {
+					newClassDist[i] = classDist.getValue(i);
+					tmpCounter += classDist.getValue(i);
+				}
+				children[0] = ((Iadem3) tree).newLeafNode(splitNode, counter, (int) tmpCounter, newClassDist, instance);
+				// a la derecha...
+				tmpCounter = this.classValueDist.sumOfValues() - tmpCounter;
+				for (int i = 0; i < newClassDist.length; i++) {
+					newClassDist[i] = this.classValueDist.getValue(i) - newClassDist[i];
+				}
+				children[1] = ((Iadem3) tree).newLeafNode(splitNode, counter, (int) tmpCounter, newClassDist, instance);
+			}
+
+			splitNode.setChildren(children);
+
+			return splitNode;
+		}
+
+		@Override
+		public void resetVariablesAtDrift() {
+			attValueDist = new DoubleVector();
+			nominalAttClassObserver = new AutoExpandVector<>();
+			classValueDist = new DoubleVector();
+		}
+	}
+
+	public class AdaptiveNumericVirtualNode extends NumericVirtualNode
+			implements Serializable, restartsVariablesAtDrift {
+
+		private static final long serialVersionUID = 1L;
+		protected IademNumericAttributeObserver altAttClassObserver;
+		protected DoubleVector altClassDist;
+		protected AbstractChangeDetector estimator;
+
+		public AdaptiveNumericVirtualNode(Iadem3 tree, Node parent, int attID,
+				IademNumericAttributeObserver observadorContinuos) {
+			super(tree, parent, attID, observadorContinuos);
+		}
+
+		@Override
+		public Node learnFromInstance(Instance inst) {
+			updateCounters(inst);
+			return super.learnFromInstance(inst);
+		}
+
+		private void updateCounters(Instance inst) {
+			double[] classVotes = this.getClassVotes(inst);
+			boolean correct = (Utils.maxIndex(classVotes) == (int) inst.classValue());
+			if (this.estimator != null && ((Iadem3) this.tree).restartAtDrift) {
+				double error = correct == true ? 0.0 : 1.0;
+				this.estimator.input(error);
+				if (this.estimator.getChange()) {
+					this.resetVariablesAtDrift();
+				}
+			}
+		}
+
+		private long sum(long[] arr) {
+			long s = 0;
+			for (int i = 0; i < arr.length; i++) {
+				s += arr[i];
+			}
+			return s;
+		}
+
+		@Override
+		public SplitNode getNewSplitNode(long counter, Node parent, IademAttributeSplitSuggestion bestSplit,
+				Instance instance) {
+			double[] cutPoints = new double[] { bestCutPoint };
+			Node[] children = new Node[2]; // a binary split
+			long[] newClassDist = numericAttClassObserver.getLeftClassDist(bestCutPoint);
+			long sumClassDist = numericAttClassObserver.getValueCount();
+			long[] sumAttClassDist = numericAttClassObserver.getClassDist();
+			boolean equalsPassesTest = true;
+			if (this.numericAttClassObserver instanceof IademVFMLNumericAttributeClassObserver) {
+				equalsPassesTest = false;
+			}
+			AdaptiveSplitNode splitNode = new AdaptiveSplitNode((Iadem3) this.tree, parent, null,
+					((LeafNode) this.parent).getMajorityClassVotes(instance),
+					new NumericAttributeBinaryTest(this.attIndex, cutPoints[0], equalsPassesTest),
+					((AdaptiveLeafNode) this.parent).estimator, (AdaptiveLeafNode) this.parent,
+					((Iadem3) this.tree).currentSplitState);
+			long leftClassDist = sum(newClassDist);
+			long rightClassDist = sumClassDist - leftClassDist;
+			double[] newLeftClassDist = new double[instance.attribute(instance.classIndex()).numValues()];
+			double[] newRightClassDist = new double[instance.attribute(instance.classIndex()).numValues()];
+
+			Arrays.fill(newLeftClassDist, 0);
+			Arrays.fill(newRightClassDist, 0);
+
+			for (int i = 0; i < newClassDist.length; i++) {
+				newLeftClassDist[i] = newClassDist[i];
+				newRightClassDist[i] = sumAttClassDist[i] - newLeftClassDist[i];
+			}
+			splitNode.setChildren(null);
+			children[0] = ((Iadem3) tree).newLeafNode(splitNode, counter, leftClassDist, newLeftClassDist, instance);
+			children[1] = ((Iadem3) tree).newLeafNode(splitNode, counter, rightClassDist, newRightClassDist, instance);
+			splitNode.setChildren(children);
+			return splitNode;
+		}
+
+		@Override
+		public void resetVariablesAtDrift() {
+			this.bestSplitSuggestion = null;
+			this.heuristicMeasureUpdated = false;
+			numericAttClassObserver.reset();
+			classValueDist = new DoubleVector();
+		}
+	}
+
+	public class AdaptiveSplitNode extends SplitNode implements Serializable {
+
+		private static final long serialVersionUID = 1L;
+
+		protected AutoExpandVector<Iadem3Subtree> alternativeTree = new AutoExpandVector<>();
+		// Detector de cambio de concepto
+		protected AbstractChangeDetector estimator;
+
+		protected int causeOfSplit;
+
+		protected AdaptiveLeafNode leaf;
+
+		public AdaptiveSplitNode(Iadem3 tree, Node parent, Node[] child, double[] freq,
+				InstanceConditionalTest splitTest, AbstractChangeDetector estimator, AdaptiveLeafNode predictionLeaf,
+				int causeOfSplit) {
+			super(tree, parent, child, freq, splitTest);
+			if (estimator != null) {
+				this.estimator = (AbstractChangeDetector) estimator.copy();
+			} else {
+				this.estimator = null;
+			}
+			this.leaf = predictionLeaf;
+			this.leaf.setSplit(false);
+			this.causeOfSplit = causeOfSplit;
+		}
+
+		@Override
+		public Node learnFromInstance(Instance instance) {
+
+			try {
+				double thisError = this.estimator.getEstimation(), thisSize = this.estimator.getDelay();
+				double leafError = this.leaf.estimator.getEstimation(), leafSize = this.leaf.estimator.getDelay();
+				double m = 1.0 / thisSize + 1.0 / leafSize;
+				double delta = 0.0001;
+				double bound = Math.sqrt(m * Math.log(2.0 / delta) / 2.0);
+				double diff = thisError - leafError;
+				if (diff > bound && thisSize > 600 && leafSize > 600/**/) {
+					prune();
+					return this.leaf;
+				} else if (-diff > bound) {
+					this.leaf.restartVariablesAtDrift();
+					this.leaf.estimator = (AbstractChangeDetector) this.leaf.estimator.copy();
+				}
+				Node node;
+				boolean rightPredicted = ((Iadem3) this.tree).lastPredictionInLeaf == instance.classValue();
+				node = checkAlternativeSubtrees(rightPredicted, instance);
+				if (node == null) {
+					// no subtree change
+					for (Iadem3Subtree subtree : this.alternativeTree) {
+						try {
+							subtree.learnFromInstance(instance);
+							subtree.incrNumberOfInstancesProcessed();
+						} catch (IademException ex) {
+							Logger.getLogger(AdaptiveSplitNode.class.getName()).log(Level.SEVERE, null, ex);
+						}
+					}
+					this.leaf.learnFromInstance(instance);
+					return super.learnFromInstance(instance);
+				} else {
+					// subtree change
+					return node.learnFromInstance(instance);
+				}
+			} catch (IademException ex) {
+				Logger.getLogger(AdaptiveSplitNode.class.getName()).log(Level.SEVERE, null, ex);
+			}
+			return null;
+		}
+
+		private Node checkAlternativeSubtrees(boolean acierto, Instance instance) throws IademException {
+			if (this.estimator != null) {
+				double loss = (acierto == true ? 0.0 : 1.0);
+				estimator.input(loss);
+				if (estimator.getChange()) {
+					this.createTree(instance);
+				}
+				for (int i = 0; i < this.alternativeTree.size(); i++) {
+					Iadem3Subtree subtree = alternativeTree.get(i);
+					double treeError = subtree.estimacionValorMedio(), thisError = this.estimator.getEstimation();
+					double bound = IademCommonProcedures.AverageComparitionByHoeffdingCorollary(
+							this.estimator.getDelay(), subtree.windowWidth(), 1e-4);
+
+					if (thisError - treeError > bound/**/) {
+						((Iadem3) this.tree).interchangedTrees++;
+						return changeTrees(i);
+					} else if (isUseless(i)) {
+						((Iadem3) this.tree).updateNumberOfLeaves(-subtree.getNumberOfLeaves());
+						((Iadem3) this.tree).updateNumberOfNodes(-subtree.getNumberOfNodes());
+						((Iadem3) this.tree).updateNumberOfNodesSplitByTieBreaking(-subtree.numSplitsByBreakingTies);
+						i--;
+					} else if (this.estimator.getDelay() > 6000 && subtree.windowWidth() > 6000/**/) {
+						{
+							if (treeError - thisError > bound) {
+								this.alternativeTree.remove(i);
+								// update number of nodes
+								((Iadem3) this.tree).updateNumberOfLeaves(-subtree.getNumberOfLeaves());
+								((Iadem3) this.tree).updateNumberOfNodes(-subtree.getNumberOfNodes());
+								((Iadem3) this.tree)
+										.updateNumberOfNodesSplitByTieBreaking(-subtree.numSplitsByBreakingTies);
+								i--;
+							} else /**/ {
+								int[] countMain = new int[3], countAlt = new int[3];
+								for (Node child : this.children) {
+									child.getNumberOfNodes(countMain);
+								}
+								subtree.getNumberOfNodes(countAlt);/**/
+
+								if (countMain[0] + countMain[1] + 1 > countAlt[0] + countAlt[1]) {
+									return changeTrees(i);
+								} else {
+									this.alternativeTree.remove(i);
+									// update number of nodes
+									((Iadem3) this.tree).updateNumberOfLeaves(-subtree.getNumberOfLeaves());
+									((Iadem3) this.tree).updateNumberOfNodes(-subtree.getNumberOfNodes());
+									((Iadem3) this.tree)
+											.updateNumberOfNodesSplitByTieBreaking(-subtree.numSplitsByBreakingTies);
+									i--;
+								}
+							}
+						} /**/
+
+					}
+
+				}
+			}
+			return null;
+		}
+
+		public boolean isUseless(int i) {
+			boolean removed = false;
+			Iadem3Subtree subtree = this.alternativeTree.get(i);
+			if (subtree.getTreeRoot() instanceof AdaptiveSplitNode) /**/ {
+				// change if it already has an alternative subtree
+				AdaptiveSplitNode splitNode = ((AdaptiveSplitNode) subtree.getTreeRoot());
+
+				int nMain = (int) this.estimator.getDelay(), nAlt = (int) subtree.getEstimador().getDelay();
+				double errorMain = this.estimator.getEstimation(), errorAlt = subtree.getEstimador().getEstimation();
+				double errorDifference = errorAlt - errorMain, absError = Math.abs(errorDifference);
+				if (!removed && nMain > 0 && nAlt > 0) {
+					double m = 1.0 / nMain + 1.0 / nAlt;
+					double delta = 1e-4;
+					double bound = Math.sqrt(m * Math.log(2.0 / delta) / 2.0);
+					if (errorDifference > bound) {
+						// alternative tree is too inaccurate
+						this.alternativeTree.remove(i);
+						removed = true;
+					}
+				}
+				if (!removed) {
+					InstanceConditionalTest condTest = splitNode.splitTest;
+					if (condTest instanceof IademNominalAttributeBinaryTest
+							&& this.splitTest instanceof IademNominalAttributeBinaryTest) {
+						IademNominalAttributeBinaryTest altTest = (IademNominalAttributeBinaryTest) condTest,
+								mainTest = (IademNominalAttributeBinaryTest) this.splitTest;
+						if (mainTest.getAttValue() == altTest.getAttValue()
+								&& mainTest.getAttsTestDependsOn()[0] == altTest.getAttsTestDependsOn()[0]) {
+							this.alternativeTree.remove(i);
+							removed = true;
+						}
+					} else if (condTest instanceof NominalAttributeMultiwayTest
+							&& this.splitTest instanceof NominalAttributeMultiwayTest) {
+						NominalAttributeMultiwayTest altTest = (NominalAttributeMultiwayTest) condTest,
+								mainTest = (NominalAttributeMultiwayTest) this.splitTest;
+						if (mainTest.getAttsTestDependsOn()[0] == altTest.getAttsTestDependsOn()[0]) {
+							this.alternativeTree.remove(i);
+							removed = true;
+						}
+					} else if (condTest instanceof NumericAttributeBinaryTest
+							&& this.splitTest instanceof NumericAttributeBinaryTest) {
+						NumericAttributeBinaryTest altTest = (NumericAttributeBinaryTest) condTest,
+								mainTest = (NumericAttributeBinaryTest) this.splitTest;
+						if (mainTest.getAttsTestDependsOn()[0] == altTest.getAttsTestDependsOn()[0]
+								&& mainTest.getSplitValue() == altTest.getSplitValue()) {
+							this.alternativeTree.remove(i);
+							removed = true;
+						}
+					}
+				}
+			}
+			return removed;
+		}
+
+		private Node changeTrees(int index) {
+			for (int i = 0; i < this.alternativeTree.size(); i++) {
+				if (i != index) {
+					Iadem3Subtree subtree = this.alternativeTree.get(i);
+					((Iadem3) this.tree).updateNumberOfLeaves(-subtree.getNumberOfLeaves());
+					((Iadem3) this.tree).updateNumberOfNodes(-subtree.getNumberOfNodes());
+					((Iadem3) this.tree).updateNumberOfNodesSplitByTieBreaking(-subtree.numSplitsByBreakingTies);
+				}
+			}
+			Iadem3Subtree subtree = this.alternativeTree.get(index);
+			// rest nodes of this main tree
+			int count[] = new int[3];
+			super.getNumberOfNodes(count);
+			if (this.causeOfSplit == ((Iadem3) this.tree).SPLIT_BY_TIE_BREAKING) {
+				count[2]++;
+			}
+			((Iadem3) this.tree).updateNumberOfLeaves(-count[1]);
+			((Iadem3) this.tree).updateNumberOfNodes(-count[0] - count[1]);
+			((Iadem3) this.tree).updateNumberOfNodesSplitByTieBreaking(-count[2]);
+			//
+			AdaptiveSplitNode tmpParent = (AdaptiveSplitNode) this.parent;
+			Node newNode = subtree.getTreeRoot();
+			((Iadem3) tree).newTreeChange();
+			if (tmpParent == null) {
+				((Iadem3) tree).copyTree(subtree);
+			} else {
+				for (int i = 0; i < tmpParent.children.size(); i++) {
+					if (tmpParent.children.get(i) == this) {
+						tmpParent.children.set(i, newNode);
+						newNode.parent = tmpParent;
+					}
+				}
+			}
+			updateAttributes(newNode);
+			if (newNode instanceof AdaptiveSplitNode) {
+				AdaptiveSplitNode splitNode = (AdaptiveSplitNode) newNode;
+				for (Iadem3Subtree currentSubtree : splitNode.alternativeTree) {
+					updateSubtreeLevel(currentSubtree.getTreeRoot());
+				}
+			}
+			return newNode;
+		}
+
+		void updateAttributes(Node newNode) {
+			if (newNode == null) {
+				return;
+			}
+			newNode.setTree(this.tree);
+			if (newNode instanceof AdaptiveSplitNode) {
+				AdaptiveSplitNode splitNode = (AdaptiveSplitNode) newNode;
+				splitNode.leaf.setTree(this.tree);
+				for (Node child : splitNode.children) {
+					updateAttributes(child);
+				}
+			} else if (newNode instanceof AdaptiveLeafNode) {
+				AdaptiveLeafNode leafNode = (AdaptiveLeafNode) newNode;
+				AutoExpandVector<VirtualNode> virtualChildren = leafNode.getVirtualChildren();
+				for (VirtualNode child : virtualChildren) {
+					if (child != null) {
+						child.setTree(this.tree);
+					}
+				}
+			}
+		}
+
+		protected void updateSubtreeLevel(Node node) {
+			if (node != null) {
+				((Iadem3) node.getTree()).treeLevel--;
+				if (node instanceof AdaptiveSplitNode) {
+					AdaptiveSplitNode splitNode = (AdaptiveSplitNode) node;
+					for (Node child : splitNode.children) {
+						updateSubtreeLevelAux(child);
+					}
+					for (Iadem3Subtree subtree : splitNode.alternativeTree) {
+						updateSubtreeLevel(subtree.getTreeRoot());
+					}
+				}
+			}
+		}
+
+		protected void updateSubtreeLevelAux(Node node) {
+			if (node != null) {
+				if (node instanceof AdaptiveSplitNode) {
+					AdaptiveSplitNode splitNode = (AdaptiveSplitNode) node;
+					// update level in alternative subtrees
+					for (Iadem3Subtree subtree : splitNode.alternativeTree) {
+						updateSubtreeLevel(subtree.getTreeRoot());
+					}
+					for (Node child : splitNode.children) {
+						updateSubtreeLevelAux(child);
+					}
+				}
+			}
+		}
+
+		void createTree(Instance instance) throws IademException {
+			Iadem3 iadem3Tree = ((Iadem3) this.tree);
+			if (iadem3Tree.canCreateSubtree()) {
+				int maxTreeLevel = iadem3Tree.getMaxNestingLevels();
+				int maxAltSubtrees = iadem3Tree.getMaxAltSubtreesPerNode();
+				if ((maxTreeLevel == -1 || iadem3Tree.getTreeLevel() < maxTreeLevel)
+						&& (maxAltSubtrees == -1 || this.alternativeTree.size() < maxAltSubtrees)) {
+					if (this.estimator != null) {
+						Iadem3Subtree subtree = new Iadem3Subtree(this, iadem3Tree.getTreeLevel() + 1,
+								(Iadem3) this.tree, instance);
+						this.alternativeTree.add(subtree);
+						((Iadem3) tree).setNewTree();
+					}
+				}
+			}
+		}
+
+		public int getNumTrees() {
+			int trees = this.alternativeTree.size() == 0 ? 0 : 1;
+			for (Node child : children) {
+				if (child instanceof AdaptiveSplitNode) {
+					trees += ((AdaptiveSplitNode) child).getNumTrees();
+				}
+			}
+			for (Iadem3Subtree subtree : this.alternativeTree) {
+				if (subtree.getTreeRoot() instanceof AdaptiveSplitNode) {
+					AdaptiveSplitNode node = (AdaptiveSplitNode) subtree.getTreeRoot();
+					trees += node.getNumTrees();
+				}
+			}
+			return trees;
+		}
+
+		@Override
+		public double[] getClassVotes(Instance observacion) {
+			double[] classDist = this.leaf.getClassVotes(observacion);
+
+			double thisError = this.estimator.getEstimation();
+			double leafError = this.leaf.estimator.getEstimation();
+
+			int childIndex = instanceChildIndex(observacion);
+			if (childIndex >= 0 && thisError < leafError) {
+				Node hijo = getChild(childIndex);
+				classDist = hijo.getClassVotes(observacion);
+			}
+
+			for (Iadem3Subtree subtree : this.alternativeTree) {
+				double[] tmp = subtree.getClassVotes(observacion);
+				double altWeight = 1.0 - subtree.estimacionValorMedio();
+				for (int j = 0; j < classDist.length; j++) {
+					classDist[j] = classDist[j] + tmp[j] * altWeight;
+				}
+			}
+			return classDist;
+		}
+
+		@Override
+		public int getSubtreeNodeCount() {
+			int tmp = super.getSubtreeNodeCount();
+			for (Iadem3Subtree subtree : this.alternativeTree) {
+				tmp += subtree.getTreeRoot().getSubtreeNodeCount();
+			}
+			return tmp;
+		}
+
+		public double getErrorEstimation() {
+			return this.estimator.getEstimation();
+		}
+
+		@Override
+		public void getNumberOfNodes(int[] count) {
+			for (Iadem3Subtree tree : this.alternativeTree) {
+				tree.getNumberOfNodes(count);
+			}
+			if (this.causeOfSplit == ((Iadem3) this.tree).SPLIT_BY_TIE_BREAKING) {
+				count[2]++;
+			}
+			super.getNumberOfNodes(count);
+		}
+
+		public int getNumberOfSubtrees() {
+			int count = this.alternativeTree.size();
+			for (Iadem3Subtree subtree : this.alternativeTree) {
+				count += ((Iadem3) subtree).getNumberOfSubtrees();
+			}
+			for (Node child : children) {
+				if (child instanceof AdaptiveSplitNode) {
+					count += ((AdaptiveSplitNode) child).getNumberOfSubtrees();
+				}
+			}
+			return count;
+		}
+
+		private void prune() {
+			this.leaf.setSplit(true);
+			for (Node node = this.parent; node != null; node = node.parent) {
+				((AdaptiveSplitNode) node).leaf.restartVariablesAtDrift();
+				this.leaf.estimator = (AbstractChangeDetector) this.leaf.estimator.copy();
+			}
+			// update tree
+			this.leaf.setTree(this.tree);
+			AutoExpandVector<VirtualNode> nodeList = this.leaf.getVirtualChildren();
+			for (VirtualNode node : nodeList) {
+				if (node != null) {
+					node.setTree(this.tree);
+				}
+			}
+
+			this.leaf.setParent(this.parent);
+
+			if (this.parent == null) {
+				this.tree.setTreeRoot(this.leaf);
+			} else {
+				((SplitNode) this.parent).changeChildren(this, this.leaf);
+			}
+
+			int count[] = new int[3];
+			getNumberOfNodes(count);
+
+			((Iadem3) this.tree).updateNumberOfLeaves(-count[1] + 1);
+			((Iadem3) this.tree).updateNumberOfNodes(-count[0] - count[1] + 1);
+			((Iadem3) this.tree).updateNumberOfNodesSplitByTieBreaking(-count[2]);
+		}
+	}
+
+	public interface restartsVariablesAtDrift {
+
+		void resetVariablesAtDrift();
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/trees/iadem/Iadem3Subtree.java b/moa/src/main/java/moa/learners/predictors/trees/iadem/Iadem3Subtree.java
new file mode 100644
index 000000000..715a80119
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/trees/iadem/Iadem3Subtree.java
@@ -0,0 +1,158 @@
+/*
+ *    Subtree.java
+ *
+ *    @author Isvani Frías-Blanco
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.predictors.trees.iadem;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.learners.predictors.core.driftdetection.AbstractChangeDetector;
+
+/**
+ *
+ * @author Isvani Frías Blanco (ifriasb at hotmail dot com)
+ */
+public class Iadem3Subtree extends Iadem3 {
+
+	protected static final long serialVersionUID = 1L;
+	protected AbstractChangeDetector errorEstimator;
+	protected Node nodo;
+
+	protected Iadem3 mainTree;
+
+	public Iadem3Subtree(Node node, int treeLevel, Iadem3 mainTree, Instance instance) {
+		// subtree configuration from main tree
+		this.numericEstimatorOption.setValueViaCLIString(mainTree.numericEstimatorOption.getValueAsCLIString());
+		this.gracePeriodOption.setValue(mainTree.gracePeriodOption.getValue());
+		this.splitCriterionOption.setChosenIndex(mainTree.splitCriterionOption.getChosenIndex());
+		this.splitConfidenceOption.setValue(mainTree.splitConfidenceOption.getValue());
+		this.splitTestsOption.setChosenIndex(mainTree.splitTestsOption.getChosenIndex());
+		this.leafPredictionOption.setChosenIndex(mainTree.leafPredictionOption.getChosenIndex());
+		this.driftDetectionMethodOption.setValueViaCLIString(mainTree.driftDetectionMethodOption.getValueAsCLIString());
+		this.attributeDiferentiation.setValue(mainTree.attributeDiferentiation.getValue());
+		this.maxNestingLevelOption.setValue(mainTree.maxNestingLevelOption.getValue());
+		this.maxSubtreesPerNodeOption.setValue(mainTree.maxSubtreesPerNodeOption.getValue());
+
+		// subtree inicializations
+		this.estimator = mainTree.getEstimatorCopy();
+		this.errorEstimator = mainTree.getEstimatorCopy();
+		this.nodo = node;
+		this.mainTree = mainTree;
+		this.mainTree.updateNumberOfLeaves(1);
+		this.mainTree.updateNumberOfNodes(1);
+		createRoot(instance);
+	}
+
+	@Override
+	public AbstractChangeDetector getEstimatorCopy() {
+		return this.mainTree.getEstimatorCopy();
+	}
+
+	@Override
+	protected IademNumericAttributeObserver newNumericClassObserver() {
+		return this.mainTree.newNumericClassObserver();
+	}
+
+	@Override
+	public void learnFromInstance(Instance instance) throws IademException {
+		getClassVotes(instance);
+		getClassVotesFromLeaf(instance);
+
+		boolean rightPredicted = this.lastPredictionInLeaf == instance.classValue();
+		double lossValue = (rightPredicted == true ? 0.0 : 1.0);
+		this.errorEstimator.input(lossValue);
+
+		treeRoot.learnFromInstance(instance);
+	}
+
+	@Override
+	public boolean canCreateSubtree() {
+		return this.mainTree.canCreateSubtree();
+	}
+
+	public double estimacionValorMedio() {
+		return this.errorEstimator != null ? this.errorEstimator.getEstimation() : -1;
+	}
+
+	public int windowWidth() {
+		return (int) (this.errorEstimator != null ? this.errorEstimator.getDelay() : 0);
+	}
+
+	public AbstractChangeDetector getEstimador() {
+		return errorEstimator;
+	}
+
+	public void setEstimador(AbstractChangeDetector estimador) {
+		this.errorEstimator = estimador;
+	}
+
+	@Override
+	public void setNewTree() {
+		((Iadem3) this.nodo.getTree()).setNewTree();
+	}
+
+	@Override
+	public void newDeletedTree() {
+		((Iadem3) this.nodo.getTree()).newDeletedTree();
+	}
+
+	@Override
+	public void newTreeChange() {
+		((Iadem3) this.nodo.getTree()).newTreeChange();
+	}
+
+	@Override
+	protected Iadem3 getMainTree() {
+		return this.mainTree;
+	}
+
+	@Override
+	public void newSplit(int numOfLeaves) {
+		this.numberOfLeaves += numOfLeaves - 1;
+		this.numberOfNodes += numOfLeaves;
+		this.mainTree.newSplit(numOfLeaves);
+	}
+
+	@Override
+	public void updateNumberOfLeaves(int amount) {
+		this.numberOfLeaves += amount;
+		this.mainTree.updateNumberOfLeaves(amount);
+	}
+
+	@Override
+	public void updateNumberOfNodes(int amount) {
+		this.numberOfNodes += amount;
+		this.mainTree.updateNumberOfNodes(amount);
+	}
+
+	@Override
+	public void updateNumberOfNodesSplitByTieBreaking(int amount) {
+		this.numSplitsByBreakingTies += amount;
+		this.mainTree.updateNumberOfNodesSplitByTieBreaking(amount);
+	}
+
+	@Override
+	public void addSubtree(Iadem3Subtree subtree) {
+		this.mainTree.addSubtree(subtree);
+	}
+
+	@Override
+	public void removeSubtree(Iadem3Subtree subtree) {
+		this.mainTree.removeSubtree(subtree);
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/trees/iadem/IademAttributeSplitSuggestion.java b/moa/src/main/java/moa/learners/predictors/trees/iadem/IademAttributeSplitSuggestion.java
similarity index 53%
rename from moa/src/main/java/moa/classifiers/trees/iadem/IademAttributeSplitSuggestion.java
rename to moa/src/main/java/moa/learners/predictors/trees/iadem/IademAttributeSplitSuggestion.java
index 27c8fd682..e3f2298f0 100644
--- a/moa/src/main/java/moa/classifiers/trees/iadem/IademAttributeSplitSuggestion.java
+++ b/moa/src/main/java/moa/learners/predictors/trees/iadem/IademAttributeSplitSuggestion.java
@@ -2,7 +2,7 @@
  *    IademAttributeSplitSuggestion.java
  *
  *    @author Isvani Frias-Blanco
- * 
+ *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
@@ -14,28 +14,26 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.classifiers.trees.iadem;
+package moa.learners.predictors.trees.iadem;
 
-import moa.classifiers.core.AttributeSplitSuggestion;
-import moa.classifiers.core.conditionaltests.InstanceConditionalTest;
+import moa.learners.predictors.core.AttributeSplitSuggestion;
+import moa.learners.predictors.core.conditionaltests.InstanceConditionalTest;
 
 public class IademAttributeSplitSuggestion extends AttributeSplitSuggestion {
-    private static final long serialVersionUID = 1L;
-    protected double meritLowerBound;
+	private static final long serialVersionUID = 1L;
+	protected double meritLowerBound;
 
-    public IademAttributeSplitSuggestion(InstanceConditionalTest splitTest, 
-            double[][] resultingClassDistributions, 
-            double merit,
-            double infMerit) {
-        super(splitTest, resultingClassDistributions, merit);
-        this.meritLowerBound = infMerit;
-    }
+	public IademAttributeSplitSuggestion(InstanceConditionalTest splitTest, double[][] resultingClassDistributions,
+			double merit, double infMerit) {
+		super(splitTest, resultingClassDistributions, merit);
+		this.meritLowerBound = infMerit;
+	}
 
-    public double getMeritLowerBound() {
-        return this.meritLowerBound;
-    }
+	public double getMeritLowerBound() {
+		return this.meritLowerBound;
+	}
 }
diff --git a/moa/src/main/java/moa/learners/predictors/trees/iadem/IademCommonProcedures.java b/moa/src/main/java/moa/learners/predictors/trees/iadem/IademCommonProcedures.java
new file mode 100644
index 000000000..2c51f968e
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/trees/iadem/IademCommonProcedures.java
@@ -0,0 +1,161 @@
+/*
+ *    IademCommonProcedures.java
+ *
+ *    @author José del Campo-Ávila
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.predictors.trees.iadem;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+
+public class IademCommonProcedures implements Serializable {
+
+	private static final long serialVersionUID = 1L;
+	private static double confidence;
+	private static double ln_2_div_confidence;
+	private static double square_ln_2_div_confianza;
+
+	public IademCommonProcedures(double confidence) {
+		IademCommonProcedures.confidence = confidence;
+		IademCommonProcedures.ln_2_div_confidence = Math.log(2.0 / confidence);
+		IademCommonProcedures.square_ln_2_div_confianza = ln_2_div_confidence * ln_2_div_confidence;
+	}
+
+	public static double AverageComparitionByHoeffdingCorollary(double n, double n1, double alfa) {
+		double m = 1.0 / n + 1.0 / n1;
+		double bound = Math.sqrt(m * Math.log(1.0 / alfa) / 2.0);
+		return bound;
+	}
+
+	public static double getConfidence() {
+		return confidence;
+	}
+
+	public static void setConfidence(double confianza) {
+		IademCommonProcedures.confidence = confianza;
+		IademCommonProcedures.ln_2_div_confidence = Math.log(2.0 / confianza);
+		IademCommonProcedures.square_ln_2_div_confianza = ln_2_div_confidence * ln_2_div_confidence;
+	}
+
+	public static double getIADEM_HoeffdingBound(double average, double n) {
+		return computeBound(average, n);
+	}
+
+	public static double log(double base, double num) {
+		return (Math.log(num) / Math.log(base));
+	}
+
+	public static void insertLotsHoles(ArrayList<Double> lots, ArrayList<Integer> holes, double inf, double sup) {
+		if (inf != sup) {
+			int currentPos = 1;
+			if (inf == 0.0) {
+				for (int i = 0; i < holes.size(); i++) {
+					int aux = holes.get(i);
+					aux++;
+					holes.set(i, aux);
+				}
+			} else {
+				while (inf > lots.get(currentPos)) {
+					currentPos++;
+				}
+				if (inf < lots.get(currentPos)) {
+					lots.add(currentPos, inf);
+					holes.add(currentPos, (holes.get(currentPos - 1) + 1));
+				} else {
+					int aux = holes.get(currentPos);
+					aux++;
+					holes.set(currentPos, aux);
+				}
+				for (int i = (currentPos + 1); i < holes.size(); i++) {
+					int aux = holes.get(i);
+					aux++;
+					holes.set(i, aux);
+				}
+			}
+			while (sup > lots.get(currentPos)) {
+				currentPos++;
+			}
+			if (sup < lots.get(currentPos)) {
+				lots.add(currentPos, sup);
+				holes.add(currentPos, (holes.get(currentPos - 1) - 1));
+			} else if (currentPos < holes.size()) {
+				int aux = holes.get(currentPos);
+				aux--;
+				holes.set(currentPos, aux);
+			}
+			for (int i = (currentPos + 1); i < holes.size(); i++) {
+				int aux = holes.get(i);
+				aux--;
+				holes.set(i, aux);
+			}
+		}
+	}
+
+	public static double computeLevel(ArrayList<Double> lots, ArrayList<Integer> holes, double amount) {
+		double level = 0.0;
+		int currentLot = 0;
+		double localAmount = amount;
+		double upperBound, lowerBound, nLot, fullAmount;
+		if (localAmount == 0.0) {
+			if ((holes.size() == 1) && (holes.get(0) == 0)) {
+				level = 0.0;
+			} else {
+				while ((currentLot < holes.size()) && (holes.get(currentLot) == 0)) {
+					currentLot++;
+				}
+				level = lots.get(currentLot);
+			}
+		} else {
+			while (localAmount > 0.0) {
+				upperBound = lots.get(currentLot + 1);
+				lowerBound = lots.get(currentLot);
+				nLot = holes.get(currentLot);
+				fullAmount = (upperBound - lowerBound) * nLot;
+				if (localAmount >= fullAmount) {
+					localAmount -= fullAmount;
+					level = lots.get(currentLot + 1);
+				} else {
+					level += (localAmount / (double) holes.get(currentLot));
+					localAmount = 0.0;
+				}
+				currentLot++;
+			}
+		}
+		return level;
+	}
+
+	public static double computeBound(double average, double n) {
+		double bound;
+		double hoeffdingBound;
+		double chernoffBound;
+		if (n == 0.0) {
+			bound = 1.0;
+		} else {
+			hoeffdingBound = Math.sqrt((1.0 / (2.0 * n)) * ln_2_div_confidence);
+			if (average >= (1.0 / 6.0)) {
+				bound = hoeffdingBound;
+			} else {
+				chernoffBound = ((3.0 * ln_2_div_confidence)
+						+ (Math.sqrt((9.0 * square_ln_2_div_confianza) + (12.0 * n * average * ln_2_div_confidence))))
+						/ (2.0 * n);
+				bound = Math.min(Math.min(chernoffBound, hoeffdingBound), 1.0);
+			}
+		}
+		return bound;
+	}
+}
diff --git a/moa/src/main/java/moa/classifiers/trees/iadem/IademException.java b/moa/src/main/java/moa/learners/predictors/trees/iadem/IademException.java
similarity index 56%
rename from moa/src/main/java/moa/classifiers/trees/iadem/IademException.java
rename to moa/src/main/java/moa/learners/predictors/trees/iadem/IademException.java
index 2aca98615..c6a77bb57 100644
--- a/moa/src/main/java/moa/classifiers/trees/iadem/IademException.java
+++ b/moa/src/main/java/moa/learners/predictors/trees/iadem/IademException.java
@@ -2,7 +2,7 @@
  *    IademException.java
  *
  *    @author José del Campo-Ávila
- * 
+ *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
@@ -14,30 +14,29 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.classifiers.trees.iadem;
+package moa.learners.predictors.trees.iadem;
 
 import java.io.Serializable;
 
 public class IademException extends Exception implements Serializable {
-    private static final long serialVersionUID = 1L;
-    private final String myClass;
-    private final String myMethod;
-    private final String myExplanation;
-    
-    public IademException(String myClass, String myMethod, String myExplanation) {
-        super();
-        this.myClass = myClass;
-        this.myMethod = myMethod;
-        this.myExplanation = myExplanation;
-    }
-    
-    
-    @Override
-    public String getMessage() {
-        return "Error in " + this.myClass + "." + this.myMethod + ": " + this.myExplanation;
-    }
+	private static final long serialVersionUID = 1L;
+	private final String myClass;
+	private final String myMethod;
+	private final String myExplanation;
+
+	public IademException(String myClass, String myMethod, String myExplanation) {
+		super();
+		this.myClass = myClass;
+		this.myMethod = myMethod;
+		this.myExplanation = myExplanation;
+	}
+
+	@Override
+	public String getMessage() {
+		return "Error in " + this.myClass + "." + this.myMethod + ": " + this.myExplanation;
+	}
 }
diff --git a/moa/src/main/java/moa/learners/predictors/trees/iadem/IademGaussianNumericAttributeClassObserver.java b/moa/src/main/java/moa/learners/predictors/trees/iadem/IademGaussianNumericAttributeClassObserver.java
new file mode 100644
index 000000000..e8a215013
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/trees/iadem/IademGaussianNumericAttributeClassObserver.java
@@ -0,0 +1,219 @@
+/*
+ *    IademGaussianNumericAttributeClassObserver.java
+ *
+ *    @author Isvani Frias-Blanco
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.predictors.trees.iadem;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import moa.core.AutoExpandVector;
+import moa.core.DoubleVector;
+import moa.core.GaussianEstimator;
+import moa.learners.predictors.core.attributeclassobservers.GaussianNumericAttributeClassObserver;
+import weka.core.Utils;
+
+public class IademGaussianNumericAttributeClassObserver extends GaussianNumericAttributeClassObserver
+		implements IademNumericAttributeObserver {
+
+	private static final long serialVersionUID = 1L;
+	private int valueCount = 0;
+	protected DoubleVector classDist = new DoubleVector();
+
+	public IademGaussianNumericAttributeClassObserver() {
+		super();
+	}
+
+	public IademGaussianNumericAttributeClassObserver(int maxTuples) {
+		super();
+		this.numBinsOption.setValue(maxTuples);
+	}
+
+	@Override
+	public void addValue(double attValue, int classValue, double weight) {
+		if (Utils.isMissingValue(attValue)) {
+		} else {
+			this.valueCount += weight;
+			this.classDist.addToValue(classValue, weight);
+			observeAttributeClass(attValue, classValue, weight);
+		}
+	}
+
+	@Override
+	public long getValueCount() {
+		return this.valueCount;
+	}
+
+	@Override
+	public long[] getClassDist() {
+		long[] classDistCopy = new long[this.classDist.numValues()];
+		for (int i = 0; i < this.classDist.numValues(); i++) {
+			classDistCopy[i] = (long) this.classDist.getValue(i);
+		}
+		return classDistCopy;
+	}
+
+	@Override
+	public long getNumberOfCutPoints() {
+		return getSplitPointSuggestions().length;
+	}
+
+	@Override
+	public long[] getLeftClassDist(double cutValue) {
+		long[] lhsDist = new long[this.classDist.numValues()];
+		Arrays.fill(lhsDist, 0);
+		for (int i = 0; i < this.attValDistPerClass.size(); i++) {
+			GaussianEstimator estimator = this.attValDistPerClass.get(i);
+			if (estimator != null) {
+				if (cutValue < this.minValueObservedPerClass.getValue(i)) {
+				} else if (cutValue >= this.maxValueObservedPerClass.getValue(i)) {
+					lhsDist[i] = (long) estimator.getTotalWeightObserved();
+				} else {
+					double[] weightDist = estimator.estimatedWeight_LessThan_EqualTo_GreaterThan_Value(cutValue);
+					lhsDist[i] = (long) (weightDist[0] + weightDist[1]);
+				}
+			}
+		}
+		return lhsDist;
+	}
+
+	@Override
+	public double getCut(int index) {
+		return getSplitPointSuggestions()[index];
+	}
+
+	@Override
+	public void computeClassDistProbabilities(double[][][] cut_value_classDist_lower,
+			double[][][] cut_value_classDist_upper, double[][] counts_cut_value, boolean withIntervalEstimates) {
+		ArrayList<Double> cuts = cutPointSuggestion(-1);
+		long[] totalDist = getClassDist();
+		for (int i = 0; i < cuts.size(); i++) {
+			long[] lDist = getLeftClassDist(cuts.get(i)), rDist = new long[lDist.length];
+			long leftTotal = sum(lDist);
+			long total = sum(totalDist);
+			counts_cut_value[i][0] = leftTotal;
+			counts_cut_value[i][1] = total - leftTotal;
+			for (int j = 0; j < totalDist.length; j++) {
+				rDist[j] = totalDist[j] - lDist[j];
+				double leftEst = 0.0;
+				if (counts_cut_value[i][0] != 0) {
+					leftEst = lDist[j] / counts_cut_value[i][0];
+				}
+				double leftError = 0.0;
+				if (withIntervalEstimates) {
+					leftError = IademCommonProcedures.getIADEM_HoeffdingBound(leftEst, counts_cut_value[i][0]);
+				}
+				cut_value_classDist_lower[i][0][j] = Math.max(0.0, leftEst - leftError);
+				cut_value_classDist_upper[i][0][j] = Math.min(1.0, leftEst + leftError);
+				double rightEst = 0.0;
+				if (counts_cut_value[i][1] != 0) {
+					rightEst = rDist[j] / counts_cut_value[i][1];
+				}
+				double rightError = 0.0;
+				if (withIntervalEstimates) {
+					rightError = IademCommonProcedures.getIADEM_HoeffdingBound(rightEst, counts_cut_value[i][1]);
+				}
+				cut_value_classDist_lower[i][1][j] = Math.max(0.0, rightEst - rightError);
+				cut_value_classDist_upper[i][1][j] = Math.min(1.0, rightEst + rightError);
+			}
+		}
+	}
+
+	protected long sum(long[] arr) {
+		long count = 0;
+		for (int i = 0; i < arr.length; i++) {
+			count += arr[i];
+		}
+		return count;
+	}
+
+	@Override
+	public ArrayList<Double> cutPointSuggestion(int total) {
+		ArrayList<Double> cuts = new ArrayList<>();
+		double[] arr = getSplitPointSuggestions();
+		for (int i = 0; i < arr.length; i++) {
+			cuts.add(arr[i]);
+		}
+		return cuts;
+	}
+
+	@Override
+	public ArrayList<Double[]> computeConditionalProbPerBin(ArrayList<Double> cuts) {
+		ArrayList<Double[]> probClassDistPerCut = new ArrayList<>();
+		long total = getValueCount();
+		for (Double currentCut : cuts) {
+			long[] numInstances = getLeftClassDist(currentCut);
+			Double[] prob = new Double[numInstances.length];
+			for (int j = 0; j < prob.length; j++) {
+				prob[j] = (double) numInstances[j] / total;
+			}
+			probClassDistPerCut.add(prob);
+		}
+		return probClassDistPerCut;
+	}
+
+	@Override
+	public double[] computeConditionalProb(ArrayList<Double> cuts, double cutValue) {
+		double[] conditionalProbability = new double[this.attValDistPerClass.size()];
+		for (int i = 0; i < this.attValDistPerClass.size(); i++) {
+			conditionalProbability[i] = probabilityOfAttributeValueGivenClass(cutValue, i);
+		}
+		return conditionalProbability;
+	}
+
+	@Override
+	public void reset() {
+		this.minValueObservedPerClass = new DoubleVector();
+		this.maxValueObservedPerClass = new DoubleVector();
+		this.attValDistPerClass = new AutoExpandVector<>();
+		this.valueCount = 0;
+		this.classDist = new DoubleVector();
+	}
+
+	// ***********************************************************************
+	// probably deprecated
+	@Override
+	public long getMaxOfValues() {
+		return this.numBinsOption.getValue();
+	}
+
+	@Override
+	public IademNumericAttributeObserver getCopy() {
+		throw new UnsupportedOperationException("Not supported yet."); // To change body of generated methods, choose
+																		// Tools | Templates.
+	}
+
+	@Override
+	public void setMaxBins(int numberOfBins) {
+		this.numBinsOption.setValue(numberOfBins);
+	}
+
+	@Override
+	public void computeClassDist(double[][][] cutClassDist) {
+		ArrayList<Double> cuts = cutPointSuggestion(-1);
+		long[] totalDist = getClassDist();
+		for (int i = 0; i < cuts.size(); i++) {
+			long[] lDist = getLeftClassDist(cuts.get(i)), rDist = new long[lDist.length];
+			for (int j = 0; j < totalDist.length; j++) {
+				rDist[j] = totalDist[j] - lDist[j];
+				cutClassDist[i][0][j] = lDist[j];
+				cutClassDist[i][1][j] = rDist[j];
+			}
+		}
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/trees/iadem/IademGreenwaldKhannaNumericAttributeClassObserver.java b/moa/src/main/java/moa/learners/predictors/trees/iadem/IademGreenwaldKhannaNumericAttributeClassObserver.java
new file mode 100644
index 000000000..5ce492f3d
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/trees/iadem/IademGreenwaldKhannaNumericAttributeClassObserver.java
@@ -0,0 +1,261 @@
+/*
+ *    IademGreenwaldKhannaNumericAttributeClassObserver.java
+ *
+ *    @author Isvani Frias-Blanco
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.predictors.trees.iadem;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import moa.core.AutoExpandVector;
+import moa.core.GreenwaldKhannaQuantileSummary;
+import moa.learners.predictors.core.attributeclassobservers.GreenwaldKhannaNumericAttributeClassObserver;
+import weka.core.Utils;
+
+public class IademGreenwaldKhannaNumericAttributeClassObserver extends GreenwaldKhannaNumericAttributeClassObserver
+		implements IademNumericAttributeObserver {
+	private static final long serialVersionUID = 1L;
+
+	public IademGreenwaldKhannaNumericAttributeClassObserver() {
+		super();
+	}
+
+	public IademGreenwaldKhannaNumericAttributeClassObserver(int maxTuples) {
+		super();
+		this.numTuplesOption.setValue(maxTuples);
+	}
+
+	@Override
+	public void observeAttributeClass(double attVal, int classVal, double weight) {
+		if (Utils.isMissingValue(attVal)) {
+		} else {
+			IademGreenwaldKhannaQuantileSummary valDist = (IademGreenwaldKhannaQuantileSummary) this.attValDistPerClass
+					.get(classVal);
+			if (valDist == null) {
+				valDist = new IademGreenwaldKhannaQuantileSummary(this.numTuplesOption.getValue());
+				this.attValDistPerClass.set(classVal, valDist);
+			}
+			// TODO: not taking weight into account
+			valDist.insert(attVal);
+		}
+	}
+
+	@Override
+	public double probabilityOfAttributeValueGivenClass(double attVal, int classVal) {
+		IademGreenwaldKhannaQuantileSummary obs = (IademGreenwaldKhannaQuantileSummary) this.attValDistPerClass
+				.get(classVal);
+		if (obs == null) {
+			return 0.0;
+		} else {
+			int index = obs.findIndexOfTupleGreaterThan(attVal);
+			double total = obs.getTotalCount();
+			double partial = obs.maxNumberOfObservation(index);
+			return total != 0 ? partial / total : 0.0;
+		}
+	}
+
+	@Override
+	public long getMaxOfValues() {
+		return this.numTuplesOption.getValue();
+	}
+
+	@Override
+	public void addValue(double attValue, int classValue, double weight) {
+		observeAttributeClass(attValue, classValue, weight);
+	}
+
+	@Override
+	public long getValueCount() {
+		int totalCount = 0;
+		for (GreenwaldKhannaQuantileSummary qs : this.attValDistPerClass) {
+			if (qs != null) {
+				totalCount += qs.getTotalCount();
+			}
+		}
+		return totalCount;
+	}
+
+	@Override
+	public long[] getClassDist() {
+		long[] classDist = new long[this.attValDistPerClass.size()];
+		for (int i = 0; i < this.attValDistPerClass.size(); i++) {
+			GreenwaldKhannaQuantileSummary qs = this.attValDistPerClass.get(i);
+			if (qs != null) {
+				classDist[i] = qs.getTotalCount();
+			} else {
+				classDist[i] = 0;
+			}
+		}
+		return classDist;
+	}
+
+	@Override
+	public long getNumberOfCutPoints() {
+		int numberOfCutPoints = 0;
+		for (GreenwaldKhannaQuantileSummary qs : this.attValDistPerClass) {
+			if (qs != null) {
+				numberOfCutPoints += qs.getSuggestedCutpoints().length;
+			}
+		}
+		return numberOfCutPoints;
+	}
+
+	@Override
+	public long[] getLeftClassDist(double cut) {
+		long[] lhsDist = new long[this.attValDistPerClass.size()];
+		Arrays.fill(lhsDist, 0);
+		for (int i = 0; i < this.attValDistPerClass.size(); i++) {
+			GreenwaldKhannaQuantileSummary estimator = this.attValDistPerClass.get(i);
+			if (estimator != null) {
+				long countBelow = estimator.getCountBelow(cut);
+				lhsDist[i] += countBelow;
+			}
+		}
+		return lhsDist;
+	}
+
+	@Override
+	public double getCut(int cutIndex) {
+		int currentCut = cutIndex;
+		for (GreenwaldKhannaQuantileSummary qs : this.attValDistPerClass) {
+			if (qs != null) {
+				double[] cuts = qs.getSuggestedCutpoints();
+				if (currentCut < cuts.length) {
+					return cuts[currentCut];
+				}
+				currentCut -= cuts.length;
+			}
+		}
+		return Double.NaN;
+	}
+
+	@Override
+	public void computeClassDistProbabilities(double[][][] cut_value_classDist_lower,
+			double[][][] cut_value_classDist_upper, double[][] counts_cut_value, boolean withIntervalEstimates) {
+		ArrayList<Double> cuts = cutPointSuggestion(-1);
+		long[] totalDist = getClassDist();
+		for (int i = 0; i < cuts.size(); i++) {
+			long[] lDist = getLeftClassDist(cuts.get(i)), rDist = new long[lDist.length];
+			long totalIzq = sum(lDist);
+			long total = sum(totalDist);
+			counts_cut_value[i][0] = totalIzq;
+			counts_cut_value[i][1] = total - totalIzq;
+			for (int j = 0; j < totalDist.length; j++) {
+				rDist[j] = totalDist[j] - lDist[j];
+				double lEst = 0.0;
+				if (counts_cut_value[i][0] != 0) {
+					lEst = lDist[j] / counts_cut_value[i][0];
+				}
+				double lError = 0.0;
+				if (withIntervalEstimates) {
+					lError = IademCommonProcedures.getIADEM_HoeffdingBound(lEst, counts_cut_value[i][0]);
+				}
+				cut_value_classDist_lower[i][0][j] = Math.max(0.0, lEst - lError);
+				cut_value_classDist_upper[i][0][j] = Math.min(1.0, lEst + lError);
+
+				double rEst = 0.0;
+				if (counts_cut_value[i][1] != 0) {
+					rEst = rDist[j] / counts_cut_value[i][1];
+				}
+				double rightError = 0.0;
+				if (withIntervalEstimates) {
+					rightError = IademCommonProcedures.getIADEM_HoeffdingBound(rEst, counts_cut_value[i][1]);
+				}
+				cut_value_classDist_lower[i][1][j] = Math.max(0.0, rEst - rightError);
+				cut_value_classDist_upper[i][1][j] = Math.min(1.0, rEst + rightError);
+			}
+		}
+	}
+
+	protected long sum(long[] arr) {
+		long counter = 0;
+		for (int i = 0; i < arr.length; i++) {
+			counter += arr[i];
+		}
+		return counter;
+	}
+
+	@Override
+	public ArrayList<Double> cutPointSuggestion(int numCortes) {
+		ArrayList<Double> cuts = new ArrayList<>();
+		for (GreenwaldKhannaQuantileSummary qs : this.attValDistPerClass) {
+			if (qs != null) {
+				double[] newCuts = qs.getSuggestedCutpoints();
+				for (double valor : newCuts) {
+					cuts.add(valor);
+				}
+			}
+		}
+		return cuts;
+	}
+
+	@Override
+	public ArrayList<Double[]> computeConditionalProbPerBin(ArrayList<Double> cuts) {
+		ArrayList<Double[]> prob = new ArrayList<>();
+		long total = getValueCount();
+		for (Double currentCut : cuts) {
+			long[] numExp = getLeftClassDist(currentCut);
+			Double[] tmpProb = new Double[numExp.length];
+			for (int j = 0; j < tmpProb.length; j++) {
+				tmpProb[j] = (double) numExp[j] / total;
+			}
+			prob.add(tmpProb);
+		}
+		return prob;
+	}
+
+	@Override
+	public double[] computeConditionalProb(ArrayList<Double> cortes, double valor) {
+		double[] probabilidadCondicional = new double[this.attValDistPerClass.size()];
+		for (int i = 0; i < this.attValDistPerClass.size(); i++) {
+			probabilidadCondicional[i] = probabilityOfAttributeValueGivenClass(valor, i);
+		}
+		return probabilidadCondicional;
+	}
+
+	@Override
+	public IademNumericAttributeObserver getCopy() {
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public void reset() {
+		this.attValDistPerClass = new AutoExpandVector<>();
+	}
+
+	@Override
+	public void setMaxBins(int numTuples) {
+		this.numTuplesOption.setValue(numTuples);
+	}
+
+	@Override
+	public void computeClassDist(double[][][] cutClassDist) {
+		ArrayList<Double> cuts = cutPointSuggestion(-1);
+		long[] totalDist = getClassDist();
+		for (int i = 0; i < cuts.size(); i++) {
+			long[] lDist = getLeftClassDist(cuts.get(i)), rDist = new long[lDist.length];
+			for (int j = 0; j < totalDist.length; j++) {
+				rDist[j] = totalDist[j] - lDist[j];
+
+				cutClassDist[i][0][j] = lDist[j];
+				cutClassDist[i][1][j] = rDist[j];
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/moa/src/main/java/moa/classifiers/trees/iadem/IademGreenwaldKhannaQuantileSummary.java b/moa/src/main/java/moa/learners/predictors/trees/iadem/IademGreenwaldKhannaQuantileSummary.java
similarity index 57%
rename from moa/src/main/java/moa/classifiers/trees/iadem/IademGreenwaldKhannaQuantileSummary.java
rename to moa/src/main/java/moa/learners/predictors/trees/iadem/IademGreenwaldKhannaQuantileSummary.java
index 8c9d9dac5..379ed8284 100644
--- a/moa/src/main/java/moa/classifiers/trees/iadem/IademGreenwaldKhannaQuantileSummary.java
+++ b/moa/src/main/java/moa/learners/predictors/trees/iadem/IademGreenwaldKhannaQuantileSummary.java
@@ -2,7 +2,7 @@
  *    IademGreenwaldKhannaQuantileSummary.java
  *
  *    @author Isvani Frias-Blanco
- * 
+ *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
@@ -14,32 +14,32 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.classifiers.trees.iadem;
+package moa.learners.predictors.trees.iadem;
 
 import moa.core.GreenwaldKhannaQuantileSummary;
 
 public class IademGreenwaldKhannaQuantileSummary extends GreenwaldKhannaQuantileSummary {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public IademGreenwaldKhannaQuantileSummary(int maxTuples) {
-        super(maxTuples);
-    }
+	public IademGreenwaldKhannaQuantileSummary(int maxTuples) {
+		super(maxTuples);
+	}
 
-    public int maxNumberOfObservation(int i) { 
-        int index = i - 1;
-        if (index >= 0 && index < this.summary.length && this.summary[index] != null) {
-            return (int) (this.summary[index].g + this.summary[index].delta - 1);
-        }
-        return 0;
-    }
+	public int maxNumberOfObservation(int i) {
+		int index = i - 1;
+		if (index >= 0 && index < this.summary.length && this.summary[index] != null) {
+			return (int) (this.summary[index].g + this.summary[index].delta - 1);
+		}
+		return 0;
+	}
 
-    @Override
-    public int findIndexOfTupleGreaterThan(double val) {
-        return super.findIndexOfTupleGreaterThan(val);
-    }
+	@Override
+	public int findIndexOfTupleGreaterThan(double val) {
+		return super.findIndexOfTupleGreaterThan(val);
+	}
 }
diff --git a/moa/src/main/java/moa/classifiers/trees/iadem/IademNominalAttributeBinaryTest.java b/moa/src/main/java/moa/learners/predictors/trees/iadem/IademNominalAttributeBinaryTest.java
similarity index 66%
rename from moa/src/main/java/moa/classifiers/trees/iadem/IademNominalAttributeBinaryTest.java
rename to moa/src/main/java/moa/learners/predictors/trees/iadem/IademNominalAttributeBinaryTest.java
index dce1fbb0a..4edf5afc4 100644
--- a/moa/src/main/java/moa/classifiers/trees/iadem/IademNominalAttributeBinaryTest.java
+++ b/moa/src/main/java/moa/learners/predictors/trees/iadem/IademNominalAttributeBinaryTest.java
@@ -2,7 +2,7 @@
  *    IademNominalAttributeBinaryTest.java
  *
  *    @author Isvani Frias-Blanco
- * 
+ *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
@@ -14,23 +14,22 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.classifiers.trees.iadem;
+package moa.learners.predictors.trees.iadem;
 
-import moa.classifiers.core.conditionaltests.NominalAttributeBinaryTest;
+import moa.learners.predictors.core.conditionaltests.NominalAttributeBinaryTest;
 
 public class IademNominalAttributeBinaryTest extends NominalAttributeBinaryTest {
-    private static final long serialVersionUID = 1L;
-    
+	private static final long serialVersionUID = 1L;
+
+	public IademNominalAttributeBinaryTest(int attIndex, int attValue) {
+		super(attIndex, attValue);
+	}
 
-    public IademNominalAttributeBinaryTest(int attIndex, int attValue) {
-        super(attIndex, attValue);
-    }
-    
-    public int getAttValue() {
-        return this.attValue;
-    }
+	public int getAttValue() {
+		return this.attValue;
+	}
 }
diff --git a/moa/src/main/java/moa/classifiers/trees/iadem/IademNominalAttributeMultiwayTest.java b/moa/src/main/java/moa/learners/predictors/trees/iadem/IademNominalAttributeMultiwayTest.java
similarity index 66%
rename from moa/src/main/java/moa/classifiers/trees/iadem/IademNominalAttributeMultiwayTest.java
rename to moa/src/main/java/moa/learners/predictors/trees/iadem/IademNominalAttributeMultiwayTest.java
index d4cc56b3b..ee22ab663 100644
--- a/moa/src/main/java/moa/classifiers/trees/iadem/IademNominalAttributeMultiwayTest.java
+++ b/moa/src/main/java/moa/learners/predictors/trees/iadem/IademNominalAttributeMultiwayTest.java
@@ -2,7 +2,7 @@
  *    IademNominalAttributeMultiwayTest.java
  *
  *    @author Isvani Frias-Blanco
- * 
+ *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
@@ -14,24 +14,24 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.classifiers.trees.iadem;
+package moa.learners.predictors.trees.iadem;
 
-import moa.classifiers.core.conditionaltests.NominalAttributeMultiwayTest;
+import moa.learners.predictors.core.conditionaltests.NominalAttributeMultiwayTest;
 
 public class IademNominalAttributeMultiwayTest extends NominalAttributeMultiwayTest {
-    int maxBranches;
+	int maxBranches;
+
+	public IademNominalAttributeMultiwayTest(int attIndex, int maxBranches) {
+		super(attIndex);
+		this.maxBranches = maxBranches;
+	}
 
-    public IademNominalAttributeMultiwayTest(int attIndex, int maxBranches) {
-        super(attIndex);
-        this.maxBranches = maxBranches;
-    }
-    
-    @Override
-    public int maxBranches() {
-        return maxBranches;
-    }
+	@Override
+	public int maxBranches() {
+		return maxBranches;
+	}
 }
diff --git a/moa/src/main/java/moa/classifiers/trees/iadem/IademNumericAttributeBinaryTest.java b/moa/src/main/java/moa/learners/predictors/trees/iadem/IademNumericAttributeBinaryTest.java
similarity index 66%
rename from moa/src/main/java/moa/classifiers/trees/iadem/IademNumericAttributeBinaryTest.java
rename to moa/src/main/java/moa/learners/predictors/trees/iadem/IademNumericAttributeBinaryTest.java
index ebd39b705..0e1ef7b55 100644
--- a/moa/src/main/java/moa/classifiers/trees/iadem/IademNumericAttributeBinaryTest.java
+++ b/moa/src/main/java/moa/learners/predictors/trees/iadem/IademNumericAttributeBinaryTest.java
@@ -2,7 +2,7 @@
  *    IademNumericAttributeBinaryTest.java
  *
  *    @author Isvani Frias-Blanco
- * 
+ *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
@@ -14,22 +14,20 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
-package moa.classifiers.trees.iadem;
-
-import moa.classifiers.core.conditionaltests.NumericAttributeBinaryTest;
+package moa.learners.predictors.trees.iadem;
 
+import moa.learners.predictors.core.conditionaltests.NumericAttributeBinaryTest;
 
 public class IademNumericAttributeBinaryTest extends NumericAttributeBinaryTest {
-    public IademNumericAttributeBinaryTest(int attIndex, double attValue,
-            boolean equalsPassesTest) {
-        super(attIndex, attValue, equalsPassesTest);
-    }
+	public IademNumericAttributeBinaryTest(int attIndex, double attValue, boolean equalsPassesTest) {
+		super(attIndex, attValue, equalsPassesTest);
+	}
 
-    public boolean isEqualsPassesTest() {
-        return equalsPassesTest;
-    }
+	public boolean isEqualsPassesTest() {
+		return equalsPassesTest;
+	}
 }
diff --git a/moa/src/main/java/moa/learners/predictors/trees/iadem/IademNumericAttributeObserver.java b/moa/src/main/java/moa/learners/predictors/trees/iadem/IademNumericAttributeObserver.java
new file mode 100644
index 000000000..5eae1086d
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/trees/iadem/IademNumericAttributeObserver.java
@@ -0,0 +1,60 @@
+/*
+ *    IademNumericAttributeObserver.java
+ *
+ *    @author Isvani Frias-Blanco
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.predictors.trees.iadem;
+
+import java.util.ArrayList;
+
+import moa.learners.predictors.core.attributeclassobservers.AttributeClassObserver;
+
+public interface IademNumericAttributeObserver extends AttributeClassObserver {
+
+	long getMaxOfValues();
+
+	void addValue(double attValue, int classValue, double weight);
+
+	long getValueCount();
+
+	long[] getClassDist();
+
+	long getNumberOfCutPoints();
+
+	long[] getLeftClassDist(double cut);
+
+	double getCut(int index);
+
+	void computeClassDistProbabilities(double[][][] inf_p_corte_valor_z, double[][][] sup_p_corte_valor_z,
+			double[][] n_corte_valor, boolean withIntervalEstimates);
+
+	void computeClassDist(double[][][] cutClassDist);
+
+	ArrayList<Double> cutPointSuggestion(int numCortes);
+
+	ArrayList<Double[]> computeConditionalProbPerBin(ArrayList<Double> cuts);
+
+	double[] computeConditionalProb(ArrayList<Double> cuts, double value);
+
+	void reset();
+
+	void setMaxBins(int numIntervalos);
+
+	@Deprecated
+	IademNumericAttributeObserver getCopy();
+}
diff --git a/moa/src/main/java/moa/learners/predictors/trees/iadem/IademSplitCriterion.java b/moa/src/main/java/moa/learners/predictors/trees/iadem/IademSplitCriterion.java
new file mode 100644
index 000000000..05bd0f4d1
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/trees/iadem/IademSplitCriterion.java
@@ -0,0 +1,359 @@
+/*
+ *    IademSplitMeasure.java
+ *
+ *    @author Isvani Frias-Blanco
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.predictors.trees.iadem;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+
+public final class IademSplitCriterion implements Serializable {
+
+	private static final long serialVersionUID = 1L;
+	private final static int ENTROPY = 0;
+	private final static int ENTROPY_LOG_VAR = 1;
+	private final static int WEIGHTED_ENTROPY_LOG_VAR = 2;
+	private final static int WEIGHTED_ENTROPY = 9;
+	private final static int BETA_1 = 3;
+	private final static int GAMMA_1 = 4;
+	private final static int BETA_2 = 5;
+	private final static int GAMMA_2 = 6;
+	private final static int BETA_4 = 7;
+	private final static int GAMMA_4 = 8;
+	private final static int ERROR_GAIN = 10;
+	private final static String ENTROPY_TEXT = "entropy";
+	private final static String ENTROPY_LOG_VAR_TEXT = "entropy_logVar";
+	private final static String WEIGHTED_ENTROPY_LOG_VAR_TEXT = "entropy_logVar+Weight";
+	private final static String WEIGHTED_ENTROPY_TEXT = "entropy+Weight";
+	private final static String BETA_1_TEXT = "beta1";
+	private final static String BETA_2_TEXT = "beta2";
+	private final static String BETA_4_TEXT = "beta4";
+	private final static String GAMMA_1_TEXT = "gamma1";
+	private final static String GAMMA_2_TEXT = "gamma2";
+	private final static String GAMMA_4_TEXT = "gamma4";
+	private final static String ERROR_GAIN_TEXT = "error_gain";
+	private int splitMeasure;
+
+	public IademSplitCriterion() {
+		this.splitMeasure = IademSplitCriterion.ENTROPY;
+	}
+
+	public IademSplitCriterion(String splitMeasure) throws IademException {
+		try {
+			setSplitMeasure(splitMeasure);
+		} catch (IademException e) {
+			throw new IademException("MySplitMeasure", "constructor",
+					"Measure could not be created" + '\n' + e.getMessage());
+		}
+	}
+
+	public String getSplitMeasureText() {
+		String splitMeasureText = "";
+		switch (this.splitMeasure) {
+		case IademSplitCriterion.ENTROPY:
+			splitMeasureText = IademSplitCriterion.ENTROPY_TEXT;
+			break;
+		case IademSplitCriterion.ENTROPY_LOG_VAR:
+			splitMeasureText = IademSplitCriterion.ENTROPY_LOG_VAR_TEXT;
+			break;
+		case IademSplitCriterion.WEIGHTED_ENTROPY_LOG_VAR:
+			splitMeasureText = IademSplitCriterion.WEIGHTED_ENTROPY_LOG_VAR_TEXT;
+			break;
+		case IademSplitCriterion.WEIGHTED_ENTROPY:
+			splitMeasureText = IademSplitCriterion.WEIGHTED_ENTROPY_TEXT;
+			break;
+		case IademSplitCriterion.BETA_1:
+			splitMeasureText = IademSplitCriterion.BETA_1_TEXT;
+			break;
+		case IademSplitCriterion.GAMMA_1:
+			splitMeasureText = IademSplitCriterion.GAMMA_1_TEXT;
+			break;
+		case IademSplitCriterion.BETA_2:
+			splitMeasureText = IademSplitCriterion.BETA_2_TEXT;
+			break;
+		case IademSplitCriterion.GAMMA_2:
+			splitMeasureText = IademSplitCriterion.GAMMA_2_TEXT;
+			break;
+		case IademSplitCriterion.BETA_4:
+			splitMeasureText = IademSplitCriterion.BETA_4_TEXT;
+			break;
+		case IademSplitCriterion.GAMMA_4:
+			splitMeasureText = IademSplitCriterion.GAMMA_4_TEXT;
+			break;
+		case IademSplitCriterion.ERROR_GAIN:
+			splitMeasureText = IademSplitCriterion.ERROR_GAIN_TEXT;
+			break;
+		}
+		return splitMeasureText;
+	}
+
+	public void setSplitMeasure(String splitMeasureType) throws IademException {
+		if (splitMeasureType.equals(IademSplitCriterion.ENTROPY_TEXT)) {
+			this.splitMeasure = IademSplitCriterion.ENTROPY;
+		} else if (splitMeasureType.equals(IademSplitCriterion.ENTROPY_LOG_VAR_TEXT)) {
+			splitMeasure = IademSplitCriterion.ENTROPY_LOG_VAR;
+		} else if (splitMeasureType.equals(WEIGHTED_ENTROPY_LOG_VAR_TEXT)) {
+			splitMeasure = IademSplitCriterion.WEIGHTED_ENTROPY_LOG_VAR;
+		} else if (splitMeasureType.equals(IademSplitCriterion.WEIGHTED_ENTROPY_TEXT)) {
+			splitMeasure = IademSplitCriterion.WEIGHTED_ENTROPY;
+		} else if (splitMeasureType.equals(IademSplitCriterion.BETA_1_TEXT)) {
+			splitMeasure = IademSplitCriterion.BETA_1;
+		} else if (splitMeasureType.equals(IademSplitCriterion.GAMMA_1_TEXT)) {
+			splitMeasure = IademSplitCriterion.GAMMA_1;
+		} else if (splitMeasureType.equals(IademSplitCriterion.BETA_2_TEXT)) {
+			splitMeasure = IademSplitCriterion.BETA_2;
+		} else if (splitMeasureType.equals(IademSplitCriterion.GAMMA_2_TEXT)) {
+			splitMeasure = IademSplitCriterion.GAMMA_2;
+		} else if (splitMeasureType.equals(IademSplitCriterion.BETA_4_TEXT)) {
+			splitMeasure = IademSplitCriterion.BETA_4;
+		} else if (splitMeasureType.equals(IademSplitCriterion.GAMMA_4_TEXT)) {
+			splitMeasure = IademSplitCriterion.GAMMA_4;
+		} else if (splitMeasureType.equals(IademSplitCriterion.ERROR_GAIN_TEXT)) {
+			splitMeasure = IademSplitCriterion.ERROR_GAIN;
+		} else {
+			throw new IademException("MySplitMeasure", "setSplitMeasure", "Measure does not exist");
+		}
+	}
+
+	public static ArrayList<String> getSplitMeasureOptions() {
+		ArrayList<String> splitMeasureList = new ArrayList<>();
+		splitMeasureList.add(IademSplitCriterion.ENTROPY_TEXT);
+		splitMeasureList.add(IademSplitCriterion.ENTROPY_LOG_VAR_TEXT);
+		splitMeasureList.add(IademSplitCriterion.WEIGHTED_ENTROPY_LOG_VAR_TEXT);
+		splitMeasureList.add(IademSplitCriterion.WEIGHTED_ENTROPY_TEXT);
+		splitMeasureList.add(IademSplitCriterion.BETA_1_TEXT);
+		splitMeasureList.add(IademSplitCriterion.GAMMA_1_TEXT);
+		splitMeasureList.add(IademSplitCriterion.BETA_2_TEXT);
+		splitMeasureList.add(IademSplitCriterion.GAMMA_2_TEXT);
+		splitMeasureList.add(IademSplitCriterion.BETA_4_TEXT);
+		splitMeasureList.add(IademSplitCriterion.GAMMA_4_TEXT);
+
+		return splitMeasureList;
+	}
+
+	public static String getDefaultSplitMeasure() {
+		return IademSplitCriterion.ENTROPY_TEXT;
+	}
+
+	public double doMeasure(ArrayList<Double> vector) throws IademException {
+		double logBase; // logarithm base for entropy
+		logBase = vector.size();
+
+		double measure = 0.0;
+		switch (this.splitMeasure) {
+		case IademSplitCriterion.ENTROPY: {
+			logBase = vector.size();
+			if (logBase > 1.0) {
+				double n = 0.0;
+				for (Double elem : vector) {
+					double tmpValue = elem;
+					if (tmpValue > 0.0) {
+						n += tmpValue;
+					} else if (tmpValue < 0.0) {
+						throw new IademException("MySplitMeasure", "doMeasure", "All values must be positive");
+					}
+				}
+
+				if (n == 0.0) {
+					throw new IademException("MySplitMeasure", "doMeasure", "Vector must be different from 0.0");
+				} else {
+					double a_i = 0.0;
+					double sum = 0.0;
+
+					for (int i = 0; i < vector.size(); i++) {
+						a_i = vector.get(i);
+						if (a_i > 0.0) {
+							sum += (a_i * IademCommonProcedures.log(logBase, a_i));
+						}
+					}
+					measure = -((1 / n) * (sum - (n * IademCommonProcedures.log(logBase, n))));
+				}
+			} else if (logBase == 1.0) {
+				measure = 0.0;
+			}
+		}
+			break;
+		case ENTROPY_LOG_VAR: {
+			if (logBase > 1.0) {
+				double n = 0.0;
+				for (Double elem : vector) {
+					double tmpValue = elem;
+					if (tmpValue > 0.0) {
+						n += tmpValue;
+					} else if (tmpValue < 0.0) {
+						throw new IademException("MySplitMeasure", "doMeasure", "All values must be positive");
+					}
+				}
+
+				if (n == 0.0) {
+					throw new IademException("MySplitMeasure", "doMeasure", "Vector must be different from 0.0");
+				} else {
+					double a_i = 0.0;
+					double sum = 0.0;
+
+					for (Double elem : vector) {
+						a_i = elem;
+						if (a_i > 0.0) {
+							sum += a_i * IademCommonProcedures.log(logBase, a_i);
+						}
+					}
+					measure = -((1 / n) * (sum - (n * IademCommonProcedures.log(logBase, n))));
+				}
+			} else if (logBase == 1.0) {
+				measure = 0.0;
+			}
+		}
+			break;
+
+		case WEIGHTED_ENTROPY: {
+			if (logBase > 1.0) {
+				double n = 0.0;
+				for (int i = 0; i < vector.size(); i++) {
+					double tmpValue = vector.get(i);
+					if (tmpValue > 0.0) {
+						n += tmpValue;
+					} else if (tmpValue < 0.0) {
+						throw new IademException("MySplitMeasure", "doMeasure", "All values must be positive");
+					}
+				}
+
+				if (n == 0.0) {
+					measure = 0.0;
+				} else {
+					double a_i = 0.0;
+					double sum = 0.0;
+
+					for (int i = 0; i < vector.size(); i++) {
+						a_i = vector.get(i);
+						if (a_i > 0.0) {
+							sum += (a_i * IademCommonProcedures.log(logBase, a_i));
+						}
+					}
+					measure = -((1 / n) * (sum - (n * IademCommonProcedures.log(logBase, n))));
+				}
+			} else if (logBase == 1.0) {
+				measure = 0.0;
+			}
+		}
+			break;
+
+		case WEIGHTED_ENTROPY_LOG_VAR: {
+			logBase = vector.size();
+			if (logBase > 1.0) {
+				double n = 0.0;
+				for (int i = 0; i < vector.size(); i++) {
+					double tmpValue = vector.get(i);
+					if (tmpValue > 0.0) {
+						n += tmpValue;
+					} else if (tmpValue < 0.0) {
+						throw new IademException("MySplitMeasure", "doMeasure", "All values must be positive");
+					}
+				}
+
+				if (n == 0.0) {
+					measure = 0.0;
+				} else {
+					double a_i = 0.0;
+					double sum = 0.0;
+
+					for (Double elem : vector) {
+						a_i = elem;
+						if (a_i > 0.0) {
+							sum += (a_i * IademCommonProcedures.log(logBase, a_i));
+						}
+					}
+					measure = -((1 / n) * (sum - (n * IademCommonProcedures.log(logBase, n))));
+				}
+			} else if (logBase == 1.0) {
+				measure = 0.0;
+			}
+		}
+			break;
+
+		case BETA_1: {
+			double mayor = 0.0;
+			for (Double elem : vector) {
+				mayor = Math.max(mayor, elem);
+			}
+			measure = 1.0 - mayor;
+		}
+			break;
+
+		case GAMMA_1: {
+			double max = 0.0;
+			for (Double elem : vector) {
+				max = Math.max(max, elem);
+			}
+			measure = 1.0 - max;
+			measure = Math.sqrt(2.0 * measure);
+		}
+			break;
+
+		case BETA_2: {
+			double mayor = 0.0;
+			double sum = 0.0;
+			for (Double elem : vector) {
+				double num = elem;
+				mayor = Math.max(mayor, num);
+				sum += (num * num);
+			}
+			measure = 1.0 - mayor + (mayor * mayor) - sum;
+		}
+			break;
+
+		case GAMMA_2: {
+			double max = 0.0;
+			double sum = 0.0;
+			for (Double elem : vector) {
+				double num = elem;
+				max = Math.max(max, num);
+				sum += (num * num);
+			}
+			measure = 1.0 - max + (max * max) - sum;
+			measure = Math.sqrt(4.0 * measure);
+		}
+			break;
+
+		case BETA_4: {
+			double sum = 0.0;
+			for (Double elem : vector) {
+				double num = elem;
+				sum += (num * num);
+			}
+			measure = 1.0 - sum;
+		}
+			break;
+
+		case GAMMA_4: {
+			double sum = 0.0;
+			for (Double elem : vector) {
+				double num = elem;
+				sum += (num * num);
+			}
+			measure = 1.0 - sum;
+			measure = Math.sqrt(2.0 * measure);
+		}
+			break;
+		}
+		if (measure < 0.0) {
+			throw new IademException("MySplitMeasure", "doMeasure", "Measure could not be calculated");
+		}
+		return measure;
+	}
+}
diff --git a/moa/src/main/java/moa/learners/predictors/trees/iadem/IademVFMLNumericAttributeClassObserver.java b/moa/src/main/java/moa/learners/predictors/trees/iadem/IademVFMLNumericAttributeClassObserver.java
new file mode 100644
index 000000000..6557c6596
--- /dev/null
+++ b/moa/src/main/java/moa/learners/predictors/trees/iadem/IademVFMLNumericAttributeClassObserver.java
@@ -0,0 +1,632 @@
+/*
+ *    IademVFMLNumericAttributeClassObserver.java
+ *
+ *    @author Isvani Frias-Blanco
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.learners.predictors.trees.iadem;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import moa.core.DoubleVector;
+import moa.core.ObjectRepository;
+import moa.learners.predictors.core.AttributeSplitSuggestion;
+import moa.learners.predictors.core.attributeclassobservers.AttributeClassObserver;
+import moa.learners.predictors.core.attributeclassobservers.VFMLNumericAttributeClassObserver;
+import moa.learners.predictors.core.splitcriteria.SplitCriterion;
+import moa.tasks.TaskMonitor;
+import weka.core.Utils;
+
+public class IademVFMLNumericAttributeClassObserver extends VFMLNumericAttributeClassObserver
+		implements IademNumericAttributeObserver, AttributeClassObserver {
+
+	private static final long serialVersionUID = 1L;
+
+	public IademVFMLNumericAttributeClassObserver() {
+		super();
+		this.numBinsOption.setValue(500);
+	}
+
+	public IademVFMLNumericAttributeClassObserver(int maxBins) {
+		super();
+		this.numBinsOption.setValue(maxBins);
+	}
+
+	@Override
+	public void setMaxBins(int numBins) {
+		this.numBinsOption.setValue(numBins);
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+	}
+
+	@Override
+	public void computeClassDist(double[][][] cutClassDist) {
+		int classes = this.classDist.numValues();
+		Bin element = binList.get(0);
+
+		double numLeftInst = element.classWeights.sumOfValues();
+		double numRightInst = this.classDist.sumOfValues() - numLeftInst;
+
+		double[] leftClassDist = new double[classes];
+		double[] rightClassDist = new double[classes];
+		for (int i = 0; i < classes; i++) {
+			leftClassDist[i] = element.classWeights.getValue(i);
+			rightClassDist[i] = this.classDist.getValue(i) - leftClassDist[i];
+
+			cutClassDist[0][0][i] = leftClassDist[i];
+			cutClassDist[0][1][i] = rightClassDist[i];
+		}
+
+		for (int i = 1; i < this.binList.size() - 1; i++) {
+			element = this.binList.get(i);
+
+			double numChangingInst = element.classWeights.sumOfValues();
+			numLeftInst += numChangingInst;
+			numRightInst -= numChangingInst;
+
+			for (int j = 0; j < classes; j++) {
+				double changingClassDist = element.classWeights.getValue(j);
+				leftClassDist[j] += changingClassDist;
+				rightClassDist[j] -= changingClassDist;
+
+				cutClassDist[i][0][j] = leftClassDist[j];
+
+				cutClassDist[i][1][j] = rightClassDist[j];
+			}
+		}
+	}
+
+	protected class Bin implements Serializable {
+
+		private static final long serialVersionUID = 1L;
+		public double lowerBound, upperBound;
+		public DoubleVector classWeights = new DoubleVector();
+		public int boundaryClass;
+		public double boundaryWeight;
+	}
+
+	protected List<Bin> binList = new ArrayList<>();
+	protected DoubleVector classDist = new DoubleVector();
+
+	@Override
+	public void observeAttributeClass(double attVal, int classVal, double weight) {
+		if (Utils.isMissingValue(attVal)) {
+		} else {
+			if (this.binList.size() < 1) {
+				// create the first bin
+				Bin newBin = new Bin();
+				newBin.classWeights.addToValue(classVal, weight);
+				newBin.boundaryClass = classVal;
+				newBin.boundaryWeight = weight;
+				newBin.upperBound = attVal;
+				newBin.lowerBound = attVal;
+				this.binList.add(newBin);
+			} else {
+				// find bin containing new example with binary search
+				int index = -1;
+				boolean found = false;
+				int min = 0;
+				int max = this.binList.size() - 1;
+				index = 0;
+				while ((min <= max) && !found) {
+					int i = (min + max) / 2;
+					Bin bin = this.binList.get(i);
+					if (((attVal >= bin.lowerBound) && (attVal < bin.upperBound)) || ((i == this.binList.size() - 1)
+							&& (attVal >= bin.lowerBound) && (attVal <= bin.upperBound))) {
+						found = true;
+						index = i;
+					} else if (attVal < bin.lowerBound) {
+						max = i - 1;
+					} else {
+						min = i + 1;
+					}
+				}
+				boolean first = false;
+				boolean last = false;
+				if (!found) {
+					// determine if it is before or after the existing range
+					Bin bin = this.binList.get(0);
+					if (bin.lowerBound > attVal) {
+						// go before the first bin
+						index = 0;
+						first = true;
+					} else {
+						// if we haven't found it yet value must be > last bins
+						// upperBound
+						index = this.binList.size() - 1;
+						last = true;
+					}
+				}
+				Bin bin = this.binList.get(index); // VLIndex(ct->bins, index);
+				if ((bin.lowerBound == attVal) || (this.binList.size() >= this.numBinsOption.getValue())) {// Option.getValue())
+					// {//1000)
+					// {
+					// if this is the exact same boundary and class as the bin
+					// boundary or we aren't adding new bins any more then
+					// increment
+					// boundary counts
+					bin.classWeights.addToValue(classVal, weight);
+					if ((bin.boundaryClass == classVal) && (bin.lowerBound == attVal)) {
+						// if it is also the same class then special case it
+						bin.boundaryWeight += weight;
+					}
+				} else {
+					// create a new bin
+					Bin newBin = new Bin();
+					newBin.classWeights.addToValue(classVal, weight);
+					newBin.boundaryWeight = weight;
+					newBin.boundaryClass = classVal;
+					newBin.upperBound = bin.upperBound;
+					newBin.lowerBound = attVal;
+
+					double percent = 0.0;
+					// estimate initial counts with a linear interpolation
+					if (!((bin.upperBound - bin.lowerBound == 0) || last || first)) {
+						percent = 1.0 - ((attVal - bin.lowerBound) / (bin.upperBound - bin.lowerBound));
+					}
+
+					// take out the boundry points, they stay with the old bin
+					bin.classWeights.addToValue(bin.boundaryClass, -bin.boundaryWeight);
+					DoubleVector weightToShift = new DoubleVector(bin.classWeights);
+
+					// make this a vector of integers
+					weightToShift.scaleValues(percent);
+					for (int i = 0; i < weightToShift.numValues(); i++) {
+						long tmp = Math.round(weightToShift.getValue(i));
+						weightToShift.setValue(i, tmp);
+					}
+
+					newBin.classWeights.addValues(weightToShift);
+					bin.classWeights.subtractValues(weightToShift);
+					// put the boundry examples back in
+					bin.classWeights.addToValue(bin.boundaryClass, bin.boundaryWeight);
+
+					// insert the new bin in the right place
+					if (last) {
+						bin.upperBound = attVal;
+						newBin.upperBound = attVal;
+						this.binList.add(newBin);
+					} else if (first) {
+						newBin.upperBound = bin.lowerBound;
+						this.binList.add(0, newBin);
+					} else {
+						newBin.upperBound = bin.upperBound;
+						bin.upperBound = attVal;
+						this.binList.add(index + 1, newBin);
+					}
+				}
+			}
+		}
+	}
+
+	@Override
+	public AttributeSplitSuggestion getBestEvaluatedSplitSuggestion(SplitCriterion criterion, double[] preSplitDist,
+			int attIndex, boolean binaryOnly) {
+		AttributeSplitSuggestion bestSuggestion = null;
+		DoubleVector rightDist = new DoubleVector();
+		for (Bin bin : this.binList) {
+			rightDist.addValues(bin.classWeights);
+		}
+		DoubleVector leftDist = new DoubleVector();
+		for (Bin bin : this.binList) {
+			leftDist.addValues(bin.classWeights);
+			rightDist.subtractValues(bin.classWeights);
+			double[][] postSplitDists = new double[][] { leftDist.getArrayCopy(), rightDist.getArrayCopy() };
+			double merit = criterion.getMeritOfSplit(preSplitDist, postSplitDists);
+			if ((bestSuggestion == null) || (merit > bestSuggestion.merit)) {
+				bestSuggestion = new AttributeSplitSuggestion(
+						new IademNumericAttributeBinaryTest(attIndex, bin.upperBound, false), postSplitDists, merit);
+			}
+		}
+		return bestSuggestion;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public double probabilityOfAttributeValueGivenClass(double attVal, int classVal) {
+		// compute the conditional probability
+		double attValClassValCount = 0.0;
+		double totalClassValCount = 0.0;
+		for (int i = 0; i < binList.size(); i++) {
+			if (attVal == this.binList.get(i).lowerBound && classVal == this.binList.get(i).boundaryClass) {
+				// attribute and class values are in a boundary
+				attValClassValCount = this.binList.get(i).boundaryWeight;
+			} else if (((attVal >= this.binList.get(i).lowerBound) && (attVal < this.binList.get(i).upperBound))
+					|| ((i == this.binList.size() - 1) && (attVal >= this.binList.get(i).lowerBound)
+							&& (attVal <= this.binList.get(i).upperBound))) {
+				// attribute value is inside a bin
+				attValClassValCount = this.binList.get(i).classWeights.getValue(classVal);
+			}
+			totalClassValCount += binList.get(i).classWeights.getValue(classVal);
+		}
+		return totalClassValCount != 0 ? attValClassValCount / totalClassValCount : 0.0;
+	}
+
+	public void forgetAttributeClass(double attVal, int classVal, double weight) {
+		if (Utils.isMissingValue(attVal)) {
+		} else if (this.classDist.sumOfValues() > 0) {
+			this.classDist.addToValue(classVal, -weight);
+
+			int i, index;
+			boolean found = false;
+			int min, max;
+			Bin bin;
+			int numBins = binList.size();
+			// Find the bin holding the example to be forgotten
+			index = 0;
+			min = 0;
+			max = numBins - 1;
+
+			// Binary search
+			while (min <= max && !found) {
+				i = (min + max) / 2;
+				bin = binList.get(i);
+				if ((attVal >= bin.lowerBound && attVal < bin.upperBound)
+						|| ((i == numBins - 1) && (attVal >= bin.lowerBound) && (attVal <= bin.upperBound))) {
+					found = true;
+					index = i;
+				} else if (attVal < bin.lowerBound) {
+					max = i - 1;
+				} else {
+					min = i + 1;
+				}
+			}
+
+			// Reduce counts
+			if (!found) {
+				// printf("Value %f not found\n", value );
+				// printBins( ct->bins );
+				// HERE UNREPORTED ERROR
+
+				return;
+			}
+
+			bin = binList.get(index);
+			// decrement counts
+			bin.classWeights.addToValue(classVal, -weight);
+			if (bin.classWeights.getValue(classVal) < 0) {
+				bin.classWeights.setValue(classVal, 0);
+			}
+			if (bin.boundaryClass == classVal) {
+				bin.boundaryWeight -= weight;
+			}
+			if (bin.boundaryWeight < 0) {
+				bin.boundaryWeight = 0;
+			}
+
+			// Remove bin
+			if (bin.boundaryWeight == 0 && binList.size() > 0) {
+				int numClasses = bin.classWeights.numValues();
+				if (index != 0) {
+					int j;
+					Bin prevBin = binList.get(index - 1);
+					prevBin.upperBound = bin.upperBound;
+					// prevBin->exampleCount += bin->exampleCount;
+					for (j = 0; j < numClasses; j++) {
+						prevBin.classWeights.addToValue(j, bin.classWeights.getValue(j));
+					}
+					binList.remove(index);
+					bin = binList.get(index - 1);
+				} // Remove first bin
+				else if (binList.size() > 1) {
+					int j;
+					Bin newFirstBin = binList.get(1);
+					Bin oldFirstBin = binList.get(0);
+					/*
+					 * printf( "removing first bin: %f - %f (%f) bc - %ld\n",
+					 * oldFirstBin->lowerBound, oldFirstBin->upperBound, oldFirstBin->exampleCount,
+					 * oldFirstBin->boundryCount);
+					 */
+					newFirstBin.lowerBound = oldFirstBin.lowerBound;
+					for (j = 0; j < numClasses; j++) {
+						newFirstBin.classWeights.addToValue(j, oldFirstBin.classWeights.getValue(j));
+					}
+					/*
+					 * printf( "new first bin: %f - %f (%f) bc - %ld\n", newFirstBin->lowerBound,
+					 * newFirstBin->upperBound, newFirstBin->exampleCount,
+					 * newFirstBin->boundryCount);
+					 */
+					binList.remove(0);
+				}
+			}
+		}
+	}
+
+	@Override
+	public void reset() {
+		this.classDist = new DoubleVector();
+		this.binList = new ArrayList<>();
+	}
+
+	@Override
+	public long getValueCount() {
+		return (long) this.classDist.sumOfValues();
+	}
+
+	@Override
+	public long[] getClassDist() {
+		long[] classDistCopy = new long[this.classDist.numValues()];
+		for (int i = 0; i < this.classDist.numValues(); i++) {
+			classDistCopy[i] = (long) this.classDist.getValue(i);
+		}
+		return classDistCopy;
+	}
+
+	@Override
+	public long getNumberOfCutPoints() {
+		return binList.size() - 1;
+	}
+
+	@Override
+	public long[] getLeftClassDist(double corte) {
+		long[] rightDist = new long[this.classDist.numValues()];
+		Arrays.fill(rightDist, 0);
+		for (int i = 0; i < this.binList.size() && corte > this.binList.get(i).upperBound; i++) {
+			for (int j = 0; j < this.binList.get(i).classWeights.numValues(); j++) {
+				rightDist[j] += this.binList.get(i).classWeights.getValue(j);
+			}
+		}
+		return rightDist;
+	}
+
+	@Override
+	public double getCut(int indice) {
+		return binList.get(indice).upperBound;
+	}
+
+	@Override
+	public void computeClassDistProbabilities(double[][][] cut_value_classDist_lower,
+			double[][][] cut_value_classDist_upper, double[][] counts_cut_value, boolean withIntervalEstimates) {
+		int classes = this.classDist.numValues();
+		Bin element = binList.get(0);
+
+		double numLeftInst = element.classWeights.sumOfValues();
+		double numRightInst = this.classDist.sumOfValues() - numLeftInst;
+		counts_cut_value[0][0] = numLeftInst;
+		counts_cut_value[0][1] = numRightInst;
+
+		double[] leftClassDist = new double[classes];
+		double[] rightClassDist = new double[classes];
+		for (int i = 0; i < classes; i++) {
+			leftClassDist[i] = element.classWeights.getValue(i);
+			rightClassDist[i] = this.classDist.getValue(i) - leftClassDist[i];
+
+			double lEstimates = 0.0;
+			if (numLeftInst != 0) {
+				lEstimates = leftClassDist[i] / numLeftInst;
+			}
+			double lError = 0.0;
+			if (withIntervalEstimates) {
+				lError = IademCommonProcedures.getIADEM_HoeffdingBound(lEstimates, numLeftInst);
+			}
+			cut_value_classDist_lower[0][0][i] = Math.max(0.0, lEstimates - lError);
+			cut_value_classDist_upper[0][0][i] = Math.min(1.0, lEstimates + lError);
+
+			double rEstimates = 0.0;
+			if (numRightInst != 0.0) {
+				rEstimates = rightClassDist[i] / numRightInst;
+			}
+			double rError = 0.0;
+			if (withIntervalEstimates) {
+				rError = IademCommonProcedures.getIADEM_HoeffdingBound(rEstimates, numRightInst);
+			}
+			cut_value_classDist_lower[0][1][i] = Math.max(0.0, rEstimates - rError);
+			cut_value_classDist_upper[0][1][i] = Math.min(1.0, rEstimates + rError);
+		}
+
+		for (int i = 1; i < this.binList.size() - 1; i++) {
+			element = this.binList.get(i);
+
+			double numChangingInst = element.classWeights.sumOfValues();
+			numLeftInst += numChangingInst;
+			numRightInst -= numChangingInst;
+			counts_cut_value[i][0] = numLeftInst; // corte i a la izquierda
+			counts_cut_value[i][1] = numRightInst; // corte i a la derecha
+
+			for (int j = 0; j < classes; j++) {
+				double changingClassDist = element.classWeights.getValue(j);
+				leftClassDist[j] += changingClassDist;
+				rightClassDist[j] -= changingClassDist;
+				double lEstimates = 0.0;
+				if (numLeftInst != 0) {
+					lEstimates = leftClassDist[j] / numLeftInst;
+				}
+				double lError = 0.0;
+				if (withIntervalEstimates) {
+					lError = IademCommonProcedures.getIADEM_HoeffdingBound(lEstimates, numLeftInst);
+				}
+				cut_value_classDist_lower[i][0][j] = Math.max(0.0, lEstimates - lError);
+				cut_value_classDist_upper[i][0][j] = Math.min(1.0, lEstimates + lError);
+				double rEstimates = 0.0;
+				if (numRightInst != 0.0) {
+					rEstimates = rightClassDist[j] / numRightInst;
+				}
+				double rError = 0.0;
+				if (withIntervalEstimates) {
+					rError = IademCommonProcedures.getIADEM_HoeffdingBound(rEstimates, numRightInst);
+				}
+				cut_value_classDist_lower[i][1][j] = Math.max(0.0, rEstimates - rError);
+				cut_value_classDist_upper[i][1][j] = Math.min(1.0, rEstimates + rError);
+			}
+		}
+	}
+
+	@Override
+	public ArrayList<Double> cutPointSuggestion(int numMaxIntervalos) {
+		ArrayList<Double> cutPoint = new ArrayList<>();
+		for (int i = 0; i < this.binList.size() - 1; i++) {
+			cutPoint.add(this.binList.get(i).upperBound);
+		}
+		return cutPoint;
+	}
+
+	@Override
+	public ArrayList<Double[]> computeConditionalProbPerBin(ArrayList<Double> cortes) {
+		ArrayList<Double[]> condProb = new ArrayList<>();
+		int numClasses = classDist.numValues();
+
+		double[] numClassesPerBin = new double[numClasses];
+		Arrays.fill(numClassesPerBin, 0);
+
+		int currentBin = 0;
+		Bin element;
+		for (int j = 0; j < this.binList.size(); j++) {
+			element = this.binList.get(j);
+			double aux = element.upperBound;
+			if ((currentBin == cortes.size()) // last bin
+					|| (aux <= cortes.get(currentBin))) {// keeps in the same bin
+				for (int i = 0; i < numClasses; i++) {
+					numClassesPerBin[i] += element.classWeights.getValue(i);
+				}
+			} else {// change of bin
+				// store the previous data
+				Double[] probCond_intervalo = new Double[numClasses];
+				for (int i = 0; i < numClasses; i++) {
+					if (this.classDist.getValue(i) == 0) {
+						probCond_intervalo[i] = 0.0;
+					} else {
+						probCond_intervalo[i] = numClassesPerBin[i] / this.classDist.getValue(i);
+					}
+				}
+				condProb.add(probCond_intervalo);
+
+				currentBin++;
+
+				while ((currentBin < cortes.size()) && (aux > cortes.get(currentBin))) {
+					currentBin++;
+					condProb.add(null);
+				}
+
+				Arrays.fill(numClassesPerBin, 0);
+				// store data in the last bin
+				for (int i = 0; i < numClasses; i++) {
+					numClassesPerBin[i] += element.classWeights.getValue(i);
+				}
+			}
+		}
+		// store data in the last bin
+		Double[] probCond_intervalo = new Double[numClasses];
+		for (int i = 0; i < numClasses; i++) {
+			if (this.classDist.getValue(i) == 0) {
+				probCond_intervalo[i] = 0.0;
+			} else {
+				probCond_intervalo[i] = numClassesPerBin[i] / this.classDist.getValue(i);
+			}
+		}
+		condProb.add(probCond_intervalo);
+
+		return condProb;
+	}
+
+	@Override
+	public double[] computeConditionalProb(ArrayList<Double> cuts, double cutValue) {
+		int numClasses = this.classDist.numValues();
+		double[] instPerClass = new double[numClasses];
+		Arrays.fill(instPerClass, 0);
+
+		int keyPos;
+		if (cutValue <= cuts.get(0)) {
+			keyPos = 0;
+			while (keyPos < this.binList.size() && this.binList.get(keyPos).upperBound <= cuts.get(0)) {
+				for (int i = 0; i < numClasses; i++) {
+					instPerClass[i] += this.binList.get(keyPos).classWeights.getValue(i);
+				}
+				keyPos++;
+			}
+		} else if (cutValue > cuts.get(cuts.size() - 1)) {
+			keyPos = this.binList.size() - 1;
+			while (keyPos < this.binList.size() && this.binList.get(keyPos).upperBound > cuts.get(cuts.size() - 1)) {
+				for (int i = 0; i < numClasses; i++) {
+					instPerClass[i] += this.binList.get(keyPos).classWeights.getValue(i);
+				}
+				keyPos--;
+			}
+		} else {
+			int currentBin = 1;
+			double lastBin = cuts.get(currentBin);
+			while (cutValue > lastBin) {
+				currentBin++;
+				lastBin = cuts.get(currentBin);
+			}
+
+			double firstBin = cuts.get(currentBin - 1);
+			keyPos = 0;
+			while (keyPos < this.binList.size() && this.binList.get(keyPos).upperBound <= firstBin) {
+				keyPos++;
+			}
+			while (keyPos < this.binList.size() && this.binList.get(keyPos).upperBound <= lastBin) {
+				for (int i = 0; i < numClasses; i++) {
+					instPerClass[i] += this.binList.get(keyPos).classWeights.getValue(i);
+				}
+				keyPos++;
+			}
+		}
+		// if there is no information in this bin...
+		boolean allZero = true;
+		int pos = 0;
+		while ((allZero) && (pos < numClasses)) {
+			if (instPerClass[pos] > 0.0) {
+				allZero = false;
+			}
+			pos++;
+		}
+
+		double[] classVotes = new double[numClasses];
+		if (allZero) {
+			for (int i = 0; i < numClasses; i++) {
+				classVotes[i] = 1.0 / numClasses;
+			}
+		} else {
+			for (int i = 0; i < numClasses; i++) {
+				if (classDist.getValue(i) == 0) {
+					classVotes[i] = 0.0;
+				} else {
+					classVotes[i] = instPerClass[i] / classDist.getValue(i);
+				}
+			}
+		}
+		return classVotes;
+	}
+
+	@Override
+	public void addValue(double attValue, int classValue, double weight) {
+		if (Utils.isMissingValue(attValue)) {
+		} else {
+			this.classDist.addToValue(classValue, weight);
+			observeAttributeClass(attValue, classValue, weight);
+		}
+	}
+
+	@Override
+	public long getMaxOfValues() {
+		return this.numBinsOption.getValue();
+	}
+
+	@Override
+	public IademNumericAttributeObserver getCopy() {
+		throw new UnsupportedOperationException("Not supported yet."); // To change body of generated methods, choose
+																		// Tools | Templates.
+	}
+}
diff --git a/moa/src/main/java/moa/options/AbstractClassOption.java b/moa/src/main/java/moa/options/AbstractClassOption.java
index 70e1af183..fb99a6ded 100644
--- a/moa/src/main/java/moa/options/AbstractClassOption.java
+++ b/moa/src/main/java/moa/options/AbstractClassOption.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.options;
 
@@ -36,202 +36,192 @@
  */
 public abstract class AbstractClassOption extends AbstractOption {
 
-    private static final long serialVersionUID = 1L;
-
-    /** The prefix text to use to indicate file.  */
-    public static final String FILE_PREFIX_STRING = "file:";
-
-    /** The prefix text to use to indicate inmem.  */
-    public static final String INMEM_PREFIX_STRING = "inmem:";
-
-    /** The current object */
-    protected Object currentValue;
-
-    /** The class type */
-    protected Class<?> requiredType;
-
-    /** The default command line interface text. */
-    protected String defaultCLIString;
-
-    /** The null text. */
-    protected String nullString;
-
-    /**
-     * Creates a new instance of an abstract option given its class name,
-     * command line interface text, its purpose, its class type and its default
-     * command line interface text.
-     *
-     * @param name the name of this option
-     * @param cliChar the command line interface text
-     * @param purpose the text describing the purpose of this option
-     * @param requiredType the class type
-     * @param defaultCLIString the default command line interface text
-     */
-    public AbstractClassOption(String name, char cliChar, String purpose,
-            Class<?> requiredType, String defaultCLIString) {
-        this(name, cliChar, purpose, requiredType, defaultCLIString, null);
-    }
-
-    /**
-     * Creates a new instance of an abstract option given its class name,
-     * command line interface text, its purpose, its class type, default
-     * command line interface text, and its null text.
-     *
-     * @param name the name of this option
-     * @param cliChar the command line interface text
-     * @param purpose the text describing the purpose of this option
-     * @param requiredType the class type
-     * @param defaultCLIString the default command line interface text
-     * @param nullString the null text
-     */
-    public AbstractClassOption(String name, char cliChar, String purpose,
-            Class<?> requiredType, String defaultCLIString, String nullString) {
-        super(name, cliChar, purpose);
-        this.requiredType = requiredType;
-        this.defaultCLIString = defaultCLIString;
-        this.nullString = nullString;
-        resetToDefault();
-    }
-
-    /**
-     * Sets current object.
-     *
-     * @param obj the object to set as current.
-     */
-    public void setCurrentObject(Object obj) {
-        if (((obj == null) && (this.nullString != null))
-                || this.requiredType.isInstance(obj)
-                || (obj instanceof String)
-                || (obj instanceof File)
-                || ((obj instanceof Task) && this.requiredType.isAssignableFrom(((Task) obj).getTaskResultType()))) {
-            this.currentValue = obj;
-        } else {
-            throw new IllegalArgumentException("Object not of required type.");
-        }
-    }
-
-    /**
-     * Returns the current object.
-     *
-     * @return the current object
-     */
-    public Object getPreMaterializedObject() {
-        return this.currentValue;
-    }
-
-    /**
-     * Gets the class type of this option.
-     *
-     * @return the class type of this option
-     */
-    public Class<?> getRequiredType() {
-        return this.requiredType;
-    }
-
-    /**
-     * Gets the null string of this option.
-     *
-     * @return the null string of this option
-     */
-    public String getNullString() {
-        return this.nullString;
-    }
-
-    /**
-     * Gets a materialized object of this option.
-     * 
-     * @param monitor the task monitor to use
-     * @param repository the object repository to use
-     * @return the materialized object
-     */
-    public Object materializeObject(TaskMonitor monitor,
-            ObjectRepository repository) {
-        if ((this.currentValue == null)
-                || this.requiredType.isInstance(this.currentValue)) {
-            return this.currentValue;
-        } else if (this.currentValue instanceof String) {
-            if (repository != null) {
-                Object inmemObj = repository.getObjectNamed((String) this.currentValue);
-                if (inmemObj == null) {
-                    throw new RuntimeException("No object named "
-                            + this.currentValue + " found in repository.");
-                }
-                return inmemObj;
-            }
-            throw new RuntimeException("No object repository available.");
-        } else if (this.currentValue instanceof Task) {
-            Task task = (Task) this.currentValue;
-            Object result = task.doTask(monitor, repository);
-            return result;
-        } else if (this.currentValue instanceof File) {
-            File inputFile = (File) this.currentValue;
-            Object result = null;
-            try {
-                result = SerializeUtils.readFromFile(inputFile);
-            } catch (Exception ex) {
-                throw new RuntimeException("Problem loading "
-                        + this.requiredType.getName() + " object from file '"
-                        + inputFile.getName() + "':\n" + ex.getMessage(), ex);
-            }
-            return result;
-        } else {
-            throw new RuntimeException(
-                    "Could not materialize object of required type "
-                    + this.requiredType.getName() + ", found "
-                    + this.currentValue.getClass().getName()
-                    + " instead.");
-        }
-    }
-
-    @Override
-    public String getDefaultCLIString() {
-        return this.defaultCLIString;
-    }
-
-    /**
-     * Gets the command line interface text of the class.
-     *
-     * @param aClass the class
-     * @param requiredType the class type
-     * @return the command line interface text of the class
-     */
-    public static String classToCLIString(Class<?> aClass, Class<?> requiredType) {
-        String className = aClass.getName();
-        String packageName = requiredType.getPackage().getName();
-        if (className.startsWith(packageName)) {
-            // cut off package name
-            className = className.substring(packageName.length() + 1, className.length());
-        } else if (Task.class.isAssignableFrom(aClass)) {
-            packageName = Task.class.getPackage().getName();
-            if (className.startsWith(packageName)) {
-                // cut off task package name
-                className = className.substring(packageName.length() + 1,
-                        className.length());
-            }
-        }
-        return className;
-    }
-
-    @Override
-    public abstract String getValueAsCLIString();
-
-    @Override
-    public abstract void setValueViaCLIString(String s);
-
-    //@Override
-    //public abstract JComponent getEditComponent();
-
-    /**
-     * Gets the class name without its package name prefix.
-     *
-     * @param className the name of the class
-     * @param expectedType the type of the class
-     * @return the class name without its package name prefix
-     */
-    public static String stripPackagePrefix(String className, Class<?> expectedType) {
-        if (className.startsWith(expectedType.getPackage().getName())) {
-            return className.substring(expectedType.getPackage().getName().length() + 1);
-        }
-        return className;
-    }
+	private static final long serialVersionUID = 1L;
+
+	/** The prefix text to use to indicate file. */
+	public static final String FILE_PREFIX_STRING = "file:";
+
+	/** The prefix text to use to indicate inmem. */
+	public static final String INMEM_PREFIX_STRING = "inmem:";
+
+	/** The current object */
+	protected Object currentValue;
+
+	/** The class type */
+	protected Class<?> requiredType;
+
+	/** The default command line interface text. */
+	protected String defaultCLIString;
+
+	/** The null text. */
+	protected String nullString;
+
+	/**
+	 * Creates a new instance of an abstract option given its class name, command
+	 * line interface text, its purpose, its class type and its default command line
+	 * interface text.
+	 *
+	 * @param name             the name of this option
+	 * @param cliChar          the command line interface text
+	 * @param purpose          the text describing the purpose of this option
+	 * @param requiredType     the class type
+	 * @param defaultCLIString the default command line interface text
+	 */
+	public AbstractClassOption(String name, char cliChar, String purpose, Class<?> requiredType,
+			String defaultCLIString) {
+		this(name, cliChar, purpose, requiredType, defaultCLIString, null);
+	}
+
+	/**
+	 * Creates a new instance of an abstract option given its class name, command
+	 * line interface text, its purpose, its class type, default command line
+	 * interface text, and its null text.
+	 *
+	 * @param name             the name of this option
+	 * @param cliChar          the command line interface text
+	 * @param purpose          the text describing the purpose of this option
+	 * @param requiredType     the class type
+	 * @param defaultCLIString the default command line interface text
+	 * @param nullString       the null text
+	 */
+	public AbstractClassOption(String name, char cliChar, String purpose, Class<?> requiredType,
+			String defaultCLIString, String nullString) {
+		super(name, cliChar, purpose);
+		this.requiredType = requiredType;
+		this.defaultCLIString = defaultCLIString;
+		this.nullString = nullString;
+		resetToDefault();
+	}
+
+	/**
+	 * Sets current object.
+	 *
+	 * @param obj the object to set as current.
+	 */
+	public void setCurrentObject(Object obj) {
+		if (((obj == null) && (this.nullString != null)) || this.requiredType.isInstance(obj) || (obj instanceof String)
+				|| (obj instanceof File)
+				|| ((obj instanceof Task) && this.requiredType.isAssignableFrom(((Task) obj).getTaskResultType()))) {
+			this.currentValue = obj;
+		} else {
+			throw new IllegalArgumentException("Object not of required type.");
+		}
+	}
+
+	/**
+	 * Returns the current object.
+	 *
+	 * @return the current object
+	 */
+	public Object getPreMaterializedObject() {
+		return this.currentValue;
+	}
+
+	/**
+	 * Gets the class type of this option.
+	 *
+	 * @return the class type of this option
+	 */
+	public Class<?> getRequiredType() {
+		return this.requiredType;
+	}
+
+	/**
+	 * Gets the null string of this option.
+	 *
+	 * @return the null string of this option
+	 */
+	public String getNullString() {
+		return this.nullString;
+	}
+
+	/**
+	 * Gets a materialized object of this option.
+	 * 
+	 * @param monitor    the task monitor to use
+	 * @param repository the object repository to use
+	 * @return the materialized object
+	 */
+	public Object materializeObject(TaskMonitor monitor, ObjectRepository repository) {
+		if ((this.currentValue == null) || this.requiredType.isInstance(this.currentValue)) {
+			return this.currentValue;
+		} else if (this.currentValue instanceof String) {
+			if (repository != null) {
+				Object inmemObj = repository.getObjectNamed((String) this.currentValue);
+				if (inmemObj == null) {
+					throw new RuntimeException("No object named " + this.currentValue + " found in repository.");
+				}
+				return inmemObj;
+			}
+			throw new RuntimeException("No object repository available.");
+		} else if (this.currentValue instanceof Task) {
+			Task task = (Task) this.currentValue;
+			Object result = task.doTask(monitor, repository);
+			return result;
+		} else if (this.currentValue instanceof File) {
+			File inputFile = (File) this.currentValue;
+			Object result = null;
+			try {
+				result = SerializeUtils.readFromFile(inputFile);
+			} catch (Exception ex) {
+				throw new RuntimeException("Problem loading " + this.requiredType.getName() + " object from file '"
+						+ inputFile.getName() + "':\n" + ex.getMessage(), ex);
+			}
+			return result;
+		} else {
+			throw new RuntimeException("Could not materialize object of required type " + this.requiredType.getName()
+					+ ", found " + this.currentValue.getClass().getName() + " instead.");
+		}
+	}
+
+	@Override
+	public String getDefaultCLIString() {
+		return this.defaultCLIString;
+	}
+
+	/**
+	 * Gets the command line interface text of the class.
+	 *
+	 * @param aClass       the class
+	 * @param requiredType the class type
+	 * @return the command line interface text of the class
+	 */
+	public static String classToCLIString(Class<?> aClass, Class<?> requiredType) {
+		String className = aClass.getName();
+		String packageName = requiredType.getPackage().getName();
+		if (className.startsWith(packageName)) {
+			// cut off package name
+			className = className.substring(packageName.length() + 1, className.length());
+		} else if (Task.class.isAssignableFrom(aClass)) {
+			packageName = Task.class.getPackage().getName();
+			if (className.startsWith(packageName)) {
+				// cut off task package name
+				className = className.substring(packageName.length() + 1, className.length());
+			}
+		}
+		return className;
+	}
+
+	@Override
+	public abstract String getValueAsCLIString();
+
+	@Override
+	public abstract void setValueViaCLIString(String s);
+
+	// @Override
+	// public abstract JComponent getEditComponent();
+
+	/**
+	 * Gets the class name without its package name prefix.
+	 *
+	 * @param className    the name of the class
+	 * @param expectedType the type of the class
+	 * @return the class name without its package name prefix
+	 */
+	public static String stripPackagePrefix(String className, Class<?> expectedType) {
+		if (className.startsWith(expectedType.getPackage().getName())) {
+			return className.substring(expectedType.getPackage().getName().length() + 1);
+		}
+		return className;
+	}
 }
diff --git a/moa/src/main/java/moa/options/AbstractOptionHandler.java b/moa/src/main/java/moa/options/AbstractOptionHandler.java
index a26009fc4..1eb402c80 100644
--- a/moa/src/main/java/moa/options/AbstractOptionHandler.java
+++ b/moa/src/main/java/moa/options/AbstractOptionHandler.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.options;
 
@@ -27,167 +27,131 @@
 import moa.tasks.TaskMonitor;
 
 /**
- * Abstract Option Handler. All classes that have options in
- * MOA extend this class.
+ * Abstract Option Handler. All classes that have options in MOA extend this
+ * class.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public abstract class AbstractOptionHandler extends AbstractMOAObject implements
-        OptionHandler {
-
-    private static final long serialVersionUID = 1L;
-
-    /** Options to handle */
-    //protected Options options;
-
-    /** Dictionary with option texts and objects */
-    //protected Map<String, Object> classOptionNamesToPreparedObjects;
-
-    @Override
-    public String getPurposeString() {
-        return "Anonymous object: purpose undocumented.";
-    }
-
-    @Override
-    public Options getOptions() {
-        /*if (this.options == null) {
-            this.options = new Options();
-            if (this.config== null) {
-                this.config = new OptionsHandler(this, "");
-                this.config.prepareForUse();
-            }
-            Option[] myOptions = this.config.discoverOptionsViaReflection();
-            for (Option option : myOptions) {
-                this.options.addOption(option);
-            }
-        }
-        return this.options;*/
-        if ( this.config == null){
-            this.config = new OptionsHandler(this, "");
-            //this.config.prepareForUse(monitor, repository);
-        }
-        return this.config.getOptions();
-    }
-
-    @Override
-    public void prepareForUse() {
-        prepareForUse(new NullMonitor(), null);
-    }
-
-    protected OptionsHandler config; 
-    
-    @Override
-    public void prepareForUse(TaskMonitor monitor, ObjectRepository repository) {
-        //prepareClassOptions(monitor, repository);
-        if ( this.config == null){
-            this.config = new OptionsHandler(this, "");
-            this.config.prepareForUse(monitor, repository);
-        }
-        prepareForUseImpl(monitor, repository);
-    }
-
-    /**
-     * This method describes the implementation of how to prepare this object for use.
-     * All classes that extends this class have to implement <code>prepareForUseImpl</code>
-     * and not <code>prepareForUse</code> since
-     * <code>prepareForUse</code> calls <code>prepareForUseImpl</code>.
-     *
-     * @param monitor the TaskMonitor to use
-     * @param repository  the ObjectRepository to use
-     */
-    protected abstract void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository);
-
-    @Override
-    public String getCLICreationString(Class<?> expectedType) {
-        return ClassOption.stripPackagePrefix(this.getClass().getName(),
-                expectedType)
-                + " " + getOptions().getAsCLIString();
-    }
-
-    @Override
-    public OptionHandler copy() {
-        return (OptionHandler) super.copy();
-    }
-
-    /**
-     * Gets the options of this class via reflection.
-     *
-     * @return an array of options
-     */
- /*   protected Option[] discoverOptionsViaReflection() {
-        Class<? extends AbstractOptionHandler> c = this.getClass();
-        Field[] fields = c.getFields();
-        List<Option> optList = new LinkedList<Option>();
-        for (Field field : fields) {
-            String fName = field.getName();
-            Class<?> fType = field.getType();
-            if (fType.getName().endsWith("Option")) {
-                if (Option.class.isAssignableFrom(fType)) {
-                    Option oVal = null;
-                    try {
-                        field.setAccessible(true);
-                        oVal = (Option) field.get(this);
-                    } catch (IllegalAccessException ignored) {
-                        // cannot access this field
-                    }
-                    if (oVal != null) {
-                        optList.add(oVal);
-                    }
-                }
-            }
-        }
-        return optList.toArray(new Option[optList.size()]);
-    }*/
-
-    /**
-     * Prepares the options of this class.
-     * 
-     * @param monitor the TaskMonitor to use
-     * @param repository  the ObjectRepository to use
-     */
-    protected void prepareClassOptions(TaskMonitor monitor,
-            ObjectRepository repository) {
-       this.config.prepareClassOptions(monitor, repository); 
-    }/*
-        this.classOptionNamesToPreparedObjects = null;
-        Option[] optionArray = getOptions().getOptionArray();
-        for (Option option : optionArray) {
-            if (option instanceof ClassOption) {
-                ClassOption classOption = (ClassOption) option;
-                monitor.setCurrentActivity("Materializing option "
-                        + classOption.getName() + "...", -1.0);
-                Object optionObj = classOption.materializeObject(monitor,
-                        repository);
-                if (monitor.taskShouldAbort()) {
-                    return;
-                }
-                if (optionObj instanceof OptionHandler) {
-                    monitor.setCurrentActivity("Preparing option "
-                            + classOption.getName() + "...", -1.0);
-                    ((OptionHandler) optionObj).prepareForUse(monitor,
-                            repository);
-                    if (monitor.taskShouldAbort()) {
-                        return;
-                    }
-                }
-                if (this.classOptionNamesToPreparedObjects == null) {
-                    this.classOptionNamesToPreparedObjects = new HashMap<String, Object>();
-                }
-                this.classOptionNamesToPreparedObjects.put(option.getName(),
-                        optionObj);
-            }
-        }
-    }*/
-
-    /**
-     *  Gets a prepared option of this class.
-     *
-     * @param opt the class option to get
-     * @return an option stored in the dictionary
-     */
-    protected Object getPreparedClassOption(ClassOption opt) {
-        return this.config.getPreparedClassOption(opt);
-    }
+public abstract class AbstractOptionHandler extends AbstractMOAObject implements OptionHandler {
+
+	private static final long serialVersionUID = 1L;
+
+	/** Options to handle */
+	// protected Options options;
+
+	/** Dictionary with option texts and objects */
+	// protected Map<String, Object> classOptionNamesToPreparedObjects;
+
+	@Override
+	public String getPurposeString() {
+		return "Anonymous object: purpose undocumented.";
+	}
+
+	@Override
+	public Options getOptions() {
+		/*
+		 * if (this.options == null) { this.options = new Options(); if (this.config==
+		 * null) { this.config = new OptionsHandler(this, "");
+		 * this.config.prepareForUse(); } Option[] myOptions =
+		 * this.config.discoverOptionsViaReflection(); for (Option option : myOptions) {
+		 * this.options.addOption(option); } } return this.options;
+		 */
+		if (this.config == null) {
+			this.config = new OptionsHandler(this, "");
+			// this.config.prepareForUse(monitor, repository);
+		}
+		return this.config.getOptions();
+	}
+
+	@Override
+	public void prepareForUse() {
+		prepareForUse(new NullMonitor(), null);
+	}
+
+	protected OptionsHandler config;
+
+	@Override
+	public void prepareForUse(TaskMonitor monitor, ObjectRepository repository) {
+		// prepareClassOptions(monitor, repository);
+		if (this.config == null) {
+			this.config = new OptionsHandler(this, "");
+			this.config.prepareForUse(monitor, repository);
+		}
+		prepareForUseImpl(monitor, repository);
+	}
+
+	/**
+	 * This method describes the implementation of how to prepare this object for
+	 * use. All classes that extends this class have to implement
+	 * <code>prepareForUseImpl</code> and not <code>prepareForUse</code> since
+	 * <code>prepareForUse</code> calls <code>prepareForUseImpl</code>.
+	 *
+	 * @param monitor    the TaskMonitor to use
+	 * @param repository the ObjectRepository to use
+	 */
+	protected abstract void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository);
+
+	@Override
+	public String getCLICreationString(Class<?> expectedType) {
+		return AbstractClassOption.stripPackagePrefix(this.getClass().getName(), expectedType) + " "
+				+ getOptions().getAsCLIString();
+	}
+
+	@Override
+	public OptionHandler copy() {
+		return (OptionHandler) super.copy();
+	}
+
+	/**
+	 * Gets the options of this class via reflection.
+	 *
+	 * @return an array of options
+	 */
+	/*
+	 * protected Option[] discoverOptionsViaReflection() { Class<? extends
+	 * AbstractOptionHandler> c = this.getClass(); Field[] fields = c.getFields();
+	 * List<Option> optList = new LinkedList<Option>(); for (Field field : fields) {
+	 * String fName = field.getName(); Class<?> fType = field.getType(); if
+	 * (fType.getName().endsWith("Option")) { if
+	 * (Option.class.isAssignableFrom(fType)) { Option oVal = null; try {
+	 * field.setAccessible(true); oVal = (Option) field.get(this); } catch
+	 * (IllegalAccessException ignored) { // cannot access this field } if (oVal !=
+	 * null) { optList.add(oVal); } } } } return optList.toArray(new
+	 * Option[optList.size()]); }
+	 */
+
+	/**
+	 * Prepares the options of this class.
+	 * 
+	 * @param monitor    the TaskMonitor to use
+	 * @param repository the ObjectRepository to use
+	 */
+	protected void prepareClassOptions(TaskMonitor monitor, ObjectRepository repository) {
+		this.config.prepareClassOptions(monitor, repository);
+	}/*
+		 * this.classOptionNamesToPreparedObjects = null; Option[] optionArray =
+		 * getOptions().getOptionArray(); for (Option option : optionArray) { if (option
+		 * instanceof ClassOption) { ClassOption classOption = (ClassOption) option;
+		 * monitor.setCurrentActivity("Materializing option " + classOption.getName() +
+		 * "...", -1.0); Object optionObj = classOption.materializeObject(monitor,
+		 * repository); if (monitor.taskShouldAbort()) { return; } if (optionObj
+		 * instanceof OptionHandler) { monitor.setCurrentActivity("Preparing option " +
+		 * classOption.getName() + "...", -1.0); ((OptionHandler)
+		 * optionObj).prepareForUse(monitor, repository); if (monitor.taskShouldAbort())
+		 * { return; } } if (this.classOptionNamesToPreparedObjects == null) {
+		 * this.classOptionNamesToPreparedObjects = new HashMap<String, Object>(); }
+		 * this.classOptionNamesToPreparedObjects.put(option.getName(), optionObj); } }
+		 * }
+		 */
+
+	/**
+	 * Gets a prepared option of this class.
+	 *
+	 * @param opt the class option to get
+	 * @return an option stored in the dictionary
+	 */
+	protected Object getPreparedClassOption(ClassOption opt) {
+		return this.config.getPreparedClassOption(opt);
+	}
 }
diff --git a/moa/src/main/java/moa/options/ClassOption.java b/moa/src/main/java/moa/options/ClassOption.java
index ac9bb1d55..c2267d6a9 100644
--- a/moa/src/main/java/moa/options/ClassOption.java
+++ b/moa/src/main/java/moa/options/ClassOption.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.options;
 
@@ -34,139 +34,128 @@
  */
 public class ClassOption extends AbstractClassOption {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public ClassOption(String name, char cliChar, String purpose,
-            Class<?> requiredType, String defaultCLIString) {
-        super(name, cliChar, purpose, requiredType, defaultCLIString);
-    }
+	public ClassOption(String name, char cliChar, String purpose, Class<?> requiredType, String defaultCLIString) {
+		super(name, cliChar, purpose, requiredType, defaultCLIString);
+	}
 
-    public ClassOption(String name, char cliChar, String purpose,
-            Class<?> requiredType, String defaultCLIString, String nullString) {
-        super(name, cliChar, purpose, requiredType, defaultCLIString, nullString);
-    }
+	public ClassOption(String name, char cliChar, String purpose, Class<?> requiredType, String defaultCLIString,
+			String nullString) {
+		super(name, cliChar, purpose, requiredType, defaultCLIString, nullString);
+	}
 
-    @Override
-    public String getValueAsCLIString() {
-        if ((this.currentValue == null) && (this.nullString != null)) {
-            return this.nullString;
-        }
-        return objectToCLIString(this.currentValue, this.requiredType);
-    }
+	@Override
+	public String getValueAsCLIString() {
+		if ((this.currentValue == null) && (this.nullString != null)) {
+			return this.nullString;
+		}
+		return objectToCLIString(this.currentValue, this.requiredType);
+	}
 
-    @Override
-    public void setValueViaCLIString(String s) {
-        if ((this.nullString != null)
-                && ((s == null) || (s.length() == 0) || s.equals(this.nullString))) {
-            this.currentValue = null;
-        } else {
-            try {
-                this.currentValue = cliStringToObject(s, this.requiredType,
-                        null);
-            } catch (Exception e) {
-                throw new IllegalArgumentException("Problems with option: " + getName(), e);
-            }
-        }
-    }
+	@Override
+	public void setValueViaCLIString(String s) {
+		if ((this.nullString != null) && ((s == null) || (s.length() == 0) || s.equals(this.nullString))) {
+			this.currentValue = null;
+		} else {
+			try {
+				this.currentValue = cliStringToObject(s, this.requiredType, null);
+			} catch (Exception e) {
+				throw new IllegalArgumentException("Problems with option: " + getName(), e);
+			}
+		}
+	}
 
-    public static String objectToCLIString(Object obj, Class<?> requiredType) {
-        if (obj == null) {
-            return "";
-        }
-        if (obj instanceof File) {
-            return (FILE_PREFIX_STRING + ((File) obj).getPath());
-        }
-        if (obj instanceof String) {
-            return (INMEM_PREFIX_STRING + obj);
-        }
-        String className = classToCLIString(obj.getClass(), requiredType);
-        if (obj instanceof OptionHandler) {
-            String subOptions = ((OptionHandler) obj).getOptions().getAsCLIString();
-            if (subOptions.length() > 0) {
-                return (className + " " + subOptions);
-            }
-        }
-        return className;
-    }
+	public static String objectToCLIString(Object obj, Class<?> requiredType) {
+		if (obj == null) {
+			return "";
+		}
+		if (obj instanceof File) {
+			return (FILE_PREFIX_STRING + ((File) obj).getPath());
+		}
+		if (obj instanceof String) {
+			return (INMEM_PREFIX_STRING + obj);
+		}
+		String className = classToCLIString(obj.getClass(), requiredType);
+		if (obj instanceof OptionHandler) {
+			String subOptions = ((OptionHandler) obj).getOptions().getAsCLIString();
+			if (subOptions.length() > 0) {
+				return (className + " " + subOptions);
+			}
+		}
+		return className;
+	}
 
-    public static Object cliStringToObject(String cliString,
-            Class<?> requiredType, Option[] externalOptions) throws Exception {
-        if (cliString.startsWith(INMEM_PREFIX_STRING)) {
-            return cliString.substring(INMEM_PREFIX_STRING.length());
-        }
-        cliString = cliString.trim();
-        int firstSpaceIndex = cliString.indexOf(' ', 0);
-        String className;
-        String classOptions;
-        if (firstSpaceIndex > 0) {
-            className = cliString.substring(0, firstSpaceIndex);
-            classOptions = cliString.substring(firstSpaceIndex + 1, cliString.length());
-            classOptions = classOptions.trim();
-        } else {
-            className = cliString;
-            classOptions = "";
-        }
-        Class<?> classObject;
-        try {
-            classObject = Class.forName(className);
-        } catch (Throwable t1) {
-            try {
-                // try prepending default package
-                classObject = Class.forName(requiredType.getPackage().getName()
-                        + "." + className);
-            } catch (Throwable t2) {
-                try {
-                    // try prepending task package
-                    classObject = Class.forName(Task.class.getPackage().getName()
-                            + "." + className);
-                } catch (Throwable t3) {
-                    throw new Exception("Class not found: " + className);
-                }
-            }
-        }
-        Object classInstance;
-        try {
-            classInstance = classObject.newInstance();
-        } catch (Exception ex) {
-            throw new Exception("Problem creating instance of class: "
-                    + className, ex);
-        }
-        if (requiredType.isInstance(classInstance)
-                || ((classInstance instanceof Task) && requiredType.isAssignableFrom(((Task) classInstance).getTaskResultType()))) {
-            Options options = new Options();
-            if (externalOptions != null) {
-                for (Option option : externalOptions) {
-                    options.addOption(option);
-                }
-            }
-            if (classInstance instanceof OptionHandler) {
-                Option[] objectOptions = ((OptionHandler) classInstance).getOptions().getOptionArray();
-                for (Option option : objectOptions) {
-                    options.addOption(option);
-                }
-            }
-            try {
-                options.setViaCLIString(classOptions);
-            } catch (Exception ex) {
-                throw new Exception("Problem with options to '"
-                        + className
-                        + "'."
-                        + "\n\nValid options for "
-                        + className
-                        + ":\n"
-                        + ((OptionHandler) classInstance).getOptions().getHelpString(), ex);
-            } finally {
-                options.removeAllOptions(); // clean up listener refs
-            }
-        } else {
-            throw new Exception("Class named '" + className
-                    + "' is not an instance of " + requiredType.getName() + ".");
-        }
-        return classInstance;
-    }
+	public static Object cliStringToObject(String cliString, Class<?> requiredType, Option[] externalOptions)
+			throws Exception {
+		if (cliString.startsWith(INMEM_PREFIX_STRING)) {
+			return cliString.substring(INMEM_PREFIX_STRING.length());
+		}
+		cliString = cliString.trim();
+		int firstSpaceIndex = cliString.indexOf(' ', 0);
+		String className;
+		String classOptions;
+		if (firstSpaceIndex > 0) {
+			className = cliString.substring(0, firstSpaceIndex);
+			classOptions = cliString.substring(firstSpaceIndex + 1, cliString.length());
+			classOptions = classOptions.trim();
+		} else {
+			className = cliString;
+			classOptions = "";
+		}
+		Class<?> classObject;
+		try {
+			classObject = Class.forName(className);
+		} catch (Throwable t1) {
+			try {
+				// try prepending default package
+				classObject = Class.forName(requiredType.getPackage().getName() + "." + className);
+			} catch (Throwable t2) {
+				try {
+					// try prepending task package
+					classObject = Class.forName(Task.class.getPackage().getName() + "." + className);
+				} catch (Throwable t3) {
+					throw new Exception("Class not found: " + className);
+				}
+			}
+		}
+		Object classInstance;
+		try {
+			classInstance = classObject.newInstance();
+		} catch (Exception ex) {
+			throw new Exception("Problem creating instance of class: " + className, ex);
+		}
+		if (requiredType.isInstance(classInstance) || ((classInstance instanceof Task)
+				&& requiredType.isAssignableFrom(((Task) classInstance).getTaskResultType()))) {
+			Options options = new Options();
+			if (externalOptions != null) {
+				for (Option option : externalOptions) {
+					options.addOption(option);
+				}
+			}
+			if (classInstance instanceof OptionHandler) {
+				Option[] objectOptions = ((OptionHandler) classInstance).getOptions().getOptionArray();
+				for (Option option : objectOptions) {
+					options.addOption(option);
+				}
+			}
+			try {
+				options.setViaCLIString(classOptions);
+			} catch (Exception ex) {
+				throw new Exception("Problem with options to '" + className + "'." + "\n\nValid options for "
+						+ className + ":\n" + ((OptionHandler) classInstance).getOptions().getHelpString(), ex);
+			} finally {
+				options.removeAllOptions(); // clean up listener refs
+			}
+		} else {
+			throw new Exception(
+					"Class named '" + className + "' is not an instance of " + requiredType.getName() + ".");
+		}
+		return classInstance;
+	}
 
-    //@Override
-    //public JComponent getEditComponent() {
-    //    return new ClassOptionEditComponent(this);
-    //}
+	// @Override
+	// public JComponent getEditComponent() {
+	// return new ClassOptionEditComponent(this);
+	// }
 }
diff --git a/moa/src/main/java/moa/options/ClassOptionWithListenerOption.java b/moa/src/main/java/moa/options/ClassOptionWithListenerOption.java
index 475e93b85..c1af62623 100644
--- a/moa/src/main/java/moa/options/ClassOptionWithListenerOption.java
+++ b/moa/src/main/java/moa/options/ClassOptionWithListenerOption.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.options;
 
@@ -24,61 +24,50 @@
 /**
  * ClassOption that can be given a ChangeListener. The listener is notified
  * whenever a new value is set for this option.
- * 
+ *
  * @author Cornelius Styp von Rekowski (cornelius.styp@ovgu.de)
  * @version $Revision: 1 $
  */
 public class ClassOptionWithListenerOption extends ClassOption {
-	
+
 	private static final long serialVersionUID = 1L;
-	
+
 	protected ChangeListener listener;
-	
-	public ClassOptionWithListenerOption(String name, char cliChar, 
-			String purpose, Class<?> requiredType,
-			String defaultCLIString) 
-	{
+
+	public ClassOptionWithListenerOption(String name, char cliChar, String purpose, Class<?> requiredType,
+			String defaultCLIString) {
 		super(name, cliChar, purpose, requiredType, defaultCLIString);
 	}
-	
-	public ClassOptionWithListenerOption(String name, char cliChar, 
-			String purpose, Class<?> requiredType,
-			String defaultCLIString, ChangeListener listener) 
-	{
+
+	public ClassOptionWithListenerOption(String name, char cliChar, String purpose, Class<?> requiredType,
+			String defaultCLIString, ChangeListener listener) {
 		super(name, cliChar, purpose, requiredType, defaultCLIString);
 		this.listener = listener;
 	}
-	
-	public ClassOptionWithListenerOption(String name, char cliChar, 
-			String purpose, Class<?> requiredType, 
-			String defaultCLIString, String nullString) 
-	{
-        super(name, cliChar, purpose, requiredType, defaultCLIString, 
-        		nullString);
-    }
-	
-	public ClassOptionWithListenerOption(String name, char cliChar, 
-			String purpose, Class<?> requiredType, 
-			String defaultCLIString, String nullString,
-			ChangeListener listener) 
-	{
-        super(name, cliChar, purpose, requiredType, defaultCLIString, 
-        		nullString);
-        this.listener = listener;
-    }
-	
+
+	public ClassOptionWithListenerOption(String name, char cliChar, String purpose, Class<?> requiredType,
+			String defaultCLIString, String nullString) {
+		super(name, cliChar, purpose, requiredType, defaultCLIString, nullString);
+	}
+
+	public ClassOptionWithListenerOption(String name, char cliChar, String purpose, Class<?> requiredType,
+			String defaultCLIString, String nullString, ChangeListener listener) {
+		super(name, cliChar, purpose, requiredType, defaultCLIString, nullString);
+		this.listener = listener;
+	}
+
 	public void setChangeListener(ChangeListener listener) {
 		this.listener = listener;
 	}
-	
+
 	public ChangeListener getChangeListener() {
 		return this.listener;
 	}
-	
+
 	@Override
 	public void setValueViaCLIString(String s) {
 		super.setValueViaCLIString(s);
-		
+
 		// inform dependent options about change
 		if (this.listener != null) {
 			this.listener.stateChanged(null);
diff --git a/moa/src/main/java/moa/options/ClassOptionWithNames.java b/moa/src/main/java/moa/options/ClassOptionWithNames.java
index 59959d90c..59273adf9 100644
--- a/moa/src/main/java/moa/options/ClassOptionWithNames.java
+++ b/moa/src/main/java/moa/options/ClassOptionWithNames.java
@@ -1,9 +1,9 @@
 /**
  * [ClassOptionWithNames.java]
- * 
+ *
  * A variation of [ClassOption], which you can choose specific classes as its entries.
  * In the constructor, put a list of class names you want to add (String[] classNames) as an argument.
- * 
+ *
  * @author Yunsu Kim
  * 		   based on the implementation of Richard Kirkby
  * Data Management and Data Exploration Group, RWTH Aachen University
@@ -20,149 +20,139 @@
 
 public class ClassOptionWithNames extends AbstractClassOption {
 
-    private static final long serialVersionUID = 1L;
-    private String[] names;
+	private static final long serialVersionUID = 1L;
+	private String[] names;
 
-    public ClassOptionWithNames(String name, char cliChar, String purpose,
-            Class<?> requiredType, String defaultCLIString, String[] classNames) {
-        super(name, cliChar, purpose, requiredType, defaultCLIString);
-        this.names = classNames;
-    }
+	public ClassOptionWithNames(String name, char cliChar, String purpose, Class<?> requiredType,
+			String defaultCLIString, String[] classNames) {
+		super(name, cliChar, purpose, requiredType, defaultCLIString);
+		this.names = classNames;
+	}
 
-    public ClassOptionWithNames(String name, char cliChar, String purpose,
-            Class<?> requiredType, String defaultCLIString, String nullString, String[] classNames) {
-        super(name, cliChar, purpose, requiredType, defaultCLIString, nullString);
-        this.names = classNames;
-    }
+	public ClassOptionWithNames(String name, char cliChar, String purpose, Class<?> requiredType,
+			String defaultCLIString, String nullString, String[] classNames) {
+		super(name, cliChar, purpose, requiredType, defaultCLIString, nullString);
+		this.names = classNames;
+	}
 
-    @Override
-    public String getValueAsCLIString() {
-        if ((this.currentValue == null) && (this.nullString != null)) {
-            return this.nullString;
-        }
-        return objectToCLIString(this.currentValue, this.requiredType);
-    }
+	@Override
+	public String getValueAsCLIString() {
+		if ((this.currentValue == null) && (this.nullString != null)) {
+			return this.nullString;
+		}
+		return objectToCLIString(this.currentValue, this.requiredType);
+	}
 
-    @Override
-    public void setValueViaCLIString(String s) {
-        if ((this.nullString != null)
-                && ((s == null) || (s.length() == 0) || s.equals(this.nullString))) {
-            this.currentValue = null;
-        } else {
-            try {
-                this.currentValue = cliStringToObject(s, this.requiredType,
-                        null);
-            } catch (Exception e) {
-                throw new IllegalArgumentException("Problems with option: " + getName(), e);
-            }
-        }
-    }
+	@Override
+	public void setValueViaCLIString(String s) {
+		if ((this.nullString != null) && ((s == null) || (s.length() == 0) || s.equals(this.nullString))) {
+			this.currentValue = null;
+		} else {
+			try {
+				this.currentValue = cliStringToObject(s, this.requiredType, null);
+			} catch (Exception e) {
+				throw new IllegalArgumentException("Problems with option: " + getName(), e);
+			}
+		}
+	}
 
-    public static String objectToCLIString(Object obj, Class<?> requiredType) {
-        if (obj == null) {
-            return "";
-        }
-        if (obj instanceof File) {
-            return (FILE_PREFIX_STRING + ((File) obj).getPath());
-        }
-        if (obj instanceof String) {
-            return (INMEM_PREFIX_STRING + obj);
-        }
-        String className = classToCLIString(obj.getClass(), requiredType);
-        if (obj instanceof OptionHandler) {
-            String subOptions = ((OptionHandler) obj).getOptions().getAsCLIString();
-            if (subOptions.length() > 0) {
-                return (className + " " + subOptions);
-            }
-        }
-        return className;
-    }
+	public static String objectToCLIString(Object obj, Class<?> requiredType) {
+		if (obj == null) {
+			return "";
+		}
+		if (obj instanceof File) {
+			return (FILE_PREFIX_STRING + ((File) obj).getPath());
+		}
+		if (obj instanceof String) {
+			return (INMEM_PREFIX_STRING + obj);
+		}
+		String className = classToCLIString(obj.getClass(), requiredType);
+		if (obj instanceof OptionHandler) {
+			String subOptions = ((OptionHandler) obj).getOptions().getAsCLIString();
+			if (subOptions.length() > 0) {
+				return (className + " " + subOptions);
+			}
+		}
+		return className;
+	}
 
-    public static Object cliStringToObject(String cliString,
-            Class<?> requiredType, Option[] externalOptions) throws Exception {
-        if (cliString.startsWith(FILE_PREFIX_STRING)) {
-            return new File(cliString.substring(FILE_PREFIX_STRING.length()));
-        }
-        if (cliString.startsWith(INMEM_PREFIX_STRING)) {
-            return cliString.substring(INMEM_PREFIX_STRING.length());
-        }
-        cliString = cliString.trim();
-        int firstSpaceIndex = cliString.indexOf(' ', 0);
-        String className;
-        String classOptions;
-        if (firstSpaceIndex > 0) {
-            className = cliString.substring(0, firstSpaceIndex);
-            classOptions = cliString.substring(firstSpaceIndex + 1, cliString.length());
-            classOptions = classOptions.trim();
-        } else {
-            className = cliString;
-            classOptions = "";
-        }
-        Class<?> classObject;
-        try {
-            classObject = Class.forName(className);
-        } catch (Throwable t1) {
-            try {
-                // try prepending default package
-                classObject = Class.forName(requiredType.getPackage().getName()
-                        + "." + className);
-            } catch (Throwable t2) {
-                try {
-                    // try prepending task package
-                    classObject = Class.forName(Task.class.getPackage().getName()
-                            + "." + className);
-                } catch (Throwable t3) {
-                    throw new Exception("Class not found: " + className);
-                }
-            }
-        }
-        Object classInstance;
-        try {
-            classInstance = classObject.newInstance();
-        } catch (Exception ex) {
-            throw new Exception("Problem creating instance of class: "
-                    + className, ex);
-        }
-        if (requiredType.isInstance(classInstance)
-                || ((classInstance instanceof Task) && requiredType.isAssignableFrom(((Task) classInstance).getTaskResultType()))) {
-            Options options = new Options();
-            if (externalOptions != null) {
-                for (Option option : externalOptions) {
-                    options.addOption(option);
-                }
-            }
-            if (classInstance instanceof OptionHandler) {
-                Option[] objectOptions = ((OptionHandler) classInstance).getOptions().getOptionArray();
-                for (Option option : objectOptions) {
-                    options.addOption(option);
-                }
-            }
-            try {
-                options.setViaCLIString(classOptions);
-            } catch (Exception ex) {
-                throw new Exception("Problem with options to '"
-                        + className
-                        + "'."
-                        + "\n\nValid options for "
-                        + className
-                        + ":\n"
-                        + ((OptionHandler) classInstance).getOptions().getHelpString(), ex);
-            } finally {
-                options.removeAllOptions(); // clean up listener refs
-            }
-        } else {
-            throw new Exception("Class named '" + className
-                    + "' is not an instance of " + requiredType.getName() + ".");
-        }
-        return classInstance;
-    }
+	public static Object cliStringToObject(String cliString, Class<?> requiredType, Option[] externalOptions)
+			throws Exception {
+		if (cliString.startsWith(FILE_PREFIX_STRING)) {
+			return new File(cliString.substring(FILE_PREFIX_STRING.length()));
+		}
+		if (cliString.startsWith(INMEM_PREFIX_STRING)) {
+			return cliString.substring(INMEM_PREFIX_STRING.length());
+		}
+		cliString = cliString.trim();
+		int firstSpaceIndex = cliString.indexOf(' ', 0);
+		String className;
+		String classOptions;
+		if (firstSpaceIndex > 0) {
+			className = cliString.substring(0, firstSpaceIndex);
+			classOptions = cliString.substring(firstSpaceIndex + 1, cliString.length());
+			classOptions = classOptions.trim();
+		} else {
+			className = cliString;
+			classOptions = "";
+		}
+		Class<?> classObject;
+		try {
+			classObject = Class.forName(className);
+		} catch (Throwable t1) {
+			try {
+				// try prepending default package
+				classObject = Class.forName(requiredType.getPackage().getName() + "." + className);
+			} catch (Throwable t2) {
+				try {
+					// try prepending task package
+					classObject = Class.forName(Task.class.getPackage().getName() + "." + className);
+				} catch (Throwable t3) {
+					throw new Exception("Class not found: " + className);
+				}
+			}
+		}
+		Object classInstance;
+		try {
+			classInstance = classObject.newInstance();
+		} catch (Exception ex) {
+			throw new Exception("Problem creating instance of class: " + className, ex);
+		}
+		if (requiredType.isInstance(classInstance) || ((classInstance instanceof Task)
+				&& requiredType.isAssignableFrom(((Task) classInstance).getTaskResultType()))) {
+			Options options = new Options();
+			if (externalOptions != null) {
+				for (Option option : externalOptions) {
+					options.addOption(option);
+				}
+			}
+			if (classInstance instanceof OptionHandler) {
+				Option[] objectOptions = ((OptionHandler) classInstance).getOptions().getOptionArray();
+				for (Option option : objectOptions) {
+					options.addOption(option);
+				}
+			}
+			try {
+				options.setViaCLIString(classOptions);
+			} catch (Exception ex) {
+				throw new Exception("Problem with options to '" + className + "'." + "\n\nValid options for "
+						+ className + ":\n" + ((OptionHandler) classInstance).getOptions().getHelpString(), ex);
+			} finally {
+				options.removeAllOptions(); // clean up listener refs
+			}
+		} else {
+			throw new Exception(
+					"Class named '" + className + "' is not an instance of " + requiredType.getName() + ".");
+		}
+		return classInstance;
+	}
 
 //    @Override
 //    public JComponent getEditComponent() {
 //        return new ClassOptionWithNamesEditComponent(this);
 //    }
-    
-    public String[] getClassNames() {
-    	return this.names;
-    }
+
+	public String[] getClassNames() {
+		return this.names;
+	}
 }
diff --git a/moa/src/main/java/moa/options/DependentOptionsUpdater.java b/moa/src/main/java/moa/options/DependentOptionsUpdater.java
index 4de2bfeab..0284e3187 100644
--- a/moa/src/main/java/moa/options/DependentOptionsUpdater.java
+++ b/moa/src/main/java/moa/options/DependentOptionsUpdater.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.options;
 
@@ -33,155 +33,139 @@
 import moa.tasks.meta.ALPrequentialEvaluationTask;
 
 /**
- * This class handles the dependency between two options by updating the 
+ * This class handles the dependency between two options by updating the
  * dependent option whenever the option it is depending on changes.
- * 
+ *
  * @author Cornelius Styp von Rekowski (cornelius.styp@ovgu.de)
  * @version $Revision: 1 $
  */
 public class DependentOptionsUpdater implements ChangeListener, Serializable {
-	
+
 	private static final long serialVersionUID = 1L;
-	
+
 	protected String lastEvalTaskCLIString;
 	protected ClassOptionWithListenerOption evalTaskOption;
 	protected EditableMultiChoiceOption variedParamNameOption;
-	
-	public DependentOptionsUpdater(
-			ClassOptionWithListenerOption learnerOption,
-			EditableMultiChoiceOption variedParamNameOption) 
-	{
+
+	public DependentOptionsUpdater(ClassOptionWithListenerOption learnerOption,
+			EditableMultiChoiceOption variedParamNameOption) {
 		this.evalTaskOption = learnerOption;
 		this.variedParamNameOption = variedParamNameOption;
-		
+
 		this.evalTaskOption.setChangeListener(this);
 	}
-	
+
 	@Override
 	public void stateChanged(ChangeEvent e) {
 		this.refreshVariedParamNameOption();
 	}
-	
+
 	/**
-	 * Refresh the provided choices of an EditableMultiChoiceOption every time
-	 * a ClassOption (the prequential evaluation task) is changed. This method 
-	 * checks if the chosen task actually changed, before updating the 
-	 * MultiChoiceOption.
+	 * Refresh the provided choices of an EditableMultiChoiceOption every time a
+	 * ClassOption (the prequential evaluation task) is changed. This method checks
+	 * if the chosen task actually changed, before updating the MultiChoiceOption.
 	 * <br>
 	 * The method looks for available options in the learner option of the
-	 * prequential evaluation task and recursively in all of its ClassOptions.
-	 * <br>
-	 * Only Int and Float options are shown in the MultiChoiceOption, because 
-	 * only numeric parameters should be variable.
-	 * <br>
-	 * If one of the options is named "budget" or its name contains the word 
+	 * prequential evaluation task and recursively in all of its ClassOptions. <br>
+	 * Only Int and Float options are shown in the MultiChoiceOption, because only
+	 * numeric parameters should be variable. <br>
+	 * If one of the options is named "budget" or its name contains the word
 	 * "budget", it is selected as the default option.
-	 * 
+	 *
 	 * @param evalTaskOption
 	 * @param variedParamNameOption
 	 */
-	public void refreshVariedParamNameOption()
-	{
-		String currentEvalTaskCLIString = 
-				this.evalTaskOption.getValueAsCLIString();
-		
+	public void refreshVariedParamNameOption() {
+		String currentEvalTaskCLIString = this.evalTaskOption.getValueAsCLIString();
+
 		// check if an update is actually needed
-		if (this.lastEvalTaskCLIString == null || 
-			!this.lastEvalTaskCLIString.equals(currentEvalTaskCLIString)) 
-		{
+		if (this.lastEvalTaskCLIString == null || !this.lastEvalTaskCLIString.equals(currentEvalTaskCLIString)) {
 			this.lastEvalTaskCLIString = currentEvalTaskCLIString;
-			
+
 			// create result lists
-			List<String> optionNames = new ArrayList<String>();
-			List<String> optionDescriptions = new ArrayList<String>();
-			
+			List<String> optionNames = new ArrayList<>();
+			List<String> optionDescriptions = new ArrayList<>();
+
 			// recursively add options
-			ALPrequentialEvaluationTask evalTask = 
-					(ALPrequentialEvaluationTask) 
-					this.evalTaskOption.getPreMaterializedObject();
-			this.addRecursiveNumberOptions(
-					evalTask.learnerOption, optionNames, optionDescriptions, "");
-			
+			ALPrequentialEvaluationTask evalTask = (ALPrequentialEvaluationTask) this.evalTaskOption
+					.getPreMaterializedObject();
+			this.addRecursiveNumberOptions(evalTask.learnerOption, optionNames, optionDescriptions, "");
+
 			// get option names and descriptions and look for default option
 			int defaultIndex = -1;
 			for (int i = 0; i < optionNames.size(); i++) {
-				if (optionNames.get(i).endsWith("/budget") || 
-					(optionNames.get(i).contains("budget") && defaultIndex < 0)) 
-				{
+				if (optionNames.get(i).endsWith("/budget")
+						|| (optionNames.get(i).contains("budget") && defaultIndex < 0)) {
 					defaultIndex = i;
 				}
 			}
-			
+
 			// pass new options to the EditableMultiChoiceOption
-			this.variedParamNameOption.setOptions(
-					optionNames.toArray(new String[0]), 
-					optionDescriptions.toArray(new String[0]), 
-					defaultIndex >= 0 ? defaultIndex : 0);
+			this.variedParamNameOption.setOptions(optionNames.toArray(new String[0]),
+					optionDescriptions.toArray(new String[0]), defaultIndex >= 0 ? defaultIndex : 0);
 		}
 	}
-	
-	private void addRecursiveNumberOptions(ClassOption option, 
-			List<String> optionNames, List<String> optionDescriptions,
-			String namePrefix) 
-	{
+
+	private void addRecursiveNumberOptions(ClassOption option, List<String> optionNames,
+			List<String> optionDescriptions, String namePrefix) {
 		OptionHandler optionHandler = (OptionHandler) option.getPreMaterializedObject();
-		Option[]      options       = optionHandler.getOptions().getOptionArray();
-		
+		Option[] options = optionHandler.getOptions().getOptionArray();
+
 		// filter for Int and Float Options
-		List<Option> numberOptions = new ArrayList<Option>(options.length);
+		List<Option> numberOptions = new ArrayList<>(options.length);
 		for (Option o : options) {
 			if (o instanceof IntOption || o instanceof FloatOption) {
 				numberOptions.add(o);
 			}
 		}
-		
+
 		// get names and descriptions
-		String       newNamePrefix = namePrefix + option.getName() + "/";
-		List<String> names         = new ArrayList<String>(numberOptions.size());
-		List<String> descriptions  = new ArrayList<String>(numberOptions.size());
+		String newNamePrefix = namePrefix + option.getName() + "/";
+		List<String> names = new ArrayList<>(numberOptions.size());
+		List<String> descriptions = new ArrayList<>(numberOptions.size());
 		for (Option o : numberOptions) {
 			names.add(newNamePrefix + o.getName());
 			descriptions.add(o.getPurpose());
 		}
-		
+
 		// add to overall lists
 		optionNames.addAll(names);
 		optionDescriptions.addAll(descriptions);
-		
+
 		// filter for ClassOptions
-		List<ClassOption> classOptions = new ArrayList<ClassOption>(options.length);
+		List<ClassOption> classOptions = new ArrayList<>(options.length);
 		for (Option o : options) {
 			if (o instanceof ClassOption) {
 				classOptions.add((ClassOption) o);
 			}
 		}
-		
+
 		// add number options of this class option to the overall list
 		for (ClassOption classOption : classOptions) {
-			this.addRecursiveNumberOptions(classOption, 
-					optionNames, optionDescriptions, newNamePrefix);
+			this.addRecursiveNumberOptions(classOption, optionNames, optionDescriptions, newNamePrefix);
 		}
 	}
-	
+
 	/**
 	 * Resolve the name of the varied parameter and return the corresponding option.
-	 * The varied parameter name has the format "learner/suboptions.../numberOption".
-	 * If no matching parameter can be found, <code>null</code> is returned.
-	 * 
-	 * @param learner the learner object that has the varied option
+	 * The varied parameter name has the format
+	 * "learner/suboptions.../numberOption". If no matching parameter can be found,
+	 * <code>null</code> is returned.
+	 *
+	 * @param learner         the learner object that has the varied option
 	 * @param variedParamName name of the (nested) varied parameter
 	 * @return varied option
 	 */
 	public static Option getVariedOption(OptionHandler learner, String variedParamName) {
 		// split nested option string
 		String[] singleOptions = variedParamName.split("/");
-		
+
 		// check if first level is "learner", which has already been resolved
 		int startIndex = 0;
 		if (singleOptions.length > 0 && singleOptions[0].equals("learner/")) {
 			startIndex = 1;
 		}
-		
+
 		// iteratively create objects and get next options for each level
 		Option learnerVariedParamOption = null;
 		OptionHandler currentOptionHandler = learner;
@@ -189,17 +173,15 @@ public static Option getVariedOption(OptionHandler learner, String variedParamNa
 			for (Option opt : currentOptionHandler.getOptions().getOptionArray()) {
 				if (opt.getName().equals(singleOptions[i])) {
 					if (opt instanceof ClassOption) {
-						currentOptionHandler = (OptionHandler) 
-								((ClassOption) opt).getPreMaterializedObject();
-					}
-					else {
+						currentOptionHandler = (OptionHandler) ((ClassOption) opt).getPreMaterializedObject();
+					} else {
 						learnerVariedParamOption = opt;
 					}
 					break;
 				}
 			}
 		}
-		
+
 		return learnerVariedParamOption;
 	}
 }
diff --git a/moa/src/main/java/moa/options/EditableMultiChoiceOption.java b/moa/src/main/java/moa/options/EditableMultiChoiceOption.java
index 9a3e67467..5461447bd 100644
--- a/moa/src/main/java/moa/options/EditableMultiChoiceOption.java
+++ b/moa/src/main/java/moa/options/EditableMultiChoiceOption.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.options;
 
@@ -25,7 +25,7 @@
 
 /**
  * MultiChoiceOption that can have changing options.
- * 
+ *
  * @author Cornelius Styp von Rekowski (cornelius.styp@ovgu.de)
  * @version $Revision: 1 $
  */
@@ -33,70 +33,60 @@ public class EditableMultiChoiceOption extends MultiChoiceOption {
 
 	private static final long serialVersionUID = 1L;
 	private static final String NO_CHOICES = "--";
-	private static final String NO_CHOICES_DESCRIPTION = 
-			"No choices available.";
-	
+	private static final String NO_CHOICES_DESCRIPTION = "No choices available.";
+
 	/**
 	 * The corresponding UI component
 	 */
 	protected EditableMultiChoiceOptionEditComponent editComponent;
 
-	public EditableMultiChoiceOption(String name, char cliChar, 
-			String purpose, String[] optionLabels,
-			String[] optionDescriptions, int defaultOptionIndex) 
-	{
-		super(name, cliChar, purpose, optionLabels, optionDescriptions, 
-				defaultOptionIndex);
-		
+	public EditableMultiChoiceOption(String name, char cliChar, String purpose, String[] optionLabels,
+			String[] optionDescriptions, int defaultOptionIndex) {
+		super(name, cliChar, purpose, optionLabels, optionDescriptions, defaultOptionIndex);
+
 		// set initial options and refresh edit component
 		this.setOptions(optionLabels, optionDescriptions, defaultOptionIndex);
 	}
-	
+
 	/**
-	 * Register the corresponding UI component, so that it can be refreshed
-	 * when options have changed.
-	 * 
+	 * Register the corresponding UI component, so that it can be refreshed when
+	 * options have changed.
+	 *
 	 * @param editComponent
 	 */
-	public void registerEditComponent(
-			EditableMultiChoiceOptionEditComponent editComponent) 
-	{
+	public void registerEditComponent(EditableMultiChoiceOptionEditComponent editComponent) {
 		this.editComponent = editComponent;
 	}
-	
+
 	/**
-	 * Set new options for this MultiChoiceOption and refresh the edit 
-	 * component.
-	 * 
+	 * Set new options for this MultiChoiceOption and refresh the edit component.
+	 *
 	 * @param labels
 	 * @param descriptions
 	 * @param defaultIndex
 	 */
-	public void setOptions(
-			String[] labels, String[] descriptions, int defaultIndex) 
-	{
+	public void setOptions(String[] labels, String[] descriptions, int defaultIndex) {
 		if (labels.length != descriptions.length) {
-            throw new IllegalArgumentException("Labels/descriptions mismatch.");
-        }
-		
+			throw new IllegalArgumentException("Labels/descriptions mismatch.");
+		}
+
 		if (labels.length > 0) {
 			this.optionLabels = labels.clone();
 			this.optionDescriptions = descriptions.clone();
 			this.defaultOptionIndex = defaultIndex;
-		}
-		else {
+		} else {
 			// use placeholders for empty list of choices
-			this.optionLabels = new String[]{NO_CHOICES};
-			this.optionDescriptions = new String[]{NO_CHOICES_DESCRIPTION};
+			this.optionLabels = new String[] { NO_CHOICES };
+			this.optionDescriptions = new String[] { NO_CHOICES_DESCRIPTION };
 			this.defaultOptionIndex = 0;
 		}
-		
+
 		// reset to default value
-        resetToDefault();
-        
-        // refresh the edit component
-        if (this.editComponent != null) {
-        	this.editComponent.refresh();
-        }
+		resetToDefault();
+
+		// refresh the edit component
+		if (this.editComponent != null) {
+			this.editComponent.refresh();
+		}
 	}
 }
diff --git a/moa/src/main/java/moa/options/OptionHandler.java b/moa/src/main/java/moa/options/OptionHandler.java
index 1fac302da..a3c00ce97 100644
--- a/moa/src/main/java/moa/options/OptionHandler.java
+++ b/moa/src/main/java/moa/options/OptionHandler.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.options;
 
@@ -27,53 +27,53 @@
 import moa.tasks.TaskMonitor;
 
 /**
- * Interface representing an object that handles options or parameters. 
+ * Interface representing an object that handles options or parameters.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $ 
+ * @version $Revision: 7 $
  */
 public interface OptionHandler extends MOAObject, Configurable {
 
-    /**
-     * Gets the purpose of this object
-     *
-     * @return the string with the purpose of this object
-     */
-    public String getPurposeString();
+	/**
+	 * Gets the purpose of this object
+	 *
+	 * @return the string with the purpose of this object
+	 */
+	String getPurposeString();
 
-    /**
-     * Gets the options of this object
-     *
-     * @return the options of this object
-     */
-    public Options getOptions();
+	/**
+	 * Gets the options of this object
+	 *
+	 * @return the options of this object
+	 */
+	Options getOptions();
 
-    /**
-     * This method prepares this object for use.
-     *
-     */
-    public void prepareForUse();
+	/**
+	 * This method prepares this object for use.
+	 *
+	 */
+	void prepareForUse();
 
-    /**
-     * This method prepares this object for use.
-     *
-     * @param monitor the TaskMonitor to use
-     * @param repository  the ObjectRepository to use
-     */
-    public void prepareForUse(TaskMonitor monitor, ObjectRepository repository);
+	/**
+	 * This method prepares this object for use.
+	 *
+	 * @param monitor    the TaskMonitor to use
+	 * @param repository the ObjectRepository to use
+	 */
+	void prepareForUse(TaskMonitor monitor, ObjectRepository repository);
 
-    /**
-     * This method produces a copy of this object.
-     *
-     * @return a copy of this object
-     */
-    @Override
-    public OptionHandler copy();
+	/**
+	 * This method produces a copy of this object.
+	 *
+	 * @return a copy of this object
+	 */
+	@Override
+	OptionHandler copy();
 
-    /**
-     * Gets the Command Line Interface text to create the object
-     *
-     * @return the Command Line Interface text to create the object
-     */
-    public String getCLICreationString(Class<?> expectedType);
+	/**
+	 * Gets the Command Line Interface text to create the object
+	 *
+	 * @return the Command Line Interface text to create the object
+	 */
+	String getCLICreationString(Class<?> expectedType);
 }
diff --git a/moa/src/main/java/moa/options/OptionsHandler.java b/moa/src/main/java/moa/options/OptionsHandler.java
index 42e0b54f2..3cb2b7a0a 100644
--- a/moa/src/main/java/moa/options/OptionsHandler.java
+++ b/moa/src/main/java/moa/options/OptionsHandler.java
@@ -1,6 +1,5 @@
 package moa.options;
 
-
 import java.util.HashMap;
 
 import com.github.javacliparser.JavaCLIParser;
@@ -21,164 +20,134 @@
  */
 public class OptionsHandler extends JavaCLIParser {
 
-    //public Object handler;
-    
-    public OptionsHandler(Object c, String cliString) {
-        super(c,cliString);
-        //this.handler = c;
-        //this.prepareForUse();
-        /*int firstSpaceIndex = cliString.indexOf(' ', 0);
-        String classOptions;
-        String className;
-        if (firstSpaceIndex > 0) {
-            className = cliString.substring(0, firstSpaceIndex);
-            classOptions = cliString.substring(firstSpaceIndex + 1, cliString.length());
-            classOptions = classOptions.trim();
-        } else {
-            className = cliString;
-            classOptions = "";
-        }*/
-        //options.setViaCLIString(cliString);
-    }
-    
-    
-    //private static final long serialVersionUID = 1L;
-
-    /** Options to handle */
-    //protected Options options;
-
-    /** Dictionary with option texts and objects */
-    //protected Map<String, Object> classOptionNamesToPreparedObjects;
-
-
-    /*public String getPurposeString() {
-        return "Anonymous object: purpose undocumented.";
-    }
-
-    public Options getOptions() {
-        if (this.options == null) {
-            this.options = new Options();
-            Option[] myOptions = discoverOptionsViaReflection();
-            for (Option option : myOptions) {
-                this.options.addOption(option);
-            }
-        }
-        return this.options;
-    }*/
-
-    public void prepareForUse() {
-        prepareForUse(new NullMonitor(), null);
-    }
-
-    public void prepareForUse(TaskMonitor monitor, ObjectRepository repository) {
-        prepareClassOptions(monitor, repository);
-        //prepareForUseImpl(monitor, repository);
-    }
-
-    /**
-     * This method describes the implementation of how to prepare this object for use.
-     * All classes that extends this class have to implement <code>prepareForUseImpl</code>
-     * and not <code>prepareForUse</code> since
-     * <code>prepareForUse</code> calls <code>prepareForUseImpl</code>.
-     *
-     * @param monitor the TaskMonitor to use
-     * @param repository  the ObjectRepository to use
-     */
-    //protected abstract void prepareForUseImpl(TaskMonitor monitor,
-      //      ObjectRepository repository);
-
-    /* public String getCLICreationString(Class<?> expectedType) {
-        return ClassOption.stripPackagePrefix(this.getClass().getName(),
-                expectedType)
-                + " " + getOptions().getAsCLIString();
-    }*/
-
-
-    /**
-     * Gets the options of this class via reflection.
-     *
-     * @return an array of options
-     */
-    /*public Option[] discoverOptionsViaReflection() {
-        //Class<? extends AbstractOptionHandler> c = this.getClass();
-        Class c = this.handler.getClass();
-        Field[] fields = c.getFields();
-        List<Option> optList = new LinkedList<Option>();
-        for (Field field : fields) {
-            String fName = field.getName();
-            Class<?> fType = field.getType();
-            if (fType.getName().endsWith("Option")) {
-                if (Option.class.isAssignableFrom(fType)) {
-                    Option oVal = null;
-                    try {
-                        field.setAccessible(true);
-                        oVal = (Option) field.get(this.handler);
-                    } catch (IllegalAccessException ignored) {
-                        // cannot access this field
-                    }
-                    if (oVal != null) {
-                        optList.add(oVal);
-                    }
-                }
-            }
-        }
-        return optList.toArray(new Option[optList.size()]);
-    }*/
-    
-    /**
-     * Prepares the options of this class.
-     * 
-     * @param monitor the TaskMonitor to use
-     * @param repository  the ObjectRepository to use
-     */
-    public void prepareClassOptions(TaskMonitor monitor,
-            ObjectRepository repository) {
-        this.classOptionNamesToPreparedObjects = null;
-        Option[] optionArray = getOptions().getOptionArray();
-        for (Option option : optionArray) {
-            if (option instanceof ClassOption) {
-                ClassOption classOption = (ClassOption) option;
-                monitor.setCurrentActivity("Materializing option "
-                        + classOption.getName() + "...", -1.0);
-                Object optionObj = classOption.materializeObject(monitor,
-                        repository);
-                if (monitor.taskShouldAbort()) {
-                    return;
-                }
-                if (optionObj instanceof OptionHandler) {
-                    monitor.setCurrentActivity("Preparing option "
-                            + classOption.getName() + "...", -1.0);
-                    ((OptionHandler) optionObj).prepareForUse(monitor,
-                            repository);
-                    if (monitor.taskShouldAbort()) {
-                        return;
-                    }
-                }
-                if (this.classOptionNamesToPreparedObjects == null) {
-                    this.classOptionNamesToPreparedObjects = new HashMap<String, Object>();
-                }
-                this.classOptionNamesToPreparedObjects.put(option.getName(),
-                        optionObj);
-            }
-        }
-    }
-
-    /**
-     *  Gets a prepared option of this class.
-     *
-     * @param opt the class option to get
-     * @return an option stored in the dictionary
-     */
-    public Object getPreparedClassOption(ClassOption opt) {
-        if (this.classOptionNamesToPreparedObjects == null) {
-                    this.prepareForUse();
-                }
-        return this.classOptionNamesToPreparedObjects.get(opt.getName());
-    }
-
-    //@Override
-    //public void getDescription(StringBuilder sb, int i) {
-    //    throw new UnsupportedOperationException("Not supported yet.");
-    //}
-    
+	// public Object handler;
+
+	public OptionsHandler(Object c, String cliString) {
+		super(c, cliString);
+		// this.handler = c;
+		// this.prepareForUse();
+		/*
+		 * int firstSpaceIndex = cliString.indexOf(' ', 0); String classOptions; String
+		 * className; if (firstSpaceIndex > 0) { className = cliString.substring(0,
+		 * firstSpaceIndex); classOptions = cliString.substring(firstSpaceIndex + 1,
+		 * cliString.length()); classOptions = classOptions.trim(); } else { className =
+		 * cliString; classOptions = ""; }
+		 */
+		// options.setViaCLIString(cliString);
+	}
+
+	// private static final long serialVersionUID = 1L;
+
+	/** Options to handle */
+	// protected Options options;
+
+	/** Dictionary with option texts and objects */
+	// protected Map<String, Object> classOptionNamesToPreparedObjects;
+
+	/*
+	 * public String getPurposeString() { return
+	 * "Anonymous object: purpose undocumented."; }
+	 * 
+	 * public Options getOptions() { if (this.options == null) { this.options = new
+	 * Options(); Option[] myOptions = discoverOptionsViaReflection(); for (Option
+	 * option : myOptions) { this.options.addOption(option); } } return
+	 * this.options; }
+	 */
+
+	public void prepareForUse() {
+		prepareForUse(new NullMonitor(), null);
+	}
+
+	public void prepareForUse(TaskMonitor monitor, ObjectRepository repository) {
+		prepareClassOptions(monitor, repository);
+		// prepareForUseImpl(monitor, repository);
+	}
+
+	/**
+	 * This method describes the implementation of how to prepare this object for
+	 * use. All classes that extends this class have to implement
+	 * <code>prepareForUseImpl</code> and not <code>prepareForUse</code> since
+	 * <code>prepareForUse</code> calls <code>prepareForUseImpl</code>.
+	 *
+	 * @param monitor    the TaskMonitor to use
+	 * @param repository the ObjectRepository to use
+	 */
+	// protected abstract void prepareForUseImpl(TaskMonitor monitor,
+	// ObjectRepository repository);
+
+	/*
+	 * public String getCLICreationString(Class<?> expectedType) { return
+	 * ClassOption.stripPackagePrefix(this.getClass().getName(), expectedType) + " "
+	 * + getOptions().getAsCLIString(); }
+	 */
+
+	/**
+	 * Gets the options of this class via reflection.
+	 *
+	 * @return an array of options
+	 */
+	/*
+	 * public Option[] discoverOptionsViaReflection() { //Class<? extends
+	 * AbstractOptionHandler> c = this.getClass(); Class c =
+	 * this.handler.getClass(); Field[] fields = c.getFields(); List<Option> optList
+	 * = new LinkedList<Option>(); for (Field field : fields) { String fName =
+	 * field.getName(); Class<?> fType = field.getType(); if
+	 * (fType.getName().endsWith("Option")) { if
+	 * (Option.class.isAssignableFrom(fType)) { Option oVal = null; try {
+	 * field.setAccessible(true); oVal = (Option) field.get(this.handler); } catch
+	 * (IllegalAccessException ignored) { // cannot access this field } if (oVal !=
+	 * null) { optList.add(oVal); } } } } return optList.toArray(new
+	 * Option[optList.size()]); }
+	 */
+
+	/**
+	 * Prepares the options of this class.
+	 * 
+	 * @param monitor    the TaskMonitor to use
+	 * @param repository the ObjectRepository to use
+	 */
+	public void prepareClassOptions(TaskMonitor monitor, ObjectRepository repository) {
+		this.classOptionNamesToPreparedObjects = null;
+		Option[] optionArray = getOptions().getOptionArray();
+		for (Option option : optionArray) {
+			if (option instanceof ClassOption) {
+				ClassOption classOption = (ClassOption) option;
+				monitor.setCurrentActivity("Materializing option " + classOption.getName() + "...", -1.0);
+				Object optionObj = classOption.materializeObject(monitor, repository);
+				if (monitor.taskShouldAbort()) {
+					return;
+				}
+				if (optionObj instanceof OptionHandler) {
+					monitor.setCurrentActivity("Preparing option " + classOption.getName() + "...", -1.0);
+					((OptionHandler) optionObj).prepareForUse(monitor, repository);
+					if (monitor.taskShouldAbort()) {
+						return;
+					}
+				}
+				if (this.classOptionNamesToPreparedObjects == null) {
+					this.classOptionNamesToPreparedObjects = new HashMap<>();
+				}
+				this.classOptionNamesToPreparedObjects.put(option.getName(), optionObj);
+			}
+		}
+	}
+
+	/**
+	 * Gets a prepared option of this class.
+	 *
+	 * @param opt the class option to get
+	 * @return an option stored in the dictionary
+	 */
+	public Object getPreparedClassOption(ClassOption opt) {
+		if (this.classOptionNamesToPreparedObjects == null) {
+			this.prepareForUse();
+		}
+		return this.classOptionNamesToPreparedObjects.get(opt.getName());
+	}
+
+	// @Override
+	// public void getDescription(StringBuilder sb, int i) {
+	// throw new UnsupportedOperationException("Not supported yet.");
+	// }
+
 }
diff --git a/moa/src/main/java/moa/options/RequiredOptionNotSpecifiedException.java b/moa/src/main/java/moa/options/RequiredOptionNotSpecifiedException.java
index 5e92e269b..08630ae8b 100644
--- a/moa/src/main/java/moa/options/RequiredOptionNotSpecifiedException.java
+++ b/moa/src/main/java/moa/options/RequiredOptionNotSpecifiedException.java
@@ -1,6 +1,5 @@
 package moa.options;
 
-
 public class RequiredOptionNotSpecifiedException extends Exception {
 	private static final long serialVersionUID = 1L;
 }
diff --git a/moa/src/main/java/moa/options/WEKAClassOption.java b/moa/src/main/java/moa/options/WEKAClassOption.java
index c46d75476..5a22cb820 100644
--- a/moa/src/main/java/moa/options/WEKAClassOption.java
+++ b/moa/src/main/java/moa/options/WEKAClassOption.java
@@ -16,7 +16,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.options;
 
@@ -33,8 +33,8 @@
 import weka.core.Utils;
 
 /**
- * WEKA class option. This option is used to access options in WEKA.
- * For example, WEKAClassifier uses it to set the base learner.
+ * WEKA class option. This option is used to access options in WEKA. For
+ * example, WEKAClassifier uses it to set the base learner.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @author FracPete (fracpete at waikato dot ac dot nz)
@@ -44,39 +44,36 @@ public class WEKAClassOption extends AbstractClassOption {
 
 	private static final long serialVersionUID = 1L;
 
-	public WEKAClassOption(String name, char cliChar, String purpose,
-			Class<?> requiredType, String defaultCLIString) {
+	public WEKAClassOption(String name, char cliChar, String purpose, Class<?> requiredType, String defaultCLIString) {
 		super(name, cliChar, purpose, requiredType, defaultCLIString);
 	}
 
-	public WEKAClassOption(String name, char cliChar, String purpose,
-			Class<?> requiredType, String defaultCLIString, String nullString) {
+	public WEKAClassOption(String name, char cliChar, String purpose, Class<?> requiredType, String defaultCLIString,
+			String nullString) {
 		super(name, cliChar, purpose, requiredType, defaultCLIString, nullString);
 	}
 
-    @Override
+	@Override
 	public String getValueAsCLIString() {
 		if ((this.currentValue == null) && (this.nullString != null)) {
 			return this.nullString;
 		}
-		
+
 		String result = currentValue.getClass().getName();
 		if (currentValue instanceof weka.core.OptionHandler)
 			result += " " + Utils.joinOptions(((weka.core.OptionHandler) currentValue).getOptions());
 		result = result.trim();
-		
+
 		return result;
 	}
 
-    @Override
+	@Override
 	public void setValueViaCLIString(String s) {
-		if ((this.nullString != null)
-				&& ((s == null) || (s.length() == 0) || s
-						.equals(this.nullString))) {
+		if ((this.nullString != null) && ((s == null) || (s.length() == 0) || s.equals(this.nullString))) {
 			this.currentValue = null;
 		} else {
 			try {
-				this.currentValue = cliStringToObject(s, this.requiredType,	null);
+				this.currentValue = cliStringToObject(s, this.requiredType, null);
 			} catch (Exception e) {
 				throw new IllegalArgumentException("Problems with option: " + getName(), e);
 			}
@@ -103,8 +100,8 @@ public static String objectToCLIString(Object obj, Class<?> requiredType) {
 		return className;
 	}
 
-	public static Object cliStringToObject(String cliString,
-			Class<?> requiredType, Option[] externalOptions) throws Exception {
+	public static Object cliStringToObject(String cliString, Class<?> requiredType, Option[] externalOptions)
+			throws Exception {
 		if (cliString.startsWith(FILE_PREFIX_STRING)) {
 			return new File(cliString.substring(FILE_PREFIX_STRING.length()));
 		}
@@ -129,11 +126,11 @@ public static Object cliStringToObject(String cliString,
 		} catch (Throwable t1) {
 			try {
 				// try prepending default package
-				classObject = Class.forName(requiredType.getPackage().getName()	+ "." + className);
+				classObject = Class.forName(requiredType.getPackage().getName() + "." + className);
 			} catch (Throwable t2) {
 				try {
 					// try prepending task package
-					classObject = Class.forName(Task.class.getPackage().getName()	+ "." + className);
+					classObject = Class.forName(Task.class.getPackage().getName() + "." + className);
 				} catch (Throwable t3) {
 					throw new Exception("Class not found: " + className);
 				}
@@ -143,18 +140,16 @@ public static Object cliStringToObject(String cliString,
 		try {
 			classInstance = classObject.newInstance();
 		} catch (Exception ex) {
-			throw new Exception("Problem creating instance of class: "
-					+ className, ex);
+			throw new Exception("Problem creating instance of class: " + className, ex);
 		}
-		if (requiredType.isInstance(classInstance)
-				|| ((classInstance instanceof Task) && requiredType.isAssignableFrom(((Task) classInstance).getTaskResultType()))) {
-			Vector<String> options = new Vector<String>();
+		if (requiredType.isInstance(classInstance) || ((classInstance instanceof Task)
+				&& requiredType.isAssignableFrom(((Task) classInstance).getTaskResultType()))) {
+			Vector<String> options = new Vector<>();
 			if (externalOptions != null) {
 				for (Option option : externalOptions) {
 					options.add(option.getValueAsCLIString());
 				}
-			}
-			else {
+			} else {
 				String[] optionsTmp = Utils.splitOptions(cliString);
 				for (int i = 1; i < optionsTmp.length; i++)
 					options.add(optionsTmp[i]);
@@ -170,24 +165,19 @@ public static Object cliStringToObject(String cliString,
 						optionsText.append(option.synopsis() + '\n');
 						optionsText.append(option.description() + "\n");
 					}
-					throw new Exception("Problem with options to '"
-							+ className
-							+ "'."
-							+ "\n\nValid options for "
-							+ className
-							+ ":\n"
-							+ optionsText.toString(), ex);
+					throw new Exception("Problem with options to '" + className + "'." + "\n\nValid options for "
+							+ className + ":\n" + optionsText.toString(), ex);
 				}
-		  }
+			}
 		} else {
-			throw new Exception("Class named '" + className
-					+ "' is not an instance of " + requiredType.getName() + ".");
+			throw new Exception(
+					"Class named '" + className + "' is not an instance of " + requiredType.getName() + ".");
 		}
 		return classInstance;
 	}
 
-	//@Override
-	//public JComponent getEditComponent() {
-	//	return new WEKAClassOptionEditComponent(this);
-	//}
+	// @Override
+	// public JComponent getEditComponent() {
+	// return new WEKAClassOptionEditComponent(this);
+	// }
 }
diff --git a/moa/src/main/java/moa/recommender/data/MemRecommenderData.java b/moa/src/main/java/moa/recommender/data/MemRecommenderData.java
index 107b35e6b..49c0c75bb 100644
--- a/moa/src/main/java/moa/recommender/data/MemRecommenderData.java
+++ b/moa/src/main/java/moa/recommender/data/MemRecommenderData.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.recommender.data;
@@ -25,22 +25,22 @@
 import moa.tasks.TaskMonitor;
 
 public class MemRecommenderData extends AbstractOptionHandler implements RecommenderData {
-    
-     moa.recommender.rc.data.impl.MemRecommenderData drm;
-    
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-        drm = new moa.recommender.rc.data.impl.MemRecommenderData();
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        throw new UnsupportedOperationException("Not supported yet.");
-    }
-
-    @Override
-    public moa.recommender.rc.data.RecommenderData getData() {
-        return drm;
-    }
-    
+
+	moa.recommender.rc.data.impl.MemRecommenderData drm;
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		drm = new moa.recommender.rc.data.impl.MemRecommenderData();
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
+
+	@Override
+	public moa.recommender.rc.data.RecommenderData getData() {
+		return drm;
+	}
+
 }
diff --git a/moa/src/main/java/moa/recommender/data/RecommenderData.java b/moa/src/main/java/moa/recommender/data/RecommenderData.java
index 8df88c26d..8e16670d3 100644
--- a/moa/src/main/java/moa/recommender/data/RecommenderData.java
+++ b/moa/src/main/java/moa/recommender/data/RecommenderData.java
@@ -15,12 +15,12 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.recommender.data;
 
 public interface RecommenderData {
-    
-    public moa.recommender.rc.data.RecommenderData getData();
-    
+
+	moa.recommender.rc.data.RecommenderData getData();
+
 }
diff --git a/moa/src/main/java/moa/recommender/dataset/Dataset.java b/moa/src/main/java/moa/recommender/dataset/Dataset.java
index cd6cea77e..9288415e7 100644
--- a/moa/src/main/java/moa/recommender/dataset/Dataset.java
+++ b/moa/src/main/java/moa/recommender/dataset/Dataset.java
@@ -14,16 +14,20 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.recommender.dataset;
 
 public interface Dataset {
-    public boolean next();
-    public  int curUserID();
-    public int curItemID();
-    public double curRating();
-    public void reset();
+	boolean next();
+
+	int curUserID();
+
+	int curItemID();
+
+	double curRating();
+
+	void reset();
 }
diff --git a/moa/src/main/java/moa/recommender/dataset/impl/FlixsterDataset.java b/moa/src/main/java/moa/recommender/dataset/impl/FlixsterDataset.java
index 19841cc24..8bffaa791 100644
--- a/moa/src/main/java/moa/recommender/dataset/impl/FlixsterDataset.java
+++ b/moa/src/main/java/moa/recommender/dataset/impl/FlixsterDataset.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.recommender.dataset.impl;
@@ -36,88 +36,89 @@
 import moa.recommender.dataset.Dataset;
 import moa.tasks.TaskMonitor;
 
-public class FlixsterDataset extends AbstractOptionHandler implements Dataset  {
-    private String strLine;
-    private BufferedReader br;
-        public FileOption fileOption = new FileOption("file", 'f',
-            "File to load.", "/home/alex/datasets/ratings.txt", "txt", false);
-    
-    /*public FlixsterDataset() throws IOException {
-        super();
-        FileInputStream fstream = new FileInputStream("/home/alex/datasets/ratings.txt");
-        DataInputStream in = new DataInputStream(fstream);
-        br = new BufferedReader(new InputStreamReader(in));
-    }*/
-        
-         @Override
-    public String getPurposeString() {
-        return "A Jester Dataset reader.";
-    }
-
-    public void init() {
-        FileInputStream fstream = null;
-        try {
-            fstream = new FileInputStream(this.fileOption.getFile());
-            DataInputStream in = new DataInputStream(fstream);
-            br = new BufferedReader(new InputStreamReader(in));
-        } catch (FileNotFoundException ex) {
-            Logger.getLogger(MovielensDataset.class.getName()).log(Level.SEVERE, null, ex);
-        }
-    }
-    
-    
-    @Override
-    public boolean next() {
-        try {
-            return (strLine = br.readLine()) != null;
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-        return false;
-    }
-
-    @Override
-    public int curUserID() {
-        String[] split = strLine.split("\\s+");
-        return Integer.valueOf(split[0]);
-    }
-
-    @Override
-    public int curItemID() {
-        String[] split = strLine.split("\\s+");
-        return Integer.valueOf(split[1]);
-    }
-
-    @Override
-    public double curRating() {
-        String[] split = strLine.split("\\s+");
-        return Double.valueOf(split[2]);
-    }
-
-    public String toString() {
-        return "Flixster";
-    }
-
-    @Override
-    public void reset() {
-        try {
-            br.close();
-            //FileInputStream fstream = new FileInputStream("/home/alicia/datasets/flixster/ratings.txt");
-            //DataInputStream in = new DataInputStream(fstream);
-            //br = new BufferedReader(new InputStreamReader(in));
-            this.init();
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-    }
-    
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-        this.init();
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        throw new UnsupportedOperationException("Not supported yet.");
-    }
+public class FlixsterDataset extends AbstractOptionHandler implements Dataset {
+	private String strLine;
+	private BufferedReader br;
+	public FileOption fileOption = new FileOption("file", 'f', "File to load.", "/home/alex/datasets/ratings.txt",
+			"txt", false);
+
+	/*
+	 * public FlixsterDataset() throws IOException { super(); FileInputStream
+	 * fstream = new FileInputStream("/home/alex/datasets/ratings.txt");
+	 * DataInputStream in = new DataInputStream(fstream); br = new
+	 * BufferedReader(new InputStreamReader(in)); }
+	 */
+
+	@Override
+	public String getPurposeString() {
+		return "A Jester Dataset reader.";
+	}
+
+	public void init() {
+		FileInputStream fstream = null;
+		try {
+			fstream = new FileInputStream(this.fileOption.getFile());
+			DataInputStream in = new DataInputStream(fstream);
+			br = new BufferedReader(new InputStreamReader(in));
+		} catch (FileNotFoundException ex) {
+			Logger.getLogger(MovielensDataset.class.getName()).log(Level.SEVERE, null, ex);
+		}
+	}
+
+	@Override
+	public boolean next() {
+		try {
+			return (strLine = br.readLine()) != null;
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		return false;
+	}
+
+	@Override
+	public int curUserID() {
+		String[] split = strLine.split("\\s+");
+		return Integer.valueOf(split[0]);
+	}
+
+	@Override
+	public int curItemID() {
+		String[] split = strLine.split("\\s+");
+		return Integer.valueOf(split[1]);
+	}
+
+	@Override
+	public double curRating() {
+		String[] split = strLine.split("\\s+");
+		return Double.valueOf(split[2]);
+	}
+
+	@Override
+	public String toString() {
+		return "Flixster";
+	}
+
+	@Override
+	public void reset() {
+		try {
+			br.close();
+			// FileInputStream fstream = new
+			// FileInputStream("/home/alicia/datasets/flixster/ratings.txt");
+			// DataInputStream in = new DataInputStream(fstream);
+			// br = new BufferedReader(new InputStreamReader(in));
+			this.init();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		this.init();
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
 }
diff --git a/moa/src/main/java/moa/recommender/dataset/impl/JesterDataset.java b/moa/src/main/java/moa/recommender/dataset/impl/JesterDataset.java
index 13716c156..1c5aee0c8 100644
--- a/moa/src/main/java/moa/recommender/dataset/impl/JesterDataset.java
+++ b/moa/src/main/java/moa/recommender/dataset/impl/JesterDataset.java
@@ -2,7 +2,7 @@
  *    JesterDataset.java
  *    Copyright (C) 2012 Universitat Politecnica de Catalunya
  *    @author Alex Catarineu (a.catarineu@gmail.com)
- * 
+ *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.recommender.dataset.impl;
@@ -38,86 +38,88 @@
 
 public class JesterDataset extends AbstractOptionHandler implements Dataset {
 
-    private String strLine;
-    private BufferedReader br;
-    public FileOption fileOption = new FileOption("file", 'f',
-            "File to load.", "/home/alicia/datasets/jester/jester_ratings.dat", "dat", false);
-
-    /* public JesterDataset() throws IOException {
-     super();
-     FileInputStream fstream = new FileInputStream("/home/alicia/datasets/jester/jester_ratings.dat");
-     DataInputStream in = new DataInputStream(fstream);
-     br = new BufferedReader(new InputStreamReader(in));
-     }*/
-    @Override
-    public String getPurposeString() {
-        return "A Jester Dataset reader.";
-    }
-
-    public void init() {
-        FileInputStream fstream = null;
-        try {
-            fstream = new FileInputStream(this.fileOption.getFile());
-            DataInputStream in = new DataInputStream(fstream);
-            br = new BufferedReader(new InputStreamReader(in));
-        } catch (FileNotFoundException ex) {
-            Logger.getLogger(MovielensDataset.class.getName()).log(Level.SEVERE, null, ex);
-        }
-    }
-
-    @Override
-    public boolean next() {
-        try {
-            return (strLine = br.readLine()) != null;
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-        return false;
-    }
-
-    public String toString() {
-        return "Jester";
-    }
-
-    @Override
-    public int curUserID() {
-        String[] split = strLine.split("\\s+");
-        return Integer.valueOf(split[0]);
-    }
-
-    @Override
-    public int curItemID() {
-        String[] split = strLine.split("\\s+");
-        return Integer.valueOf(split[1]);
-    }
-
-    @Override
-    public double curRating() {
-        String[] split = strLine.split("\\s+");
-        double rating = Double.valueOf(split[2]);
-        return (rating / 10) * 2 + 3;
-    }
-
-    @Override
-    public void reset() {
-        try {
-            br.close();
-            //FileInputStream fstream = new FileInputStream("/home/alicia/datasets/jester/jester_ratings.dat");
-            //DataInputStream in = new DataInputStream(fstream);
-            //br = new BufferedReader(new InputStreamReader(in));
-            this.init();
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-        this.init();
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        throw new UnsupportedOperationException("Not supported yet.");
-    }
+	private String strLine;
+	private BufferedReader br;
+	public FileOption fileOption = new FileOption("file", 'f', "File to load.",
+			"/home/alicia/datasets/jester/jester_ratings.dat", "dat", false);
+
+	/*
+	 * public JesterDataset() throws IOException { super(); FileInputStream fstream
+	 * = new FileInputStream("/home/alicia/datasets/jester/jester_ratings.dat");
+	 * DataInputStream in = new DataInputStream(fstream); br = new
+	 * BufferedReader(new InputStreamReader(in)); }
+	 */
+	@Override
+	public String getPurposeString() {
+		return "A Jester Dataset reader.";
+	}
+
+	public void init() {
+		FileInputStream fstream = null;
+		try {
+			fstream = new FileInputStream(this.fileOption.getFile());
+			DataInputStream in = new DataInputStream(fstream);
+			br = new BufferedReader(new InputStreamReader(in));
+		} catch (FileNotFoundException ex) {
+			Logger.getLogger(MovielensDataset.class.getName()).log(Level.SEVERE, null, ex);
+		}
+	}
+
+	@Override
+	public boolean next() {
+		try {
+			return (strLine = br.readLine()) != null;
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		return false;
+	}
+
+	@Override
+	public String toString() {
+		return "Jester";
+	}
+
+	@Override
+	public int curUserID() {
+		String[] split = strLine.split("\\s+");
+		return Integer.valueOf(split[0]);
+	}
+
+	@Override
+	public int curItemID() {
+		String[] split = strLine.split("\\s+");
+		return Integer.valueOf(split[1]);
+	}
+
+	@Override
+	public double curRating() {
+		String[] split = strLine.split("\\s+");
+		double rating = Double.valueOf(split[2]);
+		return (rating / 10) * 2 + 3;
+	}
+
+	@Override
+	public void reset() {
+		try {
+			br.close();
+			// FileInputStream fstream = new
+			// FileInputStream("/home/alicia/datasets/jester/jester_ratings.dat");
+			// DataInputStream in = new DataInputStream(fstream);
+			// br = new BufferedReader(new InputStreamReader(in));
+			this.init();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		this.init();
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
 }
diff --git a/moa/src/main/java/moa/recommender/dataset/impl/MovielensDataset.java b/moa/src/main/java/moa/recommender/dataset/impl/MovielensDataset.java
index 66c86baa6..3d886efe8 100644
--- a/moa/src/main/java/moa/recommender/dataset/impl/MovielensDataset.java
+++ b/moa/src/main/java/moa/recommender/dataset/impl/MovielensDataset.java
@@ -2,7 +2,7 @@
  *    MovielensDataset.java
  *    Copyright (C) 2012 Universitat Politecnica de Catalunya
  *    @author Alex Catarineu (a.catarineu@gmail.com)
- * 
+ *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.recommender.dataset.impl;
@@ -38,83 +38,85 @@
 
 public class MovielensDataset extends AbstractOptionHandler implements Dataset {
 
-    private String strLine;
-    
-    private BufferedReader br;
-    
-    public FileOption fileOption = new FileOption("file", 'f',
-            "File to load.", "/Users/abifet/Downloads/ml-1M/ratings.dat", "dat", false);
-
-    @Override
-    public String getPurposeString() {
-        return "A Movie Lens Dataset reader.";
-    }
-
-    public void init() {
-        FileInputStream fstream = null;
-        try {
-            //fstream = new FileInputStream("/Users/abifet/Downloads/ml-1M/ratings.dat");
-            fstream = new FileInputStream(this.fileOption.getFile());
-            DataInputStream in = new DataInputStream(fstream);
-            br = new BufferedReader(new InputStreamReader(in));
-        } catch (FileNotFoundException ex) {
-            Logger.getLogger(MovielensDataset.class.getName()).log(Level.SEVERE, null, ex);
-        }
-
-    }
-
-    @Override
-    public boolean next() {
-        try {
-            return (strLine = ((BufferedReader) br).readLine()) != null;
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-        return false;
-    }
-
-    public String toString() {
-        return "Movielens";
-    }
-
-    @Override
-    public int curUserID() {
-        String[] split = strLine.split("::");
-        return Integer.valueOf(split[0]);
-    }
-
-    @Override
-    public int curItemID() {
-        String[] split = strLine.split("::");
-        return Integer.valueOf(split[1]);
-    }
-
-    @Override
-    public double curRating() {
-        String[] split = strLine.split("::");
-        return Double.valueOf(split[2]);
-    }
-
-    @Override
-    public void reset() {
-        try {
-            br.close();
-            //FileInputStream fstream = new FileInputStream("/home/alex/datasets/ml-1m/ratings.dat");
-            //DataInputStream in = new DataInputStream(fstream);
-            //br = new BufferedReader(new InputStreamReader(in));
-            this.init();
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-        this.init();
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        throw new UnsupportedOperationException("Not supported yet.");
-    }
+	private String strLine;
+
+	private BufferedReader br;
+
+	public FileOption fileOption = new FileOption("file", 'f', "File to load.",
+			"/Users/abifet/Downloads/ml-1M/ratings.dat", "dat", false);
+
+	@Override
+	public String getPurposeString() {
+		return "A Movie Lens Dataset reader.";
+	}
+
+	public void init() {
+		FileInputStream fstream = null;
+		try {
+			// fstream = new FileInputStream("/Users/abifet/Downloads/ml-1M/ratings.dat");
+			fstream = new FileInputStream(this.fileOption.getFile());
+			DataInputStream in = new DataInputStream(fstream);
+			br = new BufferedReader(new InputStreamReader(in));
+		} catch (FileNotFoundException ex) {
+			Logger.getLogger(MovielensDataset.class.getName()).log(Level.SEVERE, null, ex);
+		}
+
+	}
+
+	@Override
+	public boolean next() {
+		try {
+			return (strLine = br.readLine()) != null;
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		return false;
+	}
+
+	@Override
+	public String toString() {
+		return "Movielens";
+	}
+
+	@Override
+	public int curUserID() {
+		String[] split = strLine.split("::");
+		return Integer.valueOf(split[0]);
+	}
+
+	@Override
+	public int curItemID() {
+		String[] split = strLine.split("::");
+		return Integer.valueOf(split[1]);
+	}
+
+	@Override
+	public double curRating() {
+		String[] split = strLine.split("::");
+		return Double.valueOf(split[2]);
+	}
+
+	@Override
+	public void reset() {
+		try {
+			br.close();
+			// FileInputStream fstream = new
+			// FileInputStream("/home/alex/datasets/ml-1m/ratings.dat");
+			// DataInputStream in = new DataInputStream(fstream);
+			// br = new BufferedReader(new InputStreamReader(in));
+			this.init();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		this.init();
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		throw new UnsupportedOperationException("Not supported yet.");
+	}
 }
diff --git a/moa/src/main/java/moa/recommender/predictor/BRISMFPredictor.java b/moa/src/main/java/moa/recommender/predictor/BRISMFPredictor.java
index 8d69c8450..575544a3d 100644
--- a/moa/src/main/java/moa/recommender/predictor/BRISMFPredictor.java
+++ b/moa/src/main/java/moa/recommender/predictor/BRISMFPredictor.java
@@ -2,7 +2,7 @@
  *    BRISMFPredictor.java
  *    Copyright (C) 2012 Universitat Politecnica de Catalunya
  *    @author Alex Catarineu (a.catarineu@gmail.com)
- * 
+ *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.recommender.predictor;
@@ -32,90 +32,83 @@
 import moa.tasks.TaskMonitor;
 
 /**
- * Implementation of the algorithm described in Scalable 
- * Collaborative Filtering Approaches for Large Recommender
- * Systems (Gábor Takács, István Pilászy, Bottyán Németh, 
- * and Domonkos Tikk). A feature vector is learned for every 
- * user and item, so that the prediction of a rating is roughly
- * the dot product of the corresponding user and item vector. 
- * Stochastic gradient descent is used to train the model, 
- * minimizing its prediction error. Both Tikhonov regularization
- * and early stopping are used to reduce overfitting. The 
- * algorithm allows batch training (from scratch, using all
- * ratings available at the moment) as well as incremental,
- * by retraining only the affected user and item vectors when 
- * a new rating is inserted.
- * 
- * <p>Parameters:</p>
+ * Implementation of the algorithm described in Scalable Collaborative Filtering
+ * Approaches for Large Recommender Systems (Gábor Takács, István Pilászy,
+ * Bottyán Németh, and Domonkos Tikk). A feature vector is learned for every
+ * user and item, so that the prediction of a rating is roughly the dot product
+ * of the corresponding user and item vector. Stochastic gradient descent is
+ * used to train the model, minimizing its prediction error. Both Tikhonov
+ * regularization and early stopping are used to reduce overfitting. The
+ * algorithm allows batch training (from scratch, using all ratings available at
+ * the moment) as well as incremental, by retraining only the affected user and
+ * item vectors when a new rating is inserted.
+ *
+ * <p>
+ * Parameters:
+ * </p>
  * <ul>
- * <li> f: features - the number of features to be trained for each user and 
- *      item</li>
- * <li> r: learning rate - the learning rate used in the regularization</li>
- * <li> a: ratio - the regularization ratio to be used in the Tikhonov 
- *      regularization</li>
- * <li> i: iterations - the number of iterations to be used when retraining
- *      user and item features (online training). </li>
- * </lu>
- * 
+ * <li>f: features - the number of features to be trained for each user and
+ * item</li>
+ * <li>r: learning rate - the learning rate used in the regularization</li>
+ * <li>a: ratio - the regularization ratio to be used in the Tikhonov
+ * regularization</li>
+ * <li>i: iterations - the number of iterations to be used when retraining user
+ * and item features (online training).</li> </lu>
+ *
  */
 
 public class BRISMFPredictor extends AbstractOptionHandler implements RatingPredictor {
 
-    protected moa.recommender.rc.predictor.impl.BRISMFPredictor rp;
-    
-    public IntOption featuresOption = new IntOption("features",
-            'f',
-            "How many features to use.",
-            20, 0, Integer.MAX_VALUE);
-    
-    public FloatOption lRateOption = new FloatOption("lRate",
-            'r', "lRate", 0.001);
-    
-    public FloatOption rFactorOption = new FloatOption("rFactor",
-            'a', "rFactor", 0.01);
-    
-    public IntOption iterationsOption = new IntOption("iterations",
-            'i',
-            "How many iterations to use.",
-            100, 0, Integer.MAX_VALUE);
-
-    public ClassOption dataOption = new ClassOption("data", 'd',
-            "Data", RecommenderData.class, "moa.recommender.data.MemRecommenderData");
-     
-    
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-        RecommenderData data = (RecommenderData) getPreparedClassOption(this.dataOption);
-        rp = new moa.recommender.rc.predictor.impl.BRISMFPredictor(featuresOption.getValue(), data.getData(), lRateOption.getValue(), rFactorOption.getValue(), false);
-        rp.setNIterations(iterationsOption.getValue());
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        sb.append(rp.toString());
-    }
-
-    public double predictRating(Integer user, Integer item) {
-        return rp.predictRating(user,item);
-    }
-
-    public moa.recommender.rc.data.RecommenderData getData() {
-        return rp.getData();
-    }
-
-    @Override
-    public double predictRating(int userID, int itemID) {
-        return rp.predictRating(userID, itemID);
-    }
-
-    @Override
-    public List<Double> predictRatings(int userID, List<Integer> itemIDS) {
-        return rp.predictRatings(userID, itemIDS);
-    }
-
-    @Override
-    public void train() {
-        rp.train();
-    }
-    
+	protected moa.recommender.rc.predictor.impl.BRISMFPredictor rp;
+
+	public IntOption featuresOption = new IntOption("features", 'f', "How many features to use.", 20, 0,
+			Integer.MAX_VALUE);
+
+	public FloatOption lRateOption = new FloatOption("lRate", 'r', "lRate", 0.001);
+
+	public FloatOption rFactorOption = new FloatOption("rFactor", 'a', "rFactor", 0.01);
+
+	public IntOption iterationsOption = new IntOption("iterations", 'i', "How many iterations to use.", 100, 0,
+			Integer.MAX_VALUE);
+
+	public ClassOption dataOption = new ClassOption("data", 'd', "Data", RecommenderData.class,
+			"moa.recommender.data.MemRecommenderData");
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		RecommenderData data = (RecommenderData) getPreparedClassOption(this.dataOption);
+		rp = new moa.recommender.rc.predictor.impl.BRISMFPredictor(featuresOption.getValue(), data.getData(),
+				lRateOption.getValue(), rFactorOption.getValue(), false);
+		rp.setNIterations(iterationsOption.getValue());
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		sb.append(rp.toString());
+	}
+
+	public double predictRating(Integer user, Integer item) {
+		return rp.predictRating(user, item);
+	}
+
+	@Override
+	public moa.recommender.rc.data.RecommenderData getData() {
+		return rp.getData();
+	}
+
+	@Override
+	public double predictRating(int userID, int itemID) {
+		return rp.predictRating(userID, itemID);
+	}
+
+	@Override
+	public List<Double> predictRatings(int userID, List<Integer> itemIDS) {
+		return rp.predictRatings(userID, itemIDS);
+	}
+
+	@Override
+	public void train() {
+		rp.train();
+	}
+
 }
diff --git a/moa/src/main/java/moa/recommender/predictor/BaselinePredictor.java b/moa/src/main/java/moa/recommender/predictor/BaselinePredictor.java
index 1ca885c1e..39c3169e7 100644
--- a/moa/src/main/java/moa/recommender/predictor/BaselinePredictor.java
+++ b/moa/src/main/java/moa/recommender/predictor/BaselinePredictor.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.recommender.predictor;
@@ -28,50 +28,52 @@
 import moa.tasks.TaskMonitor;
 
 /**
- * A naive algorithm which combines the global mean of all the existing 
- * ratings, the mean rating of the user and the mean rating of the item 
- * to make a prediction.
- * 
+ * A naive algorithm which combines the global mean of all the existing ratings,
+ * the mean rating of the user and the mean rating of the item to make a
+ * prediction.
+ *
  */
 
-public class BaselinePredictor extends AbstractOptionHandler implements moa.recommender.predictor.RatingPredictor {   
-    protected moa.recommender.rc.predictor.impl.BaselinePredictor rp;
-    
-    public ClassOption dataOption = new ClassOption("data", 'd',
-            "Data", moa.recommender.data.RecommenderData.class, "moa.recommender.data.MemRecommenderData");
+public class BaselinePredictor extends AbstractOptionHandler implements moa.recommender.predictor.RatingPredictor {
+	protected moa.recommender.rc.predictor.impl.BaselinePredictor rp;
+
+	public ClassOption dataOption = new ClassOption("data", 'd', "Data", moa.recommender.data.RecommenderData.class,
+			"moa.recommender.data.MemRecommenderData");
 
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-        moa.recommender.data.RecommenderData data = (moa.recommender.data.RecommenderData) getPreparedClassOption(this.dataOption);
-        rp = new moa.recommender.rc.predictor.impl.BaselinePredictor(data.getData());
-    }
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		moa.recommender.data.RecommenderData data = (moa.recommender.data.RecommenderData) getPreparedClassOption(
+				this.dataOption);
+		rp = new moa.recommender.rc.predictor.impl.BaselinePredictor(data.getData());
+	}
 
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        sb.append(rp.toString());
-    }
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		sb.append(rp.toString());
+	}
 
-    public double predictRating(Integer user, Integer item) {
-        return rp.predictRating(user,item);
-    }
+	public double predictRating(Integer user, Integer item) {
+		return rp.predictRating(user, item);
+	}
 
-    public moa.recommender.rc.data.RecommenderData getData() {
-        return rp.getData();
-    }
+	@Override
+	public moa.recommender.rc.data.RecommenderData getData() {
+		return rp.getData();
+	}
 
-    @Override
-    public double predictRating(int userID, int itemID) {
-        return rp.predictRating(userID, itemID);
-    }
+	@Override
+	public double predictRating(int userID, int itemID) {
+		return rp.predictRating(userID, itemID);
+	}
 
-    @Override
-    public List<Double> predictRatings(int userID, List<Integer> itemIDS) {
-        return rp.predictRatings(userID, itemIDS);
-    }
+	@Override
+	public List<Double> predictRatings(int userID, List<Integer> itemIDS) {
+		return rp.predictRatings(userID, itemIDS);
+	}
 
-    @Override
-    public void train() {
-        rp.train();
-    }
+	@Override
+	public void train() {
+		rp.train();
+	}
 
 }
diff --git a/moa/src/main/java/moa/recommender/predictor/RatingPredictor.java b/moa/src/main/java/moa/recommender/predictor/RatingPredictor.java
index 839821251..f8738a1a3 100644
--- a/moa/src/main/java/moa/recommender/predictor/RatingPredictor.java
+++ b/moa/src/main/java/moa/recommender/predictor/RatingPredictor.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.recommender.predictor;
@@ -26,15 +26,18 @@
 import moa.recommender.rc.data.RecommenderData;
 
 /**
- * Rating predicting algorithm. The core of any recommender system is its 
- * rating prediction algorithm. Its purpose is to estimate the rating
- * (a numeric score) that a certain user would give to a certain item,
- * based on previous ratings given of the user and the item.
- * 
+ * Rating predicting algorithm. The core of any recommender system is its rating
+ * prediction algorithm. Its purpose is to estimate the rating (a numeric score)
+ * that a certain user would give to a certain item, based on previous ratings
+ * given of the user and the item.
+ *
  */
 public interface RatingPredictor extends Serializable {
-	public double predictRating(int userID, int itemID);
-	public List<Double> predictRatings(int userID, List<Integer> itemIDS);
-	public RecommenderData getData();
-	public void train();
+	double predictRating(int userID, int itemID);
+
+	List<Double> predictRatings(int userID, List<Integer> itemIDS);
+
+	RecommenderData getData();
+
+	void train();
 }
diff --git a/moa/src/main/java/moa/recommender/rc/data/AbstractRecommenderData.java b/moa/src/main/java/moa/recommender/rc/data/AbstractRecommenderData.java
index 8c755448f..4819da0f6 100644
--- a/moa/src/main/java/moa/recommender/rc/data/AbstractRecommenderData.java
+++ b/moa/src/main/java/moa/recommender/rc/data/AbstractRecommenderData.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.recommender.rc.data;
@@ -26,85 +26,100 @@
 
 import moa.recommender.rc.utils.Updatable;
 
-
 public abstract class AbstractRecommenderData implements RecommenderData {
-    
-    
-    /**
-     * 
-     */
-    private static final long serialVersionUID = -5409390358073330733L;
-    
-    protected ArrayList<Updatable> updatables;
-    protected boolean disableUpdates = false;
-    
-    public AbstractRecommenderData() {
-        this.updatables = new ArrayList<Updatable>();
-    }
-    
-    public void disableUpdates(boolean disable) {
-        this.disableUpdates = disable;
-    }
-    
-    public void addUser(int userID, List<Integer> ratedItems, List<Double> ratings) {
-        Iterator<Updatable> it = updatables.iterator();
-        while (it.hasNext()) {
-            Updatable u = it.next();
-            if (!disableUpdates)
-                u.updateNewUser(userID, ratedItems, ratings);
-        }
-    }
-    public void removeUser(int userID) {
-        Iterator<Updatable> it = updatables.iterator();
-        while (it.hasNext()) {
-            Updatable u = it.next();
-            if (!disableUpdates)
-                u.updateRemoveUser(userID);
-        }
-    }
-    public void addItem(int itemID, List<Integer> ratingUsers, List<Double> ratings) {
-        Iterator<Updatable> it = updatables.iterator();
-        while (it.hasNext()) {
-            Updatable u = it.next();
-            if (!disableUpdates)
-                u.updateNewItem(itemID, ratingUsers, ratings);
-        }
-    }
-    public void removeItem(int itemID) {
-        Iterator<Updatable> it = updatables.iterator();
-        while (it.hasNext()) {
-            Updatable u = it.next();
-            if (!disableUpdates)
-                u.updateRemoveItem(itemID);
-        }
-    }
-    public void setRating(int userID, int itemID, double rating) {
-        Iterator<Updatable> it = updatables.iterator();
-        while (it.hasNext()) {
-            Updatable u = it.next();
-            if (!disableUpdates) {
-                u.updateSetRating(userID, itemID, rating);
-            }
-                
-        }
-    }
-    public void removeRating(int userID, int itemID) {
-        Iterator<Updatable> it = updatables.iterator();
-        while (it.hasNext()) {
-            Updatable u = it.next();
-            if (!disableUpdates)
-                u.updateRemoveRating(userID, itemID);
-        }
-    }
-
-    public void attachUpdatable(Updatable obj) {
-        updatables.add(obj);
-    }
-    public void clear() {
-        updatables.clear();
-        disableUpdates = false;
-    }
-    public void close() {
-        
-    }
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -5409390358073330733L;
+
+	protected ArrayList<Updatable> updatables;
+	protected boolean disableUpdates = false;
+
+	public AbstractRecommenderData() {
+		this.updatables = new ArrayList<>();
+	}
+
+	@Override
+	public void disableUpdates(boolean disable) {
+		this.disableUpdates = disable;
+	}
+
+	@Override
+	public void addUser(int userID, List<Integer> ratedItems, List<Double> ratings) {
+		Iterator<Updatable> it = updatables.iterator();
+		while (it.hasNext()) {
+			Updatable u = it.next();
+			if (!disableUpdates)
+				u.updateNewUser(userID, ratedItems, ratings);
+		}
+	}
+
+	@Override
+	public void removeUser(int userID) {
+		Iterator<Updatable> it = updatables.iterator();
+		while (it.hasNext()) {
+			Updatable u = it.next();
+			if (!disableUpdates)
+				u.updateRemoveUser(userID);
+		}
+	}
+
+	@Override
+	public void addItem(int itemID, List<Integer> ratingUsers, List<Double> ratings) {
+		Iterator<Updatable> it = updatables.iterator();
+		while (it.hasNext()) {
+			Updatable u = it.next();
+			if (!disableUpdates)
+				u.updateNewItem(itemID, ratingUsers, ratings);
+		}
+	}
+
+	@Override
+	public void removeItem(int itemID) {
+		Iterator<Updatable> it = updatables.iterator();
+		while (it.hasNext()) {
+			Updatable u = it.next();
+			if (!disableUpdates)
+				u.updateRemoveItem(itemID);
+		}
+	}
+
+	@Override
+	public void setRating(int userID, int itemID, double rating) {
+		Iterator<Updatable> it = updatables.iterator();
+		while (it.hasNext()) {
+			Updatable u = it.next();
+			if (!disableUpdates) {
+				u.updateSetRating(userID, itemID, rating);
+			}
+
+		}
+	}
+
+	@Override
+	public void removeRating(int userID, int itemID) {
+		Iterator<Updatable> it = updatables.iterator();
+		while (it.hasNext()) {
+			Updatable u = it.next();
+			if (!disableUpdates)
+				u.updateRemoveRating(userID, itemID);
+		}
+	}
+
+	@Override
+	public void attachUpdatable(Updatable obj) {
+		updatables.add(obj);
+	}
+
+	@Override
+	public void clear() {
+		updatables.clear();
+		disableUpdates = false;
+	}
+
+	@Override
+	public void close() {
+
+	}
 }
diff --git a/moa/src/main/java/moa/recommender/rc/data/RecommenderData.java b/moa/src/main/java/moa/recommender/rc/data/RecommenderData.java
index d986dcee2..faa642b9a 100644
--- a/moa/src/main/java/moa/recommender/rc/data/RecommenderData.java
+++ b/moa/src/main/java/moa/recommender/rc/data/RecommenderData.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.recommender.rc.data;
@@ -29,35 +29,61 @@
 import moa.recommender.rc.utils.SparseVector;
 import moa.recommender.rc.utils.Updatable;
 
-
 public interface RecommenderData extends Serializable {
-    
-    public void addUser(int userID, List<Integer> ratedItems, List<Double> ratings);
-    public void removeUser(int userID);
-    public void addItem(int itemID, List<Integer> ratingUsers, List<Double> ratings);
-    public void removeItem(int itemID);
-    public void setRating(int userID, int itemID, double rating);
-    public void removeRating(int userID, int itemID);
-    public SparseVector getRatingsUser(int userID); //TODO:Iterator version for this?
-    public SparseVector getRatingsItem(int itemID); //TODO:Iterator version for this?
-    public double getRating(int userID, int itemID);
-    public int getNumItems();
-    public int getNumUsers();
-    public int getNumRatings();
-    public double getAvgRatingUser(int userID);
-    public double getAvgRatingItem(int itemID);
-    public double getMinRating();
-    public double getMaxRating();
-    public Set<Integer> getUsers();
-    public Set<Integer> getItems();
-    public double getGlobalMean();
-    public void attachUpdatable(Updatable obj);
-    public void disableUpdates(boolean disable);
-    public int countRatingsUser(int userID);
-    public int countRatingsItem(int itemID);
-    public Iterator<Rating> ratingIterator();
-    public boolean userExists(int userID);
-    public boolean itemExists(int itemID);
-    public void clear();
-    public void close();
+
+	void addUser(int userID, List<Integer> ratedItems, List<Double> ratings);
+
+	void removeUser(int userID);
+
+	void addItem(int itemID, List<Integer> ratingUsers, List<Double> ratings);
+
+	void removeItem(int itemID);
+
+	void setRating(int userID, int itemID, double rating);
+
+	void removeRating(int userID, int itemID);
+
+	SparseVector getRatingsUser(int userID); // TODO:Iterator version for this?
+
+	SparseVector getRatingsItem(int itemID); // TODO:Iterator version for this?
+
+	double getRating(int userID, int itemID);
+
+	int getNumItems();
+
+	int getNumUsers();
+
+	int getNumRatings();
+
+	double getAvgRatingUser(int userID);
+
+	double getAvgRatingItem(int itemID);
+
+	double getMinRating();
+
+	double getMaxRating();
+
+	Set<Integer> getUsers();
+
+	Set<Integer> getItems();
+
+	double getGlobalMean();
+
+	void attachUpdatable(Updatable obj);
+
+	void disableUpdates(boolean disable);
+
+	int countRatingsUser(int userID);
+
+	int countRatingsItem(int itemID);
+
+	Iterator<Rating> ratingIterator();
+
+	boolean userExists(int userID);
+
+	boolean itemExists(int itemID);
+
+	void clear();
+
+	void close();
 }
diff --git a/moa/src/main/java/moa/recommender/rc/data/impl/MemRecommenderData.java b/moa/src/main/java/moa/recommender/rc/data/impl/MemRecommenderData.java
index af9b55f9c..8b8a3b7a3 100644
--- a/moa/src/main/java/moa/recommender/rc/data/impl/MemRecommenderData.java
+++ b/moa/src/main/java/moa/recommender/rc/data/impl/MemRecommenderData.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.recommender.rc.data.impl;
@@ -34,324 +34,321 @@
 
 public class MemRecommenderData extends AbstractRecommenderData {
 
-    private static final long serialVersionUID = 2844235954903772074L;
-
-    class EntityStats implements Serializable {
-        private static final long serialVersionUID = -8933750377510577120L;
-        public double sum = 0;
-        public double num = 0;
-    }
-    
-    protected Map<Integer, Map<Integer, Double>> ratingsUser;
-    protected Map<Integer, Map<Integer, Double>> ratingsItem;
-    protected Map<Integer, EntityStats> usersStats;
-    protected Map<Integer, EntityStats> itemsStats;
-    
-    protected int nItems = 0;
-    protected int nUsers = 0;
-    protected double sumRatings = 0;
-    protected int nRatings = 0;
-    protected double minRating = 0;
-    protected double maxRating = 0;
-    
-    protected class RatingIterator implements Iterator<Rating> {
-        private int currentUser = -1;
-        private Iterator<Integer> userIt = null;
-        private Iterator<Entry<Integer, Double>> ratsIt = null;
-        private boolean calculated = false;
-        private boolean result = true;
-        
-        RatingIterator() throws Exception {
-        }
-        
-        @Override
-        public boolean hasNext() {
-            if (calculated)
-                return result;
-            
-            calculated = true;
-            result = false;
-            if (ratsIt == null) {
-                if (!ratingsUser.isEmpty()) {
-                    userIt = ratingsUser.keySet().iterator();
-                    if (userIt.hasNext()) {
-                        Integer first = userIt.next();
-                        currentUser = first;
-                        ratsIt = ratingsUser.get(first).entrySet().iterator();
-                        if (ratsIt.hasNext()) {
-                            result = true;
-                        }
-                    }
-                }
-            }
-            else {
-                if (ratsIt.hasNext()) {
-                    result = true;
-                }
-                else if (userIt.hasNext()) {
-                    Integer first = userIt.next();
-                    currentUser = first;
-                    ratsIt = ratingsUser.get(first).entrySet().iterator();
-                    if (ratsIt.hasNext()) {
-                        result = true;
-                    }
-                }
-            }
-            return result;
-        }
-
-        @Override
-        public Rating next() {
-            if (!calculated)
-                hasNext();
-            calculated = false;
-            Entry<Integer, Double> pair = ratsIt.next();
-            
-            return new Rating(currentUser, pair.getKey(), pair.getValue());
-        }
-
-        @Override
-        public void remove() {
-            // TODO Auto-generated method stub
-            
-        }
-        
-    }
-    
-    public MemRecommenderData() {
-        super();
-        ratingsItem = new HashMap<Integer, Map<Integer, Double>>();
-        ratingsUser = new HashMap<Integer, Map<Integer, Double>>();
-        usersStats = new HashMap<Integer, EntityStats>();
-        itemsStats = new HashMap<Integer, EntityStats>();
-    }
-    
-    @Override
-    public void addUser(int userID, List<Integer> ratedItems, List<Double> ratings) {
-        super.addUser(userID, ratedItems, ratings);
-        
-        ratingsUser.put(userID, new HashMap<Integer, Double>());
-        usersStats.put(userID, new EntityStats());
-        
-        int n = ratedItems.size();
-        
-        for (int i = 0; i < n; ++i)
-            auxSetRating(userID, ratedItems.get(i), ratings.get(i));
-    }
-
-    //FIXME: have to update item stats!!!
-    @Override
-    public void removeUser(int userID) {
-        super.removeUser(userID);
-        ratingsUser.remove(userID);
-        usersStats.remove(userID);
-    }
-
-    @Override
-    public void addItem(int itemID, List<Integer> ratingUsers, List<Double> ratings) {
-        super.addItem(itemID, ratingUsers, ratings);
-        
-        ratingsItem.put(itemID, new HashMap<Integer, Double>());
-        itemsStats.put(itemID, new EntityStats());
-        int n = ratingUsers.size();
-        for (int i = 0; i < n; ++i)
-            auxSetRating(ratingUsers.get(i), itemID, ratings.get(i));
-    }
-
-    //FIXME: have to update user stats!!!
-    @Override
-    public void removeItem(int itemID) {
-        super.removeItem(itemID);
-        ratingsItem.remove(itemID);
-        itemsStats.remove(itemID);
-    }
-
-    private void auxSetRating(int userID, int itemID, double rating) {
-        if (nRatings == 0) {
-            minRating = rating;
-            maxRating = rating;
-        }
-        else {
-            minRating = Math.min(minRating, rating);
-            maxRating = Math.max(maxRating, rating);
-        }
-        
-        EntityStats userStats = usersStats.get(userID);
-        EntityStats itemStats = itemsStats.get(itemID);
-        if (userStats == null) {
-            ++nUsers;
-            ratingsUser.put(userID, new HashMap<Integer, Double>());
-            userStats = new EntityStats();
-            usersStats.put(userID, userStats);
-        }
-        
-        if (itemStats == null) {
-            ++nItems;
-            ratingsItem.put(itemID, new HashMap<Integer, Double>());
-            itemStats = new EntityStats();
-            itemsStats.put(itemID, itemStats);
-        }
-        
-        Map<Integer, Double> ratUser = ratingsUser.get(userID);
-        Map<Integer, Double> ratItem = ratingsItem.get(itemID);
-        Double rat = ratUser.get(itemID);
-        if (rat != null) {
-            sumRatings -= rat;
-            userStats.sum -= rat;
-            userStats.num--;
-            itemStats.sum -= rat;
-            itemStats.num--;
-            --nRatings;
-        }
-        
-        userStats.sum += rating;
-        userStats.num++;
-        itemStats.sum += rating;
-        itemStats.num++;
-        sumRatings += rating;
-        ++nRatings;
-        ratUser.put(itemID, rating);
-        ratItem.put(userID, rating);
-    }
-    
-    @Override
-    public void setRating(int userID, int itemID, double rating) {
-        super.setRating(userID, itemID, rating);
-        auxSetRating(userID, itemID, rating);
-    }
-    
-    @Override
-    public void removeRating(int userID, int itemID) {
-        super.removeRating(userID, itemID);
-        
-        Map<Integer, Double> ratUser = ratingsUser.get(userID);
-        Map<Integer, Double> ratItem = ratingsItem.get(itemID);
-        Double rat = ratUser.get(itemID);
-        EntityStats userStats = usersStats.get(userID);
-        EntityStats itemStats = itemsStats.get(itemID);
-        if (rat != null) {
-            sumRatings -= rat;
-            --nRatings;
-            userStats.sum -= rat;
-            userStats.num--;
-            itemStats.sum -= rat;
-            itemStats.num--;
-            ratUser.remove(itemID);
-            ratItem.remove(userID);
-        }
-    }
-
-    @Override
-    public SparseVector getRatingsUser(int userID) {
-        Map<Integer, Double> ratUser = ratingsUser.get(userID);
-        return new SparseVector(ratUser);
-    }
-    
-    @Override
-    public double getRating(int userID, int itemID) {
-        Map<Integer, Double> ratUser = ratingsUser.get(userID);
-        return (ratUser.get(itemID) != null ? ratUser.get(itemID) : 0);
-    }
-
-    @Override
-    public int getNumItems() {
-        return nItems;
-    }
-
-    @Override
-    public int getNumUsers() {
-        return nUsers;
-    }
-    
-    @Override
-    public double getAvgRatingUser(int userID) {
-        EntityStats stats = usersStats.get(userID);
-        double sum = (stats != null ? stats.sum : 0);
-        double num = (stats != null ? stats.num : 0);
-        double mean = (nRatings > 0 ? sumRatings/(double)nRatings : (minRating + maxRating)/2.0);
-        return (mean*25 + sum)/(25 + num);
-    }
-
-    @Override
-    public double getAvgRatingItem(int itemID) {
-        EntityStats stats = itemsStats.get(itemID);
-        double sum = (stats != null ? stats.sum : 0);
-        double num = (stats != null ? stats.num : 0);
-        double mean = (nRatings > 0 ? sumRatings/(double)nRatings : (minRating + maxRating)/2.0);
-        return (mean*25 + sum)/(25 + num);
-    }
-    
-    @Override
-    public double getMinRating() {
-        return minRating;
-    }
-
-    @Override
-    public double getMaxRating() {
-        return maxRating;
-    }
-
-    @Override
-    public Set<Integer> getUsers() {
-        return usersStats.keySet();
-    }
-
-    @Override
-    public SparseVector getRatingsItem(int itemID) {
-        Map<Integer, Double> ratItem = ratingsItem.get(itemID);
-        return new SparseVector(ratItem);
-    }
-
-    @Override
-    public Set<Integer> getItems() {
-        return itemsStats.keySet();
-    }
-
-    @Override
-    public double getGlobalMean() {
-        return (nRatings > 0 ? sumRatings/(double)nRatings : (minRating + maxRating)/2.0);
-    }
-
-    @Override
-    public int countRatingsUser(int userID) {
-        EntityStats stats = usersStats.get(userID);
-        return (stats != null ? (int)stats.num : 0);
-    }
-
-    @Override
-    public int countRatingsItem(int itemID) {
-        EntityStats stats = itemsStats.get(itemID);
-        return (stats != null ? (int)stats.num : 0);
-    }
-
-    @Override
-    public Iterator<Rating> ratingIterator() {
-        // TODO Auto-generated method stub
-        return null;
-    }
-
-    @Override
-    public int getNumRatings() {
-        return nRatings;
-    }
-    
-    @Override
-    public boolean userExists(int userID) {
-        return usersStats.containsKey(userID);
-    }
-    @Override
-    public boolean itemExists(int itemID) {
-        return itemsStats.containsKey(itemID);
-    }
-
-    @Override
-    public void clear() {
-        usersStats.clear();
-        itemsStats.clear();
-        minRating = maxRating = nItems = nUsers = 0;
-        sumRatings = nRatings = 0;
-        ratingsUser.clear();
-        ratingsItem.clear();
-    }
-}
+	private static final long serialVersionUID = 2844235954903772074L;
+
+	class EntityStats implements Serializable {
+		private static final long serialVersionUID = -8933750377510577120L;
+		public double sum = 0;
+		public double num = 0;
+	}
+
+	protected Map<Integer, Map<Integer, Double>> ratingsUser;
+	protected Map<Integer, Map<Integer, Double>> ratingsItem;
+	protected Map<Integer, EntityStats> usersStats;
+	protected Map<Integer, EntityStats> itemsStats;
+
+	protected int nItems = 0;
+	protected int nUsers = 0;
+	protected double sumRatings = 0;
+	protected int nRatings = 0;
+	protected double minRating = 0;
+	protected double maxRating = 0;
+
+	protected class RatingIterator implements Iterator<Rating> {
+		private int currentUser = -1;
+		private Iterator<Integer> userIt = null;
+		private Iterator<Entry<Integer, Double>> ratsIt = null;
+		private boolean calculated = false;
+		private boolean result = true;
+
+		RatingIterator() throws Exception {
+		}
+
+		@Override
+		public boolean hasNext() {
+			if (calculated)
+				return result;
+
+			calculated = true;
+			result = false;
+			if (ratsIt == null) {
+				if (!ratingsUser.isEmpty()) {
+					userIt = ratingsUser.keySet().iterator();
+					if (userIt.hasNext()) {
+						Integer first = userIt.next();
+						currentUser = first;
+						ratsIt = ratingsUser.get(first).entrySet().iterator();
+						if (ratsIt.hasNext()) {
+							result = true;
+						}
+					}
+				}
+			} else {
+				if (ratsIt.hasNext()) {
+					result = true;
+				} else if (userIt.hasNext()) {
+					Integer first = userIt.next();
+					currentUser = first;
+					ratsIt = ratingsUser.get(first).entrySet().iterator();
+					if (ratsIt.hasNext()) {
+						result = true;
+					}
+				}
+			}
+			return result;
+		}
+
+		@Override
+		public Rating next() {
+			if (!calculated)
+				hasNext();
+			calculated = false;
+			Entry<Integer, Double> pair = ratsIt.next();
+
+			return new Rating(currentUser, pair.getKey(), pair.getValue());
+		}
+
+		@Override
+		public void remove() {
+			// TODO Auto-generated method stub
+
+		}
+
+	}
+
+	public MemRecommenderData() {
+		super();
+		ratingsItem = new HashMap<>();
+		ratingsUser = new HashMap<>();
+		usersStats = new HashMap<>();
+		itemsStats = new HashMap<>();
+	}
+
+	@Override
+	public void addUser(int userID, List<Integer> ratedItems, List<Double> ratings) {
+		super.addUser(userID, ratedItems, ratings);
+
+		ratingsUser.put(userID, new HashMap<Integer, Double>());
+		usersStats.put(userID, new EntityStats());
+
+		int n = ratedItems.size();
+
+		for (int i = 0; i < n; ++i)
+			auxSetRating(userID, ratedItems.get(i), ratings.get(i));
+	}
+
+	// FIXME: have to update item stats!!!
+	@Override
+	public void removeUser(int userID) {
+		super.removeUser(userID);
+		ratingsUser.remove(userID);
+		usersStats.remove(userID);
+	}
+
+	@Override
+	public void addItem(int itemID, List<Integer> ratingUsers, List<Double> ratings) {
+		super.addItem(itemID, ratingUsers, ratings);
+
+		ratingsItem.put(itemID, new HashMap<Integer, Double>());
+		itemsStats.put(itemID, new EntityStats());
+		int n = ratingUsers.size();
+		for (int i = 0; i < n; ++i)
+			auxSetRating(ratingUsers.get(i), itemID, ratings.get(i));
+	}
+
+	// FIXME: have to update user stats!!!
+	@Override
+	public void removeItem(int itemID) {
+		super.removeItem(itemID);
+		ratingsItem.remove(itemID);
+		itemsStats.remove(itemID);
+	}
+
+	private void auxSetRating(int userID, int itemID, double rating) {
+		if (nRatings == 0) {
+			minRating = rating;
+			maxRating = rating;
+		} else {
+			minRating = Math.min(minRating, rating);
+			maxRating = Math.max(maxRating, rating);
+		}
+
+		EntityStats userStats = usersStats.get(userID);
+		EntityStats itemStats = itemsStats.get(itemID);
+		if (userStats == null) {
+			++nUsers;
+			ratingsUser.put(userID, new HashMap<Integer, Double>());
+			userStats = new EntityStats();
+			usersStats.put(userID, userStats);
+		}
 
+		if (itemStats == null) {
+			++nItems;
+			ratingsItem.put(itemID, new HashMap<Integer, Double>());
+			itemStats = new EntityStats();
+			itemsStats.put(itemID, itemStats);
+		}
+
+		Map<Integer, Double> ratUser = ratingsUser.get(userID);
+		Map<Integer, Double> ratItem = ratingsItem.get(itemID);
+		Double rat = ratUser.get(itemID);
+		if (rat != null) {
+			sumRatings -= rat;
+			userStats.sum -= rat;
+			userStats.num--;
+			itemStats.sum -= rat;
+			itemStats.num--;
+			--nRatings;
+		}
+
+		userStats.sum += rating;
+		userStats.num++;
+		itemStats.sum += rating;
+		itemStats.num++;
+		sumRatings += rating;
+		++nRatings;
+		ratUser.put(itemID, rating);
+		ratItem.put(userID, rating);
+	}
+
+	@Override
+	public void setRating(int userID, int itemID, double rating) {
+		super.setRating(userID, itemID, rating);
+		auxSetRating(userID, itemID, rating);
+	}
+
+	@Override
+	public void removeRating(int userID, int itemID) {
+		super.removeRating(userID, itemID);
+
+		Map<Integer, Double> ratUser = ratingsUser.get(userID);
+		Map<Integer, Double> ratItem = ratingsItem.get(itemID);
+		Double rat = ratUser.get(itemID);
+		EntityStats userStats = usersStats.get(userID);
+		EntityStats itemStats = itemsStats.get(itemID);
+		if (rat != null) {
+			sumRatings -= rat;
+			--nRatings;
+			userStats.sum -= rat;
+			userStats.num--;
+			itemStats.sum -= rat;
+			itemStats.num--;
+			ratUser.remove(itemID);
+			ratItem.remove(userID);
+		}
+	}
+
+	@Override
+	public SparseVector getRatingsUser(int userID) {
+		Map<Integer, Double> ratUser = ratingsUser.get(userID);
+		return new SparseVector(ratUser);
+	}
+
+	@Override
+	public double getRating(int userID, int itemID) {
+		Map<Integer, Double> ratUser = ratingsUser.get(userID);
+		return (ratUser.get(itemID) != null ? ratUser.get(itemID) : 0);
+	}
+
+	@Override
+	public int getNumItems() {
+		return nItems;
+	}
+
+	@Override
+	public int getNumUsers() {
+		return nUsers;
+	}
+
+	@Override
+	public double getAvgRatingUser(int userID) {
+		EntityStats stats = usersStats.get(userID);
+		double sum = (stats != null ? stats.sum : 0);
+		double num = (stats != null ? stats.num : 0);
+		double mean = (nRatings > 0 ? sumRatings / nRatings : (minRating + maxRating) / 2.0);
+		return (mean * 25 + sum) / (25 + num);
+	}
+
+	@Override
+	public double getAvgRatingItem(int itemID) {
+		EntityStats stats = itemsStats.get(itemID);
+		double sum = (stats != null ? stats.sum : 0);
+		double num = (stats != null ? stats.num : 0);
+		double mean = (nRatings > 0 ? sumRatings / nRatings : (minRating + maxRating) / 2.0);
+		return (mean * 25 + sum) / (25 + num);
+	}
+
+	@Override
+	public double getMinRating() {
+		return minRating;
+	}
+
+	@Override
+	public double getMaxRating() {
+		return maxRating;
+	}
+
+	@Override
+	public Set<Integer> getUsers() {
+		return usersStats.keySet();
+	}
+
+	@Override
+	public SparseVector getRatingsItem(int itemID) {
+		Map<Integer, Double> ratItem = ratingsItem.get(itemID);
+		return new SparseVector(ratItem);
+	}
+
+	@Override
+	public Set<Integer> getItems() {
+		return itemsStats.keySet();
+	}
+
+	@Override
+	public double getGlobalMean() {
+		return (nRatings > 0 ? sumRatings / nRatings : (minRating + maxRating) / 2.0);
+	}
+
+	@Override
+	public int countRatingsUser(int userID) {
+		EntityStats stats = usersStats.get(userID);
+		return (stats != null ? (int) stats.num : 0);
+	}
+
+	@Override
+	public int countRatingsItem(int itemID) {
+		EntityStats stats = itemsStats.get(itemID);
+		return (stats != null ? (int) stats.num : 0);
+	}
+
+	@Override
+	public Iterator<Rating> ratingIterator() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public int getNumRatings() {
+		return nRatings;
+	}
+
+	@Override
+	public boolean userExists(int userID) {
+		return usersStats.containsKey(userID);
+	}
+
+	@Override
+	public boolean itemExists(int itemID) {
+		return itemsStats.containsKey(itemID);
+	}
+
+	@Override
+	public void clear() {
+		usersStats.clear();
+		itemsStats.clear();
+		minRating = maxRating = nItems = nUsers = 0;
+		sumRatings = nRatings = 0;
+		ratingsUser.clear();
+		ratingsItem.clear();
+	}
+}
diff --git a/moa/src/main/java/moa/recommender/rc/predictor/RatingPredictor.java b/moa/src/main/java/moa/recommender/rc/predictor/RatingPredictor.java
index 9033917f9..a72ed3acd 100644
--- a/moa/src/main/java/moa/recommender/rc/predictor/RatingPredictor.java
+++ b/moa/src/main/java/moa/recommender/rc/predictor/RatingPredictor.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.recommender.rc.predictor;
@@ -26,8 +26,11 @@
 import moa.recommender.rc.data.RecommenderData;
 
 public interface RatingPredictor extends Serializable {
-	public double predictRating(int userID, int itemID);
-	public List<Double> predictRatings(int userID, List<Integer> itemIDS);
-	public RecommenderData getData();
-	public void train();
+	double predictRating(int userID, int itemID);
+
+	List<Double> predictRatings(int userID, List<Integer> itemIDS);
+
+	RecommenderData getData();
+
+	void train();
 }
diff --git a/moa/src/main/java/moa/recommender/rc/predictor/impl/BRISMFPredictor.java b/moa/src/main/java/moa/recommender/rc/predictor/impl/BRISMFPredictor.java
index 936496e73..20fb40c4f 100644
--- a/moa/src/main/java/moa/recommender/rc/predictor/impl/BRISMFPredictor.java
+++ b/moa/src/main/java/moa/recommender/rc/predictor/impl/BRISMFPredictor.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.recommender.rc.predictor.impl;
@@ -33,407 +33,408 @@
 import moa.recommender.rc.utils.Updatable;
 
 /**
- * Implementation of the algorithm described in Scalable 
- * Collaborative Filtering Approaches for Large Recommender
- * Systems (Gábor Takács, István Pilászy, Bottyán Németh, 
- * and Domonkos Tikk). A feature vector is learned for every 
- * user and item, so that the prediction of a rating is roughly
- * the dot product of the corresponding user and item vector. 
- * Stochastic gradient descent is used to train the model, 
- * minimizing its prediction error. Both Tikhonov regularization
- * and early stopping are used to reduce overfitting. The 
- * algorithm allows batch training (from scratch, using all
- * ratings available at the moment) as well as incremental,
- * by retraining only the affected user and item vectors when 
- * a new rating is inserted.
- * 
- * <p>Parameters:</p>
+ * Implementation of the algorithm described in Scalable Collaborative Filtering
+ * Approaches for Large Recommender Systems (Gábor Takács, István Pilászy,
+ * Bottyán Németh, and Domonkos Tikk). A feature vector is learned for every
+ * user and item, so that the prediction of a rating is roughly the dot product
+ * of the corresponding user and item vector. Stochastic gradient descent is
+ * used to train the model, minimizing its prediction error. Both Tikhonov
+ * regularization and early stopping are used to reduce overfitting. The
+ * algorithm allows batch training (from scratch, using all ratings available at
+ * the moment) as well as incremental, by retraining only the affected user and
+ * item vectors when a new rating is inserted.
+ *
+ * <p>
+ * Parameters:
+ * </p>
  * <ul>
- * <li> features - the number of features to be trained for each user and 
- *      item</li>
- * <li> learning rate - the learning rate used in the regularization</li>
- * <li> ratio - the regularization ratio to be used in the Tikhonov 
- *      regularization</li>
- * <li> iterations - the number of iterations to be used when retraining
- *      user and item features (online training). </li>
- * </lu>
- * 
+ * <li>features - the number of features to be trained for each user and
+ * item</li>
+ * <li>learning rate - the learning rate used in the regularization</li>
+ * <li>ratio - the regularization ratio to be used in the Tikhonov
+ * regularization</li>
+ * <li>iterations - the number of iterations to be used when retraining user and
+ * item features (online training).</li> </lu>
+ *
  */
 
 public class BRISMFPredictor implements Updatable {
-    
-    protected RecommenderData data;
-    protected int nFeatures;
-    protected HashMap<Integer, float[]> userFeature;
-    protected HashMap<Integer, float[]> itemFeature;
-    protected Random rnd;
-    protected double lRate = 0.01;
-    protected double rFactor = 0.02;
-    protected int nIterations = 30;
-    
-    public void setLRate(double lRate) {
-        this.lRate = lRate;
-    }
-    
-    public void setRFactor(double rFactor) {
-        this.rFactor = rFactor;
-    }
-    
-    public void setNIterations(int nIterations) {
-        this.nIterations = nIterations; 
-    }
-    
-    public RecommenderData getData() {
-    	return data;
-    }
-    
-    public BRISMFPredictor(int nFeatures, RecommenderData data, boolean train) {
-        this.data = data;
-        this.nFeatures = nFeatures;
-        this.userFeature = new HashMap<Integer, float[]>();
-        this.itemFeature = new HashMap<Integer, float[]>();
-        this.rnd = new Random(12345);
-        data.attachUpdatable(this);
-        if (train) train();
-    }
-    
-    public BRISMFPredictor(int nFeatures, RecommenderData data, double lRate, double rFactor, boolean train) {
-        this.data = data;
-        this.nFeatures = nFeatures;
-        this.userFeature = new HashMap<Integer, float[]>();
-        this.itemFeature = new HashMap<Integer, float[]>();
-        this.rnd = new Random(12345);
-        this.lRate = lRate;
-        this.rFactor = rFactor;
-        data.attachUpdatable(this);
-        if (train) train();
-    }
-    
-    private void resetFeatures(float[] feats, boolean userFeats) {
-        int n = feats.length;
-        for (int i = 0; i < n; ++i)
-            feats[i] = (float)0.01*(rnd.nextFloat()*2 - 1);
-        if (userFeats) feats[0] = 1;
-        else feats[1] = 1;
-    }
-    
-    public double predictRating(int userID, int itemID) {
-        float[] userFeats = userFeature.get(userID);
-        float[] itemFeats = itemFeature.get(itemID);
-        return predictRating(userFeats, itemFeats);
-    }
-    
-    public double predictRating(float userFeats[], float itemFeats[]) {
-        double ret = data.getGlobalMean();
-        if (userFeats != null && itemFeats != null)
-            for (int i = 0; i < nFeatures; ++i)
-                ret += userFeats[i]*itemFeats[i];
-
-        if (ret < data.getMinRating()) ret = data.getMinRating();
-        else if (ret > data.getMaxRating()) ret = data.getMaxRating();
-        
-        return ret;
-    }
-    
-    public float[] trainUserFeats(List<Integer> itm, List<Double> rat, int nIts) {
-        float[] userFeats = new float[nFeatures];
-        resetFeatures(userFeats, true);
-        
-        int n = itm.size();
-        for (int k = 0; k < nIts; ++k) {
-            for (int i = 0; i < n; ++i) {
-                int itemID = itm.get(i);
-                float[] itemFeats = itemFeature.get(itemID);
-                double rating = rat.get(i);
-                double pred = predictRating(userFeats, itemFeats);
-                double err = rating - pred;
-                
-                if (itemFeats != null)
-                    for (int j = 1; j < nFeatures; ++j) 
-                        userFeats[j] += lRate*(err*itemFeats[j] - rFactor*userFeats[j]);
-            }
-        }
-        
-        return userFeats;
-    }
-    
-    public float[] trainItemFeats(int itemID, List<Integer> usr, List<Double> rat, int nIts) {
-        float[] itemFeats = new float[nFeatures];
-        resetFeatures(itemFeats, false);
-        
-        int n = usr.size();
-        for (int k = 0; k < nIts; ++k) {
-            for (int i = 0; i < n; ++i) {
-                int userID = usr.get(i);
-                float[] userFeats = userFeature.get(userID);
-                double rating = rat.get(i);
-                double pred = predictRating(userFeats, itemFeats);
-                double err = rating - pred;
-                
-                if (userFeats != null) {
-                    itemFeats[0] += lRate*(err*userFeats[0] - rFactor*itemFeats[0]);
-                    for (int j = 2; j < nFeatures; ++j)
-                        itemFeats[j] += lRate*(err*userFeats[j] - rFactor*itemFeats[j]);
-                }
-            }
-        }
-        
-        return itemFeats;
-    }
-    
-    public void trainUser(int userID, List<Integer> itm, List<Double> rat, int nIts) {
-        userFeature.put(userID, trainUserFeats(itm, rat, nIts));
-    }
-    
-    public void trainUser(int userID, int nIts) {
-        SparseVector usrRats = data.getRatingsUser(userID);
-        ArrayList<Integer> itm = new ArrayList<Integer>();
-        ArrayList<Double> rat = new ArrayList<Double>();
-        Iterator<Pair<Integer, Double>> it = usrRats.iterator();
-        
-        while (it.hasNext()) {
-            Pair<Integer, Double> p = it.next();
-            itm.add(p.getFirst());
-            rat.add(p.getSecond());
-        }
-        trainUser(userID, itm, rat, nIts);
-    }
-    
-    public void trainUser(int userID, List<Integer> itm, List<Double> rat) {
-        userFeature.put(userID, trainUserFeats(itm, rat, nIterations));
-    }
-    
-    public void trainItem(int itemID) {
-        SparseVector itmRats = data.getRatingsItem(itemID);
-        ArrayList<Integer> usr = new ArrayList<Integer>();
-        ArrayList<Double> rat = new ArrayList<Double>();
-        Iterator<Pair<Integer, Double>> it = itmRats.iterator();
-        
-        while (it.hasNext()) {
-            Pair<Integer, Double> p = it.next();
-            usr.add(p.getFirst());
-            rat.add(p.getSecond());
-        }
-        trainItem(itemID, usr, rat);
-    }
-    
-    public void trainItem(int itemID, int nIts) {
-        SparseVector itmRats = data.getRatingsItem(itemID);
-        ArrayList<Integer> usr = new ArrayList<Integer>();
-        ArrayList<Double> rat = new ArrayList<Double>();
-        Iterator<Pair<Integer, Double>> it = itmRats.iterator();
-        
-        while (it.hasNext()) {
-            Pair<Integer, Double> p = it.next();
-            usr.add(p.getFirst());
-            rat.add(p.getSecond());
-        }
-        trainItem(itemID, usr, rat, nIts);
-    }
-    
-    public void trainUser(int userID) {
-        SparseVector usrRats = data.getRatingsUser(userID);
-        ArrayList<Integer> itm = new ArrayList<Integer>();
-        ArrayList<Double> rat = new ArrayList<Double>();
-        Iterator<Pair<Integer, Double>> it = usrRats.iterator();
-        
-        while (it.hasNext()) {
-            Pair<Integer, Double> p = it.next();
-            itm.add(p.getFirst());
-            rat.add(p.getSecond());
-        }
-        trainUser(userID, itm, rat);
-    }
-    
-    public void trainItem(int itemID, List<Integer> usr, List<Double> rat) {
-        itemFeature.put(itemID, trainItemFeats(itemID, usr, rat, nIterations));
-    }
-    
-    public void trainItem(int itemID, List<Integer> usr, List<Double> rat, int nIts) {
-        itemFeature.put(itemID, trainItemFeats(itemID, usr, rat, nIts));
-    }
-    
-    public void train() {
-        userFeature.clear();
-        itemFeature.clear();
-        
-        int n = data.getNumRatings();
-        
-        Iterator<Integer> it = data.getUsers().iterator();
-        while (it.hasNext()) {
-            float[] feats = new float[nFeatures];
-            resetFeatures(feats, true);
-            userFeature.put(it.next(), feats);
-        }
-        
-        it = data.getItems().iterator();
-        while (it.hasNext()) {
-            float[] feats = new float[nFeatures];
-            resetFeatures(feats, false);
-            itemFeature.put(it.next(), feats);
-        }
-
-        int exit = 0;
-        double lastRMSE = 1e20;
-        
-        int count = 0;
-        int trainDiv = Math.max(20, n/1000000);
-        ArrayList<Rating> ratTest = new ArrayList<Rating>(n/trainDiv);
-        do {
-            long start = System.currentTimeMillis();
-            Iterator<Rating> ratIt = data.ratingIterator();
-            int idx = 0;
-            
-            while (ratIt.hasNext()) {
-                Rating rat = ratIt.next();
-                if (idx%trainDiv == 0) {
-                    if (count == 0) ratTest.add(rat);
-                }
-                else {
-                    int userID = rat.userID;
-                    int itemID = rat.itemID;
-                    double rating = rat.rating;
-                    float[] userFeats = userFeature.get(userID);
-                    float[] itemFeats = itemFeature.get(itemID);
-                    
-                    double pred = predictRating(userFeats, itemFeats);
-                    double err = rating - pred;
-                    
-                    itemFeats[0] += lRate*(err*userFeats[0] - rFactor*itemFeats[0]);
-                    userFeats[1] += lRate*(err*itemFeats[1] - rFactor*userFeats[1]);
-                    for (int j = 2; j < nFeatures; ++j) {
-                        double uv = userFeats[j];
-                        userFeats[j] += lRate*(err*itemFeats[j] - rFactor*userFeats[j]);
-                        itemFeats[j] += lRate*(err*uv - rFactor*itemFeats[j]);
-                    }
-                }
-                ++idx;
-            }
-            int nTest = ratTest.size();
-
-            double sum = 0;
-            for (int i = 0; i < nTest; ++i) {
-                int userID = ratTest.get(i).userID;
-                int itemID = ratTest.get(i).itemID;
-                double rating = ratTest.get(i).rating;
-                double pred = predictRating(userID, itemID);
-                sum += Math.pow(rating - pred, 2);
-            }
-            
-            double curRMSE = Math.sqrt(sum/(double)nTest);
-            System.out.println(curRMSE + " " + (System.currentTimeMillis() - start)/1000);
-            if (curRMSE + 0.0001 >= lastRMSE) {
-                ++exit;
-            }
-            lastRMSE = curRMSE;
-            ++count;
-        }
-        while (exit < 1);
-    }
-    
-    public float[] getUserFeatures(int userID) {
-        return userFeature.get(userID);
-    }
-
-    public float[] getItemFeatures(int itemID) {
-        return itemFeature.get(itemID);
-    }
-
-    public int getNumFeatures() {
-        return nFeatures;
-    }
-    
-    @Override
-    public void updateNewUser(int userID, List<Integer> ratedItems,
-            List<Double> ratings) {
-        if (!ratedItems.isEmpty()) {
-            trainUser(userID, ratedItems, ratings);
-        }
-    }
-
-    @Override
-    public void updateNewItem(int itemID, List<Integer> ratingUsers,
-            List<Double> ratings) {
-        if (!ratingUsers.isEmpty()) {
-            trainItem(itemID, ratingUsers, ratings);
-        }
-    }
-
-    @Override
-    public void updateRemoveUser(int userID) {
-        userFeature.remove(userID);
-    }
-
-    @Override
-    public void updateRemoveItem(int itemID) {
-        itemFeature.remove(itemID);
-    }
-    
-    //We retrain the user/item separately, depending on a probability
-    //calculated using the error when predicting the new rating
-    //TODO: parametrize this
-    @Override
-    public void updateSetRating(int userID, int itemID, double rating) {
-        double nUsr = data.countRatingsUser(userID);
-        double nItm = data.countRatingsItem(itemID);
-        double prob1 = Math.pow(0.99, nUsr);
-        double prob2 = Math.pow(0.99, nItm);
-
-        if (nUsr < 5 || rnd.nextDouble() < prob1) {
-            SparseVector usrRats = data.getRatingsUser(userID);
-            ArrayList<Integer> itm = new ArrayList<Integer>();
-            ArrayList<Double> rat = new ArrayList<Double>();
-            
-            //Train user
-            boolean found = false;
-            Iterator<Pair<Integer, Double>> it = usrRats.iterator();
-            while (it.hasNext()) {
-                Pair<Integer, Double> p = it.next();
-                itm.add(p.getFirst());
-                if (p.getFirst() == itemID) {
-                    found = true;
-                    rat.add(rating);
-                }
-                else rat.add(p.getSecond());
-            }
-            if (!found) {
-                itm.add(itemID);
-                rat.add(rating);
-            }
-            trainUser(userID, itm, rat);
-        }
-        
-        if (nItm < 5 || rnd.nextDouble() < prob2) {
-            SparseVector itmRats = data.getRatingsItem(itemID);
-            //Train item
-            Iterator<Pair<Integer, Double>> it = itmRats.iterator();
-            boolean found = false;
-            ArrayList<Integer> usr = new ArrayList<Integer>();
-            ArrayList<Double> rat = new ArrayList<Double>();
-            while (it.hasNext()) {
-                Pair<Integer, Double> p = it.next();
-                usr.add(p.getFirst());
-                if (p.getFirst() == userID) {
-                    found = true;
-                    rat.add(rating);
-                }
-                else rat.add(p.getSecond());
-            }
-            if (!found) {
-                usr.add(itemID);
-                rat.add(rating);
-            }
-            trainItem(itemID, usr, rat);
-        }
-    }
-
-    @Override
-    public void updateRemoveRating(int userID, int itemID) {
-    }
+
+	protected RecommenderData data;
+	protected int nFeatures;
+	protected HashMap<Integer, float[]> userFeature;
+	protected HashMap<Integer, float[]> itemFeature;
+	protected Random rnd;
+	protected double lRate = 0.01;
+	protected double rFactor = 0.02;
+	protected int nIterations = 30;
+
+	public void setLRate(double lRate) {
+		this.lRate = lRate;
+	}
+
+	public void setRFactor(double rFactor) {
+		this.rFactor = rFactor;
+	}
+
+	public void setNIterations(int nIterations) {
+		this.nIterations = nIterations;
+	}
+
+	public RecommenderData getData() {
+		return data;
+	}
+
+	public BRISMFPredictor(int nFeatures, RecommenderData data, boolean train) {
+		this.data = data;
+		this.nFeatures = nFeatures;
+		this.userFeature = new HashMap<>();
+		this.itemFeature = new HashMap<>();
+		this.rnd = new Random(12345);
+		data.attachUpdatable(this);
+		if (train)
+			train();
+	}
+
+	public BRISMFPredictor(int nFeatures, RecommenderData data, double lRate, double rFactor, boolean train) {
+		this.data = data;
+		this.nFeatures = nFeatures;
+		this.userFeature = new HashMap<>();
+		this.itemFeature = new HashMap<>();
+		this.rnd = new Random(12345);
+		this.lRate = lRate;
+		this.rFactor = rFactor;
+		data.attachUpdatable(this);
+		if (train)
+			train();
+	}
+
+	private void resetFeatures(float[] feats, boolean userFeats) {
+		int n = feats.length;
+		for (int i = 0; i < n; ++i)
+			feats[i] = (float) 0.01 * (rnd.nextFloat() * 2 - 1);
+		if (userFeats)
+			feats[0] = 1;
+		else
+			feats[1] = 1;
+	}
+
+	public double predictRating(int userID, int itemID) {
+		float[] userFeats = userFeature.get(userID);
+		float[] itemFeats = itemFeature.get(itemID);
+		return predictRating(userFeats, itemFeats);
+	}
+
+	public double predictRating(float userFeats[], float itemFeats[]) {
+		double ret = data.getGlobalMean();
+		if (userFeats != null && itemFeats != null)
+			for (int i = 0; i < nFeatures; ++i)
+				ret += userFeats[i] * itemFeats[i];
+
+		if (ret < data.getMinRating())
+			ret = data.getMinRating();
+		else if (ret > data.getMaxRating())
+			ret = data.getMaxRating();
+
+		return ret;
+	}
+
+	public float[] trainUserFeats(List<Integer> itm, List<Double> rat, int nIts) {
+		float[] userFeats = new float[nFeatures];
+		resetFeatures(userFeats, true);
+
+		int n = itm.size();
+		for (int k = 0; k < nIts; ++k) {
+			for (int i = 0; i < n; ++i) {
+				int itemID = itm.get(i);
+				float[] itemFeats = itemFeature.get(itemID);
+				double rating = rat.get(i);
+				double pred = predictRating(userFeats, itemFeats);
+				double err = rating - pred;
+
+				if (itemFeats != null)
+					for (int j = 1; j < nFeatures; ++j)
+						userFeats[j] += lRate * (err * itemFeats[j] - rFactor * userFeats[j]);
+			}
+		}
+
+		return userFeats;
+	}
+
+	public float[] trainItemFeats(int itemID, List<Integer> usr, List<Double> rat, int nIts) {
+		float[] itemFeats = new float[nFeatures];
+		resetFeatures(itemFeats, false);
+
+		int n = usr.size();
+		for (int k = 0; k < nIts; ++k) {
+			for (int i = 0; i < n; ++i) {
+				int userID = usr.get(i);
+				float[] userFeats = userFeature.get(userID);
+				double rating = rat.get(i);
+				double pred = predictRating(userFeats, itemFeats);
+				double err = rating - pred;
+
+				if (userFeats != null) {
+					itemFeats[0] += lRate * (err * userFeats[0] - rFactor * itemFeats[0]);
+					for (int j = 2; j < nFeatures; ++j)
+						itemFeats[j] += lRate * (err * userFeats[j] - rFactor * itemFeats[j]);
+				}
+			}
+		}
+
+		return itemFeats;
+	}
+
+	public void trainUser(int userID, List<Integer> itm, List<Double> rat, int nIts) {
+		userFeature.put(userID, trainUserFeats(itm, rat, nIts));
+	}
+
+	public void trainUser(int userID, int nIts) {
+		SparseVector usrRats = data.getRatingsUser(userID);
+		ArrayList<Integer> itm = new ArrayList<>();
+		ArrayList<Double> rat = new ArrayList<>();
+		Iterator<Pair<Integer, Double>> it = usrRats.iterator();
+
+		while (it.hasNext()) {
+			Pair<Integer, Double> p = it.next();
+			itm.add(p.getFirst());
+			rat.add(p.getSecond());
+		}
+		trainUser(userID, itm, rat, nIts);
+	}
+
+	public void trainUser(int userID, List<Integer> itm, List<Double> rat) {
+		userFeature.put(userID, trainUserFeats(itm, rat, nIterations));
+	}
+
+	public void trainItem(int itemID) {
+		SparseVector itmRats = data.getRatingsItem(itemID);
+		ArrayList<Integer> usr = new ArrayList<>();
+		ArrayList<Double> rat = new ArrayList<>();
+		Iterator<Pair<Integer, Double>> it = itmRats.iterator();
+
+		while (it.hasNext()) {
+			Pair<Integer, Double> p = it.next();
+			usr.add(p.getFirst());
+			rat.add(p.getSecond());
+		}
+		trainItem(itemID, usr, rat);
+	}
+
+	public void trainItem(int itemID, int nIts) {
+		SparseVector itmRats = data.getRatingsItem(itemID);
+		ArrayList<Integer> usr = new ArrayList<>();
+		ArrayList<Double> rat = new ArrayList<>();
+		Iterator<Pair<Integer, Double>> it = itmRats.iterator();
+
+		while (it.hasNext()) {
+			Pair<Integer, Double> p = it.next();
+			usr.add(p.getFirst());
+			rat.add(p.getSecond());
+		}
+		trainItem(itemID, usr, rat, nIts);
+	}
+
+	public void trainUser(int userID) {
+		SparseVector usrRats = data.getRatingsUser(userID);
+		ArrayList<Integer> itm = new ArrayList<>();
+		ArrayList<Double> rat = new ArrayList<>();
+		Iterator<Pair<Integer, Double>> it = usrRats.iterator();
+
+		while (it.hasNext()) {
+			Pair<Integer, Double> p = it.next();
+			itm.add(p.getFirst());
+			rat.add(p.getSecond());
+		}
+		trainUser(userID, itm, rat);
+	}
+
+	public void trainItem(int itemID, List<Integer> usr, List<Double> rat) {
+		itemFeature.put(itemID, trainItemFeats(itemID, usr, rat, nIterations));
+	}
+
+	public void trainItem(int itemID, List<Integer> usr, List<Double> rat, int nIts) {
+		itemFeature.put(itemID, trainItemFeats(itemID, usr, rat, nIts));
+	}
+
+	public void train() {
+		userFeature.clear();
+		itemFeature.clear();
+
+		int n = data.getNumRatings();
+
+		Iterator<Integer> it = data.getUsers().iterator();
+		while (it.hasNext()) {
+			float[] feats = new float[nFeatures];
+			resetFeatures(feats, true);
+			userFeature.put(it.next(), feats);
+		}
+
+		it = data.getItems().iterator();
+		while (it.hasNext()) {
+			float[] feats = new float[nFeatures];
+			resetFeatures(feats, false);
+			itemFeature.put(it.next(), feats);
+		}
+
+		int exit = 0;
+		double lastRMSE = 1e20;
+
+		int count = 0;
+		int trainDiv = Math.max(20, n / 1000000);
+		ArrayList<Rating> ratTest = new ArrayList<>(n / trainDiv);
+		do {
+			long start = System.currentTimeMillis();
+			Iterator<Rating> ratIt = data.ratingIterator();
+			int idx = 0;
+
+			while (ratIt.hasNext()) {
+				Rating rat = ratIt.next();
+				if (idx % trainDiv == 0) {
+					if (count == 0)
+						ratTest.add(rat);
+				} else {
+					int userID = rat.userID;
+					int itemID = rat.itemID;
+					double rating = rat.rating;
+					float[] userFeats = userFeature.get(userID);
+					float[] itemFeats = itemFeature.get(itemID);
+
+					double pred = predictRating(userFeats, itemFeats);
+					double err = rating - pred;
+
+					itemFeats[0] += lRate * (err * userFeats[0] - rFactor * itemFeats[0]);
+					userFeats[1] += lRate * (err * itemFeats[1] - rFactor * userFeats[1]);
+					for (int j = 2; j < nFeatures; ++j) {
+						double uv = userFeats[j];
+						userFeats[j] += lRate * (err * itemFeats[j] - rFactor * userFeats[j]);
+						itemFeats[j] += lRate * (err * uv - rFactor * itemFeats[j]);
+					}
+				}
+				++idx;
+			}
+			int nTest = ratTest.size();
+
+			double sum = 0;
+			for (int i = 0; i < nTest; ++i) {
+				int userID = ratTest.get(i).userID;
+				int itemID = ratTest.get(i).itemID;
+				double rating = ratTest.get(i).rating;
+				double pred = predictRating(userID, itemID);
+				sum += Math.pow(rating - pred, 2);
+			}
+
+			double curRMSE = Math.sqrt(sum / nTest);
+			System.out.println(curRMSE + " " + (System.currentTimeMillis() - start) / 1000);
+			if (curRMSE + 0.0001 >= lastRMSE) {
+				++exit;
+			}
+			lastRMSE = curRMSE;
+			++count;
+		} while (exit < 1);
+	}
+
+	public float[] getUserFeatures(int userID) {
+		return userFeature.get(userID);
+	}
+
+	public float[] getItemFeatures(int itemID) {
+		return itemFeature.get(itemID);
+	}
+
+	public int getNumFeatures() {
+		return nFeatures;
+	}
+
+	@Override
+	public void updateNewUser(int userID, List<Integer> ratedItems, List<Double> ratings) {
+		if (!ratedItems.isEmpty()) {
+			trainUser(userID, ratedItems, ratings);
+		}
+	}
+
+	@Override
+	public void updateNewItem(int itemID, List<Integer> ratingUsers, List<Double> ratings) {
+		if (!ratingUsers.isEmpty()) {
+			trainItem(itemID, ratingUsers, ratings);
+		}
+	}
+
+	@Override
+	public void updateRemoveUser(int userID) {
+		userFeature.remove(userID);
+	}
+
+	@Override
+	public void updateRemoveItem(int itemID) {
+		itemFeature.remove(itemID);
+	}
+
+	// We retrain the user/item separately, depending on a probability
+	// calculated using the error when predicting the new rating
+	// TODO: parametrize this
+	@Override
+	public void updateSetRating(int userID, int itemID, double rating) {
+		double nUsr = data.countRatingsUser(userID);
+		double nItm = data.countRatingsItem(itemID);
+		double prob1 = Math.pow(0.99, nUsr);
+		double prob2 = Math.pow(0.99, nItm);
+
+		if (nUsr < 5 || rnd.nextDouble() < prob1) {
+			SparseVector usrRats = data.getRatingsUser(userID);
+			ArrayList<Integer> itm = new ArrayList<>();
+			ArrayList<Double> rat = new ArrayList<>();
+
+			// Train user
+			boolean found = false;
+			Iterator<Pair<Integer, Double>> it = usrRats.iterator();
+			while (it.hasNext()) {
+				Pair<Integer, Double> p = it.next();
+				itm.add(p.getFirst());
+				if (p.getFirst() == itemID) {
+					found = true;
+					rat.add(rating);
+				} else
+					rat.add(p.getSecond());
+			}
+			if (!found) {
+				itm.add(itemID);
+				rat.add(rating);
+			}
+			trainUser(userID, itm, rat);
+		}
+
+		if (nItm < 5 || rnd.nextDouble() < prob2) {
+			SparseVector itmRats = data.getRatingsItem(itemID);
+			// Train item
+			Iterator<Pair<Integer, Double>> it = itmRats.iterator();
+			boolean found = false;
+			ArrayList<Integer> usr = new ArrayList<>();
+			ArrayList<Double> rat = new ArrayList<>();
+			while (it.hasNext()) {
+				Pair<Integer, Double> p = it.next();
+				usr.add(p.getFirst());
+				if (p.getFirst() == userID) {
+					found = true;
+					rat.add(rating);
+				} else
+					rat.add(p.getSecond());
+			}
+			if (!found) {
+				usr.add(itemID);
+				rat.add(rating);
+			}
+			trainItem(itemID, usr, rat);
+		}
+	}
+
+	@Override
+	public void updateRemoveRating(int userID, int itemID) {
+	}
 
 	public List<Double> predictRatings(int userID, List<Integer> itemIDS) {
 		int n = itemIDS.size();
-		ArrayList<Double> ret = new ArrayList<Double>(n);
+		ArrayList<Double> ret = new ArrayList<>(n);
 		for (int i = 0; i < n; ++i)
 			ret.add(predictRating(userID, itemIDS.get(i)));
 		return ret;
diff --git a/moa/src/main/java/moa/recommender/rc/predictor/impl/BaselinePredictor.java b/moa/src/main/java/moa/recommender/rc/predictor/impl/BaselinePredictor.java
index 6411ce6e9..6e6d1502b 100644
--- a/moa/src/main/java/moa/recommender/rc/predictor/impl/BaselinePredictor.java
+++ b/moa/src/main/java/moa/recommender/rc/predictor/impl/BaselinePredictor.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.recommender.rc.predictor.impl;
@@ -27,43 +27,42 @@
 import moa.recommender.rc.predictor.RatingPredictor;
 
 public class BaselinePredictor implements RatingPredictor {
-    /**
-     * 
-     */
-    private static final long serialVersionUID = 8444152568941483368L;
-    protected RecommenderData data;
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 8444152568941483368L;
+	protected RecommenderData data;
 
-    public BaselinePredictor(RecommenderData data) {
-        this.data = data;
-    }
+	public BaselinePredictor(RecommenderData data) {
+		this.data = data;
+	}
 
-    @Override
-    public double predictRating(int userID, int itemID) {
-        ArrayList<Integer> itm = new ArrayList<Integer>();
-        itm.add(itemID);
-        return predictRatings(userID, itm).get(0);
-    }
+	@Override
+	public double predictRating(int userID, int itemID) {
+		ArrayList<Integer> itm = new ArrayList<>();
+		itm.add(itemID);
+		return predictRatings(userID, itm).get(0);
+	}
 
-    @Override
-    public List<Double> predictRatings(int userID, List<Integer> itemIDS) {
-        ArrayList<Double> ret = new ArrayList<Double>(itemIDS.size());
-        double avg = data.getAvgRatingUser(userID) - data.getGlobalMean();
-        for (int i = 0; i < itemIDS.size(); ++i) {
-            int itemID = itemIDS.get(i);
-            double rat = avg + data.getAvgRatingItem(itemID);
-            rat = Math.min(Math.max(rat, data.getMinRating()),
-                    data.getMaxRating());
-            ret.add(rat);
-        }
-        return ret;
-    }
+	@Override
+	public List<Double> predictRatings(int userID, List<Integer> itemIDS) {
+		ArrayList<Double> ret = new ArrayList<>(itemIDS.size());
+		double avg = data.getAvgRatingUser(userID) - data.getGlobalMean();
+		for (int i = 0; i < itemIDS.size(); ++i) {
+			int itemID = itemIDS.get(i);
+			double rat = avg + data.getAvgRatingItem(itemID);
+			rat = Math.min(Math.max(rat, data.getMinRating()), data.getMaxRating());
+			ret.add(rat);
+		}
+		return ret;
+	}
 
-    @Override
-    public RecommenderData getData() {
-        return data;
-    }
+	@Override
+	public RecommenderData getData() {
+		return data;
+	}
 
-    @Override
-    public void train() {
-    }
+	@Override
+	public void train() {
+	}
 }
diff --git a/moa/src/main/java/moa/recommender/rc/utils/DenseVector.java b/moa/src/main/java/moa/recommender/rc/utils/DenseVector.java
index e1b0782f1..c276c344b 100644
--- a/moa/src/main/java/moa/recommender/rc/utils/DenseVector.java
+++ b/moa/src/main/java/moa/recommender/rc/utils/DenseVector.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.recommender.rc.utils;
@@ -26,79 +26,80 @@
 import java.util.Set;
 
 public class DenseVector extends Vector {
-    
-    /**
-	 * 
+
+	/**
+	 *
 	 */
 	private static final long serialVersionUID = -6077169543484777829L;
 	private ArrayList<Double> list;
-    
-    public DenseVector() {
-        list = new ArrayList<Double>();
-    }
-    
-    public DenseVector(ArrayList<Double> list) {
-        this.list = list;
-    }
-    
-    @Override
-    public int size() {
-        return list.size();
-    }
-
-    @Override
-    public void set(int index, double val) {
-        while (index < list.size())
-            list.add(0.0);
-        list.set(index, val);
-    }
-
-    @Override
-    public void remove(int index) {
-        list.remove(index);
-    }
-
-    @Override
-    public Double get(int index) {
-        if (index < 0 || index >= list.size()) return null;
-        return list.get(index);
-    }
-
-    @Override
-    public Set<Integer> getIdxs() {
-        HashSet<Integer> keys = new HashSet<Integer>();
-        for (int i = 0; i < list.size(); ++i)
-            keys.add(i);
-        return keys;
-    }
-
-    @Override
-    public Vector copy() {
-        return new DenseVector(new ArrayList<Double>(list));
-    }
-    
-    public class DenseVectorIterator implements Iterator<Pair<Integer, Double>> {
-        private int index = 0;
-        
-        @Override
-        public boolean hasNext() {
-            return index < DenseVector.this.list.size();
-        }
-
-        @Override
-        public Pair<Integer, Double> next() {
-            return new Pair<Integer, Double>(index, DenseVector.this.list.get(index++));
-        }
-
-        @Override
-        public void remove() {
-            list.remove(index);
-        }
-    }
-    
-    @Override
-    public Iterator<Pair<Integer, Double>> iterator() {
-        return new DenseVectorIterator();
-    }
-  
+
+	public DenseVector() {
+		list = new ArrayList<>();
+	}
+
+	public DenseVector(ArrayList<Double> list) {
+		this.list = list;
+	}
+
+	@Override
+	public int size() {
+		return list.size();
+	}
+
+	@Override
+	public void set(int index, double val) {
+		while (index < list.size())
+			list.add(0.0);
+		list.set(index, val);
+	}
+
+	@Override
+	public void remove(int index) {
+		list.remove(index);
+	}
+
+	@Override
+	public Double get(int index) {
+		if (index < 0 || index >= list.size())
+			return null;
+		return list.get(index);
+	}
+
+	@Override
+	public Set<Integer> getIdxs() {
+		HashSet<Integer> keys = new HashSet<>();
+		for (int i = 0; i < list.size(); ++i)
+			keys.add(i);
+		return keys;
+	}
+
+	@Override
+	public Vector copy() {
+		return new DenseVector(new ArrayList<>(list));
+	}
+
+	public class DenseVectorIterator implements Iterator<Pair<Integer, Double>> {
+		private int index = 0;
+
+		@Override
+		public boolean hasNext() {
+			return index < DenseVector.this.list.size();
+		}
+
+		@Override
+		public Pair<Integer, Double> next() {
+			return new Pair<>(index, DenseVector.this.list.get(index++));
+		}
+
+		@Override
+		public void remove() {
+			list.remove(index);
+		}
+	}
+
+	@Override
+	public Iterator<Pair<Integer, Double>> iterator() {
+		return new DenseVectorIterator();
+	}
+
 }
diff --git a/moa/src/main/java/moa/recommender/rc/utils/Hash.java b/moa/src/main/java/moa/recommender/rc/utils/Hash.java
index 9525f1412..c00de4f4d 100644
--- a/moa/src/main/java/moa/recommender/rc/utils/Hash.java
+++ b/moa/src/main/java/moa/recommender/rc/utils/Hash.java
@@ -14,20 +14,20 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.recommender.rc.utils;
 
 public class Hash {
-    public static int hashCode(int a) {
-       a = (a+0x7ed55d16) + (a<<12);
-       a = (a^0xc761c23c) ^ (a>>>19);
-       a = (a+0x165667b1) + (a<<5);
-       a = (a+0xd3a2646c) ^ (a<<9);
-       a = (a+0xfd7046c5) + (a<<3);
-       a = (a^0xb55a4f09) ^ (a>>>16);
-       return a;
-    }
+	public static int hashCode(int a) {
+		a = (a + 0x7ed55d16) + (a << 12);
+		a = (a ^ 0xc761c23c) ^ (a >>> 19);
+		a = (a + 0x165667b1) + (a << 5);
+		a = (a + 0xd3a2646c) ^ (a << 9);
+		a = (a + 0xfd7046c5) + (a << 3);
+		a = (a ^ 0xb55a4f09) ^ (a >>> 16);
+		return a;
+	}
 }
diff --git a/moa/src/main/java/moa/recommender/rc/utils/Pair.java b/moa/src/main/java/moa/recommender/rc/utils/Pair.java
index 9055ed56d..fe52e2a45 100644
--- a/moa/src/main/java/moa/recommender/rc/utils/Pair.java
+++ b/moa/src/main/java/moa/recommender/rc/utils/Pair.java
@@ -14,46 +14,48 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.recommender.rc.utils;
+
 import java.io.Serializable;
 
 public class Pair<T extends Comparable<T>, U extends Comparable<U>> implements Serializable, Comparable<Pair<T, U>> {
-    /**
-	 * 
+	/**
+	 *
 	 */
 	private static final long serialVersionUID = -1048781440947783998L;
 	private T first;
-    private U second;
-    
-    public Pair(T first, U second) {
-        this.first = first;
-        this.second = second;
-    }
-
-    public T getFirst() {
-        return first;
-    }
-    
-    public U getSecond() {
-        return second;
-    }
-    
-    public void setSecond(U second) {
-        this.second = second;
-    }
-    
-    public void setFirst(T first) {
-        this.first = first;
-    }
-    
-    @Override
-    public int compareTo(Pair<T, U> o) {
-        int cmp = second.compareTo(o.second);
-        if (cmp == 0) return first.compareTo(o.first);
-        return cmp;
-    }
+	private U second;
+
+	public Pair(T first, U second) {
+		this.first = first;
+		this.second = second;
+	}
+
+	public T getFirst() {
+		return first;
+	}
+
+	public U getSecond() {
+		return second;
+	}
+
+	public void setSecond(U second) {
+		this.second = second;
+	}
+
+	public void setFirst(T first) {
+		this.first = first;
+	}
+
+	@Override
+	public int compareTo(Pair<T, U> o) {
+		int cmp = second.compareTo(o.second);
+		if (cmp == 0)
+			return first.compareTo(o.first);
+		return cmp;
+	}
 }
diff --git a/moa/src/main/java/moa/recommender/rc/utils/Rating.java b/moa/src/main/java/moa/recommender/rc/utils/Rating.java
index 379e80c52..1bbf7a299 100644
--- a/moa/src/main/java/moa/recommender/rc/utils/Rating.java
+++ b/moa/src/main/java/moa/recommender/rc/utils/Rating.java
@@ -14,20 +14,20 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.recommender.rc.utils;
 
 public class Rating {
-    public int userID;
-    public int itemID;
-    public double rating;
-    
-    public Rating(int userID, int itemID, double rating) {
-        this.userID = userID;
-        this.itemID = itemID;
-        this.rating = rating;
-    }
+	public int userID;
+	public int itemID;
+	public double rating;
+
+	public Rating(int userID, int itemID, double rating) {
+		this.userID = userID;
+		this.itemID = itemID;
+		this.rating = rating;
+	}
 }
\ No newline at end of file
diff --git a/moa/src/main/java/moa/recommender/rc/utils/SparseVector.java b/moa/src/main/java/moa/recommender/rc/utils/SparseVector.java
index 43f60baee..cf700e26f 100644
--- a/moa/src/main/java/moa/recommender/rc/utils/SparseVector.java
+++ b/moa/src/main/java/moa/recommender/rc/utils/SparseVector.java
@@ -13,10 +13,10 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
- 
+
 package moa.recommender.rc.utils;
 
 import java.util.HashMap;
@@ -25,68 +25,75 @@
 import java.util.Set;
 
 public class SparseVector extends Vector {
-    /**
-     * 
-     */
-    private static final long serialVersionUID = 1971022389328939125L;
-    private Map<Integer, Double> map;
-    
-    public SparseVector() {
-        this.map = new HashMap<Integer, Double>();
-    }
-    
-    public SparseVector(Map<Integer, Double> map) {
-        if (map == null) this.map = new HashMap<Integer, Double>();
-        else this.map = map;
-    }
-    
-    public int size() {
-        return map.size();
-    }
-    
-    public void set(int index, double val) {
-        map.put(index, val);
-    }
-
-    public void remove(int index) {
-        map.remove(index);
-    }
-    
-    public Set<Integer> getIdxs() {
-        return map.keySet();
-    }
-    
-    public SparseVector copy() {
-        return new SparseVector(new HashMap<Integer, Double>(this.map));
-    }
-
-    @Override
-    public Double get(int index) {
-        return map.get(index);
-    }
-    
-    public class SparseVectorIterator implements Iterator<Pair<Integer, Double>> {
-        private Iterator<Integer> it = SparseVector.this.map.keySet().iterator();
-        
-        @Override
-        public boolean hasNext() {
-            return it.hasNext();
-        }
-
-        @Override
-        public Pair<Integer, Double> next() {
-            Integer idx = it.next();
-            return new Pair<Integer, Double>(idx, SparseVector.this.map.get(idx));
-        }
-
-        @Override
-        public void remove() {
-            it.remove();
-        }
-    }
-
-    @Override
-    public Iterator<Pair<Integer, Double>> iterator() {
-        return new SparseVectorIterator();
-    }
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 1971022389328939125L;
+	private Map<Integer, Double> map;
+
+	public SparseVector() {
+		this.map = new HashMap<>();
+	}
+
+	public SparseVector(Map<Integer, Double> map) {
+		if (map == null)
+			this.map = new HashMap<>();
+		else
+			this.map = map;
+	}
+
+	@Override
+	public int size() {
+		return map.size();
+	}
+
+	@Override
+	public void set(int index, double val) {
+		map.put(index, val);
+	}
+
+	@Override
+	public void remove(int index) {
+		map.remove(index);
+	}
+
+	@Override
+	public Set<Integer> getIdxs() {
+		return map.keySet();
+	}
+
+	@Override
+	public SparseVector copy() {
+		return new SparseVector(new HashMap<>(this.map));
+	}
+
+	@Override
+	public Double get(int index) {
+		return map.get(index);
+	}
+
+	public class SparseVectorIterator implements Iterator<Pair<Integer, Double>> {
+		private Iterator<Integer> it = SparseVector.this.map.keySet().iterator();
+
+		@Override
+		public boolean hasNext() {
+			return it.hasNext();
+		}
+
+		@Override
+		public Pair<Integer, Double> next() {
+			Integer idx = it.next();
+			return new Pair<>(idx, SparseVector.this.map.get(idx));
+		}
+
+		@Override
+		public void remove() {
+			it.remove();
+		}
+	}
+
+	@Override
+	public Iterator<Pair<Integer, Double>> iterator() {
+		return new SparseVectorIterator();
+	}
 }
diff --git a/moa/src/main/java/moa/recommender/rc/utils/Updatable.java b/moa/src/main/java/moa/recommender/rc/utils/Updatable.java
index 1c0ba877e..47d52910a 100644
--- a/moa/src/main/java/moa/recommender/rc/utils/Updatable.java
+++ b/moa/src/main/java/moa/recommender/rc/utils/Updatable.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.recommender.rc.utils;
@@ -23,10 +23,15 @@
 import java.util.List;
 
 public interface Updatable {
-    public void updateNewUser(int userID, List<Integer> ratedItems, List<Double> ratings);
-    public void updateNewItem(int itemID, List<Integer> ratingUsers, List<Double> ratings);
-    public void updateRemoveUser(int userID);
-    public void updateRemoveItem(int itemID);
-    public void updateSetRating(int userID, int itemID, double rating);
-    public void updateRemoveRating(int userID, int itemID);
+	void updateNewUser(int userID, List<Integer> ratedItems, List<Double> ratings);
+
+	void updateNewItem(int itemID, List<Integer> ratingUsers, List<Double> ratings);
+
+	void updateRemoveUser(int userID);
+
+	void updateRemoveItem(int itemID);
+
+	void updateSetRating(int userID, int itemID, double rating);
+
+	void updateRemoveRating(int userID, int itemID);
 }
diff --git a/moa/src/main/java/moa/recommender/rc/utils/Vector.java b/moa/src/main/java/moa/recommender/rc/utils/Vector.java
index 54e5d1d62..9a0d795fb 100644
--- a/moa/src/main/java/moa/recommender/rc/utils/Vector.java
+++ b/moa/src/main/java/moa/recommender/rc/utils/Vector.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.recommender.rc.utils;
@@ -25,40 +25,49 @@
 import java.util.Set;
 
 public abstract class Vector implements Serializable {
-    /**
-     * 
-     */
-    private static final long serialVersionUID = 2440314068879207731L;
-    abstract public int size();
-    abstract public void set(int index, double val);
-    abstract public void remove(int index);
-    abstract public Double get(int index);
-    abstract public Iterator<Pair<Integer, Double>> iterator();
-    abstract public Set<Integer> getIdxs();
-    
-    public double dotProduct(Vector vec) {
-        if (size() > vec.size()) return vec.dotProduct(this);
-        Iterator<Pair<Integer, Double>> it = iterator();
-        double ret = 0;
-        
-        while(it.hasNext()) {
-            Pair<Integer, Double> ind = it.next();
-            Double val1 = ind.getSecond();
-            Double val2 = vec.get(ind.getFirst());
-            if (val2 != null) ret += val1*val2;
-        }
-        
-        return ret;
-    }
-    
-    public double norm() {
-        Iterator<Pair<Integer, Double>> it = iterator();
-        double ret = 0;
-        
-        while(it.hasNext())
-            ret += Math.pow(it.next().getSecond(), 2);
-        
-        return Math.sqrt(ret);
-    }
-    abstract public Vector copy();
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 2440314068879207731L;
+
+	abstract public int size();
+
+	abstract public void set(int index, double val);
+
+	abstract public void remove(int index);
+
+	abstract public Double get(int index);
+
+	abstract public Iterator<Pair<Integer, Double>> iterator();
+
+	abstract public Set<Integer> getIdxs();
+
+	public double dotProduct(Vector vec) {
+		if (size() > vec.size())
+			return vec.dotProduct(this);
+		Iterator<Pair<Integer, Double>> it = iterator();
+		double ret = 0;
+
+		while (it.hasNext()) {
+			Pair<Integer, Double> ind = it.next();
+			Double val1 = ind.getSecond();
+			Double val2 = vec.get(ind.getFirst());
+			if (val2 != null)
+				ret += val1 * val2;
+		}
+
+		return ret;
+	}
+
+	public double norm() {
+		Iterator<Pair<Integer, Double>> it = iterator();
+		double ret = 0;
+
+		while (it.hasNext())
+			ret += Math.pow(it.next().getSecond(), 2);
+
+		return Math.sqrt(ret);
+	}
+
+	abstract public Vector copy();
 }
diff --git a/moa/src/main/java/moa/streams/ArffFileStream.java b/moa/src/main/java/moa/streams/ArffFileStream.java
index a2ce6273f..ab7a43381 100644
--- a/moa/src/main/java/moa/streams/ArffFileStream.java
+++ b/moa/src/main/java/moa/streams/ArffFileStream.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams;
 
@@ -48,17 +48,17 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class ArffFileStream extends AbstractOptionHandler implements InstanceStream, ConceptDriftGenerator, CapabilitiesHandler {
+public class ArffFileStream extends AbstractOptionHandler
+		implements InstanceStream, ConceptDriftGenerator, CapabilitiesHandler {
 
-    @Override
-    public String getPurposeString() {
-        return "A stream read from an ARFF file.";
-    }
+	@Override
+	public String getPurposeString() {
+		return "A stream read from an ARFF file.";
+	}
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public FileOption arffFileOption = new FileOption("arffFile", 'f',
-            "ARFF file to load.", null, "arff", false);
+	public FileOption arffFileOption = new FileOption("arffFile", 'f', "ARFF file to load.", null, "arff", false);
 
 //    public IntOption classIndexOption = new IntOption(
 //            "classIndex",
@@ -66,147 +66,140 @@ public String getPurposeString() {
 //            "Class index of data. 0 for none or -1 for last attribute in file.",
 //            -1, -1, Integer.MAX_VALUE);
 
-    public StringOption outputIndexesOption = new StringOption(
-    		"outputIndexes",
-            'c',
-    		"Indices of output (class) attributes. Can be provided in a comma or semicolon separated list of single values or ranges.",
-    		"-1");
-
-    public StringOption inputIndexesOption = new StringOption(
-    		"inputIndexes",
-    		'i',
-    		"Indices of input (class) attributes. Can be provided in a comma or semicolon separated list of single values or ranges. Leave blank for all non-output attributes.",
-    		"");
-
-    
-    protected InstancesHeader instances;
-
-    protected Reader fileReader;
-
-    protected boolean hitEndOfFile;
-
-    protected InstanceExample lastInstanceRead;
-
-    protected int numInstancesRead;
-
-    protected InputStreamProgressMonitor fileProgressMonitor;
-
-    public ArffFileStream() {
-    }
-
-    public ArffFileStream(String arffFileName, int classIndex) {
-        this.arffFileOption.setValue(arffFileName);
-        this.outputIndexesOption.setValue(Integer.toString(classIndex));
-        this.inputIndexesOption.setValue("");
-        restart();
-    }
-
-    
-    public ArffFileStream(String arffFileName, String outputIndexes) {
-        this.arffFileOption.setValue(arffFileName);
-        this.outputIndexesOption.setValue(outputIndexes);
-        restart();
-    }
-    
-    public ArffFileStream(String arffFileName, String outputIndexes, String inputIndexes) {
-        this.arffFileOption.setValue(arffFileName);
-        this.outputIndexesOption.setValue(outputIndexes);
-        this.inputIndexesOption.setValue(inputIndexes);
-        restart();
-    }
-
-    @Override
-    public void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        restart();
-    }
-
-    @Override
-    public InstancesHeader getHeader() {
-        return new InstancesHeader(this.instances);
-    }
-
-    @Override
-    public long estimatedRemainingInstances() {
-        double progressFraction = this.fileProgressMonitor.getProgressFraction();
-        if ((progressFraction > 0.0) && (this.numInstancesRead > 0)) {
-            return (long) ((this.numInstancesRead / progressFraction) - this.numInstancesRead);
-        }
-        return -1;
-    }
-
-    @Override
-    public boolean hasMoreInstances() {
-        return !this.hitEndOfFile;
-    }
-
-    @Override
-    public InstanceExample nextInstance() {
-        InstanceExample prevInstance = this.lastInstanceRead;
-        this.hitEndOfFile = !readNextInstanceFromFile();
-        return prevInstance;
-    }
-
-    @Override
-    public boolean isRestartable() {
-        return true;
-    }
-
-    @Override
-    public void restart() {
-        try {
-            if (this.fileReader != null) {
-                this.fileReader.close();
-            }
-            InputStream fileStream = new FileInputStream(this.arffFileOption.getFile());
-            this.fileProgressMonitor = new InputStreamProgressMonitor(
-                    fileStream);
-            this.fileReader = new BufferedReader(new InputStreamReader(this.fileProgressMonitor));
-            this.instances = new InstancesHeader(this.fileReader, this.outputIndexesOption.getValue(), this.inputIndexesOption.getValue());
-            this.numInstancesRead = 0;
-            this.lastInstanceRead = null;
-            this.hitEndOfFile = !readNextInstanceFromFile();
-        } catch (IOException ioe) {
-            throw new RuntimeException("ArffFileStream restart failed.", ioe);
-        }
-    }
-
-    protected boolean readNextInstanceFromFile() {
-        try {
-            if (this.instances.readInstance(this.fileReader)) {
-                this.lastInstanceRead = new InstanceExample(this.instances.instance(0));
-                this.instances.delete(); // keep instances clean
-                this.numInstancesRead++;
-                return true;
-            }
-            if (this.fileReader != null) {
-                this.fileReader.close();
-                this.fileReader = null;
-            }
-            return false;
-        } catch (IOException ioe) {
-            throw new RuntimeException(
-                    "ArffFileStream failed to read instance from stream.", ioe);
-        }
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    protected ArrayList<ClusterEvent> clusterEvents;
-
-    public ArrayList<ClusterEvent> getEventsList() {
-        //This is used only in the CD Tab
-        return this.clusterEvents;
-    }
-
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == ArffFileStream.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
+	public StringOption outputIndexesOption = new StringOption("outputIndexes", 'c',
+			"Indices of output (class) attributes. Can be provided in a comma or semicolon separated list of single values or ranges.",
+			"-1");
+
+	public StringOption inputIndexesOption = new StringOption("inputIndexes", 'i',
+			"Indices of input (class) attributes. Can be provided in a comma or semicolon separated list of single values or ranges. Leave blank for all non-output attributes.",
+			"");
+
+	protected InstancesHeader instances;
+
+	protected Reader fileReader;
+
+	protected boolean hitEndOfFile;
+
+	protected InstanceExample lastInstanceRead;
+
+	protected int numInstancesRead;
+
+	protected InputStreamProgressMonitor fileProgressMonitor;
+
+	public ArffFileStream() {
+	}
+
+	public ArffFileStream(String arffFileName, int classIndex) {
+		this.arffFileOption.setValue(arffFileName);
+		this.outputIndexesOption.setValue(Integer.toString(classIndex));
+		this.inputIndexesOption.setValue("");
+		restart();
+	}
+
+	public ArffFileStream(String arffFileName, String outputIndexes) {
+		this.arffFileOption.setValue(arffFileName);
+		this.outputIndexesOption.setValue(outputIndexes);
+		restart();
+	}
+
+	public ArffFileStream(String arffFileName, String outputIndexes, String inputIndexes) {
+		this.arffFileOption.setValue(arffFileName);
+		this.outputIndexesOption.setValue(outputIndexes);
+		this.inputIndexesOption.setValue(inputIndexes);
+		restart();
+	}
+
+	@Override
+	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		restart();
+	}
+
+	@Override
+	public InstancesHeader getHeader() {
+		return new InstancesHeader(this.instances);
+	}
+
+	@Override
+	public long estimatedRemainingInstances() {
+		double progressFraction = this.fileProgressMonitor.getProgressFraction();
+		if ((progressFraction > 0.0) && (this.numInstancesRead > 0)) {
+			return (long) ((this.numInstancesRead / progressFraction) - this.numInstancesRead);
+		}
+		return -1;
+	}
+
+	@Override
+	public boolean hasMoreInstances() {
+		return !this.hitEndOfFile;
+	}
+
+	@Override
+	public InstanceExample nextInstance() {
+		InstanceExample prevInstance = this.lastInstanceRead;
+		this.hitEndOfFile = !readNextInstanceFromFile();
+		return prevInstance;
+	}
+
+	@Override
+	public boolean isRestartable() {
+		return true;
+	}
+
+	@Override
+	public void restart() {
+		try {
+			if (this.fileReader != null) {
+				this.fileReader.close();
+			}
+			InputStream fileStream = new FileInputStream(this.arffFileOption.getFile());
+			this.fileProgressMonitor = new InputStreamProgressMonitor(fileStream);
+			this.fileReader = new BufferedReader(new InputStreamReader(this.fileProgressMonitor));
+			this.instances = new InstancesHeader(this.fileReader, this.outputIndexesOption.getValue(),
+					this.inputIndexesOption.getValue());
+			this.numInstancesRead = 0;
+			this.lastInstanceRead = null;
+			this.hitEndOfFile = !readNextInstanceFromFile();
+		} catch (IOException ioe) {
+			throw new RuntimeException("ArffFileStream restart failed.", ioe);
+		}
+	}
+
+	protected boolean readNextInstanceFromFile() {
+		try {
+			if (this.instances.readInstance(this.fileReader)) {
+				this.lastInstanceRead = new InstanceExample(this.instances.instance(0));
+				this.instances.delete(); // keep instances clean
+				this.numInstancesRead++;
+				return true;
+			}
+			if (this.fileReader != null) {
+				this.fileReader.close();
+				this.fileReader = null;
+			}
+			return false;
+		} catch (IOException ioe) {
+			throw new RuntimeException("ArffFileStream failed to read instance from stream.", ioe);
+		}
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	protected ArrayList<ClusterEvent> clusterEvents;
+
+	@Override
+	public ArrayList<ClusterEvent> getEventsList() {
+		// This is used only in the CD Tab
+		return this.clusterEvents;
+	}
+
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == ArffFileStream.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
 }
diff --git a/moa/src/main/java/moa/streams/BootstrappedStream.java b/moa/src/main/java/moa/streams/BootstrappedStream.java
index 4bced84b6..4a7a497f7 100644
--- a/moa/src/main/java/moa/streams/BootstrappedStream.java
+++ b/moa/src/main/java/moa/streams/BootstrappedStream.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.streams;
@@ -36,43 +36,41 @@
 
 /**
  * Bootstrapped Stream
- * 
- * @author  Joao Duarte
- * @version $Revision: 1$* 
- * 
- * Bootstraps a data stream using the poisson distribution
+ *
+ * @author Joao Duarte
+ * @version $Revision: 1$*
+ *
+ *          Bootstraps a data stream using the poisson distribution
  **/
 
-public class BootstrappedStream extends AbstractOptionHandler implements
-		InstanceStream, MultiTargetInstanceStream {
+public class BootstrappedStream extends AbstractOptionHandler implements InstanceStream, MultiTargetInstanceStream {
 
 	private static final long serialVersionUID = 1L;
 
-    public ClassOption streamOption = new ClassOption("stream", 's',
-            "Stream to filter.", MultiTargetInstanceStream.class,
-            MultiTargetArffFileStream.class.getName());
-    public IntOption randomSeedOption = new IntOption("randomSeed",'r',"Seed for the random generator",1);
-    
-    protected MultiTargetInstanceStream originalStream;
-    protected int waitingToSend;
-    protected Example<Instance> queuedInstance;
-    protected Random randomGenerator;
-    
+	public ClassOption streamOption = new ClassOption("stream", 's', "Stream to filter.",
+			MultiTargetInstanceStream.class, MultiTargetArffFileStream.class.getName());
+	public IntOption randomSeedOption = new IntOption("randomSeed", 'r', "Seed for the random generator", 1);
+
+	protected MultiTargetInstanceStream originalStream;
+	protected int waitingToSend;
+	protected Example<Instance> queuedInstance;
+	protected Random randomGenerator;
+
 	public BootstrappedStream() {
-		randomGenerator=new Random();
+		randomGenerator = new Random();
 	}
 
 	@Override
 	public InstancesHeader getHeader() {
-		InstancesHeader h=null;
-		if (originalStream!=null)
-			h=originalStream.getHeader();
+		InstancesHeader h = null;
+		if (originalStream != null)
+			h = originalStream.getHeader();
 		return h;
 	}
 
 	@Override
 	public long estimatedRemainingInstances() {
-		if (originalStream!=null)
+		if (originalStream != null)
 			return originalStream.estimatedRemainingInstances();
 		else
 			return 0;
@@ -80,26 +78,26 @@ public long estimatedRemainingInstances() {
 
 	@Override
 	public boolean hasMoreInstances() {
-		boolean flag=false;
-		if(originalStream!=null){
-			if(waitingToSend>0 || originalStream.hasMoreInstances()){
-				flag=true;
+		boolean flag = false;
+		if (originalStream != null) {
+			if (waitingToSend > 0 || originalStream.hasMoreInstances()) {
+				flag = true;
 			}
-		}		
+		}
 		return flag;
 	}
 
 	@Override
 	public Example<Instance> nextInstance() {
 
-		if(waitingToSend==0){
+		if (waitingToSend == 0) {
 			do {
-				queuedInstance=originalStream.nextInstance();
-				waitingToSend= MiscUtils.poisson(1.0, this.randomGenerator);;
-			} while (waitingToSend==0);
-			
+				queuedInstance = originalStream.nextInstance();
+				waitingToSend = MiscUtils.poisson(1.0, this.randomGenerator);
+			} while (waitingToSend == 0);
+
 		}
-		Example<Instance> instance=new InstanceExample(queuedInstance.getData().copy());
+		Example<Instance> instance = new InstanceExample(queuedInstance.getData().copy());
 		instance.setWeight(queuedInstance.weight());
 		waitingToSend--;
 		return instance;
@@ -112,10 +110,10 @@ public boolean isRestartable() {
 
 	@Override
 	public void restart() {
-		originalStream=((MultiTargetInstanceStream)getPreparedClassOption(streamOption));
-		waitingToSend=0;
+		originalStream = ((MultiTargetInstanceStream) getPreparedClassOption(streamOption));
+		waitingToSend = 0;
 		randomGenerator.setSeed(randomSeedOption.getValue());
-		queuedInstance=null;
+		queuedInstance = null;
 		originalStream.restart();
 	}
 
@@ -124,8 +122,7 @@ public void getDescription(StringBuilder sb, int indent) {
 	}
 
 	@Override
-	protected void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
 		restart();
 	}
 
diff --git a/moa/src/main/java/moa/streams/CachedInstancesStream.java b/moa/src/main/java/moa/streams/CachedInstancesStream.java
index ccc3bbcd6..1b30d6d38 100644
--- a/moa/src/main/java/moa/streams/CachedInstancesStream.java
+++ b/moa/src/main/java/moa/streams/CachedInstancesStream.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams;
 
@@ -25,15 +25,14 @@
 import moa.core.InstanceExample;
 
 /**
- * Stream generator for representing a stream that is cached in memory.
- * This generator is used with the task <code>CacheShuffledStream</code> that
- * stores and shuffles examples in memory.
+ * Stream generator for representing a stream that is cached in memory. This
+ * generator is used with the task <code>CacheShuffledStream</code> that stores
+ * and shuffles examples in memory.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class CachedInstancesStream extends AbstractMOAObject implements
-		MultiTargetInstanceStream {
+public class CachedInstancesStream extends AbstractMOAObject implements MultiTargetInstanceStream {
 
 	private static final long serialVersionUID = 1L;
 
@@ -45,37 +44,37 @@ public CachedInstancesStream(InstancesHeader toStream) {
 		this.toStream = toStream;
 	}
 
-    @Override
+	@Override
 	public InstancesHeader getHeader() {
 		return new InstancesHeader(this.toStream);
 	}
 
-    @Override
+	@Override
 	public long estimatedRemainingInstances() {
 		return this.toStream.numInstances() - this.streamPos;
 	}
 
-    @Override
+	@Override
 	public boolean hasMoreInstances() {
 		return this.streamPos < this.toStream.numInstances();
 	}
 
-    @Override
+	@Override
 	public InstanceExample nextInstance() {
 		return new InstanceExample(this.toStream.instance(this.streamPos++));
 	}
 
-    @Override
+	@Override
 	public boolean isRestartable() {
 		return true;
 	}
 
-    @Override
+	@Override
 	public void restart() {
 		this.streamPos = 0;
 	}
 
-    @Override
+	@Override
 	public void getDescription(StringBuilder sb, int indent) {
 		// TODO Auto-generated method stub
 
diff --git a/moa/src/main/java/moa/streams/ConceptDriftRealStream.java b/moa/src/main/java/moa/streams/ConceptDriftRealStream.java
index f304ff8bb..3e0568dba 100644
--- a/moa/src/main/java/moa/streams/ConceptDriftRealStream.java
+++ b/moa/src/main/java/moa/streams/ConceptDriftRealStream.java
@@ -15,39 +15,40 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams;
 
+import java.util.Random;
+
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.capabilities.CapabilitiesHandler;
 import moa.capabilities.Capability;
 import moa.capabilities.ImmutableCapabilities;
 import moa.core.FastVector;
-import com.yahoo.labs.samoa.instances.Instance;
-
-import java.util.Random;
 import moa.core.InstanceExample;
-
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.options.ClassOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
 
 /**
  * Stream generator that adds concept drift to examples in a stream with
- * different classes and attributes. Example: real datasets.
- *<br/><br/>
- * Example:
- *<br/><br/>
+ * different classes and attributes. Example: real datasets. <br/>
+ * <br/>
+ * Example: <br/>
+ * <br/>
  * <code>ConceptDriftRealStream -s (ArffFileStream -f covtype.arff) \ <br/>
  *    -d (ConceptDriftRealStream -s (ArffFileStream -f PokerOrig.arff) \<br/>
  *    -d (ArffFileStream -f elec.arff) -w 5000 -p 1000000 ) -w 5000 -p 581012</code>
- *<br/><br/>
+ * <br/>
+ * <br/>
  * s : Stream <br/>
  * d : Concept drift Stream<br/>
  * p : Central position of concept drift change<br/>
@@ -56,166 +57,157 @@
  * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
  * @version $Revision: 7 $
  */
-public class ConceptDriftRealStream extends AbstractOptionHandler implements
-        InstanceStream, CapabilitiesHandler {
-
-    @Override
-    public String getPurposeString() {
-        return "Adds Concept Drift to examples in a stream.";
-    }
+public class ConceptDriftRealStream extends AbstractOptionHandler implements InstanceStream, CapabilitiesHandler {
 
-    private static final long serialVersionUID = 1L;
+	@Override
+	public String getPurposeString() {
+		return "Adds Concept Drift to examples in a stream.";
+	}
 
-    public ClassOption streamOption = new ClassOption("stream", 's',
-            "Stream to add concept drift.", ExampleStream.class,
-            "generators.RandomTreeGenerator");
-
-    public ClassOption driftstreamOption = new ClassOption("driftstream", 'd',
-            "Concept drift Stream.", ExampleStream.class,
-            "generators.RandomTreeGenerator");
-
-    public FloatOption alphaOption = new FloatOption("alpha",
-            'a', "Angle alpha of change grade.", 0.0, 0.0, 90.0);
-
-    public IntOption positionOption = new IntOption("position",
-            'p', "Central position of concept drift change.", 0);
-
-    public IntOption widthOption = new IntOption("width",
-            'w', "Width of concept drift change.", 1000);
-
-    public IntOption randomSeedOption = new IntOption("randomSeed", 'r',
-            "Seed for random noise.", 1);
-
-    protected InstanceStream inputStream;
-
-    protected InstanceStream driftStream;
-
-    protected Random random;
-
-    protected int numberInstanceStream;
-
-    protected InstancesHeader streamHeader;
-
-    protected Instance inputInstance;
-
-    protected Instance driftInstance;
-
-    @Override
-    public void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-
-        this.inputStream = (InstanceStream) getPreparedClassOption(this.streamOption);
-        this.driftStream = (InstanceStream) getPreparedClassOption(this.driftstreamOption);
-        this.random = new Random(this.randomSeedOption.getValue());
-        numberInstanceStream = 0;
-        if (this.alphaOption.getValue() != 0.0) {
-            this.widthOption.setValue((int) (1 / Math.tan(this.alphaOption.getValue() * Math.PI / 180)));
-        }
-
-        // generate header
-        InstancesHeader first = this.inputStream.getHeader();
-        InstancesHeader second = this.driftStream.getHeader();
-        FastVector newAttributes = new FastVector();
-        for (int i = 0; i < first.numAttributes() - 1; i++) {
-            newAttributes.addElement(first.attribute(i));
-        }
-        for (int i = 0; i < second.numAttributes() - 1; i++) {
-            newAttributes.addElement(second.attribute(i));
-        }
-
-
-        Attribute classLabels;
-        if (first.numClasses() < second.numClasses()) {
-            classLabels = second.classAttribute();
-        } else {
-            classLabels = first.classAttribute();
-        }
-        newAttributes.addElement(classLabels);
-
-        this.streamHeader = new InstancesHeader(new InstancesHeader(
-                getCLICreationString(InstanceStream.class), newAttributes, 0));
-        this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
-        // TODO adapt for multi-target streaming
-        this.streamHeader.setInputIndexes();
-        restart();
-
-    }
-
-    @Override
-    public long estimatedRemainingInstances() {
-        return -1;
-    }
-
-    @Override
-    public boolean hasMoreInstances() {
-        return true;
-    }
-
-    @Override
-    public InstancesHeader getHeader() {
-        return this.streamHeader;
-    }
-
-    @Override
-    public boolean isRestartable() {
-        return (this.inputStream.isRestartable() && this.driftStream.isRestartable());
-    }
-
-    @Override
-    public InstanceExample nextInstance() {
-        numberInstanceStream++;
-        double numclass = 0.0;
-        double x = -4.0 * (double) (numberInstanceStream - this.positionOption.getValue()) / (double) this.widthOption.getValue();
-        double probabilityDrift = 1.0 / (1.0 + Math.exp(x));
-        if (this.random.nextDouble() > probabilityDrift) {
-            if (this.inputStream.hasMoreInstances() == false) {
-                this.inputStream.restart();
-            }
-            this.inputInstance = this.inputStream.nextInstance().getData();
-            numclass = this.inputInstance.classValue();
-        } else {
-            if (this.driftStream.hasMoreInstances() == false) {
-                this.driftStream.restart();
-            }
-            this.driftInstance = this.driftStream.nextInstance().getData();
-            numclass = this.driftInstance.classValue();
-        }
-        int m = 0;
-        double[] newVals = new double[this.inputInstance.numAttributes() + this.driftInstance.numAttributes() - 1];
-        for (int j = 0; j < this.inputInstance.numAttributes() - 1; j++, m++) {
-            newVals[m] = this.inputInstance.value(j);
-        }
-        for (int j = 0; j < this.driftInstance.numAttributes() - 1; j++, m++) {
-            newVals[m] = this.driftInstance.value(j);
-        }
-        newVals[m] = numclass;
-        //return new Instance(1.0, newVals);
-        Instance inst = new DenseInstance(1.0, newVals);
-        inst.setDataset(this.getHeader());
-        inst.setClassValue(numclass);
-        return new InstanceExample(inst);
-
-    }
-
-    @Override
-    public void restart() {
-        this.inputStream.restart();
-        this.driftStream.restart();
-        numberInstanceStream = 0;
-        this.inputInstance = this.inputStream.nextInstance().getData();
-        this.driftInstance = this.driftStream.nextInstance().getData();
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == ConceptDriftRealStream.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption streamOption = new ClassOption("stream", 's', "Stream to add concept drift.",
+			ExampleStream.class, "generators.RandomTreeGenerator");
+
+	public ClassOption driftstreamOption = new ClassOption("driftstream", 'd', "Concept drift Stream.",
+			ExampleStream.class, "generators.RandomTreeGenerator");
+
+	public FloatOption alphaOption = new FloatOption("alpha", 'a', "Angle alpha of change grade.", 0.0, 0.0, 90.0);
+
+	public IntOption positionOption = new IntOption("position", 'p', "Central position of concept drift change.", 0);
+
+	public IntOption widthOption = new IntOption("width", 'w', "Width of concept drift change.", 1000);
+
+	public IntOption randomSeedOption = new IntOption("randomSeed", 'r', "Seed for random noise.", 1);
+
+	protected InstanceStream inputStream;
+
+	protected InstanceStream driftStream;
+
+	protected Random random;
+
+	protected int numberInstanceStream;
+
+	protected InstancesHeader streamHeader;
+
+	protected Instance inputInstance;
+
+	protected Instance driftInstance;
+
+	@Override
+	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+
+		this.inputStream = (InstanceStream) getPreparedClassOption(this.streamOption);
+		this.driftStream = (InstanceStream) getPreparedClassOption(this.driftstreamOption);
+		this.random = new Random(this.randomSeedOption.getValue());
+		numberInstanceStream = 0;
+		if (this.alphaOption.getValue() != 0.0) {
+			this.widthOption.setValue((int) (1 / Math.tan(this.alphaOption.getValue() * Math.PI / 180)));
+		}
+
+		// generate header
+		InstancesHeader first = this.inputStream.getHeader();
+		InstancesHeader second = this.driftStream.getHeader();
+		FastVector newAttributes = new FastVector();
+		for (int i = 0; i < first.numAttributes() - 1; i++) {
+			newAttributes.addElement(first.attribute(i));
+		}
+		for (int i = 0; i < second.numAttributes() - 1; i++) {
+			newAttributes.addElement(second.attribute(i));
+		}
+
+		Attribute classLabels;
+		if (first.numClasses() < second.numClasses()) {
+			classLabels = second.classAttribute();
+		} else {
+			classLabels = first.classAttribute();
+		}
+		newAttributes.addElement(classLabels);
+
+		this.streamHeader = new InstancesHeader(
+				new InstancesHeader(getCLICreationString(InstanceStream.class), newAttributes, 0));
+		this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
+		// TODO adapt for multi-target streaming
+		this.streamHeader.setInputIndexes();
+		restart();
+
+	}
+
+	@Override
+	public long estimatedRemainingInstances() {
+		return -1;
+	}
+
+	@Override
+	public boolean hasMoreInstances() {
+		return true;
+	}
+
+	@Override
+	public InstancesHeader getHeader() {
+		return this.streamHeader;
+	}
+
+	@Override
+	public boolean isRestartable() {
+		return (this.inputStream.isRestartable() && this.driftStream.isRestartable());
+	}
+
+	@Override
+	public InstanceExample nextInstance() {
+		numberInstanceStream++;
+		double numclass = 0.0;
+		double x = -4.0 * (numberInstanceStream - this.positionOption.getValue()) / this.widthOption.getValue();
+		double probabilityDrift = 1.0 / (1.0 + Math.exp(x));
+		if (this.random.nextDouble() > probabilityDrift) {
+			if (this.inputStream.hasMoreInstances() == false) {
+				this.inputStream.restart();
+			}
+			this.inputInstance = this.inputStream.nextInstance().getData();
+			numclass = this.inputInstance.classValue();
+		} else {
+			if (this.driftStream.hasMoreInstances() == false) {
+				this.driftStream.restart();
+			}
+			this.driftInstance = this.driftStream.nextInstance().getData();
+			numclass = this.driftInstance.classValue();
+		}
+		int m = 0;
+		double[] newVals = new double[this.inputInstance.numAttributes() + this.driftInstance.numAttributes() - 1];
+		for (int j = 0; j < this.inputInstance.numAttributes() - 1; j++, m++) {
+			newVals[m] = this.inputInstance.value(j);
+		}
+		for (int j = 0; j < this.driftInstance.numAttributes() - 1; j++, m++) {
+			newVals[m] = this.driftInstance.value(j);
+		}
+		newVals[m] = numclass;
+		// return new Instance(1.0, newVals);
+		Instance inst = new DenseInstance(1.0, newVals);
+		inst.setDataset(this.getHeader());
+		inst.setClassValue(numclass);
+		return new InstanceExample(inst);
+
+	}
+
+	@Override
+	public void restart() {
+		this.inputStream.restart();
+		this.driftStream.restart();
+		numberInstanceStream = 0;
+		this.inputInstance = this.inputStream.nextInstance().getData();
+		this.driftInstance = this.driftStream.nextInstance().getData();
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == ConceptDriftRealStream.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
 }
diff --git a/moa/src/main/java/moa/streams/ConceptDriftStream.java b/moa/src/main/java/moa/streams/ConceptDriftStream.java
index 61d9eccff..3cae4af33 100644
--- a/moa/src/main/java/moa/streams/ConceptDriftStream.java
+++ b/moa/src/main/java/moa/streams/ConceptDriftStream.java
@@ -15,33 +15,33 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams;
 
 import java.util.Random;
 
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.capabilities.CapabilitiesHandler;
 import moa.capabilities.Capability;
 import moa.capabilities.ImmutableCapabilities;
 import moa.core.Example;
-
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
 import moa.options.ClassOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
 import moa.tasks.TaskMonitor;
 
 /**
- * Stream generator that adds concept drift to examples in a stream.
- *<br/><br/>
- * Example:
- *<br/><br/>
+ * Stream generator that adds concept drift to examples in a stream. <br/>
+ * <br/>
+ * Example: <br/>
+ * <br/>
  * <code>ConceptDriftStream -s (generators.AgrawalGenerator -f 7) <br/>
- *    -d (generators.AgrawalGenerator -f 2) -w 1000000 -p 900000</code>
- *<br/><br/>
+ *    -d (generators.AgrawalGenerator -f 2) -w 1000000 -p 900000</code> <br/>
+ * <br/>
  * s : Stream <br/>
  * d : Concept drift Stream<br/>
  * p : Central position of concept drift change<br/>
@@ -50,107 +50,99 @@
  * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
  * @version $Revision: 7 $
  */
-public class ConceptDriftStream extends AbstractOptionHandler implements
-        InstanceStream, CapabilitiesHandler {
-
-    @Override
-    public String getPurposeString() {
-        return "Adds Concept Drift to examples in a stream.";
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    public ClassOption streamOption = new ClassOption("stream", 's',
-            "Stream to add concept drift.", ExampleStream.class,
-            "generators.RandomTreeGenerator");
-
-    public ClassOption driftstreamOption = new ClassOption("driftstream", 'd',
-            "Concept drift Stream.", ExampleStream.class,
-            "generators.RandomTreeGenerator");
-
-    public FloatOption alphaOption = new FloatOption("alpha",
-            'a', "Angle alpha of change grade.", 0.0, 0.0, 90.0);
-
-    public IntOption positionOption = new IntOption("position",
-            'p', "Central position of concept drift change.", 0);
-
-    public IntOption widthOption = new IntOption("width",
-            'w', "Width of concept drift change.", 1000);
-
-    public IntOption randomSeedOption = new IntOption("randomSeed", 'r',
-            "Seed for random noise.", 1);
-
-    protected ExampleStream inputStream;
-
-    protected ExampleStream driftStream;
-
-    protected Random random;
-
-    protected int numberInstanceStream;
-
-    @Override
-    public void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-
-        this.inputStream = (ExampleStream) getPreparedClassOption(this.streamOption);
-        this.driftStream = (ExampleStream) getPreparedClassOption(this.driftstreamOption);
-        this.random = new Random(this.randomSeedOption.getValue());
-        numberInstanceStream = 0;
-        if (this.alphaOption.getValue() != 0.0) {
-            this.widthOption.setValue((int) (1 / Math.tan(this.alphaOption.getValue() * Math.PI / 180)));
-        }
-    }
-
-    @Override
-    public long estimatedRemainingInstances() {
-        return this.inputStream.estimatedRemainingInstances() + this.driftStream.estimatedRemainingInstances();
-    }
-
-    @Override
-    public InstancesHeader getHeader() {
-        return this.inputStream.getHeader();
-    }
-
-    @Override
-    public boolean hasMoreInstances() {
-        return (this.inputStream.hasMoreInstances() || this.driftStream.hasMoreInstances());
-    }
-
-    @Override
-    public boolean isRestartable() {
-        return (this.inputStream.isRestartable() && this.driftStream.isRestartable());
-    }
-
-    @Override
-    public Example nextInstance() {
-        numberInstanceStream++;
-        double x = -4.0 * (double) (numberInstanceStream - this.positionOption.getValue()) / (double) this.widthOption.getValue();
-        double probabilityDrift = 1.0 / (1.0 + Math.exp(x));
-        if (this.random.nextDouble() > probabilityDrift) {
-            return this.inputStream.nextInstance();
-        } else {
-            return this.driftStream.nextInstance();
-        }
-
-    }
-
-    @Override
-    public void restart() {
-        this.inputStream.restart();
-        this.driftStream.restart();
-        numberInstanceStream = 0;
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == ConceptDriftStream.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
+public class ConceptDriftStream extends AbstractOptionHandler implements InstanceStream, CapabilitiesHandler {
+
+	@Override
+	public String getPurposeString() {
+		return "Adds Concept Drift to examples in a stream.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption streamOption = new ClassOption("stream", 's', "Stream to add concept drift.",
+			ExampleStream.class, "generators.RandomTreeGenerator");
+
+	public ClassOption driftstreamOption = new ClassOption("driftstream", 'd', "Concept drift Stream.",
+			ExampleStream.class, "generators.RandomTreeGenerator");
+
+	public FloatOption alphaOption = new FloatOption("alpha", 'a', "Angle alpha of change grade.", 0.0, 0.0, 90.0);
+
+	public IntOption positionOption = new IntOption("position", 'p', "Central position of concept drift change.", 0);
+
+	public IntOption widthOption = new IntOption("width", 'w', "Width of concept drift change.", 1000);
+
+	public IntOption randomSeedOption = new IntOption("randomSeed", 'r', "Seed for random noise.", 1);
+
+	protected ExampleStream inputStream;
+
+	protected ExampleStream driftStream;
+
+	protected Random random;
+
+	protected int numberInstanceStream;
+
+	@Override
+	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+
+		this.inputStream = (ExampleStream) getPreparedClassOption(this.streamOption);
+		this.driftStream = (ExampleStream) getPreparedClassOption(this.driftstreamOption);
+		this.random = new Random(this.randomSeedOption.getValue());
+		numberInstanceStream = 0;
+		if (this.alphaOption.getValue() != 0.0) {
+			this.widthOption.setValue((int) (1 / Math.tan(this.alphaOption.getValue() * Math.PI / 180)));
+		}
+	}
+
+	@Override
+	public long estimatedRemainingInstances() {
+		return this.inputStream.estimatedRemainingInstances() + this.driftStream.estimatedRemainingInstances();
+	}
+
+	@Override
+	public InstancesHeader getHeader() {
+		return this.inputStream.getHeader();
+	}
+
+	@Override
+	public boolean hasMoreInstances() {
+		return (this.inputStream.hasMoreInstances() || this.driftStream.hasMoreInstances());
+	}
+
+	@Override
+	public boolean isRestartable() {
+		return (this.inputStream.isRestartable() && this.driftStream.isRestartable());
+	}
+
+	@Override
+	public Example nextInstance() {
+		numberInstanceStream++;
+		double x = -4.0 * (numberInstanceStream - this.positionOption.getValue()) / this.widthOption.getValue();
+		double probabilityDrift = 1.0 / (1.0 + Math.exp(x));
+		if (this.random.nextDouble() > probabilityDrift) {
+			return this.inputStream.nextInstance();
+		} else {
+			return this.driftStream.nextInstance();
+		}
+
+	}
+
+	@Override
+	public void restart() {
+		this.inputStream.restart();
+		this.driftStream.restart();
+		numberInstanceStream = 0;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == ConceptDriftStream.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
 }
diff --git a/moa/src/main/java/moa/streams/ExampleStream.java b/moa/src/main/java/moa/streams/ExampleStream.java
index 99aa93dba..6b6526565 100644
--- a/moa/src/main/java/moa/streams/ExampleStream.java
+++ b/moa/src/main/java/moa/streams/ExampleStream.java
@@ -28,61 +28,60 @@
 import moa.core.Example;
 
 /**
- * Interface representing a data stream of examples. 
+ * Interface representing a data stream of examples.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $ 
+ * @version $Revision: 7 $
  */
-public interface ExampleStream<E extends Example> extends MOAObject,
-                                                          CapabilitiesHandler {
+public interface ExampleStream<E extends Example> extends MOAObject, CapabilitiesHandler {
 
-    /**
-     * Gets the header of this stream.
-     * This is useful to know attributes and classes.
-     * InstancesHeader is an extension of weka.Instances.
-     *
-     * @return the header of this stream
-     */
-    public InstancesHeader getHeader();
+	/**
+	 * Gets the header of this stream. This is useful to know attributes and
+	 * classes. InstancesHeader is an extension of weka.Instances.
+	 *
+	 * @return the header of this stream
+	 */
+	InstancesHeader getHeader();
 
-    /**
-     * Gets the estimated number of remaining instances in this stream
-     *
-     * @return the estimated number of instances to get from this stream
-     */
-    public long estimatedRemainingInstances();
+	/**
+	 * Gets the estimated number of remaining instances in this stream
+	 *
+	 * @return the estimated number of instances to get from this stream
+	 */
+	long estimatedRemainingInstances();
 
-    /**
-     * Gets whether this stream has more instances to output.
-     * This is useful when reading streams from files.
-     *
-     * @return true if this stream has more instances to output
-     */
-    public boolean hasMoreInstances();
+	/**
+	 * Gets whether this stream has more instances to output. This is useful when
+	 * reading streams from files.
+	 *
+	 * @return true if this stream has more instances to output
+	 */
+	boolean hasMoreInstances();
 
-    /**
-     * Gets the next example from this stream.
-     *
-     * @return the next example of this stream
-     */
-    public E nextInstance();
+	/**
+	 * Gets the next example from this stream.
+	 *
+	 * @return the next example of this stream
+	 */
+	E nextInstance();
 
-    /**
-     * Gets whether this stream can restart.
-     *
-     * @return true if this stream can restart
-     */
-    public boolean isRestartable();
+	/**
+	 * Gets whether this stream can restart.
+	 *
+	 * @return true if this stream can restart
+	 */
+	boolean isRestartable();
 
-    /**
-     * Restarts this stream. It must be similar to
-     * starting a new stream from scratch.
-     *
-     */
-    public void restart();
+	/**
+	 * Restarts this stream. It must be similar to starting a new stream from
+	 * scratch.
+	 *
+	 */
+	void restart();
 
-    default ImmutableCapabilities defineImmutableCapabilities() {
-        // We are restricting streams based on view mode
-        return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
+	@Override
+	default ImmutableCapabilities defineImmutableCapabilities() {
+		// We are restricting streams based on view mode
+		return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
 }
diff --git a/moa/src/main/java/moa/streams/FilteredStream.java b/moa/src/main/java/moa/streams/FilteredStream.java
index 6cf072f88..f34098fbe 100644
--- a/moa/src/main/java/moa/streams/FilteredStream.java
+++ b/moa/src/main/java/moa/streams/FilteredStream.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams;
 
@@ -35,82 +35,78 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class FilteredStream extends AbstractOptionHandler implements
-        ExampleStream {
-
-    @Override
-    public String getPurposeString() {
-        return "A stream that is filtered.";
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    public ClassOption streamOption = new ClassOption("stream", 's',
-            "Stream to filter.", ExampleStream.class,
-            "generators.RandomTreeGenerator");
-
-    public ClassOption filtersOption = new ClassOption("filters", 'f',
-            "Filters to apply.", StreamFilter.class, 
-            "AddNoiseFilter");
-
-    protected ExampleStream filterChain;
-
-    @Override
-    public void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        StreamFilter filters; 
-            monitor.setCurrentActivity("Materializing filter " //+ (i + 1)
-                    + "...", -1.0);
-            filters = (StreamFilter) getPreparedClassOption(this.filtersOption);
-            if (monitor.taskShouldAbort()) {
-                return;
-            }
-            if (filters instanceof OptionHandler) {
-                monitor.setCurrentActivity("Preparing filter " //+ (i + 1)
-                        + "...", -1.0);
-                ((OptionHandler) filters).prepareForUse(monitor, repository);
-                if (monitor.taskShouldAbort()) {
-                    return;
-                }
-            }
-        ExampleStream chain = (ExampleStream) getPreparedClassOption(this.streamOption);
-            filters.setInputStream(chain);
-            chain = filters;
-        this.filterChain = chain;
-    }
-
-    @Override
-    public long estimatedRemainingInstances() {
-        return this.filterChain.estimatedRemainingInstances();
-    }
-
-    @Override
-    public InstancesHeader getHeader() {
-        return this.filterChain.getHeader();
-    }
-
-    @Override
-    public boolean hasMoreInstances() {
-        return this.filterChain.hasMoreInstances();
-    }
-
-    @Override
-    public boolean isRestartable() {
-        return this.filterChain.isRestartable();
-    }
-
-    @Override
-    public Example nextInstance() {
-        return this.filterChain.nextInstance();
-    }
-
-    @Override
-    public void restart() {
-        this.filterChain.restart();
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
+public class FilteredStream extends AbstractOptionHandler implements ExampleStream {
+
+	@Override
+	public String getPurposeString() {
+		return "A stream that is filtered.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption streamOption = new ClassOption("stream", 's', "Stream to filter.", ExampleStream.class,
+			"generators.RandomTreeGenerator");
+
+	public ClassOption filtersOption = new ClassOption("filters", 'f', "Filters to apply.", StreamFilter.class,
+			"AddNoiseFilter");
+
+	protected ExampleStream filterChain;
+
+	@Override
+	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		StreamFilter filters;
+		monitor.setCurrentActivity("Materializing filter " // + (i + 1)
+				+ "...", -1.0);
+		filters = (StreamFilter) getPreparedClassOption(this.filtersOption);
+		if (monitor.taskShouldAbort()) {
+			return;
+		}
+		if (filters instanceof OptionHandler) {
+			monitor.setCurrentActivity("Preparing filter " // + (i + 1)
+					+ "...", -1.0);
+			((OptionHandler) filters).prepareForUse(monitor, repository);
+			if (monitor.taskShouldAbort()) {
+				return;
+			}
+		}
+		ExampleStream chain = (ExampleStream) getPreparedClassOption(this.streamOption);
+		filters.setInputStream(chain);
+		chain = filters;
+		this.filterChain = chain;
+	}
+
+	@Override
+	public long estimatedRemainingInstances() {
+		return this.filterChain.estimatedRemainingInstances();
+	}
+
+	@Override
+	public InstancesHeader getHeader() {
+		return this.filterChain.getHeader();
+	}
+
+	@Override
+	public boolean hasMoreInstances() {
+		return this.filterChain.hasMoreInstances();
+	}
+
+	@Override
+	public boolean isRestartable() {
+		return this.filterChain.isRestartable();
+	}
+
+	@Override
+	public Example nextInstance() {
+		return this.filterChain.nextInstance();
+	}
+
+	@Override
+	public void restart() {
+		this.filterChain.restart();
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
 }
diff --git a/moa/src/main/java/moa/streams/ImbalancedStream.java b/moa/src/main/java/moa/streams/ImbalancedStream.java
index 3e21a4dd0..75231e280 100644
--- a/moa/src/main/java/moa/streams/ImbalancedStream.java
+++ b/moa/src/main/java/moa/streams/ImbalancedStream.java
@@ -32,145 +32,142 @@
 import moa.options.ClassOption;
 import moa.tasks.TaskMonitor;
 
-
 /**
  * Imbalanced Stream.
  *
- * This is a meta-generator that produces class imbalance in a stream.
- * Only two parameters are required to be set:
- * - The original stream
- * - The ratio (proportion) of each class in the stream.
+ * This is a meta-generator that produces class imbalance in a stream. Only two
+ * parameters are required to be set: - The original stream - The ratio
+ * (proportion) of each class in the stream.
  *
  * The second parameter determines the ratio of each class in the output stream.
- * The ratio of each class should be provided as a real number between 0.0 and 1.0,
- * each being followed by a semicolon, and their sum should add up to 1.0.
- * The default value of 0.9;0.1 stands for an output stream where approximately 90%
- * of the instances belonging to the first class while the remainder 10% would
- * belong to the secondary class.
+ * The ratio of each class should be provided as a real number between 0.0 and
+ * 1.0, each being followed by a semicolon, and their sum should add up to 1.0.
+ * The default value of 0.9;0.1 stands for an output stream where approximately
+ * 90% of the instances belonging to the first class while the remainder 10%
+ * would belong to the secondary class.
  *
  * @author Jean Paul Barddal (jean.barddal@ppgia.pucpr.br)
  * @version 1.0
  */
 
-public class ImbalancedStream extends AbstractOptionHandler implements
-        InstanceStream {
-
-
-    public ClassOption streamOption = new ClassOption("stream", 's',
-            "Stream to imbalance.", ExampleStream.class,
-            "generators.RandomTreeGenerator");
-
-    public StringOption classRatioOption = new StringOption("classRatio", 'c',
-            "Determine the ratio of each class in the output stream. " +
-                    "The ratio of each class should be given as a real number " +
-                    "between 0 and 1, each followed by a semicolon, and their sum should be equal to 1. " +
-                    "The default value of \"0.9;0.1\" stands for an output stream with approximately 90% " +
-                    "of the instances belonging to the first class and 10% to the second class.",
-            "0.9;0.1");
-
-    public IntOption instanceRandomSeedOption = new IntOption(
-            "instanceRandomSeed", 'i',
-            "Seed for random generation of instances.", 1);
-
-    protected ExampleStream originalStream    = null;
-    protected InstancesHeader     instancesBuffer[] = null;
-    protected double        probPerClass[]    = null;
-    protected Random        random            = null;
-    protected int           numClasses        = 0;
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-        originalStream = (ExampleStream) getPreparedClassOption(streamOption);
-        numClasses = originalStream.getHeader().numClasses();
-        probPerClass = new double[numClasses];
-        instancesBuffer = new InstancesHeader[numClasses];
-        probPerClass = new double[numClasses];
-
-
-        // checks and sets the probabilities
-        double sumProbs = 0.0;
-        String probs[] = classRatioOption.getValue().split(";");
-        for(int i = 0; i < probs.length; i++){
-            if(i > probPerClass.length - 1) throw new IllegalArgumentException("Please make sure the number of class " +
-                    "ratios provided is less or equal the number of classes in the original stream.");
-            Double p = Double.parseDouble(probs[i]);
-            if(!p.isNaN() && ! p.isInfinite() && p.doubleValue() >= 0.0 && p.doubleValue() <= 1.0){
-                // aka is a valid number between 0.0 and 1.0
-                probPerClass[i]  = p;
-                sumProbs        += p;
-            }else{
-                throw new IllegalArgumentException("Please make sure only numbers between 0.0 and 1.0 are inputted.");
-            }
-        }
-
-        // checks if the values sum to 1.0
-        if(sumProbs != 1.0) throw new IllegalArgumentException("Please make sure the class ratios sum up to 1.0.");
-
-
-        // initializes the buffers using the original header
-        for(int i = 0; i < instancesBuffer.length; i++){
-            instancesBuffer[i] = new InstancesHeader(originalStream.getHeader());
-        }
-        // initializes the random generator
-        random = new Random(instanceRandomSeedOption.getValue());
-    }
-
-    @Override
-    public InstancesHeader getHeader() {
-        return originalStream.getHeader();
-    }
-
-    @Override
-    public long estimatedRemainingInstances() {
-        return originalStream.estimatedRemainingInstances();
-    }
-
-    @Override
-    public boolean hasMoreInstances() {
-        return originalStream.hasMoreInstances();
-    }
-
-    @Override
-    public Example<Instance> nextInstance() {
-        // a value between 0.0 and 1.0 uniformly distributed
-        double p   = random.nextDouble();
-        int iClass = -1;
-        // loops over all class probabilities to see from which class the next instance should be from
-        while(p > 0.0){
-            iClass++;
-            p -= probPerClass[iClass];
-        }
-
-        // keeps on creating and storing instances until we have an instance for the desired class
-        while(instancesBuffer[iClass].size() == 0){
-            Example<Instance> inst = originalStream.nextInstance();
-            instancesBuffer[(int) inst.getData().classValue()].add(inst.getData());
-        }
-
-        // retrieves the instance from the desired class
-        Instance instance = instancesBuffer[iClass].get(0);
-        // and also removes it from the buffer
-        instancesBuffer[iClass].delete(0);
-
-        return new InstanceExample(instance);
-    }
-
-    @Override
-    public boolean isRestartable() {
-        return originalStream.isRestartable();
-    }
-
-    @Override
-    public void restart() {
-        this.random = new Random(instanceRandomSeedOption.getValue());
-        this.originalStream.restart();
-        // initializes the buffers using the original header
-        for(int i = 0; i < instancesBuffer.length; i++){
-            instancesBuffer[i] = new InstancesHeader(originalStream.getHeader());
-        }
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {}
+public class ImbalancedStream extends AbstractOptionHandler implements InstanceStream {
+
+	public ClassOption streamOption = new ClassOption("stream", 's', "Stream to imbalance.", ExampleStream.class,
+			"generators.RandomTreeGenerator");
+
+	public StringOption classRatioOption = new StringOption("classRatio", 'c',
+			"Determine the ratio of each class in the output stream. "
+					+ "The ratio of each class should be given as a real number "
+					+ "between 0 and 1, each followed by a semicolon, and their sum should be equal to 1. "
+					+ "The default value of \"0.9;0.1\" stands for an output stream with approximately 90% "
+					+ "of the instances belonging to the first class and 10% to the second class.",
+			"0.9;0.1");
+
+	public IntOption instanceRandomSeedOption = new IntOption("instanceRandomSeed", 'i',
+			"Seed for random generation of instances.", 1);
+
+	protected ExampleStream originalStream = null;
+	protected InstancesHeader instancesBuffer[] = null;
+	protected double probPerClass[] = null;
+	protected Random random = null;
+	protected int numClasses = 0;
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		originalStream = (ExampleStream) getPreparedClassOption(streamOption);
+		numClasses = originalStream.getHeader().numClasses();
+		probPerClass = new double[numClasses];
+		instancesBuffer = new InstancesHeader[numClasses];
+		probPerClass = new double[numClasses];
+
+		// checks and sets the probabilities
+		double sumProbs = 0.0;
+		String probs[] = classRatioOption.getValue().split(";");
+		for (int i = 0; i < probs.length; i++) {
+			if (i > probPerClass.length - 1)
+				throw new IllegalArgumentException("Please make sure the number of class "
+						+ "ratios provided is less or equal the number of classes in the original stream.");
+			Double p = Double.parseDouble(probs[i]);
+			if (!p.isNaN() && !p.isInfinite() && p.doubleValue() >= 0.0 && p.doubleValue() <= 1.0) {
+				// aka is a valid number between 0.0 and 1.0
+				probPerClass[i] = p;
+				sumProbs += p;
+			} else {
+				throw new IllegalArgumentException("Please make sure only numbers between 0.0 and 1.0 are inputted.");
+			}
+		}
+
+		// checks if the values sum to 1.0
+		if (sumProbs != 1.0)
+			throw new IllegalArgumentException("Please make sure the class ratios sum up to 1.0.");
+
+		// initializes the buffers using the original header
+		for (int i = 0; i < instancesBuffer.length; i++) {
+			instancesBuffer[i] = new InstancesHeader(originalStream.getHeader());
+		}
+		// initializes the random generator
+		random = new Random(instanceRandomSeedOption.getValue());
+	}
+
+	@Override
+	public InstancesHeader getHeader() {
+		return originalStream.getHeader();
+	}
+
+	@Override
+	public long estimatedRemainingInstances() {
+		return originalStream.estimatedRemainingInstances();
+	}
+
+	@Override
+	public boolean hasMoreInstances() {
+		return originalStream.hasMoreInstances();
+	}
+
+	@Override
+	public Example<Instance> nextInstance() {
+		// a value between 0.0 and 1.0 uniformly distributed
+		double p = random.nextDouble();
+		int iClass = -1;
+		// loops over all class probabilities to see from which class the next instance
+		// should be from
+		while (p > 0.0) {
+			iClass++;
+			p -= probPerClass[iClass];
+		}
+
+		// keeps on creating and storing instances until we have an instance for the
+		// desired class
+		while (instancesBuffer[iClass].size() == 0) {
+			Example<Instance> inst = originalStream.nextInstance();
+			instancesBuffer[(int) inst.getData().classValue()].add(inst.getData());
+		}
+
+		// retrieves the instance from the desired class
+		Instance instance = instancesBuffer[iClass].get(0);
+		// and also removes it from the buffer
+		instancesBuffer[iClass].delete(0);
+
+		return new InstanceExample(instance);
+	}
+
+	@Override
+	public boolean isRestartable() {
+		return originalStream.isRestartable();
+	}
+
+	@Override
+	public void restart() {
+		this.random = new Random(instanceRandomSeedOption.getValue());
+		this.originalStream.restart();
+		// initializes the buffers using the original header
+		for (int i = 0; i < instancesBuffer.length; i++) {
+			instancesBuffer[i] = new InstancesHeader(originalStream.getHeader());
+		}
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+	}
 
 }
\ No newline at end of file
diff --git a/moa/src/main/java/moa/streams/InstanceStream.java b/moa/src/main/java/moa/streams/InstanceStream.java
index 8f90abe27..1107e4330 100644
--- a/moa/src/main/java/moa/streams/InstanceStream.java
+++ b/moa/src/main/java/moa/streams/InstanceStream.java
@@ -15,19 +15,19 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams;
 
-import moa.core.Example;
 import com.yahoo.labs.samoa.instances.Instance;
 
+import moa.core.Example;
 
 /**
- * Interface representing a data stream of instances. 
+ * Interface representing a data stream of instances.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $ 
+ * @version $Revision: 7 $
  */
 public interface InstanceStream extends ExampleStream<Example<Instance>> {
 
diff --git a/moa/src/main/java/moa/streams/IrrelevantFeatureAppenderStream.java b/moa/src/main/java/moa/streams/IrrelevantFeatureAppenderStream.java
index 9aea04a0e..3bd997358 100644
--- a/moa/src/main/java/moa/streams/IrrelevantFeatureAppenderStream.java
+++ b/moa/src/main/java/moa/streams/IrrelevantFeatureAppenderStream.java
@@ -34,171 +34,170 @@
 import moa.options.ClassOption;
 import moa.tasks.TaskMonitor;
 
-
 /**
  * IrrelevantFeatureAppender Stream.
  *
- * This is a meta-generator that appends irrelevant features in a stream.
- * The following parameters are required to be set:
- * - The original stream,
- * - The number of numeric features to be appended,
- * - The number of categorical features to be appended, and
- * - The number of values for each categorical feature.
+ * This is a meta-generator that appends irrelevant features in a stream. The
+ * following parameters are required to be set: - The original stream, - The
+ * number of numeric features to be appended, - The number of categorical
+ * features to be appended, and - The number of values for each categorical
+ * feature.
  *
- * The values for each new feature are drawn from an uniform distribution
- * and are not related with the class anyhow. This means that no
- * correlation between each feature and the class will be observed,
- * and the entropy will be maximum.
+ * The values for each new feature are drawn from an uniform distribution and
+ * are not related with the class anyhow. This means that no correlation between
+ * each feature and the class will be observed, and the entropy will be maximum.
  *
  * @author Jean Paul Barddal (jean.barddal@ppgia.pucpr.br)
  * @version 1.0
  */
 public class IrrelevantFeatureAppenderStream extends AbstractOptionHandler implements InstanceStream {
 
-    public ClassOption streamOption                    = new ClassOption("stream", 's',
-            "Stream to imbalance.", ExampleStream.class,
-            "generators.RandomTreeGenerator");
-
-    public IntOption numNumericFeaturesOption          = new IntOption("numNumericFeatures", 'n',
-            "Number of numeric features to be appended.", 0, 0, 1000);
-
-    public IntOption numCategoricalFeaturesOption      = new IntOption("numCategoricalFeatures", 'c',
-            "Number of categorical features to be appended.", 0, 0, 1000);
-
-    public IntOption numValuesCategoricalFeatureOption = new IntOption("numValuesCategoricalFeature", 'v',
-            "Number of values for each categorical feature.", 2, 1, 1000);
-
-    public IntOption instanceRandomSeedOption          = new IntOption("instanceRandomSeed", 'i',
-            "Seed for random generation of instances.", 1);
-
-    /**
-     * The original stream.
-     */
-    protected ExampleStream originalStream = null;
-
-    /**
-     * The header with the new features appended.
-     */
-    protected InstancesHeader newHeader = null;
-
-    /**
-     * A pseudo-random number generator.
-     */
-    protected Random random = null;
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-        this.originalStream = (ExampleStream) getPreparedClassOption(streamOption);
-        this.random = new Random(instanceRandomSeedOption.getValue());
-        buildHeader();
-    }
-
-    @Override
-    public InstancesHeader getHeader() {
-        return newHeader;
-    }
-
-    @Override
-    public long estimatedRemainingInstances() {
-        return originalStream.estimatedRemainingInstances();
-    }
-
-    @Override
-    public boolean hasMoreInstances() {
-        return originalStream.hasMoreInstances();
-    }
-
-    @Override
-    public Example<Instance> nextInstance() {
-        Example<Instance> original = originalStream.nextInstance();
-
-        // copies the original values
-        double values[] = new double[this.newHeader.numAttributes()];
-        int ix = 0;
-        for(int i = 0; i < original.getData().dataset().numAttributes(); i++){
-            if(original.getData().dataset().classIndex() != i) {
-                values[ix] = original.getData().value(i);
-                ix++;
-            }
-        }
-
-        // appends the new values
-        while(ix < values.length - 1){
-            Attribute att = this.newHeader.attribute(ix);
-            if(att.isNumeric()) values[ix] = this.random.nextDouble();
-            else values[ix] = this.random.nextInt(numValuesCategoricalFeatureOption.getValue());
-            ix++;
-        }
-
-        //copies the class value
-        if(original.getData().classIndex() != -1) {
-            values[values.length - 1] = original.getData().classValue();
-        }
-
-        // instantiates and returns the actual instance
-        Instance instnc = new DenseInstance(1.0, values);
-        instnc.setDataset(this.newHeader);
-
-        return new InstanceExample(instnc);
-    }
-
-    @Override
-    public boolean isRestartable() {
-        return originalStream.isRestartable();
-    }
-
-    @Override
-    public void restart() {
-        originalStream.restart();
-        this.random = new Random(instanceRandomSeedOption.getValue());
-        this.buildHeader();
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {}
-
-    /**
-     * Constructs the new header according to:
-     * 1- The original header
-     * 2- The number of numeric and categorical features given by the user.
-     */
-    private void buildHeader(){
-        ArrayList<Attribute> attributes = new ArrayList<>();
-
-        // copies the original attributes
-        InstancesHeader originalHeader = originalStream.getHeader();
-        for(int i = 0; i < originalHeader.numAttributes(); i++){
-            Attribute att = originalHeader.attribute(i);
-            if(att != originalHeader.classAttribute()) {
-                attributes.add(att);
-            }
-        }
-
-        // appends the new numeric features
-        for(int i = 0; i < numNumericFeaturesOption.getValue(); i++){
-            Attribute att = new Attribute(("irrelNum" + i));
-            attributes.add(att);
-        }
-
-        // creates the values for categorical features
-        ArrayList<String> catVals = new ArrayList<>();
-        for(int i = 0; i < numValuesCategoricalFeatureOption.getValue(); i++) catVals.add("v" + i);
-
-        // appends the new categorical features
-        for(int i = 0; i < numCategoricalFeaturesOption.getValue(); i++){
-            Attribute att = new Attribute(("irrelCat" + i), catVals);
-            attributes.add(att);
-        }
-
-        // appends the class attribute
-        if(originalHeader.classIndex() != -1){
-            attributes.add(originalHeader.attribute(originalHeader.classIndex()));
-        }
-
-        // builds the new header
-        InstancesHeader format = new InstancesHeader(getCLICreationString(InstanceStream.class), attributes, 0);
-        format.setClassIndex(attributes.size() - 1);
-        newHeader = new InstancesHeader(format);
-    }
+	public ClassOption streamOption = new ClassOption("stream", 's', "Stream to imbalance.", ExampleStream.class,
+			"generators.RandomTreeGenerator");
+
+	public IntOption numNumericFeaturesOption = new IntOption("numNumericFeatures", 'n',
+			"Number of numeric features to be appended.", 0, 0, 1000);
+
+	public IntOption numCategoricalFeaturesOption = new IntOption("numCategoricalFeatures", 'c',
+			"Number of categorical features to be appended.", 0, 0, 1000);
+
+	public IntOption numValuesCategoricalFeatureOption = new IntOption("numValuesCategoricalFeature", 'v',
+			"Number of values for each categorical feature.", 2, 1, 1000);
+
+	public IntOption instanceRandomSeedOption = new IntOption("instanceRandomSeed", 'i',
+			"Seed for random generation of instances.", 1);
+
+	/**
+	 * The original stream.
+	 */
+	protected ExampleStream originalStream = null;
+
+	/**
+	 * The header with the new features appended.
+	 */
+	protected InstancesHeader newHeader = null;
+
+	/**
+	 * A pseudo-random number generator.
+	 */
+	protected Random random = null;
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		this.originalStream = (ExampleStream) getPreparedClassOption(streamOption);
+		this.random = new Random(instanceRandomSeedOption.getValue());
+		buildHeader();
+	}
+
+	@Override
+	public InstancesHeader getHeader() {
+		return newHeader;
+	}
+
+	@Override
+	public long estimatedRemainingInstances() {
+		return originalStream.estimatedRemainingInstances();
+	}
+
+	@Override
+	public boolean hasMoreInstances() {
+		return originalStream.hasMoreInstances();
+	}
+
+	@Override
+	public Example<Instance> nextInstance() {
+		Example<Instance> original = originalStream.nextInstance();
+
+		// copies the original values
+		double values[] = new double[this.newHeader.numAttributes()];
+		int ix = 0;
+		for (int i = 0; i < original.getData().dataset().numAttributes(); i++) {
+			if (original.getData().dataset().classIndex() != i) {
+				values[ix] = original.getData().value(i);
+				ix++;
+			}
+		}
+
+		// appends the new values
+		while (ix < values.length - 1) {
+			Attribute att = this.newHeader.attribute(ix);
+			if (att.isNumeric())
+				values[ix] = this.random.nextDouble();
+			else
+				values[ix] = this.random.nextInt(numValuesCategoricalFeatureOption.getValue());
+			ix++;
+		}
+
+		// copies the class value
+		if (original.getData().classIndex() != -1) {
+			values[values.length - 1] = original.getData().classValue();
+		}
+
+		// instantiates and returns the actual instance
+		Instance instnc = new DenseInstance(1.0, values);
+		instnc.setDataset(this.newHeader);
+
+		return new InstanceExample(instnc);
+	}
+
+	@Override
+	public boolean isRestartable() {
+		return originalStream.isRestartable();
+	}
+
+	@Override
+	public void restart() {
+		originalStream.restart();
+		this.random = new Random(instanceRandomSeedOption.getValue());
+		this.buildHeader();
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+	}
+
+	/**
+	 * Constructs the new header according to: 1- The original header 2- The number
+	 * of numeric and categorical features given by the user.
+	 */
+	private void buildHeader() {
+		ArrayList<Attribute> attributes = new ArrayList<>();
+
+		// copies the original attributes
+		InstancesHeader originalHeader = originalStream.getHeader();
+		for (int i = 0; i < originalHeader.numAttributes(); i++) {
+			Attribute att = originalHeader.attribute(i);
+			if (att != originalHeader.classAttribute()) {
+				attributes.add(att);
+			}
+		}
+
+		// appends the new numeric features
+		for (int i = 0; i < numNumericFeaturesOption.getValue(); i++) {
+			Attribute att = new Attribute(("irrelNum" + i));
+			attributes.add(att);
+		}
+
+		// creates the values for categorical features
+		ArrayList<String> catVals = new ArrayList<>();
+		for (int i = 0; i < numValuesCategoricalFeatureOption.getValue(); i++)
+			catVals.add("v" + i);
+
+		// appends the new categorical features
+		for (int i = 0; i < numCategoricalFeaturesOption.getValue(); i++) {
+			Attribute att = new Attribute(("irrelCat" + i), catVals);
+			attributes.add(att);
+		}
+
+		// appends the class attribute
+		if (originalHeader.classIndex() != -1) {
+			attributes.add(originalHeader.attribute(originalHeader.classIndex()));
+		}
+
+		// builds the new header
+		InstancesHeader format = new InstancesHeader(getCLICreationString(InstanceStream.class), attributes, 0);
+		format.setClassIndex(attributes.size() - 1);
+		newHeader = new InstancesHeader(format);
+	}
 
 }
diff --git a/moa/src/main/java/moa/streams/MultiFilteredStream.java b/moa/src/main/java/moa/streams/MultiFilteredStream.java
index b4247be27..fbcb42de8 100644
--- a/moa/src/main/java/moa/streams/MultiFilteredStream.java
+++ b/moa/src/main/java/moa/streams/MultiFilteredStream.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams;
 
@@ -37,88 +37,81 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class MultiFilteredStream extends AbstractOptionHandler implements
-        ExampleStream {
-
-    @Override
-    public String getPurposeString() {
-        return "A stream that is filtered.";
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    public ClassOption streamOption = new ClassOption("stream", 's',
-            "Stream to filter.", ExampleStream.class,
-            "generators.RandomTreeGenerator");
-
-    public ListOption filtersOption = new ListOption("filters", 'f',
-            "Filters to apply.", new ClassOption("filter", ' ',
-            "Stream filter.", StreamFilter.class, "AddNoiseFilter"),
-            new Option[0], ',');
-
-    protected ExampleStream filterChain;
-
-    @Override
-    public void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        Option[] filterOptions = this.filtersOption.getList();
-        StreamFilter[] filters = new StreamFilter[filterOptions.length];
-        for (int i = 0; i < filters.length; i++) {
-            monitor.setCurrentActivity("Materializing filter " + (i + 1)
-                    + "...", -1.0);
-            filters[i] = (StreamFilter) ((ClassOption) filterOptions[i]).materializeObject(monitor, repository);
-            if (monitor.taskShouldAbort()) {
-                return;
-            }
-            if (filters[i] instanceof OptionHandler) {
-                monitor.setCurrentActivity("Preparing filter " + (i + 1)
-                        + "...", -1.0);
-                ((OptionHandler) filters[i]).prepareForUse(monitor, repository);
-                if (monitor.taskShouldAbort()) {
-                    return;
-                }
-            }
-        }
-        ExampleStream chain = (ExampleStream) getPreparedClassOption(this.streamOption);
-        for (int i = 0; i < filters.length; i++) {
-            filters[i].setInputStream(chain);
-            chain = filters[i];
-        }
-        this.filterChain = chain;
-    }
-
-    @Override
-    public long estimatedRemainingInstances() {
-        return this.filterChain.estimatedRemainingInstances();
-    }
-
-    @Override
-    public InstancesHeader getHeader() {
-        return this.filterChain.getHeader();
-    }
-
-    @Override
-    public boolean hasMoreInstances() {
-        return this.filterChain.hasMoreInstances();
-    }
-
-    @Override
-    public boolean isRestartable() {
-        return this.filterChain.isRestartable();
-    }
-
-    @Override
-    public Example nextInstance() {
-        return this.filterChain.nextInstance();
-    }
-
-    @Override
-    public void restart() {
-        this.filterChain.restart();
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
+public class MultiFilteredStream extends AbstractOptionHandler implements ExampleStream {
+
+	@Override
+	public String getPurposeString() {
+		return "A stream that is filtered.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption streamOption = new ClassOption("stream", 's', "Stream to filter.", ExampleStream.class,
+			"generators.RandomTreeGenerator");
+
+	public ListOption filtersOption = new ListOption("filters", 'f', "Filters to apply.",
+			new ClassOption("filter", ' ', "Stream filter.", StreamFilter.class, "AddNoiseFilter"), new Option[0], ',');
+
+	protected ExampleStream filterChain;
+
+	@Override
+	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		Option[] filterOptions = this.filtersOption.getList();
+		StreamFilter[] filters = new StreamFilter[filterOptions.length];
+		for (int i = 0; i < filters.length; i++) {
+			monitor.setCurrentActivity("Materializing filter " + (i + 1) + "...", -1.0);
+			filters[i] = (StreamFilter) ((ClassOption) filterOptions[i]).materializeObject(monitor, repository);
+			if (monitor.taskShouldAbort()) {
+				return;
+			}
+			if (filters[i] instanceof OptionHandler) {
+				monitor.setCurrentActivity("Preparing filter " + (i + 1) + "...", -1.0);
+				((OptionHandler) filters[i]).prepareForUse(monitor, repository);
+				if (monitor.taskShouldAbort()) {
+					return;
+				}
+			}
+		}
+		ExampleStream chain = (ExampleStream) getPreparedClassOption(this.streamOption);
+		for (int i = 0; i < filters.length; i++) {
+			filters[i].setInputStream(chain);
+			chain = filters[i];
+		}
+		this.filterChain = chain;
+	}
+
+	@Override
+	public long estimatedRemainingInstances() {
+		return this.filterChain.estimatedRemainingInstances();
+	}
+
+	@Override
+	public InstancesHeader getHeader() {
+		return this.filterChain.getHeader();
+	}
+
+	@Override
+	public boolean hasMoreInstances() {
+		return this.filterChain.hasMoreInstances();
+	}
+
+	@Override
+	public boolean isRestartable() {
+		return this.filterChain.isRestartable();
+	}
+
+	@Override
+	public Example nextInstance() {
+		return this.filterChain.nextInstance();
+	}
+
+	@Override
+	public void restart() {
+		this.filterChain.restart();
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
 }
diff --git a/moa/src/main/java/moa/streams/MultiLabelFilteredStream.java b/moa/src/main/java/moa/streams/MultiLabelFilteredStream.java
index dd722fc2b..389b0e304 100644
--- a/moa/src/main/java/moa/streams/MultiLabelFilteredStream.java
+++ b/moa/src/main/java/moa/streams/MultiLabelFilteredStream.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams;
 
@@ -36,82 +36,78 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class MultiLabelFilteredStream extends AbstractOptionHandler implements
-MultiTargetInstanceStream {
-
-    @Override
-    public String getPurposeString() {
-        return "A stream that is filtered.";
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    public ClassOption streamOption = new ClassOption("stream", 's',
-            "Stream to filter.", MultiTargetInstanceStream.class,
-            MultiTargetArffFileStream.class.getName());
-
-    public ClassOption filtersOption = new ClassOption("filters", 'f',
-            "Filters to apply.", MultiLabelStreamFilter.class, 
-            SelectAttributesFilter.class.getName());
-
-    protected ExampleStream filterChain;
-
-    @Override
-    public void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-    	MultiLabelStreamFilter filters; 
-            monitor.setCurrentActivity("Materializing filter " //+ (i + 1)
-                    + "...", -1.0);
-            filters = (MultiLabelStreamFilter) getPreparedClassOption(this.filtersOption);
-            if (monitor.taskShouldAbort()) {
-                return;
-            }
-            if (filters instanceof OptionHandler) {
-                monitor.setCurrentActivity("Preparing filter " //+ (i + 1)
-                        + "...", -1.0);
-                ((OptionHandler) filters).prepareForUse(monitor, repository);
-                if (monitor.taskShouldAbort()) {
-                    return;
-                }
-            }
-            MultiTargetInstanceStream chain = (MultiTargetInstanceStream) getPreparedClassOption(this.streamOption);
-            filters.setInputStream(chain);
-            chain = filters;
-        this.filterChain = chain;
-    }
-
-    @Override
-    public long estimatedRemainingInstances() {
-        return this.filterChain.estimatedRemainingInstances();
-    }
-
-    @Override
-    public InstancesHeader getHeader() {
-        return this.filterChain.getHeader();
-    }
-
-    @Override
-    public boolean hasMoreInstances() {
-        return this.filterChain.hasMoreInstances();
-    }
-
-    @Override
-    public boolean isRestartable() {
-        return this.filterChain.isRestartable();
-    }
-
-    @Override
-    public Example nextInstance() {
-        return this.filterChain.nextInstance();
-    }
-
-    @Override
-    public void restart() {
-        this.filterChain.restart();
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
+public class MultiLabelFilteredStream extends AbstractOptionHandler implements MultiTargetInstanceStream {
+
+	@Override
+	public String getPurposeString() {
+		return "A stream that is filtered.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption streamOption = new ClassOption("stream", 's', "Stream to filter.",
+			MultiTargetInstanceStream.class, MultiTargetArffFileStream.class.getName());
+
+	public ClassOption filtersOption = new ClassOption("filters", 'f', "Filters to apply.",
+			MultiLabelStreamFilter.class, SelectAttributesFilter.class.getName());
+
+	protected ExampleStream filterChain;
+
+	@Override
+	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		MultiLabelStreamFilter filters;
+		monitor.setCurrentActivity("Materializing filter " // + (i + 1)
+				+ "...", -1.0);
+		filters = (MultiLabelStreamFilter) getPreparedClassOption(this.filtersOption);
+		if (monitor.taskShouldAbort()) {
+			return;
+		}
+		if (filters instanceof OptionHandler) {
+			monitor.setCurrentActivity("Preparing filter " // + (i + 1)
+					+ "...", -1.0);
+			((OptionHandler) filters).prepareForUse(monitor, repository);
+			if (monitor.taskShouldAbort()) {
+				return;
+			}
+		}
+		MultiTargetInstanceStream chain = (MultiTargetInstanceStream) getPreparedClassOption(this.streamOption);
+		filters.setInputStream(chain);
+		chain = filters;
+		this.filterChain = chain;
+	}
+
+	@Override
+	public long estimatedRemainingInstances() {
+		return this.filterChain.estimatedRemainingInstances();
+	}
+
+	@Override
+	public InstancesHeader getHeader() {
+		return this.filterChain.getHeader();
+	}
+
+	@Override
+	public boolean hasMoreInstances() {
+		return this.filterChain.hasMoreInstances();
+	}
+
+	@Override
+	public boolean isRestartable() {
+		return this.filterChain.isRestartable();
+	}
+
+	@Override
+	public Example nextInstance() {
+		return this.filterChain.nextInstance();
+	}
+
+	@Override
+	public void restart() {
+		this.filterChain.restart();
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
 }
diff --git a/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java b/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java
index 54fe69cee..929864feb 100644
--- a/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java
+++ b/moa/src/main/java/moa/streams/MultiTargetArffFileStream.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams;
 
@@ -25,11 +25,10 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class MultiTargetArffFileStream extends ArffFileStream implements
-        MultiTargetInstanceStream {
+public class MultiTargetArffFileStream extends ArffFileStream implements MultiTargetInstanceStream {
 
 	// deprecated
-	
+
 //    @Override
 //    public String getPurposeString() {
 //        return "A stream read from an ARFF file.";
@@ -125,10 +124,10 @@ public class MultiTargetArffFileStream extends ArffFileStream implements
 //            this.fileReader = new BufferedReader(new InputStreamReader(
 //                    this.fileProgressMonitor));
 //			// jesse -----
-//			/*int cs[] = this.outputAttributesOption.getRange(); 
+//			/*int cs[] = this.outputAttributesOption.getRange();
 //			if (cs.length == 1) {
 //				// single label
-//				int c = cs[0]; 
+//				int c = cs[0];
 //				this.instances = new Instances(this.fileReader, 1, c);
 //				if (c < 0) {
 //					this.instances.setClassIndex(this.instances.numAttributes() - 1);
@@ -137,7 +136,7 @@ public class MultiTargetArffFileStream extends ArffFileStream implements
 //				}
 //			}
 //			else {*/
-//				// multi-label since cs[] contains _multipe_ class indices, e.g., cs[] = {9,10,11} 
+//				// multi-label since cs[] contains _multipe_ class indices, e.g., cs[] = {9,10,11}
 //				// what to do here?
 //			this.instances = new Instances(this.fileReader, this.outputAttributesOption.getRange());
 //			//}
diff --git a/moa/src/main/java/moa/streams/MultiTargetInstanceStream.java b/moa/src/main/java/moa/streams/MultiTargetInstanceStream.java
index 6b5432c90..835b0af74 100644
--- a/moa/src/main/java/moa/streams/MultiTargetInstanceStream.java
+++ b/moa/src/main/java/moa/streams/MultiTargetInstanceStream.java
@@ -15,17 +15,16 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams;
 
 /**
- * Interface representing a data stream of instances. 
+ * Interface representing a data stream of instances.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $ 
+ * @version $Revision: 7 $
  */
-public interface MultiTargetInstanceStream extends InstanceStream{
-
+public interface MultiTargetInstanceStream extends InstanceStream {
 
 }
diff --git a/moa/src/main/java/moa/streams/PartitioningStream.java b/moa/src/main/java/moa/streams/PartitioningStream.java
index e4bd7e747..634d86ac7 100644
--- a/moa/src/main/java/moa/streams/PartitioningStream.java
+++ b/moa/src/main/java/moa/streams/PartitioningStream.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams;
 
@@ -32,39 +32,35 @@
 import moa.tasks.TaskMonitor;
 
 /**
- * This stream partitions the base stream into n distinct streams and outputs one of them
+ * This stream partitions the base stream into n distinct streams and outputs
+ * one of them
  *
  * @author Tuan Pham Minh (tuan.pham@ovgu.de)
  * @version $Revision: 1 $
  */
 @SuppressWarnings("rawtypes")
-public class PartitioningStream extends AbstractOptionHandler  implements ExampleStream {
-
+public class PartitioningStream extends AbstractOptionHandler implements ExampleStream {
 
 	private static final long serialVersionUID = 1L;
-	
-	public ClassOption streamOption = new ClassOption("baseStream", 's',
-            "Stream which is used for partitioning.", ExampleStream.class,
-            "generators.RandomTreeGenerator");
-
-    public IntOption partitionIndexOption = new IntOption(
-            "partitionIndex", 'i',
-            "The index of the partition, which should be used as output.", 0);
-
-    public IntOption numPartitionsOption = new IntOption(
-            "numPartitions", 'n',
-            "The number of total streams the base stream is split into.", 1);
-    
-    public IntOption randomSeedOption = new IntOption(
-            "randomSeed", 'r',
-            "The seed which is used (all other partitions should use the same one to guarentee).", 0);
-	
-    protected ExampleStream baseStream;
-    protected int partitionIndex;
-    protected int numPartitions;
-    protected Random random;
-    
-    @Override
+
+	public ClassOption streamOption = new ClassOption("baseStream", 's', "Stream which is used for partitioning.",
+			ExampleStream.class, "generators.RandomTreeGenerator");
+
+	public IntOption partitionIndexOption = new IntOption("partitionIndex", 'i',
+			"The index of the partition, which should be used as output.", 0);
+
+	public IntOption numPartitionsOption = new IntOption("numPartitions", 'n',
+			"The number of total streams the base stream is split into.", 1);
+
+	public IntOption randomSeedOption = new IntOption("randomSeed", 'r',
+			"The seed which is used (all other partitions should use the same one to guarentee).", 0);
+
+	protected ExampleStream baseStream;
+	protected int partitionIndex;
+	protected int numPartitions;
+	protected Random random;
+
+	@Override
 	public InstancesHeader getHeader() {
 		return baseStream.getHeader();
 	}
@@ -73,14 +69,12 @@ public InstancesHeader getHeader() {
 	public long estimatedRemainingInstances() {
 		long baseEstimatedRemainingInstances = baseStream.estimatedRemainingInstances();
 		// if the base stream is endless it will return something smaller than 0
-		if(baseEstimatedRemainingInstances < 0)
-		{
+		if (baseEstimatedRemainingInstances < 0) {
 			return baseEstimatedRemainingInstances;
 		}
-		
+
 		long numRemaining = (baseEstimatedRemainingInstances * (numPartitions - 1)) / (numPartitions);
-		if(numPartitions == 1)
-		{
+		if (numPartitions == 1) {
 			numRemaining = baseEstimatedRemainingInstances;
 		}
 		return numRemaining;
@@ -96,9 +90,9 @@ public boolean hasMoreInstances() {
 	public Example<Instance> nextInstance() {
 		// take the first instance from the stream which is guaranteed to be valid
 		Example<Instance> result = baseStream.nextInstance();
-		
+
 		discardNexInstancesNotFromPartition();
-		
+
 		return result;
 	}
 
@@ -123,39 +117,37 @@ protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repositor
 		baseStream = (ExampleStream) getPreparedClassOption(streamOption);
 		partitionIndex = partitionIndexOption.getValue();
 		numPartitions = numPartitionsOption.getValue();
-		
+
 		// initialize the random seed with the corresponding option
 		random = new Random(randomSeedOption.getValue());
 		// discard the first instances if they do not belong to the stream
 		discardNexInstancesNotFromPartition();
 	}
-	
+
 	/**
 	 * get the partition which is excluded from seeing the next instance
+	 * 
 	 * @return the index of the excluded partition
 	 */
-	protected int getNextPartitionToLeaveOut()
-	{
+	protected int getNextPartitionToLeaveOut() {
 		return random.nextInt(numPartitions);
 	}
-	
+
 	/**
 	 * check if this stream is excluded from seeing the next instance
+	 * 
 	 * @return
 	 */
-	protected boolean isNextInstanceFromPartition()
-	{
+	protected boolean isNextInstanceFromPartition() {
 		return getNextPartitionToLeaveOut() != partitionIndex;
 	}
-	
+
 	/**
-	 * discarding all instances which are exluded until an instance which can be seen by this
-	 * stream or the stream is empty
+	 * discarding all instances which are exluded until an instance which can be
+	 * seen by this stream or the stream is empty
 	 */
-	protected void discardNexInstancesNotFromPartition()
-	{
-		while(!isNextInstanceFromPartition() && baseStream.hasMoreInstances() && numPartitions > 1)
-		{
+	protected void discardNexInstancesNotFromPartition() {
+		while (!isNextInstanceFromPartition() && baseStream.hasMoreInstances() && numPartitions > 1) {
 			baseStream.nextInstance();
 		}
 	}
diff --git a/moa/src/main/java/moa/streams/RecurrentConceptDriftStream.java b/moa/src/main/java/moa/streams/RecurrentConceptDriftStream.java
index 1082192f9..05cc4105b 100644
--- a/moa/src/main/java/moa/streams/RecurrentConceptDriftStream.java
+++ b/moa/src/main/java/moa/streams/RecurrentConceptDriftStream.java
@@ -16,7 +16,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams;
 
@@ -28,87 +28,84 @@
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
 
-
-
 /**
  * Stream generator that adds recurrent concept drifts to examples in a stream.
- *<br/><br/>
- * Example:
- *<br/><br/>
+ * <br/>
+ * <br/>
+ * Example: <br/>
+ * <br/>
  * <code>RecurrentConceptDriftStream -s (generators.AgrawalGenerator -f 7) <br/>
- *    -d (generators.AgrawalGenerator -f 2) -w 1000000 -p 900000</code>
- *<br/><br/>
+ *    -d (generators.AgrawalGenerator -f 2) -w 1000000 -p 900000</code> <br/>
+ * <br/>
  * s : Stream <br/>
  * d : Concept drift Stream<br/>
  * p : Central position of first concept drift change<br/>
  * w : Width of concept drift changes<br/>
- * x : Width of recurrence (number of instances during which new concept is used)
- * y : Number of stability period (number of instances between drifts)
- * z : Number of appearances of drift
+ * x : Width of recurrence (number of instances during which new concept is
+ * used) y : Number of stability period (number of instances between drifts) z :
+ * Number of appearances of drift
  *
  * @author Miguel Abad (miguel.abad.arranz at alumnos dot upm dot es)x
  * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
  * @version $Revision: 1 $
  */
 public class RecurrentConceptDriftStream extends ConceptDriftStream {
-@Override
-    public String getPurposeString() {
-        return "Adds Recurrent Concept Drift to examples in a stream.";
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    public IntOption widthRecurrenceOption = new IntOption("widthRecurrence", 'x', 
-            "Number of instances during which new concept is used", 100);
-    
-    public IntOption stabPeriodOption = new IntOption("stabPeriod", 'y', 
-            "Number of instances between drifts", 200);     
-    
-    public IntOption numRepOption = new IntOption("numRep", 'z', 
-            "Number of instances between drifts", 4); 
-
-    @Override
-    public void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-
-        this.inputStream = (InstanceStream) getPreparedClassOption(this.streamOption);
-        this.driftStream = (InstanceStream) getPreparedClassOption(this.driftstreamOption);
-        this.random = new Random(this.randomSeedOption.getValue());
-        numberInstanceStream = 0;
-        if (this.alphaOption.getValue() != 0.0) {
-            this.widthOption.setValue((int) (1 / Math.tan(this.alphaOption.getValue() * Math.PI / 180)));
-        }
-    }
-
-    @Override
-    public Example nextInstance() {
-
-        numberInstanceStream++;
-        double x = numberInstanceStream;
-        
-        double probabilityDrift = 0;
-           
-        int iPos = this.positionOption.getValue();
-        
-        //As long as the probabilistic function is recursive, it depends
-        //on the number of repetitions established in the options
-        for (int iNumRep = 0; iNumRep < this.numRepOption.getValue(); iNumRep++){
-            probabilityDrift += 1.0 / (1.0 + Math.exp(-4*(x-iPos)/this.widthOption.getValue())) - 
-                1.0 / (1.0 + Math.exp(-4*(x-(iPos + this.widthRecurrenceOption.getValue()))/this.widthOption.getValue()));
-            
-            iPos += this.widthRecurrenceOption.getValue() + this.stabPeriodOption.getValue();
-        }
-        
-        if (this.random.nextDouble() > probabilityDrift) {            
-            return this.inputStream.nextInstance();
-        } else {            
-            return this.driftStream.nextInstance();
-        }       
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-    
+	@Override
+	public String getPurposeString() {
+		return "Adds Recurrent Concept Drift to examples in a stream.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public IntOption widthRecurrenceOption = new IntOption("widthRecurrence", 'x',
+			"Number of instances during which new concept is used", 100);
+
+	public IntOption stabPeriodOption = new IntOption("stabPeriod", 'y', "Number of instances between drifts", 200);
+
+	public IntOption numRepOption = new IntOption("numRep", 'z', "Number of instances between drifts", 4);
+
+	@Override
+	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+
+		this.inputStream = (InstanceStream) getPreparedClassOption(this.streamOption);
+		this.driftStream = (InstanceStream) getPreparedClassOption(this.driftstreamOption);
+		this.random = new Random(this.randomSeedOption.getValue());
+		numberInstanceStream = 0;
+		if (this.alphaOption.getValue() != 0.0) {
+			this.widthOption.setValue((int) (1 / Math.tan(this.alphaOption.getValue() * Math.PI / 180)));
+		}
+	}
+
+	@Override
+	public Example nextInstance() {
+
+		numberInstanceStream++;
+		double x = numberInstanceStream;
+
+		double probabilityDrift = 0;
+
+		int iPos = this.positionOption.getValue();
+
+		// As long as the probabilistic function is recursive, it depends
+		// on the number of repetitions established in the options
+		for (int iNumRep = 0; iNumRep < this.numRepOption.getValue(); iNumRep++) {
+			probabilityDrift += 1.0 / (1.0 + Math.exp(-4 * (x - iPos) / this.widthOption.getValue()))
+					- 1.0 / (1.0 + Math.exp(
+							-4 * (x - (iPos + this.widthRecurrenceOption.getValue())) / this.widthOption.getValue()));
+
+			iPos += this.widthRecurrenceOption.getValue() + this.stabPeriodOption.getValue();
+		}
+
+		if (this.random.nextDouble() > probabilityDrift) {
+			return this.inputStream.nextInstance();
+		} else {
+			return this.driftStream.nextInstance();
+		}
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
 }
diff --git a/moa/src/main/java/moa/streams/clustering/ClusterEvent.java b/moa/src/main/java/moa/streams/clustering/ClusterEvent.java
index 382971458..924654175 100644
--- a/moa/src/main/java/moa/streams/clustering/ClusterEvent.java
+++ b/moa/src/main/java/moa/streams/clustering/ClusterEvent.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.streams.clustering;
@@ -24,26 +24,26 @@
 
 public class ClusterEvent extends EventObject {
 
-  private String type;
-  private String message;
-  private long timestamp;
+	private String type;
+	private String message;
+	private long timestamp;
 
-  public ClusterEvent(Object source, long timestamp, String type, String message) {
-    super(source);
-    this.type = type;
-    this.message = message;
-    this.timestamp = timestamp;
-  }
+	public ClusterEvent(Object source, long timestamp, String type, String message) {
+		super(source);
+		this.type = type;
+		this.message = message;
+		this.timestamp = timestamp;
+	}
 
-  public String getMessage(){
-      return message;
-  }
+	public String getMessage() {
+		return message;
+	}
 
-  public long getTimestamp(){
-      return timestamp;
-  }
+	public long getTimestamp() {
+		return timestamp;
+	}
 
-  public String getType(){
-      return type;
-  }
+	public String getType() {
+		return type;
+	}
 }
diff --git a/moa/src/main/java/moa/streams/clustering/ClusterEventListener.java b/moa/src/main/java/moa/streams/clustering/ClusterEventListener.java
index 9f3fa03c5..228b50f1c 100644
--- a/moa/src/main/java/moa/streams/clustering/ClusterEventListener.java
+++ b/moa/src/main/java/moa/streams/clustering/ClusterEventListener.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.streams.clustering;
@@ -24,7 +24,6 @@
 
 public interface ClusterEventListener extends EventListener {
 
-  public void changeCluster(ClusterEvent e);
+	void changeCluster(ClusterEvent e);
 
 }
-
diff --git a/moa/src/main/java/moa/streams/clustering/ClusteringStream.java b/moa/src/main/java/moa/streams/clustering/ClusteringStream.java
index c40660b02..5f4fec613 100644
--- a/moa/src/main/java/moa/streams/clustering/ClusteringStream.java
+++ b/moa/src/main/java/moa/streams/clustering/ClusteringStream.java
@@ -14,8 +14,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.streams.clustering;
@@ -26,30 +26,29 @@
 import moa.options.AbstractOptionHandler;
 import moa.streams.InstanceStream;
 
-public abstract class ClusteringStream extends AbstractOptionHandler implements InstanceStream{
-    public IntOption decayHorizonOption = new IntOption("decayHorizon", 'h',
-                    "Decay horizon", 1000, 0, Integer.MAX_VALUE);
-
-    public FloatOption decayThresholdOption = new FloatOption("decayThreshold", 't',
-                    "Decay horizon threshold", 0.01, 0, 1);
+public abstract class ClusteringStream extends AbstractOptionHandler implements InstanceStream {
+	public IntOption decayHorizonOption = new IntOption("decayHorizon", 'h', "Decay horizon", 1000, 0,
+			Integer.MAX_VALUE);
 
-    public IntOption evaluationFrequencyOption = new IntOption("evaluationFrequency", 'e',
-                    "Evaluation frequency", 1000, 0, Integer.MAX_VALUE);
+	public FloatOption decayThresholdOption = new FloatOption("decayThreshold", 't', "Decay horizon threshold", 0.01, 0,
+			1);
 
-    public IntOption numAttsOption = new IntOption("numAtts", 'a',
-                    "The number of attributes to generate.", 2, 0, Integer.MAX_VALUE);
+	public IntOption evaluationFrequencyOption = new IntOption("evaluationFrequency", 'e', "Evaluation frequency", 1000,
+			0, Integer.MAX_VALUE);
 
-    public int getDecayHorizon(){
-        return decayHorizonOption.getValue();
-    }
+	public IntOption numAttsOption = new IntOption("numAtts", 'a', "The number of attributes to generate.", 2, 0,
+			Integer.MAX_VALUE);
 
-    public double getDecayThreshold(){
-        return decayThresholdOption.getValue();
-    }
+	public int getDecayHorizon() {
+		return decayHorizonOption.getValue();
+	}
 
-    public int getEvaluationFrequency(){
-        return evaluationFrequencyOption.getValue();
-    }
+	public double getDecayThreshold() {
+		return decayThresholdOption.getValue();
+	}
 
+	public int getEvaluationFrequency() {
+		return evaluationFrequencyOption.getValue();
+	}
 
 }
diff --git a/moa/src/main/java/moa/streams/clustering/FileStream.java b/moa/src/main/java/moa/streams/clustering/FileStream.java
index 38d4d3982..476d2ea07 100644
--- a/moa/src/main/java/moa/streams/clustering/FileStream.java
+++ b/moa/src/main/java/moa/streams/clustering/FileStream.java
@@ -1,9 +1,9 @@
 /**
  * [FileStream.java]
- * 
+ *
  * @author Timm Jansen
  * @editor Yunsu Kim
- * 
+ *
  * Last Edited: 2013/06/27
  * Data Management and Data Exploration Group, RWTH Aachen University
  *
@@ -18,8 +18,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 
 package moa.streams.clustering;
@@ -49,7 +49,7 @@
 import moa.core.utils.AttributeDefinitionUtil;
 import moa.tasks.TaskMonitor;
 
-public class FileStream extends ClusteringStream{
+public class FileStream extends ClusteringStream {
 
 	@Override
 	public String getPurposeString() {
@@ -58,103 +58,92 @@ public String getPurposeString() {
 
 	private static final long serialVersionUID = 1L;
 
+	String defaultfile = "KDDCup99.arff";
+
+	public FileOption arffFileOption = new FileOption("arffFile", 'f', "ARFF file to load.", defaultfile, "arff",
+			false);
+
+	public StringOption outputIndicesOption = new StringOption("outputIndices", 'c',
+			"Indices of output (class) attributes. Can be provided in a comma or semicolon separated list of single values or ranges.",
+			"-1");
+
+	public StringOption inputIndicesOption = new StringOption("outputIndices", 'i',
+			"Indices of input (class) attributes. Can be provided in a comma or semicolon separated list of single values or ranges. Leave blank for all non-output attributes.",
+			AttributeDefinitionUtil.nonIgnoredDefinition);
+
+	public FlagOption normalizeOption = new FlagOption("normalize", 'n', "Numerical data will be normalized to 0-1 "
+			+ "for the visualization to work. The complete arff file needs to be read upfront.");
+
+	public ListOption removeAttributesOption = new ListOption("removeAttributes", 'r',
+			"Attributes to remove. Enter comma seperated list, " + "starting with 1 for first attribute.",
+			new IntOption("removeAttribute", ' ', "Attribute to remove.", -1), new Option[0], ',');
+
+	public FlagOption keepNonNumericalAttrOption = new FlagOption("keepNonNumericalAttr", 'K',
+			"Non-numerical attributes are being filtered by default " + "(except the class attribute). "
+					+ "Check to keep all attributes. This option is being "
+					+ "overwritten by the manual attribute removal filter.");
 
-    String defaultfile = "KDDCup99.arff";
-
-	public FileOption arffFileOption = new FileOption("arffFile", 'f',
-			"ARFF file to load.", defaultfile, "arff", false);
-
-
-    public StringOption outputIndicesOption = new StringOption(
-    		"outputIndices",
-    		'c',
-    		"Indices of output (class) attributes. Can be provided in a comma or semicolon separated list of single values or ranges.",
-    		"-1");
-
-    public StringOption inputIndicesOption = new StringOption(
-    		"outputIndices",
-    		'i',
-    		"Indices of input (class) attributes. Can be provided in a comma or semicolon separated list of single values or ranges. Leave blank for all non-output attributes.",
-    		AttributeDefinitionUtil.nonIgnoredDefinition);
-	
-    public FlagOption normalizeOption = 
-    		new FlagOption("normalize", 'n', 
-    				"Numerical data will be normalized to 0-1 " +
-    				"for the visualization to work. The complete arff file needs to be read upfront.");
-
-    public ListOption removeAttributesOption = new ListOption("removeAttributes", 'r',
-            "Attributes to remove. Enter comma seperated list, " +
-            "starting with 1 for first attribute.", 
-            new IntOption("removeAttribute", ' ', "Attribute to remove.",-1),
-            new Option[0], ',');	
-	
-    public FlagOption keepNonNumericalAttrOption = 
-    		new FlagOption("keepNonNumericalAttr", 'K',
-    		"Non-numerical attributes are being filtered by default " +
-    		"(except the class attribute). " +
-    		"Check to keep all attributes. This option is being " +
-    		"overwritten by the manual attribute removal filter.");
-	
-
-    
-  
 	protected InstancesHeader instances;
 
 	protected Reader fileReader;
 
 	protected boolean hitEndOfFile;
 
-    protected InstanceExample lastInstanceRead;
+	protected InstanceExample lastInstanceRead;
 
 	protected int numInstancesRead;
 
 	protected InputStreamProgressMonitor fileProgressMonitor;
-	
+
 	private Integer[] removeAttributes = null;
-    
+
 	private InstancesHeader filteredDataset = null;
-    
+
 	private ArrayList<Double[]> valuesMinMaxDiff = null;
 
-	
-	public FileStream(){
-		//remove numAttritube Option from ClusteringStream as that is being set internally for Filestream
+	public FileStream() {
+		// remove numAttritube Option from ClusteringStream as that is being set
+		// internally for Filestream
 		numAttsOption = null;
 	}
-	
+
 	@Override
-	public void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
+	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
 		restart();
 	}
 
+	@Override
 	public InstancesHeader getHeader() {
 		return new InstancesHeader(this.filteredDataset);
 	}
 
+	@Override
 	public long estimatedRemainingInstances() {
-		double progressFraction = this.fileProgressMonitor
-				.getProgressFraction();
+		double progressFraction = this.fileProgressMonitor.getProgressFraction();
 		if ((progressFraction > 0.0) && (this.numInstancesRead > 0)) {
 			return (long) ((this.numInstancesRead / progressFraction) - this.numInstancesRead);
 		}
 		return -1;
 	}
 
+	@Override
 	public boolean hasMoreInstances() {
 		return !this.hitEndOfFile;
 	}
 
-    public InstanceExample nextInstance() {
-        InstanceExample prevInstance = this.lastInstanceRead;
+	@Override
+	public InstanceExample nextInstance() {
+		InstanceExample prevInstance = this.lastInstanceRead;
 		this.hitEndOfFile = !readNextInstanceFromFile();
 		return prevInstance;
 	}
 
+	@Override
 	public boolean isRestartable() {
 		return true;
 	}
 
+	@Override
 	public void restart() {
 		try {
 			if (fileReader != null) {
@@ -163,57 +152,56 @@ public void restart() {
 			InputStream fileStream = new FileInputStream(arffFileOption.getFile());
 			fileProgressMonitor = new InputStreamProgressMonitor(fileStream);
 			fileReader = new BufferedReader(new InputStreamReader(fileProgressMonitor));
-            instances = new InstancesHeader(fileReader, this.outputIndicesOption.getValue(), this.inputIndicesOption.getValue());
-
+			instances = new InstancesHeader(fileReader, this.outputIndicesOption.getValue(),
+					this.inputIndicesOption.getValue());
 
-			//use hashset to delete duplicates and attributes numbers that aren't valid
-			HashSet<Integer> attributes =  new HashSet<Integer>(); 
+			// use hashset to delete duplicates and attributes numbers that aren't valid
+			HashSet<Integer> attributes = new HashSet<>();
 			Option[] rawAttributeList = removeAttributesOption.getList();
 			for (int i = 0; i < rawAttributeList.length; i++) {
-				int attribute = ((IntOption)rawAttributeList[i]).getValue();
-				if(1 <= attribute && attribute <= instances.numAttributes())
-					attributes.add(attribute-1);
+				int attribute = ((IntOption) rawAttributeList[i]).getValue();
+				if (1 <= attribute && attribute <= instances.numAttributes())
+					attributes.add(attribute - 1);
 				else
-					System.out.println("Found invalid attribute removal description: " +
-							"Attribute option "+attribute
-							+" will be ignored. Filestream only has "
-							+instances.numAttributes()+" attributes.");
+					System.out.println("Found invalid attribute removal description: " + "Attribute option " + attribute
+							+ " will be ignored. Filestream only has " + instances.numAttributes() + " attributes.");
 			}
-			
-			//remove all non numeric attributes except the class attribute
-			if(!keepNonNumericalAttrOption.isSet()){
+
+			// remove all non numeric attributes except the class attribute
+			if (!keepNonNumericalAttrOption.isSet()) {
 				for (int i = 0; i < instances.numAttributes(); i++) {
-					if(!instances.attribute(i).isNumeric() && i != instances.classIndex()){
+					if (!instances.attribute(i).isNumeric() && i != instances.classIndex()) {
 						attributes.add(i);
 					}
 				}
 			}
-			
-			//read min/max values in case we need to normalize
-			if(normalizeOption.isSet())
+
+			// read min/max values in case we need to normalize
+			if (normalizeOption.isSet())
 				valuesMinMaxDiff = readMinMaxDiffValues(attributes);
-			
-			//convert hashset to array and sort array so we can delete attributes in a sequence
+
+			// convert hashset to array and sort array so we can delete attributes in a
+			// sequence
 			removeAttributes = attributes.toArray(new Integer[0]);
 			Arrays.sort(removeAttributes);
-			
-			//set updated number of attributes (class attribute included)
-			numAttsOption = new IntOption("numAtts", 'a',"", instances.numAttributes() - removeAttributes.length);
-			
-			if(removeAttributes.length > 0){
+
+			// set updated number of attributes (class attribute included)
+			numAttsOption = new IntOption("numAtts", 'a', "", instances.numAttributes() - removeAttributes.length);
+
+			if (removeAttributes.length > 0) {
 				System.out.println("Removing the following attributes:");
 				for (int i = 0; i < removeAttributes.length; i++) {
-					System.out.println((removeAttributes[i]+1)+" "
-							+instances.attribute(removeAttributes[i]).name());
+					System.out
+							.println((removeAttributes[i] + 1) + " " + instances.attribute(removeAttributes[i]).name());
 				}
 			}
-            
-			//create filtered dataset
+
+			// create filtered dataset
 			filteredDataset = new InstancesHeader(instances);
-			for (int i = removeAttributes.length-1; i >= 0 ; i--) {
+			for (int i = removeAttributes.length - 1; i >= 0; i--) {
 				filteredDataset.deleteAttributeAt(removeAttributes[i]);
-				if(true){
-					
+				if (true) {
+
 				}
 			}
 
@@ -227,30 +215,30 @@ public void restart() {
 
 	protected boolean readNextInstanceFromFile() {
 		try {
-			
+
 			if (this.instances.readInstance(this.fileReader)) {
 				Instance rawInstance = this.instances.instance(0);
-				
-				//remove dataset from instance so we can delete attributes
-				for (int i = removeAttributes.length-1; i >= 0 ; i--) {
-					rawInstance.deleteAttributeAt(removeAttributes[i]);	
+
+				// remove dataset from instance so we can delete attributes
+				for (int i = removeAttributes.length - 1; i >= 0; i--) {
+					rawInstance.deleteAttributeAt(removeAttributes[i]);
 				}
-				//set adjusted dataset for instance
+				// set adjusted dataset for instance
 				rawInstance.setDataset(filteredDataset);
 
 				if (normalizeOption.isSet() && valuesMinMaxDiff != null) {
-					for (int i = 0; i < rawInstance.numAttributes() ; i++) {
-						if (valuesMinMaxDiff.get(i)[2] != 1 &&		// Already normalized
-							valuesMinMaxDiff.get(i)[2] != 0 &&		// Max. value is 0 (unable to be normalized)
-							i != rawInstance.classIndex()) {		// Class label is not subject to be normalized
+					for (int i = 0; i < rawInstance.numAttributes(); i++) {
+						if (valuesMinMaxDiff.get(i)[2] != 1 && // Already normalized
+								valuesMinMaxDiff.get(i)[2] != 0 && // Max. value is 0 (unable to be normalized)
+								i != rawInstance.classIndex()) { // Class label is not subject to be normalized
 							double v = rawInstance.value(i);
 							v = (v - valuesMinMaxDiff.get(i)[0]) / valuesMinMaxDiff.get(i)[2];
 							rawInstance.setValue(i, v);
 						}
 					}
 				}
-				
-                this.lastInstanceRead = new InstanceExample(rawInstance);
+
+				this.lastInstanceRead = new InstanceExample(rawInstance);
 				this.instances.delete(); // keep instances clean
 				this.numInstancesRead++;
 				return true;
@@ -261,53 +249,54 @@ protected boolean readNextInstanceFromFile() {
 			}
 			return false;
 		} catch (IOException ioe) {
-			throw new RuntimeException(
-					"ArffFileStream failed to read instance from stream.", ioe);
+			throw new RuntimeException("ArffFileStream failed to read instance from stream.", ioe);
 		}
 	}
-	
+
 	/**
 	 * @param ignoredAttributes Attributes that will be ignored
-	 * @return A list with min/max and diff=max-min values per attribute of the arff file 
+	 * @return A list with min/max and diff=max-min values per attribute of the arff
+	 *         file
 	 */
 	protected ArrayList<Double[]> readMinMaxDiffValues(HashSet<Integer> ignoredAttributes) {
 		ArrayList<Double[]> valuesMinMaxDiff = null;
-		
-		if(ignoredAttributes == null)
-			ignoredAttributes = new HashSet<Integer>();
-		
+
+		if (ignoredAttributes == null)
+			ignoredAttributes = new HashSet<>();
+
 		try {
 			InputStream fileStream = new FileInputStream(arffFileOption.getFile());
 			InputStreamProgressMonitor fileProgressMonitor = new InputStreamProgressMonitor(fileStream);
 			Reader fileReader = new BufferedReader(new InputStreamReader(fileProgressMonitor));
-            InstancesHeader instances = new InstancesHeader(fileReader, this.outputIndicesOption.getValue(), this.inputIndicesOption.getValue());
+			InstancesHeader instances = new InstancesHeader(fileReader, this.outputIndicesOption.getValue(),
+					this.inputIndicesOption.getValue());
 
-			valuesMinMaxDiff = new ArrayList<Double[]>();
-			for (int i = 0; i < instances.numAttributes()-ignoredAttributes.size(); i++) {
-				Double[] values =  {Double.POSITIVE_INFINITY,Double.NEGATIVE_INFINITY,0.0};
+			valuesMinMaxDiff = new ArrayList<>();
+			for (int i = 0; i < instances.numAttributes() - ignoredAttributes.size(); i++) {
+				Double[] values = { Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, 0.0 };
 				valuesMinMaxDiff.add(values);
 			}
-			
+
 			System.out.print("Reading arff file for normalization...");
 			int counter = 0;
 			while (instances.readInstance(fileReader)) {
 				Instance instance = instances.instance(0);
 				int a = 0;
 				for (int i = 0; i < instances.numAttributes(); i++) {
-					if(!ignoredAttributes.contains(i)){
+					if (!ignoredAttributes.contains(i)) {
 						double value = instance.value(i);
-						if(value < valuesMinMaxDiff.get(a)[0])
+						if (value < valuesMinMaxDiff.get(a)[0])
 							valuesMinMaxDiff.get(a)[0] = value;
-						if(value > valuesMinMaxDiff.get(a)[1])
+						if (value > valuesMinMaxDiff.get(a)[1])
 							valuesMinMaxDiff.get(a)[1] = value;
 						a++;
 					}
 				}
 				instances.delete();
 
-				//show some progress
+				// show some progress
 				counter++;
-				if(counter >= 10000){
+				if (counter >= 10000) {
 					counter = 0;
 					System.out.print(".");
 				}
@@ -319,17 +308,16 @@ protected ArrayList<Double[]> readMinMaxDiffValues(HashSet<Integer> ignoredAttri
 			System.out.println("done!");
 
 			for (int i = 0; i < valuesMinMaxDiff.size(); i++) {
-				valuesMinMaxDiff.get(i)[2]=valuesMinMaxDiff.get(i)[1]-valuesMinMaxDiff.get(i)[0];
+				valuesMinMaxDiff.get(i)[2] = valuesMinMaxDiff.get(i)[1] - valuesMinMaxDiff.get(i)[0];
 			}
 
 			return valuesMinMaxDiff;
 		} catch (IOException ioe) {
-			throw new RuntimeException(
-					"ArffFileStream failed to read instance from stream.", ioe);
+			throw new RuntimeException("ArffFileStream failed to read instance from stream.", ioe);
 		}
-	}	
-	
+	}
 
+	@Override
 	public void getDescription(StringBuilder sb, int indent) {
 		// TODO Auto-generated method stub
 
diff --git a/moa/src/main/java/moa/streams/clustering/RandomRBFGeneratorEvents.java b/moa/src/main/java/moa/streams/clustering/RandomRBFGeneratorEvents.java
index 43594fbf7..66c075344 100644
--- a/moa/src/main/java/moa/streams/clustering/RandomRBFGeneratorEvents.java
+++ b/moa/src/main/java/moa/streams/clustering/RandomRBFGeneratorEvents.java
@@ -1,10 +1,10 @@
 /**
  * RandomRBFGeneratorEvents.java
  *
- * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz) - RandomRBFGenerator 
+ * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz) - RandomRBFGenerator
  * 		   Timm Jansen (moa@cs.rwth-aachen.de) - Events
  * @editor Yunsu Kim
- * 
+ *
  * Last edited: 2013/06/02
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
@@ -18,8 +18,8 @@
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
- *    
- *    
+ *
+ *
  */
 package moa.streams.clustering;
 
@@ -48,345 +48,346 @@
 import moa.streams.InstanceStream;
 import moa.tasks.TaskMonitor;
 
-
 public class RandomRBFGeneratorEvents extends ClusteringStream {
-    private transient Vector listeners;
-
-    private static final long serialVersionUID = 1L;
-
-    public IntOption modelRandomSeedOption = new IntOption("modelRandomSeed",
-                    'm', "Seed for random generation of model.", 1);
-
-    public IntOption instanceRandomSeedOption = new IntOption(
-                    "instanceRandomSeed", 'i',
-                    "Seed for random generation of instances.", 5);
-
-    public IntOption numClusterOption = new IntOption("numCluster", 'K',
-                    "The average number of centroids in the model.", 5, 1, Integer.MAX_VALUE);
-
-    public IntOption numClusterRangeOption = new IntOption("numClusterRange", 'k',
-                    "Deviation of the number of centroids in the model.", 3, 0, Integer.MAX_VALUE);
-
-    public FloatOption kernelRadiiOption = new FloatOption("kernelRadius", 'R',
-                    "The average radii of the centroids in the model.", 0.07, 0, 1);
-
-    public FloatOption kernelRadiiRangeOption = new FloatOption("kernelRadiusRange", 'r',
-                    "Deviation of average radii of the centroids in the model.", 0, 0, 1);
-
-    public FloatOption densityRangeOption = new FloatOption("densityRange", 'd',
-                    "Offset of the average weight a cluster has. Value of 0 means all cluster " +
-                    "contain the same amount of points.", 0, 0, 1);
-
-    public IntOption speedOption = new IntOption("speed", 'V',
-                    "Kernels move a predefined distance of 0.01 every X points", 500, 1, Integer.MAX_VALUE);
-
-    public IntOption speedRangeOption = new IntOption("speedRange", 'v',
-                    "Speed/Velocity point offset", 0, 0, Integer.MAX_VALUE);
-
-    public FloatOption noiseLevelOption = new FloatOption("noiseLevel", 'N',
-                    "Noise level", 0.1, 0, 1);
-
-    public FlagOption noiseInClusterOption = new FlagOption("noiseInCluster", 'n',
-                    "Allow noise to be placed within a cluster");
-
-    public IntOption eventFrequencyOption = new IntOption("eventFrequency", 'E',
-                    "Event frequency. Enable at least one of the events below and set numClusterRange!", 30000, 0, Integer.MAX_VALUE);
-
-    public FlagOption eventMergeSplitOption = new FlagOption("eventMergeSplitOption", 'M',
-                    "Enable merging and splitting of clusters. Set eventFrequency and numClusterRange!");
-
-    public FlagOption eventDeleteCreateOption = new FlagOption("eventDeleteCreate", 'C',
-    				"Enable emering and disapperaing of clusters. Set eventFrequency and numClusterRange!");
-
-    
-    private double merge_threshold = 0.7;
-    private int kernelMovePointFrequency = 10;
-    private double maxDistanceMoveThresholdByStep = 0.01;
-    private int maxOverlapFitRuns = 50;
-    private double eventFrequencyRange = 0;
-
-    private boolean debug = false;
-
-    private AutoExpandVector<GeneratorCluster> kernels;
-    protected Random instanceRandom;
-    protected InstancesHeader streamHeader;
-    private int numGeneratedInstances;
-    private int numActiveKernels;
-    private int nextEventCounter;
-    private int nextEventChoice = -1;
-    private int clusterIdCounter;
-    private GeneratorCluster mergeClusterA;
-    private GeneratorCluster mergeClusterB;
-    private boolean mergeKernelsOverlapping = false;
-
-
-
-    private class GeneratorCluster implements Serializable{
-        //TODO: points is redundant to microclusterpoints, we need to come 
-        //up with a good strategy that microclusters get updated and 
-        //rebuild if needed. Idea: Sort microclusterpoints by timestamp and let 
-        // microclusterdecay hold the timestamp for when the last point in a 
-        //microcluster gets kicked, then we rebuild... or maybe not... could be
-        //same as searching for point to be kicked. more likely is we rebuild 
-        //fewer times then insert.
-        
-        private static final long serialVersionUID = -6301649898961112942L;
-        
-        SphereCluster generator;
-        int kill = -1;
-        boolean merging = false;
-        double[] moveVector;
-        int totalMovementSteps;
-        int currentMovementSteps;
-        boolean isSplitting = false;
-
-        LinkedList<DataPoint> points = new LinkedList<DataPoint>();
-        ArrayList<SphereCluster> microClusters = new ArrayList<SphereCluster>();
-        ArrayList<ArrayList<DataPoint>> microClustersPoints = new ArrayList();
-        ArrayList<Integer> microClustersDecay = new ArrayList();
-
-
-        public GeneratorCluster(int label) {
-            boolean outofbounds = true;
-            int tryCounter = 0;
-            while(outofbounds && tryCounter < maxOverlapFitRuns){
-                tryCounter++;
-                outofbounds = false;
-                double[] center = new double [numAttsOption.getValue()];
-                double radius = kernelRadiiOption.getValue()+(instanceRandom.nextBoolean()?-1:1)*kernelRadiiRangeOption.getValue()*instanceRandom.nextDouble();
-                while(radius <= 0){
-                    radius = kernelRadiiOption.getValue()+(instanceRandom.nextBoolean()?-1:1)*kernelRadiiRangeOption.getValue()*instanceRandom.nextDouble();
-                }
-                for (int j = 0; j < numAttsOption.getValue(); j++) {
-                     center[j] = instanceRandom.nextDouble();
-                     if(center[j]- radius < 0 || center[j] + radius > 1){
-                        outofbounds = true;
-                        break;
-                     }
-                }
-                generator = new SphereCluster(center, radius);
-            }
-            if(tryCounter < maxOverlapFitRuns){
-                generator.setId(label);
-                double avgWeight = 1.0/numClusterOption.getValue();
-                double weight = avgWeight + (instanceRandom.nextBoolean()?-1:1)*avgWeight*densityRangeOption.getValue()*instanceRandom.nextDouble();
-                generator.setWeight(weight);
-                setDesitnation(null);
-            }
-            else{
-                generator = null;
-                kill = 0;
-                System.out.println("Tried "+maxOverlapFitRuns+" times to create kernel. Reduce average radii." );
-            }
-        }
-
-        public GeneratorCluster(int label, SphereCluster cluster) {
-            this.generator = cluster;
-            cluster.setId(label);
-            setDesitnation(null);
-        }
-
-        public int getWorkID(){
-            for(int c = 0; c < kernels.size(); c++){
-                if(kernels.get(c).equals(this))
-                    return c;
-            }
-            return -1;
-        }
-
-        private void updateKernel(){
-            if(kill == 0){
-                kernels.remove(this);
-            }
-            if(kill > 0){
-                kill--;
-            }
-            //we could be lot more precise if we would keep track of timestamps of points
-            //then we could remove all old points and rebuild the cluster on up to date point base
-            //BUT worse the effort??? so far we just want to avoid overlap with this, so its more
-            //konservative as needed. Only needs to change when we need a thighter representation
-            for (int m = 0; m < microClusters.size(); m++) {
-                if(numGeneratedInstances-microClustersDecay.get(m) > decayHorizonOption.getValue()){
-                    microClusters.remove(m);
-                    microClustersPoints.remove(m);
-                    microClustersDecay.remove(m);
-                }
-            }
-
-            if(!points.isEmpty() && numGeneratedInstances-points.getFirst().getTimestamp() >= decayHorizonOption.getValue()){
+	private transient Vector listeners;
+
+	private static final long serialVersionUID = 1L;
+
+	public IntOption modelRandomSeedOption = new IntOption("modelRandomSeed", 'm',
+			"Seed for random generation of model.", 1);
+
+	public IntOption instanceRandomSeedOption = new IntOption("instanceRandomSeed", 'i',
+			"Seed for random generation of instances.", 5);
+
+	public IntOption numClusterOption = new IntOption("numCluster", 'K',
+			"The average number of centroids in the model.", 5, 1, Integer.MAX_VALUE);
+
+	public IntOption numClusterRangeOption = new IntOption("numClusterRange", 'k',
+			"Deviation of the number of centroids in the model.", 3, 0, Integer.MAX_VALUE);
+
+	public FloatOption kernelRadiiOption = new FloatOption("kernelRadius", 'R',
+			"The average radii of the centroids in the model.", 0.07, 0, 1);
+
+	public FloatOption kernelRadiiRangeOption = new FloatOption("kernelRadiusRange", 'r',
+			"Deviation of average radii of the centroids in the model.", 0, 0, 1);
+
+	public FloatOption densityRangeOption = new FloatOption("densityRange", 'd',
+			"Offset of the average weight a cluster has. Value of 0 means all cluster "
+					+ "contain the same amount of points.",
+			0, 0, 1);
+
+	public IntOption speedOption = new IntOption("speed", 'V',
+			"Kernels move a predefined distance of 0.01 every X points", 500, 1, Integer.MAX_VALUE);
+
+	public IntOption speedRangeOption = new IntOption("speedRange", 'v', "Speed/Velocity point offset", 0, 0,
+			Integer.MAX_VALUE);
+
+	public FloatOption noiseLevelOption = new FloatOption("noiseLevel", 'N', "Noise level", 0.1, 0, 1);
+
+	public FlagOption noiseInClusterOption = new FlagOption("noiseInCluster", 'n',
+			"Allow noise to be placed within a cluster");
+
+	public IntOption eventFrequencyOption = new IntOption("eventFrequency", 'E',
+			"Event frequency. Enable at least one of the events below and set numClusterRange!", 30000, 0,
+			Integer.MAX_VALUE);
+
+	public FlagOption eventMergeSplitOption = new FlagOption("eventMergeSplitOption", 'M',
+			"Enable merging and splitting of clusters. Set eventFrequency and numClusterRange!");
+
+	public FlagOption eventDeleteCreateOption = new FlagOption("eventDeleteCreate", 'C',
+			"Enable emering and disapperaing of clusters. Set eventFrequency and numClusterRange!");
+
+	private double merge_threshold = 0.7;
+	private int kernelMovePointFrequency = 10;
+	private double maxDistanceMoveThresholdByStep = 0.01;
+	private int maxOverlapFitRuns = 50;
+	private double eventFrequencyRange = 0;
+
+	private boolean debug = false;
+
+	private AutoExpandVector<GeneratorCluster> kernels;
+	protected Random instanceRandom;
+	protected InstancesHeader streamHeader;
+	private int numGeneratedInstances;
+	private int numActiveKernels;
+	private int nextEventCounter;
+	private int nextEventChoice = -1;
+	private int clusterIdCounter;
+	private GeneratorCluster mergeClusterA;
+	private GeneratorCluster mergeClusterB;
+	private boolean mergeKernelsOverlapping = false;
+
+	private class GeneratorCluster implements Serializable {
+		// TODO: points is redundant to microclusterpoints, we need to come
+		// up with a good strategy that microclusters get updated and
+		// rebuild if needed. Idea: Sort microclusterpoints by timestamp and let
+		// microclusterdecay hold the timestamp for when the last point in a
+		// microcluster gets kicked, then we rebuild... or maybe not... could be
+		// same as searching for point to be kicked. more likely is we rebuild
+		// fewer times then insert.
+
+		private static final long serialVersionUID = -6301649898961112942L;
+
+		SphereCluster generator;
+		int kill = -1;
+		boolean merging = false;
+		double[] moveVector;
+		int totalMovementSteps;
+		int currentMovementSteps;
+		boolean isSplitting = false;
+
+		LinkedList<DataPoint> points = new LinkedList<>();
+		ArrayList<SphereCluster> microClusters = new ArrayList<>();
+		ArrayList<ArrayList<DataPoint>> microClustersPoints = new ArrayList();
+		ArrayList<Integer> microClustersDecay = new ArrayList();
+
+		public GeneratorCluster(int label) {
+			boolean outofbounds = true;
+			int tryCounter = 0;
+			while (outofbounds && tryCounter < maxOverlapFitRuns) {
+				tryCounter++;
+				outofbounds = false;
+				double[] center = new double[numAttsOption.getValue()];
+				double radius = kernelRadiiOption.getValue() + (instanceRandom.nextBoolean() ? -1 : 1)
+						* kernelRadiiRangeOption.getValue() * instanceRandom.nextDouble();
+				while (radius <= 0) {
+					radius = kernelRadiiOption.getValue() + (instanceRandom.nextBoolean() ? -1 : 1)
+							* kernelRadiiRangeOption.getValue() * instanceRandom.nextDouble();
+				}
+				for (int j = 0; j < numAttsOption.getValue(); j++) {
+					center[j] = instanceRandom.nextDouble();
+					if (center[j] - radius < 0 || center[j] + radius > 1) {
+						outofbounds = true;
+						break;
+					}
+				}
+				generator = new SphereCluster(center, radius);
+			}
+			if (tryCounter < maxOverlapFitRuns) {
+				generator.setId(label);
+				double avgWeight = 1.0 / numClusterOption.getValue();
+				double weight = avgWeight + (instanceRandom.nextBoolean() ? -1 : 1) * avgWeight
+						* densityRangeOption.getValue() * instanceRandom.nextDouble();
+				generator.setWeight(weight);
+				setDesitnation(null);
+			} else {
+				generator = null;
+				kill = 0;
+				System.out.println("Tried " + maxOverlapFitRuns + " times to create kernel. Reduce average radii.");
+			}
+		}
+
+		public GeneratorCluster(int label, SphereCluster cluster) {
+			this.generator = cluster;
+			cluster.setId(label);
+			setDesitnation(null);
+		}
+
+		public int getWorkID() {
+			for (int c = 0; c < kernels.size(); c++) {
+				if (kernels.get(c).equals(this))
+					return c;
+			}
+			return -1;
+		}
+
+		private void updateKernel() {
+			if (kill == 0) {
+				kernels.remove(this);
+			}
+			if (kill > 0) {
+				kill--;
+			}
+			// we could be lot more precise if we would keep track of timestamps of points
+			// then we could remove all old points and rebuild the cluster on up to date
+			// point base
+			// BUT worse the effort??? so far we just want to avoid overlap with this, so
+			// its more
+			// konservative as needed. Only needs to change when we need a thighter
+			// representation
+			for (int m = 0; m < microClusters.size(); m++) {
+				if (numGeneratedInstances - microClustersDecay.get(m) > decayHorizonOption.getValue()) {
+					microClusters.remove(m);
+					microClustersPoints.remove(m);
+					microClustersDecay.remove(m);
+				}
+			}
+
+			if (!points.isEmpty()
+					&& numGeneratedInstances - points.getFirst().getTimestamp() >= decayHorizonOption.getValue()) {
 //                if(debug)
 //                    System.out.println("Cleaning up macro cluster "+generator.getId());
-                points.removeFirst();
-            }
-
-        }
-
-        private void addInstance(Instance instance){
-            DataPoint point = new DataPoint(instance, numGeneratedInstances);
-            points.add(point);
-            
-            int minMicroIndex = -1;
-            double minHullDist = Double.MAX_VALUE;
-            boolean inserted = false;
-            //we favour more recently build clusters so we can remove earlier cluster sooner
-            for (int m = microClusters.size()-1; m >=0 ; m--) {
-                SphereCluster micro = microClusters.get(m);
-                double hulldist = micro.getCenterDistance(point)-micro.getRadius();
-                //point fits into existing cluster
-                if(hulldist <= 0){
-                    microClustersPoints.get(m).add(point);
-                    microClustersDecay.set(m, numGeneratedInstances);
-                    inserted = true;
-                    break;
-                }
-                //if not, check if its at least the closest cluster
-                else{
-                    if(hulldist < minHullDist){
-                        minMicroIndex = m;
-                        minHullDist = hulldist;
-                    }
-                }
-            }
-            //Reseting index choice for alternative cluster building
-            int alt = 1;
-            if(alt == 1)
-                minMicroIndex = -1;
-            if(!inserted){
-                //add to closest cluster and expand cluster
-                if(minMicroIndex!=-1){
-                    microClustersPoints.get(minMicroIndex).add(point);
-                    //we should keep the miniball instances and just check in
-                    //new points instead of rebuilding the whole thing
-                    SphereCluster s = new SphereCluster(microClustersPoints.get(minMicroIndex),numAttsOption.getValue());
-                    //check if current microcluster is bigger then generating cluster
-                    if(s.getRadius() > generator.getRadius()){
-                        //remove previously added point
-                        microClustersPoints.get(minMicroIndex).remove(microClustersPoints.get(minMicroIndex).size()-1);
-                        minMicroIndex = -1;
-                    }
-                    else{
-                        microClusters.set(minMicroIndex, s);
-                        microClustersDecay.set(minMicroIndex, numGeneratedInstances);
-                    }
-                }
-                //minMicroIndex might have been reset above
-                //create new micro cluster
-                if(minMicroIndex == -1){
-                    ArrayList<DataPoint> microPoints = new ArrayList<DataPoint>();
-                    microPoints.add(point);
-                    SphereCluster s;
-                    if(alt == 0)
-                        s = new SphereCluster(microPoints,numAttsOption.getValue());
-                    else
-                        s = new SphereCluster(generator.getCenter(),generator.getRadius(),1);
-
-                    microClusters.add(s);
-                    microClustersPoints.add(microPoints);
-                    microClustersDecay.add(numGeneratedInstances);
-                    int id = 0;
-                    while(id < kernels.size()){
-                        if(kernels.get(id) == this)
-                            break;
-                        id++;
-                    }
-                    s.setGroundTruth(id);
-                }
-            }
-
-        }
-
-
-        private void move(){
-            if(currentMovementSteps < totalMovementSteps){
-                currentMovementSteps++;
-                if( moveVector == null){
-                    return;
-                }
-                else{
-                    double[] center = generator.getCenter();
-                    boolean outofbounds = true;
-                    while(outofbounds){
-                        double radius = generator.getRadius();
-                        outofbounds = false;
-                        center = generator.getCenter();
-                        for ( int d = 0; d < center.length; d++ ) {
-                            center[d]+= moveVector[d];
-                            if(center[d]- radius < 0 || center[d] + radius > 1){
-                                outofbounds = true;
-                                setDesitnation(null);
-                                break;
-                            }
-                        }
-                    }
-                    generator.setCenter(center);
-                }
-            }
-            else{
-                if(!merging){
-                    setDesitnation(null);
-                    isSplitting = false;
-                }
-            }
-        }
-
-        void setDesitnation(double[] destination){
-
-            if(destination == null){
-                destination = new double [numAttsOption.getValue()];
-                for (int j = 0; j < numAttsOption.getValue(); j++) {
-                     destination[j] = instanceRandom.nextDouble();
-                }
-            }
-            double[] center = generator.getCenter();
-            int dim = center.length;
-
-            double[] v = new double[dim];
-
-            for ( int d = 0; d < dim; d++ ) {
-                v[d]=destination[d]-center[d];
-            }
-            setMoveVector(v);
-        }
-
-        void setMoveVector(double[] vector){
-        	//we are ignoring the steps, otherwise we have to change 
-        	//speed of the kernels, do we want that?
-            moveVector = vector;
-            int speedInPoints  = speedOption.getValue();
-            if(speedRangeOption.getValue() > 0)
-                    speedInPoints +=(instanceRandom.nextBoolean()?-1:1)*instanceRandom.nextInt(speedRangeOption.getValue());
-            if(speedInPoints  < 1) speedInPoints  = speedOption.getValue();
-
-
-            double length = 0;
-            for ( int d = 0; d < moveVector.length; d++ ) {
-                length+=Math.pow(vector[d],2);
-            }
-            length = Math.sqrt(length);
-
-            totalMovementSteps = (int)(length/(maxDistanceMoveThresholdByStep*kernelMovePointFrequency)*speedInPoints);
-            for ( int d = 0; d < moveVector.length; d++ ) {
-                moveVector[d]/=(double)totalMovementSteps;
-            }
-
-
-            currentMovementSteps = 0;
+				points.removeFirst();
+			}
+
+		}
+
+		private void addInstance(Instance instance) {
+			DataPoint point = new DataPoint(instance, numGeneratedInstances);
+			points.add(point);
+
+			int minMicroIndex = -1;
+			double minHullDist = Double.MAX_VALUE;
+			boolean inserted = false;
+			// we favour more recently build clusters so we can remove earlier cluster
+			// sooner
+			for (int m = microClusters.size() - 1; m >= 0; m--) {
+				SphereCluster micro = microClusters.get(m);
+				double hulldist = micro.getCenterDistance(point) - micro.getRadius();
+				// point fits into existing cluster
+				if (hulldist <= 0) {
+					microClustersPoints.get(m).add(point);
+					microClustersDecay.set(m, numGeneratedInstances);
+					inserted = true;
+					break;
+				}
+				// if not, check if its at least the closest cluster
+				else {
+					if (hulldist < minHullDist) {
+						minMicroIndex = m;
+						minHullDist = hulldist;
+					}
+				}
+			}
+			// Reseting index choice for alternative cluster building
+			int alt = 1;
+			if (alt == 1)
+				minMicroIndex = -1;
+			if (!inserted) {
+				// add to closest cluster and expand cluster
+				if (minMicroIndex != -1) {
+					microClustersPoints.get(minMicroIndex).add(point);
+					// we should keep the miniball instances and just check in
+					// new points instead of rebuilding the whole thing
+					SphereCluster s = new SphereCluster(microClustersPoints.get(minMicroIndex),
+							numAttsOption.getValue());
+					// check if current microcluster is bigger then generating cluster
+					if (s.getRadius() > generator.getRadius()) {
+						// remove previously added point
+						microClustersPoints.get(minMicroIndex)
+								.remove(microClustersPoints.get(minMicroIndex).size() - 1);
+						minMicroIndex = -1;
+					} else {
+						microClusters.set(minMicroIndex, s);
+						microClustersDecay.set(minMicroIndex, numGeneratedInstances);
+					}
+				}
+				// minMicroIndex might have been reset above
+				// create new micro cluster
+				if (minMicroIndex == -1) {
+					ArrayList<DataPoint> microPoints = new ArrayList<>();
+					microPoints.add(point);
+					SphereCluster s;
+					if (alt == 0)
+						s = new SphereCluster(microPoints, numAttsOption.getValue());
+					else
+						s = new SphereCluster(generator.getCenter(), generator.getRadius(), 1);
+
+					microClusters.add(s);
+					microClustersPoints.add(microPoints);
+					microClustersDecay.add(numGeneratedInstances);
+					int id = 0;
+					while (id < kernels.size()) {
+						if (kernels.get(id) == this)
+							break;
+						id++;
+					}
+					s.setGroundTruth(id);
+				}
+			}
+
+		}
+
+		private void move() {
+			if (currentMovementSteps < totalMovementSteps) {
+				currentMovementSteps++;
+				if (moveVector == null) {
+					return;
+				} else {
+					double[] center = generator.getCenter();
+					boolean outofbounds = true;
+					while (outofbounds) {
+						double radius = generator.getRadius();
+						outofbounds = false;
+						center = generator.getCenter();
+						for (int d = 0; d < center.length; d++) {
+							center[d] += moveVector[d];
+							if (center[d] - radius < 0 || center[d] + radius > 1) {
+								outofbounds = true;
+								setDesitnation(null);
+								break;
+							}
+						}
+					}
+					generator.setCenter(center);
+				}
+			} else {
+				if (!merging) {
+					setDesitnation(null);
+					isSplitting = false;
+				}
+			}
+		}
+
+		void setDesitnation(double[] destination) {
+
+			if (destination == null) {
+				destination = new double[numAttsOption.getValue()];
+				for (int j = 0; j < numAttsOption.getValue(); j++) {
+					destination[j] = instanceRandom.nextDouble();
+				}
+			}
+			double[] center = generator.getCenter();
+			int dim = center.length;
+
+			double[] v = new double[dim];
+
+			for (int d = 0; d < dim; d++) {
+				v[d] = destination[d] - center[d];
+			}
+			setMoveVector(v);
+		}
+
+		void setMoveVector(double[] vector) {
+			// we are ignoring the steps, otherwise we have to change
+			// speed of the kernels, do we want that?
+			moveVector = vector;
+			int speedInPoints = speedOption.getValue();
+			if (speedRangeOption.getValue() > 0)
+				speedInPoints += (instanceRandom.nextBoolean() ? -1 : 1)
+						* instanceRandom.nextInt(speedRangeOption.getValue());
+			if (speedInPoints < 1)
+				speedInPoints = speedOption.getValue();
+
+			double length = 0;
+			for (int d = 0; d < moveVector.length; d++) {
+				length += Math.pow(vector[d], 2);
+			}
+			length = Math.sqrt(length);
+
+			totalMovementSteps = (int) (length / (maxDistanceMoveThresholdByStep * kernelMovePointFrequency)
+					* speedInPoints);
+			for (int d = 0; d < moveVector.length; d++) {
+				moveVector[d] /= totalMovementSteps;
+			}
+
+			currentMovementSteps = 0;
 //            if(debug){
 //                System.out.println("Setting new direction for C"+generator.getId()+": distance "
 //                        +length+" in "+totalMovementSteps+" steps");
 //            }
-        }
+		}
 
-        private String tryMerging(GeneratorCluster merge){
-           String message = "";
-           double overlapDegree = generator.overlapRadiusDegree(merge.generator);
-           if(overlapDegree > merge_threshold){
-                SphereCluster mcluster = merge.generator;
-                double radius = Math.max(generator.getRadius(), mcluster.getRadius());
-                generator.combine(mcluster);
+		private String tryMerging(GeneratorCluster merge) {
+			String message = "";
+			double overlapDegree = generator.overlapRadiusDegree(merge.generator);
+			if (overlapDegree > merge_threshold) {
+				SphereCluster mcluster = merge.generator;
+				double radius = Math.max(generator.getRadius(), mcluster.getRadius());
+				generator.combine(mcluster);
 
 //                //adjust radius, get bigger and bigger with high dim data
-                generator.setRadius(radius);
+				generator.setRadius(radius);
 //                double[] center = generator.getCenter();
 //                double[] mcenter = mcluster.getCenter();
 //                double weight = generator.getWeight();
@@ -395,583 +396,573 @@ private String tryMerging(GeneratorCluster merge){
 ////                    center[i] = (center[i] * weight + mcenter[i] * mweight) / (mweight + weight);
 ////                }
 //                generator.setWeight(weight + mweight);
-                message  = "Clusters merging: "+mergeClusterB.generator.getId()+" into "+mergeClusterA.generator.getId();
-
-                //clean up and restet merging stuff
-                //mark kernel so it gets killed when it doesn't contain any more instances
-                merge.kill = decayHorizonOption.getValue();
-                //set weight to 0 so no new instances will be created in the cluster
-                mcluster.setWeight(0.0);
-                normalizeWeights();
-                numActiveKernels--;
-                mergeClusterB = mergeClusterA = null;
-                merging = false;
-                mergeKernelsOverlapping = false;
-            }
-           else{
-	           if(overlapDegree > 0 && !mergeKernelsOverlapping){
-	        	   mergeKernelsOverlapping = true;
-	        	   message = "Merge overlapping started";
-	           }
-           }
-           return message;
-        }
-
-        private String splitKernel(){
-            isSplitting = true;
-            //todo radius range
-            double radius = kernelRadiiOption.getValue();
-            double avgWeight = 1.0/numClusterOption.getValue();
-            double weight = avgWeight + avgWeight*densityRangeOption.getValue()*instanceRandom.nextDouble();
-            SphereCluster spcluster = null;
-
-            double[] center = generator.getCenter();
-            spcluster = new SphereCluster(center, radius, weight);
-
-            if(spcluster !=null){
-                GeneratorCluster gc = new GeneratorCluster(clusterIdCounter++, spcluster);
-                gc.isSplitting = true;
-                kernels.add(gc);
-                normalizeWeights();
-                numActiveKernels++;
-                return "Split from Kernel "+generator.getId();
-            }
-            else{
-                System.out.println("Tried to split new kernel from C"+generator.getId()+
-                        ". Not enough room for new cluster, decrease average radii, number of clusters or enable overlap.");
-                return "";
-            }
-        }
-        
-        private String fadeOut(){
-        	kill = decayHorizonOption.getValue();
-        	generator.setWeight(0.0);
-        	numActiveKernels--;
-        	normalizeWeights();
-        	return "Fading out C"+generator.getId();
-        }
-        
-        
-    }
-
-    public RandomRBFGeneratorEvents() {
-        noiseInClusterOption.set();
+				message = "Clusters merging: " + mergeClusterB.generator.getId() + " into "
+						+ mergeClusterA.generator.getId();
+
+				// clean up and restet merging stuff
+				// mark kernel so it gets killed when it doesn't contain any more instances
+				merge.kill = decayHorizonOption.getValue();
+				// set weight to 0 so no new instances will be created in the cluster
+				mcluster.setWeight(0.0);
+				normalizeWeights();
+				numActiveKernels--;
+				mergeClusterB = mergeClusterA = null;
+				merging = false;
+				mergeKernelsOverlapping = false;
+			} else {
+				if (overlapDegree > 0 && !mergeKernelsOverlapping) {
+					mergeKernelsOverlapping = true;
+					message = "Merge overlapping started";
+				}
+			}
+			return message;
+		}
+
+		private String splitKernel() {
+			isSplitting = true;
+			// todo radius range
+			double radius = kernelRadiiOption.getValue();
+			double avgWeight = 1.0 / numClusterOption.getValue();
+			double weight = avgWeight + avgWeight * densityRangeOption.getValue() * instanceRandom.nextDouble();
+			SphereCluster spcluster = null;
+
+			double[] center = generator.getCenter();
+			spcluster = new SphereCluster(center, radius, weight);
+
+			if (spcluster != null) {
+				GeneratorCluster gc = new GeneratorCluster(clusterIdCounter++, spcluster);
+				gc.isSplitting = true;
+				kernels.add(gc);
+				normalizeWeights();
+				numActiveKernels++;
+				return "Split from Kernel " + generator.getId();
+			} else {
+				System.out.println("Tried to split new kernel from C" + generator.getId()
+						+ ". Not enough room for new cluster, decrease average radii, number of clusters or enable overlap.");
+				return "";
+			}
+		}
+
+		private String fadeOut() {
+			kill = decayHorizonOption.getValue();
+			generator.setWeight(0.0);
+			numActiveKernels--;
+			normalizeWeights();
+			return "Fading out C" + generator.getId();
+		}
+
+	}
+
+	public RandomRBFGeneratorEvents() {
+		noiseInClusterOption.set();
 //        eventDeleteCreateOption.set();
 //        eventMergeSplitOption.set();
-    }
-
-    public InstancesHeader getHeader() {
-            return streamHeader;
-    }
-
-    public long estimatedRemainingInstances() {
-            return -1;
-    }
-
-    public boolean hasMoreInstances() {
-            return true;
-    }
-
-    public boolean isRestartable() {
-            return true;
-    }
-
-    @Override
-    public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-        monitor.setCurrentActivity("Preparing random RBF...", -1.0);
-        generateHeader();
-        restart();
-    }
-
-    public void restart() {
-            instanceRandom = new Random(instanceRandomSeedOption.getValue());
-            nextEventCounter = eventFrequencyOption.getValue();
-            nextEventChoice = getNextEvent();
-            numActiveKernels = 0;
-            numGeneratedInstances = 0;
-            clusterIdCounter = 0;
-            mergeClusterA = mergeClusterB = null;
-            kernels = new AutoExpandVector<GeneratorCluster>();
-
-            initKernels();
-    }
-	
-    protected void generateHeader() {	// 2013/06/02: Noise label
-        ArrayList<Attribute> attributes = new ArrayList<Attribute>();
-        for (int i = 0; i < this.numAttsOption.getValue(); i++) {
-            attributes.add(new Attribute("att" + (i + 1)));
-        }
-        
-        ArrayList<String> classLabels = new ArrayList<String>();
-        for (int i = 0; i < this.numClusterOption.getValue(); i++) {
-            classLabels.add("class" + (i + 1));
-        }
-        if (noiseLevelOption.getValue() > 0) classLabels.add("noise");	// The last label = "noise"
-        
-        attributes.add(new Attribute("class", classLabels));
-        streamHeader = new InstancesHeader(getCLICreationString(InstanceStream.class), attributes, 0);
-        streamHeader.setClassIndex(streamHeader.numAttributes() - 1);
-    }
-
-        
-    protected void initKernels() {
-        for (int i = 0; i < numClusterOption.getValue(); i++) {
-            kernels.add(new GeneratorCluster(clusterIdCounter));
-            numActiveKernels++;
-            clusterIdCounter++;
-        }
-        normalizeWeights();
-    }
-
-    public InstanceExample nextInstance() {
-        numGeneratedInstances++;
-        eventScheduler();
-
-        //make room for the classlabel
-        double[] values_new = new double [numAttsOption.getValue()+1]; //+1
-        double[] values = null;
-        int clusterChoice = -1;
-
-        if(instanceRandom.nextDouble() > noiseLevelOption.getValue()){
-            clusterChoice = chooseWeightedElement();
-            values = kernels.get(clusterChoice).generator.sample(instanceRandom).toDoubleArray();
-        }
-        else{
-            //get ranodm noise point
-            values = getNoisePoint();
-        }
-
-        if(Double.isNaN(values[0])){
-            System.out.println("Instance corrupted:"+numGeneratedInstances);
-        }
-        //System.arraycopy(values, 0, values_new, 0, values.length);
-        System.arraycopy(values, 0, values_new, 0, values.length);
-        Instance inst = new DenseInstance(1.0, values_new);
-        inst.setDataset(getHeader());
-        if(clusterChoice == -1){
-        	// 2013/06/02 (Yunsu Kim)
-        	// Noise instance has the last class value instead of "-1"
-        	// Preventing ArrayIndexOutOfBoundsException in WriteStreamToARFFFile
-            inst.setClassValue(numClusterOption.getValue());
-        }
-        else{
-            inst.setClassValue(kernels.get(clusterChoice).generator.getId());
-            //Do we need micro cluster representation if have overlapping clusters?
-            //if(!overlappingOption.isSet())
-                kernels.get(clusterChoice).addInstance(inst);
-        }
+	}
+
+	@Override
+	public InstancesHeader getHeader() {
+		return streamHeader;
+	}
+
+	@Override
+	public long estimatedRemainingInstances() {
+		return -1;
+	}
+
+	@Override
+	public boolean hasMoreInstances() {
+		return true;
+	}
+
+	@Override
+	public boolean isRestartable() {
+		return true;
+	}
+
+	@Override
+	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		monitor.setCurrentActivity("Preparing random RBF...", -1.0);
+		generateHeader();
+		restart();
+	}
+
+	@Override
+	public void restart() {
+		instanceRandom = new Random(instanceRandomSeedOption.getValue());
+		nextEventCounter = eventFrequencyOption.getValue();
+		nextEventChoice = getNextEvent();
+		numActiveKernels = 0;
+		numGeneratedInstances = 0;
+		clusterIdCounter = 0;
+		mergeClusterA = mergeClusterB = null;
+		kernels = new AutoExpandVector<>();
+
+		initKernels();
+	}
+
+	protected void generateHeader() { // 2013/06/02: Noise label
+		ArrayList<Attribute> attributes = new ArrayList<>();
+		for (int i = 0; i < this.numAttsOption.getValue(); i++) {
+			attributes.add(new Attribute("att" + (i + 1)));
+		}
+
+		ArrayList<String> classLabels = new ArrayList<>();
+		for (int i = 0; i < this.numClusterOption.getValue(); i++) {
+			classLabels.add("class" + (i + 1));
+		}
+		if (noiseLevelOption.getValue() > 0)
+			classLabels.add("noise"); // The last label = "noise"
+
+		attributes.add(new Attribute("class", classLabels));
+		streamHeader = new InstancesHeader(getCLICreationString(InstanceStream.class), attributes, 0);
+		streamHeader.setClassIndex(streamHeader.numAttributes() - 1);
+	}
+
+	protected void initKernels() {
+		for (int i = 0; i < numClusterOption.getValue(); i++) {
+			kernels.add(new GeneratorCluster(clusterIdCounter));
+			numActiveKernels++;
+			clusterIdCounter++;
+		}
+		normalizeWeights();
+	}
+
+	@Override
+	public InstanceExample nextInstance() {
+		numGeneratedInstances++;
+		eventScheduler();
+
+		// make room for the classlabel
+		double[] values_new = new double[numAttsOption.getValue() + 1]; // +1
+		double[] values = null;
+		int clusterChoice = -1;
+
+		if (instanceRandom.nextDouble() > noiseLevelOption.getValue()) {
+			clusterChoice = chooseWeightedElement();
+			values = kernels.get(clusterChoice).generator.sample(instanceRandom).toDoubleArray();
+		} else {
+			// get ranodm noise point
+			values = getNoisePoint();
+		}
+
+		if (Double.isNaN(values[0])) {
+			System.out.println("Instance corrupted:" + numGeneratedInstances);
+		}
+		// System.arraycopy(values, 0, values_new, 0, values.length);
+		System.arraycopy(values, 0, values_new, 0, values.length);
+		Instance inst = new DenseInstance(1.0, values_new);
+		inst.setDataset(getHeader());
+		if (clusterChoice == -1) {
+			// 2013/06/02 (Yunsu Kim)
+			// Noise instance has the last class value instead of "-1"
+			// Preventing ArrayIndexOutOfBoundsException in WriteStreamToARFFFile
+			inst.setClassValue(numClusterOption.getValue());
+		} else {
+			inst.setClassValue(kernels.get(clusterChoice).generator.getId());
+			// Do we need micro cluster representation if have overlapping clusters?
+			// if(!overlappingOption.isSet())
+			kernels.get(clusterChoice).addInstance(inst);
+		}
 //        System.out.println(numGeneratedInstances+": Overlap is"+updateOverlaps());
-        
-        return new InstanceExample(inst);
-    }
-
-
-    public Clustering getGeneratingClusters(){
-        Clustering clustering = new Clustering();
-        for (int c = 0; c < kernels.size(); c++) {
-            clustering.add(kernels.get(c).generator);
-        }
-        return clustering;
-    }
-
-    public Clustering getMicroClustering(){
-        Clustering clustering = new Clustering();
-        int id = 0;
-
-            for (int c = 0; c < kernels.size(); c++) {
-                for (int m = 0; m < kernels.get(c).microClusters.size(); m++) {
-                    kernels.get(c).microClusters.get(m).setId(id);
-                    kernels.get(c).microClusters.get(m).setGroundTruth(kernels.get(c).generator.getId());
-                    clustering.add(kernels.get(c).microClusters.get(m));
-                    id++;
-                }
-            }
-
-        //System.out.println("numMicroKernels "+clustering.size());
-        return clustering;
-    }
-
-/**************************** EVENTS ******************************************/
-    private void eventScheduler(){
-
-        for ( int i = 0; i < kernels.size(); i++ ) {
-            kernels.get(i).updateKernel();
-        }
-        
-        nextEventCounter--;
-        //only move kernels every 10 points, performance reasons????
-        //should this be randomized as well???
-        if(nextEventCounter%kernelMovePointFrequency == 0){
-            //move kernels
-            for ( int i = 0; i < kernels.size(); i++ ) {
-                kernels.get(i).move();
-                //overlapControl();
-            }
-        }
-
-
-        if(eventFrequencyOption.getValue() == 0){
-            return;
-        }
-
-        String type ="";
-        String message ="";
-        boolean eventFinished = false;
-        switch(nextEventChoice){
-            case 0:
-                if(numActiveKernels > 1 && numActiveKernels > numClusterOption.getValue() - numClusterRangeOption.getValue()){
-                    message = mergeKernels(nextEventCounter);
-                    type = "Merge";
-                }
-                if(mergeClusterA==null && mergeClusterB==null && message.startsWith("Clusters merging")){
-                	eventFinished = true;
-                }                
-            break;
-            case 1:
-                if(nextEventCounter<=0){
-                    if(numActiveKernels < numClusterOption.getValue() + numClusterRangeOption.getValue()){
-                        type = "Split";
-                        message = splitKernel();
-                    }
-                    eventFinished = true;
-                }
-            break;
-            case 2:
-                if(nextEventCounter<=0){
-                	if(numActiveKernels > 1 && numActiveKernels > numClusterOption.getValue() - numClusterRangeOption.getValue()){
-                        message = fadeOut();
-                        type = "Delete";
-                    }
-                	eventFinished = true;
-                }
-            break;
-            case 3:
-                if(nextEventCounter<=0){
-                	if(numActiveKernels < numClusterOption.getValue() + numClusterRangeOption.getValue()){
-	                    message = fadeIn();
-	                    type = "Create";
-                	}
-                	eventFinished = true;          	
-                }
-            break;
-
-        }
-        if (eventFinished){
-                nextEventCounter = (int)(eventFrequencyOption.getValue()+(instanceRandom.nextBoolean()?-1:1)*eventFrequencyOption.getValue()*eventFrequencyRange*instanceRandom.nextDouble());
-                nextEventChoice = getNextEvent();
-                //System.out.println("Next event choice: "+nextEventChoice);
-        }
-        if(!message.isEmpty()){
-        	message+=" (numKernels = "+numActiveKernels+" at "+numGeneratedInstances+")";
-        	if(!type.equals("Merge") || message.startsWith("Clusters merging"))
-        		fireClusterChange(numGeneratedInstances, type, message);
-        }
-    }
-    
-    private int getNextEvent() {
-    	int choice = -1;
-    	boolean lowerLimit = numActiveKernels <= numClusterOption.getValue() - numClusterRangeOption.getValue();
-    	boolean upperLimit = numActiveKernels >= numClusterOption.getValue() + numClusterRangeOption.getValue();
-
-    	if(!lowerLimit || !upperLimit){
-	    	int mode = -1;
-	    	if(eventDeleteCreateOption.isSet() && eventMergeSplitOption.isSet()){
-	    		mode = instanceRandom.nextInt(2);
-	    	}
-	    	
-			if(mode==0 || (mode==-1 && eventMergeSplitOption.isSet())){
-				//have we reached a limit? if not free choice
-				if(!lowerLimit && !upperLimit) 
+
+		return new InstanceExample(inst);
+	}
+
+	public Clustering getGeneratingClusters() {
+		Clustering clustering = new Clustering();
+		for (int c = 0; c < kernels.size(); c++) {
+			clustering.add(kernels.get(c).generator);
+		}
+		return clustering;
+	}
+
+	public Clustering getMicroClustering() {
+		Clustering clustering = new Clustering();
+		int id = 0;
+
+		for (int c = 0; c < kernels.size(); c++) {
+			for (int m = 0; m < kernels.get(c).microClusters.size(); m++) {
+				kernels.get(c).microClusters.get(m).setId(id);
+				kernels.get(c).microClusters.get(m).setGroundTruth(kernels.get(c).generator.getId());
+				clustering.add(kernels.get(c).microClusters.get(m));
+				id++;
+			}
+		}
+
+		// System.out.println("numMicroKernels "+clustering.size());
+		return clustering;
+	}
+
+	/**************************** EVENTS ******************************************/
+	private void eventScheduler() {
+
+		for (int i = 0; i < kernels.size(); i++) {
+			kernels.get(i).updateKernel();
+		}
+
+		nextEventCounter--;
+		// only move kernels every 10 points, performance reasons????
+		// should this be randomized as well???
+		if (nextEventCounter % kernelMovePointFrequency == 0) {
+			// move kernels
+			for (int i = 0; i < kernels.size(); i++) {
+				kernels.get(i).move();
+				// overlapControl();
+			}
+		}
+
+		if (eventFrequencyOption.getValue() == 0) {
+			return;
+		}
+
+		String type = "";
+		String message = "";
+		boolean eventFinished = false;
+		switch (nextEventChoice) {
+		case 0:
+			if (numActiveKernels > 1
+					&& numActiveKernels > numClusterOption.getValue() - numClusterRangeOption.getValue()) {
+				message = mergeKernels(nextEventCounter);
+				type = "Merge";
+			}
+			if (mergeClusterA == null && mergeClusterB == null && message.startsWith("Clusters merging")) {
+				eventFinished = true;
+			}
+			break;
+		case 1:
+			if (nextEventCounter <= 0) {
+				if (numActiveKernels < numClusterOption.getValue() + numClusterRangeOption.getValue()) {
+					type = "Split";
+					message = splitKernel();
+				}
+				eventFinished = true;
+			}
+			break;
+		case 2:
+			if (nextEventCounter <= 0) {
+				if (numActiveKernels > 1
+						&& numActiveKernels > numClusterOption.getValue() - numClusterRangeOption.getValue()) {
+					message = fadeOut();
+					type = "Delete";
+				}
+				eventFinished = true;
+			}
+			break;
+		case 3:
+			if (nextEventCounter <= 0) {
+				if (numActiveKernels < numClusterOption.getValue() + numClusterRangeOption.getValue()) {
+					message = fadeIn();
+					type = "Create";
+				}
+				eventFinished = true;
+			}
+			break;
+
+		}
+		if (eventFinished) {
+			nextEventCounter = (int) (eventFrequencyOption.getValue() + (instanceRandom.nextBoolean() ? -1 : 1)
+					* eventFrequencyOption.getValue() * eventFrequencyRange * instanceRandom.nextDouble());
+			nextEventChoice = getNextEvent();
+			// System.out.println("Next event choice: "+nextEventChoice);
+		}
+		if (!message.isEmpty()) {
+			message += " (numKernels = " + numActiveKernels + " at " + numGeneratedInstances + ")";
+			if (!type.equals("Merge") || message.startsWith("Clusters merging"))
+				fireClusterChange(numGeneratedInstances, type, message);
+		}
+	}
+
+	private int getNextEvent() {
+		int choice = -1;
+		boolean lowerLimit = numActiveKernels <= numClusterOption.getValue() - numClusterRangeOption.getValue();
+		boolean upperLimit = numActiveKernels >= numClusterOption.getValue() + numClusterRangeOption.getValue();
+
+		if (!lowerLimit || !upperLimit) {
+			int mode = -1;
+			if (eventDeleteCreateOption.isSet() && eventMergeSplitOption.isSet()) {
+				mode = instanceRandom.nextInt(2);
+			}
+
+			if (mode == 0 || (mode == -1 && eventMergeSplitOption.isSet())) {
+				// have we reached a limit? if not free choice
+				if (!lowerLimit && !upperLimit)
 					choice = instanceRandom.nextInt(2);
 				else
-					//we have a limit. if lower limit, choose split
-					if(lowerLimit)
-						choice = 1;
-					//otherwise we reached upper level, choose merge
-					else
-						choice = 0;
+				// we have a limit. if lower limit, choose split
+				if (lowerLimit)
+					choice = 1;
+				// otherwise we reached upper level, choose merge
+				else
+					choice = 0;
 			}
-			
-			if(mode==1 || (mode==-1 && eventDeleteCreateOption.isSet())){
-				//have we reached a limit? if not free choice
-				if(!lowerLimit && !upperLimit) 
-					choice = instanceRandom.nextInt(2)+2;
+
+			if (mode == 1 || (mode == -1 && eventDeleteCreateOption.isSet())) {
+				// have we reached a limit? if not free choice
+				if (!lowerLimit && !upperLimit)
+					choice = instanceRandom.nextInt(2) + 2;
 				else
-					//we have a limit. if lower limit, choose create
-					if(lowerLimit)
-						choice = 3;
-					//otherwise we reached upper level, choose delete
-					else
-						choice = 2;
-			}
-    	}
-
-    	
-    	return choice;
-    }
-
-	private String fadeOut(){
-	    int id = instanceRandom.nextInt(kernels.size());
-	    while(kernels.get(id).kill!=-1)
-	        id = instanceRandom.nextInt(kernels.size());
-	
-	    String message = kernels.get(id).fadeOut();
-	    return message;
-    }
-    
-    private String fadeIn(){
-	    	GeneratorCluster gc = new GeneratorCluster(clusterIdCounter++);
-	        kernels.add(gc);
-	        numActiveKernels++;
-	        normalizeWeights();
-    	return "Creating new cluster";
-    }
-    
-    
-    private String changeWeight(boolean increase){
-        double changeRate = 0.1;
-        int id = instanceRandom.nextInt(kernels.size());
-        while(kernels.get(id).kill!=-1)
-            id = instanceRandom.nextInt(kernels.size());
-
-        int sign = 1;
-        if(!increase)
-            sign = -1;
-        double weight_old = kernels.get(id).generator.getWeight();
-        double delta = sign*numActiveKernels*instanceRandom.nextDouble()*changeRate;
-        kernels.get(id).generator.setWeight(weight_old+delta);
-
-        normalizeWeights();
-
-        String message;
-        if(increase)
-            message = "Increase ";
-        else
-            message = "Decrease ";
-        message+=" weight on Cluster "+id+" from "+weight_old+" to "+(weight_old+delta);
-        return message;
-
-
-    }
-
-    private String changeRadius(boolean increase){
-        double maxChangeRate = 0.1;
-        int id = instanceRandom.nextInt(kernels.size());
-        while(kernels.get(id).kill!=-1)
-            id = instanceRandom.nextInt(kernels.size());
-
-        int sign = 1;
-        if(!increase)
-            sign = -1;
-
-        double r_old = kernels.get(id).generator.getRadius();
-        double r_new =r_old+sign*r_old*instanceRandom.nextDouble()*maxChangeRate;
-        if(r_new >= 0.5) return "Radius to big";
-        kernels.get(id).generator.setRadius(r_new);
-        
-        String message;
-        if(increase)
-            message = "Increase ";
-        else
-            message = "Decrease ";
-        message+=" radius on Cluster "+id+" from "+r_old+" to "+r_new;
-        return message;
-    }
-
-    private String splitKernel(){
-        int id = instanceRandom.nextInt(kernels.size());
-        while(kernels.get(id).kill!=-1)
-            id = instanceRandom.nextInt(kernels.size());
-
-        String message = kernels.get(id).splitKernel();
-
-        return message;
-    }
-
-    private String mergeKernels(int steps){
-        if(numActiveKernels >1 && ((mergeClusterA == null && mergeClusterB == null))){
-
-        	//choose clusters to merge
-        	double diseredDist = steps / speedOption.getValue() * maxDistanceMoveThresholdByStep;
-        	double minDist = Double.MAX_VALUE;
+				// we have a limit. if lower limit, choose create
+				if (lowerLimit)
+					choice = 3;
+				// otherwise we reached upper level, choose delete
+				else
+					choice = 2;
+			}
+		}
+
+		return choice;
+	}
+
+	private String fadeOut() {
+		int id = instanceRandom.nextInt(kernels.size());
+		while (kernels.get(id).kill != -1)
+			id = instanceRandom.nextInt(kernels.size());
+
+		String message = kernels.get(id).fadeOut();
+		return message;
+	}
+
+	private String fadeIn() {
+		GeneratorCluster gc = new GeneratorCluster(clusterIdCounter++);
+		kernels.add(gc);
+		numActiveKernels++;
+		normalizeWeights();
+		return "Creating new cluster";
+	}
+
+	private String changeWeight(boolean increase) {
+		double changeRate = 0.1;
+		int id = instanceRandom.nextInt(kernels.size());
+		while (kernels.get(id).kill != -1)
+			id = instanceRandom.nextInt(kernels.size());
+
+		int sign = 1;
+		if (!increase)
+			sign = -1;
+		double weight_old = kernels.get(id).generator.getWeight();
+		double delta = sign * numActiveKernels * instanceRandom.nextDouble() * changeRate;
+		kernels.get(id).generator.setWeight(weight_old + delta);
+
+		normalizeWeights();
+
+		String message;
+		if (increase)
+			message = "Increase ";
+		else
+			message = "Decrease ";
+		message += " weight on Cluster " + id + " from " + weight_old + " to " + (weight_old + delta);
+		return message;
+
+	}
+
+	private String changeRadius(boolean increase) {
+		double maxChangeRate = 0.1;
+		int id = instanceRandom.nextInt(kernels.size());
+		while (kernels.get(id).kill != -1)
+			id = instanceRandom.nextInt(kernels.size());
+
+		int sign = 1;
+		if (!increase)
+			sign = -1;
+
+		double r_old = kernels.get(id).generator.getRadius();
+		double r_new = r_old + sign * r_old * instanceRandom.nextDouble() * maxChangeRate;
+		if (r_new >= 0.5)
+			return "Radius to big";
+		kernels.get(id).generator.setRadius(r_new);
+
+		String message;
+		if (increase)
+			message = "Increase ";
+		else
+			message = "Decrease ";
+		message += " radius on Cluster " + id + " from " + r_old + " to " + r_new;
+		return message;
+	}
+
+	private String splitKernel() {
+		int id = instanceRandom.nextInt(kernels.size());
+		while (kernels.get(id).kill != -1)
+			id = instanceRandom.nextInt(kernels.size());
+
+		String message = kernels.get(id).splitKernel();
+
+		return message;
+	}
+
+	private String mergeKernels(int steps) {
+		if (numActiveKernels > 1 && ((mergeClusterA == null && mergeClusterB == null))) {
+
+			// choose clusters to merge
+			double diseredDist = steps / speedOption.getValue() * maxDistanceMoveThresholdByStep;
+			double minDist = Double.MAX_VALUE;
 //        	System.out.println("DisredDist:"+(2*diseredDist));
-        	for(int i = 0; i < kernels.size(); i++){
-        		for(int j = 0; j < i; j++){
-            		if(kernels.get(i).kill!=-1 || kernels.get(j).kill!=-1){
-            			continue;
-            		}
-            		else{
-            			double kernelDist = kernels.get(i).generator.getCenterDistance(kernels.get(j).generator);
-            			double d = kernelDist-2*diseredDist;
+			for (int i = 0; i < kernels.size(); i++) {
+				for (int j = 0; j < i; j++) {
+					if (kernels.get(i).kill != -1 || kernels.get(j).kill != -1) {
+						continue;
+					} else {
+						double kernelDist = kernels.get(i).generator.getCenterDistance(kernels.get(j).generator);
+						double d = kernelDist - 2 * diseredDist;
 //            			System.out.println("Dist:"+i+" / "+j+" "+d);
-            			if(Math.abs(d) < minDist && 
-            					(minDist != Double.MAX_VALUE || d>0 || Math.abs(d) < 0.001)){
-            				minDist = Math.abs(d);
-            				mergeClusterA = kernels.get(i);
-            				mergeClusterB = kernels.get(j);
-            			}
-            		}
-        		}
-        	}
-        	
-        	if(mergeClusterA!=null && mergeClusterB!=null){
-	        	double[] merge_point = mergeClusterA.generator.getCenter();
-	        	double[] v = mergeClusterA.generator.getDistanceVector(mergeClusterB.generator);
-	        	for (int i = 0; i < v.length; i++) {
-	        		merge_point[i]= merge_point[i]+v[i]*0.5;
+						if (Math.abs(d) < minDist && (minDist != Double.MAX_VALUE || d > 0 || Math.abs(d) < 0.001)) {
+							minDist = Math.abs(d);
+							mergeClusterA = kernels.get(i);
+							mergeClusterB = kernels.get(j);
+						}
+					}
 				}
-	
-	            mergeClusterA.merging = true;
-	            mergeClusterB.merging = true;
-	            mergeClusterA.setDesitnation(merge_point);
-	            mergeClusterB.setDesitnation(merge_point);
-	            
-	            if(debug){
-	            	System.out.println("Center1"+Arrays.toString(mergeClusterA.generator.getCenter()));
-		        	System.out.println("Center2"+Arrays.toString(mergeClusterB.generator.getCenter()));
-		            System.out.println("Vector"+Arrays.toString(v));        	
-	            	
-	                System.out.println("Try to merge cluster "+mergeClusterA.generator.getId()+
-	                        " into "+mergeClusterB.generator.getId()+
-	                        " at "+Arrays.toString(merge_point)+
-	                        " time "+numGeneratedInstances);
-	            }
-	            return "Init merge";
-        	}
-        }
-
-        if(mergeClusterA != null && mergeClusterB != null){
-
-            //movekernels will move the kernels close to each other,
-            //we just need to check and merge here if they are close enough
-            return mergeClusterA.tryMerging(mergeClusterB);
-        }
-
-        return "";
-    }
-
-
-
-
-/************************* TOOLS **************************************/
-
-    public void getDescription(StringBuilder sb, int indent) {
-
-    }
-
-    private double[] getNoisePoint(){
-        double [] sample = new double [numAttsOption.getValue()];
-        boolean incluster = true;
-        int counter = 20;
-        while(incluster){
-            for (int j = 0; j < numAttsOption.getValue(); j++) {
-                 sample[j] = instanceRandom.nextDouble();
-            }
-            incluster = false;
-            if(!noiseInClusterOption.isSet() && counter > 0){
-                counter--;
-                for(int c = 0; c < kernels.size(); c++){
-                    for(int m = 0; m < kernels.get(c).microClusters.size(); m++){
-                        Instance inst = new DenseInstance(1, sample);
-                        if(kernels.get(c).microClusters.get(m).getInclusionProbability(inst) > 0){
-                            incluster = true;
-                            break;
-                        }
-                    }
-                    if(incluster)
-                        break;
-                }
-            }
-        }
+			}
+
+			if (mergeClusterA != null && mergeClusterB != null) {
+				double[] merge_point = mergeClusterA.generator.getCenter();
+				double[] v = mergeClusterA.generator.getDistanceVector(mergeClusterB.generator);
+				for (int i = 0; i < v.length; i++) {
+					merge_point[i] = merge_point[i] + v[i] * 0.5;
+				}
+
+				mergeClusterA.merging = true;
+				mergeClusterB.merging = true;
+				mergeClusterA.setDesitnation(merge_point);
+				mergeClusterB.setDesitnation(merge_point);
+
+				if (debug) {
+					System.out.println("Center1" + Arrays.toString(mergeClusterA.generator.getCenter()));
+					System.out.println("Center2" + Arrays.toString(mergeClusterB.generator.getCenter()));
+					System.out.println("Vector" + Arrays.toString(v));
+
+					System.out.println("Try to merge cluster " + mergeClusterA.generator.getId() + " into "
+							+ mergeClusterB.generator.getId() + " at " + Arrays.toString(merge_point) + " time "
+							+ numGeneratedInstances);
+				}
+				return "Init merge";
+			}
+		}
+
+		if (mergeClusterA != null && mergeClusterB != null) {
+
+			// movekernels will move the kernels close to each other,
+			// we just need to check and merge here if they are close enough
+			return mergeClusterA.tryMerging(mergeClusterB);
+		}
+
+		return "";
+	}
+
+	/************************* TOOLS **************************************/
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+
+	}
+
+	private double[] getNoisePoint() {
+		double[] sample = new double[numAttsOption.getValue()];
+		boolean incluster = true;
+		int counter = 20;
+		while (incluster) {
+			for (int j = 0; j < numAttsOption.getValue(); j++) {
+				sample[j] = instanceRandom.nextDouble();
+			}
+			incluster = false;
+			if (!noiseInClusterOption.isSet() && counter > 0) {
+				counter--;
+				for (int c = 0; c < kernels.size(); c++) {
+					for (int m = 0; m < kernels.get(c).microClusters.size(); m++) {
+						Instance inst = new DenseInstance(1, sample);
+						if (kernels.get(c).microClusters.get(m).getInclusionProbability(inst) > 0) {
+							incluster = true;
+							break;
+						}
+					}
+					if (incluster)
+						break;
+				}
+			}
+		}
 
 //        double [] sample = new double [numAttsOption.getValue()];
 //        for (int j = 0; j < numAttsOption.getValue(); j++) {
 //             sample[j] = instanceRandom.nextDouble();
 //        }
-             
-        return sample;
-    }
-
-     private int chooseWeightedElement() {
-        double r = instanceRandom.nextDouble();
-
-        // Determine index of choosen element
-        int i = 0;
-        while (r > 0.0) {
-            r -= kernels.get(i).generator.getWeight();
-            i++;
-        }
-        --i;	// Overcounted once
-        //System.out.println(i);
-        return i;
-    }
-
-    private void normalizeWeights(){
-        double sumWeights = 0.0;
-        for (int i = 0; i < kernels.size(); i++) {
-            sumWeights+=kernels.get(i).generator.getWeight();
-        }
-        for (int i = 0; i < kernels.size(); i++) {
-            kernels.get(i).generator.setWeight(kernels.get(i).generator.getWeight()/sumWeights);
-        }
-    }
-
-
-
- /*************** EVENT Listener *********************/
- // should go into the superclass of the generator, create new one for cluster streams?
-  
-  /** Add a listener */
-  synchronized public void addClusterChangeListener(ClusterEventListener l) {
-    if (listeners == null)
-      listeners = new Vector();
-    listeners.addElement(l);
-  }
-
-  /** Remove a listener */
-  synchronized public void removeClusterChangeListener(ClusterEventListener l) {
-    if (listeners == null)
-      listeners = new Vector();
-    listeners.removeElement(l);
-  }
-
-  /** Fire a ClusterChangeEvent to all registered listeners */
-  protected void fireClusterChange(long timestamp, String type, String message) {
-    // if we have no listeners, do nothing...
-    if (listeners != null && !listeners.isEmpty()) {
-      // create the event object to send
-      ClusterEvent event =
-        new ClusterEvent(this, timestamp, type , message);
-
-      // make a copy of the listener list in case
-      //   anyone adds/removes listeners
-      Vector targets;
-      synchronized (this) {
-        targets = (Vector) listeners.clone();
-      }
-
-      // walk through the listener list and
-      //   call the sunMoved method in each
-      Enumeration e = targets.elements();
-      while (e.hasMoreElements()) {
-        ClusterEventListener l = (ClusterEventListener) e.nextElement();
-        l.changeCluster(event);
-
-      }
-    }
-  }
-
-    @Override
-    public String getPurposeString() {
-            return "Generates a random radial basis function stream.";
-    }
-
-
-    public String getParameterString(){
-        return "";
-    }
 
+		return sample;
+	}
+
+	private int chooseWeightedElement() {
+		double r = instanceRandom.nextDouble();
+
+		// Determine index of choosen element
+		int i = 0;
+		while (r > 0.0) {
+			r -= kernels.get(i).generator.getWeight();
+			i++;
+		}
+		--i; // Overcounted once
+		// System.out.println(i);
+		return i;
+	}
+
+	private void normalizeWeights() {
+		double sumWeights = 0.0;
+		for (int i = 0; i < kernels.size(); i++) {
+			sumWeights += kernels.get(i).generator.getWeight();
+		}
+		for (int i = 0; i < kernels.size(); i++) {
+			kernels.get(i).generator.setWeight(kernels.get(i).generator.getWeight() / sumWeights);
+		}
+	}
+
+	/*************** EVENT Listener *********************/
+	// should go into the superclass of the generator, create new one for cluster
+	// streams?
+
+	/** Add a listener */
+	synchronized public void addClusterChangeListener(ClusterEventListener l) {
+		if (listeners == null)
+			listeners = new Vector();
+		listeners.addElement(l);
+	}
+
+	/** Remove a listener */
+	synchronized public void removeClusterChangeListener(ClusterEventListener l) {
+		if (listeners == null)
+			listeners = new Vector();
+		listeners.removeElement(l);
+	}
+
+	/** Fire a ClusterChangeEvent to all registered listeners */
+	protected void fireClusterChange(long timestamp, String type, String message) {
+		// if we have no listeners, do nothing...
+		if (listeners != null && !listeners.isEmpty()) {
+			// create the event object to send
+			ClusterEvent event = new ClusterEvent(this, timestamp, type, message);
+
+			// make a copy of the listener list in case
+			// anyone adds/removes listeners
+			Vector targets;
+			synchronized (this) {
+				targets = (Vector) listeners.clone();
+			}
+
+			// walk through the listener list and
+			// call the sunMoved method in each
+			Enumeration e = targets.elements();
+			while (e.hasMoreElements()) {
+				ClusterEventListener l = (ClusterEventListener) e.nextElement();
+				l.changeCluster(event);
+
+			}
+		}
+	}
 
+	@Override
+	public String getPurposeString() {
+		return "Generates a random radial basis function stream.";
+	}
 
+	public String getParameterString() {
+		return "";
+	}
 
 }
diff --git a/moa/src/main/java/moa/streams/clustering/SimpleCSVStream.java b/moa/src/main/java/moa/streams/clustering/SimpleCSVStream.java
index 946b5d728..a492b6bd8 100644
--- a/moa/src/main/java/moa/streams/clustering/SimpleCSVStream.java
+++ b/moa/src/main/java/moa/streams/clustering/SimpleCSVStream.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams.clustering;
 
@@ -51,14 +51,11 @@ public class SimpleCSVStream extends ClusteringStream {
 
 	String defaultfile = "/Users/kokomo40/Dropbox/BT Kim/Datasets/KDDCUP99/KDDCup99.arff";
 
-	public FileOption csvFileOption = new FileOption("csvFile", 'f',
-			"CSV file to load.", defaultfile, "csv", false);
+	public FileOption csvFileOption = new FileOption("csvFile", 'f', "CSV file to load.", defaultfile, "csv", false);
 
-	public StringOption splitCharOption = new StringOption("splitChar", 's',
-			"Input CSV split character", ",");
+	public StringOption splitCharOption = new StringOption("splitChar", 's', "Input CSV split character", ",");
 
-	public FlagOption classIndexOption = new FlagOption("classIndex", 'c',
-			"Last attribute is class index.");
+	public FlagOption classIndexOption = new FlagOption("classIndex", 'c', "Last attribute is class index.");
 
 	protected InstancesHeader dataset;
 
@@ -77,9 +74,9 @@ public class SimpleCSVStream extends ClusteringStream {
 	protected InputStreamProgressMonitor fileProgressMonitor;
 
 	/**
-	 * Creates a simple ClusteringStream for csv files. Adds if necessary a
-	 * class attribute with an identical default value.
-	 * 
+	 * Creates a simple ClusteringStream for csv files. Adds if necessary a class
+	 * attribute with an identical default value.
+	 *
 	 */
 	public SimpleCSVStream() {
 		this.numAttsOption = null;
@@ -95,7 +92,7 @@ public SimpleCSVStream() {
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see moa.options.AbstractOptionHandler#getPurposeString()
 	 */
 	@Override
@@ -105,20 +102,19 @@ public String getPurposeString() {
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see
-	 * moa.options.AbstractOptionHandler#prepareForUseImpl(moa.tasks.TaskMonitor
-	 * , moa.core.ObjectRepository)
+	 * moa.options.AbstractOptionHandler#prepareForUseImpl(moa.tasks.TaskMonitor ,
+	 * moa.core.ObjectRepository)
 	 */
 	@Override
-	public void prepareForUseImpl(TaskMonitor monitor,
-			ObjectRepository repository) {
+	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
 		restart();
 	}
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see moa.streams.InstanceStream#getHeader()
 	 */
 	@Override
@@ -128,7 +124,7 @@ public InstancesHeader getHeader() {
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see moa.streams.InstanceStream#estimatedRemainingInstances()
 	 */
 	@Override
@@ -142,7 +138,7 @@ public long estimatedRemainingInstances() {
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see moa.streams.InstanceStream#hasMoreInstances()
 	 */
 	@Override
@@ -152,7 +148,7 @@ public boolean hasMoreInstances() {
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see moa.streams.InstanceStream#nextInstance()
 	 */
 	@Override
@@ -169,12 +165,10 @@ public InstanceExample nextInstance() {
 					break;
 				}
 				line = line.trim();
-			} while (line.isEmpty() || line.charAt(0) == '%'
-					|| line.charAt(0) == '@');
+			} while (line.isEmpty() || line.charAt(0) == '%' || line.charAt(0) == '@');
 
 			if (line != null) {
-				StringTokenizer token = new StringTokenizer(line,
-						splitCharOption.getValue());
+				StringTokenizer token = new StringTokenizer(line, splitCharOption.getValue());
 
 				double[] value = new double[this.numAttributes];
 				int i;
@@ -182,8 +176,7 @@ public InstanceExample nextInstance() {
 					value[i] = Double.valueOf(token.nextToken());
 				}
 				if (i < this.numTokens || token.hasMoreTokens()) {
-					throw new RuntimeException(
-							"Next Instance has an wrong cardinality!");
+					throw new RuntimeException("Next Instance has an wrong cardinality!");
 				}
 				this.lastInstanceRead = new InstanceExample(new DenseInstance(1, value));
 				this.lastInstanceRead.getData().setDataset(this.dataset);
@@ -200,7 +193,7 @@ public InstanceExample nextInstance() {
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see moa.streams.InstanceStream#isRestartable()
 	 */
 	@Override
@@ -210,7 +203,7 @@ public boolean isRestartable() {
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see moa.streams.InstanceStream#restart()
 	 */
 	@Override
@@ -219,12 +212,9 @@ public void restart() {
 			if (fileReader != null) {
 				fileReader.close();
 			}
-			InputStream fileStream = new FileInputStream(
-					this.csvFileOption.getFile());
-			this.fileProgressMonitor = new InputStreamProgressMonitor(
-					fileStream);
-			this.fileReader = new BufferedReader(new InputStreamReader(
-					fileProgressMonitor));
+			InputStream fileStream = new FileInputStream(this.csvFileOption.getFile());
+			this.fileProgressMonitor = new InputStreamProgressMonitor(fileStream);
+			this.fileReader = new BufferedReader(new InputStreamReader(fileProgressMonitor));
 
 			String line;
 			do {
@@ -233,29 +223,23 @@ public void restart() {
 					break;
 				}
 				line = line.trim();
-			} while (line.isEmpty() || line.charAt(0) == '%'
-					|| line.charAt(0) == '@');
+			} while (line.isEmpty() || line.charAt(0) == '%' || line.charAt(0) == '@');
 
 			if (line != null) {
-				StringTokenizer token = new StringTokenizer(line,
-						splitCharOption.getValue());
+				StringTokenizer token = new StringTokenizer(line, splitCharOption.getValue());
 				this.numTokens = token.countTokens();
-				this.numAttributes = this.numTokens
-						- (classIndexOption.isSet() ? 1 : 0) + 1;
+				this.numAttributes = this.numTokens - (classIndexOption.isSet() ? 1 : 0) + 1;
 
-				ArrayList<Attribute> attributes = new ArrayList<Attribute>(
-						this.numAttributes);
+				ArrayList<Attribute> attributes = new ArrayList<>(this.numAttributes);
 				for (int i = 1; i < this.numAttributes; i++) {
 					attributes.add(new Attribute("Dim " + i));
 				}
-				ArrayList<String> classLabels = new ArrayList<String>();
+				ArrayList<String> classLabels = new ArrayList<>();
 				classLabels.add("0");
-		        attributes.add(new Attribute("class", classLabels));
-				this.dataset = new InstancesHeader(csvFileOption.getFile().getName(),
-						attributes, 0);
+				attributes.add(new Attribute("class", classLabels));
+				this.dataset = new InstancesHeader(csvFileOption.getFile().getName(), attributes, 0);
 				this.dataset.setClassIndex(this.numAttributes - 1);
-				numAttsOption = new IntOption("numAtts", 'a', "",
-						this.numAttributes);
+				numAttsOption = new IntOption("numAtts", 'a', "", this.numAttributes);
 
 				double[] value = new double[this.numAttributes];
 				for (int i = 0; i < this.numTokens && token.hasMoreTokens(); i++) {
@@ -277,7 +261,7 @@ public void restart() {
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see moa.MOAObject#getDescription(java.lang.StringBuilder, int)
 	 */
 	@Override
diff --git a/moa/src/main/java/moa/streams/filters/AbstractMultiLabelStreamFilter.java b/moa/src/main/java/moa/streams/filters/AbstractMultiLabelStreamFilter.java
index 4206ba4ca..a45c81983 100644
--- a/moa/src/main/java/moa/streams/filters/AbstractMultiLabelStreamFilter.java
+++ b/moa/src/main/java/moa/streams/filters/AbstractMultiLabelStreamFilter.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams.filters;
 
@@ -33,49 +33,48 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public abstract class AbstractMultiLabelStreamFilter extends AbstractOptionHandler
-        implements MultiLabelStreamFilter {
+public abstract class AbstractMultiLabelStreamFilter extends AbstractOptionHandler implements MultiLabelStreamFilter {
 
-    /** The input stream to this filter. */
-    protected ExampleStream<Example<Instance>> inputStream;
+	/** The input stream to this filter. */
+	protected ExampleStream<Example<Instance>> inputStream;
 
-    @Override
-    public void setInputStream(ExampleStream<Example<Instance>> stream) {
-        this.inputStream = stream;
-        prepareForUse();
-    }
+	@Override
+	public void setInputStream(ExampleStream<Example<Instance>> stream) {
+		this.inputStream = stream;
+		prepareForUse();
+	}
 
-    @Override
-    public void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        restartImpl();
-    }
+	@Override
+	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		restartImpl();
+	}
 
-    @Override
-    public long estimatedRemainingInstances() {
-        return this.inputStream.estimatedRemainingInstances();
-    }
+	@Override
+	public long estimatedRemainingInstances() {
+		return this.inputStream.estimatedRemainingInstances();
+	}
 
-    @Override
-    public boolean hasMoreInstances() {
-        return this.inputStream.hasMoreInstances();
-    }
+	@Override
+	public boolean hasMoreInstances() {
+		return this.inputStream.hasMoreInstances();
+	}
 
-    @Override
-    public boolean isRestartable() {
-        return this.inputStream.isRestartable();
-    }
+	@Override
+	public boolean isRestartable() {
+		return this.inputStream.isRestartable();
+	}
 
-    @Override
-    public void restart() {
-        this.inputStream.restart();
-        restartImpl();
-    }
+	@Override
+	public void restart() {
+		this.inputStream.restart();
+		restartImpl();
+	}
 
-    /**
-     * Restarts this filter. All instances that extends from
-     * <code>AbstractStreamFilter</code> must implement <code>restartImpl</code>.
-     * <code>restart</code> uses <code>restartImpl</code> in <code>AbstractStreamFilter</code>.
-     */
-    protected abstract void restartImpl();
+	/**
+	 * Restarts this filter. All instances that extends from
+	 * <code>AbstractStreamFilter</code> must implement <code>restartImpl</code>.
+	 * <code>restart</code> uses <code>restartImpl</code> in
+	 * <code>AbstractStreamFilter</code>.
+	 */
+	protected abstract void restartImpl();
 }
diff --git a/moa/src/main/java/moa/streams/filters/AbstractStreamFilter.java b/moa/src/main/java/moa/streams/filters/AbstractStreamFilter.java
index 29b691cc1..97856db96 100644
--- a/moa/src/main/java/moa/streams/filters/AbstractStreamFilter.java
+++ b/moa/src/main/java/moa/streams/filters/AbstractStreamFilter.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams.filters;
 
@@ -33,60 +33,59 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public abstract class AbstractStreamFilter extends AbstractOptionHandler
-        implements StreamFilter {
+public abstract class AbstractStreamFilter extends AbstractOptionHandler implements StreamFilter {
+
+	/** The input stream to this filter. */
+	protected ExampleStream inputStream;
+
+	@Override
+	public void setInputStream(ExampleStream stream) {
+		this.inputStream = stream;
+		prepareForUse();
+	}
 
-    /** The input stream to this filter. */
-    protected ExampleStream inputStream;
+	@Override
+	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		restartImpl();
+	}
 
-    @Override
-    public void setInputStream(ExampleStream stream) {
-        this.inputStream = stream;
-        prepareForUse();
-    }
+	@Override
+	public long estimatedRemainingInstances() {
+		return this.inputStream.estimatedRemainingInstances();
+	}
 
-    @Override
-    public void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        restartImpl();
-    }
+	@Override
+	public boolean hasMoreInstances() {
+		return this.inputStream.hasMoreInstances();
+	}
 
-    @Override
-    public long estimatedRemainingInstances() {
-        return this.inputStream.estimatedRemainingInstances();
-    }
+	@Override
+	public boolean isRestartable() {
+		return this.inputStream.isRestartable();
+	}
 
-    @Override
-    public boolean hasMoreInstances() {
-        return this.inputStream.hasMoreInstances();
-    }
+	@Override
+	public void restart() {
+		this.inputStream.restart();
+		restartImpl();
+	}
 
-    @Override
-    public boolean isRestartable() {
-        return this.inputStream.isRestartable();
-    }
+	/**
+	 * Restarts this filter. All instances that extends from
+	 * <code>AbstractStreamFilter</code> must implement <code>restartImpl</code>.
+	 * <code>restart</code> uses <code>restartImpl</code> in
+	 * <code>AbstractStreamFilter</code>.
+	 */
+	protected abstract void restartImpl();
 
-    @Override
-    public void restart() {
-        this.inputStream.restart();
-        restartImpl();
-    }
+	@Override
+	public InstanceExample nextInstance() {
+		Instance inst = ((Instance) this.inputStream.nextInstance().getData()).copy();
+		return new InstanceExample(filterInstance(inst));
+	}
 
-    /**
-     * Restarts this filter. All instances that extends from
-     * <code>AbstractStreamFilter</code> must implement <code>restartImpl</code>.
-     * <code>restart</code> uses <code>restartImpl</code> in <code>AbstractStreamFilter</code>.
-     */
-    protected abstract void restartImpl();
-    
-    @Override
-    public InstanceExample nextInstance() {
-         Instance inst = (Instance) ((Instance) this.inputStream.nextInstance().getData()).copy();
-         return new InstanceExample(filterInstance(inst));
-    }
-    
-    @Override
-    public Instance filterInstance(Instance inst) {
-        return inst;
-    }
+	@Override
+	public Instance filterInstance(Instance inst) {
+		return inst;
+	}
 }
diff --git a/moa/src/main/java/moa/streams/filters/AddNoiseFilter.java b/moa/src/main/java/moa/streams/filters/AddNoiseFilter.java
index 7787ae0b1..9962c62c3 100644
--- a/moa/src/main/java/moa/streams/filters/AddNoiseFilter.java
+++ b/moa/src/main/java/moa/streams/filters/AddNoiseFilter.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams.filters;
 
@@ -31,86 +31,84 @@
 import moa.core.GaussianEstimator;
 
 /**
- * Filter for adding random noise to examples in a stream.
- * Noise can be added to attribute values or to class labels.
+ * Filter for adding random noise to examples in a stream. Noise can be added to
+ * attribute values or to class labels.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
 public class AddNoiseFilter extends AbstractStreamFilter {
 
-    @Override
-    public String getPurposeString() {
-        return "Adds random noise to examples in a stream.";
-    }
+	@Override
+	public String getPurposeString() {
+		return "Adds random noise to examples in a stream.";
+	}
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public IntOption randomSeedOption = new IntOption("randomSeed", 'r',
-            "Seed for random noise.", 1);
+	public IntOption randomSeedOption = new IntOption("randomSeed", 'r', "Seed for random noise.", 1);
 
-    public FloatOption attNoiseFractionOption = new FloatOption("attNoise",
-            'a', "The fraction of attribute values to disturb.", 0.1, 0.0, 1.0);
+	public FloatOption attNoiseFractionOption = new FloatOption("attNoise", 'a',
+			"The fraction of attribute values to disturb.", 0.1, 0.0, 1.0);
 
-    public FloatOption classNoiseFractionOption = new FloatOption("classNoise",
-            'c', "The fraction of class labels to disturb.", 0.1, 0.0, 1.0);
+	public FloatOption classNoiseFractionOption = new FloatOption("classNoise", 'c',
+			"The fraction of class labels to disturb.", 0.1, 0.0, 1.0);
 
-    protected Random random;
+	protected Random random;
 
-    protected AutoExpandVector<Object> attValObservers;
+	protected AutoExpandVector<Object> attValObservers;
 
-    @Override
-    protected void restartImpl() {
-        this.random = new Random(this.randomSeedOption.getValue());
-        this.attValObservers = new AutoExpandVector<Object>();
-    }
+	@Override
+	protected void restartImpl() {
+		this.random = new Random(this.randomSeedOption.getValue());
+		this.attValObservers = new AutoExpandVector<>();
+	}
 
-    @Override
-    public InstancesHeader getHeader() {
-        return this.inputStream.getHeader();
-    }
+	@Override
+	public InstancesHeader getHeader() {
+		return this.inputStream.getHeader();
+	}
 
-    //@Override
-    //public InstanceExample nextInstance() {
-    //    Instance inst = (Instance) ((Instance) this.inputStream.nextInstance().getData()).copy();
-    public Instance filterInstance(Instance inst){
-        for (int i = 0; i < inst.numAttributes(); i++) {
-            double noiseFrac = i == inst.classIndex() ? this.classNoiseFractionOption.getValue()
-                    : this.attNoiseFractionOption.getValue();
-            if (inst.attribute(i).isNominal()) {
-                DoubleVector obs = (DoubleVector) this.attValObservers.get(i);
-                if (obs == null) {
-                    obs = new DoubleVector();
-                    this.attValObservers.set(i, obs);
-                }
-                int originalVal = (int) inst.value(i);
-                if (!inst.isMissing(i)) {
-                    obs.addToValue(originalVal, inst.weight());
-                }
-                if ((this.random.nextDouble() < noiseFrac)
-                        && (obs.numNonZeroEntries() > 1)) {
-                    do {
-                        inst.setValue(i, this.random.nextInt(obs.numValues()));
-                    } while (((int) inst.value(i) == originalVal)
-                            || (obs.getValue((int) inst.value(i)) == 0.0));
-                }
-            } else {
-                GaussianEstimator obs = (GaussianEstimator) this.attValObservers.get(i);
-                if (obs == null) {
-                    obs = new GaussianEstimator();
-                    this.attValObservers.set(i, obs);
-                }
-                obs.addObservation(inst.value(i), inst.weight());
-                inst.setValue(i, inst.value(i) + this.random.nextGaussian()
-                        * obs.getStdDev() * noiseFrac);
-            }
-        }
-        //return new InstanceExample(inst);
-        return inst;
-    }
+	// @Override
+	// public InstanceExample nextInstance() {
+	// Instance inst = (Instance) ((Instance)
+	// this.inputStream.nextInstance().getData()).copy();
+	@Override
+	public Instance filterInstance(Instance inst) {
+		for (int i = 0; i < inst.numAttributes(); i++) {
+			double noiseFrac = i == inst.classIndex() ? this.classNoiseFractionOption.getValue()
+					: this.attNoiseFractionOption.getValue();
+			if (inst.attribute(i).isNominal()) {
+				DoubleVector obs = (DoubleVector) this.attValObservers.get(i);
+				if (obs == null) {
+					obs = new DoubleVector();
+					this.attValObservers.set(i, obs);
+				}
+				int originalVal = (int) inst.value(i);
+				if (!inst.isMissing(i)) {
+					obs.addToValue(originalVal, inst.weight());
+				}
+				if ((this.random.nextDouble() < noiseFrac) && (obs.numNonZeroEntries() > 1)) {
+					do {
+						inst.setValue(i, this.random.nextInt(obs.numValues()));
+					} while (((int) inst.value(i) == originalVal) || (obs.getValue((int) inst.value(i)) == 0.0));
+				}
+			} else {
+				GaussianEstimator obs = (GaussianEstimator) this.attValObservers.get(i);
+				if (obs == null) {
+					obs = new GaussianEstimator();
+					this.attValObservers.set(i, obs);
+				}
+				obs.addObservation(inst.value(i), inst.weight());
+				inst.setValue(i, inst.value(i) + this.random.nextGaussian() * obs.getStdDev() * noiseFrac);
+			}
+		}
+		// return new InstanceExample(inst);
+		return inst;
+	}
 
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
 }
diff --git a/moa/src/main/java/moa/streams/filters/MultiLabelStreamFilter.java b/moa/src/main/java/moa/streams/filters/MultiLabelStreamFilter.java
index 627444695..1c1890614 100644
--- a/moa/src/main/java/moa/streams/filters/MultiLabelStreamFilter.java
+++ b/moa/src/main/java/moa/streams/filters/MultiLabelStreamFilter.java
@@ -8,10 +8,10 @@
 
 public interface MultiLabelStreamFilter extends MultiTargetInstanceStream {
 
-    /**
-     * Sets the input stream to the filter
-     *
-     * @param stream the input stream to the filter
-     */
-    public void setInputStream(ExampleStream<Example<Instance>> stream);
+	/**
+	 * Sets the input stream to the filter
+	 *
+	 * @param stream the input stream to the filter
+	 */
+	void setInputStream(ExampleStream<Example<Instance>> stream);
 }
diff --git a/moa/src/main/java/moa/streams/filters/RBFFilter.java b/moa/src/main/java/moa/streams/filters/RBFFilter.java
index 3a7e787a8..ddffedcf4 100644
--- a/moa/src/main/java/moa/streams/filters/RBFFilter.java
+++ b/moa/src/main/java/moa/streams/filters/RBFFilter.java
@@ -20,15 +20,16 @@ public class RBFFilter extends AbstractStreamFilter {
 	private static final long serialVersionUID = 1L;
 	protected InstancesHeader dataset;
 	public IntOption randomSeedOption = new IntOption("randomSeed", 'r', "Seed for random noise.", 1);
-	public IntOption numLatentOption = new IntOption("numLatent", 'h', "Number of latent variables in the projected space.", 1);
+	public IntOption numLatentOption = new IntOption("numLatent", 'h',
+			"Number of latent variables in the projected space.", 1);
 	protected Random random;
 	protected double c[];
 	protected double r[];
 
-    @Override
-    public String getPurposeString() {
-        return "Creates a random projection of the feature space with RBF functions.";
-    }
+	@Override
+	public String getPurposeString() {
+		return "Creates a random projection of the feature space with RBF functions.";
+	}
 
 	@Override
 	public InstancesHeader getHeader() {
@@ -38,37 +39,37 @@ public InstancesHeader getHeader() {
 	@Override
 	public InstanceExample nextInstance() {
 
-		Instance x = (Instance) ((Instance) this.inputStream.nextInstance().getData());
+		Instance x = ((Instance) this.inputStream.nextInstance().getData());
 
-		if(dataset==null){
+		if (dataset == null) {
 			System.out.println("INIT. ");
 			initialize(x);
-		}		
+		}
 
 		double z_[] = new double[dataset.numAttributes()];
-		Instance z = new InstanceImpl(x.weight(),z_);
+		Instance z = new InstanceImpl(x.weight(), z_);
 
 		int d = x.numAttributes();
 		int h = numLatentOption.getValue();
 
-		for(int k = 0; k < h; k++) {
+		for (int k = 0; k < h; k++) {
 			double sum_k = 0.;
-			for(int j = 0; j < d; j++) {
+			for (int j = 0; j < d; j++) {
 				sum_k += (x.value(j) - c[k]);
 			}
-			z.setValue(k,Math.exp(-sum_k));
+			z.setValue(k, Math.exp(-sum_k));
 		}
-		z.setValue(h,x.classValue());
+		z.setValue(h, x.classValue());
 		z.setDataset(dataset);
 
 		return new InstanceExample(z);
 	}
 
 	@Override
-    protected void restartImpl() {
+	protected void restartImpl() {
 		System.out.println("RESET ");
-        this.random = new Random(this.randomSeedOption.getValue());
-    }
+		this.random = new Random(this.randomSeedOption.getValue());
+	}
 
 	private void initialize(Instance instance) {
 
@@ -77,32 +78,31 @@ private void initialize(Instance instance) {
 		// initialize RBF features
 		c = new double[h];
 		r = new double[h];
-		for(int j = 0; j < h; j++) {
+		for (int j = 0; j < h; j++) {
 			c[j] = this.random.nextGaussian();
 			r[j] = this.random.nextDouble();
 		}
 
 		// initialize instance space
 		InstancesHeader ds = new InstancesHeader();
-		List<Attribute> v = new ArrayList<Attribute>(h);
-		List<Integer> indexValues = new ArrayList<Integer>(h);
+		List<Attribute> v = new ArrayList<>(h);
+		List<Integer> indexValues = new ArrayList<>(h);
 
-		for(int j = 0; j < h; j++) {
-			v.add(new Attribute("z"+String.valueOf(j)));
+		for (int j = 0; j < h; j++) {
+			v.add(new Attribute("z" + String.valueOf(j)));
 			indexValues.add(j);
 		}
-		v.add(instance.dataset().classAttribute()); 
+		v.add(instance.dataset().classAttribute());
 		indexValues.add(h);
 
-
 		ds.setAttributes(v);
-		dataset=(new InstancesHeader(ds));
+		dataset = (new InstancesHeader(ds));
 		dataset.setClassIndex(h);
-		System.out.println(""+dataset);
-		System.out.println("classIndex :  "+dataset.classIndex());
-		System.out.println("numClasses :  "+dataset.numClasses());
-		System.out.println("numInstances: "+dataset.numInstances());
-		System.out.println("numAttribute: "+dataset.numAttributes());
+		System.out.println("" + dataset);
+		System.out.println("classIndex :  " + dataset.classIndex());
+		System.out.println("numClasses :  " + dataset.numClasses());
+		System.out.println("numInstances: " + dataset.numInstances());
+		System.out.println("numAttribute: " + dataset.numAttributes());
 	}
 
 	@Override
diff --git a/moa/src/main/java/moa/streams/filters/ReLUFilter.java b/moa/src/main/java/moa/streams/filters/ReLUFilter.java
index 4023e2194..71d86f07d 100644
--- a/moa/src/main/java/moa/streams/filters/ReLUFilter.java
+++ b/moa/src/main/java/moa/streams/filters/ReLUFilter.java
@@ -13,13 +13,14 @@
 public class ReLUFilter extends AbstractStreamFilter {
 
 	/**
-	 * ReLUFilter - A random projection of the filter space. 
-	 * NOTE: Data should be standardized.
+	 * ReLUFilter - A random projection of the filter space. NOTE: Data should be
+	 * standardized.
 	 */
 	private static final long serialVersionUID = 1L;
 	protected InstancesHeader dataset;
 	public IntOption randomSeedOption = new IntOption("randomSeed", 'r', "Seed for random noise.", 1);
-	public IntOption numLatentOption = new IntOption("numLatent", 'h', "Percent of basis functions (wrt number of input attributes).", 10);
+	public IntOption numLatentOption = new IntOption("numLatent", 'h',
+			"Percent of basis functions (wrt number of input attributes).", 10);
 	private int H = 200;
 	protected Random random;
 	protected double W[][];
@@ -35,34 +36,34 @@ public InstancesHeader getHeader() {
 	}
 
 	/**
-	 * Filter an instance.
-	 * Assume that the instance has a single class label, as the final attribute. Note that this may not always be the case!
+	 * Filter an instance. Assume that the instance has a single class label, as the
+	 * final attribute. Note that this may not always be the case!
 	 *
-	 * @param	x	input instance
-	 * @return	output instance
+	 * @param x input instance
+	 * @return output instance
 	 */
+	@Override
 	public Instance filterInstance(Instance x) {
 
-
-		if(dataset==null){
+		if (dataset == null) {
 			initialize(x);
-		}		
+		}
 
-		double z_[] = new double[H+1];
+		double z_[] = new double[H + 1];
 
 		int d = x.numAttributes() - 1; // suppose one class attribute (at the end)
 
-		for(int k = 0; k < H; k++) {
+		for (int k = 0; k < H; k++) {
 			// for each hidden unit ...
-			double a_k = 0.; 								// k-th activation (dot product)
-			for(int j = 0; j < d; j++) {
+			double a_k = 0.; // k-th activation (dot product)
+			for (int j = 0; j < d; j++) {
 				a_k += (x.value(j) * W[k][j]);
 			}
-			z_[k] = (a_k > 0. ? a_k : 0.);				  // <------- can change threshold here
+			z_[k] = (a_k > 0. ? a_k : 0.); // <------- can change threshold here
 		}
 		z_[H] = x.classValue();
 
-		Instance z = new InstanceImpl(x.weight(),z_);
+		Instance z = new InstanceImpl(x.weight(), z_);
 		z.setDataset(dataset);
 
 		return z;
@@ -87,27 +88,26 @@ private void initialize(Instance instance) {
 
 		// initialize ReLU features
 		W = new double[H][d];
-		for(int j = 0; j < H; j++) {
-			for(int k = 0; k < d; k++) {
+		for (int j = 0; j < H; j++) {
+			for (int k = 0; k < d; k++) {
 				W[j][k] = this.random.nextGaussian();
 			}
 		}
 
 		// initialize instance space
 		InstancesHeader ds = new InstancesHeader();
-		List<Attribute> v = new ArrayList<Attribute>(H);
-		List<Integer> indexValues = new ArrayList<Integer>(H);
+		List<Attribute> v = new ArrayList<>(H);
+		List<Integer> indexValues = new ArrayList<>(H);
 
-		for(int j = 0; j < H; j++) {
-			v.add(new Attribute("z"+String.valueOf(j)));
+		for (int j = 0; j < H; j++) {
+			v.add(new Attribute("z" + String.valueOf(j)));
 			indexValues.add(j);
 		}
-		v.add(instance.dataset().classAttribute()); 
+		v.add(instance.dataset().classAttribute());
 		indexValues.add(H);
 
-
 		ds.setAttributes(v);
-		dataset=(new InstancesHeader(ds));
+		dataset = (new InstancesHeader(ds));
 		dataset.setClassIndex(H);
 
 	}
diff --git a/moa/src/main/java/moa/streams/filters/RemoveDiscreteAttributeFilter.java b/moa/src/main/java/moa/streams/filters/RemoveDiscreteAttributeFilter.java
index d5e49c595..413f99a92 100644
--- a/moa/src/main/java/moa/streams/filters/RemoveDiscreteAttributeFilter.java
+++ b/moa/src/main/java/moa/streams/filters/RemoveDiscreteAttributeFilter.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams.filters;
 
@@ -39,67 +39,67 @@
  */
 public class RemoveDiscreteAttributeFilter extends AbstractStreamFilter {
 
-    @Override
-    public String getPurposeString() {
-        return "Removes discrete attribute examples in a stream.";
-    }
-    private static final long serialVersionUID = 1L;
-
-    protected InstancesHeader streamHeader;
-
-    protected List<Integer> numericAttributes;
-    
-    @Override
-    protected void restartImpl() {
-        this.streamHeader = null;
-    }
-
-    @Override
-    public InstancesHeader getHeader() {
-        return streamHeader;
-    }
-
-    @Override
-    public InstanceExample nextInstance() {
-        Instance inst = (Instance) this.inputStream.nextInstance().getData();
-
-        if (streamHeader == null) {
-            //Create a new header
-            FastVector attributes = new FastVector();
-            numericAttributes = new ArrayList<Integer>();
-            for (int i = 0; i < inst.numAttributes(); i++) {
-                if (inst.attribute(i).isNumeric()) {
-                    numericAttributes.add(i);
-                    attributes.addElement(inst.attribute(i));
-                }
-            }
-            attributes.addElement(inst.classAttribute());
-            numericAttributes.add(inst.classIndex());
-            this.streamHeader = new InstancesHeader(new InstancesHeader(
-                    getCLICreationString(InstanceStream.class), attributes, 0));
-            this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
-
-        }
-
-        //Create a new instance
-        double[] vals = new double[getHeader().numAttributes()];
-        for (int i = 0; i < numericAttributes.size(); i++) {
-                vals[i] = inst.value(numericAttributes.get(i));
-        }
-
-        Instance instance = null;
-        if (inst instanceof SparseInstance) {
-            instance = new SparseInstance(inst.weight(), vals);
-        } else {
-            instance = new DenseInstance(inst.weight(), vals);
-        }
-
-
-        return new InstanceExample(instance);
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
+	@Override
+	public String getPurposeString() {
+		return "Removes discrete attribute examples in a stream.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	protected InstancesHeader streamHeader;
+
+	protected List<Integer> numericAttributes;
+
+	@Override
+	protected void restartImpl() {
+		this.streamHeader = null;
+	}
+
+	@Override
+	public InstancesHeader getHeader() {
+		return streamHeader;
+	}
+
+	@Override
+	public InstanceExample nextInstance() {
+		Instance inst = (Instance) this.inputStream.nextInstance().getData();
+
+		if (streamHeader == null) {
+			// Create a new header
+			FastVector attributes = new FastVector();
+			numericAttributes = new ArrayList<>();
+			for (int i = 0; i < inst.numAttributes(); i++) {
+				if (inst.attribute(i).isNumeric()) {
+					numericAttributes.add(i);
+					attributes.addElement(inst.attribute(i));
+				}
+			}
+			attributes.addElement(inst.classAttribute());
+			numericAttributes.add(inst.classIndex());
+			this.streamHeader = new InstancesHeader(
+					new InstancesHeader(getCLICreationString(InstanceStream.class), attributes, 0));
+			this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
+
+		}
+
+		// Create a new instance
+		double[] vals = new double[getHeader().numAttributes()];
+		for (int i = 0; i < numericAttributes.size(); i++) {
+			vals[i] = inst.value(numericAttributes.get(i));
+		}
+
+		Instance instance = null;
+		if (inst instanceof SparseInstance) {
+			instance = new SparseInstance(inst.weight(), vals);
+		} else {
+			instance = new DenseInstance(inst.weight(), vals);
+		}
+
+		return new InstanceExample(instance);
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
 }
diff --git a/moa/src/main/java/moa/streams/filters/ReplacingMissingValuesFilter.java b/moa/src/main/java/moa/streams/filters/ReplacingMissingValuesFilter.java
index 718de5a27..361781a6e 100644
--- a/moa/src/main/java/moa/streams/filters/ReplacingMissingValuesFilter.java
+++ b/moa/src/main/java/moa/streams/filters/ReplacingMissingValuesFilter.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams.filters;
 
@@ -34,111 +34,102 @@
 
 import moa.core.InstanceExample;
 
-
-
 /**
  * Replaces the missing values with another value according to the selected
- * strategy. Available strategies for numerical attributes are: 
- * 1. Nothing: Does nothing (doesn't replace missing values) 
- * 2. LastKnownValue: Replaces with the last non missing value
- * 3. Mean: Replaces with mean of the processed instances so far
- * 4. Max: Replaces with maximum of the processed instances so far
- * 5. Min: Replaces with minimum of the processed instances so far
- * 6. Constant: Replaces with a constant value (default: zero)
- * 
- * Available strategies for nominal attributes are:
- * 1. Nothing: Does nothing (doesn't replace missing values) 
- * 2. LastKnownValue: Replaces with the last non missing value
- * 3. Mode: Replaces with the mode of the processed instances so far (most frequent value)
+ * strategy. Available strategies for numerical attributes are: 1. Nothing: Does
+ * nothing (doesn't replace missing values) 2. LastKnownValue: Replaces with the
+ * last non missing value 3. Mean: Replaces with mean of the processed instances
+ * so far 4. Max: Replaces with maximum of the processed instances so far 5.
+ * Min: Replaces with minimum of the processed instances so far 6. Constant:
+ * Replaces with a constant value (default: zero)
+ *
+ * Available strategies for nominal attributes are: 1. Nothing: Does nothing
+ * (doesn't replace missing values) 2. LastKnownValue: Replaces with the last
+ * non missing value 3. Mode: Replaces with the mode of the processed instances
+ * so far (most frequent value)
+ *
+ * Beware of numerical strategies 2 to 5: if no previous non-missing values were
+ * processed, missing values will be replaced by 0.
  * 
- * Beware of numerical strategies 2 to 5: if no previous non-missing values were processed,
- * missing values will be replaced by 0.
- *   
  * @author Manuel Martin Salvador <draxus@gmail.com>
- * 
+ *
  */
 public class ReplacingMissingValuesFilter extends AbstractStreamFilter {
 
-
 	private static final long serialVersionUID = 1470772215201414815L;
 
-	public MultiChoiceOption numericReplacementStrategyOption = new MultiChoiceOption(
-			"numericReplacementStrategy", 's', "Replacement strategy for numeric attributes", 
-			new String[]{"Nothing", "LastKnownValue", "Mean", "Max", "Min", "Constant"},
-			new String[]{"Does nothing (doesn't replace missing values)",
-					     "Replaces with the last non missing value",
-					     "Replaces with mean of the processed instances so far",
-					     "Replaces with maximum of the processed instances so far",
-					     "Replaces with minimum of the processed instances so far",
-					     "Replaces with a constant value (default: zero)"}
-			, 0);
-	
-	public MultiChoiceOption nominalReplacementStrategyOption = new MultiChoiceOption(
-			"nominalReplacementStrategy", 't', "Replacement strategy for nominal attributes", 
-			new String[]{"Nothing", "LastKnownValue", "Mode"},
-			new String[]{"Does nothing (doesn't replace missing values)",
-					     "Replaces with the last non missing value",
-					     "Replaces with the mode of the processed instances so far (most frequent value)"}
-			, 0);
-
-	public FloatOption numericalConstantValueOption = new FloatOption("numericalConstantValue", 'c', 
+	public MultiChoiceOption numericReplacementStrategyOption = new MultiChoiceOption("numericReplacementStrategy", 's',
+			"Replacement strategy for numeric attributes",
+			new String[] { "Nothing", "LastKnownValue", "Mean", "Max", "Min", "Constant" },
+			new String[] { "Does nothing (doesn't replace missing values)", "Replaces with the last non missing value",
+					"Replaces with mean of the processed instances so far",
+					"Replaces with maximum of the processed instances so far",
+					"Replaces with minimum of the processed instances so far",
+					"Replaces with a constant value (default: zero)" },
+			0);
+
+	public MultiChoiceOption nominalReplacementStrategyOption = new MultiChoiceOption("nominalReplacementStrategy", 't',
+			"Replacement strategy for nominal attributes", new String[] { "Nothing", "LastKnownValue", "Mode" },
+			new String[] { "Does nothing (doesn't replace missing values)", "Replaces with the last non missing value",
+					"Replaces with the mode of the processed instances so far (most frequent value)" },
+			0);
+
+	public FloatOption numericalConstantValueOption = new FloatOption("numericalConstantValue", 'c',
 			"Value used to replace missing values during the numerical constant strategy", 0.0);
-	
+
 	protected int numAttributes = -1;
-	
-	protected double columnsStatistics[] = null; 
-	
+
+	protected double columnsStatistics[] = null;
+
 	protected long numberOfSamples[] = null;
-	
+
 	protected double lastNominalValues[] = null;
-	
+
 	protected HashMap<Double, Integer> frequencies[] = null;
-	
+
 	protected int numericalSelectedStrategy = 0;
 	protected int nominalSelectedStrategy = 0;
-	
-	 @Override
-    public String getPurposeString() {
-        return "Replaces the missing values with another value according to the selected strategy.";
-    }
-	 
+
+	@Override
+	public String getPurposeString() {
+		return "Replaces the missing values with another value according to the selected strategy.";
+	}
+
 	@Override
 	public InstancesHeader getHeader() {
 		return this.inputStream.getHeader();
 	}
 
-    @Override
-    public InstanceExample nextInstance() {
-        Instance inst = (Instance) ((Instance) this.inputStream.nextInstance().getData()).copy();
- 		
+	@Override
+	public InstanceExample nextInstance() {
+		Instance inst = ((Instance) this.inputStream.nextInstance().getData()).copy();
+
 		// Initialization
-		if (numAttributes < 0){
+		if (numAttributes < 0) {
 			numAttributes = inst.numAttributes();
 			columnsStatistics = new double[numAttributes];
 			numberOfSamples = new long[numAttributes];
 			lastNominalValues = new double[numAttributes];
-                        for(int i=0;i <numAttributes;i++){
-                            lastNominalValues[i]=-1;
-                        }
+			for (int i = 0; i < numAttributes; i++) {
+				lastNominalValues[i] = -1;
+			}
 			frequencies = new HashMap[numAttributes];
-			for(int i=0; i< inst.numAttributes(); i++){
-				if(inst.attribute(i).isNominal())
-					frequencies[i] = new HashMap<Double, Integer>();
+			for (int i = 0; i < inst.numAttributes(); i++) {
+				if (inst.attribute(i).isNominal())
+					frequencies[i] = new HashMap<>();
 			}
-			
+
 			numericalSelectedStrategy = this.numericReplacementStrategyOption.getChosenIndex();
 			nominalSelectedStrategy = this.nominalReplacementStrategyOption.getChosenIndex();
 		}
-		
-		
-		
+
 		for (int i = 0; i < numAttributes; i++) {
-			
+
 			// ---- Numerical values ----
 			if (inst.attribute(i).isNumeric()) {
 				// Handle missing value
 				if (inst.isMissing(i)) {
-					switch(numericalSelectedStrategy){
+					switch (numericalSelectedStrategy) {
 					case 0: // NOTHING
 						break;
 					case 1: // LAST KNOWN VALUE
@@ -150,70 +141,78 @@ public InstanceExample nextInstance() {
 					case 5: // CONSTANT
 						inst.setValue(i, numericalConstantValueOption.getValue());
 						break;
-					default: continue;
+					default:
+						continue;
 					}
 				}
 				// Update statistics with non-missing values
-				else{
-					switch(numericalSelectedStrategy){
+				else {
+					switch (numericalSelectedStrategy) {
 					case 1: // LAST KNOWN VALUE
 						columnsStatistics[i] = inst.value(i);
 						break;
 					case 2: // MEAN
 						numberOfSamples[i]++;
-						columnsStatistics[i] = columnsStatistics[i] + (inst.value(i) - columnsStatistics[i])/numberOfSamples[i];
+						columnsStatistics[i] = columnsStatistics[i]
+								+ (inst.value(i) - columnsStatistics[i]) / numberOfSamples[i];
 						break;
 					case 3: // MAX
-						columnsStatistics[i] = columnsStatistics[i] < inst.value(i) ? inst.value(i) : columnsStatistics[i];
+						columnsStatistics[i] = columnsStatistics[i] < inst.value(i) ? inst.value(i)
+								: columnsStatistics[i];
 						break;
 					case 4: // MIN
-						columnsStatistics[i] = columnsStatistics[i] > inst.value(i) ? inst.value(i) : columnsStatistics[i];
+						columnsStatistics[i] = columnsStatistics[i] > inst.value(i) ? inst.value(i)
+								: columnsStatistics[i];
 						break;
-					default: continue;
+					default:
+						continue;
 					}
 				}
 			}
 			// ---- Nominal values ----
-			else if(inst.attribute(i).isNominal()){
+			else if (inst.attribute(i).isNominal()) {
 				// Handle missing value
 				if (inst.isMissing(i)) {
-					switch(nominalSelectedStrategy){
+					switch (nominalSelectedStrategy) {
 					case 0: // NOTHING
 						break;
 					case 1: // LAST KNOWN VALUE
-						if(lastNominalValues[i] != -1){ //null){
+						if (lastNominalValues[i] != -1) { // null){
 							inst.setValue(i, lastNominalValues[i]);
 						}
 						break;
 					case 2: // MODE
-						if(!frequencies[i].isEmpty()){
+						if (!frequencies[i].isEmpty()) {
 							// Sort the map to get the most frequent value
-							Map<Double, Integer> sortedMap = MapUtil.sortByValue( frequencies[i] );
+							Map<Double, Integer> sortedMap = MapUtil.sortByValue(frequencies[i]);
 							inst.setValue(i, sortedMap.entrySet().iterator().next().getKey());
 						}
 						break;
-					default: continue;
+					default:
+						continue;
 					}
 				}
 				// Update statistics with non-missing values
-				else{
-					switch(nominalSelectedStrategy){
+				else {
+					switch (nominalSelectedStrategy) {
 					case 1: // LAST KNOWN VALUE
 						lastNominalValues[i] = inst.value(i);
 						break;
 					case 2: // MODE
 						Integer previousCounter = frequencies[i].get(inst.value(i));
-						if(previousCounter == null) previousCounter = 0;
+						if (previousCounter == null)
+							previousCounter = 0;
 						frequencies[i].put(inst.value(i), ++previousCounter);
 						break;
-					default: continue;
+					default:
+						continue;
 					}
 				}
 			}
 		}
-		
-        return new InstanceExample(inst);
-    }
+
+		return new InstanceExample(inst);
+	}
 
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
@@ -229,24 +228,25 @@ protected void restartImpl() {
 		lastNominalValues = null;
 		frequencies = null;
 	}
-	
+
 	// Solution from http://stackoverflow.com/a/2581754/2022620
 	public static class MapUtil {
-	    public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue( Map<K, V> map ) {
-	        
-	    	List<Map.Entry<K, V>> list = new LinkedList<Map.Entry<K, V>>( map.entrySet() );
-	        Collections.sort( list, new Comparator<Map.Entry<K, V>>() {
-	            public int compare( Map.Entry<K, V> o1, Map.Entry<K, V> o2 ) {
-	                return -(o1.getValue()).compareTo( o2.getValue() );
-	            }
-	        });
-
-	        Map<K, V> result = new LinkedHashMap<K, V>();
-	        for (Map.Entry<K, V> entry : list) {
-	            result.put( entry.getKey(), entry.getValue() );
-	        }
-	        return result;
-	    }
+		public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue(Map<K, V> map) {
+
+			List<Map.Entry<K, V>> list = new LinkedList<>(map.entrySet());
+			Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
+				@Override
+				public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
+					return -(o1.getValue()).compareTo(o2.getValue());
+				}
+			});
+
+			Map<K, V> result = new LinkedHashMap<>();
+			for (Map.Entry<K, V> entry : list) {
+				result.put(entry.getKey(), entry.getValue());
+			}
+			return result;
+		}
 	}
 
 }
diff --git a/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java b/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java
index fb891782b..455ff20a5 100644
--- a/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java
+++ b/moa/src/main/java/moa/streams/filters/SelectAttributesFilter.java
@@ -10,25 +10,27 @@
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import moa.core.InstanceExample;
-
 import moa.core.utils.AttributeDefinitionUtil;
 
-public class SelectAttributesFilter extends AbstractMultiLabelStreamFilter implements MultiLabelStreamFilter{
+public class SelectAttributesFilter extends AbstractMultiLabelStreamFilter implements MultiLabelStreamFilter {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 1L;
 	protected InstancesHeader dataset;
-	public StringOption inputStringOption= new StringOption("inputStringOption", 'i', "Selection of attributes to be used as input.", "1") ;
-	public StringOption outputStringOption= new StringOption("outputStringOption", 'o', "Selection of attributes to be used as output.", "-1") ;
-	
+	public StringOption inputStringOption = new StringOption("inputStringOption", 'i',
+			"Selection of attributes to be used as input.", "1");
+	public StringOption outputStringOption = new StringOption("outputStringOption", 'o',
+			"Selection of attributes to be used as output.", "-1");
+
 	protected List<Integer> outputIndexes;
 	protected List<Integer> inputIndexes;
-    @Override
-    public String getPurposeString() {
-        return "Selects input and output attributes.";
-    }
+
+	@Override
+	public String getPurposeString() {
+		return "Selects input and output attributes.";
+	}
 
 	@Override
 	public InstancesHeader getHeader() {
@@ -37,28 +39,30 @@ public InstancesHeader getHeader() {
 
 	@Override
 	public InstanceExample nextInstance() {
-		Instance instance = (Instance) ((Instance) this.inputStream.nextInstance().getData());
-		if(dataset==null){
+		Instance instance = (this.inputStream.nextInstance().getData());
+		if (dataset == null) {
 			initialize(instance);
-		}		
+		}
 		return new InstanceExample(processInstance(instance));
 	}
 
 	private void initialize(Instance instance) {
-		outputIndexes = AttributeDefinitionUtil.parseAttributeDefinition(outputStringOption.getValue(), instance.numAttributes(), null);
-		inputIndexes = AttributeDefinitionUtil.parseAttributeDefinition(inputStringOption.getValue(), instance.numAttributes(), null);
-		int totAttributes=inputIndexes.size()+outputIndexes.size();
+		outputIndexes = AttributeDefinitionUtil.parseAttributeDefinition(outputStringOption.getValue(),
+				instance.numAttributes(), null);
+		inputIndexes = AttributeDefinitionUtil.parseAttributeDefinition(inputStringOption.getValue(),
+				instance.numAttributes(), null);
+		int totAttributes = inputIndexes.size() + outputIndexes.size();
 		dataset = new InstancesHeader();
-		List<Attribute> v = new ArrayList<Attribute>(totAttributes);
-		List<Integer> newInstanceInputIndexes = new ArrayList<Integer>(); 
-		List<Integer> newInstanceOutputIndexes = new ArrayList<Integer>();
+		List<Attribute> v = new ArrayList<>(totAttributes);
+		List<Integer> newInstanceInputIndexes = new ArrayList<>();
+		List<Integer> newInstanceOutputIndexes = new ArrayList<>();
 		int count = 0;
-		for (Integer i : inputIndexes) { 
+		for (Integer i : inputIndexes) {
 			v.add(instance.attribute(i));
 			newInstanceInputIndexes.add(count);
 			count++;
 		}
-		for (Integer i : outputIndexes) { 
+		for (Integer i : outputIndexes) {
 			v.add(instance.attribute(i));
 			newInstanceOutputIndexes.add(count);
 			count++;
@@ -67,7 +71,7 @@ private void initialize(Instance instance) {
 		dataset.setInputIndexes(newInstanceInputIndexes);
 		dataset.setOutputIndexes(newInstanceOutputIndexes);
 	}
-	
+
 	@Override
 	public void getDescription(StringBuilder sb, int indent) {
 	}
@@ -76,18 +80,17 @@ public void getDescription(StringBuilder sb, int indent) {
 	protected void restartImpl() {
 
 	}
-	
+
 	private Instance processInstance(Instance instance) {
-		double [] attValues = new double[dataset.numAttributes()];
-		Instance newInstance=new InstanceImpl(instance.weight(),attValues);
+		double[] attValues = new double[dataset.numAttributes()];
+		Instance newInstance = new InstanceImpl(instance.weight(), attValues);
 		newInstance.setDataset(dataset);
 
-		for (Integer j: inputIndexes)
+		for (Integer j : inputIndexes)
 			newInstance.setValue(instance.attribute(j), instance.value(j));
 
-		for (Integer j: outputIndexes)
+		for (Integer j : outputIndexes)
 			newInstance.setValue(instance.attribute(j), instance.value(j));
 		return newInstance;
 	}
 }
-
diff --git a/moa/src/main/java/moa/streams/filters/StreamFilter.java b/moa/src/main/java/moa/streams/filters/StreamFilter.java
index 9b864d63a..05ae31bd3 100644
--- a/moa/src/main/java/moa/streams/filters/StreamFilter.java
+++ b/moa/src/main/java/moa/streams/filters/StreamFilter.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams.filters;
 
@@ -24,19 +24,19 @@
 import moa.streams.ExampleStream;
 
 /**
- * Interface representing a stream filter. 
+ * Interface representing a stream filter.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $ 
+ * @version $Revision: 7 $
  */
 public interface StreamFilter extends ExampleStream {
 
-    /**
-     * Sets the input stream to the filter
-     *
-     * @param stream the input stream to the filter
-     */
-    public void setInputStream(ExampleStream stream);
-    
-    public Instance filterInstance(Instance inst);
+	/**
+	 * Sets the input stream to the filter
+	 *
+	 * @param stream the input stream to the filter
+	 */
+	void setInputStream(ExampleStream stream);
+
+	Instance filterInstance(Instance inst);
 }
diff --git a/moa/src/main/java/moa/streams/generators/AgrawalGenerator.java b/moa/src/main/java/moa/streams/generators/AgrawalGenerator.java
index 59cd37e00..5fac9b2db 100644
--- a/moa/src/main/java/moa/streams/generators/AgrawalGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/AgrawalGenerator.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams.generators;
 
@@ -26,412 +26,367 @@
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+
 import moa.capabilities.CapabilitiesHandler;
 import moa.capabilities.Capability;
 import moa.capabilities.ImmutableCapabilities;
 import moa.core.FastVector;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-
-import java.util.Random;
-
 import moa.core.InstanceExample;
 import moa.core.ObjectRepository;
 import moa.options.AbstractOptionHandler;
-import com.github.javacliparser.FlagOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
 import moa.streams.InstanceStream;
 import moa.tasks.TaskMonitor;
 
 /**
- * Stream generator for Agrawal dataset.
- * Generator described in paper:<br/>
- *   Rakesh Agrawal, Tomasz Imielinksi, and Arun Swami,
- *    "Database Mining: A Performance Perspective",
- *     IEEE Transactions on Knowledge and Data Engineering,
- *      5(6), December 1993. <br/><br/>
- * 
+ * Stream generator for Agrawal dataset. Generator described in paper:<br/>
+ * Rakesh Agrawal, Tomasz Imielinksi, and Arun Swami, "Database Mining: A
+ * Performance Perspective", IEEE Transactions on Knowledge and Data
+ * Engineering, 5(6), December 1993. <br/>
+ * <br/>
+ *
  * Public C source code available at:<br/>
- *   <a href="http://www.almaden.ibm.com/cs/projects/iis/hdb/Projects/data_mining/datasets/syndata.html">
- * http://www.almaden.ibm.com/cs/projects/iis/hdb/Projects/data_mining/datasets/syndata.html</a><br/><br/>
+ * <a href=
+ * "http://www.almaden.ibm.com/cs/projects/iis/hdb/Projects/data_mining/datasets/syndata.html">
+ * http://www.almaden.ibm.com/cs/projects/iis/hdb/Projects/data_mining/datasets/syndata.html</a><br/>
+ * <br/>
  *
  * Notes:<br/>
- * The built in functions are based on the paper (page 924),
- *  which turn out to be functions pred20 thru pred29 in the public C implementation.
- * Perturbation function works like C implementation rather than description in paper.
- * 
+ * The built in functions are based on the paper (page 924), which turn out to
+ * be functions pred20 thru pred29 in the public C implementation. Perturbation
+ * function works like C implementation rather than description in paper.
+ *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class AgrawalGenerator extends AbstractOptionHandler implements
-        InstanceStream, CapabilitiesHandler {
-
-    @Override
-    public String getPurposeString() {
-        return "Generates one of ten different pre-defined loan functions.";
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    public IntOption functionOption = new IntOption("function", 'f',
-            "Classification function used, as defined in the original paper.",
-            1, 1, 10);
-
-    public IntOption instanceRandomSeedOption = new IntOption(
-            "instanceRandomSeed", 'i',
-            "Seed for random generation of instances.", 1);
-
-    public FloatOption peturbFractionOption = new FloatOption("peturbFraction",
-            'p',
-            "The amount of peturbation (noise) introduced to numeric values.",
-            0.05, 0.0, 1.0);
-
-    public FlagOption balanceClassesOption = new FlagOption("balanceClasses",
-            'b', "Balance the number of instances of each class.");
-
-    protected interface ClassFunction {
-
-        public int determineClass(double salary, double commission, int age,
-                int elevel, int car, int zipcode, double hvalue, int hyears,
-                double loan);
-    }
-
-    protected static ClassFunction[] classificationFunctions = {
-        // function 1
-        new ClassFunction() {
-
-    @Override
-    public int determineClass(double salary, double commission,
-            int age, int elevel, int car, int zipcode,
-            double hvalue, int hyears, double loan) {
-        return ((age < 40) || (60 <= age)) ? 0 : 1;
-    }
-},
-        // function 2
-        new ClassFunction() {
-
-    @Override
-    public int determineClass(double salary, double commission,
-            int age, int elevel, int car, int zipcode,
-            double hvalue, int hyears, double loan) {
-        if (age < 40) {
-            return ((50000 <= salary) && (salary <= 100000)) ? 0
-                    : 1;
-        } else if (age < 60) {// && age >= 40
-            return ((75000 <= salary) && (salary <= 125000)) ? 0
-                    : 1;
-        } else {// age >= 60
-            return ((25000 <= salary) && (salary <= 75000)) ? 0 : 1;
-        }
-    }
-},
-        // function 3
-        new ClassFunction() {
-
-    @Override
-    public int determineClass(double salary, double commission,
-            int age, int elevel, int car, int zipcode,
-            double hvalue, int hyears, double loan) {
-        if (age < 40) {
-            return ((elevel == 0) || (elevel == 1)) ? 0 : 1;
-        } else if (age < 60) { // && age >= 40
-            return ((elevel == 1) || (elevel == 2) || (elevel == 3)) ? 0
-                    : 1;
-        } else { // age >= 60
-            return ((elevel == 2) || (elevel == 3) || (elevel == 4)) ? 0
-                    : 1;
-        }
-    }
-},
-        // function 4
-        new ClassFunction() {
-
-    @Override
-    public int determineClass(double salary, double commission,
-            int age, int elevel, int car, int zipcode,
-            double hvalue, int hyears, double loan) {
-        if (age < 40) {
-            if ((elevel == 0) || (elevel == 1)) {
-                return ((25000 <= salary) && (salary <= 75000)) ? 0
-                        : 1;
-            }
-            return ((50000 <= salary) && (salary <= 100000)) ? 0
-                    : 1;
-        } else if (age < 60) {// && age >= 40
-            if ((elevel == 1) || (elevel == 2) || (elevel == 3)) {
-                return ((50000 <= salary) && (salary <= 100000)) ? 0
-                        : 1;
-            }
-            return ((75000 <= salary) && (salary <= 125000)) ? 0
-                    : 1;
-        } else {// age >= 60
-            if ((elevel == 2) || (elevel == 3) || (elevel == 4)) {
-                return ((50000 <= salary) && (salary <= 100000)) ? 0
-                        : 1;
-            }
-            return ((25000 <= salary) && (salary <= 75000)) ? 0 : 1;
-        }
-    }
-},
-        // function 5
-        new ClassFunction() {
-
-    @Override
-    public int determineClass(double salary, double commission,
-            int age, int elevel, int car, int zipcode,
-            double hvalue, int hyears, double loan) {
-        if (age < 40) {
-            if ((50000 <= salary) && (salary <= 100000)) {
-                return ((100000 <= loan) && (loan <= 300000)) ? 0
-                        : 1;
-            }
-            return ((200000 <= loan) && (loan <= 400000)) ? 0 : 1;
-        } else if (age < 60) {// && age >= 40
-            if ((75000 <= salary) && (salary <= 125000)) {
-                return ((200000 <= loan) && (loan <= 400000)) ? 0
-                        : 1;
-            }
-            return ((300000 <= loan) && (loan <= 500000)) ? 0 : 1;
-        } else {// age >= 60
-            if ((25000 <= salary) && (salary <= 75000)) {
-                return ((300000 <= loan) && (loan <= 500000)) ? 0
-                        : 1;
-            }
-            return ((100000 <= loan) && (loan <= 300000)) ? 0 : 1;
-        }
-    }
-},
-        // function 6
-        new ClassFunction() {
-
-    @Override
-    public int determineClass(double salary, double commission,
-            int age, int elevel, int car, int zipcode,
-            double hvalue, int hyears, double loan) {
-        double totalSalary = salary + commission;
-        if (age < 40) {
-            return ((50000 <= totalSalary) && (totalSalary <= 100000)) ? 0
-                    : 1;
-        } else if (age < 60) {// && age >= 40
-            return ((75000 <= totalSalary) && (totalSalary <= 125000)) ? 0
-                    : 1;
-        } else {// age >= 60
-            return ((25000 <= totalSalary) && (totalSalary <= 75000)) ? 0
-                    : 1;
-        }
-    }
-},
-        // function 7
-        new ClassFunction() {
-
-    @Override
-    public int determineClass(double salary, double commission,
-            int age, int elevel, int car, int zipcode,
-            double hvalue, int hyears, double loan) {
-        double disposable = (2.0 * (salary + commission) / 3.0
-                - loan / 5.0 - 20000.0);
-        return disposable > 0 ? 0 : 1;
-    }
-},
-        // function 8
-        new ClassFunction() {
-
-    @Override
-    public int determineClass(double salary, double commission,
-            int age, int elevel, int car, int zipcode,
-            double hvalue, int hyears, double loan) {
-        double disposable = (2.0 * (salary + commission) / 3.0
-                - 5000.0 * elevel - 20000.0);
-        return disposable > 0 ? 0 : 1;
-    }
-},
-        // function 9
-        new ClassFunction() {
-
-    @Override
-    public int determineClass(double salary, double commission,
-            int age, int elevel, int car, int zipcode,
-            double hvalue, int hyears, double loan) {
-        double disposable = (2.0 * (salary + commission) / 3.0
-                - 5000.0 * elevel - loan / 5.0 - 10000.0);
-        return disposable > 0 ? 0 : 1;
-    }
-},
-        // function 10
-        new ClassFunction() {
-
-    @Override
-    public int determineClass(double salary, double commission,
-            int age, int elevel, int car, int zipcode,
-            double hvalue, int hyears, double loan) {
-        double equity = 0.0;
-        if (hyears >= 20) {
-            equity = hvalue * (hyears - 20.0) / 10.0;
-        }
-        double disposable = (2.0 * (salary + commission) / 3.0
-                - 5000.0 * elevel + equity / 5.0 - 10000.0);
-        return disposable > 0 ? 0 : 1;
-    }
-}};
-
-    protected InstancesHeader streamHeader;
-
-    protected Random instanceRandom;
-
-    protected boolean nextClassShouldBeZero;
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        // generate header
-        FastVector attributes = new FastVector();
-        attributes.addElement(new Attribute("salary"));
-        attributes.addElement(new Attribute("commission"));
-        attributes.addElement(new Attribute("age"));
-        FastVector elevelLabels = new FastVector();
-        for (int i = 0; i < 5; i++) {
-            elevelLabels.addElement("level" + i);
-        }
-        attributes.addElement(new Attribute("elevel", elevelLabels));
-        FastVector carLabels = new FastVector();
-        for (int i = 0; i < 20; i++) {
-            carLabels.addElement("car" + (i + 1));
-        }
-        attributes.addElement(new Attribute("car", carLabels));
-        FastVector zipCodeLabels = new FastVector();
-        for (int i = 0; i < 9; i++) {
-            zipCodeLabels.addElement("zipcode" + (i + 1));
-        }
-        attributes.addElement(new Attribute("zipcode", zipCodeLabels));
-        attributes.addElement(new Attribute("hvalue"));
-        attributes.addElement(new Attribute("hyears"));
-        attributes.addElement(new Attribute("loan"));
-        FastVector classLabels = new FastVector();
-        classLabels.addElement("groupA");
-        classLabels.addElement("groupB");
-        attributes.addElement(new Attribute("class", classLabels));
-        this.streamHeader = new InstancesHeader(new InstancesHeader(
-                getCLICreationString(InstanceStream.class), attributes, 0));
-        this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
-        restart();
-    }
-
-    @Override
-    public long estimatedRemainingInstances() {
-        return -1;
-    }
-
-    @Override
-    public InstancesHeader getHeader() {
-        return this.streamHeader;
-    }
-
-    @Override
-    public boolean hasMoreInstances() {
-        return true;
-    }
-
-    @Override
-    public boolean isRestartable() {
-        return true;
-    }
-
-    @Override
-    public InstanceExample nextInstance() {
-        double salary = 0, commission = 0, hvalue = 0, loan = 0;
-        int age = 0, elevel = 0, car = 0, zipcode = 0, hyears = 0, group = 0;
-        boolean desiredClassFound = false;
-        while (!desiredClassFound) {
-            // generate attributes
-            salary = 20000.0 + 130000.0 * this.instanceRandom.nextDouble();
-            commission = (salary >= 75000.0) ? 0
-                    : (10000.0 + 65000.0 * this.instanceRandom.nextDouble());
-            // true to c implementation:
-            // if (instanceRandom.nextDouble() < 0.5 && salary < 75000.0)
-            // commission = 10000.0 + 65000.0 * instanceRandom.nextDouble();
-            age = 20 + this.instanceRandom.nextInt(61);
-            elevel = this.instanceRandom.nextInt(5);
-            car = this.instanceRandom.nextInt(20);
-            zipcode = this.instanceRandom.nextInt(9);
-            hvalue = (9.0 - zipcode) * 100000.0
-                    * (0.5 + this.instanceRandom.nextDouble());
-            hyears = 1 + this.instanceRandom.nextInt(30);
-            loan = this.instanceRandom.nextDouble() * 500000.0;
-            // determine class
-            group = classificationFunctions[this.functionOption.getValue() - 1].determineClass(salary, commission, age, elevel, car,
-                    zipcode, hvalue, hyears, loan);
-            if (!this.balanceClassesOption.isSet()) {
-                desiredClassFound = true;
-            } else {
-                // balance the classes
-                if ((this.nextClassShouldBeZero && (group == 0))
-                        || (!this.nextClassShouldBeZero && (group == 1))) {
-                    desiredClassFound = true;
-                    this.nextClassShouldBeZero = !this.nextClassShouldBeZero;
-                } // else keep searching
-            }
-        }
-        // perturb values
-        if (this.peturbFractionOption.getValue() > 0.0) {
-            salary = perturbValue(salary, 20000, 150000);
-            if (commission > 0) {
-                commission = perturbValue(commission, 10000, 75000);
-            }
-            age = (int) Math.round(perturbValue(age, 20, 80));
-            hvalue = perturbValue(hvalue, (9.0 - zipcode) * 100000.0, 0, 135000);
-            hyears = (int) Math.round(perturbValue(hyears, 1, 30));
-            loan = perturbValue(loan, 0, 500000);
-        }
-        // construct instance
-        InstancesHeader header = getHeader();
-        Instance inst = new DenseInstance(header.numAttributes());
-        inst.setValue(0, salary);
-        inst.setValue(1, commission);
-        inst.setValue(2, age);
-        inst.setValue(3, elevel);
-        inst.setValue(4, car);
-        inst.setValue(5, zipcode);
-        inst.setValue(6, hvalue);
-        inst.setValue(7, hyears);
-        inst.setValue(8, loan);
-        inst.setDataset(header);
-        inst.setClassValue(group);
-        return new InstanceExample(inst);
-    }
-
-    protected double perturbValue(double val, double min, double max) {
-        return perturbValue(val, max - min, min, max);
-    }
-
-    protected double perturbValue(double val, double range, double min,
-            double max) {
-        val += range * (2.0 * (this.instanceRandom.nextDouble() - 0.5))
-                * this.peturbFractionOption.getValue();
-        if (val < min) {
-            val = min;
-        } else if (val > max) {
-            val = max;
-        }
-        return val;
-    }
-
-    @Override
-    public void restart() {
-        this.instanceRandom = new Random(this.instanceRandomSeedOption.getValue());
-        this.nextClassShouldBeZero = false;
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == AgrawalGenerator.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
+public class AgrawalGenerator extends AbstractOptionHandler implements InstanceStream, CapabilitiesHandler {
+
+	@Override
+	public String getPurposeString() {
+		return "Generates one of ten different pre-defined loan functions.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public IntOption functionOption = new IntOption("function", 'f',
+			"Classification function used, as defined in the original paper.", 1, 1, 10);
+
+	public IntOption instanceRandomSeedOption = new IntOption("instanceRandomSeed", 'i',
+			"Seed for random generation of instances.", 1);
+
+	public FloatOption peturbFractionOption = new FloatOption("peturbFraction", 'p',
+			"The amount of peturbation (noise) introduced to numeric values.", 0.05, 0.0, 1.0);
+
+	public FlagOption balanceClassesOption = new FlagOption("balanceClasses", 'b',
+			"Balance the number of instances of each class.");
+
+	protected interface ClassFunction {
+
+		int determineClass(double salary, double commission, int age, int elevel, int car, int zipcode, double hvalue,
+				int hyears, double loan);
+	}
+
+	protected static ClassFunction[] classificationFunctions = {
+			// function 1
+			new ClassFunction() {
+
+				@Override
+				public int determineClass(double salary, double commission, int age, int elevel, int car, int zipcode,
+						double hvalue, int hyears, double loan) {
+					return ((age < 40) || (60 <= age)) ? 0 : 1;
+				}
+			},
+			// function 2
+			new ClassFunction() {
+
+				@Override
+				public int determineClass(double salary, double commission, int age, int elevel, int car, int zipcode,
+						double hvalue, int hyears, double loan) {
+					if (age < 40) {
+						return ((50000 <= salary) && (salary <= 100000)) ? 0 : 1;
+					} else if (age < 60) {// && age >= 40
+						return ((75000 <= salary) && (salary <= 125000)) ? 0 : 1;
+					} else {// age >= 60
+						return ((25000 <= salary) && (salary <= 75000)) ? 0 : 1;
+					}
+				}
+			},
+			// function 3
+			new ClassFunction() {
+
+				@Override
+				public int determineClass(double salary, double commission, int age, int elevel, int car, int zipcode,
+						double hvalue, int hyears, double loan) {
+					if (age < 40) {
+						return ((elevel == 0) || (elevel == 1)) ? 0 : 1;
+					} else if (age < 60) { // && age >= 40
+						return ((elevel == 1) || (elevel == 2) || (elevel == 3)) ? 0 : 1;
+					} else { // age >= 60
+						return ((elevel == 2) || (elevel == 3) || (elevel == 4)) ? 0 : 1;
+					}
+				}
+			},
+			// function 4
+			new ClassFunction() {
+
+				@Override
+				public int determineClass(double salary, double commission, int age, int elevel, int car, int zipcode,
+						double hvalue, int hyears, double loan) {
+					if (age < 40) {
+						if ((elevel == 0) || (elevel == 1)) {
+							return ((25000 <= salary) && (salary <= 75000)) ? 0 : 1;
+						}
+						return ((50000 <= salary) && (salary <= 100000)) ? 0 : 1;
+					} else if (age < 60) {// && age >= 40
+						if ((elevel == 1) || (elevel == 2) || (elevel == 3)) {
+							return ((50000 <= salary) && (salary <= 100000)) ? 0 : 1;
+						}
+						return ((75000 <= salary) && (salary <= 125000)) ? 0 : 1;
+					} else {// age >= 60
+						if ((elevel == 2) || (elevel == 3) || (elevel == 4)) {
+							return ((50000 <= salary) && (salary <= 100000)) ? 0 : 1;
+						}
+						return ((25000 <= salary) && (salary <= 75000)) ? 0 : 1;
+					}
+				}
+			},
+			// function 5
+			new ClassFunction() {
+
+				@Override
+				public int determineClass(double salary, double commission, int age, int elevel, int car, int zipcode,
+						double hvalue, int hyears, double loan) {
+					if (age < 40) {
+						if ((50000 <= salary) && (salary <= 100000)) {
+							return ((100000 <= loan) && (loan <= 300000)) ? 0 : 1;
+						}
+						return ((200000 <= loan) && (loan <= 400000)) ? 0 : 1;
+					} else if (age < 60) {// && age >= 40
+						if ((75000 <= salary) && (salary <= 125000)) {
+							return ((200000 <= loan) && (loan <= 400000)) ? 0 : 1;
+						}
+						return ((300000 <= loan) && (loan <= 500000)) ? 0 : 1;
+					} else {// age >= 60
+						if ((25000 <= salary) && (salary <= 75000)) {
+							return ((300000 <= loan) && (loan <= 500000)) ? 0 : 1;
+						}
+						return ((100000 <= loan) && (loan <= 300000)) ? 0 : 1;
+					}
+				}
+			},
+			// function 6
+			new ClassFunction() {
+
+				@Override
+				public int determineClass(double salary, double commission, int age, int elevel, int car, int zipcode,
+						double hvalue, int hyears, double loan) {
+					double totalSalary = salary + commission;
+					if (age < 40) {
+						return ((50000 <= totalSalary) && (totalSalary <= 100000)) ? 0 : 1;
+					} else if (age < 60) {// && age >= 40
+						return ((75000 <= totalSalary) && (totalSalary <= 125000)) ? 0 : 1;
+					} else {// age >= 60
+						return ((25000 <= totalSalary) && (totalSalary <= 75000)) ? 0 : 1;
+					}
+				}
+			},
+			// function 7
+			new ClassFunction() {
+
+				@Override
+				public int determineClass(double salary, double commission, int age, int elevel, int car, int zipcode,
+						double hvalue, int hyears, double loan) {
+					double disposable = (2.0 * (salary + commission) / 3.0 - loan / 5.0 - 20000.0);
+					return disposable > 0 ? 0 : 1;
+				}
+			},
+			// function 8
+			new ClassFunction() {
+
+				@Override
+				public int determineClass(double salary, double commission, int age, int elevel, int car, int zipcode,
+						double hvalue, int hyears, double loan) {
+					double disposable = (2.0 * (salary + commission) / 3.0 - 5000.0 * elevel - 20000.0);
+					return disposable > 0 ? 0 : 1;
+				}
+			},
+			// function 9
+			new ClassFunction() {
+
+				@Override
+				public int determineClass(double salary, double commission, int age, int elevel, int car, int zipcode,
+						double hvalue, int hyears, double loan) {
+					double disposable = (2.0 * (salary + commission) / 3.0 - 5000.0 * elevel - loan / 5.0 - 10000.0);
+					return disposable > 0 ? 0 : 1;
+				}
+			},
+			// function 10
+			new ClassFunction() {
+
+				@Override
+				public int determineClass(double salary, double commission, int age, int elevel, int car, int zipcode,
+						double hvalue, int hyears, double loan) {
+					double equity = 0.0;
+					if (hyears >= 20) {
+						equity = hvalue * (hyears - 20.0) / 10.0;
+					}
+					double disposable = (2.0 * (salary + commission) / 3.0 - 5000.0 * elevel + equity / 5.0 - 10000.0);
+					return disposable > 0 ? 0 : 1;
+				}
+			} };
+
+	protected InstancesHeader streamHeader;
+
+	protected Random instanceRandom;
+
+	protected boolean nextClassShouldBeZero;
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// generate header
+		FastVector attributes = new FastVector();
+		attributes.addElement(new Attribute("salary"));
+		attributes.addElement(new Attribute("commission"));
+		attributes.addElement(new Attribute("age"));
+		FastVector elevelLabels = new FastVector();
+		for (int i = 0; i < 5; i++) {
+			elevelLabels.addElement("level" + i);
+		}
+		attributes.addElement(new Attribute("elevel", elevelLabels));
+		FastVector carLabels = new FastVector();
+		for (int i = 0; i < 20; i++) {
+			carLabels.addElement("car" + (i + 1));
+		}
+		attributes.addElement(new Attribute("car", carLabels));
+		FastVector zipCodeLabels = new FastVector();
+		for (int i = 0; i < 9; i++) {
+			zipCodeLabels.addElement("zipcode" + (i + 1));
+		}
+		attributes.addElement(new Attribute("zipcode", zipCodeLabels));
+		attributes.addElement(new Attribute("hvalue"));
+		attributes.addElement(new Attribute("hyears"));
+		attributes.addElement(new Attribute("loan"));
+		FastVector classLabels = new FastVector();
+		classLabels.addElement("groupA");
+		classLabels.addElement("groupB");
+		attributes.addElement(new Attribute("class", classLabels));
+		this.streamHeader = new InstancesHeader(
+				new InstancesHeader(getCLICreationString(InstanceStream.class), attributes, 0));
+		this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
+		restart();
+	}
+
+	@Override
+	public long estimatedRemainingInstances() {
+		return -1;
+	}
+
+	@Override
+	public InstancesHeader getHeader() {
+		return this.streamHeader;
+	}
+
+	@Override
+	public boolean hasMoreInstances() {
+		return true;
+	}
+
+	@Override
+	public boolean isRestartable() {
+		return true;
+	}
+
+	@Override
+	public InstanceExample nextInstance() {
+		double salary = 0, commission = 0, hvalue = 0, loan = 0;
+		int age = 0, elevel = 0, car = 0, zipcode = 0, hyears = 0, group = 0;
+		boolean desiredClassFound = false;
+		while (!desiredClassFound) {
+			// generate attributes
+			salary = 20000.0 + 130000.0 * this.instanceRandom.nextDouble();
+			commission = (salary >= 75000.0) ? 0 : (10000.0 + 65000.0 * this.instanceRandom.nextDouble());
+			// true to c implementation:
+			// if (instanceRandom.nextDouble() < 0.5 && salary < 75000.0)
+			// commission = 10000.0 + 65000.0 * instanceRandom.nextDouble();
+			age = 20 + this.instanceRandom.nextInt(61);
+			elevel = this.instanceRandom.nextInt(5);
+			car = this.instanceRandom.nextInt(20);
+			zipcode = this.instanceRandom.nextInt(9);
+			hvalue = (9.0 - zipcode) * 100000.0 * (0.5 + this.instanceRandom.nextDouble());
+			hyears = 1 + this.instanceRandom.nextInt(30);
+			loan = this.instanceRandom.nextDouble() * 500000.0;
+			// determine class
+			group = classificationFunctions[this.functionOption.getValue() - 1].determineClass(salary, commission, age,
+					elevel, car, zipcode, hvalue, hyears, loan);
+			if (!this.balanceClassesOption.isSet()) {
+				desiredClassFound = true;
+			} else {
+				// balance the classes
+				if ((this.nextClassShouldBeZero && (group == 0)) || (!this.nextClassShouldBeZero && (group == 1))) {
+					desiredClassFound = true;
+					this.nextClassShouldBeZero = !this.nextClassShouldBeZero;
+				} // else keep searching
+			}
+		}
+		// perturb values
+		if (this.peturbFractionOption.getValue() > 0.0) {
+			salary = perturbValue(salary, 20000, 150000);
+			if (commission > 0) {
+				commission = perturbValue(commission, 10000, 75000);
+			}
+			age = (int) Math.round(perturbValue(age, 20, 80));
+			hvalue = perturbValue(hvalue, (9.0 - zipcode) * 100000.0, 0, 135000);
+			hyears = (int) Math.round(perturbValue(hyears, 1, 30));
+			loan = perturbValue(loan, 0, 500000);
+		}
+		// construct instance
+		InstancesHeader header = getHeader();
+		Instance inst = new DenseInstance(header.numAttributes());
+		inst.setValue(0, salary);
+		inst.setValue(1, commission);
+		inst.setValue(2, age);
+		inst.setValue(3, elevel);
+		inst.setValue(4, car);
+		inst.setValue(5, zipcode);
+		inst.setValue(6, hvalue);
+		inst.setValue(7, hyears);
+		inst.setValue(8, loan);
+		inst.setDataset(header);
+		inst.setClassValue(group);
+		return new InstanceExample(inst);
+	}
+
+	protected double perturbValue(double val, double min, double max) {
+		return perturbValue(val, max - min, min, max);
+	}
+
+	protected double perturbValue(double val, double range, double min, double max) {
+		val += range * (2.0 * (this.instanceRandom.nextDouble() - 0.5)) * this.peturbFractionOption.getValue();
+		if (val < min) {
+			val = min;
+		} else if (val > max) {
+			val = max;
+		}
+		return val;
+	}
+
+	@Override
+	public void restart() {
+		this.instanceRandom = new Random(this.instanceRandomSeedOption.getValue());
+		this.nextClassShouldBeZero = false;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == AgrawalGenerator.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
 }
diff --git a/moa/src/main/java/moa/streams/generators/AssetNegotiationGenerator.java b/moa/src/main/java/moa/streams/generators/AssetNegotiationGenerator.java
index 4059f4ccb..ea3430d64 100644
--- a/moa/src/main/java/moa/streams/generators/AssetNegotiationGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/AssetNegotiationGenerator.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
 package moa.streams.generators;
@@ -44,405 +44,319 @@
  *
  * @version 1.0
  * @see Originally discussed in F. Enembreck, B. C. Ávila, E. E. Scalabrin &
- * J-P. Barthès. LEARNING DRIFTING NEGOTIATIONS. In Applied Artificial
- * Intelligence: An International Journal. Volume 21, Issue 9, 2007. DOI:
- * 10.1080/08839510701526954
+ *      J-P. Barthès. LEARNING DRIFTING NEGOTIATIONS. In Applied Artificial
+ *      Intelligence: An International Journal. Volume 21, Issue 9, 2007. DOI:
+ *      10.1080/08839510701526954
  * @see First used in the data stream configuration in J. P. Barddal, H. M.
- * Gomes, F. Enembreck, B. Pfahringer & A. Bifet. ON DYNAMIC FEATURE WEIGHTING
- * FOR FEATURE DRIFTING DATA STREAMS. In European Conference on Machine Learning
- * and Principles and Practice of Knowledge Discovery (ECML/PKDD'16). 2016.
+ *      Gomes, F. Enembreck, B. Pfahringer & A. Bifet. ON DYNAMIC FEATURE
+ *      WEIGHTING FOR FEATURE DRIFTING DATA STREAMS. In European Conference on
+ *      Machine Learning and Principles and Practice of Knowledge Discovery
+ *      (ECML/PKDD'16). 2016.
  */
 
-public class AssetNegotiationGenerator
-	extends AbstractOptionHandler
-	implements InstanceStream {
-
-    /*
-     * OPTIONS
-     */        
-    public IntOption functionOption = new IntOption("function", 'f',
-	    "Classification function used, as defined in the original paper.",
-	    1, 1, 5);
-    public FloatOption noisePercentage = new FloatOption("noise", 'n',
-	    "% of class noise.", 0.05, 0.0, 1.0f);
-
-    public IntOption instanceRandomSeedOption = new IntOption(
-	    "instanceRandomSeed", 'i',
-	    "Seed for random generation of instances.", 1);
-
-    /*
-     * INTERNALS
-     */
-    protected InstancesHeader streamHeader;
-
-    protected Random instanceRandom;
-
-    protected boolean nextClassShouldBeZero;
-    
-    protected ClassFunction classFunction;
-    
-
-    /*
-     * FEATURE DEFINITIONS
-     */
-    protected static String colorValues[] = {"black",
-	"blue",
-	"cyan",
-	"brown",
-	"red",
-	"green",
-	"yellow",
-	"magenta"};
-
-    protected static String priceValues[] = {"veryLow",
-	"low",
-	"normal",
-	"high",
-	"veryHigh",
-	"quiteHigh",
-	"enormous",
-	"non_salable"};
-
-    protected static String paymentValues[] = {"0",
-	"30",
-	"60",
-	"90",
-	"120",
-	"150",
-	"180",
-	"210",
-	"240"};
-
-    protected static String amountValues[] = {"veryLow",
-	"low",
-	"normal",
-	"high",
-	"veryHigh",
-	"quiteHigh",
-	"enormous",
-	"non_ensured"};
-
-    protected static String deliveryDelayValues[] = {"veryLow",
-	"low",
-	"normal",
-	"high",
-	"veryHigh"};
-
-    protected static String classValues[] = {"interested", "notInterested"};
-
-    /*
-     * Labeling functions
-     */
-    protected interface ClassFunction {
-
-	public int determineClass(String color,
-		String price,
-		String payment,
-		String amount,
-		String deliveryDelay);
-
-	public Instance makeTrue(Instance intnc);
-    }
-
-    protected static ClassFunction concepts[] = {
-	new ClassFunction() {
-	    Random r = new Random(Integer.MAX_VALUE);
-
-	    @Override
-	    public int determineClass(String color,
-		    String price,
-		    String payment,
-		    String amount,
-		    String deliveryDelay) {
-		if ((price.equals("normal") && amount.equals("high")
-			|| (color.equals("brown") && price.equals("veryLow")
-			&& deliveryDelay.equals("high")))) {
-		    return indexOfValue("interested", classValues);
+public class AssetNegotiationGenerator extends AbstractOptionHandler implements InstanceStream {
+
+	/*
+	 * OPTIONS
+	 */
+	public IntOption functionOption = new IntOption("function", 'f',
+			"Classification function used, as defined in the original paper.", 1, 1, 5);
+	public FloatOption noisePercentage = new FloatOption("noise", 'n', "% of class noise.", 0.05, 0.0, 1.0f);
+
+	public IntOption instanceRandomSeedOption = new IntOption("instanceRandomSeed", 'i',
+			"Seed for random generation of instances.", 1);
+
+	/*
+	 * INTERNALS
+	 */
+	protected InstancesHeader streamHeader;
+
+	protected Random instanceRandom;
+
+	protected boolean nextClassShouldBeZero;
+
+	protected ClassFunction classFunction;
+
+	/*
+	 * FEATURE DEFINITIONS
+	 */
+	protected static String colorValues[] = { "black", "blue", "cyan", "brown", "red", "green", "yellow", "magenta" };
+
+	protected static String priceValues[] = { "veryLow", "low", "normal", "high", "veryHigh", "quiteHigh", "enormous",
+			"non_salable" };
+
+	protected static String paymentValues[] = { "0", "30", "60", "90", "120", "150", "180", "210", "240" };
+
+	protected static String amountValues[] = { "veryLow", "low", "normal", "high", "veryHigh", "quiteHigh", "enormous",
+			"non_ensured" };
+
+	protected static String deliveryDelayValues[] = { "veryLow", "low", "normal", "high", "veryHigh" };
+
+	protected static String classValues[] = { "interested", "notInterested" };
+
+	/*
+	 * Labeling functions
+	 */
+	protected interface ClassFunction {
+
+		int determineClass(String color, String price, String payment, String amount, String deliveryDelay);
+
+		Instance makeTrue(Instance intnc);
+	}
+
+	protected static ClassFunction concepts[] = { new ClassFunction() {
+		Random r = new Random(Integer.MAX_VALUE);
+
+		@Override
+		public int determineClass(String color, String price, String payment, String amount, String deliveryDelay) {
+			if ((price.equals("normal") && amount.equals("high")
+					|| (color.equals("brown") && price.equals("veryLow") && deliveryDelay.equals("high")))) {
+				return indexOfValue("interested", classValues);
+			}
+			return indexOfValue("notInterested", classValues);
+		}
+
+		@Override
+		public Instance makeTrue(Instance intnc) {
+			int part = r.nextInt(2);
+			if (part == 0) {
+
+				intnc.setValue(1, indexOfValue("normal", priceValues));
+				intnc.setValue(3, indexOfValue("high", amountValues));
+			} else {
+				intnc.setValue(0, indexOfValue("brown", colorValues));
+				intnc.setValue(1, indexOfValue("veryLow", priceValues));
+				intnc.setValue(4, indexOfValue("high", deliveryDelayValues));
+			}
+			intnc.setClassValue(indexOfValue("interested", classValues));
+			return intnc;
+		}
+
+	}, new ClassFunction() {
+		Random r = new Random(Integer.MAX_VALUE);
+
+		@Override
+		public int determineClass(String color, String price, String payment, String amount, String deliveryDelay) {
+			if (price.equals("high") && amount.equals("veryHigh") && deliveryDelay.equals("high")) {
+				return indexOfValue("interested", classValues);
+			}
+			return indexOfValue("notInterested", classValues);
+		}
+
+		@Override
+		public Instance makeTrue(Instance intnc) {
+			intnc.setValue(1, indexOfValue("high", priceValues));
+			intnc.setValue(3, indexOfValue("veryHigh", amountValues));
+			intnc.setValue(4, indexOfValue("high", deliveryDelayValues));
+			intnc.setClassValue(Arrays.asList(classValues).indexOf("interested"));
+			return intnc;
 		}
-		return indexOfValue("notInterested", classValues);
-	    }
-
-	    @Override
-	    public Instance makeTrue(Instance intnc) {
-		int part = r.nextInt(2);
-		if (part == 0) {
-
-		    intnc.setValue(1, indexOfValue("normal", priceValues));
-		    intnc.setValue(3, indexOfValue("high", amountValues));
-		} else {
-		    intnc.setValue(0, indexOfValue("brown", colorValues));
-		    intnc.setValue(1, indexOfValue("veryLow", priceValues));
-		    intnc.setValue(4, indexOfValue("high", deliveryDelayValues));
+	}, new ClassFunction() {
+		Random r = new Random(Integer.MAX_VALUE);
+
+		@Override
+		public int determineClass(String color, String price, String payment, String amount, String deliveryDelay) {
+			if ((price.equals("veryLow") && payment.equals("0") && amount.equals("high"))
+					|| (color.equals("red") && price.equals("low") && payment.equals("30"))) {
+				return indexOfValue("interested", classValues);
+			}
+			return indexOfValue("notInterested", classValues);
 		}
-		intnc.setClassValue(indexOfValue("interested", classValues));
-		return intnc;
-	    }
-
-	},
-	new ClassFunction() {
-	    Random r = new Random(Integer.MAX_VALUE);
-
-	    @Override
-	    public int determineClass(String color,
-		    String price,
-		    String payment,
-		    String amount,
-		    String deliveryDelay) {
-		if (price.equals("high") && amount.equals("veryHigh")
-			&& deliveryDelay.equals("high")) {
-		    return indexOfValue("interested", classValues);
+
+		@Override
+		public Instance makeTrue(Instance intnc) {
+			int part = r.nextInt(2);
+			if (part == 0) {
+				intnc.setValue(1, indexOfValue("veryLow", priceValues));
+				intnc.setValue(2, indexOfValue("0", paymentValues));
+				intnc.setValue(3, indexOfValue("high", amountValues));
+			} else {
+				intnc.setValue(0, indexOfValue("red", colorValues));
+				intnc.setValue(1, indexOfValue("low", priceValues));
+				intnc.setValue(2, indexOfValue("30", paymentValues));
+			}
+			intnc.setClassValue(Arrays.asList(classValues).indexOf("interested"));
+			return intnc;
 		}
-		return indexOfValue("notInterested", classValues);
-	    }
-
-	    @Override
-	    public Instance makeTrue(Instance intnc) {
-		intnc.setValue(1, indexOfValue("high", priceValues));
-		intnc.setValue(3, indexOfValue("veryHigh", amountValues));
-		intnc.setValue(4, indexOfValue("high", deliveryDelayValues));
-		intnc.setClassValue(Arrays.asList(classValues).indexOf("interested"));
-		return intnc;
-	    }	    
-	},
-	new ClassFunction() {
-	    Random r = new Random(Integer.MAX_VALUE);
-
-	    @Override
-	    public int determineClass(String color,
-		    String price,
-		    String payment,
-		    String amount,
-		    String deliveryDelay) {
-		if ((price.equals("veryLow")
-			&& payment.equals("0") && amount.equals("high"))
-			|| (color.equals("red") && price.equals("low")
-			&& payment.equals("30"))) {
-		    return indexOfValue("interested", classValues);
+	}, new ClassFunction() {
+		Random r = new Random(Integer.MAX_VALUE);
+
+		@Override
+		public int determineClass(String color, String price, String payment, String amount, String deliveryDelay) {
+			if ((color.equals("black") && payment.equals("90") && deliveryDelay.equals("veryLow"))
+					|| (color.equals("magenta") && price.equals("high") && deliveryDelay.equals("veryLow"))) {
+				return indexOfValue("interested", classValues);
+			}
+			return indexOfValue("notInterested", classValues);
 		}
-		return indexOfValue("notInterested", classValues);
-	    }
-
-	    @Override
-	    public Instance makeTrue(Instance intnc) {
-		int part = r.nextInt(2);
-		if (part == 0) {
-		    intnc.setValue(1, indexOfValue("veryLow", priceValues));
-		    intnc.setValue(2, indexOfValue("0", paymentValues));
-		    intnc.setValue(3, indexOfValue("high", amountValues));
-		} else {
-		    intnc.setValue(0, indexOfValue("red", colorValues));
-		    intnc.setValue(1, indexOfValue("low", priceValues));
-		    intnc.setValue(2, indexOfValue("30", paymentValues));
+
+		@Override
+		public Instance makeTrue(Instance intnc) {
+			int part = r.nextInt(2);
+			if (part == 0) {
+				intnc.setValue(0, indexOfValue("black", colorValues));
+				intnc.setValue(2, indexOfValue("90", paymentValues));
+				intnc.setValue(4, indexOfValue("veryLow", deliveryDelayValues));
+			} else {
+				intnc.setValue(0, indexOfValue("magenta", colorValues));
+				intnc.setValue(1, indexOfValue("high", priceValues));
+				intnc.setValue(4, indexOfValue("veryLow", deliveryDelayValues));
+			}
+			intnc.setClassValue(Arrays.asList(classValues).indexOf("interested"));
+			return intnc;
 		}
-		intnc.setClassValue(Arrays.asList(classValues).indexOf("interested"));
-		return intnc;
-	    }	    
-	},
-	new ClassFunction() {
-	    Random r = new Random(Integer.MAX_VALUE);
-
-	    @Override
-	    public int determineClass(String color,
-		    String price,
-		    String payment,
-		    String amount,
-		    String deliveryDelay) {
-		if ((color.equals("black")
-			&& payment.equals("90")
-			&& deliveryDelay.equals("veryLow"))
-			|| (color.equals("magenta")
-			&& price.equals("high")
-			&& deliveryDelay.equals("veryLow"))) {
-		    return indexOfValue("interested", classValues);
+	}, new ClassFunction() {
+		Random r = new Random(Integer.MAX_VALUE);
+
+		@Override
+		public int determineClass(String color, String price, String payment, String amount, String deliveryDelay) {
+			if ((color.equals("blue") && payment.equals("60") && amount.equals("low") && deliveryDelay.equals("normal"))
+					|| (color.equals("cyan") && amount.equals("low") && deliveryDelay.equals("normal"))) {
+				return indexOfValue("interested", classValues);
+			}
+			return indexOfValue("notInterested", classValues);
 		}
-		return indexOfValue("notInterested", classValues);
-	    }
-
-	    @Override
-	    public Instance makeTrue(Instance intnc) {
-		int part = r.nextInt(2);
-		if (part == 0) {
-		    intnc.setValue(0, indexOfValue("black", colorValues));
-		    intnc.setValue(2, indexOfValue("90", paymentValues));
-		    intnc.setValue(4, indexOfValue("veryLow", deliveryDelayValues));
-		} else {
-		    intnc.setValue(0, indexOfValue("magenta", colorValues));
-		    intnc.setValue(1, indexOfValue("high", priceValues));
-		    intnc.setValue(4, indexOfValue("veryLow", deliveryDelayValues));
+
+		@Override
+		public Instance makeTrue(Instance intnc) {
+			int part = r.nextInt(2);
+			if (part == 0) {
+				intnc.setValue(0, indexOfValue("blue", colorValues));
+				intnc.setValue(2, indexOfValue("60", paymentValues));
+				intnc.setValue(3, indexOfValue("low", amountValues));
+				intnc.setValue(4, indexOfValue("normal", deliveryDelayValues));
+			} else {
+				intnc.setValue(0, indexOfValue("cyan", colorValues));
+				intnc.setValue(3, indexOfValue("low", amountValues));
+				intnc.setValue(4, indexOfValue("normal", deliveryDelayValues));
+			}
+			intnc.setClassValue(Arrays.asList(classValues).indexOf("interested"));
+			return intnc;
 		}
-		intnc.setClassValue(Arrays.asList(classValues).indexOf("interested"));
-		return intnc;
-	    }	    
-	},
-	new ClassFunction() {
-	    Random r = new Random(Integer.MAX_VALUE);
-
-	    @Override
-	    public int determineClass(String color,
-		    String price,
-		    String payment,
-		    String amount,
-		    String deliveryDelay) {
-		if ((color.equals("blue")
-			&& payment.equals("60")
-			&& amount.equals("low")
-			&& deliveryDelay.equals("normal"))
-			|| (color.equals("cyan")
-			&& amount.equals("low")
-			&& deliveryDelay.equals("normal"))) {
-		    return indexOfValue("interested", classValues);
+	} };
+
+	/*
+	 * Generator core
+	 */
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		sb.append("Generates instances based on 5 different concept functions "
+				+ "that describe whether another agent is " + "interested or not in an item.");
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor tm, ObjectRepository or) {
+
+		classFunction = concepts[this.functionOption.getValue() - 1];
+
+		FastVector attributes = new FastVector();
+		attributes.addElement(new Attribute("color", Arrays.asList(colorValues)));
+		attributes.addElement(new Attribute("price", Arrays.asList(priceValues)));
+		attributes.addElement(new Attribute("payment", Arrays.asList(paymentValues)));
+		attributes.addElement(new Attribute("amount", Arrays.asList(amountValues)));
+		attributes.addElement(new Attribute("deliveryDelay", Arrays.asList(deliveryDelayValues)));
+
+		this.instanceRandom = new Random(System.currentTimeMillis());
+
+		FastVector classLabels = new FastVector();
+		for (int i = 0; i < classValues.length; i++) {
+			classLabels.addElement(classValues[i]);
 		}
-		return indexOfValue("notInterested", classValues);
-	    }
-
-	    @Override
-	    public Instance makeTrue(Instance intnc) {
-		int part = r.nextInt(2);
-		if (part == 0) {
-		    intnc.setValue(0, indexOfValue("blue", colorValues));
-		    intnc.setValue(2, indexOfValue("60", paymentValues));
-		    intnc.setValue(3, indexOfValue("low", amountValues));
-		    intnc.setValue(4, indexOfValue("normal", deliveryDelayValues));
-		} else {
-		    intnc.setValue(0, indexOfValue("cyan", colorValues));
-		    intnc.setValue(3, indexOfValue("low", amountValues));
-		    intnc.setValue(4, indexOfValue("normal", deliveryDelayValues));
+
+		attributes.addElement(new Attribute("class", classLabels));
+		this.streamHeader = new InstancesHeader(
+				new InstancesHeader(getCLICreationString(InstanceStream.class), attributes, 0));
+		this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
+
+		restart();
+	}
+
+	@Override
+	public InstancesHeader getHeader() {
+		return streamHeader;
+	}
+
+	@Override
+	public long estimatedRemainingInstances() {
+		return Integer.MAX_VALUE;
+	}
+
+	@Override
+	public boolean hasMoreInstances() {
+		return true;
+	}
+
+	@Override
+	public InstanceExample nextInstance() {
+		Instance instnc = null;
+
+		boolean classFound = false;
+		while (!classFound) {
+			// randomize indexes for new instance
+			int indexColor = this.instanceRandom.nextInt(colorValues.length);
+			int indexPrice = this.instanceRandom.nextInt(priceValues.length);
+			int indexPayment = this.instanceRandom.nextInt(paymentValues.length);
+			int indexAmount = this.instanceRandom.nextInt(amountValues.length);
+			int indexDelivery = this.instanceRandom.nextInt(deliveryDelayValues.length);
+			// retrieve values
+			String color = colorValues[indexColor];
+			String price = priceValues[indexPrice];
+			String payment = paymentValues[indexPayment];
+			String amount = amountValues[indexAmount];
+			String delivery = deliveryDelayValues[indexDelivery];
+			int classValue = classFunction.determineClass(color, price, payment, amount, delivery);
+
+			instnc = new DenseInstance(streamHeader.numAttributes());
+			// set values
+			instnc.setDataset(this.getHeader());
+			instnc.setValue(0, Arrays.asList(colorValues).indexOf(color));
+			instnc.setValue(1, Arrays.asList(priceValues).indexOf(price));
+			instnc.setValue(2, Arrays.asList(paymentValues).indexOf(payment));
+			instnc.setValue(3, Arrays.asList(amountValues).indexOf(amount));
+			instnc.setValue(4, Arrays.asList(deliveryDelayValues).indexOf(delivery));
+
+			if (classValue == 0 && !nextClassShouldBeZero) {
+				instnc = classFunction.makeTrue(instnc);
+				classValue = 1;
+				nextClassShouldBeZero = !nextClassShouldBeZero;
+				classFound = true;
+			} else if (classValue == 0 && nextClassShouldBeZero) {
+				nextClassShouldBeZero = !nextClassShouldBeZero;
+				classFound = true;
+			} else if (classValue == 1 && !nextClassShouldBeZero) {
+				nextClassShouldBeZero = !nextClassShouldBeZero;
+				classFound = true;
+			}
+			instnc.setClassValue(classValue);
+
 		}
-		intnc.setClassValue(Arrays.asList(classValues).indexOf("interested"));
-		return intnc;
-	    }	    
+		// add noise
+		int newClassValue = addNoise((int) instnc.classValue());
+		instnc.setClassValue(newClassValue);
+		return new InstanceExample(instnc);
 	}
-    };
-    
-    /*
-     * Generator core
-     */
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-	sb.append("Generates instances based on 5 different concept functions "
-		+ "that describe whether another agent is "
-		+ "interested or not in an item.");
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor tm, ObjectRepository or) {
-	
-	classFunction = concepts[this.functionOption.getValue() - 1];
-
-	FastVector attributes = new FastVector();
-	attributes.addElement(new Attribute("color",
-		Arrays.asList(colorValues)));
-	attributes.addElement(new Attribute("price",
-		Arrays.asList(priceValues)));
-	attributes.addElement(new Attribute("payment",
-		Arrays.asList(paymentValues)));
-	attributes.addElement(new Attribute("amount",
-		Arrays.asList(amountValues)));
-	attributes.addElement(new Attribute("deliveryDelay",
-		Arrays.asList(deliveryDelayValues)));
-
-	this.instanceRandom = new Random(System.currentTimeMillis());
-
-	FastVector classLabels = new FastVector();
-	for (int i = 0; i < classValues.length; i++) {
-	    classLabels.addElement(classValues[i]);
+
+	@Override
+	public boolean isRestartable() {
+		return true;
 	}
 
-	attributes.addElement(new Attribute("class", classLabels));
-	this.streamHeader = new InstancesHeader(new InstancesHeader(
-		getCLICreationString(InstanceStream.class), attributes, 0));
-	this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
-
-	restart();
-    }
-
-    @Override
-    public InstancesHeader getHeader() {
-	return streamHeader;
-    }
-
-    @Override
-    public long estimatedRemainingInstances() {
-	return Integer.MAX_VALUE;
-    }
-
-    @Override
-    public boolean hasMoreInstances() {
-	return true;
-    }
-
-    @Override
-    public InstanceExample nextInstance() {
-	Instance instnc = null;
-
-	boolean classFound = false;
-	while (!classFound) {
-	    //randomize indexes for new instance
-	    int indexColor = this.instanceRandom.nextInt(colorValues.length);
-	    int indexPrice = this.instanceRandom.nextInt(priceValues.length);
-	    int indexPayment = this.instanceRandom.nextInt(paymentValues.length);
-	    int indexAmount = this.instanceRandom.nextInt(amountValues.length);
-	    int indexDelivery = this.instanceRandom.nextInt(deliveryDelayValues.length);
-	    //retrieve values
-	    String color = colorValues[indexColor];
-	    String price = priceValues[indexPrice];
-	    String payment = paymentValues[indexPayment];
-	    String amount = amountValues[indexAmount];
-	    String delivery = deliveryDelayValues[indexDelivery];
-	    int classValue = classFunction.
-		    determineClass(color, price, payment, amount, delivery);
-
-	    instnc = new DenseInstance(streamHeader.numAttributes());
-	    //set values
-	    instnc.setDataset(this.getHeader());
-	    instnc.setValue(0, Arrays.asList(colorValues).indexOf(color));
-	    instnc.setValue(1, Arrays.asList(priceValues).indexOf(price));
-	    instnc.setValue(2, Arrays.asList(paymentValues).indexOf(payment));
-	    instnc.setValue(3, Arrays.asList(amountValues).indexOf(amount));
-	    instnc.setValue(4, Arrays.asList(deliveryDelayValues).indexOf(delivery));
-
-	    if (classValue == 0 && !nextClassShouldBeZero) {
-		instnc = classFunction.makeTrue(instnc);
-		classValue = 1;
-		nextClassShouldBeZero = !nextClassShouldBeZero;
-		classFound = true;
-	    } else if (classValue == 0 && nextClassShouldBeZero) {
-		nextClassShouldBeZero = !nextClassShouldBeZero;
-		classFound = true;
-	    } else if (classValue == 1 && !nextClassShouldBeZero) {
-		nextClassShouldBeZero = !nextClassShouldBeZero;
-		classFound = true;
-	    }
-	    instnc.setClassValue((int) classValue);
-	    
+	@Override
+	public void restart() {
+		this.instanceRandom = new Random(this.instanceRandomSeedOption.getValue());
+		this.nextClassShouldBeZero = false;
 	}
-	//add noise
-	int newClassValue = addNoise((int) instnc.classValue());
-	instnc.setClassValue(newClassValue);
-	return new InstanceExample(instnc);
-    }
-
-    @Override
-    public boolean isRestartable() {
-	return true;
-    }
-
-    @Override
-    public void restart() {
-	this.instanceRandom = new Random(this.instanceRandomSeedOption.getValue());
-	this.nextClassShouldBeZero = false;
-    }
-
-    int addNoise(int classObtained) {
-	if (this.instanceRandom.nextFloat() <= this.noisePercentage.getValue()) {
-	    classObtained = classObtained == 0 ? 1 : 0;
+
+	int addNoise(int classObtained) {
+		if (this.instanceRandom.nextFloat() <= this.noisePercentage.getValue()) {
+			classObtained = classObtained == 0 ? 1 : 0;
+		}
+		return classObtained;
 	}
-	return classObtained;
-    }
 
-    private static int indexOfValue(String value, Object[] arr) {
-	int index = Arrays.asList(arr).indexOf(value);
-	return index;
-    }
+	private static int indexOfValue(String value, Object[] arr) {
+		int index = Arrays.asList(arr).indexOf(value);
+		return index;
+	}
 }
\ No newline at end of file
diff --git a/moa/src/main/java/moa/streams/generators/HyperplaneGenerator.java b/moa/src/main/java/moa/streams/generators/HyperplaneGenerator.java
index 5d8453f47..db10ac645 100644
--- a/moa/src/main/java/moa/streams/generators/HyperplaneGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/HyperplaneGenerator.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams.generators;
 
@@ -23,10 +23,10 @@
 
 import com.github.javacliparser.FloatOption;
 import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
 
 import moa.capabilities.CapabilitiesHandler;
 import moa.capabilities.Capability;
@@ -44,153 +44,150 @@
  * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
  * @version $Revision: 7 $
  */
-public class HyperplaneGenerator extends AbstractOptionHandler implements
-        InstanceStream, CapabilitiesHandler {
-
-    @Override
-    public String getPurposeString() {
-        return "Generates a problem of predicting class of a rotating hyperplane.";
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    public IntOption instanceRandomSeedOption = new IntOption(
-            "instanceRandomSeed", 'i',
-            "Seed for random generation of instances.", 1);
-
-    public IntOption numClassesOption = new IntOption("numClasses", 'c',
-            "The number of classes to generate.", 2, 2, Integer.MAX_VALUE);
-
-    public IntOption numAttsOption = new IntOption("numAtts", 'a',
-            "The number of attributes to generate.", 10, 0, Integer.MAX_VALUE);
-
-    public IntOption numDriftAttsOption = new IntOption("numDriftAtts", 'k',
-            "The number of attributes with drift.", 2, 0, Integer.MAX_VALUE);
-
-    public FloatOption magChangeOption = new FloatOption("magChange", 't',
-            "Magnitude of the change for every example", 0.0, 0.0, 1.0);
-
-    public IntOption noisePercentageOption = new IntOption("noisePercentage",
-            'n', "Percentage of noise to add to the data.", 5, 0, 100);
-
-    public IntOption sigmaPercentageOption = new IntOption("sigmaPercentage",
-            's', "Percentage of probability that the direction of change is reversed.", 10, 0, 100);
-
-    protected InstancesHeader streamHeader;
-
-    protected Random instanceRandom;
-
-    protected double[] weights;
-
-    protected int[] sigma;
-
-    public int numberInstance;
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        monitor.setCurrentActivity("Preparing hyperplane...", -1.0);
-        generateHeader();
-        restart();
-    }
-
-    protected void generateHeader() {
-        FastVector attributes = new FastVector();
-        for (int i = 0; i < this.numAttsOption.getValue(); i++) {
-            attributes.addElement(new Attribute("att" + (i + 1)));
-        }
-
-        FastVector classLabels = new FastVector();
-        for (int i = 0; i < this.numClassesOption.getValue(); i++) {
-            classLabels.addElement("class" + (i + 1));
-        }
-        attributes.addElement(new Attribute("class", classLabels));
-        this.streamHeader = new InstancesHeader(new InstancesHeader(
-                getCLICreationString(InstanceStream.class), attributes, 0));
-        this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
-    }
-
-    @Override
-    public long estimatedRemainingInstances() {
-        return -1;
-    }
-
-    @Override
-    public InstancesHeader getHeader() {
-        return this.streamHeader;
-    }
-
-    @Override
-    public boolean hasMoreInstances() {
-        return true;
-    }
-
-    @Override
-    public boolean isRestartable() {
-        return true;
-    }
-
-    @Override
-    public InstanceExample nextInstance() {
-
-        int numAtts = this.numAttsOption.getValue();
-        double[] attVals = new double[numAtts + 1];
-        double sum = 0.0;
-        double sumWeights = 0.0;
-        for (int i = 0; i < numAtts; i++) {
-            attVals[i] = this.instanceRandom.nextDouble();
-            sum += this.weights[i] * attVals[i];
-            sumWeights += this.weights[i];
-        }
-        int classLabel;
-        if (sum >= sumWeights * 0.5) {
-            classLabel = 1;
-        } else {
-            classLabel = 0;
-        }
-        //Add Noise
-        if ((1 + (this.instanceRandom.nextInt(100))) <= this.noisePercentageOption.getValue()) {
-            classLabel = (classLabel == 0 ? 1 : 0);
-        }
-
-        Instance inst = new DenseInstance(1.0, attVals);
-        inst.setDataset(getHeader());
-        inst.setClassValue(classLabel);
-        addDrift();
-        return new InstanceExample(inst);
-    }
-
-    private void addDrift() {
-        for (int i = 0; i < this.numDriftAttsOption.getValue(); i++) {
-            this.weights[i] += (double) ((double) sigma[i]) * ((double) this.magChangeOption.getValue());
-            if (//this.weights[i] >= 1.0 || this.weights[i] <= 0.0 ||
-                    (1 + (this.instanceRandom.nextInt(100))) <= this.sigmaPercentageOption.getValue()) {
-                this.sigma[i] *= -1;
-            }
-        }
-    }
-
-    @Override
-    public void restart() {
-        this.instanceRandom = new Random(this.instanceRandomSeedOption.getValue());
-        this.weights = new double[this.numAttsOption.getValue()];
-        this.sigma = new int[this.numAttsOption.getValue()];
-        for (int i = 0; i < this.numAttsOption.getValue(); i++) {
-            this.weights[i] = this.instanceRandom.nextDouble();
-            this.sigma[i] = (i < this.numDriftAttsOption.getValue() ? 1 : 0);
-        }
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == HyperplaneGenerator.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
+public class HyperplaneGenerator extends AbstractOptionHandler implements InstanceStream, CapabilitiesHandler {
+
+	@Override
+	public String getPurposeString() {
+		return "Generates a problem of predicting class of a rotating hyperplane.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public IntOption instanceRandomSeedOption = new IntOption("instanceRandomSeed", 'i',
+			"Seed for random generation of instances.", 1);
+
+	public IntOption numClassesOption = new IntOption("numClasses", 'c', "The number of classes to generate.", 2, 2,
+			Integer.MAX_VALUE);
+
+	public IntOption numAttsOption = new IntOption("numAtts", 'a', "The number of attributes to generate.", 10, 0,
+			Integer.MAX_VALUE);
+
+	public IntOption numDriftAttsOption = new IntOption("numDriftAtts", 'k', "The number of attributes with drift.", 2,
+			0, Integer.MAX_VALUE);
+
+	public FloatOption magChangeOption = new FloatOption("magChange", 't', "Magnitude of the change for every example",
+			0.0, 0.0, 1.0);
+
+	public IntOption noisePercentageOption = new IntOption("noisePercentage", 'n',
+			"Percentage of noise to add to the data.", 5, 0, 100);
+
+	public IntOption sigmaPercentageOption = new IntOption("sigmaPercentage", 's',
+			"Percentage of probability that the direction of change is reversed.", 10, 0, 100);
+
+	protected InstancesHeader streamHeader;
+
+	protected Random instanceRandom;
+
+	protected double[] weights;
+
+	protected int[] sigma;
+
+	public int numberInstance;
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		monitor.setCurrentActivity("Preparing hyperplane...", -1.0);
+		generateHeader();
+		restart();
+	}
+
+	protected void generateHeader() {
+		FastVector attributes = new FastVector();
+		for (int i = 0; i < this.numAttsOption.getValue(); i++) {
+			attributes.addElement(new Attribute("att" + (i + 1)));
+		}
+
+		FastVector classLabels = new FastVector();
+		for (int i = 0; i < this.numClassesOption.getValue(); i++) {
+			classLabels.addElement("class" + (i + 1));
+		}
+		attributes.addElement(new Attribute("class", classLabels));
+		this.streamHeader = new InstancesHeader(
+				new InstancesHeader(getCLICreationString(InstanceStream.class), attributes, 0));
+		this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
+	}
+
+	@Override
+	public long estimatedRemainingInstances() {
+		return -1;
+	}
+
+	@Override
+	public InstancesHeader getHeader() {
+		return this.streamHeader;
+	}
+
+	@Override
+	public boolean hasMoreInstances() {
+		return true;
+	}
+
+	@Override
+	public boolean isRestartable() {
+		return true;
+	}
+
+	@Override
+	public InstanceExample nextInstance() {
+
+		int numAtts = this.numAttsOption.getValue();
+		double[] attVals = new double[numAtts + 1];
+		double sum = 0.0;
+		double sumWeights = 0.0;
+		for (int i = 0; i < numAtts; i++) {
+			attVals[i] = this.instanceRandom.nextDouble();
+			sum += this.weights[i] * attVals[i];
+			sumWeights += this.weights[i];
+		}
+		int classLabel;
+		if (sum >= sumWeights * 0.5) {
+			classLabel = 1;
+		} else {
+			classLabel = 0;
+		}
+		// Add Noise
+		if ((1 + (this.instanceRandom.nextInt(100))) <= this.noisePercentageOption.getValue()) {
+			classLabel = (classLabel == 0 ? 1 : 0);
+		}
+
+		Instance inst = new DenseInstance(1.0, attVals);
+		inst.setDataset(getHeader());
+		inst.setClassValue(classLabel);
+		addDrift();
+		return new InstanceExample(inst);
+	}
+
+	private void addDrift() {
+		for (int i = 0; i < this.numDriftAttsOption.getValue(); i++) {
+			this.weights[i] += (sigma[i]) * (this.magChangeOption.getValue());
+			if (// this.weights[i] >= 1.0 || this.weights[i] <= 0.0 ||
+			(1 + (this.instanceRandom.nextInt(100))) <= this.sigmaPercentageOption.getValue()) {
+				this.sigma[i] *= -1;
+			}
+		}
+	}
+
+	@Override
+	public void restart() {
+		this.instanceRandom = new Random(this.instanceRandomSeedOption.getValue());
+		this.weights = new double[this.numAttsOption.getValue()];
+		this.sigma = new int[this.numAttsOption.getValue()];
+		for (int i = 0; i < this.numAttsOption.getValue(); i++) {
+			this.weights[i] = this.instanceRandom.nextDouble();
+			this.sigma[i] = (i < this.numDriftAttsOption.getValue() ? 1 : 0);
+		}
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == HyperplaneGenerator.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
 }
diff --git a/moa/src/main/java/moa/streams/generators/LEDGenerator.java b/moa/src/main/java/moa/streams/generators/LEDGenerator.java
index 76033dacd..4f310575f 100644
--- a/moa/src/main/java/moa/streams/generators/LEDGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/LEDGenerator.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams.generators;
 
@@ -25,13 +25,12 @@
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
-import moa.capabilities.CapabilitiesHandler;
-import moa.capabilities.Capability;
-import moa.capabilities.ImmutableCapabilities;
-import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.capabilities.CapabilitiesHandler;
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
 import moa.core.FastVector;
 import moa.core.InstanceExample;
 import moa.core.ObjectRepository;
@@ -40,128 +39,122 @@
 import moa.tasks.TaskMonitor;
 
 /**
- * Stream generator for the problem of predicting the digit displayed on a 7-segment LED display.
+ * Stream generator for the problem of predicting the digit displayed on a
+ * 7-segment LED display.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class LEDGenerator extends AbstractOptionHandler implements
-        InstanceStream, CapabilitiesHandler {
-
-    @Override
-    public String getPurposeString() {
-        return "Generates a problem of predicting the digit displayed on a 7-segment LED display.";
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    public static final int NUM_IRRELEVANT_ATTRIBUTES = 17;
-
-    protected static final int originalInstances[][] = {
-        {1, 1, 1, 0, 1, 1, 1}, {0, 0, 1, 0, 0, 1, 0},
-        {1, 0, 1, 1, 1, 0, 1}, {1, 0, 1, 1, 0, 1, 1},
-        {0, 1, 1, 1, 0, 1, 0}, {1, 1, 0, 1, 0, 1, 1},
-        {1, 1, 0, 1, 1, 1, 1}, {1, 0, 1, 0, 0, 1, 0},
-        {1, 1, 1, 1, 1, 1, 1}, {1, 1, 1, 1, 0, 1, 1}};
-
-    public IntOption instanceRandomSeedOption = new IntOption(
-            "instanceRandomSeed", 'i',
-            "Seed for random generation of instances.", 1);
-
-    public IntOption noisePercentageOption = new IntOption("noisePercentage",
-            'n', "Percentage of noise to add to the data.", 10, 0, 100);
-
-    public FlagOption suppressIrrelevantAttributesOption = new FlagOption(
-            "suppressIrrelevantAttributes", 's',
-            "Reduce the data to only contain 7 relevant binary attributes.");
-
-    protected InstancesHeader streamHeader;
-
-    protected Random instanceRandom;
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        // generate header
-        FastVector attributes = new FastVector();
-        FastVector binaryLabels = new FastVector();
-        binaryLabels.addElement("0");
-        binaryLabels.addElement("1");
-        int numAtts = 7;
-        if (!this.suppressIrrelevantAttributesOption.isSet()) {
-            numAtts += NUM_IRRELEVANT_ATTRIBUTES;
-        }
-        for (int i = 0; i < numAtts; i++) {
-            attributes.addElement(new Attribute("att" + (i + 1), binaryLabels));
-        }
-        FastVector classLabels = new FastVector();
-        for (int i = 0; i < 10; i++) {
-            classLabels.addElement(Integer.toString(i));
-        }
-        attributes.addElement(new Attribute("class", classLabels));
-        this.streamHeader = new InstancesHeader(new InstancesHeader(
-                getCLICreationString(InstanceStream.class), attributes, 0));
-        this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
-        restart();
-    }
-
-    @Override
-    public long estimatedRemainingInstances() {
-        return -1;
-    }
-
-    @Override
-    public InstancesHeader getHeader() {
-        return this.streamHeader;
-    }
-
-    @Override
-    public boolean hasMoreInstances() {
-        return true;
-    }
-
-    @Override
-    public boolean isRestartable() {
-        return true;
-    }
-
-    @Override
-    public InstanceExample nextInstance() {
-        InstancesHeader header = getHeader();
-        Instance inst = new DenseInstance(header.numAttributes());
-        inst.setDataset(header);
-        int selected = this.instanceRandom.nextInt(10);
-        for (int i = 0; i < 7; i++) {
-            if ((1 + (this.instanceRandom.nextInt(100))) <= this.noisePercentageOption.getValue()) {
-                inst.setValue(i, originalInstances[selected][i] == 0 ? 1 : 0);
-            } else {
-                inst.setValue(i, originalInstances[selected][i]);
-            }
-        }
-        if (!this.suppressIrrelevantAttributesOption.isSet()) {
-            for (int i = 0; i < NUM_IRRELEVANT_ATTRIBUTES; i++) {
-                inst.setValue(i + 7, this.instanceRandom.nextInt(2));
-            }
-        }
-        inst.setClassValue(selected);
-        return new InstanceExample(inst);
-    }
-
-    @Override
-    public void restart() {
-        this.instanceRandom = new Random(this.instanceRandomSeedOption.getValue());
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == LEDGenerator.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
+public class LEDGenerator extends AbstractOptionHandler implements InstanceStream, CapabilitiesHandler {
+
+	@Override
+	public String getPurposeString() {
+		return "Generates a problem of predicting the digit displayed on a 7-segment LED display.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public static final int NUM_IRRELEVANT_ATTRIBUTES = 17;
+
+	protected static final int originalInstances[][] = { { 1, 1, 1, 0, 1, 1, 1 }, { 0, 0, 1, 0, 0, 1, 0 },
+			{ 1, 0, 1, 1, 1, 0, 1 }, { 1, 0, 1, 1, 0, 1, 1 }, { 0, 1, 1, 1, 0, 1, 0 }, { 1, 1, 0, 1, 0, 1, 1 },
+			{ 1, 1, 0, 1, 1, 1, 1 }, { 1, 0, 1, 0, 0, 1, 0 }, { 1, 1, 1, 1, 1, 1, 1 }, { 1, 1, 1, 1, 0, 1, 1 } };
+
+	public IntOption instanceRandomSeedOption = new IntOption("instanceRandomSeed", 'i',
+			"Seed for random generation of instances.", 1);
+
+	public IntOption noisePercentageOption = new IntOption("noisePercentage", 'n',
+			"Percentage of noise to add to the data.", 10, 0, 100);
+
+	public FlagOption suppressIrrelevantAttributesOption = new FlagOption("suppressIrrelevantAttributes", 's',
+			"Reduce the data to only contain 7 relevant binary attributes.");
+
+	protected InstancesHeader streamHeader;
+
+	protected Random instanceRandom;
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// generate header
+		FastVector attributes = new FastVector();
+		FastVector binaryLabels = new FastVector();
+		binaryLabels.addElement("0");
+		binaryLabels.addElement("1");
+		int numAtts = 7;
+		if (!this.suppressIrrelevantAttributesOption.isSet()) {
+			numAtts += NUM_IRRELEVANT_ATTRIBUTES;
+		}
+		for (int i = 0; i < numAtts; i++) {
+			attributes.addElement(new Attribute("att" + (i + 1), binaryLabels));
+		}
+		FastVector classLabels = new FastVector();
+		for (int i = 0; i < 10; i++) {
+			classLabels.addElement(Integer.toString(i));
+		}
+		attributes.addElement(new Attribute("class", classLabels));
+		this.streamHeader = new InstancesHeader(
+				new InstancesHeader(getCLICreationString(InstanceStream.class), attributes, 0));
+		this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
+		restart();
+	}
+
+	@Override
+	public long estimatedRemainingInstances() {
+		return -1;
+	}
+
+	@Override
+	public InstancesHeader getHeader() {
+		return this.streamHeader;
+	}
+
+	@Override
+	public boolean hasMoreInstances() {
+		return true;
+	}
+
+	@Override
+	public boolean isRestartable() {
+		return true;
+	}
+
+	@Override
+	public InstanceExample nextInstance() {
+		InstancesHeader header = getHeader();
+		Instance inst = new DenseInstance(header.numAttributes());
+		inst.setDataset(header);
+		int selected = this.instanceRandom.nextInt(10);
+		for (int i = 0; i < 7; i++) {
+			if ((1 + (this.instanceRandom.nextInt(100))) <= this.noisePercentageOption.getValue()) {
+				inst.setValue(i, originalInstances[selected][i] == 0 ? 1 : 0);
+			} else {
+				inst.setValue(i, originalInstances[selected][i]);
+			}
+		}
+		if (!this.suppressIrrelevantAttributesOption.isSet()) {
+			for (int i = 0; i < NUM_IRRELEVANT_ATTRIBUTES; i++) {
+				inst.setValue(i + 7, this.instanceRandom.nextInt(2));
+			}
+		}
+		inst.setClassValue(selected);
+		return new InstanceExample(inst);
+	}
+
+	@Override
+	public void restart() {
+		this.instanceRandom = new Random(this.instanceRandomSeedOption.getValue());
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == LEDGenerator.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
 }
diff --git a/moa/src/main/java/moa/streams/generators/LEDGeneratorDrift.java b/moa/src/main/java/moa/streams/generators/LEDGeneratorDrift.java
index 03e7843ab..43afe7018 100644
--- a/moa/src/main/java/moa/streams/generators/LEDGeneratorDrift.java
+++ b/moa/src/main/java/moa/streams/generators/LEDGeneratorDrift.java
@@ -15,96 +15,94 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams.generators;
 
-import moa.capabilities.Capability;
-import moa.capabilities.ImmutableCapabilities;
-import moa.core.InstanceExample;
-
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
 import moa.core.InstanceExample;
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
 
 /**
- * Stream generator for the problem of predicting the digit displayed on a 7-segment LED display with drift.
+ * Stream generator for the problem of predicting the digit displayed on a
+ * 7-segment LED display with drift.
  *
  * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
  * @version $Revision: 7 $
  */
 public class LEDGeneratorDrift extends LEDGenerator {
 
-    @Override
-    public String getPurposeString() {
-        return "Generates a problem of predicting the digit displayed on a 7-segment LED display with drift.";
-    }
+	@Override
+	public String getPurposeString() {
+		return "Generates a problem of predicting the digit displayed on a 7-segment LED display with drift.";
+	}
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public IntOption numberAttributesDriftOption = new IntOption("numberAttributesDrift",
-            'd', "Number of attributes with drift.", 1, 0, 7);
+	public IntOption numberAttributesDriftOption = new IntOption("numberAttributesDrift", 'd',
+			"Number of attributes with drift.", 1, 0, 7);
 
-    protected int[] numberAttribute;
+	protected int[] numberAttribute;
 
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        super.prepareForUseImpl(monitor, repository);
-        this.numberAttribute = new int[7 + NUM_IRRELEVANT_ATTRIBUTES];
-        for (int i = 0; i < 7 + NUM_IRRELEVANT_ATTRIBUTES; i++) {
-            this.numberAttribute[i] = i;
-        }
-        //Change atributes
-        if (!this.suppressIrrelevantAttributesOption.isSet() && this.numberAttributesDriftOption.getValue() > 0) {
-            int randomInt = 0;//this.instanceRandom.nextInt(7);
-            int offset = 0;//this.instanceRandom.nextInt(NUM_IRRELEVANT_ATTRIBUTES);
-            for (int i = 0; i < this.numberAttributesDriftOption.getValue(); i++) {
-                int value1 = (i + randomInt) % 7;
-                int value2 = 7 + ((i + offset) % (NUM_IRRELEVANT_ATTRIBUTES));
-                this.numberAttribute[value1] = value2;
-                this.numberAttribute[value2] = value1;
-            }
-        }
-    }
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		super.prepareForUseImpl(monitor, repository);
+		this.numberAttribute = new int[7 + NUM_IRRELEVANT_ATTRIBUTES];
+		for (int i = 0; i < 7 + NUM_IRRELEVANT_ATTRIBUTES; i++) {
+			this.numberAttribute[i] = i;
+		}
+		// Change atributes
+		if (!this.suppressIrrelevantAttributesOption.isSet() && this.numberAttributesDriftOption.getValue() > 0) {
+			int randomInt = 0;// this.instanceRandom.nextInt(7);
+			int offset = 0;// this.instanceRandom.nextInt(NUM_IRRELEVANT_ATTRIBUTES);
+			for (int i = 0; i < this.numberAttributesDriftOption.getValue(); i++) {
+				int value1 = (i + randomInt) % 7;
+				int value2 = 7 + ((i + offset) % (NUM_IRRELEVANT_ATTRIBUTES));
+				this.numberAttribute[value1] = value2;
+				this.numberAttribute[value2] = value1;
+			}
+		}
+	}
 
-    @Override
-    public InstanceExample nextInstance() {
-        InstancesHeader header = getHeader();
-        Instance inst = new DenseInstance(header.numAttributes());
-        inst.setDataset(header);
-        int selected = this.instanceRandom.nextInt(10);
-        for (int i = 0; i < 7; i++) {
-            if ((1 + (this.instanceRandom.nextInt(100))) <= this.noisePercentageOption.getValue()) {
-                inst.setValue(this.numberAttribute[i], originalInstances[selected][i] == 0 ? 1 : 0);
-            } else {
-                inst.setValue(this.numberAttribute[i], originalInstances[selected][i]);
-            }
-        }
-        if (!this.suppressIrrelevantAttributesOption.isSet()) {
-            for (int i = 0; i < NUM_IRRELEVANT_ATTRIBUTES; i++) {
-                inst.setValue(this.numberAttribute[i + 7], this.instanceRandom.nextInt(2));
-            }
-        }
-        inst.setClassValue(selected);
-        return new InstanceExample(inst);
-    }
+	@Override
+	public InstanceExample nextInstance() {
+		InstancesHeader header = getHeader();
+		Instance inst = new DenseInstance(header.numAttributes());
+		inst.setDataset(header);
+		int selected = this.instanceRandom.nextInt(10);
+		for (int i = 0; i < 7; i++) {
+			if ((1 + (this.instanceRandom.nextInt(100))) <= this.noisePercentageOption.getValue()) {
+				inst.setValue(this.numberAttribute[i], originalInstances[selected][i] == 0 ? 1 : 0);
+			} else {
+				inst.setValue(this.numberAttribute[i], originalInstances[selected][i]);
+			}
+		}
+		if (!this.suppressIrrelevantAttributesOption.isSet()) {
+			for (int i = 0; i < NUM_IRRELEVANT_ATTRIBUTES; i++) {
+				inst.setValue(this.numberAttribute[i + 7], this.instanceRandom.nextInt(2));
+			}
+		}
+		inst.setClassValue(selected);
+		return new InstanceExample(inst);
+	}
 
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
 
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == LEDGeneratorDrift.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == LEDGeneratorDrift.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
 }
diff --git a/moa/src/main/java/moa/streams/generators/MixedGenerator.java b/moa/src/main/java/moa/streams/generators/MixedGenerator.java
index f2a803225..937ddf19e 100644
--- a/moa/src/main/java/moa/streams/generators/MixedGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/MixedGenerator.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams.generators;
 
@@ -37,158 +37,151 @@
 import moa.tasks.TaskMonitor;
 
 /**
- * Abrupt concept drift, boolean noise-free examples. Four relevant attributes, 
- * two boolean attributes v,w and two numeric attributes from [0; 1]. The 
- * examples are classified positive if two of three conditions are satisfied: 
- * v,w, y &lt; 0,5 + 0,3 sin(3 * PI * x). After each context change the 
- * classification is reversed. Proposed by "Gama, Joao, et al. "Learning with 
- * drift detection." Advances in artificial intelligence–SBIA 2004. Springer 
+ * Abrupt concept drift, boolean noise-free examples. Four relevant attributes,
+ * two boolean attributes v,w and two numeric attributes from [0; 1]. The
+ * examples are classified positive if two of three conditions are satisfied:
+ * v,w, y &lt; 0,5 + 0,3 sin(3 * PI * x). After each context change the
+ * classification is reversed. Proposed by "Gama, Joao, et al. "Learning with
+ * drift detection." Advances in artificial intelligence–SBIA 2004. Springer
  * Berlin Heidelberg, 2004. 286-295."
  *
  * @author Paulo Gonçalves (paulogoncalves@recife.ifpe.edu.br)
  * @version $Revision: 1 $
  */
-public class MixedGenerator extends AbstractOptionHandler implements
-        InstanceStream {
-
-    public IntOption functionOption = new IntOption("function", 'f',
-            "Classification function used, as defined in the original paper.",
-            1, 1, 2);
-
-    public IntOption instanceRandomSeedOption = new IntOption(
-            "instanceRandomSeed", 'i',
-            "Seed for random generation of instances.", 1);
-
-    public FlagOption balanceClassesOption = new FlagOption("balanceClasses",
-            'b', "Balance the number of instances of each class.");
-
-    protected InstancesHeader streamHeader;
-
-    protected Random instanceRandom;
-
-    protected boolean nextClassShouldBeZero;
-
-    protected interface ClassFunction {
-
-        public int determineClass(double v, double w, double x, double y);
-    }
-
-    protected static ClassFunction[] classificationFunctions = {
-        new ClassFunction() {
-            @Override
-            public int determineClass(double v, double w, double x, double y) {
-                boolean z = y < 0.5 + 0.3 * Math.sin(3 * Math.PI * x);
-                if ((v == 1 && w == 1) || (v == 1 && z) || (w == 1 && z)) {
-                    return 0;
-                } else {
-                    return 1;
-                }
-            }
-        },
-        new ClassFunction() {
-            @Override
-            public int determineClass(double v, double w, double x, double y) {
-                boolean z = y < 0.5 + 0.3 * Math.sin(3 * Math.PI * x);
-                if ((v == 1 && w == 1) || (v == 1 && z) || (w == 1 && z)) {
-                    return 1;
-                } else {
-                    return 0;
-                }
-            }
-        },};
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-
-    }
-
-    @Override
-    public InstancesHeader getHeader() {
-        return this.streamHeader;
-    }
-
-    @Override
-    public long estimatedRemainingInstances() {
-        return -1;
-    }
-
-    @Override
-    public boolean hasMoreInstances() {
-        return true;
-    }
-
-    @Override
-    public InstanceExample nextInstance() {
-        double v = 0, w = 0, x = 0, y = 0, group = 0;
-        boolean desiredClassFound = false;
-        while (!desiredClassFound) {
-            v = (this.instanceRandom.nextDouble() < 0.5) ? 0 : 1;
-            w = (this.instanceRandom.nextDouble() < 0.5) ? 0 : 1;
-            x = this.instanceRandom.nextDouble();
-            y = this.instanceRandom.nextDouble();
-            group = classificationFunctions[this.functionOption.getValue() - 1].determineClass(v, w, x, y);
-            if (!this.balanceClassesOption.isSet()) {
-                desiredClassFound = true;
-            } else {
-                // balance the classes
-                if ((this.nextClassShouldBeZero && (group == 0))
-                        || (!this.nextClassShouldBeZero && (group == 1))) {
-                    desiredClassFound = true;
-                    this.nextClassShouldBeZero = !this.nextClassShouldBeZero;
-                } // else keep searching
-            }
-        }
-        // construct instance
-        InstancesHeader header = getHeader();
-        Instance inst = new DenseInstance(header.numAttributes());
-        inst.setValue(0, v);
-        inst.setValue(1, w);
-        inst.setValue(2, x);
-        inst.setValue(3, y);
-        inst.setDataset(header);
-        inst.setClassValue(group);
-        return new InstanceExample(inst);
-    }
-
-    @Override
-    public boolean isRestartable() {
-        return true;
-    }
-
-    @Override
-    public void restart() {
-        this.instanceRandom = new Random(this.instanceRandomSeedOption.getValue());
-        this.nextClassShouldBeZero = false;
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        List booleanLabels = new ArrayList();
-        booleanLabels.add("0");
-        booleanLabels.add("1");
-
-        ArrayList<Attribute> attributes = new ArrayList();
-        Attribute attribute1 = new Attribute("v", booleanLabels);
-        Attribute attribute2 = new Attribute("w", booleanLabels);
-
-        Attribute attribute3 = new Attribute("x");
-        Attribute attribute4 = new Attribute("y");
-
-        List classLabels = new ArrayList();
-        classLabels.add("positive");
-        classLabels.add("negative");
-        Attribute classAtt = new Attribute("class", classLabels);
-
-        attributes.add(attribute1);
-        attributes.add(attribute2);
-        attributes.add(attribute3);
-        attributes.add(attribute4);
-        attributes.add(classAtt);
-
-        this.streamHeader = new InstancesHeader(new InstancesHeader(
-                getCLICreationString(InstanceStream.class), attributes, 0));
-        this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
-        restart();
-    }
+public class MixedGenerator extends AbstractOptionHandler implements InstanceStream {
+
+	public IntOption functionOption = new IntOption("function", 'f',
+			"Classification function used, as defined in the original paper.", 1, 1, 2);
+
+	public IntOption instanceRandomSeedOption = new IntOption("instanceRandomSeed", 'i',
+			"Seed for random generation of instances.", 1);
+
+	public FlagOption balanceClassesOption = new FlagOption("balanceClasses", 'b',
+			"Balance the number of instances of each class.");
+
+	protected InstancesHeader streamHeader;
+
+	protected Random instanceRandom;
+
+	protected boolean nextClassShouldBeZero;
+
+	protected interface ClassFunction {
+
+		int determineClass(double v, double w, double x, double y);
+	}
+
+	protected static ClassFunction[] classificationFunctions = { new ClassFunction() {
+		@Override
+		public int determineClass(double v, double w, double x, double y) {
+			boolean z = y < 0.5 + 0.3 * Math.sin(3 * Math.PI * x);
+			if ((v == 1 && w == 1) || (v == 1 && z) || (w == 1 && z)) {
+				return 0;
+			} else {
+				return 1;
+			}
+		}
+	}, new ClassFunction() {
+		@Override
+		public int determineClass(double v, double w, double x, double y) {
+			boolean z = y < 0.5 + 0.3 * Math.sin(3 * Math.PI * x);
+			if ((v == 1 && w == 1) || (v == 1 && z) || (w == 1 && z)) {
+				return 1;
+			} else {
+				return 0;
+			}
+		}
+	}, };
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+
+	}
+
+	@Override
+	public InstancesHeader getHeader() {
+		return this.streamHeader;
+	}
+
+	@Override
+	public long estimatedRemainingInstances() {
+		return -1;
+	}
+
+	@Override
+	public boolean hasMoreInstances() {
+		return true;
+	}
+
+	@Override
+	public InstanceExample nextInstance() {
+		double v = 0, w = 0, x = 0, y = 0, group = 0;
+		boolean desiredClassFound = false;
+		while (!desiredClassFound) {
+			v = (this.instanceRandom.nextDouble() < 0.5) ? 0 : 1;
+			w = (this.instanceRandom.nextDouble() < 0.5) ? 0 : 1;
+			x = this.instanceRandom.nextDouble();
+			y = this.instanceRandom.nextDouble();
+			group = classificationFunctions[this.functionOption.getValue() - 1].determineClass(v, w, x, y);
+			if (!this.balanceClassesOption.isSet()) {
+				desiredClassFound = true;
+			} else {
+				// balance the classes
+				if ((this.nextClassShouldBeZero && (group == 0)) || (!this.nextClassShouldBeZero && (group == 1))) {
+					desiredClassFound = true;
+					this.nextClassShouldBeZero = !this.nextClassShouldBeZero;
+				} // else keep searching
+			}
+		}
+		// construct instance
+		InstancesHeader header = getHeader();
+		Instance inst = new DenseInstance(header.numAttributes());
+		inst.setValue(0, v);
+		inst.setValue(1, w);
+		inst.setValue(2, x);
+		inst.setValue(3, y);
+		inst.setDataset(header);
+		inst.setClassValue(group);
+		return new InstanceExample(inst);
+	}
+
+	@Override
+	public boolean isRestartable() {
+		return true;
+	}
+
+	@Override
+	public void restart() {
+		this.instanceRandom = new Random(this.instanceRandomSeedOption.getValue());
+		this.nextClassShouldBeZero = false;
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		List booleanLabels = new ArrayList();
+		booleanLabels.add("0");
+		booleanLabels.add("1");
+
+		ArrayList<Attribute> attributes = new ArrayList();
+		Attribute attribute1 = new Attribute("v", booleanLabels);
+		Attribute attribute2 = new Attribute("w", booleanLabels);
+
+		Attribute attribute3 = new Attribute("x");
+		Attribute attribute4 = new Attribute("y");
+
+		List classLabels = new ArrayList();
+		classLabels.add("positive");
+		classLabels.add("negative");
+		Attribute classAtt = new Attribute("class", classLabels);
+
+		attributes.add(attribute1);
+		attributes.add(attribute2);
+		attributes.add(attribute3);
+		attributes.add(attribute4);
+		attributes.add(classAtt);
+
+		this.streamHeader = new InstancesHeader(
+				new InstancesHeader(getCLICreationString(InstanceStream.class), attributes, 0));
+		this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
+		restart();
+	}
 }
diff --git a/moa/src/main/java/moa/streams/generators/RandomRBFGenerator.java b/moa/src/main/java/moa/streams/generators/RandomRBFGenerator.java
index 87e5fbdba..8651b4f18 100644
--- a/moa/src/main/java/moa/streams/generators/RandomRBFGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/RandomRBFGenerator.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams.generators;
 
@@ -25,13 +25,12 @@
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
-import moa.capabilities.CapabilitiesHandler;
-import moa.capabilities.Capability;
-import moa.capabilities.ImmutableCapabilities;
-import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.capabilities.CapabilitiesHandler;
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
 import moa.core.FastVector;
 import moa.core.InstanceExample;
 import moa.core.MiscUtils;
@@ -46,153 +45,149 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class RandomRBFGenerator extends AbstractOptionHandler implements
-        InstanceStream, CapabilitiesHandler {
-
-    @Override
-    public String getPurposeString() {
-        return "Generates a random radial basis function stream.";
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    public IntOption modelRandomSeedOption = new IntOption("modelRandomSeed",
-            'r', "Seed for random generation of model.", 1);
-
-    public IntOption instanceRandomSeedOption = new IntOption(
-            "instanceRandomSeed", 'i',
-            "Seed for random generation of instances.", 1);
-
-    public IntOption numClassesOption = new IntOption("numClasses", 'c',
-            "The number of classes to generate.", 2, 2, Integer.MAX_VALUE);
-
-    public IntOption numAttsOption = new IntOption("numAtts", 'a',
-            "The number of attributes to generate.", 10, 0, Integer.MAX_VALUE);
-
-    public IntOption numCentroidsOption = new IntOption("numCentroids", 'n',
-            "The number of centroids in the model.", 50, 1, Integer.MAX_VALUE);
-
-    protected static class Centroid implements Serializable {
-
-        private static final long serialVersionUID = 1L;
-
-        public double[] centre;
-
-        public int classLabel;
-
-        public double stdDev;
-    }
-
-    protected InstancesHeader streamHeader;
-
-    protected Centroid[] centroids;
-
-    protected double[] centroidWeights;
-
-    protected Random instanceRandom;
-
-    @Override
-    public void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        monitor.setCurrentActivity("Preparing random RBF...", -1.0);
-        generateHeader();
-        generateCentroids();
-        restart();
-    }
-
-    @Override
-    public InstancesHeader getHeader() {
-        return this.streamHeader;
-    }
-
-    @Override
-    public long estimatedRemainingInstances() {
-        return -1;
-    }
-
-    @Override
-    public boolean hasMoreInstances() {
-        return true;
-    }
-
-    @Override
-    public boolean isRestartable() {
-        return true;
-    }
-
-    @Override
-    public void restart() {
-        this.instanceRandom = new Random(this.instanceRandomSeedOption.getValue());
-    }
-
-    @Override
-    public InstanceExample nextInstance() {
-        Centroid centroid = this.centroids[MiscUtils.chooseRandomIndexBasedOnWeights(this.centroidWeights,
-                this.instanceRandom)];
-        int numAtts = this.numAttsOption.getValue();
-        double[] attVals = new double[numAtts + 1];
-        for (int i = 0; i < numAtts; i++) {
-            attVals[i] = (this.instanceRandom.nextDouble() * 2.0) - 1.0;
-        }
-        double magnitude = 0.0;
-        for (int i = 0; i < numAtts; i++) {
-            magnitude += attVals[i] * attVals[i];
-        }
-        magnitude = Math.sqrt(magnitude);
-        double desiredMag = this.instanceRandom.nextGaussian()
-                * centroid.stdDev;
-        double scale = desiredMag / magnitude;
-        for (int i = 0; i < numAtts; i++) {
-            attVals[i] = centroid.centre[i] + attVals[i] * scale;
-        }
-        Instance inst = new DenseInstance(1.0, attVals);
-        inst.setDataset(getHeader());
-        inst.setClassValue(centroid.classLabel);
-        return new InstanceExample(inst);
-    }
-
-    protected void generateHeader() {
-        FastVector attributes = new FastVector();
-        for (int i = 0; i < this.numAttsOption.getValue(); i++) {
-            attributes.addElement(new Attribute("att" + (i + 1)));
-        }
-        FastVector classLabels = new FastVector();
-        for (int i = 0; i < this.numClassesOption.getValue(); i++) {
-            classLabels.addElement("class" + (i + 1));
-        }
-        attributes.addElement(new Attribute("class", classLabels));
-        this.streamHeader = new InstancesHeader(new InstancesHeader(
-                getCLICreationString(InstanceStream.class), attributes, 0));
-        this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
-    }
-
-    protected void generateCentroids() {
-        Random modelRand = new Random(this.modelRandomSeedOption.getValue());
-        this.centroids = new Centroid[this.numCentroidsOption.getValue()];
-        this.centroidWeights = new double[this.centroids.length];
-        for (int i = 0; i < this.centroids.length; i++) {
-            this.centroids[i] = new Centroid();
-            double[] randCentre = new double[this.numAttsOption.getValue()];
-            for (int j = 0; j < randCentre.length; j++) {
-                randCentre[j] = modelRand.nextDouble();
-            }
-            this.centroids[i].centre = randCentre;
-            this.centroids[i].classLabel = modelRand.nextInt(this.numClassesOption.getValue());
-            this.centroids[i].stdDev = modelRand.nextDouble();
-            this.centroidWeights[i] = modelRand.nextDouble();
-        }
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == RandomRBFGenerator.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
+public class RandomRBFGenerator extends AbstractOptionHandler implements InstanceStream, CapabilitiesHandler {
+
+	@Override
+	public String getPurposeString() {
+		return "Generates a random radial basis function stream.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public IntOption modelRandomSeedOption = new IntOption("modelRandomSeed", 'r',
+			"Seed for random generation of model.", 1);
+
+	public IntOption instanceRandomSeedOption = new IntOption("instanceRandomSeed", 'i',
+			"Seed for random generation of instances.", 1);
+
+	public IntOption numClassesOption = new IntOption("numClasses", 'c', "The number of classes to generate.", 2, 2,
+			Integer.MAX_VALUE);
+
+	public IntOption numAttsOption = new IntOption("numAtts", 'a', "The number of attributes to generate.", 10, 0,
+			Integer.MAX_VALUE);
+
+	public IntOption numCentroidsOption = new IntOption("numCentroids", 'n', "The number of centroids in the model.",
+			50, 1, Integer.MAX_VALUE);
+
+	protected static class Centroid implements Serializable {
+
+		private static final long serialVersionUID = 1L;
+
+		public double[] centre;
+
+		public int classLabel;
+
+		public double stdDev;
+	}
+
+	protected InstancesHeader streamHeader;
+
+	protected Centroid[] centroids;
+
+	protected double[] centroidWeights;
+
+	protected Random instanceRandom;
+
+	@Override
+	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		monitor.setCurrentActivity("Preparing random RBF...", -1.0);
+		generateHeader();
+		generateCentroids();
+		restart();
+	}
+
+	@Override
+	public InstancesHeader getHeader() {
+		return this.streamHeader;
+	}
+
+	@Override
+	public long estimatedRemainingInstances() {
+		return -1;
+	}
+
+	@Override
+	public boolean hasMoreInstances() {
+		return true;
+	}
+
+	@Override
+	public boolean isRestartable() {
+		return true;
+	}
+
+	@Override
+	public void restart() {
+		this.instanceRandom = new Random(this.instanceRandomSeedOption.getValue());
+	}
+
+	@Override
+	public InstanceExample nextInstance() {
+		Centroid centroid = this.centroids[MiscUtils.chooseRandomIndexBasedOnWeights(this.centroidWeights,
+				this.instanceRandom)];
+		int numAtts = this.numAttsOption.getValue();
+		double[] attVals = new double[numAtts + 1];
+		for (int i = 0; i < numAtts; i++) {
+			attVals[i] = (this.instanceRandom.nextDouble() * 2.0) - 1.0;
+		}
+		double magnitude = 0.0;
+		for (int i = 0; i < numAtts; i++) {
+			magnitude += attVals[i] * attVals[i];
+		}
+		magnitude = Math.sqrt(magnitude);
+		double desiredMag = this.instanceRandom.nextGaussian() * centroid.stdDev;
+		double scale = desiredMag / magnitude;
+		for (int i = 0; i < numAtts; i++) {
+			attVals[i] = centroid.centre[i] + attVals[i] * scale;
+		}
+		Instance inst = new DenseInstance(1.0, attVals);
+		inst.setDataset(getHeader());
+		inst.setClassValue(centroid.classLabel);
+		return new InstanceExample(inst);
+	}
+
+	protected void generateHeader() {
+		FastVector attributes = new FastVector();
+		for (int i = 0; i < this.numAttsOption.getValue(); i++) {
+			attributes.addElement(new Attribute("att" + (i + 1)));
+		}
+		FastVector classLabels = new FastVector();
+		for (int i = 0; i < this.numClassesOption.getValue(); i++) {
+			classLabels.addElement("class" + (i + 1));
+		}
+		attributes.addElement(new Attribute("class", classLabels));
+		this.streamHeader = new InstancesHeader(
+				new InstancesHeader(getCLICreationString(InstanceStream.class), attributes, 0));
+		this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
+	}
+
+	protected void generateCentroids() {
+		Random modelRand = new Random(this.modelRandomSeedOption.getValue());
+		this.centroids = new Centroid[this.numCentroidsOption.getValue()];
+		this.centroidWeights = new double[this.centroids.length];
+		for (int i = 0; i < this.centroids.length; i++) {
+			this.centroids[i] = new Centroid();
+			double[] randCentre = new double[this.numAttsOption.getValue()];
+			for (int j = 0; j < randCentre.length; j++) {
+				randCentre[j] = modelRand.nextDouble();
+			}
+			this.centroids[i].centre = randCentre;
+			this.centroids[i].classLabel = modelRand.nextInt(this.numClassesOption.getValue());
+			this.centroids[i].stdDev = modelRand.nextDouble();
+			this.centroidWeights[i] = modelRand.nextDouble();
+		}
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == RandomRBFGenerator.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
 }
diff --git a/moa/src/main/java/moa/streams/generators/RandomRBFGeneratorDrift.java b/moa/src/main/java/moa/streams/generators/RandomRBFGeneratorDrift.java
index 1a6d08507..ea7ea44f0 100644
--- a/moa/src/main/java/moa/streams/generators/RandomRBFGeneratorDrift.java
+++ b/moa/src/main/java/moa/streams/generators/RandomRBFGeneratorDrift.java
@@ -2,7 +2,7 @@
  *    RandomRBFGeneratorDrift.java
  *    Copyright (C) 2008 University of Waikato, Hamilton, New Zealand
  *    @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
- * 
+ *
  *    This program is free software; you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
  *    the Free Software Foundation; either version 3 of the License, or
@@ -15,19 +15,19 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams.generators;
 
 import java.util.Random;
 
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+
 import moa.capabilities.Capability;
 import moa.capabilities.ImmutableCapabilities;
 import moa.core.InstanceExample;
 
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-
 /**
  * Stream generator for a random radial basis function stream with drift.
  *
@@ -36,78 +36,78 @@
  */
 public class RandomRBFGeneratorDrift extends RandomRBFGenerator {
 
-    @Override
-    public String getPurposeString() {
-        return "Generates a random radial basis function stream with drift.";
-    }
+	@Override
+	public String getPurposeString() {
+		return "Generates a random radial basis function stream with drift.";
+	}
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public FloatOption speedChangeOption = new FloatOption("speedChange", 's',
-            "Speed of change of centroids in the model.", 0, 0, Float.MAX_VALUE);
+	public FloatOption speedChangeOption = new FloatOption("speedChange", 's',
+			"Speed of change of centroids in the model.", 0, 0, Float.MAX_VALUE);
 
-    public IntOption numDriftCentroidsOption = new IntOption("numDriftCentroids", 'k',
-            "The number of centroids with drift.", 50, 0, Integer.MAX_VALUE);
+	public IntOption numDriftCentroidsOption = new IntOption("numDriftCentroids", 'k',
+			"The number of centroids with drift.", 50, 0, Integer.MAX_VALUE);
 
-    protected double[][] speedCentroids;
+	protected double[][] speedCentroids;
 
-    @Override
-    public InstanceExample nextInstance() {
-        //Update Centroids with drift
-        int len = this.numDriftCentroidsOption.getValue();
-        if (len > this.centroids.length) {
-            len = this.centroids.length;
-        }
-        for (int j = 0; j < len; j++) {
-            for (int i = 0; i < this.numAttsOption.getValue(); i++) {
-                this.centroids[j].centre[i] += this.speedCentroids[j][i] * this.speedChangeOption.getValue();
-                if (this.centroids[j].centre[i] > 1) {
-                    this.centroids[j].centre[i] = 1;
-                    this.speedCentroids[j][i] = -this.speedCentroids[j][i];
-                }
-                if (this.centroids[j].centre[i] < 0) {
-                    this.centroids[j].centre[i] = 0;
-                    this.speedCentroids[j][i] = -this.speedCentroids[j][i];
-                }
-            }
-        }
-        return super.nextInstance();
-    }
+	@Override
+	public InstanceExample nextInstance() {
+		// Update Centroids with drift
+		int len = this.numDriftCentroidsOption.getValue();
+		if (len > this.centroids.length) {
+			len = this.centroids.length;
+		}
+		for (int j = 0; j < len; j++) {
+			for (int i = 0; i < this.numAttsOption.getValue(); i++) {
+				this.centroids[j].centre[i] += this.speedCentroids[j][i] * this.speedChangeOption.getValue();
+				if (this.centroids[j].centre[i] > 1) {
+					this.centroids[j].centre[i] = 1;
+					this.speedCentroids[j][i] = -this.speedCentroids[j][i];
+				}
+				if (this.centroids[j].centre[i] < 0) {
+					this.centroids[j].centre[i] = 0;
+					this.speedCentroids[j][i] = -this.speedCentroids[j][i];
+				}
+			}
+		}
+		return super.nextInstance();
+	}
 
-    @Override
-    protected void generateCentroids() {
-        super.generateCentroids();
-        Random modelRand = new Random(this.modelRandomSeedOption.getValue());
-        int len = this.numDriftCentroidsOption.getValue();
-        if (len > this.centroids.length) {
-            len = this.centroids.length;
-        }
-        this.speedCentroids = new double[len][this.numAttsOption.getValue()];
-        for (int i = 0; i < len; i++) {
-            double[] randSpeed = new double[this.numAttsOption.getValue()];
-            double normSpeed = 0.0;
-            for (int j = 0; j < randSpeed.length; j++) {
-                randSpeed[j] = modelRand.nextDouble();
-                normSpeed += randSpeed[j] * randSpeed[j];
-            }
-            normSpeed = Math.sqrt(normSpeed);
-            for (int j = 0; j < randSpeed.length; j++) {
-                randSpeed[j] /= normSpeed;
-            }
-            this.speedCentroids[i] = randSpeed;
-        }
-    }
+	@Override
+	protected void generateCentroids() {
+		super.generateCentroids();
+		Random modelRand = new Random(this.modelRandomSeedOption.getValue());
+		int len = this.numDriftCentroidsOption.getValue();
+		if (len > this.centroids.length) {
+			len = this.centroids.length;
+		}
+		this.speedCentroids = new double[len][this.numAttsOption.getValue()];
+		for (int i = 0; i < len; i++) {
+			double[] randSpeed = new double[this.numAttsOption.getValue()];
+			double normSpeed = 0.0;
+			for (int j = 0; j < randSpeed.length; j++) {
+				randSpeed[j] = modelRand.nextDouble();
+				normSpeed += randSpeed[j] * randSpeed[j];
+			}
+			normSpeed = Math.sqrt(normSpeed);
+			for (int j = 0; j < randSpeed.length; j++) {
+				randSpeed[j] /= normSpeed;
+			}
+			this.speedCentroids[i] = randSpeed;
+		}
+	}
 
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
 
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == RandomRBFGeneratorDrift.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == RandomRBFGeneratorDrift.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
 }
diff --git a/moa/src/main/java/moa/streams/generators/RandomTreeGenerator.java b/moa/src/main/java/moa/streams/generators/RandomTreeGenerator.java
index 2212da9ae..cb0bdd198 100644
--- a/moa/src/main/java/moa/streams/generators/RandomTreeGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/RandomTreeGenerator.java
@@ -15,18 +15,10 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams.generators;
 
-import com.yahoo.labs.samoa.instances.Attribute;
-import com.yahoo.labs.samoa.instances.DenseInstance;
-import moa.capabilities.CapabilitiesHandler;
-import moa.capabilities.Capability;
-import moa.capabilities.ImmutableCapabilities;
-import moa.core.FastVector;
-import com.yahoo.labs.samoa.instances.Instance;
-
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Random;
@@ -38,6 +30,9 @@
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.capabilities.CapabilitiesHandler;
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
 import moa.core.FastVector;
 import moa.core.InstanceExample;
 import moa.core.ObjectRepository;
@@ -51,230 +46,207 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class RandomTreeGenerator extends AbstractOptionHandler implements
-        InstanceStream, CapabilitiesHandler {
+public class RandomTreeGenerator extends AbstractOptionHandler implements InstanceStream, CapabilitiesHandler {
+
+	@Override
+	public String getPurposeString() {
+		return "Generates a stream based on a randomly generated tree.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public IntOption treeRandomSeedOption = new IntOption("treeRandomSeed", 'r', "Seed for random generation of tree.",
+			1);
 
-    @Override
-    public String getPurposeString() {
-        return "Generates a stream based on a randomly generated tree.";
-    }
+	public IntOption instanceRandomSeedOption = new IntOption("instanceRandomSeed", 'i',
+			"Seed for random generation of instances.", 1);
 
-    private static final long serialVersionUID = 1L;
+	public IntOption numClassesOption = new IntOption("numClasses", 'c', "The number of classes to generate.", 2, 2,
+			Integer.MAX_VALUE);
 
-    public IntOption treeRandomSeedOption = new IntOption("treeRandomSeed",
-            'r', "Seed for random generation of tree.", 1);
-
-    public IntOption instanceRandomSeedOption = new IntOption(
-            "instanceRandomSeed", 'i',
-            "Seed for random generation of instances.", 1);
-
-    public IntOption numClassesOption = new IntOption("numClasses", 'c',
-            "The number of classes to generate.", 2, 2, Integer.MAX_VALUE);
-
-    public IntOption numNominalsOption = new IntOption("numNominals", 'o',
-            "The number of nominal attributes to generate.", 5, 0,
-            Integer.MAX_VALUE);
-
-    public IntOption numNumericsOption = new IntOption("numNumerics", 'u',
-            "The number of numeric attributes to generate.", 5, 0,
-            Integer.MAX_VALUE);
-
-    public IntOption numValsPerNominalOption = new IntOption(
-            "numValsPerNominal", 'v',
-            "The number of values to generate per nominal attribute.", 5, 2,
-            Integer.MAX_VALUE);
-
-    public IntOption maxTreeDepthOption = new IntOption("maxTreeDepth", 'd',
-            "The maximum depth of the tree concept.", 5, 0, Integer.MAX_VALUE);
-
-    public IntOption firstLeafLevelOption = new IntOption(
-            "firstLeafLevel",
-            'l',
-            "The first level of the tree above maxTreeDepth that can have leaves.",
-            3, 0, Integer.MAX_VALUE);
-
-    public FloatOption leafFractionOption = new FloatOption("leafFraction",
-            'f',
-            "The fraction of leaves per level from firstLeafLevel onwards.",
-            0.15, 0.0, 1.0);
-
-    protected static class Node implements Serializable {
-
-        private static final long serialVersionUID = 1L;
-
-        public int classLabel;
-
-        public int splitAttIndex;
-
-        public double splitAttValue;
-
-        public Node[] children;
-    }
-
-    protected Node treeRoot;
-
-    protected InstancesHeader streamHeader;
-
-    protected Random instanceRandom;
-
-    @Override
-    public void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        monitor.setCurrentActivity("Preparing random tree...", -1.0);
-        generateHeader();
-        generateRandomTree();
-        restart();
-    }
-
-    @Override
-    public long estimatedRemainingInstances() {
-        return -1;
-    }
-
-    @Override
-    public boolean isRestartable() {
-        return true;
-    }
-
-    @Override
-    public void restart() {
-        this.instanceRandom = new Random(this.instanceRandomSeedOption.getValue());
-    }
-
-    @Override
-    public InstancesHeader getHeader() {
-        return this.streamHeader;
-    }
-
-    @Override
-    public boolean hasMoreInstances() {
-        return true;
-    }
-
-    @Override
-    public InstanceExample nextInstance() {
-        double[] attVals = new double[this.numNominalsOption.getValue()
-                + this.numNumericsOption.getValue()];
-        InstancesHeader header = getHeader();
-        Instance inst = new DenseInstance(header.numAttributes());
-        for (int i = 0; i < attVals.length; i++) {
-            attVals[i] = i < this.numNominalsOption.getValue() ? this.instanceRandom.nextInt(this.numValsPerNominalOption.getValue())
-                    : this.instanceRandom.nextDouble();
-            inst.setValue(i, attVals[i]);
-        }
-        inst.setDataset(header);
-        inst.setClassValue(classifyInstance(this.treeRoot, attVals));
-        return new InstanceExample(inst);
-    }
-
-    protected int classifyInstance(Node node, double[] attVals) {
-        if (node.children == null) {
-            return node.classLabel;
-        }
-        if (node.splitAttIndex < this.numNominalsOption.getValue()) {
-            return classifyInstance(
-                    node.children[(int) attVals[node.splitAttIndex]], attVals);
-        }
-        return classifyInstance(
-                node.children[attVals[node.splitAttIndex] < node.splitAttValue ? 0
-                : 1], attVals);
-    }
-
-    protected void generateHeader() {
-        FastVector attributes = new FastVector();
-        FastVector nominalAttVals = new FastVector();
-        for (int i = 0; i < this.numValsPerNominalOption.getValue(); i++) {
-            nominalAttVals.addElement("value" + (i + 1));
-        }
-        for (int i = 0; i < this.numNominalsOption.getValue(); i++) {
-            attributes.addElement(new Attribute("nominal" + (i + 1),
-                    nominalAttVals));
-        }
-        for (int i = 0; i < this.numNumericsOption.getValue(); i++) {
-            attributes.addElement(new Attribute("numeric" + (i + 1)));
-        }
-        FastVector classLabels = new FastVector();
-        for (int i = 0; i < this.numClassesOption.getValue(); i++) {
-            classLabels.addElement("class" + (i + 1));
-        }
-        attributes.addElement(new Attribute("class", classLabels));
-        this.streamHeader = new InstancesHeader(new InstancesHeader(
-                getCLICreationString(InstanceStream.class), attributes, 0));
-        this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
-    }
-
-    protected void generateRandomTree() {
-        Random treeRand = new Random(this.treeRandomSeedOption.getValue());
-        ArrayList<Integer> nominalAttCandidates = new ArrayList<Integer>(
-                this.numNominalsOption.getValue());
-        for (int i = 0; i < this.numNominalsOption.getValue(); i++) {
-            nominalAttCandidates.add(i);
-        }
-        double[] minNumericVals = new double[this.numNumericsOption.getValue()];
-        double[] maxNumericVals = new double[this.numNumericsOption.getValue()];
-        for (int i = 0; i < this.numNumericsOption.getValue(); i++) {
-            minNumericVals[i] = 0.0;
-            maxNumericVals[i] = 1.0;
-        }
-        this.treeRoot = generateRandomTreeNode(0, nominalAttCandidates,
-                minNumericVals, maxNumericVals, treeRand);
-    }
-
-    protected Node generateRandomTreeNode(int currentDepth,
-            ArrayList<Integer> nominalAttCandidates, double[] minNumericVals,
-            double[] maxNumericVals, Random treeRand) {
-        if ((currentDepth >= this.maxTreeDepthOption.getValue())
-                || ((currentDepth >= this.firstLeafLevelOption.getValue()) && (this.leafFractionOption.getValue() >= (1.0 - treeRand.nextDouble())))) {
-            Node leaf = new Node();
-            leaf.classLabel = treeRand.nextInt(this.numClassesOption.getValue());
-            return leaf;
-        }
-        Node node = new Node();
-        int chosenAtt = treeRand.nextInt(nominalAttCandidates.size()
-                + this.numNumericsOption.getValue());
-        if (chosenAtt < nominalAttCandidates.size()) {
-            node.splitAttIndex = nominalAttCandidates.get(chosenAtt);
-            node.children = new Node[this.numValsPerNominalOption.getValue()];
-            ArrayList<Integer> newNominalCandidates = new ArrayList<Integer>(
-                    nominalAttCandidates);
-            newNominalCandidates.remove(new Integer(node.splitAttIndex));
-            newNominalCandidates.trimToSize();
-            for (int i = 0; i < node.children.length; i++) {
-                node.children[i] = generateRandomTreeNode(currentDepth + 1,
-                        newNominalCandidates, minNumericVals, maxNumericVals,
-                        treeRand);
-            }
-        } else {
-            int numericIndex = chosenAtt - nominalAttCandidates.size();
-            node.splitAttIndex = this.numNominalsOption.getValue()
-                    + numericIndex;
-            double minVal = minNumericVals[numericIndex];
-            double maxVal = maxNumericVals[numericIndex];
-            node.splitAttValue = ((maxVal - minVal) * treeRand.nextDouble())
-                    + minVal;
-            node.children = new Node[2];
-            double[] newMaxVals = maxNumericVals.clone();
-            newMaxVals[numericIndex] = node.splitAttValue;
-            node.children[0] = generateRandomTreeNode(currentDepth + 1,
-                    nominalAttCandidates, minNumericVals, newMaxVals, treeRand);
-            double[] newMinVals = minNumericVals.clone();
-            newMinVals[numericIndex] = node.splitAttValue;
-            node.children[1] = generateRandomTreeNode(currentDepth + 1,
-                    nominalAttCandidates, newMinVals, maxNumericVals, treeRand);
-        }
-        return node;
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == RandomTreeGenerator.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
+	public IntOption numNominalsOption = new IntOption("numNominals", 'o',
+			"The number of nominal attributes to generate.", 5, 0, Integer.MAX_VALUE);
+
+	public IntOption numNumericsOption = new IntOption("numNumerics", 'u',
+			"The number of numeric attributes to generate.", 5, 0, Integer.MAX_VALUE);
+
+	public IntOption numValsPerNominalOption = new IntOption("numValsPerNominal", 'v',
+			"The number of values to generate per nominal attribute.", 5, 2, Integer.MAX_VALUE);
+
+	public IntOption maxTreeDepthOption = new IntOption("maxTreeDepth", 'd', "The maximum depth of the tree concept.",
+			5, 0, Integer.MAX_VALUE);
+
+	public IntOption firstLeafLevelOption = new IntOption("firstLeafLevel", 'l',
+			"The first level of the tree above maxTreeDepth that can have leaves.", 3, 0, Integer.MAX_VALUE);
+
+	public FloatOption leafFractionOption = new FloatOption("leafFraction", 'f',
+			"The fraction of leaves per level from firstLeafLevel onwards.", 0.15, 0.0, 1.0);
+
+	protected static class Node implements Serializable {
+
+		private static final long serialVersionUID = 1L;
+
+		public int classLabel;
+
+		public int splitAttIndex;
+
+		public double splitAttValue;
+
+		public Node[] children;
+	}
+
+	protected Node treeRoot;
+
+	protected InstancesHeader streamHeader;
+
+	protected Random instanceRandom;
+
+	@Override
+	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		monitor.setCurrentActivity("Preparing random tree...", -1.0);
+		generateHeader();
+		generateRandomTree();
+		restart();
+	}
+
+	@Override
+	public long estimatedRemainingInstances() {
+		return -1;
+	}
+
+	@Override
+	public boolean isRestartable() {
+		return true;
+	}
+
+	@Override
+	public void restart() {
+		this.instanceRandom = new Random(this.instanceRandomSeedOption.getValue());
+	}
+
+	@Override
+	public InstancesHeader getHeader() {
+		return this.streamHeader;
+	}
+
+	@Override
+	public boolean hasMoreInstances() {
+		return true;
+	}
+
+	@Override
+	public InstanceExample nextInstance() {
+		double[] attVals = new double[this.numNominalsOption.getValue() + this.numNumericsOption.getValue()];
+		InstancesHeader header = getHeader();
+		Instance inst = new DenseInstance(header.numAttributes());
+		for (int i = 0; i < attVals.length; i++) {
+			attVals[i] = i < this.numNominalsOption.getValue()
+					? this.instanceRandom.nextInt(this.numValsPerNominalOption.getValue())
+					: this.instanceRandom.nextDouble();
+			inst.setValue(i, attVals[i]);
+		}
+		inst.setDataset(header);
+		inst.setClassValue(classifyInstance(this.treeRoot, attVals));
+		return new InstanceExample(inst);
+	}
+
+	protected int classifyInstance(Node node, double[] attVals) {
+		if (node.children == null) {
+			return node.classLabel;
+		}
+		if (node.splitAttIndex < this.numNominalsOption.getValue()) {
+			return classifyInstance(node.children[(int) attVals[node.splitAttIndex]], attVals);
+		}
+		return classifyInstance(node.children[attVals[node.splitAttIndex] < node.splitAttValue ? 0 : 1], attVals);
+	}
+
+	protected void generateHeader() {
+		FastVector attributes = new FastVector();
+		FastVector nominalAttVals = new FastVector();
+		for (int i = 0; i < this.numValsPerNominalOption.getValue(); i++) {
+			nominalAttVals.addElement("value" + (i + 1));
+		}
+		for (int i = 0; i < this.numNominalsOption.getValue(); i++) {
+			attributes.addElement(new Attribute("nominal" + (i + 1), nominalAttVals));
+		}
+		for (int i = 0; i < this.numNumericsOption.getValue(); i++) {
+			attributes.addElement(new Attribute("numeric" + (i + 1)));
+		}
+		FastVector classLabels = new FastVector();
+		for (int i = 0; i < this.numClassesOption.getValue(); i++) {
+			classLabels.addElement("class" + (i + 1));
+		}
+		attributes.addElement(new Attribute("class", classLabels));
+		this.streamHeader = new InstancesHeader(
+				new InstancesHeader(getCLICreationString(InstanceStream.class), attributes, 0));
+		this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
+	}
+
+	protected void generateRandomTree() {
+		Random treeRand = new Random(this.treeRandomSeedOption.getValue());
+		ArrayList<Integer> nominalAttCandidates = new ArrayList<>(this.numNominalsOption.getValue());
+		for (int i = 0; i < this.numNominalsOption.getValue(); i++) {
+			nominalAttCandidates.add(i);
+		}
+		double[] minNumericVals = new double[this.numNumericsOption.getValue()];
+		double[] maxNumericVals = new double[this.numNumericsOption.getValue()];
+		for (int i = 0; i < this.numNumericsOption.getValue(); i++) {
+			minNumericVals[i] = 0.0;
+			maxNumericVals[i] = 1.0;
+		}
+		this.treeRoot = generateRandomTreeNode(0, nominalAttCandidates, minNumericVals, maxNumericVals, treeRand);
+	}
+
+	protected Node generateRandomTreeNode(int currentDepth, ArrayList<Integer> nominalAttCandidates,
+			double[] minNumericVals, double[] maxNumericVals, Random treeRand) {
+		if ((currentDepth >= this.maxTreeDepthOption.getValue())
+				|| ((currentDepth >= this.firstLeafLevelOption.getValue())
+						&& (this.leafFractionOption.getValue() >= (1.0 - treeRand.nextDouble())))) {
+			Node leaf = new Node();
+			leaf.classLabel = treeRand.nextInt(this.numClassesOption.getValue());
+			return leaf;
+		}
+		Node node = new Node();
+		int chosenAtt = treeRand.nextInt(nominalAttCandidates.size() + this.numNumericsOption.getValue());
+		if (chosenAtt < nominalAttCandidates.size()) {
+			node.splitAttIndex = nominalAttCandidates.get(chosenAtt);
+			node.children = new Node[this.numValsPerNominalOption.getValue()];
+			ArrayList<Integer> newNominalCandidates = new ArrayList<>(nominalAttCandidates);
+			newNominalCandidates.remove(new Integer(node.splitAttIndex));
+			newNominalCandidates.trimToSize();
+			for (int i = 0; i < node.children.length; i++) {
+				node.children[i] = generateRandomTreeNode(currentDepth + 1, newNominalCandidates, minNumericVals,
+						maxNumericVals, treeRand);
+			}
+		} else {
+			int numericIndex = chosenAtt - nominalAttCandidates.size();
+			node.splitAttIndex = this.numNominalsOption.getValue() + numericIndex;
+			double minVal = minNumericVals[numericIndex];
+			double maxVal = maxNumericVals[numericIndex];
+			node.splitAttValue = ((maxVal - minVal) * treeRand.nextDouble()) + minVal;
+			node.children = new Node[2];
+			double[] newMaxVals = maxNumericVals.clone();
+			newMaxVals[numericIndex] = node.splitAttValue;
+			node.children[0] = generateRandomTreeNode(currentDepth + 1, nominalAttCandidates, minNumericVals,
+					newMaxVals, treeRand);
+			double[] newMinVals = minNumericVals.clone();
+			newMinVals[numericIndex] = node.splitAttValue;
+			node.children[1] = generateRandomTreeNode(currentDepth + 1, nominalAttCandidates, newMinVals,
+					maxNumericVals, treeRand);
+		}
+		return node;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == RandomTreeGenerator.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
 }
diff --git a/moa/src/main/java/moa/streams/generators/SEAGenerator.java b/moa/src/main/java/moa/streams/generators/SEAGenerator.java
index 1d3bad6dc..b930adf35 100644
--- a/moa/src/main/java/moa/streams/generators/SEAGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/SEAGenerator.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams.generators;
 
@@ -25,13 +25,12 @@
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
-import moa.capabilities.CapabilitiesHandler;
-import moa.capabilities.Capability;
-import moa.capabilities.ImmutableCapabilities;
-import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.capabilities.CapabilitiesHandler;
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
 import moa.core.FastVector;
 import moa.core.InstanceExample;
 import moa.core.ObjectRepository;
@@ -40,12 +39,13 @@
 import moa.tasks.TaskMonitor;
 
 /**
- * Stream generator for SEA concepts functions.
- * Generator described in the paper:<br/>
- * W. Nick Street and YongSeog Kim
- *    "A streaming ensemble algorithm (SEA) for large-scale classification",
- *     KDD '01: Proceedings of the seventh ACM SIGKDD international conference on Knowledge discovery and data mining
- *     377-382 2001.<br/><br/>
+ * Stream generator for SEA concepts functions. Generator described in the
+ * paper:<br/>
+ * W. Nick Street and YongSeog Kim "A streaming ensemble algorithm (SEA) for
+ * large-scale classification", KDD '01: Proceedings of the seventh ACM SIGKDD
+ * international conference on Knowledge discovery and data mining 377-382
+ * 2001.<br/>
+ * <br/>
  *
  * Notes:<br/>
  * The built in functions are based on the paper.
@@ -53,173 +53,169 @@
  * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
  * @version $Revision: 7 $
  */
-public class SEAGenerator extends AbstractOptionHandler implements
-        InstanceStream, CapabilitiesHandler {
-
-    @Override
-    public String getPurposeString() {
-        return "Generates SEA concepts functions.";
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    public IntOption functionOption = new IntOption("function", 'f',
-            "Classification function used, as defined in the original paper.",
-            1, 1, 4);
-
-    public IntOption instanceRandomSeedOption = new IntOption(
-            "instanceRandomSeed", 'i',
-            "Seed for random generation of instances.", 1);
-
-    public FlagOption balanceClassesOption = new FlagOption("balanceClasses",
-            'b', "Balance the number of instances of each class.");
-
-    public IntOption numInstancesConcept = new IntOption("numInstancesConcept", 'n',
-            "The number of instances for each concept.", 0, 0, Integer.MAX_VALUE);
-
-    public IntOption noisePercentageOption = new IntOption("noisePercentage",
-            'p', "Percentage of noise to add to the data.", 10, 0, 100);
-
-    protected interface ClassFunction {
-
-        public int determineClass(double attrib1, double attrib2, double attrib3);
-    }
-
-    protected static ClassFunction[] classificationFunctions = {
-        // function 1
-        new ClassFunction() {
-
-    @Override
-    public int determineClass(double attrib1, double attrib2, double attrib3) {
-        return (attrib1 + attrib2 <= 8) ? 0 : 1;
-    }
-},
-        // function 2
-        new ClassFunction() {
-
-    @Override
-    public int determineClass(double attrib1, double attrib2, double attrib3) {
-        return (attrib1 + attrib2 <= 9) ? 0 : 1;
-    }
-},
-        // function 3
-        new ClassFunction() {
-
-    public int determineClass(double attrib1, double attrib2, double attrib3) {
-        return (attrib1 + attrib2 <= 7) ? 0 : 1;
-    }
-},
-        // function 4
-        new ClassFunction() {
-
-    @Override
-    public int determineClass(double attrib1, double attrib2, double attrib3) {
-        return (attrib1 + attrib2 <= 9.5) ? 0 : 1;
-    }
-}
-    };
-
-    protected InstancesHeader streamHeader;
-
-    protected Random instanceRandom;
-
-    protected boolean nextClassShouldBeZero;
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        // generate header
-        FastVector attributes = new FastVector();
-        attributes.addElement(new Attribute("attrib1"));
-        attributes.addElement(new Attribute("attrib2"));
-        attributes.addElement(new Attribute("attrib3"));
-
-        FastVector classLabels = new FastVector();
-        classLabels.addElement("groupA");
-        classLabels.addElement("groupB");
-        attributes.addElement(new Attribute("class", classLabels));
-        this.streamHeader = new InstancesHeader(new InstancesHeader(
-                getCLICreationString(InstanceStream.class), attributes, 0));
-        this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
-        restart();
-    }
-
-    @Override
-    public long estimatedRemainingInstances() {
-        return -1;
-    }
-
-    @Override
-    public InstancesHeader getHeader() {
-        return this.streamHeader;
-    }
-
-    @Override
-    public boolean hasMoreInstances() {
-        return true;
-    }
-
-    @Override
-    public boolean isRestartable() {
-        return true;
-    }
-
-    @Override
-    public InstanceExample nextInstance() {
-        double attrib1 = 0, attrib2 = 0, attrib3 = 0;
-        int group = 0;
-        boolean desiredClassFound = false;
-        while (!desiredClassFound) {
-            // generate attributes
-            attrib1 = 10 * this.instanceRandom.nextDouble();
-            attrib2 = 10 * this.instanceRandom.nextDouble();
-            attrib3 = 10 * this.instanceRandom.nextDouble();
-
-            // determine class
-            group = classificationFunctions[this.functionOption.getValue() - 1].determineClass(attrib1, attrib2, attrib3);
-            if (!this.balanceClassesOption.isSet()) {
-                desiredClassFound = true;
-            } else {
-                // balance the classes
-                if ((this.nextClassShouldBeZero && (group == 0))
-                        || (!this.nextClassShouldBeZero && (group == 1))) {
-                    desiredClassFound = true;
-                    this.nextClassShouldBeZero = !this.nextClassShouldBeZero;
-                } // else keep searching
-            }
-        }
-        //Add Noise
-        if ((1 + (this.instanceRandom.nextInt(100))) <= this.noisePercentageOption.getValue()) {
-            group = (group == 0 ? 1 : 0);
-        }
-
-        // construct instance
-        InstancesHeader header = getHeader();
-        Instance inst = new DenseInstance(header.numAttributes());
-        inst.setValue(0, attrib1);
-        inst.setValue(1, attrib2);
-        inst.setValue(2, attrib3);
-        inst.setDataset(header);
-        inst.setClassValue(group);
-        return new InstanceExample(inst);
-    }
-
-    @Override
-    public void restart() {
-        this.instanceRandom = new Random(this.instanceRandomSeedOption.getValue());
-        this.nextClassShouldBeZero = false;
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == SEAGenerator.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
+public class SEAGenerator extends AbstractOptionHandler implements InstanceStream, CapabilitiesHandler {
+
+	@Override
+	public String getPurposeString() {
+		return "Generates SEA concepts functions.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public IntOption functionOption = new IntOption("function", 'f',
+			"Classification function used, as defined in the original paper.", 1, 1, 4);
+
+	public IntOption instanceRandomSeedOption = new IntOption("instanceRandomSeed", 'i',
+			"Seed for random generation of instances.", 1);
+
+	public FlagOption balanceClassesOption = new FlagOption("balanceClasses", 'b',
+			"Balance the number of instances of each class.");
+
+	public IntOption numInstancesConcept = new IntOption("numInstancesConcept", 'n',
+			"The number of instances for each concept.", 0, 0, Integer.MAX_VALUE);
+
+	public IntOption noisePercentageOption = new IntOption("noisePercentage", 'p',
+			"Percentage of noise to add to the data.", 10, 0, 100);
+
+	protected interface ClassFunction {
+
+		int determineClass(double attrib1, double attrib2, double attrib3);
+	}
+
+	protected static ClassFunction[] classificationFunctions = {
+			// function 1
+			new ClassFunction() {
+
+				@Override
+				public int determineClass(double attrib1, double attrib2, double attrib3) {
+					return (attrib1 + attrib2 <= 8) ? 0 : 1;
+				}
+			},
+			// function 2
+			new ClassFunction() {
+
+				@Override
+				public int determineClass(double attrib1, double attrib2, double attrib3) {
+					return (attrib1 + attrib2 <= 9) ? 0 : 1;
+				}
+			},
+			// function 3
+			new ClassFunction() {
+
+				@Override
+				public int determineClass(double attrib1, double attrib2, double attrib3) {
+					return (attrib1 + attrib2 <= 7) ? 0 : 1;
+				}
+			},
+			// function 4
+			new ClassFunction() {
+
+				@Override
+				public int determineClass(double attrib1, double attrib2, double attrib3) {
+					return (attrib1 + attrib2 <= 9.5) ? 0 : 1;
+				}
+			} };
+
+	protected InstancesHeader streamHeader;
+
+	protected Random instanceRandom;
+
+	protected boolean nextClassShouldBeZero;
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// generate header
+		FastVector attributes = new FastVector();
+		attributes.addElement(new Attribute("attrib1"));
+		attributes.addElement(new Attribute("attrib2"));
+		attributes.addElement(new Attribute("attrib3"));
+
+		FastVector classLabels = new FastVector();
+		classLabels.addElement("groupA");
+		classLabels.addElement("groupB");
+		attributes.addElement(new Attribute("class", classLabels));
+		this.streamHeader = new InstancesHeader(
+				new InstancesHeader(getCLICreationString(InstanceStream.class), attributes, 0));
+		this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
+		restart();
+	}
+
+	@Override
+	public long estimatedRemainingInstances() {
+		return -1;
+	}
+
+	@Override
+	public InstancesHeader getHeader() {
+		return this.streamHeader;
+	}
+
+	@Override
+	public boolean hasMoreInstances() {
+		return true;
+	}
+
+	@Override
+	public boolean isRestartable() {
+		return true;
+	}
+
+	@Override
+	public InstanceExample nextInstance() {
+		double attrib1 = 0, attrib2 = 0, attrib3 = 0;
+		int group = 0;
+		boolean desiredClassFound = false;
+		while (!desiredClassFound) {
+			// generate attributes
+			attrib1 = 10 * this.instanceRandom.nextDouble();
+			attrib2 = 10 * this.instanceRandom.nextDouble();
+			attrib3 = 10 * this.instanceRandom.nextDouble();
+
+			// determine class
+			group = classificationFunctions[this.functionOption.getValue() - 1].determineClass(attrib1, attrib2,
+					attrib3);
+			if (!this.balanceClassesOption.isSet()) {
+				desiredClassFound = true;
+			} else {
+				// balance the classes
+				if ((this.nextClassShouldBeZero && (group == 0)) || (!this.nextClassShouldBeZero && (group == 1))) {
+					desiredClassFound = true;
+					this.nextClassShouldBeZero = !this.nextClassShouldBeZero;
+				} // else keep searching
+			}
+		}
+		// Add Noise
+		if ((1 + (this.instanceRandom.nextInt(100))) <= this.noisePercentageOption.getValue()) {
+			group = (group == 0 ? 1 : 0);
+		}
+
+		// construct instance
+		InstancesHeader header = getHeader();
+		Instance inst = new DenseInstance(header.numAttributes());
+		inst.setValue(0, attrib1);
+		inst.setValue(1, attrib2);
+		inst.setValue(2, attrib3);
+		inst.setDataset(header);
+		inst.setClassValue(group);
+		return new InstanceExample(inst);
+	}
+
+	@Override
+	public void restart() {
+		this.instanceRandom = new Random(this.instanceRandomSeedOption.getValue());
+		this.nextClassShouldBeZero = false;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == SEAGenerator.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
 }
diff --git a/moa/src/main/java/moa/streams/generators/STAGGERGenerator.java b/moa/src/main/java/moa/streams/generators/STAGGERGenerator.java
index d30da4b30..d847ceae3 100644
--- a/moa/src/main/java/moa/streams/generators/STAGGERGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/STAGGERGenerator.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams.generators;
 
@@ -25,13 +25,12 @@
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
-import moa.capabilities.CapabilitiesHandler;
-import moa.capabilities.Capability;
-import moa.capabilities.ImmutableCapabilities;
-import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.capabilities.CapabilitiesHandler;
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
 import moa.core.FastVector;
 import moa.core.InstanceExample;
 import moa.core.ObjectRepository;
@@ -42,10 +41,10 @@
 /**
  * Stream generator for STAGGER Concept functions.
  *
- *  Generator described in the paper:<br/>
- *   Jeffrey C. Schlimmer and Richard H. Granger Jr.
- *    "Incremental Learning from Noisy Data",
- *     Machine Learning 1: 317-354 1986.<br/><br/>
+ * Generator described in the paper:<br/>
+ * Jeffrey C. Schlimmer and Richard H. Granger Jr. "Incremental Learning from
+ * Noisy Data", Machine Learning 1: 317-354 1986.<br/>
+ * <br/>
  *
  * Notes:<br/>
  * The built in functions are based on the paper (page 341).
@@ -53,171 +52,165 @@
  * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
  * @version $Revision: 7 $
  */
-public class STAGGERGenerator extends AbstractOptionHandler implements
-        InstanceStream, CapabilitiesHandler {
-
-    @Override
-    public String getPurposeString() {
-        return "Generates STAGGER Concept functions.";
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    public IntOption instanceRandomSeedOption = new IntOption(
-            "instanceRandomSeed", 'i',
-            "Seed for random generation of instances.", 1);
-
-    public IntOption functionOption = new IntOption("function", 'f',
-            "Classification function used, as defined in the original paper.",
-            1, 1, 3);
-
-    public FlagOption balanceClassesOption = new FlagOption("balanceClasses",
-            'b', "Balance the number of instances of each class.");
-
-    protected interface ClassFunction {
-
-        public int determineClass(int size, int color, int shape);
-    }
-
-    protected static ClassFunction[] classificationFunctions = {
-        // function 1
-        new ClassFunction() {
-
-    @Override
-    public int determineClass(int size, int color, int shape) {
-        return (size == 0 && color == 0) ? 1 : 0; //size==small && color==red
-    }
-},
-        // function 2
-        new ClassFunction() {
-
-    @Override
-    public int determineClass(int size, int color, int shape) {
-        return (color == 2 || shape == 0) ? 1 : 0; //color==green || shape==circle
-    }
-},
-        // function 3
-        new ClassFunction() {
-
-    @Override
-    public int determineClass(int size, int color, int shape) {
-        return (size == 1 || size == 2) ? 1 : 0; // size==medium || size==large
-    }
-}
-    };
-
-    protected InstancesHeader streamHeader;
-
-    protected Random instanceRandom;
-
-    protected boolean nextClassShouldBeZero;
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        // generate header
-        FastVector attributes = new FastVector();
-
-        FastVector sizeLabels = new FastVector();
-        sizeLabels.addElement("small");
-        sizeLabels.addElement("medium");
-        sizeLabels.addElement("large");
-        attributes.addElement(new Attribute("size", sizeLabels));
-
-        FastVector colorLabels = new FastVector();
-        colorLabels.addElement("red");
-        colorLabels.addElement("blue");
-        colorLabels.addElement("green");
-        attributes.addElement(new Attribute("color", colorLabels));
-
-        FastVector shapeLabels = new FastVector();
-        shapeLabels.addElement("circle");
-        shapeLabels.addElement("square");
-        shapeLabels.addElement("triangle");
-        attributes.addElement(new Attribute("shape", shapeLabels));
-
-        FastVector classLabels = new FastVector();
-        classLabels.addElement("false");
-        classLabels.addElement("true");
-        attributes.addElement(new Attribute("class", classLabels));
-        this.streamHeader = new InstancesHeader(new InstancesHeader(
-                getCLICreationString(InstanceStream.class), attributes, 0));
-        this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
-        restart();
-    }
-
-    @Override
-    public long estimatedRemainingInstances() {
-        return -1;
-    }
-
-    @Override
-    public InstancesHeader getHeader() {
-        return this.streamHeader;
-    }
-
-    @Override
-    public boolean hasMoreInstances() {
-        return true;
-    }
-
-    @Override
-    public boolean isRestartable() {
-        return true;
-    }
-
-    @Override
-    public InstanceExample nextInstance() {
-
-        int size = 0, color = 0, shape = 0, group = 0;
-        boolean desiredClassFound = false;
-        while (!desiredClassFound) {
-            // generate attributes
-            size = this.instanceRandom.nextInt(3);
-            color = this.instanceRandom.nextInt(3);
-            shape = this.instanceRandom.nextInt(3);
-
-            // determine class
-            group = classificationFunctions[this.functionOption.getValue() - 1].determineClass(size, color, shape);
-            if (!this.balanceClassesOption.isSet()) {
-                desiredClassFound = true;
-            } else {
-                // balance the classes
-                if ((this.nextClassShouldBeZero && (group == 0))
-                        || (!this.nextClassShouldBeZero && (group == 1))) {
-                    desiredClassFound = true;
-                    this.nextClassShouldBeZero = !this.nextClassShouldBeZero;
-                } // else keep searching
-            }
-        }
-
-        // construct instance
-        InstancesHeader header = getHeader();
-        Instance inst = new DenseInstance(header.numAttributes());
-        inst.setValue(0, size);
-        inst.setValue(1, color);
-        inst.setValue(2, shape);
-        inst.setDataset(header);
-        inst.setClassValue(group);
-        return new InstanceExample(inst);
-    }
-
-    @Override
-    public void restart() {
-        this.instanceRandom = new Random(this.instanceRandomSeedOption.getValue());
-        this.nextClassShouldBeZero = false;
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == STAGGERGenerator.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
+public class STAGGERGenerator extends AbstractOptionHandler implements InstanceStream, CapabilitiesHandler {
+
+	@Override
+	public String getPurposeString() {
+		return "Generates STAGGER Concept functions.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public IntOption instanceRandomSeedOption = new IntOption("instanceRandomSeed", 'i',
+			"Seed for random generation of instances.", 1);
+
+	public IntOption functionOption = new IntOption("function", 'f',
+			"Classification function used, as defined in the original paper.", 1, 1, 3);
+
+	public FlagOption balanceClassesOption = new FlagOption("balanceClasses", 'b',
+			"Balance the number of instances of each class.");
+
+	protected interface ClassFunction {
+
+		int determineClass(int size, int color, int shape);
+	}
+
+	protected static ClassFunction[] classificationFunctions = {
+			// function 1
+			new ClassFunction() {
+
+				@Override
+				public int determineClass(int size, int color, int shape) {
+					return (size == 0 && color == 0) ? 1 : 0; // size==small && color==red
+				}
+			},
+			// function 2
+			new ClassFunction() {
+
+				@Override
+				public int determineClass(int size, int color, int shape) {
+					return (color == 2 || shape == 0) ? 1 : 0; // color==green || shape==circle
+				}
+			},
+			// function 3
+			new ClassFunction() {
+
+				@Override
+				public int determineClass(int size, int color, int shape) {
+					return (size == 1 || size == 2) ? 1 : 0; // size==medium || size==large
+				}
+			} };
+
+	protected InstancesHeader streamHeader;
+
+	protected Random instanceRandom;
+
+	protected boolean nextClassShouldBeZero;
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// generate header
+		FastVector attributes = new FastVector();
+
+		FastVector sizeLabels = new FastVector();
+		sizeLabels.addElement("small");
+		sizeLabels.addElement("medium");
+		sizeLabels.addElement("large");
+		attributes.addElement(new Attribute("size", sizeLabels));
+
+		FastVector colorLabels = new FastVector();
+		colorLabels.addElement("red");
+		colorLabels.addElement("blue");
+		colorLabels.addElement("green");
+		attributes.addElement(new Attribute("color", colorLabels));
+
+		FastVector shapeLabels = new FastVector();
+		shapeLabels.addElement("circle");
+		shapeLabels.addElement("square");
+		shapeLabels.addElement("triangle");
+		attributes.addElement(new Attribute("shape", shapeLabels));
+
+		FastVector classLabels = new FastVector();
+		classLabels.addElement("false");
+		classLabels.addElement("true");
+		attributes.addElement(new Attribute("class", classLabels));
+		this.streamHeader = new InstancesHeader(
+				new InstancesHeader(getCLICreationString(InstanceStream.class), attributes, 0));
+		this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
+		restart();
+	}
+
+	@Override
+	public long estimatedRemainingInstances() {
+		return -1;
+	}
+
+	@Override
+	public InstancesHeader getHeader() {
+		return this.streamHeader;
+	}
+
+	@Override
+	public boolean hasMoreInstances() {
+		return true;
+	}
+
+	@Override
+	public boolean isRestartable() {
+		return true;
+	}
+
+	@Override
+	public InstanceExample nextInstance() {
+
+		int size = 0, color = 0, shape = 0, group = 0;
+		boolean desiredClassFound = false;
+		while (!desiredClassFound) {
+			// generate attributes
+			size = this.instanceRandom.nextInt(3);
+			color = this.instanceRandom.nextInt(3);
+			shape = this.instanceRandom.nextInt(3);
+
+			// determine class
+			group = classificationFunctions[this.functionOption.getValue() - 1].determineClass(size, color, shape);
+			if (!this.balanceClassesOption.isSet()) {
+				desiredClassFound = true;
+			} else {
+				// balance the classes
+				if ((this.nextClassShouldBeZero && (group == 0)) || (!this.nextClassShouldBeZero && (group == 1))) {
+					desiredClassFound = true;
+					this.nextClassShouldBeZero = !this.nextClassShouldBeZero;
+				} // else keep searching
+			}
+		}
+
+		// construct instance
+		InstancesHeader header = getHeader();
+		Instance inst = new DenseInstance(header.numAttributes());
+		inst.setValue(0, size);
+		inst.setValue(1, color);
+		inst.setValue(2, shape);
+		inst.setDataset(header);
+		inst.setClassValue(group);
+		return new InstanceExample(inst);
+	}
+
+	@Override
+	public void restart() {
+		this.instanceRandom = new Random(this.instanceRandomSeedOption.getValue());
+		this.nextClassShouldBeZero = false;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == STAGGERGenerator.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
 }
diff --git a/moa/src/main/java/moa/streams/generators/SineGenerator.java b/moa/src/main/java/moa/streams/generators/SineGenerator.java
index cc8d87b8e..5f36dfc22 100644
--- a/moa/src/main/java/moa/streams/generators/SineGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/SineGenerator.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams.generators;
 
@@ -37,180 +37,171 @@
 import moa.tasks.TaskMonitor;
 
 /**
- * 1.SINE1. Abrupt concept drift, noise-free examples. It has two relevant 
- * attributes. Each attributes has values uniformly distributed in [0; 1]. In 
- * the first context all points below the curve y = sin(x) are classified as 
- * positive. After the context change the classification is reversed.
- * 2.SINE2. The same two relevant attributes. The classification function is 
- * y &lt; 0.5 + 0.3 sin(3 * PI * x). After the context change the classification 
- * is reversed.
+ * 1.SINE1. Abrupt concept drift, noise-free examples. It has two relevant
+ * attributes. Each attributes has values uniformly distributed in [0; 1]. In
+ * the first context all points below the curve y = sin(x) are classified as
+ * positive. After the context change the classification is reversed. 2.SINE2.
+ * The same two relevant attributes. The classification function is y &lt; 0.5 +
+ * 0.3 sin(3 * PI * x). After the context change the classification is reversed.
  * 3.SINIRREL1. Presence of irrelevant attributes. The same classification
- * function of SINE1 but the examples have two more random attributes
- * with no influence on the classification function.
- * 4.SINIRREL2. The same classification function of SINE2 but the examples
- * have two more random attributes with no influence on the classification
- * function.
- * Based on proposal by "Gama, Joao, et al. "Learning with drift 
- * detection." Advances in artificial intelligence–SBIA 2004. Springer Berlin 
- * Heidelberg, 2004. 286-295."
+ * function of SINE1 but the examples have two more random attributes with no
+ * influence on the classification function. 4.SINIRREL2. The same
+ * classification function of SINE2 but the examples have two more random
+ * attributes with no influence on the classification function. Based on
+ * proposal by "Gama, Joao, et al. "Learning with drift detection." Advances in
+ * artificial intelligence–SBIA 2004. Springer Berlin Heidelberg, 2004.
+ * 286-295."
  *
  * @author Paulo Gonçalves (paulogoncalves@recife.ifpe.edu.br)
  * @version $Revision: 1 $
  */
-public class SineGenerator extends AbstractOptionHandler implements
-        InstanceStream {
-
-    public static final int NUM_IRRELEVANT_ATTRIBUTES = 2;
-
-    public IntOption instanceRandomSeedOption = new IntOption(
-            "instanceRandomSeed", 'i',
-            "Seed for random generation of instances.", 1);
-
-    public IntOption functionOption = new IntOption("function", 'f',
-            "Classification function used, as defined in the original paper.",
-            1, 1, 4);
-
-    public FlagOption suppressIrrelevantAttributesOption = new FlagOption(
-            "suppressIrrelevantAttributes", 's',
-            "Reduce the data to only contain 2 relevant numeric attributes.");
-
-    public FlagOption balanceClassesOption = new FlagOption("balanceClasses",
-            'b', "Balance the number of instances of each class.");
-
-    protected InstancesHeader streamHeader;
-
-    protected Random instanceRandom;
-
-    protected boolean nextClassShouldBeZero;
-
-    protected interface ClassFunction {
-
-        public int determineClass(double x, double y);
-    }
-
-    protected static ClassFunction[] classificationFunctions = {
-        // Values below the curve y = sin(x) are classified as positive.
-        new ClassFunction() {
-
-            @Override
-            public int determineClass(double x, double y) {
-                return (y < Math.sin(x)) ? 0 : 1;
-            }
-        },
-        // Values below the curve y = sin(x) are classified as negative.
-        new ClassFunction() {
-
-            @Override
-            public int determineClass(double x, double y) {
-                return (y >= Math.sin(x)) ? 0 : 1;
-            }
-        },
-        // Values below the curve y = 0.5 + 0.3*sin(3*PI*x) are classified as positive.
-        new ClassFunction() {
-
-            @Override
-            public int determineClass(double x, double y) {
-                return (y < 0.5 + 0.3 * Math.sin(3 * Math.PI * x)) ? 0 : 1;
-            }
-        },
-        // Values below the curve y = 0.5 + 0.3*sin(3*PI*x) are classified as negative.
-        new ClassFunction() {
-
-            @Override
-            public int determineClass(double x, double y) {
-                return (y >= 0.5 + 0.3 * Math.sin(3 * Math.PI * x)) ? 0 : 1;
-            }
-        },};
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-
-    }
-
-    @Override
-    public InstancesHeader getHeader() {
-        return this.streamHeader;
-    }
-
-    @Override
-    public long estimatedRemainingInstances() {
-        return -1;
-    }
-
-    @Override
-    public boolean hasMoreInstances() {
-        return true;
-    }
-
-    @Override
-    public InstanceExample nextInstance() {
-        double a1 = 0, a2 = 0, group = 0;
-
-        boolean desiredClassFound = false;
-        while (!desiredClassFound) {
-            a1 = this.instanceRandom.nextDouble();
-            a2 = this.instanceRandom.nextDouble();
-            group = classificationFunctions[this.functionOption.getValue() - 1].determineClass(a1, a2);
-            if (!this.balanceClassesOption.isSet()) {
-                desiredClassFound = true;
-            } else {
-                // balance the classes
-                if ((this.nextClassShouldBeZero && (group == 0))
-                        || (!this.nextClassShouldBeZero && (group == 1))) {
-                    desiredClassFound = true;
-                    this.nextClassShouldBeZero = !this.nextClassShouldBeZero;
-                } // else keep searching
-            }
-        }
-        // construct instance
-        InstancesHeader header = getHeader();
-        Instance inst = new DenseInstance(header.numAttributes());
-        inst.setValue(0, a1);
-        inst.setValue(1, a2);
-        inst.setDataset(header);
-        if (!this.suppressIrrelevantAttributesOption.isSet()) {
-            for (int i = 0; i < NUM_IRRELEVANT_ATTRIBUTES; i++) {
-                inst.setValue(i + 2, this.instanceRandom.nextDouble());
-            }
-        }
-        inst.setClassValue(group);
-        return new InstanceExample(inst);
-    }
-
-    @Override
-    public boolean isRestartable() {
-        return true;
-    }
-
-    @Override
-    public void restart() {
-        this.instanceRandom = new Random(
-                this.instanceRandomSeedOption.getValue());
-        this.nextClassShouldBeZero = false;
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        ArrayList<Attribute> attributes = new ArrayList();
-
-        int numAtts = 2;
-        if (!this.suppressIrrelevantAttributesOption.isSet()) {
-            numAtts += NUM_IRRELEVANT_ATTRIBUTES;
-        }
-        for (int i = 0; i < numAtts; i++) {
-            attributes.add(new Attribute("att" + (i + 1)));
-        }
-
-        List classLabels = new ArrayList();
-        classLabels.add("positive");
-        classLabels.add("negative");
-        Attribute classAtt = new Attribute("class", classLabels);
-        attributes.add(classAtt);
-
-        this.streamHeader = new InstancesHeader(new InstancesHeader(
-                getCLICreationString(InstanceStream.class), attributes, 0));
-        this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
-        restart();
-    }
+public class SineGenerator extends AbstractOptionHandler implements InstanceStream {
+
+	public static final int NUM_IRRELEVANT_ATTRIBUTES = 2;
+
+	public IntOption instanceRandomSeedOption = new IntOption("instanceRandomSeed", 'i',
+			"Seed for random generation of instances.", 1);
+
+	public IntOption functionOption = new IntOption("function", 'f',
+			"Classification function used, as defined in the original paper.", 1, 1, 4);
+
+	public FlagOption suppressIrrelevantAttributesOption = new FlagOption("suppressIrrelevantAttributes", 's',
+			"Reduce the data to only contain 2 relevant numeric attributes.");
+
+	public FlagOption balanceClassesOption = new FlagOption("balanceClasses", 'b',
+			"Balance the number of instances of each class.");
+
+	protected InstancesHeader streamHeader;
+
+	protected Random instanceRandom;
+
+	protected boolean nextClassShouldBeZero;
+
+	protected interface ClassFunction {
+
+		int determineClass(double x, double y);
+	}
+
+	protected static ClassFunction[] classificationFunctions = {
+			// Values below the curve y = sin(x) are classified as positive.
+			new ClassFunction() {
+
+				@Override
+				public int determineClass(double x, double y) {
+					return (y < Math.sin(x)) ? 0 : 1;
+				}
+			},
+			// Values below the curve y = sin(x) are classified as negative.
+			new ClassFunction() {
+
+				@Override
+				public int determineClass(double x, double y) {
+					return (y >= Math.sin(x)) ? 0 : 1;
+				}
+			},
+			// Values below the curve y = 0.5 + 0.3*sin(3*PI*x) are classified as positive.
+			new ClassFunction() {
+
+				@Override
+				public int determineClass(double x, double y) {
+					return (y < 0.5 + 0.3 * Math.sin(3 * Math.PI * x)) ? 0 : 1;
+				}
+			},
+			// Values below the curve y = 0.5 + 0.3*sin(3*PI*x) are classified as negative.
+			new ClassFunction() {
+
+				@Override
+				public int determineClass(double x, double y) {
+					return (y >= 0.5 + 0.3 * Math.sin(3 * Math.PI * x)) ? 0 : 1;
+				}
+			}, };
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+
+	}
+
+	@Override
+	public InstancesHeader getHeader() {
+		return this.streamHeader;
+	}
+
+	@Override
+	public long estimatedRemainingInstances() {
+		return -1;
+	}
+
+	@Override
+	public boolean hasMoreInstances() {
+		return true;
+	}
+
+	@Override
+	public InstanceExample nextInstance() {
+		double a1 = 0, a2 = 0, group = 0;
+
+		boolean desiredClassFound = false;
+		while (!desiredClassFound) {
+			a1 = this.instanceRandom.nextDouble();
+			a2 = this.instanceRandom.nextDouble();
+			group = classificationFunctions[this.functionOption.getValue() - 1].determineClass(a1, a2);
+			if (!this.balanceClassesOption.isSet()) {
+				desiredClassFound = true;
+			} else {
+				// balance the classes
+				if ((this.nextClassShouldBeZero && (group == 0)) || (!this.nextClassShouldBeZero && (group == 1))) {
+					desiredClassFound = true;
+					this.nextClassShouldBeZero = !this.nextClassShouldBeZero;
+				} // else keep searching
+			}
+		}
+		// construct instance
+		InstancesHeader header = getHeader();
+		Instance inst = new DenseInstance(header.numAttributes());
+		inst.setValue(0, a1);
+		inst.setValue(1, a2);
+		inst.setDataset(header);
+		if (!this.suppressIrrelevantAttributesOption.isSet()) {
+			for (int i = 0; i < NUM_IRRELEVANT_ATTRIBUTES; i++) {
+				inst.setValue(i + 2, this.instanceRandom.nextDouble());
+			}
+		}
+		inst.setClassValue(group);
+		return new InstanceExample(inst);
+	}
+
+	@Override
+	public boolean isRestartable() {
+		return true;
+	}
+
+	@Override
+	public void restart() {
+		this.instanceRandom = new Random(this.instanceRandomSeedOption.getValue());
+		this.nextClassShouldBeZero = false;
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		ArrayList<Attribute> attributes = new ArrayList();
+
+		int numAtts = 2;
+		if (!this.suppressIrrelevantAttributesOption.isSet()) {
+			numAtts += NUM_IRRELEVANT_ATTRIBUTES;
+		}
+		for (int i = 0; i < numAtts; i++) {
+			attributes.add(new Attribute("att" + (i + 1)));
+		}
+
+		List classLabels = new ArrayList();
+		classLabels.add("positive");
+		classLabels.add("negative");
+		Attribute classAtt = new Attribute("class", classLabels);
+		attributes.add(classAtt);
+
+		this.streamHeader = new InstancesHeader(
+				new InstancesHeader(getCLICreationString(InstanceStream.class), attributes, 0));
+		this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
+		restart();
+	}
 }
diff --git a/moa/src/main/java/moa/streams/generators/TextGenerator.java b/moa/src/main/java/moa/streams/generators/TextGenerator.java
index 245e61687..0b592598c 100644
--- a/moa/src/main/java/moa/streams/generators/TextGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/TextGenerator.java
@@ -16,7 +16,7 @@
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * 
+ *
  */
 
 import com.github.javacliparser.IntOption;
@@ -36,170 +36,169 @@
  */
 public class TextGenerator extends AbstractOptionHandler implements InstanceStream {
 
-    private static final long serialVersionUID = 3028905554604259131L;
-
-    public IntOption numAttsOption = new IntOption("numAtts", 'a',
-            "The number of attributes to generate.", 1000, 0, Integer.MAX_VALUE);
-
-    public IntOption instanceRandomSeedOption = new IntOption(
-            "instanceRandomSeed", 'i',
-            "Seed for random generation of instances.", 1);
-
-    protected InstancesHeader streamHeader;
-
-    protected Random instanceRandom;
-
-    protected int[] wordTwitterGenerator;
-    protected double[] freqTwitterGenerator;
-    protected double[] sumFreqTwitterGenerator;
-    protected int[] classTwitterGenerator;
-
-    protected int sizeTable;
-    protected double probPositive = 0.1;
-    protected double probNegative = 0.1;
-    protected double zipfExponent = 1.5;
-    protected double lengthTweet = 15;
-
-    protected int countTweets = 0;
-
-    @Override
-    public InstancesHeader getHeader() {
-        return this.streamHeader;
-    }
-
-    @Override
-    public long estimatedRemainingInstances() {
-        return -1;
-    }
-
-    @Override
-    public boolean hasMoreInstances() {
-        return true;
-    }
-
-    @Override
-    public InstanceExample nextInstance() {
-        int[] votes;
-        double[] attVals;
-        attVals = new double[this.numAttsOption.getValue() + 1];
-
-        do {
-            int length = (int) (lengthTweet * (1.0 + this.instanceRandom.nextGaussian()));
-            if (length < 1) length = 1;
-            votes = new int[3];
-            for (int j = 0; j < length; j++) {
-                double rand = this.instanceRandom.nextDouble();
-                //binary search
-                int i = 0;
-                int min = 0;
-                int max = sizeTable - 1;
-                int mid;
-                do {
-                    mid = (min + max) / 2;
-                    if (rand > this.sumFreqTwitterGenerator[mid]) {
-                        min = mid + 1;
-                    } else {
-                        max = mid - 1;
-                    }
-                } while ((this.sumFreqTwitterGenerator[mid] != rand) && (min <= max));
-
-                attVals[this.wordTwitterGenerator[mid]] = 1;
-                votes[this.classTwitterGenerator[mid]]++;
-
-            }
-        } while (votes[1] == votes[2]);
-
-        Instance inst = new SparseInstance(1.0, attVals);
-        inst.setDataset(getHeader());
-        inst.setClassValue((votes[1] > votes[2]) ? 0 : 1);
-        this.countTweets++;
-        return new InstanceExample(inst);
-    }
-
-    @Override
-    public boolean isRestartable() {
-        return true;
-    }
-
-    @Override
-    public void restart() {
-
-        this.sizeTable = this.numAttsOption.getValue();
-
-        //Prepare table of words to generate tweets
-        this.wordTwitterGenerator = new int[sizeTable];
-        this.freqTwitterGenerator = new double[sizeTable];
-        this.sumFreqTwitterGenerator = new double[sizeTable];
-        this.classTwitterGenerator = new int[sizeTable];
-
-        this.countTweets = 0;
-
-        double sum = 0;
-        this.instanceRandom = new Random(this.instanceRandomSeedOption.getValue());
-        for (int i = 0; i < this.sizeTable; i++) {
-            this.wordTwitterGenerator[i] = i + 1;
-            this.freqTwitterGenerator[i] = 1.0 / Math.pow(i + 1, zipfExponent);
-            sum += this.freqTwitterGenerator[i];
-            this.sumFreqTwitterGenerator[i] = sum;
-            double rand = this.instanceRandom.nextDouble();
-            this.classTwitterGenerator[i] = (rand < probPositive ? 1 : (rand < probNegative + probPositive ? 2 : 0));
-        }
-        for (int i = 0; i < this.sizeTable; i++) {
-            this.freqTwitterGenerator[i] /= sum;
-            this.sumFreqTwitterGenerator[i] /= sum;
-        }
-
-    }
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-        generateHeader();
-        restart();
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-
-    }
-    private void generateHeader() {
-        ArrayList<String>  classLabels = new ArrayList();
-        for (int i = 0; i < 2; i++) {
-            classLabels.add("class" + (i + 1));
-        }
-        ArrayList<Attribute> attributes = new ArrayList();
-        for (int i = 0; i < this.numAttsOption.getValue(); i++) {
-            attributes.add(new Attribute("att" + (i + 1), classLabels));
-        }
-        attributes.add(new Attribute("class", classLabels));
-        this.streamHeader = new InstancesHeader(new InstancesHeader(
-                getCLICreationString(InstanceStream.class), attributes, 0));
-        this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
-    }
-
-
-    public void changePolarity(int numberWords) {
-        for (int i = 0; i < numberWords; ) {
-            int randWord = this.instanceRandom.nextInt(this.sizeTable);
-            int polarity = this.classTwitterGenerator[randWord];
-            if (polarity == 1) {
-                this.classTwitterGenerator[i] = 2;
-                i++;
-            }
-            if (polarity == 2) {
-                this.classTwitterGenerator[i] = 1;
-                i++;
-            }
-        }
-    }
-
-    public void changeFreqWords(int numberWords) {
-        for (int i = 0; i < numberWords; i++) {
-            int randWordTo = this.instanceRandom.nextInt(this.sizeTable);
-            int randWordFrom = this.instanceRandom.nextInt(this.sizeTable);
-            this.wordTwitterGenerator[randWordTo] = randWordFrom;
-            this.wordTwitterGenerator[randWordFrom] = randWordTo;
-        }
-    }
-
+	private static final long serialVersionUID = 3028905554604259131L;
+
+	public IntOption numAttsOption = new IntOption("numAtts", 'a', "The number of attributes to generate.", 1000, 0,
+			Integer.MAX_VALUE);
+
+	public IntOption instanceRandomSeedOption = new IntOption("instanceRandomSeed", 'i',
+			"Seed for random generation of instances.", 1);
+
+	protected InstancesHeader streamHeader;
+
+	protected Random instanceRandom;
+
+	protected int[] wordTwitterGenerator;
+	protected double[] freqTwitterGenerator;
+	protected double[] sumFreqTwitterGenerator;
+	protected int[] classTwitterGenerator;
+
+	protected int sizeTable;
+	protected double probPositive = 0.1;
+	protected double probNegative = 0.1;
+	protected double zipfExponent = 1.5;
+	protected double lengthTweet = 15;
+
+	protected int countTweets = 0;
+
+	@Override
+	public InstancesHeader getHeader() {
+		return this.streamHeader;
+	}
+
+	@Override
+	public long estimatedRemainingInstances() {
+		return -1;
+	}
+
+	@Override
+	public boolean hasMoreInstances() {
+		return true;
+	}
+
+	@Override
+	public InstanceExample nextInstance() {
+		int[] votes;
+		double[] attVals;
+		attVals = new double[this.numAttsOption.getValue() + 1];
+
+		do {
+			int length = (int) (lengthTweet * (1.0 + this.instanceRandom.nextGaussian()));
+			if (length < 1)
+				length = 1;
+			votes = new int[3];
+			for (int j = 0; j < length; j++) {
+				double rand = this.instanceRandom.nextDouble();
+				// binary search
+				int i = 0;
+				int min = 0;
+				int max = sizeTable - 1;
+				int mid;
+				do {
+					mid = (min + max) / 2;
+					if (rand > this.sumFreqTwitterGenerator[mid]) {
+						min = mid + 1;
+					} else {
+						max = mid - 1;
+					}
+				} while ((this.sumFreqTwitterGenerator[mid] != rand) && (min <= max));
+
+				attVals[this.wordTwitterGenerator[mid]] = 1;
+				votes[this.classTwitterGenerator[mid]]++;
+
+			}
+		} while (votes[1] == votes[2]);
+
+		Instance inst = new SparseInstance(1.0, attVals);
+		inst.setDataset(getHeader());
+		inst.setClassValue((votes[1] > votes[2]) ? 0 : 1);
+		this.countTweets++;
+		return new InstanceExample(inst);
+	}
+
+	@Override
+	public boolean isRestartable() {
+		return true;
+	}
+
+	@Override
+	public void restart() {
+
+		this.sizeTable = this.numAttsOption.getValue();
+
+		// Prepare table of words to generate tweets
+		this.wordTwitterGenerator = new int[sizeTable];
+		this.freqTwitterGenerator = new double[sizeTable];
+		this.sumFreqTwitterGenerator = new double[sizeTable];
+		this.classTwitterGenerator = new int[sizeTable];
+
+		this.countTweets = 0;
+
+		double sum = 0;
+		this.instanceRandom = new Random(this.instanceRandomSeedOption.getValue());
+		for (int i = 0; i < this.sizeTable; i++) {
+			this.wordTwitterGenerator[i] = i + 1;
+			this.freqTwitterGenerator[i] = 1.0 / Math.pow(i + 1, zipfExponent);
+			sum += this.freqTwitterGenerator[i];
+			this.sumFreqTwitterGenerator[i] = sum;
+			double rand = this.instanceRandom.nextDouble();
+			this.classTwitterGenerator[i] = (rand < probPositive ? 1 : (rand < probNegative + probPositive ? 2 : 0));
+		}
+		for (int i = 0; i < this.sizeTable; i++) {
+			this.freqTwitterGenerator[i] /= sum;
+			this.sumFreqTwitterGenerator[i] /= sum;
+		}
+
+	}
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		generateHeader();
+		restart();
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+
+	}
+
+	private void generateHeader() {
+		ArrayList<String> classLabels = new ArrayList();
+		for (int i = 0; i < 2; i++) {
+			classLabels.add("class" + (i + 1));
+		}
+		ArrayList<Attribute> attributes = new ArrayList();
+		for (int i = 0; i < this.numAttsOption.getValue(); i++) {
+			attributes.add(new Attribute("att" + (i + 1), classLabels));
+		}
+		attributes.add(new Attribute("class", classLabels));
+		this.streamHeader = new InstancesHeader(
+				new InstancesHeader(getCLICreationString(InstanceStream.class), attributes, 0));
+		this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
+	}
+
+	public void changePolarity(int numberWords) {
+		for (int i = 0; i < numberWords;) {
+			int randWord = this.instanceRandom.nextInt(this.sizeTable);
+			int polarity = this.classTwitterGenerator[randWord];
+			if (polarity == 1) {
+				this.classTwitterGenerator[i] = 2;
+				i++;
+			}
+			if (polarity == 2) {
+				this.classTwitterGenerator[i] = 1;
+				i++;
+			}
+		}
+	}
+
+	public void changeFreqWords(int numberWords) {
+		for (int i = 0; i < numberWords; i++) {
+			int randWordTo = this.instanceRandom.nextInt(this.sizeTable);
+			int randWordFrom = this.instanceRandom.nextInt(this.sizeTable);
+			this.wordTwitterGenerator[randWordTo] = randWordFrom;
+			this.wordTwitterGenerator[randWordFrom] = randWordTo;
+		}
+	}
 
 }
diff --git a/moa/src/main/java/moa/streams/generators/WaveformGenerator.java b/moa/src/main/java/moa/streams/generators/WaveformGenerator.java
index ce0eb0989..79859d684 100644
--- a/moa/src/main/java/moa/streams/generators/WaveformGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/WaveformGenerator.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams.generators;
 
@@ -25,13 +25,12 @@
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Attribute;
 import com.yahoo.labs.samoa.instances.DenseInstance;
-import moa.capabilities.CapabilitiesHandler;
-import moa.capabilities.Capability;
-import moa.capabilities.ImmutableCapabilities;
-import moa.core.FastVector;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.capabilities.CapabilitiesHandler;
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
 import moa.core.FastVector;
 import moa.core.InstanceExample;
 import moa.core.ObjectRepository;
@@ -45,132 +44,125 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class WaveformGenerator extends AbstractOptionHandler implements
-        InstanceStream, CapabilitiesHandler {
-
-    @Override
-    public String getPurposeString() {
-        return "Generates a problem of predicting one of three waveform types.";
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    public static final int NUM_CLASSES = 3;
-
-    public static final int NUM_BASE_ATTRIBUTES = 21;
-
-    public static final int TOTAL_ATTRIBUTES_INCLUDING_NOISE = 40;
-
-    protected static final int hFunctions[][] = {
-        {0, 1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-        {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1, 0},
-        {0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0}};
-
-    public IntOption instanceRandomSeedOption = new IntOption(
-            "instanceRandomSeed", 'i',
-            "Seed for random generation of instances.", 1);
-
-    public FlagOption addNoiseOption = new FlagOption("addNoise", 'n',
-            "Adds noise, for a total of 40 attributes.");
-
-    protected InstancesHeader streamHeader;
-
-    protected Random instanceRandom;
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        // generate header
-        FastVector attributes = new FastVector();
-        int numAtts = this.addNoiseOption.isSet() ? TOTAL_ATTRIBUTES_INCLUDING_NOISE
-                : NUM_BASE_ATTRIBUTES;
-        for (int i = 0; i < numAtts; i++) {
-            attributes.addElement(new Attribute("att" + (i + 1)));
-        }
-        FastVector classLabels = new FastVector();
-        for (int i = 0; i < NUM_CLASSES; i++) {
-            classLabels.addElement("class" + (i + 1));
-        }
-        attributes.addElement(new Attribute("class", classLabels));
-        this.streamHeader = new InstancesHeader(new InstancesHeader(
-                getCLICreationString(InstanceStream.class), attributes, 0));
-        this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
-        restart();
-    }
-
-    @Override
-    public long estimatedRemainingInstances() {
-        return -1;
-    }
-
-    @Override
-    public InstancesHeader getHeader() {
-        return this.streamHeader;
-    }
-
-    @Override
-    public boolean hasMoreInstances() {
-        return true;
-    }
-
-    @Override
-    public boolean isRestartable() {
-        return true;
-    }
-
-    @Override
-    public InstanceExample nextInstance() {
-        InstancesHeader header = getHeader();
-        Instance inst = new DenseInstance(header.numAttributes());
-        inst.setDataset(header);
-        int waveform = this.instanceRandom.nextInt(NUM_CLASSES);
-        int choiceA = 0, choiceB = 0;
-        switch (waveform) {
-            case 0:
-                choiceA = 0;
-                choiceB = 1;
-                break;
-            case 1:
-                choiceA = 0;
-                choiceB = 2;
-                break;
-            case 2:
-                choiceA = 1;
-                choiceB = 2;
-                break;
-
-        }
-        double multiplierA = this.instanceRandom.nextDouble();
-        double multiplierB = 1.0 - multiplierA;
-        for (int i = 0; i < NUM_BASE_ATTRIBUTES; i++) {
-            inst.setValue(i, (multiplierA * hFunctions[choiceA][i])
-                    + (multiplierB * hFunctions[choiceB][i])
-                    + this.instanceRandom.nextGaussian());
-        }
-        if (this.addNoiseOption.isSet()) {
-            for (int i = NUM_BASE_ATTRIBUTES; i < TOTAL_ATTRIBUTES_INCLUDING_NOISE; i++) {
-                inst.setValue(i, this.instanceRandom.nextGaussian());
-            }
-        }
-        inst.setClassValue(waveform);
-        return new InstanceExample(inst);
-    }
-
-    @Override
-    public void restart() {
-        this.instanceRandom = new Random(this.instanceRandomSeedOption.getValue());
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
-
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == WaveformGenerator.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
+public class WaveformGenerator extends AbstractOptionHandler implements InstanceStream, CapabilitiesHandler {
+
+	@Override
+	public String getPurposeString() {
+		return "Generates a problem of predicting one of three waveform types.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public static final int NUM_CLASSES = 3;
+
+	public static final int NUM_BASE_ATTRIBUTES = 21;
+
+	public static final int TOTAL_ATTRIBUTES_INCLUDING_NOISE = 40;
+
+	protected static final int hFunctions[][] = { { 0, 1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+			{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1, 0 },
+			{ 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0 } };
+
+	public IntOption instanceRandomSeedOption = new IntOption("instanceRandomSeed", 'i',
+			"Seed for random generation of instances.", 1);
+
+	public FlagOption addNoiseOption = new FlagOption("addNoise", 'n', "Adds noise, for a total of 40 attributes.");
+
+	protected InstancesHeader streamHeader;
+
+	protected Random instanceRandom;
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// generate header
+		FastVector attributes = new FastVector();
+		int numAtts = this.addNoiseOption.isSet() ? TOTAL_ATTRIBUTES_INCLUDING_NOISE : NUM_BASE_ATTRIBUTES;
+		for (int i = 0; i < numAtts; i++) {
+			attributes.addElement(new Attribute("att" + (i + 1)));
+		}
+		FastVector classLabels = new FastVector();
+		for (int i = 0; i < NUM_CLASSES; i++) {
+			classLabels.addElement("class" + (i + 1));
+		}
+		attributes.addElement(new Attribute("class", classLabels));
+		this.streamHeader = new InstancesHeader(
+				new InstancesHeader(getCLICreationString(InstanceStream.class), attributes, 0));
+		this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
+		restart();
+	}
+
+	@Override
+	public long estimatedRemainingInstances() {
+		return -1;
+	}
+
+	@Override
+	public InstancesHeader getHeader() {
+		return this.streamHeader;
+	}
+
+	@Override
+	public boolean hasMoreInstances() {
+		return true;
+	}
+
+	@Override
+	public boolean isRestartable() {
+		return true;
+	}
+
+	@Override
+	public InstanceExample nextInstance() {
+		InstancesHeader header = getHeader();
+		Instance inst = new DenseInstance(header.numAttributes());
+		inst.setDataset(header);
+		int waveform = this.instanceRandom.nextInt(NUM_CLASSES);
+		int choiceA = 0, choiceB = 0;
+		switch (waveform) {
+		case 0:
+			choiceA = 0;
+			choiceB = 1;
+			break;
+		case 1:
+			choiceA = 0;
+			choiceB = 2;
+			break;
+		case 2:
+			choiceA = 1;
+			choiceB = 2;
+			break;
+
+		}
+		double multiplierA = this.instanceRandom.nextDouble();
+		double multiplierB = 1.0 - multiplierA;
+		for (int i = 0; i < NUM_BASE_ATTRIBUTES; i++) {
+			inst.setValue(i, (multiplierA * hFunctions[choiceA][i]) + (multiplierB * hFunctions[choiceB][i])
+					+ this.instanceRandom.nextGaussian());
+		}
+		if (this.addNoiseOption.isSet()) {
+			for (int i = NUM_BASE_ATTRIBUTES; i < TOTAL_ATTRIBUTES_INCLUDING_NOISE; i++) {
+				inst.setValue(i, this.instanceRandom.nextGaussian());
+			}
+		}
+		inst.setClassValue(waveform);
+		return new InstanceExample(inst);
+	}
+
+	@Override
+	public void restart() {
+		this.instanceRandom = new Random(this.instanceRandomSeedOption.getValue());
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
+
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == WaveformGenerator.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
 }
diff --git a/moa/src/main/java/moa/streams/generators/WaveformGeneratorDrift.java b/moa/src/main/java/moa/streams/generators/WaveformGeneratorDrift.java
index f1f3bc1c8..013763e78 100644
--- a/moa/src/main/java/moa/streams/generators/WaveformGeneratorDrift.java
+++ b/moa/src/main/java/moa/streams/generators/WaveformGeneratorDrift.java
@@ -16,112 +16,108 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams.generators;
 
-import moa.capabilities.Capability;
-import moa.capabilities.ImmutableCapabilities;
-import moa.core.InstanceExample;
-
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.DenseInstance;
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
 import moa.core.InstanceExample;
 import moa.core.ObjectRepository;
 import moa.tasks.TaskMonitor;
 
 /**
- * Stream generator for the problem of predicting one of three waveform types with drift.
+ * Stream generator for the problem of predicting one of three waveform types
+ * with drift.
  *
  * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
  * @version $Revision: 7 $
  */
 public class WaveformGeneratorDrift extends WaveformGenerator {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public IntOption numberAttributesDriftOption = new IntOption("numberAttributesDrift",
-            'd', "Number of attributes with drift.", 0, 0, TOTAL_ATTRIBUTES_INCLUDING_NOISE);
+	public IntOption numberAttributesDriftOption = new IntOption("numberAttributesDrift", 'd',
+			"Number of attributes with drift.", 0, 0, TOTAL_ATTRIBUTES_INCLUDING_NOISE);
 
-    protected int[] numberAttribute;
+	protected int[] numberAttribute;
 
-    @Override
-    public String getPurposeString() {
-        return "Generates a problem of predicting one of three waveform types with drift.";
-    }
+	@Override
+	public String getPurposeString() {
+		return "Generates a problem of predicting one of three waveform types with drift.";
+	}
 
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        super.prepareForUseImpl(monitor, repository);
-        int numAtts = this.addNoiseOption.isSet() ? TOTAL_ATTRIBUTES_INCLUDING_NOISE
-                : NUM_BASE_ATTRIBUTES;
-        this.numberAttribute = new int[numAtts];
-        for (int i = 0; i < numAtts; i++) {
-            this.numberAttribute[i] = i;
-        }
-        //Change atributes
-        int randomInt = this.instanceRandom.nextInt(numAtts);
-        int offset = this.instanceRandom.nextInt(numAtts);
-        int swap;
-        for (int i = 0; i < this.numberAttributesDriftOption.getValue(); i++) {
-            swap = this.numberAttribute[(i + randomInt) % numAtts];
-            this.numberAttribute[(i + randomInt) % numAtts] = this.numberAttribute[(i + offset) % numAtts];
-            this.numberAttribute[(i + offset) % numAtts] = swap;
-        }
-    }
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		super.prepareForUseImpl(monitor, repository);
+		int numAtts = this.addNoiseOption.isSet() ? TOTAL_ATTRIBUTES_INCLUDING_NOISE : NUM_BASE_ATTRIBUTES;
+		this.numberAttribute = new int[numAtts];
+		for (int i = 0; i < numAtts; i++) {
+			this.numberAttribute[i] = i;
+		}
+		// Change atributes
+		int randomInt = this.instanceRandom.nextInt(numAtts);
+		int offset = this.instanceRandom.nextInt(numAtts);
+		int swap;
+		for (int i = 0; i < this.numberAttributesDriftOption.getValue(); i++) {
+			swap = this.numberAttribute[(i + randomInt) % numAtts];
+			this.numberAttribute[(i + randomInt) % numAtts] = this.numberAttribute[(i + offset) % numAtts];
+			this.numberAttribute[(i + offset) % numAtts] = swap;
+		}
+	}
 
-    @Override
-    public InstanceExample nextInstance() {
-        InstancesHeader header = getHeader();
-        Instance inst = new DenseInstance(header.numAttributes());
-        inst.setDataset(header);
-        int waveform = this.instanceRandom.nextInt(NUM_CLASSES);
-        int choiceA = 0, choiceB = 0;
-        switch (waveform) {
-            case 0:
-                choiceA = 0;
-                choiceB = 1;
-                break;
-            case 1:
-                choiceA = 0;
-                choiceB = 2;
-                break;
-            case 2:
-                choiceA = 1;
-                choiceB = 2;
-                break;
+	@Override
+	public InstanceExample nextInstance() {
+		InstancesHeader header = getHeader();
+		Instance inst = new DenseInstance(header.numAttributes());
+		inst.setDataset(header);
+		int waveform = this.instanceRandom.nextInt(NUM_CLASSES);
+		int choiceA = 0, choiceB = 0;
+		switch (waveform) {
+		case 0:
+			choiceA = 0;
+			choiceB = 1;
+			break;
+		case 1:
+			choiceA = 0;
+			choiceB = 2;
+			break;
+		case 2:
+			choiceA = 1;
+			choiceB = 2;
+			break;
 
-        }
-        double multiplierA = this.instanceRandom.nextDouble();
-        double multiplierB = 1.0 - multiplierA;
-        for (int i = 0; i < NUM_BASE_ATTRIBUTES; i++) {
-            inst.setValue(this.numberAttribute[i], (multiplierA * hFunctions[choiceA][i])
-                    + (multiplierB * hFunctions[choiceB][i])
-                    + this.instanceRandom.nextGaussian());
-        }
-        if (this.addNoiseOption.isSet()) {
-            for (int i = NUM_BASE_ATTRIBUTES; i < TOTAL_ATTRIBUTES_INCLUDING_NOISE; i++) {
-                inst.setValue(this.numberAttribute[i], this.instanceRandom.nextGaussian());
-            }
-        }
-        inst.setClassValue(waveform);
-        return new InstanceExample(inst);
-    }
+		}
+		double multiplierA = this.instanceRandom.nextDouble();
+		double multiplierB = 1.0 - multiplierA;
+		for (int i = 0; i < NUM_BASE_ATTRIBUTES; i++) {
+			inst.setValue(this.numberAttribute[i], (multiplierA * hFunctions[choiceA][i])
+					+ (multiplierB * hFunctions[choiceB][i]) + this.instanceRandom.nextGaussian());
+		}
+		if (this.addNoiseOption.isSet()) {
+			for (int i = NUM_BASE_ATTRIBUTES; i < TOTAL_ATTRIBUTES_INCLUDING_NOISE; i++) {
+				inst.setValue(this.numberAttribute[i], this.instanceRandom.nextGaussian());
+			}
+		}
+		inst.setClassValue(waveform);
+		return new InstanceExample(inst);
+	}
 
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
 
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == WaveformGeneratorDrift.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == WaveformGeneratorDrift.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
 }
diff --git a/moa/src/main/java/moa/streams/generators/cd/AbruptChangeGenerator.java b/moa/src/main/java/moa/streams/generators/cd/AbruptChangeGenerator.java
index f07f119b7..80c3c41f6 100644
--- a/moa/src/main/java/moa/streams/generators/cd/AbruptChangeGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/cd/AbruptChangeGenerator.java
@@ -15,18 +15,18 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams.generators.cd;
 
 public class AbruptChangeGenerator extends AbstractConceptDriftGenerator {
 
-    @Override
-    protected double nextValue() {
-        double res;
-        double t = this.numInstances % this.period;
-        this.change = (t == this.period / 2) ? true : false;
-        res = (t < this.period / 2) ? .2 : .8;
-        return res;
-    }
+	@Override
+	protected double nextValue() {
+		double res;
+		double t = this.numInstances % this.period;
+		this.change = (t == this.period / 2) ? true : false;
+		res = (t < this.period / 2) ? .2 : .8;
+		return res;
+	}
 }
diff --git a/moa/src/main/java/moa/streams/generators/cd/AbstractConceptDriftGenerator.java b/moa/src/main/java/moa/streams/generators/cd/AbstractConceptDriftGenerator.java
index 6a1ae7979..1e28a6d3b 100644
--- a/moa/src/main/java/moa/streams/generators/cd/AbstractConceptDriftGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/cd/AbstractConceptDriftGenerator.java
@@ -37,132 +37,140 @@
 import moa.streams.clustering.ClusterEvent;
 import moa.tasks.TaskMonitor;
 
-public abstract class AbstractConceptDriftGenerator extends AbstractOptionHandler implements
-        ConceptDriftGenerator {
+public abstract class AbstractConceptDriftGenerator extends AbstractOptionHandler implements ConceptDriftGenerator {
 
-    @Override
-    public String getPurposeString() {
-        return "Generates a stream problem of predicting concept drift.";
-    }
-    protected ArrayList<ClusterEvent> clusterEvents;
+	@Override
+	public String getPurposeString() {
+		return "Generates a stream problem of predicting concept drift.";
+	}
 
-    public ArrayList<ClusterEvent> getEventsList() {
-        return this.clusterEvents;
-    }
-    private static final long serialVersionUID = 1L;
+	protected ArrayList<ClusterEvent> clusterEvents;
 
-    public IntOption instanceRandomSeedOption = new IntOption(
-            "instanceRandomSeed", 'i',
-            "Seed for random generation of instances.", 1);
+	@Override
+	public ArrayList<ClusterEvent> getEventsList() {
+		return this.clusterEvents;
+	}
 
-    public FlagOption notBinaryStreamOption = new FlagOption("notBinaryStream",
-            'b', "Don't convert to a binary stream of 0 and 1.");
+	private static final long serialVersionUID = 1L;
 
-    public IntOption numInstancesConceptOption = new IntOption("numInstancesConcept", 'p',
-            "The number of instances for each concept.", 500, 0, Integer.MAX_VALUE);
-
-    protected InstancesHeader streamHeader;
+	public IntOption instanceRandomSeedOption = new IntOption("instanceRandomSeed", 'i',
+			"Seed for random generation of instances.", 1);
 
-    protected Random instanceRandom;
-
-    protected int period;
-
-    protected int numInstances;
-
-    protected boolean change;
-
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-
-        restart();
-
-        this.numInstances = 0;
-        this.period = numInstancesConceptOption.getValue();
-        // generate header
-        FastVector attributes = new FastVector();
-
-        FastVector binaryLabels = new FastVector();
-        binaryLabels.addElement("0");
-        binaryLabels.addElement("1");
-
-        if (!this.notBinaryStreamOption.isSet()) {
-
-            attributes.addElement(new Attribute("input", binaryLabels));
-        } else {
-            attributes.addElement(new Attribute("input"));
-        }
-
-        // Ground Truth
-        attributes.addElement(new Attribute("change", binaryLabels));
-        attributes.addElement(new Attribute("ground truth input"));
-
-        this.streamHeader = new InstancesHeader(new InstancesHeader(
-                getCLICreationString(InstanceStream.class), attributes, 0));
-        this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
-
-        this.clusterEvents = new ArrayList<ClusterEvent>();
-
-        //this.clusterEvents.add(new ClusterEvent(this,100,"Change", "Drift"));
-        //this.clusterEvents.add(new ClusterEvent(this,200,"Change2", "Drift2"));
-
-    }
-
-    public long estimatedRemainingInstances() {
-        return -1;
-    }
-
-    public InstancesHeader getHeader() {
-        return this.streamHeader;
-    }
-
-    public boolean hasMoreInstances() {
-        return true;
-    }
-
-    public boolean isRestartable() {
-        return true;
-    }
-
-    protected abstract double nextValue();
-
-    private int nextbinaryValue( double num) {
-        int res = 0;
-        if (this.instanceRandom.nextDouble() <= num) {
-            res = 1;
-        }
-        return res;
-    }
-
-    public boolean getChange() {
-        return this.change;
-    }
-
-    public InstanceExample nextInstance() {
-        this.numInstances++;
-        InstancesHeader header = getHeader();
-        Instance inst = new DenseInstance(header.numAttributes());
-        inst.setDataset(header);
-        double nextValue = this.nextValue();
-        if (this.notBinaryStreamOption.isSet()) {
-            inst.setValue(0,  nextValue);
-        } else {
-            inst.setValue(0, this.nextbinaryValue(nextValue));
-        }
-        //Ground truth
-        inst.setValue(1, this.getChange() ? 1 : 0);
-        if (this.getChange() == true) {
-            //this.clusterEvents.add(new ClusterEvent(this, this.numInstances, "Change", "Drift"));
-        }
-        inst.setValue(2,  nextValue);
-        return new InstanceExample(inst);
-    }
+	public FlagOption notBinaryStreamOption = new FlagOption("notBinaryStream", 'b',
+			"Don't convert to a binary stream of 0 and 1.");
 
-    public void restart() {
-        this.instanceRandom = new Random(this.instanceRandomSeedOption.getValue());
-    }
-
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
+	public IntOption numInstancesConceptOption = new IntOption("numInstancesConcept", 'p',
+			"The number of instances for each concept.", 500, 0, Integer.MAX_VALUE);
+
+	protected InstancesHeader streamHeader;
+
+	protected Random instanceRandom;
+
+	protected int period;
+
+	protected int numInstances;
+
+	protected boolean change;
+
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+
+		restart();
+
+		this.numInstances = 0;
+		this.period = numInstancesConceptOption.getValue();
+		// generate header
+		FastVector attributes = new FastVector();
+
+		FastVector binaryLabels = new FastVector();
+		binaryLabels.addElement("0");
+		binaryLabels.addElement("1");
+
+		if (!this.notBinaryStreamOption.isSet()) {
+
+			attributes.addElement(new Attribute("input", binaryLabels));
+		} else {
+			attributes.addElement(new Attribute("input"));
+		}
+
+		// Ground Truth
+		attributes.addElement(new Attribute("change", binaryLabels));
+		attributes.addElement(new Attribute("ground truth input"));
+
+		this.streamHeader = new InstancesHeader(
+				new InstancesHeader(getCLICreationString(InstanceStream.class), attributes, 0));
+		this.streamHeader.setClassIndex(this.streamHeader.numAttributes() - 1);
+
+		this.clusterEvents = new ArrayList<>();
+
+		// this.clusterEvents.add(new ClusterEvent(this,100,"Change", "Drift"));
+		// this.clusterEvents.add(new ClusterEvent(this,200,"Change2", "Drift2"));
+
+	}
+
+	@Override
+	public long estimatedRemainingInstances() {
+		return -1;
+	}
+
+	@Override
+	public InstancesHeader getHeader() {
+		return this.streamHeader;
+	}
+
+	@Override
+	public boolean hasMoreInstances() {
+		return true;
+	}
+
+	@Override
+	public boolean isRestartable() {
+		return true;
+	}
+
+	protected abstract double nextValue();
+
+	private int nextbinaryValue(double num) {
+		int res = 0;
+		if (this.instanceRandom.nextDouble() <= num) {
+			res = 1;
+		}
+		return res;
+	}
+
+	public boolean getChange() {
+		return this.change;
+	}
+
+	@Override
+	public InstanceExample nextInstance() {
+		this.numInstances++;
+		InstancesHeader header = getHeader();
+		Instance inst = new DenseInstance(header.numAttributes());
+		inst.setDataset(header);
+		double nextValue = this.nextValue();
+		if (this.notBinaryStreamOption.isSet()) {
+			inst.setValue(0, nextValue);
+		} else {
+			inst.setValue(0, this.nextbinaryValue(nextValue));
+		}
+		// Ground truth
+		inst.setValue(1, this.getChange() ? 1 : 0);
+		if (this.getChange() == true) {
+			// this.clusterEvents.add(new ClusterEvent(this, this.numInstances, "Change",
+			// "Drift"));
+		}
+		inst.setValue(2, nextValue);
+		return new InstanceExample(inst);
+	}
+
+	@Override
+	public void restart() {
+		this.instanceRandom = new Random(this.instanceRandomSeedOption.getValue());
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
 }
diff --git a/moa/src/main/java/moa/streams/generators/cd/ConceptDriftGenerator.java b/moa/src/main/java/moa/streams/generators/cd/ConceptDriftGenerator.java
index 732885aa7..a86a56489 100644
--- a/moa/src/main/java/moa/streams/generators/cd/ConceptDriftGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/cd/ConceptDriftGenerator.java
@@ -25,5 +25,5 @@
 import moa.streams.clustering.ClusterEvent;
 
 public interface ConceptDriftGenerator extends InstanceStream {
-      public ArrayList<ClusterEvent> getEventsList();
+	ArrayList<ClusterEvent> getEventsList();
 }
diff --git a/moa/src/main/java/moa/streams/generators/cd/GradualChangeGenerator.java b/moa/src/main/java/moa/streams/generators/cd/GradualChangeGenerator.java
index 88748d63a..0d336ee0d 100644
--- a/moa/src/main/java/moa/streams/generators/cd/GradualChangeGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/cd/GradualChangeGenerator.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams.generators.cd;
 
@@ -23,16 +23,16 @@
 
 public class GradualChangeGenerator extends AbstractConceptDriftGenerator {
 
-    public FloatOption changeDriftOption = new FloatOption("changeDrift", 'c',
-            "The magnitude of change.", .001, 0.0, Double.MAX_VALUE);
-    
-    @Override
-    protected double nextValue() {
-        double res;
-        double t = this.numInstances;
-        this.change = (t == this.period ) ? true : false;
-        res = (t < this.period ) ? .2 : .2 + (t - this.period) * changeDriftOption.getValue();
-        res = res > 1.0 ? 1.0 : res;
-        return res;
-    }
+	public FloatOption changeDriftOption = new FloatOption("changeDrift", 'c', "The magnitude of change.", .001, 0.0,
+			Double.MAX_VALUE);
+
+	@Override
+	protected double nextValue() {
+		double res;
+		double t = this.numInstances;
+		this.change = (t == this.period) ? true : false;
+		res = (t < this.period) ? .2 : .2 + (t - this.period) * changeDriftOption.getValue();
+		res = res > 1.0 ? 1.0 : res;
+		return res;
+	}
 }
diff --git a/moa/src/main/java/moa/streams/generators/cd/NoChangeGenerator.java b/moa/src/main/java/moa/streams/generators/cd/NoChangeGenerator.java
index c3fe5abab..9df195ed9 100644
--- a/moa/src/main/java/moa/streams/generators/cd/NoChangeGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/cd/NoChangeGenerator.java
@@ -15,15 +15,15 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams.generators.cd;
 
 public class NoChangeGenerator extends AbstractConceptDriftGenerator {
 
-    @Override
-    protected double nextValue() {
-        double res = .2;
-        return res;
-    }
+	@Override
+	protected double nextValue() {
+		double res = .2;
+		return res;
+	}
 }
diff --git a/moa/src/main/java/moa/streams/generators/multilabel/MetaMultilabelGenerator.java b/moa/src/main/java/moa/streams/generators/multilabel/MetaMultilabelGenerator.java
index 68fdf0998..9620b2b9e 100644
--- a/moa/src/main/java/moa/streams/generators/multilabel/MetaMultilabelGenerator.java
+++ b/moa/src/main/java/moa/streams/generators/multilabel/MetaMultilabelGenerator.java
@@ -2,7 +2,7 @@
  *    MetaMultilabelGenerator.java
  *    Copyright (C) 2012 University of Waikato, Hamilton, New Zealand
  *    @author Jesse Read (jesse@tsc.uc3m.es)
- * 
+ *
  *    This program is free software; you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
  *    the Free Software Foundation; either version 3 of the License, or
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams.generators.multilabel;
 
@@ -54,529 +54,540 @@
  */
 public class MetaMultilabelGenerator extends AbstractOptionHandler implements InstanceStream {
 
-    private static final long serialVersionUID = 1L;
-
-    public ClassOption binaryGeneratorOption = new ClassOption(
-            "binaryGenerator", 's', "Binary Generator (specify the number of attributes here, but only two classes!).", InstanceStream.class, "generators.RandomTreeGenerator");
-
-    public IntOption metaRandomSeedOption = new IntOption(
-            "metaRandomSeed", 'm', "Random seed (for the meta process). Use two streams with the same seed and r > 0.0 in the second stream if you wish to introduce drift to the label dependencies without changing the underlying concept.", 1);
+	private static final long serialVersionUID = 1L;
 
-    public IntOption numLabelsOption = new IntOption(
-            "numLabels", 'c', "Number of labels.", 10, 2, Integer.MAX_VALUE);
+	public ClassOption binaryGeneratorOption = new ClassOption("binaryGenerator", 's',
+			"Binary Generator (specify the number of attributes here, but only two classes!).", InstanceStream.class,
+			"generators.RandomTreeGenerator");
 
-    public IntOption skewOption = new IntOption(
-            "skew", 'k', "Skewed label distribution: 1 (default) = yes; 0 = no (relatively uniform) @NOTE: not currently implemented.", 1, 0, 1);
+	public IntOption metaRandomSeedOption = new IntOption("metaRandomSeed", 'm',
+			"Random seed (for the meta process). Use two streams with the same seed and r > 0.0 in the second stream if you wish to introduce drift to the label dependencies without changing the underlying concept.",
+			1);
 
-    public FloatOption labelCardinalityOption = new FloatOption(
-            "labelCardinality", 'z', "Desired label cardinality (average number of labels per example).", 1.5, 0.0, Integer.MAX_VALUE);
+	public IntOption numLabelsOption = new IntOption("numLabels", 'c', "Number of labels.", 10, 2, Integer.MAX_VALUE);
 
-    public FloatOption labelCardinalityVarOption = new FloatOption(
-            "labelCardinalityVar", 'v', "Desired label cardinality variance (variance of z) @NOTE: not currently implemented.", 1.0, 0.0, Integer.MAX_VALUE);
+	public IntOption skewOption = new IntOption("skew", 'k',
+			"Skewed label distribution: 1 (default) = yes; 0 = no (relatively uniform) @NOTE: not currently implemented.",
+			1, 0, 1);
 
-    public FloatOption labelCardinalityRatioOption = new FloatOption(
-            "labelDependency", 'u', "Specifies how much label dependency from 0 (total independence) to 1 (full dependence).", 0.25, 0.0, 1.0);
+	public FloatOption labelCardinalityOption = new FloatOption("labelCardinality", 'z',
+			"Desired label cardinality (average number of labels per example).", 1.5, 0.0, Integer.MAX_VALUE);
 
-    public FloatOption labelDependencyChangeRatioOption = new FloatOption(
-            "labelDependencyRatioChange", 'r', "Each label-pair dependency has a 'r' chance of being modified. Use this option on the second of two streams with the same random seed (-m) to introduce label-dependence drift.", 0.0, 0.0, 1.0);
+	public FloatOption labelCardinalityVarOption = new FloatOption("labelCardinalityVar", 'v',
+			"Desired label cardinality variance (variance of z) @NOTE: not currently implemented.", 1.0, 0.0,
+			Integer.MAX_VALUE);
 
-    protected MultilabelInstancesHeader m_MultilabelInstancesHeader = null;
+	public FloatOption labelCardinalityRatioOption = new FloatOption("labelDependency", 'u',
+			"Specifies how much label dependency from 0 (total independence) to 1 (full dependence).", 0.25, 0.0, 1.0);
 
-    protected InstanceStream m_BinaryGenerator = null;
+	public FloatOption labelDependencyChangeRatioOption = new FloatOption("labelDependencyRatioChange", 'r',
+			"Each label-pair dependency has a 'r' chance of being modified. Use this option on the second of two streams with the same random seed (-m) to introduce label-dependence drift.",
+			0.0, 0.0, 1.0);
 
-    protected InstancesHeader multilabelStreamTemplate = null;
+	protected MultilabelInstancesHeader m_MultilabelInstancesHeader = null;
 
-    protected Random m_MetaRandom = new Random();
+	protected InstanceStream m_BinaryGenerator = null;
 
-    protected int m_L = 0, m_A = 0;
+	protected InstancesHeader multilabelStreamTemplate = null;
 
-    protected double priors[] = null, priors_norm[] = null;
+	protected Random m_MetaRandom = new Random();
 
-    protected double Conditional[][] = null;
-
-    protected HashSet m_TopCombinations[] = null;
-
-    @Override
-    public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
-        this.restart();
-    }
-
-    @Override
-    public void restart() {
-
-        // The number of class labels L
-        this.m_L = numLabelsOption.getValue();
-
-        if (this.labelCardinalityOption.getValue() > m_L) {
-            System.err.println("Error: Label cardinality (z) cannot be greater than the number of labels (c)!");
-            System.exit(1);
-        }
-
-        // Initialise the chosen binary generator
-        this.m_BinaryGenerator = (InstanceStream) getPreparedClassOption(this.binaryGeneratorOption);
-        this.m_BinaryGenerator.restart();
-
-        // The number of attributes A (not including class-attributes)
-        this.m_A = this.m_BinaryGenerator.getHeader().numAttributes() - 1;
-
-        // Random seed
-        this.m_MetaRandom = new Random(this.metaRandomSeedOption.getValue());
-
-        // Set up a queue system
-        this.queue = new LinkedList[2];
-        for (int i = 0; i < this.queue.length; i++) {
-            this.queue[i] = new LinkedList<Instance>();
-        }
-
-        // Generate the multi-label header
-        this.m_MultilabelInstancesHeader = generateMultilabelHeader(this.m_BinaryGenerator.getHeader());
-
-        // Generate label prior distribution
-        this.priors = generatePriors(m_MetaRandom, m_L, labelCardinalityOption.getValue(), (skewOption.getValue() >= 1));
-        //printVector(this.priors);
-
-        // Generate the matrix marking the label-dependencies
-        boolean DependencyMatrix[][] = modifyDependencyMatrix(new boolean[m_L][m_L], labelCardinalityRatioOption.getValue(), m_MetaRandom);
-
-        // Modify the dependency matrix (and the priors) if they are to change in this stream
-        if (labelDependencyChangeRatioOption.getValue() > 0.0) {
-            priors = modifyPriorVector(priors, labelDependencyChangeRatioOption.getValue(), m_MetaRandom, (skewOption.getValue() >= 1));
-            modifyDependencyMatrix(DependencyMatrix, labelDependencyChangeRatioOption.getValue(), m_MetaRandom);
-        }
-
-        // Generate the conditional matrix, using this change matrix
-        this.Conditional = generateConditional(priors, DependencyMatrix);
-        //printMatrix(this.Conditional);
-
-        // Make a normalised version of the priors
-        this.priors_norm = Arrays.copyOf(priors, priors.length);
-        Utils.normalize(this.priors_norm);
-
-        // Create the feature-label mappings
-        m_TopCombinations = getTopCombinations(m_A);
-    }
-
-    /**
-     * GenerateMultilabelHeader.
-     *
-     * @param	si	single-label Instances
-     */
-    protected MultilabelInstancesHeader generateMultilabelHeader(InstancesHeader si) {
-        InstancesHeader mi = new InstancesHeader(si, 0, 0);
-        mi.setClassIndex(-1);
-        mi.deleteAttributeAt(mi.numAttributes() - 1);
-        FastVector bfv = new FastVector();
-        bfv.addElement("0");
-        bfv.addElement("1");
-        for (int i = 0; i < this.m_L; i++) {
-            mi.insertAttributeAt(new Attribute("class" + i, bfv), i);
-        }
-        this.multilabelStreamTemplate = mi;
-        this.multilabelStreamTemplate.setRelationName("SYN_Z" + this.labelCardinalityOption.getValue() + "L" + this.m_L + "X" + m_A + "S" + metaRandomSeedOption.getValue() + ": -C " + this.m_L);
-        this.multilabelStreamTemplate.setClassIndex(this.m_L);
-        return new MultilabelInstancesHeader(multilabelStreamTemplate, m_L);
-    }
-
-    /**
-     * Generate Priors. Generate the label priors.
-     *
-     * @param	L	number of labels
-     * @param	z	desired label cardinality
-     * @param	r	random number generator
-     * @param	skew	whether to be very skewed or not (@NOTE not currently used)
-     * @return	P	label prior distribution
-     */
-    private double[] generatePriors(Random r, int L, double z, boolean skew) {
-        double P[] = new double[L];
-        for (int i = 0; i < L; i++) {
-            P[i] = r.nextDouble();
-            //P[i] = 1.0; // @temp
-        }
-        // normalise to z
-        do {
-            double c = Utils.sum(P) / z;
-            for (int i = 0; i < L; i++) {
-                P[i] = Math.min(1.0, P[i] / c); // must be in [0,1]
-            }
-        } while (Utils.sum(P) < z);
-        return P;
-    }
-    /**
-     * GetNextWithBinary. Get the next instance with binary class i
-     *
-     * @param	i	the class to generate (0,1)
-     */
-    LinkedList<Instance> queue[] = null;
-
-    private Instance getNextWithBinary(int i) {
-        int lim = 1000;
-        if (queue[i].size() <= 0) {
-            int c = -1;
-            while (lim-- > 0) {
-                Instance tinst = this.m_BinaryGenerator.nextInstance().getData();
-                c = (int) Math.round(tinst.classValue());
-                if (i == c) {
-                    return tinst;
-                } else if (queue[c].size() < 100) {
-                    queue[c].add(tinst);
-                }
-            }
-            System.err.println("[Overflow] The binary stream is too skewed, could not get an example of class " + i + "");
-            System.exit(1);
-            return null;
-        } else {
-            return queue[i].remove();
-        }
-    }
-
-    /**
-     * GenerateML. Generates a multi-label example.
-     */
-    @Override
-    public InstanceExample nextInstance() {
-        return new InstanceExample(generateMLInstance(generateSet()));
-    }
-
-    /**
-     * Generate Set.
-     *
-     * @return	a label set Y
-     */
-    private HashSet generateSet() {
-
-        int y[] = new int[m_L]; 			// [0,0,0]
-        int k = samplePMF(priors_norm); 	// k = 1     // y[k] ~ p(k==1)
-        y[k] = 1; 							// [0,1,0]
-        ArrayList<Integer> indices = getShuffledListToLWithoutK(m_L, k);
-        for (int j : indices) {
-            //y[j] ~ p(j==1|y)
-            y[j] = (joint(j, y) > m_MetaRandom.nextDouble()) ? 1 : 0;
-        }
-        return vector2set(y);
-    }
-
-    // P(y[] where y[k]==1)
-    private double joint(int k, int y[]) {
-        double p = 1.0; //priors[k];
-        for (int j = 0; j < y.length; j++) {
-            if (j != k && y[j] == 1) {
-                p *= Conditional[k][j];
-            }
-        }
-        return p;
-    }
-
-    /**
-     * GenerateMLInstance.
-     *
-     * @param	Y	a set of label [indices]
-     * @return a multit-labelled example
-     */
-    private Instance generateMLInstance(HashSet<Integer> Y) {
-
-        // create a multi-label instance:
-        Instance x_ml = new SparseInstance(this.multilabelStreamTemplate.numAttributes());
-        x_ml.setDataset(this.multilabelStreamTemplate);
-
-        // set classes
-        for (int j = 0; j < m_L; j++) {
-            x_ml.setValue(j, 0.0);
-        }
-        for (int l : Y) {
-            x_ml.setValue(l, 1.0);
-        }
-
-        // generate binary instances
-        Instance x_0 = getNextWithBinary(0);
-        Instance x_1 = getNextWithBinary(1);
-
-        // Loop through each feature attribute @warning: assumes class is last index
-        for (int a = 0; a < m_A; a++) {
-
-            // The combination is present: use a positive value
-            if (Y.containsAll(m_TopCombinations[a])) {
-                x_ml.setValue(m_L + a, x_1.value(a));
-                //x_ml.setValue(m_L+a,1.0);
-            } // The combination is absent: use a negative value
-            else {
-                x_ml.setValue(m_L + a, x_0.value(a));
-                //x_ml.setValue(m_L+a,0.0);
-            }
-        }
-
-        return x_ml;
-    }
-
-    /**
-     * samplePMF.
-     *
-     * @param	p	a pmf
-     * @return	an index i of p with probability p[i], and -1 with probability
-     * 1.0-p[i]
-     */
-    private int samplePMF(double p[]) {
-
-        double r = m_MetaRandom.nextDouble();
-
-        double sum = 0.0;
-        for (int i = 0; i < p.length; i++) {
-            sum += p[i];
-            if (r < sum) {
-                return i;
-            }
-        }
-        return -1;
-    }
-
-    /**
-     * ModifyPriorVector. A certain number of values will be altered.
-     *
-     * @param	P[]	the prior distribution
-     * @param	u	the probability of changing P[j]
-     * @param	r	for random numbers
-     * @param	skew	NOTE not currently used
-     * @return	the modified P
-     */
-    protected double[] modifyPriorVector(double P[], double u, Random r, boolean skew) {
-        for (int j = 0; j < P.length; j++) {
-            if (r.nextDouble() < u) {
-                P[j] = r.nextDouble();
-            }
-        }
-        return P;
-    }
-
-    /**
-     * ModifyDependencyMatrix. A certain number of values will be altered. @NOTE
-     * a future improvement would be to detect cycles, since this may lead to
-     * inconsistencies. However, due to the rarity of this occurring, and the
-     * minimal problems it would cause (and considering that inconsistencies
-     * also occr in real datasets) we don't implement this.
-     *
-     * @param	M[][]	a boolean matrix
-     * @param	u	the probability of changing the relationship M[j][k]
-     * @param	r	for random numbers
-     * @return	the modified M
-     */
-    protected boolean[][] modifyDependencyMatrix(boolean M[][], double u, Random r) {
-        //List<int[]> L = new ArrayList<int[]>();
-        for (int j = 0; j < M.length; j++) {
-            for (int k = j + 1; k < M[j].length; k++) {
-                if (/*
-                         * !hasCycle(L) &&
-                         */r.nextDouble() <= u) {
-                    M[j][k] ^= true;
-                    //L.add(new int[]{j,k});
-                }
-            }
-        }
-        return M;
-    }
-
-    /**
-     * GenerateConditional. Given the priors distribution and a matrix flagging
-     * dependencies, generate a conditional distribution matrix Q; such that:
-     * P(i) = Q[i][i] P(i|j) = Q[i][j]
-     *
-     * @param	P	prior distribution
-     * @param	M	dependency matrix (where 1 == dependency)
-     * @return	Q	conditional dependency matrix
-     */
-    protected double[][] generateConditional(double P[], boolean M[][]) {
-
-        int L = P.length;
-
-        double Q[][] = new double[L][L];
-
-        // set priors
-        for (int j = 0; j < L; j++) {
-            Q[j][j] = P[j];
-        }
-
-        // create conditionals
-        for (int j = 0; j < Q.length; j++) {
-            for (int k = j + 1; k < Q[j].length; k++) {
-
-                // dependence
-                if (M[j][k]) {
-                    // min = tending toward mutual exclusivity
-                    // max = tending toward total co-occurence
-                    // @NOTE it would also be an option to select in [min,max], but since
-                    //       we are approximating the joint distribution, we can take
-                    //       a stronger approach, and just take either min or max.
-                    Q[j][k] = (m_MetaRandom.nextBoolean() ? min(P[j], P[k]) : max(P[j], P[k]));
-                    Q[k][j] = (Q[j][k] * Q[j][j]) / Q[k][k]; // Bayes Rule
-                } // independence
-                else {
-                    Q[j][k] = P[j];
-                    Q[k][j] = (Q[j][k] * P[k]) / P[j]; // Bayes Rule
-                }
-            }
-        }
-
-        return Q;
-    }
-
-    /**
-     * GetTopCombinations. Calculating the full joint probability distribution
-     * is too complex. - sample from the approximate joint many times - record
-     * the the n most commonly ocurring Y and their frequencies - create a map
-     * based on these frequencies
-     *
-     * @param	n	the number of labelsets
-     * @return	n labelsts
-     */
-    private HashSet[] getTopCombinations(int n) {
-
-        final HashMap<HashSet, Integer> count = new HashMap<HashSet, Integer>();
-        HashMap<HashSet, Integer> isets = new HashMap<HashSet, Integer>();
-
-        int N = 100000;
-        double lc = 0.0;
-        for (int i = 0; i < N; i++) {
-            HashSet Y = generateSet();
-            lc += Y.size();
-            count.put(Y, count.get(Y) != null ? count.get(Y) + 1 : 1);
-        }
-        lc = lc / N;
-
-        // @TODO could generate closed frequent itemsets from 'count'
-
-        List<HashSet> top_set = new ArrayList<HashSet>(count.keySet());
-        // Sort the sets by their count
-        Collections.sort(top_set, new Comparator<HashSet>() {
-
-            @Override
-            public int compare(HashSet Y1, HashSet Y2) {
-                return count.get(Y2).compareTo(count.get(Y1));
-            }
-        });
-
-        System.err.println("The most common labelsets (from which we will build the map) will likely be: ");
-        HashSet map_set[] = new HashSet[n];
-        double weights[] = new double[n];
-        int idx = 0;
-        for (HashSet Y : top_set) {
-            System.err.println(" " + Y + " : " + (count.get(Y) * 100.0 / N) + "%");
-            weights[idx++] = count.get(Y);
-            if (idx == weights.length) {
-                break;
-            }
-        }
-        double sum = Utils.sum(weights);
-
-        System.err.println("Estimated Label Cardinality:  " + lc + "\n\n");
-        System.err.println("Estimated % Unique Labelsets: " + (count.size() * 100.0 / N) + "%\n\n");
-
-        // normalize weights[]
-        Utils.normalize(weights);
-
-        // add sets to the map set, according to their weights
-        for (int i = 0, k = 0; i < top_set.size() && k < map_set.length; i++) {   // i'th combination (pre)
-            int num = (int) Math.round(Math.max(weights[i] * map_set.length, 1.0));	 // i'th weight
-            for (int j = 0; j < num && k < map_set.length; j++) {
-                map_set[k++] = top_set.get(i);
-            }
-        }
-
-        // shuffle 
-        Collections.shuffle(Arrays.asList(map_set));
-
-        // return
-        return map_set;
-    }
-
-    @Override
-    public InstancesHeader getHeader() {
-        return m_MultilabelInstancesHeader;
-    }
-
-    @Override
-    public String getPurposeString() {
-        return "Generates a multi-label stream based on a binary random generator.";
-    }
-
-    @Override
-    public long estimatedRemainingInstances() {
-        return -1;
-    }
-
-    @Override
-    public boolean hasMoreInstances() {
-        return true;
-    }
-
-    @Override
-    public boolean isRestartable() {
-        return true;
-    }
-
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-    }
-
-    // ------- following are private utility functions -----------
-    // convert set Y to an L-length vector y
-    private int[] set2vector(HashSet<Integer> Y, int L) {
-        int y[] = new int[L];
-        for (int j : Y) {
-            y[j] = 1;
-        }
-        return y;
-    }
-    // convert L-length vector y to set Y
-
-    private HashSet<Integer> vector2set(int y[]) {
-        HashSet<Integer> Y = new HashSet<Integer>();
-        for (int j = 0; j < y.length; j++) {
-            if (y[j] > 0) {
-                Y.add(j);
-            }
-        }
-        return Y;
-    }
-
-    // the highest possible prob. of P(A|B) given A and B
-    private double max(double A, double B) {
-        return Math.min(1.0, (B / A));
-    }
-
-    // the lowest possible prob. of P(A|B) given A and B
-    private double min(double A, double B) {
-        return Math.max(0.0, (-1.0 + A + B));
-    }
-
-    private ArrayList<Integer> getShuffledListToLWithoutK(int L, int k) {
-        ArrayList<Integer> list = new ArrayList<Integer>(L - 1);
-        for (int j = 0; j < L; j++) {
-            if (j != k) {
-                list.add(j);
-            }
-        }
-        Collections.shuffle(list);
-        return list;
-    }
-
-    // ------- following are private debugging functions -----------
-    public static void main(String args[]) {
-        // test routines
-    }
-
-    private void printMatrix(double M[][]) {
-        System.out.println("--- MATRIX ---");
-        for (int i = 0; i < M.length; i++) {
-            for (int j = 0; j < M[i].length; j++) {
-                System.out.print(" " + Utils.doubleToString(M[i][j], 5, 3));
-            }
-            System.out.println("");
-        }
-    }
-
-    private void printVector(double V[]) {
-        System.out.println("--- VECTOR ---");
-        for (int j = 0; j < V.length; j++) {
-            System.out.print(" " + Utils.doubleToString(V[j], 5, 3));
-        }
-        System.out.println("");
-    }
+	protected int m_L = 0, m_A = 0;
+
+	protected double priors[] = null, priors_norm[] = null;
+
+	protected double Conditional[][] = null;
+
+	protected HashSet m_TopCombinations[] = null;
+
+	@Override
+	public void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		this.restart();
+	}
+
+	@Override
+	public void restart() {
+
+		// The number of class labels L
+		this.m_L = numLabelsOption.getValue();
+
+		if (this.labelCardinalityOption.getValue() > m_L) {
+			System.err.println("Error: Label cardinality (z) cannot be greater than the number of labels (c)!");
+			System.exit(1);
+		}
+
+		// Initialise the chosen binary generator
+		this.m_BinaryGenerator = (InstanceStream) getPreparedClassOption(this.binaryGeneratorOption);
+		this.m_BinaryGenerator.restart();
+
+		// The number of attributes A (not including class-attributes)
+		this.m_A = this.m_BinaryGenerator.getHeader().numAttributes() - 1;
+
+		// Random seed
+		this.m_MetaRandom = new Random(this.metaRandomSeedOption.getValue());
+
+		// Set up a queue system
+		this.queue = new LinkedList[2];
+		for (int i = 0; i < this.queue.length; i++) {
+			this.queue[i] = new LinkedList<>();
+		}
+
+		// Generate the multi-label header
+		this.m_MultilabelInstancesHeader = generateMultilabelHeader(this.m_BinaryGenerator.getHeader());
+
+		// Generate label prior distribution
+		this.priors = generatePriors(m_MetaRandom, m_L, labelCardinalityOption.getValue(),
+				(skewOption.getValue() >= 1));
+		// printVector(this.priors);
+
+		// Generate the matrix marking the label-dependencies
+		boolean DependencyMatrix[][] = modifyDependencyMatrix(new boolean[m_L][m_L],
+				labelCardinalityRatioOption.getValue(), m_MetaRandom);
+
+		// Modify the dependency matrix (and the priors) if they are to change in this
+		// stream
+		if (labelDependencyChangeRatioOption.getValue() > 0.0) {
+			priors = modifyPriorVector(priors, labelDependencyChangeRatioOption.getValue(), m_MetaRandom,
+					(skewOption.getValue() >= 1));
+			modifyDependencyMatrix(DependencyMatrix, labelDependencyChangeRatioOption.getValue(), m_MetaRandom);
+		}
+
+		// Generate the conditional matrix, using this change matrix
+		this.Conditional = generateConditional(priors, DependencyMatrix);
+		// printMatrix(this.Conditional);
+
+		// Make a normalised version of the priors
+		this.priors_norm = Arrays.copyOf(priors, priors.length);
+		Utils.normalize(this.priors_norm);
+
+		// Create the feature-label mappings
+		m_TopCombinations = getTopCombinations(m_A);
+	}
+
+	/**
+	 * GenerateMultilabelHeader.
+	 *
+	 * @param si single-label Instances
+	 */
+	protected MultilabelInstancesHeader generateMultilabelHeader(InstancesHeader si) {
+		InstancesHeader mi = new InstancesHeader(si, 0, 0);
+		mi.setClassIndex(-1);
+		mi.deleteAttributeAt(mi.numAttributes() - 1);
+		FastVector bfv = new FastVector();
+		bfv.addElement("0");
+		bfv.addElement("1");
+		for (int i = 0; i < this.m_L; i++) {
+			mi.insertAttributeAt(new Attribute("class" + i, bfv), i);
+		}
+		this.multilabelStreamTemplate = mi;
+		this.multilabelStreamTemplate.setRelationName("SYN_Z" + this.labelCardinalityOption.getValue() + "L" + this.m_L
+				+ "X" + m_A + "S" + metaRandomSeedOption.getValue() + ": -C " + this.m_L);
+		this.multilabelStreamTemplate.setClassIndex(this.m_L);
+		return new MultilabelInstancesHeader(multilabelStreamTemplate, m_L);
+	}
+
+	/**
+	 * Generate Priors. Generate the label priors.
+	 *
+	 * @param L    number of labels
+	 * @param z    desired label cardinality
+	 * @param r    random number generator
+	 * @param skew whether to be very skewed or not (@NOTE not currently used)
+	 * @return P label prior distribution
+	 */
+	private double[] generatePriors(Random r, int L, double z, boolean skew) {
+		double P[] = new double[L];
+		for (int i = 0; i < L; i++) {
+			P[i] = r.nextDouble();
+			// P[i] = 1.0; // @temp
+		}
+		// normalise to z
+		do {
+			double c = Utils.sum(P) / z;
+			for (int i = 0; i < L; i++) {
+				P[i] = Math.min(1.0, P[i] / c); // must be in [0,1]
+			}
+		} while (Utils.sum(P) < z);
+		return P;
+	}
+
+	/**
+	 * GetNextWithBinary. Get the next instance with binary class i
+	 *
+	 * @param i the class to generate (0,1)
+	 */
+	LinkedList<Instance> queue[] = null;
+
+	private Instance getNextWithBinary(int i) {
+		int lim = 1000;
+		if (queue[i].size() <= 0) {
+			int c = -1;
+			while (lim-- > 0) {
+				Instance tinst = this.m_BinaryGenerator.nextInstance().getData();
+				c = (int) Math.round(tinst.classValue());
+				if (i == c) {
+					return tinst;
+				} else if (queue[c].size() < 100) {
+					queue[c].add(tinst);
+				}
+			}
+			System.err
+					.println("[Overflow] The binary stream is too skewed, could not get an example of class " + i + "");
+			System.exit(1);
+			return null;
+		} else {
+			return queue[i].remove();
+		}
+	}
+
+	/**
+	 * GenerateML. Generates a multi-label example.
+	 */
+	@Override
+	public InstanceExample nextInstance() {
+		return new InstanceExample(generateMLInstance(generateSet()));
+	}
+
+	/**
+	 * Generate Set.
+	 *
+	 * @return a label set Y
+	 */
+	private HashSet generateSet() {
+
+		int y[] = new int[m_L]; // [0,0,0]
+		int k = samplePMF(priors_norm); // k = 1 // y[k] ~ p(k==1)
+		y[k] = 1; // [0,1,0]
+		ArrayList<Integer> indices = getShuffledListToLWithoutK(m_L, k);
+		for (int j : indices) {
+			// y[j] ~ p(j==1|y)
+			y[j] = (joint(j, y) > m_MetaRandom.nextDouble()) ? 1 : 0;
+		}
+		return vector2set(y);
+	}
+
+	// P(y[] where y[k]==1)
+	private double joint(int k, int y[]) {
+		double p = 1.0; // priors[k];
+		for (int j = 0; j < y.length; j++) {
+			if (j != k && y[j] == 1) {
+				p *= Conditional[k][j];
+			}
+		}
+		return p;
+	}
+
+	/**
+	 * GenerateMLInstance.
+	 *
+	 * @param Y a set of label [indices]
+	 * @return a multit-labelled example
+	 */
+	private Instance generateMLInstance(HashSet<Integer> Y) {
+
+		// create a multi-label instance:
+		Instance x_ml = new SparseInstance(this.multilabelStreamTemplate.numAttributes());
+		x_ml.setDataset(this.multilabelStreamTemplate);
+
+		// set classes
+		for (int j = 0; j < m_L; j++) {
+			x_ml.setValue(j, 0.0);
+		}
+		for (int l : Y) {
+			x_ml.setValue(l, 1.0);
+		}
+
+		// generate binary instances
+		Instance x_0 = getNextWithBinary(0);
+		Instance x_1 = getNextWithBinary(1);
+
+		// Loop through each feature attribute @warning: assumes class is last index
+		for (int a = 0; a < m_A; a++) {
+
+			// The combination is present: use a positive value
+			if (Y.containsAll(m_TopCombinations[a])) {
+				x_ml.setValue(m_L + a, x_1.value(a));
+				// x_ml.setValue(m_L+a,1.0);
+			} // The combination is absent: use a negative value
+			else {
+				x_ml.setValue(m_L + a, x_0.value(a));
+				// x_ml.setValue(m_L+a,0.0);
+			}
+		}
+
+		return x_ml;
+	}
+
+	/**
+	 * samplePMF.
+	 *
+	 * @param p a pmf
+	 * @return an index i of p with probability p[i], and -1 with probability
+	 *         1.0-p[i]
+	 */
+	private int samplePMF(double p[]) {
+
+		double r = m_MetaRandom.nextDouble();
+
+		double sum = 0.0;
+		for (int i = 0; i < p.length; i++) {
+			sum += p[i];
+			if (r < sum) {
+				return i;
+			}
+		}
+		return -1;
+	}
+
+	/**
+	 * ModifyPriorVector. A certain number of values will be altered.
+	 *
+	 * @param P[]  the prior distribution
+	 * @param u    the probability of changing P[j]
+	 * @param r    for random numbers
+	 * @param skew NOTE not currently used
+	 * @return the modified P
+	 */
+	protected double[] modifyPriorVector(double P[], double u, Random r, boolean skew) {
+		for (int j = 0; j < P.length; j++) {
+			if (r.nextDouble() < u) {
+				P[j] = r.nextDouble();
+			}
+		}
+		return P;
+	}
+
+	/**
+	 * ModifyDependencyMatrix. A certain number of values will be altered. @NOTE a
+	 * future improvement would be to detect cycles, since this may lead to
+	 * inconsistencies. However, due to the rarity of this occurring, and the
+	 * minimal problems it would cause (and considering that inconsistencies also
+	 * occr in real datasets) we don't implement this.
+	 *
+	 * @param M[][] a boolean matrix
+	 * @param u     the probability of changing the relationship M[j][k]
+	 * @param r     for random numbers
+	 * @return the modified M
+	 */
+	protected boolean[][] modifyDependencyMatrix(boolean M[][], double u, Random r) {
+		// List<int[]> L = new ArrayList<int[]>();
+		for (int j = 0; j < M.length; j++) {
+			for (int k = j + 1; k < M[j].length; k++) {
+				if (/*
+					 * !hasCycle(L) &&
+					 */r.nextDouble() <= u) {
+					M[j][k] ^= true;
+					// L.add(new int[]{j,k});
+				}
+			}
+		}
+		return M;
+	}
+
+	/**
+	 * GenerateConditional. Given the priors distribution and a matrix flagging
+	 * dependencies, generate a conditional distribution matrix Q; such that: P(i) =
+	 * Q[i][i] P(i|j) = Q[i][j]
+	 *
+	 * @param P prior distribution
+	 * @param M dependency matrix (where 1 == dependency)
+	 * @return Q conditional dependency matrix
+	 */
+	protected double[][] generateConditional(double P[], boolean M[][]) {
+
+		int L = P.length;
+
+		double Q[][] = new double[L][L];
+
+		// set priors
+		for (int j = 0; j < L; j++) {
+			Q[j][j] = P[j];
+		}
+
+		// create conditionals
+		for (int j = 0; j < Q.length; j++) {
+			for (int k = j + 1; k < Q[j].length; k++) {
+
+				// dependence
+				if (M[j][k]) {
+					// min = tending toward mutual exclusivity
+					// max = tending toward total co-occurence
+					// @NOTE it would also be an option to select in [min,max], but since
+					// we are approximating the joint distribution, we can take
+					// a stronger approach, and just take either min or max.
+					Q[j][k] = (m_MetaRandom.nextBoolean() ? min(P[j], P[k]) : max(P[j], P[k]));
+					Q[k][j] = (Q[j][k] * Q[j][j]) / Q[k][k]; // Bayes Rule
+				} // independence
+				else {
+					Q[j][k] = P[j];
+					Q[k][j] = (Q[j][k] * P[k]) / P[j]; // Bayes Rule
+				}
+			}
+		}
+
+		return Q;
+	}
+
+	/**
+	 * GetTopCombinations. Calculating the full joint probability distribution is
+	 * too complex. - sample from the approximate joint many times - record the the
+	 * n most commonly ocurring Y and their frequencies - create a map based on
+	 * these frequencies
+	 *
+	 * @param n the number of labelsets
+	 * @return n labelsts
+	 */
+	private HashSet[] getTopCombinations(int n) {
+
+		final HashMap<HashSet, Integer> count = new HashMap<>();
+		HashMap<HashSet, Integer> isets = new HashMap<>();
+
+		int N = 100000;
+		double lc = 0.0;
+		for (int i = 0; i < N; i++) {
+			HashSet Y = generateSet();
+			lc += Y.size();
+			count.put(Y, count.get(Y) != null ? count.get(Y) + 1 : 1);
+		}
+		lc = lc / N;
+
+		// @TODO could generate closed frequent itemsets from 'count'
+
+		List<HashSet> top_set = new ArrayList<>(count.keySet());
+		// Sort the sets by their count
+		Collections.sort(top_set, new Comparator<HashSet>() {
+
+			@Override
+			public int compare(HashSet Y1, HashSet Y2) {
+				return count.get(Y2).compareTo(count.get(Y1));
+			}
+		});
+
+		System.err.println("The most common labelsets (from which we will build the map) will likely be: ");
+		HashSet map_set[] = new HashSet[n];
+		double weights[] = new double[n];
+		int idx = 0;
+		for (HashSet Y : top_set) {
+			System.err.println(" " + Y + " : " + (count.get(Y) * 100.0 / N) + "%");
+			weights[idx++] = count.get(Y);
+			if (idx == weights.length) {
+				break;
+			}
+		}
+		double sum = Utils.sum(weights);
+
+		System.err.println("Estimated Label Cardinality:  " + lc + "\n\n");
+		System.err.println("Estimated % Unique Labelsets: " + (count.size() * 100.0 / N) + "%\n\n");
+
+		// normalize weights[]
+		Utils.normalize(weights);
+
+		// add sets to the map set, according to their weights
+		for (int i = 0, k = 0; i < top_set.size() && k < map_set.length; i++) { // i'th combination (pre)
+			int num = (int) Math.round(Math.max(weights[i] * map_set.length, 1.0)); // i'th weight
+			for (int j = 0; j < num && k < map_set.length; j++) {
+				map_set[k++] = top_set.get(i);
+			}
+		}
+
+		// shuffle
+		Collections.shuffle(Arrays.asList(map_set));
+
+		// return
+		return map_set;
+	}
+
+	@Override
+	public InstancesHeader getHeader() {
+		return m_MultilabelInstancesHeader;
+	}
+
+	@Override
+	public String getPurposeString() {
+		return "Generates a multi-label stream based on a binary random generator.";
+	}
+
+	@Override
+	public long estimatedRemainingInstances() {
+		return -1;
+	}
+
+	@Override
+	public boolean hasMoreInstances() {
+		return true;
+	}
+
+	@Override
+	public boolean isRestartable() {
+		return true;
+	}
+
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+	}
+
+	// ------- following are private utility functions -----------
+	// convert set Y to an L-length vector y
+	private int[] set2vector(HashSet<Integer> Y, int L) {
+		int y[] = new int[L];
+		for (int j : Y) {
+			y[j] = 1;
+		}
+		return y;
+	}
+	// convert L-length vector y to set Y
+
+	private HashSet<Integer> vector2set(int y[]) {
+		HashSet<Integer> Y = new HashSet<>();
+		for (int j = 0; j < y.length; j++) {
+			if (y[j] > 0) {
+				Y.add(j);
+			}
+		}
+		return Y;
+	}
+
+	// the highest possible prob. of P(A|B) given A and B
+	private double max(double A, double B) {
+		return Math.min(1.0, (B / A));
+	}
+
+	// the lowest possible prob. of P(A|B) given A and B
+	private double min(double A, double B) {
+		return Math.max(0.0, (-1.0 + A + B));
+	}
+
+	private ArrayList<Integer> getShuffledListToLWithoutK(int L, int k) {
+		ArrayList<Integer> list = new ArrayList<>(L - 1);
+		for (int j = 0; j < L; j++) {
+			if (j != k) {
+				list.add(j);
+			}
+		}
+		Collections.shuffle(list);
+		return list;
+	}
+
+	// ------- following are private debugging functions -----------
+	public static void main(String args[]) {
+		// test routines
+	}
+
+	private void printMatrix(double M[][]) {
+		System.out.println("--- MATRIX ---");
+		for (int i = 0; i < M.length; i++) {
+			for (int j = 0; j < M[i].length; j++) {
+				System.out.print(" " + Utils.doubleToString(M[i][j], 5, 3));
+			}
+			System.out.println("");
+		}
+	}
+
+	private void printVector(double V[]) {
+		System.out.println("--- VECTOR ---");
+		for (int j = 0; j < V.length; j++) {
+			System.out.print(" " + Utils.doubleToString(V[j], 5, 3));
+		}
+		System.out.println("");
+	}
 }
diff --git a/moa/src/main/java/moa/streams/generators/multilabel/MultilabelArffFileStream.java b/moa/src/main/java/moa/streams/generators/multilabel/MultilabelArffFileStream.java
index feba68150..c93c6f0ed 100644
--- a/moa/src/main/java/moa/streams/generators/multilabel/MultilabelArffFileStream.java
+++ b/moa/src/main/java/moa/streams/generators/multilabel/MultilabelArffFileStream.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.streams.generators.multilabel;
 
@@ -32,29 +32,30 @@
  * @author Jesse Read (jmr30@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class MultilabelArffFileStream extends ArffFileStream implements MultiTargetInstanceStream{
+public class MultilabelArffFileStream extends ArffFileStream implements MultiTargetInstanceStream {
 
-    @Override
-    public String getPurposeString() {
-        return "A stream read from an ARFF file.";
-    }
+	@Override
+	public String getPurposeString() {
+		return "A stream read from an ARFF file.";
+	}
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public IntOption numLabelsOption = new IntOption("numLabels", 'l',
-            "The number of labels. e.g. n = 10 : the first 10 binary attributes are the labels; n = -10 the last 10 binary attributes are the labels.", -1, -1, Integer.MAX_VALUE);
+	public IntOption numLabelsOption = new IntOption("numLabels", 'l',
+			"The number of labels. e.g. n = 10 : the first 10 binary attributes are the labels; n = -10 the last 10 binary attributes are the labels.",
+			-1, -1, Integer.MAX_VALUE);
 
-    public MultilabelArffFileStream() {
-    }
+	public MultilabelArffFileStream() {
+	}
 
-    public MultilabelArffFileStream(String arffFileName, int numLabels) {
-        this.arffFileOption.setValue(arffFileName);
-        this.numLabelsOption.setValue(numLabels);
-        restart();
-    }
+	public MultilabelArffFileStream(String arffFileName, int numLabels) {
+		this.arffFileOption.setValue(arffFileName);
+		this.numLabelsOption.setValue(numLabels);
+		restart();
+	}
 
-    @Override
-    public InstancesHeader getHeader() {
-        return new MultilabelInstancesHeader(this.instances, numLabelsOption.getValue());
-    }
+	@Override
+	public InstancesHeader getHeader() {
+		return new MultilabelInstancesHeader(this.instances, numLabelsOption.getValue());
+	}
 }
diff --git a/moa/src/main/java/moa/tasks/AbstractEvaluateInterleavedTestThenTrain.java b/moa/src/main/java/moa/tasks/AbstractEvaluateInterleavedTestThenTrain.java
index 9569fe065..69b9846bb 100644
--- a/moa/src/main/java/moa/tasks/AbstractEvaluateInterleavedTestThenTrain.java
+++ b/moa/src/main/java/moa/tasks/AbstractEvaluateInterleavedTestThenTrain.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks;
 
@@ -26,196 +26,172 @@
 import com.github.javacliparser.FileOption;
 import com.github.javacliparser.IntOption;
 
-import moa.capabilities.Capability;
-import moa.capabilities.ImmutableCapabilities;
+import moa.capabilities.CapabilitiesHandler;
 import moa.core.Example;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
 import moa.core.TimingUtils;
 import moa.evaluation.LearningEvaluation;
-import moa.evaluation.LearningPerformanceEvaluator;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
 import moa.evaluation.preview.LearningCurve;
-import moa.learners.InstanceLearner;
+import moa.learners.predictors.InstanceLearner;
 import moa.options.ClassOption;
 import moa.streams.ExampleStream;
 import moa.streams.InstanceStream;
 
 /**
- * Task for evaluating a classifier on a stream by testing then training with each example in sequence.
+ * Task for evaluating a classifier on a stream by testing then training with
+ * each example in sequence.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public abstract class AbstractEvaluateInterleavedTestThenTrain<MLTask extends InstanceLearner> extends MainTask {
-
-    private static final long serialVersionUID = 1L;
-
-    // CLI char: l
-    public ClassOption learnerOption;
-
-    public ClassOption streamOption = new ClassOption("stream", 's',
-            "Stream to learn from.", ExampleStream.class,
-            "generators.RandomTreeGenerator");
-
-    public IntOption randomSeedOption = new IntOption(
-            "instanceRandomSeed", 'r',
-            "Seed for random generation of instances.", 1);
-
-    // CLI char: e
-    public ClassOption evaluatorOption;
-
-    public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
-            "Maximum number of instances to test/train on  (-1 = no limit).",
-            100000000, -1, Integer.MAX_VALUE);
-
-    public IntOption timeLimitOption = new IntOption("timeLimit", 't',
-            "Maximum number of seconds to test/train for (-1 = no limit).", -1,
-            -1, Integer.MAX_VALUE);
-
-    public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
-            'f',
-            "How many instances between samples of the learning performance.",
-            100000, 0, Integer.MAX_VALUE);
-
-    public IntOption memCheckFrequencyOption = new IntOption(
-            "memCheckFrequency", 'q',
-            "How many instances between memory bound checks.", 100000, 0,
-            Integer.MAX_VALUE);
-
-    public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
-            "File to append intermediate csv reslts to.", null, "csv", true);
-
-    @Override
-    public Class<?> getTaskResultType() {
-        return LearningCurve.class;
-    }
-
-    @Override
-    protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
-
-        String learnerString = this.learnerOption.getValueAsCLIString();
-        String streamString = this.streamOption.getValueAsCLIString();
-        //this.learnerOption.setValueViaCLIString(this.learnerOption.getValueAsCLIString() + " -r " +this.randomSeedOption);
-       // this.streamOption.setValueViaCLIString(streamString + " -i " + this.randomSeedOption.getValueAsCLIString());
-        
-        MLTask learner = (MLTask) getPreparedClassOption(this.learnerOption);
-        if (learner.isRandomizable()) {
-            learner.setRandomSeed(this.randomSeedOption.getValue());
-            learner.resetLearning();
-        }
-        ExampleStream stream = (InstanceStream) getPreparedClassOption(this.streamOption);
-        
-        LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
-        learner.setModelContext(stream.getHeader());
-        int maxInstances = this.instanceLimitOption.getValue();
-        long instancesProcessed = 0;
-        int maxSeconds = this.timeLimitOption.getValue();
-        int secondsElapsed = 0;
-        monitor.setCurrentActivity("Evaluating learner...", -1.0);
-        LearningCurve learningCurve = new LearningCurve(
-                "learning evaluation instances");
-        File dumpFile = this.dumpFileOption.getFile();
-        PrintStream immediateResultStream = null;
-        if (dumpFile != null) {
-            try {
-                if (dumpFile.exists()) {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile, true), true);
-                } else {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile), true);
-                }
-            } catch (Exception ex) {
-                throw new RuntimeException(
-                        "Unable to open immediate result file: " + dumpFile, ex);
-            }
-        }
-        boolean firstDump = true;
-        boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
-        long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-        long lastEvaluateStartTime = evaluateStartTime;
-        double RAMHours = 0.0;
-        while (stream.hasMoreInstances()
-                && ((maxInstances < 0) || (instancesProcessed < maxInstances))
-                && ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
-            Example trainInst = stream.nextInstance();
-            Example testInst = trainInst; //.copy();
-            //int trueClass = (int) trainInst.classValue();
-            //testInst.setClassMissing();
-            double[] prediction = learner.getPredictionForInstance(testInst).asDoubleArray();
-            //evaluator.addClassificationAttempt(trueClass, prediction, testInst
-            //		.weight());
-            evaluator.addResult(testInst, prediction);
-            learner.trainOnInstance(trainInst);
-            instancesProcessed++;
-            if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0
-                  ||  stream.hasMoreInstances() == false) {
-                long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-                double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);
-                double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);
-                double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); //GBs
-                RAMHoursIncrement *= (timeIncrement / 3600.0); //Hours
-                RAMHours += RAMHoursIncrement;
-                lastEvaluateStartTime = evaluateTime;
-                learningCurve.insertEntry(new LearningEvaluation(
-                        new Measurement[]{
-                            new Measurement(
-                            "learning evaluation instances",
-                            instancesProcessed),
-                            new Measurement(
-                            "evaluation time ("
-                            + (preciseCPUTiming ? "cpu "
-                            : "") + "seconds)",
-                            time),
-                            new Measurement(
-                            "model cost (RAM-Hours)",
-                            RAMHours)
-                        },
-                        evaluator, learner));
-                if (immediateResultStream != null) {
-                    if (firstDump) {
-                        immediateResultStream.print("Learner,stream,randomSeed,");
-                        immediateResultStream.println(learningCurve.headerToString());
-                        firstDump = false;
-                    }
-                    immediateResultStream.print(learnerString + "," + streamString + "," + this.randomSeedOption.getValueAsCLIString() + ",");
-                    immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
-                    immediateResultStream.flush();
-                }
-            }
-            if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
-                if (monitor.taskShouldAbort()) {
-                    return null;
-                }
-                long estimatedRemainingInstances = stream.estimatedRemainingInstances();
-                if (maxInstances > 0) {
-                    long maxRemaining = maxInstances - instancesProcessed;
-                    if ((estimatedRemainingInstances < 0)
-                            || (maxRemaining < estimatedRemainingInstances)) {
-                        estimatedRemainingInstances = maxRemaining;
-                    }
-                }
-                monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
-                        : (double) instancesProcessed
-                        / (double) (instancesProcessed + estimatedRemainingInstances));
-                if (monitor.resultPreviewRequested()) {
-                    monitor.setLatestResultPreview(learningCurve.copy());
-                }
-                secondsElapsed = (int) TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread()
-                        - evaluateStartTime);
-            }
-        }
-        if (immediateResultStream != null) {
-            immediateResultStream.close();
-        }
-        return learningCurve;
-    }
-
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == EvaluateInterleavedTestThenTrain.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
+public abstract class AbstractEvaluateInterleavedTestThenTrain<MLTask extends InstanceLearner> extends MainTask
+		implements CapabilitiesHandler {
+
+	private static final long serialVersionUID = 1L;
+
+	// CLI char: l
+	public ClassOption learnerOption;
+
+	public ClassOption streamOption = new ClassOption("stream", 's', "Stream to learn from.", ExampleStream.class,
+			"generators.RandomTreeGenerator");
+
+	public IntOption randomSeedOption = new IntOption("instanceRandomSeed", 'r',
+			"Seed for random generation of instances.", 1);
+
+	// CLI char: e
+	public ClassOption evaluatorOption;
+
+	public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
+			"Maximum number of instances to test/train on  (-1 = no limit).", 100000000, -1, Integer.MAX_VALUE);
+
+	public IntOption timeLimitOption = new IntOption("timeLimit", 't',
+			"Maximum number of seconds to test/train for (-1 = no limit).", -1, -1, Integer.MAX_VALUE);
+
+	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency", 'f',
+			"How many instances between samples of the learning performance.", 100000, 0, Integer.MAX_VALUE);
+
+	public IntOption memCheckFrequencyOption = new IntOption("memCheckFrequency", 'q',
+			"How many instances between memory bound checks.", 100000, 0, Integer.MAX_VALUE);
+
+	public FileOption dumpFileOption = new FileOption("dumpFile", 'd', "File to append intermediate csv reslts to.",
+			null, "csv", true);
+
+	@Override
+	public Class<?> getTaskResultType() {
+		return LearningCurve.class;
+	}
+
+	@Override
+	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
+
+		String learnerString = this.learnerOption.getValueAsCLIString();
+		String streamString = this.streamOption.getValueAsCLIString();
+		// this.learnerOption.setValueViaCLIString(this.learnerOption.getValueAsCLIString()
+		// + " -r " +this.randomSeedOption);
+		// this.streamOption.setValueViaCLIString(streamString + " -i " +
+		// this.randomSeedOption.getValueAsCLIString());
+
+		MLTask learner = (MLTask) getPreparedClassOption(this.learnerOption);
+		if (learner.isRandomizable()) {
+			learner.setRandomSeed(this.randomSeedOption.getValue());
+			learner.resetLearning();
+		}
+		ExampleStream stream = (InstanceStream) getPreparedClassOption(this.streamOption);
+
+		LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(
+				this.evaluatorOption);
+		learner.setModelContext(stream.getHeader());
+		int maxInstances = this.instanceLimitOption.getValue();
+		long instancesProcessed = 0;
+		int maxSeconds = this.timeLimitOption.getValue();
+		int secondsElapsed = 0;
+		monitor.setCurrentActivity("Evaluating learner...", -1.0);
+		LearningCurve learningCurve = new LearningCurve("learning evaluation instances");
+		File dumpFile = this.dumpFileOption.getFile();
+		PrintStream immediateResultStream = null;
+		if (dumpFile != null) {
+			try {
+				if (dumpFile.exists()) {
+					immediateResultStream = new PrintStream(new FileOutputStream(dumpFile, true), true);
+				} else {
+					immediateResultStream = new PrintStream(new FileOutputStream(dumpFile), true);
+				}
+			} catch (Exception ex) {
+				throw new RuntimeException("Unable to open immediate result file: " + dumpFile, ex);
+			}
+		}
+		boolean firstDump = true;
+		boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
+		long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+		long lastEvaluateStartTime = evaluateStartTime;
+		double RAMHours = 0.0;
+		while (stream.hasMoreInstances() && ((maxInstances < 0) || (instancesProcessed < maxInstances))
+				&& ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
+			Example trainInst = stream.nextInstance();
+			Example testInst = trainInst; // .copy();
+			// int trueClass = (int) trainInst.classValue();
+			// testInst.setClassMissing();
+			double[] prediction = learner.getPredictionForInstance(testInst).asDoubleArray();
+			// evaluator.addClassificationAttempt(trueClass, prediction, testInst
+			// .weight());
+			evaluator.addResult(testInst, prediction);
+			learner.trainOnInstance(trainInst);
+			instancesProcessed++;
+			if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0 || stream.hasMoreInstances() == false) {
+				long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+				double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);
+				double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);
+				double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); // GBs
+				RAMHoursIncrement *= (timeIncrement / 3600.0); // Hours
+				RAMHours += RAMHoursIncrement;
+				lastEvaluateStartTime = evaluateTime;
+				learningCurve
+						.insertEntry(
+								new LearningEvaluation(
+										new Measurement[] {
+												new Measurement("learning evaluation instances", instancesProcessed),
+												new Measurement("evaluation time (" + (preciseCPUTiming ? "cpu " : "")
+														+ "seconds)", time),
+												new Measurement("model cost (RAM-Hours)", RAMHours) },
+										evaluator, learner));
+				if (immediateResultStream != null) {
+					if (firstDump) {
+						immediateResultStream.print("Learner,stream,randomSeed,");
+						immediateResultStream.println(learningCurve.headerToString());
+						firstDump = false;
+					}
+					immediateResultStream.print(learnerString + "," + streamString + ","
+							+ this.randomSeedOption.getValueAsCLIString() + ",");
+					immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
+					immediateResultStream.flush();
+				}
+			}
+			if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
+				if (monitor.taskShouldAbort()) {
+					return null;
+				}
+				long estimatedRemainingInstances = stream.estimatedRemainingInstances();
+				if (maxInstances > 0) {
+					long maxRemaining = maxInstances - instancesProcessed;
+					if ((estimatedRemainingInstances < 0) || (maxRemaining < estimatedRemainingInstances)) {
+						estimatedRemainingInstances = maxRemaining;
+					}
+				}
+				monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
+						: (double) instancesProcessed / (double) (instancesProcessed + estimatedRemainingInstances));
+				if (monitor.resultPreviewRequested()) {
+					monitor.setLatestResultPreview(learningCurve.copy());
+				}
+				secondsElapsed = (int) TimingUtils
+						.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread() - evaluateStartTime);
+			}
+		}
+		if (immediateResultStream != null) {
+			immediateResultStream.close();
+		}
+		return learningCurve;
+	}
+
 }
diff --git a/moa/src/main/java/moa/tasks/AbstractEvaluateModel.java b/moa/src/main/java/moa/tasks/AbstractEvaluateModel.java
index 3c544bf70..d545e3d9e 100644
--- a/moa/src/main/java/moa/tasks/AbstractEvaluateModel.java
+++ b/moa/src/main/java/moa/tasks/AbstractEvaluateModel.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks;
 
@@ -29,16 +29,14 @@
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
 import moa.capabilities.CapabilitiesHandler;
-import moa.capabilities.Capability;
-import moa.capabilities.ImmutableCapabilities;
 import moa.core.Example;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
 import moa.core.Utils;
 import moa.evaluation.LearningEvaluation;
-import moa.evaluation.LearningPerformanceEvaluator;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
 import moa.evaluation.preview.LearningCurve;
-import moa.learners.InstanceLearner;
+import moa.learners.predictors.InstanceLearner;
 import moa.options.ClassOption;
 import moa.streams.ExampleStream;
 
@@ -48,126 +46,105 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public abstract class AbstractEvaluateModel<MLTask extends InstanceLearner> extends MainTask implements CapabilitiesHandler {
-
-    @Override
-    public String getPurposeString() {
-        return "Evaluates a static model on a stream.";
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    public ClassOption modelOption;
-
-    public ClassOption streamOption = new ClassOption("stream", 's',
-            "Stream to evaluate on.", ExampleStream.class,
-            "generators.RandomTreeGenerator");
-
-    public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
-            "Classification performance evaluation method.",
-            LearningPerformanceEvaluator.class,
-            "BasicClassificationPerformanceEvaluator");
-
-    public IntOption maxInstancesOption = new IntOption("maxInstances", 'i',
-            "Maximum number of instances to test.", 100000000, 0,
-            Integer.MAX_VALUE);
-    
-    public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
-            'f',
-            "How many instances between samples of the learning performance.",
-            100000, 0, Integer.MAX_VALUE);
-
-    public FileOption outputPredictionFileOption = new FileOption("outputPredictionFile", 'o',
-            "File to append output predictions to.", null, "pred", true);
-
-    @Override
-    public Class<?> getTaskResultType() {
-        return LearningEvaluation.class;
-    }
-
-    @Override
-    public Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
-        MLTask model = (MLTask) getPreparedClassOption(this.modelOption);
-        ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
-        LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
-        LearningCurve learningCurve = new LearningCurve("learning evaluation instances");
-        int maxInstances = this.maxInstancesOption.getValue();
-        long instancesProcessed = 0;
-        monitor.setCurrentActivity("Evaluating model...", -1.0);
-
-        //File for output predictions
-        File outputPredictionFile = this.outputPredictionFileOption.getFile();
-        PrintStream outputPredictionResultStream = null;
-        if (outputPredictionFile != null) {
-            try {
-                if (outputPredictionFile.exists()) {
-                    outputPredictionResultStream = new PrintStream(
-                            new FileOutputStream(outputPredictionFile, true), true);
-                } else {
-                    outputPredictionResultStream = new PrintStream(
-                            new FileOutputStream(outputPredictionFile), true);
-                }
-            } catch (Exception ex) {
-                throw new RuntimeException(
-                        "Unable to open prediction result file: " + outputPredictionFile, ex);
-            }
-        }
-        while (stream.hasMoreInstances()
-                && ((maxInstances < 0) || (instancesProcessed < maxInstances))) {
-            Example testInst = (Example) stream.nextInstance();//.copy();
-            int trueClass = (int) ((Instance) testInst.getData()).classValue();
-            //testInst.setClassMissing();
-            Prediction prediction = model.getPredictionForInstance(testInst);
-            //evaluator.addClassificationAttempt(trueClass, prediction, testInst
-            //		.weight());
-            if (outputPredictionFile != null) {
-                outputPredictionResultStream.println(Utils.maxIndex(prediction) + "," +(
-                        ((Instance) testInst.getData()).classIsMissing() == true ? " ? " : trueClass));
-            }
-            evaluator.addResult(testInst, prediction);
-            instancesProcessed++;
-
-            if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0
-                    || stream.hasMoreInstances() == false) {
-	            learningCurve.insertEntry(new LearningEvaluation(
-	                    new Measurement[]{
-	                        new Measurement(
-	                        "learning evaluation instances",
-	                        instancesProcessed)
-	                    },
-	                    evaluator, model));
-            }
-            if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
-                if (monitor.taskShouldAbort()) {
-                    return null;
-                }
-                long estimatedRemainingInstances = stream.estimatedRemainingInstances();
-                if (maxInstances > 0) {
-                    long maxRemaining = maxInstances - instancesProcessed;
-                    if ((estimatedRemainingInstances < 0)
-                            || (maxRemaining < estimatedRemainingInstances)) {
-                        estimatedRemainingInstances = maxRemaining;
-                    }
-                }
-                monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
-                        : (double) instancesProcessed
-                        / (double) (instancesProcessed + estimatedRemainingInstances));
-                if (monitor.resultPreviewRequested()) {
-                    monitor.setLatestResultPreview(learningCurve.copy());
-                }
-            }
-        }
-        if (outputPredictionResultStream != null) {
-            outputPredictionResultStream.close();
-        }
-        return learningCurve;
-    }
-
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == EvaluateModel.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
+public abstract class AbstractEvaluateModel<MLTask extends InstanceLearner> extends MainTask
+		implements CapabilitiesHandler {
+
+	@Override
+	public String getPurposeString() {
+		return "Evaluates a static model on a stream.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption modelOption;
+
+	public ClassOption streamOption = new ClassOption("stream", 's', "Stream to evaluate on.", ExampleStream.class,
+			"generators.RandomTreeGenerator");
+
+	public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
+			"Classification performance evaluation method.", LearningPerformanceEvaluator.class,
+			"BasicClassificationPerformanceEvaluator");
+
+	public IntOption maxInstancesOption = new IntOption("maxInstances", 'i', "Maximum number of instances to test.",
+			100000000, 0, Integer.MAX_VALUE);
+
+	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency", 'f',
+			"How many instances between samples of the learning performance.", 100000, 0, Integer.MAX_VALUE);
+
+	public FileOption outputPredictionFileOption = new FileOption("outputPredictionFile", 'o',
+			"File to append output predictions to.", null, "pred", true);
+
+	@Override
+	public Class<?> getTaskResultType() {
+		return LearningEvaluation.class;
+	}
+
+	@Override
+	public Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
+		MLTask model = (MLTask) getPreparedClassOption(this.modelOption);
+		ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
+		LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(
+				this.evaluatorOption);
+		LearningCurve learningCurve = new LearningCurve("learning evaluation instances");
+		int maxInstances = this.maxInstancesOption.getValue();
+		long instancesProcessed = 0;
+		monitor.setCurrentActivity("Evaluating model...", -1.0);
+
+		// File for output predictions
+		File outputPredictionFile = this.outputPredictionFileOption.getFile();
+		PrintStream outputPredictionResultStream = null;
+		if (outputPredictionFile != null) {
+			try {
+				if (outputPredictionFile.exists()) {
+					outputPredictionResultStream = new PrintStream(new FileOutputStream(outputPredictionFile, true),
+							true);
+				} else {
+					outputPredictionResultStream = new PrintStream(new FileOutputStream(outputPredictionFile), true);
+				}
+			} catch (Exception ex) {
+				throw new RuntimeException("Unable to open prediction result file: " + outputPredictionFile, ex);
+			}
+		}
+		while (stream.hasMoreInstances() && ((maxInstances < 0) || (instancesProcessed < maxInstances))) {
+			Example testInst = stream.nextInstance();// .copy();
+			int trueClass = (int) ((Instance) testInst.getData()).classValue();
+			// testInst.setClassMissing();
+			Prediction prediction = model.getPredictionForInstance(testInst);
+			// evaluator.addClassificationAttempt(trueClass, prediction, testInst
+			// .weight());
+			if (outputPredictionFile != null) {
+				outputPredictionResultStream.println(Utils.maxIndex(prediction) + ","
+						+ (((Instance) testInst.getData()).classIsMissing() == true ? " ? " : trueClass));
+			}
+			evaluator.addResult(testInst, prediction);
+			instancesProcessed++;
+
+			if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0 || stream.hasMoreInstances() == false) {
+				learningCurve.insertEntry(new LearningEvaluation(
+						new Measurement[] { new Measurement("learning evaluation instances", instancesProcessed) },
+						evaluator, model));
+			}
+			if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
+				if (monitor.taskShouldAbort()) {
+					return null;
+				}
+				long estimatedRemainingInstances = stream.estimatedRemainingInstances();
+				if (maxInstances > 0) {
+					long maxRemaining = maxInstances - instancesProcessed;
+					if ((estimatedRemainingInstances < 0) || (maxRemaining < estimatedRemainingInstances)) {
+						estimatedRemainingInstances = maxRemaining;
+					}
+				}
+				monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
+						: (double) instancesProcessed / (double) (instancesProcessed + estimatedRemainingInstances));
+				if (monitor.resultPreviewRequested()) {
+					monitor.setLatestResultPreview(learningCurve.copy());
+				}
+			}
+		}
+		if (outputPredictionResultStream != null) {
+			outputPredictionResultStream.close();
+		}
+		return learningCurve;
+	}
 }
diff --git a/moa/src/main/java/moa/tasks/AbstractEvaluatePrequential.java b/moa/src/main/java/moa/tasks/AbstractEvaluatePrequential.java
index c7519209c..59e50e835 100644
--- a/moa/src/main/java/moa/tasks/AbstractEvaluatePrequential.java
+++ b/moa/src/main/java/moa/tasks/AbstractEvaluatePrequential.java
@@ -16,7 +16,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks;
 
@@ -34,18 +34,19 @@
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
 import moa.core.TimingUtils;
-import moa.evaluation.EWMAClassificationPerformanceEvaluator;
-import moa.evaluation.FadingFactorClassificationPerformanceEvaluator;
 import moa.evaluation.LearningEvaluation;
-import moa.evaluation.LearningPerformanceEvaluator;
-import moa.evaluation.WindowClassificationPerformanceEvaluator;
+import moa.evaluation.evaluators.EWMAClassificationPerformanceEvaluator;
+import moa.evaluation.evaluators.FadingFactorClassificationPerformanceEvaluator;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
+import moa.evaluation.evaluators.WindowClassificationPerformanceEvaluator;
 import moa.evaluation.preview.LearningCurve;
-import moa.learners.InstanceLearner;
+import moa.learners.predictors.InstanceLearner;
 import moa.options.ClassOption;
 import moa.streams.ExampleStream;
 
 /**
- * Task for evaluating a classifier on a stream by testing then training with each example in sequence.
+ * Task for evaluating a classifier on a stream by testing then training with
+ * each example in sequence.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
@@ -62,43 +63,35 @@ public String getPurposeString() {
 
 	public ClassOption learnerOption;
 
-	public ClassOption streamOption = new ClassOption("stream", 's',
-			"Stream to learn from.", ExampleStream.class,
+	public ClassOption streamOption = new ClassOption("stream", 's', "Stream to learn from.", ExampleStream.class,
 			"generators.RandomTreeGenerator");
 
 	public ClassOption evaluatorOption;
 
 	public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
-			"Maximum number of instances to test/train on  (-1 = no limit).",
-			100000000, -1, Integer.MAX_VALUE);
+			"Maximum number of instances to test/train on  (-1 = no limit).", 100000000, -1, Integer.MAX_VALUE);
 
 	public IntOption timeLimitOption = new IntOption("timeLimit", 't',
-			"Maximum number of seconds to test/train for (-1 = no limit).", -1,
-			-1, Integer.MAX_VALUE);
+			"Maximum number of seconds to test/train for (-1 = no limit).", -1, -1, Integer.MAX_VALUE);
 
-	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
-			'f',
-			"How many instances between samples of the learning performance.",
-			100000, 0, Integer.MAX_VALUE);
+	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency", 'f',
+			"How many instances between samples of the learning performance.", 100000, 0, Integer.MAX_VALUE);
 
-	public IntOption memCheckFrequencyOption = new IntOption(
-			"memCheckFrequency", 'q',
-			"How many instances between memory bound checks.", 100000, 0,
-			Integer.MAX_VALUE);
+	public IntOption memCheckFrequencyOption = new IntOption("memCheckFrequency", 'q',
+			"How many instances between memory bound checks.", 100000, 0, Integer.MAX_VALUE);
 
-	public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
-			"File to append intermediate csv results to.", null, "csv", true);
+	public FileOption dumpFileOption = new FileOption("dumpFile", 'd', "File to append intermediate csv results to.",
+			null, "csv", true);
 
 	public FileOption outputPredictionFileOption = new FileOption("outputPredictionFile", 'o',
 			"File to append output predictions to.", null, "pred", true);
 
-	//New for prequential method DEPRECATED
-	public IntOption widthOption = new IntOption("width",
-			'w', "Size of Window", 1000);
+	// New for prequential method DEPRECATED
+	public IntOption widthOption = new IntOption("width", 'w', "Size of Window", 1000);
 
-	public FloatOption alphaOption = new FloatOption("alpha",
-			'a', "Fading factor or exponential smoothing factor", .01);
-	//End New for prequential methods
+	public FloatOption alphaOption = new FloatOption("alpha", 'a', "Fading factor or exponential smoothing factor",
+			.01);
+	// End New for prequential methods
 
 	@Override
 	public Class<?> getTaskResultType() {
@@ -110,33 +103,41 @@ public Class<?> getTaskResultType() {
 	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
 		MLTask learner = (MLTask) getPreparedClassOption(this.learnerOption);
 		ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
-		LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
-		LearningCurve learningCurve = new LearningCurve(
-				"learning evaluation instances");
+		LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(
+				this.evaluatorOption);
+		LearningCurve learningCurve = new LearningCurve("learning evaluation instances");
 
-		//New for prequential methods
+		// New for prequential methods
 		if (evaluator instanceof WindowClassificationPerformanceEvaluator) {
-			//((WindowClassificationPerformanceEvaluator) evaluator).setWindowWidth(widthOption.getValue());
+			// ((WindowClassificationPerformanceEvaluator)
+			// evaluator).setWindowWidth(widthOption.getValue());
 			if (widthOption.getValue() != 1000) {
-				System.out.println("DEPRECATED! Use EvaluatePrequential -e (WindowClassificationPerformanceEvaluator -w " + widthOption.getValue() + ")");
+				System.out
+						.println("DEPRECATED! Use EvaluatePrequential -e (WindowClassificationPerformanceEvaluator -w "
+								+ widthOption.getValue() + ")");
 				return learningCurve;
 			}
 		}
 		if (evaluator instanceof EWMAClassificationPerformanceEvaluator) {
-			//((EWMAClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
+			// ((EWMAClassificationPerformanceEvaluator)
+			// evaluator).setalpha(alphaOption.getValue());
 			if (alphaOption.getValue() != .01) {
-				System.out.println("DEPRECATED! Use EvaluatePrequential -e (EWMAClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
+				System.out.println("DEPRECATED! Use EvaluatePrequential -e (EWMAClassificationPerformanceEvaluator -a "
+						+ alphaOption.getValue() + ")");
 				return learningCurve;
 			}
 		}
 		if (evaluator instanceof FadingFactorClassificationPerformanceEvaluator) {
-			//((FadingFactorClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
+			// ((FadingFactorClassificationPerformanceEvaluator)
+			// evaluator).setalpha(alphaOption.getValue());
 			if (alphaOption.getValue() != .01) {
-				System.out.println("DEPRECATED! Use EvaluatePrequential -e (FadingFactorClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
+				System.out.println(
+						"DEPRECATED! Use EvaluatePrequential -e (FadingFactorClassificationPerformanceEvaluator -a "
+								+ alphaOption.getValue() + ")");
 				return learningCurve;
 			}
 		}
-		//End New for prequential methods
+		// End New for prequential methods
 
 		learner.setModelContext(stream.getHeader());
 		int maxInstances = this.instanceLimitOption.getValue();
@@ -150,32 +151,27 @@ protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
 		if (dumpFile != null) {
 			try {
 				if (dumpFile.exists()) {
-					immediateResultStream = new PrintStream(
-							new FileOutputStream(dumpFile, true), true);
+					immediateResultStream = new PrintStream(new FileOutputStream(dumpFile, true), true);
 				} else {
-					immediateResultStream = new PrintStream(
-							new FileOutputStream(dumpFile), true);
+					immediateResultStream = new PrintStream(new FileOutputStream(dumpFile), true);
 				}
 			} catch (Exception ex) {
-				throw new RuntimeException(
-						"Unable to open immediate result file: " + dumpFile, ex);
+				throw new RuntimeException("Unable to open immediate result file: " + dumpFile, ex);
 			}
 		}
-		//File for output predictions
+		// File for output predictions
 		File outputPredictionFile = this.outputPredictionFileOption.getFile();
 		PrintStream outputPredictionResultStream = null;
 		if (outputPredictionFile != null) {
 			try {
 				if (outputPredictionFile.exists()) {
-					outputPredictionResultStream = new PrintStream(
-							new FileOutputStream(outputPredictionFile, true), true);
+					outputPredictionResultStream = new PrintStream(new FileOutputStream(outputPredictionFile, true),
+							true);
 				} else {
-					outputPredictionResultStream = new PrintStream(
-							new FileOutputStream(outputPredictionFile), true);
+					outputPredictionResultStream = new PrintStream(new FileOutputStream(outputPredictionFile), true);
 				}
 			} catch (Exception ex) {
-				throw new RuntimeException(
-						"Unable to open prediction result file: " + outputPredictionFile, ex);
+				throw new RuntimeException("Unable to open prediction result file: " + outputPredictionFile, ex);
 			}
 		}
 		boolean firstDump = true;
@@ -183,44 +179,37 @@ protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
 		long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
 		long lastEvaluateStartTime = evaluateStartTime;
 		double RAMHours = 0.0;
-		while (stream.hasMoreInstances()
-				&& ((maxInstances < 0) || (instancesProcessed < maxInstances))
+		while (stream.hasMoreInstances() && ((maxInstances < 0) || (instancesProcessed < maxInstances))
 				&& ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
 			Example trainInst = stream.nextInstance();
-			Example testInst = (Example) trainInst; //.copy();
-			//testInst.setClassMissing();
+			Example testInst = trainInst; // .copy();
+			// testInst.setClassMissing();
 			Prediction prediction = learner.getPredictionForInstance(testInst);
 			// Output prediction
 			if (outputPredictionFile != null) {
 				this.printPrediction(outputPredictionResultStream, (Instance) testInst.getData(), prediction);
 			}
-			//evaluator.addClassificationAttempt(trueClass, prediction, testInst.weight());
+			// evaluator.addClassificationAttempt(trueClass, prediction, testInst.weight());
 			evaluator.addResult(testInst, prediction);
 			learner.trainOnInstance(trainInst);
 			instancesProcessed++;
-			if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0
-					|| stream.hasMoreInstances() == false) {
+			if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0 || stream.hasMoreInstances() == false) {
 				long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
 				double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);
 				double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);
-				double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); //GBs
-				RAMHoursIncrement *= (timeIncrement / 3600.0); //Hours
+				double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); // GBs
+				RAMHoursIncrement *= (timeIncrement / 3600.0); // Hours
 				RAMHours += RAMHoursIncrement;
 				lastEvaluateStartTime = evaluateTime;
-				learningCurve.insertEntry(new LearningEvaluation(
-						new Measurement[]{
-								new Measurement(
-										"learning evaluation instances",
-										instancesProcessed),
-								new Measurement(
-										"evaluation time ("
-												+ (preciseCPUTiming ? "cpu " : "") + "seconds)",
-												time),
-								new Measurement(
-										"model cost (RAM-Hours)",
-										RAMHours)
-						},
-						evaluator, learner));
+				learningCurve
+						.insertEntry(
+								new LearningEvaluation(
+										new Measurement[] {
+												new Measurement("learning evaluation instances", instancesProcessed),
+												new Measurement("evaluation time (" + (preciseCPUTiming ? "cpu " : "")
+														+ "seconds)", time),
+												new Measurement("model cost (RAM-Hours)", RAMHours) },
+										evaluator, learner));
 
 				if (immediateResultStream != null) {
 					if (firstDump) {
@@ -238,19 +227,17 @@ protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
 				long estimatedRemainingInstances = stream.estimatedRemainingInstances();
 				if (maxInstances > 0) {
 					long maxRemaining = maxInstances - instancesProcessed;
-					if ((estimatedRemainingInstances < 0)
-							|| (maxRemaining < estimatedRemainingInstances)) {
+					if ((estimatedRemainingInstances < 0) || (maxRemaining < estimatedRemainingInstances)) {
 						estimatedRemainingInstances = maxRemaining;
 					}
 				}
 				monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
-						: (double) instancesProcessed
-						/ (double) (instancesProcessed + estimatedRemainingInstances));
+						: (double) instancesProcessed / (double) (instancesProcessed + estimatedRemainingInstances));
 				if (monitor.resultPreviewRequested()) {
 					monitor.setLatestResultPreview(learningCurve.copy());
 				}
-				secondsElapsed = (int) TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread()
-						- evaluateStartTime);
+				secondsElapsed = (int) TimingUtils
+						.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread() - evaluateStartTime);
 			}
 		}
 		if (immediateResultStream != null) {
diff --git a/moa/src/main/java/moa/tasks/AbstractEvaluatePrequentialCV.java b/moa/src/main/java/moa/tasks/AbstractEvaluatePrequentialCV.java
index f83fde442..da4bec4c3 100644
--- a/moa/src/main/java/moa/tasks/AbstractEvaluatePrequentialCV.java
+++ b/moa/src/main/java/moa/tasks/AbstractEvaluatePrequentialCV.java
@@ -16,7 +16,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks;
 
@@ -39,18 +39,22 @@
 import moa.core.ObjectRepository;
 import moa.core.TimingUtils;
 import moa.evaluation.LearningEvaluation;
-import moa.evaluation.LearningPerformanceEvaluator;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
 import moa.evaluation.preview.LearningCurve;
-import moa.learners.InstanceLearner;
+import moa.learners.predictors.InstanceLearner;
 import moa.options.ClassOption;
 import moa.streams.ExampleStream;
 
 /**
- * Task for prequential cross-validation evaluation of a classifier on a stream by testing then training with each
- * example in sequence and doing cross-validation at the same time.
+ * Task for prequential cross-validation evaluation of a classifier on a stream
+ * by testing then training with each example in sequence and doing
+ * cross-validation at the same time.
  *
- * <p>Albert Bifet, Gianmarco De Francisci Morales, Jesse Read, Geoff Holmes, Bernhard Pfahringer: Efficient Online
- * Evaluation of Big Data Stream Classifiers. KDD 2015: 59-68</p>
+ * <p>
+ * Albert Bifet, Gianmarco De Francisci Morales, Jesse Read, Geoff Holmes,
+ * Bernhard Pfahringer: Efficient Online Evaluation of Big Data Stream
+ * Classifiers. KDD 2015: 59-68
+ * </p>
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
@@ -58,78 +62,68 @@
  */
 public abstract class AbstractEvaluatePrequentialCV<MLTask extends InstanceLearner> extends MainTask {
 
-
 	private static final long serialVersionUID = 1L;
 
 	public ClassOption learnerOption;
 
-	public ClassOption streamOption = new ClassOption("stream", 's',
-			"Stream to learn from.", ExampleStream.class,
+	public ClassOption streamOption = new ClassOption("stream", 's', "Stream to learn from.", ExampleStream.class,
 			"generators.RandomTreeGenerator");
 
 	public ClassOption evaluatorOption;
 
 	public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
-			"Maximum number of instances to test/train on  (-1 = no limit).",
-			100000000, -1, Integer.MAX_VALUE);
+			"Maximum number of instances to test/train on  (-1 = no limit).", 100000000, -1, Integer.MAX_VALUE);
 
 	public IntOption timeLimitOption = new IntOption("timeLimit", 't',
-			"Maximum number of seconds to test/train for (-1 = no limit).", -1,
-			-1, Integer.MAX_VALUE);
+			"Maximum number of seconds to test/train for (-1 = no limit).", -1, -1, Integer.MAX_VALUE);
 
-	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
-			'f',
-			"How many instances between samples of the learning performance.",
-			100000, 0, Integer.MAX_VALUE);
+	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency", 'f',
+			"How many instances between samples of the learning performance.", 100000, 0, Integer.MAX_VALUE);
 
-	public IntOption memCheckFrequencyOption = new IntOption(
-			"memCheckFrequency", 'q',
-			"How many instances between memory bound checks.", 100000, 0,
-			Integer.MAX_VALUE);
+	public IntOption memCheckFrequencyOption = new IntOption("memCheckFrequency", 'q',
+			"How many instances between memory bound checks.", 100000, 0, Integer.MAX_VALUE);
 
-	public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
-			"File to append intermediate csv results to.", null, "csv", true);
+	public FileOption dumpFileOption = new FileOption("dumpFile", 'd', "File to append intermediate csv results to.",
+			null, "csv", true);
 
 	public IntOption numFoldsOption = new IntOption("numFolds", 'w',
 			"The number of folds (e.g. distributed models) to be used.", 10, 1, Integer.MAX_VALUE);
 
-	public MultiChoiceOption validationMethodologyOption = new MultiChoiceOption(
-			"validationMethodology", 'a', "Validation methodology to use.", new String[]{
-					"Cross-Validation", "Bootstrap-Validation", "Split-Validation"},
-			new String[]{"k-fold distributed Cross Validation",
-					"k-fold distributed Bootstrap Validation",
-					"k-fold distributed Split Validation"
-			}, 0);
-
-	public IntOption randomSeedOption = new IntOption("randomSeed", 'r',
-			"Seed for random behaviour of the task.", 1);
+	public MultiChoiceOption validationMethodologyOption = new MultiChoiceOption("validationMethodology", 'a',
+			"Validation methodology to use.",
+			new String[] { "Cross-Validation", "Bootstrap-Validation", "Split-Validation" },
+			new String[] { "k-fold distributed Cross Validation", "k-fold distributed Bootstrap Validation",
+					"k-fold distributed Split Validation" },
+			0);
 
+	public IntOption randomSeedOption = new IntOption("randomSeed", 'r', "Seed for random behaviour of the task.", 1);
 
 	@Override
 	public Class<?> getTaskResultType() {
 		return LearningCurve.class;
 	}
 
+	@Override
 	@SuppressWarnings("rawtypes")
 	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
 
 		Random random = new Random(this.randomSeedOption.getValue());
 		ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
 
-		ArrayList<MLTask> learners = new ArrayList<MLTask>(this.numFoldsOption.getValue());
+		ArrayList<MLTask> learners = new ArrayList<>(this.numFoldsOption.getValue());
 		MLTask baseLearner = (MLTask) getPreparedClassOption(this.learnerOption);
 		baseLearner.resetLearning();
 
 		LearningPerformanceEvaluator[] evaluators = new LearningPerformanceEvaluator[this.numFoldsOption.getValue()];
-		LearningPerformanceEvaluator baseEvaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
+		LearningPerformanceEvaluator baseEvaluator = (LearningPerformanceEvaluator) getPreparedClassOption(
+				this.evaluatorOption);
 		for (int i = 0; i < learners.size(); i++) {
 			learners.set(i, (MLTask) baseLearner.copy());
 			learners.get(i).setModelContext(stream.getHeader());
 			evaluators[i] = (LearningPerformanceEvaluator) baseEvaluator.copy();
 		}
 
-		LearningCurve learningCurve = new LearningCurve(
-				"learning evaluation instances");
+		LearningCurve learningCurve = new LearningCurve("learning evaluation instances");
 		int maxInstances = this.instanceLimitOption.getValue();
 		long instancesProcessed = 0;
 		int maxSeconds = this.timeLimitOption.getValue();
@@ -141,15 +135,12 @@ protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
 		if (dumpFile != null) {
 			try {
 				if (dumpFile.exists()) {
-					immediateResultStream = new PrintStream(
-							new FileOutputStream(dumpFile, true), true);
+					immediateResultStream = new PrintStream(new FileOutputStream(dumpFile, true), true);
 				} else {
-					immediateResultStream = new PrintStream(
-							new FileOutputStream(dumpFile), true);
+					immediateResultStream = new PrintStream(new FileOutputStream(dumpFile), true);
 				}
 			} catch (Exception ex) {
-				throw new RuntimeException(
-						"Unable to open immediate result file: " + dumpFile, ex);
+				throw new RuntimeException("Unable to open immediate result file: " + dumpFile, ex);
 			}
 		}
 
@@ -158,12 +149,11 @@ protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
 		long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
 		long lastEvaluateStartTime = evaluateStartTime;
 		double RAMHours = 0.0;
-		while (stream.hasMoreInstances()
-				&& ((maxInstances < 0) || (instancesProcessed < maxInstances))
+		while (stream.hasMoreInstances() && ((maxInstances < 0) || (instancesProcessed < maxInstances))
 				&& ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
 			Example trainInst = stream.nextInstance();
-			Example testInst = (Example) trainInst; //.copy();
-			//testInst.setClassMissing();
+			Example testInst = trainInst; // .copy();
+			// testInst.setClassMissing();
 
 			for (int i = 0; i < learners.size(); i++) {
 				evaluators[i].addResult(testInst, learners.get(i).getPredictionForInstance(testInst));
@@ -172,51 +162,45 @@ protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
 			for (int i = 0; i < learners.size(); i++) {
 				int k = 1;
 				switch (this.validationMethodologyOption.getChosenIndex()) {
-				case 0: //Cross-Validation;
-					k = instancesProcessed % learners.size() == i ? 0: 1; //Test all except one
+				case 0: // Cross-Validation;
+					k = instancesProcessed % learners.size() == i ? 0 : 1; // Test all except one
 					break;
-				case 1: //Bootstrap;
+				case 1: // Bootstrap;
 					k = MiscUtils.poisson(1, random);
 					break;
-				case 2: //Split-Validation;
-					k = instancesProcessed % learners.size() == i ? 1: 0; //Test only one
+				case 2: // Split-Validation;
+					k = instancesProcessed % learners.size() == i ? 1 : 0; // Test only one
 					break;
 				}
 				if (k > 0) {
-					Example weightedInst = (Example) trainInst.copy();
+					Example weightedInst = trainInst.copy();
 					weightedInst.setWeight(trainInst.weight() * k);
 					learners.get(i).trainOnInstance(weightedInst);
 				}
 			}
 
 			instancesProcessed++;
-			if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0
-					|| stream.hasMoreInstances() == false) {
+			if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0 || stream.hasMoreInstances() == false) {
 				long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
 				double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);
 				double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);
 
 				for (int i = 0; i < learners.size(); i++) {
-					double RAMHoursIncrement = learners.get(i).measureByteSize() / (1024.0 * 1024.0 * 1024.0); //GBs
-					RAMHoursIncrement *= (timeIncrement / 3600.0); //Hours
+					double RAMHoursIncrement = learners.get(i).measureByteSize() / (1024.0 * 1024.0 * 1024.0); // GBs
+					RAMHoursIncrement *= (timeIncrement / 3600.0); // Hours
 					RAMHours += RAMHoursIncrement;
 				}
 
 				lastEvaluateStartTime = evaluateTime;
-				learningCurve.insertEntry(new LearningEvaluation(
-						getEvaluationMeasurements(
-								new Measurement[]{
+				learningCurve
+						.insertEntry(new LearningEvaluation(getEvaluationMeasurements(
+								new Measurement[] {
+										new Measurement("learning evaluation instances", instancesProcessed),
 										new Measurement(
-												"learning evaluation instances",
-												instancesProcessed),
-										new Measurement(
-												"evaluation time ("
-														+ (preciseCPUTiming ? "cpu " : "") + "seconds)",
-														time),
-										new Measurement(
-												"model cost (RAM-Hours)",
-												RAMHours)
-								}, evaluators)));
+												"evaluation time (" + (preciseCPUTiming ? "cpu " : "") + "seconds)",
+												time),
+										new Measurement("model cost (RAM-Hours)", RAMHours) },
+								evaluators)));
 
 				if (immediateResultStream != null) {
 					if (firstDump) {
@@ -234,19 +218,17 @@ protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
 				long estimatedRemainingInstances = stream.estimatedRemainingInstances();
 				if (maxInstances > 0) {
 					long maxRemaining = maxInstances - instancesProcessed;
-					if ((estimatedRemainingInstances < 0)
-							|| (maxRemaining < estimatedRemainingInstances)) {
+					if ((estimatedRemainingInstances < 0) || (maxRemaining < estimatedRemainingInstances)) {
 						estimatedRemainingInstances = maxRemaining;
 					}
 				}
 				monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
-						: (double) instancesProcessed
-						/ (double) (instancesProcessed + estimatedRemainingInstances));
+						: (double) instancesProcessed / (double) (instancesProcessed + estimatedRemainingInstances));
 				if (monitor.resultPreviewRequested()) {
 					monitor.setLatestResultPreview(learningCurve.copy());
 				}
-				secondsElapsed = (int) TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread()
-						- evaluateStartTime);
+				secondsElapsed = (int) TimingUtils
+						.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread() - evaluateStartTime);
 			}
 		}
 		if (immediateResultStream != null) {
@@ -255,21 +237,22 @@ protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
 		return learningCurve;
 	}
 
-
-	public Measurement[] getEvaluationMeasurements(Measurement[] modelMeasurements, LearningPerformanceEvaluator[] subEvaluators) {
-		List<Measurement> measurementList = new LinkedList<Measurement>();
+	public Measurement[] getEvaluationMeasurements(Measurement[] modelMeasurements,
+			LearningPerformanceEvaluator[] subEvaluators) {
+		List<Measurement> measurementList = new LinkedList<>();
 		if (modelMeasurements != null) {
 			measurementList.addAll(Arrays.asList(modelMeasurements));
 		}
 		// add average of sub-model measurements
 		if ((subEvaluators != null) && (subEvaluators.length > 0)) {
-			List<Measurement[]> subMeasurements = new LinkedList<Measurement[]>();
+			List<Measurement[]> subMeasurements = new LinkedList<>();
 			for (LearningPerformanceEvaluator subEvaluator : subEvaluators) {
 				if (subEvaluator != null) {
 					subMeasurements.add(subEvaluator.getPerformanceMeasurements());
 				}
 			}
-			Measurement[] avgMeasurements = Measurement.averageMeasurements(subMeasurements.toArray(new Measurement[subMeasurements.size()][]));
+			Measurement[] avgMeasurements = Measurement
+					.averageMeasurements(subMeasurements.toArray(new Measurement[subMeasurements.size()][]));
 			measurementList.addAll(Arrays.asList(avgMeasurements));
 		}
 		return measurementList.toArray(new Measurement[measurementList.size()]);
diff --git a/moa/src/main/java/moa/tasks/AbstractLearnModel.java b/moa/src/main/java/moa/tasks/AbstractLearnModel.java
index 19e8bc953..60aed544e 100644
--- a/moa/src/main/java/moa/tasks/AbstractLearnModel.java
+++ b/moa/src/main/java/moa/tasks/AbstractLearnModel.java
@@ -15,19 +15,16 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks;
 
 import com.github.javacliparser.IntOption;
 
 import moa.capabilities.CapabilitiesHandler;
-import moa.capabilities.Capability;
-import moa.capabilities.ImmutableCapabilities;
 import moa.core.ObjectRepository;
-import moa.learners.Classifier;
-import moa.learners.InstanceLearner;
-import moa.learners.MLTask;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.InstanceLearner;
 import moa.options.ClassOption;
 import moa.streams.ExampleStream;
 import moa.streams.InstanceStream;
@@ -38,99 +35,83 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public abstract class AbstractLearnModel<MLTask extends InstanceLearner> extends MainTask implements CapabilitiesHandler {
-
-    @Override
-    public String getPurposeString() {
-        return "Learns a model from a stream.";
-    }
+public abstract class AbstractLearnModel<MLTask extends InstanceLearner> extends MainTask
+		implements CapabilitiesHandler {
 
-    private static final long serialVersionUID = 1L;
+	@Override
+	public String getPurposeString() {
+		return "Learns a model from a stream.";
+	}
 
-    public ClassOption learnerOption;
+	private static final long serialVersionUID = 1L;
 
-    public ClassOption streamOption = new ClassOption("stream", 's',
-            "Stream to learn from.", ExampleStream.class,
-            "generators.RandomTreeGenerator");
+	public ClassOption learnerOption;
 
-    public IntOption maxInstancesOption = new IntOption("maxInstances", 'm',
-            "Maximum number of instances to train on per pass over the data.",
-            10000000, 0, Integer.MAX_VALUE);
+	public ClassOption streamOption = new ClassOption("stream", 's', "Stream to learn from.", ExampleStream.class,
+			"generators.RandomTreeGenerator");
 
-    public IntOption numPassesOption = new IntOption("numPasses", 'p',
-            "The number of passes to do over the data.", 1, 1,
-            Integer.MAX_VALUE);
+	public IntOption maxInstancesOption = new IntOption("maxInstances", 'm',
+			"Maximum number of instances to train on per pass over the data.", 10000000, 0, Integer.MAX_VALUE);
 
-    public IntOption memCheckFrequencyOption = new IntOption(
-            "memCheckFrequency", 'q',
-            "How many instances between memory bound checks.", 100000, 0,
-            Integer.MAX_VALUE);
+	public IntOption numPassesOption = new IntOption("numPasses", 'p', "The number of passes to do over the data.", 1,
+			1, Integer.MAX_VALUE);
 
-    public AbstractLearnModel() {
-    }
+	public IntOption memCheckFrequencyOption = new IntOption("memCheckFrequency", 'q',
+			"How many instances between memory bound checks.", 100000, 0, Integer.MAX_VALUE);
 
-    public AbstractLearnModel(MLTask learner, InstanceStream stream,
-            int maxInstances, int numPasses) {
-        this.learnerOption.setCurrentObject(learner);
-        this.streamOption.setCurrentObject(stream);
-        this.maxInstancesOption.setValue(maxInstances);
-        this.numPassesOption.setValue(numPasses);
-    }
+	public AbstractLearnModel() {
+	}
 
-    @Override
-    public Class<?> getTaskResultType() {
-        return Classifier.class;
-    }
+	public AbstractLearnModel(MLTask learner, InstanceStream stream, int maxInstances, int numPasses) {
+		this.learnerOption.setCurrentObject(learner);
+		this.streamOption.setCurrentObject(stream);
+		this.maxInstancesOption.setValue(maxInstances);
+		this.numPassesOption.setValue(numPasses);
+	}
 
-    @Override
-    public Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
-        MLTask learner = (MLTask) getPreparedClassOption(this.learnerOption);
-        ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
-        learner.setModelContext(stream.getHeader());
-        int numPasses = this.numPassesOption.getValue();
-        int maxInstances = this.maxInstancesOption.getValue();
-        for (int pass = 0; pass < numPasses; pass++) {
-            long instancesProcessed = 0;
-            monitor.setCurrentActivity("Training learner"
-                    + (numPasses > 1 ? (" (pass " + (pass + 1) + "/"
-                    + numPasses + ")") : "") + "...", -1.0);
-            if (pass > 0) {
-                stream.restart();
-            }
-            while (stream.hasMoreInstances()
-                    && ((maxInstances < 0) || (instancesProcessed < maxInstances))) {
-                learner.trainOnInstance(stream.nextInstance());
-                instancesProcessed++;
-                if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
-                    if (monitor.taskShouldAbort()) {
-                        return null;
-                    }
-                    long estimatedRemainingInstances = stream.estimatedRemainingInstances();
-                    if (maxInstances > 0) {
-                        long maxRemaining = maxInstances - instancesProcessed;
-                        if ((estimatedRemainingInstances < 0)
-                                || (maxRemaining < estimatedRemainingInstances)) {
-                            estimatedRemainingInstances = maxRemaining;
-                        }
-                    }
-                    monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
-                            : (double) instancesProcessed
-                            / (double) (instancesProcessed + estimatedRemainingInstances));
-                    if (monitor.resultPreviewRequested()) {
-                        monitor.setLatestResultPreview(learner.copy());
-                    }
-                }
-            }
-        }
-        learner.setModelContext(stream.getHeader());
-        return learner;
-    }
+	@Override
+	public Class<?> getTaskResultType() {
+		return Classifier.class;
+	}
 
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == LearnModel.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
+	@Override
+	public Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
+		MLTask learner = (MLTask) getPreparedClassOption(this.learnerOption);
+		ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
+		learner.setModelContext(stream.getHeader());
+		int numPasses = this.numPassesOption.getValue();
+		int maxInstances = this.maxInstancesOption.getValue();
+		for (int pass = 0; pass < numPasses; pass++) {
+			long instancesProcessed = 0;
+			monitor.setCurrentActivity("Training learner"
+					+ (numPasses > 1 ? (" (pass " + (pass + 1) + "/" + numPasses + ")") : "") + "...", -1.0);
+			if (pass > 0) {
+				stream.restart();
+			}
+			while (stream.hasMoreInstances() && ((maxInstances < 0) || (instancesProcessed < maxInstances))) {
+				learner.trainOnInstance(stream.nextInstance());
+				instancesProcessed++;
+				if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
+					if (monitor.taskShouldAbort()) {
+						return null;
+					}
+					long estimatedRemainingInstances = stream.estimatedRemainingInstances();
+					if (maxInstances > 0) {
+						long maxRemaining = maxInstances - instancesProcessed;
+						if ((estimatedRemainingInstances < 0) || (maxRemaining < estimatedRemainingInstances)) {
+							estimatedRemainingInstances = maxRemaining;
+						}
+					}
+					monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
+							: (double) instancesProcessed
+									/ (double) (instancesProcessed + estimatedRemainingInstances));
+					if (monitor.resultPreviewRequested()) {
+						monitor.setLatestResultPreview(learner.copy());
+					}
+				}
+			}
+		}
+		learner.setModelContext(stream.getHeader());
+		return learner;
+	}
 }
diff --git a/moa/src/main/java/moa/tasks/AbstractTask.java b/moa/src/main/java/moa/tasks/AbstractTask.java
index 330408405..ea601c531 100644
--- a/moa/src/main/java/moa/tasks/AbstractTask.java
+++ b/moa/src/main/java/moa/tasks/AbstractTask.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks;
 
@@ -33,54 +33,51 @@ public abstract class AbstractTask extends AbstractOptionHandler implements Task
 	private static final long serialVersionUID = 1L;
 
 	/**
-     * Gets the name of this task.
-     *
-     * @return the name of this task
-     */
-    public String getTaskName() {
-        return this.getClass().getSimpleName();
-    }
+	 * Gets the name of this task.
+	 *
+	 * @return the name of this task
+	 */
+	public String getTaskName() {
+		return this.getClass().getSimpleName();
+	}
 
-    @Override
-    public Object doTask() {
-        return doTask(new NullMonitor(), null);
-    }
+	@Override
+	public Object doTask() {
+		return doTask(new NullMonitor(), null);
+	}
 
-    @Override
-    public Object doTask(TaskMonitor monitor, ObjectRepository repository) {
-        monitor.setCurrentActivity("Preparing options to " + getTaskName()
-                + "...", -1.0);
-        prepareClassOptions(monitor, repository);
-        if (monitor.taskShouldAbort()) {
-            return null;
-        }
-        monitor.setCurrentActivity("Doing task " + getTaskName() + "...", -1.0);
-        Object result = doTaskImpl(monitor, repository);
-        monitor.setCurrentActivity("Task " + getTaskName() + " complete.", 1.0);
-        //this.classOptionNamesToPreparedObjects = null; // clean up refs
-        return result;
-    }
+	@Override
+	public Object doTask(TaskMonitor monitor, ObjectRepository repository) {
+		monitor.setCurrentActivity("Preparing options to " + getTaskName() + "...", -1.0);
+		prepareClassOptions(monitor, repository);
+		if (monitor.taskShouldAbort()) {
+			return null;
+		}
+		monitor.setCurrentActivity("Doing task " + getTaskName() + "...", -1.0);
+		Object result = doTaskImpl(monitor, repository);
+		monitor.setCurrentActivity("Task " + getTaskName() + " complete.", 1.0);
+		// this.classOptionNamesToPreparedObjects = null; // clean up refs
+		return result;
+	}
 
-    /**
-     * This method performs this task.
-     * <code>AbstractTask</code> implements <code>doTask</code> so all
-     * its extensions only need to implement <code>doTaskImpl</code>.
-     *
-     * @param monitor the TaskMonitor to use
-     * @param repository  the ObjectRepository to use
-     * @return an object with the result of this task
-     */
-    protected abstract Object doTaskImpl(TaskMonitor monitor,
-            ObjectRepository repository);
+	/**
+	 * This method performs this task. <code>AbstractTask</code> implements
+	 * <code>doTask</code> so all its extensions only need to implement
+	 * <code>doTaskImpl</code>.
+	 *
+	 * @param monitor    the TaskMonitor to use
+	 * @param repository the ObjectRepository to use
+	 * @return an object with the result of this task
+	 */
+	protected abstract Object doTaskImpl(TaskMonitor monitor, ObjectRepository repository);
 
-    @Override
-    protected void prepareForUseImpl(TaskMonitor monitor,
-            ObjectRepository repository) {
-        // tasks prepare themselves upon running
-    }
+	@Override
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
+		// tasks prepare themselves upon running
+	}
 
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        // TODO Auto-generated method stub
-    }
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		// TODO Auto-generated method stub
+	}
 }
diff --git a/moa/src/main/java/moa/tasks/CacheShuffledStream.java b/moa/src/main/java/moa/tasks/CacheShuffledStream.java
index 91cf2194f..7b181ee6b 100644
--- a/moa/src/main/java/moa/tasks/CacheShuffledStream.java
+++ b/moa/src/main/java/moa/tasks/CacheShuffledStream.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks;
 
@@ -37,56 +37,50 @@
  */
 public class CacheShuffledStream extends AbstractTask {
 
-    @Override
-    public String getPurposeString() {
-        return "Stores and shuffles examples in memory.";
-    }
+	@Override
+	public String getPurposeString() {
+		return "Stores and shuffles examples in memory.";
+	}
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public ClassOption streamOption = new ClassOption("stream", 's',
-            "Stream to cache and shuffle.", InstanceStream.class,
-            "generators.RandomTreeGenerator");
+	public ClassOption streamOption = new ClassOption("stream", 's', "Stream to cache and shuffle.",
+			InstanceStream.class, "generators.RandomTreeGenerator");
 
-    public IntOption maximumCacheSizeOption = new IntOption("maximumCacheSize",
-            'm', "Maximum number of instances to cache.", 1000000, 1,
-            Integer.MAX_VALUE);
+	public IntOption maximumCacheSizeOption = new IntOption("maximumCacheSize", 'm',
+			"Maximum number of instances to cache.", 1000000, 1, Integer.MAX_VALUE);
 
-    public IntOption shuffleRandomSeedOption = new IntOption(
-            "shuffleRandomSeed", 'r',
-            "Seed for random shuffling of instances.", 1);
+	public IntOption shuffleRandomSeedOption = new IntOption("shuffleRandomSeed", 'r',
+			"Seed for random shuffling of instances.", 1);
 
-    @Override
-    protected Object doTaskImpl(TaskMonitor monitor, ObjectRepository repository) {
-        InstanceStream stream = (InstanceStream) getPreparedClassOption(this.streamOption);
-        InstancesHeader cache = new InstancesHeader(stream.getHeader(), 0);
-        monitor.setCurrentActivity("Caching instances...", -1.0);
-        while ((cache.numInstances() < this.maximumCacheSizeOption.getValue())
-                && stream.hasMoreInstances()) {
-            cache.add(stream.nextInstance().getData());
-            if (cache.numInstances()
-                    % MainTask.INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
-                if (monitor.taskShouldAbort()) {
-                    return null;
-                }
-                long estimatedRemainingInstances = stream.estimatedRemainingInstances();
-                long maxRemaining = this.maximumCacheSizeOption.getValue()
-                        - cache.numInstances();
-                if ((estimatedRemainingInstances < 0)
-                        || (maxRemaining < estimatedRemainingInstances)) {
-                    estimatedRemainingInstances = maxRemaining;
-                }
-                monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
-                        : (double) cache.numInstances()
-                        / (double) (cache.numInstances() + estimatedRemainingInstances));
-            }
-        }
-        monitor.setCurrentActivity("Shuffling instances...", -1.0);
-        cache.randomize(new Random(this.shuffleRandomSeedOption.getValue()));
-        return new CachedInstancesStream(cache);
-    }
+	@Override
+	protected Object doTaskImpl(TaskMonitor monitor, ObjectRepository repository) {
+		InstanceStream stream = (InstanceStream) getPreparedClassOption(this.streamOption);
+		InstancesHeader cache = new InstancesHeader(stream.getHeader(), 0);
+		monitor.setCurrentActivity("Caching instances...", -1.0);
+		while ((cache.numInstances() < this.maximumCacheSizeOption.getValue()) && stream.hasMoreInstances()) {
+			cache.add(stream.nextInstance().getData());
+			if (cache.numInstances() % MainTask.INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
+				if (monitor.taskShouldAbort()) {
+					return null;
+				}
+				long estimatedRemainingInstances = stream.estimatedRemainingInstances();
+				long maxRemaining = this.maximumCacheSizeOption.getValue() - cache.numInstances();
+				if ((estimatedRemainingInstances < 0) || (maxRemaining < estimatedRemainingInstances)) {
+					estimatedRemainingInstances = maxRemaining;
+				}
+				monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
+						: (double) cache.numInstances()
+								/ (double) (cache.numInstances() + estimatedRemainingInstances));
+			}
+		}
+		monitor.setCurrentActivity("Shuffling instances...", -1.0);
+		cache.randomize(new Random(this.shuffleRandomSeedOption.getValue()));
+		return new CachedInstancesStream(cache);
+	}
 
-    public Class<?> getTaskResultType() {
-        return CachedInstancesStream.class;
-    }
+	@Override
+	public Class<?> getTaskResultType() {
+		return CachedInstancesStream.class;
+	}
 }
diff --git a/moa/src/main/java/moa/tasks/FailedTaskReport.java b/moa/src/main/java/moa/tasks/FailedTaskReport.java
index 85ea38b5e..d85a1ae60 100644
--- a/moa/src/main/java/moa/tasks/FailedTaskReport.java
+++ b/moa/src/main/java/moa/tasks/FailedTaskReport.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks;
 
@@ -26,33 +26,33 @@
 import moa.core.StringUtils;
 
 /**
- * Class for reporting a failed task.
- * <code>TaskThread</code> returns this class as final result object when a task fails.
+ * Class for reporting a failed task. <code>TaskThread</code> returns this class
+ * as final result object when a task fails.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
 public class FailedTaskReport extends AbstractMOAObject {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    protected Throwable failureReason;
+	protected Throwable failureReason;
 
-    public FailedTaskReport(Throwable failureReason) {
-        this.failureReason = failureReason;
-    }
+	public FailedTaskReport(Throwable failureReason) {
+		this.failureReason = failureReason;
+	}
 
-    public Throwable getFailureReason() {
-        return this.failureReason;
-    }
+	public Throwable getFailureReason() {
+		return this.failureReason;
+	}
 
-    @Override
-    public void getDescription(StringBuilder sb, int indent) {
-        sb.append("Failure reason: ");
-        sb.append(this.failureReason.getMessage());
-        StringUtils.appendNewlineIndented(sb, indent, "*** STACK TRACE ***");
-        StringWriter stackTraceWriter = new StringWriter();
-        this.failureReason.printStackTrace(new PrintWriter(stackTraceWriter));
-        sb.append(stackTraceWriter.toString());
-    }
+	@Override
+	public void getDescription(StringBuilder sb, int indent) {
+		sb.append("Failure reason: ");
+		sb.append(this.failureReason.getMessage());
+		StringUtils.appendNewlineIndented(sb, indent, "*** STACK TRACE ***");
+		StringWriter stackTraceWriter = new StringWriter();
+		this.failureReason.printStackTrace(new PrintWriter(stackTraceWriter));
+		sb.append(stackTraceWriter.toString());
+	}
 }
diff --git a/moa/src/main/java/moa/tasks/MainTask.java b/moa/src/main/java/moa/tasks/MainTask.java
index 43247f76f..6f3f053ae 100644
--- a/moa/src/main/java/moa/tasks/MainTask.java
+++ b/moa/src/main/java/moa/tasks/MainTask.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks;
 
@@ -31,73 +31,67 @@
 import moa.streams.clustering.ClusterEvent;
 
 /**
- * Abstract Main Task. All tasks that want to write their result 
- * to a file must extend this class.
+ * Abstract Main Task. All tasks that want to write their result to a file must
+ * extend this class.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
 public abstract class MainTask extends AbstractTask {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
+
+	/** The number of instances between monitor updates. */
+	protected static final int INSTANCES_BETWEEN_MONITOR_UPDATES = 10;
+
+	/** File option to save the final result of the task to. */
+	public FileOption outputFileOption = new FileOption("taskResultFile", 'O',
+			"File to save the final result of the task to.", null, "moa", true);
 
-    /** The number of instances between monitor updates. */
-    protected static final int INSTANCES_BETWEEN_MONITOR_UPDATES = 10;
+	@Override
+	protected Object doTaskImpl(TaskMonitor monitor, ObjectRepository repository) {
+		Object result = doMainTask(monitor, repository);
+		if (monitor.taskShouldAbort()) {
+			return null;
+		}
+		File outputFile = this.outputFileOption.getFile();
+		if (outputFile != null) {
+			if (result instanceof Serializable) {
+				monitor.setCurrentActivity("Saving result of task " + getTaskName() + " to file " + outputFile + "...",
+						-1.0);
+				try {
+					SerializeUtils.writeToFile(outputFile, (Serializable) result);
+				} catch (IOException ioe) {
+					throw new RuntimeException(
+							"Failed writing result of task " + getTaskName() + " to file " + outputFile, ioe);
+				}
+			} else {
+				throw new RuntimeException("Result of task " + getTaskName()
+						+ " is not serializable, so cannot be written to file " + outputFile);
+			}
+		}
+		return result;
+	}
 
-    /** File option to save the final result of the task to. */
-    public FileOption outputFileOption = new FileOption("taskResultFile", 'O',
-            "File to save the final result of the task to.", null, "moa", true);
+	/**
+	 * This method performs this task. <code>AbstractTask</code> implements
+	 * <code>doTask</code>, that uses <code>doTaskImpl</code>. <code>MainTask</code>
+	 * implements <code>doTaskImpl</code> using <code>doMainTask</code> so its
+	 * extensions only need to implement <code>doMainTask</code>.
+	 *
+	 * @param monitor    the TaskMonitor to use
+	 * @param repository the ObjectRepository to use
+	 * @return an object with the result of this task
+	 */
+	protected abstract Object doMainTask(TaskMonitor monitor, ObjectRepository repository);
 
-    @Override
-    protected Object doTaskImpl(TaskMonitor monitor, ObjectRepository repository) {
-        Object result = doMainTask(monitor, repository);
-        if (monitor.taskShouldAbort()) {
-            return null;
-        }
-        File outputFile = this.outputFileOption.getFile();
-        if (outputFile != null) {
-            if (result instanceof Serializable) {
-                monitor.setCurrentActivity("Saving result of task "
-                        + getTaskName() + " to file " + outputFile + "...",
-                        -1.0);
-                try {
-                    SerializeUtils.writeToFile(outputFile,
-                            (Serializable) result);
-                } catch (IOException ioe) {
-                    throw new RuntimeException("Failed writing result of task "
-                            + getTaskName() + " to file " + outputFile, ioe);
-                }
-            } else {
-                throw new RuntimeException("Result of task " + getTaskName()
-                        + " is not serializable, so cannot be written to file "
-                        + outputFile);
-            }
-        }
-        return result;
-    }
+	protected ArrayList<ClusterEvent> events;
 
-    /**
-     * This method performs this task.
-     * <code>AbstractTask</code> implements <code>doTask</code>,
-     * that uses <code>doTaskImpl</code>.
-     * <code>MainTask</code> implements <code>doTaskImpl</code> using
-     * <code>doMainTask</code> so its extensions only need to implement
-     * <code>doMainTask</code>.
-     *
-     * @param monitor the TaskMonitor to use
-     * @param repository  the ObjectRepository to use
-     * @return an object with the result of this task
-     */
-    protected abstract Object doMainTask(TaskMonitor monitor,
-            ObjectRepository repository);
-    
-    protected ArrayList<ClusterEvent> events;
+	protected void setEventsList(ArrayList<ClusterEvent> events) {
+		this.events = events;
+	}
 
-    protected void setEventsList(ArrayList<ClusterEvent> events) {
-        this.events = events;
-    }
-    
-    public ArrayList<ClusterEvent> getEventsList() {
-        return this.events;
-    }
+	public ArrayList<ClusterEvent> getEventsList() {
+		return this.events;
+	}
 }
diff --git a/moa/src/main/java/moa/tasks/MainTaskInterface.java b/moa/src/main/java/moa/tasks/MainTaskInterface.java
index 10eaf61c4..bda4c36a2 100644
--- a/moa/src/main/java/moa/tasks/MainTaskInterface.java
+++ b/moa/src/main/java/moa/tasks/MainTaskInterface.java
@@ -2,9 +2,9 @@
 
 public interface MainTaskInterface {
 
-	public Object doTask();
-	
-	public String getCLICreationString(Class<?> c);
-	
-	public Object copy();
+	Object doTask();
+
+	String getCLICreationString(Class<?> c);
+
+	Object copy();
 }
diff --git a/moa/src/main/java/moa/tasks/NullMonitor.java b/moa/src/main/java/moa/tasks/NullMonitor.java
index b78cdebbd..1bac31369 100644
--- a/moa/src/main/java/moa/tasks/NullMonitor.java
+++ b/moa/src/main/java/moa/tasks/NullMonitor.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks;
 
@@ -27,75 +27,74 @@
  */
 public class NullMonitor implements TaskMonitor {
 
-    @Override
-    public void setCurrentActivity(String activityDescription,
-            double fracComplete) {
-    }
-
-    @Override
-    public void setCurrentActivityDescription(String activity) {
-    }
-
-    @Override
-    public void setCurrentActivityFractionComplete(double fracComplete) {
-    }
-
-    @Override
-    public boolean taskShouldAbort() {
-        return false;
-    }
-
-    @Override
-    public String getCurrentActivityDescription() {
-        return null;
-    }
-
-    @Override
-    public double getCurrentActivityFractionComplete() {
-        return -1.0;
-    }
-
-    @Override
-    public boolean isPaused() {
-        return false;
-    }
-
-    @Override
-    public boolean isCancelled() {
-        return false;
-    }
-
-    @Override
-    public void requestCancel() {
-    }
-
-    @Override
-    public void requestPause() {
-    }
-
-    @Override
-    public void requestResume() {
-    }
-
-    @Override
-    public Object getLatestResultPreview() {
-        return null;
-    }
-
-    @Override
-    public void requestResultPreview() {
-    }
-
-    @Override
-    public boolean resultPreviewRequested() {
-        return false;
-    }
-
-    @Override
-    public void setLatestResultPreview(Object latestPreview) {
-    }
-
-    @Override
-    public void requestResultPreview(ResultPreviewListener toInform) {
-    }
+	@Override
+	public void setCurrentActivity(String activityDescription, double fracComplete) {
+	}
+
+	@Override
+	public void setCurrentActivityDescription(String activity) {
+	}
+
+	@Override
+	public void setCurrentActivityFractionComplete(double fracComplete) {
+	}
+
+	@Override
+	public boolean taskShouldAbort() {
+		return false;
+	}
+
+	@Override
+	public String getCurrentActivityDescription() {
+		return null;
+	}
+
+	@Override
+	public double getCurrentActivityFractionComplete() {
+		return -1.0;
+	}
+
+	@Override
+	public boolean isPaused() {
+		return false;
+	}
+
+	@Override
+	public boolean isCancelled() {
+		return false;
+	}
+
+	@Override
+	public void requestCancel() {
+	}
+
+	@Override
+	public void requestPause() {
+	}
+
+	@Override
+	public void requestResume() {
+	}
+
+	@Override
+	public Object getLatestResultPreview() {
+		return null;
+	}
+
+	@Override
+	public void requestResultPreview() {
+	}
+
+	@Override
+	public boolean resultPreviewRequested() {
+		return false;
+	}
+
+	@Override
+	public void setLatestResultPreview(Object latestPreview) {
+	}
+
+	@Override
+	public void requestResultPreview(ResultPreviewListener toInform) {
+	}
 }
diff --git a/moa/src/main/java/moa/tasks/Plot.java b/moa/src/main/java/moa/tasks/Plot.java
index 328625433..c4958b22c 100644
--- a/moa/src/main/java/moa/tasks/Plot.java
+++ b/moa/src/main/java/moa/tasks/Plot.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks;
 
@@ -37,541 +37,501 @@
 
 /**
  * A task allowing to create and plot gnuplot scripts.
- * 
+ *
  * @author Dariusz Brzezinski
- * 
+ *
  */
 public class Plot extends MainTask {
-    @Override
-    public String getPurposeString() {
-	return "Creates a Gnuplot script and plots a chart from a set of given csv files.";
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    /**
-     * Path to gunplot's binary directory, for example C:\Tools\Gnuplot\binary.
-     */
-    public StringOption gnuplotPathOption = new StringOption("gnuplotPath", 'e',
-	    "Directory of the gnuplot executable. For example \"C:\\Tools\\Gnuplot\\binary\".", "");
-
-    
-    /**
-     * FileOption for selecting the plot output file.
-     */
-    public FileOption plotOutputOption = new FileOption("plotOutputFile", 'r',
-	    "File with the result plot (image).", null, "eps", true);
-
-    /**
-     * Comma separated list of input *csv files. The file paths can be absolute
-     * or relative to the executing directory (moa.jar directory).
-     */
-    public ListOption inputFilesOption = new ListOption(
-	    "inputFiles",
-	    'i',
-	    "File names or file paths of csv inputs. Values should be seperated by commas.",
-	    new StringOption("inputFile", ' ', "Input file.", "algorithm.csv"),
-	    new StringOption[] {
-		    new StringOption("", ' ', "", "algorithm1.csv"),
-		    new StringOption("", ' ', "", "algorithm2.csv"),
-		    new StringOption("", ' ', "", "algorithm3.csv") }, ',');
-
-    /**
-     * Comma separated list of aliases for the input *csv files. If a legend is
-     * added to the plot, aliases will be presented in the legend.
-     */
-    public ListOption fileAliasesOption = new ListOption(
-	    "aliases",
-	    'a',
-	    "Aliases for files stated in the inputFiles parameter. Aliases will be presented in the plot's legend.",
-	    new StringOption("alias", ' ', "File alias.", "MyAlg"),
-	    new StringOption[] { new StringOption("", ' ', "", "OZABag"),
-		    new StringOption("", ' ', "", "HOT"),
-		    new StringOption("", ' ', "", "AWE") }, ',');
-
-    /**
-     * Gnuplot terminal - postscript, png, pdf etc.
-     */
-    public MultiChoiceOption outputTypeOption = new MultiChoiceOption(
-	    "outputType", 't', "Gnuplot output terminal.", Terminal
-		    .getStringValues(), Terminal.getDescriptions(), 8);
-
-    /**
-     * Type of plot - dots, points, lines ets.
-     */
-    public MultiChoiceOption plotStyleOption = new MultiChoiceOption(
-	    "plotStyle", 'p', "Plot style.", PlotStyle.getStringValues(),
-	    PlotStyle.getDescriptions(), 2);
-
-    /**
-     * Index of the csv column from which values for the x-axis should be taken.
-     */
-    public IntOption xColumnOption = new IntOption(
-	    "xColumn",
-	    'x',
-	    "Index of the csv column from which values for the x-axis should be taken.",
-	    1);
-
-    /**
-     * Title of the plots' x-axis.
-     */
-    public StringOption xTitleOption = new StringOption("xTitle", 'm',
-	    "Title of the plots' x-axis.", "Processed instances");
-
-    /**
-     * Units displayed next to x-axis values.
-     */
-    public StringOption xUnitOption = new StringOption("xUnit", 'g',
-	    "Units displayed next to x-axis values.", "");
-
-    /**
-     * Index of the csv column from which values for the y-axis should be taken.
-     */
-    public IntOption yColumnOption = new IntOption(
-	    "yColumn",
-	    'y',
-	    "Index of the column from which values for the y-axis should be taken",
-	    9);
-
-    /**
-     * Title of the plots' y-axis.
-     */
-    public StringOption yTitleOption = new StringOption("yTitle", 'n',
-	    "Title of the plots' y-axis.", "Accuracy");
-
-    /**
-     * Units displayed next to y-axis values.
-     */
-    public StringOption yUnitOption = new StringOption("yUnit", 'u',
-	    "Units displayed next to y-axis values.", "%");
-
-    /**
-     * Plotted line width.
-     */
-    public IntOption lineWidthOption = new IntOption("lineWidth", 'w',
-	    "Determines the thickness of plotted lines", 2);
-
-    /**
-     * Interval between plotted data points.
-     */
-    public IntOption pointIntervalOption = new IntOption(
-	    "pointInterval",
-	    'v',
-	    "Determines the inteval between plotted data points. Used for LINESPOINTS plots only.",
-	    0, 0, Integer.MAX_VALUE);
-    /**
-     * Determines whether to smooth the plot with bezier curves.
-     */
-    public FlagOption smoothOption = new FlagOption("smooth", 's',
-	    "Determines whether to smooth the plot with bezier curves.");
-    /**
-     * Determines whether to delete gnuplot scripts after plotting.
-     */
-    public FlagOption deleteScriptsOption = new FlagOption("deleteScripts",
-	    'd', "Determines whether to delete gnuplot scripts after plotting.");
-
-    /**
-     * Legend (key) location on the plot.
-     */
-    public MultiChoiceOption legendLocationOption = new MultiChoiceOption(
-	    "legendLocation", 'l', "Legend (key) location on the plot.",
-	    LegendLocation.getStringValues(), LegendLocation.getDescriptions(),
-	    8);
-
-    /**
-     * Legend elements' alignment.
-     */
-    public MultiChoiceOption legendTypeOption = new MultiChoiceOption(
-	    "legendType", 'k', "Legend elements' alignment.", LegendType
-		    .getStringValues(), LegendType.getDescriptions(), 1);
-
-    /**
-     * Addition pre-plot gunplot commands. For example "set tics out" will
-     * change the default tic option and force outward facing tics. See the
-     * gnuplot manual for more commands.
-     */
-    public StringOption additionalSetOption = new StringOption(
-	    "additionalCommands",
-	    'c',
-	    "Additional commands that should be added to the gnuplot script before the plot command. For example \"set tics out\" will change the default tic option and force outward facing tics. See the gnuplot manual for more commands.",
-	    " ");
-
-    /**
-     * Additional plot options. For example \"[] [0:]\" will force the y-axis to
-     * start from 0. See the gnuplot manual for more options.
-     */
-    public StringOption additionalPlotOption = new StringOption(
-	    "additionalPlotOptions",
-	    'z',
-	    "Additional options that should be added to the gnuplot script in the plot statement. For example \"[] [0:]\" will force the y-axis to start from 0. See the gnuplot manual for more options.",
-	    " ");
-
-    /**
-     * Plot output terminal.
-     * @author Dariusz Brzezi�ski
-     *
-     */
-    public enum Terminal {
-	CANVAS, EPSLATEX, GIF, JPEG, LATEX, PDFCAIRO, PNG, POSTSCRIPT, POSTSCRIPT_COLOR, PSLATEX, PSTEX, PSTRICKS, SVG;
-
-	private static String[] descriptions = new String[] {
-		"HTML Canvas object",
-		"LaTeX picture environment using graphicx package",
-		"GIF images using libgd and TrueType fonts",
-		"JPEG images using libgd and TrueType fonts",
-		"LaTeX picture environment",
-		"pdf terminal based on cairo",
-		"PNG images using libgd and TrueType fonts",
-		"PostScript graphics, including EPSF embedded files (*.eps)",
-		"Color PostScript graphics, including EPSF embedded files (*.eps)",
-		"LaTeX picture environment with PostScript specials",
-		"plain TeX with PostScript specials",
-		"LaTeX picture environment with PSTricks macros",
-		"W3C Scalable Vector Graphics driver" };
+	@Override
+	public String getPurposeString() {
+		return "Creates a Gnuplot script and plots a chart from a set of given csv files.";
+	}
+
+	private static final long serialVersionUID = 1L;
 
 	/**
-	 * Gets an array of string descriptions - one for each enum value.
-	 * @return a description for each enum value.
+	 * Path to gunplot's binary directory, for example C:\Tools\Gnuplot\binary.
 	 */
-	public static String[] getDescriptions() {
-	    return descriptions;
-	}
+	public StringOption gnuplotPathOption = new StringOption("gnuplotPath", 'e',
+			"Directory of the gnuplot executable. For example \"C:\\Tools\\Gnuplot\\binary\".", "");
 
 	/**
-	 * Get string values for the enum values.
-	 * @return a set of string values for the enum values.
+	 * FileOption for selecting the plot output file.
 	 */
-	public static String[] getStringValues() {
-	    int i = 0;
-	    String[] result = new String[values().length];
+	public FileOption plotOutputOption = new FileOption("plotOutputFile", 'r', "File with the result plot (image).",
+			null, "eps", true);
 
-	    for (Terminal value : values()) {
-		result[i++] = value.name();
-	    }
+	/**
+	 * Comma separated list of input *csv files. The file paths can be absolute or
+	 * relative to the executing directory (moa.jar directory).
+	 */
+	public ListOption inputFilesOption = new ListOption("inputFiles", 'i',
+			"File names or file paths of csv inputs. Values should be seperated by commas.",
+			new StringOption("inputFile", ' ', "Input file.", "algorithm.csv"),
+			new StringOption[] { new StringOption("", ' ', "", "algorithm1.csv"),
+					new StringOption("", ' ', "", "algorithm2.csv"), new StringOption("", ' ', "", "algorithm3.csv") },
+			',');
 
-	    return result;
-	}
-    }
+	/**
+	 * Comma separated list of aliases for the input *csv files. If a legend is
+	 * added to the plot, aliases will be presented in the legend.
+	 */
+	public ListOption fileAliasesOption = new ListOption("aliases", 'a',
+			"Aliases for files stated in the inputFiles parameter. Aliases will be presented in the plot's legend.",
+			new StringOption("alias", ' ', "File alias.", "MyAlg"),
+			new StringOption[] { new StringOption("", ' ', "", "OZABag"), new StringOption("", ' ', "", "HOT"),
+					new StringOption("", ' ', "", "AWE") },
+			',');
 
-    /**
-     * Location of the legend on the plot.
-     * @author Dariusz Brzezi�ski
-     *
-     */
-    public enum LegendLocation {
-	TOP_LEFT_INSIDE, TOP_CENTER_INSIDE, TOP_RIGHT_INSIDE, LEFT_INSIDE, CENTER_INSIDE, RIGHT_INSIDE, BOTTOM_LEFT_INSIDE, BOTTOM_CENTER_INSIDE, BOTTOM_RIGHT_INSIDE, TOP_LEFT_OUTSIDE, TOP_CENTER_OUTSIDE, TOP_RIGHT_OUTSIDE, LEFT_OUTSIDE, CENTER_OUTSIDE, RIGHT_OUTSIDE, BOTTOM_LEFT_OUTSIDE, BOTTOM_CENTER_OUTSIDE, BOTTOM_RIGHT_OUTSIDE;
+	/**
+	 * Gnuplot terminal - postscript, png, pdf etc.
+	 */
+	public MultiChoiceOption outputTypeOption = new MultiChoiceOption("outputType", 't', "Gnuplot output terminal.",
+			Terminal.getStringValues(), Terminal.getDescriptions(), 8);
 
 	/**
-	 * Gets an array of string descriptions - one for each enum value.
-	 * @return a description for each enum value.
+	 * Type of plot - dots, points, lines ets.
 	 */
-	public static String[] getDescriptions() {
-	    int i = 0;
-	    String[] result = new String[values().length];
+	public MultiChoiceOption plotStyleOption = new MultiChoiceOption("plotStyle", 'p', "Plot style.",
+			PlotStyle.getStringValues(), PlotStyle.getDescriptions(), 2);
 
-	    for (LegendLocation value : values()) {
-		result[i++] = value.name().toLowerCase().replace('_', ' ');
-	    }
+	/**
+	 * Index of the csv column from which values for the x-axis should be taken.
+	 */
+	public IntOption xColumnOption = new IntOption("xColumn", 'x',
+			"Index of the csv column from which values for the x-axis should be taken.", 1);
 
-	    return result;
-	}
+	/**
+	 * Title of the plots' x-axis.
+	 */
+	public StringOption xTitleOption = new StringOption("xTitle", 'm', "Title of the plots' x-axis.",
+			"Processed instances");
 
 	/**
-	 * Get string values for the enum values.
-	 * @return a set of string values for the enum values.
+	 * Units displayed next to x-axis values.
 	 */
-	public static String[] getStringValues() {
-	    int i = 0;
-	    String[] result = new String[values().length];
+	public StringOption xUnitOption = new StringOption("xUnit", 'g', "Units displayed next to x-axis values.", "");
 
-	    for (LegendLocation value : values()) {
-		result[i++] = value.name();
-	    }
+	/**
+	 * Index of the csv column from which values for the y-axis should be taken.
+	 */
+	public IntOption yColumnOption = new IntOption("yColumn", 'y',
+			"Index of the column from which values for the y-axis should be taken", 9);
 
-	    return result;
-	}
-    }
+	/**
+	 * Title of the plots' y-axis.
+	 */
+	public StringOption yTitleOption = new StringOption("yTitle", 'n', "Title of the plots' y-axis.", "Accuracy");
 
-    /**
-     * Type of legend.
-     * @author Dariusz Brzezi�ski
-     *
-     */
-    public enum LegendType {
-	NONE, BOX_VERTICAL, BOX_HORIZONTAL, NOBOX_VERTICAL, NOBOX_HORIZONTAL;
+	/**
+	 * Units displayed next to y-axis values.
+	 */
+	public StringOption yUnitOption = new StringOption("yUnit", 'u', "Units displayed next to y-axis values.", "%");
 
 	/**
-	 * Gets an array of string descriptions - one for each enum value.
-	 * @return a description for each enum value.
+	 * Plotted line width.
 	 */
-	public static String[] getDescriptions() {
-	    int i = 0;
-	    String[] result = new String[values().length];
+	public IntOption lineWidthOption = new IntOption("lineWidth", 'w', "Determines the thickness of plotted lines", 2);
 
-	    for (LegendType value : values()) {
-		result[i++] = value.name().toLowerCase().replace('_', ' ');
-	    }
+	/**
+	 * Interval between plotted data points.
+	 */
+	public IntOption pointIntervalOption = new IntOption("pointInterval", 'v',
+			"Determines the inteval between plotted data points. Used for LINESPOINTS plots only.", 0, 0,
+			Integer.MAX_VALUE);
+	/**
+	 * Determines whether to smooth the plot with bezier curves.
+	 */
+	public FlagOption smoothOption = new FlagOption("smooth", 's',
+			"Determines whether to smooth the plot with bezier curves.");
+	/**
+	 * Determines whether to delete gnuplot scripts after plotting.
+	 */
+	public FlagOption deleteScriptsOption = new FlagOption("deleteScripts", 'd',
+			"Determines whether to delete gnuplot scripts after plotting.");
 
-	    return result;
-	}
+	/**
+	 * Legend (key) location on the plot.
+	 */
+	public MultiChoiceOption legendLocationOption = new MultiChoiceOption("legendLocation", 'l',
+			"Legend (key) location on the plot.", LegendLocation.getStringValues(), LegendLocation.getDescriptions(),
+			8);
 
 	/**
-	 * Get string values for the enum values.
-	 * @return a set of string values for the enum values.
+	 * Legend elements' alignment.
 	 */
-	public static String[] getStringValues() {
-	    int i = 0;
-	    String[] result = new String[values().length];
+	public MultiChoiceOption legendTypeOption = new MultiChoiceOption("legendType", 'k', "Legend elements' alignment.",
+			LegendType.getStringValues(), LegendType.getDescriptions(), 1);
 
-	    for (LegendType value : values()) {
-		result[i++] = value.name();
-	    }
+	/**
+	 * Addition pre-plot gunplot commands. For example "set tics out" will change
+	 * the default tic option and force outward facing tics. See the gnuplot manual
+	 * for more commands.
+	 */
+	public StringOption additionalSetOption = new StringOption("additionalCommands", 'c',
+			"Additional commands that should be added to the gnuplot script before the plot command. For example \"set tics out\" will change the default tic option and force outward facing tics. See the gnuplot manual for more commands.",
+			" ");
 
-	    return result;
-	}
-    }
+	/**
+	 * Additional plot options. For example \"[] [0:]\" will force the y-axis to
+	 * start from 0. See the gnuplot manual for more options.
+	 */
+	public StringOption additionalPlotOption = new StringOption("additionalPlotOptions", 'z',
+			"Additional options that should be added to the gnuplot script in the plot statement. For example \"[] [0:]\" will force the y-axis to start from 0. See the gnuplot manual for more options.",
+			" ");
+
+	/**
+	 * Plot output terminal.
+	 * 
+	 * @author Dariusz Brzezi�ski
+	 *
+	 */
+	public enum Terminal {
+		CANVAS, EPSLATEX, GIF, JPEG, LATEX, PDFCAIRO, PNG, POSTSCRIPT, POSTSCRIPT_COLOR, PSLATEX, PSTEX, PSTRICKS, SVG;
+
+		private static String[] descriptions = new String[] { "HTML Canvas object",
+				"LaTeX picture environment using graphicx package", "GIF images using libgd and TrueType fonts",
+				"JPEG images using libgd and TrueType fonts", "LaTeX picture environment",
+				"pdf terminal based on cairo", "PNG images using libgd and TrueType fonts",
+				"PostScript graphics, including EPSF embedded files (*.eps)",
+				"Color PostScript graphics, including EPSF embedded files (*.eps)",
+				"LaTeX picture environment with PostScript specials", "plain TeX with PostScript specials",
+				"LaTeX picture environment with PSTricks macros", "W3C Scalable Vector Graphics driver" };
+
+		/**
+		 * Gets an array of string descriptions - one for each enum value.
+		 * 
+		 * @return a description for each enum value.
+		 */
+		public static String[] getDescriptions() {
+			return descriptions;
+		}
 
-    public enum PlotStyle {
-	LINES, POINTS, LINESPOINTS, IMPULSES, STEPS, FSTEPS, HISTEPS, DOTS;
+		/**
+		 * Get string values for the enum values.
+		 * 
+		 * @return a set of string values for the enum values.
+		 */
+		public static String[] getStringValues() {
+			int i = 0;
+			String[] result = new String[values().length];
 
-	private static String[] descriptions = new String[] {
-		"It connects each data point with lines. Suitable to smoothly varying data.",
-		"Symbols are shown at the data point location, can be used to plot experimental data.",
-		"Draws lines and symbols at the same time.",
-		"Draw vertical lines from each data point to X-axis. This is a bar-graph without width.",
-		"Histogram type 1",
-		"Histogram type 2",
-		"Histogram type 3",
-		"It displays dots, can be used when there many data points, but hard to see though.", };
+			for (Terminal value : values()) {
+				result[i++] = value.name();
+			}
+
+			return result;
+		}
+	}
 
 	/**
-	 * Gets an array of string descriptions = one for each enum value.
-	 * @return a description for each enum value.
+	 * Location of the legend on the plot.
+	 * 
+	 * @author Dariusz Brzezi�ski
+	 *
 	 */
-	public static String[] getDescriptions() {
-	    return descriptions;
+	public enum LegendLocation {
+		TOP_LEFT_INSIDE, TOP_CENTER_INSIDE, TOP_RIGHT_INSIDE, LEFT_INSIDE, CENTER_INSIDE, RIGHT_INSIDE,
+		BOTTOM_LEFT_INSIDE, BOTTOM_CENTER_INSIDE, BOTTOM_RIGHT_INSIDE, TOP_LEFT_OUTSIDE, TOP_CENTER_OUTSIDE,
+		TOP_RIGHT_OUTSIDE, LEFT_OUTSIDE, CENTER_OUTSIDE, RIGHT_OUTSIDE, BOTTOM_LEFT_OUTSIDE, BOTTOM_CENTER_OUTSIDE,
+		BOTTOM_RIGHT_OUTSIDE;
+
+		/**
+		 * Gets an array of string descriptions - one for each enum value.
+		 * 
+		 * @return a description for each enum value.
+		 */
+		public static String[] getDescriptions() {
+			int i = 0;
+			String[] result = new String[values().length];
+
+			for (LegendLocation value : values()) {
+				result[i++] = value.name().toLowerCase().replace('_', ' ');
+			}
+
+			return result;
+		}
+
+		/**
+		 * Get string values for the enum values.
+		 * 
+		 * @return a set of string values for the enum values.
+		 */
+		public static String[] getStringValues() {
+			int i = 0;
+			String[] result = new String[values().length];
+
+			for (LegendLocation value : values()) {
+				result[i++] = value.name();
+			}
+
+			return result;
+		}
 	}
 
 	/**
-	 * Get string values for the enum values.
-	 * @return a set of string values for the enum values.
+	 * Type of legend.
+	 * 
+	 * @author Dariusz Brzezi�ski
+	 *
 	 */
-	public static String[] getStringValues() {
-	    int i = 0;
-	    String[] result = new String[values().length];
+	public enum LegendType {
+		NONE, BOX_VERTICAL, BOX_HORIZONTAL, NOBOX_VERTICAL, NOBOX_HORIZONTAL;
+
+		/**
+		 * Gets an array of string descriptions - one for each enum value.
+		 * 
+		 * @return a description for each enum value.
+		 */
+		public static String[] getDescriptions() {
+			int i = 0;
+			String[] result = new String[values().length];
+
+			for (LegendType value : values()) {
+				result[i++] = value.name().toLowerCase().replace('_', ' ');
+			}
+
+			return result;
+		}
 
-	    for (PlotStyle value : values()) {
-		result[i++] = value.name();
-	    }
+		/**
+		 * Get string values for the enum values.
+		 * 
+		 * @return a set of string values for the enum values.
+		 */
+		public static String[] getStringValues() {
+			int i = 0;
+			String[] result = new String[values().length];
 
-	    return result;
-	}
-    }
-
-    /**
-     * Defines the task's result type.
-     */
-    public Class<?> getTaskResultType() {
-	return String.class;
-    }
-
-    @Override
-    protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
-	File resultFile = this.plotOutputOption.getFile();
-	if (this.plotOutputOption.getFile() == null) {
-	    throw new RuntimeException("Plot output file option not set!");
-	}
+			for (LegendType value : values()) {
+				result[i++] = value.name();
+			}
 
-	String resultDirectory = (new File(resultFile.getAbsolutePath()))
-		.getParent();
-	String gnuPlotPath = gnuplotPathOption.getValue();
-	File gnuplotDir = new File(gnuPlotPath);
-	if(!gnuplotDir.exists()){
-	    throw new RuntimeException("Gnuplot directory not found: " + gnuPlotPath);
+			return result;
+		}
 	}
 
-	monitor.setCurrentActivity("Verifying input files...", 0.0);
-
-	if (inputFilesOption.getList().length > fileAliasesOption.getList().length) {
-	    throw new RuntimeException("Too little aliases for input files!");
-	} else if (inputFilesOption.getList().length < fileAliasesOption
-		.getList().length) {
-	    throw new RuntimeException("Too many aliases for input files!");
-	} else {
-	    for (int i = 0; i < inputFilesOption.getList().length; i++) {
-		File inputFile = new File(((StringOption) inputFilesOption
-			.getList()[i]).getValue());
-
-		if (!inputFile.exists()) {
-		    throw new RuntimeException("File not found: "
-			    + inputFile.getAbsolutePath());
+	public enum PlotStyle {
+		LINES, POINTS, LINESPOINTS, IMPULSES, STEPS, FSTEPS, HISTEPS, DOTS;
+
+		private static String[] descriptions = new String[] {
+				"It connects each data point with lines. Suitable to smoothly varying data.",
+				"Symbols are shown at the data point location, can be used to plot experimental data.",
+				"Draws lines and symbols at the same time.",
+				"Draw vertical lines from each data point to X-axis. This is a bar-graph without width.",
+				"Histogram type 1", "Histogram type 2", "Histogram type 3",
+				"It displays dots, can be used when there many data points, but hard to see though.", };
+
+		/**
+		 * Gets an array of string descriptions = one for each enum value.
+		 * 
+		 * @return a description for each enum value.
+		 */
+		public static String[] getDescriptions() {
+			return descriptions;
 		}
-	    }
-	}
 
-	if (monitor.taskShouldAbort()) {
-	    return null;
-	}
-	monitor.setCurrentActivity("Creating script file...", 1.0 / 4.0);
+		/**
+		 * Get string values for the enum values.
+		 * 
+		 * @return a set of string values for the enum values.
+		 */
+		public static String[] getStringValues() {
+			int i = 0;
+			String[] result = new String[values().length];
 
-	String gnuplotScriptPath = resultDirectory + File.separator
-		+ resultFile.getName() + ".plt";
-	String script = createScript(resultFile);
-	File scriptFile = writeScriptToFile(gnuplotScriptPath, script);
+			for (PlotStyle value : values()) {
+				result[i++] = value.name();
+			}
 
-	if (monitor.taskShouldAbort()) {
-	    return null;
-	}
-	monitor.setCurrentActivity("Plotting data...", 2.0 / 4.0);
-
-	String gnuplotCommand = gnuPlotPath + File.separator + "gnuplot \""
-		+ gnuplotScriptPath + "\"";
-
-	String line, gnuplotOutput = "";
-	try {
-	    Process p = Runtime.getRuntime().exec(gnuplotCommand);
-
-	    BufferedReader err = new BufferedReader(new InputStreamReader(p
-		    .getErrorStream()));
-	    while ((line = err.readLine()) != null) {
-		gnuplotOutput += line + System.getProperty("line.separator");
-	    }
-	    err.close();
-	} catch (IOException ex) {
-	    throw new RuntimeException("Error while executing gnuplot script:"
-		    + scriptFile, ex);
+			return result;
+		}
 	}
 
-	if (monitor.taskShouldAbort()) {
-	    return null;
-	}
-	if (deleteScriptsOption.isSet()) {
-	    monitor.setCurrentActivity("Deleting script...", 3.0 / 4.0);
-	    scriptFile.delete();
-	}
-	if (monitor.taskShouldAbort()) {
-	    return null;
+	/**
+	 * Defines the task's result type.
+	 */
+	@Override
+	public Class<?> getTaskResultType() {
+		return String.class;
 	}
-	monitor.setCurrentActivity("Done", 1.0);
-
-	return resultFile.getAbsolutePath()
-		+ System.getProperty("line.separator") + gnuplotOutput;
-    }
-
-    /**
-     * Method responsible for saving a gnuplot script to a file.
-     * @param gnuplotScriptPath Path of the file
-     * @param script gnuplot script content
-     * @return the object of the saved file
-     */
-    private File writeScriptToFile(String gnuplotScriptPath, String script) {
-	File scriptFile = new File(gnuplotScriptPath);
-	BufferedWriter writer;
-	try {
-	    writer = new BufferedWriter(new FileWriter(scriptFile));
-	    writer.write(script);
-	    writer.close();
-	} catch (IOException ex) {
-	    throw new RuntimeException(
-		    "Unable to create or write to script file: " + scriptFile,
-		    ex);
+
+	@Override
+	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
+		File resultFile = this.plotOutputOption.getFile();
+		if (this.plotOutputOption.getFile() == null) {
+			throw new RuntimeException("Plot output file option not set!");
+		}
+
+		String resultDirectory = (new File(resultFile.getAbsolutePath())).getParent();
+		String gnuPlotPath = gnuplotPathOption.getValue();
+		File gnuplotDir = new File(gnuPlotPath);
+		if (!gnuplotDir.exists()) {
+			throw new RuntimeException("Gnuplot directory not found: " + gnuPlotPath);
+		}
+
+		monitor.setCurrentActivity("Verifying input files...", 0.0);
+
+		if (inputFilesOption.getList().length > fileAliasesOption.getList().length) {
+			throw new RuntimeException("Too little aliases for input files!");
+		} else if (inputFilesOption.getList().length < fileAliasesOption.getList().length) {
+			throw new RuntimeException("Too many aliases for input files!");
+		} else {
+			for (int i = 0; i < inputFilesOption.getList().length; i++) {
+				File inputFile = new File(((StringOption) inputFilesOption.getList()[i]).getValue());
+
+				if (!inputFile.exists()) {
+					throw new RuntimeException("File not found: " + inputFile.getAbsolutePath());
+				}
+			}
+		}
+
+		if (monitor.taskShouldAbort()) {
+			return null;
+		}
+		monitor.setCurrentActivity("Creating script file...", 1.0 / 4.0);
+
+		String gnuplotScriptPath = resultDirectory + File.separator + resultFile.getName() + ".plt";
+		String script = createScript(resultFile);
+		File scriptFile = writeScriptToFile(gnuplotScriptPath, script);
+
+		if (monitor.taskShouldAbort()) {
+			return null;
+		}
+		monitor.setCurrentActivity("Plotting data...", 2.0 / 4.0);
+
+		String gnuplotCommand = gnuPlotPath + File.separator + "gnuplot \"" + gnuplotScriptPath + "\"";
+
+		String line, gnuplotOutput = "";
+		try {
+			Process p = Runtime.getRuntime().exec(gnuplotCommand);
+
+			BufferedReader err = new BufferedReader(new InputStreamReader(p.getErrorStream()));
+			while ((line = err.readLine()) != null) {
+				gnuplotOutput += line + System.getProperty("line.separator");
+			}
+			err.close();
+		} catch (IOException ex) {
+			throw new RuntimeException("Error while executing gnuplot script:" + scriptFile, ex);
+		}
+
+		if (monitor.taskShouldAbort()) {
+			return null;
+		}
+		if (deleteScriptsOption.isSet()) {
+			monitor.setCurrentActivity("Deleting script...", 3.0 / 4.0);
+			scriptFile.delete();
+		}
+		if (monitor.taskShouldAbort()) {
+			return null;
+		}
+		monitor.setCurrentActivity("Done", 1.0);
+
+		return resultFile.getAbsolutePath() + System.getProperty("line.separator") + gnuplotOutput;
 	}
-	return scriptFile;
-    }
-
-    /**
-     * Creates the content of the gnuplot script.
-     * @param resultFile path of the plot output file
-     * @return gnuplot script
-     */
-    private String createScript(File resultFile) {
-	String newLine = System.getProperty("line.separator");
-	int sourceFileIdx = 0;
-
-	// terminal options;
-	String script = "set term "
-		+ terminalOptions(Terminal.valueOf(outputTypeOption
-			.getChosenLabel())) + newLine;
-	script += "set output '" + resultFile.getAbsolutePath() + "'" + newLine;
-	script += "set datafile separator ','" + newLine;
-	script += "set grid" + newLine;
-	script += "set style line 1 pt 8" + newLine;
-	script += "set style line 2 lt rgb '#00C000'" + newLine;
-	script += "set style line 5 lt rgb '#FFD800'" + newLine;
-	script += "set style line 6 lt rgb '#4E0000'" + newLine;
-	script += "set format x '%.0s %c" + getAxisUnit(xUnitOption.getValue())
-		+ "'" + newLine;
-	script += "set format y '%.0s %c" + getAxisUnit(yUnitOption.getValue())
-		+ "'" + newLine;
-	script += "set ylabel '" + yTitleOption.getValue() + "'" + newLine;
-	script += "set xlabel '" + xTitleOption.getValue() + "'" + newLine;
-	if (!legendTypeOption.getChosenLabel().equals(LegendType.NONE)) {
-	    script += "set key "
-		    + legendTypeOption.getChosenLabel().toLowerCase().replace(
-			    '_', ' ')
-		    + " "
-		    + legendLocationOption.getChosenLabel().toLowerCase()
-			    .replace('_', ' ') + newLine;
+
+	/**
+	 * Method responsible for saving a gnuplot script to a file.
+	 * 
+	 * @param gnuplotScriptPath Path of the file
+	 * @param script            gnuplot script content
+	 * @return the object of the saved file
+	 */
+	private File writeScriptToFile(String gnuplotScriptPath, String script) {
+		File scriptFile = new File(gnuplotScriptPath);
+		BufferedWriter writer;
+		try {
+			writer = new BufferedWriter(new FileWriter(scriptFile));
+			writer.write(script);
+			writer.close();
+		} catch (IOException ex) {
+			throw new RuntimeException("Unable to create or write to script file: " + scriptFile, ex);
+		}
+		return scriptFile;
 	}
 
-	// additional commands
-	script += additionalSetOption.getValue();
-
-	// plot command
-	script += "plot " + additionalPlotOption.getValue() + " ";
-
-	// plot for each input file
-	for (int i = 0; i < inputFilesOption.getList().length; i++) {
-		
-	    if (sourceFileIdx > 0) {
-		script += ", ";
-	    }
-	    sourceFileIdx++;
-	    script += "'" + ((StringOption) inputFilesOption
-			.getList()[i]).getValue() + "' using "
-		    + xColumnOption.getValue() + ":" + yColumnOption.getValue();
-
-	    if (smoothOption.isSet()) {
-		script += ":(1.0) smooth bezier";
-	    }
-
-	    script += " with " + plotStyleOption.getChosenLabel().toLowerCase()
-		    + " ls " + sourceFileIdx + " lw "
-		    + lineWidthOption.getValue();
-	    if (plotStyleOption.getChosenLabel().equals(
-		    PlotStyle.LINESPOINTS.toString())
-		    && pointIntervalOption.getValue() > 0) {
-		script += " pointinterval " + pointIntervalOption.getValue();
-	    }
-	    script += " title '" + ((StringOption) fileAliasesOption
-			.getList()[i]).getValue() + "'";
+	/**
+	 * Creates the content of the gnuplot script.
+	 * 
+	 * @param resultFile path of the plot output file
+	 * @return gnuplot script
+	 */
+	private String createScript(File resultFile) {
+		String newLine = System.getProperty("line.separator");
+		int sourceFileIdx = 0;
+
+		// terminal options;
+		String script = "set term " + terminalOptions(Terminal.valueOf(outputTypeOption.getChosenLabel())) + newLine;
+		script += "set output '" + resultFile.getAbsolutePath() + "'" + newLine;
+		script += "set datafile separator ','" + newLine;
+		script += "set grid" + newLine;
+		script += "set style line 1 pt 8" + newLine;
+		script += "set style line 2 lt rgb '#00C000'" + newLine;
+		script += "set style line 5 lt rgb '#FFD800'" + newLine;
+		script += "set style line 6 lt rgb '#4E0000'" + newLine;
+		script += "set format x '%.0s %c" + getAxisUnit(xUnitOption.getValue()) + "'" + newLine;
+		script += "set format y '%.0s %c" + getAxisUnit(yUnitOption.getValue()) + "'" + newLine;
+		script += "set ylabel '" + yTitleOption.getValue() + "'" + newLine;
+		script += "set xlabel '" + xTitleOption.getValue() + "'" + newLine;
+		if (!legendTypeOption.getChosenLabel().equals(LegendType.NONE)) {
+			script += "set key " + legendTypeOption.getChosenLabel().toLowerCase().replace('_', ' ') + " "
+					+ legendLocationOption.getChosenLabel().toLowerCase().replace('_', ' ') + newLine;
+		}
+
+		// additional commands
+		script += additionalSetOption.getValue();
+
+		// plot command
+		script += "plot " + additionalPlotOption.getValue() + " ";
+
+		// plot for each input file
+		for (int i = 0; i < inputFilesOption.getList().length; i++) {
+
+			if (sourceFileIdx > 0) {
+				script += ", ";
+			}
+			sourceFileIdx++;
+			script += "'" + ((StringOption) inputFilesOption.getList()[i]).getValue() + "' using "
+					+ xColumnOption.getValue() + ":" + yColumnOption.getValue();
+
+			if (smoothOption.isSet()) {
+				script += ":(1.0) smooth bezier";
+			}
+
+			script += " with " + plotStyleOption.getChosenLabel().toLowerCase() + " ls " + sourceFileIdx + " lw "
+					+ lineWidthOption.getValue();
+			if (plotStyleOption.getChosenLabel().equals(PlotStyle.LINESPOINTS.toString())
+					&& pointIntervalOption.getValue() > 0) {
+				script += " pointinterval " + pointIntervalOption.getValue();
+			}
+			script += " title '" + ((StringOption) fileAliasesOption.getList()[i]).getValue() + "'";
+		}
+		script += newLine;
+		return script;
 	}
-	script += newLine;
-	return script;
-    }
-
-    private String getAxisUnit(String unit) {
-	if (unit.equals("%")) {
-	    return "%%";
-	} else {
-	    return unit;
+
+	private String getAxisUnit(String unit) {
+		if (unit.equals("%")) {
+			return "%%";
+		} else {
+			return unit;
+		}
 	}
-    }
-
-    private String terminalOptions(Terminal term) {
-	String options;
-
-	switch (term) {
-	case POSTSCRIPT:
-	    options = "postscript enhanced";
-	    break;
-	case POSTSCRIPT_COLOR:
-	    options = "postscript color enhanced";
-	    break;
-	default:
-	    options = term.toString().toLowerCase();
-	    break;
+
+	private String terminalOptions(Terminal term) {
+		String options;
+
+		switch (term) {
+		case POSTSCRIPT:
+			options = "postscript enhanced";
+			break;
+		case POSTSCRIPT_COLOR:
+			options = "postscript color enhanced";
+			break;
+		default:
+			options = term.toString().toLowerCase();
+			break;
+		}
+		return options;
 	}
-	return options;
-    }
 }
diff --git a/moa/src/main/java/moa/tasks/ResultPreviewListener.java b/moa/src/main/java/moa/tasks/ResultPreviewListener.java
index 5121ea059..6d0b5a6dd 100644
--- a/moa/src/main/java/moa/tasks/ResultPreviewListener.java
+++ b/moa/src/main/java/moa/tasks/ResultPreviewListener.java
@@ -15,25 +15,24 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks;
 
 /**
- * Interface implemented by classes that preview results 
- * on the Graphical User Interface 
+ * Interface implemented by classes that preview results on the Graphical User
+ * Interface
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
 public interface ResultPreviewListener {
 
-    /**
-     * This method is used to receive a signal from
-     * <code>TaskMonitor</code> that the lastest preview has
-     * changed. This method is implemented in <code>PreviewPanel</code>
-     * to change the results that are shown in its panel.
-     *
-     */
-    public void latestPreviewChanged();
+	/**
+	 * This method is used to receive a signal from <code>TaskMonitor</code> that
+	 * the lastest preview has changed. This method is implemented in
+	 * <code>PreviewPanel</code> to change the results that are shown in its panel.
+	 *
+	 */
+	void latestPreviewChanged();
 }
diff --git a/moa/src/main/java/moa/tasks/RunStreamTasks.java b/moa/src/main/java/moa/tasks/RunStreamTasks.java
index c3e211653..85b99b767 100644
--- a/moa/src/main/java/moa/tasks/RunStreamTasks.java
+++ b/moa/src/main/java/moa/tasks/RunStreamTasks.java
@@ -16,7 +16,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks;
 
@@ -38,52 +38,49 @@
  */
 public class RunStreamTasks extends ConceptDriftMainTask {
 
-    @Override
-    public String getPurposeString() {
-        return "Runs several experiments modifying values of parameters.";
-    }
+	@Override
+	public String getPurposeString() {
+		return "Runs several experiments modifying values of parameters.";
+	}
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public ClassOption taskOption = new ClassOption("task", 't',
-            "Task to do.", Task.class, "EvaluatePrequential -l active.ALUncertainty -i 1000000 -d temp.txt");
+	public ClassOption taskOption = new ClassOption("task", 't', "Task to do.", Task.class,
+			"EvaluatePrequential -l active.ALUncertainty -i 1000000 -d temp.txt");
 
-    public StringOption streamParameterOption = new StringOption("streamParameter", 'p',
-            "Stream parameter to vary.", "b");
+	public StringOption streamParameterOption = new StringOption("streamParameter", 'p', "Stream parameter to vary.",
+			"b");
 
-    public FloatOption firstValueOption = new FloatOption("firstValue",
-            'f', "First value", 0.0);
+	public FloatOption firstValueOption = new FloatOption("firstValue", 'f', "First value", 0.0);
 
-    public FloatOption lastValueOption = new FloatOption("lastValue",
-            'l', "Last value", 1.0);
+	public FloatOption lastValueOption = new FloatOption("lastValue", 'l', "Last value", 1.0);
 
-    public FloatOption incrementValueOption = new FloatOption("incrementValue",
-            'i', "Increment value", 0.1);
+	public FloatOption incrementValueOption = new FloatOption("incrementValue", 'i', "Increment value", 0.1);
 
-    @Override
-    public Class<?> getTaskResultType() {
-        return this.task.getTaskResultType();
-    }
+	@Override
+	public Class<?> getTaskResultType() {
+		return this.task.getTaskResultType();
+	}
 
-    protected Task task;
+	protected Task task;
 
-    @Override
-    protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
-        Object result = null;
-        Task taskBase = (Task) getPreparedClassOption(this.taskOption); 
-        //for each possible value of the parameter
-        for (int valueParameter = (int) this.firstValueOption.getValue();
-                valueParameter <= this.lastValueOption.getValue();
-                valueParameter += (int) this.incrementValueOption.getValue()) {
-            //Add parameter
-            this.task = (Task) ((MOAObject) taskBase).copy();
-            if (this.task instanceof EvaluateConceptDrift) {
-                String stream = ((EvaluateConceptDrift) this.task).streamOption.getValueAsCLIString();
-                ((EvaluateConceptDrift) this.task).streamOption.setValueViaCLIString(stream + " -" + streamParameterOption.getValue() + " " + valueParameter);
-            }
-            //Run task
-            result = this.task.doTask(monitor, repository);
-        }
-        return result;
-    }
+	@Override
+	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
+		Object result = null;
+		Task taskBase = (Task) getPreparedClassOption(this.taskOption);
+		// for each possible value of the parameter
+		for (int valueParameter = (int) this.firstValueOption.getValue(); valueParameter <= this.lastValueOption
+				.getValue(); valueParameter += (int) this.incrementValueOption.getValue()) {
+			// Add parameter
+			this.task = (Task) ((MOAObject) taskBase).copy();
+			if (this.task instanceof EvaluateConceptDrift) {
+				String stream = ((EvaluateConceptDrift) this.task).streamOption.getValueAsCLIString();
+				((EvaluateConceptDrift) this.task).streamOption
+						.setValueViaCLIString(stream + " -" + streamParameterOption.getValue() + " " + valueParameter);
+			}
+			// Run task
+			result = this.task.doTask(monitor, repository);
+		}
+		return result;
+	}
 }
diff --git a/moa/src/main/java/moa/tasks/RunTasks.java b/moa/src/main/java/moa/tasks/RunTasks.java
index 2cc8cfc01..21e0a91d8 100644
--- a/moa/src/main/java/moa/tasks/RunTasks.java
+++ b/moa/src/main/java/moa/tasks/RunTasks.java
@@ -16,7 +16,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks;
 
@@ -35,58 +35,58 @@
  */
 public class RunTasks extends MainTask {
 
-    @Override
-    public String getPurposeString() {
-        return "Runs several experiments modifying values of parameters.";
-    }
+	@Override
+	public String getPurposeString() {
+		return "Runs several experiments modifying values of parameters.";
+	}
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public ClassOption taskOption = new ClassOption("task", 't',
-            "Task to do.", Task.class, "EvaluatePrequential -l active.ALUncertainty -i 1000000 -d temp.txt");
+	public ClassOption taskOption = new ClassOption("task", 't', "Task to do.", Task.class,
+			"EvaluatePrequential -l active.ALUncertainty -i 1000000 -d temp.txt");
 
-    public StringOption classifierParameterOption = new StringOption("classifierParameter", 'p',
-            "Classifier parameter to vary.", "b");
+	public StringOption classifierParameterOption = new StringOption("classifierParameter", 'p',
+			"Classifier parameter to vary.", "b");
 
-    public FloatOption firstValueOption = new FloatOption("firstValue",
-            'f', "First value", 0.0);
+	public FloatOption firstValueOption = new FloatOption("firstValue", 'f', "First value", 0.0);
 
-    public FloatOption lastValueOption = new FloatOption("lastValue",
-            'l', "Last value", 1.0);
+	public FloatOption lastValueOption = new FloatOption("lastValue", 'l', "Last value", 1.0);
 
-    public FloatOption incrementValueOption = new FloatOption("incrementValue",
-            'i', "Increment value", 0.1);
+	public FloatOption incrementValueOption = new FloatOption("incrementValue", 'i', "Increment value", 0.1);
 
-    @Override
-    public Class<?> getTaskResultType() {
-        return this.task.getTaskResultType();
-    }
+	@Override
+	public Class<?> getTaskResultType() {
+		return this.task.getTaskResultType();
+	}
 
-    protected Task task;
+	protected Task task;
 
-    @Override
-    protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
-        Object result = null;
+	@Override
+	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
+		Object result = null;
 
-        String commandString = this.taskOption.getValueAsCLIString();
-        //for each possible value of the parameter
-        for (double valueParameter = this.firstValueOption.getValue();
-                valueParameter <= this.lastValueOption.getValue();
-                valueParameter += this.incrementValueOption.getValue()) {
-            //Add parameter
-            this.task = (Task) getPreparedClassOption(this.taskOption);
-            if (this.task instanceof AbstractEvaluatePrequential) {
-                String classifier = ((AbstractEvaluatePrequential) this.task).learnerOption.getValueAsCLIString();
-                ((AbstractEvaluatePrequential) this.task).learnerOption.setValueViaCLIString(classifier + " -" + classifierParameterOption.getValue() + " " + valueParameter);
-            }
-            if (this.task instanceof AbstractEvaluateInterleavedTestThenTrain) {
-                String classifier = ((AbstractEvaluateInterleavedTestThenTrain) this.task).learnerOption.getValueAsCLIString();
-                ((AbstractEvaluateInterleavedTestThenTrain) this.task).learnerOption.setValueViaCLIString(classifier + " -" + classifierParameterOption.getValue() + " " + valueParameter);
-            }
-            //Run task
-            result = this.task.doTask(monitor, repository);
-            //System.out.println(((AbstractOptionHandler) this.task).getCLICreationString(Task.class));
-        }
-        return result;
-    }
+		String commandString = this.taskOption.getValueAsCLIString();
+		// for each possible value of the parameter
+		for (double valueParameter = this.firstValueOption.getValue(); valueParameter <= this.lastValueOption
+				.getValue(); valueParameter += this.incrementValueOption.getValue()) {
+			// Add parameter
+			this.task = (Task) getPreparedClassOption(this.taskOption);
+			if (this.task instanceof AbstractEvaluatePrequential) {
+				String classifier = ((AbstractEvaluatePrequential) this.task).learnerOption.getValueAsCLIString();
+				((AbstractEvaluatePrequential) this.task).learnerOption.setValueViaCLIString(
+						classifier + " -" + classifierParameterOption.getValue() + " " + valueParameter);
+			}
+			if (this.task instanceof AbstractEvaluateInterleavedTestThenTrain) {
+				String classifier = ((AbstractEvaluateInterleavedTestThenTrain) this.task).learnerOption
+						.getValueAsCLIString();
+				((AbstractEvaluateInterleavedTestThenTrain) this.task).learnerOption.setValueViaCLIString(
+						classifier + " -" + classifierParameterOption.getValue() + " " + valueParameter);
+			}
+			// Run task
+			result = this.task.doTask(monitor, repository);
+			// System.out.println(((AbstractOptionHandler)
+			// this.task).getCLICreationString(Task.class));
+		}
+		return result;
+	}
 }
diff --git a/moa/src/main/java/moa/tasks/StandardTaskMonitor.java b/moa/src/main/java/moa/tasks/StandardTaskMonitor.java
index 7a6357356..437fd7727 100644
--- a/moa/src/main/java/moa/tasks/StandardTaskMonitor.java
+++ b/moa/src/main/java/moa/tasks/StandardTaskMonitor.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks;
 
@@ -27,119 +27,118 @@
  */
 public class StandardTaskMonitor implements TaskMonitor {
 
-    protected String currentActivityDescription = "";
-
-    protected double currentActivityFractionComplete = -1.0;
-
-    protected volatile boolean cancelFlag = false;
-
-    protected volatile boolean pauseFlag = false;
-
-    protected volatile boolean isComplete = false;
-
-    protected volatile boolean resultPreviewRequested = false;
-
-    protected volatile Object latestResultPreview = null;
-
-    protected volatile ResultPreviewListener resultPreviewer = null;
-
-    @Override
-    public void setCurrentActivity(String activityDescription,
-            double fracComplete) {
-        setCurrentActivityDescription(activityDescription);
-        setCurrentActivityFractionComplete(fracComplete);
-    }
-
-    @Override
-    public void setCurrentActivityDescription(String activity) {
-        this.currentActivityDescription = activity;
-    }
-
-    @Override
-    public void setCurrentActivityFractionComplete(double fracComplete) {
-        this.currentActivityFractionComplete = fracComplete;
-    }
-
-    @Override
-    public boolean taskShouldAbort() {
-        if (this.pauseFlag) {
-            try {
-                synchronized (this) {
-                    while (this.pauseFlag && !this.cancelFlag) {
-                        wait();
-                    }
-                }
-            } catch (InterruptedException e) {
-            }
-        }
-        return this.cancelFlag;
-    }
-
-    @Override
-    public String getCurrentActivityDescription() {
-        return this.currentActivityDescription;
-    }
-
-    @Override
-    public double getCurrentActivityFractionComplete() {
-        return this.currentActivityFractionComplete;
-    }
-
-    @Override
-    public boolean isCancelled() {
-        return this.cancelFlag;
-    }
-
-    @Override
-    public void requestCancel() {
-        this.cancelFlag = true;
-        requestResume();
-    }
-
-    @Override
-    public void requestPause() {
-        this.pauseFlag = true;
-    }
-
-    @Override
-    public synchronized void requestResume() {
-        this.pauseFlag = false;
-        notify();
-    }
-
-    @Override
-    public boolean isPaused() {
-        return this.pauseFlag;
-    }
-
-    @Override
-    public Object getLatestResultPreview() {
-        return this.latestResultPreview;
-    }
-
-    @Override
-    public void requestResultPreview() {
-        this.resultPreviewRequested = true;
-    }
-
-    @Override
-    public void requestResultPreview(ResultPreviewListener toInform) {
-        this.resultPreviewer = toInform;
-        this.resultPreviewRequested = true;
-    }
-
-    @Override
-    public boolean resultPreviewRequested() {
-        return this.resultPreviewRequested;
-    }
-
-    @Override
-    public synchronized void setLatestResultPreview(Object latestPreview) {
-        this.resultPreviewRequested = false;
-        this.latestResultPreview = latestPreview;
-        if (this.resultPreviewer != null) {
-            this.resultPreviewer.latestPreviewChanged();
-        }
-        this.resultPreviewer = null;
-    }
+	protected String currentActivityDescription = "";
+
+	protected double currentActivityFractionComplete = -1.0;
+
+	protected volatile boolean cancelFlag = false;
+
+	protected volatile boolean pauseFlag = false;
+
+	protected volatile boolean isComplete = false;
+
+	protected volatile boolean resultPreviewRequested = false;
+
+	protected volatile Object latestResultPreview = null;
+
+	protected volatile ResultPreviewListener resultPreviewer = null;
+
+	@Override
+	public void setCurrentActivity(String activityDescription, double fracComplete) {
+		setCurrentActivityDescription(activityDescription);
+		setCurrentActivityFractionComplete(fracComplete);
+	}
+
+	@Override
+	public void setCurrentActivityDescription(String activity) {
+		this.currentActivityDescription = activity;
+	}
+
+	@Override
+	public void setCurrentActivityFractionComplete(double fracComplete) {
+		this.currentActivityFractionComplete = fracComplete;
+	}
+
+	@Override
+	public boolean taskShouldAbort() {
+		if (this.pauseFlag) {
+			try {
+				synchronized (this) {
+					while (this.pauseFlag && !this.cancelFlag) {
+						wait();
+					}
+				}
+			} catch (InterruptedException e) {
+			}
+		}
+		return this.cancelFlag;
+	}
+
+	@Override
+	public String getCurrentActivityDescription() {
+		return this.currentActivityDescription;
+	}
+
+	@Override
+	public double getCurrentActivityFractionComplete() {
+		return this.currentActivityFractionComplete;
+	}
+
+	@Override
+	public boolean isCancelled() {
+		return this.cancelFlag;
+	}
+
+	@Override
+	public void requestCancel() {
+		this.cancelFlag = true;
+		requestResume();
+	}
+
+	@Override
+	public void requestPause() {
+		this.pauseFlag = true;
+	}
+
+	@Override
+	public synchronized void requestResume() {
+		this.pauseFlag = false;
+		notify();
+	}
+
+	@Override
+	public boolean isPaused() {
+		return this.pauseFlag;
+	}
+
+	@Override
+	public Object getLatestResultPreview() {
+		return this.latestResultPreview;
+	}
+
+	@Override
+	public void requestResultPreview() {
+		this.resultPreviewRequested = true;
+	}
+
+	@Override
+	public void requestResultPreview(ResultPreviewListener toInform) {
+		this.resultPreviewer = toInform;
+		this.resultPreviewRequested = true;
+	}
+
+	@Override
+	public boolean resultPreviewRequested() {
+		return this.resultPreviewRequested;
+	}
+
+	@Override
+	public synchronized void setLatestResultPreview(Object latestPreview) {
+		this.resultPreviewRequested = false;
+		this.latestResultPreview = latestPreview;
+		if (this.resultPreviewer != null) {
+			this.resultPreviewer.latestPreviewChanged();
+		}
+		this.resultPreviewer = null;
+	}
 }
diff --git a/moa/src/main/java/moa/tasks/Task.java b/moa/src/main/java/moa/tasks/Task.java
index 0e88ee24a..8b8b533c9 100644
--- a/moa/src/main/java/moa/tasks/Task.java
+++ b/moa/src/main/java/moa/tasks/Task.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks;
 
@@ -23,38 +23,36 @@
 import moa.core.ObjectRepository;
 
 /**
- * Interface representing a task. 
+ * Interface representing a task.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $ 
+ * @version $Revision: 7 $
  */
 public interface Task extends MOAObject {
 
-    /**
-     * Gets the result type of this task.
-     * Tasks can return LearningCurve, LearningEvaluation,
-     * Classifier, String, Instances..
-     *
-     * @return a class object of the result of this task
-     */
-    public Class<?> getTaskResultType();
+	/**
+	 * Gets the result type of this task. Tasks can return LearningCurve,
+	 * LearningEvaluation, Classifier, String, Instances..
+	 *
+	 * @return a class object of the result of this task
+	 */
+	Class<?> getTaskResultType();
 
-    /**
-     * This method performs this task,
-     * when TaskMonitor and ObjectRepository are no needed.
-     *
-     * @return an object with the result of this task
-     */
-    public Object doTask();
+	/**
+	 * This method performs this task, when TaskMonitor and ObjectRepository are no
+	 * needed.
+	 *
+	 * @return an object with the result of this task
+	 */
+	Object doTask();
 
-    /**
-     * This method performs this task.
-     * <code>AbstractTask</code> implements this method so all
-     * its extensions only need to implement <code>doTaskImpl</code>
-     *
-     * @param monitor the TaskMonitor to use
-     * @param repository  the ObjectRepository to use
-     * @return an object with the result of this task
-     */
-    public Object doTask(TaskMonitor monitor, ObjectRepository repository);
+	/**
+	 * This method performs this task. <code>AbstractTask</code> implements this
+	 * method so all its extensions only need to implement <code>doTaskImpl</code>
+	 *
+	 * @param monitor    the TaskMonitor to use
+	 * @param repository the ObjectRepository to use
+	 * @return an object with the result of this task
+	 */
+	Object doTask(TaskMonitor monitor, ObjectRepository repository);
 }
diff --git a/moa/src/main/java/moa/tasks/TaskCompletionListener.java b/moa/src/main/java/moa/tasks/TaskCompletionListener.java
index 825ec0d58..b9dea383e 100644
--- a/moa/src/main/java/moa/tasks/TaskCompletionListener.java
+++ b/moa/src/main/java/moa/tasks/TaskCompletionListener.java
@@ -15,24 +15,24 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks;
 
 /**
- * Interface representing a listener for the task in TaskThread to be completed. 
- * TaskThread fires that the task is completed
- * to all its listeners when it finishes to run its task.
+ * Interface representing a listener for the task in TaskThread to be completed.
+ * TaskThread fires that the task is completed to all its listeners when it
+ * finishes to run its task.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $ 
+ * @version $Revision: 7 $
  */
 public interface TaskCompletionListener {
 
-    /**
-     * The method to perform when the task finishes.
-     *
-     * @param task the TaskThead that this listener is listening
-     */
-    public void taskCompleted(TaskThread task);
+	/**
+	 * The method to perform when the task finishes.
+	 *
+	 * @param task the TaskThead that this listener is listening
+	 */
+	void taskCompleted(TaskThread task);
 }
diff --git a/moa/src/main/java/moa/tasks/TaskMonitor.java b/moa/src/main/java/moa/tasks/TaskMonitor.java
index 4cb9b733b..186f627ea 100644
--- a/moa/src/main/java/moa/tasks/TaskMonitor.java
+++ b/moa/src/main/java/moa/tasks/TaskMonitor.java
@@ -15,125 +15,124 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks;
 
 /**
- * Interface representing a task monitor. 
+ * Interface representing a task monitor.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
- * @version $Revision: 7 $ 
+ * @version $Revision: 7 $
  */
 public interface TaskMonitor {
 
-    /**
-     * Sets the description and the percentage done of the current activity.
-     *
-     * @param activity the description of the current activity
-     * @param fracComplete the percentage done of the current activity
-     */
-    public void setCurrentActivity(String activityDescription,
-            double fracComplete);
-
-    /**
-     * Sets the description of the current activity.
-     *
-     * @param activity the description of the current activity
-     */
-    public void setCurrentActivityDescription(String activity);
-
-    /**
-     * Sets the percentage done of the current activity
-     *
-     * @param fracComplete the percentage done of the current activity
-     */
-    public void setCurrentActivityFractionComplete(double fracComplete);
-
-    /**
-     * Gets whether the task should abort.
-     *
-     * @return true if the task should abort
-     */
-    public boolean taskShouldAbort();
-
-    /**
-     * Gets whether there is a request for preview the task result.
-     *
-     * @return true if there is a request for preview the task result
-     */
-    public boolean resultPreviewRequested();
-
-    /**
-     * Sets the current result to preview
-     *
-     * @param latestPreview the result to preview
-     */
-    public void setLatestResultPreview(Object latestPreview);
-
-    /**
-     * Gets the description of the current activity.
-     *
-     * @return the description of the current activity
-     */
-    public String getCurrentActivityDescription();
-
-    /**
-     * Gets the percentage done of the current activity
-     *
-     * @return the percentage done of the current activity
-     */
-    public double getCurrentActivityFractionComplete();
-
-    /**
-     * Requests the task monitored to pause.
-     *
-     */
-    public void requestPause();
-
-    /**
-     * Requests the task monitored to resume.
-     *
-     */
-    public void requestResume();
-
-    /**
-     * Requests the task monitored to cancel.
-     *
-     */
-    public void requestCancel();
-
-    /**
-     * Gets whether the task monitored is paused.
-     *
-     * @return true if the task is paused
-     */
-    public boolean isPaused();
-
-    /**
-     * Gets whether the task monitored is cancelled.
-     *
-     * @return true if the task is cancelled
-     */
-    public boolean isCancelled();
-
-    /**
-     * Requests to preview the task result.
-     *
-     */
-    public void requestResultPreview();
-
-    /**
-     * Requests to preview the task result.
-     *
-     * @param toInform the listener of the changes in the preview of the result
-     */
-    public void requestResultPreview(ResultPreviewListener toInform);
-
-    /**
-     * Gets the current result to preview
-     *
-     * @return the result to preview
-     */
-    public Object getLatestResultPreview();
+	/**
+	 * Sets the description and the percentage done of the current activity.
+	 *
+	 * @param activity     the description of the current activity
+	 * @param fracComplete the percentage done of the current activity
+	 */
+	void setCurrentActivity(String activityDescription, double fracComplete);
+
+	/**
+	 * Sets the description of the current activity.
+	 *
+	 * @param activity the description of the current activity
+	 */
+	void setCurrentActivityDescription(String activity);
+
+	/**
+	 * Sets the percentage done of the current activity
+	 *
+	 * @param fracComplete the percentage done of the current activity
+	 */
+	void setCurrentActivityFractionComplete(double fracComplete);
+
+	/**
+	 * Gets whether the task should abort.
+	 *
+	 * @return true if the task should abort
+	 */
+	boolean taskShouldAbort();
+
+	/**
+	 * Gets whether there is a request for preview the task result.
+	 *
+	 * @return true if there is a request for preview the task result
+	 */
+	boolean resultPreviewRequested();
+
+	/**
+	 * Sets the current result to preview
+	 *
+	 * @param latestPreview the result to preview
+	 */
+	void setLatestResultPreview(Object latestPreview);
+
+	/**
+	 * Gets the description of the current activity.
+	 *
+	 * @return the description of the current activity
+	 */
+	String getCurrentActivityDescription();
+
+	/**
+	 * Gets the percentage done of the current activity
+	 *
+	 * @return the percentage done of the current activity
+	 */
+	double getCurrentActivityFractionComplete();
+
+	/**
+	 * Requests the task monitored to pause.
+	 *
+	 */
+	void requestPause();
+
+	/**
+	 * Requests the task monitored to resume.
+	 *
+	 */
+	void requestResume();
+
+	/**
+	 * Requests the task monitored to cancel.
+	 *
+	 */
+	void requestCancel();
+
+	/**
+	 * Gets whether the task monitored is paused.
+	 *
+	 * @return true if the task is paused
+	 */
+	boolean isPaused();
+
+	/**
+	 * Gets whether the task monitored is cancelled.
+	 *
+	 * @return true if the task is cancelled
+	 */
+	boolean isCancelled();
+
+	/**
+	 * Requests to preview the task result.
+	 *
+	 */
+	void requestResultPreview();
+
+	/**
+	 * Requests to preview the task result.
+	 *
+	 * @param toInform the listener of the changes in the preview of the result
+	 */
+	void requestResultPreview(ResultPreviewListener toInform);
+
+	/**
+	 * Gets the current result to preview
+	 *
+	 * @return the result to preview
+	 */
+	Object getLatestResultPreview();
 }
diff --git a/moa/src/main/java/moa/tasks/TaskThread.java b/moa/src/main/java/moa/tasks/TaskThread.java
index c1dbde4b6..946a302cb 100644
--- a/moa/src/main/java/moa/tasks/TaskThread.java
+++ b/moa/src/main/java/moa/tasks/TaskThread.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks;
 
@@ -32,182 +32,178 @@
  */
 public class TaskThread extends Thread {
 
-    public static enum Status {
-
-        NOT_STARTED, RUNNING, PAUSED, CANCELLING, CANCELLED, COMPLETED, FAILED
-    }
-
-    protected Task runningTask;
-
-    protected volatile Status currentStatus;
-
-    protected TaskMonitor taskMonitor;
-
-    protected ObjectRepository repository;
-
-    protected Object finalResult;
-
-    protected long taskStartTime;
-
-    protected long taskEndTime;
-
-    protected double latestPreviewGrabTime = 0.0;
-
-    CopyOnWriteArraySet<TaskCompletionListener> completionListeners = new CopyOnWriteArraySet<TaskCompletionListener>();
-
-    public TaskThread(Task toRun) {
-        this(toRun, null);
-    }
-
-    public TaskThread(Task toRun, ObjectRepository repository) {
-        this.runningTask = toRun;
-        this.repository = repository;
-        this.currentStatus = Status.NOT_STARTED;
-        this.taskMonitor = new StandardTaskMonitor();
-        this.taskMonitor.setCurrentActivityDescription("Running task " + toRun);
-    }
-
-    @Override
-    public void run() {
-        TimingUtils.enablePreciseTiming();
-        this.taskStartTime = TimingUtils.getNanoCPUTimeOfThread(getId());
-        try {
-            this.currentStatus = Status.RUNNING;
-            this.finalResult = this.runningTask.doTask(this.taskMonitor,
-                    this.repository);
-            this.currentStatus = this.taskMonitor.isCancelled() ? Status.CANCELLED
-                    : Status.COMPLETED;
-        } catch (Throwable ex) {
-            this.currentStatus = Status.FAILED;
-            this.finalResult = new FailedTaskReport(ex);
-        }
-        this.taskEndTime = TimingUtils.getNanoCPUTimeOfThread(getId());
-        fireTaskCompleted();
-        this.taskMonitor.setLatestResultPreview(null); // free preview memory
-    }
-
-    public synchronized void pauseTask() {
-        if (this.currentStatus == Status.RUNNING) {
-            this.taskMonitor.requestPause();
-            this.currentStatus = Status.PAUSED;
-        }
-    }
-
-    public synchronized void resumeTask() {
-        if (this.currentStatus == Status.PAUSED) {
-            this.taskMonitor.requestResume();
-            this.currentStatus = Status.RUNNING;
-        }
-    }
-
-    public synchronized void cancelTask() {
-        if ((this.currentStatus == Status.RUNNING)
-                || (this.currentStatus == Status.PAUSED)) {
-            this.taskMonitor.requestCancel();
-            this.currentStatus = Status.CANCELLING;
-        }
-    }
-
-    public double getCPUSecondsElapsed() {
-        double secondsElapsed = 0.0;
-        if (this.currentStatus == Status.NOT_STARTED) {
-            secondsElapsed = 0.0;
-        } else if (isComplete()) {
-            secondsElapsed = TimingUtils.nanoTimeToSeconds(this.taskEndTime
-                    - this.taskStartTime);
-        } else {
-            secondsElapsed = TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfThread(getId())
-                    - this.taskStartTime);
-        }
-        return secondsElapsed > 0.0 ? secondsElapsed : 0.0;
-    }
-
-    public Task getTask() {
-        return this.runningTask;
-    }
-
-    public String getCurrentStatusString() {
-        switch (this.currentStatus) {
-            case NOT_STARTED:
-                return "not started";
-            case RUNNING:
-                return "running";
-            case PAUSED:
-                return "paused";
-            case CANCELLING:
-                return "cancelling";
-            case CANCELLED:
-                return "cancelled";
-            case COMPLETED:
-                return "completed";
-            case FAILED:
-                return "failed";
-        }
-        return "unknown";
-    }
-
-    public String getCurrentActivityString() {
-        return (isComplete() || (this.currentStatus == Status.NOT_STARTED)) ? ""
-                : this.taskMonitor.getCurrentActivityDescription();
-    }
-
-    public double getCurrentActivityFracComplete() {
-        switch (this.currentStatus) {
-            case NOT_STARTED:
-                return 0.0;
-            case RUNNING:
-            case PAUSED:
-            case CANCELLING:
-                return this.taskMonitor.getCurrentActivityFractionComplete();
-            case CANCELLED:
-            case COMPLETED:
-            case FAILED:
-                return 1.0;
-        }
-        return 0.0;
-    }
-
-    public boolean isComplete() {
-        return ((this.currentStatus == Status.CANCELLED)
-                || (this.currentStatus == Status.COMPLETED) || (this.currentStatus == Status.FAILED));
-    }
+	public enum Status {
+
+		NOT_STARTED, RUNNING, PAUSED, CANCELLING, CANCELLED, COMPLETED, FAILED
+	}
+
+	protected Task runningTask;
+
+	protected volatile Status currentStatus;
+
+	protected TaskMonitor taskMonitor;
+
+	protected ObjectRepository repository;
+
+	protected Object finalResult;
+
+	protected long taskStartTime;
+
+	protected long taskEndTime;
+
+	protected double latestPreviewGrabTime = 0.0;
+
+	CopyOnWriteArraySet<TaskCompletionListener> completionListeners = new CopyOnWriteArraySet<>();
+
+	public TaskThread(Task toRun) {
+		this(toRun, null);
+	}
+
+	public TaskThread(Task toRun, ObjectRepository repository) {
+		this.runningTask = toRun;
+		this.repository = repository;
+		this.currentStatus = Status.NOT_STARTED;
+		this.taskMonitor = new StandardTaskMonitor();
+		this.taskMonitor.setCurrentActivityDescription("Running task " + toRun);
+	}
+
+	@Override
+	public void run() {
+		TimingUtils.enablePreciseTiming();
+		this.taskStartTime = TimingUtils.getNanoCPUTimeOfThread(getId());
+		try {
+			this.currentStatus = Status.RUNNING;
+			this.finalResult = this.runningTask.doTask(this.taskMonitor, this.repository);
+			this.currentStatus = this.taskMonitor.isCancelled() ? Status.CANCELLED : Status.COMPLETED;
+		} catch (Throwable ex) {
+			this.currentStatus = Status.FAILED;
+			this.finalResult = new FailedTaskReport(ex);
+		}
+		this.taskEndTime = TimingUtils.getNanoCPUTimeOfThread(getId());
+		fireTaskCompleted();
+		this.taskMonitor.setLatestResultPreview(null); // free preview memory
+	}
+
+	public synchronized void pauseTask() {
+		if (this.currentStatus == Status.RUNNING) {
+			this.taskMonitor.requestPause();
+			this.currentStatus = Status.PAUSED;
+		}
+	}
+
+	public synchronized void resumeTask() {
+		if (this.currentStatus == Status.PAUSED) {
+			this.taskMonitor.requestResume();
+			this.currentStatus = Status.RUNNING;
+		}
+	}
+
+	public synchronized void cancelTask() {
+		if ((this.currentStatus == Status.RUNNING) || (this.currentStatus == Status.PAUSED)) {
+			this.taskMonitor.requestCancel();
+			this.currentStatus = Status.CANCELLING;
+		}
+	}
+
+	public double getCPUSecondsElapsed() {
+		double secondsElapsed = 0.0;
+		if (this.currentStatus == Status.NOT_STARTED) {
+			secondsElapsed = 0.0;
+		} else if (isComplete()) {
+			secondsElapsed = TimingUtils.nanoTimeToSeconds(this.taskEndTime - this.taskStartTime);
+		} else {
+			secondsElapsed = TimingUtils
+					.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfThread(getId()) - this.taskStartTime);
+		}
+		return secondsElapsed > 0.0 ? secondsElapsed : 0.0;
+	}
+
+	public Task getTask() {
+		return this.runningTask;
+	}
+
+	public String getCurrentStatusString() {
+		switch (this.currentStatus) {
+		case NOT_STARTED:
+			return "not started";
+		case RUNNING:
+			return "running";
+		case PAUSED:
+			return "paused";
+		case CANCELLING:
+			return "cancelling";
+		case CANCELLED:
+			return "cancelled";
+		case COMPLETED:
+			return "completed";
+		case FAILED:
+			return "failed";
+		}
+		return "unknown";
+	}
+
+	public String getCurrentActivityString() {
+		return (isComplete() || (this.currentStatus == Status.NOT_STARTED)) ? ""
+				: this.taskMonitor.getCurrentActivityDescription();
+	}
+
+	public double getCurrentActivityFracComplete() {
+		switch (this.currentStatus) {
+		case NOT_STARTED:
+			return 0.0;
+		case RUNNING:
+		case PAUSED:
+		case CANCELLING:
+			return this.taskMonitor.getCurrentActivityFractionComplete();
+		case CANCELLED:
+		case COMPLETED:
+		case FAILED:
+			return 1.0;
+		}
+		return 0.0;
+	}
+
+	public boolean isComplete() {
+		return ((this.currentStatus == Status.CANCELLED) || (this.currentStatus == Status.COMPLETED)
+				|| (this.currentStatus == Status.FAILED));
+	}
 
 	public boolean isFailed() {
 		return currentStatus == Status.FAILED;
 	}
-	
+
 	public boolean isCancelled() {
 		return currentStatus == Status.CANCELLED;
 	}
 
-    public Object getFinalResult() {
-        return this.finalResult;
-    }
+	public Object getFinalResult() {
+		return this.finalResult;
+	}
 
-    public void addTaskCompletionListener(TaskCompletionListener tcl) {
-        this.completionListeners.add(tcl);
-    }
+	public void addTaskCompletionListener(TaskCompletionListener tcl) {
+		this.completionListeners.add(tcl);
+	}
 
-    public void removeTaskCompletionListener(TaskCompletionListener tcl) {
-        this.completionListeners.remove(tcl);
-    }
+	public void removeTaskCompletionListener(TaskCompletionListener tcl) {
+		this.completionListeners.remove(tcl);
+	}
 
-    protected void fireTaskCompleted() {
-        for (TaskCompletionListener listener : this.completionListeners) {
-            listener.taskCompleted(this);
-        }
-    }
+	protected void fireTaskCompleted() {
+		for (TaskCompletionListener listener : this.completionListeners) {
+			listener.taskCompleted(this);
+		}
+	}
 
-    public void getPreview(ResultPreviewListener previewer) {
-        this.taskMonitor.requestResultPreview(previewer);
-        this.latestPreviewGrabTime = getCPUSecondsElapsed();
-    }
+	public void getPreview(ResultPreviewListener previewer) {
+		this.taskMonitor.requestResultPreview(previewer);
+		this.latestPreviewGrabTime = getCPUSecondsElapsed();
+	}
 
-    public Object getLatestResultPreview() {
-        return this.taskMonitor.getLatestResultPreview();
-    }
+	public Object getLatestResultPreview() {
+		return this.taskMonitor.getLatestResultPreview();
+	}
 
-    public double getLatestPreviewGrabTimeSeconds() {
-        return this.latestPreviewGrabTime;
-    }
+	public double getLatestPreviewGrabTimeSeconds() {
+		return this.latestPreviewGrabTime;
+	}
 }
diff --git a/moa/src/main/java/moa/tasks/auxiliar/AuxiliarMainTask.java b/moa/src/main/java/moa/tasks/auxiliar/AuxiliarMainTask.java
index 63a139b1c..5febb8051 100644
--- a/moa/src/main/java/moa/tasks/auxiliar/AuxiliarMainTask.java
+++ b/moa/src/main/java/moa/tasks/auxiliar/AuxiliarMainTask.java
@@ -33,14 +33,16 @@
  */
 public abstract class AuxiliarMainTask extends MainTask {
 
-    protected ArrayList<ClusterEvent> events;
+	protected ArrayList<ClusterEvent> events;
+
+	@Override
+	protected void setEventsList(ArrayList<ClusterEvent> events) {
+		this.events = events;
+	}
+
+	@Override
+	public ArrayList<ClusterEvent> getEventsList() {
+		return this.events;
+	}
 
-    protected void setEventsList(ArrayList<ClusterEvent> events) {
-        this.events = events;
-    }
-    
-    public ArrayList<ClusterEvent> getEventsList() {
-        return this.events;
-    }
-    
 }
diff --git a/moa/src/main/java/moa/tasks/auxiliar/EvaluateOnlineRecommender.java b/moa/src/main/java/moa/tasks/auxiliar/EvaluateOnlineRecommender.java
index ab4567e24..0a6ab22f0 100644
--- a/moa/src/main/java/moa/tasks/auxiliar/EvaluateOnlineRecommender.java
+++ b/moa/src/main/java/moa/tasks/auxiliar/EvaluateOnlineRecommender.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks.auxiliar;
 
@@ -32,14 +32,18 @@
 import moa.tasks.TaskMonitor;
 
 /**
- * Test for evaluating a recommender by training and periodically testing 
- * on samples from a rating dataset. When finished, it will show the learning
- * curve of the recommender rating predictor.
+ * Test for evaluating a recommender by training and periodically testing on
+ * samples from a rating dataset. When finished, it will show the learning curve
+ * of the recommender rating predictor.
  *
- * <p>Parameters:</p>
- * <ul>  
- * <li> d: dataset - the dataset to be used to train/test the rating predictor.</li>
- * <li> f: sample frequency - the frequency in which a rating from the dataset will be used to test the model </li>
+ * <p>
+ * Parameters:
+ * </p>
+ * <ul>
+ * <li>d: dataset - the dataset to be used to train/test the rating
+ * predictor.</li>
+ * <li>f: sample frequency - the frequency in which a rating from the dataset
+ * will be used to test the model</li>
  * </ul>
  *
  * @author Alex Catarineu (a.catarineu@gmail.com)
@@ -47,99 +51,86 @@
  */
 public class EvaluateOnlineRecommender extends AuxiliarMainTask {
 
-    @Override
-    public String getPurposeString() {
-        return "Evaluates a online reccommender system.";
-    }
+	@Override
+	public String getPurposeString() {
+		return "Evaluates a online reccommender system.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption datasetOption = new ClassOption("dataset", 'd', "Dataset to evaluate.", Dataset.class,
+			"moa.recommender.dataset.impl.MovielensDataset");
+
+	public ClassOption ratingPredictorOption = new ClassOption("ratingPredictor", 's',
+			"Rating Predictor to evaluate on.", RatingPredictor.class, "moa.recommender.predictor.BRISMFPredictor");
+
+	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency", 'f',
+			"How many instances between samples of the learning performance.", 100, 0, Integer.MAX_VALUE);
 
-    private static final long serialVersionUID = 1L;
+	public EvaluateOnlineRecommender() {
+	}
 
-    public ClassOption datasetOption = new ClassOption("dataset", 'd',
-            "Dataset to evaluate.", Dataset.class, "moa.recommender.dataset.impl.MovielensDataset");
+	@Override
+	public Class<?> getTaskResultType() {
+		return LearningCurve.class;
+	}
 
-    public ClassOption ratingPredictorOption = new ClassOption("ratingPredictor", 's',
-            "Rating Predictor to evaluate on.", RatingPredictor.class,
-            "moa.recommender.predictor.BRISMFPredictor");
-    
-    public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
-            'f',
-            "How many instances between samples of the learning performance.",
-            100, 0, Integer.MAX_VALUE);
+	@Override
+	public Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
 
-    public EvaluateOnlineRecommender() {
-    }
+		Dataset d = (Dataset) getPreparedClassOption(this.datasetOption);
+		RatingPredictor rp = (RatingPredictor) getPreparedClassOption(this.ratingPredictorOption);
+		LearningCurve learningCurve = new LearningCurve("n");
+		RecommenderData data = rp.getData();
+		data.clear();
+		data.disableUpdates(false);
+		long start = System.currentTimeMillis();
+		long evalTime = 0;
+		double sum = 0;
+		int n = 0;
+		// ArrayList<TestMetric> metrics = new ArrayList<TestMetric>();
+		int sampleFrequency = this.sampleFrequencyOption.getValue();
+		int count = 0;
+		while (d.next())
+			++count;
+		d.reset();
+		while (d.next()) {
+			Integer user = d.curUserID();
+			Integer item = d.curItemID();
+			Double rating = d.curRating();
+			long startPredTime = System.currentTimeMillis();
+			double pred = rp.predictRating(user, item);
+			sum += Math.pow(pred - rating, 2);
+			evalTime += System.currentTimeMillis() - startPredTime;
+			data.setRating(user, item, rating);
+			// System.out.println(data.countRatingsItem(item) + " " +
+			// data.countRatingsUser(user));
+			// if (n++%100 == 99) metrics.add(new TestMetric("RMSE (" + n +")",
+			// Math.sqrt(sum/(double)n)));
+			n++;
+			if (n % sampleFrequency == sampleFrequency - 1) {
+				if (monitor.taskShouldAbort()) {
+					return null;
+				}
+				monitor.setCurrentActivityFractionComplete((double) n / (double) count);
+				learningCurve.insertEntry(new LearningEvaluation(
+						new Measurement[] { new Measurement("n", n), new Measurement("RMSE", Math.sqrt(sum / n)),
+								new Measurement("trainingTime",
+										(int) ((System.currentTimeMillis() - start - evalTime) / 1000)),
+								new Measurement("evalTime", (int) (evalTime / 1000)) }));
+				if (monitor.resultPreviewRequested()) {
+					monitor.setLatestResultPreview(learningCurve.headerToString() + "\n"
+							+ learningCurve.entryToString(learningCurve.numEntries() - 1));
+				}
+			}
+		}
+		// System.out.println(n + " " + Math.sqrt(sum/(double)n));
+		// metrics.add(new TestMetric("RMSE (" + n +")", Math.sqrt(sum/(double)n)));
+		// long trainingTime = System.currentTimeMillis() - start - evalTime;
+		// return new TestStatistics((int)(trainingTime/1000),
+		// (int)(evalTime/1000),
+		// metrics.toArray(new TestMetric[metrics.size()]));
 
-    @Override
-    public Class<?> getTaskResultType() {
-        return LearningCurve.class;
-    }
-    
-    @Override
-    public Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
-        
-        Dataset d = (Dataset) getPreparedClassOption(this.datasetOption);
-        RatingPredictor rp = (RatingPredictor)getPreparedClassOption(this.ratingPredictorOption);
-        LearningCurve learningCurve = new LearningCurve("n");
-        RecommenderData data = rp.getData();
-        data.clear();
-        data.disableUpdates(false);
-        long start = System.currentTimeMillis();
-        long evalTime = 0;
-        double sum = 0;
-        int n = 0;
-        //ArrayList<TestMetric> metrics = new ArrayList<TestMetric>();
-        int sampleFrequency = this.sampleFrequencyOption.getValue();
-        int count = 0;
-        while (d.next())
-          ++count;
-        d.reset();
-        while (d.next()) {
-            Integer user = d.curUserID();
-            Integer item = d.curItemID();
-            Double rating = d.curRating();
-            long startPredTime = System.currentTimeMillis();
-            double pred = rp.predictRating(user, item);
-            sum += Math.pow(pred - rating, 2);
-            evalTime += System.currentTimeMillis() - startPredTime;
-            data.setRating(user, item, rating);
-            //System.out.println(data.countRatingsItem(item) + " " + data.countRatingsUser(user));
-            //if (n++%100 == 99) metrics.add(new TestMetric("RMSE (" + n +")", Math.sqrt(sum/(double)n)));
-            n++;
-            if (n%sampleFrequency == sampleFrequency-1) {
-               if (monitor.taskShouldAbort()) {
-                    return null;
-                }
-                monitor.setCurrentActivityFractionComplete((double)n/(double)count);
-                learningCurve.insertEntry(new LearningEvaluation(
-                        new Measurement[]{
-                            new Measurement(
-                            "n",
-                            n),
-                            new Measurement(
-                            "RMSE",
-                            Math.sqrt(sum/(double)n)),
-                            new Measurement(
-                            "trainingTime",
-                            (int)((System.currentTimeMillis() - start - evalTime)/1000)),
-                            new Measurement(
-                            "evalTime",
-                            (int)(evalTime/1000))
-                        }
-                         ));
-                if (monitor.resultPreviewRequested()) {
-                    monitor.setLatestResultPreview(learningCurve.headerToString() + "\n" +
-                      learningCurve.entryToString(learningCurve.numEntries() - 1));
-                }
-            }
-        }
-        //System.out.println(n + " " + Math.sqrt(sum/(double)n));
-        //metrics.add(new TestMetric("RMSE (" + n +")", Math.sqrt(sum/(double)n)));
-       // long trainingTime = System.currentTimeMillis() - start - evalTime;
-        //return new TestStatistics((int)(trainingTime/1000),
-        //        (int)(evalTime/1000),
-        //        metrics.toArray(new TestMetric[metrics.size()]));
-        
-       
-        return learningCurve;
-    }
+		return learningCurve;
+	}
 }
diff --git a/moa/src/main/java/moa/tasks/auxiliar/MeasureStreamSpeed.java b/moa/src/main/java/moa/tasks/auxiliar/MeasureStreamSpeed.java
index 2aeab46e4..b77af1548 100644
--- a/moa/src/main/java/moa/tasks/auxiliar/MeasureStreamSpeed.java
+++ b/moa/src/main/java/moa/tasks/auxiliar/MeasureStreamSpeed.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks.auxiliar;
 
@@ -37,43 +37,38 @@
  */
 public class MeasureStreamSpeed extends AuxiliarMainTask {
 
-    @Override
-    public String getPurposeString() {
-        return "Measures the speed of a stream.";
-    }
+	@Override
+	public String getPurposeString() {
+		return "Measures the speed of a stream.";
+	}
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public ClassOption streamOption = new ClassOption("stream", 's',
-            "Stream to measure.", ExampleStream.class,
-            "generators.RandomTreeGenerator");
+	public ClassOption streamOption = new ClassOption("stream", 's', "Stream to measure.", ExampleStream.class,
+			"generators.RandomTreeGenerator");
 
-    public IntOption generateSizeOption = new IntOption("generateSize", 'g',
-            "Number of examples.", 10000000, 0, Integer.MAX_VALUE);
+	public IntOption generateSizeOption = new IntOption("generateSize", 'g', "Number of examples.", 10000000, 0,
+			Integer.MAX_VALUE);
 
-    @Override
-    protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
-        TimingUtils.enablePreciseTiming();
-        int numInstances = 0;
-        ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
-        long genStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-        while (numInstances < this.generateSizeOption.getValue()) {
-            stream.nextInstance();
-            numInstances++;
-        }
-        double genTime = TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread()
-                - genStartTime);
-        return new LearningEvaluation(
-                new Measurement[]{
-                    new Measurement("Number of instances generated",
-                    numInstances),
-                    new Measurement("Time elapsed", genTime),
-                    new Measurement("Instances per second", numInstances
-                    / genTime)});
-    }
+	@Override
+	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
+		TimingUtils.enablePreciseTiming();
+		int numInstances = 0;
+		ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
+		long genStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+		while (numInstances < this.generateSizeOption.getValue()) {
+			stream.nextInstance();
+			numInstances++;
+		}
+		double genTime = TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread() - genStartTime);
+		return new LearningEvaluation(
+				new Measurement[] { new Measurement("Number of instances generated", numInstances),
+						new Measurement("Time elapsed", genTime),
+						new Measurement("Instances per second", numInstances / genTime) });
+	}
 
-    @Override
-    public Class<?> getTaskResultType() {
-        return LearningEvaluation.class;
-    }
+	@Override
+	public Class<?> getTaskResultType() {
+		return LearningEvaluation.class;
+	}
 }
diff --git a/moa/src/main/java/moa/tasks/auxiliar/WriteMultipleStreamsToARFF.java b/moa/src/main/java/moa/tasks/auxiliar/WriteMultipleStreamsToARFF.java
index ec9efc835..47643fa2b 100644
--- a/moa/src/main/java/moa/tasks/auxiliar/WriteMultipleStreamsToARFF.java
+++ b/moa/src/main/java/moa/tasks/auxiliar/WriteMultipleStreamsToARFF.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks.auxiliar;
 
@@ -39,119 +39,102 @@
  *
  * @author Richard Hugh Moulton
  */
-public class WriteMultipleStreamsToARFF extends AuxiliarMainTask
-{
+public class WriteMultipleStreamsToARFF extends AuxiliarMainTask {
 
 	private static final long serialVersionUID = 4687495597494400174L;
 
-	// 121 prime and semi-prime numbers to use as the seeds for random number generators
-	private static final int[] primesAndBiprimes = {0,1,2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,
-			 61,67,71,73,79,83,89,97,101,103,107,109,113,127,
-			 131,137,139,149,151,157,163,167,173,179,181,191,
-			 193,197,199,211,223,227,229,233,239,241,251,257,
-			 263,269,271,4,6,9,10,14,15,21,22,25,26,33,34,35,
-			 38,39,46,49,51,55,57,58,62,65,69,74,77,82,85,86,
-			 87,91,93,94,95,106,111,115,118,119,121,122,123,129,
-			 133,134,141,142,143,145,146,155,158,159,161,166,
-			 169,177,178,183,185,187};
-	
+	// 121 prime and semi-prime numbers to use as the seeds for random number
+	// generators
+	private static final int[] primesAndBiprimes = { 0, 1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53,
+			59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167,
+			173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 4, 6, 9, 10,
+			14, 15, 21, 22, 25, 26, 33, 34, 35, 38, 39, 46, 49, 51, 55, 57, 58, 62, 65, 69, 74, 77, 82, 85, 86, 87, 91,
+			93, 94, 95, 106, 111, 115, 118, 119, 121, 122, 123, 129, 133, 134, 141, 142, 143, 145, 146, 155, 158, 159,
+			161, 166, 169, 177, 178, 183, 185, 187 };
+
 	@Override
-	public String getPurposeString()
-	{
+	public String getPurposeString() {
 		return "Outputs multiple streams to their respective ARFF files.";
 	}
 
-	public ClassOption streamOption = new ClassOption("stream", 's',
-			"Stream to write.", InstanceStream.class,
+	public ClassOption streamOption = new ClassOption("stream", 's', "Stream to write.", InstanceStream.class,
 			"generators.RandomTreeGenerator");
 
-	public FileOption arffFileOption = new FileOption("arffFile", 'a',
-			"Destination ARFF file.", null, "arff", true);
+	public FileOption arffFileOption = new FileOption("arffFile", 'a', "Destination ARFF file.", null, "arff", true);
 
 	public IntOption maxInstancesOption = new IntOption("maxInstances", 'm',
-			"Maximum number of instances to write to file.", 10000000, 0,
-			Integer.MAX_VALUE);
+			"Maximum number of instances to write to file.", 10000000, 0, Integer.MAX_VALUE);
 
-	public FlagOption suppressHeaderOption = new FlagOption("suppressHeader",
-			'h', "Suppress header from output.");
+	public FlagOption suppressHeaderOption = new FlagOption("suppressHeader", 'h', "Suppress header from output.");
 
 	public IntOption numStreamsOption = new IntOption("numStreams", 'n',
 			"Number of streams to generate and write to file.", 100, 0, Integer.MAX_VALUE);
-	
+
 	public FlagOption randomFlagOne = new FlagOption("randomFlagOne", 'f',
 			"Check in order to provide the first random option with different seeds.");
-	
+
 	public StringOption randomOneOption = new StringOption("randomOptionOne", '1',
-            "Random option to provide with different seed values.", "m");
-	
+			"Random option to provide with different seed values.", "m");
+
 	public FlagOption randomFlagTwo = new FlagOption("randomFlagTwo", 'F',
 			"Check in order to provide the second random option with different seeds.");
-	
+
 	public StringOption randomTwoOption = new StringOption("randomOptionTwo", '2',
-            "Random option to provide with different seed values.", "i");
+			"Random option to provide with different seed values.", "i");
 
 	protected InstanceStream stream;
-	
-	
+
 	@Override
-	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository)
-	{
-		// Store the original values of these two options, which may be altered during the remainder of this task.
+	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
+		// Store the original values of these two options, which may be altered during
+		// the remainder of this task.
 		String streamCLI = this.streamOption.getValueAsCLIString();
 		String fileCLI = this.arffFileOption.getValueAsCLIString();
 		stream = (InstanceStream) getPreparedClassOption(this.streamOption);
-		
+
 		// For each stream to be created...
-		for(int i = 0 ; i < this.numStreamsOption.getValue() ; i++)
-		{
+		for (int i = 0; i < this.numStreamsOption.getValue(); i++) {
 			// ...provide different seeds for each of the selected random processes...
 			String s = streamCLI;
-			if(this.randomFlagOne.isSet())
-			{
-				s = s.concat(" -"+randomOneOption.getValue()+" "+WriteMultipleStreamsToARFF.primesAndBiprimes[i]);
+			if (this.randomFlagOne.isSet()) {
+				s = s.concat(" -" + randomOneOption.getValue() + " " + WriteMultipleStreamsToARFF.primesAndBiprimes[i]);
 			}
-			if(this.randomFlagTwo.isSet())
-			{
-				s = s.concat(" -"+randomTwoOption.getValue()+" "+
-			WriteMultipleStreamsToARFF.primesAndBiprimes[i/WriteMultipleStreamsToARFF.primesAndBiprimes.length]);
+			if (this.randomFlagTwo.isSet()) {
+				s = s.concat(" -" + randomTwoOption.getValue() + " " + WriteMultipleStreamsToARFF.primesAndBiprimes[i
+						/ WriteMultipleStreamsToARFF.primesAndBiprimes.length]);
 			}
 			this.streamOption.setValueViaCLIString(s);
-			
+
 			// ...update the file name of the ARFF file to output...
 			s = fileCLI;
-			if(s.substring(s.length()-5, s.length()).equals(".arff"))
-			{
-				s = s.substring(0, s.length()-5);
+			if (s.substring(s.length() - 5, s.length()).equals(".arff")) {
+				s = s.substring(0, s.length() - 5);
 			}
-			s = s.concat("n"+i+".arff");
+			s = s.concat("n" + i + ".arff");
 			this.arffFileOption.setValueViaCLIString(s);
 			File destFile = this.arffFileOption.getFile();
-			
+
 			// ...and attempt to write the file.
-			if (destFile != null)
-			{
-				try
-				{
+			if (destFile != null) {
+				try {
 					Writer w = new BufferedWriter(new FileWriter(destFile));
-					System.out.println("Writing stream to ARFF: "+this.streamOption.getValueAsCLIString()+" to "+this.arffFileOption.getValueAsCLIString());
-					monitor.setCurrentActivityDescription("Writing stream to ARFF: "+this.streamOption.getValueAsCLIString()+" to "+this.arffFileOption.getValueAsCLIString());
-					if (!this.suppressHeaderOption.isSet())
-					{
+					System.out.println("Writing stream to ARFF: " + this.streamOption.getValueAsCLIString() + " to "
+							+ this.arffFileOption.getValueAsCLIString());
+					monitor.setCurrentActivityDescription(
+							"Writing stream to ARFF: " + this.streamOption.getValueAsCLIString() + " to "
+									+ this.arffFileOption.getValueAsCLIString());
+					if (!this.suppressHeaderOption.isSet()) {
 						w.write(stream.getHeader().toString());
 						w.write("\n");
 					}
 					int numWritten = 0;
-					while ((numWritten < this.maxInstancesOption.getValue())
-							&& stream.hasMoreInstances())
-					{
+					while ((numWritten < this.maxInstancesOption.getValue()) && stream.hasMoreInstances()) {
 						w.write(stream.nextInstance().getData().toString());
 						w.write("\n");
 						numWritten++;
 					}
 					w.close();
-				}
-				catch (Exception ex)
-				{
+				} catch (Exception ex) {
 					throw new RuntimeException("Failed writing to file " + destFile, ex);
 				}
 
@@ -161,8 +144,7 @@ protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository)
 	}
 
 	@Override
-	public Class<?> getTaskResultType()
-	{
+	public Class<?> getTaskResultType() {
 		return String.class;
 	}
 }
diff --git a/moa/src/main/java/moa/tasks/auxiliar/WriteStreamToARFFFile.java b/moa/src/main/java/moa/tasks/auxiliar/WriteStreamToARFFFile.java
index 6ec0272a2..6f09ff756 100644
--- a/moa/src/main/java/moa/tasks/auxiliar/WriteStreamToARFFFile.java
+++ b/moa/src/main/java/moa/tasks/auxiliar/WriteStreamToARFFFile.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks.auxiliar;
 
@@ -41,58 +41,52 @@
  */
 public class WriteStreamToARFFFile extends AuxiliarMainTask {
 
-    @Override
-    public String getPurposeString() {
-        return "Outputs a stream to an ARFF file.";
-    }
+	@Override
+	public String getPurposeString() {
+		return "Outputs a stream to an ARFF file.";
+	}
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public ClassOption streamOption = new ClassOption("stream", 's',
-            "Stream to write.", InstanceStream.class,
-            "generators.RandomTreeGenerator");
+	public ClassOption streamOption = new ClassOption("stream", 's', "Stream to write.", InstanceStream.class,
+			"generators.RandomTreeGenerator");
 
-    public FileOption arffFileOption = new FileOption("arffFile", 'f',
-            "Destination ARFF file.", null, "arff", true);
+	public FileOption arffFileOption = new FileOption("arffFile", 'f', "Destination ARFF file.", null, "arff", true);
 
-    public IntOption maxInstancesOption = new IntOption("maxInstances", 'm',
-            "Maximum number of instances to write to file.", 10000000, 0,
-            Integer.MAX_VALUE);
+	public IntOption maxInstancesOption = new IntOption("maxInstances", 'm',
+			"Maximum number of instances to write to file.", 10000000, 0, Integer.MAX_VALUE);
 
-    public FlagOption suppressHeaderOption = new FlagOption("suppressHeader",
-            'h', "Suppress header from output.");
+	public FlagOption suppressHeaderOption = new FlagOption("suppressHeader", 'h', "Suppress header from output.");
 
-    @Override
-    protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
-        InstanceStream stream = (InstanceStream) getPreparedClassOption(this.streamOption);
-        File destFile = this.arffFileOption.getFile();
-        if (destFile != null) {
-            try {
-                Writer w = new BufferedWriter(new FileWriter(destFile));
-                monitor.setCurrentActivityDescription("Writing stream to ARFF");
-                if (!this.suppressHeaderOption.isSet()) {
-                    w.write(stream.getHeader().toString());
-                    w.write("\n");
-                }
-                int numWritten = 0;
-                while ((numWritten < this.maxInstancesOption.getValue())
-                        && stream.hasMoreInstances()) {
-                    w.write(stream.nextInstance().getData().toString());
-                    w.write("\n");
-                    numWritten++;
-                }
-                w.close();
-            } catch (Exception ex) {
-                throw new RuntimeException(
-                        "Failed writing to file " + destFile, ex);
-            }
-            return "Stream written to ARFF file " + destFile;
-        }
-        throw new IllegalArgumentException("No destination file to write to.");
-    }
+	@Override
+	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
+		InstanceStream stream = (InstanceStream) getPreparedClassOption(this.streamOption);
+		File destFile = this.arffFileOption.getFile();
+		if (destFile != null) {
+			try {
+				Writer w = new BufferedWriter(new FileWriter(destFile));
+				monitor.setCurrentActivityDescription("Writing stream to ARFF");
+				if (!this.suppressHeaderOption.isSet()) {
+					w.write(stream.getHeader().toString());
+					w.write("\n");
+				}
+				int numWritten = 0;
+				while ((numWritten < this.maxInstancesOption.getValue()) && stream.hasMoreInstances()) {
+					w.write(stream.nextInstance().getData().toString());
+					w.write("\n");
+					numWritten++;
+				}
+				w.close();
+			} catch (Exception ex) {
+				throw new RuntimeException("Failed writing to file " + destFile, ex);
+			}
+			return "Stream written to ARFF file " + destFile;
+		}
+		throw new IllegalArgumentException("No destination file to write to.");
+	}
 
-    @Override
-    public Class<?> getTaskResultType() {
-        return String.class;
-    }
+	@Override
+	public Class<?> getTaskResultType() {
+		return String.class;
+	}
 }
diff --git a/moa/src/main/java/moa/tasks/classification/EvaluateInterleavedChunks.java b/moa/src/main/java/moa/tasks/classification/EvaluateInterleavedChunks.java
index f3a18c821..6c3c0eece 100644
--- a/moa/src/main/java/moa/tasks/classification/EvaluateInterleavedChunks.java
+++ b/moa/src/main/java/moa/tasks/classification/EvaluateInterleavedChunks.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks.classification;
 
@@ -35,9 +35,10 @@
 import moa.core.ObjectRepository;
 import moa.core.TimingUtils;
 import moa.evaluation.LearningEvaluation;
-import moa.evaluation.LearningPerformanceEvaluator;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
 import moa.evaluation.preview.LearningCurve;
 import moa.learners.MLTask;
+import moa.learners.predictors.Classifier;
 import moa.options.ClassOption;
 import moa.streams.ExampleStream;
 import moa.tasks.MainTask;
@@ -49,83 +50,75 @@ public class EvaluateInterleavedChunks extends MainTask implements Classificatio
 	public String getPurposeString() {
 		return "Evaluates a classifier on a stream by testing then training with chunks of data in sequence.";
 	}
-	
+
 	private static final long serialVersionUID = 1L;
 
 	/**
 	 * Allows to select the trained classifier.
 	 */
-	public ClassOption learnerOption = new ClassOption("learner", 'l',
-			"Classifier to train.", MLTask.class, "moa.classifiers.bayes.NaiveBayes");
+	public ClassOption learnerOption = new ClassOption("learner", 'l', "Classifier to train.", Classifier.class,
+			"bayes.NaiveBayes");
 
 	/**
-	 * Allows to select the stream the classifier will learn. 
+	 * Allows to select the stream the classifier will learn.
 	 */
-	public ClassOption streamOption = new ClassOption("stream", 's',
-			"Stream to learn from.", ExampleStream.class,
+	public ClassOption streamOption = new ClassOption("stream", 's', "Stream to learn from.", ExampleStream.class,
 			"generators.RandomTreeGenerator");
 
 	/**
 	 * Allows to select the classifier performance evaluation method.
 	 */
-	public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
-            "Learning performance evaluation method.",
-            LearningPerformanceEvaluator.class,
-			"BasicClassificationPerformanceEvaluator");
+	public ClassOption evaluatorOption = new ClassOption("evaluator", 'e', "Learning performance evaluation method.",
+			LearningPerformanceEvaluator.class, "BasicClassificationPerformanceEvaluator");
 
 	/**
-	 * Allows to define the maximum number of instances to test/train on  (-1 = no limit).
+	 * Allows to define the maximum number of instances to test/train on (-1 = no
+	 * limit).
 	 */
 	public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
-			"Maximum number of instances to test/train on  (-1 = no limit).",
-			100000000, -1, Integer.MAX_VALUE);
+			"Maximum number of instances to test/train on  (-1 = no limit).", 100000000, -1, Integer.MAX_VALUE);
 
 	/**
 	 * Allow to define the training/testing chunk size.
 	 */
-	public IntOption chunkSizeOption = new IntOption("chunkSize", 'c',
-			"Number of instances in a data chunk.",
-			1000, 1, Integer.MAX_VALUE);
-	
+	public IntOption chunkSizeOption = new IntOption("chunkSize", 'c', "Number of instances in a data chunk.", 1000, 1,
+			Integer.MAX_VALUE);
+
 	/**
-	 * Allows to define the maximum number of seconds to test/train for (-1 = no limit).
+	 * Allows to define the maximum number of seconds to test/train for (-1 = no
+	 * limit).
 	 */
 	public IntOption timeLimitOption = new IntOption("timeLimit", 't',
-			"Maximum number of seconds to test/train for (-1 = no limit).", -1,
-			-1, Integer.MAX_VALUE);
+			"Maximum number of seconds to test/train for (-1 = no limit).", -1, -1, Integer.MAX_VALUE);
 
 	/**
 	 * Defines how often classifier parameters will be calculated.
 	 */
-	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
-			'f',
-			"How many instances between samples of the learning performance.",
-			100000, 0, Integer.MAX_VALUE);
+	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency", 'f',
+			"How many instances between samples of the learning performance.", 100000, 0, Integer.MAX_VALUE);
 
 	/**
 	 * Allows to define the memory limit for the created model.
 	 */
 	public IntOption maxMemoryOption = new IntOption("maxMemory", 'b',
-			"Maximum size of model (in bytes). -1 = no limit.", -1, -1,
-			Integer.MAX_VALUE);
+			"Maximum size of model (in bytes). -1 = no limit.", -1, -1, Integer.MAX_VALUE);
 
 	/**
 	 * Allows to define the frequency of memory checks.
 	 */
-	public IntOption memCheckFrequencyOption = new IntOption(
-			"memCheckFrequency", 'q',
-			"How many instances between memory bound checks.", 100000, 0,
-			Integer.MAX_VALUE);
+	public IntOption memCheckFrequencyOption = new IntOption("memCheckFrequency", 'q',
+			"How many instances between memory bound checks.", 100000, 0, Integer.MAX_VALUE);
 
 	/**
 	 * Allows to define the output file name and location.
 	 */
-	public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
-			"File to append intermediate csv reslts to.", null, "csv", true);
+	public FileOption dumpFileOption = new FileOption("dumpFile", 'd', "File to append intermediate csv reslts to.",
+			null, "csv", true);
 
 	/**
 	 * Defines the task's result type.
 	 */
+	@Override
 	public Class<?> getTaskResultType() {
 		return LearningCurve.class;
 	}
@@ -134,157 +127,143 @@ public Class<?> getTaskResultType() {
 	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
 		MLTask learner = (MLTask) getPreparedClassOption(this.learnerOption);
 		ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
-		LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
+		LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(
+				this.evaluatorOption);
 		learner.setModelContext(stream.getHeader());
 		int maxInstances = this.instanceLimitOption.getValue();
 		int chunkSize = this.chunkSizeOption.getValue();
 		long instancesProcessed = 0;
 		int maxSeconds = this.timeLimitOption.getValue();
 		int secondsElapsed = 0;
-		
+
 		monitor.setCurrentActivity("Evaluating learner...", -1.0);
-		LearningCurve learningCurve = new LearningCurve(
-				"learning evaluation instances");
+		LearningCurve learningCurve = new LearningCurve("learning evaluation instances");
 		File dumpFile = this.dumpFileOption.getFile();
 		PrintStream immediateResultStream = null;
 		if (dumpFile != null) {
 			try {
 				if (dumpFile.exists()) {
-					immediateResultStream = new PrintStream(
-							new FileOutputStream(dumpFile, true), true);
+					immediateResultStream = new PrintStream(new FileOutputStream(dumpFile, true), true);
 				} else {
-					immediateResultStream = new PrintStream(
-							new FileOutputStream(dumpFile), true);
+					immediateResultStream = new PrintStream(new FileOutputStream(dumpFile), true);
 				}
 			} catch (Exception ex) {
-				throw new RuntimeException(
-						"Unable to open immediate result file: " + dumpFile, ex);
+				throw new RuntimeException("Unable to open immediate result file: " + dumpFile, ex);
 			}
 		}
 		boolean firstDump = true;
 		boolean firstChunk = true;
 		boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
 		long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-		long sampleTestTime =0, sampleTrainTime = 0;
+		long sampleTestTime = 0, sampleTrainTime = 0;
 		double RAMHours = 0.0;
-		
-		while (stream.hasMoreInstances()
-				&& ((maxInstances < 0) || (instancesProcessed < maxInstances))
+
+		while (stream.hasMoreInstances() && ((maxInstances < 0) || (instancesProcessed < maxInstances))
 				&& ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
-			
+
 			InstancesHeader chunkInstances = new InstancesHeader(stream.getHeader(), chunkSize);
-			
+
 			while (stream.hasMoreInstances() && chunkInstances.numInstances() < chunkSize) {
 				chunkInstances.add((Instance) stream.nextInstance().getData());
-				if (chunkInstances.numInstances()
-						% INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
+				if (chunkInstances.numInstances() % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
 					if (monitor.taskShouldAbort()) {
 						return null;
 					}
-					
+
 					long estimatedRemainingInstances = stream.estimatedRemainingInstances();
-			
+
 					if (maxInstances > 0) {
 						long maxRemaining = maxInstances - instancesProcessed;
 						if ((estimatedRemainingInstances < 0) || (maxRemaining < estimatedRemainingInstances)) {
 							estimatedRemainingInstances = maxRemaining;
 						}
 					}
-					
-					monitor.setCurrentActivityFractionComplete((double) instancesProcessed/ (double) (instancesProcessed + estimatedRemainingInstances));
+
+					monitor.setCurrentActivityFractionComplete(
+							(double) instancesProcessed / (double) (instancesProcessed + estimatedRemainingInstances));
 				}
-			}		
-			
-			////Testing
+			}
+
+			//// Testing
 			long testStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-			if(!firstChunk)
-			{
-				for (int i=0; i< chunkInstances.numInstances(); i++) {
-					Example testInst = new InstanceExample((Instance) chunkInstances.instance(i));
-					//testInst.setClassMissing();
+			if (!firstChunk) {
+				for (int i = 0; i < chunkInstances.numInstances(); i++) {
+					Example testInst = new InstanceExample(chunkInstances.instance(i));
+					// testInst.setClassMissing();
 					Prediction prediction = learner.getPredictionForInstance(testInst);
 					evaluator.addResult(testInst, prediction);
-			    }
-			}
-			else
-			{
+				}
+			} else {
 				firstChunk = false;
 			}
-			
+
 			sampleTestTime += TimingUtils.getNanoCPUTimeOfCurrentThread() - testStartTime;
-			
-			////Training
+
+			//// Training
 			long trainStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-			
-			for (int i=0; i< chunkInstances.numInstances(); i++) {
+
+			for (int i = 0; i < chunkInstances.numInstances(); i++) {
 				learner.trainOnInstance(new InstanceExample(chunkInstances.instance(i)));
 				instancesProcessed++;
-		    }
-			
+			}
+
 			sampleTrainTime += TimingUtils.getNanoCPUTimeOfCurrentThread() - trainStartTime;
-			
-			////Result output
+
+			//// Result output
 			if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0) {
-				
-				double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); //GBs
-                RAMHoursIncrement *= (TimingUtils.nanoTimeToSeconds(sampleTrainTime + sampleTestTime) / 3600.0); //Hours
-                RAMHours += RAMHoursIncrement;
-				
-				double avgTrainTime = TimingUtils.nanoTimeToSeconds(sampleTrainTime)/((double)this.sampleFrequencyOption.getValue()/chunkInstances.numInstances());
-				double avgTestTime = TimingUtils.nanoTimeToSeconds(sampleTestTime)/((double)this.sampleFrequencyOption.getValue()/chunkInstances.numInstances());
-				
+
+				double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); // GBs
+				RAMHoursIncrement *= (TimingUtils.nanoTimeToSeconds(sampleTrainTime + sampleTestTime) / 3600.0); // Hours
+				RAMHours += RAMHoursIncrement;
+
+				double avgTrainTime = TimingUtils.nanoTimeToSeconds(sampleTrainTime)
+						/ ((double) this.sampleFrequencyOption.getValue() / chunkInstances.numInstances());
+				double avgTestTime = TimingUtils.nanoTimeToSeconds(sampleTestTime)
+						/ ((double) this.sampleFrequencyOption.getValue() / chunkInstances.numInstances());
+
 				sampleTestTime = 0;
 				sampleTrainTime = 0;
-				
-				learningCurve.insertEntry(new LearningEvaluation(
-					new Measurement[] {
+
+				learningCurve.insertEntry(new LearningEvaluation(new Measurement[] {
 						new Measurement("learning evaluation instances", instancesProcessed),
-						new Measurement(("evaluation time ("+ (preciseCPUTiming ? "cpu " : "") + "seconds)"),TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread() - evaluateStartTime)),
+						new Measurement(("evaluation time (" + (preciseCPUTiming ? "cpu " : "") + "seconds)"),
+								TimingUtils.nanoTimeToSeconds(
+										TimingUtils.getNanoCPUTimeOfCurrentThread() - evaluateStartTime)),
 						new Measurement("average chunk train time", avgTrainTime),
 						new Measurement("average chunk train speed", chunkInstances.numInstances() / avgTrainTime),
 						new Measurement("average chunk test time", avgTestTime),
-						new Measurement("average chunk test speed", chunkInstances.numInstances()/ avgTestTime),
-						new Measurement( "model cost (RAM-Hours)", RAMHours)}, 
-					evaluator, 
-					learner));
-				
+						new Measurement("average chunk test speed", chunkInstances.numInstances() / avgTestTime),
+						new Measurement("model cost (RAM-Hours)", RAMHours) }, evaluator, learner));
+
 				if (immediateResultStream != null) {
 					if (firstDump) {
-						immediateResultStream.println(learningCurve
-								.headerToString());
+						immediateResultStream.println(learningCurve.headerToString());
 						firstDump = false;
 					}
-					immediateResultStream.println(learningCurve
-							.entryToString(learningCurve.numEntries() - 1));
+					immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
 					immediateResultStream.flush();
 				}
 			}
-			
-			////Memory testing
+
+			//// Memory testing
 			if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
 				if (monitor.taskShouldAbort()) {
 					return null;
 				}
-				long estimatedRemainingInstances = stream
-						.estimatedRemainingInstances();
+				long estimatedRemainingInstances = stream.estimatedRemainingInstances();
 				if (maxInstances > 0) {
 					long maxRemaining = maxInstances - instancesProcessed;
-					if ((estimatedRemainingInstances < 0)
-							|| (maxRemaining < estimatedRemainingInstances)) {
+					if ((estimatedRemainingInstances < 0) || (maxRemaining < estimatedRemainingInstances)) {
 						estimatedRemainingInstances = maxRemaining;
 					}
 				}
-				monitor
-						.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
-								: (double) instancesProcessed
-										/ (double) (instancesProcessed + estimatedRemainingInstances));
+				monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
+						: (double) instancesProcessed / (double) (instancesProcessed + estimatedRemainingInstances));
 				if (monitor.resultPreviewRequested()) {
 					monitor.setLatestResultPreview(learningCurve.copy());
 				}
 				secondsElapsed = (int) TimingUtils
-						.nanoTimeToSeconds(TimingUtils
-								.getNanoCPUTimeOfCurrentThread()
-								- evaluateStartTime);
+						.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread() - evaluateStartTime);
 			}
 		}
 		if (immediateResultStream != null) {
diff --git a/moa/src/main/java/moa/tasks/classification/EvaluateInterleavedTestThenTrain.java b/moa/src/main/java/moa/tasks/classification/EvaluateInterleavedTestThenTrain.java
index f98f3ecdb..43e0ed1c0 100644
--- a/moa/src/main/java/moa/tasks/classification/EvaluateInterleavedTestThenTrain.java
+++ b/moa/src/main/java/moa/tasks/classification/EvaluateInterleavedTestThenTrain.java
@@ -1,24 +1,32 @@
 package moa.tasks.classification;
 
-import moa.evaluation.LearningPerformanceEvaluator;
-import moa.learners.Classifier;
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
+import moa.learners.predictors.Classifier;
 import moa.options.ClassOption;
 import moa.tasks.AbstractEvaluateInterleavedTestThenTrain;
 
-public class EvaluateInterleavedTestThenTrain extends AbstractEvaluateInterleavedTestThenTrain<Classifier> implements ClassificationMainTask {
+public class EvaluateInterleavedTestThenTrain extends AbstractEvaluateInterleavedTestThenTrain<Classifier>
+		implements ClassificationMainTask {
 
-	public EvaluateInterleavedTestThenTrain(){
-		this.learnerOption = new ClassOption("learner", 'l',
-	            "Learner to train.", Classifier.class, "moa.classifiers.bayes.NaiveBayes");
-		this.evaluatorOption = new ClassOption("evaluator", 'e',
-	            "Classification performance evaluation method.",
-	            LearningPerformanceEvaluator.class,
-	            "BasicClassificationPerformanceEvaluator");
+	public EvaluateInterleavedTestThenTrain() {
+		this.learnerOption = new ClassOption("learner", 'l', "Learner to train.", Classifier.class,
+				"bayes.NaiveBayes");
+		this.evaluatorOption = new ClassOption("evaluator", 'e', "Classification performance evaluation method.",
+				LearningPerformanceEvaluator.class, "BasicClassificationPerformanceEvaluator");
 	}
-	
-    public String getPurposeString() {
-        return "Evaluates a classifier on a stream by testing then training with each example in sequence.";
-    }
 
-	
+	@Override
+	public String getPurposeString() {
+		return "Evaluates a classifier on a stream by testing then training with each example in sequence.";
+	}
+
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == EvaluateInterleavedTestThenTrain.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
 }
diff --git a/moa/src/main/java/moa/tasks/classification/EvaluatePeriodicHeldOutTest.java b/moa/src/main/java/moa/tasks/classification/EvaluatePeriodicHeldOutTest.java
index 044b3bb67..669a5ffc0 100644
--- a/moa/src/main/java/moa/tasks/classification/EvaluatePeriodicHeldOutTest.java
+++ b/moa/src/main/java/moa/tasks/classification/EvaluatePeriodicHeldOutTest.java
@@ -16,7 +16,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks.classification;
 
@@ -33,6 +33,7 @@
 import com.yahoo.labs.samoa.instances.InstancesHeader;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
+import moa.capabilities.CapabilitiesHandler;
 import moa.capabilities.Capability;
 import moa.capabilities.ImmutableCapabilities;
 import moa.core.Example;
@@ -41,9 +42,9 @@
 import moa.core.StringUtils;
 import moa.core.TimingUtils;
 import moa.evaluation.LearningEvaluation;
-import moa.evaluation.LearningPerformanceEvaluator;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
 import moa.evaluation.preview.LearningCurve;
-import moa.learners.Classifier;
+import moa.learners.predictors.Classifier;
 import moa.options.ClassOption;
 import moa.streams.CachedInstancesStream;
 import moa.streams.ExampleStream;
@@ -51,256 +52,238 @@
 import moa.tasks.TaskMonitor;
 
 /**
- * Task for evaluating a classifier on a stream by periodically testing on a heldout set.
+ * Task for evaluating a classifier on a stream by periodically testing on a
+ * heldout set.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class EvaluatePeriodicHeldOutTest extends MainTask implements ClassificationMainTask {
+public class EvaluatePeriodicHeldOutTest extends MainTask implements ClassificationMainTask, CapabilitiesHandler {
 
-    @Override
-    public String getPurposeString() {
-        return "Evaluates a classifier on a stream by periodically testing on a heldout set.";
-    }
+	@Override
+	public String getPurposeString() {
+		return "Evaluates a classifier on a stream by periodically testing on a heldout set.";
+	}
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public ClassOption learnerOption = new ClassOption("learner", 'l',
-            "Classifier to train.", Classifier.class, "moa.classifiers.trees.HoeffdingTree");
+	public ClassOption learnerOption = new ClassOption("learner", 'l', "Classifier to train.", Classifier.class,
+			"trees.HoeffdingTree");
 
-    public ClassOption streamOption = new ClassOption("stream", 's',
-            "Stream to learn from.", ExampleStream.class,
-            "generators.RandomTreeGenerator");
+	public ClassOption streamOption = new ClassOption("stream", 's', "Stream to learn from.", ExampleStream.class,
+			"generators.RandomTreeGenerator");
 
-    public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
-            "Learning performance evaluation method.",
-            LearningPerformanceEvaluator.class,
-            "BasicClassificationPerformanceEvaluator");
+	public ClassOption evaluatorOption = new ClassOption("evaluator", 'e', "Learning performance evaluation method.",
+			LearningPerformanceEvaluator.class, "BasicClassificationPerformanceEvaluator");
 
-    public IntOption testSizeOption = new IntOption("testSize", 'n',
-            "Number of testing examples.", 1000000, 0, Integer.MAX_VALUE);
+	public IntOption testSizeOption = new IntOption("testSize", 'n', "Number of testing examples.", 1000000, 0,
+			Integer.MAX_VALUE);
 
-    public IntOption trainSizeOption = new IntOption("trainSize", 'i',
-            "Number of training examples, <1 = unlimited.", 0, 0,
-            Integer.MAX_VALUE);
+	public IntOption trainSizeOption = new IntOption("trainSize", 'i', "Number of training examples, <1 = unlimited.",
+			0, 0, Integer.MAX_VALUE);
 
-    public IntOption trainTimeOption = new IntOption("trainTime", 't',
-            "Number of training seconds.", 10 * 60 * 60, 0, Integer.MAX_VALUE);
+	public IntOption trainTimeOption = new IntOption("trainTime", 't', "Number of training seconds.", 10 * 60 * 60, 0,
+			Integer.MAX_VALUE);
 
-    public IntOption sampleFrequencyOption = new IntOption(
-            "sampleFrequency",
-            'f',
-            "Number of training examples between samples of learning performance.",
-            100000, 0, Integer.MAX_VALUE);
+	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency", 'f',
+			"Number of training examples between samples of learning performance.", 100000, 0, Integer.MAX_VALUE);
 
-    public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
-            "File to append intermediate csv results to.", null, "csv", true);
+	public FileOption dumpFileOption = new FileOption("dumpFile", 'd', "File to append intermediate csv results to.",
+			null, "csv", true);
 
-    public FlagOption cacheTestOption = new FlagOption("cacheTest", 'c',
-            "Cache test instances in memory.");
+	public FlagOption cacheTestOption = new FlagOption("cacheTest", 'c', "Cache test instances in memory.");
 
-    @Override
-    protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
-        Classifier learner = (Classifier) getPreparedClassOption(this.learnerOption);
-        ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
-        LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
-        learner.setModelContext(stream.getHeader());
-        long instancesProcessed = 0;
-        LearningCurve learningCurve = new LearningCurve("evaluation instances");
-        File dumpFile = this.dumpFileOption.getFile();
-        PrintStream immediateResultStream = null;
-        if (dumpFile != null) {
-            try {
-                if (dumpFile.exists()) {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile, true), true);
-                } else {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile), true);
-                }
-            } catch (Exception ex) {
-                throw new RuntimeException(
-                        "Unable to open immediate result file: " + dumpFile, ex);
-            }
-        }
-        boolean firstDump = true;
-        ExampleStream testStream = null;
-        int testSize = this.testSizeOption.getValue();
-        if (this.cacheTestOption.isSet()) {
-            monitor.setCurrentActivity("Caching test examples...", -1.0);
-            InstancesHeader testInstances = new InstancesHeader(stream.getHeader(),
-                    this.testSizeOption.getValue());
-            while (testInstances.numInstances() < testSize) {
-                testInstances.add((Instance) stream.nextInstance().getData());
-                if (testInstances.numInstances()
-                        % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
-                    if (monitor.taskShouldAbort()) {
-                        return null;
-                    }
-                    monitor.setCurrentActivityFractionComplete((double) testInstances.numInstances()
-                            / (double) (this.testSizeOption.getValue()));
-                }
-            }
-            testStream = new CachedInstancesStream(testInstances);
-        } else {
-            //testStream = (InstanceStream) stream.copy();
-            testStream = stream;
-            /*monitor.setCurrentActivity("Skipping test examples...", -1.0);
-            for (int i = 0; i < testSize; i++) {
-            stream.nextInstance();
-            }*/
-        }
-        instancesProcessed = 0;
-        TimingUtils.enablePreciseTiming();
-        double totalTrainTime = 0.0;
-        while ((this.trainSizeOption.getValue() < 1
-                || instancesProcessed < this.trainSizeOption.getValue())
-                && stream.hasMoreInstances() == true) {
-            monitor.setCurrentActivityDescription("Training...");
-            long instancesTarget = instancesProcessed
-                    + this.sampleFrequencyOption.getValue();
-            long trainStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-            while (instancesProcessed < instancesTarget && stream.hasMoreInstances() == true) {
-                learner.trainOnInstance(stream.nextInstance());
-                instancesProcessed++;
-                if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
-                    if (monitor.taskShouldAbort()) {
-                        return null;
-                    }
-                    monitor.setCurrentActivityFractionComplete((double) (instancesProcessed)
-                            / (double) (this.trainSizeOption.getValue()));
-                }
-            }
-            double lastTrainTime = TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread()
-                    - trainStartTime);
-            totalTrainTime += lastTrainTime;
-            if (totalTrainTime > this.trainTimeOption.getValue()) {
-                break;
-            }
-	    if (this.cacheTestOption.isSet()) {
-                testStream.restart();
-            } 
-            evaluator.reset();
-            long testInstancesProcessed = 0;
-            monitor.setCurrentActivityDescription("Testing (after "
-                    + StringUtils.doubleToString(
-                    ((double) (instancesProcessed)
-                    / (double) (this.trainSizeOption.getValue()) * 100.0), 2)
-                    + "% training)...");
-            long testStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-            int instCount = 0 ;
-            for (instCount = 0; instCount < testSize; instCount++) {
+	@Override
+	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
+		Classifier learner = (Classifier) getPreparedClassOption(this.learnerOption);
+		ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
+		LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(
+				this.evaluatorOption);
+		learner.setModelContext(stream.getHeader());
+		long instancesProcessed = 0;
+		LearningCurve learningCurve = new LearningCurve("evaluation instances");
+		File dumpFile = this.dumpFileOption.getFile();
+		PrintStream immediateResultStream = null;
+		if (dumpFile != null) {
+			try {
+				if (dumpFile.exists()) {
+					immediateResultStream = new PrintStream(new FileOutputStream(dumpFile, true), true);
+				} else {
+					immediateResultStream = new PrintStream(new FileOutputStream(dumpFile), true);
+				}
+			} catch (Exception ex) {
+				throw new RuntimeException("Unable to open immediate result file: " + dumpFile, ex);
+			}
+		}
+		boolean firstDump = true;
+		ExampleStream testStream = null;
+		int testSize = this.testSizeOption.getValue();
+		if (this.cacheTestOption.isSet()) {
+			monitor.setCurrentActivity("Caching test examples...", -1.0);
+			InstancesHeader testInstances = new InstancesHeader(stream.getHeader(), this.testSizeOption.getValue());
+			while (testInstances.numInstances() < testSize) {
+				testInstances.add((Instance) stream.nextInstance().getData());
+				if (testInstances.numInstances() % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
+					if (monitor.taskShouldAbort()) {
+						return null;
+					}
+					monitor.setCurrentActivityFractionComplete(
+							(double) testInstances.numInstances() / (double) (this.testSizeOption.getValue()));
+				}
+			}
+			testStream = new CachedInstancesStream(testInstances);
+		} else {
+			// testStream = (InstanceStream) stream.copy();
+			testStream = stream;
+			/*
+			 * monitor.setCurrentActivity("Skipping test examples...", -1.0); for (int i =
+			 * 0; i < testSize; i++) { stream.nextInstance(); }
+			 */
+		}
+		instancesProcessed = 0;
+		TimingUtils.enablePreciseTiming();
+		double totalTrainTime = 0.0;
+		while ((this.trainSizeOption.getValue() < 1 || instancesProcessed < this.trainSizeOption.getValue())
+				&& stream.hasMoreInstances() == true) {
+			monitor.setCurrentActivityDescription("Training...");
+			long instancesTarget = instancesProcessed + this.sampleFrequencyOption.getValue();
+			long trainStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+			while (instancesProcessed < instancesTarget && stream.hasMoreInstances() == true) {
+				learner.trainOnInstance(stream.nextInstance());
+				instancesProcessed++;
+				if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
+					if (monitor.taskShouldAbort()) {
+						return null;
+					}
+					monitor.setCurrentActivityFractionComplete(
+							(double) (instancesProcessed) / (double) (this.trainSizeOption.getValue()));
+				}
+			}
+			double lastTrainTime = TimingUtils
+					.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread() - trainStartTime);
+			totalTrainTime += lastTrainTime;
+			if (totalTrainTime > this.trainTimeOption.getValue()) {
+				break;
+			}
+			if (this.cacheTestOption.isSet()) {
+				testStream.restart();
+			}
+			evaluator.reset();
+			long testInstancesProcessed = 0;
+			monitor.setCurrentActivityDescription("Testing (after "
+					+ StringUtils.doubleToString(
+							((double) (instancesProcessed) / (double) (this.trainSizeOption.getValue()) * 100.0), 2)
+					+ "% training)...");
+			long testStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+			int instCount = 0;
+			for (instCount = 0; instCount < testSize; instCount++) {
 				if (stream.hasMoreInstances() == false) {
 					break;
 				}
-                Example testInst = (Example) testStream.nextInstance(); //.copy();
-                //testInst.setClassMissing();
-                Prediction prediction = learner.getPredictionForInstance(testInst);
-                //testInst.setClassValue(trueClass);
-                evaluator.addResult(testInst, prediction);
-                testInstancesProcessed++;
-                if (testInstancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
-                    if (monitor.taskShouldAbort()) {
-                        return null;
-                    }
-                    monitor.setCurrentActivityFractionComplete((double) testInstancesProcessed
-                            / (double) (testSize));
-                }
-            }
-        	if ( instCount != testSize) {
+				Example testInst = testStream.nextInstance(); // .copy();
+				// testInst.setClassMissing();
+				Prediction prediction = learner.getPredictionForInstance(testInst);
+				// testInst.setClassValue(trueClass);
+				evaluator.addResult(testInst, prediction);
+				testInstancesProcessed++;
+				if (testInstancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
+					if (monitor.taskShouldAbort()) {
+						return null;
+					}
+					monitor.setCurrentActivityFractionComplete((double) testInstancesProcessed / (double) (testSize));
+				}
+			}
+			if (instCount != testSize) {
 				break;
 			}
-            double testTime = TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread()
-                    - testStartTime);
-            List<Measurement> measurements = new ArrayList<Measurement>();
-            measurements.add(new Measurement("evaluation instances",            		
-                    instancesProcessed));
-            measurements.add(new Measurement("total train time", totalTrainTime));
-            measurements.add(new Measurement("total train speed",
-                    instancesProcessed / totalTrainTime));
-            measurements.add(new Measurement("last train time", lastTrainTime));
-            measurements.add(new Measurement("last train speed",
-                    this.sampleFrequencyOption.getValue() / lastTrainTime));
-            measurements.add(new Measurement("test time", testTime));
-            measurements.add(new Measurement("test speed", this.testSizeOption.getValue()
-                    / testTime));
-            Measurement[] performanceMeasurements = evaluator.getPerformanceMeasurements();
-            for (Measurement measurement : performanceMeasurements) {
-                measurements.add(measurement);
-            }
-            Measurement[] modelMeasurements = learner.getModelMeasurements();
-            for (Measurement measurement : modelMeasurements) {
-                measurements.add(measurement);
-            }
-            learningCurve.insertEntry(new LearningEvaluation(measurements.toArray(new Measurement[measurements.size()])));
-            if (immediateResultStream != null) {
-                if (firstDump) {
-                    immediateResultStream.println(learningCurve.headerToString());
-                    firstDump = false;
-                }
-                immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
-                immediateResultStream.flush();
-            }
-            if (monitor.resultPreviewRequested()) {
-                monitor.setLatestResultPreview(learningCurve.copy());
-            }
-            // if (learner instanceof HoeffdingTree
-            // || learner instanceof HoeffdingOptionTree) {
-            // int numActiveNodes = (int) Measurement.getMeasurementNamed(
-            // "active learning leaves",
-            // modelMeasurements).getValue();
-            // // exit if tree frozen
-            // if (numActiveNodes < 1) {
-            // break;
-            // }
-            // int numNodes = (int) Measurement.getMeasurementNamed(
-            // "tree size (nodes)", modelMeasurements)
-            // .getValue();
-            // if (numNodes == lastNumNodes) {
-            // noGrowthCount++;
-            // } else {
-            // noGrowthCount = 0;
-            // }
-            // lastNumNodes = numNodes;
-            // } else if (learner instanceof OzaBoost || learner instanceof
-            // OzaBag) {
-            // double numActiveNodes = Measurement.getMeasurementNamed(
-            // "[avg] active learning leaves",
-            // modelMeasurements).getValue();
-            // // exit if all trees frozen
-            // if (numActiveNodes == 0.0) {
-            // break;
-            // }
-            // int numNodes = (int) (Measurement.getMeasurementNamed(
-            // "[avg] tree size (nodes)",
-            // learner.getModelMeasurements()).getValue() * Measurement
-            // .getMeasurementNamed("ensemble size",
-            // modelMeasurements).getValue());
-            // if (numNodes == lastNumNodes) {
-            // noGrowthCount++;
-            // } else {
-            // noGrowthCount = 0;
-            // }
-            // lastNumNodes = numNodes;
-            // }
-        }
-        if (immediateResultStream != null) {
-            immediateResultStream.close();
-        }
-        return learningCurve;
-    }
-
-    @Override
-    public Class<?> getTaskResultType() {
-        return LearningCurve.class;
-    }
+			double testTime = TimingUtils
+					.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread() - testStartTime);
+			List<Measurement> measurements = new ArrayList<>();
+			measurements.add(new Measurement("evaluation instances", instancesProcessed));
+			measurements.add(new Measurement("total train time", totalTrainTime));
+			measurements.add(new Measurement("total train speed", instancesProcessed / totalTrainTime));
+			measurements.add(new Measurement("last train time", lastTrainTime));
+			measurements
+					.add(new Measurement("last train speed", this.sampleFrequencyOption.getValue() / lastTrainTime));
+			measurements.add(new Measurement("test time", testTime));
+			measurements.add(new Measurement("test speed", this.testSizeOption.getValue() / testTime));
+			Measurement[] performanceMeasurements = evaluator.getPerformanceMeasurements();
+			for (Measurement measurement : performanceMeasurements) {
+				measurements.add(measurement);
+			}
+			Measurement[] modelMeasurements = learner.getModelMeasurements();
+			for (Measurement measurement : modelMeasurements) {
+				measurements.add(measurement);
+			}
+			learningCurve
+					.insertEntry(new LearningEvaluation(measurements.toArray(new Measurement[measurements.size()])));
+			if (immediateResultStream != null) {
+				if (firstDump) {
+					immediateResultStream.println(learningCurve.headerToString());
+					firstDump = false;
+				}
+				immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
+				immediateResultStream.flush();
+			}
+			if (monitor.resultPreviewRequested()) {
+				monitor.setLatestResultPreview(learningCurve.copy());
+			}
+			// if (learner instanceof HoeffdingTree
+			// || learner instanceof HoeffdingOptionTree) {
+			// int numActiveNodes = (int) Measurement.getMeasurementNamed(
+			// "active learning leaves",
+			// modelMeasurements).getValue();
+			// // exit if tree frozen
+			// if (numActiveNodes < 1) {
+			// break;
+			// }
+			// int numNodes = (int) Measurement.getMeasurementNamed(
+			// "tree size (nodes)", modelMeasurements)
+			// .getValue();
+			// if (numNodes == lastNumNodes) {
+			// noGrowthCount++;
+			// } else {
+			// noGrowthCount = 0;
+			// }
+			// lastNumNodes = numNodes;
+			// } else if (learner instanceof OzaBoost || learner instanceof
+			// OzaBag) {
+			// double numActiveNodes = Measurement.getMeasurementNamed(
+			// "[avg] active learning leaves",
+			// modelMeasurements).getValue();
+			// // exit if all trees frozen
+			// if (numActiveNodes == 0.0) {
+			// break;
+			// }
+			// int numNodes = (int) (Measurement.getMeasurementNamed(
+			// "[avg] tree size (nodes)",
+			// learner.getModelMeasurements()).getValue() * Measurement
+			// .getMeasurementNamed("ensemble size",
+			// modelMeasurements).getValue());
+			// if (numNodes == lastNumNodes) {
+			// noGrowthCount++;
+			// } else {
+			// noGrowthCount = 0;
+			// }
+			// lastNumNodes = numNodes;
+			// }
+		}
+		if (immediateResultStream != null) {
+			immediateResultStream.close();
+		}
+		return learningCurve;
+	}
 
+	@Override
+	public Class<?> getTaskResultType() {
+		return LearningCurve.class;
+	}
 
-    @Override
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        if (this.getClass() == EvaluatePeriodicHeldOutTest.class)
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
-        else
-            return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == EvaluatePeriodicHeldOutTest.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
 }
diff --git a/moa/src/main/java/moa/tasks/classification/EvaluatePrequential.java b/moa/src/main/java/moa/tasks/classification/EvaluatePrequential.java
index 89bfecdf7..4722e76a9 100644
--- a/moa/src/main/java/moa/tasks/classification/EvaluatePrequential.java
+++ b/moa/src/main/java/moa/tasks/classification/EvaluatePrequential.java
@@ -6,27 +6,26 @@
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
 import moa.core.Utils;
-import moa.evaluation.LearningPerformanceEvaluator;
-import moa.learners.Classifier;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
+import moa.learners.predictors.Classifier;
 import moa.options.ClassOption;
 import moa.tasks.AbstractEvaluatePrequential;
 
 public class EvaluatePrequential extends AbstractEvaluatePrequential<Classifier> implements ClassificationMainTask {
 
 	private static final long serialVersionUID = 1L;
-	
+
 	public EvaluatePrequential() {
-		this.learnerOption = new ClassOption("learner", 'l', "Learner to train.", Classifier.class, "moa.classifiers.trees.HoeffdingTree");
-		this.evaluatorOption = new ClassOption("evaluator", 'e',
-					"Classification performance evaluation method.",
-					LearningPerformanceEvaluator.class,
-					"WindowClassificationPerformanceEvaluator");
+		this.learnerOption = new ClassOption("learner", 'l', "Learner to train.", Classifier.class, "trees.HoeffdingTree");
+		this.evaluatorOption = new ClassOption("evaluator", 'e', "Classification performance evaluation method.",
+				LearningPerformanceEvaluator.class, "WindowClassificationPerformanceEvaluator");
 	}
 
 	@Override
-    public String getPurposeString() {
-        return "Evaluates a classifier on a stream by testing then training with each example in sequence.";
-    }
+	public String getPurposeString() {
+		return "Evaluates a classifier on a stream by testing then training with each example in sequence.";
+	}
+
 	@Override
 	public void printPrediction(PrintStream print, Instance inst, Prediction prediction) {
 		int trueClass = (int) inst.classValue();
diff --git a/moa/src/main/java/moa/tasks/classification/EvaluatePrequentialCV.java b/moa/src/main/java/moa/tasks/classification/EvaluatePrequentialCV.java
index bcb64f601..fba4b8676 100644
--- a/moa/src/main/java/moa/tasks/classification/EvaluatePrequentialCV.java
+++ b/moa/src/main/java/moa/tasks/classification/EvaluatePrequentialCV.java
@@ -6,29 +6,28 @@
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
 import moa.core.Utils;
-import moa.evaluation.LearningPerformanceEvaluator;
-import moa.learners.Classifier;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
+import moa.learners.predictors.Classifier;
 import moa.options.ClassOption;
 import moa.tasks.AbstractEvaluatePrequential;
 
 public class EvaluatePrequentialCV extends AbstractEvaluatePrequential<Classifier> implements ClassificationMainTask {
 
 	private static final long serialVersionUID = 1L;
-	
+
 	public EvaluatePrequentialCV() {
-		this.learnerOption = new ClassOption("learner", 'l', "Classifier to evaluate.", 
-				Classifier.class, "moa.classifiers.trees.HoeffdingTree");
+		this.learnerOption = new ClassOption("learner", 'l', "Classifier to evaluate.", Classifier.class,
+				"trees.HoeffdingTree");
 		this.evaluatorOption = new ClassOption("evaluator", 'e', "Classification performance evaluation method.",
-				LearningPerformanceEvaluator.class,
-				"WindowClassificationPerformanceEvaluator");
+				LearningPerformanceEvaluator.class, "WindowClassificationPerformanceEvaluator");
 	}
 
 	@Override
 	public String getPurposeString() {
-		return "Evaluates a classifier on a stream by doing prequential evaluation (testing then training with each" +
-				" example in sequence) and doing cross-validation.";
+		return "Evaluates a classifier on a stream by doing prequential evaluation (testing then training with each"
+				+ " example in sequence) and doing cross-validation.";
 	}
-	
+
 	@Override
 	public void printPrediction(PrintStream print, Instance inst, Prediction prediction) {
 		int trueClass = (int) inst.classValue();
diff --git a/moa/src/main/java/moa/tasks/classification/EvaluatePrequentialDelayed.java b/moa/src/main/java/moa/tasks/classification/EvaluatePrequentialDelayed.java
index ee6363d77..cb1078665 100644
--- a/moa/src/main/java/moa/tasks/classification/EvaluatePrequentialDelayed.java
+++ b/moa/src/main/java/moa/tasks/classification/EvaluatePrequentialDelayed.java
@@ -17,7 +17,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks.classification;
 
@@ -38,300 +38,283 @@
 import moa.core.ObjectRepository;
 import moa.core.TimingUtils;
 import moa.core.Utils;
-import moa.evaluation.EWMAClassificationPerformanceEvaluator;
-import moa.evaluation.FadingFactorClassificationPerformanceEvaluator;
 import moa.evaluation.LearningEvaluation;
-import moa.evaluation.LearningPerformanceEvaluator;
-import moa.evaluation.WindowClassificationPerformanceEvaluator;
+import moa.evaluation.evaluators.EWMAClassificationPerformanceEvaluator;
+import moa.evaluation.evaluators.FadingFactorClassificationPerformanceEvaluator;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
+import moa.evaluation.evaluators.WindowClassificationPerformanceEvaluator;
 import moa.evaluation.preview.LearningCurve;
-import moa.learners.Classifier;
 import moa.learners.MLTask;
+import moa.learners.predictors.Classifier;
 import moa.options.ClassOption;
 import moa.streams.ExampleStream;
 import moa.tasks.MainTask;
 import moa.tasks.TaskMonitor;
 
 /**
- * Task for evaluating a classifier on a delayed stream by testing and only 
+ * Task for evaluating a classifier on a delayed stream by testing and only
  * training with the example after k other examples (delayed labeling).
  *
- * <p>See details in:<br> Heitor Murilo Gomes, Albert Bifet, Jesse Read, 
- * Jean Paul Barddal, Fabricio Enembreck, Bernhard Pfharinger, Geoff Holmes, 
- * Talel Abdessalem. Adaptive random forests for evolving data stream classification. 
- * In Machine Learning, DOI: 10.1007/s10994-017-5642-8, Springer, 2017.</p><br>
- * 
+ * <p>
+ * See details in:<br>
+ * Heitor Murilo Gomes, Albert Bifet, Jesse Read, Jean Paul Barddal, Fabricio
+ * Enembreck, Bernhard Pfharinger, Geoff Holmes, Talel Abdessalem. Adaptive
+ * random forests for evolving data stream classification. In Machine Learning,
+ * DOI: 10.1007/s10994-017-5642-8, Springer, 2017.
+ * </p>
+ * <br>
+ *
  * @author Heitor Murilo Gomes (heitor dot gomes at telecom-paristech dot fr)
  * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
  * @version $Revision: 1 $
  */
 public class EvaluatePrequentialDelayed extends MainTask implements ClassificationMainTask {
 
-    @Override
-    public String getPurposeString() {
-        return "Evaluates a classifier on a delayed stream by testing and only"
-                + " training with the example after k other examples (delayed labeling).";
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    public ClassOption learnerOption = new ClassOption("learner", 'l',
-            "Learner to train.", Classifier.class, "moa.classifiers.bayes.NaiveBayes");
-
-    public ClassOption streamOption = new ClassOption("stream", 's',
-            "Stream to learn from.", ExampleStream.class,
-            "generators.RandomTreeGenerator");
-
-    public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
-            "Classification performance evaluation method.",
-            LearningPerformanceEvaluator.class,
-            "WindowClassificationPerformanceEvaluator");
-
-    public IntOption delayLengthOption = new IntOption("delay", 'k',
-            "Number of instances before test instance is used for training",
-            1000, 1, Integer.MAX_VALUE);
-    
-    public IntOption initialWindowSizeOption = new IntOption("initialTrainingWindow", 'p',
-        "Number of instances used for training in the beginning of the stream.",
-        1000, 0, Integer.MAX_VALUE);
-    
-    public FlagOption trainOnInitialWindowOption = new FlagOption("trainOnInitialWindow", 'm', 
-            "Whether to train or not using instances in the initial window.");
-    
-    public FlagOption trainInBatches = new FlagOption("trainInBatches", 'b', 
-        "If set training will not be interleaved with testing. ");
-    
-    public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
-            "Maximum number of instances to test/train on  (-1 = no limit).",
-            100000000, -1, Integer.MAX_VALUE);
-
-    public IntOption timeLimitOption = new IntOption("timeLimit", 't',
-            "Maximum number of seconds to test/train for (-1 = no limit).", -1,
-            -1, Integer.MAX_VALUE);
-    
-    public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
-            'f',
-            "How many instances between samples of the learning performance.",
-            100000, 0, Integer.MAX_VALUE);
-    
-    public IntOption memCheckFrequencyOption = new IntOption(
-            "memCheckFrequency", 'q',
-            "How many instances between memory bound checks.", 100000, 0,
-            Integer.MAX_VALUE);
-
-    public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
-            "File to append intermediate csv results to.", null, "csv", true);
-
-    public FileOption outputPredictionFileOption = new FileOption("outputPredictionFile", 'o',
-            "File to append output predictions to.", null, "pred", true);
-
-    //New for prequential method DEPRECATED
-    public IntOption widthOption = new IntOption("width",
-            'w', "Size of Window", 1000);
-
-    public FloatOption alphaOption = new FloatOption("alpha",
-            'a', "Fading factor or exponential smoothing factor", .01);
-
-    // Buffer of instances to use for training. 
-    protected LinkedList<Example> trainInstances;
-    
-    @Override
-    public Class<?> getTaskResultType() {
-        return LearningCurve.class;
-    }
-
-    @Override
-    protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
-        MLTask learner = (MLTask) getPreparedClassOption(this.learnerOption);
-        ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
-        LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
-        LearningCurve learningCurve = new LearningCurve(
-                "learning evaluation instances");
-
-        this.trainInstances = new LinkedList<Example>();
-        
-        //New for prequential methods
-        if (evaluator instanceof WindowClassificationPerformanceEvaluator) {
-            //((WindowClassificationPerformanceEvaluator) evaluator).setWindowWidth(widthOption.getValue());
-            if (widthOption.getValue() != 1000) {
-                System.out.println("DEPRECATED! Use EvaluatePrequential -e (WindowClassificationPerformanceEvaluator -w " + widthOption.getValue() + ")");
-                 return learningCurve;
-            }
-        }
-        if (evaluator instanceof EWMAClassificationPerformanceEvaluator) {
-            //((EWMAClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
-            if (alphaOption.getValue() != .01) {
-                System.out.println("DEPRECATED! Use EvaluatePrequential -e (EWMAClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
-                return learningCurve;
-            }
-        }
-        if (evaluator instanceof FadingFactorClassificationPerformanceEvaluator) {
-            //((FadingFactorClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
-            if (alphaOption.getValue() != .01) {
-                System.out.println("DEPRECATED! Use EvaluatePrequential -e (FadingFactorClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
-                return learningCurve;
-            }
-        }
-
-        learner.setModelContext(stream.getHeader());
-        int maxInstances = this.instanceLimitOption.getValue();
-        long instancesProcessed = 0;
-        int maxSeconds = this.timeLimitOption.getValue();
-        int secondsElapsed = 0;
-        monitor.setCurrentActivity("Evaluating learner...", -1.0);
-
-        File dumpFile = this.dumpFileOption.getFile();
-        PrintStream immediateResultStream = null;
-        if (dumpFile != null) {
-            try {
-                if (dumpFile.exists()) {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile, true), true);
-                } else {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile), true);
-                }
-            } catch (Exception ex) {
-                throw new RuntimeException(
-                        "Unable to open immediate result file: " + dumpFile, ex);
-            }
-        }
-        //File for output predictions
-        File outputPredictionFile = this.outputPredictionFileOption.getFile();
-        PrintStream outputPredictionResultStream = null;
-        if (outputPredictionFile != null) {
-            try {
-                if (outputPredictionFile.exists()) {
-                    outputPredictionResultStream = new PrintStream(
-                            new FileOutputStream(outputPredictionFile, true), true);
-                } else {
-                    outputPredictionResultStream = new PrintStream(
-                            new FileOutputStream(outputPredictionFile), true);
-                }
-            } catch (Exception ex) {
-                throw new RuntimeException(
-                        "Unable to open prediction result file: " + outputPredictionFile, ex);
-            }
-        }
-        boolean firstDump = true;
-        boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
-        long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-        long lastEvaluateStartTime = evaluateStartTime;
-        double RAMHours = 0.0;
-        
-        while (stream.hasMoreInstances()
-                && ((maxInstances < 0) || (instancesProcessed < maxInstances))
-                && ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
-            
-            instancesProcessed++;
-            Example currentInst = stream.nextInstance();
-            
-            if(instancesProcessed <= this.initialWindowSizeOption.getValue()) {
-                if(this.trainOnInitialWindowOption.isSet()) {
-                    learner.trainOnInstance(currentInst);
-                }
-                else if((this.initialWindowSizeOption.getValue() - instancesProcessed) < this.delayLengthOption.getValue()) {
-                    this.trainInstances.addLast(currentInst);
-                }
-            }
-            else {
-                this.trainInstances.addLast(currentInst);
-
-                if(this.delayLengthOption.getValue() < this.trainInstances.size()) {
-                    if(this.trainInBatches.isSet()) {
-                        // Do not train on the latest instance, otherwise
-                        // it would train on k+1 instances
-                        while(this.trainInstances.size() > 1) {
-                            Example trainInst = this.trainInstances.removeFirst();
-                            learner.trainOnInstance(trainInst);
-                        }
-                    }
-                    else {
-                        Example trainInst = this.trainInstances.removeFirst();
-                        learner.trainOnInstance(trainInst);
-                    }
-                }
-
-                // Remove class label from test instances. 
-                Instance testInstance = ((Instance) currentInst.getData()).copy();
-                Example testInst = new InstanceExample(testInstance);
-                testInstance.setMissing(testInstance.classAttribute());
-                testInstance.setClassValue(0.0);
-          
-                double[] prediction = learner.getPredictionForInstance(testInst).asDoubleArray();
-    //          reinstate the testInstance as it is used in evaluator.addResult
-                testInstance = ((Instance) currentInst.getData()).copy();
-                testInst = new InstanceExample(testInstance);
-
-                // Output prediction
-                if (outputPredictionFile != null) {
-                    int trueClass = (int) ((Instance) currentInst.getData()).classValue();
-                    outputPredictionResultStream.println(Utils.maxIndex(prediction) + "," + (
-                     ((Instance) testInst.getData()).classIsMissing() == true ? " ? " : trueClass));
-                }
-                evaluator.addResult(testInst, prediction);
-                
-                if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0
-                        || stream.hasMoreInstances() == false) {
-                    long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-                    double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);
-                    double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);
-                    double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); //GBs
-                    RAMHoursIncrement *= (timeIncrement / 3600.0); //Hours
-                    RAMHours += RAMHoursIncrement;
-                    lastEvaluateStartTime = evaluateTime;
-                    learningCurve.insertEntry(new LearningEvaluation(
-                            new Measurement[]{
-                                new Measurement(
-                                "learning evaluation instances",
-                                instancesProcessed),
-                                new Measurement(
-                                "evaluation time ("
-                                + (preciseCPUTiming ? "cpu "
-                                : "") + "seconds)",
-                                time),
-                                new Measurement(
-                                "model cost (RAM-Hours)",
-                                RAMHours)
-                            },
-                            evaluator, learner));
-                    if (immediateResultStream != null) {
-                        if (firstDump) {
-                            immediateResultStream.println(learningCurve.headerToString());
-                            firstDump = false;
-                        }
-                        immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
-                        immediateResultStream.flush();
-                    }
-                }
-                if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
-                    if (monitor.taskShouldAbort()) {
-                        return null;
-                    }
-                    long estimatedRemainingInstances = stream.estimatedRemainingInstances();
-                    if (maxInstances > 0) {
-                        long maxRemaining = maxInstances - instancesProcessed;
-                        if ((estimatedRemainingInstances < 0)
-                                || (maxRemaining < estimatedRemainingInstances)) {
-                            estimatedRemainingInstances = maxRemaining;
-                        }
-                    }
-                    monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
-                            : (double) instancesProcessed
-                            / (double) (instancesProcessed + estimatedRemainingInstances));
-                    if (monitor.resultPreviewRequested()) {
-                        monitor.setLatestResultPreview(learningCurve.copy());
-                    }
-                    secondsElapsed = (int) TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread()
-                            - evaluateStartTime);
-                }
-            }
-        }
-        if (immediateResultStream != null) {
-            immediateResultStream.close();
-        }
-        if (outputPredictionResultStream != null) {
-            outputPredictionResultStream.close();
-        }
-        return learningCurve;
-    }
+	@Override
+	public String getPurposeString() {
+		return "Evaluates a classifier on a delayed stream by testing and only"
+				+ " training with the example after k other examples (delayed labeling).";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption learnerOption = new ClassOption("learner", 'l', "Learner to train.", Classifier.class,
+			"bayes.NaiveBayes");
+
+	public ClassOption streamOption = new ClassOption("stream", 's', "Stream to learn from.", ExampleStream.class,
+			"generators.RandomTreeGenerator");
+
+	public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
+			"Classification performance evaluation method.", LearningPerformanceEvaluator.class,
+			"WindowClassificationPerformanceEvaluator");
+
+	public IntOption delayLengthOption = new IntOption("delay", 'k',
+			"Number of instances before test instance is used for training", 1000, 1, Integer.MAX_VALUE);
+
+	public IntOption initialWindowSizeOption = new IntOption("initialTrainingWindow", 'p',
+			"Number of instances used for training in the beginning of the stream.", 1000, 0, Integer.MAX_VALUE);
+
+	public FlagOption trainOnInitialWindowOption = new FlagOption("trainOnInitialWindow", 'm',
+			"Whether to train or not using instances in the initial window.");
+
+	public FlagOption trainInBatches = new FlagOption("trainInBatches", 'b',
+			"If set training will not be interleaved with testing. ");
+
+	public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
+			"Maximum number of instances to test/train on  (-1 = no limit).", 100000000, -1, Integer.MAX_VALUE);
+
+	public IntOption timeLimitOption = new IntOption("timeLimit", 't',
+			"Maximum number of seconds to test/train for (-1 = no limit).", -1, -1, Integer.MAX_VALUE);
+
+	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency", 'f',
+			"How many instances between samples of the learning performance.", 100000, 0, Integer.MAX_VALUE);
+
+	public IntOption memCheckFrequencyOption = new IntOption("memCheckFrequency", 'q',
+			"How many instances between memory bound checks.", 100000, 0, Integer.MAX_VALUE);
+
+	public FileOption dumpFileOption = new FileOption("dumpFile", 'd', "File to append intermediate csv results to.",
+			null, "csv", true);
+
+	public FileOption outputPredictionFileOption = new FileOption("outputPredictionFile", 'o',
+			"File to append output predictions to.", null, "pred", true);
+
+	// New for prequential method DEPRECATED
+	public IntOption widthOption = new IntOption("width", 'w', "Size of Window", 1000);
+
+	public FloatOption alphaOption = new FloatOption("alpha", 'a', "Fading factor or exponential smoothing factor",
+			.01);
+
+	// Buffer of instances to use for training.
+	protected LinkedList<Example> trainInstances;
+
+	@Override
+	public Class<?> getTaskResultType() {
+		return LearningCurve.class;
+	}
+
+	@Override
+	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
+		MLTask learner = (MLTask) getPreparedClassOption(this.learnerOption);
+		ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
+		LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(
+				this.evaluatorOption);
+		LearningCurve learningCurve = new LearningCurve("learning evaluation instances");
+
+		this.trainInstances = new LinkedList<>();
+
+		// New for prequential methods
+		if (evaluator instanceof WindowClassificationPerformanceEvaluator) {
+			// ((WindowClassificationPerformanceEvaluator)
+			// evaluator).setWindowWidth(widthOption.getValue());
+			if (widthOption.getValue() != 1000) {
+				System.out
+						.println("DEPRECATED! Use EvaluatePrequential -e (WindowClassificationPerformanceEvaluator -w "
+								+ widthOption.getValue() + ")");
+				return learningCurve;
+			}
+		}
+		if (evaluator instanceof EWMAClassificationPerformanceEvaluator) {
+			// ((EWMAClassificationPerformanceEvaluator)
+			// evaluator).setalpha(alphaOption.getValue());
+			if (alphaOption.getValue() != .01) {
+				System.out.println("DEPRECATED! Use EvaluatePrequential -e (EWMAClassificationPerformanceEvaluator -a "
+						+ alphaOption.getValue() + ")");
+				return learningCurve;
+			}
+		}
+		if (evaluator instanceof FadingFactorClassificationPerformanceEvaluator) {
+			// ((FadingFactorClassificationPerformanceEvaluator)
+			// evaluator).setalpha(alphaOption.getValue());
+			if (alphaOption.getValue() != .01) {
+				System.out.println(
+						"DEPRECATED! Use EvaluatePrequential -e (FadingFactorClassificationPerformanceEvaluator -a "
+								+ alphaOption.getValue() + ")");
+				return learningCurve;
+			}
+		}
+
+		learner.setModelContext(stream.getHeader());
+		int maxInstances = this.instanceLimitOption.getValue();
+		long instancesProcessed = 0;
+		int maxSeconds = this.timeLimitOption.getValue();
+		int secondsElapsed = 0;
+		monitor.setCurrentActivity("Evaluating learner...", -1.0);
+
+		File dumpFile = this.dumpFileOption.getFile();
+		PrintStream immediateResultStream = null;
+		if (dumpFile != null) {
+			try {
+				if (dumpFile.exists()) {
+					immediateResultStream = new PrintStream(new FileOutputStream(dumpFile, true), true);
+				} else {
+					immediateResultStream = new PrintStream(new FileOutputStream(dumpFile), true);
+				}
+			} catch (Exception ex) {
+				throw new RuntimeException("Unable to open immediate result file: " + dumpFile, ex);
+			}
+		}
+		// File for output predictions
+		File outputPredictionFile = this.outputPredictionFileOption.getFile();
+		PrintStream outputPredictionResultStream = null;
+		if (outputPredictionFile != null) {
+			try {
+				if (outputPredictionFile.exists()) {
+					outputPredictionResultStream = new PrintStream(new FileOutputStream(outputPredictionFile, true),
+							true);
+				} else {
+					outputPredictionResultStream = new PrintStream(new FileOutputStream(outputPredictionFile), true);
+				}
+			} catch (Exception ex) {
+				throw new RuntimeException("Unable to open prediction result file: " + outputPredictionFile, ex);
+			}
+		}
+		boolean firstDump = true;
+		boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
+		long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+		long lastEvaluateStartTime = evaluateStartTime;
+		double RAMHours = 0.0;
+
+		while (stream.hasMoreInstances() && ((maxInstances < 0) || (instancesProcessed < maxInstances))
+				&& ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
+
+			instancesProcessed++;
+			Example currentInst = stream.nextInstance();
+
+			if (instancesProcessed <= this.initialWindowSizeOption.getValue()) {
+				if (this.trainOnInitialWindowOption.isSet()) {
+					learner.trainOnInstance(currentInst);
+				} else if ((this.initialWindowSizeOption.getValue() - instancesProcessed) < this.delayLengthOption
+						.getValue()) {
+					this.trainInstances.addLast(currentInst);
+				}
+			} else {
+				this.trainInstances.addLast(currentInst);
+
+				if (this.delayLengthOption.getValue() < this.trainInstances.size()) {
+					if (this.trainInBatches.isSet()) {
+						// Do not train on the latest instance, otherwise
+						// it would train on k+1 instances
+						while (this.trainInstances.size() > 1) {
+							Example trainInst = this.trainInstances.removeFirst();
+							learner.trainOnInstance(trainInst);
+						}
+					} else {
+						Example trainInst = this.trainInstances.removeFirst();
+						learner.trainOnInstance(trainInst);
+					}
+				}
+
+				// Remove class label from test instances.
+				Instance testInstance = ((Instance) currentInst.getData()).copy();
+				Example testInst = new InstanceExample(testInstance);
+				testInstance.setMissing(testInstance.classAttribute());
+				testInstance.setClassValue(0.0);
+
+				double[] prediction = learner.getPredictionForInstance(testInst).asDoubleArray();
+				// reinstate the testInstance as it is used in evaluator.addResult
+				testInstance = ((Instance) currentInst.getData()).copy();
+				testInst = new InstanceExample(testInstance);
+
+				// Output prediction
+				if (outputPredictionFile != null) {
+					int trueClass = (int) ((Instance) currentInst.getData()).classValue();
+					outputPredictionResultStream.println(Utils.maxIndex(prediction) + ","
+							+ (((Instance) testInst.getData()).classIsMissing() == true ? " ? " : trueClass));
+				}
+				evaluator.addResult(testInst, prediction);
+
+				if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0
+						|| stream.hasMoreInstances() == false) {
+					long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+					double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);
+					double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);
+					double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); // GBs
+					RAMHoursIncrement *= (timeIncrement / 3600.0); // Hours
+					RAMHours += RAMHoursIncrement;
+					lastEvaluateStartTime = evaluateTime;
+					learningCurve.insertEntry(new LearningEvaluation(
+							new Measurement[] { new Measurement("learning evaluation instances", instancesProcessed),
+									new Measurement("evaluation time (" + (preciseCPUTiming ? "cpu " : "") + "seconds)",
+											time),
+									new Measurement("model cost (RAM-Hours)", RAMHours) },
+							evaluator, learner));
+					if (immediateResultStream != null) {
+						if (firstDump) {
+							immediateResultStream.println(learningCurve.headerToString());
+							firstDump = false;
+						}
+						immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
+						immediateResultStream.flush();
+					}
+				}
+				if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
+					if (monitor.taskShouldAbort()) {
+						return null;
+					}
+					long estimatedRemainingInstances = stream.estimatedRemainingInstances();
+					if (maxInstances > 0) {
+						long maxRemaining = maxInstances - instancesProcessed;
+						if ((estimatedRemainingInstances < 0) || (maxRemaining < estimatedRemainingInstances)) {
+							estimatedRemainingInstances = maxRemaining;
+						}
+					}
+					monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
+							: (double) instancesProcessed
+									/ (double) (instancesProcessed + estimatedRemainingInstances));
+					if (monitor.resultPreviewRequested()) {
+						monitor.setLatestResultPreview(learningCurve.copy());
+					}
+					secondsElapsed = (int) TimingUtils
+							.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread() - evaluateStartTime);
+				}
+			}
+		}
+		if (immediateResultStream != null) {
+			immediateResultStream.close();
+		}
+		if (outputPredictionResultStream != null) {
+			outputPredictionResultStream.close();
+		}
+		return learningCurve;
+	}
 }
diff --git a/moa/src/main/java/moa/tasks/classification/EvaluatePrequentialDelayedCV.java b/moa/src/main/java/moa/tasks/classification/EvaluatePrequentialDelayedCV.java
index 765953941..c4911c057 100644
--- a/moa/src/main/java/moa/tasks/classification/EvaluatePrequentialDelayedCV.java
+++ b/moa/src/main/java/moa/tasks/classification/EvaluatePrequentialDelayedCV.java
@@ -17,7 +17,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks.classification;
 
@@ -39,276 +39,261 @@
 import moa.core.ObjectRepository;
 import moa.core.TimingUtils;
 import moa.evaluation.LearningEvaluation;
-import moa.evaluation.LearningPerformanceEvaluator;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
 import moa.evaluation.preview.LearningCurve;
-import moa.learners.Classifier;
 import moa.learners.MLTask;
+import moa.learners.predictors.Classifier;
 import moa.options.ClassOption;
 import moa.streams.ExampleStream;
 import moa.tasks.AbstractEvaluatePrequentialCV;
 import moa.tasks.TaskMonitor;
 
 /**
- * Task for delayed cross-validation evaluation of a classifier on a 
- * stream by testing and only training with the example after the arrival of 
- * other k examples (delayed labeling). 
- * 
- * <p>See details in:<br> Heitor Murilo Gomes, Albert Bifet, Jesse Read, 
- * Jean Paul Barddal, Fabricio Enembreck, Bernhard Pfharinger, Geoff Holmes, 
- * Talel Abdessalem. Adaptive random forests for evolving data stream classification. 
- * In Machine Learning, DOI: 10.1007/s10994-017-5642-8, Springer, 2017.</p><br> 
- * <p>Cross-validation for data streams was originally proposed in:<br>
- * Albert Bifet, Gianmarco De Francisci Morales, Jesse Read, Geoff Holmes, Bernhard Pfahringer: Efficient Online
- * Evaluation of Big Data Stream Classifiers. KDD 2015: 59-68</p>
+ * Task for delayed cross-validation evaluation of a classifier on a stream by
+ * testing and only training with the example after the arrival of other k
+ * examples (delayed labeling).
+ *
+ * <p>
+ * See details in:<br>
+ * Heitor Murilo Gomes, Albert Bifet, Jesse Read, Jean Paul Barddal, Fabricio
+ * Enembreck, Bernhard Pfharinger, Geoff Holmes, Talel Abdessalem. Adaptive
+ * random forests for evolving data stream classification. In Machine Learning,
+ * DOI: 10.1007/s10994-017-5642-8, Springer, 2017.
+ * </p>
+ * <br>
+ * <p>
+ * Cross-validation for data streams was originally proposed in:<br>
+ * Albert Bifet, Gianmarco De Francisci Morales, Jesse Read, Geoff Holmes,
+ * Bernhard Pfahringer: Efficient Online Evaluation of Big Data Stream
+ * Classifiers. KDD 2015: 59-68
+ * </p>
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
  * @author Heitor Murilo Gomes (heitor dot gomes at telecom-paristech dot fr)
  * @version $Revision: 7 $
  */
-public class EvaluatePrequentialDelayedCV extends AbstractEvaluatePrequentialCV<Classifier> implements ClassificationMainTask {
-
-    @Override
-    public String getPurposeString() {
-        return "Evaluates a classifier using delayed cross-validation evaluation "
-                + "by testing and only training with the example after the arrival of other k examples (delayed labeling) ";
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    public ClassOption learnerOption = new ClassOption("learner", 'l',
-            "Learner to train.", Classifier.class, "moa.classifiers.bayes.NaiveBayes");
-
-    public ClassOption streamOption = new ClassOption("stream", 's',
-            "Stream to learn from.", ExampleStream.class,
-            "generators.RandomTreeGenerator");
-
-    public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
-            "Classification performance evaluation method.",
-            LearningPerformanceEvaluator.class,
-            "WindowClassificationPerformanceEvaluator");
-
-        public IntOption delayLengthOption = new IntOption("delay", 'k',
-            "Number of instances before test instance is used for training",
-            1000, 1, Integer.MAX_VALUE);
-     
-    public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
-            "Maximum number of instances to test/train on  (-1 = no limit).",
-            100000000, -1, Integer.MAX_VALUE);
-
-    public IntOption timeLimitOption = new IntOption("timeLimit", 't',
-            "Maximum number of seconds to test/train for (-1 = no limit).", -1,
-            -1, Integer.MAX_VALUE);
-
-    public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
-            'f',
-            "How many instances between samples of the learning performance.",
-            100000, 0, Integer.MAX_VALUE);
-
-    public IntOption memCheckFrequencyOption = new IntOption(
-            "memCheckFrequency", 'q',
-            "How many instances between memory bound checks.", 100000, 0,
-            Integer.MAX_VALUE);
-
-    public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
-            "File to append intermediate csv results to.", null, "csv", true);
-
-    public IntOption numFoldsOption = new IntOption("numFolds", 'w',
-            "The number of folds (e.g. distributed models) to be used.", 10, 1, Integer.MAX_VALUE);
-
-    public MultiChoiceOption validationMethodologyOption = new MultiChoiceOption(
-            "validationMethodology", 'a', "Validation methodology to use.", new String[]{
-            "Cross-Validation", "Bootstrap-Validation", "Split-Validation"},
-            new String[]{"k-fold distributed Cross Validation",
-                    "k-fold distributed Bootstrap Validation",
-                    "k-fold distributed Split Validation"
-            }, 0);
-
-    public IntOption randomSeedOption = new IntOption("randomSeed", 'r',
-            "Seed for random behaviour of the task.", 1);
-
-    // Buffer of instances to use for training. 
-    // Note: It is a list of lists because it stores instances per learner, e.g.
-    // CV of 10, would be 10 lists of buffered instances for delayed training. 
-    protected LinkedList<LinkedList<Example>> trainInstances;
-    
-    @Override
-    public Class<?> getTaskResultType() {
-        return LearningCurve.class;
-    }
-
-    @Override
-    protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
-
-        Random random = new Random(this.randomSeedOption.getValue());
-        ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
-
-        MLTask[] learners = new MLTask[this.numFoldsOption.getValue()];
-        MLTask baseLearner = (MLTask) getPreparedClassOption(this.learnerOption);
-        baseLearner.resetLearning();
-
-        LearningPerformanceEvaluator[] evaluators = new LearningPerformanceEvaluator[this.numFoldsOption.getValue()];
-        LearningPerformanceEvaluator baseEvaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
-        for (int i = 0; i < learners.length; i++) {
-            learners[i] = (MLTask) baseLearner.copy();
-            learners[i].setModelContext(stream.getHeader());
-            evaluators[i] = (LearningPerformanceEvaluator) baseEvaluator.copy();
-        }
-
-        LearningCurve learningCurve = new LearningCurve(
-                "learning evaluation instances");
-        int maxInstances = this.instanceLimitOption.getValue();
-        long instancesProcessed = 0;
-        int maxSeconds = this.timeLimitOption.getValue();
-        int secondsElapsed = 0;
-        monitor.setCurrentActivity("Evaluating learner...", -1.0);
-
-        this.trainInstances = new LinkedList<LinkedList<Example>>();
-        
-        for(int i = 0; i < learners.length; i++) {
-            this.trainInstances.add(new LinkedList<Example>());
-        }
-        File dumpFile = this.dumpFileOption.getFile();
-        PrintStream immediateResultStream = null;
-        if (dumpFile != null) {
-            try {
-                if (dumpFile.exists()) {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile, true), true);
-                } else {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile), true);
-                }
-            } catch (Exception ex) {
-                throw new RuntimeException(
-                        "Unable to open immediate result file: " + dumpFile, ex);
-            }
-        }
-
-        boolean firstDump = true;
-        boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
-        long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-        long lastEvaluateStartTime = evaluateStartTime;
-        double RAMHours = 0.0;
-        
-        while (stream.hasMoreInstances()
-                && ((maxInstances < 0) || (instancesProcessed < maxInstances))
-                && ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
-            
-            
-            Example trainInst = stream.nextInstance();
-            Example testInst = (Example) trainInst;
-            
-            instancesProcessed++;
-            for (int i = 0; i < learners.length; i++) {
-                
-                double[] prediction = learners[i].getPredictionForInstance(testInst).asDoubleArray();
-                evaluators[i].addResult(testInst, prediction);
-                
-                int k = 1;
-                switch (this.validationMethodologyOption.getChosenIndex()) {
-                    case 0: //Cross-Validation;
-                        k = instancesProcessed % learners.length == i ? 0: 1; //Test all except one
-                        break;
-                    case 1: //Bootstrap;
-                        k = MiscUtils.poisson(1, random);
-                        break;
-                    case 2: //Split-Validation;
-                        k = instancesProcessed % learners.length == i ? 1: 0; //Test only one
-                        break;
-                }
-                if (k > 0) {
-                    this.trainInstances.get(i).addLast(trainInst);
-                }
-                if(this.delayLengthOption.getValue() < this.trainInstances.get(i).size()) {
-                    Example trainInstI = this.trainInstances.get(i).removeFirst();
-                    learners[i].trainOnInstance(trainInstI);
-                }
-            }
-            
-            if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0
-                    || stream.hasMoreInstances() == false) {
-                long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-                double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);
-                double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);
-
-                for (int i = 0; i < learners.length; i++) {
-                    double RAMHoursIncrement = learners[i].measureByteSize() / (1024.0 * 1024.0 * 1024.0); //GBs
-                    RAMHoursIncrement *= (timeIncrement / 3600.0); //Hours
-                    RAMHours += RAMHoursIncrement;
-                }
-
-                lastEvaluateStartTime = evaluateTime;
-                learningCurve.insertEntry(new LearningEvaluation(
-                        getEvaluationMeasurements(
-                        new Measurement[]{
-                                new Measurement(
-                                        "learning evaluation instances",
-                                        instancesProcessed),
-                                new Measurement(
-                                        "evaluation time ("
-                                                + (preciseCPUTiming ? "cpu "
-                                                : "") + "seconds)",
-                                        time),
-                                new Measurement(
-                                        "model cost (RAM-Hours)",
-                                        RAMHours)
-                        }, evaluators)));
-
-                if (immediateResultStream != null) {
-                    if (firstDump) {
-                        immediateResultStream.println(learningCurve.headerToString());
-                        firstDump = false;
-                    }
-                    immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
-                    immediateResultStream.flush();
-                }
-            }
-            if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
-                if (monitor.taskShouldAbort()) {
-                    return null;
-                }
-                long estimatedRemainingInstances = stream.estimatedRemainingInstances();
-                if (maxInstances > 0) {
-                    long maxRemaining = maxInstances - instancesProcessed;
-                    if ((estimatedRemainingInstances < 0)
-                            || (maxRemaining < estimatedRemainingInstances)) {
-                        estimatedRemainingInstances = maxRemaining;
-                    }
-                }
-                monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
-                        : (double) instancesProcessed
-                        / (double) (instancesProcessed + estimatedRemainingInstances));
-                if (monitor.resultPreviewRequested()) {
-                    monitor.setLatestResultPreview(learningCurve.copy());
-                }
-                secondsElapsed = (int) TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread()
-                        - evaluateStartTime);
-            }
-        }
-        if (immediateResultStream != null) {
-            immediateResultStream.close();
-        }
-        return learningCurve;
-    }
-
-
-    public Measurement[] getEvaluationMeasurements(Measurement[] modelMeasurements, LearningPerformanceEvaluator[] subEvaluators) {
-        List<Measurement> measurementList = new LinkedList<>();
-        if (modelMeasurements != null) {
-            measurementList.addAll(Arrays.asList(modelMeasurements));
-        }
-        // add average of sub-model measurements
-        if ((subEvaluators != null) && (subEvaluators.length > 0)) {
-            List<Measurement[]> subMeasurements = new LinkedList<>();
-            for (LearningPerformanceEvaluator subEvaluator : subEvaluators) {
-                if (subEvaluator != null) {
-                    subMeasurements.add(subEvaluator.getPerformanceMeasurements());
-                }
-            }
-            Measurement[] avgMeasurements = Measurement.averageMeasurements(subMeasurements.toArray(new Measurement[subMeasurements.size()][]));
-            measurementList.addAll(Arrays.asList(avgMeasurements));
-        }
-        return measurementList.toArray(new Measurement[measurementList.size()]);
-    }
+public class EvaluatePrequentialDelayedCV extends AbstractEvaluatePrequentialCV<Classifier>
+		implements ClassificationMainTask {
+
+	@Override
+	public String getPurposeString() {
+		return "Evaluates a classifier using delayed cross-validation evaluation "
+				+ "by testing and only training with the example after the arrival of other k examples (delayed labeling) ";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption learnerOption = new ClassOption("learner", 'l', "Learner to train.", Classifier.class,
+			"bayes.NaiveBayes");
+
+	public ClassOption streamOption = new ClassOption("stream", 's', "Stream to learn from.", ExampleStream.class,
+			"generators.RandomTreeGenerator");
+
+	public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
+			"Classification performance evaluation method.", LearningPerformanceEvaluator.class,
+			"WindowClassificationPerformanceEvaluator");
+
+	public IntOption delayLengthOption = new IntOption("delay", 'k',
+			"Number of instances before test instance is used for training", 1000, 1, Integer.MAX_VALUE);
+
+	public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
+			"Maximum number of instances to test/train on  (-1 = no limit).", 100000000, -1, Integer.MAX_VALUE);
+
+	public IntOption timeLimitOption = new IntOption("timeLimit", 't',
+			"Maximum number of seconds to test/train for (-1 = no limit).", -1, -1, Integer.MAX_VALUE);
+
+	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency", 'f',
+			"How many instances between samples of the learning performance.", 100000, 0, Integer.MAX_VALUE);
+
+	public IntOption memCheckFrequencyOption = new IntOption("memCheckFrequency", 'q',
+			"How many instances between memory bound checks.", 100000, 0, Integer.MAX_VALUE);
+
+	public FileOption dumpFileOption = new FileOption("dumpFile", 'd', "File to append intermediate csv results to.",
+			null, "csv", true);
+
+	public IntOption numFoldsOption = new IntOption("numFolds", 'w',
+			"The number of folds (e.g. distributed models) to be used.", 10, 1, Integer.MAX_VALUE);
+
+	public MultiChoiceOption validationMethodologyOption = new MultiChoiceOption("validationMethodology", 'a',
+			"Validation methodology to use.",
+			new String[] { "Cross-Validation", "Bootstrap-Validation", "Split-Validation" },
+			new String[] { "k-fold distributed Cross Validation", "k-fold distributed Bootstrap Validation",
+					"k-fold distributed Split Validation" },
+			0);
+
+	public IntOption randomSeedOption = new IntOption("randomSeed", 'r', "Seed for random behaviour of the task.", 1);
+
+	// Buffer of instances to use for training.
+	// Note: It is a list of lists because it stores instances per learner, e.g.
+	// CV of 10, would be 10 lists of buffered instances for delayed training.
+	protected LinkedList<LinkedList<Example>> trainInstances;
+
+	@Override
+	public Class<?> getTaskResultType() {
+		return LearningCurve.class;
+	}
+
+	@Override
+	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
+
+		Random random = new Random(this.randomSeedOption.getValue());
+		ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
+
+		MLTask[] learners = new MLTask[this.numFoldsOption.getValue()];
+		MLTask baseLearner = (MLTask) getPreparedClassOption(this.learnerOption);
+		baseLearner.resetLearning();
+
+		LearningPerformanceEvaluator[] evaluators = new LearningPerformanceEvaluator[this.numFoldsOption.getValue()];
+		LearningPerformanceEvaluator baseEvaluator = (LearningPerformanceEvaluator) getPreparedClassOption(
+				this.evaluatorOption);
+		for (int i = 0; i < learners.length; i++) {
+			learners[i] = (MLTask) baseLearner.copy();
+			learners[i].setModelContext(stream.getHeader());
+			evaluators[i] = (LearningPerformanceEvaluator) baseEvaluator.copy();
+		}
+
+		LearningCurve learningCurve = new LearningCurve("learning evaluation instances");
+		int maxInstances = this.instanceLimitOption.getValue();
+		long instancesProcessed = 0;
+		int maxSeconds = this.timeLimitOption.getValue();
+		int secondsElapsed = 0;
+		monitor.setCurrentActivity("Evaluating learner...", -1.0);
+
+		this.trainInstances = new LinkedList<>();
+
+		for (int i = 0; i < learners.length; i++) {
+			this.trainInstances.add(new LinkedList<Example>());
+		}
+		File dumpFile = this.dumpFileOption.getFile();
+		PrintStream immediateResultStream = null;
+		if (dumpFile != null) {
+			try {
+				if (dumpFile.exists()) {
+					immediateResultStream = new PrintStream(new FileOutputStream(dumpFile, true), true);
+				} else {
+					immediateResultStream = new PrintStream(new FileOutputStream(dumpFile), true);
+				}
+			} catch (Exception ex) {
+				throw new RuntimeException("Unable to open immediate result file: " + dumpFile, ex);
+			}
+		}
+
+		boolean firstDump = true;
+		boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
+		long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+		long lastEvaluateStartTime = evaluateStartTime;
+		double RAMHours = 0.0;
+
+		while (stream.hasMoreInstances() && ((maxInstances < 0) || (instancesProcessed < maxInstances))
+				&& ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
+
+			Example trainInst = stream.nextInstance();
+			Example testInst = trainInst;
+
+			instancesProcessed++;
+			for (int i = 0; i < learners.length; i++) {
+
+				double[] prediction = learners[i].getPredictionForInstance(testInst).asDoubleArray();
+				evaluators[i].addResult(testInst, prediction);
+
+				int k = 1;
+				switch (this.validationMethodologyOption.getChosenIndex()) {
+				case 0: // Cross-Validation;
+					k = instancesProcessed % learners.length == i ? 0 : 1; // Test all except one
+					break;
+				case 1: // Bootstrap;
+					k = MiscUtils.poisson(1, random);
+					break;
+				case 2: // Split-Validation;
+					k = instancesProcessed % learners.length == i ? 1 : 0; // Test only one
+					break;
+				}
+				if (k > 0) {
+					this.trainInstances.get(i).addLast(trainInst);
+				}
+				if (this.delayLengthOption.getValue() < this.trainInstances.get(i).size()) {
+					Example trainInstI = this.trainInstances.get(i).removeFirst();
+					learners[i].trainOnInstance(trainInstI);
+				}
+			}
+
+			if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0 || stream.hasMoreInstances() == false) {
+				long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+				double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);
+				double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);
+
+				for (int i = 0; i < learners.length; i++) {
+					double RAMHoursIncrement = learners[i].measureByteSize() / (1024.0 * 1024.0 * 1024.0); // GBs
+					RAMHoursIncrement *= (timeIncrement / 3600.0); // Hours
+					RAMHours += RAMHoursIncrement;
+				}
+
+				lastEvaluateStartTime = evaluateTime;
+				learningCurve
+						.insertEntry(new LearningEvaluation(getEvaluationMeasurements(
+								new Measurement[] {
+										new Measurement("learning evaluation instances", instancesProcessed),
+										new Measurement(
+												"evaluation time (" + (preciseCPUTiming ? "cpu " : "") + "seconds)",
+												time),
+										new Measurement("model cost (RAM-Hours)", RAMHours) },
+								evaluators)));
+
+				if (immediateResultStream != null) {
+					if (firstDump) {
+						immediateResultStream.println(learningCurve.headerToString());
+						firstDump = false;
+					}
+					immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
+					immediateResultStream.flush();
+				}
+			}
+			if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
+				if (monitor.taskShouldAbort()) {
+					return null;
+				}
+				long estimatedRemainingInstances = stream.estimatedRemainingInstances();
+				if (maxInstances > 0) {
+					long maxRemaining = maxInstances - instancesProcessed;
+					if ((estimatedRemainingInstances < 0) || (maxRemaining < estimatedRemainingInstances)) {
+						estimatedRemainingInstances = maxRemaining;
+					}
+				}
+				monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
+						: (double) instancesProcessed / (double) (instancesProcessed + estimatedRemainingInstances));
+				if (monitor.resultPreviewRequested()) {
+					monitor.setLatestResultPreview(learningCurve.copy());
+				}
+				secondsElapsed = (int) TimingUtils
+						.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread() - evaluateStartTime);
+			}
+		}
+		if (immediateResultStream != null) {
+			immediateResultStream.close();
+		}
+		return learningCurve;
+	}
+
+	@Override
+	public Measurement[] getEvaluationMeasurements(Measurement[] modelMeasurements,
+			LearningPerformanceEvaluator[] subEvaluators) {
+		List<Measurement> measurementList = new LinkedList<>();
+		if (modelMeasurements != null) {
+			measurementList.addAll(Arrays.asList(modelMeasurements));
+		}
+		// add average of sub-model measurements
+		if ((subEvaluators != null) && (subEvaluators.length > 0)) {
+			List<Measurement[]> subMeasurements = new LinkedList<>();
+			for (LearningPerformanceEvaluator subEvaluator : subEvaluators) {
+				if (subEvaluator != null) {
+					subMeasurements.add(subEvaluator.getPerformanceMeasurements());
+				}
+			}
+			Measurement[] avgMeasurements = Measurement
+					.averageMeasurements(subMeasurements.toArray(new Measurement[subMeasurements.size()][]));
+			measurementList.addAll(Arrays.asList(avgMeasurements));
+		}
+		return measurementList.toArray(new Measurement[measurementList.size()]);
+	}
 }
diff --git a/moa/src/main/java/moa/tasks/classification/LearnModel.java b/moa/src/main/java/moa/tasks/classification/LearnModel.java
index 343b4103f..c8ce6f4b6 100644
--- a/moa/src/main/java/moa/tasks/classification/LearnModel.java
+++ b/moa/src/main/java/moa/tasks/classification/LearnModel.java
@@ -1,20 +1,31 @@
 package moa.tasks.classification;
 
-import moa.learners.Classifier;
+import moa.capabilities.CapabilitiesHandler;
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
+import moa.learners.predictors.Classifier;
 import moa.options.ClassOption;
 import moa.tasks.AbstractLearnModel;
 
-public class LearnModel extends AbstractLearnModel<Classifier> implements ClassificationMainTask {
+public class LearnModel extends AbstractLearnModel<Classifier> implements ClassificationMainTask, CapabilitiesHandler {
 
-    @Override
-    public String getPurposeString() {
-        return "Learns a Classification model from a stream.";
-    }
+	@Override
+	public String getPurposeString() {
+		return "Learns a Classification model from a stream.";
+	}
+
+	private static final long serialVersionUID = 1L;
 
-    private static final long serialVersionUID = 1L;
+	public LearnModel() {
+		this.learnerOption = new ClassOption("learner", 'l', "Learner to train.", Classifier.class,
+				"trees.HoeffdingTree");
+	}
 
-    public LearnModel() {
-		this.learnerOption = new ClassOption("learner", 'l', "Learner to train.", Classifier.class, "moa.classifiers.trees.HoeffdingTree");
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == LearnModel.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
 	}
-	
 }
diff --git a/moa/src/main/java/moa/tasks/clustering/EvaluateClustering.java b/moa/src/main/java/moa/tasks/clustering/EvaluateClustering.java
index a5f7492b2..d6e1b4abf 100644
--- a/moa/src/main/java/moa/tasks/clustering/EvaluateClustering.java
+++ b/moa/src/main/java/moa/tasks/clustering/EvaluateClustering.java
@@ -1,9 +1,9 @@
 /**
  * EvaluateClustering.java
- * 
+ *
  * @author Albert Bifet (abifet@cs.waikato.ac.nz)
  * @editor Yunsu Kim
- * 
+ *
  * Last edited: 2013/06/02
  */
 package moa.tasks.clustering;
@@ -12,10 +12,10 @@
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.IntOption;
 
-import moa.clusterers.AbstractClusterer;
 import moa.core.ObjectRepository;
 import moa.evaluation.preview.LearningCurve;
 import moa.gui.BatchCmd;
+import moa.learners.clusterers.AbstractClusterer;
 import moa.options.ClassOption;
 import moa.streams.clustering.ClusteringStream;
 import moa.tasks.MainTask;
@@ -29,109 +29,107 @@
  */
 public class EvaluateClustering extends MainTask {
 
-    @Override
-    public String getPurposeString() {
-        return "Evaluates a clusterer on a stream.";
-    }
+	@Override
+	public String getPurposeString() {
+		return "Evaluates a clusterer on a stream.";
+	}
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public ClassOption learnerOption = new ClassOption("learner", 'l',
-            "Clusterer to train.", AbstractClusterer.class, "clustream.Clustream");
+	public ClassOption learnerOption = new ClassOption("learner", 'l', "Clusterer to train.", AbstractClusterer.class,
+			"clustream.Clustream");
 
-    public ClassOption streamOption = new ClassOption("stream", 's',
-            "Stream to learn from.",  ClusteringStream.class,
-            "RandomRBFGeneratorEvents");
+	public ClassOption streamOption = new ClassOption("stream", 's', "Stream to learn from.", ClusteringStream.class,
+			"RandomRBFGeneratorEvents");
 
-    public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
-            "Maximum number of instances to test/train on  (-1 = no limit).",
-            100000, -1, Integer.MAX_VALUE);
+	public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
+			"Maximum number of instances to test/train on  (-1 = no limit).", 100000, -1, Integer.MAX_VALUE);
 
-    public FlagOption generalEvalOption = new FlagOption("General", 'g',
+	public FlagOption generalEvalOption = new FlagOption("General", 'g',
 			"GPrecision, GRecall, Redundancy, numCluster, numClasses");
-   
-    public FlagOption f1Option = new FlagOption("F1", 'f', "F1-P, F1-R, Purity.");
-    
-    public FlagOption entropyOption = new FlagOption("Entropy", 'e',
+
+	public FlagOption f1Option = new FlagOption("F1", 'f', "F1-P, F1-R, Purity.");
+
+	public FlagOption entropyOption = new FlagOption("Entropy", 'e',
 			"GT cross entropy, FC cross entropy, Homogeneity, Completeness, V-Measure, VarInformation.");
-    
-    public FlagOption cmmOption = new FlagOption("CMM", 'c',
+
+	public FlagOption cmmOption = new FlagOption("CMM", 'c',
 			"CMM, CMM Basic, CMM Missed, CMM Misplaced, CMM Noise, CA Seperability, CA Noise, CA Model.");
 
-    public FlagOption ssqOption = new FlagOption("SSQ", 'q', "SSQ.");
-    
-    public FlagOption separationOption = new FlagOption("Separation", 'p', "BSS, BSS-GT, BSS-Ratio.");
-    
-    public FlagOption silhouetteOption = new FlagOption("Silhouette", 'h', "SilhCoeff.");
-    
-    public FlagOption statisticalOption = new FlagOption("Statistical", 't', "van Dongen, Rand statistic.");
-
-    /*public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
-    "Performance evaluation method.",
-    LearningPerformanceEvaluator.class,
-    "BasicClusteringPerformanceEvaluator");*/
-
-    /*public IntOption timeLimitOption = new IntOption("timeLimit", 't',
-    "Maximum number of seconds to test/train for (-1 = no limit).", -1,
-    -1, Integer.MAX_VALUE);
-
-    public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
-    'f',
-    "How many instances between samples of the learning performance.",
-    100000, 0, Integer.MAX_VALUE);
-
-    public IntOption maxMemoryOption = new IntOption("maxMemory", 'b',
-    "Maximum size of model (in bytes). -1 = no limit.", -1, -1,
-    Integer.MAX_VALUE);
-
-    public IntOption memCheckFrequencyOption = new IntOption(
-    "memCheckFrequency", 'q',
-    "How many instances between memory bound checks.", 100000, 0,
-    Integer.MAX_VALUE);*/
-    public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
-            "File to append intermediate csv reslts to.", "dumpClustering.csv", "csv", true);
-
-    @Override
-    public Class<?> getTaskResultType() {
-        return LearningCurve.class;
-    }
-
-    // Given an array summarizing selected measures, set the appropriate flag options
-    protected void setMeasures(boolean[] measures)
-    {
-    	this.generalEvalOption.setValue(measures[0]);
-    	this.f1Option.setValue(measures[1]);
-    	this.entropyOption.setValue(measures[2]);
-    	this.cmmOption.setValue(measures[3]);
-    	this.ssqOption.setValue(measures[4]);
-    	this.separationOption.setValue(measures[5]);
-    	this.silhouetteOption.setValue(measures[6]);
-    	this.statisticalOption.setValue(measures[7]);
-    }
-
-    @Override
-    protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
-
-    	// Create an array to summarize the selected measures
-    	boolean[] measureCollection = new boolean[8];
-    	measureCollection[0] = this.generalEvalOption.isSet();
-    	measureCollection[1] = this.f1Option.isSet();
-    	measureCollection[2] = this.entropyOption.isSet();
-    	measureCollection[3] = this.cmmOption.isSet();
-    	measureCollection[4] = this.ssqOption.isSet();
-    	measureCollection[5] = this.separationOption.isSet();
-    	measureCollection[6] = this.silhouetteOption.isSet();
-    	measureCollection[7] = this.statisticalOption.isSet();
-    	
-        BatchCmd.runBatch((ClusteringStream) getPreparedClassOption(this.streamOption),
-                (AbstractClusterer) getPreparedClassOption(this.learnerOption),
-                measureCollection,
-                (int) this.instanceLimitOption.getValue(),
-                (String) dumpFileOption.getValue());
-
-        LearningCurve learningCurve = new LearningCurve("EvaluateClustering does not support custom output file (> [filename]).\n" +
-        												"Check out the dump file to see the results (if you haven't specified, dumpClustering.csv by default).");
-        //System.out.println(learner.toString());
-        return learningCurve;
-    }
+	public FlagOption ssqOption = new FlagOption("SSQ", 'q', "SSQ.");
+
+	public FlagOption separationOption = new FlagOption("Separation", 'p', "BSS, BSS-GT, BSS-Ratio.");
+
+	public FlagOption silhouetteOption = new FlagOption("Silhouette", 'h', "SilhCoeff.");
+
+	public FlagOption statisticalOption = new FlagOption("Statistical", 't', "van Dongen, Rand statistic.");
+
+	/*
+	 * public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
+	 * "Performance evaluation method.", LearningPerformanceEvaluator.class,
+	 * "BasicClusteringPerformanceEvaluator");
+	 */
+
+	/*
+	 * public IntOption timeLimitOption = new IntOption("timeLimit", 't',
+	 * "Maximum number of seconds to test/train for (-1 = no limit).", -1, -1,
+	 * Integer.MAX_VALUE);
+	 * 
+	 * public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
+	 * 'f', "How many instances between samples of the learning performance.",
+	 * 100000, 0, Integer.MAX_VALUE);
+	 * 
+	 * public IntOption maxMemoryOption = new IntOption("maxMemory", 'b',
+	 * "Maximum size of model (in bytes). -1 = no limit.", -1, -1,
+	 * Integer.MAX_VALUE);
+	 * 
+	 * public IntOption memCheckFrequencyOption = new IntOption(
+	 * "memCheckFrequency", 'q', "How many instances between memory bound checks.",
+	 * 100000, 0, Integer.MAX_VALUE);
+	 */
+	public FileOption dumpFileOption = new FileOption("dumpFile", 'd', "File to append intermediate csv reslts to.",
+			"dumpClustering.csv", "csv", true);
+
+	@Override
+	public Class<?> getTaskResultType() {
+		return LearningCurve.class;
+	}
+
+	// Given an array summarizing selected measures, set the appropriate flag
+	// options
+	protected void setMeasures(boolean[] measures) {
+		this.generalEvalOption.setValue(measures[0]);
+		this.f1Option.setValue(measures[1]);
+		this.entropyOption.setValue(measures[2]);
+		this.cmmOption.setValue(measures[3]);
+		this.ssqOption.setValue(measures[4]);
+		this.separationOption.setValue(measures[5]);
+		this.silhouetteOption.setValue(measures[6]);
+		this.statisticalOption.setValue(measures[7]);
+	}
+
+	@Override
+	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
+
+		// Create an array to summarize the selected measures
+		boolean[] measureCollection = new boolean[8];
+		measureCollection[0] = this.generalEvalOption.isSet();
+		measureCollection[1] = this.f1Option.isSet();
+		measureCollection[2] = this.entropyOption.isSet();
+		measureCollection[3] = this.cmmOption.isSet();
+		measureCollection[4] = this.ssqOption.isSet();
+		measureCollection[5] = this.separationOption.isSet();
+		measureCollection[6] = this.silhouetteOption.isSet();
+		measureCollection[7] = this.statisticalOption.isSet();
+
+		BatchCmd.runBatch((ClusteringStream) getPreparedClassOption(this.streamOption),
+				(AbstractClusterer) getPreparedClassOption(this.learnerOption), measureCollection,
+				this.instanceLimitOption.getValue(), dumpFileOption.getValue());
+
+		LearningCurve learningCurve = new LearningCurve(
+				"EvaluateClustering does not support custom output file (> [filename]).\n"
+						+ "Check out the dump file to see the results (if you haven't specified, dumpClustering.csv by default).");
+		// System.out.println(learner.toString());
+		return learningCurve;
+	}
 }
diff --git a/moa/src/main/java/moa/tasks/clustering/EvaluateMultipleClusterings.java b/moa/src/main/java/moa/tasks/clustering/EvaluateMultipleClusterings.java
index 95f60cde2..8557a04ab 100644
--- a/moa/src/main/java/moa/tasks/clustering/EvaluateMultipleClusterings.java
+++ b/moa/src/main/java/moa/tasks/clustering/EvaluateMultipleClusterings.java
@@ -15,25 +15,28 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks.clustering;
 
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
-import java.io.StringReader;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
 import com.github.javacliparser.FileOption;
 import com.github.javacliparser.FlagOption;
 import com.github.javacliparser.IntOption;
-import com.opencsv.*;
+import com.opencsv.CSVParser;
+import com.opencsv.CSVParserBuilder;
+import com.opencsv.CSVReader;
+import com.opencsv.CSVReaderBuilder;
+import com.opencsv.CSVWriter;
 
-import moa.clusterers.AbstractClusterer;
 import moa.core.ObjectRepository;
 import moa.gui.visualization.RunVisualizer;
+import moa.learners.clusterers.AbstractClusterer;
 import moa.options.ClassOption;
 import moa.streams.clustering.ClusteringStream;
 import moa.streams.clustering.FileStream;
@@ -48,311 +51,267 @@
 public class EvaluateMultipleClusterings extends AuxiliarMainTask {
 
 	/**
-	 * 
+	 *
 	 */
 	private static final long serialVersionUID = 4846907962483608940L;
 
 	@Override
-	public String getPurposeString()
-	{
+	public String getPurposeString() {
 		return "Evaluates a clusterer on multiple (related) streams.";
 	}
 
 	String defaultfile = "covtypeNorm.arff";
-	
-	public ClassOption learnerOption = new ClassOption("learner", 'l',
-			"Clusterer to train.", AbstractClusterer.class, "clustream.Clustream");
 
-	public ClassOption streamOption = new ClassOption("stream", 's',
-            "Base stream to learn from (must use FileStream).",  ClusteringStream.class,
-            "FileStream");
+	public ClassOption learnerOption = new ClassOption("learner", 'l', "Clusterer to train.", AbstractClusterer.class,
+			"clustream.Clustream");
+
+	public ClassOption streamOption = new ClassOption("stream", 's', "Base stream to learn from (must use FileStream).",
+			ClusteringStream.class, "FileStream");
 
 	public IntOption numStreamsOption = new IntOption("numStreams", 'n',
 			"The number of streams to iterate through (must be named according to WriteMultipleStreamsToARFF format.",
 			100, 2, Integer.MAX_VALUE);
 
-	public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
-			"File to append intermediate csv reslts to.", "dumpClustering.csv", "csv", true);
-	
-	public FlagOption mergeResultsOption = new FlagOption("mergeResults", 'm', 
+	public FileOption dumpFileOption = new FileOption("dumpFile", 'd', "File to append intermediate csv reslts to.",
+			"dumpClustering.csv", "csv", true);
+
+	public FlagOption mergeResultsOption = new FlagOption("mergeResults", 'm',
 			"Produce a csv file that contains all of the individual results merged together.");
-	
+
 	public FlagOption generalEvalOption = new FlagOption("General", 'g',
 			"GPrecision, GRecall, Redundancy, numCluster, numClasses");
-   
-    public FlagOption f1Option = new FlagOption("F1", 'f', "F1-P, F1-R, Purity.");
-    
-    public FlagOption entropyOption = new FlagOption("Entropy", 'e',
+
+	public FlagOption f1Option = new FlagOption("F1", 'f', "F1-P, F1-R, Purity.");
+
+	public FlagOption entropyOption = new FlagOption("Entropy", 'e',
 			"GT cross entropy, FC cross entropy, Homogeneity, Completeness, V-Measure, VarInformation.");
-    
-    public FlagOption cmmOption = new FlagOption("CMM", 'c',
+
+	public FlagOption cmmOption = new FlagOption("CMM", 'c',
 			"CMM, CMM Basic, CMM Missed, CMM Misplaced, CMM Noise, CA Seperability, CA Noise, CA Model.");
 
-    public FlagOption ssqOption = new FlagOption("SSQ", 'q', "SSQ.");
-    
-    public FlagOption separationOption = new FlagOption("Separation", 'p', "BSS, BSS-GT, BSS-Ratio.");
-    
-    public FlagOption silhouetteOption = new FlagOption("Silhouette", 'h', "SilhCoeff.");
-    
-    public FlagOption statisticalOption = new FlagOption("Statistical", 't', "van Dongen, Rand statistic.");
+	public FlagOption ssqOption = new FlagOption("SSQ", 'q', "SSQ.");
 
+	public FlagOption separationOption = new FlagOption("Separation", 'p', "BSS, BSS-GT, BSS-Ratio.");
+
+	public FlagOption silhouetteOption = new FlagOption("Silhouette", 'h', "SilhCoeff.");
+
+	public FlagOption statisticalOption = new FlagOption("Statistical", 't', "van Dongen, Rand statistic.");
 
 	protected EvaluateClustering task;
-	
+
 	@Override
-	public Class<?> getTaskResultType()
-	{
+	public Class<?> getTaskResultType() {
 		return Object.class;
 	}
 
 	@Override
-	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository)
-	{
+	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
 		Object result = null;
 		String arffFile, outputFile;
 		FileStream fStream;
-		
+
 		String mergedFile = this.dumpFileOption.getValueAsCLIString();
-		String tempFile = mergedFile.substring(0, mergedFile.length()-4).concat("*.csv");
-		
-		for(int i = 0 ; i < this.numStreamsOption.getValue() ; i++)
-		{
+		String tempFile = mergedFile.substring(0, mergedFile.length() - 4).concat("*.csv");
+
+		for (int i = 0; i < this.numStreamsOption.getValue(); i++) {
 			// Get Base task
-            this.task = new EvaluateClustering();
-            
-            // Learner
-            this.task.learnerOption.setValueViaCLIString(this.learnerOption.getValueAsCLIString());
-            
-            // Build stream
-            fStream = (FileStream) getPreparedClassOption(this.streamOption);
-            arffFile = fStream.arffFileOption.getValueAsCLIString();
-            arffFile = arffFile.substring(0, arffFile.lastIndexOf('n')+1).concat(i+".arff");
-            fStream.arffFileOption.setValueViaCLIString(arffFile);
-            this.task.streamOption.setValueViaCLIString(fStream.getCLICreationString(fStream.getClass()));
-            
-            // Build Output File
-            outputFile = this.dumpFileOption.getValueAsCLIString();
-            if(outputFile.endsWith(".csv"))
-			{
-            	outputFile = outputFile.substring(0, outputFile.length()-4);
+			this.task = new EvaluateClustering();
+
+			// Learner
+			this.task.learnerOption.setValueViaCLIString(this.learnerOption.getValueAsCLIString());
+
+			// Build stream
+			fStream = (FileStream) getPreparedClassOption(this.streamOption);
+			arffFile = fStream.arffFileOption.getValueAsCLIString();
+			arffFile = arffFile.substring(0, arffFile.lastIndexOf('n') + 1).concat(i + ".arff");
+			fStream.arffFileOption.setValueViaCLIString(arffFile);
+			this.task.streamOption.setValueViaCLIString(fStream.getCLICreationString(fStream.getClass()));
+
+			// Build Output File
+			outputFile = this.dumpFileOption.getValueAsCLIString();
+			if (outputFile.endsWith(".csv")) {
+				outputFile = outputFile.substring(0, outputFile.length() - 4);
+			}
+			outputFile = outputFile.concat("n" + i + ".csv");
+			this.task.dumpFileOption.setValueViaCLIString(outputFile);
+
+			// Instance Limit
+			this.task.instanceLimitOption.setValue(-1);
+
+			// Measure Collection
+			// Create an array to summarize the selected measures
+			boolean[] measureCollection = new boolean[8];
+			measureCollection[0] = this.generalEvalOption.isSet();
+			measureCollection[1] = this.f1Option.isSet();
+			measureCollection[2] = this.entropyOption.isSet();
+			measureCollection[3] = this.cmmOption.isSet();
+			measureCollection[4] = this.ssqOption.isSet();
+			measureCollection[5] = this.separationOption.isSet();
+			measureCollection[6] = this.silhouetteOption.isSet();
+			measureCollection[7] = this.statisticalOption.isSet();
+
+			this.task.setMeasures(measureCollection);
+
+			System.out.println("Evaluation #" + (i + 1) + " of " + this.numStreamsOption.getValue() + ": "
+					+ this.task.getCLICreationString(this.task.getClass()));
+
+			// Run task
+			result = this.task.doTask(monitor, repository);
+
+			if (this.mergeResultsOption.isSet()) {
+				System.out.println("Merge " + mergedFile + " and " + outputFile);
+				if (i == 0)
+					writeToMergeFile(mergedFile, outputFile);
+				else
+					mergeFiles(mergedFile, outputFile, tempFile);
 			}
-            outputFile = outputFile.concat("n"+i+".csv");
-            this.task.dumpFileOption.setValueViaCLIString(outputFile);
-            
-            // Instance Limit
-            this.task.instanceLimitOption.setValue(-1);
-            
-            // Measure Collection
-            // Create an array to summarize the selected measures
-        	boolean[] measureCollection = new boolean[8];
-        	measureCollection[0] = this.generalEvalOption.isSet();
-        	measureCollection[1] = this.f1Option.isSet();
-        	measureCollection[2] = this.entropyOption.isSet();
-        	measureCollection[3] = this.cmmOption.isSet();
-        	measureCollection[4] = this.ssqOption.isSet();
-        	measureCollection[5] = this.separationOption.isSet();
-        	measureCollection[6] = this.silhouetteOption.isSet();
-        	measureCollection[7] = this.statisticalOption.isSet();
-            
-            this.task.setMeasures(measureCollection);
-            
-            System.out.println("Evaluation #"+(i+1)+" of "+this.numStreamsOption.getValue()+
-            		": "+this.task.getCLICreationString(this.task.getClass()));
-            
-            //Run task
-            result = this.task.doTask(monitor, repository);
-            
-            if(this.mergeResultsOption.isSet())
-            {
-            	System.out.println("Merge "+mergedFile+" and "+outputFile);
-            	if (i == 0)
-            		writeToMergeFile(mergedFile, outputFile);
-            	else
-            		mergeFiles(mergedFile, outputFile, tempFile);
-            }
 		}
 
 		return result;
 	}
-	
-	private void writeToMergeFile(String mergedFile, String outputFile)
-	{
+
+	private void writeToMergeFile(String mergedFile, String outputFile) {
 		CSVWriter writer = null;
 		CSVParser parser = null;
 		CSVReader reader = null;
-		
-		//System.out.println("WTMF: "+mergedFile+" <-- "+outputFile);
-		
-		try
-		{
-			// Prepare an output file			
-			if (!mergedFile.endsWith(".csv"))
-			{
+
+		// System.out.println("WTMF: "+mergedFile+" <-- "+outputFile);
+
+		try {
+			// Prepare an output file
+			if (!mergedFile.endsWith(".csv")) {
 				mergedFile += ".csv";
 			}
 
-			writer = new CSVWriter(new FileWriter(mergedFile),';', '\"', '\\', "\n");
+			writer = new CSVWriter(new FileWriter(mergedFile), ';', '\"', '\\', "\n");
 			parser = new CSVParserBuilder().withSeparator(';').withIgnoreQuotations(false).build();
 			reader = new CSVReaderBuilder(new FileReader(outputFile)).withCSVParser(parser).build();
-			
+
 			String[] nextLine = reader.readNext();
-			while(nextLine != null)
-			{
+			while (nextLine != null) {
 				writer.writeNext(nextLine);
 				nextLine = reader.readNext();
 			}
-		}
-		catch (IOException ex)
-		{
+		} catch (IOException ex) {
 			Logger.getLogger(RunVisualizer.class.getName()).log(Level.SEVERE, null, ex);
-		}
-		finally
-		{
-			try
-			{
+		} finally {
+			try {
 				writer.close();
 				reader.close();
-			}
-			catch (IOException e)
-			{
+			} catch (IOException e) {
 				e.printStackTrace();
 			}
 		}
 	}
 
-	private void mergeFiles(String mergedFile, String outputFile, String tempFile)
-	{
+	private void mergeFiles(String mergedFile, String outputFile, String tempFile) {
 		CSVWriter writer = null;
 		CSVParser parser1 = null;
 		CSVReader reader1 = null;
 		CSVParser parser2 = null;
 		CSVReader reader2 = null;
 
-		//System.out.println("mergeFiles "+mergedFile+" * "+outputFile+" (temp: "+tempFile+")");
-		
-		try
-		{
-			// Prepare an output file			
-			if (!mergedFile.endsWith(".csv"))
-			{
+		// System.out.println("mergeFiles "+mergedFile+" * "+outputFile+" (temp:
+		// "+tempFile+")");
+
+		try {
+			// Prepare an output file
+			if (!mergedFile.endsWith(".csv")) {
 				mergedFile += ".csv";
 			}
-			writer = new CSVWriter(new FileWriter(tempFile),';', '\"', '\\', "\n");
+			writer = new CSVWriter(new FileWriter(tempFile), ';', '\"', '\\', "\n");
 			parser1 = new CSVParserBuilder().withSeparator(';').withIgnoreQuotations(false).build();
 			reader1 = new CSVReaderBuilder(new FileReader(mergedFile)).withCSVParser(parser1).build();
 			parser2 = new CSVParserBuilder().withSeparator(';').withIgnoreQuotations(false).build();
 			reader2 = new CSVReaderBuilder(new FileReader(outputFile)).withCSVParser(parser2).build();
 
-
 			int state = 0;
-			
+
 			String[] nextLine1 = reader1.readNext();
 			int mergedWidth = nextLine1.length;
 			String[] nextLine2 = reader2.readNext();
 			int outputWidth = nextLine2.length;
 			String[] nextLine = mergeArrays(nextLine1, nextLine2);
-			
+
 			writer.writeNext(nextLine);
 
 			// While both mergedFile and outputFile have lines remaining
-			while(state == 0)
-			{
+			while (state == 0) {
 				nextLine1 = reader1.readNext();
-				if(nextLine1 == null)
-				{
+				if (nextLine1 == null) {
 					nextLine1 = new String[mergedWidth];
 					state += 1;
 				}
-				
+
 				nextLine2 = reader2.readNext();
-				if(nextLine2 == null)
-				{
+				if (nextLine2 == null) {
 					nextLine2 = new String[outputWidth];
 					state += 2;
 				}
-				
-				if(state == 3)
-				{
+
+				if (state == 3) {
 					break;
 				}
-				
+
 				nextLine = mergeArrays(nextLine1, nextLine2);
 				writer.writeNext(nextLine);
 			}
-			
+
 			// While only outputFile has lines remaining
-			while(state == 1)
-			{
+			while (state == 1) {
 				nextLine2 = reader2.readNext();
-				if(nextLine == null)
-				{
+				if (nextLine == null) {
 					break;
-				}
-				else
-				{
+				} else {
 					nextLine1 = new String[mergedWidth];
 					nextLine = mergeArrays(nextLine1, nextLine2);
 					writer.writeNext(nextLine);
 				}
 			}
-			
+
 			// While only mergedFile has lines remaining
-			while(state == 2)
-			{
+			while (state == 2) {
 				nextLine1 = reader1.readNext();
-				if(nextLine == null)
-				{
+				if (nextLine == null) {
 					break;
-				}
-				else
-				{
+				} else {
 					nextLine2 = new String[outputWidth];
 					nextLine = mergeArrays(nextLine1, nextLine2);
 					writer.writeNext(nextLine);
 				}
 			}
-		}
-		catch (IOException ex)
-		{
+		} catch (IOException ex) {
 			Logger.getLogger(RunVisualizer.class.getName()).log(Level.SEVERE, null, ex);
-		}
-		finally
-		{
-			try
-			{
+		} finally {
+			try {
 				writer.close();
 				reader1.close();
 				reader2.close();
-			}
-			catch (IOException e)
-			{
+			} catch (IOException e) {
 				e.printStackTrace();
 			}
 		}
-		
+
 		writeToMergeFile(mergedFile, tempFile);
 	}
 
-	private String[] mergeArrays(String[] nextLine1, String[] nextLine2)
-	{
+	private String[] mergeArrays(String[] nextLine1, String[] nextLine2) {
 		int length1 = nextLine1.length;
 		int length2 = nextLine2.length;
-				
-		if(nextLine1[nextLine1.length-1].equals(""))
+
+		if (nextLine1[nextLine1.length - 1].equals(""))
 			length1--;
-		if(nextLine2[nextLine2.length-1].equals(""))
+		if (nextLine2[nextLine2.length - 1].equals(""))
 			length2--;
-		
-		String[] nextLine = new String[length1+length2];
-		for(int i = 0 ; i < length1 ; i++)
-		{
+
+		String[] nextLine = new String[length1 + length2];
+		for (int i = 0; i < length1; i++) {
 			nextLine[i] = nextLine1[i];
 		}
-		for(int i = 0 ; i < length2 ; i++)
-		{
-			nextLine[length1+i] = nextLine2[i];
+		for (int i = 0; i < length2; i++) {
+			nextLine[length1 + i] = nextLine2[i];
 		}
-		
+
 		return nextLine;
 	}
 
diff --git a/moa/src/main/java/moa/tasks/conceptdrift/ConceptDriftMainTask.java b/moa/src/main/java/moa/tasks/conceptdrift/ConceptDriftMainTask.java
index 4a67f312c..685ba108c 100644
--- a/moa/src/main/java/moa/tasks/conceptdrift/ConceptDriftMainTask.java
+++ b/moa/src/main/java/moa/tasks/conceptdrift/ConceptDriftMainTask.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks.conceptdrift;
 
@@ -26,14 +26,16 @@
 
 public abstract class ConceptDriftMainTask extends MainTask {
 
-    protected ArrayList<ClusterEvent> events;
+	protected ArrayList<ClusterEvent> events;
+
+	@Override
+	protected void setEventsList(ArrayList<ClusterEvent> events) {
+		this.events = events;
+	}
+
+	@Override
+	public ArrayList<ClusterEvent> getEventsList() {
+		return this.events;
+	}
 
-    protected void setEventsList(ArrayList<ClusterEvent> events) {
-        this.events = events;
-    }
-    
-    public ArrayList<ClusterEvent> getEventsList() {
-        return this.events;
-    }
-    
 }
diff --git a/moa/src/main/java/moa/tasks/conceptdrift/EvaluateConceptDrift.java b/moa/src/main/java/moa/tasks/conceptdrift/EvaluateConceptDrift.java
index 08e09d3c3..2f2fa3143 100644
--- a/moa/src/main/java/moa/tasks/conceptdrift/EvaluateConceptDrift.java
+++ b/moa/src/main/java/moa/tasks/conceptdrift/EvaluateConceptDrift.java
@@ -16,7 +16,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks.conceptdrift;
 
@@ -33,209 +33,190 @@
 import moa.core.ObjectRepository;
 import moa.core.TimingUtils;
 import moa.evaluation.LearningEvaluation;
-import moa.evaluation.LearningPerformanceEvaluator;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
 import moa.evaluation.preview.LearningCurve;
-import moa.learners.ChangeDetectorLearner;
+import moa.learners.predictors.ChangeDetectorLearner;
 import moa.options.ClassOption;
 import moa.streams.clustering.ClusterEvent;
 import moa.streams.generators.cd.ConceptDriftGenerator;
 import moa.tasks.TaskMonitor;
 
-
 /**
- * Task for evaluating a classifier on a stream by testing then training with each example in sequence.
+ * Task for evaluating a classifier on a stream by testing then training with
+ * each example in sequence.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
  * @version $Revision: 7 $
  */
-public class EvaluateConceptDrift extends ConceptDriftMainTask{
-
-   
-    @Override
-    public String getPurposeString() {
-        return "Evaluates a classifier on a stream by testing then training with each example in sequence.";
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    public ClassOption learnerOption = new ClassOption("learner", 'l',
-            "Change detector to train.", ChangeDetectorLearner.class, "ChangeDetectorLearner");
-
-    public ClassOption streamOption = new ClassOption("stream", 's',
-            "Stream to learn from.", ConceptDriftGenerator.class,
-            "GradualChangeGenerator");
-
-    public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
-            "Classification performance evaluation method.",
-            LearningPerformanceEvaluator.class,
-            "BasicConceptDriftPerformanceEvaluator");
-
-    public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
-            "Maximum number of instances to test/train on  (-1 = no limit).",
-            1000, -1, Integer.MAX_VALUE);
-
-    public IntOption timeLimitOption = new IntOption("timeLimit", 't',
-            "Maximum number of seconds to test/train for (-1 = no limit).", -1,
-            -1, Integer.MAX_VALUE);
-
-    public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
-            'f',
-            "How many instances between samples of the learning performance.",
-            10, 0, Integer.MAX_VALUE);
-
-    /*public IntOption memCheckFrequencyOption = new IntOption(
-            "memCheckFrequency", 'q',
-            "How many instances between memory bound checks.", 100000, 0,
-            Integer.MAX_VALUE);*/
-
-    public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
-            "File to append intermediate csv results to.", null, "csv", true);
-
-    /*public FileOption outputPredictionFileOption = new FileOption("outputPredictionFile", 'o',
-            "File to append output predictions to.", null, "pred", true);*/
-
-    @Override
-    public Class<?> getTaskResultType() {
-        return LearningCurve.class;
-    }
-
-    
-    @Override
-    protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
-        ChangeDetectorLearner learner = (ChangeDetectorLearner) getPreparedClassOption(this.learnerOption);
-        ConceptDriftGenerator stream = (ConceptDriftGenerator) getPreparedClassOption(this.streamOption);
-        this.setEventsList(stream.getEventsList());
-        LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
-        LearningCurve learningCurve = new LearningCurve(
-                "learning evaluation instances");
-
-        learner.setModelContext(stream.getHeader());
-        int maxInstances = this.instanceLimitOption.getValue();
-        long instancesProcessed = 0;
-        int maxSeconds = this.timeLimitOption.getValue();
-        int secondsElapsed = 0;
-        monitor.setCurrentActivity("Evaluating learner...", -1.0);
-
-        File dumpFile = this.dumpFileOption.getFile();
-        PrintStream immediateResultStream = null;
-        if (dumpFile != null) {
-            try {
-                if (dumpFile.exists()) {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile, true), true);
-                } else {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile), true);
-                }
-            } catch (Exception ex) {
-                throw new RuntimeException(
-                        "Unable to open immediate result file: " + dumpFile, ex);
-            }
-        }
-        //File for output predictions
-      /*  File outputPredictionFile = this.outputPredictionFileOption.getFile();
-        PrintStream outputPredictionResultStream = null;
-        if (outputPredictionFile != null) {
-            try {
-                if (outputPredictionFile.exists()) {
-                    outputPredictionResultStream = new PrintStream(
-                            new FileOutputStream(outputPredictionFile, true), true);
-                } else {
-                    outputPredictionResultStream = new PrintStream(
-                            new FileOutputStream(outputPredictionFile), true);
-                }
-            } catch (Exception ex) {
-                throw new RuntimeException(
-                        "Unable to open prediction result file: " + outputPredictionFile, ex);
-            }
-        }*/
-        boolean firstDump = true;
-        boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
-        long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-        long lastEvaluateStartTime = evaluateStartTime;
-        double RAMHours = 0.0;
-        while (stream.hasMoreInstances()
-                && ((maxInstances < 0) || (instancesProcessed < maxInstances))
-                && ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
-            Example trainInst = (Example) stream.nextInstance();
-            Example testInst = trainInst; 
-            int trueClass = (int) ((Instance)trainInst.getData()).classValue();
-            //testInst.setClassMissing();
-            double[] prediction = learner.getPredictionForInstance(testInst).asDoubleArray();
-            if (prediction[0] == 1){ //Change detected
-                this.getEventsList().add(new ClusterEvent(this, instancesProcessed, "Detected Change", "Drift"));
-            }
-            // Output prediction
-           /* if (outputPredictionFile != null) {
-                outputPredictionResultStream.println(Utils.maxIndex(prediction) + "," + trueClass);
-            }*/
-
-            evaluator.addResult(testInst, prediction);
-            learner.trainOnInstance(trainInst);
-            instancesProcessed++;
-            if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0
-                    || stream.hasMoreInstances() == false) {
-                long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-                double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);
-                double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);
-                double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); //GBs
-                RAMHoursIncrement *= (timeIncrement / 3600.0); //Hours
-                RAMHours += RAMHoursIncrement;
-                lastEvaluateStartTime = evaluateTime;
-                learningCurve.insertEntry(new LearningEvaluation(
-                        new Measurement[]{
-                            new Measurement(
-                            "learning evaluation instances",
-                            instancesProcessed),
-                            new Measurement(
-                            "evaluation time ("
-                            + (preciseCPUTiming ? "cpu "
-                            : "") + "seconds)",
-                            time),
-                            new Measurement(
-                            "model cost (RAM-Hours)",
-                            RAMHours)
-                        },
-                        evaluator, learner));
-
-                if (immediateResultStream != null) {
-                    if (firstDump) {
-                        immediateResultStream.println(learningCurve.headerToString());
-                        firstDump = false;
-                    }
-                    immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
-                    immediateResultStream.flush();
-                }
-            }
-            if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
-                if (monitor.taskShouldAbort()) {
-                    return null;
-                }
-                long estimatedRemainingInstances = stream.estimatedRemainingInstances();
-                if (maxInstances > 0) {
-                    long maxRemaining = maxInstances - instancesProcessed;
-                    if ((estimatedRemainingInstances < 0)
-                            || (maxRemaining < estimatedRemainingInstances)) {
-                        estimatedRemainingInstances = maxRemaining;
-                    }
-                }
-                monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
-                        : (double) instancesProcessed
-                        / (double) (instancesProcessed + estimatedRemainingInstances));
-                if (monitor.resultPreviewRequested()) {
-                    monitor.setLatestResultPreview(learningCurve.copy());
-                }
-                secondsElapsed = (int) TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread()
-                        - evaluateStartTime);
-            }
-        }
-        if (immediateResultStream != null) {
-            immediateResultStream.close();
-        }
-       /* if (outputPredictionResultStream != null) {
-            outputPredictionResultStream.close();
-        }*/
-        return learningCurve;
-    }
+public class EvaluateConceptDrift extends ConceptDriftMainTask {
+
+	@Override
+	public String getPurposeString() {
+		return "Evaluates a classifier on a stream by testing then training with each example in sequence.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption learnerOption = new ClassOption("learner", 'l', "Change detector to train.",
+			ChangeDetectorLearner.class, "ChangeDetectorLearner");
+
+	public ClassOption streamOption = new ClassOption("stream", 's', "Stream to learn from.",
+			ConceptDriftGenerator.class, "GradualChangeGenerator");
+
+	public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
+			"Classification performance evaluation method.", LearningPerformanceEvaluator.class,
+			"BasicConceptDriftPerformanceEvaluator");
+
+	public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
+			"Maximum number of instances to test/train on  (-1 = no limit).", 1000, -1, Integer.MAX_VALUE);
+
+	public IntOption timeLimitOption = new IntOption("timeLimit", 't',
+			"Maximum number of seconds to test/train for (-1 = no limit).", -1, -1, Integer.MAX_VALUE);
+
+	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency", 'f',
+			"How many instances between samples of the learning performance.", 10, 0, Integer.MAX_VALUE);
+
+	/*
+	 * public IntOption memCheckFrequencyOption = new IntOption(
+	 * "memCheckFrequency", 'q', "How many instances between memory bound checks.",
+	 * 100000, 0, Integer.MAX_VALUE);
+	 */
+
+	public FileOption dumpFileOption = new FileOption("dumpFile", 'd', "File to append intermediate csv results to.",
+			null, "csv", true);
+
+	/*
+	 * public FileOption outputPredictionFileOption = new
+	 * FileOption("outputPredictionFile", 'o',
+	 * "File to append output predictions to.", null, "pred", true);
+	 */
+
+	@Override
+	public Class<?> getTaskResultType() {
+		return LearningCurve.class;
+	}
+
+	@Override
+	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
+		ChangeDetectorLearner learner = (ChangeDetectorLearner) getPreparedClassOption(this.learnerOption);
+		ConceptDriftGenerator stream = (ConceptDriftGenerator) getPreparedClassOption(this.streamOption);
+		this.setEventsList(stream.getEventsList());
+		LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(
+				this.evaluatorOption);
+		LearningCurve learningCurve = new LearningCurve("learning evaluation instances");
+
+		learner.setModelContext(stream.getHeader());
+		int maxInstances = this.instanceLimitOption.getValue();
+		long instancesProcessed = 0;
+		int maxSeconds = this.timeLimitOption.getValue();
+		int secondsElapsed = 0;
+		monitor.setCurrentActivity("Evaluating learner...", -1.0);
+
+		File dumpFile = this.dumpFileOption.getFile();
+		PrintStream immediateResultStream = null;
+		if (dumpFile != null) {
+			try {
+				if (dumpFile.exists()) {
+					immediateResultStream = new PrintStream(new FileOutputStream(dumpFile, true), true);
+				} else {
+					immediateResultStream = new PrintStream(new FileOutputStream(dumpFile), true);
+				}
+			} catch (Exception ex) {
+				throw new RuntimeException("Unable to open immediate result file: " + dumpFile, ex);
+			}
+		}
+		// File for output predictions
+		/*
+		 * File outputPredictionFile = this.outputPredictionFileOption.getFile();
+		 * PrintStream outputPredictionResultStream = null; if (outputPredictionFile !=
+		 * null) { try { if (outputPredictionFile.exists()) {
+		 * outputPredictionResultStream = new PrintStream( new
+		 * FileOutputStream(outputPredictionFile, true), true); } else {
+		 * outputPredictionResultStream = new PrintStream( new
+		 * FileOutputStream(outputPredictionFile), true); } } catch (Exception ex) {
+		 * throw new RuntimeException( "Unable to open prediction result file: " +
+		 * outputPredictionFile, ex); } }
+		 */
+		boolean firstDump = true;
+		boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
+		long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+		long lastEvaluateStartTime = evaluateStartTime;
+		double RAMHours = 0.0;
+		while (stream.hasMoreInstances() && ((maxInstances < 0) || (instancesProcessed < maxInstances))
+				&& ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
+			Example trainInst = stream.nextInstance();
+			Example testInst = trainInst;
+			int trueClass = (int) ((Instance) trainInst.getData()).classValue();
+			// testInst.setClassMissing();
+			double[] prediction = learner.getPredictionForInstance(testInst).asDoubleArray();
+			if (prediction[0] == 1) { // Change detected
+				this.getEventsList().add(new ClusterEvent(this, instancesProcessed, "Detected Change", "Drift"));
+			}
+			// Output prediction
+			/*
+			 * if (outputPredictionFile != null) {
+			 * outputPredictionResultStream.println(Utils.maxIndex(prediction) + "," +
+			 * trueClass); }
+			 */
+
+			evaluator.addResult(testInst, prediction);
+			learner.trainOnInstance(trainInst);
+			instancesProcessed++;
+			if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0 || stream.hasMoreInstances() == false) {
+				long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+				double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);
+				double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);
+				double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); // GBs
+				RAMHoursIncrement *= (timeIncrement / 3600.0); // Hours
+				RAMHours += RAMHoursIncrement;
+				lastEvaluateStartTime = evaluateTime;
+				learningCurve
+						.insertEntry(
+								new LearningEvaluation(
+										new Measurement[] {
+												new Measurement("learning evaluation instances", instancesProcessed),
+												new Measurement("evaluation time (" + (preciseCPUTiming ? "cpu " : "")
+														+ "seconds)", time),
+												new Measurement("model cost (RAM-Hours)", RAMHours) },
+										evaluator, learner));
+
+				if (immediateResultStream != null) {
+					if (firstDump) {
+						immediateResultStream.println(learningCurve.headerToString());
+						firstDump = false;
+					}
+					immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
+					immediateResultStream.flush();
+				}
+			}
+			if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
+				if (monitor.taskShouldAbort()) {
+					return null;
+				}
+				long estimatedRemainingInstances = stream.estimatedRemainingInstances();
+				if (maxInstances > 0) {
+					long maxRemaining = maxInstances - instancesProcessed;
+					if ((estimatedRemainingInstances < 0) || (maxRemaining < estimatedRemainingInstances)) {
+						estimatedRemainingInstances = maxRemaining;
+					}
+				}
+				monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
+						: (double) instancesProcessed / (double) (instancesProcessed + estimatedRemainingInstances));
+				if (monitor.resultPreviewRequested()) {
+					monitor.setLatestResultPreview(learningCurve.copy());
+				}
+				secondsElapsed = (int) TimingUtils
+						.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread() - evaluateStartTime);
+			}
+		}
+		if (immediateResultStream != null) {
+			immediateResultStream.close();
+		}
+		/*
+		 * if (outputPredictionResultStream != null) {
+		 * outputPredictionResultStream.close(); }
+		 */
+		return learningCurve;
+	}
 }
\ No newline at end of file
diff --git a/moa/src/main/java/moa/tasks/meta/ALMainTask.java b/moa/src/main/java/moa/tasks/meta/ALMainTask.java
index 0f14255ed..da2262307 100644
--- a/moa/src/main/java/moa/tasks/meta/ALMainTask.java
+++ b/moa/src/main/java/moa/tasks/meta/ALMainTask.java
@@ -15,26 +15,25 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks.meta;
 
 import java.util.List;
 
 /**
- * This class provides a superclass for Active Learning tasks, which 
- * enables convenient searching for those tasks for example when showing 
- * a list of available Active Learning tasks.
- * Furthermore, it specifies the type of threads being used as
- * {@link ALTaskThread}.
- * 
+ * This class provides a superclass for Active Learning tasks, which enables
+ * convenient searching for those tasks for example when showing a list of
+ * available Active Learning tasks. Furthermore, it specifies the type of
+ * threads being used as {@link ALTaskThread}.
+ *
  * @author Cornelius Styp von Rekowski (cornelius.styp@ovgu.de)
  * @version $Revision: 1 $
  */
 public abstract class ALMainTask extends MetaMainTask {
-	
+
 	private static final long serialVersionUID = 1L;
-	
+
 	@Override
 	public abstract List<ALTaskThread> getSubtaskThreads();
 }
diff --git a/moa/src/main/java/moa/tasks/meta/ALMultiParamTask.java b/moa/src/main/java/moa/tasks/meta/ALMultiParamTask.java
index 5d8c7e721..e9a696975 100644
--- a/moa/src/main/java/moa/tasks/meta/ALMultiParamTask.java
+++ b/moa/src/main/java/moa/tasks/meta/ALMultiParamTask.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks.meta;
 
@@ -30,12 +30,12 @@
 import com.github.javacliparser.Option;
 import com.github.javacliparser.Options;
 
-import moa.classifiers.active.ALClassifier;
 import moa.core.ObjectRepository;
 import moa.evaluation.preview.LearningCurve;
 import moa.evaluation.preview.PreviewCollection;
 import moa.evaluation.preview.PreviewCollectionLearningCurveWrapper;
 import moa.gui.colorGenerator.HSVColorGenerator;
+import moa.learners.predictors.active.ALClassifier;
 import moa.options.ClassOption;
 import moa.options.ClassOptionWithListenerOption;
 import moa.options.DependentOptionsUpdater;
@@ -43,263 +43,225 @@
 import moa.tasks.TaskMonitor;
 
 /**
- * This task individually evaluates an active learning classifier for each 
- * element of a set of parameter values. The individual evaluation is done by 
- * prequential evaluation (testing, then training with each example in 
+ * This task individually evaluates an active learning classifier for each
+ * element of a set of parameter values. The individual evaluation is done by
+ * prequential evaluation (testing, then training with each example in
  * sequence).
- * 
+ *
  * @author Cornelius Styp von Rekowski (cornelius.styp@ovgu.de)
  * @version $Revision: 1 $
  */
 public class ALMultiParamTask extends ALMainTask {
-	
+
 	private static final long serialVersionUID = 1L;
-	
+
 	@Override
 	public String getPurposeString() {
 		return "Individually evaluates an active learning classifier for each"
 				+ " element of a set of parameter values using prequential"
-				+ " evaluation (testing, then training with each example in"
-				+ " sequence).";
+				+ " evaluation (testing, then training with each example in" + " sequence).";
 	}
-	
-	public ClassOptionWithListenerOption prequentialEvaluationTaskOption = 
-			new ClassOptionWithListenerOption(
-				"prequentialEvaluationTask", 'e', 
-				"Prequential evaluation task to be performed for each " + 
-				"parameter value.", ALPrequentialEvaluationTask.class, 
-				"moa.tasks.meta.ALPrequentialEvaluationTask");
-	
-	public EditableMultiChoiceOption variedParamNameOption = 
-			new EditableMultiChoiceOption(
-					"variedParamName", 'p', 
-					"Name of the parameter to be varied.",
-					new String[]{"budget"}, 
-					new String[]{"default varied parameter name"}, 
-					0);
-	
-	public ListOption variedParamValuesOption = new ListOption(
-			"variedParamValues", 'v',
+
+	public ClassOptionWithListenerOption prequentialEvaluationTaskOption = new ClassOptionWithListenerOption(
+			"prequentialEvaluationTask", 'e',
+			"Prequential evaluation task to be performed for each " + "parameter value.",
+			ALPrequentialEvaluationTask.class, "moa.tasks.meta.ALPrequentialEvaluationTask");
+
+	public EditableMultiChoiceOption variedParamNameOption = new EditableMultiChoiceOption("variedParamName", 'p',
+			"Name of the parameter to be varied.", new String[] { "budget" },
+			new String[] { "default varied parameter name" }, 0);
+
+	public ListOption variedParamValuesOption = new ListOption("variedParamValues", 'v',
 			"List of parameter values to train classifiers for.",
-			new FloatOption("value", ' ', "Parameter value.", 0.0), 
-			new FloatOption[]{
-					new FloatOption("", ' ', "", 0.1),
-					new FloatOption("", ' ', "", 0.2),
-					new FloatOption("", ' ', "", 0.5)
-			}, ',');
-	
-	
+			new FloatOption("value", ' ', "Parameter value.", 0.0),
+			new FloatOption[] { new FloatOption("", ' ', "", 0.1), new FloatOption("", ' ', "", 0.2),
+					new FloatOption("", ' ', "", 0.5) },
+			',');
+
 	private ArrayList<ALPrequentialEvaluationTask> subtasks = new ArrayList<>();
 	private ArrayList<ALTaskThread> subtaskThreads = new ArrayList<>();
 	private ArrayList<ALTaskThread> flattenedSubtaskThreads = new ArrayList<>();
-	
+
 	private Color[] subTaskColorCoding;
 	private int partitionIdx = -1;
-	
+
 	/**
-	 * Default constructor which sets up the refresh mechanism between the 
-	 * learner and the variedParamName option.
+	 * Default constructor which sets up the refresh mechanism between the learner
+	 * and the variedParamName option.
 	 */
 	public ALMultiParamTask() {
 		super();
-		
+
 		// enable refreshing the variedParamNameOption depending on the
 		// learnerOption
-		new DependentOptionsUpdater(
-				this.prequentialEvaluationTaskOption, 
-				this.variedParamNameOption);
+		new DependentOptionsUpdater(this.prequentialEvaluationTaskOption, this.variedParamNameOption);
 	}
-	
+
 	/**
-	 * Constructor that sets the color coding for the subtasks additionally
-	 * to the default constructor.
-	 * 
+	 * Constructor that sets the color coding for the subtasks additionally to the
+	 * default constructor.
+	 *
 	 * @param subTaskColorCoding
 	 */
 	public ALMultiParamTask(Color[] subTaskColorCoding) {
 		this();
 		this.subTaskColorCoding = subTaskColorCoding;
 	}
-	
+
 	public void setPartitionIdx(int partitionIdx) {
 		this.partitionIdx = partitionIdx;
 		this.setNameSuffix("partition " + partitionIdx);
 	}
-	
+
 	@Override
 	public Options getOptions() {
 		Options options = super.getOptions();
-		
+
 		// make sure that all dependent options are up to date
-		this.prequentialEvaluationTaskOption.getChangeListener()
-			.stateChanged(null);
-		
+		this.prequentialEvaluationTaskOption.getChangeListener().stateChanged(null);
+
 		return options;
 	}
-	
+
 	@Override
 	public Class<?> getTaskResultType() {
 		return LearningCurve.class;
 	}
-	
-	
+
 	@Override
-	protected void prepareForUseImpl(
-			TaskMonitor monitor, ObjectRepository repository) 
-	{
+	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
 		super.prepareForUseImpl(monitor, repository);
-		
+
 		// get varied parameter name
-		String variedParamName = 
-				this.variedParamNameOption.getValueAsCLIString();
-		
+		String variedParamName = this.variedParamNameOption.getValueAsCLIString();
+
 		// get prequential evaluation task
-		ALPrequentialEvaluationTask evalTask = (ALPrequentialEvaluationTask)
-				this.prequentialEvaluationTaskOption.getPreMaterializedObject();
-		
+		ALPrequentialEvaluationTask evalTask = (ALPrequentialEvaluationTask) this.prequentialEvaluationTaskOption
+				.getPreMaterializedObject();
+
 		// get learner
-		ALClassifier learner = (ALClassifier) 
-				evalTask.learnerOption.getPreMaterializedObject();
-		
+		ALClassifier learner = (ALClassifier) evalTask.learnerOption.getPreMaterializedObject();
+
 		// get the learner's varied parameter option
-		Option learnerVariedParamOption = 
-				DependentOptionsUpdater.getVariedOption(learner, variedParamName);
-		
+		Option learnerVariedParamOption = DependentOptionsUpdater.getVariedOption(learner, variedParamName);
+
 		// get values for the varied parameter
 		Option[] paramValues;
 		if (learnerVariedParamOption != null) {
 			paramValues = this.variedParamValuesOption.getList();
+		} else {
+			paramValues = new Option[] { null };
 		}
-		else {
-			paramValues = new Option[]{null};
-		}
-		
+
 		// append partition index to task result file if necessary
 		if (this.partitionIdx >= 0) {
 			File ownTaskResultFile = this.outputFileOption.getFile();
-			
+
 			if (ownTaskResultFile != null) {
 				this.outputFileOption.setValue(
-						this.insertFileNameExtension(
-								ownTaskResultFile.getAbsolutePath(), 
-								"_p" + this.partitionIdx));
+						this.insertFileNameExtension(ownTaskResultFile.getAbsolutePath(), "_p" + this.partitionIdx));
 			}
 		}
-		
+
 		// get base dump file name of subtasks
 		File baseDumpFile = evalTask.dumpFileOption.getFile();
-		String baseDumpFileName = baseDumpFile != null ? 
-				baseDumpFile.getAbsolutePath() : null;
-		
+		String baseDumpFileName = baseDumpFile != null ? baseDumpFile.getAbsolutePath() : null;
+
 		// get task result name of subtask
 		File baseTaskResultFile = evalTask.outputFileOption.getFile();
-		String baseTaskResultName = baseTaskResultFile != null ?
-				baseTaskResultFile.getAbsolutePath() : null;
-		
+		String baseTaskResultName = baseTaskResultFile != null ? baseTaskResultFile.getAbsolutePath() : null;
+
 		// create color coding
 		colorCoding = Color.WHITE;
-		
-		if(subTaskColorCoding == null)
-		{
-			subTaskColorCoding = 
-					new HSVColorGenerator().generateColors(paramValues.length);
+
+		if (subTaskColorCoding == null) {
+			subTaskColorCoding = new HSVColorGenerator().generateColors(paramValues.length);
 		}
-		
+
 		// setup task for each parameter value
 		for (int i = 0; i < paramValues.length; i++) {
-			
+
 			// create subtask
-			ALPrequentialEvaluationTask paramValueTask = 
-					(ALPrequentialEvaluationTask) evalTask.copy();
+			ALPrequentialEvaluationTask paramValueTask = (ALPrequentialEvaluationTask) evalTask.copy();
 			paramValueTask.setColorCoding(subTaskColorCoding[i]);
-			paramValueTask.setIsLastSubtaskOnLevel(
-					this.isLastSubtaskOnLevel, i == paramValues.length - 1);
-			
+			paramValueTask.setIsLastSubtaskOnLevel(this.isLastSubtaskOnLevel, i == paramValues.length - 1);
+
 			// set the learner's varied parameter option
 			if (learnerVariedParamOption != null) {
 				String paramValue = paramValues[i].getValueAsCLIString().trim();
 				paramValueTask.setNameSuffix(paramValue);
-				
+
 				// parse to integer if necessary
 				if (learnerVariedParamOption instanceof IntOption) {
 					int intParamValue = (int) Double.parseDouble(paramValue);
 					paramValue = Integer.toString(intParamValue);
 				}
-				
+
 				learnerVariedParamOption.setValueViaCLIString(paramValue);
-				
+
 				String outputFileExtension = "";
 				if (this.partitionIdx >= 0) {
 					// append partition index
 					outputFileExtension += "_p" + this.partitionIdx;
 				}
-				
+
 				if (paramValues.length > 1) {
 					// append varied parameter value
 					outputFileExtension += "_v" + paramValue;
 				}
-				
+
 				// adapt the dump file name
 				if (baseDumpFileName != null) {
-					paramValueTask.dumpFileOption.setValue(
-							this.insertFileNameExtension(
-									baseDumpFileName, outputFileExtension));
+					paramValueTask.dumpFileOption
+							.setValue(this.insertFileNameExtension(baseDumpFileName, outputFileExtension));
 				}
-				
+
 				// adapt the task result file name
 				if (baseTaskResultName != null) {
-					paramValueTask.outputFileOption.setValue(
-							this.insertFileNameExtension(
-									baseTaskResultName, outputFileExtension));
+					paramValueTask.outputFileOption
+							.setValue(this.insertFileNameExtension(baseTaskResultName, outputFileExtension));
 				}
 			}
-			
-			paramValueTask.learnerOption.setValueViaCLIString(
-					ClassOption.objectToCLIString(learner, ALClassifier.class));
+
+			paramValueTask.learnerOption
+					.setValueViaCLIString(ClassOption.objectToCLIString(learner, ALClassifier.class));
 			paramValueTask.prepareForUse();
-			
+
 			List<ALTaskThread> childSubtasks = paramValueTask.getSubtaskThreads();
-			
+
 			// add new subtask and its thread to lists
 			this.subtasks.add(paramValueTask);
-			
+
 			ALTaskThread subtaskThread = new ALTaskThread(paramValueTask);
 			this.subtaskThreads.add(subtaskThread);
 
 			this.flattenedSubtaskThreads.add(subtaskThread);
 			this.flattenedSubtaskThreads.addAll(childSubtasks);
 		}
-		
+
 		// reset learner varied parameter option
 		if (learnerVariedParamOption != null) {
 			learnerVariedParamOption.resetToDefault();
 		}
 	}
-	
+
 	@Override
-	protected Object doMainTask(
-			TaskMonitor monitor, ObjectRepository repository) 
-	{
+	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
 		// get varied parameter values
 		Option[] variedParamValueOptions = this.variedParamValuesOption.getList();
 		double[] variedParamValues = new double[variedParamValueOptions.length];
 		for (int i = 0; i < variedParamValueOptions.length; i++) {
-			variedParamValues[i] = 
-					Double.valueOf(variedParamValueOptions[i].getValueAsCLIString());
+			variedParamValues[i] = Double.valueOf(variedParamValueOptions[i].getValueAsCLIString());
 		}
-		
+
 		// initialize the learning curve collection
-		PreviewCollection<PreviewCollectionLearningCurveWrapper> 
-			previewCollection = new PreviewCollection<>(
-					"multi param entry id", "learner id", this.getClass(),
-					this.variedParamNameOption.getValueAsCLIString(),
-					variedParamValues);
-		
+		PreviewCollection<PreviewCollectionLearningCurveWrapper> previewCollection = new PreviewCollection<>(
+				"multi param entry id", "learner id", this.getClass(), this.variedParamNameOption.getValueAsCLIString(),
+				variedParamValues);
+
 		// start subtasks
-		monitor.setCurrentActivity(
-				"Evaluating learners for parameter values...", -1.0);
-		for(int i = 0; i < this.subtaskThreads.size(); ++i)
-		{
+		monitor.setCurrentActivity("Evaluating learners for parameter values...", -1.0);
+		for (int i = 0; i < this.subtaskThreads.size(); ++i) {
 			subtaskThreads.get(i).start();
 		}
 
@@ -308,94 +270,82 @@ protected Object doMainTask(
 		// check the previews of subtaskthreads
 		boolean allThreadsCompleted = false;
 		// iterate while there are threads active
-		while(!allThreadsCompleted)
-		{
-			
+		while (!allThreadsCompleted) {
+
 			allThreadsCompleted = true;
 			int oldNumEntries = previewCollection.numEntries();
 			double completionSum = 0;
 			// iterate over all threads
-			for(int i = 0; i < numSubtaskThreads; ++i)
-			{
+			for (int i = 0; i < numSubtaskThreads; ++i) {
 				ALTaskThread currentTaskThread = subtaskThreads.get(i);
 				// check if the thread is completed
 				allThreadsCompleted &= currentTaskThread.isComplete();
-				
+
 				// request cancel if subtask failed or was cancelled
-				if(currentTaskThread.isFailed() || currentTaskThread.isCancelled())
-				{
+				if (currentTaskThread.isFailed() || currentTaskThread.isCancelled()) {
 					monitor.requestCancel();
 				}
-				
+
 				// get the completion fraction
 				completionSum += currentTaskThread.getCurrentActivityFracComplete();
 				// get the latest preview
-				PreviewCollectionLearningCurveWrapper latestPreview = 
-						(PreviewCollectionLearningCurveWrapper) 
-						currentTaskThread.getLatestResultPreview();
+				PreviewCollectionLearningCurveWrapper latestPreview = (PreviewCollectionLearningCurveWrapper) currentTaskThread
+						.getLatestResultPreview();
 				// ignore the preview if it is null
-				if(latestPreview != null && latestPreview.numEntries() > 0)
-				{	
+				if (latestPreview != null && latestPreview.numEntries() > 0) {
 					// update/add the learning curve to the learning curve collection
 					previewCollection.setPreview(i, latestPreview);
-				}
-				else if(!currentTaskThread.isComplete())
-				{
+				} else if (!currentTaskThread.isComplete()) {
 					// skip for loop until all threads before were at least added once
 					break;
-				}
-				else {
+				} else {
 					// set final result as latest preview
-					PreviewCollectionLearningCurveWrapper finalPreview = 
-							(PreviewCollectionLearningCurveWrapper) 
-							currentTaskThread.getFinalResult();
+					PreviewCollectionLearningCurveWrapper finalPreview = (PreviewCollectionLearningCurveWrapper) currentTaskThread
+							.getFinalResult();
 					previewCollection.setPreview(i, finalPreview);
 				}
 			}
 			double completionFraction = completionSum / numSubtaskThreads;
-			
+
 			monitor.setCurrentActivityFractionComplete(completionFraction);
-			
+
 			// check if the task should abort or paused
-    		if (monitor.taskShouldAbort()) {
-                return null;
-            }
-			
+			if (monitor.taskShouldAbort()) {
+				return null;
+			}
+
 			// check if the preview has actually changed
-			if(oldNumEntries < previewCollection.numEntries())
-			{
+			if (oldNumEntries < previewCollection.numEntries()) {
 				// check if a preview is requested
-	    		if (monitor.resultPreviewRequested() || isSubtask()) {
-	    			// send the latest preview to the monitor
-	                monitor.setLatestResultPreview(previewCollection.copy());
+				if (monitor.resultPreviewRequested() || isSubtask()) {
+					// send the latest preview to the monitor
+					monitor.setLatestResultPreview(previewCollection.copy());
 
-	        		monitor.setCurrentActivityFractionComplete(-1.0);
-	            }
+					monitor.setCurrentActivityFractionComplete(-1.0);
+				}
 			}
 		}
-		
+
 		return previewCollection;
 	}
-	
+
 	@Override
 	public List<ALTaskThread> getSubtaskThreads() {
 		return this.flattenedSubtaskThreads;
 	}
-	
-	private String insertFileNameExtension(
-			String baseName, String fileNameExtension) 
-	{
+
+	private String insertFileNameExtension(String baseName, String fileNameExtension) {
 		int fileExtIndex = baseName.lastIndexOf('.');
-		
+
 		// remove file extension
 		String extendedName = baseName.substring(0, fileExtIndex);
-		
+
 		// append partition and parameter extension
 		extendedName += fileNameExtension;
-		
+
 		// append file extension
-		extendedName += baseName.substring(fileExtIndex); 
-		
+		extendedName += baseName.substring(fileExtIndex);
+
 		return extendedName;
 	}
 }
diff --git a/moa/src/main/java/moa/tasks/meta/ALPartitionEvaluationTask.java b/moa/src/main/java/moa/tasks/meta/ALPartitionEvaluationTask.java
index 64b378a06..45a757c46 100644
--- a/moa/src/main/java/moa/tasks/meta/ALPartitionEvaluationTask.java
+++ b/moa/src/main/java/moa/tasks/meta/ALPartitionEvaluationTask.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks.meta;
 
@@ -37,12 +37,12 @@
 /**
  * This task extensively evaluates an active learning classifier on a stream.
  * First, the given data set is partitioned into subsets, each leaving out a
- * different part of the overall data. On each subset, the ALMultiParamTask is 
- * performed which individually evaluates the active learning classifier for 
- * each element of a set of parameter values. The individual evaluation is 
- * done by prequential evaluation (testing, then training with each example in
+ * different part of the overall data. On each subset, the ALMultiParamTask is
+ * performed which individually evaluates the active learning classifier for
+ * each element of a set of parameter values. The individual evaluation is done
+ * by prequential evaluation (testing, then training with each example in
  * sequence).
- * 
+ *
  * @author Cornelius Styp von Rekowski (cornelius.styp@ovgu.de)
  * @version $Revision: 1 $
  */
@@ -51,45 +51,39 @@ public class ALPartitionEvaluationTask extends ALMainTask {
 	private static final long serialVersionUID = 1L;
 
 	@Override
-	 public String getPurposeString() {
-	  return "Evaluates an active learning classifier on a stream by"
-	    + " partitioning the data stream and evaluating"
-	    + " the classifier on each subset for each element of a"
-	    + " set of parameter values using prequential evaluation"
-	    + " (testing, then training with each example in sequence).";
-	 }
-	public ClassOption multiParamTaskOption = new ClassOption(
-			"multiParamTask", 't', 
-			"Multi param task to be performed for each partition", 
-			ALMultiParamTask.class, "moa.tasks.meta.ALMultiParamTask");
-
-	public IntOption numPartitionsOption = new IntOption("numPartitions", 'k', 
-			"Number of data set partitions.", 10);
-
-	public IntOption randomSeedOption = new IntOption("randomSeed", 'r', 
+	public String getPurposeString() {
+		return "Evaluates an active learning classifier on a stream by" + " partitioning the data stream and evaluating"
+				+ " the classifier on each subset for each element of a"
+				+ " set of parameter values using prequential evaluation"
+				+ " (testing, then training with each example in sequence).";
+	}
+
+	public ClassOption multiParamTaskOption = new ClassOption("multiParamTask", 't',
+			"Multi param task to be performed for each partition", ALMultiParamTask.class,
+			"moa.tasks.meta.ALMultiParamTask");
+
+	public IntOption numPartitionsOption = new IntOption("numPartitions", 'k', "Number of data set partitions.", 10);
+
+	public IntOption randomSeedOption = new IntOption("randomSeed", 'r',
 			"random seed which is used for partitioning of the stream.", 0);
-	
-	
+
 	private ArrayList<ALTaskThread> subtaskThreads = new ArrayList<>();
 	private ArrayList<ALTaskThread> flattenedSubtaskThreads = new ArrayList<>();
-	
-	
+
 	@Override
 	protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repository) {
 		super.prepareForUseImpl(monitor, repository);
-		
+
 		colorCoding = Color.WHITE;
-		
+
 		// get subtask objects
-		ALMultiParamTask multiParamTask = (ALMultiParamTask) 
-				this.multiParamTaskOption.getPreMaterializedObject();
-		ALPrequentialEvaluationTask evalTask = (ALPrequentialEvaluationTask)
-				multiParamTask.prequentialEvaluationTaskOption
+		ALMultiParamTask multiParamTask = (ALMultiParamTask) this.multiParamTaskOption.getPreMaterializedObject();
+		ALPrequentialEvaluationTask evalTask = (ALPrequentialEvaluationTask) multiParamTask.prequentialEvaluationTaskOption
 				.getPreMaterializedObject();
 		String baseStream = evalTask.streamOption.getValueAsCLIString();
-		
+
 		Random random = new Random(randomSeedOption.getValue());
-		
+
 		// setup subtask for each partition
 		for (int i = 0; i < this.numPartitionsOption.getValue(); i++) {
 			// wrap base stream into a PartitioningStream to split up data
@@ -100,14 +94,14 @@ protected void prepareForUseImpl(TaskMonitor monitor, ObjectRepository repositor
 			stream.randomSeedOption.setValue(random.nextInt());
 			// create subtask
 			ALMultiParamTask partitionTask = (ALMultiParamTask) multiParamTask.copy();
-			partitionTask.setIsLastSubtaskOnLevel(
-					this.isLastSubtaskOnLevel, i == this.numPartitionsOption.getValue() - 1);
+			partitionTask.setIsLastSubtaskOnLevel(this.isLastSubtaskOnLevel,
+					i == this.numPartitionsOption.getValue() - 1);
 			partitionTask.setPartitionIdx(i);
-			
-			ALPrequentialEvaluationTask partitionEvalTask = (ALPrequentialEvaluationTask) 
-					partitionTask.prequentialEvaluationTaskOption.getPreMaterializedObject();
+
+			ALPrequentialEvaluationTask partitionEvalTask = (ALPrequentialEvaluationTask) partitionTask.prequentialEvaluationTaskOption
+					.getPreMaterializedObject();
 			partitionEvalTask.streamOption.setCurrentObject(stream);
-			
+
 			partitionTask.prepareForUse();
 
 			List<ALTaskThread> childSubtasks = partitionTask.getSubtaskThreads();
@@ -127,111 +121,89 @@ public Class<?> getTaskResultType() {
 	}
 
 	@Override
-	protected Object doMainTask(
-			TaskMonitor monitor, ObjectRepository repository) 
-	{
+	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
 		// get varied parameter values
-		ALMultiParamTask multiParamTask = (ALMultiParamTask) 
-				this.multiParamTaskOption.getPreMaterializedObject();
-		Option[] variedParamValueOptions = 
-				multiParamTask.variedParamValuesOption.getList();
+		ALMultiParamTask multiParamTask = (ALMultiParamTask) this.multiParamTaskOption.getPreMaterializedObject();
+		Option[] variedParamValueOptions = multiParamTask.variedParamValuesOption.getList();
 		int numVariedParams = variedParamValueOptions.length;
 		double[] variedParamValues = new double[numVariedParams];
 		for (int i = 0; i < numVariedParams; i++) {
-			variedParamValues[i] = 
-					Double.valueOf(variedParamValueOptions[i].getValueAsCLIString());
+			variedParamValues[i] = Double.valueOf(variedParamValueOptions[i].getValueAsCLIString());
 		}
-		
+
 		// initialize the learning curve collection
-		PreviewCollection<PreviewCollection<PreviewCollectionLearningCurveWrapper>> 
-			previewCollection = new PreviewCollection<>(
-					"partition evaluation entry id", "partition id", this.getClass(),
-					multiParamTask.variedParamNameOption.getValueAsCLIString(),
-					variedParamValues);
-		
+		PreviewCollection<PreviewCollection<PreviewCollectionLearningCurveWrapper>> previewCollection = new PreviewCollection<>(
+				"partition evaluation entry id", "partition id", this.getClass(),
+				multiParamTask.variedParamNameOption.getValueAsCLIString(), variedParamValues);
 
 		monitor.setCurrentActivity("Performing evaluation...", 50.0);
-		
+
 		// start subtasks
 		monitor.setCurrentActivity("Performing evaluation...", -1.0);
-		for(int i = 0; i < this.subtaskThreads.size(); ++i)
-		{
+		for (int i = 0; i < this.subtaskThreads.size(); ++i) {
 			subtaskThreads.get(i).start();
 		}
 
-
 		// get the number of subtask threads
 		int numSubtaskThreads = subtaskThreads.size();
 		// check the previews of subtaskthreads
 		boolean allThreadsCompleted = false;
 		// iterate while there are threads active
-		while(!allThreadsCompleted)
-		{
+		while (!allThreadsCompleted) {
 			allThreadsCompleted = true;
 			int oldNumEntries = previewCollection.numEntries();
 			double completionSum = 0;
 			// iterate over all threads
-			for(int i = 0; i < numSubtaskThreads; ++i)
-			{
+			for (int i = 0; i < numSubtaskThreads; ++i) {
 				ALTaskThread currentTaskThread = subtaskThreads.get(i);
 				// check if the thread is completed
 				allThreadsCompleted &= currentTaskThread.isComplete();
 
 				// request cancel if subtask failed or was cancelled
-				if(currentTaskThread.isFailed() || currentTaskThread.isCancelled())
-				{
+				if (currentTaskThread.isFailed() || currentTaskThread.isCancelled()) {
 					monitor.requestCancel();
 				}
 				// get the completion fraction
 				completionSum += currentTaskThread.getCurrentActivityFracComplete();
 				// get the latest preview
 				@SuppressWarnings("unchecked")
-				PreviewCollection<PreviewCollectionLearningCurveWrapper> 
-					latestPreview = 
-						(PreviewCollection<PreviewCollectionLearningCurveWrapper>)
-						currentTaskThread.getLatestResultPreview();
+				PreviewCollection<PreviewCollectionLearningCurveWrapper> latestPreview = (PreviewCollection<PreviewCollectionLearningCurveWrapper>) currentTaskThread
+						.getLatestResultPreview();
 				// ignore the preview if it is null
-				if(latestPreview != null && latestPreview.numEntries() > 0)
-				{	
+				if (latestPreview != null && latestPreview.numEntries() > 0) {
 					// update/add the learning curve to the learning curve collection
 					previewCollection.setPreview(i, latestPreview);
-				}
-				else if(!currentTaskThread.isComplete())
-				{
+				} else if (!currentTaskThread.isComplete()) {
 					// skip for loop until all threads before were at least added once
 					break;
-				}
-				else {
+				} else {
 					// set final result as latest preview
 					@SuppressWarnings("unchecked")
-					PreviewCollection<PreviewCollectionLearningCurveWrapper> 
-						finalPreview = 
-							(PreviewCollection<PreviewCollectionLearningCurveWrapper>)
-							currentTaskThread.getFinalResult();
+					PreviewCollection<PreviewCollectionLearningCurveWrapper> finalPreview = (PreviewCollection<PreviewCollectionLearningCurveWrapper>) currentTaskThread
+							.getFinalResult();
 					previewCollection.setPreview(i, finalPreview);
 				}
 			}
-			
+
 			double completionFraction = completionSum / numSubtaskThreads;
-			
+
 			monitor.setCurrentActivityFractionComplete(completionFraction);
-			
+
 			// check if the task should abort or paused
-    		if (monitor.taskShouldAbort()) {
-                return null;
-            }
-			
+			if (monitor.taskShouldAbort()) {
+				return null;
+			}
+
 			// check if the preview has actually changed
-			if(oldNumEntries < previewCollection.numEntries())
-			{
+			if (oldNumEntries < previewCollection.numEntries()) {
 				// check if a preview is requested
-	    		if (monitor.resultPreviewRequested() || isSubtask()) {
-	    			// send the latest preview to the monitor
-	                monitor.setLatestResultPreview(previewCollection.copy());
-	            }
+				if (monitor.resultPreviewRequested() || isSubtask()) {
+					// send the latest preview to the monitor
+					monitor.setLatestResultPreview(previewCollection.copy());
+				}
 			}
 		}
-		
+
 		return previewCollection;
 	}
 
diff --git a/moa/src/main/java/moa/tasks/meta/ALPrequentialEvaluationTask.java b/moa/src/main/java/moa/tasks/meta/ALPrequentialEvaluationTask.java
index 910dc7cc0..8f02f590e 100644
--- a/moa/src/main/java/moa/tasks/meta/ALPrequentialEvaluationTask.java
+++ b/moa/src/main/java/moa/tasks/meta/ALPrequentialEvaluationTask.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks.meta;
 
@@ -30,252 +30,216 @@
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
-import moa.classifiers.active.ALClassifier;
 import moa.core.Example;
 import moa.core.Measurement;
 import moa.core.ObjectRepository;
 import moa.core.TimingUtils;
-import moa.evaluation.ALClassificationPerformanceEvaluator;
 import moa.evaluation.LearningEvaluation;
+import moa.evaluation.evaluators.ALClassificationPerformanceEvaluator;
 import moa.evaluation.preview.LearningCurve;
 import moa.evaluation.preview.PreviewCollectionLearningCurveWrapper;
+import moa.learners.predictors.active.ALClassifier;
 import moa.options.ClassOption;
 import moa.streams.ExampleStream;
 import moa.tasks.TaskMonitor;
 
 /**
- * This task performs prequential evaluation for an active learning classifier 
- * (testing, then training with each example in sequence). It is mainly based
- * on the class EvaluateALPrequentialCV.
- * 
+ * This task performs prequential evaluation for an active learning classifier
+ * (testing, then training with each example in sequence). It is mainly based on
+ * the class EvaluateALPrequentialCV.
+ *
  * @author Cornelius Styp von Rekowski (cornelius.styp@ovgu.de)
  * @version $Revision: 1 $
  */
 public class ALPrequentialEvaluationTask extends ALMainTask {
-	
+
 	private static final long serialVersionUID = 1L;
-	
+
 	@Override
 	public String getPurposeString() {
 		return "Perform prequential evaluation (testing, then training with"
-				+ " each example in sequence) for an active learning"
-				+ " classifier.";
+				+ " each example in sequence) for an active learning" + " classifier.";
 	}
-	
-	public ClassOption learnerOption = new ClassOption("learner", 'l',
-            "Learner to train.", ALClassifier.class, 
-            "moa.classifiers.active.ALRandom");
-	
-	public ClassOption streamOption = new ClassOption("stream", 's',
-            "Stream to learn from.", ExampleStream.class,
-            "generators.RandomTreeGenerator");
-	
-	public ClassOption evaluatorOption = new ClassOption(
-			"evaluator", 'e',
-            "Active Learning classification performance evaluation method.",
-            ALClassificationPerformanceEvaluator.class,
-            "ALWindowClassificationPerformanceEvaluator");
-	
+
+	public ClassOption learnerOption = new ClassOption("learner", 'l', "Learner to train.", ALClassifier.class,
+			"ALRandom");
+
+	public ClassOption streamOption = new ClassOption("stream", 's', "Stream to learn from.", ExampleStream.class,
+			"generators.RandomTreeGenerator");
+
+	public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
+			"Active Learning classification performance evaluation method.", ALClassificationPerformanceEvaluator.class,
+			"ALWindowClassificationPerformanceEvaluator");
+
 	public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
-            "Maximum number of instances to test/train on  (-1 = no limit).",
-            100000000, -1, Integer.MAX_VALUE);
-	
+			"Maximum number of instances to test/train on  (-1 = no limit).", 100000000, -1, Integer.MAX_VALUE);
+
 	public IntOption timeLimitOption = new IntOption("timeLimit", 't',
-            "Maximum number of seconds to test/train for (-1 = no limit).", -1,
-            -1, Integer.MAX_VALUE);
-	
-	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
-            'f',
-            "How many instances between samples of the learning performance.",
-            100000, 0, Integer.MAX_VALUE);
-	
-	public FileOption dumpFileOption = new FileOption("dumpFile", 'd',
-            "File to append intermediate csv results to.", null, "csv", true);
-	
-	
+			"Maximum number of seconds to test/train for (-1 = no limit).", -1, -1, Integer.MAX_VALUE);
+
+	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency", 'f',
+			"How many instances between samples of the learning performance.", 100000, 0, Integer.MAX_VALUE);
+
+	public FileOption dumpFileOption = new FileOption("dumpFile", 'd', "File to append intermediate csv results to.",
+			null, "csv", true);
+
 	/**
 	 * Constructor which sets the color coding to black.
 	 */
 	public ALPrequentialEvaluationTask() {
 		this(Color.BLACK);
 	}
-	
+
 	/**
 	 * Constructor with which a color coding can be set.
+	 * 
 	 * @param colorCoding the color used by the task
 	 */
 	public ALPrequentialEvaluationTask(Color colorCoding) {
 		this.colorCoding = colorCoding;
 	}
-	
+
 	@Override
 	public Class<?> getTaskResultType() {
 		return LearningCurve.class;
 	}
-	
+
 	@SuppressWarnings("unchecked")
 	@Override
 	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
 		// get stream
-		ExampleStream<Example<Instance>> stream = 
-				(ExampleStream<Example<Instance>>) 
-				getPreparedClassOption(this.streamOption);
-		
+		ExampleStream<Example<Instance>> stream = (ExampleStream<Example<Instance>>) getPreparedClassOption(
+				this.streamOption);
+
 		// initialize learner
-		ALClassifier learner = 
-				(ALClassifier) getPreparedClassOption(this.learnerOption);
+		ALClassifier learner = (ALClassifier) getPreparedClassOption(this.learnerOption);
 		learner.resetLearning();
 		learner.setModelContext(stream.getHeader());
-		
+
 		// get evaluator
-        ALClassificationPerformanceEvaluator evaluator = (ALClassificationPerformanceEvaluator) 
-        		getPreparedClassOption(this.evaluatorOption);
-        
-        // initialize learning curve
-        LearningCurve learningCurve = new LearningCurve(
-        		"learning evaluation instances");
-        
+		ALClassificationPerformanceEvaluator evaluator = (ALClassificationPerformanceEvaluator) getPreparedClassOption(
+				this.evaluatorOption);
+
+		// initialize learning curve
+		LearningCurve learningCurve = new LearningCurve("learning evaluation instances");
+
 		// perform training and testing
-        int maxInstances = this.instanceLimitOption.getValue();
-        int instancesProcessed = 0;
-        int maxSeconds = this.timeLimitOption.getValue();
-        int secondsElapsed = 0;
-        boolean firstDump = true;
-        boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
-        long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-        long lastEvaluateStartTime = evaluateStartTime;
-        double RAMHours = 0.0;
-        
-        File dumpFile = this.dumpFileOption.getFile();
-        PrintStream immediateResultStream = null;
-        if (dumpFile != null) {
-        	try {
-        		if (dumpFile.exists()) {
-        			immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile, true), true);
-                } else {
-                    immediateResultStream = new PrintStream(
-                            new FileOutputStream(dumpFile), true);
-                }
-        	} catch (Exception ex) {
-                throw new RuntimeException(
-                		"Unable to open immediate result file: " + dumpFile, ex);
-            }
-        }
-        
-        monitor.setCurrentActivity("Evaluating learner...", -1.0);
-        while (stream.hasMoreInstances()
-        	   && ((maxInstances < 0) 
-        		   || (instancesProcessed < maxInstances))
-        	   && ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) 
-        {
-        	Example<Instance> trainInst = stream.nextInstance();
-        	Example<Instance> testInst = trainInst;
-        	
-        	// predict class for instance
-        	double[] prediction = learner.getPredictionForInstance(testInst).asDoubleArray();
-        	evaluator.addResult(testInst, prediction);
-        	
-        	// train on instance
-        	learner.trainOnInstance(trainInst);
-        	
-        	// check if label was acquired
-        	int labelAcquired = learner.getLastLabelAcqReport();
-        	evaluator.doLabelAcqReport(trainInst, labelAcquired);
-        	
-        	instancesProcessed++;
-        	
-        	// update learning curve
-        	if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0
-        		|| !stream.hasMoreInstances())
-        	{
-        		long evaluateTime = 
-        				TimingUtils.getNanoCPUTimeOfCurrentThread();
-                double time = TimingUtils.nanoTimeToSeconds(
-                		evaluateTime - evaluateStartTime);
-                double timeIncrement = TimingUtils.nanoTimeToSeconds(
-                		evaluateTime - lastEvaluateStartTime);
-                double RAMHoursIncrement = 
-                		learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); //GBs
-                RAMHoursIncrement *= (timeIncrement / 3600.0); //Hours
-                RAMHours += RAMHoursIncrement;
-                lastEvaluateStartTime = evaluateTime;
-        		
-        		learningCurve.insertEntry(new LearningEvaluation(
-        				new Measurement[]{
-        						new Measurement(
-        								"learning evaluation instances",
-        								instancesProcessed),
-        						new Measurement(
-        	                            "evaluation time ("
-        	                            + (preciseCPUTiming ? "cpu "
-        	                            : "") + "seconds)",
-        	                            time),
-	                            new Measurement(
-        	                            "model cost (RAM-Hours)",
-        	                            RAMHours),
-        				},
-        				evaluator, learner));
-        		
-        		if (immediateResultStream != null) {
-                    if (firstDump) {
-                        immediateResultStream.println(learningCurve.headerToString());
-                        firstDump = false;
-                    }
-                    immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
-                    immediateResultStream.flush();
-                }
-        	}
-        	
-        	// update monitor
-        	if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0 && learningCurve.numEntries() > 0) {
-        		if (monitor.taskShouldAbort()) {
-                    return null;
-                }
-        		
-        		long estimatedRemainingInstances = 
-        				stream.estimatedRemainingInstances();
-        		
-        		if (maxInstances > 0) {
-        			long maxRemaining = maxInstances - instancesProcessed;
-        			if ((estimatedRemainingInstances < 0 || estimatedRemainingInstances == 0)
-        				|| (maxRemaining < estimatedRemainingInstances))
-        			{
-        				estimatedRemainingInstances = maxRemaining;
-        			}
-        		}
-        		
-        		
-        		// calculate completion fraction
-        		double fractionComplete = (double) instancesProcessed / 
-        				(instancesProcessed + estimatedRemainingInstances);
-        		monitor.setCurrentActivityFractionComplete(
-        				estimatedRemainingInstances < 0 ? 
-        						-1.0 : fractionComplete);
-        		
-        		
-        		// TODO currently the preview is sent after each instance
-        		// 		should be changed later on
-        		if (monitor.resultPreviewRequested() || isSubtask()) {
-        			monitor.setLatestResultPreview(new PreviewCollectionLearningCurveWrapper((LearningCurve)learningCurve.copy(), this.getClass()));
-                }
-        		
-        		// update time measurement
-        		secondsElapsed = (int) TimingUtils.nanoTimeToSeconds(
-        				TimingUtils.getNanoCPUTimeOfCurrentThread()
-                        - evaluateStartTime);
-        	}
-        }
-        
-        if (immediateResultStream != null) {
-            immediateResultStream.close();
-        }
-		
+		int maxInstances = this.instanceLimitOption.getValue();
+		int instancesProcessed = 0;
+		int maxSeconds = this.timeLimitOption.getValue();
+		int secondsElapsed = 0;
+		boolean firstDump = true;
+		boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
+		long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+		long lastEvaluateStartTime = evaluateStartTime;
+		double RAMHours = 0.0;
+
+		File dumpFile = this.dumpFileOption.getFile();
+		PrintStream immediateResultStream = null;
+		if (dumpFile != null) {
+			try {
+				if (dumpFile.exists()) {
+					immediateResultStream = new PrintStream(new FileOutputStream(dumpFile, true), true);
+				} else {
+					immediateResultStream = new PrintStream(new FileOutputStream(dumpFile), true);
+				}
+			} catch (Exception ex) {
+				throw new RuntimeException("Unable to open immediate result file: " + dumpFile, ex);
+			}
+		}
+
+		monitor.setCurrentActivity("Evaluating learner...", -1.0);
+		while (stream.hasMoreInstances() && ((maxInstances < 0) || (instancesProcessed < maxInstances))
+				&& ((maxSeconds < 0) || (secondsElapsed < maxSeconds))) {
+			Example<Instance> trainInst = stream.nextInstance();
+			Example<Instance> testInst = trainInst;
+
+			// predict class for instance
+			double[] prediction = learner.getPredictionForInstance(testInst).asDoubleArray();
+			evaluator.addResult(testInst, prediction);
+
+			// train on instance
+			learner.trainOnInstance(trainInst);
+
+			// check if label was acquired
+			int labelAcquired = learner.getLastLabelAcqReport();
+			evaluator.doLabelAcqReport(trainInst, labelAcquired);
+
+			instancesProcessed++;
+
+			// update learning curve
+			if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0 || !stream.hasMoreInstances()) {
+				long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+				double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);
+				double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);
+				double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); // GBs
+				RAMHoursIncrement *= (timeIncrement / 3600.0); // Hours
+				RAMHours += RAMHoursIncrement;
+				lastEvaluateStartTime = evaluateTime;
+
+				learningCurve
+						.insertEntry(
+								new LearningEvaluation(
+										new Measurement[] {
+												new Measurement("learning evaluation instances", instancesProcessed),
+												new Measurement("evaluation time (" + (preciseCPUTiming ? "cpu " : "")
+														+ "seconds)", time),
+												new Measurement("model cost (RAM-Hours)", RAMHours), },
+										evaluator, learner));
+
+				if (immediateResultStream != null) {
+					if (firstDump) {
+						immediateResultStream.println(learningCurve.headerToString());
+						firstDump = false;
+					}
+					immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
+					immediateResultStream.flush();
+				}
+			}
+
+			// update monitor
+			if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0 && learningCurve.numEntries() > 0) {
+				if (monitor.taskShouldAbort()) {
+					return null;
+				}
+
+				long estimatedRemainingInstances = stream.estimatedRemainingInstances();
+
+				if (maxInstances > 0) {
+					long maxRemaining = maxInstances - instancesProcessed;
+					if ((estimatedRemainingInstances < 0 || estimatedRemainingInstances == 0)
+							|| (maxRemaining < estimatedRemainingInstances)) {
+						estimatedRemainingInstances = maxRemaining;
+					}
+				}
+
+				// calculate completion fraction
+				double fractionComplete = (double) instancesProcessed
+						/ (instancesProcessed + estimatedRemainingInstances);
+				monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0 : fractionComplete);
+
+				// TODO currently the preview is sent after each instance
+				// should be changed later on
+				if (monitor.resultPreviewRequested() || isSubtask()) {
+					monitor.setLatestResultPreview(new PreviewCollectionLearningCurveWrapper(
+							(LearningCurve) learningCurve.copy(), this.getClass()));
+				}
+
+				// update time measurement
+				secondsElapsed = (int) TimingUtils
+						.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread() - evaluateStartTime);
+			}
+		}
+
+		if (immediateResultStream != null) {
+			immediateResultStream.close();
+		}
+
 		return new PreviewCollectionLearningCurveWrapper(learningCurve, this.getClass());
 	}
-	
+
 	@Override
 	public List<ALTaskThread> getSubtaskThreads() {
-		return new ArrayList<ALTaskThread>();
+		return new ArrayList<>();
 	}
 }
diff --git a/moa/src/main/java/moa/tasks/meta/ALTaskThread.java b/moa/src/main/java/moa/tasks/meta/ALTaskThread.java
index 08f4078d1..4a02388eb 100644
--- a/moa/src/main/java/moa/tasks/meta/ALTaskThread.java
+++ b/moa/src/main/java/moa/tasks/meta/ALTaskThread.java
@@ -17,7 +17,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks.meta;
 
@@ -30,7 +30,8 @@
 import moa.tasks.TaskThread;
 
 /**
- * Task Thread for ALMainTask which supports pausing/resuming and cancelling of child threads
+ * Task Thread for ALMainTask which supports pausing/resuming and cancelling of
+ * child threads
  *
  * @author Tuan Pham Minh (tuan.pham@ovgu.de)
  * @version $Revision: 1 $
@@ -44,78 +45,70 @@ public ALTaskThread(Task toRun) {
 	public ALTaskThread(Task toRun, ObjectRepository repository) {
 		super(toRun, repository);
 	}
-	
+
 	@Override
-    public synchronized void pauseTask() {
-		ALMainTask task = (ALMainTask)getTask();
+	public synchronized void pauseTask() {
+		ALMainTask task = (ALMainTask) getTask();
 		List<ALTaskThread> threads = task.getSubtaskThreads();
-		
-        super.pauseTask();
-        
-        // pause all subtask threads
-        for(int i = 0; i < threads.size(); ++i)
-        {
-        	threads.get(i).pauseTask();
-        }
-    }
+
+		super.pauseTask();
+
+		// pause all subtask threads
+		for (int i = 0; i < threads.size(); ++i) {
+			threads.get(i).pauseTask();
+		}
+	}
 
 	@Override
-    public synchronized void resumeTask() {
-		ALMainTask task = (ALMainTask)getTask();
+	public synchronized void resumeTask() {
+		ALMainTask task = (ALMainTask) getTask();
 		List<ALTaskThread> threads = task.getSubtaskThreads();
-		
-        super.resumeTask();
 
-        // resume all subtask threads
-        for(int i = 0; i < threads.size(); ++i)
-        {
-        	threads.get(i).resumeTask();
-        }
-    }
+		super.resumeTask();
+
+		// resume all subtask threads
+		for (int i = 0; i < threads.size(); ++i) {
+			threads.get(i).resumeTask();
+		}
+	}
 
 	@Override
-    public synchronized void cancelTask() {
-		ALMainTask task = (ALMainTask)getTask();
+	public synchronized void cancelTask() {
+		ALMainTask task = (ALMainTask) getTask();
 		List<ALTaskThread> threads = task.getSubtaskThreads();
-		
-        super.cancelTask();
-        
-        if(!isFailed())
-        	this.finalResult = getLatestResultPreview();
-        
-
-        // cancel all subtask threads
-        for(int i = 0; i < threads.size(); ++i)
-        {
-        	if(!threads.get(i).isComplete())
-        	{
-            	threads.get(i).cancelTask();
-        	}
-        }
-    }
-
-    @Override
-    public void run() {
-        TimingUtils.enablePreciseTiming();
-        this.taskStartTime = TimingUtils.getNanoCPUTimeOfThread(getId());
-        try {
-            this.currentStatus = Status.RUNNING;
-            this.finalResult = this.runningTask.doTask(this.taskMonitor,
-                    this.repository);
-            this.currentStatus = this.taskMonitor.isCancelled() ? Status.CANCELLED
-                    : Status.COMPLETED;
-        } catch (Throwable ex) {
-            this.finalResult = new FailedTaskReport(ex);
-            this.currentStatus = Status.FAILED;
-        }
-        
-        if(currentStatus == Status.FAILED || currentStatus == Status.CANCELLED)
-        {
-            cancelTask();
-        }
-        
-        this.taskEndTime = TimingUtils.getNanoCPUTimeOfThread(getId());
-        fireTaskCompleted();
-        this.taskMonitor.setLatestResultPreview(null); // free preview memory
-    }
+
+		super.cancelTask();
+
+		if (!isFailed())
+			this.finalResult = getLatestResultPreview();
+
+		// cancel all subtask threads
+		for (int i = 0; i < threads.size(); ++i) {
+			if (!threads.get(i).isComplete()) {
+				threads.get(i).cancelTask();
+			}
+		}
+	}
+
+	@Override
+	public void run() {
+		TimingUtils.enablePreciseTiming();
+		this.taskStartTime = TimingUtils.getNanoCPUTimeOfThread(getId());
+		try {
+			this.currentStatus = Status.RUNNING;
+			this.finalResult = this.runningTask.doTask(this.taskMonitor, this.repository);
+			this.currentStatus = this.taskMonitor.isCancelled() ? Status.CANCELLED : Status.COMPLETED;
+		} catch (Throwable ex) {
+			this.finalResult = new FailedTaskReport(ex);
+			this.currentStatus = Status.FAILED;
+		}
+
+		if (currentStatus == Status.FAILED || currentStatus == Status.CANCELLED) {
+			cancelTask();
+		}
+
+		this.taskEndTime = TimingUtils.getNanoCPUTimeOfThread(getId());
+		fireTaskCompleted();
+		this.taskMonitor.setLatestResultPreview(null); // free preview memory
+	}
 }
diff --git a/moa/src/main/java/moa/tasks/meta/MetaMainTask.java b/moa/src/main/java/moa/tasks/meta/MetaMainTask.java
index bce28d049..b0b6e0170 100644
--- a/moa/src/main/java/moa/tasks/meta/MetaMainTask.java
+++ b/moa/src/main/java/moa/tasks/meta/MetaMainTask.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks.meta;
 
@@ -26,128 +26,123 @@
 import moa.tasks.TaskThread;
 
 /**
- * This class provides features for handling tasks in a tree-like 
- * structure of parents and subtasks.
- * 
+ * This class provides features for handling tasks in a tree-like structure of
+ * parents and subtasks.
+ *
  * @author Cornelius Styp von Rekowski (cornelius.styp@ovgu.de)
  * @version $Revision: 1 $
  */
 public abstract class MetaMainTask extends MainTask {
-	
+
 	private static final long serialVersionUID = 1L;
-	
+
 	protected boolean[] isLastSubtaskOnLevel = {};
-	
+
 	protected String nameSuffix = "";
-	
+
 	protected Color colorCoding = Color.BLACK;
-	
+
 	/**
 	 * Get the list of threads for all subtasks and recursively the children's
 	 * subtasks.
-	 * 
+	 *
 	 * @return list of subtask threads, recursively generated
 	 */
 	public abstract List<? extends TaskThread> getSubtaskThreads();
-	
+
 	/**
-	 * Get the task's display name consisting of the general task name, 
-	 * indentation showing the tree structure depending on the subtask level
-	 * and optionally a name suffix given from a supertask.
-	 * 
+	 * Get the task's display name consisting of the general task name, indentation
+	 * showing the tree structure depending on the subtask level and optionally a
+	 * name suffix given from a supertask.
+	 *
 	 * @return display name
 	 */
 	public String getDisplayName() {
 		StringBuilder name = new StringBuilder();
-		
+
 		// add indentation representing tree structure of tasks
-		for (int i = 0; i < this.getSubtaskLevel() -1; i++) {
+		for (int i = 0; i < this.getSubtaskLevel() - 1; i++) {
 			if (this.isLastSubtaskOnLevel[i]) {
 				name.append("         ");
-			}
-			else {
+			} else {
 				name.append("│      ");
 			}
 		}
 		if (this.getSubtaskLevel() > 0) {
-			if (this.isLastSubtaskOnLevel[this.getSubtaskLevel() - 1]) 
-			{
+			if (this.isLastSubtaskOnLevel[this.getSubtaskLevel() - 1]) {
 				name.append("└──");
-			}
-			else {
+			} else {
 				name.append("├──");
 			}
 		}
-		
+
 		// append class name
 		name.append(this.getClass().getSimpleName());
-		
+
 		// append optional suffix
 		name.append(" ").append(this.nameSuffix);
-		
+
 		return name.toString();
 	}
-	
+
 	/**
 	 * Set a suffix for the tasks display name.
-	 * 
+	 *
 	 * @param suffix
 	 */
 	public void setNameSuffix(String suffix) {
 		this.nameSuffix = suffix;
 	}
-	
+
 	/**
-	 * Set the list of booleans indicating if the current branch in the 
-	 * subtask tree is the last one on its respective level.
-	 * 
+	 * Set the list of booleans indicating if the current branch in the subtask tree
+	 * is the last one on its respective level.
+	 *
 	 * @param parentIsLastSubtaskList the internal list of the parent
-	 * @param isLastSubtask if the current subtask is the parents last one
+	 * @param isLastSubtask           if the current subtask is the parents last one
 	 */
-	public void setIsLastSubtaskOnLevel(
-			boolean[] parentIsLastSubtaskList, boolean isLastSubtask)
-	{
-		this.isLastSubtaskOnLevel = 
-				new boolean[parentIsLastSubtaskList.length + 1];
-		
+	public void setIsLastSubtaskOnLevel(boolean[] parentIsLastSubtaskList, boolean isLastSubtask) {
+		this.isLastSubtaskOnLevel = new boolean[parentIsLastSubtaskList.length + 1];
+
 		for (int i = 0; i < parentIsLastSubtaskList.length; i++) {
 			this.isLastSubtaskOnLevel[i] = parentIsLastSubtaskList[i];
 		}
-		this.isLastSubtaskOnLevel[parentIsLastSubtaskList.length] = 
-				isLastSubtask;
+		this.isLastSubtaskOnLevel[parentIsLastSubtaskList.length] = isLastSubtask;
 	}
-	
+
 	/**
-	 * Get the tasks subtask level (how deep it is in the tree).
-	 * 0 is the root task level.
-	 * 
+	 * Get the tasks subtask level (how deep it is in the tree). 0 is the root task
+	 * level.
+	 *
 	 * @return
 	 */
 	public int getSubtaskLevel() {
 		return this.isLastSubtaskOnLevel.length;
 	}
-	
+
 	/**
 	 * Check if the task is a subtask of another parent.
-	 * 
+	 *
 	 * @return true if the task is a subtask
 	 */
 	public boolean isSubtask() {
 		return this.getSubtaskLevel() > 0;
 	}
-	
+
 	/**
-	 * Set the color coding for this task (the color which is used for multi-curve plots).
-	 * 
+	 * Set the color coding for this task (the color which is used for multi-curve
+	 * plots).
+	 *
 	 * @param newColorCoding the new color coding for this task
 	 */
 	public void setColorCoding(Color newColorCoding) {
 		this.colorCoding = newColorCoding;
 	}
-	
+
 	/**
-	 * Get the color coding for this task (the color which is used for multi-curve plots).
-	 * 
+	 * Get the color coding for this task (the color which is used for multi-curve
+	 * plots).
+	 *
 	 * @return the color coding for this task
 	 */
 	public Color getColorCoding() {
diff --git a/moa/src/main/java/moa/tasks/regression/EvaluateModel.java b/moa/src/main/java/moa/tasks/regression/EvaluateModel.java
index dddb0feb9..ad5b659f2 100644
--- a/moa/src/main/java/moa/tasks/regression/EvaluateModel.java
+++ b/moa/src/main/java/moa/tasks/regression/EvaluateModel.java
@@ -15,11 +15,14 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks.regression;
 
-import moa.learners.Regressor;
+import moa.capabilities.CapabilitiesHandler;
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
+import moa.learners.predictors.Regressor;
 import moa.options.ClassOption;
 import moa.tasks.AbstractEvaluateModel;
 
@@ -29,18 +32,25 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class EvaluateModel extends AbstractEvaluateModel<Regressor> implements RegressionMainTask {
+public class EvaluateModel extends AbstractEvaluateModel<Regressor> implements RegressionMainTask, CapabilitiesHandler {
 
-    @Override
-    public String getPurposeString() {
-        return "Evaluates a static model on a stream.";
-    }
+	@Override
+	public String getPurposeString() {
+		return "Evaluates a static model on a stream.";
+	}
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public EvaluateModel() {
-    	this.modelOption = new ClassOption("model", 'm',
-                "Learner to evaluate.", Regressor.class, "moa.classifiers.trees.FIMTDD");
+	public EvaluateModel() {
+		this.modelOption = new ClassOption("model", 'm', "Learner to evaluate.", Regressor.class,
+				"trees.FIMTDD");
 	}
 
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == EvaluateModel.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
 }
diff --git a/moa/src/main/java/moa/tasks/regression/EvaluatePrequential.java b/moa/src/main/java/moa/tasks/regression/EvaluatePrequential.java
index 4962ca3b8..78795a36d 100644
--- a/moa/src/main/java/moa/tasks/regression/EvaluatePrequential.java
+++ b/moa/src/main/java/moa/tasks/regression/EvaluatePrequential.java
@@ -16,7 +16,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks.regression;
 
@@ -25,34 +25,33 @@
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-import moa.evaluation.LearningPerformanceEvaluator;
-import moa.learners.Regressor;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
+import moa.learners.predictors.Regressor;
 import moa.options.ClassOption;
 import moa.tasks.AbstractEvaluatePrequential;
 
 /**
- * Task for evaluating a classifier on a stream by testing then training with each example in sequence.
+ * Task for evaluating a classifier on a stream by testing then training with
+ * each example in sequence.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
  * @version $Revision: 7 $
  */
 public class EvaluatePrequential extends AbstractEvaluatePrequential<Regressor> implements RegressionMainTask {
-	
-    private static final long serialVersionUID = 1L;
-	
-    public EvaluatePrequential() {
-    	this.learnerOption = new ClassOption("learner", 'l', "Regressor to evaluate.", Regressor.class, "moa.classifiers.trees.FIMTDD");
-    	this.evaluatorOption = new ClassOption("evaluator", 'e',
-				"Regression performance evaluation method.",
-				LearningPerformanceEvaluator.class,
-				"WindowRegressionPerformanceEvaluator");
+
+	private static final long serialVersionUID = 1L;
+
+	public EvaluatePrequential() {
+		this.learnerOption = new ClassOption("learner", 'l', "Regressor to evaluate.", Regressor.class, "trees.FIMTDD");
+		this.evaluatorOption = new ClassOption("evaluator", 'e', "Regression performance evaluation method.",
+				LearningPerformanceEvaluator.class, "WindowRegressionPerformanceEvaluator");
 	}
 
 	@Override
-    public String getPurposeString() {
-        return "Evaluates a regressor on a stream by testing then training with each example in sequence.";
-    }
+	public String getPurposeString() {
+		return "Evaluates a regressor on a stream by testing then training with each example in sequence.";
+	}
 
 	@Override
 	public void printPrediction(PrintStream print, Instance inst, Prediction prediction) {
diff --git a/moa/src/main/java/moa/tasks/regression/EvaluatePrequentialCV.java b/moa/src/main/java/moa/tasks/regression/EvaluatePrequentialCV.java
index e78ee89df..5ca0b3d62 100644
--- a/moa/src/main/java/moa/tasks/regression/EvaluatePrequentialCV.java
+++ b/moa/src/main/java/moa/tasks/regression/EvaluatePrequentialCV.java
@@ -6,9 +6,9 @@
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
 import moa.core.Utils;
-import moa.evaluation.LearningPerformanceEvaluator;
-import moa.learners.Classifier;
-import moa.learners.Regressor;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.Regressor;
 import moa.options.ClassOption;
 import moa.tasks.AbstractEvaluatePrequential;
 import moa.tasks.classification.ClassificationMainTask;
@@ -16,21 +16,20 @@
 public class EvaluatePrequentialCV extends AbstractEvaluatePrequential<Classifier> implements ClassificationMainTask {
 
 	private static final long serialVersionUID = 1L;
-	
+
 	public EvaluatePrequentialCV() {
-		this.learnerOption = new ClassOption("learner", 'l', "Classifier to evaluate.", 
-				Regressor.class, "moa.classifiers.trees.FIMTDD");
+		this.learnerOption = new ClassOption("learner", 'l', "Classifier to evaluate.", Regressor.class,
+				"trees.FIMTDD");
 		this.evaluatorOption = new ClassOption("evaluator", 'e', "Classification performance evaluation method.",
-				LearningPerformanceEvaluator.class,
-				"WindowRegressionPerformanceEvaluator");
+				LearningPerformanceEvaluator.class, "WindowRegressionPerformanceEvaluator");
 	}
 
 	@Override
 	public String getPurposeString() {
-		return "Evaluates a classifier on a stream by doing prequential evaluation (testing then training with each" +
-				" example in sequence) and doing cross-validation.";
+		return "Evaluates a classifier on a stream by doing prequential evaluation (testing then training with each"
+				+ " example in sequence) and doing cross-validation.";
 	}
-	
+
 	@Override
 	public void printPrediction(PrintStream print, Instance inst, Prediction prediction) {
 		int trueClass = (int) inst.classValue();
diff --git a/moa/src/main/java/moa/tasks/regression/LearnModel.java b/moa/src/main/java/moa/tasks/regression/LearnModel.java
index a5f0c2789..14ceae0c6 100644
--- a/moa/src/main/java/moa/tasks/regression/LearnModel.java
+++ b/moa/src/main/java/moa/tasks/regression/LearnModel.java
@@ -15,16 +15,14 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks.regression;
 
 import moa.capabilities.CapabilitiesHandler;
 import moa.capabilities.Capability;
 import moa.capabilities.ImmutableCapabilities;
-import moa.streams.clustering.ClusterEvent;
-
-import moa.learners.Regressor;
+import moa.learners.predictors.Regressor;
 import moa.options.ClassOption;
 import moa.tasks.AbstractLearnModel;
 
@@ -36,20 +34,23 @@
  */
 public class LearnModel extends AbstractLearnModel<Regressor> implements RegressionMainTask, CapabilitiesHandler {
 
-    @Override
-    public String getPurposeString() {
-        return "Learns a regression model from a stream.";
-    }
+	@Override
+	public String getPurposeString() {
+		return "Learns a regression model from a stream.";
+	}
+
+	private static final long serialVersionUID = 1L;
 
-    private static final long serialVersionUID = 1L;
+	public LearnModel() {
+		this.learnerOption = new ClassOption("learner", 'l', "Learner to train.", Regressor.class,
+				"trees.FIMTDD");
+	}
 
-    public LearnModel() {
-		this.learnerOption = new ClassOption("learner", 'l', "Learner to train.", Regressor.class, "moa.classifiers.trees.FIMTDD");
-    }
-    
-    public ImmutableCapabilities defineImmutableCapabilities() {
-        // We are restricting tasks based on view mode
-        return new ImmutableCapabilities(Capability.VIEW_STANDARD);
-    }
-    
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == LearnModel.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
+	}
 }
diff --git a/moa/src/main/java/moa/tasks/regression/RegressionMainTask.java b/moa/src/main/java/moa/tasks/regression/RegressionMainTask.java
index 1784edce9..706d902c7 100644
--- a/moa/src/main/java/moa/tasks/regression/RegressionMainTask.java
+++ b/moa/src/main/java/moa/tasks/regression/RegressionMainTask.java
@@ -27,5 +27,4 @@
  */
 public interface RegressionMainTask extends MainTaskInterface {
 
-    
 }
diff --git a/moa/src/main/java/moa/tasks/structuredoutput/multilabelclassification/EvaluateModel.java b/moa/src/main/java/moa/tasks/structuredoutput/multilabelclassification/EvaluateModel.java
index bf91400f5..520608003 100644
--- a/moa/src/main/java/moa/tasks/structuredoutput/multilabelclassification/EvaluateModel.java
+++ b/moa/src/main/java/moa/tasks/structuredoutput/multilabelclassification/EvaluateModel.java
@@ -15,7 +15,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks.structuredoutput.multilabelclassification;
 
@@ -27,15 +27,15 @@
 import com.github.javacliparser.IntOption;
 import com.yahoo.labs.samoa.instances.Instance;
 
-import moa.classifiers.rules.multilabel.functions.MultiLabelNaiveBayes;
 import moa.core.Example;
 import moa.core.ObjectRepository;
 import moa.evaluation.LearningEvaluation;
-import moa.evaluation.LearningPerformanceEvaluator;
-import moa.evaluation.MultiTargetRegressionPerformanceEvaluator;
-import moa.learners.Classifier;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
+import moa.evaluation.evaluators.MultiTargetRegressionPerformanceEvaluator;
 import moa.learners.MLTask;
-import moa.learners.MultiLabelClassifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.MultiLabelClassifier;
+import moa.learners.predictors.core.functions.MultiLabelNaiveBayes;
 import moa.options.ClassOption;
 import moa.streams.ExampleStream;
 import moa.streams.InstanceStream;
@@ -49,114 +49,106 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class EvaluateModel extends AbstractEvaluateModel<MultiLabelClassifier> implements MultiLabelClassificatioMainTask {
-
-    @Override
-    public String getPurposeString() {
-        return "Evaluates a static model on a stream.";
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    public ClassOption modelOption = new ClassOption("model", 'm',
-            "Learner to evaluate.", MultiLabelClassifier.class, MultiLabelNaiveBayes.class.getName());
-    
-    public ClassOption streamOption = new ClassOption("stream", 's',
-            "Stream to learn from.", MultiTargetInstanceStream.class,
-            "MultiTargetArffFileStream");
-
-    public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
-            "Classification performance evaluation method.",
-            MultiTargetRegressionPerformanceEvaluator.class,
-            "BasicMultiLabelPerformanceEvaluator");
-
-
-    public IntOption maxInstancesOption = new IntOption("maxInstances", 'i',
-            "Maximum number of instances to test.", 1000000, 0,
-            Integer.MAX_VALUE);
-
-    public FileOption outputPredictionFileOption = new FileOption("outputPredictionFile", 'o',
-            "File to append output predictions to.", null, "pred", true);
-
-    public EvaluateModel() {
-    }
-
-    public EvaluateModel(Classifier model, InstanceStream stream,
-                                   LearningPerformanceEvaluator evaluator, int maxInstances) {
-        this.modelOption.setCurrentObject(model);
-        this.streamOption.setCurrentObject(stream);
-        this.evaluatorOption.setCurrentObject(evaluator);
-        this.maxInstancesOption.setValue(maxInstances);
-    }
-
-    @Override
-    public Class<?> getTaskResultType() {
-        return LearningEvaluation.class;
-    }
-
-    @Override
-    public Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
-        MLTask model = (MLTask) getPreparedClassOption(this.modelOption);
-        ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
-        LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
-        int maxInstances = this.maxInstancesOption.getValue();
-        long instancesProcessed = 0;
-        monitor.setCurrentActivity("Evaluating model...", -1.0);
-
-        //File for output predictions
-        File outputPredictionFile = this.outputPredictionFileOption.getFile();
-        PrintStream outputPredictionResultStream = null;
-        if (outputPredictionFile != null) {
-            try {
-                if (outputPredictionFile.exists()) {
-                    outputPredictionResultStream = new PrintStream(
-                            new FileOutputStream(outputPredictionFile, true), true);
-                } else {
-                    outputPredictionResultStream = new PrintStream(
-                            new FileOutputStream(outputPredictionFile), true);
-                }
-            } catch (Exception ex) {
-                throw new RuntimeException(
-                        "Unable to open prediction result file: " + outputPredictionFile, ex);
-            }
-        }
-        while (stream.hasMoreInstances()
-                && ((maxInstances < 0) || (instancesProcessed < maxInstances))) {
-            Example testInst = (Example) stream.nextInstance();//.copy();
-            double trueClass = ((Instance) testInst.getData()).classValue();
-            //testInst.setClassMissing();
-            double[] prediction = model.getPredictionForInstance(testInst).asDoubleArray();
-            //evaluator.addClassificationAttempt(trueClass, prediction, testInst
-            //		.weight());
-            if (outputPredictionFile != null) {
-                outputPredictionResultStream.println(prediction[0] + "," + trueClass);
-            }
-            evaluator.addResult(testInst, prediction);
-            instancesProcessed++;
-            if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
-                if (monitor.taskShouldAbort()) {
-                    return null;
-                }
-                long estimatedRemainingInstances = stream.estimatedRemainingInstances();
-                if (maxInstances > 0) {
-                    long maxRemaining = maxInstances - instancesProcessed;
-                    if ((estimatedRemainingInstances < 0)
-                            || (maxRemaining < estimatedRemainingInstances)) {
-                        estimatedRemainingInstances = maxRemaining;
-                    }
-                }
-                monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
-                        : (double) instancesProcessed
-                        / (double) (instancesProcessed + estimatedRemainingInstances));
-                if (monitor.resultPreviewRequested()) {
-                    monitor.setLatestResultPreview(new LearningEvaluation(
-                            evaluator, model));
-                }
-            }
-        }
-        if (outputPredictionResultStream != null) {
-            outputPredictionResultStream.close();
-        }
-        return new LearningEvaluation(evaluator, model);
-    }
+public class EvaluateModel extends AbstractEvaluateModel<MultiLabelClassifier>
+		implements MultiLabelClassificatioMainTask {
+
+	@Override
+	public String getPurposeString() {
+		return "Evaluates a static model on a stream.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption modelOption = new ClassOption("model", 'm', "Learner to evaluate.", MultiLabelClassifier.class,
+			MultiLabelNaiveBayes.class.getName());
+
+	public ClassOption streamOption = new ClassOption("stream", 's', "Stream to learn from.",
+			MultiTargetInstanceStream.class, "MultiTargetArffFileStream");
+
+	public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
+			"Classification performance evaluation method.", MultiTargetRegressionPerformanceEvaluator.class,
+			"BasicMultiLabelPerformanceEvaluator");
+
+	public IntOption maxInstancesOption = new IntOption("maxInstances", 'i', "Maximum number of instances to test.",
+			1000000, 0, Integer.MAX_VALUE);
+
+	public FileOption outputPredictionFileOption = new FileOption("outputPredictionFile", 'o',
+			"File to append output predictions to.", null, "pred", true);
+
+	public EvaluateModel() {
+	}
+
+	public EvaluateModel(Classifier model, InstanceStream stream, LearningPerformanceEvaluator evaluator,
+			int maxInstances) {
+		this.modelOption.setCurrentObject(model);
+		this.streamOption.setCurrentObject(stream);
+		this.evaluatorOption.setCurrentObject(evaluator);
+		this.maxInstancesOption.setValue(maxInstances);
+	}
+
+	@Override
+	public Class<?> getTaskResultType() {
+		return LearningEvaluation.class;
+	}
+
+	@Override
+	public Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
+		MLTask model = (MLTask) getPreparedClassOption(this.modelOption);
+		ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
+		LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(
+				this.evaluatorOption);
+		int maxInstances = this.maxInstancesOption.getValue();
+		long instancesProcessed = 0;
+		monitor.setCurrentActivity("Evaluating model...", -1.0);
+
+		// File for output predictions
+		File outputPredictionFile = this.outputPredictionFileOption.getFile();
+		PrintStream outputPredictionResultStream = null;
+		if (outputPredictionFile != null) {
+			try {
+				if (outputPredictionFile.exists()) {
+					outputPredictionResultStream = new PrintStream(new FileOutputStream(outputPredictionFile, true),
+							true);
+				} else {
+					outputPredictionResultStream = new PrintStream(new FileOutputStream(outputPredictionFile), true);
+				}
+			} catch (Exception ex) {
+				throw new RuntimeException("Unable to open prediction result file: " + outputPredictionFile, ex);
+			}
+		}
+		while (stream.hasMoreInstances() && ((maxInstances < 0) || (instancesProcessed < maxInstances))) {
+			Example testInst = stream.nextInstance();// .copy();
+			double trueClass = ((Instance) testInst.getData()).classValue();
+			// testInst.setClassMissing();
+			double[] prediction = model.getPredictionForInstance(testInst).asDoubleArray();
+			// evaluator.addClassificationAttempt(trueClass, prediction, testInst
+			// .weight());
+			if (outputPredictionFile != null) {
+				outputPredictionResultStream.println(prediction[0] + "," + trueClass);
+			}
+			evaluator.addResult(testInst, prediction);
+			instancesProcessed++;
+			if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
+				if (monitor.taskShouldAbort()) {
+					return null;
+				}
+				long estimatedRemainingInstances = stream.estimatedRemainingInstances();
+				if (maxInstances > 0) {
+					long maxRemaining = maxInstances - instancesProcessed;
+					if ((estimatedRemainingInstances < 0) || (maxRemaining < estimatedRemainingInstances)) {
+						estimatedRemainingInstances = maxRemaining;
+					}
+				}
+				monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
+						: (double) instancesProcessed / (double) (instancesProcessed + estimatedRemainingInstances));
+				if (monitor.resultPreviewRequested()) {
+					monitor.setLatestResultPreview(new LearningEvaluation(evaluator, model));
+				}
+			}
+		}
+		if (outputPredictionResultStream != null) {
+			outputPredictionResultStream.close();
+		}
+		return new LearningEvaluation(evaluator, model);
+	}
 }
diff --git a/moa/src/main/java/moa/tasks/structuredoutput/multilabelclassification/EvaluatePrequential.java b/moa/src/main/java/moa/tasks/structuredoutput/multilabelclassification/EvaluatePrequential.java
index bb87dd582..5b91d8208 100644
--- a/moa/src/main/java/moa/tasks/structuredoutput/multilabelclassification/EvaluatePrequential.java
+++ b/moa/src/main/java/moa/tasks/structuredoutput/multilabelclassification/EvaluatePrequential.java
@@ -16,7 +16,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks.structuredoutput.multilabelclassification;
 
@@ -25,38 +25,39 @@
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-import moa.classifiers.rules.multilabel.functions.MultiLabelNaiveBayes;
-import moa.evaluation.MultiLabelClassificationPerformanceEvaluator;
-import moa.learners.MultiLabelClassifier;
+import moa.evaluation.evaluators.MultiLabelClassificationPerformanceEvaluator;
+import moa.learners.predictors.MultiLabelClassifier;
+import moa.learners.predictors.core.functions.MultiLabelNaiveBayes;
 import moa.options.ClassOption;
 import moa.tasks.AbstractEvaluatePrequential;
 
 /**
- * Task for evaluating a classifier on a stream by testing then training with each example in sequence.
+ * Task for evaluating a classifier on a stream by testing then training with
+ * each example in sequence.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
  * @version $Revision: 7 $
  */
-public class EvaluatePrequential extends AbstractEvaluatePrequential<MultiLabelClassifier> implements MultiLabelClassificatioMainTask {
+public class EvaluatePrequential extends AbstractEvaluatePrequential<MultiLabelClassifier>
+		implements MultiLabelClassificatioMainTask {
+
+	@Override
+	public String getPurposeString() {
+		return "Evaluates a multi-label classifier on a stream by testing then training with each example in sequence.";
+	}
 
-    @Override
-    public String getPurposeString() {
-        return "Evaluates a multi-label classifier on a stream by testing then training with each example in sequence.";
-    }
+	private static final long serialVersionUID = 1L;
 
-    private static final long serialVersionUID = 1L;
+	public EvaluatePrequential() {
+		this.learnerOption = new ClassOption("learner", 'l', "Learner to train.", MultiLabelClassifier.class,
+				"rules.multilabel.functions.MultiLabelNaiveBayes");
+
+		this.evaluatorOption = new ClassOption("evaluator", 'e', "Classification performance evaluation method.",
+				MultiLabelClassificationPerformanceEvaluator.class, "BasicMultiLabelPerformanceEvaluator");
+	}
 
-    public EvaluatePrequential() {
-    	this.learnerOption = new ClassOption("learner", 'l',
-            "Learner to train.", MultiLabelClassifier.class, MultiLabelNaiveBayes.class.getName());
-    
-    	this.evaluatorOption = new ClassOption("evaluator", 'e',
-            "Classification performance evaluation method.",
-            MultiLabelClassificationPerformanceEvaluator.class,
-            "BasicMultiLabelPerformanceEvaluator");  
-    }
-    
+	@Override
 	public void printPrediction(PrintStream print, Instance inst, Prediction prediction) {
 		print.println(prediction.asPredictionString() + "," + inst.outputAttributesToString());
 	}
diff --git a/moa/src/main/java/moa/tasks/structuredoutput/multilabelclassification/LearnModel.java b/moa/src/main/java/moa/tasks/structuredoutput/multilabelclassification/LearnModel.java
index 59520efc3..4b0202d50 100644
--- a/moa/src/main/java/moa/tasks/structuredoutput/multilabelclassification/LearnModel.java
+++ b/moa/src/main/java/moa/tasks/structuredoutput/multilabelclassification/LearnModel.java
@@ -1,21 +1,31 @@
 package moa.tasks.structuredoutput.multilabelclassification;
 
-import moa.learners.MultiLabelClassifier;
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
+import moa.learners.predictors.MultiLabelClassifier;
 import moa.options.ClassOption;
 import moa.tasks.AbstractLearnModel;
 
 public class LearnModel extends AbstractLearnModel<MultiLabelClassifier> implements MultiLabelClassificatioMainTask {
 
-    @Override
-    public String getPurposeString() {
-        return "Learns a multi-label classification model from a stream.";
-    }
+	@Override
+	public String getPurposeString() {
+		return "Learns a multi-label classification model from a stream.";
+	}
+
+	private static final long serialVersionUID = 1L;
 
-    private static final long serialVersionUID = 1L;
+	public LearnModel() {
+		this.learnerOption = new ClassOption("learner", 'l', "Learner to train.", MultiLabelClassifier.class,
+				"mlc.trees.MultiLabelHoeffdingTree");
+	}
 
-    public LearnModel() {
-		this.learnerOption = new ClassOption("learner", 'l', "Learner to train.", MultiLabelClassifier.class, "moa.classifiers.mlc.trees.MultiLabelHoeffdingTree");
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == LearnModel.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
 	}
-    
 	
 }
diff --git a/moa/src/main/java/moa/tasks/structuredoutput/multitargetregression/EvaluateModel.java b/moa/src/main/java/moa/tasks/structuredoutput/multitargetregression/EvaluateModel.java
index 08ec9dea7..860b62881 100644
--- a/moa/src/main/java/moa/tasks/structuredoutput/multitargetregression/EvaluateModel.java
+++ b/moa/src/main/java/moa/tasks/structuredoutput/multitargetregression/EvaluateModel.java
@@ -15,11 +15,11 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks.structuredoutput.multitargetregression;
 
-import moa.learners.MultiTargetRegressor;
+import moa.learners.predictors.MultiTargetRegressor;
 import moa.options.ClassOption;
 import moa.tasks.AbstractEvaluateModel;
 
@@ -29,16 +29,17 @@
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @version $Revision: 7 $
  */
-public class EvaluateModel extends AbstractEvaluateModel<MultiTargetRegressor> implements MultiTargetRegressionMainTask {
+public class EvaluateModel extends AbstractEvaluateModel<MultiTargetRegressor>
+		implements MultiTargetRegressionMainTask {
+
+	@Override
+	public String getPurposeString() {
+		return "Evaluates a static multi-target regression model on a stream.";
+	}
 
-    @Override
-    public String getPurposeString() {
-        return "Evaluates a static multi-target regression model on a stream.";
-    }
-    
-    public EvaluateModel() {
-    	this.modelOption = new ClassOption("model", 'm', 
-    			"Learner to evaluate.", MultiTargetRegressor.class, "moa.classifiers.mtr.trees.ISOUPTree");
+	public EvaluateModel() {
+		this.modelOption = new ClassOption("model", 'm', "Learner to evaluate.", MultiTargetRegressor.class,
+				"mtr.trees.ISOUPTree");
 	}
 
 	private static final long serialVersionUID = 1L;
diff --git a/moa/src/main/java/moa/tasks/structuredoutput/multitargetregression/EvaluatePrequential.java b/moa/src/main/java/moa/tasks/structuredoutput/multitargetregression/EvaluatePrequential.java
index 63ce667c2..3f58147f8 100644
--- a/moa/src/main/java/moa/tasks/structuredoutput/multitargetregression/EvaluatePrequential.java
+++ b/moa/src/main/java/moa/tasks/structuredoutput/multitargetregression/EvaluatePrequential.java
@@ -16,7 +16,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks.structuredoutput.multitargetregression;
 
@@ -25,40 +25,41 @@
 import com.yahoo.labs.samoa.instances.Instance;
 import com.yahoo.labs.samoa.instances.predictions.Prediction;
 
-import moa.evaluation.LearningPerformanceEvaluator;
-import moa.learners.Classifier;
-import moa.learners.MultiTargetRegressor;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
+import moa.learners.predictors.MultiTargetRegressor;
 import moa.options.ClassOption;
 import moa.tasks.AbstractEvaluatePrequential;
 
 /**
- * Task for evaluating a classifier on a stream by testing then training with each example in sequence.
+ * Task for evaluating a classifier on a stream by testing then training with
+ * each example in sequence.
  *
  * @author Richard Kirkby (rkirkby@cs.waikato.ac.nz)
  * @author Albert Bifet (abifet at cs dot waikato dot ac dot nz)
  * @version $Revision: 7 $
  */
-public class EvaluatePrequential extends AbstractEvaluatePrequential<MultiTargetRegressor> implements MultiTargetRegressionMainTask {
+public class EvaluatePrequential extends AbstractEvaluatePrequential<MultiTargetRegressor>
+		implements MultiTargetRegressionMainTask {
+
+	private static final long serialVersionUID = 1L;
 
-    private static final long serialVersionUID = 1L;
-	
-    public EvaluatePrequential() {
-		this.learnerOption = new ClassOption("learner", 'l', "Learner to train.", MultiTargetRegressor.class, "moa.classifiers.mtr.trees.ISOUPTree");
+	public EvaluatePrequential() {
+		this.learnerOption = new ClassOption("learner", 'l', "Learner to train.", MultiTargetRegressor.class,
+				"mtr.trees.ISOUPTree");
 		this.evaluatorOption = new ClassOption("evaluator", 'e',
-					"Multi target regression performance evaluation method.",
-					LearningPerformanceEvaluator.class,
-					"WindowMultiTargetRegressionPerformanceEvaluator");
-		}
+				"Multi target regression performance evaluation method.", LearningPerformanceEvaluator.class,
+				"WindowMultiTargetRegressionPerformanceEvaluator");
+	}
 
 	@Override
-    public String getPurposeString() {
-        return "Evaluates a multi-target regressor on a stream by testing then training with each example in sequence.";
-    }
+	public String getPurposeString() {
+		return "Evaluates a multi-target regressor on a stream by testing then training with each example in sequence.";
+	}
 
 	@Override
 	public void printPrediction(PrintStream print, Instance inst, Prediction prediction) {
 		print.println(prediction.asPredictionString() + "," + inst.outputAttributesToString());
-		
+
 	}
 
 }
diff --git a/moa/src/main/java/moa/tasks/structuredoutput/multitargetregression/EvaluatePrequentialMultiTargetSemiSuper.java b/moa/src/main/java/moa/tasks/structuredoutput/multitargetregression/EvaluatePrequentialMultiTargetSemiSuper.java
deleted file mode 100644
index dc3efcecd..000000000
--- a/moa/src/main/java/moa/tasks/structuredoutput/multitargetregression/EvaluatePrequentialMultiTargetSemiSuper.java
+++ /dev/null
@@ -1,401 +0,0 @@
-/*
- *    AMRulesMultiLabel.java
- *    Copyright (C) 2017 University of Porto, Portugal
- *    @author R. Sousa, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *    
- *    
- */
-package moa.tasks.structuredoutput.multitargetregression;
-
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.PrintStream;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Random;
-
-import com.github.javacliparser.FileOption;
-import com.github.javacliparser.FloatOption;
-import com.github.javacliparser.IntOption;
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.classifiers.MultiTargetLearnerSemiSupervised;
-import moa.core.Example;
-import moa.core.Measurement;
-import moa.core.ObjectRepository;
-import moa.core.TimingUtils;
-import moa.evaluation.EWMAClassificationPerformanceEvaluator;
-import moa.evaluation.FadingFactorClassificationPerformanceEvaluator;
-import moa.evaluation.LearningEvaluation;
-import moa.evaluation.LearningPerformanceEvaluator;
-import moa.evaluation.MultiTargetRegressionPerformanceEvaluator;
-import moa.evaluation.WindowClassificationPerformanceEvaluator;
-import moa.evaluation.preview.LearningCurve;
-import moa.options.ClassOption;
-import moa.streams.ExampleStream;
-import moa.streams.MultiTargetInstanceStream;
-import moa.tasks.MainTask;
-import moa.tasks.TaskMonitor;
-
-
-
-/**
-* Multi-target Prequential semi-supervised evaluation
-* 
-*Phase1: Creates a initial model with <dbInitialModelPercentage> of the instances in the dataset 
-*Phase2: When an instance is received:
-* A binary random process with a binomial distribution selects if the instance should be 
-* labeled or unlabeled with probability <unlabeledPercentage>.
-
-* @author RSousa
-* @version $Revision: 2 $
-*/
-
-
-public class EvaluatePrequentialMultiTargetSemiSuper extends MainTask {
-
-    @Override
-    public String getPurposeString() {
-        return "Multi-target Prequential semi-supervised evaluation \n Phase1: Creates a initial model with <dbInitialModelPercentage> of the instances in the dataset\n Phase2: When a instance is received: A binary random process with a binomial distribution selects if the instance should be  labeled or unlabeled with probability <unlabeledPercentage>.";
-    }
-
-    private static final long serialVersionUID = 1L;
-
-    public ClassOption learnerOption = new ClassOption("learner", 
-                'l',"Learner to train.", MultiTargetLearnerSemiSupervised.class, "moa.classifiers.rules.multilabel.AMRulesMultiTargetRegressorSemiSuper");
-    public ClassOption streamOption = new ClassOption("stream", 
-                's',"Stream to learn from.", MultiTargetInstanceStream.class,"MultiTargetArffFileStream");
-    public ClassOption evaluatorOption = new ClassOption("evaluator", 
-                'e',"Classification performance evaluation method.",MultiTargetRegressionPerformanceEvaluator.class,"BasicMultiTargetPerformanceEvaluator");
-    public IntOption instanceLimitOption = new IntOption("instanceLimit", 
-                'i',"Maximum number of instances to test/train on  (-1 = no limit).",100000000, -1, Integer.MAX_VALUE);
-    public IntOption timeLimitOption = new IntOption("timeLimit", 
-                't',"Maximum number of seconds to test/train for (-1 = no limit).", -1,-1, Integer.MAX_VALUE);
-    public IntOption sampleFrequencyOption = new IntOption("sampleFrequency",
-                'f',"How many instances between samples of the learning performance.",100000, 0, Integer.MAX_VALUE);
-    public IntOption memCheckFrequencyOption = new IntOption("memCheckFrequency", 
-                'q',"How many instances between memory bound checks.", 100000, 0,Integer.MAX_VALUE);
-    public FileOption dumpFileOption = new FileOption("dumpFile", 
-                'd',"File to append intermediate csv results to.", null, "csv", true);
-    public FileOption outputPredictionFileOption = new FileOption("outputPredictionFile", 
-                'o',"File to append output predictions to.", null, "pred", true);
-    public IntOption widthOption = new IntOption("width",
-                'w', "Size of Window", 1000); //New for prequential method DEPRECATED
-    public FloatOption alphaOption = new FloatOption("alpha",
-                'a', "Fading factor or exponential smoothing factor", .01);
-    public FloatOption unlabeledPercentage = new FloatOption("WithoutTarget",
-                'z', "Without target percentage(%)", 50);
-    public FloatOption dbInitialModelPercentage = new FloatOption("DBPercent",
-    			'D', "Initial dataset (%)", 30);
-    public IntOption runSeed = new IntOption("Seed",
-                'r', "Number of predictions",1);
-    public IntOption slidingWindowSize = new IntOption("slidingWindowSize",
-                'W', "slidingWindowSize",1000);
-    public IntOption slidingWindowStep = new IntOption("slidingWindowStep",
-                'j', "slidingWindowStep",1);
-    
-    @Override
-    public Class<?> getTaskResultType() {
-        return LearningCurve.class;
-    }
-
-    @Override
-    protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
-        
-        MultiTargetLearnerSemiSupervised learner = (MultiTargetLearnerSemiSupervised) getPreparedClassOption(this.learnerOption);
-        ExampleStream stream = (ExampleStream) getPreparedClassOption(this.streamOption);
-        LearningPerformanceEvaluator evaluator = (LearningPerformanceEvaluator) getPreparedClassOption(this.evaluatorOption);
-        LearningCurve learningCurve = new LearningCurve("learning evaluation instances");
-
-        
-        //New for prequential methods
-        if (evaluator instanceof WindowClassificationPerformanceEvaluator) {
-            //((WindowClassificationPerformanceEvaluator) evaluator).setWindowWidth(widthOption.getValue());
-            if (widthOption.getValue() != 1000) {
-                System.out.println("DEPRECATED! Use EvaluatePrequential -e (WindowClassificationPerformanceEvaluator -w " + widthOption.getValue() + ")");
-                 return learningCurve;
-            }
-        }
-        if (evaluator instanceof EWMAClassificationPerformanceEvaluator) {
-            //((EWMAClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
-            if (alphaOption.getValue() != .01) {
-                System.out.println("DEPRECATED! Use EvaluatePrequential -e (EWMAClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
-                return learningCurve;
-            }
-        }
-        if (evaluator instanceof FadingFactorClassificationPerformanceEvaluator) {
-            //((FadingFactorClassificationPerformanceEvaluator) evaluator).setalpha(alphaOption.getValue());
-            if (alphaOption.getValue() != .01) {
-                System.out.println("DEPRECATED! Use EvaluatePrequential -e (FadingFactorClassificationPerformanceEvaluator -a " + alphaOption.getValue() + ")");
-                return learningCurve;
-            }
-        }
-        
-        //End New for prequential methods
-        learner.setModelContext(stream.getHeader());
-        int maxInstances = this.instanceLimitOption.getValue();
-        long instancesProcessed = 0;
-        int maxSeconds = this.timeLimitOption.getValue();
-        int secondsElapsed = 0;
-        monitor.setCurrentActivity("Evaluating learner...", -1.0);
-
-        
-        File dumpFile = this.dumpFileOption.getFile();
-        PrintStream immediateResultStream = null;
-        if (dumpFile != null) {
-            try {
-                if (dumpFile.exists()) {
-                    immediateResultStream = new PrintStream(new FileOutputStream(dumpFile, true), true);
-                } else {
-                    immediateResultStream = new PrintStream(new FileOutputStream(dumpFile), true);
-                }
-            } catch (Exception ex) {
-                throw new RuntimeException("Unable to open immediate result file: " + dumpFile, ex);
-            }
-        }
-        
-        //File for output predictions
-        File outputPredictionFile = this.outputPredictionFileOption.getFile();
-        PrintStream outputPredictionResultStream = null;
-        if (outputPredictionFile != null) {
-            try {
-                if (outputPredictionFile.exists()) {
-                    outputPredictionResultStream = new PrintStream(new FileOutputStream(outputPredictionFile, true), true);
-                } else {
-                    outputPredictionResultStream = new PrintStream(new FileOutputStream(outputPredictionFile), true);
-                }
-            } catch (Exception ex) {
-                throw new RuntimeException("Unable to open prediction result file: " + outputPredictionFile, ex);
-            }
-        }
-        
-        boolean firstDump = true;
-        boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
-        long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-        long lastEvaluateStartTime = evaluateStartTime;
-        double RAMHours = 0.0;
-        
-        
-        Random randomGenerator1 = new Random(runSeed.getValue());   //Examples scrambler
-        Random randomGenerator2 = new Random(1);                    //Labeled/Unlabeled selector
-        List<Double> slidingWindow = new LinkedList<Double>();
-        
-        //Compute stream size
-        int StrmDtSz=0;
-        while (stream.hasMoreInstances()==true){
-            stream.nextInstance();
-            StrmDtSz++;
-        }
-
-        
-        Example [] streamData = new Example[StrmDtSz];
-        int[] randIndex= new int[StrmDtSz];
-        
-        int i=0;
-        stream.restart();
-        while (stream.hasMoreInstances()){
-            streamData[i]=stream.nextInstance();
-            i++;
-        }
-         
-        for (int ri=0; ri < StrmDtSz ; ri++)
-            randIndex[ri] = ri;
- 
-        int randomIndex; // the randomly selected index each time through the loop
-        int randomValue; // the value at nums[randomIndex] each time through the loop
-        
-        //Randomize order of examples
-        if( runSeed.getValue()> 0 ){
-            for( int ri = 0; ri < randIndex.length; ++ri){
-                randomIndex = randomGenerator1.nextInt(randIndex.length);
-                randomValue = randIndex[randomIndex];
-                randIndex[randomIndex] = randIndex[ri];
-                randIndex[ri] = randomValue;
-            } 
-        }
-        
-        
-        //TRAIN  initial Model 
-        double errorAllSum=0;
-        int examplesCounter=0;
-        Example trainInst=streamData[randIndex[0]]; 
-        Example testInst= (Example) trainInst;
-        Instance inst= (Instance) testInst.getData();
-        
-        while( examplesCounter < dbInitialModelPercentage.getValue()/100*StrmDtSz ){
-        	
-            trainInst =streamData[randIndex[examplesCounter]]; 
-            testInst = (Example) trainInst;
-            inst= (Instance) testInst.getData();
-            examplesCounter++;
-            learner.trainOnInstance(trainInst);
-            
-            if(examplesCounter>1){
-                Prediction trainPrediction =learner.getTrainingPrediction();
-                double sumDenominator=0;double sumNumerator=0;
-                for( int m=0 ; m<inst.numOutputAttributes() ; m++){
-                    //sumNumerator+=Math.pow( inst.valueOutputAttribute(m) - learner.prediction.getVote(m,0) , 2 );
-                    sumNumerator+=Math.pow( inst.valueOutputAttribute(m) - trainPrediction.getVote(m,0) , 2 );
-                    sumDenominator+=Math.pow( inst.valueOutputAttribute(m) , 2 );
-                }
-                errorAllSum+=Math.sqrt(sumNumerator/sumDenominator);
-                
-                slidingWindow.add(Math.sqrt(sumNumerator/sumDenominator));
-                if(slidingWindow.size()==slidingWindowSize.getValue()+1)
-                    slidingWindow.remove(0);
-            }
-            
-            if( examplesCounter % slidingWindowStep.getValue() == 0 ){
-                //System.out.format(" %.4f" + " ",(double)errorAllSum/(double)examplesCounter);
-                double windowMean=0;
-                for(int j=0; j<slidingWindow.size() ; j++)
-                    windowMean+=slidingWindow.get(j);
-                //System.out.format(" %.4f" + "\n",windowMean/slidingWindow.size());
-            }
-        }
-
-        double [] exampleOutputs= new double[inst.numOutputAttributes()];
-
-          
-        //TEST 
-        while (examplesCounter<StrmDtSz-1) {
-            
-            trainInst =streamData[randIndex[examplesCounter]];
-            testInst = (Example) trainInst;
-            inst= (Instance) testInst.getData();
-
-            Prediction prediction = learner.getPredictionForInstance(testInst);
-            evaluator.addResult(testInst,prediction);
-
-            //Labeled or unlabeled imposition
-            if( randomGenerator2.nextDouble() <= unlabeledPercentage.getValue()/100 ){ 
-                for(int m=0; m < inst.numOutputAttributes() ; m++){
-                    inst.setClassValue(m,Double.NEGATIVE_INFINITY); //Double.NaN
-                }
-            }
-               
-            examplesCounter++;
-            learner.trainOnInstance(trainInst);
-
-            //MONITORING 
-            instancesProcessed++;
-            if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0
-                    ) {   //|| stream.hasMoreInstances() == false
-                long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-                double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);
-                double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);
-                double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); //GBs
-                RAMHoursIncrement *= (timeIncrement / 3600.0); //Hours
-                RAMHours += RAMHoursIncrement;
-                lastEvaluateStartTime = evaluateTime;
-                learningCurve.insertEntry(new LearningEvaluation(
-                        new Measurement[]{
-                            new Measurement(
-                            "learning evaluation instances",
-                            instancesProcessed),
-                            new Measurement(
-                            "evaluation time ("
-                            + (preciseCPUTiming ? "cpu "
-                            : "") + "seconds)",
-                            time),
-                            new Measurement(
-                            "model cost (RAM-Hours)",
-                            RAMHours)
-                        },
-                        evaluator, learner));
-
-                if (immediateResultStream != null) {
-                    if (firstDump) {
-                        immediateResultStream.println(learningCurve.headerToString());
-                        firstDump = false;
-                    }
-                    immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
-                    immediateResultStream.flush();
-                }
-            }
-            if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
-                if (monitor.taskShouldAbort()) {
-                    return null;
-                }
-                long estimatedRemainingInstances = stream.estimatedRemainingInstances();
-                if (maxInstances > 0) {
-                    long maxRemaining = maxInstances - instancesProcessed;
-                    if ((estimatedRemainingInstances < 0)
-                            || (maxRemaining < estimatedRemainingInstances)) {
-                        estimatedRemainingInstances = maxRemaining;
-                    }
-                }
-                monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
-                        : (double) instancesProcessed
-                        / (double) (instancesProcessed + estimatedRemainingInstances));
-                if (monitor.resultPreviewRequested()) {
-                    monitor.setLatestResultPreview(learningCurve.copy());
-                }
-                secondsElapsed = (int) TimingUtils.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread()
-                        - evaluateStartTime);
-            }
-            
-            
-        }
-
-        //|| stream.hasMoreInstances() == false
-        long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
-        double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);
-        double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);
-        double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); //GBs
-        RAMHoursIncrement *= (timeIncrement / 3600.0); //Hours
-        RAMHours += RAMHoursIncrement;
-        lastEvaluateStartTime = evaluateTime;
-        learningCurve.insertEntry(new LearningEvaluation(
-                new Measurement[]{
-                    new Measurement(
-                    "learning evaluation instances",
-                    instancesProcessed),
-                    new Measurement(
-                    "evaluation time ("
-                    + (preciseCPUTiming ? "cpu "
-                    : "") + "seconds)",
-                    time),
-                    new Measurement(
-                    "model cost (RAM-Hours)",
-                    RAMHours)
-                },
-                evaluator, learner));
-
-        if (immediateResultStream != null) {
-            if (firstDump) {
-                immediateResultStream.println(learningCurve.headerToString());
-                firstDump = false;
-            }
-            immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
-            immediateResultStream.flush();
-        }
-
-        StringBuilder sb= new StringBuilder();
-        learner.getDescription(sb, 0);
-        System.out.println(sb.toString());
-        if (immediateResultStream != null) {
-            immediateResultStream.close();
-        }
-        if (outputPredictionResultStream != null) {
-            outputPredictionResultStream.close();
-        }
-
-        return learningCurve;
-    }
-}
-
-
diff --git a/moa/src/main/java/moa/tasks/structuredoutput/multitargetregression/EvaluatePrequentialSemiSupervised.java b/moa/src/main/java/moa/tasks/structuredoutput/multitargetregression/EvaluatePrequentialSemiSupervised.java
new file mode 100644
index 000000000..e3206976a
--- /dev/null
+++ b/moa/src/main/java/moa/tasks/structuredoutput/multitargetregression/EvaluatePrequentialSemiSupervised.java
@@ -0,0 +1,382 @@
+/*
+ *    AMRulesMultiLabel.java
+ *    Copyright (C) 2017 University of Porto, Portugal
+ *    @author R. Sousa, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+package moa.tasks.structuredoutput.multitargetregression;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.PrintStream;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Random;
+
+import com.github.javacliparser.FileOption;
+import com.github.javacliparser.FloatOption;
+import com.github.javacliparser.IntOption;
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.core.Example;
+import moa.core.Measurement;
+import moa.core.ObjectRepository;
+import moa.core.TimingUtils;
+import moa.evaluation.LearningEvaluation;
+import moa.evaluation.evaluators.EWMAClassificationPerformanceEvaluator;
+import moa.evaluation.evaluators.FadingFactorClassificationPerformanceEvaluator;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
+import moa.evaluation.evaluators.MultiTargetRegressionPerformanceEvaluator;
+import moa.evaluation.evaluators.WindowClassificationPerformanceEvaluator;
+import moa.evaluation.preview.LearningCurve;
+import moa.learners.predictors.SemiSupervisedMultiTargetRegressor;
+import moa.options.ClassOption;
+import moa.streams.ExampleStream;
+import moa.streams.MultiTargetInstanceStream;
+import moa.tasks.MainTask;
+import moa.tasks.TaskMonitor;
+
+/**
+ * Multi-target Prequential semi-supervised evaluation
+ * 
+ * Phase1: Creates a initial model with <dbInitialModelPercentage> of the
+ * instances in the dataset Phase2: When an instance is received: A binary
+ * random process with a binomial distribution selects if the instance should be
+ * labeled or unlabeled with probability <unlabeledPercentage>.
+ * 
+ * @author RSousa
+ * @version $Revision: 2 $
+ */
+
+public class EvaluatePrequentialSemiSupervised extends MainTask implements MultiTargetRegressionMainTask {
+
+	@Override
+	public String getPurposeString() {
+		return "Multi-target Prequential semi-supervised evaluation \n Phase1: Creates a initial model with <dbInitialModelPercentage> of the instances in the dataset\n Phase2: When a instance is received: A binary random process with a binomial distribution selects if the instance should be  labeled or unlabeled with probability <unlabeledPercentage>.";
+	}
+
+	private static final long serialVersionUID = 1L;
+
+	public ClassOption learnerOption = new ClassOption("learner", 'l', "Learner to train.",
+			SemiSupervisedMultiTargetRegressor.class, "rules.multilabel.AMRulesMultiTargetRegressorSemiSuper");
+	public ClassOption streamOption = new ClassOption("stream", 's', "Stream to learn from.",
+			MultiTargetInstanceStream.class, "MultiTargetArffFileStream");
+	public ClassOption evaluatorOption = new ClassOption("evaluator", 'e',
+			"Classification performance evaluation method.", MultiTargetRegressionPerformanceEvaluator.class,
+			"BasicMultiTargetPerformanceEvaluator");
+	public IntOption instanceLimitOption = new IntOption("instanceLimit", 'i',
+			"Maximum number of instances to test/train on  (-1 = no limit).", 100000000, -1, Integer.MAX_VALUE);
+	public IntOption timeLimitOption = new IntOption("timeLimit", 't',
+			"Maximum number of seconds to test/train for (-1 = no limit).", -1, -1, Integer.MAX_VALUE);
+	public IntOption sampleFrequencyOption = new IntOption("sampleFrequency", 'f',
+			"How many instances between samples of the learning performance.", 100000, 0, Integer.MAX_VALUE);
+	public IntOption memCheckFrequencyOption = new IntOption("memCheckFrequency", 'q',
+			"How many instances between memory bound checks.", 100000, 0, Integer.MAX_VALUE);
+	public FileOption dumpFileOption = new FileOption("dumpFile", 'd', "File to append intermediate csv results to.",
+			null, "csv", true);
+	public FileOption outputPredictionFileOption = new FileOption("outputPredictionFile", 'o',
+			"File to append output predictions to.", null, "pred", true);
+	public IntOption widthOption = new IntOption("width", 'w', "Size of Window", 1000); // New for prequential method
+																						// DEPRECATED
+	public FloatOption alphaOption = new FloatOption("alpha", 'a', "Fading factor or exponential smoothing factor",
+			.01);
+	public FloatOption unlabeledPercentage = new FloatOption("WithoutTarget", 'z', "Without target percentage(%)", 50);
+	public FloatOption dbInitialModelPercentage = new FloatOption("DBPercent", 'D', "Initial dataset (%)", 30);
+	public IntOption runSeed = new IntOption("Seed", 'r', "Number of predictions", 1);
+	public IntOption slidingWindowSize = new IntOption("slidingWindowSize", 'W', "slidingWindowSize", 1000);
+	public IntOption slidingWindowStep = new IntOption("slidingWindowStep", 'j', "slidingWindowStep", 1);
+
+	@Override
+	public Class<?> getTaskResultType() {
+		return LearningCurve.class;
+	}
+
+	@Override
+	protected Object doMainTask(TaskMonitor monitor, ObjectRepository repository) {
+
+		SemiSupervisedMultiTargetRegressor learner = (SemiSupervisedMultiTargetRegressor) getPreparedClassOption(
+				this.learnerOption);
+		ExampleStream<Example<Instance>> stream = (ExampleStream<Example<Instance>> ) getPreparedClassOption(this.streamOption);
+		LearningPerformanceEvaluator<Example<Instance>> evaluator = (LearningPerformanceEvaluator<Example<Instance>>) getPreparedClassOption(
+				this.evaluatorOption);
+		LearningCurve learningCurve = new LearningCurve("learning evaluation instances");
+
+		// New for prequential methods
+		if (evaluator instanceof WindowClassificationPerformanceEvaluator) {
+			// ((WindowClassificationPerformanceEvaluator)
+			// evaluator).setWindowWidth(widthOption.getValue());
+			if (widthOption.getValue() != 1000) {
+				System.out
+						.println("DEPRECATED! Use EvaluatePrequential -e (WindowClassificationPerformanceEvaluator -w "
+								+ widthOption.getValue() + ")");
+				return learningCurve;
+			}
+		}
+		if (evaluator instanceof EWMAClassificationPerformanceEvaluator) {
+			// ((EWMAClassificationPerformanceEvaluator)
+			// evaluator).setalpha(alphaOption.getValue());
+			if (alphaOption.getValue() != .01) {
+				System.out.println("DEPRECATED! Use EvaluatePrequential -e (EWMAClassificationPerformanceEvaluator -a "
+						+ alphaOption.getValue() + ")");
+				return learningCurve;
+			}
+		}
+		if (evaluator instanceof FadingFactorClassificationPerformanceEvaluator) {
+			// ((FadingFactorClassificationPerformanceEvaluator)
+			// evaluator).setalpha(alphaOption.getValue());
+			if (alphaOption.getValue() != .01) {
+				System.out.println(
+						"DEPRECATED! Use EvaluatePrequential -e (FadingFactorClassificationPerformanceEvaluator -a "
+								+ alphaOption.getValue() + ")");
+				return learningCurve;
+			}
+		}
+
+		// End New for prequential methods
+		learner.setModelContext(stream.getHeader());
+		int maxInstances = this.instanceLimitOption.getValue();
+		long instancesProcessed = 0;
+		int maxSeconds = this.timeLimitOption.getValue();
+		int secondsElapsed = 0;
+		monitor.setCurrentActivity("Evaluating learner...", -1.0);
+
+		File dumpFile = this.dumpFileOption.getFile();
+		PrintStream immediateResultStream = null;
+		if (dumpFile != null) {
+			try {
+				if (dumpFile.exists()) {
+					immediateResultStream = new PrintStream(new FileOutputStream(dumpFile, true), true);
+				} else {
+					immediateResultStream = new PrintStream(new FileOutputStream(dumpFile), true);
+				}
+			} catch (Exception ex) {
+				throw new RuntimeException("Unable to open immediate result file: " + dumpFile, ex);
+			}
+		}
+
+		// File for output predictions
+		File outputPredictionFile = this.outputPredictionFileOption.getFile();
+		PrintStream outputPredictionResultStream = null;
+		if (outputPredictionFile != null) {
+			try {
+				if (outputPredictionFile.exists()) {
+					outputPredictionResultStream = new PrintStream(new FileOutputStream(outputPredictionFile, true),
+							true);
+				} else {
+					outputPredictionResultStream = new PrintStream(new FileOutputStream(outputPredictionFile), true);
+				}
+			} catch (Exception ex) {
+				throw new RuntimeException("Unable to open prediction result file: " + outputPredictionFile, ex);
+			}
+		}
+
+		boolean firstDump = true;
+		boolean preciseCPUTiming = TimingUtils.enablePreciseTiming();
+		long evaluateStartTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+		long lastEvaluateStartTime = evaluateStartTime;
+		double RAMHours = 0.0;
+
+		Random randomGenerator1 = new Random(runSeed.getValue()); // Examples scrambler
+		Random randomGenerator2 = new Random(1); // Labeled/Unlabeled selector
+		List<Double> slidingWindow = new LinkedList<>();
+
+		// Compute stream size
+		int StrmDtSz = 0;
+		while (stream.hasMoreInstances() == true) {
+			stream.nextInstance();
+			StrmDtSz++;
+		}
+
+		Example[] streamData = new Example[StrmDtSz];
+		int[] randIndex = new int[StrmDtSz];
+
+		int i = 0;
+		stream.restart();
+		while (stream.hasMoreInstances()) {
+			streamData[i] = stream.nextInstance();
+			i++;
+		}
+
+		for (int ri = 0; ri < StrmDtSz; ri++)
+			randIndex[ri] = ri;
+
+		int randomIndex; // the randomly selected index each time through the loop
+		int randomValue; // the value at nums[randomIndex] each time through the loop
+
+		// Randomize order of examples
+		if (runSeed.getValue() > 0) {
+			for (int ri = 0; ri < randIndex.length; ++ri) {
+				randomIndex = randomGenerator1.nextInt(randIndex.length);
+				randomValue = randIndex[randomIndex];
+				randIndex[randomIndex] = randIndex[ri];
+				randIndex[ri] = randomValue;
+			}
+		}
+
+		// TRAIN initial Model
+		double errorAllSum = 0;
+		int examplesCounter = 0;
+		Example trainInst = streamData[randIndex[0]];
+		Example testInst = trainInst;
+		Instance inst = (Instance) testInst.getData();
+
+		while (examplesCounter < dbInitialModelPercentage.getValue() / 100 * StrmDtSz) {
+
+			trainInst = streamData[randIndex[examplesCounter]];
+			testInst = trainInst;
+			inst = (Instance) testInst.getData();
+			examplesCounter++;
+			learner.trainOnInstance(trainInst);
+
+			if (examplesCounter > 1) {
+				Prediction trainPrediction = learner.getTrainingPrediction(inst);
+				double sumDenominator = 0;
+				double sumNumerator = 0;
+				for (int m = 0; m < inst.numOutputAttributes(); m++) {
+					// sumNumerator+=Math.pow( inst.valueOutputAttribute(m) -
+					// learner.prediction.getVote(m,0) , 2 );
+					sumNumerator += Math.pow(inst.valueOutputAttribute(m) - trainPrediction.getVote(m, 0), 2);
+					sumDenominator += Math.pow(inst.valueOutputAttribute(m), 2);
+				}
+				errorAllSum += Math.sqrt(sumNumerator / sumDenominator);
+
+				slidingWindow.add(Math.sqrt(sumNumerator / sumDenominator));
+				if (slidingWindow.size() == slidingWindowSize.getValue() + 1)
+					slidingWindow.remove(0);
+			}
+
+			if (examplesCounter % slidingWindowStep.getValue() == 0) {
+				// System.out.format(" %.4f" + " ",(double)errorAllSum/(double)examplesCounter);
+				double windowMean = 0;
+				for (int j = 0; j < slidingWindow.size(); j++)
+					windowMean += slidingWindow.get(j);
+				// System.out.format(" %.4f" + "\n",windowMean/slidingWindow.size());
+			}
+		}
+
+		double[] exampleOutputs = new double[inst.numOutputAttributes()];
+
+		// TEST
+		while (examplesCounter < StrmDtSz - 1) {
+
+			trainInst = streamData[randIndex[examplesCounter]];
+			testInst = trainInst;
+			inst = (Instance) testInst.getData();
+
+			Prediction prediction = learner.getPredictionForInstance(testInst);
+			evaluator.addResult(testInst, prediction);
+
+			// Labeled or unlabeled imposition
+			if (randomGenerator2.nextDouble() <= unlabeledPercentage.getValue() / 100) {
+				for (int m = 0; m < inst.numOutputAttributes(); m++) {
+					inst.setClassValue(m, Double.NEGATIVE_INFINITY); // Double.NaN
+				}
+			}
+
+			examplesCounter++;
+			learner.trainOnInstance(trainInst);
+
+			// MONITORING
+			instancesProcessed++;
+			if (instancesProcessed % this.sampleFrequencyOption.getValue() == 0) { // || stream.hasMoreInstances() ==
+																					// false
+				long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+				double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);
+				double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);
+				double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); // GBs
+				RAMHoursIncrement *= (timeIncrement / 3600.0); // Hours
+				RAMHours += RAMHoursIncrement;
+				lastEvaluateStartTime = evaluateTime;
+				learningCurve
+						.insertEntry(
+								new LearningEvaluation(
+										new Measurement[] {
+												new Measurement("learning evaluation instances", instancesProcessed),
+												new Measurement("evaluation time (" + (preciseCPUTiming ? "cpu " : "")
+														+ "seconds)", time),
+												new Measurement("model cost (RAM-Hours)", RAMHours) },
+										evaluator, learner));
+
+				if (immediateResultStream != null) {
+					if (firstDump) {
+						immediateResultStream.println(learningCurve.headerToString());
+						firstDump = false;
+					}
+					immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
+					immediateResultStream.flush();
+				}
+			}
+			if (instancesProcessed % INSTANCES_BETWEEN_MONITOR_UPDATES == 0) {
+				if (monitor.taskShouldAbort()) {
+					return null;
+				}
+				long estimatedRemainingInstances = stream.estimatedRemainingInstances();
+				if (maxInstances > 0) {
+					long maxRemaining = maxInstances - instancesProcessed;
+					if ((estimatedRemainingInstances < 0) || (maxRemaining < estimatedRemainingInstances)) {
+						estimatedRemainingInstances = maxRemaining;
+					}
+				}
+				monitor.setCurrentActivityFractionComplete(estimatedRemainingInstances < 0 ? -1.0
+						: (double) instancesProcessed / (double) (instancesProcessed + estimatedRemainingInstances));
+				if (monitor.resultPreviewRequested()) {
+					monitor.setLatestResultPreview(learningCurve.copy());
+				}
+				secondsElapsed = (int) TimingUtils
+						.nanoTimeToSeconds(TimingUtils.getNanoCPUTimeOfCurrentThread() - evaluateStartTime);
+			}
+
+		}
+
+		// || stream.hasMoreInstances() == false
+		long evaluateTime = TimingUtils.getNanoCPUTimeOfCurrentThread();
+		double time = TimingUtils.nanoTimeToSeconds(evaluateTime - evaluateStartTime);
+		double timeIncrement = TimingUtils.nanoTimeToSeconds(evaluateTime - lastEvaluateStartTime);
+		double RAMHoursIncrement = learner.measureByteSize() / (1024.0 * 1024.0 * 1024.0); // GBs
+		RAMHoursIncrement *= (timeIncrement / 3600.0); // Hours
+		RAMHours += RAMHoursIncrement;
+		lastEvaluateStartTime = evaluateTime;
+		learningCurve
+				.insertEntry(new LearningEvaluation(
+						new Measurement[] { new Measurement("learning evaluation instances", instancesProcessed),
+								new Measurement("evaluation time (" + (preciseCPUTiming ? "cpu " : "") + "seconds)",
+										time),
+								new Measurement("model cost (RAM-Hours)", RAMHours) },
+						evaluator, learner));
+
+		if (immediateResultStream != null) {
+			if (firstDump) {
+				immediateResultStream.println(learningCurve.headerToString());
+				firstDump = false;
+			}
+			immediateResultStream.println(learningCurve.entryToString(learningCurve.numEntries() - 1));
+			immediateResultStream.flush();
+		}
+
+		StringBuilder sb = new StringBuilder();
+		learner.getDescription(sb, 0);
+		System.out.println(sb.toString());
+		if (immediateResultStream != null) {
+			immediateResultStream.close();
+		}
+		if (outputPredictionResultStream != null) {
+			outputPredictionResultStream.close();
+		}
+
+		return learningCurve;
+	}
+}
diff --git a/moa/src/main/java/moa/tasks/structuredoutput/multitargetregression/LearnModel.java b/moa/src/main/java/moa/tasks/structuredoutput/multitargetregression/LearnModel.java
index 39a572aa9..08b08ebe7 100644
--- a/moa/src/main/java/moa/tasks/structuredoutput/multitargetregression/LearnModel.java
+++ b/moa/src/main/java/moa/tasks/structuredoutput/multitargetregression/LearnModel.java
@@ -15,11 +15,13 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 package moa.tasks.structuredoutput.multitargetregression;
 
-import moa.learners.MultiTargetRegressor;
+import moa.capabilities.Capability;
+import moa.capabilities.ImmutableCapabilities;
+import moa.learners.predictors.MultiTargetRegressor;
 import moa.options.ClassOption;
 import moa.tasks.AbstractLearnModel;
 
@@ -31,15 +33,22 @@
  */
 public class LearnModel extends AbstractLearnModel<MultiTargetRegressor> implements MultiTargetRegressionMainTask {
 
-    @Override
-    public String getPurposeString() {
-        return "Learns a multi-target regression model from a stream.";
-    }
+	@Override
+	public String getPurposeString() {
+		return "Learns a multi-target regression model from a stream.";
+	}
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public LearnModel() {
-		this.learnerOption = new ClassOption("learner", 'l', "Learner to train.", MultiTargetRegressor.class, "moa.classifiers.mtr.trees.ISOUPTree");
+	public LearnModel() {
+		this.learnerOption = new ClassOption("learner", 'l', "Learner to train.", MultiTargetRegressor.class,
+				"mtr.trees.ISOUPTree");
+	}
+	@Override
+	public ImmutableCapabilities defineImmutableCapabilities() {
+		if (this.getClass() == LearnModel.class)
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD, Capability.VIEW_LITE);
+		else
+			return new ImmutableCapabilities(Capability.VIEW_STANDARD);
 	}
-    
 }
diff --git a/moa/src/main/java/weka/classifiers/meta/MOA.java b/moa/src/main/java/weka/classifiers/meta/MOA.java
index 128428919..c83674b5a 100644
--- a/moa/src/main/java/weka/classifiers/meta/MOA.java
+++ b/moa/src/main/java/weka/classifiers/meta/MOA.java
@@ -11,7 +11,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
 /*
@@ -27,8 +27,8 @@
 import com.yahoo.labs.samoa.instances.SamoaToWekaInstanceConverter;
 import com.yahoo.labs.samoa.instances.WekaToSamoaInstanceConverter;
 
-import moa.classifiers.trees.DecisionStump;
-import moa.learners.Classifier;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.trees.DecisionStump;
 import moa.options.ClassOption;
 import weka.classifiers.UpdateableClassifier;
 import weka.core.Capabilities;
@@ -41,27 +41,33 @@
 import weka.core.Utils;
 
 /**
- <!-- globalinfo-start -->
- * Wrapper for MOA classifiers.<br/>
+ * <!-- globalinfo-start --> Wrapper for MOA classifiers.<br/>
  * <br/>
- * Since MOA doesn't offer a mechanism to query a classifier for the types of attributes and classes it can handle, the capabilities of this wrapper are hard-coded: nominal and numeric attributes and only nominal class attributes are allowed.
+ * Since MOA doesn't offer a mechanism to query a classifier for the types of
+ * attributes and classes it can handle, the capabilities of this wrapper are
+ * hard-coded: nominal and numeric attributes and only nominal class attributes
+ * are allowed.
  * <p/>
- <!-- globalinfo-end -->
+ * <!-- globalinfo-end -->
  *
- <!-- options-start -->
- * Valid options are: <p/>
+ * <!-- options-start --> Valid options are:
+ * <p/>
  *
- * <pre> -B &lt;classname + options&gt;
+ * <pre>
+ *  -B &lt;classname + options&gt;
  *  The MOA classifier to use.
- *  (default: moa.classifiers.DecisionStump)</pre>
+ *  (default: moa.learners.predictors.DecisionStump)
+ * </pre>
  *
- * <pre> -D
+ * <pre>
+ *  -D
  *  If set, classifier is run in debug mode and
- *  may output additional info to the console</pre>
+ *  may output additional info to the console
+ * </pre>
  *
- <!-- options-end -->
+ * <!-- options-end -->
  *
- * @author  fracpete (fracpete at waikato dot ac dot nz)
+ * @author fracpete (fracpete at waikato dot ac dot nz)
  * @version $Revision$
  */
 public class MOA extends weka.classifiers.AbstractClassifier implements UpdateableClassifier {
@@ -72,26 +78,25 @@ public class MOA extends weka.classifiers.AbstractClassifier implements Updateab
 	/** the actual moa classifier to use for learning. */
 	protected Classifier m_ActualClassifier = new DecisionStump();
 
-	/** the moa classifier option (this object is used in the GenericObjectEditor). */
-	protected ClassOption m_Classifier = new ClassOption(
-			"classifier", 'B', "The MOA classifier to use from within WEKA.",
-			Classifier.class, m_ActualClassifier.getClass().getName().replace("moa.classifiers.", ""),
+	/**
+	 * the moa classifier option (this object is used in the GenericObjectEditor).
+	 */
+	protected ClassOption m_Classifier = new ClassOption("classifier", 'B',
+			"The MOA classifier to use from within WEKA.", Classifier.class,
+			m_ActualClassifier.getClass().getName().replace("moa.learners.predictors.", ""),
 			m_ActualClassifier.getClass().getName());
 
-
 	protected WekaToSamoaInstanceConverter samoaConverter;
 	protected SamoaToWekaInstanceConverter wekaConverter;
 
 	/**
 	 * Returns a string describing the classifier.
 	 *
-	 * @return a description suitable for
-	 * displaying in the explorer/experimenter gui
+	 * @return a description suitable for displaying in the explorer/experimenter
+	 *         gui
 	 */
 	public String globalInfo() {
-		return
-				"Wrapper for MOA classifiers.\n\n"
-				+ "Since MOA doesn't offer a mechanism to query a classifier for the "
+		return "Wrapper for MOA classifiers.\n\n" + "Since MOA doesn't offer a mechanism to query a classifier for the "
 				+ "types of attributes and classes it can handle, the capabilities of "
 				+ "this wrapper are hard-coded: nominal and numeric attributes and "
 				+ "only nominal class attributes are allowed.";
@@ -102,13 +107,13 @@ public String globalInfo() {
 	 *
 	 * @return an enumeration of all the available options.
 	 */
+	@Override
 	public Enumeration listOptions() {
 		Vector result = new Vector();
 
 		result.addElement(new Option(
-				"\tThe MOA classifier to use.\n"
-						+ "\t(default: " + MOAUtils.toCommandLine(new DecisionStump()) + ")",
-						"B", 1, "-B <classname + options>"));
+				"\tThe MOA classifier to use.\n" + "\t(default: " + MOAUtils.toCommandLine(new DecisionStump()) + ")",
+				"B", 1, "-B <classname + options>"));
 
 		Enumeration en = super.listOptions();
 		while (en.hasMoreElements())
@@ -118,27 +123,33 @@ public Enumeration listOptions() {
 	}
 
 	/**
-	 * Parses a given list of options. <p/>
+	 * Parses a given list of options.
+	 * <p/>
 	 *
-   <!-- options-start -->
-	 * Valid options are: <p/>
+	 * <!-- options-start --> Valid options are:
+	 * <p/>
 	 *
-	 * <pre> -B &lt;classname + options&gt;
+	 * <pre>
+	 *  -B &lt;classname + options&gt;
 	 *  The MOA classifier to use.
-	 *  (default: moa.classifiers.trees.DecisionStump)</pre>
+	 *  (default: moa.learners.predictors.trees.DecisionStump)
+	 * </pre>
 	 *
-	 * <pre> -D
+	 * <pre>
+	 *  -D
 	 *  If set, classifier is run in debug mode and
-	 *  may output additional info to the console</pre>
+	 *  may output additional info to the console
+	 * </pre>
 	 *
-   <!-- options-end -->
+	 * <!-- options-end -->
 	 *
 	 * @param options the list of options as an array of strings
 	 * @throws Exception if an option is not supported
 	 */
+	@Override
 	public void setOptions(String[] options) throws Exception {
-		String        			tmpStr;
-		ClassOption					option;
+		String tmpStr;
+		ClassOption option;
 
 		tmpStr = Utils.getOption('B', options);
 		option = (ClassOption) m_Classifier.copy();
@@ -156,12 +167,13 @@ public void setOptions(String[] options) throws Exception {
 	 *
 	 * @return an array of strings suitable for passing to setOptions
 	 */
+	@Override
 	public String[] getOptions() {
-		Vector<String>	result;
-		String[]      	options;
-		int           	i;
+		Vector<String> result;
+		String[] options;
+		int i;
 
-		result = new Vector<String>();
+		result = new Vector<>();
 
 		result.add("-B");
 		result.add(MOAUtils.toCommandLine(m_ActualClassifier));
@@ -179,7 +191,7 @@ public String[] getOptions() {
 	 * @param value the classifier to use
 	 */
 	public void setClassifier(ClassOption value) {
-		m_Classifier       = value;
+		m_Classifier = value;
 		m_ActualClassifier = (Classifier) MOAUtils.fromOption(m_Classifier);
 	}
 
@@ -205,9 +217,10 @@ public String classifierTipText() {
 	 * Returns the Capabilities of this classifier. Maximally permissive
 	 * capabilities are allowed by default. MOA doesn't specify what
 	 *
-	 * @return            the capabilities of this object
-	 * @see               Capabilities
+	 * @return the capabilities of this object
+	 * @see Capabilities
 	 */
+	@Override
 	public Capabilities getCapabilities() {
 		Capabilities result = new Capabilities(this);
 
@@ -229,12 +242,11 @@ public Capabilities getCapabilities() {
 	 * Generates a classifier.
 	 *
 	 * @param data set of instances serving as training data
-	 * @throws Exception if the classifier has not been
-	 * generated successfully
+	 * @throws Exception if the classifier has not been generated successfully
 	 */
+	@Override
 	public void buildClassifier(Instances data) throws Exception {
 
-
 		this.samoaConverter = new WekaToSamoaInstanceConverter();
 		this.wekaConverter = new SamoaToWekaInstanceConverter();
 
@@ -253,29 +265,27 @@ public void buildClassifier(Instances data) throws Exception {
 	 * Updates a classifier using the given instance.
 	 *
 	 * @param instance the instance to included
-	 * @throws Exception if instance could not be incorporated
-	 * successfully
+	 * @throws Exception if instance could not be incorporated successfully
 	 */
+	@Override
 	public void updateClassifier(Instance instance) throws Exception {
 		m_ActualClassifier.trainOnInstance(samoaConverter.samoaInstance(instance));
 	}
 
 	/**
-	 * Predicts the class memberships for a given instance. If
-	 * an instance is unclassified, the returned array elements
-	 * must be all zero. If the class is numeric, the array
-	 * must consist of only one element, which contains the
+	 * Predicts the class memberships for a given instance. If an instance is
+	 * unclassified, the returned array elements must be all zero. If the class is
+	 * numeric, the array must consist of only one element, which contains the
 	 * predicted value.
 	 *
 	 * @param instance the instance to be classified
-	 * @return an array containing the estimated membership
-	 * probabilities of the test instance in each class
-	 * or the numeric prediction
-	 * @throws Exception if distribution could not be
-	 * computed successfully
+	 * @return an array containing the estimated membership probabilities of the
+	 *         test instance in each class or the numeric prediction
+	 * @throws Exception if distribution could not be computed successfully
 	 */
+	@Override
 	public double[] distributionForInstance(Instance instance) throws Exception {
-		double[]	result;
+		double[] result;
 
 		result = m_ActualClassifier.getPredictionForInstance(samoaConverter.samoaInstance(instance)).asDoubleArray();
 		// ensure that the array has as many elements as there are
@@ -288,8 +298,7 @@ public double[] distributionForInstance(Instance instance) throws Exception {
 
 		try {
 			Utils.normalize(result);
-		}
-		catch (Exception e) {
+		} catch (Exception e) {
 			result = new double[instance.numClasses()];
 		}
 
@@ -301,6 +310,7 @@ public double[] distributionForInstance(Instance instance) throws Exception {
 	 *
 	 * @return the revision
 	 */
+	@Override
 	public String getRevision() {
 		return RevisionUtils.extract("$Revision$");
 	}
@@ -310,8 +320,9 @@ public String getRevision() {
 	 *
 	 * @return the string representation
 	 */
+	@Override
 	public String toString() {
-		StringBuilder		result;
+		StringBuilder result;
 
 		result = new StringBuilder();
 		m_ActualClassifier.getDescription(result, 0);
@@ -324,7 +335,7 @@ public String toString() {
 	 *
 	 * @param args the options
 	 */
-	public static void main(String [] args) {
+	public static void main(String[] args) {
 		runClassifier(new MOA(), args);
 	}
 }
diff --git a/moa/src/main/java/weka/core/MOAUtils.java b/moa/src/main/java/weka/core/MOAUtils.java
index 45d90d4f5..9ff65e92a 100644
--- a/moa/src/main/java/weka/core/MOAUtils.java
+++ b/moa/src/main/java/weka/core/MOAUtils.java
@@ -11,7 +11,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
 /*
@@ -27,81 +27,79 @@
 
 /**
  * A helper class for MOA related classes.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
  * @version $Revision$
  */
 public class MOAUtils {
 
-  /**
-   * Turns a commandline into an object (classname + optional options).
-   * 
-   * @param option the corresponding class option
-   * @param commandline the commandline to turn into an object
-   * @return the generated oblect
-   */
-  public static MOAObject fromCommandLine(ClassOption option, String commandline) {
-  	return fromCommandLine(option.getRequiredType(), commandline);
-  }
+	/**
+	 * Turns a commandline into an object (classname + optional options).
+	 * 
+	 * @param option      the corresponding class option
+	 * @param commandline the commandline to turn into an object
+	 * @return the generated oblect
+	 */
+	public static MOAObject fromCommandLine(ClassOption option, String commandline) {
+		return fromCommandLine(option.getRequiredType(), commandline);
+	}
+
+	/**
+	 * Turns a commandline into an object (classname + optional options).
+	 * 
+	 * @param requiredType the required class
+	 * @param commandline  the commandline to turn into an object
+	 * @return the generated oblect
+	 */
+	public static MOAObject fromCommandLine(Class requiredType, String commandline) {
+		MOAObject result;
+		String[] tmpOptions;
+		String classname;
+
+		try {
+			tmpOptions = Utils.splitOptions(commandline);
+			classname = tmpOptions[0];
+			tmpOptions[0] = "";
+			try {
+				result = (MOAObject) Class.forName(classname).newInstance();
+			} catch (Exception e) {
+				// try to prepend package name
+				result = (MOAObject) Class.forName(requiredType.getPackage().getName() + "." + classname).newInstance();
+			}
+			if (result instanceof AbstractOptionHandler) {
+				((AbstractOptionHandler) result).getOptions().setViaCLIString(Utils.joinOptions(tmpOptions));
+				((AbstractOptionHandler) result).prepareForUse();
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+			result = null;
+		}
+
+		return result;
+	}
+
+	/**
+	 * Creates a MOA object from the specified class option.
+	 * 
+	 * @param option the option to build the object from
+	 * @return the created object
+	 */
+	public static MOAObject fromOption(ClassOption option) {
+		return MOAUtils.fromCommandLine(option.getRequiredType(), option.getValueAsCLIString());
+	}
 
-  /**
-   * Turns a commandline into an object (classname + optional options).
-   * 
-   * @param requiredType the required class
-   * @param commandline the commandline to turn into an object
-   * @return the generated oblect
-   */
-  public static MOAObject fromCommandLine(Class requiredType, String commandline) {
-  	MOAObject     result;
-  	String[]			tmpOptions;
-  	String				classname;
-  	
-  	try {
-  		tmpOptions    = Utils.splitOptions(commandline);
-  		classname     = tmpOptions[0];
-  		tmpOptions[0] = "";
-  		try {
-  			result = (MOAObject) Class.forName(classname).newInstance();
-  		}
-  		catch (Exception e) {
-  			// try to prepend package name
-  			result = (MOAObject) Class.forName(requiredType.getPackage().getName() + "." + classname).newInstance();
-  		}
-  		if (result instanceof AbstractOptionHandler) {
-  			((AbstractOptionHandler) result).getOptions().setViaCLIString(Utils.joinOptions(tmpOptions));
-  			((AbstractOptionHandler) result).prepareForUse();
-  		}
-  	}
-  	catch (Exception e) {
-  		e.printStackTrace();
-  		result = null;
-  	}
-  	
-  	return result;
-  }
-  
-  /**
-   * Creates a MOA object from the specified class option.
-   * 
-   * @param option the option to build the object from
-   * @return the created object
-   */
-  public static MOAObject fromOption(ClassOption option) {
-  	return MOAUtils.fromCommandLine(option.getRequiredType(), option.getValueAsCLIString());
-  }
-  
-  /**
-   * Returs the commandline for the given object. If the object is not
-   * derived from AbstractOptionHandler, then only the classname. Otherwise
-   * the classname and the options are returned.
-   * 
-   * @param obj the object to generate the commandline for
-   * @return the commandline
-   */
-  public static String toCommandLine(MOAObject obj) {
-  	String result = obj.getClass().getName();
-  	if (obj instanceof AbstractOptionHandler)
-  		result += " " + ((AbstractOptionHandler) obj).getOptions().getAsCLIString();
-  	return result.trim();
-  }
+	/**
+	 * Returs the commandline for the given object. If the object is not derived
+	 * from AbstractOptionHandler, then only the classname. Otherwise the classname
+	 * and the options are returned.
+	 * 
+	 * @param obj the object to generate the commandline for
+	 * @return the commandline
+	 */
+	public static String toCommandLine(MOAObject obj) {
+		String result = obj.getClass().getName();
+		if (obj instanceof AbstractOptionHandler)
+			result += " " + ((AbstractOptionHandler) obj).getOptions().getAsCLIString();
+		return result.trim();
+	}
 }
diff --git a/moa/src/main/java/weka/datagenerators/classifiers/classification/MOA.java b/moa/src/main/java/weka/datagenerators/classifiers/classification/MOA.java
index 76257e8e6..3cb9d0341 100644
--- a/moa/src/main/java/weka/datagenerators/classifiers/classification/MOA.java
+++ b/moa/src/main/java/weka/datagenerators/classifiers/classification/MOA.java
@@ -11,7 +11,7 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
 
 /*
@@ -41,300 +41,337 @@
 import weka.datagenerators.ClassificationGenerator;
 
 /**
- <!-- globalinfo-start -->
- * A wrapper around MOA instance streams.
+ * <!-- globalinfo-start --> A wrapper around MOA instance streams.
  * <p/>
- <!-- globalinfo-end -->
- * 
- <!-- options-start -->
- * Valid options are: <p/>
- * 
- * <pre> -h
- *  Prints this help.</pre>
+ * <!-- globalinfo-end -->
  * 
- * <pre> -o &lt;file&gt;
+ * <!-- options-start --> Valid options are:
+ * <p/>
+ *
+ * <pre>
+ *  -h
+ *  Prints this help.
+ * </pre>
+ *
+ * <pre>
+ *  -o &lt;file&gt;
  *  The name of the output file, otherwise the generated data is
- *  printed to stdout.</pre>
- * 
- * <pre> -r &lt;name&gt;
- *  The name of the relation.</pre>
- * 
- * <pre> -d
- *  Whether to print debug informations.</pre>
- * 
- * <pre> -S
- *  The seed for random function (default 1)</pre>
- * 
- * <pre> -n &lt;num&gt;
- *  The number of examples to generate (default 100)</pre>
- * 
- * <pre> -B &lt;classname + options&gt;
+ *  printed to stdout.
+ * </pre>
+ *
+ * <pre>
+ *  -r &lt;name&gt;
+ *  The name of the relation.
+ * </pre>
+ *
+ * <pre>
+ *  -d
+ *  Whether to print debug informations.
+ * </pre>
+ *
+ * <pre>
+ *  -S
+ *  The seed for random function (default 1)
+ * </pre>
+ *
+ * <pre>
+ *  -n &lt;num&gt;
+ *  The number of examples to generate (default 100)
+ * </pre>
+ *
+ * <pre>
+ *  -B &lt;classname + options&gt;
  *  The MOA stream generator.
- *  (default: moa.streams.generators.LEDGenerator)</pre>
+ *  (default: moa.streams.generators.LEDGenerator)
+ * </pre>
  * 
- <!-- options-end -->
+ * <!-- options-end -->
  *
  * @author FracPete (fracpete at waikato dot ac dot nz)
  * @version $Revision$
  */
-public class MOA
-  extends ClassificationGenerator {
-  
-  /** for serialization. */
+public class MOA extends ClassificationGenerator {
+
+	/** for serialization. */
 	private static final long serialVersionUID = 13533833825026962L;
 
 	/** the actual data generator. */
-  protected InstanceStream m_ActualGenerator = new LEDGenerator();
-
-  /** for manipulating the generator through the GUI. */
-  protected ClassOption m_Generator = new ClassOption("InstanceStream", 'B', "The MOA instance stream generator to use from within WEKA.", InstanceStream.class, m_ActualGenerator.getClass().getName());
-  
-  protected SamoaToWekaInstanceConverter instanceConverter;
-  
-  /**
-   * Returns a string describing this data generator.
-   *
-   * @return a description of the data generator suitable for
-   * displaying in the explorer/experimenter gui
-   */
-  public String globalInfo() {
-    return "A wrapper around MOA instance streams.";
-  }
-
- /**
-   * Returns an enumeration describing the available options.
-   *
-   * @return an enumeration of all the available options
-   */
-  public Enumeration listOptions() {
-    Vector result = enumToVector(super.listOptions());
-
-    result.add(new Option(
-    		"\tThe MOA stream generator.\n"
-    		+ "\t(default: " + MOAUtils.toCommandLine(new LEDGenerator()) + ")",
-    		"B", 1, "-B <classname + options>"));
-
-    return result.elements();
-  }
-
-  /**
-   * Parses a list of options for this object. <p/>
-   *
-   <!-- options-start -->
-   * Valid options are: <p/>
-   * 
-   * <pre> -h
-   *  Prints this help.</pre>
-   * 
-   * <pre> -o &lt;file&gt;
-   *  The name of the output file, otherwise the generated data is
-   *  printed to stdout.</pre>
-   * 
-   * <pre> -r &lt;name&gt;
-   *  The name of the relation.</pre>
-   * 
-   * <pre> -d
-   *  Whether to print debug informations.</pre>
-   * 
-   * <pre> -S
-   *  The seed for random function (default 1)</pre>
-   * 
-   * <pre> -n &lt;num&gt;
-   *  The number of examples to generate (default 100)</pre>
-   * 
-   * <pre> -B &lt;classname + options&gt;
-   *  The MOA stream generator.
-   *  (default: moa.streams.generators.LEDGenerator)</pre>
-   * 
-   <!-- options-end -->
-   *
-   * @param options the list of options as an array of strings
-   * @throws Exception if an option is not supported
-   */
-  public void setOptions(String[] options) throws Exception {
-    String        			tmpStr;
-    ClassOption					option;
-
-    tmpStr = Utils.getOption('B', options);
-    option = (ClassOption) m_Generator.copy();
-    if (tmpStr.length() == 0)
-    	option.setCurrentObject(new LEDGenerator());
-    else
-    	option.setCurrentObject(MOAUtils.fromCommandLine(m_Generator, tmpStr));
-    setGenerator(option);
-    
-    super.setOptions(options);
-  }
-
-  /**
-   * Gets the current settings of the datagenerator.
-   *
-   * @return an array of strings suitable for passing to setOptions
-   */
-  public String[] getOptions() {
-    Vector<String>	result;
-    String[]      	options;
-    int           	i;
-    
-    result = new Vector<String>();
-
-    result.add("-B");
-    result.add(MOAUtils.toCommandLine(m_ActualGenerator));
-    
-    options = super.getOptions();
-    for (i = 0; i < options.length; i++)
-      result.add(options[i]);
-    
-    return result.toArray(new String[result.size()]);
-  }
-  
-  /**
-   * Sets the MOA stream generator to use.
-   * 
-   * @param value the stream generator to use
-   */
-  public void setGenerator(ClassOption value) {
-  	m_Generator       = value;
-  	m_ActualGenerator = (InstanceStream) MOAUtils.fromOption(m_Generator);
-  }
-  
-  /**
-   * Returns the current MOA stream generator in use.
-   * 
-   * @return the stream generator in use
-   */
-  public ClassOption getGenerator() {
-  	return m_Generator;
-  }
-  
-  /**
-   * Returns the tooltip displayed in the GUI.
-   * 
-   * @return the tooltip
-   */
-  public String generatorTipText() {
-  	return "The MOA stream generator to use.";
-  }
-
-  /**
-   * Return if single mode is set for the given data generator
-   * mode depends on option setting and or generator type.
-   * 
-   * @return single mode flag, always true
-   * @throws Exception if mode is not set yet
-   */
-  public boolean getSingleModeFlag() throws Exception {
-    return true;
-  }
-
-  /**
-   * Initializes the format for the dataset produced. 
-   *
-   * @return the format for the dataset 
-   * @throws Exception if the generating of the format failed
-   */
-  public Instances defineDataFormat() throws Exception {
-  	int		numExamples;
-  	
-  	m_ActualGenerator = (InstanceStream) MOAUtils.fromOption(m_Generator);
-  	((AbstractOptionHandler) m_ActualGenerator).prepareForUse();
-     this.instanceConverter = new SamoaToWekaInstanceConverter();   
-    m_DatasetFormat = new Instances(instanceConverter.wekaInstances(m_ActualGenerator.getHeader()));
-
-    // determine number of instances to generate
-    numExamples = getNumExamples();
-    if (m_ActualGenerator.estimatedRemainingInstances() != -1) {
-    	if (m_ActualGenerator.estimatedRemainingInstances() < numExamples)
-    		numExamples = (int) m_ActualGenerator.estimatedRemainingInstances();
-    }
-    setNumExamplesAct(numExamples);
-    
-    return m_DatasetFormat;
-  }
-
-  /**
-   * Generates one example of the dataset. 
-   *
-   * @return the generated example, null if no further example available
-   * @throws Exception if the format of the dataset is not yet defined
-   * @throws Exception if the generator only works with generateExamples
-   * which means in non single mode
-   */
-  public Instance generateExample() throws Exception {
-  	if (m_ActualGenerator.hasMoreInstances()) {
-  		return instanceConverter.wekaInstance(m_ActualGenerator.nextInstance().getData());
-        } else {
-  		return null;
-  }
-  }
-
-  /**
-   * Generates all examples of the dataset. Re-initializes the random number
-   * generator with the given seed, before generating instances.
-   *
-   * @return the generated dataset
-   * @throws Exception if the format of the dataset is not yet defined
-   * @throws Exception if the generator only works with generateExample,
-   * which means in single mode
-   * @see   #getSeed()
-   */
-  public Instances generateExamples() throws Exception {
-    Instances       result;
-    Instance				inst;
-    int             i;
-
-    result   = new Instances(m_DatasetFormat, 0);
-    m_Random = new Random(getSeed());
-
-    for (i = 0; i < getNumExamplesAct(); i++) {
-    	inst = generateExample();
-    	if (inst != null)
-    		result.add(inst);
-    	else
-    		break;
-    }
-    
-    return result;
-  }
-
-  /**
-   * Generates a comment string that documentates the data generator.
-   * By default this string is added at the beginning of the produced output
-   * as ARFF file type, next after the options.
-   * 
-   * @return string contains info about the generated rules
-   */
-  public String generateStart () {
-    return "";
-  }
-
-  /**
-   * Generates a comment string that documentats the data generator.
-   * By default this string is added at the end of theproduces output
-   * as ARFF file type.
-   * 
-   * @return string contains info about the generated rules
-   * @throws Exception if the generating of the documentaion fails
-   */
-  public String generateFinished() throws Exception {
-    return "";
-  }
-  
-  /**
-   * Returns the revision string.
-   * 
-   * @return		the revision
-   */
-  public String getRevision() {
-    return RevisionUtils.extract("$Revision$");
-  }
-
-  /**
-   * Main method for executing this class.
-   *
-   * @param args should contain arguments for the data producer: 
-   */
-  public static void main(String[] args) {
-    runDataGenerator(new MOA(), args);
-  }
+	protected InstanceStream m_ActualGenerator = new LEDGenerator();
+
+	/** for manipulating the generator through the GUI. */
+	protected ClassOption m_Generator = new ClassOption("InstanceStream", 'B',
+			"The MOA instance stream generator to use from within WEKA.", InstanceStream.class,
+			m_ActualGenerator.getClass().getName());
+
+	protected SamoaToWekaInstanceConverter instanceConverter;
+
+	/**
+	 * Returns a string describing this data generator.
+	 *
+	 * @return a description of the data generator suitable for displaying in the
+	 *         explorer/experimenter gui
+	 */
+	public String globalInfo() {
+		return "A wrapper around MOA instance streams.";
+	}
+
+	/**
+	 * Returns an enumeration describing the available options.
+	 *
+	 * @return an enumeration of all the available options
+	 */
+	@Override
+	public Enumeration listOptions() {
+		Vector result = enumToVector(super.listOptions());
+
+		result.add(new Option(
+				"\tThe MOA stream generator.\n" + "\t(default: " + MOAUtils.toCommandLine(new LEDGenerator()) + ")",
+				"B", 1, "-B <classname + options>"));
+
+		return result.elements();
+	}
+
+	/**
+	 * Parses a list of options for this object.
+	 * <p/>
+	 *
+	 * <!-- options-start --> Valid options are:
+	 * <p/>
+	 * 
+	 * <pre>
+	 *  -h
+	 *  Prints this help.
+	 * </pre>
+	 * 
+	 * <pre>
+	 *  -o &lt;file&gt;
+	 *  The name of the output file, otherwise the generated data is
+	 *  printed to stdout.
+	 * </pre>
+	 * 
+	 * <pre>
+	 *  -r &lt;name&gt;
+	 *  The name of the relation.
+	 * </pre>
+	 * 
+	 * <pre>
+	 *  -d
+	 *  Whether to print debug informations.
+	 * </pre>
+	 * 
+	 * <pre>
+	 *  -S
+	 *  The seed for random function (default 1)
+	 * </pre>
+	 * 
+	 * <pre>
+	 *  -n &lt;num&gt;
+	 *  The number of examples to generate (default 100)
+	 * </pre>
+	 * 
+	 * <pre>
+	 *  -B &lt;classname + options&gt;
+	 *  The MOA stream generator.
+	 *  (default: moa.streams.generators.LEDGenerator)
+	 * </pre>
+	 * 
+	 * <!-- options-end -->
+	 *
+	 * @param options the list of options as an array of strings
+	 * @throws Exception if an option is not supported
+	 */
+	@Override
+	public void setOptions(String[] options) throws Exception {
+		String tmpStr;
+		ClassOption option;
+
+		tmpStr = Utils.getOption('B', options);
+		option = (ClassOption) m_Generator.copy();
+		if (tmpStr.length() == 0)
+			option.setCurrentObject(new LEDGenerator());
+		else
+			option.setCurrentObject(MOAUtils.fromCommandLine(m_Generator, tmpStr));
+		setGenerator(option);
+
+		super.setOptions(options);
+	}
+
+	/**
+	 * Gets the current settings of the datagenerator.
+	 *
+	 * @return an array of strings suitable for passing to setOptions
+	 */
+	@Override
+	public String[] getOptions() {
+		Vector<String> result;
+		String[] options;
+		int i;
+
+		result = new Vector<>();
+
+		result.add("-B");
+		result.add(MOAUtils.toCommandLine(m_ActualGenerator));
+
+		options = super.getOptions();
+		for (i = 0; i < options.length; i++)
+			result.add(options[i]);
+
+		return result.toArray(new String[result.size()]);
+	}
+
+	/**
+	 * Sets the MOA stream generator to use.
+	 * 
+	 * @param value the stream generator to use
+	 */
+	public void setGenerator(ClassOption value) {
+		m_Generator = value;
+		m_ActualGenerator = (InstanceStream) MOAUtils.fromOption(m_Generator);
+	}
+
+	/**
+	 * Returns the current MOA stream generator in use.
+	 * 
+	 * @return the stream generator in use
+	 */
+	public ClassOption getGenerator() {
+		return m_Generator;
+	}
+
+	/**
+	 * Returns the tooltip displayed in the GUI.
+	 * 
+	 * @return the tooltip
+	 */
+	public String generatorTipText() {
+		return "The MOA stream generator to use.";
+	}
+
+	/**
+	 * Return if single mode is set for the given data generator mode depends on
+	 * option setting and or generator type.
+	 * 
+	 * @return single mode flag, always true
+	 * @throws Exception if mode is not set yet
+	 */
+	@Override
+	public boolean getSingleModeFlag() throws Exception {
+		return true;
+	}
+
+	/**
+	 * Initializes the format for the dataset produced.
+	 *
+	 * @return the format for the dataset
+	 * @throws Exception if the generating of the format failed
+	 */
+	@Override
+	public Instances defineDataFormat() throws Exception {
+		int numExamples;
+
+		m_ActualGenerator = (InstanceStream) MOAUtils.fromOption(m_Generator);
+		((AbstractOptionHandler) m_ActualGenerator).prepareForUse();
+		this.instanceConverter = new SamoaToWekaInstanceConverter();
+		m_DatasetFormat = new Instances(instanceConverter.wekaInstances(m_ActualGenerator.getHeader()));
+
+		// determine number of instances to generate
+		numExamples = getNumExamples();
+		if (m_ActualGenerator.estimatedRemainingInstances() != -1) {
+			if (m_ActualGenerator.estimatedRemainingInstances() < numExamples)
+				numExamples = (int) m_ActualGenerator.estimatedRemainingInstances();
+		}
+		setNumExamplesAct(numExamples);
+
+		return m_DatasetFormat;
+	}
+
+	/**
+	 * Generates one example of the dataset.
+	 *
+	 * @return the generated example, null if no further example available
+	 * @throws Exception if the format of the dataset is not yet defined
+	 * @throws Exception if the generator only works with generateExamples which
+	 *                   means in non single mode
+	 */
+	@Override
+	public Instance generateExample() throws Exception {
+		if (m_ActualGenerator.hasMoreInstances()) {
+			return instanceConverter.wekaInstance(m_ActualGenerator.nextInstance().getData());
+		} else {
+			return null;
+		}
+	}
+
+	/**
+	 * Generates all examples of the dataset. Re-initializes the random number
+	 * generator with the given seed, before generating instances.
+	 *
+	 * @return the generated dataset
+	 * @throws Exception if the format of the dataset is not yet defined
+	 * @throws Exception if the generator only works with generateExample, which
+	 *                   means in single mode
+	 * @see #getSeed()
+	 */
+	@Override
+	public Instances generateExamples() throws Exception {
+		Instances result;
+		Instance inst;
+		int i;
+
+		result = new Instances(m_DatasetFormat, 0);
+		m_Random = new Random(getSeed());
+
+		for (i = 0; i < getNumExamplesAct(); i++) {
+			inst = generateExample();
+			if (inst != null)
+				result.add(inst);
+			else
+				break;
+		}
+
+		return result;
+	}
+
+	/**
+	 * Generates a comment string that documentates the data generator. By default
+	 * this string is added at the beginning of the produced output as ARFF file
+	 * type, next after the options.
+	 * 
+	 * @return string contains info about the generated rules
+	 */
+	@Override
+	public String generateStart() {
+		return "";
+	}
+
+	/**
+	 * Generates a comment string that documentats the data generator. By default
+	 * this string is added at the end of theproduces output as ARFF file type.
+	 * 
+	 * @return string contains info about the generated rules
+	 * @throws Exception if the generating of the documentaion fails
+	 */
+	@Override
+	public String generateFinished() throws Exception {
+		return "";
+	}
+
+	/**
+	 * Returns the revision string.
+	 * 
+	 * @return the revision
+	 */
+	@Override
+	public String getRevision() {
+		return RevisionUtils.extract("$Revision$");
+	}
+
+	/**
+	 * Main method for executing this class.
+	 *
+	 * @param args should contain arguments for the data producer:
+	 */
+	public static void main(String[] args) {
+		runDataGenerator(new MOA(), args);
+	}
 }
diff --git a/moa/src/main/java/weka/gui/MOAClassOptionEditor.java b/moa/src/main/java/weka/gui/MOAClassOptionEditor.java
index 029f0f025..ebaaab2e9 100644
--- a/moa/src/main/java/weka/gui/MOAClassOptionEditor.java
+++ b/moa/src/main/java/weka/gui/MOAClassOptionEditor.java
@@ -33,8 +33,7 @@
  * @version $Revision$
  * @see ClassOption
  */
-public class MOAClassOptionEditor
-  extends PropertyEditorSupport {
+public class MOAClassOptionEditor extends PropertyEditorSupport {
 
 	/** the custom editor. */
 	protected Component m_CustomEditor;
@@ -45,8 +44,9 @@ public class MOAClassOptionEditor
 	/**
 	 * Returns true since this editor is paintable.
 	 *
-	 * @return 		always true.
+	 * @return always true.
 	 */
+	@Override
 	public boolean isPaintable() {
 		return false;
 	}
@@ -54,8 +54,9 @@ public boolean isPaintable() {
 	/**
 	 * Returns true because we do support a custom editor.
 	 *
-	 * @return 		always true
+	 * @return always true
 	 */
+	@Override
 	public boolean supportsCustomEditor() {
 		return true;
 	}
@@ -74,15 +75,16 @@ protected void closeDialog() {
 	/**
 	 * Creates the custom editor.
 	 *
-	 * @return		the editor
+	 * @return the editor
 	 */
 	protected Component createCustomEditor() {
-		JPanel			panel;
+		JPanel panel;
 
 		panel = new JPanel(new BorderLayout());
 		panel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
 		m_EditComponent = (ClassOptionEditComponent) getEditComponent((ClassOption) getValue());
 		m_EditComponent.addChangeListener(new ChangeListener() {
+			@Override
 			public void stateChanged(ChangeEvent e) {
 				m_EditComponent.applyState();
 				setValue(m_EditComponent.getEditedOption());
@@ -93,15 +95,16 @@ public void stateChanged(ChangeEvent e) {
 		return panel;
 	}
 
-        public JComponent getEditComponent(Option option){
-             return OptionsConfigurationPanel.getEditComponent(option);
-        }
+	public JComponent getEditComponent(Option option) {
+		return OptionsConfigurationPanel.getEditComponent(option);
+	}
 
 	/**
 	 * Gets the custom editor component.
 	 *
-	 * @return 		the editor
+	 * @return the editor
 	 */
+	@Override
 	public Component getCustomEditor() {
 		if (m_CustomEditor == null)
 			m_CustomEditor = createCustomEditor();
@@ -109,20 +112,21 @@ public Component getCustomEditor() {
 		return m_CustomEditor;
 	}
 
-  /**
-   * Paints a representation of the current Object.
-   *
-   * @param gfx 	the graphics context to use
-   * @param box 	the area we are allowed to paint into
-   */
-  public void paintValue(Graphics gfx, Rectangle box) {
-    FontMetrics 	fm;
-    int 					vpad;
-    String 				val;
-
-    fm   = gfx.getFontMetrics();
-    vpad = (box.height - fm.getHeight()) / 2 ;
-    val  = ((ClassOption) getValue()).getValueAsCLIString();
-    gfx.drawString(val, 2, fm.getHeight() + vpad);
-  }
+	/**
+	 * Paints a representation of the current Object.
+	 *
+	 * @param gfx the graphics context to use
+	 * @param box the area we are allowed to paint into
+	 */
+	@Override
+	public void paintValue(Graphics gfx, Rectangle box) {
+		FontMetrics fm;
+		int vpad;
+		String val;
+
+		fm = gfx.getFontMetrics();
+		vpad = (box.height - fm.getHeight()) / 2;
+		val = ((ClassOption) getValue()).getValueAsCLIString();
+		gfx.drawString(val, 2, fm.getHeight() + vpad);
+	}
 }
diff --git a/moa/src/main/resources/moa/gui/clustertab/ClusteringSetupTab.form b/moa/src/main/resources/moa/gui/clustertab/ClusteringSetupTab.form
index 36879ac25..04c8df4ec 100644
--- a/moa/src/main/resources/moa/gui/clustertab/ClusteringSetupTab.form
+++ b/moa/src/main/resources/moa/gui/clustertab/ClusteringSetupTab.form
@@ -16,7 +16,7 @@
 
   <Layout class="org.netbeans.modules.form.compat2.layouts.DesignGridBagLayout"/>
   <SubComponents>
-    <Component class="moa.gui.clustertab.ClusteringAlgoPanel" name="clusteringAlgoPanel0">
+    <Component class=gui.clustertab.ClusteringAlgoPanel" name="clusteringAlgoPanel0">
       <Properties>
         <Property name="minimumSize" type="java.awt.Dimension" editor="org.netbeans.beaninfo.editors.DimensionEditor">
           <Dimension value="[335, 150]"/>
@@ -32,7 +32,7 @@
         </Constraint>
       </Constraints>
     </Component>
-    <Component class="moa.gui.clustertab.ClusteringEvalPanel" name="clusteringEvalPanel1">
+    <Component class=gui.clustertab.ClusteringEvalPanel" name="clusteringEvalPanel1">
       <Constraints>
         <Constraint layoutClass="org.netbeans.modules.form.compat2.layouts.DesignGridBagLayout" value="org.netbeans.modules.form.compat2.layouts.DesignGridBagLayout$GridBagConstraintsDescription">
           <GridBagConstraints gridX="4" gridY="0" gridWidth="2" gridHeight="4" fill="1" ipadX="0" ipadY="0" insetsTop="4" insetsLeft="4" insetsBottom="4" insetsRight="4" anchor="18" weightX="0.0" weightY="0.0"/>
@@ -117,7 +117,7 @@
         </Constraint>
       </Constraints>
     </Component>
-    <Component class="moa.gui.TextViewerPanel" name="logPanel">
+    <Component class=gui.TextViewerPanel" name="logPanel">
       <Constraints>
         <Constraint layoutClass="org.netbeans.modules.form.compat2.layouts.DesignGridBagLayout" value="org.netbeans.modules.form.compat2.layouts.DesignGridBagLayout$GridBagConstraintsDescription">
           <GridBagConstraints gridX="0" gridY="5" gridWidth="7" gridHeight="1" fill="1" ipadX="0" ipadY="0" insetsTop="4" insetsLeft="4" insetsBottom="4" insetsRight="4" anchor="10" weightX="1.0" weightY="1.0"/>
diff --git a/moa/src/main/resources/moa/gui/clustertab/ClusteringTabPanel.form b/moa/src/main/resources/moa/gui/clustertab/ClusteringTabPanel.form
index e97f7ead5..d3f618767 100644
--- a/moa/src/main/resources/moa/gui/clustertab/ClusteringTabPanel.form
+++ b/moa/src/main/resources/moa/gui/clustertab/ClusteringTabPanel.form
@@ -29,7 +29,7 @@
 
       <Layout class="org.netbeans.modules.form.compat2.layouts.support.JTabbedPaneSupportLayout"/>
       <SubComponents>
-        <Component class="moa.gui.clustertab.ClusteringSetupTab" name="clusteringSetupTab">
+        <Component class=gui.clustertab.ClusteringSetupTab" name="clusteringSetupTab">
           <Constraints>
             <Constraint layoutClass="org.netbeans.modules.form.compat2.layouts.support.JTabbedPaneSupportLayout" value="org.netbeans.modules.form.compat2.layouts.support.JTabbedPaneSupportLayout$JTabbedPaneConstraintsDescription">
               <JTabbedPaneConstraints tabName="Setup">
@@ -38,7 +38,7 @@
             </Constraint>
           </Constraints>
         </Component>
-        <Component class="moa.gui.clustertab.ClusteringVisualTab" name="clusteringVisualTab">
+        <Component class=gui.clustertab.ClusteringVisualTab" name="clusteringVisualTab">
           <Constraints>
             <Constraint layoutClass="org.netbeans.modules.form.compat2.layouts.support.JTabbedPaneSupportLayout" value="org.netbeans.modules.form.compat2.layouts.support.JTabbedPaneSupportLayout$JTabbedPaneConstraintsDescription">
               <JTabbedPaneConstraints tabName="Visualization">
diff --git a/moa/src/main/resources/moa/gui/clustertab/ClusteringVisualTab.form b/moa/src/main/resources/moa/gui/clustertab/ClusteringVisualTab.form
index e1a16ca0f..d34313105 100644
--- a/moa/src/main/resources/moa/gui/clustertab/ClusteringVisualTab.form
+++ b/moa/src/main/resources/moa/gui/clustertab/ClusteringVisualTab.form
@@ -81,7 +81,7 @@
 
                       <Layout class="org.netbeans.modules.form.compat2.layouts.support.JScrollPaneSupportLayout"/>
                       <SubComponents>
-                        <Container class="moa.gui.visualization.StreamPanel" name="streamPanel1">
+                        <Container class=gui.visualization.StreamPanel" name="streamPanel1">
                           <Properties>
                             <Property name="preferredSize" type="java.awt.Dimension" editor="org.netbeans.beaninfo.editors.DimensionEditor">
                               <Dimension value="[400, 250]"/>
@@ -115,7 +115,7 @@
 
                       <Layout class="org.netbeans.modules.form.compat2.layouts.support.JScrollPaneSupportLayout"/>
                       <SubComponents>
-                        <Container class="moa.gui.visualization.StreamPanel" name="streamPanel0">
+                        <Container class=gui.visualization.StreamPanel" name="streamPanel0">
                           <Properties>
                             <Property name="preferredSize" type="java.awt.Dimension" editor="org.netbeans.beaninfo.editors.DimensionEditor">
                               <Dimension value="[400, 250]"/>
@@ -427,7 +427,7 @@
 
           <Layout class="org.netbeans.modules.form.compat2.layouts.DesignGridBagLayout"/>
           <SubComponents>
-            <Component class="moa.gui.clustertab.ClusteringVisualEvalPanel" name="clusteringVisualEvalPanel1">
+            <Component class=gui.clustertab.ClusteringVisualEvalPanel" name="clusteringVisualEvalPanel1">
               <Properties>
                 <Property name="minimumSize" type="java.awt.Dimension" editor="org.netbeans.beaninfo.editors.DimensionEditor">
                   <Dimension value="[280, 118]"/>
@@ -517,7 +517,7 @@
 
                   <Layout class="org.netbeans.modules.form.compat2.layouts.support.JScrollPaneSupportLayout"/>
                   <SubComponents>
-                    <Container class="moa.gui.visualization.GraphCanvas" name="graphCanvas">
+                    <Container class=gui.visualization.GraphCanvas" name="graphCanvas">
                       <Properties>
                         <Property name="preferredSize" type="java.awt.Dimension" editor="org.netbeans.beaninfo.editors.DimensionEditor">
                           <Dimension value="[500, 111]"/>
diff --git a/moa/src/test/java/com/yahoo/labs/samoa/instances/ArffLoaderAttributeSelectionTest.java b/moa/src/test/java/com/yahoo/labs/samoa/instances/ArffLoaderAttributeSelectionTest.java
index 43e5653b8..8af76ce63 100644
--- a/moa/src/test/java/com/yahoo/labs/samoa/instances/ArffLoaderAttributeSelectionTest.java
+++ b/moa/src/test/java/com/yahoo/labs/samoa/instances/ArffLoaderAttributeSelectionTest.java
@@ -30,20 +30,21 @@ public static void setUpBeforeClass() throws Exception {
 			InputStream fileStream;
 			Reader reader;
 
-			fileStream = new FileInputStream(ClassLoader.getSystemResource("moa/classifiers/data/small_regression.arff").getPath());
+			fileStream = new FileInputStream(
+					ClassLoader.getSystemResource("moa/learners/predictors/data/small_regression.arff").getPath());
 			reader = new BufferedReader(new InputStreamReader(fileStream));
 			instancesHeader = new InstancesHeader(reader, "4-5", "2,3,8");
 		} catch (IOException ioe) {
 			throw new RuntimeException("ArffFileStream restart failed.", ioe);
 		}
 	}
-	
+
 	@Test
 	public void testHeaderAttributeSelection() {
 		// check number of attributes
 		assertEquals(3, instancesHeader.arff.instanceInformation.numInputAttributes());
 		assertEquals(2, instancesHeader.arff.instanceInformation.numOutputAttributes());
-		
+
 		// check attribute types for each position
 		assertTrue(instancesHeader.arff.instanceInformation.attribute(0).isNumeric());
 		assertTrue(instancesHeader.arff.instanceInformation.attribute(1).isNominal());
@@ -57,8 +58,8 @@ public void testHeaderAttributeSelection() {
 		assertTrue(instancesHeader.arff.instanceInformation.attribute(2).name.equals("R1"));
 		assertTrue(instancesHeader.arff.instanceInformation.attribute(3).name.equals("R2"));
 		assertTrue(instancesHeader.arff.instanceInformation.attribute(4).name.equals("N2"));
-		
-		//check class index
+
+		// check class index
 	}
 
 	@Test
@@ -66,7 +67,7 @@ public void testInstancesAttributeSelection() {
 		// ---------------------- instance 1 ----------------------
 		Instance instance = instancesHeader.arff.readInstance();
 		instance.setDataset(instancesHeader);
-		
+
 		// check attributes
 		assertEquals(-2.3, instance.value(0), EPS);
 		assertEquals(2, instance.value(1), EPS);
@@ -98,7 +99,7 @@ public void testInstancesAttributeSelection() {
 		assertEquals(-2.2, instance.valueInputAttribute(0), EPS);
 		assertEquals(0, instance.valueInputAttribute(1), EPS);
 		assertEquals(0, instance.valueInputAttribute(2), EPS);
-		
+
 		// check output values
 		assertEquals(3, instance.valueOutputAttribute(0), EPS);
 		assertEquals(1, instance.valueOutputAttribute(1), EPS);
diff --git a/moa/src/test/java/com/yahoo/labs/samoa/instances/ArffLoaderClassificationTest.java b/moa/src/test/java/com/yahoo/labs/samoa/instances/ArffLoaderClassificationTest.java
index 0e4e185f3..834014db1 100644
--- a/moa/src/test/java/com/yahoo/labs/samoa/instances/ArffLoaderClassificationTest.java
+++ b/moa/src/test/java/com/yahoo/labs/samoa/instances/ArffLoaderClassificationTest.java
@@ -30,7 +30,8 @@ public static void setUpBeforeClass() throws Exception {
 			InputStream fileStream;
 			Reader reader;
 
-			fileStream = new FileInputStream(ClassLoader.getSystemResource("moa/classifiers/data/small_classification.arff").getPath());
+			fileStream = new FileInputStream(
+					ClassLoader.getSystemResource("moa/learners/predictors/data/small_classification.arff").getPath());
 			reader = new BufferedReader(new InputStreamReader(fileStream));
 			instancesHeader = new InstancesHeader(reader, "1");
 		} catch (IOException ioe) {
diff --git a/moa/src/test/java/com/yahoo/labs/samoa/instances/ArffLoaderMultiLabelClassificationTest.java b/moa/src/test/java/com/yahoo/labs/samoa/instances/ArffLoaderMultiLabelClassificationTest.java
index d84d4380c..8ed422e02 100644
--- a/moa/src/test/java/com/yahoo/labs/samoa/instances/ArffLoaderMultiLabelClassificationTest.java
+++ b/moa/src/test/java/com/yahoo/labs/samoa/instances/ArffLoaderMultiLabelClassificationTest.java
@@ -30,7 +30,8 @@ public static void setUpBeforeClass() throws Exception {
 			InputStream fileStream;
 			Reader reader;
 
-			fileStream = new FileInputStream(ClassLoader.getSystemResource("moa/classifiers/data/small_classification.arff").getPath());
+			fileStream = new FileInputStream(
+					ClassLoader.getSystemResource("moa/learners/predictors/data/small_classification.arff").getPath());
 			reader = new BufferedReader(new InputStreamReader(fileStream));
 			instancesHeader = new InstancesHeader(reader, "1,2");
 		} catch (IOException ioe) {
@@ -43,7 +44,7 @@ public void testHeaderMultiLabelClassification() {
 		// check number of attributes
 		assertEquals(4, instancesHeader.arff.instanceInformation.numInputAttributes());
 		assertEquals(2, instancesHeader.arff.instanceInformation.numOutputAttributes());
-		
+
 		// check attribute types for each position
 		assertTrue(instancesHeader.arff.instanceInformation.attribute(0).isNominal());
 		assertTrue(instancesHeader.arff.instanceInformation.attribute(1).isNominal());
diff --git a/moa/src/test/java/com/yahoo/labs/samoa/instances/ArffLoaderMultiTargetRegressionTest.java b/moa/src/test/java/com/yahoo/labs/samoa/instances/ArffLoaderMultiTargetRegressionTest.java
index 3dc4b6b0e..a1265184e 100644
--- a/moa/src/test/java/com/yahoo/labs/samoa/instances/ArffLoaderMultiTargetRegressionTest.java
+++ b/moa/src/test/java/com/yahoo/labs/samoa/instances/ArffLoaderMultiTargetRegressionTest.java
@@ -30,20 +30,21 @@ public static void setUpBeforeClass() throws Exception {
 			InputStream fileStream;
 			Reader reader;
 
-			fileStream = new FileInputStream(ClassLoader.getSystemResource("moa/classifiers/data/small_regression.arff").getPath());
+			fileStream = new FileInputStream(
+					ClassLoader.getSystemResource("moa/learners/predictors/data/small_regression.arff").getPath());
 			reader = new BufferedReader(new InputStreamReader(fileStream));
 			instancesHeader = new InstancesHeader(reader, "4-6");
 		} catch (IOException ioe) {
 			throw new RuntimeException("ArffFileStream restart failed.", ioe);
 		}
 	}
-	
+
 	@Test
 	public void testHeaderMultiTargetRegression() {
 		// check number of attributes
 		assertEquals(5, instancesHeader.arff.instanceInformation.numInputAttributes());
 		assertEquals(3, instancesHeader.arff.instanceInformation.numOutputAttributes());
-		
+
 		// check attribute types for each position
 		assertTrue(instancesHeader.arff.instanceInformation.attribute(0).isNumeric());
 		assertTrue(instancesHeader.arff.instanceInformation.attribute(1).isNumeric());
@@ -63,8 +64,8 @@ public void testHeaderMultiTargetRegression() {
 		assertTrue(instancesHeader.arff.instanceInformation.attribute(5).name.equals("R3"));
 		assertTrue(instancesHeader.arff.instanceInformation.attribute(6).name.equals("F3"));
 		assertTrue(instancesHeader.arff.instanceInformation.attribute(7).name.equals("N2"));
-		
-		//check class index
+
+		// check class index
 	}
 
 	@Test
@@ -72,7 +73,7 @@ public void testInstancesMultiTargetRegression() {
 		// ---------------------- instance 1 ----------------------
 		Instance instance = instancesHeader.arff.readInstance();
 		instance.setDataset(instancesHeader);
-		
+
 		// check attributes
 		assertEquals(1.1, instance.value(0), EPS);
 		assertEquals(-2.3, instance.value(1), EPS);
@@ -115,7 +116,7 @@ public void testInstancesMultiTargetRegression() {
 		assertEquals(0, instance.valueInputAttribute(2), EPS);
 		assertEquals(3.2, instance.valueInputAttribute(3), EPS);
 		assertEquals(0, instance.valueInputAttribute(4), EPS);
-		
+
 		// check output values
 		assertEquals(3, instance.valueOutputAttribute(0), EPS);
 		assertEquals(1, instance.valueOutputAttribute(1), EPS);
diff --git a/moa/src/test/java/com/yahoo/labs/samoa/instances/ArffLoaderRegressionTest.java b/moa/src/test/java/com/yahoo/labs/samoa/instances/ArffLoaderRegressionTest.java
index 30623e58d..2bd6ce677 100644
--- a/moa/src/test/java/com/yahoo/labs/samoa/instances/ArffLoaderRegressionTest.java
+++ b/moa/src/test/java/com/yahoo/labs/samoa/instances/ArffLoaderRegressionTest.java
@@ -29,8 +29,9 @@ public static void setUpBeforeClass() throws Exception {
 		try {
 			InputStream fileStream;
 			Reader reader;
-			
-			fileStream = new FileInputStream(ClassLoader.getSystemResource("moa/classifiers/data/small_regression.arff").getPath());
+
+			fileStream = new FileInputStream(
+					ClassLoader.getSystemResource("moa/learners/predictors/data/small_regression.arff").getPath());
 			reader = new BufferedReader(new InputStreamReader(fileStream));
 			instancesHeader = new InstancesHeader(reader, "6");
 		} catch (IOException ioe) {
@@ -43,7 +44,7 @@ public void testHeaderRegression() {
 		// check number of attributes
 		assertEquals(7, instancesHeader.arff.instanceInformation.numInputAttributes());
 		assertEquals(1, instancesHeader.arff.instanceInformation.numOutputAttributes());
-		
+
 		// check attribute types for each position
 		assertTrue(instancesHeader.arff.instanceInformation.attribute(0).isNumeric());
 		assertTrue(instancesHeader.arff.instanceInformation.attribute(1).isNumeric());
@@ -63,8 +64,8 @@ public void testHeaderRegression() {
 		assertTrue(instancesHeader.arff.instanceInformation.attribute(5).name.equals("R3"));
 		assertTrue(instancesHeader.arff.instanceInformation.attribute(6).name.equals("F3"));
 		assertTrue(instancesHeader.arff.instanceInformation.attribute(7).name.equals("N2"));
-		
-		//check class index
+
+		// check class index
 		assertEquals(5, instancesHeader.classIndex());
 	}
 
@@ -73,7 +74,7 @@ public void testInstancesRegression() {
 		// ---------------------- instance 1 ----------------------
 		Instance instance = instancesHeader.arff.readInstance();
 		instance.setDataset(instancesHeader);
-		
+
 		// check attributes
 		assertEquals(1.1, instance.value(0), EPS);
 		assertEquals(-2.3, instance.value(1), EPS);
@@ -119,7 +120,7 @@ public void testInstancesRegression() {
 		assertEquals(1, instance.valueInputAttribute(4), EPS);
 		assertEquals(3.2, instance.valueInputAttribute(5), EPS);
 		assertEquals(0, instance.valueInputAttribute(6), EPS);
-		
+
 		// check output values
 		assertEquals(2, instance.classValue(), EPS);
 		assertEquals(2, instance.valueOutputAttribute(0), EPS);
diff --git a/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java b/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java
deleted file mode 100644
index 9ceb9fb8a..000000000
--- a/moa/src/test/java/moa/classifiers/AbstractClassifierTestCase.java
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-/**
- * AbstractMultipleClassifierTestCase.java Copyright (C) 2013 University of Waikato, Hamilton, New
- * Zealand
- */
-package moa.classifiers;
-
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.core.Example;
-import moa.evaluation.BasicClassificationPerformanceEvaluator;
-import moa.evaluation.LearningPerformanceEvaluator;
-import moa.learners.Classifier;
-
-/**
- * Ancestor that defines a setting to test a classifier several times with
- * different parameters using this predefined same setting.
- *
- * @author fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public abstract class AbstractClassifierTestCase
-        extends AbstractInstanceLearnerTestCase<Classifier> {
-
-    protected int numberTests = 1;
-
-    /**
-     * Constructs the test case. Called by subclasses.
-     *
-     * @param name the name of the test
-     */
-    public AbstractClassifierTestCase(String name) {
-        super(name);
-    }
-
-    /**
-     * Sets the number of tests to run with this classifier.
-     *
-     * @param name the name of the test
-     * @param numberTests the numbers of tests to run
-     */
-
-    public void setNumberTests(int numberTests) {
-        this.numberTests = numberTests;
-    }
-
-    /**
-     * Called by JUnit before each test method.
-     *
-     * @throws Exception if an error occurs.
-     */
-    @Override
-    protected void setUp() throws Exception {
-        super.setUp();
-
-        m_TestHelper.copyResourceToTmp("classification.arff");
-    }
-
-    /**
-     * Called by JUnit after each test method.
-     *
-     * @throws Exception	if tear-down fails
-     */
-    @Override
-    protected void tearDown() throws Exception {
-        m_TestHelper.deleteFileFromTmp("classification.arff");
-
-        super.tearDown();
-    }
-
-    /**
-     * Returns the filenames (without path) of the input data files to use in
-     * the regression test.
-     *
-     * @return	the filenames
-     */
-    @Override
-    protected String[] getRegressionInputFiles() {
-        String value = "classification.arff";
-        String[] ret = new String[this.numberTests];
-        for (int i = 0; i < this.numberTests; i++) {
-            ret[i] = value;
-        }
-        return ret;
-    }
-
-    /**
-     * Returns the class index for the datasets.
-     *
-     * @return	the class indices (0-based)
-     */
-    @Override
-    protected int[] getRegressionInputClassIndex() {
-        int value = 10;
-        int[] ret = new int[this.numberTests];
-        for (int i = 0; i < this.numberTests; i++) {
-            ret[i] = value;
-        }
-        return ret;
-    }
-
-    /**
-     * Returns the index of the instances in the stream to inspect the
-     * performance/classification output of the classifiers.
-     *
-     * @return	the inspection indices
-     */
-    @Override
-    protected int[][] getRegressionInspectionPoints() {
-        int[] value = new int[]{10000, 20000, 30000, 40000, 50000, 60000, 70000, 80000, 90000, 100000};
-        int[][] ret = new int[this.numberTests][value.length];
-        for (int i = 0; i < this.numberTests; i++) {
-            ret[i] = value.clone();
-        }
-        return ret;
-    }
-
-    /**
-     * Returns the evaluator setups to use in the regression test.
-     *
-     * @return	the setups
-     */
-    @Override
-    protected LearningPerformanceEvaluator<Example<Instance>> [] getRegressionEvaluatorSetups() {
-    	LearningPerformanceEvaluator<Example<Instance>> value = new BasicClassificationPerformanceEvaluator();
-    	LearningPerformanceEvaluator<Example<Instance>>[] ret = new BasicClassificationPerformanceEvaluator[this.numberTests];
-        for (int i = 0; i < this.numberTests; i++) {
-            ret[i] = (LearningPerformanceEvaluator<Example<Instance>> ) value.copy();
-        }
-        return ret;
-    }
-
-    public Classifier copySetup(Classifier setup) {
-    	return (Classifier) setup.copy();
-    }
-}
diff --git a/moa/src/test/java/moa/classifiers/AbstractMultiTargetRegressorTestCase.java b/moa/src/test/java/moa/classifiers/AbstractMultiTargetRegressorTestCase.java
deleted file mode 100644
index f5b7d5ddd..000000000
--- a/moa/src/test/java/moa/classifiers/AbstractMultiTargetRegressorTestCase.java
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-/**
- * AbstractMultipleRegressorTestCase.java Copyright (C) 2013 University of Waikato, Hamilton, New
- * Zealand
- */
-package moa.classifiers;
-
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.core.Example;
-import moa.evaluation.BasicRegressionPerformanceEvaluator;
-import moa.evaluation.LearningPerformanceEvaluator;
-import moa.learners.MultiTargetRegressor;
-
-/**
- * Ancestor that defines a setting to test a classifier several times with
- * different parameters using this predefined same setting.
- *
- * @author fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public abstract class AbstractMultiTargetRegressorTestCase extends AbstractInstanceLearnerTestCase<MultiTargetRegressor> {
-
-    protected int numberTests = 1;
-
-    /**
-     * Constructs the test case. Called by subclasses.
-     *
-     * @param name the name of the test
-     */
-    public AbstractMultiTargetRegressorTestCase(String name) {
-        super(name);
-    }
-
-    /**
-     * Sets the number of tests to run with this classifier.
-     *
-     * @param name the name of the test
-     * @param numberTests the numbers of tests to run
-     */
-
-    public void setNumberTests(int numberTests) {
-        this.numberTests = numberTests;
-    }
-
-    /**
-     * Called by JUnit before each test method.
-     *
-     * @throws Exception if an error occurs.
-     */
-    @Override
-    protected void setUp() throws Exception {
-        super.setUp();
-
-        m_TestHelper.copyResourceToTmp("regression.arff");
-    }
-
-    /**
-     * Called by JUnit after each test method.
-     *
-     * @throws Exception	if tear-down fails
-     */
-    @Override
-    protected void tearDown() throws Exception {
-        m_TestHelper.deleteFileFromTmp("regression.arff");
-
-        super.tearDown();
-    }
-
-    /**
-     * Returns the filenames (without path) of the input data files to use in
-     * the regression test.
-     *
-     * @return	the filenames
-     */
-    @Override
-    protected String[] getRegressionInputFiles() {
-        String value = "regression.arff";
-        String[] ret = new String[this.numberTests];
-        for (int i = 0; i < this.numberTests; i++) {
-            ret[i] = value;
-        }
-        return ret;
-    }
-
-    /**
-     * Returns the class index for the datasets.
-     *
-     * @return	the class indices (0-based)
-     */
-    @Override
-    protected int[] getRegressionInputClassIndex() {
-        int value = 8;
-        int[] ret = new int[this.numberTests];
-        for (int i = 0; i < this.numberTests; i++) {
-            ret[i] = value;
-        }
-        return ret;
-    }
-
-    /**
-     * Returns the index of the instances in the stream to inspect the
-     * performance/classification output of the classifiers.
-     *
-     * @return	the inspection indices
-     */
-    @Override
-    protected int[][] getRegressionInspectionPoints() {
-        int[] value = new int[]{100, 200, 300, 400, 500, 600, 700, 800, 900, 1000};
-        int[][] ret = new int[this.numberTests][value.length];
-        for (int i = 0; i < this.numberTests; i++) {
-            ret[i] = value.clone();
-        }
-        return ret;
-    }
-
-    /**
-     * Returns the evaluator setups to use in the regression test.
-     *
-     * @return	the setups
-     */
-    @Override
-    protected LearningPerformanceEvaluator<Example<Instance>> [] getRegressionEvaluatorSetups() {
-    	LearningPerformanceEvaluator<Example<Instance>>  value = new BasicRegressionPerformanceEvaluator();
-    	LearningPerformanceEvaluator<Example<Instance>> [] ret = new BasicRegressionPerformanceEvaluator[this.numberTests];
-        for (int i = 0; i < this.numberTests; i++) {
-            ret[i] = (LearningPerformanceEvaluator<Example<Instance>> ) value.copy();
-        }
-        return ret;
-    }
-    
-    public MultiTargetRegressor copySetup(MultiTargetRegressor setup) {
-    	return (MultiTargetRegressor) setup.copy();
-    }
-}
diff --git a/moa/src/test/java/moa/classifiers/AbstractRegressorTestCase.java b/moa/src/test/java/moa/classifiers/AbstractRegressorTestCase.java
deleted file mode 100644
index 42ff9ddfa..000000000
--- a/moa/src/test/java/moa/classifiers/AbstractRegressorTestCase.java
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-/**
- * AbstractMultipleRegressorTestCase.java Copyright (C) 2013 University of Waikato, Hamilton, New
- * Zealand
- */
-package moa.classifiers;
-
-import com.yahoo.labs.samoa.instances.Instance;
-
-import moa.core.Example;
-import moa.evaluation.BasicRegressionPerformanceEvaluator;
-import moa.evaluation.LearningPerformanceEvaluator;
-import moa.learners.Regressor;
-
-/**
- * Ancestor that defines a setting to test a classifier several times with
- * different parameters using this predefined same setting.
- *
- * @author fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public abstract class AbstractRegressorTestCase extends AbstractInstanceLearnerTestCase<Regressor> {
-
-    protected int numberTests = 1;
-
-    /**
-     * Constructs the test case. Called by subclasses.
-     *
-     * @param name the name of the test
-     */
-    public AbstractRegressorTestCase(String name) {
-        super(name);
-    }
-
-    /**
-     * Sets the number of tests to run with this classifier.
-     *
-     * @param name the name of the test
-     * @param numberTests the numbers of tests to run
-     */
-
-    public void setNumberTests(int numberTests) {
-        this.numberTests = numberTests;
-    }
-
-    /**
-     * Called by JUnit before each test method.
-     *
-     * @throws Exception if an error occurs.
-     */
-    @Override
-    protected void setUp() throws Exception {
-        super.setUp();
-
-        m_TestHelper.copyResourceToTmp("regression.arff");
-    }
-
-    /**
-     * Called by JUnit after each test method.
-     *
-     * @throws Exception	if tear-down fails
-     */
-    @Override
-    protected void tearDown() throws Exception {
-        m_TestHelper.deleteFileFromTmp("regression.arff");
-
-        super.tearDown();
-    }
-
-    /**
-     * Returns the filenames (without path) of the input data files to use in
-     * the regression test.
-     *
-     * @return	the filenames
-     */
-    @Override
-    protected String[] getRegressionInputFiles() {
-        String value = "regression.arff";
-        String[] ret = new String[this.numberTests];
-        for (int i = 0; i < this.numberTests; i++) {
-            ret[i] = value;
-        }
-        return ret;
-    }
-
-    /**
-     * Returns the class index for the datasets.
-     *
-     * @return	the class indices (0-based)
-     */
-    @Override
-    protected int[] getRegressionInputClassIndex() {
-        int value = 8;
-        int[] ret = new int[this.numberTests];
-        for (int i = 0; i < this.numberTests; i++) {
-            ret[i] = value;
-        }
-        return ret;
-    }
-
-    /**
-     * Returns the index of the instances in the stream to inspect the
-     * performance/classification output of the classifiers.
-     *
-     * @return	the inspection indices
-     */
-    @Override
-    protected int[][] getRegressionInspectionPoints() {
-        int[] value = new int[]{100, 200, 300, 400, 500, 600, 700, 800, 900, 1000};
-        int[][] ret = new int[this.numberTests][value.length];
-        for (int i = 0; i < this.numberTests; i++) {
-            ret[i] = value.clone();
-        }
-        return ret;
-    }
-
-    /**
-     * Returns the evaluator setups to use in the regression test.
-     *
-     * @return	the setups
-     */
-    @Override
-    protected LearningPerformanceEvaluator<Example<Instance>> [] getRegressionEvaluatorSetups() {
-    	LearningPerformanceEvaluator<Example<Instance>>  value = new BasicRegressionPerformanceEvaluator();
-    	LearningPerformanceEvaluator<Example<Instance>> [] ret = new BasicRegressionPerformanceEvaluator[this.numberTests];
-        for (int i = 0; i < this.numberTests; i++) {
-            ret[i] = (LearningPerformanceEvaluator<Example<Instance>> ) value.copy();
-        }
-        return ret;
-    }
-    
-    public Regressor copySetup(Regressor setup) {
-    	return (Regressor) setup.copy();
-    }
-}
diff --git a/moa/src/test/java/moa/classifiers/active/ALRandomTest.java b/moa/src/test/java/moa/classifiers/active/ALRandomTest.java
deleted file mode 100644
index cacac51e6..000000000
--- a/moa/src/test/java/moa/classifiers/active/ALRandomTest.java
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * ALRandomTest.java
- * Copyright (C) 2016 Otto von Guericke University, Magdeburg, Germany
- */
-package moa.classifiers.active;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the ALRandom classifier.
- * 
- * @author  Cornelius Styp von Rekowski (cornelius dot styp at ovgu dot de)
- */
-public class ALRandomTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public ALRandomTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-	return new Classifier[]{
-		new ALRandom()
-	};
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(ALRandomTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/active/ALUncertaintyTest.java b/moa/src/test/java/moa/classifiers/active/ALUncertaintyTest.java
deleted file mode 100644
index 679993d55..000000000
--- a/moa/src/test/java/moa/classifiers/active/ALUncertaintyTest.java
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * ALUncertaintyTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.active;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the ALUncertainty classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class ALUncertaintyTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public ALUncertaintyTest(String name) {
-    super(name);
-    this.setNumberTests(4);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-	ALUncertainty fixed       = new ALUncertainty();
-	ALUncertainty var         = new ALUncertainty();
-	ALUncertainty randVar     = new ALUncertainty();
-	ALUncertainty selSampling = new ALUncertainty();
-	
-	fixed.activeLearningStrategyOption.setChosenLabel("FixedUncertainty");
-	var.activeLearningStrategyOption.setChosenLabel("VarUncertainty");
-	randVar.activeLearningStrategyOption.setChosenLabel("RandVarUncertainty");
-	selSampling.activeLearningStrategyOption.setChosenLabel("SelSampling");
-	
-	return new Classifier[]{
-		fixed, var, randVar, selSampling
-	};
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(ALUncertaintyTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/bayes/NaiveBayesMultinomialTest.java b/moa/src/test/java/moa/classifiers/bayes/NaiveBayesMultinomialTest.java
deleted file mode 100644
index 83178c351..000000000
--- a/moa/src/test/java/moa/classifiers/bayes/NaiveBayesMultinomialTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * NaiveBayesMultinomialTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.bayes;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the NaiveBayesMultinomial classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class NaiveBayesMultinomialTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public NaiveBayesMultinomialTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-  
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {  
-    return new Classifier[]{
-	new NaiveBayesMultinomial(),
-    };
-  }
-
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(NaiveBayesMultinomialTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/bayes/NaiveBayesTest.java b/moa/src/test/java/moa/classifiers/bayes/NaiveBayesTest.java
deleted file mode 100644
index 680b27b2c..000000000
--- a/moa/src/test/java/moa/classifiers/bayes/NaiveBayesTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * NaiveBayesTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.bayes;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the NaiveBayes classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class NaiveBayesTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public NaiveBayesTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new NaiveBayes(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(NaiveBayesTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/drift/DriftDetectionMethodClassifierTest.java b/moa/src/test/java/moa/classifiers/drift/DriftDetectionMethodClassifierTest.java
deleted file mode 100644
index b58927ab8..000000000
--- a/moa/src/test/java/moa/classifiers/drift/DriftDetectionMethodClassifierTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * DriftDetectionMethodClassifierTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.drift;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the DriftDetectionMethodClassifier classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class DriftDetectionMethodClassifierTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public DriftDetectionMethodClassifierTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new DriftDetectionMethodClassifier(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(DriftDetectionMethodClassifierTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/drift/SingleClassifierDriftTest.java b/moa/src/test/java/moa/classifiers/drift/SingleClassifierDriftTest.java
deleted file mode 100644
index a00460ee0..000000000
--- a/moa/src/test/java/moa/classifiers/drift/SingleClassifierDriftTest.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * SingleClassifierDriftTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.drift;
-
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the SingleClassifierDrift classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class SingleClassifierDriftTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public SingleClassifierDriftTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new SingleClassifierDrift(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(SingleClassifierDriftTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
\ No newline at end of file
diff --git a/moa/src/test/java/moa/classifiers/functions/MajorityClassTest.java b/moa/src/test/java/moa/classifiers/functions/MajorityClassTest.java
deleted file mode 100644
index 7bc0e2ca1..000000000
--- a/moa/src/test/java/moa/classifiers/functions/MajorityClassTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * MajorityClassTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.functions;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the MajorityClass classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class MajorityClassTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public MajorityClassTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new MajorityClass(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(MajorityClassTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/functions/NoChangeTest.java b/moa/src/test/java/moa/classifiers/functions/NoChangeTest.java
deleted file mode 100644
index 2e9577967..000000000
--- a/moa/src/test/java/moa/classifiers/functions/NoChangeTest.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * NoChangeTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.functions;
-
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the NoChange classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class NoChangeTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public NoChangeTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new NoChange(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(NoChangeTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/functions/PerceptronTest.java b/moa/src/test/java/moa/classifiers/functions/PerceptronTest.java
deleted file mode 100644
index b2ae7e2a0..000000000
--- a/moa/src/test/java/moa/classifiers/functions/PerceptronTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * PerceptronTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.functions;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the Perceptron classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class PerceptronTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public PerceptronTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new Perceptron(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(PerceptronTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/functions/SGDTest.java b/moa/src/test/java/moa/classifiers/functions/SGDTest.java
deleted file mode 100644
index 308855ec3..000000000
--- a/moa/src/test/java/moa/classifiers/functions/SGDTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * SGDTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.functions;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the SGD classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class SGDTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public SGDTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new SGD(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(SGDTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/functions/SPegasosTest.java b/moa/src/test/java/moa/classifiers/functions/SPegasosTest.java
deleted file mode 100644
index 3032868e4..000000000
--- a/moa/src/test/java/moa/classifiers/functions/SPegasosTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * SPegasosTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.functions;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the SPegasos classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class SPegasosTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public SPegasosTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new SPegasos(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(SPegasosTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/meta/ADOBTest.java b/moa/src/test/java/moa/classifiers/meta/ADOBTest.java
deleted file mode 100644
index 6219f806d..000000000
--- a/moa/src/test/java/moa/classifiers/meta/ADOBTest.java
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- */
-
-/**
- * ADOBTest.java
- * Copyright (C) 2014 Santos, Goncalves, Barros
- */
-package moa.classifiers.meta;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the ADOB classifier.
- * 
- * @author  Silas G. T. C. Santos (sgtcs@cin.ufpe.br)
- * @version $Revision$
- */
-public class ADOBTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public ADOBTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new ADOB(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(ADOBTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/meta/AccuracyUpdatedEnsembleTest.java b/moa/src/test/java/moa/classifiers/meta/AccuracyUpdatedEnsembleTest.java
deleted file mode 100644
index 5e2900c22..000000000
--- a/moa/src/test/java/moa/classifiers/meta/AccuracyUpdatedEnsembleTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * AccuracyUpdatedEnsembleTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.meta;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the AccuracyUpdatedEnsemble classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class AccuracyUpdatedEnsembleTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public AccuracyUpdatedEnsembleTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new AccuracyUpdatedEnsemble(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(AccuracyUpdatedEnsembleTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/meta/AccuracyWeightedEnsembleTest.java b/moa/src/test/java/moa/classifiers/meta/AccuracyWeightedEnsembleTest.java
deleted file mode 100644
index 1ef0b425d..000000000
--- a/moa/src/test/java/moa/classifiers/meta/AccuracyWeightedEnsembleTest.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * AccuracyWeightedEnsembleTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.meta;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the AccuracyWeightedEnsemble classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class AccuracyWeightedEnsembleTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public AccuracyWeightedEnsembleTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new AccuracyWeightedEnsemble(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(AccuracyWeightedEnsembleTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
-
diff --git a/moa/src/test/java/moa/classifiers/meta/AdaptiveRandomForestTest.java b/moa/src/test/java/moa/classifiers/meta/AdaptiveRandomForestTest.java
deleted file mode 100644
index 8dd3c3c68..000000000
--- a/moa/src/test/java/moa/classifiers/meta/AdaptiveRandomForestTest.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- *   AdaptiveRandomForestTest.java
- *
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * 
- */
-package moa.classifiers.meta;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the AdaptiveRandomForest classifier.
- * 
- * @author  Heitor Murilo Gomes (heitor_murilo_gomes at yahoo dot com dot br)
- * @version $Revision$
- */
-public class AdaptiveRandomForestTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public AdaptiveRandomForestTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new AdaptiveRandomForest(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(AdaptiveRandomForestTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/meta/BOLETest.java b/moa/src/test/java/moa/classifiers/meta/BOLETest.java
deleted file mode 100644
index 4a6313305..000000000
--- a/moa/src/test/java/moa/classifiers/meta/BOLETest.java
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- */
-
-/**
- * BOLETest.java
- * Copyright (C) 2015 Santos, Barros
- */
-package moa.classifiers.meta;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the BOLE classifier.
- * 
- * @author  Silas G. T. C. Santos (sgtcs@cin.ufpe.br)
- * @version $Revision$
- */
-public class BOLETest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public BOLETest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new BOLE(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(BOLETest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/meta/DynamicWeightedMajorityTest.java b/moa/src/test/java/moa/classifiers/meta/DynamicWeightedMajorityTest.java
deleted file mode 100644
index 2353a6b8e..000000000
--- a/moa/src/test/java/moa/classifiers/meta/DynamicWeightedMajorityTest.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-/**
- * DynamicWeightedMajorityTest.java
- * Copyright (C) 2016 Instituto Federal de Pernambuco, Recife, Brazil
- */
-package moa.classifiers.meta;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the Dynamic Weighted Majority classifier.
- *
- * @author Paulo Gonçalves (paulogoncalves at recife dot ifpe dot edu dot br)
- * @version $Revision$
- */
-public class DynamicWeightedMajorityTest
-        extends AbstractClassifierTestCase {
-
-    /**
-     * Constructs the test case. Called by subclasses.
-     *
-     * @param name the name of the test
-     */
-    public DynamicWeightedMajorityTest(String name) {
-        super(name);
-        this.setNumberTests(1);
-    }
-
-    /**
-     * Returns the classifier setups to use in the regression test.
-     *
-     * @return	the setups
-     */
-    @Override
-    protected Classifier[] getLearnerSetups() {
-        return new Classifier[]{
-            new DynamicWeightedMajority(),};
-    }
-
-    /**
-     * Returns a test suite.
-     *
-     * @return	the test suite
-     */
-    public static Test suite() {
-        return new TestSuite(DynamicWeightedMajorityTest.class);
-    }
-
-    /**
-     * Runs the test from command line.
-     *
-     * @param args	ignored
-     */
-    public static void main(String[] args) {
-        runTest(suite());
-    }
-}
diff --git a/moa/src/test/java/moa/classifiers/meta/LeveragingBagTest.java b/moa/src/test/java/moa/classifiers/meta/LeveragingBagTest.java
deleted file mode 100644
index 7e417009e..000000000
--- a/moa/src/test/java/moa/classifiers/meta/LeveragingBagTest.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * LeveragingBagTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.meta;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the LeveragingBag classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class LeveragingBagTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public LeveragingBagTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new LeveragingBag(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(LeveragingBagTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
-
diff --git a/moa/src/test/java/moa/classifiers/meta/LimAttClassifierTest.java b/moa/src/test/java/moa/classifiers/meta/LimAttClassifierTest.java
deleted file mode 100644
index ffaa9ba5a..000000000
--- a/moa/src/test/java/moa/classifiers/meta/LimAttClassifierTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * LimAttClassifierTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.meta;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the LimAttClassifier classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class LimAttClassifierTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public LimAttClassifierTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new LimAttClassifier(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(LimAttClassifierTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/meta/OCBoostTest.java b/moa/src/test/java/moa/classifiers/meta/OCBoostTest.java
deleted file mode 100644
index f439010c2..000000000
--- a/moa/src/test/java/moa/classifiers/meta/OCBoostTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * OCBoostTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.meta;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the OCBoost classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class OCBoostTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public OCBoostTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new OCBoost(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(OCBoostTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/meta/OnlineAccuracyUpdatedEnsembleTest.java b/moa/src/test/java/moa/classifiers/meta/OnlineAccuracyUpdatedEnsembleTest.java
deleted file mode 100644
index 782a1cae6..000000000
--- a/moa/src/test/java/moa/classifiers/meta/OnlineAccuracyUpdatedEnsembleTest.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * OnlineAccuracyUpdatedEnsembleTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.meta;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the OnlineAccuracyUpdatedEnsemble classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class OnlineAccuracyUpdatedEnsembleTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public OnlineAccuracyUpdatedEnsembleTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new OnlineAccuracyUpdatedEnsemble(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(OnlineAccuracyUpdatedEnsembleTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
-
diff --git a/moa/src/test/java/moa/classifiers/meta/OzaBagASHTTest.java b/moa/src/test/java/moa/classifiers/meta/OzaBagASHTTest.java
deleted file mode 100644
index 6ff6925b1..000000000
--- a/moa/src/test/java/moa/classifiers/meta/OzaBagASHTTest.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * OzaBagASHTTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.meta;
-
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the OzaBagASHT classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class OzaBagASHTTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public OzaBagASHTTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    OzaBagASHT[]	result;
-    result    = new OzaBagASHT[1];
-    result[0] = new OzaBagASHT();
-    return result;
-    
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(OzaBagASHTTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
-
diff --git a/moa/src/test/java/moa/classifiers/meta/OzaBagAdwinClassificationTest.java b/moa/src/test/java/moa/classifiers/meta/OzaBagAdwinClassificationTest.java
deleted file mode 100644
index 73e783c4b..000000000
--- a/moa/src/test/java/moa/classifiers/meta/OzaBagAdwinClassificationTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * OzaBagAdwinTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.meta;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the OzaBagAdwin classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class OzaBagAdwinClassificationTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public OzaBagAdwinClassificationTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new OzaBagAdwinClassification(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(OzaBagAdwinClassificationTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/meta/OzaBagClassificationTest.java b/moa/src/test/java/moa/classifiers/meta/OzaBagClassificationTest.java
deleted file mode 100644
index e42d6fa8a..000000000
--- a/moa/src/test/java/moa/classifiers/meta/OzaBagClassificationTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * OzaBagTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.meta;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the OzaBag classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class OzaBagClassificationTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public OzaBagClassificationTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new OzaBagClassification(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(OzaBagClassificationTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/meta/OzaBoostAdwinTest.java b/moa/src/test/java/moa/classifiers/meta/OzaBoostAdwinTest.java
deleted file mode 100644
index 4c0d8a382..000000000
--- a/moa/src/test/java/moa/classifiers/meta/OzaBoostAdwinTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * OzaBoostAdwinTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.meta;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the OzaBoostAdwin classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class OzaBoostAdwinTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public OzaBoostAdwinTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new OzaBoostAdwin(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(OzaBoostAdwinTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/meta/OzaBoostClassificationTest.java b/moa/src/test/java/moa/classifiers/meta/OzaBoostClassificationTest.java
deleted file mode 100644
index cf659c4f9..000000000
--- a/moa/src/test/java/moa/classifiers/meta/OzaBoostClassificationTest.java
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * OzaBoostTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.meta;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the OzaBoost classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class OzaBoostClassificationTest extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public OzaBoostClassificationTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new OzaBoostClassification(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(OzaBoostClassificationTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/meta/TemporallyAugmentedClassifierTest.java b/moa/src/test/java/moa/classifiers/meta/TemporallyAugmentedClassifierTest.java
deleted file mode 100644
index 108a8e234..000000000
--- a/moa/src/test/java/moa/classifiers/meta/TemporallyAugmentedClassifierTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * TemporallyAugmentedClassifierTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.meta;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the TemporallyAugmentedClassifier classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class TemporallyAugmentedClassifierTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public TemporallyAugmentedClassifierTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new TemporallyAugmentedClassifier(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(TemporallyAugmentedClassifierTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/meta/WEKAClassifierTest.java b/moa/src/test/java/moa/classifiers/meta/WEKAClassifierTest.java
deleted file mode 100644
index 55c546606..000000000
--- a/moa/src/test/java/moa/classifiers/meta/WEKAClassifierTest.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * WEKAClassifierTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.meta;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the WEKAClassifier classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class WEKAClassifierTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public WEKAClassifierTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new WEKAClassifier(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(WEKAClassifierTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
-
diff --git a/moa/src/test/java/moa/classifiers/meta/WeightedMajorityAlgorithmTest.java b/moa/src/test/java/moa/classifiers/meta/WeightedMajorityAlgorithmTest.java
deleted file mode 100644
index 226130108..000000000
--- a/moa/src/test/java/moa/classifiers/meta/WeightedMajorityAlgorithmTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * WeightedMajorityAlgorithmTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.meta;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the WeightedMajorityAlgorithm classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class WeightedMajorityAlgorithmTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public WeightedMajorityAlgorithmTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new WeightedMajorityAlgorithm(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(WeightedMajorityAlgorithmTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/rules/RuleClassifierNBayesTest.java b/moa/src/test/java/moa/classifiers/rules/RuleClassifierNBayesTest.java
deleted file mode 100644
index 65dc0dca3..000000000
--- a/moa/src/test/java/moa/classifiers/rules/RuleClassifierNBayesTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * RuleClassifierNBayesTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.rules;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the RuleClassifierNBayes classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class RuleClassifierNBayesTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public RuleClassifierNBayesTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new RuleClassifierNBayes(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(RuleClassifierNBayesTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/rules/RuleClassifierTest.java b/moa/src/test/java/moa/classifiers/rules/RuleClassifierTest.java
deleted file mode 100644
index cd3edc707..000000000
--- a/moa/src/test/java/moa/classifiers/rules/RuleClassifierTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * RuleClassifierTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.rules;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the RuleClassifier classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class RuleClassifierTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public RuleClassifierTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new RuleClassifier(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(RuleClassifierTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/rules/core/UtilsTest.java b/moa/src/test/java/moa/classifiers/rules/core/UtilsTest.java
deleted file mode 100644
index 2e88c48f5..000000000
--- a/moa/src/test/java/moa/classifiers/rules/core/UtilsTest.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- *    UtilsTest.java
- *    Copyright (C) 2017 University of Porto, Portugal
- *    @author J. Duarte, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *
- *
- */
-
-package moa.classifiers.rules.core;
-
-import static org.junit.Assert.assertArrayEquals;
-
-import org.junit.Test;
-
-public class UtilsTest {
-
-	@Test
-	public void testComplementSet() {
-		int [] result=Utils.complementSet(new int []{1,3,4,5,6}, new int []{4,5});
-		assertArrayEquals(new int []{1,3,6},result);
-		
-		result=Utils.complementSet(new int []{1,3,4,5,6}, new int []{1,3,4,5,6});
-		assertArrayEquals(new int []{},result);
-		
-		result=Utils.complementSet(new int []{1,3,4,5,6}, new int []{1});
-		assertArrayEquals(new int []{3,4,5,6},result);
-		
-		result=Utils.complementSet(new int []{1,3,4,5,6}, new int []{4,6});
-		assertArrayEquals(new int []{1,3,5},result);
-	}
-	@Test
-	public void testGetIndexCorrespondence(){
-		int[] result=Utils.getIndexCorrespondence(new int []{2,3,5}, new int []{2,3});
-		assertArrayEquals(new int []{0,1},result);
-		
-		result=Utils.getIndexCorrespondence(new int []{1,2,3,4,5}, new int []{1,2,3,4,5});
-		assertArrayEquals(new int []{0,1,2,3,4},result);
-		
-		result=Utils.getIndexCorrespondence(new int []{1,2,5}, new int []{1,5});
-		assertArrayEquals(new int []{0,2},result);
-		
-		result=Utils.getIndexCorrespondence(new int []{1,2,5}, new int []{2});
-		assertArrayEquals(new int []{1},result);
-	}
-
-}
diff --git a/moa/src/test/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressorSemiSuperTest.java b/moa/src/test/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressorSemiSuperTest.java
deleted file mode 100644
index f7a13a408..000000000
--- a/moa/src/test/java/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressorSemiSuperTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- *    MultiTargetLearnerSemiSupervised.java
- *    Copyright (C) 2017 University of Porto, Portugal
- *    @author R. Sousa, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *
- *
- */
-
-package moa.classifiers.rules.multilabel;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractMultiTargetRegressorTestCase;
-import moa.learners.MultiTargetRegressor;
-
-
-/**
- * Created by RSousa on 04/07/2017.
- */
-public class AMRulesMultiTargetRegressorSemiSuperTest
-        extends AbstractMultiTargetRegressorTestCase {
-
-    /**
-     * Constructs the test case. Called by subclasses.
-     *
-     * @param name 	the name of the test
-     */
-    public AMRulesMultiTargetRegressorSemiSuperTest(String name) {
-        super(name);
-        this.setNumberTests(1);
-    }
-
-    /**
-     * Returns the classifier setups to use in the regression test.
-     *
-     * @return		the setups
-     */
-    @Override
-    protected MultiTargetRegressor[] getLearnerSetups() {
-        return new MultiTargetRegressor[]{
-                new AMRulesMultiTargetRegressorSemiSuper(),
-        };
-    }
-
-    /**
-     * Returns a test suite.
-     *
-     * @return		the test suite
-     */
-    public static Test suite() {
-        return new TestSuite(moa.classifiers.rules.multilabel.AMRulesMultiTargetRegressorSemiSuperTest.class);
-    }
-
-    /**
-     * Runs the test from commandline.
-     *
-     * @param args	ignored
-     */
-    public static void main(String[] args) {
-        runTest(suite());
-    }
-}
-
diff --git a/moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/FirstHitVoteMultiLabelTest.java b/moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/FirstHitVoteMultiLabelTest.java
deleted file mode 100644
index 4a01e879a..000000000
--- a/moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/FirstHitVoteMultiLabelTest.java
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- *    FirstHitVoteMultiLabelTest.java
- *    Copyright (C) 2017 University of Porto, Portugal
- *    @author J. Duarte, J. Gama
- *
- *    Licensed under the Apache License, Version 2.0 (the "License");
- *    you may not use this file except in compliance with the License.
- *    You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *    Unless required by applicable law or agreed to in writing, software
- *    distributed under the License is distributed on an "AS IS" BASIS,
- *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *    See the License for the specific language governing permissions and
- *    limitations under the License.
- *
- *
- */
-
-package moa.classifiers.rules.multilabel.core.voting;
-
-import static org.junit.Assert.assertEquals;
-
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-/**
- * Test FirstHitVoteMultiLabel class
- *
- * @author João Duarte (joaomaiaduarte@gmail.com)
- */
-public class FirstHitVoteMultiLabelTest {
-
-	static FirstHitVoteMultiLabel weightedVote;
-	static final double EPS=0.0000001;
-	@BeforeClass
-	    public static void runBefore() {
-			weightedVote = new FirstHitVoteMultiLabel();
-			Prediction pred= new MultiLabelClassificationPrediction(4);
-			pred.setVote(0, 1);
-			pred.setVote(3, 4);
-			weightedVote.addVote(pred, new double[]{4,Double.MAX_VALUE,Double.MAX_VALUE,3});
-			
-			pred= new MultiLabelClassificationPrediction(4);
-			pred.setVote(0, 2);
-			pred.setVote(2, 3);
-			pred.setVote(3, 2);
-			weightedVote.addVote(pred, new double[]{3,Double.MAX_VALUE,1,1});
-			
-			pred= new MultiLabelClassificationPrediction(4);
-			pred.setVote(1, 2);
-			pred.setVote(3, 1);
-			weightedVote.addVote(pred, new double[]{Double.MAX_VALUE,4,Double.MAX_VALUE,0});
-			weightedVote.computeWeightedVote(); 
-	     }
-	    
-	
-		@Test
-		public void testComputeWeightedVote() {
-			Prediction weightedPred=weightedVote.computeWeightedVote();
-			assertEquals(1,weightedPred.getVote(0, 0), EPS);
-			assertEquals(2,weightedPred.getVote(1, 0), EPS);
-			assertEquals(3,weightedPred.getVote(2, 0), EPS);
-			assertEquals(4,weightedPred.getVote(3, 0), EPS);
-		}
-	
-		@Test
-		public void testGetWeightedError() {
-			assertEquals(3,weightedVote.getWeightedError(), EPS);
-		}
-	
-		@Test
-		public void testGetWeights() {
-			double [][] weights=weightedVote.getWeights();
-			assertEquals(1,weights[0][0], EPS);
-			assertEquals(1,weights[0][3], EPS);
-			
-			assertEquals(0,weights[1][0], EPS);
-			assertEquals(1,weights[1][2], EPS);
-			assertEquals(0,weights[1][3], EPS);
-			
-			assertEquals(1,weights[2][1], EPS);
-			assertEquals(0,weights[2][3], EPS);
-			
-		}
-	
-		@Test
-		public void testGetNumberVotes() {
-			assertEquals(2,weightedVote.getNumberVotes(0));
-		}
-	
-		@Test
-		public void testGetNumberVotesInt() {
-			assertEquals(2, weightedVote.getNumberVotes(0));
-			assertEquals(1, weightedVote.getNumberVotes(1));
-			assertEquals(1, weightedVote.getNumberVotes(2));
-			assertEquals(3, weightedVote.getNumberVotes(3));
-		}
-	
-		@Test
-		public void testGetOutputAttributesErrors() {
-			double [] errors=weightedVote.getOutputAttributesErrors();
-			assertEquals(4, errors[0],EPS);
-			assertEquals(4, errors[1],EPS);
-			assertEquals(1, errors[2],EPS);
-			assertEquals(3, errors[3],EPS);
-		}
-}
diff --git a/moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/InverseErrorWeightedVoteMultiLabelTest.java b/moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/InverseErrorWeightedVoteMultiLabelTest.java
deleted file mode 100644
index ddb9bddf5..000000000
--- a/moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/InverseErrorWeightedVoteMultiLabelTest.java
+++ /dev/null
@@ -1,99 +0,0 @@
-package moa.classifiers.rules.multilabel.core.voting;
-
-import static org.junit.Assert.assertEquals;
-
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-/**
- * Test InverseErrorWeightedVoteMultiLabeL class
- *
- * @author João Duarte (joaomaiaduarte@gmail.com)
- */
-public class InverseErrorWeightedVoteMultiLabelTest {
-	static InverseErrorWeightedVoteMultiLabel weightedVote;
-	static final double EPS=0.0000001;
-	@BeforeClass
-	    public static void runBefore() {
-			weightedVote = new InverseErrorWeightedVoteMultiLabel();
-			Prediction pred= new MultiLabelClassificationPrediction(4);
-			pred.setVote(0, 1);
-			pred.setVote(1, 2);
-			pred.setVote(2, 3);
-			pred.setVote(3, 4);
-			weightedVote.addVote(pred, new double[]{4,3,2,1});
-			
-			pred= new MultiLabelClassificationPrediction(4);
-			pred.setVote(0, 1);
-			pred.setVote(1, 2);
-			pred.setVote(3, 4);
-			weightedVote.addVote(pred, new double[]{3,2,Double.MAX_VALUE,0});
-			
-			pred= new MultiLabelClassificationPrediction(4);
-			pred.setVote(0, 4);
-			pred.setVote(1, 2);
-			pred.setVote(3, 1);
-			weightedVote.addVote(pred, new double[]{1,0,Double.MAX_VALUE,0});
-			weightedVote.computeWeightedVote(); 
-	     }
-	    
-	
-		@Test
-		public void testComputeWeightedVote() {
-			Prediction weightedPred=weightedVote.computeWeightedVote();
-			assertEquals(2.8947368416,weightedPred.getVote(0, 0), EPS);
-			assertEquals(2,weightedPred.getVote(1, 0), EPS);
-			assertEquals(3,weightedPred.getVote(2, 0), EPS);
-			assertEquals(2.5000000008,weightedPred.getVote(3, 0), EPS);
-		}
-	
-		@Test
-		public void testGetWeightedError() {
-			assertEquals(0.9736842113,weightedVote.getWeightedError(), EPS);
-		}
-	
-		@Test
-		public void testGetWeights() {
-			double [][] weights=weightedVote.getWeights();
-			assertEquals(0.15789474,weights[0][0], EPS);
-			assertEquals(0.21052632,weights[1][0], EPS);
-			assertEquals(0.63157895,weights[2][0], EPS);
-			
-			assertEquals(0,weights[0][1], EPS);
-			assertEquals(0,weights[1][1], EPS);
-			assertEquals(1,weights[2][1], EPS);
-			
-			assertEquals(1,weights[0][2], EPS);
-			assertEquals(0,weights[1][2], EPS);
-			assertEquals(0,weights[2][2], EPS);
-			
-			assertEquals(0,weights[0][3], EPS);
-			assertEquals(.5,weights[1][3], EPS);
-			assertEquals(.5,weights[2][3], EPS);
-		}
-	
-		@Test
-		public void testGetNumberVotes() {
-			assertEquals(3,weightedVote.getNumberVotes(0));
-		}
-	
-		@Test
-		public void testGetNumberVotesInt() {
-			assertEquals(3, weightedVote.getNumberVotes(0));
-			assertEquals(3, weightedVote.getNumberVotes(1));
-			assertEquals(1, weightedVote.getNumberVotes(2));
-			assertEquals(3, weightedVote.getNumberVotes(3));
-		}
-	
-		@Test
-		public void testGetOutputAttributesErrors() {
-			double [] errors=weightedVote.getOutputAttributesErrors();
-			assertEquals(1.894736843, errors[0],EPS);
-			assertEquals(0.000000002, errors[1],EPS);
-			assertEquals(2, errors[2],EPS);
-			assertEquals(0, errors[3],EPS);
-		}
-}
diff --git a/moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/UniformWeightedVoteMultiLabelTest.java b/moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/UniformWeightedVoteMultiLabelTest.java
deleted file mode 100644
index e11e0ee1b..000000000
--- a/moa/src/test/java/moa/classifiers/rules/multilabel/core/voting/UniformWeightedVoteMultiLabelTest.java
+++ /dev/null
@@ -1,105 +0,0 @@
-package moa.classifiers.rules.multilabel.core.voting;
-
-import static org.junit.Assert.assertEquals;
-
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.core.DoubleVector;
-
-/**
- * Test UniformWeightedVoteMultiLabel
- *
- * @author João Duarte (joaomaiaduarte@gmail.com)
- */
-public class UniformWeightedVoteMultiLabelTest {
-	
-	static UniformWeightedVoteMultiLabel weightedVote;
-	static final double EPS=0.0000001;
-	
-    @BeforeClass
-    public static void runBefore() {
-		weightedVote = new UniformWeightedVoteMultiLabel();
-		Prediction pred= new MultiLabelClassificationPrediction(new double[] {1,2,3,4});
-//		pred.setVotes(0, new double[]{1});
-//		pred.setVotes(1, new double[]{2});
-//		pred.setVotes(2, new double[]{3});
-//		pred.setVotes(3, new double[]{4});
-		weightedVote.addVote(pred, new double[]{4,3,2,1});
-		
-		pred= new MultiLabelClassificationPrediction(new double[] {1, 2, 0, 4});
-//		pred.setVotes(0, new double[]{1});
-//		pred.setVotes(1, new double[]{2});
-//		pred.setVotes(3, new double[]{4});
-		weightedVote.addVote(pred, new double[]{3,2,Double.MAX_VALUE,0});
-		
-		pred= new MultiLabelClassificationPrediction(new double[] {4, 2, 0, 1});
-//		pred.setVotes(0, new double[]{4});
-//		pred.setVotes(1, new double[]{2});
-//		pred.setVotes(3, new double[]{1});
-		weightedVote.addVote(pred, new double[]{1,0,Double.MAX_VALUE,0});
-		weightedVote.computeWeightedVote(); 
-     }
-    
-
-	@Test
-	public void testComputeWeightedVote() {
-		Prediction weightedPred=weightedVote.computeWeightedVote();
-		assertEquals(2,weightedPred.getVote(0, 0), EPS);
-		assertEquals(2,weightedPred.getVote(1, 0), EPS);
-		assertEquals(3,weightedPred.getVote(2, 0), EPS);
-		assertEquals(3,weightedPred.getVote(3, 0), EPS);
-	}
-
-	@Test
-	public void testGetWeightedError() {
-		assertEquals(1.66666666666666,weightedVote.getWeightedError(), EPS);
-	}
-
-	@Test
-	public void testGetWeights() {
-		double [][] weights=weightedVote.getWeights();
-		assertEquals(1.0/3,weights[0][0], EPS);
-		assertEquals(1.0/3,weights[1][0], EPS);
-		assertEquals(1.0/3,weights[2][0], EPS);
-		
-		assertEquals(1.0/3,weights[0][1], EPS);
-		assertEquals(1.0/3,weights[1][1], EPS);
-		assertEquals(1.0/3,weights[2][1], EPS);
-		
-		assertEquals(1,weights[0][2], EPS);
-		assertEquals(0,weights[1][2], EPS);
-		assertEquals(0,weights[2][2], EPS);
-		
-		assertEquals(1.0/3,weights[0][3], EPS);
-		assertEquals(1.0/3,weights[1][3], EPS);
-		assertEquals(1.0/3,weights[2][3], EPS);
-	}
-
-	@Test
-	public void testGetNumberVotes() {
-		assertEquals(3,weightedVote.getNumberVotes(0));
-	}
-
-	@Test
-	public void testGetNumberVotesInt() {
-		assertEquals(3, weightedVote.getNumberVotes(0));
-		assertEquals(3, weightedVote.getNumberVotes(1));
-		assertEquals(1, weightedVote.getNumberVotes(2));
-		assertEquals(3, weightedVote.getNumberVotes(3));
-	}
-
-	@Test
-	public void testGetOutputAttributesErrors() {
-		double [] errors=weightedVote.getOutputAttributesErrors();
-		assertEquals(8.0/3, errors[0],EPS);
-		assertEquals(5.0/3, errors[1],EPS);
-		assertEquals(2, errors[2],EPS);
-		assertEquals(1.0/3, errors[3],EPS);
-		
-	}
-
-}
diff --git a/moa/src/test/java/moa/classifiers/rules/multilabel/errormeasurers/RelativeMeanAbsoluteDeviationMTTest.java b/moa/src/test/java/moa/classifiers/rules/multilabel/errormeasurers/RelativeMeanAbsoluteDeviationMTTest.java
deleted file mode 100644
index 7dd7a9b7f..000000000
--- a/moa/src/test/java/moa/classifiers/rules/multilabel/errormeasurers/RelativeMeanAbsoluteDeviationMTTest.java
+++ /dev/null
@@ -1,80 +0,0 @@
-package moa.classifiers.rules.multilabel.errormeasurers;
-
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-
-public class RelativeMeanAbsoluteDeviationMTTest {
-	static protected MultiTargetErrorMeasurer m; 
-
-	@BeforeClass
-	public static void setUpBeforeClass() throws Exception {
-		m= new RelativeMeanAbsoluteDeviationMT();
-		Prediction trueTarget=new MultiLabelClassificationPrediction(3);
-		Prediction prediction=new MultiLabelClassificationPrediction(3);
-		prediction.setVote(0,0,4);
-		prediction.setVote(1,0,50);
-		prediction.setVote(2,0,-80);
-		trueTarget.setVote(0,0,3);
-		trueTarget.setVote(1,0,30);
-		trueTarget.setVote(2,0,-100);
-		m.addPrediction(prediction, trueTarget);
-		
-		trueTarget=new MultiLabelClassificationPrediction(3);
-		prediction=new MultiLabelClassificationPrediction(3);
-		prediction.setVote(0,0,3);
-		prediction.setVote(1,0,2);
-		prediction.setVote(2,0,-80);
-		trueTarget.setVote(0,0,2);
-		trueTarget.setVote(1,0,12);
-		trueTarget.setVote(2,0,-75);
-		m.addPrediction(prediction, trueTarget);
-		
-		trueTarget=new MultiLabelClassificationPrediction(3);
-		prediction=new MultiLabelClassificationPrediction(3);
-		prediction.setVote(0,0,9);
-		prediction.setVote(1,0,-40);
-		prediction.setVote(2,0,-80);
-		trueTarget.setVote(0,0,3);
-		trueTarget.setVote(1,0,-50);
-		trueTarget.setVote(2,0,-50);
-		m.addPrediction(prediction, trueTarget);
-		
-		trueTarget=new MultiLabelClassificationPrediction(3);
-		prediction=new MultiLabelClassificationPrediction(3);
-
-		prediction.setVote(0,0,-8);
-		prediction.setVote(1,0,30);
-		prediction.setVote(2,0,-80);
-		trueTarget.setVote(0,0,-4);
-		trueTarget.setVote(1,0,40);
-		trueTarget.setVote(2,0,-80);
-		m.addPrediction(prediction, trueTarget);
-	}
-
-
-	@Test
-	public void testGetCurrentError() {
-		assertEquals(0.9111995717892043, m.getCurrentError(), 0.0000001);
-	}
-
-	@Test
-	public void testGetCurrentErrorInt() {
-		assertEquals(0.7116760869790253, m.getCurrentError(0), 0.0000001);
-		assertEquals(0.5077398163068827, m.getCurrentError(1), 0.0000001);
-		assertEquals(1.5141828120817051, m.getCurrentError(2), 0.0000001);
-	}
-
-	@Test
-	public void testGetCurrentErrors() {
-		assertArrayEquals(new double []{0.7116760869790253,0.5077398163068827,1.5141828120817051}, m.getCurrentErrors(), 0.0000001);
-	}
-
-
-}
diff --git a/moa/src/test/java/moa/classifiers/rules/multilabel/errormeasurers/RelativeRootMeanSquaredErrorMTTest.java b/moa/src/test/java/moa/classifiers/rules/multilabel/errormeasurers/RelativeRootMeanSquaredErrorMTTest.java
deleted file mode 100644
index 2dacce2b2..000000000
--- a/moa/src/test/java/moa/classifiers/rules/multilabel/errormeasurers/RelativeRootMeanSquaredErrorMTTest.java
+++ /dev/null
@@ -1,76 +0,0 @@
-package moa.classifiers.rules.multilabel.errormeasurers;
-
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-
-public class RelativeRootMeanSquaredErrorMTTest {
-	static protected MultiTargetErrorMeasurer m; 
-
-	@BeforeClass
-	public static void setUpBeforeClass() throws Exception {
-		m= new RelativeRootMeanSquaredErrorMT();
-		Prediction trueTarget=new MultiLabelClassificationPrediction(3);
-		Prediction prediction=new MultiLabelClassificationPrediction(3);
-		prediction.setVote(0,0,4);
-		prediction.setVote(1,0,50);
-		prediction.setVote(2,0,-80);
-		trueTarget.setVote(0,0,3);
-		trueTarget.setVote(1,0,30);
-		trueTarget.setVote(2,0,-100);
-		m.addPrediction(prediction, trueTarget);
-		
-		trueTarget=new MultiLabelClassificationPrediction(3);
-		prediction=new MultiLabelClassificationPrediction(3);
-		prediction.setVote(0,0,3);
-		prediction.setVote(1,0,2);
-		prediction.setVote(2,0,-80);
-		trueTarget.setVote(0,0,2);
-		trueTarget.setVote(1,0,12);
-		trueTarget.setVote(2,0,-75);
-		m.addPrediction(prediction, trueTarget);
-		
-		trueTarget=new MultiLabelClassificationPrediction(3);
-		prediction=new MultiLabelClassificationPrediction(3);
-		prediction.setVote(0,0,9);
-		prediction.setVote(1,0,-40);
-		prediction.setVote(2,0,-80);
-		trueTarget.setVote(0,0,3);
-		trueTarget.setVote(1,0,-50);
-		trueTarget.setVote(2,0,-50);
-		m.addPrediction(prediction, trueTarget);
-		
-		trueTarget=new MultiLabelClassificationPrediction(3);
-		prediction=new MultiLabelClassificationPrediction(3);
-
-		prediction.setVote(0,0,-8);
-		prediction.setVote(1,0,30);
-		prediction.setVote(2,0,-80);
-		trueTarget.setVote(0,0,-4);
-		trueTarget.setVote(1,0,40);
-		trueTarget.setVote(2,0,-80);
-		m.addPrediction(prediction, trueTarget);
-	}
-	@Test
-	public void testGetCurrentError() {
-		assertEquals(0.9402350854416155, m.getCurrentError(), 0.0000001);
-	}
-
-	@Test
-	public void testGetCurrentErrorInt() {
-		assertEquals(0.664202694282111, m.getCurrentError(0), 0.0000001);
-		assertEquals(0.5147167180492306, m.getCurrentError(1), 0.0000001);
-		assertEquals(1.641785843993505, m.getCurrentError(2), 0.0000001);
-	}
-
-	@Test
-	public void testGetCurrentErrors() {
-		assertArrayEquals(new double []{0.664202694282111,0.5147167180492306,1.641785843993505}, m.getCurrentErrors(), 0.0000001);
-	}
-}
diff --git a/moa/src/test/java/moa/classifiers/rules/multilabel/instancetransformers/InstanceOutputAttributesSelectorTest.java b/moa/src/test/java/moa/classifiers/rules/multilabel/instancetransformers/InstanceOutputAttributesSelectorTest.java
deleted file mode 100644
index 2170ca112..000000000
--- a/moa/src/test/java/moa/classifiers/rules/multilabel/instancetransformers/InstanceOutputAttributesSelectorTest.java
+++ /dev/null
@@ -1,71 +0,0 @@
-package moa.classifiers.rules.multilabel.instancetransformers;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import com.yahoo.labs.samoa.instances.Instance;
-import com.yahoo.labs.samoa.instances.InstancesHeader;
-import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
-import com.yahoo.labs.samoa.instances.predictions.Prediction;
-
-import moa.streams.ArffFileStream;
-import moa.streams.MultiTargetArffFileStream;
-
-public class InstanceOutputAttributesSelectorTest {
-	private static Instance instance1, instance2, transformed1, transformed2;
-	private static double EPS=0.00000001;
-	private static InstanceOutputAttributesSelector transformer;
-	@BeforeClass
-	public static void setUpBeforeClass() throws Exception {
-        ArffFileStream stream =  new ArffFileStream(ClassLoader.getSystemResource("moa/classifiers/data/small_regression.arff").getPath(), "4-6");
-		instance1=stream.nextInstance().getData();
-		instance2=stream.nextInstance().getData();
-		transformer= new InstanceOutputAttributesSelector(new InstancesHeader(instance1.dataset()), new int[]{0,2});
-		transformed1=transformer.sourceInstanceToTarget(instance1);
-		transformed2=transformer.sourceInstanceToTarget(instance2);
-	}
-	@Test
-	public void sourceInstanceToTarget() {
-		assertEquals(1,transformed1.valueOutputAttribute(0), EPS);
-		assertEquals(3,transformed1.valueOutputAttribute(1), EPS);
-		assertEquals(1.1,transformed1.valueInputAttribute(0), EPS);
-		assertEquals(-2.3,transformed1.valueInputAttribute(1), EPS);
-		assertEquals(2,transformed1.valueInputAttribute(2), EPS);
-		assertEquals(3.3,transformed1.valueInputAttribute(3), EPS);
-		assertEquals(0,transformed1.valueInputAttribute(4), EPS);
-		
-		assertEquals(1.2,transformed2.valueInputAttribute(0), EPS);
-		assertEquals(-2.2,transformed2.valueInputAttribute(1), EPS);
-		assertEquals(0,transformed2.valueInputAttribute(2), EPS);
-		assertEquals(3.2,transformed2.valueInputAttribute(3), EPS);
-		assertEquals(0,transformed2.valueInputAttribute(4), EPS);
-		
-		assertEquals(3,transformed2.valueOutputAttribute(0), EPS);
-		assertEquals(2, transformed2.valueOutputAttribute(1), EPS);
-	}
-
-	@Test
-	public void testTargetPredictionToSource() {
-		Prediction targetPred = new MultiLabelClassificationPrediction(2);
-		targetPred.setVotes(new double []{0.5, 1.5});
-		
-		assertEquals(0.5, targetPred.getVotes()[0], EPS);
-		assertEquals(1.5, targetPred.getVotes()[1], EPS);
-	}
-	
-	@Test
-	public void testNumInputs() {
-		assertEquals(5, transformed1.numInputAttributes(), EPS);
-		assertEquals(5, transformed2.numInputAttributes(), EPS);
-	}
-	
-	@Test
-	public void testNumOutputs() {
-		assertEquals(2, transformed1.numOutputAttributes(), EPS);
-		assertEquals(2, transformed2.numOutputAttributes(), EPS);
-	}
-
-}
diff --git a/moa/src/test/java/moa/classifiers/trees/ASHoeffdingTreeTest.java b/moa/src/test/java/moa/classifiers/trees/ASHoeffdingTreeTest.java
deleted file mode 100644
index 7718237a6..000000000
--- a/moa/src/test/java/moa/classifiers/trees/ASHoeffdingTreeTest.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * ASHoeffdingTreeTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.trees;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the ASHoeffdingTree classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class ASHoeffdingTreeTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public ASHoeffdingTreeTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new ASHoeffdingTree(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(ASHoeffdingTreeTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
-
diff --git a/moa/src/test/java/moa/classifiers/trees/AdaHoeffdingOptionTreeTest.java b/moa/src/test/java/moa/classifiers/trees/AdaHoeffdingOptionTreeTest.java
deleted file mode 100644
index 6e32bc4fc..000000000
--- a/moa/src/test/java/moa/classifiers/trees/AdaHoeffdingOptionTreeTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * AdaHoeffdingOptionTreeTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.trees;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the AdaHoeffdingOptionTree classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class AdaHoeffdingOptionTreeTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public AdaHoeffdingOptionTreeTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new AdaHoeffdingOptionTree(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(AdaHoeffdingOptionTreeTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/trees/DecisionStumpTest.java b/moa/src/test/java/moa/classifiers/trees/DecisionStumpTest.java
deleted file mode 100644
index ae8491e64..000000000
--- a/moa/src/test/java/moa/classifiers/trees/DecisionStumpTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * DecisionStumpTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.trees;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the DecisionStump classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class DecisionStumpTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public DecisionStumpTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new DecisionStump(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(DecisionStumpTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/trees/EFDTTest.java b/moa/src/test/java/moa/classifiers/trees/EFDTTest.java
deleted file mode 100644
index 0e96f85ca..000000000
--- a/moa/src/test/java/moa/classifiers/trees/EFDTTest.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/*
- * EFDTTest.java
- * Copyright (C) 2019 University of Waikato, Hamilton, NZ
- */
-
-package moa.classifiers.trees;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractMultipleClassifierTestCase;
-import moa.classifiers.Classifier;
-
-/**
- * Tests the EFDT classifier.
- *
- * @author Corey Sterling (csterlin at waikato dot ac dot nz)
- */
-public class EFDTTest
-  extends AbstractMultipleClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public EFDTTest(String name) {
-    super(name);
-    this.setNumberTests(2);
-  }
-
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getRegressionClassifierSetups() {
-    EFDT[]	result;
-    result    = new EFDT[2];
-    result[0] = new EFDT();
-    result[1] = new EFDT();
-    result[1].tieThresholdOption.setValue(0.2);
-
-    return result;
-  }
-
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(EFDTTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/trees/FIMTDDTest.java b/moa/src/test/java/moa/classifiers/trees/FIMTDDTest.java
deleted file mode 100644
index 725f0a8b1..000000000
--- a/moa/src/test/java/moa/classifiers/trees/FIMTDDTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * FIMTDDTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.trees;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractRegressorTestCase;
-import moa.learners.Regressor;
-
-/**
- * Tests the FIMTDD classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class FIMTDDTest extends AbstractRegressorTestCase {  
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public FIMTDDTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Regressor[] getLearnerSetups() {
-    return new Regressor[]{
-	new FIMTDD(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(FIMTDDTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
-
diff --git a/moa/src/test/java/moa/classifiers/trees/HoeffdingAdaptiveTreeTest.java b/moa/src/test/java/moa/classifiers/trees/HoeffdingAdaptiveTreeTest.java
deleted file mode 100644
index 29d07077b..000000000
--- a/moa/src/test/java/moa/classifiers/trees/HoeffdingAdaptiveTreeTest.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * HoeffdingAdaptiveTreeTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.trees;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the HoeffdingAdaptiveTree classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class HoeffdingAdaptiveTreeTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public HoeffdingAdaptiveTreeTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new HoeffdingAdaptiveTree(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(HoeffdingAdaptiveTreeTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
-
diff --git a/moa/src/test/java/moa/classifiers/trees/HoeffdingOptionTreeTest.java b/moa/src/test/java/moa/classifiers/trees/HoeffdingOptionTreeTest.java
deleted file mode 100644
index b341810f9..000000000
--- a/moa/src/test/java/moa/classifiers/trees/HoeffdingOptionTreeTest.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * HoeffdingOptionTreeTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.trees;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the HoeffdingOptionTree classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class HoeffdingOptionTreeTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public HoeffdingOptionTreeTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new HoeffdingOptionTree(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(HoeffdingOptionTreeTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
-
diff --git a/moa/src/test/java/moa/classifiers/trees/HoeffdingTreeTest.java b/moa/src/test/java/moa/classifiers/trees/HoeffdingTreeTest.java
deleted file mode 100644
index b438b5d40..000000000
--- a/moa/src/test/java/moa/classifiers/trees/HoeffdingTreeTest.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * HoeffdingTreeTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.trees;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the HoeffdingTree classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class HoeffdingTreeTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public HoeffdingTreeTest(String name) {
-    super(name);
-    this.setNumberTests(2);
-  }
-
-  
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    HoeffdingTree[]	result;
-    result    = new HoeffdingTree[2];
-    result[0] = new HoeffdingTree();
-    result[1] = new HoeffdingTree();
-    result[1].tieThresholdOption.setValue(0.2);
-    
-    return result;
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(HoeffdingTreeTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
diff --git a/moa/src/test/java/moa/classifiers/trees/LimAttHoeffdingTreeTest.java b/moa/src/test/java/moa/classifiers/trees/LimAttHoeffdingTreeTest.java
deleted file mode 100644
index a4bec5b94..000000000
--- a/moa/src/test/java/moa/classifiers/trees/LimAttHoeffdingTreeTest.java
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * LimAttHoeffdingTreeTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.trees;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the LimAttHoeffdingTree classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class LimAttHoeffdingTreeTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public LimAttHoeffdingTreeTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    LimAttHoeffdingTree[]	result;
-    result    = new LimAttHoeffdingTree[1];
-    result[0] = new LimAttHoeffdingTree();  
-    result[0].setlistAttributes(new int[]{1,2});
-    return result;
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(LimAttHoeffdingTreeTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
-
diff --git a/moa/src/test/java/moa/classifiers/trees/ORTOTest.java b/moa/src/test/java/moa/classifiers/trees/ORTOTest.java
deleted file mode 100644
index a612f6e8f..000000000
--- a/moa/src/test/java/moa/classifiers/trees/ORTOTest.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * ORTOTest.java
- * Copyright (C) 2014 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.trees;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractRegressorTestCase;
-import moa.learners.Regressor;
-
-/**
- * Tests the ORTO classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class ORTOTest
-  extends AbstractRegressorTestCase {  
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public ORTOTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Regressor[] getLearnerSetups() {
-    return new Regressor[]{
-	new ORTO(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(ORTOTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
-
diff --git a/moa/src/test/java/moa/classifiers/trees/RandomHoeffdingTreeTest.java b/moa/src/test/java/moa/classifiers/trees/RandomHoeffdingTreeTest.java
deleted file mode 100644
index c03a3d5b8..000000000
--- a/moa/src/test/java/moa/classifiers/trees/RandomHoeffdingTreeTest.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * RandomHoeffdingTreeTest.java
- * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
- */
-package moa.classifiers.trees;
-
-import junit.framework.Test;
-import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
-
-/**
- * Tests the RandomHoeffdingTree classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
- * @version $Revision$
- */
-public class RandomHoeffdingTreeTest
-  extends AbstractClassifierTestCase {
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public RandomHoeffdingTreeTest(String name) {
-    super(name);
-    this.setNumberTests(1);
-  }
-
-  /**
-   * Returns the classifier setups to use in the regression test.
-   *
-   * @return		the setups
-   */
-  @Override
-  protected Classifier[] getLearnerSetups() {
-    return new Classifier[]{
-	new RandomHoeffdingTree(),
-    };
-  }
-  
-  /**
-   * Returns a test suite.
-   *
-   * @return		the test suite
-   */
-  public static Test suite() {
-    return new TestSuite(RandomHoeffdingTreeTest.class);
-  }
-
-  /**
-   * Runs the test from commandline.
-   *
-   * @param args	ignored
-   */
-  public static void main(String[] args) {
-    runTest(suite());
-  }
-}
-
diff --git a/moa/src/test/java/moa/integration/SimpleClusterTest.java b/moa/src/test/java/moa/integration/SimpleClusterTest.java
index 182aa0813..50d1090cf 100644
--- a/moa/src/test/java/moa/integration/SimpleClusterTest.java
+++ b/moa/src/test/java/moa/integration/SimpleClusterTest.java
@@ -19,153 +19,158 @@
 /* test that all clusterers run, i.e., do not die on simpe input **/
 public class SimpleClusterTest extends TestCase {
 
-	final static String [] Clusterers = new String[]{"ClusterGenerator", "CobWeb", "KMeans", 
-		"clustream.Clustream", "clustree.ClusTree", "denstream.WithDBSCAN -i 1000", "streamkm.StreamKM"};
-	
+	final static String[] Clusterers = new String[] { "ClusterGenerator", "CobWeb", "KMeans", "clustream.Clustream",
+			"clustree.ClusTree", "denstream.WithDBSCAN -i 1000", "streamkm.StreamKM" };
+
 	@Test
-	public void testClusterGenerator(){testClusterer(Clusterers[0]);}
+	public void testClusterGenerator() {
+		testClusterer(Clusterers[0]);
+	}
+
 //	@Test
 //	public void testCobWeb(){testClusterer(Clusterers[1]);}
 	@Test
-	public void testClustream(){testClusterer(Clusterers[3]);}
+	public void testClustream() {
+		testClusterer(Clusterers[3]);
+	}
+
 	@Test
-	public void testClusTree(){testClusterer(Clusterers[4]);}
+	public void testClusTree() {
+		testClusterer(Clusterers[4]);
+	}
+
 	@Test
-	public void testDenStream(){testClusterer(Clusterers[5]);}
+	public void testDenStream() {
+		testClusterer(Clusterers[5]);
+	}
+
 	@Test
-	public void testStreamKM(){testClusterer(Clusterers[6]);}
-	
+	public void testStreamKM() {
+		testClusterer(Clusterers[6]);
+	}
+
 	void testClusterer(String clusterer) {
 		System.out.println("Processing: " + clusterer);
 		try {
-			doTask(new String[]{"moa.tasks.clustering.EvaluateClustering -l " + clusterer});
+			doTask(new String[] { "moa.tasks.clustering.EvaluateClustering -l " + clusterer });
 		} catch (Exception e) {
 			assertTrue("Failed on clusterer " + clusterer + ": " + e.getMessage(), false);
 		}
 	}
-	
-	// code copied from moa.DoTask.main, to allow exceptions to be thrown in case of failure
-	public void doTask(String [] args) throws Exception {
-        if (args.length < 1) {
-            System.out.println();
-            System.out.println(Globals.getWorkbenchInfoString());
-            System.out.println();
-            System.out.println("No task specified.");
-        } else {
-            if (moa.DoTask.isJavaVersionOK() == false ) {//|| moa.DoTask.isWekaVersionOK() == false) {
-                return;
-            }
-            // create standard options
-            FlagOption suppressStatusOutputOption = new FlagOption(
-                    "suppressStatusOutput", 'S',
-                    "Suppress the task status output that is normally send to stderr.");
-            FlagOption suppressResultOutputOption = new FlagOption(
-                    "suppressResultOutput", 'R',
-                    "Suppress the task result output that is normally send to stdout.");
-            IntOption statusUpdateFrequencyOption = new IntOption(
-                    "statusUpdateFrequency",
-                    'F',
-                    "How many milliseconds to wait between status updates.",
-                    1000, 0, Integer.MAX_VALUE);
-            Option[] extraOptions = new Option[]{
-                suppressStatusOutputOption, suppressResultOutputOption,
-                statusUpdateFrequencyOption};
-            // build a single string by concatenating cli options
-            StringBuilder cliString = new StringBuilder();
-            for (int i = 0; i < args.length; i++) {
-                cliString.append(" ").append(args[i]);
-            }
-            // parse options
-            Task task = (Task) ClassOption.cliStringToObject(cliString.toString(), Task.class, extraOptions);
-            
-            StringBuilder sb = new StringBuilder();
-            task.getDescription(sb, 4);
-            System.out.println(sb.toString());
-            
-            
-            Object result = null;
-            if (suppressStatusOutputOption.isSet()) {
-                result = task.doTask();
-            } else {
-                System.out.println();
-                System.out.println(Globals.getWorkbenchInfoString());
-                System.out.println();
-                boolean preciseTiming = TimingUtils.enablePreciseTiming();
-                // start the task thread
-                TaskThread taskThread = new TaskThread(task);
-                taskThread.start();
-                int progressAnimIndex = 0;
-                // inform user of progress
-                while (!taskThread.isComplete()) {
-                    StringBuilder progressLine = new StringBuilder();
-                    progressLine.append(moa.DoTask.progressAnimSequence[progressAnimIndex]);
-                    progressLine.append(' ');
-                    progressLine.append(StringUtils.secondsToDHMSString(taskThread.getCPUSecondsElapsed()));
-                    progressLine.append(" [");
-                    progressLine.append(taskThread.getCurrentStatusString());
-                    progressLine.append("] ");
-                    double fracComplete = taskThread.getCurrentActivityFracComplete();
-                    if (fracComplete >= 0.0) {
-                        progressLine.append(StringUtils.doubleToString(
-                                fracComplete * 100.0, 2, 2));
-                        progressLine.append("% ");
-                    }
-                    progressLine.append(taskThread.getCurrentActivityString());
-                    while (progressLine.length() < moa.DoTask.MAX_STATUS_STRING_LENGTH) {
-                        progressLine.append(" ");
-                    }
-                    if (progressLine.length() > moa.DoTask.MAX_STATUS_STRING_LENGTH) {
-                        progressLine.setLength(moa.DoTask.MAX_STATUS_STRING_LENGTH);
-                        progressLine.setCharAt(
-                        		moa.DoTask.MAX_STATUS_STRING_LENGTH - 1, '~');
-                    }
-                    System.out.print(progressLine.toString());
-                    System.out.print('\r');
-                    if (++progressAnimIndex >= moa.DoTask.progressAnimSequence.length) {
-                        progressAnimIndex = 0;
-                    }
-                    try {
-                        Thread.sleep(statusUpdateFrequencyOption.getValue());
-                    } catch (InterruptedException ignored) {
-                        // wake up
-                    }
-                }
-                StringBuilder cleanupString = new StringBuilder();
-                for (int i = 0; i < moa.DoTask.MAX_STATUS_STRING_LENGTH; i++) {
-                    cleanupString.append(' ');
-                }
-                System.out.println(cleanupString);
-                result = taskThread.getFinalResult();
-                if (!(result instanceof FailedTaskReport)) {
-                    System.out.print("Task completed in "
-                            + StringUtils.secondsToDHMSString(taskThread.getCPUSecondsElapsed()));
-                    if (preciseTiming) {
-                        System.out.print(" (CPU time)");
-                    }
-                    System.out.println();
-                    System.out.println();
-                }
-            }
-            
-            if (result instanceof FailedTaskReport) {
-                System.out.println("Task failed. Reason: ");
-                ((FailedTaskReport) result).getFailureReason().printStackTrace();
-                throw new Exception(((FailedTaskReport) result).getFailureReason());
-            } else {
-                if (!suppressResultOutputOption.isSet()) {
-                    if (result instanceof Measurement[]) {
-                        sb = new StringBuilder();
-                        Measurement.getMeasurementsDescription(
-                                (Measurement[]) result, sb, 0);
-                        System.out.println(sb.toString());
-                    } else {
-                        System.out.println(result);
-                    }
-                    System.out.flush();
-                }
-            }
-        }
+
+	// code copied from moa.DoTask.main, to allow exceptions to be thrown in case of
+	// failure
+	public void doTask(String[] args) throws Exception {
+		if (args.length < 1) {
+			System.out.println();
+			System.out.println(Globals.getWorkbenchInfoString());
+			System.out.println();
+			System.out.println("No task specified.");
+		} else {
+			if (moa.DoTask.isJavaVersionOK() == false) {// || moa.DoTask.isWekaVersionOK() == false) {
+				return;
+			}
+			// create standard options
+			FlagOption suppressStatusOutputOption = new FlagOption("suppressStatusOutput", 'S',
+					"Suppress the task status output that is normally send to stderr.");
+			FlagOption suppressResultOutputOption = new FlagOption("suppressResultOutput", 'R',
+					"Suppress the task result output that is normally send to stdout.");
+			IntOption statusUpdateFrequencyOption = new IntOption("statusUpdateFrequency", 'F',
+					"How many milliseconds to wait between status updates.", 1000, 0, Integer.MAX_VALUE);
+			Option[] extraOptions = new Option[] { suppressStatusOutputOption, suppressResultOutputOption,
+					statusUpdateFrequencyOption };
+			// build a single string by concatenating cli options
+			StringBuilder cliString = new StringBuilder();
+			for (int i = 0; i < args.length; i++) {
+				cliString.append(" ").append(args[i]);
+			}
+			// parse options
+			Task task = (Task) ClassOption.cliStringToObject(cliString.toString(), Task.class, extraOptions);
+
+			StringBuilder sb = new StringBuilder();
+			task.getDescription(sb, 4);
+			System.out.println(sb.toString());
+
+			Object result = null;
+			if (suppressStatusOutputOption.isSet()) {
+				result = task.doTask();
+			} else {
+				System.out.println();
+				System.out.println(Globals.getWorkbenchInfoString());
+				System.out.println();
+				boolean preciseTiming = TimingUtils.enablePreciseTiming();
+				// start the task thread
+				TaskThread taskThread = new TaskThread(task);
+				taskThread.start();
+				int progressAnimIndex = 0;
+				// inform user of progress
+				while (!taskThread.isComplete()) {
+					StringBuilder progressLine = new StringBuilder();
+					progressLine.append(moa.DoTask.progressAnimSequence[progressAnimIndex]);
+					progressLine.append(' ');
+					progressLine.append(StringUtils.secondsToDHMSString(taskThread.getCPUSecondsElapsed()));
+					progressLine.append(" [");
+					progressLine.append(taskThread.getCurrentStatusString());
+					progressLine.append("] ");
+					double fracComplete = taskThread.getCurrentActivityFracComplete();
+					if (fracComplete >= 0.0) {
+						progressLine.append(StringUtils.doubleToString(fracComplete * 100.0, 2, 2));
+						progressLine.append("% ");
+					}
+					progressLine.append(taskThread.getCurrentActivityString());
+					while (progressLine.length() < moa.DoTask.MAX_STATUS_STRING_LENGTH) {
+						progressLine.append(" ");
+					}
+					if (progressLine.length() > moa.DoTask.MAX_STATUS_STRING_LENGTH) {
+						progressLine.setLength(moa.DoTask.MAX_STATUS_STRING_LENGTH);
+						progressLine.setCharAt(moa.DoTask.MAX_STATUS_STRING_LENGTH - 1, '~');
+					}
+					System.out.print(progressLine.toString());
+					System.out.print('\r');
+					if (++progressAnimIndex >= moa.DoTask.progressAnimSequence.length) {
+						progressAnimIndex = 0;
+					}
+					try {
+						Thread.sleep(statusUpdateFrequencyOption.getValue());
+					} catch (InterruptedException ignored) {
+						// wake up
+					}
+				}
+				StringBuilder cleanupString = new StringBuilder();
+				for (int i = 0; i < moa.DoTask.MAX_STATUS_STRING_LENGTH; i++) {
+					cleanupString.append(' ');
+				}
+				System.out.println(cleanupString);
+				result = taskThread.getFinalResult();
+				if (!(result instanceof FailedTaskReport)) {
+					System.out.print(
+							"Task completed in " + StringUtils.secondsToDHMSString(taskThread.getCPUSecondsElapsed()));
+					if (preciseTiming) {
+						System.out.print(" (CPU time)");
+					}
+					System.out.println();
+					System.out.println();
+				}
+			}
+
+			if (result instanceof FailedTaskReport) {
+				System.out.println("Task failed. Reason: ");
+				((FailedTaskReport) result).getFailureReason().printStackTrace();
+				throw new Exception(((FailedTaskReport) result).getFailureReason());
+			} else {
+				if (!suppressResultOutputOption.isSet()) {
+					if (result instanceof Measurement[]) {
+						sb = new StringBuilder();
+						Measurement.getMeasurementsDescription((Measurement[]) result, sb, 0);
+						System.out.println(sb.toString());
+					} else {
+						System.out.println(result);
+					}
+					System.out.flush();
+				}
+			}
+		}
 
 	}
-	
+
 }
diff --git a/moa/src/test/java/moa/learners/predictors/AbstractClassifierTestCase.java b/moa/src/test/java/moa/learners/predictors/AbstractClassifierTestCase.java
new file mode 100644
index 000000000..5d250ffee
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/AbstractClassifierTestCase.java
@@ -0,0 +1,149 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/**
+ * AbstractMultipleClassifierTestCase.java Copyright (C) 2013 University of Waikato, Hamilton, New
+ * Zealand
+ */
+package moa.learners.predictors;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.core.Example;
+import moa.evaluation.evaluators.BasicClassificationPerformanceEvaluator;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
+import moa.learners.predictors.Classifier;
+
+/**
+ * Ancestor that defines a setting to test a classifier several times with
+ * different parameters using this predefined same setting.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public abstract class AbstractClassifierTestCase extends AbstractInstanceLearnerTestCase<Classifier> {
+
+	protected int numberTests = 1;
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public AbstractClassifierTestCase(String name) {
+		super(name);
+	}
+
+	/**
+	 * Sets the number of tests to run with this classifier.
+	 *
+	 * @param name        the name of the test
+	 * @param numberTests the numbers of tests to run
+	 */
+
+	public void setNumberTests(int numberTests) {
+		this.numberTests = numberTests;
+	}
+
+	/**
+	 * Called by JUnit before each test method.
+	 *
+	 * @throws Exception if an error occurs.
+	 */
+	@Override
+	protected void setUp() throws Exception {
+		super.setUp();
+
+		m_TestHelper.copyResourceToTmp("classification.arff");
+	}
+
+	/**
+	 * Called by JUnit after each test method.
+	 *
+	 * @throws Exception if tear-down fails
+	 */
+	@Override
+	protected void tearDown() throws Exception {
+		m_TestHelper.deleteFileFromTmp("classification.arff");
+
+		super.tearDown();
+	}
+
+	/**
+	 * Returns the filenames (without path) of the input data files to use in the
+	 * regression test.
+	 *
+	 * @return the filenames
+	 */
+	@Override
+	protected String[] getRegressionInputFiles() {
+		String value = "classification.arff";
+		String[] ret = new String[this.numberTests];
+		for (int i = 0; i < this.numberTests; i++) {
+			ret[i] = value;
+		}
+		return ret;
+	}
+
+	/**
+	 * Returns the class index for the datasets.
+	 *
+	 * @return the class indices (0-based)
+	 */
+	@Override
+	protected int[] getRegressionInputClassIndex() {
+		int value = 10;
+		int[] ret = new int[this.numberTests];
+		for (int i = 0; i < this.numberTests; i++) {
+			ret[i] = value;
+		}
+		return ret;
+	}
+
+	/**
+	 * Returns the index of the instances in the stream to inspect the
+	 * performance/classification output of the classifiers.
+	 *
+	 * @return the inspection indices
+	 */
+	@Override
+	protected int[][] getRegressionInspectionPoints() {
+		int[] value = new int[] { 10000, 20000, 30000, 40000, 50000, 60000, 70000, 80000, 90000, 100000 };
+		int[][] ret = new int[this.numberTests][value.length];
+		for (int i = 0; i < this.numberTests; i++) {
+			ret[i] = value.clone();
+		}
+		return ret;
+	}
+
+	/**
+	 * Returns the evaluator setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected LearningPerformanceEvaluator<Example<Instance>>[] getRegressionEvaluatorSetups() {
+		LearningPerformanceEvaluator<Example<Instance>> value = new BasicClassificationPerformanceEvaluator();
+		LearningPerformanceEvaluator<Example<Instance>>[] ret = new BasicClassificationPerformanceEvaluator[this.numberTests];
+		for (int i = 0; i < this.numberTests; i++) {
+			ret[i] = (LearningPerformanceEvaluator<Example<Instance>>) value.copy();
+		}
+		return ret;
+	}
+
+	@Override
+	public Classifier copySetup(Classifier setup) {
+		return (Classifier) setup.copy();
+	}
+}
diff --git a/moa/src/test/java/moa/classifiers/AbstractInstanceLearnerTestCase.java b/moa/src/test/java/moa/learners/predictors/AbstractInstanceLearnerTestCase.java
similarity index 69%
rename from moa/src/test/java/moa/classifiers/AbstractInstanceLearnerTestCase.java
rename to moa/src/test/java/moa/learners/predictors/AbstractInstanceLearnerTestCase.java
index fed8a0d12..39c35a5d4 100644
--- a/moa/src/test/java/moa/classifiers/AbstractInstanceLearnerTestCase.java
+++ b/moa/src/test/java/moa/learners/predictors/AbstractInstanceLearnerTestCase.java
@@ -17,7 +17,7 @@
  * AbstractClassifierTestCase.java
  * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
  */
-package moa.classifiers;
+package moa.learners.predictors;
 
 import java.io.BufferedReader;
 import java.io.FileInputStream;
@@ -31,8 +31,8 @@
 import moa.core.Example;
 import moa.core.InstanceExample;
 import moa.core.Measurement;
-import moa.evaluation.LearningPerformanceEvaluator;
-import moa.learners.InstanceLearner;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
+import moa.learners.predictors.InstanceLearner;
 import moa.test.AbstractTestHelper;
 import moa.test.MoaTestCase;
 import moa.test.TestHelper;
@@ -41,17 +41,17 @@
 
 /**
  * Ancestor for all classifier test cases.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
  * @version $Revision$
  */
 public abstract class AbstractInstanceLearnerTestCase<MLTask extends InstanceLearner> extends MoaTestCase {
 
 	/**
-	 * Container for the data collected from a classifier at a specified
-	 * inspection point in the stream.
-	 * 
-	 * @author  fracpete (fracpete at waikato dot ac dot nz)
+	 * Container for the data collected from a classifier at a specified inspection
+	 * point in the stream.
+	 *
+	 * @author fracpete (fracpete at waikato dot ac dot nz)
 	 * @version $Revision$
 	 */
 	public static class InspectionData {
@@ -70,13 +70,13 @@ public static class InspectionData {
 
 		/**
 		 * Returns the container data as string.
-		 * 
-		 * @return		the string representation
+		 *
+		 * @return the string representation
 		 */
 		@Override
 		public String toString() {
-			StringBuilder	result;
-			int		i;
+			StringBuilder result;
+			int i;
 
 			result = new StringBuilder();
 
@@ -88,11 +88,11 @@ public String toString() {
 				result.append("  " + i + ": " + MoaTestCase.doubleToString(votes[i], 8) + "\n");
 
 			result.append("Measurements\n");
-			for (Measurement m: measurements)
+			for (Measurement m : measurements)
 				result.append("  " + m.getName() + ": " + MoaTestCase.doubleToString(m.getValue(), 8) + "\n");
 
 			result.append("Model measurements\n");
-			for (Measurement m: modelMeasurements) {
+			for (Measurement m : modelMeasurements) {
 				if (m.getName().indexOf("serialized") > -1)
 					continue;
 				result.append("  " + m.getName() + ": " + MoaTestCase.doubleToString(m.getValue(), 8) + "\n");
@@ -105,7 +105,7 @@ public String toString() {
 	/**
 	 * Constructs the test case. Called by subclasses.
 	 *
-	 * @param name 	the name of the test
+	 * @param name the name of the test
 	 */
 	public AbstractInstanceLearnerTestCase(String name) {
 		super(name);
@@ -114,33 +114,33 @@ public AbstractInstanceLearnerTestCase(String name) {
 	/**
 	 * Returns the test helper class to use.
 	 *
-	 * @return		the helper class instance
+	 * @return the helper class instance
 	 */
 	@Override
 	protected AbstractTestHelper newTestHelper() {
-		return new TestHelper(this, "moa/classifiers/data");
+		return new TestHelper(this, "moa/learners/predictors/data");
 	}
 
 	/**
 	 * Loads the data to process.
 	 *
-	 * @param filename	the filename to load (without path)
-	 * @param classIndex	the class index to use
-	 * @return		the data, null if it could not be loaded
-	 * @see		#getDataDirectory()
+	 * @param filename   the filename to load (without path)
+	 * @param classIndex the class index to use
+	 * @return the data, null if it could not be loaded
+	 * @see #getDataDirectory()
 	 */
 	protected InstancesHeader load(String filename, int classIndex) {
-		InstancesHeader	result = null;
+		InstancesHeader result = null;
 
 		try {
-			TmpFile tmp=new TmpFile(filename);
+			TmpFile tmp = new TmpFile(filename);
 			FileInputStream fileStream = new FileInputStream(tmp.getAbsolutePath());
-			Reader reader=new BufferedReader(new InputStreamReader(fileStream));
-			result = new InstancesHeader(reader,"-1");
+			Reader reader = new BufferedReader(new InputStreamReader(fileStream));
+			result = new InstancesHeader(reader, "-1");
 			result.setClassIndex(classIndex);
-			while (result.readInstance(null));
-		}
-		catch (Exception e) {
+			while (result.readInstance(null))
+				;
+		} catch (Exception e) {
 			System.err.println("Failed to load dataset: " + filename);
 			e.printStackTrace();
 			result = null;
@@ -152,17 +152,18 @@ protected InstancesHeader load(String filename, int classIndex) {
 	/**
 	 * Processes the input data and returns the inspection data.
 	 *
-	 * @param data		the data to work on
-	 * @param inspectionPoints	the inspection points
-	 * @param evaluator		the evaluator to use
-	 * @param scheme		the scheme to process the data with
-	 * @return			the processed data
+	 * @param data             the data to work on
+	 * @param inspectionPoints the inspection points
+	 * @param evaluator        the evaluator to use
+	 * @param scheme           the scheme to process the data with
+	 * @return the processed data
 	 */
-	protected InspectionData[] inspect(InstancesHeader data, int[] inspectionPoints, LearningPerformanceEvaluator<Example<Instance>>  evaluator, MLTask scheme) {
-		InspectionData[]	result;
-		int			i;
-		int			point;
-		Instance		inst;
+	protected InspectionData[] inspect(InstancesHeader data, int[] inspectionPoints,
+			LearningPerformanceEvaluator<Example<Instance>> evaluator, MLTask scheme) {
+		InspectionData[] result;
+		int i;
+		int point;
+		Instance inst;
 		Prediction votes;
 
 		result = new InspectionData[inspectionPoints.length];
@@ -175,14 +176,14 @@ protected InspectionData[] inspect(InstancesHeader data, int[] inspectionPoints,
 			if (i > 0) {
 				votes = scheme.getPredictionForInstance(inst);
 
-				evaluator.addResult((Example<Instance>)new InstanceExample(inst), votes.asDoubleArray());
+				evaluator.addResult(new InstanceExample(inst), votes.asDoubleArray());
 
 				if (point < inspectionPoints.length) {
 					if (i == inspectionPoints[point] - 1) {
-						result[point]                   = new InspectionData();
-						result[point].index             = inspectionPoints[point];
-						result[point].votes             = votes.asDoubleArray();
-						result[point].measurements      = evaluator.getPerformanceMeasurements();
+						result[point] = new InspectionData();
+						result[point].index = inspectionPoints[point];
+						result[point].votes = votes.asDoubleArray();
+						result[point].measurements = evaluator.getPerformanceMeasurements();
 						result[point].modelMeasurements = scheme.getModelMeasurements();
 						point++;
 					}
@@ -198,19 +199,19 @@ protected InspectionData[] inspect(InstancesHeader data, int[] inspectionPoints,
 	/**
 	 * Saves the data in the tmp directory.
 	 *
-	 * @param data	the data to save
-	 * @param filename	the filename to save to (without path)
-	 * @return		true if successfully saved
+	 * @param data     the data to save
+	 * @param filename the filename to save to (without path)
+	 * @return true if successfully saved
 	 */
 	protected boolean save(MLTask cls, InspectionData[] data, String filename) {
-		StringBuilder	str;
+		StringBuilder str;
 
 		str = new StringBuilder();
 
 		str.append(MOAUtils.toCommandLine(cls) + "\n");
 		str.append("\n");
 
-		for (InspectionData d: data) {
+		for (InspectionData d : data) {
 			str.append(d.toString());
 			str.append("\n");
 		}
@@ -219,62 +220,61 @@ protected boolean save(MLTask cls, InspectionData[] data, String filename) {
 	}
 
 	/**
-	 * Returns the filenames (without path) of the input data files to use
-	 * in the regression test.
+	 * Returns the filenames (without path) of the input data files to use in the
+	 * regression test.
 	 *
-	 * @return		the filenames
+	 * @return the filenames
 	 */
 	protected abstract String[] getRegressionInputFiles();
 
 	/**
 	 * Returns the class index for the datasets.
-	 * 
-	 * @return		the class indices (0-based)
+	 *
+	 * @return the class indices (0-based)
 	 */
 	protected abstract int[] getRegressionInputClassIndex();
 
 	/**
-	 * Returns the index of the instances in the stream to inspect the 
+	 * Returns the index of the instances in the stream to inspect the
 	 * performance/classification output of the classifiers.
-	 * 
-	 * @return		the inspection indices
+	 *
+	 * @return the inspection indices
 	 */
 	protected abstract int[][] getRegressionInspectionPoints();
 
 	/**
 	 * Returns the classifier setups to use in the regression test.
 	 *
-	 * @return		the setups
+	 * @return the setups
 	 */
 	protected abstract MLTask[] getLearnerSetups();
 
 	/**
 	 * Returns the evaluator setups to use in the regression test.
 	 *
-	 * @return		the setups
+	 * @return the setups
 	 */
-	protected abstract LearningPerformanceEvaluator<Example<Instance>> [] getRegressionEvaluatorSetups();
+	protected abstract LearningPerformanceEvaluator<Example<Instance>>[] getRegressionEvaluatorSetups();
 
 	/**
 	 * Creates an output filename based on the input filename.
 	 *
-	 * @param input	the input filename (no path)
-	 * @param no		the number of the test
-	 * @return		the generated output filename (no path)
+	 * @param input the input filename (no path)
+	 * @param no    the number of the test
+	 * @return the generated output filename (no path)
 	 */
 	protected String createOutputFilename(String input, int no) {
-		String	result;
-		int		index;
-		String	ext;
+		String result;
+		int index;
+		String ext;
 
 		ext = "-out" + no;
 
 		index = input.lastIndexOf('.');
 		if (index == -1) {
 			result = input + ext;
-		}
-		else {
-			result  = input.substring(0, index);
+		} else {
+			result = input.substring(0, index);
 			result += ext;
 			result += input.substring(index);
 		}
@@ -286,29 +286,29 @@ protected String createOutputFilename(String input, int no) {
 	 * Compares the processed data against previously saved output data.
 	 */
 	public void testRegression() {
-		InstancesHeader					data;
-		InspectionData[]				processed;
-		boolean					ok;
-		String					regression;
-		int						i;
-		String[]					input;
-		int[]					cindices;
-		MLTask[]				setups;
-		LearningPerformanceEvaluator<Example<Instance>> []	evals;
-		int[][]					points;
-		MLTask					current;
-		String[]					output;
-		TmpFile[]					outputFiles;
+		InstancesHeader data;
+		InspectionData[] processed;
+		boolean ok;
+		String regression;
+		int i;
+		String[] input;
+		int[] cindices;
+		MLTask[] setups;
+		LearningPerformanceEvaluator<Example<Instance>>[] evals;
+		int[][] points;
+		MLTask current;
+		String[] output;
+		TmpFile[] outputFiles;
 
 		if (m_NoRegressionTest)
 			return;
 
-		input    = getRegressionInputFiles();
+		input = getRegressionInputFiles();
 		cindices = getRegressionInputClassIndex();
-		output   = new String[input.length];
-		setups   = getLearnerSetups();
-		evals    = getRegressionEvaluatorSetups();
-		points   = getRegressionInspectionPoints();
+		output = new String[input.length];
+		setups = getLearnerSetups();
+		evals = getRegressionEvaluatorSetups();
+		points = getRegressionInspectionPoints();
 		assertEquals("Number of files and class indices differ!", input.length, cindices.length);
 		assertEquals("Number of files and classifier setups differ!", input.length, setups.length);
 		assertEquals("Number of classifier setups and evaluator setups differ!", setups.length, evals.length);
@@ -328,7 +328,7 @@ public void testRegression() {
 			assertNotNull("Failed to process data?", processed);
 
 			output[i] = createOutputFilename(input[i], i);
-			ok        = save(current, processed, output[i]);
+			ok = save(current, processed, output[i]);
 			assertTrue("Failed to save regression data?", ok);
 		}
 
diff --git a/moa/src/test/java/moa/learners/predictors/AbstractMultiTargetRegressorTestCase.java b/moa/src/test/java/moa/learners/predictors/AbstractMultiTargetRegressorTestCase.java
new file mode 100644
index 000000000..597d200b1
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/AbstractMultiTargetRegressorTestCase.java
@@ -0,0 +1,150 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/**
+ * AbstractMultipleRegressorTestCase.java Copyright (C) 2013 University of Waikato, Hamilton, New
+ * Zealand
+ */
+package moa.learners.predictors;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.core.Example;
+import moa.evaluation.evaluators.BasicRegressionPerformanceEvaluator;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
+import moa.learners.predictors.MultiTargetRegressor;
+
+/**
+ * Ancestor that defines a setting to test a classifier several times with
+ * different parameters using this predefined same setting.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public abstract class AbstractMultiTargetRegressorTestCase
+		extends AbstractInstanceLearnerTestCase<MultiTargetRegressor> {
+
+	protected int numberTests = 1;
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public AbstractMultiTargetRegressorTestCase(String name) {
+		super(name);
+	}
+
+	/**
+	 * Sets the number of tests to run with this classifier.
+	 *
+	 * @param name        the name of the test
+	 * @param numberTests the numbers of tests to run
+	 */
+
+	public void setNumberTests(int numberTests) {
+		this.numberTests = numberTests;
+	}
+
+	/**
+	 * Called by JUnit before each test method.
+	 *
+	 * @throws Exception if an error occurs.
+	 */
+	@Override
+	protected void setUp() throws Exception {
+		super.setUp();
+
+		m_TestHelper.copyResourceToTmp("regression.arff");
+	}
+
+	/**
+	 * Called by JUnit after each test method.
+	 *
+	 * @throws Exception if tear-down fails
+	 */
+	@Override
+	protected void tearDown() throws Exception {
+		m_TestHelper.deleteFileFromTmp("regression.arff");
+
+		super.tearDown();
+	}
+
+	/**
+	 * Returns the filenames (without path) of the input data files to use in the
+	 * regression test.
+	 *
+	 * @return the filenames
+	 */
+	@Override
+	protected String[] getRegressionInputFiles() {
+		String value = "regression.arff";
+		String[] ret = new String[this.numberTests];
+		for (int i = 0; i < this.numberTests; i++) {
+			ret[i] = value;
+		}
+		return ret;
+	}
+
+	/**
+	 * Returns the class index for the datasets.
+	 *
+	 * @return the class indices (0-based)
+	 */
+	@Override
+	protected int[] getRegressionInputClassIndex() {
+		int value = 8;
+		int[] ret = new int[this.numberTests];
+		for (int i = 0; i < this.numberTests; i++) {
+			ret[i] = value;
+		}
+		return ret;
+	}
+
+	/**
+	 * Returns the index of the instances in the stream to inspect the
+	 * performance/classification output of the classifiers.
+	 *
+	 * @return the inspection indices
+	 */
+	@Override
+	protected int[][] getRegressionInspectionPoints() {
+		int[] value = new int[] { 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000 };
+		int[][] ret = new int[this.numberTests][value.length];
+		for (int i = 0; i < this.numberTests; i++) {
+			ret[i] = value.clone();
+		}
+		return ret;
+	}
+
+	/**
+	 * Returns the evaluator setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected LearningPerformanceEvaluator<Example<Instance>>[] getRegressionEvaluatorSetups() {
+		LearningPerformanceEvaluator<Example<Instance>> value = new BasicRegressionPerformanceEvaluator();
+		LearningPerformanceEvaluator<Example<Instance>>[] ret = new BasicRegressionPerformanceEvaluator[this.numberTests];
+		for (int i = 0; i < this.numberTests; i++) {
+			ret[i] = (LearningPerformanceEvaluator<Example<Instance>>) value.copy();
+		}
+		return ret;
+	}
+
+	@Override
+	public MultiTargetRegressor copySetup(MultiTargetRegressor setup) {
+		return (MultiTargetRegressor) setup.copy();
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/AbstractRegressorTestCase.java b/moa/src/test/java/moa/learners/predictors/AbstractRegressorTestCase.java
new file mode 100644
index 000000000..5eb9c88b7
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/AbstractRegressorTestCase.java
@@ -0,0 +1,149 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/**
+ * AbstractMultipleRegressorTestCase.java Copyright (C) 2013 University of Waikato, Hamilton, New
+ * Zealand
+ */
+package moa.learners.predictors;
+
+import com.yahoo.labs.samoa.instances.Instance;
+
+import moa.core.Example;
+import moa.evaluation.evaluators.BasicRegressionPerformanceEvaluator;
+import moa.evaluation.evaluators.LearningPerformanceEvaluator;
+import moa.learners.predictors.Regressor;
+
+/**
+ * Ancestor that defines a setting to test a classifier several times with
+ * different parameters using this predefined same setting.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public abstract class AbstractRegressorTestCase extends AbstractInstanceLearnerTestCase<Regressor> {
+
+	protected int numberTests = 1;
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public AbstractRegressorTestCase(String name) {
+		super(name);
+	}
+
+	/**
+	 * Sets the number of tests to run with this classifier.
+	 *
+	 * @param name        the name of the test
+	 * @param numberTests the numbers of tests to run
+	 */
+
+	public void setNumberTests(int numberTests) {
+		this.numberTests = numberTests;
+	}
+
+	/**
+	 * Called by JUnit before each test method.
+	 *
+	 * @throws Exception if an error occurs.
+	 */
+	@Override
+	protected void setUp() throws Exception {
+		super.setUp();
+
+		m_TestHelper.copyResourceToTmp("regression.arff");
+	}
+
+	/**
+	 * Called by JUnit after each test method.
+	 *
+	 * @throws Exception if tear-down fails
+	 */
+	@Override
+	protected void tearDown() throws Exception {
+		m_TestHelper.deleteFileFromTmp("regression.arff");
+
+		super.tearDown();
+	}
+
+	/**
+	 * Returns the filenames (without path) of the input data files to use in the
+	 * regression test.
+	 *
+	 * @return the filenames
+	 */
+	@Override
+	protected String[] getRegressionInputFiles() {
+		String value = "regression.arff";
+		String[] ret = new String[this.numberTests];
+		for (int i = 0; i < this.numberTests; i++) {
+			ret[i] = value;
+		}
+		return ret;
+	}
+
+	/**
+	 * Returns the class index for the datasets.
+	 *
+	 * @return the class indices (0-based)
+	 */
+	@Override
+	protected int[] getRegressionInputClassIndex() {
+		int value = 8;
+		int[] ret = new int[this.numberTests];
+		for (int i = 0; i < this.numberTests; i++) {
+			ret[i] = value;
+		}
+		return ret;
+	}
+
+	/**
+	 * Returns the index of the instances in the stream to inspect the
+	 * performance/classification output of the classifiers.
+	 *
+	 * @return the inspection indices
+	 */
+	@Override
+	protected int[][] getRegressionInspectionPoints() {
+		int[] value = new int[] { 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000 };
+		int[][] ret = new int[this.numberTests][value.length];
+		for (int i = 0; i < this.numberTests; i++) {
+			ret[i] = value.clone();
+		}
+		return ret;
+	}
+
+	/**
+	 * Returns the evaluator setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected LearningPerformanceEvaluator<Example<Instance>>[] getRegressionEvaluatorSetups() {
+		LearningPerformanceEvaluator<Example<Instance>> value = new BasicRegressionPerformanceEvaluator();
+		LearningPerformanceEvaluator<Example<Instance>>[] ret = new BasicRegressionPerformanceEvaluator[this.numberTests];
+		for (int i = 0; i < this.numberTests; i++) {
+			ret[i] = (LearningPerformanceEvaluator<Example<Instance>>) value.copy();
+		}
+		return ret;
+	}
+
+	@Override
+	public Regressor copySetup(Regressor setup) {
+		return (Regressor) setup.copy();
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/active/ALRandomTest.java b/moa/src/test/java/moa/learners/predictors/active/ALRandomTest.java
new file mode 100644
index 000000000..a3323cca5
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/active/ALRandomTest.java
@@ -0,0 +1,72 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * ALRandomTest.java
+ * Copyright (C) 2016 Otto von Guericke University, Magdeburg, Germany
+ */
+package moa.learners.predictors.active;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.active.ALRandom;
+
+/**
+ * Tests the ALRandom classifier.
+ *
+ * @author Cornelius Styp von Rekowski (cornelius dot styp at ovgu dot de)
+ */
+public class ALRandomTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public ALRandomTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new ALRandom() };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(ALRandomTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/active/ALUncertaintyTest.java b/moa/src/test/java/moa/learners/predictors/active/ALUncertaintyTest.java
new file mode 100644
index 000000000..a8397b0ad
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/active/ALUncertaintyTest.java
@@ -0,0 +1,83 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * ALUncertaintyTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.active;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.active.ALUncertainty;
+
+/**
+ * Tests the ALUncertainty classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class ALUncertaintyTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public ALUncertaintyTest(String name) {
+		super(name);
+		this.setNumberTests(4);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		ALUncertainty fixed = new ALUncertainty();
+		ALUncertainty var = new ALUncertainty();
+		ALUncertainty randVar = new ALUncertainty();
+		ALUncertainty selSampling = new ALUncertainty();
+
+		fixed.activeLearningStrategyOption.setChosenLabel("FixedUncertainty");
+		var.activeLearningStrategyOption.setChosenLabel("VarUncertainty");
+		randVar.activeLearningStrategyOption.setChosenLabel("RandVarUncertainty");
+		selSampling.activeLearningStrategyOption.setChosenLabel("SelSampling");
+
+		return new Classifier[] { fixed, var, randVar, selSampling };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(ALUncertaintyTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/bayes/NaiveBayesMultinomialTest.java b/moa/src/test/java/moa/learners/predictors/bayes/NaiveBayesMultinomialTest.java
new file mode 100644
index 000000000..f6bea5476
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/bayes/NaiveBayesMultinomialTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * NaiveBayesMultinomialTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.bayes;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.bayes.NaiveBayesMultinomial;
+
+/**
+ * Tests the NaiveBayesMultinomial classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class NaiveBayesMultinomialTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public NaiveBayesMultinomialTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new NaiveBayesMultinomial(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(NaiveBayesMultinomialTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/bayes/NaiveBayesTest.java b/moa/src/test/java/moa/learners/predictors/bayes/NaiveBayesTest.java
new file mode 100644
index 000000000..6fe9544ee
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/bayes/NaiveBayesTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * NaiveBayesTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.bayes;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.bayes.NaiveBayes;
+
+/**
+ * Tests the NaiveBayes classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class NaiveBayesTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public NaiveBayesTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new NaiveBayes(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(NaiveBayesTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/drift/DriftDetectionMethodClassifierTest.java b/moa/src/test/java/moa/learners/predictors/drift/DriftDetectionMethodClassifierTest.java
new file mode 100644
index 000000000..4fe261953
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/drift/DriftDetectionMethodClassifierTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * DriftDetectionMethodClassifierTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.drift;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.drift.DriftDetectionMethodClassifier;
+
+/**
+ * Tests the DriftDetectionMethodClassifier classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class DriftDetectionMethodClassifierTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public DriftDetectionMethodClassifierTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new DriftDetectionMethodClassifier(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(DriftDetectionMethodClassifierTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/functions/MajorityClassTest.java b/moa/src/test/java/moa/learners/predictors/functions/MajorityClassTest.java
new file mode 100644
index 000000000..25e585684
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/functions/MajorityClassTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * MajorityClassTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.functions;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.functions.MajorityClass;
+
+/**
+ * Tests the MajorityClass classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class MajorityClassTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public MajorityClassTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new MajorityClass(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(MajorityClassTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/functions/NoChangeTest.java b/moa/src/test/java/moa/learners/predictors/functions/NoChangeTest.java
new file mode 100644
index 000000000..167a40b9f
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/functions/NoChangeTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * NoChangeTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.functions;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.functions.NoChange;
+
+/**
+ * Tests the NoChange classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class NoChangeTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public NoChangeTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new NoChange(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(NoChangeTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/functions/PerceptronTest.java b/moa/src/test/java/moa/learners/predictors/functions/PerceptronTest.java
new file mode 100644
index 000000000..fce5a7b21
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/functions/PerceptronTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * PerceptronTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.functions;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.functions.Perceptron;
+
+/**
+ * Tests the Perceptron classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class PerceptronTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public PerceptronTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new Perceptron(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(PerceptronTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/functions/SGDTest.java b/moa/src/test/java/moa/learners/predictors/functions/SGDTest.java
new file mode 100644
index 000000000..f6f380147
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/functions/SGDTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * SGDTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.functions;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.functions.SGD;
+
+/**
+ * Tests the SGD classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class SGDTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public SGDTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new SGD(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(SGDTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/functions/SPegasosTest.java b/moa/src/test/java/moa/learners/predictors/functions/SPegasosTest.java
new file mode 100644
index 000000000..1d7016f3a
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/functions/SPegasosTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * SPegasosTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.functions;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.functions.SPegasos;
+
+/**
+ * Tests the SPegasos classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class SPegasosTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public SPegasosTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new SPegasos(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(SPegasosTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/meta/ADOBTest.java b/moa/src/test/java/moa/learners/predictors/meta/ADOBTest.java
new file mode 100644
index 000000000..57888b79d
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/meta/ADOBTest.java
@@ -0,0 +1,72 @@
+/*
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ * ADOBTest.java
+ * Copyright (C) 2014 Santos, Goncalves, Barros
+ */
+package moa.learners.predictors.meta;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.meta.ADOB;
+
+/**
+ * Tests the ADOB classifier.
+ *
+ * @author Silas G. T. C. Santos (sgtcs@cin.ufpe.br)
+ * @version $Revision$
+ */
+public class ADOBTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public ADOBTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new ADOB(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(ADOBTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/meta/AccuracyUpdatedEnsembleTest.java b/moa/src/test/java/moa/learners/predictors/meta/AccuracyUpdatedEnsembleTest.java
new file mode 100644
index 000000000..2988e0a73
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/meta/AccuracyUpdatedEnsembleTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * AccuracyUpdatedEnsembleTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.meta;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.meta.AccuracyUpdatedEnsemble;
+
+/**
+ * Tests the AccuracyUpdatedEnsemble classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class AccuracyUpdatedEnsembleTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public AccuracyUpdatedEnsembleTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new AccuracyUpdatedEnsemble(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(AccuracyUpdatedEnsembleTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/meta/AccuracyWeightedEnsembleTest.java b/moa/src/test/java/moa/learners/predictors/meta/AccuracyWeightedEnsembleTest.java
new file mode 100644
index 000000000..978c13c3b
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/meta/AccuracyWeightedEnsembleTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * AccuracyWeightedEnsembleTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.meta;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.meta.AccuracyWeightedEnsemble;
+
+/**
+ * Tests the AccuracyWeightedEnsemble classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class AccuracyWeightedEnsembleTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public AccuracyWeightedEnsembleTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new AccuracyWeightedEnsemble(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(AccuracyWeightedEnsembleTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/meta/AdaptiveRandomForestTest.java b/moa/src/test/java/moa/learners/predictors/meta/AdaptiveRandomForestTest.java
new file mode 100644
index 000000000..c35fae612
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/meta/AdaptiveRandomForestTest.java
@@ -0,0 +1,74 @@
+/*
+ *   AdaptiveRandomForestTest.java
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ *
+ */
+package moa.learners.predictors.meta;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.meta.AdaptiveRandomForest;
+
+/**
+ * Tests the AdaptiveRandomForest classifier.
+ *
+ * @author Heitor Murilo Gomes (heitor_murilo_gomes at yahoo dot com dot br)
+ * @version $Revision$
+ */
+public class AdaptiveRandomForestTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public AdaptiveRandomForestTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new AdaptiveRandomForest(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(AdaptiveRandomForestTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/meta/BOLETest.java b/moa/src/test/java/moa/learners/predictors/meta/BOLETest.java
new file mode 100644
index 000000000..00e3ca5d7
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/meta/BOLETest.java
@@ -0,0 +1,72 @@
+/*
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ * BOLETest.java
+ * Copyright (C) 2015 Santos, Barros
+ */
+package moa.learners.predictors.meta;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.meta.BOLE;
+
+/**
+ * Tests the BOLE classifier.
+ *
+ * @author Silas G. T. C. Santos (sgtcs@cin.ufpe.br)
+ * @version $Revision$
+ */
+public class BOLETest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public BOLETest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new BOLE(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(BOLETest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/meta/DynamicWeightedMajorityTest.java b/moa/src/test/java/moa/learners/predictors/meta/DynamicWeightedMajorityTest.java
new file mode 100644
index 000000000..3e4b7db15
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/meta/DynamicWeightedMajorityTest.java
@@ -0,0 +1,72 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/**
+ * DynamicWeightedMajorityTest.java
+ * Copyright (C) 2016 Instituto Federal de Pernambuco, Recife, Brazil
+ */
+package moa.learners.predictors.meta;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.meta.DynamicWeightedMajority;
+
+/**
+ * Tests the Dynamic Weighted Majority classifier.
+ *
+ * @author Paulo Gonçalves (paulogoncalves at recife dot ifpe dot edu dot br)
+ * @version $Revision$
+ */
+public class DynamicWeightedMajorityTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public DynamicWeightedMajorityTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new DynamicWeightedMajority(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(DynamicWeightedMajorityTest.class);
+	}
+
+	/**
+	 * Runs the test from command line.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/classifiers/meta/HeterogeneousEnsembleBlastTest.java b/moa/src/test/java/moa/learners/predictors/meta/HeterogeneousEnsembleBlastTest.java
similarity index 75%
rename from moa/src/test/java/moa/classifiers/meta/HeterogeneousEnsembleBlastTest.java
rename to moa/src/test/java/moa/learners/predictors/meta/HeterogeneousEnsembleBlastTest.java
index f0e5bde6e..0bd10281a 100644
--- a/moa/src/test/java/moa/classifiers/meta/HeterogeneousEnsembleBlastTest.java
+++ b/moa/src/test/java/moa/learners/predictors/meta/HeterogeneousEnsembleBlastTest.java
@@ -15,22 +15,22 @@
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program. If not, see <http://www.gnu.org/licenses/>.
- *    
+ *
  */
-package moa.classifiers.meta;
+package moa.learners.predictors.meta;
 
 import junit.framework.Test;
 import junit.framework.TestSuite;
-import moa.classifiers.AbstractClassifierTestCase;
-import moa.learners.Classifier;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.meta.HeterogeneousEnsembleBlast;
+import moa.learners.predictors.meta.HeterogeneousEnsembleBlastFadingFactors;
 
-public class HeterogeneousEnsembleBlastTest
-		extends AbstractClassifierTestCase {
+public class HeterogeneousEnsembleBlastTest extends AbstractClassifierTestCase {
 	/**
 	 * Constructs the test case. Called by subclasses.
 	 *
-	 * @param name
-	 *          the name of the test
+	 * @param name the name of the test
 	 */
 	public HeterogeneousEnsembleBlastTest(String name) {
 		super(name);
@@ -44,8 +44,7 @@ public HeterogeneousEnsembleBlastTest(String name) {
 	 */
 	@Override
 	protected Classifier[] getLearnerSetups() {
-		return new Classifier[] { new HeterogeneousEnsembleBlast(),
-				new HeterogeneousEnsembleBlastFadingFactors(), };
+		return new Classifier[] { new HeterogeneousEnsembleBlast(), new HeterogeneousEnsembleBlastFadingFactors(), };
 	}
 
 	@org.junit.Test
@@ -53,8 +52,8 @@ public void testSetup() { // TODO: test case doesn't run
 		// checks whether differently initialized ensembles are what they claim to
 		// be.
 
-		String[] ensembleComposition = { "moa.classifiers.trees.HoeffdingTree", "moa.classifiers.bayes.NaiveBayes",
-				"moa.classifiers.functions.Perceptron" };
+		String[] ensembleComposition = { "trees.HoeffdingTree", "bayes.NaiveBayes",
+				"functions.Perceptron" };
 
 		HeterogeneousEnsembleBlastFadingFactors ff = new HeterogeneousEnsembleBlastFadingFactors();
 
@@ -69,8 +68,7 @@ public void testSetup() { // TODO: test case doesn't run
 			ff.prepareForUse();
 			assertEquals(ff.getEnsembleSize(), i + 1);
 			for (int j = 0; j < i; ++j) {
-				assertEquals(ff.getMemberCliString(j).trim(),
-						ensembleComposition[j].trim());
+				assertEquals(ff.getMemberCliString(j).trim(), ensembleComposition[j].trim());
 			}
 
 		}
@@ -88,8 +86,7 @@ public static Test suite() {
 	/**
 	 * Runs the test from commandline.
 	 *
-	 * @param args
-	 *          ignored
+	 * @param args ignored
 	 */
 	public static void main(String[] args) {
 		runTest(suite());
diff --git a/moa/src/test/java/moa/learners/predictors/meta/LeveragingBagTest.java b/moa/src/test/java/moa/learners/predictors/meta/LeveragingBagTest.java
new file mode 100644
index 000000000..d2993e06e
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/meta/LeveragingBagTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * LeveragingBagTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.meta;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.meta.LeveragingBag;
+
+/**
+ * Tests the LeveragingBag classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class LeveragingBagTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public LeveragingBagTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new LeveragingBag(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(LeveragingBagTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/meta/LimAttClassifierTest.java b/moa/src/test/java/moa/learners/predictors/meta/LimAttClassifierTest.java
new file mode 100644
index 000000000..ce3fc4cc6
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/meta/LimAttClassifierTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * LimAttClassifierTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.meta;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.meta.LimAttClassifier;
+
+/**
+ * Tests the LimAttClassifier classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class LimAttClassifierTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public LimAttClassifierTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new LimAttClassifier(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(LimAttClassifierTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/meta/OCBoostTest.java b/moa/src/test/java/moa/learners/predictors/meta/OCBoostTest.java
new file mode 100644
index 000000000..d009c8888
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/meta/OCBoostTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * OCBoostTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.meta;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.meta.OCBoost;
+
+/**
+ * Tests the OCBoost classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class OCBoostTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public OCBoostTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new OCBoost(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(OCBoostTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/meta/OnlineAccuracyUpdatedEnsembleTest.java b/moa/src/test/java/moa/learners/predictors/meta/OnlineAccuracyUpdatedEnsembleTest.java
new file mode 100644
index 000000000..8ce063088
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/meta/OnlineAccuracyUpdatedEnsembleTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * OnlineAccuracyUpdatedEnsembleTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.meta;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.meta.OnlineAccuracyUpdatedEnsemble;
+
+/**
+ * Tests the OnlineAccuracyUpdatedEnsemble classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class OnlineAccuracyUpdatedEnsembleTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public OnlineAccuracyUpdatedEnsembleTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new OnlineAccuracyUpdatedEnsemble(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(OnlineAccuracyUpdatedEnsembleTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/meta/OzaBagASHTTest.java b/moa/src/test/java/moa/learners/predictors/meta/OzaBagASHTTest.java
new file mode 100644
index 000000000..f6fd75c2f
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/meta/OzaBagASHTTest.java
@@ -0,0 +1,77 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * OzaBagASHTTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.meta;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.meta.OzaBagASHT;
+
+/**
+ * Tests the OzaBagASHT classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class OzaBagASHTTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public OzaBagASHTTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		OzaBagASHT[] result;
+		result = new OzaBagASHT[1];
+		result[0] = new OzaBagASHT();
+		return result;
+
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(OzaBagASHTTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/meta/OzaBoostAdwinTest.java b/moa/src/test/java/moa/learners/predictors/meta/OzaBoostAdwinTest.java
new file mode 100644
index 000000000..629ffdba7
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/meta/OzaBoostAdwinTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * OzaBoostAdwinTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.meta;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.meta.OzaBoostAdwin;
+
+/**
+ * Tests the OzaBoostAdwin classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class OzaBoostAdwinTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public OzaBoostAdwinTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new OzaBoostAdwin(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(OzaBoostAdwinTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/meta/TemporallyAugmentedClassifierTest.java b/moa/src/test/java/moa/learners/predictors/meta/TemporallyAugmentedClassifierTest.java
new file mode 100644
index 000000000..0b0ed812d
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/meta/TemporallyAugmentedClassifierTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * TemporallyAugmentedClassifierTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.meta;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.meta.TemporallyAugmentedClassifier;
+
+/**
+ * Tests the TemporallyAugmentedClassifier classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class TemporallyAugmentedClassifierTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public TemporallyAugmentedClassifierTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new TemporallyAugmentedClassifier(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(TemporallyAugmentedClassifierTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/meta/WEKAClassifierTest.java b/moa/src/test/java/moa/learners/predictors/meta/WEKAClassifierTest.java
new file mode 100644
index 000000000..bea6123b2
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/meta/WEKAClassifierTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * WEKAClassifierTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.meta;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.meta.WEKAClassifier;
+
+/**
+ * Tests the WEKAClassifier classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class WEKAClassifierTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public WEKAClassifierTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new WEKAClassifier(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(WEKAClassifierTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/meta/WeightedMajorityAlgorithmTest.java b/moa/src/test/java/moa/learners/predictors/meta/WeightedMajorityAlgorithmTest.java
new file mode 100644
index 000000000..1367be497
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/meta/WeightedMajorityAlgorithmTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * WeightedMajorityAlgorithmTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.meta;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.meta.WeightedMajorityAlgorithm;
+
+/**
+ * Tests the WeightedMajorityAlgorithm classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class WeightedMajorityAlgorithmTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public WeightedMajorityAlgorithmTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new WeightedMajorityAlgorithm(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(WeightedMajorityAlgorithmTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/meta/classifiers/OzaBagAdwinTest.java b/moa/src/test/java/moa/learners/predictors/meta/classifiers/OzaBagAdwinTest.java
new file mode 100644
index 000000000..43a1b4442
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/meta/classifiers/OzaBagAdwinTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * OzaBagAdwinTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.meta.classifiers;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.meta.classifiers.OzaBagAdwin;
+
+/**
+ * Tests the OzaBagAdwin classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class OzaBagAdwinTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public OzaBagAdwinTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new OzaBagAdwin(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(OzaBagAdwinTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/meta/classifiers/OzaBagTest.java b/moa/src/test/java/moa/learners/predictors/meta/classifiers/OzaBagTest.java
new file mode 100644
index 000000000..6dfb51ed1
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/meta/classifiers/OzaBagTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * OzaBagTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.meta.classifiers;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.meta.classifiers.OzaBag;
+
+/**
+ * Tests the OzaBag classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class OzaBagTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public OzaBagTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new OzaBag(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(OzaBagTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/meta/classifiers/OzaBoostTest.java b/moa/src/test/java/moa/learners/predictors/meta/classifiers/OzaBoostTest.java
new file mode 100644
index 000000000..f6364a1e9
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/meta/classifiers/OzaBoostTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * OzaBoostTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.meta.classifiers;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.meta.classifiers.OzaBoost;
+
+/**
+ * Tests the OzaBoost classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class OzaBoostTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public OzaBoostTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new OzaBoost(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(OzaBoostTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/rules/AMRulesMultiTargetRegressorSemiSuperTest.java b/moa/src/test/java/moa/learners/predictors/rules/AMRulesMultiTargetRegressorSemiSuperTest.java
new file mode 100644
index 000000000..32725b754
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/rules/AMRulesMultiTargetRegressorSemiSuperTest.java
@@ -0,0 +1,71 @@
+/*
+ *    MultiTargetLearnerSemiSupervised.java
+ *    Copyright (C) 2017 University of Porto, Portugal
+ *    @author R. Sousa, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.predictors.rules;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractMultiTargetRegressorTestCase;
+import moa.learners.predictors.MultiTargetRegressor;
+import moa.learners.predictors.rules.AMRulesMultiTargetRegressorSemiSuper;
+
+/**
+ * Created by RSousa on 04/07/2017.
+ */
+public class AMRulesMultiTargetRegressorSemiSuperTest extends AbstractMultiTargetRegressorTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public AMRulesMultiTargetRegressorSemiSuperTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected MultiTargetRegressor[] getLearnerSetups() {
+		return new MultiTargetRegressor[] { new AMRulesMultiTargetRegressorSemiSuper(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(moa.learners.predictors.rules.AMRulesMultiTargetRegressorSemiSuperTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/classifiers/rules/AMRulesRegressorTest.java b/moa/src/test/java/moa/learners/predictors/rules/AMRulesRegressorTest.java
similarity index 72%
rename from moa/src/test/java/moa/classifiers/rules/AMRulesRegressorTest.java
rename to moa/src/test/java/moa/learners/predictors/rules/AMRulesRegressorTest.java
index 501852dc1..aa5930bc3 100644
--- a/moa/src/test/java/moa/classifiers/rules/AMRulesRegressorTest.java
+++ b/moa/src/test/java/moa/learners/predictors/rules/AMRulesRegressorTest.java
@@ -17,27 +17,26 @@
  * AMRulesTest.java
  * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
  */
-package moa.classifiers.rules;
+package moa.learners.predictors.rules;
 
 import junit.framework.Test;
 import junit.framework.TestSuite;
-import moa.classifiers.AbstractRegressorTestCase;
-import moa.learners.Regressor;
+import moa.learners.predictors.AbstractRegressorTestCase;
+import moa.learners.predictors.Regressor;
 import moa.options.ClassOption;
 
 /**
  * Tests the AMRulesRegressor classifier.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
  * @version $Revision$
  */
-public class AMRulesRegressorTest
-extends AbstractRegressorTestCase {
+public class AMRulesRegressorTest extends AbstractRegressorTestCase {
 
 	/**
 	 * Constructs the test case. Called by subclasses.
 	 *
-	 * @param name 	the name of the test
+	 * @param name the name of the test
 	 */
 	public AMRulesRegressorTest(String name) {
 		super(name);
@@ -47,24 +46,24 @@ public AMRulesRegressorTest(String name) {
 	/**
 	 * Returns the classifier setups to use in the regression test.
 	 *
-	 * @return		the setups
+	 * @return the setups
 	 */
 	@Override
 	protected Regressor[] getLearnerSetups() {
 		Regressor r = null;
 		try {
-			r = (Regressor) ClassOption.cliStringToObject("moa.classifiers.meta.RegressionViaMTR -c (moa.classifiers.rules.multilabel.AMRulesMultiTargetRegressor)", Regressor.class, null);
+			r = (Regressor) ClassOption.cliStringToObject(
+					"meta.RegressionViaMTR -c (rules.AMRulesMultiTargetRegressor)",
+					Regressor.class, null);
 		} catch (Exception e) {
 		}
-		return new Regressor[]{
-				r
-		};
+		return new Regressor[] { r };
 	}
 
 	/**
 	 * Returns a test suite.
 	 *
-	 * @return		the test suite
+	 * @return the test suite
 	 */
 	public static Test suite() {
 		return new TestSuite(AMRulesRegressorTest.class);
@@ -73,7 +72,7 @@ public static Test suite() {
 	/**
 	 * Runs the test from commandline.
 	 *
-	 * @param args	ignored
+	 * @param args ignored
 	 */
 	public static void main(String[] args) {
 		runTest(suite());
diff --git a/moa/src/test/java/moa/learners/predictors/rules/RuleClassifierNBayesTest.java b/moa/src/test/java/moa/learners/predictors/rules/RuleClassifierNBayesTest.java
new file mode 100644
index 000000000..443df4d04
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/rules/RuleClassifierNBayesTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * RuleClassifierNBayesTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.rules;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.rules.RuleClassifierNBayes;
+
+/**
+ * Tests the RuleClassifierNBayes classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class RuleClassifierNBayesTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public RuleClassifierNBayesTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new RuleClassifierNBayes(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(RuleClassifierNBayesTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/rules/RuleClassifierTest.java b/moa/src/test/java/moa/learners/predictors/rules/RuleClassifierTest.java
new file mode 100644
index 000000000..d65dcaa24
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/rules/RuleClassifierTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * RuleClassifierTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.rules;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.rules.RuleClassifier;
+
+/**
+ * Tests the RuleClassifier classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class RuleClassifierTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public RuleClassifierTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new RuleClassifier(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(RuleClassifierTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/rules/core/UtilsTest.java b/moa/src/test/java/moa/learners/predictors/rules/core/UtilsTest.java
new file mode 100644
index 000000000..e372e4c37
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/rules/core/UtilsTest.java
@@ -0,0 +1,61 @@
+/*
+ *    UtilsTest.java
+ *    Copyright (C) 2017 University of Porto, Portugal
+ *    @author J. Duarte, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.predictors.rules.core;
+
+import static org.junit.Assert.assertArrayEquals;
+
+import org.junit.Test;
+
+import moa.learners.predictors.rules.core.Utils;
+
+public class UtilsTest {
+
+	@Test
+	public void testComplementSet() {
+		int[] result = Utils.complementSet(new int[] { 1, 3, 4, 5, 6 }, new int[] { 4, 5 });
+		assertArrayEquals(new int[] { 1, 3, 6 }, result);
+
+		result = Utils.complementSet(new int[] { 1, 3, 4, 5, 6 }, new int[] { 1, 3, 4, 5, 6 });
+		assertArrayEquals(new int[] {}, result);
+
+		result = Utils.complementSet(new int[] { 1, 3, 4, 5, 6 }, new int[] { 1 });
+		assertArrayEquals(new int[] { 3, 4, 5, 6 }, result);
+
+		result = Utils.complementSet(new int[] { 1, 3, 4, 5, 6 }, new int[] { 4, 6 });
+		assertArrayEquals(new int[] { 1, 3, 5 }, result);
+	}
+
+	@Test
+	public void testGetIndexCorrespondence() {
+		int[] result = Utils.getIndexCorrespondence(new int[] { 2, 3, 5 }, new int[] { 2, 3 });
+		assertArrayEquals(new int[] { 0, 1 }, result);
+
+		result = Utils.getIndexCorrespondence(new int[] { 1, 2, 3, 4, 5 }, new int[] { 1, 2, 3, 4, 5 });
+		assertArrayEquals(new int[] { 0, 1, 2, 3, 4 }, result);
+
+		result = Utils.getIndexCorrespondence(new int[] { 1, 2, 5 }, new int[] { 1, 5 });
+		assertArrayEquals(new int[] { 0, 2 }, result);
+
+		result = Utils.getIndexCorrespondence(new int[] { 1, 2, 5 }, new int[] { 2 });
+		assertArrayEquals(new int[] { 1 }, result);
+	}
+
+}
diff --git a/moa/src/test/java/moa/learners/predictors/rules/multilabel/core/voting/FirstHitVoteMultiLabelTest.java b/moa/src/test/java/moa/learners/predictors/rules/multilabel/core/voting/FirstHitVoteMultiLabelTest.java
new file mode 100644
index 000000000..1ee81f826
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/rules/multilabel/core/voting/FirstHitVoteMultiLabelTest.java
@@ -0,0 +1,114 @@
+/*
+ *    FirstHitVoteMultiLabelTest.java
+ *    Copyright (C) 2017 University of Porto, Portugal
+ *    @author J. Duarte, J. Gama
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ *
+ */
+
+package moa.learners.predictors.rules.multilabel.core.voting;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.learners.predictors.core.voting.FirstHitVoteMultiLabel;
+
+/**
+ * Test FirstHitVoteMultiLabel class
+ *
+ * @author João Duarte (joaomaiaduarte@gmail.com)
+ */
+public class FirstHitVoteMultiLabelTest {
+
+	static FirstHitVoteMultiLabel weightedVote;
+	static final double EPS = 0.0000001;
+
+	@BeforeClass
+	public static void runBefore() {
+		weightedVote = new FirstHitVoteMultiLabel();
+		Prediction pred = new MultiLabelClassificationPrediction(4);
+		pred.setVote(0, 1);
+		pred.setVote(3, 4);
+		weightedVote.addVote(pred, new double[] { 4, Double.MAX_VALUE, Double.MAX_VALUE, 3 });
+
+		pred = new MultiLabelClassificationPrediction(4);
+		pred.setVote(0, 2);
+		pred.setVote(2, 3);
+		pred.setVote(3, 2);
+		weightedVote.addVote(pred, new double[] { 3, Double.MAX_VALUE, 1, 1 });
+
+		pred = new MultiLabelClassificationPrediction(4);
+		pred.setVote(1, 2);
+		pred.setVote(3, 1);
+		weightedVote.addVote(pred, new double[] { Double.MAX_VALUE, 4, Double.MAX_VALUE, 0 });
+		weightedVote.computeWeightedVote();
+	}
+
+	@Test
+	public void testComputeWeightedVote() {
+		Prediction weightedPred = weightedVote.computeWeightedVote();
+		assertEquals(1, weightedPred.getVote(0, 0), EPS);
+		assertEquals(2, weightedPred.getVote(1, 0), EPS);
+		assertEquals(3, weightedPred.getVote(2, 0), EPS);
+		assertEquals(4, weightedPred.getVote(3, 0), EPS);
+	}
+
+	@Test
+	public void testGetWeightedError() {
+		assertEquals(3, weightedVote.getWeightedError(), EPS);
+	}
+
+	@Test
+	public void testGetWeights() {
+		double[][] weights = weightedVote.getWeights();
+		assertEquals(1, weights[0][0], EPS);
+		assertEquals(1, weights[0][3], EPS);
+
+		assertEquals(0, weights[1][0], EPS);
+		assertEquals(1, weights[1][2], EPS);
+		assertEquals(0, weights[1][3], EPS);
+
+		assertEquals(1, weights[2][1], EPS);
+		assertEquals(0, weights[2][3], EPS);
+
+	}
+
+	@Test
+	public void testGetNumberVotes() {
+		assertEquals(2, weightedVote.getNumberVotes(0));
+	}
+
+	@Test
+	public void testGetNumberVotesInt() {
+		assertEquals(2, weightedVote.getNumberVotes(0));
+		assertEquals(1, weightedVote.getNumberVotes(1));
+		assertEquals(1, weightedVote.getNumberVotes(2));
+		assertEquals(3, weightedVote.getNumberVotes(3));
+	}
+
+	@Test
+	public void testGetOutputAttributesErrors() {
+		double[] errors = weightedVote.getOutputAttributesErrors();
+		assertEquals(4, errors[0], EPS);
+		assertEquals(4, errors[1], EPS);
+		assertEquals(1, errors[2], EPS);
+		assertEquals(3, errors[3], EPS);
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/rules/multilabel/core/voting/InverseErrorWeightedVoteMultiLabelTest.java b/moa/src/test/java/moa/learners/predictors/rules/multilabel/core/voting/InverseErrorWeightedVoteMultiLabelTest.java
new file mode 100644
index 000000000..6af2ad0f8
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/rules/multilabel/core/voting/InverseErrorWeightedVoteMultiLabelTest.java
@@ -0,0 +1,101 @@
+package moa.learners.predictors.rules.multilabel.core.voting;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.learners.predictors.core.voting.InverseErrorWeightedVoteMultiLabel;
+
+/**
+ * Test InverseErrorWeightedVoteMultiLabeL class
+ *
+ * @author João Duarte (joaomaiaduarte@gmail.com)
+ */
+public class InverseErrorWeightedVoteMultiLabelTest {
+	static InverseErrorWeightedVoteMultiLabel weightedVote;
+	static final double EPS = 0.0000001;
+
+	@BeforeClass
+	public static void runBefore() {
+		weightedVote = new InverseErrorWeightedVoteMultiLabel();
+		Prediction pred = new MultiLabelClassificationPrediction(4);
+		pred.setVote(0, 1);
+		pred.setVote(1, 2);
+		pred.setVote(2, 3);
+		pred.setVote(3, 4);
+		weightedVote.addVote(pred, new double[] { 4, 3, 2, 1 });
+
+		pred = new MultiLabelClassificationPrediction(4);
+		pred.setVote(0, 1);
+		pred.setVote(1, 2);
+		pred.setVote(3, 4);
+		weightedVote.addVote(pred, new double[] { 3, 2, Double.MAX_VALUE, 0 });
+
+		pred = new MultiLabelClassificationPrediction(4);
+		pred.setVote(0, 4);
+		pred.setVote(1, 2);
+		pred.setVote(3, 1);
+		weightedVote.addVote(pred, new double[] { 1, 0, Double.MAX_VALUE, 0 });
+		weightedVote.computeWeightedVote();
+	}
+
+	@Test
+	public void testComputeWeightedVote() {
+		Prediction weightedPred = weightedVote.computeWeightedVote();
+		assertEquals(2.8947368416, weightedPred.getVote(0, 0), EPS);
+		assertEquals(2, weightedPred.getVote(1, 0), EPS);
+		assertEquals(3, weightedPred.getVote(2, 0), EPS);
+		assertEquals(2.5000000008, weightedPred.getVote(3, 0), EPS);
+	}
+
+	@Test
+	public void testGetWeightedError() {
+		assertEquals(0.9736842113, weightedVote.getWeightedError(), EPS);
+	}
+
+	@Test
+	public void testGetWeights() {
+		double[][] weights = weightedVote.getWeights();
+		assertEquals(0.15789474, weights[0][0], EPS);
+		assertEquals(0.21052632, weights[1][0], EPS);
+		assertEquals(0.63157895, weights[2][0], EPS);
+
+		assertEquals(0, weights[0][1], EPS);
+		assertEquals(0, weights[1][1], EPS);
+		assertEquals(1, weights[2][1], EPS);
+
+		assertEquals(1, weights[0][2], EPS);
+		assertEquals(0, weights[1][2], EPS);
+		assertEquals(0, weights[2][2], EPS);
+
+		assertEquals(0, weights[0][3], EPS);
+		assertEquals(.5, weights[1][3], EPS);
+		assertEquals(.5, weights[2][3], EPS);
+	}
+
+	@Test
+	public void testGetNumberVotes() {
+		assertEquals(3, weightedVote.getNumberVotes(0));
+	}
+
+	@Test
+	public void testGetNumberVotesInt() {
+		assertEquals(3, weightedVote.getNumberVotes(0));
+		assertEquals(3, weightedVote.getNumberVotes(1));
+		assertEquals(1, weightedVote.getNumberVotes(2));
+		assertEquals(3, weightedVote.getNumberVotes(3));
+	}
+
+	@Test
+	public void testGetOutputAttributesErrors() {
+		double[] errors = weightedVote.getOutputAttributesErrors();
+		assertEquals(1.894736843, errors[0], EPS);
+		assertEquals(0.000000002, errors[1], EPS);
+		assertEquals(2, errors[2], EPS);
+		assertEquals(0, errors[3], EPS);
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/rules/multilabel/core/voting/UniformWeightedVoteMultiLabelTest.java b/moa/src/test/java/moa/learners/predictors/rules/multilabel/core/voting/UniformWeightedVoteMultiLabelTest.java
new file mode 100644
index 000000000..e273a0ac3
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/rules/multilabel/core/voting/UniformWeightedVoteMultiLabelTest.java
@@ -0,0 +1,104 @@
+package moa.learners.predictors.rules.multilabel.core.voting;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.learners.predictors.core.voting.UniformWeightedVoteMultiLabel;
+
+/**
+ * Test UniformWeightedVoteMultiLabel
+ *
+ * @author João Duarte (joaomaiaduarte@gmail.com)
+ */
+public class UniformWeightedVoteMultiLabelTest {
+
+	static UniformWeightedVoteMultiLabel weightedVote;
+	static final double EPS = 0.0000001;
+
+	@BeforeClass
+	public static void runBefore() {
+		weightedVote = new UniformWeightedVoteMultiLabel();
+		Prediction pred = new MultiLabelClassificationPrediction(new double[] { 1, 2, 3, 4 });
+//		pred.setVotes(0, new double[]{1});
+//		pred.setVotes(1, new double[]{2});
+//		pred.setVotes(2, new double[]{3});
+//		pred.setVotes(3, new double[]{4});
+		weightedVote.addVote(pred, new double[] { 4, 3, 2, 1 });
+
+		pred = new MultiLabelClassificationPrediction(new double[] { 1, 2, 0, 4 });
+//		pred.setVotes(0, new double[]{1});
+//		pred.setVotes(1, new double[]{2});
+//		pred.setVotes(3, new double[]{4});
+		weightedVote.addVote(pred, new double[] { 3, 2, Double.MAX_VALUE, 0 });
+
+		pred = new MultiLabelClassificationPrediction(new double[] { 4, 2, 0, 1 });
+//		pred.setVotes(0, new double[]{4});
+//		pred.setVotes(1, new double[]{2});
+//		pred.setVotes(3, new double[]{1});
+		weightedVote.addVote(pred, new double[] { 1, 0, Double.MAX_VALUE, 0 });
+		weightedVote.computeWeightedVote();
+	}
+
+	@Test
+	public void testComputeWeightedVote() {
+		Prediction weightedPred = weightedVote.computeWeightedVote();
+		assertEquals(2, weightedPred.getVote(0, 0), EPS);
+		assertEquals(2, weightedPred.getVote(1, 0), EPS);
+		assertEquals(3, weightedPred.getVote(2, 0), EPS);
+		assertEquals(3, weightedPred.getVote(3, 0), EPS);
+	}
+
+	@Test
+	public void testGetWeightedError() {
+		assertEquals(1.66666666666666, weightedVote.getWeightedError(), EPS);
+	}
+
+	@Test
+	public void testGetWeights() {
+		double[][] weights = weightedVote.getWeights();
+		assertEquals(1.0 / 3, weights[0][0], EPS);
+		assertEquals(1.0 / 3, weights[1][0], EPS);
+		assertEquals(1.0 / 3, weights[2][0], EPS);
+
+		assertEquals(1.0 / 3, weights[0][1], EPS);
+		assertEquals(1.0 / 3, weights[1][1], EPS);
+		assertEquals(1.0 / 3, weights[2][1], EPS);
+
+		assertEquals(1, weights[0][2], EPS);
+		assertEquals(0, weights[1][2], EPS);
+		assertEquals(0, weights[2][2], EPS);
+
+		assertEquals(1.0 / 3, weights[0][3], EPS);
+		assertEquals(1.0 / 3, weights[1][3], EPS);
+		assertEquals(1.0 / 3, weights[2][3], EPS);
+	}
+
+	@Test
+	public void testGetNumberVotes() {
+		assertEquals(3, weightedVote.getNumberVotes(0));
+	}
+
+	@Test
+	public void testGetNumberVotesInt() {
+		assertEquals(3, weightedVote.getNumberVotes(0));
+		assertEquals(3, weightedVote.getNumberVotes(1));
+		assertEquals(1, weightedVote.getNumberVotes(2));
+		assertEquals(3, weightedVote.getNumberVotes(3));
+	}
+
+	@Test
+	public void testGetOutputAttributesErrors() {
+		double[] errors = weightedVote.getOutputAttributesErrors();
+		assertEquals(8.0 / 3, errors[0], EPS);
+		assertEquals(5.0 / 3, errors[1], EPS);
+		assertEquals(2, errors[2], EPS);
+		assertEquals(1.0 / 3, errors[3], EPS);
+
+	}
+
+}
diff --git a/moa/src/test/java/moa/learners/predictors/rules/multilabel/errormeasurers/RelativeMeanAbsoluteDeviationMTTest.java b/moa/src/test/java/moa/learners/predictors/rules/multilabel/errormeasurers/RelativeMeanAbsoluteDeviationMTTest.java
new file mode 100644
index 000000000..7454ed915
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/rules/multilabel/errormeasurers/RelativeMeanAbsoluteDeviationMTTest.java
@@ -0,0 +1,81 @@
+package moa.learners.predictors.rules.multilabel.errormeasurers;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.learners.predictors.core.errormeasurers.MultiTargetErrorMeasurer;
+import moa.learners.predictors.core.errormeasurers.RelativeMeanAbsoluteDeviationMT;
+
+public class RelativeMeanAbsoluteDeviationMTTest {
+	static protected MultiTargetErrorMeasurer m;
+
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+		m = new RelativeMeanAbsoluteDeviationMT();
+		Prediction trueTarget = new MultiLabelClassificationPrediction(3);
+		Prediction prediction = new MultiLabelClassificationPrediction(3);
+		prediction.setVote(0, 0, 4);
+		prediction.setVote(1, 0, 50);
+		prediction.setVote(2, 0, -80);
+		trueTarget.setVote(0, 0, 3);
+		trueTarget.setVote(1, 0, 30);
+		trueTarget.setVote(2, 0, -100);
+		m.addPrediction(prediction, trueTarget);
+
+		trueTarget = new MultiLabelClassificationPrediction(3);
+		prediction = new MultiLabelClassificationPrediction(3);
+		prediction.setVote(0, 0, 3);
+		prediction.setVote(1, 0, 2);
+		prediction.setVote(2, 0, -80);
+		trueTarget.setVote(0, 0, 2);
+		trueTarget.setVote(1, 0, 12);
+		trueTarget.setVote(2, 0, -75);
+		m.addPrediction(prediction, trueTarget);
+
+		trueTarget = new MultiLabelClassificationPrediction(3);
+		prediction = new MultiLabelClassificationPrediction(3);
+		prediction.setVote(0, 0, 9);
+		prediction.setVote(1, 0, -40);
+		prediction.setVote(2, 0, -80);
+		trueTarget.setVote(0, 0, 3);
+		trueTarget.setVote(1, 0, -50);
+		trueTarget.setVote(2, 0, -50);
+		m.addPrediction(prediction, trueTarget);
+
+		trueTarget = new MultiLabelClassificationPrediction(3);
+		prediction = new MultiLabelClassificationPrediction(3);
+
+		prediction.setVote(0, 0, -8);
+		prediction.setVote(1, 0, 30);
+		prediction.setVote(2, 0, -80);
+		trueTarget.setVote(0, 0, -4);
+		trueTarget.setVote(1, 0, 40);
+		trueTarget.setVote(2, 0, -80);
+		m.addPrediction(prediction, trueTarget);
+	}
+
+	@Test
+	public void testGetCurrentError() {
+		assertEquals(0.9111995717892043, m.getCurrentError(), 0.0000001);
+	}
+
+	@Test
+	public void testGetCurrentErrorInt() {
+		assertEquals(0.7116760869790253, m.getCurrentError(0), 0.0000001);
+		assertEquals(0.5077398163068827, m.getCurrentError(1), 0.0000001);
+		assertEquals(1.5141828120817051, m.getCurrentError(2), 0.0000001);
+	}
+
+	@Test
+	public void testGetCurrentErrors() {
+		assertArrayEquals(new double[] { 0.7116760869790253, 0.5077398163068827, 1.5141828120817051 },
+				m.getCurrentErrors(), 0.0000001);
+	}
+
+}
diff --git a/moa/src/test/java/moa/learners/predictors/rules/multilabel/errormeasurers/RelativeRootMeanSquaredErrorMTTest.java b/moa/src/test/java/moa/learners/predictors/rules/multilabel/errormeasurers/RelativeRootMeanSquaredErrorMTTest.java
new file mode 100644
index 000000000..79ce31509
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/rules/multilabel/errormeasurers/RelativeRootMeanSquaredErrorMTTest.java
@@ -0,0 +1,80 @@
+package moa.learners.predictors.rules.multilabel.errormeasurers;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.learners.predictors.core.errormeasurers.MultiTargetErrorMeasurer;
+import moa.learners.predictors.core.errormeasurers.RelativeRootMeanSquaredErrorMT;
+
+public class RelativeRootMeanSquaredErrorMTTest {
+	static protected MultiTargetErrorMeasurer m;
+
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+		m = new RelativeRootMeanSquaredErrorMT();
+		Prediction trueTarget = new MultiLabelClassificationPrediction(3);
+		Prediction prediction = new MultiLabelClassificationPrediction(3);
+		prediction.setVote(0, 0, 4);
+		prediction.setVote(1, 0, 50);
+		prediction.setVote(2, 0, -80);
+		trueTarget.setVote(0, 0, 3);
+		trueTarget.setVote(1, 0, 30);
+		trueTarget.setVote(2, 0, -100);
+		m.addPrediction(prediction, trueTarget);
+
+		trueTarget = new MultiLabelClassificationPrediction(3);
+		prediction = new MultiLabelClassificationPrediction(3);
+		prediction.setVote(0, 0, 3);
+		prediction.setVote(1, 0, 2);
+		prediction.setVote(2, 0, -80);
+		trueTarget.setVote(0, 0, 2);
+		trueTarget.setVote(1, 0, 12);
+		trueTarget.setVote(2, 0, -75);
+		m.addPrediction(prediction, trueTarget);
+
+		trueTarget = new MultiLabelClassificationPrediction(3);
+		prediction = new MultiLabelClassificationPrediction(3);
+		prediction.setVote(0, 0, 9);
+		prediction.setVote(1, 0, -40);
+		prediction.setVote(2, 0, -80);
+		trueTarget.setVote(0, 0, 3);
+		trueTarget.setVote(1, 0, -50);
+		trueTarget.setVote(2, 0, -50);
+		m.addPrediction(prediction, trueTarget);
+
+		trueTarget = new MultiLabelClassificationPrediction(3);
+		prediction = new MultiLabelClassificationPrediction(3);
+
+		prediction.setVote(0, 0, -8);
+		prediction.setVote(1, 0, 30);
+		prediction.setVote(2, 0, -80);
+		trueTarget.setVote(0, 0, -4);
+		trueTarget.setVote(1, 0, 40);
+		trueTarget.setVote(2, 0, -80);
+		m.addPrediction(prediction, trueTarget);
+	}
+
+	@Test
+	public void testGetCurrentError() {
+		assertEquals(0.9402350854416155, m.getCurrentError(), 0.0000001);
+	}
+
+	@Test
+	public void testGetCurrentErrorInt() {
+		assertEquals(0.664202694282111, m.getCurrentError(0), 0.0000001);
+		assertEquals(0.5147167180492306, m.getCurrentError(1), 0.0000001);
+		assertEquals(1.641785843993505, m.getCurrentError(2), 0.0000001);
+	}
+
+	@Test
+	public void testGetCurrentErrors() {
+		assertArrayEquals(new double[] { 0.664202694282111, 0.5147167180492306, 1.641785843993505 },
+				m.getCurrentErrors(), 0.0000001);
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/rules/multilabel/instancetransformers/InstanceOutputAttributesSelectorTest.java b/moa/src/test/java/moa/learners/predictors/rules/multilabel/instancetransformers/InstanceOutputAttributesSelectorTest.java
new file mode 100644
index 000000000..7333b1b7e
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/rules/multilabel/instancetransformers/InstanceOutputAttributesSelectorTest.java
@@ -0,0 +1,74 @@
+package moa.learners.predictors.rules.multilabel.instancetransformers;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import com.yahoo.labs.samoa.instances.Instance;
+import com.yahoo.labs.samoa.instances.InstancesHeader;
+import com.yahoo.labs.samoa.instances.predictions.MultiLabelClassificationPrediction;
+import com.yahoo.labs.samoa.instances.predictions.Prediction;
+
+import moa.learners.predictors.core.instancetransformers.InstanceOutputAttributesSelector;
+import moa.streams.ArffFileStream;
+
+public class InstanceOutputAttributesSelectorTest {
+	private static Instance instance1, instance2, transformed1, transformed2;
+	private static double EPS = 0.00000001;
+	private static InstanceOutputAttributesSelector transformer;
+
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+		ArffFileStream stream = new ArffFileStream(
+				ClassLoader.getSystemResource("moa/learners/predictors/data/small_regression.arff").getPath(), "4-6");
+		instance1 = stream.nextInstance().getData();
+		instance2 = stream.nextInstance().getData();
+		transformer = new InstanceOutputAttributesSelector(new InstancesHeader(instance1.dataset()),
+				new int[] { 0, 2 });
+		transformed1 = transformer.sourceInstanceToTarget(instance1);
+		transformed2 = transformer.sourceInstanceToTarget(instance2);
+	}
+
+	@Test
+	public void sourceInstanceToTarget() {
+		assertEquals(1, transformed1.valueOutputAttribute(0), EPS);
+		assertEquals(3, transformed1.valueOutputAttribute(1), EPS);
+		assertEquals(1.1, transformed1.valueInputAttribute(0), EPS);
+		assertEquals(-2.3, transformed1.valueInputAttribute(1), EPS);
+		assertEquals(2, transformed1.valueInputAttribute(2), EPS);
+		assertEquals(3.3, transformed1.valueInputAttribute(3), EPS);
+		assertEquals(0, transformed1.valueInputAttribute(4), EPS);
+
+		assertEquals(1.2, transformed2.valueInputAttribute(0), EPS);
+		assertEquals(-2.2, transformed2.valueInputAttribute(1), EPS);
+		assertEquals(0, transformed2.valueInputAttribute(2), EPS);
+		assertEquals(3.2, transformed2.valueInputAttribute(3), EPS);
+		assertEquals(0, transformed2.valueInputAttribute(4), EPS);
+
+		assertEquals(3, transformed2.valueOutputAttribute(0), EPS);
+		assertEquals(2, transformed2.valueOutputAttribute(1), EPS);
+	}
+
+	@Test
+	public void testTargetPredictionToSource() {
+		Prediction targetPred = new MultiLabelClassificationPrediction(2);
+		targetPred.setVotes(new double[] { 0.5, 1.5 });
+
+		assertEquals(0.5, targetPred.getVotes()[0], EPS);
+		assertEquals(1.5, targetPred.getVotes()[1], EPS);
+	}
+
+	@Test
+	public void testNumInputs() {
+		assertEquals(5, transformed1.numInputAttributes(), EPS);
+		assertEquals(5, transformed2.numInputAttributes(), EPS);
+	}
+
+	@Test
+	public void testNumOutputs() {
+		assertEquals(2, transformed1.numOutputAttributes(), EPS);
+		assertEquals(2, transformed2.numOutputAttributes(), EPS);
+	}
+
+}
diff --git a/moa/src/test/java/moa/learners/predictors/trees/ASHoeffdingTreeTest.java b/moa/src/test/java/moa/learners/predictors/trees/ASHoeffdingTreeTest.java
new file mode 100644
index 000000000..d208ab6e8
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/trees/ASHoeffdingTreeTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * ASHoeffdingTreeTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.trees;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.trees.ASHoeffdingTree;
+
+/**
+ * Tests the ASHoeffdingTree classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class ASHoeffdingTreeTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public ASHoeffdingTreeTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new ASHoeffdingTree(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(ASHoeffdingTreeTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/trees/AdaHoeffdingOptionTreeTest.java b/moa/src/test/java/moa/learners/predictors/trees/AdaHoeffdingOptionTreeTest.java
new file mode 100644
index 000000000..e9c97d256
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/trees/AdaHoeffdingOptionTreeTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * AdaHoeffdingOptionTreeTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.trees;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.trees.AdaHoeffdingOptionTree;
+
+/**
+ * Tests the AdaHoeffdingOptionTree classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class AdaHoeffdingOptionTreeTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public AdaHoeffdingOptionTreeTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new AdaHoeffdingOptionTree(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(AdaHoeffdingOptionTreeTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/trees/DecisionStumpTest.java b/moa/src/test/java/moa/learners/predictors/trees/DecisionStumpTest.java
new file mode 100644
index 000000000..33e364005
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/trees/DecisionStumpTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * DecisionStumpTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.trees;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.trees.DecisionStump;
+
+/**
+ * Tests the DecisionStump classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class DecisionStumpTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public DecisionStumpTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new DecisionStump(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(DecisionStumpTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/trees/EFDTTest.java b/moa/src/test/java/moa/learners/predictors/trees/EFDTTest.java
new file mode 100644
index 000000000..7e130d711
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/trees/EFDTTest.java
@@ -0,0 +1,79 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * EFDTTest.java
+ * Copyright (C) 2019 University of Waikato, Hamilton, NZ
+ */
+
+package moa.learners.predictors.trees;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.trees.EFDT;
+
+/**
+ * Tests the EFDT classifier.
+ *
+ * @author Corey Sterling (csterlin at waikato dot ac dot nz)
+ */
+public class EFDTTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public EFDTTest(String name) {
+		super(name);
+		this.setNumberTests(2);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		EFDT[] result;
+		result = new EFDT[2];
+		result[0] = new EFDT();
+		result[1] = new EFDT();
+		result[1].tieThresholdOption.setValue(0.2);
+
+		return result;
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(EFDTTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/trees/FIMTDDTest.java b/moa/src/test/java/moa/learners/predictors/trees/FIMTDDTest.java
new file mode 100644
index 000000000..aabece1f5
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/trees/FIMTDDTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * FIMTDDTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.trees;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractRegressorTestCase;
+import moa.learners.predictors.Regressor;
+import moa.learners.predictors.trees.FIMTDD;
+
+/**
+ * Tests the FIMTDD classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class FIMTDDTest extends AbstractRegressorTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public FIMTDDTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Regressor[] getLearnerSetups() {
+		return new Regressor[] { new FIMTDD(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(FIMTDDTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/trees/HoeffdingAdaptiveTreeTest.java b/moa/src/test/java/moa/learners/predictors/trees/HoeffdingAdaptiveTreeTest.java
new file mode 100644
index 000000000..73d03a364
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/trees/HoeffdingAdaptiveTreeTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * HoeffdingAdaptiveTreeTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.trees;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.trees.HoeffdingAdaptiveTree;
+
+/**
+ * Tests the HoeffdingAdaptiveTree classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class HoeffdingAdaptiveTreeTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public HoeffdingAdaptiveTreeTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new HoeffdingAdaptiveTree(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(HoeffdingAdaptiveTreeTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/trees/HoeffdingOptionTreeTest.java b/moa/src/test/java/moa/learners/predictors/trees/HoeffdingOptionTreeTest.java
new file mode 100644
index 000000000..d2b9ebcba
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/trees/HoeffdingOptionTreeTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * HoeffdingOptionTreeTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.trees;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.trees.HoeffdingOptionTree;
+
+/**
+ * Tests the HoeffdingOptionTree classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class HoeffdingOptionTreeTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public HoeffdingOptionTreeTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new HoeffdingOptionTree(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(HoeffdingOptionTreeTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/trees/HoeffdingTreeTest.java b/moa/src/test/java/moa/learners/predictors/trees/HoeffdingTreeTest.java
new file mode 100644
index 000000000..8cc69df89
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/trees/HoeffdingTreeTest.java
@@ -0,0 +1,79 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * HoeffdingTreeTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.trees;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.trees.HoeffdingTree;
+
+/**
+ * Tests the HoeffdingTree classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class HoeffdingTreeTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public HoeffdingTreeTest(String name) {
+		super(name);
+		this.setNumberTests(2);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		HoeffdingTree[] result;
+		result = new HoeffdingTree[2];
+		result[0] = new HoeffdingTree();
+		result[1] = new HoeffdingTree();
+		result[1].tieThresholdOption.setValue(0.2);
+
+		return result;
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(HoeffdingTreeTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/trees/LimAttHoeffdingTreeTest.java b/moa/src/test/java/moa/learners/predictors/trees/LimAttHoeffdingTreeTest.java
new file mode 100644
index 000000000..7b411996d
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/trees/LimAttHoeffdingTreeTest.java
@@ -0,0 +1,77 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * LimAttHoeffdingTreeTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.trees;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.trees.LimAttHoeffdingTree;
+
+/**
+ * Tests the LimAttHoeffdingTree classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class LimAttHoeffdingTreeTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public LimAttHoeffdingTreeTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		LimAttHoeffdingTree[] result;
+		result = new LimAttHoeffdingTree[1];
+		result[0] = new LimAttHoeffdingTree();
+		result[0].setlistAttributes(new int[] { 1, 2 });
+		return result;
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(LimAttHoeffdingTreeTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/trees/ORTOTest.java b/moa/src/test/java/moa/learners/predictors/trees/ORTOTest.java
new file mode 100644
index 000000000..99f69fab7
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/trees/ORTOTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * ORTOTest.java
+ * Copyright (C) 2014 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.trees;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractRegressorTestCase;
+import moa.learners.predictors.Regressor;
+import moa.learners.predictors.trees.ORTO;
+
+/**
+ * Tests the ORTO classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class ORTOTest extends AbstractRegressorTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public ORTOTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Regressor[] getLearnerSetups() {
+		return new Regressor[] { new ORTO(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(ORTOTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/learners/predictors/trees/RandomHoeffdingTreeTest.java b/moa/src/test/java/moa/learners/predictors/trees/RandomHoeffdingTreeTest.java
new file mode 100644
index 000000000..ae722d25c
--- /dev/null
+++ b/moa/src/test/java/moa/learners/predictors/trees/RandomHoeffdingTreeTest.java
@@ -0,0 +1,73 @@
+/*
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * RandomHoeffdingTreeTest.java
+ * Copyright (C) 2013 University of Waikato, Hamilton, New Zealand
+ */
+package moa.learners.predictors.trees;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import moa.learners.predictors.AbstractClassifierTestCase;
+import moa.learners.predictors.Classifier;
+import moa.learners.predictors.trees.RandomHoeffdingTree;
+
+/**
+ * Tests the RandomHoeffdingTree classifier.
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
+ * @version $Revision$
+ */
+public class RandomHoeffdingTreeTest extends AbstractClassifierTestCase {
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public RandomHoeffdingTreeTest(String name) {
+		super(name);
+		this.setNumberTests(1);
+	}
+
+	/**
+	 * Returns the classifier setups to use in the regression test.
+	 *
+	 * @return the setups
+	 */
+	@Override
+	protected Classifier[] getLearnerSetups() {
+		return new Classifier[] { new RandomHoeffdingTree(), };
+	}
+
+	/**
+	 * Returns a test suite.
+	 *
+	 * @return the test suite
+	 */
+	public static Test suite() {
+		return new TestSuite(RandomHoeffdingTreeTest.class);
+	}
+
+	/**
+	 * Runs the test from commandline.
+	 *
+	 * @param args ignored
+	 */
+	public static void main(String[] args) {
+		runTest(suite());
+	}
+}
diff --git a/moa/src/test/java/moa/streams/filters/SelectAttributesFilterTest.java b/moa/src/test/java/moa/streams/filters/SelectAttributesFilterTest.java
index 8773d3034..5ef732d36 100644
--- a/moa/src/test/java/moa/streams/filters/SelectAttributesFilterTest.java
+++ b/moa/src/test/java/moa/streams/filters/SelectAttributesFilterTest.java
@@ -16,48 +16,50 @@
  */
 
 public class SelectAttributesFilterTest {
-	private static double EPS=0.00000001;
+	private static double EPS = 0.00000001;
 	private static SelectAttributesFilter filter;
 
 	@BeforeClass
 	public static void setUpBeforeClass() throws Exception {
-		ArffFileStream stream=new ArffFileStream(ClassLoader.getSystemResource("moa/classifiers/data/small_regression.arff").getPath(), "4-6");
-		filter= new SelectAttributesFilter();
-		filter.setInputStream(stream);   
-		// The definition below is problematic as it has overlapping inputs and outputs (index 5)
+		ArffFileStream stream = new ArffFileStream(
+				ClassLoader.getSystemResource("moa/learners/predictors/data/small_regression.arff").getPath(), "4-6");
+		filter = new SelectAttributesFilter();
+		filter.setInputStream(stream);
+		// The definition below is problematic as it has overlapping inputs and outputs
+		// (index 5)
 		// The test has been modified so that this does not occur
 		// filter.inputStringOption.setValue("2-5,8");
 		// filter.outputStringOption.setValue("1,5-7");
 		filter.inputStringOption.setValue("2-5,8");
 		filter.outputStringOption.setValue("1,6-7");
 
-
 	}
+
 	@Test
-	public void testNextInstance(){
-		Instance inst=filter.nextInstance().getData();
+	public void testNextInstance() {
+		Instance inst = filter.nextInstance().getData();
 		assertEquals("F2", inst.inputAttribute(0).name());
 		assertEquals("N1", inst.inputAttribute(1).name());
 		assertEquals("R1", inst.inputAttribute(2).name());
 		assertEquals("R2", inst.inputAttribute(3).name());
 		assertEquals("N2", inst.inputAttribute(4).name());
-		
+
 		assertEquals("F1", inst.outputAttribute(0).name());
 		assertEquals("R3", inst.outputAttribute(1).name());
 		assertEquals("F3", inst.outputAttribute(2).name());
 		assertEquals(8, inst.numAttributes());
-		//Original instance
-		//1.1, -2.3, val3, 1, 2, 3, 3.3, cat1
-		//Filtered instance
-		//-2.3, val3, 1, 2, cat1, 1.1, 2, 3, 3.3
-		assertEquals(-2.3, inst.value(0),EPS);
-		assertEquals(2, inst.value(1),EPS);
-		assertEquals(1, inst.value(2),EPS);
-		assertEquals(2, inst.value(3),EPS);
-		assertEquals(0, inst.value(4),EPS);
-		assertEquals(1.1, inst.value(5),EPS);
-		assertEquals(3, inst.value(6),EPS);
-		assertEquals(3.3, inst.value(7),EPS);
+		// Original instance
+		// 1.1, -2.3, val3, 1, 2, 3, 3.3, cat1
+		// Filtered instance
+		// -2.3, val3, 1, 2, cat1, 1.1, 2, 3, 3.3
+		assertEquals(-2.3, inst.value(0), EPS);
+		assertEquals(2, inst.value(1), EPS);
+		assertEquals(1, inst.value(2), EPS);
+		assertEquals(2, inst.value(3), EPS);
+		assertEquals(0, inst.value(4), EPS);
+		assertEquals(1.1, inst.value(5), EPS);
+		assertEquals(3, inst.value(6), EPS);
+		assertEquals(3.3, inst.value(7), EPS);
 	}
 
 }
diff --git a/moa/src/test/java/moa/test/AbstractTestHelper.java b/moa/src/test/java/moa/test/AbstractTestHelper.java
index 8d59ec6b1..3058cfebe 100644
--- a/moa/src/test/java/moa/test/AbstractTestHelper.java
+++ b/moa/src/test/java/moa/test/AbstractTestHelper.java
@@ -28,215 +28,209 @@
 /**
  * Ancestor for helper classes for tests.
  *
- * @author  fracpete (fracpete at waikato dot ac dot nz)
+ * @author fracpete (fracpete at waikato dot ac dot nz)
  * @version $Revision: 4584 $
  * @param <I> the type of data to process (input)
  * @param <O> the type of data to process (output)
  */
 public abstract class AbstractTestHelper<I, O> {
 
-  /** the owning test case. */
-  protected MoaTestCase m_Owner;
-
-  /** the data directory to use. */
-  protected String m_DataDirectory;
-
-  /**
-   * Initializes the helper class.
-   *
-   * @param owner	the owning test case
-   * @param dataDir	the data directory to use
-   */
-  public AbstractTestHelper(MoaTestCase owner, String dataDir) {
-    super();
-
-    m_Owner         = owner;
-    m_DataDirectory = dataDir;
-  }
-
-  /**
-   * Returns the data directory in use.
-   *
-   * @return		the directory
-   */
-  public String getDataDirectory() {
-    return m_DataDirectory;
-  }
-
-  /**
-   * Returns the tmp directory.
-   *
-   * @return		the tmp directory
-   */
-  public String getTmpDirectory() {
-    return System.getProperty("java.io.tmpdir");
-  }
-
-  /**
-   * Returns the location in the tmp directory for given resource.
-   *
-   * @param resource	the resource (path in project) to get the tmp location for
-   * @return		the tmp location
-   * @see		#getTmpDirectory()
-   */
-  public String getTmpLocationFromResource(String resource) {
-    String	result;
-    File	file;
-
-    file   = new File(resource);
-    result = getTmpDirectory() + File.separator + file.getName();
-
-    return result;
-  }
-
-  /**
-   * Copies the given resource to the tmp directory.
-   *
-   * @param resource	the resource (path in project) to copy
-   * @return		false if copying failed
-   * @see		#getTmpLocationFromResource(String)
-   */
-  public boolean copyResourceToTmp(String resource) {
-    boolean			result;
-    BufferedInputStream		input;
-    BufferedOutputStream	output;
-    byte[]			buffer;
-    int				read;
-    String			ext;
-
-    input    = null;
-    output   = null;
-    resource = getDataDirectory() + "/" + resource;
-
-    try {
-      input  = new BufferedInputStream(ClassLoader.getSystemResourceAsStream(resource));
-      output = new BufferedOutputStream(new FileOutputStream(getTmpLocationFromResource(resource)));
-      buffer = new byte[1024];
-      while ((read = input.read(buffer)) != -1) {
-	output.write(buffer, 0, read);
-	if (read < buffer.length)
-	  break;
-      }
-      result = true;
-    }
-    catch (IOException e) {
-      if (e.getMessage().equals("Stream closed")) {
-	ext = resource.replaceAll(".*\\.", "");
-	System.err.println(
-	    "Resource '" + resource + "' not available? "
-	    + "Or extension '*." + ext + "' not in pom.xml ('project.build.testSourceDirectory') listed?");
-      }
-      e.printStackTrace();
-      result = false;
-    }
-    catch (Exception e) {
-      e.printStackTrace();
-      result = false;
-    }
-
-    if (input != null) {
-      try {
-	input.close();
-      }
-      catch (Exception e) {
-	// ignored
-      }
-    }
-    if (output != null) {
-      try {
-	output.close();
-      }
-      catch (Exception e) {
-	// ignored
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * Copies the given resource to the tmp directory and renames it.
-   *
-   * @param resource	the resource (path in project) to copy
-   * @param newName	the new name of the file
-   * @return		false if copying/renaming failed
-   * @see		#copyResourceToTmp(String)
-   * @see		#renameTmpFile(String, String)
-   */
-  public boolean copyResourceToTmp(String resource, String newName) {
-    boolean	result;
-
-    result = copyResourceToTmp(resource);
-    if (result)
-      result = renameTmpFile(resource, newName);
-
-    return result;
-  }
-
-  /**
-   * Removes the file from the tmp directory.
-   *
-   * @param filename	the file in the tmp directory to delete (no path!)
-   * @return		true if deleting succeeded or file not present
-   * @see		#getTmpLocationFromResource(String)
-   */
-  public boolean deleteFileFromTmp(String filename) {
-    boolean	result;
-    File	file;
-
-    result = true;
-    file   = new File(getTmpDirectory() + File.separator + filename);
-    if (file.exists())
-      result = file.delete();
-
-    return result;
-  }
-
-  /**
-   * Renames a file in the tmp directory.
-   *
-   * @param oldName	the old name of the file
-   * @param newName	the new name of the file
-   * @return		true if renaming succeeded or file not present
-   */
-  public boolean renameTmpFile(String oldName, String newName) {
-    boolean	result;
-    File	oldFile;
-    File	newFile;
-
-    result  = true;
-    oldFile = new File(getTmpDirectory() + File.separator + oldName);
-    if (oldFile.exists()) {
-      newFile = new File(getTmpDirectory() + File.separator + newName);
-      try {
-	FileUtils.move(oldFile, newFile);
-	result = newFile.exists();
-      }
-      catch (Exception e) {
-	System.err.println("Failed to move file '" + oldFile + "' to '" + newFile + "':");
-	e.printStackTrace();
-	result = false;
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * Loads the data to process.
-   *
-   * @param filename	the filename to load (without path)
-   * @return		the data, null if it could not be loaded
-   * @see		#getDataDirectory()
-   */
-  public abstract I load(String filename);
-
-  /**
-   * Saves the data in the tmp directory.
-   *
-   * @param data	the data to save
-   * @param filename	the filename to save to (without path)
-   * @return		true if successfully saved
-   */
-  public abstract boolean save(O data, String filename);
+	/** the owning test case. */
+	protected MoaTestCase m_Owner;
+
+	/** the data directory to use. */
+	protected String m_DataDirectory;
+
+	/**
+	 * Initializes the helper class.
+	 *
+	 * @param owner   the owning test case
+	 * @param dataDir the data directory to use
+	 */
+	public AbstractTestHelper(MoaTestCase owner, String dataDir) {
+		super();
+
+		m_Owner = owner;
+		m_DataDirectory = dataDir;
+	}
+
+	/**
+	 * Returns the data directory in use.
+	 *
+	 * @return the directory
+	 */
+	public String getDataDirectory() {
+		return m_DataDirectory;
+	}
+
+	/**
+	 * Returns the tmp directory.
+	 *
+	 * @return the tmp directory
+	 */
+	public String getTmpDirectory() {
+		return System.getProperty("java.io.tmpdir");
+	}
+
+	/**
+	 * Returns the location in the tmp directory for given resource.
+	 *
+	 * @param resource the resource (path in project) to get the tmp location for
+	 * @return the tmp location
+	 * @see #getTmpDirectory()
+	 */
+	public String getTmpLocationFromResource(String resource) {
+		String result;
+		File file;
+
+		file = new File(resource);
+		result = getTmpDirectory() + File.separator + file.getName();
+
+		return result;
+	}
+
+	/**
+	 * Copies the given resource to the tmp directory.
+	 *
+	 * @param resource the resource (path in project) to copy
+	 * @return false if copying failed
+	 * @see #getTmpLocationFromResource(String)
+	 */
+	public boolean copyResourceToTmp(String resource) {
+		boolean result;
+		BufferedInputStream input;
+		BufferedOutputStream output;
+		byte[] buffer;
+		int read;
+		String ext;
+
+		input = null;
+		output = null;
+		resource = getDataDirectory() + "/" + resource;
+
+		try {
+			input = new BufferedInputStream(ClassLoader.getSystemResourceAsStream(resource));
+			output = new BufferedOutputStream(new FileOutputStream(getTmpLocationFromResource(resource)));
+			buffer = new byte[1024];
+			while ((read = input.read(buffer)) != -1) {
+				output.write(buffer, 0, read);
+				if (read < buffer.length)
+					break;
+			}
+			result = true;
+		} catch (IOException e) {
+			if (e.getMessage().equals("Stream closed")) {
+				ext = resource.replaceAll(".*\\.", "");
+				System.err.println("Resource '" + resource + "' not available? " + "Or extension '*." + ext
+						+ "' not in pom.xml ('project.build.testSourceDirectory') listed?");
+			}
+			e.printStackTrace();
+			result = false;
+		} catch (Exception e) {
+			e.printStackTrace();
+			result = false;
+		}
+
+		if (input != null) {
+			try {
+				input.close();
+			} catch (Exception e) {
+				// ignored
+			}
+		}
+		if (output != null) {
+			try {
+				output.close();
+			} catch (Exception e) {
+				// ignored
+			}
+		}
+
+		return result;
+	}
+
+	/**
+	 * Copies the given resource to the tmp directory and renames it.
+	 *
+	 * @param resource the resource (path in project) to copy
+	 * @param newName  the new name of the file
+	 * @return false if copying/renaming failed
+	 * @see #copyResourceToTmp(String)
+	 * @see #renameTmpFile(String, String)
+	 */
+	public boolean copyResourceToTmp(String resource, String newName) {
+		boolean result;
+
+		result = copyResourceToTmp(resource);
+		if (result)
+			result = renameTmpFile(resource, newName);
+
+		return result;
+	}
+
+	/**
+	 * Removes the file from the tmp directory.
+	 *
+	 * @param filename the file in the tmp directory to delete (no path!)
+	 * @return true if deleting succeeded or file not present
+	 * @see #getTmpLocationFromResource(String)
+	 */
+	public boolean deleteFileFromTmp(String filename) {
+		boolean result;
+		File file;
+
+		result = true;
+		file = new File(getTmpDirectory() + File.separator + filename);
+		if (file.exists())
+			result = file.delete();
+
+		return result;
+	}
+
+	/**
+	 * Renames a file in the tmp directory.
+	 *
+	 * @param oldName the old name of the file
+	 * @param newName the new name of the file
+	 * @return true if renaming succeeded or file not present
+	 */
+	public boolean renameTmpFile(String oldName, String newName) {
+		boolean result;
+		File oldFile;
+		File newFile;
+
+		result = true;
+		oldFile = new File(getTmpDirectory() + File.separator + oldName);
+		if (oldFile.exists()) {
+			newFile = new File(getTmpDirectory() + File.separator + newName);
+			try {
+				FileUtils.move(oldFile, newFile);
+				result = newFile.exists();
+			} catch (Exception e) {
+				System.err.println("Failed to move file '" + oldFile + "' to '" + newFile + "':");
+				e.printStackTrace();
+				result = false;
+			}
+		}
+
+		return result;
+	}
+
+	/**
+	 * Loads the data to process.
+	 *
+	 * @param filename the filename to load (without path)
+	 * @return the data, null if it could not be loaded
+	 * @see #getDataDirectory()
+	 */
+	public abstract I load(String filename);
+
+	/**
+	 * Saves the data in the tmp directory.
+	 *
+	 * @param data     the data to save
+	 * @param filename the filename to save to (without path)
+	 * @return true if successfully saved
+	 */
+	public abstract boolean save(O data, String filename);
 }
diff --git a/moa/src/test/java/moa/test/DiffUtils.java b/moa/src/test/java/moa/test/DiffUtils.java
index 49db121e7..79808769d 100644
--- a/moa/src/test/java/moa/test/DiffUtils.java
+++ b/moa/src/test/java/moa/test/DiffUtils.java
@@ -34,668 +34,658 @@
 /**
  * A helper class for generating diffs between two files, lists of strings.
  *
- * @author  fracpete (fracpete at waikato dot ac dot nz)
+ * @author fracpete (fracpete at waikato dot ac dot nz)
  * @version $Revision: 6358 $
  */
 public class DiffUtils {
 
-  /** the indicator for "changed". */
-  public final static char INDICATOR_CHANGED = 'c';
-
-  /** the indicator for "added". */
-  public final static char INDICATOR_ADDED = 'a';
-
-  /** the indicator for "deleted". */
-  public final static char INDICATOR_DELETED = 'd';
-
-  /** the indicator for "same". */
-  public final static char INDICATOR_SAME = ' ';
-
-  /** the source indicator. */
-  public final static String SOURCE = "<";
-
-  /** the destination indicator. */
-  public final static String DESTINATION = ">";
-
-  /** the separator for the unified output. */
-  public final static String SEPARATOR_UNIFIED = "---";
-
-  /** the separator for the side-by-side output on the command-line. */
-  public final static String SEPARATOR_SIDEBYSIDE = " | ";
-
-  /** the unified option. */
-  public final static String OPTION_UNIFIED = "unified";
-
-  /** the side-by-side option. */
-  public final static String OPTION_SIDEBYSIDE = "side-by-side";
-
-  /** the brief option. */
-  public final static String OPTION_BRIEF = "brief";
-
-  /** the number of array elements in side-by-side diff. */
-  public final static int SIDEBYSIDE_SIZE = 5;
-
-  /** the index for the first file in side-by-side diff. */
-  public final static int SIDEBYSIDE_FIRST = 0;
-
-  /** the index for the second file in side-by-side diff. */
-  public final static int SIDEBYSIDE_SECOND = 1;
-
-  /** the index for the indicator list in side-by-side diff. */
-  public final static int SIDEBYSIDE_INDICATOR = 2;
-
-  /** the index for the list of start positions of deltas in side-by-side diff. */
-  public final static int SIDEBYSIDE_STARTPOS = 3;
-
-  /** the index for the list of end positions of deltas in side-by-side diff. */
-  public final static int SIDEBYSIDE_ENDPOS = 4;
-
-  /**
-   * Container object for a side-by-side diff.
-   *
-   * @author  fracpete (fracpete at waikato dot ac dot nz)
-   * @version $Revision: 6358 $
-   */
-  public static class SideBySideDiff
-    implements Serializable, Cloneable {
-
-    /** for serialization. */
-    private static final long serialVersionUID = -6775907286936991130L;
-
-    /** the diff information. */
-    protected List[] m_Diff;
-
-    /**
-     * Initializes the container with an empty diff.
-     */
-    public SideBySideDiff() {
-      this(
-	  new List[]{
-	      new ArrayList(),
-	      new ArrayList(),
-	      new ArrayList(),
-	      new ArrayList(),
-	      new ArrayList()});
-    }
-
-    /**
-     * Initializes the container.
-     */
-    public SideBySideDiff(List[] diff) {
-      if (diff.length != SIDEBYSIDE_SIZE)
-	throw new IllegalArgumentException("Expected array with length " + SIDEBYSIDE_SIZE + " but got: " + diff.length);
-      m_Diff = diff.clone();
-    }
-
-    /**
-     * Return the diff of the left/first list/file.
-     *
-     * @return		the diff
-     */
-    public List getLeft() {
-      return m_Diff[SIDEBYSIDE_FIRST];
-    }
-
-    /**
-     * Return the diff of the right/second list/file.
-     *
-     * @return		the diff
-     */
-    public List getRight() {
-      return m_Diff[SIDEBYSIDE_SECOND];
-    }
-
-    /**
-     * Returns the indicator list.
-     *
-     * @return		the indicator
-     */
-    public List getIndicator() {
-      return m_Diff[SIDEBYSIDE_INDICATOR];
-    }
-
-    /**
-     * Return the list with starting positions of the deltas.
-     *
-     * @return		the list with start positions
-     */
-    public List getStartPos() {
-      return m_Diff[SIDEBYSIDE_STARTPOS];
-    }
-
-    /**
-     * Returns whether there are any differences between the two files/lists.
-     *
-     * @return		true if there are differences
-     */
-    public boolean hasDifferences() {
-      return (m_Diff[SIDEBYSIDE_STARTPOS].size() > 0);
-    }
-
-    /**
-     * Returns the number of differences.
-     *
-     * @return		the number of differences
-     */
-    public int differences() {
-      return m_Diff[SIDEBYSIDE_STARTPOS].size();
-    }
-
-    /**
-     * Returns the closest patch delta index for the given line number.
-     *
-     * @param line	the 0-based line number
-     * @return		the index of the delta, -1 if no delta matched
-     */
-    public int lineToDelta(int line) {
-      int	result;
-      int	i;
-      List	start;
-      List	end;
-
-      result = -1;
-
-      if (!hasDifferences())
-	return result;
-
-      start = m_Diff[SIDEBYSIDE_STARTPOS];
-      end   = m_Diff[SIDEBYSIDE_ENDPOS];
-      for (i = 0; i < start.size(); i++) {
-	if ((((Integer) start.get(i)) >= line) && (line <= ((Integer) end.get(i)))) {
-	  result = i;
-	  break;
+	/** the indicator for "changed". */
+	public final static char INDICATOR_CHANGED = 'c';
+
+	/** the indicator for "added". */
+	public final static char INDICATOR_ADDED = 'a';
+
+	/** the indicator for "deleted". */
+	public final static char INDICATOR_DELETED = 'd';
+
+	/** the indicator for "same". */
+	public final static char INDICATOR_SAME = ' ';
+
+	/** the source indicator. */
+	public final static String SOURCE = "<";
+
+	/** the destination indicator. */
+	public final static String DESTINATION = ">";
+
+	/** the separator for the unified output. */
+	public final static String SEPARATOR_UNIFIED = "---";
+
+	/** the separator for the side-by-side output on the command-line. */
+	public final static String SEPARATOR_SIDEBYSIDE = " | ";
+
+	/** the unified option. */
+	public final static String OPTION_UNIFIED = "unified";
+
+	/** the side-by-side option. */
+	public final static String OPTION_SIDEBYSIDE = "side-by-side";
+
+	/** the brief option. */
+	public final static String OPTION_BRIEF = "brief";
+
+	/** the number of array elements in side-by-side diff. */
+	public final static int SIDEBYSIDE_SIZE = 5;
+
+	/** the index for the first file in side-by-side diff. */
+	public final static int SIDEBYSIDE_FIRST = 0;
+
+	/** the index for the second file in side-by-side diff. */
+	public final static int SIDEBYSIDE_SECOND = 1;
+
+	/** the index for the indicator list in side-by-side diff. */
+	public final static int SIDEBYSIDE_INDICATOR = 2;
+
+	/** the index for the list of start positions of deltas in side-by-side diff. */
+	public final static int SIDEBYSIDE_STARTPOS = 3;
+
+	/** the index for the list of end positions of deltas in side-by-side diff. */
+	public final static int SIDEBYSIDE_ENDPOS = 4;
+
+	/**
+	 * Container object for a side-by-side diff.
+	 *
+	 * @author fracpete (fracpete at waikato dot ac dot nz)
+	 * @version $Revision: 6358 $
+	 */
+	public static class SideBySideDiff implements Serializable, Cloneable {
+
+		/** for serialization. */
+		private static final long serialVersionUID = -6775907286936991130L;
+
+		/** the diff information. */
+		protected List[] m_Diff;
+
+		/**
+		 * Initializes the container with an empty diff.
+		 */
+		public SideBySideDiff() {
+			this(new List[] { new ArrayList(), new ArrayList(), new ArrayList(), new ArrayList(), new ArrayList() });
+		}
+
+		/**
+		 * Initializes the container.
+		 */
+		public SideBySideDiff(List[] diff) {
+			if (diff.length != SIDEBYSIDE_SIZE)
+				throw new IllegalArgumentException(
+						"Expected array with length " + SIDEBYSIDE_SIZE + " but got: " + diff.length);
+			m_Diff = diff.clone();
+		}
+
+		/**
+		 * Return the diff of the left/first list/file.
+		 *
+		 * @return the diff
+		 */
+		public List getLeft() {
+			return m_Diff[SIDEBYSIDE_FIRST];
+		}
+
+		/**
+		 * Return the diff of the right/second list/file.
+		 *
+		 * @return the diff
+		 */
+		public List getRight() {
+			return m_Diff[SIDEBYSIDE_SECOND];
+		}
+
+		/**
+		 * Returns the indicator list.
+		 *
+		 * @return the indicator
+		 */
+		public List getIndicator() {
+			return m_Diff[SIDEBYSIDE_INDICATOR];
+		}
+
+		/**
+		 * Return the list with starting positions of the deltas.
+		 *
+		 * @return the list with start positions
+		 */
+		public List getStartPos() {
+			return m_Diff[SIDEBYSIDE_STARTPOS];
+		}
+
+		/**
+		 * Returns whether there are any differences between the two files/lists.
+		 *
+		 * @return true if there are differences
+		 */
+		public boolean hasDifferences() {
+			return (m_Diff[SIDEBYSIDE_STARTPOS].size() > 0);
+		}
+
+		/**
+		 * Returns the number of differences.
+		 *
+		 * @return the number of differences
+		 */
+		public int differences() {
+			return m_Diff[SIDEBYSIDE_STARTPOS].size();
+		}
+
+		/**
+		 * Returns the closest patch delta index for the given line number.
+		 *
+		 * @param line the 0-based line number
+		 * @return the index of the delta, -1 if no delta matched
+		 */
+		public int lineToDelta(int line) {
+			int result;
+			int i;
+			List start;
+			List end;
+
+			result = -1;
+
+			if (!hasDifferences())
+				return result;
+
+			start = m_Diff[SIDEBYSIDE_STARTPOS];
+			end = m_Diff[SIDEBYSIDE_ENDPOS];
+			for (i = 0; i < start.size(); i++) {
+				if ((((Integer) start.get(i)) >= line) && (line <= ((Integer) end.get(i)))) {
+					result = i;
+					break;
+				}
+			}
+
+			return result;
+		}
+
+		/**
+		 * Returns the line number (start or end) of the given delta.
+		 *
+		 * @param delta the 0-based delta index
+		 * @return the line number, -1 if failed to determine
+		 */
+		public int deltaToLine(int delta, boolean start) {
+			int result;
+
+			result = -1;
+
+			if ((delta >= 0) && (delta < m_Diff[SIDEBYSIDE_STARTPOS].size())) {
+				if (start)
+					result = (Integer) m_Diff[SIDEBYSIDE_STARTPOS].get(delta);
+				else
+					result = (Integer) m_Diff[SIDEBYSIDE_ENDPOS].get(delta);
+			}
+
+			return result;
+		}
+
+		/**
+		 * Checks whether there is a next delta after the current line.
+		 *
+		 * @param line the current line number (0-based)
+		 * @return the next delta index, -1 if none available
+		 */
+		public boolean hasNextDelta(int line) {
+			return (getNextDelta(line) != -1);
+		}
+
+		/**
+		 * Returns the next delta after the current line.
+		 *
+		 * @param line the current line number (0-based)
+		 * @return the next delta index, -1 if none available
+		 */
+		public int getNextDelta(int line) {
+			int result;
+			int delta;
+
+			result = -1;
+			delta = lineToDelta(line);
+			if (delta == -1)
+				return result;
+
+			delta++;
+			if (delta < m_Diff[SIDEBYSIDE_STARTPOS].size())
+				result = delta;
+
+			return result;
+		}
+
+		/**
+		 * Checks whether there is a previous delta after the current line.
+		 *
+		 * @param line the current line number (0-based)
+		 * @return the previous delta index, -1 if none available
+		 */
+		public boolean hasPreviousDelta(int line) {
+			return (getPreviousDelta(line) != -1);
+		}
+
+		/**
+		 * Returns the previous delta after the current line.
+		 *
+		 * @param line the current line number (0-based)
+		 * @return the previous delta index, -1 if none available
+		 */
+		public int getPreviousDelta(int line) {
+			int result;
+			int delta;
+
+			result = -1;
+			delta = lineToDelta(line);
+			if (delta == -1)
+				return result;
+
+			delta--;
+			if (delta >= 0)
+				result = delta;
+
+			return result;
+		}
+
+		/**
+		 * Returns a clone if itself.
+		 *
+		 * @return the clone
+		 */
+		@Override
+		public SideBySideDiff clone() {
+			return new SideBySideDiff(m_Diff);
+		}
+
+		/**
+		 * Generates a string representation of the diff information.
+		 *
+		 * @param separator the separator between the columns
+		 * @return the string representation
+		 */
+		public String toString(String separator) {
+			StringBuilder result;
+			int i;
+
+			result = new StringBuilder();
+
+			for (i = 0; i < m_Diff[SIDEBYSIDE_FIRST].size(); i++) {
+				result.append(m_Diff[SIDEBYSIDE_INDICATOR].get(i));
+				result.append(separator);
+				result.append(m_Diff[SIDEBYSIDE_FIRST].get(i));
+				result.append(separator);
+				result.append(m_Diff[SIDEBYSIDE_SECOND].get(i));
+				result.append("\n");
+			}
+
+			return result.toString();
+		}
+
+		/**
+		 * Generates a string representation of the diff information.
+		 *
+		 * @return the string representation
+		 */
+		@Override
+		public String toString() {
+			return toString(SEPARATOR_SIDEBYSIDE);
+		}
+	}
+
+	/**
+	 * A helper class for the side-by-side diff.
+	 *
+	 * @author fracpete (fracpete at waikato dot ac dot nz)
+	 * @version $Revision: 6358 $
+	 */
+	public static class Filler implements Serializable {
+
+		/** for serialization. */
+		private static final long serialVersionUID = 3295616348711569065L;
+
+		/**
+		 * Indicates whether some other object is "equal to" this one.
+		 *
+		 * @param obj the reference object with which to compare.
+		 * @return <code>true</code> if the object is a {@link Filler} instance
+		 */
+		@Override
+		public boolean equals(Object obj) {
+			if (obj == null)
+				return false;
+			else if (obj instanceof Filler)
+				return true;
+			else
+				return false;
+		}
+
+		/**
+		 * Returns a hash code value for the object. This method is supported for the
+		 * benefit of hashtables such as those provided by
+		 * <code>java.util.Hashtable</code>.
+		 *
+		 * @return a hash code value for this object.
+		 */
+		@Override
+		public int hashCode() {
+			return toString().hashCode();
+		}
+
+		/**
+		 * Returns an empty string.
+		 *
+		 * @return empty string
+		 */
+		@Override
+		public String toString() {
+			return "";
+		}
+	}
+
+	/**
+	 * Loads the file. If file points to a directory, an empty vector is returned
+	 * instead.
+	 *
+	 * @param file the file to load
+	 * @return the content of the file, empty vector if directory
+	 */
+	protected static List<String> loadFromFile(File file) {
+		if (file.isDirectory())
+			return new ArrayList<>();
+		else
+			return FileUtils.loadFromFile(file);
+	}
+
+	/**
+	 * Returns whether the two files differ.
+	 *
+	 * @param file1 the first text file
+	 * @param file2 the second text file
+	 * @return true if different
+	 */
+	public static boolean isDifferent(File file1, File file2) {
+		return isDifferent(loadFromFile(file1), loadFromFile(file2));
+	}
+
+	/**
+	 * Returns whether the two lists differ.
+	 *
+	 * @param file1 the first list
+	 * @param file2 the second list
+	 * @return true if different
+	 */
+	public static boolean isDifferent(String[] list1, String[] list2) {
+		return isDifferent(Arrays.asList(list1), Arrays.asList(list2));
+	}
+
+	/**
+	 * Returns whether the two lists differ.
+	 *
+	 * @param file1 the first text file
+	 * @param file2 the second text file
+	 * @return the side-by-side diff (first file: index 0, second file: index 1,
+	 *         indicator: )
+	 */
+	public static boolean isDifferent(List<String> list1, List<String> list2) {
+		boolean result;
+		Patch patch;
+
+		patch = difflib.DiffUtils.diff(list1, list2);
+		result = (patch.getDeltas().size() > 0);
+
+		return result;
+	}
+
+	/**
+	 * Assembles the lines into a string.
+	 *
+	 * @param ind   the indicator string
+	 * @param lines the underlying lines
+	 * @return the generated string
+	 */
+	protected static String toString(String ind, List lines) {
+		StringBuilder result;
+
+		result = new StringBuilder();
+
+		for (Object line : lines)
+			result.append(ind + " " + line + "\n");
+
+		return result.toString();
+	}
+
+	/**
+	 * Generates a unified diff for the two files.
+	 *
+	 * @param file1 the first text file
+	 * @param file2 the second text file
+	 * @return the unified diff
+	 */
+	public static String unified(File file1, File file2) {
+		return unified(loadFromFile(file1), loadFromFile(file2));
+	}
+
+	/**
+	 * Creates a range string.
+	 *
+	 * @param chunk the chunk to create the range string for
+	 * @return the range string
+	 */
+	protected static String createRange(Chunk chunk) {
+		if (chunk.size() == 1)
+			return (chunk.getPosition() + 1) + "";
+		else
+			return (chunk.getPosition() + 1) + "," + (chunk.getPosition() + chunk.size());
+	}
+
+	/**
+	 * Generates a unified diff for the two lists.
+	 *
+	 * @param file1 the first list
+	 * @param file2 the second list
+	 * @return the unified diff
+	 */
+	public static String unified(List<String> list1, List<String> list2) {
+		StringBuilder result;
+		Patch patch;
+
+		patch = difflib.DiffUtils.diff(list1, list2);
+		result = new StringBuilder();
+		for (Delta delta : patch.getDeltas()) {
+			if (delta instanceof InsertDelta) {
+				result.append(delta.getOriginal().getPosition() + "a" + createRange(delta.getRevised()) + "\n");
+				result.append(toString(DESTINATION, delta.getRevised().getLines()));
+			} else if (delta instanceof DeleteDelta) {
+				result.append(createRange(delta.getOriginal()) + "d" + delta.getRevised().getPosition() + "\n");
+				result.append(toString(SOURCE, delta.getOriginal().getLines()));
+			} else {
+				result.append(createRange(delta.getOriginal()) + "c");
+				result.append(createRange(delta.getRevised()) + "\n");
+				result.append(toString(SOURCE, delta.getOriginal().getLines()));
+				result.append(SEPARATOR_UNIFIED + "\n");
+				result.append(toString(DESTINATION, delta.getRevised().getLines()));
+			}
+		}
+
+		return result.toString();
+	}
+
+	/**
+	 * Generates a side-by-side diff for the two files.
+	 *
+	 * @param file1 the first text file
+	 * @param file2 the second text file
+	 * @return the side-by-side diff
+	 */
+	public static SideBySideDiff sideBySide(File file1, File file2) {
+		return sideBySide(loadFromFile(file1), loadFromFile(file2));
+	}
+
+	/**
+	 * Generates a side-by-side diff for the two lists.
+	 *
+	 * @param file1 the first list
+	 * @param file2 the second list
+	 * @return the side-by-side diff
+	 */
+	public static SideBySideDiff sideBySide(String[] list1, String[] list2) {
+		return sideBySide(Arrays.asList(list1), Arrays.asList(list2));
+	}
+
+	/**
+	 * Adds the specified contents of the source list to the destination list.
+	 *
+	 * @param from   the starting index
+	 * @param to     the ending index (included)
+	 * @param source the source list
+	 * @param dest   the destination of the data
+	 */
+	protected static void addToList(int from, int to, List<String> source, List dest) {
+		for (int i = from; i <= to; i++)
+			dest.add(source.get(i));
+	}
+
+	/**
+	 * Adds the object to the destination list.
+	 *
+	 * @param from the starting index
+	 * @param to   the ending index (included)
+	 * @param dest the destination of the data
+	 */
+	protected static void addToList(int from, int to, Object obj, List dest) {
+		for (int i = from; i <= to; i++)
+			dest.add(obj);
+	}
+
+	/**
+	 * Generates a side-by-side diff for the two lists.
+	 *
+	 * @param file1 the first text file
+	 * @param file2 the second text file
+	 * @return the side-by-side diff
+	 */
+	public static SideBySideDiff sideBySide(List<String> list1, List<String> list2) {
+		List[] result;
+		Patch patch;
+		int from;
+		int to;
+		int sizeDiff;
+
+		result = new List[SIDEBYSIDE_SIZE];
+		result[SIDEBYSIDE_FIRST] = new ArrayList();
+		result[SIDEBYSIDE_SECOND] = new ArrayList();
+		result[SIDEBYSIDE_INDICATOR] = new ArrayList();
+		result[SIDEBYSIDE_STARTPOS] = new ArrayList();
+		result[SIDEBYSIDE_ENDPOS] = new ArrayList();
+		patch = difflib.DiffUtils.diff(list1, list2);
+
+		// the same?
+		if (patch.getDeltas().size() == 0) {
+			result[SIDEBYSIDE_FIRST].addAll(list1);
+			result[SIDEBYSIDE_SECOND].addAll(list2);
+			addToList(0, list1.size() - 1, INDICATOR_SAME, result[SIDEBYSIDE_INDICATOR]);
+			return new SideBySideDiff(result);
+		}
+
+		to = 0;
+		for (Delta delta : patch.getDeltas()) {
+			from = to;
+
+			// common content
+			to = delta.getOriginal().getPosition() - 1;
+			addToList(from, to, list1, result[SIDEBYSIDE_FIRST]);
+			addToList(from, to, list1, result[SIDEBYSIDE_SECOND]);
+			addToList(from, to, INDICATOR_SAME, result[SIDEBYSIDE_INDICATOR]);
+
+			// start pos of delta
+			result[SIDEBYSIDE_STARTPOS].add(result[SIDEBYSIDE_FIRST].size());
+
+			if (delta instanceof InsertDelta) {
+				// added content
+				addToList(0, delta.getRevised().size() - 1, new Filler(), result[SIDEBYSIDE_FIRST]);
+				result[SIDEBYSIDE_SECOND].addAll(delta.getRevised().getLines());
+				addToList(0, delta.getRevised().size() - 1, INDICATOR_ADDED, result[SIDEBYSIDE_INDICATOR]);
+				to = delta.getOriginal().getPosition() + delta.getOriginal().size();
+			} else if (delta instanceof DeleteDelta) {
+				// deleted content
+				result[SIDEBYSIDE_FIRST].addAll(delta.getOriginal().getLines());
+				addToList(0, delta.getOriginal().size() - 1, new Filler(), result[SIDEBYSIDE_SECOND]);
+				addToList(0, delta.getOriginal().size() - 1, INDICATOR_DELETED, result[SIDEBYSIDE_INDICATOR]);
+				to = delta.getOriginal().getPosition() + delta.getOriginal().size();
+			} else {
+				// changed content
+				result[SIDEBYSIDE_FIRST].addAll(delta.getOriginal().getLines());
+				result[SIDEBYSIDE_SECOND].addAll(delta.getRevised().getLines());
+				addToList(1, Math.max(delta.getOriginal().size(), delta.getRevised().size()), INDICATOR_CHANGED,
+						result[SIDEBYSIDE_INDICATOR]);
+				// filler necessary?
+				sizeDiff = delta.getRevised().size() - delta.getOriginal().size();
+				if (sizeDiff > 0)
+					addToList(1, sizeDiff, new Filler(), result[SIDEBYSIDE_FIRST]);
+				if (sizeDiff < 0)
+					addToList(1, -sizeDiff, new Filler(), result[SIDEBYSIDE_SECOND]);
+				to = delta.getOriginal().getPosition() + delta.getOriginal().size();
+			}
+
+			// end pos of delta
+			result[SIDEBYSIDE_ENDPOS].add(result[SIDEBYSIDE_FIRST].size());
+		}
+
+		// trailing common content?
+		if (to < list1.size()) {
+			addToList(to, list1.size() - 1, list1, result[SIDEBYSIDE_FIRST]);
+			addToList(to, list1.size() - 1, list1, result[SIDEBYSIDE_SECOND]);
+			addToList(to, list1.size() - 1, INDICATOR_SAME, result[SIDEBYSIDE_INDICATOR]);
+		}
+
+		return new SideBySideDiff(result);
+	}
+
+	/**
+	 * Usage: DiffUtils &lt;unified|side-by-side|brief&gt; &lt;file1&gt;
+	 * &lt;file2&gt;
+	 *
+	 * @param args the files to compare
+	 * @throws Exception if comparison fails
+	 */
+	public static void main(String[] args) throws Exception {
+		if (args.length == 3) {
+			File file1 = new File(args[1]);
+			if (file1.isDirectory()) {
+				System.err.println("File '" + file1 + "' is a directory!");
+				return;
+			}
+			if (!file1.exists()) {
+				System.err.println("File '" + file1 + "' does not exist!");
+				return;
+			}
+			File file2 = new File(args[2]);
+			if (file2.isDirectory()) {
+				System.err.println("File '" + file2 + "' is a directory!");
+				return;
+			}
+			if (!file2.exists()) {
+				System.err.println("File '" + file2 + "' does not exist!");
+				return;
+			}
+			if (args[0].equals(OPTION_UNIFIED)) {
+				System.out.println(unified(file1, file2));
+			} else if (args[0].equals(OPTION_SIDEBYSIDE)) {
+				System.out.println(sideBySide(file1, file2));
+			} else if (args[0].equals(OPTION_BRIEF)) {
+				if (isDifferent(file1, file2))
+					System.out.println("Files " + file1 + " and " + file2 + " differ");
+			} else {
+				System.err.println("Only '" + OPTION_UNIFIED + "', '" + OPTION_SIDEBYSIDE + "' and '" + OPTION_BRIEF
+						+ "' are available as options!");
+				return;
+			}
+		} else {
+			System.err.println("\nUsage: " + DiffUtils.class.getName() + " <" + OPTION_UNIFIED + "|" + OPTION_SIDEBYSIDE
+					+ "|" + OPTION_BRIEF + "> <file1> <file2>\n");
+			return;
+		}
 	}
-      }
-
-      return result;
-    }
-
-    /**
-     * Returns the line number (start or end) of the given delta.
-     *
-     * @param delta	the 0-based delta index
-     * @return		the line number, -1 if failed to determine
-     */
-    public int deltaToLine(int delta, boolean start) {
-      int	result;
-
-      result = -1;
-
-      if ((delta >= 0) && (delta < m_Diff[SIDEBYSIDE_STARTPOS].size())) {
-	if (start)
-	  result = (Integer) m_Diff[SIDEBYSIDE_STARTPOS].get(delta);
-	else
-	  result = (Integer) m_Diff[SIDEBYSIDE_ENDPOS].get(delta);
-      }
-
-      return result;
-    }
-
-    /**
-     * Checks whether there is a next delta after the current line.
-     *
-     * @param line	the current line number (0-based)
-     * @return		the next delta index, -1 if none available
-     */
-    public boolean hasNextDelta(int line) {
-      return (getNextDelta(line) != -1);
-    }
-
-    /**
-     * Returns the next delta after the current line.
-     *
-     * @param line	the current line number (0-based)
-     * @return		the next delta index, -1 if none available
-     */
-    public int getNextDelta(int line) {
-      int	result;
-      int	delta;
-
-      result = -1;
-      delta  = lineToDelta(line);
-      if (delta == -1)
-	return result;
-
-      delta++;
-      if (delta < m_Diff[SIDEBYSIDE_STARTPOS].size())
-	result = delta;
-
-      return result;
-    }
-
-    /**
-     * Checks whether there is a previous delta after the current line.
-     *
-     * @param line	the current line number (0-based)
-     * @return		the previous delta index, -1 if none available
-     */
-    public boolean hasPreviousDelta(int line) {
-      return (getPreviousDelta(line) != -1);
-    }
-
-    /**
-     * Returns the previous delta after the current line.
-     *
-     * @param line	the current line number (0-based)
-     * @return		the previous delta index, -1 if none available
-     */
-    public int getPreviousDelta(int line) {
-      int	result;
-      int	delta;
-
-      result = -1;
-      delta  = lineToDelta(line);
-      if (delta == -1)
-	return result;
-
-      delta--;
-      if (delta >= 0)
-	result = delta;
-
-      return result;
-    }
-
-    /**
-     * Returns a clone if itself.
-     *
-     * @return		the clone
-     */
-    @Override
-    public SideBySideDiff clone() {
-      return new SideBySideDiff(m_Diff);
-    }
-
-    /**
-     * Generates a string representation of the diff information.
-     *
-     * @param separator	the separator between the columns
-     * @return		the string representation
-     */
-    public String toString(String separator) {
-      StringBuilder	result;
-      int		i;
-
-      result = new StringBuilder();
-
-      for (i = 0; i < m_Diff[SIDEBYSIDE_FIRST].size(); i++) {
-	result.append(m_Diff[SIDEBYSIDE_INDICATOR].get(i));
-	result.append(separator);
-	result.append(m_Diff[SIDEBYSIDE_FIRST].get(i));
-	result.append(separator);
-	result.append(m_Diff[SIDEBYSIDE_SECOND].get(i));
-	result.append("\n");
-      }
-
-      return result.toString();
-    }
-
-    /**
-     * Generates a string representation of the diff information.
-     *
-     * @return		the string representation
-     */
-    @Override
-    public String toString() {
-      return toString(SEPARATOR_SIDEBYSIDE);
-    }
-  }
-
-  /**
-   * A helper class for the side-by-side diff.
-   *
-   * @author  fracpete (fracpete at waikato dot ac dot nz)
-   * @version $Revision: 6358 $
-   */
-  public static class Filler
-    implements Serializable {
-
-    /** for serialization. */
-    private static final long serialVersionUID = 3295616348711569065L;
-
-    /**
-     * Indicates whether some other object is "equal to" this one.
-     *
-     * @param   obj   the reference object with which to compare.
-     * @return  <code>true</code> if the object is a {@link Filler} instance
-     */
-    @Override
-    public boolean equals(Object obj) {
-      if (obj == null)
-	return false;
-      else if (obj instanceof Filler)
-	return true;
-      else
-	return false;
-    }
-
-    /**
-     * Returns a hash code value for the object. This method is
-     * supported for the benefit of hashtables such as those provided by
-     * <code>java.util.Hashtable</code>.
-     *
-     * @return  a hash code value for this object.
-     */
-    @Override
-    public int hashCode() {
-      return toString().hashCode();
-    }
-
-    /**
-     * Returns an empty string.
-     *
-     * @return		empty string
-     */
-    @Override
-    public String toString() {
-      return "";
-    }
-  }
-
-  /**
-   * Loads the file. If file points to a directory, an empty vector is
-   * returned instead.
-   *
-   * @param file	the file to load
-   * @return		the content of the file, empty vector if directory
-   */
-  protected static List<String> loadFromFile(File file) {
-    if (file.isDirectory())
-      return new ArrayList<String>();
-    else
-      return FileUtils.loadFromFile(file);
-  }
-
-  /**
-   * Returns whether the two files differ.
-   *
-   * @param file1	the first text file
-   * @param file2	the second text file
-   * @return		true if different
-   */
-  public static boolean isDifferent(File file1, File file2) {
-    return isDifferent(loadFromFile(file1), loadFromFile(file2));
-  }
-
-  /**
-   * Returns whether the two lists differ.
-   *
-   * @param file1	the first list
-   * @param file2	the second list
-   * @return		true if different
-   */
-  public static boolean isDifferent(String[] list1, String[] list2) {
-    return isDifferent(Arrays.asList(list1), Arrays.asList(list2));
-  }
-
-  /**
-   * Returns whether the two lists differ.
-   *
-   * @param file1	the first text file
-   * @param file2	the second text file
-   * @return		the side-by-side diff (first file: index 0, second file: index 1, indicator: )
-   */
-  public static boolean isDifferent(List<String> list1, List<String> list2) {
-    boolean	result;
-    Patch	patch;
-
-    patch  = difflib.DiffUtils.diff(list1, list2);
-    result = (patch.getDeltas().size() > 0);
-
-    return result;
-  }
-
-  /**
-   * Assembles the lines into a string.
-   *
-   * @param ind		the indicator string
-   * @param lines	the underlying lines
-   * @return		the generated string
-   */
-  protected static String toString(String ind, List lines) {
-    StringBuilder	result;
-
-    result = new StringBuilder();
-
-    for (Object line: lines)
-      result.append(ind + " " + line + "\n");
-
-    return result.toString();
-  }
-
-  /**
-   * Generates a unified diff for the two files.
-   *
-   * @param file1	the first text file
-   * @param file2	the second text file
-   * @return		the unified diff
-   */
-  public static String unified(File file1, File file2) {
-    return unified(loadFromFile(file1), loadFromFile(file2));
-  }
-
-  /**
-   * Creates a range string.
-   *
-   * @param chunk	the chunk to create the range string for
-   * @return		the range string
-   */
-  protected static String createRange(Chunk chunk) {
-    if (chunk.size() == 1)
-      return (chunk.getPosition() + 1) + "";
-    else
-      return (chunk.getPosition() + 1) + "," + (chunk.getPosition() + chunk.size());
-  }
-
-  /**
-   * Generates a unified diff for the two lists.
-   *
-   * @param file1	the first list
-   * @param file2	the second list
-   * @return		the unified diff
-   */
-  public static String unified(List<String> list1, List<String> list2) {
-    StringBuilder	result;
-    Patch		patch;
-
-    patch  = difflib.DiffUtils.diff(list1, list2);
-    result = new StringBuilder();
-    for (Delta delta: patch.getDeltas()) {
-      if (delta instanceof InsertDelta) {
-	result.append(delta.getOriginal().getPosition() + "a" + createRange(delta.getRevised()) + "\n");
-	result.append(toString(DESTINATION, delta.getRevised().getLines()));
-      }
-      else if (delta instanceof DeleteDelta) {
-	result.append(createRange(delta.getOriginal()) + "d" + delta.getRevised().getPosition() + "\n");
-	result.append(toString(SOURCE, delta.getOriginal().getLines()));
-      }
-      else {
-	result.append(createRange(delta.getOriginal()) + "c");
-	result.append(createRange(delta.getRevised()) + "\n");
-	result.append(toString(SOURCE, delta.getOriginal().getLines()));
-	result.append(SEPARATOR_UNIFIED + "\n");
-	result.append(toString(DESTINATION, delta.getRevised().getLines()));
-      }
-    }
-
-    return result.toString();
-  }
-
-  /**
-   * Generates a side-by-side diff for the two files.
-   *
-   * @param file1	the first text file
-   * @param file2	the second text file
-   * @return		the side-by-side diff
-   */
-  public static SideBySideDiff sideBySide(File file1, File file2) {
-    return sideBySide(loadFromFile(file1), loadFromFile(file2));
-  }
-
-  /**
-   * Generates a side-by-side diff for the two lists.
-   *
-   * @param file1	the first list
-   * @param file2	the second list
-   * @return		the side-by-side diff
-   */
-  public static SideBySideDiff sideBySide(String[] list1, String[] list2) {
-    return sideBySide(Arrays.asList(list1), Arrays.asList(list2));
-  }
-
-  /**
-   * Adds the specified contents of the source list to the destination list.
-   *
-   * @param from	the starting index
-   * @param to		the ending index (included)
-   * @param source	the source list
-   * @param dest	the destination of the data
-   */
-  protected static void addToList(int from, int to, List<String> source, List dest) {
-    for (int i = from; i <= to; i++)
-      dest.add(source.get(i));
-  }
-
-  /**
-   * Adds the object to the destination list.
-   *
-   * @param from	the starting index
-   * @param to		the ending index (included)
-   * @param dest	the destination of the data
-   */
-  protected static void addToList(int from, int to, Object obj, List dest) {
-    for (int i = from; i <= to; i++)
-      dest.add(obj);
-  }
-
-  /**
-   * Generates a side-by-side diff for the two lists.
-   *
-   * @param file1	the first text file
-   * @param file2	the second text file
-   * @return		the side-by-side diff
-   */
-  public static SideBySideDiff sideBySide(List<String> list1, List<String> list2) {
-    List[]	result;
-    Patch	patch;
-    int		from;
-    int		to;
-    int		sizeDiff;
-
-    result                       = new List[SIDEBYSIDE_SIZE];
-    result[SIDEBYSIDE_FIRST]     = new ArrayList();
-    result[SIDEBYSIDE_SECOND]    = new ArrayList();
-    result[SIDEBYSIDE_INDICATOR] = new ArrayList();
-    result[SIDEBYSIDE_STARTPOS]  = new ArrayList();
-    result[SIDEBYSIDE_ENDPOS]    = new ArrayList();
-    patch                        = difflib.DiffUtils.diff(list1, list2);
-
-    // the same?
-    if (patch.getDeltas().size() == 0) {
-      result[SIDEBYSIDE_FIRST].addAll(list1);
-      result[SIDEBYSIDE_SECOND].addAll(list2);
-      addToList(0, list1.size() - 1, INDICATOR_SAME, result[SIDEBYSIDE_INDICATOR]);
-      return new SideBySideDiff(result);
-    }
-
-    to = 0;
-    for (Delta delta: patch.getDeltas()) {
-      from = to;
-
-      // common content
-      to = delta.getOriginal().getPosition() - 1;
-      addToList(from, to, list1,          result[SIDEBYSIDE_FIRST]);
-      addToList(from, to, list1,          result[SIDEBYSIDE_SECOND]);
-      addToList(from, to, INDICATOR_SAME, result[SIDEBYSIDE_INDICATOR]);
-
-      // start pos of delta
-      result[SIDEBYSIDE_STARTPOS].add(result[SIDEBYSIDE_FIRST].size());
-
-      if (delta instanceof InsertDelta) {
-	// added content
-	addToList(0, delta.getRevised().size() - 1, new Filler(), result[SIDEBYSIDE_FIRST]);
-	result[SIDEBYSIDE_SECOND].addAll(delta.getRevised().getLines());
-	addToList(0, delta.getRevised().size() - 1, INDICATOR_ADDED, result[SIDEBYSIDE_INDICATOR]);
-	to = delta.getOriginal().getPosition() + delta.getOriginal().size();
-      }
-      else if (delta instanceof DeleteDelta) {
-	// deleted content
-	result[SIDEBYSIDE_FIRST].addAll(delta.getOriginal().getLines());
-	addToList(0, delta.getOriginal().size() - 1, new Filler(), result[SIDEBYSIDE_SECOND]);
-	addToList(0, delta.getOriginal().size() - 1, INDICATOR_DELETED, result[SIDEBYSIDE_INDICATOR]);
-	to = delta.getOriginal().getPosition() + delta.getOriginal().size();
-      }
-      else {
-	// changed content
-	result[SIDEBYSIDE_FIRST].addAll(delta.getOriginal().getLines());
-	result[SIDEBYSIDE_SECOND].addAll(delta.getRevised().getLines());
-	addToList(1, Math.max(delta.getOriginal().size(), delta.getRevised().size()), INDICATOR_CHANGED, result[SIDEBYSIDE_INDICATOR]);
-	// filler necessary?
-	sizeDiff = delta.getRevised().size() - delta.getOriginal().size();
-	if (sizeDiff > 0)
-	  addToList(1, sizeDiff, new Filler(), result[SIDEBYSIDE_FIRST]);
-	if (sizeDiff < 0)
-	  addToList(1, -sizeDiff, new Filler(), result[SIDEBYSIDE_SECOND]);
-	to = delta.getOriginal().getPosition() + delta.getOriginal().size();
-      }
-
-      // end pos of delta
-      result[SIDEBYSIDE_ENDPOS].add(result[SIDEBYSIDE_FIRST].size());
-    }
-
-    // trailing common content?
-    if (to < list1.size()) {
-      addToList(to, list1.size() - 1, list1,          result[SIDEBYSIDE_FIRST]);
-      addToList(to, list1.size() - 1, list1,          result[SIDEBYSIDE_SECOND]);
-      addToList(to, list1.size() - 1, INDICATOR_SAME, result[SIDEBYSIDE_INDICATOR]);
-    }
-
-    return new SideBySideDiff(result);
-  }
-
-  /**
-   * Usage: DiffUtils &lt;unified|side-by-side|brief&gt; &lt;file1&gt; &lt;file2&gt;
-   *
-   * @param args	the files to compare
-   * @throws Exception	if comparison fails
-   */
-  public static void main(String[] args) throws Exception {
-    if (args.length == 3) {
-      File file1 = new File(args[1]);
-      if (file1.isDirectory()) {
-	System.err.println("File '" + file1 + "' is a directory!");
-	return;
-      }
-      if (!file1.exists()) {
-	System.err.println("File '" + file1 + "' does not exist!");
-	return;
-      }
-      File file2 = new File(args[2]);
-      if (file2.isDirectory()) {
-	System.err.println("File '" + file2 + "' is a directory!");
-	return;
-      }
-      if (!file2.exists()) {
-	System.err.println("File '" + file2 + "' does not exist!");
-	return;
-      }
-      if (args[0].equals(OPTION_UNIFIED)) {
-	System.out.println(unified(file1, file2));
-      }
-      else if (args[0].equals(OPTION_SIDEBYSIDE)) {
-	System.out.println(sideBySide(file1, file2));
-      }
-      else if (args[0].equals(OPTION_BRIEF)) {
-	if (isDifferent(file1, file2))
-	  System.out.println("Files " + file1 + " and " + file2 + " differ");
-      }
-      else {
-	System.err.println("Only '" + OPTION_UNIFIED + "', '" + OPTION_SIDEBYSIDE + "' and '" + OPTION_BRIEF + "' are available as options!");
-	return;
-      }
-    }
-    else {
-      System.err.println("\nUsage: " + DiffUtils.class.getName() + " <" + OPTION_UNIFIED + "|" + OPTION_SIDEBYSIDE + "|" + OPTION_BRIEF + "> <file1> <file2>\n");
-      return;
-    }
-  }
 }
diff --git a/moa/src/test/java/moa/test/FileUtils.java b/moa/src/test/java/moa/test/FileUtils.java
index 9cbd4ec7b..49089b1cd 100644
--- a/moa/src/test/java/moa/test/FileUtils.java
+++ b/moa/src/test/java/moa/test/FileUtils.java
@@ -34,272 +34,270 @@
 
 /**
  * Basic file-handling stuff.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
  * @version $Revision$
  */
 public class FileUtils {
-  
-  /**
-   * Returns the content of the given file, null in case of an error.
-   *
-   * @param file	the file to load
-   * @return		the content/lines of the file
-   */
-  public static List<String> loadFromFile(File file) {
-    return loadFromFile(file, null);
-  }
 
-  /**
-   * Returns the content of the given file, null in case of an error.
-   *
-   * @param file	the file to load
-   * @param encoding	the encoding to use, null to use default
-   * @return		the content/lines of the file
-   */
-  public static List<String> loadFromFile(File file, String encoding) {
-    List<String>	result;
-    BufferedReader	reader;
-    String		line;
+	/**
+	 * Returns the content of the given file, null in case of an error.
+	 *
+	 * @param file the file to load
+	 * @return the content/lines of the file
+	 */
+	public static List<String> loadFromFile(File file) {
+		return loadFromFile(file, null);
+	}
+
+	/**
+	 * Returns the content of the given file, null in case of an error.
+	 *
+	 * @param file     the file to load
+	 * @param encoding the encoding to use, null to use default
+	 * @return the content/lines of the file
+	 */
+	public static List<String> loadFromFile(File file, String encoding) {
+		List<String> result;
+		BufferedReader reader;
+		String line;
+
+		result = new ArrayList<>();
 
-    result = new ArrayList<String>();
+		try {
+			if ((encoding != null) && (encoding.length() > 0))
+				reader = new BufferedReader(
+						new InputStreamReader(new FileInputStream(file.getAbsolutePath()), encoding));
+			else
+				reader = new BufferedReader(new InputStreamReader(new FileInputStream(file.getAbsolutePath())));
+			while ((line = reader.readLine()) != null)
+				result.add(line);
+			reader.close();
+		} catch (Exception e) {
+			result = null;
+			e.printStackTrace();
+		}
 
-    try {
-      if ((encoding != null) && (encoding.length() > 0))
-	reader = new BufferedReader(new InputStreamReader(new FileInputStream(file.getAbsolutePath()), encoding));
-      else
-	reader = new BufferedReader(new InputStreamReader(new FileInputStream(file.getAbsolutePath())));
-      while ((line = reader.readLine()) != null)
-        result.add(line);
-      reader.close();
-    }
-    catch (Exception e) {
-      result = null;
-      e.printStackTrace();
-    }
+		return result;
+	}
 
-    return result;
-  }
+	/**
+	 * Saves the content to the given file.
+	 *
+	 * @param content the content to save
+	 * @param file    the file to save the content to
+	 * @return true if successfully saved
+	 */
+	public static boolean saveToFile(String[] content, File file) {
+		List<String> lines;
+		int i;
 
-  /**
-   * Saves the content to the given file.
-   *
-   * @param content	the content to save
-   * @param file	the file to save the content to
-   * @return		true if successfully saved
-   */
-  public static boolean saveToFile(String[] content, File file) {
-    List<String>	lines;
-    int			i;
+		lines = new ArrayList<>();
+		for (i = 0; i < content.length; i++)
+			lines.add(content[i]);
 
-    lines = new ArrayList<String>();
-    for (i = 0; i < content.length; i++)
-      lines.add(content[i]);
+		return FileUtils.saveToFile(lines, file);
+	}
 
-    return FileUtils.saveToFile(lines, file);
-  }
+	/**
+	 * Saves the content to the given file.
+	 *
+	 * @param content the content to save
+	 * @param file    the file to save the content to
+	 * @return true if successfully saved
+	 */
+	public static boolean saveToFile(List<String> content, File file) {
+		return saveToFile(content, file, null);
+	}
 
-  /**
-   * Saves the content to the given file.
-   *
-   * @param content	the content to save
-   * @param file	the file to save the content to
-   * @return		true if successfully saved
-   */
-  public static boolean saveToFile(List<String> content, File file) {
-    return saveToFile(content, file, null);
-  }
+	/**
+	 * Saves the content to the given file.
+	 *
+	 * @param content  the content to save
+	 * @param file     the file to save the content to
+	 * @param encoding the encoding to use, null for default
+	 * @return true if successfully saved
+	 */
+	public static boolean saveToFile(List<String> content, File file, String encoding) {
+		boolean result;
+		BufferedWriter writer;
+		int i;
 
-  /**
-   * Saves the content to the given file.
-   *
-   * @param content	the content to save
-   * @param file	the file to save the content to
-   * @param encoding	the encoding to use, null for default
-   * @return		true if successfully saved
-   */
-  public static boolean saveToFile(List<String> content, File file, String encoding) {
-    boolean		result;
-    BufferedWriter	writer;
-    int			i;
+		result = true;
 
-    result = true;
-    
-    try {
-      if ((encoding != null) && (encoding.length() > 0))
-	writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file.getAbsolutePath()), encoding));
-      else
-	writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file.getAbsolutePath())));
-      for (i = 0; i < content.size(); i++) {
-        writer.write(content.get(i));
-        writer.newLine();
-      }
-      writer.flush();
-      writer.close();
-    }
-    catch (Exception e) {
-      result = false;
-      e.printStackTrace();
-    }
+		try {
+			if ((encoding != null) && (encoding.length() > 0))
+				writer = new BufferedWriter(
+						new OutputStreamWriter(new FileOutputStream(file.getAbsolutePath()), encoding));
+			else
+				writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file.getAbsolutePath())));
+			for (i = 0; i < content.size(); i++) {
+				writer.write(content.get(i));
+				writer.newLine();
+			}
+			writer.flush();
+			writer.close();
+		} catch (Exception e) {
+			result = false;
+			e.printStackTrace();
+		}
 
-    return result;
-  }
+		return result;
+	}
 
-  /**
-   * Writes the given object to the specified file. The object is always
-   * appended.
-   *
-   * @param filename	the file to write to
-   * @param obj		the object to write
-   * @return		true if writing was successful
-   */
-  public static boolean writeToFile(String filename, Object obj) {
-    return writeToFile(filename, obj, null);
-  }
+	/**
+	 * Writes the given object to the specified file. The object is always appended.
+	 *
+	 * @param filename the file to write to
+	 * @param obj      the object to write
+	 * @return true if writing was successful
+	 */
+	public static boolean writeToFile(String filename, Object obj) {
+		return writeToFile(filename, obj, null);
+	}
 
-  /**
-   * Writes the given object to the specified file. The object is always
-   * appended.
-   *
-   * @param filename	the file to write to
-   * @param obj		the object to write
-   * @param encoding	the encoding to use, null for default
-   * @return		true if writing was successful
-   */
-  public static boolean writeToFile(String filename, Object obj, String encoding) {
-    return writeToFile(filename, obj, true, encoding);
-  }
+	/**
+	 * Writes the given object to the specified file. The object is always appended.
+	 *
+	 * @param filename the file to write to
+	 * @param obj      the object to write
+	 * @param encoding the encoding to use, null for default
+	 * @return true if writing was successful
+	 */
+	public static boolean writeToFile(String filename, Object obj, String encoding) {
+		return writeToFile(filename, obj, true, encoding);
+	}
 
-  /**
-   * Writes the given object to the specified file. The message is either
-   * appended or replaces the current content of the file.
-   *
-   * @param filename	the file to write to
-   * @param obj		the object to write
-   * @param append	whether to append the message or not
-   * @return		true if writing was successful
-   */
-  public static boolean writeToFile(String filename, Object obj, boolean append) {
-    return writeToFile(filename, obj, append, null);
-  }
+	/**
+	 * Writes the given object to the specified file. The message is either appended
+	 * or replaces the current content of the file.
+	 *
+	 * @param filename the file to write to
+	 * @param obj      the object to write
+	 * @param append   whether to append the message or not
+	 * @return true if writing was successful
+	 */
+	public static boolean writeToFile(String filename, Object obj, boolean append) {
+		return writeToFile(filename, obj, append, null);
+	}
 
-  /**
-   * Writes the given object to the specified file. The message is either
-   * appended or replaces the current content of the file.
-   *
-   * @param filename	the file to write to
-   * @param obj		the object to write
-   * @param append	whether to append the message or not
-   * @param encoding	the encoding to use, null for default
-   * @return		true if writing was successful
-   */
-  public static boolean writeToFile(String filename, Object obj, boolean append, String encoding) {
-    boolean		result;
-    BufferedWriter	writer;
+	/**
+	 * Writes the given object to the specified file. The message is either appended
+	 * or replaces the current content of the file.
+	 *
+	 * @param filename the file to write to
+	 * @param obj      the object to write
+	 * @param append   whether to append the message or not
+	 * @param encoding the encoding to use, null for default
+	 * @return true if writing was successful
+	 */
+	public static boolean writeToFile(String filename, Object obj, boolean append, String encoding) {
+		boolean result;
+		BufferedWriter writer;
 
-    try {
-      if ((encoding != null) && (encoding.length() > 0))
-	writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(filename, append), encoding));
-      else
-	writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(filename, append)));
-      writer.write("" + obj);
-      writer.newLine();
-      writer.flush();
-      writer.close();
-      result = true;
-    }
-    catch (Exception e) {
-      result = false;
-    }
+		try {
+			if ((encoding != null) && (encoding.length() > 0))
+				writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(filename, append), encoding));
+			else
+				writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(filename, append)));
+			writer.write("" + obj);
+			writer.newLine();
+			writer.flush();
+			writer.close();
+			result = true;
+		} catch (Exception e) {
+			result = false;
+		}
 
-    return result;
-  }
+		return result;
+	}
 
-  /**
-   * Copies the file/directory (recursively).
-   *
-   * @param sourceLocation	the source file/dir
-   * @param targetLocation	the target file/dir
-   * @return			if successfully copied
-   * @throws IOException	if copying fails
-   */
-  public static boolean copy(File sourceLocation, File targetLocation) throws IOException {
-    return copyOrMove(sourceLocation, targetLocation, false);
-  }
+	/**
+	 * Copies the file/directory (recursively).
+	 *
+	 * @param sourceLocation the source file/dir
+	 * @param targetLocation the target file/dir
+	 * @return if successfully copied
+	 * @throws IOException if copying fails
+	 */
+	public static boolean copy(File sourceLocation, File targetLocation) throws IOException {
+		return copyOrMove(sourceLocation, targetLocation, false);
+	}
 
-  /**
-   * Moves the file/directory (recursively).
-   *
-   * @param sourceLocation	the source file/dir
-   * @param targetLocation	the target file/dir
-   * @return			if successfully moved
-   * @throws IOException	if moving fails
-   */
-  public static boolean move(File sourceLocation, File targetLocation) throws IOException {
-    return copyOrMove(sourceLocation, targetLocation, true);
-  }
+	/**
+	 * Moves the file/directory (recursively).
+	 *
+	 * @param sourceLocation the source file/dir
+	 * @param targetLocation the target file/dir
+	 * @return if successfully moved
+	 * @throws IOException if moving fails
+	 */
+	public static boolean move(File sourceLocation, File targetLocation) throws IOException {
+		return copyOrMove(sourceLocation, targetLocation, true);
+	}
 
-  /**
-   * Copies or moves files and directories (recursively).
-   * If targetLocation does not exist, it will be created.
-   * <p/>
-   * Original code from <a href="http://www.java-tips.org/java-se-tips/java.io/how-to-copy-a-directory-from-one-location-to-another-loc.html" target="_blank">Java-Tips.org</a>.
-   *
-   * @param sourceLocation	the source file/dir
-   * @param targetLocation	the target file/dir
-   * @param move		if true then the source files/dirs get deleted
-   * 				as soon as copying finished
-   * @return			false if failed to delete when moving or failed to create target directory
-   * @throws IOException	if copying/moving fails
-   */
-  public static boolean copyOrMove(File sourceLocation, File targetLocation, boolean move) throws IOException {
-    String[] 		children;
-    int 		i;
-    InputStream 	in;
-    OutputStream 	out;
-    byte[] 		buf;
-    int 		len;
+	/**
+	 * Copies or moves files and directories (recursively). If targetLocation does
+	 * not exist, it will be created.
+	 * <p/>
+	 * Original code from <a href=
+	 * "http://www.java-tips.org/java-se-tips/java.io/how-to-copy-a-directory-from-one-location-to-another-loc.html"
+	 * target="_blank">Java-Tips.org</a>.
+	 *
+	 * @param sourceLocation the source file/dir
+	 * @param targetLocation the target file/dir
+	 * @param move           if true then the source files/dirs get deleted as soon
+	 *                       as copying finished
+	 * @return false if failed to delete when moving or failed to create target
+	 *         directory
+	 * @throws IOException if copying/moving fails
+	 */
+	public static boolean copyOrMove(File sourceLocation, File targetLocation, boolean move) throws IOException {
+		String[] children;
+		int i;
+		InputStream in;
+		OutputStream out;
+		byte[] buf;
+		int len;
 
-    if (sourceLocation.isDirectory()) {
-      if (!targetLocation.exists()) {
-	if (!targetLocation.mkdir())
-	  return false;
-      }
+		if (sourceLocation.isDirectory()) {
+			if (!targetLocation.exists()) {
+				if (!targetLocation.mkdir())
+					return false;
+			}
 
-      children = sourceLocation.list();
-      for (i = 0; i < children.length; i++) {
-        if (!copyOrMove(
-            new File(sourceLocation.getAbsoluteFile(), children[i]),
-            new File(targetLocation.getAbsoluteFile(), children[i]),
-            move))
-          return false;
-      }
+			children = sourceLocation.list();
+			for (i = 0; i < children.length; i++) {
+				if (!copyOrMove(new File(sourceLocation.getAbsoluteFile(), children[i]),
+						new File(targetLocation.getAbsoluteFile(), children[i]), move))
+					return false;
+			}
 
-      if (move)
-        return sourceLocation.delete();
-      else
-	return true;
-    }
-    else {
-      in = new FileInputStream(sourceLocation.getAbsoluteFile());
-      // do we need to append the filename?
-      if (targetLocation.isDirectory())
-        out = new FileOutputStream(targetLocation.getAbsolutePath() + File.separator + sourceLocation.getName());
-      else
-        out = new FileOutputStream(targetLocation.getAbsoluteFile());
+			if (move)
+				return sourceLocation.delete();
+			else
+				return true;
+		} else {
+			in = new FileInputStream(sourceLocation.getAbsoluteFile());
+			// do we need to append the filename?
+			if (targetLocation.isDirectory())
+				out = new FileOutputStream(
+						targetLocation.getAbsolutePath() + File.separator + sourceLocation.getName());
+			else
+				out = new FileOutputStream(targetLocation.getAbsoluteFile());
 
-      // Copy the content from instream to outstream
-      buf = new byte[1024];
-      while ((len = in.read(buf)) > 0)
-        out.write(buf, 0, len);
+			// Copy the content from instream to outstream
+			buf = new byte[1024];
+			while ((len = in.read(buf)) > 0)
+				out.write(buf, 0, len);
 
-      in.close();
-      out.close();
+			in.close();
+			out.close();
 
-      if (move)
-        return sourceLocation.delete();
-      else
-	return true;
-    }
-  }
+			if (move)
+				return sourceLocation.delete();
+			else
+				return true;
+		}
+	}
 }
diff --git a/moa/src/test/java/moa/test/MoaTestCase.java b/moa/src/test/java/moa/test/MoaTestCase.java
index 4bf2b492b..6682b55d8 100644
--- a/moa/src/test/java/moa/test/MoaTestCase.java
+++ b/moa/src/test/java/moa/test/MoaTestCase.java
@@ -30,286 +30,279 @@
  * Ancestor for all test cases.
  * <p/>
  * Any regression test can be skipped as follows: <br/>
- *   <code>-Dmoa.test.noregression=true</code>
+ * <code>-Dmoa.test.noregression=true</code>
  *
- * @author  fracpete (fracpete at waikato dot ac dot nz)
+ * @author fracpete (fracpete at waikato dot ac dot nz)
  * @version $Revision: 8349 $
  */
-public class MoaTestCase
-  extends TestCase {
-
-  /** property indicating whether tests should be run in headless mode. */
-  public final static String PROPERTY_HEADLESS = "moa.test.headless";
-
-  /** property indicating whether regression tests should not be executed. */
-  public final static String PROPERTY_NOREGRESSION = "moa.test.noregression";
-
-  /** whether to execute any regression test. */
-  protected boolean m_NoRegressionTest;
-  
-  /** the helper class for regression. */
-  protected Regression m_Regression;
-
-  /** the test class to use. */
-  protected AbstractTestHelper m_TestHelper;
-
-  /** whether to run tests in headless mode. */
-  protected boolean m_Headless;
-
-  /**
-   * Constructs the test case. Called by subclasses.
-   *
-   * @param name 	the name of the test
-   */
-  public MoaTestCase(String name) {
-    super(name);
-  }
-
-  /**
-   * Tries to load the class based on the test class's name.
-   *
-   * @return		the class that is being tested or null if none could
-   * 			be determined
-   */
-  protected Class getTestedClass() {
-    Class	result;
-
-    result = null;
-
-    if (getClass().getName().endsWith("Test")) {
-      try {
-	result = Class.forName(getClass().getName().replaceAll("Test$", ""));
-      }
-      catch (Exception e) {
-	result = null;
-      }
-    }
-
-    return result;
-  }
-  
-  /**
-   * Returns whether the test can be executed in a headless environment. If not
-   * then the test gets skipped.
-   * 
-   * @return		true if OK to run in headless mode
-   */
-  protected boolean canHandleHeadless() {
-    return true;
-  }
-  
-  /**
-   * Called by JUnit before each test method.
-   *
-   * @throws Exception if an error occurs.
-   */
-  @Override
-  protected void setUp() throws Exception {
-    Class cls;
-
-    super.setUp();
-    
-    cls = getTestedClass();
-    if (cls != null)
-      m_Regression = new Regression(cls);
-
-    m_TestHelper       = newTestHelper();
-    m_Headless         = Boolean.getBoolean(PROPERTY_HEADLESS);
-    m_NoRegressionTest = Boolean.getBoolean(PROPERTY_NOREGRESSION);
-  }
-
-  /**
-   * Override to run the test and assert its state. Checks whether the test
-   * or test-method is platform-specific.
-   * 
-   * @throws Throwable if any exception is thrown
-   */
-  @Override
-  protected void runTest() throws Throwable {
-    boolean		proceed;
-    
-    proceed = true;
-    
-    if (m_Headless && !canHandleHeadless())
-      proceed = false;
-    
-    if (proceed)
-      super.runTest();
-    else
-      System.out.println("Skipped");
-  }
-
-  /**
-   * Called by JUnit after each test method.
-   *
-   * @throws Exception	if tear-down fails
-   */
-  @Override
-  protected void tearDown() throws Exception {
-    m_Regression = null;
-
-    super.tearDown();
-  }
-
-  /**
-   * Returns the test helper class to use.
-   *
-   * @return		the helper class instance
-   */
-  protected AbstractTestHelper newTestHelper() {
-    return new TestHelper(this, "");
-  }
-
-  /**
-   * Tries to obtain an instance of the given class.
-   *
-   * @param cls		the class to obtain an instance from
-   * @param intf	the required interface that the class must implement
-   * @param fail	if true, errors/exceptions will result in a test fail
-   */
-  protected Object getInstance(Class cls, Class intf, boolean fail) {
-    Object		result;
-    Constructor		constr;
-
-    if (!intf.isAssignableFrom(cls))
-      return null;
-
-    // default constructor?
-    constr = null;
-    try {
-      constr = cls.getConstructor(new Class[0]);
-    }
-    catch (NoSuchMethodException e) {
-      if (fail)
-	fail("No default constructor, requires custom test method: " + cls.getName());
-      return null;
-    }
-
-    // create instance
-    result = null;
-    try {
-      result = constr.newInstance(new Object[0]);
-    }
-    catch (Exception e) {
-      if (fail)
-	fail("Failed to instantiate object using default constructor: " + cls.getName());
-      return null;
-    }
-
-    return result;
-  }
-  
-  /**
-   * Creates a deep copy of the given object (must be serializable!). Returns
-   * null in case of an error.
-   *
-   * @param o		the object to copy
-   * @return		the deep copy
-   */
-  protected Object deepCopy(Object o) {
-    Object		result;
-    SerializedObject	so;
-
-    try {
-      so     = new SerializedObject((Serializable) o);
-      result = so.getObject();
-    }
-    catch (Exception e) {
-      System.err.println("Failed to serialize " + o.getClass().getName() + ":");
-      e.printStackTrace();
-      result = null;
-    }
-
-    return result;
-  }
-
-  /**
-   * Rounds a double and converts it into String.
-   *
-   * @param value 		the double value
-   * @param afterDecimalPoint 	the (maximum) number of digits permitted
-   * 				after the decimal point
-   * @return 			the double as a formatted string
-   */
-  public static String doubleToString(double value, int afterDecimalPoint) {
-    StringBuilder 	builder;
-    double 		temp;
-    int 		dotPosition;
-    int 		currentPos;
-    long 		precisionValue;
-    char		separator;
-
-    temp = value * Math.pow(10.0, afterDecimalPoint);
-    if (Math.abs(temp) < Long.MAX_VALUE) {
-      precisionValue = 	(temp > 0) ? (long)(temp + 0.5)
-	  : -(long)(Math.abs(temp) + 0.5);
-      if (precisionValue == 0)
-	builder = new StringBuilder(String.valueOf(0));
-      else
-	builder = new StringBuilder(String.valueOf(precisionValue));
-
-      if (afterDecimalPoint == 0)
-	return builder.toString();
-
-      separator   = '.';
-      dotPosition = builder.length() - afterDecimalPoint;
-      while (((precisionValue < 0) && (dotPosition < 1)) || (dotPosition < 0)) {
-	if (precisionValue < 0)
-	  builder.insert(1, '0');
-	else
-	  builder.insert(0, '0');
-	dotPosition++;
-      }
-
-      builder.insert(dotPosition, separator);
-
-      if ((precisionValue < 0) && (builder.charAt(1) == separator))
-	builder.insert(1, '0');
-      else if (builder.charAt(0) == separator)
-	builder.insert(0, '0');
-
-      currentPos = builder.length() - 1;
-      while ((currentPos > dotPosition) && (builder.charAt(currentPos) == '0'))
-	builder.setCharAt(currentPos--, ' ');
-
-      if (builder.charAt(currentPos) == separator)
-	builder.setCharAt(currentPos, ' ');
-
-      return builder.toString().trim();
-    }
-    return new String("" + value);
-  }
-
-  /**
-   * Performs a serializable test on the given class.
-   *
-   * @param cls		the class to test
-   */
-  protected void performSerializableTest(Class cls) {
-    Object		obj;
-
-    obj = getInstance(cls, Serializable.class, true);
-    if (obj == null)
-      return;
-    
-    assertNotNull("Serialization failed", deepCopy(obj));
-  }
-
-  /**
-   * For classes (with default constructor) that are serializable, are tested
-   * whether they are truly serializable.
-   */
-  public void testSerializable() {
-    if (m_Regression != null)
-      performSerializableTest(m_Regression.getRegressionClass());
-  }
-
-  /**
-   * Runs the specified suite. Used for running the test from commandline.
-   *
-   * @param suite	the suite to run
-   */
-  public static void runTest(Test suite) {
-    TestRunner.run(suite);
-  }
+public class MoaTestCase extends TestCase {
+
+	/** property indicating whether tests should be run in headless mode. */
+	public final static String PROPERTY_HEADLESS = "moa.test.headless";
+
+	/** property indicating whether regression tests should not be executed. */
+	public final static String PROPERTY_NOREGRESSION = "moa.test.noregression";
+
+	/** whether to execute any regression test. */
+	protected boolean m_NoRegressionTest;
+
+	/** the helper class for regression. */
+	protected Regression m_Regression;
+
+	/** the test class to use. */
+	protected AbstractTestHelper m_TestHelper;
+
+	/** whether to run tests in headless mode. */
+	protected boolean m_Headless;
+
+	/**
+	 * Constructs the test case. Called by subclasses.
+	 *
+	 * @param name the name of the test
+	 */
+	public MoaTestCase(String name) {
+		super(name);
+	}
+
+	/**
+	 * Tries to load the class based on the test class's name.
+	 *
+	 * @return the class that is being tested or null if none could be determined
+	 */
+	protected Class getTestedClass() {
+		Class result;
+
+		result = null;
+
+		if (getClass().getName().endsWith("Test")) {
+			try {
+				result = Class.forName(getClass().getName().replaceAll("Test$", ""));
+			} catch (Exception e) {
+				result = null;
+			}
+		}
+
+		return result;
+	}
+
+	/**
+	 * Returns whether the test can be executed in a headless environment. If not
+	 * then the test gets skipped.
+	 * 
+	 * @return true if OK to run in headless mode
+	 */
+	protected boolean canHandleHeadless() {
+		return true;
+	}
+
+	/**
+	 * Called by JUnit before each test method.
+	 *
+	 * @throws Exception if an error occurs.
+	 */
+	@Override
+	protected void setUp() throws Exception {
+		Class cls;
+
+		super.setUp();
+
+		cls = getTestedClass();
+		if (cls != null)
+			m_Regression = new Regression(cls);
+
+		m_TestHelper = newTestHelper();
+		m_Headless = Boolean.getBoolean(PROPERTY_HEADLESS);
+		m_NoRegressionTest = Boolean.getBoolean(PROPERTY_NOREGRESSION);
+	}
+
+	/**
+	 * Override to run the test and assert its state. Checks whether the test or
+	 * test-method is platform-specific.
+	 * 
+	 * @throws Throwable if any exception is thrown
+	 */
+	@Override
+	protected void runTest() throws Throwable {
+		boolean proceed;
+
+		proceed = true;
+
+		if (m_Headless && !canHandleHeadless())
+			proceed = false;
+
+		if (proceed)
+			super.runTest();
+		else
+			System.out.println("Skipped");
+	}
+
+	/**
+	 * Called by JUnit after each test method.
+	 *
+	 * @throws Exception if tear-down fails
+	 */
+	@Override
+	protected void tearDown() throws Exception {
+		m_Regression = null;
+
+		super.tearDown();
+	}
+
+	/**
+	 * Returns the test helper class to use.
+	 *
+	 * @return the helper class instance
+	 */
+	protected AbstractTestHelper newTestHelper() {
+		return new TestHelper(this, "");
+	}
+
+	/**
+	 * Tries to obtain an instance of the given class.
+	 *
+	 * @param cls  the class to obtain an instance from
+	 * @param intf the required interface that the class must implement
+	 * @param fail if true, errors/exceptions will result in a test fail
+	 */
+	protected Object getInstance(Class cls, Class intf, boolean fail) {
+		Object result;
+		Constructor constr;
+
+		if (!intf.isAssignableFrom(cls))
+			return null;
+
+		// default constructor?
+		constr = null;
+		try {
+			constr = cls.getConstructor(new Class[0]);
+		} catch (NoSuchMethodException e) {
+			if (fail)
+				fail("No default constructor, requires custom test method: " + cls.getName());
+			return null;
+		}
+
+		// create instance
+		result = null;
+		try {
+			result = constr.newInstance(new Object[0]);
+		} catch (Exception e) {
+			if (fail)
+				fail("Failed to instantiate object using default constructor: " + cls.getName());
+			return null;
+		}
+
+		return result;
+	}
+
+	/**
+	 * Creates a deep copy of the given object (must be serializable!). Returns null
+	 * in case of an error.
+	 *
+	 * @param o the object to copy
+	 * @return the deep copy
+	 */
+	protected Object deepCopy(Object o) {
+		Object result;
+		SerializedObject so;
+
+		try {
+			so = new SerializedObject((Serializable) o);
+			result = so.getObject();
+		} catch (Exception e) {
+			System.err.println("Failed to serialize " + o.getClass().getName() + ":");
+			e.printStackTrace();
+			result = null;
+		}
+
+		return result;
+	}
+
+	/**
+	 * Rounds a double and converts it into String.
+	 *
+	 * @param value             the double value
+	 * @param afterDecimalPoint the (maximum) number of digits permitted after the
+	 *                          decimal point
+	 * @return the double as a formatted string
+	 */
+	public static String doubleToString(double value, int afterDecimalPoint) {
+		StringBuilder builder;
+		double temp;
+		int dotPosition;
+		int currentPos;
+		long precisionValue;
+		char separator;
+
+		temp = value * Math.pow(10.0, afterDecimalPoint);
+		if (Math.abs(temp) < Long.MAX_VALUE) {
+			precisionValue = (temp > 0) ? (long) (temp + 0.5) : -(long) (Math.abs(temp) + 0.5);
+			if (precisionValue == 0)
+				builder = new StringBuilder(String.valueOf(0));
+			else
+				builder = new StringBuilder(String.valueOf(precisionValue));
+
+			if (afterDecimalPoint == 0)
+				return builder.toString();
+
+			separator = '.';
+			dotPosition = builder.length() - afterDecimalPoint;
+			while (((precisionValue < 0) && (dotPosition < 1)) || (dotPosition < 0)) {
+				if (precisionValue < 0)
+					builder.insert(1, '0');
+				else
+					builder.insert(0, '0');
+				dotPosition++;
+			}
+
+			builder.insert(dotPosition, separator);
+
+			if ((precisionValue < 0) && (builder.charAt(1) == separator))
+				builder.insert(1, '0');
+			else if (builder.charAt(0) == separator)
+				builder.insert(0, '0');
+
+			currentPos = builder.length() - 1;
+			while ((currentPos > dotPosition) && (builder.charAt(currentPos) == '0'))
+				builder.setCharAt(currentPos--, ' ');
+
+			if (builder.charAt(currentPos) == separator)
+				builder.setCharAt(currentPos, ' ');
+
+			return builder.toString().trim();
+		}
+		return new String("" + value);
+	}
+
+	/**
+	 * Performs a serializable test on the given class.
+	 *
+	 * @param cls the class to test
+	 */
+	protected void performSerializableTest(Class cls) {
+		Object obj;
+
+		obj = getInstance(cls, Serializable.class, true);
+		if (obj == null)
+			return;
+
+		assertNotNull("Serialization failed", deepCopy(obj));
+	}
+
+	/**
+	 * For classes (with default constructor) that are serializable, are tested
+	 * whether they are truly serializable.
+	 */
+	public void testSerializable() {
+		if (m_Regression != null)
+			performSerializableTest(m_Regression.getRegressionClass());
+	}
+
+	/**
+	 * Runs the specified suite. Used for running the test from commandline.
+	 *
+	 * @param suite the suite to run
+	 */
+	public static void runTest(Test suite) {
+		TestRunner.run(suite);
+	}
 }
diff --git a/moa/src/test/java/moa/test/Regression.java b/moa/src/test/java/moa/test/Regression.java
index 1cd360725..ba02916f5 100644
--- a/moa/src/test/java/moa/test/Regression.java
+++ b/moa/src/test/java/moa/test/Regression.java
@@ -28,251 +28,253 @@
 /**
  * Helper class for regression tests.
  *
- * @author  fracpete (fracpete at waikato dot ac dot nz)
+ * @author fracpete (fracpete at waikato dot ac dot nz)
  * @version $Revision: 8528 $
  */
 public class Regression {
 
-  /** the storage place for reference files. */
-  public final static String REFERENCES = "src/test/resources";
-
-  /** the extension for references (incl dot). */
-  public final static String EXTENSION = ".ref";
-
-  /** the class this regression test is for. */
-  protected Class m_RegressionClass;
-
-  /** the regression file to use. */
-  protected File m_ReferenceFile;
-
-  /**
-   * Initializes the regression check.
-   *
-   * @param cls		the class that is being checked
-   */
-  public Regression(Class cls) {
-    super();
-
-    m_RegressionClass = cls;
-    m_ReferenceFile   = createReferenceFile(m_RegressionClass);
-  }
-
-  /**
-   * Returns the class this regression helper is for.
-   *
-   * @return		the class
-   */
-  public Class getRegressionClass() {
-    return m_RegressionClass;
-  }
-
-  /**
-   * Sets the reference file to use.
-   * <p/>
-   * Normally, the reference file is determined based on the classname.
-   * This method should only be called if a file different from the class
-   * name must be used, for instance for an additional regression test.
-   * 
-   * @param value	the reference file to use
-   */
-  public void setReferenceFile(File value) {
-    m_ReferenceFile = value;
-  }
-
-  /**
-   * Returns the file for storing the reference data in.
-   *
-   * @return		the reference file
-   */
-  public File getReferenceFile() {
-    return m_ReferenceFile;
-  }
-
-  /**
-   * Compares the content generated by the specified class with the stored
-   * regression data. Creates a new reference file if not present yet.
-   *
-   * @param content	the content to check
-   * @return		the difference (or an error message), null if no difference
-   */
-  protected String compare(List<String> content) {
-    String		result;
-    List<String>	reference;
-
-    // reference available?
-    if (!getReferenceFile().exists()) {
-      if (!getReferenceFile().getParentFile().exists()) {
-	if (!getReferenceFile().getParentFile().mkdirs())
-	  return "Failed to create reference file: " + m_ReferenceFile;
-      }
-
-      if (FileUtils.saveToFile(content, getReferenceFile())) {
-	System.err.println("Reference file created: " + m_ReferenceFile);
-	return null;
-      }
-      else {
-	return "Failed to create reference file: " + m_ReferenceFile;
-      }
-    }
-
-    // compare
-    reference = FileUtils.loadFromFile(getReferenceFile());
-    result    = DiffUtils.unified(reference, content);
-
-    if (result.length() == 0)
-      return null;
-    else
-      return result.toString();
-  }
-
-  /**
-   * Trims the list, i.e., removes the ignored indices from it.
-   *
-   * @param list	the list to trim
-   * @param ignore	the ignored indices
-   * @return		the trimmed list
-   */
-  public static List<String> trim(List<String> list, int[] ignore) {
-    List<String>	result;
-    HashSet<Integer>	ignored;
-    int			i;
-
-    if (ignore.length == 0)
-      return list;
-
-    result  = new ArrayList<String>();
-    ignored = new HashSet<Integer>();
-    for (int ign: ignore)
-      ignored.add(ign);
-
-    for (i = 0; i < list.size(); i++) {
-      if (ignored.contains(i))
-	continue;
-      result.add(list.get(i));
-    }
-
-    return result;
-  }
-
-  /**
-   * Compares the content generated by the specified class with the stored
-   * regression data. Creates a new reference file if not present yet.
-   * Uses "\n" for splitting the string content into lines.
-   *
-   * @param content	the content to check
-   * @return		the difference, null if no difference
-   */
-  public String compare(String content) {
-    return compare(content, "\n");
-  }
-
-  /**
-   * Compares the content generated by the specified class with the stored
-   * regression data. Creates a new reference file if not present yet.
-   * Uses "\n" for splitting the string content into lines.
-   *
-   * @param content	the content to check
-   * @param ignore	the indices of the lines to ignore
-   * @return		the difference, null if no difference
-   */
-  public String compare(String content, int[] ignore) {
-    return compare(content, "\n", ignore);
-  }
-
-  /**
-   * Compares the content generated by the specified class with the stored
-   * regression data. Creates a new reference file if not present yet.
-   *
-   * @param content	the content to check
-   * @param nl		the new line string to use
-   * @return		the difference, null if no difference
-   */
-  public String compare(String content, String nl) {
-    return compare(content, nl, new int[0]);
-  }
-
-  /**
-   * Compares the content generated by the specified class with the stored
-   * regression data. Creates a new reference file if not present yet.
-   *
-   * @param content	the content to check
-   * @param nl		the new line string to use
-   * @param ignore	the indices of the lines to ignore
-   * @return		the difference, null if no difference
-   */
-  public String compare(String content, String nl, int[] ignore) {
-    return compare(trim(Arrays.asList(content.split(nl)), ignore));
-  }
-
-  /**
-   * Compares the file content generated by the specified class with the stored
-   * regression data. Creates a new reference file if not present yet.
-   *
-   * @param files	the files containing the generated output to check
-   * @return		the difference, null if no difference
-   */
-  public String compare(File[] files) {
-    return compare(files, new int[0]);
-  }
-
-  /**
-   * Compares the file content generated by the specified class with the stored
-   * regression data. Creates a new reference file if not present yet.
-   *
-   * @param files	the files containing the generated output to check
-   * @param ignore	the line indices in the files to ignore
-   * @return		the difference, null if no difference
-   */
-  public String compare(File[] files, int[] ignore) {
-    List<String>	content;
-    int			i;
-
-    content = new ArrayList<String>();
-    for (i = 0; i < files.length; i++) {
-      content.add("--> " + files[i].getName());
-      if (!files[i].exists())
-	content.add("file is missing");
-      else
-	content.addAll(trim(FileUtils.loadFromFile(files[i]), ignore));
-      content.add("");
-    }
-
-    return compare(content);
-  }
-
-  /**
-   * Creates a reference file for the specified class.
-   * 
-   * @param regressionClass	the class to build the reference file name for
-   * @param suffix		the suffix to use (between classname and extension), null to omit
-   * @return			the generated filename
-   */
-  public static File createReferenceFile(Class regressionClass) {
-    return createReferenceFile(regressionClass, null);
-  }
-
-  /**
-   * Creates a reference file for the specified class.
-   * 
-   * @param regressionClass	the class to build the reference file name for
-   * @param suffix		the suffix to use (between classname and extension), null to omit
-   * @return			the generated filename
-   */
-  public static File createReferenceFile(Class regressionClass, String suffix) {
-    return createReferenceFile(regressionClass, suffix, EXTENSION);
-  }
-
-  /**
-   * Creates a reference file for the specified class.
-   * 
-   * @param regressionClass	the class to build the reference file name for
-   * @param suffix		the suffix to use (between classname and extension), null to omit
-   * @param extension		the file extension (incl the dot, eg ".ref")
-   * @return			the generated filename
-   */
-  public static File createReferenceFile(Class regressionClass, String suffix, String extension) {
-    if (suffix == null)
-      suffix = "";
-    return new File(REFERENCES + "/" + regressionClass.getName().replace(".", "/") + suffix + extension);  
-  }
+	/** the storage place for reference files. */
+	public final static String REFERENCES = "src/test/resources";
+
+	/** the extension for references (incl dot). */
+	public final static String EXTENSION = ".ref";
+
+	/** the class this regression test is for. */
+	protected Class m_RegressionClass;
+
+	/** the regression file to use. */
+	protected File m_ReferenceFile;
+
+	/**
+	 * Initializes the regression check.
+	 *
+	 * @param cls the class that is being checked
+	 */
+	public Regression(Class cls) {
+		super();
+
+		m_RegressionClass = cls;
+		m_ReferenceFile = createReferenceFile(m_RegressionClass);
+	}
+
+	/**
+	 * Returns the class this regression helper is for.
+	 *
+	 * @return the class
+	 */
+	public Class getRegressionClass() {
+		return m_RegressionClass;
+	}
+
+	/**
+	 * Sets the reference file to use.
+	 * <p/>
+	 * Normally, the reference file is determined based on the classname. This
+	 * method should only be called if a file different from the class name must be
+	 * used, for instance for an additional regression test.
+	 * 
+	 * @param value the reference file to use
+	 */
+	public void setReferenceFile(File value) {
+		m_ReferenceFile = value;
+	}
+
+	/**
+	 * Returns the file for storing the reference data in.
+	 *
+	 * @return the reference file
+	 */
+	public File getReferenceFile() {
+		return m_ReferenceFile;
+	}
+
+	/**
+	 * Compares the content generated by the specified class with the stored
+	 * regression data. Creates a new reference file if not present yet.
+	 *
+	 * @param content the content to check
+	 * @return the difference (or an error message), null if no difference
+	 */
+	protected String compare(List<String> content) {
+		String result;
+		List<String> reference;
+
+		// reference available?
+		if (!getReferenceFile().exists()) {
+			if (!getReferenceFile().getParentFile().exists()) {
+				if (!getReferenceFile().getParentFile().mkdirs())
+					return "Failed to create reference file: " + m_ReferenceFile;
+			}
+
+			if (FileUtils.saveToFile(content, getReferenceFile())) {
+				System.err.println("Reference file created: " + m_ReferenceFile);
+				return null;
+			} else {
+				return "Failed to create reference file: " + m_ReferenceFile;
+			}
+		}
+
+		// compare
+		reference = FileUtils.loadFromFile(getReferenceFile());
+		result = DiffUtils.unified(reference, content);
+
+		if (result.length() == 0)
+			return null;
+		else
+			return result.toString();
+	}
+
+	/**
+	 * Trims the list, i.e., removes the ignored indices from it.
+	 *
+	 * @param list   the list to trim
+	 * @param ignore the ignored indices
+	 * @return the trimmed list
+	 */
+	public static List<String> trim(List<String> list, int[] ignore) {
+		List<String> result;
+		HashSet<Integer> ignored;
+		int i;
+
+		if (ignore.length == 0)
+			return list;
+
+		result = new ArrayList<>();
+		ignored = new HashSet<>();
+		for (int ign : ignore)
+			ignored.add(ign);
+
+		for (i = 0; i < list.size(); i++) {
+			if (ignored.contains(i))
+				continue;
+			result.add(list.get(i));
+		}
+
+		return result;
+	}
+
+	/**
+	 * Compares the content generated by the specified class with the stored
+	 * regression data. Creates a new reference file if not present yet. Uses "\n"
+	 * for splitting the string content into lines.
+	 *
+	 * @param content the content to check
+	 * @return the difference, null if no difference
+	 */
+	public String compare(String content) {
+		return compare(content, "\n");
+	}
+
+	/**
+	 * Compares the content generated by the specified class with the stored
+	 * regression data. Creates a new reference file if not present yet. Uses "\n"
+	 * for splitting the string content into lines.
+	 *
+	 * @param content the content to check
+	 * @param ignore  the indices of the lines to ignore
+	 * @return the difference, null if no difference
+	 */
+	public String compare(String content, int[] ignore) {
+		return compare(content, "\n", ignore);
+	}
+
+	/**
+	 * Compares the content generated by the specified class with the stored
+	 * regression data. Creates a new reference file if not present yet.
+	 *
+	 * @param content the content to check
+	 * @param nl      the new line string to use
+	 * @return the difference, null if no difference
+	 */
+	public String compare(String content, String nl) {
+		return compare(content, nl, new int[0]);
+	}
+
+	/**
+	 * Compares the content generated by the specified class with the stored
+	 * regression data. Creates a new reference file if not present yet.
+	 *
+	 * @param content the content to check
+	 * @param nl      the new line string to use
+	 * @param ignore  the indices of the lines to ignore
+	 * @return the difference, null if no difference
+	 */
+	public String compare(String content, String nl, int[] ignore) {
+		return compare(trim(Arrays.asList(content.split(nl)), ignore));
+	}
+
+	/**
+	 * Compares the file content generated by the specified class with the stored
+	 * regression data. Creates a new reference file if not present yet.
+	 *
+	 * @param files the files containing the generated output to check
+	 * @return the difference, null if no difference
+	 */
+	public String compare(File[] files) {
+		return compare(files, new int[0]);
+	}
+
+	/**
+	 * Compares the file content generated by the specified class with the stored
+	 * regression data. Creates a new reference file if not present yet.
+	 *
+	 * @param files  the files containing the generated output to check
+	 * @param ignore the line indices in the files to ignore
+	 * @return the difference, null if no difference
+	 */
+	public String compare(File[] files, int[] ignore) {
+		List<String> content;
+		int i;
+
+		content = new ArrayList<>();
+		for (i = 0; i < files.length; i++) {
+			content.add("--> " + files[i].getName());
+			if (!files[i].exists())
+				content.add("file is missing");
+			else
+				content.addAll(trim(FileUtils.loadFromFile(files[i]), ignore));
+			content.add("");
+		}
+
+		return compare(content);
+	}
+
+	/**
+	 * Creates a reference file for the specified class.
+	 * 
+	 * @param regressionClass the class to build the reference file name for
+	 * @param suffix          the suffix to use (between classname and extension),
+	 *                        null to omit
+	 * @return the generated filename
+	 */
+	public static File createReferenceFile(Class regressionClass) {
+		return createReferenceFile(regressionClass, null);
+	}
+
+	/**
+	 * Creates a reference file for the specified class.
+	 * 
+	 * @param regressionClass the class to build the reference file name for
+	 * @param suffix          the suffix to use (between classname and extension),
+	 *                        null to omit
+	 * @return the generated filename
+	 */
+	public static File createReferenceFile(Class regressionClass, String suffix) {
+		return createReferenceFile(regressionClass, suffix, EXTENSION);
+	}
+
+	/**
+	 * Creates a reference file for the specified class.
+	 * 
+	 * @param regressionClass the class to build the reference file name for
+	 * @param suffix          the suffix to use (between classname and extension),
+	 *                        null to omit
+	 * @param extension       the file extension (incl the dot, eg ".ref")
+	 * @return the generated filename
+	 */
+	public static File createReferenceFile(Class regressionClass, String suffix, String extension) {
+		if (suffix == null)
+			suffix = "";
+		return new File(REFERENCES + "/" + regressionClass.getName().replace(".", "/") + suffix + extension);
+	}
 }
diff --git a/moa/src/test/java/moa/test/SerializedObject.java b/moa/src/test/java/moa/test/SerializedObject.java
index 59f51d5ba..13d328162 100644
--- a/moa/src/test/java/moa/test/SerializedObject.java
+++ b/moa/src/test/java/moa/test/SerializedObject.java
@@ -35,201 +35,196 @@
 import java.util.zip.GZIPOutputStream;
 
 /**
- * Class for storing an object in serialized form in memory. It can be used 
- * to make deep copies of objects, and also allows compression to conserve
- * memory.
+ * Class for storing an object in serialized form in memory. It can be used to
+ * make deep copies of objects, and also allows compression to conserve memory.
  *
  * @author Richard Kirkby (rbk1@cs.waikato.ac.nz)
- * @version $Revision: 4584 $ 
+ * @version $Revision: 4584 $
  */
-public class SerializedObject
-  implements Serializable {
-
-  /** for serialization. */
-  private static final long serialVersionUID = 6635502953928860434L;
-
-  /** The array storing the object. */
-  private byte[] m_storedObjectArray;
-
-  /** Whether or not the object is compressed. */
-  private boolean m_isCompressed;
-  
-  /**
-   * Creates a new serialized object (without compression).
-   *
-   * @param o 		the object to store
-   * @throws Exception 	if the object couldn't be serialized
-   */ 
-  public SerializedObject(Serializable o) throws Exception {
-    this(o, false);
-  }
-
-  /**
-   * Creates a new serialized object.
-   *
-   * @param o 		the object to store
-   * @param compress 	whether or not to use compression
-   * @throws Exception 	if the object couldn't be serialized
-   */ 
-  public SerializedObject(Serializable o, boolean compress) throws Exception {
-    ByteArrayOutputStream 	ostream;
-    ObjectOutputStream		p;
-
-    ostream = new ByteArrayOutputStream();
-    if (!compress)
-      p = new ObjectOutputStream(new BufferedOutputStream(ostream));
-    else
-      p = new ObjectOutputStream(new BufferedOutputStream(new GZIPOutputStream(ostream)));
-    p.writeObject(o);
-    p.flush();
-    p.close();
-    m_storedObjectArray = ostream.toByteArray();
-    m_isCompressed = compress;
-  }
-
-  /**
-   * Checks to see whether this object is equal to another.
-   *
-   * @param o the object to compare to
-   * @return whether or not the objects are equal
-   */
-  @Override
-  public boolean equals(Object o) {
-    byte[] 	compareArray;
-    int		i;
-    
-    if (o == null)
-      return false;
-    
-    if (!o.getClass().equals(this.getClass())) 
-      return false;
-    
-    compareArray = ((SerializedObject) o).m_storedObjectArray;
-    
-    if (compareArray.length != m_storedObjectArray.length) 
-      return false;
-    
-    for (i = 0; i < compareArray.length; i++) {
-      if (compareArray[i] != m_storedObjectArray[i]) 
-	return false;
-    }
-
-    return true;
-  }
-
-  /**
-   * Returns a hashcode for this object.
-   *
-   * @return the hashcode
-   */
-  @Override
-  public int hashCode() {
-    return m_storedObjectArray.length;
-  }
-
-  /**
-   * Returns a serialized object.
-   *
-   * @return the restored object
-   */ 
-  public Object getObject() {
-    ByteArrayInputStream 	istream;
-    ObjectInputStream 		p;
-    Object 			result;
-    
-    result = null;
-    
-    try {
-      istream = new ByteArrayInputStream(m_storedObjectArray);
-      if (!m_isCompressed)
-	p = new ObjectInputStream(new BufferedInputStream(istream));
-      else 
-	p = new ObjectInputStream(new BufferedInputStream(new GZIPInputStream(istream)));
-      result = p.readObject();
-      istream.close();
-    }
-    catch (Exception e) {
-      e.printStackTrace();
-      result = null;
-    }
-
-    return result;
-  }
-  
-  /**
-   * Returns the size of bytes stored.
-   * 
-   * @return		the number of bytes
-   */
-  public int size() {
-    return m_storedObjectArray.length;
-  }
-  
-  /**
-   * Writes the object to the given file.
-   * 
-   * @param filename	the file to write to
-   * @param o		the object to write
-   * @return		true if successfully written
-   */
-  public static boolean write(String filename, Serializable o) {
-    return write(new File(filename), o);
-  }
-  
-  /**
-   * Writes the object to the given file.
-   * 
-   * @param file	the file to write to
-   * @param o		the object to write
-   * @return		true if successfully written
-   */
-  public static boolean write(File file, Serializable o) {
-    boolean		result;
-    ObjectOutputStream 	oo;
-    
-    try {
-      oo = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(file)));
-      oo.writeObject(o);
-      oo.close();
-      result = true;
-    }
-    catch (Exception e) {
-      e.printStackTrace();
-      result = false;
-    }
-    
-    return result;
-  }
-  
-  /**
-   * Reads the object from the given file.
-   * 
-   * @param filename	the file to read from
-   * @return		if successful the object, otherwise null
-   */
-  public static Object read(String filename) {
-    return read(new File(filename));
-  }
-  
-  /**
-   * Reads the object from the given file.
-   * 
-   * @param file	the file to read from
-   * @return		if successful the object, otherwise null
-   */
-  public static Object read(File file) {
-    Object		result;
-    ObjectInputStream	oi;
-    
-    try {
-      oi     = new ObjectInputStream(new BufferedInputStream(new FileInputStream(file)));
-      result = oi.readObject();
-      oi.close();
-    }
-    catch (Exception ex) {
-      result = null;
-    }
-    
-    return result;
-  }
+public class SerializedObject implements Serializable {
+
+	/** for serialization. */
+	private static final long serialVersionUID = 6635502953928860434L;
+
+	/** The array storing the object. */
+	private byte[] m_storedObjectArray;
+
+	/** Whether or not the object is compressed. */
+	private boolean m_isCompressed;
+
+	/**
+	 * Creates a new serialized object (without compression).
+	 *
+	 * @param o the object to store
+	 * @throws Exception if the object couldn't be serialized
+	 */
+	public SerializedObject(Serializable o) throws Exception {
+		this(o, false);
+	}
+
+	/**
+	 * Creates a new serialized object.
+	 *
+	 * @param o        the object to store
+	 * @param compress whether or not to use compression
+	 * @throws Exception if the object couldn't be serialized
+	 */
+	public SerializedObject(Serializable o, boolean compress) throws Exception {
+		ByteArrayOutputStream ostream;
+		ObjectOutputStream p;
+
+		ostream = new ByteArrayOutputStream();
+		if (!compress)
+			p = new ObjectOutputStream(new BufferedOutputStream(ostream));
+		else
+			p = new ObjectOutputStream(new BufferedOutputStream(new GZIPOutputStream(ostream)));
+		p.writeObject(o);
+		p.flush();
+		p.close();
+		m_storedObjectArray = ostream.toByteArray();
+		m_isCompressed = compress;
+	}
+
+	/**
+	 * Checks to see whether this object is equal to another.
+	 *
+	 * @param o the object to compare to
+	 * @return whether or not the objects are equal
+	 */
+	@Override
+	public boolean equals(Object o) {
+		byte[] compareArray;
+		int i;
+
+		if (o == null)
+			return false;
+
+		if (!o.getClass().equals(this.getClass()))
+			return false;
+
+		compareArray = ((SerializedObject) o).m_storedObjectArray;
+
+		if (compareArray.length != m_storedObjectArray.length)
+			return false;
+
+		for (i = 0; i < compareArray.length; i++) {
+			if (compareArray[i] != m_storedObjectArray[i])
+				return false;
+		}
+
+		return true;
+	}
+
+	/**
+	 * Returns a hashcode for this object.
+	 *
+	 * @return the hashcode
+	 */
+	@Override
+	public int hashCode() {
+		return m_storedObjectArray.length;
+	}
+
+	/**
+	 * Returns a serialized object.
+	 *
+	 * @return the restored object
+	 */
+	public Object getObject() {
+		ByteArrayInputStream istream;
+		ObjectInputStream p;
+		Object result;
+
+		result = null;
+
+		try {
+			istream = new ByteArrayInputStream(m_storedObjectArray);
+			if (!m_isCompressed)
+				p = new ObjectInputStream(new BufferedInputStream(istream));
+			else
+				p = new ObjectInputStream(new BufferedInputStream(new GZIPInputStream(istream)));
+			result = p.readObject();
+			istream.close();
+		} catch (Exception e) {
+			e.printStackTrace();
+			result = null;
+		}
+
+		return result;
+	}
+
+	/**
+	 * Returns the size of bytes stored.
+	 * 
+	 * @return the number of bytes
+	 */
+	public int size() {
+		return m_storedObjectArray.length;
+	}
+
+	/**
+	 * Writes the object to the given file.
+	 * 
+	 * @param filename the file to write to
+	 * @param o        the object to write
+	 * @return true if successfully written
+	 */
+	public static boolean write(String filename, Serializable o) {
+		return write(new File(filename), o);
+	}
+
+	/**
+	 * Writes the object to the given file.
+	 * 
+	 * @param file the file to write to
+	 * @param o    the object to write
+	 * @return true if successfully written
+	 */
+	public static boolean write(File file, Serializable o) {
+		boolean result;
+		ObjectOutputStream oo;
+
+		try {
+			oo = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(file)));
+			oo.writeObject(o);
+			oo.close();
+			result = true;
+		} catch (Exception e) {
+			e.printStackTrace();
+			result = false;
+		}
+
+		return result;
+	}
+
+	/**
+	 * Reads the object from the given file.
+	 * 
+	 * @param filename the file to read from
+	 * @return if successful the object, otherwise null
+	 */
+	public static Object read(String filename) {
+		return read(new File(filename));
+	}
+
+	/**
+	 * Reads the object from the given file.
+	 * 
+	 * @param file the file to read from
+	 * @return if successful the object, otherwise null
+	 */
+	public static Object read(File file) {
+		Object result;
+		ObjectInputStream oi;
+
+		try {
+			oi = new ObjectInputStream(new BufferedInputStream(new FileInputStream(file)));
+			result = oi.readObject();
+			oi.close();
+		} catch (Exception ex) {
+			result = null;
+		}
+
+		return result;
+	}
 }
diff --git a/moa/src/test/java/moa/test/TestHelper.java b/moa/src/test/java/moa/test/TestHelper.java
index af0561db8..f6d5a98bd 100644
--- a/moa/src/test/java/moa/test/TestHelper.java
+++ b/moa/src/test/java/moa/test/TestHelper.java
@@ -22,45 +22,44 @@
 /**
  * A helper class specific to the moa project.
  *
- * @author  fracpete (fracpete at waikato dot ac dot nz)
+ * @author fracpete (fracpete at waikato dot ac dot nz)
  * @version $Revision: 4584 $
  * @param <I> the type of input data
  * @param <O> the type of output data
  */
-public class TestHelper<I, O>
-  extends AbstractTestHelper<I, O> {
+public class TestHelper<I, O> extends AbstractTestHelper<I, O> {
 
-  /**
-   * Initializes the helper class.
-   *
-   * @param owner	the owning test case
-   * @param dataDir	the data directory to use
-   */
-  public TestHelper(MoaTestCase owner, String dataDir) {
-    super(owner, dataDir);
-  }
+	/**
+	 * Initializes the helper class.
+	 *
+	 * @param owner   the owning test case
+	 * @param dataDir the data directory to use
+	 */
+	public TestHelper(MoaTestCase owner, String dataDir) {
+		super(owner, dataDir);
+	}
 
-  /**
-   * Dummy, does nothing.
-   *
-   * @param filename	the filename to load (without path)
-   * @return		always null
-   */
-  @Override
-  public I load(String filename) {
-    return null;
-  }
+	/**
+	 * Dummy, does nothing.
+	 *
+	 * @param filename the filename to load (without path)
+	 * @return always null
+	 */
+	@Override
+	public I load(String filename) {
+		return null;
+	}
 
-  /**
-   * Dummy, just write the string returned by the object's toString()
-   * method to the file.
-   *
-   * @param data	the data to save
-   * @param filename	the filename to save to (without path)
-   * @return		always true
-   */
-  @Override
-  public boolean save(O data, String filename) {
-    return FileUtils.writeToFile(new TmpFile(filename).getAbsolutePath(), data.toString(), false);
-  }
+	/**
+	 * Dummy, just write the string returned by the object's toString() method to
+	 * the file.
+	 *
+	 * @param data     the data to save
+	 * @param filename the filename to save to (without path)
+	 * @return always true
+	 */
+	@Override
+	public boolean save(O data, String filename) {
+		return FileUtils.writeToFile(new TmpFile(filename).getAbsolutePath(), data.toString(), false);
+	}
 }
diff --git a/moa/src/test/java/moa/test/TmpFile.java b/moa/src/test/java/moa/test/TmpFile.java
index 81a33fccc..fd03061e3 100644
--- a/moa/src/test/java/moa/test/TmpFile.java
+++ b/moa/src/test/java/moa/test/TmpFile.java
@@ -23,36 +23,35 @@
 
 /**
  * A simple file handler class that automatically places the file in the
- * system's tmp directory. But the user still needs to delete the file
- * manually when it's no longer used.
+ * system's tmp directory. But the user still needs to delete the file manually
+ * when it's no longer used.
  *
- * @author  fracpete (fracpete at waikato dot ac dot nz)
+ * @author fracpete (fracpete at waikato dot ac dot nz)
  * @version $Revision: 4584 $
  */
-public class TmpFile
-  extends File {
+public class TmpFile extends File {
 
-  /** for serialization. */
-  private static final long serialVersionUID = 4323672645601038764L;
+	/** for serialization. */
+	private static final long serialVersionUID = 4323672645601038764L;
 
-  /**
-   * Creates a new <code>File</code> instance by converting the given
-   * pathname string into an abstract pathname.  If the given string is
-   * the empty string, then the result is the empty abstract pathname.
-   * Creates a file object pointing to the tmp directory.
-   */
-  public TmpFile() {
-    super(System.getProperty("java.io.tmpdir"));
-  }
+	/**
+	 * Creates a new <code>File</code> instance by converting the given pathname
+	 * string into an abstract pathname. If the given string is the empty string,
+	 * then the result is the empty abstract pathname. Creates a file object
+	 * pointing to the tmp directory.
+	 */
+	public TmpFile() {
+		super(System.getProperty("java.io.tmpdir"));
+	}
 
-  /**
-   * Creates a new <code>File</code> instance by converting the given
-   * pathname string into an abstract pathname.  If the given string is
-   * the empty string, then the result is the empty abstract pathname.
-   *
-   * @param   pathname  A pathname string
-   */
-  public TmpFile(String pathname) {
-    super(System.getProperty("java.io.tmpdir") + separator + pathname);
-  }
+	/**
+	 * Creates a new <code>File</code> instance by converting the given pathname
+	 * string into an abstract pathname. If the given string is the empty string,
+	 * then the result is the empty abstract pathname.
+	 *
+	 * @param pathname A pathname string
+	 */
+	public TmpFile(String pathname) {
+		super(System.getProperty("java.io.tmpdir") + separator + pathname);
+	}
 }
diff --git a/moa/src/test/java/moa/test/Utils.java b/moa/src/test/java/moa/test/Utils.java
index 2a3361416..7b7e37a90 100644
--- a/moa/src/test/java/moa/test/Utils.java
+++ b/moa/src/test/java/moa/test/Utils.java
@@ -23,116 +23,110 @@
 
 /**
  * Class with useful methods.
- * 
- * @author  fracpete (fracpete at waikato dot ac dot nz)
+ *
+ * @author fracpete (fracpete at waikato dot ac dot nz)
  * @version $Revision$
  */
 public class Utils {
 
-  /**
-   * Returns the basic class of an array class (handles multi-dimensional
-   * arrays).
-   * @param c        the array to inspect
-   * @return         the class of the innermost elements
-   */
-  public static Class getArrayClass(Class c) {
-    if (c.getComponentType().isArray())
-      return getArrayClass(c.getComponentType());
-    else
-      return c.getComponentType();
-  }
+	/**
+	 * Returns the basic class of an array class (handles multi-dimensional arrays).
+	 * 
+	 * @param c the array to inspect
+	 * @return the class of the innermost elements
+	 */
+	public static Class getArrayClass(Class c) {
+		if (c.getComponentType().isArray())
+			return getArrayClass(c.getComponentType());
+		else
+			return c.getComponentType();
+	}
+
+	/**
+	 * Returns the dimensions of the given array. Even though the parameter is of
+	 * type "Object" one can hand over primitve arrays, e.g. int[3] or double[2][4].
+	 *
+	 * @param array the array to determine the dimensions for
+	 * @return the dimensions of the array
+	 */
+	public static int getArrayDimensions(Class array) {
+		if (array.getComponentType().isArray())
+			return 1 + getArrayDimensions(array.getComponentType());
+		else
+			return 1;
+	}
 
-  /**
-   * Returns the dimensions of the given array. Even though the
-   * parameter is of type "Object" one can hand over primitve arrays, e.g.
-   * int[3] or double[2][4].
-   *
-   * @param array       the array to determine the dimensions for
-   * @return            the dimensions of the array
-   */
-  public static int getArrayDimensions(Class array) {
-    if (array.getComponentType().isArray())
-      return 1 + getArrayDimensions(array.getComponentType());
-    else
-      return 1;
-  }
+	/**
+	 * Returns the dimensions of the given array. Even though the parameter is of
+	 * type "Object" one can hand over primitve arrays, e.g. int[3] or double[2][4].
+	 *
+	 * @param array the array to determine the dimensions for
+	 * @return the dimensions of the array
+	 */
+	public static int getArrayDimensions(Object array) {
+		return getArrayDimensions(array.getClass());
+	}
 
-  /**
-   * Returns the dimensions of the given array. Even though the
-   * parameter is of type "Object" one can hand over primitve arrays, e.g.
-   * int[3] or double[2][4].
-   *
-   * @param array       the array to determine the dimensions for
-   * @return            the dimensions of the array
-   */
-  public static int getArrayDimensions(Object array) {
-    return getArrayDimensions(array.getClass());
-  }
+	/**
+	 * Returns the given Array in a string representation. Even though the parameter
+	 * is of type "Object" one can hand over primitve arrays, e.g. int[3] or
+	 * double[2][4].
+	 *
+	 * @param array       the array to return in a string representation
+	 * @param outputClass whether to output the class name instead of calling the
+	 *                    object's "toString()" method
+	 * @return the array as string
+	 */
+	public static String arrayToString(Object array, boolean outputClass) {
+		StringBuilder result;
+		int dimensions;
+		int i;
+		Object obj;
 
-  /**
-   * Returns the given Array in a string representation. Even though the
-   * parameter is of type "Object" one can hand over primitve arrays, e.g.
-   * int[3] or double[2][4].
-   *
-   * @param array       the array to return in a string representation
-   * @param outputClass	whether to output the class name instead of calling
-   * 			the object's "toString()" method
-   * @return            the array as string
-   */
-  public static String arrayToString(Object array, boolean outputClass) {
-    StringBuilder	result;
-    int			dimensions;
-    int			i;
-    Object		obj;
+		result = new StringBuilder();
+		dimensions = getArrayDimensions(array);
 
-    result     = new StringBuilder();
-    dimensions = getArrayDimensions(array);
+		if (dimensions == 0) {
+			result.append("null");
+		} else if (dimensions == 1) {
+			for (i = 0; i < Array.getLength(array); i++) {
+				if (i > 0)
+					result.append(",");
+				if (Array.get(array, i) == null) {
+					result.append("null");
+				} else {
+					obj = Array.get(array, i);
+					if (outputClass) {
+						if (obj instanceof Class)
+							result.append(((Class) obj).getName());
+						else
+							result.append(obj.getClass().getName());
+					} else {
+						result.append(obj.toString());
+					}
+				}
+			}
+		} else {
+			for (i = 0; i < Array.getLength(array); i++) {
+				if (i > 0)
+					result.append(",");
+				result.append("[" + arrayToString(Array.get(array, i)) + "]");
+			}
+		}
 
-    if (dimensions == 0) {
-      result.append("null");
-    }
-    else if (dimensions == 1) {
-      for (i = 0; i < Array.getLength(array); i++) {
-	if (i > 0)
-	  result.append(",");
-	if (Array.get(array, i) == null) {
-	  result.append("null");
-	}
-	else {
-	  obj = Array.get(array, i);
-	  if (outputClass) {
-	    if (obj instanceof Class)
-	      result.append(((Class) obj).getName());
-	    else
-	      result.append(obj.getClass().getName());
-	  }
-	  else {
-	    result.append(obj.toString());
-	  }
+		return result.toString();
 	}
-      }
-    }
-    else {
-      for (i = 0; i < Array.getLength(array); i++) {
-	if (i > 0)
-	  result.append(",");
-	result.append("[" + arrayToString(Array.get(array, i)) + "]");
-      }
-    }
 
-    return result.toString();
-  }
-
-  /**
-   * Returns the given Array in a string representation. Even though the
-   * parameter is of type "Object" one can hand over primitve arrays, e.g.
-   * int[3] or double[2][4].
-   *
-   * @param array       the array to return in a string representation
-   * @return            the array as string
-   */
-  public static String arrayToString(Object array) {
-    return arrayToString(array, false);
-  }
+	/**
+	 * Returns the given Array in a string representation. Even though the parameter
+	 * is of type "Object" one can hand over primitve arrays, e.g. int[3] or
+	 * double[2][4].
+	 *
+	 * @param array the array to return in a string representation
+	 * @return the array as string
+	 */
+	public static String arrayToString(Object array) {
+		return arrayToString(array, false);
+	}
 
 }
diff --git a/moa/src/test/resources/moa/classifiers/drift/SingleClassifierDrift.ref b/moa/src/test/resources/moa/classifiers/drift/SingleClassifierDrift.ref
deleted file mode 100644
index 7101799e3..000000000
--- a/moa/src/test/resources/moa/classifiers/drift/SingleClassifierDrift.ref
+++ /dev/null
@@ -1,175 +0,0 @@
---> classification-out0.arff
-moa.classifiers.drift.SingleClassifierDrift
-
-Index
-  10000
-Votes
-  0: 0.0000641
-  1: 0.00003628
-Measurements
-  classified instances: 9999
-  classifications correct (percent): 72.89728973
-  Kappa Statistic (percent): 41.81847765
-  Kappa Temporal Statistic (percent): 42.87521079
-  Kappa M Statistic (percent): 33.82173382
-Model measurements
-  model training instances: 9999
-  Change detected: 0
-  Warning detected: 52
-  model training instances: 9999
-
-Index
-  20000
-Votes
-  0: 0.00006447
-  1: 0.00011607
-Measurements
-  classified instances: 19999
-  classifications correct (percent): 73.16865843
-  Kappa Statistic (percent): 42.93623835
-  Kappa Temporal Statistic (percent): 43.98162647
-  Kappa M Statistic (percent): 35.67489811
-Model measurements
-  model training instances: 19999
-  Change detected: 0
-  Warning detected: 0
-  model training instances: 19999
-
-Index
-  30000
-Votes
-  0: 0.00015275
-  1: 0.00025596
-Measurements
-  classified instances: 29999
-  classifications correct (percent): 73.27244241
-  Kappa Statistic (percent): 43.15271423
-  Kappa Temporal Statistic (percent): 44.61559715
-  Kappa M Statistic (percent): 35.79436259
-Model measurements
-  model training instances: 29999
-  Change detected: 0
-  Warning detected: 0
-  model training instances: 29999
-
-Index
-  40000
-Votes
-  0: 0.00003871
-  1: 0.00012759
-Measurements
-  classified instances: 39999
-  classifications correct (percent): 73.38433461
-  Kappa Statistic (percent): 43.54638422
-  Kappa Temporal Statistic (percent): 44.98475531
-  Kappa M Statistic (percent): 36.3277512
-Model measurements
-  model training instances: 39999
-  Change detected: 0
-  Warning detected: 0
-  model training instances: 39999
-
-Index
-  50000
-Votes
-  0: 0.00002152
-  1: 0.0000518
-Measurements
-  classified instances: 49999
-  classifications correct (percent): 73.35746715
-  Kappa Statistic (percent): 43.48652952
-  Kappa Temporal Statistic (percent): 44.85884593
-  Kappa M Statistic (percent): 36.25095712
-Model measurements
-  model training instances: 49999
-  Change detected: 0
-  Warning detected: 0
-  model training instances: 49999
-
-Index
-  60000
-Votes
-  0: 0.00003779
-  1: 0.00018819
-Measurements
-  classified instances: 59999
-  classifications correct (percent): 73.36122269
-  Kappa Statistic (percent): 43.62514295
-  Kappa Temporal Statistic (percent): 44.91469929
-  Kappa M Statistic (percent): 36.58043012
-Model measurements
-  model training instances: 59999
-  Change detected: 0
-  Warning detected: 0
-  model training instances: 59999
-
-Index
-  70000
-Votes
-  0: 0.00011882
-  1: 0.00018488
-Measurements
-  classified instances: 69999
-  classifications correct (percent): 73.3810483
-  Kappa Statistic (percent): 43.73709504
-  Kappa Temporal Statistic (percent): 45.13089314
-  Kappa M Statistic (percent): 36.84585141
-Model measurements
-  model training instances: 69999
-  Change detected: 0
-  Warning detected: 0
-  model training instances: 69999
-
-Index
-  80000
-Votes
-  0: 0.0001627
-  1: 0.00013146
-Measurements
-  classified instances: 79999
-  classifications correct (percent): 73.36341704
-  Kappa Statistic (percent): 43.71144848
-  Kappa Temporal Statistic (percent): 45.14916729
-  Kappa M Statistic (percent): 36.79855262
-Model measurements
-  model training instances: 79999
-  Change detected: 0
-  Warning detected: 0
-  model training instances: 79999
-
-Index
-  90000
-Votes
-  0: 0.00008438
-  1: 0.00008116
-Measurements
-  classified instances: 89999
-  classifications correct (percent): 73.39081545
-  Kappa Statistic (percent): 43.77125988
-  Kappa Temporal Statistic (percent): 45.18026783
-  Kappa M Statistic (percent): 36.84599156
-Model measurements
-  model training instances: 89999
-  Change detected: 0
-  Warning detected: 0
-  model training instances: 89999
-
-Index
-  100000
-Votes
-  0: 0.00024103
-  1: 0.00003174
-Measurements
-  classified instances: 99999
-  classifications correct (percent): 73.38573386
-  Kappa Statistic (percent): 43.79308354
-  Kappa Temporal Statistic (percent): 45.17551088
-  Kappa M Statistic (percent): 36.90673747
-Model measurements
-  model training instances: 99999
-  Change detected: 0
-  Warning detected: 0
-  model training instances: 99999
-
-
-
diff --git a/moa/src/test/resources/moa/classifiers/functions/Perceptron.ref b/moa/src/test/resources/moa/classifiers/functions/Perceptron.ref
deleted file mode 100644
index 249d9b7e5..000000000
--- a/moa/src/test/resources/moa/classifiers/functions/Perceptron.ref
+++ /dev/null
@@ -1,145 +0,0 @@
---> classification-out0.arff
-moa.classifiers.functions.Perceptron
-
-Index
-  10000
-Votes
-  0: 1
-  1: 0
-Measurements
-  classified instances: 9999
-  classifications correct (percent): 60.56605661
-  Kappa Statistic (percent): 14.58053886
-  Kappa Temporal Statistic (percent): 16.88448567
-  Kappa M Statistic (percent): 3.71184371
-Model measurements
-  model training instances: 9999
-
-Index
-  20000
-Votes
-  0: 0
-  1: 1
-Measurements
-  classified instances: 19999
-  classifications correct (percent): 60.5780289
-  Kappa Statistic (percent): 15.66547339
-  Kappa Temporal Statistic (percent): 17.69495772
-  Kappa M Statistic (percent): 5.4902901
-Model measurements
-  model training instances: 19999
-
-Index
-  30000
-Votes
-  0: 0
-  1: 1
-Measurements
-  classified instances: 29999
-  classifications correct (percent): 61.07536918
-  Kappa Statistic (percent): 16.11413873
-  Kappa Temporal Statistic (percent): 19.34102369
-  Kappa M Statistic (percent): 6.49423447
-Model measurements
-  model training instances: 29999
-
-Index
-  40000
-Votes
-  0: 0.21927306
-  1: 0.78072694
-Measurements
-  classified instances: 39999
-  classifications correct (percent): 60.72651816
-  Kappa Statistic (percent): 16.25921999
-  Kappa Temporal Statistic (percent): 18.82073278
-  Kappa M Statistic (percent): 6.04665072
-Model measurements
-  model training instances: 39999
-
-Index
-  50000
-Votes
-  0: 0.50003863
-  1: 0.49996137
-Measurements
-  classified instances: 49999
-  classifications correct (percent): 60.43120862
-  Kappa Statistic (percent): 16.57599528
-  Kappa Temporal Statistic (percent): 18.10580346
-  Kappa M Statistic (percent): 5.32159265
-Model measurements
-  model training instances: 49999
-
-Index
-  60000
-Votes
-  0: 0
-  1: 1
-Measurements
-  classified instances: 59999
-  classifications correct (percent): 60.25933766
-  Kappa Statistic (percent): 16.59662639
-  Kappa Temporal Statistic (percent): 17.8218163
-  Kappa M Statistic (percent): 5.38846123
-Model measurements
-  model training instances: 59999
-
-Index
-  70000
-Votes
-  0: 1
-  1: 0
-Measurements
-  classified instances: 69999
-  classifications correct (percent): 60.20800297
-  Kappa Statistic (percent): 16.95899541
-  Kappa Temporal Statistic (percent): 17.97756118
-  Kappa M Statistic (percent): 5.59246204
-Model measurements
-  model training instances: 69999
-
-Index
-  80000
-Votes
-  0: 0.99345669
-  1: 0.00654331
-Measurements
-  classified instances: 79999
-  classifications correct (percent): 60.03950049
-  Kappa Statistic (percent): 16.83389735
-  Kappa Temporal Statistic (percent): 17.71216762
-  Kappa M Statistic (percent): 5.18448214
-Model measurements
-  model training instances: 79999
-
-Index
-  90000
-Votes
-  0: 0.5
-  1: 0.5
-Measurements
-  classified instances: 89999
-  classifications correct (percent): 59.91399904
-  Kappa Statistic (percent): 16.60980374
-  Kappa Temporal Statistic (percent): 17.41558887
-  Kappa M Statistic (percent): 4.86023207
-Model measurements
-  model training instances: 89999
-
-Index
-  100000
-Votes
-  0: 0.50000347
-  1: 0.49999653
-Measurements
-  classified instances: 99999
-  classifications correct (percent): 59.87259873
-  Kappa Statistic (percent): 16.60960489
-  Kappa Temporal Statistic (percent): 17.33890903
-  Kappa M Statistic (percent): 4.87174624
-Model measurements
-  model training instances: 99999
-
-
-
diff --git a/moa/src/test/resources/moa/classifiers/meta/OzaBagAdwin.ref b/moa/src/test/resources/moa/classifiers/meta/OzaBagAdwin.ref
deleted file mode 100644
index 9f6fcd0e4..000000000
--- a/moa/src/test/resources/moa/classifiers/meta/OzaBagAdwin.ref
+++ /dev/null
@@ -1,315 +0,0 @@
---> classification-out0.arff
-moa.classifiers.meta.OzaBagAdwin
-
-Index
-  10000
-Votes
-  0: 8.05910059
-  1: 1.94089941
-Measurements
-  classified instances: 9999
-  classifications correct (percent): 81.73817382
-  Kappa Statistic (percent): 61.49714818
-  Kappa Temporal Statistic (percent): 61.50927487
-  Kappa M Statistic (percent): 55.40903541
-Model measurements
-  model training instances: 9999
-  ensemble size: 10
-  [avg] model training instances: 9978.8
-  [err] model training instances: 62.04801009
-  [avg] tree size (nodes): 43.1
-  [err] tree size (nodes): 8.00624756
-  [avg] tree size (leaves): 33.9
-  [err] tree size (leaves): 6.27959659
-  [avg] active learning leaves: 33.9
-  [err] active learning leaves: 6.27959659
-  [avg] tree depth: 3
-  [err] tree depth: 0
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  20000
-Votes
-  0: 1.01860009
-  1: 8.98139991
-Measurements
-  classified instances: 19999
-  classifications correct (percent): 84.36421821
-  Kappa Statistic (percent): 67.44374263
-  Kappa Temporal Statistic (percent): 67.35567387
-  Kappa M Statistic (percent): 62.51498442
-Model measurements
-  model training instances: 19999
-  ensemble size: 10
-  [avg] model training instances: 20014.7
-  [err] model training instances: 77.62166078
-  [avg] tree size (nodes): 63.4
-  [err] tree size (nodes): 3.37309617
-  [avg] tree size (leaves): 47.2
-  [err] tree size (leaves): 1.68654809
-  [avg] active learning leaves: 47.2
-  [err] active learning leaves: 1.68654809
-  [avg] tree depth: 3
-  [err] tree depth: 0
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  30000
-Votes
-  0: 0.01405849
-  1: 9.98594151
-Measurements
-  classified instances: 29999
-  classifications correct (percent): 85.97286576
-  Kappa Statistic (percent): 70.84723817
-  Kappa Temporal Statistic (percent): 70.93320439
-  Kappa M Statistic (percent): 66.30365151
-Model measurements
-  model training instances: 29999
-  ensemble size: 10
-  [avg] model training instances: 29946.3
-  [err] model training instances: 105.60308287
-  [avg] tree size (nodes): 75.2
-  [err] tree size (nodes): 2.93636207
-  [avg] tree size (leaves): 53.7
-  [err] tree size (leaves): 2.26323269
-  [avg] active learning leaves: 53.7
-  [err] active learning leaves: 2.26323269
-  [avg] tree depth: 4
-  [err] tree depth: 0
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  40000
-Votes
-  0: 0.61385275
-  1: 9.38614725
-Measurements
-  classified instances: 39999
-  classifications correct (percent): 86.7721693
-  Kappa Statistic (percent): 72.57926888
-  Kappa Temporal Statistic (percent): 72.65774379
-  Kappa M Statistic (percent): 68.35526316
-Model measurements
-  model training instances: 39999
-  ensemble size: 10
-  [avg] model training instances: 39926.3
-  [err] model training instances: 131.01149229
-  [avg] tree size (nodes): 99
-  [err] tree size (nodes): 4.98887652
-  [avg] tree size (leaves): 68
-  [err] tree size (leaves): 2.49443826
-  [avg] active learning leaves: 68
-  [err] active learning leaves: 2.49443826
-  [avg] tree depth: 4
-  [err] tree depth: 0
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  50000
-Votes
-  0: 6.75079178
-  1: 3.24920822
-Measurements
-  classified instances: 49999
-  classifications correct (percent): 87.39774795
-  Kappa Statistic (percent): 73.90124952
-  Kappa Temporal Statistic (percent): 73.91754284
-  Kappa M Statistic (percent): 69.84590352
-Model measurements
-  model training instances: 49999
-  ensemble size: 10
-  [avg] model training instances: 49914.4
-  [err] model training instances: 146.11198141
-  [avg] tree size (nodes): 107.6
-  [err] tree size (nodes): 5.50151494
-  [avg] tree size (leaves): 72.3
-  [err] tree size (leaves): 2.75075747
-  [avg] active learning leaves: 72.3
-  [err] active learning leaves: 2.75075747
-  [avg] tree depth: 4
-  [err] tree depth: 0
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  60000
-Votes
-  0: 0.00297407
-  1: 9.99702593
-Measurements
-  classified instances: 59999
-  classifications correct (percent): 87.96313272
-  Kappa Statistic (percent): 75.13090877
-  Kappa Temporal Statistic (percent): 75.10942616
-  Kappa M Statistic (percent): 71.34354416
-Model measurements
-  model training instances: 59999
-  ensemble size: 10
-  [avg] model training instances: 59896.4
-  [err] model training instances: 143.12170423
-  [avg] tree size (nodes): 118.7
-  [err] tree size (nodes): 5.27151675
-  [avg] tree size (leaves): 78.3
-  [err] tree size (leaves): 3.02030168
-  [avg] active learning leaves: 78.3
-  [err] active learning leaves: 3.02030168
-  [avg] tree depth: 4.5
-  [err] tree depth: 0.52704628
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  70000
-Votes
-  0: 0.18695406
-  1: 9.81304594
-Measurements
-  classified instances: 69999
-  classifications correct (percent): 88.36554808
-  Kappa Statistic (percent): 75.99851798
-  Kappa Temporal Statistic (percent): 76.01813952
-  Kappa M Statistic (percent): 72.39696312
-Model measurements
-  model training instances: 69999
-  ensemble size: 10
-  [avg] model training instances: 69920.7
-  [err] model training instances: 163.21155324
-  [avg] tree size (nodes): 133.5
-  [err] tree size (nodes): 6.24054841
-  [avg] tree size (leaves): 87.5
-  [err] tree size (leaves): 4.42844342
-  [avg] active learning leaves: 87.5
-  [err] active learning leaves: 4.42844342
-  [avg] tree depth: 4.9
-  [err] tree depth: 0.31622777
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  80000
-Votes
-  0: 0.21629667
-  1: 9.78370333
-Measurements
-  classified instances: 79999
-  classifications correct (percent): 88.73985925
-  Kappa Statistic (percent): 76.78183907
-  Kappa Temporal Statistic (percent): 76.81278797
-  Kappa M Statistic (percent): 73.28271444
-Model measurements
-  model training instances: 79999
-  ensemble size: 10
-  [avg] model training instances: 79907.9
-  [err] model training instances: 164.46914604
-  [avg] tree size (nodes): 142.8
-  [err] tree size (nodes): 5.65292451
-  [avg] tree size (leaves): 93.2
-  [err] tree size (leaves): 3.91010088
-  [avg] active learning leaves: 93.2
-  [err] active learning leaves: 3.91010088
-  [avg] tree depth: 4.9
-  [err] tree depth: 0.31622777
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  90000
-Votes
-  0: 0.02339952
-  1: 9.97660048
-Measurements
-  classified instances: 89999
-  classifications correct (percent): 89.04210047
-  Kappa Statistic (percent): 77.41497444
-  Kappa Temporal Statistic (percent): 77.42474534
-  Kappa M Statistic (percent): 73.99261603
-Model measurements
-  model training instances: 89999
-  ensemble size: 10
-  [avg] model training instances: 89910.8
-  [err] model training instances: 189.59067019
-  [avg] tree size (nodes): 164.3
-  [err] tree size (nodes): 4.32177947
-  [avg] tree size (leaves): 104.4
-  [err] tree size (leaves): 2.31900362
-  [avg] active learning leaves: 104.4
-  [err] active learning leaves: 2.31900362
-  [avg] tree depth: 5
-  [err] tree depth: 0
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  100000
-Votes
-  0: 8.56422451
-  1: 1.43577549
-Measurements
-  classified instances: 99999
-  classifications correct (percent): 89.34689347
-  Kappa Statistic (percent): 78.05429949
-  Kappa Temporal Statistic (percent): 78.05496045
-  Kappa M Statistic (percent): 74.74515196
-Model measurements
-  model training instances: 99999
-  ensemble size: 10
-  [avg] model training instances: 99859.3
-  [err] model training instances: 230.91703657
-  [avg] tree size (nodes): 184.3
-  [err] tree size (nodes): 4.37289632
-  [avg] tree size (leaves): 115.9
-  [err] tree size (leaves): 2.3781412
-  [avg] active learning leaves: 115.9
-  [err] active learning leaves: 2.3781412
-  [avg] tree depth: 5.1
-  [err] tree depth: 0.31622777
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-
-
diff --git a/moa/src/test/resources/moa/classifiers/meta/OzaBagClassification.ref b/moa/src/test/resources/moa/classifiers/meta/OzaBagClassification.ref
deleted file mode 100644
index b96d4b0f7..000000000
--- a/moa/src/test/resources/moa/classifiers/meta/OzaBagClassification.ref
+++ /dev/null
@@ -1,315 +0,0 @@
---> classification-out0.arff
-moa.classifiers.meta.OzaBagClassification
-
-Index
-  10000
-Votes
-  0: 0
-  1: 0
-Measurements
-  classified instances: 9999
-  classifications correct (percent): 40.95409541
-  Kappa Statistic (percent): 0
-  Kappa Temporal Statistic (percent): -24.45193929
-  Kappa M Statistic (percent): -44.17582418
-Model measurements
-  model training instances: 9999
-  ensemble size: 10
-  [avg] model training instances: 9978.8
-  [err] model training instances: 62.04801009
-  [avg] tree size (nodes): 43.1
-  [err] tree size (nodes): 8.00624756
-  [avg] tree size (leaves): 33.9
-  [err] tree size (leaves): 6.27959659
-  [avg] active learning leaves: 33.9
-  [err] active learning leaves: 6.27959659
-  [avg] tree depth: 3
-  [err] tree depth: 0
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  20000
-Votes
-  0: 0
-  1: 0
-Measurements
-  classified instances: 19999
-  classifications correct (percent): 41.7120856
-  Kappa Statistic (percent): 0
-  Kappa Temporal Statistic (percent): -21.6932874
-  Kappa M Statistic (percent): -39.73867178
-Model measurements
-  model training instances: 19999
-  ensemble size: 10
-  [avg] model training instances: 20014.7
-  [err] model training instances: 77.62166078
-  [avg] tree size (nodes): 63.4
-  [err] tree size (nodes): 3.37309617
-  [avg] tree size (leaves): 47.2
-  [err] tree size (leaves): 1.68654809
-  [avg] active learning leaves: 47.2
-  [err] active learning leaves: 1.68654809
-  [avg] tree depth: 3
-  [err] tree depth: 0
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  30000
-Votes
-  0: 0
-  1: 0
-Measurements
-  classified instances: 29999
-  classifications correct (percent): 41.62805427
-  Kappa Statistic (percent): 0
-  Kappa Temporal Statistic (percent): -20.95738067
-  Kappa M Statistic (percent): -40.22261371
-Model measurements
-  model training instances: 29999
-  ensemble size: 10
-  [avg] model training instances: 29946.3
-  [err] model training instances: 105.60308287
-  [avg] tree size (nodes): 75.2
-  [err] tree size (nodes): 2.93636207
-  [avg] tree size (leaves): 53.7
-  [err] tree size (leaves): 2.26323269
-  [avg] active learning leaves: 53.7
-  [err] active learning leaves: 2.26323269
-  [avg] tree depth: 4
-  [err] tree depth: 0
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  40000
-Votes
-  0: 0
-  1: 0
-Measurements
-  classified instances: 39999
-  classifications correct (percent): 41.80104503
-  Kappa Statistic (percent): 0
-  Kappa Temporal Statistic (percent): -20.29869257
-  Kappa M Statistic (percent): -39.2284689
-Model measurements
-  model training instances: 39999
-  ensemble size: 10
-  [avg] model training instances: 39926.3
-  [err] model training instances: 131.01149229
-  [avg] tree size (nodes): 99
-  [err] tree size (nodes): 4.98887652
-  [avg] tree size (leaves): 68
-  [err] tree size (leaves): 2.49443826
-  [avg] active learning leaves: 68
-  [err] active learning leaves: 2.49443826
-  [avg] tree depth: 4
-  [err] tree depth: 0
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  50000
-Votes
-  0: 0
-  1: 0
-Measurements
-  classified instances: 49999
-  classifications correct (percent): 41.79283586
-  Kappa Statistic (percent): 0
-  Kappa Temporal Statistic (percent): -20.46940972
-  Kappa M Statistic (percent): -39.27545942
-Model measurements
-  model training instances: 49999
-  ensemble size: 10
-  [avg] model training instances: 49914.4
-  [err] model training instances: 146.11198141
-  [avg] tree size (nodes): 107.6
-  [err] tree size (nodes): 5.50151494
-  [avg] tree size (leaves): 72.3
-  [err] tree size (leaves): 2.75075747
-  [avg] active learning leaves: 72.3
-  [err] active learning leaves: 2.75075747
-  [avg] tree depth: 4
-  [err] tree depth: 0
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  60000
-Votes
-  0: 0
-  1: 0
-Measurements
-  classified instances: 59999
-  classifications correct (percent): 42.0040334
-  Kappa Statistic (percent): 0
-  Kappa Temporal Statistic (percent): -19.92762364
-  Kappa M Statistic (percent): -38.07237521
-Model measurements
-  model training instances: 59999
-  ensemble size: 10
-  [avg] model training instances: 59896.4
-  [err] model training instances: 143.12170423
-  [avg] tree size (nodes): 118.7
-  [err] tree size (nodes): 5.27151675
-  [avg] tree size (leaves): 78.3
-  [err] tree size (leaves): 3.02030168
-  [avg] active learning leaves: 78.3
-  [err] active learning leaves: 3.02030168
-  [avg] tree depth: 4.5
-  [err] tree depth: 0.52704628
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  70000
-Votes
-  0: 0
-  1: 0
-Measurements
-  classified instances: 69999
-  classifications correct (percent): 42.14917356
-  Kappa Statistic (percent): 0
-  Kappa Temporal Statistic (percent): -19.24673871
-  Kappa M Statistic (percent): -37.25257592
-Model measurements
-  model training instances: 69999
-  ensemble size: 10
-  [avg] model training instances: 69920.7
-  [err] model training instances: 163.21155324
-  [avg] tree size (nodes): 133.5
-  [err] tree size (nodes): 6.24054841
-  [avg] tree size (leaves): 87.5
-  [err] tree size (leaves): 4.42844342
-  [avg] active learning leaves: 87.5
-  [err] active learning leaves: 4.42844342
-  [avg] tree depth: 4.9
-  [err] tree depth: 0.31622777
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  80000
-Votes
-  0: 0
-  1: 0
-Measurements
-  classified instances: 79999
-  classifications correct (percent): 42.14552682
-  Kappa Statistic (percent): 0
-  Kappa Temporal Statistic (percent): -19.13562769
-  Kappa M Statistic (percent): -37.27310476
-Model measurements
-  model training instances: 79999
-  ensemble size: 10
-  [avg] model training instances: 79907.9
-  [err] model training instances: 164.46914604
-  [avg] tree size (nodes): 142.8
-  [err] tree size (nodes): 5.65292451
-  [avg] tree size (leaves): 93.2
-  [err] tree size (leaves): 3.91010088
-  [avg] active learning leaves: 93.2
-  [err] active learning leaves: 3.91010088
-  [avg] tree depth: 4.9
-  [err] tree depth: 0.31622777
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  90000
-Votes
-  0: 0
-  1: 0
-Measurements
-  classified instances: 89999
-  classifications correct (percent): 42.13380149
-  Kappa Statistic (percent): 0
-  Kappa Temporal Statistic (percent): -19.21483347
-  Kappa M Statistic (percent): -37.33913502
-Model measurements
-  model training instances: 89999
-  ensemble size: 10
-  [avg] model training instances: 89910.8
-  [err] model training instances: 189.59067019
-  [avg] tree size (nodes): 164.3
-  [err] tree size (nodes): 4.32177947
-  [avg] tree size (leaves): 104.4
-  [err] tree size (leaves): 2.31900362
-  [avg] active learning leaves: 104.4
-  [err] active learning leaves: 2.31900362
-  [avg] tree depth: 5
-  [err] tree depth: 0
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  100000
-Votes
-  0: 0
-  1: 0
-Measurements
-  classified instances: 99999
-  classifications correct (percent): 42.18242182
-  Kappa Statistic (percent): 0
-  Kappa Temporal Statistic (percent): -19.10225775
-  Kappa M Statistic (percent): -37.06557299
-Model measurements
-  model training instances: 99999
-  ensemble size: 10
-  [avg] model training instances: 99859.3
-  [err] model training instances: 230.91703657
-  [avg] tree size (nodes): 184.3
-  [err] tree size (nodes): 4.37289632
-  [avg] tree size (leaves): 115.9
-  [err] tree size (leaves): 2.3781412
-  [avg] active learning leaves: 115.9
-  [err] active learning leaves: 2.3781412
-  [avg] tree depth: 5.1
-  [err] tree depth: 0.31622777
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-
-
diff --git a/moa/src/test/resources/moa/classifiers/meta/OzaBoostClassification.ref b/moa/src/test/resources/moa/classifiers/meta/OzaBoostClassification.ref
deleted file mode 100644
index b33a026e5..000000000
--- a/moa/src/test/resources/moa/classifiers/meta/OzaBoostClassification.ref
+++ /dev/null
@@ -1,315 +0,0 @@
---> classification-out0.arff
-moa.classifiers.meta.OzaBoostClassification
-
-Index
-  10000
-Votes
-  0: 3.77662479
-  1: 2.07318379
-Measurements
-  classified instances: 9999
-  classifications correct (percent): 80.3080308
-  Kappa Statistic (percent): 58.90048662
-  Kappa Temporal Statistic (percent): 58.49494098
-  Kappa M Statistic (percent): 51.91697192
-Model measurements
-  model training instances: 9999
-  ensemble size: 10
-  [avg] model training instances: 9824.6
-  [err] model training instances: 351.24040517
-  [avg] tree size (nodes): 13.9
-  [err] tree size (nodes): 13.27863782
-  [avg] tree size (leaves): 11.2
-  [err] tree size (leaves): 10.26103742
-  [avg] active learning leaves: 11.2
-  [err] active learning leaves: 10.26103742
-  [avg] tree depth: 1.7
-  [err] tree depth: 0.67494856
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  20000
-Votes
-  0: 3.01678724
-  1: 3.66988516
-Measurements
-  classified instances: 19999
-  classifications correct (percent): 83.75918796
-  Kappa Statistic (percent): 66.3517898
-  Kappa Temporal Statistic (percent): 66.092494
-  Kappa M Statistic (percent): 61.06449293
-Model measurements
-  model training instances: 19999
-  ensemble size: 10
-  [avg] model training instances: 19564.5
-  [err] model training instances: 494.78553154
-  [avg] tree size (nodes): 35.7
-  [err] tree size (nodes): 10.92448829
-  [avg] tree size (leaves): 26.9
-  [err] tree size (leaves): 7.78103107
-  [avg] active learning leaves: 26.9
-  [err] active learning leaves: 7.78103107
-  [avg] tree depth: 2.7
-  [err] tree depth: 0.48304589
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  30000
-Votes
-  0: 0.41793115
-  1: 7.13032724
-Measurements
-  classified instances: 29999
-  classifications correct (percent): 85.78952632
-  Kappa Statistic (percent): 70.53763056
-  Kappa Temporal Statistic (percent): 70.55329143
-  Kappa M Statistic (percent): 65.8632287
-Model measurements
-  model training instances: 29999
-  ensemble size: 10
-  [avg] model training instances: 28852.9
-  [err] model training instances: 698.80715032
-  [avg] tree size (nodes): 50.1
-  [err] tree size (nodes): 17.38102414
-  [avg] tree size (leaves): 37.7
-  [err] tree size (leaves): 12.60555433
-  [avg] active learning leaves: 37.7
-  [err] active learning leaves: 12.60555433
-  [avg] tree depth: 3.1
-  [err] tree depth: 0.73786479
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  40000
-Votes
-  0: 1.76252297
-  1: 6.20209883
-Measurements
-  classified instances: 39999
-  classifications correct (percent): 86.83967099
-  Kappa Statistic (percent): 72.77218507
-  Kappa Temporal Statistic (percent): 72.79727146
-  Kappa M Statistic (percent): 68.51674641
-Model measurements
-  model training instances: 39999
-  ensemble size: 10
-  [avg] model training instances: 38824.7
-  [err] model training instances: 979.42727596
-  [avg] tree size (nodes): 59.9
-  [err] tree size (nodes): 22.30819481
-  [avg] tree size (leaves): 43.8
-  [err] tree size (leaves): 15.03181811
-  [avg] active learning leaves: 43.8
-  [err] active learning leaves: 15.03181811
-  [avg] tree depth: 3.7
-  [err] tree depth: 0.67494856
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  50000
-Votes
-  0: 6.10164541
-  1: 2.17604177
-Measurements
-  classified instances: 49999
-  classifications correct (percent): 87.749755
-  Kappa Statistic (percent): 74.68188173
-  Kappa Temporal Statistic (percent): 74.64607997
-  Kappa M Statistic (percent): 70.68816998
-Model measurements
-  model training instances: 49999
-  ensemble size: 10
-  [avg] model training instances: 48554.6
-  [err] model training instances: 1233.43956299
-  [avg] tree size (nodes): 74.8
-  [err] tree size (nodes): 25.92639153
-  [avg] tree size (leaves): 53.8
-  [err] tree size (leaves): 16.53817134
-  [avg] active learning leaves: 53.8
-  [err] active learning leaves: 16.53817134
-  [avg] tree depth: 4.1
-  [err] tree depth: 0.87559504
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  60000
-Votes
-  0: 1.60964748
-  1: 6.93408322
-Measurements
-  classified instances: 59999
-  classifications correct (percent): 88.48980816
-  Kappa Statistic (percent): 76.26663404
-  Kappa Temporal Statistic (percent): 76.19851801
-  Kappa M Statistic (percent): 72.5974129
-Model measurements
-  model training instances: 59999
-  ensemble size: 10
-  [avg] model training instances: 58211.7
-  [err] model training instances: 1435.91604908
-  [avg] tree size (nodes): 90
-  [err] tree size (nodes): 27.48332828
-  [avg] tree size (leaves): 64.4
-  [err] tree size (leaves): 17.44324129
-  [avg] active learning leaves: 64.4
-  [err] active learning leaves: 17.44324129
-  [avg] tree depth: 4.3
-  [err] tree depth: 0.67494856
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  70000
-Votes
-  0: 2.0755613
-  1: 6.67603301
-Measurements
-  classified instances: 69999
-  classifications correct (percent): 88.98269975
-  Kappa Statistic (percent): 77.31723558
-  Kappa Temporal Statistic (percent): 77.29026179
-  Kappa M Statistic (percent): 73.86117137
-Model measurements
-  model training instances: 69999
-  ensemble size: 10
-  [avg] model training instances: 67846.9
-  [err] model training instances: 1628.55010157
-  [avg] tree size (nodes): 107
-  [err] tree size (nodes): 33.12937602
-  [avg] tree size (leaves): 76.2
-  [err] tree size (leaves): 20.73536967
-  [avg] active learning leaves: 76.2
-  [err] active learning leaves: 20.73536967
-  [avg] tree depth: 4.6
-  [err] tree depth: 0.6992059
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  80000
-Votes
-  0: 2.87136077
-  1: 6.09272103
-Measurements
-  classified instances: 79999
-  classifications correct (percent): 89.49236865
-  Kappa Statistic (percent): 78.37220305
-  Kappa Temporal Statistic (percent): 78.36237741
-  Kappa M Statistic (percent): 75.06821687
-Model measurements
-  model training instances: 79999
-  ensemble size: 10
-  [avg] model training instances: 77355.6
-  [err] model training instances: 1843.25196927
-  [avg] tree size (nodes): 118.6
-  [err] tree size (nodes): 38.1639737
-  [avg] tree size (leaves): 84.1
-  [err] tree size (leaves): 23.7273869
-  [avg] active learning leaves: 84.1
-  [err] active learning leaves: 23.7273869
-  [avg] tree depth: 4.7
-  [err] tree depth: 0.67494856
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  90000
-Votes
-  0: 0.08537322
-  1: 9.0724379
-Measurements
-  classified instances: 89999
-  classifications correct (percent): 89.88544317
-  Kappa Statistic (percent): 79.18698401
-  Kappa Temporal Statistic (percent): 79.16218382
-  Kappa M Statistic (percent): 75.99419831
-Model measurements
-  model training instances: 89999
-  ensemble size: 10
-  [avg] model training instances: 86627.9
-  [err] model training instances: 2100.80642982
-  [avg] tree size (nodes): 136.4
-  [err] tree size (nodes): 35.44071732
-  [avg] tree size (leaves): 96.3
-  [err] tree size (leaves): 19.731813
-  [avg] active learning leaves: 96.3
-  [err] active learning leaves: 19.731813
-  [avg] tree depth: 5.1
-  [err] tree depth: 0.56764621
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-Index
-  100000
-Votes
-  0: 7.8497285
-  1: 1.51403311
-Measurements
-  classified instances: 99999
-  classifications correct (percent): 90.25590256
-  Kappa Statistic (percent): 79.96231623
-  Kappa Temporal Statistic (percent): 79.92748846
-  Kappa M Statistic (percent): 76.90009957
-Model measurements
-  model training instances: 99999
-  ensemble size: 10
-  [avg] model training instances: 95899.9
-  [err] model training instances: 2382.10002822
-  [avg] tree size (nodes): 159.1
-  [err] tree size (nodes): 32.29189785
-  [avg] tree size (leaves): 112.6
-  [err] tree size (leaves): 16.93910663
-  [avg] active learning leaves: 112.6
-  [err] active learning leaves: 16.93910663
-  [avg] tree depth: 5.2
-  [err] tree depth: 0.63245553
-  [avg] active leaf byte size estimate: 0
-  [err] active leaf byte size estimate: 0
-  [avg] inactive leaf byte size estimate: 0
-  [err] inactive leaf byte size estimate: 0
-  [avg] byte size estimate overhead: 1
-  [err] byte size estimate overhead: 0
-
-
-
diff --git a/moa/src/test/resources/moa/classifiers/rules/AMRulesRegressor.ref b/moa/src/test/resources/moa/classifiers/rules/AMRulesRegressor.ref
deleted file mode 100644
index 67d053cd4..000000000
--- a/moa/src/test/resources/moa/classifiers/rules/AMRulesRegressor.ref
+++ /dev/null
@@ -1,185 +0,0 @@
---> regression-out0.arff
-moa.classifiers.rules.AMRulesRegressor -L (rules.multilabel.functions.AdaptiveMultiTargetRegressor -l MultiTargetMeanRegressor -m MultiTargetPerceptronRegressor -e MeanAbsoluteDeviationMT) -A (OddsRatioScore -p CantellisInequality) -S MultiTargetVarianceRatio -e RelativeMeanAbsoluteDeviationMT -w InverseErrorWeightedVoteMultiLabel -O SelectAllOutputs -I SelectAllInputs -F NoFeatureRanking
-
-Index
-  100
-Votes
-  0: 55948.38383838
-Measurements
-  classified instances: 99
-  mean absolute error: 34794.95416064
-  root mean squared error: 65129.5747211
-  relative mean absolute error: 1.00023248
-  relative root mean squared error: 1.00188841
-Model measurements
-  model training instances: 99
-  anomaly detections: 0
-  change detections: 0
-  rules (number): 1
-  Avg #inputs/rule: 8
-  Avg #outputs/rule: 1
-
-Index
-  200
-Votes
-  0: 39692.60681793
-Measurements
-  classified instances: 199
-  mean absolute error: 31087.52678275
-  root mean squared error: 51752.33673783
-  relative mean absolute error: 0.97415822
-  relative root mean squared error: 0.99544337
-Model measurements
-  model training instances: 199
-  anomaly detections: 0
-  change detections: 0
-  rules (number): 1
-  Avg #inputs/rule: 8
-  Avg #outputs/rule: 1
-
-Index
-  300
-Votes
-  0: 42720.37926708
-Measurements
-  classified instances: 299
-  mean absolute error: 29733.47445214
-  root mean squared error: 49145.69117053
-  relative mean absolute error: 0.96732943
-  relative root mean squared error: 0.97689175
-Model measurements
-  model training instances: 299
-  anomaly detections: 0
-  change detections: 0
-  rules (number): 1
-  Avg #inputs/rule: 8
-  Avg #outputs/rule: 1
-
-Index
-  400
-Votes
-  0: -3346.50006093
-Measurements
-  classified instances: 399
-  mean absolute error: 30878.74607908
-  root mean squared error: 51358.13737722
-  relative mean absolute error: 0.94994309
-  relative root mean squared error: 0.95782043
-Model measurements
-  model training instances: 399
-  anomaly detections: 0
-  change detections: 0
-  rules (number): 1
-  Avg #inputs/rule: 8
-  Avg #outputs/rule: 1
-
-Index
-  500
-Votes
-  0: 51068.01539989
-Measurements
-  classified instances: 499
-  mean absolute error: 29199.8139149
-  root mean squared error: 48465.35768983
-  relative mean absolute error: 0.91641167
-  relative root mean squared error: 0.94415448
-Model measurements
-  model training instances: 499
-  anomaly detections: 0
-  change detections: 0
-  rules (number): 1
-  Avg #inputs/rule: 8
-  Avg #outputs/rule: 1
-
-Index
-  600
-Votes
-  0: 38259.18584555
-Measurements
-  classified instances: 599
-  mean absolute error: 28373.04435178
-  root mean squared error: 49053.18023401
-  relative mean absolute error: 0.89375218
-  relative root mean squared error: 0.93560276
-Model measurements
-  model training instances: 599
-  anomaly detections: 0
-  change detections: 0
-  rules (number): 1
-  Avg #inputs/rule: 8
-  Avg #outputs/rule: 1
-
-Index
-  700
-Votes
-  0: 28282.97659308
-Measurements
-  classified instances: 699
-  mean absolute error: 27271.85831087
-  root mean squared error: 46681.82880826
-  relative mean absolute error: 0.86717656
-  relative root mean squared error: 0.91890589
-Model measurements
-  model training instances: 699
-  anomaly detections: 0
-  change detections: 0
-  rules (number): 1
-  Avg #inputs/rule: 8
-  Avg #outputs/rule: 1
-
-Index
-  800
-Votes
-  0: 55951.84345479
-Measurements
-  classified instances: 799
-  mean absolute error: 27746.90658614
-  root mean squared error: 48571.53587788
-  relative mean absolute error: 0.88041499
-  relative root mean squared error: 0.9651345
-Model measurements
-  model training instances: 799
-  anomaly detections: 0
-  change detections: 0
-  rules (number): 1
-  Avg #inputs/rule: 8
-  Avg #outputs/rule: 1
-
-Index
-  900
-Votes
-  0: -1779.42143224
-Measurements
-  classified instances: 899
-  mean absolute error: 27088.7725763
-  root mean squared error: 46810.81877853
-  relative mean absolute error: 0.87444528
-  relative root mean squared error: 0.95901644
-Model measurements
-  model training instances: 899
-  anomaly detections: 0
-  change detections: 0
-  rules (number): 1
-  Avg #inputs/rule: 8
-  Avg #outputs/rule: 1
-
-Index
-  1000
-Votes
-  0: 13432.44591002
-Measurements
-  classified instances: 999
-  mean absolute error: 27231.92632342
-  root mean squared error: 46872.8677322
-  relative mean absolute error: 0.8767323
-  relative root mean squared error: 0.96542486
-Model measurements
-  model training instances: 999
-  anomaly detections: 0
-  change detections: 0
-  rules (number): 1
-  Avg #inputs/rule: 8
-  Avg #outputs/rule: 1
-
-
-
diff --git a/moa/src/test/resources/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressorSemiSuper.ref b/moa/src/test/resources/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressorSemiSuper.ref
deleted file mode 100644
index 94d600f62..000000000
--- a/moa/src/test/resources/moa/classifiers/rules/multilabel/AMRulesMultiTargetRegressorSemiSuper.ref
+++ /dev/null
@@ -1,185 +0,0 @@
---> regression-out0.arff
-moa.classifiers.rules.multilabel.AMRulesMultiTargetRegressorSemiSuper -L (rules.multilabel.functions.AdaptiveMultiTargetRegressor -l MultiTargetMeanRegressor -m MultiTargetPerceptronRegressor -e MeanAbsoluteDeviationMT) -A (OddsRatioScore -p CantellisInequality) -S MultiTargetVarianceRatio -e RelativeMeanAbsoluteDeviationMT -w InverseErrorWeightedVoteMultiLabel -O SelectAllOutputs -I SelectAllInputs -F NoFeatureRanking
-
-Index
-  100
-Votes
-  0: 55948.38383838
-Measurements
-  classified instances: 99
-  mean absolute error: 34794.95416064
-  root mean squared error: 65129.5747211
-  relative mean absolute error: 1.00023248
-  relative root mean squared error: 1.00188841
-Model measurements
-  model training instances: 99
-  anomaly detections: 0
-  change detections: 0
-  rules (number): 1
-  Avg #inputs/rule: 8
-  Avg #outputs/rule: 1
-
-Index
-  200
-Votes
-  0: 39692.60681793
-Measurements
-  classified instances: 199
-  mean absolute error: 31087.52678275
-  root mean squared error: 51752.33673783
-  relative mean absolute error: 0.97415822
-  relative root mean squared error: 0.99544337
-Model measurements
-  model training instances: 199
-  anomaly detections: 0
-  change detections: 0
-  rules (number): 1
-  Avg #inputs/rule: 8
-  Avg #outputs/rule: 1
-
-Index
-  300
-Votes
-  0: 42720.37926708
-Measurements
-  classified instances: 299
-  mean absolute error: 29733.47445214
-  root mean squared error: 49145.69117053
-  relative mean absolute error: 0.96732943
-  relative root mean squared error: 0.97689175
-Model measurements
-  model training instances: 299
-  anomaly detections: 0
-  change detections: 0
-  rules (number): 1
-  Avg #inputs/rule: 8
-  Avg #outputs/rule: 1
-
-Index
-  400
-Votes
-  0: -3346.50006093
-Measurements
-  classified instances: 399
-  mean absolute error: 30878.74607908
-  root mean squared error: 51358.13737722
-  relative mean absolute error: 0.94994309
-  relative root mean squared error: 0.95782043
-Model measurements
-  model training instances: 399
-  anomaly detections: 0
-  change detections: 0
-  rules (number): 1
-  Avg #inputs/rule: 8
-  Avg #outputs/rule: 1
-
-Index
-  500
-Votes
-  0: 51068.01539989
-Measurements
-  classified instances: 499
-  mean absolute error: 29199.8139149
-  root mean squared error: 48465.35768983
-  relative mean absolute error: 0.91641167
-  relative root mean squared error: 0.94415448
-Model measurements
-  model training instances: 499
-  anomaly detections: 0
-  change detections: 0
-  rules (number): 1
-  Avg #inputs/rule: 8
-  Avg #outputs/rule: 1
-
-Index
-  600
-Votes
-  0: 38259.18584555
-Measurements
-  classified instances: 599
-  mean absolute error: 28373.04435178
-  root mean squared error: 49053.18023401
-  relative mean absolute error: 0.89375218
-  relative root mean squared error: 0.93560276
-Model measurements
-  model training instances: 599
-  anomaly detections: 0
-  change detections: 0
-  rules (number): 1
-  Avg #inputs/rule: 8
-  Avg #outputs/rule: 1
-
-Index
-  700
-Votes
-  0: 28282.97659308
-Measurements
-  classified instances: 699
-  mean absolute error: 27271.85831087
-  root mean squared error: 46681.82880826
-  relative mean absolute error: 0.86717656
-  relative root mean squared error: 0.91890589
-Model measurements
-  model training instances: 699
-  anomaly detections: 0
-  change detections: 0
-  rules (number): 1
-  Avg #inputs/rule: 8
-  Avg #outputs/rule: 1
-
-Index
-  800
-Votes
-  0: 55951.84345479
-Measurements
-  classified instances: 799
-  mean absolute error: 27746.90658614
-  root mean squared error: 48571.53587788
-  relative mean absolute error: 0.88041499
-  relative root mean squared error: 0.9651345
-Model measurements
-  model training instances: 799
-  anomaly detections: 0
-  change detections: 0
-  rules (number): 1
-  Avg #inputs/rule: 8
-  Avg #outputs/rule: 1
-
-Index
-  900
-Votes
-  0: -1779.42143224
-Measurements
-  classified instances: 899
-  mean absolute error: 27088.7725763
-  root mean squared error: 46810.81877853
-  relative mean absolute error: 0.87444528
-  relative root mean squared error: 0.95901644
-Model measurements
-  model training instances: 899
-  anomaly detections: 0
-  change detections: 0
-  rules (number): 1
-  Avg #inputs/rule: 8
-  Avg #outputs/rule: 1
-
-Index
-  1000
-Votes
-  0: 13432.44591002
-Measurements
-  classified instances: 999
-  mean absolute error: 27231.92632342
-  root mean squared error: 46872.8677322
-  relative mean absolute error: 0.8767323
-  relative root mean squared error: 0.96542486
-Model measurements
-  model training instances: 999
-  anomaly detections: 0
-  change detections: 0
-  rules (number): 1
-  Avg #inputs/rule: 8
-  Avg #outputs/rule: 1
-
-
-
diff --git a/moa/src/test/resources/moa/classifiers/active/ALRandom.ref b/moa/src/test/resources/moa/learners/predictors/active/ALRandom.ref
similarity index 97%
rename from moa/src/test/resources/moa/classifiers/active/ALRandom.ref
rename to moa/src/test/resources/moa/learners/predictors/active/ALRandom.ref
index a72088699..289c11b24 100644
--- a/moa/src/test/resources/moa/classifiers/active/ALRandom.ref
+++ b/moa/src/test/resources/moa/learners/predictors/active/ALRandom.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.active.ALRandom -l (moa.classifiers.drift.SingleClassifierDrift -d DDM)
+moa.learners.predictors.active.ALRandom
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/active/ALUncertainty.ref b/moa/src/test/resources/moa/learners/predictors/active/ALUncertainty.ref
similarity index 98%
rename from moa/src/test/resources/moa/classifiers/active/ALUncertainty.ref
rename to moa/src/test/resources/moa/learners/predictors/active/ALUncertainty.ref
index 9e7369139..0ec9fb793 100644
--- a/moa/src/test/resources/moa/classifiers/active/ALUncertainty.ref
+++ b/moa/src/test/resources/moa/learners/predictors/active/ALUncertainty.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.active.ALUncertainty
+moa.learners.predictors.active.ALUncertainty
 
 Index
   10000
@@ -224,7 +224,7 @@ Model measurements
 
 
 --> classification-out1.arff
-moa.classifiers.active.ALUncertainty -d VarUncertainty
+moa.learners.predictors.active.ALUncertainty -d VarUncertainty
 
 Index
   10000
@@ -449,7 +449,7 @@ Model measurements
 
 
 --> classification-out2.arff
-moa.classifiers.active.ALUncertainty -d RandVarUncertainty
+moa.learners.predictors.active.ALUncertainty -d RandVarUncertainty
 
 Index
   10000
@@ -674,7 +674,7 @@ Model measurements
 
 
 --> classification-out3.arff
-moa.classifiers.active.ALUncertainty -d SelSampling
+moa.learners.predictors.active.ALUncertainty -d SelSampling
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/bayes/NaiveBayes.ref b/moa/src/test/resources/moa/learners/predictors/bayes/NaiveBayes.ref
similarity index 98%
rename from moa/src/test/resources/moa/classifiers/bayes/NaiveBayes.ref
rename to moa/src/test/resources/moa/learners/predictors/bayes/NaiveBayes.ref
index acfd3fda9..080a399e0 100644
--- a/moa/src/test/resources/moa/classifiers/bayes/NaiveBayes.ref
+++ b/moa/src/test/resources/moa/learners/predictors/bayes/NaiveBayes.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.bayes.NaiveBayes
+moa.learners.predictors.bayes.NaiveBayes
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/bayes/NaiveBayesMultinomial.ref b/moa/src/test/resources/moa/learners/predictors/bayes/NaiveBayesMultinomial.ref
similarity index 98%
rename from moa/src/test/resources/moa/classifiers/bayes/NaiveBayesMultinomial.ref
rename to moa/src/test/resources/moa/learners/predictors/bayes/NaiveBayesMultinomial.ref
index 9d3979334..5b5cc3ccf 100644
--- a/moa/src/test/resources/moa/classifiers/bayes/NaiveBayesMultinomial.ref
+++ b/moa/src/test/resources/moa/learners/predictors/bayes/NaiveBayesMultinomial.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.bayes.NaiveBayesMultinomial
+moa.learners.predictors.bayes.NaiveBayesMultinomial
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/data/classification.arff b/moa/src/test/resources/moa/learners/predictors/data/classification.arff
similarity index 100%
rename from moa/src/test/resources/moa/classifiers/data/classification.arff
rename to moa/src/test/resources/moa/learners/predictors/data/classification.arff
diff --git a/moa/src/test/resources/moa/classifiers/data/regression.arff b/moa/src/test/resources/moa/learners/predictors/data/regression.arff
similarity index 100%
rename from moa/src/test/resources/moa/classifiers/data/regression.arff
rename to moa/src/test/resources/moa/learners/predictors/data/regression.arff
diff --git a/moa/src/test/resources/moa/classifiers/data/small_classification.arff b/moa/src/test/resources/moa/learners/predictors/data/small_classification.arff
similarity index 100%
rename from moa/src/test/resources/moa/classifiers/data/small_classification.arff
rename to moa/src/test/resources/moa/learners/predictors/data/small_classification.arff
diff --git a/moa/src/test/resources/moa/classifiers/data/small_regression.arff b/moa/src/test/resources/moa/learners/predictors/data/small_regression.arff
similarity index 100%
rename from moa/src/test/resources/moa/classifiers/data/small_regression.arff
rename to moa/src/test/resources/moa/learners/predictors/data/small_regression.arff
diff --git a/moa/src/test/resources/moa/classifiers/drift/DriftDetectionMethodClassifier.ref b/moa/src/test/resources/moa/learners/predictors/drift/DriftDetectionMethodClassifier.ref
similarity index 98%
rename from moa/src/test/resources/moa/classifiers/drift/DriftDetectionMethodClassifier.ref
rename to moa/src/test/resources/moa/learners/predictors/drift/DriftDetectionMethodClassifier.ref
index 0d94bdf6f..aeae07a94 100644
--- a/moa/src/test/resources/moa/classifiers/drift/DriftDetectionMethodClassifier.ref
+++ b/moa/src/test/resources/moa/learners/predictors/drift/DriftDetectionMethodClassifier.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.drift.DriftDetectionMethodClassifier
+moa.learners.predictors.drift.DriftDetectionMethodClassifier
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/functions/MajorityClass.ref b/moa/src/test/resources/moa/learners/predictors/functions/MajorityClass.ref
similarity index 98%
rename from moa/src/test/resources/moa/classifiers/functions/MajorityClass.ref
rename to moa/src/test/resources/moa/learners/predictors/functions/MajorityClass.ref
index 57aa245fe..17eb46c36 100644
--- a/moa/src/test/resources/moa/classifiers/functions/MajorityClass.ref
+++ b/moa/src/test/resources/moa/learners/predictors/functions/MajorityClass.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.functions.MajorityClass
+moa.learners.predictors.functions.MajorityClass
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/functions/NoChange.ref b/moa/src/test/resources/moa/learners/predictors/functions/NoChange.ref
similarity index 98%
rename from moa/src/test/resources/moa/classifiers/functions/NoChange.ref
rename to moa/src/test/resources/moa/learners/predictors/functions/NoChange.ref
index e974a72ae..bdb9fb00b 100644
--- a/moa/src/test/resources/moa/classifiers/functions/NoChange.ref
+++ b/moa/src/test/resources/moa/learners/predictors/functions/NoChange.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.functions.NoChange
+moa.learners.predictors.functions.NoChange
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/learners/predictors/functions/Perceptron.ref b/moa/src/test/resources/moa/learners/predictors/functions/Perceptron.ref
new file mode 100644
index 000000000..2d0930e39
--- /dev/null
+++ b/moa/src/test/resources/moa/learners/predictors/functions/Perceptron.ref
@@ -0,0 +1,145 @@
+--> classification-out0.arff
+moa.learners.predictors.functions.Perceptron
+
+Index
+  10000
+Votes
+  0: 0.95727957
+  1: 0.04272043
+Measurements
+  classified instances: 9999
+  classifications correct (percent): 60.4960496
+  Kappa Statistic (percent): 13.08330511
+  Kappa Temporal Statistic (percent): 16.73693086
+  Kappa M Statistic (percent): 3.54090354
+Model measurements
+  model training instances: 9999
+
+Index
+  20000
+Votes
+  0: 0.99999997
+  1: 0.00000003
+Measurements
+  classified instances: 19999
+  classifications correct (percent): 60.80304015
+  Kappa Statistic (percent): 17.04844553
+  Kappa Temporal Statistic (percent): 18.16473536
+  Kappa M Statistic (percent): 6.02972908
+Model measurements
+  model training instances: 19999
+
+Index
+  30000
+Votes
+  0: 0
+  1: 1
+Measurements
+  classified instances: 29999
+  classifications correct (percent): 61.33537785
+  Kappa Statistic (percent): 17.2735181
+  Kappa Temporal Statistic (percent): 19.87980935
+  Kappa M Statistic (percent): 7.11883408
+Model measurements
+  model training instances: 29999
+
+Index
+  40000
+Votes
+  0: 0.4986752
+  1: 0.5013248
+Measurements
+  classified instances: 39999
+  classifications correct (percent): 61.60654016
+  Kappa Statistic (percent): 17.41810117
+  Kappa Temporal Statistic (percent): 20.63976022
+  Kappa M Statistic (percent): 8.15191388
+Model measurements
+  model training instances: 39999
+
+Index
+  50000
+Votes
+  0: 0
+  1: 1
+Measurements
+  classified instances: 49999
+  classifications correct (percent): 61.77323546
+  Kappa Statistic (percent): 17.4765336
+  Kappa Temporal Statistic (percent): 20.88335127
+  Kappa M Statistic (percent): 8.53273354
+Model measurements
+  model training instances: 49999
+
+Index
+  60000
+Votes
+  0: 0
+  1: 1
+Measurements
+  classified instances: 59999
+  classifications correct (percent): 61.84103068
+  Kappa Statistic (percent): 17.54584799
+  Kappa Temporal Statistic (percent): 21.09253834
+  Kappa M Statistic (percent): 9.15403539
+Model measurements
+  model training instances: 59999
+
+Index
+  70000
+Votes
+  0: 1
+  1: 0
+Measurements
+  classified instances: 69999
+  classifications correct (percent): 62.05945799
+  Kappa Statistic (percent): 17.93943012
+  Kappa Temporal Statistic (percent): 21.79392797
+  Kappa M Statistic (percent): 9.98508677
+Model measurements
+  model training instances: 69999
+
+Index
+  80000
+Votes
+  0: 0.99236767
+  1: 0.00763233
+Measurements
+  classified instances: 79999
+  classifications correct (percent): 62.33202915
+  Kappa Statistic (percent): 18.27317161
+  Kappa Temporal Statistic (percent): 22.43300986
+  Kappa M Statistic (percent): 10.62403607
+Model measurements
+  model training instances: 79999
+
+Index
+  90000
+Votes
+  0: 0
+  1: 1
+Measurements
+  classified instances: 89999
+  classifications correct (percent): 62.49624996
+  Kappa Statistic (percent): 18.42483773
+  Kappa Temporal Statistic (percent): 22.73549273
+  Kappa M Statistic (percent): 10.98892405
+Model measurements
+  model training instances: 89999
+
+Index
+  100000
+Votes
+  0: 0.00007837
+  1: 0.99992163
+Measurements
+  classified instances: 99999
+  classifications correct (percent): 62.599626
+  Kappa Statistic (percent): 18.58736517
+  Kappa Temporal Statistic (percent): 22.95649308
+  Kappa M Statistic (percent): 11.33658907
+Model measurements
+  model training instances: 99999
+
+
+
diff --git a/moa/src/test/resources/moa/classifiers/functions/SGD.ref b/moa/src/test/resources/moa/learners/predictors/functions/SGD.ref
similarity index 98%
rename from moa/src/test/resources/moa/classifiers/functions/SGD.ref
rename to moa/src/test/resources/moa/learners/predictors/functions/SGD.ref
index 3e93619ae..7a18023f2 100644
--- a/moa/src/test/resources/moa/classifiers/functions/SGD.ref
+++ b/moa/src/test/resources/moa/learners/predictors/functions/SGD.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.functions.SGD
+moa.learners.predictors.functions.SGD
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/functions/SPegasos.ref b/moa/src/test/resources/moa/learners/predictors/functions/SPegasos.ref
similarity index 98%
rename from moa/src/test/resources/moa/classifiers/functions/SPegasos.ref
rename to moa/src/test/resources/moa/learners/predictors/functions/SPegasos.ref
index 97f2f3584..983272029 100644
--- a/moa/src/test/resources/moa/classifiers/functions/SPegasos.ref
+++ b/moa/src/test/resources/moa/learners/predictors/functions/SPegasos.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.functions.SPegasos
+moa.learners.predictors.functions.SPegasos
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/meta/ADOB.ref b/moa/src/test/resources/moa/learners/predictors/meta/ADOB.ref
similarity index 98%
rename from moa/src/test/resources/moa/classifiers/meta/ADOB.ref
rename to moa/src/test/resources/moa/learners/predictors/meta/ADOB.ref
index 860f3a87e..31d002ffb 100644
--- a/moa/src/test/resources/moa/classifiers/meta/ADOB.ref
+++ b/moa/src/test/resources/moa/learners/predictors/meta/ADOB.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.meta.ADOB -l (moa.classifiers.drift.SingleClassifierDrift -l moa.classifiers.trees.HoeffdingTree -d ADWINChangeDetector)
+moa.learners.predictors.meta.ADOB
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/meta/AccuracyUpdatedEnsemble.ref b/moa/src/test/resources/moa/learners/predictors/meta/AccuracyUpdatedEnsemble.ref
similarity index 99%
rename from moa/src/test/resources/moa/classifiers/meta/AccuracyUpdatedEnsemble.ref
rename to moa/src/test/resources/moa/learners/predictors/meta/AccuracyUpdatedEnsemble.ref
index 8bcd39507..7f737bef5 100644
--- a/moa/src/test/resources/moa/classifiers/meta/AccuracyUpdatedEnsemble.ref
+++ b/moa/src/test/resources/moa/learners/predictors/meta/AccuracyUpdatedEnsemble.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.meta.AccuracyUpdatedEnsemble
+moa.learners.predictors.meta.AccuracyUpdatedEnsemble
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/meta/AccuracyWeightedEnsemble.ref b/moa/src/test/resources/moa/learners/predictors/meta/AccuracyWeightedEnsemble.ref
similarity index 99%
rename from moa/src/test/resources/moa/classifiers/meta/AccuracyWeightedEnsemble.ref
rename to moa/src/test/resources/moa/learners/predictors/meta/AccuracyWeightedEnsemble.ref
index fa777cc07..5ea2bb1ec 100644
--- a/moa/src/test/resources/moa/classifiers/meta/AccuracyWeightedEnsemble.ref
+++ b/moa/src/test/resources/moa/learners/predictors/meta/AccuracyWeightedEnsemble.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.meta.AccuracyWeightedEnsemble -l (moa.classifiers.trees.HoeffdingTree -e 1000 -g 100 -c 0.01 -l NB)
+moa.learners.predictors.meta.AccuracyWeightedEnsemble -l (trees.HoeffdingTree -e 1000 -g 100 -c 0.01 -l NB)
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/meta/AdaptiveRandomForest.ref b/moa/src/test/resources/moa/learners/predictors/meta/AdaptiveRandomForest.ref
similarity index 97%
rename from moa/src/test/resources/moa/classifiers/meta/AdaptiveRandomForest.ref
rename to moa/src/test/resources/moa/learners/predictors/meta/AdaptiveRandomForest.ref
index 55d1ee46e..6163cc995 100644
--- a/moa/src/test/resources/moa/classifiers/meta/AdaptiveRandomForest.ref
+++ b/moa/src/test/resources/moa/learners/predictors/meta/AdaptiveRandomForest.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.meta.AdaptiveRandomForest -l (ARFHoeffdingTree -k 4 -e 2000000 -g 50 -c 0.01)
+moa.learners.predictors.meta.AdaptiveRandomForest -l (ARFHoeffdingTree -k 4 -e 2000000 -g 50 -c 0.01)
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/meta/BOLE.ref b/moa/src/test/resources/moa/learners/predictors/meta/BOLE.ref
similarity index 99%
rename from moa/src/test/resources/moa/classifiers/meta/BOLE.ref
rename to moa/src/test/resources/moa/learners/predictors/meta/BOLE.ref
index 7def7ad3e..bd0200b3c 100644
--- a/moa/src/test/resources/moa/classifiers/meta/BOLE.ref
+++ b/moa/src/test/resources/moa/learners/predictors/meta/BOLE.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.meta.BOLE
+moa.learners.predictors.meta.BOLE
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/meta/DynamicWeightedMajority.ref b/moa/src/test/resources/moa/learners/predictors/meta/DynamicWeightedMajority.ref
similarity index 98%
rename from moa/src/test/resources/moa/classifiers/meta/DynamicWeightedMajority.ref
rename to moa/src/test/resources/moa/learners/predictors/meta/DynamicWeightedMajority.ref
index 2041b5bb7..a98926cf8 100644
--- a/moa/src/test/resources/moa/classifiers/meta/DynamicWeightedMajority.ref
+++ b/moa/src/test/resources/moa/learners/predictors/meta/DynamicWeightedMajority.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.meta.DynamicWeightedMajority
+moa.learners.predictors.meta.DynamicWeightedMajority
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/meta/HeterogeneousEnsembleBlast.ref b/moa/src/test/resources/moa/learners/predictors/meta/HeterogeneousEnsembleBlast.ref
similarity index 98%
rename from moa/src/test/resources/moa/classifiers/meta/HeterogeneousEnsembleBlast.ref
rename to moa/src/test/resources/moa/learners/predictors/meta/HeterogeneousEnsembleBlast.ref
index ad875b6b2..e24469b3a 100644
--- a/moa/src/test/resources/moa/classifiers/meta/HeterogeneousEnsembleBlast.ref
+++ b/moa/src/test/resources/moa/learners/predictors/meta/HeterogeneousEnsembleBlast.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.meta.HeterogeneousEnsembleBlast
+moa.learners.predictors.meta.HeterogeneousEnsembleBlast
 
 Index
   10000
@@ -144,7 +144,7 @@ Model measurements
 
 
 --> classification-out1.arff
-moa.classifiers.meta.HeterogeneousEnsembleBlastFadingFactors
+moa.learners.predictors.meta.HeterogeneousEnsembleBlastFadingFactors
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/meta/LeveragingBag.ref b/moa/src/test/resources/moa/learners/predictors/meta/LeveragingBag.ref
similarity index 99%
rename from moa/src/test/resources/moa/classifiers/meta/LeveragingBag.ref
rename to moa/src/test/resources/moa/learners/predictors/meta/LeveragingBag.ref
index 45a55ac65..1e2aab4c9 100644
--- a/moa/src/test/resources/moa/classifiers/meta/LeveragingBag.ref
+++ b/moa/src/test/resources/moa/learners/predictors/meta/LeveragingBag.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.meta.LeveragingBag
+moa.learners.predictors.meta.LeveragingBag
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/meta/LimAttClassifier.ref b/moa/src/test/resources/moa/learners/predictors/meta/LimAttClassifier.ref
similarity index 99%
rename from moa/src/test/resources/moa/classifiers/meta/LimAttClassifier.ref
rename to moa/src/test/resources/moa/learners/predictors/meta/LimAttClassifier.ref
index b6ef1d378..542a92b05 100644
--- a/moa/src/test/resources/moa/classifiers/meta/LimAttClassifier.ref
+++ b/moa/src/test/resources/moa/learners/predictors/meta/LimAttClassifier.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.meta.LimAttClassifier
+moa.learners.predictors.meta.LimAttClassifier
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/meta/OCBoost.ref b/moa/src/test/resources/moa/learners/predictors/meta/OCBoost.ref
similarity index 84%
rename from moa/src/test/resources/moa/classifiers/meta/OCBoost.ref
rename to moa/src/test/resources/moa/learners/predictors/meta/OCBoost.ref
index 1b0906491..c45c75885 100644
--- a/moa/src/test/resources/moa/classifiers/meta/OCBoost.ref
+++ b/moa/src/test/resources/moa/learners/predictors/meta/OCBoost.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.meta.OCBoost
+moa.learners.predictors.meta.OCBoost
 
 Index
   10000
@@ -110,12 +110,12 @@ Model measurements
   ensemble size: 10
   [avg] model training instances: 28753.21243854
   [err] model training instances: 545.74298905
-  [avg] tree size (nodes): 53
-  [err] tree size (nodes): 9.01849951
-  [avg] tree size (leaves): 38.1
-  [err] tree size (leaves): 6.48845128
-  [avg] active learning leaves: 38.1
-  [err] active learning leaves: 6.48845128
+  [avg] tree size (nodes): 52.7
+  [err] tree size (nodes): 9.10494371
+  [avg] tree size (leaves): 37.8
+  [err] tree size (leaves): 6.61311828
+  [avg] active learning leaves: 37.8
+  [err] active learning leaves: 6.61311828
   [avg] tree depth: 3.8
   [err] tree depth: 0.42163702
   [avg] active leaf byte size estimate: 0
@@ -141,12 +141,12 @@ Model measurements
   ensemble size: 10
   [avg] model training instances: 34777.80523119
   [err] model training instances: 767.64429107
-  [avg] tree size (nodes): 55.6
-  [err] tree size (nodes): 9.16757571
-  [avg] tree size (leaves): 39.4
-  [err] tree size (leaves): 6.58618082
-  [avg] active learning leaves: 39.4
-  [err] active learning leaves: 6.58618082
+  [avg] tree size (nodes): 55.3
+  [err] tree size (nodes): 9.34582497
+  [avg] tree size (leaves): 39.1
+  [err] tree size (leaves): 6.77331365
+  [avg] active learning leaves: 39.1
+  [err] active learning leaves: 6.77331365
   [avg] tree depth: 4
   [err] tree depth: 0
   [avg] active leaf byte size estimate: 0
@@ -172,12 +172,12 @@ Model measurements
   ensemble size: 10
   [avg] model training instances: 40783.21210629
   [err] model training instances: 960.92540852
-  [avg] tree size (nodes): 61.2
-  [err] tree size (nodes): 14.1562707
-  [avg] tree size (leaves): 43.1
-  [err] tree size (leaves): 9.49210198
-  [avg] active learning leaves: 43.1
-  [err] active learning leaves: 9.49210198
+  [avg] tree size (nodes): 60.9
+  [err] tree size (nodes): 14.35618334
+  [avg] tree size (leaves): 42.8
+  [err] tree size (leaves): 9.71596624
+  [avg] active learning leaves: 42.8
+  [err] active learning leaves: 9.71596624
   [avg] tree depth: 4.2
   [err] tree depth: 0.42163702
   [avg] active leaf byte size estimate: 0
@@ -203,12 +203,12 @@ Model measurements
   ensemble size: 10
   [avg] model training instances: 46830.07791904
   [err] model training instances: 1148.73184776
-  [avg] tree size (nodes): 64.8
-  [err] tree size (nodes): 18.04192648
-  [avg] tree size (leaves): 45.2
-  [err] tree size (leaves): 11.86779021
-  [avg] active learning leaves: 45.2
-  [err] active learning leaves: 11.86779021
+  [avg] tree size (nodes): 64.5
+  [err] tree size (nodes): 18.22848808
+  [avg] tree size (leaves): 44.9
+  [err] tree size (leaves): 12.07798732
+  [avg] active learning leaves: 44.9
+  [err] active learning leaves: 12.07798732
   [avg] tree depth: 4.6
   [err] tree depth: 0.51639778
   [avg] active leaf byte size estimate: 0
@@ -234,12 +234,12 @@ Model measurements
   ensemble size: 10
   [avg] model training instances: 52733.24227107
   [err] model training instances: 1321.2056227
-  [avg] tree size (nodes): 75.7
-  [err] tree size (nodes): 14.17391971
-  [avg] tree size (leaves): 53.2
-  [err] tree size (leaves): 8.54790423
-  [avg] active learning leaves: 53.2
-  [err] active learning leaves: 8.54790423
+  [avg] tree size (nodes): 75.4
+  [err] tree size (nodes): 14.31549277
+  [avg] tree size (leaves): 52.9
+  [err] tree size (leaves): 8.68523652
+  [avg] active learning leaves: 52.9
+  [err] active learning leaves: 8.68523652
   [avg] tree depth: 4.7
   [err] tree depth: 0.48304589
   [avg] active leaf byte size estimate: 0
@@ -265,12 +265,12 @@ Model measurements
   ensemble size: 10
   [avg] model training instances: 58560.19117091
   [err] model training instances: 1568.6729505
-  [avg] tree size (nodes): 82.6
-  [err] tree size (nodes): 16.39241017
-  [avg] tree size (leaves): 57.1
-  [err] tree size (leaves): 9.58528966
-  [avg] active learning leaves: 57.1
-  [err] active learning leaves: 9.58528966
+  [avg] tree size (nodes): 82.3
+  [err] tree size (nodes): 16.61358213
+  [avg] tree size (leaves): 56.8
+  [err] tree size (leaves): 9.80702696
+  [avg] active learning leaves: 56.8
+  [err] active learning leaves: 9.80702696
   [avg] tree depth: 5
   [err] tree depth: 0
   [avg] active leaf byte size estimate: 0
@@ -297,11 +297,11 @@ Model measurements
   [avg] model training instances: 64255.7300068
   [err] model training instances: 1859.08409412
   [avg] tree size (nodes): 87.4
-  [err] tree size (nodes): 16.83382838
+  [err] tree size (nodes): 17.06979138
   [avg] tree size (leaves): 59.8
-  [err] tree size (leaves): 10.27186016
+  [err] tree size (leaves): 10.46475566
   [avg] active learning leaves: 59.8
-  [err] active learning leaves: 10.27186016
+  [err] active learning leaves: 10.46475566
   [avg] tree depth: 5.2
   [err] tree depth: 0.42163702
   [avg] active leaf byte size estimate: 0
diff --git a/moa/src/test/resources/moa/classifiers/meta/OnlineAccuracyUpdatedEnsemble.ref b/moa/src/test/resources/moa/learners/predictors/meta/OnlineAccuracyUpdatedEnsemble.ref
similarity index 99%
rename from moa/src/test/resources/moa/classifiers/meta/OnlineAccuracyUpdatedEnsemble.ref
rename to moa/src/test/resources/moa/learners/predictors/meta/OnlineAccuracyUpdatedEnsemble.ref
index 083aaa55b..2d5d729f7 100644
--- a/moa/src/test/resources/moa/classifiers/meta/OnlineAccuracyUpdatedEnsemble.ref
+++ b/moa/src/test/resources/moa/learners/predictors/meta/OnlineAccuracyUpdatedEnsemble.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.meta.OnlineAccuracyUpdatedEnsemble
+moa.learners.predictors.meta.OnlineAccuracyUpdatedEnsemble
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/meta/OzaBagASHT.ref b/moa/src/test/resources/moa/learners/predictors/meta/OzaBagASHT.ref
similarity index 99%
rename from moa/src/test/resources/moa/classifiers/meta/OzaBagASHT.ref
rename to moa/src/test/resources/moa/learners/predictors/meta/OzaBagASHT.ref
index 278042e89..a8f59c19a 100644
--- a/moa/src/test/resources/moa/classifiers/meta/OzaBagASHT.ref
+++ b/moa/src/test/resources/moa/learners/predictors/meta/OzaBagASHT.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.meta.OzaBagASHT -l ASHoeffdingTree
+moa.learners.predictors.meta.OzaBagASHT
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/meta/OzaBoostAdwin.ref b/moa/src/test/resources/moa/learners/predictors/meta/OzaBoostAdwin.ref
similarity index 99%
rename from moa/src/test/resources/moa/classifiers/meta/OzaBoostAdwin.ref
rename to moa/src/test/resources/moa/learners/predictors/meta/OzaBoostAdwin.ref
index 89b317c82..7c0db9fa5 100644
--- a/moa/src/test/resources/moa/classifiers/meta/OzaBoostAdwin.ref
+++ b/moa/src/test/resources/moa/learners/predictors/meta/OzaBoostAdwin.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.meta.OzaBoostAdwin
+moa.learners.predictors.meta.OzaBoostAdwin
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/meta/TemporallyAugmentedClassifier.ref b/moa/src/test/resources/moa/learners/predictors/meta/TemporallyAugmentedClassifier.ref
similarity index 98%
rename from moa/src/test/resources/moa/classifiers/meta/TemporallyAugmentedClassifier.ref
rename to moa/src/test/resources/moa/learners/predictors/meta/TemporallyAugmentedClassifier.ref
index 7beae6416..7873c743e 100644
--- a/moa/src/test/resources/moa/classifiers/meta/TemporallyAugmentedClassifier.ref
+++ b/moa/src/test/resources/moa/learners/predictors/meta/TemporallyAugmentedClassifier.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.meta.TemporallyAugmentedClassifier
+moa.learners.predictors.meta.TemporallyAugmentedClassifier
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/meta/WEKAClassifier.ref b/moa/src/test/resources/moa/learners/predictors/meta/WEKAClassifier.ref
similarity index 98%
rename from moa/src/test/resources/moa/classifiers/meta/WEKAClassifier.ref
rename to moa/src/test/resources/moa/learners/predictors/meta/WEKAClassifier.ref
index 63e23a65f..855b77f8c 100644
--- a/moa/src/test/resources/moa/classifiers/meta/WEKAClassifier.ref
+++ b/moa/src/test/resources/moa/learners/predictors/meta/WEKAClassifier.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.meta.WEKAClassifier
+moa.learners.predictors.meta.WEKAClassifier
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/meta/WeightedMajorityAlgorithm.ref b/moa/src/test/resources/moa/learners/predictors/meta/WeightedMajorityAlgorithm.ref
similarity index 99%
rename from moa/src/test/resources/moa/classifiers/meta/WeightedMajorityAlgorithm.ref
rename to moa/src/test/resources/moa/learners/predictors/meta/WeightedMajorityAlgorithm.ref
index b68426503..ca501574d 100644
--- a/moa/src/test/resources/moa/classifiers/meta/WeightedMajorityAlgorithm.ref
+++ b/moa/src/test/resources/moa/learners/predictors/meta/WeightedMajorityAlgorithm.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.meta.WeightedMajorityAlgorithm
+moa.learners.predictors.meta.WeightedMajorityAlgorithm
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/meta/OzaBag.ref b/moa/src/test/resources/moa/learners/predictors/meta/classifiers/OzaBag.ref
similarity index 77%
rename from moa/src/test/resources/moa/classifiers/meta/OzaBag.ref
rename to moa/src/test/resources/moa/learners/predictors/meta/classifiers/OzaBag.ref
index 56f9c0788..31809483c 100644
--- a/moa/src/test/resources/moa/classifiers/meta/OzaBag.ref
+++ b/moa/src/test/resources/moa/learners/predictors/meta/classifiers/OzaBag.ref
@@ -1,17 +1,17 @@
 --> classification-out0.arff
-moa.classifiers.meta.OzaBag
+moa.learners.predictors.meta.classifiers.OzaBag
 
 Index
   10000
 Votes
-  0: 8.05910059
-  1: 1.94089941
+  0: 0
+  1: 0
 Measurements
   classified instances: 9999
-  classifications correct (percent): 81.73817382
-  Kappa Statistic (percent): 61.49714818
-  Kappa Temporal Statistic (percent): 61.50927487
-  Kappa M Statistic (percent): 55.40903541
+  classifications correct (percent): 40.95409541
+  Kappa Statistic (percent): 0
+  Kappa Temporal Statistic (percent): -24.45193929
+  Kappa M Statistic (percent): -44.17582418
 Model measurements
   model training instances: 9999
   ensemble size: 10
@@ -35,14 +35,14 @@ Model measurements
 Index
   20000
 Votes
-  0: 1.01860009
-  1: 8.98139991
+  0: 0
+  1: 0
 Measurements
   classified instances: 19999
-  classifications correct (percent): 84.36421821
-  Kappa Statistic (percent): 67.44374263
-  Kappa Temporal Statistic (percent): 67.35567387
-  Kappa M Statistic (percent): 62.51498442
+  classifications correct (percent): 41.7120856
+  Kappa Statistic (percent): 0
+  Kappa Temporal Statistic (percent): -21.6932874
+  Kappa M Statistic (percent): -39.73867178
 Model measurements
   model training instances: 19999
   ensemble size: 10
@@ -66,14 +66,14 @@ Model measurements
 Index
   30000
 Votes
-  0: 0.01405849
-  1: 9.98594151
+  0: 0
+  1: 0
 Measurements
   classified instances: 29999
-  classifications correct (percent): 85.97286576
-  Kappa Statistic (percent): 70.84723817
-  Kappa Temporal Statistic (percent): 70.93320439
-  Kappa M Statistic (percent): 66.30365151
+  classifications correct (percent): 41.62805427
+  Kappa Statistic (percent): 0
+  Kappa Temporal Statistic (percent): -20.95738067
+  Kappa M Statistic (percent): -40.22261371
 Model measurements
   model training instances: 29999
   ensemble size: 10
@@ -97,14 +97,14 @@ Model measurements
 Index
   40000
 Votes
-  0: 0.61385275
-  1: 9.38614725
+  0: 0
+  1: 0
 Measurements
   classified instances: 39999
-  classifications correct (percent): 86.7721693
-  Kappa Statistic (percent): 72.57926888
-  Kappa Temporal Statistic (percent): 72.65774379
-  Kappa M Statistic (percent): 68.35526316
+  classifications correct (percent): 41.80104503
+  Kappa Statistic (percent): 0
+  Kappa Temporal Statistic (percent): -20.29869257
+  Kappa M Statistic (percent): -39.2284689
 Model measurements
   model training instances: 39999
   ensemble size: 10
@@ -128,14 +128,14 @@ Model measurements
 Index
   50000
 Votes
-  0: 6.75079178
-  1: 3.24920822
+  0: 0
+  1: 0
 Measurements
   classified instances: 49999
-  classifications correct (percent): 87.39774795
-  Kappa Statistic (percent): 73.90124952
-  Kappa Temporal Statistic (percent): 73.91754284
-  Kappa M Statistic (percent): 69.84590352
+  classifications correct (percent): 41.79283586
+  Kappa Statistic (percent): 0
+  Kappa Temporal Statistic (percent): -20.46940972
+  Kappa M Statistic (percent): -39.27545942
 Model measurements
   model training instances: 49999
   ensemble size: 10
@@ -159,14 +159,14 @@ Model measurements
 Index
   60000
 Votes
-  0: 0.00297407
-  1: 9.99702593
+  0: 0
+  1: 0
 Measurements
   classified instances: 59999
-  classifications correct (percent): 87.96313272
-  Kappa Statistic (percent): 75.13090877
-  Kappa Temporal Statistic (percent): 75.10942616
-  Kappa M Statistic (percent): 71.34354416
+  classifications correct (percent): 42.0040334
+  Kappa Statistic (percent): 0
+  Kappa Temporal Statistic (percent): -19.92762364
+  Kappa M Statistic (percent): -38.07237521
 Model measurements
   model training instances: 59999
   ensemble size: 10
@@ -190,14 +190,14 @@ Model measurements
 Index
   70000
 Votes
-  0: 0.18695406
-  1: 9.81304594
+  0: 0
+  1: 0
 Measurements
   classified instances: 69999
-  classifications correct (percent): 88.36554808
-  Kappa Statistic (percent): 75.99851798
-  Kappa Temporal Statistic (percent): 76.01813952
-  Kappa M Statistic (percent): 72.39696312
+  classifications correct (percent): 42.14917356
+  Kappa Statistic (percent): 0
+  Kappa Temporal Statistic (percent): -19.24673871
+  Kappa M Statistic (percent): -37.25257592
 Model measurements
   model training instances: 69999
   ensemble size: 10
@@ -221,14 +221,14 @@ Model measurements
 Index
   80000
 Votes
-  0: 0.21629667
-  1: 9.78370333
+  0: 0
+  1: 0
 Measurements
   classified instances: 79999
-  classifications correct (percent): 88.73985925
-  Kappa Statistic (percent): 76.78183907
-  Kappa Temporal Statistic (percent): 76.81278797
-  Kappa M Statistic (percent): 73.28271444
+  classifications correct (percent): 42.14552682
+  Kappa Statistic (percent): 0
+  Kappa Temporal Statistic (percent): -19.13562769
+  Kappa M Statistic (percent): -37.27310476
 Model measurements
   model training instances: 79999
   ensemble size: 10
@@ -252,14 +252,14 @@ Model measurements
 Index
   90000
 Votes
-  0: 0.02339952
-  1: 9.97660048
+  0: 0
+  1: 0
 Measurements
   classified instances: 89999
-  classifications correct (percent): 89.04210047
-  Kappa Statistic (percent): 77.41497444
-  Kappa Temporal Statistic (percent): 77.42474534
-  Kappa M Statistic (percent): 73.99261603
+  classifications correct (percent): 42.13380149
+  Kappa Statistic (percent): 0
+  Kappa Temporal Statistic (percent): -19.21483347
+  Kappa M Statistic (percent): -37.33913502
 Model measurements
   model training instances: 89999
   ensemble size: 10
@@ -283,14 +283,14 @@ Model measurements
 Index
   100000
 Votes
-  0: 8.56422451
-  1: 1.43577549
+  0: 0
+  1: 0
 Measurements
   classified instances: 99999
-  classifications correct (percent): 89.34689347
-  Kappa Statistic (percent): 78.05429949
-  Kappa Temporal Statistic (percent): 78.05496045
-  Kappa M Statistic (percent): 74.74515196
+  classifications correct (percent): 42.18242182
+  Kappa Statistic (percent): 0
+  Kappa Temporal Statistic (percent): -19.10225775
+  Kappa M Statistic (percent): -37.06557299
 Model measurements
   model training instances: 99999
   ensemble size: 10
diff --git a/moa/src/test/resources/moa/classifiers/meta/OzaBagAdwinClassification.ref b/moa/src/test/resources/moa/learners/predictors/meta/classifiers/OzaBagAdwin.ref
similarity index 99%
rename from moa/src/test/resources/moa/classifiers/meta/OzaBagAdwinClassification.ref
rename to moa/src/test/resources/moa/learners/predictors/meta/classifiers/OzaBagAdwin.ref
index 87a31d8fc..b5243a729 100644
--- a/moa/src/test/resources/moa/classifiers/meta/OzaBagAdwinClassification.ref
+++ b/moa/src/test/resources/moa/learners/predictors/meta/classifiers/OzaBagAdwin.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.meta.OzaBagAdwinClassification
+moa.learners.predictors.meta.classifiers.OzaBagAdwin
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/meta/OzaBoost.ref b/moa/src/test/resources/moa/learners/predictors/meta/classifiers/OzaBoost.ref
similarity index 99%
rename from moa/src/test/resources/moa/classifiers/meta/OzaBoost.ref
rename to moa/src/test/resources/moa/learners/predictors/meta/classifiers/OzaBoost.ref
index 473ef4971..db45aafea 100644
--- a/moa/src/test/resources/moa/classifiers/meta/OzaBoost.ref
+++ b/moa/src/test/resources/moa/learners/predictors/meta/classifiers/OzaBoost.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.meta.OzaBoost
+moa.learners.predictors.meta.classifiers.OzaBoost
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/learners/predictors/rules/AMRulesMultiTargetRegressorSemiSuper.ref b/moa/src/test/resources/moa/learners/predictors/rules/AMRulesMultiTargetRegressorSemiSuper.ref
new file mode 100644
index 000000000..23d0910db
--- /dev/null
+++ b/moa/src/test/resources/moa/learners/predictors/rules/AMRulesMultiTargetRegressorSemiSuper.ref
@@ -0,0 +1,185 @@
+--> regression-out0.arff
+moa.learners.predictors.rules.AMRulesMultiTargetRegressorSemiSuper -L (core.structuredoutput.functions.AdaptiveMultiTargetRegressor -l MultiTargetMeanRegressor -m MultiTargetPerceptronRegressor -e MeanAbsoluteDeviationMT) -A (OddsRatioScore -p CantellisInequality) -S MultiTargetVarianceRatio -e RelativeMeanAbsoluteDeviationMT -w InverseErrorWeightedVoteMultiLabel -O SelectAllOutputs -I SelectAllInputs -F NoFeatureRanking
+
+Index
+  100
+Votes
+  0: 55948.38383838
+Measurements
+  classified instances: 99
+  mean absolute error: 34628.12606101
+  root mean squared error: 65078.43264825
+  relative mean absolute error: 0.99543676
+  relative root mean squared error: 1.0011017
+Model measurements
+  model training instances: 99
+  anomaly detections: 0
+  change detections: 0
+  rules (number): 1
+  Avg #inputs/rule: 8
+  Avg #outputs/rule: 1
+
+Index
+  200
+Votes
+  0: 47263.67336683
+Measurements
+  classified instances: 199
+  mean absolute error: 31761.42175101
+  root mean squared error: 52002.95041982
+  relative mean absolute error: 0.99527538
+  relative root mean squared error: 1.00026386
+Model measurements
+  model training instances: 199
+  anomaly detections: 0
+  change detections: 0
+  rules (number): 1
+  Avg #inputs/rule: 8
+  Avg #outputs/rule: 1
+
+Index
+  300
+Votes
+  0: 48188.16053512
+Measurements
+  classified instances: 299
+  mean absolute error: 30623.01794139
+  root mean squared error: 50319.68756534
+  relative mean absolute error: 0.99626926
+  relative root mean squared error: 1.00022782
+Model measurements
+  model training instances: 299
+  anomaly detections: 0
+  change detections: 0
+  rules (number): 1
+  Avg #inputs/rule: 8
+  Avg #outputs/rule: 1
+
+Index
+  400
+Votes
+  0: 50652.7593985
+Measurements
+  classified instances: 399
+  mean absolute error: 32412.18603515
+  root mean squared error: 53631.70236175
+  relative mean absolute error: 0.99711731
+  relative root mean squared error: 1.00022202
+Model measurements
+  model training instances: 399
+  anomaly detections: 0
+  change detections: 0
+  rules (number): 1
+  Avg #inputs/rule: 8
+  Avg #outputs/rule: 1
+
+Index
+  500
+Votes
+  0: 49999.08016032
+Measurements
+  classified instances: 499
+  mean absolute error: 31780.53748788
+  root mean squared error: 51341.07280009
+  relative mean absolute error: 0.99740552
+  relative root mean squared error: 1.00017633
+Model measurements
+  model training instances: 499
+  anomaly detections: 0
+  change detections: 0
+  rules (number): 1
+  Avg #inputs/rule: 8
+  Avg #outputs/rule: 1
+
+Index
+  600
+Votes
+  0: 49752.29549249
+Measurements
+  classified instances: 599
+  mean absolute error: 31672.03154081
+  root mean squared error: 52436.59832602
+  relative mean absolute error: 0.99767043
+  relative root mean squared error: 1.00013548
+Model measurements
+  model training instances: 599
+  anomaly detections: 0
+  change detections: 0
+  rules (number): 1
+  Avg #inputs/rule: 8
+  Avg #outputs/rule: 1
+
+Index
+  700
+Votes
+  0: 49530.49356223
+Measurements
+  classified instances: 699
+  mean absolute error: 31383.15192748
+  root mean squared error: 50807.58656296
+  relative mean absolute error: 0.99790537
+  relative root mean squared error: 1.00011915
+Model measurements
+  model training instances: 699
+  anomaly detections: 0
+  change detections: 0
+  rules (number): 1
+  Avg #inputs/rule: 8
+  Avg #outputs/rule: 1
+
+Index
+  800
+Votes
+  0: 49380.97747184
+Measurements
+  classified instances: 799
+  mean absolute error: 31455.44072913
+  root mean squared error: 50331.41633995
+  relative mean absolute error: 0.99808753
+  relative root mean squared error: 1.00010398
+Model measurements
+  model training instances: 799
+  anomaly detections: 0
+  change detections: 0
+  rules (number): 1
+  Avg #inputs/rule: 8
+  Avg #outputs/rule: 1
+
+Index
+  900
+Votes
+  0: 48703.32480534
+Measurements
+  classified instances: 899
+  mean absolute error: 30922.61187338
+  root mean squared error: 48815.54573427
+  relative mean absolute error: 0.9982044
+  relative root mean squared error: 1.00008741
+Model measurements
+  model training instances: 899
+  anomaly detections: 0
+  change detections: 0
+  rules (number): 1
+  Avg #inputs/rule: 8
+  Avg #outputs/rule: 1
+
+Index
+  1000
+Votes
+  0: 48543.00900901
+Measurements
+  classified instances: 999
+  mean absolute error: 31008.88719526
+  root mean squared error: 48555.27694969
+  relative mean absolute error: 0.99833161
+  relative root mean squared error: 1.00007689
+Model measurements
+  model training instances: 999
+  anomaly detections: 0
+  change detections: 0
+  rules (number): 1
+  Avg #inputs/rule: 8
+  Avg #outputs/rule: 1
+
+
+
diff --git a/moa/src/test/resources/moa/learners/predictors/rules/AMRulesRegressor.ref b/moa/src/test/resources/moa/learners/predictors/rules/AMRulesRegressor.ref
new file mode 100644
index 000000000..dc9e5f058
--- /dev/null
+++ b/moa/src/test/resources/moa/learners/predictors/rules/AMRulesRegressor.ref
@@ -0,0 +1,195 @@
+--> regression-out0.arff
+moa.learners.predictors.meta.RegressionViaMTR -c (rules.AMRulesMultiTargetRegressor -L (core.structuredoutput.functions.AdaptiveMultiTargetRegressor -l MultiTargetMeanRegressor -m MultiTargetPerceptronRegressor -e MeanAbsoluteDeviationMT) -A (OddsRatioScore -p CantellisInequality) -S MultiTargetVarianceRatio -e RelativeMeanAbsoluteDeviationMT -w InverseErrorWeightedVoteMultiLabel -O SelectAllOutputs -I SelectAllInputs -F NoFeatureRanking)
+
+Index
+  100
+Votes
+  0: 55948.38383838
+Measurements
+  classified instances: 99
+  mean absolute error: 34628.12606101
+  root mean squared error: 65078.43264825
+  relative mean absolute error: 0.99543676
+  relative root mean squared error: 1.0011017
+Model measurements
+  model training instances: 99
+  model training instances: 99
+  anomaly detections: 0
+  change detections: 0
+  rules (number): 1
+  Avg #inputs/rule: 8
+  Avg #outputs/rule: 1
+
+Index
+  200
+Votes
+  0: 47263.67336683
+Measurements
+  classified instances: 199
+  mean absolute error: 31761.42175101
+  root mean squared error: 52002.95041982
+  relative mean absolute error: 0.99527538
+  relative root mean squared error: 1.00026386
+Model measurements
+  model training instances: 199
+  model training instances: 199
+  anomaly detections: 0
+  change detections: 0
+  rules (number): 1
+  Avg #inputs/rule: 8
+  Avg #outputs/rule: 1
+
+Index
+  300
+Votes
+  0: 48188.16053512
+Measurements
+  classified instances: 299
+  mean absolute error: 30623.01794139
+  root mean squared error: 50319.68756534
+  relative mean absolute error: 0.99626926
+  relative root mean squared error: 1.00022782
+Model measurements
+  model training instances: 299
+  model training instances: 299
+  anomaly detections: 0
+  change detections: 0
+  rules (number): 1
+  Avg #inputs/rule: 8
+  Avg #outputs/rule: 1
+
+Index
+  400
+Votes
+  0: 50652.7593985
+Measurements
+  classified instances: 399
+  mean absolute error: 32412.18603515
+  root mean squared error: 53631.70236175
+  relative mean absolute error: 0.99711731
+  relative root mean squared error: 1.00022202
+Model measurements
+  model training instances: 399
+  model training instances: 399
+  anomaly detections: 0
+  change detections: 0
+  rules (number): 1
+  Avg #inputs/rule: 8
+  Avg #outputs/rule: 1
+
+Index
+  500
+Votes
+  0: 49999.08016032
+Measurements
+  classified instances: 499
+  mean absolute error: 31780.53748788
+  root mean squared error: 51341.07280009
+  relative mean absolute error: 0.99740552
+  relative root mean squared error: 1.00017633
+Model measurements
+  model training instances: 499
+  model training instances: 499
+  anomaly detections: 0
+  change detections: 0
+  rules (number): 1
+  Avg #inputs/rule: 8
+  Avg #outputs/rule: 1
+
+Index
+  600
+Votes
+  0: 49752.29549249
+Measurements
+  classified instances: 599
+  mean absolute error: 31672.03154081
+  root mean squared error: 52436.59832602
+  relative mean absolute error: 0.99767043
+  relative root mean squared error: 1.00013548
+Model measurements
+  model training instances: 599
+  model training instances: 599
+  anomaly detections: 0
+  change detections: 0
+  rules (number): 1
+  Avg #inputs/rule: 8
+  Avg #outputs/rule: 1
+
+Index
+  700
+Votes
+  0: 49530.49356223
+Measurements
+  classified instances: 699
+  mean absolute error: 31383.15192748
+  root mean squared error: 50807.58656296
+  relative mean absolute error: 0.99790537
+  relative root mean squared error: 1.00011915
+Model measurements
+  model training instances: 699
+  model training instances: 699
+  anomaly detections: 0
+  change detections: 0
+  rules (number): 1
+  Avg #inputs/rule: 8
+  Avg #outputs/rule: 1
+
+Index
+  800
+Votes
+  0: 49380.97747184
+Measurements
+  classified instances: 799
+  mean absolute error: 31455.44072913
+  root mean squared error: 50331.41633995
+  relative mean absolute error: 0.99808753
+  relative root mean squared error: 1.00010398
+Model measurements
+  model training instances: 799
+  model training instances: 799
+  anomaly detections: 0
+  change detections: 0
+  rules (number): 1
+  Avg #inputs/rule: 8
+  Avg #outputs/rule: 1
+
+Index
+  900
+Votes
+  0: 48703.32480534
+Measurements
+  classified instances: 899
+  mean absolute error: 30922.61187338
+  root mean squared error: 48815.54573427
+  relative mean absolute error: 0.9982044
+  relative root mean squared error: 1.00008741
+Model measurements
+  model training instances: 899
+  model training instances: 899
+  anomaly detections: 0
+  change detections: 0
+  rules (number): 1
+  Avg #inputs/rule: 8
+  Avg #outputs/rule: 1
+
+Index
+  1000
+Votes
+  0: 48543.00900901
+Measurements
+  classified instances: 999
+  mean absolute error: 31008.88719526
+  root mean squared error: 48555.27694969
+  relative mean absolute error: 0.99833161
+  relative root mean squared error: 1.00007689
+Model measurements
+  model training instances: 999
+  model training instances: 999
+  anomaly detections: 0
+  change detections: 0
+  rules (number): 1
+  Avg #inputs/rule: 8
+  Avg #outputs/rule: 1
+
+
+
diff --git a/moa/src/test/resources/moa/classifiers/rules/RuleClassifier.ref b/moa/src/test/resources/moa/learners/predictors/rules/RuleClassifier.ref
similarity index 98%
rename from moa/src/test/resources/moa/classifiers/rules/RuleClassifier.ref
rename to moa/src/test/resources/moa/learners/predictors/rules/RuleClassifier.ref
index 1f188b60c..fd576a713 100644
--- a/moa/src/test/resources/moa/classifiers/rules/RuleClassifier.ref
+++ b/moa/src/test/resources/moa/learners/predictors/rules/RuleClassifier.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.rules.RuleClassifier
+moa.learners.predictors.rules.RuleClassifier
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/rules/RuleClassifierNBayes.ref b/moa/src/test/resources/moa/learners/predictors/rules/RuleClassifierNBayes.ref
similarity index 98%
rename from moa/src/test/resources/moa/classifiers/rules/RuleClassifierNBayes.ref
rename to moa/src/test/resources/moa/learners/predictors/rules/RuleClassifierNBayes.ref
index 32b59991e..ea09cb2f7 100644
--- a/moa/src/test/resources/moa/classifiers/rules/RuleClassifierNBayes.ref
+++ b/moa/src/test/resources/moa/learners/predictors/rules/RuleClassifierNBayes.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.rules.RuleClassifierNBayes
+moa.learners.predictors.rules.RuleClassifierNBayes
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/trees/ASHoeffdingTree.ref b/moa/src/test/resources/moa/learners/predictors/trees/ASHoeffdingTree.ref
similarity index 99%
rename from moa/src/test/resources/moa/classifiers/trees/ASHoeffdingTree.ref
rename to moa/src/test/resources/moa/learners/predictors/trees/ASHoeffdingTree.ref
index 5db3bd8bd..bc6910f5c 100644
--- a/moa/src/test/resources/moa/classifiers/trees/ASHoeffdingTree.ref
+++ b/moa/src/test/resources/moa/learners/predictors/trees/ASHoeffdingTree.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.trees.ASHoeffdingTree
+moa.learners.predictors.trees.ASHoeffdingTree
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/trees/AdaHoeffdingOptionTree.ref b/moa/src/test/resources/moa/learners/predictors/trees/AdaHoeffdingOptionTree.ref
similarity index 99%
rename from moa/src/test/resources/moa/classifiers/trees/AdaHoeffdingOptionTree.ref
rename to moa/src/test/resources/moa/learners/predictors/trees/AdaHoeffdingOptionTree.ref
index 37c4259c5..dabfe4623 100644
--- a/moa/src/test/resources/moa/classifiers/trees/AdaHoeffdingOptionTree.ref
+++ b/moa/src/test/resources/moa/learners/predictors/trees/AdaHoeffdingOptionTree.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.trees.AdaHoeffdingOptionTree
+moa.learners.predictors.trees.AdaHoeffdingOptionTree
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/trees/DecisionStump.ref b/moa/src/test/resources/moa/learners/predictors/trees/DecisionStump.ref
similarity index 98%
rename from moa/src/test/resources/moa/classifiers/trees/DecisionStump.ref
rename to moa/src/test/resources/moa/learners/predictors/trees/DecisionStump.ref
index 3e2e6c1a4..83678cc25 100644
--- a/moa/src/test/resources/moa/classifiers/trees/DecisionStump.ref
+++ b/moa/src/test/resources/moa/learners/predictors/trees/DecisionStump.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.trees.DecisionStump
+moa.learners.predictors.trees.DecisionStump
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/trees/EFDT.ref b/moa/src/test/resources/moa/learners/predictors/trees/EFDT.ref
similarity index 99%
rename from moa/src/test/resources/moa/classifiers/trees/EFDT.ref
rename to moa/src/test/resources/moa/learners/predictors/trees/EFDT.ref
index 7185f074a..dd7dddae7 100644
--- a/moa/src/test/resources/moa/classifiers/trees/EFDT.ref
+++ b/moa/src/test/resources/moa/learners/predictors/trees/EFDT.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.trees.EFDT
+moa.learners.predictors.trees.EFDT
 
 Index
   10000
@@ -224,7 +224,7 @@ Model measurements
 
 
 --> classification-out1.arff
-moa.classifiers.trees.EFDT -t 0.2
+moa.learners.predictors.trees.EFDT -t 0.2
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/trees/FIMTDD.ref b/moa/src/test/resources/moa/learners/predictors/trees/FIMTDD.ref
similarity index 98%
rename from moa/src/test/resources/moa/classifiers/trees/FIMTDD.ref
rename to moa/src/test/resources/moa/learners/predictors/trees/FIMTDD.ref
index 4e54e386f..905073395 100644
--- a/moa/src/test/resources/moa/classifiers/trees/FIMTDD.ref
+++ b/moa/src/test/resources/moa/learners/predictors/trees/FIMTDD.ref
@@ -1,5 +1,5 @@
 --> regression-out0.arff
-moa.classifiers.trees.FIMTDD -s VarianceReductionSplitCriterion
+moa.learners.predictors.trees.FIMTDD
 
 Index
   100
diff --git a/moa/src/test/resources/moa/classifiers/trees/HoeffdingAdaptiveTree.ref b/moa/src/test/resources/moa/learners/predictors/trees/HoeffdingAdaptiveTree.ref
similarity index 99%
rename from moa/src/test/resources/moa/classifiers/trees/HoeffdingAdaptiveTree.ref
rename to moa/src/test/resources/moa/learners/predictors/trees/HoeffdingAdaptiveTree.ref
index 1987533c9..76566f3ed 100644
--- a/moa/src/test/resources/moa/classifiers/trees/HoeffdingAdaptiveTree.ref
+++ b/moa/src/test/resources/moa/learners/predictors/trees/HoeffdingAdaptiveTree.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.trees.HoeffdingAdaptiveTree
+moa.learners.predictors.trees.HoeffdingAdaptiveTree
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/trees/HoeffdingOptionTree.ref b/moa/src/test/resources/moa/learners/predictors/trees/HoeffdingOptionTree.ref
similarity index 99%
rename from moa/src/test/resources/moa/classifiers/trees/HoeffdingOptionTree.ref
rename to moa/src/test/resources/moa/learners/predictors/trees/HoeffdingOptionTree.ref
index e0683b922..2929cffa2 100644
--- a/moa/src/test/resources/moa/classifiers/trees/HoeffdingOptionTree.ref
+++ b/moa/src/test/resources/moa/learners/predictors/trees/HoeffdingOptionTree.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.trees.HoeffdingOptionTree
+moa.learners.predictors.trees.HoeffdingOptionTree
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/trees/HoeffdingTree.ref b/moa/src/test/resources/moa/learners/predictors/trees/HoeffdingTree.ref
similarity index 99%
rename from moa/src/test/resources/moa/classifiers/trees/HoeffdingTree.ref
rename to moa/src/test/resources/moa/learners/predictors/trees/HoeffdingTree.ref
index 3990afbcb..806579fc7 100644
--- a/moa/src/test/resources/moa/classifiers/trees/HoeffdingTree.ref
+++ b/moa/src/test/resources/moa/learners/predictors/trees/HoeffdingTree.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.trees.HoeffdingTree
+moa.learners.predictors.trees.HoeffdingTree
 
 Index
   10000
@@ -214,7 +214,7 @@ Model measurements
 
 
 --> classification-out1.arff
-moa.classifiers.trees.HoeffdingTree -t 0.2
+moa.learners.predictors.trees.HoeffdingTree -t 0.2
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/trees/LimAttHoeffdingTree.ref b/moa/src/test/resources/moa/learners/predictors/trees/LimAttHoeffdingTree.ref
similarity index 99%
rename from moa/src/test/resources/moa/classifiers/trees/LimAttHoeffdingTree.ref
rename to moa/src/test/resources/moa/learners/predictors/trees/LimAttHoeffdingTree.ref
index ff895af0c..61b4dd70d 100644
--- a/moa/src/test/resources/moa/classifiers/trees/LimAttHoeffdingTree.ref
+++ b/moa/src/test/resources/moa/learners/predictors/trees/LimAttHoeffdingTree.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.trees.LimAttHoeffdingTree
+moa.learners.predictors.trees.LimAttHoeffdingTree
 
 Index
   10000
diff --git a/moa/src/test/resources/moa/classifiers/trees/ORTO.ref b/moa/src/test/resources/moa/learners/predictors/trees/ORTO.ref
similarity index 98%
rename from moa/src/test/resources/moa/classifiers/trees/ORTO.ref
rename to moa/src/test/resources/moa/learners/predictors/trees/ORTO.ref
index dbccda5ca..17accd748 100644
--- a/moa/src/test/resources/moa/classifiers/trees/ORTO.ref
+++ b/moa/src/test/resources/moa/learners/predictors/trees/ORTO.ref
@@ -1,5 +1,5 @@
 --> regression-out0.arff
-moa.classifiers.trees.ORTO -s VarianceReductionSplitCriterion
+moa.learners.predictors.trees.ORTO
 
 Index
   100
diff --git a/moa/src/test/resources/moa/classifiers/trees/RandomHoeffdingTree.ref b/moa/src/test/resources/moa/learners/predictors/trees/RandomHoeffdingTree.ref
similarity index 99%
rename from moa/src/test/resources/moa/classifiers/trees/RandomHoeffdingTree.ref
rename to moa/src/test/resources/moa/learners/predictors/trees/RandomHoeffdingTree.ref
index 07cd54071..b9e2de012 100644
--- a/moa/src/test/resources/moa/classifiers/trees/RandomHoeffdingTree.ref
+++ b/moa/src/test/resources/moa/learners/predictors/trees/RandomHoeffdingTree.ref
@@ -1,5 +1,5 @@
 --> classification-out0.arff
-moa.classifiers.trees.RandomHoeffdingTree
+moa.learners.predictors.trees.RandomHoeffdingTree
 
 Index
   10000